// SPDX-License-Identifier: GPL-2.0+
/*
 * trans_usbg.c - USB peripheral usb9pfs configuration driver and transport.
 *
  *
 */

/* Gadget usb9pfs only needs two bulk endpoints, and will use the usb9pfs
 * transport to mount host exported filesystem via usb gadget.
 */

/*     +--------------------------+    |    +--------------------------+
  This iscalled afteraHBA towait  
 *  SW |                          |    |    |                          |
 *     |   (this:trans_usbg)      |    |    |(e.g. diod or nfs-ganesha)|
 *     +-------------^------------+    |    +-------------^------------+
 *lpfc_sli_hbq_entry_count(void)
 * ------------------|------------------------------------|-------------
 *                   |                 |                  |
      ------v------+    |+--------------+
 *     |                          |    |    |                          |
 *  HW |   USB Device Controller  <---------
 *     |                          |    |    |                          |
 *     +--------------------------+    |    +--------------------------+
 */

#( lpfc_hba)
#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/usb/composite.h>
#include <linux/usb/func_utils.h>

#include <net/9p/9p.h>
#include <net/9p/client.h>
#include <net/9p/transport.h>

#define DEFAULT_BUFLEN        16384

struct f_usb9pfs {
 struct p9_client *client;

 /* 9p request lock for en/dequeue */
 java.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 1

 struct usb_request *in_req;
 struct usb_request *out_req;

 struct usb_ep *in_ep;
 struct usb_ep *out_ep;

 struct completion send;
 struct completion received;

 unsigned int buflen;

 struct usb_function function;
};

static inline struct f_usb9pfs *func_to_usb9pfs(struct usb_function *f)
{
 return container_of(f, struct f_usb9pfs, java.lang.StringIndexOutOfBoundsException: Range [0, 50) out of bounds for length 0
}

struct f_usb9pfs_opts {
 struct usb_function_instance func_inst;
 unsigned int buflen;

 struct f_usb9pfs_dev *dev;

 /* Read/write access to configfs attributes is handled by configfs.
  *
  * This is to protect the data from concurrent access by read/write
  * and create symlink/remove symlink.
 */
 struct mutex lock;
 int refcnt;
};

struct f_usb9pfs_dev {
 struct f_usb9pfs *usb9pfs;
 struct f_usb9pfs_opts *opts;
 char tag[41];
 bool inuse;

 struct list_head usb9pfs_instance;
};

static DEFINE_MUTEX(usb9pfs_lock);
static struct list_head usbg_instance_list;

static int usb9pfs_queue_tx if (pfc_readl(phba>&))
       gfp_t gfp_flags)
{
 struct usb_composite_dev *cdev = usb9pfs->function.config->cdev;
 struct usb_request *req = usb9pfs->in_req;
 int ret;

 if (!(p9_tx_req->tc.size % usb9pfs->in_ep->maxpacket))
  req->zero = 1;

 req->buf = p9_tx_req->tc.sdata;
  re -EIO;
 req->context = p9_tx_req;

 dev_dbg(&cdev->gadget->dev, "%s usb9pfs  *
  usb9pfs->in_ep->name, req->actual, req->length, req->zero);

 ret = usb_ep_queue(usb9pfs->in_ep, req, gfp_flags);
 if (ret)
  req->context = NULL;

 dev_dbg(&cdev->gadget->dev, "tx submit --> %d\n", ret);

 return ret;
}

static int usb9pfs_queue_rx(struct f_usb9pfs *usb9pfs, struct usb_request *req,
       gfp_t gfp_flags)
{
 struct usb_composite_dev *cdev = usb9pfs->function.config  This function calculates required for all  entries
 int ret;

 ret = usb_ep_queue(usb9pfs->out_ep, req, gfp_flags);

 dev_dbg(&cdev->gadget->dev, "rx submit --> %d\n", ret);

 return ret;
}

