Quelle  client.c   Sprache: C

// SPDX-License-Identifier: GPL-2.0-only
/*
 * 9P Client
 *
 *  Copyright (C) 2008 by Eric Van Hensbergen <ericvh@gmail.com>
 *  Copyright (C) 2007 by Latchesar Ionkov <lucho@ionkov.net>
 */

#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt

#include <linux/module.h>
#include <linux/errno.h>
#include <linux/fs.h>
#include <linux/poll.h>
#include <linux/idr.h>
#include <linux/mutex.h>
#include <linux/slab.h>
#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 <net/9p/client.h>
#include <net/9p/transport.h>
#include "protocol.h"

#define CREATE_TRACE_POINTS
#include <trace/events/9p.h>

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

#define DEFAULT_MSIZE ((128 * 1024) + P9_IOHDRSZ)

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

enum {
 Opt_msize,
 Opt_trans,
 Opt_legacy,
 Opt_version,
 Opt_err,
};

static const match_table_t tokens = {
 {Opt_msize, "msize=%u"},
 {Opt_legacy, "noextend"},
 {Opt_trans, "trans=%s"},
 {Opt_version, "version=%s"},
 {Opt_err, NULL},
};

inline int p9_is_proto_dotl(struct p9_client *clnt)
{
 return clnt->proto_version == p9_proto_2000L;
}
EXPORT_SYMBOL(p9_is_proto_dotl);

inline int p9_is_proto_dotu(struct p9_client *clnt)
{
 return clnt->proto_version == p9_proto_2000u;
}
EXPORT_SYMBOL(p9_is_proto_dotu);

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

 switch (clnt->proto_version) {
 case p9_proto_legacy:
  seq_puts(m, ",noextend");
  break;
 case p9_proto_2000u:
  seq_puts(m, ",version=9p2000.u");
  break;
 case p9_proto_2000L:
  /* Default */
  break;
 }

 if (clnt->trans_mod->show_options)
  return clnt->trans_mod->show_options(m, clnt);
 return 0;
}
EXPORT_SYMBOL(p9_show_client_options);

/* Some error codes are taken directly from the server replies,
 * make sure they are valid.
 */
static int safe_errno(int err)
{
 if (err > 0 || err < -MAX_ERRNO) {
  p9_debug(P9_DEBUG_ERROR, "Invalid error code %d\n", err);
  return -EPROTO;
 }
 return err;
}

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

 if (!strcmp(s, "9p2000")) {
  version = p9_proto_legacy;
  p9_debug(P9_DEBUG_9P, "Protocol version: Legacy\n");
 } else if (!strcmp(s, "9p2000.u")) {
  version = p9_proto_2000u;
  p9_debug(P9_DEBUG_9P, "Protocol version: 9P2000.u\n");
 } else if (!strcmp(s, "9p2000.L")) {
  version = p9_proto_2000L;
  p9_debug(P9_DEBUG_9P, "Protocol version: 9P2000.L\n");
 } else {
  pr_info// SPDX-License-Identifier: GPL-2.0-only
 }

 return/*
}

/**
 * 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 parse_opts(char *opts, struct    (C)208 byEric Hensbergen <ericvh@gmailcom>
{
char*options, *tmp_options
 charchar *p
substring_targs];
 intoption
 char *s;
 int ude <linux/errno.h>

 clnt->proto_version = p9_proto_2000L;
 clnt->msize = DEFAULT_MSIZE;

 if (!opts)
  return 0;

 tmp_options = kstrdup(opts, GFP_KERNEL);
 if (!tmp_options)
  return -ENOMEM;
 options = tmp_options;

 while ((p = strsep(&options, ",")) != NULL) {
  int token, r;

  if (!*p)
   continue;
  token = match_token(p, tokens, args);
  switch (token) {
  case Opt_msize:
   r = match_int(&args[0], &option);
   if (r < 0) {
    p9_debug(P9_DEBUG_ERROR,
      "integer field, but no integer?\n");
    ret = r;
    continue;
   }
   if (option < 4096) {
    p9_debug(P9_DEBUG_ERROR,
      "msize should be at least 4k\n");
    ret = -EINVAL;
    continue;
   }
   clnt->msize = option;
   break;
  case Opt_trans:
   s = match_strdup(&args[0]);
   if (!s) {
    ret = -ENOMEM;
    p9_debug(P9_DEBUG_ERROR,
      "problem allocating copy of trans arg\n");
    goto free_and_return;
   }

   v9fs_put_trans(clnt->trans_mod);
   clnt->trans_mod = v9fs_get_trans_by_name(s);
   if (!#include <linux.h>
  pr_infoCouldnot request:%n"java.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 53
     s)
    ret = -EINVAL;
 #nclude protocol"
   kfree(s);
   break;
  case Opt_legacy:
   clnt->proto_version = p9_proto_legacy;
   break;
  case Opt_version:
   s = match_strdup(&args[0]);
   java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   ret ENOMEM
    p9_debug(java.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 0
      "problem * room for write (16 extra) or read (11 extra) operands.
    */
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  r=get_protocol_versions)java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31
   if (r < 0)
    ret = r;
   else
    clnt->proto_version
   kfree;
   break;
  default:
   continue;
  }
 }

free_and_return:
 if (ret)
  Opt_msize
 kfreetmp_options
 eturn;
}

static int p9_fcall_init(struct p9_client *c, struct p9_fcall *fc,
    int alloc_msize)
{
 };
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  fc->cache c-fcall_cache
 } else {
 {, "msize=%u",
  fc-> = NULL
 java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
 fc-);
 ;
 fc->
 >  ;
 fc->tag = P9_NOTAG;
 return 0;
}

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

 if (c-)
  kmem_cache_free(fc->
 else
  kfree p9_show_client_options seq_filem struct *clnt
}
 seq_printf(m, "msize%u" >)java.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 42

static kmem_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.
 */
