2011-08-02 14:05:54 +08:00
|
|
|
/*
|
2015-11-19 02:03:14 +08:00
|
|
|
* 9p handle callback
|
2011-08-02 14:05:54 +08:00
|
|
|
*
|
|
|
|
* Copyright IBM, Corp. 2011
|
|
|
|
*
|
|
|
|
* Authors:
|
|
|
|
* 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.
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
|
2016-01-27 02:17:10 +08:00
|
|
|
#include "qemu/osdep.h"
|
2016-01-08 02:18:02 +08:00
|
|
|
#include "9p.h"
|
2015-11-19 02:31:52 +08:00
|
|
|
#include "9p-xattr.h"
|
2011-08-02 14:05:54 +08:00
|
|
|
#include <arpa/inet.h>
|
|
|
|
#include <pwd.h>
|
|
|
|
#include <grp.h>
|
|
|
|
#include <sys/socket.h>
|
|
|
|
#include <sys/un.h>
|
2012-12-18 01:20:00 +08:00
|
|
|
#include "qemu/xattr.h"
|
2016-01-22 22:12:17 +08:00
|
|
|
#include "qemu/error-report.h"
|
2011-10-12 21:41:25 +08:00
|
|
|
#include <linux/fs.h>
|
|
|
|
#ifdef CONFIG_LINUX_MAGIC_H
|
|
|
|
#include <linux/magic.h>
|
|
|
|
#endif
|
|
|
|
#include <sys/ioctl.h>
|
|
|
|
|
|
|
|
#ifndef XFS_SUPER_MAGIC
|
|
|
|
#define XFS_SUPER_MAGIC 0x58465342
|
|
|
|
#endif
|
|
|
|
#ifndef EXT2_SUPER_MAGIC
|
|
|
|
#define EXT2_SUPER_MAGIC 0xEF53
|
|
|
|
#endif
|
|
|
|
#ifndef REISERFS_SUPER_MAGIC
|
|
|
|
#define REISERFS_SUPER_MAGIC 0x52654973
|
|
|
|
#endif
|
|
|
|
#ifndef BTRFS_SUPER_MAGIC
|
|
|
|
#define BTRFS_SUPER_MAGIC 0x9123683E
|
|
|
|
#endif
|
2011-08-02 14:05:54 +08:00
|
|
|
|
|
|
|
struct handle_data {
|
|
|
|
int mountfd;
|
|
|
|
int handle_bytes;
|
|
|
|
};
|
|
|
|
|
2011-10-12 21:41:24 +08:00
|
|
|
static inline int name_to_handle(int dirfd, const char *name,
|
|
|
|
struct file_handle *fh, int *mnt_id, int flags)
|
|
|
|
{
|
|
|
|
return name_to_handle_at(dirfd, name, fh, mnt_id, flags);
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline int open_by_handle(int mountfd, const char *fh, int flags)
|
|
|
|
{
|
|
|
|
return open_by_handle_at(mountfd, (struct file_handle *)fh, flags);
|
|
|
|
}
|
2011-08-02 14:05:54 +08:00
|
|
|
|
|
|
|
static int handle_update_file_cred(int dirfd, const char *name, FsCred *credp)
|
|
|
|
{
|
|
|
|
int fd, ret;
|
2011-11-29 16:52:38 +08:00
|
|
|
fd = openat(dirfd, name, O_NONBLOCK | O_NOFOLLOW);
|
2011-08-02 14:05:54 +08:00
|
|
|
if (fd < 0) {
|
|
|
|
return fd;
|
|
|
|
}
|
2012-01-19 14:51:12 +08:00
|
|
|
ret = fchownat(fd, "", credp->fc_uid, credp->fc_gid, AT_EMPTY_PATH);
|
2011-08-02 14:05:54 +08:00
|
|
|
if (ret < 0) {
|
|
|
|
goto err_out;
|
|
|
|
}
|
2012-01-19 14:51:12 +08:00
|
|
|
ret = fchmod(fd, credp->fc_mode & 07777);
|
2011-08-02 14:05:54 +08:00
|
|
|
err_out:
|
|
|
|
close(fd);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
static int handle_lstat(FsContext *fs_ctx, V9fsPath *fs_path,
|
|
|
|
struct stat *stbuf)
|
|
|
|
{
|
|
|
|
int fd, ret;
|
|
|
|
struct handle_data *data = (struct handle_data *)fs_ctx->private;
|
|
|
|
|
|
|
|
fd = open_by_handle(data->mountfd, fs_path->data, O_PATH);
|
|
|
|
if (fd < 0) {
|
|
|
|
return fd;
|
|
|
|
}
|
|
|
|
ret = fstatat(fd, "", stbuf, AT_EMPTY_PATH);
|
|
|
|
close(fd);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
static ssize_t handle_readlink(FsContext *fs_ctx, V9fsPath *fs_path,
|
|
|
|
char *buf, size_t bufsz)
|
|
|
|
{
|
|
|
|
int fd, ret;
|
|
|
|
struct handle_data *data = (struct handle_data *)fs_ctx->private;
|
|
|
|
|
|
|
|
fd = open_by_handle(data->mountfd, fs_path->data, O_PATH);
|
|
|
|
if (fd < 0) {
|
|
|
|
return fd;
|
|
|
|
}
|
|
|
|
ret = readlinkat(fd, "", buf, bufsz);
|
|
|
|
close(fd);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2011-10-25 14:40:40 +08:00
|
|
|
static int handle_close(FsContext *ctx, V9fsFidOpenState *fs)
|
2011-08-02 14:05:54 +08:00
|
|
|
{
|
2011-10-25 14:40:40 +08:00
|
|
|
return close(fs->fd);
|
2011-08-02 14:05:54 +08:00
|
|
|
}
|
|
|
|
|
2011-10-25 14:40:40 +08:00
|
|
|
static int handle_closedir(FsContext *ctx, V9fsFidOpenState *fs)
|
2011-08-02 14:05:54 +08:00
|
|
|
{
|
2011-10-25 14:40:40 +08:00
|
|
|
return closedir(fs->dir);
|
2011-08-02 14:05:54 +08:00
|
|
|
}
|
|
|
|
|
2011-10-25 14:40:40 +08:00
|
|
|
static int handle_open(FsContext *ctx, V9fsPath *fs_path,
|
|
|
|
int flags, V9fsFidOpenState *fs)
|
2011-08-02 14:05:54 +08:00
|
|
|
{
|
|
|
|
struct handle_data *data = (struct handle_data *)ctx->private;
|
|
|
|
|
2011-10-25 14:40:40 +08:00
|
|
|
fs->fd = open_by_handle(data->mountfd, fs_path->data, flags);
|
|
|
|
return fs->fd;
|
2011-08-02 14:05:54 +08:00
|
|
|
}
|
|
|
|
|
2011-10-25 14:40:40 +08:00
|
|
|
static int handle_opendir(FsContext *ctx,
|
|
|
|
V9fsPath *fs_path, V9fsFidOpenState *fs)
|
2011-08-02 14:05:54 +08:00
|
|
|
{
|
2011-10-25 14:40:40 +08:00
|
|
|
int ret;
|
|
|
|
ret = handle_open(ctx, fs_path, O_DIRECTORY, fs);
|
|
|
|
if (ret < 0) {
|
|
|
|
return -1;
|
2011-08-02 14:05:54 +08:00
|
|
|
}
|
2011-10-25 14:40:40 +08:00
|
|
|
fs->dir = fdopendir(ret);
|
|
|
|
if (!fs->dir) {
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
return 0;
|
2011-08-02 14:05:54 +08:00
|
|
|
}
|
|
|
|
|
2011-10-25 14:40:40 +08:00
|
|
|
static void handle_rewinddir(FsContext *ctx, V9fsFidOpenState *fs)
|
2011-08-02 14:05:54 +08:00
|
|
|
{
|
2015-03-09 02:17:54 +08:00
|
|
|
rewinddir(fs->dir);
|
2011-08-02 14:05:54 +08:00
|
|
|
}
|
|
|
|
|
2011-10-25 14:40:40 +08:00
|
|
|
static off_t handle_telldir(FsContext *ctx, V9fsFidOpenState *fs)
|
2011-08-02 14:05:54 +08:00
|
|
|
{
|
2011-10-25 14:40:40 +08:00
|
|
|
return telldir(fs->dir);
|
2011-08-02 14:05:54 +08:00
|
|
|
}
|
|
|
|
|
2011-10-25 14:40:40 +08:00
|
|
|
static int handle_readdir_r(FsContext *ctx, V9fsFidOpenState *fs,
|
|
|
|
struct dirent *entry,
|
2011-08-02 14:05:54 +08:00
|
|
|
struct dirent **result)
|
|
|
|
{
|
2011-10-25 14:40:40 +08:00
|
|
|
return readdir_r(fs->dir, entry, result);
|
2011-08-02 14:05:54 +08:00
|
|
|
}
|
|
|
|
|
2011-10-25 14:40:40 +08:00
|
|
|
static void handle_seekdir(FsContext *ctx, V9fsFidOpenState *fs, off_t off)
|
2011-08-02 14:05:54 +08:00
|
|
|
{
|
2015-03-09 02:17:54 +08:00
|
|
|
seekdir(fs->dir, off);
|
2011-08-02 14:05:54 +08:00
|
|
|
}
|
|
|
|
|
2011-10-25 14:40:40 +08:00
|
|
|
static ssize_t handle_preadv(FsContext *ctx, V9fsFidOpenState *fs,
|
|
|
|
const struct iovec *iov,
|
2011-08-02 14:05:54 +08:00
|
|
|
int iovcnt, off_t offset)
|
|
|
|
{
|
|
|
|
#ifdef CONFIG_PREADV
|
2011-10-25 14:40:40 +08:00
|
|
|
return preadv(fs->fd, iov, iovcnt, offset);
|
2011-08-02 14:05:54 +08:00
|
|
|
#else
|
2011-10-25 14:40:40 +08:00
|
|
|
int err = lseek(fs->fd, offset, SEEK_SET);
|
2011-08-02 14:05:54 +08:00
|
|
|
if (err == -1) {
|
|
|
|
return err;
|
|
|
|
} else {
|
2011-10-25 14:40:40 +08:00
|
|
|
return readv(fs->fd, iov, iovcnt);
|
2011-08-02 14:05:54 +08:00
|
|
|
}
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
2011-10-25 14:40:40 +08:00
|
|
|
static ssize_t handle_pwritev(FsContext *ctx, V9fsFidOpenState *fs,
|
|
|
|
const struct iovec *iov,
|
2011-08-02 14:05:54 +08:00
|
|
|
int iovcnt, off_t offset)
|
|
|
|
{
|
2011-10-12 21:41:23 +08:00
|
|
|
ssize_t ret;
|
2011-08-02 14:05:54 +08:00
|
|
|
#ifdef CONFIG_PREADV
|
2011-10-25 14:40:40 +08:00
|
|
|
ret = pwritev(fs->fd, iov, iovcnt, offset);
|
2011-08-02 14:05:54 +08:00
|
|
|
#else
|
2011-10-25 14:40:40 +08:00
|
|
|
int err = lseek(fs->fd, offset, SEEK_SET);
|
2011-08-02 14:05:54 +08:00
|
|
|
if (err == -1) {
|
|
|
|
return err;
|
|
|
|
} else {
|
2011-10-25 14:40:40 +08:00
|
|
|
ret = writev(fs->fd, iov, iovcnt);
|
2011-08-02 14:05:54 +08:00
|
|
|
}
|
|
|
|
#endif
|
2011-10-12 21:41:23 +08:00
|
|
|
#ifdef CONFIG_SYNC_FILE_RANGE
|
|
|
|
if (ret > 0 && ctx->export_flags & V9FS_IMMEDIATE_WRITEOUT) {
|
|
|
|
/*
|
|
|
|
* Initiate a writeback. This is not a data integrity sync.
|
|
|
|
* We want to ensure that we don't leave dirty pages in the cache
|
|
|
|
* after write when writeout=immediate is sepcified.
|
|
|
|
*/
|
2011-10-25 14:40:40 +08:00
|
|
|
sync_file_range(fs->fd, offset, ret,
|
2011-10-12 21:41:23 +08:00
|
|
|
SYNC_FILE_RANGE_WAIT_BEFORE | SYNC_FILE_RANGE_WRITE);
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
return ret;
|
2011-08-02 14:05:54 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
static int handle_chmod(FsContext *fs_ctx, V9fsPath *fs_path, FsCred *credp)
|
|
|
|
{
|
|
|
|
int fd, ret;
|
|
|
|
struct handle_data *data = (struct handle_data *)fs_ctx->private;
|
|
|
|
|
|
|
|
fd = open_by_handle(data->mountfd, fs_path->data, O_NONBLOCK);
|
|
|
|
if (fd < 0) {
|
|
|
|
return fd;
|
|
|
|
}
|
|
|
|
ret = fchmod(fd, credp->fc_mode);
|
|
|
|
close(fd);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int handle_mknod(FsContext *fs_ctx, V9fsPath *dir_path,
|
|
|
|
const char *name, FsCred *credp)
|
|
|
|
{
|
|
|
|
int dirfd, ret;
|
|
|
|
struct handle_data *data = (struct handle_data *)fs_ctx->private;
|
|
|
|
|
|
|
|
dirfd = open_by_handle(data->mountfd, dir_path->data, O_PATH);
|
|
|
|
if (dirfd < 0) {
|
|
|
|
return dirfd;
|
|
|
|
}
|
|
|
|
ret = mknodat(dirfd, name, credp->fc_mode, credp->fc_rdev);
|
|
|
|
if (!ret) {
|
|
|
|
ret = handle_update_file_cred(dirfd, name, credp);
|
|
|
|
}
|
|
|
|
close(dirfd);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int handle_mkdir(FsContext *fs_ctx, V9fsPath *dir_path,
|
|
|
|
const char *name, FsCred *credp)
|
|
|
|
{
|
|
|
|
int dirfd, ret;
|
|
|
|
struct handle_data *data = (struct handle_data *)fs_ctx->private;
|
|
|
|
|
|
|
|
dirfd = open_by_handle(data->mountfd, dir_path->data, O_PATH);
|
|
|
|
if (dirfd < 0) {
|
|
|
|
return dirfd;
|
|
|
|
}
|
|
|
|
ret = mkdirat(dirfd, name, credp->fc_mode);
|
|
|
|
if (!ret) {
|
|
|
|
ret = handle_update_file_cred(dirfd, name, credp);
|
|
|
|
}
|
|
|
|
close(dirfd);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2011-12-05 01:05:28 +08:00
|
|
|
static int handle_fstat(FsContext *fs_ctx, int fid_type,
|
|
|
|
V9fsFidOpenState *fs, struct stat *stbuf)
|
2011-08-02 14:05:54 +08:00
|
|
|
{
|
2011-12-05 01:05:28 +08:00
|
|
|
int fd;
|
|
|
|
|
|
|
|
if (fid_type == P9_FID_DIR) {
|
|
|
|
fd = dirfd(fs->dir);
|
|
|
|
} else {
|
|
|
|
fd = fs->fd;
|
|
|
|
}
|
|
|
|
return fstat(fd, stbuf);
|
2011-08-02 14:05:54 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
static int handle_open2(FsContext *fs_ctx, V9fsPath *dir_path, const char *name,
|
2011-10-25 14:40:40 +08:00
|
|
|
int flags, FsCred *credp, V9fsFidOpenState *fs)
|
2011-08-02 14:05:54 +08:00
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
int dirfd, fd;
|
|
|
|
struct handle_data *data = (struct handle_data *)fs_ctx->private;
|
|
|
|
|
|
|
|
dirfd = open_by_handle(data->mountfd, dir_path->data, O_PATH);
|
|
|
|
if (dirfd < 0) {
|
|
|
|
return dirfd;
|
|
|
|
}
|
|
|
|
fd = openat(dirfd, name, flags | O_NOFOLLOW, credp->fc_mode);
|
|
|
|
if (fd >= 0) {
|
|
|
|
ret = handle_update_file_cred(dirfd, name, credp);
|
|
|
|
if (ret < 0) {
|
|
|
|
close(fd);
|
|
|
|
fd = ret;
|
2011-10-25 14:40:40 +08:00
|
|
|
} else {
|
|
|
|
fs->fd = fd;
|
2011-08-02 14:05:54 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
close(dirfd);
|
|
|
|
return fd;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
static int handle_symlink(FsContext *fs_ctx, const char *oldpath,
|
|
|
|
V9fsPath *dir_path, const char *name, FsCred *credp)
|
|
|
|
{
|
|
|
|
int fd, dirfd, ret;
|
|
|
|
struct handle_data *data = (struct handle_data *)fs_ctx->private;
|
|
|
|
|
|
|
|
dirfd = open_by_handle(data->mountfd, dir_path->data, O_PATH);
|
|
|
|
if (dirfd < 0) {
|
|
|
|
return dirfd;
|
|
|
|
}
|
|
|
|
ret = symlinkat(oldpath, dirfd, name);
|
|
|
|
if (!ret) {
|
|
|
|
fd = openat(dirfd, name, O_PATH | O_NOFOLLOW);
|
|
|
|
if (fd < 0) {
|
|
|
|
ret = fd;
|
|
|
|
goto err_out;
|
|
|
|
}
|
|
|
|
ret = fchownat(fd, "", credp->fc_uid, credp->fc_gid, AT_EMPTY_PATH);
|
|
|
|
close(fd);
|
|
|
|
}
|
|
|
|
err_out:
|
|
|
|
close(dirfd);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int handle_link(FsContext *ctx, V9fsPath *oldpath,
|
|
|
|
V9fsPath *dirpath, const char *name)
|
|
|
|
{
|
|
|
|
int oldfd, newdirfd, ret;
|
|
|
|
struct handle_data *data = (struct handle_data *)ctx->private;
|
|
|
|
|
|
|
|
oldfd = open_by_handle(data->mountfd, oldpath->data, O_PATH);
|
|
|
|
if (oldfd < 0) {
|
|
|
|
return oldfd;
|
|
|
|
}
|
|
|
|
newdirfd = open_by_handle(data->mountfd, dirpath->data, O_PATH);
|
|
|
|
if (newdirfd < 0) {
|
|
|
|
close(oldfd);
|
|
|
|
return newdirfd;
|
|
|
|
}
|
|
|
|
ret = linkat(oldfd, "", newdirfd, name, AT_EMPTY_PATH);
|
|
|
|
close(newdirfd);
|
|
|
|
close(oldfd);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int handle_truncate(FsContext *ctx, V9fsPath *fs_path, off_t size)
|
|
|
|
{
|
|
|
|
int fd, ret;
|
|
|
|
struct handle_data *data = (struct handle_data *)ctx->private;
|
|
|
|
|
|
|
|
fd = open_by_handle(data->mountfd, fs_path->data, O_NONBLOCK | O_WRONLY);
|
|
|
|
if (fd < 0) {
|
|
|
|
return fd;
|
|
|
|
}
|
|
|
|
ret = ftruncate(fd, size);
|
|
|
|
close(fd);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int handle_rename(FsContext *ctx, const char *oldpath,
|
|
|
|
const char *newpath)
|
|
|
|
{
|
|
|
|
errno = EOPNOTSUPP;
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int handle_chown(FsContext *fs_ctx, V9fsPath *fs_path, FsCred *credp)
|
|
|
|
{
|
|
|
|
int fd, ret;
|
|
|
|
struct handle_data *data = (struct handle_data *)fs_ctx->private;
|
|
|
|
|
|
|
|
fd = open_by_handle(data->mountfd, fs_path->data, O_PATH);
|
|
|
|
if (fd < 0) {
|
|
|
|
return fd;
|
|
|
|
}
|
|
|
|
ret = fchownat(fd, "", credp->fc_uid, credp->fc_gid, AT_EMPTY_PATH);
|
|
|
|
close(fd);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int handle_utimensat(FsContext *ctx, V9fsPath *fs_path,
|
|
|
|
const struct timespec *buf)
|
|
|
|
{
|
2011-10-12 21:41:24 +08:00
|
|
|
int ret;
|
|
|
|
#ifdef CONFIG_UTIMENSAT
|
|
|
|
int fd;
|
2011-08-02 14:05:54 +08:00
|
|
|
struct handle_data *data = (struct handle_data *)ctx->private;
|
|
|
|
|
|
|
|
fd = open_by_handle(data->mountfd, fs_path->data, O_NONBLOCK);
|
|
|
|
if (fd < 0) {
|
|
|
|
return fd;
|
|
|
|
}
|
|
|
|
ret = futimens(fd, buf);
|
|
|
|
close(fd);
|
2011-10-12 21:41:24 +08:00
|
|
|
#else
|
|
|
|
ret = -1;
|
|
|
|
errno = ENOSYS;
|
|
|
|
#endif
|
2011-08-02 14:05:54 +08:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int handle_remove(FsContext *ctx, const char *path)
|
|
|
|
{
|
|
|
|
errno = EOPNOTSUPP;
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
2011-12-05 01:05:28 +08:00
|
|
|
static int handle_fsync(FsContext *ctx, int fid_type,
|
|
|
|
V9fsFidOpenState *fs, int datasync)
|
2011-08-02 14:05:54 +08:00
|
|
|
{
|
2011-12-05 01:05:28 +08:00
|
|
|
int fd;
|
|
|
|
|
|
|
|
if (fid_type == P9_FID_DIR) {
|
|
|
|
fd = dirfd(fs->dir);
|
|
|
|
} else {
|
|
|
|
fd = fs->fd;
|
|
|
|
}
|
|
|
|
|
2011-08-02 14:05:54 +08:00
|
|
|
if (datasync) {
|
2011-12-05 01:05:28 +08:00
|
|
|
return qemu_fdatasync(fd);
|
2011-08-02 14:05:54 +08:00
|
|
|
} else {
|
2011-12-05 01:05:28 +08:00
|
|
|
return fsync(fd);
|
2011-08-02 14:05:54 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static int handle_statfs(FsContext *ctx, V9fsPath *fs_path,
|
|
|
|
struct statfs *stbuf)
|
|
|
|
{
|
|
|
|
int fd, ret;
|
|
|
|
struct handle_data *data = (struct handle_data *)ctx->private;
|
|
|
|
|
|
|
|
fd = open_by_handle(data->mountfd, fs_path->data, O_NONBLOCK);
|
|
|
|
if (fd < 0) {
|
|
|
|
return fd;
|
|
|
|
}
|
|
|
|
ret = fstatfs(fd, stbuf);
|
|
|
|
close(fd);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
static ssize_t handle_lgetxattr(FsContext *ctx, V9fsPath *fs_path,
|
|
|
|
const char *name, void *value, size_t size)
|
|
|
|
{
|
|
|
|
int fd, ret;
|
|
|
|
struct handle_data *data = (struct handle_data *)ctx->private;
|
|
|
|
|
|
|
|
fd = open_by_handle(data->mountfd, fs_path->data, O_NONBLOCK);
|
|
|
|
if (fd < 0) {
|
|
|
|
return fd;
|
|
|
|
}
|
|
|
|
ret = fgetxattr(fd, name, value, size);
|
|
|
|
close(fd);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
static ssize_t handle_llistxattr(FsContext *ctx, V9fsPath *fs_path,
|
|
|
|
void *value, size_t size)
|
|
|
|
{
|
|
|
|
int fd, ret;
|
|
|
|
struct handle_data *data = (struct handle_data *)ctx->private;
|
|
|
|
|
|
|
|
fd = open_by_handle(data->mountfd, fs_path->data, O_NONBLOCK);
|
|
|
|
if (fd < 0) {
|
|
|
|
return fd;
|
|
|
|
}
|
|
|
|
ret = flistxattr(fd, value, size);
|
|
|
|
close(fd);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int handle_lsetxattr(FsContext *ctx, V9fsPath *fs_path, const char *name,
|
|
|
|
void *value, size_t size, int flags)
|
|
|
|
{
|
|
|
|
int fd, ret;
|
|
|
|
struct handle_data *data = (struct handle_data *)ctx->private;
|
|
|
|
|
|
|
|
fd = open_by_handle(data->mountfd, fs_path->data, O_NONBLOCK);
|
|
|
|
if (fd < 0) {
|
|
|
|
return fd;
|
|
|
|
}
|
|
|
|
ret = fsetxattr(fd, name, value, size, flags);
|
|
|
|
close(fd);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int handle_lremovexattr(FsContext *ctx, V9fsPath *fs_path,
|
|
|
|
const char *name)
|
|
|
|
{
|
|
|
|
int fd, ret;
|
|
|
|
struct handle_data *data = (struct handle_data *)ctx->private;
|
|
|
|
|
|
|
|
fd = open_by_handle(data->mountfd, fs_path->data, O_NONBLOCK);
|
|
|
|
if (fd < 0) {
|
|
|
|
return fd;
|
|
|
|
}
|
|
|
|
ret = fremovexattr(fd, name);
|
|
|
|
close(fd);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int handle_name_to_path(FsContext *ctx, V9fsPath *dir_path,
|
|
|
|
const char *name, V9fsPath *target)
|
|
|
|
{
|
hw/9pfs: use g_strdup_printf() instead of PATH_MAX limitation
When path is truncated by PATH_MAX limitation, it causes QEMU to access
incorrect file. So use original full path instead of PATH_MAX within
9pfs (need check/process ENOMEM for related memory allocation).
The related test:
- Environments (for qemu-devel):
- Host is under fedora17 desktop with ext4fs:
qemu-system-x86_64 -hda test.img -m 1024 \
-net nic,vlan=4,model=virtio,macaddr=00:16:35:AF:94:04 \
-net tap,vlan=4,ifname=tap4,script=no,downscript=no \
-device virtio-9p-pci,id=fs0,fsdev=fsdev0,mount_tag=hostshare \
-fsdev local,security_model=passthrough,id=fsdev0,\
path=/upstream/vm/data/share/1234567890abcdefghijklmnopqrstuvwxyz\
ABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890acdefghijklmnopqrstuvwxyz\
ABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890/111111111111111111111111111\
1111111111111111111111111111111111111111111111111111222222222222\
2222222222222222222222222222222222222222222222222222222222222222\
2222222222222222222222222222222222233333333333333333333333333333\
3333333333333333333333333333333333
- Guest is ubuntu12 server with 9pfs.
mount -t 9p -o trans=virtio,version=9p2000.L hostshare /share
- Limitations:
full path limitation is PATH_MAX (4096B include nul) under Linux.
file/dir node name maximized length is 256 (include nul) under ext4.
- Special test:
Under host, modify the file: "/upstream/vm/data/share/1234567890abcdefg\
hijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890acdefghijklmno\
pqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890/111111111111111111111\
111111111111111111111111111111111111111111111111111111111122222222222\
222222222222222222222222222222222222222222222222222222222222222222222\
222222222222222222222222222222233333333333333333333333333333333333333\
3333333333333333333333333/4444444444444444444444444444444444444444444\
444444444444444444444444444444444444444444444444444444444444444444444\
444444444444444444444444444444444444444444444444444444444444444444444\
444444444444444444444444444444444444444/55555555555555555555555555555\
555555555555555555555555555555555555555555555555555555555555555555555\
555555555555555555555555555555555555555555555555555555555555555555555\
555555555555555555555555555555555555555555555555555555555555555555555\
55555555/666666666666666666666666666666666666666666666666666666666666\
666666666666666666666666666666666666666666666666666666666666666666666\
666666666666666666666666666666666666666666666666666666666666666666666\
666666666666666666666/77777777777777777777777777777777777777777777777\
777777777777777777777777777777777777777777777777777777777777777777777\
777777777777777777777777777777777777777777777777777777777777777777777\
77777777777777777777777777777777777777777777777777777777777/888888888\
888888888888888888888888888888888888888888888888888888888888888888888\
888888888888888888888888888888888888888888888888888888888888888888888\
888888888888888888888888888888888888888888888888888888888888888888888\
888888888/99999999999999999999999999999999999999999999999999999999999\
999999999999999999999999999999999999999999999999999999999999999999999\
999999999999999999999999999999999999999999999999999999999999999999999\
99999999999999999999999999999999999999999/000000000000000000000000000\
000000000000000000000000000000000000000000000000000000000000000000000\
000000000000000000000000000000000000000000000000000000000000000000000\
000000000000000000000000000000000000000000000000/aaaaaaaaaaaaaaaaaaaa\
aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\
aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\
aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa/bbbbbbbbbbbbbbbbbbbbbbb\
bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\
bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\
bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb/ccccccccc\
ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc\
ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc\
ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc\
cccccccccc/dddddddddddddddddddddddddddddddddddddddddddddddddddddddddd\
ddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddd\
ddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddd\
dddddddddddddddddddddd/eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee\
eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee\
eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee\
eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee/fffffffffffffff\
fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff\
fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff\
ffffffffffffffffffffffffffffffffffffffffffffffffffffffffff/gggggggggg\
ggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggg\
ggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggg\
ggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggg\
ggggggggggggggggggggggg/iiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiii\
iiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiii\
iiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiii\
iiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiii/jjjjjjjjjjjjj\
jjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjj\
jjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjj/ppppppppppppppppppppp\
ppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppp\
ppppppppppppppppppppppppppppppppppppppp/test1234567890file.log"
(need enter dir firstly, then modify file, or can not open it).
Under guest, still allow modify "test1234567890file.log" (will generate
"test123456" file with contents).
After apply this patch, can not open "test1234567890file.log" under guest
(permission denied).
- Common test:
All are still OK after apply this path.
"mkdir -p", "create/open file/dir", "modify file/dir", "rm file/dir".
change various mount point paths under host and/or guest.
Signed-off-by: Chen Gang <gang.chen.5i5j@gmail.com>
Signed-off-by: Aneesh Kumar K.V <aneesh.kumar@linux.vnet.ibm.com>
2014-03-02 01:36:19 +08:00
|
|
|
char *buffer;
|
2011-08-02 14:05:54 +08:00
|
|
|
struct file_handle *fh;
|
|
|
|
int dirfd, ret, mnt_id;
|
|
|
|
struct handle_data *data = (struct handle_data *)ctx->private;
|
|
|
|
|
|
|
|
/* "." and ".." are not allowed */
|
|
|
|
if (!strcmp(name, ".") || !strcmp(name, "..")) {
|
|
|
|
errno = EINVAL;
|
|
|
|
return -1;
|
|
|
|
|
|
|
|
}
|
|
|
|
if (dir_path) {
|
|
|
|
dirfd = open_by_handle(data->mountfd, dir_path->data, O_PATH);
|
|
|
|
} else {
|
|
|
|
/* relative to export root */
|
hw/9pfs: use g_strdup_printf() instead of PATH_MAX limitation
When path is truncated by PATH_MAX limitation, it causes QEMU to access
incorrect file. So use original full path instead of PATH_MAX within
9pfs (need check/process ENOMEM for related memory allocation).
The related test:
- Environments (for qemu-devel):
- Host is under fedora17 desktop with ext4fs:
qemu-system-x86_64 -hda test.img -m 1024 \
-net nic,vlan=4,model=virtio,macaddr=00:16:35:AF:94:04 \
-net tap,vlan=4,ifname=tap4,script=no,downscript=no \
-device virtio-9p-pci,id=fs0,fsdev=fsdev0,mount_tag=hostshare \
-fsdev local,security_model=passthrough,id=fsdev0,\
path=/upstream/vm/data/share/1234567890abcdefghijklmnopqrstuvwxyz\
ABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890acdefghijklmnopqrstuvwxyz\
ABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890/111111111111111111111111111\
1111111111111111111111111111111111111111111111111111222222222222\
2222222222222222222222222222222222222222222222222222222222222222\
2222222222222222222222222222222222233333333333333333333333333333\
3333333333333333333333333333333333
- Guest is ubuntu12 server with 9pfs.
mount -t 9p -o trans=virtio,version=9p2000.L hostshare /share
- Limitations:
full path limitation is PATH_MAX (4096B include nul) under Linux.
file/dir node name maximized length is 256 (include nul) under ext4.
- Special test:
Under host, modify the file: "/upstream/vm/data/share/1234567890abcdefg\
hijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890acdefghijklmno\
pqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890/111111111111111111111\
111111111111111111111111111111111111111111111111111111111122222222222\
222222222222222222222222222222222222222222222222222222222222222222222\
222222222222222222222222222222233333333333333333333333333333333333333\
3333333333333333333333333/4444444444444444444444444444444444444444444\
444444444444444444444444444444444444444444444444444444444444444444444\
444444444444444444444444444444444444444444444444444444444444444444444\
444444444444444444444444444444444444444/55555555555555555555555555555\
555555555555555555555555555555555555555555555555555555555555555555555\
555555555555555555555555555555555555555555555555555555555555555555555\
555555555555555555555555555555555555555555555555555555555555555555555\
55555555/666666666666666666666666666666666666666666666666666666666666\
666666666666666666666666666666666666666666666666666666666666666666666\
666666666666666666666666666666666666666666666666666666666666666666666\
666666666666666666666/77777777777777777777777777777777777777777777777\
777777777777777777777777777777777777777777777777777777777777777777777\
777777777777777777777777777777777777777777777777777777777777777777777\
77777777777777777777777777777777777777777777777777777777777/888888888\
888888888888888888888888888888888888888888888888888888888888888888888\
888888888888888888888888888888888888888888888888888888888888888888888\
888888888888888888888888888888888888888888888888888888888888888888888\
888888888/99999999999999999999999999999999999999999999999999999999999\
999999999999999999999999999999999999999999999999999999999999999999999\
999999999999999999999999999999999999999999999999999999999999999999999\
99999999999999999999999999999999999999999/000000000000000000000000000\
000000000000000000000000000000000000000000000000000000000000000000000\
000000000000000000000000000000000000000000000000000000000000000000000\
000000000000000000000000000000000000000000000000/aaaaaaaaaaaaaaaaaaaa\
aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\
aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\
aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa/bbbbbbbbbbbbbbbbbbbbbbb\
bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\
bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\
bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb/ccccccccc\
ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc\
ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc\
ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc\
cccccccccc/dddddddddddddddddddddddddddddddddddddddddddddddddddddddddd\
ddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddd\
ddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddd\
dddddddddddddddddddddd/eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee\
eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee\
eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee\
eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee/fffffffffffffff\
fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff\
fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff\
ffffffffffffffffffffffffffffffffffffffffffffffffffffffffff/gggggggggg\
ggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggg\
ggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggg\
ggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggg\
ggggggggggggggggggggggg/iiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiii\
iiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiii\
iiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiii\
iiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiii/jjjjjjjjjjjjj\
jjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjj\
jjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjj/ppppppppppppppppppppp\
ppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppp\
ppppppppppppppppppppppppppppppppppppppp/test1234567890file.log"
(need enter dir firstly, then modify file, or can not open it).
Under guest, still allow modify "test1234567890file.log" (will generate
"test123456" file with contents).
After apply this patch, can not open "test1234567890file.log" under guest
(permission denied).
- Common test:
All are still OK after apply this path.
"mkdir -p", "create/open file/dir", "modify file/dir", "rm file/dir".
change various mount point paths under host and/or guest.
Signed-off-by: Chen Gang <gang.chen.5i5j@gmail.com>
Signed-off-by: Aneesh Kumar K.V <aneesh.kumar@linux.vnet.ibm.com>
2014-03-02 01:36:19 +08:00
|
|
|
buffer = rpath(ctx, ".");
|
|
|
|
dirfd = open(buffer, O_DIRECTORY);
|
|
|
|
g_free(buffer);
|
2011-08-02 14:05:54 +08:00
|
|
|
}
|
|
|
|
if (dirfd < 0) {
|
|
|
|
return dirfd;
|
|
|
|
}
|
|
|
|
fh = g_malloc(sizeof(struct file_handle) + data->handle_bytes);
|
|
|
|
fh->handle_bytes = data->handle_bytes;
|
2011-11-29 16:52:39 +08:00
|
|
|
/* add a "./" at the beginning of the path */
|
hw/9pfs: use g_strdup_printf() instead of PATH_MAX limitation
When path is truncated by PATH_MAX limitation, it causes QEMU to access
incorrect file. So use original full path instead of PATH_MAX within
9pfs (need check/process ENOMEM for related memory allocation).
The related test:
- Environments (for qemu-devel):
- Host is under fedora17 desktop with ext4fs:
qemu-system-x86_64 -hda test.img -m 1024 \
-net nic,vlan=4,model=virtio,macaddr=00:16:35:AF:94:04 \
-net tap,vlan=4,ifname=tap4,script=no,downscript=no \
-device virtio-9p-pci,id=fs0,fsdev=fsdev0,mount_tag=hostshare \
-fsdev local,security_model=passthrough,id=fsdev0,\
path=/upstream/vm/data/share/1234567890abcdefghijklmnopqrstuvwxyz\
ABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890acdefghijklmnopqrstuvwxyz\
ABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890/111111111111111111111111111\
1111111111111111111111111111111111111111111111111111222222222222\
2222222222222222222222222222222222222222222222222222222222222222\
2222222222222222222222222222222222233333333333333333333333333333\
3333333333333333333333333333333333
- Guest is ubuntu12 server with 9pfs.
mount -t 9p -o trans=virtio,version=9p2000.L hostshare /share
- Limitations:
full path limitation is PATH_MAX (4096B include nul) under Linux.
file/dir node name maximized length is 256 (include nul) under ext4.
- Special test:
Under host, modify the file: "/upstream/vm/data/share/1234567890abcdefg\
hijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890acdefghijklmno\
pqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890/111111111111111111111\
111111111111111111111111111111111111111111111111111111111122222222222\
222222222222222222222222222222222222222222222222222222222222222222222\
222222222222222222222222222222233333333333333333333333333333333333333\
3333333333333333333333333/4444444444444444444444444444444444444444444\
444444444444444444444444444444444444444444444444444444444444444444444\
444444444444444444444444444444444444444444444444444444444444444444444\
444444444444444444444444444444444444444/55555555555555555555555555555\
555555555555555555555555555555555555555555555555555555555555555555555\
555555555555555555555555555555555555555555555555555555555555555555555\
555555555555555555555555555555555555555555555555555555555555555555555\
55555555/666666666666666666666666666666666666666666666666666666666666\
666666666666666666666666666666666666666666666666666666666666666666666\
666666666666666666666666666666666666666666666666666666666666666666666\
666666666666666666666/77777777777777777777777777777777777777777777777\
777777777777777777777777777777777777777777777777777777777777777777777\
777777777777777777777777777777777777777777777777777777777777777777777\
77777777777777777777777777777777777777777777777777777777777/888888888\
888888888888888888888888888888888888888888888888888888888888888888888\
888888888888888888888888888888888888888888888888888888888888888888888\
888888888888888888888888888888888888888888888888888888888888888888888\
888888888/99999999999999999999999999999999999999999999999999999999999\
999999999999999999999999999999999999999999999999999999999999999999999\
999999999999999999999999999999999999999999999999999999999999999999999\
99999999999999999999999999999999999999999/000000000000000000000000000\
000000000000000000000000000000000000000000000000000000000000000000000\
000000000000000000000000000000000000000000000000000000000000000000000\
000000000000000000000000000000000000000000000000/aaaaaaaaaaaaaaaaaaaa\
aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\
aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\
aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa/bbbbbbbbbbbbbbbbbbbbbbb\
bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\
bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\
bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb/ccccccccc\
ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc\
ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc\
ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc\
cccccccccc/dddddddddddddddddddddddddddddddddddddddddddddddddddddddddd\
ddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddd\
ddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddd\
dddddddddddddddddddddd/eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee\
eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee\
eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee\
eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee/fffffffffffffff\
fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff\
fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff\
ffffffffffffffffffffffffffffffffffffffffffffffffffffffffff/gggggggggg\
ggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggg\
ggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggg\
ggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggg\
ggggggggggggggggggggggg/iiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiii\
iiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiii\
iiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiii\
iiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiii/jjjjjjjjjjjjj\
jjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjj\
jjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjj/ppppppppppppppppppppp\
ppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppp\
ppppppppppppppppppppppppppppppppppppppp/test1234567890file.log"
(need enter dir firstly, then modify file, or can not open it).
Under guest, still allow modify "test1234567890file.log" (will generate
"test123456" file with contents).
After apply this patch, can not open "test1234567890file.log" under guest
(permission denied).
- Common test:
All are still OK after apply this path.
"mkdir -p", "create/open file/dir", "modify file/dir", "rm file/dir".
change various mount point paths under host and/or guest.
Signed-off-by: Chen Gang <gang.chen.5i5j@gmail.com>
Signed-off-by: Aneesh Kumar K.V <aneesh.kumar@linux.vnet.ibm.com>
2014-03-02 01:36:19 +08:00
|
|
|
buffer = g_strdup_printf("./%s", name);
|
2011-08-02 14:05:54 +08:00
|
|
|
/* flag = 0 imply don't follow symlink */
|
|
|
|
ret = name_to_handle(dirfd, buffer, fh, &mnt_id, 0);
|
|
|
|
if (!ret) {
|
|
|
|
target->data = (char *)fh;
|
|
|
|
target->size = sizeof(struct file_handle) + data->handle_bytes;
|
|
|
|
} else {
|
|
|
|
g_free(fh);
|
|
|
|
}
|
|
|
|
close(dirfd);
|
hw/9pfs: use g_strdup_printf() instead of PATH_MAX limitation
When path is truncated by PATH_MAX limitation, it causes QEMU to access
incorrect file. So use original full path instead of PATH_MAX within
9pfs (need check/process ENOMEM for related memory allocation).
The related test:
- Environments (for qemu-devel):
- Host is under fedora17 desktop with ext4fs:
qemu-system-x86_64 -hda test.img -m 1024 \
-net nic,vlan=4,model=virtio,macaddr=00:16:35:AF:94:04 \
-net tap,vlan=4,ifname=tap4,script=no,downscript=no \
-device virtio-9p-pci,id=fs0,fsdev=fsdev0,mount_tag=hostshare \
-fsdev local,security_model=passthrough,id=fsdev0,\
path=/upstream/vm/data/share/1234567890abcdefghijklmnopqrstuvwxyz\
ABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890acdefghijklmnopqrstuvwxyz\
ABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890/111111111111111111111111111\
1111111111111111111111111111111111111111111111111111222222222222\
2222222222222222222222222222222222222222222222222222222222222222\
2222222222222222222222222222222222233333333333333333333333333333\
3333333333333333333333333333333333
- Guest is ubuntu12 server with 9pfs.
mount -t 9p -o trans=virtio,version=9p2000.L hostshare /share
- Limitations:
full path limitation is PATH_MAX (4096B include nul) under Linux.
file/dir node name maximized length is 256 (include nul) under ext4.
- Special test:
Under host, modify the file: "/upstream/vm/data/share/1234567890abcdefg\
hijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890acdefghijklmno\
pqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890/111111111111111111111\
111111111111111111111111111111111111111111111111111111111122222222222\
222222222222222222222222222222222222222222222222222222222222222222222\
222222222222222222222222222222233333333333333333333333333333333333333\
3333333333333333333333333/4444444444444444444444444444444444444444444\
444444444444444444444444444444444444444444444444444444444444444444444\
444444444444444444444444444444444444444444444444444444444444444444444\
444444444444444444444444444444444444444/55555555555555555555555555555\
555555555555555555555555555555555555555555555555555555555555555555555\
555555555555555555555555555555555555555555555555555555555555555555555\
555555555555555555555555555555555555555555555555555555555555555555555\
55555555/666666666666666666666666666666666666666666666666666666666666\
666666666666666666666666666666666666666666666666666666666666666666666\
666666666666666666666666666666666666666666666666666666666666666666666\
666666666666666666666/77777777777777777777777777777777777777777777777\
777777777777777777777777777777777777777777777777777777777777777777777\
777777777777777777777777777777777777777777777777777777777777777777777\
77777777777777777777777777777777777777777777777777777777777/888888888\
888888888888888888888888888888888888888888888888888888888888888888888\
888888888888888888888888888888888888888888888888888888888888888888888\
888888888888888888888888888888888888888888888888888888888888888888888\
888888888/99999999999999999999999999999999999999999999999999999999999\
999999999999999999999999999999999999999999999999999999999999999999999\
999999999999999999999999999999999999999999999999999999999999999999999\
99999999999999999999999999999999999999999/000000000000000000000000000\
000000000000000000000000000000000000000000000000000000000000000000000\
000000000000000000000000000000000000000000000000000000000000000000000\
000000000000000000000000000000000000000000000000/aaaaaaaaaaaaaaaaaaaa\
aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\
aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\
aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa/bbbbbbbbbbbbbbbbbbbbbbb\
bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\
bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\
bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb/ccccccccc\
ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc\
ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc\
ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc\
cccccccccc/dddddddddddddddddddddddddddddddddddddddddddddddddddddddddd\
ddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddd\
ddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddd\
dddddddddddddddddddddd/eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee\
eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee\
eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee\
eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee/fffffffffffffff\
fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff\
fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff\
ffffffffffffffffffffffffffffffffffffffffffffffffffffffffff/gggggggggg\
ggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggg\
ggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggg\
ggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggg\
ggggggggggggggggggggggg/iiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiii\
iiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiii\
iiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiii\
iiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiii/jjjjjjjjjjjjj\
jjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjj\
jjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjj/ppppppppppppppppppppp\
ppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppp\
ppppppppppppppppppppppppppppppppppppppp/test1234567890file.log"
(need enter dir firstly, then modify file, or can not open it).
Under guest, still allow modify "test1234567890file.log" (will generate
"test123456" file with contents).
After apply this patch, can not open "test1234567890file.log" under guest
(permission denied).
- Common test:
All are still OK after apply this path.
"mkdir -p", "create/open file/dir", "modify file/dir", "rm file/dir".
change various mount point paths under host and/or guest.
Signed-off-by: Chen Gang <gang.chen.5i5j@gmail.com>
Signed-off-by: Aneesh Kumar K.V <aneesh.kumar@linux.vnet.ibm.com>
2014-03-02 01:36:19 +08:00
|
|
|
g_free(buffer);
|
2011-08-02 14:05:54 +08:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int handle_renameat(FsContext *ctx, V9fsPath *olddir,
|
|
|
|
const char *old_name, V9fsPath *newdir,
|
|
|
|
const char *new_name)
|
|
|
|
{
|
|
|
|
int olddirfd, newdirfd, ret;
|
|
|
|
struct handle_data *data = (struct handle_data *)ctx->private;
|
|
|
|
|
|
|
|
olddirfd = open_by_handle(data->mountfd, olddir->data, O_PATH);
|
|
|
|
if (olddirfd < 0) {
|
|
|
|
return olddirfd;
|
|
|
|
}
|
|
|
|
newdirfd = open_by_handle(data->mountfd, newdir->data, O_PATH);
|
|
|
|
if (newdirfd < 0) {
|
|
|
|
close(olddirfd);
|
|
|
|
return newdirfd;
|
|
|
|
}
|
|
|
|
ret = renameat(olddirfd, old_name, newdirfd, new_name);
|
|
|
|
close(newdirfd);
|
|
|
|
close(olddirfd);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int handle_unlinkat(FsContext *ctx, V9fsPath *dir,
|
|
|
|
const char *name, int flags)
|
|
|
|
{
|
|
|
|
int dirfd, ret;
|
|
|
|
struct handle_data *data = (struct handle_data *)ctx->private;
|
2011-11-19 00:35:38 +08:00
|
|
|
int rflags;
|
2011-08-02 14:05:54 +08:00
|
|
|
|
|
|
|
dirfd = open_by_handle(data->mountfd, dir->data, O_PATH);
|
|
|
|
if (dirfd < 0) {
|
|
|
|
return dirfd;
|
|
|
|
}
|
|
|
|
|
2011-11-19 00:35:38 +08:00
|
|
|
rflags = 0;
|
|
|
|
if (flags & P9_DOTL_AT_REMOVEDIR) {
|
|
|
|
rflags |= AT_REMOVEDIR;
|
|
|
|
}
|
|
|
|
|
|
|
|
ret = unlinkat(dirfd, name, rflags);
|
|
|
|
|
2011-08-02 14:05:54 +08:00
|
|
|
close(dirfd);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2011-10-12 21:41:25 +08:00
|
|
|
static int handle_ioc_getversion(FsContext *ctx, V9fsPath *path,
|
|
|
|
mode_t st_mode, uint64_t *st_gen)
|
|
|
|
{
|
2014-01-28 23:08:25 +08:00
|
|
|
#ifdef FS_IOC_GETVERSION
|
2011-10-25 14:40:40 +08:00
|
|
|
int err;
|
|
|
|
V9fsFidOpenState fid_open;
|
2011-10-12 21:41:25 +08:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Do not try to open special files like device nodes, fifos etc
|
|
|
|
* We can get fd for regular files and directories only
|
|
|
|
*/
|
|
|
|
if (!S_ISREG(st_mode) && !S_ISDIR(st_mode)) {
|
2014-01-28 23:08:26 +08:00
|
|
|
errno = ENOTTY;
|
|
|
|
return -1;
|
2011-10-12 21:41:25 +08:00
|
|
|
}
|
2011-10-25 14:40:40 +08:00
|
|
|
err = handle_open(ctx, path, O_RDONLY, &fid_open);
|
|
|
|
if (err < 0) {
|
|
|
|
return err;
|
2011-10-12 21:41:25 +08:00
|
|
|
}
|
2011-10-25 14:40:40 +08:00
|
|
|
err = ioctl(fid_open.fd, FS_IOC_GETVERSION, st_gen);
|
|
|
|
handle_close(ctx, &fid_open);
|
2011-10-12 21:41:25 +08:00
|
|
|
return err;
|
2014-01-28 23:08:25 +08:00
|
|
|
#else
|
|
|
|
errno = ENOTTY;
|
|
|
|
return -1;
|
|
|
|
#endif
|
2011-10-12 21:41:25 +08:00
|
|
|
}
|
|
|
|
|
2011-08-02 14:05:54 +08:00
|
|
|
static int handle_init(FsContext *ctx)
|
|
|
|
{
|
|
|
|
int ret, mnt_id;
|
2011-10-12 21:41:25 +08:00
|
|
|
struct statfs stbuf;
|
2011-08-02 14:05:54 +08:00
|
|
|
struct file_handle fh;
|
|
|
|
struct handle_data *data = g_malloc(sizeof(struct handle_data));
|
2011-10-12 21:41:24 +08:00
|
|
|
|
2011-08-02 14:05:54 +08:00
|
|
|
data->mountfd = open(ctx->fs_root, O_DIRECTORY);
|
|
|
|
if (data->mountfd < 0) {
|
|
|
|
ret = data->mountfd;
|
|
|
|
goto err_out;
|
|
|
|
}
|
2011-10-12 21:41:25 +08:00
|
|
|
ret = statfs(ctx->fs_root, &stbuf);
|
|
|
|
if (!ret) {
|
|
|
|
switch (stbuf.f_type) {
|
|
|
|
case EXT2_SUPER_MAGIC:
|
|
|
|
case BTRFS_SUPER_MAGIC:
|
|
|
|
case REISERFS_SUPER_MAGIC:
|
|
|
|
case XFS_SUPER_MAGIC:
|
|
|
|
ctx->exops.get_st_gen = handle_ioc_getversion;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
2011-08-02 14:05:54 +08:00
|
|
|
memset(&fh, 0, sizeof(struct file_handle));
|
|
|
|
ret = name_to_handle(data->mountfd, ".", &fh, &mnt_id, 0);
|
|
|
|
if (ret && errno == EOVERFLOW) {
|
|
|
|
data->handle_bytes = fh.handle_bytes;
|
|
|
|
ctx->private = data;
|
|
|
|
ret = 0;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
/* we got 0 byte handle ? */
|
|
|
|
ret = -1;
|
|
|
|
close(data->mountfd);
|
|
|
|
err_out:
|
|
|
|
g_free(data);
|
|
|
|
out:
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2011-12-14 16:18:59 +08:00
|
|
|
static int handle_parse_opts(QemuOpts *opts, struct FsDriverEntry *fse)
|
|
|
|
{
|
|
|
|
const char *sec_model = qemu_opt_get(opts, "security_model");
|
|
|
|
const char *path = qemu_opt_get(opts, "path");
|
|
|
|
|
|
|
|
if (sec_model) {
|
2016-01-22 22:12:17 +08:00
|
|
|
error_report("Invalid argument security_model specified with handle fsdriver");
|
2011-12-14 16:18:59 +08:00
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!path) {
|
2016-01-22 22:12:17 +08:00
|
|
|
error_report("fsdev: No path specified");
|
2011-12-14 16:18:59 +08:00
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
fse->path = g_strdup(path);
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
}
|
|
|
|
|
2011-08-02 14:05:54 +08:00
|
|
|
FileOperations handle_ops = {
|
2011-12-14 16:18:59 +08:00
|
|
|
.parse_opts = handle_parse_opts,
|
2011-08-02 14:05:54 +08:00
|
|
|
.init = handle_init,
|
|
|
|
.lstat = handle_lstat,
|
|
|
|
.readlink = handle_readlink,
|
|
|
|
.close = handle_close,
|
|
|
|
.closedir = handle_closedir,
|
|
|
|
.open = handle_open,
|
|
|
|
.opendir = handle_opendir,
|
|
|
|
.rewinddir = handle_rewinddir,
|
|
|
|
.telldir = handle_telldir,
|
|
|
|
.readdir_r = handle_readdir_r,
|
|
|
|
.seekdir = handle_seekdir,
|
|
|
|
.preadv = handle_preadv,
|
|
|
|
.pwritev = handle_pwritev,
|
|
|
|
.chmod = handle_chmod,
|
|
|
|
.mknod = handle_mknod,
|
|
|
|
.mkdir = handle_mkdir,
|
|
|
|
.fstat = handle_fstat,
|
|
|
|
.open2 = handle_open2,
|
|
|
|
.symlink = handle_symlink,
|
|
|
|
.link = handle_link,
|
|
|
|
.truncate = handle_truncate,
|
|
|
|
.rename = handle_rename,
|
|
|
|
.chown = handle_chown,
|
|
|
|
.utimensat = handle_utimensat,
|
|
|
|
.remove = handle_remove,
|
|
|
|
.fsync = handle_fsync,
|
|
|
|
.statfs = handle_statfs,
|
|
|
|
.lgetxattr = handle_lgetxattr,
|
|
|
|
.llistxattr = handle_llistxattr,
|
|
|
|
.lsetxattr = handle_lsetxattr,
|
|
|
|
.lremovexattr = handle_lremovexattr,
|
|
|
|
.name_to_path = handle_name_to_path,
|
|
|
|
.renameat = handle_renameat,
|
|
|
|
.unlinkat = handle_unlinkat,
|
|
|
|
};
|