blob: 513164eedc5ec7cbc0e1a2e7e4f40906be3dc71c [file] [log] [blame]
#include "kvm/virtio-pci-dev.h"
#include "kvm/ioport.h"
#include "kvm/util.h"
#include "kvm/threadpool.h"
#include "kvm/irq.h"
#include "kvm/virtio-9p.h"
#include "kvm/guest_compat.h"
#include "kvm/builtin-setup.h"
#include <stdio.h>
#include <stdlib.h>
#include <fcntl.h>
#include <sys/stat.h>
#include <sys/sysmacros.h>
#include <unistd.h>
#include <string.h>
#include <errno.h>
#include <sys/vfs.h>
#include <linux/virtio_ring.h>
#include <linux/virtio_9p.h>
#include <linux/9p.h>
static LIST_HEAD(devs);
static int compat_id = -1;
static int insert_new_fid(struct p9_dev *dev, struct p9_fid *fid);
static struct p9_fid *find_or_create_fid(struct p9_dev *dev, u32 fid)
{
struct rb_node *node = dev->fids.rb_node;
struct p9_fid *pfid = NULL;
size_t len;
while (node) {
struct p9_fid *cur = rb_entry(node, struct p9_fid, node);
if (fid < cur->fid) {
node = node->rb_left;
} else if (fid > cur->fid) {
node = node->rb_right;
} else {
return cur;
}
}
pfid = calloc(sizeof(*pfid), 1);
if (!pfid)
return NULL;
len = strlen(dev->root_dir);
if (len >= sizeof(pfid->abs_path)) {
free(pfid);
return NULL;
}
pfid->fid = fid;
strcpy(pfid->abs_path, dev->root_dir);
pfid->path = pfid->abs_path + strlen(pfid->abs_path);
insert_new_fid(dev, pfid);
return pfid;
}
static int insert_new_fid(struct p9_dev *dev, struct p9_fid *fid)
{
struct rb_node **node = &(dev->fids.rb_node), *parent = NULL;
while (*node) {
int result = fid->fid - rb_entry(*node, struct p9_fid, node)->fid;
parent = *node;
if (result < 0)
node = &((*node)->rb_left);
else if (result > 0)
node = &((*node)->rb_right);
else
return -EEXIST;
}
rb_link_node(&fid->node, parent, node);
rb_insert_color(&fid->node, &dev->fids);
return 0;
}
static struct p9_fid *get_fid(struct p9_dev *p9dev, int fid)
{
struct p9_fid *new;
new = find_or_create_fid(p9dev, fid);
return new;
}
static void stat2qid(struct stat *st, struct p9_qid *qid)
{
*qid = (struct p9_qid) {
.path = st->st_ino,
.version = st->st_mtime,
};
if (S_ISDIR(st->st_mode))
qid->type |= P9_QTDIR;
}
static void close_fid(struct p9_dev *p9dev, u32 fid)
{
struct p9_fid *pfid = get_fid(p9dev, fid);
if (pfid->fd > 0)
close(pfid->fd);
if (pfid->dir)
closedir(pfid->dir);
rb_erase(&pfid->node, &p9dev->fids);
free(pfid);
}
static void virtio_p9_set_reply_header(struct p9_pdu *pdu, u32 size)
{
u8 cmd;
u16 tag;
pdu->read_offset = sizeof(u32);
virtio_p9_pdu_readf(pdu, "bw", &cmd, &tag);
pdu->write_offset = 0;
/* cmd + 1 is the reply message */
virtio_p9_pdu_writef(pdu, "dbw", size, cmd + 1, tag);
}
static u16 virtio_p9_update_iov_cnt(struct iovec iov[], u32 count, int iov_cnt)
{
int i;
u32 total = 0;
for (i = 0; (i < iov_cnt) && (total < count); i++) {
if (total + iov[i].iov_len > count) {
/* we don't need this iov fully */
iov[i].iov_len -= ((total + iov[i].iov_len) - count);
i++;
break;
}
total += iov[i].iov_len;
}
return i;
}
static void virtio_p9_error_reply(struct p9_dev *p9dev,
struct p9_pdu *pdu, int err, u32 *outlen)
{
u16 tag;
/* EMFILE at server implies ENFILE for the VM */
if (err == EMFILE)
err = ENFILE;
pdu->write_offset = VIRTIO_9P_HDR_LEN;
virtio_p9_pdu_writef(pdu, "d", err);
*outlen = pdu->write_offset;
/* read the tag from input */
pdu->read_offset = sizeof(u32) + sizeof(u8);
virtio_p9_pdu_readf(pdu, "w", &tag);
/* Update the header */
pdu->write_offset = 0;
virtio_p9_pdu_writef(pdu, "dbw", *outlen, P9_RLERROR, tag);
}
static void virtio_p9_version(struct p9_dev *p9dev,
struct p9_pdu *pdu, u32 *outlen)
{
u32 msize;
char *version;
virtio_p9_pdu_readf(pdu, "ds", &msize, &version);
/*
* reply with the same msize the client sent us
* Error out if the request is not for 9P2000.L
*/
if (!strcmp(version, VIRTIO_9P_VERSION_DOTL))
virtio_p9_pdu_writef(pdu, "ds", msize, version);
else
virtio_p9_pdu_writef(pdu, "ds", msize, "unknown");
*outlen = pdu->write_offset;
virtio_p9_set_reply_header(pdu, *outlen);
free(version);
return;
}
static void virtio_p9_clunk(struct p9_dev *p9dev,
struct p9_pdu *pdu, u32 *outlen)
{
u32 fid;
virtio_p9_pdu_readf(pdu, "d", &fid);
close_fid(p9dev, fid);
*outlen = pdu->write_offset;
virtio_p9_set_reply_header(pdu, *outlen);
return;
}
/*
* FIXME!! Need to map to protocol independent value. Upstream
* 9p also have the same BUG
*/
static int virtio_p9_openflags(int flags)
{
flags &= ~(O_NOCTTY | O_ASYNC | O_CREAT | O_DIRECT);
flags |= O_NOFOLLOW;
return flags;
}
static bool is_dir(struct p9_fid *fid)
{
struct stat st;
stat(fid->abs_path, &st);
return S_ISDIR(st.st_mode);
}
/* path is always absolute */
static bool path_is_illegal(const char *path)
{
size_t len;
if (strstr(path, "/../") != NULL)
return true;
len = strlen(path);
if (len >= 3 && strcmp(path + len - 3, "/..") == 0)
return true;
return false;
}
static int get_full_path_helper(char *full_path, size_t size,
const char *dirname, const char *name)
{
int ret;
ret = snprintf(full_path, size, "%s/%s", dirname, name);
if (ret >= (int)size) {
errno = ENAMETOOLONG;
return -1;
}
if (path_is_illegal(full_path)) {
errno = EACCES;
return -1;
}
return 0;
}
static int get_full_path(char *full_path, size_t size, struct p9_fid *fid,
const char *name)
{
return get_full_path_helper(full_path, size, fid->abs_path, name);
}
static int stat_rel(struct p9_dev *p9dev, const char *path, struct stat *st)
{
char full_path[PATH_MAX];
if (get_full_path_helper(full_path, sizeof(full_path), p9dev->root_dir, path) != 0)
return -1;
if (lstat(full_path, st) != 0)
return -1;
return 0;
}
static void virtio_p9_open(struct p9_dev *p9dev,
struct p9_pdu *pdu, u32 *outlen)
{
u32 fid, flags;
struct stat st;
struct p9_qid qid;
struct p9_fid *new_fid;
virtio_p9_pdu_readf(pdu, "dd", &fid, &flags);
new_fid = get_fid(p9dev, fid);
if (lstat(new_fid->abs_path, &st) < 0)
goto err_out;
stat2qid(&st, &qid);
if (is_dir(new_fid)) {
new_fid->dir = opendir(new_fid->abs_path);
if (!new_fid->dir)
goto err_out;
} else {
new_fid->fd = open(new_fid->abs_path,
virtio_p9_openflags(flags));
if (new_fid->fd < 0)
goto err_out;
}
/* FIXME!! need ot send proper iounit */
virtio_p9_pdu_writef(pdu, "Qd", &qid, 0);
*outlen = pdu->write_offset;
virtio_p9_set_reply_header(pdu, *outlen);
return;
err_out:
virtio_p9_error_reply(p9dev, pdu, errno, outlen);
return;
}
static void virtio_p9_create(struct p9_dev *p9dev,
struct p9_pdu *pdu, u32 *outlen)
{
int fd, ret;
char *name;
size_t size;
struct stat st;
struct p9_qid qid;
struct p9_fid *dfid;
char full_path[PATH_MAX];
char *tmp_path;
u32 dfid_val, flags, mode, gid;
virtio_p9_pdu_readf(pdu, "dsddd", &dfid_val,
&name, &flags, &mode, &gid);
dfid = get_fid(p9dev, dfid_val);
if (get_full_path(full_path, sizeof(full_path), dfid, name) != 0)
goto err_out;
size = sizeof(dfid->abs_path) - (dfid->path - dfid->abs_path);
tmp_path = strdup(dfid->path);
if (!tmp_path)
goto err_out;
ret = snprintf(dfid->path, size, "%s/%s", tmp_path, name);
free(tmp_path);
if (ret >= (int)size) {
errno = ENAMETOOLONG;
if (size > 0)
dfid->path[size] = '\x00';
goto err_out;
}
flags = virtio_p9_openflags(flags);
fd = open(full_path, flags | O_CREAT, mode);
if (fd < 0)
goto err_out;
dfid->fd = fd;
if (lstat(full_path, &st) < 0)
goto err_out;
ret = chmod(full_path, mode & 0777);
if (ret < 0)
goto err_out;
stat2qid(&st, &qid);
virtio_p9_pdu_writef(pdu, "Qd", &qid, 0);
*outlen = pdu->write_offset;
virtio_p9_set_reply_header(pdu, *outlen);
free(name);
return;
err_out:
free(name);
virtio_p9_error_reply(p9dev, pdu, errno, outlen);
return;
}
static void virtio_p9_mkdir(struct p9_dev *p9dev,
struct p9_pdu *pdu, u32 *outlen)
{
int ret;
char *name;
struct stat st;
struct p9_qid qid;
struct p9_fid *dfid;
char full_path[PATH_MAX];
u32 dfid_val, mode, gid;
virtio_p9_pdu_readf(pdu, "dsdd", &dfid_val,
&name, &mode, &gid);
dfid = get_fid(p9dev, dfid_val);
if (get_full_path(full_path, sizeof(full_path), dfid, name) != 0)
goto err_out;
ret = mkdir(full_path, mode);
if (ret < 0)
goto err_out;
if (lstat(full_path, &st) < 0)
goto err_out;
ret = chmod(full_path, mode & 0777);
if (ret < 0)
goto err_out;
stat2qid(&st, &qid);
virtio_p9_pdu_writef(pdu, "Qd", &qid, 0);
*outlen = pdu->write_offset;
virtio_p9_set_reply_header(pdu, *outlen);
free(name);
return;
err_out:
free(name);
virtio_p9_error_reply(p9dev, pdu, errno, outlen);
return;
}
static int join_path(struct p9_fid *fid, const char *name)
{
size_t len, size;
size = sizeof(fid->abs_path) - (fid->path - fid->abs_path);
len = strlen(name);
if (len >= size)
return -1;
strncpy(fid->path, name, size);
return 0;
}
static void virtio_p9_walk(struct p9_dev *p9dev,
struct p9_pdu *pdu, u32 *outlen)
{
u8 i;
u16 nwqid;
u16 nwname;
struct p9_qid wqid;
struct p9_fid *new_fid, *old_fid;
u32 fid_val, newfid_val;
virtio_p9_pdu_readf(pdu, "ddw", &fid_val, &newfid_val, &nwname);
new_fid = get_fid(p9dev, newfid_val);
nwqid = 0;
if (nwname) {
struct p9_fid *fid = get_fid(p9dev, fid_val);
if (join_path(new_fid, fid->path) != 0) {
errno = ENAMETOOLONG;
goto err_out;
}
/* skip the space for count */
pdu->write_offset += sizeof(u16);
for (i = 0; i < nwname; i++) {
struct stat st;
char tmp[PATH_MAX] = {0};
char *str;
int ret;
virtio_p9_pdu_readf(pdu, "s", &str);
/* Format the new path we're 'walk'ing into */
ret = snprintf(tmp, sizeof(tmp), "%s/%s", new_fid->path, str);
if (ret >= (int)sizeof(tmp)) {
errno = ENAMETOOLONG;
goto err_out;
}
free(str);
if (stat_rel(p9dev, tmp, &st) != 0)
goto err_out;
stat2qid(&st, &wqid);
if (join_path(new_fid, tmp) != 0) {
errno = ENAMETOOLONG;
goto err_out;
}
new_fid->uid = fid->uid;
nwqid++;
virtio_p9_pdu_writef(pdu, "Q", &wqid);
}
} else {
/*
* update write_offset so our outlen get correct value
*/
pdu->write_offset += sizeof(u16);
old_fid = get_fid(p9dev, fid_val);
if (join_path(new_fid, old_fid->path) != 0) {
errno = ENAMETOOLONG;
goto err_out;
}
new_fid->uid = old_fid->uid;
}
*outlen = pdu->write_offset;
pdu->write_offset = VIRTIO_9P_HDR_LEN;
virtio_p9_pdu_writef(pdu, "d", nwqid);
virtio_p9_set_reply_header(pdu, *outlen);
return;
err_out:
virtio_p9_error_reply(p9dev, pdu, errno, outlen);
return;
}
static void virtio_p9_attach(struct p9_dev *p9dev,
struct p9_pdu *pdu, u32 *outlen)
{
char *uname;
char *aname;
struct stat st;
struct p9_qid qid;
struct p9_fid *fid;
u32 fid_val, afid, uid;
virtio_p9_pdu_readf(pdu, "ddssd", &fid_val, &afid,
&uname, &aname, &uid);
free(uname);
free(aname);
if (lstat(p9dev->root_dir, &st) < 0)
goto err_out;
stat2qid(&st, &qid);
fid = get_fid(p9dev, fid_val);
fid->uid = uid;
if (join_path(fid, "/") != 0) {
errno = ENAMETOOLONG;
goto err_out;
}
virtio_p9_pdu_writef(pdu, "Q", &qid);
*outlen = pdu->write_offset;
virtio_p9_set_reply_header(pdu, *outlen);
return;
err_out:
virtio_p9_error_reply(p9dev, pdu, errno, outlen);
return;
}
static void virtio_p9_fill_stat(struct p9_dev *p9dev,
struct stat *st, struct p9_stat_dotl *statl)
{
memset(statl, 0, sizeof(*statl));
statl->st_mode = st->st_mode;
statl->st_nlink = st->st_nlink;
statl->st_uid = KUIDT_INIT(st->st_uid);
statl->st_gid = KGIDT_INIT(st->st_gid);
statl->st_rdev = st->st_rdev;
statl->st_size = st->st_size;
statl->st_blksize = st->st_blksize;
statl->st_blocks = st->st_blocks;
statl->st_atime_sec = st->st_atime;
statl->st_atime_nsec = st->st_atim.tv_nsec;
statl->st_mtime_sec = st->st_mtime;
statl->st_mtime_nsec = st->st_mtim.tv_nsec;
statl->st_ctime_sec = st->st_ctime;
statl->st_ctime_nsec = st->st_ctim.tv_nsec;
/* Currently we only support BASIC fields in stat */
statl->st_result_mask = P9_STATS_BASIC;
stat2qid(st, &statl->qid);
}
static void virtio_p9_read(struct p9_dev *p9dev,
struct p9_pdu *pdu, u32 *outlen)
{
u64 offset;
u32 fid_val;
u16 iov_cnt;
void *iov_base;
size_t iov_len;
u32 count, rcount;
struct p9_fid *fid;
rcount = 0;
virtio_p9_pdu_readf(pdu, "dqd", &fid_val, &offset, &count);
fid = get_fid(p9dev, fid_val);
iov_base = pdu->in_iov[0].iov_base;
iov_len = pdu->in_iov[0].iov_len;
iov_cnt = pdu->in_iov_cnt;
pdu->in_iov[0].iov_base += VIRTIO_9P_HDR_LEN + sizeof(u32);
pdu->in_iov[0].iov_len -= VIRTIO_9P_HDR_LEN + sizeof(u32);
pdu->in_iov_cnt = virtio_p9_update_iov_cnt(pdu->in_iov,
count,
pdu->in_iov_cnt);
rcount = preadv(fid->fd, pdu->in_iov,
pdu->in_iov_cnt, offset);
if (rcount > count)
rcount = count;
/*
* Update the iov_base back, so that rest of
* pdu_writef works correctly.
*/
pdu->in_iov[0].iov_base = iov_base;
pdu->in_iov[0].iov_len = iov_len;
pdu->in_iov_cnt = iov_cnt;
pdu->write_offset = VIRTIO_9P_HDR_LEN;
virtio_p9_pdu_writef(pdu, "d", rcount);
*outlen = pdu->write_offset + rcount;
virtio_p9_set_reply_header(pdu, *outlen);
return;
}
static int virtio_p9_dentry_size(struct dirent *dent)
{
/*
* Size of each dirent:
* qid(13) + offset(8) + type(1) + name_len(2) + name
*/
return 24 + strlen(dent->d_name);
}
static void virtio_p9_readdir(struct p9_dev *p9dev,
struct p9_pdu *pdu, u32 *outlen)
{
u32 fid_val;
u32 count, rcount;
struct stat st;
struct p9_fid *fid;
struct dirent *dent;
u64 offset, old_offset;
rcount = 0;
virtio_p9_pdu_readf(pdu, "dqd", &fid_val, &offset, &count);
fid = get_fid(p9dev, fid_val);
if (!is_dir(fid)) {
errno = EINVAL;
goto err_out;
}
/* Move the offset specified */
seekdir(fid->dir, offset);
old_offset = offset;
/* If reading a dir, fill the buffer with p9_stat entries */
dent = readdir(fid->dir);
/* Skip the space for writing count */
pdu->write_offset += sizeof(u32);
while (dent) {
u32 read;
struct p9_qid qid;
if ((rcount + virtio_p9_dentry_size(dent)) > count) {
/* seek to the previous offset and return */
seekdir(fid->dir, old_offset);
break;
}
old_offset = dent->d_off;
if (stat_rel(p9dev, dent->d_name, &st) != 0)
memset(&st, -1, sizeof(st));
stat2qid(&st, &qid);
read = pdu->write_offset;
virtio_p9_pdu_writef(pdu, "Qqbs", &qid, dent->d_off,
dent->d_type, dent->d_name);
rcount += pdu->write_offset - read;
dent = readdir(fid->dir);
}
pdu->write_offset = VIRTIO_9P_HDR_LEN;
virtio_p9_pdu_writef(pdu, "d", rcount);
*outlen = pdu->write_offset + rcount;
virtio_p9_set_reply_header(pdu, *outlen);
return;
err_out:
virtio_p9_error_reply(p9dev, pdu, errno, outlen);
return;
}
static void virtio_p9_getattr(struct p9_dev *p9dev,
struct p9_pdu *pdu, u32 *outlen)
{
u32 fid_val;
struct stat st;
u64 request_mask;
struct p9_fid *fid;
struct p9_stat_dotl statl;
virtio_p9_pdu_readf(pdu, "dq", &fid_val, &request_mask);
fid = get_fid(p9dev, fid_val);
if (lstat(fid->abs_path, &st) < 0)
goto err_out;
virtio_p9_fill_stat(p9dev, &st, &statl);
virtio_p9_pdu_writef(pdu, "A", &statl);
*outlen = pdu->write_offset;
virtio_p9_set_reply_header(pdu, *outlen);
return;
err_out:
virtio_p9_error_reply(p9dev, pdu, errno, outlen);
return;
}
/* FIXME!! from linux/fs.h */
/*
* Attribute flags. These should be or-ed together to figure out what
* has been changed!
*/
#define ATTR_MODE (1 << 0)
#define ATTR_UID (1 << 1)
#define ATTR_GID (1 << 2)
#define ATTR_SIZE (1 << 3)
#define ATTR_ATIME (1 << 4)
#define ATTR_MTIME (1 << 5)
#define ATTR_CTIME (1 << 6)
#define ATTR_ATIME_SET (1 << 7)
#define ATTR_MTIME_SET (1 << 8)
#define ATTR_FORCE (1 << 9) /* Not a change, but a change it */
#define ATTR_ATTR_FLAG (1 << 10)
#define ATTR_KILL_SUID (1 << 11)
#define ATTR_KILL_SGID (1 << 12)
#define ATTR_FILE (1 << 13)
#define ATTR_KILL_PRIV (1 << 14)
#define ATTR_OPEN (1 << 15) /* Truncating from open(O_TRUNC) */
#define ATTR_TIMES_SET (1 << 16)
#define ATTR_MASK 127
static void virtio_p9_setattr(struct p9_dev *p9dev,
struct p9_pdu *pdu, u32 *outlen)
{
int ret = 0;
u32 fid_val;
struct p9_fid *fid;
struct p9_iattr_dotl p9attr;
virtio_p9_pdu_readf(pdu, "dI", &fid_val, &p9attr);
fid = get_fid(p9dev, fid_val);
if (p9attr.valid & ATTR_MODE) {
ret = chmod(fid->abs_path, p9attr.mode);
if (ret < 0)
goto err_out;
}
if (p9attr.valid & (ATTR_ATIME | ATTR_MTIME)) {
struct timespec times[2];
if (p9attr.valid & ATTR_ATIME) {
if (p9attr.valid & ATTR_ATIME_SET) {
times[0].tv_sec = p9attr.atime_sec;
times[0].tv_nsec = p9attr.atime_nsec;
} else {
times[0].tv_nsec = UTIME_NOW;
}
} else {
times[0].tv_nsec = UTIME_OMIT;
}
if (p9attr.valid & ATTR_MTIME) {
if (p9attr.valid & ATTR_MTIME_SET) {
times[1].tv_sec = p9attr.mtime_sec;
times[1].tv_nsec = p9attr.mtime_nsec;
} else {
times[1].tv_nsec = UTIME_NOW;
}
} else
times[1].tv_nsec = UTIME_OMIT;
ret = utimensat(-1, fid->abs_path, times, AT_SYMLINK_NOFOLLOW);
if (ret < 0)
goto err_out;
}
/*
* If the only valid entry in iattr is ctime we can call
* chown(-1,-1) to update the ctime of the file
*/
if ((p9attr.valid & (ATTR_UID | ATTR_GID)) ||
((p9attr.valid & ATTR_CTIME)
&& !((p9attr.valid & ATTR_MASK) & ~ATTR_CTIME))) {
if (!(p9attr.valid & ATTR_UID))
p9attr.uid = KUIDT_INIT(-1);
if (!(p9attr.valid & ATTR_GID))
p9attr.gid = KGIDT_INIT(-1);
ret = lchown(fid->abs_path, __kuid_val(p9attr.uid),
__kgid_val(p9attr.gid));
if (ret < 0)
goto err_out;
}
if (p9attr.valid & (ATTR_SIZE)) {
ret = truncate(fid->abs_path, p9attr.size);
if (ret < 0)
goto err_out;
}
*outlen = VIRTIO_9P_HDR_LEN;
virtio_p9_set_reply_header(pdu, *outlen);
return;
err_out:
virtio_p9_error_reply(p9dev, pdu, errno, outlen);
return;
}
static void virtio_p9_write(struct p9_dev *p9dev,
struct p9_pdu *pdu, u32 *outlen)
{
u64 offset;
u32 fid_val;
u32 count;
ssize_t res;
u16 iov_cnt;
void *iov_base;
size_t iov_len;
struct p9_fid *fid;
/* u32 fid + u64 offset + u32 count */
int twrite_size = sizeof(u32) + sizeof(u64) + sizeof(u32);
virtio_p9_pdu_readf(pdu, "dqd", &fid_val, &offset, &count);
fid = get_fid(p9dev, fid_val);
iov_base = pdu->out_iov[0].iov_base;
iov_len = pdu->out_iov[0].iov_len;
iov_cnt = pdu->out_iov_cnt;
/* Adjust the iovec to skip the header and meta data */
pdu->out_iov[0].iov_base += (sizeof(struct p9_msg) + twrite_size);
pdu->out_iov[0].iov_len -= (sizeof(struct p9_msg) + twrite_size);
pdu->out_iov_cnt = virtio_p9_update_iov_cnt(pdu->out_iov, count,
pdu->out_iov_cnt);
res = pwritev(fid->fd, pdu->out_iov, pdu->out_iov_cnt, offset);
/*
* Update the iov_base back, so that rest of
* pdu_readf works correctly.
*/
pdu->out_iov[0].iov_base = iov_base;
pdu->out_iov[0].iov_len = iov_len;
pdu->out_iov_cnt = iov_cnt;
if (res < 0)
goto err_out;
virtio_p9_pdu_writef(pdu, "d", res);
*outlen = pdu->write_offset;
virtio_p9_set_reply_header(pdu, *outlen);
return;
err_out:
virtio_p9_error_reply(p9dev, pdu, errno, outlen);
return;
}
static void virtio_p9_remove(struct p9_dev *p9dev,
struct p9_pdu *pdu, u32 *outlen)
{
int ret;
u32 fid_val;
struct p9_fid *fid;
virtio_p9_pdu_readf(pdu, "d", &fid_val);
fid = get_fid(p9dev, fid_val);
ret = remove(fid->abs_path);
if (ret < 0)
goto err_out;
*outlen = pdu->write_offset;
virtio_p9_set_reply_header(pdu, *outlen);
return;
err_out:
virtio_p9_error_reply(p9dev, pdu, errno, outlen);
return;
}
static void virtio_p9_rename(struct p9_dev *p9dev,
struct p9_pdu *pdu, u32 *outlen)
{
int ret;
u32 fid_val, new_fid_val;
struct p9_fid *fid, *new_fid;
char full_path[PATH_MAX], *new_name;
virtio_p9_pdu_readf(pdu, "dds", &fid_val, &new_fid_val, &new_name);
fid = get_fid(p9dev, fid_val);
new_fid = get_fid(p9dev, new_fid_val);
if (get_full_path(full_path, sizeof(full_path), new_fid, new_name) != 0)
goto err_out;
ret = rename(fid->abs_path, full_path);
if (ret < 0)
goto err_out;
*outlen = pdu->write_offset;
virtio_p9_set_reply_header(pdu, *outlen);
return;
err_out:
virtio_p9_error_reply(p9dev, pdu, errno, outlen);
return;
}
static void virtio_p9_readlink(struct p9_dev *p9dev,
struct p9_pdu *pdu, u32 *outlen)
{
int ret;
u32 fid_val;
struct p9_fid *fid;
char target_path[PATH_MAX];
virtio_p9_pdu_readf(pdu, "d", &fid_val);
fid = get_fid(p9dev, fid_val);
memset(target_path, 0, PATH_MAX);
ret = readlink(fid->abs_path, target_path, PATH_MAX - 1);
if (ret < 0)
goto err_out;
virtio_p9_pdu_writef(pdu, "s", target_path);
*outlen = pdu->write_offset;
virtio_p9_set_reply_header(pdu, *outlen);
return;
err_out:
virtio_p9_error_reply(p9dev, pdu, errno, outlen);
return;
}
static void virtio_p9_statfs(struct p9_dev *p9dev,
struct p9_pdu *pdu, u32 *outlen)
{
int ret;
u64 fsid;
u32 fid_val;
struct p9_fid *fid;
struct statfs stat_buf;
virtio_p9_pdu_readf(pdu, "d", &fid_val);
fid = get_fid(p9dev, fid_val);
ret = statfs(fid->abs_path, &stat_buf);
if (ret < 0)
goto err_out;
/* FIXME!! f_blocks needs update based on client msize */
fsid = (unsigned int) stat_buf.f_fsid.__val[0] |
(unsigned long long)stat_buf.f_fsid.__val[1] << 32;
virtio_p9_pdu_writef(pdu, "ddqqqqqqd", stat_buf.f_type,
stat_buf.f_bsize, stat_buf.f_blocks,
stat_buf.f_bfree, stat_buf.f_bavail,
stat_buf.f_files, stat_buf.f_ffree,
fsid, stat_buf.f_namelen);
*outlen = pdu->write_offset;
virtio_p9_set_reply_header(pdu, *outlen);
return;
err_out:
virtio_p9_error_reply(p9dev, pdu, errno, outlen);
return;
}
static void virtio_p9_mknod(struct p9_dev *p9dev,
struct p9_pdu *pdu, u32 *outlen)
{
int ret;
char *name;
struct stat st;
struct p9_fid *dfid;
struct p9_qid qid;
char full_path[PATH_MAX];
u32 fid_val, mode, major, minor, gid;
virtio_p9_pdu_readf(pdu, "dsdddd", &fid_val, &name, &mode,
&major, &minor, &gid);
dfid = get_fid(p9dev, fid_val);
if (get_full_path(full_path, sizeof(full_path), dfid, name) != 0)
goto err_out;
ret = mknod(full_path, mode, makedev(major, minor));
if (ret < 0)
goto err_out;
if (lstat(full_path, &st) < 0)
goto err_out;
ret = chmod(full_path, mode & 0777);
if (ret < 0)
goto err_out;
stat2qid(&st, &qid);
virtio_p9_pdu_writef(pdu, "Q", &qid);
free(name);
*outlen = pdu->write_offset;
virtio_p9_set_reply_header(pdu, *outlen);
return;
err_out:
free(name);
virtio_p9_error_reply(p9dev, pdu, errno, outlen);
return;
}
static void virtio_p9_fsync(struct p9_dev *p9dev,
struct p9_pdu *pdu, u32 *outlen)
{
int ret, fd;
struct p9_fid *fid;
u32 fid_val, datasync;
virtio_p9_pdu_readf(pdu, "dd", &fid_val, &datasync);
fid = get_fid(p9dev, fid_val);
if (fid->dir)
fd = dirfd(fid->dir);
else
fd = fid->fd;
if (datasync)
ret = fdatasync(fd);
else
ret = fsync(fd);
if (ret < 0)
goto err_out;
*outlen = pdu->write_offset;
virtio_p9_set_reply_header(pdu, *outlen);
return;
err_out:
virtio_p9_error_reply(p9dev, pdu, errno, outlen);
return;
}
static void virtio_p9_symlink(struct p9_dev *p9dev,
struct p9_pdu *pdu, u32 *outlen)
{
int ret;
struct stat st;
u32 fid_val, gid;
struct p9_qid qid;
struct p9_fid *dfid;
char new_name[PATH_MAX];
char *old_path, *name;
virtio_p9_pdu_readf(pdu, "dssd", &fid_val, &name, &old_path, &gid);
dfid = get_fid(p9dev, fid_val);
if (get_full_path(new_name, sizeof(new_name), dfid, name) != 0)
goto err_out;
ret = symlink(old_path, new_name);
if (ret < 0)
goto err_out;
if (lstat(new_name, &st) < 0)
goto err_out;
stat2qid(&st, &qid);
virtio_p9_pdu_writef(pdu, "Q", &qid);
free(name);
free(old_path);
*outlen = pdu->write_offset;
virtio_p9_set_reply_header(pdu, *outlen);
return;
err_out:
free(name);
free(old_path);
virtio_p9_error_reply(p9dev, pdu, errno, outlen);
return;
}
static void virtio_p9_link(struct p9_dev *p9dev,
struct p9_pdu *pdu, u32 *outlen)
{
int ret;
char *name;
u32 fid_val, dfid_val;
struct p9_fid *dfid, *fid;
char full_path[PATH_MAX];
virtio_p9_pdu_readf(pdu, "dds", &dfid_val, &fid_val, &name);
dfid = get_fid(p9dev, dfid_val);
fid = get_fid(p9dev, fid_val);
if (get_full_path(full_path, sizeof(full_path), dfid, name) != 0)
goto err_out;
ret = link(fid->abs_path, full_path);
if (ret < 0)
goto err_out;
free(name);
*outlen = pdu->write_offset;
virtio_p9_set_reply_header(pdu, *outlen);
return;
err_out:
free(name);
virtio_p9_error_reply(p9dev, pdu, errno, outlen);
return;
}
static void virtio_p9_lock(struct p9_dev *p9dev,
struct p9_pdu *pdu, u32 *outlen)
{
u8 ret;
u32 fid_val;
struct p9_flock flock;
virtio_p9_pdu_readf(pdu, "dbdqqds", &fid_val, &flock.type,
&flock.flags, &flock.start, &flock.length,
&flock.proc_id, &flock.client_id);
/* Just return success */
ret = P9_LOCK_SUCCESS;
virtio_p9_pdu_writef(pdu, "d", ret);
*outlen = pdu->write_offset;
virtio_p9_set_reply_header(pdu, *outlen);
free(flock.client_id);
return;
}
static void virtio_p9_getlock(struct p9_dev *p9dev,
struct p9_pdu *pdu, u32 *outlen)
{
u32 fid_val;
struct p9_getlock glock;
virtio_p9_pdu_readf(pdu, "dbqqds", &fid_val, &glock.type,
&glock.start, &glock.length, &glock.proc_id,
&glock.client_id);
/* Just return success */
glock.type = F_UNLCK;
virtio_p9_pdu_writef(pdu, "bqqds", glock.type,
glock.start, glock.length, glock.proc_id,
glock.client_id);
*outlen = pdu->write_offset;
virtio_p9_set_reply_header(pdu, *outlen);
free(glock.client_id);
return;
}
static int virtio_p9_ancestor(char *path, char *ancestor)
{
int size = strlen(ancestor);
if (!strncmp(path, ancestor, size)) {
/*
* Now check whether ancestor is a full name or
* or directory component and not just part
* of a name.
*/
if (path[size] == '\0' || path[size] == '/')
return 1;
}
return 0;
}
static int virtio_p9_fix_path(struct p9_fid *fid, char *old_name, char *new_name)
{
int ret;
char *p, tmp_name[PATH_MAX];
size_t rp_sz = strlen(old_name);
if (rp_sz == strlen(fid->path)) {
/* replace the full name */
p = new_name;
} else {
/* save the trailing path details */
ret = snprintf(tmp_name, sizeof(tmp_name), "%s%s", new_name, fid->path + rp_sz);
if (ret >= (int)sizeof(tmp_name))
return -1;
p = tmp_name;
}
return join_path(fid, p);
}
static void rename_fids(struct p9_dev *p9dev, char *old_name, char *new_name)
{
struct rb_node *node = rb_first(&p9dev->fids);
while (node) {
struct p9_fid *fid = rb_entry(node, struct p9_fid, node);
if (fid->fid != P9_NOFID && virtio_p9_ancestor(fid->path, old_name)) {
virtio_p9_fix_path(fid, old_name, new_name);
}
node = rb_next(node);
}
}
static void virtio_p9_renameat(struct p9_dev *p9dev,
struct p9_pdu *pdu, u32 *outlen)
{
int ret;
char *old_name, *new_name;
u32 old_dfid_val, new_dfid_val;
struct p9_fid *old_dfid, *new_dfid;
char old_full_path[PATH_MAX], new_full_path[PATH_MAX];
virtio_p9_pdu_readf(pdu, "dsds", &old_dfid_val, &old_name,
&new_dfid_val, &new_name);
old_dfid = get_fid(p9dev, old_dfid_val);
new_dfid = get_fid(p9dev, new_dfid_val);
if (get_full_path(old_full_path, sizeof(old_full_path), old_dfid, old_name) != 0)
goto err_out;
if (get_full_path(new_full_path, sizeof(new_full_path), new_dfid, new_name) != 0)
goto err_out;
ret = rename(old_full_path, new_full_path);
if (ret < 0)
goto err_out;
/*
* Now fix path in other fids, if the renamed path is part of
* that.
*/
rename_fids(p9dev, old_name, new_name);
free(old_name);
free(new_name);
*outlen = pdu->write_offset;
virtio_p9_set_reply_header(pdu, *outlen);
return;
err_out:
free(old_name);
free(new_name);
virtio_p9_error_reply(p9dev, pdu, errno, outlen);
return;
}
static void virtio_p9_unlinkat(struct p9_dev *p9dev,
struct p9_pdu *pdu, u32 *outlen)
{
int ret;
char *name;
u32 fid_val, flags;
struct p9_fid *fid;
char full_path[PATH_MAX];
virtio_p9_pdu_readf(pdu, "dsd", &fid_val, &name, &flags);
fid = get_fid(p9dev, fid_val);
if (get_full_path(full_path, sizeof(full_path), fid, name) != 0)
goto err_out;
ret = remove(full_path);
if (ret < 0)
goto err_out;
free(name);
*outlen = pdu->write_offset;
virtio_p9_set_reply_header(pdu, *outlen);
return;
err_out:
free(name);
virtio_p9_error_reply(p9dev, pdu, errno, outlen);
return;
}
static void virtio_p9_flush(struct p9_dev *p9dev,
struct p9_pdu *pdu, u32 *outlen)
{
u16 tag, oldtag;
virtio_p9_pdu_readf(pdu, "ww", &tag, &oldtag);
virtio_p9_pdu_writef(pdu, "w", tag);
*outlen = pdu->write_offset;
virtio_p9_set_reply_header(pdu, *outlen);
return;
}
static void virtio_p9_eopnotsupp(struct p9_dev *p9dev,
struct p9_pdu *pdu, u32 *outlen)
{
return virtio_p9_error_reply(p9dev, pdu, EOPNOTSUPP, outlen);
}
typedef void p9_handler(struct p9_dev *p9dev,
struct p9_pdu *pdu, u32 *outlen);
/* FIXME should be removed when merging with latest linus tree */
#define P9_TRENAMEAT 74
#define P9_TUNLINKAT 76
static p9_handler *virtio_9p_dotl_handler [] = {
[P9_TREADDIR] = virtio_p9_readdir,
[P9_TSTATFS] = virtio_p9_statfs,
[P9_TGETATTR] = virtio_p9_getattr,
[P9_TSETATTR] = virtio_p9_setattr,
[P9_TXATTRWALK] = virtio_p9_eopnotsupp,
[P9_TXATTRCREATE] = virtio_p9_eopnotsupp,
[P9_TMKNOD] = virtio_p9_mknod,
[P9_TLOCK] = virtio_p9_lock,
[P9_TGETLOCK] = virtio_p9_getlock,
[P9_TRENAMEAT] = virtio_p9_renameat,
[P9_TREADLINK] = virtio_p9_readlink,
[P9_TUNLINKAT] = virtio_p9_unlinkat,
[P9_TMKDIR] = virtio_p9_mkdir,
[P9_TVERSION] = virtio_p9_version,
[P9_TLOPEN] = virtio_p9_open,
[P9_TATTACH] = virtio_p9_attach,
[P9_TWALK] = virtio_p9_walk,
[P9_TCLUNK] = virtio_p9_clunk,
[P9_TFSYNC] = virtio_p9_fsync,
[P9_TREAD] = virtio_p9_read,
[P9_TFLUSH] = virtio_p9_flush,
[P9_TLINK] = virtio_p9_link,
[P9_TSYMLINK] = virtio_p9_symlink,
[P9_TLCREATE] = virtio_p9_create,
[P9_TWRITE] = virtio_p9_write,
[P9_TREMOVE] = virtio_p9_remove,
[P9_TRENAME] = virtio_p9_rename,
};
static struct p9_pdu *virtio_p9_pdu_init(struct kvm *kvm, struct virt_queue *vq)
{
struct p9_pdu *pdu = calloc(1, sizeof(*pdu));
if (!pdu)
return NULL;
/* skip the pdu header p9_msg */
pdu->read_offset = VIRTIO_9P_HDR_LEN;
pdu->write_offset = VIRTIO_9P_HDR_LEN;
pdu->queue_head = virt_queue__get_inout_iov(kvm, vq, pdu->in_iov,
pdu->out_iov, &pdu->in_iov_cnt, &pdu->out_iov_cnt);
return pdu;
}
static u8 virtio_p9_get_cmd(struct p9_pdu *pdu)
{
struct p9_msg *msg;
/*
* we can peek directly into pdu for a u8
* value. The host endianess won't be an issue
*/
msg = pdu->out_iov[0].iov_base;
return msg->cmd;
}
static bool virtio_p9_do_io_request(struct kvm *kvm, struct p9_dev_job *job)
{
u8 cmd;
u32 len = 0;
p9_handler *handler;
struct p9_dev *p9dev;
struct virt_queue *vq;
struct p9_pdu *p9pdu;
vq = job->vq;
p9dev = job->p9dev;
p9pdu = virtio_p9_pdu_init(kvm, vq);
cmd = virtio_p9_get_cmd(p9pdu);
if ((cmd >= ARRAY_SIZE(virtio_9p_dotl_handler)) ||
!virtio_9p_dotl_handler[cmd])
handler = virtio_p9_eopnotsupp;
else
handler = virtio_9p_dotl_handler[cmd];
handler(p9dev, p9pdu, &len);
virt_queue__set_used_elem(vq, p9pdu->queue_head, len);
free(p9pdu);
return true;
}
static void virtio_p9_do_io(struct kvm *kvm, void *param)
{
struct p9_dev_job *job = (struct p9_dev_job *)param;
struct p9_dev *p9dev = job->p9dev;
struct virt_queue *vq = job->vq;
while (virt_queue__available(vq)) {
virtio_p9_do_io_request(kvm, job);
p9dev->vdev.ops->signal_vq(kvm, &p9dev->vdev, vq - p9dev->vqs);
}
}
static u8 *get_config(struct kvm *kvm, void *dev)
{
struct p9_dev *p9dev = dev;
return ((u8 *)(p9dev->config));
}
static size_t get_config_size(struct kvm *kvm, void *dev)
{
struct p9_dev *p9dev = dev;
return p9dev->config_size;
}
static u64 get_host_features(struct kvm *kvm, void *dev)
{
return 1 << VIRTIO_9P_MOUNT_TAG;
}
static void notify_status(struct kvm *kvm, void *dev, u32 status)
{
struct p9_dev *p9dev = dev;
struct p9_fid *pfid, *next;
if (status & VIRTIO__STATUS_CONFIG)
p9dev->config->tag_len = virtio_host_to_guest_u16(p9dev->vdev.endian,
p9dev->tag_len);
if (!(status & VIRTIO__STATUS_STOP))
return;
rbtree_postorder_for_each_entry_safe(pfid, next, &p9dev->fids, node)
close_fid(p9dev, pfid->fid);
}
static int init_vq(struct kvm *kvm, void *dev, u32 vq)
{
struct p9_dev *p9dev = dev;
struct p9_dev_job *job;
struct virt_queue *queue;
compat__remove_message(compat_id);
queue = &p9dev->vqs[vq];
job = &p9dev->jobs[vq];
virtio_init_device_vq(kvm, &p9dev->vdev, queue, VIRTQUEUE_NUM);
*job = (struct p9_dev_job) {
.vq = queue,
.p9dev = p9dev,
};
thread_pool__init_job(&job->job_id, kvm, virtio_p9_do_io, job);
return 0;
}
static void exit_vq(struct kvm *kvm, void *dev, u32 vq)
{
struct p9_dev *p9dev = dev;
thread_pool__cancel_job(&p9dev->jobs[vq].job_id);
}
static int notify_vq(struct kvm *kvm, void *dev, u32 vq)
{
struct p9_dev *p9dev = dev;
thread_pool__do_job(&p9dev->jobs[vq].job_id);
return 0;
}
static struct virt_queue *get_vq(struct kvm *kvm, void *dev, u32 vq)
{
struct p9_dev *p9dev = dev;
return &p9dev->vqs[vq];
}
static int get_size_vq(struct kvm *kvm, void *dev, u32 vq)
{
return VIRTQUEUE_NUM;
}
static int set_size_vq(struct kvm *kvm, void *dev, u32 vq, int size)
{
/* FIXME: dynamic */
return size;
}
static unsigned int get_vq_count(struct kvm *kvm, void *dev)
{
return NUM_VIRT_QUEUES;
}
struct virtio_ops p9_dev_virtio_ops = {
.get_config = get_config,
.get_config_size = get_config_size,
.get_host_features = get_host_features,
.init_vq = init_vq,
.exit_vq = exit_vq,
.notify_status = notify_status,
.notify_vq = notify_vq,
.get_vq = get_vq,
.get_size_vq = get_size_vq,
.set_size_vq = set_size_vq,
.get_vq_count = get_vq_count,
};
int virtio_9p_rootdir_parser(const struct option *opt, const char *arg, int unset)
{
char *tag_name;
char tmp[PATH_MAX];
struct kvm *kvm = opt->ptr;
/*
* 9p dir can be of the form dirname,tag_name or
* just dirname. In the later case we use the
* default tag name
*/
tag_name = strstr(arg, ",");
if (tag_name) {
*tag_name = '\0';
tag_name++;
}
if (realpath(arg, tmp)) {
if (virtio_9p__register(kvm, tmp, tag_name) < 0)
die("Unable to initialize virtio 9p");
} else
die("Failed resolving 9p path");
return 0;
}
int virtio_9p_img_name_parser(const struct option *opt, const char *arg, int unset)
{
char path[PATH_MAX];
struct stat st;
struct kvm *kvm = opt->ptr;
if (stat(arg, &st) == 0 &&
S_ISDIR(st.st_mode)) {
char tmp[PATH_MAX];
if (kvm->cfg.using_rootfs)
die("Please use only one rootfs directory atmost");
if (realpath(arg, tmp) == 0 ||
virtio_9p__register(kvm, tmp, "/dev/root") < 0)
die("Unable to initialize virtio 9p");
kvm->cfg.using_rootfs = 1;
return 0;
}
snprintf(path, PATH_MAX, "%s%s", kvm__get_dir(), arg);
if (stat(path, &st) == 0 &&
S_ISDIR(st.st_mode)) {
char tmp[PATH_MAX];
if (kvm->cfg.using_rootfs)
die("Please use only one rootfs directory atmost");
if (realpath(path, tmp) == 0 ||
virtio_9p__register(kvm, tmp, "/dev/root") < 0)
die("Unable to initialize virtio 9p");
if (virtio_9p__register(kvm, "/", "hostfs") < 0)
die("Unable to initialize virtio 9p");
kvm_setup_resolv(arg);
kvm->cfg.using_rootfs = kvm->cfg.custom_rootfs = 1;
kvm->cfg.custom_rootfs_name = arg;
return 0;
}
return -1;
}
int virtio_9p__init(struct kvm *kvm)
{
struct p9_dev *p9dev;
int r;
list_for_each_entry(p9dev, &devs, list) {
r = virtio_init(kvm, p9dev, &p9dev->vdev, &p9_dev_virtio_ops,
kvm->cfg.virtio_transport, PCI_DEVICE_ID_VIRTIO_9P,
VIRTIO_ID_9P, PCI_CLASS_9P);
if (r < 0)
return r;
}
return 0;
}
virtio_dev_init(virtio_9p__init);
int virtio_9p__register(struct kvm *kvm, const char *root, const char *tag_name)
{
struct p9_dev *p9dev;
size_t tag_length;
size_t config_size;
int err;
p9dev = calloc(1, sizeof(*p9dev));
if (!p9dev)
return -ENOMEM;
if (!tag_name)
tag_name = VIRTIO_9P_DEFAULT_TAG;
tag_length = strlen(tag_name);
/* The tag_name zero byte is intentionally excluded */
config_size = sizeof(*p9dev->config) + tag_length;
p9dev->config = calloc(1, config_size);
if (p9dev->config == NULL) {
err = -ENOMEM;
goto free_p9dev;
}
p9dev->config_size = config_size;
strncpy(p9dev->root_dir, root, sizeof(p9dev->root_dir));
p9dev->root_dir[sizeof(p9dev->root_dir)-1] = '\x00';
p9dev->tag_len = tag_length;
if (p9dev->tag_len > MAX_TAG_LEN) {
err = -EINVAL;
goto free_p9dev_config;
}
memcpy(&p9dev->config->tag, tag_name, tag_length);
list_add(&p9dev->list, &devs);
if (compat_id == -1)
compat_id = virtio_compat_add_message("virtio-9p", "CONFIG_NET_9P_VIRTIO");
return 0;
free_p9dev_config:
free(p9dev->config);
free_p9dev:
free(p9dev);
return err;
}