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

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
ace51c4d	26	static int
342fee1d	27	p9pdu_writef(struct p9_fcall pdu, int proto_version, const char fmt, ...);
ace51c4d EVH	28
	29	void p9stat_free(struct p9_wstat *stbuf)
	30	{
	31	kfree(stbuf->name);
62e39417	32	stbuf->name = NULL;
ace51c4d	33	kfree(stbuf->uid);
62e39417	34	stbuf->uid = NULL;
ace51c4d	35	kfree(stbuf->gid);
62e39417	36	stbuf->gid = NULL;
ace51c4d	37	kfree(stbuf->muid);
62e39417	38	stbuf->muid = NULL;
ace51c4d	39	kfree(stbuf->extension);
62e39417	40	stbuf->extension = NULL;
ace51c4d EVH	41	}
	42	EXPORT_SYMBOL(p9stat_free);
	43
abfa034e	44	size_t pdu_read(struct p9_fcall pdu, void data, size_t size)
ace51c4d	45	{
01b0c5cf	46	size_t len = min(pdu->size - pdu->offset, size);
6e195b0f	47
ace51c4d EVH	48	memcpy(data, &pdu->sdata[pdu->offset], len);
	49	pdu->offset += len;
	50	return size - len;
	51	}
	52
	53	static size_t pdu_write(struct p9_fcall pdu, const void data, size_t size)
	54	{
01b0c5cf	55	size_t len = min(pdu->capacity - pdu->size, size);
6e195b0f	56
ace51c4d EVH	57	memcpy(&pdu->sdata[pdu->size], data, len);
	58	pdu->size += len;
	59	return size - len;
	60	}
	61
51a87c55	62	static size_t
4f3b35c1	63	pdu_write_u(struct p9_fcall pdu, struct iov_iter from, size_t size)
51a87c55	64	{
01b0c5cf	65	size_t len = min(pdu->capacity - pdu->size, size);
6e195b0f	66
7f024647	67	if (!copy_from_iter_full(&pdu->sdata[pdu->size], len, from))
7b3bb3fe	68	len = 0;
51a87c55 EVH	69
	70	pdu->size += len;
	71	return size - len;
	72	}
	73
6e195b0f DM	74	/* b - int8_t
	75	* w - int16_t
	76	* d - int32_t
	77	* q - int64_t
	78	* s - string
	79	* u - numeric uid
	80	* g - numeric gid
	81	* S - stat
	82	* Q - qid
	83	* D - data blob (int32_t size followed by void *, results are not freed)
	84	* T - array of strings (int16_t count, followed by strings)
	85	* R - array of qids (int16_t count, followed by qids)
	86	* A - stat for 9p2000.L (p9_stat_dotl)
	87	* ? - if optional = 1, continue parsing
	88	*/
