2010-04-29 14:14:44 +02:00
|
|
|
/*
|
|
|
|
* Virtio 9p Posix callback
|
|
|
|
*
|
|
|
|
* 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.
|
|
|
|
*
|
|
|
|
*/
|
2011-06-01 09:05:14 +02:00
|
|
|
|
|
|
|
#include "hw/virtio.h"
|
2010-04-29 14:14:44 +02:00
|
|
|
#include "virtio-9p.h"
|
2010-10-18 11:58:16 +02:00
|
|
|
#include "virtio-9p-xattr.h"
|
2010-04-29 14:14:59 +02:00
|
|
|
#include <arpa/inet.h>
|
2010-04-29 14:14:47 +02:00
|
|
|
#include <pwd.h>
|
|
|
|
#include <grp.h>
|
2010-04-29 14:14:59 +02:00
|
|
|
#include <sys/socket.h>
|
|
|
|
#include <sys/un.h>
|
2011-11-09 13:44:52 +01:00
|
|
|
#include "qemu-xattr.h"
|
2011-10-12 15:41:25 +02: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
|
2010-04-29 14:14:47 +02:00
|
|
|
|
2011-09-09 11:44:18 +02:00
|
|
|
static int local_lstat(FsContext *fs_ctx, V9fsPath *fs_path, struct stat *stbuf)
|
2010-04-29 14:14:47 +02:00
|
|
|
{
|
2010-06-14 22:34:44 +02:00
|
|
|
int err;
|
2011-06-01 09:05:14 +02:00
|
|
|
char buffer[PATH_MAX];
|
2011-09-09 11:44:18 +02:00
|
|
|
char *path = fs_path->data;
|
|
|
|
|
2011-06-01 09:05:14 +02:00
|
|
|
err = lstat(rpath(fs_ctx, path, buffer), stbuf);
|
2010-06-14 22:34:44 +02:00
|
|
|
if (err) {
|
|
|
|
return err;
|
|
|
|
}
|
2011-10-13 09:51:00 +02:00
|
|
|
if (fs_ctx->export_flags & V9FS_SM_MAPPED) {
|
2010-06-14 22:34:44 +02:00
|
|
|
/* Actual credentials are part of extended attrs */
|
|
|
|
uid_t tmp_uid;
|
|
|
|
gid_t tmp_gid;
|
|
|
|
mode_t tmp_mode;
|
|
|
|
dev_t tmp_dev;
|
2011-06-01 09:05:14 +02:00
|
|
|
if (getxattr(rpath(fs_ctx, path, buffer), "user.virtfs.uid", &tmp_uid,
|
2010-06-14 22:34:44 +02:00
|
|
|
sizeof(uid_t)) > 0) {
|
|
|
|
stbuf->st_uid = tmp_uid;
|
|
|
|
}
|
2011-06-01 09:05:14 +02:00
|
|
|
if (getxattr(rpath(fs_ctx, path, buffer), "user.virtfs.gid", &tmp_gid,
|
2010-06-14 22:34:44 +02:00
|
|
|
sizeof(gid_t)) > 0) {
|
|
|
|
stbuf->st_gid = tmp_gid;
|
|
|
|
}
|
2011-06-01 09:05:14 +02:00
|
|
|
if (getxattr(rpath(fs_ctx, path, buffer), "user.virtfs.mode",
|
|
|
|
&tmp_mode, sizeof(mode_t)) > 0) {
|
2010-06-14 22:34:44 +02:00
|
|
|
stbuf->st_mode = tmp_mode;
|
|
|
|
}
|
2011-06-01 09:05:14 +02:00
|
|
|
if (getxattr(rpath(fs_ctx, path, buffer), "user.virtfs.rdev", &tmp_dev,
|
2010-06-14 22:34:44 +02:00
|
|
|
sizeof(dev_t)) > 0) {
|
|
|
|
stbuf->st_rdev = tmp_dev;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return err;
|
2010-04-29 14:14:47 +02:00
|
|
|
}
|
|
|
|
|
2010-06-14 22:34:41 +02:00
|
|
|
static int local_set_xattr(const char *path, FsCred *credp)
|
2010-04-29 14:14:47 +02:00
|
|
|
{
|
2010-06-14 22:34:41 +02:00
|
|
|
int err;
|
2011-09-09 11:44:18 +02:00
|
|
|
|
2010-06-14 22:34:41 +02:00
|
|
|
if (credp->fc_uid != -1) {
|
|
|
|
err = setxattr(path, "user.virtfs.uid", &credp->fc_uid, sizeof(uid_t),
|
|
|
|
0);
|
|
|
|
if (err) {
|
|
|
|
return err;
|
|
|
|
}
|
2010-04-29 14:14:47 +02:00
|
|
|
}
|
2010-06-14 22:34:41 +02:00
|
|
|
if (credp->fc_gid != -1) {
|
|
|
|
err = setxattr(path, "user.virtfs.gid", &credp->fc_gid, sizeof(gid_t),
|
|
|
|
0);
|
|
|
|
if (err) {
|
|
|
|
return err;
|
|
|
|
}
|
2010-04-29 14:14:47 +02:00
|
|
|
}
|
2010-06-14 22:34:41 +02:00
|
|
|
if (credp->fc_mode != -1) {
|
|
|
|
err = setxattr(path, "user.virtfs.mode", &credp->fc_mode,
|
|
|
|
sizeof(mode_t), 0);
|
|
|
|
if (err) {
|
|
|
|
return err;
|
|
|
|
}
|
2010-04-29 14:14:47 +02:00
|
|
|
}
|
2010-06-14 22:34:41 +02:00
|
|
|
if (credp->fc_rdev != -1) {
|
|
|
|
err = setxattr(path, "user.virtfs.rdev", &credp->fc_rdev,
|
|
|
|
sizeof(dev_t), 0);
|
|
|
|
if (err) {
|
|
|
|
return err;
|
|
|
|
}
|
2010-04-29 14:14:47 +02:00
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2010-06-14 22:34:45 +02:00
|
|
|
static int local_post_create_passthrough(FsContext *fs_ctx, const char *path,
|
2011-09-09 11:44:18 +02:00
|
|
|
FsCred *credp)
|
2010-06-14 22:34:45 +02:00
|
|
|
{
|
2011-06-01 09:05:14 +02:00
|
|
|
char buffer[PATH_MAX];
|
2011-09-09 11:44:18 +02:00
|
|
|
|
2011-06-01 09:05:14 +02:00
|
|
|
if (chmod(rpath(fs_ctx, path, buffer), credp->fc_mode & 07777) < 0) {
|
2010-06-14 22:34:45 +02:00
|
|
|
return -1;
|
|
|
|
}
|
2011-06-01 09:05:14 +02:00
|
|
|
if (lchown(rpath(fs_ctx, path, buffer), credp->fc_uid,
|
|
|
|
credp->fc_gid) < 0) {
|
2010-09-02 07:39:07 +02:00
|
|
|
/*
|
|
|
|
* If we fail to change ownership and if we are
|
|
|
|
* using security model none. Ignore the error
|
|
|
|
*/
|
2011-10-13 09:51:00 +02:00
|
|
|
if ((fs_ctx->export_flags & V9FS_SEC_MASK) != V9FS_SM_NONE) {
|
2010-09-02 07:39:07 +02:00
|
|
|
return -1;
|
|
|
|
}
|
2010-06-14 22:34:45 +02:00
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2011-09-09 11:44:18 +02:00
|
|
|
static ssize_t local_readlink(FsContext *fs_ctx, V9fsPath *fs_path,
|
|
|
|
char *buf, size_t bufsz)
|
2010-04-29 14:14:47 +02:00
|
|
|
{
|
2010-06-14 22:34:47 +02:00
|
|
|
ssize_t tsize = -1;
|
2011-06-01 09:05:14 +02:00
|
|
|
char buffer[PATH_MAX];
|
2011-09-09 11:44:18 +02:00
|
|
|
char *path = fs_path->data;
|
|
|
|
|
2011-10-13 09:51:00 +02:00
|
|
|
if (fs_ctx->export_flags & V9FS_SM_MAPPED) {
|
2010-06-14 22:34:47 +02:00
|
|
|
int fd;
|
2011-06-01 09:05:14 +02:00
|
|
|
fd = open(rpath(fs_ctx, path, buffer), O_RDONLY);
|
2010-06-14 22:34:47 +02:00
|
|
|
if (fd == -1) {
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
do {
|
|
|
|
tsize = read(fd, (void *)buf, bufsz);
|
|
|
|
} while (tsize == -1 && errno == EINTR);
|
|
|
|
close(fd);
|
|
|
|
return tsize;
|
2011-10-13 09:51:00 +02:00
|
|
|
} else if ((fs_ctx->export_flags & V9FS_SM_PASSTHROUGH) ||
|
|
|
|
(fs_ctx->export_flags & V9FS_SM_NONE)) {
|
2011-06-01 09:05:14 +02:00
|
|
|
tsize = readlink(rpath(fs_ctx, path, buffer), buf, bufsz);
|
2010-06-14 22:34:47 +02:00
|
|
|
}
|
|
|
|
return tsize;
|
2010-04-29 14:14:47 +02:00
|
|
|
}
|
|
|
|
|
2011-10-25 08:40:40 +02:00
|
|
|
static int local_close(FsContext *ctx, V9fsFidOpenState *fs)
|
2010-04-29 14:14:47 +02:00
|
|
|
{
|
2011-10-25 08:40:40 +02:00
|
|
|
return close(fs->fd);
|
2010-04-29 14:14:47 +02:00
|
|
|
}
|
|
|
|
|
2011-10-25 08:40:40 +02:00
|
|
|
static int local_closedir(FsContext *ctx, V9fsFidOpenState *fs)
|
2010-04-29 14:14:47 +02:00
|
|
|
{
|
2011-10-25 08:40:40 +02:00
|
|
|
return closedir(fs->dir);
|
2010-04-29 14:14:47 +02:00
|
|
|
}
|
2010-04-29 14:14:44 +02:00
|
|
|
|
2011-10-25 08:40:40 +02:00
|
|
|
static int local_open(FsContext *ctx, V9fsPath *fs_path,
|
|
|
|
int flags, V9fsFidOpenState *fs)
|
2010-04-29 14:14:55 +02:00
|
|
|
{
|
2011-06-01 09:05:14 +02:00
|
|
|
char buffer[PATH_MAX];
|
2011-09-09 11:44:18 +02:00
|
|
|
char *path = fs_path->data;
|
|
|
|
|
2011-10-25 08:40:40 +02:00
|
|
|
fs->fd = open(rpath(ctx, path, buffer), flags);
|
|
|
|
return fs->fd;
|
2010-04-29 14:14:55 +02:00
|
|
|
}
|
|
|
|
|
2011-10-25 08:40:40 +02:00
|
|
|
static int local_opendir(FsContext *ctx,
|
|
|
|
V9fsPath *fs_path, V9fsFidOpenState *fs)
|
2010-04-29 14:14:55 +02:00
|
|
|
{
|
2011-06-01 09:05:14 +02:00
|
|
|
char buffer[PATH_MAX];
|
2011-09-09 11:44:18 +02:00
|
|
|
char *path = fs_path->data;
|
|
|
|
|
2011-10-25 08:40:40 +02:00
|
|
|
fs->dir = opendir(rpath(ctx, path, buffer));
|
|
|
|
if (!fs->dir) {
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
return 0;
|
2010-04-29 14:14:55 +02:00
|
|
|
}
|
|
|
|
|
2011-10-25 08:40:40 +02:00
|
|
|
static void local_rewinddir(FsContext *ctx, V9fsFidOpenState *fs)
|
2010-04-29 14:14:56 +02:00
|
|
|
{
|
2011-10-25 08:40:40 +02:00
|
|
|
return rewinddir(fs->dir);
|
2010-04-29 14:14:56 +02:00
|
|
|
}
|
|
|
|
|
2011-10-25 08:40:40 +02:00
|
|
|
static off_t local_telldir(FsContext *ctx, V9fsFidOpenState *fs)
|
2010-04-29 14:14:56 +02:00
|
|
|
{
|
2011-10-25 08:40:40 +02:00
|
|
|
return telldir(fs->dir);
|
2010-04-29 14:14:56 +02:00
|
|
|
}
|
|
|
|
|
2011-10-25 08:40:40 +02:00
|
|
|
static int local_readdir_r(FsContext *ctx, V9fsFidOpenState *fs,
|
|
|
|
struct dirent *entry,
|
2011-09-09 11:44:18 +02:00
|
|
|
struct dirent **result)
|
2010-04-29 14:14:56 +02:00
|
|
|
{
|
2011-10-25 08:40:40 +02:00
|
|
|
return readdir_r(fs->dir, entry, result);
|
2010-04-29 14:14:56 +02:00
|
|
|
}
|
|
|
|
|
2011-10-25 08:40:40 +02:00
|
|
|
static void local_seekdir(FsContext *ctx, V9fsFidOpenState *fs, off_t off)
|
2010-04-29 14:14:56 +02:00
|
|
|
{
|
2011-10-25 08:40:40 +02:00
|
|
|
return seekdir(fs->dir, off);
|
2010-04-29 14:14:56 +02:00
|
|
|
}
|
|
|
|
|
2011-10-25 08:40:40 +02:00
|
|
|
static ssize_t local_preadv(FsContext *ctx, V9fsFidOpenState *fs,
|
|
|
|
const struct iovec *iov,
|
2010-10-08 08:00:16 +02:00
|
|
|
int iovcnt, off_t offset)
|
2010-04-29 14:14:56 +02:00
|
|
|
{
|
2010-10-08 08:00:16 +02:00
|
|
|
#ifdef CONFIG_PREADV
|
2011-10-25 08:40:40 +02:00
|
|
|
return preadv(fs->fd, iov, iovcnt, offset);
|
2010-10-08 08:00:16 +02:00
|
|
|
#else
|
2011-10-25 08:40:40 +02:00
|
|
|
int err = lseek(fs->fd, offset, SEEK_SET);
|
2010-10-08 08:00:16 +02:00
|
|
|
if (err == -1) {
|
|
|
|
return err;
|
|
|
|
} else {
|
2011-10-25 08:40:40 +02:00
|
|
|
return readv(fs->fd, iov, iovcnt);
|
2010-10-08 08:00:16 +02:00
|
|
|
}
|
|
|
|
#endif
|
2010-04-29 14:14:56 +02:00
|
|
|
}
|
|
|
|
|
2011-10-25 08:40:40 +02:00
|
|
|
static ssize_t local_pwritev(FsContext *ctx, V9fsFidOpenState *fs,
|
|
|
|
const struct iovec *iov,
|
2011-09-09 11:44:18 +02:00
|
|
|
int iovcnt, off_t offset)
|
2010-04-29 14:14:58 +02:00
|
|
|
{
|
2011-10-12 15:41:23 +02:00
|
|
|
ssize_t ret
|
|
|
|
;
|
2010-10-08 08:00:16 +02:00
|
|
|
#ifdef CONFIG_PREADV
|
2011-10-25 08:40:40 +02:00
|
|
|
ret = pwritev(fs->fd, iov, iovcnt, offset);
|
2010-10-08 08:00:16 +02:00
|
|
|
#else
|
2011-10-25 08:40:40 +02:00
|
|
|
int err = lseek(fs->fd, offset, SEEK_SET);
|
2010-10-08 08:00:16 +02:00
|
|
|
if (err == -1) {
|
|
|
|
return err;
|
|
|
|
} else {
|
2011-10-25 08:40:40 +02:00
|
|
|
ret = writev(fs->fd, iov, iovcnt);
|
2010-10-08 08:00:16 +02:00
|
|
|
}
|
|
|
|
#endif
|
2011-10-12 15:41:23 +02: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 08:40:40 +02:00
|
|
|
sync_file_range(fs->fd, offset, ret,
|
2011-10-12 15:41:23 +02:00
|
|
|
SYNC_FILE_RANGE_WAIT_BEFORE | SYNC_FILE_RANGE_WRITE);
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
return ret;
|
2010-04-29 14:14:58 +02:00
|
|
|
}
|
|
|
|
|
2011-09-09 11:44:18 +02:00
|
|
|
static int local_chmod(FsContext *fs_ctx, V9fsPath *fs_path, FsCred *credp)
|
2010-04-29 14:14:59 +02:00
|
|
|
{
|
2011-06-01 09:05:14 +02:00
|
|
|
char buffer[PATH_MAX];
|
2011-09-09 11:44:18 +02:00
|
|
|
char *path = fs_path->data;
|
|
|
|
|
2011-10-13 09:51:00 +02:00
|
|
|
if (fs_ctx->export_flags & V9FS_SM_MAPPED) {
|
2011-06-01 09:05:14 +02:00
|
|
|
return local_set_xattr(rpath(fs_ctx, path, buffer), credp);
|
2011-10-13 09:51:00 +02:00
|
|
|
} else if ((fs_ctx->export_flags & V9FS_SM_PASSTHROUGH) ||
|
|
|
|
(fs_ctx->export_flags & V9FS_SM_NONE)) {
|
2011-06-01 09:05:14 +02:00
|
|
|
return chmod(rpath(fs_ctx, path, buffer), credp->fc_mode);
|
2010-06-14 22:34:42 +02:00
|
|
|
}
|
|
|
|
return -1;
|
2010-04-29 14:14:59 +02:00
|
|
|
}
|
|
|
|
|
2011-09-09 11:44:18 +02:00
|
|
|
static int local_mknod(FsContext *fs_ctx, V9fsPath *dir_path,
|
|
|
|
const char *name, FsCred *credp)
|
2010-04-29 14:14:59 +02:00
|
|
|
{
|
2011-09-09 11:44:18 +02:00
|
|
|
char *path;
|
2010-06-14 22:34:48 +02:00
|
|
|
int err = -1;
|
|
|
|
int serrno = 0;
|
2011-09-09 11:44:18 +02:00
|
|
|
V9fsString fullname;
|
2011-06-01 09:05:14 +02:00
|
|
|
char buffer[PATH_MAX];
|
2010-06-14 22:34:48 +02:00
|
|
|
|
2011-09-09 11:44:18 +02:00
|
|
|
v9fs_string_init(&fullname);
|
|
|
|
v9fs_string_sprintf(&fullname, "%s/%s", dir_path->data, name);
|
|
|
|
path = fullname.data;
|
|
|
|
|
2010-06-14 22:34:48 +02:00
|
|
|
/* Determine the security model */
|
2011-10-13 09:51:00 +02:00
|
|
|
if (fs_ctx->export_flags & V9FS_SM_MAPPED) {
|
2011-06-01 09:05:14 +02:00
|
|
|
err = mknod(rpath(fs_ctx, path, buffer),
|
|
|
|
SM_LOCAL_MODE_BITS|S_IFREG, 0);
|
2010-06-14 22:34:48 +02:00
|
|
|
if (err == -1) {
|
2011-09-09 11:44:18 +02:00
|
|
|
goto out;
|
2010-06-14 22:34:48 +02:00
|
|
|
}
|
2011-10-25 08:40:39 +02:00
|
|
|
err = local_set_xattr(rpath(fs_ctx, path, buffer), credp);
|
2010-06-14 22:34:48 +02:00
|
|
|
if (err == -1) {
|
|
|
|
serrno = errno;
|
|
|
|
goto err_end;
|
|
|
|
}
|
2011-10-13 09:51:00 +02:00
|
|
|
} else if ((fs_ctx->export_flags & V9FS_SM_PASSTHROUGH) ||
|
|
|
|
(fs_ctx->export_flags & V9FS_SM_NONE)) {
|
2011-06-01 09:05:14 +02:00
|
|
|
err = mknod(rpath(fs_ctx, path, buffer), credp->fc_mode,
|
|
|
|
credp->fc_rdev);
|
2010-06-14 22:34:48 +02:00
|
|
|
if (err == -1) {
|
2011-09-09 11:44:18 +02:00
|
|
|
goto out;
|
2010-06-14 22:34:48 +02:00
|
|
|
}
|
|
|
|
err = local_post_create_passthrough(fs_ctx, path, credp);
|
|
|
|
if (err == -1) {
|
|
|
|
serrno = errno;
|
|
|
|
goto err_end;
|
|
|
|
}
|
|
|
|
}
|
2011-09-09 11:44:18 +02:00
|
|
|
goto out;
|
2010-06-14 22:34:48 +02:00
|
|
|
|
|
|
|
err_end:
|
2011-06-01 09:05:14 +02:00
|
|
|
remove(rpath(fs_ctx, path, buffer));
|
2010-06-14 22:34:48 +02:00
|
|
|
errno = serrno;
|
2011-09-09 11:44:18 +02:00
|
|
|
out:
|
|
|
|
v9fs_string_free(&fullname);
|
2010-06-14 22:34:48 +02:00
|
|
|
return err;
|
2010-04-29 14:14:59 +02:00
|
|
|
}
|
|
|
|
|
2011-09-09 11:44:18 +02:00
|
|
|
static int local_mkdir(FsContext *fs_ctx, V9fsPath *dir_path,
|
|
|
|
const char *name, FsCred *credp)
|
2010-04-29 14:14:59 +02:00
|
|
|
{
|
2011-09-09 11:44:18 +02:00
|
|
|
char *path;
|
2010-06-14 22:34:46 +02:00
|
|
|
int err = -1;
|
|
|
|
int serrno = 0;
|
2011-09-09 11:44:18 +02:00
|
|
|
V9fsString fullname;
|
2011-06-01 09:05:14 +02:00
|
|
|
char buffer[PATH_MAX];
|
2010-06-14 22:34:46 +02:00
|
|
|
|
2011-09-09 11:44:18 +02:00
|
|
|
v9fs_string_init(&fullname);
|
|
|
|
v9fs_string_sprintf(&fullname, "%s/%s", dir_path->data, name);
|
|
|
|
path = fullname.data;
|
|
|
|
|
2010-06-14 22:34:46 +02:00
|
|
|
/* Determine the security model */
|
2011-10-13 09:51:00 +02:00
|
|
|
if (fs_ctx->export_flags & V9FS_SM_MAPPED) {
|
2011-06-01 09:05:14 +02:00
|
|
|
err = mkdir(rpath(fs_ctx, path, buffer), SM_LOCAL_DIR_MODE_BITS);
|
2010-06-14 22:34:46 +02:00
|
|
|
if (err == -1) {
|
2011-09-09 11:44:18 +02:00
|
|
|
goto out;
|
2010-06-14 22:34:46 +02:00
|
|
|
}
|
|
|
|
credp->fc_mode = credp->fc_mode|S_IFDIR;
|
2011-06-01 09:05:14 +02:00
|
|
|
err = local_set_xattr(rpath(fs_ctx, path, buffer), credp);
|
2010-06-14 22:34:46 +02:00
|
|
|
if (err == -1) {
|
|
|
|
serrno = errno;
|
|
|
|
goto err_end;
|
|
|
|
}
|
2011-10-13 09:51:00 +02:00
|
|
|
} else if ((fs_ctx->export_flags & V9FS_SM_PASSTHROUGH) ||
|
|
|
|
(fs_ctx->export_flags & V9FS_SM_NONE)) {
|
2011-06-01 09:05:14 +02:00
|
|
|
err = mkdir(rpath(fs_ctx, path, buffer), credp->fc_mode);
|
2010-06-14 22:34:46 +02:00
|
|
|
if (err == -1) {
|
2011-09-09 11:44:18 +02:00
|
|
|
goto out;
|
2010-06-14 22:34:46 +02:00
|
|
|
}
|
|
|
|
err = local_post_create_passthrough(fs_ctx, path, credp);
|
|
|
|
if (err == -1) {
|
|
|
|
serrno = errno;
|
|
|
|
goto err_end;
|
|
|
|
}
|
|
|
|
}
|
2011-09-09 11:44:18 +02:00
|
|
|
goto out;
|
2010-06-14 22:34:46 +02:00
|
|
|
|
|
|
|
err_end:
|
2011-06-01 09:05:14 +02:00
|
|
|
remove(rpath(fs_ctx, path, buffer));
|
2010-06-14 22:34:46 +02:00
|
|
|
errno = serrno;
|
2011-09-09 11:44:18 +02:00
|
|
|
out:
|
|
|
|
v9fs_string_free(&fullname);
|
2010-06-14 22:34:46 +02:00
|
|
|
return err;
|
2010-04-29 14:14:59 +02:00
|
|
|
}
|
|
|
|
|
2011-10-25 08:40:40 +02:00
|
|
|
static int local_fstat(FsContext *fs_ctx,
|
|
|
|
V9fsFidOpenState *fs, struct stat *stbuf)
|
2010-04-29 14:14:59 +02:00
|
|
|
{
|
2010-06-14 22:34:44 +02:00
|
|
|
int err;
|
2011-10-25 08:40:40 +02:00
|
|
|
err = fstat(fs->fd, stbuf);
|
2010-06-14 22:34:44 +02:00
|
|
|
if (err) {
|
|
|
|
return err;
|
|
|
|
}
|
2011-10-13 09:51:00 +02:00
|
|
|
if (fs_ctx->export_flags & V9FS_SM_MAPPED) {
|
2010-06-14 22:34:44 +02:00
|
|
|
/* Actual credentials are part of extended attrs */
|
|
|
|
uid_t tmp_uid;
|
|
|
|
gid_t tmp_gid;
|
|
|
|
mode_t tmp_mode;
|
|
|
|
dev_t tmp_dev;
|
|
|
|
|
2011-10-25 08:40:40 +02:00
|
|
|
if (fgetxattr(fs->fd, "user.virtfs.uid",
|
|
|
|
&tmp_uid, sizeof(uid_t)) > 0) {
|
2010-06-14 22:34:44 +02:00
|
|
|
stbuf->st_uid = tmp_uid;
|
|
|
|
}
|
2011-10-25 08:40:40 +02:00
|
|
|
if (fgetxattr(fs->fd, "user.virtfs.gid",
|
|
|
|
&tmp_gid, sizeof(gid_t)) > 0) {
|
2010-06-14 22:34:44 +02:00
|
|
|
stbuf->st_gid = tmp_gid;
|
|
|
|
}
|
2011-10-25 08:40:40 +02:00
|
|
|
if (fgetxattr(fs->fd, "user.virtfs.mode",
|
|
|
|
&tmp_mode, sizeof(mode_t)) > 0) {
|
2010-06-14 22:34:44 +02:00
|
|
|
stbuf->st_mode = tmp_mode;
|
|
|
|
}
|
2011-10-25 08:40:40 +02:00
|
|
|
if (fgetxattr(fs->fd, "user.virtfs.rdev",
|
|
|
|
&tmp_dev, sizeof(dev_t)) > 0) {
|
2010-06-14 22:34:44 +02:00
|
|
|
stbuf->st_rdev = tmp_dev;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return err;
|
2010-04-29 14:14:59 +02:00
|
|
|
}
|
|
|
|
|
2011-09-09 11:44:18 +02:00
|
|
|
static int local_open2(FsContext *fs_ctx, V9fsPath *dir_path, const char *name,
|
2011-10-25 08:40:40 +02:00
|
|
|
int flags, FsCred *credp, V9fsFidOpenState *fs)
|
2010-04-29 14:14:59 +02:00
|
|
|
{
|
2011-09-09 11:44:18 +02:00
|
|
|
char *path;
|
2010-06-14 22:34:45 +02:00
|
|
|
int fd = -1;
|
|
|
|
int err = -1;
|
|
|
|
int serrno = 0;
|
2011-09-09 11:44:18 +02:00
|
|
|
V9fsString fullname;
|
2011-06-01 09:05:14 +02:00
|
|
|
char buffer[PATH_MAX];
|
2010-06-14 22:34:45 +02:00
|
|
|
|
2011-09-09 11:44:18 +02:00
|
|
|
v9fs_string_init(&fullname);
|
|
|
|
v9fs_string_sprintf(&fullname, "%s/%s", dir_path->data, name);
|
|
|
|
path = fullname.data;
|
|
|
|
|
2010-06-14 22:34:45 +02:00
|
|
|
/* Determine the security model */
|
2011-10-13 09:51:00 +02:00
|
|
|
if (fs_ctx->export_flags & V9FS_SM_MAPPED) {
|
2011-06-01 09:05:14 +02:00
|
|
|
fd = open(rpath(fs_ctx, path, buffer), flags, SM_LOCAL_MODE_BITS);
|
2010-06-14 22:34:45 +02:00
|
|
|
if (fd == -1) {
|
2011-09-09 11:44:18 +02:00
|
|
|
err = fd;
|
|
|
|
goto out;
|
2010-06-14 22:34:45 +02:00
|
|
|
}
|
|
|
|
credp->fc_mode = credp->fc_mode|S_IFREG;
|
|
|
|
/* Set cleint credentials in xattr */
|
2011-06-01 09:05:14 +02:00
|
|
|
err = local_set_xattr(rpath(fs_ctx, path, buffer), credp);
|
2010-06-14 22:34:45 +02:00
|
|
|
if (err == -1) {
|
|
|
|
serrno = errno;
|
|
|
|
goto err_end;
|
|
|
|
}
|
2011-10-13 09:51:00 +02:00
|
|
|
} else if ((fs_ctx->export_flags & V9FS_SM_PASSTHROUGH) ||
|
|
|
|
(fs_ctx->export_flags & V9FS_SM_NONE)) {
|
2011-06-01 09:05:14 +02:00
|
|
|
fd = open(rpath(fs_ctx, path, buffer), flags, credp->fc_mode);
|
2010-06-14 22:34:45 +02:00
|
|
|
if (fd == -1) {
|
2011-09-09 11:44:18 +02:00
|
|
|
err = fd;
|
|
|
|
goto out;
|
2010-06-14 22:34:45 +02:00
|
|
|
}
|
|
|
|
err = local_post_create_passthrough(fs_ctx, path, credp);
|
|
|
|
if (err == -1) {
|
|
|
|
serrno = errno;
|
|
|
|
goto err_end;
|
|
|
|
}
|
|
|
|
}
|
2011-09-09 11:44:18 +02:00
|
|
|
err = fd;
|
2011-10-25 08:40:40 +02:00
|
|
|
fs->fd = fd;
|
2011-09-09 11:44:18 +02:00
|
|
|
goto out;
|
2010-06-14 22:34:45 +02:00
|
|
|
|
|
|
|
err_end:
|
|
|
|
close(fd);
|
2011-06-01 09:05:14 +02:00
|
|
|
remove(rpath(fs_ctx, path, buffer));
|
2010-06-14 22:34:45 +02:00
|
|
|
errno = serrno;
|
2011-09-09 11:44:18 +02:00
|
|
|
out:
|
|
|
|
v9fs_string_free(&fullname);
|
2010-06-14 22:34:45 +02:00
|
|
|
return err;
|
2010-04-29 14:14:59 +02:00
|
|
|
}
|
|
|
|
|
2010-06-14 22:34:41 +02:00
|
|
|
|
2010-06-14 22:34:47 +02:00
|
|
|
static int local_symlink(FsContext *fs_ctx, const char *oldpath,
|
2011-09-09 11:44:18 +02:00
|
|
|
V9fsPath *dir_path, const char *name, FsCred *credp)
|
2010-04-29 14:14:59 +02:00
|
|
|
{
|
2010-06-14 22:34:47 +02:00
|
|
|
int err = -1;
|
|
|
|
int serrno = 0;
|
2011-09-09 11:44:18 +02:00
|
|
|
char *newpath;
|
|
|
|
V9fsString fullname;
|
2011-06-01 09:05:14 +02:00
|
|
|
char buffer[PATH_MAX];
|
2010-06-14 22:34:47 +02:00
|
|
|
|
2011-09-09 11:44:18 +02:00
|
|
|
v9fs_string_init(&fullname);
|
|
|
|
v9fs_string_sprintf(&fullname, "%s/%s", dir_path->data, name);
|
|
|
|
newpath = fullname.data;
|
|
|
|
|
2010-06-14 22:34:47 +02:00
|
|
|
/* Determine the security model */
|
2011-10-13 09:51:00 +02:00
|
|
|
if (fs_ctx->export_flags & V9FS_SM_MAPPED) {
|
2010-06-14 22:34:47 +02:00
|
|
|
int fd;
|
|
|
|
ssize_t oldpath_size, write_size;
|
2011-06-01 09:05:14 +02:00
|
|
|
fd = open(rpath(fs_ctx, newpath, buffer), O_CREAT|O_EXCL|O_RDWR,
|
2010-06-14 22:34:47 +02:00
|
|
|
SM_LOCAL_MODE_BITS);
|
|
|
|
if (fd == -1) {
|
2011-09-09 11:44:18 +02:00
|
|
|
err = fd;
|
|
|
|
goto out;
|
2010-06-14 22:34:47 +02:00
|
|
|
}
|
|
|
|
/* Write the oldpath (target) to the file. */
|
2011-02-02 05:50:33 +01:00
|
|
|
oldpath_size = strlen(oldpath);
|
2010-06-14 22:34:47 +02:00
|
|
|
do {
|
|
|
|
write_size = write(fd, (void *)oldpath, oldpath_size);
|
|
|
|
} while (write_size == -1 && errno == EINTR);
|
|
|
|
|
|
|
|
if (write_size != oldpath_size) {
|
|
|
|
serrno = errno;
|
|
|
|
close(fd);
|
|
|
|
err = -1;
|
|
|
|
goto err_end;
|
|
|
|
}
|
|
|
|
close(fd);
|
|
|
|
/* Set cleint credentials in symlink's xattr */
|
|
|
|
credp->fc_mode = credp->fc_mode|S_IFLNK;
|
2011-06-01 09:05:14 +02:00
|
|
|
err = local_set_xattr(rpath(fs_ctx, newpath, buffer), credp);
|
2010-06-14 22:34:47 +02:00
|
|
|
if (err == -1) {
|
|
|
|
serrno = errno;
|
|
|
|
goto err_end;
|
|
|
|
}
|
2011-10-13 09:51:00 +02:00
|
|
|
} else if ((fs_ctx->export_flags & V9FS_SM_PASSTHROUGH) ||
|
|
|
|
(fs_ctx->export_flags & V9FS_SM_NONE)) {
|
2011-06-01 09:05:14 +02:00
|
|
|
err = symlink(oldpath, rpath(fs_ctx, newpath, buffer));
|
2010-06-14 22:34:47 +02:00
|
|
|
if (err) {
|
2011-09-09 11:44:18 +02:00
|
|
|
goto out;
|
2010-06-14 22:34:47 +02:00
|
|
|
}
|
2011-06-01 09:05:14 +02:00
|
|
|
err = lchown(rpath(fs_ctx, newpath, buffer), credp->fc_uid,
|
2011-09-09 11:44:18 +02:00
|
|
|
credp->fc_gid);
|
2010-06-14 22:34:47 +02:00
|
|
|
if (err == -1) {
|
2010-09-02 07:39:07 +02:00
|
|
|
/*
|
|
|
|
* If we fail to change ownership and if we are
|
|
|
|
* using security model none. Ignore the error
|
|
|
|
*/
|
2011-10-13 09:51:00 +02:00
|
|
|
if ((fs_ctx->export_flags & V9FS_SEC_MASK) != V9FS_SM_NONE) {
|
2010-09-02 07:39:07 +02:00
|
|
|
serrno = errno;
|
|
|
|
goto err_end;
|
|
|
|
} else
|
|
|
|
err = 0;
|
2010-06-14 22:34:47 +02:00
|
|
|
}
|
|
|
|
}
|
2011-09-09 11:44:18 +02:00
|
|
|
goto out;
|
2010-06-14 22:34:47 +02:00
|
|
|
|
|
|
|
err_end:
|
2011-06-01 09:05:14 +02:00
|
|
|
remove(rpath(fs_ctx, newpath, buffer));
|
2010-06-14 22:34:47 +02:00
|
|
|
errno = serrno;
|
2011-09-09 11:44:18 +02:00
|
|
|
out:
|
|
|
|
v9fs_string_free(&fullname);
|
2010-06-14 22:34:47 +02:00
|
|
|
return err;
|
2010-04-29 14:14:59 +02:00
|
|
|
}
|
|
|
|
|
2011-09-09 11:44:18 +02:00
|
|
|
static int local_link(FsContext *ctx, V9fsPath *oldpath,
|
|
|
|
V9fsPath *dirpath, const char *name)
|
2010-04-29 14:14:59 +02:00
|
|
|
{
|
2011-09-09 11:44:18 +02:00
|
|
|
int ret;
|
|
|
|
V9fsString newpath;
|
2011-06-01 09:05:14 +02:00
|
|
|
char buffer[PATH_MAX], buffer1[PATH_MAX];
|
2010-04-29 14:14:59 +02:00
|
|
|
|
2011-09-09 11:44:18 +02:00
|
|
|
v9fs_string_init(&newpath);
|
|
|
|
v9fs_string_sprintf(&newpath, "%s/%s", dirpath->data, name);
|
|
|
|
|
|
|
|
ret = link(rpath(ctx, oldpath->data, buffer),
|
|
|
|
rpath(ctx, newpath.data, buffer1));
|
|
|
|
v9fs_string_free(&newpath);
|
|
|
|
return ret;
|
2010-04-29 14:14:59 +02:00
|
|
|
}
|
|
|
|
|
2011-09-09 11:44:18 +02:00
|
|
|
static int local_truncate(FsContext *ctx, V9fsPath *fs_path, off_t size)
|
2010-04-29 14:15:00 +02:00
|
|
|
{
|
2011-06-01 09:05:14 +02:00
|
|
|
char buffer[PATH_MAX];
|
2011-09-09 11:44:18 +02:00
|
|
|
char *path = fs_path->data;
|
|
|
|
|
2011-06-01 09:05:14 +02:00
|
|
|
return truncate(rpath(ctx, path, buffer), size);
|
2010-04-29 14:15:00 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
static int local_rename(FsContext *ctx, const char *oldpath,
|
|
|
|
const char *newpath)
|
|
|
|
{
|
2011-06-01 09:05:14 +02:00
|
|
|
char buffer[PATH_MAX], buffer1[PATH_MAX];
|
2010-04-29 14:15:00 +02:00
|
|
|
|
2011-06-01 09:05:14 +02:00
|
|
|
return rename(rpath(ctx, oldpath, buffer), rpath(ctx, newpath, buffer1));
|
2010-04-29 14:15:00 +02:00
|
|
|
}
|
|
|
|
|
2011-09-09 11:44:18 +02:00
|
|
|
static int local_chown(FsContext *fs_ctx, V9fsPath *fs_path, FsCred *credp)
|
2010-04-29 14:15:00 +02:00
|
|
|
{
|
2011-06-01 09:05:14 +02:00
|
|
|
char buffer[PATH_MAX];
|
2011-09-09 11:44:18 +02:00
|
|
|
char *path = fs_path->data;
|
|
|
|
|
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
|
|
|
if ((credp->fc_uid == -1 && credp->fc_gid == -1) ||
|
2011-10-25 08:40:39 +02:00
|
|
|
(fs_ctx->export_flags & V9FS_SM_PASSTHROUGH) ||
|
|
|
|
(fs_ctx->export_flags & V9FS_SM_NONE)) {
|
|
|
|
return lchown(rpath(fs_ctx, path, buffer),
|
|
|
|
credp->fc_uid, credp->fc_gid);
|
2011-10-13 09:51:00 +02:00
|
|
|
} else if (fs_ctx->export_flags & V9FS_SM_MAPPED) {
|
2011-06-01 09:05:14 +02:00
|
|
|
return local_set_xattr(rpath(fs_ctx, path, buffer), credp);
|
2010-06-14 22:34:43 +02:00
|
|
|
}
|
|
|
|
return -1;
|
2010-04-29 14:15:00 +02:00
|
|
|
}
|
|
|
|
|
2011-09-09 11:44:18 +02:00
|
|
|
static int local_utimensat(FsContext *s, V9fsPath *fs_path,
|
2010-11-24 03:38:10 +01:00
|
|
|
const struct timespec *buf)
|
2010-04-29 14:15:00 +02:00
|
|
|
{
|
2011-06-01 09:05:14 +02:00
|
|
|
char buffer[PATH_MAX];
|
2011-09-09 11:44:18 +02:00
|
|
|
char *path = fs_path->data;
|
|
|
|
|
2011-11-21 09:29:11 +01:00
|
|
|
return qemu_utimens(rpath(s, path, buffer), buf);
|
2010-04-29 14:15:00 +02:00
|
|
|
}
|
|
|
|
|
2010-04-29 14:15:01 +02:00
|
|
|
static int local_remove(FsContext *ctx, const char *path)
|
|
|
|
{
|
2011-06-01 09:05:14 +02:00
|
|
|
char buffer[PATH_MAX];
|
|
|
|
return remove(rpath(ctx, path, buffer));
|
2010-04-29 14:15:01 +02:00
|
|
|
}
|
|
|
|
|
2011-10-25 08:40:40 +02:00
|
|
|
static int local_fsync(FsContext *ctx, V9fsFidOpenState *fs, int datasync)
|
2010-04-29 14:15:00 +02:00
|
|
|
{
|
2010-10-22 19:08:45 +02:00
|
|
|
if (datasync) {
|
2011-10-25 08:40:40 +02:00
|
|
|
return qemu_fdatasync(fs->fd);
|
2010-10-22 19:08:45 +02:00
|
|
|
} else {
|
2011-10-25 08:40:40 +02:00
|
|
|
return fsync(fs->fd);
|
2010-10-22 19:08:45 +02:00
|
|
|
}
|
2010-04-29 14:15:00 +02:00
|
|
|
}
|
|
|
|
|
2011-09-09 11:44:18 +02:00
|
|
|
static int local_statfs(FsContext *s, V9fsPath *fs_path, struct statfs *stbuf)
|
2010-05-10 08:41:03 +02:00
|
|
|
{
|
2011-06-01 09:05:14 +02:00
|
|
|
char buffer[PATH_MAX];
|
2011-09-09 11:44:18 +02:00
|
|
|
char *path = fs_path->data;
|
|
|
|
|
|
|
|
return statfs(rpath(s, path, buffer), stbuf);
|
2010-05-10 08:41:03 +02:00
|
|
|
}
|
|
|
|
|
2011-09-09 11:44:18 +02:00
|
|
|
static ssize_t local_lgetxattr(FsContext *ctx, V9fsPath *fs_path,
|
2010-09-02 07:39:06 +02:00
|
|
|
const char *name, void *value, size_t size)
|
|
|
|
{
|
2011-09-09 11:44:18 +02:00
|
|
|
char *path = fs_path->data;
|
|
|
|
|
2010-10-18 11:58:16 +02:00
|
|
|
return v9fs_get_xattr(ctx, path, name, value, size);
|
2010-09-02 07:39:06 +02:00
|
|
|
}
|
|
|
|
|
2011-09-09 11:44:18 +02:00
|
|
|
static ssize_t local_llistxattr(FsContext *ctx, V9fsPath *fs_path,
|
2010-09-02 07:39:06 +02:00
|
|
|
void *value, size_t size)
|
|
|
|
{
|
2011-09-09 11:44:18 +02:00
|
|
|
char *path = fs_path->data;
|
|
|
|
|
2010-10-18 11:58:16 +02:00
|
|
|
return v9fs_list_xattr(ctx, path, value, size);
|
2010-09-02 07:39:06 +02:00
|
|
|
}
|
|
|
|
|
2011-09-09 11:44:18 +02:00
|
|
|
static int local_lsetxattr(FsContext *ctx, V9fsPath *fs_path, const char *name,
|
2010-09-02 07:39:07 +02:00
|
|
|
void *value, size_t size, int flags)
|
|
|
|
{
|
2011-09-09 11:44:18 +02:00
|
|
|
char *path = fs_path->data;
|
|
|
|
|
2010-10-18 11:58:16 +02:00
|
|
|
return v9fs_set_xattr(ctx, path, name, value, size, flags);
|
2010-09-02 07:39:07 +02:00
|
|
|
}
|
|
|
|
|
2011-09-09 11:44:18 +02:00
|
|
|
static int local_lremovexattr(FsContext *ctx, V9fsPath *fs_path,
|
|
|
|
const char *name)
|
2010-08-26 07:45:23 +02:00
|
|
|
{
|
2011-09-09 11:44:18 +02:00
|
|
|
char *path = fs_path->data;
|
|
|
|
|
2010-10-18 11:58:16 +02:00
|
|
|
return v9fs_remove_xattr(ctx, path, name);
|
2010-08-26 07:45:23 +02:00
|
|
|
}
|
|
|
|
|
2011-09-09 11:44:18 +02:00
|
|
|
static int local_name_to_path(FsContext *ctx, V9fsPath *dir_path,
|
|
|
|
const char *name, V9fsPath *target)
|
|
|
|
{
|
|
|
|
if (dir_path) {
|
|
|
|
v9fs_string_sprintf((V9fsString *)target, "%s/%s",
|
|
|
|
dir_path->data, name);
|
|
|
|
} else {
|
|
|
|
v9fs_string_sprintf((V9fsString *)target, "%s", name);
|
|
|
|
}
|
|
|
|
/* Bump the size for including terminating NULL */
|
|
|
|
target->size++;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int local_renameat(FsContext *ctx, V9fsPath *olddir,
|
|
|
|
const char *old_name, V9fsPath *newdir,
|
|
|
|
const char *new_name)
|
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
V9fsString old_full_name, new_full_name;
|
|
|
|
|
|
|
|
v9fs_string_init(&old_full_name);
|
|
|
|
v9fs_string_init(&new_full_name);
|
|
|
|
|
|
|
|
v9fs_string_sprintf(&old_full_name, "%s/%s", olddir->data, old_name);
|
|
|
|
v9fs_string_sprintf(&new_full_name, "%s/%s", newdir->data, new_name);
|
|
|
|
|
|
|
|
ret = local_rename(ctx, old_full_name.data, new_full_name.data);
|
|
|
|
v9fs_string_free(&old_full_name);
|
|
|
|
v9fs_string_free(&new_full_name);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int local_unlinkat(FsContext *ctx, V9fsPath *dir,
|
|
|
|
const char *name, int flags)
|
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
V9fsString fullname;
|
|
|
|
char buffer[PATH_MAX];
|
|
|
|
v9fs_string_init(&fullname);
|
|
|
|
|
|
|
|
v9fs_string_sprintf(&fullname, "%s/%s", dir->data, name);
|
|
|
|
ret = remove(rpath(ctx, fullname.data, buffer));
|
|
|
|
v9fs_string_free(&fullname);
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
2010-08-26 07:45:23 +02:00
|
|
|
|
2011-10-12 15:41:25 +02:00
|
|
|
static int local_ioc_getversion(FsContext *ctx, V9fsPath *path,
|
|
|
|
mode_t st_mode, uint64_t *st_gen)
|
|
|
|
{
|
2011-10-25 08:40:40 +02:00
|
|
|
int err;
|
2011-11-21 09:29:11 +01:00
|
|
|
#ifdef FS_IOC_GETVERSION
|
2011-10-25 08:40:40 +02:00
|
|
|
V9fsFidOpenState fid_open;
|
|
|
|
|
2011-10-12 15:41:25 +02: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)) {
|
|
|
|
return 0;
|
|
|
|
}
|
2011-10-25 08:40:40 +02:00
|
|
|
err = local_open(ctx, path, O_RDONLY, &fid_open);
|
|
|
|
if (err < 0) {
|
|
|
|
return err;
|
2011-10-12 15:41:25 +02:00
|
|
|
}
|
2011-10-25 08:40:40 +02:00
|
|
|
err = ioctl(fid_open.fd, FS_IOC_GETVERSION, st_gen);
|
|
|
|
local_close(ctx, &fid_open);
|
2011-11-21 09:29:11 +01:00
|
|
|
#else
|
|
|
|
err = -ENOTTY;
|
|
|
|
#endif
|
2011-10-12 15:41:25 +02:00
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
2011-08-02 08:05:54 +02:00
|
|
|
static int local_init(FsContext *ctx)
|
|
|
|
{
|
2011-11-23 07:16:27 +01:00
|
|
|
int err = 0;
|
2011-10-12 15:41:25 +02:00
|
|
|
struct statfs stbuf;
|
|
|
|
|
2011-10-12 17:29:18 +02:00
|
|
|
ctx->export_flags |= V9FS_PATHNAME_FSCONTEXT;
|
2011-11-23 07:16:27 +01:00
|
|
|
#ifdef FS_IOC_GETVERSION
|
|
|
|
/*
|
|
|
|
* use ioc_getversion only if the iocl is definied
|
|
|
|
*/
|
2011-10-12 15:41:25 +02:00
|
|
|
err = statfs(ctx->fs_root, &stbuf);
|
|
|
|
if (!err) {
|
|
|
|
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 = local_ioc_getversion;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
2011-11-23 07:16:27 +01:00
|
|
|
#endif
|
2011-10-12 15:41:25 +02:00
|
|
|
return err;
|
2011-08-02 08:05:54 +02:00
|
|
|
}
|
|
|
|
|
2010-04-29 14:14:44 +02:00
|
|
|
FileOperations local_ops = {
|
2011-08-02 08:05:54 +02:00
|
|
|
.init = local_init,
|
2010-04-29 14:14:47 +02:00
|
|
|
.lstat = local_lstat,
|
|
|
|
.readlink = local_readlink,
|
|
|
|
.close = local_close,
|
|
|
|
.closedir = local_closedir,
|
2010-04-29 14:14:55 +02:00
|
|
|
.open = local_open,
|
|
|
|
.opendir = local_opendir,
|
2010-04-29 14:14:56 +02:00
|
|
|
.rewinddir = local_rewinddir,
|
|
|
|
.telldir = local_telldir,
|
2011-05-18 13:53:00 +02:00
|
|
|
.readdir_r = local_readdir_r,
|
2010-04-29 14:14:56 +02:00
|
|
|
.seekdir = local_seekdir,
|
2010-10-08 08:00:16 +02:00
|
|
|
.preadv = local_preadv,
|
|
|
|
.pwritev = local_pwritev,
|
2010-04-29 14:14:59 +02:00
|
|
|
.chmod = local_chmod,
|
|
|
|
.mknod = local_mknod,
|
|
|
|
.mkdir = local_mkdir,
|
|
|
|
.fstat = local_fstat,
|
|
|
|
.open2 = local_open2,
|
|
|
|
.symlink = local_symlink,
|
|
|
|
.link = local_link,
|
2010-04-29 14:15:00 +02:00
|
|
|
.truncate = local_truncate,
|
|
|
|
.rename = local_rename,
|
|
|
|
.chown = local_chown,
|
2010-06-09 15:44:38 +02:00
|
|
|
.utimensat = local_utimensat,
|
2010-04-29 14:15:01 +02:00
|
|
|
.remove = local_remove,
|
2010-04-29 14:15:00 +02:00
|
|
|
.fsync = local_fsync,
|
2010-05-10 08:41:03 +02:00
|
|
|
.statfs = local_statfs,
|
2010-09-02 07:39:06 +02:00
|
|
|
.lgetxattr = local_lgetxattr,
|
|
|
|
.llistxattr = local_llistxattr,
|
2010-09-02 07:39:07 +02:00
|
|
|
.lsetxattr = local_lsetxattr,
|
2010-08-26 07:45:23 +02:00
|
|
|
.lremovexattr = local_lremovexattr,
|
2011-09-09 11:44:18 +02:00
|
|
|
.name_to_path = local_name_to_path,
|
|
|
|
.renameat = local_renameat,
|
|
|
|
.unlinkat = local_unlinkat,
|
2010-04-29 14:14:44 +02:00
|
|
|
};
|