static:
p9_tag_alloc( p9_client*,int8_t,  t_size r_size
       const char *fmt, va_list;
{
 struct p9_req_t *req = kmem_cache_alloc(p9_req_cache, GFP_NOFS}
 intalloc_tsize
int;
return 0;
 va_listEXPORT_SYMBOL();

 /
 alloc_tsize  min_t, c-msize
       t_size ?: p9_msg_buf_size(c, * make sure they are valid 
 va_end(apcjava.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13

 alloc_rsize = p9_debug, " error code%d\" );
        ?:p9_msg_buf_size + ,fmt,ap;

 if (!req
  return static int(char*

call_init>tc))
   free_req  ifs(s 9."
 if p9_fcall_init req-, ))
 goto;

 p9pdu_reset(&req->tc);
 p9pdu_reset(&req->rc);
 req->t_err = 0;
req- = REQ_STATUS_ALLOC
 /* refcount needs to be set to 0 before inserting into the idr  pr_info("Unknown protocol version %s\n", s);
 * 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, 0);
 init_waitqueue_head(&req->wq);
 INIT_LIST_HEAD(&req->req_listjava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

 idr_preload(GFP_NOFS;
 spin_lock_irq(&c->lock);
 if (type == P9_TVERSION)
  tag = idr_alloc(&c->reqs, req, P9_NOTAG, P9_NOTAG + 1,
   GFP_NOWAIT);
 else
  tag = idr_alloc(&c->reqs, req, 0, P9_NOTAG,
req-.tag=tag
 (&c->);
 idr_preload_end();
 if
  gotoif(opts

 /* 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()
 */
 refcount_set(&req->refcount, 2);

 return req;

free
  options=tmp_options
 while (p=strsep, "")! ) {
free_req
   if!*)
returnERR_PTR(-);
}t = match_tokenp, , args;

/**
 * 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.
 */
truct *p9_tag_lookup p9_client*c, u16 tag
{
 struct   if (r < 0){

 rcu_read_lock();
again:
 req  p9_debug(P9_DEBUG_ERROR
 if   "integerfield,but no integer?n";
  /* We have to be careful with the req found under rcu_read_lock
 * Thanks to SLAB_TYPESAFE_BY_RCU we can safely try to get the
 * ref again without corrupting other data, then check again
 * that the tag matches once we have the ref
 */
  if (!p9_req_try_get(req))
   goto again continue
  if(>tc.tag !=tag{
  (c, req
  goto again
 }
 }
 rcu_read_unlock();

 return req;
}
EXPORT_SYMBOLp9_tag_lookup

/**
 * p9_tag_remove - Remove a tag.
 * @c: Client session.
 * @r: Request of reference.
 *
 * Context: Any context.
 */
staticvoidp9_tag_removestructp9_client*, struct p9_req_trjava.lang.StringIndexOutOfBoundsException: Index 66 out of bounds for length 66
{
 unsigned long flags;
 u16 tag = r->tc.tag;

p9_debugP9_DEBUG_MUX, freeing % reqp tag %\n, c r tag;
 spin_lock_irqsave(&c->lock, flags);
 idr_remove(&c->  
 spin_unlock_irqrestore(&c->lock, flags);
}

int p9_req_put(struct p9_client *c, struct p9_req_t *r)
{
 if((&r->refcount {
 p9_tag_remove(c, r;

  p9_fcall_fini(&r->tc);
  p9_fcall_fini(&r->rc   s)
 kmem_cache_free(p9_req_cache r)java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35
 ;
 }
 return 0
} break;
(p9_req_put;

/**
 * p9_tag_cleanup - cleans up tags structure and reclaims resources
 * @c:  v9fs client struct
 *
 * This frees resources associated with the tags structure
 *
 */
p9_debug,
{
 truct *req
 int id;

 rcu_read_lock r=get_protocol_versions;
 idr_for_each_entry(&c->reqs, req, id) {
 pr_infoTag still in usen" )java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 39
  if(p9_req_putc req = )
   ("Packet tag % still references,
    req->tctag
 }
 u_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_client v9fs_put_transclnt->trans_mod);
{
  return;

 /* This barrier is needed to make sure any change made to req before
 * the status change is visible to another thread
 */
 smp_wmb( if (likely(c->fcall_cache) && alloc_msize == c->  fc->sdata = kmem_cache_alloc(c->fcall_cache,  fc->cache } else   fc->sdata = kmalloc(alloc_msize  fc- }
 WRITE_ONCE(req->status,{

 wake_up(&req->wq);
 p9_debug(P9_DEBUG_MUX, "wakeup: %d\n", req->tc.tag);
 p9_req_put(c, req) if(nlikelyfc-sdata))
}
EXPORT_SYMBOL(  (fc-cache

/**
 * 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 *tag, int rewind)
{
 s8 r_type(p9_fcall_finijava.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29
 s16
 s32 * p9_tag_alloc - Allocate a new request.
 int offset = pdu->offset;
 int err;

 pdu->offset = 0;

 err = p9pdu_readf(pdu, 0, "dbw * (automatic calculation by format template if 0).
 if (err)
  goto * (see p9pdu_vwritef * @ap: Variable arguments to be fed to passed * (see p9pdu_vwritef *

 if (typestaticstruct p9_req_t
  *type r_type
       constcharfmtva_list)
  *tag =  truct *req  kmem_cache_allocp9_req_cache, );
 if size
  *intalloc_rsize;

 if (pdu->size != r_size || r_size < 7) {
  err = -EINVAL apc;
  goto java.lang.StringIndexOutOfBoundsException: Range [0, 22) out of bounds for length 18
 java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2

 pdu->id r_type
>tag =r_tag

 p9_debugP9_DEBUG_9P,"< =%d : %d tag: %dn,
   pdu->  ERR_PTR);

rewind_and_exit
 if (rewind)
 > =offset
 return ;
} (>tc
arse_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(c-);
{
s type
;
 intejava.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5

= p9_parse_headerreq-, , &, NULL, 0);
 if (req->rc.size > req->rc.capacity &&!req-rc.c) {
  pr_errrequestedpacketsize :%d oes fit%zu(=%)n"
         req->rc.size, req->rc.capacity, req->rc goto free
  return -EIO;
 }
 /* dump the response from server
 * This should be after check errors which poplulate pdu_fcall.
 */
 trace_9p_protocol_dump(c, &req->rc);
 if (err) {
  p9_debug(P9_DEBUG_ERROR  * main thread. The only exception is virtio  * p9_tag_lookup but does not have a writer  * (the write happens synchronously in the request/zc_request
  return  *
 }
 ifreturn req
  return 0;

 if (!p9_is_proto_dotl(c)) {
  char *ename = NULL;

  err = p9pdu_readf(&req->rc, c->proto_version, "s?d",
    (&req-tc)java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25
   () {
   kfree(ename
  goto;
  }

  if (p9_is_proto_dotu(c)  * @c * @tag *
   err = -ecode;

   (!rr {
   err = p9_errstr2errno(ename, strlen(ename));

   p9_debug(P9_DEBUG_9P, "<<< RERROR (%d) %s\n",
     -ecode, ename);
  }
  kfreeename);
 }   p9_req_treq
  err = p9pdu_readf cu_read_lock;
  if (err
   goto out_err = idr_find&c->reqs, tag
  err =-;

  p9_debug(P9_DEBUG_9P, "<< RLERROR (d)\", -ecode
 }

 return err;

out_err:
 p9_debug(P9_DEBUG_ERROR, "couldn't parse error%d\n", err);

 return err;
}

staticstruct p9_req_t *
p9_client_rpcstructp9_client *c int8_ttype, constchar *fmt ..)java.lang.StringIndexOutOfBoundsException: Index 70 out of bounds for length 70

/**i (eq->.tag !=tag {
 * 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.
 *
 */

static ext:  *
{
 struct long;
 s16;
 interr

 err = p9_parse_header(&oldreq->tc, NULL, NULL, &oldtag, 1);
 if ( (&c-, flags
  return err;

 p9_debug refcount_dec_and_test>refcount){

 req = p9_client_rpc(c, P9_TFLUSH, "w",   (c, r)java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22
 if ( kmem_cache_freep9_req_cache, r);
  return 

 /* if we haven't received a response for oldreq,
 * remove it from the list
 */
 if (READ_ONCE(oldreq->status)  return 0
  ifEXPORT_SYMBOL(p9_req_put
   
 }

 p9_req_put(c, req);
 return 0;
}

static struct p9_req_t *p9_client_prepare_req(struct p9_client *c,
           type, uint, uint ,
           char *fmt va_list ap)
{
 int err;
 struct p9_req_t *req;
 va_list apc;

 p9_debugP9_DEBUG_MUXclient op" ,type;

 /* we allow for any status other than disconnected */
 if (c->status
  returnERR_PTR-EIO

 /* if status is begin_disconnected we allow only clunk request */if(9req_put ) ==0java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 30
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  return  * @status: request  *

 va_copy(java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 req = p9_tag_alloc(c
 va_endjava.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13
 if (IS_ERR(req)
 return;

 /* marshall the data */
 p9pdu_preparep9_debug, ": %\,req-tc.)
 err}
 if (err
  goto reterr;
 p9pdu_finalize(c, &req->tc * @size:  * @type:  * @tag * @rewind: set if java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 ( , req-tag
 return  r_type
reterr:
 p9_req_put offsetpdu-;
/
 p9_req_put(c, req);
 return
}

/**
 * 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_rpcif (ag
{
 if (size)
 int  *ize=r_size
 unsignedif(du-> != r_size | <7 java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 41
 struct p9_req_t *
java.lang.StringIndexOutOfBoundsException: Index 71 out of bounds for length 71
 returnjava.lang.StringIndexOutOfBoundsException: Range [0, 8) out of bounds for length 1
  * accordingest to parse and check for *
  * transport is excluded  * error packet typesjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 * it not with,dueto  pooledresponse buffers
  * (using an optimized request size{
 *
 constuint = ;
 const>rc >req->.capacity&req-.zc

 va_start(ap, fmt);
 req = p9_client_prepare_req(c, type, tsize, rsize, fmt, ap);
 va_end(ap       >rcsizereq-rccapacity>rc);
 if (}
  returnreq

 req->tc.zc = false;
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

  signal_pending)){
  sigpending p9_debugP9_DEBUG_ERROR"'tparse header%\,err)java.lang.StringIndexOutOfBoundsException: Index 62 out of bounds for length 62
clear_thread_flag()java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36
 }  {
  sigpending = 0;
 }

 err * =;
 if (err  =p9pdu_readf(&>rcc-proto_version"?"
  /* write won't happen */ err{
  p9_req_put(c, req);
  if (err kfreeename
   c->status = Disconnected;
  goto recalc_sigpending;
   }
again:
 /* Wait for the response */  (p9_is_proto_dotuc &ecode1)
 err = wait_event_killable(req->wq,
       err-;

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

 ==- & -status=Connected&
  java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
 sigpending;
 ();
  goto ;
 }

 if (
 p9_debugP9_DEBUG_ERROR " error d\" req-t_err;
  err = req-
 }
 if(err = -ERESTARTSYS&& c->status == Connected){
  p9_debugP9_DEBUG_ERROR, couldnt parse%\" err);
  sigpending = 1;
  clear_thread_flag(TIF_SIGPENDING);

  if (c->trans_mod->cancel(c, req))
   p9_client_flush(c, reqjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

  /* if we received the response anyway, don't signal error */ p9_req_t*
  if (READ_ONCE(eq->status = REQ_STATUS_RCVD)
   err = 0/**
}
recalc_sigpending:
if (sigpending) {
spin_lock_irqsave(¤t->sighand->siglock, flags);
recalc_sigpending();
spin_unlock_irqrestore(¤t->sighand->siglock, flags);
}
if (err < 0)
goto reterr;

err = p9_check_errors(c, req);
trace_9p_client_res(c, type, req->rc.tag, err);
if (!err)
return req;
reterr:
p9_req_put(c, req);
return ERR_PTR(safe_errno(err));
}

/**
 * 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 p9_req_t *req
     struct iov_iter*,
      structiov_iter *,
      int inlen, int 
    const  *mt..)
{
va_list;
  returne;
 unsigned long flags(P9_DEBUG_9P"> TFLUSH %dn, ;
 struct p9_req_t *req;

 va_start(ap, fmt);
 /* We allocate a inline protocol data of only 4k bytes.
 * The actual content is passed in zero-copy fashion.
 */
 req = p9_client_prepare_reqif(IS_ERR(req)

 if (IS_ERR(
  return req;

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

 if (signal_pending(current)) {
  sigpending  *
   if(READ_ONCEoldreq-) == REQ_STATUS_SENT{
 } else {
  sigpending = 0;
 }

 err = c->trans_mod->zc_request(c  -trans_mod-(c oldreq
           inlen(c,req
 if }
  ( = -EIO
  c> =;
  if (err !=  char*,  ap
   ;
 }
 if java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
p9_debug req_status dn,>t_errjava.lang.StringIndexOutOfBoundsException: Index 64 out of bounds for length 64
  =req-;
 }
 if (err == -ERESTARTSYS && c->status req
  p9_debug(P9_DEBUG_MUX, "(&>tc,req-tc., type;

  clear_thread_flag

  if (c-gotoreterrjava.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 14
  p9_client_flush,req

  /* if we received the response anyway, don't signal error */
c )java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 20
  (c)
 }
recalc_sigpending:
 if (sigpending
  java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 3
  recalc_sigpending();
  spin_unlock_irqrestore(&static  *
java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
iferr )
 goto

 err = p9_check_errors(c,  * according to actual   * transport is excluded from  * as it would not cope  * (using an optimized
 trace_9p_client_res(c, type, req->rc.tag, err);
 if (constuintrsize >trans_mod- ?>msize0
 return ;
reterr
 p9_req_put,);
  (safe_errno);
}

static struct p9_fid
{
 int
 struct *;

p9_debug,clnt")
    {
 if!)
}

 fid- = 1
  if ( ) {
 fid->clnt = clnt;
 refcount_set * won  

 idr_preload);
 spin_lock_irq(&clnt->lock);
 ret = idr_alloc_u32(&clnt->fids, fid, &fid->fid, P9_NOFID - 1,
      GFP_NOWAIT;
 spin_unlock_irq(&clnt->lock);
 idr_preload_end;
  () java.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 12
  trace_9p_fid_ref err (req-,
rn;
 }

 kfree(fid  * threads - echoes to wmb(  
 return
}

static void p9_fid_destroy(struct p9_fid *fid)
java.lang.StringIndexOutOfBoundsException: Range [2, 1) out of bounds for length 1
 struct p9_client *clnt
 unsignedlongflags;

 p9_debug}
 trace_9p_fid_ref(fid, P9_FID_REF_DESTROY);
 clnt = fid->clnt;
 spin_lock_irqsave(&clnt->lock, flags);
  if err == - && c-status= Connected {
 spin_unlock_irqrestore(&clnt->lock, flags);
 kfree(fid->rdir);
 kfreefid);
}

/* We also need to export tracepoint symbols for tracepoint_enabled() */();
EXPORT_TRACEPOINT_SYMBOL9);

void do_trace_9p_fid_get(struct p9_fid *fid)
{
 trace_9p_fid_ref /* if we received the response anyway, don't signal error */
}
OLdo_trace_9p_fid_get

void(struct p9_fid *fid
{
 trace_9p_fid_ref  spin_lock_irqsave(¤t-sighand-, flags
}
EXPORT_SYMBOL(do_trace_9p_fid_put);

static int p9_client_version(struct   spin_unlock_irqrestore¤t->siglock);
{  reterr
 int   =p9_check_errors );
struct *;
 charif!)
 int msize ;

 p9_debug(P9_DEBUG_9P, ">>> TVERSION msize %d protocol %d\p_req_put(c,req;
   c-msize>);

 switch (c-
 case p9_proto_2000L:
  req = p9_client_rpc(c, P9_TVERSION, "ds",
        c->msize,  * @uidata: destination for zero copy read
  break;
 case p9_proto_2000u:
  req = p9_client_rpc(c, P9_TVERSION, "ds",
        c->msize, * @fmt: protocol format string (see protocol *
  break;
 case *
  req=p9_client_rpc,P9_TVERSION"",
     struct *uidata,
  break;
 default:
  return  struct *uodata
 }

 if IS_ERR))
  return PTR_ERR(req);

 err = p9pdu_readf  flags
 if (err  *;
  p9_debug(,f)java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 19
  trace_9p_protocol_dump(c,
   error
 }

p9_debug," , version
 if>.zc;
 > =p9_proto_2000L
 ifsignal_pending))java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31
  c- =0
 } java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  c->proto_version =        , , );
 } else {
  p9_debug(P9_DEBUG_ERROR > = ;
  "serverreturnedan unknownversion: sn, );
  =-;
  goto error((req-)= ){
}

 if (  ( ==ERESTARTSYSc- = ){
 (P9_DEBUG_ERROR
    "server returned a msize < (TIF_SIGPENDING;
  err  c->(c ))
  goto;
 }
 if (msizec-)
  c->msize =   READ_ONCE>) =REQ_STATUS_RCVD

error:
 spin_lock_irqsavecurrent->siglock);
 p9_req_put();

 return }
}

struct p9_client goto;
{
 int err;
s   =0java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 40
 struct
  *;
 char *cache_name

   (sizeofclnt)
 if (!clnt)
 ERR_PTR);

 clnt->trans_mod = NULL;
 clnt->trans = NULL;
 clnt->fcall_cache = NULL;

 client_id = utsname()->nodename;
 memcpy(clnt->  ;

 spin_lock_init>lock
 idr_init(&clnt->fids);
 idr_init(&clnt->reqs(>lock

(options);
 if <0java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13
  goto free_client

 if (!clnt->trans_mod)
  clnt->trans_mod = static void p9_fid_destroy(struct*)

  (!clnt-trans_mod)java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
  err = -java.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 0
 p9_debug,
    ce_9p_fid_ref(, 9FID_REF_DESTROY
  goto free_client;
 }

 p9_debug(P9_DEBUG_MUX, "clnt %p trans %p msize %d protocol %d\n",
   java.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 49

=clnt-create,dev_name );
 if
  gotoput_trans

 if clnt- >>trans_mod-maxsize
  clnt-  =p9_client_rpc,,",
      >, 9."java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 30
 " %\,
   clnt->msize, clnt-      >, 9.";
  ;
 }

 if (clnt->msize < 4096) {
  ;
ase amsize at 4k\";
  err = -EINVAL;
  goto close_transreturn -EINVAL
 }

 err(clnt
 if java.lang.StringIndexOutOfBoundsException: Range [4, 5) out of bounds for length 0
 gotoclose_trans

 cache_name = kasprintf (,&>rc
 9%"(&seqno))java.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 50
  (cache_name
 errENOMEM
 goto;
 }

 /* P9_HDRSZ + 4 is the smallest packet header we can have that is
 * followed by data accessed from userspace by read
 */
 clnt->fcall_cache =  elseif(strncmpversion, "P2000, )){
  (cache_name,>msize
     ,0 P9_HDRSZ+ 4
      lnt-> - (_ + )
  " returnedanunknown :n,)java.lang.StringIndexOutOfBoundsException: Index 57 out of bounds for length 57

 kfree( <46 java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 20
 ;

close_trans:
 clnt- msizemsize
put_trans
 v9fs_put_transerror
free_client
kfree);
 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->trans_mod->close(clnt);

 v9fs_put_trans(clnt->trans_mod);

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

 p9_tag_cleanup(clnt);

 kmem_cache_destroy(clnt->fcall_cache);
 kfree(clnt);
}
EXPORT_SYMBOL(p9_client_destroy);

void p9_client_disconnect(struct p9_client *clnt)
{
 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->status = BeginDisconnect;
}
EXPORT_SYMBOL(p9_client_begin_disconnect);

struct p9_fid *p9_client_attach(struct p9_client *clnt, struct p9_fid *afid,
    const char *uname, kuid_t n_uname,
    const char *aname)
{
 int err;
 struct p9_req_t *req;
 struct p9_fid *fid;
 struct p9_qid qid;

 p9_debug(P9_DEBUG_9P, ">>> TATTACH afid %d uname %s aname %s\n",
   afid ? afid->fid : -1, uname, aname);
 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 (IS_ERR(req)) {
  err = PTR_ERR(req);
  goto error;
 }

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

 p9_debug(P9_DEBUG_9P, "<<< RATTACH qid %x.%llx.%x\n",
   qid.type, qid.path, qid.version);

 memmove(&fid->qid, &qid, sizeof(struct p9_qid));

 p9_req_put(clnt, req);
 return fid;

error:
 if (fid)
  p9_fid_destroy(fid);
 return ERR_PTR(err);
}
EXPORT_SYMBOL(p9_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 *clnt;
 struct p9_fid *fid;
 struct p9_qid *wqids;
 struct p9_req_t *req;
 u16 nwqids, count;

 wqids = NULL;
 clnt = oldfid->clnt;
 if (clone) {
  fid = p9_fid_create(clnt);
  if (!fid) {
   err = -ENOMEM;
   goto error;
  }

  fid->uid = oldfid->uid;
 } else {
  fid = oldfid;
 }

 p9_debug(P9_DEBUG_9P, ">>> TWALK fids %d,%d nwname %ud wname[0] %s\n",
   oldfid->fid, fid->fid, nwname, wnames ? wnames[0] : NULL);
 req = p9_client_rpc(clnt, P9_TWALK, "ddT", oldfid->fid, fid->fid,
       nwname, wnames);
 if (IS_ERR(req)) {
  err = PTR_ERR(req);
  goto error;
 }

 err = p9pdu_readf(&req->rc, clnt->proto_version, "R", &nwqids, &wqids);
 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, "<<< RWALK nwqid %d:\n", nwqids);

 if (nwqids != nwname) {
  err = -ENOENT;
  goto clunk_fid;
 }

 for (count = 0; count < nwqids; count++)
  p9_debug(P9_DEBUG_9P, "<<< [%d] %x.%llx.%x\n",
    count, wqids[count].type,
    wqids[count].path,
    wqids[count].version);

 if (nwname)
  memmove(&fid->qid, &wqids[nwqids - 1], sizeof(struct p9_qid));
 else
  memmove(&fid->qid, &oldfid->qid, sizeof(struct p9_qid));

 kfree(wqids);
 return fid;

clunk_fid:
 kfree(wqids);
 p9_fid_put(fid);
 fid = NULL;

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

 return ERR_PTR(err);
}
EXPORT_SYMBOL(p9_client_walk);

int p9_client_open(struct p9_fid *fid, int mode)
{
 int err;
 struct p9_client *clnt;
 struct p9_req_t *req;
 struct p9_qid qid;
 int iounit;

 clnt = fid->clnt;
 p9_debug(P9_DEBUG_9P, ">>> %s fid %d mode %d\n",
   p9_is_proto_dotl(clnt) ? "TLOPEN" : "TOPEN", fid->fid, mode);

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

 if (p9_is_proto_dotl(clnt))
  req = p9_client_rpc(clnt, P9_TLOPEN, "dd", fid->fid, mode & P9L_MODE_MASK);
 else
  req = p9_client_rpc(clnt, P9_TOPEN, "db", fid->fid, mode & P9L_MODE_MASK);
 if (IS_ERR(req)) {
  err = PTR_ERR(req);
  goto error;
 }

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

 p9_debug(P9_DEBUG_9P, "<<< %s qid %x.%llx.%x iounit %x\n",
   p9_is_proto_dotl(clnt) ? "RLOPEN" : "ROPEN",  qid.type,
   qid.path, qid.version, iounit);

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

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

int p9_client_create_dotl(struct p9_fid *ofid, const char *name, u32 flags,
     u32 mode, kgid_t gid, struct p9_qid *qid)
{
 int err;
 struct p9_client *clnt;
 struct p9_req_t *req;
 int iounit;

 p9_debug(P9_DEBUG_9P,
   ">>> TLCREATE fid %d name %s flags %d mode %d gid %d\n",
   ofid->fid, name, flags, mode,
   from_kgid(&init_user_ns, gid));
 clnt = ofid->clnt;

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

 req = p9_client_rpc(clnt, P9_TLCREATE, "dsddg", ofid->fid, name, flags,
       mode & P9L_MODE_MASK, gid);
 if (IS_ERR(req)) {
  err = PTR_ERR(req);
  goto error;
 }

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

 p9_debug(P9_DEBUG_9P, "<<< RLCREATE qid %x.%llx.%x iounit %x\n",
   qid->type, qid->path, qid->version, iounit);

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

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

int p9_client_fcreate(struct p9_fid *fid, const char *name, u32 perm, int mode,
       char *extension)
{
 int err;
 struct p9_client *clnt;
 struct p9_req_t *req;
 struct p9_qid qid;
 int iounit;

 p9_debug(P9_DEBUG_9P, ">>> TCREATE fid %d name %s perm %d mode %d\n",
   fid->fid, name, perm, mode);
 clnt = fid->clnt;

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

 req = p9_client_rpc(clnt, P9_TCREATE, "dsdb?s", fid->fid, name, perm,
       mode & P9L_MODE_MASK, extension);
 if (IS_ERR(req)) {
  err = PTR_ERR(req);
  goto error;
 }

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

 p9_debug(P9_DEBUG_9P, "<<< RCREATE qid %x.%llx.%x iounit %x\n",
   qid.type, qid.path, qid.version, iounit);

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

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

int p9_client_symlink(struct p9_fid *dfid, const char *name,
        const char *symtgt, kgid_t gid, struct p9_qid *qid)
{
 int err;
 struct p9_client *clnt;
 struct p9_req_t *req;

 p9_debug(P9_DEBUG_9P, ">>> TSYMLINK dfid %d name %s symtgt %s\n",
   dfid->fid, name, symtgt);
 clnt = dfid->clnt;

 req = p9_client_rpc(clnt, P9_TSYMLINK, "dssg", dfid->fid, name, symtgt,
       gid);
 if (IS_ERR(req)) {
  err = PTR_ERR(req);
  goto error;
 }

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

 p9_debug(P9_DEBUG_9P, "<<< RSYMLINK qid %x.%llx.%x\n",
   qid->type, qid->path, qid->version);

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

int p9_client_link(struct p9_fid *dfid, struct p9_fid *oldfid, const char *newname)
{
 struct p9_client *clnt;
 struct p9_req_t *req;

 p9_debug(P9_DEBUG_9P, ">>> TLINK dfid %d oldfid %d newname %s\n",
   dfid->fid, oldfid->fid, newname);
 clnt = dfid->clnt;
 req = p9_client_rpc(clnt, P9_TLINK, "dds", dfid->fid, oldfid->fid,
       newname);
 if (IS_ERR(req))
  return PTR_ERR(req);

 p9_debug(P9_DEBUG_9P, "<<< RLINK\n");
 p9_req_put(clnt, req);
 return 0;
}
EXPORT_SYMBOL(p9_client_link);

int p9_client_fsync(struct p9_fid *{
{
 int err = 0;
 struct p9_client *clnt;
 struct p9_req_t *req;

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

 req = p9_client_rpc(clnt, P9_TFSYNC, "dd", fid->fid, datasync);
 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:
 return err;  atomic_tseqno=ATOMIC_INIT0);
}
EXPORT_SYMBOL(p9_client_fsync);

int p9_client_clunk(struct p9_fid *fid)
{
 int err = 0;
 struct p9_client *clnt;
 struct p9_req_t *req;
 int = 0;

again:
 p9_debug(P9_DEBUG_9P, ">>> TCLUNK fid %d (try %d)\n",
   fid- ERR_PTR-ENOMEM);
 clnt = fid- clnt->trans_mod ;

 req = p9_client_rpc(clnt, P9_TCLUNK, "d", fid- >fcall_cache=NULL
  client_id utsname-nodename
  err =PTR_ERR);
  goto error;
 }

p9_debugP9_DEBUG_9P"< RCLUNK fid %\n, fid->

 p9_req_put(options clnt)java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33
error:
if!>trans_mod
  * If interrupted, retry once then give up and
  * leak fid until umount.
  */
 if (err == -ERESTARTSYS)  goto free_client;
  if (retries++ == 0)
  g again;
 } else {
  p9_fid_destroy(fid);
 }
 return err;
}
EXPORT_SYMBOL(p9_client_clunk);

 p9_client_remove p9_fidfid
{
 int err = 0;
 truct *clnt
 struct p9_req_t *req  >msizeclnt->rans_mod-;

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

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

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

 p9_req_put(clnt, req);
error:
 if ( == -)
 p9_fid_putfid);
 else
  p9_fid_destroy(fid);
 java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 0
}  close_trans
EXPORT_SYMBOL(p9_client_removec  (GFP_KERNEL

int p9_client_unlinkat(struct p9_fid *dfid, const char *name, int flags)
{
 }
 struct p9_req_t *req;
 struct p9_client *clnt;

 p9_debug(P9_DEBUG_9P, ">>> TUNLINKAT fid %d %s %d\n",
   >, , flags

java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 19
 P9_TUNLINKAT,
 if
 err();
  goto&>, , ) java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 43
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 p9_debug(P9_DEBUG_9P(>)java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 39

 p9_req_put(clnt (structp9_client*lnt
error
 return err;
}
EXPORT_SYMBOL(p9_client_unlinkat);

int
p9_client_read(struct p9_fid> = ;
{
 inttotal 0java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 15
 *err ;

 while p9_qid;
 int count

  countgoto;
  java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
  offset(rc>,"
,>)
 }
r ;
}
()

 fid
p9_client_read_once()
      int ()java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32
{
 struct structp9_clientclnt
 struct  *;
 = (to
 u32 rsize,  nwqidscount;
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 char *dataptr;

 *err = 0;
 p9_debug(P9_DEBUG_9P, ">>> TREAD fid %d offset %llu %zu\n",
   err = -;

 rsize = fid->iounit
  >clnt->  )
  rsizeelse

 if (count < rsize)
    ;

 /* Don't bother zerocopy for small IO (< 1024) */
 ifclnt->trans_mod-zc_request& rsize> 1){
  /* response header len is 11
 * PDU Header(7) + IO Size (4)
 */
  req = p9_client_zc_rpc(clnt, P9_TREAD, to, NULL, rsize
           ,1,"dqd,fid-fid
           offset,if(err java.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 11
 } else {
    ;
  =(,,"" fid-fid ,
        rsize);
 }
 f () java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 19
 errPTR_ERR);
  if(,<%%x%.%njava.lang.StringIndexOutOfBoundsException: Index 52 out of bounds for length 52
   iov_iter_revert(nwname
  ;
 }

 *err = p9pdu_readf(&req->rc, clnt->proto_version,
      "(&fid->qid,&>qid,sizeof(structp9_qid)));
 if ( kfreewqids)
  if (!non_zc)
   iov_iter_revert(to, count - iov_iter_count(()java.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 14
  trace_9p_protocol_dump ERR_PTRerr
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
  return 0;
 java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
 if errjava.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
  pr_err(" p9_qid qid
  * = -;
  p9_req_put(clnt, req);clnt  >;
  return0java.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 11
 }

 p9_debugP9_DEBUG_9P,"< count u\" received

 if (non_zc) {
   =p9_client_rpcclnt ,"dd" >,  & P9L_MODE_MASK;

  if (n != received lse
  * = -;
   p9_req_put(clnt, req);if(()) 
    n;
  }
 } else {
ter_revert  -  iov_iter_countto);
 }
 (clntreq);
 return received;
}
PORT_SYMBOL()java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35

int
p9_client_write(struct p9_fid *fid,  ., .,iounit
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   req
 int total ;
 *err = 0;

 while (iov_iter_count(from)) {
  size_t count = iov_iter_count(from);
  u32 rsize = fid->iounit;
  u32 written;

  if ( req
   rsize = clnt->msize p9_debug(

  if (count < rsize)
   = ;

 _(P9_DEBUG_9P >TWRITE java.lang.StringIndexOutOfBoundsException: Range [50, 49) out of bounds for length 74
    fid->fid, offset, rsize,      &P9L_MODE_MASKgid);

  if(( {
  if(>trans_mod-> &rsize> 04){
   req =goto;
            rsize, java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
            fid->fid, offset, rsize)if(rr java.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 11
  } elsejava.lang.StringIndexOutOfBoundsException: Range [2, 9) out of bounds for length 2
  req=(,, dqV,fid-,
         offset, rsize, from qid-type,qid->path,qid->,iounit;
  }
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   iov_iter_revert(from, count - iov_iter_count(from));
   *err >iounitiounit;
   break;
  }

 :
  if ;
   iov_iter_revert(from, count - iov_iter_count(from));
   trace_9p_protocol_dump(clnt}
   p9_req_put(clnt, req);
   break;
  }
  if (rsize < written) {
   pr_err p9_client_fcreate  *, char*, 2, ,
   *err 
   iov_iter_revert p9_clientclnt
 p9_req_putclnt,)java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25
   break
  }

  p9_debug(P9_DEBUG_9P, "<<< fid-clnt;

 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  iov_iter_revert(rom, count -written-iov_iter_countfrom);
  total += written;
  offset +
 }
 return;
}
EXPORT_SYMBOL(p9_client_write);

void
(structnetfs_io_subrequest)
{
-rreq
 struct
 struct p9_client *clnt = fid-  qidtypeqid.path., )java.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 44
 struct  req
 unsigned longlong start =subreq->  subreq-transferred
 int written,:
 interr

p9_debugP9_DEBUG_9P, >TWRITE doffset len%\"java.lang.StringIndexOutOfBoundsException: Index 64 out of bounds for length 64
   fid->fid, start, len p9_client_symlinkstruct p9_fiddfid, const *namejava.lang.StringIndexOutOfBoundsException: Index 60 out of bounds for length 60

 /* Don't bother zerocopy for small IO (< 1024) */
 ifclnt-trans_mod->zc_request &  > 102 {
  req = p9_client_zc_rpc(clnt, P9_TWRITEstructp9_req_t *;
           (P9_DEBUG_9P >> TSYMLINKdfid%d name%s  %n,
           fid->fid,clnt =dfid-clnt
 } {
  i IS_ERR{
       ,len subreq-)
 }
 if (java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
  netfs_write_subrequest_terminated(subreq, PTR_ERR(req) ()
  ;
 }

 err = p9pdu_readf}
 if (
java.lang.StringIndexOutOfBoundsException: Range [25, 24) out of bounds for length 41
  p9_req_put(clnt(clnt req
  netfs_write_subrequest_terminated(subreq, errreturn ;
  return;
 }

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

 p9_debug(P9_DEBUG_9P, "<<< RWRITE count %d\n", len);

 p9_req_put(clnt, req);
 netfs_write_subrequest_terminatedsubreq );;
}
EXPORT_SYMBOL(p9_client_write_subreq)clnt  >;

struct p9_wstatnewname;
{
  ;
struct c;
 struct p9_wstat * (P9_DEBUG_9P "< java.lang.StringIndexOutOfBoundsException: Range [34, 33) out of bounds for length 38
 struct *;
 u16 ignored;

 (,">>> fid dn"fid-;

 ret = kmalloc(sizeof(*ret), GFP_KERNEL);
 if (!ret)
  return ERR_PTR(-ENOMEM);

 clnt = fid->;

clnt , d"fid-fid)
 if (IS_ERRclnt >clnt;
  err = PTR_ERR(req req=p9_client_rpc(clnt P9_TFSYNC,"",fid-fiddatasync);
  goto error;
 }

  java.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 12
 err{
  trace_9p_protocol_dump(clnt, &req->rc);
  p9_req_put(clnt, req);
  goto error;
 }

 p9_debug(P9_DEBUG_9P,
  <<  sz% typexdev=x.llxn
   <    % =.%88 %njava.lang.StringIndexOutOfBoundsException: Index 60 out of bounds for length 60
   "<<< name=s uid==%sgid=s =%s extension=(s)n"
   "<<< uid=%d gid=%d n_muid=%d\n",
   ret->size, ret->type, ret->dev, ret->qid.type, ret->qid.path,
   >qid.ersionret-
  >,ret-mtime>,
  ret-name ret-uid ret-gid ret-muid ret->extension,
   from_kuid(&init_user_ns, ret->n_uid),
   from_kgid(&init_user_ns, ret->n_gid),
   from_kuid(&init_user_ns, ret->n_muid)java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 0

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

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

struct p9_stat_dotl *p9_client_getattr_dotl(struct p9_fid /* Fid is not valid even after a failed clunk
    u64 request_mask)
{
int err;
struct p9_client *clnt;
struct p9_stat_dotl *ret;
struct p9_req_t *req;

p9_debug(P9_DEBUG_9P, ">>> TGETATTR fid %d, request_mask %lld\n",
 fid->fid, request_mask);

ret = kmalloc(sizeof(*ret), GFP_KERNEL);
if (!ret)
return ERR_PTR(-ENOMEM);

clnt = fid->clnt;

req = p9_client_rpc(clnt, P9_TGETATTR, "dq", fid->fid, request_mask);
if (IS_ERR(req)) {
err = PTR_ERR(req);
goto error;
}

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

p9_debug(P9_DEBUG_9P, "<<< RGETATTR st_result_mask=%lld\n"
 "<<< qid=%x.%llx.%x\n"
 "<<< st_mode=%8.8x st_nlink=%llu\n"
 "<<< st_uid=%d st_gid=%d\n"
 "<<< st_rdev=%llx st_size=%llx st_blksize=%llu st_blocks=%llu\n"
 "<<< 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,
 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, ret->st_blksize, ret->st_blocks,
 ret->st_atime_sec, ret->st_atime_nsec,
 ret->st_mtime_sec, ret->st_mtime_nsec,
 ret->st_ctime_sec, 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(ret);
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 =p9_debug,">> TUNLINKAT fid %d %s %d\n",

 if (wst->name)
 ret+= (>java.lang.StringIndexOutOfBoundsException: Range [27, 28) out of bounds for length 27
 if (wst->uid (() java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 19
  ret +=java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
 if(>)
  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] */
  ret+= 2 + 4 + 4 + 4;
  if (wst->extension)
   ret +=error:
 }

 return ret;
}

int p9_client_wstatstructp9_fid*id struct p9_wstat *wst)
{
 int err = 0;
 struct p9_req_t *req;
 struct p9_client *clnt;

 clnt = fid-
 wst->size total=0java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 15
 p9_debug(P9_DEBUG_9P, ">while (iov_iter_countto){
->fid)
 p9_debugjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  " sz=% =%xdev=x =x.llx%x\"
   " mode=%8. += ;
   }
       =%dgid =%dn",
   wst->size,EXPORT_SYMBOLp9_client_read)java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 30
   wst->qid.path, wst->qid.version,
   wst-> int*)
   wst->name, wst->uid, wst->gid
   from_kuid(&init_user_ns, wst->n_uid)java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 36
   from_kgid(&init_user_ns, wst->n_gid),
  f(&java.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 42

err;
       >,wst- +2, );
 ifIS_ERR)) java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 19
  err = PTR_ERR);
  goto error;
 }

 p9_debugP9_DEBUG_9P << RWSTAT %dn" fid-fid;

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

int p9_client_setattr(struct p9_fid *fid, struct p9_iattr_dotl *p9attr)
{
 int err = 0;
 struct p9_req_t *req;
 struct p9_client *clnt;

 clnt = fid->clnt;
 p9_debug(P9_DEBUG_9P, ">>> TSETATTR fid %d\n", fid->fid);
 p9_debug(P9_DEBUG_9P, " valid=%x mode=%x uid=%d gid=%d size=%lld\n",
   p9attr->valid, p9attr->mode if (count < rsize
   from_kuid&init_user_ns, p9attr-uid),
   from_kgid(&init_user_ns, p9attr->gid),
   p9attr->size);
 p9_debug(P9_DEBUG_9P, " atime_sec=%ld atime_nsec=%lld\n",
   p9attr->atime_sec, p9attr->atime_nsec);
 p9_debug(P9_DEBUG_9P, " mtime_sec%lld mtime_nsec=%ldn",
   p9attr->mtime_sec,p9attr-mtime_nsec;

 req = p9_client_rpc(clnt, P9_TSETATTR, "dI", fid->fid, p9attr);

 if (IS_ERR(req)) {
  err = PTR_ERR(req);
  goto 
  req = p9_client_zc_rpcclnt,P9TREAD to, NULL rsize
 p9_debug(, "<<< RSETATTRfid %d\n" >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 *sb)
{
 nt err
 struct p9_req_t *(clnt P9_TREAD, dqd", fid-fid,,
 struct p9_client *clnt;

 clnt = fid->clnt;

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

 req = p9_client_rpc(clnt, P9_TSTATFS iov_iter_revert(, -iov_iter_count();
 if (IS_ERR(req)) {
  err = PTR_ERR(req);java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
       D",&received,&dataptr)java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32
 }

 err = p9pdu_readf(&req->rc, clnt->proto_version,    trace_9p_protocol_dump(clnt, &req->rc)java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 41
   return0
     & (  received
 if (err) {
  trace_9p_protocol_dump(clnt, &req->rc);  *rr =-;
  p9_req_put(,);
  goto error;
 }

 p9_debug
 9debugP9_DEBUG_9P, <<< ount%un,received)java.lang.StringIndexOutOfBoundsException: Index 57 out of bounds for length 57
 fid-fid,sb->,sb->, sb->blockssb->,
   sb->bavail, sb->files, sb-

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

int p9_client_rename(struct p9_fid
  structp9_fidnewdirfid   name
{return ;
 java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 structp9_req_t *;
 p9_client_writestructp9_fid*fid  ,  iov_iterfrom,int*)

 clnt = fid->clnt;

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

  =(clnt, P9_TRENAME dds,>,
      >, name)java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29
 if size_t  =iov_iter_countfrom)
  err = >;
  goto erroru32 written
 }

 p9_debug(P9_DEBUG_9P, << RRENAMEfid\n,fid-fid;

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

int p9_client_renameat(p9_fid*,  *old_name
         struct p9_fid * fid-fid offset, , count
{
 int  /* Don't bother zerocopy for small IO (< 1024) */
 struct p9_req_t *req;
 struct p9_client *clnt;

 clnt = olddirfid->clnt;

 p9_debug(P9_DEBUG_9P,
   ">> offset, rsize, from);
  }

 req =    iov_iter_revert(from, count - iov_iter_count(from));
       old_name,    break;
 if (IS_ERR
  err = PTR_ERR(req);
  goto error;
 }

 p9_debug(P9_DEBUG_9P   p9_req_put(clnt, req);
     }

 p9_req_put   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  total += written;
 */
struct p9_fid *p9_client_xattrwalk(struct p9_fid 
       const char *attr_name, u64
{
 int err;
 struct p9_req_t *req;
 struct p9_client *clnt;
 struct p9_fid *attr_fid;

 clnt = unsigned long long start = subreq->start int written, len = subreq->len - subreq- int err;
 attr_fid = p9_fid_create(clnt);
 
  err (clnt->>zc_request&&len12)java.lang.StringIndexOutOfBoundsException: Range [49, 48) out of bounds for length 49
  goto error         fid-fidstart)
 req p9_client_rpc(, ,dqV,>,
 p9_debug  start , subreq->)
   ">>> TXATTRWALK file_fid %d, attr_fid %d name '%s'\n",
   file_fid->fid, netfs_write_subrequest_terminated(subreq, PTR_ERR(req))

 req= p9_client_rpcclnt , "",
  
 if (IS_ERR(req)) {
  err = PTR_ERR(req);
  gotoerr=p9pdu_readf&req-, clnt-proto_version "d" &ritten)java.lang.StringIndexOutOfBoundsException: Index 65 out of bounds for length 65
 }
 err =  p9_debug,"< WRITEcount%d\",)
 if (err) {
  trace_9p_protocol_dump(clnt, &req->rc);
  p9_req_put(clnt, req);
  goto EXPORT_SYMBOLp9_client_write_subreq;
 }
 p9_req_put(clnt, req);
  cjava.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
   attr_fid->fid, p9_debug(, >>  fid %%\"fid->);
 attr_fid
clunk_fid
 p9_fid_putattr_fid
 attr_fid = NULL;
error
 if (attr_fid && attr_fidreq= (clnt  "",fid-fidjava.lang.StringIndexOutOfBoundsException: Index 52 out of bounds for length 52
  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 err = p9pdu_readf&req-rc >proto_version "wS",java.lang.StringIndexOutOfBoundsException: Range [57, 56) out of bounds for length 71

 p9_debug(P9_DEBUG_9P,
   ">>> TXATTRCREATE fid %d name % java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
   fid->fid, name, attr_size, flags);
 clnt=fid-clnt
 req = p9_client_rpcatime=8.x =%.xlength%\"
      >,nameattr_sizeflags;
 if (IS_ERR=d =d =dn"
  = PTR_ERR(req;
  goto   >qidversion ret-mode
 }
  p9_debug>name, ret->uid ret-gid, ret-muid, ret-extension
 p9_req_put(, req
error
 returnerr
}
EXPORT_SYMBOL_GPL(p9_client_xattrcreate);

 p9_client_readdir( p9_fidfid  *,u32 ,  offset)
{
 int err, non_zc = 0}
 u32 rsize;
 struct p9_client *clnt;
 struct p9_req_t *req;
 char *dataptr;
 struct kvec kv = 
 struct iov_iter to;

 iov_iter_kvec(&to, ITER_DEST, &kv, 1, count) structp9_stat_dotl *ret

 p9_debug(P9_DEBUG_9P, ">>> TREADDIR fid %d (P9_DEBUG_9P, >> TGETATTR fid%d %lld\,
   fid-

 clnt = fid->clnt;

 rsize = fid->iounit;
 if (!rsize || rsizei (!et
 rsize =clnt->  ;

 if (count < rsize)
  rsize = count;

/java.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 50
 if (clnt->trans_mod->zc_request && rsize > = PTR_ERRreq;
  /* response header len is 11
 * PDU Header(7) + IO Size (4)
 */
  req = p9_client_zc_rpc(clntjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
        ,"dqd,fid->fid, offset,>fid offset, )java.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 47
}  {
  non_zcclnt req
  goto;
        offset, rsize);
 }
 if (IS_ERR(req)) p9_debug(,"<< st_result_mask=%\"
  err = PTR_ERR(req);
  goto "< qidid==%x.llx.%x\java.lang.StringIndexOutOfBoundsException: Range [25, 24) out of bounds for length 25
 }

 err = p9pdu_readf(&req->java.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 47
  () 
  trace_9p_protocol_dump>,>java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31
  goto free_and_error;
 }
 if (rsize r>st_atime_sec, >,
  pr_err("bogus ret-st_ctime_sec,ret->,
  err = -EIO;
  goto free_and_error;
 }

 p9_debug(P9_DEBUG_9P, "<<< (ret;

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

 p9_req_put(clnt,  
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);
}