[linux-block.git] / net / 9p / protocol.c

// SPDX-License-Identifier: GPL-2.0-only
/*
 * 9P Protocol Support Code
 *
 *  Copyright (C) 2008 by Eric Van Hensbergen <ericvh@gmail.com>
 *
 *  Base on code from Anthony Liguori <aliguori@us.ibm.com>
 *  Copyright (C) 2008 by IBM, Corp.
 */

#include <linux/module.h>
#include <linux/errno.h>
#include <linux/kernel.h>
#include <linux/uaccess.h>
#include <linux/slab.h>
#include <linux/sched.h>
#include <linux/stddef.h>
#include <linux/types.h>
#include <linux/uio.h>
#include <net/9p/9p.h>
#include <net/9p/client.h>
#include "protocol.h"

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

/* len[2] text[len] */
#define P9_STRLEN(s) \
	(2 + min_t(size_t, s ? strlen(s) : 0, USHRT_MAX))

/**
 * p9_msg_buf_size - Returns a buffer size sufficiently large to hold the
 * intended 9p message.
 * @c: client
 * @type: message type
 * @fmt: format template for assembling request message
 * (see p9pdu_vwritef)
 * @ap: variable arguments to be fed to passed format template
 * (see p9pdu_vwritef)
 *
 * Note: Even for response types (P9_R*) the format template and variable
 * arguments must always be for the originating request type (P9_T*).
 */
size_t p9_msg_buf_size(struct p9_client *c, enum p9_msg_t type,
			const char *fmt, va_list ap)
{
	/* size[4] type[1] tag[2] */
	const int hdr = 4 + 1 + 2;
	/* ename[s] errno[4] */
	const int rerror_size = hdr + P9_ERRMAX + 4;
	/* ecode[4] */
	const int rlerror_size = hdr + 4;
	const int err_size =
		c->proto_version == p9_proto_2000L ? rlerror_size : rerror_size;

	static_assert(NAME_MAX <= 4*1024, "p9_msg_buf_size() currently assumes "
				  "a max. allowed directory entry name length of 4k");

	switch (type) {

	/* message types not used at all */
	case P9_TERROR:
	case P9_TLERROR:
	case P9_TAUTH:
	case P9_RAUTH:
		BUG();

	/* variable length & potentially large message types */
	case P9_TATTACH:
		BUG_ON(strcmp("ddss?u", fmt));
		va_arg(ap, int32_t);
		va_arg(ap, int32_t);
		{
			const char *uname = va_arg(ap, const char *);
			const char *aname = va_arg(ap, const char *);
			/* fid[4] afid[4] uname[s] aname[s] n_uname[4] */
			return hdr + 4 + 4 + P9_STRLEN(uname) + P9_STRLEN(aname) + 4;
		}
	case P9_TWALK:
		BUG_ON(strcmp("ddT", fmt));
		va_arg(ap, int32_t);
		va_arg(ap, int32_t);
		{
			uint i, nwname = va_arg(ap, int);
			size_t wname_all;
			const char **wnames = va_arg(ap, const char **);
			for (i = 0, wname_all = 0; i < nwname; ++i) {
				wname_all += P9_STRLEN(wnames[i]);
			}
			/* fid[4] newfid[4] nwname[2] nwname*(wname[s]) */
			return hdr + 4 + 4 + 2 + wname_all;
		}
	case P9_RWALK:
		BUG_ON(strcmp("ddT", fmt));
		va_arg(ap, int32_t);
		va_arg(ap, int32_t);
		{
			uint nwname = va_arg(ap, int);
			/* nwqid[2] nwqid*(wqid[13]) */
			return max_t(size_t, hdr + 2 + nwname * 13, err_size);
		}
	case P9_TCREATE:
		BUG_ON(strcmp("dsdb?s", fmt));
		va_arg(ap, int32_t);
		{
			const char *name = va_arg(ap, const char *);
			if (c->proto_version == p9_proto_legacy) {
				/* fid[4] name[s] perm[4] mode[1] */
				return hdr + 4 + P9_STRLEN(name) + 4 + 1;
			} else {
				va_arg(ap, int32_t);
				va_arg(ap, int);
				{
					const char *ext = va_arg(ap, const char *);
					/* fid[4] name[s] perm[4] mode[1] extension[s] */
					return hdr + 4 + P9_STRLEN(name) + 4 + 1 + P9_STRLEN(ext);
				}
			}
		}
	case P9_TLCREATE:
		BUG_ON(strcmp("dsddg", fmt));
		va_arg(ap, int32_t);
		{
			const char *name = va_arg(ap, const char *);
			/* fid[4] name[s] flags[4] mode[4] gid[4] */
			return hdr + 4 + P9_STRLEN(name) + 4 + 4 + 4;
		}
	case P9_RREAD:
	case P9_RREADDIR:
		BUG_ON(strcmp("dqd", fmt));
		va_arg(ap, int32_t);
		va_arg(ap, int64_t);
		{
			const int32_t count = va_arg(ap, int32_t);
			/* count[4] data[count] */
			return max_t(size_t, hdr + 4 + count, err_size);
		}
	case P9_TWRITE:
		BUG_ON(strcmp("dqV", fmt));
		va_arg(ap, int32_t);
		va_arg(ap, int64_t);
		{
			const int32_t count = va_arg(ap, int32_t);
			/* fid[4] offset[8] count[4] data[count] */
			return hdr + 4 + 8 + 4 + count;
		}
	case P9_TRENAMEAT:
		BUG_ON(strcmp("dsds", fmt));
		va_arg(ap, int32_t);
		{
			const char *oldname, *newname;
			oldname = va_arg(ap, const char *);
			va_arg(ap, int32_t);
			newname = va_arg(ap, const char *);
			/* olddirfid[4] oldname[s] newdirfid[4] newname[s] */
			return hdr + 4 + P9_STRLEN(oldname) + 4 + P9_STRLEN(newname);
		}
	case P9_TSYMLINK:
		BUG_ON(strcmp("dssg", fmt));
		va_arg(ap, int32_t);
		{
			const char *name = va_arg(ap, const char *);
			const char *symtgt = va_arg(ap, const char *);
			/* fid[4] name[s] symtgt[s] gid[4] */
			return hdr + 4 + P9_STRLEN(name) + P9_STRLEN(symtgt) + 4;
		}

	case P9_RERROR:
		return rerror_size;
	case P9_RLERROR:
		return rlerror_size;

	/* small message types */
	case P9_TWSTAT:
	case P9_RSTAT:
	case P9_RREADLINK:
	case P9_TXATTRWALK:
	case P9_TXATTRCREATE:
	case P9_TLINK:
	case P9_TMKDIR:
	case P9_TMKNOD:
	case P9_TRENAME:
	case P9_TUNLINKAT:
	case P9_TLOCK:
		return 8 * 1024;

	/* tiny message types */
	default:
		return 4 * 1024;

	}
}

static int
p9pdu_writef(struct p9_fcall *pdu, int proto_version, const char *fmt, ...);