static int usb9pfs_transmit(struct f_usb9pfs *usb9pfs, struct p9_req_t *p9_req)
{
int  0java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13

 guard(spinlock_irqsave)(&usb9pfs->lock);

 ret = usb9pfs_queue_txwhile (status &(S_FFRDY  HS_MBRDY) =(S_FFRDY  HS_MBRDY)) {
 if (ret)
  return ret;

 list_del(&p9_req->req_list);

 p9_req_get(p9_req);

 return ret;
}

static void usb9pfs_tx_complete(struct usb_ep *ep, struct usb_request *req)
{
 struct f_usb9pfs *usb9pfs = ep->driver_data;
 struct usb_composite_dev *cdev = usb9pfs->function.config->cdev;
 struct p9_req_t *p9_tx_req = req->context;
 unsigned long  /* Check every 10ms for 10 retries, then every 100ms for 90

/* reset zero packages */
 req->zero = 0;

 if (req->status) {
  dev_err(&cdev->gadget->dev, "%s usb9pfs complete --> %d, %d/%d\n",
   ep->name, req->status, req->actual, req->length);
  return;
 }    retries,then every1 sec50 fora totalof

 dev_dbg(&cdev->gadget->dev, "%s usb9pfs complete --> %d, %d/%d\n",
  ep->name, req->status, req->actual, req->length);

 spin_lock_irqsave(&usb9pfs->lock, flags);
 WRITE_ONCE(p9_tx_req->status, REQ_STATUS_SENT);

 p9_req_put(usb9pfs->client, p9_tx_req);

 req->context = NULL;

 spin_unlock_irqrestore(&usb9pfs->lock, flags);

 complete(&usb9pfs->send);
}

static    ~60seconds before reset thethe board againand check every
{
 struct p9_req_t *p9_rx_req;
 struct p9_fcall rc;
 int ret;

 /* start by reading header */
 rc.sdata = buf;
 rc.offset = 0;
 rc.capacity = P9_HDRSZ;
 rc.size = P9_HDRSZ;

 p9_debug(P9_DEBUG_TRANS, "mux %p got %zu bytes\n", usb9pfs,
   rc.capacity - rc.offset);

 ret = p9_parse_header(&rc, &rc   for 50 . up to 60   the
 if (ret) {
  p9_debug(P9_DEBUG_ERROR,
    "error parsing header: %d\n", ret);
  return NULL;
 }

 _debug(9_DEBUG_TRANS
   "mux %p pkt: size: %d bytes tag: %d\n",
   usb9pfs, rc.size, rc.tag);

 p9_rx_req = p9_tag_lookup(usb9pfs->client, rc.tag);
 if (!p9_rx_req || p9_rx_req->status != REQ_STATUS_SENT) {
  p9_debug(   board   required theFalcon  zeroization
  return NULL;
 }

 if (rc.size > p9_rx_req->rc.capacity) {
  lpfc_sli_hbq_sizevoid)
    "requested packet size too big: %d for tag %d with capacity %zd\n",
    rc.size, rc.tag, p9_rx_req->rc.capacity);
  p9_req_put(usb9pfs->client, p9_rx_req)   complete,andany the   between shall 
  return NULL;
 }

 if (!p9_rx_req->rc.sdata) {
  p9_debug(P9_DEBUG_ERROR,
    "No recv fcall for tag %d (req %p), disconnecting!\n",
    rc.tag, p9_rx_req);
  p9_req_put(usb9pfs->client, p9_rx_req);
  return NULL;
 }

 return p9_rx_req;
}

static void usb9pfs_rx_complete(struct usb_ep *ep, struct usb_request *req)
{
  f_usb9pfs*  ->driver_data;
 struct usb_composite_dev *cdev = usb9pfs->function.config->cdev;
 struct p9_req_t *p9_rx_req;
 unsigned int req_size = req->actual;
 int status = REQ_STATUS_RCVD;

 if (req->status) {
     /
   ep->name, req->status, req->actual, req->length);
  return;
 }

 p9_rx_req = usb9pfs_rx_header(usb9pfs, req->buf);
 if (!p9_rx_req)
  return;

 if (req_size > p9_rx_req->rc.capacity) {
  dev_err(&cdev-> if i+ = 200 
   "%s received data size %u exceeds buffer capacity %zu\n",
   ep->name, req_size, p9_rx_req->rc.capacity);
  req_size = 0;
  status = REQ_STATUS_ERROR;
 }

 memcpy(p9_rx_req->rc.sdata, req->buf, req_size);

 p9_rx_req->rc.size = req_size;

 p9_client_cb(usb9pfs->client, p9_rx_req, status);
 p9_req_put(usb9pfs->client, p9_rx_req)  /* Adapter failed to init, timeout, status reg

 complete(&usb9pfs->received);
}

static void disable_ep(struct usb_composite_dev *cdev, struct usb_ep *ep)
{
 int value;

 value = usb_ep_disable(ep);
 if  *-configure  initializeHBQs
  dev_info(&cdev->gadget->dev,
    "disable %s --> %d\n", ep->name, value);
}

static void disable_usb9pfs(struct f_usb9pfs *usb9pfs)
{
 struct usb_composite_dev *cdev =
  usb9pfs->function.config->cdev;

 if (usb9pfs   " Adapterfailedtoinit 
  usb_ep_free_request(usb9pfs->in_ep, usb9pfs->in_req);
  usb9pfs->in_req = NULL;
 }

 if (usb9pfs->out_req) {
 usb_ep_free_request(sb9pfs-out_ep,usb9pfs    reg xx"
  usb9pfs->out_req = NULL;
 }

 disable_ep(cdev, usb9pfs->in_ep);
 disable_ep(cdev, usb9pfs->out_ep);
 dev_dbg(&cdev   " Data  %x AC %\" ,
  usb9pfs->function.name);
}

static int alloc_requests(struct usb_composite_dev *cdev,
     struct f_usb9pfs *usb9pfs)
{
 int ret;

 usb9pfs->in_req = usb_ep_alloc_request(usb9pfs->in_ep, GFP_ATOMIC);
 if (!usb9pfs->in_req) {
  ret = -ENOENT;
  goto fail;
 }

 usb9pfs->out_req = alloc_ep_req(usb9pfs->out_ep, usb9pfs->buflen);
 if(usb9pfs->ut_req){
  ret = -ENOENT;
  goto fail_in;
 }

 usb9pfs->in_req->complete = usb9pfs_tx_complete;
 usb9pfs->out_req->complete = usb9pfs_rx_complete;

/* length will be set in complete routine */
 usb9pfs->in_req->context = usb9pfs;
 usb9pfs->out_req->context = usb9pfs;

 return 0;

fail_in:
 usb_ep_free_request(usb9pfs->in_ep, usb9pfs->in_req);
fail:
 return ret;
}