ace51c4d EVH	89
ace51c4d EVH	90	static int
342fee1d	91	p9pdu_vreadf(struct p9_fcall pdu, int proto_version, const char fmt,
6e195b0f	92	va_list ap)
ace51c4d EVH	93	{
	94	const char *ptr;
	95	int errcode = 0;
	96
	97	for (ptr = fmt; *ptr; ptr++) {
	98	switch (*ptr) {
	99	case 'b':{
	100	int8_t val = va_arg(ap, int8_t );
	101	if (pdu_read(pdu, val, sizeof(*val))) {
	102	errcode = -EFAULT;
	103	break;
	104	}
	105	}
	106	break;
	107	case 'w':{
	108	int16_t val = va_arg(ap, int16_t );
beeebc92 EVH	109	__le16 le_val;
beeebc92 EVH	110	if (pdu_read(pdu, &le_val, sizeof(le_val))) {
ace51c4d EVH	111	errcode = -EFAULT;
	112	break;
	113	}
beeebc92	114	*val = le16_to_cpu(le_val);
ace51c4d EVH	115	}
	116	break;
	117	case 'd':{
	118	int32_t val = va_arg(ap, int32_t );
beeebc92 EVH	119	__le32 le_val;
beeebc92 EVH	120	if (pdu_read(pdu, &le_val, sizeof(le_val))) {
ace51c4d EVH	121	errcode = -EFAULT;
	122	break;
	123	}
beeebc92	124	*val = le32_to_cpu(le_val);
ace51c4d EVH	125	}
	126	break;
	127	case 'q':{
	128	int64_t val = va_arg(ap, int64_t );
beeebc92 EVH	129	__le64 le_val;
beeebc92 EVH	130	if (pdu_read(pdu, &le_val, sizeof(le_val))) {
ace51c4d EVH	131	errcode = -EFAULT;
	132	break;
	133	}
beeebc92	134	*val = le64_to_cpu(le_val);
ace51c4d EVH	135	}
	136	break;
	137	case 's':{
e45c5405	138	char sptr = va_arg(ap, char );
219fd58b	139	uint16_t len;
ace51c4d	140
342fee1d SK	141	errcode = p9pdu_readf(pdu, proto_version,
342fee1d SK	142	"w", &len);
ace51c4d EVH	143	if (errcode)
	144	break;
	145
eeff66ef	146	*sptr = kmalloc(len + 1, GFP_NOFS);
e45c5405	147	if (*sptr == NULL) {
b87d1d26	148	errcode = -ENOMEM;
ace51c4d EVH	149	break;
ace51c4d EVH	150	}
219fd58b	151	if (pdu_read(pdu, *sptr, len)) {
ace51c4d	152	errcode = -EFAULT;
e45c5405 EVH	153	kfree(*sptr);
e45c5405 EVH	154	*sptr = NULL;
ace51c4d	155	} else
219fd58b	156	(*sptr)[len] = 0;
ace51c4d EVH	157	}
ace51c4d EVH	158	break;
97fc8b1e EB	159	case 'u': {
	160	kuid_t uid = va_arg(ap, kuid_t );
	161	__le32 le_val;
	162	if (pdu_read(pdu, &le_val, sizeof(le_val))) {
	163	errcode = -EFAULT;
	164	break;
	165	}
	166	*uid = make_kuid(&init_user_ns,
	167	le32_to_cpu(le_val));
	168	} break;
	169	case 'g': {
	170	kgid_t gid = va_arg(ap, kgid_t );
	171	__le32 le_val;
	172	if (pdu_read(pdu, &le_val, sizeof(le_val))) {
	173	errcode = -EFAULT;
	174	break;
	175	}
	176	*gid = make_kgid(&init_user_ns,
	177	le32_to_cpu(le_val));
	178	} break;
ace51c4d EVH	179	case 'Q':{
	180	struct p9_qid *qid =
	181	va_arg(ap, struct p9_qid *);
	182
342fee1d	183	errcode = p9pdu_readf(pdu, proto_version, "bdq",
ace51c4d EVH	184	&qid->type, &qid->version,
	185	&qid->path);
	186	}
	187	break;
	188	case 'S':{
	189	struct p9_wstat *stbuf =
	190	va_arg(ap, struct p9_wstat *);
	191
f0a0ac2e	192	memset(stbuf, 0, sizeof(struct p9_wstat));
447c5094 EB	193	stbuf->n_uid = stbuf->n_muid = INVALID_UID;
	194	stbuf->n_gid = INVALID_GID;
	195
ace51c4d	196	errcode =
342fee1d	197	p9pdu_readf(pdu, proto_version,
447c5094	198	"wwdQdddqssss?sugu",
ace51c4d EVH	199	&stbuf->size, &stbuf->type,
	200	&stbuf->dev, &stbuf->qid,
	201	&stbuf->mode, &stbuf->atime,
	202	&stbuf->mtime, &stbuf->length,
	203	&stbuf->name, &stbuf->uid,
	204	&stbuf->gid, &stbuf->muid,
	205	&stbuf->extension,
	206	&stbuf->n_uid, &stbuf->n_gid,
	207	&stbuf->n_muid);
	208	if (errcode)
	209	p9stat_free(stbuf);
	210	}
	211	break;
	212	case 'D':{
219fd58b	213	uint32_t count = va_arg(ap, uint32_t );
ace51c4d EVH	214	void data = va_arg(ap, void );
	215
	216	errcode =
342fee1d	217	p9pdu_readf(pdu, proto_version, "d", count);
ace51c4d EVH	218	if (!errcode) {
ace51c4d EVH	219	*count =
219fd58b	220	min_t(uint32_t, *count,
01b0c5cf	221	pdu->size - pdu->offset);
ace51c4d EVH	222	*data = &pdu->sdata[pdu->offset];
	223	}
	224	}
	225	break;
	226	case 'T':{
b76225e2	227	uint16_t nwname = va_arg(ap, uint16_t );
ace51c4d EVH	228	char *wnames = va_arg(ap, char *);
ace51c4d EVH	229
342fee1d SK	230	errcode = p9pdu_readf(pdu, proto_version,
342fee1d SK	231	"w", nwname);
ace51c4d EVH	232	if (!errcode) {
ace51c4d EVH	233	*wnames =
6da2ec56 KC	234	kmalloc_array(*nwname,
	235	sizeof(char *),
	236	GFP_NOFS);
ace51c4d EVH	237	if (!*wnames)
	238	errcode = -ENOMEM;
	239	}
	240
	241	if (!errcode) {
	242	int i;
	243
	244	for (i = 0; i < *nwname; i++) {
	245	errcode =
342fee1d SK	246	p9pdu_readf(pdu,
342fee1d SK	247	proto_version,
ace51c4d EVH	248	"s",
	249	&(*wnames)[i]);
	250	if (errcode)
	251	break;
	252	}
	253	}
	254
	255	if (errcode) {
	256	if (*wnames) {
	257	int i;
	258
	259	for (i = 0; i < *nwname; i++)
	260	kfree((*wnames)[i]);
	261	}
	262	kfree(*wnames);
	263	*wnames = NULL;
	264	}
	265	}
	266	break;
	267	case 'R':{
6250a8ba	268	uint16_t nwqid = va_arg(ap, uint16_t );
ace51c4d EVH	269	struct p9_qid **wqids =
	270	va_arg(ap, struct p9_qid **);
	271
	272	*wqids = NULL;
	273
	274	errcode =
342fee1d	275	p9pdu_readf(pdu, proto_version, "w", nwqid);
ace51c4d EVH	276	if (!errcode) {
ace51c4d EVH	277	*wqids =
6da2ec56 KC	278	kmalloc_array(*nwqid,
	279	sizeof(struct p9_qid),
	280	GFP_NOFS);
ace51c4d EVH	281	if (*wqids == NULL)
	282	errcode = -ENOMEM;
	283	}
	284
	285	if (!errcode) {
	286	int i;
	287
	288	for (i = 0; i < *nwqid; i++) {
	289	errcode =
342fee1d SK	290	p9pdu_readf(pdu,
342fee1d SK	291	proto_version,
ace51c4d EVH	292	"Q",
	293	&(*wqids)[i]);
	294	if (errcode)
	295	break;
	296	}
	297	}
	298
	299	if (errcode) {
	300	kfree(*wqids);
	301	*wqids = NULL;
	302	}
	303	}
	304	break;
f0853122 SK	305	case 'A': {
	306	struct p9_stat_dotl *stbuf =
	307	va_arg(ap, struct p9_stat_dotl *);
	308
	309	memset(stbuf, 0, sizeof(struct p9_stat_dotl));
	310	errcode =
	311	p9pdu_readf(pdu, proto_version,
447c5094	312	"qQdugqqqqqqqqqqqqqqq",
f0853122 SK	313	&stbuf->st_result_mask,
	314	&stbuf->qid,
	315	&stbuf->st_mode,
	316	&stbuf->st_uid, &stbuf->st_gid,
	317	&stbuf->st_nlink,
	318	&stbuf->st_rdev, &stbuf->st_size,
	319	&stbuf->st_blksize, &stbuf->st_blocks,
	320	&stbuf->st_atime_sec,
	321	&stbuf->st_atime_nsec,
	322	&stbuf->st_mtime_sec,
	323	&stbuf->st_mtime_nsec,
	324	&stbuf->st_ctime_sec,
	325	&stbuf->st_ctime_nsec,
	326	&stbuf->st_btime_sec,
	327	&stbuf->st_btime_nsec,
	328	&stbuf->st_gen,
	329	&stbuf->st_data_version);
	330	}
	331	break;
ace51c4d	332	case '?':
c56e4acf SK	333	if ((proto_version != p9_proto_2000u) &&
c56e4acf SK	334	(proto_version != p9_proto_2000L))
ace51c4d EVH	335	return 0;
	336	break;
	337	default:
	338	BUG();
	339	break;
	340	}
	341
	342	if (errcode)
	343	break;
	344	}
	345
	346	return errcode;
	347	}
	348
	349	int