void p9stat_free(struct p9_wstat *stbuf)
{
	kfree(stbuf->name);
	stbuf->name = NULL;
	kfree(stbuf->uid);
	stbuf->uid = NULL;
	kfree(stbuf->gid);
	stbuf->gid = NULL;
	kfree(stbuf->muid);
	stbuf->muid = NULL;
	kfree(stbuf->extension);
	stbuf->extension = NULL;
}
EXPORT_SYMBOL(p9stat_free);

size_t pdu_read(struct p9_fcall *pdu, void *data, size_t size)
{
	size_t len = min(pdu->size - pdu->offset, size);

	memcpy(data, &pdu->sdata[pdu->offset], len);
	pdu->offset += len;
	return size - len;
}

static size_t pdu_write(struct p9_fcall *pdu, const void *data, size_t size)
{
	size_t len = min(pdu->capacity - pdu->size, size);

	memcpy(&pdu->sdata[pdu->size], data, len);
	pdu->size += len;
	return size - len;
}

static size_t
pdu_write_u(struct p9_fcall *pdu, struct iov_iter *from, size_t size)
{
	size_t len = min(pdu->capacity - pdu->size, size);

	if (!copy_from_iter_full(&pdu->sdata[pdu->size], len, from))
		len = 0;

	pdu->size += len;
	return size - len;
}

/*	b - int8_t
 *	w - int16_t
 *	d - int32_t
 *	q - int64_t
 *	s - string
 *	u - numeric uid
 *	g - numeric gid
 *	S - stat
 *	Q - qid
 *	D - data blob (int32_t size followed by void *, results are not freed)
 *	T - array of strings (int16_t count, followed by strings)
 *	R - array of qids (int16_t count, followed by qids)
 *	A - stat for 9p2000.L (p9_stat_dotl)
 *	? - if optional = 1, continue parsing
 */

static int
p9pdu_vreadf(struct p9_fcall *pdu, int proto_version, const char *fmt,
	     va_list ap)
{
	const char *ptr;
	int errcode = 0;

	for (ptr = fmt; *ptr; ptr++) {
		switch (*ptr) {
		case 'b':{
				int8_t *val = va_arg(ap, int8_t *);
				if (pdu_read(pdu, val, sizeof(*val))) {
					errcode = -EFAULT;
					break;
				}
			}
			break;
		case 'w':{
				int16_t *val = va_arg(ap, int16_t *);
				__le16 le_val;
				if (pdu_read(pdu, &le_val, sizeof(le_val))) {
					errcode = -EFAULT;
					break;
				}
				*val = le16_to_cpu(le_val);
			}
			break;
		case 'd':{
				int32_t *val = va_arg(ap, int32_t *);
				__le32 le_val;
				if (pdu_read(pdu, &le_val, sizeof(le_val))) {
					errcode = -EFAULT;
					break;
				}
				*val = le32_to_cpu(le_val);
			}
			break;
		case 'q':{
				int64_t *val = va_arg(ap, int64_t *);
				__le64 le_val;
				if (pdu_read(pdu, &le_val, sizeof(le_val))) {
					errcode = -EFAULT;
					break;
				}
				*val = le64_to_cpu(le_val);
			}
			break;
		case 's':{
				char **sptr = va_arg(ap, char **);
				uint16_t len;

				errcode = p9pdu_readf(pdu, proto_version,
								"w", &len);
				if (errcode)
					break;

				*sptr = kmalloc(len + 1, GFP_NOFS);
				if (*sptr == NULL) {
					errcode = -ENOMEM;
					break;
				}
				if (pdu_read(pdu, *sptr, len)) {
					errcode = -EFAULT;
					kfree(*sptr);
					*sptr = NULL;
				} else
					(*sptr)[len] = 0;
			}
			break;
		case 'u': {
				kuid_t *uid = va_arg(ap, kuid_t *);
				__le32 le_val;
				if (pdu_read(pdu, &le_val, sizeof(le_val))) {
					errcode = -EFAULT;
					break;
				}
				*uid = make_kuid(&init_user_ns,
						 le32_to_cpu(le_val));
			} break;
		case 'g': {
				kgid_t *gid = va_arg(ap, kgid_t *);
				__le32 le_val;
				if (pdu_read(pdu, &le_val, sizeof(le_val))) {
					errcode = -EFAULT;
					break;
				}
				*gid = make_kgid(&init_user_ns,
						 le32_to_cpu(le_val));
			} break;
		case 'Q':{
				struct p9_qid *qid =
				    va_arg(ap, struct p9_qid *);

				errcode = p9pdu_readf(pdu, proto_version, "bdq",
						      &qid->type, &qid->version,
						      &qid->path);
			}
			break;
		case 'S':{
				struct p9_wstat *stbuf =
				    va_arg(ap, struct p9_wstat *);

				memset(stbuf, 0, sizeof(struct p9_wstat));
				stbuf->n_uid = stbuf->n_muid = INVALID_UID;
				stbuf->n_gid = INVALID_GID;

				errcode =
				    p9pdu_readf(pdu, proto_version,
						"wwdQdddqssss?sugu",
						&stbuf->size, &stbuf->type,
						&stbuf->dev, &stbuf->qid,
						&stbuf->mode, &stbuf->atime,
						&stbuf->mtime, &stbuf->length,
						&stbuf->name, &stbuf->uid,
						&stbuf->gid, &stbuf->muid,
						&stbuf->extension,
						&stbuf->n_uid, &stbuf->n_gid,
						&stbuf->n_muid);
				if (errcode)
					p9stat_free(stbuf);
			}
			break;
		case 'D':{
				uint32_t *count = va_arg(ap, uint32_t *);
				void **data = va_arg(ap, void **);

				errcode =
				    p9pdu_readf(pdu, proto_version, "d", count);
				if (!errcode) {
					*count =
					    min_t(uint32_t, *count,
						  pdu->size - pdu->offset);
					*data = &pdu->sdata[pdu->offset];
				}
			}
			break;
		case 'T':{
				uint16_t *nwname = va_arg(ap, uint16_t *);
				char ***wnames = va_arg(ap, char ***);

				errcode = p9pdu_readf(pdu, proto_version,
								"w", nwname);
				if (!errcode) {
					*wnames =
					    kmalloc_array(*nwname,
							  sizeof(char *),
							  GFP_NOFS);
					if (!*wnames)
						errcode = -ENOMEM;
				}

				if (!errcode) {
					int i;

					for (i = 0; i < *nwname; i++) {
						errcode =
						    p9pdu_readf(pdu,
								proto_version,
								"s",
								&(*wnames)[i]);
						if (errcode)
							break;
					}
				}

				if (errcode) {
					if (*wnames) {
						int i;

						for (i = 0; i < *nwname; i++)
							kfree((*wnames)[i]);
					}
					kfree(*wnames);
					*wnames = NULL;
				}
			}
			break;
		case 'R':{
				uint16_t *nwqid = va_arg(ap, uint16_t *);
				struct p9_qid **wqids =
				    va_arg(ap, struct p9_qid **);

				*wqids = NULL;

				errcode =
				    p9pdu_readf(pdu, proto_version, "w", nwqid);
				if (!errcode) {
					*wqids =
					    kmalloc_array(*nwqid,
							  sizeof(struct p9_qid),
							  GFP_NOFS);
					if (*wqids == NULL)
						errcode = -ENOMEM;
				}

				if (!errcode) {
					int i;

					for (i = 0; i < *nwqid; i++) {
						errcode =
						    p9pdu_readf(pdu,
								proto_version,
								"Q",
								&(*wqids)[i]);
						if (errcode)
							break;
					}
				}

				if (errcode) {
					kfree(*wqids);
					*wqids = NULL;
				}
			}
			break;
		case 'A': {
				struct p9_stat_dotl *stbuf =
				    va_arg(ap, struct p9_stat_dotl *);

				memset(stbuf, 0, sizeof(struct p9_stat_dotl));
				errcode =
				    p9pdu_readf(pdu, proto_version,
					"qQdugqqqqqqqqqqqqqqq",
					&stbuf->st_result_mask,
					&stbuf->qid,
					&stbuf->st_mode,
					&stbuf->st_uid, &stbuf->st_gid,
					&stbuf->st_nlink,
					&stbuf->st_rdev, &stbuf->st_size,
					&stbuf->st_blksize, &stbuf->st_blocks,
					&stbuf->st_atime_sec,
					&stbuf->st_atime_nsec,
					&stbuf->st_mtime_sec,
					&stbuf->st_mtime_nsec,
					&stbuf->st_ctime_sec,
					&stbuf->st_ctime_nsec,
					&stbuf->st_btime_sec,
					&stbuf->st_btime_nsec,
					&stbuf->st_gen,
					&stbuf->st_data_version);
			}
			break;
		case '?':
			if ((proto_version != p9_proto_2000u) &&
				(proto_version != p9_proto_2000L))
				return 0;
			break;
		default:
			BUG();
			break;
		}

		if (errcode)
			break;
	}

	return errcode;
}