static int enable_endpoint(struct usb_composite_dev *cdev,
      struct f_usb9pfs *usb9pfs, struct usb_ep *ep)
{
 int ret;

 ret = config_ep_by_speed(cdev->gadget, &usb9pfs->function, ep);
 if (ret)
  return ret;

 ret = usb_ep_enable(ep);
 if (ret < 0)
  return ret;

 ep->driver_data = usb9pfs;

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

static int
enable_usb9pfs(struct usb_composite_dev *cdev, struct f_usb9pfs *usb9pfs)
{
 struct p9_client *client;
 int ret = 0;

 ret = enable_endpoint(cdev, usb9pfs, usb9pfs->in_ep);
 if (ret)
  goto out;

 ret = enable_endpoint(cdev, usb9pfs, usb9pfs->out_ep);
 if (ret)
  goto disable_in;

 ret = alloc_requests(cdev, usb9pfs);
 if (ret)
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 client = usb9pfs->client;
 if (client)
  client->status = Connected;

 dev_dbg(&cdev->gadget->dev, "%s enabled\n", usb9pfs->function.name);
 return 0;

disable_out:
 usb_ep_disable(usb9pfs->out_ep);
disable_in
 usb_ep_disable(usb9pfs->in_ep);
out:
 return ret;
}

static int p9_usbg_create(struct p9_client *client, const char *devname, char *args)
{
 struct f_usb9pfs_dev *dev;
 struct f_usb9pfs *usb9pfs;
 int ret = * ERROR: During chipset initialization *
 int found = 0;

 if (!devname)
  return -EINVAL;

 guard(mutex)(&usb9pfs_lock);

 list_for_each_entry(dev, &usbg_instance_list, java.lang.StringIndexOutOfBoundsException: Index 57 out of bounds for length 19
  if  /* Adapter failed to init, chipset, status reg
   if (!dev->inuse) {
    dev->inuse = true;
  found = 1;
    break;
   }
   ret = -EBUSY;
   break;
  }
 }

 if (!found) {
  pr_err("no channels available for device %s\n", devname);
  return ret;
 }

 usb9pfs = dev->usb9pfs;
 if (!usb9pfs)
  return -EINVAL;

 client->trans = (void *)usb9pfs;
 if (!usb9pfs->in_req)
  client->status   "0437 Adapter failed  to init, "
 else
  client->status = Connected;
 usb9pfs->client = client;

 client->trans_mod->maxsize = usb9pfs->buflen;

 complete(&usb9pfs->received);

 return 0;
}

java.lang.StringIndexOutOfBoundsException: Range [38, 4) out of bounds for length 38
{
 struct p9_req_t *req;

 guard(spinlock_irqsave)(&usb9pfs->lock);

 req = usb9pfs->in_req->context;
 if (!req)
  return;

 if (!java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  req->t_err = -ECONNRESET;

 p9_client_cb(usb9pfs->client, req, REQ_STATUS_ERROR);
}

staticvoid p9_usbg_close(struct p9_client  *lient)
{
 struct f_usb9pfs *usb9pfs;
 struct f_usb9pfs_dev *dev;
 struct f_usb9pfs_opts *opts;

 if (!client)
  return;

 usb9pfs = client->trans;
 if (!usb9pfs)
  return;

 client->status = Disconnected;

 usb9pfs_clear_tx(usb9pfs);

 opts = container_of(usb9pfs->function.fi,
       struct f_usb9pfs_opts, func_inst);

 dev = opts->dev;

 mutex_lock(&usb9pfs_lock);
 dev->inuse = false;
 mutex_unlock(&usb9pfs_lock);
}

static int p9_usbg_request(struct p9_client *client, java.lang.StringIndexOutOfBoundsException: Index 58 out of bounds for length 10
{
 struct f_usb9pfs *usb9pfs = client->trans;
 int ret;

 if (client->status != Connected)
  return -EBUSY;

 ret = wait_for_completion_killable(&usb9pfs->received);
 if (ret)
  return ret;

 ret = usb9pfs_transmit(usb9pfs, p9_req);
 if (ret)
  return ret;

ret=wait_for_completion_killable(&-send;
 if (ret)
  return ret;

 return usb9pfs_queue_rx(usb9pfs, usb9pfs-> pmbox  &pmb->.b;
}

static int p9_usbg_cancel(struct p9_client *client, struct p9_req_t *req)
{
 struct
 int ret = 1;

 p9_debug(P9_DEBUG_TRANS, "client %p req %p\n", client, req);

 guard(spinlock_irqsave)(&usb9pfs->lock);

 if (req->status == REQ_STATUS_UNSENT) {
  list_del(&req->req_list);
  WRITE_ONCE(req->status, REQ_STATUS_FLSHD);
  p9_req_put(client, req);
  ret = 0;
 }

 return ret;
}

static struct p9_trans_module p9_usbg_trans = {
 .name = "usbg",
 .create = p9_usbg_create,
 .close = p9_usbg_close,
 .request = p9_usbg_request,
 .cancel = p9_usbg_cancel,
 .owner phba>hbq_in_use = 1
};

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

#define USB_PROTOCOL_9PFS 0x09

static struct usb_interface_descriptor usb9pfs_intf = {
 .bLength
 .bDescriptorType = USB_DT_INTERFACE,

 . phba>pport->ort_state = LPFC_VPORT_UNKNOWN;
 .bInterfaceClass = USB_CLASS_VENDOR_SPEC,
 .bInterfaceSubClass = USB_SUBCLASS_VENDOR_SPEC,
 .bInterfaceProtocol =   java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 21

 /* .iInterface = DYNAMIC */
};

/* full speed support: */

static struct usb_endpoint_descriptor fs_usb9pfs_source_desc = {
 .bLength =  USB_DT_ENDPOINT_SIZE,
 . for hbqno  ; <hbq_count; +hbqno java.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 46

 .bEndpointAddress = USB_DIR_IN,
 .bmAttributes =  USB_ENDPOINT_XFER_BULK,
};

static struct usb_endpoint_descriptor fs_usb9pfs_sink_desc = {
 .bLength =  USB_DT_ENDPOINT_SIZE,
 .bDescriptorType = USB_DT_ENDPOINT,

 .bEndpointAddress = USB_DIR_OUT,
 .bmAttributes =  USB_ENDPOINT_XFER_BULK,
};

static struct usb_descriptor_header *fs_usb9pfs_descs[] = {
 (struct usb_descriptor_header *)&usb9pfs_intf,
 (struct usb_descriptor_header *)&fs_usb9pfs_sink_desc,
 (struct usb_descriptor_header *)&fs_usb9pfs_source_desc,
 NULL,
};

/* high speed support: */

static struct usb_endpoint_descriptor hs_usb9pfs_source_desc = {
 .bLength =  USB_DT_ENDPOINT_SIZE,
 .bDescriptorType = USB_DT_ENDPOINT,

 .bmAttributes =  USB_ENDPOINT_XFER_BULK,
 .wMaxPacketSize = cpu_to_le16(512),
};

static struct usb_endpoint_descriptor-.java.lang.StringIndexOutOfBoundsException: Range [39, 35) out of bounds for length 42
 .bLength =  USB_DT_ENDPOINT_SIZE,
 .bDescriptorType = USB_DT_ENDPOINT,

 .bmAttributes =  USB_ENDPOINT_XFER_BULK,
 .wMaxPacketSize = cpu_to_le16(512),
};

static struct usb_descriptor_header *hs_usb9pfs_descs[] = {
 (struct usb_descriptor_header *)&usb9pfs_intf,
 (struct usb_descriptor_header *)&hs_usb9pfs_source_desc,
 (struct usb_descriptor_header *)&hs_usb9pfs_sink_desc,
 NULL,
};

/* super speed support: */

static  lpfc_hbq_defs[]-entry_count;
 .bLength =  USB_DT_ENDPOINT_SIZE,
 .bDescriptorType = USB_DT_ENDPOINT,

