Merge branch 'next'

14 files changed, 321 insertions, 211 deletions

diff --git a/fs/nfs/client.c b/fs/nfs/client.c
index 5ee23e7058b3..7547600b6174 100644
--- a/fs/nfs/client.c
+++ b/fs/nfs/client.c
@@ -675,7 +675,7 @@ static int nfs_init_server(struct nfs_server *server,
         server->nfs_client = clp;
 
         /* Initialise the client representation from the mount data */
-        server->flags = data->flags & NFS_MOUNT_FLAGMASK;
+        server->flags = data->flags;
 
         if (data->rsize)
                 server->rsize = nfs_block_size(data->rsize, NULL);
@@ -850,7 +850,6 @@ static struct nfs_server *nfs_alloc_server(void)
         INIT_LIST_HEAD(&server->client_link);
         INIT_LIST_HEAD(&server->master_link);
 
-        init_waitqueue_head(&server->active_wq);
         atomic_set(&server->active, 0);
 
         server->io_stats = nfs_alloc_iostats();
@@ -1073,7 +1072,7 @@ static int nfs4_init_server(struct nfs_server *server,
                 goto error;
 
         /* Initialise the client representation from the mount data */
-        server->flags = data->flags & NFS_MOUNT_FLAGMASK;
+        server->flags = data->flags;
         server->caps |= NFS_CAP_ATOMIC_OPEN;
 
         if (data->rsize)
diff --git a/fs/nfs/dir.c b/fs/nfs/dir.c
index 74f92b717f78..2ab70d46ecbc 100644
--- a/fs/nfs/dir.c
+++ b/fs/nfs/dir.c
@@ -156,6 +156,7 @@ typedef struct {
         decode_dirent_t decode;
         int             plus;
         unsigned long   timestamp;
+        unsigned long   gencount;
         int             timestamp_valid;
 } nfs_readdir_descriptor_t;
 
@@ -177,7 +178,7 @@ int nfs_readdir_filler(nfs_readdir_descriptor_t *desc, struct page *page)
         struct file     *file = desc->file;
         struct inode    *inode = file->f_path.dentry->d_inode;
         struct rpc_cred *cred = nfs_file_cred(file);
-        unsigned long   timestamp;
+        unsigned long   timestamp, gencount;
         int             error;
 
         dfprintk(DIRCACHE, "NFS: %s: reading cookie %Lu into page %lu\n",
@@ -186,6 +187,7 @@ int nfs_readdir_filler(nfs_readdir_descriptor_t *desc, struct page *page)
 
  again:
         timestamp = jiffies;
+        gencount = nfs_inc_attr_generation_counter();
         error = NFS_PROTO(inode)->readdir(file->f_path.dentry, cred, desc->entry->cookie, page,
                                           NFS_SERVER(inode)->dtsize, desc->plus);
         if (error < 0) {
@@ -199,6 +201,7 @@ int nfs_readdir_filler(nfs_readdir_descriptor_t *desc, struct page *page)
                 goto error;
         }
         desc->timestamp = timestamp;
+        desc->gencount = gencount;
         desc->timestamp_valid = 1;
         SetPageUptodate(page);
         /* Ensure consistent page alignment of the data.
@@ -224,9 +227,10 @@ int dir_decode(nfs_readdir_descriptor_t *desc)
         if (IS_ERR(p))
                 return PTR_ERR(p);
         desc->ptr = p;
-        if (desc->timestamp_valid)
+        if (desc->timestamp_valid) {
                 desc->entry->fattr->time_start = desc->timestamp;
-        else
+                desc->entry->fattr->gencount = desc->gencount;
+        } else
                 desc->entry->fattr->valid &= ~NFS_ATTR_FATTR;
         return 0;
 }
@@ -471,7 +475,7 @@ int uncached_readdir(nfs_readdir_descriptor_t *desc, void *dirent,
         struct rpc_cred *cred = nfs_file_cred(file);
         struct page     *page = NULL;
         int             status;
-        unsigned long   timestamp;
+        unsigned long   timestamp, gencount;
 
         dfprintk(DIRCACHE, "NFS: uncached_readdir() searching for cookie %Lu\n",
                         (unsigned long long)*desc->dir_cookie);
@@ -482,6 +486,7 @@ int uncached_readdir(nfs_readdir_descriptor_t *desc, void *dirent,
                 goto out;
         }
         timestamp = jiffies;
+        gencount = nfs_inc_attr_generation_counter();
         status = NFS_PROTO(inode)->readdir(file->f_path.dentry, cred,
                                                 *desc->dir_cookie, page,
                                                 NFS_SERVER(inode)->dtsize,
@@ -490,6 +495,7 @@ int uncached_readdir(nfs_readdir_descriptor_t *desc, void *dirent,
         desc->ptr = kmap(page);         /* matching kunmap in nfs_do_filldir */
         if (status >= 0) {
                 desc->timestamp = timestamp;
+                desc->gencount = gencount;
                 desc->timestamp_valid = 1;
                 if ((status = dir_decode(desc)) == 0)
                         desc->entry->prev_cookie = *desc->dir_cookie;
@@ -655,7 +661,7 @@ static int nfs_fsync_dir(struct file *filp, struct dentry *dentry, int datasync)
  */
 void nfs_force_lookup_revalidate(struct inode *dir)
 {
-        NFS_I(dir)->cache_change_attribute = jiffies;
+        NFS_I(dir)->cache_change_attribute++;
 }
 
 /*
@@ -667,6 +673,8 @@ static int nfs_check_verifier(struct inode *dir, struct dentry *dentry)
 {
         if (IS_ROOT(dentry))
                 return 1;
+        if (NFS_SERVER(dir)->flags & NFS_MOUNT_LOOKUP_CACHE_NONE)
+                return 0;
         if (!nfs_verify_change_attribute(dir, dentry->d_time))
                 return 0;
         /* Revalidate nfsi->cache_change_attribute before we declare a match */
@@ -750,6 +758,8 @@ int nfs_neg_need_reval(struct inode *dir, struct dentry *dentry,
         /* Don't revalidate a negative dentry if we're creating a new file */
         if (nd != NULL && nfs_lookup_check_intent(nd, LOOKUP_CREATE) != 0)
                 return 0;
+        if (NFS_SERVER(dir)->flags & NFS_MOUNT_LOOKUP_CACHE_NONEG)
+                return 1;
         return !nfs_check_verifier(dir, dentry);
 }
 
diff --git a/fs/nfs/file.c b/fs/nfs/file.c
index 78460657f5cb..d319b49f8f06 100644
--- a/fs/nfs/file.c
+++ b/fs/nfs/file.c
@@ -188,13 +188,16 @@ static loff_t nfs_file_llseek(struct file *filp, loff_t offset, int origin)
         /* origin == SEEK_END => we must revalidate the cached file length */
         if (origin == SEEK_END) {
                 struct inode *inode = filp->f_mapping->host;
+
                 int retval = nfs_revalidate_file_size(inode, filp);
                 if (retval < 0)
                         return (loff_t)retval;
-        }
-        lock_kernel();  /* BKL needed? */
-        loff = generic_file_llseek_unlocked(filp, offset, origin);
-        unlock_kernel();
+
+                spin_lock(&inode->i_lock);
+                loff = generic_file_llseek_unlocked(filp, offset, origin);
+                spin_unlock(&inode->i_lock);
+        } else
+                loff = generic_file_llseek_unlocked(filp, offset, origin);
         return loff;
 }
 
@@ -699,13 +702,6 @@ static int nfs_flock(struct file *filp, int cmd, struct file_lock *fl)
                         filp->f_path.dentry->d_name.name,
                         fl->fl_type, fl->fl_flags);
 
-        /*
-         * No BSD flocks over NFS allowed.
-         * Note: we could try to fake a POSIX lock request here by
-         * using ((u32) filp | 0x80000000) or some such as the pid.
-         * Not sure whether that would be unique, though, or whether
-         * that would break in other places.
-         */
         if (!(fl->fl_flags & FL_FLOCK))
                 return -ENOLCK;
 
diff --git a/fs/nfs/inode.c b/fs/nfs/inode.c
index 52daefa2f521..b9195c02a863 100644
--- a/fs/nfs/inode.c
+++ b/fs/nfs/inode.c
@@ -305,8 +305,7 @@ nfs_fhget(struct super_block *sb, struct nfs_fh *fh, struct nfs_fattr *fattr)
                         init_special_inode(inode, inode->i_mode, fattr->rdev);
 
                 nfsi->read_cache_jiffies = fattr->time_start;
-                nfsi->last_updated = now;
-                nfsi->cache_change_attribute = now;
+                nfsi->attr_gencount = fattr->gencount;
                 inode->i_atime = fattr->atime;
                 inode->i_mtime = fattr->mtime;
                 inode->i_ctime = fattr->ctime;
@@ -453,6 +452,7 @@ out_big:
 void nfs_setattr_update_inode(struct inode *inode, struct iattr *attr)
 {
         if ((attr->ia_valid & (ATTR_MODE|ATTR_UID|ATTR_GID)) != 0) {
+                spin_lock(&inode->i_lock);
                 if ((attr->ia_valid & ATTR_MODE) != 0) {
                         int mode = attr->ia_mode & S_IALLUGO;
                         mode |= inode->i_mode & ~S_IALLUGO;
@@ -462,7 +462,6 @@ void nfs_setattr_update_inode(struct inode *inode, struct iattr *attr)
                         inode->i_uid = attr->ia_uid;
                 if ((attr->ia_valid & ATTR_GID) != 0)
                         inode->i_gid = attr->ia_gid;
-                spin_lock(&inode->i_lock);
                 NFS_I(inode)->cache_validity |= NFS_INO_INVALID_ACCESS|NFS_INO_INVALID_ACL;
                 spin_unlock(&inode->i_lock);
         }
@@ -472,37 +471,6 @@ void nfs_setattr_update_inode(struct inode *inode, struct iattr *attr)
         }
 }
 
-static int nfs_wait_schedule(void *word)
-{
-        if (signal_pending(current))
-                return -ERESTARTSYS;
-        schedule();
-        return 0;
-}
-
-/*
- * Wait for the inode to get unlocked.
- */
-static int nfs_wait_on_inode(struct inode *inode)
-{
-        struct nfs_inode *nfsi = NFS_I(inode);
-        int error;
-
-        error = wait_on_bit_lock(&nfsi->flags, NFS_INO_REVALIDATING,
-                                        nfs_wait_schedule, TASK_KILLABLE);
-
-        return error;
-}
-
-static void nfs_wake_up_inode(struct inode *inode)
-{
-        struct nfs_inode *nfsi = NFS_I(inode);
-
-        clear_bit(NFS_INO_REVALIDATING, &nfsi->flags);
-        smp_mb__after_clear_bit();
-        wake_up_bit(&nfsi->flags, NFS_INO_REVALIDATING);
-}
-
 int nfs_getattr(struct vfsmount *mnt, struct dentry *dentry, struct kstat *stat)
 {
         struct inode *inode = dentry->d_inode;
@@ -697,20 +665,15 @@ __nfs_revalidate_inode(struct nfs_server *server, struct inode *inode)
         dfprintk(PAGECACHE, "NFS: revalidating (%s/%Ld)\n",
                 inode->i_sb->s_id, (long long)NFS_FILEID(inode));
 
-        nfs_inc_stats(inode, NFSIOS_INODEREVALIDATE);
         if (is_bad_inode(inode))
-                goto out_nowait;
+                goto out;
         if (NFS_STALE(inode))
-                goto out_nowait;
-
-        status = nfs_wait_on_inode(inode);
-        if (status < 0)
                 goto out;
 
-        status = -ESTALE;
         if (NFS_STALE(inode))
                 goto out;
 
+        nfs_inc_stats(inode, NFSIOS_INODEREVALIDATE);
         status = NFS_PROTO(inode)->getattr(server, NFS_FH(inode), &fattr);
         if (status != 0) {
                 dfprintk(PAGECACHE, "nfs_revalidate_inode: (%s/%Ld) getattr failed, error=%d\n",
@@ -724,16 +687,13 @@ __nfs_revalidate_inode(struct nfs_server *server, struct inode *inode)
                 goto out;
         }
 
-        spin_lock(&inode->i_lock);
-        status = nfs_update_inode(inode, &fattr);
+        status = nfs_refresh_inode(inode, &fattr);
         if (status) {
-                spin_unlock(&inode->i_lock);
                 dfprintk(PAGECACHE, "nfs_revalidate_inode: (%s/%Ld) refresh failed, error=%d\n",
                          inode->i_sb->s_id,
                          (long long)NFS_FILEID(inode), status);
                 goto out;
         }
-        spin_unlock(&inode->i_lock);
 
         if (nfsi->cache_validity & NFS_INO_INVALID_ACL)
                 nfs_zap_acl_cache(inode);
@@ -743,9 +703,6 @@ __nfs_revalidate_inode(struct nfs_server *server, struct inode *inode)
                 (long long)NFS_FILEID(inode));
 
  out:
-        nfs_wake_up_inode(inode);
-
- out_nowait:
         return status;
 }
 
@@ -908,9 +865,6 @@ static int nfs_check_inode_attributes(struct inode *inode, struct nfs_fattr *fat
                 return -EIO;
         }
 
-        /* Do atomic weak cache consistency updates */
-        nfs_wcc_update_inode(inode, fattr);
-
         if ((fattr->valid & NFS_ATTR_FATTR_V4) != 0 &&
                         nfsi->change_attr != fattr->change_attr)
                 invalid |= NFS_INO_INVALID_ATTR|NFS_INO_REVAL_PAGECACHE;
@@ -939,15 +893,81 @@ static int nfs_check_inode_attributes(struct inode *inode, struct nfs_fattr *fat
 
         if (invalid != 0)
                 nfsi->cache_validity |= invalid;
-        else
-                nfsi->cache_validity &= ~(NFS_INO_INVALID_ATTR
-                                | NFS_INO_INVALID_ATIME
-                                | NFS_INO_REVAL_PAGECACHE);
 
         nfsi->read_cache_jiffies = fattr->time_start;
         return 0;
 }
 
+static int nfs_ctime_need_update(const struct inode *inode, const struct nfs_fattr *fattr)
+{
+        return timespec_compare(&fattr->ctime, &inode->i_ctime) > 0;
+}
+
+static int nfs_size_need_update(const struct inode *inode, const struct nfs_fattr *fattr)
+{
+        return nfs_size_to_loff_t(fattr->size) > i_size_read(inode);
+}
+
+static unsigned long nfs_attr_generation_counter;
+
+static unsigned long nfs_read_attr_generation_counter(void)
+{
+        smp_rmb();
+        return nfs_attr_generation_counter;
+}
+
+unsigned long nfs_inc_attr_generation_counter(void)
+{
+        unsigned long ret;
+        smp_rmb();
+        ret = ++nfs_attr_generation_counter;
+        smp_wmb();
+        return ret;
+}
+
+void nfs_fattr_init(struct nfs_fattr *fattr)
+{
+        fattr->valid = 0;
+        fattr->time_start = jiffies;
+        fattr->gencount = nfs_inc_attr_generation_counter();
+}
+
+/**
+ * nfs_inode_attrs_need_update - check if the inode attributes need updating
+ * @inode - pointer to inode
+ * @fattr - attributes
+ *
+ * Attempt to divine whether or not an RPC call reply carrying stale
+ * attributes got scheduled after another call carrying updated ones.
+ *
+ * To do so, the function first assumes that a more recent ctime means
+ * that the attributes in fattr are newer, however it also attempt to
+ * catch the case where ctime either didn't change, or went backwards
+ * (if someone reset the clock on the server) by looking at whether
+ * or not this RPC call was started after the inode was last updated.
+ * Note also the check for wraparound of 'attr_gencount'
+ *
+ * The function returns 'true' if it thinks the attributes in 'fattr' are
+ * more recent than the ones cached in the inode.
+ *
+ */
+static int nfs_inode_attrs_need_update(const struct inode *inode, const struct nfs_fattr *fattr)
+{
+        const struct nfs_inode *nfsi = NFS_I(inode);
+
+        return ((long)fattr->gencount - (long)nfsi->attr_gencount) > 0 ||
+                nfs_ctime_need_update(inode, fattr) ||
+                nfs_size_need_update(inode, fattr) ||
+                ((long)nfsi->attr_gencount - (long)nfs_read_attr_generation_counter() > 0);
+}
+
+static int nfs_refresh_inode_locked(struct inode *inode, struct nfs_fattr *fattr)
+{
+        if (nfs_inode_attrs_need_update(inode, fattr))
+                return nfs_update_inode(inode, fattr);
+        return nfs_check_inode_attributes(inode, fattr);
+}
+
 /**
  * nfs_refresh_inode - try to update the inode attribute cache
  * @inode - pointer to inode
@@ -960,21 +980,28 @@ static int nfs_check_inode_attributes(struct inode *inode, struct nfs_fattr *fat
  */
 int nfs_refresh_inode(struct inode *inode, struct nfs_fattr *fattr)
 {
-        struct nfs_inode *nfsi = NFS_I(inode);
         int status;
 
         if ((fattr->valid & NFS_ATTR_FATTR) == 0)
                 return 0;
         spin_lock(&inode->i_lock);
-        if (time_after(fattr->time_start, nfsi->last_updated))
-                status = nfs_update_inode(inode, fattr);
-        else
-                status = nfs_check_inode_attributes(inode, fattr);
-
+        status = nfs_refresh_inode_locked(inode, fattr);
         spin_unlock(&inode->i_lock);
         return status;
 }
 
+static int nfs_post_op_update_inode_locked(struct inode *inode, struct nfs_fattr *fattr)
+{
+        struct nfs_inode *nfsi = NFS_I(inode);
+
+        nfsi->cache_validity |= NFS_INO_INVALID_ATTR|NFS_INO_REVAL_PAGECACHE;
+        if (S_ISDIR(inode->i_mode))
+                nfsi->cache_validity |= NFS_INO_INVALID_DATA;
+        if ((fattr->valid & NFS_ATTR_FATTR) == 0)
+                return 0;
+        return nfs_refresh_inode_locked(inode, fattr);
+}
+
 /**
  * nfs_post_op_update_inode - try to update the inode attribute cache
  * @inode - pointer to inode
@@ -991,14 +1018,12 @@ int nfs_refresh_inode(struct inode *inode, struct nfs_fattr *fattr)
  */
 int nfs_post_op_update_inode(struct inode *inode, struct nfs_fattr *fattr)
 {
-        struct nfs_inode *nfsi = NFS_I(inode);
+        int status;
 
         spin_lock(&inode->i_lock);
-        nfsi->cache_validity |= NFS_INO_INVALID_ATTR|NFS_INO_REVAL_PAGECACHE;
-        if (S_ISDIR(inode->i_mode))
-                nfsi->cache_validity |= NFS_INO_INVALID_DATA;
+        status = nfs_post_op_update_inode_locked(inode, fattr);
         spin_unlock(&inode->i_lock);
-        return nfs_refresh_inode(inode, fattr);
+        return status;
 }
 
 /**
@@ -1014,6 +1039,15 @@ int nfs_post_op_update_inode(struct inode *inode, struct nfs_fattr *fattr)
  */
 int nfs_post_op_update_inode_force_wcc(struct inode *inode, struct nfs_fattr *fattr)
 {
+        int status;
+
+        spin_lock(&inode->i_lock);
+        /* Don't do a WCC update if these attributes are already stale */
+        if ((fattr->valid & NFS_ATTR_FATTR) == 0 ||
+                        !nfs_inode_attrs_need_update(inode, fattr)) {
+                fattr->valid &= ~(NFS_ATTR_WCC_V4|NFS_ATTR_WCC);
+                goto out_noforce;
+        }
         if ((fattr->valid & NFS_ATTR_FATTR_V4) != 0 &&
                         (fattr->valid & NFS_ATTR_WCC_V4) == 0) {
                 fattr->pre_change_attr = NFS_I(inode)->change_attr;
@@ -1026,7 +1060,10 @@ int nfs_post_op_update_inode_force_wcc(struct inode *inode, struct nfs_fattr *fa
                 fattr->pre_size = i_size_read(inode);
                 fattr->valid |= NFS_ATTR_WCC;
         }
-        return nfs_post_op_update_inode(inode, fattr);
+out_noforce:
+        status = nfs_post_op_update_inode_locked(inode, fattr);
+        spin_unlock(&inode->i_lock);
+        return status;
 }
 
 /*
@@ -1092,7 +1129,7 @@ static int nfs_update_inode(struct inode *inode, struct nfs_fattr *fattr)
                 }
                 /* If ctime has changed we should definitely clear access+acl caches */
                 if (!timespec_equal(&inode->i_ctime, &fattr->ctime))
-                        invalid |= NFS_INO_INVALID_ACCESS|NFS_INO_INVALID_ACL;
+                        invalid |= NFS_INO_INVALID_ATTR|NFS_INO_INVALID_ACCESS|NFS_INO_INVALID_ACL;
         } else if (nfsi->change_attr != fattr->change_attr) {
                 dprintk("NFS: change_attr change on server for file %s/%ld\n",
                                 inode->i_sb->s_id, inode->i_ino);
@@ -1126,6 +1163,9 @@ static int nfs_update_inode(struct inode *inode, struct nfs_fattr *fattr)
             inode->i_gid != fattr->gid)
                 invalid |= NFS_INO_INVALID_ATTR|NFS_INO_INVALID_ACCESS|NFS_INO_INVALID_ACL;
 
+        if (inode->i_nlink != fattr->nlink)
+                invalid |= NFS_INO_INVALID_ATTR;
+
         inode->i_mode = fattr->mode;
         inode->i_nlink = fattr->nlink;
         inode->i_uid = fattr->uid;
@@ -1145,18 +1185,13 @@ static int nfs_update_inode(struct inode *inode, struct nfs_fattr *fattr)
                 nfs_inc_stats(inode, NFSIOS_ATTRINVALIDATE);
                 nfsi->attrtimeo = NFS_MINATTRTIMEO(inode);
                 nfsi->attrtimeo_timestamp = now;
-                nfsi->last_updated = now;
+                nfsi->attr_gencount = nfs_inc_attr_generation_counter();
         } else {
                 if (!time_in_range(now, nfsi->attrtimeo_timestamp, nfsi->attrtimeo_timestamp + nfsi->attrtimeo)) {
                         if ((nfsi->attrtimeo <<= 1) > NFS_MAXATTRTIMEO(inode))
                                 nfsi->attrtimeo = NFS_MAXATTRTIMEO(inode);
                         nfsi->attrtimeo_timestamp = now;
                 }
-                /*
-                 * Avoid jiffy wraparound issues with nfsi->last_updated
-                 */
-                if (!time_in_range(nfsi->last_updated, nfsi->read_cache_jiffies, now))
-                        nfsi->last_updated = nfsi->read_cache_jiffies;
         }
         invalid &= ~NFS_INO_INVALID_ATTR;
         /* Don't invalidate the data if we were to blame */
