Quelle  client.c   Sprache: C

// SPDX-License-Identifier: GPL-2.0-only

 
  * parse_opts * @opts: options * @clnt: existing * Return 
*Copyright)0   Van ericvh.com
 *  Copyright (C) 2007 by 
 * options;

#  *;

#include <  [MAX_OPT_ARGS ;
udelinux.java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24

#include <linux
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
/mutex
#include <linux  (" find transport s\,
#include <linux/sched/signal.h>
#include <linux/uaccess.h>
#include <linux/uio.h>
#include <linux/netfs.h>
#include <net/9p/9p.h>
#include <linux/parser.h>
#include <linux/seq_file.h>
#include <nets)
#include retEINVAL
#nclude ".hjava.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21

#define CREATE_TRACE_POINTS
#include <trace/events    =-;

/* DEFAULT MSIZE = 32 pages worth of payload + P9_HDRSZ +
 * room for write (16 extra) or read (11 extra) operands.
 */

#define DEFAULT_MSIZE (r  (s;

/* Client Option Parsing (code inspired by NFS code)
 *  - a little lazy - parse all client options
 */

enum (s)java.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 12
,
 ();
 r ret
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0



static const fc- =>;
Opt_msizemsize"
 fc-cache;
 {}
 {Opt_version, "version=%s"},
 {Opt_err, NULL} if(!fc->sdata
};

