73 files changed, 1010 insertions, 445 deletions

diff --git a/fs/Kconfig b/fs/Kconfig
index ee11f8d94085..613df554728d 100644
--- a/fs/Kconfig
+++ b/fs/Kconfig
@@ -1675,6 +1675,7 @@ config NFSD_V3_ACL
 config NFSD_V4
         bool "Provide NFSv4 server support (EXPERIMENTAL)"
         depends on NFSD_V3 && EXPERIMENTAL
+        select RPCSEC_GSS_KRB5
         help
           If you would like to include the NFSv4 server as well as the NFSv2
           and NFSv3 servers, say Y here.  This feature is experimental, and
diff --git a/fs/anon_inodes.c b/fs/anon_inodes.c
index a260198306c2..b4a75880f6fd 100644
--- a/fs/anon_inodes.c
+++ b/fs/anon_inodes.c
@@ -139,6 +139,7 @@ err_put_filp:
         put_filp(file);
         return error;
 }
+EXPORT_SYMBOL_GPL(anon_inode_getfd);
 
 /*
  * A single inode exists for all anon_inode files. Contrary to pipes,
diff --git a/fs/attr.c b/fs/attr.c
index a0a0c7b07ba3..f8dfc2269d85 100644
--- a/fs/attr.c
+++ b/fs/attr.c
@@ -42,7 +42,7 @@ int inode_change_ok(struct inode *inode, struct iattr *attr)
 
         /* Make sure a caller can chmod. */
         if (ia_valid & ATTR_MODE) {
-                if ((current->fsuid != inode->i_uid) && !capable(CAP_FOWNER))
+                if (!is_owner_or_cap(inode))
                         goto error;
                 /* Also check the setgid bit! */
                 if (!in_group_p((ia_valid & ATTR_GID) ? attr->ia_gid :
@@ -52,7 +52,7 @@ int inode_change_ok(struct inode *inode, struct iattr *attr)
 
         /* Check for setting the inode time. */
         if (ia_valid & (ATTR_MTIME_SET | ATTR_ATIME_SET)) {
-                if (current->fsuid != inode->i_uid && !capable(CAP_FOWNER))
+                if (!is_owner_or_cap(inode))
                         goto error;
         }
 fine:
diff --git a/fs/buffer.c b/fs/buffer.c
index 424165b569f8..0f9006714230 100644
--- a/fs/buffer.c
+++ b/fs/buffer.c
@@ -356,7 +356,7 @@ static void free_more_memory(void)
         for_each_online_pgdat(pgdat) {
                 zones = pgdat->node_zonelists[gfp_zone(GFP_NOFS)].zones;
                 if (*zones)
-                        try_to_free_pages(zones, GFP_NOFS);
+                        try_to_free_pages(zones, 0, GFP_NOFS);
         }
 }
 
@@ -676,6 +676,39 @@ void mark_buffer_dirty_inode(struct buffer_head *bh, struct inode *inode)
 EXPORT_SYMBOL(mark_buffer_dirty_inode);
 
 /*
+ * Mark the page dirty, and set it dirty in the radix tree, and mark the inode
+ * dirty.
+ *
+ * If warn is true, then emit a warning if the page is not uptodate and has
+ * not been truncated.
+ */
+static int __set_page_dirty(struct page *page,
+                struct address_space *mapping, int warn)
+{
+        if (unlikely(!mapping))
+                return !TestSetPageDirty(page);
+
+        if (TestSetPageDirty(page))
+                return 0;
+
+        write_lock_irq(&mapping->tree_lock);
+        if (page->mapping) {    /* Race with truncate? */
+                WARN_ON_ONCE(warn && !PageUptodate(page));
+
+                if (mapping_cap_account_dirty(mapping)) {
+                        __inc_zone_page_state(page, NR_FILE_DIRTY);
+                        task_io_account_write(PAGE_CACHE_SIZE);
+                }
+                radix_tree_tag_set(&mapping->page_tree,
+                                page_index(page), PAGECACHE_TAG_DIRTY);
+        }
+        write_unlock_irq(&mapping->tree_lock);
+        __mark_inode_dirty(mapping->host, I_DIRTY_PAGES);
+
+        return 1;
+}
+
+/*
  * Add a page to the dirty page list.
  *
  * It is a sad fact of life that this function is called from several places
@@ -702,7 +735,7 @@ EXPORT_SYMBOL(mark_buffer_dirty_inode);
  */
 int __set_page_dirty_buffers(struct page *page)
 {
-        struct address_space * const mapping = page_mapping(page);
+        struct address_space *mapping = page_mapping(page);
 
         if (unlikely(!mapping))
                 return !TestSetPageDirty(page);
@@ -719,21 +752,7 @@ int __set_page_dirty_buffers(struct page *page)
         }
         spin_unlock(&mapping->private_lock);
 
-        if (TestSetPageDirty(page))
-                return 0;
-
-        write_lock_irq(&mapping->tree_lock);
-        if (page->mapping) {    /* Race with truncate? */
-                if (mapping_cap_account_dirty(mapping)) {
-                        __inc_zone_page_state(page, NR_FILE_DIRTY);
-                        task_io_account_write(PAGE_CACHE_SIZE);
-                }
-                radix_tree_tag_set(&mapping->page_tree,
-                                page_index(page), PAGECACHE_TAG_DIRTY);
-        }
-        write_unlock_irq(&mapping->tree_lock);
-        __mark_inode_dirty(mapping->host, I_DIRTY_PAGES);
-        return 1;
+        return __set_page_dirty(page, mapping, 1);
 }
 EXPORT_SYMBOL(__set_page_dirty_buffers);
 
@@ -982,7 +1001,7 @@ grow_dev_page(struct block_device *bdev, sector_t block,
         struct buffer_head *bh;
 
         page = find_or_create_page(inode->i_mapping, index,
-                mapping_gfp_mask(inode->i_mapping) & ~__GFP_FS);
+                (mapping_gfp_mask(inode->i_mapping) & ~__GFP_FS)|__GFP_MOVABLE);
         if (!page)
                 return NULL;
 
@@ -1132,8 +1151,9 @@ __getblk_slow(struct block_device *bdev, sector_t block, int size)
  */
 void fastcall mark_buffer_dirty(struct buffer_head *bh)
 {
+        WARN_ON_ONCE(!buffer_uptodate(bh));
         if (!buffer_dirty(bh) && !test_set_buffer_dirty(bh))
-                __set_page_dirty_nobuffers(bh->b_page);
+                __set_page_dirty(bh->b_page, page_mapping(bh->b_page), 0);
 }
 
 /*
diff --git a/fs/cifs/cifsfs.c b/fs/cifs/cifsfs.c
index 8b0cbf4a4ad0..bd0f2f2353ce 100644
--- a/fs/cifs/cifsfs.c
+++ b/fs/cifs/cifsfs.c
@@ -849,6 +849,7 @@ static int cifs_oplock_thread(void * dummyarg)
         __u16  netfid;
         int rc;
 
+        set_freezable();
         do {
                 if (try_to_freeze()) 
                         continue;
diff --git a/fs/cifs/connect.c b/fs/cifs/connect.c
index f4e92661b223..0a1b8bd1dfcb 100644
--- a/fs/cifs/connect.c
+++ b/fs/cifs/connect.c
@@ -363,6 +363,7 @@ cifs_demultiplex_thread(struct TCP_Server_Info *server)
                         GFP_KERNEL);
         }
 
+        set_freezable();
         while (!kthread_should_stop()) {
                 if (try_to_freeze())
                         continue;
diff --git a/fs/cifs/export.c b/fs/cifs/export.c
index 1d716392c3aa..96df1d51fdc3 100644
--- a/fs/cifs/export.c
+++ b/fs/cifs/export.c
@@ -29,6 +29,7 @@
   */
 
 #include <linux/fs.h>
+#include <linux/exportfs.h>
  
 #ifdef CONFIG_CIFS_EXPERIMENTAL
  
diff --git a/fs/dcache.c b/fs/dcache.c
index 0e73aa0a0e8b..cb9d05056b54 100644
--- a/fs/dcache.c
+++ b/fs/dcache.c
@@ -883,6 +883,11 @@ static int shrink_dcache_memory(int nr, gfp_t gfp_mask)
         return (dentry_stat.nr_unused / 100) * sysctl_vfs_cache_pressure;
 }
 
+static struct shrinker dcache_shrinker = {
+        .shrink = shrink_dcache_memory,
+        .seeks = DEFAULT_SEEKS,
+};
+
 /**
  * d_alloc      -       allocate a dcache entry
  * @parent: parent of entry to allocate
@@ -2115,7 +2120,7 @@ static void __init dcache_init(unsigned long mempages)
         dentry_cache = KMEM_CACHE(dentry,
                 SLAB_RECLAIM_ACCOUNT|SLAB_PANIC|SLAB_MEM_SPREAD);
         
-        set_shrinker(DEFAULT_SEEKS, shrink_dcache_memory);
+        register_shrinker(&dcache_shrinker);
 
         /* Hash may have been set up in dcache_init_early */
         if (!hashdist)
diff --git a/fs/dquot.c b/fs/dquot.c
index 8819d281500c..7e273151f589 100644
--- a/fs/dquot.c
+++ b/fs/dquot.c
@@ -538,6 +538,11 @@ static int shrink_dqcache_memory(int nr, gfp_t gfp_mask)
         return (dqstats.free_dquots / 100) * sysctl_vfs_cache_pressure;
 }
 