342fee1d SK	350	p9pdu_vwritef(struct p9_fcall pdu, int proto_version, const char fmt,
342fee1d SK	351	va_list ap)
ace51c4d EVH	352	{
	353	const char *ptr;
	354	int errcode = 0;
	355
	356	for (ptr = fmt; *ptr; ptr++) {
	357	switch (*ptr) {
	358	case 'b':{
	359	int8_t val = va_arg(ap, int);
	360	if (pdu_write(pdu, &val, sizeof(val)))
	361	errcode = -EFAULT;
	362	}
	363	break;
	364	case 'w':{
beeebc92	365	__le16 val = cpu_to_le16(va_arg(ap, int));
ace51c4d EVH	366	if (pdu_write(pdu, &val, sizeof(val)))
	367	errcode = -EFAULT;
	368	}
	369	break;
	370	case 'd':{
beeebc92	371	__le32 val = cpu_to_le32(va_arg(ap, int32_t));
ace51c4d EVH	372	if (pdu_write(pdu, &val, sizeof(val)))
	373	errcode = -EFAULT;
	374	}
	375	break;
	376	case 'q':{
beeebc92	377	__le64 val = cpu_to_le64(va_arg(ap, int64_t));
ace51c4d EVH	378	if (pdu_write(pdu, &val, sizeof(val)))
	379	errcode = -EFAULT;
	380	}
	381	break;
	382	case 's':{
e45c5405	383	const char sptr = va_arg(ap, const char );
219fd58b	384	uint16_t len = 0;
e45c5405	385	if (sptr)
d31bb4f0	386	len = min_t(size_t, strlen(sptr),
219fd58b	387	USHRT_MAX);
ace51c4d	388
342fee1d SK	389	errcode = p9pdu_writef(pdu, proto_version,
342fee1d SK	390	"w", len);
e45c5405	391	if (!errcode && pdu_write(pdu, sptr, len))
ace51c4d EVH	392	errcode = -EFAULT;
	393	}
	394	break;
97fc8b1e EB	395	case 'u': {
	396	kuid_t uid = va_arg(ap, kuid_t);
	397	__le32 val = cpu_to_le32(
	398	from_kuid(&init_user_ns, uid));
	399	if (pdu_write(pdu, &val, sizeof(val)))
	400	errcode = -EFAULT;
	401	} break;
	402	case 'g': {
	403	kgid_t gid = va_arg(ap, kgid_t);
	404	__le32 val = cpu_to_le32(
	405	from_kgid(&init_user_ns, gid));
	406	if (pdu_write(pdu, &val, sizeof(val)))
	407	errcode = -EFAULT;
	408	} break;
ace51c4d EVH	409	case 'Q':{
	410	const struct p9_qid *qid =
	411	va_arg(ap, const struct p9_qid *);
	412	errcode =
342fee1d	413	p9pdu_writef(pdu, proto_version, "bdq",
ace51c4d EVH	414	qid->type, qid->version,
	415	qid->path);
	416	} break;
	417	case 'S':{
	418	const struct p9_wstat *stbuf =
	419	va_arg(ap, const struct p9_wstat *);
	420	errcode =
342fee1d	421	p9pdu_writef(pdu, proto_version,
447c5094	422	"wwdQdddqssss?sugu",
ace51c4d	423	stbuf->size, stbuf->type,
51a87c55	424	stbuf->dev, &stbuf->qid,
ace51c4d EVH	425	stbuf->mode, stbuf->atime,
	426	stbuf->mtime, stbuf->length,
	427	stbuf->name, stbuf->uid,
	428	stbuf->gid, stbuf->muid,
	429	stbuf->extension, stbuf->n_uid,
	430	stbuf->n_gid, stbuf->n_muid);
	431	} break;
4f3b35c1	432	case 'V':{
6250a8ba	433	uint32_t count = va_arg(ap, uint32_t);
4f3b35c1 AV	434	struct iov_iter *from =
4f3b35c1 AV	435	va_arg(ap, struct iov_iter *);
342fee1d SK	436	errcode = p9pdu_writef(pdu, proto_version, "d",
342fee1d SK	437	count);
4f3b35c1	438	if (!errcode && pdu_write_u(pdu, from, count))
51a87c55 EVH	439	errcode = -EFAULT;
	440	}
	441	break;
ace51c4d	442	case 'T':{
b76225e2	443	uint16_t nwname = va_arg(ap, int);
ace51c4d EVH	444	const char wnames = va_arg(ap, const char );
ace51c4d EVH	445
342fee1d SK	446	errcode = p9pdu_writef(pdu, proto_version, "w",
342fee1d SK	447	nwname);
ace51c4d EVH	448	if (!errcode) {
	449	int i;
	450
	451	for (i = 0; i < nwname; i++) {
	452	errcode =
342fee1d SK	453	p9pdu_writef(pdu,
342fee1d SK	454	proto_version,
ace51c4d EVH	455	"s",
	456	wnames[i]);
	457	if (errcode)
	458	break;
	459	}
	460	}
	461	}
	462	break;
	463	case 'R':{
6250a8ba	464	uint16_t nwqid = va_arg(ap, int);
ace51c4d EVH	465	struct p9_qid *wqids =
	466	va_arg(ap, struct p9_qid *);
	467
342fee1d SK	468	errcode = p9pdu_writef(pdu, proto_version, "w",
342fee1d SK	469	nwqid);
ace51c4d EVH	470	if (!errcode) {
	471	int i;
	472
	473	for (i = 0; i < nwqid; i++) {
	474	errcode =
342fee1d SK	475	p9pdu_writef(pdu,
342fee1d SK	476	proto_version,
ace51c4d EVH	477	"Q",
	478	&wqids[i]);
	479	if (errcode)
	480	break;
	481	}
	482	}
	483	}
	484	break;
87d7845a SK	485	case 'I':{
	486	struct p9_iattr_dotl *p9attr = va_arg(ap,
	487	struct p9_iattr_dotl *);
	488
	489	errcode = p9pdu_writef(pdu, proto_version,
447c5094	490	"ddugqqqqq",
87d7845a SK	491	p9attr->valid,
	492	p9attr->mode,
	493	p9attr->uid,
	494	p9attr->gid,
	495	p9attr->size,
	496	p9attr->atime_sec,
	497	p9attr->atime_nsec,
	498	p9attr->mtime_sec,
	499	p9attr->mtime_nsec);
	500	}
	501	break;
ace51c4d	502	case '?':
c56e4acf SK	503	if ((proto_version != p9_proto_2000u) &&
c56e4acf SK	504	(proto_version != p9_proto_2000L))
ace51c4d EVH	505	return 0;
	506	break;
	507	default:
	508	BUG();
	509	break;
	510	}
	511
	512	if (errcode)
	513	break;
	514	}
	515
	516	return errcode;
	517	}
	518
