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 <aneesh.kumar@linux.vnet.ibm.com>
+ *
+ * This work is licensed under the terms of the GNU GPL, version 2.  See
+ * the COPYING file in the top-level directory.
+ *
+ */
+#ifndef _FILEOP_H
+#define _FILEOP_H
+#include <sys/types.h>
+#include <dirent.h>
+#include <sys/time.h>
+#include <utime.h>
+#include <sys/stat.h>
+#include <sys/uio.h>
+
+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 <sys/socket.h>
 #include <sys/un.h>
 
-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 <sys/time.h>
 #include <utime.h>
 
+#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);
 
