Merge tag 'for-3.14-merge-window' of git://git.kernel.org/pub/scm/linux/kernel/git/ericvh/v9fs

Pull 9p changes from Eric Van Hensbergen:
 "Included are a new cache model for support of mmap, and several
  cleanups across the filesystem and networking portions of the code"

* tag 'for-3.14-merge-window' of git://git.kernel.org/pub/scm/linux/kernel/git/ericvh/v9fs:
  9p: update documentation
  9P: introduction of a new cache=mmap model.
  net/9p: remove virtio default hack and set appropriate bits instead
  9p: remove useless 'name' variable and assignment
  9p: fix return value in case in v9fs_fid_xattr_set()
  9p: remove useless variable and assignment
  9p: remove useless assignment
  9p: remove unused 'super_block' struct pointer
  9p: remove never used return variable
  9p: remove unused 'p9_fid' struct pointer
  9p: remove unused 'p9_client' struct pointer

14 files changed, 195 insertions, 54 deletions

diff --git a/Documentation/filesystems/9p.txt b/Documentation/filesystems/9p.txt
index 2c0321442845..fec7144e817c 100644
--- a/Documentation/filesystems/9p.txt
+++ b/Documentation/filesystems/9p.txt
@@ -69,10 +69,14 @@ OPTIONS
                 offering several exported file systems.
 
   cache=mode    specifies a caching policy.  By default, no caches are used.
+                        none = default no cache policy, metadata and data
+                                alike are synchronous.
                         loose = no attempts are made at consistency,
                                 intended for exclusive, read-only mounts
-                        fscache = use FS-Cache for a persistent, read-only
+                        fscache = use FS-Cache for a persistent, read-only
                                 cache backend.
+                        mmap = minimal cache that is only used for read-write
+                                mmap.  Northing else is cached, like cache=none
 
   debug=n       specifies debug level.  The debug level is a bitmask.
                         0x01  = display verbose error messages