342fee1d	519	int p9pdu_readf(struct p9_fcall pdu, int proto_version, const char fmt, ...)
ace51c4d EVH	520	{
	521	va_list ap;
	522	int ret;
	523
	524	va_start(ap, fmt);
342fee1d	525	ret = p9pdu_vreadf(pdu, proto_version, fmt, ap);
ace51c4d EVH	526	va_end(ap);
	527
	528	return ret;
	529	}
	530
	531	static int
342fee1d	532	p9pdu_writef(struct p9_fcall pdu, int proto_version, const char fmt, ...)
ace51c4d EVH	533	{
	534	va_list ap;
	535	int ret;
	536
	537	va_start(ap, fmt);
342fee1d	538	ret = p9pdu_vwritef(pdu, proto_version, fmt, ap);
ace51c4d EVH	539	va_end(ap);
	540
	541	return ret;
	542	}
51a87c55	543
348b5901	544	int p9stat_read(struct p9_client clnt, char buf, int len, struct p9_wstat *st)
02da398b EVH	545	{
02da398b EVH	546	struct p9_fcall fake_pdu;
e7f4b8f1	547	int ret;
02da398b EVH	548
	549	fake_pdu.size = len;
	550	fake_pdu.capacity = len;
	551	fake_pdu.sdata = buf;
	552	fake_pdu.offset = 0;
	553
348b5901	554	ret = p9pdu_readf(&fake_pdu, clnt->proto_version, "S", st);
e7f4b8f1	555	if (ret) {
5d385153	556	p9_debug(P9_DEBUG_9P, "<<< p9stat_read failed: %d\n", ret);
348b5901	557	trace_9p_protocol_dump(clnt, &fake_pdu);
2803cf43	558	return ret;
e7f4b8f1 EVH	559	}
e7f4b8f1 EVH	560
2803cf43	561	return fake_pdu.offset;
02da398b EVH	562	}
	563	EXPORT_SYMBOL(p9stat_read);
	564