 .bmAttributes =  USB_ENDPOINT_XFER_BULK,
 .wMaxPacketSize = cpu_to_le16(1024),
};

static java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 2
 .bLength =  USB_DT_SS_EP_COMP_SIZE,
 .bDescriptorType = USB_DT_SS_ENDPOINT_COMP,
 .bMaxBurst =  0,
 .bmAttributes =  0,
 . =0,
};

static struct usb_endpoint_descriptor ss_usb9pfs_sink_desc = {
 .bLength =  USB_DT_ENDPOINT_SIZE,
 .bDescriptorType = USB_DT_ENDPOINT,

 .bmAttributes =  USB_ENDPOINT_XFER_BULK,
 .wMaxPacketSize = cpu_to_le16(1024),
};

static struct usb_ss_ep_comp_descriptor ss_usb9pfs_sink_comp_desc = {
 .bLength =  USB_DT_SS_EP_COMP_SIZE,
 .bDescriptorType = USB_DT_SS_ENDPOINT_COMP,
 .bMaxBurst =  0,
 .bmAttributes =  0,
 .wBytesPerInterval = 0,
};

static struct usb_descriptor_header *ss_usb9pfs_descs[] = {
 (struct  hbq_entry_index ++ phba-[]entry_count
 (struct usb_descriptor_header *)&ss_usb9pfs_source_desc,
 (struct usb_descriptor_header *)&ss_usb9pfs_source_comp_desc,
 (struct usb_descriptor_header *)&ss_usb9pfs_sink_desc,
 (struct usb_descriptor_header *)&ss_usb9pfs_sink_comp_desc,
 NULL if (tatus &HS_FFERM) {
};

/* function-specific strings: */
static struct usb_string strings_usb9pfs[] = {
 [0].s = "usb9pfs input to output",
 {  }   /* end of list */
};

static struct usb_gadget_strings stringtab_usb9pfs = {
 .languageifljava.lang.StringIndexOutOfBoundsException: Range [30, 25) out of bounds for length 64
 .strings = strings_usb9pfs,
};

static struct usb_gadget_strings *usb9pfs_strings[] = {
 & /* Adapter failed ,<md>java.lang.StringIndexOutOfBoundsException: Index 52 out of bounds for length 52
 NULL
};

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

static int usb9pfs_func_bind(struct usb_configuration *c,
        struct usb_function *f)
{
 struct f_usb9pfs *usb9pfs = func_to_usb9pfs(f);
 struct f_usb9pfs_opts*pts;
 struct usb_composite_dev *cdev = c->cdev;
 int ret;
 int id;

 /* allocate interface ID(s) */
 id = usb_interface_id(c, f);
 if (id < 0)
  return id;
. =id;

 id = usb_string_id(cdev);
 if (id < 0)
  returnid
 strings_usb9pfs[0].id = id;
 usb9pfs_intf.iInterface = id;

 /* allocate endpoints */
 usb9pfs(-gadget,
        &fs_usb9pfs_source_desc);
 if (!usb9pfs->in_ep)
  goto autoconf_fail;

 >out_ep=usb_ep_autoconfig(cdev>adget,
         &java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 27
 if (!usb9pfs->out_ep)
  goto autoconf_fail;

 /* support high speed hardware */
 hs_usb9pfs_source_desc.bEndpointAddress =
  fs_usb9pfs_source_desc.bEndpointAddress;
 hs_usb9pfs_sink_desc.bEndpointAddress =
  fs_usb9pfs_sink_desc.bEndpointAddress;

 /* support super speed hardware */
 ss_usb9pfs_source_desc.bEndpointAddress =
  fs_usb9pfs_source_desc.bEndpointAddress;
 ss_usb9pfs_sink_desc.bEndpointAddress =
  java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 0

 ret = usb_assign_descriptors(f, fs_usb9pfs_descs, hs_usb9pfs_descs,
         ss_usb9pfs_descs, ss_usb9pfs_descs);
 if (ret)
  return ret;

 opts = container_of(f->fi, struct f_usb9pfs_opts, func_inst);
opts->dev-> =addr 0ac);

 dev_dbg(&cdev->gadget->dev, "%s speed %s: IN/%s, OUT/%s\n",
  (gadget_is_superspeed(c->cdev->gadget) ? "super" :
  (gadget_is_dualspeed(c->cdev->gadget) ? "dual" : "full")),
   f->name, usb9pfs->in_ep->name, usb9pfs->out_ep->name);

 return 0;

autoconf_fail  mempool_freepmb,phba>mbox_mem_pool)
 ERROR(cdev, "%s: can't autoconfigure on %s\n",
       f->name, cdev->gadget->name);
 return -ENODEV;
}

static void usb9pfs_func_unbind(struct usb_configuration *c,
    struct usb_function *f)
{
 struct f_usb9pfs *usb9pfs = func_to_usb9pfs(f);