int
p9pdu_vwritef(struct p9_fcall *pdu, int proto_version, const char *fmt,
	va_list ap)
{
	const char *ptr;
	int errcode = 0;

	for (ptr = fmt; *ptr; ptr++) {
		switch (*ptr) {
		case 'b':{
				int8_t val = va_arg(ap, int);
				if (pdu_write(pdu, &val, sizeof(val)))
					errcode = -EFAULT;
			}
			break;
		case 'w':{
				__le16 val = cpu_to_le16(va_arg(ap, int));
				if (pdu_write(pdu, &val, sizeof(val)))
					errcode = -EFAULT;
			}
			break;
		case 'd':{
				__le32 val = cpu_to_le32(va_arg(ap, int32_t));
				if (pdu_write(pdu, &val, sizeof(val)))
					errcode = -EFAULT;
			}
			break;
		case 'q':{
				__le64 val = cpu_to_le64(va_arg(ap, int64_t));
				if (pdu_write(pdu, &val, sizeof(val)))
					errcode = -EFAULT;
			}
			break;
		case 's':{
				const char *sptr = va_arg(ap, const char *);
				uint16_t len = 0;
				if (sptr)
					len = min_t(size_t, strlen(sptr),
								USHRT_MAX);

				errcode = p9pdu_writef(pdu, proto_version,
								"w", len);
				if (!errcode && pdu_write(pdu, sptr, len))
					errcode = -EFAULT;
			}
			break;
		case 'u': {
				kuid_t uid = va_arg(ap, kuid_t);
				__le32 val = cpu_to_le32(
						from_kuid(&init_user_ns, uid));
				if (pdu_write(pdu, &val, sizeof(val)))
					errcode = -EFAULT;
			} break;
		case 'g': {
				kgid_t gid = va_arg(ap, kgid_t);
				__le32 val = cpu_to_le32(
						from_kgid(&init_user_ns, gid));
				if (pdu_write(pdu, &val, sizeof(val)))
					errcode = -EFAULT;
			} break;
		case 'Q':{
				const struct p9_qid *qid =
				    va_arg(ap, const struct p9_qid *);
				errcode =
				    p9pdu_writef(pdu, proto_version, "bdq",
						 qid->type, qid->version,
						 qid->path);
			} break;
		case 'S':{
				const struct p9_wstat *stbuf =
				    va_arg(ap, const struct p9_wstat *);
				errcode =
				    p9pdu_writef(pdu, proto_version,
						 "wwdQdddqssss?sugu",
						 stbuf->size, stbuf->type,
						 stbuf->dev, &stbuf->qid,
						 stbuf->mode, stbuf->atime,
						 stbuf->mtime, stbuf->length,
						 stbuf->name, stbuf->uid,
						 stbuf->gid, stbuf->muid,
						 stbuf->extension, stbuf->n_uid,
						 stbuf->n_gid, stbuf->n_muid);
			} break;
		case 'V':{
				uint32_t count = va_arg(ap, uint32_t);
				struct iov_iter *from =
						va_arg(ap, struct iov_iter *);
				errcode = p9pdu_writef(pdu, proto_version, "d",
									count);
				if (!errcode && pdu_write_u(pdu, from, count))
					errcode = -EFAULT;
			}
			break;
		case 'T':{
				uint16_t nwname = va_arg(ap, int);
				const char **wnames = va_arg(ap, const char **);

				errcode = p9pdu_writef(pdu, proto_version, "w",
									nwname);
				if (!errcode) {
					int i;

					for (i = 0; i < nwname; i++) {
						errcode =
						    p9pdu_writef(pdu,
								proto_version,
								 "s",
								 wnames[i]);
						if (errcode)
							break;
					}
				}
			}
			break;
		case 'R':{
				uint16_t nwqid = va_arg(ap, int);
				struct p9_qid *wqids =
				    va_arg(ap, struct p9_qid *);

				errcode = p9pdu_writef(pdu, proto_version, "w",
									nwqid);
				if (!errcode) {
					int i;

					for (i = 0; i < nwqid; i++) {
						errcode =
						    p9pdu_writef(pdu,
								proto_version,
								 "Q",
								 &wqids[i]);
						if (errcode)
							break;
					}
				}
			}
			break;
		case 'I':{
				struct p9_iattr_dotl *p9attr = va_arg(ap,
							struct p9_iattr_dotl *);

				errcode = p9pdu_writef(pdu, proto_version,
							"ddugqqqqq",
							p9attr->valid,
							p9attr->mode,
							p9attr->uid,
							p9attr->gid,
							p9attr->size,
							p9attr->atime_sec,
							p9attr->atime_nsec,
							p9attr->mtime_sec,
							p9attr->mtime_nsec);
			}
			break;
		case '?':
			if ((proto_version != p9_proto_2000u) &&
				(proto_version != p9_proto_2000L))
				return 0;
			break;
		default:
			BUG();
			break;
		}

		if (errcode)
			break;
	}

	return errcode;
}

int p9pdu_readf(struct p9_fcall *pdu, int proto_version, const char *fmt, ...)
{
	va_list ap;
	int ret;

	va_start(ap, fmt);
	ret = p9pdu_vreadf(pdu, proto_version, fmt, ap);
	va_end(ap);

	return ret;
}

