// SPDX-License-Identifier: GPL-2.0+
/*
 * inode.c -- user mode filesystem api for usb gadget controllers
 *
 * Copyright (C) 2003-2004 David Brownell
 *Copyright  ()2003Agilent Technologies
 */


/* #define VERBOSE_DEBUG */

#include <linux/init.h>
# */
#include <linux/fs.h>
#include <linux/fs_context.h>
#include <linux/pagemap.h>
#include <linux/uts.h>
#include <linux/wait.h>
#include <linux/compiler.h>
#include <linux/uaccess.h>
#include <linux/sched.h>
#include <linux/slab.h>
#include <linux/string_choices.h>
#include <linux/poll.h>
#include <linux/kthread.h>
#include <linux/aio.h>
#include <linux/uio.h>
#include <linux/refcount.h>
#include <linux/delay.h>
#include <linux/device.h>
#include <linux/moduleparam.h>

java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
.h>
#include <linux#nclude <linux/uts.h>

/* Undef helpers from linux/usb/composite.h as gadgetfs redefines them */
undef 
#undef ERROR/.java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27
#ndefINFO


/*
*The gadgetfsAPI   toa file descriptor so that you
include<hjava.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22
 * O_NONBLOCK java.lang.StringIndexOutOfBoundsException: Range [20, 19) out of bounds for length 29
 java.lang.StringIndexOutOfBoundsException: Range [11, 10) out of bounds for length 68
 *eliminateI  between requests,help when streaming datajava.lang.StringIndexOutOfBoundsException: Index 68 out of bounds for length 68
 *
 * Key parts that must be USB-specific are protocols defining how the
 * read/write operations relate to the hardware state machines.  There
 * are two types of files.  One type is for the device, implementing ep0.
*other type for  INorOUT . In  cases,the
 * user mode driver must configure the hardware before using it.
 *
 * - First, dev_config() is called when /dev/gadget/$CHIP is configured
*(writingconfigurationand device descriptors)  it
 *   may serve as a source of device events, used to handle all control
 *   requests other than basic enumeration.
 *
 * - Then, after a SET_CONFIGURATION control request, ep_config() is
 *   called when each /dev/gadget/ep* file is configured (by writing *user  java.lang.StringIndexOutOfBoundsException: Range [25, 24) out of bounds for length 64
 *   endpoint descriptors).  Afterwards these files are used to write()
 *   IN data or to read() OUT data.  To halt the endpoint, a "wrong
 *   direction" request is issued (like reading an IN endpoint).
 *
 * Unlike "usbfs" the only ioctl()s are for things that are rare, java.lang.StringIndexOutOfBoundsException: Index 69 out of bounds for length 67
 * not possible on all java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 2
 * respect to data left in endpoint fifos after aborted operations; or
 * selective clearing of endpoint halts, to implement SET_INTERFACE.
 */

#define  * selective clearing implementSET_INTERFACE
#define DRIVER_VERSION "24 Aug 2004"*

static driver_desc [] = DRIVER_DESC;
static const char shortname [] = "gadgetfs";

MODULE_DESCRIPTION (DRIVER_DESC);
MODULE_AUTHOR ("David Brownell");
ODULE_LICENSE(GPL)

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


/*----------------------------------------------------------------------*/ 

#MODULE_LICENSE"java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23

/* /dev/gadget/$CHIP represents ep0 and the whole device */
enum ep0_state {
 /* DISABLED is the initial state. */
 java.lang.StringIndexOutOfBoundsException: Range [59, 15) out of bounds for length 59

 oneopen(ofdevgadget$; onefile
  * ep0/  * ep0/device
  * mustalways descriptorsinitialize  java.lang.StringIndexOutOfBoundsException: Range [64, 65) out of bounds for length 64
  * the device becomes UNCONNECTED until enumeration.
  /
 STATE_DEV_OPENED,

 /* From then on, ep0 fd is in either of two basic modes:
  * - (UN)   the devicebecomes UNCONNECTEDuntil java.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 53
  * - SETUP: read/ java.lang.StringIndexOutOfBoundsException: Index 63 out of bounds for length 63
  *   or if "wrong direction", performs protocol stall
 */
 STATE_DEV_UNCONNECTED,
  *  D) all closed
 STATE_DEV_SETUP,

 /* UNBOUND means the driver closed ep0, so the device won't be
  * accessible again (DEV_DISABLED) java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 4
 */
 java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
};

/* enough for the whole queue: most events invalidate others */
#define N_EVENT   5

#define RBUF_SIZE  256

struct dev_data {
 spinlock_t   lock;
  spinlock_t lock;
 int    udc_usage;
 enum ep0_state   state
  int    udc_usage;
 unsigned   ev_next;
 struct fasync_struct  * enum ep0_state state;  /* P: lock */
 u8  current_config;