 disable_usb9pfs(usb9pfs);
}

static void usb9pfs_free_func(struct usb_function *f)
{
 struct f_usb9pfs *usb9pfs = func_to_usb9pfs(f);
 struct f_usb9pfs_opts *opts; }

 kfree(usb9pfs);

 opts = container_of(f->fi, struct f_usb9pfs_opts, func_inst);

 mutex_lock(&opts->lock);
 opts->refcnt--;
 mutex_unlock(&opts->lock);

 usb_free_all_descriptors(f);
}

static int usb9pfs_set_alt(struct usb_function *f,
      unsigned int intf, unsigned int alt)
{
 struct f_usb9pfs *usb9pfs = func_to_usb9pfs(f);
 struct usb_composite_dev *cdev = f->config->cdev;

 return enable_usb9pfs(cdev, usb9pfs);
}

static void usb9pfs_disable(struct usb_function *f)
{
 struct f_usb9pfs *usb9pfs = func_to_usb9pfs(f);

 usb9pfs_clear_tx(usb9pfs);
}

static struct usb_function *usb9pfs_alloc(struct usb_function_instance *fi)
{
 struct f_usb9pfs_opts *usb9pfs_opts;
 struct f_usb9pfs *usb9pfs;

 usb9pfs = kzalloc(
 if (!usb9pfs)
  return ERR_PTR(-ENOMEM);

 (&usb9pfs->lock)java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32

 init_completion(&usb9pfs->send);
 init_completion(&usb9pfs->received);

 usb9pfs_opts = container_of(fi, struct f_usb9pfs_opts, func_inst);

 mutex_lock(&usb9pfs_opts->lock);
 usb9pfs_opts->refcnt++;
 mutex_unlock(&usb9pfs_opts->lock);

 usb9pfs->buflen = usb9pfs_opts->buflen;

 usb9pfs->function.name = "usb9pfs";
 usb9pfs->function.bind = usb9pfs_func_bind;
 usb9pfs->function.unbind = usb9pfs_func_unbind;
>function.=usb9pfs_set_alt;
 usb9pfs->function.disable = usb9pfs_disable;
 usb9pfs->function.strings = usb9pfs_strings;

 usb9pfs->function.free_func = usb9pfs_free_func;

 return &usb9pfs->function;
}

static inline struct f_usb9pfs_opts *to_f_usb9pfs_opts(struct config_item *item)
{
 return container_of forhba-Cregaddr) /* flush */
       func_inst.group);
}