static int
p9pdu_writef(struct p9_fcall *pdu, int proto_version, const char *fmt, ...)
{
	va_list ap;
	int ret;

	va_start(ap, fmt);
	ret = p9pdu_vwritef(pdu, proto_version, fmt, ap);
	va_end(ap);

	return ret;
}

int p9stat_read(struct p9_client *clnt, char *buf, int len, struct p9_wstat *st)
{
	struct p9_fcall fake_pdu;
	int ret;

	fake_pdu.size = len;
	fake_pdu.capacity = len;
	fake_pdu.sdata = buf;
	fake_pdu.offset = 0;

	ret = p9pdu_readf(&fake_pdu, clnt->proto_version, "S", st);
	if (ret) {
		p9_debug(P9_DEBUG_9P, "<<< p9stat_read failed: %d\n", ret);
		trace_9p_protocol_dump(clnt, &fake_pdu);
		return ret;
	}

	return fake_pdu.offset;
}
EXPORT_SYMBOL(p9stat_read);

int p9pdu_prepare(struct p9_fcall *pdu, int16_t tag, int8_t type)
{
	pdu->id = type;
	return p9pdu_writef(pdu, 0, "dbw", 0, type, tag);
}

int p9pdu_finalize(struct p9_client *clnt, struct p9_fcall *pdu)
{
	int size = pdu->size;
	int err;

	pdu->size = 0;
	err = p9pdu_writef(pdu, 0, "d", size);
	pdu->size = size;

	trace_9p_protocol_dump(clnt, pdu);
	p9_debug(P9_DEBUG_9P, ">>> size=%d type: %d tag: %d\n",
		 pdu->size, pdu->id, pdu->tag);

	return err;
}

void p9pdu_reset(struct p9_fcall *pdu)
{
	pdu->offset = 0;
	pdu->size = 0;
}

int p9dirent_read(struct p9_client *clnt, char *buf, int len,
		  struct p9_dirent *dirent)
{
	struct p9_fcall fake_pdu;
	int ret;
	char *nameptr;

	fake_pdu.size = len;
	fake_pdu.capacity = len;
	fake_pdu.sdata = buf;
	fake_pdu.offset = 0;

	ret = p9pdu_readf(&fake_pdu, clnt->proto_version, "Qqbs", &dirent->qid,
			  &dirent->d_off, &dirent->d_type, &nameptr);
	if (ret) {
		p9_debug(P9_DEBUG_9P, "<<< p9dirent_read failed: %d\n", ret);
		trace_9p_protocol_dump(clnt, &fake_pdu);
		return ret;
	}

	ret = strscpy(dirent->d_name, nameptr, sizeof(dirent->d_name));
	if (ret < 0) {
		p9_debug(P9_DEBUG_ERROR,
			 "On the wire dirent name too long: %s\n",
			 nameptr);
		kfree(nameptr);
		return ret;
	}
	kfree(nameptr);

	return fake_pdu.offset;
}
EXPORT_SYMBOL(p9dirent_read);
Commit	Line	Data
1f327613	1	// SPDX-License-Identifier: GPL-2.0-only
ace51c4d	2	/*
ace51c4d EVH	3	* 9P Protocol Support Code
	4	*
	5	* Copyright (C) 2008 by Eric Van Hensbergen <ericvh@gmail.com>
	6	*
	7	* Base on code from Anthony Liguori <aliguori@us.ibm.com>
	8	* Copyright (C) 2008 by IBM, Corp.
ace51c4d EVH	9	*/
	10
	11	#include <linux/module.h>
	12	#include <linux/errno.h>
01b0c5cf	13	#include <linux/kernel.h>
51a87c55	14	#include <linux/uaccess.h>
5a0e3ad6	15	#include <linux/slab.h>
e7f4b8f1	16	#include <linux/sched.h>
01b0c5cf	17	#include <linux/stddef.h>
beeebc92	18	#include <linux/types.h>
4f3b35c1	19	#include <linux/uio.h>
ace51c4d EVH	20	#include <net/9p/9p.h>
	21	#include <net/9p/client.h>
	22	#include "protocol.h"
	23