@@ -147,8 +151,7 @@ on sourceforge (http://sourceforge.net/projects/v9fs).
 News and other information is maintained on a Wiki.
 (http://sf.net/apps/mediawiki/v9fs/index.php).
 
-Bug reports may be issued through the kernel.org bugzilla 
-(http://bugzilla.kernel.org)
+Bug reports are best issued via the mailing list.
 
 For more information on the Plan 9 Operating System check out
 http://plan9.bell-labs.com/plan9
@@ -156,11 +159,3 @@ http://plan9.bell-labs.com/plan9
 For information on Plan 9 from User Space (Plan 9 applications and libraries
 ported to Linux/BSD/OSX/etc) check out http://swtch.com/plan9
 
-
-STATUS
-======
-
-The 2.6 kernel support is working on PPC and x86.
-
-PLEASE USE THE KERNEL BUGZILLA TO REPORT PROBLEMS. (http://bugzilla.kernel.org)
-
diff --git a/fs/9p/cache.c b/fs/9p/cache.c
index 2b7a032c37bc..a69260f27555 100644
--- a/fs/9p/cache.c
+++ b/fs/9p/cache.c
@@ -239,13 +239,12 @@ void v9fs_cache_inode_flush_cookie(struct inode *inode)
 void v9fs_cache_inode_set_cookie(struct inode *inode, struct file *filp)
 {
         struct v9fs_inode *v9inode = V9FS_I(inode);
-        struct p9_fid *fid;
 
         if (!v9inode->fscache)
                 return;
 
         spin_lock(&v9inode->fscache_lock);
-        fid = filp->private_data;
+
         if ((filp->f_flags & O_ACCMODE) != O_RDONLY)
                 v9fs_cache_inode_flush_cookie(inode);
         else
diff --git a/fs/9p/v9fs.c b/fs/9p/v9fs.c
index 08f2e1e9a7e6..14da82564f4e 100644
--- a/fs/9p/v9fs.c
+++ b/fs/9p/v9fs.c
@@ -56,7 +56,7 @@ enum {
         /* Options that take no arguments */
         Opt_nodevmap,
         /* Cache options */
-        Opt_cache_loose, Opt_fscache,
+        Opt_cache_loose, Opt_fscache, Opt_mmap,
         /* Access options */
         Opt_access, Opt_posixacl,
         /* Error token */
@@ -74,6 +74,7 @@ static const match_table_t tokens = {
         {Opt_cache, "cache=%s"},
         {Opt_cache_loose, "loose"},
         {Opt_fscache, "fscache"},
+        {Opt_mmap, "mmap"},
         {Opt_cachetag, "cachetag=%s"},
         {Opt_access, "access=%s"},
         {Opt_posixacl, "posixacl"},
@@ -91,6 +92,9 @@ static int get_cache_mode(char *s)
         } else if (!strcmp(s, "fscache")) {
                 version = CACHE_FSCACHE;
                 p9_debug(P9_DEBUG_9P, "Cache mode: fscache\n");
+        } else if (!strcmp(s, "mmap")) {
+                version = CACHE_MMAP;
+                p9_debug(P9_DEBUG_9P, "Cache mode: mmap\n");
         } else if (!strcmp(s, "none")) {
                 version = CACHE_NONE;
                 p9_debug(P9_DEBUG_9P, "Cache mode: none\n");
@@ -220,6 +224,9 @@ static int v9fs_parse_options(struct v9fs_session_info *v9ses, char *opts)
                 case Opt_fscache:
                         v9ses->cache = CACHE_FSCACHE;
                         break;
+                case Opt_mmap:
+                        v9ses->cache = CACHE_MMAP;
+                        break;
                 case Opt_cachetag:
 #ifdef CONFIG_9P_FSCACHE
                         v9ses->cachetag = match_strdup(&args[0]);
diff --git a/fs/9p/v9fs.h b/fs/9p/v9fs.h
index a8e127c89627..099c7712631c 100644
--- a/fs/9p/v9fs.h
+++ b/fs/9p/v9fs.h
@@ -64,6 +64,7 @@ enum p9_session_flags {
 
 enum p9_cache_modes {
         CACHE_NONE,
+        CACHE_MMAP,
         CACHE_LOOSE,
         CACHE_FSCACHE,
 };
diff --git a/fs/9p/v9fs_vfs.h b/fs/9p/v9fs_vfs.h
index dc95a252523d..b83ebfbf3fdc 100644
--- a/fs/9p/v9fs_vfs.h
+++ b/fs/9p/v9fs_vfs.h
@@ -50,6 +50,8 @@ extern const struct dentry_operations v9fs_dentry_operations;
 extern const struct dentry_operations v9fs_cached_dentry_operations;
 extern const struct file_operations v9fs_cached_file_operations;
 extern const struct file_operations v9fs_cached_file_operations_dotl;
+extern const struct file_operations v9fs_mmap_file_operations;
+extern const struct file_operations v9fs_mmap_file_operations_dotl;
 extern struct kmem_cache *v9fs_inode_cache;
 
 struct inode *v9fs_alloc_inode(struct super_block *sb);
diff --git a/fs/9p/vfs_addr.c b/fs/9p/vfs_addr.c
index 9ff073f4090a..c71e88602ff4 100644
--- a/fs/9p/vfs_addr.c
+++ b/fs/9p/vfs_addr.c
@@ -202,6 +202,8 @@ static int v9fs_vfs_writepage(struct page *page, struct writeback_control *wbc)
 {
         int retval;
 
+        p9_debug(P9_DEBUG_VFS, "page %p\n", page);
+
         retval = v9fs_vfs_writepage_locked(page);
         if (retval < 0) {
                 if (retval == -EAGAIN) {
@@ -282,6 +284,9 @@ static int v9fs_write_begin(struct file *filp, struct address_space *mapping,
         pgoff_t index = pos >> PAGE_CACHE_SHIFT;
         struct inode *inode = mapping->host;
 
+
+        p9_debug(P9_DEBUG_VFS, "filp %p, mapping %p\n", filp, mapping);
+
         v9inode = V9FS_I(inode);
 start:
         page = grab_cache_page_write_begin(mapping, index, flags);
@@ -312,6 +317,8 @@ static int v9fs_write_end(struct file *filp, struct address_space *mapping,
         loff_t last_pos = pos + copied;
         struct inode *inode = page->mapping->host;
 
+        p9_debug(P9_DEBUG_VFS, "filp %p, mapping %p\n", filp, mapping);
+
         if (unlikely(copied < len)) {
                 /*
                  * zero out the rest of the area
diff --git a/fs/9p/vfs_file.c b/fs/9p/vfs_file.c
index a0df3e73c2b1..a16b0ff497ca 100644
--- a/fs/9p/vfs_file.c
+++ b/fs/9p/vfs_file.c
@@ -45,6 +45,7 @@
 #include "cache.h"
 
 static const struct vm_operations_struct v9fs_file_vm_ops;
+static const struct vm_operations_struct v9fs_mmap_file_vm_ops;
 
 /**
  * v9fs_file_open - open a file (or directory)
@@ -87,7 +88,8 @@ int v9fs_file_open(struct inode *inode, struct file *file)
 
         file->private_data = fid;
         mutex_lock(&v9inode->v_mutex);
-        if (v9ses->cache && !v9inode->writeback_fid &&
+        if ((v9ses->cache == CACHE_LOOSE || v9ses->cache == CACHE_FSCACHE) &&
+            !v9inode->writeback_fid &&
             ((file->f_flags & O_ACCMODE) != O_RDONLY)) {
                 /*
                  * clone a fid and add it to writeback_fid
@@ -105,7 +107,7 @@ int v9fs_file_open(struct inode *inode, struct file *file)
                 v9inode->writeback_fid = (void *) fid;
         }
         mutex_unlock(&v9inode->v_mutex);
-        if (v9ses->cache)
+        if (v9ses->cache == CACHE_LOOSE || v9ses->cache == CACHE_FSCACHE)
                 v9fs_cache_inode_set_cookie(inode, file);
         return 0;
 out_error:
@@ -461,14 +463,12 @@ v9fs_file_write_internal(struct inode *inode, struct p9_fid *fid,
         int n;
         loff_t i_size;
         size_t total = 0;
-        struct p9_client *clnt;
         loff_t origin = *offset;
         unsigned long pg_start, pg_end;
 
         p9_debug(P9_DEBUG_VFS, "data %p count %d offset %x\n",
                  data, (int)count, (int)*offset);
 
-        clnt = fid->clnt;
         do {
                 n = p9_client_write(fid, NULL, data+total, origin+total, count);
                 if (n <= 0)
@@ -581,11 +581,12 @@ int v9fs_file_fsync_dotl(struct file *filp, loff_t start, loff_t end,
 }
 
 static int
-v9fs_file_mmap(struct file *file, struct vm_area_struct *vma)
+v9fs_file_mmap(struct file *filp, struct vm_area_struct *vma)
 {
         int retval;
 
-        retval = generic_file_mmap(file, vma);
+
+        retval = generic_file_mmap(filp, vma);
         if (!retval)
                 vma->vm_ops = &v9fs_file_vm_ops;
 
@@ -593,6 +594,43 @@ v9fs_file_mmap(struct file *file, struct vm_area_struct *vma)
 }
 
 static int
+v9fs_mmap_file_mmap(struct file *filp, struct vm_area_struct *vma)
+{
+        int retval;
+        struct inode *inode;
+        struct v9fs_inode *v9inode;
+        struct p9_fid *fid;
+
+        inode = file_inode(filp);
+        v9inode = V9FS_I(inode);
+        mutex_lock(&v9inode->v_mutex);
+        if (!v9inode->writeback_fid &&
+            (vma->vm_flags & VM_WRITE)) {
+                /*
+                 * clone a fid and add it to writeback_fid
+                 * we do it during mmap instead of
+                 * page dirty time via write_begin/page_mkwrite
+                 * because we want write after unlink usecase
+                 * to work.
+                 */
+                fid = v9fs_writeback_fid(filp->f_path.dentry);
+                if (IS_ERR(fid)) {
+                        retval = PTR_ERR(fid);
+                        mutex_unlock(&v9inode->v_mutex);
+                        return retval;
+                }
+                v9inode->writeback_fid = (void *) fid;
+        }
+        mutex_unlock(&v9inode->v_mutex);
+
+        retval = generic_file_mmap(filp, vma);
+        if (!retval)
+                vma->vm_ops = &v9fs_mmap_file_vm_ops;
+
+        return retval;
+}
+
+static int
 v9fs_vm_page_mkwrite(struct vm_area_struct *vma, struct vm_fault *vmf)
 {
         struct v9fs_inode *v9inode;
@@ -660,6 +698,22 @@ v9fs_cached_file_read(struct file *filp, char __user *data, size_t count,
         return do_sync_read(filp, data, count, offset);
 }
 
+/**
+ * v9fs_mmap_file_read - read from a file
+ * @filp: file pointer to read
+ * @udata: user data buffer to read data into
+ * @count: size of buffer
+ * @offset: offset at which to read data
+ *
+ */
+static ssize_t
+v9fs_mmap_file_read(struct file *filp, char __user *data, size_t count,
+                      loff_t *offset)
+{
+        /* TODO: Check if there are dirty pages */
+        return v9fs_file_read(filp, data, count, offset);
+}
+
 static ssize_t
 v9fs_direct_write(struct file *filp, const char __user * data,
                   size_t count, loff_t *offsetp)
@@ -730,12 +784,65 @@ v9fs_cached_file_write(struct file *filp, const char __user * data,
         return do_sync_write(filp, data, count, offset);
 }
 
+
+/**
+ * v9fs_mmap_file_write - write to a file
+ * @filp: file pointer to write
+ * @data: data buffer to write data from
+ * @count: size of buffer
+ * @offset: offset at which to write data
+ *
+ */
+static ssize_t
+v9fs_mmap_file_write(struct file *filp, const char __user *data,
+                       size_t count, loff_t *offset)
+{
+        /*
+         * TODO: invalidate mmaps on filp's inode between
+         * offset and offset+count
+         */
+        return v9fs_file_write(filp, data, count, offset);
+}
+
+static void v9fs_mmap_vm_close(struct vm_area_struct *vma)
+{
+        struct inode *inode;
+
+        struct writeback_control wbc = {
+                .nr_to_write = LONG_MAX,
+                .sync_mode = WB_SYNC_ALL,
+                .range_start = vma->vm_pgoff * PAGE_SIZE,
+                 /* absolute end, byte at end included */
+                .range_end = vma->vm_pgoff * PAGE_SIZE +
+                        (vma->vm_end - vma->vm_start - 1),
+        };
+
+
+        p9_debug(P9_DEBUG_VFS, "9p VMA close, %p, flushing", vma);
+
+        inode = file_inode(vma->vm_file);
+
+        if (!mapping_cap_writeback_dirty(inode->i_mapping))
+                wbc.nr_to_write = 0;
+
+        might_sleep();
+        sync_inode(inode, &wbc);
+}
+
+
 static const struct vm_operations_struct v9fs_file_vm_ops = {
         .fault = filemap_fault,
         .page_mkwrite = v9fs_vm_page_mkwrite,
         .remap_pages = generic_file_remap_pages,
 };
 
+static const struct vm_operations_struct v9fs_mmap_file_vm_ops = {
+        .close = v9fs_mmap_vm_close,
+        .fault = filemap_fault,
+        .page_mkwrite = v9fs_vm_page_mkwrite,
+        .remap_pages = generic_file_remap_pages,
+};
+
 
 const struct file_operations v9fs_cached_file_operations = {
         .llseek = generic_file_llseek,
@@ -786,3 +893,26 @@ const struct file_operations v9fs_file_operations_dotl = {
         .mmap = generic_file_readonly_mmap,
         .fsync = v9fs_file_fsync_dotl,
 };
+
+const struct file_operations v9fs_mmap_file_operations = {
+        .llseek = generic_file_llseek,
+        .read = v9fs_mmap_file_read,
+        .write = v9fs_mmap_file_write,
+        .open = v9fs_file_open,
+        .release = v9fs_dir_release,
+        .lock = v9fs_file_lock,
+        .mmap = v9fs_mmap_file_mmap,
+        .fsync = v9fs_file_fsync,
+};
+
+const struct file_operations v9fs_mmap_file_operations_dotl = {
+        .llseek = generic_file_llseek,
+        .read = v9fs_mmap_file_read,
+        .write = v9fs_mmap_file_write,
+        .open = v9fs_file_open,
+        .release = v9fs_dir_release,
+        .lock = v9fs_file_lock_dotl,
+        .flock = v9fs_file_flock_dotl,
+        .mmap = v9fs_mmap_file_mmap,
+        .fsync = v9fs_file_fsync_dotl,
+};
diff --git a/fs/9p/vfs_inode.c b/fs/9p/vfs_inode.c
index 4e65aa903345..bb7991c7e5c7 100644
--- a/fs/9p/vfs_inode.c
+++ b/fs/9p/vfs_inode.c
@@ -299,15 +299,22 @@ int v9fs_init_inode(struct v9fs_session_info *v9ses,
         case S_IFREG:
                 if (v9fs_proto_dotl(v9ses)) {
                         inode->i_op = &v9fs_file_inode_operations_dotl;
-                        if (v9ses->cache)
+                        if (v9ses->cache == CACHE_LOOSE ||
+                            v9ses->cache == CACHE_FSCACHE)
                                 inode->i_fop =
                                         &v9fs_cached_file_operations_dotl;
+                        else if (v9ses->cache == CACHE_MMAP)
+                                inode->i_fop = &v9fs_mmap_file_operations_dotl;
                         else
                                 inode->i_fop = &v9fs_file_operations_dotl;
                 } else {
                         inode->i_op = &v9fs_file_inode_operations;
-                        if (v9ses->cache)
-                                inode->i_fop = &v9fs_cached_file_operations;
+                        if (v9ses->cache == CACHE_LOOSE ||
+                            v9ses->cache == CACHE_FSCACHE)
+                                inode->i_fop =
+                                        &v9fs_cached_file_operations;
+                        else if (v9ses->cache == CACHE_MMAP)
+                                inode->i_fop = &v9fs_mmap_file_operations;
                         else
                                 inode->i_fop = &v9fs_file_operations;
                 }
@@ -779,7 +786,6 @@ struct dentry *v9fs_vfs_lookup(struct inode *dir, struct dentry *dentry,
                                       unsigned int flags)
 {
         struct dentry *res;
-        struct super_block *sb;
         struct v9fs_session_info *v9ses;
         struct p9_fid *dfid, *fid;
         struct inode *inode;
@@ -791,7 +797,6 @@ struct dentry *v9fs_vfs_lookup(struct inode *dir, struct dentry *dentry,
         if (dentry->d_name.len > NAME_MAX)
                 return ERR_PTR(-ENAMETOOLONG);
 
-        sb = dir->i_sb;
         v9ses = v9fs_inode2v9ses(dir);
         /* We can walk d_parent because we hold the dir->i_mutex */
         dfid = v9fs_fid_lookup(dentry->d_parent);
@@ -812,7 +817,7 @@ struct dentry *v9fs_vfs_lookup(struct inode *dir, struct dentry *dentry,
          * unlink. For cached mode create calls request for new
          * inode. But with cache disabled, lookup should do this.
          */
-        if (v9ses->cache)
+        if (v9ses->cache == CACHE_LOOSE || v9ses->cache == CACHE_FSCACHE)
                 inode = v9fs_get_inode_from_fid(v9ses, fid, dir->i_sb);
         else
                 inode = v9fs_get_new_inode_from_fid(v9ses, fid, dir->i_sb);
@@ -863,7 +868,7 @@ v9fs_vfs_atomic_open(struct inode *dir, struct dentry *dentry,
                 return finish_no_open(file, res);
 
         err = 0;
-        fid = NULL;
+
         v9ses = v9fs_inode2v9ses(dir);
         perm = unixmode2p9mode(v9ses, mode);
         fid = v9fs_create(v9ses, dir, dentry, NULL, perm,
@@ -878,7 +883,8 @@ v9fs_vfs_atomic_open(struct inode *dir, struct dentry *dentry,
         v9fs_invalidate_inode_attr(dir);
         v9inode = V9FS_I(dentry->d_inode);
         mutex_lock(&v9inode->v_mutex);
-        if (v9ses->cache && !v9inode->writeback_fid &&
+        if ((v9ses->cache == CACHE_LOOSE || v9ses->cache == CACHE_FSCACHE) &&
+            !v9inode->writeback_fid &&
             ((flags & O_ACCMODE) != O_RDONLY)) {
                 /*
                  * clone a fid and add it to writeback_fid
@@ -901,7 +907,7 @@ v9fs_vfs_atomic_open(struct inode *dir, struct dentry *dentry,
                 goto error;
 
         file->private_data = fid;
-        if (v9ses->cache)
+        if (v9ses->cache == CACHE_LOOSE || v9ses->cache == CACHE_FSCACHE)
                 v9fs_cache_inode_set_cookie(dentry->d_inode, file);
 
         *opened |= FILE_CREATED;
@@ -1479,7 +1485,7 @@ int v9fs_refresh_inode(struct p9_fid *fid, struct inode *inode)
          */
         i_size = inode->i_size;
         v9fs_stat2inode(st, inode, inode->i_sb);
-        if (v9ses->cache)
+        if (v9ses->cache == CACHE_LOOSE || v9ses->cache == CACHE_FSCACHE)
                 inode->i_size = i_size;
         spin_unlock(&inode->i_lock);
 out:
diff --git a/fs/9p/vfs_inode_dotl.c b/fs/9p/vfs_inode_dotl.c
index 4c10edec26a0..59dc8e87647f 100644
--- a/fs/9p/vfs_inode_dotl.c
+++ b/fs/9p/vfs_inode_dotl.c
@@ -330,7 +330,8 @@ v9fs_vfs_atomic_open_dotl(struct inode *dir, struct dentry *dentry,
 
         v9inode = V9FS_I(inode);
         mutex_lock(&v9inode->v_mutex);
-        if (v9ses->cache && !v9inode->writeback_fid &&
+        if ((v9ses->cache == CACHE_LOOSE || v9ses->cache == CACHE_FSCACHE) &&
+            !v9inode->writeback_fid &&
             ((flags & O_ACCMODE) != O_RDONLY)) {
                 /*
                  * clone a fid and add it to writeback_fid
@@ -353,7 +354,7 @@ v9fs_vfs_atomic_open_dotl(struct inode *dir, struct dentry *dentry,
         if (err)
                 goto err_clunk_old_fid;
         file->private_data = ofid;
-        if (v9ses->cache)
+        if (v9ses->cache == CACHE_LOOSE || v9ses->cache == CACHE_FSCACHE)
                 v9fs_cache_inode_set_cookie(inode, file);
         *opened |= FILE_CREATED;
 out:
@@ -473,13 +474,11 @@ static int
 v9fs_vfs_getattr_dotl(struct vfsmount *mnt, struct dentry *dentry,
                  struct kstat *stat)
 {
-        int err;
         struct v9fs_session_info *v9ses;
         struct p9_fid *fid;
         struct p9_stat_dotl *st;
 
         p9_debug(P9_DEBUG_VFS, "dentry: %p\n", dentry);
-        err = -EPERM;
         v9ses = v9fs_dentry2v9ses(dentry);
         if (v9ses->cache == CACHE_LOOSE || v9ses->cache == CACHE_FSCACHE) {
                 generic_fillattr(dentry->d_inode, stat);
@@ -556,7 +555,6 @@ static int v9fs_mapped_iattr_valid(int iattr_valid)
 int v9fs_vfs_setattr_dotl(struct dentry *dentry, struct iattr *iattr)
 {
         int retval;
-        struct v9fs_session_info *v9ses;
         struct p9_fid *fid;
         struct p9_iattr_dotl p9attr;
         struct inode *inode = dentry->d_inode;
@@ -577,8 +575,6 @@ int v9fs_vfs_setattr_dotl(struct dentry *dentry, struct iattr *iattr)
         p9attr.mtime_sec = iattr->ia_mtime.tv_sec;
         p9attr.mtime_nsec = iattr->ia_mtime.tv_nsec;
 
-        retval = -EPERM;
-        v9ses = v9fs_dentry2v9ses(dentry);
         fid = v9fs_fid_lookup(dentry);
         if (IS_ERR(fid))
                 return PTR_ERR(fid);
@@ -715,7 +711,7 @@ v9fs_vfs_symlink_dotl(struct inode *dir, struct dentry *dentry,
         }
 
         v9fs_invalidate_inode_attr(dir);
-        if (v9ses->cache) {
+        if (v9ses->cache == CACHE_LOOSE || v9ses->cache == CACHE_FSCACHE) {
                 /* Now walk from the parent so we can get an unopened fid. */
                 fid = p9_client_walk(dfid, 1, &name, 1);
                 if (IS_ERR(fid)) {
@@ -768,7 +764,6 @@ v9fs_vfs_link_dotl(struct dentry *old_dentry, struct inode *dir,
                 struct dentry *dentry)
 {
         int err;
-        char *name;
         struct dentry *dir_dentry;
         struct p9_fid *dfid, *oldfid;
         struct v9fs_session_info *v9ses;
@@ -786,8 +781,6 @@ v9fs_vfs_link_dotl(struct dentry *old_dentry, struct inode *dir,
         if (IS_ERR(oldfid))
                 return PTR_ERR(oldfid);
 
-        name = (char *) dentry->d_name.name;
-
         err = p9_client_link(dfid, oldfid, (char *)dentry->d_name.name);
 
         if (err < 0) {
@@ -973,7 +966,7 @@ int v9fs_refresh_inode_dotl(struct p9_fid *fid, struct inode *inode)
          */
         i_size = inode->i_size;
         v9fs_stat2inode_dotl(st, inode);
-        if (v9ses->cache)
+        if (v9ses->cache == CACHE_LOOSE || v9ses->cache == CACHE_FSCACHE)
                 inode->i_size = i_size;
         spin_unlock(&inode->i_lock);
 out:
diff --git a/fs/9p/vfs_super.c b/fs/9p/vfs_super.c
index 2756dcd5de6e..0afd0382822b 100644
--- a/fs/9p/vfs_super.c
+++ b/fs/9p/vfs_super.c
@@ -144,7 +144,7 @@ static struct dentry *v9fs_mount(struct file_system_type *fs_type, int flags,
         }
         v9fs_fill_super(sb, v9ses, flags, data);
 
-        if (v9ses->cache)
+        if (v9ses->cache == CACHE_LOOSE || v9ses->cache == CACHE_FSCACHE)
                 sb->s_d_op = &v9fs_cached_dentry_operations;
         else
                 sb->s_d_op = &v9fs_dentry_operations;
@@ -282,7 +282,7 @@ static int v9fs_drop_inode(struct inode *inode)
 {
         struct v9fs_session_info *v9ses;
         v9ses = v9fs_inode2v9ses(inode);
-        if (v9ses->cache)
+        if (v9ses->cache == CACHE_LOOSE || v9ses->cache == CACHE_FSCACHE)
                 return generic_drop_inode(inode);
         /*
          * in case of non cached mode always drop the
@@ -325,10 +325,12 @@ static int v9fs_write_inode_dotl(struct inode *inode,
          * send an fsync request to server irrespective of
          * wbc->sync_mode.
          */
-        p9_debug(P9_DEBUG_VFS, "%s: inode %p\n", __func__, inode);
         v9inode = V9FS_I(inode);
+        p9_debug(P9_DEBUG_VFS, "%s: inode %p, writeback_fid %p\n",
+                 __func__, inode, v9inode->writeback_fid);
         if (!v9inode->writeback_fid)
                 return 0;
+
         ret = p9_client_fsync(v9inode->writeback_fid, 0);
         if (ret < 0) {
                 __mark_inode_dirty(inode, I_DIRTY_DATASYNC);
diff --git a/fs/9p/xattr.c b/fs/9p/xattr.c
index 3c28cdfb8c47..04133a1fd9cb 100644
--- a/fs/9p/xattr.c
+++ b/fs/9p/xattr.c
@@ -138,8 +138,7 @@ int v9fs_fid_xattr_set(struct p9_fid *fid, const char *name,
         if (retval < 0) {
                 p9_debug(P9_DEBUG_VFS, "p9_client_xattrcreate failed %d\n",
                          retval);
-                p9_client_clunk(fid);
-                return retval;
+                goto err;
         }
         msize = fid->clnt->msize;
         while (value_len) {
@@ -152,12 +151,15 @@ int v9fs_fid_xattr_set(struct p9_fid *fid, const char *name,
                 if (write_count < 0) {
                         /* error in xattr write */
                         retval = write_count;
-                        break;
+                        goto err;
                 }
                 offset += write_count;
                 value_len -= write_count;
         }
-        return p9_client_clunk(fid);
+        retval = offset;
+err:
+        p9_client_clunk(fid);
+        return retval;
 }
 
 ssize_t v9fs_listxattr(struct dentry *dentry, char *buffer, size_t buffer_size)
diff --git a/net/9p/client.c b/net/9p/client.c
index ee8fd6bd4035..a5e4d2dcb03e 100644
--- a/net/9p/client.c
+++ b/net/9p/client.c
@@ -1012,9 +1012,6 @@ struct p9_client *p9_client_create(const char *dev_name, char *options)
                 goto destroy_tagpool;
 
         if (!clnt->trans_mod)
-                clnt->trans_mod = v9fs_get_trans_by_name("virtio");
-
-        if (!clnt->trans_mod)
                 clnt->trans_mod = v9fs_get_default_trans();
 
         if (clnt->trans_mod == NULL) {
diff --git a/net/9p/trans_fd.c b/net/9p/trans_fd.c
index 9321a7763067..b7bd7f2961bf 100644
--- a/net/9p/trans_fd.c
+++ b/net/9p/trans_fd.c
@@ -1048,7 +1048,7 @@ p9_fd_create(struct p9_client *client, const char *addr, char *args)
 static struct p9_trans_module p9_tcp_trans = {
         .name = "tcp",
         .maxsize = MAX_SOCK_BUF,
-        .def = 1,
+        .def = 0,
         .create = p9_fd_create_tcp,
         .close = p9_fd_close,
         .request = p9_fd_request,
diff --git a/net/9p/trans_virtio.c b/net/9p/trans_virtio.c
index 9c5a1aa34d12..cd1e1ede73a4 100644
--- a/net/9p/trans_virtio.c
+++ b/net/9p/trans_virtio.c
@@ -698,7 +698,7 @@ static struct p9_trans_module p9_virtio_trans = {
          * page in zero copy.
          */
         .maxsize = PAGE_SIZE * (VIRTQUEUE_NUM - 3),
-        .def = 0,
+        .def = 1,
         .owner = THIS_MODULE,
 };