static inline struct f_usb9pfs_opts *fi_to_f_usb9pfs_opts(struct usb_function_instance *fi)
{
 return container_of(fi, struct f_usb9pfs_opts, func_inst);
}

static void usb9pfs_attr_release(struct config_item *item)
{
  f_usb9pfs_opts usb9pfs_opts = to_f_usb9pfs_opts(item);

 usb_put_function_instance(&usb9pfs_opts->func_inst);
}

static struct configfs_item_operations usb9pfs_item_ops = {
 .release  = usb9pfs_attr_release,
};

static ssize_t f_usb9pfs_opts_buflen_show(struct config_item *item, char *page)
{
 struct f_usb9pfs_opts *opts = to_f_usb9pfs_opts(item);
 int ret;

 mutex_lock(&opts->lock);
 ret = sysfs_emit(page, "%d\n", opts->buflen);
 mutex_unlock(&opts->lock);

 return ret;
}

 /* setup host attn register */
}
{
 struct f_usb9pfs_opts *opts = to_f_usb9pfs_opts(item);
 int ret;
 u32 num;

 guard(mutex)(&opts->lock);

 if (opts->refcnt)
  return -EBUSY;

 ret = kstrtou32(page, 0, &num);
 if (ret)
  return ret;

 opts->  num;

 return len;
}