348b5901 AK	24	#include <trace/events/9p.h>
348b5901 AK	25
1effdbf9 CS	26	/* len[2] text[len] */
	27	#define P9_STRLEN(s) \
	28	(2 + min_t(size_t, s ? strlen(s) : 0, USHRT_MAX))
	29
	30	/**
	31	* p9_msg_buf_size - Returns a buffer size sufficiently large to hold the
	32	* intended 9p message.
	33	* @c: client
	34	* @type: message type
	35	* @fmt: format template for assembling request message
	36	* (see p9pdu_vwritef)
	37	* @ap: variable arguments to be fed to passed format template
	38	* (see p9pdu_vwritef)
	39	*
	40	* Note: Even for response types (P9_R*) the format template and variable
	41	* arguments must always be for the originating request type (P9_T*).
	42	*/
	43	size_t p9_msg_buf_size(struct p9_client *c, enum p9_msg_t type,
	44	const char *fmt, va_list ap)
	45	{
	46	/* size[4] type[1] tag[2] */
	47	const int hdr = 4 + 1 + 2;
	48	/* ename[s] errno[4] */
	49	const int rerror_size = hdr + P9_ERRMAX + 4;
	50	/* ecode[4] */
	51	const int rlerror_size = hdr + 4;
	52	const int err_size =
	53	c->proto_version == p9_proto_2000L ? rlerror_size : rerror_size;
	54
	55	static_assert(NAME_MAX <= 4*1024, "p9_msg_buf_size() currently assumes "
	56	"a max. allowed directory entry name length of 4k");
	57
	58	switch (type) {
	59
	60	/* message types not used at all */
	61	case P9_TERROR:
	62	case P9_TLERROR:
	63	case P9_TAUTH:
	64	case P9_RAUTH:
	65	BUG();
	66
	67	/* variable length & potentially large message types */
	68	case P9_TATTACH:
	69	BUG_ON(strcmp("ddss?u", fmt));
	70	va_arg(ap, int32_t);
	71	va_arg(ap, int32_t);
	72	{
	73	const char uname = va_arg(ap, const char );
	74	const char aname = va_arg(ap, const char );
	75	/* fid[4] afid[4] uname[s] aname[s] n_uname[4] */
	76	return hdr + 4 + 4 + P9_STRLEN(uname) + P9_STRLEN(aname) + 4;
	77	}
	78	case P9_TWALK:
	79	BUG_ON(strcmp("ddT", fmt));
	80	va_arg(ap, int32_t);
	81	va_arg(ap, int32_t);
	82	{
	83	uint i, nwname = va_arg(ap, int);
	84	size_t wname_all;
	85	const char wnames = va_arg(ap, const char );
	86	for (i = 0, wname_all = 0; i < nwname; ++i) {
	87	wname_all += P9_STRLEN(wnames[i]);
	88	}
	89	/* fid[4] newfid[4] nwname[2] nwname(wname[s]) /
90	return hdr + 4 + 4 + 2 + wname_all;
91	}
92	case P9_RWALK:
93	BUG_ON(strcmp("ddT", fmt));
94	va_arg(ap, int32_t);
95	va_arg(ap, int32_t);
96	{
97	uint nwname = va_arg(ap, int);
98	/* nwqid[2] nwqid(wqid[13]) /
99	return max_t(size_t, hdr + 2 + nwname * 13, err_size);
100	}
101	case P9_TCREATE:
102	BUG_ON(strcmp("dsdb?s", fmt));
103	va_arg(ap, int32_t);
104	{
105	const char name = va_arg(ap, const char );
106	if (c->proto_version == p9_proto_legacy) {
107	/* fid[4] name[s] perm[4] mode[1] */
108	return hdr + 4 + P9_STRLEN(name) + 4 + 1;
109	} else {
110	va_arg(ap, int32_t);
111	va_arg(ap, int);
112	{
113	const char ext = va_arg(ap, const char );
114	/* fid[4] name[s] perm[4] mode[1] extension[s] */
115	return hdr + 4 + P9_STRLEN(name) + 4 + 1 + P9_STRLEN(ext);
116	}
117	}
118	}
119	case P9_TLCREATE:
120	BUG_ON(strcmp("dsddg", fmt));
121	va_arg(ap, int32_t);
122	{
123	const char name = va_arg(ap, const char );
124	/* fid[4] name[s] flags[4] mode[4] gid[4] */
125	return hdr + 4 + P9_STRLEN(name) + 4 + 4 + 4;
126	}
127	case P9_RREAD:
128	case P9_RREADDIR:
129	BUG_ON(strcmp("dqd", fmt));
130	va_arg(ap, int32_t);
131	va_arg(ap, int64_t);
132	{
133	const int32_t count = va_arg(ap, int32_t);
134	/* count[4] data[count] */
135	return max_t(size_t, hdr + 4 + count, err_size);
136	}
137	case P9_TWRITE:
138	BUG_ON(strcmp("dqV", fmt));
139	va_arg(ap, int32_t);
140	va_arg(ap, int64_t);
141	{
142	const int32_t count = va_arg(ap, int32_t);
143	/* fid[4] offset[8] count[4] data[count] */
144	return hdr + 4 + 8 + 4 + count;
145	}
146	case P9_TRENAMEAT:
147	BUG_ON(strcmp("dsds", fmt));
148	va_arg(ap, int32_t);
149	{
150	const char oldname, newname;
151	oldname = va_arg(ap, const char *);
152	va_arg(ap, int32_t);
153	newname = va_arg(ap, const char *);
154	/* olddirfid[4] oldname[s] newdirfid[4] newname[s] */
155	return hdr + 4 + P9_STRLEN(oldname) + 4 + P9_STRLEN(newname);
156	}
157	case P9_TSYMLINK:
158	BUG_ON(strcmp("dssg", fmt));
159	va_arg(ap, int32_t);
160	{
161	const char name = va_arg(ap, const char );
162	const char symtgt = va_arg(ap, const char );
163	/* fid[4] name[s] symtgt[s] gid[4] */
164	return hdr + 4 + P9_STRLEN(name) + P9_STRLEN(symtgt) + 4;
165	}
166
167	case P9_RERROR:
168	return rerror_size;
169	case P9_RLERROR:
170	return rlerror_size;
171
172	/* small message types */
173	case P9_TWSTAT:
174	case P9_RSTAT:
175	case P9_RREADLINK:
176	case P9_TXATTRWALK:
177	case P9_TXATTRCREATE:
178	case P9_TLINK:
179	case P9_TMKDIR:
180	case P9_TMKNOD:
181	case P9_TRENAME:
182	case P9_TUNLINKAT:
183	case P9_TLOCK:
184	return 8 * 1024;
185
186	/* tiny message types */
187	default:
188	return 4 * 1024;
189
190	}
191	}
192
ace51c4d	193	static int
342fee1d	194	p9pdu_writef(struct p9_fcall pdu, int proto_version, const char fmt, ...);
ace51c4d EVH	195
	196	void p9stat_free(struct p9_wstat *stbuf)
	197	{
	198	kfree(stbuf->name);
62e39417	199	stbuf->name = NULL;
ace51c4d	200	kfree(stbuf->uid);
62e39417	201	stbuf->uid = NULL;
ace51c4d	202	kfree(stbuf->gid);
62e39417	203	stbuf->gid = NULL;
ace51c4d	204	kfree(stbuf->muid);
62e39417	205	stbuf->muid = NULL;
ace51c4d	206	kfree(stbuf->extension);
62e39417	207	stbuf->extension = NULL;
ace51c4d EVH	208	}
	209	EXPORT_SYMBOL(p9stat_free);
	210
abfa034e	211	size_t pdu_read(struct p9_fcall pdu, void data, size_t size)
ace51c4d	212	{
01b0c5cf	213	size_t len = min(pdu->size - pdu->offset, size);
6e195b0f	214
ace51c4d EVH	215	memcpy(data, &pdu->sdata[pdu->offset], len);
	216	pdu->offset += len;
	217	return size - len;
	218	}
	219
	220	static size_t pdu_write(struct p9_fcall pdu, const void data, size_t size)
	221	{
01b0c5cf	222	size_t len = min(pdu->capacity - pdu->size, size);
6e195b0f	223
ace51c4d EVH	224	memcpy(&pdu->sdata[pdu->size], data, len);
	225	pdu->size += len;
	226	return size - len;
	227	}
	228
51a87c55	229	static size_t
4f3b35c1	230	pdu_write_u(struct p9_fcall pdu, struct iov_iter from, size_t size)
51a87c55	231	{
01b0c5cf	232	size_t len = min(pdu->capacity - pdu->size, size);
6e195b0f	233
7f024647	234	if (!copy_from_iter_full(&pdu->sdata[pdu->size], len, from))
7b3bb3fe	235	len = 0;
51a87c55 EVH	236
	237	pdu->size += len;
	238	return size - len;
	239	}
	240
6e195b0f DM	241	/* b - int8_t
	242	* w - int16_t
	243	* d - int32_t
	244	* q - int64_t
	245	* s - string
	246	* u - numeric uid
	247	* g - numeric gid
	248	* S - stat
	249	* Q - qid
	250	* D - data blob (int32_t size followed by void *, results are not freed)
	251	* T - array of strings (int16_t count, followed by strings)
	252	* R - array of qids (int16_t count, followed by qids)
	253	* A - stat for 9p2000.L (p9_stat_dotl)
	254	* ? - if optional = 1, continue parsing
	255	*/
