mirror of
https://mirrors.bfsu.edu.cn/git/linux.git
synced 2024-12-13 05:54:23 +08:00
1effdbf94a
This new function calculates a buffer size suitable for holding the intended 9p request or response. For rather small message types (which applies to almost all 9p message types actually) simply use hard coded values. For some variable-length and potentially large message types calculate a more precise value according to what data is actually transmitted to avoid unnecessarily huge buffers. So p9_msg_buf_size() divides the individual 9p message types into 3 message size categories: - dynamically calculated message size (i.e. potentially large) - 8k hard coded message size - 4k hard coded message size As for the latter two hard coded message types: for most 9p message types it is pretty obvious whether they would always fit into 4k or 8k. But for some of them it depends on the maximum directory entry name length allowed by OS and filesystem for determining into which of the two size categories they would fit into. Currently Linux supports directory entry names up to NAME_MAX (255), however when comparing the limitation of individual filesystems, ReiserFS theoretically supports up to slightly below 4k long names. So in order to make this code more future proof, and as revisiting it later on is a bit tedious and has the potential to miss out details, the decision [1] was made to take 4k as basis as for max. name length. Link: https://lkml.kernel.org/r/bd6be891cf67e867688e8c8796d06408bfafa0d9.1657920926.git.linux_oss@crudebyte.com Link: https://lore.kernel.org/all/5564296.oo812IJUPE@silver/ [1] Signed-off-by: Christian Schoenebeck <linux_oss@crudebyte.com> Signed-off-by: Dominique Martinet <asmadeus@codewreck.org>
793 lines
18 KiB
C
793 lines
18 KiB
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);
|