+static struct shrinker dqcache_shrinker = {
+        .shrink = shrink_dqcache_memory,
+        .seeks = DEFAULT_SEEKS,
+};
+
 /*
  * Put reference to dquot
  * NOTE: If you change this function please check whether dqput_blocks() works right...
@@ -1870,7 +1875,7 @@ static int __init dquot_init(void)
         printk("Dquot-cache hash table entries: %ld (order %ld, %ld bytes)\n",
                         nr_hash, order, (PAGE_SIZE << order));
 
-        set_shrinker(DEFAULT_SEEKS, shrink_dqcache_memory);
+        register_shrinker(&dqcache_shrinker);
 
         return 0;
 }
diff --git a/fs/ecryptfs/inode.c b/fs/ecryptfs/inode.c
index 83e94fedd4e9..e77a2ec71aa5 100644
--- a/fs/ecryptfs/inode.c
+++ b/fs/ecryptfs/inode.c
@@ -282,7 +282,7 @@ static struct dentry *ecryptfs_lookup(struct inode *dir, struct dentry *dentry,
         struct dentry *lower_dentry;
         struct vfsmount *lower_mnt;
         char *encoded_name;
-        unsigned int encoded_namelen;
+        int encoded_namelen;
         struct ecryptfs_crypt_stat *crypt_stat = NULL;
         struct ecryptfs_mount_crypt_stat *mount_crypt_stat;
         char *page_virt = NULL;
@@ -473,7 +473,7 @@ static int ecryptfs_symlink(struct inode *dir, struct dentry *dentry,
         struct dentry *lower_dir_dentry;
         umode_t mode;
         char *encoded_symname;
-        unsigned int encoded_symlen;
+        int encoded_symlen;
         struct ecryptfs_crypt_stat *crypt_stat = NULL;
 
         lower_dentry = ecryptfs_dentry_to_lower(dentry);
diff --git a/fs/efs/namei.c b/fs/efs/namei.c
index ed4a207fe22a..5276b19423c1 100644
--- a/fs/efs/namei.c
+++ b/fs/efs/namei.c
@@ -75,6 +75,38 @@ struct dentry *efs_lookup(struct inode *dir, struct dentry *dentry, struct namei
         return NULL;
 }
 
+struct dentry *efs_get_dentry(struct super_block *sb, void *vobjp)
+{
+        __u32 *objp = vobjp;
+        unsigned long ino = objp[0];
+        __u32 generation = objp[1];
+        struct inode *inode;
+        struct dentry *result;
+
+        if (ino == 0)
+                return ERR_PTR(-ESTALE);
+        inode = iget(sb, ino);
+        if (inode == NULL)
+                return ERR_PTR(-ENOMEM);
+
+        if (is_bad_inode(inode) ||
+            (generation && inode->i_generation != generation)) {
+                result = ERR_PTR(-ESTALE);
+                goto out_iput;
+        }
+
+        result = d_alloc_anon(inode);
+        if (!result) {
+                result = ERR_PTR(-ENOMEM);
+                goto out_iput;
+        }
+        return result;
+
+ out_iput:
+        iput(inode);
+        return result;
+}
+
 struct dentry *efs_get_parent(struct dentry *child)
 {
         struct dentry *parent;
diff --git a/fs/efs/super.c b/fs/efs/super.c
index e0a6839e68ae..d360c81f3a72 100644
--- a/fs/efs/super.c
+++ b/fs/efs/super.c
@@ -11,6 +11,7 @@
 #include <linux/efs_fs.h>
 #include <linux/efs_vh.h>
 #include <linux/efs_fs_sb.h>
+#include <linux/exportfs.h>
 #include <linux/slab.h>
 #include <linux/buffer_head.h>
 #include <linux/vfs.h>
@@ -113,6 +114,7 @@ static const struct super_operations efs_superblock_operations = {
 };
 
 static struct export_operations efs_export_ops = {
+        .get_dentry     = efs_get_dentry,
         .get_parent     = efs_get_parent,
 };
 
diff --git a/fs/exportfs/expfs.c b/fs/exportfs/expfs.c
index e98f6cd7200c..8adb32a9387a 100644
--- a/fs/exportfs/expfs.c
+++ b/fs/exportfs/expfs.c
@@ -1,15 +1,45 @@
 
+#include <linux/exportfs.h>
 #include <linux/fs.h>
 #include <linux/file.h>
 #include <linux/module.h>
+#include <linux/mount.h>
 #include <linux/namei.h>
 
-struct export_operations export_op_default;
+#define dprintk(fmt, args...) do{}while(0)
 
-#define CALL(ops,fun) ((ops->fun)?(ops->fun):export_op_default.fun)
 
-#define dprintk(fmt, args...) do{}while(0)
+static int get_name(struct dentry *dentry, char *name,
+                struct dentry *child);
+
+
+static struct dentry *exportfs_get_dentry(struct super_block *sb, void *obj)
+{
+        struct dentry *result = ERR_PTR(-ESTALE);
+
+        if (sb->s_export_op->get_dentry) {
+                result = sb->s_export_op->get_dentry(sb, obj);
+                if (!result)
+                        result = ERR_PTR(-ESTALE);
+        }
+
+        return result;
+}
+
+static int exportfs_get_name(struct dentry *dir, char *name,
+                struct dentry *child)
+{
+        struct export_operations *nop = dir->d_sb->s_export_op;
 
+        if (nop->get_name)
+                return nop->get_name(dir, name, child);
+        else
+                return get_name(dir, name, child);
+}
+
+/*
+ * Check if the dentry or any of it's aliases is acceptable.
+ */
 static struct dentry *
 find_acceptable_alias(struct dentry *result,
                 int (*acceptable)(void *context, struct dentry *dentry),
@@ -17,6 +47,9 @@ find_acceptable_alias(struct dentry *result,
 {
         struct dentry *dentry, *toput = NULL;
 
+        if (acceptable(context, result))
+                return result;
+
         spin_lock(&dcache_lock);
         list_for_each_entry(dentry, &result->d_inode->i_dentry, d_alias) {
                 dget_locked(dentry);
@@ -37,130 +70,50 @@ find_acceptable_alias(struct dentry *result,
         return NULL;
 }
 
-/**
- * find_exported_dentry - helper routine to implement export_operations->decode_fh
- * @sb:         The &super_block identifying the filesystem
- * @obj:        An opaque identifier of the object to be found - passed to
- *              get_inode
- * @parent:     An optional opqaue identifier of the parent of the object.
- * @acceptable: A function used to test possible &dentries to see if they are
- *              acceptable
- * @context:    A parameter to @acceptable so that it knows on what basis to
- *              judge.
- *
- * find_exported_dentry is the central helper routine to enable file systems
- * to provide the decode_fh() export_operation.  It's main task is to take
- * an &inode, find or create an appropriate &dentry structure, and possibly
- * splice this into the dcache in the correct place.
- *
- * The decode_fh() operation provided by the filesystem should call
- * find_exported_dentry() with the same parameters that it received except
- * that instead of the file handle fragment, pointers to opaque identifiers
- * for the object and optionally its parent are passed.  The default decode_fh
- * routine passes one pointer to the start of the filehandle fragment, and
- * one 8 bytes into the fragment.  It is expected that most filesystems will
- * take this approach, though the offset to the parent identifier may well be
- * different.
- *
- * find_exported_dentry() will call get_dentry to get an dentry pointer from
- * the file system.  If any &dentry in the d_alias list is acceptable, it will
- * be returned.  Otherwise find_exported_dentry() will attempt to splice a new
- * &dentry into the dcache using get_name() and get_parent() to find the
- * appropriate place.
+/*
+ * Find root of a disconnected subtree and return a reference to it.
  */
-
-struct dentry *
-find_exported_dentry(struct super_block *sb, void *obj, void *parent,
-                     int (*acceptable)(void *context, struct dentry *de),
-                     void *context)
+static struct dentry *
+find_disconnected_root(struct dentry *dentry)
 {
-        struct dentry *result = NULL;
-        struct dentry *target_dir;
-        int err;
-        struct export_operations *nops = sb->s_export_op;
-        struct dentry *alias;
-        int noprogress;
-        char nbuf[NAME_MAX+1];
-
-        /*
-         * Attempt to find the inode.
-         */
-        result = CALL(sb->s_export_op,get_dentry)(sb,obj);
-        err = -ESTALE;
-        if (result == NULL)
-                goto err_out;
-        if (IS_ERR(result)) {
-                err = PTR_ERR(result);
-                goto err_out;
+        dget(dentry);
+        spin_lock(&dentry->d_lock);
+        while (!IS_ROOT(dentry) &&
+               (dentry->d_parent->d_flags & DCACHE_DISCONNECTED)) {
+                struct dentry *parent = dentry->d_parent;
+                dget(parent);
+                spin_unlock(&dentry->d_lock);
+                dput(dentry);
+                dentry = parent;
+                spin_lock(&dentry->d_lock);
         }
-        if (S_ISDIR(result->d_inode->i_mode) &&
-            (result->d_flags & DCACHE_DISCONNECTED)) {
-                /* it is an unconnected directory, we must connect it */
-                ;
-        } else {
-                if (acceptable(context, result))
-                        return result;
-                if (S_ISDIR(result->d_inode->i_mode)) {
-                        err = -EACCES;
-                        goto err_result;
-                }
+        spin_unlock(&dentry->d_lock);
+        return dentry;
+}
 
-                alias = find_acceptable_alias(result, acceptable, context);
-                if (alias)
-                        return alias;
-        }                       
-
-        /* It's a directory, or we are required to confirm the file's
-         * location in the tree based on the parent information
-         */
-        dprintk("find_exported_dentry: need to look harder for %s/%d\n",sb->s_id,*(int*)obj);
-        if (S_ISDIR(result->d_inode->i_mode))
-                target_dir = dget(result);
-        else {
-                if (parent == NULL)
-                        goto err_result;
 
-                target_dir = CALL(sb->s_export_op,get_dentry)(sb,parent);
-                if (IS_ERR(target_dir))
-                        err = PTR_ERR(target_dir);
-                if (target_dir == NULL || IS_ERR(target_dir))
-                        goto err_result;
-        }
-        /*
-         * Now we need to make sure that target_dir is properly connected.
-         * It may already be, as the flag isn't always updated when connection
-         * happens.
-         * So, we walk up parent links until we find a connected directory,
-         * or we run out of directories.  Then we find the parent, find
-         * the name of the child in that parent, and do a lookup.
-         * This should connect the child into the parent
-         * We then repeat.
-         */
+/*
+ * Make sure target_dir is fully connected to the dentry tree.
+ *
+ * It may already be, as the flag isn't always updated when connection happens.
+ */
+static int
+reconnect_path(struct super_block *sb, struct dentry *target_dir)
+{
+        char nbuf[NAME_MAX+1];
+        int noprogress = 0;
+        int err = -ESTALE;
 
-        /* it is possible that a confused file system might not let us complete 
+        /*
+         * It is possible that a confused file system might not let us complete
          * the path to the root.  For example, if get_parent returns a directory
          * in which we cannot find a name for the child.  While this implies a
          * very sick filesystem we don't want it to cause knfsd to spin.  Hence
          * the noprogress counter.  If we go through the loop 10 times (2 is
          * probably enough) without getting anywhere, we just give up
          */
-        noprogress= 0;
         while (target_dir->d_flags & DCACHE_DISCONNECTED && noprogress++ < 10) {
-                struct dentry *pd = target_dir;
-
-                dget(pd);
-                spin_lock(&pd->d_lock);
-                while (!IS_ROOT(pd) &&
-                                (pd->d_parent->d_flags&DCACHE_DISCONNECTED)) {
-                        struct dentry *parent = pd->d_parent;
-
-                        dget(parent);
-                        spin_unlock(&pd->d_lock);
-                        dput(pd);
-                        pd = parent;
-                        spin_lock(&pd->d_lock);
-                }
-                spin_unlock(&pd->d_lock);
+                struct dentry *pd = find_disconnected_root(target_dir);
 
                 if (!IS_ROOT(pd)) {
                         /* must have found a connected parent - great */
@@ -175,29 +128,40 @@ find_exported_dentry(struct super_block *sb, void *obj, void *parent,
                         spin_unlock(&pd->d_lock);
                         noprogress = 0;
                 } else {
-                        /* we have hit the top of a disconnected path.  Try
-                         * to find parent and connect
-                         * note: racing with some other process renaming a
-                         * directory isn't much of a problem here.  If someone
-                         * renames the directory, it will end up properly
-                         * connected, which is what we want
+                        /*
+                         * We have hit the top of a disconnected path, try to
+                         * find parent and connect.
+                         *
+                         * Racing with some other process renaming a directory
+                         * isn't much of a problem here.  If someone renames
+                         * the directory, it will end up properly connected,
+                         * which is what we want
+                         *
+                         * Getting the parent can't be supported generically,
+                         * the locking is too icky.
+                         *
+                         * Instead we just return EACCES.  If server reboots
+                         * or inodes get flushed, you lose
                          */
-                        struct dentry *ppd;
+                        struct dentry *ppd = ERR_PTR(-EACCES);
                         struct dentry *npd;
 
                         mutex_lock(&pd->d_inode->i_mutex);
-                        ppd = CALL(nops,get_parent)(pd);
+                        if (sb->s_export_op->get_parent)
+                                ppd = sb->s_export_op->get_parent(pd);
                         mutex_unlock(&pd->d_inode->i_mutex);
 
                         if (IS_ERR(ppd)) {
                                 err = PTR_ERR(ppd);
-                                dprintk("find_exported_dentry: get_parent of %ld failed, err %d\n",
-                                        pd->d_inode->i_ino, err);
+                                dprintk("%s: get_parent of %ld failed, err %d\n",
+                                        __FUNCTION__, pd->d_inode->i_ino, err);
                                 dput(pd);
                                 break;
                         }
-                        dprintk("find_exported_dentry: find name of %lu in %lu\n", pd->d_inode->i_ino, ppd->d_inode->i_ino);
-                        err = CALL(nops,get_name)(ppd, nbuf, pd);
+
+                        dprintk("%s: find name of %lu in %lu\n", __FUNCTION__,
+                                pd->d_inode->i_ino, ppd->d_inode->i_ino);
+                        err = exportfs_get_name(ppd, nbuf, pd);
                         if (err) {
                                 dput(ppd);
                                 dput(pd);
@@ -208,13 +172,14 @@ find_exported_dentry(struct super_block *sb, void *obj, void *parent,
                                         continue;
                                 break;
                         }
-                        dprintk("find_exported_dentry: found name: %s\n", nbuf);
+                        dprintk("%s: found name: %s\n", __FUNCTION__, nbuf);
                         mutex_lock(&ppd->d_inode->i_mutex);
                         npd = lookup_one_len(nbuf, ppd, strlen(nbuf));
                         mutex_unlock(&ppd->d_inode->i_mutex);
                         if (IS_ERR(npd)) {
                                 err = PTR_ERR(npd);
-                                dprintk("find_exported_dentry: lookup failed: %d\n", err);
+                                dprintk("%s: lookup failed: %d\n",
+                                        __FUNCTION__, err);
                                 dput(ppd);
                                 dput(pd);
                                 break;
@@ -227,7 +192,7 @@ find_exported_dentry(struct super_block *sb, void *obj, void *parent,
                         if (npd == pd)
                                 noprogress = 0;
                         else
-                                printk("find_exported_dentry: npd != pd\n");
+                                printk("%s: npd != pd\n", __FUNCTION__);
                         dput(npd);
                         dput(ppd);
                         if (IS_ROOT(pd)) {
@@ -243,15 +208,101 @@ find_exported_dentry(struct super_block *sb, void *obj, void *parent,
                 /* something went wrong - oh-well */
                 if (!err)
                         err = -ESTALE;
-                goto err_target;
+                return err;
         }
-        /* if we weren't after a directory, have one more step to go */
-        if (result != target_dir) {
-                struct dentry *nresult;
-                err = CALL(nops,get_name)(target_dir, nbuf, result);
+
+        return 0;
+}
+
+/**
+ * find_exported_dentry - helper routine to implement export_operations->decode_fh
+ * @sb:         The &super_block identifying the filesystem
+ * @obj:        An opaque identifier of the object to be found - passed to
+ *              get_inode
+ * @parent:     An optional opqaue identifier of the parent of the object.
+ * @acceptable: A function used to test possible &dentries to see if they are
+ *              acceptable
+ * @context:    A parameter to @acceptable so that it knows on what basis to
+ *              judge.
+ *
+ * find_exported_dentry is the central helper routine to enable file systems
+ * to provide the decode_fh() export_operation.  It's main task is to take
+ * an &inode, find or create an appropriate &dentry structure, and possibly
+ * splice this into the dcache in the correct place.
+ *
+ * The decode_fh() operation provided by the filesystem should call
+ * find_exported_dentry() with the same parameters that it received except
+ * that instead of the file handle fragment, pointers to opaque identifiers
+ * for the object and optionally its parent are passed.  The default decode_fh
+ * routine passes one pointer to the start of the filehandle fragment, and
+ * one 8 bytes into the fragment.  It is expected that most filesystems will
+ * take this approach, though the offset to the parent identifier may well be
+ * different.
+ *
+ * find_exported_dentry() will call get_dentry to get an dentry pointer from
+ * the file system.  If any &dentry in the d_alias list is acceptable, it will
+ * be returned.  Otherwise find_exported_dentry() will attempt to splice a new
+ * &dentry into the dcache using get_name() and get_parent() to find the
+ * appropriate place.
+ */
+
+struct dentry *
+find_exported_dentry(struct super_block *sb, void *obj, void *parent,
+                     int (*acceptable)(void *context, struct dentry *de),
+                     void *context)
+{
+        struct dentry *result, *alias;
+        int err = -ESTALE;
+
+        /*
+         * Attempt to find the inode.
+         */
+        result = exportfs_get_dentry(sb, obj);
+        if (IS_ERR(result))
+                return result;
+
+        if (S_ISDIR(result->d_inode->i_mode)) {
+                if (!(result->d_flags & DCACHE_DISCONNECTED)) {
+                        if (acceptable(context, result))
+                                return result;
+                        err = -EACCES;
+                        goto err_result;
+                }
+
+                err = reconnect_path(sb, result);
+                if (err)
+                        goto err_result;
+        } else {
+                struct dentry *target_dir, *nresult;
+                char nbuf[NAME_MAX+1];
+
+                alias = find_acceptable_alias(result, acceptable, context);
+                if (alias)
+                        return alias;
+
+                if (parent == NULL)
+                        goto err_result;
+
+                target_dir = exportfs_get_dentry(sb,parent);
+                if (IS_ERR(target_dir)) {
+                        err = PTR_ERR(target_dir);
+                        goto err_result;
+                }
+
+                err = reconnect_path(sb, target_dir);
+                if (err) {
+                        dput(target_dir);
+                        goto err_result;
+                }
+
+                /*
+                 * As we weren't after a directory, have one more step to go.
+                 */
+                err = exportfs_get_name(target_dir, nbuf, result);
                 if (!err) {
                         mutex_lock(&target_dir->d_inode->i_mutex);
-                        nresult = lookup_one_len(nbuf, target_dir, strlen(nbuf));
+                        nresult = lookup_one_len(nbuf, target_dir,
+                                                 strlen(nbuf));
                         mutex_unlock(&target_dir->d_inode->i_mutex);
                         if (!IS_ERR(nresult)) {
                                 if (nresult->d_inode) {
@@ -261,11 +312,8 @@ find_exported_dentry(struct super_block *sb, void *obj, void *parent,
                                         dput(nresult);
                         }
                 }
+                dput(target_dir);
         }
-        dput(target_dir);
-        /* now result is properly connected, it is our best bet */
-        if (acceptable(context, result))
-                return result;
 
         alias = find_acceptable_alias(result, acceptable, context);
         if (alias)
@@ -275,32 +323,16 @@ find_exported_dentry(struct super_block *sb, void *obj, void *parent,
         dput(result);
         /* It might be justifiable to return ESTALE here,
          * but the filehandle at-least looks reasonable good
-         * and it just be a permission problem, so returning
+         * and it may just be a permission problem, so returning
          * -EACCESS is safer
          */
         return ERR_PTR(-EACCES);
 
- err_target:
-        dput(target_dir);
  err_result:
         dput(result);
- err_out:
         return ERR_PTR(err);
 }
 
-
-
-static struct dentry *get_parent(struct dentry *child)
-{
-        /* get_parent cannot be supported generically, the locking
-         * is too icky.
-         * instead, we just return EACCES.  If server reboots or inodes
-         * get flushed, you lose
-         */
-        return ERR_PTR(-EACCES);
-}
-
-
 struct getdents_callback {
         char *name;             /* name that was found. It already points to a
                                    buffer NAME_MAX+1 is size */
@@ -390,61 +422,6 @@ out:
         return error;
 }
 
-
-static struct dentry *export_iget(struct super_block *sb, unsigned long ino, __u32 generation)
-{
-
-        /* iget isn't really right if the inode is currently unallocated!!
-         * This should really all be done inside each filesystem
-         *
-         * ext2fs' read_inode has been strengthed to return a bad_inode if
-         * the inode had been deleted.
-         *
-         * Currently we don't know the generation for parent directory, so
-         * a generation of 0 means "accept any"
-         */
-        struct inode *inode;
-        struct dentry *result;
-        if (ino == 0)
-                return ERR_PTR(-ESTALE);
-        inode = iget(sb, ino);
-        if (inode == NULL)
-                return ERR_PTR(-ENOMEM);
-        if (is_bad_inode(inode)
-            || (generation && inode->i_generation != generation)
-                ) {
-                /* we didn't find the right inode.. */
-                dprintk("fh_verify: Inode %lu, Bad count: %d %d or version  %u %u\n",
-                        inode->i_ino,
-                        inode->i_nlink, atomic_read(&inode->i_count),
-                        inode->i_generation,
-                        generation);
-
-                iput(inode);
-                return ERR_PTR(-ESTALE);
-        }
-        /* now to find a dentry.
-         * If possible, get a well-connected one
-         */
-        result = d_alloc_anon(inode);
-        if (!result) {
-                iput(inode);
-                return ERR_PTR(-ENOMEM);
-        }
-        return result;
-}
-
-
-static struct dentry *get_object(struct super_block *sb, void *vobjp)
-{
-        __u32 *objp = vobjp;
-        unsigned long ino = objp[0];
-        __u32 generation = objp[1];
-
-        return export_iget(sb, ino, generation);
-}
-
-
 /**
  * export_encode_fh - default export_operations->encode_fh function
  * @dentry:  the dentry to encode
@@ -517,16 +494,40 @@ static struct dentry *export_decode_fh(struct super_block *sb, __u32 *fh, int fh
                                    acceptable, context);
 }
 
-struct export_operations export_op_default = {
-        .decode_fh      = export_decode_fh,
-        .encode_fh      = export_encode_fh,
+int exportfs_encode_fh(struct dentry *dentry, __u32 *fh, int *max_len,
+                int connectable)
+{
+        struct export_operations *nop = dentry->d_sb->s_export_op;
+        int error;
+
+        if (nop->encode_fh)
+                error = nop->encode_fh(dentry, fh, max_len, connectable);
+        else
+                error = export_encode_fh(dentry, fh, max_len, connectable);
 
-        .get_name       = get_name,
-        .get_parent     = get_parent,
-        .get_dentry     = get_object,
-};
+        return error;
+}
+EXPORT_SYMBOL_GPL(exportfs_encode_fh);
+
+struct dentry *exportfs_decode_fh(struct vfsmount *mnt, __u32 *fh, int fh_len,
+                int fileid_type, int (*acceptable)(void *, struct dentry *),
+                void *context)
+{
+        struct export_operations *nop = mnt->mnt_sb->s_export_op;
+        struct dentry *result;
+
+        if (nop->decode_fh) {
+                result = nop->decode_fh(mnt->mnt_sb, fh, fh_len, fileid_type,
+                        acceptable, context);
+        } else {
+                result = export_decode_fh(mnt->mnt_sb, fh, fh_len, fileid_type,
+                        acceptable, context);
+        }
+
+        return result;
+}
+EXPORT_SYMBOL_GPL(exportfs_decode_fh);
 
-EXPORT_SYMBOL(export_op_default);
 EXPORT_SYMBOL(find_exported_dentry);
 
 MODULE_LICENSE("GPL");
diff --git a/fs/ext2/acl.c b/fs/ext2/acl.c
index 7c420b800c34..e58669e1b87c 100644
--- a/fs/ext2/acl.c
+++ b/fs/ext2/acl.c
@@ -464,7 +464,7 @@ ext2_xattr_set_acl(struct inode *inode, int type, const void *value,
 
         if (!test_opt(inode->i_sb, POSIX_ACL))
                 return -EOPNOTSUPP;
-        if ((current->fsuid != inode->i_uid) && !capable(CAP_FOWNER))
+        if (!is_owner_or_cap(inode))
                 return -EPERM;
 
         if (value) {
diff --git a/fs/ext2/ioctl.c b/fs/ext2/ioctl.c
index e85c48218239..3bcd25422ee4 100644
--- a/fs/ext2/ioctl.c
+++ b/fs/ext2/ioctl.c
@@ -36,7 +36,7 @@ int ext2_ioctl (struct inode * inode, struct file * filp, unsigned int cmd,
                 if (IS_RDONLY(inode))
                         return -EROFS;
 
-                if ((current->fsuid != inode->i_uid) && !capable(CAP_FOWNER))
+                if (!is_owner_or_cap(inode))
                         return -EACCES;
 
                 if (get_user(flags, (int __user *) arg))
@@ -74,7 +74,7 @@ int ext2_ioctl (struct inode * inode, struct file * filp, unsigned int cmd,
         case EXT2_IOC_GETVERSION:
                 return put_user(inode->i_generation, (int __user *) arg);
         case EXT2_IOC_SETVERSION:
-                if ((current->fsuid != inode->i_uid) && !capable(CAP_FOWNER))
+                if (!is_owner_or_cap(inode))
                         return -EPERM;
                 if (IS_RDONLY(inode))
                         return -EROFS;
diff --git a/fs/ext2/super.c b/fs/ext2/super.c
index b2efd9083b9b..3eefa97fe204 100644
--- a/fs/ext2/super.c
+++ b/fs/ext2/super.c
@@ -25,6 +25,7 @@
 #include <linux/parser.h>
 #include <linux/random.h>
 #include <linux/buffer_head.h>
+#include <linux/exportfs.h>
 #include <linux/smp_lock.h>
 #include <linux/vfs.h>
 #include <linux/seq_file.h>
diff --git a/fs/ext3/acl.c b/fs/ext3/acl.c
index 1e5038d9a01b..d34e9967430a 100644
--- a/fs/ext3/acl.c
+++ b/fs/ext3/acl.c
@@ -489,7 +489,7 @@ ext3_xattr_set_acl(struct inode *inode, int type, const void *value,
 
         if (!test_opt(inode->i_sb, POSIX_ACL))
                 return -EOPNOTSUPP;
-        if ((current->fsuid != inode->i_uid) && !capable(CAP_FOWNER))
+        if (!is_owner_or_cap(inode))
                 return -EPERM;
 
         if (value) {
diff --git a/fs/ext3/ioctl.c b/fs/ext3/ioctl.c
index 965006dba6be..4a2a02c95bf9 100644
--- a/fs/ext3/ioctl.c
+++ b/fs/ext3/ioctl.c
@@ -41,7 +41,7 @@ int ext3_ioctl (struct inode * inode, struct file * filp, unsigned int cmd,
                 if (IS_RDONLY(inode))
                         return -EROFS;
 
-                if ((current->fsuid != inode->i_uid) && !capable(CAP_FOWNER))
+                if (!is_owner_or_cap(inode))
                         return -EACCES;
 
                 if (get_user(flags, (int __user *) arg))
@@ -122,7 +122,7 @@ flags_err:
                 __u32 generation;
                 int err;
 
-                if ((current->fsuid != inode->i_uid) && !capable(CAP_FOWNER))
+                if (!is_owner_or_cap(inode))
                         return -EPERM;
                 if (IS_RDONLY(inode))
                         return -EROFS;
@@ -181,7 +181,7 @@ flags_err:
                 if (IS_RDONLY(inode))
                         return -EROFS;
 
-                if ((current->fsuid != inode->i_uid) && !capable(CAP_FOWNER))
+                if (!is_owner_or_cap(inode))
                         return -EACCES;
 
                 if (get_user(rsv_window_size, (int __user *)arg))
diff --git a/fs/ext3/super.c b/fs/ext3/super.c
index 51d1c456cdab..4f84dc86628a 100644
--- a/fs/ext3/super.c
+++ b/fs/ext3/super.c
@@ -29,6 +29,7 @@
 #include <linux/parser.h>
 #include <linux/smp_lock.h>
 #include <linux/buffer_head.h>
+#include <linux/exportfs.h>
 #include <linux/vfs.h>
 #include <linux/random.h>
 #include <linux/mount.h>
diff --git a/fs/ext4/acl.c b/fs/ext4/acl.c
index 9e882546d91a..a8bae8cd1d5d 100644
--- a/fs/ext4/acl.c
+++ b/fs/ext4/acl.c
@@ -489,7 +489,7 @@ ext4_xattr_set_acl(struct inode *inode, int type, const void *value,
 
         if (!test_opt(inode->i_sb, POSIX_ACL))
                 return -EOPNOTSUPP;
-        if ((current->fsuid != inode->i_uid) && !capable(CAP_FOWNER))
+        if (!is_owner_or_cap(inode))
                 return -EPERM;
 
         if (value) {
diff --git a/fs/ext4/ioctl.c b/fs/ext4/ioctl.c
index 500567dd53b6..7b4aa4543c83 100644
--- a/fs/ext4/ioctl.c
+++ b/fs/ext4/ioctl.c
@@ -40,7 +40,7 @@ int ext4_ioctl (struct inode * inode, struct file * filp, unsigned int cmd,
                 if (IS_RDONLY(inode))
                         return -EROFS;
 
-                if ((current->fsuid != inode->i_uid) && !capable(CAP_FOWNER))
+                if (!is_owner_or_cap(inode))
                         return -EACCES;
 
                 if (get_user(flags, (int __user *) arg))
@@ -121,7 +121,7 @@ flags_err:
                 __u32 generation;
                 int err;
 
-                if ((current->fsuid != inode->i_uid) && !capable(CAP_FOWNER))
+                if (!is_owner_or_cap(inode))
                         return -EPERM;
                 if (IS_RDONLY(inode))
                         return -EROFS;
@@ -180,7 +180,7 @@ flags_err:
                 if (IS_RDONLY(inode))
                         return -EROFS;
 
-                if ((current->fsuid != inode->i_uid) && !capable(CAP_FOWNER))
+                if (!is_owner_or_cap(inode))
                         return -EACCES;
 
                 if (get_user(rsv_window_size, (int __user *)arg))
diff --git a/fs/ext4/super.c b/fs/ext4/super.c
index d0d8c76c7edb..b806e689c4aa 100644
--- a/fs/ext4/super.c
+++ b/fs/ext4/super.c
@@ -29,6 +29,7 @@
 #include <linux/parser.h>
 #include <linux/smp_lock.h>
 #include <linux/buffer_head.h>
+#include <linux/exportfs.h>
 #include <linux/vfs.h>
 #include <linux/random.h>
 #include <linux/mount.h>
diff --git a/fs/fat/inode.c b/fs/fat/inode.c
index cfaf5877d98b..0a7ddb39a593 100644
--- a/fs/fat/inode.c
+++ b/fs/fat/inode.c
@@ -20,6 +20,7 @@
 #include <linux/pagemap.h>
 #include <linux/mpage.h>
 #include <linux/buffer_head.h>
+#include <linux/exportfs.h>
 #include <linux/mount.h>
 #include <linux/vfs.h>
 #include <linux/parser.h>
diff --git a/fs/fcntl.c b/fs/fcntl.c
index 8e382a5d51bd..3f22e9f4f691 100644
--- a/fs/fcntl.c
+++ b/fs/fcntl.c
@@ -215,7 +215,7 @@ static int setfl(int fd, struct file * filp, unsigned long arg)
 
         /* O_NOATIME can only be set by the owner or superuser */
         if ((arg & O_NOATIME) && !(filp->f_flags & O_NOATIME))
-                if (current->fsuid != inode->i_uid && !capable(CAP_FOWNER))
+                if (!is_owner_or_cap(inode))
                         return -EPERM;
 
         /* required for strict SunOS emulation */
diff --git a/fs/generic_acl.c b/fs/generic_acl.c
index 9ccb78947171..995d63b2e747 100644
--- a/fs/generic_acl.c
+++ b/fs/generic_acl.c
@@ -78,7 +78,7 @@ generic_acl_set(struct inode *inode, struct generic_acl_operations *ops,
 
         if (S_ISLNK(inode->i_mode))
                 return -EOPNOTSUPP;
-        if (current->fsuid != inode->i_uid && !capable(CAP_FOWNER))
+        if (!is_owner_or_cap(inode))
                 return -EPERM;
         if (value) {
                 acl = posix_acl_from_xattr(value, size);
diff --git a/fs/gfs2/acl.c b/fs/gfs2/acl.c
index 6e80844367ee..1047a8c7226a 100644
--- a/fs/gfs2/acl.c
+++ b/fs/gfs2/acl.c
@@ -74,7 +74,7 @@ int gfs2_acl_validate_remove(struct gfs2_inode *ip, int access)
 {
         if (!GFS2_SB(&ip->i_inode)->sd_args.ar_posix_acl)
                 return -EOPNOTSUPP;
-        if (current->fsuid != ip->i_inode.i_uid && !capable(CAP_FOWNER))
+        if (!is_owner_or_cap(&ip->i_inode))
                 return -EPERM;
         if (S_ISLNK(ip->i_inode.i_mode))
                 return -EOPNOTSUPP;
diff --git a/fs/gfs2/ops_export.c b/fs/gfs2/ops_export.c
index 99ea5659bc2c..b8312edee0e4 100644
--- a/fs/gfs2/ops_export.c
+++ b/fs/gfs2/ops_export.c
@@ -11,6 +11,7 @@
 #include <linux/spinlock.h>
 #include <linux/completion.h>
 #include <linux/buffer_head.h>
+#include <linux/exportfs.h>
 #include <linux/gfs2_ondisk.h>
 #include <linux/crc32.h>
 #include <linux/lm_interface.h>
diff --git a/fs/hfsplus/ioctl.c b/fs/hfsplus/ioctl.c
index 79fd10402ea3..b60c0affbec5 100644
--- a/fs/hfsplus/ioctl.c
+++ b/fs/hfsplus/ioctl.c
@@ -38,7 +38,7 @@ int hfsplus_ioctl(struct inode *inode, struct file *filp, unsigned int cmd,
                 if (IS_RDONLY(inode))
                         return -EROFS;
 
-                if ((current->fsuid != inode->i_uid) && !capable(CAP_FOWNER))
+                if (!is_owner_or_cap(inode))
                         return -EACCES;
 
                 if (get_user(flags, (int __user *)arg))
diff --git a/fs/inode.c b/fs/inode.c
index 9a012cc5b6cd..320e088d0b28 100644
--- a/fs/inode.c
+++ b/fs/inode.c
@@ -145,7 +145,7 @@ static struct inode *alloc_inode(struct super_block *sb)
                 mapping->a_ops = &empty_aops;
                 mapping->host = inode;
                 mapping->flags = 0;
-                mapping_set_gfp_mask(mapping, GFP_HIGHUSER);
+                mapping_set_gfp_mask(mapping, GFP_HIGHUSER_PAGECACHE);
                 mapping->assoc_mapping = NULL;
                 mapping->backing_dev_info = &default_backing_dev_info;
 
@@ -462,6 +462,11 @@ static int shrink_icache_memory(int nr, gfp_t gfp_mask)
         return (inodes_stat.nr_unused / 100) * sysctl_vfs_cache_pressure;
 }
 
+static struct shrinker icache_shrinker = {
+        .shrink = shrink_icache_memory,
+        .seeks = DEFAULT_SEEKS,
+};
+
 static void __wait_on_freeing_inode(struct inode *inode);
 /*
  * Called with the inode lock held.
@@ -519,7 +524,13 @@ repeat:
  *      new_inode       - obtain an inode
  *      @sb: superblock
  *
- *      Allocates a new inode for given superblock.
+ *      Allocates a new inode for given superblock. The default gfp_mask
+ *      for allocations related to inode->i_mapping is GFP_HIGHUSER_PAGECACHE.
+ *      If HIGHMEM pages are unsuitable or it is known that pages allocated
+ *      for the page cache are not reclaimable or migratable,
+ *      mapping_set_gfp_mask() must be called with suitable flags on the
+ *      newly created inode's mapping
+ *
  */
 struct inode *new_inode(struct super_block *sb)
 {
@@ -1379,7 +1390,7 @@ void __init inode_init(unsigned long mempages)
                                          SLAB_MEM_SPREAD),
                                          init_once,
                                          NULL);
-        set_shrinker(DEFAULT_SEEKS, shrink_icache_memory);
+        register_shrinker(&icache_shrinker);
 
         /* Hash may have been set up in inode_init_early */
         if (!hashdist)
diff --git a/fs/isofs/isofs.h b/fs/isofs/isofs.h
index efe2872cd4e3..a07e67b1ea7f 100644
--- a/fs/isofs/isofs.h
+++ b/fs/isofs/isofs.h
@@ -1,5 +1,6 @@
 #include <linux/fs.h>
 #include <linux/buffer_head.h>
+#include <linux/exportfs.h>
 #include <linux/iso_fs.h>
 #include <asm/unaligned.h>
 
diff --git a/fs/jffs2/acl.c b/fs/jffs2/acl.c
index a46101ee867a..65b3a1b5b88d 100644
--- a/fs/jffs2/acl.c
+++ b/fs/jffs2/acl.c
@@ -435,7 +435,7 @@ static int jffs2_acl_setxattr(struct inode *inode, int type, const void *value,
         struct posix_acl *acl;
         int rc;
 
-        if ((current->fsuid != inode->i_uid) && !capable(CAP_FOWNER))
+        if (!is_owner_or_cap(inode))
                 return -EPERM;
 
         if (value) {
diff --git a/fs/jffs2/background.c b/fs/jffs2/background.c
index 0c82dfcfd246..143c5530caf3 100644
--- a/fs/jffs2/background.c
+++ b/fs/jffs2/background.c
@@ -81,6 +81,7 @@ static int jffs2_garbage_collect_thread(void *_c)
 
         set_user_nice(current, 10);
 
+        set_freezable();
         for (;;) {
                 allow_signal(SIGHUP);
 
diff --git a/fs/jfs/ioctl.c b/fs/jfs/ioctl.c
index fe063af6fd2f..3c8663bea98c 100644
--- a/fs/jfs/ioctl.c
+++ b/fs/jfs/ioctl.c
@@ -69,7 +69,7 @@ int jfs_ioctl(struct inode * inode, struct file * filp, unsigned int cmd,
                 if (IS_RDONLY(inode))
                         return -EROFS;
 
-                if ((current->fsuid != inode->i_uid) && !capable(CAP_FOWNER))
+                if (!is_owner_or_cap(inode))
                         return -EACCES;
 
                 if (get_user(flags, (int __user *) arg))
diff --git a/fs/jfs/jfs_inode.h b/fs/jfs/jfs_inode.h
index 2374b595f2e1..f0ec72b263f1 100644
--- a/fs/jfs/jfs_inode.h
+++ b/fs/jfs/jfs_inode.h
@@ -32,6 +32,7 @@ extern void jfs_truncate_nolock(struct inode *, loff_t);
 extern void jfs_free_zero_link(struct inode *);
 extern struct dentry *jfs_get_parent(struct dentry *dentry);
 extern void jfs_get_inode_flags(struct jfs_inode_info *);
+extern struct dentry *jfs_get_dentry(struct super_block *sb, void *vobjp);
 extern void jfs_set_inode_flags(struct inode *);
 extern int jfs_get_block(struct inode *, sector_t, struct buffer_head *, int);
 
diff --git a/fs/jfs/namei.c b/fs/jfs/namei.c
index 25161c4121e4..932797ba433b 100644
--- a/fs/jfs/namei.c
+++ b/fs/jfs/namei.c
@@ -1477,6 +1477,38 @@ static struct dentry *jfs_lookup(struct inode *dip, struct dentry *dentry, struc
         return dentry;
 }
 
+struct dentry *jfs_get_dentry(struct super_block *sb, void *vobjp)
+{
+        __u32 *objp = vobjp;
+        unsigned long ino = objp[0];
+        __u32 generation = objp[1];
+        struct inode *inode;
+        struct dentry *result;
+
+        if (ino == 0)
+                return ERR_PTR(-ESTALE);
+        inode = iget(sb, ino);
+        if (inode == NULL)
+                return ERR_PTR(-ENOMEM);
+
+        if (is_bad_inode(inode) ||
+            (generation && inode->i_generation != generation)) {
+                result = ERR_PTR(-ESTALE);
+                goto out_iput;
+        }
+
+        result = d_alloc_anon(inode);
+        if (!result) {
+                result = ERR_PTR(-ENOMEM);
+                goto out_iput;
+        }
+        return result;
+
+ out_iput:
+        iput(inode);
+        return result;
+}
+
 struct dentry *jfs_get_parent(struct dentry *dentry)
 {
         struct super_block *sb = dentry->d_inode->i_sb;
diff --git a/fs/jfs/super.c b/fs/jfs/super.c
index 20e4ac1c79a3..929fceca7999 100644
--- a/fs/jfs/super.c
+++ b/fs/jfs/super.c
@@ -27,6 +27,7 @@
 #include <linux/kthread.h>
 #include <linux/posix_acl.h>
 #include <linux/buffer_head.h>
+#include <linux/exportfs.h>
 #include <asm/uaccess.h>
 #include <linux/seq_file.h>
 
@@ -737,6 +738,7 @@ static const struct super_operations jfs_super_operations = {
 };
 
 static struct export_operations jfs_export_operations = {
+        .get_dentry     = jfs_get_dentry,
         .get_parent     = jfs_get_parent,
 };
 
diff --git a/fs/jfs/xattr.c b/fs/jfs/xattr.c
index b2375f0774b7..9b7f2cdaae0a 100644
--- a/fs/jfs/xattr.c
+++ b/fs/jfs/xattr.c
@@ -697,7 +697,7 @@ static int can_set_system_xattr(struct inode *inode, const char *name,
         struct posix_acl *acl;
         int rc;
 
-        if ((current->fsuid != inode->i_uid) && !capable(CAP_FOWNER))
+        if (!is_owner_or_cap(inode))
                 return -EPERM;
 
         /*
diff --git a/fs/lockd/svc.c b/fs/lockd/svc.c
index 26809325469c..82e2192a0d5c 100644
--- a/fs/lockd/svc.c
+++ b/fs/lockd/svc.c
@@ -25,6 +25,7 @@
 #include <linux/smp.h>
 #include <linux/smp_lock.h>
 #include <linux/mutex.h>
+#include <linux/freezer.h>
 
 #include <linux/sunrpc/types.h>
 #include <linux/sunrpc/stats.h>
@@ -75,18 +76,31 @@ static const int		nlm_port_min = 0, nlm_port_max = 65535;
 
 static struct ctl_table_header * nlm_sysctl_table;
 
-static unsigned long set_grace_period(void)
+static unsigned long get_lockd_grace_period(void)
 {
-        unsigned long grace_period;
-
         /* Note: nlm_timeout should always be nonzero */
         if (nlm_grace_period)
-                grace_period = ((nlm_grace_period + nlm_timeout - 1)
-                                / nlm_timeout) * nlm_timeout * HZ;
+                return roundup(nlm_grace_period, nlm_timeout) * HZ;
         else
-                grace_period = nlm_timeout * 5 * HZ;
+                return nlm_timeout * 5 * HZ;
+}
+
+unsigned long get_nfs_grace_period(void)
+{
+        unsigned long lockdgrace = get_lockd_grace_period();
+        unsigned long nfsdgrace = 0;
+
+        if (nlmsvc_ops)
+                nfsdgrace = nlmsvc_ops->get_grace_period();
+
+        return max(lockdgrace, nfsdgrace);
+}
+EXPORT_SYMBOL(get_nfs_grace_period);
+
+static unsigned long set_grace_period(void)
+{
         nlmsvc_grace_period = 1;
-        return grace_period + jiffies;
+        return get_nfs_grace_period() + jiffies;
 }
 
 static inline void clear_grace_period(void)
@@ -119,6 +133,7 @@ lockd(struct svc_rqst *rqstp)
         complete(&lockd_start_done);
 
         daemonize("lockd");
+        set_freezable();
 
         /* Process request with signals blocked, but allow SIGKILL.  */
         allow_signal(SIGKILL);
diff --git a/fs/mbcache.c b/fs/mbcache.c
index deeb9dc062d9..fbb1d02f8791 100644
--- a/fs/mbcache.c
+++ b/fs/mbcache.c
@@ -100,7 +100,6 @@ struct mb_cache {
 static LIST_HEAD(mb_cache_list);
 static LIST_HEAD(mb_cache_lru_list);
 static DEFINE_SPINLOCK(mb_cache_spinlock);
-static struct shrinker *mb_shrinker;
 
 static inline int
 mb_cache_indexes(struct mb_cache *cache)
@@ -118,6 +117,10 @@ mb_cache_indexes(struct mb_cache *cache)
 
 static int mb_cache_shrink_fn(int nr_to_scan, gfp_t gfp_mask);
 
+static struct shrinker mb_cache_shrinker = {
+        .shrink = mb_cache_shrink_fn,
+        .seeks = DEFAULT_SEEKS,
+};
 
 static inline int
 __mb_cache_entry_is_hashed(struct mb_cache_entry *ce)
@@ -662,13 +665,13 @@ mb_cache_entry_find_next(struct mb_cache_entry *prev, int index,
 
 static int __init init_mbcache(void)
 {
-        mb_shrinker = set_shrinker(DEFAULT_SEEKS, mb_cache_shrink_fn);
+        register_shrinker(&mb_cache_shrinker);
         return 0;
 }
 
 static void __exit exit_mbcache(void)
 {
-        remove_shrinker(mb_shrinker);
+        unregister_shrinker(&mb_cache_shrinker);
 }
 
 module_init(init_mbcache)
diff --git a/fs/namei.c b/fs/namei.c
index 5e2d98d10c5d..defaa47c11d4 100644
--- a/fs/namei.c
+++ b/fs/namei.c
@@ -1576,7 +1576,7 @@ int may_open(struct nameidata *nd, int acc_mode, int flag)
 
         /* O_NOATIME can only be set by the owner or superuser */
         if (flag & O_NOATIME)
-                if (current->fsuid != inode->i_uid && !capable(CAP_FOWNER))
+                if (!is_owner_or_cap(inode))
                         return -EPERM;
 
         /*
diff --git a/fs/nfs/callback.c b/fs/nfs/callback.c
index 75f309c8741a..a796be5051bf 100644
--- a/fs/nfs/callback.c
+++ b/fs/nfs/callback.c
@@ -14,6 +14,7 @@
 #include <linux/sunrpc/svcsock.h>
 #include <linux/nfs_fs.h>
 #include <linux/mutex.h>
+#include <linux/freezer.h>
 
 #include <net/inet_sock.h>
 
@@ -67,6 +68,7 @@ static void nfs_callback_svc(struct svc_rqst *rqstp)
         daemonize("nfsv4-svc");
         /* Process request with signals blocked, but allow SIGKILL.  */
         allow_signal(SIGKILL);
+        set_freezable();
 
         complete(&nfs_callback_info.started);
 
diff --git a/fs/nfs/super.c b/fs/nfs/super.c
index a2b1af89ca1a..adffe1615c51 100644
--- a/fs/nfs/super.c
+++ b/fs/nfs/super.c
@@ -300,7 +300,10 @@ static const struct super_operations nfs4_sops = {
 };
 #endif
 
-static struct shrinker *acl_shrinker;
+static struct shrinker acl_shrinker = {
+        .shrink         = nfs_access_cache_shrinker,
+        .seeks          = DEFAULT_SEEKS,
+};
 
 /*
  * Register the NFS filesystems
@@ -321,7 +324,7 @@ int __init register_nfs_fs(void)
         if (ret < 0)
                 goto error_2;
 #endif
-        acl_shrinker = set_shrinker(DEFAULT_SEEKS, nfs_access_cache_shrinker);
+        register_shrinker(&acl_shrinker);
         return 0;
 
 #ifdef CONFIG_NFS_V4
@@ -339,8 +342,7 @@ error_0:
  */
 void __exit unregister_nfs_fs(void)
 {
-        if (acl_shrinker != NULL)
-                remove_shrinker(acl_shrinker);
+        unregister_shrinker(&acl_shrinker);
 #ifdef CONFIG_NFS_V4
         unregister_filesystem(&nfs4_fs_type);
         nfs_unregister_sysctl();
diff --git a/fs/nfsd/auth.c b/fs/nfsd/auth.c
index 6e92b0fe5323..cf61dc8ae942 100644
--- a/fs/nfsd/auth.c
+++ b/fs/nfsd/auth.c
@@ -12,17 +12,31 @@
 
 #define CAP_NFSD_MASK (CAP_FS_MASK|CAP_TO_MASK(CAP_SYS_RESOURCE))
 
+static int nfsexp_flags(struct svc_rqst *rqstp, struct svc_export *exp)
+{
+        struct exp_flavor_info *f;
+        struct exp_flavor_info *end = exp->ex_flavors + exp->ex_nflavors;
+
+        for (f = exp->ex_flavors; f < end; f++) {
+                if (f->pseudoflavor == rqstp->rq_flavor)
+                        return f->flags;
+        }
+        return exp->ex_flags;
+
+}
+
 int nfsd_setuser(struct svc_rqst *rqstp, struct svc_export *exp)
 {
         struct svc_cred cred = rqstp->rq_cred;
         int i;
+        int flags = nfsexp_flags(rqstp, exp);
         int ret;
 
-        if (exp->ex_flags & NFSEXP_ALLSQUASH) {
+        if (flags & NFSEXP_ALLSQUASH) {
                 cred.cr_uid = exp->ex_anon_uid;
                 cred.cr_gid = exp->ex_anon_gid;
                 cred.cr_group_info = groups_alloc(0);
-        } else if (exp->ex_flags & NFSEXP_ROOTSQUASH) {
+        } else if (flags & NFSEXP_ROOTSQUASH) {
                 struct group_info *gi;
                 if (!cred.cr_uid)
                         cred.cr_uid = exp->ex_anon_uid;
diff --git a/fs/nfsd/export.c b/fs/nfsd/export.c
index 79bd03b8bbf8..c7bbf460b009 100644
--- a/fs/nfsd/export.c
+++ b/fs/nfsd/export.c
@@ -26,12 +26,15 @@
 #include <linux/mount.h>
 #include <linux/hash.h>
 #include <linux/module.h>
+#include <linux/exportfs.h>
 
 #include <linux/sunrpc/svc.h>
 #include <linux/nfsd/nfsd.h>
 #include <linux/nfsd/nfsfh.h>
 #include <linux/nfsd/syscall.h>
 #include <linux/lockd/bind.h>
+#include <linux/sunrpc/msg_prot.h>
+#include <linux/sunrpc/gss_api.h>
 
 #define NFSDDBG_FACILITY        NFSDDBG_EXPORT
 
@@ -451,8 +454,48 @@ out_free_all:
         return err;
 }
 
+static int secinfo_parse(char **mesg, char *buf, struct svc_export *exp)
+{
+        int listsize, err;
+        struct exp_flavor_info *f;
+
+        err = get_int(mesg, &listsize);
+        if (err)
+                return err;
+        if (listsize < 0 || listsize > MAX_SECINFO_LIST)
+                return -EINVAL;
+
+        for (f = exp->ex_flavors; f < exp->ex_flavors + listsize; f++) {
+                err = get_int(mesg, &f->pseudoflavor);
+                if (err)
+                        return err;
+                /*
+                 * Just a quick sanity check; we could also try to check
+                 * whether this pseudoflavor is supported, but at worst
+                 * an unsupported pseudoflavor on the export would just
+                 * be a pseudoflavor that won't match the flavor of any
+                 * authenticated request.  The administrator will
+                 * probably discover the problem when someone fails to
+                 * authenticate.
+                 */
+                if (f->pseudoflavor < 0)
+                        return -EINVAL;
+                err = get_int(mesg, &f->flags);
+                if (err)
+                        return err;
+                /* Only some flags are allowed to differ between flavors: */
+                if (~NFSEXP_SECINFO_FLAGS & (f->flags ^ exp->ex_flags))
+                        return -EINVAL;
+        }
+        exp->ex_nflavors = listsize;
+        return 0;
+}
+
 #else /* CONFIG_NFSD_V4 */
-static inline int fsloc_parse(char **mesg, char *buf, struct nfsd4_fs_locations *fsloc) { return 0; }
+static inline int
+fsloc_parse(char **mesg, char *buf, struct nfsd4_fs_locations *fsloc){return 0;}
+static inline int
+secinfo_parse(char **mesg, char *buf, struct svc_export *exp) { return 0; }
 #endif
 
 static int svc_export_parse(struct cache_detail *cd, char *mesg, int mlen)
@@ -476,6 +519,9 @@ static int svc_export_parse(struct cache_detail *cd, char *mesg, int mlen)
 
         exp.ex_uuid = NULL;
 
+        /* secinfo */
+        exp.ex_nflavors = 0;
+
         if (mesg[mlen-1] != '\n')
                 return -EINVAL;
         mesg[mlen-1] = 0;
@@ -553,7 +599,9 @@ static int svc_export_parse(struct cache_detail *cd, char *mesg, int mlen)
                                         if (exp.ex_uuid == NULL)
                                                 err = -ENOMEM;
                                 }
-                        } else
+                        } else if (strcmp(buf, "secinfo") == 0)
+                                err = secinfo_parse(&mesg, buf, &exp);
+                        else
                                 /* quietly ignore unknown words and anything
                                  * following. Newer user-space can try to set
                                  * new values, then see what the result was.
@@ -593,6 +641,7 @@ static int svc_export_parse(struct cache_detail *cd, char *mesg, int mlen)
 
 static void exp_flags(struct seq_file *m, int flag, int fsid,
                 uid_t anonu, uid_t anong, struct nfsd4_fs_locations *fslocs);
+static void show_secinfo(struct seq_file *m, struct svc_export *exp);
 
 static int svc_export_show(struct seq_file *m,
                            struct cache_detail *cd,
@@ -622,6 +671,7 @@ static int svc_export_show(struct seq_file *m,
                                 seq_printf(m, "%02x", exp->ex_uuid[i]);
                         }
                 }
+                show_secinfo(m, exp);
         }
         seq_puts(m, ")\n");
         return 0;
@@ -654,6 +704,7 @@ static void export_update(struct cache_head *cnew, struct cache_head *citem)
 {
         struct svc_export *new = container_of(cnew, struct svc_export, h);
         struct svc_export *item = container_of(citem, struct svc_export, h);
+        int i;
 
         new->ex_flags = item->ex_flags;
         new->ex_anon_uid = item->ex_anon_uid;
@@ -669,6 +720,10 @@ static void export_update(struct cache_head *cnew, struct cache_head *citem)
         item->ex_fslocs.locations_count = 0;
         new->ex_fslocs.migrated = item->ex_fslocs.migrated;
         item->ex_fslocs.migrated = 0;
+        new->ex_nflavors = item->ex_nflavors;
+        for (i = 0; i < MAX_SECINFO_LIST; i++) {
+                new->ex_flavors[i] = item->ex_flavors[i];
+        }
 }
 
 static struct cache_head *svc_export_alloc(void)
@@ -738,16 +793,18 @@ exp_find_key(svc_client *clp, int fsid_type, u32 *fsidv, struct cache_req *reqp)
         int err;
         
         if (!clp)
-                return NULL;
+                return ERR_PTR(-ENOENT);
 
         key.ek_client = clp;
         key.ek_fsidtype = fsid_type;
         memcpy(key.ek_fsid, fsidv, key_len(fsid_type));
 
         ek = svc_expkey_lookup(&key);
-        if (ek != NULL)
-                if ((err = cache_check(&svc_expkey_cache, &ek->h, reqp)))
-                        ek = ERR_PTR(err);
+        if (ek == NULL)
+                return ERR_PTR(-ENOMEM);
+        err = cache_check(&svc_expkey_cache, &ek->h, reqp);
+        if (err)
+                return ERR_PTR(err);
         return ek;
 }
 
@@ -808,30 +865,21 @@ exp_get_by_name(svc_client *clp, struct vfsmount *mnt, struct dentry *dentry,
                 struct cache_req *reqp)
 {
         struct svc_export *exp, key;
+        int err;
         
         if (!clp)
-                return NULL;
+                return ERR_PTR(-ENOENT);
 
         key.ex_client = clp;
         key.ex_mnt = mnt;
         key.ex_dentry = dentry;
 
         exp = svc_export_lookup(&key);
-        if (exp != NULL)  {
-                int err;
-
-                err = cache_check(&svc_export_cache, &exp->h, reqp);
-                switch (err) {
-                case 0: break;
-                case -EAGAIN:
-                case -ETIMEDOUT:
-                        exp = ERR_PTR(err);
-                        break;
-                default:
-                        exp = NULL;
-                }
-        }
-
+        if (exp == NULL)
+                return ERR_PTR(-ENOMEM);
+        err = cache_check(&svc_export_cache, &exp->h, reqp);
+        if (err)
+                return ERR_PTR(err);
         return exp;
 }
 
@@ -847,7 +895,7 @@ exp_parent(svc_client *clp, struct vfsmount *mnt, struct dentry *dentry,
         dget(dentry);
         exp = exp_get_by_name(clp, mnt, dentry, reqp);
 
-        while (exp == NULL && !IS_ROOT(dentry)) {
+        while (PTR_ERR(exp) == -ENOENT && !IS_ROOT(dentry)) {
                 struct dentry *parent;
 
                 parent = dget_parent(dentry);
@@ -900,7 +948,7 @@ static void exp_fsid_unhash(struct svc_export *exp)
                 return;
 
         ek = exp_get_fsid_key(exp->ex_client, exp->ex_fsid);
-        if (ek && !IS_ERR(ek)) {
+        if (!IS_ERR(ek)) {
                 ek->h.expiry_time = get_seconds()-1;
                 cache_put(&ek->h, &svc_expkey_cache);
         }
@@ -938,7 +986,7 @@ static void exp_unhash(struct svc_export *exp)
         struct inode *inode = exp->ex_dentry->d_inode;
 
         ek = exp_get_key(exp->ex_client, inode->i_sb->s_dev, inode->i_ino);
-        if (ek && !IS_ERR(ek)) {
+        if (!IS_ERR(ek)) {
                 ek->h.expiry_time = get_seconds()-1;
                 cache_put(&ek->h, &svc_expkey_cache);
         }
@@ -989,13 +1037,12 @@ exp_export(struct nfsctl_export *nxp)
 
         /* must make sure there won't be an ex_fsid clash */
         if ((nxp->ex_flags & NFSEXP_FSID) &&
-            (fsid_key = exp_get_fsid_key(clp, nxp->ex_dev)) &&
-            !IS_ERR(fsid_key) &&
+            (!IS_ERR(fsid_key = exp_get_fsid_key(clp, nxp->ex_dev))) &&
             fsid_key->ek_mnt &&
             (fsid_key->ek_mnt != nd.mnt || fsid_key->ek_dentry != nd.dentry) )
                 goto finish;
 
-        if (exp) {
+        if (!IS_ERR(exp)) {
                 /* just a flags/id/fsid update */
 
                 exp_fsid_unhash(exp);
@@ -1104,7 +1151,7 @@ exp_unexport(struct nfsctl_export *nxp)
         err = -EINVAL;
         exp = exp_get_by_name(dom, nd.mnt, nd.dentry, NULL);
         path_release(&nd);
-        if (!exp)
+        if (IS_ERR(exp))
                 goto out_domain;
 
         exp_do_unexport(exp);
@@ -1149,10 +1196,6 @@ exp_rootfh(svc_client *clp, char *path, struct knfsd_fh *f, int maxsize)
                 err = PTR_ERR(exp);
                 goto out;
         }
-        if (!exp) {
-                dprintk("nfsd: exp_rootfh export not found.\n");
-                goto out;
-        }
 
         /*
          * fh must be initialized before calling fh_compose
@@ -1176,17 +1219,130 @@ exp_find(struct auth_domain *clp, int fsid_type, u32 *fsidv,
 {
         struct svc_export *exp;
         struct svc_expkey *ek = exp_find_key(clp, fsid_type, fsidv, reqp);
-        if (!ek || IS_ERR(ek))
+        if (IS_ERR(ek))
                 return ERR_PTR(PTR_ERR(ek));
 
         exp = exp_get_by_name(clp, ek->ek_mnt, ek->ek_dentry, reqp);
         cache_put(&ek->h, &svc_expkey_cache);
 
-        if (!exp || IS_ERR(exp))
+        if (IS_ERR(exp))
                 return ERR_PTR(PTR_ERR(exp));
         return exp;
 }
 
+__be32 check_nfsd_access(struct svc_export *exp, struct svc_rqst *rqstp)
+{
+        struct exp_flavor_info *f;
+        struct exp_flavor_info *end = exp->ex_flavors + exp->ex_nflavors;
+
+        /* legacy gss-only clients are always OK: */
+        if (exp->ex_client == rqstp->rq_gssclient)
+                return 0;
+        /* ip-address based client; check sec= export option: */
+        for (f = exp->ex_flavors; f < end; f++) {
+                if (f->pseudoflavor == rqstp->rq_flavor)
+                        return 0;
+        }
+        /* defaults in absence of sec= options: */
+        if (exp->ex_nflavors == 0) {
+                if (rqstp->rq_flavor == RPC_AUTH_NULL ||
+                    rqstp->rq_flavor == RPC_AUTH_UNIX)
+                        return 0;
+        }
+        return nfserr_wrongsec;
+}
+
+/*
+ * Uses rq_client and rq_gssclient to find an export; uses rq_client (an
+ * auth_unix client) if it's available and has secinfo information;
+ * otherwise, will try to use rq_gssclient.
+ *
+ * Called from functions that handle requests; functions that do work on
+ * behalf of mountd are passed a single client name to use, and should
+ * use exp_get_by_name() or exp_find().
+ */
+struct svc_export *
+rqst_exp_get_by_name(struct svc_rqst *rqstp, struct vfsmount *mnt,
+                struct dentry *dentry)
+{
+        struct svc_export *gssexp, *exp = NULL;
+
+        if (rqstp->rq_client == NULL)
+                goto gss;
+
+        /* First try the auth_unix client: */
+        exp = exp_get_by_name(rqstp->rq_client, mnt, dentry,
+                                                &rqstp->rq_chandle);
+        if (PTR_ERR(exp) == -ENOENT)
+                goto gss;
+        if (IS_ERR(exp))
+                return exp;
+        /* If it has secinfo, assume there are no gss/... clients */
+        if (exp->ex_nflavors > 0)
+                return exp;
+gss:
+        /* Otherwise, try falling back on gss client */
+        if (rqstp->rq_gssclient == NULL)
+                return exp;
+        gssexp = exp_get_by_name(rqstp->rq_gssclient, mnt, dentry,
+                                                &rqstp->rq_chandle);
+        if (PTR_ERR(gssexp) == -ENOENT)
+                return exp;
+        if (exp && !IS_ERR(exp))
+                exp_put(exp);
+        return gssexp;
+}
+
+struct svc_export *
+rqst_exp_find(struct svc_rqst *rqstp, int fsid_type, u32 *fsidv)
+{
+        struct svc_export *gssexp, *exp = NULL;
+
+        if (rqstp->rq_client == NULL)
+                goto gss;
+
+        /* First try the auth_unix client: */
+        exp = exp_find(rqstp->rq_client, fsid_type, fsidv, &rqstp->rq_chandle);
+        if (PTR_ERR(exp) == -ENOENT)
+                goto gss;
+        if (IS_ERR(exp))
+                return exp;
+        /* If it has secinfo, assume there are no gss/... clients */
+        if (exp->ex_nflavors > 0)
+                return exp;
+gss:
+        /* Otherwise, try falling back on gss client */
+        if (rqstp->rq_gssclient == NULL)
+                return exp;
+        gssexp = exp_find(rqstp->rq_gssclient, fsid_type, fsidv,
+                                                &rqstp->rq_chandle);
+        if (PTR_ERR(gssexp) == -ENOENT)
+                return exp;
+        if (exp && !IS_ERR(exp))
+                exp_put(exp);
+        return gssexp;
+}
+
+struct svc_export *
+rqst_exp_parent(struct svc_rqst *rqstp, struct vfsmount *mnt,
+                struct dentry *dentry)
+{
+        struct svc_export *exp;
+
+        dget(dentry);
+        exp = rqst_exp_get_by_name(rqstp, mnt, dentry);
+
+        while (PTR_ERR(exp) == -ENOENT && !IS_ROOT(dentry)) {
+                struct dentry *parent;
+
+                parent = dget_parent(dentry);
+                dput(dentry);
+                dentry = parent;
+                exp = rqst_exp_get_by_name(rqstp, mnt, dentry);
+        }
+        dput(dentry);
+        return exp;
+}
 
 /*
  * Called when we need the filehandle for the root of the pseudofs,
@@ -1194,8 +1350,7 @@ exp_find(struct auth_domain *clp, int fsid_type, u32 *fsidv,
  * export point with fsid==0
  */
 __be32
-exp_pseudoroot(struct auth_domain *clp, struct svc_fh *fhp,
-               struct cache_req *creq)
+exp_pseudoroot(struct svc_rqst *rqstp, struct svc_fh *fhp)
 {
         struct svc_export *exp;
         __be32 rv;
@@ -1203,12 +1358,16 @@ exp_pseudoroot(struct auth_domain *clp, struct svc_fh *fhp,
 
         mk_fsid(FSID_NUM, fsidv, 0, 0, 0, NULL);
 
-        exp = exp_find(clp, FSID_NUM, fsidv, creq);
+        exp = rqst_exp_find(rqstp, FSID_NUM, fsidv);
+        if (PTR_ERR(exp) == -ENOENT)
+                return nfserr_perm;
         if (IS_ERR(exp))
                 return nfserrno(PTR_ERR(exp));
-        if (exp == NULL)
-                return nfserr_perm;
         rv = fh_compose(fhp, exp, exp->ex_dentry, NULL);
+        if (rv)
+                goto out;
+        rv = check_nfsd_access(exp, rqstp);
+out:
         exp_put(exp);
         return rv;
 }
@@ -1296,28 +1455,62 @@ static struct flags {
         { 0, {"", ""}}
 };
 
-static void exp_flags(struct seq_file *m, int flag, int fsid,
-                uid_t anonu, uid_t anong, struct nfsd4_fs_locations *fsloc)
+static void show_expflags(struct seq_file *m, int flags, int mask)
 {
-        int first = 0;
         struct flags *flg;
+        int state, first = 0;
 
         for (flg = expflags; flg->flag; flg++) {
-                int state = (flg->flag & flag)?0:1;
+                if (flg->flag & ~mask)
+                        continue;
+                state = (flg->flag & flags) ? 0 : 1;
                 if (*flg->name[state])
                         seq_printf(m, "%s%s", first++?",":"", flg->name[state]);
         }
+}
+
+static void show_secinfo_flags(struct seq_file *m, int flags)
+{
+        seq_printf(m, ",");
+        show_expflags(m, flags, NFSEXP_SECINFO_FLAGS);
+}
+
+static void show_secinfo(struct seq_file *m, struct svc_export *exp)
+{
+        struct exp_flavor_info *f;
+        struct exp_flavor_info *end = exp->ex_flavors + exp->ex_nflavors;
+        int lastflags = 0, first = 0;
+
+        if (exp->ex_nflavors == 0)
+                return;
+        for (f = exp->ex_flavors; f < end; f++) {
+                if (first || f->flags != lastflags) {
+                        if (!first)
+                                show_secinfo_flags(m, lastflags);
+                        seq_printf(m, ",sec=%d", f->pseudoflavor);
+                        lastflags = f->flags;
+                } else {
+                        seq_printf(m, ":%d", f->pseudoflavor);
+                }
+        }
+        show_secinfo_flags(m, lastflags);
+}
+
+static void exp_flags(struct seq_file *m, int flag, int fsid,
+                uid_t anonu, uid_t anong, struct nfsd4_fs_locations *fsloc)
+{
+        show_expflags(m, flag, NFSEXP_ALLFLAGS);
         if (flag & NFSEXP_FSID)
-                seq_printf(m, "%sfsid=%d", first++?",":"", fsid);
+                seq_printf(m, ",fsid=%d", fsid);
         if (anonu != (uid_t)-2 && anonu != (0x10000-2))
-                seq_printf(m, "%sanonuid=%d", first++?",":"", anonu);
+                seq_printf(m, ",sanonuid=%d", anonu);
         if (anong != (gid_t)-2 && anong != (0x10000-2))
-                seq_printf(m, "%sanongid=%d", first++?",":"", anong);
+                seq_printf(m, ",sanongid=%d", anong);
         if (fsloc && fsloc->locations_count > 0) {
                 char *loctype = (fsloc->migrated) ? "refer" : "replicas";
                 int i;
 
-                seq_printf(m, "%s%s=", first++?",":"", loctype);
+                seq_printf(m, ",%s=", loctype);
                 seq_escape(m, fsloc->locations[0].path, ",;@ \t\n\\");
                 seq_putc(m, '@');
                 seq_escape(m, fsloc->locations[0].hosts, ",;@ \t\n\\");
diff --git a/fs/nfsd/lockd.c b/fs/nfsd/lockd.c
index 221acd1f11f6..9e4a568a5013 100644
--- a/fs/nfsd/lockd.c
+++ b/fs/nfsd/lockd.c
@@ -65,6 +65,7 @@ nlm_fclose(struct file *filp)
 static struct nlmsvc_binding    nfsd_nlm_ops = {
         .fopen          = nlm_fopen,            /* open file for locking */
         .fclose         = nlm_fclose,           /* close file */
+        .get_grace_period = get_nfs4_grace_period,
 };
 
 void
diff --git a/fs/nfsd/nfs4acl.c b/fs/nfsd/nfs4acl.c
index cc3b7badd486..b6ed38380ab8 100644
--- a/fs/nfsd/nfs4acl.c
+++ b/fs/nfsd/nfs4acl.c
@@ -183,8 +183,13 @@ static void
 summarize_posix_acl(struct posix_acl *acl, struct posix_acl_summary *pas)
 {
         struct posix_acl_entry *pa, *pe;
-        pas->users = 0;
-        pas->groups = 0;
+
+        /*
+         * Only pas.users and pas.groups need initialization; previous
+         * posix_acl_valid() calls ensure that the other fields will be
+         * initialized in the following loop.  But, just to placate gcc:
+         */
+        memset(pas, 0, sizeof(*pas));
         pas->mask = 07;
 
         pe = acl->a_entries + acl->a_count;
@@ -732,13 +737,16 @@ int nfs4_acl_nfsv4_to_posix(struct nfs4_acl *acl, struct posix_acl **pacl,
         *pacl = posix_state_to_acl(&effective_acl_state, flags);
         if (IS_ERR(*pacl)) {
                 ret = PTR_ERR(*pacl);
+                *pacl = NULL;
                 goto out_dstate;
         }
         *dpacl = posix_state_to_acl(&default_acl_state,
                                                 flags | NFS4_ACL_TYPE_DEFAULT);
         if (IS_ERR(*dpacl)) {
                 ret = PTR_ERR(*dpacl);
+                *dpacl = NULL;
                 posix_acl_release(*pacl);
+                *pacl = NULL;
                 goto out_dstate;
         }
         sort_pacl(*pacl);
diff --git a/fs/nfsd/nfs4callback.c b/fs/nfsd/nfs4callback.c
index 5443c52b57aa..31d6633c7fe4 100644
--- a/fs/nfsd/nfs4callback.c
+++ b/fs/nfsd/nfs4callback.c
@@ -75,7 +75,7 @@ enum nfs_cb_opnum4 {
 #define op_enc_sz                       1
 #define op_dec_sz                       2
 #define enc_nfs4_fh_sz                  (1 + (NFS4_FHSIZE >> 2))
-#define enc_stateid_sz                  16
+#define enc_stateid_sz                  (NFS4_STATEID_SIZE >> 2)
 #define NFS4_enc_cb_recall_sz           (cb_compound_enc_hdr_sz +       \
                                         1 + enc_stateid_sz +            \
                                         enc_nfs4_fh_sz)
diff --git a/fs/nfsd/nfs4idmap.c b/fs/nfsd/nfs4idmap.c
index 45aa21ce6784..2cf9a9a2d89c 100644
--- a/fs/nfsd/nfs4idmap.c
+++ b/fs/nfsd/nfs4idmap.c
@@ -587,6 +587,15 @@ idmap_lookup(struct svc_rqst *rqstp,
         return ret;
 }
 
+static char *
+rqst_authname(struct svc_rqst *rqstp)
+{
+        struct auth_domain *clp;
+
+        clp = rqstp->rq_gssclient ? rqstp->rq_gssclient : rqstp->rq_client;
+        return clp->name;
+}
+
 static int
 idmap_name_to_id(struct svc_rqst *rqstp, int type, const char *name, u32 namelen,
                 uid_t *id)
@@ -600,7 +609,7 @@ idmap_name_to_id(struct svc_rqst *rqstp, int type, const char *name, u32 namelen
                 return -EINVAL;
         memcpy(key.name, name, namelen);
         key.name[namelen] = '\0';
-        strlcpy(key.authname, rqstp->rq_client->name, sizeof(key.authname));
+        strlcpy(key.authname, rqst_authname(rqstp), sizeof(key.authname));
         ret = idmap_lookup(rqstp, nametoid_lookup, &key, &nametoid_cache, &item);
         if (ret == -ENOENT)
                 ret = -ESRCH; /* nfserr_badname */
@@ -620,7 +629,7 @@ idmap_id_to_name(struct svc_rqst *rqstp, int type, uid_t id, char *name)
         };
         int ret;
 
-        strlcpy(key.authname, rqstp->rq_client->name, sizeof(key.authname));
+        strlcpy(key.authname, rqst_authname(rqstp), sizeof(key.authname));
         ret = idmap_lookup(rqstp, idtoname_lookup, &key, &idtoname_cache, &item);
         if (ret == -ENOENT)
                 return sprintf(name, "%u", id);
diff --git a/fs/nfsd/nfs4proc.c b/fs/nfsd/nfs4proc.c
index 8522729830db..3c627128e205 100644
--- a/fs/nfsd/nfs4proc.c
+++ b/fs/nfsd/nfs4proc.c
@@ -47,6 +47,7 @@
 #include <linux/nfsd/state.h>
 #include <linux/nfsd/xdr4.h>
 #include <linux/nfs4_acl.h>
+#include <linux/sunrpc/gss_api.h>
 
 #define NFSDDBG_FACILITY                NFSDDBG_PROC
 
@@ -286,8 +287,7 @@ nfsd4_putrootfh(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
         __be32 status;
 
         fh_put(&cstate->current_fh);
-        status = exp_pseudoroot(rqstp->rq_client, &cstate->current_fh,
-                              &rqstp->rq_chandle);
+        status = exp_pseudoroot(rqstp, &cstate->current_fh);
         return status;
 }
 
@@ -474,8 +474,8 @@ nfsd4_lookupp(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
         __be32 ret;
 
         fh_init(&tmp_fh, NFS4_FHSIZE);
-        if((ret = exp_pseudoroot(rqstp->rq_client, &tmp_fh,
-                              &rqstp->rq_chandle)) != 0)
+        ret = exp_pseudoroot(rqstp, &tmp_fh);
+        if (ret)
                 return ret;
         if (tmp_fh.fh_dentry == cstate->current_fh.fh_dentry) {
                 fh_put(&tmp_fh);
@@ -611,6 +611,30 @@ nfsd4_rename(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
 }
 
 static __be32
+nfsd4_secinfo(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
+              struct nfsd4_secinfo *secinfo)
+{
+        struct svc_fh resfh;
+        struct svc_export *exp;
+        struct dentry *dentry;
+        __be32 err;
+
+        fh_init(&resfh, NFS4_FHSIZE);
+        err = nfsd_lookup_dentry(rqstp, &cstate->current_fh,
+                                    secinfo->si_name, secinfo->si_namelen,
+                                    &exp, &dentry);
+        if (err)
+                return err;
+        if (dentry->d_inode == NULL) {
+                exp_put(exp);
+                err = nfserr_noent;
+        } else
+                secinfo->si_exp = exp;
+        dput(dentry);
+        return err;
+}
+
+static __be32
 nfsd4_setattr(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
               struct nfsd4_setattr *setattr)
 {
@@ -1009,6 +1033,9 @@ static struct nfsd4_operation nfsd4_ops[OP_RELEASE_LOCKOWNER+1] = {
         [OP_SAVEFH] = {
                 .op_func = (nfsd4op_func)nfsd4_savefh,
         },
+        [OP_SECINFO] = {
+                .op_func = (nfsd4op_func)nfsd4_secinfo,
+        },
         [OP_SETATTR] = {
                 .op_func = (nfsd4op_func)nfsd4_setattr,
         },
diff --git a/fs/nfsd/nfs4state.c b/fs/nfsd/nfs4state.c
index 8c52913d7cb6..e4a4c87ec8c6 100644
--- a/fs/nfsd/nfs4state.c
+++ b/fs/nfsd/nfs4state.c
@@ -49,8 +49,10 @@
 #include <linux/nfsd/state.h>
 #include <linux/nfsd/xdr4.h>
 #include <linux/namei.h>
+#include <linux/swap.h>
 #include <linux/mutex.h>
 #include <linux/lockd/bind.h>
+#include <linux/module.h>
 
 #define NFSDDBG_FACILITY                NFSDDBG_PROC
 
@@ -149,6 +151,7 @@ get_nfs4_file(struct nfs4_file *fi)
 }
 
 static int num_delegations;
+unsigned int max_delegations;
 
 /*
  * Open owner state (share locks)
@@ -192,7 +195,9 @@ alloc_init_deleg(struct nfs4_client *clp, struct nfs4_stateid *stp, struct svc_f
         struct nfs4_callback *cb = &stp->st_stateowner->so_client->cl_callback;
 
         dprintk("NFSD alloc_init_deleg\n");
-        if (num_delegations > STATEID_HASH_SIZE * 4)
+        if (fp->fi_had_conflict)
+                return NULL;
+        if (num_delegations > max_delegations)
                 return NULL;
         dp = kmem_cache_alloc(deleg_slab, GFP_KERNEL);
         if (dp == NULL)
@@ -999,6 +1004,7 @@ alloc_init_file(struct inode *ino)
                 list_add(&fp->fi_hash, &file_hashtbl[hashval]);
                 fp->fi_inode = igrab(ino);
                 fp->fi_id = current_fileid++;
+                fp->fi_had_conflict = false;
                 return fp;
         }
         return NULL;
@@ -1325,6 +1331,7 @@ do_recall(void *__dp)
 {
         struct nfs4_delegation *dp = __dp;
 
+        dp->dl_file->fi_had_conflict = true;
         nfsd4_cb_recall(dp);
         return 0;
 }
@@ -3190,20 +3197,49 @@ nfsd4_load_reboot_recovery_data(void)
                 printk("NFSD: Failure reading reboot recovery data\n");
 }
 
+unsigned long
+get_nfs4_grace_period(void)
+{
+        return max(user_lease_time, lease_time) * HZ;
+}
+
+/*
+ * Since the lifetime of a delegation isn't limited to that of an open, a
+ * client may quite reasonably hang on to a delegation as long as it has
+ * the inode cached.  This becomes an obvious problem the first time a
+ * client's inode cache approaches the size of the server's total memory.
+ *
+ * For now we avoid this problem by imposing a hard limit on the number
+ * of delegations, which varies according to the server's memory size.
+ */
+static void
+set_max_delegations(void)
+{
+        /*
+         * Allow at most 4 delegations per megabyte of RAM.  Quick
+         * estimates suggest that in the worst case (where every delegation
+         * is for a different inode), a delegation could take about 1.5K,
+         * giving a worst case usage of about 6% of memory.
+         */
+        max_delegations = nr_free_buffer_pages() >> (20 - 2 - PAGE_SHIFT);
+}
+
 /* initialization to perform when the nfsd service is started: */
 
 static void
 __nfs4_state_start(void)
 {
-        time_t grace_time;
+        unsigned long grace_time;
 
         boot_time = get_seconds();
-        grace_time = max(user_lease_time, lease_time);
+        grace_time = get_nfs_grace_period();
         lease_time = user_lease_time;
         in_grace = 1;
-        printk("NFSD: starting %ld-second grace period\n", grace_time);
+        printk(KERN_INFO "NFSD: starting %ld-second grace period\n",
+               grace_time/HZ);
         laundry_wq = create_singlethread_workqueue("nfsd4");
-        queue_delayed_work(laundry_wq, &laundromat_work, grace_time*HZ);
+        queue_delayed_work(laundry_wq, &laundromat_work, grace_time);
+        set_max_delegations();
 }
 
 int
diff --git a/fs/nfsd/nfs4xdr.c b/fs/nfsd/nfs4xdr.c
index 15809dfd88a5..b3d55c6747fd 100644
--- a/fs/nfsd/nfs4xdr.c
+++ b/fs/nfsd/nfs4xdr.c
@@ -56,6 +56,8 @@
 #include <linux/nfsd_idmap.h>
 #include <linux/nfs4.h>
 #include <linux/nfs4_acl.h>
+#include <linux/sunrpc/gss_api.h>
+#include <linux/sunrpc/svcauth_gss.h>
 
 #define NFSDDBG_FACILITY                NFSDDBG_XDR
 
@@ -819,6 +821,23 @@ nfsd4_decode_renew(struct nfsd4_compoundargs *argp, clientid_t *clientid)
 }
 
 static __be32
+nfsd4_decode_secinfo(struct nfsd4_compoundargs *argp,
+                     struct nfsd4_secinfo *secinfo)
+{
+        DECODE_HEAD;
+
+        READ_BUF(4);
+        READ32(secinfo->si_namelen);
+        READ_BUF(secinfo->si_namelen);
+        SAVEMEM(secinfo->si_name, secinfo->si_namelen);
+        status = check_filename(secinfo->si_name, secinfo->si_namelen,
+                                                                nfserr_noent);
+        if (status)
+                return status;
+        DECODE_TAIL;
+}
+
+static __be32
 nfsd4_decode_setattr(struct nfsd4_compoundargs *argp, struct nfsd4_setattr *setattr)
 {
         DECODE_HEAD;
@@ -1131,6 +1150,9 @@ nfsd4_decode_compound(struct nfsd4_compoundargs *argp)
                 case OP_SAVEFH:
                         op->status = nfs_ok;
                         break;
+                case OP_SECINFO:
+                        op->status = nfsd4_decode_secinfo(argp, &op->u.secinfo);
+                        break;
                 case OP_SETATTR:
                         op->status = nfsd4_decode_setattr(argp, &op->u.setattr);
                         break;
@@ -1296,7 +1318,7 @@ static char *nfsd4_path(struct svc_rqst *rqstp, struct svc_export *exp, __be32 *
         char *path, *rootpath;
 
         fh_init(&tmp_fh, NFS4_FHSIZE);
-        *stat = exp_pseudoroot(rqstp->rq_client, &tmp_fh, &rqstp->rq_chandle);
+        *stat = exp_pseudoroot(rqstp, &tmp_fh);
         if (*stat)
                 return NULL;
         rootpath = tmp_fh.fh_export->ex_path;
@@ -1847,11 +1869,19 @@ nfsd4_encode_dirent_fattr(struct nfsd4_readdir *cd,
         if (d_mountpoint(dentry)) {
                 int err;
 
+                /*
+                 * Why the heck aren't we just using nfsd_lookup??
+                 * Different "."/".." handling?  Something else?
+                 * At least, add a comment here to explain....
+                 */
                 err = nfsd_cross_mnt(cd->rd_rqstp, &dentry, &exp);
                 if (err) {
                         nfserr = nfserrno(err);
                         goto out_put;
                 }
+                nfserr = check_nfsd_access(exp, cd->rd_rqstp);
+                if (nfserr)
+                        goto out_put;
 
         }
         nfserr = nfsd4_encode_fattr(NULL, exp, dentry, p, buflen, cd->rd_bmval,
@@ -2419,6 +2449,72 @@ nfsd4_encode_rename(struct nfsd4_compoundres *resp, __be32 nfserr, struct nfsd4_
         }
 }
 
+static void
+nfsd4_encode_secinfo(struct nfsd4_compoundres *resp, int nfserr,
+                     struct nfsd4_secinfo *secinfo)
+{
+        int i = 0;
+        struct svc_export *exp = secinfo->si_exp;
+        u32 nflavs;
+        struct exp_flavor_info *flavs;
+        struct exp_flavor_info def_flavs[2];
+        ENCODE_HEAD;
+
+        if (nfserr)
+                goto out;
+        if (exp->ex_nflavors) {
+                flavs = exp->ex_flavors;
+                nflavs = exp->ex_nflavors;
+        } else { /* Handling of some defaults in absence of real secinfo: */
+                flavs = def_flavs;
+                if (exp->ex_client->flavour->flavour == RPC_AUTH_UNIX) {
+                        nflavs = 2;
+                        flavs[0].pseudoflavor = RPC_AUTH_UNIX;
+                        flavs[1].pseudoflavor = RPC_AUTH_NULL;
+                } else if (exp->ex_client->flavour->flavour == RPC_AUTH_GSS) {
+                        nflavs = 1;
+                        flavs[0].pseudoflavor
+                                        = svcauth_gss_flavor(exp->ex_client);
+                } else {
+                        nflavs = 1;
+                        flavs[0].pseudoflavor
+                                        = exp->ex_client->flavour->flavour;
+                }
+        }
+
+        RESERVE_SPACE(4);
+        WRITE32(nflavs);
+        ADJUST_ARGS();
+        for (i = 0; i < nflavs; i++) {
+                u32 flav = flavs[i].pseudoflavor;
+                struct gss_api_mech *gm = gss_mech_get_by_pseudoflavor(flav);
+
+                if (gm) {
+                        RESERVE_SPACE(4);
+                        WRITE32(RPC_AUTH_GSS);
+                        ADJUST_ARGS();
+                        RESERVE_SPACE(4 + gm->gm_oid.len);
+                        WRITE32(gm->gm_oid.len);
+                        WRITEMEM(gm->gm_oid.data, gm->gm_oid.len);
+                        ADJUST_ARGS();
+                        RESERVE_SPACE(4);
+                        WRITE32(0); /* qop */
+                        ADJUST_ARGS();
+                        RESERVE_SPACE(4);
+                        WRITE32(gss_pseudoflavor_to_service(gm, flav));
+                        ADJUST_ARGS();
+                        gss_mech_put(gm);
+                } else {
+                        RESERVE_SPACE(4);
+                        WRITE32(flav);
+                        ADJUST_ARGS();
+                }
+        }
+out:
+        if (exp)
+                exp_put(exp);
+}
+
 /*
  * The SETATTR encode routine is special -- it always encodes a bitmap,
  * regardless of the error status.
@@ -2559,6 +2655,9 @@ nfsd4_encode_operation(struct nfsd4_compoundres *resp, struct nfsd4_op *op)
                 break;
         case OP_SAVEFH:
                 break;
+        case OP_SECINFO:
+                nfsd4_encode_secinfo(resp, op->status, &op->u.secinfo);
+                break;
         case OP_SETATTR:
                 nfsd4_encode_setattr(resp, op->status, &op->u.setattr);
                 break;
diff --git a/fs/nfsd/nfsctl.c b/fs/nfsd/nfsctl.c
index 71c686dc7257..baac89d917ca 100644
--- a/fs/nfsd/nfsctl.c
+++ b/fs/nfsd/nfsctl.c
@@ -35,7 +35,6 @@
 #include <linux/nfsd/cache.h>
 #include <linux/nfsd/xdr.h>
 #include <linux/nfsd/syscall.h>
-#include <linux/nfsd/interface.h>
 
 #include <asm/uaccess.h>
 
@@ -245,7 +244,7 @@ static ssize_t write_getfs(struct file *file, char *buf, size_t size)
         }
         exp_readunlock();
         if (err == 0)
-                err = res->fh_size + (int)&((struct knfsd_fh*)0)->fh_base;
+                err = res->fh_size + offsetof(struct knfsd_fh, fh_base);
  out:
         return err;
 }
diff --git a/fs/nfsd/nfsfh.c b/fs/nfsd/nfsfh.c
index 6ca2d24fc216..0eb464a39aae 100644
--- a/fs/nfsd/nfsfh.c
+++ b/fs/nfsd/nfsfh.c
@@ -15,10 +15,12 @@
 #include <linux/string.h>
 #include <linux/stat.h>
 #include <linux/dcache.h>
+#include <linux/exportfs.h>
 #include <linux/mount.h>
 
 #include <linux/sunrpc/clnt.h>
 #include <linux/sunrpc/svc.h>
+#include <linux/sunrpc/svcauth_gss.h>
 #include <linux/nfsd/nfsd.h>
 
 #define NFSDDBG_FACILITY                NFSDDBG_FH
@@ -27,10 +29,6 @@
 static int nfsd_nr_verified;
 static int nfsd_nr_put;
 
-extern struct export_operations export_op_default;
-
-#define CALL(ops,fun) ((ops->fun)?(ops->fun):export_op_default.fun)
-
 /*
  * our acceptability function.
  * if NOSUBTREECHECK, accept anything
@@ -123,8 +121,6 @@ fh_verify(struct svc_rqst *rqstp, struct svc_fh *fhp, int type, int access)
                 int data_left = fh->fh_size/4;
 
                 error = nfserr_stale;
-                if (rqstp->rq_client == NULL)
-                        goto out;
                 if (rqstp->rq_vers > 2)
                         error = nfserr_badhandle;
                 if (rqstp->rq_vers == 4 && fh->fh_size == 0)
@@ -148,7 +144,7 @@ fh_verify(struct svc_rqst *rqstp, struct svc_fh *fhp, int type, int access)
                                 fh->fh_fsid[1] = fh->fh_fsid[2];
                         }
                         if ((data_left -= len)<0) goto out;
-                        exp = exp_find(rqstp->rq_client, fh->fh_fsid_type, datap, &rqstp->rq_chandle);
+                        exp = rqst_exp_find(rqstp, fh->fh_fsid_type, datap);
                         datap += len;
                 } else {
                         dev_t xdev;
@@ -159,19 +155,17 @@ fh_verify(struct svc_rqst *rqstp, struct svc_fh *fhp, int type, int access)
                         xdev = old_decode_dev(fh->ofh_xdev);
                         xino = u32_to_ino_t(fh->ofh_xino);
                         mk_fsid(FSID_DEV, tfh, xdev, xino, 0, NULL);
-                        exp = exp_find(rqstp->rq_client, FSID_DEV, tfh,
-                                       &rqstp->rq_chandle);
+                        exp = rqst_exp_find(rqstp, FSID_DEV, tfh);
                 }
 
-                if (IS_ERR(exp) && (PTR_ERR(exp) == -EAGAIN
-                                || PTR_ERR(exp) == -ETIMEDOUT)) {
-                        error = nfserrno(PTR_ERR(exp));
+                error = nfserr_stale;
+                if (PTR_ERR(exp) == -ENOENT)
                         goto out;
-                }
 
-                error = nfserr_stale; 
-                if (!exp || IS_ERR(exp))
+                if (IS_ERR(exp)) {
+                        error = nfserrno(PTR_ERR(exp));
                         goto out;
+                }
 
                 /* Check if the request originated from a secure port. */
                 error = nfserr_perm;
@@ -211,11 +205,9 @@ fh_verify(struct svc_rqst *rqstp, struct svc_fh *fhp, int type, int access)
                 if (fileid_type == 0)
                         dentry = dget(exp->ex_dentry);
                 else {
-                        struct export_operations *nop = exp->ex_mnt->mnt_sb->s_export_op;
-                        dentry = CALL(nop,decode_fh)(exp->ex_mnt->mnt_sb,
-                                                     datap, data_left,
-                                                     fileid_type,
-                                                     nfsd_acceptable, exp);
+                        dentry = exportfs_decode_fh(exp->ex_mnt, datap,
+                                        data_left, fileid_type,
+                                        nfsd_acceptable, exp);
                 }
                 if (dentry == NULL)
                         goto out;
@@ -257,8 +249,19 @@ fh_verify(struct svc_rqst *rqstp, struct svc_fh *fhp, int type, int access)
         if (error)
                 goto out;
 
+        if (!(access & MAY_LOCK)) {
+                /*
+                 * pseudoflavor restrictions are not enforced on NLM,
+                 * which clients virtually always use auth_sys for,
+                 * even while using RPCSEC_GSS for NFS.
+                 */
+                error = check_nfsd_access(exp, rqstp);
+                if (error)
+                        goto out;
+        }
+
         /* Finally, check access permissions. */
-        error = nfsd_permission(exp, dentry, access);
+        error = nfsd_permission(rqstp, exp, dentry, access);
 
         if (error) {
                 dprintk("fh_verify: %s/%s permission failure, "
@@ -286,15 +289,13 @@ out:
 static inline int _fh_update(struct dentry *dentry, struct svc_export *exp,
                              __u32 *datap, int *maxsize)
 {
-        struct export_operations *nop = exp->ex_mnt->mnt_sb->s_export_op;
-
         if (dentry == exp->ex_dentry) {
                 *maxsize = 0;
                 return 0;
         }
 
-        return CALL(nop,encode_fh)(dentry, datap, maxsize,
-                          !(exp->ex_flags&NFSEXP_NOSUBTREECHECK));
+        return exportfs_encode_fh(dentry, datap, maxsize,
+                          !(exp->ex_flags & NFSEXP_NOSUBTREECHECK));
 }
 
 /*
diff --git a/fs/nfsd/nfsproc.c b/fs/nfsd/nfsproc.c
index b2c7147aa921..977a71f64e19 100644
--- a/fs/nfsd/nfsproc.c
+++ b/fs/nfsd/nfsproc.c
@@ -278,7 +278,8 @@ nfsd_proc_create(struct svc_rqst *rqstp, struct nfsd_createargs *argp,
                                          *   echo thing > device-special-file-or-pipe
                                          * by doing a CREATE with type==0
                                          */
-                                        nfserr = nfsd_permission(newfhp->fh_export,
+                                        nfserr = nfsd_permission(rqstp,
+                                                                 newfhp->fh_export,
                                                                  newfhp->fh_dentry,
                                                                  MAY_WRITE|MAY_LOCAL_ACCESS);
                                         if (nfserr && nfserr != nfserr_rofs)
diff --git a/fs/nfsd/nfssvc.c b/fs/nfsd/nfssvc.c
index ff55950efb43..a8c89ae4c743 100644
--- a/fs/nfsd/nfssvc.c
+++ b/fs/nfsd/nfssvc.c
@@ -19,6 +19,7 @@
 #include <linux/slab.h>
 #include <linux/smp.h>
 #include <linux/smp_lock.h>
+#include <linux/freezer.h>
 #include <linux/fs_struct.h>
 
 #include <linux/sunrpc/types.h>
@@ -432,6 +433,7 @@ nfsd(struct svc_rqst *rqstp)
          * dirty pages.
          */
         current->flags |= PF_LESS_THROTTLE;
+        set_freezable();
 
         /*
          * The main request loop
@@ -492,6 +494,15 @@ out:
         module_put_and_exit(0);
 }
 
+static __be32 map_new_errors(u32 vers, __be32 nfserr)
+{
+        if (nfserr == nfserr_jukebox && vers == 2)
+                return nfserr_dropit;
+        if (nfserr == nfserr_wrongsec && vers < 4)
+                return nfserr_acces;
+        return nfserr;
+}
+
 int
 nfsd_dispatch(struct svc_rqst *rqstp, __be32 *statp)
 {
@@ -534,6 +545,7 @@ nfsd_dispatch(struct svc_rqst *rqstp, __be32 *statp)
 
         /* Now call the procedure handler, and encode NFS status. */
         nfserr = proc->pc_func(rqstp, rqstp->rq_argp, rqstp->rq_resp);
+        nfserr = map_new_errors(rqstp->rq_vers, nfserr);
         if (nfserr == nfserr_jukebox && rqstp->rq_vers == 2)
                 nfserr = nfserr_dropit;
         if (nfserr == nfserr_dropit) {
diff --git a/fs/nfsd/vfs.c b/fs/nfsd/vfs.c
index 945b1cedde2b..e90f4a8a1d01 100644
--- a/fs/nfsd/vfs.c
+++ b/fs/nfsd/vfs.c
@@ -113,7 +113,7 @@ nfsd_cross_mnt(struct svc_rqst *rqstp, struct dentry **dpp,
 
         while (follow_down(&mnt,&mounts)&&d_mountpoint(mounts));
 
-        exp2 = exp_get_by_name(exp->ex_client, mnt, mounts, &rqstp->rq_chandle);
+        exp2 = rqst_exp_get_by_name(rqstp, mnt, mounts);
         if (IS_ERR(exp2)) {
                 err = PTR_ERR(exp2);
                 dput(mounts);
@@ -135,21 +135,10 @@ out:
         return err;
 }
 
-/*
- * Look up one component of a pathname.
- * N.B. After this call _both_ fhp and resfh need an fh_put
- *
- * If the lookup would cross a mountpoint, and the mounted filesystem
- * is exported to the client with NFSEXP_NOHIDE, then the lookup is
- * accepted as it stands and the mounted directory is
- * returned. Otherwise the covered directory is returned.
- * NOTE: this mountpoint crossing is not supported properly by all
- *   clients and is explicitly disallowed for NFSv3
- *      NeilBrown <neilb@cse.unsw.edu.au>
- */
 __be32
-nfsd_lookup(struct svc_rqst *rqstp, struct svc_fh *fhp, const char *name,
-                                        int len, struct svc_fh *resfh)
+nfsd_lookup_dentry(struct svc_rqst *rqstp, struct svc_fh *fhp,
+                   const char *name, int len,
+                   struct svc_export **exp_ret, struct dentry **dentry_ret)
 {
         struct svc_export       *exp;
         struct dentry           *dparent;
@@ -168,8 +157,6 @@ nfsd_lookup(struct svc_rqst *rqstp, struct svc_fh *fhp, const char *name,
         exp  = fhp->fh_export;
         exp_get(exp);
 
-        err = nfserr_acces;
-
         /* Lookup the name, but don't follow links */
         if (isdotent(name, len)) {
                 if (len==1)
@@ -190,17 +177,15 @@ nfsd_lookup(struct svc_rqst *rqstp, struct svc_fh *fhp, const char *name,
                         dput(dentry);
                         dentry = dp;
 
-                        exp2 = exp_parent(exp->ex_client, mnt, dentry,
-                                          &rqstp->rq_chandle);
-                        if (IS_ERR(exp2)) {
+                        exp2 = rqst_exp_parent(rqstp, mnt, dentry);
+                        if (PTR_ERR(exp2) == -ENOENT) {
+                                dput(dentry);
+                                dentry = dget(dparent);
+                        } else if (IS_ERR(exp2)) {
                                 host_err = PTR_ERR(exp2);
                                 dput(dentry);
                                 mntput(mnt);
                                 goto out_nfserr;
-                        }
-                        if (!exp2) {
-                                dput(dentry);
-                                dentry = dget(dparent);
                         } else {
                                 exp_put(exp);
                                 exp = exp2;
@@ -223,6 +208,41 @@ nfsd_lookup(struct svc_rqst *rqstp, struct svc_fh *fhp, const char *name,
                         }
                 }
         }
+        *dentry_ret = dentry;
+        *exp_ret = exp;
+        return 0;
+
+out_nfserr:
+        exp_put(exp);
+        return nfserrno(host_err);
+}
+
+/*
+ * Look up one component of a pathname.
+ * N.B. After this call _both_ fhp and resfh need an fh_put
+ *
+ * If the lookup would cross a mountpoint, and the mounted filesystem
+ * is exported to the client with NFSEXP_NOHIDE, then the lookup is
+ * accepted as it stands and the mounted directory is
+ * returned. Otherwise the covered directory is returned.
+ * NOTE: this mountpoint crossing is not supported properly by all
+ *   clients and is explicitly disallowed for NFSv3
+ *      NeilBrown <neilb@cse.unsw.edu.au>
+ */
+__be32
+nfsd_lookup(struct svc_rqst *rqstp, struct svc_fh *fhp, const char *name,
+                                        int len, struct svc_fh *resfh)
+{
+        struct svc_export       *exp;
+        struct dentry           *dentry;
+        __be32 err;
+
+        err = nfsd_lookup_dentry(rqstp, fhp, name, len, &exp, &dentry);
+        if (err)
+                return err;
+        err = check_nfsd_access(exp, rqstp);
+        if (err)
+                goto out;
         /*
          * Note: we compose the file handle now, but as the
          * dentry may be negative, it may need to be updated.
@@ -230,16 +250,13 @@ nfsd_lookup(struct svc_rqst *rqstp, struct svc_fh *fhp, const char *name,
         err = fh_compose(resfh, exp, dentry, fhp);
         if (!err && !dentry->d_inode)
                 err = nfserr_noent;
-        dput(dentry);
 out:
+        dput(dentry);
         exp_put(exp);
         return err;
-
-out_nfserr:
-        err = nfserrno(host_err);
-        goto out;
 }
 
+
 /*
  * Set various file attributes.
  * N.B. After this call fhp needs an fh_put
@@ -311,7 +328,7 @@ nfsd_setattr(struct svc_rqst *rqstp, struct svc_fh *fhp, struct iattr *iap,
         /* The size case is special. It changes the file as well as the attributes.  */
         if (iap->ia_valid & ATTR_SIZE) {
                 if (iap->ia_size < inode->i_size) {
-                        err = nfsd_permission(fhp->fh_export, dentry, MAY_TRUNC|MAY_OWNER_OVERRIDE);
+                        err = nfsd_permission(rqstp, fhp->fh_export, dentry, MAY_TRUNC|MAY_OWNER_OVERRIDE);
                         if (err)
                                 goto out;
                 }
@@ -435,7 +452,7 @@ nfsd4_set_nfs4_acl(struct svc_rqst *rqstp, struct svc_fh *fhp,
         /* Get inode */
         error = fh_verify(rqstp, fhp, 0 /* S_IFREG */, MAY_SATTR);
         if (error)
-                goto out;
+                return error;
 
         dentry = fhp->fh_dentry;
         inode = dentry->d_inode;
@@ -444,33 +461,25 @@ nfsd4_set_nfs4_acl(struct svc_rqst *rqstp, struct svc_fh *fhp,
 
         host_error = nfs4_acl_nfsv4_to_posix(acl, &pacl, &dpacl, flags);
         if (host_error == -EINVAL) {
-                error = nfserr_attrnotsupp;
-                goto out;
+                return nfserr_attrnotsupp;
         } else if (host_error < 0)
                 goto out_nfserr;
 
         host_error = set_nfsv4_acl_one(dentry, pacl, POSIX_ACL_XATTR_ACCESS);
         if (host_error < 0)
-                goto out_nfserr;
+                goto out_release;
 
-        if (S_ISDIR(inode->i_mode)) {
+        if (S_ISDIR(inode->i_mode))
                 host_error = set_nfsv4_acl_one(dentry, dpacl, POSIX_ACL_XATTR_DEFAULT);
-                if (host_error < 0)
-                        goto out_nfserr;
-        }
-
-        error = nfs_ok;
 
-out:
+out_release:
         posix_acl_release(pacl);
         posix_acl_release(dpacl);
-        return (error);
 out_nfserr:
         if (host_error == -EOPNOTSUPP)
-                error = nfserr_attrnotsupp;
+                return nfserr_attrnotsupp;
         else
-                error = nfserrno(host_error);
-        goto out;
+                return nfserrno(host_error);
 }
 
 static struct posix_acl *
@@ -607,7 +616,7 @@ nfsd_access(struct svc_rqst *rqstp, struct svc_fh *fhp, u32 *access, u32 *suppor
 
                         sresult |= map->access;
 
-                        err2 = nfsd_permission(export, dentry, map->how);
+                        err2 = nfsd_permission(rqstp, export, dentry, map->how);
                         switch (err2) {
                         case nfs_ok:
                                 result |= map->access;
@@ -1034,7 +1043,7 @@ nfsd_read(struct svc_rqst *rqstp, struct svc_fh *fhp, struct file *file,
         __be32          err;
 
         if (file) {
-                err = nfsd_permission(fhp->fh_export, fhp->fh_dentry,
+                err = nfsd_permission(rqstp, fhp->fh_export, fhp->fh_dentry,
                                 MAY_READ|MAY_OWNER_OVERRIDE);
                 if (err)
                         goto out;
@@ -1063,7 +1072,7 @@ nfsd_write(struct svc_rqst *rqstp, struct svc_fh *fhp, struct file *file,
         __be32                  err = 0;
 
         if (file) {
-                err = nfsd_permission(fhp->fh_export, fhp->fh_dentry,
+                err = nfsd_permission(rqstp, fhp->fh_export, fhp->fh_dentry,
                                 MAY_WRITE|MAY_OWNER_OVERRIDE);
                 if (err)
                         goto out;
@@ -1792,7 +1801,8 @@ nfsd_statfs(struct svc_rqst *rqstp, struct svc_fh *fhp, struct kstatfs *stat)
  * Check for a user's access permissions to this inode.
  */
 __be32
-nfsd_permission(struct svc_export *exp, struct dentry *dentry, int acc)
+nfsd_permission(struct svc_rqst *rqstp, struct svc_export *exp,
+                                        struct dentry *dentry, int acc)
 {
         struct inode    *inode = dentry->d_inode;
         int             err;
@@ -1823,7 +1833,7 @@ nfsd_permission(struct svc_export *exp, struct dentry *dentry, int acc)
          */
         if (!(acc & MAY_LOCAL_ACCESS))
                 if (acc & (MAY_WRITE | MAY_SATTR | MAY_TRUNC)) {
-                        if (EX_RDONLY(exp) || IS_RDONLY(inode))
+                        if (EX_RDONLY(exp, rqstp) || IS_RDONLY(inode))
                                 return nfserr_rofs;
                         if (/* (acc & MAY_WRITE) && */ IS_IMMUTABLE(inode))
                                 return nfserr_perm;
diff --git a/fs/ntfs/namei.c b/fs/ntfs/namei.c
index bff01a54675a..e93c6142b23c 100644
--- a/fs/ntfs/namei.c
+++ b/fs/ntfs/namei.c
@@ -21,6 +21,7 @@
  */
 
 #include <linux/dcache.h>
+#include <linux/exportfs.h>
 #include <linux/security.h>
 
 #include "attrib.h"
diff --git a/fs/ocfs2/export.h b/fs/ocfs2/export.h
index 5b77ee7866ef..e08bed9e45a0 100644
--- a/fs/ocfs2/export.h
+++ b/fs/ocfs2/export.h
@@ -26,6 +26,8 @@
 #ifndef OCFS2_EXPORT_H
 #define OCFS2_EXPORT_H
 
+#include <linux/exportfs.h>
+
 extern struct export_operations ocfs2_export_ops;
 
 #endif /* OCFS2_EXPORT_H */
diff --git a/fs/ocfs2/file.c b/fs/ocfs2/file.c
index f04c7aa834cb..004c2abbc732 100644
--- a/fs/ocfs2/file.c
+++ b/fs/ocfs2/file.c
@@ -1867,7 +1867,8 @@ static ssize_t ocfs2_file_buffered_write(struct file *file, loff_t *ppos,
         loff_t pos;
         const struct iovec *cur_iov = iov;
         struct page *user_page, *page;
-        char *buf, *dst;
+        char * uninitialized_var(buf);
+        char *dst;
         void *fsdata;
 
         /*
diff --git a/fs/ocfs2/ioctl.c b/fs/ocfs2/ioctl.c
index bd68c3f2afbe..87dcece7e1b5 100644
--- a/fs/ocfs2/ioctl.c
+++ b/fs/ocfs2/ioctl.c
@@ -63,7 +63,7 @@ static int ocfs2_set_inode_attr(struct inode *inode, unsigned flags,
                 goto bail_unlock;
 
         status = -EACCES;
-        if ((current->fsuid != inode->i_uid) && !capable(CAP_FOWNER))
+        if (!is_owner_or_cap(inode))
                 goto bail_unlock;
 
         if (!S_ISDIR(inode->i_mode))
diff --git a/fs/proc/base.c b/fs/proc/base.c
index ae3627337a92..42cb4f5613b6 100644
--- a/fs/proc/base.c
+++ b/fs/proc/base.c
@@ -283,7 +283,7 @@ static int proc_pid_auxv(struct task_struct *task, char *buffer)
 static int proc_pid_wchan(struct task_struct *task, char *buffer)
 {
         unsigned long wchan;
-        char symname[KSYM_NAME_LEN+1];
+        char symname[KSYM_NAME_LEN];
 
         wchan = get_wchan(task);
 
diff --git a/fs/ramfs/inode.c b/fs/ramfs/inode.c
index d40d22b347b7..ef2b46d099ff 100644
--- a/fs/ramfs/inode.c
+++ b/fs/ramfs/inode.c
@@ -60,6 +60,7 @@ struct inode *ramfs_get_inode(struct super_block *sb, int mode, dev_t dev)
                 inode->i_blocks = 0;
                 inode->i_mapping->a_ops = &ramfs_aops;
                 inode->i_mapping->backing_dev_info = &ramfs_backing_dev_info;
+                mapping_set_gfp_mask(inode->i_mapping, GFP_HIGHUSER);
                 inode->i_atime = inode->i_mtime = inode->i_ctime = CURRENT_TIME;
                 switch (mode & S_IFMT) {
                 default:
diff --git a/fs/reiserfs/inode.c b/fs/reiserfs/inode.c
index 1272d11399fb..ddde489f1cb2 100644
--- a/fs/reiserfs/inode.c
+++ b/fs/reiserfs/inode.c
@@ -7,6 +7,7 @@
 #include <linux/reiserfs_fs.h>
 #include <linux/reiserfs_acl.h>
 #include <linux/reiserfs_xattr.h>
+#include <linux/exportfs.h>
 #include <linux/smp_lock.h>
 #include <linux/pagemap.h>
 #include <linux/highmem.h>
diff --git a/fs/reiserfs/ioctl.c b/fs/reiserfs/ioctl.c
index b484d2913c0d..11a0fcc2d402 100644
--- a/fs/reiserfs/ioctl.c
+++ b/fs/reiserfs/ioctl.c
@@ -51,8 +51,7 @@ int reiserfs_ioctl(struct inode *inode, struct file *filp, unsigned int cmd,
                         if (IS_RDONLY(inode))
                                 return -EROFS;
 
-                        if ((current->fsuid != inode->i_uid)
-                            && !capable(CAP_FOWNER))
+                        if (!is_owner_or_cap(inode))
                                 return -EPERM;
 
                         if (get_user(flags, (int __user *)arg))
@@ -81,7 +80,7 @@ int reiserfs_ioctl(struct inode *inode, struct file *filp, unsigned int cmd,
         case REISERFS_IOC_GETVERSION:
                 return put_user(inode->i_generation, (int __user *)arg);
         case REISERFS_IOC_SETVERSION:
-                if ((current->fsuid != inode->i_uid) && !capable(CAP_FOWNER))
+                if (!is_owner_or_cap(inode))
                         return -EPERM;
                 if (IS_RDONLY(inode))
                         return -EROFS;
diff --git a/fs/reiserfs/super.c b/fs/reiserfs/super.c
index b4ac9119200e..5a93cfe1a032 100644
--- a/fs/reiserfs/super.c
+++ b/fs/reiserfs/super.c
@@ -21,6 +21,7 @@
 #include <linux/init.h>
 #include <linux/blkdev.h>
 #include <linux/buffer_head.h>
+#include <linux/exportfs.h>
 #include <linux/vfs.h>
 #include <linux/mnt_namespace.h>
 #include <linux/mount.h>
diff --git a/fs/reiserfs/xattr_acl.c b/fs/reiserfs/xattr_acl.c
index 5296a29cc5eb..b7e4fa4539de 100644
--- a/fs/reiserfs/xattr_acl.c
+++ b/fs/reiserfs/xattr_acl.c
@@ -21,7 +21,7 @@ xattr_set_acl(struct inode *inode, int type, const void *value, size_t size)
 
         if (!reiserfs_posixacl(inode->i_sb))
                 return -EOPNOTSUPP;
-        if ((current->fsuid != inode->i_uid) && !capable(CAP_FOWNER))
+        if (!is_owner_or_cap(inode))
                 return -EPERM;
 
         if (value) {
diff --git a/fs/udf/super.c b/fs/udf/super.c
index 6658afb41cc7..d6a504f5d758 100644
--- a/fs/udf/super.c
+++ b/fs/udf/super.c
@@ -1356,7 +1356,7 @@ udf_load_partition(struct super_block *sb, kernel_lb_addr *fileset)
                         case UDF_VIRTUAL_MAP15:
                         case UDF_VIRTUAL_MAP20:
                         {
-                                kernel_lb_addr ino;
+                                kernel_lb_addr uninitialized_var(ino);
 
                                 if (!UDF_SB_LASTBLOCK(sb))
                                 {
diff --git a/fs/utimes.c b/fs/utimes.c
index 83a7e69e706c..682eb63b20ad 100644
--- a/fs/utimes.c
+++ b/fs/utimes.c
@@ -106,7 +106,7 @@ long do_utimes(int dfd, char __user *filename, struct timespec *times, int flags
                 if (IS_IMMUTABLE(inode))
                         goto dput_and_out;
 
-                if ((current->fsuid != inode->i_uid) && !capable(CAP_FOWNER)) {
+                if (!is_owner_or_cap(inode)) {
                         if (f) {
                                 if (!(f->f_mode & FMODE_WRITE))
                                         goto dput_and_out;
diff --git a/fs/xattr.c b/fs/xattr.c
index 4523aca79659..a44fd92caca3 100644
--- a/fs/xattr.c
+++ b/fs/xattr.c
@@ -60,8 +60,7 @@ xattr_permission(struct inode *inode, const char *name, int mask)
                 if (!S_ISREG(inode->i_mode) && !S_ISDIR(inode->i_mode))
                         return -EPERM;
                 if (S_ISDIR(inode->i_mode) && (inode->i_mode & S_ISVTX) &&
-                    (mask & MAY_WRITE) && (current->fsuid != inode->i_uid) &&
-                    !capable(CAP_FOWNER))
+                    (mask & MAY_WRITE) && !is_owner_or_cap(inode))
                         return -EPERM;
         }
 
diff --git a/fs/xfs/linux-2.6/xfs_buf.c b/fs/xfs/linux-2.6/xfs_buf.c
index 2df63622354e..b0f0e58866de 100644
--- a/fs/xfs/linux-2.6/xfs_buf.c
+++ b/fs/xfs/linux-2.6/xfs_buf.c
@@ -35,10 +35,13 @@
 #include <linux/freezer.h>
 
 static kmem_zone_t *xfs_buf_zone;
-static struct shrinker *xfs_buf_shake;
 STATIC int xfsbufd(void *);
 STATIC int xfsbufd_wakeup(int, gfp_t);
 STATIC void xfs_buf_delwri_queue(xfs_buf_t *, int);
+static struct shrinker xfs_buf_shake = {
+        .shrink = xfsbufd_wakeup,
+        .seeks = DEFAULT_SEEKS,
+};
 
 static struct workqueue_struct *xfslogd_workqueue;
 struct workqueue_struct *xfsdatad_workqueue;
@@ -1832,14 +1835,9 @@ xfs_buf_init(void)
         if (!xfsdatad_workqueue)
                 goto out_destroy_xfslogd_workqueue;
 
-        xfs_buf_shake = set_shrinker(DEFAULT_SEEKS, xfsbufd_wakeup);
-        if (!xfs_buf_shake)
-                goto out_destroy_xfsdatad_workqueue;
-
+        register_shrinker(&xfs_buf_shake);
         return 0;
 
- out_destroy_xfsdatad_workqueue:
-        destroy_workqueue(xfsdatad_workqueue);
  out_destroy_xfslogd_workqueue:
         destroy_workqueue(xfslogd_workqueue);
  out_free_buf_zone:
@@ -1854,7 +1852,7 @@ xfs_buf_init(void)
 void
 xfs_buf_terminate(void)
 {
-        remove_shrinker(xfs_buf_shake);
+        unregister_shrinker(&xfs_buf_shake);
         destroy_workqueue(xfsdatad_workqueue);
         destroy_workqueue(xfslogd_workqueue);
         kmem_zone_destroy(xfs_buf_zone);
diff --git a/fs/xfs/linux-2.6/xfs_super.c b/fs/xfs/linux-2.6/xfs_super.c
index 06894cf00b12..4528f9a3f304 100644
--- a/fs/xfs/linux-2.6/xfs_super.c
+++ b/fs/xfs/linux-2.6/xfs_super.c
@@ -562,6 +562,7 @@ xfssyncd(
         bhv_vfs_sync_work_t     *work, *n;
         LIST_HEAD               (tmp);
 
+        set_freezable();
         timeleft = xfs_syncd_centisecs * msecs_to_jiffies(10);
         for (;;) {
                 timeleft = schedule_timeout_interruptible(timeleft);
diff --git a/fs/xfs/linux-2.6/xfs_super.h b/fs/xfs/linux-2.6/xfs_super.h
index 33dd1ca13245..201cc3273c84 100644
--- a/fs/xfs/linux-2.6/xfs_super.h
+++ b/fs/xfs/linux-2.6/xfs_super.h
@@ -18,6 +18,8 @@
 #ifndef __XFS_SUPER_H__
 #define __XFS_SUPER_H__
 
+#include <linux/exportfs.h>
+
 #ifdef CONFIG_XFS_DMAPI
 # define vfs_insertdmapi(vfs)   vfs_insertops(vfsp, &xfs_dmops)
 # define vfs_initdmapi()        dmapi_init()
diff --git a/fs/xfs/quota/xfs_qm.c b/fs/xfs/quota/xfs_qm.c
index 7def4c699343..2d274b23ade5 100644
--- a/fs/xfs/quota/xfs_qm.c
+++ b/fs/xfs/quota/xfs_qm.c
@@ -62,7 +62,6 @@ uint		ndquot;
 
 kmem_zone_t     *qm_dqzone;
 kmem_zone_t     *qm_dqtrxzone;
-static struct shrinker *xfs_qm_shaker;
 
 static cred_t   xfs_zerocr;
 
@@ -78,6 +77,11 @@ STATIC int	xfs_qm_init_quotainos(xfs_mount_t *);
 STATIC int      xfs_qm_init_quotainfo(xfs_mount_t *);
 STATIC int      xfs_qm_shake(int, gfp_t);
 
+static struct shrinker xfs_qm_shaker = {
+        .shrink = xfs_qm_shake,
+        .seeks = DEFAULT_SEEKS,
+};
+
 #ifdef DEBUG
 extern mutex_t  qcheck_lock;
 #endif
@@ -149,7 +153,7 @@ xfs_Gqm_init(void)
         } else
                 xqm->qm_dqzone = qm_dqzone;
 
-        xfs_qm_shaker = set_shrinker(DEFAULT_SEEKS, xfs_qm_shake);
+        register_shrinker(&xfs_qm_shaker);
 
         /*
          * The t_dqinfo portion of transactions.
@@ -181,7 +185,7 @@ xfs_qm_destroy(
 
         ASSERT(xqm != NULL);
         ASSERT(xqm->qm_nrefs == 0);
-        remove_shrinker(xfs_qm_shaker);
+        unregister_shrinker(&xfs_qm_shaker);
         hsize = xqm->qm_dqhashmask + 1;
         for (i = 0; i < hsize; i++) {
                 xfs_qm_list_destroy(&(xqm->qm_usr_dqhtable[i]));