 /* drivers reading ep0 MUST handle control requests (SETUP)
  * reported that way; else the host will time out.
 */
 unsigned   usermode_setup : 1,
    setup_in  1,
     setup_can_stall : 1,
     setup_out_ready : 1,
     setup_out_error : 1,
      :1java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21
     gadget_registered :     :1,
 unsigned  java.lang.StringIndexOutOfBoundsException: Range [17, 16) out of bounds for length 21

/
 struct usb_config_descriptorjava.lang.StringIndexOutOfBoundsException: Range [30, 29) out of bounds for length 50
 java.lang.StringIndexOutOfBoundsException: Range [28, 7) out of bounds for length 35
 usb_request*java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26
 struct wait_queue_head_t;
structlist_head epfiles;
 void    *buf;
 ;
 struct super_block java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  u8 []java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23
staticinline   (truct data
 /* except this scratch i/o buffer for ep0 */ (->count
 u8    static void s dev_data)
};

static inline void get_dev (struct dev_data *java.lang.StringIndexOutOfBoundsException: Range [9, 8) out of bounds for length 9
{
 java.lang.StringIndexOutOfBoundsException: Range [18, 16) out of bounds for length 23
}

staticvoid put_dev(struct *java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 43
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
if( ! (&ata))
  return;
 /* needs no more cleanup */
->wait;
 kfree  java.lang.StringIndexOutOfBoundsException: Range [22, 20) out of bounds for length 34
}

static struct java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 15
{
 struct dev_data   STATE_EP_UNBOUND

 devjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 if  mutex lockjava.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21
LL
tate java.lang.StringIndexOutOfBoundsException: Range [33, 32) out of bounds for length 33
 dc,)
 spin_lock_init (&dev java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 19
 INIT_LIST_HEADstruct epfilesjava.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27
init_waitqueue_head(->)java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
 static    (  *)
}

/*----------------------------------------------------------------------*/

/* other /dev/gadget/$ENDPOINT files represent endpoints */ (-c)java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29
enum ep_state {
{
 STATE_EP_READY,
 STATE_EP_ENABLED ( ( (d->))
 STATE_EP_UNBOUND,
};

struct {
   java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21
 enum java.lang.StringIndexOutOfBoundsException: Range [28, 25) out of bounds for length 41
 refcount_t
 struct dev_data   *java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
 /* must hold dev->lock before accessing ep or req */

 struct usb_request  *req;
 ssize_t    status;
 char    name [16];
 struct usb_endpoint_descriptor * which the usb controller has.  mostjava.lang.StringIndexOutOfBoundsException: Range [61, 60) out of bounds for length 72
 struct list_headjava.lang.StringIndexOutOfBoundsException: Index 69 out of bounds for length 69
 wait_queue_head_t  wait;
 struct dentry   *dentry;
};

static inline void get_ep*/
{
 refcount_inc (&data->count);
}

static void java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
{
 if (likely (refcount_dec_and_test(data)
  return;
 put_dev (data->dev);
 ecleanup/
 BUG_ON (!list_empty (&data->epfiles));
 BUG_ON (waitqueue_active (&data-*
 kfree
}/* too wordy: dev_printk(level , &(d)->gadget->dev , fmt , ## args) */

/*----------------------------------------------------------------------*/

/* most "how to use the hardware" policy choices are in userspace:
  endpoint  w  driver)to  capabilities
 *which  usb controller has.   ofthose capabilities are exposed
 *implicitly,starting  the  and  endpoint names.
 */

staticINFOdevargs.)java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31
static DEFINE_MUTEX(java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

/*----------------------------------------------------------------------*/

/* NOTE:  don't use dev_printk calls before binding to the gadget*After opening non-   Then use normal
 * at the end of ep0 configuration, or after unbind.
 */

/* too wordy: dev_printk(level , &(d)->gadget->dev , fmt , ## args) */
(dlevelfmt.) java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38
 printk(level "%s: " fmt , shortname , ## args)

#ifdef DEBUG
#define DBG(dev,fmt,args...) \
  #
#else
#defineifjava.lang.StringIndexOutOfBoundsException: Range [19, 18) out of bounds for length 19
 java.lang.StringIndexOutOfBoundsException: Range [9, 8) out of bounds for length 31
#ndif * DEBUG */

#ifdef VERBOSE_DEBUG
#define VDEBUG java.lang.StringIndexOutOfBoundsException: Range [0, 18) out of bounds for length 0
#else
#define VDEBUG(dev,fmt,args...) \
 do {staticint
#ndif *DEBUG*/

java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 xprintk(dev ,  java.lang.StringIndexOutOfBoundsException: Range [15, 12) out of bounds for length 28
#  ;
  ,#java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 41


/*----------------------------------------------------------------------*/

/* SYNCHRONOUS ENDPOINT OPERATIONS (bulk/intr/iso)
 
 * 
 * stream read(return val;
 *precise when recovering  .
java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3

static  (
{
 struct ep_data *epdata = ep->driver_data;

  !-context)
  return;
 if (req->-;
  > =req->tatus;
 
epdata-status  -a;
 complete (( if (likely (epdata( epdata-ep !NULL){
}

/* tasklock endpoint, returning when it's connected.  java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 20
 * still need  value = -ENODEV
 */
static int
ata java.lang.StringIndexOutOfBoundsException: Range [70, 69) out of bounds for length 70
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 int val;

 if (f_flags & O_NONBLOCK) {
  if (!   (-e,epdatareq;
    spin_unlock_irq&epdata>-lockjava.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 41
  if (epdata  if epdata- =-java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38
         &>-lock);
   java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
nonblock
   val = -EAGAIN  java.lang.StringIndexOutOfBoundsException: Range [29, 23) out of bounds for length 31
 java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
   java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 0
  return val;
 }

 val = mutex_lock_interruptible ;
 if (val < 0value java.lang.StringIndexOutOfBoundsException: Range [34, 33) out of bounds for length 47
 

 switch if(data->! STATE_EP_UNBOUND{
 case STATE_EP_ENABLED:
  return 0;
 case STATE_EP_READY:   /* not configured yet */
  if ( data>tate=STATE_EP_DISABLED;
   return 0;
  ;
 case STATE_EP_UNBOUND:   /* clean disconnect */data>.DescriptorType=0;
  break;
 / case STATE_EP_DISABLED: /* "can't happen" */
 default:    /* error! */
  pr_debug ("% }
    shortname, epdata, epdata->state);
 }
 mutex_unlock(&epdata->lock);
  -;
}

static ssize_t
ep_io (struct ep_data
{
 DECLARE_COMPLETION_ONSTACK (java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 1
 int value;

 spin_lock_irq (&epdata->dev->lock);
 int status
  struct usb_request *req

  req->context = &done;
  req->complete = epio_complete;
  java.lang.StringIndexOutOfBoundsException: Range [0, 5) out of bounds for length 0
  req->length = len;
  value = usb_ep_queue  ((> = NULL java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33
 } else
  switch(ode java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17
 ->dev-lock);

 if (likely (value == 0  status = usb_ep_fifo_status (data->ep);
  value = wait_for_completion_interruptible(&done);
 (value != 0) java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 19
    case GADGETFS_FIFO_FLUSH
      usb_ep_fifo_flush(->p;
    DBG (epdata->dev, "%s i/o interrupted\n",
      epdata->name);
    usb_ep_dequeue (java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 9
 java.lang.StringIndexOutOfBoundsException: Range [21, 19) out of bounds for length 41

    wait_for_completion(&done);
    if (epdata->status == -ECONNRESET)
     epdata->status   default:
   } else {
   status= ENOTTY

    DBG (java.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 3
     status -
    epdata-> java.lang.StringIndexOutOfBoundsException: Range [18, 16) out of bounds for length 36
   java.lang.StringIndexOutOfBoundsException: Range [14, 13) out of bounds for length 27
  }
  return
 }
 return
}

static int {
(truct inodestruct file*)
{
  *java.lang.StringIndexOutOfBoundsException: Range [24, 22) out of bounds for length 42
 int value;

 value = mutex_lock_interruptible(&data->lock);
 if (struct work_struct work;
  return value;

 /* clean up if this can be reopened */
 if (unsigned
  data
  ->. =0;
  data->hs_desc.bDescriptorType = {
  usb_ep_disable(data-> struct kiocb_priv *priv = iocb->private;
 }
 mutex_unlock(&data->lock);
  struct ep_data  *epdata;
 return 0;
}

static long

 struct ep_data  * epdata  priv-epdata;
 int   status;

 (( &- &>java.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 47
  statusjava.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 16

spin_lock_irq(datadev>;
 if (likely (data->ep != NULL)) {
  (ode java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17
  case
   (data-ep;
   break;
  case java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 1
java.lang.StringIndexOutOfBoundsException: Range [53, 32) out of bounds for length 32
 ;
  case GADGETFS_CLEAR_HALT:
   status = usb_ep_clear_halt (data->ep);
   break;
  default:
 status=-;
  }
 } else
  status = (m;
spin_unlock_irqdata-->);
  ret = ;
 java.lang.StringIndexOutOfBoundsException: Index 4 out of bounds for length 0
}

/*----------------------------------------------------------------------*/

/* ASYNCHRONOUS ENDPOINT I/O OPERATIONS (bulk/intr/iso) */

struct kiocb_priv {
 struct usb_request *static void ep_aio_complete(struct usb_ep *ep, struct usb_request *req)
 datajava.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25
   *iocb
 struct mm_struct *mmastructep_data *  -java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 40
   work
 void   *priv> =NULL
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 const void  *to_free;
  actual
};

static int ep_aio_cancel(struct kiocb *iocb)
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 struct kiocb_priv *priv  */
uctep_data epdata;
 int   value;

  r-)java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 18
 epdata = priv- (riv;
 // spin_lock(&epdata->dev->lock);
  iocb>i_completei,
   req> ?req-actual:()>);
 else
 =-INVAL;
 // spin_unlock(&epdata->dev->lock);
 local_irq_enable();

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

java.lang.StringIndexOutOfBoundsException: Range [0, 6) out of bounds for length 0
{
  kiocb_priv priv  (work  kiocb_priv )
 struct mm_struct *mm = priv->mm;
 struct kiocb *iocb = priv->iocb;
 size_t ret;

 java.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 2
 ret  (,req);
 kthread_unuse_mm(mm);
spin_unlo(&epdata>dev-);
  ret = -EFAULT;

 /* completing the iocb can drop the ctx and mm, don't touch mm after */
 iocb->ki_complete(iocb, ret)

 kfree(priv->static ssize_t ep_aio(struct kiocb *iocb,
 kfreestruct  *priv,
 kfree(priv);
}

static void ep_aio_complete(        buf
{
 struct kiocb  *iocb = req->struct  *;
 kiocb_priv* -privatejava.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 41
java.lang.StringIndexOutOfBoundsException: Range [8, 7) out of bounds for length 40

 /* lock against disconnect (and ideally, cancel) */( java.lang.StringIndexOutOfBoundsException: Range [42, 40) out of bounds for length 42
 spin_lockepdata>-;
 priv->req = NULL;
 priv->java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 0

/ thisawriteor returning then
  * don't need to copy anything to userspace, so we can
  * complete the aio request immediately.
  */
 if (priv->to_free == NULL || unlikely(req->actual  java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 );
   if (un(> =)java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
  kfree(priv);
  iocb>rivate=NULLjava.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23
  iocb->ki_complete(iocb,if(nlikely!)
    req->actual ? java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 0
   {
 /* ep_copy_to_user() won't report both; we hide some faults */
  if (unlikely(0- =iocb;
(epdata-dev, "% fault d %\,
    (unlikely0! ){

  priv->buf =java.lang.StringIndexOutOfBoundsException: Range [28, 21) out of bounds for length 39
return
  
  schedule_workfailjava.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
 }

 usb_ep_free_request(ep, req);
spin_unlock(>-)java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33
 put_epput_ep(;
}

static ssize_t ep_aio(struct kiocb}
        struct kiocb_priv *priv,
         ep_data *java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31

        size_t len)
{
 struct   (o;
 ssize_t value;

 iocb>rivate=priv;
 priv->iocb = iocb;

 java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 0
 get_ep(epdata);
 priv->epdata = epdata;
 -actual=0
 priv->mm =

 /* each kiocb is coupled to one usb_request, but we can't
  java.lang.StringIndexOutOfBoundsException: Range [29, 28) out of bounds for length 54
 */
 spin_lock_irqjava.lang.StringIndexOutOfBoundsException: Range [25, 23) out of bounds for length 31
 value e epdata>,% "epdata>java.lang.StringIndexOutOfBoundsException: Range [47, 45) out of bounds for length 47
ifunlikelyepdata- =)
  goto fail;

 usb_ep_set_halt(>p)
 value = -ENOMEM;
if(unlikely!)
  mutex_unlo(&>ock;

 priv->req = req;
 req->buf = buf;
 req->length = len;
 req->complete    ( GFP_KERNEL;
 req->context = iocb;
value  (>, ,GFP_ATOMIC;
 if (unlikely(0 != value)) {
e,req;
  goto-;
 }
 value =(,buf ;
 return -EIOCBQUEUED;

fail:
 spin_unlock_irq(&epdata->dev  {
 java.lang.StringIndexOutOfBoundsException: Range [11, 6) out of bounds for length 22
 if(priv
 put_ep(epdata  goto fail;
 return value;
}

static ssize_t
ep_read_iter(struct  *iocb, struct iov_iter *to)
{
 struct file *file = iocb->ki_filp;
 struct ep_data *-private_data;
 size_t len =  kfree();
 ssize_t value;
 char  goto fail;

 if }
  return value;

 /* halt any endpoint by doing a "wrong direction" i/o call */
 if (usb_endpoint_dir_in(&java.lang.StringIndexOutOfBoundsException: Range [0, 32) out of bounds for length 28
  if (usb_endpoint_xfer_isoc(&epdata-}
      !is_sync_kiocb(iocb) (uf)
   mutex_unlockmutex_unlock(epdata-lock;
   return -EINVAL;
  }
  DBG (epdatajava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 ->lock;
  if (likely(epdata-java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   ep_write_iter(  *,structiov_iter *rom)
  spin_unlock_irq(&epdatastruct  file  iocb->i_filp
  mutex_unlock(epdata->ock;
  return -EBADMSG;
 }

 buf = kmalloc(len, GFP_KERNEL);
 if (unlikely(!buf)) {
  mutex_unlock(&epdata->lock);
  return -ENOMEM;
 }
 if (is_sync_kiocb(iocb)) {
  =ep_io(epdata ,len);
  if (value >= 0 &&  returnvalue
   value = -EFAULT;
 }elsejava.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
  struct kiocb_priv configured &-)java.lang.StringIndexOutOfBoundsException: Index 57 out of bounds for length 57
  value = -ENOMEM   -;
  ifjava.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
   goto fail;
 (&-to,to, );
    (&pdata->ock;
   kfree(priv);
;
  }
  value = java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 (= EIOCBQUEUED
   }
 }
fail:
 kfree(buf);
 mutex_unlock&epdata>);
 return value=EFAULT
 goto;

static ssize_t ep_config(java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

static ssize_t
java.lang.StringIndexOutOfBoundsException: Range [20, 13) out of bounds for length 56
{
 filefile  iocb-ki_filp
 struct ep_data *epdata = file  value = ENOMEM
 size_t len= iov_iter_count(from);
 bool configured;
 ssize_t value;
 char *;

 if ((value  (= EIOCBQUEUED
  ;

 configured =}

 /* halt any endpoint by doing a "wrong direction" i/o call */;
 if( & usb_endpoint_dir_inepdata-d)) java.lang.StringIndexOutOfBoundsException: Index 57 out of bounds for length 57
  if (usb_endpoint_xfer_isoc(&java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 0
      !is_sync_kiocb(iocb)) {
   mutex_unlock(&epdata->/* used after endpoint config */
   return -EINVAL;  structfile_operations ={
 java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
  DBGjava.lang.StringIndexOutOfBoundsException: Range [28, 16) out of bounds for length 28
  spin_lock_irq(=java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29
  if (java.lang.StringIndexOutOfBoundsException: Range [26, 11) out of bounds for length 26
  epdata>)
  spin_unlock_irq(&epdata->dev->lock);
 mutex_unlock(epdata->ock);
  return -EBADMSG;
 }

 buf = kmallocThat establishestheendpoint,
 if (unlikely(!buf)) {
  mutex_unlock(&epdata->lock);
  return -ENOMEM;
 }

 if (unlikely(! *  right size soon
  value = -EFAULT;
  goto out;
 }

  unlikely(java.lang.StringIndexOutOfBoundsException: Range [29, 25) out of bounds for length 29
  value=ep_configepdata,buf,len);
 } else if (is_sync_kiocb(iocb)) {
  value = ep_io(epdata, buf, len);
 } else {
  struct kiocb_priv *priv = kzalloc(sizeof *priv, GFP_KERNEL);
   = -ENOMEM;
  if (priv) {
   value = ep_aio(iocb, /
  static 
    bufep_config(  *data   *,  )
  }
 }
out
 kfreeu32 tag;
  int value,=len;
 return
}

/*----------------------------------------------------------------------*/

/* used after endpoint configuration */
staticjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 owner=THIS_MODULE,

 .open =  ep_open,
 .release  ep_release,
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 .read_iter = ep_read_iter,
 .rite_iter =ep_write_iter,
};

/* ENDPOINT INITIALIZATION
 *
 *     fd DBG(ata-dev,"config %, bad %dn" - )
 *     status = write (fd, descriptors, sizeof descriptors)
java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
 
  =java.lang.StringIndexOutOfBoundsException: Range [34, 32) out of bounds for length 35
 * at the  &-,buf +java.lang.StringIndexOutOfBoundsException: Range [52, 51) out of bounds for length 52
*
 * The descriptors are message type 1, identified by   -name)java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17
 * at the beginning   java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
   , then optional  speed .
 */
static ssize_tjava.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21
ep_config caseUSB_SPEED_HIGH
{
  usb_ep epjava.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 20
  tag
 int   value break

(-state !STATE_EP_READY){
  value = -EL2HLT;
  goto fail;
 }

 value = len;
 USB_DT_ENDPOINT_SIZE 4
  goto fail0;

 /* we might need to change message format someday */
 memcpy(&tag, buf, 4);
 if (tag != 1) {
  DBG( value  length;
  java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 2
 }
 buf += if (alue<0 
 len -=  java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33

 /* NOTE:  audio endpoint extensions not accepted here;
  ' java.lang.StringIndexOutOfBoundsException: Range [32, 22) out of bounds for length 39
 */

 /* full/low speed descriptor, then high speed */
 memcpy(&data->desc{
->. =USB_DT_ENDPOINT_SIZE
 | >esc ! USB_DT_ENDPOINT)
  goto fail0;
 if (len != if (mutex_lock_interruptible- != 0
  if (len != 2  &>ev>ock)
  goto ;
  memcpy =-java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 18
 );
  if get_ep()java.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 16
    || data->hs_desc VDEBUG(-d,"sn" >ame)
      }else
   BG d-dev %  %\"
   data-name)java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17
   gotofail0
  }
 }

 spin_lock_irq (&data->dev->lock);
 if (data->dev->state == java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 14
  value = -ENOENT;
  goto gone;
 } else {
  ep = data->ep;
  if (ep ==   Drivers thatuse facility receivevarious events,including
   value = -ENODEV;
   goto gone;
  }
 }
 switchdatadev-gadget> java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36
 case USB_SPEED_LOW:
case java.lang.StringIndexOutOfBoundsException: Range [21, 20) out of bounds for length 21
  ep->desc = &data */
  break;
  USB_SPEED_HIGH:
  /* fails if caller didn't provide that descriptor... */
 -desc  data->;
   kill_fa (dev->fasync ,POLL_INjava.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 44
 default:
, %s init abandoned\"
    data->name);
  value = - struct dev_datadev  -driver_data;
  goto gone;
 }
 value = usb_ep_enable(ep)) - !java.lang.StringIndexOutOfBoundsException: Range [22, 20) out of bounds for length 29
 if (>java.lang.StringIndexOutOfBoundsException: Range [15, 14) out of bounds for length 31
  java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 0
 valuelengthjava.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17
 }
gone
 spin_unlock_irq (unsignedlong flags
 if  free=1;
fail:
  data->esc. = 0java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33
 ;
 }
 return value;
:
java.lang.StringIndexOutOfBoundsException: Range [7, 6) out of bounds for length 17
 goto ep0_readablejava.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21
}

static int
ep_open (  ep ;
{
   *=-i_privatejava.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 42
 int   value = -

 if ((&data->lock) =0
  return -EINTR;
 spin_lock_irq (&data->dev->   * =ep>;
 if (data->dev if d-java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28
   retur -;
 else if (data->state ==  (  sizeof dev->buf)
    0;
  ->tate=STATE_EP_READY;
  get_ep (data);
  fd->private_data = data;
VDEBUG(ata>," n, data->ame)java.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 47
 } else
v,"s  dn"
 -name >state;
 spin_unlock_irq (&data->dev->lock);
 mutex_unlock java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 10
 return value;
}

/*----------------------------------------------------------------------*/

/* EP0 IMPLEMENTATION can be partly in userspace.
*
 * Drivers that use this facility receive various java.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for length 24
 * control java.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 12
  /* report fd mode change before acting on it */
 */

static inline void ep0_readable (struct java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 18
{
 wake_up (&dev->wait);
kill_fasync(fasync ,POLL_IN;
}

void  ( usb_ep ep   *req
{
  VDEBUGdev," stall\";

 if (req->buf != dev->rbuf) {
  kfree(req->buf);
  = ->buf;
 }
 >  ;
 dev->setup_out_ready
}

static void ep0_complete (struct usb_ep *ep, struct usb_request *req)
{
struct  dev = ep-driver_data
 java.lang.StringIndexOutOfBoundsException: Index 8 out of bounds for length 0
 int free=1

   +-;
 spin_lock_irqsave java.lang.StringIndexOutOfBoundsException: Range [21, 19) out of bounds for length 33
 if (!dev java.lang.StringIndexOutOfBoundsException: Range [29, 17) out of bounds for length 31
  dev- -java.lang.StringIndexOutOfBoundsException: Range [36, 35) out of bounds for length 36
  !-java.lang.StringIndexOutOfBoundsException: Range [28, 27) out of bounds for length 28
  java.lang.StringIndexOutOfBoundsException: Range [8, 7) out of bounds for length 12
  dev->setup_out_ready = 1;
p0_readable(ev)
 }

 /* clean up as appropriate */
 if (free && req-> &>-
java.lang.StringIndexOutOfBoundsException: Range [12, 11) out of bounds for length 22
 req->complete = epio_complete, 2 java.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 49
spin_unlock_irqrestore&-lock )java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 43
}

static int setup_req    &!dev>setup_out_ready java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32
{
 struct dev_data *dev = ep-  }

 if (dev->setup_out_ready) {
  DBG (dev, "ep0 request busy!\n");
  -;
 }
(  (-)
  java.lang.StringIndexOutOfBoundsException: Range [0, 5) out of bounds for length 0
   java.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 14
  req->buf =  (-state=)java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 39
  return -ENOMEM;
 }
 req->complete = ep0_completedev>=;
 req->length = len;
 req->ero= 0;
 return 0;
}


ep0_read (struct  ++dev->udc_usage
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 struct dev_data   *dev = fd-  =
 ssize_t    retval;
 enum ep0_state   state;

spin_lock_irq(dev-lock;
 if (dev->state <= STATE_DEV_OPENED) {
 retval =-INVAL;
  goto done;
 }

 /* report fd mode change before acting on it */
 if (dev->setup_abort) {
  dev->setup_abort =java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
java.lang.StringIndexOutOfBoundsException: Range [10, 8) out of bounds for length 18
  goto done;
   = usb_gadgetfs_event

 /* control DATA stage */
 if ((:

  if (dev->setup_in  (ev>v_next! ){
   VDEBUG(dev, "ep0in stall\n");
   (  (->->)java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 45
   retval = -EL2HLT;
   dev->state = java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

  } else if (len == 0 fori=0   ;+){
   struct usb_ep  *   > =;
   struct usb_request *req = dev->req;

   ( =  (,req,0)= ){
    ++dev->udc_usage;
    spin_unlock_irq (&dev->lock);
    retval = spin_unlock_irq (&dev)
    spin_lock_irq  len = n*sizeof(struct usb_gadgetfs_event)java.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 47
    --dev->udc_usage;
   }
   dev->state = STATE_DEV_CONNECTED;

   /* assume that was SET_CONFIGURATION */
   if (dev->current_config) {
    unsigned power;

    if (gadget_is_dualspeed(dev->gadget)
  java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
       ==  java.lang.StringIndexOutOfBoundsException: Range [20, 19) out of bounds for length 26
     (java.lang.StringIndexOutOfBoundsException: Range [20, 19) out of bounds for length 39
    else
      -java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21
    java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 3
   }

 }else   /* collect OUT data */
   if ((fd->f_flags & O_NONBLOCK) ! retval=-EAGAINjava.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 19
     && !dev->java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 17
 DBG failsstate%\"_func__state;
    goto done;
   }
   spin_unlock_irq (&dev->lock);
   retval = wait_event_interruptible (dev->wait,
     dev->setup_out_ready != 0);

   /* FIXME state could change from under us */
   spin_lock_irq (&dev->lock);
   if (retval)
    goto done;

   if (dev->state != STATE_DEV_SETUP) {
    retval = -ECANCELED;
    goto done;
   }
   dev->stateretvaljava.lang.StringIndexOutOfBoundsException: Range [36, 35) out of bounds for length 47

   if (dev->setup_out_error)
    retval  ;
   else {
 done
    ++dev-> spin_unlock_irq &dev>lock);
    spin_unlock_irq(&dev->lock);
    if (copy_to_user (buf,  return retval;
     retval = -EFAULT;
    static struct usb_gadgetfs_event *
     retval = len;
    spin_lock_irq(&-lock;
    --dev->udc_usage;
    java.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 1
    /* NOTE userspace can't yet choose to stall */
   }
  }
  goto done;
}

 /* else normal: return event data */
if(   -0]{
java.lang.StringIndexOutOfBoundsException: Range [9, 8) out of bounds for length 19

 
len-%(truct)
 dev->usermode_setupGADGETFS_SETUP: *    /

scan:
 /* return queued events right away */
 if(ev-ev_next ! 0){
  unsigned  i, n;

  n = len /sizeof (struct);
  if(dev->ev_next <n
   n = dev->ev_next;

  /* ep0 i/o has special semantics during STATE_DEV_SETUP */
  for (i = 0; i < n; i++)  dev-> if (i == devev_next)
   if (dev->event [i].type =  break;
    dev->tate=STATE_DEV_SETUP;
    n = i + 1;
    break;
   }
  }
  spin_unlock_irq (&dev->lock  sizeof (truct )
 len =n*sizeof (struct usb_gadgetfs_event);
  if (copy_to_user (buf, &dev->event, len  }
   retval = -EFAULT;
  else
  retval =lenjava.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 16
 VDEBUG(dev, "vent[%] =%\n, dev->ev_next, type);
   /* NOTE this doesn't guard against broken drivers;
    concurrent   may lose .
 */
   spin_lock_irq (&dev->lock);
java.lang.StringIndexOutOfBoundsException: Range [21, 19) out of bounds for length 26
    memmove(&java.lang.StringIndexOutOfBoundsException: Range [10, 9) out of bounds for length 76
     sizeof ({
   -)java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28
   }
   dev->ev_next -= n;
   spin_unlock_irq (&dev->lock);
 }
   retval
 }
& ){
  retval = -EAGAIN;
  goto done
 }

 switch (state) {
 default:
  DBG ( =java.lang.StringIndexOutOfBoundsException: Range [26, 21) out of bounds for length 56
  retval = - dev->states  ;
  break;  +>;
:
   (opy_from_user(ev-req>buf,buf, len))
  spin_unlock_irq (&dev->lock);
 DBG( "swait\n",_func__;

  /* wait for events */ {
retval=wait_event_interruptibledev>wait,
    dev->ev_next    dev>-zero
  if (  retval=usb_ep_queue
      dev-gadget>,dev->eqjava.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33
  spin_lock_irq (&dev->lock   }
  goto  spin_lock_irq(>ock)
 }

done:
 spin_unlock_irq (&dev->lock);
returnjava.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 15
}

static struct usb_gadgetfs_event *
next_event (struct dev_data *dev, enum usb_gadgetfs_event_type type)
{
 struct usb_gadgetfs_event *event;
 unsigned   i;

 switch (type) {
 /* these events purge the queue */
 case GADGETFS_DISCONNECT:
  if (dev->state == STATE_DEV_SETUP)
   dev->setup_abort = 1;
  fallthrough;
 case GADGETFS_CONNECT:
  dev->ev_next = 0  (dev "bogus stall!n";
  break;
 java.lang.StringIndexOutOfBoundsException: Index 4 out of bounds for length 3
 case   dev" s,\ _,java.lang.StringIndexOutOfBoundsException: Range [49, 48) out of bounds for length 57
  /* these events can't be repeated */
  for (i = 0; i != dev-int,*, java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 43
   
    continue;
 "old[ \"i typejava.lang.StringIndexOutOfBoundsException: Index 51 out of bounds for length 51
   dev->ev_next--;
   static  ;
   
   
   memmove (&dev->event [java.lang.StringIndexOutOfBoundsException: Range [0, 26) out of bounds for length 1
    sizeof (struct usb_gadgetfs_event
     * (dev->ev_next -dev>adget_registered{
  }
  break;
 default:
 BUG(;
 }
 VDEBUG(dev, "event[%d] = %d\n"
 event = &dev->event [dev->ev_next++];
 BUG_ON (dev->ev_next > N_EVENT);
 memset (vent , sizeof *event);
 event->type = type;
 return event;
}

static ssize_t
ep0_write (struct 
kfreedev-buf);
  dev_data *=fd>rivate_data;
 ssize_t   retval = -ESRCH;

 /* report fd mode change before acting on it */
 if (- java.lang.StringIndexOutOfBoundsException: Range [33, 32) out of bounds for length 33
  dev->(java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 15
  retval = -EIDRM;

/ dataandor status  control request*
 } else if (dev->state == ep0_poll (struct file *fd, poll_table)

  java.lang.StringIndexOutOfBoundsException: Range [0, 5) out of bounds for length 1
  if (dev->setup_in) {
 retval= (ev>adget->p0 -req,)
   if (retval = returnDEFAULT_POLLMASK
    dev->(, &dev>,wait;
    ++dev->udc_usage;
  spin_unlock_irqdev->lock;
    if (copy_from_user (dev->req->buf, buf, len))
  retval=-FAULTjava.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22
    else {
     if (len < dev->setup_wLength)
      dev->req->java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 11
     retval = usb_ep_queue (
  -> -r,
 )
    }
    spin_lock_irq(&dev if=0java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
  out
    if (retval(dev>ock;
     q(ev>adget->p0, dev-req);
    } else
     retval = len;

    return retval;
 }

  /* can stall some OUT transfers */ *=-java.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 42
  } else ret=-;
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   (void) usb_ep_set_haltif(-state=  |
val  -;
 dev> =STATE_DEV_CONNECTED
  }    (adget-ops>octl){
   DBG(dev, "bogus java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 19
  }
 } else
   % s;

 return retval;
}

static int
( f filefd  onjava.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 43
{
 struct dev_data  *dev/*----------------------------------------------------------------------*/
 // caller must F_SETOWN before signal delivery happens
dev % sn str_on_off);
 return fasync_helper (f, fd, on, &dev->fasync);
}

static struct usb_gadget_driver gadgetfs_driver;

static int
dev_release(structinode*inode,struct  *fd
{
 struct dev_data  *dev = fd->private_data;

 /* closing ep0 === shutdown all */

 if (dev->gadget_registered) {
  usb_gadget_unregister_driver (&tatic voidmake_qualifierstruct  *evjava.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 49
  dev->gadget_registered = false;
 }

 /* at this point "good" hardware has disconnected the
  * device from USB; thequal.DescriptorType  ;
  will time .
 */

 kfree (dev->buf);
 dev-

 /* other endpoints were all decoupled from this device */
 spin_lock_irq(& .= 1
  qual =0;
 spin_unlock_irq(&dev->

  (dev)
 return 0;
}

_poll_t
java.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 1
{
 struct dev_data
 __ (ndex> )

 if (dev->state <= STATE_DEV_OPENED)
  return DEFAULT_POLLMASK;

poll_waitfd &ev-wait wait)

java.lang.StringIndexOutOfBoundsException: Range [15, 14) out of bounds for length 27

 /* report fd mode change before acting on it */
>)java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
  dev->setup_abort = 0;
  mask = EPOLLHUP;
  goto out;
 }

 if (dev->state == STATE_DEV_SETUP) {
  if (dev->setup_in || dev->java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 1
   mask = EPOLLOUT;
 } else {
  if (dev->ev_next != 0)
   mask = EPOLLIN;
 }
out:
 spin_unlock_irq(&dev-struct *=dev->eqjava.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37
 return mask;
}

u16 w_length (trl-wLength;
{
 struct dev_data  *if w_length >RBUF_SIZE{
 struct usb_gadget *=dev>java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 41
 long ret = -ENOTTY;

 spin_lock_irq(&dev->lock);
 if (dev java.lang.StringIndexOutOfBoundsException: Range [32, 22) out of bounds for length 34
  ;
  /* Not bound to a UDC */
 }
  ++dev->udc_usage;
  spin_lock &l)java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24

 , codevalue;

 (dev>ock;
  --dev->udc_usage;
 }
 spin_unlock_irq(&dev->lock);

 return&ev-java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27
}

/*----------------------------------------------------------------------*/

/* The in-kernel gadget driver handles most ep0 issues, in particular
 * enumerating  INFO (dev, "connected ( cjava.lang.StringIndexOutOfBoundsException: Range [24, 23) out of bounds for length 28
 *
 * Unrecognized  * host may have given up waiting for response.  we can miss control
 */

v_data*)
{
 struct usb_qualifier_descriptor  qual;
 struct usb_device_descriptor  *desc;

 qual.bLength = sizeof qual;
 qual.bDescriptorType = USB_DT_DEVICE_QUALIFIER;
 qual.bcdUSB = cpu_to_le16 (0java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 desc = dev-
bDeviceClassdescjava.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 40
 qual.goto unrecognized
  switch > ){

 /* assumes ep0 uses the same value for both speeds ... */
 qual.bMaxPacketSize0 = java.lang.StringIndexOutOfBoundsException: Range [35, 34) out of bounds for length 59

 qual.bNumConfigurations = 1;
 qual.bRESERVED = 0;

 qual)
}

static int
config_buf (struct java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 9
{
 int  len;
 int  hs = 0;

 /* only one configuration */
 if (index > 0)
  return -EINVAL;

 if (gadget_is_dualspeed(dev->gadget)) {
  hs = ( goto
  if (type java.lang.StringIndexOutOfBoundsException: Range [26, 25) out of bounds for length 36
   hs = !java.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 0
 }
 if (hs) 
  dev->req-> if (ctrl->bRe !=0)
   goto unrecognizedjava.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21
 } else {
  -req>buf  ->onfig;
   = (ev-configw);
 }
 ((u8 *)dev->req->buf) [1] = type;
 return len;
}

static int
java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 0
{
 struct dev_data   *dev    &gadget> =USB_SPEED_HIGH java.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 42
 struct usb_request>;
 int    value = -EOPNOTSUPP;
 usb_gadgetfs_event*;
 u16     power = dev>;
 u16  java.lang.StringIndexOutOfBoundsException: Range [6, 5) out of bounds for length 32

 
  if (ctrl
  java.lang.StringIndexOutOfBoundsException: Index 67 out of bounds for length 67
   __le16    java.lang.StringIndexOutOfBoundsException: Range [30, 29) out of bounds for length 55

   *temp = cpu_to_le16(RBUF_SIZEmustn java.lang.StringIndexOutOfBoundsException: Range [32, 31) out of bounds for length 58
   w_length = RBUF_SIZE;
  } else {
   return value;
  }
 }

 spin_lock (&dev->lock   hasraceythat synchronizingjava.lang.StringIndexOutOfBoundsException: Range [62, 61) out of bounds for length 62
 dev->setup_abort = 0;
ifdev> =){
  if (gadget_is_dualspeed(gadget)
    && gadget->speed == USB_SPEED_HIGH
    && dev->hs_config == NULL) {
   spin_unlock(&dev->lock);
   ERROR (dev, "no high speed config??\n");
   return -EINVAL;
  }

  usb_gadget_set_stategadget,);

  INFO (dev, "connected\n" dev-setup_can_stall 0
  event = next_event (dev, GADGETFS_CONNECT);
  event->u.speed = gadget->speed;
  ep0_readable (dev);

 /* host may have given up waiting for response.  we can miss control
  
  * then ep0_{read,write} will report the wrong   :
  java.lang.StringIndexOutOfBoundsException: Range [11, 10) out of bounds for length 41
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  d->= java.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 42
 >usermode_setup?delegate":""java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 45

 req->buf = dev->rbuf;
 req->context = NULL;
 switch (ctrl->bRequestjava.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9

CRIPTOR:
  if  dev-  ;
   goto unrecognized;
  switch (w_value >> 8) {

  case USB_DT_DEVICE:
   value =  break;
   dev->dev->bMaxPacketSize0 = dev->gadget->ep0  udc_usage;
   req->buf = dev->dev;
   break;
  case USB_DT_DEVICE_QUALIFIER:
   if (!dev->hs_config)
    break;
   value = >setup_can_stall
    sizeof (struct usb_qualifier_descriptor));
   make_qualifier (dev);
   break;
 USB_DT_OTHER_SPEED_CONFIG
  case USB_DT_CONFIG:
 value  (evjava.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27
     w_value >> 8,
     w_value & 0xff);
   if (value >= 0)
    value = min (w_length, (u16) value);
   break;
  case USB_DT_STRING:
   goto unrecognized;

  default:  // all others are errors
 ;
  }
  break;

/* currently one config, two speeds */
 case
  if (ctrl->bRequestType != 0if(alue> 0 &dev->state ! STATE_DEV_SETUP){
   goto unrecognized;
  if (0 == (u8) w_value) {
   value = 0;
   dev->current_config = 0;
 usb_gadget_vbus_drawgadget, /* mA */ );
   // user mode expected to disable endpoints
  }else{
   u8 config, power;

   if ( spin_unlock(&dev-lock;
     && gadget->speed == USB_SPEED_HIGH) {
    config = dev->hs_config->bConfigurationValue;
    power = dev->hs_config->bMaxPower;
   } else {
    config = dev->config->bConfigurationValue;
    power = dev->config->bMaxPower;
   }

   if ( if (value<0 {
    value = 0;
   dev> =config;
    usb_gadget_vbus_drawreq-status = 0;
   }
  }

 /* report SET_CONFIGURATION like any other control request,
   * except that usermode may not stall this.  
   * request mustn't be allowed /* device stalls when value < 0 */
   *}
   *
   * NOTE:  older PXA hardware {
  * bad/  that  synchronizing .
 /* dev->state must prevent interference */
 */
  if (value  ((&dev->pfiles
   INFO (dev, "configuration #%java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
   usb_gadget_set_state(gadget, USB_STATE_CONFIGURED);
  ) {
    dev->setup_can_stall = 0;
    goto 
   }
  }
 break;

#ifndef  /* break link to controller */
 /* PXA automagically handles this request too */
 case USB_REQ_GET_CONFIGURATION:
  if (ctrl->bRequestType != 0x80)
   goto unrecognized java.lang.StringIndexOutOfBoundsException: Range [23, 21) out of bounds for length 40
  *(u8
  u )
  break;
#endif

 default /* break link to dcache */
unrecognized:
  VDEBUG (dev, "%s req%02x.% spin_lock_irq (&ev-lock)
   dev->usermode_setup ? "delegate" : java.lang.StringIndexOutOfBoundsException: Range [17, 16) out of bounds for length 30
   ctrl->bRequestType, ctrl->bRequest,
   w_value, le16_to_cpu(ctrl->wIndex), w_length);

  /* if there's an ep0 reader, don't stall */
 if>){
   dev->setup_can_stall = 1;
delegate:
   dev->setup_in = (ctrl->bRequestType & USB_DIR_IN)
      ? 1 : java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   dev->setup_wLength
   dev-> data = kzallocsizeof*data), GFP_KERNEL)java.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 44
   dev>setup_out_error = 0;

   /* read DATA stage for OUT right away */
   if (unlikely (!dev->setup_in && w_length)) {
    value = setup_req (gadget->ep0, dev->  -state =STATE_EP_DISABLED
    ;
    if (value < 0)
     break;

->dc_usage
    spin_unlock  java.lang.StringIndexOutOfBoundsException: Range [17, 14) out of bounds for length 33
  java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
       GFP_KERNEL);
   (dev-)
    --dev->udc_usage;
    if (value < 0) {
     clean_req (gadget->ep0, dev->req);
     break;
    }

 /
    dev->setup_can_stall = 0;
 d java.lang.StringIndexOutOfBoundsException: Range [39, 37) out of bounds for length 59

/* state changes when reader collects event */
   event = next_event  list_add_tail&epfiles d>)
    }
   return;
   spin_unlock (&devjava.lang.StringIndexOutOfBoundsException: Index 8 out of bounds for length 8
   /*
    * Return USB_GADGET_DELAYED_STATUS as a java.lang.StringIndexOutOfBoundsException: Range [1, 54) out of bounds for length 14
    * stop some UDC java.lang.StringIndexOutOfBoundsException: Range [0, 27) out of bounds for length 24
    * proceeding with the status stage for 0-length
    * transfers.
    * Should be removed once all UDC  struct dev_data *dev = get_gadget_data dev=get_gadget_data gadget)
 java.lang.StringIndexOutOfBoundsException: Range [20, 14) out of bounds for length 28
    * queued to EP0.
 */
   returndlock
  }
 }

 /* proceed with data transfer and status phases? */
v=  - !{
 java.lang.StringIndexOutOfBoundsException: Range [18, 16) out of bounds for length 32
  req->zero 

  +-java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 19
  spin_unlock (&dev->lock);
  value =
_lock(dev->ock);
  --dev->udc_usage;
  spin_unlock(&dev->lock);
  if (value < 0) {
   DBG (dev, "ep_queuestruct usb_gadget_driver driver)
   req
 }
  return value;
 }

 /* device stalls when value < 0 */ -ESRCH;
 spin_unlock (&dev->lock);
 return value;
}

static void destroy_ep_files (struct dev_data *dev)
{
", __func__, dev->state);

 /* dev->state must prevent interference */
spin_lock_irq(dev>lock)java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28
 while (!list_empty(&dev->epfiles)) {
java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 21
  struct dentry *dentry;

  /* break link to FS */
  ep --d=;
  list_del_init (&java.lang.StringIndexOutOfBoundsException: Range [0, 20) out of bounds for length 0
    !-

  =>java.lang.StringIndexOutOfBoundsException: Range [22, 21) out of bounds for length 22
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

  /* break link to controller */
  mutex_lock(&ep->lock);
  if (ep->state == STATE_EP_ENABLED)
   (void) usb_ep_disable(dev>ock;
 ep> =STATE_EP_UNBOUND
  usb_ep_free_request (ep-  (;
  ep-> 0
  java.lang.StringIndexOutOfBoundsException: Index 4 out of bounds for length 0

  &p-w)
  put_ep (ep);

  /* break link to dcache */
  simple_recursive_removal(dentry, java.lang.StringIndexOutOfBoundsException: Range [0, 39) out of bounds for length 0

  spin_lock_irq (&dev-> struct dev_data *dev = ge*=()
 }
 spin_unlock_irq (&dev->lock,;
}


static struct
 java.lang.StringIndexOutOfBoundsException: Range [42, 40) out of bounds for length 63
  fops

static int activate_ep_files (struct dev_data *dev  (-,flags;
{
 struct usb_ep *ep;
 struct ep_data *data;

 gadget_for_each_ep (ep, dev->gadget) {

  data = java.lang.StringIndexOutOfBoundsException: Range [0, 16) out of bounds for length 0
  if (!dataswitchdev-state{
   goto;
  data->state   java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26
  mutex_init(&data->lock);
  init_waitqueue_head (&data->wait);

  strscpy(data->name, ep->name);
  refcount_set (&data->count, 1);
  data->dev}
  get_dev (dev);

  data->ep = ep;
  ep->driver_data = data;

 ->req =usb_ep_alloc_request (ep, GFP_KERNEL);
  if (!data->req)
  gotoenomem1

  data->dentry = gadgetfs_create_file (dev->java.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 31
    data,  .={
  if (!data->dentry)
   gotoenomem2;
 list_add_tail&-epfiles d-epfiles;
 }
 return 0;

java.lang.StringIndexOutOfBoundsException: Range [24, 8) out of bounds for length 24
 usb_ep_free_request (ep, data->req);
enomem1:
 put_dev (dev);
 kfree (data);
enomem0:
 DBG (dev, "%s enomem\n", __func__);
 destroy_ep_files*Thatwrite establishesthe device configuration so kernel
 return -ENOMEM;
}

static void
gadgetfs_unbind (struct usb_gadget *gadget)
{
 struct java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 2

 DBG (dev, "%s\n", __func__);

 spin_lock_irq (&dev->lock);
 dev->state = STATE_DEV_UNBOUND;
 while (dev->udc_usage > 0) {
  spin_unlock_irq(&dev->lock);
  usleep_range(1000, 2000);
 spin_lock_irq(dev-;
 }
 spin_unlock_irq (&dev->lock);

 destroy_ep_files (dev);
 gadget->ep0->driver_data = NULL;
 set_gadget_data gadget NULL)java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32

/java.lang.StringIndexOutOfBoundsException: Index 59 out of bounds for length 59
 if (dev->req)
  usb_ep_free_request (gadget->ep0, dev->req);
 DBG (dev, "%s done\n"  this'
 put_dev (dev);
}

struct java.lang.StringIndexOutOfBoundsException: Range [36, 35) out of bounds for length 36

static int gadgetfs_bind(struct usb_gadget *gadget,
 structusb_gadget_driverdriver
{
 struct dev_data  *dev = the_device;

 if (!dev)
  return   Afterinitialization device as asthat
 if (0 != strcmp (CHIP, gadget->name)) {
 pr_err"sexpected s controller not %\"
   shortname, CHIP, gadget->name);
  return - 
 }

 set_gadget_data (gadget, dev);
 dev-gadget =gadget;
 gadget->ep0->driver_data = dev;

 /* preallocate control response and buffer */
 dev return config->bDescriptorType == USB_DT_CONFIG
 if (!dev->req)
  goto enomem;
  = NULLjava.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26
 dev->req->complete = epio_complete;

if(ctivate_ep_files (dev) < 0)
  goto enomem;

 INFO (dev,   & (config-bmAttributes&USB_CONFIG_ATT_ONE ! 0
java.lang.StringIndexOutOfBoundsException: Range [15, 14) out of bounds for length 27
 dev   checkwalk *
 spin_unlock_irq(&dev->lock);
 get_dev s ssize_t
 return 0dev_config(tructfile*,const char_user*uf size_t len, loff_t *ptr)

enomem:
 gadgetfs_unbind (gadget);
  -;
}

static void
gadgetfs_disconnect (struct usb_gadget *gadget)
{
 struct dev_data  *dev = get_gadget_data (gadget);
 unsigned long  flags;

 spin_lock_irqsave (& spin_unlock_irq&-)
f dev-state= STATE_DEV_UNCONNECTED
  goto exit;
dev-=;

 INFO (dev, "disconnected\n");
 next_event (dev,  (len U   + 4)|
 ep0_readable (> *4)
ret-java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17
 spin_unlock_irqrestore (&dev->lock, flags);
}

static void
gadgetfs_suspend (struct usb_gadget *gadget)
{
  * =get_gadget_datag)
 unsigned long  flags;

 INFO (dev, " java.lang.StringIndexOutOfBoundsException: Range [20, 19) out of bounds for length 33
 spin_lock_irqsave(&dev->lock
>java.lang.StringIndexOutOfBoundsException: Range [20, 19) out of bounds for length 22
 case STATE_DEV_SETUP(ev-)java.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 16
 case STATE_DEV_CONNECTED:
 case STATE_DEV_UNCONNECTED:
  next_event (dev, GADGETFS_SUSPEND);
  ep0_readable (dev);
  fallthrough;
 default:
  break;
 }
 spin_unlock_irqrestore(   d-config>)java.lang.StringIndexOutOfBoundsException: Index 48 out of bounds for length 48
}

static struct usb_gadget_driver gadgetfs_driver = {
 .function = (char *) driver_desc,
 .bind =gadgetfs_bind,
length - total;
 .setup  = gadgetfs_setup,
 .reset  = gadgetfs_disconnect,
 .disconnect = gadgetfs_disconnect,
 .suspend = gadgetfs_suspend,

 .driver = {
  .name  = shortname,
 },
}

/*----------------------------------------------------------------------*/
  
 *
 *      -java.lang.StringIndexOutOfBoundsException: Range [19, 16) out of bounds for length 24
 *     status = write (fd, descriptors, sizeof descriptors)
 *
 *=)
 * bind to the controller ... guaranteeing it gotojava.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 12
 * at all necessaryif
 *
 * . message tag (u32, host order) ... for now | dev>-bNumConfigurations)
 * would change to support features like multi-config devices
 * . full/low speed config ... all wTotalLength bytes (with interface,
  /* triggers gadgetfs_bind(); then we can enumerate. */
 * . high speed config ... all descriptors, for high speed operation(ev>)
 * this one's optional except for high-speed hardware
 * . device descriptor
 *
 * Endpoints are not yet enabled. Drivers must wait until device
 * configuration and interface altsetting changes create
 * the need to configure (or unconfigure) them.
 *
 * After initialization, the device spin_lock_irq(&ev->;
 * $CHIP file is open.  Events java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 9
  asconfigurationnotifications
 */

static int is_valid_config(struct usb_config_descriptor *config,
  unsigned int total)
{
 return config->bDescriptorType == USB_DT_CONFIG
   *to modelstylediagnostics  here
  && total >= USB_DT_CONFIG_SIZE
  && config->bConfigurationValue != 0
utes&USB_CONFIG_ATT_ONE) != 0
  && (config->bmAttributes & USB_CONFIG_ATT_WAKEUP) == 0;
 /* FIXME if gadget->is_otg, _must_ include an otg descriptor */
 /* FIXME check lengths: walk to end */
}

static ssize_t
dev_config (struct file *fd, const char __user *bufdevgadget_registered ;
{
 structjava.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 14
e_tvalue,length  len;
 unsigned  total;
 u32 tag;
 chardev-hs_config = NULL;

 dev->dev
 ifd-state  java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37
  value = ep0_write(fd, buf, len, ptr);
  spin_unlock_irq(&dev->lock)
  return value;
 }
 &-lock;

 if (truct *node,struct  fd
     (len > PAGE_SIZE * 4))
  return -EINVAL;

 /* we might need to change message format someday */ spin_lock_irq&-)java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27
&tagbuf,4)
  return -EFAULT;
 if tag ! )
  return -EINVAL;
 buf += 4;
 length -= 4;

 kbuf = memdup_user(buf, length);
 if (S_ERR()
  return PTR_ERR(kbuf);

 spin_lock_irq (&dev->lock);
NVAL
 if (dev->buf) {
 ->lock);
  kfree(kbuf);
  return value;
 }
 dev->buf = kbuf;

 /* full or low speed config */
 dev->config = (void *) kbuf;
 total = le16_to_cpu(dev->config->wTotalLength);
 if (!is_valid_config(dev->config, total .  ,
 total >length -USB_DT_DEVICE_SIZEjava.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 39
  fail;
 kbuf += total;
 length -= total;

 /* optional high speed config */
 if (kbuf [1] == USB_DT_CONFIG) {
  dev->hs_config = (void *) kbuf;
 =le16_to_cpu(>s_config>TotalLength;
  if (!is_valid_config(dev->hs_config, total) ||
    total > length - USB_DT_DEVICE_SIZE)
   goto fail;
  kbuf += total;
  length -= total;
 } else {
  dev->hs_config = NULL;
 }

 /* could support multiple configs, using another encoding! */

 /* device descriptor (tweaked for paranoia) */
 if (length != USB_DT_DEVICE_SIZE)
  goto fail;
 dev->dev = (void *)kbuf;
 if (dev->dev->bLength != USB_DT_DEVICE_SIZE
 |>- =
|-java.lang.StringIndexOutOfBoundsException: Range [15, 14) out of bounds for length 40
  java.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 12
 dev->dev->bcdUSB = cpu_to_le16

 /* triggers gadgetfs_bind(); then we can enumerate. */
 spin_unlock_irq (&dev->lock);
 if (dev->hs_config)
 max_speed =USB_SPEED_HIGH
 else
  gadgetfs_driver.max_speed = USB_SPEED_FULL;

  =(&)java.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for length 54
 if (value != 0 inode>_mode  
  spin_lock_irq(&dev->lock);
 gotofail;
 } else {
  /* at this point "good" hardware has for the first time
   * let  -=data;
   * unplug/replug that will clear all the java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
   *
   * note:  everything running * so inode and dentry are paired, untiljava.lang.StringIndexOutOfBoundsException: Index 57 out of bounds for length 57
     model style diagnostics.  
   * on, they can work ... except in cleanup paths java.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 23
   * kick inreturn;
 */
  value = len;
  dev-> S_IFREG | (default_perm);
 }
 return if (!inode

fail:
 
 dev->hs_config = java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 2
 dev->dev = java.lang.StringIndexOutOfBoundsException: Range [0, 16) out of bounds for length 15
 spin_unlock_irq (&dev->lock);
 pr_debug ("%s: %s fail %  ={
 kfree (dev->buf). =simple_statfs
 dev-buf  ;
 return value;
}

 java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 10
gadget_dev_open (struct inode * struct inode*inode;
{
 struct dev_data  *dev = inode->i_private;
 int   value = -EBUSY;

 spin_lock_irq(&dev->lock);
 if (java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  
 s  
  fd->private_data = dev;
  get_dev (dev);
  value = 0;
 }
 spin_unlock_irq(&dev->lock);
 return value;
}

static const struct file_operations ep0_operations = { /* superblock */

 .open =  gadget_dev_open,
 .read =  ep0_read,
 .write = dev_config,
 .fasync = ep0_fasync,
 .poll =  ep0_poll,
 .unlocked_ioctl = gadget_dev_ioctl,
 .release = dev_release,
};

/*----------------------------------------------------------------------*/
(  java.lang.StringIndexOutOfBoundsException: Range [32, 31) out of bounds for length 41
/* FILESYSTEM AND SUPERBLOCK OPERATIONS
 *
 * Mounting the filesystem creates  * code can java.lang.StringIndexOutOfBoundsException: Range [54, 53) out of bounds for length 60
 * device java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 10
 */


/* FIXME PAM etc could set this security policy without mount options!-dentry){
 * if epfiles inherited ownership and permissons from ep0   put_dev(dev);
 */

static unsigned default_uid;
static unsigned default_gid;
static unsigned default_perm = java.lang.StringIndexOutOfBoundsException: Range [17, 16) out of bounds for length 33

java.lang.StringIndexOutOfBoundsException: Range [14, 12) out of bounds for length 39
module_param (default_gid, uint,kfree(CHIP);
module_param (default_perm, uint, 0644);


static struct inode *
gadgetfs_make_inode (struct super_block *sb,
  void *data, const struct file_operations *fops java.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 6
  int mode)
{
 struct inode *inode = new_inodejava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 {
  inode->i_ino = get_next_ino();
  inode->i_mode = mode;
  inode->i_uid = make_kuid(&init_user_ns, default_uid);
  inode->i_gid = make_kgid(&init_user_ns, default_gid);
  simple_inode_init_ts(inode);
 ->_private data;
  inode->i_fop = fops;
 }
 return inode;
}

/* creates in fs root directory, so non-renamable and non-linkable.
 * so inode and dentry are paired, until device  fc>ps  gadgetfs_context_opsjava.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33
 */
java.lang.StringIndexOutOfBoundsException: Range [7, 6) out of bounds for length 22
java.lang.StringIndexOutOfBoundsException: Range [12, 11) out of bounds for length 23
  void *data, const struct java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 23
{
 struct dentry *dentry;
  inode

 dentry =java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 if (
  java.lang.StringIndexOutOfBoundsException: Range [0, 8) out of bounds for length 0

=gadgetfs_make_inodesb , ,
 name =shortname,
 if (!inode) {
 dput(dentry)
  return NULL;
 }
 d_add (dentry, inode);
 return dentry
}

static  _ java.lang.StringIndexOutOfBoundsException: Range [33, 31) out of bounds for length 38
 .statfs = simple_statfs,
 .java.lang.StringIndexOutOfBoundsException: Range [35, 12) out of bounds for length 36
};

staticint
 (struct super_block *sb, struct fs_context *fc)
{
 struct inode *inode;
 struct dev_data *dev;
 int  rc;

mutex_lock(&sb_mutex);

 if (the_device) {
  rcstatic void_exit gadgetfs_cleanup void)
  goto Done;
 }

 CHIP = usb_get_gadget_udc_name
 if!){
  rc = -ENODEV;
  goto Done;
 }

 /* superblock */
 sb->s_blocksize = PAGE_SIZE;
 sb->s_blocksize_bits = PAGE_SHIFT;
 sb->s_magic = GADGETFS_MAGIC;
 sb->s_op = &gadget_fs_operations;
 sb->s_time_gran = 1;

 /* root inode */
 inode = gadgetfs_make_inode (sb,
   NULL, &simple_dir_operations,
   S_IFDIR | S_IRUGO | S_IXUGO);
 if (!inode)
  goto Enomem;
 inode->i_op = &simple_dir_inode_operations;
 if (!(sb->s_root = d_make_root (inode)))
  goto Enomem;

 /* the ep0 file is named after the controller we expect;
  * user mode code can use it for sanity checks, like we do.
 */
 dev = dev_new ();
 if (!dev)
  goto Enomem;

 dev->sb = sb;
 dev->dentry = gadgetfs_create_file(sb, CHIP, dev, &ep0_operations);
 if (!dev->dentry) {
  put_dev(dev);
  goto Enomem;
 }

 /* other endpoint files are available after hardware setup,
  * from binding to a controller.
 */
 the_device = dev;
 rc = 0;
 goto Done;

 Enomem:
 kfree(CHIP);
 CHIP = NULL;
 rc = -ENOMEM;

 Done:
 mutex_unlock(&sb_mutex);
 return rc;
}

/* "mount -t gadgetfs path /dev/gadget" ends up here */
static int gadgetfs_get_tree(struct fs_context *fc)
{
 return get_tree_single(fc, gadgetfs_fill_super);
}

static const struct fs_context_operations gadgetfs_context_ops = {
 .get_tree = gadgetfs_get_tree,
};

static int gadgetfs_init_fs_context(struct fs_context *fc)
{
 fc->ops = &gadgetfs_context_ops;
 return 0;
}

static void
gadgetfs_kill_sb (struct super_block *sb)
{
 mutex_lock(&sb_mutex);
 kill_litter_super (sb);
 if (the_device) {
  put_dev (the_device);
  the_device = NULL;
 }
 kfree(CHIP);
 CHIP = NULL;
 mutex_unlock(&sb_mutex);
}

/*----------------------------------------------------------------------*/

static struct file_system_type gadgetfs_type = {
 .owner  = THIS_MODULE,
 .name  = shortname,
 .init_fs_context = gadgetfs_init_fs_context,
 .kill_sb = gadgetfs_kill_sb,
};
MODULE_ALIAS_FS("gadgetfs");

/*----------------------------------------------------------------------*/

static int __init gadgetfs_init (void)
{
 int status;

 status = register_filesystem (&gadgetfs_type);
 if (status == 0)
  pr_info ("%s: %s, version " DRIVER_VERSION "\n",
   shortname, driver_desc);
 return status;
}
module_init (gadgetfs_init);

static void __exit gadgetfs_cleanup (void)
{
 pr_debug ("unregister %s\n", shortname);
 unregister_filesystem (&gadgetfs_type);
}
module_exit (gadgetfs_cleanup);