ace51c4d EVH	256
ace51c4d EVH	257	static int
342fee1d	258	p9pdu_vreadf(struct p9_fcall pdu, int proto_version, const char fmt,
6e195b0f	259	va_list ap)
ace51c4d EVH	260	{
	261	const char *ptr;
	262	int errcode = 0;
	263
	264	for (ptr = fmt; *ptr; ptr++) {
	265	switch (*ptr) {
	266	case 'b':{
	267	int8_t val = va_arg(ap, int8_t );
	268	if (pdu_read(pdu, val, sizeof(*val))) {
	269	errcode = -EFAULT;
	270	break;
	271	}
	272	}
	273	break;
	274	case 'w':{
	275	int16_t val = va_arg(ap, int16_t );
beeebc92 EVH	276	__le16 le_val;
beeebc92 EVH	277	if (pdu_read(pdu, &le_val, sizeof(le_val))) {
ace51c4d EVH	278	errcode = -EFAULT;
	279	break;
	280	}
beeebc92	281	*val = le16_to_cpu(le_val);
ace51c4d EVH	282	}
	283	break;
	284	case 'd':{
	285	int32_t val = va_arg(ap, int32_t );
beeebc92 EVH	286	__le32 le_val;
beeebc92 EVH	287	if (pdu_read(pdu, &le_val, sizeof(le_val))) {
ace51c4d EVH	288	errcode = -EFAULT;
	289	break;
	290	}
beeebc92	291	*val = le32_to_cpu(le_val);
ace51c4d EVH	292	}
	293	break;
	294	case 'q':{
	295	int64_t val = va_arg(ap, int64_t );
beeebc92 EVH	296	__le64 le_val;
beeebc92 EVH	297	if (pdu_read(pdu, &le_val, sizeof(le_val))) {
ace51c4d EVH	298	errcode = -EFAULT;
	299	break;
	300	}
beeebc92	301	*val = le64_to_cpu(le_val);
ace51c4d EVH	302	}
	303	break;
	304	case 's':{
e45c5405	305	char sptr = va_arg(ap, char );
219fd58b	306	uint16_t len;
ace51c4d	307
342fee1d SK	308	errcode = p9pdu_readf(pdu, proto_version,
342fee1d SK	309	"w", &len);
ace51c4d EVH	310	if (errcode)
	311	break;
	312
eeff66ef	313	*sptr = kmalloc(len + 1, GFP_NOFS);
e45c5405	314	if (*sptr == NULL) {
b87d1d26	315	errcode = -ENOMEM;
ace51c4d EVH	316	break;
ace51c4d EVH	317	}
219fd58b	318	if (pdu_read(pdu, *sptr, len)) {
ace51c4d	319	errcode = -EFAULT;
e45c5405 EVH	320	kfree(*sptr);
e45c5405 EVH	321	*sptr = NULL;
ace51c4d	322	} else
219fd58b	323	(*sptr)[len] = 0;
ace51c4d EVH	324	}
ace51c4d EVH	325	break;
97fc8b1e EB	326	case 'u': {
	327	kuid_t uid = va_arg(ap, kuid_t );
	328	__le32 le_val;
	329	if (pdu_read(pdu, &le_val, sizeof(le_val))) {
	330	errcode = -EFAULT;
	331	break;
	332	}
	333	*uid = make_kuid(&init_user_ns,
	334	le32_to_cpu(le_val));
	335	} break;
	336	case 'g': {
	337	kgid_t gid = va_arg(ap, kgid_t );
	338	__le32 le_val;
	339	if (pdu_read(pdu, &le_val, sizeof(le_val))) {
	340	errcode = -EFAULT;
	341	break;
	342	}
	343	*gid = make_kgid(&init_user_ns,
	344	le32_to_cpu(le_val));
	345	} break;
ace51c4d EVH	346	case 'Q':{
	347	struct p9_qid *qid =
	348	va_arg(ap, struct p9_qid *);
	349
342fee1d	350	errcode = p9pdu_readf(pdu, proto_version, "bdq",
ace51c4d EVH	351	&qid->type, &qid->version,
	352	&qid->path);
	353	}
	354	break;
	355	case 'S':{
	356	struct p9_wstat *stbuf =
	357	va_arg(ap, struct p9_wstat *);
	358
f0a0ac2e	359	memset(stbuf, 0, sizeof(struct p9_wstat));
447c5094 EB	360	stbuf->n_uid = stbuf->n_muid = INVALID_UID;
	361	stbuf->n_gid = INVALID_GID;
	362
ace51c4d	363	errcode =
342fee1d	364	p9pdu_readf(pdu, proto_version,
447c5094	365	"wwdQdddqssss?sugu",
ace51c4d EVH	366	&stbuf->size, &stbuf->type,
	367	&stbuf->dev, &stbuf->qid,
	368	&stbuf->mode, &stbuf->atime,
	369	&stbuf->mtime, &stbuf->length,
	370	&stbuf->name, &stbuf->uid,
	371	&stbuf->gid, &stbuf->muid,
	372	&stbuf->extension,
	373	&stbuf->n_uid, &stbuf->n_gid,
	374	&stbuf->n_muid);
	375	if (errcode)
	376	p9stat_free(stbuf);
	377	}
	378	break;
	379	case 'D':{
219fd58b	380	uint32_t count = va_arg(ap, uint32_t );
ace51c4d EVH	381	void data = va_arg(ap, void );
	382
	383	errcode =
342fee1d	384	p9pdu_readf(pdu, proto_version, "d", count);
ace51c4d EVH	385	if (!errcode) {
ace51c4d EVH	386	*count =
219fd58b	387	min_t(uint32_t, *count,
01b0c5cf	388	pdu->size - pdu->offset);
ace51c4d EVH	389	*data = &pdu->sdata[pdu->offset];
	390	}
	391	}
	392	break;
	393	case 'T':{
b76225e2	394	uint16_t nwname = va_arg(ap, uint16_t );
ace51c4d EVH	395	char *wnames = va_arg(ap, char *);
ace51c4d EVH	396
342fee1d SK	397	errcode = p9pdu_readf(pdu, proto_version,
342fee1d SK	398	"w", nwname);
ace51c4d EVH	399	if (!errcode) {
ace51c4d EVH	400	*wnames =
6da2ec56 KC	401	kmalloc_array(*nwname,
	402	sizeof(char *),
	403	GFP_NOFS);
ace51c4d EVH	404	if (!*wnames)
	405	errcode = -ENOMEM;
	406	}
	407
	408	if (!errcode) {
	409	int i;
	410
	411	for (i = 0; i < *nwname; i++) {
	412	errcode =
342fee1d SK	413	p9pdu_readf(pdu,
342fee1d SK	414	proto_version,
ace51c4d EVH	415	"s",
	416	&(*wnames)[i]);
	417	if (errcode)
	418	break;
	419	}
	420	}
	421
	422	if (errcode) {
	423	if (*wnames) {
	424	int i;
	425
	426	for (i = 0; i < *nwname; i++)
	427	kfree((*wnames)[i]);
	428	}
	429	kfree(*wnames);
	430	*wnames = NULL;
	431	}
	432	}
	433	break;
	434	case 'R':{
6250a8ba	435	uint16_t nwqid = va_arg(ap, uint16_t );
ace51c4d EVH	436	struct p9_qid **wqids =
	437	va_arg(ap, struct p9_qid **);
	438
	439	*wqids = NULL;
	440
	441	errcode =
342fee1d	442	p9pdu_readf(pdu, proto_version, "w", nwqid);
ace51c4d EVH	443	if (!errcode) {
ace51c4d EVH	444	*wqids =
6da2ec56 KC	445	kmalloc_array(*nwqid,
	446	sizeof(struct p9_qid),
	447	GFP_NOFS);
ace51c4d EVH	448	if (*wqids == NULL)
	449	errcode = -ENOMEM;
	450	}
	451
	452	if (!errcode) {
	453	int i;
	454
	455	for (i = 0; i < *nwqid; i++) {
	456	errcode =
342fee1d SK	457	p9pdu_readf(pdu,
342fee1d SK	458	proto_version,
ace51c4d EVH	459	"Q",
	460	&(*wqids)[i]);
	461	if (errcode)
	462	break;
	463	}
	464	}
	465
	466	if (errcode) {
	467	kfree(*wqids);
	468	*wqids = NULL;
	469	}
	470	}
	471	break;
f0853122 SK	472	case 'A': {
	473	struct p9_stat_dotl *stbuf =
	474	va_arg(ap, struct p9_stat_dotl *);
	475
	476	memset(stbuf, 0, sizeof(struct p9_stat_dotl));
	477	errcode =
	478	p9pdu_readf(pdu, proto_version,
447c5094	479	"qQdugqqqqqqqqqqqqqqq",
f0853122 SK	480	&stbuf->st_result_mask,
	481	&stbuf->qid,
	482	&stbuf->st_mode,
	483	&stbuf->st_uid, &stbuf->st_gid,
	484	&stbuf->st_nlink,
	485	&stbuf->st_rdev, &stbuf->st_size,
	486	&stbuf->st_blksize, &stbuf->st_blocks,
	487	&stbuf->st_atime_sec,
	488	&stbuf->st_atime_nsec,
	489	&stbuf->st_mtime_sec,
	490	&stbuf->st_mtime_nsec,
	491	&stbuf->st_ctime_sec,
	492	&stbuf->st_ctime_nsec,
	493	&stbuf->st_btime_sec,
	494	&stbuf->st_btime_nsec,
	495	&stbuf->st_gen,
	496	&stbuf->st_data_version);
	497	}
	498	break;
ace51c4d	499	case '?':
c56e4acf SK	500	if ((proto_version != p9_proto_2000u) &&
c56e4acf SK	501	(proto_version != p9_proto_2000L))
ace51c4d EVH	502	return 0;
	503	break;
	504	default:
	505	BUG();
	506	break;
	507	}
	508
	509	if (errcode)
	510	break;
	511	}
	512
	513	return errcode;
	514	}
	515
	516	int