51a87c55 EVH	565	int p9pdu_prepare(struct p9_fcall *pdu, int16_t tag, int8_t type)
51a87c55 EVH	566	{
9bb6c10a	567	pdu->id = type;
51a87c55 EVH	568	return p9pdu_writef(pdu, 0, "dbw", 0, type, tag);
	569	}
	570
348b5901	571	int p9pdu_finalize(struct p9_client clnt, struct p9_fcall pdu)
51a87c55 EVH	572	{
	573	int size = pdu->size;
	574	int err;
	575
	576	pdu->size = 0;
	577	err = p9pdu_writef(pdu, 0, "d", size);
	578	pdu->size = size;
	579
348b5901	580	trace_9p_protocol_dump(clnt, pdu);
5d385153 JP	581	p9_debug(P9_DEBUG_9P, ">>> size=%d type: %d tag: %d\n",
5d385153 JP	582	pdu->size, pdu->id, pdu->tag);
e7f4b8f1	583
51a87c55 EVH	584	return err;
	585	}
	586
	587	void p9pdu_reset(struct p9_fcall *pdu)
	588	{
	589	pdu->offset = 0;
	590	pdu->size = 0;
	591	}
7751bdb3	592
348b5901 AK	593	int p9dirent_read(struct p9_client clnt, char buf, int len,
348b5901 AK	594	struct p9_dirent *dirent)
7751bdb3 SK	595	{
	596	struct p9_fcall fake_pdu;
	597	int ret;
	598	char *nameptr;
	599
	600	fake_pdu.size = len;
	601	fake_pdu.capacity = len;
	602	fake_pdu.sdata = buf;
	603	fake_pdu.offset = 0;
	604
348b5901 AK	605	ret = p9pdu_readf(&fake_pdu, clnt->proto_version, "Qqbs", &dirent->qid,
348b5901 AK	606	&dirent->d_off, &dirent->d_type, &nameptr);
7751bdb3	607	if (ret) {
5d385153	608	p9_debug(P9_DEBUG_9P, "<<< p9dirent_read failed: %d\n", ret);
348b5901	609	trace_9p_protocol_dump(clnt, &fake_pdu);
ef5305f1	610	return ret;
7751bdb3 SK	611	}
7751bdb3 SK	612
ef5305f1 DM	613	ret = strscpy(dirent->d_name, nameptr, sizeof(dirent->d_name));
	614	if (ret < 0) {
	615	p9_debug(P9_DEBUG_ERROR,
	616	"On the wire dirent name too long: %s\n",
	617	nameptr);
	618	kfree(nameptr);
	619	return ret;
	620	}
1b0bcbcf	621	kfree(nameptr);
7751bdb3	622
7751bdb3 SK	623	return fake_pdu.offset;
	624	}
	625	EXPORT_SYMBOL(p9dirent_read);