]> git.openfabrics.org - ~shefty/rdma-dev.git/commitdiff
Merge branch 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/ericvh...
authorLinus Torvalds <torvalds@linux-foundation.org>
Sat, 23 Jul 2011 17:58:49 +0000 (10:58 -0700)
committerLinus Torvalds <torvalds@linux-foundation.org>
Sat, 23 Jul 2011 17:58:49 +0000 (10:58 -0700)
* 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/ericvh/v9fs:
  net/9p: Fix the msize calculation.
  fs/9p: add 9P2000.L unlinkat operation
  fs/9p: add 9P2000.L renameat operation
  fs/9p: Always ask new inode in create
  fs/9p: Clean-up get_protocol_version() to use strcmp
  fs/9p: Fix invalid mount options/args
  fs/9p: When doing inode lookup compare qid details and inode mode bits.
  fs/9p: Fid is not valid after a failed clunk.
  net/9p: Remove structure not used in the code
  VirtIO can transfer VIRTQUEUE_NUM of pages.
  Fix the size of receive buffer packing onto VirtIO ring.
  9p: clean up packet dump code
  fs/9p: remove rename work around in 9p
  net/9p: fix client code to fail more gracefully on protocol error

13 files changed:
fs/9p/cache.c
fs/9p/cache.h
fs/9p/v9fs.c
fs/9p/v9fs.h
fs/9p/vfs_inode.c
fs/9p/vfs_inode_dotl.c
include/net/9p/9p.h
include/net/9p/client.h
include/net/9p/transport.h
net/9p/client.c
net/9p/mod.c
net/9p/protocol.c
net/9p/trans_virtio.c

index 5b335c5086a1011d7b9e301ac1b52c9d4d3ba7ea..945aa5f02f9beb9786d8033b3d79d141071cdca0 100644 (file)
@@ -108,11 +108,10 @@ static uint16_t v9fs_cache_inode_get_key(const void *cookie_netfs_data,
                                         void *buffer, uint16_t bufmax)
 {
        const struct v9fs_inode *v9inode = cookie_netfs_data;
-       memcpy(buffer, &v9inode->fscache_key->path,
-              sizeof(v9inode->fscache_key->path));
+       memcpy(buffer, &v9inode->qid.path, sizeof(v9inode->qid.path));
        P9_DPRINTK(P9_DEBUG_FSC, "inode %p get key %llu", &v9inode->vfs_inode,
-                  v9inode->fscache_key->path);
-       return sizeof(v9inode->fscache_key->path);
+                  v9inode->qid.path);
+       return sizeof(v9inode->qid.path);
 }
 
 static void v9fs_cache_inode_get_attr(const void *cookie_netfs_data,
@@ -129,11 +128,10 @@ static uint16_t v9fs_cache_inode_get_aux(const void *cookie_netfs_data,
                                         void *buffer, uint16_t buflen)
 {
        const struct v9fs_inode *v9inode = cookie_netfs_data;
-       memcpy(buffer, &v9inode->fscache_key->version,
-              sizeof(v9inode->fscache_key->version));
+       memcpy(buffer, &v9inode->qid.version, sizeof(v9inode->qid.version));
        P9_DPRINTK(P9_DEBUG_FSC, "inode %p get aux %u", &v9inode->vfs_inode,
-                  v9inode->fscache_key->version);
-       return sizeof(v9inode->fscache_key->version);
+                  v9inode->qid.version);
+       return sizeof(v9inode->qid.version);
 }
 
 static enum
@@ -143,11 +141,11 @@ fscache_checkaux v9fs_cache_inode_check_aux(void *cookie_netfs_data,
 {
        const struct v9fs_inode *v9inode = cookie_netfs_data;
 
-       if (buflen != sizeof(v9inode->fscache_key->version))
+       if (buflen != sizeof(v9inode->qid.version))
                return FSCACHE_CHECKAUX_OBSOLETE;
 
-       if (memcmp(buffer, &v9inode->fscache_key->version,
-                  sizeof(v9inode->fscache_key->version)))
+       if (memcmp(buffer, &v9inode->qid.version,
+                  sizeof(v9inode->qid.version)))
                return FSCACHE_CHECKAUX_OBSOLETE;
 
        return FSCACHE_CHECKAUX_OKAY;
index 049507a5b01c39985fb3a4626aecfbb7fb3c1a64..40cc54ced5d97621b81bc96ab8b90f3644f72a4e 100644 (file)
@@ -93,15 +93,6 @@ static inline void v9fs_uncache_page(struct inode *inode, struct page *page)
        BUG_ON(PageFsCache(page));
 }
 
-static inline void v9fs_fscache_set_key(struct inode *inode,
-                                       struct p9_qid *qid)
-{
-       struct v9fs_inode *v9inode = V9FS_I(inode);
-       spin_lock(&v9inode->fscache_lock);
-       v9inode->fscache_key = qid;
-       spin_unlock(&v9inode->fscache_lock);
-}
-
 static inline void v9fs_fscache_wait_on_page_write(struct inode *inode,
                                                   struct page *page)
 {
index c82b017f51f3658bd22513c88c11b598b8e67cb0..ef96618861129ea023f6d9b4e0b77c65b452b997 100644 (file)
@@ -78,6 +78,25 @@ static const match_table_t tokens = {
        {Opt_err, NULL}
 };
 
+/* Interpret mount options for cache mode */
+static int get_cache_mode(char *s)
+{
+       int version = -EINVAL;
+
+       if (!strcmp(s, "loose")) {
+               version = CACHE_LOOSE;
+               P9_DPRINTK(P9_DEBUG_9P, "Cache mode: loose\n");
+       } else if (!strcmp(s, "fscache")) {
+               version = CACHE_FSCACHE;
+               P9_DPRINTK(P9_DEBUG_9P, "Cache mode: fscache\n");
+       } else if (!strcmp(s, "none")) {
+               version = CACHE_NONE;
+               P9_DPRINTK(P9_DEBUG_9P, "Cache mode: none\n");
+       } else
+               printk(KERN_INFO "9p: Unknown Cache mode %s.\n", s);
+       return version;
+}
+
 /**
  * v9fs_parse_options - parse mount options into session structure
  * @v9ses: existing v9fs session information
@@ -97,7 +116,7 @@ static int v9fs_parse_options(struct v9fs_session_info *v9ses, char *opts)
        /* setup defaults */
        v9ses->afid = ~0;
        v9ses->debug = 0;
-       v9ses->cache = 0;
+       v9ses->cache = CACHE_NONE;
 #ifdef CONFIG_9P_FSCACHE
        v9ses->cachetag = NULL;
 #endif
@@ -171,13 +190,13 @@ static int v9fs_parse_options(struct v9fs_session_info *v9ses, char *opts)
                                  "problem allocating copy of cache arg\n");
                                goto free_and_return;
                        }
+                       ret = get_cache_mode(s);
+                       if (ret == -EINVAL) {
+                               kfree(s);
+                               goto free_and_return;
+                       }
 
-                       if (strcmp(s, "loose") == 0)
-                               v9ses->cache = CACHE_LOOSE;
-                       else if (strcmp(s, "fscache") == 0)
-                               v9ses->cache = CACHE_FSCACHE;
-                       else
-                               v9ses->cache = CACHE_NONE;
+                       v9ses->cache = ret;
                        kfree(s);
                        break;
 
