/*
   * net/9p/clnt.c
   *
   * 9P Client
   *

   *  Copyright (C) 2008 by Eric Van Hensbergen <ericvh@gmail.com>

   *  Copyright (C) 2007 by Latchesar Ionkov <lucho@ionkov.net>
   *
   *  This program is free software; you can redistribute it and/or modify
   *  it under the terms of the GNU General Public License version 2
   *  as published by the Free Software Foundation.
   *
   *  This program is distributed in the hope that it will be useful,
   *  but WITHOUT ANY WARRANTY; without even the implied warranty of
   *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   *  GNU General Public License for more details.
   *
   *  You should have received a copy of the GNU General Public License
   *  along with this program; if not, write to:
   *  Free Software Foundation
   *  51 Franklin Street, Fifth Floor
   *  Boston, MA  02111-1301  USA
   *
   */

  #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 <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>

  /*
    * 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 != 8192)
  		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
  ", 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
  ");

  	} else if (!strcmp(s, "9p2000.u")) {

  		version = p9_proto_2000u;

  		p9_debug(P9_DEBUG_9P, "Protocol version: 9P2000.u
  ");

  	} else if (!strcmp(s, "9p2000.L")) {

  		version = p9_proto_2000L;

  		p9_debug(P9_DEBUG_9P, "Protocol version: 9P2000.L
  ");

  	} else

  		pr_info("Unknown protocol version %s
  ", s);

  	return version;
  }

  /**

   * parse_options - 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 p9_client *clnt)

  {

  	char *options, *tmp_options;

  	char *p;
  	substring_t args[MAX_OPT_ARGS];
  	int option;

  	char *s;

  	int ret = 0;

  	clnt->proto_version = p9_proto_2000L;

  	clnt->msize = 8192;

  	if (!opts)
  		return 0;

  	tmp_options = kstrdup(opts, GFP_KERNEL);
  	if (!tmp_options) {

  		p9_debug(P9_DEBUG_ERROR,
  			 "failed to allocate copy of option string
  ");

  		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?
  ");

  				ret = r;

  				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
  ");

  				goto free_and_return;
  			 }
  			clnt->trans_mod = v9fs_get_trans_by_name(s);
  			if (clnt->trans_mod == NULL) {

  				pr_info("Could not find request transport: %s
  ",
  					s);

  				ret = -EINVAL;

  				kfree(s);

  				goto free_and_return;
  			}

  			kfree(s);

  			break;
  		case Opt_legacy:

  			clnt->proto_version = p9_proto_legacy;

  			break;

  		case Opt_version:

  			s = match_strdup(&args[0]);
  			if (!s) {
  				ret = -ENOMEM;

  				p9_debug(P9_DEBUG_ERROR,
  					 "problem allocating copy of version arg
  ");

  				goto free_and_return;

  			}
  			ret = get_protocol_version(s);
  			if (ret == -EINVAL) {
  				kfree(s);
  				goto free_and_return;
  			}
  			kfree(s);

  			clnt->proto_version = ret;
  			break;

  		default:
  			continue;
  		}
  	}

  free_and_return:

  	kfree(tmp_options);

  	return ret;

  }

  static struct p9_fcall *p9_fcall_alloc(int alloc_msize)

  {
  	struct p9_fcall *fc;
  	fc = kmalloc(sizeof(struct p9_fcall) + alloc_msize, GFP_NOFS);
  	if (!fc)
  		return NULL;
  	fc->capacity = alloc_msize;
  	fc->sdata = (char *) fc + sizeof(struct p9_fcall);
  	return fc;
  }

  /**
   * p9_tag_alloc - lookup/allocate a request by tag
   * @c: client session to lookup tag within
   * @tag: numeric id for transaction
   *
   * this is a simple array lookup, but will grow the

   * request_slots as necessary to accommodate transaction

   * ids which did not previously have a slot.
   *
   * this code relies on the client spinlock to manage locks, its
   * possible we should switch to something else, but I'd rather
   * stick with something low-overhead for the common case.
   *
   */

  static struct p9_req_t *
  p9_tag_alloc(struct p9_client *c, u16 tag, unsigned int max_size)

  {
  	unsigned long flags;
  	int row, col;

  	struct p9_req_t *req;

  	int alloc_msize = min(c->msize, max_size);

  
  	/* This looks up the original request by tag so we know which
  	 * buffer to read the data into */
  	tag++;
  
  	if (tag >= c->max_tag) {
  		spin_lock_irqsave(&c->lock, flags);
  		/* check again since original check was outside of lock */
  		while (tag >= c->max_tag) {
  			row = (tag / P9_ROW_MAXTAG);
  			c->reqs[row] = kcalloc(P9_ROW_MAXTAG,
  					sizeof(struct p9_req_t), GFP_ATOMIC);
  
  			if (!c->reqs[row]) {

  				pr_err("Couldn't grow tag array
  ");

  				spin_unlock_irqrestore(&c->lock, flags);

  				return ERR_PTR(-ENOMEM);

  			}
  			for (col = 0; col < P9_ROW_MAXTAG; col++) {
  				c->reqs[row][col].status = REQ_STATUS_IDLE;

  				c->reqs[row][col].tc = NULL;

  			}
  			c->max_tag += P9_ROW_MAXTAG;
  		}
  		spin_unlock_irqrestore(&c->lock, flags);
  	}
  	row = tag / P9_ROW_MAXTAG;
  	col = tag % P9_ROW_MAXTAG;

  	req = &c->reqs[row][col];

  	if (!req->wq) {

  		req->wq = kmalloc(sizeof(wait_queue_head_t), GFP_NOFS);

  		if (!req->wq)
  			goto grow_failed;

  		init_waitqueue_head(req->wq);

  	}

  	if (!req->tc)
  		req->tc = p9_fcall_alloc(alloc_msize);
  	if (!req->rc)
  		req->rc = p9_fcall_alloc(alloc_msize);
  	if (!req->tc || !req->rc)
  		goto grow_failed;

  
  	p9pdu_reset(req->tc);
  	p9pdu_reset(req->rc);

  	req->tc->tag = tag-1;
  	req->status = REQ_STATUS_ALLOC;

  	return req;
  
  grow_failed:
  	pr_err("Couldn't grow tag array
  ");
  	kfree(req->tc);
  	kfree(req->rc);
  	kfree(req->wq);
  	req->tc = req->rc = NULL;
  	req->wq = NULL;
  	return ERR_PTR(-ENOMEM);

  }

  
  /**
   * p9_tag_lookup - lookup a request by tag
   * @c: client session to lookup tag within
   * @tag: numeric id for transaction
   *
   */
  
  struct p9_req_t *p9_tag_lookup(struct p9_client *c, u16 tag)
  {
  	int row, col;
  
  	/* This looks up the original request by tag so we know which
  	 * buffer to read the data into */
  	tag++;

  	if(tag >= c->max_tag) 
  		return NULL;

  
  	row = tag / P9_ROW_MAXTAG;
  	col = tag % P9_ROW_MAXTAG;
  
  	return &c->reqs[row][col];
  }
  EXPORT_SYMBOL(p9_tag_lookup);
  
  /**
   * p9_tag_init - setup tags structure and contents

   * @c:  v9fs client struct

   *
   * This initializes the tags structure for each client instance.
   *
   */
  
  static int p9_tag_init(struct p9_client *c)
  {
  	int err = 0;
  
  	c->tagpool = p9_idpool_create();
  	if (IS_ERR(c->tagpool)) {
  		err = PTR_ERR(c->tagpool);

  		goto error;
  	}

  	err = p9_idpool_get(c->tagpool); /* reserve tag 0 */
  	if (err < 0) {
  		p9_idpool_destroy(c->tagpool);
  		goto error;
  	}

  	c->max_tag = 0;
  error:
  	return err;
  }
  
  /**
   * p9_tag_cleanup - cleans up tags structure and reclaims resources

   * @c:  v9fs client struct

   *
   * This frees resources associated with the tags structure
   *
   */
  static void p9_tag_cleanup(struct p9_client *c)
  {
  	int row, col;
  
  	/* check to insure all requests are idle */
  	for (row = 0; row < (c->max_tag/P9_ROW_MAXTAG); row++) {
  		for (col = 0; col < P9_ROW_MAXTAG; col++) {
  			if (c->reqs[row][col].status != REQ_STATUS_IDLE) {

  				p9_debug(P9_DEBUG_MUX,
  					 "Attempting to cleanup non-free tag %d,%d
  ",
  					 row, col);

  				/* TODO: delay execution of cleanup */
  				return;
  			}
  		}
  	}

  	if (c->tagpool) {
  		p9_idpool_put(0, c->tagpool); /* free reserved tag 0 */

  		p9_idpool_destroy(c->tagpool);

  	}

  
  	/* free requests associated with tags */
  	for (row = 0; row < (c->max_tag/P9_ROW_MAXTAG); row++) {

  		for (col = 0; col < P9_ROW_MAXTAG; col++) {

  			kfree(c->reqs[row][col].wq);

  			kfree(c->reqs[row][col].tc);
  			kfree(c->reqs[row][col].rc);
  		}

  		kfree(c->reqs[row]);
  	}
  	c->max_tag = 0;
  }

  /**
   * p9_free_req - free a request and clean-up as necessary
   * c: client state
   * r: request to release
   *
   */

  static void p9_free_req(struct p9_client *c, struct p9_req_t *r)

  {

  	int tag = r->tc->tag;

  	p9_debug(P9_DEBUG_MUX, "clnt %p req %p tag: %d
  ", c, r, tag);

  	r->status = REQ_STATUS_IDLE;

  	if (tag != P9_NOTAG && p9_idpool_check(tag, c->tagpool))
  		p9_idpool_put(tag, c->tagpool);

  }

  /**
   * p9_client_cb - call back from transport to client
   * c: client state
   * req: request received
   *
   */

  void p9_client_cb(struct p9_client *c, struct p9_req_t *req, int status)

  {

  	p9_debug(P9_DEBUG_MUX, " tag %d
  ", req->tc->tag);

  
  	/*
  	 * This barrier is needed to make sure any change made to req before
  	 * the other thread wakes up will indeed be seen by the waiting side.
  	 */
  	smp_wmb();
  	req->status = status;

  	wake_up(req->wq);

  	p9_debug(P9_DEBUG_MUX, "wakeup: %d
  ", req->tc->tag);

  }
  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 *tag,
  								int rewind)
  {
  	int8_t r_type;
  	int16_t r_tag;
  	int32_t r_size;
  	int offset = pdu->offset;
  	int err;
  
  	pdu->offset = 0;
  	if (pdu->size == 0)
  		pdu->size = 7;
  
  	err = p9pdu_readf(pdu, 0, "dbw", &r_size, &r_type, &r_tag);
  	if (err)
  		goto rewind_and_exit;
  
  	pdu->size = r_size;
  	pdu->id = r_type;
  	pdu->tag = r_tag;

  	p9_debug(P9_DEBUG_9P, "<<< size=%d type: %d tag: %d
  ",
  		 pdu->size, pdu->id, pdu->tag);

  
  	if (type)
  		*type = r_type;
  	if (tag)
  		*tag = r_tag;
  	if (size)
  		*size = r_size;
  
  
  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 p9_req_t *req)
  {
  	int8_t type;
  	int err;

  	int ecode;

  
  	err = p9_parse_header(req->rc, NULL, &type, NULL, 0);

  	/*
  	 * 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, "couldn't parse header %d
  ", err);

  		return err;
  	}

  	if (type != P9_RERROR && type != P9_RLERROR)
  		return 0;

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

  		err = p9pdu_readf(req->rc, c->proto_version, "s?d",

  				  &ename, &ecode);

  		if (err)
  			goto out_err;

  		if (p9_is_proto_dotu(c) && ecode < 512)

  			err = -ecode;

  		if (!err) {

  			err = p9_errstr2errno(ename, strlen(ename));

  			p9_debug(P9_DEBUG_9P, "<<< RERROR (%d) %s
  ",
  				 -ecode, ename);

  		}

  		kfree(ename);

  	} else {
  		err = p9pdu_readf(req->rc, c->proto_version, "d", &ecode);
  		err = -ecode;

  		p9_debug(P9_DEBUG_9P, "<<< RLERROR (%d)
  ", -ecode);

  	}

  	return err;

  
  out_err:

  	p9_debug(P9_DEBUG_ERROR, "couldn't parse error%d
  ", err);

  
  	return err;

  }

  /**
   * p9_check_zc_errors - check 9p packet for error return and process it
   * @c: current client instance
   * @req: request to parse and check for error conditions
   * @in_hdrlen: Size of response protocol buffer.
   *
   * 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_zc_errors(struct p9_client *c, struct p9_req_t *req,

  			      struct iov_iter *uidata, int in_hdrlen)

  {
  	int err;
  	int ecode;
  	int8_t type;
  	char *ename = NULL;
  
  	err = p9_parse_header(req->rc, NULL, &type, NULL, 0);

  	/*
  	 * dump the response from server
  	 * This should be after parse_header which poplulate pdu_fcall.
  	 */
  	trace_9p_protocol_dump(c, req->rc);

  	if (err) {

  		p9_debug(P9_DEBUG_ERROR, "couldn't parse header %d
  ", err);

  		return err;
  	}
  
  	if (type != P9_RERROR && type != P9_RLERROR)
  		return 0;
  
  	if (!p9_is_proto_dotl(c)) {
  		/* Error is reported in string format */

  		int len;
  		/* 7 = header size for RERROR; */
  		int inline_len = in_hdrlen - 7;

  		len =  req->rc->size - req->rc->offset;
  		if (len > (P9_ZC_HDR_SZ - 7)) {
  			err = -EFAULT;

  			goto out_err;
  		}

  		ename = &req->rc->sdata[req->rc->offset];
  		if (len > inline_len) {
  			/* We have error in external buffer */

  			if (!copy_from_iter_full(ename + inline_len,
  					     len - inline_len, uidata)) {

  				err = -EFAULT;
  				goto out_err;

  			}
  		}

  		ename = NULL;
  		err = p9pdu_readf(req->rc, c->proto_version, "s?d",
  				  &ename, &ecode);
  		if (err)
  			goto out_err;

  		if (p9_is_proto_dotu(c) && ecode < 512)

  			err = -ecode;

  		if (!err) {

  			err = p9_errstr2errno(ename, strlen(ename));

  			p9_debug(P9_DEBUG_9P, "<<< RERROR (%d) %s
  ",
  				 -ecode, ename);

  		}
  		kfree(ename);
  	} else {
  		err = p9pdu_readf(req->rc, c->proto_version, "d", &ecode);
  		err = -ecode;

  		p9_debug(P9_DEBUG_9P, "<<< RLERROR (%d)
  ", -ecode);

  	}
  	return err;

  out_err:

  	p9_debug(P9_DEBUG_ERROR, "couldn't parse error%d
  ", err);

  	return err;
  }

  static struct p9_req_t *
  p9_client_rpc(struct p9_client *c, int8_t type, const char *fmt, ...);

  /**
   * 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 int p9_client_flush(struct p9_client *c, struct p9_req_t *oldreq)
  {
  	struct p9_req_t *req;
  	int16_t oldtag;
  	int err;
  
  	err = p9_parse_header(oldreq->tc, NULL, NULL, &oldtag, 1);
  	if (err)
  		return err;

  	p9_debug(P9_DEBUG_9P, ">>> TFLUSH tag %d
  ", oldtag);

  
  	req = p9_client_rpc(c, P9_TFLUSH, "w", oldtag);
  	if (IS_ERR(req))
  		return PTR_ERR(req);

  	/*
  	 * if we haven't received a response for oldreq,

  	 * remove it from the list

  	 */

  	if (oldreq->status == REQ_STATUS_SENT)

  		if (c->trans_mod->cancelled)
  			c->trans_mod->cancelled(c, oldreq);

  
  	p9_free_req(c, req);

  	return 0;
  }

  static struct p9_req_t *p9_client_prepare_req(struct p9_client *c,
  					      int8_t type, int req_size,
  					      const char *fmt, va_list ap)

  {

  	int tag, err;

  	struct p9_req_t *req;

  	p9_debug(P9_DEBUG_MUX, "client %p op %d
  ", 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);

  	tag = P9_NOTAG;

  	if (type != P9_TVERSION) {

  		tag = p9_idpool_get(c->tagpool);
  		if (tag < 0)

  			return ERR_PTR(-ENOMEM);

  	}

  	req = p9_tag_alloc(c, tag, req_size);

  	if (IS_ERR(req))
  		return req;

  	/* marshall the data */
  	p9pdu_prepare(req->tc, tag, type);

  	err = p9pdu_vwritef(req->tc, c->proto_version, fmt, ap);

  	if (err)
  		goto reterr;

  	p9pdu_finalize(c, req->tc);
  	trace_9p_client_req(c, type, tag);

  	return req;
  reterr:
  	p9_free_req(c, req);
  	return ERR_PTR(err);
  }
  
  /**
   * 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_free_req)
   */
  
  static struct p9_req_t *
  p9_client_rpc(struct p9_client *c, int8_t type, const char *fmt, ...)
  {
  	va_list ap;
  	int sigpending, err;
  	unsigned long flags;
  	struct p9_req_t *req;
  
  	va_start(ap, fmt);
  	req = p9_client_prepare_req(c, type, c->msize, fmt, ap);
  	va_end(ap);
  	if (IS_ERR(req))
  		return req;
  
  	if (signal_pending(current)) {
  		sigpending = 1;
  		clear_thread_flag(TIF_SIGPENDING);
  	} else
  		sigpending = 0;

  
  	err = c->trans_mod->request(c, req);
  	if (err < 0) {

  		if (err != -ERESTARTSYS && err != -EFAULT)

  			c->status = Disconnected;

  		goto reterr;
  	}

  again:

  	/* Wait for the response */

  	err = wait_event_killable(*req->wq, req->status >= REQ_STATUS_RCVD);

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

  	if ((err == -ERESTARTSYS) && (c->status == Connected)
  				  && (type == P9_TFLUSH)) {
  		sigpending = 1;
  		clear_thread_flag(TIF_SIGPENDING);
  		goto again;
  	}

  	if (req->status == REQ_STATUS_ERROR) {

  		p9_debug(P9_DEBUG_ERROR, "req_status error %d
  ", req->t_err);

  		err = req->t_err;

  	}

  	if ((err == -ERESTARTSYS) && (c->status == Connected)) {

  		p9_debug(P9_DEBUG_MUX, "flushing
  ");

  		sigpending = 1;

  		clear_thread_flag(TIF_SIGPENDING);

  		if (c->trans_mod->cancel(c, req))
  			p9_client_flush(c, req);
  
  		/* if we received the response anyway, don't signal error */
  		if (req->status == REQ_STATUS_RCVD)
  			err = 0;

  	}

  	if (sigpending) {
  		spin_lock_irqsave(&current->sighand->siglock, flags);
  		recalc_sigpending();
  		spin_unlock_irqrestore(&current->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_free_req(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
   * @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_free_req)
   */
  static struct p9_req_t *p9_client_zc_rpc(struct p9_client *c, int8_t type,

  					 struct iov_iter *uidata,
  					 struct iov_iter *uodata,

  					 int inlen, int olen, int in_hdrlen,

  					 const char *fmt, ...)

  {
  	va_list ap;
  	int sigpending, err;
  	unsigned long flags;
  	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_req(c, type, P9_ZC_HDR_SZ, fmt, ap);
  	va_end(ap);
  	if (IS_ERR(req))
  		return req;
  
  	if (signal_pending(current)) {
  		sigpending = 1;
  		clear_thread_flag(TIF_SIGPENDING);
  	} else
  		sigpending = 0;

  	err = c->trans_mod->zc_request(c, req, uidata, uodata,

  				       inlen, olen, in_hdrlen);

  	if (err < 0) {
  		if (err == -EIO)
  			c->status = Disconnected;

  		if (err != -ERESTARTSYS)
  			goto reterr;

  	}
  	if (req->status == REQ_STATUS_ERROR) {

  		p9_debug(P9_DEBUG_ERROR, "req_status error %d
  ", req->t_err);

  		err = req->t_err;
  	}
  	if ((err == -ERESTARTSYS) && (c->status == Connected)) {

  		p9_debug(P9_DEBUG_MUX, "flushing
  ");

  		sigpending = 1;
  		clear_thread_flag(TIF_SIGPENDING);

  		if (c->trans_mod->cancel(c, req))
  			p9_client_flush(c, req);
  
  		/* if we received the response anyway, don't signal error */
  		if (req->status == REQ_STATUS_RCVD)
  			err = 0;
  	}
  	if (sigpending) {
  		spin_lock_irqsave(&current->sighand->siglock, flags);
  		recalc_sigpending();
  		spin_unlock_irqrestore(&current->sighand->siglock, flags);
  	}
  	if (err < 0)
  		goto reterr;

  	err = p9_check_zc_errors(c, req, uidata, in_hdrlen);

  	trace_9p_client_res(c, type, req->rc->tag, err);
  	if (!err)

  		return req;

  reterr:
  	p9_free_req(c, req);

  	return ERR_PTR(safe_errno(err));

  }

  static struct p9_fid *p9_fid_create(struct p9_client *clnt)
  {

  	int ret;

  	struct p9_fid *fid;

  	unsigned long flags;

  	p9_debug(P9_DEBUG_FID, "clnt %p
  ", clnt);

  	fid = kmalloc(sizeof(struct p9_fid), GFP_KERNEL);
  	if (!fid)
  		return ERR_PTR(-ENOMEM);

  	ret = p9_idpool_get(clnt->fidpool);

  	if (ret < 0) {

  		ret = -ENOSPC;

  		goto error;
  	}

  	fid->fid = ret;

  
  	memset(&fid->qid, 0, sizeof(struct p9_qid));
  	fid->mode = -1;

  	fid->uid = current_fsuid();

  	fid->clnt = clnt;

  	fid->rdir = NULL;

  	spin_lock_irqsave(&clnt->lock, flags);

  	list_add(&fid->flist, &clnt->fidlist);

  	spin_unlock_irqrestore(&clnt->lock, flags);

  
  	return fid;
  
  error:
  	kfree(fid);

  	return ERR_PTR(ret);

  }
  
  static void p9_fid_destroy(struct p9_fid *fid)
  {
  	struct p9_client *clnt;

  	unsigned long flags;

  	p9_debug(P9_DEBUG_FID, "fid %d
  ", fid->fid);

  	clnt = fid->clnt;
  	p9_idpool_put(fid->fid, clnt->fidpool);

  	spin_lock_irqsave(&clnt->lock, flags);

  	list_del(&fid->flist);

  	spin_unlock_irqrestore(&clnt->lock, flags);

  	kfree(fid->rdir);

  	kfree(fid);
  }

  static int p9_client_version(struct p9_client *c)

  {

  	int err = 0;

  	struct p9_req_t *req;

  	char *version = NULL;

  	int msize;

  	p9_debug(P9_DEBUG_9P, ">>> TVERSION msize %d protocol %d
  ",
  		 c->msize, c->proto_version);

  
  	switch (c->proto_version) {

  	case p9_proto_2000L:

  		req = p9_client_rpc(c, P9_TVERSION, "ds",

  					c->msize, "9P2000.L");

  		break;
  	case p9_proto_2000u:
  		req = p9_client_rpc(c, P9_TVERSION, "ds",
  					c->msize, "9P2000.u");
  		break;
  	case p9_proto_legacy:
  		req = p9_client_rpc(c, P9_TVERSION, "ds",
  					c->msize, "9P2000");
  		break;
  	default:
  		return -EINVAL;

  	}

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

  	err = p9pdu_readf(req->rc, c->proto_version, "ds", &msize, &version);

  	if (err) {

  		p9_debug(P9_DEBUG_9P, "version error %d
  ", err);

  		trace_9p_protocol_dump(c, req->rc);

  		goto error;

  	}

  	p9_debug(P9_DEBUG_9P, "<<< RVERSION msize %d %s
  ", msize, version);

  	if (!strncmp(version, "9P2000.L", 8))
  		c->proto_version = p9_proto_2000L;

  	else if (!strncmp(version, "9P2000.u", 8))

  		c->proto_version = p9_proto_2000u;
  	else if (!strncmp(version, "9P2000", 6))
  		c->proto_version = p9_proto_legacy;

  	else {
  		err = -EREMOTEIO;
  		goto error;
  	}

  	if (msize < c->msize)
  		c->msize = msize;

  
  error:

  	kfree(version);
  	p9_free_req(c, req);

  
  	return err;
  }

  
  struct p9_client *p9_client_create(const char *dev_name, char *options)
  {
  	int err;
  	struct p9_client *clnt;

  	char *client_id;

  
  	err = 0;

  	clnt = kmalloc(sizeof(struct p9_client), GFP_KERNEL);
  	if (!clnt)
  		return ERR_PTR(-ENOMEM);

  	clnt->trans_mod = NULL;

  	clnt->trans = NULL;

  
  	client_id = utsname()->nodename;
  	memcpy(clnt->name, client_id, strlen(client_id) + 1);

  	spin_lock_init(&clnt->lock);

  	INIT_LIST_HEAD(&clnt->fidlist);

  	err = p9_tag_init(clnt);
  	if (err < 0)
  		goto free_client;

  	err = parse_opts(options, clnt);
  	if (err < 0)

  		goto destroy_tagpool;

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

  	if (clnt->trans_mod == NULL) {
  		err = -EPROTONOSUPPORT;

  		p9_debug(P9_DEBUG_ERROR,
  			 "No transport defined or default transport
  ");

  		goto destroy_tagpool;

  	}
  
  	clnt->fidpool = p9_idpool_create();
  	if (IS_ERR(clnt->fidpool)) {
  		err = PTR_ERR(clnt->fidpool);

  		goto put_trans;

  	}

  	p9_debug(P9_DEBUG_MUX, "clnt %p trans %p msize %d protocol %d
  ",
  		 clnt, clnt->trans_mod, clnt->msize, clnt->proto_version);

  	err = clnt->trans_mod->create(clnt, dev_name, options);
  	if (err)

  		goto destroy_fidpool;

  	if (clnt->msize > clnt->trans_mod->maxsize)
  		clnt->msize = clnt->trans_mod->maxsize;

  	err = p9_client_version(clnt);

  	if (err)

  		goto close_trans;

  	return clnt;

  close_trans:
  	clnt->trans_mod->close(clnt);
  destroy_fidpool:
  	p9_idpool_destroy(clnt->fidpool);
  put_trans:
  	v9fs_put_trans(clnt->trans_mod);

  destroy_tagpool:
  	p9_idpool_destroy(clnt->tagpool);

  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, *fidptr;

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

  	if (clnt->trans_mod)
  		clnt->trans_mod->close(clnt);

  	v9fs_put_trans(clnt->trans_mod);

  	list_for_each_entry_safe(fid, fidptr, &clnt->fidlist, flist) {

  		pr_info("Found fid %d not clunked
  ", fid->fid);

  		p9_fid_destroy(fid);

  	}

  	if (clnt->fidpool)
  		p9_idpool_destroy(clnt->fidpool);

  	p9_tag_cleanup(clnt);

  	kfree(clnt);
  }
  EXPORT_SYMBOL(p9_client_destroy);
  
  void p9_client_disconnect(struct p9_client *clnt)
  {

  	p9_debug(P9_DEBUG_9P, "clnt %p
  ", 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
  ", 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 = 0;

  	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
  ",
  		 afid ? afid->fid : -1, uname, aname);

  	fid = p9_fid_create(clnt);
  	if (IS_ERR(fid)) {
  		err = PTR_ERR(fid);
  		fid = NULL;
  		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_free_req(clnt, req);

  		goto error;

  	}

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

  
  	memmove(&fid->qid, &qid, sizeof(struct p9_qid));
  
  	p9_free_req(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;

  	uint16_t nwqids, count;

  	err = 0;

  	wqids = NULL;

  	clnt = oldfid->clnt;
  	if (clone) {
  		fid = p9_fid_create(clnt);
  		if (IS_ERR(fid)) {
  			err = PTR_ERR(fid);
  			fid = NULL;
  			goto error;
  		}
  
  		fid->uid = oldfid->uid;
  	} else
  		fid = oldfid;

  	p9_debug(P9_DEBUG_9P, ">>> TWALK fids %d,%d nwname %ud wname[0] %s
  ",
  		 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_free_req(clnt, req);

  		goto clunk_fid;

  	}
  	p9_free_req(clnt, req);

  	p9_debug(P9_DEBUG_9P, "<<< RWALK nwqid %d:
  ", nwqids);

  
  	if (nwqids != nwname) {

  		err = -ENOENT;
  		goto clunk_fid;
  	}

  	for (count = 0; count < nwqids; count++)

  		p9_debug(P9_DEBUG_9P, "<<<     [%d] %x.%llx.%x
  ",

  			count, wqids[count].type,
  			(unsigned long long)wqids[count].path,

  			wqids[count].version);

  	if (nwname)

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

  	else
  		fid->qid = oldfid->qid;

  	kfree(wqids);

  	return fid;
  
  clunk_fid:

  	kfree(wqids);

  	p9_client_clunk(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
  ",

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

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

  	if (p9_is_proto_dotl(clnt))
  		req = p9_client_rpc(clnt, P9_TLOPEN, "dd", fid->fid, mode);
  	else
  		req = p9_client_rpc(clnt, P9_TOPEN, "db", fid->fid, mode);

  	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
  ",

  		p9_is_proto_dotl(clnt) ? "RLOPEN" : "ROPEN",  qid.type,
  		(unsigned long long)qid.path, qid.version, iounit);

  
  	fid->mode = mode;

  	fid->iounit = iounit;

  free_and_error:
  	p9_free_req(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 = 0;
  	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
  ",

  			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, 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
  ",

  			qid->type,
  			(unsigned long long)qid->path,
  			qid->version, iounit);
  
  	ofid->mode = mode;
  	ofid->iounit = iounit;
  
  free_and_error:
  	p9_free_req(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
  ",

  						fid->fid, name, perm, mode);

  	err = 0;

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

  	req = p9_client_rpc(clnt, P9_TCREATE, "dsdb?s", fid->fid, name, perm,
  				mode, 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
  ",

  				qid.type,
  				(unsigned long long)qid.path,
  				qid.version, iounit);

  
  	fid->mode = mode;

  	fid->iounit = iounit;

  free_and_error:
  	p9_free_req(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 = 0;
  	struct p9_client *clnt;
  	struct p9_req_t *req;

  	p9_debug(P9_DEBUG_9P, ">>> TSYMLINK dfid %d name %s  symtgt %s
  ",

  			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
  ",

  			qid->type, (unsigned long long)qid->path, qid->version);
  
  free_and_error:
  	p9_free_req(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
  ",

  			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
  ");

  	p9_free_req(clnt, req);
  	return 0;
  }
  EXPORT_SYMBOL(p9_client_link);

  int p9_client_fsync(struct p9_fid *fid, int datasync)

  {
  	int err;
  	struct p9_client *clnt;
  	struct p9_req_t *req;

  	p9_debug(P9_DEBUG_9P, ">>> TFSYNC fid %d datasync:%d
  ",

  			fid->fid, datasync);

  	err = 0;
  	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
  ", fid->fid);

  
  	p9_free_req(clnt, req);
  
  error:
  	return err;
  }
  EXPORT_SYMBOL(p9_client_fsync);

  int p9_client_clunk(struct p9_fid *fid)
  {
  	int err;

  	struct p9_client *clnt;

  	struct p9_req_t *req;

  	int retries = 0;

  	if (!fid) {

  		pr_warn("%s (%d): Trying to clunk with NULL fid
  ",
  			__func__, task_pid_nr(current));

  		dump_stack();
  		return 0;
  	}

  again:
  	p9_debug(P9_DEBUG_9P, ">>> TCLUNK fid %d (try %d)
  ", fid->fid,
  								retries);

  	err = 0;

  	clnt = fid->clnt;

  	req = p9_client_rpc(clnt, P9_TCLUNK, "d", fid->fid);
  	if (IS_ERR(req)) {
  		err = PTR_ERR(req);
  		goto error;

  	}

  	p9_debug(P9_DEBUG_9P, "<<< RCLUNK fid %d
  ", fid->fid);

  	p9_free_req(clnt, req);

  error:

  	/*
  	 * Fid is not valid even after a failed clunk

  	 * If interrupted, retry once then give up and
  	 * leak fid until umount.

  	 */

  	if (err == -ERESTARTSYS) {
  		if (retries++ == 0)
  			goto again;
  	} else
  		p9_fid_destroy(fid);

  	return err;
  }
  EXPORT_SYMBOL(p9_client_clunk);
  
  int p9_client_remove(struct p9_fid *fid)
  {
  	int err;

  	struct p9_client *clnt;

  	struct p9_req_t *req;

  	p9_debug(P9_DEBUG_9P, ">>> TREMOVE fid %d
  ", fid->fid);

  	err = 0;

  	clnt = fid->clnt;

  	req = p9_client_rpc(clnt, P9_TREMOVE, "d", fid->fid);
  	if (IS_ERR(req)) {
  		err = PTR_ERR(req);
  		goto error;

  	}

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

  	p9_free_req(clnt, req);

  error:

  	if (err == -ERESTARTSYS)
  		p9_client_clunk(fid);
  	else
  		p9_fid_destroy(fid);

  	return err;
  }
  EXPORT_SYMBOL(p9_client_remove);

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

  	p9_debug(P9_DEBUG_9P, ">>> TUNLINKAT fid %d %s %d
  ",

  		   dfid->fid, name, flags);
  
  	clnt = dfid->clnt;
  	req = p9_client_rpc(clnt, P9_TUNLINKAT, "dsd", dfid->fid, name, flags);
  	if (IS_ERR(req)) {
  		err = PTR_ERR(req);
  		goto error;
  	}

  	p9_debug(P9_DEBUG_9P, "<<< RUNLINKAT fid %d %s
  ", dfid->fid, name);

  
  	p9_free_req(clnt, req);
  error:
  	return err;
  }
  EXPORT_SYMBOL(p9_client_unlinkat);

  int

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

  {

  	struct p9_client *clnt = fid->clnt;

  	struct p9_req_t *req;

  	int total = 0;

  	*err = 0;

  	p9_debug(P9_DEBUG_9P, ">>> TREAD fid %d offset %llu %d
  ",

  		   fid->fid, (unsigned long long) offset, (int)iov_iter_count(to));
  
  	while (iov_iter_count(to)) {
  		int count = iov_iter_count(to);
  		int rsize, non_zc = 0;
  		char *dataptr;
  			
  		rsize = fid->iounit;
  		if (!rsize || rsize > clnt->msize-P9_IOHDRSZ)
  			rsize = clnt->msize - P9_IOHDRSZ;
  
  		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_TREAD, to, NULL, rsize,
  					       0, 11, "dqd", fid->fid,
  					       offset, rsize);
  		} else {
  			non_zc = 1;
  			req = p9_client_rpc(clnt, P9_TREAD, "dqd", fid->fid, offset,
  					    rsize);
  		}
  		if (IS_ERR(req)) {
  			*err = PTR_ERR(req);
  			break;
  		}

  		*err = p9pdu_readf(req->rc, clnt->proto_version,
  				   "D", &count, &dataptr);
  		if (*err) {
  			trace_9p_protocol_dump(clnt, req->rc);
  			p9_free_req(clnt, req);
  			break;
  		}

  		if (rsize < count) {
  			pr_err("bogus RREAD count (%d > %d)
  ", count, rsize);
  			count = rsize;
  		}

  		p9_debug(P9_DEBUG_9P, "<<< RREAD count %d
  ", count);
  		if (!count) {
  			p9_free_req(clnt, req);
  			break;
  		}

  		if (non_zc) {
  			int n = copy_to_iter(dataptr, count, to);
  			total += n;
  			offset += n;
  			if (n != count) {
  				*err = -EFAULT;
  				p9_free_req(clnt, req);
  				break;
  			}
  		} else {
  			iov_iter_advance(to, count);
  			total += count;
  			offset += count;
  		}
  		p9_free_req(clnt, req);

  	}

  	return total;

  }

  EXPORT_SYMBOL(p9_client_read);

  
  int

  p9_client_write(struct p9_fid *fid, u64 offset, struct iov_iter *from, int *err)

  {

  	struct p9_client *clnt = fid->clnt;

  	struct p9_req_t *req;

  	int total = 0;

  	*err = 0;

  
  	p9_debug(P9_DEBUG_9P, ">>> TWRITE fid %d offset %llu count %zd
  ",
  				fid->fid, (unsigned long long) offset,
  				iov_iter_count(from));
  
  	while (iov_iter_count(from)) {
  		int count = iov_iter_count(from);
  		int rsize = fid->iounit;
  		if (!rsize || rsize > clnt->msize-P9_IOHDRSZ)
  			rsize = clnt->msize - P9_IOHDRSZ;
  
  		if (count < rsize)
  			rsize = count;
  
  		/* Don't bother zerocopy for small IO (< 1024) */
  		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)) {
  			*err = PTR_ERR(req);
  			break;
  		}