diff --git a/fs/nfs/internal.h b/fs/nfs/internal.h
index 24241fcbb98d..d212ee41caf2 100644
--- a/fs/nfs/internal.h
+++ b/fs/nfs/internal.h
@@ -153,6 +153,7 @@ extern void nfs4_clear_inode(struct inode *);
 void nfs_zap_acl_cache(struct inode *inode);
 
 /* super.c */
+void nfs_parse_ip_address(char *, size_t, struct sockaddr *, size_t *);
 extern struct file_system_type nfs_xdev_fs_type;
 #ifdef CONFIG_NFS_V4
 extern struct file_system_type nfs4_xdev_fs_type;
@@ -163,8 +164,8 @@ extern struct rpc_stat nfs_rpcstat;
 
 extern int __init register_nfs_fs(void);
 extern void __exit unregister_nfs_fs(void);
-extern void nfs_sb_active(struct nfs_server *server);
-extern void nfs_sb_deactive(struct nfs_server *server);
+extern void nfs_sb_active(struct super_block *sb);
+extern void nfs_sb_deactive(struct super_block *sb);
 
 /* namespace.c */
 extern char *nfs_path(const char *base,
@@ -276,3 +277,23 @@ unsigned int nfs_page_array_len(unsigned int base, size_t len)
                 PAGE_SIZE - 1) >> PAGE_SHIFT;
 }
 
