2019-05-28 16:57:16 +00:00
|
|
|
// SPDX-License-Identifier: GPL-2.0-only
|
2008-10-14 01:40:27 +00:00
|
|
|
/*
|
|
|
|
|
* 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.
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
#include <linux/module.h>
|
|
|
|
|
#include <linux/errno.h>
|
2010-12-04 15:22:46 +00:00
|
|
|
#include <linux/kernel.h>
|
2008-10-16 13:30:07 +00:00
|
|
|
#include <linux/uaccess.h>
|
include cleanup: Update gfp.h and slab.h includes to prepare for breaking implicit slab.h inclusion from percpu.h
percpu.h is included by sched.h and module.h and thus ends up being
included when building most .c files. percpu.h includes slab.h which
in turn includes gfp.h making everything defined by the two files
universally available and complicating inclusion dependencies.
percpu.h -> slab.h dependency is about to be removed. Prepare for
this change by updating users of gfp and slab facilities include those
headers directly instead of assuming availability. As this conversion
needs to touch large number of source files, the following script is
used as the basis of conversion.
http://userweb.kernel.org/~tj/misc/slabh-sweep.py
The script does the followings.
* Scan files for gfp and slab usages and update includes such that
only the necessary includes are there. ie. if only gfp is used,
gfp.h, if slab is used, slab.h.
* When the script inserts a new include, it looks at the include
blocks and try to put the new include such that its order conforms
to its surrounding. It's put in the include block which contains
core kernel includes, in the same order that the rest are ordered -
alphabetical, Christmas tree, rev-Xmas-tree or at the end if there
doesn't seem to be any matching order.
* If the script can't find a place to put a new include (mostly
because the file doesn't have fitting include block), it prints out
an error message indicating which .h file needs to be added to the
file.
The conversion was done in the following steps.
1. The initial automatic conversion of all .c files updated slightly
over 4000 files, deleting around 700 includes and adding ~480 gfp.h
and ~3000 slab.h inclusions. The script emitted errors for ~400
files.
2. Each error was manually checked. Some didn't need the inclusion,
some needed manual addition while adding it to implementation .h or
embedding .c file was more appropriate for others. This step added
inclusions to around 150 files.
3. The script was run again and the output was compared to the edits
from #2 to make sure no file was left behind.
4. Several build tests were done and a couple of problems were fixed.
e.g. lib/decompress_*.c used malloc/free() wrappers around slab
APIs requiring slab.h to be added manually.
5. The script was run on all .h files but without automatically
editing them as sprinkling gfp.h and slab.h inclusions around .h
files could easily lead to inclusion dependency hell. Most gfp.h
inclusion directives were ignored as stuff from gfp.h was usually
wildly available and often used in preprocessor macros. Each
slab.h inclusion directive was examined and added manually as
necessary.
6. percpu.h was updated not to include slab.h.
7. Build test were done on the following configurations and failures
were fixed. CONFIG_GCOV_KERNEL was turned off for all tests (as my
distributed build env didn't work with gcov compiles) and a few
more options had to be turned off depending on archs to make things
build (like ipr on powerpc/64 which failed due to missing writeq).
* x86 and x86_64 UP and SMP allmodconfig and a custom test config.
* powerpc and powerpc64 SMP allmodconfig
* sparc and sparc64 SMP allmodconfig
* ia64 SMP allmodconfig
* s390 SMP allmodconfig
* alpha SMP allmodconfig
* um on x86_64 SMP allmodconfig
8. percpu.h modifications were reverted so that it could be applied as
a separate patch and serve as bisection point.
Given the fact that I had only a couple of failures from tests on step
6, I'm fairly confident about the coverage of this conversion patch.
If there is a breakage, it's likely to be something in one of the arch
headers which should be easily discoverable easily on most builds of
the specific arch.
Signed-off-by: Tejun Heo <tj@kernel.org>
Guess-its-ok-by: Christoph Lameter <cl@linux-foundation.org>
Cc: Ingo Molnar <mingo@redhat.com>
Cc: Lee Schermerhorn <Lee.Schermerhorn@hp.com>
2010-03-24 08:04:11 +00:00
|
|
|
#include <linux/slab.h>
|
2008-10-17 21:20:07 +00:00
|
|
|
#include <linux/sched.h>
|
2010-12-04 15:22:46 +00:00
|
|
|
#include <linux/stddef.h>
|
2009-02-07 06:07:41 +00:00
|
|
|
#include <linux/types.h>
|
2015-04-01 23:57:53 +00:00
|
|
|
#include <linux/uio.h>
|
2008-10-14 01:40:27 +00:00
|
|
|
#include <net/9p/9p.h>
|
|
|
|
|
#include <net/9p/client.h>
|
|
|
|
|
#include "protocol.h"
|
|
|
|
|
|
2011-08-06 19:16:59 +00:00
|
|
|
#include <trace/events/9p.h>
|
|
|
|
|
|
2008-10-14 01:40:27 +00:00
|
|
|
static int
|
2010-03-05 18:50:14 +00:00
|
|
|
p9pdu_writef(struct p9_fcall *pdu, int proto_version, const char *fmt, ...);
|
2008-10-14 01:40:27 +00:00
|
|
|
|
|
|
|
|
void p9stat_free(struct p9_wstat *stbuf)
|
|
|
|
|
{
|
|
|
|
|
kfree(stbuf->name);
|
2018-08-27 22:32:35 +00:00
|
|
|
stbuf->name = NULL;
|
2008-10-14 01:40:27 +00:00
|
|
|
kfree(stbuf->uid);
|
2018-08-27 22:32:35 +00:00
|
|
|
stbuf->uid = NULL;
|
2008-10-14 01:40:27 +00:00
|
|
|
kfree(stbuf->gid);
|
2018-08-27 22:32:35 +00:00
|
|
|
stbuf->gid = NULL;
|
2008-10-14 01:40:27 +00:00
|
|
|
kfree(stbuf->muid);
|
2018-08-27 22:32:35 +00:00
|
|
|
stbuf->muid = NULL;
|
2008-10-14 01:40:27 +00:00
|
|
|
kfree(stbuf->extension);
|
2018-08-27 22:32:35 +00:00
|
|
|
stbuf->extension = NULL;
|
2008-10-14 01:40:27 +00:00
|
|
|
}
|
|
|
|
|
EXPORT_SYMBOL(p9stat_free);
|
|
|
|
|
|
2011-08-16 05:20:10 +00:00
|
|
|
size_t pdu_read(struct p9_fcall *pdu, void *data, size_t size)
|
2008-10-14 01:40:27 +00:00
|
|
|
{
|
2010-12-04 15:22:46 +00:00
|
|
|
size_t len = min(pdu->size - pdu->offset, size);
|
2008-10-14 01:40:27 +00:00
|
|
|
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)
|
|
|
|
|
{
|
2010-12-04 15:22:46 +00:00
|
|
|
size_t len = min(pdu->capacity - pdu->size, size);
|
2008-10-14 01:40:27 +00:00
|
|
|
memcpy(&pdu->sdata[pdu->size], data, len);
|
|
|
|
|
pdu->size += len;
|
|
|
|
|
return size - len;
|
|
|
|
|
}
|
|
|
|
|
|
2008-10-16 13:30:07 +00:00
|
|
|
static size_t
|
2015-04-01 23:57:53 +00:00
|
|
|
pdu_write_u(struct p9_fcall *pdu, struct iov_iter *from, size_t size)
|
2008-10-16 13:30:07 +00:00
|
|
|
{
|
2010-12-04 15:22:46 +00:00
|
|
|
size_t len = min(pdu->capacity - pdu->size, size);
|
2015-04-01 23:57:53 +00:00
|
|
|
struct iov_iter i = *from;
|
2017-02-18 04:16:09 +00:00
|
|
|
if (!copy_from_iter_full(&pdu->sdata[pdu->size], len, &i))
|
2010-10-19 03:47:02 +00:00
|
|
|
len = 0;
|
2008-10-16 13:30:07 +00:00
|
|
|
|
|
|
|
|
pdu->size += len;
|
|
|
|
|
return size - len;
|
|
|
|
|
}
|
|
|
|
|
|
2008-10-14 01:40:27 +00:00
|
|
|
/*
|
|
|
|
|
b - int8_t
|
|
|
|
|
w - int16_t
|
|
|
|
|
d - int32_t
|
|
|
|
|
q - int64_t
|
|
|
|
|
s - string
|
2013-01-30 01:07:42 +00:00
|
|
|
u - numeric uid
|
|
|
|
|
g - numeric gid
|
2008-10-14 01:40:27 +00:00
|
|
|
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)
|
9p: getattr client implementation for 9P2000.L protocol.
SYNOPSIS
size[4] Tgetattr tag[2] fid[4] request_mask[8]
size[4] Rgetattr tag[2] lstat[n]
DESCRIPTION
The getattr transaction inquires about the file identified by fid.
request_mask is a bit mask that specifies which fields of the
stat structure is the client interested in.
The reply will contain a machine-independent directory entry,
laid out as follows:
st_result_mask[8]
Bit mask that indicates which fields in the stat structure
have been populated by the server
qid.type[1]
the type of the file (directory, etc.), represented as a bit
vector corresponding to the high 8 bits of the file's mode
word.
qid.vers[4]
version number for given path
qid.path[8]
the file server's unique identification for the file
st_mode[4]
Permission and flags
st_uid[4]
User id of owner
st_gid[4]
Group ID of owner
st_nlink[8]
Number of hard links
st_rdev[8]
Device ID (if special file)
st_size[8]
Size, in bytes
st_blksize[8]
Block size for file system IO
st_blocks[8]
Number of file system blocks allocated
st_atime_sec[8]
Time of last access, seconds
st_atime_nsec[8]
Time of last access, nanoseconds
st_mtime_sec[8]
Time of last modification, seconds
st_mtime_nsec[8]
Time of last modification, nanoseconds
st_ctime_sec[8]
Time of last status change, seconds
st_ctime_nsec[8]
Time of last status change, nanoseconds
st_btime_sec[8]
Time of creation (birth) of file, seconds
st_btime_nsec[8]
Time of creation (birth) of file, nanoseconds
st_gen[8]
Inode generation
st_data_version[8]
Data version number
request_mask and result_mask bit masks contain the following bits
#define P9_STATS_MODE 0x00000001ULL
#define P9_STATS_NLINK 0x00000002ULL
#define P9_STATS_UID 0x00000004ULL
#define P9_STATS_GID 0x00000008ULL
#define P9_STATS_RDEV 0x00000010ULL
#define P9_STATS_ATIME 0x00000020ULL
#define P9_STATS_MTIME 0x00000040ULL
#define P9_STATS_CTIME 0x00000080ULL
#define P9_STATS_INO 0x00000100ULL
#define P9_STATS_SIZE 0x00000200ULL
#define P9_STATS_BLOCKS 0x00000400ULL
#define P9_STATS_BTIME 0x00000800ULL
#define P9_STATS_GEN 0x00001000ULL
#define P9_STATS_DATA_VERSION 0x00002000ULL
#define P9_STATS_BASIC 0x000007ffULL
#define P9_STATS_ALL 0x00003fffULL
This patch implements the client side of getattr implementation for
9P2000.L. It introduces a new structure p9_stat_dotl for getting
Linux stat information along with QID. The data layout is similar to
stat structure in Linux user space with the following major
differences:
inode (st_ino) is not part of data. Instead qid is.
device (st_dev) is not part of data because this doesn't make sense
on the client.
All time variables are 64 bit wide on the wire. The kernel seems to use
32 bit variables for these variables. However, some of the architectures
have used 64 bit variables and glibc exposes 64 bit variables to user
space on some architectures. Hence to be on the safer side we have made
these 64 bit in the protocol. Refer to the comments in
include/asm-generic/stat.h
There are some additional fields: st_btime_sec, st_btime_nsec, st_gen,
st_data_version apart from the bitmask, st_result_mask. The bit mask
is filled by the server to indicate which stat fields have been
populated by the server. Currently there is no clean way for the
server to obtain these additional fields, so it sends back just the
basic fields.
Signed-off-by: Sripathi Kodi <sripathik@in.ibm.com>
Signed-off-by: Eric Van Hensbegren <ericvh@gmail.com>
2010-07-12 14:37:23 +00:00
|
|
|
A - stat for 9p2000.L (p9_stat_dotl)
|
2008-10-14 01:40:27 +00:00
|
|
|
? - if optional = 1, continue parsing
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
static int
|
2010-03-05 18:50:14 +00:00
|
|
|
p9pdu_vreadf(struct p9_fcall *pdu, int proto_version, const char *fmt,
|
|
|
|
|
va_list ap)
|
2008-10-14 01:40:27 +00:00
|
|
|
{
|
|
|
|
|
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 *);
|
2009-02-07 06:07:41 +00:00
|
|
|
__le16 le_val;
|
|
|
|
|
if (pdu_read(pdu, &le_val, sizeof(le_val))) {
|
2008-10-14 01:40:27 +00:00
|
|
|
errcode = -EFAULT;
|
|
|
|
|
break;
|
|
|
|
|
}
|
2009-02-07 06:07:41 +00:00
|
|
|
*val = le16_to_cpu(le_val);
|
2008-10-14 01:40:27 +00:00
|
|
|
}
|
|
|
|
|
break;
|
|
|
|
|
case 'd':{
|
|
|
|
|
int32_t *val = va_arg(ap, int32_t *);
|
2009-02-07 06:07:41 +00:00
|
|
|
__le32 le_val;
|
|
|
|
|
if (pdu_read(pdu, &le_val, sizeof(le_val))) {
|
2008-10-14 01:40:27 +00:00
|
|
|
errcode = -EFAULT;
|
|
|
|
|
break;
|
|
|
|
|
}
|
2009-02-07 06:07:41 +00:00
|
|
|
*val = le32_to_cpu(le_val);
|
2008-10-14 01:40:27 +00:00
|
|
|
}
|
|
|
|
|
break;
|
|
|
|
|
case 'q':{
|
|
|
|
|
int64_t *val = va_arg(ap, int64_t *);
|
2009-02-07 06:07:41 +00:00
|
|
|
__le64 le_val;
|
|
|
|
|
if (pdu_read(pdu, &le_val, sizeof(le_val))) {
|
2008-10-14 01:40:27 +00:00
|
|
|
errcode = -EFAULT;
|
|
|
|
|
break;
|
|
|
|
|
}
|
2009-02-07 06:07:41 +00:00
|
|
|
*val = le64_to_cpu(le_val);
|
2008-10-14 01:40:27 +00:00
|
|
|
}
|
|
|
|
|
break;
|
|
|
|
|
case 's':{
|
2008-10-22 23:54:47 +00:00
|
|
|
char **sptr = va_arg(ap, char **);
|
2011-01-10 20:23:53 +00:00
|
|
|
uint16_t len;
|
2008-10-14 01:40:27 +00:00
|
|
|
|
2010-03-05 18:50:14 +00:00
|
|
|
errcode = p9pdu_readf(pdu, proto_version,
|
|
|
|
|
"w", &len);
|
2008-10-14 01:40:27 +00:00
|
|
|
if (errcode)
|
|
|
|
|
break;
|
|
|
|
|
|
2011-03-08 11:09:47 +00:00
|
|
|
*sptr = kmalloc(len + 1, GFP_NOFS);
|
2008-10-22 23:54:47 +00:00
|
|
|
if (*sptr == NULL) {
|
2018-07-11 00:43:49 +00:00
|
|
|
errcode = -ENOMEM;
|
2008-10-14 01:40:27 +00:00
|
|
|
break;
|
|
|
|
|
}
|
2011-01-10 20:23:53 +00:00
|
|
|
if (pdu_read(pdu, *sptr, len)) {
|
2008-10-14 01:40:27 +00:00
|
|
|
errcode = -EFAULT;
|
2008-10-22 23:54:47 +00:00
|
|
|
kfree(*sptr);
|
|
|
|
|
*sptr = NULL;
|
2008-10-14 01:40:27 +00:00
|
|
|
} else
|
2011-01-10 20:23:53 +00:00
|
|
|
(*sptr)[len] = 0;
|
2008-10-14 01:40:27 +00:00
|
|
|
}
|
|
|
|
|
break;
|
2013-01-30 01:07:42 +00:00
|
|
|
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;
|
2008-10-14 01:40:27 +00:00
|
|
|
case 'Q':{
|
|
|
|
|
struct p9_qid *qid =
|
|
|
|
|
va_arg(ap, struct p9_qid *);
|
|
|
|
|
|
2010-03-05 18:50:14 +00:00
|
|
|
errcode = p9pdu_readf(pdu, proto_version, "bdq",
|
2008-10-14 01:40:27 +00:00
|
|
|
&qid->type, &qid->version,
|
|
|
|
|
&qid->path);
|
|
|
|
|
}
|
|
|
|
|
break;
|
|
|
|
|
case 'S':{
|
|
|
|
|
struct p9_wstat *stbuf =
|
|
|
|
|
va_arg(ap, struct p9_wstat *);
|
|
|
|
|
|
2008-10-17 17:45:23 +00:00
|
|
|
memset(stbuf, 0, sizeof(struct p9_wstat));
|
2013-01-30 00:18:50 +00:00
|
|
|
stbuf->n_uid = stbuf->n_muid = INVALID_UID;
|
|
|
|
|
stbuf->n_gid = INVALID_GID;
|
|
|
|
|
|
2008-10-14 01:40:27 +00:00
|
|
|
errcode =
|
2010-03-05 18:50:14 +00:00
|
|
|
p9pdu_readf(pdu, proto_version,
|
2013-01-30 00:18:50 +00:00
|
|
|
"wwdQdddqssss?sugu",
|
2008-10-14 01:40:27 +00:00
|
|
|
&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':{
|
2011-01-10 20:23:53 +00:00
|
|
|
uint32_t *count = va_arg(ap, uint32_t *);
|
2008-10-14 01:40:27 +00:00
|
|
|
void **data = va_arg(ap, void **);
|
|
|
|
|
|
|
|
|
|
errcode =
|
2010-03-05 18:50:14 +00:00
|
|
|
p9pdu_readf(pdu, proto_version, "d", count);
|
2008-10-14 01:40:27 +00:00
|
|
|
if (!errcode) {
|
|
|
|
|
*count =
|
2011-01-10 20:23:53 +00:00
|
|
|
min_t(uint32_t, *count,
|
2010-12-04 15:22:46 +00:00
|
|
|
pdu->size - pdu->offset);
|
2008-10-14 01:40:27 +00:00
|
|
|
*data = &pdu->sdata[pdu->offset];
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
break;
|
|
|
|
|
case 'T':{
|
2011-03-31 10:19:39 +00:00
|
|
|
uint16_t *nwname = va_arg(ap, uint16_t *);
|
2008-10-14 01:40:27 +00:00
|
|
|
char ***wnames = va_arg(ap, char ***);
|
|
|
|
|
|
2010-03-05 18:50:14 +00:00
|
|
|
errcode = p9pdu_readf(pdu, proto_version,
|
|
|
|
|
"w", nwname);
|
2008-10-14 01:40:27 +00:00
|
|
|
if (!errcode) {
|
|
|
|
|
*wnames =
|
treewide: kmalloc() -> kmalloc_array()
The kmalloc() function has a 2-factor argument form, kmalloc_array(). This
patch replaces cases of:
kmalloc(a * b, gfp)
with:
kmalloc_array(a * b, gfp)
as well as handling cases of:
kmalloc(a * b * c, gfp)
with:
kmalloc(array3_size(a, b, c), gfp)
as it's slightly less ugly than:
kmalloc_array(array_size(a, b), c, gfp)
This does, however, attempt to ignore constant size factors like:
kmalloc(4 * 1024, gfp)
though any constants defined via macros get caught up in the conversion.
Any factors with a sizeof() of "unsigned char", "char", and "u8" were
dropped, since they're redundant.
The tools/ directory was manually excluded, since it has its own
implementation of kmalloc().
The Coccinelle script used for this was:
// Fix redundant parens around sizeof().
@@
type TYPE;
expression THING, E;
@@
(
kmalloc(
- (sizeof(TYPE)) * E
+ sizeof(TYPE) * E
, ...)
|
kmalloc(
- (sizeof(THING)) * E
+ sizeof(THING) * E
, ...)
)
// Drop single-byte sizes and redundant parens.
@@
expression COUNT;
typedef u8;
typedef __u8;
@@
(
kmalloc(
- sizeof(u8) * (COUNT)
+ COUNT
, ...)
|
kmalloc(
- sizeof(__u8) * (COUNT)
+ COUNT
, ...)
|
kmalloc(
- sizeof(char) * (COUNT)
+ COUNT
, ...)
|
kmalloc(
- sizeof(unsigned char) * (COUNT)
+ COUNT
, ...)
|
kmalloc(
- sizeof(u8) * COUNT
+ COUNT
, ...)
|
kmalloc(
- sizeof(__u8) * COUNT
+ COUNT
, ...)
|
kmalloc(
- sizeof(char) * COUNT
+ COUNT
, ...)
|
kmalloc(
- sizeof(unsigned char) * COUNT
+ COUNT
, ...)
)
// 2-factor product with sizeof(type/expression) and identifier or constant.
@@
type TYPE;
expression THING;
identifier COUNT_ID;
constant COUNT_CONST;
@@
(
- kmalloc
+ kmalloc_array
(
- sizeof(TYPE) * (COUNT_ID)
+ COUNT_ID, sizeof(TYPE)
, ...)
|
- kmalloc
+ kmalloc_array
(
- sizeof(TYPE) * COUNT_ID
+ COUNT_ID, sizeof(TYPE)
, ...)
|
- kmalloc
+ kmalloc_array
(
- sizeof(TYPE) * (COUNT_CONST)
+ COUNT_CONST, sizeof(TYPE)
, ...)
|
- kmalloc
+ kmalloc_array
(
- sizeof(TYPE) * COUNT_CONST
+ COUNT_CONST, sizeof(TYPE)
, ...)
|
- kmalloc
+ kmalloc_array
(
- sizeof(THING) * (COUNT_ID)
+ COUNT_ID, sizeof(THING)
, ...)
|
- kmalloc
+ kmalloc_array
(
- sizeof(THING) * COUNT_ID
+ COUNT_ID, sizeof(THING)
, ...)
|
- kmalloc
+ kmalloc_array
(
- sizeof(THING) * (COUNT_CONST)
+ COUNT_CONST, sizeof(THING)
, ...)
|
- kmalloc
+ kmalloc_array
(
- sizeof(THING) * COUNT_CONST
+ COUNT_CONST, sizeof(THING)
, ...)
)
// 2-factor product, only identifiers.
@@
identifier SIZE, COUNT;
@@
- kmalloc
+ kmalloc_array
(
- SIZE * COUNT
+ COUNT, SIZE
, ...)
// 3-factor product with 1 sizeof(type) or sizeof(expression), with
// redundant parens removed.
@@
expression THING;
identifier STRIDE, COUNT;
type TYPE;
@@
(
kmalloc(
- sizeof(TYPE) * (COUNT) * (STRIDE)
+ array3_size(COUNT, STRIDE, sizeof(TYPE))
, ...)
|
kmalloc(
- sizeof(TYPE) * (COUNT) * STRIDE
+ array3_size(COUNT, STRIDE, sizeof(TYPE))
, ...)
|
kmalloc(
- sizeof(TYPE) * COUNT * (STRIDE)
+ array3_size(COUNT, STRIDE, sizeof(TYPE))
, ...)
|
kmalloc(
- sizeof(TYPE) * COUNT * STRIDE
+ array3_size(COUNT, STRIDE, sizeof(TYPE))
, ...)
|
kmalloc(
- sizeof(THING) * (COUNT) * (STRIDE)
+ array3_size(COUNT, STRIDE, sizeof(THING))
, ...)
|
kmalloc(
- sizeof(THING) * (COUNT) * STRIDE
+ array3_size(COUNT, STRIDE, sizeof(THING))
, ...)
|
kmalloc(
- sizeof(THING) * COUNT * (STRIDE)
+ array3_size(COUNT, STRIDE, sizeof(THING))
, ...)
|
kmalloc(
- sizeof(THING) * COUNT * STRIDE
+ array3_size(COUNT, STRIDE, sizeof(THING))
, ...)
)
// 3-factor product with 2 sizeof(variable), with redundant parens removed.
@@
expression THING1, THING2;
identifier COUNT;
type TYPE1, TYPE2;
@@
(
kmalloc(
- sizeof(TYPE1) * sizeof(TYPE2) * COUNT
+ array3_size(COUNT, sizeof(TYPE1), sizeof(TYPE2))
, ...)
|
kmalloc(
- sizeof(TYPE1) * sizeof(THING2) * (COUNT)
+ array3_size(COUNT, sizeof(TYPE1), sizeof(TYPE2))
, ...)
|
kmalloc(
- sizeof(THING1) * sizeof(THING2) * COUNT
+ array3_size(COUNT, sizeof(THING1), sizeof(THING2))
, ...)
|
kmalloc(
- sizeof(THING1) * sizeof(THING2) * (COUNT)
+ array3_size(COUNT, sizeof(THING1), sizeof(THING2))
, ...)
|
kmalloc(
- sizeof(TYPE1) * sizeof(THING2) * COUNT
+ array3_size(COUNT, sizeof(TYPE1), sizeof(THING2))
, ...)
|
kmalloc(
- sizeof(TYPE1) * sizeof(THING2) * (COUNT)
+ array3_size(COUNT, sizeof(TYPE1), sizeof(THING2))
, ...)
)
// 3-factor product, only identifiers, with redundant parens removed.
@@
identifier STRIDE, SIZE, COUNT;
@@
(
kmalloc(
- (COUNT) * STRIDE * SIZE
+ array3_size(COUNT, STRIDE, SIZE)
, ...)
|
kmalloc(
- COUNT * (STRIDE) * SIZE
+ array3_size(COUNT, STRIDE, SIZE)
, ...)
|
kmalloc(
- COUNT * STRIDE * (SIZE)
+ array3_size(COUNT, STRIDE, SIZE)
, ...)
|
kmalloc(
- (COUNT) * (STRIDE) * SIZE
+ array3_size(COUNT, STRIDE, SIZE)
, ...)
|
kmalloc(
- COUNT * (STRIDE) * (SIZE)
+ array3_size(COUNT, STRIDE, SIZE)
, ...)
|
kmalloc(
- (COUNT) * STRIDE * (SIZE)
+ array3_size(COUNT, STRIDE, SIZE)
, ...)
|
kmalloc(
- (COUNT) * (STRIDE) * (SIZE)
+ array3_size(COUNT, STRIDE, SIZE)
, ...)
|
kmalloc(
- COUNT * STRIDE * SIZE
+ array3_size(COUNT, STRIDE, SIZE)
, ...)
)
// Any remaining multi-factor products, first at least 3-factor products,
// when they're not all constants...
@@
expression E1, E2, E3;
constant C1, C2, C3;
@@
(
kmalloc(C1 * C2 * C3, ...)
|
kmalloc(
- (E1) * E2 * E3
+ array3_size(E1, E2, E3)
, ...)
|
kmalloc(
- (E1) * (E2) * E3
+ array3_size(E1, E2, E3)
, ...)
|
kmalloc(
- (E1) * (E2) * (E3)
+ array3_size(E1, E2, E3)
, ...)
|
kmalloc(
- E1 * E2 * E3
+ array3_size(E1, E2, E3)
, ...)
)
// And then all remaining 2 factors products when they're not all constants,
// keeping sizeof() as the second factor argument.
@@
expression THING, E1, E2;
type TYPE;
constant C1, C2, C3;
@@
(
kmalloc(sizeof(THING) * C2, ...)
|
kmalloc(sizeof(TYPE) * C2, ...)
|
kmalloc(C1 * C2 * C3, ...)
|
kmalloc(C1 * C2, ...)
|
- kmalloc
+ kmalloc_array
(
- sizeof(TYPE) * (E2)
+ E2, sizeof(TYPE)
, ...)
|
- kmalloc
+ kmalloc_array
(
- sizeof(TYPE) * E2
+ E2, sizeof(TYPE)
, ...)
|
- kmalloc
+ kmalloc_array
(
- sizeof(THING) * (E2)
+ E2, sizeof(THING)
, ...)
|
- kmalloc
+ kmalloc_array
(
- sizeof(THING) * E2
+ E2, sizeof(THING)
, ...)
|
- kmalloc
+ kmalloc_array
(
- (E1) * E2
+ E1, E2
, ...)
|
- kmalloc
+ kmalloc_array
(
- (E1) * (E2)
+ E1, E2
, ...)
|
- kmalloc
+ kmalloc_array
(
- E1 * E2
+ E1, E2
, ...)
)
Signed-off-by: Kees Cook <keescook@chromium.org>
2018-06-12 20:55:00 +00:00
|
|
|
kmalloc_array(*nwname,
|
|
|
|
|
sizeof(char *),
|
|
|
|
|
GFP_NOFS);
|
2008-10-14 01:40:27 +00:00
|
|
|
if (!*wnames)
|
|
|
|
|
errcode = -ENOMEM;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (!errcode) {
|
|
|
|
|
int i;
|
|
|
|
|
|
|
|
|
|
for (i = 0; i < *nwname; i++) {
|
|
|
|
|
errcode =
|
2010-03-05 18:50:14 +00:00
|
|
|
p9pdu_readf(pdu,
|
|
|
|
|
proto_version,
|
2008-10-14 01:40:27 +00:00
|
|
|
"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':{
|
2014-12-30 00:48:09 +00:00
|
|
|
uint16_t *nwqid = va_arg(ap, uint16_t *);
|
2008-10-14 01:40:27 +00:00
|
|
|
struct p9_qid **wqids =
|
|
|
|
|
va_arg(ap, struct p9_qid **);
|
|
|
|
|
|
|
|
|
|
*wqids = NULL;
|
|
|
|
|
|
|
|
|
|
errcode =
|
2010-03-05 18:50:14 +00:00
|
|
|
p9pdu_readf(pdu, proto_version, "w", nwqid);
|
2008-10-14 01:40:27 +00:00
|
|
|
if (!errcode) {
|
|
|
|
|
*wqids =
|
treewide: kmalloc() -> kmalloc_array()
The kmalloc() function has a 2-factor argument form, kmalloc_array(). This
patch replaces cases of:
kmalloc(a * b, gfp)
with:
kmalloc_array(a * b, gfp)
as well as handling cases of:
kmalloc(a * b * c, gfp)
with:
kmalloc(array3_size(a, b, c), gfp)
as it's slightly less ugly than:
kmalloc_array(array_size(a, b), c, gfp)
This does, however, attempt to ignore constant size factors like:
kmalloc(4 * 1024, gfp)
though any constants defined via macros get caught up in the conversion.
Any factors with a sizeof() of "unsigned char", "char", and "u8" were
dropped, since they're redundant.
The tools/ directory was manually excluded, since it has its own
implementation of kmalloc().
The Coccinelle script used for this was:
// Fix redundant parens around sizeof().
@@
type TYPE;
expression THING, E;
@@
(
kmalloc(
- (sizeof(TYPE)) * E
+ sizeof(TYPE) * E
, ...)
|
kmalloc(
- (sizeof(THING)) * E
+ sizeof(THING) * E
, ...)
)
// Drop single-byte sizes and redundant parens.
@@
expression COUNT;
typedef u8;
typedef __u8;
@@
(
kmalloc(
- sizeof(u8) * (COUNT)
+ COUNT
, ...)
|
kmalloc(
- sizeof(__u8) * (COUNT)
+ COUNT
, ...)
|
kmalloc(
- sizeof(char) * (COUNT)
+ COUNT
, ...)
|
kmalloc(
- sizeof(unsigned char) * (COUNT)
+ COUNT
, ...)
|
kmalloc(
- sizeof(u8) * COUNT
+ COUNT
, ...)
|
kmalloc(
- sizeof(__u8) * COUNT
+ COUNT
, ...)
|
kmalloc(
- sizeof(char) * COUNT
+ COUNT
, ...)
|
kmalloc(
- sizeof(unsigned char) * COUNT
+ COUNT
, ...)
)
// 2-factor product with sizeof(type/expression) and identifier or constant.
@@
type TYPE;
expression THING;
identifier COUNT_ID;
constant COUNT_CONST;
@@
(
- kmalloc
+ kmalloc_array
(
- sizeof(TYPE) * (COUNT_ID)
+ COUNT_ID, sizeof(TYPE)
, ...)
|
- kmalloc
+ kmalloc_array
(
- sizeof(TYPE) * COUNT_ID
+ COUNT_ID, sizeof(TYPE)
, ...)
|
- kmalloc
+ kmalloc_array
(
- sizeof(TYPE) * (COUNT_CONST)
+ COUNT_CONST, sizeof(TYPE)
, ...)
|
- kmalloc
+ kmalloc_array
(
- sizeof(TYPE) * COUNT_CONST
+ COUNT_CONST, sizeof(TYPE)
, ...)
|
- kmalloc
+ kmalloc_array
(
- sizeof(THING) * (COUNT_ID)
+ COUNT_ID, sizeof(THING)
, ...)
|
- kmalloc
+ kmalloc_array
(
- sizeof(THING) * COUNT_ID
+ COUNT_ID, sizeof(THING)
, ...)
|
- kmalloc
+ kmalloc_array
(
- sizeof(THING) * (COUNT_CONST)
+ COUNT_CONST, sizeof(THING)
, ...)
|
- kmalloc
+ kmalloc_array
(
- sizeof(THING) * COUNT_CONST
+ COUNT_CONST, sizeof(THING)
, ...)
)
// 2-factor product, only identifiers.
@@
identifier SIZE, COUNT;
@@
- kmalloc
+ kmalloc_array
(
- SIZE * COUNT
+ COUNT, SIZE
, ...)
// 3-factor product with 1 sizeof(type) or sizeof(expression), with
// redundant parens removed.
@@
expression THING;
identifier STRIDE, COUNT;
type TYPE;
@@
(
kmalloc(
- sizeof(TYPE) * (COUNT) * (STRIDE)
+ array3_size(COUNT, STRIDE, sizeof(TYPE))
, ...)
|
kmalloc(
- sizeof(TYPE) * (COUNT) * STRIDE
+ array3_size(COUNT, STRIDE, sizeof(TYPE))
, ...)
|
kmalloc(
- sizeof(TYPE) * COUNT * (STRIDE)
+ array3_size(COUNT, STRIDE, sizeof(TYPE))
, ...)
|
kmalloc(
- sizeof(TYPE) * COUNT * STRIDE
+ array3_size(COUNT, STRIDE, sizeof(TYPE))
, ...)
|
kmalloc(
- sizeof(THING) * (COUNT) * (STRIDE)
+ array3_size(COUNT, STRIDE, sizeof(THING))
, ...)
|
kmalloc(
- sizeof(THING) * (COUNT) * STRIDE
+ array3_size(COUNT, STRIDE, sizeof(THING))
, ...)
|
kmalloc(
- sizeof(THING) * COUNT * (STRIDE)
+ array3_size(COUNT, STRIDE, sizeof(THING))
, ...)
|
kmalloc(
- sizeof(THING) * COUNT * STRIDE
+ array3_size(COUNT, STRIDE, sizeof(THING))
, ...)
)
// 3-factor product with 2 sizeof(variable), with redundant parens removed.
@@
expression THING1, THING2;
identifier COUNT;
type TYPE1, TYPE2;
@@
(
kmalloc(
- sizeof(TYPE1) * sizeof(TYPE2) * COUNT
+ array3_size(COUNT, sizeof(TYPE1), sizeof(TYPE2))
, ...)
|
kmalloc(
- sizeof(TYPE1) * sizeof(THING2) * (COUNT)
+ array3_size(COUNT, sizeof(TYPE1), sizeof(TYPE2))
, ...)
|
kmalloc(
- sizeof(THING1) * sizeof(THING2) * COUNT
+ array3_size(COUNT, sizeof(THING1), sizeof(THING2))
, ...)
|
kmalloc(
- sizeof(THING1) * sizeof(THING2) * (COUNT)
+ array3_size(COUNT, sizeof(THING1), sizeof(THING2))
, ...)
|
kmalloc(
- sizeof(TYPE1) * sizeof(THING2) * COUNT
+ array3_size(COUNT, sizeof(TYPE1), sizeof(THING2))
, ...)
|
kmalloc(
- sizeof(TYPE1) * sizeof(THING2) * (COUNT)
+ array3_size(COUNT, sizeof(TYPE1), sizeof(THING2))
, ...)
)
// 3-factor product, only identifiers, with redundant parens removed.
@@
identifier STRIDE, SIZE, COUNT;
@@
(
kmalloc(
- (COUNT) * STRIDE * SIZE
+ array3_size(COUNT, STRIDE, SIZE)
, ...)
|
kmalloc(
- COUNT * (STRIDE) * SIZE
+ array3_size(COUNT, STRIDE, SIZE)
, ...)
|
kmalloc(
- COUNT * STRIDE * (SIZE)
+ array3_size(COUNT, STRIDE, SIZE)
, ...)
|
kmalloc(
- (COUNT) * (STRIDE) * SIZE
+ array3_size(COUNT, STRIDE, SIZE)
, ...)
|
kmalloc(
- COUNT * (STRIDE) * (SIZE)
+ array3_size(COUNT, STRIDE, SIZE)
, ...)
|
kmalloc(
- (COUNT) * STRIDE * (SIZE)
+ array3_size(COUNT, STRIDE, SIZE)
, ...)
|
kmalloc(
- (COUNT) * (STRIDE) * (SIZE)
+ array3_size(COUNT, STRIDE, SIZE)
, ...)
|
kmalloc(
- COUNT * STRIDE * SIZE
+ array3_size(COUNT, STRIDE, SIZE)
, ...)
)
// Any remaining multi-factor products, first at least 3-factor products,
// when they're not all constants...
@@
expression E1, E2, E3;
constant C1, C2, C3;
@@
(
kmalloc(C1 * C2 * C3, ...)
|
kmalloc(
- (E1) * E2 * E3
+ array3_size(E1, E2, E3)
, ...)
|
kmalloc(
- (E1) * (E2) * E3
+ array3_size(E1, E2, E3)
, ...)
|
kmalloc(
- (E1) * (E2) * (E3)
+ array3_size(E1, E2, E3)
, ...)
|
kmalloc(
- E1 * E2 * E3
+ array3_size(E1, E2, E3)
, ...)
)
// And then all remaining 2 factors products when they're not all constants,
// keeping sizeof() as the second factor argument.
@@
expression THING, E1, E2;
type TYPE;
constant C1, C2, C3;
@@
(
kmalloc(sizeof(THING) * C2, ...)
|
kmalloc(sizeof(TYPE) * C2, ...)
|
kmalloc(C1 * C2 * C3, ...)
|
kmalloc(C1 * C2, ...)
|
- kmalloc
+ kmalloc_array
(
- sizeof(TYPE) * (E2)
+ E2, sizeof(TYPE)
, ...)
|
- kmalloc
+ kmalloc_array
(
- sizeof(TYPE) * E2
+ E2, sizeof(TYPE)
, ...)
|
- kmalloc
+ kmalloc_array
(
- sizeof(THING) * (E2)
+ E2, sizeof(THING)
, ...)
|
- kmalloc
+ kmalloc_array
(
- sizeof(THING) * E2
+ E2, sizeof(THING)
, ...)
|
- kmalloc
+ kmalloc_array
(
- (E1) * E2
+ E1, E2
, ...)
|
- kmalloc
+ kmalloc_array
(
- (E1) * (E2)
+ E1, E2
, ...)
|
- kmalloc
+ kmalloc_array
(
- E1 * E2
+ E1, E2
, ...)
)
Signed-off-by: Kees Cook <keescook@chromium.org>
2018-06-12 20:55:00 +00:00
|
|
|
kmalloc_array(*nwqid,
|
|
|
|
|
sizeof(struct p9_qid),
|
|
|
|
|
GFP_NOFS);
|
2008-10-14 01:40:27 +00:00
|
|
|
if (*wqids == NULL)
|
|
|
|
|
errcode = -ENOMEM;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (!errcode) {
|
|
|
|
|
int i;
|
|
|
|
|
|
|
|
|
|
for (i = 0; i < *nwqid; i++) {
|
|
|
|
|
errcode =
|
2010-03-05 18:50:14 +00:00
|
|
|
p9pdu_readf(pdu,
|
|
|
|
|
proto_version,
|
2008-10-14 01:40:27 +00:00
|
|
|
"Q",
|
|
|
|
|
&(*wqids)[i]);
|
|
|
|
|
if (errcode)
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (errcode) {
|
|
|
|
|
kfree(*wqids);
|
|
|
|
|
*wqids = NULL;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
break;
|
9p: getattr client implementation for 9P2000.L protocol.
SYNOPSIS
size[4] Tgetattr tag[2] fid[4] request_mask[8]
size[4] Rgetattr tag[2] lstat[n]
DESCRIPTION
The getattr transaction inquires about the file identified by fid.
request_mask is a bit mask that specifies which fields of the
stat structure is the client interested in.
The reply will contain a machine-independent directory entry,
laid out as follows:
st_result_mask[8]
Bit mask that indicates which fields in the stat structure
have been populated by the server
qid.type[1]
the type of the file (directory, etc.), represented as a bit
vector corresponding to the high 8 bits of the file's mode
word.
qid.vers[4]
version number for given path
qid.path[8]
the file server's unique identification for the file
st_mode[4]
Permission and flags
st_uid[4]
User id of owner
st_gid[4]
Group ID of owner
st_nlink[8]
Number of hard links
st_rdev[8]
Device ID (if special file)
st_size[8]
Size, in bytes
st_blksize[8]
Block size for file system IO
st_blocks[8]
Number of file system blocks allocated
st_atime_sec[8]
Time of last access, seconds
st_atime_nsec[8]
Time of last access, nanoseconds
st_mtime_sec[8]
Time of last modification, seconds
st_mtime_nsec[8]
Time of last modification, nanoseconds
st_ctime_sec[8]
Time of last status change, seconds
st_ctime_nsec[8]
Time of last status change, nanoseconds
st_btime_sec[8]
Time of creation (birth) of file, seconds
st_btime_nsec[8]
Time of creation (birth) of file, nanoseconds
st_gen[8]
Inode generation
st_data_version[8]
Data version number
request_mask and result_mask bit masks contain the following bits
#define P9_STATS_MODE 0x00000001ULL
#define P9_STATS_NLINK 0x00000002ULL
#define P9_STATS_UID 0x00000004ULL
#define P9_STATS_GID 0x00000008ULL
#define P9_STATS_RDEV 0x00000010ULL
#define P9_STATS_ATIME 0x00000020ULL
#define P9_STATS_MTIME 0x00000040ULL
#define P9_STATS_CTIME 0x00000080ULL
#define P9_STATS_INO 0x00000100ULL
#define P9_STATS_SIZE 0x00000200ULL
#define P9_STATS_BLOCKS 0x00000400ULL
#define P9_STATS_BTIME 0x00000800ULL
#define P9_STATS_GEN 0x00001000ULL
#define P9_STATS_DATA_VERSION 0x00002000ULL
#define P9_STATS_BASIC 0x000007ffULL
#define P9_STATS_ALL 0x00003fffULL
This patch implements the client side of getattr implementation for
9P2000.L. It introduces a new structure p9_stat_dotl for getting
Linux stat information along with QID. The data layout is similar to
stat structure in Linux user space with the following major
differences:
inode (st_ino) is not part of data. Instead qid is.
device (st_dev) is not part of data because this doesn't make sense
on the client.
All time variables are 64 bit wide on the wire. The kernel seems to use
32 bit variables for these variables. However, some of the architectures
have used 64 bit variables and glibc exposes 64 bit variables to user
space on some architectures. Hence to be on the safer side we have made
these 64 bit in the protocol. Refer to the comments in
include/asm-generic/stat.h
There are some additional fields: st_btime_sec, st_btime_nsec, st_gen,
st_data_version apart from the bitmask, st_result_mask. The bit mask
is filled by the server to indicate which stat fields have been
populated by the server. Currently there is no clean way for the
server to obtain these additional fields, so it sends back just the
basic fields.
Signed-off-by: Sripathi Kodi <sripathik@in.ibm.com>
Signed-off-by: Eric Van Hensbegren <ericvh@gmail.com>
2010-07-12 14:37:23 +00:00
|
|
|
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,
|
2013-01-30 00:18:50 +00:00
|
|
|
"qQdugqqqqqqqqqqqqqqq",
|
9p: getattr client implementation for 9P2000.L protocol.
SYNOPSIS
size[4] Tgetattr tag[2] fid[4] request_mask[8]
size[4] Rgetattr tag[2] lstat[n]
DESCRIPTION
The getattr transaction inquires about the file identified by fid.
request_mask is a bit mask that specifies which fields of the
stat structure is the client interested in.
The reply will contain a machine-independent directory entry,
laid out as follows:
st_result_mask[8]
Bit mask that indicates which fields in the stat structure
have been populated by the server
qid.type[1]
the type of the file (directory, etc.), represented as a bit
vector corresponding to the high 8 bits of the file's mode
word.
qid.vers[4]
version number for given path
qid.path[8]
the file server's unique identification for the file
st_mode[4]
Permission and flags
st_uid[4]
User id of owner
st_gid[4]
Group ID of owner
st_nlink[8]
Number of hard links
st_rdev[8]
Device ID (if special file)
st_size[8]
Size, in bytes
st_blksize[8]
Block size for file system IO
st_blocks[8]
Number of file system blocks allocated
st_atime_sec[8]
Time of last access, seconds
st_atime_nsec[8]
Time of last access, nanoseconds
st_mtime_sec[8]
Time of last modification, seconds
st_mtime_nsec[8]
Time of last modification, nanoseconds
st_ctime_sec[8]
Time of last status change, seconds
st_ctime_nsec[8]
Time of last status change, nanoseconds
st_btime_sec[8]
Time of creation (birth) of file, seconds
st_btime_nsec[8]
Time of creation (birth) of file, nanoseconds
st_gen[8]
Inode generation
st_data_version[8]
Data version number
request_mask and result_mask bit masks contain the following bits
#define P9_STATS_MODE 0x00000001ULL
#define P9_STATS_NLINK 0x00000002ULL
#define P9_STATS_UID 0x00000004ULL
#define P9_STATS_GID 0x00000008ULL
#define P9_STATS_RDEV 0x00000010ULL
#define P9_STATS_ATIME 0x00000020ULL
#define P9_STATS_MTIME 0x00000040ULL
#define P9_STATS_CTIME 0x00000080ULL
#define P9_STATS_INO 0x00000100ULL
#define P9_STATS_SIZE 0x00000200ULL
#define P9_STATS_BLOCKS 0x00000400ULL
#define P9_STATS_BTIME 0x00000800ULL
#define P9_STATS_GEN 0x00001000ULL
#define P9_STATS_DATA_VERSION 0x00002000ULL
#define P9_STATS_BASIC 0x000007ffULL
#define P9_STATS_ALL 0x00003fffULL
This patch implements the client side of getattr implementation for
9P2000.L. It introduces a new structure p9_stat_dotl for getting
Linux stat information along with QID. The data layout is similar to
stat structure in Linux user space with the following major
differences:
inode (st_ino) is not part of data. Instead qid is.
device (st_dev) is not part of data because this doesn't make sense
on the client.
All time variables are 64 bit wide on the wire. The kernel seems to use
32 bit variables for these variables. However, some of the architectures
have used 64 bit variables and glibc exposes 64 bit variables to user
space on some architectures. Hence to be on the safer side we have made
these 64 bit in the protocol. Refer to the comments in
include/asm-generic/stat.h
There are some additional fields: st_btime_sec, st_btime_nsec, st_gen,
st_data_version apart from the bitmask, st_result_mask. The bit mask
is filled by the server to indicate which stat fields have been
populated by the server. Currently there is no clean way for the
server to obtain these additional fields, so it sends back just the
basic fields.
Signed-off-by: Sripathi Kodi <sripathik@in.ibm.com>
Signed-off-by: Eric Van Hensbegren <ericvh@gmail.com>
2010-07-12 14:37:23 +00:00
|
|
|
&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;
|
2008-10-14 01:40:27 +00:00
|
|
|
case '?':
|
2010-03-25 12:40:35 +00:00
|
|
|
if ((proto_version != p9_proto_2000u) &&
|
|
|
|
|
(proto_version != p9_proto_2000L))
|
2008-10-14 01:40:27 +00:00
|
|
|
return 0;
|
|
|
|
|
break;
|
|
|
|
|
default:
|
|
|
|
|
BUG();
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (errcode)
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return errcode;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
int
|
2010-03-05 18:50:14 +00:00
|
|
|
p9pdu_vwritef(struct p9_fcall *pdu, int proto_version, const char *fmt,
|
|
|
|
|
va_list ap)
|
2008-10-14 01:40:27 +00:00
|
|
|
{
|
|
|
|
|
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':{
|
2009-02-07 06:07:41 +00:00
|
|
|
__le16 val = cpu_to_le16(va_arg(ap, int));
|
2008-10-14 01:40:27 +00:00
|
|
|
if (pdu_write(pdu, &val, sizeof(val)))
|
|
|
|
|
errcode = -EFAULT;
|
|
|
|
|
}
|
|
|
|
|
break;
|
|
|
|
|
case 'd':{
|
2009-02-07 06:07:41 +00:00
|
|
|
__le32 val = cpu_to_le32(va_arg(ap, int32_t));
|
2008-10-14 01:40:27 +00:00
|
|
|
if (pdu_write(pdu, &val, sizeof(val)))
|
|
|
|
|
errcode = -EFAULT;
|
|
|
|
|
}
|
|
|
|
|
break;
|
|
|
|
|
case 'q':{
|
2009-02-07 06:07:41 +00:00
|
|
|
__le64 val = cpu_to_le64(va_arg(ap, int64_t));
|
2008-10-14 01:40:27 +00:00
|
|
|
if (pdu_write(pdu, &val, sizeof(val)))
|
|
|
|
|
errcode = -EFAULT;
|
|
|
|
|
}
|
|
|
|
|
break;
|
|
|
|
|
case 's':{
|
2008-10-22 23:54:47 +00:00
|
|
|
const char *sptr = va_arg(ap, const char *);
|
2011-01-10 20:23:53 +00:00
|
|
|
uint16_t len = 0;
|
2008-10-22 23:54:47 +00:00
|
|
|
if (sptr)
|
2012-06-26 23:01:41 +00:00
|
|
|
len = min_t(size_t, strlen(sptr),
|
2011-01-10 20:23:53 +00:00
|
|
|
USHRT_MAX);
|
2008-10-14 01:40:27 +00:00
|
|
|
|
2010-03-05 18:50:14 +00:00
|
|
|
errcode = p9pdu_writef(pdu, proto_version,
|
|
|
|
|
"w", len);
|
2008-10-22 23:54:47 +00:00
|
|
|
if (!errcode && pdu_write(pdu, sptr, len))
|
2008-10-14 01:40:27 +00:00
|
|
|
errcode = -EFAULT;
|
|
|
|
|
}
|
|
|
|
|
break;
|
2013-01-30 01:07:42 +00:00
|
|
|
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;
|
2008-10-14 01:40:27 +00:00
|
|
|
case 'Q':{
|
|
|
|
|
const struct p9_qid *qid =
|
|
|
|
|
va_arg(ap, const struct p9_qid *);
|
|
|
|
|
errcode =
|
2010-03-05 18:50:14 +00:00
|
|
|
p9pdu_writef(pdu, proto_version, "bdq",
|
2008-10-14 01:40:27 +00:00
|
|
|
qid->type, qid->version,
|
|
|
|
|
qid->path);
|
|
|
|
|
} break;
|
|
|
|
|
case 'S':{
|
|
|
|
|
const struct p9_wstat *stbuf =
|
|
|
|
|
va_arg(ap, const struct p9_wstat *);
|
|
|
|
|
errcode =
|
2010-03-05 18:50:14 +00:00
|
|
|
p9pdu_writef(pdu, proto_version,
|
2013-01-30 00:18:50 +00:00
|
|
|
"wwdQdddqssss?sugu",
|
2008-10-14 01:40:27 +00:00
|
|
|
stbuf->size, stbuf->type,
|
2008-10-16 13:30:07 +00:00
|
|
|
stbuf->dev, &stbuf->qid,
|
2008-10-14 01:40:27 +00:00
|
|
|
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;
|
2015-04-01 23:57:53 +00:00
|
|
|
case 'V':{
|
2014-12-30 00:48:09 +00:00
|
|
|
uint32_t count = va_arg(ap, uint32_t);
|
2015-04-01 23:57:53 +00:00
|
|
|
struct iov_iter *from =
|
|
|
|
|
va_arg(ap, struct iov_iter *);
|
2010-03-05 18:50:14 +00:00
|
|
|
errcode = p9pdu_writef(pdu, proto_version, "d",
|
|
|
|
|
count);
|
2015-04-01 23:57:53 +00:00
|
|
|
if (!errcode && pdu_write_u(pdu, from, count))
|
2008-10-16 13:30:07 +00:00
|
|
|
errcode = -EFAULT;
|
|
|
|
|
}
|
|
|
|
|
break;
|
2008-10-14 01:40:27 +00:00
|
|
|
case 'T':{
|
2011-03-31 10:19:39 +00:00
|
|
|
uint16_t nwname = va_arg(ap, int);
|
2008-10-14 01:40:27 +00:00
|
|
|
const char **wnames = va_arg(ap, const char **);
|
|
|
|
|
|
2010-03-05 18:50:14 +00:00
|
|
|
errcode = p9pdu_writef(pdu, proto_version, "w",
|
|
|
|
|
nwname);
|
2008-10-14 01:40:27 +00:00
|
|
|
if (!errcode) {
|
|
|
|
|
int i;
|
|
|
|
|
|
|
|
|
|
for (i = 0; i < nwname; i++) {
|
|
|
|
|
errcode =
|
2010-03-05 18:50:14 +00:00
|
|
|
p9pdu_writef(pdu,
|
|
|
|
|
proto_version,
|
2008-10-14 01:40:27 +00:00
|
|
|
"s",
|
|
|
|
|
wnames[i]);
|
|
|
|
|
if (errcode)
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
break;
|
|
|
|
|
case 'R':{
|
2014-12-30 00:48:09 +00:00
|
|
|
uint16_t nwqid = va_arg(ap, int);
|
2008-10-14 01:40:27 +00:00
|
|
|
struct p9_qid *wqids =
|
|
|
|
|
va_arg(ap, struct p9_qid *);
|
|
|
|
|
|
2010-03-05 18:50:14 +00:00
|
|
|
errcode = p9pdu_writef(pdu, proto_version, "w",
|
|
|
|
|
nwqid);
|
2008-10-14 01:40:27 +00:00
|
|
|
if (!errcode) {
|
|
|
|
|
int i;
|
|
|
|
|
|
|
|
|
|
for (i = 0; i < nwqid; i++) {
|
|
|
|
|
errcode =
|
2010-03-05 18:50:14 +00:00
|
|
|
p9pdu_writef(pdu,
|
|
|
|
|
proto_version,
|
2008-10-14 01:40:27 +00:00
|
|
|
"Q",
|
|
|
|
|
&wqids[i]);
|
|
|
|
|
if (errcode)
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
break;
|
9p: Implement client side of setattr for 9P2000.L protocol.
SYNOPSIS
size[4] Tsetattr tag[2] attr[n]
size[4] Rsetattr tag[2]
DESCRIPTION
The setattr command changes some of the file status information.
attr resembles the iattr structure used in Linux kernel. It
specifies which status parameter is to be changed and to what
value. It is laid out as follows:
valid[4]
specifies which status information is to be changed. Possible
values are:
ATTR_MODE (1 << 0)
ATTR_UID (1 << 1)
ATTR_GID (1 << 2)
ATTR_SIZE (1 << 3)
ATTR_ATIME (1 << 4)
ATTR_MTIME (1 << 5)
ATTR_ATIME_SET (1 << 7)
ATTR_MTIME_SET (1 << 8)
The last two bits represent whether the time information
is being sent by the client's user space. In the absense
of these bits the server always uses server's time.
mode[4]
File permission bits
uid[4]
Owner id of file
gid[4]
Group id of the file
size[8]
File size
atime_sec[8]
Time of last file access, seconds
atime_nsec[8]
Time of last file access, nanoseconds
mtime_sec[8]
Time of last file modification, seconds
mtime_nsec[8]
Time of last file modification, nanoseconds
Explanation of the patches:
--------------------------
*) The kernel just copies relevent contents of iattr structure to
p9_iattr_dotl structure and passes it down to the client. The
only check it has is calling inode_change_ok()
*) The p9_iattr_dotl structure does not have ctime and ia_file
parameters because I don't think these are needed in our case.
The client user space can request updating just ctime by calling
chown(fd, -1, -1). This is handled on server side without a need
for putting ctime on the wire.
*) The server currently supports changing mode, time, ownership and
size of the file.
*) 9P RFC says "Either all the changes in wstat request happen, or
none of them does: if the request succeeds, all changes were made;
if it fails, none were."
I have not done anything to implement this specifically because I
don't see a reason.
Signed-off-by: Sripathi Kodi <sripathik@in.ibm.com>
Signed-off-by: Venkateswararao Jujjuri <jvrao@linux.vnet.ibm.com>
Signed-off-by: Eric Van Hensbergen <ericvh@gmail.com>
2010-06-18 06:20:10 +00:00
|
|
|
case 'I':{
|
|
|
|
|
struct p9_iattr_dotl *p9attr = va_arg(ap,
|
|
|
|
|
struct p9_iattr_dotl *);
|
|
|
|
|
|
|
|
|
|
errcode = p9pdu_writef(pdu, proto_version,
|
2013-01-30 00:18:50 +00:00
|
|
|
"ddugqqqqq",
|
9p: Implement client side of setattr for 9P2000.L protocol.
SYNOPSIS
size[4] Tsetattr tag[2] attr[n]
size[4] Rsetattr tag[2]
DESCRIPTION
The setattr command changes some of the file status information.
attr resembles the iattr structure used in Linux kernel. It
specifies which status parameter is to be changed and to what
value. It is laid out as follows:
valid[4]
specifies which status information is to be changed. Possible
values are:
ATTR_MODE (1 << 0)
ATTR_UID (1 << 1)
ATTR_GID (1 << 2)
ATTR_SIZE (1 << 3)
ATTR_ATIME (1 << 4)
ATTR_MTIME (1 << 5)
ATTR_ATIME_SET (1 << 7)
ATTR_MTIME_SET (1 << 8)
The last two bits represent whether the time information
is being sent by the client's user space. In the absense
of these bits the server always uses server's time.
mode[4]
File permission bits
uid[4]
Owner id of file
gid[4]
Group id of the file
size[8]
File size
atime_sec[8]
Time of last file access, seconds
atime_nsec[8]
Time of last file access, nanoseconds
mtime_sec[8]
Time of last file modification, seconds
mtime_nsec[8]
Time of last file modification, nanoseconds
Explanation of the patches:
--------------------------
*) The kernel just copies relevent contents of iattr structure to
p9_iattr_dotl structure and passes it down to the client. The
only check it has is calling inode_change_ok()
*) The p9_iattr_dotl structure does not have ctime and ia_file
parameters because I don't think these are needed in our case.
The client user space can request updating just ctime by calling
chown(fd, -1, -1). This is handled on server side without a need
for putting ctime on the wire.
*) The server currently supports changing mode, time, ownership and
size of the file.
*) 9P RFC says "Either all the changes in wstat request happen, or
none of them does: if the request succeeds, all changes were made;
if it fails, none were."
I have not done anything to implement this specifically because I
don't see a reason.
Signed-off-by: Sripathi Kodi <sripathik@in.ibm.com>
Signed-off-by: Venkateswararao Jujjuri <jvrao@linux.vnet.ibm.com>
Signed-off-by: Eric Van Hensbergen <ericvh@gmail.com>
2010-06-18 06:20:10 +00:00
|
|
|
p9attr->valid,
|
|
|
|
|
p9attr->mode,
|
|
|
|
|
p9attr->uid,
|
|
|
|
|
p9attr->gid,
|
|
|
|
|
p9attr->size,
|
|
|
|
|
p9attr->atime_sec,
|
|
|
|
|
p9attr->atime_nsec,
|
|
|
|
|
p9attr->mtime_sec,
|
|
|
|
|
p9attr->mtime_nsec);
|
|
|
|
|
}
|
|
|
|
|
break;
|
2008-10-14 01:40:27 +00:00
|
|
|
case '?':
|
2010-03-25 12:40:35 +00:00
|
|
|
if ((proto_version != p9_proto_2000u) &&
|
|
|
|
|
(proto_version != p9_proto_2000L))
|
2008-10-14 01:40:27 +00:00
|
|
|
return 0;
|
|
|
|
|
break;
|
|
|
|
|
default:
|
|
|
|
|
BUG();
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (errcode)
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return errcode;
|
|
|
|
|
}
|
|
|
|
|
|
2010-03-05 18:50:14 +00:00
|
|
|
int p9pdu_readf(struct p9_fcall *pdu, int proto_version, const char *fmt, ...)
|
2008-10-14 01:40:27 +00:00
|
|
|
{
|
|
|
|
|
va_list ap;
|
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
|
|
va_start(ap, fmt);
|
2010-03-05 18:50:14 +00:00
|
|
|
ret = p9pdu_vreadf(pdu, proto_version, fmt, ap);
|
2008-10-14 01:40:27 +00:00
|
|
|
va_end(ap);
|
|
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static int
|
2010-03-05 18:50:14 +00:00
|
|
|
p9pdu_writef(struct p9_fcall *pdu, int proto_version, const char *fmt, ...)
|
2008-10-14 01:40:27 +00:00
|
|
|
{
|
|
|
|
|
va_list ap;
|
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
|
|
va_start(ap, fmt);
|
2010-03-05 18:50:14 +00:00
|
|
|
ret = p9pdu_vwritef(pdu, proto_version, fmt, ap);
|
2008-10-14 01:40:27 +00:00
|
|
|
va_end(ap);
|
|
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
|
}
|
2008-10-16 13:30:07 +00:00
|
|
|
|
2011-08-06 19:16:59 +00:00
|
|
|
int p9stat_read(struct p9_client *clnt, char *buf, int len, struct p9_wstat *st)
|
2008-10-16 13:29:30 +00:00
|
|
|
{
|
|
|
|
|
struct p9_fcall fake_pdu;
|
2008-10-17 21:20:07 +00:00
|
|
|
int ret;
|
2008-10-16 13:29:30 +00:00
|
|
|
|
|
|
|
|
fake_pdu.size = len;
|
|
|
|
|
fake_pdu.capacity = len;
|
|
|
|
|
fake_pdu.sdata = buf;
|
|
|
|
|
fake_pdu.offset = 0;
|
|
|
|
|
|
2011-08-06 19:16:59 +00:00
|
|
|
ret = p9pdu_readf(&fake_pdu, clnt->proto_version, "S", st);
|
2008-10-17 21:20:07 +00:00
|
|
|
if (ret) {
|
2011-11-28 18:40:46 +00:00
|
|
|
p9_debug(P9_DEBUG_9P, "<<< p9stat_read failed: %d\n", ret);
|
2011-08-06 19:16:59 +00:00
|
|
|
trace_9p_protocol_dump(clnt, &fake_pdu);
|
2018-09-05 06:41:29 +00:00
|
|
|
return ret;
|
2008-10-17 21:20:07 +00:00
|
|
|
}
|
|
|
|
|
|
2018-09-05 06:41:29 +00:00
|
|
|
return fake_pdu.offset;
|
2008-10-16 13:29:30 +00:00
|
|
|
}
|
|
|
|
|
EXPORT_SYMBOL(p9stat_read);
|
|
|
|
|
|
2008-10-16 13:30:07 +00:00
|
|
|
int p9pdu_prepare(struct p9_fcall *pdu, int16_t tag, int8_t type)
|
|
|
|
|
{
|
2011-02-03 01:52:46 +00:00
|
|
|
pdu->id = type;
|
2008-10-16 13:30:07 +00:00
|
|
|
return p9pdu_writef(pdu, 0, "dbw", 0, type, tag);
|
|
|
|
|
}
|
|
|
|
|
|
2011-08-06 19:16:59 +00:00
|
|
|
int p9pdu_finalize(struct p9_client *clnt, struct p9_fcall *pdu)
|
2008-10-16 13:30:07 +00:00
|
|
|
{
|
|
|
|
|
int size = pdu->size;
|
|
|
|
|
int err;
|
|
|
|
|
|
|
|
|
|
pdu->size = 0;
|
|
|
|
|
err = p9pdu_writef(pdu, 0, "d", size);
|
|
|
|
|
pdu->size = size;
|
|
|
|
|
|
2011-08-06 19:16:59 +00:00
|
|
|
trace_9p_protocol_dump(clnt, pdu);
|
2011-11-28 18:40:46 +00:00
|
|
|
p9_debug(P9_DEBUG_9P, ">>> size=%d type: %d tag: %d\n",
|
|
|
|
|
pdu->size, pdu->id, pdu->tag);
|
2008-10-17 21:20:07 +00:00
|
|
|
|
2008-10-16 13:30:07 +00:00
|
|
|
return err;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void p9pdu_reset(struct p9_fcall *pdu)
|
|
|
|
|
{
|
|
|
|
|
pdu->offset = 0;
|
|
|
|
|
pdu->size = 0;
|
|
|
|
|
}
|
2010-06-04 13:41:26 +00:00
|
|
|
|
2011-08-06 19:16:59 +00:00
|
|
|
int p9dirent_read(struct p9_client *clnt, char *buf, int len,
|
|
|
|
|
struct p9_dirent *dirent)
|
2010-06-04 13:41:26 +00:00
|
|
|
{
|
|
|
|
|
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;
|
|
|
|
|
|
2011-08-06 19:16:59 +00:00
|
|
|
ret = p9pdu_readf(&fake_pdu, clnt->proto_version, "Qqbs", &dirent->qid,
|
|
|
|
|
&dirent->d_off, &dirent->d_type, &nameptr);
|
2010-06-04 13:41:26 +00:00
|
|
|
if (ret) {
|
2011-11-28 18:40:46 +00:00
|
|
|
p9_debug(P9_DEBUG_9P, "<<< p9dirent_read failed: %d\n", ret);
|
2011-08-06 19:16:59 +00:00
|
|
|
trace_9p_protocol_dump(clnt, &fake_pdu);
|
2018-09-07 15:36:08 +00:00
|
|
|
return ret;
|
2010-06-04 13:41:26 +00:00
|
|
|
}
|
|
|
|
|
|
2018-09-07 15:36:08 +00:00
|
|
|
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;
|
|
|
|
|
}
|
2011-05-09 14:10:49 +00:00
|
|
|
kfree(nameptr);
|
2010-06-04 13:41:26 +00:00
|
|
|
|
|
|
|
|
return fake_pdu.offset;
|
|
|
|
|
}
|
|
|
|
|
EXPORT_SYMBOL(p9dirent_read);
|