@@ -200,9 +219,15 @@ static int v9fs_parse_options(struct v9fs_session_info *v9ses, char *opts)
                        } else {
                                v9ses->flags |= V9FS_ACCESS_SINGLE;
                                v9ses->uid = simple_strtoul(s, &e, 10);
-                               if (*e != '\0')
-                                       v9ses->uid = ~0;
+                               if (*e != '\0') {
+                                       ret = -EINVAL;
+                                       printk(KERN_INFO "9p: Unknown access "
+                                                       "argument %s.\n", s);
+                                       kfree(s);
+                                       goto free_and_return;
+                               }
                        }
+
                        kfree(s);
                        break;
 
@@ -487,8 +512,8 @@ static void v9fs_inode_init_once(void *foo)
        struct v9fs_inode *v9inode = (struct v9fs_inode *)foo;
 #ifdef CONFIG_9P_FSCACHE
        v9inode->fscache = NULL;
-       v9inode->fscache_key = NULL;
 #endif
+       memset(&v9inode->qid, 0, sizeof(v9inode->qid));
        inode_init_once(&v9inode->vfs_inode);
 }
 
index e5ebedfc5ed8d345e366cd1482978a2ff2f2e4ae..e78956cbd7021c81a50d7bd6e9220ffa9623bb22 100644 (file)
@@ -125,8 +125,8 @@ struct v9fs_inode {
 #ifdef CONFIG_9P_FSCACHE
        spinlock_t fscache_lock;
        struct fscache_cookie *fscache;
-       struct p9_qid *fscache_key;
 #endif
+       struct p9_qid qid;
        unsigned int cache_validity;
        struct p9_fid *writeback_fid;
        struct mutex v_mutex;
@@ -153,13 +153,13 @@ extern void v9fs_vfs_put_link(struct dentry *dentry, struct nameidata *nd,
                        void *p);
 extern struct inode *v9fs_inode_from_fid(struct v9fs_session_info *v9ses,
                                         struct p9_fid *fid,
-                                        struct super_block *sb);
+                                        struct super_block *sb, int new);
 extern const struct inode_operations v9fs_dir_inode_operations_dotl;
 extern const struct inode_operations v9fs_file_inode_operations_dotl;
 extern const struct inode_operations v9fs_symlink_inode_operations_dotl;
 extern struct inode *v9fs_inode_from_fid_dotl(struct v9fs_session_info *v9ses,
                                              struct p9_fid *fid,
-                                             struct super_block *sb);
+                                             struct super_block *sb, int new);
 
 /* other default globals */
 #define V9FS_PORT      564
@@ -201,8 +201,27 @@ v9fs_get_inode_from_fid(struct v9fs_session_info *v9ses, struct p9_fid *fid,
                        struct super_block *sb)
 {
        if (v9fs_proto_dotl(v9ses))
-               return v9fs_inode_from_fid_dotl(v9ses, fid, sb);
+               return v9fs_inode_from_fid_dotl(v9ses, fid, sb, 0);
        else
-               return v9fs_inode_from_fid(v9ses, fid, sb);
+               return v9fs_inode_from_fid(v9ses, fid, sb, 0);
 }
+
+/**
+ * v9fs_get_new_inode_from_fid - Helper routine to populate an inode by
+ * issuing a attribute request
+ * @v9ses: session information
+ * @fid: fid to issue attribute request for
+ * @sb: superblock on which to create inode
+ *
+ */
+static inline struct inode *
+v9fs_get_new_inode_from_fid(struct v9fs_session_info *v9ses, struct p9_fid *fid,
+                           struct super_block *sb)
+{
+       if (v9fs_proto_dotl(v9ses))
+               return v9fs_inode_from_fid_dotl(v9ses, fid, sb, 1);
+       else
+               return v9fs_inode_from_fid(v9ses, fid, sb, 1);
+}
+
 #endif
index 7f9976a866e9404f891c8af67d344447177c5309..8bb5507e822f4151574f564150f48acd4531f002 100644 (file)
@@ -216,7 +216,6 @@ struct inode *v9fs_alloc_inode(struct super_block *sb)
                return NULL;
 #ifdef CONFIG_9P_FSCACHE
        v9inode->fscache = NULL;
-       v9inode->fscache_key = NULL;
        spin_lock_init(&v9inode->fscache_lock);
 #endif
        v9inode->writeback_fid = NULL;
@@ -433,17 +432,60 @@ void v9fs_evict_inode(struct inode *inode)
        }
 }
 
