Merge branch 'linux-2.6' into for-2.6.24

5 files changed, 122 insertions, 60 deletions

diff --git a/fs/nfs/file.c b/fs/nfs/file.c
index c87dc713b5d7..579cf8a7d4a7 100644
--- a/fs/nfs/file.c
+++ b/fs/nfs/file.c
@@ -316,7 +316,7 @@ static void nfs_invalidate_page(struct page *page, unsigned long offset)
         if (offset != 0)
                 return;
         /* Cancel any unstarted writes on this page */
-        nfs_wb_page_priority(page->mapping->host, page, FLUSH_INVALIDATE);
+        nfs_wb_page_cancel(page->mapping->host, page);
 }
 
 static int nfs_release_page(struct page *page, gfp_t gfp)
diff --git a/fs/nfs/namespace.c b/fs/nfs/namespace.c
index aea76d0e5fbd..acfc56f9edc0 100644
--- a/fs/nfs/namespace.c
+++ b/fs/nfs/namespace.c
@@ -176,7 +176,7 @@ static void nfs_expire_automounts(struct work_struct *work)
 void nfs_release_automount_timer(void)
 {
         if (list_empty(&nfs_automount_list))
-                cancel_delayed_work_sync(&nfs_automount_task);
+                cancel_delayed_work(&nfs_automount_task);
 }
 
 /*
diff --git a/fs/nfs/nfs4proc.c b/fs/nfs/nfs4proc.c
index 62b3ae280310..4b90e17555a9 100644
--- a/fs/nfs/nfs4proc.c
+++ b/fs/nfs/nfs4proc.c
@@ -646,7 +646,7 @@ static int _nfs4_do_open_reclaim(struct nfs_open_context *ctx, struct nfs4_state
         rcu_read_lock();
         delegation = rcu_dereference(NFS_I(state->inode)->delegation);
         if (delegation != NULL && (delegation->flags & NFS_DELEGATION_NEED_RECLAIM) != 0)
-                delegation_type = delegation->flags;
+                delegation_type = delegation->type;
         rcu_read_unlock();
         opendata->o_arg.u.delegation_type = delegation_type;
         status = nfs4_open_recover(opendata, state);
@@ -1434,7 +1434,7 @@ nfs4_atomic_open(struct inode *dir, struct dentry *dentry, struct nameidata *nd)
         }
         res = d_add_unique(dentry, igrab(state->inode));
         if (res != NULL)
-                dentry = res;
+                path.dentry = res;
         nfs4_intent_set_file(nd, &path, state);
         return res;
 }
diff --git a/fs/nfs/super.c b/fs/nfs/super.c
index b2a851c1b8cb..8ed593766f16 100644
--- a/fs/nfs/super.c
+++ b/fs/nfs/super.c
@@ -911,13 +911,13 @@ static int nfs_parse_mount_options(char *raw,
                         kfree(string);
 
                         switch (token) {
-                        case Opt_udp:
+                        case Opt_xprt_udp:
                                 mnt->flags &= ~NFS_MOUNT_TCP;
                                 mnt->nfs_server.protocol = IPPROTO_UDP;
                                 mnt->timeo = 7;
                                 mnt->retrans = 5;
                                 break;
-                        case Opt_tcp:
+                        case Opt_xprt_tcp:
                                 mnt->flags |= NFS_MOUNT_TCP;
                                 mnt->nfs_server.protocol = IPPROTO_TCP;
                                 mnt->timeo = 600;
@@ -936,10 +936,10 @@ static int nfs_parse_mount_options(char *raw,
                         kfree(string);
 
                         switch (token) {
-                        case Opt_udp:
+                        case Opt_xprt_udp:
                                 mnt->mount_server.protocol = IPPROTO_UDP;
                                 break;
-                        case Opt_tcp:
+                        case Opt_xprt_tcp:
                                 mnt->mount_server.protocol = IPPROTO_TCP;
                                 break;
                         default:
@@ -1153,20 +1153,20 @@ static int nfs_validate_mount_data(struct nfs_mount_data **options,
                 c = strchr(dev_name, ':');
                 if (c == NULL)
                         return -EINVAL;
-                len = c - dev_name - 1;
+                len = c - dev_name;
                 if (len > sizeof(data->hostname))
-                        return -EINVAL;
+                        return -ENAMETOOLONG;
                 strncpy(data->hostname, dev_name, len);
                 args.nfs_server.hostname = data->hostname;
 
                 c++;
                 if (strlen(c) > NFS_MAXPATHLEN)
-                        return -EINVAL;
+                        return -ENAMETOOLONG;
                 args.nfs_server.export_path = c;
 
                 status = nfs_try_mount(&args, mntfh);
                 if (status)
-                        return -EINVAL;
+                        return status;
 
                 /*
                  * Translate to nfs_mount_data, which nfs_fill_super
@@ -1303,34 +1303,6 @@ static void nfs_clone_super(struct super_block *sb,
         nfs_initialise_sb(sb);
 }
 
-static int nfs_set_super(struct super_block *s, void *_server)
-{
-        struct nfs_server *server = _server;
-        int ret;
-
-        s->s_fs_info = server;
-        ret = set_anon_super(s, server);
-        if (ret == 0)
-                server->s_dev = s->s_dev;
-        return ret;
-}
-
-static int nfs_compare_super(struct super_block *sb, void *data)
-{
-        struct nfs_server *server = data, *old = NFS_SB(sb);
-
-        if (memcmp(&old->nfs_client->cl_addr,
-                                &server->nfs_client->cl_addr,
-                                sizeof(old->nfs_client->cl_addr)) != 0)
-                return 0;
-        /* Note: NFS_MOUNT_UNSHARED == NFS4_MOUNT_UNSHARED */
-        if (old->flags & NFS_MOUNT_UNSHARED)
-                return 0;
-        if (memcmp(&old->fsid, &server->fsid, sizeof(old->fsid)) != 0)
-                return 0;
-        return 1;
-}
-
 #define NFS_MS_MASK (MS_RDONLY|MS_NOSUID|MS_NODEV|MS_NOEXEC|MS_SYNCHRONOUS)
 
 static int nfs_compare_mount_options(const struct super_block *s, const struct nfs_server *b, int flags)