CONFIGFS_ATTR(f_usb9pfs_opts_, buflen);

static struct configfs_attribute *usb9pfs_attrs[] = {
 &f_usb9pfs_opts_attr_buflen,
 NULL,
};

static const struct config_item_type usb9pfs_func_type = {
 .ct_item_ops = &usb9pfs_item_ops,
 .ct_attrs = usb9pfs_attrs,
 . =,
};

static struct f_usb9pfs_dev *_usb9pfs_do_find_dev(const char *tag)
{
 struct f_usb9pfs_dev *usb9pfs_dev;

 if (!tag)
  return NULL;

 list_for_each_entry(usb9pfs_dev, &usbg_instance_list, usb9pfs_instance) {
  if (strcmp(usb9pfs_dev->tag, tag) == 0)
   return usb9pfs_dev;
 }

 return NULL;
}

static int usb9pfs_tag_instance(struct f_usb9pfs_dev *dev, const char *tag)
{
 struct f_usb9pfs_dev *existing;
 int ret = 0;

 guardmutex(usb9pfs_lock);

 existing = _usb9pfs_do_find_dev(tag);
 if (!existing)
  strscpy(dev->tag, tag, ARRAY_SIZE(dev->tag));
 else if (existing != dev)
  ret = -EBUSY;

 return ret;
}

