[deliverable/linux.git] / net / 9p / protocol.c

/*
 * net/9p/protocol.c
 *
 * 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.
 *
 *  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
 *
 */

#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 <net/9p/9p.h>
#include <net/9p/client.h>
#include "protocol.h"

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

#ifdef CONFIG_NET_9P_DEBUG
void
p9pdu_dump(int way, struct p9_fcall *pdu)
{
	int i, n;
	u8 *data = pdu->sdata;
	int datalen = pdu->size;
	char buf[255];
	int buflen = 255;

	i = n = 0;
	if (datalen > (buflen-16))
		datalen = buflen-16;
	while (i < datalen) {
		n += scnprintf(buf + n, buflen - n, "%02x ", data[i]);
		if (i%4 == 3)
			n += scnprintf(buf + n, buflen - n, " ");
		if (i%32 == 31)
			n += scnprintf(buf + n, buflen - n, "\n");

		i++;
	}
	n += scnprintf(buf + n, buflen - n, "\n");

	if (way)
		P9_DPRINTK(P9_DEBUG_PKT, "[[[(%d) %s\n", datalen, buf);
	else
		P9_DPRINTK(P9_DEBUG_PKT, "]]](%d) %s\n", datalen, buf);
}
#else
void
p9pdu_dump(int way, struct p9_fcall *pdu)
{
}
#endif
EXPORT_SYMBOL(p9pdu_dump);

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