@@ -1359,9 +1331,46 @@ static int nfs_compare_mount_options(const struct super_block *s, const struct n
                 goto Ebusy;
         if (clnt_a->cl_auth->au_flavor != clnt_b->cl_auth->au_flavor)
                 goto Ebusy;
-        return 0;
+        return 1;
 Ebusy:
-        return -EBUSY;
+        return 0;
+}
+
+struct nfs_sb_mountdata {
+        struct nfs_server *server;
+        int mntflags;
+};
+
+static int nfs_set_super(struct super_block *s, void *data)
+{
+        struct nfs_sb_mountdata *sb_mntdata = data;
+        struct nfs_server *server = sb_mntdata->server;
+        int ret;
+
+        s->s_flags = sb_mntdata->mntflags;
+        s->s_fs_info = server;
+        ret = set_anon_super(s, server);
+        if (ret == 0)
+                server->s_dev = s->s_dev;
+        return ret;
+}
+
+static int nfs_compare_super(struct super_block *sb, void *data)
+{
+        struct nfs_sb_mountdata *sb_mntdata = data;
+        struct nfs_server *server = sb_mntdata->server, *old = NFS_SB(sb);
+        int mntflags = sb_mntdata->mntflags;
+
+        if (memcmp(&old->nfs_client->cl_addr,
+                                &server->nfs_client->cl_addr,
+                                sizeof(old->nfs_client->cl_addr)) != 0)
+                return 0;
+        /* Note: NFS_MOUNT_UNSHARED == NFS4_MOUNT_UNSHARED */
+        if (old->flags & NFS_MOUNT_UNSHARED)
+                return 0;
+        if (memcmp(&old->fsid, &server->fsid, sizeof(old->fsid)) != 0)
+                return 0;
+        return nfs_compare_mount_options(sb, server, mntflags);
 }
 
 static int nfs_get_sb(struct file_system_type *fs_type,
@@ -1373,6 +1382,9 @@ static int nfs_get_sb(struct file_system_type *fs_type,
         struct nfs_mount_data *data = raw_data;
         struct dentry *mntroot;
         int (*compare_super)(struct super_block *, void *) = nfs_compare_super;
+        struct nfs_sb_mountdata sb_mntdata = {
+                .mntflags = flags,
+        };
         int error;
 
         /* Validate the mount data */
@@ -1386,28 +1398,25 @@ static int nfs_get_sb(struct file_system_type *fs_type,
                 error = PTR_ERR(server);
                 goto out;
         }
+        sb_mntdata.server = server;
 
         if (server->flags & NFS_MOUNT_UNSHARED)
                 compare_super = NULL;
 
         /* Get a superblock - note that we may end up sharing one that already exists */
-        s = sget(fs_type, compare_super, nfs_set_super, server);
+        s = sget(fs_type, compare_super, nfs_set_super, &sb_mntdata);
         if (IS_ERR(s)) {
                 error = PTR_ERR(s);
                 goto out_err_nosb;
         }
 
         if (s->s_fs_info != server) {
-                error = nfs_compare_mount_options(s, server, flags);
                 nfs_free_server(server);
                 server = NULL;
-                if (error < 0)
-                        goto error_splat_super;
         }
 
         if (!s->s_root) {
                 /* initial superblock/root creation */
-                s->s_flags = flags;
                 nfs_fill_super(s, data);
         }
 
@@ -1460,6 +1469,9 @@ static int nfs_xdev_get_sb(struct file_system_type *fs_type, int flags,
         struct nfs_server *server;
         struct dentry *mntroot;
         int (*compare_super)(struct super_block *, void *) = nfs_compare_super;
+        struct nfs_sb_mountdata sb_mntdata = {
+                .mntflags = flags,
+        };
         int error;
 
         dprintk("--> nfs_xdev_get_sb()\n");
@@ -1470,28 +1482,25 @@ static int nfs_xdev_get_sb(struct file_system_type *fs_type, int flags,
                 error = PTR_ERR(server);
                 goto out_err_noserver;
         }
+        sb_mntdata.server = server;
 
         if (server->flags & NFS_MOUNT_UNSHARED)
                 compare_super = NULL;
 
         /* Get a superblock - note that we may end up sharing one that already exists */
-        s = sget(&nfs_fs_type, compare_super, nfs_set_super, server);
+        s = sget(&nfs_fs_type, compare_super, nfs_set_super, &sb_mntdata);
         if (IS_ERR(s)) {
                 error = PTR_ERR(s);
                 goto out_err_nosb;
         }
 
         if (s->s_fs_info != server) {
-                error = nfs_compare_mount_options(s, server, flags);
                 nfs_free_server(server);
                 server = NULL;
-                if (error < 0)
-                        goto error_splat_super;
         }
 
         if (!s->s_root) {
                 /* initial superblock/root creation */
-                s->s_flags = flags;
                 nfs_clone_super(s, data->sb);
         }
 
@@ -1668,7 +1677,7 @@ static int nfs4_validate_mount_data(struct nfs4_mount_data **options,
                 /* while calculating len, pretend ':' is '\0' */
                 len = c - dev_name;
                 if (len > NFS4_MAXNAMLEN)
-                        return -EINVAL;
+                        return -ENAMETOOLONG;
                 *hostname = kzalloc(len, GFP_KERNEL);
                 if (*hostname == NULL)
                         return -ENOMEM;
@@ -1677,7 +1686,7 @@ static int nfs4_validate_mount_data(struct nfs4_mount_data **options,
                 c++;                    /* step over the ':' */
                 len = strlen(c);
                 if (len > NFS4_MAXPATHLEN)
-                        return -EINVAL;
+                        return -ENAMETOOLONG;
                 *mntpath = kzalloc(len + 1, GFP_KERNEL);
                 if (*mntpath == NULL)
                         return -ENOMEM;
@@ -1729,6 +1738,9 @@ static int nfs4_get_sb(struct file_system_type *fs_type,
         struct dentry *mntroot;
         char *mntpath = NULL, *hostname = NULL, *ip_addr = NULL;
         int (*compare_super)(struct super_block *, void *) = nfs_compare_super;
+        struct nfs_sb_mountdata sb_mntdata = {
+                .mntflags = flags,
+        };
         int error;
 
         /* Validate the mount data */
@@ -1744,12 +1756,13 @@ static int nfs4_get_sb(struct file_system_type *fs_type,
                 error = PTR_ERR(server);
                 goto out;
         }
+        sb_mntdata.server = server;
 
         if (server->flags & NFS4_MOUNT_UNSHARED)
                 compare_super = NULL;
 
         /* Get a superblock - note that we may end up sharing one that already exists */
-        s = sget(fs_type, compare_super, nfs_set_super, server);
+        s = sget(fs_type, compare_super, nfs_set_super, &sb_mntdata);
         if (IS_ERR(s)) {
                 error = PTR_ERR(s);
                 goto out_free;
@@ -1762,7 +1775,6 @@ static int nfs4_get_sb(struct file_system_type *fs_type,
 
         if (!s->s_root) {
                 /* initial superblock/root creation */
-                s->s_flags = flags;
                 nfs4_fill_super(s);
         }
 
@@ -1816,6 +1828,9 @@ static int nfs4_xdev_get_sb(struct file_system_type *fs_type, int flags,
         struct nfs_server *server;
         struct dentry *mntroot;
         int (*compare_super)(struct super_block *, void *) = nfs_compare_super;
+        struct nfs_sb_mountdata sb_mntdata = {
+                .mntflags = flags,
+        };
         int error;
 
         dprintk("--> nfs4_xdev_get_sb()\n");
@@ -1826,12 +1841,13 @@ static int nfs4_xdev_get_sb(struct file_system_type *fs_type, int flags,
                 error = PTR_ERR(server);
                 goto out_err_noserver;
         }
+        sb_mntdata.server = server;
 
         if (server->flags & NFS4_MOUNT_UNSHARED)
                 compare_super = NULL;
 
         /* Get a superblock - note that we may end up sharing one that already exists */
-        s = sget(&nfs_fs_type, compare_super, nfs_set_super, server);
+        s = sget(&nfs_fs_type, compare_super, nfs_set_super, &sb_mntdata);
         if (IS_ERR(s)) {
                 error = PTR_ERR(s);
                 goto out_err_nosb;
@@ -1844,7 +1860,6 @@ static int nfs4_xdev_get_sb(struct file_system_type *fs_type, int flags,
 
         if (!s->s_root) {
                 /* initial superblock/root creation */
-                s->s_flags = flags;
                 nfs4_clone_super(s, data->sb);
         }
 
@@ -1887,6 +1902,9 @@ static int nfs4_referral_get_sb(struct file_system_type *fs_type, int flags,
         struct dentry *mntroot;
         struct nfs_fh mntfh;
         int (*compare_super)(struct super_block *, void *) = nfs_compare_super;
+        struct nfs_sb_mountdata sb_mntdata = {
+                .mntflags = flags,
+        };
         int error;
 
         dprintk("--> nfs4_referral_get_sb()\n");
@@ -1897,12 +1915,13 @@ static int nfs4_referral_get_sb(struct file_system_type *fs_type, int flags,
                 error = PTR_ERR(server);
                 goto out_err_noserver;
         }
+        sb_mntdata.server = server;
 
         if (server->flags & NFS4_MOUNT_UNSHARED)
                 compare_super = NULL;
 
         /* Get a superblock - note that we may end up sharing one that already exists */
-        s = sget(&nfs_fs_type, compare_super, nfs_set_super, server);
+        s = sget(&nfs_fs_type, compare_super, nfs_set_super, &sb_mntdata);
         if (IS_ERR(s)) {
                 error = PTR_ERR(s);
                 goto out_err_nosb;
@@ -1915,7 +1934,6 @@ static int nfs4_referral_get_sb(struct file_system_type *fs_type, int flags,
 
         if (!s->s_root) {
                 /* initial superblock/root creation */
-                s->s_flags = flags;
                 nfs4_fill_super(s);
         }
 
diff --git a/fs/nfs/write.c b/fs/nfs/write.c
index ef97e0c0f5b1..0d7a77cc394b 100644
--- a/fs/nfs/write.c
+++ b/fs/nfs/write.c
@@ -1396,6 +1396,50 @@ out:
         return ret;
 }
 
+int nfs_wb_page_cancel(struct inode *inode, struct page *page)
+{
+        struct nfs_page *req;
+        loff_t range_start = page_offset(page);
+        loff_t range_end = range_start + (loff_t)(PAGE_CACHE_SIZE - 1);
+        struct writeback_control wbc = {
+                .bdi = page->mapping->backing_dev_info,
+                .sync_mode = WB_SYNC_ALL,
+                .nr_to_write = LONG_MAX,
+                .range_start = range_start,
+                .range_end = range_end,
+        };
+        int ret = 0;
+
+        BUG_ON(!PageLocked(page));
+        for (;;) {
+                req = nfs_page_find_request(page);
+                if (req == NULL)
+                        goto out;
+                if (test_bit(PG_NEED_COMMIT, &req->wb_flags)) {
+                        nfs_release_request(req);
+                        break;
+                }
+                if (nfs_lock_request_dontget(req)) {
+                        nfs_inode_remove_request(req);
+                        /*
+                         * In case nfs_inode_remove_request has marked the
+                         * page as being dirty
+                         */
+                        cancel_dirty_page(page, PAGE_CACHE_SIZE);
+                        nfs_unlock_request(req);
+                        break;
+                }
+                ret = nfs_wait_on_request(req);
+                if (ret < 0)
+                        goto out;
+        }
+        if (!PagePrivate(page))
+                return 0;
+        ret = nfs_sync_mapping_wait(page->mapping, &wbc, FLUSH_INVALIDATE);
+out:
+        return ret;
+}
+
 int nfs_wb_page_priority(struct inode *inode, struct page *page, int how)
 {
         loff_t range_start = page_offset(page);