+#define IPV6_SCOPE_DELIMITER    '%'
+
+/*
+ * Set the port number in an address.  Be agnostic about the address
+ * family.
+ */
+static inline void nfs_set_port(struct sockaddr *sap, unsigned short port)
+{
+        struct sockaddr_in *ap = (struct sockaddr_in *)sap;
+        struct sockaddr_in6 *ap6 = (struct sockaddr_in6 *)sap;
+
+        switch (sap->sa_family) {
+        case AF_INET:
+                ap->sin_port = htons(port);
+                break;
+        case AF_INET6:
+                ap6->sin6_port = htons(port);
+                break;
+        }
+}
diff --git a/fs/nfs/mount_clnt.c b/fs/nfs/mount_clnt.c
index 779d2eb649c5..086a6830d785 100644
--- a/fs/nfs/mount_clnt.c
+++ b/fs/nfs/mount_clnt.c
@@ -14,6 +14,7 @@
 #include <linux/sunrpc/clnt.h>
 #include <linux/sunrpc/sched.h>
 #include <linux/nfs_fs.h>
+#include "internal.h"
 
 #ifdef RPC_DEBUG
 # define NFSDBG_FACILITY        NFSDBG_MOUNT
@@ -98,7 +99,7 @@ out_call_err:
 
 out_mnt_err:
         dprintk("NFS: MNT server returned result %d\n", result.status);