+static int v9fs_test_inode(struct inode *inode, void *data)
+{
+       int umode;
+       struct v9fs_inode *v9inode = V9FS_I(inode);
+       struct p9_wstat *st = (struct p9_wstat *)data;
+       struct v9fs_session_info *v9ses = v9fs_inode2v9ses(inode);
+
+       umode = p9mode2unixmode(v9ses, st->mode);
+       /* don't match inode of different type */
+       if ((inode->i_mode & S_IFMT) != (umode & S_IFMT))
+               return 0;
+
+       /* compare qid details */
+       if (memcmp(&v9inode->qid.version,
+                  &st->qid.version, sizeof(v9inode->qid.version)))
+               return 0;
+
+       if (v9inode->qid.type != st->qid.type)
+               return 0;
+       return 1;
+}
+
+static int v9fs_test_new_inode(struct inode *inode, void *data)
+{
+       return 0;
+}
+
+static int v9fs_set_inode(struct inode *inode,  void *data)
+{
+       struct v9fs_inode *v9inode = V9FS_I(inode);
+       struct p9_wstat *st = (struct p9_wstat *)data;
+
+       memcpy(&v9inode->qid, &st->qid, sizeof(st->qid));
+       return 0;
+}
+
 static struct inode *v9fs_qid_iget(struct super_block *sb,
                                   struct p9_qid *qid,
-                                  struct p9_wstat *st)
+                                  struct p9_wstat *st,
+                                  int new)
 {
        int retval, umode;
        unsigned long i_ino;
        struct inode *inode;
        struct v9fs_session_info *v9ses = sb->s_fs_info;
+       int (*test)(struct inode *, void *);
+
+       if (new)
+               test = v9fs_test_new_inode;
+       else
+               test = v9fs_test_inode;
 
        i_ino = v9fs_qid2ino(qid);
-       inode = iget_locked(sb, i_ino);
+       inode = iget5_locked(sb, i_ino, test, v9fs_set_inode, st);
        if (!inode)
                return ERR_PTR(-ENOMEM);
        if (!(inode->i_state & I_NEW))
@@ -453,6 +495,7 @@ static struct inode *v9fs_qid_iget(struct super_block *sb,
         * FIXME!! we may need support for stale inodes
         * later.
         */
+       inode->i_ino = i_ino;
        umode = p9mode2unixmode(v9ses, st->mode);
        retval = v9fs_init_inode(v9ses, inode, umode);
        if (retval)
@@ -460,7 +503,6 @@ static struct inode *v9fs_qid_iget(struct super_block *sb,
 
        v9fs_stat2inode(st, inode, sb);
 #ifdef CONFIG_9P_FSCACHE
-       v9fs_fscache_set_key(inode, &st->qid);
        v9fs_cache_inode_get_cookie(inode);
 #endif
        unlock_new_inode(inode);
@@ -474,7 +516,7 @@ error:
 
 struct inode *
 v9fs_inode_from_fid(struct v9fs_session_info *v9ses, struct p9_fid *fid,
-                   struct super_block *sb)
+                   struct super_block *sb, int new)
 {
        struct p9_wstat *st;
        struct inode *inode = NULL;
@@ -483,7 +525,7 @@ v9fs_inode_from_fid(struct v9fs_session_info *v9ses, struct p9_fid *fid,
        if (IS_ERR(st))
                return ERR_CAST(st);
 
-       inode = v9fs_qid_iget(sb, &st->qid, st);
+       inode = v9fs_qid_iget(sb, &st->qid, st, new);
        p9stat_free(st);
        kfree(st);
        return inode;
@@ -492,38 +534,50 @@ v9fs_inode_from_fid(struct v9fs_session_info *v9ses, struct p9_fid *fid,
 /**
  * v9fs_remove - helper function to remove files and directories
  * @dir: directory inode that is being deleted
- * @file:  dentry that is being deleted
+ * @dentry:  dentry that is being deleted
  * @rmdir: removing a directory
  *
  */
 
-static int v9fs_remove(struct inode *dir, struct dentry *file, int rmdir)
+static int v9fs_remove(struct inode *dir, struct dentry *dentry, int flags)
 {
-       int retval;
-       struct p9_fid *v9fid;
-       struct inode *file_inode;
-
-       P9_DPRINTK(P9_DEBUG_VFS, "inode: %p dentry: %p rmdir: %d\n", dir, file,
-               rmdir);
+       struct inode *inode;
+       int retval = -EOPNOTSUPP;
+       struct p9_fid *v9fid, *dfid;
+       struct v9fs_session_info *v9ses;
 
-       file_inode = file->d_inode;
-       v9fid = v9fs_fid_clone(file);
-       if (IS_ERR(v9fid))
-               return PTR_ERR(v9fid);
+       P9_DPRINTK(P9_DEBUG_VFS, "inode: %p dentry: %p rmdir: %x\n",
+                  dir, dentry, flags);
 
-       retval = p9_client_remove(v9fid);
+       v9ses = v9fs_inode2v9ses(dir);
+       inode = dentry->d_inode;
+       dfid = v9fs_fid_lookup(dentry->d_parent);
+       if (IS_ERR(dfid)) {
+               retval = PTR_ERR(dfid);
+               P9_DPRINTK(P9_DEBUG_VFS, "fid lookup failed %d\n", retval);
+               return retval;
+       }
+       if (v9fs_proto_dotl(v9ses))
+               retval = p9_client_unlinkat(dfid, dentry->d_name.name, flags);
+       if (retval == -EOPNOTSUPP) {
+               /* Try the one based on path */
+               v9fid = v9fs_fid_clone(dentry);
+               if (IS_ERR(v9fid))
+                       return PTR_ERR(v9fid);
+               retval = p9_client_remove(v9fid);
+       }
        if (!retval) {
                /*
                 * directories on unlink should have zero
                 * link count
                 */
-               if (rmdir) {
-                       clear_nlink(file_inode);
+               if (flags & AT_REMOVEDIR) {
+                       clear_nlink(inode);
                        drop_nlink(dir);
                } else
-                       drop_nlink(file_inode);
+                       drop_nlink(inode);
 
-               v9fs_invalidate_inode_attr(file_inode);
+               v9fs_invalidate_inode_attr(inode);
                v9fs_invalidate_inode_attr(dir);
        }
        return retval;
@@ -585,7 +639,7 @@ v9fs_create(struct v9fs_session_info *v9ses, struct inode *dir,
        }
 
        /* instantiate inode and assign the unopened fid to the dentry */
-       inode = v9fs_get_inode_from_fid(v9ses, fid, dir->i_sb);
+       inode = v9fs_get_new_inode_from_fid(v9ses, fid, dir->i_sb);
        if (IS_ERR(inode)) {
                err = PTR_ERR(inode);
                P9_DPRINTK(P9_DEBUG_VFS, "inode creation failed %d\n", err);
@@ -814,7 +868,7 @@ int v9fs_vfs_unlink(struct inode *i, struct dentry *d)
 
 int v9fs_vfs_rmdir(struct inode *i, struct dentry *d)
 {
-       return v9fs_remove(i, d, 1);
+       return v9fs_remove(i, d, AT_REMOVEDIR);
 }
 
 /**
@@ -862,9 +916,12 @@ v9fs_vfs_rename(struct inode *old_dir, struct dentry *old_dentry,
 
        down_write(&v9ses->rename_sem);
        if (v9fs_proto_dotl(v9ses)) {
-               retval = p9_client_rename(oldfid, newdirfid,
-                                       (char *) new_dentry->d_name.name);
-               if (retval != -ENOSYS)
+               retval = p9_client_renameat(olddirfid, old_dentry->d_name.name,
+                                           newdirfid, new_dentry->d_name.name);
+               if (retval == -EOPNOTSUPP)
+                       retval = p9_client_rename(oldfid, newdirfid,
+                                                 new_dentry->d_name.name);
+               if (retval != -EOPNOTSUPP)
                        goto clunk_newdir;
        }
        if (old_dentry->d_parent != new_dentry->d_parent) {
@@ -889,11 +946,6 @@ clunk_newdir:
                                clear_nlink(new_inode);
                        else
                                drop_nlink(new_inode);
-                       /*
-                        * Work around vfs rename rehash bug with
-                        * FS_RENAME_DOES_D_MOVE
-                        */
-                       v9fs_invalidate_inode_attr(new_inode);
                }
                if (S_ISDIR(old_inode->i_mode)) {
                        if (!new_inode)
index 32bbbe5aa689486df75a2eed721aaf12b656138c..276f4a69ecd459e029f665c6acf0959d536009c1 100644 (file)
@@ -86,18 +86,63 @@ static struct dentry *v9fs_dentry_from_dir_inode(struct inode *inode)
        return dentry;
 }
 
+static int v9fs_test_inode_dotl(struct inode *inode, void *data)
+{
+       struct v9fs_inode *v9inode = V9FS_I(inode);
+       struct p9_stat_dotl *st = (struct p9_stat_dotl *)data;
+
+       /* don't match inode of different type */
+       if ((inode->i_mode & S_IFMT) != (st->st_mode & S_IFMT))
+               return 0;
+
+       if (inode->i_generation != st->st_gen)
+               return 0;
+
+       /* compare qid details */
+       if (memcmp(&v9inode->qid.version,
+                  &st->qid.version, sizeof(v9inode->qid.version)))
+               return 0;
+
+       if (v9inode->qid.type != st->qid.type)
+               return 0;
+       return 1;
+}
+
+/* Always get a new inode */
+static int v9fs_test_new_inode_dotl(struct inode *inode, void *data)
+{
+       return 0;
+}
+
+static int v9fs_set_inode_dotl(struct inode *inode,  void *data)
+{
+       struct v9fs_inode *v9inode = V9FS_I(inode);
+       struct p9_stat_dotl *st = (struct p9_stat_dotl *)data;
+
+       memcpy(&v9inode->qid, &st->qid, sizeof(st->qid));
+       inode->i_generation = st->st_gen;
+       return 0;
+}
+
 static struct inode *v9fs_qid_iget_dotl(struct super_block *sb,
                                        struct p9_qid *qid,
                                        struct p9_fid *fid,
-                                       struct p9_stat_dotl *st)
+                                       struct p9_stat_dotl *st,
+                                       int new)
 {
        int retval;
        unsigned long i_ino;
        struct inode *inode;
        struct v9fs_session_info *v9ses = sb->s_fs_info;
+       int (*test)(struct inode *, void *);
+
+       if (new)
+               test = v9fs_test_new_inode_dotl;
+       else
+               test = v9fs_test_inode_dotl;
 
        i_ino = v9fs_qid2ino(qid);
-       inode = iget_locked(sb, i_ino);
+       inode = iget5_locked(sb, i_ino, test, v9fs_set_inode_dotl, st);
        if (!inode)
                return ERR_PTR(-ENOMEM);
        if (!(inode->i_state & I_NEW))
@@ -107,13 +152,13 @@ static struct inode *v9fs_qid_iget_dotl(struct super_block *sb,
         * FIXME!! we may need support for stale inodes
         * later.
         */
+       inode->i_ino = i_ino;
        retval = v9fs_init_inode(v9ses, inode, st->st_mode);
        if (retval)
                goto error;
 
        v9fs_stat2inode_dotl(st, inode);
 #ifdef CONFIG_9P_FSCACHE
-       v9fs_fscache_set_key(inode, &st->qid);
        v9fs_cache_inode_get_cookie(inode);
 #endif
        retval = v9fs_get_acl(inode, fid);
@@ -131,16 +176,16 @@ error:
 
 struct inode *
 v9fs_inode_from_fid_dotl(struct v9fs_session_info *v9ses, struct p9_fid *fid,
-                        struct super_block *sb)
+                        struct super_block *sb, int new)
 {
        struct p9_stat_dotl *st;
        struct inode *inode = NULL;
 
-       st = p9_client_getattr_dotl(fid, P9_STATS_BASIC);
+       st = p9_client_getattr_dotl(fid, P9_STATS_BASIC | P9_STATS_GEN);
        if (IS_ERR(st))
                return ERR_CAST(st);
 
-       inode = v9fs_qid_iget_dotl(sb, &st->qid, fid, st);
+       inode = v9fs_qid_iget_dotl(sb, &st->qid, fid, st, new);
        kfree(st);
        return inode;
 }
@@ -230,7 +275,7 @@ v9fs_vfs_create_dotl(struct inode *dir, struct dentry *dentry, int omode,
                fid = NULL;
                goto error;
        }
-       inode = v9fs_get_inode_from_fid(v9ses, fid, dir->i_sb);
+       inode = v9fs_get_new_inode_from_fid(v9ses, fid, dir->i_sb);
        if (IS_ERR(inode)) {
                err = PTR_ERR(inode);
                P9_DPRINTK(P9_DEBUG_VFS, "inode creation failed %d\n", err);
@@ -350,7 +395,7 @@ static int v9fs_vfs_mkdir_dotl(struct inode *dir,
                        goto error;
                }
 
-               inode = v9fs_get_inode_from_fid(v9ses, fid, dir->i_sb);
+               inode = v9fs_get_new_inode_from_fid(v9ses, fid, dir->i_sb);
                if (IS_ERR(inode)) {
                        err = PTR_ERR(inode);
                        P9_DPRINTK(P9_DEBUG_VFS, "inode creation failed %d\n",
@@ -547,7 +592,7 @@ v9fs_stat2inode_dotl(struct p9_stat_dotl *stat, struct inode *inode)
                        inode->i_blocks = stat->st_blocks;
        }
        if (stat->st_result_mask & P9_STATS_GEN)
-                       inode->i_generation = stat->st_gen;
+               inode->i_generation = stat->st_gen;
 
        /* Currently we don't support P9_STATS_BTIME and P9_STATS_DATA_VERSION
         * because the inode structure does not have fields for them.
@@ -603,7 +648,7 @@ v9fs_vfs_symlink_dotl(struct inode *dir, struct dentry *dentry,
                }
 
                /* instantiate inode and assign the unopened fid to dentry */
-               inode = v9fs_get_inode_from_fid(v9ses, fid, dir->i_sb);
+               inode = v9fs_get_new_inode_from_fid(v9ses, fid, dir->i_sb);
                if (IS_ERR(inode)) {
                        err = PTR_ERR(inode);
                        P9_DPRINTK(P9_DEBUG_VFS, "inode creation failed %d\n",
@@ -756,7 +801,7 @@ v9fs_vfs_mknod_dotl(struct inode *dir, struct dentry *dentry, int omode,
                        goto error;
                }
 
-               inode = v9fs_get_inode_from_fid(v9ses, fid, dir->i_sb);
+               inode = v9fs_get_new_inode_from_fid(v9ses, fid, dir->i_sb);
                if (IS_ERR(inode)) {
                        err = PTR_ERR(inode);
                        P9_DPRINTK(P9_DEBUG_VFS, "inode creation failed %d\n",
index 008711e8e78f265d512105d788aad6877c016a07..342dcf13d039a8470ddcf4628b55c510c7fb13fe 100644 (file)
@@ -40,6 +40,7 @@
  * @P9_DEBUG_FID: fid allocation/deallocation tracking
  * @P9_DEBUG_PKT: packet marshalling/unmarshalling
  * @P9_DEBUG_FSC: FS-cache tracing
+ * @P9_DEBUG_VPKT: Verbose packet debugging (full packet dump)
  *
  * These flags are passed at mount time to turn on various levels of
  * verbosity and tracing which will be output to the system logs.
@@ -57,6 +58,7 @@ enum p9_debug_flags {
        P9_DEBUG_FID =          (1<<9),
        P9_DEBUG_PKT =          (1<<10),
        P9_DEBUG_FSC =          (1<<11),
+       P9_DEBUG_VPKT =         (1<<12),
 };
 
 #ifdef CONFIG_NET_9P_DEBUG
@@ -74,10 +76,14 @@ do {  \
        } \
 } while (0)
 
+#define P9_DUMP_PKT(way, pdu) p9pdu_dump(way, pdu)
+
 #else
 #define P9_DPRINTK(level, format, arg...)  do { } while (0)
+#define P9_DUMP_PKT(way, pdu) do { } while (0)
 #endif
 
+
 #define P9_EPRINTK(level, format, arg...) \
 do { \
        printk(level "9p: %s (%d): " \
@@ -175,6 +181,10 @@ enum p9_msg_t {
        P9_RLINK,
        P9_TMKDIR = 72,
        P9_RMKDIR,
+       P9_TRENAMEAT = 74,
+       P9_RRENAMEAT,
+       P9_TUNLINKAT = 76,
+       P9_RUNLINKAT,
        P9_TVERSION = 100,
        P9_RVERSION,
        P9_TAUTH = 102,
@@ -320,21 +330,6 @@ enum p9_qid_t {
 /* Room for readdir header */
 #define P9_READDIRHDRSZ        24
 
-/**
- * struct p9_str - length prefixed string type
- * @len: length of the string
- * @str: the string
- *
- * The protocol uses length prefixed strings for all
- * string data, so we replicate that for our internal
- * string members.
- */
-
-struct p9_str {
-       u16 len;
-       char *str;
-};
-
 /**
  * struct p9_qid - file system entity information
  * @type: 8-bit type &p9_qid_t
@@ -371,11 +366,11 @@ struct p9_qid {
  * @atime: Last access/read time
  * @mtime: Last modify/write time
  * @length: file length
- * @name: last element of path (aka filename) in type &p9_str
- * @uid: owner name in type &p9_str
- * @gid: group owner in type &p9_str
- * @muid: last modifier in type &p9_str
- * @extension: area used to encode extended UNIX support in type &p9_str
+ * @name: last element of path (aka filename)
+ * @uid: owner name
+ * @gid: group owner
+ * @muid: last modifier
+ * @extension: area used to encode extended UNIX support
  * @n_uid: numeric user id of owner (part of 9p2000.u extension)
  * @n_gid: numeric group id (part of 9p2000.u extension)
  * @n_muid: numeric user id of laster modifier (part of 9p2000.u extension)
@@ -512,11 +507,6 @@ struct p9_getlock {
        char *client_id;
 };
 
-/* Structures for Protocol Operations */
-struct p9_tstatfs {
-       u32 fid;
-};
-
 struct p9_rstatfs {
        u32 type;
        u32 bsize;
@@ -529,159 +519,6 @@ struct p9_rstatfs {
        u32 namelen;
 };
 
-struct p9_trename {
-       u32 fid;
-       u32 newdirfid;
-       struct p9_str name;
-};
-
-struct p9_rrename {
-};
-
-struct p9_tversion {
-       u32 msize;
-       struct p9_str version;
-};
-
-struct p9_rversion {
-       u32 msize;
-       struct p9_str version;
-};
-
-struct p9_tauth {
-       u32 afid;
-       struct p9_str uname;
-       struct p9_str aname;
-       u32 n_uname;            /* 9P2000.u extensions */
-};
-
-struct p9_rauth {
-       struct p9_qid qid;
-};
-
-struct p9_rerror {
-       struct p9_str error;
-       u32 errno;              /* 9p2000.u extension */
-};
-
-struct p9_tflush {
-       u16 oldtag;
-};
-
-struct p9_rflush {
-};
-
-struct p9_tattach {
-       u32 fid;
-       u32 afid;
-       struct p9_str uname;
-       struct p9_str aname;
-       u32 n_uname;            /* 9P2000.u extensions */
-};
-
-struct p9_rattach {
-       struct p9_qid qid;
-};
-
-struct p9_twalk {
-       u32 fid;
-       u32 newfid;
-       u16 nwname;
-       struct p9_str wnames[16];
-};
-
-struct p9_rwalk {
-       u16 nwqid;
-       struct p9_qid wqids[16];
-};
-
-struct p9_topen {
-       u32 fid;
-       u8 mode;
-};
-
-struct p9_ropen {
-       struct p9_qid qid;
-       u32 iounit;
-};
-
-struct p9_tcreate {
-       u32 fid;
-       struct p9_str name;
-       u32 perm;
-       u8 mode;
-       struct p9_str extension;
-};
-
-struct p9_rcreate {
-       struct p9_qid qid;
-       u32 iounit;
-};
-
-struct p9_tread {
-       u32 fid;
-       u64 offset;
-       u32 count;
-};
-
-struct p9_rread {
-       u32 count;
-       u8 *data;
-};
-
-struct p9_twrite {
-       u32 fid;
-       u64 offset;
-       u32 count;
-       u8 *data;
-};
-
-struct p9_rwrite {
-       u32 count;
-};
-
-struct p9_treaddir {
-       u32 fid;
-       u64 offset;
-       u32 count;
-};
-
-struct p9_rreaddir {
-       u32 count;
-       u8 *data;
-};
-
-
-struct p9_tclunk {
-       u32 fid;
-};
-
-struct p9_rclunk {
-};
-
-struct p9_tremove {
-       u32 fid;
-};
-
-struct p9_rremove {
-};
-
-struct p9_tstat {
-       u32 fid;
-};
-
-struct p9_rstat {
-       struct p9_wstat stat;
-};
-
-struct p9_twstat {
-       u32 fid;
-       struct p9_wstat stat;
-};
-
-struct p9_rwstat {
-};
-
 /**
  * struct p9_fcall - primary packet structure
  * @size: prefixed length of the structure
index d26d5e98a1737e85e9e2004f30d5fa17f4f007ae..55ce72ce98618bbc42e7310bb637275a3b80645c 100644 (file)
@@ -36,9 +36,9 @@
  */
 
 enum p9_proto_versions{
-       p9_proto_legacy = 0,
-       p9_proto_2000u = 1,
-       p9_proto_2000L = 2,
+       p9_proto_legacy,
+       p9_proto_2000u,
+       p9_proto_2000L,
 };
 
 
@@ -211,7 +211,10 @@ struct p9_dirent {
 };
 
 int p9_client_statfs(struct p9_fid *fid, struct p9_rstatfs *sb);
-int p9_client_rename(struct p9_fid *fid, struct p9_fid *newdirfid, char *name);
+int p9_client_rename(struct p9_fid *fid, struct p9_fid *newdirfid,
+                    const char *name);
+int p9_client_renameat(struct p9_fid *olddirfid, const char *old_name,
+                      struct p9_fid *newdirfid, const char *new_name);
 struct p9_client *p9_client_create(const char *dev_name, char *options);
 void p9_client_destroy(struct p9_client *clnt);
 void p9_client_disconnect(struct p9_client *clnt);
@@ -231,6 +234,7 @@ int p9_client_create_dotl(struct p9_fid *ofid, char *name, u32 flags, u32 mode,
 int p9_client_clunk(struct p9_fid *fid);
 int p9_client_fsync(struct p9_fid *fid, int datasync);
 int p9_client_remove(struct p9_fid *fid);
+int p9_client_unlinkat(struct p9_fid *dfid, const char *name, int flags);
 int p9_client_read(struct p9_fid *fid, char *data, char __user *udata,
                                                        u64 offset, u32 count);
 int p9_client_write(struct p9_fid *fid, char *data, const char __user *udata,
index d8549fb9c742209369f324db5953fd5904aa36dd..83531ebeee99084746d9679dce3c29e47471e38c 100644 (file)
@@ -67,7 +67,7 @@ struct p9_trans_module {
 
 void v9fs_register_trans(struct p9_trans_module *m);
 void v9fs_unregister_trans(struct p9_trans_module *m);
-struct p9_trans_module *v9fs_get_trans_by_name(const substring_t *name);
+struct p9_trans_module *v9fs_get_trans_by_name(char *s);
 struct p9_trans_module *v9fs_get_default_trans(void);
 void v9fs_put_trans(struct p9_trans_module *m);
 #endif /* NET_9P_TRANSPORT_H */
index 9e3b0e640da179a122f6f846bd8cff31920db159..0505a03c374c1599cac7bffbf1ec6d0af311910e 100644 (file)
@@ -72,23 +72,22 @@ inline int p9_is_proto_dotu(struct p9_client *clnt)
 EXPORT_SYMBOL(p9_is_proto_dotu);
 
 /* Interpret mount option for protocol version */
-static int get_protocol_version(const substring_t *name)
+static int get_protocol_version(char *s)
 {
        int version = -EINVAL;
 
-       if (!strncmp("9p2000", name->from, name->to-name->from)) {
+       if (!strcmp(s, "9p2000")) {
                version = p9_proto_legacy;
                P9_DPRINTK(P9_DEBUG_9P, "Protocol version: Legacy\n");
-       } else if (!strncmp("9p2000.u", name->from, name->to-name->from)) {
+       } else if (!strcmp(s, "9p2000.u")) {
                version = p9_proto_2000u;
                P9_DPRINTK(P9_DEBUG_9P, "Protocol version: 9P2000.u\n");
-       } else if (!strncmp("9p2000.L", name->from, name->to-name->from)) {
+       } else if (!strcmp(s, "9p2000.L")) {
                version = p9_proto_2000L;
                P9_DPRINTK(P9_DEBUG_9P, "Protocol version: 9P2000.L\n");
-       } else {
-               P9_DPRINTK(P9_DEBUG_ERROR, "Unknown protocol version %s. ",
-                                                       name->from);
-       }
+       } else
+               printk(KERN_INFO "9p: Unknown protocol version %s.\n", s);
+
        return version;
 }
 
@@ -106,6 +105,7 @@ static int parse_opts(char *opts, struct p9_client *clnt)
        char *p;
        substring_t args[MAX_OPT_ARGS];
        int option;
+       char *s;
        int ret = 0;
 
        clnt->proto_version = p9_proto_2000u;
@@ -141,22 +141,41 @@ static int parse_opts(char *opts, struct p9_client *clnt)
                        clnt->msize = option;
                        break;
                case Opt_trans:
-                       clnt->trans_mod = v9fs_get_trans_by_name(&args[0]);
-                       if(clnt->trans_mod == NULL) {
+                       s = match_strdup(&args[0]);
+                       if (!s) {
+                               ret = -ENOMEM;
                                P9_DPRINTK(P9_DEBUG_ERROR,
-                                  "Could not find request transport: %s\n",
-                                  (char *) &args[0]);
+                                       "problem allocating copy of trans arg\n");
+                               goto free_and_return;
+                        }
+                       clnt->trans_mod = v9fs_get_trans_by_name(s);
+                       if (clnt->trans_mod == NULL) {
+                               printk(KERN_INFO
+                                       "9p: Could not find "
+                                       "request transport: %s\n", s);
                                ret = -EINVAL;
+                               kfree(s);
                                goto free_and_return;
                        }
+                       kfree(s);
                        break;
                case Opt_legacy:
                        clnt->proto_version = p9_proto_legacy;
                        break;
                case Opt_version:
-                       ret = get_protocol_version(&args[0]);
-                       if (ret == -EINVAL)
+                       s = match_strdup(&args[0]);
+                       if (!s) {
+                               ret = -ENOMEM;
+                               P9_DPRINTK(P9_DEBUG_ERROR,
+                                       "problem allocating copy of version arg\n");
                                goto free_and_return;
+                       }
+                       ret = get_protocol_version(s);
+                       if (ret == -EINVAL) {
+                               kfree(s);
+                               goto free_and_return;
+                       }
+                       kfree(s);
                        clnt->proto_version = ret;
                        break;
                default:
@@ -280,7 +299,8 @@ struct p9_req_t *p9_tag_lookup(struct p9_client *c, u16 tag)
         * buffer to read the data into */
        tag++;
 
-       BUG_ON(tag >= c->max_tag);
+       if(tag >= c->max_tag) 
+               return NULL;
 
        row = tag / P9_ROW_MAXTAG;
        col = tag % P9_ROW_MAXTAG;
@@ -749,7 +769,7 @@ static int p9_client_version(struct p9_client *c)
        err = p9pdu_readf(req->rc, c->proto_version, "ds", &msize, &version);
        if (err) {
                P9_DPRINTK(P9_DEBUG_9P, "version error %d\n", err);
-               p9pdu_dump(1, req->rc);
+               P9_DUMP_PKT(1, req->rc);
                goto error;
        }
 
@@ -821,8 +841,8 @@ struct p9_client *p9_client_create(const char *dev_name, char *options)
        if (err)
                goto destroy_fidpool;
 
-       if ((clnt->msize+P9_IOHDRSZ) > clnt->trans_mod->maxsize)
-               clnt->msize = clnt->trans_mod->maxsize-P9_IOHDRSZ;
+       if (clnt->msize > clnt->trans_mod->maxsize)
+               clnt->msize = clnt->trans_mod->maxsize;
 
        err = p9_client_version(clnt);
        if (err)
@@ -911,7 +931,7 @@ struct p9_fid *p9_client_attach(struct p9_client *clnt, struct p9_fid *afid,
 
        err = p9pdu_readf(req->rc, clnt->proto_version, "Q", &qid);
        if (err) {
-               p9pdu_dump(1, req->rc);
+               P9_DUMP_PKT(1, req->rc);
                p9_free_req(clnt, req);
                goto error;
        }
@@ -971,7 +991,7 @@ struct p9_fid *p9_client_walk(struct p9_fid *oldfid, uint16_t nwname,
 
        err = p9pdu_readf(req->rc, clnt->proto_version, "R", &nwqids, &wqids);
        if (err) {
-               p9pdu_dump(1, req->rc);
+               P9_DUMP_PKT(1, req->rc);
                p9_free_req(clnt, req);
                goto clunk_fid;
        }
@@ -1038,7 +1058,7 @@ int p9_client_open(struct p9_fid *fid, int mode)
 
        err = p9pdu_readf(req->rc, clnt->proto_version, "Qd", &qid, &iounit);
        if (err) {
-               p9pdu_dump(1, req->rc);
+               P9_DUMP_PKT(1, req->rc);
                goto free_and_error;
        }
 
@@ -1081,7 +1101,7 @@ int p9_client_create_dotl(struct p9_fid *ofid, char *name, u32 flags, u32 mode,
 
        err = p9pdu_readf(req->rc, clnt->proto_version, "Qd", qid, &iounit);
        if (err) {
-               p9pdu_dump(1, req->rc);
+               P9_DUMP_PKT(1, req->rc);
                goto free_and_error;
        }
 
@@ -1126,7 +1146,7 @@ int p9_client_fcreate(struct p9_fid *fid, char *name, u32 perm, int mode,
 
        err = p9pdu_readf(req->rc, clnt->proto_version, "Qd", &qid, &iounit);
        if (err) {
-               p9pdu_dump(1, req->rc);
+               P9_DUMP_PKT(1, req->rc);
                goto free_and_error;
        }
 
@@ -1165,7 +1185,7 @@ int p9_client_symlink(struct p9_fid *dfid, char *name, char *symtgt, gid_t gid,
 
        err = p9pdu_readf(req->rc, clnt->proto_version, "Q", qid);
        if (err) {
-               p9pdu_dump(1, req->rc);
+               P9_DUMP_PKT(1, req->rc);
                goto free_and_error;
        }
 
@@ -1249,9 +1269,11 @@ int p9_client_clunk(struct p9_fid *fid)
        P9_DPRINTK(P9_DEBUG_9P, "<<< RCLUNK fid %d\n", fid->fid);
 
        p9_free_req(clnt, req);
-       p9_fid_destroy(fid);
-
 error:
+       /*
+        * Fid is not valid even after a failed clunk
+        */
+       p9_fid_destroy(fid);
        return err;
 }
 EXPORT_SYMBOL(p9_client_clunk);
@@ -1281,6 +1303,29 @@ error:
 }
 EXPORT_SYMBOL(p9_client_remove);
 
+int p9_client_unlinkat(struct p9_fid *dfid, const char *name, int flags)
+{
+       int err = 0;
+       struct p9_req_t *req;
+       struct p9_client *clnt;
+
+       P9_DPRINTK(P9_DEBUG_9P, ">>> TUNLINKAT fid %d %s %d\n",
+                  dfid->fid, name, flags);
+
+       clnt = dfid->clnt;
+       req = p9_client_rpc(clnt, P9_TUNLINKAT, "dsd", dfid->fid, name, flags);
+       if (IS_ERR(req)) {
+               err = PTR_ERR(req);
+               goto error;
+       }
+       P9_DPRINTK(P9_DEBUG_9P, "<<< RUNLINKAT fid %d %s\n", dfid->fid, name);
+
+       p9_free_req(clnt, req);
+error:
+       return err;
+}
+EXPORT_SYMBOL(p9_client_unlinkat);
+
 int
 p9_client_read(struct p9_fid *fid, char *data, char __user *udata, u64 offset,
                                                                u32 count)
@@ -1318,11 +1363,12 @@ p9_client_read(struct p9_fid *fid, char *data, char __user *udata, u64 offset,
 
        err = p9pdu_readf(req->rc, clnt->proto_version, "D", &count, &dataptr);
        if (err) {
-               p9pdu_dump(1, req->rc);
+               P9_DUMP_PKT(1, req->rc);
                goto free_and_error;
        }
 
        P9_DPRINTK(P9_DEBUG_9P, "<<< RREAD count %d\n", count);
+       P9_DUMP_PKT(1, req->rc);
 
        if (!req->tc->pbuf_size) {
                if (data) {
@@ -1386,7 +1432,7 @@ p9_client_write(struct p9_fid *fid, char *data, const char __user *udata,
 
        err = p9pdu_readf(req->rc, clnt->proto_version, "d", &count);
        if (err) {
-               p9pdu_dump(1, req->rc);
+               P9_DUMP_PKT(1, req->rc);
                goto free_and_error;
        }
 
@@ -1426,7 +1472,7 @@ struct p9_wstat *p9_client_stat(struct p9_fid *fid)
 
        err = p9pdu_readf(req->rc, clnt->proto_version, "wS", &ignored, ret);
        if (err) {
-               p9pdu_dump(1, req->rc);
+               P9_DUMP_PKT(1, req->rc);
                p9_free_req(clnt, req);
                goto error;
        }
@@ -1477,7 +1523,7 @@ struct p9_stat_dotl *p9_client_getattr_dotl(struct p9_fid *fid,
 
        err = p9pdu_readf(req->rc, clnt->proto_version, "A", ret);
        if (err) {
-               p9pdu_dump(1, req->rc);
+               P9_DUMP_PKT(1, req->rc);
                p9_free_req(clnt, req);
                goto error;
        }
@@ -1625,7 +1671,7 @@ int p9_client_statfs(struct p9_fid *fid, struct p9_rstatfs *sb)
                &sb->bsize, &sb->blocks, &sb->bfree, &sb->bavail,
                &sb->files, &sb->ffree, &sb->fsid, &sb->namelen);
        if (err) {
-               p9pdu_dump(1, req->rc);
+               P9_DUMP_PKT(1, req->rc);
                p9_free_req(clnt, req);
                goto error;
        }
@@ -1643,7 +1689,8 @@ error:
 }
 EXPORT_SYMBOL(p9_client_statfs);
 
-int p9_client_rename(struct p9_fid *fid, struct p9_fid *newdirfid, char *name)
+int p9_client_rename(struct p9_fid *fid,
+                    struct p9_fid *newdirfid, const char *name)
 {
        int err;
        struct p9_req_t *req;
@@ -1670,6 +1717,36 @@ error:
 }
 EXPORT_SYMBOL(p9_client_rename);
 
+int p9_client_renameat(struct p9_fid *olddirfid, const char *old_name,
+                      struct p9_fid *newdirfid, const char *new_name)
+{
+       int err;
+       struct p9_req_t *req;
+       struct p9_client *clnt;
+
+       err = 0;
+       clnt = olddirfid->clnt;
+
+       P9_DPRINTK(P9_DEBUG_9P, ">>> TRENAMEAT olddirfid %d old name %s"
+                  " newdirfid %d new name %s\n", olddirfid->fid, old_name,
+                  newdirfid->fid, new_name);
+
+       req = p9_client_rpc(clnt, P9_TRENAMEAT, "dsds", olddirfid->fid,
+                           old_name, newdirfid->fid, new_name);
+       if (IS_ERR(req)) {
+               err = PTR_ERR(req);
+               goto error;
+       }
+
+       P9_DPRINTK(P9_DEBUG_9P, "<<< RRENAMEAT newdirfid %d new name %s\n",
+                  newdirfid->fid, new_name);
+
+       p9_free_req(clnt, req);
+error:
+       return err;
+}
+EXPORT_SYMBOL(p9_client_renameat);
+
 /*
  * An xattrwalk without @attr_name gives the fid for the lisxattr namespace
  */
@@ -1701,7 +1778,7 @@ struct p9_fid *p9_client_xattrwalk(struct p9_fid *file_fid,
        }
        err = p9pdu_readf(req->rc, clnt->proto_version, "q", attr_size);
        if (err) {
-               p9pdu_dump(1, req->rc);
+               P9_DUMP_PKT(1, req->rc);
                p9_free_req(clnt, req);
                goto clunk_fid;
        }
@@ -1780,7 +1857,7 @@ int p9_client_readdir(struct p9_fid *fid, char *data, u32 count, u64 offset)
 
        err = p9pdu_readf(req->rc, clnt->proto_version, "D", &count, &dataptr);
        if (err) {
-               p9pdu_dump(1, req->rc);
+               P9_DUMP_PKT(1, req->rc);
                goto free_and_error;
        }
 
@@ -1817,7 +1894,7 @@ int p9_client_mknod_dotl(struct p9_fid *fid, char *name, int mode,
 
        err = p9pdu_readf(req->rc, clnt->proto_version, "Q", qid);
        if (err) {
-               p9pdu_dump(1, req->rc);
+               P9_DUMP_PKT(1, req->rc);
                goto error;
        }
        P9_DPRINTK(P9_DEBUG_9P, "<<< RMKNOD qid %x.%llx.%x\n", qid->type,
@@ -1848,7 +1925,7 @@ int p9_client_mkdir_dotl(struct p9_fid *fid, char *name, int mode,
 
        err = p9pdu_readf(req->rc, clnt->proto_version, "Q", qid);
        if (err) {
-               p9pdu_dump(1, req->rc);
+               P9_DUMP_PKT(1, req->rc);
                goto error;
        }
        P9_DPRINTK(P9_DEBUG_9P, "<<< RMKDIR qid %x.%llx.%x\n", qid->type,
@@ -1883,7 +1960,7 @@ int p9_client_lock_dotl(struct p9_fid *fid, struct p9_flock *flock, u8 *status)
 
        err = p9pdu_readf(req->rc, clnt->proto_version, "b", status);
        if (err) {
-               p9pdu_dump(1, req->rc);
+               P9_DUMP_PKT(1, req->rc);
                goto error;
        }
        P9_DPRINTK(P9_DEBUG_9P, "<<< RLOCK status %i\n", *status);
@@ -1916,7 +1993,7 @@ int p9_client_getlock_dotl(struct p9_fid *fid, struct p9_getlock *glock)
                        &glock->start, &glock->length, &glock->proc_id,
                        &glock->client_id);
        if (err) {
-               p9pdu_dump(1, req->rc);
+               P9_DUMP_PKT(1, req->rc);
                goto error;
        }
        P9_DPRINTK(P9_DEBUG_9P, "<<< RGETLOCK type %i start %lld length %lld "
@@ -1944,7 +2021,7 @@ int p9_client_readlink(struct p9_fid *fid, char **target)
 
        err = p9pdu_readf(req->rc, clnt->proto_version, "s", target);
        if (err) {
-               p9pdu_dump(1, req->rc);
+               P9_DUMP_PKT(1, req->rc);
                goto error;
        }
        P9_DPRINTK(P9_DEBUG_9P, "<<< RREADLINK target %s\n", *target);
index 72c39827505125b618b7a007b6a1dc23d98b4f4f..2664d1292291344e6a43964334df681d4e49e372 100644 (file)
@@ -80,14 +80,14 @@ EXPORT_SYMBOL(v9fs_unregister_trans);
  * @name: string identifying transport
  *
  */
-struct p9_trans_module *v9fs_get_trans_by_name(const substring_t *name)
+struct p9_trans_module *v9fs_get_trans_by_name(char *s)
 {
        struct p9_trans_module *t, *found = NULL;
 
        spin_lock(&v9fs_trans_lock);
 
        list_for_each_entry(t, &v9fs_trans_list, list)
-               if (strncmp(t->name, name->from, name->to-name->from) == 0 &&
+               if (strcmp(t->name, s) == 0 &&
                    try_module_get(t->owner)) {
                        found = t;
                        break;
index a873277cb996810162ee875db9485952144541bb..df58375ea6b33890030c649938403cf73c2f30f6 100644 (file)
@@ -44,30 +44,24 @@ p9pdu_writef(struct p9_fcall *pdu, int proto_version, const char *fmt, ...);
 void
 p9pdu_dump(int way, struct p9_fcall *pdu)
 {
-       int i, n;
-       u8 *data = pdu->sdata;
-       int datalen = pdu->size;
-       char buf[255];
-       int buflen = 255;
-
-       i = n = 0;
-       if (datalen > (buflen-16))
-               datalen = buflen-16;
-       while (i < datalen) {
-               n += scnprintf(buf + n, buflen - n, "%02x ", data[i]);
-               if (i%4 == 3)
-                       n += scnprintf(buf + n, buflen - n, " ");
-               if (i%32 == 31)
-                       n += scnprintf(buf + n, buflen - n, "\n");
-
-               i++;
+       int len = pdu->size;
+
+       if ((p9_debug_level & P9_DEBUG_VPKT) != P9_DEBUG_VPKT) {
+               if ((p9_debug_level & P9_DEBUG_PKT) == P9_DEBUG_PKT) {
+                       if (len > 32)
+                               len = 32;
+               } else {
+                       /* shouldn't happen */
+                       return;
+               }
        }
-       n += scnprintf(buf + n, buflen - n, "\n");
 
        if (way)
-               P9_DPRINTK(P9_DEBUG_PKT, "[[[(%d) %s\n", datalen, buf);
+               print_hex_dump_bytes("[9P] ", DUMP_PREFIX_OFFSET, pdu->sdata,
+                                                                       len);
        else
-               P9_DPRINTK(P9_DEBUG_PKT, "]]](%d) %s\n", datalen, buf);
+               print_hex_dump_bytes("]9P[ ", DUMP_PREFIX_OFFSET, pdu->sdata,
+                                                                       len);
 }
 #else
 void
@@ -610,7 +604,7 @@ int p9stat_read(char *buf, int len, struct p9_wstat *st, int proto_version)
        ret = p9pdu_readf(&fake_pdu, proto_version, "S", st);
        if (ret) {
                P9_DPRINTK(P9_DEBUG_9P, "<<< p9stat_read failed: %d\n", ret);
-               p9pdu_dump(1, &fake_pdu);
+               P9_DUMP_PKT(0, &fake_pdu);
        }
 
        return ret;
@@ -632,11 +626,7 @@ int p9pdu_finalize(struct p9_fcall *pdu)
        err = p9pdu_writef(pdu, 0, "d", size);
        pdu->size = size;
 
-#ifdef CONFIG_NET_9P_DEBUG
-       if ((p9_debug_level & P9_DEBUG_PKT) == P9_DEBUG_PKT)
-               p9pdu_dump(0, pdu);
-#endif
-
+       P9_DUMP_PKT(0, pdu);
        P9_DPRINTK(P9_DEBUG_9P, ">>> size=%d type: %d tag: %d\n", pdu->size,
                                                        pdu->id, pdu->tag);
 
@@ -669,7 +659,7 @@ int p9dirent_read(char *buf, int len, struct p9_dirent *dirent,
                        &dirent->d_off, &dirent->d_type, &nameptr);
        if (ret) {
                P9_DPRINTK(P9_DEBUG_9P, "<<< p9dirent_read failed: %d\n", ret);
-               p9pdu_dump(1, &fake_pdu);
+               P9_DUMP_PKT(1, &fake_pdu);
                goto out;
        }
 
index 244e70742183dd689c347166885905baa1584e43..175b5135bdcf524d324c73298cd17da0819c9a1e 100644 (file)
@@ -367,7 +367,7 @@ req_retry_pinned:
                in += inp;
        } else {
                in = pack_sg_list(chan->sg, out, VIRTQUEUE_NUM, rdata,
-                               client->msize);
+                               req->rc->capacity);
        }
 
        err = virtqueue_add_buf(chan->vq, chan->sg, out, in, req->tc);
@@ -592,7 +592,7 @@ static struct p9_trans_module p9_virtio_trans = {
        .close = p9_virtio_close,
        .request = p9_virtio_request,
        .cancel = p9_virtio_cancel,
-       .maxsize = PAGE_SIZE*16,
+       .maxsize = PAGE_SIZE*VIRTQUEUE_NUM,
        .pref = P9_TRANS_PREF_PAYLOAD_SEP,
        .def = 0,
        .owner = THIS_MODULE,