提交 c494dd6f 编写于 作者: A Anthony Liguori

virtio-9p: Add P9_TCREATE support

Implement P9_TCREATE support.
[jvrao@linux.vnet.ibm.com: strdup to qemu_strdup conversion]
Signed-off-by: NAnthony Liguori <aliguori@us.ibm.com>
Signed-off-by: NAneesh Kumar K.V <aneesh.kumar@linux.vnet.ibm.com>
Signed-off-by: NAnthony Liguori <aliguori@us.ibm.com>
上级 8449360c
......@@ -29,11 +29,17 @@ typedef struct FileOperations
{
int (*lstat)(FsContext *, const char *, struct stat *);
ssize_t (*readlink)(FsContext *, const char *, char *, size_t);
int (*chmod)(FsContext *, const char *, mode_t);
int (*mknod)(FsContext *, const char *, mode_t, dev_t);
int (*mksock)(FsContext *, const char *);
int (*symlink)(FsContext *, const char *, const char *);
int (*link)(FsContext *, const char *, const char *);
int (*setuid)(FsContext *, uid_t);
int (*close)(FsContext *, int);
int (*closedir)(FsContext *, DIR *);
DIR *(*opendir)(FsContext *, const char *);
int (*open)(FsContext *, const char *, int);
int (*open2)(FsContext *, const char *, int, mode_t);
void (*rewinddir)(FsContext *, DIR *);
off_t (*telldir)(FsContext *, DIR *);
struct dirent *(*readdir)(FsContext *, DIR *);
......@@ -41,6 +47,8 @@ typedef struct FileOperations
ssize_t (*readv)(FsContext *, int, const struct iovec *, int);
ssize_t (*writev)(FsContext *, int, const struct iovec *, int);
off_t (*lseek)(FsContext *, int, off_t, int);
int (*mkdir)(FsContext *, const char *, mode_t);
int (*fstat)(FsContext *, int, struct stat *);
void *opaque;
} FileOperations;
#endif
......@@ -12,8 +12,11 @@
*/
#include "virtio.h"
#include "virtio-9p.h"
#include <arpa/inet.h>
#include <pwd.h>
#include <grp.h>
#include <sys/socket.h>
#include <sys/un.h>
static const char *rpath(FsContext *ctx, const char *path)
{
......@@ -133,6 +136,82 @@ static ssize_t local_writev(FsContext *ctx, int fd, const struct iovec *iov,
return writev(fd, iov, iovcnt);
}
static int local_chmod(FsContext *ctx, const char *path, mode_t mode)
{
return chmod(rpath(ctx, path), mode);
}
static int local_mknod(FsContext *ctx, const char *path, mode_t mode, dev_t dev)
{
return mknod(rpath(ctx, path), mode, dev);
}
static int local_mksock(FsContext *ctx2, const char *path)
{
struct sockaddr_un addr;
int s;
addr.sun_family = AF_UNIX;
snprintf(addr.sun_path, 108, "%s", rpath(ctx2, path));
s = socket(PF_UNIX, SOCK_STREAM, 0);
if (s == -1) {
return -1;
}
if (bind(s, (struct sockaddr *)&addr, sizeof(addr))) {
close(s);
return -1;
}
close(s);
return 0;
}
static int local_mkdir(FsContext *ctx, const char *path, mode_t mode)
{
return mkdir(rpath(ctx, path), mode);
}
static int local_fstat(FsContext *ctx, int fd, struct stat *stbuf)
{
return fstat(fd, stbuf);
}
static int local_open2(FsContext *ctx, const char *path, int flags, mode_t mode)
{
return open(rpath(ctx, path), flags, mode);
}
static int local_symlink(FsContext *ctx, const char *oldpath,
const char *newpath)
{
return symlink(oldpath, rpath(ctx, newpath));
}
static int local_link(FsContext *ctx, const char *oldpath, const char *newpath)
{
char *tmp = qemu_strdup(rpath(ctx, oldpath));
int err, serrno = 0;
if (tmp == NULL) {
return -ENOMEM;
}
err = link(tmp, rpath(ctx, newpath));
if (err == -1) {
serrno = errno;
}
qemu_free(tmp);
if (err == -1) {
errno = serrno;
}
return err;
}
FileOperations local_ops = {
.lstat = local_lstat,
.setuid = local_setuid,
......@@ -148,4 +227,12 @@ FileOperations local_ops = {
.readv = local_readv,
.lseek = local_lseek,
.writev = local_writev,
.chmod = local_chmod,
.mknod = local_mknod,
.mksock = local_mksock,
.mkdir = local_mkdir,
.fstat = local_fstat,
.open2 = local_open2,
.symlink = local_symlink,
.link = local_link,
};
......@@ -103,6 +103,47 @@ static int v9fs_do_writev(V9fsState *s, int fd, const struct iovec *iov,
return s->ops->writev(&s->ctx, fd, iov, iovcnt);
}
static int v9fs_do_chmod(V9fsState *s, V9fsString *path, mode_t mode)
{
return s->ops->chmod(&s->ctx, path->data, mode);
}
static int v9fs_do_mknod(V9fsState *s, V9fsString *path, mode_t mode, dev_t dev)
{
return s->ops->mknod(&s->ctx, path->data, mode, dev);
}
static int v9fs_do_mksock(V9fsState *s, V9fsString *path)
{
return s->ops->mksock(&s->ctx, path->data);
}
static int v9fs_do_mkdir(V9fsState *s, V9fsString *path, mode_t mode)
{
return s->ops->mkdir(&s->ctx, path->data, mode);
}
static int v9fs_do_fstat(V9fsState *s, int fd, struct stat *stbuf)
{
return s->ops->fstat(&s->ctx, fd, stbuf);
}
static int v9fs_do_open2(V9fsState *s, V9fsString *path, int flags, mode_t mode)
{
return s->ops->open2(&s->ctx, path->data, flags, mode);
}
static int v9fs_do_symlink(V9fsState *s, V9fsString *oldpath,
V9fsString *newpath)
{
return s->ops->symlink(&s->ctx, oldpath->data, newpath->data);
}
static int v9fs_do_link(V9fsState *s, V9fsString *oldpath, V9fsString *newpath)
{
return s->ops->link(&s->ctx, oldpath->data, newpath->data);
}
static void v9fs_string_init(V9fsString *str)
{
str->data = NULL;
......@@ -1649,11 +1690,230 @@ out:
qemu_free(vs);
}
typedef struct V9fsCreateState {
V9fsPDU *pdu;
size_t offset;
V9fsFidState *fidp;
V9fsQID qid;
int32_t perm;
int8_t mode;
struct stat stbuf;
V9fsString name;
V9fsString extension;
V9fsString fullname;
} V9fsCreateState;
static void v9fs_post_create(V9fsState *s, V9fsCreateState *vs, int err)
{
if (err == 0) {
v9fs_string_copy(&vs->fidp->path, &vs->fullname);
stat_to_qid(&vs->stbuf, &vs->qid);
vs->offset += pdu_marshal(vs->pdu, vs->offset, "Qd", &vs->qid, 0);
err = vs->offset;
}
complete_pdu(s, vs->pdu, err);
v9fs_string_free(&vs->name);
v9fs_string_free(&vs->extension);
v9fs_string_free(&vs->fullname);
qemu_free(vs);
}
static void v9fs_create_post_perms(V9fsState *s, V9fsCreateState *vs, int err)
{
if (err) {
err = -errno;
}
v9fs_post_create(s, vs, err);
}
static void v9fs_create_post_opendir(V9fsState *s, V9fsCreateState *vs,
int err)
{
if (!vs->fidp->dir) {
err = -errno;
}
v9fs_post_create(s, vs, err);
}
static void v9fs_create_post_dir_lstat(V9fsState *s, V9fsCreateState *vs,
int err)
{
if (err) {
err = -errno;
goto out;
}
vs->fidp->dir = v9fs_do_opendir(s, &vs->fullname);
v9fs_create_post_opendir(s, vs, err);
return;
out:
v9fs_post_create(s, vs, err);
}
static void v9fs_create_post_mkdir(V9fsState *s, V9fsCreateState *vs, int err)
{
if (err) {
err = -errno;
goto out;
}
err = v9fs_do_lstat(s, &vs->fullname, &vs->stbuf);
v9fs_create_post_dir_lstat(s, vs, err);
return;
out:
v9fs_post_create(s, vs, err);
}
static void v9fs_create_post_mksock(V9fsState *s, V9fsCreateState *vs,
int err)
{
if (err) {
err = -errno;
goto out;
}
err = v9fs_do_chmod(s, &vs->fullname, vs->perm & 0777);
v9fs_create_post_perms(s, vs, err);
return;
out:
v9fs_post_create(s, vs, err);
}
static void v9fs_create_post_fstat(V9fsState *s, V9fsCreateState *vs, int err)
{
if (err) {
vs->fidp->fd = -1;
err = -errno;
}
v9fs_post_create(s, vs, err);
return;
}
static void v9fs_create_post_open2(V9fsState *s, V9fsCreateState *vs, int err)
{
if (vs->fidp->fd == -1) {
err = -errno;
goto out;
}
err = v9fs_do_fstat(s, vs->fidp->fd, &vs->stbuf);
v9fs_create_post_fstat(s, vs, err);
return;
out:
v9fs_post_create(s, vs, err);
}
static void v9fs_create_post_lstat(V9fsState *s, V9fsCreateState *vs, int err)
{
if (err == 0 || errno != ENOENT) {
err = -errno;
goto out;
}
if (vs->perm & P9_STAT_MODE_DIR) {
err = v9fs_do_mkdir(s, &vs->fullname, vs->perm & 0777);
v9fs_create_post_mkdir(s, vs, err);
} else if (vs->perm & P9_STAT_MODE_SYMLINK) {
err = v9fs_do_symlink(s, &vs->extension, &vs->fullname);
v9fs_create_post_perms(s, vs, err);
} else if (vs->perm & P9_STAT_MODE_LINK) {
int32_t nfid = atoi(vs->extension.data);
V9fsFidState *nfidp = lookup_fid(s, nfid);
if (nfidp == NULL) {
err = -errno;
v9fs_post_create(s, vs, err);
}
err = v9fs_do_link(s, &nfidp->path, &vs->fullname);
v9fs_create_post_perms(s, vs, err);
} else if (vs->perm & P9_STAT_MODE_DEVICE) {
char ctype;
uint32_t major, minor;
mode_t nmode = 0;
if (sscanf(vs->extension.data, "%c %u %u", &ctype, &major,
&minor) != 3) {
err = -errno;
v9fs_post_create(s, vs, err);
}
switch (ctype) {
case 'c':
nmode = S_IFCHR;
break;
case 'b':
nmode = S_IFBLK;
break;
default:
err = -EIO;
v9fs_post_create(s, vs, err);
}
nmode |= vs->perm & 0777;
err = v9fs_do_mknod(s, &vs->fullname, nmode, makedev(major, minor));
v9fs_create_post_perms(s, vs, err);
} else if (vs->perm & P9_STAT_MODE_NAMED_PIPE) {
err = v9fs_do_mknod(s, &vs->fullname, S_IFIFO | (vs->mode & 0777), 0);
v9fs_post_create(s, vs, err);
} else if (vs->perm & P9_STAT_MODE_SOCKET) {
err = v9fs_do_mksock(s, &vs->fullname);
v9fs_create_post_mksock(s, vs, err);
} else {
vs->fidp->fd = v9fs_do_open2(s, &vs->fullname,
omode_to_uflags(vs->mode) | O_CREAT,
vs->perm & 0777);
v9fs_create_post_open2(s, vs, err);
}
return;
out:
v9fs_post_create(s, vs, err);
}
static void v9fs_create(V9fsState *s, V9fsPDU *pdu)
{
if (debug_9p_pdu) {
pprint_pdu(pdu);
int32_t fid;
V9fsCreateState *vs;
int err = 0;
vs = qemu_malloc(sizeof(*vs));
vs->pdu = pdu;
vs->offset = 7;
v9fs_string_init(&vs->fullname);
pdu_unmarshal(vs->pdu, vs->offset, "dsdbs", &fid, &vs->name,
&vs->perm, &vs->mode, &vs->extension);
vs->fidp = lookup_fid(s, fid);
if (vs->fidp == NULL) {
err = -EINVAL;
goto out;
}
v9fs_string_sprintf(&vs->fullname, "%s/%s", vs->fidp->path.data,
vs->name.data);
err = v9fs_do_lstat(s, &vs->fullname, &vs->stbuf);
v9fs_create_post_lstat(s, vs, err);
return;
out:
complete_pdu(s, vs->pdu, err);
v9fs_string_free(&vs->name);
v9fs_string_free(&vs->extension);
qemu_free(vs);
}
static void v9fs_flush(V9fsState *s, V9fsPDU *pdu)
......
Markdown is supported
0% .
You are about to add 0 people to the discussion. Proceed with caution.
先完成此消息的编辑!
想要评论请 注册