342fee1d SK	517	p9pdu_vwritef(struct p9_fcall pdu, int proto_version, const char fmt,
342fee1d SK	518	va_list ap)
ace51c4d EVH	519	{
	520	const char *ptr;
	521	int errcode = 0;
	522
	523	for (ptr = fmt; *ptr; ptr++) {
	524	switch (*ptr) {
	525	case 'b':{
	526	int8_t val = va_arg(ap, int);
	527	if (pdu_write(pdu, &val, sizeof(val)))
	528	errcode = -EFAULT;
	529	}
	530	break;
	531	case 'w':{
beeebc92	532	__le16 val = cpu_to_le16(va_arg(ap, int));
ace51c4d EVH	533	if (pdu_write(pdu, &val, sizeof(val)))
	534	errcode = -EFAULT;
	535	}
	536	break;
	537	case 'd':{
beeebc92	538	__le32 val = cpu_to_le32(va_arg(ap, int32_t));
ace51c4d EVH	539	if (pdu_write(pdu, &val, sizeof(val)))
	540	errcode = -EFAULT;
	541	}
	542	break;
	543	case 'q':{
beeebc92	544	__le64 val = cpu_to_le64(va_arg(ap, int64_t));
ace51c4d EVH	545	if (pdu_write(pdu, &val, sizeof(val)))
	546	errcode = -EFAULT;
	547	}
	548	break;
	549	case 's':{
e45c5405	550	const char sptr = va_arg(ap, const char );
219fd58b	551	uint16_t len = 0;
e45c5405	552	if (sptr)
d31bb4f0	553	len = min_t(size_t, strlen(sptr),
219fd58b	554	USHRT_MAX);
ace51c4d	555
342fee1d SK	556	errcode = p9pdu_writef(pdu, proto_version,
342fee1d SK	557	"w", len);
e45c5405	558	if (!errcode && pdu_write(pdu, sptr, len))
ace51c4d EVH	559	errcode = -EFAULT;
	560	}
	561	break;
97fc8b1e EB	562	case 'u': {
	563	kuid_t uid = va_arg(ap, kuid_t);
	564	__le32 val = cpu_to_le32(
	565	from_kuid(&init_user_ns, uid));
	566	if (pdu_write(pdu, &val, sizeof(val)))
	567	errcode = -EFAULT;
	568	} break;
	569	case 'g': {
	570	kgid_t gid = va_arg(ap, kgid_t);
	571	__le32 val = cpu_to_le32(
	572	from_kgid(&init_user_ns, gid));
	573	if (pdu_write(pdu, &val, sizeof(val)))
	574	errcode = -EFAULT;
	575	} break;
ace51c4d EVH	576	case 'Q':{
	577	const struct p9_qid *qid =
	578	va_arg(ap, const struct p9_qid *);
	579	errcode =
342fee1d	580	p9pdu_writef(pdu, proto_version, "bdq",
ace51c4d EVH	581	qid->type, qid->version,
	582	qid->path);
	583	} break;
	584	case 'S':{
	585	const struct p9_wstat *stbuf =
	586	va_arg(ap, const struct p9_wstat *);
	587	errcode =
342fee1d	588	p9pdu_writef(pdu, proto_version,
447c5094	589	"wwdQdddqssss?sugu",
ace51c4d	590	stbuf->size, stbuf->type,
51a87c55	591	stbuf->dev, &stbuf->qid,
ace51c4d EVH	592	stbuf->mode, stbuf->atime,
	593	stbuf->mtime, stbuf->length,
	594	stbuf->name, stbuf->uid,
	595	stbuf->gid, stbuf->muid,
	596	stbuf->extension, stbuf->n_uid,
	597	stbuf->n_gid, stbuf->n_muid);
	598	} break;
4f3b35c1	599	case 'V':{
6250a8ba	600	uint32_t count = va_arg(ap, uint32_t);
4f3b35c1 AV	601	struct iov_iter *from =
4f3b35c1 AV	602	va_arg(ap, struct iov_iter *);
342fee1d SK	603	errcode = p9pdu_writef(pdu, proto_version, "d",
342fee1d SK	604	count);
4f3b35c1	605	if (!errcode && pdu_write_u(pdu, from, count))
51a87c55 EVH	606	errcode = -EFAULT;
	607	}
	608	break;
ace51c4d	609	case 'T':{
b76225e2	610	uint16_t nwname = va_arg(ap, int);
ace51c4d EVH	611	const char wnames = va_arg(ap, const char );
ace51c4d EVH	612
342fee1d SK	613	errcode = p9pdu_writef(pdu, proto_version, "w",
342fee1d SK	614	nwname);
ace51c4d EVH	615	if (!errcode) {
	616	int i;
	617
	618	for (i = 0; i < nwname; i++) {
	619	errcode =
342fee1d SK	620	p9pdu_writef(pdu,
342fee1d SK	621	proto_version,
ace51c4d EVH	622	"s",
	623	wnames[i]);
	624	if (errcode)
	625	break;
	626	}
	627	}
	628	}
	629	break;
	630	case 'R':{
6250a8ba	631	uint16_t nwqid = va_arg(ap, int);
ace51c4d EVH	632	struct p9_qid *wqids =
	633	va_arg(ap, struct p9_qid *);
	634
342fee1d SK	635	errcode = p9pdu_writef(pdu, proto_version, "w",
342fee1d SK	636	nwqid);
ace51c4d EVH	637	if (!errcode) {
	638	int i;
	639
	640	for (i = 0; i < nwqid; i++) {
	641	errcode =
342fee1d SK	642	p9pdu_writef(pdu,
342fee1d SK	643	proto_version,
ace51c4d EVH	644	"Q",
	645	&wqids[i]);
	646	if (errcode)
	647	break;
	648	}
	649	}
	650	}
	651	break;
87d7845a SK	652	case 'I':{
	653	struct p9_iattr_dotl *p9attr = va_arg(ap,
	654	struct p9_iattr_dotl *);
	655
	656	errcode = p9pdu_writef(pdu, proto_version,
447c5094	657	"ddugqqqqq",
87d7845a SK	658	p9attr->valid,
	659	p9attr->mode,
	660	p9attr->uid,
	661	p9attr->gid,
	662	p9attr->size,
	663	p9attr->atime_sec,
	664	p9attr->atime_nsec,
	665	p9attr->mtime_sec,
	666	p9attr->mtime_nsec);
	667	}
	668	break;
ace51c4d	669	case '?':
c56e4acf SK	670	if ((proto_version != p9_proto_2000u) &&
c56e4acf SK	671	(proto_version != p9_proto_2000L))
ace51c4d EVH	672	return 0;
	673	break;
	674	default:
	675	BUG();
	676	break;
	677	}
	678
	679	if (errcode)
	680	break;
	681	}
	682
	683	return errcode;
	684	}
	685