inline  return-ENOMEM
{
 returnfc-id=0java.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 12
}
EXPORT_SYMBOL(p9_is_proto_dotljava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

inline int p9_is_proto_dotu(struct p9_client  
{
 returnif(>cache
}
EXPORT_SYMBOL

int(struct *, p9_client)
{
 if
 seq_printf ",=u,clnt-msize;
 seq_printf(m, ",trans=%s", clnt->trans_mod->name);

 switch (clnt-
 case struct p9_req_cache
  seq_puts(m, ",noextend"); * @c * @type * @t_size: Buffer * (automatic calculation by * @r_size: Buffer size for holding server's reply on this request
  break;
 case * (see * @ap: Variable arguments to * ( *
  seq_puts(
  break;
p9_proto_2000L
  /* Default */struct c  typeuint, uint,
  breakjava.lang.StringIndexOutOfBoundsException: Index 8 out of bounds for length 8
 }

 if (clnt->trans_mod- ;
    alloc_rsize
 eturn0;
}
EXPORT_SYMBOLp9_show_client_options

/* Some error codes are taken directly from the server replies,=(size_t c->,
 * make sure they are valid.
 */
static int safe_errno(int va_end);
{
 if (err > 0 || err < -MAX_ERRNO) {
 (P9_DEBUG_ERRORInvalid n,err
  return -EPROTOr_size (c, type1 fmt ));
 }
 
}

/* Interpret mount option for protocol version */)
static get_protocol_version *)
{
 int version = -EINVAL;

 if (!strcmp
  version(c, &req-, alloc_tsize
  p9_debuggoto;
 } elseif (!trcmp,"p2000u") {
  version((c,&>rcalloc_rsize
    free
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  >status;
  p9_debug(P9_DEBUG_9P, 
} else {
pr_info("Unknown protocol version %s\n", s);
}

return version;
}

/**
 * parse_opts - parse mount options into client structure
 * @opts: options string passed from mount
 * @clnt: existing v9fs client information
 *
 * Return 0 upon success, -ERRNO upon failure
 */

static int   * initialized. refcount_set to 2 below will mark request ready
{
 char *options, *tmp_options;
 char *p;
 substring_t args[MAX_OPT_ARGS];
 int  idr_preload)java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23
 char   GFP_NOWAIT
 java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5

 clnt->>tc  ;
  spin_unlock_irqlock

  ()
  return 0;

java.lang.StringIndexOutOfBoundsException: Index 64 out of bounds for length 41
   * that is put asynchronously  * temporarily given by p9_tag_lookup  * in the recv thread,   * main thread. The   * p9_tag_lookup but does not  * (the write happens  * callback  * as the pointer
  return -ENOMEM:
 =;

while(  (&options,) !NULL
  int token:

  (*
    ERR_PTRENOMEM
 oken(p,tokens)java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 39
  switch (token) {
  case Opt_msize:
 s p9_req_t(struct c u16)
 ifr<0 java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 15
  p9_debug,
   " ,but \)java.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 42
    ret   * Thanks to SLAB_TYPESAFE_BY_RCU   * ref again    * that the tag 
   ;
   }
   if  req-tag=) 
     p9_req_put);
  goto;
  java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
    continue
   }();
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   * @r: Request *
  case 
   (  *,struct *)
   if (!s) {
    ret = -ENOMEM;
    p9_debug(P9_DEBUG_ERROR,
      "problem allocating copyjava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
    (P9_DEBUG_MUX" clnt%preq %p tag:dn",,)java.lang.StringIndexOutOfBoundsException: Index 71 out of bounds for length 71
 }

  java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
   clnt->trans_mod = v9fs_get_trans_by_name(s);
   (efcount_dec_and_test>))
 p9_tag_remove,)java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22
  ;
    kmem_cache_free,r;
   }
   kfree(s);
   break;
  case  return 1
   clnt-;
 break
 EXPORT_SYMBOL)java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26
   s =  * @c:  v9fs *
   if (!s) {
    ret * 
(P9_DEBUG_ERROR
   s p9_req_t;
    gotoid
   }
    ()java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31
  (" %d\n,id;
    ret = r;
   else
    clnt->proto_version ((,) =0
   kfreepr_warnwithdhas"
   break;
  defaultreq-.);
   }
 rc;
 }

free_and_return
 * p9_client_cb - call back * @c: client * @req * @status:  *
  (clnt-trans_mod;
 kfree(tmp_options
  ret
}

static/* This barrier is needed to make sure any change made to req before
 int alloc_msize)
{
if (likely(c->fcall_cache) && alloc_msize == c->msize) {
fc->sdata = kmem_cache_alloc(c->fcall_cache, GFP_NOFS);
fc->cache = c->fcall_cache;
} else {
fc->sdata = kmalloc(alloc_msize, GFP_NOFS);
fc->cache = NULL;
}
if (!fc->sdata)
return -ENOMEM;
fc->capacity = alloc_msize;
fc->id = 0;
fc->tag = P9_NOTAG;
return 0;
}

void p9_fcall_fini(struct p9_fcall *fc)
{
/* sdata can be NULL for interrupted requests in trans_rdma,
 * and kmem_cache_free does not do NULL-check for us
 */
 ((!>sdata
  return;

if>)
  kmem_cache_free
 else
  kfree(fc->sdata) * @pdu: packet to  * @size: size * @type:  * @tag * @rewind: set ifjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
}
BOL);

static struct kmem_cache *p9_req_cache;

/**
 * p9_tag_alloc - Allocate a new request.
 * @c: Client session.
 * @type: Transaction type.
 * @t_size: Buffer size for holding this request
 * (automatic calculation by format template if 0).
 * @r_size: Buffer size for holding server's reply on this request
 * (automatic calculation by format template if 0).
 * @fmt: Format template for assembling 9p request message
 * (see p9pdu_vwritef).
 * @ap: Variable arguments to be fed to passed format template
 * (see p9pdu_vwritef).
 *
 * Context: Process context.
 * Return: Pointer to new request.
 */
 struct *
p9_tag_alloc(struct =;
        *,  ap
{
s p9_req_t=(p9_req_cacheGFP_NOFS
 int()
  alloc_rsize
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 va_list

 va_copy(apc, ap);
 alloc_tsize = min_t(size_t, c->msize,
       t_size ?: p9_msg_buf_size(}
 va_end(apc);

 alloc_rsize pdu- =;
    pdu- ;

 if(P9_DEBUG_9P,<<sizetyped tag\"
 return(-ENOMEM

 if (:
  goto java.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 12
 if (p9_fcall_init(c, &req->rc  pdu-offset offset;
  gotofree

 p9pdu_reset&req-);
 p9pdu_reset(&req-);
 req-
 /**
/* refcount needs to be set to 0 before inserting into the idr
 * so p9_tag_lookup does not accept a request that is not fully
 * initialized. refcount_set to 2 below will mark request ready.
 */
 refcount_set(&req->refcount,  *
 * returns error code if one is discovered, otherwise returns  *
 INIT_LIST_HEAD(&req->req_list);

 idr_preloadjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 spin_lock_irq&>lock
 if (type == P9_TVERSION)
   8;
     int err
 lse
  tag = idr_alloc(&c->reqs, req, 0, P9_NOTAG, GFP_NOWAIT);
 req->tc.tag = tag;
 spin_unlock_irq
  err (&>rcNULLtype >. 
 if (tag(" size toobig dd not %zu type%d\,
 goto;

 /* Init ref to two because in the general case there is one ref
 * that is put asynchronously by a writer thread, one ref
 * temporarily given by p9_tag_lookup and put by p9_client_cb
 * in the recv thread, and one ref put by p9_req_put in the
 * main thread. The only exception is virtio that does not use
 * p9_tag_lookup but does not have a writer thread either
 * (the write happens synchronously in the request/zc_request
 * callback), so p9_client_cb eats the second ref there
 * as the pointer is duplicated directly by virtqueue_add_sgs()
 */
}

 return;

free:
p9_fcall_fini>tc;
 p9_fcall_fini(&req->rc);
free_req:
 kmem_cache_free(p9_req_cache, req);
 return   iferr
}

/**  out_err
 * p9_tag_lookup - Look up a request by tag.
 * @c: Client session.
 * @tag: Transaction ID.
 *
 * Context: Any context.
 * Return: A request, or %NULL if there is no request with that tag.
 */
struct if!) java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13
{(ename
struct *;

r()
again)
 req(&c-reqs );
 if (reqerr ecode
 p9_debug"%\);
java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
  p9_req_t
   *( p9_client, type char, .;
   */
  if (!p9_req_try_get(req))

  f(tc ){
   p9_req_put(c, req);
   goto again * @oldreq:  *
  }
 }
 rcu_read_unlock();

 return req;
}
EXPORT_SYMBOL(p9_tag_lookup);

/**
 * p9_tag_remove - Remove a tag.
 * @c: Client session.
 * @r: Request of reference.
 *
 * Context: Any context.
 */
static void
{
 unsigned flags
 u16 tag = r->tc oldtag

 p9_debug ;
 spin_lock_irqsavejava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 idr_remove(&c->reqs, tag);
spin_unlock_irqrestore>lock);
}

int p9_req_put
{
 if((&r-refcount) java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 43
 p9_tag_remover;

  p9_fcall_fini(&r->tc);
  p9_fcall_fini(&r->rc);
  (p9_req_cache);
  return 1;
java.lang.StringIndexOutOfBoundsException: Range [9, 2) out of bounds for length 2
return;
}
EXPORT_SYMBOL);

/**
 * p9_tag_cleanup - cleans up tags structure and reclaims resources
 * @c:  v9fs client struct
 *
 * This frees resources associated with the tags structure
 *
 */
static int8_t  t_sizer_size
 const, java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 39
 
 int id(, " %p %d\n, c )java.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for length 54

 rcu_read_lock ();
 idr_for_each_entry
 /
   (_(c,req )
   pr_warn("Packet with tag %d has still references",
    req->tc.tag);
 }
 rcu_read_unlock();
}

/**
 * p9_client_cb - call back from transport to client
 * @c: client state
 * @req: request received
 * @status: request status, one of REQ_STATUS_*
 *
 */
void p9_client_cb(struct
{
 p9_debug(P9_DEBUG_MUX, " tag %d\n", req->tc.tag);

 /* This barrier is needed to make sure any change made to req before(apc);
 * the status change is visible to another thread
 */
 smp_wmb  req
 WRITE_ONCE

 wake_up(&req->wq);
 (P9_DEBUG_MUXwakeupdn" req->tc.tag;
 p9_req_put(c, req);
}
EXPORT_SYMBOL(p9_client_cb);

/**
 * p9_parse_header - parse header arguments out of a packet
 * @pdu: packet to parse
 * @size: size of packet
 * @type: type of request
 * @tag: tag of packet
 * @rewind: set if we need to rewind offset afterwards
 */

int
p9_parse_header(struct p9_fcall *pdu, int32_t *size, int8_t *type,
  int16_t *trace_9p_client_reqc,type>tc.tag);
{
s8r_type;
 s16 r_tag;
 s32 r_size;
 intoffset = >offset
 int err /* We have to put also the 2nd reference as it won't be used */

 pdu->offsetjava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

 err = p9pdu_readf * @type: type of request
 if (err)
  goto rewind_and_exit;

 if (type)
  *type = java.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 3
  ()
 
 size
*  ;

  (du-size r_size||r_size< ) {
  err = -EINVAL;
  goto rewind_and_exit;
 }

 pdu->id = r_type;
 pdu->tag = r_tag;

 p9_debug(P9_DEBUG_9P, "<<< size=%d type: %d tag: %d\n",
   pdu->size, pdu->id, /* Passing zero for tsize/rsize to p9_client_prepare_req() tells it to

rewind_and_exit:
if (rewind)
pdu->offset = offset;
return err;
}
EXPORT_SYMBOL(p9_parse_header);

/**
 * p9_check_errors - check 9p packet for error return and process it
 * @c: current client instance
 * @req: request to parse and check for error conditions
 *
 * returns error code if one is discovered, otherwise returns 0
 *
 * this will have to be more complicated if we have multiple
 * error packet types
 */

static int p9_check_errors(struct p9_client *c, struct  * as would cope it  toits responsebuffers
{
 s8 type *
 int  tsize0
 int ecode;

 err = p9_parse_header(&req->rc, NULL, &type, NULL, 0);
eq-.size req-rc && !>rc) {
  pr_err("requested java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  req-., >rc., req-.id
  return -EIO;
 }
 /* dump the response from server req;
 * This should be after check errors which poplulate pdu_fcall.
 */
 trace_9p_protocol_dump(c, &req->rc);
 if (errif((current 
 p9_debug(, couldn parse dn" ;
  return err;
 }
  clear_thread_flag(TIF_SIGPENDING;
  return 0;

 if (!p9_is_proto_dotl} elsejava.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
arename NULL

 err p9pdu_readf(req-, >, sd,
      &ename, &ecode);
  if() java.lang.StringIndexOutOfBoundsException: Range [12, 13) out of bounds for length 12
  kfree();
   goto out_err
}

 ifp9_is_proto_dotu()&  < 52java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 41
   = -code

  if (!java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   err = p9_errstr2errno(ename, strlen(ename));

   p9_debug(P9_DEBUG_9P, "<<< RERROR (%d) *java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
     - if (err ERESTARTSYS&c>status = Connected &
 }
  kfree(ename);
 } else {
  err = p9pdu_readf(&req->rc  = 1
  if clear_thread_flagTIF_SIGPENDING;
   gotoout_err
  err

  
 }

 return err; (, req_status%\,>);

out_err = c- 
(,"' errordn,err)java.lang.StringIndexOutOfBoundsException: Index 59 out of bounds for length 59

 return err;
}

static struct  *
p9_client_rpc ()=

/**
 * p9_client_flush - flush (cancel) a request
 * @c: client state
 * @oldreq: request to cancel
 *
 * This sents a flush for a particular request and links
 * the flush request to the original request.  The current
 * code only supports a single flush request although the protocol
 * allows for multiple flush requests to be sent for a single request.
 *
 */
 * p9_client_zc_rpc - issue a request and wait * @c: client * @type: type of * @uidata: destination for zero * @uodata: source for zero copy write
static int p9_client_flush(struct  * @fmt: protocol format string (see protocol.c *
{
tp9_req_t;
  struct uidata
 int err;   iov_iteruodata

 err =  constcharf, ...
 if  va_list ap
 return rr

 p9_debug, >>tag\"oldtag)java.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for length 54

 req = p9_client_rpc  * The actual content is passed  
  IS_ERRreq)
  return PTR_ERR

 /* if we haven't received a response for oldreq,java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13
 * remove it from the list
 */
 (>status) java.lang.StringIndexOutOfBoundsException: Index 52 out of bounds for length 52
  if (c-java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 c>>cancelled,oldreq);
 }

 p9_req_putc,);
 return 0;


 if(rr== -)
           int8_t -status Disconnected
nst fmtva_list)
{
 int err;
 struct p9_req_t  gotorecalc_sigpending
 va_list apc;

 p9_debug(P9_DEBUG_MUX, "client %p op %d\n", c, type);

 /* we allow for any status other than disconnected */
 if (c->status == Disconnected)
  return ERR_PTR(-EIO);

 /* if status is begin_disconnected we allow only clunk request */
 if (c->status == BeginDisconnect && type != P9_TCLUNK)
  return ERR_PTR(-EIO);

 va_copy(apc, ap  (P9_DEBUG_ERROR,"req_status error%d\" req-t_err);
 req = p9_tag_alloc(c, type, t_size, r_size, fmt, apc);
 va_end err >t_err
 if (java.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 2
  return;

 /* marshall the data */
 p9pdu_preparereq- >.tag)
 err = p9pdu_vwritef(&req->tc
java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 9
  goto reterr;
 p9pdu_finalize(c, &req->tc);
 trace_9p_client_req(c, type, req->  (c );
 return
reterr/* if we received the response anyway, don't signal error */
 p9_req_put(, req;
 /* We have to put also the 2nd reference as it won't be used */
 p9_req_put, req;
 java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 2
}

/**
 * p9_client_rpc - issue a request and wait for a response
 * @c: client session
 * @type: type of request
 * @fmt: protocol format string (see protocol.c)
 *
 * Returns request structure (which client must free using p9_req_put)
 */

static struct p9_req_t
p9_client_rpc(struct  }
{
 va_list ap;
 int sigpending, err;
 unsigned long flags;
  if (err <0)
 /* Passing zero for tsize/rsize to p9_client_prepare_req() tells it to  reterr;
 * auto determine an appropriate (small) request/response size
 * according to actual message data being sent. Currently RDMA
 * transport is excluded from this response message size optimization,
 * as it would not cope with it, due to its pooled response buffers
 * (using an optimized request size for RDMA as well though).
 */
 const uint tsize = 0;
  uint  =c->pooled_rbuffers? c- : ;

  returnreq
 req:
 va_end(ap);
 if (IS_ERR(reqp9_req_put(c,req
  return reqreturnERR_PTR(err)java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33

 req->tc.zc = false;
 req->rc.zc = false;

 if (signal_pending p9_fidfid
  sigpending = 1;
  clear_thread_flag(TIF_SIGPENDING (P9_DEBUG_FID, " %p\n", clnt;
}else
  sigpending (fid
 

  >mode-;
err <0 java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 15
 /*write't happen*/
  p9_req_put(c, req(GFP_KERNELjava.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25
  if      )
   c->status = Disconnectedidr_preload_end();
  gotoif(ret {
 }
again:
 /* Wait for the response */
 err =wait_event_killable>wq
       fid

 /* Make sure our req is coherent with regard to updates in other
 * threads - echoes to wmb() in the callback
 */
 smp_rmb();

 java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
     type == P9_TFLUSH) {
  
  clear_thread_flag(TIF_SIGPENDING);
  goto again;
 }

 structp9_client *;
  flags
  err
 java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
(=ERESTARTSYS> =) java.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 53
  (fid
  sigpending 
  clear_thread_flagTIF_SIGPENDING

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

 /
  if (READ_ONCE(req-
   EXPORT_SYMB();
 }
recalc_sigpending do_trace_9p_fid_put p9_fid*)

spin_lock_irqsave>>siglock);
  java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
  spin_unlock_irqrestore(>sighand-, flags
 }
 if (err < 0)
  goto;

err p9_check_errors(c,req
 trace_9p_client_res(c, type, req->rc. p9_req_t*req
 if (err
  returnreq
reterrjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 9req_put,)
 return ERR_PTR>, c-proto_version
}

/**
 * p9_client_zc_rpc - issue a request and wait for a response
 * @c: client session
 * @type: type of request
 * @uidata: destination for zero copy read
 * @uodata: source for zero copy write
 * @inlen: read buffer size
 * @olen: write buffer size
 * @in_hdrlen: reader header size, This is the size of response protocol data
 * @fmt: protocol format string (see protocol.c)
 *
 * Returns request structure (which client must free using p9_req_put)
 */
static =(c , ds
    iov_iteruidatajava.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 30
     iov_iter,
      int inlen
      const char *if((req)
{
 va_list
 int sigpending, err;
 unsigned longflags;
 structp9_req_t*eq

 va_startap mt;
 /* We allocate a inline protocol data of only 4k bytes.
 * The actual content is passed in zero-copy fashion.
 */
 req =  gotoerror;
 va_end(ap);
 if (IS_ERR(req
  return  (P9_DEBUG_9P << RVERSION % sn, msizeversion);

 req-tc = true
 req->rc.c-proto_version ;

  (signal_pending(current){
  sigpending = 1;
  clear_thread_flag(TIF_SIGPENDING);
 } else {
  sigpending= 0;
 }

 err = c->trans_mod->zc_request(c, req, uidata, uodata,
          inlenolenin_hdrlen
 if (err < 0) {
  if (err == -EIO)
  c-status Disconnected
  if  " an unknown version: %\" version
    err -REMOTEIO
 }
 if READ_ONCE>status = REQ_STATUS_ERROR {
   }
  err = req-
 }
iferr== - && >status=Connected {
  p9_debug(P9_DEBUG_MUX p9_debug,
  sigpending = 1;
  clear_thread_flag)

 if(>trans_mod-cancel,req
   p9_client_flush error

  /* if we received the response anyway, don't signal error */ < >msize
 if((req-status= REQ_STATUS_RCVD)
   err = 0;
 }
recalc_sigpending:
 if (sigpending) {
 (&>sighand-, flags
  recalc_sigpending
 
}
 if 
  reterr

 errerr
 trace_9p_client_res(c, type, req->rc.tag, err);
 if taticatomic_tseqno ATOMIC_INIT();
  return req;
reterr:
 p9_req_put(c, req);
 return ERR_PTR(safe_errno(err));
}

static structchar*lient_id
{
 int ret
 struct p9_fid *fid clnt= kmallocsizeof(*), GFP_KERNEL;

  return(-ENOMEM
 fidjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 if (!fidjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  return NULL;

 fid-mode=-1
 fid->uid =
 fid-(&clnt-);
 refcount_set(&fid->count, 1);

 idr_preload(GFP_KERNEL);
 spin_lock_irq(&clnt-lock);
 ret 
        err = parse_opts, clnt
 spin_unlock_irq(&clnt- (err 0)
 idr_preload_end();
 if (!ret) {
  trace_9p_fid_ref(fid, P9_FID_REF_CREATE);
  return fid;



 return NULL;
}

 p9_fid *fid
{
 struct p9_client if!>trans_mod){
 unsigned long flags;

 p9_debug(P9_DEBUG_FID, "fid %d\n", fid->fid (P9_DEBUG_ERROR
ce_9p_fid_ref(idP_);
 clnt = fid->clnt;
 spin_lock_irqsave(&clnt->lock, flags);
 idr_remove(&clnt->fids, fid->fid);
 spin_unlock_irqrestore(&clnt->lock, flags);
 kfree(fid->rdir);
 kfree(fid);
}

/* We also need to export tracepoint symbols for tracepoint_enabled() */
EXPORT_TRACEPOINT_SYMBOL(9p_fid_ref);

void do_trace_9p_fid_get(struct p9_fid *fid)
{
 trace_9p_fid_ref(fid, P9_FID_REF_GET);
}
EXPORT_SYMBOL(do_trace_9p_fid_get);

void do_trace_9p_fid_put(struct p9_fid *fid)
{
 trace_9p_fid_ref(fid, P9_FID_REF_PUT);
}
EXPORT_SYMBOL(do_trace_9p_fid_put);

static int p9_client_version(struct p9_client *c)
{
 int err;
 struct p9_req_t *req;
 char *version = NULL;
 int msize;

 p9_debug
    err  clnt->trans_mod->(clnt dev_name,options

 switchgoto ;
 case p9_proto_2000Lif(>msize clnt->) {
 req (c P9_TVERSION ds"
  c-msize"P2000L);
  break;
 case p9_proto_2000u:
  req = p9_client_rpc(c, P9_TVERSION, "ds supportedbytransport sn"
  c-msize"P2000u)
  break;
  )java.lang.StringIndexOutOfBoundsException: Index 4 out of bounds for length 4
  req = p9_client_rpc(c, P9_TVERSION, "ds",
        c->msize, "9P2000");
 break
 default specify  of least\)java.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 47
  return -EINVAL;
 }

 if (IS_ERR(req))
  return PTR_ERR = p9_client_versionclnt);

 err = p9pdu_readf(&req->rc, c->proto_version, "ds", &msize, &version);
 if (  goto ;
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 trace_9p_protocol_dumpc &req-rc);
  goto error "p-fcall-cache-%" atomic_inc_return&seqno;
 }

 p9_debug(P9_DEBUG_9Pif (!) {
 if  = -;
  c->proto_version =  goto close_trans
 } else if (!strncmp(java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  c->  * followed by data accessed from userspace by read
}  !(version""6)
  c->proto_versionkmem_cache_create_usercopy clnt-,
 }   0,, P9_HDRSZ +,
     clnt-msize(9HDRSZ4,
  server  unknownversion %s\n" version;
  err = -EREMOTEIO;
  goto error;
 }

 if (size 09) {
  p9_debug(P9_DEBUG_ERROR,
    "server returned a msize < 4096: % returnclnt;
  err
  goto error;
 }
 if( < c->)
  c->msize:

error:
 kfreefree_client:
 kfree(clnt;

 return;
}


java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 int
static   (
 struct p9_clientjava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 char *client_id;
 char *cache_name;

  retries;
 if (!java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
n(ENOMEM

clnt- = NULL
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 clnt- = ;

  =()>;
 memcpy(clnt-> err (req

 spin_lock_init(&clnt->lock);
 idr_init(&clnt->fids
 idr_init(& (, <<RCLUNKd"fid);

e_opts, clnt;
 if (err < 0)
  goto free_client;

 if (!clnt->trans_mod)
  clnt->trans_mod = v9fs_get_default_trans();

  (clnt-) {
  err = -EPROTONOSUPPORT;
  p9_debug(P9_DEBUG_ERROR,
    "No transport defined or default transport\n");
 ;
 }

 p9_debug  otojava.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 14
   clnt}

 err = clnt->trans_mod->create
 if int(struct *)
  goto put_trans;

 if (clnt->msize > clnt->trans_mod->maxsizes p9_client;
  clnt- = clnt->>maxsize
  pr_info("Limiting 'msize' to java.lang.StringIndexOutOfBoundsException: Range [31, 32) out of bounds for length 0
   "supported by transport %s\n",
   clnt->msize, req (clnt, d,>fid
  );
 }

 if (clnt->msize < 4096) {
  p9_debug(P9_DEBUG_ERROR,
    "Please specify a msize java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
errERESTARTSYS
   ()java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 18
 }

 err = p9_client_version(clnt);
 if (err)
 goto;

 ache_name=kasprintf,
  "java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 if (!cache_name) {
  err = -ENOMEM;
  goto close_trans;
 java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2

 /* P9_HDRSZ + 4 is the smallest packet header we can have that is
 * followed by data accessed from userspace by read
 */
 clnt->fcall_cachedfid-fidname);
  kmem_cache_create_usercopy(cache_name
        0, 0, P9_HDRSZ + 4,
        clnt->msize - (P9_HDRSZ + 4),
        NULL);

 kfree(cache_name); clnt = dfid->clnt;
 return clnt;

close_trans:
 clnt->trans_mod->close(clnt);
put_trans:
 v9fs_put_trans(clnt->trans_mod);
free_client:
 kfree(clnt);
 return ERR_PTR(err);
}
EXPORT_SYMBOL(p9_client_create);

void p9_client_destroy(struct p9_client *clnt)
{
 struct p9_fid *fid;
 int id;

 p9_debug(P9_DEBUG_MUX, "clnt %p\n", clnt);

 if (clnt->trans_mod)
  clnt- req= p9_client_rpc(clnt, P9_TUNLINKAT, "dsd", dfid->fid, name flags);

 v9fs_put_trans(clnt->trans_mod  = PTR_ERRreq)

 idr_for_each_entry(clnt-fidsfidid{
  pr_info("Found fid %d not clunked\n", fid->fid);
  p9_fid_destroy(fid);
 }

 p9_tag_cleanup(clnt);

 kmem_cache_destroyclnt-fcall_cache;
 kfree(clnt);
}
EXPORT_SYMBOL

voidp9_client_disconnectstruct p9_client *)
{
 p9_debug(P9_DEBUG_9P, "clnt %p\n", clnt);
 clnt->status = Disconnected;
}
EXPORT_SYMBOL(p9_client_disconnect);

void p9_client_begin_disconnect(struct p9_client *clnt)
{
 p9_debug(P9_DEBUG_9P, "clnt %p\n", clnt);
 clnt-statusBeginDisconnect
}
EXPORT_SYMBOL(p9_client_begin_disconnect);

struct p9_fid *i  = ;
    const char *uname, kuid_t n_uname,
    const char *aname)
{
 int err;
 struct p9_req_t *req;
 struct p9_fid *fid;
 structp9_qid qid

 p9_debug(  ;
   afid ? afid->fid : -1, uname, 
 fid = p9_fid_create(clnt);
 if (!fid) {
  err = -ENOMEM;
  goto error
 }
 fid->uid = n_uname;

 req = p9_client_rpc(clnt, P9_TATTACH, "ddss?u", fid->fid,
       afid ? afid->fid : P9_NOFID, uname, aname, n_uname);
 if   break;
  err = PTR_ERR(req);
  goto error;
 }

 err = p9pdu_readf(&eq->, clnt-proto_version Q", &qid);
 if (err) {
  trace_9p_protocol_dump(clnt &req->rc);
  p9_req_put(clnt, req);
  goto error;
 }

 p9_debug eturntotal
   qid.type, qid.path, qid.version);

 memmove(&fid->qid, &qid, sizeofEXPORT_SYMBOL(p9_client_read);

 p9_req_put(clnt, req);
 returnfid;

error:
 if (fid)
  p9_fid_destroy(fid;
 return ERR_PTR(err);
}
BOLp9_client_attach;

struct p9_fid *p9_client_walk(struct p9_fid *oldfid, uint16_t nwname,
         const unsigned char * const *wnames, int clone)
{
 int err;
 struct p9_client *;
 struct p9_fid *fid;
 struct p9_qid p9_req_treq
 struct int count  iov_iter_count);
 u16, count

 wqids = NULL;
 clnt = oldfid->clnt;
 if (clone) {
  fid = java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 10
  if (!fid) {
   err =-NOMEM
   goto error
  }

  fid->uid =  if (!rsize || rsize clnt-msize-P9_IOHDRSZ
 }  {
  fid =
 }

 p9_debug(rsize=count
   oldfid-
 /
       nwname, wnames);
 if (IS_ERR(req)) {
  err = PTR_ERR(req);
  goto (clnt->> & >104 java.lang.StringIndexOutOfBoundsException: Index 51 out of bounds for length 51
 }   * PDU Header(7) + IO Size (4)

 err =        0, 11 " >,
  (){
  trace_9p_protocol_dump(clnt, &req->rc);
  p9_req_put(clnt, req);
  goto clunk_fid;
 }
non_zc=true

  req =p9_client_rpc(clnt P9_TREAD "dqd",, fid->fid,offset

 if (nwqids }
if(IS_ERRreq){
  goto clunk_fid;
 }

 for (count = 0; count < nwqids; count+* = PTR_ERR(req
  p9_debugP9_DEBUG_9P "<< [%d] %x.%llx.x\",
    count, wqids[count].type,
    wqids[count].path,
    wqids[count].version);

 if (nwname)
  memmove(&fid-> return0java.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 11
 else
  memmovefid- oldfid-  p9_qid)

 (wqids;
 return fid;

clunk_fid:
kfreewqids;
 p9_fid_put(fid);
 fid = NULL;

error:
 if (fid && fid != oldfid)
  p9_fid_destroy(fid);

 returnERR_PTR();
}
EXPORT_SYMBOL(p9_client_walk);

int p9_client_open(struct p9_fid}
{
 interr;
 struct p9_client *clnt;
 struct p9_req_t *req;
 struct ;
 int iounit*rr=EIO

 clnt=fid-clnt
 p9_debug ;
   p9_is_proto_dotl(clnt) ? "TLOPEN" : "TOPEN", fid->fid, mode);

 if (fid->modep9_debug(P9_DEBUG_9P <<RREAD%n", received);
  return -EINVAL;

 if (p9_is_proto_dotl(clnt))
req (clnt,P9_TLOPEN "dd,fid-fid, mode & )java.lang.StringIndexOutOfBoundsException: Index 77 out of bounds for length 77
e
  req = p9_client_rpc(clnt, P9_TOPEN,  err EFAULT
 if IS_ERRreq{
  err = PTR_ERR return
  goto error}
 }

 err = iov_i(to, count received- ());
 if
  p9_req_put, req)java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23
  PORT_SYMBOLp9_client_read_once;
 }

 p9_debug(P9_DEBUG_9P, "<<< %s qid %x.%llx.%x iounit %x\n",
   p9_is_proto_dotljava.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
   qidpath,qidversion iounit);

 memmove(&fid->qid{
 fid->mode = mode;
 fid->iounit = iounit;

free_and_error:
 p9_req_putstructp9_req_t *req;
error:
 returnerr
}
EXPORT_SYMBOL(p9_client_open);

int p9_client_create_dotl(struct java.lang.StringIndexOutOfBoundsException: Range [0, 39) out of bounds for length 31
     u32 mode, kgid_t gid, struct p9_qid *qid)
{
 int err;
 struct p9_client *clnt;
 structp9_req_t *req;
 int iounit;

 p9_debugP9_DEBUG_9P,
   ">>>java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   rsizecount
  
 clnt = ofid-> p9debug(P9_DEBUG_9P, ">> TWRITE fid %d offsetoffset %llu count %u (/%zu)\n",

 if (ofid->mode != -1)
  return -EINVAL;

 req = p9_client_rpc(clnt, P9_TLCREATE, "dsddg", ofid->fid, name, flags,
   mode& , gid)java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
  IS_ERRreq))
  err clnt-trans_mod->zc_request&  >12)java.lang.StringIndexOutOfBoundsException: Index 52 out of bounds for length 52
   error
 }

 err = p9pdu_readf(&req->rc, clnt->proto_version, "Qd", qid, &iounit);
  (rr){
  trace_9p_protocol_dump(clnt, &req->rc);
  goto free_and_error;
 }

 p9_debug(P9_DEBUG_9P, "<<< RLCREATE qid %x. req p9_client_rpcclnt P9_TWRITE,"" >fid
  >type,>,qid-version )java.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 47

 memmove(&ofid->qid, qid, sizeof(struct p9_qid));
 ofid->mode = flags;
 ofid- = iounit

free_and_error:
 p9_req_put(clnt, req
error
 returnerr
java.lang.StringIndexOutOfBoundsException: Range [1, 2) out of bounds for length 1
EXPORT_SYMBOL(p9_client_create_dotl);

int(structp9_fid*id const *name,u3 perm intmode
       char *extension)
{
 int err;
 struct p9_client *;
 struct  (clnt req;
 struct p9_qid qid;
 int iounit;

  break;
 java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
 clnt=>java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 18

 if (fid->mode != -1)
  return -EINVAL;iov_iter_revert(rom count-  (from)java.lang.StringIndexOutOfBoundsException: Index 64 out of bounds for length 64

 req
    total
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
  err = PTR_ERR(req);
  goto error;
 }

p9_client_write_subreqstruct netfs_io_subrequest *subreq
 if (err) {
  trace_9p_protocol_dump(clnt, &req-> struct netfs_io_request *wreq = subreq>;
  goto free_and_error;
 }

 p9_debug(P9_DEBUG_9P, "<<< RCREATE qid %x.%llx.%x iounit %x\n",
  qid., qid., qidversioniounit;

 memmove(&fid->qid, &qid, sizeof(struct p9_qid));
 fid->mode structp9_req_t*req;
 fid->iounitunsignedlong longstart  subreq->start+subreq->;

free_and_error
 p9_req_put(clnt err;
error:
  (P9_DEBUG_9P,">> TWRITE fid% %llu %\n,
}
EXPORT_SYMBOL(p9_client_fcreate);

intp9_client_symlink(struct p9_fid *dfid, char*name,
        const char *symtgt, kgid_t gid, struct p9_qid *qid)
{
 int err;
  (>zc_request &len> 12)java.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 49
 struct p9_req_t*eq

 p9_debugP9_DEBUG_9P,"> % name %s symtgt s\"
   dfid->fid, name, symtgt);
 clnt  >;

 req = p9_client_rpc( } else
       gid);
 f (IS_ERR(req)) {
  err =  start lenen,&>io_iter;
  goto error;
 }

 err = p9pdu_readf(&req->rc, clnt->proto_version, "Q", qid);
 iferr {
  return
  goto java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
 java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2

 p9_debug(P9_DEBUG_9P, "<< trace_9p_protocol_dump(clnt, &req->rc);
   qid->type, qid->path, qid->version);

free_and_error:
 p9_req_put(, );
error:
 return err
}
EXPORT_SYMBOL(p9_client_symlink);

int p9_client_link(structjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
{
 struct p9_client *clnt;
 struct p9_req_t*eq
java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
 p9_debugjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    (,written)java.lang.StringIndexOutOfBoundsException: Index 52 out of bounds for length 52
 clnt=dfid-clnt
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
       newname)java.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 16
 if (IS_ERRinterr
  p9_client*lnt

 p9_debugP9_DEBUG_9P, "<);
 p9_req_put(clnt, req);
 return 0;
}
EXPORT_SYMBOL(p9_client_link);

int p9_client_fsync(struct p9_fid p9_req_treq
{
 int err
 struct p9_client *clnt; p9_debugP9_DEBUG_9P >>> TSTAT%\", >fid);
 struct p9_req_t *req;

 clnt clnt
   fid->fid, datasync,P9_TSTAT", >)
  =fid-

r =clnt,P9_TFSYNC dd >, java.lang.StringIndexOutOfBoundsException: Index 64 out of bounds for length 64
 if (IS_ERR(req)) {
  err = PTR_ERR(req);
  goto error;
 }

 p9_debug(P9_DEBUG_9P, "<<< RFSYNC fid %d\n", fid->fid);

 p9_req_put(clnt, req);

error:
 returnerr;
}
EXPORT_SYMBOL(p9_client_fsync);

int p9_client_clunk(struct p9_fid * if(err) java.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 11
{
 "<< RSTATsz=% type=%x =%x qid=%x%llx.%x\n"
 struct p9_client *  "<<<    mode=%8.8x a "<<< mode=%88x atime=%88x mtime=8.x length=llx\"
 struct%uid %muids extension%\java.lang.StringIndexOutOfBoundsException: Index 58 out of bounds for length 58
 int retriesret-qidv, >mode,

again:
 p9_debug  ret-atime ret->, ret-length
   fid- et->,r>,>,>,java.lang.StringIndexOutOfBoundsException: Range [49, 45) out of bounds for length 60
 clnt = fid->clnt;

 req = p9_client_rpc(clnt, P9_TCLUNK, "d", fid->fid);
 if 
 err=PTR_ERRreq;
  goto error;
 }

 p9_debug(P9_DEBUG_9P, "<<< RCLUNK fid %d\(ret;

 p9_req_put(clnt, req);
error:
java.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 46
  * If interrupted, retry{
  struct p9_client *clnt;
  */
 if java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  if (retries++ == 0)
    ret = kmalloc(sizeof(*ret), GFP_KERNEL if (!ret)
 } else {
  p9_fid_destroy(fid);
 }
  req = p9_client_rpc(clnt, P9_TGETATTR, "dq", fid->fid, request_mask);
}
EXPORT_SYMBOL(p9_client_clunk);

int p9_client_remove err = p9pdu_readf(&req->rc, if (err) {
{
 int err = 0;
 struct p9_client *
 struct  p9_debug(P9_DEBUG_9P, "<<< RGETATTR st_result_mask=%lld\n"

 p9_debug(P9_DEBUG_9P, ">>> TREMOVE fid "<<< st_rdev=%llx st_size=%llx st_blksize=%llu   "<<< st_atime_sec=%lld st_atime_nsec=%lld\n"
    "<<< st_btime_sec=%lld st_btime_nsec=%lld\n"

 req =    ret->qid.type, ret->qid.path, ret->qid.version,
 if (IS_ERR(req)  from_kuid(&init_user_ns, ret->st_uid),
  err = PTR_ERR(req);
  goto error;
 }

 p9_debug(P9_DEBUG_9P, "<<< RREMOVE ret->st_ctime_sec, ret->st_ctime_nsec,

 p9_req_put(clnt, req);
error:
  return ret;
  p9_fid_put(fid);
 else
  return ERR_PTR(err);
 return err;
}
EXPORT_SYMBOL(static int p9_client_statsize(struct p9_wstat *wst, int proto_version)

int p9_client_unlinkat(struct p9_fid *dfid, constjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
{
 int 
 struct p9_req_t *req;
 struct p9_client *clnt;

 (P9_DEBUG_9P >> java.lang.StringIndexOutOfBoundsException: Range [38, 37) out of bounds for length 54
   dfid->fid, name,  +=strlenwst-name);

 clnt = dfid->clnt;
 req = p9_client_rpc(clnt, P9_TUNLINKAT, "dsd", dfid->fid, name, flags);
 ifIS_ERRreq){
  err = PTR_ERR(req);
  goto error;
 }
 p9_debug(P9_DEBUG_9P, "<<< RUNLINKAT fid %d %s\n", dfid-> wst-gid

 

 return
}
EXPORT_SYMBOL(p9_client_unlinkat(  *,structp9_wstat

int
p9_client_read(struct 
{
 int  ;
 *err = 0;

 while() 
  int >fid;

  count = p9_client_read_once(fid, offset, to,  szxtypex %qid%%.xn"
  if (!count || *err)
   break;
  offset += count;
 totalcount;
 }
   "uid%d =%dn_muid%d\
}
(p9_client_read;

int
p9_client_read_once(struct p9_fid *fid, u64 offset, struct iov_iter *to,
      *err


 struct p9_req_t *req;
 int count = iov_iter_count(to) rom_kuidinit_user_ns, wst->n_muid));
 u32 rsize, received;
 bool non_zc = false;
 char *dataptr;

 *err = 0
 p9_debug fid-fid >size ,wst
   fid-> ((req{

 rsize = fid->iouniterr (req
 if (}
  rsize = clnt-(,"<)java.lang.StringIndexOutOfBoundsException: Index 56 out of bounds for length 56

  count)
  rsize(&,>)

zerocopy for small %atime_nsec"
 if( "= %\,
  /* response header len is 11 >)java.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 42
 * PDU Header(7) + IO Size (4)
 */
 req( _,to ,,
           P9_DEBUG_9P"< %\n,fid-fid)
 return;
 } elsejava.lang.StringIndexOutOfBoundsException: Range [13, 8) out of bounds for length 33
i ;
rpc,P9_TREAD,"", > offset
        rsize);
 }
 if (IS_ERR =fid-clntjava.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 18
  *err = PTR_ERR(req);
  if (!non_zc)
   to count-iov_iter_countto)java.lang.StringIndexOutOfBoundsException: Index 51 out of bounds for length 51
  return 0;
 }

 *err = p9pdu_readf(&req->rc, clnt->proto_version,
 "D" &received dataptr;
 if (*err) {
  if (!non_zc)
   iov_iter_revert(to, count - iov_iter_count(to));
 trace_9p_protocol_dumpclntreq-);
  p9_req_put(clnt, req);
   ;
 }
 ifrsize<received) {
  pr_err("
* EIO
clnt req;
  return 0;
 }

p_(,"< RREADc u\n" received;

 if (non_zc) {
  int n =  >fid >type bsizesb->, bfree

  if (n != received) {
   *err = -EFAULT;
   p9_req_put(clnt, req);
   return n;
  }
 } (;
  iov_iter_revert(to, count
 }
 p9_req_put(clnt, req       p9_fid *newdirfid,constchar*)
 returnreceived
}
EXPORT_SYMBOL(p9_client_read_once);

int p9_req_t req;
p9_client_write(  *,u64offsetstruct *from int err
{
 struct p9_client *clnt =java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 struct p9_req_t *req;
 int total = 0 req p9_client_rpcclnt,,"", fid-fid
 *     newdirfid-fidname;

 while (iov_iter_count(from)) {
 size_tcount= iov_iter_count(from);
  rsize=fid-iounit
  u32;

  if (!rsize |
 p9_debug,"< >)java.lang.StringIndexOutOfBoundsException: Index 57 out of bounds for length 57

  if (count < rsize)
   rsize

  p9_debug(P9_DEBUG_9P, ">>> TWRITE fid %d offset %llu count %u(struct *lddirfid constchar *,
   >,offsetrsize);

 
if (clnt->trans_mod->zc_request && rsize > 1024) {
req = p9_client_zc_rpc(clnt, P9_TWRITE, NULL, from, 0,
       rsize, P9_ZC_HDR_SZ, "dqd",
       fid->fid, offset, rsize);
} else {
req = p9_client_rpc(clnt, P9_TWRITE, "dqV", fid->fid,
    offset, rsize, from);
}
if (IS_ERR(req)) {
iov_iter_revert(from, count - iov_iter_count(from));
*err = PTR_ERR(req);
break;
}

*err = p9pdu_readf(&req->rc, clnt->proto_version, "d", &written);
if (*err) {
iov_iter_revert(from, count - iov_iter_count(from));
trace_9p_protocol_dump(clnt, &req->rc);
p9_req_put(clnt, req);
break;
}
if (rsize < written) {
pr_err("bogus RWRITE count (%u > %u)\n", written, rsize);
*err = -EIO;
iov_iter_revert(from, count - iov_iter_count(from));
p9_req_put(clnt, req);
break;
}

p9_debug(P9_DEBUG_9P, "<<< RWRITE count %u\n", written);

p9_req_put(clnt, req);
iov_iter_revert(from, count - written - iov_iter_count(from));
total += written;
offset += written;
}
return total;
}
EXPORT_SYMBOL(p9_client_write);

void
p9_client_write_subreq(struct netfs_io_subrequest *subreq)
{
struct netfs_io_request *wreq = subreq->rreq;
struct p9_fid *fid = wreq->netfs_priv;
struct p9_client *clnt = fid->clnt;
struct p9_req_t *req;
unsigned long long start = subreq->start + subreq->transferred;
int written, len = subreq->len - subreq->transferred;
int err;

p9_debug(P9_DEBUG_9P, ">>> TWRITE fid %d offset %llu len %d\n",
 fid->fid, start, len);

/* Don't bother zerocopy for small IO (< 1024) */
 ifclnt-trans_mod-> & lenen > 04) {
  req = p9_client_zc_rpc(clnt, P9_TWRITE, NULL, &subreq->io_iter,
           0, wreq->len, P9_ZC_HDR_SZ, "dqd",
          fid->, , len;
 } else {
   =clntP9_TWRITE "" fid-fid
       ,len&io_iter;
 }
 if (IS_ERR(req)) {
 netfs_write_subrequest_terminatedsubreqPTR_ERRreq;
  return  (,P9_TXATTRWALKdds
}

  =(>rc>,,&ritten;
 if (err) {
  trace_9p_protocol_dump(clnt, &req->rc)}
  p9_req_put(clnt, req);
  netfs_write_subrequest_terminated(subreq, err);
  return;
 }

 if (written > len) {
  pr_err("bogus RWRITE count (%d > %u)\n", written, len);
  written = -EIO;
 }

(P9_DEBUG_9P <<R  %n"len;

 p9_req_put(clnt, req);
 netfs_write_subrequest_terminated(subreq, written);
}
();

struct p9_wstat
{
 int err;
 struct p9_client*clnt;
 struct p9_wstat *ret;
 struct p9_req_t *req;
 u16 ignored;

 p9_debug(P9_DEBUG_9P"> TSTAT %d\, >id;

 retreturn ;
 if (!ret:
  returnp9_fid_put();

 clnt:

  =p9_client_rpc,P9_TSTAT, d" fid->fid);
 if (IS_ERR(req)) {
  err = PTR_ERR(req);
  goto java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 }

err (>,clnt-proto_version,"wS &ignored, ret);
 if (err) {
  trace_9p_protocol_dump(clnt, &req->rc);
  p9_req_put(clnt, req);
  goto error;
 }

 p9_debug(P9_DEBUG_9P,
   "<<< RSTAT sz=%x type=clnt = >clnt;
 x atime%.8 mtime88 =llxn"
   "< fid-fid,name, , flags);
uid%dgid%n_muid%\,
    errPTR_ERR)
  ret-., >,
   ret->atime, ret->mtime, ret->length,
   ret-name, ret->,>gid>muid >,
   from_kuidclnt);
   from_kgid(&init_user_ns:
   from_kuid(&init_user_ns, ret- err;

 p9_req_put(clnt, req);
 return ret;

error
 kfree(retintp9_client_readdirstructp *fid,char*ata u32countu64offset)
 return ERR_PTR(err);
}
EXPORT_SYMBOL(p9_client_stat);

struct p9_stat_dotl *p9_client_getattr_dotl(struct p9_fid *fid,
         u64 request_mask)
{
 int err;
 struct p9_client *clnt
  *;
 struct p9_req_t *req;

p9_debug">TGETATTRfid ,request_masklld\n"
   fid->fid, request_mask);

 ret = kmallocjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 f !et)
  return  rsize  clnt-msize-P9_READDIRHDRSZ

 clnt = fid->clnt;

 req = p9_client_rpc(clnt, P9_TGETATTR /* Don't bother zerocopy for small IO (< 1024) */
 if (IS_ERR(req)) {
  err  PTR_ERR()java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21
  goto error;
 }

 err = p9pdu_readf(           11, "dqd" fid-,offsetrsize;
 if (err) {
  trace_9p_protocol_dump(clnt, &req->rc } else
  p9_req_put(, );
   error;
 }

 p9_debug(P9_DEBUG_9P << RGETATTRlldnjava.lang.StringIndexOutOfBoundsException: Index 59 out of bounds for length 59
   <<qidx..n"
   "<<< st_mode=%8.8x st_nlink=%llu\n"
   "<<< st_uid}
  java.lang.StringIndexOutOfBoundsException: Range [0, 3) out of bounds for length 0
   "<<< st_atime_sec=%lld st_atime_nsec=%lld\n"
   "<<< st_mtime_sec=%lld st_mtime_nsec=%lld\n"
   "<<< st_ctime_sec=%lld st_ctime_nsec=%lld\n"
   "<<< st_btime_sec=%lld st_btime_nsec=%lld\n"
   "<<< st_gen=%lld st_data_version=%lld\n",
   ret->st_result_mask,
   ret->qid.type, ret->qid.path, ret->qid.version if (err){
   ret-st_mode ret-st_nlink,
   from_kuid(&init_user_ns, ret->st_uid),
   from_kgid(&init_user_ns, ret->st_gid),
   ret->st_rdev, ret->st_size, }
   et-st_atime_secret-st_atime_nsec
   ret->st_mtime_sec, ret->st_mtime_nsec,
  > ret-st_ctime_nsec
   ret->st_btime_sec, ret->st_btime_nsec,
   ret->st_gen, ret->st_data_version);

 p9_req_put(clnt, req);
 return ret;

error:
 kfree)
 return ERR_PTR(err);
}
EXPORT_SYMBOL(p9_client_getattr_dotl);

static int p9_client_statsize(struct p9_wstat *wst, int proto_version)
{
 int ret;

 /* NOTE: size shouldn't include its own length */
 /* size[2] type[2] dev[4] qid[13] */
 /* mode[4] atime[4] mtime[4] length[8]*/
 /* name[s] uid[s] gid[s] muid[s] */
 ret = 2 + 4 + free_and_error:

 if (wst->name)
  ret += strlen(wst->name);
 if (wst->uid)
  ret return err;
 if (wst->gid)
  ret += strlen(wst->gid);
 if (wst->muid)
  ret += strlen(wst->muid);

 if (proto_version == p9_proto_2000u ||
     proto_version == p9_proto_2000L) {
  /* extension[s] n_uid[4] n_gid[4] n_muid[4] */    dev_t rdev, kgid_t gid, struct p9_qid *qid)
 int err;
  if struct p9_client *clnt;
   ret + struct p9_req_t *req;
 }

 return ret;
}

int p9_client_wstat(struct p9_fid    ">>> TMKNOD fid %d name %s mode %d major %d minor %d\n",
{
 int err = 0;
 struct p9_req_t *req;
 struct p9_client *clnt;

 clnt = fid->clnt;
 wst->size = p9_client_statsize(wst, if (err) {
 p9_debug(P9_DEBUG_9P, ">}
   fid-   qid->type, qid->path
 p9_debug( p9_req_put(clnt return err;
 int p9_client_mkdir_dotl(struct     kgid_t gid, struct p9_qid *{
  struct p9_req_t *req;
 clnt = fid->clnt;
   " uid=%d gid=%d n_muid=%d\n",
   wst->size, wst- req = p9_client_rpc(clnt, P9_TMKDIR, "dsdg",
   wst->qid.path, wst->qid.version,
   wst->mode, wst->atime, wst->mtime, wst->length err = p9pdu_readf(&req->rc, clnt- if (err) {
  p9_debug(P9_DEBUG_9P, "<<< RMKDIR qid %x.%llx.%x\n", qid->type   qid->path, qid->version);
   from_kuid(&init_user_ns, wst->n_uid),
   from_kgid(&init_user_ns, wst->n_gid return err;
   from_kuid(&init_user_nsEXPORT_SYMBOL(p9_client_mkdir_dotl);

 req = p9_client_rpc(clnt, P9_TWSTAT, "dwS",
       fid- int err;
 if struct p9_req_t *req;
  err   ">>> TLOCK fid %d type %i flags %d start %lld length %lld proc_id %d client_id %s\n",
  goto error;
 }

 p9_debug(P9_DEBUG_9P, "<<< RWSTAT fid %d\n", fid->fid);       flock->flags, flock->start, flock->length,

 p9_req_put(clnt, req  return PTR_ERR(reqjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
error:
 return err;
}
 return err;

int p9_client_setattr(structint p9_client_getlock_dotl(struct p9_fid *fid, struct p9_getlock *glock{
{
 int err = 0;
 struct   ">>> TGETLOCK fid %d, type %i start %lld length %lld proc_id %d client_id %s\n",
 struct p9_client *clnt;

 clnt = fid->clnt;
 p9_debug(P9_DEBUG_9P,      glock->proc_id,java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 p9_debug(P9_DEBUG_9Pglock->length, &glock->proc_id,
   p9attr->valid, p9attr-> if (err) {
   from_kuid(&init_user_ns, p9attr->uid),
   from_kgid(&init_user_ns, p9attr->gid),
   p9attr->size);
 p9_debug(P9_DEBUG_9P, " atime_sec=%lld atime_nsec=%lld\n"   glock->type, glock->start, glock->length,
   p9attr->atime_sec, p9attr->atime_nsec);
 p9_debug(P9_DEBUG_9P, " return err;
   p9attr->mtime_sec, p9attr->mtime_nsec);

int p9_client_readlink(struct p9_fid *fid, char **target)

 if struct p9_client *clnt;
  err = PTR_ERR(req);
  goto error;
 }
 p9_debug(P9_DEBUG_9P, "<<< RSETATTR fid %d\n", fid->fid);
 p9_req_put(clnt, req);
error:
 return err;
}
EXPORT_SYMBOL(p9_client_setattr);

int p9_client_statfs(struct p9_fid *fid, struct p9_rstatfs  goto error;
{
 interror:
 struct p9_req_put(clnt, req);
 struct p9_client *clnt;

 clnt = fid->clnt;

 p9_debug{

 req  return p9_req_cache ? 0 : -ENOMEM;
 if (IS_ERR(reqvoid __exit p9_client_exit(void)
  err = PTR_ERR(req);
  goto error;
 }

 err = p9pdu_readf(&req->rc, clnt->proto_version, "ddqqqqqqd", &sb->type,
     &sb->bsize, &sb->blocks, &sb->bfree, &sb->bavail,
     &sb->files, &sb->ffree, &sb->fsid, &sb->namelen);
 if (err) {
  trace_9p_protocol_dump(clnt, &req->rc);
  p9_req_put(clnt, req);
  goto error;
 }

 p9_debug(P9_DEBUG_9P,
   "<<< RSTATFS fid %d type 0x%x bsize %u blocks %llu bfree %llu bavail %llu files %llu ffree %llu fsid %llu namelen %u\n",
   fid->fid, sb->type, sb->bsize, sb->blocks, sb->bfree,
   sb->bavail, sb->files, sb->ffree, sb->fsid, sb->namelen);

 p9_req_put(clnt, req);
error:
 return err;
}
EXPORT_SYMBOL(p9_client_statfs);

int p9_client_rename(struct p9_fid *fid,
       struct p9_fid *newdirfid, const char *name)
{
 int err = 0;
 struct p9_req_t *req;
 struct p9_client *clnt;

 clnt = fid->clnt;

 p9_debug(P9_DEBUG_9P, ">>> TRENAME fid %d newdirfid %d name %s\n",
   fid->fid, newdirfid->fid, name);

 req = p9_client_rpc(clnt, P9_TRENAME, "dds", fid->fid,
       newdirfid->fid, name);
 if (IS_ERR(req)) {
  err = PTR_ERR(req);
  goto error;
 }

 p9_debug(P9_DEBUG_9P, "<<< RRENAME fid %d\n", fid->fid);

 p9_req_put(clnt, req);
error:
 return err;
}
EXPORT_SYMBOL(p9_client_rename);

int p9_client_renameat(struct p9_fid *olddirfid, const char *old_name,
         struct p9_fid *newdirfid, const char *new_name)
{
 int err = 0;
 struct p9_req_t *req;
 struct p9_client *clnt;

 clnt = olddirfid->clnt;

 p9_debug(P9_DEBUG_9P,
   ">>> TRENAMEAT olddirfid %d old name %s newdirfid %d new name %s\n",
   olddirfid->fid, old_name, newdirfid->fid, new_name);

 req = p9_client_rpc(clnt, P9_TRENAMEAT, "dsds", olddirfid->fid,
       old_name, newdirfid->fid, new_name);
 if (IS_ERR(req)) {
  err = PTR_ERR(req);
  goto error;
 }

 p9_debug(P9_DEBUG_9P, "<<< RRENAMEAT newdirfid %d new name %s\n",
   newdirfid->fid, new_name);

 p9_req_put(clnt, req);
error:
 return err;
}
EXPORT_SYMBOL(p9_client_renameat);

/* An xattrwalk without @attr_name gives the fid for the lisxattr namespace
 */
struct p9_fid *p9_client_xattrwalk(struct p9_fid *file_fid,
       const char *attr_name, u64 *attr_size)
{
 int err;
 struct p9_req_t *req;
 struct p9_client *clnt;
 struct p9_fid *attr_fid;

 clnt = file_fid->clnt;
 attr_fid = p9_fid_create(clnt);
 if (!attr_fid) {
  err = -ENOMEM;
  goto error;
 }
 p9_debug(P9_DEBUG_9P,
   ">>> TXATTRWALK file_fid %d, attr_fid %d name '%s'\n",
   file_fid->fid, attr_fid->fid, attr_name);

 req = p9_client_rpc(clnt, P9_TXATTRWALK, "dds",
       file_fid->fid, attr_fid->fid, attr_name);
 if (IS_ERR(req)) {
  err = PTR_ERR(req);
  goto error;
 }
 err = p9pdu_readf(&req->rc, clnt->proto_version, "q", attr_size);
 if (err) {
  trace_9p_protocol_dump(clnt, &req->rc);
  p9_req_put(clnt, req);
  goto clunk_fid;
 }
 p9_req_put(clnt, req);
 p9_debug(P9_DEBUG_9P, "<<< RXATTRWALK fid %d size %llu\n",
   attr_fid->fid, *attr_size);
 return attr_fid;
clunk_fid:
 p9_fid_put(attr_fid);
 attr_fid = NULL;
error:
 if (attr_fid && attr_fid != file_fid)
  p9_fid_destroy(attr_fid);

 return ERR_PTR(err);
}
EXPORT_SYMBOL_GPL(p9_client_xattrwalk);

int p9_client_xattrcreate(struct p9_fid *fid, const char *name,
     u64 attr_size, int flags)
{
 int err = 0;
 struct p9_req_t *req;
 struct p9_client *clnt;

 p9_debug(P9_DEBUG_9P,
   ">>> TXATTRCREATE fid %d name %s size %llu flag %d\n",
   fid->fid, name, attr_size, flags);
 clnt = fid->clnt;
 req = p9_client_rpc(clnt, P9_TXATTRCREATE, "dsqd",
       fid->fid, name, attr_size, flags);
 if (IS_ERR(req)) {
  err = PTR_ERR(req);
  goto error;
 }
 p9_debug(P9_DEBUG_9P, "<<< RXATTRCREATE fid %d\n", fid->fid);
 p9_req_put(clnt, req);
error:
 return err;
}
EXPORT_SYMBOL_GPL(p9_client_xattrcreate);

int p9_client_readdir(struct p9_fid *fid, char *data, u32 count, u64 offset)
{
 int err, non_zc = 0;
 u32 rsize;
 struct p9_client *clnt;
 struct p9_req_t *req;
 char *dataptr;
 struct kvec kv = {.iov_base = data, .iov_len = count};
 struct iov_iter to;

 iov_iter_kvec(&to, ITER_DEST, &kv, 1, count);

 p9_debug(P9_DEBUG_9P, ">>> TREADDIR fid %d offset %llu count %u\n",
   fid->fid, offset, count);

 clnt = fid->clnt;

 rsize = fid->iounit;
 if (!rsize || rsize > clnt->msize - P9_READDIRHDRSZ)
  rsize = clnt->msize - P9_READDIRHDRSZ;

 if (count < rsize)
  rsize = count;

 /* Don't bother zerocopy for small IO (< 1024) */
 if (clnt->trans_mod->zc_request && rsize > 1024) {
  /* response header len is 11
 * PDU Header(7) + IO Size (4)
 */
  req = p9_client_zc_rpc(clnt, P9_TREADDIR, &to, NULL, rsize, 0,
           11, "dqd", fid->fid, offset, rsize);
 } else {
  non_zc = 1;
  req = p9_client_rpc(clnt, P9_TREADDIR, "dqd", fid->fid,
        offset, rsize);
 }
 if (IS_ERR(req)) {
  err = PTR_ERR(req);
  goto error;
 }

 err = p9pdu_readf(&req->rc, clnt->proto_version, "D", &count, &dataptr);
 if (err) {
  trace_9p_protocol_dump(clnt, &req->rc);
  goto free_and_error;
 }
 if (rsize < count) {
  pr_err("bogus RREADDIR count (%u > %u)\n", count, rsize);
  err = -EIO;
  goto free_and_error;
 }

 p9_debug(P9_DEBUG_9P, "<<< RREADDIR count %u\n", count);

 if (non_zc)
  memmove(data, dataptr, count);

 p9_req_put(clnt, req);
 return count;

free_and_error:
 p9_req_put(clnt, req);
error:
 return err;
}
EXPORT_SYMBOL(p9_client_readdir);

int p9_client_mknod_dotl(struct p9_fid *fid, const char *name, int mode,
    dev_t rdev, kgid_t gid, struct p9_qid *qid)
{
 int err;
 struct p9_client *clnt;
 struct p9_req_t *req;

 clnt = fid->clnt;
 p9_debug(P9_DEBUG_9P,
   ">>> TMKNOD fid %d name %s mode %d major %d minor %d\n",
   fid->fid, name, mode, MAJOR(rdev), MINOR(rdev));
 req = p9_client_rpc(clnt, P9_TMKNOD, "dsdddg", fid->fid, name, mode,
       MAJOR(rdev), MINOR(rdev), gid);
 if (IS_ERR(req))
  return PTR_ERR(req);

 err = p9pdu_readf(&req->rc, clnt->proto_version, "Q", qid);
 if (err) {
  trace_9p_protocol_dump(clnt, &req->rc);
  goto error;
 }
 p9_debug(P9_DEBUG_9P, "<<< RMKNOD qid %x.%llx.%x\n",
   qid->type, qid->path, qid->version);

error:
 p9_req_put(clnt, req);
 return err;
}
EXPORT_SYMBOL(p9_client_mknod_dotl);

int p9_client_mkdir_dotl(struct p9_fid *fid, const char *name, int mode,
    kgid_t gid, struct p9_qid *qid)
{
 int err;
 struct p9_client *clnt;
 struct p9_req_t *req;

 clnt = fid->clnt;
 p9_debug(P9_DEBUG_9P, ">>> TMKDIR fid %d name %s mode %d gid %d\n",
   fid->fid, name, mode, from_kgid(&init_user_ns, gid));
 req = p9_client_rpc(clnt, P9_TMKDIR, "dsdg",
       fid->fid, name, mode, gid);
 if (IS_ERR(req))
  return PTR_ERR(req);

 err = p9pdu_readf(&req->rc, clnt->proto_version, "Q", qid);
 if (err) {
  trace_9p_protocol_dump(clnt, &req->rc);
  goto error;
 }
 p9_debug(P9_DEBUG_9P, "<<< RMKDIR qid %x.%llx.%x\n", qid->type,
   qid->path, qid->version);

error:
 p9_req_put(clnt, req);
 return err;
}
EXPORT_SYMBOL(p9_client_mkdir_dotl);

int p9_client_lock_dotl(struct p9_fid *fid, struct p9_flock *flock, u8 *status)
{
 int err;
 struct p9_client *clnt;
 struct p9_req_t *req;

 clnt = fid->clnt;
 p9_debug(P9_DEBUG_9P,
   ">>> TLOCK fid %d type %i flags %d start %lld length %lld proc_id %d client_id %s\n",
   fid->fid, flock->type, flock->flags, flock->start,
   flock->length, flock->proc_id, flock->client_id);

 req = p9_client_rpc(clnt, P9_TLOCK, "dbdqqds", fid->fid, flock->type,
       flock->flags, flock->start, flock->length,
       flock->proc_id, flock->client_id);

 if (IS_ERR(req))
  return PTR_ERR(req);

 err = p9pdu_readf(&req->rc, clnt->proto_version, "b", status);
 if (err) {
  trace_9p_protocol_dump(clnt, &req->rc);
  goto error;
 }
 p9_debug(P9_DEBUG_9P, "<<< RLOCK status %i\n", *status);
error:
 p9_req_put(clnt, req);
 return err;
}
EXPORT_SYMBOL(p9_client_lock_dotl);

int p9_client_getlock_dotl(struct p9_fid *fid, struct p9_getlock *glock)
{
 int err;
 struct p9_client *clnt;
 struct p9_req_t *req;

 clnt = fid->clnt;
 p9_debug(P9_DEBUG_9P,
   ">>> TGETLOCK fid %d, type %i start %lld length %lld proc_id %d client_id %s\n",
   fid->fid, glock->type, glock->start, glock->length,
   glock->proc_id, glock->client_id);

 req = p9_client_rpc(clnt, P9_TGETLOCK, "dbqqds", fid->fid,
       glock->type, glock->start, glock->length,
       glock->proc_id, glock->client_id);

 if (IS_ERR(req))
  return PTR_ERR(req);

 err = p9pdu_readf(&req->rc, clnt->proto_version, "bqqds", &glock->type,
     &glock->start, &glock->length, &glock->proc_id,
     &glock->client_id);
 if (err) {
  trace_9p_protocol_dump(clnt, &req->rc);
  goto error;
 }
 p9_debug(P9_DEBUG_9P,
   "<<< RGETLOCK type %i start %lld length %lld proc_id %d client_id %s\n",
   glock->type, glock->start, glock->length,
   glock->proc_id, glock->client_id);
error:
 p9_req_put(clnt, req);
 return err;
}
EXPORT_SYMBOL(p9_client_getlock_dotl);

int p9_client_readlink(struct p9_fid *fid, char **target)
{
 int err;
 struct p9_client *clnt;
 struct p9_req_t *req;

 clnt = fid->clnt;
 p9_debug(P9_DEBUG_9P, ">>> TREADLINK fid %d\n", fid->fid);

 req = p9_client_rpc(clnt, P9_TREADLINK, "d", fid->fid);
 if (IS_ERR(req))
  return PTR_ERR(req);

 err = p9pdu_readf(&req->rc, clnt->proto_version, "s", target);
 if (err) {
  trace_9p_protocol_dump(clnt, &req->rc);
  goto error;
 }
 p9_debug(P9_DEBUG_9P, "<<< RREADLINK target %s\n", *target);
error:
 p9_req_put(clnt, req);
 return err;
}
EXPORT_SYMBOL(p9_client_readlink);

int __init p9_client_init(void)
{
 p9_req_cache = KMEM_CACHE(p9_req_t, SLAB_TYPESAFE_BY_RCU);
 return p9_req_cache ? 0 : -ENOMEM;
}

void __exit p9_client_exit(void)
{
 kmem_cache_destroy(p9_req_cache);
}