2010-04-29 14:14:44 +02:00
|
|
|
/*
|
|
|
|
* Virtio 9p backend
|
|
|
|
*
|
|
|
|
* Copyright IBM, Corp. 2010
|
|
|
|
*
|
|
|
|
* Authors:
|
|
|
|
* Anthony Liguori <aliguori@us.ibm.com>
|
|
|
|
*
|
|
|
|
* This work is licensed under the terms of the GNU GPL, version 2. See
|
|
|
|
* the COPYING file in the top-level directory.
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
|
2021-05-06 15:12:23 +02:00
|
|
|
/*
|
|
|
|
* Not so fast! You might want to read the 9p developer docs first:
|
|
|
|
* https://wiki.qemu.org/Documentation/9p
|
|
|
|
*/
|
|
|
|
|
2016-01-26 19:17:10 +01:00
|
|
|
#include "qemu/osdep.h"
|
2016-09-16 08:56:15 +02:00
|
|
|
#include <glib/gprintf.h>
|
2013-02-05 17:06:20 +01:00
|
|
|
#include "hw/virtio/virtio.h"
|
include/qemu/osdep.h: Don't include qapi/error.h
Commit 57cb38b included qapi/error.h into qemu/osdep.h to get the
Error typedef. Since then, we've moved to include qemu/osdep.h
everywhere. Its file comment explains: "To avoid getting into
possible circular include dependencies, this file should not include
any other QEMU headers, with the exceptions of config-host.h,
compiler.h, os-posix.h and os-win32.h, all of which are doing a
similar job to this file and are under similar constraints."
qapi/error.h doesn't do a similar job, and it doesn't adhere to
similar constraints: it includes qapi-types.h. That's in excess of
100KiB of crap most .c files don't actually need.
Add the typedef to qemu/typedefs.h, and include that instead of
qapi/error.h. Include qapi/error.h in .c files that need it and don't
get it now. Include qapi-types.h in qom/object.h for uint16List.
Update scripts/clean-includes accordingly. Update it further to match
reality: replace config.h by config-target.h, add sysemu/os-posix.h,
sysemu/os-win32.h. Update the list of includes in the qemu/osdep.h
comment quoted above similarly.
This reduces the number of objects depending on qapi/error.h from "all
of them" to less than a third. Unfortunately, the number depending on
qapi-types.h shrinks only a little. More work is needed for that one.
Signed-off-by: Markus Armbruster <armbru@redhat.com>
[Fix compilation without the spice devel packages. - Paolo]
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
2016-03-14 09:01:28 +01:00
|
|
|
#include "qapi/error.h"
|
2015-03-17 18:29:20 +01:00
|
|
|
#include "qemu/error-report.h"
|
2015-07-23 19:57:53 +02:00
|
|
|
#include "qemu/iov.h"
|
Include qemu/main-loop.h less
In my "build everything" tree, changing qemu/main-loop.h triggers a
recompile of some 5600 out of 6600 objects (not counting tests and
objects that don't depend on qemu/osdep.h). It includes block/aio.h,
which in turn includes qemu/event_notifier.h, qemu/notify.h,
qemu/processor.h, qemu/qsp.h, qemu/queue.h, qemu/thread-posix.h,
qemu/thread.h, qemu/timer.h, and a few more.
Include qemu/main-loop.h only where it's needed. Touching it now
recompiles only some 1700 objects. For block/aio.h and
qemu/event_notifier.h, these numbers drop from 5600 to 2800. For the
others, they shrink only slightly.
Signed-off-by: Markus Armbruster <armbru@redhat.com>
Message-Id: <20190812052359.30071-21-armbru@redhat.com>
Reviewed-by: Alex Bennée <alex.bennee@linaro.org>
Reviewed-by: Philippe Mathieu-Daudé <philmd@redhat.com>
Tested-by: Philippe Mathieu-Daudé <philmd@redhat.com>
2019-08-12 07:23:50 +02:00
|
|
|
#include "qemu/main-loop.h"
|
2012-12-17 18:20:00 +01:00
|
|
|
#include "qemu/sockets.h"
|
2010-04-29 14:14:44 +02:00
|
|
|
#include "virtio-9p.h"
|
|
|
|
#include "fsdev/qemu-fsdev.h"
|
2015-11-18 19:31:52 +01:00
|
|
|
#include "9p-xattr.h"
|
2015-11-18 18:57:30 +01:00
|
|
|
#include "coth.h"
|
2011-10-12 15:41:25 +02:00
|
|
|
#include "trace.h"
|
2017-04-06 12:00:28 +02:00
|
|
|
#include "migration/blocker.h"
|
2019-10-10 11:36:05 +02:00
|
|
|
#include "qemu/xxhash.h"
|
2019-10-07 17:02:45 +02:00
|
|
|
#include <math.h>
|
2020-05-25 10:38:03 +02:00
|
|
|
#include <linux/limits.h>
|
2010-04-29 14:14:44 +02:00
|
|
|
|
2011-05-18 12:10:57 +02:00
|
|
|
int open_fd_hw;
|
|
|
|
int total_open_fd;
|
|
|
|
static int open_fd_rc;
|
2010-04-29 14:14:44 +02:00
|
|
|
|
2010-06-01 22:30:51 +02:00
|
|
|
enum {
|
|
|
|
Oread = 0x00,
|
|
|
|
Owrite = 0x01,
|
|
|
|
Ordwr = 0x02,
|
|
|
|
Oexec = 0x03,
|
|
|
|
Oexcl = 0x04,
|
|
|
|
Otrunc = 0x10,
|
|
|
|
Orexec = 0x20,
|
|
|
|
Orclose = 0x40,
|
|
|
|
Oappend = 0x80,
|
|
|
|
};
|
|
|
|
|
2021-10-01 16:27:46 +02:00
|
|
|
P9ARRAY_DEFINE_TYPE(V9fsPath, v9fs_path_free);
|
|
|
|
|
2018-01-08 11:18:22 +01:00
|
|
|
static ssize_t pdu_marshal(V9fsPDU *pdu, size_t offset, const char *fmt, ...)
|
2015-12-02 15:22:04 +01:00
|
|
|
{
|
|
|
|
ssize_t ret;
|
|
|
|
va_list ap;
|
|
|
|
|
|
|
|
va_start(ap, fmt);
|
2017-01-03 17:28:44 +01:00
|
|
|
ret = pdu->s->transport->pdu_vmarshal(pdu, offset, fmt, ap);
|
2015-12-02 15:22:04 +01:00
|
|
|
va_end(ap);
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2018-01-08 11:18:22 +01:00
|
|
|
static ssize_t pdu_unmarshal(V9fsPDU *pdu, size_t offset, const char *fmt, ...)
|
2015-12-02 15:22:04 +01:00
|
|
|
{
|
|
|
|
ssize_t ret;
|
|
|
|
va_list ap;
|
|
|
|
|
|
|
|
va_start(ap, fmt);
|
2017-01-03 17:28:44 +01:00
|
|
|
ret = pdu->s->transport->pdu_vunmarshal(pdu, offset, fmt, ap);
|
2015-12-02 15:22:04 +01:00
|
|
|
va_end(ap);
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2010-06-01 22:30:51 +02:00
|
|
|
static int omode_to_uflags(int8_t mode)
|
|
|
|
{
|
|
|
|
int ret = 0;
|
|
|
|
|
|
|
|
switch (mode & 3) {
|
|
|
|
case Oread:
|
|
|
|
ret = O_RDONLY;
|
|
|
|
break;
|
|
|
|
case Ordwr:
|
|
|
|
ret = O_RDWR;
|
|
|
|
break;
|
|
|
|
case Owrite:
|
|
|
|
ret = O_WRONLY;
|
|
|
|
break;
|
|
|
|
case Oexec:
|
|
|
|
ret = O_RDONLY;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (mode & Otrunc) {
|
|
|
|
ret |= O_TRUNC;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (mode & Oappend) {
|
|
|
|
ret |= O_APPEND;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (mode & Oexcl) {
|
|
|
|
ret |= O_EXCL;
|
|
|
|
}
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2018-01-08 11:18:22 +01:00
|
|
|
typedef struct DotlOpenflagMap {
|
2011-10-12 15:41:24 +02:00
|
|
|
int dotl_flag;
|
|
|
|
int open_flag;
|
2018-01-08 11:18:22 +01:00
|
|
|
} DotlOpenflagMap;
|
2011-10-12 15:41:24 +02:00
|
|
|
|
|
|
|
static int dotl_to_open_flags(int flags)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
/*
|
|
|
|
* We have same bits for P9_DOTL_READONLY, P9_DOTL_WRONLY
|
|
|
|
* and P9_DOTL_NOACCESS
|
|
|
|
*/
|
|
|
|
int oflags = flags & O_ACCMODE;
|
|
|
|
|
2018-01-08 11:18:22 +01:00
|
|
|
DotlOpenflagMap dotl_oflag_map[] = {
|
2011-10-12 15:41:24 +02:00
|
|
|
{ P9_DOTL_CREATE, O_CREAT },
|
|
|
|
{ P9_DOTL_EXCL, O_EXCL },
|
|
|
|
{ P9_DOTL_NOCTTY , O_NOCTTY },
|
|
|
|
{ P9_DOTL_TRUNC, O_TRUNC },
|
|
|
|
{ P9_DOTL_APPEND, O_APPEND },
|
|
|
|
{ P9_DOTL_NONBLOCK, O_NONBLOCK } ,
|
|
|
|
{ P9_DOTL_DSYNC, O_DSYNC },
|
|
|
|
{ P9_DOTL_FASYNC, FASYNC },
|
|
|
|
{ P9_DOTL_DIRECT, O_DIRECT },
|
|
|
|
{ P9_DOTL_LARGEFILE, O_LARGEFILE },
|
|
|
|
{ P9_DOTL_DIRECTORY, O_DIRECTORY },
|
|
|
|
{ P9_DOTL_NOFOLLOW, O_NOFOLLOW },
|
|
|
|
{ P9_DOTL_NOATIME, O_NOATIME },
|
|
|
|
{ P9_DOTL_SYNC, O_SYNC },
|
|
|
|
};
|
|
|
|
|
|
|
|
for (i = 0; i < ARRAY_SIZE(dotl_oflag_map); i++) {
|
|
|
|
if (flags & dotl_oflag_map[i].dotl_flag) {
|
|
|
|
oflags |= dotl_oflag_map[i].open_flag;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return oflags;
|
|
|
|
}
|
|
|
|
|
2010-06-14 22:34:41 +02:00
|
|
|
void cred_init(FsCred *credp)
|
2010-04-29 14:14:47 +02:00
|
|
|
{
|
2010-06-14 22:34:41 +02:00
|
|
|
credp->fc_uid = -1;
|
|
|
|
credp->fc_gid = -1;
|
|
|
|
credp->fc_mode = -1;
|
|
|
|
credp->fc_rdev = -1;
|
2010-04-29 14:14:47 +02:00
|
|
|
}
|
|
|
|
|
2011-10-12 15:41:23 +02:00
|
|
|
static int get_dotl_openflags(V9fsState *s, int oflags)
|
|
|
|
{
|
|
|
|
int flags;
|
|
|
|
/*
|
|
|
|
* Filter the client open flags
|
|
|
|
*/
|
2011-10-12 15:41:24 +02:00
|
|
|
flags = dotl_to_open_flags(oflags);
|
|
|
|
flags &= ~(O_NOCTTY | O_ASYNC | O_CREAT);
|
2011-10-12 15:41:23 +02:00
|
|
|
/*
|
|
|
|
* Ignore direct disk access hint until the server supports it.
|
|
|
|
*/
|
|
|
|
flags &= ~O_DIRECT;
|
|
|
|
return flags;
|
|
|
|
}
|
|
|
|
|
2011-09-09 11:44:18 +02:00
|
|
|
void v9fs_path_init(V9fsPath *path)
|
|
|
|
{
|
|
|
|
path->data = NULL;
|
|
|
|
path->size = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
void v9fs_path_free(V9fsPath *path)
|
|
|
|
{
|
|
|
|
g_free(path->data);
|
|
|
|
path->data = NULL;
|
|
|
|
path->size = 0;
|
|
|
|
}
|
|
|
|
|
2016-09-16 08:56:15 +02:00
|
|
|
|
|
|
|
void GCC_FMT_ATTR(2, 3)
|
|
|
|
v9fs_path_sprintf(V9fsPath *path, const char *fmt, ...)
|
|
|
|
{
|
|
|
|
va_list ap;
|
|
|
|
|
|
|
|
v9fs_path_free(path);
|
|
|
|
|
|
|
|
va_start(ap, fmt);
|
|
|
|
/* Bump the size for including terminating NULL */
|
|
|
|
path->size = g_vasprintf(&path->data, fmt, ap) + 1;
|
|
|
|
va_end(ap);
|
|
|
|
}
|
|
|
|
|
2018-02-19 18:27:15 +01:00
|
|
|
void v9fs_path_copy(V9fsPath *dst, const V9fsPath *src)
|
2011-09-09 11:44:18 +02:00
|
|
|
{
|
2018-02-19 18:27:15 +01:00
|
|
|
v9fs_path_free(dst);
|
|
|
|
dst->size = src->size;
|
|
|
|
dst->data = g_memdup(src->data, src->size);
|
2011-09-09 11:44:18 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
int v9fs_name_to_path(V9fsState *s, V9fsPath *dirpath,
|
|
|
|
const char *name, V9fsPath *path)
|
|
|
|
{
|
|
|
|
int err;
|
|
|
|
err = s->ops->name_to_path(&s->ctx, dirpath, name, path);
|
|
|
|
if (err < 0) {
|
|
|
|
err = -errno;
|
|
|
|
}
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
2011-06-01 09:05:11 +02:00
|
|
|
/*
|
|
|
|
* Return TRUE if s1 is an ancestor of s2.
|
|
|
|
*
|
|
|
|
* E.g. "a/b" is an ancestor of "a/b/c" but not of "a/bc/d".
|
|
|
|
* As a special case, We treat s1 as ancestor of s2 if they are same!
|
|
|
|
*/
|
2011-09-09 11:44:18 +02:00
|
|
|
static int v9fs_path_is_ancestor(V9fsPath *s1, V9fsPath *s2)
|
2011-06-01 09:05:11 +02:00
|
|
|
{
|
2011-09-09 11:44:18 +02:00
|
|
|
if (!strncmp(s1->data, s2->data, s1->size - 1)) {
|
|
|
|
if (s2->data[s1->size - 1] == '\0' || s2->data[s1->size - 1] == '/') {
|
2011-06-01 09:05:11 +02:00
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2010-04-29 14:14:46 +02:00
|
|
|
static size_t v9fs_string_size(V9fsString *str)
|
|
|
|
{
|
|
|
|
return str->size;
|
|
|
|
}
|
|
|
|
|
2011-08-02 08:06:24 +02:00
|
|
|
/*
|
|
|
|
* returns 0 if fid got re-opened, 1 if not, < 0 on error */
|
2016-10-17 14:13:58 +02:00
|
|
|
static int coroutine_fn v9fs_reopen_fid(V9fsPDU *pdu, V9fsFidState *f)
|
2011-08-02 08:06:24 +02:00
|
|
|
{
|
|
|
|
int err = 1;
|
|
|
|
if (f->fid_type == P9_FID_FILE) {
|
|
|
|
if (f->fs.fd == -1) {
|
|
|
|
do {
|
2011-08-02 08:06:17 +02:00
|
|
|
err = v9fs_co_open(pdu, f, f->open_flags);
|
|
|
|
} while (err == -EINTR && !pdu->cancelled);
|
2011-08-02 08:06:24 +02:00
|
|
|
}
|
|
|
|
} else if (f->fid_type == P9_FID_DIR) {
|
2016-06-06 11:52:34 +02:00
|
|
|
if (f->fs.dir.stream == NULL) {
|
2011-08-02 08:06:24 +02:00
|
|
|
do {
|
2011-08-02 08:06:17 +02:00
|
|
|
err = v9fs_co_opendir(pdu, f);
|
|
|
|
} while (err == -EINTR && !pdu->cancelled);
|
2011-08-02 08:06:24 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
2016-10-17 14:13:58 +02:00
|
|
|
static V9fsFidState *coroutine_fn get_fid(V9fsPDU *pdu, int32_t fid)
|
2010-04-29 14:14:48 +02:00
|
|
|
{
|
2011-05-18 12:10:57 +02:00
|
|
|
int err;
|
2010-04-29 14:14:48 +02:00
|
|
|
V9fsFidState *f;
|
2011-08-02 08:06:17 +02:00
|
|
|
V9fsState *s = pdu->s;
|
2010-04-29 14:14:48 +02:00
|
|
|
|
2021-01-18 15:22:59 +01:00
|
|
|
QSIMPLEQ_FOREACH(f, &s->fid_list, next) {
|
2011-05-18 14:08:07 +02:00
|
|
|
BUG_ON(f->clunked);
|
2010-04-29 14:14:48 +02:00
|
|
|
if (f->fid == fid) {
|
2011-05-18 12:10:57 +02:00
|
|
|
/*
|
|
|
|
* Update the fid ref upfront so that
|
|
|
|
* we don't get reclaimed when we yield
|
|
|
|
* in open later.
|
|
|
|
*/
|
2011-05-18 14:08:07 +02:00
|
|
|
f->ref++;
|
2011-05-18 12:10:57 +02:00
|
|
|
/*
|
|
|
|
* check whether we need to reopen the
|
|
|
|
* file. We might have closed the fd
|
|
|
|
* while trying to free up some file
|
|
|
|
* descriptors.
|
|
|
|
*/
|
2011-08-02 08:06:17 +02:00
|
|
|
err = v9fs_reopen_fid(pdu, f);
|
2011-08-02 08:06:24 +02:00
|
|
|
if (err < 0) {
|
|
|
|
f->ref--;
|
|
|
|
return NULL;
|
|
|
|
}
|
2011-05-18 12:10:57 +02:00
|
|
|
/*
|
|
|
|
* Mark the fid as referenced so that the LRU
|
|
|
|
* reclaim won't close the file descriptor
|
|
|
|
*/
|
|
|
|
f->flags |= FID_REFERENCED;
|
2010-04-29 14:14:48 +02:00
|
|
|
return f;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
static V9fsFidState *alloc_fid(V9fsState *s, int32_t fid)
|
|
|
|
{
|
|
|
|
V9fsFidState *f;
|
|
|
|
|
2021-01-18 15:22:59 +01:00
|
|
|
QSIMPLEQ_FOREACH(f, &s->fid_list, next) {
|
2011-05-18 14:08:07 +02:00
|
|
|
/* If fid is already there return NULL */
|
|
|
|
BUG_ON(f->clunked);
|
|
|
|
if (f->fid == fid) {
|
|
|
|
return NULL;
|
|
|
|
}
|
2010-04-29 14:14:48 +02:00
|
|
|
}
|
2011-08-21 05:09:37 +02:00
|
|
|
f = g_malloc0(sizeof(V9fsFidState));
|
2010-04-29 14:14:48 +02:00
|
|
|
f->fid = fid;
|
2010-09-02 07:39:06 +02:00
|
|
|
f->fid_type = P9_FID_NONE;
|
2011-05-18 14:08:07 +02:00
|
|
|
f->ref = 1;
|
2011-05-18 12:10:57 +02:00
|
|
|
/*
|
|
|
|
* Mark the fid as referenced so that the LRU
|
|
|
|
* reclaim won't close the file descriptor
|
|
|
|
*/
|
|
|
|
f->flags |= FID_REFERENCED;
|
2021-01-21 19:15:10 +01:00
|
|
|
QSIMPLEQ_INSERT_TAIL(&s->fid_list, f, next);
|
2010-04-29 14:14:48 +02:00
|
|
|
|
2020-07-29 10:39:12 +02:00
|
|
|
v9fs_readdir_init(s->proto_version, &f->fs.dir);
|
|
|
|
v9fs_readdir_init(s->proto_version, &f->fs_reclaim.dir);
|
2016-06-06 11:52:34 +02:00
|
|
|
|
2010-04-29 14:14:48 +02:00
|
|
|
return f;
|
|
|
|
}
|
|
|
|
|
2016-10-17 14:13:58 +02:00
|
|
|
static int coroutine_fn v9fs_xattr_fid_clunk(V9fsPDU *pdu, V9fsFidState *fidp)
|
2010-09-02 07:39:07 +02:00
|
|
|
{
|
|
|
|
int retval = 0;
|
|
|
|
|
2016-11-01 12:00:40 +01:00
|
|
|
if (fidp->fs.xattr.xattrwalk_fid) {
|
2010-09-02 07:39:07 +02:00
|
|
|
/* getxattr/listxattr fid */
|
|
|
|
goto free_value;
|
|
|
|
}
|
|
|
|
/*
|
|
|
|
* if this is fid for setxattr. clunk should
|
|
|
|
* result in setxattr localcall
|
|
|
|
*/
|
|
|
|
if (fidp->fs.xattr.len != fidp->fs.xattr.copied_len) {
|
|
|
|
/* clunk after partial write */
|
|
|
|
retval = -EINVAL;
|
|
|
|
goto free_out;
|
|
|
|
}
|
2010-08-26 07:45:23 +02:00
|
|
|
if (fidp->fs.xattr.len) {
|
2011-08-02 08:06:17 +02:00
|
|
|
retval = v9fs_co_lsetxattr(pdu, &fidp->path, &fidp->fs.xattr.name,
|
2010-08-26 07:45:23 +02:00
|
|
|
fidp->fs.xattr.value,
|
|
|
|
fidp->fs.xattr.len,
|
|
|
|
fidp->fs.xattr.flags);
|
|
|
|
} else {
|
2011-08-02 08:06:17 +02:00
|
|
|
retval = v9fs_co_lremovexattr(pdu, &fidp->path, &fidp->fs.xattr.name);
|
2010-08-26 07:45:23 +02:00
|
|
|
}
|
2010-09-02 07:39:07 +02:00
|
|
|
free_out:
|
|
|
|
v9fs_string_free(&fidp->fs.xattr.name);
|
|
|
|
free_value:
|
2014-06-06 18:43:29 +02:00
|
|
|
g_free(fidp->fs.xattr.value);
|
2010-09-02 07:39:07 +02:00
|
|
|
return retval;
|
|
|
|
}
|
|
|
|
|
2016-10-17 14:13:58 +02:00
|
|
|
static int coroutine_fn free_fid(V9fsPDU *pdu, V9fsFidState *fidp)
|
2010-04-29 14:14:48 +02:00
|
|
|
{
|
2010-09-02 07:39:07 +02:00
|
|
|
int retval = 0;
|
2011-05-18 14:08:07 +02:00
|
|
|
|
|
|
|
if (fidp->fid_type == P9_FID_FILE) {
|
2011-05-18 12:10:57 +02:00
|
|
|
/* If we reclaimed the fd no need to close */
|
|
|
|
if (fidp->fs.fd != -1) {
|
2011-10-25 08:40:40 +02:00
|
|
|
retval = v9fs_co_close(pdu, &fidp->fs);
|
2011-05-18 12:10:57 +02:00
|
|
|
}
|
2011-05-18 14:08:07 +02:00
|
|
|
} else if (fidp->fid_type == P9_FID_DIR) {
|
2016-06-06 11:52:34 +02:00
|
|
|
if (fidp->fs.dir.stream != NULL) {
|
2011-10-25 08:40:40 +02:00
|
|
|
retval = v9fs_co_closedir(pdu, &fidp->fs);
|
2011-05-18 13:38:34 +02:00
|
|
|
}
|
2011-05-18 14:08:07 +02:00
|
|
|
} else if (fidp->fid_type == P9_FID_XATTR) {
|
2011-08-02 08:06:17 +02:00
|
|
|
retval = v9fs_xattr_fid_clunk(pdu, fidp);
|
2011-05-18 14:08:07 +02:00
|
|
|
}
|
2011-09-09 11:44:18 +02:00
|
|
|
v9fs_path_free(&fidp->path);
|
2011-05-18 14:08:07 +02:00
|
|
|
g_free(fidp);
|
|
|
|
return retval;
|
|
|
|
}
|
|
|
|
|
2016-10-17 14:13:58 +02:00
|
|
|
static int coroutine_fn put_fid(V9fsPDU *pdu, V9fsFidState *fidp)
|
2011-05-18 14:08:07 +02:00
|
|
|
{
|
|
|
|
BUG_ON(!fidp->ref);
|
|
|
|
fidp->ref--;
|
2011-05-18 12:10:57 +02:00
|
|
|
/*
|
|
|
|
* Don't free the fid if it is in reclaim list
|
|
|
|
*/
|
2011-05-18 14:08:07 +02:00
|
|
|
if (!fidp->ref && fidp->clunked) {
|
2011-12-04 18:05:28 +01:00
|
|
|
if (fidp->fid == pdu->s->root_fid) {
|
|
|
|
/*
|
|
|
|
* if the clunked fid is root fid then we
|
|
|
|
* have unmounted the fs on the client side.
|
|
|
|
* delete the migration blocker. Ideally, this
|
|
|
|
* should be hooked to transport close notification
|
|
|
|
*/
|
|
|
|
if (pdu->s->migration_blocker) {
|
|
|
|
migrate_del_blocker(pdu->s->migration_blocker);
|
|
|
|
error_free(pdu->s->migration_blocker);
|
|
|
|
pdu->s->migration_blocker = NULL;
|
|
|
|
}
|
|
|
|
}
|
2013-02-05 06:57:46 +01:00
|
|
|
return free_fid(pdu, fidp);
|
2011-05-18 14:08:07 +02:00
|
|
|
}
|
2013-02-05 06:57:46 +01:00
|
|
|
return 0;
|
2011-05-18 14:08:07 +02:00
|
|
|
}
|
|
|
|
|
2011-08-02 08:06:24 +02:00
|
|
|
static V9fsFidState *clunk_fid(V9fsState *s, int32_t fid)
|
2011-05-18 14:08:07 +02:00
|
|
|
{
|
2021-01-18 15:22:59 +01:00
|
|
|
V9fsFidState *fidp;
|
2010-04-29 14:14:48 +02:00
|
|
|
|
2021-01-18 15:22:59 +01:00
|
|
|
QSIMPLEQ_FOREACH(fidp, &s->fid_list, next) {
|
|
|
|
if (fidp->fid == fid) {
|
|
|
|
QSIMPLEQ_REMOVE(&s->fid_list, fidp, V9fsFidState, next);
|
|
|
|
fidp->clunked = true;
|
|
|
|
return fidp;
|
2010-04-29 14:14:48 +02:00
|
|
|
}
|
|
|
|
}
|
2021-01-18 15:22:59 +01:00
|
|
|
return NULL;
|
2010-04-29 14:14:48 +02:00
|
|
|
}
|
|
|
|
|
2016-10-17 14:13:58 +02:00
|
|
|
void coroutine_fn v9fs_reclaim_fd(V9fsPDU *pdu)
|
2011-05-18 12:10:57 +02:00
|
|
|
{
|
|
|
|
int reclaim_count = 0;
|
2011-08-02 08:06:17 +02:00
|
|
|
V9fsState *s = pdu->s;
|
2021-01-22 15:35:14 +01:00
|
|
|
V9fsFidState *f;
|
|
|
|
QSLIST_HEAD(, V9fsFidState) reclaim_list =
|
|
|
|
QSLIST_HEAD_INITIALIZER(reclaim_list);
|
2011-05-18 12:10:57 +02:00
|
|
|
|
2021-01-18 15:22:59 +01:00
|
|
|
QSIMPLEQ_FOREACH(f, &s->fid_list, next) {
|
2011-05-18 12:10:57 +02:00
|
|
|
/*
|
|
|
|
* Unlink fids cannot be reclaimed. Check
|
|
|
|
* for them and skip them. Also skip fids
|
|
|
|
* currently being operated on.
|
|
|
|
*/
|
|
|
|
if (f->ref || f->flags & FID_NON_RECLAIMABLE) {
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
/*
|
|
|
|
* if it is a recently referenced fid
|
|
|
|
* we leave the fid untouched and clear the
|
|
|
|
* reference bit. We come back to it later
|
|
|
|
* in the next iteration. (a simple LRU without
|
|
|
|
* moving list elements around)
|
|
|
|
*/
|
|
|
|
if (f->flags & FID_REFERENCED) {
|
|
|
|
f->flags &= ~FID_REFERENCED;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
/*
|
|
|
|
* Add fids to reclaim list.
|
|
|
|
*/
|
|
|
|
if (f->fid_type == P9_FID_FILE) {
|
|
|
|
if (f->fs.fd != -1) {
|
|
|
|
/*
|
|
|
|
* Up the reference count so that
|
|
|
|
* a clunk request won't free this fid
|
|
|
|
*/
|
|
|
|
f->ref++;
|
2021-01-22 15:35:14 +01:00
|
|
|
QSLIST_INSERT_HEAD(&reclaim_list, f, reclaim_next);
|
2011-05-18 12:10:57 +02:00
|
|
|
f->fs_reclaim.fd = f->fs.fd;
|
|
|
|
f->fs.fd = -1;
|
|
|
|
reclaim_count++;
|
|
|
|
}
|
2011-05-18 13:38:34 +02:00
|
|
|
} else if (f->fid_type == P9_FID_DIR) {
|
2016-06-06 11:52:34 +02:00
|
|
|
if (f->fs.dir.stream != NULL) {
|
2011-05-18 13:38:34 +02:00
|
|
|
/*
|
|
|
|
* Up the reference count so that
|
|
|
|
* a clunk request won't free this fid
|
|
|
|
*/
|
|
|
|
f->ref++;
|
2021-01-22 15:35:14 +01:00
|
|
|
QSLIST_INSERT_HEAD(&reclaim_list, f, reclaim_next);
|
2016-06-06 11:52:34 +02:00
|
|
|
f->fs_reclaim.dir.stream = f->fs.dir.stream;
|
|
|
|
f->fs.dir.stream = NULL;
|
2011-05-18 13:38:34 +02:00
|
|
|
reclaim_count++;
|
|
|
|
}
|
2011-05-18 12:10:57 +02:00
|
|
|
}
|
|
|
|
if (reclaim_count >= open_fd_rc) {
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
/*
|
|
|
|
* Now close the fid in reclaim list. Free them if they
|
|
|
|
* are already clunked.
|
|
|
|
*/
|
2021-01-22 15:35:14 +01:00
|
|
|
while (!QSLIST_EMPTY(&reclaim_list)) {
|
|
|
|
f = QSLIST_FIRST(&reclaim_list);
|
|
|
|
QSLIST_REMOVE(&reclaim_list, f, V9fsFidState, reclaim_next);
|
2011-05-18 12:10:57 +02:00
|
|
|
if (f->fid_type == P9_FID_FILE) {
|
2011-10-25 08:40:40 +02:00
|
|
|
v9fs_co_close(pdu, &f->fs_reclaim);
|
2011-05-18 13:38:34 +02:00
|
|
|
} else if (f->fid_type == P9_FID_DIR) {
|
2011-10-25 08:40:40 +02:00
|
|
|
v9fs_co_closedir(pdu, &f->fs_reclaim);
|
2011-05-18 12:10:57 +02:00
|
|
|
}
|
|
|
|
/*
|
|
|
|
* Now drop the fid reference, free it
|
|
|
|
* if clunked.
|
|
|
|
*/
|
2011-08-02 08:06:17 +02:00
|
|
|
put_fid(pdu, f);
|
2011-05-18 12:10:57 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-10-17 14:13:58 +02:00
|
|
|
static int coroutine_fn v9fs_mark_fids_unreclaim(V9fsPDU *pdu, V9fsPath *path)
|
2011-05-18 12:10:57 +02:00
|
|
|
{
|
|
|
|
int err;
|
2011-08-02 08:06:17 +02:00
|
|
|
V9fsState *s = pdu->s;
|
2021-01-21 19:15:10 +01:00
|
|
|
V9fsFidState *fidp, *fidp_next;
|
2011-05-18 12:10:57 +02:00
|
|
|
|
2021-01-21 19:15:10 +01:00
|
|
|
fidp = QSIMPLEQ_FIRST(&s->fid_list);
|
|
|
|
if (!fidp) {
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* v9fs_reopen_fid() can yield : a reference on the fid must be held
|
|
|
|
* to ensure its pointer remains valid and we can safely pass it to
|
|
|
|
* QSIMPLEQ_NEXT(). The corresponding put_fid() can also yield so
|
|
|
|
* we must keep a reference on the next fid as well. So the logic here
|
|
|
|
* is to get a reference on a fid and only put it back during the next
|
|
|
|
* iteration after we could get a reference on the next fid. Start with
|
|
|
|
* the first one.
|
|
|
|
*/
|
|
|
|
for (fidp->ref++; fidp; fidp = fidp_next) {
|
|
|
|
if (fidp->path.size == path->size &&
|
|
|
|
!memcmp(fidp->path.data, path->data, path->size)) {
|
2011-05-18 12:10:57 +02:00
|
|
|
/* Mark the fid non reclaimable. */
|
|
|
|
fidp->flags |= FID_NON_RECLAIMABLE;
|
2011-08-02 08:06:24 +02:00
|
|
|
|
|
|
|
/* reopen the file/dir if already closed */
|
2011-08-02 08:06:17 +02:00
|
|
|
err = v9fs_reopen_fid(pdu, fidp);
|
2011-08-02 08:06:24 +02:00
|
|
|
if (err < 0) {
|
2021-01-21 19:15:10 +01:00
|
|
|
put_fid(pdu, fidp);
|
2017-11-06 18:05:35 +01:00
|
|
|
return err;
|
2011-08-02 08:06:24 +02:00
|
|
|
}
|
2021-01-21 19:15:10 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
fidp_next = QSIMPLEQ_NEXT(fidp, next);
|
|
|
|
|
|
|
|
if (fidp_next) {
|
2011-08-02 08:06:24 +02:00
|
|
|
/*
|
2021-01-21 19:15:10 +01:00
|
|
|
* Ensure the next fid survives a potential clunk request during
|
|
|
|
* put_fid() below and v9fs_reopen_fid() in the next iteration.
|
2011-08-02 08:06:24 +02:00
|
|
|
*/
|
2021-01-21 19:15:10 +01:00
|
|
|
fidp_next->ref++;
|
2011-05-18 12:10:57 +02:00
|
|
|
}
|
2021-01-21 19:15:10 +01:00
|
|
|
|
|
|
|
/* We're done with this fid */
|
|
|
|
put_fid(pdu, fidp);
|
2011-05-18 12:10:57 +02:00
|
|
|
}
|
2021-01-21 19:15:10 +01:00
|
|
|
|
2011-05-18 12:10:57 +02:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2016-10-17 14:13:58 +02:00
|
|
|
static void coroutine_fn virtfs_reset(V9fsPDU *pdu)
|
2011-12-04 18:05:28 +01:00
|
|
|
{
|
|
|
|
V9fsState *s = pdu->s;
|
2016-11-01 12:00:40 +01:00
|
|
|
V9fsFidState *fidp;
|
2011-12-04 18:05:28 +01:00
|
|
|
|
|
|
|
/* Free all fids */
|
2021-01-18 15:22:59 +01:00
|
|
|
while (!QSIMPLEQ_EMPTY(&s->fid_list)) {
|
2017-04-04 18:06:01 +02:00
|
|
|
/* Get fid */
|
2021-01-18 15:22:59 +01:00
|
|
|
fidp = QSIMPLEQ_FIRST(&s->fid_list);
|
2017-04-04 18:06:01 +02:00
|
|
|
fidp->ref++;
|
|
|
|
|
|
|
|
/* Clunk fid */
|
2021-01-18 15:22:59 +01:00
|
|
|
QSIMPLEQ_REMOVE(&s->fid_list, fidp, V9fsFidState, next);
|
2021-01-18 15:22:58 +01:00
|
|
|
fidp->clunked = true;
|
2011-12-04 18:05:28 +01:00
|
|
|
|
2017-04-04 18:06:01 +02:00
|
|
|
put_fid(pdu, fidp);
|
2011-12-04 18:05:28 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2010-04-29 14:14:48 +02:00
|
|
|
#define P9_QID_TYPE_DIR 0x80
|
|
|
|
#define P9_QID_TYPE_SYMLINK 0x02
|
|
|
|
|
|
|
|
#define P9_STAT_MODE_DIR 0x80000000
|
|
|
|
#define P9_STAT_MODE_APPEND 0x40000000
|
|
|
|
#define P9_STAT_MODE_EXCL 0x20000000
|
|
|
|
#define P9_STAT_MODE_MOUNT 0x10000000
|
|
|
|
#define P9_STAT_MODE_AUTH 0x08000000
|
|
|
|
#define P9_STAT_MODE_TMP 0x04000000
|
|
|
|
#define P9_STAT_MODE_SYMLINK 0x02000000
|
|
|
|
#define P9_STAT_MODE_LINK 0x01000000
|
|
|
|
#define P9_STAT_MODE_DEVICE 0x00800000
|
|
|
|
#define P9_STAT_MODE_NAMED_PIPE 0x00200000
|
|
|
|
#define P9_STAT_MODE_SOCKET 0x00100000
|
|
|
|
#define P9_STAT_MODE_SETUID 0x00080000
|
|
|
|
#define P9_STAT_MODE_SETGID 0x00040000
|
|
|
|
#define P9_STAT_MODE_SETVTX 0x00010000
|
|
|
|
|
|
|
|
#define P9_STAT_MODE_TYPE_BITS (P9_STAT_MODE_DIR | \
|
|
|
|
P9_STAT_MODE_SYMLINK | \
|
|
|
|
P9_STAT_MODE_LINK | \
|
|
|
|
P9_STAT_MODE_DEVICE | \
|
|
|
|
P9_STAT_MODE_NAMED_PIPE | \
|
|
|
|
P9_STAT_MODE_SOCKET)
|
|
|
|
|
2019-10-07 17:02:45 +02:00
|
|
|
/* Mirrors all bits of a byte. So e.g. binary 10100000 would become 00000101. */
|
|
|
|
static inline uint8_t mirror8bit(uint8_t byte)
|
|
|
|
{
|
|
|
|
return (byte * 0x0202020202ULL & 0x010884422010ULL) % 1023;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Same as mirror8bit() just for a 64 bit data type instead for a byte. */
|
|
|
|
static inline uint64_t mirror64bit(uint64_t value)
|
|
|
|
{
|
|
|
|
return ((uint64_t)mirror8bit(value & 0xff) << 56) |
|
|
|
|
((uint64_t)mirror8bit((value >> 8) & 0xff) << 48) |
|
|
|
|
((uint64_t)mirror8bit((value >> 16) & 0xff) << 40) |
|
|
|
|
((uint64_t)mirror8bit((value >> 24) & 0xff) << 32) |
|
|
|
|
((uint64_t)mirror8bit((value >> 32) & 0xff) << 24) |
|
|
|
|
((uint64_t)mirror8bit((value >> 40) & 0xff) << 16) |
|
|
|
|
((uint64_t)mirror8bit((value >> 48) & 0xff) << 8) |
|
|
|
|
((uint64_t)mirror8bit((value >> 56) & 0xff));
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @brief Parameter k for the Exponential Golomb algorihm to be used.
|
|
|
|
*
|
|
|
|
* The smaller this value, the smaller the minimum bit count for the Exp.
|
|
|
|
* Golomb generated affixes will be (at lowest index) however for the
|
|
|
|
* price of having higher maximum bit count of generated affixes (at highest
|
|
|
|
* index). Likewise increasing this parameter yields in smaller maximum bit
|
|
|
|
* count for the price of having higher minimum bit count.
|
|
|
|
*
|
|
|
|
* In practice that means: a good value for k depends on the expected amount
|
|
|
|
* of devices to be exposed by one export. For a small amount of devices k
|
|
|
|
* should be small, for a large amount of devices k might be increased
|
|
|
|
* instead. The default of k=0 should be fine for most users though.
|
|
|
|
*
|
|
|
|
* @b IMPORTANT: In case this ever becomes a runtime parameter; the value of
|
|
|
|
* k should not change as long as guest is still running! Because that would
|
|
|
|
* cause completely different inode numbers to be generated on guest.
|
|
|
|
*/
|
|
|
|
#define EXP_GOLOMB_K 0
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @brief Exponential Golomb algorithm for arbitrary k (including k=0).
|
|
|
|
*
|
|
|
|
* The Exponential Golomb algorithm generates @b prefixes (@b not suffixes!)
|
|
|
|
* with growing length and with the mathematical property of being
|
|
|
|
* "prefix-free". The latter means the generated prefixes can be prepended
|
|
|
|
* in front of arbitrary numbers and the resulting concatenated numbers are
|
|
|
|
* guaranteed to be always unique.
|
|
|
|
*
|
|
|
|
* This is a minor adjustment to the original Exp. Golomb algorithm in the
|
|
|
|
* sense that lowest allowed index (@param n) starts with 1, not with zero.
|
|
|
|
*
|
|
|
|
* @param n - natural number (or index) of the prefix to be generated
|
|
|
|
* (1, 2, 3, ...)
|
|
|
|
* @param k - parameter k of Exp. Golomb algorithm to be used
|
|
|
|
* (see comment on EXP_GOLOMB_K macro for details about k)
|
|
|
|
*/
|
|
|
|
static VariLenAffix expGolombEncode(uint64_t n, int k)
|
|
|
|
{
|
|
|
|
const uint64_t value = n + (1 << k) - 1;
|
|
|
|
const int bits = (int) log2(value) + 1;
|
|
|
|
return (VariLenAffix) {
|
|
|
|
.type = AffixType_Prefix,
|
|
|
|
.value = value,
|
|
|
|
.bits = bits + MAX((bits - 1 - k), 0)
|
|
|
|
};
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @brief Converts a suffix into a prefix, or a prefix into a suffix.
|
|
|
|
*
|
|
|
|
* Simply mirror all bits of the affix value, for the purpose to preserve
|
|
|
|
* respectively the mathematical "prefix-free" or "suffix-free" property
|
|
|
|
* after the conversion.
|
|
|
|
*
|
|
|
|
* If a passed prefix is suitable to create unique numbers, then the
|
|
|
|
* returned suffix is suitable to create unique numbers as well (and vice
|
|
|
|
* versa).
|
|
|
|
*/
|
|
|
|
static VariLenAffix invertAffix(const VariLenAffix *affix)
|
|
|
|
{
|
|
|
|
return (VariLenAffix) {
|
|
|
|
.type =
|
|
|
|
(affix->type == AffixType_Suffix) ?
|
|
|
|
AffixType_Prefix : AffixType_Suffix,
|
|
|
|
.value =
|
|
|
|
mirror64bit(affix->value) >>
|
|
|
|
((sizeof(affix->value) * 8) - affix->bits),
|
|
|
|
.bits = affix->bits
|
|
|
|
};
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @brief Generates suffix numbers with "suffix-free" property.
|
|
|
|
*
|
|
|
|
* This is just a wrapper function on top of the Exp. Golomb algorithm.
|
|
|
|
*
|
|
|
|
* Since the Exp. Golomb algorithm generates prefixes, but we need suffixes,
|
|
|
|
* this function converts the Exp. Golomb prefixes into appropriate suffixes
|
|
|
|
* which are still suitable for generating unique numbers.
|
|
|
|
*
|
|
|
|
* @param n - natural number (or index) of the suffix to be generated
|
|
|
|
* (1, 2, 3, ...)
|
|
|
|
*/
|
|
|
|
static VariLenAffix affixForIndex(uint64_t index)
|
|
|
|
{
|
|
|
|
VariLenAffix prefix;
|
|
|
|
prefix = expGolombEncode(index, EXP_GOLOMB_K);
|
|
|
|
return invertAffix(&prefix); /* convert prefix to suffix */
|
|
|
|
}
|
|
|
|
|
2019-10-10 11:36:05 +02:00
|
|
|
/* creative abuse of tb_hash_func7, which is based on xxhash */
|
|
|
|
static uint32_t qpp_hash(QppEntry e)
|
|
|
|
{
|
|
|
|
return qemu_xxhash7(e.ino_prefix, e.dev, 0, 0, 0);
|
|
|
|
}
|
|
|
|
|
2019-10-07 17:02:45 +02:00
|
|
|
static uint32_t qpf_hash(QpfEntry e)
|
|
|
|
{
|
|
|
|
return qemu_xxhash7(e.ino, e.dev, 0, 0, 0);
|
|
|
|
}
|
|
|
|
|
2019-10-07 17:02:45 +02:00
|
|
|
static bool qpd_cmp_func(const void *obj, const void *userp)
|
|
|
|
{
|
|
|
|
const QpdEntry *e1 = obj, *e2 = userp;
|
|
|
|
return e1->dev == e2->dev;
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool qpp_cmp_func(const void *obj, const void *userp)
|
2019-10-10 11:36:05 +02:00
|
|
|
{
|
|
|
|
const QppEntry *e1 = obj, *e2 = userp;
|
|
|
|
return e1->dev == e2->dev && e1->ino_prefix == e2->ino_prefix;
|
|
|
|
}
|
|
|
|
|
2019-10-07 17:02:45 +02:00
|
|
|
static bool qpf_cmp_func(const void *obj, const void *userp)
|
2019-10-07 17:02:45 +02:00
|
|
|
{
|
|
|
|
const QpfEntry *e1 = obj, *e2 = userp;
|
|
|
|
return e1->dev == e2->dev && e1->ino == e2->ino;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void qp_table_remove(void *p, uint32_t h, void *up)
|
2019-10-10 11:36:05 +02:00
|
|
|
{
|
|
|
|
g_free(p);
|
|
|
|
}
|
|
|
|
|
2019-10-07 17:02:45 +02:00
|
|
|
static void qp_table_destroy(struct qht *ht)
|
2019-10-10 11:36:05 +02:00
|
|
|
{
|
|
|
|
if (!ht || !ht->map) {
|
|
|
|
return;
|
|
|
|
}
|
2019-10-07 17:02:45 +02:00
|
|
|
qht_iter(ht, qp_table_remove, NULL);
|
2019-10-10 11:36:05 +02:00
|
|
|
qht_destroy(ht);
|
|
|
|
}
|
|
|
|
|
2019-10-07 17:02:45 +02:00
|
|
|
static void qpd_table_init(struct qht *ht)
|
|
|
|
{
|
|
|
|
qht_init(ht, qpd_cmp_func, 1, QHT_MODE_AUTO_RESIZE);
|
|
|
|
}
|
|
|
|
|
2019-10-10 11:36:05 +02:00
|
|
|
static void qpp_table_init(struct qht *ht)
|
|
|
|
{
|
2019-10-07 17:02:45 +02:00
|
|
|
qht_init(ht, qpp_cmp_func, 1, QHT_MODE_AUTO_RESIZE);
|
2019-10-10 11:36:05 +02:00
|
|
|
}
|
|
|
|
|
2019-10-07 17:02:45 +02:00
|
|
|
static void qpf_table_init(struct qht *ht)
|
|
|
|
{
|
2019-10-07 17:02:45 +02:00
|
|
|
qht_init(ht, qpf_cmp_func, 1 << 16, QHT_MODE_AUTO_RESIZE);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Returns how many (high end) bits of inode numbers of the passed fs
|
|
|
|
* device shall be used (in combination with the device number) to
|
|
|
|
* generate hash values for qpp_table entries.
|
|
|
|
*
|
|
|
|
* This function is required if variable length suffixes are used for inode
|
|
|
|
* number mapping on guest level. Since a device may end up having multiple
|
|
|
|
* entries in qpp_table, each entry most probably with a different suffix
|
|
|
|
* length, we thus need this function in conjunction with qpd_table to
|
|
|
|
* "agree" about a fix amount of bits (per device) to be always used for
|
|
|
|
* generating hash values for the purpose of accessing qpp_table in order
|
|
|
|
* get consistent behaviour when accessing qpp_table.
|
|
|
|
*/
|
|
|
|
static int qid_inode_prefix_hash_bits(V9fsPDU *pdu, dev_t dev)
|
|
|
|
{
|
|
|
|
QpdEntry lookup = {
|
|
|
|
.dev = dev
|
|
|
|
}, *val;
|
|
|
|
uint32_t hash = dev;
|
|
|
|
VariLenAffix affix;
|
|
|
|
|
|
|
|
val = qht_lookup(&pdu->s->qpd_table, &lookup, hash);
|
|
|
|
if (!val) {
|
|
|
|
val = g_malloc0(sizeof(QpdEntry));
|
|
|
|
*val = lookup;
|
|
|
|
affix = affixForIndex(pdu->s->qp_affix_next);
|
|
|
|
val->prefix_bits = affix.bits;
|
|
|
|
qht_insert(&pdu->s->qpd_table, val, hash, NULL);
|
|
|
|
pdu->s->qp_ndevices++;
|
|
|
|
}
|
|
|
|
return val->prefix_bits;
|
2019-10-07 17:02:45 +02:00
|
|
|
}
|
|
|
|
|
2019-10-07 17:02:45 +02:00
|
|
|
/**
|
|
|
|
* @brief Slow / full mapping host inode nr -> guest inode nr.
|
|
|
|
*
|
|
|
|
* This function performs a slower and much more costly remapping of an
|
|
|
|
* original file inode number on host to an appropriate different inode
|
|
|
|
* number on guest. For every (dev, inode) combination on host a new
|
|
|
|
* sequential number is generated, cached and exposed as inode number on
|
|
|
|
* guest.
|
|
|
|
*
|
|
|
|
* This is just a "last resort" fallback solution if the much faster/cheaper
|
|
|
|
* qid_path_suffixmap() failed. In practice this slow / full mapping is not
|
|
|
|
* expected ever to be used at all though.
|
|
|
|
*
|
|
|
|
* @see qid_path_suffixmap() for details
|
|
|
|
*
|
|
|
|
*/
|
2019-10-07 17:02:45 +02:00
|
|
|
static int qid_path_fullmap(V9fsPDU *pdu, const struct stat *stbuf,
|
|
|
|
uint64_t *path)
|
|
|
|
{
|
|
|
|
QpfEntry lookup = {
|
|
|
|
.dev = stbuf->st_dev,
|
|
|
|
.ino = stbuf->st_ino
|
|
|
|
}, *val;
|
|
|
|
uint32_t hash = qpf_hash(lookup);
|
2019-10-07 17:02:45 +02:00
|
|
|
VariLenAffix affix;
|
2019-10-07 17:02:45 +02:00
|
|
|
|
|
|
|
val = qht_lookup(&pdu->s->qpf_table, &lookup, hash);
|
|
|
|
|
|
|
|
if (!val) {
|
|
|
|
if (pdu->s->qp_fullpath_next == 0) {
|
|
|
|
/* no more files can be mapped :'( */
|
|
|
|
error_report_once(
|
|
|
|
"9p: No more prefixes available for remapping inodes from "
|
|
|
|
"host to guest."
|
|
|
|
);
|
|
|
|
return -ENFILE;
|
|
|
|
}
|
|
|
|
|
|
|
|
val = g_malloc0(sizeof(QppEntry));
|
|
|
|
*val = lookup;
|
|
|
|
|
|
|
|
/* new unique inode and device combo */
|
2019-10-07 17:02:45 +02:00
|
|
|
affix = affixForIndex(
|
|
|
|
1ULL << (sizeof(pdu->s->qp_affix_next) * 8)
|
|
|
|
);
|
|
|
|
val->path = (pdu->s->qp_fullpath_next++ << affix.bits) | affix.value;
|
|
|
|
pdu->s->qp_fullpath_next &= ((1ULL << (64 - affix.bits)) - 1);
|
2019-10-07 17:02:45 +02:00
|
|
|
qht_insert(&pdu->s->qpf_table, val, hash, NULL);
|
|
|
|
}
|
|
|
|
|
|
|
|
*path = val->path;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2019-10-07 17:02:45 +02:00
|
|
|
/**
|
|
|
|
* @brief Quick mapping host inode nr -> guest inode nr.
|
2019-10-10 11:36:05 +02:00
|
|
|
*
|
2019-10-07 17:02:45 +02:00
|
|
|
* This function performs quick remapping of an original file inode number
|
|
|
|
* on host to an appropriate different inode number on guest. This remapping
|
|
|
|
* of inodes is required to avoid inode nr collisions on guest which would
|
|
|
|
* happen if the 9p export contains more than 1 exported file system (or
|
|
|
|
* more than 1 file system data set), because unlike on host level where the
|
|
|
|
* files would have different device nrs, all files exported by 9p would
|
|
|
|
* share the same device nr on guest (the device nr of the virtual 9p device
|
|
|
|
* that is).
|
|
|
|
*
|
|
|
|
* Inode remapping is performed by chopping off high end bits of the original
|
|
|
|
* inode number from host, shifting the result upwards and then assigning a
|
|
|
|
* generated suffix number for the low end bits, where the same suffix number
|
|
|
|
* will be shared by all inodes with the same device id AND the same high end
|
|
|
|
* bits that have been chopped off. That approach utilizes the fact that inode
|
|
|
|
* numbers very likely share the same high end bits (i.e. due to their common
|
|
|
|
* sequential generation by file systems) and hence we only have to generate
|
|
|
|
* and track a very limited amount of suffixes in practice due to that.
|
|
|
|
*
|
|
|
|
* We generate variable size suffixes for that purpose. The 1st generated
|
|
|
|
* suffix will only have 1 bit and hence we only need to chop off 1 bit from
|
|
|
|
* the original inode number. The subsequent suffixes being generated will
|
|
|
|
* grow in (bit) size subsequently, i.e. the 2nd and 3rd suffix being
|
|
|
|
* generated will have 3 bits and hence we have to chop off 3 bits from their
|
|
|
|
* original inodes, and so on. That approach of using variable length suffixes
|
|
|
|
* (i.e. over fixed size ones) utilizes the fact that in practice only a very
|
|
|
|
* limited amount of devices are shared by the same export (e.g. typically
|
|
|
|
* less than 2 dozen devices per 9p export), so in practice we need to chop
|
|
|
|
* off less bits than with fixed size prefixes and yet are flexible to add
|
|
|
|
* new devices at runtime below host's export directory at any time without
|
|
|
|
* having to reboot guest nor requiring to reconfigure guest for that. And due
|
|
|
|
* to the very limited amount of original high end bits that we chop off that
|
|
|
|
* way, the total amount of suffixes we need to generate is less than by using
|
|
|
|
* fixed size prefixes and hence it also improves performance of the inode
|
|
|
|
* remapping algorithm, and finally has the nice side effect that the inode
|
|
|
|
* numbers on guest will be much smaller & human friendly. ;-)
|
2019-10-10 11:36:05 +02:00
|
|
|
*/
|
2019-10-07 17:02:45 +02:00
|
|
|
static int qid_path_suffixmap(V9fsPDU *pdu, const struct stat *stbuf,
|
2019-10-10 11:36:05 +02:00
|
|
|
uint64_t *path)
|
|
|
|
{
|
2019-10-07 17:02:45 +02:00
|
|
|
const int ino_hash_bits = qid_inode_prefix_hash_bits(pdu, stbuf->st_dev);
|
2019-10-10 11:36:05 +02:00
|
|
|
QppEntry lookup = {
|
|
|
|
.dev = stbuf->st_dev,
|
2019-10-07 17:02:45 +02:00
|
|
|
.ino_prefix = (uint16_t) (stbuf->st_ino >> (64 - ino_hash_bits))
|
2019-10-10 11:36:05 +02:00
|
|
|
}, *val;
|
|
|
|
uint32_t hash = qpp_hash(lookup);
|
|
|
|
|
|
|
|
val = qht_lookup(&pdu->s->qpp_table, &lookup, hash);
|
|
|
|
|
|
|
|
if (!val) {
|
2019-10-07 17:02:45 +02:00
|
|
|
if (pdu->s->qp_affix_next == 0) {
|
|
|
|
/* we ran out of affixes */
|
2019-10-07 17:02:45 +02:00
|
|
|
warn_report_once(
|
|
|
|
"9p: Potential degraded performance of inode remapping"
|
2019-10-10 11:36:05 +02:00
|
|
|
);
|
|
|
|
return -ENFILE;
|
|
|
|
}
|
|
|
|
|
|
|
|
val = g_malloc0(sizeof(QppEntry));
|
|
|
|
*val = lookup;
|
|
|
|
|
2019-10-07 17:02:45 +02:00
|
|
|
/* new unique inode affix and device combo */
|
|
|
|
val->qp_affix_index = pdu->s->qp_affix_next++;
|
|
|
|
val->qp_affix = affixForIndex(val->qp_affix_index);
|
2019-10-10 11:36:05 +02:00
|
|
|
qht_insert(&pdu->s->qpp_table, val, hash, NULL);
|
|
|
|
}
|
2019-10-07 17:02:45 +02:00
|
|
|
/* assuming generated affix to be suffix type, not prefix */
|
|
|
|
*path = (stbuf->st_ino << val->qp_affix.bits) | val->qp_affix.value;
|
2019-10-10 11:36:05 +02:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2019-10-10 11:36:05 +02:00
|
|
|
static int stat_to_qid(V9fsPDU *pdu, const struct stat *stbuf, V9fsQID *qidp)
|
2010-04-29 14:14:48 +02:00
|
|
|
{
|
2019-10-10 11:36:05 +02:00
|
|
|
int err;
|
2010-04-29 14:14:48 +02:00
|
|
|
size_t size;
|
|
|
|
|
2019-10-10 11:36:05 +02:00
|
|
|
if (pdu->s->ctx.export_flags & V9FS_REMAP_INODES) {
|
|
|
|
/* map inode+device to qid path (fast path) */
|
2019-10-07 17:02:45 +02:00
|
|
|
err = qid_path_suffixmap(pdu, stbuf, &qidp->path);
|
2019-10-07 17:02:45 +02:00
|
|
|
if (err == -ENFILE) {
|
|
|
|
/* fast path didn't work, fall back to full map */
|
|
|
|
err = qid_path_fullmap(pdu, stbuf, &qidp->path);
|
|
|
|
}
|
2019-10-10 11:36:05 +02:00
|
|
|
if (err) {
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
if (pdu->s->dev_id != stbuf->st_dev) {
|
|
|
|
if (pdu->s->ctx.export_flags & V9FS_FORBID_MULTIDEVS) {
|
|
|
|
error_report_once(
|
|
|
|
"9p: Multiple devices detected in same VirtFS export. "
|
|
|
|
"Access of guest to additional devices is (partly) "
|
|
|
|
"denied due to virtfs option 'multidevs=forbid' being "
|
|
|
|
"effective."
|
|
|
|
);
|
|
|
|
return -ENODEV;
|
|
|
|
} else {
|
|
|
|
warn_report_once(
|
|
|
|
"9p: Multiple devices detected in same VirtFS export, "
|
|
|
|
"which might lead to file ID collisions and severe "
|
|
|
|
"misbehaviours on guest! You should either use a "
|
|
|
|
"separate export for each device shared from host or "
|
|
|
|
"use virtfs option 'multidevs=remap'!"
|
|
|
|
);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
memset(&qidp->path, 0, sizeof(qidp->path));
|
|
|
|
size = MIN(sizeof(stbuf->st_ino), sizeof(qidp->path));
|
|
|
|
memcpy(&qidp->path, &stbuf->st_ino, size);
|
2019-10-10 11:36:05 +02:00
|
|
|
}
|
|
|
|
|
2010-04-29 14:14:48 +02:00
|
|
|
qidp->version = stbuf->st_mtime ^ (stbuf->st_size << 8);
|
|
|
|
qidp->type = 0;
|
|
|
|
if (S_ISDIR(stbuf->st_mode)) {
|
|
|
|
qidp->type |= P9_QID_TYPE_DIR;
|
|
|
|
}
|
|
|
|
if (S_ISLNK(stbuf->st_mode)) {
|
|
|
|
qidp->type |= P9_QID_TYPE_SYMLINK;
|
|
|
|
}
|
2019-10-10 11:36:05 +02:00
|
|
|
|
|
|
|
return 0;
|
2010-04-29 14:14:48 +02:00
|
|
|
}
|
|
|
|
|
2016-01-07 19:35:12 +01:00
|
|
|
V9fsPDU *pdu_alloc(V9fsState *s)
|
2010-04-29 14:14:44 +02:00
|
|
|
{
|
|
|
|
V9fsPDU *pdu = NULL;
|
|
|
|
|
|
|
|
if (!QLIST_EMPTY(&s->free_list)) {
|
2011-08-02 08:06:17 +02:00
|
|
|
pdu = QLIST_FIRST(&s->free_list);
|
|
|
|
QLIST_REMOVE(pdu, next);
|
|
|
|
QLIST_INSERT_HEAD(&s->active_list, pdu, next);
|
2010-04-29 14:14:44 +02:00
|
|
|
}
|
|
|
|
return pdu;
|
|
|
|
}
|
|
|
|
|
2016-01-07 19:35:12 +01:00
|
|
|
void pdu_free(V9fsPDU *pdu)
|
2010-04-29 14:14:44 +02:00
|
|
|
{
|
2016-10-17 14:13:58 +02:00
|
|
|
V9fsState *s = pdu->s;
|
2016-10-17 14:13:58 +02:00
|
|
|
|
|
|
|
g_assert(!pdu->cancelled);
|
|
|
|
QLIST_REMOVE(pdu, next);
|
|
|
|
QLIST_INSERT_HEAD(&s->free_list, pdu, next);
|
2010-04-29 14:14:44 +02:00
|
|
|
}
|
|
|
|
|
2016-10-17 14:13:58 +02:00
|
|
|
static void coroutine_fn pdu_complete(V9fsPDU *pdu, ssize_t len)
|
2010-04-29 14:14:45 +02:00
|
|
|
{
|
|
|
|
int8_t id = pdu->id + 1; /* Response */
|
2015-12-02 13:06:28 +01:00
|
|
|
V9fsState *s = pdu->s;
|
2017-06-29 15:11:51 +02:00
|
|
|
int ret;
|
2010-04-29 14:14:45 +02:00
|
|
|
|
9pfs: Correctly handle cancelled requests
# Background
I was investigating spurious non-deterministic EINTR returns from
various 9p file system operations in a Linux guest served from the
qemu 9p server.
## EINTR, ERESTARTSYS and the linux kernel
When a signal arrives that the Linux kernel needs to deliver to user-space
while a given thread is blocked (in the 9p case waiting for a reply to its
request in 9p_client_rpc -> wait_event_interruptible), it asks whatever
driver is currently running to abort its current operation (in the 9p case
causing the submission of a TFLUSH message) and return to user space.
In these situations, the error message reported is generally ERESTARTSYS.
If the userspace processes specified SA_RESTART, this means that the
system call will get restarted upon completion of the signal handler
delivery (assuming the signal handler doesn't modify the process state
in complicated ways not relevant here). If SA_RESTART is not specified,
ERESTARTSYS gets translated to EINTR and user space is expected to handle
the restart itself.
## The 9p TFLUSH command
The 9p TFLUSH commands requests that the server abort an ongoing operation.
The man page [1] specifies:
```
If it recognizes oldtag as the tag of a pending transaction, it should
abort any pending response and discard that tag.
[...]
When the client sends a Tflush, it must wait to receive the corresponding
Rflush before reusing oldtag for subsequent messages. If a response to the
flushed request is received before the Rflush, the client must honor the
response as if it had not been flushed, since the completed request may
signify a state change in the server
```
In particular, this means that the server must not send a reply with the
orignal tag in response to the cancellation request, because the client is
obligated to interpret such a reply as a coincidental reply to the original
request.
# The bug
When qemu receives a TFlush request, it sets the `cancelled` flag on the
relevant pdu. This flag is periodically checked, e.g. in
`v9fs_co_name_to_path`, and if set, the operation is aborted and the error
is set to EINTR. However, the server then violates the spec, by returning
to the client an Rerror response, rather than discarding the message
entirely. As a result, the client is required to assume that said Rerror
response is a result of the original request, not a result of the
cancellation and thus passes the EINTR error back to user space.
This is not the worst thing it could do, however as discussed above, the
correct error code would have been ERESTARTSYS, such that user space
programs with SA_RESTART set get correctly restarted upon completion of
the signal handler.
Instead, such programs get spurious EINTR results that they were not
expecting to handle.
It should be noted that there are plenty of user space programs that do not
set SA_RESTART and do not correctly handle EINTR either. However, that is
then a userspace bug. It should also be noted that this bug has been
mitigated by a recent commit to the Linux kernel [2], which essentially
prevents the kernel from sending Tflush requests unless the process is about
to die (in which case the process likely doesn't care about the response).
Nevertheless, for older kernels and to comply with the spec, I believe this
change is beneficial.
# Implementation
The fix is fairly simple, just skipping notification of a reply if
the pdu was previously cancelled. We do however, also notify the transport
layer that we're doing this, so it can clean up any resources it may be
holding. I also added a new trace event to distinguish
operations that caused an error reply from those that were cancelled.
One complication is that we only omit sending the message on EINTR errors in
order to avoid confusing the rest of the code (which may assume that a
client knows about a fid if it sucessfully passed it off to pud_complete
without checking for cancellation status). This does mean that if the server
acts upon the cancellation flag, it always needs to set err to EINTR. I
believe this is true of the current code.
[1] https://9fans.github.io/plan9port/man/man9/flush.html
[2] https://github.com/torvalds/linux/commit/9523feac272ccad2ad8186ba4fcc891
Signed-off-by: Keno Fischer <keno@juliacomputing.com>
Reviewed-by: Greg Kurz <groug@kaod.org>
[groug, send a zero-sized reply instead of detaching the buffer]
Signed-off-by: Greg Kurz <groug@kaod.org>
Acked-by: Michael S. Tsirkin <mst@redhat.com>
Reviewed-by: Stefano Stabellini <sstabellini@kernel.org>
2018-02-01 21:21:27 +01:00
|
|
|
/*
|
|
|
|
* The 9p spec requires that successfully cancelled pdus receive no reply.
|
|
|
|
* Sending a reply would confuse clients because they would
|
|
|
|
* assume that any EINTR is the actual result of the operation,
|
|
|
|
* rather than a consequence of the cancellation. However, if
|
|
|
|
* the operation completed (succesfully or with an error other
|
|
|
|
* than caused be cancellation), we do send out that reply, both
|
|
|
|
* for efficiency and to avoid confusing the rest of the state machine
|
|
|
|
* that assumes passing a non-error here will mean a successful
|
|
|
|
* transmission of the reply.
|
|
|
|
*/
|
|
|
|
bool discard = pdu->cancelled && len == -EINTR;
|
|
|
|
if (discard) {
|
|
|
|
trace_v9fs_rcancel(pdu->tag, pdu->id);
|
|
|
|
pdu->size = 0;
|
|
|
|
goto out_notify;
|
|
|
|
}
|
|
|
|
|
2010-04-29 14:14:45 +02:00
|
|
|
if (len < 0) {
|
|
|
|
int err = -len;
|
2010-07-28 10:40:22 +02:00
|
|
|
len = 7;
|
2010-04-29 14:14:45 +02:00
|
|
|
|
2010-07-28 10:40:22 +02:00
|
|
|
if (s->proto_version != V9FS_PROTO_2000L) {
|
|
|
|
V9fsString str;
|
|
|
|
|
|
|
|
str.data = strerror(err);
|
|
|
|
str.size = strlen(str.data);
|
|
|
|
|
2017-06-29 15:11:51 +02:00
|
|
|
ret = pdu_marshal(pdu, len, "s", &str);
|
|
|
|
if (ret < 0) {
|
|
|
|
goto out_notify;
|
|
|
|
}
|
|
|
|
len += ret;
|
2010-07-28 10:40:22 +02:00
|
|
|
id = P9_RERROR;
|
|
|
|
}
|
2010-04-29 14:14:45 +02:00
|
|
|
|
2017-06-29 15:11:51 +02:00
|
|
|
ret = pdu_marshal(pdu, len, "d", err);
|
|
|
|
if (ret < 0) {
|
|
|
|
goto out_notify;
|
|
|
|
}
|
|
|
|
len += ret;
|
2010-04-29 14:14:45 +02:00
|
|
|
|
2010-07-28 10:40:22 +02:00
|
|
|
if (s->proto_version == V9FS_PROTO_2000L) {
|
|
|
|
id = P9_RLERROR;
|
|
|
|
}
|
2011-10-24 11:39:49 +02:00
|
|
|
trace_v9fs_rerror(pdu->tag, pdu->id, err); /* Trace ERROR */
|
2010-04-29 14:14:45 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/* fill out the header */
|
2017-06-29 15:11:51 +02:00
|
|
|
if (pdu_marshal(pdu, 0, "dbw", (int32_t)len, id, pdu->tag) < 0) {
|
|
|
|
goto out_notify;
|
|
|
|
}
|
2010-04-29 14:14:45 +02:00
|
|
|
|
|
|
|
/* keep these in sync */
|
|
|
|
pdu->size = len;
|
|
|
|
pdu->id = id;
|
|
|
|
|
2017-06-29 15:11:51 +02:00
|
|
|
out_notify:
|
2017-05-25 10:30:13 +02:00
|
|
|
pdu->s->transport->push_and_notify(pdu);
|
2010-04-29 14:14:45 +02:00
|
|
|
|
2011-08-02 08:06:17 +02:00
|
|
|
/* Now wakeup anybody waiting in flush for this request */
|
2016-10-17 14:13:58 +02:00
|
|
|
if (!qemu_co_queue_next(&pdu->complete)) {
|
|
|
|
pdu_free(pdu);
|
|
|
|
}
|
2010-04-29 14:14:45 +02:00
|
|
|
}
|
|
|
|
|
2010-04-29 14:14:49 +02:00
|
|
|
static mode_t v9mode_to_mode(uint32_t mode, V9fsString *extension)
|
|
|
|
{
|
|
|
|
mode_t ret;
|
|
|
|
|
|
|
|
ret = mode & 0777;
|
|
|
|
if (mode & P9_STAT_MODE_DIR) {
|
|
|
|
ret |= S_IFDIR;
|
|
|
|
}
|
|
|
|
|
2010-07-28 10:25:05 +02:00
|
|
|
if (mode & P9_STAT_MODE_SYMLINK) {
|
|
|
|
ret |= S_IFLNK;
|
|
|
|
}
|
|
|
|
if (mode & P9_STAT_MODE_SOCKET) {
|
|
|
|
ret |= S_IFSOCK;
|
|
|
|
}
|
|
|
|
if (mode & P9_STAT_MODE_NAMED_PIPE) {
|
|
|
|
ret |= S_IFIFO;
|
|
|
|
}
|
|
|
|
if (mode & P9_STAT_MODE_DEVICE) {
|
2013-05-20 07:59:52 +02:00
|
|
|
if (extension->size && extension->data[0] == 'c') {
|
2010-07-28 10:25:05 +02:00
|
|
|
ret |= S_IFCHR;
|
|
|
|
} else {
|
|
|
|
ret |= S_IFBLK;
|
2010-04-29 14:14:49 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-10-30 05:35:13 +01:00
|
|
|
if (!(ret & ~0777)) {
|
2010-04-29 14:14:49 +02:00
|
|
|
ret |= S_IFREG;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (mode & P9_STAT_MODE_SETUID) {
|
|
|
|
ret |= S_ISUID;
|
|
|
|
}
|
|
|
|
if (mode & P9_STAT_MODE_SETGID) {
|
|
|
|
ret |= S_ISGID;
|
|
|
|
}
|
|
|
|
if (mode & P9_STAT_MODE_SETVTX) {
|
|
|
|
ret |= S_ISVTX;
|
|
|
|
}
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int donttouch_stat(V9fsStat *stat)
|
|
|
|
{
|
|
|
|
if (stat->type == -1 &&
|
|
|
|
stat->dev == -1 &&
|
2019-10-10 11:36:04 +02:00
|
|
|
stat->qid.type == 0xff &&
|
|
|
|
stat->qid.version == (uint32_t) -1 &&
|
|
|
|
stat->qid.path == (uint64_t) -1 &&
|
2010-04-29 14:14:49 +02:00
|
|
|
stat->mode == -1 &&
|
|
|
|
stat->atime == -1 &&
|
|
|
|
stat->mtime == -1 &&
|
|
|
|
stat->length == -1 &&
|
|
|
|
!stat->name.size &&
|
|
|
|
!stat->uid.size &&
|
|
|
|
!stat->gid.size &&
|
|
|
|
!stat->muid.size &&
|
|
|
|
stat->n_uid == -1 &&
|
|
|
|
stat->n_gid == -1 &&
|
|
|
|
stat->n_muid == -1) {
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2011-12-14 09:19:13 +01:00
|
|
|
static void v9fs_stat_init(V9fsStat *stat)
|
|
|
|
{
|
|
|
|
v9fs_string_init(&stat->name);
|
|
|
|
v9fs_string_init(&stat->uid);
|
|
|
|
v9fs_string_init(&stat->gid);
|
|
|
|
v9fs_string_init(&stat->muid);
|
|
|
|
v9fs_string_init(&stat->extension);
|
|
|
|
}
|
|
|
|
|
2010-04-29 14:14:49 +02:00
|
|
|
static void v9fs_stat_free(V9fsStat *stat)
|
|
|
|
{
|
|
|
|
v9fs_string_free(&stat->name);
|
|
|
|
v9fs_string_free(&stat->uid);
|
|
|
|
v9fs_string_free(&stat->gid);
|
|
|
|
v9fs_string_free(&stat->muid);
|
|
|
|
v9fs_string_free(&stat->extension);
|
|
|
|
}
|
|
|
|
|
|
|
|
static uint32_t stat_to_v9mode(const struct stat *stbuf)
|
|
|
|
{
|
|
|
|
uint32_t mode;
|
|
|
|
|
|
|
|
mode = stbuf->st_mode & 0777;
|
|
|
|
if (S_ISDIR(stbuf->st_mode)) {
|
|
|
|
mode |= P9_STAT_MODE_DIR;
|
|
|
|
}
|
|
|
|
|
2010-07-28 10:25:05 +02:00
|
|
|
if (S_ISLNK(stbuf->st_mode)) {
|
|
|
|
mode |= P9_STAT_MODE_SYMLINK;
|
|
|
|
}
|
2010-04-29 14:14:49 +02:00
|
|
|
|
2010-07-28 10:25:05 +02:00
|
|
|
if (S_ISSOCK(stbuf->st_mode)) {
|
|
|
|
mode |= P9_STAT_MODE_SOCKET;
|
|
|
|
}
|
2010-04-29 14:14:49 +02:00
|
|
|
|
2010-07-28 10:25:05 +02:00
|
|
|
if (S_ISFIFO(stbuf->st_mode)) {
|
|
|
|
mode |= P9_STAT_MODE_NAMED_PIPE;
|
|
|
|
}
|
2010-04-29 14:14:49 +02:00
|
|
|
|
2010-07-28 10:25:05 +02:00
|
|
|
if (S_ISBLK(stbuf->st_mode) || S_ISCHR(stbuf->st_mode)) {
|
|
|
|
mode |= P9_STAT_MODE_DEVICE;
|
|
|
|
}
|
2010-04-29 14:14:49 +02:00
|
|
|
|
2010-07-28 10:25:05 +02:00
|
|
|
if (stbuf->st_mode & S_ISUID) {
|
|
|
|
mode |= P9_STAT_MODE_SETUID;
|
|
|
|
}
|
2010-04-29 14:14:49 +02:00
|
|
|
|
2010-07-28 10:25:05 +02:00
|
|
|
if (stbuf->st_mode & S_ISGID) {
|
|
|
|
mode |= P9_STAT_MODE_SETGID;
|
|
|
|
}
|
2010-04-29 14:14:49 +02:00
|
|
|
|
2010-07-28 10:25:05 +02:00
|
|
|
if (stbuf->st_mode & S_ISVTX) {
|
|
|
|
mode |= P9_STAT_MODE_SETVTX;
|
2010-04-29 14:14:49 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
return mode;
|
|
|
|
}
|
|
|
|
|
2017-09-20 08:48:51 +02:00
|
|
|
static int coroutine_fn stat_to_v9stat(V9fsPDU *pdu, V9fsPath *path,
|
|
|
|
const char *basename,
|
2016-10-17 14:13:58 +02:00
|
|
|
const struct stat *stbuf,
|
|
|
|
V9fsStat *v9stat)
|
2010-04-29 14:14:49 +02:00
|
|
|
{
|
|
|
|
int err;
|
|
|
|
|
|
|
|
memset(v9stat, 0, sizeof(*v9stat));
|
|
|
|
|
2019-10-10 11:36:05 +02:00
|
|
|
err = stat_to_qid(pdu, stbuf, &v9stat->qid);
|
|
|
|
if (err < 0) {
|
|
|
|
return err;
|
|
|
|
}
|
2010-04-29 14:14:49 +02:00
|
|
|
v9stat->mode = stat_to_v9mode(stbuf);
|
|
|
|
v9stat->atime = stbuf->st_atime;
|
|
|
|
v9stat->mtime = stbuf->st_mtime;
|
|
|
|
v9stat->length = stbuf->st_size;
|
|
|
|
|
2016-09-16 08:56:15 +02:00
|
|
|
v9fs_string_free(&v9stat->uid);
|
|
|
|
v9fs_string_free(&v9stat->gid);
|
|
|
|
v9fs_string_free(&v9stat->muid);
|
2010-04-29 14:14:49 +02:00
|
|
|
|
2010-07-28 10:25:05 +02:00
|
|
|
v9stat->n_uid = stbuf->st_uid;
|
|
|
|
v9stat->n_gid = stbuf->st_gid;
|
|
|
|
v9stat->n_muid = 0;
|
2010-04-29 14:14:49 +02:00
|
|
|
|
2016-09-16 08:56:15 +02:00
|
|
|
v9fs_string_free(&v9stat->extension);
|
2010-04-29 14:14:49 +02:00
|
|
|
|
2010-07-28 10:25:05 +02:00
|
|
|
if (v9stat->mode & P9_STAT_MODE_SYMLINK) {
|
2017-09-20 08:48:51 +02:00
|
|
|
err = v9fs_co_readlink(pdu, path, &v9stat->extension);
|
2011-08-08 20:06:41 +02:00
|
|
|
if (err < 0) {
|
2010-07-28 10:25:05 +02:00
|
|
|
return err;
|
2010-04-29 14:14:49 +02:00
|
|
|
}
|
2010-07-28 10:25:05 +02:00
|
|
|
} else if (v9stat->mode & P9_STAT_MODE_DEVICE) {
|
|
|
|
v9fs_string_sprintf(&v9stat->extension, "%c %u %u",
|
|
|
|
S_ISCHR(stbuf->st_mode) ? 'c' : 'b',
|
|
|
|
major(stbuf->st_rdev), minor(stbuf->st_rdev));
|
|
|
|
} else if (S_ISDIR(stbuf->st_mode) || S_ISREG(stbuf->st_mode)) {
|
2010-09-27 18:45:47 +02:00
|
|
|
v9fs_string_sprintf(&v9stat->extension, "%s %lu",
|
|
|
|
"HARDLINKCOUNT", (unsigned long)stbuf->st_nlink);
|
2010-04-29 14:14:49 +02:00
|
|
|
}
|
|
|
|
|
2017-09-20 08:48:51 +02:00
|
|
|
v9fs_string_sprintf(&v9stat->name, "%s", basename);
|
2010-04-29 14:14:49 +02:00
|
|
|
|
|
|
|
v9stat->size = 61 +
|
|
|
|
v9fs_string_size(&v9stat->name) +
|
|
|
|
v9fs_string_size(&v9stat->uid) +
|
|
|
|
v9fs_string_size(&v9stat->gid) +
|
|
|
|
v9fs_string_size(&v9stat->muid) +
|
|
|
|
v9fs_string_size(&v9stat->extension);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
virtio-9p: getattr server 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: M. Mohan Kumar <mohan@in.ibm.com>
Signed-off-by: Sripathi Kodi <sripathik@in.ibm.com>
2010-07-20 08:14:41 +02:00
|
|
|
#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 /* Mask for fields up to BLOCKS */
|
|
|
|
#define P9_STATS_ALL 0x00003fffULL /* Mask for All fields above */
|
|
|
|
|
|
|
|
|
2021-09-27 17:45:00 +02:00
|
|
|
/**
|
|
|
|
* Convert host filesystem's block size into an appropriate block size for
|
|
|
|
* 9p client (guest OS side). The value returned suggests an "optimum" block
|
|
|
|
* size for 9p I/O, i.e. to maximize performance.
|
|
|
|
*
|
|
|
|
* @pdu: 9p client request
|
|
|
|
* @blksize: host filesystem's block size
|
|
|
|
*/
|
|
|
|
static int32_t blksize_to_iounit(const V9fsPDU *pdu, int32_t blksize)
|
2021-09-22 15:13:31 +02:00
|
|
|
{
|
|
|
|
int32_t iounit = 0;
|
|
|
|
V9fsState *s = pdu->s;
|
|
|
|
|
|
|
|
/*
|
2021-09-27 17:45:00 +02:00
|
|
|
* iounit should be multiples of blksize (host filesystem block size)
|
2021-09-22 15:13:31 +02:00
|
|
|
* as well as less than (client msize - P9_IOHDRSZ)
|
|
|
|
*/
|
2021-09-27 17:45:00 +02:00
|
|
|
if (blksize) {
|
2021-09-27 17:50:36 +02:00
|
|
|
iounit = QEMU_ALIGN_DOWN(s->msize - P9_IOHDRSZ, blksize);
|
2021-09-22 15:13:31 +02:00
|
|
|
}
|
|
|
|
if (!iounit) {
|
|
|
|
iounit = s->msize - P9_IOHDRSZ;
|
|
|
|
}
|
|
|
|
return iounit;
|
|
|
|
}
|
|
|
|
|
2021-09-27 17:45:00 +02:00
|
|
|
static int32_t stat_to_iounit(const V9fsPDU *pdu, const struct stat *stbuf)
|
|
|
|
{
|
|
|
|
return blksize_to_iounit(pdu, stbuf->st_blksize);
|
|
|
|
}
|
|
|
|
|
2019-10-10 11:36:05 +02:00
|
|
|
static int stat_to_v9stat_dotl(V9fsPDU *pdu, const struct stat *stbuf,
|
2011-05-19 01:04:33 +02:00
|
|
|
V9fsStatDotl *v9lstat)
|
virtio-9p: getattr server 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: M. Mohan Kumar <mohan@in.ibm.com>
Signed-off-by: Sripathi Kodi <sripathik@in.ibm.com>
2010-07-20 08:14:41 +02:00
|
|
|
{
|
|
|
|
memset(v9lstat, 0, sizeof(*v9lstat));
|
|
|
|
|
|
|
|
v9lstat->st_mode = stbuf->st_mode;
|
|
|
|
v9lstat->st_nlink = stbuf->st_nlink;
|
|
|
|
v9lstat->st_uid = stbuf->st_uid;
|
|
|
|
v9lstat->st_gid = stbuf->st_gid;
|
|
|
|
v9lstat->st_rdev = stbuf->st_rdev;
|
|
|
|
v9lstat->st_size = stbuf->st_size;
|
2021-09-22 15:13:31 +02:00
|
|
|
v9lstat->st_blksize = stat_to_iounit(pdu, stbuf);
|
virtio-9p: getattr server 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: M. Mohan Kumar <mohan@in.ibm.com>
Signed-off-by: Sripathi Kodi <sripathik@in.ibm.com>
2010-07-20 08:14:41 +02:00
|
|
|
v9lstat->st_blocks = stbuf->st_blocks;
|
|
|
|
v9lstat->st_atime_sec = stbuf->st_atime;
|
|
|
|
v9lstat->st_atime_nsec = stbuf->st_atim.tv_nsec;
|
|
|
|
v9lstat->st_mtime_sec = stbuf->st_mtime;
|
|
|
|
v9lstat->st_mtime_nsec = stbuf->st_mtim.tv_nsec;
|
|
|
|
v9lstat->st_ctime_sec = stbuf->st_ctime;
|
|
|
|
v9lstat->st_ctime_nsec = stbuf->st_ctim.tv_nsec;
|
|
|
|
/* Currently we only support BASIC fields in stat */
|
|
|
|
v9lstat->st_result_mask = P9_STATS_BASIC;
|
|
|
|
|
2019-10-10 11:36:05 +02:00
|
|
|
return stat_to_qid(pdu, stbuf, &v9lstat->qid);
|
virtio-9p: getattr server 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: M. Mohan Kumar <mohan@in.ibm.com>
Signed-off-by: Sripathi Kodi <sripathik@in.ibm.com>
2010-07-20 08:14:41 +02:00
|
|
|
}
|
|
|
|
|
2010-04-29 14:14:50 +02:00
|
|
|
static void print_sg(struct iovec *sg, int cnt)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
|
|
|
printf("sg[%d]: {", cnt);
|
|
|
|
for (i = 0; i < cnt; i++) {
|
|
|
|
if (i) {
|
|
|
|
printf(", ");
|
|
|
|
}
|
|
|
|
printf("(%p, %zd)", sg[i].iov_base, sg[i].iov_len);
|
|
|
|
}
|
|
|
|
printf("}\n");
|
|
|
|
}
|
|
|
|
|
2011-09-09 11:44:18 +02:00
|
|
|
/* Will call this only for path name based fid */
|
|
|
|
static void v9fs_fix_path(V9fsPath *dst, V9fsPath *src, int len)
|
2010-04-29 14:15:00 +02:00
|
|
|
{
|
2011-09-09 11:44:18 +02:00
|
|
|
V9fsPath str;
|
|
|
|
v9fs_path_init(&str);
|
|
|
|
v9fs_path_copy(&str, dst);
|
2016-09-16 08:56:15 +02:00
|
|
|
v9fs_path_sprintf(dst, "%s%s", src->data, str.data + len);
|
2011-09-09 11:44:18 +02:00
|
|
|
v9fs_path_free(&str);
|
2010-04-29 14:15:00 +02:00
|
|
|
}
|
|
|
|
|
2011-10-25 08:40:39 +02:00
|
|
|
static inline bool is_ro_export(FsContext *ctx)
|
|
|
|
{
|
|
|
|
return ctx->export_flags & V9FS_RDONLY;
|
|
|
|
}
|
|
|
|
|
2016-10-17 14:13:58 +02:00
|
|
|
static void coroutine_fn v9fs_version(void *opaque)
|
2010-04-29 14:14:44 +02:00
|
|
|
{
|
2011-12-14 09:19:13 +01:00
|
|
|
ssize_t err;
|
2011-05-18 23:18:05 +02:00
|
|
|
V9fsPDU *pdu = opaque;
|
|
|
|
V9fsState *s = pdu->s;
|
2010-04-29 14:14:51 +02:00
|
|
|
V9fsString version;
|
|
|
|
size_t offset = 7;
|
|
|
|
|
2011-12-14 09:19:13 +01:00
|
|
|
v9fs_string_init(&version);
|
|
|
|
err = pdu_unmarshal(pdu, offset, "ds", &s->msize, &version);
|
|
|
|
if (err < 0) {
|
|
|
|
goto out;
|
|
|
|
}
|
2011-10-12 15:41:25 +02:00
|
|
|
trace_v9fs_version(pdu->tag, pdu->id, s->msize, version.data);
|
2010-04-29 14:14:51 +02:00
|
|
|
|
2011-12-04 18:05:28 +01:00
|
|
|
virtfs_reset(pdu);
|
|
|
|
|
2010-05-27 10:27:29 +02:00
|
|
|
if (!strcmp(version.data, "9P2000.u")) {
|
|
|
|
s->proto_version = V9FS_PROTO_2000U;
|
|
|
|
} else if (!strcmp(version.data, "9P2000.L")) {
|
|
|
|
s->proto_version = V9FS_PROTO_2000L;
|
|
|
|
} else {
|
2010-04-29 14:14:51 +02:00
|
|
|
v9fs_string_sprintf(&version, "unknown");
|
2020-02-08 09:24:19 +01:00
|
|
|
/* skip min. msize check, reporting invalid version has priority */
|
|
|
|
goto marshal;
|
2010-04-29 14:14:44 +02:00
|
|
|
}
|
2010-04-29 14:14:51 +02:00
|
|
|
|
2020-02-08 09:24:19 +01:00
|
|
|
if (s->msize < P9_MIN_MSIZE) {
|
|
|
|
err = -EMSGSIZE;
|
|
|
|
error_report(
|
|
|
|
"9pfs: Client requested msize < minimum msize ("
|
|
|
|
stringify(P9_MIN_MSIZE) ") supported by this server."
|
|
|
|
);
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
2020-09-03 16:20:21 +02:00
|
|
|
/* 8192 is the default msize of Linux clients */
|
2020-09-06 18:50:32 +02:00
|
|
|
if (s->msize <= 8192 && !(s->ctx.export_flags & V9FS_NO_PERF_WARN)) {
|
2020-09-03 16:20:21 +02:00
|
|
|
warn_report_once(
|
|
|
|
"9p: degraded performance: a reasonable high msize should be "
|
|
|
|
"chosen on client/guest side (chosen msize is <= 8192). See "
|
|
|
|
"https://wiki.qemu.org/Documentation/9psetup#msize for details."
|
|
|
|
);
|
|
|
|
}
|
|
|
|
|
2020-02-08 09:24:19 +01:00
|
|
|
marshal:
|
2011-12-14 09:19:13 +01:00
|
|
|
err = pdu_marshal(pdu, offset, "ds", s->msize, &version);
|
|
|
|
if (err < 0) {
|
|
|
|
goto out;
|
|
|
|
}
|
2017-08-09 16:32:46 +02:00
|
|
|
err += offset;
|
2011-10-12 15:41:25 +02:00
|
|
|
trace_v9fs_version_return(pdu->tag, pdu->id, s->msize, version.data);
|
2011-12-14 09:19:13 +01:00
|
|
|
out:
|
2017-08-09 16:32:46 +02:00
|
|
|
pdu_complete(pdu, err);
|
2010-04-29 14:14:51 +02:00
|
|
|
v9fs_string_free(&version);
|
2010-04-29 14:14:44 +02:00
|
|
|
}
|
|
|
|
|
2016-10-17 14:13:58 +02:00
|
|
|
static void coroutine_fn v9fs_attach(void *opaque)
|
2010-04-29 14:14:44 +02:00
|
|
|
{
|
2011-05-18 23:18:05 +02:00
|
|
|
V9fsPDU *pdu = opaque;
|
|
|
|
V9fsState *s = pdu->s;
|
2010-04-29 14:14:52 +02:00
|
|
|
int32_t fid, afid, n_uname;
|
|
|
|
V9fsString uname, aname;
|
|
|
|
V9fsFidState *fidp;
|
|
|
|
size_t offset = 7;
|
2011-05-08 09:45:29 +02:00
|
|
|
V9fsQID qid;
|
2010-04-29 14:14:52 +02:00
|
|
|
ssize_t err;
|
2021-06-04 19:52:18 +02:00
|
|
|
struct stat stbuf;
|
2010-04-29 14:14:52 +02:00
|
|
|
|
2011-12-14 09:19:13 +01:00
|
|
|
v9fs_string_init(&uname);
|
|
|
|
v9fs_string_init(&aname);
|
|
|
|
err = pdu_unmarshal(pdu, offset, "ddssd", &fid,
|
|
|
|
&afid, &uname, &aname, &n_uname);
|
|
|
|
if (err < 0) {
|
|
|
|
goto out_nofid;
|
|
|
|
}
|
2011-10-12 15:41:25 +02:00
|
|
|
trace_v9fs_attach(pdu->tag, pdu->id, fid, afid, uname.data, aname.data);
|
2010-04-29 14:14:52 +02:00
|
|
|
|
|
|
|
fidp = alloc_fid(s, fid);
|
|
|
|
if (fidp == NULL) {
|
|
|
|
err = -EINVAL;
|
2011-05-18 14:08:07 +02:00
|
|
|
goto out_nofid;
|
2010-04-29 14:14:44 +02:00
|
|
|
}
|
2010-04-29 14:14:52 +02:00
|
|
|
fidp->uid = n_uname;
|
2011-08-02 08:06:17 +02:00
|
|
|
err = v9fs_co_name_to_path(pdu, NULL, "/", &fidp->path);
|
2011-09-09 11:44:18 +02:00
|
|
|
if (err < 0) {
|
|
|
|
err = -EINVAL;
|
|
|
|
clunk_fid(s, fid);
|
|
|
|
goto out;
|
|
|
|
}
|
2021-06-04 19:52:18 +02:00
|
|
|
err = v9fs_co_lstat(pdu, &fidp->path, &stbuf);
|
|
|
|
if (err < 0) {
|
|
|
|
err = -EINVAL;
|
|
|
|
clunk_fid(s, fid);
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
err = stat_to_qid(pdu, &stbuf, &qid);
|
2011-05-08 09:45:29 +02:00
|
|
|
if (err < 0) {
|
2010-04-29 14:14:52 +02:00
|
|
|
err = -EINVAL;
|
2011-05-18 14:08:07 +02:00
|
|
|
clunk_fid(s, fid);
|
2010-04-29 14:14:52 +02:00
|
|
|
goto out;
|
|
|
|
}
|
2017-01-16 12:31:53 +01:00
|
|
|
|
2012-07-31 09:23:18 +02:00
|
|
|
/*
|
|
|
|
* disable migration if we haven't done already.
|
|
|
|
* attach could get called multiple times for the same export.
|
|
|
|
*/
|
|
|
|
if (!s->migration_blocker) {
|
2014-03-22 00:42:26 +01:00
|
|
|
error_setg(&s->migration_blocker,
|
|
|
|
"Migration is disabled when VirtFS export path '%s' is mounted in the guest using mount_tag '%s'",
|
|
|
|
s->ctx.fs_root ? s->ctx.fs_root : "NULL", s->tag);
|
2020-06-30 11:03:28 +02:00
|
|
|
err = migrate_add_blocker(s->migration_blocker, NULL);
|
|
|
|
if (err < 0) {
|
2017-01-16 12:31:53 +01:00
|
|
|
error_free(s->migration_blocker);
|
|
|
|
s->migration_blocker = NULL;
|
|
|
|
clunk_fid(s, fid);
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
s->root_fid = fid;
|
|
|
|
}
|
|
|
|
|
|
|
|
err = pdu_marshal(pdu, offset, "Q", &qid);
|
|
|
|
if (err < 0) {
|
|
|
|
clunk_fid(s, fid);
|
|
|
|
goto out;
|
2012-07-31 09:23:18 +02:00
|
|
|
}
|
2017-01-16 12:31:53 +01:00
|
|
|
err += offset;
|
|
|
|
|
2021-06-04 19:52:18 +02:00
|
|
|
memcpy(&s->root_st, &stbuf, sizeof(stbuf));
|
2017-01-16 12:31:53 +01:00
|
|
|
trace_v9fs_attach_return(pdu->tag, pdu->id,
|
|
|
|
qid.type, qid.version, qid.path);
|
2010-04-29 14:14:52 +02:00
|
|
|
out:
|
2011-08-02 08:06:17 +02:00
|
|
|
put_fid(pdu, fidp);
|
2011-05-18 14:08:07 +02:00
|
|
|
out_nofid:
|
2015-12-02 16:00:14 +01:00
|
|
|
pdu_complete(pdu, err);
|
2010-04-29 14:14:52 +02:00
|
|
|
v9fs_string_free(&uname);
|
|
|
|
v9fs_string_free(&aname);
|
2010-04-29 14:14:44 +02:00
|
|
|
}
|
|
|
|
|
2016-10-17 14:13:58 +02:00
|
|
|
static void coroutine_fn v9fs_stat(void *opaque)
|
2010-04-29 14:14:44 +02:00
|
|
|
{
|
2010-04-29 14:14:53 +02:00
|
|
|
int32_t fid;
|
2011-05-07 14:59:24 +02:00
|
|
|
V9fsStat v9stat;
|
2010-04-29 14:14:53 +02:00
|
|
|
ssize_t err = 0;
|
2011-05-07 14:59:24 +02:00
|
|
|
size_t offset = 7;
|
|
|
|
struct stat stbuf;
|
|
|
|
V9fsFidState *fidp;
|
|
|
|
V9fsPDU *pdu = opaque;
|
2017-09-20 08:48:51 +02:00
|
|
|
char *basename;
|
2010-04-29 14:14:53 +02:00
|
|
|
|
2011-12-14 09:19:13 +01:00
|
|
|
err = pdu_unmarshal(pdu, offset, "d", &fid);
|
|
|
|
if (err < 0) {
|
|
|
|
goto out_nofid;
|
|
|
|
}
|
2011-10-12 15:41:25 +02:00
|
|
|
trace_v9fs_stat(pdu->tag, pdu->id, fid);
|
2011-05-18 14:08:07 +02:00
|
|
|
|
2011-08-02 08:06:17 +02:00
|
|
|
fidp = get_fid(pdu, fid);
|
2011-05-07 14:59:24 +02:00
|
|
|
if (fidp == NULL) {
|
2010-04-29 14:14:53 +02:00
|
|
|
err = -ENOENT;
|
2011-05-18 14:08:07 +02:00
|
|
|
goto out_nofid;
|
2010-04-29 14:14:44 +02:00
|
|
|
}
|
2011-08-02 08:06:17 +02:00
|
|
|
err = v9fs_co_lstat(pdu, &fidp->path, &stbuf);
|
2011-05-07 14:59:24 +02:00
|
|
|
if (err < 0) {
|
|
|
|
goto out;
|
|
|
|
}
|
2017-09-20 08:48:51 +02:00
|
|
|
basename = g_path_get_basename(fidp->path.data);
|
|
|
|
err = stat_to_v9stat(pdu, &fidp->path, basename, &stbuf, &v9stat);
|
|
|
|
g_free(basename);
|
2011-05-07 14:59:24 +02:00
|
|
|
if (err < 0) {
|
|
|
|
goto out;
|
|
|
|
}
|
2011-12-14 09:19:13 +01:00
|
|
|
err = pdu_marshal(pdu, offset, "wS", 0, &v9stat);
|
|
|
|
if (err < 0) {
|
|
|
|
v9fs_stat_free(&v9stat);
|
|
|
|
goto out;
|
|
|
|
}
|
2011-10-24 11:39:49 +02:00
|
|
|
trace_v9fs_stat_return(pdu->tag, pdu->id, v9stat.mode,
|
|
|
|
v9stat.atime, v9stat.mtime, v9stat.length);
|
2011-12-14 09:19:13 +01:00
|
|
|
err += offset;
|
2011-05-07 14:59:24 +02:00
|
|
|
v9fs_stat_free(&v9stat);
|
2010-04-29 14:14:53 +02:00
|
|
|
out:
|
2011-08-02 08:06:17 +02:00
|
|
|
put_fid(pdu, fidp);
|
2011-05-18 14:08:07 +02:00
|
|
|
out_nofid:
|
2015-12-02 16:00:14 +01:00
|
|
|
pdu_complete(pdu, err);
|
2010-04-29 14:14:44 +02:00
|
|
|
}
|
|
|
|
|
2016-10-17 14:13:58 +02:00
|
|
|
static void coroutine_fn v9fs_getattr(void *opaque)
|
virtio-9p: getattr server 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: M. Mohan Kumar <mohan@in.ibm.com>
Signed-off-by: Sripathi Kodi <sripathik@in.ibm.com>
2010-07-20 08:14:41 +02:00
|
|
|
{
|
|
|
|
int32_t fid;
|
2011-05-19 01:04:33 +02:00
|
|
|
size_t offset = 7;
|
|
|
|
ssize_t retval = 0;
|
|
|
|
struct stat stbuf;
|
virtio-9p: getattr server 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: M. Mohan Kumar <mohan@in.ibm.com>
Signed-off-by: Sripathi Kodi <sripathik@in.ibm.com>
2010-07-20 08:14:41 +02:00
|
|
|
V9fsFidState *fidp;
|
|
|
|
uint64_t request_mask;
|
2011-05-19 01:04:33 +02:00
|
|
|
V9fsStatDotl v9stat_dotl;
|
|
|
|
V9fsPDU *pdu = opaque;
|
virtio-9p: getattr server 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: M. Mohan Kumar <mohan@in.ibm.com>
Signed-off-by: Sripathi Kodi <sripathik@in.ibm.com>
2010-07-20 08:14:41 +02:00
|
|
|
|
2011-12-14 09:19:13 +01:00
|
|
|
retval = pdu_unmarshal(pdu, offset, "dq", &fid, &request_mask);
|
|
|
|
if (retval < 0) {
|
|
|
|
goto out_nofid;
|
|
|
|
}
|
2011-10-12 15:41:25 +02:00
|
|
|
trace_v9fs_getattr(pdu->tag, pdu->id, fid, request_mask);
|
virtio-9p: getattr server 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: M. Mohan Kumar <mohan@in.ibm.com>
Signed-off-by: Sripathi Kodi <sripathik@in.ibm.com>
2010-07-20 08:14:41 +02:00
|
|
|
|
2011-08-02 08:06:17 +02:00
|
|
|
fidp = get_fid(pdu, fid);
|
virtio-9p: getattr server 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: M. Mohan Kumar <mohan@in.ibm.com>
Signed-off-by: Sripathi Kodi <sripathik@in.ibm.com>
2010-07-20 08:14:41 +02:00
|
|
|
if (fidp == NULL) {
|
2011-05-19 01:04:33 +02:00
|
|
|
retval = -ENOENT;
|
2011-05-18 14:08:07 +02:00
|
|
|
goto out_nofid;
|
virtio-9p: getattr server 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: M. Mohan Kumar <mohan@in.ibm.com>
Signed-off-by: Sripathi Kodi <sripathik@in.ibm.com>
2010-07-20 08:14:41 +02:00
|
|
|
}
|
2011-05-19 01:04:33 +02:00
|
|
|
/*
|
|
|
|
* Currently we only support BASIC fields in stat, so there is no
|
virtio-9p: getattr server 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: M. Mohan Kumar <mohan@in.ibm.com>
Signed-off-by: Sripathi Kodi <sripathik@in.ibm.com>
2010-07-20 08:14:41 +02:00
|
|
|
* need to look at request_mask.
|
|
|
|
*/
|
2011-08-02 08:06:17 +02:00
|
|
|
retval = v9fs_co_lstat(pdu, &fidp->path, &stbuf);
|
2011-05-19 01:04:33 +02:00
|
|
|
if (retval < 0) {
|
|
|
|
goto out;
|
|
|
|
}
|
2019-10-10 11:36:05 +02:00
|
|
|
retval = stat_to_v9stat_dotl(pdu, &stbuf, &v9stat_dotl);
|
|
|
|
if (retval < 0) {
|
|
|
|
goto out;
|
|
|
|
}
|
2011-10-12 15:41:25 +02:00
|
|
|
|
|
|
|
/* fill st_gen if requested and supported by underlying fs */
|
|
|
|
if (request_mask & P9_STATS_GEN) {
|
|
|
|
retval = v9fs_co_st_gen(pdu, &fidp->path, stbuf.st_mode, &v9stat_dotl);
|
2014-01-28 16:08:27 +01:00
|
|
|
switch (retval) {
|
|
|
|
case 0:
|
|
|
|
/* we have valid st_gen: update result mask */
|
|
|
|
v9stat_dotl.st_result_mask |= P9_STATS_GEN;
|
|
|
|
break;
|
|
|
|
case -EINTR:
|
|
|
|
/* request cancelled, e.g. by Tflush */
|
2011-10-12 15:41:25 +02:00
|
|
|
goto out;
|
2014-01-28 16:08:27 +01:00
|
|
|
default:
|
|
|
|
/* failed to get st_gen: not fatal, ignore */
|
|
|
|
break;
|
2011-10-12 15:41:25 +02:00
|
|
|
}
|
|
|
|
}
|
2011-12-14 09:19:13 +01:00
|
|
|
retval = pdu_marshal(pdu, offset, "A", &v9stat_dotl);
|
|
|
|
if (retval < 0) {
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
retval += offset;
|
2011-10-12 15:41:25 +02:00
|
|
|
trace_v9fs_getattr_return(pdu->tag, pdu->id, v9stat_dotl.st_result_mask,
|
|
|
|
v9stat_dotl.st_mode, v9stat_dotl.st_uid,
|
|
|
|
v9stat_dotl.st_gid);
|
2011-10-24 11:39:49 +02:00
|
|
|
out:
|
|
|
|
put_fid(pdu, fidp);
|
|
|
|
out_nofid:
|
2015-12-02 16:00:14 +01:00
|
|
|
pdu_complete(pdu, retval);
|
virtio-9p: getattr server 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: M. Mohan Kumar <mohan@in.ibm.com>
Signed-off-by: Sripathi Kodi <sripathik@in.ibm.com>
2010-07-20 08:14:41 +02:00
|
|
|
}
|
|
|
|
|
2011-12-21 08:07:23 +01:00
|
|
|
/* Attribute flags */
|
|
|
|
#define P9_ATTR_MODE (1 << 0)
|
|
|
|
#define P9_ATTR_UID (1 << 1)
|
|
|
|
#define P9_ATTR_GID (1 << 2)
|
|
|
|
#define P9_ATTR_SIZE (1 << 3)
|
|
|
|
#define P9_ATTR_ATIME (1 << 4)
|
|
|
|
#define P9_ATTR_MTIME (1 << 5)
|
|
|
|
#define P9_ATTR_CTIME (1 << 6)
|
|
|
|
#define P9_ATTR_ATIME_SET (1 << 7)
|
|
|
|
#define P9_ATTR_MTIME_SET (1 << 8)
|
|
|
|
|
|
|
|
#define P9_ATTR_MASK 127
|
virtio-9p: Implement server 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_CTIME (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.
[jvrao@linux.vnet.ibm.com: Parts of code for handling chown(-1,-1)
Signed-off-by: Sripathi Kodi <sripathik@in.ibm.com>
Signed-off-by: Venkateswararao Jujjuri <jvrao@linux.vnet.ibm.com>
2010-06-17 14:48:47 +02:00
|
|
|
|
2016-10-17 14:13:58 +02:00
|
|
|
static void coroutine_fn v9fs_setattr(void *opaque)
|
virtio-9p: Implement server 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_CTIME (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.
[jvrao@linux.vnet.ibm.com: Parts of code for handling chown(-1,-1)
Signed-off-by: Sripathi Kodi <sripathik@in.ibm.com>
Signed-off-by: Venkateswararao Jujjuri <jvrao@linux.vnet.ibm.com>
2010-06-17 14:48:47 +02:00
|
|
|
{
|
2011-05-19 01:05:10 +02:00
|
|
|
int err = 0;
|
|
|
|
int32_t fid;
|
|
|
|
V9fsFidState *fidp;
|
|
|
|
size_t offset = 7;
|
|
|
|
V9fsIattr v9iattr;
|
|
|
|
V9fsPDU *pdu = opaque;
|
virtio-9p: Implement server 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_CTIME (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.
[jvrao@linux.vnet.ibm.com: Parts of code for handling chown(-1,-1)
Signed-off-by: Sripathi Kodi <sripathik@in.ibm.com>
Signed-off-by: Venkateswararao Jujjuri <jvrao@linux.vnet.ibm.com>
2010-06-17 14:48:47 +02:00
|
|
|
|
2011-12-14 09:19:13 +01:00
|
|
|
err = pdu_unmarshal(pdu, offset, "dI", &fid, &v9iattr);
|
|
|
|
if (err < 0) {
|
|
|
|
goto out_nofid;
|
|
|
|
}
|
virtio-9p: Implement server 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_CTIME (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.
[jvrao@linux.vnet.ibm.com: Parts of code for handling chown(-1,-1)
Signed-off-by: Sripathi Kodi <sripathik@in.ibm.com>
Signed-off-by: Venkateswararao Jujjuri <jvrao@linux.vnet.ibm.com>
2010-06-17 14:48:47 +02:00
|
|
|
|
2018-05-02 08:59:24 +02:00
|
|
|
trace_v9fs_setattr(pdu->tag, pdu->id, fid,
|
|
|
|
v9iattr.valid, v9iattr.mode, v9iattr.uid, v9iattr.gid,
|
|
|
|
v9iattr.size, v9iattr.atime_sec, v9iattr.mtime_sec);
|
|
|
|
|
2011-08-02 08:06:17 +02:00
|
|
|
fidp = get_fid(pdu, fid);
|
2011-05-19 01:05:10 +02:00
|
|
|
if (fidp == NULL) {
|
|
|
|
err = -EINVAL;
|
2011-05-18 14:08:07 +02:00
|
|
|
goto out_nofid;
|
virtio-9p: Implement server 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_CTIME (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.
[jvrao@linux.vnet.ibm.com: Parts of code for handling chown(-1,-1)
Signed-off-by: Sripathi Kodi <sripathik@in.ibm.com>
Signed-off-by: Venkateswararao Jujjuri <jvrao@linux.vnet.ibm.com>
2010-06-17 14:48:47 +02:00
|
|
|
}
|
2011-12-21 08:07:23 +01:00
|
|
|
if (v9iattr.valid & P9_ATTR_MODE) {
|
2011-08-02 08:06:17 +02:00
|
|
|
err = v9fs_co_chmod(pdu, &fidp->path, v9iattr.mode);
|
2011-05-19 01:05:10 +02:00
|
|
|
if (err < 0) {
|
|
|
|
goto out;
|
virtio-9p: Implement server 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_CTIME (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.
[jvrao@linux.vnet.ibm.com: Parts of code for handling chown(-1,-1)
Signed-off-by: Sripathi Kodi <sripathik@in.ibm.com>
Signed-off-by: Venkateswararao Jujjuri <jvrao@linux.vnet.ibm.com>
2010-06-17 14:48:47 +02:00
|
|
|
}
|
|
|
|
}
|
2011-12-21 08:07:23 +01:00
|
|
|
if (v9iattr.valid & (P9_ATTR_ATIME | P9_ATTR_MTIME)) {
|
virtio-9p: Implement server 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_CTIME (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.
[jvrao@linux.vnet.ibm.com: Parts of code for handling chown(-1,-1)
Signed-off-by: Sripathi Kodi <sripathik@in.ibm.com>
Signed-off-by: Venkateswararao Jujjuri <jvrao@linux.vnet.ibm.com>
2010-06-17 14:48:47 +02:00
|
|
|
struct timespec times[2];
|
2011-12-21 08:07:23 +01:00
|
|
|
if (v9iattr.valid & P9_ATTR_ATIME) {
|
|
|
|
if (v9iattr.valid & P9_ATTR_ATIME_SET) {
|
2011-05-19 01:05:10 +02:00
|
|
|
times[0].tv_sec = v9iattr.atime_sec;
|
|
|
|
times[0].tv_nsec = v9iattr.atime_nsec;
|
virtio-9p: Implement server 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_CTIME (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.
[jvrao@linux.vnet.ibm.com: Parts of code for handling chown(-1,-1)
Signed-off-by: Sripathi Kodi <sripathik@in.ibm.com>
Signed-off-by: Venkateswararao Jujjuri <jvrao@linux.vnet.ibm.com>
2010-06-17 14:48:47 +02:00
|
|
|
} else {
|
|
|
|
times[0].tv_nsec = UTIME_NOW;
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
times[0].tv_nsec = UTIME_OMIT;
|
|
|
|
}
|
2011-12-21 08:07:23 +01:00
|
|
|
if (v9iattr.valid & P9_ATTR_MTIME) {
|
|
|
|
if (v9iattr.valid & P9_ATTR_MTIME_SET) {
|
2011-05-19 01:05:10 +02:00
|
|
|
times[1].tv_sec = v9iattr.mtime_sec;
|
|
|
|
times[1].tv_nsec = v9iattr.mtime_nsec;
|
virtio-9p: Implement server 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_CTIME (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.
[jvrao@linux.vnet.ibm.com: Parts of code for handling chown(-1,-1)
Signed-off-by: Sripathi Kodi <sripathik@in.ibm.com>
Signed-off-by: Venkateswararao Jujjuri <jvrao@linux.vnet.ibm.com>
2010-06-17 14:48:47 +02:00
|
|
|
} else {
|
|
|
|
times[1].tv_nsec = UTIME_NOW;
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
times[1].tv_nsec = UTIME_OMIT;
|
|
|
|
}
|
2011-08-02 08:06:17 +02:00
|
|
|
err = v9fs_co_utimensat(pdu, &fidp->path, times);
|
2011-05-19 01:05:10 +02:00
|
|
|
if (err < 0) {
|
|
|
|
goto out;
|
|
|
|
}
|
virtio-9p: Implement server 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_CTIME (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.
[jvrao@linux.vnet.ibm.com: Parts of code for handling chown(-1,-1)
Signed-off-by: Sripathi Kodi <sripathik@in.ibm.com>
Signed-off-by: Venkateswararao Jujjuri <jvrao@linux.vnet.ibm.com>
2010-06-17 14:48:47 +02:00
|
|
|
}
|
2011-05-19 01:05:10 +02:00
|
|
|
/*
|
|
|
|
* If the only valid entry in iattr is ctime we can call
|
|
|
|
* chown(-1,-1) to update the ctime of the file
|
|
|
|
*/
|
2011-12-21 08:07:23 +01:00
|
|
|
if ((v9iattr.valid & (P9_ATTR_UID | P9_ATTR_GID)) ||
|
|
|
|
((v9iattr.valid & P9_ATTR_CTIME)
|
|
|
|
&& !((v9iattr.valid & P9_ATTR_MASK) & ~P9_ATTR_CTIME))) {
|
|
|
|
if (!(v9iattr.valid & P9_ATTR_UID)) {
|
2011-05-19 01:05:10 +02:00
|
|
|
v9iattr.uid = -1;
|
|
|
|
}
|
2011-12-21 08:07:23 +01:00
|
|
|
if (!(v9iattr.valid & P9_ATTR_GID)) {
|
2011-05-19 01:05:10 +02:00
|
|
|
v9iattr.gid = -1;
|
|
|
|
}
|
2011-08-02 08:06:17 +02:00
|
|
|
err = v9fs_co_chown(pdu, &fidp->path, v9iattr.uid,
|
2011-05-19 01:05:10 +02:00
|
|
|
v9iattr.gid);
|
|
|
|
if (err < 0) {
|
|
|
|
goto out;
|
|
|
|
}
|
virtio-9p: Implement server 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_CTIME (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.
[jvrao@linux.vnet.ibm.com: Parts of code for handling chown(-1,-1)
Signed-off-by: Sripathi Kodi <sripathik@in.ibm.com>
Signed-off-by: Venkateswararao Jujjuri <jvrao@linux.vnet.ibm.com>
2010-06-17 14:48:47 +02:00
|
|
|
}
|
2011-12-21 08:07:23 +01:00
|
|
|
if (v9iattr.valid & (P9_ATTR_SIZE)) {
|
2011-08-02 08:06:17 +02:00
|
|
|
err = v9fs_co_truncate(pdu, &fidp->path, v9iattr.size);
|
2011-05-19 01:05:10 +02:00
|
|
|
if (err < 0) {
|
|
|
|
goto out;
|
|
|
|
}
|
virtio-9p: Implement server 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_CTIME (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.
[jvrao@linux.vnet.ibm.com: Parts of code for handling chown(-1,-1)
Signed-off-by: Sripathi Kodi <sripathik@in.ibm.com>
Signed-off-by: Venkateswararao Jujjuri <jvrao@linux.vnet.ibm.com>
2010-06-17 14:48:47 +02:00
|
|
|
}
|
2011-05-19 01:05:10 +02:00
|
|
|
err = offset;
|
2018-05-02 08:59:24 +02:00
|
|
|
trace_v9fs_setattr_return(pdu->tag, pdu->id);
|
virtio-9p: Implement server 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_CTIME (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.
[jvrao@linux.vnet.ibm.com: Parts of code for handling chown(-1,-1)
Signed-off-by: Sripathi Kodi <sripathik@in.ibm.com>
Signed-off-by: Venkateswararao Jujjuri <jvrao@linux.vnet.ibm.com>
2010-06-17 14:48:47 +02:00
|
|
|
out:
|
2011-08-02 08:06:17 +02:00
|
|
|
put_fid(pdu, fidp);
|
2011-05-18 14:08:07 +02:00
|
|
|
out_nofid:
|
2015-12-02 16:00:14 +01:00
|
|
|
pdu_complete(pdu, err);
|
virtio-9p: Implement server 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_CTIME (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.
[jvrao@linux.vnet.ibm.com: Parts of code for handling chown(-1,-1)
Signed-off-by: Sripathi Kodi <sripathik@in.ibm.com>
Signed-off-by: Venkateswararao Jujjuri <jvrao@linux.vnet.ibm.com>
2010-06-17 14:48:47 +02:00
|
|
|
}
|
|
|
|
|
2011-05-07 16:11:55 +02:00
|
|
|
static int v9fs_walk_marshal(V9fsPDU *pdu, uint16_t nwnames, V9fsQID *qids)
|
2010-04-29 14:14:54 +02:00
|
|
|
{
|
|
|
|
int i;
|
2011-12-14 09:19:13 +01:00
|
|
|
ssize_t err;
|
2011-05-07 16:11:55 +02:00
|
|
|
size_t offset = 7;
|
2011-12-14 09:19:13 +01:00
|
|
|
|
|
|
|
err = pdu_marshal(pdu, offset, "w", nwnames);
|
|
|
|
if (err < 0) {
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
offset += err;
|
2011-05-07 16:11:55 +02:00
|
|
|
for (i = 0; i < nwnames; i++) {
|
2011-12-14 09:19:13 +01:00
|
|
|
err = pdu_marshal(pdu, offset, "Q", &qids[i]);
|
|
|
|
if (err < 0) {
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
offset += err;
|
2010-04-29 14:14:54 +02:00
|
|
|
}
|
2011-05-07 16:11:55 +02:00
|
|
|
return offset;
|
2010-04-29 14:14:54 +02:00
|
|
|
}
|
|
|
|
|
2016-08-30 19:11:05 +02:00
|
|
|
static bool name_is_illegal(const char *name)
|
|
|
|
{
|
|
|
|
return !*name || strchr(name, '/') != NULL;
|
|
|
|
}
|
|
|
|
|
2021-06-04 19:57:21 +02:00
|
|
|
static bool same_stat_id(const struct stat *a, const struct stat *b)
|
2016-08-30 17:02:27 +02:00
|
|
|
{
|
2021-06-04 19:57:21 +02:00
|
|
|
return a->st_dev == b->st_dev && a->st_ino == b->st_ino;
|
2016-08-30 17:02:27 +02:00
|
|
|
}
|
|
|
|
|
2016-10-17 14:13:58 +02:00
|
|
|
static void coroutine_fn v9fs_walk(void *opaque)
|
2010-04-29 14:14:44 +02:00
|
|
|
{
|
2011-05-07 16:11:55 +02:00
|
|
|
int name_idx;
|
2021-08-17 15:46:50 +02:00
|
|
|
g_autofree V9fsQID *qids = NULL;
|
2011-05-07 16:11:55 +02:00
|
|
|
int i, err = 0;
|
2021-10-01 16:27:59 +02:00
|
|
|
V9fsPath dpath, path;
|
|
|
|
P9ARRAY_REF(V9fsPath) pathes = NULL;
|
2011-05-07 16:11:55 +02:00
|
|
|
uint16_t nwnames;
|
2021-08-17 15:46:50 +02:00
|
|
|
struct stat stbuf, fidst;
|
|
|
|
g_autofree struct stat *stbufs = NULL;
|
2011-05-07 16:11:55 +02:00
|
|
|
size_t offset = 7;
|
|
|
|
int32_t fid, newfid;
|
2021-10-01 16:27:59 +02:00
|
|
|
P9ARRAY_REF(V9fsString) wnames = NULL;
|
2011-05-07 16:11:55 +02:00
|
|
|
V9fsFidState *fidp;
|
2011-11-29 09:52:38 +01:00
|
|
|
V9fsFidState *newfidp = NULL;
|
2011-05-18 23:18:05 +02:00
|
|
|
V9fsPDU *pdu = opaque;
|
|
|
|
V9fsState *s = pdu->s;
|
2016-08-30 17:02:27 +02:00
|
|
|
V9fsQID qid;
|
2010-04-29 14:14:54 +02:00
|
|
|
|
2011-12-14 09:19:13 +01:00
|
|
|
err = pdu_unmarshal(pdu, offset, "ddw", &fid, &newfid, &nwnames);
|
|
|
|
if (err < 0) {
|
2015-12-02 16:00:14 +01:00
|
|
|
pdu_complete(pdu, err);
|
2011-12-14 09:19:13 +01:00
|
|
|
return ;
|
|
|
|
}
|
|
|
|
offset += err;
|
2010-04-29 14:14:54 +02:00
|
|
|
|
2011-10-12 15:41:25 +02:00
|
|
|
trace_v9fs_walk(pdu->tag, pdu->id, fid, newfid, nwnames);
|
|
|
|
|
2021-05-16 17:55:34 +02:00
|
|
|
if (nwnames > P9_MAXWELEM) {
|
|
|
|
err = -EINVAL;
|
|
|
|
goto out_nofid;
|
|
|
|
}
|
|
|
|
if (nwnames) {
|
2021-10-01 16:27:59 +02:00
|
|
|
P9ARRAY_NEW(V9fsString, wnames, nwnames);
|
2018-12-12 14:18:10 +01:00
|
|
|
qids = g_new0(V9fsQID, nwnames);
|
2021-07-02 17:16:32 +02:00
|
|
|
stbufs = g_new0(struct stat, nwnames);
|
2021-10-01 16:27:59 +02:00
|
|
|
P9ARRAY_NEW(V9fsPath, pathes, nwnames);
|
2011-05-07 16:11:55 +02:00
|
|
|
for (i = 0; i < nwnames; i++) {
|
2011-12-14 09:19:13 +01:00
|
|
|
err = pdu_unmarshal(pdu, offset, "s", &wnames[i]);
|
|
|
|
if (err < 0) {
|
|
|
|
goto out_nofid;
|
|
|
|
}
|
2016-08-30 19:11:05 +02:00
|
|
|
if (name_is_illegal(wnames[i].data)) {
|
|
|
|
err = -ENOENT;
|
|
|
|
goto out_nofid;
|
|
|
|
}
|
2011-12-14 09:19:13 +01:00
|
|
|
offset += err;
|
2010-04-29 14:14:54 +02:00
|
|
|
}
|
|
|
|
}
|
2011-08-02 08:06:17 +02:00
|
|
|
fidp = get_fid(pdu, fid);
|
2011-05-07 16:11:55 +02:00
|
|
|
if (fidp == NULL) {
|
2010-04-29 14:14:54 +02:00
|
|
|
err = -ENOENT;
|
2011-05-18 14:08:07 +02:00
|
|
|
goto out_nofid;
|
2010-04-29 14:14:54 +02:00
|
|
|
}
|
2016-08-30 17:02:27 +02:00
|
|
|
|
2016-09-16 11:44:49 +02:00
|
|
|
v9fs_path_init(&dpath);
|
|
|
|
v9fs_path_init(&path);
|
2021-07-02 17:16:32 +02:00
|
|
|
/*
|
|
|
|
* Both dpath and path initially point to fidp.
|
|
|
|
* Needed to handle request with nwnames == 0
|
|
|
|
*/
|
|
|
|
v9fs_path_copy(&dpath, &fidp->path);
|
|
|
|
v9fs_path_copy(&path, &fidp->path);
|
2016-09-16 11:44:49 +02:00
|
|
|
|
2021-07-02 17:16:32 +02:00
|
|
|
/*
|
|
|
|
* To keep latency (i.e. overall execution time for processing this
|
|
|
|
* Twalk client request) as small as possible, run all the required fs
|
|
|
|
* driver code altogether inside the following block.
|
|
|
|
*/
|
|
|
|
v9fs_co_run_in_worker({
|
|
|
|
if (v9fs_request_cancelled(pdu)) {
|
|
|
|
err = -EINTR;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
err = s->ops->lstat(&s->ctx, &dpath, &fidst);
|
|
|
|
if (err < 0) {
|
|
|
|
err = -errno;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
stbuf = fidst;
|
|
|
|
for (name_idx = 0; name_idx < nwnames; name_idx++) {
|
|
|
|
if (v9fs_request_cancelled(pdu)) {
|
|
|
|
err = -EINTR;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
if (!same_stat_id(&pdu->s->root_st, &stbuf) ||
|
|
|
|
strcmp("..", wnames[name_idx].data))
|
|
|
|
{
|
|
|
|
err = s->ops->name_to_path(&s->ctx, &dpath,
|
2021-08-17 14:38:24 +02:00
|
|
|
wnames[name_idx].data,
|
|
|
|
&pathes[name_idx]);
|
2021-07-02 17:16:32 +02:00
|
|
|
if (err < 0) {
|
|
|
|
err = -errno;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
if (v9fs_request_cancelled(pdu)) {
|
|
|
|
err = -EINTR;
|
|
|
|
break;
|
|
|
|
}
|
2021-08-17 14:38:24 +02:00
|
|
|
err = s->ops->lstat(&s->ctx, &pathes[name_idx], &stbuf);
|
2021-07-02 17:16:32 +02:00
|
|
|
if (err < 0) {
|
|
|
|
err = -errno;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
stbufs[name_idx] = stbuf;
|
2021-08-17 14:38:24 +02:00
|
|
|
v9fs_path_copy(&dpath, &pathes[name_idx]);
|
2021-07-02 17:16:32 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
});
|
|
|
|
/*
|
|
|
|
* Handle all the rest of this Twalk request on main thread ...
|
|
|
|
*/
|
2021-06-04 19:54:57 +02:00
|
|
|
if (err < 0) {
|
|
|
|
goto out;
|
|
|
|
}
|
2021-07-02 17:16:32 +02:00
|
|
|
|
|
|
|
err = stat_to_qid(pdu, &fidst, &qid);
|
2016-08-30 17:02:27 +02:00
|
|
|
if (err < 0) {
|
|
|
|
goto out;
|
|
|
|
}
|
2021-07-02 17:16:32 +02:00
|
|
|
stbuf = fidst;
|
2016-08-30 17:02:27 +02:00
|
|
|
|
2021-07-02 17:16:32 +02:00
|
|
|
/* reset dpath and path */
|
2011-09-09 11:44:18 +02:00
|
|
|
v9fs_path_copy(&dpath, &fidp->path);
|
|
|
|
v9fs_path_copy(&path, &fidp->path);
|
2021-07-02 17:16:32 +02:00
|
|
|
|
2011-09-09 11:44:18 +02:00
|
|
|
for (name_idx = 0; name_idx < nwnames; name_idx++) {
|
2021-06-04 19:57:21 +02:00
|
|
|
if (!same_stat_id(&pdu->s->root_st, &stbuf) ||
|
2021-07-02 17:16:32 +02:00
|
|
|
strcmp("..", wnames[name_idx].data))
|
|
|
|
{
|
|
|
|
stbuf = stbufs[name_idx];
|
2019-10-10 11:36:05 +02:00
|
|
|
err = stat_to_qid(pdu, &stbuf, &qid);
|
|
|
|
if (err < 0) {
|
|
|
|
goto out;
|
|
|
|
}
|
2021-07-02 17:16:32 +02:00
|
|
|
v9fs_path_copy(&path, &pathes[name_idx]);
|
2016-08-30 17:02:27 +02:00
|
|
|
v9fs_path_copy(&dpath, &path);
|
2011-09-09 11:44:18 +02:00
|
|
|
}
|
2016-08-30 17:02:27 +02:00
|
|
|
memcpy(&qids[name_idx], &qid, sizeof(qid));
|
2011-09-09 11:44:18 +02:00
|
|
|
}
|
2010-04-29 14:14:54 +02:00
|
|
|
if (fid == newfid) {
|
2016-11-01 12:00:40 +01:00
|
|
|
if (fidp->fid_type != P9_FID_NONE) {
|
|
|
|
err = -EINVAL;
|
|
|
|
goto out;
|
|
|
|
}
|
2018-11-20 13:00:35 +01:00
|
|
|
v9fs_path_write_lock(s);
|
2011-09-09 11:44:18 +02:00
|
|
|
v9fs_path_copy(&fidp->path, &path);
|
2018-11-20 13:00:35 +01:00
|
|
|
v9fs_path_unlock(s);
|
2010-04-29 14:14:54 +02:00
|
|
|
} else {
|
2011-05-07 16:11:55 +02:00
|
|
|
newfidp = alloc_fid(s, newfid);
|
|
|
|
if (newfidp == NULL) {
|
2010-04-29 14:14:54 +02:00
|
|
|
err = -EINVAL;
|
|
|
|
goto out;
|
|
|
|
}
|
2011-05-07 16:11:55 +02:00
|
|
|
newfidp->uid = fidp->uid;
|
2011-09-09 11:44:18 +02:00
|
|
|
v9fs_path_copy(&newfidp->path, &path);
|
2010-04-29 14:14:44 +02:00
|
|
|
}
|
2011-05-07 16:11:55 +02:00
|
|
|
err = v9fs_walk_marshal(pdu, nwnames, qids);
|
2011-10-24 11:39:49 +02:00
|
|
|
trace_v9fs_walk_return(pdu->tag, pdu->id, nwnames, qids);
|
2010-04-29 14:14:54 +02:00
|
|
|
out:
|
2011-08-02 08:06:17 +02:00
|
|
|
put_fid(pdu, fidp);
|
2011-05-18 14:08:07 +02:00
|
|
|
if (newfidp) {
|
2011-08-02 08:06:17 +02:00
|
|
|
put_fid(pdu, newfidp);
|
2011-05-18 14:08:07 +02:00
|
|
|
}
|
2011-09-09 11:44:18 +02:00
|
|
|
v9fs_path_free(&dpath);
|
|
|
|
v9fs_path_free(&path);
|
2011-05-18 14:08:07 +02:00
|
|
|
out_nofid:
|
2015-12-02 16:00:14 +01:00
|
|
|
pdu_complete(pdu, err);
|
2010-04-29 14:14:44 +02:00
|
|
|
}
|
|
|
|
|
2016-10-17 14:13:58 +02:00
|
|
|
static int32_t coroutine_fn get_iounit(V9fsPDU *pdu, V9fsPath *path)
|
2010-06-09 15:44:28 +02:00
|
|
|
{
|
|
|
|
struct statfs stbuf;
|
2021-09-27 17:45:00 +02:00
|
|
|
int err = v9fs_co_statfs(pdu, path, &stbuf);
|
2010-06-09 15:44:28 +02:00
|
|
|
|
2021-09-27 17:45:00 +02:00
|
|
|
return blksize_to_iounit(pdu, (err >= 0) ? stbuf.f_bsize : 0);
|
2010-06-09 15:44:28 +02:00
|
|
|
}
|
|
|
|
|
2016-10-17 14:13:58 +02:00
|
|
|
static void coroutine_fn v9fs_open(void *opaque)
|
2010-06-09 15:44:28 +02:00
|
|
|
{
|
2011-05-07 14:06:36 +02:00
|
|
|
int flags;
|
|
|
|
int32_t fid;
|
|
|
|
int32_t mode;
|
|
|
|
V9fsQID qid;
|
2011-10-24 11:39:49 +02:00
|
|
|
int iounit = 0;
|
2011-05-07 14:06:36 +02:00
|
|
|
ssize_t err = 0;
|
|
|
|
size_t offset = 7;
|
|
|
|
struct stat stbuf;
|
|
|
|
V9fsFidState *fidp;
|
|
|
|
V9fsPDU *pdu = opaque;
|
|
|
|
V9fsState *s = pdu->s;
|
2010-06-09 15:44:28 +02:00
|
|
|
|
2011-05-07 14:06:36 +02:00
|
|
|
if (s->proto_version == V9FS_PROTO_2000L) {
|
2011-12-14 09:19:13 +01:00
|
|
|
err = pdu_unmarshal(pdu, offset, "dd", &fid, &mode);
|
2011-05-07 14:06:36 +02:00
|
|
|
} else {
|
2012-02-24 01:23:30 +01:00
|
|
|
uint8_t modebyte;
|
|
|
|
err = pdu_unmarshal(pdu, offset, "db", &fid, &modebyte);
|
|
|
|
mode = modebyte;
|
2011-12-14 09:19:13 +01:00
|
|
|
}
|
|
|
|
if (err < 0) {
|
|
|
|
goto out_nofid;
|
2011-05-07 14:06:36 +02:00
|
|
|
}
|
2011-10-12 15:41:25 +02:00
|
|
|
trace_v9fs_open(pdu->tag, pdu->id, fid, mode);
|
|
|
|
|
2011-08-02 08:06:17 +02:00
|
|
|
fidp = get_fid(pdu, fid);
|
2011-05-07 14:06:36 +02:00
|
|
|
if (fidp == NULL) {
|
|
|
|
err = -ENOENT;
|
2011-05-18 14:08:07 +02:00
|
|
|
goto out_nofid;
|
2010-04-29 14:14:55 +02:00
|
|
|
}
|
2016-11-01 12:00:40 +01:00
|
|
|
if (fidp->fid_type != P9_FID_NONE) {
|
|
|
|
err = -EINVAL;
|
|
|
|
goto out;
|
|
|
|
}
|
2010-04-29 14:14:55 +02:00
|
|
|
|
2011-08-02 08:06:17 +02:00
|
|
|
err = v9fs_co_lstat(pdu, &fidp->path, &stbuf);
|
2011-05-07 14:06:36 +02:00
|
|
|
if (err < 0) {
|
2010-04-29 14:14:55 +02:00
|
|
|
goto out;
|
|
|
|
}
|
2019-10-10 11:36:05 +02:00
|
|
|
err = stat_to_qid(pdu, &stbuf, &qid);
|
|
|
|
if (err < 0) {
|
|
|
|
goto out;
|
|
|
|
}
|
2011-05-07 14:06:36 +02:00
|
|
|
if (S_ISDIR(stbuf.st_mode)) {
|
2011-08-02 08:06:17 +02:00
|
|
|
err = v9fs_co_opendir(pdu, fidp);
|
2011-05-07 14:06:36 +02:00
|
|
|
if (err < 0) {
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
fidp->fid_type = P9_FID_DIR;
|
2011-12-14 09:19:13 +01:00
|
|
|
err = pdu_marshal(pdu, offset, "Qd", &qid, 0);
|
|
|
|
if (err < 0) {
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
err += offset;
|
2010-04-29 14:14:55 +02:00
|
|
|
} else {
|
2010-06-22 16:17:04 +02:00
|
|
|
if (s->proto_version == V9FS_PROTO_2000L) {
|
2011-10-12 15:41:23 +02:00
|
|
|
flags = get_dotl_openflags(s, mode);
|
2010-06-22 16:17:04 +02:00
|
|
|
} else {
|
2011-05-07 14:06:36 +02:00
|
|
|
flags = omode_to_uflags(mode);
|
2010-06-22 16:17:04 +02:00
|
|
|
}
|
2011-10-25 08:40:39 +02:00
|
|
|
if (is_ro_export(&s->ctx)) {
|
|
|
|
if (mode & O_WRONLY || mode & O_RDWR ||
|
|
|
|
mode & O_APPEND || mode & O_TRUNC) {
|
|
|
|
err = -EROFS;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
}
|
2011-08-02 08:06:17 +02:00
|
|
|
err = v9fs_co_open(pdu, fidp, flags);
|
2011-05-07 14:06:36 +02:00
|
|
|
if (err < 0) {
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
fidp->fid_type = P9_FID_FILE;
|
2011-05-18 12:10:57 +02:00
|
|
|
fidp->open_flags = flags;
|
|
|
|
if (flags & O_EXCL) {
|
|
|
|
/*
|
|
|
|
* We let the host file system do O_EXCL check
|
|
|
|
* We should not reclaim such fd
|
|
|
|
*/
|
|
|
|
fidp->flags |= FID_NON_RECLAIMABLE;
|
|
|
|
}
|
2011-08-02 08:06:17 +02:00
|
|
|
iounit = get_iounit(pdu, &fidp->path);
|
2011-12-14 09:19:13 +01:00
|
|
|
err = pdu_marshal(pdu, offset, "Qd", &qid, iounit);
|
|
|
|
if (err < 0) {
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
err += offset;
|
2010-04-29 14:14:55 +02:00
|
|
|
}
|
2011-10-24 11:39:49 +02:00
|
|
|
trace_v9fs_open_return(pdu->tag, pdu->id,
|
|
|
|
qid.type, qid.version, qid.path, iounit);
|
2010-04-29 14:14:55 +02:00
|
|
|
out:
|
2011-08-02 08:06:17 +02:00
|
|
|
put_fid(pdu, fidp);
|
2011-05-18 14:08:07 +02:00
|
|
|
out_nofid:
|
2015-12-02 16:00:14 +01:00
|
|
|
pdu_complete(pdu, err);
|
2010-04-29 14:14:55 +02:00
|
|
|
}
|
|
|
|
|
2016-10-17 14:13:58 +02:00
|
|
|
static void coroutine_fn v9fs_lcreate(void *opaque)
|
2010-06-18 03:27:24 +02:00
|
|
|
{
|
|
|
|
int32_t dfid, flags, mode;
|
|
|
|
gid_t gid;
|
|
|
|
ssize_t err = 0;
|
2011-08-08 20:24:08 +02:00
|
|
|
ssize_t offset = 7;
|
|
|
|
V9fsString name;
|
|
|
|
V9fsFidState *fidp;
|
|
|
|
struct stat stbuf;
|
|
|
|
V9fsQID qid;
|
|
|
|
int32_t iounit;
|
|
|
|
V9fsPDU *pdu = opaque;
|
2010-06-18 03:27:24 +02:00
|
|
|
|
2011-12-14 09:19:13 +01:00
|
|
|
v9fs_string_init(&name);
|
|
|
|
err = pdu_unmarshal(pdu, offset, "dsddd", &dfid,
|
|
|
|
&name, &flags, &mode, &gid);
|
|
|
|
if (err < 0) {
|
|
|
|
goto out_nofid;
|
|
|
|
}
|
2011-10-12 15:41:25 +02:00
|
|
|
trace_v9fs_lcreate(pdu->tag, pdu->id, dfid, flags, mode, gid);
|
2010-06-18 03:27:24 +02:00
|
|
|
|
2016-08-30 19:11:05 +02:00
|
|
|
if (name_is_illegal(name.data)) {
|
|
|
|
err = -ENOENT;
|
|
|
|
goto out_nofid;
|
|
|
|
}
|
|
|
|
|
2016-08-30 19:13:11 +02:00
|
|
|
if (!strcmp(".", name.data) || !strcmp("..", name.data)) {
|
|
|
|
err = -EEXIST;
|
|
|
|
goto out_nofid;
|
|
|
|
}
|
|
|
|
|
2011-08-02 08:06:17 +02:00
|
|
|
fidp = get_fid(pdu, dfid);
|
2011-08-08 20:24:08 +02:00
|
|
|
if (fidp == NULL) {
|
2010-06-18 03:27:24 +02:00
|
|
|
err = -ENOENT;
|
2011-05-18 14:08:07 +02:00
|
|
|
goto out_nofid;
|
2010-06-18 03:27:24 +02:00
|
|
|
}
|
2017-03-27 21:13:19 +02:00
|
|
|
if (fidp->fid_type != P9_FID_NONE) {
|
|
|
|
err = -EINVAL;
|
|
|
|
goto out;
|
|
|
|
}
|
2010-06-18 03:27:24 +02:00
|
|
|
|
2011-10-12 15:41:23 +02:00
|
|
|
flags = get_dotl_openflags(pdu->s, flags);
|
2011-08-02 08:06:17 +02:00
|
|
|
err = v9fs_co_open2(pdu, fidp, &name, gid,
|
2011-05-24 11:40:56 +02:00
|
|
|
flags | O_CREAT, mode, &stbuf);
|
2011-08-08 20:24:08 +02:00
|
|
|
if (err < 0) {
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
fidp->fid_type = P9_FID_FILE;
|
2011-05-18 12:10:57 +02:00
|
|
|
fidp->open_flags = flags;
|
|
|
|
if (flags & O_EXCL) {
|
|
|
|
/*
|
|
|
|
* We let the host file system do O_EXCL check
|
|
|
|
* We should not reclaim such fd
|
|
|
|
*/
|
|
|
|
fidp->flags |= FID_NON_RECLAIMABLE;
|
|
|
|
}
|
2011-08-02 08:06:17 +02:00
|
|
|
iounit = get_iounit(pdu, &fidp->path);
|
2019-10-10 11:36:05 +02:00
|
|
|
err = stat_to_qid(pdu, &stbuf, &qid);
|
|
|
|
if (err < 0) {
|
|
|
|
goto out;
|
|
|
|
}
|
2011-12-14 09:19:13 +01:00
|
|
|
err = pdu_marshal(pdu, offset, "Qd", &qid, iounit);
|
|
|
|
if (err < 0) {
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
err += offset;
|
2011-10-24 11:39:49 +02:00
|
|
|
trace_v9fs_lcreate_return(pdu->tag, pdu->id,
|
|
|
|
qid.type, qid.version, qid.path, iounit);
|
2010-06-18 03:27:24 +02:00
|
|
|
out:
|
2011-08-02 08:06:17 +02:00
|
|
|
put_fid(pdu, fidp);
|
2011-05-18 14:08:07 +02:00
|
|
|
out_nofid:
|
2015-12-02 16:00:14 +01:00
|
|
|
pdu_complete(pdu, err);
|
2011-08-08 20:24:08 +02:00
|
|
|
v9fs_string_free(&name);
|
2010-06-18 03:27:24 +02:00
|
|
|
}
|
|
|
|
|
2016-11-25 12:54:21 +01:00
|
|
|
static void coroutine_fn v9fs_fsync(void *opaque)
|
2010-09-23 02:18:33 +02:00
|
|
|
{
|
2011-05-07 17:55:51 +02:00
|
|
|
int err;
|
2010-09-23 02:18:33 +02:00
|
|
|
int32_t fid;
|
2011-05-07 17:55:51 +02:00
|
|
|
int datasync;
|
2010-09-23 02:18:33 +02:00
|
|
|
size_t offset = 7;
|
|
|
|
V9fsFidState *fidp;
|
2011-05-07 17:55:51 +02:00
|
|
|
V9fsPDU *pdu = opaque;
|
2010-09-23 02:18:33 +02:00
|
|
|
|
2011-12-14 09:19:13 +01:00
|
|
|
err = pdu_unmarshal(pdu, offset, "dd", &fid, &datasync);
|
|
|
|
if (err < 0) {
|
|
|
|
goto out_nofid;
|
|
|
|
}
|
2011-10-12 15:41:25 +02:00
|
|
|
trace_v9fs_fsync(pdu->tag, pdu->id, fid, datasync);
|
|
|
|
|
2011-08-02 08:06:17 +02:00
|
|
|
fidp = get_fid(pdu, fid);
|
2010-09-23 02:18:33 +02:00
|
|
|
if (fidp == NULL) {
|
|
|
|
err = -ENOENT;
|
2011-05-18 14:08:07 +02:00
|
|
|
goto out_nofid;
|
2010-09-23 02:18:33 +02:00
|
|
|
}
|
2011-08-02 08:06:17 +02:00
|
|
|
err = v9fs_co_fsync(pdu, fidp, datasync);
|
2011-05-07 17:55:51 +02:00
|
|
|
if (!err) {
|
|
|
|
err = offset;
|
|
|
|
}
|
2011-08-02 08:06:17 +02:00
|
|
|
put_fid(pdu, fidp);
|
2011-05-18 14:08:07 +02:00
|
|
|
out_nofid:
|
2015-12-02 16:00:14 +01:00
|
|
|
pdu_complete(pdu, err);
|
2010-09-23 02:18:33 +02:00
|
|
|
}
|
|
|
|
|
2016-10-17 14:13:58 +02:00
|
|
|
static void coroutine_fn v9fs_clunk(void *opaque)
|
2010-04-29 14:14:55 +02:00
|
|
|
{
|
2011-05-07 17:06:38 +02:00
|
|
|
int err;
|
2010-04-29 14:14:57 +02:00
|
|
|
int32_t fid;
|
|
|
|
size_t offset = 7;
|
2011-05-18 14:08:07 +02:00
|
|
|
V9fsFidState *fidp;
|
2011-05-07 17:06:38 +02:00
|
|
|
V9fsPDU *pdu = opaque;
|
|
|
|
V9fsState *s = pdu->s;
|
2010-04-29 14:14:57 +02:00
|
|
|
|
2011-12-14 09:19:13 +01:00
|
|
|
err = pdu_unmarshal(pdu, offset, "d", &fid);
|
|
|
|
if (err < 0) {
|
|
|
|
goto out_nofid;
|
|
|
|
}
|
2011-10-12 15:41:25 +02:00
|
|
|
trace_v9fs_clunk(pdu->tag, pdu->id, fid);
|
2011-05-18 14:08:07 +02:00
|
|
|
|
2011-08-02 08:06:24 +02:00
|
|
|
fidp = clunk_fid(s, fid);
|
2011-05-18 14:08:07 +02:00
|
|
|
if (fidp == NULL) {
|
|
|
|
err = -ENOENT;
|
|
|
|
goto out_nofid;
|
|
|
|
}
|
2011-08-02 08:06:24 +02:00
|
|
|
/*
|
|
|
|
* Bump the ref so that put_fid will
|
|
|
|
* free the fid.
|
|
|
|
*/
|
|
|
|
fidp->ref++;
|
2013-02-05 06:57:46 +01:00
|
|
|
err = put_fid(pdu, fidp);
|
|
|
|
if (!err) {
|
|
|
|
err = offset;
|
|
|
|
}
|
2011-05-18 14:08:07 +02:00
|
|
|
out_nofid:
|
2015-12-02 16:00:14 +01:00
|
|
|
pdu_complete(pdu, err);
|
2010-04-29 14:14:44 +02:00
|
|
|
}
|
|
|
|
|
2017-01-03 17:28:44 +01:00
|
|
|
/*
|
|
|
|
* Create a QEMUIOVector for a sub-region of PDU iovecs
|
|
|
|
*
|
|
|
|
* @qiov: uninitialized QEMUIOVector
|
|
|
|
* @skip: number of bytes to skip from beginning of PDU
|
|
|
|
* @size: number of bytes to include
|
|
|
|
* @is_write: true - write, false - read
|
|
|
|
*
|
|
|
|
* The resulting QEMUIOVector has heap-allocated iovecs and must be cleaned up
|
|
|
|
* with qemu_iovec_destroy().
|
|
|
|
*/
|
|
|
|
static void v9fs_init_qiov_from_pdu(QEMUIOVector *qiov, V9fsPDU *pdu,
|
2020-05-21 21:26:25 +02:00
|
|
|
size_t skip, size_t size,
|
2017-01-03 17:28:44 +01:00
|
|
|
bool is_write)
|
|
|
|
{
|
|
|
|
QEMUIOVector elem;
|
|
|
|
struct iovec *iov;
|
|
|
|
unsigned int niov;
|
|
|
|
|
2017-01-03 17:28:44 +01:00
|
|
|
if (is_write) {
|
2020-05-21 21:26:25 +02:00
|
|
|
pdu->s->transport->init_out_iov_from_pdu(pdu, &iov, &niov, size + skip);
|
2017-01-03 17:28:44 +01:00
|
|
|
} else {
|
2020-05-21 21:26:25 +02:00
|
|
|
pdu->s->transport->init_in_iov_from_pdu(pdu, &iov, &niov, size + skip);
|
2017-01-03 17:28:44 +01:00
|
|
|
}
|
2017-01-03 17:28:44 +01:00
|
|
|
|
|
|
|
qemu_iovec_init_external(&elem, iov, niov);
|
|
|
|
qemu_iovec_init(qiov, niov);
|
2020-05-21 21:26:25 +02:00
|
|
|
qemu_iovec_concat(qiov, &elem, skip, size);
|
2017-01-03 17:28:44 +01:00
|
|
|
}
|
|
|
|
|
2011-12-21 08:07:23 +01:00
|
|
|
static int v9fs_xattr_read(V9fsState *s, V9fsPDU *pdu, V9fsFidState *fidp,
|
|
|
|
uint64_t off, uint32_t max_count)
|
2010-04-29 14:14:56 +02:00
|
|
|
{
|
2011-12-14 09:19:13 +01:00
|
|
|
ssize_t err;
|
2011-05-20 22:46:31 +02:00
|
|
|
size_t offset = 7;
|
2020-05-21 21:26:25 +02:00
|
|
|
uint64_t read_count;
|
2017-01-03 17:28:44 +01:00
|
|
|
QEMUIOVector qiov_full;
|
2010-04-29 14:14:56 +02:00
|
|
|
|
2016-11-01 12:00:40 +01:00
|
|
|
if (fidp->fs.xattr.len < off) {
|
|
|
|
read_count = 0;
|
2020-01-20 15:11:39 +01:00
|
|
|
} else {
|
2020-05-21 21:26:25 +02:00
|
|
|
read_count = fidp->fs.xattr.len - off;
|
|
|
|
}
|
|
|
|
if (read_count > max_count) {
|
2011-05-20 22:46:31 +02:00
|
|
|
read_count = max_count;
|
2010-04-29 14:14:56 +02:00
|
|
|
}
|
2011-12-14 09:19:13 +01:00
|
|
|
err = pdu_marshal(pdu, offset, "d", read_count);
|
|
|
|
if (err < 0) {
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
offset += err;
|
2016-01-11 10:29:37 +01:00
|
|
|
|
2020-05-21 21:26:25 +02:00
|
|
|
v9fs_init_qiov_from_pdu(&qiov_full, pdu, offset, read_count, false);
|
2017-01-25 00:23:49 +01:00
|
|
|
err = v9fs_pack(qiov_full.iov, qiov_full.niov, 0,
|
2011-12-14 09:19:13 +01:00
|
|
|
((char *)fidp->fs.xattr.value) + off,
|
|
|
|
read_count);
|
2017-01-03 17:28:44 +01:00
|
|
|
qemu_iovec_destroy(&qiov_full);
|
2011-12-14 09:19:13 +01:00
|
|
|
if (err < 0) {
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
offset += err;
|
2011-05-20 22:46:31 +02:00
|
|
|
return offset;
|
2010-04-29 14:14:56 +02:00
|
|
|
}
|
|
|
|
|
2016-10-17 14:13:58 +02:00
|
|
|
static int coroutine_fn v9fs_do_readdir_with_stat(V9fsPDU *pdu,
|
|
|
|
V9fsFidState *fidp,
|
|
|
|
uint32_t max_count)
|
2010-04-29 14:14:56 +02:00
|
|
|
{
|
2011-09-09 11:44:18 +02:00
|
|
|
V9fsPath path;
|
2011-05-20 22:46:31 +02:00
|
|
|
V9fsStat v9stat;
|
|
|
|
int len, err = 0;
|
|
|
|
int32_t count = 0;
|
|
|
|
struct stat stbuf;
|
|
|
|
off_t saved_dir_pos;
|
2016-06-06 11:52:34 +02:00
|
|
|
struct dirent *dent;
|
2010-04-29 14:14:56 +02:00
|
|
|
|
2011-05-20 22:46:31 +02:00
|
|
|
/* save the directory position */
|
2011-08-02 08:06:17 +02:00
|
|
|
saved_dir_pos = v9fs_co_telldir(pdu, fidp);
|
2011-05-20 22:46:31 +02:00
|
|
|
if (saved_dir_pos < 0) {
|
|
|
|
return saved_dir_pos;
|
2010-04-29 14:14:56 +02:00
|
|
|
}
|
2011-05-18 13:53:00 +02:00
|
|
|
|
2011-05-20 22:46:31 +02:00
|
|
|
while (1) {
|
2011-09-09 11:44:18 +02:00
|
|
|
v9fs_path_init(&path);
|
2016-06-06 11:52:34 +02:00
|
|
|
|
|
|
|
v9fs_readdir_lock(&fidp->fs.dir);
|
|
|
|
|
2016-06-06 11:52:34 +02:00
|
|
|
err = v9fs_co_readdir(pdu, fidp, &dent);
|
|
|
|
if (err || !dent) {
|
2011-05-20 22:46:31 +02:00
|
|
|
break;
|
|
|
|
}
|
2011-08-02 08:06:17 +02:00
|
|
|
err = v9fs_co_name_to_path(pdu, &fidp->path, dent->d_name, &path);
|
2011-05-20 22:46:31 +02:00
|
|
|
if (err < 0) {
|
2016-06-06 11:52:34 +02:00
|
|
|
break;
|
2011-05-20 22:46:31 +02:00
|
|
|
}
|
2011-08-02 08:06:17 +02:00
|
|
|
err = v9fs_co_lstat(pdu, &path, &stbuf);
|
2011-09-09 11:44:18 +02:00
|
|
|
if (err < 0) {
|
2016-06-06 11:52:34 +02:00
|
|
|
break;
|
2011-09-09 11:44:18 +02:00
|
|
|
}
|
2017-09-20 08:48:51 +02:00
|
|
|
err = stat_to_v9stat(pdu, &path, dent->d_name, &stbuf, &v9stat);
|
2011-05-20 22:46:31 +02:00
|
|
|
if (err < 0) {
|
2016-06-06 11:52:34 +02:00
|
|
|
break;
|
2010-04-29 14:14:56 +02:00
|
|
|
}
|
2017-09-20 08:48:52 +02:00
|
|
|
if ((count + v9stat.size + 2) > max_count) {
|
|
|
|
v9fs_readdir_unlock(&fidp->fs.dir);
|
|
|
|
|
|
|
|
/* Ran out of buffer. Set dir back to old position and return */
|
|
|
|
v9fs_co_seekdir(pdu, fidp, saved_dir_pos);
|
|
|
|
v9fs_stat_free(&v9stat);
|
|
|
|
v9fs_path_free(&path);
|
|
|
|
return count;
|
|
|
|
}
|
|
|
|
|
2011-05-20 22:46:31 +02:00
|
|
|
/* 11 = 7 + 4 (7 = start offset, 4 = space for storing count) */
|
|
|
|
len = pdu_marshal(pdu, 11 + count, "S", &v9stat);
|
2016-06-06 11:52:34 +02:00
|
|
|
|
|
|
|
v9fs_readdir_unlock(&fidp->fs.dir);
|
|
|
|
|
2017-09-20 08:48:52 +02:00
|
|
|
if (len < 0) {
|
2011-08-02 08:06:17 +02:00
|
|
|
v9fs_co_seekdir(pdu, fidp, saved_dir_pos);
|
2011-05-20 22:46:31 +02:00
|
|
|
v9fs_stat_free(&v9stat);
|
2011-09-09 11:44:18 +02:00
|
|
|
v9fs_path_free(&path);
|
2017-09-20 08:48:52 +02:00
|
|
|
return len;
|
2011-05-20 22:46:31 +02:00
|
|
|
}
|
|
|
|
count += len;
|
|
|
|
v9fs_stat_free(&v9stat);
|
2011-09-09 11:44:18 +02:00
|
|
|
v9fs_path_free(&path);
|
2011-05-20 22:46:31 +02:00
|
|
|
saved_dir_pos = dent->d_off;
|
2010-04-29 14:14:56 +02:00
|
|
|
}
|
2016-06-06 11:52:34 +02:00
|
|
|
|
2016-06-06 11:52:34 +02:00
|
|
|
v9fs_readdir_unlock(&fidp->fs.dir);
|
|
|
|
|
2011-09-09 11:44:18 +02:00
|
|
|
v9fs_path_free(&path);
|
2011-05-20 22:46:31 +02:00
|
|
|
if (err < 0) {
|
|
|
|
return err;
|
2010-09-02 07:39:06 +02:00
|
|
|
}
|
2011-05-20 22:46:31 +02:00
|
|
|
return count;
|
2010-09-02 07:39:06 +02:00
|
|
|
}
|
|
|
|
|
2016-10-17 14:13:58 +02:00
|
|
|
static void coroutine_fn v9fs_read(void *opaque)
|
2010-04-29 14:14:44 +02:00
|
|
|
{
|
2010-04-29 14:14:56 +02:00
|
|
|
int32_t fid;
|
2011-12-21 08:07:23 +01:00
|
|
|
uint64_t off;
|
2010-04-29 14:14:56 +02:00
|
|
|
ssize_t err = 0;
|
2011-05-20 22:46:31 +02:00
|
|
|
int32_t count = 0;
|
|
|
|
size_t offset = 7;
|
2011-12-21 08:07:23 +01:00
|
|
|
uint32_t max_count;
|
2011-05-20 22:46:31 +02:00
|
|
|
V9fsFidState *fidp;
|
|
|
|
V9fsPDU *pdu = opaque;
|
|
|
|
V9fsState *s = pdu->s;
|
2010-04-29 14:14:56 +02:00
|
|
|
|
2011-12-14 09:19:13 +01:00
|
|
|
err = pdu_unmarshal(pdu, offset, "dqd", &fid, &off, &max_count);
|
|
|
|
if (err < 0) {
|
|
|
|
goto out_nofid;
|
|
|
|
}
|
2011-10-12 15:41:25 +02:00
|
|
|
trace_v9fs_read(pdu->tag, pdu->id, fid, off, max_count);
|
2011-05-18 14:08:07 +02:00
|
|
|
|
2011-08-02 08:06:17 +02:00
|
|
|
fidp = get_fid(pdu, fid);
|
2011-05-20 22:46:31 +02:00
|
|
|
if (fidp == NULL) {
|
2010-04-29 14:14:56 +02:00
|
|
|
err = -EINVAL;
|
2011-05-18 14:08:07 +02:00
|
|
|
goto out_nofid;
|
2010-04-29 14:14:56 +02:00
|
|
|
}
|
2011-05-20 22:46:31 +02:00
|
|
|
if (fidp->fid_type == P9_FID_DIR) {
|
2020-07-29 10:39:12 +02:00
|
|
|
if (s->proto_version != V9FS_PROTO_2000U) {
|
|
|
|
warn_report_once(
|
|
|
|
"9p: bad client: T_read request on directory only expected "
|
|
|
|
"with 9P2000.u protocol version"
|
|
|
|
);
|
|
|
|
err = -EOPNOTSUPP;
|
|
|
|
goto out;
|
|
|
|
}
|
2011-05-20 22:46:31 +02:00
|
|
|
if (off == 0) {
|
2011-08-02 08:06:17 +02:00
|
|
|
v9fs_co_rewinddir(pdu, fidp);
|
2010-04-29 14:14:56 +02:00
|
|
|
}
|
2011-08-02 08:06:17 +02:00
|
|
|
count = v9fs_do_readdir_with_stat(pdu, fidp, max_count);
|
2011-05-20 22:46:31 +02:00
|
|
|
if (count < 0) {
|
|
|
|
err = count;
|
|
|
|
goto out;
|
2010-10-08 08:00:16 +02:00
|
|
|
}
|
2011-12-14 09:19:13 +01:00
|
|
|
err = pdu_marshal(pdu, offset, "d", count);
|
|
|
|
if (err < 0) {
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
err += offset + count;
|
2011-05-20 22:46:31 +02:00
|
|
|
} else if (fidp->fid_type == P9_FID_FILE) {
|
2011-12-21 08:07:22 +01:00
|
|
|
QEMUIOVector qiov_full;
|
|
|
|
QEMUIOVector qiov;
|
2011-05-20 22:46:31 +02:00
|
|
|
int32_t len;
|
|
|
|
|
2020-05-21 21:26:25 +02:00
|
|
|
v9fs_init_qiov_from_pdu(&qiov_full, pdu, offset + 4, max_count, false);
|
2011-12-21 08:07:22 +01:00
|
|
|
qemu_iovec_init(&qiov, qiov_full.niov);
|
2011-05-20 22:46:31 +02:00
|
|
|
do {
|
2011-12-21 08:07:22 +01:00
|
|
|
qemu_iovec_reset(&qiov);
|
consolidate qemu_iovec_copy() and qemu_iovec_concat() and make them consistent
qemu_iovec_concat() is currently a wrapper for
qemu_iovec_copy(), use the former (with extra
"0" arg) in a few places where it is used.
Change skip argument of qemu_iovec_copy() from
uint64_t to size_t, since size of qiov itself
is size_t, so there's no way to skip larger
sizes. Rename it to soffset, to make it clear
that the offset is applied to src.
Also change the only usage of uint64_t in
hw/9pfs/virtio-9p.c, in v9fs_init_qiov_from_pdu() -
all callers of it actually uses size_t too,
not uint64_t.
One added restriction: as for all other iovec-related
functions, soffset must point inside src.
Order of argumens is already good:
qemu_iovec_memset(QEMUIOVector *qiov, size_t offset,
int c, size_t bytes)
vs:
qemu_iovec_concat(QEMUIOVector *dst,
QEMUIOVector *src,
size_t soffset, size_t sbytes)
(note soffset is after _src_ not dst, since it applies to src;
for memset it applies to qiov).
Note that in many places where this function is used,
the previous call is qemu_iovec_reset(), which means
many callers actually want copy (replacing dst content),
not concat. So we may want to add a wrapper like
qemu_iovec_copy() with the same arguments but which
calls qemu_iovec_reset() before _concat().
Signed-off-by: Michael Tokarev <mjt@tls.msk.ru>
2012-03-12 18:28:06 +01:00
|
|
|
qemu_iovec_concat(&qiov, &qiov_full, count, qiov_full.size - count);
|
2011-05-20 22:46:31 +02:00
|
|
|
if (0) {
|
2011-12-21 08:07:22 +01:00
|
|
|
print_sg(qiov.iov, qiov.niov);
|
2011-05-20 22:46:31 +02:00
|
|
|
}
|
|
|
|
/* Loop in case of EINTR */
|
|
|
|
do {
|
2011-12-21 08:07:22 +01:00
|
|
|
len = v9fs_co_preadv(pdu, fidp, qiov.iov, qiov.niov, off);
|
2011-05-20 22:46:31 +02:00
|
|
|
if (len >= 0) {
|
|
|
|
off += len;
|
|
|
|
count += len;
|
|
|
|
}
|
2011-08-02 08:06:17 +02:00
|
|
|
} while (len == -EINTR && !pdu->cancelled);
|
2011-05-20 22:46:31 +02:00
|
|
|
if (len < 0) {
|
|
|
|
/* IO error return the error */
|
|
|
|
err = len;
|
2016-10-17 14:13:58 +02:00
|
|
|
goto out_free_iovec;
|
2011-05-20 22:46:31 +02:00
|
|
|
}
|
|
|
|
} while (count < max_count && len > 0);
|
2011-12-14 09:19:13 +01:00
|
|
|
err = pdu_marshal(pdu, offset, "d", count);
|
|
|
|
if (err < 0) {
|
2016-10-17 14:13:58 +02:00
|
|
|
goto out_free_iovec;
|
2011-12-14 09:19:13 +01:00
|
|
|
}
|
|
|
|
err += offset + count;
|
2016-10-17 14:13:58 +02:00
|
|
|
out_free_iovec:
|
2011-12-21 08:07:22 +01:00
|
|
|
qemu_iovec_destroy(&qiov);
|
|
|
|
qemu_iovec_destroy(&qiov_full);
|
2011-05-20 22:46:31 +02:00
|
|
|
} else if (fidp->fid_type == P9_FID_XATTR) {
|
|
|
|
err = v9fs_xattr_read(s, pdu, fidp, off, max_count);
|
2010-04-29 14:14:56 +02:00
|
|
|
} else {
|
|
|
|
err = -EINVAL;
|
2010-04-29 14:14:44 +02:00
|
|
|
}
|
2011-10-24 11:39:49 +02:00
|
|
|
trace_v9fs_read_return(pdu->tag, pdu->id, count, err);
|
2010-04-29 14:14:56 +02:00
|
|
|
out:
|
2011-08-02 08:06:17 +02:00
|
|
|
put_fid(pdu, fidp);
|
2011-05-18 14:08:07 +02:00
|
|
|
out_nofid:
|
2015-12-02 16:00:14 +01:00
|
|
|
pdu_complete(pdu, err);
|
2010-04-29 14:14:44 +02:00
|
|
|
}
|
|
|
|
|
2020-07-29 10:11:15 +02:00
|
|
|
/**
|
|
|
|
* Returns size required in Rreaddir response for the passed dirent @p name.
|
|
|
|
*
|
|
|
|
* @param name - directory entry's name (i.e. file name, directory name)
|
|
|
|
* @returns required size in bytes
|
|
|
|
*/
|
|
|
|
size_t v9fs_readdir_response_size(V9fsString *name)
|
2010-06-09 11:27:57 +02:00
|
|
|
{
|
2011-05-19 00:57:17 +02:00
|
|
|
/*
|
|
|
|
* Size of each dirent on the wire: size of qid (13) + size of offset (8)
|
|
|
|
* size of type (1) + size of name.size (2) + strlen(name.data)
|
|
|
|
*/
|
|
|
|
return 24 + v9fs_string_size(name);
|
2010-06-09 11:27:57 +02:00
|
|
|
}
|
|
|
|
|
2020-07-29 10:13:05 +02:00
|
|
|
static void v9fs_free_dirents(struct V9fsDirEnt *e)
|
|
|
|
{
|
|
|
|
struct V9fsDirEnt *next = NULL;
|
|
|
|
|
|
|
|
for (; e; e = next) {
|
|
|
|
next = e->next;
|
|
|
|
g_free(e->dent);
|
|
|
|
g_free(e->st);
|
|
|
|
g_free(e);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-10-17 14:13:58 +02:00
|
|
|
static int coroutine_fn v9fs_do_readdir(V9fsPDU *pdu, V9fsFidState *fidp,
|
2020-07-29 10:13:05 +02:00
|
|
|
off_t offset, int32_t max_count)
|
2010-06-09 11:27:57 +02:00
|
|
|
{
|
|
|
|
size_t size;
|
2011-05-19 00:57:17 +02:00
|
|
|
V9fsQID qid;
|
|
|
|
V9fsString name;
|
|
|
|
int len, err = 0;
|
|
|
|
int32_t count = 0;
|
2016-06-06 11:52:34 +02:00
|
|
|
struct dirent *dent;
|
2020-07-29 10:13:05 +02:00
|
|
|
struct stat *st;
|
|
|
|
struct V9fsDirEnt *entries = NULL;
|
2010-06-09 11:27:57 +02:00
|
|
|
|
2020-07-29 10:13:05 +02:00
|
|
|
/*
|
|
|
|
* inode remapping requires the device id, which in turn might be
|
|
|
|
* different for different directory entries, so if inode remapping is
|
|
|
|
* enabled we have to make a full stat for each directory entry
|
|
|
|
*/
|
|
|
|
const bool dostat = pdu->s->ctx.export_flags & V9FS_REMAP_INODES;
|
2016-06-06 11:52:34 +02:00
|
|
|
|
2020-07-29 10:13:05 +02:00
|
|
|
/*
|
|
|
|
* Fetch all required directory entries altogether on a background IO
|
|
|
|
* thread from fs driver. We don't want to do that for each entry
|
|
|
|
* individually, because hopping between threads (this main IO thread
|
|
|
|
* and background IO driver thread) would sum up to huge latencies.
|
|
|
|
*/
|
|
|
|
count = v9fs_co_readdir_many(pdu, fidp, &entries, offset, max_count,
|
|
|
|
dostat);
|
|
|
|
if (count < 0) {
|
|
|
|
err = count;
|
|
|
|
count = 0;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
count = 0;
|
2016-06-06 11:52:34 +02:00
|
|
|
|
2020-07-29 10:13:05 +02:00
|
|
|
for (struct V9fsDirEnt *e = entries; e; e = e->next) {
|
|
|
|
dent = e->dent;
|
2019-10-10 11:36:05 +02:00
|
|
|
|
|
|
|
if (pdu->s->ctx.export_flags & V9FS_REMAP_INODES) {
|
2020-07-29 10:13:05 +02:00
|
|
|
st = e->st;
|
|
|
|
/* e->st should never be NULL, but just to be sure */
|
|
|
|
if (!st) {
|
|
|
|
err = -1;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* remap inode */
|
|
|
|
err = stat_to_qid(pdu, st, &qid);
|
2019-10-10 11:36:05 +02:00
|
|
|
if (err < 0) {
|
2020-07-29 10:13:05 +02:00
|
|
|
break;
|
2019-10-10 11:36:05 +02:00
|
|
|
}
|
|
|
|
} else {
|
|
|
|
/*
|
|
|
|
* Fill up just the path field of qid because the client uses
|
|
|
|
* only that. To fill the entire qid structure we will have
|
|
|
|
* to stat each dirent found, which is expensive. For the
|
2020-07-29 10:13:05 +02:00
|
|
|
* latter reason we don't call stat_to_qid() here. Only drawback
|
2019-10-10 11:36:05 +02:00
|
|
|
* is that no multi-device export detection of stat_to_qid()
|
|
|
|
* would be done and provided as error to the user here. But
|
|
|
|
* user would get that error anyway when accessing those
|
|
|
|
* files/dirs through other ways.
|
|
|
|
*/
|
|
|
|
size = MIN(sizeof(dent->d_ino), sizeof(qid.path));
|
|
|
|
memcpy(&qid.path, &dent->d_ino, size);
|
|
|
|
/* Fill the other fields with dummy values */
|
|
|
|
qid.type = 0;
|
|
|
|
qid.version = 0;
|
|
|
|
}
|
2010-06-09 11:27:57 +02:00
|
|
|
|
2020-07-29 10:13:05 +02:00
|
|
|
v9fs_string_init(&name);
|
|
|
|
v9fs_string_sprintf(&name, "%s", dent->d_name);
|
|
|
|
|
2011-05-19 00:57:17 +02:00
|
|
|
/* 11 = 7 + 4 (7 = start offset, 4 = space for storing count) */
|
|
|
|
len = pdu_marshal(pdu, 11 + count, "Qqbs",
|
|
|
|
&qid, dent->d_off,
|
|
|
|
dent->d_type, &name);
|
2016-06-06 11:52:34 +02:00
|
|
|
|
2020-07-29 10:13:05 +02:00
|
|
|
v9fs_string_free(&name);
|
2016-06-06 11:52:34 +02:00
|
|
|
|
2011-12-14 09:19:13 +01:00
|
|
|
if (len < 0) {
|
2020-07-29 10:13:05 +02:00
|
|
|
err = len;
|
|
|
|
break;
|
2011-12-14 09:19:13 +01:00
|
|
|
}
|
2020-07-29 10:13:05 +02:00
|
|
|
|
2011-05-19 00:57:17 +02:00
|
|
|
count += len;
|
|
|
|
}
|
2016-06-06 11:52:34 +02:00
|
|
|
|
2020-07-29 10:13:05 +02:00
|
|
|
out:
|
|
|
|
v9fs_free_dirents(entries);
|
2011-05-19 00:57:17 +02:00
|
|
|
if (err < 0) {
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
return count;
|
2010-06-09 11:27:57 +02:00
|
|
|
}
|
|
|
|
|
2016-10-17 14:13:58 +02:00
|
|
|
static void coroutine_fn v9fs_readdir(void *opaque)
|
2010-06-09 11:27:57 +02:00
|
|
|
{
|
|
|
|
int32_t fid;
|
2011-05-19 00:57:17 +02:00
|
|
|
V9fsFidState *fidp;
|
|
|
|
ssize_t retval = 0;
|
2010-06-09 11:27:57 +02:00
|
|
|
size_t offset = 7;
|
2011-12-21 08:07:23 +01:00
|
|
|
uint64_t initial_offset;
|
|
|
|
int32_t count;
|
|
|
|
uint32_t max_count;
|
2011-05-19 00:57:17 +02:00
|
|
|
V9fsPDU *pdu = opaque;
|
2020-02-08 09:24:19 +01:00
|
|
|
V9fsState *s = pdu->s;
|
2010-06-09 11:27:57 +02:00
|
|
|
|
2011-12-14 09:19:13 +01:00
|
|
|
retval = pdu_unmarshal(pdu, offset, "dqd", &fid,
|
|
|
|
&initial_offset, &max_count);
|
|
|
|
if (retval < 0) {
|
|
|
|
goto out_nofid;
|
|
|
|
}
|
2011-10-12 15:41:25 +02:00
|
|
|
trace_v9fs_readdir(pdu->tag, pdu->id, fid, initial_offset, max_count);
|
|
|
|
|
2020-02-08 09:24:19 +01:00
|
|
|
/* Enough space for a R_readdir header: size[4] Rreaddir tag[2] count[4] */
|
|
|
|
if (max_count > s->msize - 11) {
|
|
|
|
max_count = s->msize - 11;
|
|
|
|
warn_report_once(
|
|
|
|
"9p: bad client: T_readdir with count > msize - 11"
|
|
|
|
);
|
|
|
|
}
|
|
|
|
|
2011-08-02 08:06:17 +02:00
|
|
|
fidp = get_fid(pdu, fid);
|
2011-05-18 14:08:07 +02:00
|
|
|
if (fidp == NULL) {
|
|
|
|
retval = -EINVAL;
|
|
|
|
goto out_nofid;
|
|
|
|
}
|
2016-06-06 11:52:34 +02:00
|
|
|
if (!fidp->fs.dir.stream) {
|
2011-05-19 00:57:17 +02:00
|
|
|
retval = -EINVAL;
|
2010-06-09 11:27:57 +02:00
|
|
|
goto out;
|
|
|
|
}
|
2020-07-29 10:39:12 +02:00
|
|
|
if (s->proto_version != V9FS_PROTO_2000L) {
|
|
|
|
warn_report_once(
|
|
|
|
"9p: bad client: T_readdir request only expected with 9P2000.L "
|
|
|
|
"protocol version"
|
|
|
|
);
|
|
|
|
retval = -EOPNOTSUPP;
|
|
|
|
goto out;
|
|
|
|
}
|
2020-07-29 10:13:05 +02:00
|
|
|
count = v9fs_do_readdir(pdu, fidp, (off_t) initial_offset, max_count);
|
2011-05-19 00:57:17 +02:00
|
|
|
if (count < 0) {
|
|
|
|
retval = count;
|
|
|
|
goto out;
|
|
|
|
}
|
2011-12-14 09:19:13 +01:00
|
|
|
retval = pdu_marshal(pdu, offset, "d", count);
|
|
|
|
if (retval < 0) {
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
retval += count + offset;
|
2011-10-24 11:39:49 +02:00
|
|
|
trace_v9fs_readdir_return(pdu->tag, pdu->id, count, retval);
|
2010-06-09 11:27:57 +02:00
|
|
|
out:
|
2011-08-02 08:06:17 +02:00
|
|
|
put_fid(pdu, fidp);
|
2011-05-18 14:08:07 +02:00
|
|
|
out_nofid:
|
2015-12-02 16:00:14 +01:00
|
|
|
pdu_complete(pdu, retval);
|
2010-06-09 11:27:57 +02:00
|
|
|
}
|
|
|
|
|
2011-05-08 08:59:31 +02:00
|
|
|
static int v9fs_xattr_write(V9fsState *s, V9fsPDU *pdu, V9fsFidState *fidp,
|
2011-12-21 08:07:23 +01:00
|
|
|
uint64_t off, uint32_t count,
|
2011-05-08 08:59:31 +02:00
|
|
|
struct iovec *sg, int cnt)
|
2010-09-02 07:39:07 +02:00
|
|
|
{
|
|
|
|
int i, to_copy;
|
|
|
|
ssize_t err = 0;
|
2016-11-01 12:00:40 +01:00
|
|
|
uint64_t write_count;
|
2011-05-08 08:59:31 +02:00
|
|
|
size_t offset = 7;
|
2010-09-02 07:39:07 +02:00
|
|
|
|
2011-05-08 08:59:31 +02:00
|
|
|
|
2016-11-01 12:00:40 +01:00
|
|
|
if (fidp->fs.xattr.len < off) {
|
2020-01-20 15:11:39 +01:00
|
|
|
return -ENOSPC;
|
2010-09-02 07:39:07 +02:00
|
|
|
}
|
2016-11-01 12:00:40 +01:00
|
|
|
write_count = fidp->fs.xattr.len - off;
|
|
|
|
if (write_count > count) {
|
|
|
|
write_count = count;
|
|
|
|
}
|
2011-12-14 09:19:13 +01:00
|
|
|
err = pdu_marshal(pdu, offset, "d", write_count);
|
|
|
|
if (err < 0) {
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
err += offset;
|
2011-05-08 08:59:31 +02:00
|
|
|
fidp->fs.xattr.copied_len += write_count;
|
2010-09-02 07:39:07 +02:00
|
|
|
/*
|
|
|
|
* Now copy the content from sg list
|
|
|
|
*/
|
2011-05-08 08:59:31 +02:00
|
|
|
for (i = 0; i < cnt; i++) {
|
|
|
|
if (write_count > sg[i].iov_len) {
|
|
|
|
to_copy = sg[i].iov_len;
|
2010-09-02 07:39:07 +02:00
|
|
|
} else {
|
|
|
|
to_copy = write_count;
|
|
|
|
}
|
2011-05-08 08:59:31 +02:00
|
|
|
memcpy((char *)fidp->fs.xattr.value + off, sg[i].iov_base, to_copy);
|
2010-09-02 07:39:07 +02:00
|
|
|
/* updating vs->off since we are not using below */
|
2011-05-08 08:59:31 +02:00
|
|
|
off += to_copy;
|
2010-09-02 07:39:07 +02:00
|
|
|
write_count -= to_copy;
|
|
|
|
}
|
2020-01-20 15:11:39 +01:00
|
|
|
|
2011-05-08 08:59:31 +02:00
|
|
|
return err;
|
2010-09-02 07:39:07 +02:00
|
|
|
}
|
|
|
|
|
2016-10-17 14:13:58 +02:00
|
|
|
static void coroutine_fn v9fs_write(void *opaque)
|
2010-04-29 14:14:44 +02:00
|
|
|
{
|
2011-05-08 08:59:31 +02:00
|
|
|
ssize_t err;
|
|
|
|
int32_t fid;
|
2011-12-21 08:07:23 +01:00
|
|
|
uint64_t off;
|
|
|
|
uint32_t count;
|
2011-05-08 08:59:31 +02:00
|
|
|
int32_t len = 0;
|
|
|
|
int32_t total = 0;
|
|
|
|
size_t offset = 7;
|
|
|
|
V9fsFidState *fidp;
|
2011-05-18 23:18:05 +02:00
|
|
|
V9fsPDU *pdu = opaque;
|
|
|
|
V9fsState *s = pdu->s;
|
2011-12-21 08:07:22 +01:00
|
|
|
QEMUIOVector qiov_full;
|
|
|
|
QEMUIOVector qiov;
|
2010-04-29 14:14:58 +02:00
|
|
|
|
2011-12-14 09:19:13 +01:00
|
|
|
err = pdu_unmarshal(pdu, offset, "dqd", &fid, &off, &count);
|
|
|
|
if (err < 0) {
|
2015-12-02 16:00:14 +01:00
|
|
|
pdu_complete(pdu, err);
|
2015-03-08 19:17:54 +01:00
|
|
|
return;
|
2011-12-14 09:19:13 +01:00
|
|
|
}
|
|
|
|
offset += err;
|
2020-05-21 21:26:25 +02:00
|
|
|
v9fs_init_qiov_from_pdu(&qiov_full, pdu, offset, count, true);
|
2011-12-21 08:07:22 +01:00
|
|
|
trace_v9fs_write(pdu->tag, pdu->id, fid, off, count, qiov_full.niov);
|
2011-05-18 14:08:07 +02:00
|
|
|
|
2011-08-02 08:06:17 +02:00
|
|
|
fidp = get_fid(pdu, fid);
|
2011-05-08 08:59:31 +02:00
|
|
|
if (fidp == NULL) {
|
2010-04-29 14:14:58 +02:00
|
|
|
err = -EINVAL;
|
2011-05-18 14:08:07 +02:00
|
|
|
goto out_nofid;
|
2010-04-29 14:14:44 +02:00
|
|
|
}
|
2011-05-08 08:59:31 +02:00
|
|
|
if (fidp->fid_type == P9_FID_FILE) {
|
|
|
|
if (fidp->fs.fd == -1) {
|
2010-09-02 07:39:07 +02:00
|
|
|
err = -EINVAL;
|
|
|
|
goto out;
|
|
|
|
}
|
2011-05-08 08:59:31 +02:00
|
|
|
} else if (fidp->fid_type == P9_FID_XATTR) {
|
2010-09-02 07:39:07 +02:00
|
|
|
/*
|
|
|
|
* setxattr operation
|
|
|
|
*/
|
2011-12-21 08:07:22 +01:00
|
|
|
err = v9fs_xattr_write(s, pdu, fidp, off, count,
|
|
|
|
qiov_full.iov, qiov_full.niov);
|
2011-05-08 08:59:31 +02:00
|
|
|
goto out;
|
2010-09-02 07:39:07 +02:00
|
|
|
} else {
|
2010-04-29 14:14:58 +02:00
|
|
|
err = -EINVAL;
|
|
|
|
goto out;
|
|
|
|
}
|
2011-12-21 08:07:22 +01:00
|
|
|
qemu_iovec_init(&qiov, qiov_full.niov);
|
2011-05-08 08:59:31 +02:00
|
|
|
do {
|
2011-12-21 08:07:22 +01:00
|
|
|
qemu_iovec_reset(&qiov);
|
consolidate qemu_iovec_copy() and qemu_iovec_concat() and make them consistent
qemu_iovec_concat() is currently a wrapper for
qemu_iovec_copy(), use the former (with extra
"0" arg) in a few places where it is used.
Change skip argument of qemu_iovec_copy() from
uint64_t to size_t, since size of qiov itself
is size_t, so there's no way to skip larger
sizes. Rename it to soffset, to make it clear
that the offset is applied to src.
Also change the only usage of uint64_t in
hw/9pfs/virtio-9p.c, in v9fs_init_qiov_from_pdu() -
all callers of it actually uses size_t too,
not uint64_t.
One added restriction: as for all other iovec-related
functions, soffset must point inside src.
Order of argumens is already good:
qemu_iovec_memset(QEMUIOVector *qiov, size_t offset,
int c, size_t bytes)
vs:
qemu_iovec_concat(QEMUIOVector *dst,
QEMUIOVector *src,
size_t soffset, size_t sbytes)
(note soffset is after _src_ not dst, since it applies to src;
for memset it applies to qiov).
Note that in many places where this function is used,
the previous call is qemu_iovec_reset(), which means
many callers actually want copy (replacing dst content),
not concat. So we may want to add a wrapper like
qemu_iovec_copy() with the same arguments but which
calls qemu_iovec_reset() before _concat().
Signed-off-by: Michael Tokarev <mjt@tls.msk.ru>
2012-03-12 18:28:06 +01:00
|
|
|
qemu_iovec_concat(&qiov, &qiov_full, total, qiov_full.size - total);
|
2011-05-08 08:59:31 +02:00
|
|
|
if (0) {
|
2011-12-21 08:07:22 +01:00
|
|
|
print_sg(qiov.iov, qiov.niov);
|
2010-10-08 08:00:16 +02:00
|
|
|
}
|
2011-05-08 08:59:31 +02:00
|
|
|
/* Loop in case of EINTR */
|
|
|
|
do {
|
2011-12-21 08:07:22 +01:00
|
|
|
len = v9fs_co_pwritev(pdu, fidp, qiov.iov, qiov.niov, off);
|
2011-05-08 08:59:31 +02:00
|
|
|
if (len >= 0) {
|
|
|
|
off += len;
|
|
|
|
total += len;
|
|
|
|
}
|
2011-08-02 08:06:17 +02:00
|
|
|
} while (len == -EINTR && !pdu->cancelled);
|
2011-05-08 08:59:31 +02:00
|
|
|
if (len < 0) {
|
|
|
|
/* IO error return the error */
|
|
|
|
err = len;
|
2011-12-21 08:07:22 +01:00
|
|
|
goto out_qiov;
|
2011-05-08 08:59:31 +02:00
|
|
|
}
|
|
|
|
} while (total < count && len > 0);
|
2011-12-21 08:07:22 +01:00
|
|
|
|
|
|
|
offset = 7;
|
2011-12-14 09:19:13 +01:00
|
|
|
err = pdu_marshal(pdu, offset, "d", total);
|
|
|
|
if (err < 0) {
|
2016-10-17 14:13:58 +02:00
|
|
|
goto out_qiov;
|
2011-12-14 09:19:13 +01:00
|
|
|
}
|
|
|
|
err += offset;
|
2011-10-24 11:39:49 +02:00
|
|
|
trace_v9fs_write_return(pdu->tag, pdu->id, total, err);
|
2011-12-21 08:07:22 +01:00
|
|
|
out_qiov:
|
|
|
|
qemu_iovec_destroy(&qiov);
|
2010-04-29 14:14:58 +02:00
|
|
|
out:
|
2011-08-02 08:06:17 +02:00
|
|
|
put_fid(pdu, fidp);
|
2011-05-18 14:08:07 +02:00
|
|
|
out_nofid:
|
2011-12-21 08:07:22 +01:00
|
|
|
qemu_iovec_destroy(&qiov_full);
|
2015-12-02 16:00:14 +01:00
|
|
|
pdu_complete(pdu, err);
|
2010-04-29 14:14:44 +02:00
|
|
|
}
|
|
|
|
|
2016-10-17 14:13:58 +02:00
|
|
|
static void coroutine_fn v9fs_create(void *opaque)
|
2010-06-09 15:44:28 +02:00
|
|
|
{
|
2011-08-08 20:26:50 +02:00
|
|
|
int32_t fid;
|
|
|
|
int err = 0;
|
|
|
|
size_t offset = 7;
|
|
|
|
V9fsFidState *fidp;
|
|
|
|
V9fsQID qid;
|
|
|
|
int32_t perm;
|
|
|
|
int8_t mode;
|
2011-09-09 11:44:18 +02:00
|
|
|
V9fsPath path;
|
2011-08-08 20:26:50 +02:00
|
|
|
struct stat stbuf;
|
|
|
|
V9fsString name;
|
|
|
|
V9fsString extension;
|
|
|
|
int iounit;
|
|
|
|
V9fsPDU *pdu = opaque;
|
2018-11-20 13:00:35 +01:00
|
|
|
V9fsState *s = pdu->s;
|
2010-04-29 14:14:59 +02:00
|
|
|
|
2011-09-09 11:44:18 +02:00
|
|
|
v9fs_path_init(&path);
|
2011-12-14 09:19:13 +01:00
|
|
|
v9fs_string_init(&name);
|
|
|
|
v9fs_string_init(&extension);
|
|
|
|
err = pdu_unmarshal(pdu, offset, "dsdbs", &fid, &name,
|
|
|
|
&perm, &mode, &extension);
|
|
|
|
if (err < 0) {
|
|
|
|
goto out_nofid;
|
|
|
|
}
|
2011-10-12 15:41:25 +02:00
|
|
|
trace_v9fs_create(pdu->tag, pdu->id, fid, name.data, perm, mode);
|
|
|
|
|
2016-08-30 19:11:05 +02:00
|
|
|
if (name_is_illegal(name.data)) {
|
|
|
|
err = -ENOENT;
|
|
|
|
goto out_nofid;
|
|
|
|
}
|
|
|
|
|
2016-08-30 19:13:11 +02:00
|
|
|
if (!strcmp(".", name.data) || !strcmp("..", name.data)) {
|
|
|
|
err = -EEXIST;
|
|
|
|
goto out_nofid;
|
|
|
|
}
|
|
|
|
|
2011-08-02 08:06:17 +02:00
|
|
|
fidp = get_fid(pdu, fid);
|
2011-08-08 20:26:50 +02:00
|
|
|
if (fidp == NULL) {
|
|
|
|
err = -EINVAL;
|
2011-05-18 14:08:07 +02:00
|
|
|
goto out_nofid;
|
2010-04-29 14:14:59 +02:00
|
|
|
}
|
2017-03-27 21:13:19 +02:00
|
|
|
if (fidp->fid_type != P9_FID_NONE) {
|
|
|
|
err = -EINVAL;
|
|
|
|
goto out;
|
|
|
|
}
|
2011-08-08 20:26:50 +02:00
|
|
|
if (perm & P9_STAT_MODE_DIR) {
|
2011-08-02 08:06:17 +02:00
|
|
|
err = v9fs_co_mkdir(pdu, fidp, &name, perm & 0777,
|
2011-05-24 11:40:56 +02:00
|
|
|
fidp->uid, -1, &stbuf);
|
2011-08-08 20:26:50 +02:00
|
|
|
if (err < 0) {
|
|
|
|
goto out;
|
|
|
|
}
|
2011-08-02 08:06:17 +02:00
|
|
|
err = v9fs_co_name_to_path(pdu, &fidp->path, name.data, &path);
|
2011-09-09 11:44:18 +02:00
|
|
|
if (err < 0) {
|
|
|
|
goto out;
|
|
|
|
}
|
2018-11-20 13:00:35 +01:00
|
|
|
v9fs_path_write_lock(s);
|
2011-09-09 11:44:18 +02:00
|
|
|
v9fs_path_copy(&fidp->path, &path);
|
2018-11-20 13:00:35 +01:00
|
|
|
v9fs_path_unlock(s);
|
2011-08-02 08:06:17 +02:00
|
|
|
err = v9fs_co_opendir(pdu, fidp);
|
2011-08-08 20:26:50 +02:00
|
|
|
if (err < 0) {
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
fidp->fid_type = P9_FID_DIR;
|
|
|
|
} else if (perm & P9_STAT_MODE_SYMLINK) {
|
2011-08-02 08:06:17 +02:00
|
|
|
err = v9fs_co_symlink(pdu, fidp, &name,
|
2011-05-24 11:40:56 +02:00
|
|
|
extension.data, -1 , &stbuf);
|
2011-08-08 20:26:50 +02:00
|
|
|
if (err < 0) {
|
|
|
|
goto out;
|
|
|
|
}
|
2011-08-02 08:06:17 +02:00
|
|
|
err = v9fs_co_name_to_path(pdu, &fidp->path, name.data, &path);
|
2011-09-09 11:44:18 +02:00
|
|
|
if (err < 0) {
|
|
|
|
goto out;
|
|
|
|
}
|
2018-11-20 13:00:35 +01:00
|
|
|
v9fs_path_write_lock(s);
|
2011-09-09 11:44:18 +02:00
|
|
|
v9fs_path_copy(&fidp->path, &path);
|
2018-11-20 13:00:35 +01:00
|
|
|
v9fs_path_unlock(s);
|
2011-08-08 20:26:50 +02:00
|
|
|
} else if (perm & P9_STAT_MODE_LINK) {
|
2011-09-09 11:44:18 +02:00
|
|
|
int32_t ofid = atoi(extension.data);
|
2011-08-02 08:06:17 +02:00
|
|
|
V9fsFidState *ofidp = get_fid(pdu, ofid);
|
2011-09-09 11:44:18 +02:00
|
|
|
if (ofidp == NULL) {
|
2011-08-08 20:26:50 +02:00
|
|
|
err = -EINVAL;
|
|
|
|
goto out;
|
|
|
|
}
|
2011-08-02 08:06:17 +02:00
|
|
|
err = v9fs_co_link(pdu, ofidp, fidp, &name);
|
|
|
|
put_fid(pdu, ofidp);
|
2011-09-09 11:44:18 +02:00
|
|
|
if (err < 0) {
|
|
|
|
goto out;
|
|
|
|
}
|
2011-08-02 08:06:17 +02:00
|
|
|
err = v9fs_co_name_to_path(pdu, &fidp->path, name.data, &path);
|
2011-08-08 20:26:50 +02:00
|
|
|
if (err < 0) {
|
2011-09-09 11:44:18 +02:00
|
|
|
fidp->fid_type = P9_FID_NONE;
|
2011-08-08 20:26:50 +02:00
|
|
|
goto out;
|
2010-04-29 14:14:59 +02:00
|
|
|
}
|
2018-11-20 13:00:35 +01:00
|
|
|
v9fs_path_write_lock(s);
|
2011-09-09 11:44:18 +02:00
|
|
|
v9fs_path_copy(&fidp->path, &path);
|
2018-11-20 13:00:35 +01:00
|
|
|
v9fs_path_unlock(s);
|
2011-08-02 08:06:17 +02:00
|
|
|
err = v9fs_co_lstat(pdu, &fidp->path, &stbuf);
|
2011-05-24 11:40:56 +02:00
|
|
|
if (err < 0) {
|
|
|
|
fidp->fid_type = P9_FID_NONE;
|
|
|
|
goto out;
|
|
|
|
}
|
2011-08-08 20:26:50 +02:00
|
|
|
} else if (perm & P9_STAT_MODE_DEVICE) {
|
2010-04-29 14:14:59 +02:00
|
|
|
char ctype;
|
|
|
|
uint32_t major, minor;
|
|
|
|
mode_t nmode = 0;
|
|
|
|
|
2011-08-08 20:26:50 +02:00
|
|
|
if (sscanf(extension.data, "%c %u %u", &ctype, &major, &minor) != 3) {
|
2010-04-29 14:14:59 +02:00
|
|
|
err = -errno;
|
2011-08-08 20:26:50 +02:00
|
|
|
goto out;
|
2010-04-29 14:14:59 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
switch (ctype) {
|
|
|
|
case 'c':
|
|
|
|
nmode = S_IFCHR;
|
|
|
|
break;
|
|
|
|
case 'b':
|
|
|
|
nmode = S_IFBLK;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
err = -EIO;
|
2011-08-08 20:26:50 +02:00
|
|
|
goto out;
|
|
|
|
}
|
2010-06-18 03:27:24 +02:00
|
|
|
|
2011-08-08 20:26:50 +02:00
|
|
|
nmode |= perm & 0777;
|
2011-08-02 08:06:17 +02:00
|
|
|
err = v9fs_co_mknod(pdu, fidp, &name, fidp->uid, -1,
|
2011-05-24 11:40:56 +02:00
|
|
|
makedev(major, minor), nmode, &stbuf);
|
2011-08-08 20:26:50 +02:00
|
|
|
if (err < 0) {
|
|
|
|
goto out;
|
|
|
|
}
|
2011-08-02 08:06:17 +02:00
|
|
|
err = v9fs_co_name_to_path(pdu, &fidp->path, name.data, &path);
|
2011-09-09 11:44:18 +02:00
|
|
|
if (err < 0) {
|
|
|
|
goto out;
|
|
|
|
}
|
2018-11-20 13:00:35 +01:00
|
|
|
v9fs_path_write_lock(s);
|
2011-09-09 11:44:18 +02:00
|
|
|
v9fs_path_copy(&fidp->path, &path);
|
2018-11-20 13:00:35 +01:00
|
|
|
v9fs_path_unlock(s);
|
2011-08-08 20:26:50 +02:00
|
|
|
} else if (perm & P9_STAT_MODE_NAMED_PIPE) {
|
2011-08-02 08:06:17 +02:00
|
|
|
err = v9fs_co_mknod(pdu, fidp, &name, fidp->uid, -1,
|
2011-05-24 11:40:56 +02:00
|
|
|
0, S_IFIFO | (perm & 0777), &stbuf);
|
2011-08-08 20:26:50 +02:00
|
|
|
if (err < 0) {
|
|
|
|
goto out;
|
|
|
|
}
|
2011-08-02 08:06:17 +02:00
|
|
|
err = v9fs_co_name_to_path(pdu, &fidp->path, name.data, &path);
|
2011-09-09 11:44:18 +02:00
|
|
|
if (err < 0) {
|
|
|
|
goto out;
|
|
|
|
}
|
2018-11-20 13:00:35 +01:00
|
|
|
v9fs_path_write_lock(s);
|
2011-09-09 11:44:18 +02:00
|
|
|
v9fs_path_copy(&fidp->path, &path);
|
2018-11-20 13:00:35 +01:00
|
|
|
v9fs_path_unlock(s);
|
2011-08-08 20:26:50 +02:00
|
|
|
} else if (perm & P9_STAT_MODE_SOCKET) {
|
2011-08-02 08:06:17 +02:00
|
|
|
err = v9fs_co_mknod(pdu, fidp, &name, fidp->uid, -1,
|
2011-05-24 11:40:56 +02:00
|
|
|
0, S_IFSOCK | (perm & 0777), &stbuf);
|
2011-08-08 20:26:50 +02:00
|
|
|
if (err < 0) {
|
|
|
|
goto out;
|
|
|
|
}
|
2011-08-02 08:06:17 +02:00
|
|
|
err = v9fs_co_name_to_path(pdu, &fidp->path, name.data, &path);
|
2011-09-09 11:44:18 +02:00
|
|
|
if (err < 0) {
|
|
|
|
goto out;
|
|
|
|
}
|
2018-11-20 13:00:35 +01:00
|
|
|
v9fs_path_write_lock(s);
|
2011-09-09 11:44:18 +02:00
|
|
|
v9fs_path_copy(&fidp->path, &path);
|
2018-11-20 13:00:35 +01:00
|
|
|
v9fs_path_unlock(s);
|
2011-08-08 20:26:50 +02:00
|
|
|
} else {
|
2011-08-02 08:06:17 +02:00
|
|
|
err = v9fs_co_open2(pdu, fidp, &name, -1,
|
2020-10-30 05:35:13 +01:00
|
|
|
omode_to_uflags(mode) | O_CREAT, perm, &stbuf);
|
2011-08-08 20:26:50 +02:00
|
|
|
if (err < 0) {
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
fidp->fid_type = P9_FID_FILE;
|
2011-05-18 12:10:57 +02:00
|
|
|
fidp->open_flags = omode_to_uflags(mode);
|
|
|
|
if (fidp->open_flags & O_EXCL) {
|
|
|
|
/*
|
|
|
|
* We let the host file system do O_EXCL check
|
|
|
|
* We should not reclaim such fd
|
|
|
|
*/
|
|
|
|
fidp->flags |= FID_NON_RECLAIMABLE;
|
|
|
|
}
|
2010-04-29 14:14:59 +02:00
|
|
|
}
|
2011-08-02 08:06:17 +02:00
|
|
|
iounit = get_iounit(pdu, &fidp->path);
|
2019-10-10 11:36:05 +02:00
|
|
|
err = stat_to_qid(pdu, &stbuf, &qid);
|
|
|
|
if (err < 0) {
|
|
|
|
goto out;
|
|
|
|
}
|
2011-12-14 09:19:13 +01:00
|
|
|
err = pdu_marshal(pdu, offset, "Qd", &qid, iounit);
|
|
|
|
if (err < 0) {
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
err += offset;
|
2011-10-24 11:39:49 +02:00
|
|
|
trace_v9fs_create_return(pdu->tag, pdu->id,
|
|
|
|
qid.type, qid.version, qid.path, iounit);
|
2010-04-29 14:14:59 +02:00
|
|
|
out:
|
2011-08-02 08:06:17 +02:00
|
|
|
put_fid(pdu, fidp);
|
2011-05-18 14:08:07 +02:00
|
|
|
out_nofid:
|
2015-12-02 16:00:14 +01:00
|
|
|
pdu_complete(pdu, err);
|
2011-08-08 20:26:50 +02:00
|
|
|
v9fs_string_free(&name);
|
|
|
|
v9fs_string_free(&extension);
|
2011-09-09 11:44:18 +02:00
|
|
|
v9fs_path_free(&path);
|
2010-04-29 14:14:44 +02:00
|
|
|
}
|
|
|
|
|
2016-10-17 14:13:58 +02:00
|
|
|
static void coroutine_fn v9fs_symlink(void *opaque)
|
2010-06-09 23:02:08 +02:00
|
|
|
{
|
2011-05-18 23:18:05 +02:00
|
|
|
V9fsPDU *pdu = opaque;
|
2011-08-08 20:30:01 +02:00
|
|
|
V9fsString name;
|
|
|
|
V9fsString symname;
|
|
|
|
V9fsFidState *dfidp;
|
|
|
|
V9fsQID qid;
|
|
|
|
struct stat stbuf;
|
2010-06-09 23:02:08 +02:00
|
|
|
int32_t dfid;
|
|
|
|
int err = 0;
|
|
|
|
gid_t gid;
|
2011-08-08 20:30:01 +02:00
|
|
|
size_t offset = 7;
|
2010-06-09 23:02:08 +02:00
|
|
|
|
2011-12-14 09:19:13 +01:00
|
|
|
v9fs_string_init(&name);
|
|
|
|
v9fs_string_init(&symname);
|
|
|
|
err = pdu_unmarshal(pdu, offset, "dssd", &dfid, &name, &symname, &gid);
|
|
|
|
if (err < 0) {
|
|
|
|
goto out_nofid;
|
|
|
|
}
|
2011-10-12 15:41:25 +02:00
|
|
|
trace_v9fs_symlink(pdu->tag, pdu->id, dfid, name.data, symname.data, gid);
|
2010-06-09 23:02:08 +02:00
|
|
|
|
2016-08-30 19:11:05 +02:00
|
|
|
if (name_is_illegal(name.data)) {
|
|
|
|
err = -ENOENT;
|
|
|
|
goto out_nofid;
|
|
|
|
}
|
|
|
|
|
2016-08-30 19:13:11 +02:00
|
|
|
if (!strcmp(".", name.data) || !strcmp("..", name.data)) {
|
|
|
|
err = -EEXIST;
|
|
|
|
goto out_nofid;
|
|
|
|
}
|
|
|
|
|
2011-08-02 08:06:17 +02:00
|
|
|
dfidp = get_fid(pdu, dfid);
|
2011-08-08 20:30:01 +02:00
|
|
|
if (dfidp == NULL) {
|
2010-06-09 23:02:08 +02:00
|
|
|
err = -EINVAL;
|
2011-05-18 14:08:07 +02:00
|
|
|
goto out_nofid;
|
2010-06-09 23:02:08 +02:00
|
|
|
}
|
2011-08-02 08:06:17 +02:00
|
|
|
err = v9fs_co_symlink(pdu, dfidp, &name, symname.data, gid, &stbuf);
|
2011-08-08 20:30:01 +02:00
|
|
|
if (err < 0) {
|
|
|
|
goto out;
|
|
|
|
}
|
2019-10-10 11:36:05 +02:00
|
|
|
err = stat_to_qid(pdu, &stbuf, &qid);
|
|
|
|
if (err < 0) {
|
|
|
|
goto out;
|
|
|
|
}
|
2011-12-14 09:19:13 +01:00
|
|
|
err = pdu_marshal(pdu, offset, "Q", &qid);
|
|
|
|
if (err < 0) {
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
err += offset;
|
2011-10-24 11:39:49 +02:00
|
|
|
trace_v9fs_symlink_return(pdu->tag, pdu->id,
|
|
|
|
qid.type, qid.version, qid.path);
|
2010-06-09 23:02:08 +02:00
|
|
|
out:
|
2011-08-02 08:06:17 +02:00
|
|
|
put_fid(pdu, dfidp);
|
2011-05-18 14:08:07 +02:00
|
|
|
out_nofid:
|
2015-12-02 16:00:14 +01:00
|
|
|
pdu_complete(pdu, err);
|
2011-08-08 20:30:01 +02:00
|
|
|
v9fs_string_free(&name);
|
|
|
|
v9fs_string_free(&symname);
|
2010-06-09 23:02:08 +02:00
|
|
|
}
|
|
|
|
|
2016-11-25 12:54:21 +01:00
|
|
|
static void coroutine_fn v9fs_flush(void *opaque)
|
2010-04-29 14:14:44 +02:00
|
|
|
{
|
2011-12-14 09:19:13 +01:00
|
|
|
ssize_t err;
|
2011-08-02 08:06:17 +02:00
|
|
|
int16_t tag;
|
|
|
|
size_t offset = 7;
|
9pfs: don't try to flush self and avoid QEMU hang on reset
According to the 9P spec [*], when a client wants to cancel a pending I/O
request identified by a given tag (uint16), it must send a Tflush message
and wait for the server to respond with a Rflush message before reusing this
tag for another I/O. The server may still send a completion message for the
I/O if it wasn't actually cancelled but the Rflush message must arrive after
that.
QEMU hence waits for the flushed PDU to complete before sending the Rflush
message back to the client.
If a client sends 'Tflush tag oldtag' and tag == oldtag, QEMU will then
allocate a PDU identified by tag, find it in the PDU list and wait for
this same PDU to complete... i.e. wait for a completion that will never
happen. This causes a tag and ring slot leak in the guest, and a PDU
leak in QEMU, all of them limited by the maximal number of PDUs (128).
But, worse, this causes QEMU to hang on device reset since v9fs_reset()
wants to drain all pending I/O.
This insane behavior is likely to denote a bug in the client, and it would
deserve an Rerror message to be sent back. Unfortunately, the protocol
allows it and requires all flush requests to suceed (only a Tflush response
is expected).
The only option is to detect when we have to handle a self-referencing
flush request and report success to the client right away.
[*] http://man.cat-v.org/plan_9/5/flush
Reported-by: Al Viro <viro@ZenIV.linux.org.uk>
Signed-off-by: Greg Kurz <groug@kaod.org>
2017-03-21 09:12:47 +01:00
|
|
|
V9fsPDU *cancel_pdu = NULL;
|
2011-05-18 23:18:05 +02:00
|
|
|
V9fsPDU *pdu = opaque;
|
|
|
|
V9fsState *s = pdu->s;
|
2011-08-02 08:06:17 +02:00
|
|
|
|
2011-12-14 09:19:13 +01:00
|
|
|
err = pdu_unmarshal(pdu, offset, "w", &tag);
|
|
|
|
if (err < 0) {
|
2015-12-02 16:00:14 +01:00
|
|
|
pdu_complete(pdu, err);
|
2011-12-14 09:19:13 +01:00
|
|
|
return;
|
|
|
|
}
|
2011-10-12 15:41:25 +02:00
|
|
|
trace_v9fs_flush(pdu->tag, pdu->id, tag);
|
2011-08-02 08:06:17 +02:00
|
|
|
|
9pfs: don't try to flush self and avoid QEMU hang on reset
According to the 9P spec [*], when a client wants to cancel a pending I/O
request identified by a given tag (uint16), it must send a Tflush message
and wait for the server to respond with a Rflush message before reusing this
tag for another I/O. The server may still send a completion message for the
I/O if it wasn't actually cancelled but the Rflush message must arrive after
that.
QEMU hence waits for the flushed PDU to complete before sending the Rflush
message back to the client.
If a client sends 'Tflush tag oldtag' and tag == oldtag, QEMU will then
allocate a PDU identified by tag, find it in the PDU list and wait for
this same PDU to complete... i.e. wait for a completion that will never
happen. This causes a tag and ring slot leak in the guest, and a PDU
leak in QEMU, all of them limited by the maximal number of PDUs (128).
But, worse, this causes QEMU to hang on device reset since v9fs_reset()
wants to drain all pending I/O.
This insane behavior is likely to denote a bug in the client, and it would
deserve an Rerror message to be sent back. Unfortunately, the protocol
allows it and requires all flush requests to suceed (only a Tflush response
is expected).
The only option is to detect when we have to handle a self-referencing
flush request and report success to the client right away.
[*] http://man.cat-v.org/plan_9/5/flush
Reported-by: Al Viro <viro@ZenIV.linux.org.uk>
Signed-off-by: Greg Kurz <groug@kaod.org>
2017-03-21 09:12:47 +01:00
|
|
|
if (pdu->tag == tag) {
|
2017-07-12 15:57:41 +02:00
|
|
|
warn_report("the guest sent a self-referencing 9P flush request");
|
9pfs: don't try to flush self and avoid QEMU hang on reset
According to the 9P spec [*], when a client wants to cancel a pending I/O
request identified by a given tag (uint16), it must send a Tflush message
and wait for the server to respond with a Rflush message before reusing this
tag for another I/O. The server may still send a completion message for the
I/O if it wasn't actually cancelled but the Rflush message must arrive after
that.
QEMU hence waits for the flushed PDU to complete before sending the Rflush
message back to the client.
If a client sends 'Tflush tag oldtag' and tag == oldtag, QEMU will then
allocate a PDU identified by tag, find it in the PDU list and wait for
this same PDU to complete... i.e. wait for a completion that will never
happen. This causes a tag and ring slot leak in the guest, and a PDU
leak in QEMU, all of them limited by the maximal number of PDUs (128).
But, worse, this causes QEMU to hang on device reset since v9fs_reset()
wants to drain all pending I/O.
This insane behavior is likely to denote a bug in the client, and it would
deserve an Rerror message to be sent back. Unfortunately, the protocol
allows it and requires all flush requests to suceed (only a Tflush response
is expected).
The only option is to detect when we have to handle a self-referencing
flush request and report success to the client right away.
[*] http://man.cat-v.org/plan_9/5/flush
Reported-by: Al Viro <viro@ZenIV.linux.org.uk>
Signed-off-by: Greg Kurz <groug@kaod.org>
2017-03-21 09:12:47 +01:00
|
|
|
} else {
|
|
|
|
QLIST_FOREACH(cancel_pdu, &s->active_list, next) {
|
|
|
|
if (cancel_pdu->tag == tag) {
|
|
|
|
break;
|
|
|
|
}
|
2011-08-02 08:06:17 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
if (cancel_pdu) {
|
|
|
|
cancel_pdu->cancelled = 1;
|
|
|
|
/*
|
|
|
|
* Wait for pdu to complete.
|
|
|
|
*/
|
2017-02-13 19:12:43 +01:00
|
|
|
qemu_co_queue_wait(&cancel_pdu->complete, NULL);
|
2017-04-04 18:06:01 +02:00
|
|
|
if (!qemu_co_queue_next(&cancel_pdu->complete)) {
|
|
|
|
cancel_pdu->cancelled = 0;
|
|
|
|
pdu_free(cancel_pdu);
|
|
|
|
}
|
2011-08-02 08:06:17 +02:00
|
|
|
}
|
2015-12-02 16:00:14 +01:00
|
|
|
pdu_complete(pdu, 7);
|
2010-04-29 14:14:44 +02:00
|
|
|
}
|
|
|
|
|
2016-10-17 14:13:58 +02:00
|
|
|
static void coroutine_fn v9fs_link(void *opaque)
|
2010-06-09 20:21:15 +02:00
|
|
|
{
|
2011-05-18 23:18:05 +02:00
|
|
|
V9fsPDU *pdu = opaque;
|
2010-06-09 20:21:15 +02:00
|
|
|
int32_t dfid, oldfid;
|
|
|
|
V9fsFidState *dfidp, *oldfidp;
|
2011-11-29 09:52:38 +01:00
|
|
|
V9fsString name;
|
2010-06-09 20:21:15 +02:00
|
|
|
size_t offset = 7;
|
|
|
|
int err = 0;
|
|
|
|
|
2011-12-14 09:19:13 +01:00
|
|
|
v9fs_string_init(&name);
|
|
|
|
err = pdu_unmarshal(pdu, offset, "dds", &dfid, &oldfid, &name);
|
|
|
|
if (err < 0) {
|
|
|
|
goto out_nofid;
|
|
|
|
}
|
2011-10-12 15:41:25 +02:00
|
|
|
trace_v9fs_link(pdu->tag, pdu->id, dfid, oldfid, name.data);
|
2010-06-09 20:21:15 +02:00
|
|
|
|
2016-08-30 19:11:05 +02:00
|
|
|
if (name_is_illegal(name.data)) {
|
|
|
|
err = -ENOENT;
|
|
|
|
goto out_nofid;
|
|
|
|
}
|
|
|
|
|
2016-08-30 19:13:11 +02:00
|
|
|
if (!strcmp(".", name.data) || !strcmp("..", name.data)) {
|
|
|
|
err = -EEXIST;
|
|
|
|
goto out_nofid;
|
|
|
|
}
|
|
|
|
|
2011-08-02 08:06:17 +02:00
|
|
|
dfidp = get_fid(pdu, dfid);
|
2010-06-09 20:21:15 +02:00
|
|
|
if (dfidp == NULL) {
|
2011-05-09 20:47:28 +02:00
|
|
|
err = -ENOENT;
|
2011-05-18 14:08:07 +02:00
|
|
|
goto out_nofid;
|
2010-06-09 20:21:15 +02:00
|
|
|
}
|
|
|
|
|
2011-08-02 08:06:17 +02:00
|
|
|
oldfidp = get_fid(pdu, oldfid);
|
2010-06-09 20:21:15 +02:00
|
|
|
if (oldfidp == NULL) {
|
2011-05-09 20:47:28 +02:00
|
|
|
err = -ENOENT;
|
2010-06-09 20:21:15 +02:00
|
|
|
goto out;
|
|
|
|
}
|
2011-08-02 08:06:17 +02:00
|
|
|
err = v9fs_co_link(pdu, oldfidp, dfidp, &name);
|
2011-05-09 20:47:28 +02:00
|
|
|
if (!err) {
|
|
|
|
err = offset;
|
2010-06-09 20:21:15 +02:00
|
|
|
}
|
2016-10-17 14:13:58 +02:00
|
|
|
put_fid(pdu, oldfidp);
|
2010-06-09 20:21:15 +02:00
|
|
|
out:
|
2011-08-02 08:06:17 +02:00
|
|
|
put_fid(pdu, dfidp);
|
2011-05-18 14:08:07 +02:00
|
|
|
out_nofid:
|
2010-06-09 20:21:15 +02:00
|
|
|
v9fs_string_free(&name);
|
2015-12-02 16:00:14 +01:00
|
|
|
pdu_complete(pdu, err);
|
2010-06-09 20:21:15 +02:00
|
|
|
}
|
|
|
|
|
2011-08-02 08:05:54 +02:00
|
|
|
/* Only works with path name based fid */
|
2016-10-17 14:13:58 +02:00
|
|
|
static void coroutine_fn v9fs_remove(void *opaque)
|
2010-04-29 14:14:44 +02:00
|
|
|
{
|
2010-04-29 14:15:01 +02:00
|
|
|
int32_t fid;
|
|
|
|
int err = 0;
|
2011-08-08 20:20:20 +02:00
|
|
|
size_t offset = 7;
|
|
|
|
V9fsFidState *fidp;
|
|
|
|
V9fsPDU *pdu = opaque;
|
2010-04-29 14:15:01 +02:00
|
|
|
|
2011-12-14 09:19:13 +01:00
|
|
|
err = pdu_unmarshal(pdu, offset, "d", &fid);
|
|
|
|
if (err < 0) {
|
|
|
|
goto out_nofid;
|
|
|
|
}
|
2011-10-12 15:41:25 +02:00
|
|
|
trace_v9fs_remove(pdu->tag, pdu->id, fid);
|
2010-04-29 14:15:01 +02:00
|
|
|
|
2011-08-02 08:06:17 +02:00
|
|
|
fidp = get_fid(pdu, fid);
|
2011-08-08 20:20:20 +02:00
|
|
|
if (fidp == NULL) {
|
2010-04-29 14:15:01 +02:00
|
|
|
err = -EINVAL;
|
2011-05-18 14:08:07 +02:00
|
|
|
goto out_nofid;
|
2010-04-29 14:14:44 +02:00
|
|
|
}
|
2011-08-02 08:05:54 +02:00
|
|
|
/* if fs driver is not path based, return EOPNOTSUPP */
|
2011-10-12 17:29:18 +02:00
|
|
|
if (!(pdu->s->ctx.export_flags & V9FS_PATHNAME_FSCONTEXT)) {
|
2011-08-02 08:05:54 +02:00
|
|
|
err = -EOPNOTSUPP;
|
|
|
|
goto out_err;
|
|
|
|
}
|
2011-05-18 12:10:57 +02:00
|
|
|
/*
|
|
|
|
* IF the file is unlinked, we cannot reopen
|
|
|
|
* the file later. So don't reclaim fd
|
|
|
|
*/
|
2011-08-02 08:06:17 +02:00
|
|
|
err = v9fs_mark_fids_unreclaim(pdu, &fidp->path);
|
2011-05-18 12:10:57 +02:00
|
|
|
if (err < 0) {
|
|
|
|
goto out_err;
|
|
|
|
}
|
2011-08-02 08:06:17 +02:00
|
|
|
err = v9fs_co_remove(pdu, &fidp->path);
|
2011-08-08 20:20:20 +02:00
|
|
|
if (!err) {
|
|
|
|
err = offset;
|
|
|
|
}
|
2011-05-18 12:10:57 +02:00
|
|
|
out_err:
|
2011-08-08 20:20:20 +02:00
|
|
|
/* For TREMOVE we need to clunk the fid even on failed remove */
|
2011-05-18 14:08:07 +02:00
|
|
|
clunk_fid(pdu->s, fidp->fid);
|
2011-08-02 08:06:17 +02:00
|
|
|
put_fid(pdu, fidp);
|
2011-05-18 14:08:07 +02:00
|
|
|
out_nofid:
|
2015-12-02 16:00:14 +01:00
|
|
|
pdu_complete(pdu, err);
|
2010-04-29 14:14:44 +02:00
|
|
|
}
|
|
|
|
|
2016-10-17 14:13:58 +02:00
|
|
|
static void coroutine_fn v9fs_unlinkat(void *opaque)
|
2011-09-09 11:37:01 +02:00
|
|
|
{
|
|
|
|
int err = 0;
|
|
|
|
V9fsString name;
|
2018-06-07 12:17:22 +02:00
|
|
|
int32_t dfid, flags, rflags = 0;
|
2011-09-09 11:37:01 +02:00
|
|
|
size_t offset = 7;
|
2011-09-09 11:44:18 +02:00
|
|
|
V9fsPath path;
|
2011-09-09 11:37:01 +02:00
|
|
|
V9fsFidState *dfidp;
|
|
|
|
V9fsPDU *pdu = opaque;
|
|
|
|
|
2011-12-14 09:19:13 +01:00
|
|
|
v9fs_string_init(&name);
|
|
|
|
err = pdu_unmarshal(pdu, offset, "dsd", &dfid, &name, &flags);
|
|
|
|
if (err < 0) {
|
|
|
|
goto out_nofid;
|
|
|
|
}
|
2016-08-30 19:11:05 +02:00
|
|
|
|
|
|
|
if (name_is_illegal(name.data)) {
|
|
|
|
err = -ENOENT;
|
|
|
|
goto out_nofid;
|
|
|
|
}
|
|
|
|
|
2016-08-30 19:13:11 +02:00
|
|
|
if (!strcmp(".", name.data)) {
|
|
|
|
err = -EINVAL;
|
|
|
|
goto out_nofid;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!strcmp("..", name.data)) {
|
|
|
|
err = -ENOTEMPTY;
|
|
|
|
goto out_nofid;
|
|
|
|
}
|
|
|
|
|
2018-06-07 12:17:22 +02:00
|
|
|
if (flags & ~P9_DOTL_AT_REMOVEDIR) {
|
|
|
|
err = -EINVAL;
|
|
|
|
goto out_nofid;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (flags & P9_DOTL_AT_REMOVEDIR) {
|
|
|
|
rflags |= AT_REMOVEDIR;
|
|
|
|
}
|
|
|
|
|
2011-08-02 08:06:17 +02:00
|
|
|
dfidp = get_fid(pdu, dfid);
|
2011-09-09 11:37:01 +02:00
|
|
|
if (dfidp == NULL) {
|
|
|
|
err = -EINVAL;
|
|
|
|
goto out_nofid;
|
|
|
|
}
|
|
|
|
/*
|
|
|
|
* IF the file is unlinked, we cannot reopen
|
|
|
|
* the file later. So don't reclaim fd
|
|
|
|
*/
|
2011-09-09 11:44:18 +02:00
|
|
|
v9fs_path_init(&path);
|
2011-08-02 08:06:17 +02:00
|
|
|
err = v9fs_co_name_to_path(pdu, &dfidp->path, name.data, &path);
|
2011-09-09 11:44:18 +02:00
|
|
|
if (err < 0) {
|
|
|
|
goto out_err;
|
|
|
|
}
|
2011-08-02 08:06:17 +02:00
|
|
|
err = v9fs_mark_fids_unreclaim(pdu, &path);
|
2011-09-09 11:37:01 +02:00
|
|
|
if (err < 0) {
|
|
|
|
goto out_err;
|
|
|
|
}
|
2018-06-07 12:17:22 +02:00
|
|
|
err = v9fs_co_unlinkat(pdu, &dfidp->path, &name, rflags);
|
2011-09-09 11:37:01 +02:00
|
|
|
if (!err) {
|
|
|
|
err = offset;
|
|
|
|
}
|
|
|
|
out_err:
|
2011-08-02 08:06:17 +02:00
|
|
|
put_fid(pdu, dfidp);
|
2011-09-09 11:44:18 +02:00
|
|
|
v9fs_path_free(&path);
|
2011-09-09 11:37:01 +02:00
|
|
|
out_nofid:
|
2015-12-02 16:00:14 +01:00
|
|
|
pdu_complete(pdu, err);
|
2011-09-09 11:37:01 +02:00
|
|
|
v9fs_string_free(&name);
|
|
|
|
}
|
|
|
|
|
2011-09-09 11:44:18 +02:00
|
|
|
|
|
|
|
/* Only works with path name based fid */
|
2016-10-17 14:13:58 +02:00
|
|
|
static int coroutine_fn v9fs_complete_rename(V9fsPDU *pdu, V9fsFidState *fidp,
|
|
|
|
int32_t newdirfid,
|
|
|
|
V9fsString *name)
|
2010-04-29 14:15:00 +02:00
|
|
|
{
|
2010-06-22 08:59:41 +02:00
|
|
|
int err = 0;
|
2011-09-09 11:44:18 +02:00
|
|
|
V9fsPath new_path;
|
|
|
|
V9fsFidState *tfidp;
|
2011-08-02 08:06:17 +02:00
|
|
|
V9fsState *s = pdu->s;
|
2011-05-18 14:08:07 +02:00
|
|
|
V9fsFidState *dirfidp = NULL;
|
2010-04-29 14:15:00 +02:00
|
|
|
|
2011-09-09 11:44:18 +02:00
|
|
|
v9fs_path_init(&new_path);
|
2011-05-07 12:31:33 +02:00
|
|
|
if (newdirfid != -1) {
|
2011-08-02 08:06:17 +02:00
|
|
|
dirfidp = get_fid(pdu, newdirfid);
|
2010-06-22 08:59:41 +02:00
|
|
|
if (dirfidp == NULL) {
|
2020-01-20 15:11:39 +01:00
|
|
|
return -ENOENT;
|
2010-06-22 08:59:41 +02:00
|
|
|
}
|
2016-11-01 12:00:40 +01:00
|
|
|
if (fidp->fid_type != P9_FID_NONE) {
|
|
|
|
err = -EINVAL;
|
|
|
|
goto out;
|
|
|
|
}
|
2017-05-25 10:30:14 +02:00
|
|
|
err = v9fs_co_name_to_path(pdu, &dirfidp->path, name->data, &new_path);
|
|
|
|
if (err < 0) {
|
|
|
|
goto out;
|
|
|
|
}
|
2010-06-22 08:59:41 +02:00
|
|
|
} else {
|
2017-09-20 08:48:52 +02:00
|
|
|
char *dir_name = g_path_get_dirname(fidp->path.data);
|
|
|
|
V9fsPath dir_path;
|
|
|
|
|
|
|
|
v9fs_path_init(&dir_path);
|
|
|
|
v9fs_path_sprintf(&dir_path, "%s", dir_name);
|
|
|
|
g_free(dir_name);
|
|
|
|
|
|
|
|
err = v9fs_co_name_to_path(pdu, &dir_path, name->data, &new_path);
|
|
|
|
v9fs_path_free(&dir_path);
|
2017-05-25 10:30:14 +02:00
|
|
|
if (err < 0) {
|
|
|
|
goto out;
|
|
|
|
}
|
2010-06-22 08:59:41 +02:00
|
|
|
}
|
2011-08-02 08:06:17 +02:00
|
|
|
err = v9fs_co_rename(pdu, &fidp->path, &new_path);
|
2011-09-09 11:44:18 +02:00
|
|
|
if (err < 0) {
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
/*
|
|
|
|
* Fixup fid's pointing to the old name to
|
|
|
|
* start pointing to the new name
|
|
|
|
*/
|
2021-01-18 15:22:59 +01:00
|
|
|
QSIMPLEQ_FOREACH(tfidp, &s->fid_list, next) {
|
2011-09-09 11:44:18 +02:00
|
|
|
if (v9fs_path_is_ancestor(&fidp->path, &tfidp->path)) {
|
|
|
|
/* replace the name */
|
|
|
|
v9fs_fix_path(&tfidp->path, &new_path, strlen(fidp->path.data));
|
2010-04-29 14:15:00 +02:00
|
|
|
}
|
|
|
|
}
|
2010-06-22 08:59:41 +02:00
|
|
|
out:
|
2011-05-18 14:08:07 +02:00
|
|
|
if (dirfidp) {
|
2011-08-02 08:06:17 +02:00
|
|
|
put_fid(pdu, dirfidp);
|
2011-05-18 14:08:07 +02:00
|
|
|
}
|
2011-09-09 11:44:18 +02:00
|
|
|
v9fs_path_free(&new_path);
|
2010-06-22 08:59:41 +02:00
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
2011-08-02 08:05:54 +02:00
|
|
|
/* Only works with path name based fid */
|
2016-10-17 14:13:58 +02:00
|
|
|
static void coroutine_fn v9fs_rename(void *opaque)
|
2010-06-22 08:59:41 +02:00
|
|
|
{
|
|
|
|
int32_t fid;
|
|
|
|
ssize_t err = 0;
|
2011-05-07 12:31:33 +02:00
|
|
|
size_t offset = 7;
|
|
|
|
V9fsString name;
|
|
|
|
int32_t newdirfid;
|
|
|
|
V9fsFidState *fidp;
|
|
|
|
V9fsPDU *pdu = opaque;
|
|
|
|
V9fsState *s = pdu->s;
|
2010-06-22 08:59:41 +02:00
|
|
|
|
2011-12-14 09:19:13 +01:00
|
|
|
v9fs_string_init(&name);
|
|
|
|
err = pdu_unmarshal(pdu, offset, "dds", &fid, &newdirfid, &name);
|
|
|
|
if (err < 0) {
|
|
|
|
goto out_nofid;
|
|
|
|
}
|
2016-08-30 19:11:05 +02:00
|
|
|
|
|
|
|
if (name_is_illegal(name.data)) {
|
|
|
|
err = -ENOENT;
|
|
|
|
goto out_nofid;
|
|
|
|
}
|
|
|
|
|
2016-08-30 19:13:11 +02:00
|
|
|
if (!strcmp(".", name.data) || !strcmp("..", name.data)) {
|
|
|
|
err = -EISDIR;
|
|
|
|
goto out_nofid;
|
|
|
|
}
|
|
|
|
|
2011-08-02 08:06:17 +02:00
|
|
|
fidp = get_fid(pdu, fid);
|
2011-05-07 12:31:33 +02:00
|
|
|
if (fidp == NULL) {
|
2010-06-22 08:59:41 +02:00
|
|
|
err = -ENOENT;
|
2011-05-18 14:08:07 +02:00
|
|
|
goto out_nofid;
|
2010-06-22 08:59:41 +02:00
|
|
|
}
|
2016-11-01 12:00:40 +01:00
|
|
|
if (fidp->fid_type != P9_FID_NONE) {
|
|
|
|
err = -EINVAL;
|
|
|
|
goto out;
|
|
|
|
}
|
2011-08-02 08:05:54 +02:00
|
|
|
/* if fs driver is not path based, return EOPNOTSUPP */
|
2011-10-12 17:29:18 +02:00
|
|
|
if (!(pdu->s->ctx.export_flags & V9FS_PATHNAME_FSCONTEXT)) {
|
2011-08-02 08:05:54 +02:00
|
|
|
err = -EOPNOTSUPP;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
v9fs_path_write_lock(s);
|
2011-08-02 08:06:17 +02:00
|
|
|
err = v9fs_complete_rename(pdu, fidp, newdirfid, &name);
|
2011-08-02 08:05:54 +02:00
|
|
|
v9fs_path_unlock(s);
|
2011-05-07 12:31:33 +02:00
|
|
|
if (!err) {
|
|
|
|
err = offset;
|
|
|
|
}
|
2011-08-02 08:05:54 +02:00
|
|
|
out:
|
2011-08-02 08:06:17 +02:00
|
|
|
put_fid(pdu, fidp);
|
2011-05-18 14:08:07 +02:00
|
|
|
out_nofid:
|
2015-12-02 16:00:14 +01:00
|
|
|
pdu_complete(pdu, err);
|
2011-05-07 12:31:33 +02:00
|
|
|
v9fs_string_free(&name);
|
2010-06-22 08:59:41 +02:00
|
|
|
}
|
|
|
|
|
2017-05-25 10:30:14 +02:00
|
|
|
static int coroutine_fn v9fs_fix_fid_paths(V9fsPDU *pdu, V9fsPath *olddir,
|
|
|
|
V9fsString *old_name,
|
|
|
|
V9fsPath *newdir,
|
|
|
|
V9fsString *new_name)
|
2011-09-09 11:44:18 +02:00
|
|
|
{
|
|
|
|
V9fsFidState *tfidp;
|
|
|
|
V9fsPath oldpath, newpath;
|
2011-08-02 08:06:17 +02:00
|
|
|
V9fsState *s = pdu->s;
|
2017-05-25 10:30:14 +02:00
|
|
|
int err;
|
2011-09-09 11:44:18 +02:00
|
|
|
|
|
|
|
v9fs_path_init(&oldpath);
|
|
|
|
v9fs_path_init(&newpath);
|
2017-05-25 10:30:14 +02:00
|
|
|
err = v9fs_co_name_to_path(pdu, olddir, old_name->data, &oldpath);
|
|
|
|
if (err < 0) {
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
err = v9fs_co_name_to_path(pdu, newdir, new_name->data, &newpath);
|
|
|
|
if (err < 0) {
|
|
|
|
goto out;
|
|
|
|
}
|
2011-09-09 11:44:18 +02:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Fixup fid's pointing to the old name to
|
|
|
|
* start pointing to the new name
|
|
|
|
*/
|
2021-01-18 15:22:59 +01:00
|
|
|
QSIMPLEQ_FOREACH(tfidp, &s->fid_list, next) {
|
2011-09-09 11:44:18 +02:00
|
|
|
if (v9fs_path_is_ancestor(&oldpath, &tfidp->path)) {
|
|
|
|
/* replace the name */
|
|
|
|
v9fs_fix_path(&tfidp->path, &newpath, strlen(oldpath.data));
|
|
|
|
}
|
|
|
|
}
|
2017-05-25 10:30:14 +02:00
|
|
|
out:
|
2011-09-09 11:44:18 +02:00
|
|
|
v9fs_path_free(&oldpath);
|
|
|
|
v9fs_path_free(&newpath);
|
2017-05-25 10:30:14 +02:00
|
|
|
return err;
|
2011-09-09 11:44:18 +02:00
|
|
|
}
|
|
|
|
|
2016-10-17 14:13:58 +02:00
|
|
|
static int coroutine_fn v9fs_complete_renameat(V9fsPDU *pdu, int32_t olddirfid,
|
|
|
|
V9fsString *old_name,
|
|
|
|
int32_t newdirfid,
|
|
|
|
V9fsString *new_name)
|
2011-05-23 19:54:41 +02:00
|
|
|
{
|
|
|
|
int err = 0;
|
2011-08-02 08:06:17 +02:00
|
|
|
V9fsState *s = pdu->s;
|
2011-05-23 19:54:41 +02:00
|
|
|
V9fsFidState *newdirfidp = NULL, *olddirfidp = NULL;
|
|
|
|
|
2011-08-02 08:06:17 +02:00
|
|
|
olddirfidp = get_fid(pdu, olddirfid);
|
2011-05-23 19:54:41 +02:00
|
|
|
if (olddirfidp == NULL) {
|
|
|
|
err = -ENOENT;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
if (newdirfid != -1) {
|
2011-08-02 08:06:17 +02:00
|
|
|
newdirfidp = get_fid(pdu, newdirfid);
|
2011-05-23 19:54:41 +02:00
|
|
|
if (newdirfidp == NULL) {
|
|
|
|
err = -ENOENT;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
} else {
|
2011-08-02 08:06:17 +02:00
|
|
|
newdirfidp = get_fid(pdu, olddirfid);
|
2011-05-23 19:54:41 +02:00
|
|
|
}
|
|
|
|
|
2011-08-02 08:06:17 +02:00
|
|
|
err = v9fs_co_renameat(pdu, &olddirfidp->path, old_name,
|
2011-09-09 11:44:18 +02:00
|
|
|
&newdirfidp->path, new_name);
|
|
|
|
if (err < 0) {
|
|
|
|
goto out;
|
2011-05-23 19:54:41 +02:00
|
|
|
}
|
2011-10-12 17:29:18 +02:00
|
|
|
if (s->ctx.export_flags & V9FS_PATHNAME_FSCONTEXT) {
|
2011-08-02 08:05:54 +02:00
|
|
|
/* Only for path based fid we need to do the below fixup */
|
2017-05-25 10:30:14 +02:00
|
|
|
err = v9fs_fix_fid_paths(pdu, &olddirfidp->path, old_name,
|
|
|
|
&newdirfidp->path, new_name);
|
2011-08-02 08:05:54 +02:00
|
|
|
}
|
2011-05-23 19:54:41 +02:00
|
|
|
out:
|
|
|
|
if (olddirfidp) {
|
2011-08-02 08:06:17 +02:00
|
|
|
put_fid(pdu, olddirfidp);
|
2011-05-23 19:54:41 +02:00
|
|
|
}
|
|
|
|
if (newdirfidp) {
|
2011-08-02 08:06:17 +02:00
|
|
|
put_fid(pdu, newdirfidp);
|
2011-05-23 19:54:41 +02:00
|
|
|
}
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
2016-10-17 14:13:58 +02:00
|
|
|
static void coroutine_fn v9fs_renameat(void *opaque)
|
2011-05-23 19:54:41 +02:00
|
|
|
{
|
|
|
|
ssize_t err = 0;
|
|
|
|
size_t offset = 7;
|
|
|
|
V9fsPDU *pdu = opaque;
|
|
|
|
V9fsState *s = pdu->s;
|
|
|
|
int32_t olddirfid, newdirfid;
|
|
|
|
V9fsString old_name, new_name;
|
|
|
|
|
2011-12-14 09:19:13 +01:00
|
|
|
v9fs_string_init(&old_name);
|
|
|
|
v9fs_string_init(&new_name);
|
|
|
|
err = pdu_unmarshal(pdu, offset, "dsds", &olddirfid,
|
|
|
|
&old_name, &newdirfid, &new_name);
|
|
|
|
if (err < 0) {
|
|
|
|
goto out_err;
|
|
|
|
}
|
2011-05-23 19:54:41 +02:00
|
|
|
|
2016-08-30 19:11:05 +02:00
|
|
|
if (name_is_illegal(old_name.data) || name_is_illegal(new_name.data)) {
|
|
|
|
err = -ENOENT;
|
|
|
|
goto out_err;
|
|
|
|
}
|
|
|
|
|
2016-08-30 19:13:11 +02:00
|
|
|
if (!strcmp(".", old_name.data) || !strcmp("..", old_name.data) ||
|
|
|
|
!strcmp(".", new_name.data) || !strcmp("..", new_name.data)) {
|
|
|
|
err = -EISDIR;
|
|
|
|
goto out_err;
|
|
|
|
}
|
|
|
|
|
2011-08-02 08:05:54 +02:00
|
|
|
v9fs_path_write_lock(s);
|
2011-08-02 08:06:17 +02:00
|
|
|
err = v9fs_complete_renameat(pdu, olddirfid,
|
|
|
|
&old_name, newdirfid, &new_name);
|
2011-08-02 08:05:54 +02:00
|
|
|
v9fs_path_unlock(s);
|
2011-05-23 19:54:41 +02:00
|
|
|
if (!err) {
|
|
|
|
err = offset;
|
|
|
|
}
|
2011-12-14 09:19:13 +01:00
|
|
|
|
|
|
|
out_err:
|
2015-12-02 16:00:14 +01:00
|
|
|
pdu_complete(pdu, err);
|
2011-05-23 19:54:41 +02:00
|
|
|
v9fs_string_free(&old_name);
|
|
|
|
v9fs_string_free(&new_name);
|
|
|
|
}
|
|
|
|
|
2016-10-17 14:13:58 +02:00
|
|
|
static void coroutine_fn v9fs_wstat(void *opaque)
|
2010-04-29 14:15:00 +02:00
|
|
|
{
|
2011-05-08 09:36:04 +02:00
|
|
|
int32_t fid;
|
|
|
|
int err = 0;
|
|
|
|
int16_t unused;
|
|
|
|
V9fsStat v9stat;
|
|
|
|
size_t offset = 7;
|
|
|
|
struct stat stbuf;
|
|
|
|
V9fsFidState *fidp;
|
|
|
|
V9fsPDU *pdu = opaque;
|
9p: fix QEMU crash when renaming files
When using the 9P2000.u version of the protocol, the following shell
command line in the guest can cause QEMU to crash:
while true; do rm -rf aa; mkdir -p a/b & touch a/b/c & mv a aa; done
With 9P2000.u, file renaming is handled by the WSTAT command. The
v9fs_wstat() function calls v9fs_complete_rename(), which calls
v9fs_fix_path() for every fid whose path is affected by the change.
The involved calls to v9fs_path_copy() may race with any other access
to the fid path performed by some worker thread, causing a crash like
shown below:
Thread 12 "qemu-system-x86" received signal SIGSEGV, Segmentation fault.
0x0000555555a25da2 in local_open_nofollow (fs_ctx=0x555557d958b8, path=0x0,
flags=65536, mode=0) at hw/9pfs/9p-local.c:59
59 while (*path && fd != -1) {
(gdb) bt
#0 0x0000555555a25da2 in local_open_nofollow (fs_ctx=0x555557d958b8,
path=0x0, flags=65536, mode=0) at hw/9pfs/9p-local.c:59
#1 0x0000555555a25e0c in local_opendir_nofollow (fs_ctx=0x555557d958b8,
path=0x0) at hw/9pfs/9p-local.c:92
#2 0x0000555555a261b8 in local_lstat (fs_ctx=0x555557d958b8,
fs_path=0x555556b56858, stbuf=0x7fff84830ef0) at hw/9pfs/9p-local.c:185
#3 0x0000555555a2b367 in v9fs_co_lstat (pdu=0x555557d97498,
path=0x555556b56858, stbuf=0x7fff84830ef0) at hw/9pfs/cofile.c:53
#4 0x0000555555a1e9e2 in v9fs_stat (opaque=0x555557d97498)
at hw/9pfs/9p.c:1083
#5 0x0000555555e060a2 in coroutine_trampoline (i0=-669165424, i1=32767)
at util/coroutine-ucontext.c:116
#6 0x00007fffef4f5600 in __start_context () at /lib64/libc.so.6
#7 0x0000000000000000 in ()
(gdb)
The fix is to take the path write lock when calling v9fs_complete_rename(),
like in v9fs_rename().
Impact: DoS triggered by unprivileged guest users.
Fixes: CVE-2018-19489
Cc: P J P <ppandit@redhat.com>
Reported-by: zhibin hu <noirfate@gmail.com>
Reviewed-by: Prasad J Pandit <pjp@fedoraproject.org>
Signed-off-by: Greg Kurz <groug@kaod.org>
2018-11-23 13:28:03 +01:00
|
|
|
V9fsState *s = pdu->s;
|
2010-04-29 14:15:00 +02:00
|
|
|
|
2011-12-14 09:19:13 +01:00
|
|
|
v9fs_stat_init(&v9stat);
|
|
|
|
err = pdu_unmarshal(pdu, offset, "dwS", &fid, &unused, &v9stat);
|
|
|
|
if (err < 0) {
|
|
|
|
goto out_nofid;
|
|
|
|
}
|
2011-10-12 15:41:25 +02:00
|
|
|
trace_v9fs_wstat(pdu->tag, pdu->id, fid,
|
|
|
|
v9stat.mode, v9stat.atime, v9stat.mtime);
|
2011-05-18 14:08:07 +02:00
|
|
|
|
2011-08-02 08:06:17 +02:00
|
|
|
fidp = get_fid(pdu, fid);
|
2011-05-08 09:36:04 +02:00
|
|
|
if (fidp == NULL) {
|
|
|
|
err = -EINVAL;
|
2011-05-18 14:08:07 +02:00
|
|
|
goto out_nofid;
|
2010-04-29 14:15:00 +02:00
|
|
|
}
|
2011-05-08 09:36:04 +02:00
|
|
|
/* do we need to sync the file? */
|
|
|
|
if (donttouch_stat(&v9stat)) {
|
2011-08-02 08:06:17 +02:00
|
|
|
err = v9fs_co_fsync(pdu, fidp, 0);
|
2010-04-29 14:15:00 +02:00
|
|
|
goto out;
|
|
|
|
}
|
2011-05-08 09:36:04 +02:00
|
|
|
if (v9stat.mode != -1) {
|
|
|
|
uint32_t v9_mode;
|
2011-08-02 08:06:17 +02:00
|
|
|
err = v9fs_co_lstat(pdu, &fidp->path, &stbuf);
|
2011-05-08 09:36:04 +02:00
|
|
|
if (err < 0) {
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
v9_mode = stat_to_v9mode(&stbuf);
|
|
|
|
if ((v9stat.mode & P9_STAT_MODE_TYPE_BITS) !=
|
|
|
|
(v9_mode & P9_STAT_MODE_TYPE_BITS)) {
|
|
|
|
/* Attempting to change the type */
|
|
|
|
err = -EIO;
|
|
|
|
goto out;
|
|
|
|
}
|
2011-08-02 08:06:17 +02:00
|
|
|
err = v9fs_co_chmod(pdu, &fidp->path,
|
2011-05-08 09:36:04 +02:00
|
|
|
v9mode_to_mode(v9stat.mode,
|
|
|
|
&v9stat.extension));
|
|
|
|
if (err < 0) {
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (v9stat.mtime != -1 || v9stat.atime != -1) {
|
2010-06-09 15:44:38 +02:00
|
|
|
struct timespec times[2];
|
2011-05-08 09:36:04 +02:00
|
|
|
if (v9stat.atime != -1) {
|
|
|
|
times[0].tv_sec = v9stat.atime;
|
2010-06-09 15:44:38 +02:00
|
|
|
times[0].tv_nsec = 0;
|
|
|
|
} else {
|
|
|
|
times[0].tv_nsec = UTIME_OMIT;
|
|
|
|
}
|
2011-05-08 09:36:04 +02:00
|
|
|
if (v9stat.mtime != -1) {
|
|
|
|
times[1].tv_sec = v9stat.mtime;
|
2010-06-09 15:44:38 +02:00
|
|
|
times[1].tv_nsec = 0;
|
|
|
|
} else {
|
|
|
|
times[1].tv_nsec = UTIME_OMIT;
|
|
|
|
}
|
2011-08-02 08:06:17 +02:00
|
|
|
err = v9fs_co_utimensat(pdu, &fidp->path, times);
|
2011-05-08 09:36:04 +02:00
|
|
|
if (err < 0) {
|
|
|
|
goto out;
|
2010-04-29 14:15:00 +02:00
|
|
|
}
|
|
|
|
}
|
2011-05-08 09:36:04 +02:00
|
|
|
if (v9stat.n_gid != -1 || v9stat.n_uid != -1) {
|
2011-08-02 08:06:17 +02:00
|
|
|
err = v9fs_co_chown(pdu, &fidp->path, v9stat.n_uid, v9stat.n_gid);
|
2011-05-08 09:36:04 +02:00
|
|
|
if (err < 0) {
|
2010-04-29 14:15:00 +02:00
|
|
|
goto out;
|
2011-05-08 09:36:04 +02:00
|
|
|
}
|
2010-04-29 14:15:00 +02:00
|
|
|
}
|
2011-05-08 09:36:04 +02:00
|
|
|
if (v9stat.name.size != 0) {
|
9p: fix QEMU crash when renaming files
When using the 9P2000.u version of the protocol, the following shell
command line in the guest can cause QEMU to crash:
while true; do rm -rf aa; mkdir -p a/b & touch a/b/c & mv a aa; done
With 9P2000.u, file renaming is handled by the WSTAT command. The
v9fs_wstat() function calls v9fs_complete_rename(), which calls
v9fs_fix_path() for every fid whose path is affected by the change.
The involved calls to v9fs_path_copy() may race with any other access
to the fid path performed by some worker thread, causing a crash like
shown below:
Thread 12 "qemu-system-x86" received signal SIGSEGV, Segmentation fault.
0x0000555555a25da2 in local_open_nofollow (fs_ctx=0x555557d958b8, path=0x0,
flags=65536, mode=0) at hw/9pfs/9p-local.c:59
59 while (*path && fd != -1) {
(gdb) bt
#0 0x0000555555a25da2 in local_open_nofollow (fs_ctx=0x555557d958b8,
path=0x0, flags=65536, mode=0) at hw/9pfs/9p-local.c:59
#1 0x0000555555a25e0c in local_opendir_nofollow (fs_ctx=0x555557d958b8,
path=0x0) at hw/9pfs/9p-local.c:92
#2 0x0000555555a261b8 in local_lstat (fs_ctx=0x555557d958b8,
fs_path=0x555556b56858, stbuf=0x7fff84830ef0) at hw/9pfs/9p-local.c:185
#3 0x0000555555a2b367 in v9fs_co_lstat (pdu=0x555557d97498,
path=0x555556b56858, stbuf=0x7fff84830ef0) at hw/9pfs/cofile.c:53
#4 0x0000555555a1e9e2 in v9fs_stat (opaque=0x555557d97498)
at hw/9pfs/9p.c:1083
#5 0x0000555555e060a2 in coroutine_trampoline (i0=-669165424, i1=32767)
at util/coroutine-ucontext.c:116
#6 0x00007fffef4f5600 in __start_context () at /lib64/libc.so.6
#7 0x0000000000000000 in ()
(gdb)
The fix is to take the path write lock when calling v9fs_complete_rename(),
like in v9fs_rename().
Impact: DoS triggered by unprivileged guest users.
Fixes: CVE-2018-19489
Cc: P J P <ppandit@redhat.com>
Reported-by: zhibin hu <noirfate@gmail.com>
Reviewed-by: Prasad J Pandit <pjp@fedoraproject.org>
Signed-off-by: Greg Kurz <groug@kaod.org>
2018-11-23 13:28:03 +01:00
|
|
|
v9fs_path_write_lock(s);
|
2011-08-02 08:06:17 +02:00
|
|
|
err = v9fs_complete_rename(pdu, fidp, -1, &v9stat.name);
|
9p: fix QEMU crash when renaming files
When using the 9P2000.u version of the protocol, the following shell
command line in the guest can cause QEMU to crash:
while true; do rm -rf aa; mkdir -p a/b & touch a/b/c & mv a aa; done
With 9P2000.u, file renaming is handled by the WSTAT command. The
v9fs_wstat() function calls v9fs_complete_rename(), which calls
v9fs_fix_path() for every fid whose path is affected by the change.
The involved calls to v9fs_path_copy() may race with any other access
to the fid path performed by some worker thread, causing a crash like
shown below:
Thread 12 "qemu-system-x86" received signal SIGSEGV, Segmentation fault.
0x0000555555a25da2 in local_open_nofollow (fs_ctx=0x555557d958b8, path=0x0,
flags=65536, mode=0) at hw/9pfs/9p-local.c:59
59 while (*path && fd != -1) {
(gdb) bt
#0 0x0000555555a25da2 in local_open_nofollow (fs_ctx=0x555557d958b8,
path=0x0, flags=65536, mode=0) at hw/9pfs/9p-local.c:59
#1 0x0000555555a25e0c in local_opendir_nofollow (fs_ctx=0x555557d958b8,
path=0x0) at hw/9pfs/9p-local.c:92
#2 0x0000555555a261b8 in local_lstat (fs_ctx=0x555557d958b8,
fs_path=0x555556b56858, stbuf=0x7fff84830ef0) at hw/9pfs/9p-local.c:185
#3 0x0000555555a2b367 in v9fs_co_lstat (pdu=0x555557d97498,
path=0x555556b56858, stbuf=0x7fff84830ef0) at hw/9pfs/cofile.c:53
#4 0x0000555555a1e9e2 in v9fs_stat (opaque=0x555557d97498)
at hw/9pfs/9p.c:1083
#5 0x0000555555e060a2 in coroutine_trampoline (i0=-669165424, i1=32767)
at util/coroutine-ucontext.c:116
#6 0x00007fffef4f5600 in __start_context () at /lib64/libc.so.6
#7 0x0000000000000000 in ()
(gdb)
The fix is to take the path write lock when calling v9fs_complete_rename(),
like in v9fs_rename().
Impact: DoS triggered by unprivileged guest users.
Fixes: CVE-2018-19489
Cc: P J P <ppandit@redhat.com>
Reported-by: zhibin hu <noirfate@gmail.com>
Reviewed-by: Prasad J Pandit <pjp@fedoraproject.org>
Signed-off-by: Greg Kurz <groug@kaod.org>
2018-11-23 13:28:03 +01:00
|
|
|
v9fs_path_unlock(s);
|
2011-05-08 09:36:04 +02:00
|
|
|
if (err < 0) {
|
|
|
|
goto out;
|
|
|
|
}
|
2010-04-29 14:15:00 +02:00
|
|
|
}
|
2011-05-08 09:36:04 +02:00
|
|
|
if (v9stat.length != -1) {
|
2011-08-02 08:06:17 +02:00
|
|
|
err = v9fs_co_truncate(pdu, &fidp->path, v9stat.length);
|
2011-05-08 09:36:04 +02:00
|
|
|
if (err < 0) {
|
|
|
|
goto out;
|
|
|
|
}
|
2010-04-29 14:15:00 +02:00
|
|
|
}
|
2011-05-08 09:36:04 +02:00
|
|
|
err = offset;
|
2010-04-29 14:15:00 +02:00
|
|
|
out:
|
2011-08-02 08:06:17 +02:00
|
|
|
put_fid(pdu, fidp);
|
2011-05-18 14:08:07 +02:00
|
|
|
out_nofid:
|
2011-05-08 09:36:04 +02:00
|
|
|
v9fs_stat_free(&v9stat);
|
2015-12-02 16:00:14 +01:00
|
|
|
pdu_complete(pdu, err);
|
2010-04-29 14:14:44 +02:00
|
|
|
}
|
|
|
|
|
2011-05-19 01:04:01 +02:00
|
|
|
static int v9fs_fill_statfs(V9fsState *s, V9fsPDU *pdu, struct statfs *stbuf)
|
|
|
|
{
|
|
|
|
uint32_t f_type;
|
|
|
|
uint32_t f_bsize;
|
|
|
|
uint64_t f_blocks;
|
|
|
|
uint64_t f_bfree;
|
|
|
|
uint64_t f_bavail;
|
|
|
|
uint64_t f_files;
|
|
|
|
uint64_t f_ffree;
|
|
|
|
uint64_t fsid_val;
|
|
|
|
uint32_t f_namelen;
|
|
|
|
size_t offset = 7;
|
2010-06-09 15:44:28 +02:00
|
|
|
int32_t bsize_factor;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* compute bsize factor based on host file system block size
|
|
|
|
* and client msize
|
|
|
|
*/
|
2020-10-30 05:35:13 +01:00
|
|
|
bsize_factor = (s->msize - P9_IOHDRSZ) / stbuf->f_bsize;
|
2010-06-09 15:44:28 +02:00
|
|
|
if (!bsize_factor) {
|
|
|
|
bsize_factor = 1;
|
|
|
|
}
|
2011-05-19 01:04:01 +02:00
|
|
|
f_type = stbuf->f_type;
|
|
|
|
f_bsize = stbuf->f_bsize;
|
|
|
|
f_bsize *= bsize_factor;
|
2010-06-09 15:44:28 +02:00
|
|
|
/*
|
|
|
|
* f_bsize is adjusted(multiplied) by bsize factor, so we need to
|
|
|
|
* adjust(divide) the number of blocks, free blocks and available
|
|
|
|
* blocks by bsize factor
|
|
|
|
*/
|
2020-10-30 05:35:13 +01:00
|
|
|
f_blocks = stbuf->f_blocks / bsize_factor;
|
|
|
|
f_bfree = stbuf->f_bfree / bsize_factor;
|
|
|
|
f_bavail = stbuf->f_bavail / bsize_factor;
|
2011-05-19 01:04:01 +02:00
|
|
|
f_files = stbuf->f_files;
|
|
|
|
f_ffree = stbuf->f_ffree;
|
|
|
|
fsid_val = (unsigned int) stbuf->f_fsid.__val[0] |
|
|
|
|
(unsigned long long)stbuf->f_fsid.__val[1] << 32;
|
|
|
|
f_namelen = stbuf->f_namelen;
|
2010-05-10 08:41:03 +02:00
|
|
|
|
2011-05-19 01:04:01 +02:00
|
|
|
return pdu_marshal(pdu, offset, "ddqqqqqqd",
|
|
|
|
f_type, f_bsize, f_blocks, f_bfree,
|
|
|
|
f_bavail, f_files, f_ffree,
|
|
|
|
fsid_val, f_namelen);
|
2010-05-10 08:41:03 +02:00
|
|
|
}
|
|
|
|
|
2016-10-17 14:13:58 +02:00
|
|
|
static void coroutine_fn v9fs_statfs(void *opaque)
|
2010-05-10 08:41:03 +02:00
|
|
|
{
|
2011-05-19 01:04:01 +02:00
|
|
|
int32_t fid;
|
|
|
|
ssize_t retval = 0;
|
|
|
|
size_t offset = 7;
|
|
|
|
V9fsFidState *fidp;
|
|
|
|
struct statfs stbuf;
|
2011-05-18 23:18:05 +02:00
|
|
|
V9fsPDU *pdu = opaque;
|
|
|
|
V9fsState *s = pdu->s;
|
2010-05-10 08:41:03 +02:00
|
|
|
|
2011-12-14 09:19:13 +01:00
|
|
|
retval = pdu_unmarshal(pdu, offset, "d", &fid);
|
|
|
|
if (retval < 0) {
|
|
|
|
goto out_nofid;
|
|
|
|
}
|
2011-08-02 08:06:17 +02:00
|
|
|
fidp = get_fid(pdu, fid);
|
2011-05-19 01:04:01 +02:00
|
|
|
if (fidp == NULL) {
|
|
|
|
retval = -ENOENT;
|
2011-05-18 14:08:07 +02:00
|
|
|
goto out_nofid;
|
2010-05-10 08:41:03 +02:00
|
|
|
}
|
2011-08-02 08:06:17 +02:00
|
|
|
retval = v9fs_co_statfs(pdu, &fidp->path, &stbuf);
|
2011-05-19 01:04:01 +02:00
|
|
|
if (retval < 0) {
|
|
|
|
goto out;
|
|
|
|
}
|
2011-12-14 09:19:13 +01:00
|
|
|
retval = v9fs_fill_statfs(s, pdu, &stbuf);
|
|
|
|
if (retval < 0) {
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
retval += offset;
|
2010-05-10 08:41:03 +02:00
|
|
|
out:
|
2011-08-02 08:06:17 +02:00
|
|
|
put_fid(pdu, fidp);
|
2011-05-18 14:08:07 +02:00
|
|
|
out_nofid:
|
2015-12-02 16:00:14 +01:00
|
|
|
pdu_complete(pdu, retval);
|
2010-05-10 08:41:03 +02:00
|
|
|
}
|
|
|
|
|
2016-10-17 14:13:58 +02:00
|
|
|
static void coroutine_fn v9fs_mknod(void *opaque)
|
2010-06-22 08:54:09 +02:00
|
|
|
{
|
2011-05-19 01:06:51 +02:00
|
|
|
|
|
|
|
int mode;
|
|
|
|
gid_t gid;
|
2010-06-22 08:54:09 +02:00
|
|
|
int32_t fid;
|
2011-05-19 01:06:51 +02:00
|
|
|
V9fsQID qid;
|
2010-06-22 08:54:09 +02:00
|
|
|
int err = 0;
|
|
|
|
int major, minor;
|
2011-05-19 01:06:51 +02:00
|
|
|
size_t offset = 7;
|
|
|
|
V9fsString name;
|
|
|
|
struct stat stbuf;
|
|
|
|
V9fsFidState *fidp;
|
|
|
|
V9fsPDU *pdu = opaque;
|
2010-06-22 08:54:09 +02:00
|
|
|
|
2011-12-14 09:19:13 +01:00
|
|
|
v9fs_string_init(&name);
|
|
|
|
err = pdu_unmarshal(pdu, offset, "dsdddd", &fid, &name, &mode,
|
|
|
|
&major, &minor, &gid);
|
|
|
|
if (err < 0) {
|
|
|
|
goto out_nofid;
|
|
|
|
}
|
2011-10-12 15:41:25 +02:00
|
|
|
trace_v9fs_mknod(pdu->tag, pdu->id, fid, mode, major, minor);
|
2010-06-22 08:54:09 +02:00
|
|
|
|
2016-08-30 19:11:05 +02:00
|
|
|
if (name_is_illegal(name.data)) {
|
|
|
|
err = -ENOENT;
|
|
|
|
goto out_nofid;
|
|
|
|
}
|
|
|
|
|
2016-08-30 19:13:11 +02:00
|
|
|
if (!strcmp(".", name.data) || !strcmp("..", name.data)) {
|
|
|
|
err = -EEXIST;
|
|
|
|
goto out_nofid;
|
|
|
|
}
|
|
|
|
|
2011-08-02 08:06:17 +02:00
|
|
|
fidp = get_fid(pdu, fid);
|
2010-06-22 08:54:09 +02:00
|
|
|
if (fidp == NULL) {
|
|
|
|
err = -ENOENT;
|
2011-05-18 14:08:07 +02:00
|
|
|
goto out_nofid;
|
2010-06-22 08:54:09 +02:00
|
|
|
}
|
2011-08-02 08:06:17 +02:00
|
|
|
err = v9fs_co_mknod(pdu, fidp, &name, fidp->uid, gid,
|
2011-05-24 11:40:56 +02:00
|
|
|
makedev(major, minor), mode, &stbuf);
|
2011-05-19 01:06:51 +02:00
|
|
|
if (err < 0) {
|
|
|
|
goto out;
|
|
|
|
}
|
2019-10-10 11:36:05 +02:00
|
|
|
err = stat_to_qid(pdu, &stbuf, &qid);
|
|
|
|
if (err < 0) {
|
|
|
|
goto out;
|
|
|
|
}
|
2011-12-14 09:19:13 +01:00
|
|
|
err = pdu_marshal(pdu, offset, "Q", &qid);
|
|
|
|
if (err < 0) {
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
err += offset;
|
2011-10-24 11:39:49 +02:00
|
|
|
trace_v9fs_mknod_return(pdu->tag, pdu->id,
|
|
|
|
qid.type, qid.version, qid.path);
|
2010-06-22 08:54:09 +02:00
|
|
|
out:
|
2011-08-02 08:06:17 +02:00
|
|
|
put_fid(pdu, fidp);
|
2011-05-18 14:08:07 +02:00
|
|
|
out_nofid:
|
2015-12-02 16:00:14 +01:00
|
|
|
pdu_complete(pdu, err);
|
2011-05-19 01:06:51 +02:00
|
|
|
v9fs_string_free(&name);
|
2010-06-22 08:54:09 +02:00
|
|
|
}
|
|
|
|
|
[virto-9p] Implement TLOCK
Synopsis
size[4] TLock tag[2] fid[4] flock[n]
size[4] RLock tag[2] status[1]
Description
Tlock is used to acquire/release byte range posix locks on a file
identified by given fid. The reply contains status of the lock request
flock structure:
type[1] - Type of lock: F_RDLCK, F_WRLCK, F_UNLCK
flags[4] - Flags could be either of
P9_LOCK_FLAGS_BLOCK(1) - Blocked lock request, if there is a
conflicting lock exists, wait for that lock to be released.
P9_LOCK_FLAGS_RECLAIM(2) - Reclaim lock request, used when client is
trying to reclaim a lock after a server restrart (due to crash)
start[8] - Starting offset for lock
length[8] - Number of bytes to lock
If length is 0, lock all bytes starting at the location 'start'
through to the end of file
pid[4] - PID of the process that wants to take lock
client_id[4] - Unique client id
status[1] - Status of the lock request, can be
P9_LOCK_SUCCESS(0), P9_LOCK_BLOCKED(1), P9_LOCK_ERROR(2) or
P9_LOCK_GRACE(3)
P9_LOCK_SUCCESS - Request was successful
P9_LOCK_BLOCKED - A conflicting lock is held by another process
P9_LOCK_ERROR - Error while processing the lock request
P9_LOCK_GRACE - Server is in grace period, it can't accept new lock
requests in this period (except locks with
P9_LOCK_FLAGS_RECLAIM flag set)
Signed-off-by: M. Mohan Kumar <mohan@in.ibm.com>
Signed-off-by: Aneesh Kumar K.V <aneesh.kumar@linux.vnet.ibm.com>
Signed-off-by: Venkateswararao Jujjuri <jvrao@linux.vnet.ibm.com>
2010-09-07 22:49:32 +02:00
|
|
|
/*
|
|
|
|
* Implement posix byte range locking code
|
|
|
|
* Server side handling of locking code is very simple, because 9p server in
|
|
|
|
* QEMU can handle only one client. And most of the lock handling
|
|
|
|
* (like conflict, merging) etc is done by the VFS layer itself, so no need to
|
|
|
|
* do any thing in * qemu 9p server side lock code path.
|
|
|
|
* So when a TLOCK request comes, always return success
|
|
|
|
*/
|
2016-10-17 14:13:58 +02:00
|
|
|
static void coroutine_fn v9fs_lock(void *opaque)
|
[virto-9p] Implement TLOCK
Synopsis
size[4] TLock tag[2] fid[4] flock[n]
size[4] RLock tag[2] status[1]
Description
Tlock is used to acquire/release byte range posix locks on a file
identified by given fid. The reply contains status of the lock request
flock structure:
type[1] - Type of lock: F_RDLCK, F_WRLCK, F_UNLCK
flags[4] - Flags could be either of
P9_LOCK_FLAGS_BLOCK(1) - Blocked lock request, if there is a
conflicting lock exists, wait for that lock to be released.
P9_LOCK_FLAGS_RECLAIM(2) - Reclaim lock request, used when client is
trying to reclaim a lock after a server restrart (due to crash)
start[8] - Starting offset for lock
length[8] - Number of bytes to lock
If length is 0, lock all bytes starting at the location 'start'
through to the end of file
pid[4] - PID of the process that wants to take lock
client_id[4] - Unique client id
status[1] - Status of the lock request, can be
P9_LOCK_SUCCESS(0), P9_LOCK_BLOCKED(1), P9_LOCK_ERROR(2) or
P9_LOCK_GRACE(3)
P9_LOCK_SUCCESS - Request was successful
P9_LOCK_BLOCKED - A conflicting lock is held by another process
P9_LOCK_ERROR - Error while processing the lock request
P9_LOCK_GRACE - Server is in grace period, it can't accept new lock
requests in this period (except locks with
P9_LOCK_FLAGS_RECLAIM flag set)
Signed-off-by: M. Mohan Kumar <mohan@in.ibm.com>
Signed-off-by: Aneesh Kumar K.V <aneesh.kumar@linux.vnet.ibm.com>
Signed-off-by: Venkateswararao Jujjuri <jvrao@linux.vnet.ibm.com>
2010-09-07 22:49:32 +02:00
|
|
|
{
|
2011-12-14 09:19:13 +01:00
|
|
|
V9fsFlock flock;
|
2011-08-22 05:44:04 +02:00
|
|
|
size_t offset = 7;
|
|
|
|
struct stat stbuf;
|
|
|
|
V9fsFidState *fidp;
|
|
|
|
int32_t fid, err = 0;
|
2011-05-18 23:18:05 +02:00
|
|
|
V9fsPDU *pdu = opaque;
|
[virto-9p] Implement TLOCK
Synopsis
size[4] TLock tag[2] fid[4] flock[n]
size[4] RLock tag[2] status[1]
Description
Tlock is used to acquire/release byte range posix locks on a file
identified by given fid. The reply contains status of the lock request
flock structure:
type[1] - Type of lock: F_RDLCK, F_WRLCK, F_UNLCK
flags[4] - Flags could be either of
P9_LOCK_FLAGS_BLOCK(1) - Blocked lock request, if there is a
conflicting lock exists, wait for that lock to be released.
P9_LOCK_FLAGS_RECLAIM(2) - Reclaim lock request, used when client is
trying to reclaim a lock after a server restrart (due to crash)
start[8] - Starting offset for lock
length[8] - Number of bytes to lock
If length is 0, lock all bytes starting at the location 'start'
through to the end of file
pid[4] - PID of the process that wants to take lock
client_id[4] - Unique client id
status[1] - Status of the lock request, can be
P9_LOCK_SUCCESS(0), P9_LOCK_BLOCKED(1), P9_LOCK_ERROR(2) or
P9_LOCK_GRACE(3)
P9_LOCK_SUCCESS - Request was successful
P9_LOCK_BLOCKED - A conflicting lock is held by another process
P9_LOCK_ERROR - Error while processing the lock request
P9_LOCK_GRACE - Server is in grace period, it can't accept new lock
requests in this period (except locks with
P9_LOCK_FLAGS_RECLAIM flag set)
Signed-off-by: M. Mohan Kumar <mohan@in.ibm.com>
Signed-off-by: Aneesh Kumar K.V <aneesh.kumar@linux.vnet.ibm.com>
Signed-off-by: Venkateswararao Jujjuri <jvrao@linux.vnet.ibm.com>
2010-09-07 22:49:32 +02:00
|
|
|
|
2011-12-14 09:19:13 +01:00
|
|
|
v9fs_string_init(&flock.client_id);
|
|
|
|
err = pdu_unmarshal(pdu, offset, "dbdqqds", &fid, &flock.type,
|
|
|
|
&flock.flags, &flock.start, &flock.length,
|
|
|
|
&flock.proc_id, &flock.client_id);
|
|
|
|
if (err < 0) {
|
|
|
|
goto out_nofid;
|
|
|
|
}
|
2011-10-12 15:41:25 +02:00
|
|
|
trace_v9fs_lock(pdu->tag, pdu->id, fid,
|
2011-12-14 09:19:13 +01:00
|
|
|
flock.type, flock.start, flock.length);
|
2011-10-12 15:41:25 +02:00
|
|
|
|
[virto-9p] Implement TLOCK
Synopsis
size[4] TLock tag[2] fid[4] flock[n]
size[4] RLock tag[2] status[1]
Description
Tlock is used to acquire/release byte range posix locks on a file
identified by given fid. The reply contains status of the lock request
flock structure:
type[1] - Type of lock: F_RDLCK, F_WRLCK, F_UNLCK
flags[4] - Flags could be either of
P9_LOCK_FLAGS_BLOCK(1) - Blocked lock request, if there is a
conflicting lock exists, wait for that lock to be released.
P9_LOCK_FLAGS_RECLAIM(2) - Reclaim lock request, used when client is
trying to reclaim a lock after a server restrart (due to crash)
start[8] - Starting offset for lock
length[8] - Number of bytes to lock
If length is 0, lock all bytes starting at the location 'start'
through to the end of file
pid[4] - PID of the process that wants to take lock
client_id[4] - Unique client id
status[1] - Status of the lock request, can be
P9_LOCK_SUCCESS(0), P9_LOCK_BLOCKED(1), P9_LOCK_ERROR(2) or
P9_LOCK_GRACE(3)
P9_LOCK_SUCCESS - Request was successful
P9_LOCK_BLOCKED - A conflicting lock is held by another process
P9_LOCK_ERROR - Error while processing the lock request
P9_LOCK_GRACE - Server is in grace period, it can't accept new lock
requests in this period (except locks with
P9_LOCK_FLAGS_RECLAIM flag set)
Signed-off-by: M. Mohan Kumar <mohan@in.ibm.com>
Signed-off-by: Aneesh Kumar K.V <aneesh.kumar@linux.vnet.ibm.com>
Signed-off-by: Venkateswararao Jujjuri <jvrao@linux.vnet.ibm.com>
2010-09-07 22:49:32 +02:00
|
|
|
|
|
|
|
/* We support only block flag now (that too ignored currently) */
|
2011-12-14 09:19:13 +01:00
|
|
|
if (flock.flags & ~P9_LOCK_FLAGS_BLOCK) {
|
[virto-9p] Implement TLOCK
Synopsis
size[4] TLock tag[2] fid[4] flock[n]
size[4] RLock tag[2] status[1]
Description
Tlock is used to acquire/release byte range posix locks on a file
identified by given fid. The reply contains status of the lock request
flock structure:
type[1] - Type of lock: F_RDLCK, F_WRLCK, F_UNLCK
flags[4] - Flags could be either of
P9_LOCK_FLAGS_BLOCK(1) - Blocked lock request, if there is a
conflicting lock exists, wait for that lock to be released.
P9_LOCK_FLAGS_RECLAIM(2) - Reclaim lock request, used when client is
trying to reclaim a lock after a server restrart (due to crash)
start[8] - Starting offset for lock
length[8] - Number of bytes to lock
If length is 0, lock all bytes starting at the location 'start'
through to the end of file
pid[4] - PID of the process that wants to take lock
client_id[4] - Unique client id
status[1] - Status of the lock request, can be
P9_LOCK_SUCCESS(0), P9_LOCK_BLOCKED(1), P9_LOCK_ERROR(2) or
P9_LOCK_GRACE(3)
P9_LOCK_SUCCESS - Request was successful
P9_LOCK_BLOCKED - A conflicting lock is held by another process
P9_LOCK_ERROR - Error while processing the lock request
P9_LOCK_GRACE - Server is in grace period, it can't accept new lock
requests in this period (except locks with
P9_LOCK_FLAGS_RECLAIM flag set)
Signed-off-by: M. Mohan Kumar <mohan@in.ibm.com>
Signed-off-by: Aneesh Kumar K.V <aneesh.kumar@linux.vnet.ibm.com>
Signed-off-by: Venkateswararao Jujjuri <jvrao@linux.vnet.ibm.com>
2010-09-07 22:49:32 +02:00
|
|
|
err = -EINVAL;
|
2011-05-18 14:08:07 +02:00
|
|
|
goto out_nofid;
|
[virto-9p] Implement TLOCK
Synopsis
size[4] TLock tag[2] fid[4] flock[n]
size[4] RLock tag[2] status[1]
Description
Tlock is used to acquire/release byte range posix locks on a file
identified by given fid. The reply contains status of the lock request
flock structure:
type[1] - Type of lock: F_RDLCK, F_WRLCK, F_UNLCK
flags[4] - Flags could be either of
P9_LOCK_FLAGS_BLOCK(1) - Blocked lock request, if there is a
conflicting lock exists, wait for that lock to be released.
P9_LOCK_FLAGS_RECLAIM(2) - Reclaim lock request, used when client is
trying to reclaim a lock after a server restrart (due to crash)
start[8] - Starting offset for lock
length[8] - Number of bytes to lock
If length is 0, lock all bytes starting at the location 'start'
through to the end of file
pid[4] - PID of the process that wants to take lock
client_id[4] - Unique client id
status[1] - Status of the lock request, can be
P9_LOCK_SUCCESS(0), P9_LOCK_BLOCKED(1), P9_LOCK_ERROR(2) or
P9_LOCK_GRACE(3)
P9_LOCK_SUCCESS - Request was successful
P9_LOCK_BLOCKED - A conflicting lock is held by another process
P9_LOCK_ERROR - Error while processing the lock request
P9_LOCK_GRACE - Server is in grace period, it can't accept new lock
requests in this period (except locks with
P9_LOCK_FLAGS_RECLAIM flag set)
Signed-off-by: M. Mohan Kumar <mohan@in.ibm.com>
Signed-off-by: Aneesh Kumar K.V <aneesh.kumar@linux.vnet.ibm.com>
Signed-off-by: Venkateswararao Jujjuri <jvrao@linux.vnet.ibm.com>
2010-09-07 22:49:32 +02:00
|
|
|
}
|
2011-08-02 08:06:17 +02:00
|
|
|
fidp = get_fid(pdu, fid);
|
2011-08-22 05:44:04 +02:00
|
|
|
if (fidp == NULL) {
|
[virto-9p] Implement TLOCK
Synopsis
size[4] TLock tag[2] fid[4] flock[n]
size[4] RLock tag[2] status[1]
Description
Tlock is used to acquire/release byte range posix locks on a file
identified by given fid. The reply contains status of the lock request
flock structure:
type[1] - Type of lock: F_RDLCK, F_WRLCK, F_UNLCK
flags[4] - Flags could be either of
P9_LOCK_FLAGS_BLOCK(1) - Blocked lock request, if there is a
conflicting lock exists, wait for that lock to be released.
P9_LOCK_FLAGS_RECLAIM(2) - Reclaim lock request, used when client is
trying to reclaim a lock after a server restrart (due to crash)
start[8] - Starting offset for lock
length[8] - Number of bytes to lock
If length is 0, lock all bytes starting at the location 'start'
through to the end of file
pid[4] - PID of the process that wants to take lock
client_id[4] - Unique client id
status[1] - Status of the lock request, can be
P9_LOCK_SUCCESS(0), P9_LOCK_BLOCKED(1), P9_LOCK_ERROR(2) or
P9_LOCK_GRACE(3)
P9_LOCK_SUCCESS - Request was successful
P9_LOCK_BLOCKED - A conflicting lock is held by another process
P9_LOCK_ERROR - Error while processing the lock request
P9_LOCK_GRACE - Server is in grace period, it can't accept new lock
requests in this period (except locks with
P9_LOCK_FLAGS_RECLAIM flag set)
Signed-off-by: M. Mohan Kumar <mohan@in.ibm.com>
Signed-off-by: Aneesh Kumar K.V <aneesh.kumar@linux.vnet.ibm.com>
Signed-off-by: Venkateswararao Jujjuri <jvrao@linux.vnet.ibm.com>
2010-09-07 22:49:32 +02:00
|
|
|
err = -ENOENT;
|
2011-05-18 14:08:07 +02:00
|
|
|
goto out_nofid;
|
[virto-9p] Implement TLOCK
Synopsis
size[4] TLock tag[2] fid[4] flock[n]
size[4] RLock tag[2] status[1]
Description
Tlock is used to acquire/release byte range posix locks on a file
identified by given fid. The reply contains status of the lock request
flock structure:
type[1] - Type of lock: F_RDLCK, F_WRLCK, F_UNLCK
flags[4] - Flags could be either of
P9_LOCK_FLAGS_BLOCK(1) - Blocked lock request, if there is a
conflicting lock exists, wait for that lock to be released.
P9_LOCK_FLAGS_RECLAIM(2) - Reclaim lock request, used when client is
trying to reclaim a lock after a server restrart (due to crash)
start[8] - Starting offset for lock
length[8] - Number of bytes to lock
If length is 0, lock all bytes starting at the location 'start'
through to the end of file
pid[4] - PID of the process that wants to take lock
client_id[4] - Unique client id
status[1] - Status of the lock request, can be
P9_LOCK_SUCCESS(0), P9_LOCK_BLOCKED(1), P9_LOCK_ERROR(2) or
P9_LOCK_GRACE(3)
P9_LOCK_SUCCESS - Request was successful
P9_LOCK_BLOCKED - A conflicting lock is held by another process
P9_LOCK_ERROR - Error while processing the lock request
P9_LOCK_GRACE - Server is in grace period, it can't accept new lock
requests in this period (except locks with
P9_LOCK_FLAGS_RECLAIM flag set)
Signed-off-by: M. Mohan Kumar <mohan@in.ibm.com>
Signed-off-by: Aneesh Kumar K.V <aneesh.kumar@linux.vnet.ibm.com>
Signed-off-by: Venkateswararao Jujjuri <jvrao@linux.vnet.ibm.com>
2010-09-07 22:49:32 +02:00
|
|
|
}
|
2011-10-25 08:40:40 +02:00
|
|
|
err = v9fs_co_fstat(pdu, fidp, &stbuf);
|
[virto-9p] Implement TLOCK
Synopsis
size[4] TLock tag[2] fid[4] flock[n]
size[4] RLock tag[2] status[1]
Description
Tlock is used to acquire/release byte range posix locks on a file
identified by given fid. The reply contains status of the lock request
flock structure:
type[1] - Type of lock: F_RDLCK, F_WRLCK, F_UNLCK
flags[4] - Flags could be either of
P9_LOCK_FLAGS_BLOCK(1) - Blocked lock request, if there is a
conflicting lock exists, wait for that lock to be released.
P9_LOCK_FLAGS_RECLAIM(2) - Reclaim lock request, used when client is
trying to reclaim a lock after a server restrart (due to crash)
start[8] - Starting offset for lock
length[8] - Number of bytes to lock
If length is 0, lock all bytes starting at the location 'start'
through to the end of file
pid[4] - PID of the process that wants to take lock
client_id[4] - Unique client id
status[1] - Status of the lock request, can be
P9_LOCK_SUCCESS(0), P9_LOCK_BLOCKED(1), P9_LOCK_ERROR(2) or
P9_LOCK_GRACE(3)
P9_LOCK_SUCCESS - Request was successful
P9_LOCK_BLOCKED - A conflicting lock is held by another process
P9_LOCK_ERROR - Error while processing the lock request
P9_LOCK_GRACE - Server is in grace period, it can't accept new lock
requests in this period (except locks with
P9_LOCK_FLAGS_RECLAIM flag set)
Signed-off-by: M. Mohan Kumar <mohan@in.ibm.com>
Signed-off-by: Aneesh Kumar K.V <aneesh.kumar@linux.vnet.ibm.com>
Signed-off-by: Venkateswararao Jujjuri <jvrao@linux.vnet.ibm.com>
2010-09-07 22:49:32 +02:00
|
|
|
if (err < 0) {
|
|
|
|
goto out;
|
|
|
|
}
|
2017-02-28 10:31:46 +01:00
|
|
|
err = pdu_marshal(pdu, offset, "b", P9_LOCK_SUCCESS);
|
|
|
|
if (err < 0) {
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
err += offset;
|
|
|
|
trace_v9fs_lock_return(pdu->tag, pdu->id, P9_LOCK_SUCCESS);
|
[virto-9p] Implement TLOCK
Synopsis
size[4] TLock tag[2] fid[4] flock[n]
size[4] RLock tag[2] status[1]
Description
Tlock is used to acquire/release byte range posix locks on a file
identified by given fid. The reply contains status of the lock request
flock structure:
type[1] - Type of lock: F_RDLCK, F_WRLCK, F_UNLCK
flags[4] - Flags could be either of
P9_LOCK_FLAGS_BLOCK(1) - Blocked lock request, if there is a
conflicting lock exists, wait for that lock to be released.
P9_LOCK_FLAGS_RECLAIM(2) - Reclaim lock request, used when client is
trying to reclaim a lock after a server restrart (due to crash)
start[8] - Starting offset for lock
length[8] - Number of bytes to lock
If length is 0, lock all bytes starting at the location 'start'
through to the end of file
pid[4] - PID of the process that wants to take lock
client_id[4] - Unique client id
status[1] - Status of the lock request, can be
P9_LOCK_SUCCESS(0), P9_LOCK_BLOCKED(1), P9_LOCK_ERROR(2) or
P9_LOCK_GRACE(3)
P9_LOCK_SUCCESS - Request was successful
P9_LOCK_BLOCKED - A conflicting lock is held by another process
P9_LOCK_ERROR - Error while processing the lock request
P9_LOCK_GRACE - Server is in grace period, it can't accept new lock
requests in this period (except locks with
P9_LOCK_FLAGS_RECLAIM flag set)
Signed-off-by: M. Mohan Kumar <mohan@in.ibm.com>
Signed-off-by: Aneesh Kumar K.V <aneesh.kumar@linux.vnet.ibm.com>
Signed-off-by: Venkateswararao Jujjuri <jvrao@linux.vnet.ibm.com>
2010-09-07 22:49:32 +02:00
|
|
|
out:
|
2011-08-02 08:06:17 +02:00
|
|
|
put_fid(pdu, fidp);
|
2011-05-18 14:08:07 +02:00
|
|
|
out_nofid:
|
2015-12-02 16:00:14 +01:00
|
|
|
pdu_complete(pdu, err);
|
2011-12-14 09:19:13 +01:00
|
|
|
v9fs_string_free(&flock.client_id);
|
[virto-9p] Implement TLOCK
Synopsis
size[4] TLock tag[2] fid[4] flock[n]
size[4] RLock tag[2] status[1]
Description
Tlock is used to acquire/release byte range posix locks on a file
identified by given fid. The reply contains status of the lock request
flock structure:
type[1] - Type of lock: F_RDLCK, F_WRLCK, F_UNLCK
flags[4] - Flags could be either of
P9_LOCK_FLAGS_BLOCK(1) - Blocked lock request, if there is a
conflicting lock exists, wait for that lock to be released.
P9_LOCK_FLAGS_RECLAIM(2) - Reclaim lock request, used when client is
trying to reclaim a lock after a server restrart (due to crash)
start[8] - Starting offset for lock
length[8] - Number of bytes to lock
If length is 0, lock all bytes starting at the location 'start'
through to the end of file
pid[4] - PID of the process that wants to take lock
client_id[4] - Unique client id
status[1] - Status of the lock request, can be
P9_LOCK_SUCCESS(0), P9_LOCK_BLOCKED(1), P9_LOCK_ERROR(2) or
P9_LOCK_GRACE(3)
P9_LOCK_SUCCESS - Request was successful
P9_LOCK_BLOCKED - A conflicting lock is held by another process
P9_LOCK_ERROR - Error while processing the lock request
P9_LOCK_GRACE - Server is in grace period, it can't accept new lock
requests in this period (except locks with
P9_LOCK_FLAGS_RECLAIM flag set)
Signed-off-by: M. Mohan Kumar <mohan@in.ibm.com>
Signed-off-by: Aneesh Kumar K.V <aneesh.kumar@linux.vnet.ibm.com>
Signed-off-by: Venkateswararao Jujjuri <jvrao@linux.vnet.ibm.com>
2010-09-07 22:49:32 +02:00
|
|
|
}
|
|
|
|
|
2010-09-07 23:06:52 +02:00
|
|
|
/*
|
|
|
|
* When a TGETLOCK request comes, always return success because all lock
|
|
|
|
* handling is done by client's VFS layer.
|
|
|
|
*/
|
2016-10-17 14:13:58 +02:00
|
|
|
static void coroutine_fn v9fs_getlock(void *opaque)
|
2010-09-07 23:06:52 +02:00
|
|
|
{
|
2011-05-07 13:51:38 +02:00
|
|
|
size_t offset = 7;
|
|
|
|
struct stat stbuf;
|
|
|
|
V9fsFidState *fidp;
|
2011-12-14 09:19:13 +01:00
|
|
|
V9fsGetlock glock;
|
2011-05-07 13:51:38 +02:00
|
|
|
int32_t fid, err = 0;
|
2011-05-18 23:18:05 +02:00
|
|
|
V9fsPDU *pdu = opaque;
|
2010-09-07 23:06:52 +02:00
|
|
|
|
2011-12-14 09:19:13 +01:00
|
|
|
v9fs_string_init(&glock.client_id);
|
|
|
|
err = pdu_unmarshal(pdu, offset, "dbqqds", &fid, &glock.type,
|
|
|
|
&glock.start, &glock.length, &glock.proc_id,
|
|
|
|
&glock.client_id);
|
|
|
|
if (err < 0) {
|
|
|
|
goto out_nofid;
|
|
|
|
}
|
2011-10-12 15:41:25 +02:00
|
|
|
trace_v9fs_getlock(pdu->tag, pdu->id, fid,
|
2011-12-14 09:19:13 +01:00
|
|
|
glock.type, glock.start, glock.length);
|
2011-10-12 15:41:25 +02:00
|
|
|
|
2011-08-02 08:06:17 +02:00
|
|
|
fidp = get_fid(pdu, fid);
|
2011-05-07 13:51:38 +02:00
|
|
|
if (fidp == NULL) {
|
2010-09-07 23:06:52 +02:00
|
|
|
err = -ENOENT;
|
2011-05-18 14:08:07 +02:00
|
|
|
goto out_nofid;
|
2010-09-07 23:06:52 +02:00
|
|
|
}
|
2011-10-25 08:40:40 +02:00
|
|
|
err = v9fs_co_fstat(pdu, fidp, &stbuf);
|
2010-09-07 23:06:52 +02:00
|
|
|
if (err < 0) {
|
|
|
|
goto out;
|
|
|
|
}
|
2011-12-14 09:19:13 +01:00
|
|
|
glock.type = P9_LOCK_TYPE_UNLCK;
|
|
|
|
err = pdu_marshal(pdu, offset, "bqqds", glock.type,
|
|
|
|
glock.start, glock.length, glock.proc_id,
|
|
|
|
&glock.client_id);
|
|
|
|
if (err < 0) {
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
err += offset;
|
|
|
|
trace_v9fs_getlock_return(pdu->tag, pdu->id, glock.type, glock.start,
|
|
|
|
glock.length, glock.proc_id);
|
2010-09-07 23:06:52 +02:00
|
|
|
out:
|
2011-08-02 08:06:17 +02:00
|
|
|
put_fid(pdu, fidp);
|
2011-05-18 14:08:07 +02:00
|
|
|
out_nofid:
|
2015-12-02 16:00:14 +01:00
|
|
|
pdu_complete(pdu, err);
|
2011-12-14 09:19:13 +01:00
|
|
|
v9fs_string_free(&glock.client_id);
|
2010-09-07 23:06:52 +02:00
|
|
|
}
|
|
|
|
|
2016-10-17 14:13:58 +02:00
|
|
|
static void coroutine_fn v9fs_mkdir(void *opaque)
|
2010-06-22 08:55:22 +02:00
|
|
|
{
|
2011-05-18 23:18:05 +02:00
|
|
|
V9fsPDU *pdu = opaque;
|
2011-08-08 20:16:14 +02:00
|
|
|
size_t offset = 7;
|
2010-06-22 08:55:22 +02:00
|
|
|
int32_t fid;
|
2011-08-08 20:16:14 +02:00
|
|
|
struct stat stbuf;
|
|
|
|
V9fsQID qid;
|
2011-05-24 11:40:56 +02:00
|
|
|
V9fsString name;
|
2010-06-22 08:55:22 +02:00
|
|
|
V9fsFidState *fidp;
|
|
|
|
gid_t gid;
|
|
|
|
int mode;
|
2011-08-08 20:16:14 +02:00
|
|
|
int err = 0;
|
2010-06-22 08:55:22 +02:00
|
|
|
|
2011-12-14 09:19:13 +01:00
|
|
|
v9fs_string_init(&name);
|
|
|
|
err = pdu_unmarshal(pdu, offset, "dsdd", &fid, &name, &mode, &gid);
|
|
|
|
if (err < 0) {
|
|
|
|
goto out_nofid;
|
|
|
|
}
|
2011-10-12 15:41:25 +02:00
|
|
|
trace_v9fs_mkdir(pdu->tag, pdu->id, fid, name.data, mode, gid);
|
|
|
|
|
2016-08-30 19:11:05 +02:00
|
|
|
if (name_is_illegal(name.data)) {
|
|
|
|
err = -ENOENT;
|
|
|
|
goto out_nofid;
|
|
|
|
}
|
|
|
|
|
2016-08-30 19:13:11 +02:00
|
|
|
if (!strcmp(".", name.data) || !strcmp("..", name.data)) {
|
|
|
|
err = -EEXIST;
|
|
|
|
goto out_nofid;
|
|
|
|
}
|
|
|
|
|
2011-08-02 08:06:17 +02:00
|
|
|
fidp = get_fid(pdu, fid);
|
2010-06-22 08:55:22 +02:00
|
|
|
if (fidp == NULL) {
|
|
|
|
err = -ENOENT;
|
2011-05-18 14:08:07 +02:00
|
|
|
goto out_nofid;
|
2010-06-22 08:55:22 +02:00
|
|
|
}
|
2011-08-02 08:06:17 +02:00
|
|
|
err = v9fs_co_mkdir(pdu, fidp, &name, mode, fidp->uid, gid, &stbuf);
|
2011-08-08 20:16:14 +02:00
|
|
|
if (err < 0) {
|
|
|
|
goto out;
|
|
|
|
}
|
2019-10-10 11:36:05 +02:00
|
|
|
err = stat_to_qid(pdu, &stbuf, &qid);
|
|
|
|
if (err < 0) {
|
|
|
|
goto out;
|
|
|
|
}
|
2011-12-14 09:19:13 +01:00
|
|
|
err = pdu_marshal(pdu, offset, "Q", &qid);
|
|
|
|
if (err < 0) {
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
err += offset;
|
2011-10-24 11:39:49 +02:00
|
|
|
trace_v9fs_mkdir_return(pdu->tag, pdu->id,
|
|
|
|
qid.type, qid.version, qid.path, err);
|
2010-06-22 08:55:22 +02:00
|
|
|
out:
|
2011-08-02 08:06:17 +02:00
|
|
|
put_fid(pdu, fidp);
|
2011-05-18 14:08:07 +02:00
|
|
|
out_nofid:
|
2015-12-02 16:00:14 +01:00
|
|
|
pdu_complete(pdu, err);
|
2011-08-08 20:16:14 +02:00
|
|
|
v9fs_string_free(&name);
|
2010-06-22 08:55:22 +02:00
|
|
|
}
|
|
|
|
|
2016-10-17 14:13:58 +02:00
|
|
|
static void coroutine_fn v9fs_xattrwalk(void *opaque)
|
2010-09-02 07:39:06 +02:00
|
|
|
{
|
2011-05-19 01:05:48 +02:00
|
|
|
int64_t size;
|
|
|
|
V9fsString name;
|
2010-09-02 07:39:06 +02:00
|
|
|
ssize_t err = 0;
|
2011-05-19 01:05:48 +02:00
|
|
|
size_t offset = 7;
|
2010-09-02 07:39:06 +02:00
|
|
|
int32_t fid, newfid;
|
2011-05-19 01:05:48 +02:00
|
|
|
V9fsFidState *file_fidp;
|
2011-05-18 14:08:07 +02:00
|
|
|
V9fsFidState *xattr_fidp = NULL;
|
2011-05-19 01:05:48 +02:00
|
|
|
V9fsPDU *pdu = opaque;
|
|
|
|
V9fsState *s = pdu->s;
|
2010-09-02 07:39:06 +02:00
|
|
|
|
2011-12-14 09:19:13 +01:00
|
|
|
v9fs_string_init(&name);
|
|
|
|
err = pdu_unmarshal(pdu, offset, "dds", &fid, &newfid, &name);
|
|
|
|
if (err < 0) {
|
|
|
|
goto out_nofid;
|
|
|
|
}
|
2011-10-12 15:41:25 +02:00
|
|
|
trace_v9fs_xattrwalk(pdu->tag, pdu->id, fid, newfid, name.data);
|
|
|
|
|
2011-08-02 08:06:17 +02:00
|
|
|
file_fidp = get_fid(pdu, fid);
|
2011-05-19 01:05:48 +02:00
|
|
|
if (file_fidp == NULL) {
|
2010-09-02 07:39:06 +02:00
|
|
|
err = -ENOENT;
|
2011-05-18 14:08:07 +02:00
|
|
|
goto out_nofid;
|
2010-09-02 07:39:06 +02:00
|
|
|
}
|
2011-05-19 01:05:48 +02:00
|
|
|
xattr_fidp = alloc_fid(s, newfid);
|
|
|
|
if (xattr_fidp == NULL) {
|
2010-09-02 07:39:06 +02:00
|
|
|
err = -EINVAL;
|
|
|
|
goto out;
|
|
|
|
}
|
2011-09-09 11:44:18 +02:00
|
|
|
v9fs_path_copy(&xattr_fidp->path, &file_fidp->path);
|
2016-10-17 14:13:58 +02:00
|
|
|
if (!v9fs_string_size(&name)) {
|
2010-09-02 07:39:06 +02:00
|
|
|
/*
|
|
|
|
* listxattr request. Get the size first
|
|
|
|
*/
|
2011-08-02 08:06:17 +02:00
|
|
|
size = v9fs_co_llistxattr(pdu, &xattr_fidp->path, NULL, 0);
|
2011-05-19 01:05:48 +02:00
|
|
|
if (size < 0) {
|
|
|
|
err = size;
|
2011-05-18 14:08:07 +02:00
|
|
|
clunk_fid(s, xattr_fidp->fid);
|
2011-05-19 01:05:48 +02:00
|
|
|
goto out;
|
2010-09-02 07:39:06 +02:00
|
|
|
}
|
2011-05-19 01:05:48 +02:00
|
|
|
/*
|
|
|
|
* Read the xattr value
|
|
|
|
*/
|
|
|
|
xattr_fidp->fs.xattr.len = size;
|
|
|
|
xattr_fidp->fid_type = P9_FID_XATTR;
|
2016-11-01 12:00:40 +01:00
|
|
|
xattr_fidp->fs.xattr.xattrwalk_fid = true;
|
2018-06-07 12:17:22 +02:00
|
|
|
xattr_fidp->fs.xattr.value = g_malloc0(size);
|
2011-05-19 01:05:48 +02:00
|
|
|
if (size) {
|
2011-08-02 08:06:17 +02:00
|
|
|
err = v9fs_co_llistxattr(pdu, &xattr_fidp->path,
|
2011-05-19 01:05:48 +02:00
|
|
|
xattr_fidp->fs.xattr.value,
|
|
|
|
xattr_fidp->fs.xattr.len);
|
|
|
|
if (err < 0) {
|
2011-05-18 14:08:07 +02:00
|
|
|
clunk_fid(s, xattr_fidp->fid);
|
2011-05-19 01:05:48 +02:00
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
}
|
2011-12-14 09:19:13 +01:00
|
|
|
err = pdu_marshal(pdu, offset, "q", size);
|
|
|
|
if (err < 0) {
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
err += offset;
|
2010-09-02 07:39:06 +02:00
|
|
|
} else {
|
|
|
|
/*
|
|
|
|
* specific xattr fid. We check for xattr
|
|
|
|
* presence also collect the xattr size
|
|
|
|
*/
|
2011-08-02 08:06:17 +02:00
|
|
|
size = v9fs_co_lgetxattr(pdu, &xattr_fidp->path,
|
2011-05-19 01:05:48 +02:00
|
|
|
&name, NULL, 0);
|
|
|
|
if (size < 0) {
|
|
|
|
err = size;
|
2011-05-18 14:08:07 +02:00
|
|
|
clunk_fid(s, xattr_fidp->fid);
|
2011-05-19 01:05:48 +02:00
|
|
|
goto out;
|
2010-09-02 07:39:06 +02:00
|
|
|
}
|
2011-05-19 01:05:48 +02:00
|
|
|
/*
|
|
|
|
* Read the xattr value
|
|
|
|
*/
|
|
|
|
xattr_fidp->fs.xattr.len = size;
|
|
|
|
xattr_fidp->fid_type = P9_FID_XATTR;
|
2016-11-01 12:00:40 +01:00
|
|
|
xattr_fidp->fs.xattr.xattrwalk_fid = true;
|
2018-06-07 12:17:22 +02:00
|
|
|
xattr_fidp->fs.xattr.value = g_malloc0(size);
|
2011-05-19 01:05:48 +02:00
|
|
|
if (size) {
|
2011-08-02 08:06:17 +02:00
|
|
|
err = v9fs_co_lgetxattr(pdu, &xattr_fidp->path,
|
2011-05-19 01:05:48 +02:00
|
|
|
&name, xattr_fidp->fs.xattr.value,
|
|
|
|
xattr_fidp->fs.xattr.len);
|
|
|
|
if (err < 0) {
|
2011-05-18 14:08:07 +02:00
|
|
|
clunk_fid(s, xattr_fidp->fid);
|
2011-05-19 01:05:48 +02:00
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
}
|
2011-12-14 09:19:13 +01:00
|
|
|
err = pdu_marshal(pdu, offset, "q", size);
|
|
|
|
if (err < 0) {
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
err += offset;
|
2010-09-02 07:39:06 +02:00
|
|
|
}
|
2011-10-24 11:39:49 +02:00
|
|
|
trace_v9fs_xattrwalk_return(pdu->tag, pdu->id, size);
|
2010-09-02 07:39:06 +02:00
|
|
|
out:
|
2011-08-02 08:06:17 +02:00
|
|
|
put_fid(pdu, file_fidp);
|
2011-05-18 14:08:07 +02:00
|
|
|
if (xattr_fidp) {
|
2011-08-02 08:06:17 +02:00
|
|
|
put_fid(pdu, xattr_fidp);
|
2011-05-18 14:08:07 +02:00
|
|
|
}
|
|
|
|
out_nofid:
|
2015-12-02 16:00:14 +01:00
|
|
|
pdu_complete(pdu, err);
|
2011-05-19 01:05:48 +02:00
|
|
|
v9fs_string_free(&name);
|
2010-09-02 07:39:06 +02:00
|
|
|
}
|
|
|
|
|
2016-10-17 14:13:58 +02:00
|
|
|
static void coroutine_fn v9fs_xattrcreate(void *opaque)
|
2010-09-02 07:39:07 +02:00
|
|
|
{
|
2018-06-07 12:17:22 +02:00
|
|
|
int flags, rflags = 0;
|
2010-09-02 07:39:07 +02:00
|
|
|
int32_t fid;
|
2016-11-01 12:00:40 +01:00
|
|
|
uint64_t size;
|
2010-09-02 07:39:07 +02:00
|
|
|
ssize_t err = 0;
|
2011-05-19 01:06:26 +02:00
|
|
|
V9fsString name;
|
|
|
|
size_t offset = 7;
|
|
|
|
V9fsFidState *file_fidp;
|
|
|
|
V9fsFidState *xattr_fidp;
|
|
|
|
V9fsPDU *pdu = opaque;
|
2010-09-02 07:39:07 +02:00
|
|
|
|
2011-12-14 09:19:13 +01:00
|
|
|
v9fs_string_init(&name);
|
|
|
|
err = pdu_unmarshal(pdu, offset, "dsqd", &fid, &name, &size, &flags);
|
|
|
|
if (err < 0) {
|
|
|
|
goto out_nofid;
|
|
|
|
}
|
2011-10-12 15:41:25 +02:00
|
|
|
trace_v9fs_xattrcreate(pdu->tag, pdu->id, fid, name.data, size, flags);
|
2010-09-02 07:39:07 +02:00
|
|
|
|
2018-06-07 12:17:22 +02:00
|
|
|
if (flags & ~(P9_XATTR_CREATE | P9_XATTR_REPLACE)) {
|
|
|
|
err = -EINVAL;
|
|
|
|
goto out_nofid;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (flags & P9_XATTR_CREATE) {
|
|
|
|
rflags |= XATTR_CREATE;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (flags & P9_XATTR_REPLACE) {
|
|
|
|
rflags |= XATTR_REPLACE;
|
|
|
|
}
|
|
|
|
|
2016-11-01 12:00:40 +01:00
|
|
|
if (size > XATTR_SIZE_MAX) {
|
|
|
|
err = -E2BIG;
|
|
|
|
goto out_nofid;
|
|
|
|
}
|
|
|
|
|
2011-08-02 08:06:17 +02:00
|
|
|
file_fidp = get_fid(pdu, fid);
|
2011-05-19 01:06:26 +02:00
|
|
|
if (file_fidp == NULL) {
|
2010-09-02 07:39:07 +02:00
|
|
|
err = -EINVAL;
|
2011-05-18 14:08:07 +02:00
|
|
|
goto out_nofid;
|
2010-09-02 07:39:07 +02:00
|
|
|
}
|
2016-11-01 12:00:40 +01:00
|
|
|
if (file_fidp->fid_type != P9_FID_NONE) {
|
|
|
|
err = -EINVAL;
|
|
|
|
goto out_put_fid;
|
|
|
|
}
|
|
|
|
|
2010-09-02 07:39:07 +02:00
|
|
|
/* Make the file fid point to xattr */
|
2011-05-19 01:06:26 +02:00
|
|
|
xattr_fidp = file_fidp;
|
|
|
|
xattr_fidp->fid_type = P9_FID_XATTR;
|
|
|
|
xattr_fidp->fs.xattr.copied_len = 0;
|
2016-11-01 12:00:40 +01:00
|
|
|
xattr_fidp->fs.xattr.xattrwalk_fid = false;
|
2011-05-19 01:06:26 +02:00
|
|
|
xattr_fidp->fs.xattr.len = size;
|
2018-06-07 12:17:22 +02:00
|
|
|
xattr_fidp->fs.xattr.flags = rflags;
|
2011-05-19 01:06:26 +02:00
|
|
|
v9fs_string_init(&xattr_fidp->fs.xattr.name);
|
|
|
|
v9fs_string_copy(&xattr_fidp->fs.xattr.name, &name);
|
2016-10-17 14:13:58 +02:00
|
|
|
xattr_fidp->fs.xattr.value = g_malloc0(size);
|
2011-05-19 01:06:26 +02:00
|
|
|
err = offset;
|
2016-11-01 12:00:40 +01:00
|
|
|
out_put_fid:
|
2011-08-02 08:06:17 +02:00
|
|
|
put_fid(pdu, file_fidp);
|
2011-05-18 14:08:07 +02:00
|
|
|
out_nofid:
|
2015-12-02 16:00:14 +01:00
|
|
|
pdu_complete(pdu, err);
|
2011-05-19 01:06:26 +02:00
|
|
|
v9fs_string_free(&name);
|
2010-09-02 07:39:07 +02:00
|
|
|
}
|
2010-09-02 07:39:06 +02:00
|
|
|
|
2016-10-17 14:13:58 +02:00
|
|
|
static void coroutine_fn v9fs_readlink(void *opaque)
|
2010-09-14 11:38:25 +02:00
|
|
|
{
|
2011-05-18 23:18:05 +02:00
|
|
|
V9fsPDU *pdu = opaque;
|
2011-08-08 20:06:41 +02:00
|
|
|
size_t offset = 7;
|
|
|
|
V9fsString target;
|
2010-09-14 11:38:25 +02:00
|
|
|
int32_t fid;
|
|
|
|
int err = 0;
|
|
|
|
V9fsFidState *fidp;
|
|
|
|
|
2011-12-14 09:19:13 +01:00
|
|
|
err = pdu_unmarshal(pdu, offset, "d", &fid);
|
|
|
|
if (err < 0) {
|
|
|
|
goto out_nofid;
|
|
|
|
}
|
2011-10-12 15:41:25 +02:00
|
|
|
trace_v9fs_readlink(pdu->tag, pdu->id, fid);
|
2011-08-02 08:06:17 +02:00
|
|
|
fidp = get_fid(pdu, fid);
|
2010-09-14 11:38:25 +02:00
|
|
|
if (fidp == NULL) {
|
|
|
|
err = -ENOENT;
|
2011-05-18 14:08:07 +02:00
|
|
|
goto out_nofid;
|
2010-09-14 11:38:25 +02:00
|
|
|
}
|
|
|
|
|
2011-08-08 20:06:41 +02:00
|
|
|
v9fs_string_init(&target);
|
2011-08-02 08:06:17 +02:00
|
|
|
err = v9fs_co_readlink(pdu, &fidp->path, &target);
|
2011-08-08 20:06:41 +02:00
|
|
|
if (err < 0) {
|
|
|
|
goto out;
|
|
|
|
}
|
2011-12-14 09:19:13 +01:00
|
|
|
err = pdu_marshal(pdu, offset, "s", &target);
|
|
|
|
if (err < 0) {
|
|
|
|
v9fs_string_free(&target);
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
err += offset;
|
2011-10-24 11:39:49 +02:00
|
|
|
trace_v9fs_readlink_return(pdu->tag, pdu->id, target.data);
|
2011-08-08 20:06:41 +02:00
|
|
|
v9fs_string_free(&target);
|
2010-09-14 11:38:25 +02:00
|
|
|
out:
|
2011-08-02 08:06:17 +02:00
|
|
|
put_fid(pdu, fidp);
|
2011-05-18 14:08:07 +02:00
|
|
|
out_nofid:
|
2015-12-02 16:00:14 +01:00
|
|
|
pdu_complete(pdu, err);
|
2010-09-14 11:38:25 +02:00
|
|
|
}
|
|
|
|
|
2011-05-18 23:18:05 +02:00
|
|
|
static CoroutineEntry *pdu_co_handlers[] = {
|
2010-06-09 11:27:57 +02:00
|
|
|
[P9_TREADDIR] = v9fs_readdir,
|
2010-05-10 08:41:03 +02:00
|
|
|
[P9_TSTATFS] = v9fs_statfs,
|
virtio-9p: getattr server 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: M. Mohan Kumar <mohan@in.ibm.com>
Signed-off-by: Sripathi Kodi <sripathik@in.ibm.com>
2010-07-20 08:14:41 +02:00
|
|
|
[P9_TGETATTR] = v9fs_getattr,
|
virtio-9p: Implement server 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_CTIME (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.
[jvrao@linux.vnet.ibm.com: Parts of code for handling chown(-1,-1)
Signed-off-by: Sripathi Kodi <sripathik@in.ibm.com>
Signed-off-by: Venkateswararao Jujjuri <jvrao@linux.vnet.ibm.com>
2010-06-17 14:48:47 +02:00
|
|
|
[P9_TSETATTR] = v9fs_setattr,
|
2010-09-02 07:39:06 +02:00
|
|
|
[P9_TXATTRWALK] = v9fs_xattrwalk,
|
2010-09-02 07:39:07 +02:00
|
|
|
[P9_TXATTRCREATE] = v9fs_xattrcreate,
|
2010-06-22 08:54:09 +02:00
|
|
|
[P9_TMKNOD] = v9fs_mknod,
|
2010-06-22 08:59:41 +02:00
|
|
|
[P9_TRENAME] = v9fs_rename,
|
[virto-9p] Implement TLOCK
Synopsis
size[4] TLock tag[2] fid[4] flock[n]
size[4] RLock tag[2] status[1]
Description
Tlock is used to acquire/release byte range posix locks on a file
identified by given fid. The reply contains status of the lock request
flock structure:
type[1] - Type of lock: F_RDLCK, F_WRLCK, F_UNLCK
flags[4] - Flags could be either of
P9_LOCK_FLAGS_BLOCK(1) - Blocked lock request, if there is a
conflicting lock exists, wait for that lock to be released.
P9_LOCK_FLAGS_RECLAIM(2) - Reclaim lock request, used when client is
trying to reclaim a lock after a server restrart (due to crash)
start[8] - Starting offset for lock
length[8] - Number of bytes to lock
If length is 0, lock all bytes starting at the location 'start'
through to the end of file
pid[4] - PID of the process that wants to take lock
client_id[4] - Unique client id
status[1] - Status of the lock request, can be
P9_LOCK_SUCCESS(0), P9_LOCK_BLOCKED(1), P9_LOCK_ERROR(2) or
P9_LOCK_GRACE(3)
P9_LOCK_SUCCESS - Request was successful
P9_LOCK_BLOCKED - A conflicting lock is held by another process
P9_LOCK_ERROR - Error while processing the lock request
P9_LOCK_GRACE - Server is in grace period, it can't accept new lock
requests in this period (except locks with
P9_LOCK_FLAGS_RECLAIM flag set)
Signed-off-by: M. Mohan Kumar <mohan@in.ibm.com>
Signed-off-by: Aneesh Kumar K.V <aneesh.kumar@linux.vnet.ibm.com>
Signed-off-by: Venkateswararao Jujjuri <jvrao@linux.vnet.ibm.com>
2010-09-07 22:49:32 +02:00
|
|
|
[P9_TLOCK] = v9fs_lock,
|
2010-09-07 23:06:52 +02:00
|
|
|
[P9_TGETLOCK] = v9fs_getlock,
|
2011-05-23 19:54:41 +02:00
|
|
|
[P9_TRENAMEAT] = v9fs_renameat,
|
2010-09-14 11:38:25 +02:00
|
|
|
[P9_TREADLINK] = v9fs_readlink,
|
2011-09-09 11:37:01 +02:00
|
|
|
[P9_TUNLINKAT] = v9fs_unlinkat,
|
2010-06-22 08:55:22 +02:00
|
|
|
[P9_TMKDIR] = v9fs_mkdir,
|
2010-04-29 14:14:44 +02:00
|
|
|
[P9_TVERSION] = v9fs_version,
|
2010-06-22 16:17:04 +02:00
|
|
|
[P9_TLOPEN] = v9fs_open,
|
2010-04-29 14:14:44 +02:00
|
|
|
[P9_TATTACH] = v9fs_attach,
|
|
|
|
[P9_TSTAT] = v9fs_stat,
|
|
|
|
[P9_TWALK] = v9fs_walk,
|
|
|
|
[P9_TCLUNK] = v9fs_clunk,
|
2010-09-23 02:18:33 +02:00
|
|
|
[P9_TFSYNC] = v9fs_fsync,
|
2010-04-29 14:14:44 +02:00
|
|
|
[P9_TOPEN] = v9fs_open,
|
|
|
|
[P9_TREAD] = v9fs_read,
|
|
|
|
#if 0
|
|
|
|
[P9_TAUTH] = v9fs_auth,
|
|
|
|
#endif
|
|
|
|
[P9_TFLUSH] = v9fs_flush,
|
2010-06-09 20:21:15 +02:00
|
|
|
[P9_TLINK] = v9fs_link,
|
2010-06-09 23:02:08 +02:00
|
|
|
[P9_TSYMLINK] = v9fs_symlink,
|
2010-04-29 14:14:44 +02:00
|
|
|
[P9_TCREATE] = v9fs_create,
|
2010-06-18 03:27:24 +02:00
|
|
|
[P9_TLCREATE] = v9fs_lcreate,
|
2010-04-29 14:14:44 +02:00
|
|
|
[P9_TWRITE] = v9fs_write,
|
|
|
|
[P9_TWSTAT] = v9fs_wstat,
|
|
|
|
[P9_TREMOVE] = v9fs_remove,
|
|
|
|
};
|
|
|
|
|
2016-10-17 14:13:58 +02:00
|
|
|
static void coroutine_fn v9fs_op_not_supp(void *opaque)
|
2011-06-01 09:05:14 +02:00
|
|
|
{
|
2011-05-18 23:18:05 +02:00
|
|
|
V9fsPDU *pdu = opaque;
|
2015-12-02 16:00:14 +01:00
|
|
|
pdu_complete(pdu, -EOPNOTSUPP);
|
2011-06-01 09:05:14 +02:00
|
|
|
}
|
|
|
|
|
2016-10-17 14:13:58 +02:00
|
|
|
static void coroutine_fn v9fs_fs_ro(void *opaque)
|
2011-10-25 08:40:39 +02:00
|
|
|
{
|
|
|
|
V9fsPDU *pdu = opaque;
|
2015-12-02 16:00:14 +01:00
|
|
|
pdu_complete(pdu, -EROFS);
|
2011-10-25 08:40:39 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
static inline bool is_read_only_op(V9fsPDU *pdu)
|
|
|
|
{
|
|
|
|
switch (pdu->id) {
|
|
|
|
case P9_TREADDIR:
|
|
|
|
case P9_TSTATFS:
|
|
|
|
case P9_TGETATTR:
|
|
|
|
case P9_TXATTRWALK:
|
|
|
|
case P9_TLOCK:
|
|
|
|
case P9_TGETLOCK:
|
|
|
|
case P9_TREADLINK:
|
|
|
|
case P9_TVERSION:
|
|
|
|
case P9_TLOPEN:
|
|
|
|
case P9_TATTACH:
|
|
|
|
case P9_TSTAT:
|
|
|
|
case P9_TWALK:
|
|
|
|
case P9_TCLUNK:
|
|
|
|
case P9_TFSYNC:
|
|
|
|
case P9_TOPEN:
|
|
|
|
case P9_TREAD:
|
|
|
|
case P9_TAUTH:
|
|
|
|
case P9_TFLUSH:
|
|
|
|
return 1;
|
|
|
|
default:
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-05-25 10:30:13 +02:00
|
|
|
void pdu_submit(V9fsPDU *pdu, P9MsgHeader *hdr)
|
2010-04-29 14:14:44 +02:00
|
|
|
{
|
2011-05-18 23:18:05 +02:00
|
|
|
Coroutine *co;
|
|
|
|
CoroutineEntry *handler;
|
2015-12-02 13:06:28 +01:00
|
|
|
V9fsState *s = pdu->s;
|
2010-04-29 14:14:44 +02:00
|
|
|
|
2017-05-25 10:30:13 +02:00
|
|
|
pdu->size = le32_to_cpu(hdr->size_le);
|
|
|
|
pdu->id = hdr->id;
|
|
|
|
pdu->tag = le16_to_cpu(hdr->tag_le);
|
|
|
|
|
2011-05-18 23:18:05 +02:00
|
|
|
if (pdu->id >= ARRAY_SIZE(pdu_co_handlers) ||
|
|
|
|
(pdu_co_handlers[pdu->id] == NULL)) {
|
2011-06-01 09:05:14 +02:00
|
|
|
handler = v9fs_op_not_supp;
|
2018-01-08 11:18:22 +01:00
|
|
|
} else if (is_ro_export(&s->ctx) && !is_read_only_op(pdu)) {
|
|
|
|
handler = v9fs_fs_ro;
|
2011-06-01 09:05:14 +02:00
|
|
|
} else {
|
2011-05-18 23:18:05 +02:00
|
|
|
handler = pdu_co_handlers[pdu->id];
|
2011-06-01 09:05:14 +02:00
|
|
|
}
|
2011-10-25 08:40:39 +02:00
|
|
|
|
2017-05-25 10:30:13 +02:00
|
|
|
qemu_co_queue_init(&pdu->complete);
|
coroutine: move entry argument to qemu_coroutine_create
In practice the entry argument is always known at creation time, and
it is confusing that sometimes qemu_coroutine_enter is used with a
non-NULL argument to re-enter a coroutine (this happens in
block/sheepdog.c and tests/test-coroutine.c). So pass the opaque value
at creation time, for consistency with e.g. aio_bh_new.
Mostly done with the following semantic patch:
@ entry1 @
expression entry, arg, co;
@@
- co = qemu_coroutine_create(entry);
+ co = qemu_coroutine_create(entry, arg);
...
- qemu_coroutine_enter(co, arg);
+ qemu_coroutine_enter(co);
@ entry2 @
expression entry, arg;
identifier co;
@@
- Coroutine *co = qemu_coroutine_create(entry);
+ Coroutine *co = qemu_coroutine_create(entry, arg);
...
- qemu_coroutine_enter(co, arg);
+ qemu_coroutine_enter(co);
@ entry3 @
expression entry, arg;
@@
- qemu_coroutine_enter(qemu_coroutine_create(entry), arg);
+ qemu_coroutine_enter(qemu_coroutine_create(entry, arg));
@ reentry @
expression co;
@@
- qemu_coroutine_enter(co, NULL);
+ qemu_coroutine_enter(co);
except for the aforementioned few places where the semantic patch
stumbled (as expected) and for test_co_queue, which would otherwise
produce an uninitialized variable warning.
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
Reviewed-by: Fam Zheng <famz@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
2016-07-04 19:10:01 +02:00
|
|
|
co = qemu_coroutine_create(handler, pdu);
|
|
|
|
qemu_coroutine_enter(co);
|
2010-04-29 14:14:44 +02:00
|
|
|
}
|
|
|
|
|
2015-12-03 12:55:49 +01:00
|
|
|
/* Returns 0 on success, 1 on failure. */
|
2018-02-01 21:21:27 +01:00
|
|
|
int v9fs_device_realize_common(V9fsState *s, const V9fsTransport *t,
|
|
|
|
Error **errp)
|
2015-12-03 12:55:49 +01:00
|
|
|
{
|
2020-07-07 18:50:35 +02:00
|
|
|
ERRP_GUARD();
|
2015-12-03 12:55:49 +01:00
|
|
|
int i, len;
|
|
|
|
struct stat stat;
|
|
|
|
FsDriverEntry *fse;
|
|
|
|
V9fsPath path;
|
|
|
|
int rc = 1;
|
|
|
|
|
2018-02-01 21:21:27 +01:00
|
|
|
assert(!s->transport);
|
|
|
|
s->transport = t;
|
|
|
|
|
2015-12-03 12:55:49 +01:00
|
|
|
/* initialize pdu allocator */
|
|
|
|
QLIST_INIT(&s->free_list);
|
|
|
|
QLIST_INIT(&s->active_list);
|
2017-01-13 18:18:20 +01:00
|
|
|
for (i = 0; i < MAX_REQ; i++) {
|
2017-01-03 17:28:44 +01:00
|
|
|
QLIST_INSERT_HEAD(&s->free_list, &s->pdus[i], next);
|
|
|
|
s->pdus[i].s = s;
|
|
|
|
s->pdus[i].idx = i;
|
2015-12-03 12:55:49 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
v9fs_path_init(&path);
|
|
|
|
|
|
|
|
fse = get_fsdev_fsentry(s->fsconf.fsdev_id);
|
|
|
|
|
|
|
|
if (!fse) {
|
|
|
|
/* We don't have a fsdev identified by fsdev_id */
|
|
|
|
error_setg(errp, "9pfs device couldn't find fsdev with the "
|
|
|
|
"id = %s",
|
|
|
|
s->fsconf.fsdev_id ? s->fsconf.fsdev_id : "NULL");
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!s->fsconf.tag) {
|
|
|
|
/* we haven't specified a mount_tag */
|
|
|
|
error_setg(errp, "fsdev with id %s needs mount_tag arguments",
|
|
|
|
s->fsconf.fsdev_id);
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
s->ctx.export_flags = fse->export_flags;
|
|
|
|
s->ctx.fs_root = g_strdup(fse->path);
|
|
|
|
s->ctx.exops.get_st_gen = NULL;
|
|
|
|
len = strlen(s->fsconf.tag);
|
|
|
|
if (len > MAX_TAG_LEN - 1) {
|
|
|
|
error_setg(errp, "mount tag '%s' (%d bytes) is longer than "
|
|
|
|
"maximum (%d bytes)", s->fsconf.tag, len, MAX_TAG_LEN - 1);
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
s->tag = g_strdup(s->fsconf.tag);
|
|
|
|
s->ctx.uid = -1;
|
|
|
|
|
|
|
|
s->ops = fse->ops;
|
|
|
|
|
2017-06-29 15:11:50 +02:00
|
|
|
s->ctx.fmode = fse->fmode;
|
|
|
|
s->ctx.dmode = fse->dmode;
|
|
|
|
|
2021-01-18 15:22:59 +01:00
|
|
|
QSIMPLEQ_INIT(&s->fid_list);
|
2015-12-03 12:55:49 +01:00
|
|
|
qemu_co_rwlock_init(&s->rename_lock);
|
|
|
|
|
2018-01-08 11:18:23 +01:00
|
|
|
if (s->ops->init(&s->ctx, errp) < 0) {
|
|
|
|
error_prepend(errp, "cannot initialize fsdev '%s': ",
|
|
|
|
s->fsconf.fsdev_id);
|
2015-12-03 12:55:49 +01:00
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Check details of export path, We need to use fs driver
|
|
|
|
* call back to do that. Since we are in the init path, we don't
|
|
|
|
* use co-routines here.
|
|
|
|
*/
|
|
|
|
if (s->ops->name_to_path(&s->ctx, NULL, "/", &path) < 0) {
|
|
|
|
error_setg(errp,
|
|
|
|
"error in converting name to path %s", strerror(errno));
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
if (s->ops->lstat(&s->ctx, &path, &stat)) {
|
|
|
|
error_setg(errp, "share path %s does not exist", fse->path);
|
|
|
|
goto out;
|
|
|
|
} else if (!S_ISDIR(stat.st_mode)) {
|
|
|
|
error_setg(errp, "share path %s is not a directory", fse->path);
|
|
|
|
goto out;
|
|
|
|
}
|
2017-02-28 10:31:46 +01:00
|
|
|
|
2019-10-10 11:36:05 +02:00
|
|
|
s->dev_id = stat.st_dev;
|
|
|
|
|
2019-10-07 17:02:45 +02:00
|
|
|
/* init inode remapping : */
|
|
|
|
/* hash table for variable length inode suffixes */
|
|
|
|
qpd_table_init(&s->qpd_table);
|
|
|
|
/* hash table for slow/full inode remapping (most users won't need it) */
|
|
|
|
qpf_table_init(&s->qpf_table);
|
|
|
|
/* hash table for quick inode remapping */
|
2019-10-10 11:36:05 +02:00
|
|
|
qpp_table_init(&s->qpp_table);
|
2019-10-07 17:02:45 +02:00
|
|
|
s->qp_ndevices = 0;
|
|
|
|
s->qp_affix_next = 1; /* reserve 0 to detect overflow */
|
2019-10-07 17:02:45 +02:00
|
|
|
s->qp_fullpath_next = 1;
|
2019-10-10 11:36:05 +02:00
|
|
|
|
2017-02-28 10:31:46 +01:00
|
|
|
s->ctx.fst = &fse->fst;
|
|
|
|
fsdev_throttle_init(s->ctx.fst);
|
|
|
|
|
2015-12-03 12:55:49 +01:00
|
|
|
rc = 0;
|
|
|
|
out:
|
|
|
|
if (rc) {
|
qdev: Unrealize must not fail
Devices may have component devices and buses.
Device realization may fail. Realization is recursive: a device's
realize() method realizes its components, and device_set_realized()
realizes its buses (which should in turn realize the devices on that
bus, except bus_set_realized() doesn't implement that, yet).
When realization of a component or bus fails, we need to roll back:
unrealize everything we realized so far. If any of these unrealizes
failed, the device would be left in an inconsistent state. Must not
happen.
device_set_realized() lets it happen: it ignores errors in the roll
back code starting at label child_realize_fail.
Since realization is recursive, unrealization must be recursive, too.
But how could a partly failed unrealize be rolled back? We'd have to
re-realize, which can fail. This design is fundamentally broken.
device_set_realized() does not roll back at all. Instead, it keeps
unrealizing, ignoring further errors.
It can screw up even for a device with no buses: if the lone
dc->unrealize() fails, it still unregisters vmstate, and calls
listeners' unrealize() callback.
bus_set_realized() does not roll back either. Instead, it stops
unrealizing.
Fortunately, no unrealize method can fail, as we'll see below.
To fix the design error, drop parameter @errp from all the unrealize
methods.
Any unrealize method that uses @errp now needs an update. This leads
us to unrealize() methods that can fail. Merely passing it to another
unrealize method cannot cause failure, though. Here are the ones that
do other things with @errp:
* virtio_serial_device_unrealize()
Fails when qbus_set_hotplug_handler() fails, but still does all the
other work. On failure, the device would stay realized with its
resources completely gone. Oops. Can't happen, because
qbus_set_hotplug_handler() can't actually fail here. Pass
&error_abort to qbus_set_hotplug_handler() instead.
* hw/ppc/spapr_drc.c's unrealize()
Fails when object_property_del() fails, but all the other work is
already done. On failure, the device would stay realized with its
vmstate registration gone. Oops. Can't happen, because
object_property_del() can't actually fail here. Pass &error_abort
to object_property_del() instead.
* spapr_phb_unrealize()
Fails and bails out when remove_drcs() fails, but other work is
already done. On failure, the device would stay realized with some
of its resources gone. Oops. remove_drcs() fails only when
chassis_from_bus()'s object_property_get_uint() fails, and it can't
here. Pass &error_abort to remove_drcs() instead.
Therefore, no unrealize method can fail before this patch.
device_set_realized()'s recursive unrealization via bus uses
object_property_set_bool(). Can't drop @errp there, so pass
&error_abort.
We similarly unrealize with object_property_set_bool() elsewhere,
always ignoring errors. Pass &error_abort instead.
Several unrealize methods no longer handle errors from other unrealize
methods: virtio_9p_device_unrealize(),
virtio_input_device_unrealize(), scsi_qdev_unrealize(), ...
Much of the deleted error handling looks wrong anyway.
One unrealize methods no longer ignore such errors:
usb_ehci_pci_exit().
Several realize methods no longer ignore errors when rolling back:
v9fs_device_realize_common(), pci_qdev_unrealize(),
spapr_phb_realize(), usb_qdev_realize(), vfio_ccw_realize(),
virtio_device_realize().
Signed-off-by: Markus Armbruster <armbru@redhat.com>
Reviewed-by: Philippe Mathieu-Daudé <philmd@redhat.com>
Reviewed-by: Paolo Bonzini <pbonzini@redhat.com>
Message-Id: <20200505152926.18877-17-armbru@redhat.com>
2020-05-05 17:29:24 +02:00
|
|
|
v9fs_device_unrealize_common(s);
|
2015-12-03 12:55:49 +01:00
|
|
|
}
|
2019-10-10 11:36:04 +02:00
|
|
|
v9fs_path_free(&path);
|
2015-12-03 12:55:49 +01:00
|
|
|
return rc;
|
|
|
|
}
|
|
|
|
|
qdev: Unrealize must not fail
Devices may have component devices and buses.
Device realization may fail. Realization is recursive: a device's
realize() method realizes its components, and device_set_realized()
realizes its buses (which should in turn realize the devices on that
bus, except bus_set_realized() doesn't implement that, yet).
When realization of a component or bus fails, we need to roll back:
unrealize everything we realized so far. If any of these unrealizes
failed, the device would be left in an inconsistent state. Must not
happen.
device_set_realized() lets it happen: it ignores errors in the roll
back code starting at label child_realize_fail.
Since realization is recursive, unrealization must be recursive, too.
But how could a partly failed unrealize be rolled back? We'd have to
re-realize, which can fail. This design is fundamentally broken.
device_set_realized() does not roll back at all. Instead, it keeps
unrealizing, ignoring further errors.
It can screw up even for a device with no buses: if the lone
dc->unrealize() fails, it still unregisters vmstate, and calls
listeners' unrealize() callback.
bus_set_realized() does not roll back either. Instead, it stops
unrealizing.
Fortunately, no unrealize method can fail, as we'll see below.
To fix the design error, drop parameter @errp from all the unrealize
methods.
Any unrealize method that uses @errp now needs an update. This leads
us to unrealize() methods that can fail. Merely passing it to another
unrealize method cannot cause failure, though. Here are the ones that
do other things with @errp:
* virtio_serial_device_unrealize()
Fails when qbus_set_hotplug_handler() fails, but still does all the
other work. On failure, the device would stay realized with its
resources completely gone. Oops. Can't happen, because
qbus_set_hotplug_handler() can't actually fail here. Pass
&error_abort to qbus_set_hotplug_handler() instead.
* hw/ppc/spapr_drc.c's unrealize()
Fails when object_property_del() fails, but all the other work is
already done. On failure, the device would stay realized with its
vmstate registration gone. Oops. Can't happen, because
object_property_del() can't actually fail here. Pass &error_abort
to object_property_del() instead.
* spapr_phb_unrealize()
Fails and bails out when remove_drcs() fails, but other work is
already done. On failure, the device would stay realized with some
of its resources gone. Oops. remove_drcs() fails only when
chassis_from_bus()'s object_property_get_uint() fails, and it can't
here. Pass &error_abort to remove_drcs() instead.
Therefore, no unrealize method can fail before this patch.
device_set_realized()'s recursive unrealization via bus uses
object_property_set_bool(). Can't drop @errp there, so pass
&error_abort.
We similarly unrealize with object_property_set_bool() elsewhere,
always ignoring errors. Pass &error_abort instead.
Several unrealize methods no longer handle errors from other unrealize
methods: virtio_9p_device_unrealize(),
virtio_input_device_unrealize(), scsi_qdev_unrealize(), ...
Much of the deleted error handling looks wrong anyway.
One unrealize methods no longer ignore such errors:
usb_ehci_pci_exit().
Several realize methods no longer ignore errors when rolling back:
v9fs_device_realize_common(), pci_qdev_unrealize(),
spapr_phb_realize(), usb_qdev_realize(), vfio_ccw_realize(),
virtio_device_realize().
Signed-off-by: Markus Armbruster <armbru@redhat.com>
Reviewed-by: Philippe Mathieu-Daudé <philmd@redhat.com>
Reviewed-by: Paolo Bonzini <pbonzini@redhat.com>
Message-Id: <20200505152926.18877-17-armbru@redhat.com>
2020-05-05 17:29:24 +02:00
|
|
|
void v9fs_device_unrealize_common(V9fsState *s)
|
2015-12-03 12:55:49 +01:00
|
|
|
{
|
2019-10-10 11:36:04 +02:00
|
|
|
if (s->ops && s->ops->cleanup) {
|
2016-11-23 13:53:34 +01:00
|
|
|
s->ops->cleanup(&s->ctx);
|
|
|
|
}
|
2019-10-10 11:36:04 +02:00
|
|
|
if (s->ctx.fst) {
|
|
|
|
fsdev_throttle_cleanup(s->ctx.fst);
|
|
|
|
}
|
2015-12-03 12:55:49 +01:00
|
|
|
g_free(s->tag);
|
2019-10-07 17:02:45 +02:00
|
|
|
qp_table_destroy(&s->qpd_table);
|
2019-10-07 17:02:45 +02:00
|
|
|
qp_table_destroy(&s->qpp_table);
|
|
|
|
qp_table_destroy(&s->qpf_table);
|
2016-11-23 13:53:34 +01:00
|
|
|
g_free(s->ctx.fs_root);
|
2015-12-03 12:55:49 +01:00
|
|
|
}
|
|
|
|
|
2016-10-17 14:13:58 +02:00
|
|
|
typedef struct VirtfsCoResetData {
|
|
|
|
V9fsPDU pdu;
|
|
|
|
bool done;
|
|
|
|
} VirtfsCoResetData;
|
|
|
|
|
|
|
|
static void coroutine_fn virtfs_co_reset(void *opaque)
|
|
|
|
{
|
|
|
|
VirtfsCoResetData *data = opaque;
|
|
|
|
|
|
|
|
virtfs_reset(&data->pdu);
|
|
|
|
data->done = true;
|
|
|
|
}
|
|
|
|
|
|
|
|
void v9fs_reset(V9fsState *s)
|
|
|
|
{
|
|
|
|
VirtfsCoResetData data = { .pdu = { .s = s }, .done = false };
|
|
|
|
Coroutine *co;
|
|
|
|
|
|
|
|
while (!QLIST_EMPTY(&s->active_list)) {
|
|
|
|
aio_poll(qemu_get_aio_context(), true);
|
|
|
|
}
|
|
|
|
|
|
|
|
co = qemu_coroutine_create(virtfs_co_reset, &data);
|
|
|
|
qemu_coroutine_enter(co);
|
|
|
|
|
|
|
|
while (!data.done) {
|
|
|
|
aio_poll(qemu_get_aio_context(), true);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-01-07 19:40:09 +01:00
|
|
|
static void __attribute__((__constructor__)) v9fs_set_fd_limit(void)
|
2011-05-18 12:10:57 +02:00
|
|
|
{
|
|
|
|
struct rlimit rlim;
|
|
|
|
if (getrlimit(RLIMIT_NOFILE, &rlim) < 0) {
|
2016-01-22 15:12:17 +01:00
|
|
|
error_report("Failed to get the resource limit");
|
2011-05-18 12:10:57 +02:00
|
|
|
exit(1);
|
|
|
|
}
|
2020-10-30 05:35:13 +01:00
|
|
|
open_fd_hw = rlim.rlim_cur - MIN(400, rlim.rlim_cur / 3);
|
|
|
|
open_fd_rc = rlim.rlim_cur / 2;
|
2011-05-18 12:10:57 +02:00
|
|
|
}
|