342fee1d	686	int p9pdu_readf(struct p9_fcall pdu, int proto_version, const char fmt, ...)
ace51c4d EVH	687	{
	688	va_list ap;
	689	int ret;
	690
	691	va_start(ap, fmt);
342fee1d	692	ret = p9pdu_vreadf(pdu, proto_version, fmt, ap);
ace51c4d EVH	693	va_end(ap);
	694
	695	return ret;
	696	}
	697
	698	static int
342fee1d	699	p9pdu_writef(struct p9_fcall pdu, int proto_version, const char fmt, ...)
ace51c4d EVH	700	{
	701	va_list ap;
	702	int ret;
	703
	704	va_start(ap, fmt);
342fee1d	705	ret = p9pdu_vwritef(pdu, proto_version, fmt, ap);
ace51c4d EVH	706	va_end(ap);
	707
	708	return ret;
	709	}
51a87c55	710
348b5901	711	int p9stat_read(struct p9_client clnt, char buf, int len, struct p9_wstat *st)
02da398b EVH	712	{
02da398b EVH	713	struct p9_fcall fake_pdu;
e7f4b8f1	714	int ret;
02da398b EVH	715
	716	fake_pdu.size = len;
	717	fake_pdu.capacity = len;
	718	fake_pdu.sdata = buf;
	719	fake_pdu.offset = 0;
	720
348b5901	721	ret = p9pdu_readf(&fake_pdu, clnt->proto_version, "S", st);
e7f4b8f1	722	if (ret) {
5d385153	723	p9_debug(P9_DEBUG_9P, "<<< p9stat_read failed: %d\n", ret);
348b5901	724	trace_9p_protocol_dump(clnt, &fake_pdu);
2803cf43	725	return ret;
e7f4b8f1 EVH	726	}
e7f4b8f1 EVH	727
2803cf43	728	return fake_pdu.offset;
02da398b EVH	729	}
	730	EXPORT_SYMBOL(p9stat_read);
	731
51a87c55 EVH	732	int p9pdu_prepare(struct p9_fcall *pdu, int16_t tag, int8_t type)
51a87c55 EVH	733	{
9bb6c10a	734	pdu->id = type;
51a87c55 EVH	735	return p9pdu_writef(pdu, 0, "dbw", 0, type, tag);
	736	}
	737
348b5901	738	int p9pdu_finalize(struct p9_client clnt, struct p9_fcall pdu)
51a87c55 EVH	739	{
	740	int size = pdu->size;
	741	int err;
	742
	743	pdu->size = 0;
	744	err = p9pdu_writef(pdu, 0, "d", size);
	745	pdu->size = size;
	746
348b5901	747	trace_9p_protocol_dump(clnt, pdu);
5d385153 JP	748	p9_debug(P9_DEBUG_9P, ">>> size=%d type: %d tag: %d\n",
5d385153 JP	749	pdu->size, pdu->id, pdu->tag);
e7f4b8f1	750
51a87c55 EVH	751	return err;
	752	}
	753
	754	void p9pdu_reset(struct p9_fcall *pdu)
	755	{
	756	pdu->offset = 0;
	757	pdu->size = 0;
	758	}
7751bdb3	759
348b5901 AK	760	int p9dirent_read(struct p9_client clnt, char buf, int len,
348b5901 AK	761	struct p9_dirent *dirent)
7751bdb3 SK	762	{
	763	struct p9_fcall fake_pdu;
	764	int ret;
	765	char *nameptr;
	766
	767	fake_pdu.size = len;
	768	fake_pdu.capacity = len;
	769	fake_pdu.sdata = buf;
	770	fake_pdu.offset = 0;
	771
348b5901 AK	772	ret = p9pdu_readf(&fake_pdu, clnt->proto_version, "Qqbs", &dirent->qid,
348b5901 AK	773	&dirent->d_off, &dirent->d_type, &nameptr);
7751bdb3	774	if (ret) {
5d385153	775	p9_debug(P9_DEBUG_9P, "<<< p9dirent_read failed: %d\n", ret);
348b5901	776	trace_9p_protocol_dump(clnt, &fake_pdu);
ef5305f1	777	return ret;
7751bdb3 SK	778	}
7751bdb3 SK	779
ef5305f1 DM	780	ret = strscpy(dirent->d_name, nameptr, sizeof(dirent->d_name));
	781	if (ret < 0) {
	782	p9_debug(P9_DEBUG_ERROR,
	783	"On the wire dirent name too long: %s\n",
	784	nameptr);
	785	kfree(nameptr);
	786	return ret;
	787	}
1b0bcbcf	788	kfree(nameptr);
7751bdb3	789
7751bdb3 SK	790	return fake_pdu.offset;
	791	}
	792	EXPORT_SYMBOL(p9dirent_read);