-        status = -EACCES;
+        status = nfs_stat_to_errno(result.status);
         goto out;
 }
 
diff --git a/fs/nfs/namespace.c b/fs/nfs/namespace.c
index 66df08dd1caf..64a288ee046d 100644
--- a/fs/nfs/namespace.c
+++ b/fs/nfs/namespace.c
@@ -105,7 +105,10 @@ static void * nfs_follow_mountpoint(struct dentry *dentry, struct nameidata *nd)
 
         dprintk("--> nfs_follow_mountpoint()\n");
 
-        BUG_ON(IS_ROOT(dentry));
+        err = -ESTALE;
+        if (IS_ROOT(dentry))
+                goto out_err;
+
         dprintk("%s: enter\n", __func__);
         dput(nd->path.dentry);
         nd->path.dentry = dget(dentry);
@@ -189,7 +192,7 @@ static struct vfsmount *nfs_do_clone_mount(struct nfs_server *server,
                                            struct nfs_clone_mount *mountdata)
 {
 #ifdef CONFIG_NFS_V4
-        struct vfsmount *mnt = NULL;
+        struct vfsmount *mnt = ERR_PTR(-EINVAL);
         switch (server->nfs_client->rpc_ops->version) {
                 case 2:
                 case 3:
diff --git a/fs/nfs/nfs3acl.c b/fs/nfs/nfs3acl.c
index 423842f51ac9..cef62557c87d 100644
--- a/fs/nfs/nfs3acl.c
+++ b/fs/nfs/nfs3acl.c
@@ -229,6 +229,7 @@ struct posix_acl *nfs3_proc_getacl(struct inode *inode, int type)
 
         dprintk("NFS call getacl\n");
         msg.rpc_proc = &server->client_acl->cl_procinfo[ACLPROC3_GETACL];
+        nfs_fattr_init(&fattr);
         status = rpc_call_sync(server->client_acl, &msg, 0);
         dprintk("NFS reply getacl: %d\n", status);
 
@@ -322,6 +323,7 @@ static int nfs3_proc_setacls(struct inode *inode, struct posix_acl *acl,
 
         dprintk("NFS call setacl\n");
         msg.rpc_proc = &server->client_acl->cl_procinfo[ACLPROC3_SETACL];
+        nfs_fattr_init(&fattr);
         status = rpc_call_sync(server->client_acl, &msg, 0);
         nfs_access_zap_cache(inode);
         nfs_zap_acl_cache(inode);
diff --git a/fs/nfs/nfs3proc.c b/fs/nfs/nfs3proc.c
index 1e750e4574a9..c55be7a7679e 100644
--- a/fs/nfs/nfs3proc.c
+++ b/fs/nfs/nfs3proc.c
@@ -699,7 +699,7 @@ nfs3_proc_statfs(struct nfs_server *server, struct nfs_fh *fhandle,
 }
 
 static int
-nfs3_proc_fsinfo(struct nfs_server *server, struct nfs_fh *fhandle,
+do_proc_fsinfo(struct rpc_clnt *client, struct nfs_fh *fhandle,
                  struct nfs_fsinfo *info)
 {
         struct rpc_message msg = {
@@ -711,11 +711,27 @@ nfs3_proc_fsinfo(struct nfs_server *server, struct nfs_fh *fhandle,
 
         dprintk("NFS call  fsinfo\n");
         nfs_fattr_init(info->fattr);
-        status = rpc_call_sync(server->nfs_client->cl_rpcclient, &msg, 0);
+        status = rpc_call_sync(client, &msg, 0);
         dprintk("NFS reply fsinfo: %d\n", status);
         return status;
 }
 
+/*
+ * Bare-bones access to fsinfo: this is for nfs_get_root/nfs_get_sb via
+ * nfs_create_server
+ */
+static int
+nfs3_proc_fsinfo(struct nfs_server *server, struct nfs_fh *fhandle,
+                   struct nfs_fsinfo *info)
+{
+        int     status;
+
+        status = do_proc_fsinfo(server->client, fhandle, info);
+        if (status && server->nfs_client->cl_rpcclient != server->client)
+                status = do_proc_fsinfo(server->nfs_client->cl_rpcclient, fhandle, info);
+        return status;
+}
+
 static int
 nfs3_proc_pathconf(struct nfs_server *server, struct nfs_fh *fhandle,
                    struct nfs_pathconf *info)
diff --git a/fs/nfs/nfs4namespace.c b/fs/nfs/nfs4namespace.c
index b112857301f7..30befc39b3c6 100644
--- a/fs/nfs/nfs4namespace.c
+++ b/fs/nfs/nfs4namespace.c
@@ -93,21 +93,52 @@ static int nfs4_validate_fspath(const struct vfsmount *mnt_parent,
         return 0;
 }
 
-/*
- * Check if the string represents a "valid" IPv4 address
- */
-static inline int valid_ipaddr4(const char *buf)
+static struct vfsmount *try_location(struct nfs_clone_mount *mountdata,
+                                     char *page, char *page2,
+                                     const struct nfs4_fs_location *location)
 {
-        int rc, count, in[4];
-
-        rc = sscanf(buf, "%d.%d.%d.%d", &in[0], &in[1], &in[2], &in[3]);
-        if (rc != 4)
-                return -EINVAL;
-        for (count = 0; count < 4; count++) {
-                if (in[count] > 255)
-                        return -EINVAL;
+        struct vfsmount *mnt = ERR_PTR(-ENOENT);
+        char *mnt_path;
+        int page2len;
+        unsigned int s;
+
+        mnt_path = nfs4_pathname_string(&location->rootpath, page2, PAGE_SIZE);
+        if (IS_ERR(mnt_path))
+                return mnt;
+        mountdata->mnt_path = mnt_path;
+        page2 += strlen(mnt_path) + 1;
+        page2len = PAGE_SIZE - strlen(mnt_path) - 1;
+
+        for (s = 0; s < location->nservers; s++) {
+                const struct nfs4_string *buf = &location->servers[s];
+                struct sockaddr_storage addr;
+
+                if (buf->len <= 0 || buf->len >= PAGE_SIZE)
+                        continue;
+
+                mountdata->addr = (struct sockaddr *)&addr;
+
+                if (memchr(buf->data, IPV6_SCOPE_DELIMITER, buf->len))
+                        continue;
+                nfs_parse_ip_address(buf->data, buf->len,
+                                mountdata->addr, &mountdata->addrlen);
+                if (mountdata->addr->sa_family == AF_UNSPEC)
+                        continue;
+                nfs_set_port(mountdata->addr, NFS_PORT);
+
+                strncpy(page2, buf->data, page2len);
+                page2[page2len] = '\0';
+                mountdata->hostname = page2;
+
+                snprintf(page, PAGE_SIZE, "%s:%s",
+                                mountdata->hostname,
+                                mountdata->mnt_path);
+
+                mnt = vfs_kern_mount(&nfs4_referral_fs_type, 0, page, mountdata);
+                if (!IS_ERR(mnt))
+                        break;
         }
-        return 0;
+        return mnt;
 }
 
 /**
@@ -128,7 +159,6 @@ static struct vfsmount *nfs_follow_referral(const struct vfsmount *mnt_parent,
                 .authflavor = NFS_SB(mnt_parent->mnt_sb)->client->cl_auth->au_flavor,
         };
         char *page = NULL, *page2 = NULL;
-        unsigned int s;
         int loc, error;
 
         if (locations == NULL || locations->nlocations <= 0)
@@ -152,53 +182,16 @@ static struct vfsmount *nfs_follow_referral(const struct vfsmount *mnt_parent,
                 goto out;
         }
 
-        loc = 0;
-        while (loc < locations->nlocations && IS_ERR(mnt)) {
+        for (loc = 0; loc < locations->nlocations; loc++) {
                 const struct nfs4_fs_location *location = &locations->locations[loc];
-                char *mnt_path;
 
                 if (location == NULL || location->nservers <= 0 ||
-                    location->rootpath.ncomponents == 0) {
-                        loc++;
+                    location->rootpath.ncomponents == 0)
                         continue;
-                }
 
-                mnt_path = nfs4_pathname_string(&location->rootpath, page2, PAGE_SIZE);
-                if (IS_ERR(mnt_path)) {
-                        loc++;
-                        continue;
-                }
-                mountdata.mnt_path = mnt_path;
-
-                s = 0;
-                while (s < location->nservers) {
-                        struct sockaddr_in addr = {
-                                .sin_family     = AF_INET,
-                                .sin_port       = htons(NFS_PORT),
-                        };
-
-                        if (location->servers[s].len <= 0 ||
-                            valid_ipaddr4(location->servers[s].data) < 0) {
-                                s++;
-                                continue;
-                        }
-
-                        mountdata.hostname = location->servers[s].data;
-                        addr.sin_addr.s_addr = in_aton(mountdata.hostname),
-                        mountdata.addr = (struct sockaddr *)&addr;
-                        mountdata.addrlen = sizeof(addr);
-
-                        snprintf(page, PAGE_SIZE, "%s:%s",
-                                        mountdata.hostname,
-                                        mountdata.mnt_path);
-
-                        mnt = vfs_kern_mount(&nfs4_referral_fs_type, 0, page, &mountdata);
-                        if (!IS_ERR(mnt)) {
-                                break;
-                        }
-                        s++;
-                }
-                loc++;
+                mnt = try_location(&mountdata, page, page2, location);
+                if (!IS_ERR(mnt))
+                        break;
         }
 
 out:
diff --git a/fs/nfs/proc.c b/fs/nfs/proc.c
index 4dbb84df1b68..193465210d7c 100644
--- a/fs/nfs/proc.c
+++ b/fs/nfs/proc.c
@@ -65,14 +65,20 @@ nfs_proc_get_root(struct nfs_server *server, struct nfs_fh *fhandle,
 
         dprintk("%s: call getattr\n", __func__);
         nfs_fattr_init(fattr);
-        status = rpc_call_sync(server->nfs_client->cl_rpcclient, &msg, 0);
+        status = rpc_call_sync(server->client, &msg, 0);
+        /* Retry with default authentication if different */
+        if (status && server->nfs_client->cl_rpcclient != server->client)
+                status = rpc_call_sync(server->nfs_client->cl_rpcclient, &msg, 0);
         dprintk("%s: reply getattr: %d\n", __func__, status);
         if (status)
                 return status;
         dprintk("%s: call statfs\n", __func__);
         msg.rpc_proc = &nfs_procedures[NFSPROC_STATFS];
         msg.rpc_resp = &fsinfo;
-        status = rpc_call_sync(server->nfs_client->cl_rpcclient, &msg, 0);
+        status = rpc_call_sync(server->client, &msg, 0);
+        /* Retry with default authentication if different */
+        if (status && server->nfs_client->cl_rpcclient != server->client)
+                status = rpc_call_sync(server->nfs_client->cl_rpcclient, &msg, 0);
         dprintk("%s: reply statfs: %d\n", __func__, status);
         if (status)
                 return status;
diff --git a/fs/nfs/super.c b/fs/nfs/super.c
index ffb697416cb1..8b28b95c9e44 100644
--- a/fs/nfs/super.c
+++ b/fs/nfs/super.c
@@ -91,6 +91,7 @@ enum {
         /* Mount options that take string arguments */
         Opt_sec, Opt_proto, Opt_mountproto, Opt_mounthost,
         Opt_addr, Opt_mountaddr, Opt_clientaddr,
+        Opt_lookupcache,
 
         /* Special mount options */
         Opt_userspace, Opt_deprecated, Opt_sloppy,
@@ -154,6 +155,8 @@ static const match_table_t nfs_mount_option_tokens = {
         { Opt_mounthost, "mounthost=%s" },
         { Opt_mountaddr, "mountaddr=%s" },
 
+        { Opt_lookupcache, "lookupcache=%s" },
+
         { Opt_err, NULL }
 };
 
@@ -200,6 +203,22 @@ static const match_table_t nfs_secflavor_tokens = {
         { Opt_sec_err, NULL }
 };
 
+enum {
+        Opt_lookupcache_all, Opt_lookupcache_positive,
+        Opt_lookupcache_none,
+
+        Opt_lookupcache_err
+};
+
+static match_table_t nfs_lookupcache_tokens = {
+        { Opt_lookupcache_all, "all" },
+        { Opt_lookupcache_positive, "pos" },
+        { Opt_lookupcache_positive, "positive" },
+        { Opt_lookupcache_none, "none" },
+
+        { Opt_lookupcache_err, NULL }
+};
+
 
 static void nfs_umount_begin(struct super_block *);
 static int  nfs_statfs(struct dentry *, struct kstatfs *);
@@ -209,7 +228,6 @@ static int nfs_get_sb(struct file_system_type *, int, const char *, void *, stru
 static int nfs_xdev_get_sb(struct file_system_type *fs_type,
                 int flags, const char *dev_name, void *raw_data, struct vfsmount *mnt);
 static void nfs_kill_super(struct super_block *);
-static void nfs_put_super(struct super_block *);
 static int nfs_remount(struct super_block *sb, int *flags, char *raw_data);
 
 static struct file_system_type nfs_fs_type = {
@@ -232,7 +250,6 @@ static const struct super_operations nfs_sops = {
         .alloc_inode    = nfs_alloc_inode,
         .destroy_inode  = nfs_destroy_inode,
         .write_inode    = nfs_write_inode,
-        .put_super      = nfs_put_super,
         .statfs         = nfs_statfs,
         .clear_inode    = nfs_clear_inode,
         .umount_begin   = nfs_umount_begin,
@@ -337,26 +354,20 @@ void __exit unregister_nfs_fs(void)
         unregister_filesystem(&nfs_fs_type);
 }
 
-void nfs_sb_active(struct nfs_server *server)
+void nfs_sb_active(struct super_block *sb)
 {
-        atomic_inc(&server->active);
-}
+        struct nfs_server *server = NFS_SB(sb);
 
-void nfs_sb_deactive(struct nfs_server *server)
-{
-        if (atomic_dec_and_test(&server->active))
-                wake_up(&server->active_wq);
+        if (atomic_inc_return(&server->active) == 1)
+                atomic_inc(&sb->s_active);
 }
 
-static void nfs_put_super(struct super_block *sb)
+void nfs_sb_deactive(struct super_block *sb)
 {
         struct nfs_server *server = NFS_SB(sb);
-        /*
-         * Make sure there are no outstanding ops to this server.
-         * If so, wait for them to finish before allowing the
-         * unmount to continue.
-         */
-        wait_event(server->active_wq, atomic_read(&server->active) == 0);
+
+        if (atomic_dec_and_test(&server->active))
+                deactivate_super(sb);
 }
 
 /*
@@ -664,25 +675,6 @@ static void nfs_umount_begin(struct super_block *sb)
 }
 
 /*
- * Set the port number in an address.  Be agnostic about the address family.
- */
-static void nfs_set_port(struct sockaddr *sap, unsigned short port)
-{
-        switch (sap->sa_family) {
-        case AF_INET: {
-                struct sockaddr_in *ap = (struct sockaddr_in *)sap;
-                ap->sin_port = htons(port);
-                break;
-        }
-        case AF_INET6: {
-                struct sockaddr_in6 *ap = (struct sockaddr_in6 *)sap;
-                ap->sin6_port = htons(port);
-                break;
-        }
-        }
-}
-
-/*
  * Sanity-check a server address provided by the mount command.
  *
  * Address family must be initialized, and address must not be
@@ -724,20 +716,22 @@ static void nfs_parse_ipv4_address(char *string, size_t str_len,
         *addr_len = 0;
 }
 
-#define IPV6_SCOPE_DELIMITER    '%'
-
 #if defined(CONFIG_IPV6) || defined(CONFIG_IPV6_MODULE)
-static void nfs_parse_ipv6_scope_id(const char *string, const size_t str_len,
-                                    const char *delim,
-                                    struct sockaddr_in6 *sin6)
+static int nfs_parse_ipv6_scope_id(const char *string, const size_t str_len,
+                                   const char *delim,
+                                   struct sockaddr_in6 *sin6)
 {
         char *p;
         size_t len;
 
-        if (!(ipv6_addr_type(&sin6->sin6_addr) & IPV6_ADDR_LINKLOCAL))
-                return ;
+        if ((string + str_len) == delim)
+                return 1;
+
         if (*delim != IPV6_SCOPE_DELIMITER)
-                return;
+                return 0;
+
+        if (!(ipv6_addr_type(&sin6->sin6_addr) & IPV6_ADDR_LINKLOCAL))
+                return 0;
 
         len = (string + str_len) - delim - 1;
         p = kstrndup(delim + 1, len, GFP_KERNEL);
@@ -750,14 +744,20 @@ static void nfs_parse_ipv6_scope_id(const char *string, const size_t str_len,
                         scope_id = dev->ifindex;
                         dev_put(dev);
                 } else {
-                        /* scope_id is set to zero on error */
-                        strict_strtoul(p, 10, &scope_id);
+                        if (strict_strtoul(p, 10, &scope_id) == 0) {
+                                kfree(p);
+                                return 0;
+                        }
                 }
 
                 kfree(p);
+
                 sin6->sin6_scope_id = scope_id;
                 dfprintk(MOUNT, "NFS: IPv6 scope ID = %lu\n", scope_id);
+                return 1;
         }
+
+        return 0;
 }
 
 static void nfs_parse_ipv6_address(char *string, size_t str_len,
@@ -773,9 +773,11 @@ static void nfs_parse_ipv6_address(char *string, size_t str_len,
 
                 sin6->sin6_family = AF_INET6;
                 *addr_len = sizeof(*sin6);
-                if (in6_pton(string, str_len, addr, IPV6_SCOPE_DELIMITER, &delim)) {
-                        nfs_parse_ipv6_scope_id(string, str_len, delim, sin6);
-                        return;
+                if (in6_pton(string, str_len, addr,
+                                        IPV6_SCOPE_DELIMITER, &delim) != 0) {
+                        if (nfs_parse_ipv6_scope_id(string, str_len,
+                                                        delim, sin6) != 0)
+                                return;
                 }
         }
 
@@ -798,7 +800,7 @@ static void nfs_parse_ipv6_address(char *string, size_t str_len,
  * If there is a problem constructing the new sockaddr, set the address
  * family to AF_UNSPEC.
  */
-static void nfs_parse_ip_address(char *string, size_t str_len,
+void nfs_parse_ip_address(char *string, size_t str_len,
                                  struct sockaddr *sap, size_t *addr_len)
 {
         unsigned int i, colons;
@@ -1258,6 +1260,30 @@ static int nfs_parse_mount_options(char *raw,
                                              &mnt->mount_server.addrlen);
                         kfree(string);
                         break;
+                case Opt_lookupcache:
+                        string = match_strdup(args);
+                        if (string == NULL)
+                                goto out_nomem;
+                        token = match_token(string,
+                                        nfs_lookupcache_tokens, args);
+                        kfree(string);
+                        switch (token) {
+                                case Opt_lookupcache_all:
+                                        mnt->flags &= ~(NFS_MOUNT_LOOKUP_CACHE_NONEG|NFS_MOUNT_LOOKUP_CACHE_NONE);
+                                        break;
+                                case Opt_lookupcache_positive:
+                                        mnt->flags &= ~NFS_MOUNT_LOOKUP_CACHE_NONE;
+                                        mnt->flags |= NFS_MOUNT_LOOKUP_CACHE_NONEG;
+                                        break;
+                                case Opt_lookupcache_none:
+                                        mnt->flags |= NFS_MOUNT_LOOKUP_CACHE_NONEG|NFS_MOUNT_LOOKUP_CACHE_NONE;
+                                        break;
+                                default:
+                                        errors++;
+                                        dfprintk(MOUNT, "NFS:   invalid "
+                                                        "lookupcache argument\n");
+                        };
+                        break;
 
                 /*
                  * Special options
@@ -1558,7 +1584,7 @@ static int nfs_validate_mount_data(void *options,
                  * Translate to nfs_parsed_mount_data, which nfs_fill_super
                  * can deal with.
                  */
-                args->flags             = data->flags;
+                args->flags             = data->flags & NFS_MOUNT_FLAGMASK;
                 args->rsize             = data->rsize;
                 args->wsize             = data->wsize;
                 args->timeo             = data->timeo;
diff --git a/fs/nfs/unlink.c b/fs/nfs/unlink.c
index f089e5839d7d..ecc295347775 100644
--- a/fs/nfs/unlink.c
+++ b/fs/nfs/unlink.c
@@ -99,7 +99,7 @@ static void nfs_async_unlink_release(void *calldata)
 
         nfs_dec_sillycount(data->dir);
         nfs_free_unlinkdata(data);
-        nfs_sb_deactive(NFS_SB(sb));
+        nfs_sb_deactive(sb);
 }
 
 static const struct rpc_call_ops nfs_unlink_ops = {
@@ -118,6 +118,7 @@ static int nfs_do_call_unlink(struct dentry *parent, struct inode *dir, struct n
                 .rpc_message = &msg,
                 .callback_ops = &nfs_unlink_ops,
                 .callback_data = data,
+                .workqueue = nfsiod_workqueue,
                 .flags = RPC_TASK_ASYNC,
         };
         struct rpc_task *task;
@@ -149,7 +150,7 @@ static int nfs_do_call_unlink(struct dentry *parent, struct inode *dir, struct n
                 nfs_dec_sillycount(dir);
                 return 0;
         }
-        nfs_sb_active(NFS_SERVER(dir));
+        nfs_sb_active(dir->i_sb);
         data->args.fh = NFS_FH(dir);
         nfs_fattr_init(&data->res.dir_attr);
 
diff --git a/fs/nfs/write.c b/fs/nfs/write.c
index 3229e217c773..9f9845859fc1 100644
--- a/fs/nfs/write.c
+++ b/fs/nfs/write.c
@@ -1427,8 +1427,9 @@ static int nfs_write_mapping(struct address_space *mapping, int how)
                 .bdi = mapping->backing_dev_info,
                 .sync_mode = WB_SYNC_NONE,
                 .nr_to_write = LONG_MAX,
+                .range_start = 0,
+                .range_end = LLONG_MAX,
                 .for_writepages = 1,
-                .range_cyclic = 1,
         };
         int ret;