static 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, const char __user *udata, size_t size)
{
	size_t len = min(pdu->capacity - pdu->size, size);
	if (copy_from_user(&pdu->sdata[pdu->size], udata, len))
		len = 0;

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

static size_t
pdu_write_urw(struct p9_fcall *pdu, const char *kdata, const char __user *udata,
		size_t size)
{
	BUG_ON(pdu->size > P9_IOHDRSZ);
	pdu->pubuf = (char __user *)udata;
	pdu->pkbuf = (char *)kdata;
	pdu->pbuf_size = size;
	return 0;
}

static size_t
pdu_write_readdir(struct p9_fcall *pdu, const char *kdata, size_t size)
{
	BUG_ON(pdu->size > P9_READDIRHDRSZ);
	pdu->pkbuf = (char *)kdata;
	pdu->pbuf_size = size;
	return 0;
}

/*
	b - int8_t
	w - int16_t
	d - int32_t
	q - int64_t
	s - string
	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 = -EFAULT;
					break;
				}
				if (pdu_read(pdu, *sptr, len)) {
					errcode = -EFAULT;
					kfree(*sptr);
					*sptr = NULL;
				} else
					(*sptr)[len] = 0;
			}
			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_gid = stbuf->n_muid =
									-1;
				errcode =
				    p9pdu_readf(pdu, proto_version,
						"wwdQdddqssss?sddd",
						&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(sizeof(char *) * *nwname,
						    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':{
				int16_t *nwqid = va_arg(ap, int16_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(*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,
					"qQdddqqqqqqqqqqqqqqq",
					&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(uint16_t, strlen(sptr),
								USHRT_MAX);

				errcode = p9pdu_writef(pdu, proto_version,
								"w", len);
				if (!errcode && pdu_write(pdu, sptr, len))
					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?sddd",
						 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 'D':{
				uint32_t count = va_arg(ap, uint32_t);
				const void *data = va_arg(ap, const void *);

				errcode = p9pdu_writef(pdu, proto_version, "d",
									count);
				if (!errcode && pdu_write(pdu, data, count))
					errcode = -EFAULT;
			}
			break;
		case 'E':{
				 int32_t cnt = va_arg(ap, int32_t);
				 const char *k = va_arg(ap, const void *);
				 const char __user *u = va_arg(ap,
							const void __user *);
				 errcode = p9pdu_writef(pdu, proto_version, "d",
						 cnt);
				 if (!errcode && pdu_write_urw(pdu, k, u, cnt))
					errcode = -EFAULT;
			 }
			 break;
		case 'F':{
				 int32_t cnt = va_arg(ap, int32_t);
				 const char *k = va_arg(ap, const void *);
				 errcode = p9pdu_writef(pdu, proto_version, "d",
						 cnt);
				 if (!errcode && pdu_write_readdir(pdu, k, cnt))
					errcode = -EFAULT;
			 }
			 break;
		case 'U':{
				int32_t count = va_arg(ap, int32_t);
				const char __user *udata =
						va_arg(ap, const void __user *);
				errcode = p9pdu_writef(pdu, proto_version, "d",
									count);
				if (!errcode && pdu_write_u(pdu, udata, 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':{
				int16_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,
							"ddddqqqqq",
							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(char *buf, int len, struct p9_wstat *st, int proto_version)
{
	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, proto_version, "S", st);
	if (ret) {
		P9_DPRINTK(P9_DEBUG_9P, "<<< p9stat_read failed: %d\n", ret);
		p9pdu_dump(1, &fake_pdu);
	}

	return ret;
}
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_fcall *pdu)
{
	int size = pdu->size;
	int err;

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

#ifdef CONFIG_NET_9P_DEBUG
	if ((p9_debug_level & P9_DEBUG_PKT) == P9_DEBUG_PKT)
		p9pdu_dump(0, pdu);
#endif

	P9_DPRINTK(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;
	pdu->private = NULL;
	pdu->pubuf = NULL;
	pdu->pkbuf = NULL;
	pdu->pbuf_size = 0;
}

int p9dirent_read(char *buf, int len, struct p9_dirent *dirent,
						int proto_version)
{
	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, proto_version, "Qqbs", &dirent->qid,
			&dirent->d_off, &dirent->d_type, &nameptr);
	if (ret) {
		P9_DPRINTK(P9_DEBUG_9P, "<<< p9dirent_read failed: %d\n", ret);
		p9pdu_dump(1, &fake_pdu);
		goto out;
	}

	strcpy(dirent->d_name, nameptr);

out:
	return fake_pdu.offset;
}
EXPORT_SYMBOL(p9dirent_read);
Commit	Line	Data
ace51c4d EVH	1	/*
	2	* net/9p/protocol.c
	3	*
	4	* 9P Protocol Support Code
	5	*
	6	* Copyright (C) 2008 by Eric Van Hensbergen <ericvh@gmail.com>
	7	*
	8	* Base on code from Anthony Liguori <aliguori@us.ibm.com>
	9	* Copyright (C) 2008 by IBM, Corp.
	10	*
	11	* This program is free software; you can redistribute it and/or modify
	12	* it under the terms of the GNU General Public License version 2
	13	* as published by the Free Software Foundation.
	14	*
	15	* This program is distributed in the hope that it will be useful,
	16	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	17	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	18	* GNU General Public License for more details.
	19	*
	20	* You should have received a copy of the GNU General Public License
	21	* along with this program; if not, write to:
	22	* Free Software Foundation
	23	* 51 Franklin Street, Fifth Floor
	24	* Boston, MA 02111-1301 USA
	25	*
	26	*/
	27
	28	#include <linux/module.h>
	29	#include <linux/errno.h>
01b0c5cf	30	#include <linux/kernel.h>
51a87c55	31	#include <linux/uaccess.h>
5a0e3ad6	32	#include <linux/slab.h>
e7f4b8f1	33	#include <linux/sched.h>
01b0c5cf	34	#include <linux/stddef.h>
beeebc92	35	#include <linux/types.h>
ace51c4d EVH	36	#include <net/9p/9p.h>
	37	#include <net/9p/client.h>
	38	#include "protocol.h"
	39
ace51c4d	40	static int
342fee1d	41	p9pdu_writef(struct p9_fcall pdu, int proto_version, const char fmt, ...);
ace51c4d	42
0b15a3a5	43	#ifdef CONFIG_NET_9P_DEBUG
51a87c55 EVH	44	void
	45	p9pdu_dump(int way, struct p9_fcall *pdu)
	46	{
	47	int i, n;
	48	u8 *data = pdu->sdata;
	49	int datalen = pdu->size;
	50	char buf[255];
	51	int buflen = 255;
	52
	53	i = n = 0;
	54	if (datalen > (buflen-16))
	55	datalen = buflen-16;
	56	while (i < datalen) {
	57	n += scnprintf(buf + n, buflen - n, "%02x ", data[i]);
	58	if (i%4 == 3)
	59	n += scnprintf(buf + n, buflen - n, " ");
	60	if (i%32 == 31)
	61	n += scnprintf(buf + n, buflen - n, "\n");
	62
	63	i++;
	64	}
	65	n += scnprintf(buf + n, buflen - n, "\n");
	66
	67	if (way)
e7f4b8f1	68	P9_DPRINTK(P9_DEBUG_PKT, "[[[(%d) %s\n", datalen, buf);
51a87c55	69	else
e7f4b8f1	70	P9_DPRINTK(P9_DEBUG_PKT, "]]](%d) %s\n", datalen, buf);
51a87c55	71	}
0b15a3a5 EVH	72	#else
	73	void
	74	p9pdu_dump(int way, struct p9_fcall *pdu)
	75	{
	76	}
	77	#endif
51a87c55 EVH	78	EXPORT_SYMBOL(p9pdu_dump);
51a87c55 EVH	79
ace51c4d EVH	80	void p9stat_free(struct p9_wstat *stbuf)
	81	{
	82	kfree(stbuf->name);
	83	kfree(stbuf->uid);
	84	kfree(stbuf->gid);
	85	kfree(stbuf->muid);
	86	kfree(stbuf->extension);
	87	}
	88	EXPORT_SYMBOL(p9stat_free);
	89
	90	static size_t pdu_read(struct p9_fcall pdu, void data, size_t size)
	91	{
01b0c5cf	92	size_t len = min(pdu->size - pdu->offset, size);
ace51c4d EVH	93	memcpy(data, &pdu->sdata[pdu->offset], len);
	94	pdu->offset += len;
	95	return size - len;
	96	}
	97
	98	static size_t pdu_write(struct p9_fcall pdu, const void data, size_t size)
	99	{
01b0c5cf	100	size_t len = min(pdu->capacity - pdu->size, size);
ace51c4d EVH	101	memcpy(&pdu->sdata[pdu->size], data, len);
	102	pdu->size += len;
	103	return size - len;
	104	}
	105
51a87c55 EVH	106	static size_t
	107	pdu_write_u(struct p9_fcall pdu, const char __user udata, size_t size)
	108	{
01b0c5cf	109	size_t len = min(pdu->capacity - pdu->size, size);
7b3bb3fe AK	110	if (copy_from_user(&pdu->sdata[pdu->size], udata, len))
7b3bb3fe AK	111	len = 0;
51a87c55 EVH	112
	113	pdu->size += len;
	114	return size - len;
	115	}
	116
bb2f8a55 VJJ	117	static size_t
	118	pdu_write_urw(struct p9_fcall pdu, const char kdata, const char __user *udata,
	119	size_t size)
	120	{
	121	BUG_ON(pdu->size > P9_IOHDRSZ);
	122	pdu->pubuf = (char __user *)udata;
	123	pdu->pkbuf = (char *)kdata;
	124	pdu->pbuf_size = size;
	125	return 0;
	126	}
	127
2c66523f VJJ	128	static size_t
	129	pdu_write_readdir(struct p9_fcall pdu, const char kdata, size_t size)
	130	{
	131	BUG_ON(pdu->size > P9_READDIRHDRSZ);
	132	pdu->pkbuf = (char *)kdata;
	133	pdu->pbuf_size = size;
	134	return 0;
	135	}
	136
ace51c4d EVH	137	/*
	138	b - int8_t
	139	w - int16_t
	140	d - int32_t
	141	q - int64_t
	142	s - string
	143	S - stat
	144	Q - qid
	145	D - data blob (int32_t size followed by void *, results are not freed)
	146	T - array of strings (int16_t count, followed by strings)
	147	R - array of qids (int16_t count, followed by qids)
f0853122	148	A - stat for 9p2000.L (p9_stat_dotl)
ace51c4d EVH	149	? - if optional = 1, continue parsing
	150	*/
	151
	152	static int
342fee1d SK	153	p9pdu_vreadf(struct p9_fcall pdu, int proto_version, const char fmt,
342fee1d SK	154	va_list ap)
ace51c4d EVH	155	{
	156	const char *ptr;
	157	int errcode = 0;
	158
	159	for (ptr = fmt; *ptr; ptr++) {
	160	switch (*ptr) {
	161	case 'b':{
	162	int8_t val = va_arg(ap, int8_t );
	163	if (pdu_read(pdu, val, sizeof(*val))) {
	164	errcode = -EFAULT;
	165	break;
	166	}
	167	}
	168	break;
	169	case 'w':{
	170	int16_t val = va_arg(ap, int16_t );
beeebc92 EVH	171	__le16 le_val;
beeebc92 EVH	172	if (pdu_read(pdu, &le_val, sizeof(le_val))) {
ace51c4d EVH	173	errcode = -EFAULT;
	174	break;
	175	}
beeebc92	176	*val = le16_to_cpu(le_val);
ace51c4d EVH	177	}
	178	break;
	179	case 'd':{
	180	int32_t val = va_arg(ap, int32_t );
beeebc92 EVH	181	__le32 le_val;
beeebc92 EVH	182	if (pdu_read(pdu, &le_val, sizeof(le_val))) {
ace51c4d EVH	183	errcode = -EFAULT;
	184	break;
	185	}
beeebc92	186	*val = le32_to_cpu(le_val);
ace51c4d EVH	187	}
	188	break;
	189	case 'q':{
	190	int64_t val = va_arg(ap, int64_t );
beeebc92 EVH	191	__le64 le_val;
beeebc92 EVH	192	if (pdu_read(pdu, &le_val, sizeof(le_val))) {
ace51c4d EVH	193	errcode = -EFAULT;
	194	break;
	195	}
beeebc92	196	*val = le64_to_cpu(le_val);
ace51c4d EVH	197	}
	198	break;
	199	case 's':{
e45c5405	200	char sptr = va_arg(ap, char );
219fd58b	201	uint16_t len;
ace51c4d	202
342fee1d SK	203	errcode = p9pdu_readf(pdu, proto_version,
342fee1d SK	204	"w", &len);
ace51c4d EVH	205	if (errcode)
	206	break;
	207
eeff66ef	208	*sptr = kmalloc(len + 1, GFP_NOFS);
e45c5405	209	if (*sptr == NULL) {
ace51c4d EVH	210	errcode = -EFAULT;
	211	break;
	212	}
219fd58b	213	if (pdu_read(pdu, *sptr, len)) {
ace51c4d	214	errcode = -EFAULT;
e45c5405 EVH	215	kfree(*sptr);
e45c5405 EVH	216	*sptr = NULL;
ace51c4d	217	} else
219fd58b	218	(*sptr)[len] = 0;
ace51c4d EVH	219	}
	220	break;
	221	case 'Q':{
	222	struct p9_qid *qid =
	223	va_arg(ap, struct p9_qid *);
	224
342fee1d	225	errcode = p9pdu_readf(pdu, proto_version, "bdq",
ace51c4d EVH	226	&qid->type, &qid->version,
	227	&qid->path);
	228	}
	229	break;
	230	case 'S':{
	231	struct p9_wstat *stbuf =
	232	va_arg(ap, struct p9_wstat *);
	233
f0a0ac2e	234	memset(stbuf, 0, sizeof(struct p9_wstat));
ace51c4d	235	stbuf->n_uid = stbuf->n_gid = stbuf->n_muid =
f0a0ac2e	236	-1;
ace51c4d	237	errcode =
342fee1d	238	p9pdu_readf(pdu, proto_version,
ace51c4d EVH	239	"wwdQdddqssss?sddd",
	240	&stbuf->size, &stbuf->type,
	241	&stbuf->dev, &stbuf->qid,
	242	&stbuf->mode, &stbuf->atime,
	243	&stbuf->mtime, &stbuf->length,
	244	&stbuf->name, &stbuf->uid,
	245	&stbuf->gid, &stbuf->muid,
	246	&stbuf->extension,
	247	&stbuf->n_uid, &stbuf->n_gid,
	248	&stbuf->n_muid);
	249	if (errcode)
	250	p9stat_free(stbuf);
	251	}
	252	break;
	253	case 'D':{
219fd58b	254	uint32_t count = va_arg(ap, uint32_t );
ace51c4d EVH	255	void data = va_arg(ap, void );
	256
	257	errcode =
342fee1d	258	p9pdu_readf(pdu, proto_version, "d", count);
ace51c4d EVH	259	if (!errcode) {
ace51c4d EVH	260	*count =
219fd58b	261	min_t(uint32_t, *count,
01b0c5cf	262	pdu->size - pdu->offset);
ace51c4d EVH	263	*data = &pdu->sdata[pdu->offset];
	264	}
	265	}
	266	break;
	267	case 'T':{
b76225e2	268	uint16_t nwname = va_arg(ap, uint16_t );
ace51c4d EVH	269	char *wnames = va_arg(ap, char *);
ace51c4d EVH	270
342fee1d SK	271	errcode = p9pdu_readf(pdu, proto_version,
342fee1d SK	272	"w", nwname);
ace51c4d EVH	273	if (!errcode) {
	274	*wnames =
	275	kmalloc(sizeof(char ) *nwname,
eeff66ef	276	GFP_NOFS);
ace51c4d EVH	277	if (!*wnames)
	278	errcode = -ENOMEM;
	279	}
	280
	281	if (!errcode) {
	282	int i;
	283
	284	for (i = 0; i < *nwname; i++) {
	285	errcode =
342fee1d SK	286	p9pdu_readf(pdu,
342fee1d SK	287	proto_version,
ace51c4d EVH	288	"s",
	289	&(*wnames)[i]);
	290	if (errcode)
	291	break;
	292	}
	293	}
	294
	295	if (errcode) {
	296	if (*wnames) {
	297	int i;
	298
	299	for (i = 0; i < *nwname; i++)
	300	kfree((*wnames)[i]);
	301	}
	302	kfree(*wnames);
	303	*wnames = NULL;
	304	}
	305	}
	306	break;
	307	case 'R':{
	308	int16_t nwqid = va_arg(ap, int16_t );
	309	struct p9_qid **wqids =
	310	va_arg(ap, struct p9_qid **);
	311
	312	*wqids = NULL;
	313
	314	errcode =
342fee1d	315	p9pdu_readf(pdu, proto_version, "w", nwqid);
ace51c4d EVH	316	if (!errcode) {
	317	*wqids =
	318	kmalloc(nwqid
	319	sizeof(struct p9_qid),
eeff66ef	320	GFP_NOFS);
ace51c4d EVH	321	if (*wqids == NULL)
	322	errcode = -ENOMEM;
	323	}
	324
	325	if (!errcode) {
	326	int i;
	327
	328	for (i = 0; i < *nwqid; i++) {
	329	errcode =
342fee1d SK	330	p9pdu_readf(pdu,
342fee1d SK	331	proto_version,
ace51c4d EVH	332	"Q",
	333	&(*wqids)[i]);
	334	if (errcode)
	335	break;
	336	}
	337	}
	338
	339	if (errcode) {
	340	kfree(*wqids);
	341	*wqids = NULL;
	342	}
	343	}
	344	break;
f0853122 SK	345	case 'A': {
	346	struct p9_stat_dotl *stbuf =
	347	va_arg(ap, struct p9_stat_dotl *);
	348
	349	memset(stbuf, 0, sizeof(struct p9_stat_dotl));
	350	errcode =
	351	p9pdu_readf(pdu, proto_version,
	352	"qQdddqqqqqqqqqqqqqqq",
	353	&stbuf->st_result_mask,
	354	&stbuf->qid,
	355	&stbuf->st_mode,
	356	&stbuf->st_uid, &stbuf->st_gid,
	357	&stbuf->st_nlink,
	358	&stbuf->st_rdev, &stbuf->st_size,
	359	&stbuf->st_blksize, &stbuf->st_blocks,
	360	&stbuf->st_atime_sec,
	361	&stbuf->st_atime_nsec,
	362	&stbuf->st_mtime_sec,
	363	&stbuf->st_mtime_nsec,
	364	&stbuf->st_ctime_sec,
	365	&stbuf->st_ctime_nsec,
	366	&stbuf->st_btime_sec,
	367	&stbuf->st_btime_nsec,
	368	&stbuf->st_gen,
	369	&stbuf->st_data_version);
	370	}
	371	break;
ace51c4d	372	case '?':
c56e4acf SK	373	if ((proto_version != p9_proto_2000u) &&
c56e4acf SK	374	(proto_version != p9_proto_2000L))
ace51c4d EVH	375	return 0;
	376	break;
	377	default:
	378	BUG();
	379	break;
	380	}
	381
	382	if (errcode)
	383	break;
	384	}
	385
	386	return errcode;
	387	}
	388
	389	int
342fee1d SK	390	p9pdu_vwritef(struct p9_fcall pdu, int proto_version, const char fmt,
342fee1d SK	391	va_list ap)
ace51c4d EVH	392	{
	393	const char *ptr;
	394	int errcode = 0;
	395
	396	for (ptr = fmt; *ptr; ptr++) {
	397	switch (*ptr) {
	398	case 'b':{
	399	int8_t val = va_arg(ap, int);
	400	if (pdu_write(pdu, &val, sizeof(val)))
	401	errcode = -EFAULT;
	402	}
	403	break;
	404	case 'w':{
beeebc92	405	__le16 val = cpu_to_le16(va_arg(ap, int));
ace51c4d EVH	406	if (pdu_write(pdu, &val, sizeof(val)))
	407	errcode = -EFAULT;
	408	}
	409	break;
	410	case 'd':{
beeebc92	411	__le32 val = cpu_to_le32(va_arg(ap, int32_t));
ace51c4d EVH	412	if (pdu_write(pdu, &val, sizeof(val)))
	413	errcode = -EFAULT;
	414	}
	415	break;
	416	case 'q':{
beeebc92	417	__le64 val = cpu_to_le64(va_arg(ap, int64_t));
ace51c4d EVH	418	if (pdu_write(pdu, &val, sizeof(val)))
	419	errcode = -EFAULT;
	420	}
	421	break;
	422	case 's':{
e45c5405	423	const char sptr = va_arg(ap, const char );
219fd58b	424	uint16_t len = 0;
e45c5405	425	if (sptr)
219fd58b MK	426	len = min_t(uint16_t, strlen(sptr),
219fd58b MK	427	USHRT_MAX);
ace51c4d	428
342fee1d SK	429	errcode = p9pdu_writef(pdu, proto_version,
342fee1d SK	430	"w", len);
e45c5405	431	if (!errcode && pdu_write(pdu, sptr, len))
ace51c4d EVH	432	errcode = -EFAULT;
	433	}
	434	break;
	435	case 'Q':{
	436	const struct p9_qid *qid =
	437	va_arg(ap, const struct p9_qid *);
	438	errcode =
342fee1d	439	p9pdu_writef(pdu, proto_version, "bdq",
ace51c4d EVH	440	qid->type, qid->version,
	441	qid->path);
	442	} break;
	443	case 'S':{
	444	const struct p9_wstat *stbuf =
	445	va_arg(ap, const struct p9_wstat *);
	446	errcode =
342fee1d	447	p9pdu_writef(pdu, proto_version,
ace51c4d EVH	448	"wwdQdddqssss?sddd",
ace51c4d EVH	449	stbuf->size, stbuf->type,
51a87c55	450	stbuf->dev, &stbuf->qid,
ace51c4d EVH	451	stbuf->mode, stbuf->atime,
	452	stbuf->mtime, stbuf->length,
	453	stbuf->name, stbuf->uid,
	454	stbuf->gid, stbuf->muid,
	455	stbuf->extension, stbuf->n_uid,
	456	stbuf->n_gid, stbuf->n_muid);
	457	} break;
	458	case 'D':{
219fd58b	459	uint32_t count = va_arg(ap, uint32_t);
ace51c4d EVH	460	const void data = va_arg(ap, const void );
ace51c4d EVH	461
342fee1d SK	462	errcode = p9pdu_writef(pdu, proto_version, "d",
342fee1d SK	463	count);
ace51c4d EVH	464	if (!errcode && pdu_write(pdu, data, count))
	465	errcode = -EFAULT;
	466	}
	467	break;
bb2f8a55 VJJ	468	case 'E':{
	469	int32_t cnt = va_arg(ap, int32_t);
	470	const char k = va_arg(ap, const void );
bd8c8ade AK	471	const char __user *u = va_arg(ap,
bd8c8ade AK	472	const void __user *);
bb2f8a55 VJJ	473	errcode = p9pdu_writef(pdu, proto_version, "d",
	474	cnt);
	475	if (!errcode && pdu_write_urw(pdu, k, u, cnt))
	476	errcode = -EFAULT;
	477	}
	478	break;
2c66523f VJJ	479	case 'F':{
	480	int32_t cnt = va_arg(ap, int32_t);
	481	const char k = va_arg(ap, const void );
	482	errcode = p9pdu_writef(pdu, proto_version, "d",
	483	cnt);
	484	if (!errcode && pdu_write_readdir(pdu, k, cnt))
	485	errcode = -EFAULT;
	486	}
	487	break;
51a87c55 EVH	488	case 'U':{
	489	int32_t count = va_arg(ap, int32_t);
	490	const char __user *udata =
e45c5405	491	va_arg(ap, const void __user *);
342fee1d SK	492	errcode = p9pdu_writef(pdu, proto_version, "d",
342fee1d SK	493	count);
51a87c55 EVH	494	if (!errcode && pdu_write_u(pdu, udata, count))
	495	errcode = -EFAULT;
	496	}
	497	break;
ace51c4d	498	case 'T':{
b76225e2	499	uint16_t nwname = va_arg(ap, int);
ace51c4d EVH	500	const char wnames = va_arg(ap, const char );
ace51c4d EVH	501
342fee1d SK	502	errcode = p9pdu_writef(pdu, proto_version, "w",
342fee1d SK	503	nwname);
ace51c4d EVH	504	if (!errcode) {
	505	int i;
	506
	507	for (i = 0; i < nwname; i++) {
	508	errcode =
342fee1d SK	509	p9pdu_writef(pdu,
342fee1d SK	510	proto_version,
ace51c4d EVH	511	"s",
	512	wnames[i]);
	513	if (errcode)
	514	break;
	515	}
	516	}
	517	}
	518	break;
	519	case 'R':{
	520	int16_t nwqid = va_arg(ap, int);
	521	struct p9_qid *wqids =
	522	va_arg(ap, struct p9_qid *);
	523
342fee1d SK	524	errcode = p9pdu_writef(pdu, proto_version, "w",
342fee1d SK	525	nwqid);
ace51c4d EVH	526	if (!errcode) {
	527	int i;
	528
	529	for (i = 0; i < nwqid; i++) {
	530	errcode =
342fee1d SK	531	p9pdu_writef(pdu,
342fee1d SK	532	proto_version,
ace51c4d EVH	533	"Q",
	534	&wqids[i]);
	535	if (errcode)
	536	break;
	537	}
	538	}
	539	}
	540	break;
87d7845a SK	541	case 'I':{
	542	struct p9_iattr_dotl *p9attr = va_arg(ap,
	543	struct p9_iattr_dotl *);
	544
	545	errcode = p9pdu_writef(pdu, proto_version,
	546	"ddddqqqqq",
	547	p9attr->valid,
	548	p9attr->mode,
	549	p9attr->uid,
	550	p9attr->gid,
	551	p9attr->size,
	552	p9attr->atime_sec,
	553	p9attr->atime_nsec,
	554	p9attr->mtime_sec,
	555	p9attr->mtime_nsec);
	556	}
	557	break;
ace51c4d	558	case '?':
c56e4acf SK	559	if ((proto_version != p9_proto_2000u) &&
c56e4acf SK	560	(proto_version != p9_proto_2000L))
ace51c4d EVH	561	return 0;
	562	break;
	563	default:
	564	BUG();
	565	break;
	566	}
	567
	568	if (errcode)
	569	break;
	570	}
	571
	572	return errcode;
	573	}
	574
342fee1d	575	int p9pdu_readf(struct p9_fcall pdu, int proto_version, const char fmt, ...)
ace51c4d EVH	576	{
	577	va_list ap;
	578	int ret;
	579
	580	va_start(ap, fmt);
342fee1d	581	ret = p9pdu_vreadf(pdu, proto_version, fmt, ap);
ace51c4d EVH	582	va_end(ap);
	583
	584	return ret;
	585	}
	586
	587	static int
342fee1d	588	p9pdu_writef(struct p9_fcall pdu, int proto_version, const char fmt, ...)
ace51c4d EVH	589	{
	590	va_list ap;
	591	int ret;
	592
	593	va_start(ap, fmt);
342fee1d	594	ret = p9pdu_vwritef(pdu, proto_version, fmt, ap);
ace51c4d EVH	595	va_end(ap);
	596
	597	return ret;
	598	}
51a87c55	599
342fee1d	600	int p9stat_read(char buf, int len, struct p9_wstat st, int proto_version)
02da398b EVH	601	{
02da398b EVH	602	struct p9_fcall fake_pdu;
e7f4b8f1	603	int ret;
02da398b EVH	604
	605	fake_pdu.size = len;
	606	fake_pdu.capacity = len;
	607	fake_pdu.sdata = buf;
	608	fake_pdu.offset = 0;
	609
342fee1d	610	ret = p9pdu_readf(&fake_pdu, proto_version, "S", st);
e7f4b8f1 EVH	611	if (ret) {
	612	P9_DPRINTK(P9_DEBUG_9P, "<<< p9stat_read failed: %d\n", ret);
	613	p9pdu_dump(1, &fake_pdu);
	614	}
	615
	616	return ret;
02da398b EVH	617	}
	618	EXPORT_SYMBOL(p9stat_read);
	619
51a87c55 EVH	620	int p9pdu_prepare(struct p9_fcall *pdu, int16_t tag, int8_t type)
51a87c55 EVH	621	{
9bb6c10a	622	pdu->id = type;
51a87c55 EVH	623	return p9pdu_writef(pdu, 0, "dbw", 0, type, tag);
	624	}
	625
	626	int p9pdu_finalize(struct p9_fcall *pdu)
	627	{
	628	int size = pdu->size;
	629	int err;
	630
	631	pdu->size = 0;
	632	err = p9pdu_writef(pdu, 0, "d", size);
	633	pdu->size = size;
	634
0b15a3a5	635	#ifdef CONFIG_NET_9P_DEBUG
e7f4b8f1	636	if ((p9_debug_level & P9_DEBUG_PKT) == P9_DEBUG_PKT)
51a87c55	637	p9pdu_dump(0, pdu);
0b15a3a5	638	#endif
51a87c55	639
e7f4b8f1 EVH	640	P9_DPRINTK(P9_DEBUG_9P, ">>> size=%d type: %d tag: %d\n", pdu->size,
	641	pdu->id, pdu->tag);
	642
51a87c55 EVH	643	return err;
	644	}
	645
	646	void p9pdu_reset(struct p9_fcall *pdu)
	647	{
	648	pdu->offset = 0;
	649	pdu->size = 0;
022cae36 VJJ	650	pdu->private = NULL;
	651	pdu->pubuf = NULL;
	652	pdu->pkbuf = NULL;
	653	pdu->pbuf_size = 0;
51a87c55	654	}
7751bdb3 SK	655
	656	int p9dirent_read(char buf, int len, struct p9_dirent dirent,
	657	int proto_version)
	658	{
	659	struct p9_fcall fake_pdu;
	660	int ret;
	661	char *nameptr;
	662
	663	fake_pdu.size = len;
	664	fake_pdu.capacity = len;
	665	fake_pdu.sdata = buf;
	666	fake_pdu.offset = 0;
	667
	668	ret = p9pdu_readf(&fake_pdu, proto_version, "Qqbs", &dirent->qid,
	669	&dirent->d_off, &dirent->d_type, &nameptr);
	670	if (ret) {
	671	P9_DPRINTK(P9_DEBUG_9P, "<<< p9dirent_read failed: %d\n", ret);
	672	p9pdu_dump(1, &fake_pdu);
	673	goto out;
	674	}
	675
	676	strcpy(dirent->d_name, nameptr);
	677
	678	out:
	679	return fake_pdu.offset;
	680	}
	681	EXPORT_SYMBOL(p9dirent_read);