From patchwork Thu Mar 25 16:43:33 2010 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: "Aneesh Kumar K.V" X-Patchwork-Id: 48582 Return-Path: X-Original-To: incoming@patchwork.ozlabs.org Delivered-To: patchwork-incoming@bilbo.ozlabs.org Received: from lists.gnu.org (lists.gnu.org [199.232.76.165]) (using TLSv1 with cipher DHE-RSA-AES256-SHA (256/256 bits)) (Client did not present a certificate) by ozlabs.org (Postfix) with ESMTPS id 7BEE7B7CBB for ; Fri, 26 Mar 2010 05:33:26 +1100 (EST) Received: from localhost ([127.0.0.1]:60737 helo=lists.gnu.org) by lists.gnu.org with esmtp (Exim 4.43) id 1NurkD-0000ig-E7 for incoming@patchwork.ozlabs.org; Thu, 25 Mar 2010 14:25:25 -0400 Received: from mailman by lists.gnu.org with tmda-scanned (Exim 4.43) id 1NuqB2-0007K4-P8 for qemu-devel@nongnu.org; Thu, 25 Mar 2010 12:45:00 -0400 Received: from [140.186.70.92] (port=50755 helo=eggs.gnu.org) by lists.gnu.org with esmtp (Exim 4.43) id 1NuqAs-0007HL-VZ for qemu-devel@nongnu.org; Thu, 25 Mar 2010 12:45:00 -0400 Received: from Debian-exim by eggs.gnu.org with spam-scanned (Exim 4.69) (envelope-from ) id 1NuqAk-0005Dv-HL for qemu-devel@nongnu.org; Thu, 25 Mar 2010 12:44:50 -0400 Received: from e23smtp04.au.ibm.com ([202.81.31.146]:56949) by eggs.gnu.org with esmtp (Exim 4.69) (envelope-from ) id 1NuqAh-0005DM-UC for qemu-devel@nongnu.org; Thu, 25 Mar 2010 12:44:42 -0400 Received: from d23relay04.au.ibm.com (d23relay04.au.ibm.com [202.81.31.246]) by e23smtp04.au.ibm.com (8.14.3/8.13.1) with ESMTP id o2PGeq1w024912 for ; Fri, 26 Mar 2010 03:40:52 +1100 Received: from d23av03.au.ibm.com (d23av03.au.ibm.com [9.190.234.97]) by d23relay04.au.ibm.com (8.13.8/8.13.8/NCO v10.0) with ESMTP id o2PGcacu1663156 for ; Fri, 26 Mar 2010 03:38:36 +1100 Received: from d23av03.au.ibm.com (loopback [127.0.0.1]) by d23av03.au.ibm.com (8.14.3/8.13.1/NCO v10.0 AVout) with ESMTP id o2PGic6b031680 for ; Fri, 26 Mar 2010 03:44:38 +1100 Received: from localhost.localdomain ([9.77.125.24]) by d23av03.au.ibm.com (8.14.3/8.13.1/NCO v10.0 AVin) with ESMTP id o2PGhgP0030935; Fri, 26 Mar 2010 03:44:35 +1100 From: "Aneesh Kumar K.V" To: qemu-devel@nongnu.org Date: Thu, 25 Mar 2010 22:13:33 +0530 Message-Id: <1269535420-31206-26-git-send-email-aneesh.kumar@linux.vnet.ibm.com> X-Mailer: git-send-email 1.7.0.2.323.g0d092 In-Reply-To: <1269535420-31206-1-git-send-email-aneesh.kumar@linux.vnet.ibm.com> References: <1269535420-31206-1-git-send-email-aneesh.kumar@linux.vnet.ibm.com> X-detected-operating-system: by eggs.gnu.org: GNU/Linux 2.6, seldom 2.4 (older, 4) Cc: ericvh@gmail.com, aliguori@us.ibm.com, "Aneesh Kumar K.V" , Gautham R Shenoy Subject: [Qemu-devel] [PATCH -V3 25/32] virtio-9p: Move V9fs File system specific options to a separate header file. X-BeenThere: qemu-devel@nongnu.org X-Mailman-Version: 2.1.5 Precedence: list List-Id: qemu-devel.nongnu.org List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Sender: qemu-devel-bounces+incoming=patchwork.ozlabs.org@nongnu.org Errors-To: qemu-devel-bounces+incoming=patchwork.ozlabs.org@nongnu.org Move the V9fs File System specific operations structs into a different header file. Also introduce a new struct named context which is the subset of the V9fsState to be passed to the individual file-system operations. Signed-off-by: Aneesh Kumar K.V Signed-off-by: Gautham R Shenoy --- hw/file-op.h | 60 ++++++++++++++ hw/virtio-9p-local.c | 64 ++++++++-------- hw/virtio-9p.c | 209 +++++++++++++++++++++++++------------------------- hw/virtio-9p.h | 43 +--------- 4 files changed, 202 insertions(+), 174 deletions(-) create mode 100644 hw/file-op.h diff --git a/hw/file-op.h b/hw/file-op.h new file mode 100644 index 0000000..f84767f --- /dev/null +++ b/hw/file-op.h @@ -0,0 +1,60 @@ +/* + * Virtio 9p + * + * Copyright IBM, Corp. 2010 + * + * Authors: + * Aneesh Kumar K.V + * + * This work is licensed under the terms of the GNU GPL, version 2. See + * the COPYING file in the top-level directory. + * + */ +#ifndef _FILEOP_H +#define _FILEOP_H +#include +#include +#include +#include +#include +#include + +typedef struct FsContext +{ + char *fs_root; + uid_t uid; +} FsContext; + +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 (*chown)(FsContext *, const char *, uid_t, gid_t); + int (*mknod)(FsContext *, const char *, mode_t, dev_t); + int (*mksock)(FsContext *, const char *); + int (*utime)(FsContext *, const char *, const struct utimbuf *); + int (*remove)(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 *); + void (*seekdir)(FsContext *, DIR *, off_t); + 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 *); + int (*rename)(FsContext *, const char *, const char *); + int (*truncate)(FsContext *, const char *, off_t); + int (*fsync)(FsContext *, int); + void *opaque; +} FileOperations; +#endif diff --git a/hw/virtio-9p-local.c b/hw/virtio-9p-local.c index 4584bf6..690ba3f 100644 --- a/hw/virtio-9p-local.c +++ b/hw/virtio-9p-local.c @@ -22,7 +22,7 @@ #include #include -static const char *rpath(V9fsState *s, const char *path) +static const char *rpath(FsContext *s, const char *path) { /* FIXME: so wrong... */ static char buffer[4096]; @@ -30,12 +30,12 @@ static const char *rpath(V9fsState *s, const char *path) return buffer; } -static int local_lstat(V9fsState *s, const char *path, struct stat *stbuf) +static int local_lstat(FsContext *s, const char *path, struct stat *stbuf) { return lstat(rpath(s, path), stbuf); } -static int local_setuid(V9fsState *s, uid_t uid) +static int local_setuid(FsContext *s, uid_t uid) { struct passwd *pw; gid_t groups[33]; @@ -70,80 +70,80 @@ static int local_setuid(V9fsState *s, uid_t uid) return 0; } -static ssize_t local_readlink(V9fsState *s, const char *path, +static ssize_t local_readlink(FsContext *s, const char *path, char *buf, size_t bufsz) { return readlink(rpath(s, path), buf, bufsz); } -static int local_close(V9fsState *s, int fd) +static int local_close(FsContext *s, int fd) { return close(fd); } -static int local_closedir(V9fsState *s, DIR *dir) +static int local_closedir(FsContext *s, DIR *dir) { return closedir(dir); } -static int local_open(V9fsState *s, const char *path, int flags) +static int local_open(FsContext *s, const char *path, int flags) { return open(rpath(s, path), flags); } -static DIR *local_opendir(V9fsState *s, const char *path) +static DIR *local_opendir(FsContext *s, const char *path) { return opendir(rpath(s, path)); } -static void local_rewinddir(V9fsState *s, DIR *dir) +static void local_rewinddir(FsContext *s, DIR *dir) { return rewinddir(dir); } -static off_t local_telldir(V9fsState *s, DIR *dir) +static off_t local_telldir(FsContext *s, DIR *dir) { return telldir(dir); } -static struct dirent *local_readdir(V9fsState *s, DIR *dir) +static struct dirent *local_readdir(FsContext *s, DIR *dir) { return readdir(dir); } -static void local_seekdir(V9fsState *s, DIR *dir, off_t off) +static void local_seekdir(FsContext *s, DIR *dir, off_t off) { return seekdir(dir, off); } -static ssize_t local_readv(V9fsState *s, int fd, const struct iovec *iov, +static ssize_t local_readv(FsContext *s, int fd, const struct iovec *iov, int iovcnt) { return readv(fd, iov, iovcnt); } -static off_t local_lseek(V9fsState *s, int fd, off_t offset, int whence) +static off_t local_lseek(FsContext *s, int fd, off_t offset, int whence) { return lseek(fd, offset, whence); } -static ssize_t local_writev(V9fsState *s, int fd, const struct iovec *iov, +static ssize_t local_writev(FsContext *s, int fd, const struct iovec *iov, int iovcnt) { return writev(fd, iov, iovcnt); } -static int local_chmod(V9fsState *s, const char *path, mode_t mode) +static int local_chmod(FsContext *s, const char *path, mode_t mode) { return chmod(rpath(s, path), mode); } -static int local_mknod(V9fsState *s, const char *path, mode_t mode, dev_t dev) +static int local_mknod(FsContext *s, const char *path, mode_t mode, dev_t dev) { return mknod(rpath(s, path), mode, dev); } -static int local_mksock(V9fsState *s2, const char *path) +static int local_mksock(FsContext *s2, const char *path) { struct sockaddr_un addr; int s; @@ -164,28 +164,28 @@ static int local_mksock(V9fsState *s2, const char *path) return 0; } -static int local_mkdir(V9fsState *s, const char *path, mode_t mode) +static int local_mkdir(FsContext *s, const char *path, mode_t mode) { return mkdir(rpath(s, path), mode); } -static int local_fstat(V9fsState *s, int fd, struct stat *stbuf) +static int local_fstat(FsContext *s, int fd, struct stat *stbuf) { return fstat(fd, stbuf); } -static int local_open2(V9fsState *s, const char *path, int flags, mode_t mode) +static int local_open2(FsContext *s, const char *path, int flags, mode_t mode) { return open(rpath(s, path), flags, mode); } -static int local_symlink(V9fsState *s, const char *oldpath, +static int local_symlink(FsContext *s, const char *oldpath, const char *newpath) { return symlink(oldpath, rpath(s, newpath)); } -static int local_link(V9fsState *s, const char *oldpath, const char *newpath) +static int local_link(FsContext *s, const char *oldpath, const char *newpath) { char *tmp = qemu_strdup(rpath(s, oldpath)); int err, serrno = 0; @@ -205,12 +205,12 @@ static int local_link(V9fsState *s, const char *oldpath, const char *newpath) return err; } -static int local_truncate(V9fsState *s, const char *path, off_t size) +static int local_truncate(FsContext *s, const char *path, off_t size) { return truncate(rpath(s, path), size); } -static int local_rename(V9fsState *s, const char *oldpath, +static int local_rename(FsContext *s, const char *oldpath, const char *newpath) { char *tmp; @@ -232,29 +232,29 @@ static int local_rename(V9fsState *s, const char *oldpath, } -static int local_chown(V9fsState *s, const char *path, uid_t uid, gid_t gid) +static int local_chown(FsContext *s, const char *path, uid_t uid, gid_t gid) { return chown(rpath(s, path), uid, gid); } -static int local_utime(V9fsState *s, const char *path, +static int local_utime(FsContext *s, const char *path, const struct utimbuf *buf) { return utime(rpath(s, path), buf); } -static int local_remove(V9fsState *s, const char *path) +static int local_remove(FsContext *s, const char *path) { return remove(rpath(s, path)); } -static int local_fsync(V9fsState *s, int fd) +static int local_fsync(FsContext *s, int fd) { return fsync(fd); } -static V9fsPosixFileOperations ops = { +static FileOperations ops = { .lstat = local_lstat, .setuid = local_setuid, .readlink = local_readlink, @@ -285,7 +285,7 @@ static V9fsPosixFileOperations ops = { .fsync = local_fsync, }; -V9fsPosixFileOperations *virtio_9p_init_local(const char *path) +FileOperations *virtio_9p_init_local(const char *path) { -return &ops; + return &ops; } diff --git a/hw/virtio-9p.c b/hw/virtio-9p.c index e519605..d03693d 100644 --- a/hw/virtio-9p.c +++ b/hw/virtio-9p.c @@ -22,23 +22,23 @@ int debug_9p_pdu = 1; extern void pprint_pdu(V9fsPDU *pdu); -static int posix_lstat(V9fsState *s, V9fsString *path, struct stat *stbuf) +static int v9fs_do_lstat(V9fsState *s, V9fsString *path, struct stat *stbuf) { - return s->ops->lstat(s, path->data, stbuf); + return s->ops->lstat(&s->ctx, path->data, stbuf); } -static int posix_setuid(V9fsState *s, uid_t uid) +static int v9fs_do_setuid(V9fsState *s, uid_t uid) { - return s->ops->setuid(s, uid); + return s->ops->setuid(&s->ctx, uid); } -static ssize_t posix_readlink(V9fsState *s, V9fsString *path, V9fsString *buf) +static ssize_t v9fs_do_readlink(V9fsState *s, V9fsString *path, V9fsString *buf) { ssize_t len; buf->data = qemu_malloc(1024); - len = s->ops->readlink(s, path->data, buf->data, 1024 - 1); + len = s->ops->readlink(&s->ctx, path->data, buf->data, 1024 - 1); if (len > -1) { buf->size = len; buf->data[len] = 0; @@ -47,134 +47,134 @@ static ssize_t posix_readlink(V9fsState *s, V9fsString *path, V9fsString *buf) return len; } -static int posix_close(V9fsState *s, int fd) +static int v9fs_do_close(V9fsState *s, int fd) { - return s->ops->close(s, fd); + return s->ops->close(&s->ctx, fd); } -static int posix_closedir(V9fsState *s, DIR *dir) +static int v9fs_do_closedir(V9fsState *s, DIR *dir) { - return s->ops->closedir(s, dir); + return s->ops->closedir(&s->ctx, dir); } -static int posix_open(V9fsState *s, V9fsString *path, int flags) +static int v9fs_do_open(V9fsState *s, V9fsString *path, int flags) { - return s->ops->open(s, path->data, flags); + return s->ops->open(&s->ctx, path->data, flags); } -static DIR *posix_opendir(V9fsState *s, V9fsString *path) +static DIR *v9fs_do_opendir(V9fsState *s, V9fsString *path) { - return s->ops->opendir(s, path->data); + return s->ops->opendir(&s->ctx, path->data); } -static void posix_rewinddir(V9fsState *s, DIR *dir) +static void v9fs_do_rewinddir(V9fsState *s, DIR *dir) { - return s->ops->rewinddir(s, dir); + return s->ops->rewinddir(&s->ctx, dir); } -static off_t posix_telldir(V9fsState *s, DIR *dir) +static off_t v9fs_do_telldir(V9fsState *s, DIR *dir) { - return s->ops->telldir(s, dir); + return s->ops->telldir(&s->ctx, dir); } -static struct dirent *posix_readdir(V9fsState *s, DIR *dir) +static struct dirent *v9fs_do_readdir(V9fsState *s, DIR *dir) { - return s->ops->readdir(s, dir); + return s->ops->readdir(&s->ctx, dir); } -static void posix_seekdir(V9fsState *s, DIR *dir, off_t off) +static void v9fs_do_seekdir(V9fsState *s, DIR *dir, off_t off) { - return s->ops->seekdir(s, dir, off); + return s->ops->seekdir(&s->ctx, dir, off); } -static int posix_readv(V9fsState *s, int fd, const struct iovec *iov, +static int v9fs_do_readv(V9fsState *s, int fd, const struct iovec *iov, int iovcnt) { - return s->ops->readv(s, fd, iov, iovcnt); + return s->ops->readv(&s->ctx, fd, iov, iovcnt); } -static off_t posix_lseek(V9fsState *s, int fd, off_t offset, int whence) +static off_t v9fs_do_lseek(V9fsState *s, int fd, off_t offset, int whence) { - return s->ops->lseek(s, fd, offset, whence); + return s->ops->lseek(&s->ctx, fd, offset, whence); } -static int posix_writev(V9fsState *s, int fd, const struct iovec *iov, +static int v9fs_do_writev(V9fsState *s, int fd, const struct iovec *iov, int iovcnt) { - return s->ops->writev(s, fd, iov, iovcnt); + return s->ops->writev(&s->ctx, fd, iov, iovcnt); } -static int posix_chmod(V9fsState *s, V9fsString *path, mode_t mode) +static int v9fs_do_chmod(V9fsState *s, V9fsString *path, mode_t mode) { - return s->ops->chmod(s, path->data, mode); + return s->ops->chmod(&s->ctx, path->data, mode); } -static int posix_mknod(V9fsState *s, V9fsString *path, mode_t mode, dev_t dev) +static int v9fs_do_mknod(V9fsState *s, V9fsString *path, mode_t mode, dev_t dev) { - return s->ops->mknod(s, path->data, mode, dev); + return s->ops->mknod(&s->ctx, path->data, mode, dev); } -static int posix_mksock(V9fsState *s, V9fsString *path) +static int v9fs_do_mksock(V9fsState *s, V9fsString *path) { - return s->ops->mksock(s, path->data); + return s->ops->mksock(&s->ctx, path->data); } -static int posix_mkdir(V9fsState *s, V9fsString *path, mode_t mode) +static int v9fs_do_mkdir(V9fsState *s, V9fsString *path, mode_t mode) { - return s->ops->mkdir(s, path->data, mode); + return s->ops->mkdir(&s->ctx, path->data, mode); } -static int posix_fstat(V9fsState *s, int fd, struct stat *stbuf) +static int v9fs_do_fstat(V9fsState *s, int fd, struct stat *stbuf) { - return s->ops->fstat(s, fd, stbuf); + return s->ops->fstat(&s->ctx, fd, stbuf); } -static int posix_open2(V9fsState *s, V9fsString *path, int flags, mode_t mode) +static int v9fs_do_open2(V9fsState *s, V9fsString *path, int flags, mode_t mode) { - return s->ops->open2(s, path->data, flags, mode); + return s->ops->open2(&s->ctx, path->data, flags, mode); } -static int posix_symlink(V9fsState *s, V9fsString *oldpath, +static int v9fs_do_symlink(V9fsState *s, V9fsString *oldpath, V9fsString *newpath) { - return s->ops->symlink(s, oldpath->data, newpath->data); + return s->ops->symlink(&s->ctx, oldpath->data, newpath->data); } -static int posix_link(V9fsState *s, V9fsString *oldpath, V9fsString *newpath) +static int v9fs_do_link(V9fsState *s, V9fsString *oldpath, V9fsString *newpath) { - return s->ops->link(s, oldpath->data, newpath->data); + return s->ops->link(&s->ctx, oldpath->data, newpath->data); } -static int posix_truncate(V9fsState *s, V9fsString *path, off_t size) +static int v9fs_do_truncate(V9fsState *s, V9fsString *path, off_t size) { - return s->ops->truncate(s, path->data, size); + return s->ops->truncate(&s->ctx, path->data, size); } -static int posix_rename(V9fsState *s, V9fsString *oldpath, +static int v9fs_do_rename(V9fsState *s, V9fsString *oldpath, V9fsString *newpath) { - return s->ops->rename(s, oldpath->data, newpath->data); + return s->ops->rename(&s->ctx, oldpath->data, newpath->data); } -static int posix_chown(V9fsState *s, V9fsString *path, uid_t uid, gid_t gid) +static int v9fs_do_chown(V9fsState *s, V9fsString *path, uid_t uid, gid_t gid) { - return s->ops->chown(s, path->data, uid, gid); + return s->ops->chown(&s->ctx, path->data, uid, gid); } -static int posix_utime(V9fsState *s, V9fsString *path, +static int v9fs_do_utime(V9fsState *s, V9fsString *path, const struct utimbuf *buf) { - return s->ops->utime(s, path->data, buf); + return s->ops->utime(&s->ctx, path->data, buf); } -static int posix_remove(V9fsState *s, V9fsString *path) +static int v9fs_do_remove(V9fsState *s, V9fsString *path) { - return s->ops->remove(s, path->data); + return s->ops->remove(&s->ctx, path->data); } -static int posix_fsync(V9fsState *s, int fd) +static int v9fs_do_fsync(V9fsState *s, int fd) { - return s->ops->fsync(s, fd); + return s->ops->fsync(&s->ctx, fd); } static void v9fs_string_init(V9fsString *str) @@ -227,7 +227,7 @@ static V9fsFidState *lookup_fid(V9fsState *s, int32_t fid) for (f = s->fid_list; f; f = f->next) { if (f->fid == fid) { - posix_setuid(s, f->uid); + v9fs_do_setuid(s, f->uid); return f; } } @@ -271,9 +271,9 @@ static int free_fid(V9fsState *s, int32_t fid) *fidpp = fidp->next; if (fidp->fd != -1) - posix_close(s, fidp->fd); + v9fs_do_close(s, fidp->fd); if (fidp->dir) - posix_closedir(s, fidp->dir); + v9fs_do_closedir(s, fidp->dir); v9fs_string_free(&fidp->path); qemu_free(fidp); @@ -325,7 +325,7 @@ static int fid_to_qid(V9fsState *s, V9fsFidState *fidp, V9fsQID *qidp) struct stat stbuf; int err; - err = posix_lstat(s, &fidp->path, &stbuf); + err = v9fs_do_lstat(s, &fidp->path, &stbuf); if (err) { return err; } @@ -683,7 +683,7 @@ static int stat_to_v9stat(V9fsState *s, V9fsString *name, v9fs_string_null(&v9stat->extension); if (v9stat->mode & P9_STAT_MODE_SYMLINK) { - err = posix_readlink(s, name, &v9stat->extension); + err = v9fs_do_readlink(s, name, &v9stat->extension); if (err == -1) { err = -errno; return err; @@ -816,7 +816,7 @@ static void v9fs_stat(V9fsState *s, V9fsPDU *pdu) goto out; } - err = posix_lstat(s, &vs->fidp->path, &vs->stbuf); + err = v9fs_do_lstat(s, &vs->fidp->path, &vs->stbuf); v9fs_stat_post_lstat(s, vs, err); return; @@ -880,7 +880,7 @@ static void v9fs_walk_post_newfid_lstat(V9fsState *s, V9fsWalkState *vs, vs->wnames[vs->name_idx].data); v9fs_string_copy(&vs->newfidp->path, &vs->path); - err = posix_lstat(s, &vs->newfidp->path, &vs->stbuf); + err = v9fs_do_lstat(s, &vs->newfidp->path, &vs->stbuf); v9fs_walk_post_newfid_lstat(s, vs, err); return; } @@ -909,7 +909,7 @@ static void v9fs_walk_post_oldfid_lstat(V9fsState *s, V9fsWalkState *vs, vs->fidp->path.data, vs->wnames[vs->name_idx].data); v9fs_string_copy(&vs->fidp->path, &vs->path); - err = posix_lstat(s, &vs->fidp->path, &vs->stbuf); + err = v9fs_do_lstat(s, &vs->fidp->path, &vs->stbuf); v9fs_walk_post_oldfid_lstat(s, vs, err); return; } @@ -967,7 +967,7 @@ static void v9fs_walk(V9fsState *s, V9fsPDU *pdu) vs->fidp->path.data, vs->wnames[vs->name_idx].data); v9fs_string_copy(&vs->fidp->path, &vs->path); - err = posix_lstat(s, &vs->fidp->path, &vs->stbuf); + err = v9fs_do_lstat(s, &vs->fidp->path, &vs->stbuf); v9fs_walk_post_oldfid_lstat(s, vs, err); return; } @@ -988,7 +988,7 @@ static void v9fs_walk(V9fsState *s, V9fsPDU *pdu) vs->wnames[vs->name_idx].data); v9fs_string_copy(&vs->newfidp->path, &vs->path); - err = posix_lstat(s, &vs->newfidp->path, &vs->stbuf); + err = v9fs_do_lstat(s, &vs->newfidp->path, &vs->stbuf); v9fs_walk_post_newfid_lstat(s, vs, err); return; } @@ -1092,10 +1092,10 @@ static void v9fs_open_post_lstat(V9fsState *s, V9fsOpenState *vs, int err) stat_to_qid(&vs->stbuf, &vs->qid); if (S_ISDIR(vs->stbuf.st_mode)) { - vs->fidp->dir = posix_opendir(s, &vs->fidp->path); + vs->fidp->dir = v9fs_do_opendir(s, &vs->fidp->path); v9fs_open_post_opendir(s, vs, err); } else { - vs->fidp->fd = posix_open(s, &vs->fidp->path, + vs->fidp->fd = v9fs_do_open(s, &vs->fidp->path, omode_to_uflags(vs->mode)); v9fs_open_post_open(s, vs, err); } @@ -1127,7 +1127,7 @@ static void v9fs_open(V9fsState *s, V9fsPDU *pdu) BUG_ON(vs->fidp->fd != -1); BUG_ON(vs->fidp->dir); - err = posix_lstat(s, &vs->fidp->path, &vs->stbuf); + err = v9fs_do_lstat(s, &vs->fidp->path, &vs->stbuf); v9fs_open_post_lstat(s, vs, err); return; @@ -1238,7 +1238,7 @@ static void v9fs_read_post_dir_lstat(V9fsState *s, V9fsReadState *vs, &vs->v9stat); if ((vs->len != (vs->v9stat.size + 2)) || ((vs->count + vs->len) > vs->max_count)) { - posix_seekdir(s, vs->fidp->dir, vs->dir_pos); + v9fs_do_seekdir(s, vs->fidp->dir, vs->dir_pos); v9fs_read_post_seekdir(s, vs, err); return; } @@ -1246,11 +1246,11 @@ static void v9fs_read_post_dir_lstat(V9fsState *s, V9fsReadState *vs, v9fs_stat_free(&vs->v9stat); v9fs_string_free(&vs->name); vs->dir_pos = vs->dent->d_off; - vs->dent = posix_readdir(s, vs->fidp->dir); + vs->dent = v9fs_do_readdir(s, vs->fidp->dir); v9fs_read_post_readdir(s, vs, err); return; out: - posix_seekdir(s, vs->fidp->dir, vs->dir_pos); + v9fs_do_seekdir(s, vs->fidp->dir, vs->dir_pos); v9fs_read_post_seekdir(s, vs, err); return; @@ -1263,7 +1263,7 @@ static void v9fs_read_post_readdir(V9fsState *s, V9fsReadState *vs, ssize_t err) v9fs_string_init(&vs->name); v9fs_string_sprintf(&vs->name, "%s/%s", vs->fidp->path.data, vs->dent->d_name); - err = posix_lstat(s, &vs->name, &vs->stbuf); + err = v9fs_do_lstat(s, &vs->name, &vs->stbuf); v9fs_read_post_dir_lstat(s, vs, err); return; } @@ -1278,7 +1278,7 @@ static void v9fs_read_post_readdir(V9fsState *s, V9fsReadState *vs, ssize_t err) static void v9fs_read_post_telldir(V9fsState *s, V9fsReadState *vs, ssize_t err) { - vs->dent = posix_readdir(s, vs->fidp->dir); + vs->dent = v9fs_do_readdir(s, vs->fidp->dir); v9fs_read_post_readdir(s, vs, err); return; } @@ -1286,7 +1286,7 @@ static void v9fs_read_post_telldir(V9fsState *s, V9fsReadState *vs, ssize_t err) static void v9fs_read_post_rewinddir(V9fsState *s, V9fsReadState *vs, ssize_t err) { - vs->dir_pos = posix_telldir(s, vs->fidp->dir); + vs->dir_pos = v9fs_do_telldir(s, vs->fidp->dir); v9fs_read_post_telldir(s, vs, err); return; } @@ -1305,7 +1305,7 @@ static void v9fs_read_post_readv(V9fsState *s, V9fsReadState *vs, ssize_t err) if (0) { print_sg(vs->sg, vs->cnt); } - vs->len = posix_readv(s, vs->fidp->fd, vs->sg, vs->cnt); + vs->len = v9fs_do_readv(s, vs->fidp->fd, vs->sg, vs->cnt); } while (vs->len == -1 && errno == EINTR); if (vs->len == -1) { err = -errno; @@ -1335,7 +1335,7 @@ static void v9fs_read_post_lseek(V9fsState *s, V9fsReadState *vs, ssize_t err) if (0) { print_sg(vs->sg, vs->cnt); } - vs->len = posix_readv(s, vs->fidp->fd, vs->sg, vs->cnt); + vs->len = v9fs_do_readv(s, vs->fidp->fd, vs->sg, vs->cnt); } while (vs->len == -1 && errno == EINTR); if (vs->len == -1) { err = -errno; @@ -1373,14 +1373,14 @@ static void v9fs_read(V9fsState *s, V9fsPDU *pdu) vs->max_count = vs->count; vs->count = 0; if (vs->off == 0) { - posix_rewinddir(s, vs->fidp->dir); + v9fs_do_rewinddir(s, vs->fidp->dir); } v9fs_read_post_rewinddir(s, vs, err); return; } else if (vs->fidp->fd != -1) { vs->sg = vs->iov; pdu_marshal(vs->pdu, vs->offset + 4, "v", vs->sg, &vs->cnt); - err = posix_lseek(s, vs->fidp->fd, vs->off, SEEK_SET); + err = v9fs_do_lseek(s, vs->fidp->fd, vs->off, SEEK_SET); v9fs_read_post_lseek(s, vs, err); return; } else { @@ -1436,7 +1436,7 @@ static void v9fs_write_post_writev(V9fsState *s, V9fsWriteState *vs, do { if (0) print_sg(vs->sg, vs->cnt); - vs->len = posix_writev(s, vs->fidp->fd, vs->sg, vs->cnt); + vs->len = v9fs_do_writev(s, vs->fidp->fd, vs->sg, vs->cnt); } while (vs->len == -1 && errno == EINTR); if (vs->len == -1) { err = -errno; @@ -1464,7 +1464,7 @@ static void v9fs_write_post_lseek(V9fsState *s, V9fsWriteState *vs, ssize_t err) do { if (0) print_sg(vs->sg, vs->cnt); - vs->len = posix_writev(s, vs->fidp->fd, vs->sg, vs->cnt); + vs->len = v9fs_do_writev(s, vs->fidp->fd, vs->sg, vs->cnt); } while (vs->len == -1 && errno == EINTR); if (vs->len == -1) { err = -errno; @@ -1506,7 +1506,7 @@ static void v9fs_write(V9fsState *s, V9fsPDU *pdu) goto out; } - err = posix_lseek(s, vs->fidp->fd, vs->off, SEEK_SET); + err = v9fs_do_lseek(s, vs->fidp->fd, vs->off, SEEK_SET); v9fs_write_post_lseek(s, vs, err); return; @@ -1572,7 +1572,7 @@ static void v9fs_create_post_dir_lstat(V9fsState *s, V9fsCreateState *vs, goto out; } - vs->fidp->dir = posix_opendir(s, &vs->fullname); + vs->fidp->dir = v9fs_do_opendir(s, &vs->fullname); v9fs_create_post_opendir(s, vs, err); return; @@ -1587,7 +1587,7 @@ static void v9fs_create_post_mkdir(V9fsState *s, V9fsCreateState *vs, int err) goto out; } - err = posix_lstat(s, &vs->fullname, &vs->stbuf); + err = v9fs_do_lstat(s, &vs->fullname, &vs->stbuf); v9fs_create_post_dir_lstat(s, vs, err); return; @@ -1603,7 +1603,7 @@ static void v9fs_create_post_mksock(V9fsState *s, V9fsCreateState *vs, goto out; } - err = posix_chmod(s, &vs->fullname, vs->perm & 0777); + err = v9fs_do_chmod(s, &vs->fullname, vs->perm & 0777); v9fs_create_post_perms(s, vs, err); return; @@ -1629,7 +1629,7 @@ static void v9fs_create_post_open2(V9fsState *s, V9fsCreateState *vs, int err) goto out; } - err = posix_fstat(s, vs->fidp->fd, &vs->stbuf); + err = v9fs_do_fstat(s, vs->fidp->fd, &vs->stbuf); v9fs_create_post_fstat(s, vs, err); return; @@ -1648,10 +1648,10 @@ static void v9fs_create_post_lstat(V9fsState *s, V9fsCreateState *vs, int err) } if (vs->perm & P9_STAT_MODE_DIR) { - err = posix_mkdir(s, &vs->fullname, vs->perm & 0777); + 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 = posix_symlink(s, &vs->extension, &vs->fullname); + 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); @@ -1660,7 +1660,7 @@ static void v9fs_create_post_lstat(V9fsState *s, V9fsCreateState *vs, int err) err = -errno; v9fs_post_create(s, vs, err); } - err = posix_link(s, &nfidp->path, &vs->fullname); + 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; @@ -1686,16 +1686,16 @@ static void v9fs_create_post_lstat(V9fsState *s, V9fsCreateState *vs, int err) } nmode |= vs->perm & 0777; - err = posix_mknod(s, &vs->fullname, nmode, makedev(major, minor)); + 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 = posix_mknod(s, &vs->fullname, S_IFIFO | (vs->mode & 0777), 0); + 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 = posix_mksock(s, &vs->fullname); + err = v9fs_do_mksock(s, &vs->fullname); v9fs_create_post_mksock(s, vs, err); } else { - vs->fidp->fd = posix_open2(s, &vs->fullname, + 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); @@ -1731,7 +1731,7 @@ static void v9fs_create(V9fsState *s, V9fsPDU *pdu) v9fs_string_sprintf(&vs->fullname, "%s/%s", vs->fidp->path.data, vs->name.data); - err = posix_lstat(s, &vs->fullname, &vs->stbuf); + err = v9fs_do_lstat(s, &vs->fullname, &vs->stbuf); v9fs_create_post_lstat(s, vs, err); return; @@ -1791,7 +1791,7 @@ static void v9fs_remove(V9fsState *s, V9fsPDU *pdu) goto out; } - err = posix_remove(s, &vs->fidp->path); + err = v9fs_do_remove(s, &vs->fidp->path); v9fs_remove_post_remove(s, vs, err); return; @@ -1872,7 +1872,7 @@ static void v9fs_wstat_post_rename(V9fsState *s, V9fsWstatState *vs, int err) } if (vs->v9stat.length != -1) { - if (posix_truncate(s, &vs->fidp->path, vs->v9stat.length) < 0) { + if (v9fs_do_truncate(s, &vs->fidp->path, vs->v9stat.length) < 0) { err = -errno; } } @@ -1922,7 +1922,7 @@ static void v9fs_wstat_post_chown(V9fsState *s, V9fsWstatState *vs, int err) vs->nname.size = strlen(new_name); if (strcmp(new_name, vs->fidp->path.data) != 0) { - if (posix_rename(s, &vs->fidp->path, &vs->nname)) { + if (v9fs_do_rename(s, &vs->fidp->path, &vs->nname)) { err = -errno; } else { /* @@ -1965,7 +1965,7 @@ static void v9fs_wstat_post_utime(V9fsState *s, V9fsWstatState *vs, int err) } if (vs->v9stat.n_gid != -1) { - if (posix_chown(s, &vs->fidp->path, vs->v9stat.n_uid, + if (v9fs_do_chown(s, &vs->fidp->path, vs->v9stat.n_uid, vs->v9stat.n_gid)) { err = -errno; } @@ -1989,7 +1989,7 @@ static void v9fs_wstat_post_chmod(V9fsState *s, V9fsWstatState *vs, int err) struct utimbuf tb; tb.actime = 0; tb.modtime = vs->v9stat.mtime; - if (posix_utime(s, &vs->fidp->path, &tb)) { + if (v9fs_do_utime(s, &vs->fidp->path, &tb)) { err = -errno; } } @@ -2054,7 +2054,7 @@ static void v9fs_wstat_post_lstat(V9fsState *s, V9fsWstatState *vs, int err) goto out; } - if (posix_chmod(s, &vs->fidp->path, v9mode_to_mode(vs->v9stat.mode, + if (v9fs_do_chmod(s, &vs->fidp->path, v9mode_to_mode(vs->v9stat.mode, &vs->v9stat.extension))) { err = -errno; } @@ -2087,13 +2087,13 @@ static void v9fs_wstat(V9fsState *s, V9fsPDU *pdu) /* do we need to sync the file? */ if (donttouch_stat(&vs->v9stat)) { - err = posix_fsync(s, vs->fidp->fd); + err = v9fs_do_fsync(s, vs->fidp->fd); v9fs_wstat_post_fsync(s, vs, err); return; } if (vs->v9stat.mode != -1) { - err = posix_lstat(s, &vs->fidp->path, &vs->stbuf); + err = v9fs_do_lstat(s, &vs->fidp->path, &vs->stbuf); v9fs_wstat_post_lstat(s, vs, err); return; } @@ -2243,7 +2243,8 @@ VirtIODevice *virtio_9p_init(DeviceState *dev, V9fsConf *conf) fprintf(stderr, "share path %s is not a directory \n", conf->share_path); exit(1); } - s->fs_root = qemu_strdup(conf->share_path); + + s->ctx.fs_root = qemu_strdup(conf->share_path); len = strlen(conf->tag); if (len > MAX_TAG_LEN) len = MAX_TAG_LEN; @@ -2251,7 +2252,7 @@ VirtIODevice *virtio_9p_init(DeviceState *dev, V9fsConf *conf) s->tag = qemu_malloc(len); memcpy(s->tag, conf->tag, len); s->tag_len = len; - s->uid = -1; + s->ctx.uid = -1; s->ops = virtio_9p_init_local(conf->share_path); s->vdev.get_features = virtio_9p_get_features; diff --git a/hw/virtio-9p.h b/hw/virtio-9p.h index 81c2c59..a249b67 100644 --- a/hw/virtio-9p.h +++ b/hw/virtio-9p.h @@ -6,6 +6,8 @@ #include #include +#include "file-op.h" + /* The feature bitmap for virtio 9P */ /* The mount point is specified in a config variable */ #define VIRTIO_9P_MOUNT_TAG 0 @@ -129,7 +131,6 @@ struct V9fsFidState V9fsFidState *next; }; -struct V9fsPosixFileOpertions ; typedef struct V9fsState { VirtIODevice vdev; @@ -137,9 +138,8 @@ typedef struct V9fsState V9fsPDU pdus[MAX_REQ]; V9fsPDU *free_pdu; V9fsFidState *fid_list; - struct V9fsPosixFileOpertions *ops; - char *fs_root; - uid_t uid; + FileOperations *ops; + FsContext ctx; uint16_t tag_len; uint8_t *tag; size_t config_size; @@ -153,40 +153,7 @@ struct virtio_9p_config uint8_t tag[0]; } __attribute__((packed)); -typedef struct V9fsPosixFileOpertions -{ - int (*lstat)(V9fsState *, const char *, struct stat *); - ssize_t (*readlink)(V9fsState *, const char *, char *, size_t); - int (*chmod)(V9fsState *, const char *, mode_t); - int (*chown)(V9fsState *, const char *, uid_t, gid_t); - int (*mknod)(V9fsState *, const char *, mode_t, dev_t); - int (*mksock)(V9fsState *, const char *); - int (*utime)(V9fsState *, const char *, const struct utimbuf *); - int (*remove)(V9fsState *, const char *); - int (*symlink)(V9fsState *, const char *, const char *); - int (*link)(V9fsState *, const char *, const char *); - int (*setuid)(V9fsState *, uid_t); - int (*close)(V9fsState *, int); - int (*closedir)(V9fsState *, DIR *); - DIR *(*opendir)(V9fsState *, const char *); - int (*open)(V9fsState *, const char *, int); - int (*open2)(V9fsState *, const char *, int, mode_t); - void (*rewinddir)(V9fsState *, DIR *); - off_t (*telldir)(V9fsState *, DIR *); - struct dirent *(*readdir)(V9fsState *, DIR *); - void (*seekdir)(V9fsState *, DIR *, off_t); - ssize_t (*readv)(V9fsState *, int, const struct iovec *, int); - ssize_t (*writev)(V9fsState *, int, const struct iovec *, int); - off_t (*lseek)(V9fsState *, int, off_t, int); - int (*mkdir)(V9fsState *, const char *, mode_t); - int (*fstat)(V9fsState *, int, struct stat *); - int (*rename)(V9fsState *, const char *, const char *); - int (*truncate)(V9fsState *, const char *, off_t); - int (*fsync)(V9fsState *, int); - void *opaque; -} V9fsPosixFileOperations; - -V9fsPosixFileOperations *virtio_9p_init_local(const char *path); +FileOperations *virtio_9p_init_local(const char *path); extern size_t pdu_packunpack(void *addr, struct iovec *sg, int sg_count, size_t offset, size_t size, int pack);