660 lines
17 KiB
C
660 lines
17 KiB
C
/*
|
|
* 9p synthetic file system support
|
|
*
|
|
* Copyright IBM, Corp. 2011
|
|
*
|
|
* Authors:
|
|
* Malahal Naineni <malahal@us.ibm.com>
|
|
* Aneesh Kumar K.V <aneesh.kumar@linux.vnet.ibm.com>
|
|
*
|
|
* This work is licensed under the terms of the GNU GPL, version 2. See
|
|
* the COPYING file in the top-level directory.
|
|
*
|
|
*/
|
|
|
|
/*
|
|
* Not so fast! You might want to read the 9p developer docs first:
|
|
* https://wiki.qemu.org/Documentation/9p
|
|
*/
|
|
|
|
#include "qemu/osdep.h"
|
|
#include "9p.h"
|
|
#include "fsdev/qemu-fsdev.h"
|
|
#include "9p-synth.h"
|
|
#include "qemu/rcu.h"
|
|
#include "qemu/rcu_queue.h"
|
|
#include "qemu/cutils.h"
|
|
#include "sysemu/qtest.h"
|
|
|
|
/* Root node for synth file system */
|
|
static V9fsSynthNode synth_root = {
|
|
.name = "/",
|
|
.actual_attr = {
|
|
.mode = 0555 | S_IFDIR,
|
|
.nlink = 1,
|
|
},
|
|
.attr = &synth_root.actual_attr,
|
|
};
|
|
|
|
static QemuMutex synth_mutex;
|
|
static int synth_node_count;
|
|
/* set to 1 when the synth fs is ready */
|
|
static int synth_fs;
|
|
|
|
static V9fsSynthNode *v9fs_add_dir_node(V9fsSynthNode *parent, int mode,
|
|
const char *name,
|
|
V9fsSynthNodeAttr *attr, int inode)
|
|
{
|
|
V9fsSynthNode *node;
|
|
|
|
/* Add directory type and remove write bits */
|
|
mode = ((mode & 0777) | S_IFDIR) & ~(S_IWUSR | S_IWGRP | S_IWOTH);
|
|
node = g_new0(V9fsSynthNode, 1);
|
|
if (attr) {
|
|
/* We are adding .. or . entries */
|
|
node->attr = attr;
|
|
node->attr->nlink++;
|
|
} else {
|
|
node->attr = &node->actual_attr;
|
|
node->attr->inode = inode;
|
|
node->attr->nlink = 1;
|
|
/* We don't allow write to directories */
|
|
node->attr->mode = mode;
|
|
node->attr->write = NULL;
|
|
node->attr->read = NULL;
|
|
}
|
|
node->private = node;
|
|
pstrcpy(node->name, sizeof(node->name), name);
|
|
QLIST_INSERT_HEAD_RCU(&parent->child, node, sibling);
|
|
return node;
|
|
}
|
|
|
|
int qemu_v9fs_synth_mkdir(V9fsSynthNode *parent, int mode,
|
|
const char *name, V9fsSynthNode **result)
|
|
{
|
|
int ret;
|
|
V9fsSynthNode *node, *tmp;
|
|
|
|
if (!synth_fs) {
|
|
return EAGAIN;
|
|
}
|
|
if (!name || (strlen(name) >= NAME_MAX)) {
|
|
return EINVAL;
|
|
}
|
|
if (!parent) {
|
|
parent = &synth_root;
|
|
}
|
|
QEMU_LOCK_GUARD(&synth_mutex);
|
|
QLIST_FOREACH(tmp, &parent->child, sibling) {
|
|
if (!strcmp(tmp->name, name)) {
|
|
ret = EEXIST;
|
|
return ret;
|
|
}
|
|
}
|
|
/* Add the name */
|
|
node = v9fs_add_dir_node(parent, mode, name, NULL, ++synth_node_count);
|
|
v9fs_add_dir_node(node, parent->attr->mode, "..",
|
|
parent->attr, parent->attr->inode);
|
|
v9fs_add_dir_node(node, node->attr->mode, ".",
|
|
node->attr, node->attr->inode);
|
|
*result = node;
|
|
ret = 0;
|
|
return ret;
|
|
}
|
|
|
|
int qemu_v9fs_synth_add_file(V9fsSynthNode *parent, int mode,
|
|
const char *name, v9fs_synth_read read,
|
|
v9fs_synth_write write, void *arg)
|
|
{
|
|
int ret;
|
|
V9fsSynthNode *node, *tmp;
|
|
|
|
if (!synth_fs) {
|
|
return EAGAIN;
|
|
}
|
|
if (!name || (strlen(name) >= NAME_MAX)) {
|
|
return EINVAL;
|
|
}
|
|
if (!parent) {
|
|
parent = &synth_root;
|
|
}
|
|
|
|
QEMU_LOCK_GUARD(&synth_mutex);
|
|
QLIST_FOREACH(tmp, &parent->child, sibling) {
|
|
if (!strcmp(tmp->name, name)) {
|
|
ret = EEXIST;
|
|
return ret;
|
|
}
|
|
}
|
|
/* Add file type and remove write bits */
|
|
mode = ((mode & 0777) | S_IFREG);
|
|
node = g_new0(V9fsSynthNode, 1);
|
|
node->attr = &node->actual_attr;
|
|
node->attr->inode = ++synth_node_count;
|
|
node->attr->nlink = 1;
|
|
node->attr->read = read;
|
|
node->attr->write = write;
|
|
node->attr->mode = mode;
|
|
node->private = arg;
|
|
pstrcpy(node->name, sizeof(node->name), name);
|
|
QLIST_INSERT_HEAD_RCU(&parent->child, node, sibling);
|
|
ret = 0;
|
|
return ret;
|
|
}
|
|
|
|
static void synth_fill_statbuf(V9fsSynthNode *node, struct stat *stbuf)
|
|
{
|
|
stbuf->st_dev = 0;
|
|
stbuf->st_ino = node->attr->inode;
|
|
stbuf->st_mode = node->attr->mode;
|
|
stbuf->st_nlink = node->attr->nlink;
|
|
stbuf->st_uid = 0;
|
|
stbuf->st_gid = 0;
|
|
stbuf->st_rdev = 0;
|
|
stbuf->st_size = 0;
|
|
stbuf->st_blksize = 0;
|
|
stbuf->st_blocks = 0;
|
|
stbuf->st_atime = 0;
|
|
stbuf->st_mtime = 0;
|
|
stbuf->st_ctime = 0;
|
|
}
|
|
|
|
static int synth_lstat(FsContext *fs_ctx,
|
|
V9fsPath *fs_path, struct stat *stbuf)
|
|
{
|
|
V9fsSynthNode *node = *(V9fsSynthNode **)fs_path->data;
|
|
|
|
synth_fill_statbuf(node, stbuf);
|
|
return 0;
|
|
}
|
|
|
|
static int synth_fstat(FsContext *fs_ctx, int fid_type,
|
|
V9fsFidOpenState *fs, struct stat *stbuf)
|
|
{
|
|
V9fsSynthOpenState *synth_open = fs->private;
|
|
synth_fill_statbuf(synth_open->node, stbuf);
|
|
return 0;
|
|
}
|
|
|
|
static int synth_opendir(FsContext *ctx,
|
|
V9fsPath *fs_path, V9fsFidOpenState *fs)
|
|
{
|
|
V9fsSynthOpenState *synth_open;
|
|
V9fsSynthNode *node = *(V9fsSynthNode **)fs_path->data;
|
|
|
|
/*
|
|
* V9fsSynthOpenState contains 'struct dirent' which have OS-specific
|
|
* properties, thus it's zero cleared on allocation here and below
|
|
* in synth_open.
|
|
*/
|
|
synth_open = g_new0(V9fsSynthOpenState, 1);
|
|
synth_open->node = node;
|
|
node->open_count++;
|
|
fs->private = synth_open;
|
|
return 0;
|
|
}
|
|
|
|
static int synth_closedir(FsContext *ctx, V9fsFidOpenState *fs)
|
|
{
|
|
V9fsSynthOpenState *synth_open = fs->private;
|
|
V9fsSynthNode *node = synth_open->node;
|
|
|
|
node->open_count--;
|
|
g_free(synth_open);
|
|
fs->private = NULL;
|
|
return 0;
|
|
}
|
|
|
|
static off_t synth_telldir(FsContext *ctx, V9fsFidOpenState *fs)
|
|
{
|
|
V9fsSynthOpenState *synth_open = fs->private;
|
|
return synth_open->offset;
|
|
}
|
|
|
|
static void synth_seekdir(FsContext *ctx, V9fsFidOpenState *fs, off_t off)
|
|
{
|
|
V9fsSynthOpenState *synth_open = fs->private;
|
|
synth_open->offset = off;
|
|
}
|
|
|
|
static void synth_rewinddir(FsContext *ctx, V9fsFidOpenState *fs)
|
|
{
|
|
synth_seekdir(ctx, fs, 0);
|
|
}
|
|
|
|
static void synth_direntry(V9fsSynthNode *node,
|
|
struct dirent *entry, off_t off)
|
|
{
|
|
size_t sz = strlen(node->name) + 1;
|
|
/*
|
|
* 'entry' is always inside of V9fsSynthOpenState which have NAME_MAX
|
|
* back padding. Ensure we do not overflow it.
|
|
*/
|
|
g_assert(sizeof(struct dirent) + NAME_MAX >=
|
|
offsetof(struct dirent, d_name) + sz);
|
|
memcpy(entry->d_name, node->name, sz);
|
|
entry->d_ino = node->attr->inode;
|
|
#ifdef CONFIG_DARWIN
|
|
entry->d_seekoff = off + 1;
|
|
#else
|
|
entry->d_off = off + 1;
|
|
#endif
|
|
}
|
|
|
|
static struct dirent *synth_get_dentry(V9fsSynthNode *dir,
|
|
struct dirent *entry, off_t off)
|
|
{
|
|
int i = 0;
|
|
V9fsSynthNode *node;
|
|
|
|
rcu_read_lock();
|
|
QLIST_FOREACH(node, &dir->child, sibling) {
|
|
/* This is the off child of the directory */
|
|
if (i == off) {
|
|
break;
|
|
}
|
|
i++;
|
|
}
|
|
rcu_read_unlock();
|
|
if (!node) {
|
|
/* end of directory */
|
|
return NULL;
|
|
}
|
|
synth_direntry(node, entry, off);
|
|
return entry;
|
|
}
|
|
|
|
static struct dirent *synth_readdir(FsContext *ctx, V9fsFidOpenState *fs)
|
|
{
|
|
struct dirent *entry;
|
|
V9fsSynthOpenState *synth_open = fs->private;
|
|
V9fsSynthNode *node = synth_open->node;
|
|
entry = synth_get_dentry(node, &synth_open->dent, synth_open->offset);
|
|
if (entry) {
|
|
synth_open->offset++;
|
|
}
|
|
return entry;
|
|
}
|
|
|
|
static int synth_open(FsContext *ctx, V9fsPath *fs_path,
|
|
int flags, V9fsFidOpenState *fs)
|
|
{
|
|
V9fsSynthOpenState *synth_open;
|
|
V9fsSynthNode *node = *(V9fsSynthNode **)fs_path->data;
|
|
|
|
synth_open = g_new0(V9fsSynthOpenState, 1);
|
|
synth_open->node = node;
|
|
node->open_count++;
|
|
fs->private = synth_open;
|
|
return 0;
|
|
}
|
|
|
|
static int synth_open2(FsContext *fs_ctx, V9fsPath *dir_path,
|
|
const char *name, int flags,
|
|
FsCred *credp, V9fsFidOpenState *fs)
|
|
{
|
|
errno = ENOSYS;
|
|
return -1;
|
|
}
|
|
|
|
static int synth_close(FsContext *ctx, V9fsFidOpenState *fs)
|
|
{
|
|
V9fsSynthOpenState *synth_open = fs->private;
|
|
V9fsSynthNode *node = synth_open->node;
|
|
|
|
node->open_count--;
|
|
g_free(synth_open);
|
|
fs->private = NULL;
|
|
return 0;
|
|
}
|
|
|
|
static ssize_t synth_pwritev(FsContext *ctx, V9fsFidOpenState *fs,
|
|
const struct iovec *iov,
|
|
int iovcnt, off_t offset)
|
|
{
|
|
int i, count = 0, wcount;
|
|
V9fsSynthOpenState *synth_open = fs->private;
|
|
V9fsSynthNode *node = synth_open->node;
|
|
if (!node->attr->write) {
|
|
errno = EPERM;
|
|
return -1;
|
|
}
|
|
for (i = 0; i < iovcnt; i++) {
|
|
wcount = node->attr->write(iov[i].iov_base, iov[i].iov_len,
|
|
offset, node->private);
|
|
offset += wcount;
|
|
count += wcount;
|
|
/* If we wrote less than requested. we are done */
|
|
if (wcount < iov[i].iov_len) {
|
|
break;
|
|
}
|
|
}
|
|
return count;
|
|
}
|
|
|
|
static ssize_t synth_preadv(FsContext *ctx, V9fsFidOpenState *fs,
|
|
const struct iovec *iov,
|
|
int iovcnt, off_t offset)
|
|
{
|
|
int i, count = 0, rcount;
|
|
V9fsSynthOpenState *synth_open = fs->private;
|
|
V9fsSynthNode *node = synth_open->node;
|
|
if (!node->attr->read) {
|
|
errno = EPERM;
|
|
return -1;
|
|
}
|
|
for (i = 0; i < iovcnt; i++) {
|
|
rcount = node->attr->read(iov[i].iov_base, iov[i].iov_len,
|
|
offset, node->private);
|
|
offset += rcount;
|
|
count += rcount;
|
|
/* If we read less than requested. we are done */
|
|
if (rcount < iov[i].iov_len) {
|
|
break;
|
|
}
|
|
}
|
|
return count;
|
|
}
|
|
|
|
static int synth_truncate(FsContext *ctx, V9fsPath *path, off_t offset)
|
|
{
|
|
errno = ENOSYS;
|
|
return -1;
|
|
}
|
|
|
|
static int synth_chmod(FsContext *fs_ctx, V9fsPath *path, FsCred *credp)
|
|
{
|
|
errno = EPERM;
|
|
return -1;
|
|
}
|
|
|
|
static int synth_mknod(FsContext *fs_ctx, V9fsPath *path,
|
|
const char *buf, FsCred *credp)
|
|
{
|
|
errno = EPERM;
|
|
return -1;
|
|
}
|
|
|
|
static int synth_mkdir(FsContext *fs_ctx, V9fsPath *path,
|
|
const char *buf, FsCred *credp)
|
|
{
|
|
errno = EPERM;
|
|
return -1;
|
|
}
|
|
|
|
static ssize_t synth_readlink(FsContext *fs_ctx, V9fsPath *path,
|
|
char *buf, size_t bufsz)
|
|
{
|
|
errno = ENOSYS;
|
|
return -1;
|
|
}
|
|
|
|
static int synth_symlink(FsContext *fs_ctx, const char *oldpath,
|
|
V9fsPath *newpath, const char *buf, FsCred *credp)
|
|
{
|
|
errno = EPERM;
|
|
return -1;
|
|
}
|
|
|
|
static int synth_link(FsContext *fs_ctx, V9fsPath *oldpath,
|
|
V9fsPath *newpath, const char *buf)
|
|
{
|
|
errno = EPERM;
|
|
return -1;
|
|
}
|
|
|
|
static int synth_rename(FsContext *ctx, const char *oldpath,
|
|
const char *newpath)
|
|
{
|
|
errno = EPERM;
|
|
return -1;
|
|
}
|
|
|
|
static int synth_chown(FsContext *fs_ctx, V9fsPath *path, FsCred *credp)
|
|
{
|
|
errno = EPERM;
|
|
return -1;
|
|
}
|
|
|
|
static int synth_utimensat(FsContext *fs_ctx, V9fsPath *path,
|
|
const struct timespec *buf)
|
|
{
|
|
errno = EPERM;
|
|
return 0;
|
|
}
|
|
|
|
static int synth_remove(FsContext *ctx, const char *path)
|
|
{
|
|
errno = EPERM;
|
|
return -1;
|
|
}
|
|
|
|
static int synth_fsync(FsContext *ctx, int fid_type,
|
|
V9fsFidOpenState *fs, int datasync)
|
|
{
|
|
errno = ENOSYS;
|
|
return 0;
|
|
}
|
|
|
|
static int synth_statfs(FsContext *s, V9fsPath *fs_path,
|
|
struct statfs *stbuf)
|
|
{
|
|
stbuf->f_type = 0xABCD;
|
|
stbuf->f_bsize = 512;
|
|
stbuf->f_blocks = 0;
|
|
stbuf->f_files = synth_node_count;
|
|
#ifndef CONFIG_DARWIN
|
|
stbuf->f_namelen = NAME_MAX;
|
|
#endif
|
|
return 0;
|
|
}
|
|
|
|
static ssize_t synth_lgetxattr(FsContext *ctx, V9fsPath *path,
|
|
const char *name, void *value, size_t size)
|
|
{
|
|
errno = ENOTSUP;
|
|
return -1;
|
|
}
|
|
|
|
static ssize_t synth_llistxattr(FsContext *ctx, V9fsPath *path,
|
|
void *value, size_t size)
|
|
{
|
|
errno = ENOTSUP;
|
|
return -1;
|
|
}
|
|
|
|
static int synth_lsetxattr(FsContext *ctx, V9fsPath *path,
|
|
const char *name, void *value,
|
|
size_t size, int flags)
|
|
{
|
|
errno = ENOTSUP;
|
|
return -1;
|
|
}
|
|
|
|
static int synth_lremovexattr(FsContext *ctx,
|
|
V9fsPath *path, const char *name)
|
|
{
|
|
errno = ENOTSUP;
|
|
return -1;
|
|
}
|
|
|
|
static int synth_name_to_path(FsContext *ctx, V9fsPath *dir_path,
|
|
const char *name, V9fsPath *target)
|
|
{
|
|
V9fsSynthNode *node;
|
|
V9fsSynthNode *dir_node;
|
|
|
|
/* "." and ".." are not allowed */
|
|
if (!strcmp(name, ".") || !strcmp(name, "..")) {
|
|
errno = EINVAL;
|
|
return -1;
|
|
|
|
}
|
|
if (!dir_path) {
|
|
dir_node = &synth_root;
|
|
} else {
|
|
dir_node = *(V9fsSynthNode **)dir_path->data;
|
|
}
|
|
if (!strcmp(name, "/")) {
|
|
node = dir_node;
|
|
goto out;
|
|
}
|
|
/* search for the name in the childern */
|
|
rcu_read_lock();
|
|
QLIST_FOREACH(node, &dir_node->child, sibling) {
|
|
if (!strcmp(node->name, name)) {
|
|
break;
|
|
}
|
|
}
|
|
rcu_read_unlock();
|
|
|
|
if (!node) {
|
|
errno = ENOENT;
|
|
return -1;
|
|
}
|
|
out:
|
|
/* Copy the node pointer to fid */
|
|
g_free(target->data);
|
|
target->data = g_memdup(&node, sizeof(void *));
|
|
target->size = sizeof(void *);
|
|
return 0;
|
|
}
|
|
|
|
static int synth_renameat(FsContext *ctx, V9fsPath *olddir,
|
|
const char *old_name, V9fsPath *newdir,
|
|
const char *new_name)
|
|
{
|
|
errno = EPERM;
|
|
return -1;
|
|
}
|
|
|
|
static int synth_unlinkat(FsContext *ctx, V9fsPath *dir,
|
|
const char *name, int flags)
|
|
{
|
|
errno = EPERM;
|
|
return -1;
|
|
}
|
|
|
|
static ssize_t v9fs_synth_qtest_write(void *buf, int len, off_t offset,
|
|
void *arg)
|
|
{
|
|
return 1;
|
|
}
|
|
|
|
static ssize_t v9fs_synth_qtest_flush_write(void *buf, int len, off_t offset,
|
|
void *arg)
|
|
{
|
|
bool should_block = !!*(uint8_t *)buf;
|
|
|
|
if (should_block) {
|
|
/* This will cause the server to call us again until we're cancelled */
|
|
errno = EINTR;
|
|
return -1;
|
|
}
|
|
|
|
return 1;
|
|
}
|
|
|
|
static int synth_init(FsContext *ctx, Error **errp)
|
|
{
|
|
QLIST_INIT(&synth_root.child);
|
|
qemu_mutex_init(&synth_mutex);
|
|
|
|
/* Add "." and ".." entries for root */
|
|
v9fs_add_dir_node(&synth_root, synth_root.attr->mode,
|
|
"..", synth_root.attr, synth_root.attr->inode);
|
|
v9fs_add_dir_node(&synth_root, synth_root.attr->mode,
|
|
".", synth_root.attr, synth_root.attr->inode);
|
|
|
|
/* Mark the subsystem is ready for use */
|
|
synth_fs = 1;
|
|
|
|
if (qtest_enabled()) {
|
|
V9fsSynthNode *node = NULL;
|
|
int i, ret;
|
|
|
|
/* Directory hierarchy for WALK test */
|
|
for (i = 0; i < P9_MAXWELEM; i++) {
|
|
char *name = g_strdup_printf(QTEST_V9FS_SYNTH_WALK_FILE, i);
|
|
|
|
ret = qemu_v9fs_synth_mkdir(node, 0700, name, &node);
|
|
assert(!ret);
|
|
g_free(name);
|
|
}
|
|
|
|
/* File for LOPEN test */
|
|
ret = qemu_v9fs_synth_add_file(NULL, 0, QTEST_V9FS_SYNTH_LOPEN_FILE,
|
|
NULL, NULL, ctx);
|
|
assert(!ret);
|
|
|
|
/* File for WRITE test */
|
|
ret = qemu_v9fs_synth_add_file(NULL, 0, QTEST_V9FS_SYNTH_WRITE_FILE,
|
|
NULL, v9fs_synth_qtest_write, ctx);
|
|
assert(!ret);
|
|
|
|
/* File for FLUSH test */
|
|
ret = qemu_v9fs_synth_add_file(NULL, 0, QTEST_V9FS_SYNTH_FLUSH_FILE,
|
|
NULL, v9fs_synth_qtest_flush_write,
|
|
ctx);
|
|
assert(!ret);
|
|
|
|
/* Directory for READDIR test */
|
|
{
|
|
V9fsSynthNode *dir = NULL;
|
|
ret = qemu_v9fs_synth_mkdir(
|
|
NULL, 0700, QTEST_V9FS_SYNTH_READDIR_DIR, &dir
|
|
);
|
|
assert(!ret);
|
|
for (i = 0; i < QTEST_V9FS_SYNTH_READDIR_NFILES; ++i) {
|
|
char *name = g_strdup_printf(
|
|
QTEST_V9FS_SYNTH_READDIR_FILE, i
|
|
);
|
|
ret = qemu_v9fs_synth_add_file(
|
|
dir, 0, name, NULL, NULL, ctx
|
|
);
|
|
assert(!ret);
|
|
g_free(name);
|
|
}
|
|
}
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
FileOperations synth_ops = {
|
|
.init = synth_init,
|
|
.lstat = synth_lstat,
|
|
.readlink = synth_readlink,
|
|
.close = synth_close,
|
|
.closedir = synth_closedir,
|
|
.open = synth_open,
|
|
.opendir = synth_opendir,
|
|
.rewinddir = synth_rewinddir,
|
|
.telldir = synth_telldir,
|
|
.readdir = synth_readdir,
|
|
.seekdir = synth_seekdir,
|
|
.preadv = synth_preadv,
|
|
.pwritev = synth_pwritev,
|
|
.chmod = synth_chmod,
|
|
.mknod = synth_mknod,
|
|
.mkdir = synth_mkdir,
|
|
.fstat = synth_fstat,
|
|
.open2 = synth_open2,
|
|
.symlink = synth_symlink,
|
|
.link = synth_link,
|
|
.truncate = synth_truncate,
|
|
.rename = synth_rename,
|
|
.chown = synth_chown,
|
|
.utimensat = synth_utimensat,
|
|
.remove = synth_remove,
|
|
.fsync = synth_fsync,
|
|
.statfs = synth_statfs,
|
|
.lgetxattr = synth_lgetxattr,
|
|
.llistxattr = synth_llistxattr,
|
|
.lsetxattr = synth_lsetxattr,
|
|
.lremovexattr = synth_lremovexattr,
|
|
.name_to_path = synth_name_to_path,
|
|
.renameat = synth_renameat,
|
|
.unlinkat = synth_unlinkat,
|
|
};
|