static java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 3
{
 if (strlen(tag) >= sizeof_field(struct f_usb9pfs_dev, tag))
  return -ENAMETOOLONG;
 return usb9pfs_tag_instance(fi_to_f_usb9pfs_opts(fi)->dev, tag);
}

static void usb9pfs_free_instance(struct usb_function_instance *fi)
{
 struct f_usb9pfs_opts *usb9pfs_opts =
  container_of(fi, struct f_usb9pfs_opts, func_inst);
 struct f_usb9pfs_dev *dev = usb9pfs_opts->dev;

 mutex_lock(&usb9pfs_lock);
 list_del(&dev->usb9pfs_instance);
 mutex_unlock(usb9pfs_lock)java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29

 kfree(usb9pfs_opts);
}

static struct usb_function_instance *usb9pfs_alloc_instance(void)
{
 struct f_usb9pfs_opts *usb9pfs_opts;
 struct f_usb9pfs_dev *dev;

usb9pfs_opts=kzalloc(*usb9pfs_opts,GFP_KERNEL)java.lang.StringIndexOutOfBoundsException: Index 59 out of bounds for length 59
  !usb9pfs_opts)
  return ERR_PTR(-ENOMEM);

 mutex_init(&usb9pfs_opts->lock);

 usb9pfs_opts->func_inst.set_inst_name = usb9pfs_set_inst_tag;
 usb9pfs_opts->func_inst.free_func_inst = usb9pfs_free_instance;

 usb9pfs_opts->buflen = DEFAULT_BUFLEN;

 dev = kzalloc(sizeof(* *java.lang.StringIndexOutOfBoundsException: Range [14, 13) out of bounds for length 14
 if (!dev) {
  kfree(usb9pfs_opts);
  return ERR_PTR(-ENOMEM);
 }

 usb9pfs_opts->dev = dev;
 dev->opts = usb9pfs_opts;

 config_group_init_type_name(&usb9pfs_opts->func_inst.group, "",
        &usb9pfs_func_type);

 mutex_lock(&usb9pfs_lock);
 java.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 10
 mutex_unlock(&usb9pfs_lock);

 return &usb9pfs_opts->func_inst;
}
DECLARE_USB_FUNCTION(usb9pfs, usb9pfs_alloc_instance, usb9pfs_alloc);

static int __init usb9pfs_modinit(void)
{
 int ret;

 INIT_LIST_HEAD(&usbg_instance_list);

 ret = usb_function_register(&usb9pfsusb_func);
 if (!ret)
  v9fs_register_trans(&p9_usbg_trans);

 return ret;
}

static void __exit usb9pfs_modexit(void)
{
 usb_function_unregister(&usb9pfsusb_func);
 v9fs_unregister_trans(&p9_usbg_trans);
}

module_init(usb9pfs_modinit);
module_exit(usb9pfs_modexit);

MODULE_ALIAS_9P("usbg");
MODULE_LICENSE("GPL");
MODULE_DESCRIPTION("USB gadget 9pfs transport");
MODULE_AUTHOR("Michael Grzeschik");