150 files changed, 1655 insertions, 1762 deletions
diff --git a/fs/Kconfig b/fs/Kconfig
index a42f767dcdd5..8ea7b04c661f 100644
--- a/fs/Kconfig
+++ b/fs/Kconfig
@@ -1734,6 +1734,18 @@ config SUNRPC
 config SUNRPC_GSS
        tristate
+config SUNRPC_BIND34
+        bool "Support for rpcbind versions 3 & 4 (EXPERIMENTAL)"
+        depends on SUNRPC && EXPERIMENTAL
+        help
+          Provides kernel support for querying rpcbind servers via versions 3
+          and 4 of the rpcbind protocol.  The kernel automatically falls back
+          to version 2 if a remote rpcbind service does not support versions
+          3 or 4.
+          If unsure, say N to get traditional behavior (version 2 rpcbind
+          requests only).
 config RPCSEC_GSS_KRB5
        tristate "Secure RPC: Kerberos V mechanism (EXPERIMENTAL)"
        depends on SUNRPC && EXPERIMENTAL
@@ -2020,7 +2032,6 @@ config AFS_FS
        tristate "Andrew File System support (AFS) (EXPERIMENTAL)"
        depends on INET && EXPERIMENTAL
        select AF_RXRPC
-        select KEYS
        help
          If you say Y here, you will get an experimental Andrew File System
          driver. It currently only supports unsecured read-only AFS access.
diff --git a/fs/Kconfig.binfmt b/fs/Kconfig.binfmt
index f3d3d81eb7e9..74c64409ddbc 100644
--- a/fs/Kconfig.binfmt
+++ b/fs/Kconfig.binfmt
@@ -26,7 +26,7 @@ config BINFMT_ELF
 config BINFMT_ELF_FDPIC
        bool "Kernel support for FDPIC ELF binaries"
        default y
-        depends on FRV
+        depends on (FRV || BLACKFIN)
        help
          ELF FDPIC binaries are based on ELF, but allow the individual load
          segments of a binary to be located in memory independently of each
diff --git a/fs/adfs/super.c b/fs/adfs/super.c
index 2e5f2c8371ee..30c296508497 100644
--- a/fs/adfs/super.c
+++ b/fs/adfs/super.c
@@ -232,8 +232,7 @@ static void init_once(void * foo, struct kmem_cache * cachep, unsigned long flag
 {
        struct adfs_inode_info *ei = (struct adfs_inode_info *) foo;
-        if ((flags & (SLAB_CTOR_VERIFY|SLAB_CTOR_CONSTRUCTOR)) ==
+        if (flags & SLAB_CTOR_CONSTRUCTOR)
-            SLAB_CTOR_CONSTRUCTOR)
                inode_init_once(&ei->vfs_inode);
 }
 
diff --git a/fs/affs/super.c b/fs/affs/super.c
index c3986a1911b0..beff7d21e6e2 100644
--- a/fs/affs/super.c
+++ b/fs/affs/super.c
@@ -87,8 +87,7 @@ static void init_once(void * foo, struct kmem_cache * cachep, unsigned long flag
 {
        struct affs_inode_info *ei = (struct affs_inode_info *) foo;
-        if ((flags & (SLAB_CTOR_VERIFY|SLAB_CTOR_CONSTRUCTOR)) ==
+        if (flags & SLAB_CTOR_CONSTRUCTOR) {
-            SLAB_CTOR_CONSTRUCTOR) {
                init_MUTEX(&ei->i_link_lock);
                init_MUTEX(&ei->i_ext_lock);
                inode_init_once(&ei->vfs_inode);
diff --git a/fs/afs/Makefile b/fs/afs/Makefile
index 01545eb1d872..cf83e5d63512 100644
--- a/fs/afs/Makefile
+++ b/fs/afs/Makefile
@@ -18,7 +18,7 @@ kafs-objs := \
        security.o \
        server.o \
        super.o \
-        use-rtnetlink.o \
+        netdevices.o \
        vlclient.o \
        vlocation.o \
        vnode.o \
diff --git a/fs/afs/callback.c b/fs/afs/callback.c
index 639399f0ab6f..9bdbf36a9aa9 100644
--- a/fs/afs/callback.c
+++ b/fs/afs/callback.c
@@ -468,7 +468,7 @@ int __init afs_callback_update_init(void)
 /*
 * shut down the callback update process
 */
-void __exit afs_callback_update_kill(void)
+void afs_callback_update_kill(void)
 {
        destroy_workqueue(afs_callback_update_worker);
 }
diff --git a/fs/afs/cmservice.c b/fs/afs/cmservice.c
index 6685f4cbccb3..d5b2ad6575bc 100644
--- a/fs/afs/cmservice.c
+++ b/fs/afs/cmservice.c
@@ -443,6 +443,7 @@ static void SRXAFSCB_GetCapabilities(struct work_struct *work)
                        reply.ia.netmask[loop] = ifs[loop].netmask.s_addr;
                        reply.ia.mtu[loop] = htonl(ifs[loop].mtu);
                }
+                kfree(ifs);
        }
        reply.cap.capcount = htonl(1);
diff --git a/fs/afs/dir.c b/fs/afs/dir.c
index dac5b990c0cd..0c1e902f17a3 100644
--- a/fs/afs/dir.c
+++ b/fs/afs/dir.c
@@ -194,10 +194,7 @@ static struct page *afs_dir_get_page(struct inode *dir, unsigned long index,
        page = read_mapping_page(dir->i_mapping, index, &file);
        if (!IS_ERR(page)) {
-                wait_on_page_locked(page);
                kmap(page);
-                if (!PageUptodate(page))
-                        goto fail;
                if (!PageChecked(page))
                        afs_dir_check_page(dir, page);
                if (PageError(page))
diff --git a/fs/afs/fsclient.c b/fs/afs/fsclient.c
index 2393d2a08d79..e54e6c2ad343 100644
--- a/fs/afs/fsclient.c
+++ b/fs/afs/fsclient.c
@@ -266,7 +266,8 @@ static int afs_deliver_fs_fetch_data(struct afs_call *call,
                call->unmarshall++;
                if (call->count < PAGE_SIZE) {
-                        buffer = kmap_atomic(call->reply3, KM_USER0);
+                        page = call->reply3;
+                        buffer = kmap_atomic(page, KM_USER0);
                        memset(buffer + PAGE_SIZE - call->count, 0,
                               call->count);
                        kunmap_atomic(buffer, KM_USER0);
diff --git a/fs/afs/internal.h b/fs/afs/internal.h
index 34665f7d7a19..d90c158cd934 100644
--- a/fs/afs/internal.h
+++ b/fs/afs/internal.h
@@ -349,7 +349,6 @@ struct afs_permits {
 * record of one of a system's set of network interfaces
 */
 struct afs_interface {
-        unsigned        index;          /* interface index */
        struct in_addr  address;        /* IPv4 address bound to interface */
        struct in_addr  netmask;        /* netmask applied to address */
        unsigned        mtu;            /* MTU of interface */
@@ -392,7 +391,7 @@ extern void afs_give_up_callback(struct afs_vnode *);
 extern void afs_dispatch_give_up_callbacks(struct work_struct *);
 extern void afs_flush_callback_breaks(struct afs_server *);
 extern int __init afs_callback_update_init(void);
-extern void __exit afs_callback_update_kill(void);
+extern void afs_callback_update_kill(void);
 /*
 * cell.c
@@ -564,7 +563,7 @@ extern void afs_fs_exit(void);
 * use-rtnetlink.c
 */
 extern int afs_get_ipv4_interfaces(struct afs_interface *, size_t, bool);
-extern int afs_get_MAC_address(u8 [6]);
+extern int afs_get_MAC_address(u8 *, size_t);
 /*
 * vlclient.c
@@ -591,7 +590,7 @@ extern struct afs_vlocation *afs_vlocation_lookup(struct afs_cell *,
                                                  struct key *,
                                                  const char *, size_t);
 extern void afs_put_vlocation(struct afs_vlocation *);
-extern void __exit afs_vlocation_purge(void);
+extern void afs_vlocation_purge(void);
 /*
 * vnode.c
diff --git a/fs/afs/main.c b/fs/afs/main.c
index 40c2704e7557..80ec6fd19a73 100644
--- a/fs/afs/main.c
+++ b/fs/afs/main.c
@@ -54,7 +54,7 @@ static int __init afs_get_client_UUID(void)
        /* read the MAC address of one of the external interfaces and construct
         * a UUID from it */
-        ret = afs_get_MAC_address(afs_uuid.node);
+        ret = afs_get_MAC_address(afs_uuid.node, sizeof(afs_uuid.node));
        if (ret < 0)
                return ret;
diff --git a/fs/afs/mntpt.c b/fs/afs/mntpt.c
index b905ae37f912..034fcfd4e330 100644
--- a/fs/afs/mntpt.c
+++ b/fs/afs/mntpt.c
@@ -68,13 +68,11 @@ int afs_mntpt_check_symlink(struct afs_vnode *vnode, struct key *key)
        }
        ret = -EIO;
-        wait_on_page_locked(page);
-        buf = kmap(page);
-        if (!PageUptodate(page))
-                goto out_free;
        if (PageError(page))
                goto out_free;
+        buf = kmap(page);
        /* examine the symlink's contents */
        size = vnode->status.size;
        _debug("symlink to %*.*s", (int) size, (int) size, buf);
@@ -91,8 +89,8 @@ int afs_mntpt_check_symlink(struct afs_vnode *vnode, struct key *key)
        ret = 0;
-out_free:
        kunmap(page);
+out_free:
        page_cache_release(page);
 out:
        _leave(" = %d", ret);
@@ -171,8 +169,7 @@ static struct vfsmount *afs_mntpt_do_automount(struct dentry *mntpt)
        }
        ret = -EIO;
-        wait_on_page_locked(page);
+        if (PageError(page))
-        if (!PageUptodate(page) || PageError(page))
                goto error;
        buf = kmap(page);
diff --git a/fs/afs/netdevices.c b/fs/afs/netdevices.c
new file mode 100644
index 000000000000..fc27d4b52e5f
--- /dev/null
+++ b/fs/afs/netdevices.c
@@ -0,0 +1,68 @@
+/* AFS network device helpers
+ *
+ * Copyright (c) 2007 Patrick McHardy <kaber@trash.net>
+ */
+#include <linux/string.h>
+#include <linux/rtnetlink.h>
+#include <linux/inetdevice.h>
+#include <linux/netdevice.h>
+#include <linux/if_arp.h>
+#include "internal.h"
+/*
+ * get a MAC address from a random ethernet interface that has a real one
+ * - the buffer will normally be 6 bytes in size
+ */
+int afs_get_MAC_address(u8 *mac, size_t maclen)
+{
+        struct net_device *dev;
+        int ret = -ENODEV;
+        if (maclen != ETH_ALEN)
+                BUG();
+        rtnl_lock();
+        dev = __dev_getfirstbyhwtype(ARPHRD_ETHER);
+        if (dev) {
+                memcpy(mac, dev->dev_addr, maclen);
+                ret = 0;
+        }
+        rtnl_unlock();
+        return ret;
+}
+/*
+ * get a list of this system's interface IPv4 addresses, netmasks and MTUs
+ * - maxbufs must be at least 1
+ * - returns the number of interface records in the buffer
+ */
+int afs_get_ipv4_interfaces(struct afs_interface *bufs, size_t maxbufs,
+                            bool wantloopback)
+{
+        struct net_device *dev;
+        struct in_device *idev;
+        int n = 0;
+        ASSERT(maxbufs > 0);
+        rtnl_lock();
+        for_each_netdev(dev) {
+                if (dev->type == ARPHRD_LOOPBACK && !wantloopback)
+                        continue;
+                idev = __in_dev_get_rtnl(dev);
+                if (!idev)
+                        continue;
+                for_primary_ifa(idev) {
+                        bufs[n].address.s_addr = ifa->ifa_address;
+                        bufs[n].netmask.s_addr = ifa->ifa_mask;
+                        bufs[n].mtu = dev->mtu;
+                        n++;
+                        if (n >= maxbufs)
+                                goto out;
+                } endfor_ifa(idev);
+        }
+out:
+        rtnl_unlock();
+        return n;
+}
diff --git a/fs/afs/super.c b/fs/afs/super.c
index cebd03c91f57..7030d76155fc 100644
--- a/fs/afs/super.c
+++ b/fs/afs/super.c
@@ -20,6 +20,7 @@
 #include <linux/slab.h>
 #include <linux/fs.h>
 #include <linux/pagemap.h>
+#include <linux/parser.h>
 #include "internal.h"
 #define AFS_FS_MAGIC 0x6B414653 /* 'kAFS' */
@@ -42,7 +43,7 @@ struct file_system_type afs_fs_type = {
        .name           = "afs",
        .get_sb         = afs_get_sb,
        .kill_sb        = kill_anon_super,
-        .fs_flags       = FS_BINARY_MOUNTDATA,
+        .fs_flags       = 0,
 };
 static const struct super_operations afs_super_ops = {
@@ -58,6 +59,20 @@ static const struct super_operations afs_super_ops = {
 static struct kmem_cache *afs_inode_cachep;
 static atomic_t afs_count_active_inodes;
+enum {
+        afs_no_opt,
+        afs_opt_cell,
+        afs_opt_rwpath,
+        afs_opt_vol,
+};
+static const match_table_t afs_options_list = {
+        { afs_opt_cell,         "cell=%s"       },
+        { afs_opt_rwpath,       "rwpath"        },
+        { afs_opt_vol,          "vol=%s"        },
+        { afs_no_opt,           NULL            },
+};
 /*
 * initialise the filesystem
 */
@@ -115,31 +130,6 @@ void __exit afs_fs_exit(void)
 }
 /*
- * check that an argument has a value
- */
-static int want_arg(char **_value, const char *option)
-{
-        if (!_value || !*_value || !**_value) {
-                printk(KERN_NOTICE "kAFS: %s: argument missing\n", option);
-                return 0;
-        }
-        return 1;
-}
-/*
- * check that there's no subsequent value
- */
-static int want_no_value(char *const *_value, const char *option)
-{
-        if (*_value && **_value) {
-                printk(KERN_NOTICE "kAFS: %s: Invalid argument: %s\n",
-                       option, *_value);
-                return 0;
-        }
-        return 1;
-}
-/*
 * parse the mount options
 * - this function has been shamelessly adapted from the ext3 fs which
 *   shamelessly adapted it from the msdos fs
@@ -148,48 +138,46 @@ static int afs_parse_options(struct afs_mount_params *params,
                             char *options, const char **devname)
 {
        struct afs_cell *cell;
-        char *key, *value;
+        substring_t args[MAX_OPT_ARGS];
-        int ret;
+        char *p;
+        int token;
        _enter("%s", options);
        options[PAGE_SIZE - 1] = 0;
-        ret = 0;
+        while ((p = strsep(&options, ","))) {
-        while ((key = strsep(&options, ","))) {
+                if (!*p)
-                value = strchr(key, '=');
+                        continue;
-                if (value)
-                        *value++ = 0;
-                _debug("kAFS: KEY: %s, VAL:%s", key, value ?: "-");
-                if (strcmp(key, "rwpath") == 0) {
+                token = match_token(p, afs_options_list, args);
-                        if (!want_no_value(&value, "rwpath"))
+                switch (token) {
-                                return -EINVAL;
+                case afs_opt_cell:
-                        params->rwpath = 1;
+                        cell = afs_cell_lookup(args[0].from,
-                } else if (strcmp(key, "vol") == 0) {
+                                               args[0].to - args[0].from);
-                        if (!want_arg(&value, "vol"))
-                                return -EINVAL;
-                        *devname = value;
-                } else if (strcmp(key, "cell") == 0) {
-                        if (!want_arg(&value, "cell"))
-                                return -EINVAL;
-                        cell = afs_cell_lookup(value, strlen(value));
                        if (IS_ERR(cell))
                                return PTR_ERR(cell);
                        afs_put_cell(params->cell);
                        params->cell = cell;
-                } else {
+                        break;
-                        printk("kAFS: Unknown mount option: '%s'\n",  key);
-                        ret = -EINVAL;
+                case afs_opt_rwpath:
-                        goto error;
+                        params->rwpath = 1;
+                        break;
+                case afs_opt_vol:
+                        *devname = args[0].from;
+                        break;
+                default:
+                        printk(KERN_ERR "kAFS:"
+                               " Unknown or invalid mount option: '%s'\n", p);
+                        return -EINVAL;
                }
        }
-        ret = 0;
+        _leave(" = 0");
-error:
+        return 0;
-        _leave(" = %d", ret);
-        return ret;
 }
 /*
@@ -361,7 +349,6 @@ error:
 /*
 * get an AFS superblock
- * - TODO: don't use get_sb_nodev(), but rather call sget() directly
 */
 static int afs_get_sb(struct file_system_type *fs_type,
                      int flags,
@@ -386,7 +373,6 @@ static int afs_get_sb(struct file_system_type *fs_type,
                        goto error;
        }
        ret = afs_parse_device_name(&params, dev_name);
        if (ret < 0)
                goto error;
@@ -467,8 +453,7 @@ static void afs_i_init_once(void *_vnode, struct kmem_cache *cachep,
 {
        struct afs_vnode *vnode = _vnode;
-        if ((flags & (SLAB_CTOR_VERIFY|SLAB_CTOR_CONSTRUCTOR)) ==
+        if (flags & SLAB_CTOR_CONSTRUCTOR) {
-            SLAB_CTOR_CONSTRUCTOR) {
                memset(vnode, 0, sizeof(*vnode));
                inode_init_once(&vnode->vfs_inode);
                init_waitqueue_head(&vnode->update_waitq);
diff --git a/fs/afs/use-rtnetlink.c b/fs/afs/use-rtnetlink.c
deleted file mode 100644
index f8991c700e02..000000000000
--- a/fs/afs/use-rtnetlink.c
+++ /dev/null
@@ -1,473 +0,0 @@
-/* RTNETLINK client
- *
- * Copyright (C) 2007 Red Hat, Inc. All Rights Reserved.
- * Written by David Howells (dhowells@redhat.com)
- *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU General Public License
- * as published by the Free Software Foundation; either version
- * 2 of the License, or (at your option) any later version.
- */
-#include <linux/netlink.h>
-#include <linux/rtnetlink.h>
-#include <linux/if_addr.h>
-#include <linux/if_arp.h>
-#include <linux/inetdevice.h>
-#include <net/netlink.h>
-#include "internal.h"
-struct afs_rtm_desc {
-        struct socket           *nlsock;
-        struct afs_interface    *bufs;
-        u8                      *mac;
-        size_t                  nbufs;
-        size_t                  maxbufs;
-        void                    *data;
-        ssize_t                 datalen;
-        size_t                  datamax;
-        int                     msg_seq;
-        unsigned                mac_index;
-        bool                    wantloopback;
-        int (*parse)(struct afs_rtm_desc *, struct nlmsghdr *);
-};
-/*
- * parse an RTM_GETADDR response
- */
-static int afs_rtm_getaddr_parse(struct afs_rtm_desc *desc,
-                                 struct nlmsghdr *nlhdr)
-{
-        struct afs_interface *this;
-        struct ifaddrmsg *ifa;
-        struct rtattr *rtattr;
-        const char *name;
-        size_t len;
-        ifa = (struct ifaddrmsg *) NLMSG_DATA(nlhdr);
-        _enter("{ix=%d,af=%d}", ifa->ifa_index, ifa->ifa_family);
-        if (ifa->ifa_family != AF_INET) {
-                _leave(" = 0 [family %d]", ifa->ifa_family);
-                return 0;
-        }
-        if (desc->nbufs >= desc->maxbufs) {
-                _leave(" = 0 [max %zu/%zu]", desc->nbufs, desc->maxbufs);
-                return 0;
-        }
-        this = &desc->bufs[desc->nbufs];
-        this->index = ifa->ifa_index;
-        this->netmask.s_addr = inet_make_mask(ifa->ifa_prefixlen);
-        this->mtu = 0;
-        rtattr = NLMSG_DATA(nlhdr) + NLMSG_ALIGN(sizeof(struct ifaddrmsg));
-        len = NLMSG_PAYLOAD(nlhdr, sizeof(struct ifaddrmsg));
-        name = "unknown";
-        for (; RTA_OK(rtattr, len); rtattr = RTA_NEXT(rtattr, len)) {
-                switch (rtattr->rta_type) {
-                case IFA_ADDRESS:
-                        memcpy(&this->address, RTA_DATA(rtattr), 4);
-                        break;
-                case IFA_LABEL:
-                        name = RTA_DATA(rtattr);
-                        break;
-                }
-        }
-        _debug("%s: "NIPQUAD_FMT"/"NIPQUAD_FMT,
-               name, NIPQUAD(this->address), NIPQUAD(this->netmask));
-        desc->nbufs++;
-        _leave(" = 0");
-        return 0;
-}
-/*
- * parse an RTM_GETLINK response for MTUs
- */
-static int afs_rtm_getlink_if_parse(struct afs_rtm_desc *desc,
-                                    struct nlmsghdr *nlhdr)
-{
-        struct afs_interface *this;
-        struct ifinfomsg *ifi;
-        struct rtattr *rtattr;
-        const char *name;
-        size_t len, loop;
-        ifi = (struct ifinfomsg *) NLMSG_DATA(nlhdr);
-        _enter("{ix=%d}", ifi->ifi_index);
-        for (loop = 0; loop < desc->nbufs; loop++) {
-                this = &desc->bufs[loop];
-                if (this->index == ifi->ifi_index)
-                        goto found;
-        }
-        _leave(" = 0 [no match]");
-        return 0;
-found:
-        if (ifi->ifi_type == ARPHRD_LOOPBACK && !desc->wantloopback) {
-                _leave(" = 0 [loopback]");
-                return 0;
-        }
-        rtattr = NLMSG_DATA(nlhdr) + NLMSG_ALIGN(sizeof(struct ifinfomsg));
-        len = NLMSG_PAYLOAD(nlhdr, sizeof(struct ifinfomsg));
-        name = "unknown";
-        for (; RTA_OK(rtattr, len); rtattr = RTA_NEXT(rtattr, len)) {
-                switch (rtattr->rta_type) {
-                case IFLA_MTU:
-                        memcpy(&this->mtu, RTA_DATA(rtattr), 4);
-                        break;
-                case IFLA_IFNAME:
-                        name = RTA_DATA(rtattr);
-                        break;
-                }
-        }
-        _debug("%s: "NIPQUAD_FMT"/"NIPQUAD_FMT" mtu %u",
-               name, NIPQUAD(this->address), NIPQUAD(this->netmask),
-               this->mtu);
-        _leave(" = 0");
-        return 0;
-}
-/*
- * parse an RTM_GETLINK response for the MAC address belonging to the lowest
- * non-internal interface
- */
-static int afs_rtm_getlink_mac_parse(struct afs_rtm_desc *desc,
-                                     struct nlmsghdr *nlhdr)
-{
-        struct ifinfomsg *ifi;
-        struct rtattr *rtattr;
-        const char *name;
-        size_t remain, len;
-        bool set;
-        ifi = (struct ifinfomsg *) NLMSG_DATA(nlhdr);
-        _enter("{ix=%d}", ifi->ifi_index);
-        if (ifi->ifi_index >= desc->mac_index) {
-                _leave(" = 0 [high]");
-                return 0;
-        }
-        if (ifi->ifi_type == ARPHRD_LOOPBACK) {
-                _leave(" = 0 [loopback]");
-                return 0;
-        }
-        rtattr = NLMSG_DATA(nlhdr) + NLMSG_ALIGN(sizeof(struct ifinfomsg));
-        remain = NLMSG_PAYLOAD(nlhdr, sizeof(struct ifinfomsg));
-        name = "unknown";
-        set = false;
-        for (; RTA_OK(rtattr, remain); rtattr = RTA_NEXT(rtattr, remain)) {
-                switch (rtattr->rta_type) {
-                case IFLA_ADDRESS:
-                        len = RTA_PAYLOAD(rtattr);
-                        memcpy(desc->mac, RTA_DATA(rtattr),
-                               min_t(size_t, len, 6));
-                        desc->mac_index = ifi->ifi_index;
-                        set = true;
-                        break;
-                case IFLA_IFNAME:
-                        name = RTA_DATA(rtattr);
-                        break;
-                }
-        }
-        if (set)
-                _debug("%s: %02x:%02x:%02x:%02x:%02x:%02x",
-                       name,
-                       desc->mac[0], desc->mac[1], desc->mac[2],
-                       desc->mac[3], desc->mac[4], desc->mac[5]);
-        _leave(" = 0");
-        return 0;
-}
-/*
- * read the rtnetlink response and pass to parsing routine
- */
-static int afs_read_rtm(struct afs_rtm_desc *desc)
-{
-        struct nlmsghdr *nlhdr, tmphdr;
-        struct msghdr msg;
-        struct kvec iov[1];
-        void *data;
-        bool last = false;
-        int len, ret, remain;
-        _enter("");
-        do {
-                /* first of all peek to see how big the packet is */
-                memset(&msg, 0, sizeof(msg));
-                iov[0].iov_base = &tmphdr;
-                iov[0].iov_len = sizeof(tmphdr);
-                len = kernel_recvmsg(desc->nlsock, &msg, iov, 1,
-                                     sizeof(tmphdr), MSG_PEEK | MSG_TRUNC);
-                if (len < 0) {
-                        _leave(" = %d [peek]", len);
-                        return len;
-                }
-                if (len == 0)
-                        continue;
-                if (len < sizeof(tmphdr) || len < NLMSG_PAYLOAD(&tmphdr, 0)) {
-                        _leave(" = -EMSGSIZE");
-                        return -EMSGSIZE;
-                }
-                if (desc->datamax < len) {
-                        kfree(desc->data);
-                        desc->data = NULL;
-                        data = kmalloc(len, GFP_KERNEL);
-                        if (!data)
-                                return -ENOMEM;
-                        desc->data = data;
-                }
-                desc->datamax = len;
-                /* read all the data from this packet */
-                iov[0].iov_base = desc->data;
-                iov[0].iov_len = desc->datamax;
-                desc->datalen = kernel_recvmsg(desc->nlsock, &msg, iov, 1,
-                                               desc->datamax, 0);
-                if (desc->datalen < 0) {
-                        _leave(" = %zd [recv]", desc->datalen);
-                        return desc->datalen;
-                }
-                nlhdr = desc->data;
-                /* check if the header is valid */
-                if (!NLMSG_OK(nlhdr, desc->datalen) ||
-                    nlhdr->nlmsg_type == NLMSG_ERROR) {
-                        _leave(" = -EIO");
-                        return -EIO;
-                }
-                /* see if this is the last message */
-                if (nlhdr->nlmsg_type == NLMSG_DONE ||
-                    !(nlhdr->nlmsg_flags & NLM_F_MULTI))
-                        last = true;
-                /* parse the bits we got this time */
-                nlmsg_for_each_msg(nlhdr, desc->data, desc->datalen, remain) {
-                        ret = desc->parse(desc, nlhdr);
-                        if (ret < 0) {
-                                _leave(" = %d [parse]", ret);
-                                return ret;
-                        }
-                }
-        } while (!last);
-        _leave(" = 0");
-        return 0;
-}
-/*
- * list the interface bound addresses to get the address and netmask
- */
-static int afs_rtm_getaddr(struct afs_rtm_desc *desc)
-{
-        struct msghdr msg;
-        struct kvec iov[1];
-        int ret;
-        struct {
-                struct nlmsghdr nl_msg __attribute__((aligned(NLMSG_ALIGNTO)));
-                struct ifaddrmsg addr_msg __attribute__((aligned(NLMSG_ALIGNTO)));
-        } request;
-        _enter("");
-        memset(&request, 0, sizeof(request));
-        request.nl_msg.nlmsg_len = NLMSG_LENGTH(sizeof(struct ifaddrmsg));
-        request.nl_msg.nlmsg_type = RTM_GETADDR;
-        request.nl_msg.nlmsg_flags = NLM_F_REQUEST | NLM_F_DUMP;
-        request.nl_msg.nlmsg_seq = desc->msg_seq++;
-        request.nl_msg.nlmsg_pid = 0;
-        memset(&msg, 0, sizeof(msg));
-        iov[0].iov_base = &request;
-        iov[0].iov_len = sizeof(request);
-        ret = kernel_sendmsg(desc->nlsock, &msg, iov, 1, iov[0].iov_len);
-        _leave(" = %d", ret);
-        return ret;
-}
-/*
- * list the interface link statuses to get the MTUs
- */
-static int afs_rtm_getlink(struct afs_rtm_desc *desc)
-{
-        struct msghdr msg;
-        struct kvec iov[1];
-        int ret;
-        struct {
-                struct nlmsghdr nl_msg __attribute__((aligned(NLMSG_ALIGNTO)));
-                struct ifinfomsg link_msg __attribute__((aligned(NLMSG_ALIGNTO)));
-        } request;
-        _enter("");
-        memset(&request, 0, sizeof(request));
-        request.nl_msg.nlmsg_len = NLMSG_LENGTH(sizeof(struct ifinfomsg));
-        request.nl_msg.nlmsg_type = RTM_GETLINK;
-        request.nl_msg.nlmsg_flags = NLM_F_REQUEST | NLM_F_ROOT;
-        request.nl_msg.nlmsg_seq = desc->msg_seq++;
-        request.nl_msg.nlmsg_pid = 0;
-        memset(&msg, 0, sizeof(msg));
-        iov[0].iov_base = &request;
-        iov[0].iov_len = sizeof(request);
-        ret = kernel_sendmsg(desc->nlsock, &msg, iov, 1, iov[0].iov_len);
-        _leave(" = %d", ret);
-        return ret;
-}
-/*
- * cull any interface records for which there isn't an MTU value
- */
-static void afs_cull_interfaces(struct afs_rtm_desc *desc)
-{
-        struct afs_interface *bufs = desc->bufs;
-        size_t nbufs = desc->nbufs;
-        int loop, point = 0;
-        _enter("{%zu}", nbufs);
-        for (loop = 0; loop < nbufs; loop++) {
-                if (desc->bufs[loop].mtu != 0) {
-                        if (loop != point) {
-                                ASSERTCMP(loop, >, point);
-                                bufs[point] = bufs[loop];
-                        }
-                        point++;
-                }
-        }
-        desc->nbufs = point;
-        _leave(" [%zu/%zu]", desc->nbufs, nbufs);
-}
-/*
- * get a list of this system's interface IPv4 addresses, netmasks and MTUs
- * - returns the number of interface records in the buffer
- */
-int afs_get_ipv4_interfaces(struct afs_interface *bufs, size_t maxbufs,
-                            bool wantloopback)
-{
-        struct afs_rtm_desc desc;
-        int ret, loop;
-        _enter("");
-        memset(&desc, 0, sizeof(desc));
-        desc.bufs = bufs;
-        desc.maxbufs = maxbufs;
-        desc.wantloopback = wantloopback;
-        ret = sock_create_kern(AF_NETLINK, SOCK_DGRAM, NETLINK_ROUTE,
-                               &desc.nlsock);
-        if (ret < 0) {
-                _leave(" = %d [sock]", ret);
-                return ret;
-        }
-        /* issue RTM_GETADDR */
-        desc.parse = afs_rtm_getaddr_parse;
-        ret = afs_rtm_getaddr(&desc);
-        if (ret < 0)
-                goto error;
-        ret = afs_read_rtm(&desc);
-        if (ret < 0)
-                goto error;
-        /* issue RTM_GETLINK */
-        desc.parse = afs_rtm_getlink_if_parse;
-        ret = afs_rtm_getlink(&desc);
-        if (ret < 0)
-                goto error;
-        ret = afs_read_rtm(&desc);
-        if (ret < 0)
-                goto error;
-        afs_cull_interfaces(&desc);
-        ret = desc.nbufs;
-        for (loop = 0; loop < ret; loop++)
-                _debug("[%d] "NIPQUAD_FMT"/"NIPQUAD_FMT" mtu %u",
-                       bufs[loop].index,
-                       NIPQUAD(bufs[loop].address),
-                       NIPQUAD(bufs[loop].netmask),
-                       bufs[loop].mtu);
-error:
-        kfree(desc.data);
-        sock_release(desc.nlsock);
-        _leave(" = %d", ret);
-        return ret;
-}
-/*
- * get a MAC address from a random ethernet interface that has a real one
- * - the buffer should be 6 bytes in size
- */
-int afs_get_MAC_address(u8 mac[6])
-{
-        struct afs_rtm_desc desc;
-        int ret;
-        _enter("");
-        memset(&desc, 0, sizeof(desc));
-        desc.mac = mac;
-        desc.mac_index = UINT_MAX;
-        ret = sock_create_kern(AF_NETLINK, SOCK_DGRAM, NETLINK_ROUTE,
-                               &desc.nlsock);
-        if (ret < 0) {
-                _leave(" = %d [sock]", ret);
-                return ret;
-        }
-        /* issue RTM_GETLINK */
-        desc.parse = afs_rtm_getlink_mac_parse;
-        ret = afs_rtm_getlink(&desc);
-        if (ret < 0)
-                goto error;
-        ret = afs_read_rtm(&desc);
-        if (ret < 0)
-                goto error;
-        if (desc.mac_index < UINT_MAX) {
-                /* got a MAC address */
-                _debug("[%d] %02x:%02x:%02x:%02x:%02x:%02x",
-                       desc.mac_index,
-                       mac[0], mac[1], mac[2], mac[3], mac[4], mac[5]);
-        } else {
-                ret = -ENONET;
-        }
-error:
-        sock_release(desc.nlsock);
-        _leave(" = %d", ret);
-        return ret;
-}
diff --git a/fs/afs/vlocation.c b/fs/afs/vlocation.c
index 6c8e95a7c2c9..3370cdb72566 100644
--- a/fs/afs/vlocation.c
+++ b/fs/afs/vlocation.c
@@ -602,7 +602,7 @@ int __init afs_vlocation_update_init(void)
 /*
 * discard all the volume location records for rmmod
 */
-void __exit afs_vlocation_purge(void)
+void afs_vlocation_purge(void)
 {
        afs_vlocation_timeout = 0;
diff --git a/fs/aio.c b/fs/aio.c
index e4598d6d49dd..b97ab8028b6d 100644
--- a/fs/aio.c
+++ b/fs/aio.c
@@ -68,10 +68,8 @@ static void aio_queue_work(struct kioctx *);
 */
 static int __init aio_setup(void)
 {
-        kiocb_cachep = kmem_cache_create("kiocb", sizeof(struct kiocb),
+        kiocb_cachep = KMEM_CACHE(kiocb, SLAB_HWCACHE_ALIGN|SLAB_PANIC);
-                                0, SLAB_HWCACHE_ALIGN|SLAB_PANIC, NULL, NULL);
+        kioctx_cachep = KMEM_CACHE(kioctx,SLAB_HWCACHE_ALIGN|SLAB_PANIC);
-        kioctx_cachep = kmem_cache_create("kioctx", sizeof(struct kioctx),
-                                0, SLAB_HWCACHE_ALIGN|SLAB_PANIC, NULL, NULL);
        aio_wq = create_workqueue("aio");
diff --git a/fs/befs/linuxvfs.c b/fs/befs/linuxvfs.c
index cc6cc8ed2e39..fe96108a788d 100644
--- a/fs/befs/linuxvfs.c
+++ b/fs/befs/linuxvfs.c
@@ -293,8 +293,7 @@ static void init_once(void * foo, struct kmem_cache * cachep, unsigned long flag
 {
        struct befs_inode_info *bi = (struct befs_inode_info *) foo;
        
-                if ((flags & (SLAB_CTOR_VERIFY|SLAB_CTOR_CONSTRUCTOR)) ==
+                if (flags & SLAB_CTOR_CONSTRUCTOR) {
-                            SLAB_CTOR_CONSTRUCTOR) {
                        inode_init_once(&bi->vfs_inode);
                }
 }
diff --git a/fs/bfs/inode.c b/fs/bfs/inode.c
index 93d6219243ad..edc08d89aabc 100644
--- a/fs/bfs/inode.c
+++ b/fs/bfs/inode.c
@@ -248,8 +248,7 @@ static void init_once(void * foo, struct kmem_cache * cachep, unsigned long flag
 {
        struct bfs_inode_info *bi = foo;
-        if ((flags & (SLAB_CTOR_VERIFY|SLAB_CTOR_CONSTRUCTOR)) ==
+        if (flags & SLAB_CTOR_CONSTRUCTOR)
-            SLAB_CTOR_CONSTRUCTOR)
                inode_init_once(&bi->vfs_inode);
 }
 
diff --git a/fs/bio.c b/fs/bio.c
index 693940da4090..093345f00128 100644
--- a/fs/bio.c
+++ b/fs/bio.c
@@ -1193,8 +1193,7 @@ static void __init biovec_init_slabs(void)
 static int __init init_bio(void)
 {
-        bio_slab = kmem_cache_create("bio", sizeof(struct bio), 0,
+        bio_slab = KMEM_CACHE(bio, SLAB_HWCACHE_ALIGN|SLAB_PANIC);
-                                SLAB_HWCACHE_ALIGN|SLAB_PANIC, NULL, NULL);
        biovec_init_slabs();
diff --git a/fs/block_dev.c b/fs/block_dev.c
index 575076c018f4..f02b7bdd9864 100644
--- a/fs/block_dev.c
+++ b/fs/block_dev.c
@@ -55,10 +55,12 @@ static sector_t max_block(struct block_device *bdev)
        return retval;
 }
-/* Kill _all_ buffers, dirty or not.. */
+/* Kill _all_ buffers and pagecache , dirty or not.. */
 static void kill_bdev(struct block_device *bdev)
 {
-        invalidate_bdev(bdev, 1);
+        if (bdev->bd_inode->i_mapping->nrpages == 0)
+                return;
+        invalidate_bh_lrus();
        truncate_inode_pages(bdev->bd_inode->i_mapping, 0);
 }       
@@ -455,9 +457,7 @@ static void init_once(void * foo, struct kmem_cache * cachep, unsigned long flag
        struct bdev_inode *ei = (struct bdev_inode *) foo;
        struct block_device *bdev = &ei->bdev;
-        if ((flags & (SLAB_CTOR_VERIFY|SLAB_CTOR_CONSTRUCTOR)) ==
+        if (flags & SLAB_CTOR_CONSTRUCTOR) {
-            SLAB_CTOR_CONSTRUCTOR)
-        {
                memset(bdev, 0, sizeof(*bdev));
                mutex_init(&bdev->bd_mutex);
                sema_init(&bdev->bd_mount_sem, 1);
@@ -1478,7 +1478,7 @@ int __invalidate_device(struct block_device *bdev)
                res = invalidate_inodes(sb);
                drop_super(sb);
        }
-        invalidate_bdev(bdev, 0);
+        invalidate_bdev(bdev);
        return res;
 }
 EXPORT_SYMBOL(__invalidate_device);
diff --git a/fs/buffer.c b/fs/buffer.c
index 1d0852fa728b..7db24b9e5449 100644
--- a/fs/buffer.c
+++ b/fs/buffer.c
@@ -44,7 +44,6 @@
 #include <linux/bit_spinlock.h>
 static int fsync_buffers_list(spinlock_t *lock, struct list_head *list);
-static void invalidate_bh_lrus(void);
 #define BH_ENTRY(list) list_entry((list), struct buffer_head, b_assoc_buffers)
@@ -333,7 +332,7 @@ out:
   we think the disk contains more recent information than the buffercache.
   The update == 1 pass marks the buffers we need to update, the update == 2
   pass does the actual I/O. */
-void invalidate_bdev(struct block_device *bdev, int destroy_dirty_buffers)
+void invalidate_bdev(struct block_device *bdev)
 {
        struct address_space *mapping = bdev->bd_inode->i_mapping;
@@ -341,11 +340,6 @@ void invalidate_bdev(struct block_device *bdev, int destroy_dirty_buffers)
                return;
        invalidate_bh_lrus();
-        /*
-         * FIXME: what about destroy_dirty_buffers?
-         * We really want to use invalidate_inode_pages2() for
-         * that, but not until that's cleaned up.
-         */
        invalidate_mapping_pages(mapping, 0, -1);
 }
@@ -1408,7 +1402,7 @@ static void invalidate_bh_lru(void *arg)
        put_cpu_var(bh_lrus);
 }
        
-static void invalidate_bh_lrus(void)
+void invalidate_bh_lrus(void)
 {
        on_each_cpu(invalidate_bh_lru, NULL, 1, 1);
 }
@@ -1700,17 +1694,8 @@ done:
                 * clean.  Someone wrote them back by hand with
                 * ll_rw_block/submit_bh.  A rare case.
                 */
-                int uptodate = 1;
-                do {
-                        if (!buffer_uptodate(bh)) {
-                                uptodate = 0;
-                                break;
-                        }
-                        bh = bh->b_this_page;
-                } while (bh != head);
-                if (uptodate)
-                        SetPageUptodate(page);
                end_page_writeback(page);
                /*
                 * The page and buffer_heads can be released at any time from
                 * here on.
@@ -2968,8 +2953,7 @@ EXPORT_SYMBOL(free_buffer_head);
 static void
 init_buffer_head(void *data, struct kmem_cache *cachep, unsigned long flags)
 {
-        if ((flags & (SLAB_CTOR_VERIFY|SLAB_CTOR_CONSTRUCTOR)) ==
+        if (flags & SLAB_CTOR_CONSTRUCTOR) {
-                            SLAB_CTOR_CONSTRUCTOR) {
                struct buffer_head * bh = (struct buffer_head *)data;
                memset(bh, 0, sizeof(*bh));
diff --git a/fs/cifs/CHANGES b/fs/cifs/CHANGES
index 5d1f4873d701..a9b6bc5157b8 100644
--- a/fs/cifs/CHANGES
+++ b/fs/cifs/CHANGES
@@ -1,4 +1,16 @@
-Verison 1.48
+Version 1.49
+------------
+IPv6 support.  Enable ipv6 addresses to be passed on mount (put the ipv6
+address after the "ip=" mount option, at least until mount.cifs is fixed to
+handle DNS host to ipv6 name translation).  Accept override of uid or gid
+on mount even when Unix Extensions are negotiated (it used to be ignored
+when Unix Extensions were ignored).  This allows users to override the
+default uid and gid for files when they are certain that the uids or
+gids on the server do not match those of the client.  Make "sec=none"
+mount override username (so that null user connection is attempted)
+to match what documentation said.
+Version 1.48
 ------------
 Fix mtime bouncing around from local idea of last write times to remote time.
 Fix hang (in i_size_read) when simultaneous size update of same remote file
@@ -9,7 +21,13 @@ from read-only back to read-write, reflect this change in default file mode
 (we had been leaving a file's mode read-only until the inode were reloaded).
 Allow setting of attribute back to ATTR_NORMAL (removing readonly dos attribute
 when archive dos attribute not set and we are changing mode back to writeable
-on server which does not support the Unix Extensions).
+on server which does not support the Unix Extensions).  Remove read only dos
+attribute on chmod when adding any write permission (ie on any of
+user/group/other (not all of user/group/other ie  0222) when
+mounted to windows.  Add support for POSIX MkDir (slight performance
+enhancement and eliminates the network race between the mkdir and set 
+path info of the mode).
 Version 1.47
 ------------
diff --git a/fs/cifs/README b/fs/cifs/README
index 080c5eba112b..4d01697722cc 100644
--- a/fs/cifs/README
+++ b/fs/cifs/README
@@ -257,13 +257,19 @@ A partial list of the supported mount options follows:
                mount.  
  domain        Set the SMB/CIFS workgroup name prepended to the
                username during CIFS session establishment
-  uid           If CIFS Unix extensions are not supported by the server
+  uid           Set the default uid for inodes. For mounts to servers
-                this overrides the default uid for inodes. For mounts to
+                which do support the CIFS Unix extensions, such as a
-                servers which do support the CIFS Unix extensions, such
+                properly configured Samba server, the server provides
-                as a properly configured Samba server, the server provides
+                the uid, gid and mode so this parameter should  not be
-                the uid, gid and mode.  For servers which do not support
+                specified unless the server and clients uid and gid
-                the Unix extensions, the default uid (and gid) returned on
+                numbering differ.  If the server and client are in the
-                lookup of existing files is the uid (gid) of the person
+                same domain (e.g. running winbind or nss_ldap) and
+                the server supports the Unix Extensions then the uid
+                and gid can be retrieved from the server (and uid
+                and gid would not have to be specifed on the mount. 
+                For servers which do not support the CIFS Unix
+                extensions, the default uid (and gid) returned on lookup
+                of existing files will be the uid (gid) of the person
                who executed the mount (root, except when mount.cifs
                is configured setuid for user mounts) unless the "uid=" 
                (gid) mount option is specified.  For the uid (gid) of newly
@@ -281,8 +287,7 @@ A partial list of the supported mount options follows:
                the client.  Note that the mount.cifs helper must be
                at version 1.10 or higher to support specifying the uid
                (or gid) in non-numberic form.
-  gid           If CIFS Unix extensions are not supported by the server
+  gid           Set the default gid for inodes (similar to above).
-                this overrides the default gid for inodes.
  file_mode     If CIFS Unix extensions are not supported by the server
                this overrides the default mode for file inodes.
  dir_mode      If CIFS Unix extensions are not supported by the server 
@@ -467,7 +472,7 @@ including:
        -V      print mount.cifs version
        -?      display simple usage information
-With recent 2.6 kernel versions of modutils, the version of the cifs kernel
+With most 2.6 kernel versions of modutils, the version of the cifs kernel
 module can be displayed via modinfo.
 Misc /proc/fs/cifs Flags and Debug Info
@@ -516,8 +521,22 @@ SecurityFlags		Flags which control security negotiation and
                        must use plaintext passwords                    0x20020
                        (reserved for future packet encryption)         0x00040
-cifsFYI                 If set to one, additional debug information is
+cifsFYI                 If set to non-zero value, additional debug information
-                        logged to the system error log. (default 0)
+                        will be logged to the system error log.  This field
+                        contains three flags controlling different classes of
+                        debugging entries.  The maximum value it can be set
+                        to is 7 which enables all debugging points (default 0).
+                        Some debugging statements are not compiled into the
+                        cifs kernel unless CONFIG_CIFS_DEBUG2 is enabled in the
+                        kernel configuration. cifsFYI may be set to one or
+                        nore of the following flags (7 sets them all):
+                        log cifs informational messages                 0x01
+                        log return codes from cifs entry points         0x02
+                        log slow responses (ie which take longer than 1 second)
+                          CONFIG_CIFS_STATS2 must be enabled in .config 0x04
+                                
+                                
 traceSMB                If set to one, debug information is logged to the
                        system error log with the start of smb requests
                        and responses (default 0)
diff --git a/fs/cifs/TODO b/fs/cifs/TODO
index d7b9c27c942d..78b620e332bd 100644
--- a/fs/cifs/TODO
+++ b/fs/cifs/TODO
@@ -1,4 +1,4 @@
-Version 1.39 November 30, 2005
+Version 1.49 April 26, 2007
 A Partial List of Missing Features
 ==================================
@@ -18,7 +18,7 @@ better)
 d) Kerberos/SPNEGO session setup support - (started)
-e) NTLMv2 authentication (mostly implemented - double check
+e) More testing of NTLMv2 authentication (mostly implemented - double check
 that NTLMv2 signing works, also need to cleanup now unneeded SessSetup code in
 fs/cifs/connect.c)
@@ -27,55 +27,44 @@ used (Kerberos or NTLMSSP). Signing alreadyimplemented for NTLM
 and raw NTLMSSP already. This is important when enabling
 extended security and mounting to Windows 2003 Servers
-f) Directory entry caching relies on a 1 second timer, rather than 
+g) Directory entry caching relies on a 1 second timer, rather than 
 using FindNotify or equivalent.  - (started)
-g) A few byte range testcases fail due to POSIX vs. Windows/CIFS
+h) quota support (needs minor kernel change since quota calls
-style byte range lock differences.  Save byte range locks so
-reconnect can replay them.  
-h) Support unlock all (unlock 0,MAX_OFFSET)
-by unlocking all known byte range locks that we locked on the file.
-i) quota support (needs minor kernel change since quota calls
 to make it to network filesystems or deviceless filesystems)
-j) investigate sync behavior (including syncpage) and check  
+i) investigate sync behavior (including syncpage) and check  
 for proper behavior of intr/nointr
-k) hook lower into the sockets api (as NFS/SunRPC does) to avoid the
+j) hook lower into the sockets api (as NFS/SunRPC does) to avoid the
 extra copy in/out of the socket buffers in some cases.
-l) finish support for IPv6.  This is mostly complete but
+k) Better optimize open (and pathbased setfilesize) to reduce the
-needs a simple conversion of ipv6 to sin6_addr from the
-address in string representation.
-m) Better optimize open (and pathbased setfilesize) to reduce the
 oplock breaks coming from windows srv.  Piggyback identical file
 opens on top of each other by incrementing reference count rather
 than resending (helps reduce server resource utilization and avoid
 spurious oplock breaks).
-o) Improve performance of readpages by sending more than one read
+l) Improve performance of readpages by sending more than one read
 at a time when 8 pages or more are requested. In conjuntion
 add support for async_cifs_readpages.
-p) Add support for storing symlink info to Windows servers 
+m) Add support for storing symlink info to Windows servers 
 in the Extended Attribute format their SFU clients would recognize.
-q) Finish fcntl D_NOTIFY support so kde and gnome file list windows
+n) Finish fcntl D_NOTIFY support so kde and gnome file list windows
 will autorefresh (partially complete by Asser). Needs minor kernel
 vfs change to support removing D_NOTIFY on a file.   
-r) Add GUI tool to configure /proc/fs/cifs settings and for display of
+o) Add GUI tool to configure /proc/fs/cifs settings and for display of
 the CIFS statistics (started)
-s) implement support for security and trusted categories of xattrs
+p) implement support for security and trusted categories of xattrs
 (requires minor protocol extension) to enable better support for SELINUX
-t) Implement O_DIRECT flag on open (already supported on mount)
+q) Implement O_DIRECT flag on open (already supported on mount)
-u) Create UID mapping facility so server UIDs can be mapped on a per
+r) Create UID mapping facility so server UIDs can be mapped on a per
 mount or a per server basis to client UIDs or nobody if no mapping
 exists.  This is helpful when Unix extensions are negotiated to
 allow better permission checking when UIDs differ on the server
@@ -83,19 +72,26 @@ and client.  Add new protocol request to the CIFS protocol
 standard for asking the server for the corresponding name of a
 particular uid.
-v) Add support for CIFS Unix and also the newer POSIX extensions to the
+s) Add support for CIFS Unix and also the newer POSIX extensions to the
 server side for Samba 4.
-w) Finish up the dos time conversion routines needed to return old server
+t) In support for OS/2 (LANMAN 1.2 and LANMAN2.1 based SMB servers) 
-time to the client (default time, of now or time 0 is used now for these 
-very old servers)
-x) In support for OS/2 (LANMAN 1.2 and LANMAN2.1 based SMB servers) 
 need to add ability to set time to server (utimes command)
-y) Finish testing of Windows 9x/Windows ME server support (started).
+u) DOS attrs - returned as pseudo-xattr in Samba format (check VFAT and NTFS for this too)
+v) mount check for unmatched uids
+w) Add mount option for Linux extension disable per mount, and partial
+disable per mount (uid off, symlink/fifo/mknod on but what about posix acls?)
-KNOWN BUGS (updated February 26, 2007)
+x) Fix Samba 3 server to handle Linux kernel aio so dbench with lots of 
+processes can proceed better in parallel (on the server)
+y) Fix Samba 3 to handle reads/writes over 127K (and remove the cifs mount
+restriction of wsize max being 127K) 
+KNOWN BUGS (updated April 24, 2007)
 ====================================
 See http://bugzilla.samba.org - search on product "CifsVFS" for
 current bug list.
@@ -127,10 +123,3 @@ negotiated size) and send larger write sizes to modern servers.
 4) More exhaustively test against less common servers.  More testing
 against Windows 9x, Windows ME servers.
-DOS attrs - returned as pseudo-xattr in Samba format (check VFAT and NTFS for this too)
-mount check for unmatched uids - and uid override
-Add mount option for Linux extension disable per mount, and partial disable per mount (uid off, symlink/fifo/mknod on but what about posix acls?) 
-Free threads at umount --force that are stuck on the sesSem
diff --git a/fs/cifs/cifs_fs_sb.h b/fs/cifs/cifs_fs_sb.h
index fd1e52ebcee6..4cc2012e9322 100644
--- a/fs/cifs/cifs_fs_sb.h
+++ b/fs/cifs/cifs_fs_sb.h
@@ -22,12 +22,14 @@
 #define CIFS_MOUNT_SET_UID      2 /* set current->euid in create etc. */
 #define CIFS_MOUNT_SERVER_INUM  4 /* inode numbers from uniqueid from server */
 #define CIFS_MOUNT_DIRECT_IO    8 /* do not write nor read through page cache */
-#define CIFS_MOUNT_NO_XATTR  0x10 /* if set - disable xattr support */
+#define CIFS_MOUNT_NO_XATTR     0x10  /* if set - disable xattr support       */
-#define CIFS_MOUNT_MAP_SPECIAL_CHR 0x20 /* remap illegal chars in filenames */
+#define CIFS_MOUNT_MAP_SPECIAL_CHR 0x20 /* remap illegal chars in filenames   */
-#define CIFS_MOUNT_POSIX_PATHS  0x40 /* Negotiate posix pathnames if possible. */
+#define CIFS_MOUNT_POSIX_PATHS  0x40  /* Negotiate posix pathnames if possible*/
-#define CIFS_MOUNT_UNX_EMUL     0x80 /* Network compat with SFUnix emulation */
+#define CIFS_MOUNT_UNX_EMUL     0x80  /* Network compat with SFUnix emulation */
-#define CIFS_MOUNT_NO_BRL       0x100 /* No sending byte range locks to srv */
+#define CIFS_MOUNT_NO_BRL       0x100 /* No sending byte range locks to srv   */
-#define CIFS_MOUNT_CIFS_ACL     0x200 /* send ACL requests to non-POSIX srv */
+#define CIFS_MOUNT_CIFS_ACL     0x200 /* send ACL requests to non-POSIX srv   */
+#define CIFS_MOUNT_OVERR_UID    0x400 /* override uid returned from server    */
+#define CIFS_MOUNT_OVERR_GID    0x800 /* override gid returned from server    */
 struct cifs_sb_info {
        struct cifsTconInfo *tcon;      /* primary mount */
diff --git a/fs/cifs/cifs_unicode.c b/fs/cifs/cifs_unicode.c
index d2a8b2941fc2..793c4b95c164 100644
--- a/fs/cifs/cifs_unicode.c
+++ b/fs/cifs/cifs_unicode.c
@@ -74,8 +74,8 @@ cifs_strtoUCS(__le16 * to, const char *from, int len,
                charlen = codepage->char2uni(from, len, &wchar_to[i]);
                if (charlen < 1) {
                        cERROR(1,
-                               ("cifs_strtoUCS: char2uni returned %d",
+                               ("strtoUCS: char2uni of %d returned %d",
-                                charlen));
+                                (int)*from, charlen));
                        /* A question mark */
                        to[i] = cpu_to_le16(0x003f);
                        charlen = 1;
diff --git a/fs/cifs/cifsfs.c b/fs/cifs/cifsfs.c
index faba4d69fe91..8568e100953c 100644
--- a/fs/cifs/cifsfs.c
+++ b/fs/cifs/cifsfs.c
@@ -100,7 +100,7 @@ cifs_read_super(struct super_block *sb, void *data,
        sb->s_flags |= MS_NODIRATIME | MS_NOATIME;
        sb->s_fs_info = kzalloc(sizeof(struct cifs_sb_info),GFP_KERNEL);
        cifs_sb = CIFS_SB(sb);
-        if(cifs_sb == NULL)
+        if (cifs_sb == NULL)
                return -ENOMEM;
        rc = cifs_mount(sb, cifs_sb, data, devname);
@@ -115,10 +115,10 @@ cifs_read_super(struct super_block *sb, void *data,
        sb->s_magic = CIFS_MAGIC_NUMBER;
        sb->s_op = &cifs_super_ops;
 #ifdef CONFIG_CIFS_EXPERIMENTAL
-        if(experimEnabled != 0)
+        if (experimEnabled != 0)
                sb->s_export_op = &cifs_export_ops;
 #endif /* EXPERIMENTAL */       
-/*      if(cifs_sb->tcon->ses->server->maxBuf > MAX_CIFS_HDR_SIZE + 512)
+/*      if (cifs_sb->tcon->ses->server->maxBuf > MAX_CIFS_HDR_SIZE + 512)
            sb->s_blocksize = cifs_sb->tcon->ses->server->maxBuf - MAX_CIFS_HDR_SIZE; */
 #ifdef CONFIG_CIFS_QUOTA
        sb->s_qcop = &cifs_quotactl_ops;
@@ -147,8 +147,8 @@ out_no_root:
                iput(inode);
 out_mount_failed:
-        if(cifs_sb) {
+        if (cifs_sb) {
-                if(cifs_sb->local_nls)
+                if (cifs_sb->local_nls)
                        unload_nls(cifs_sb->local_nls); 
                kfree(cifs_sb);
        }
@@ -163,7 +163,7 @@ cifs_put_super(struct super_block *sb)
        cFYI(1, ("In cifs_put_super"));
        cifs_sb = CIFS_SB(sb);
-        if(cifs_sb == NULL) {
+        if (cifs_sb == NULL) {
                cFYI(1,("Empty cifs superblock info passed to unmount"));
                return;
        }
@@ -208,14 +208,14 @@ cifs_statfs(struct dentry *dentry, struct kstatfs *buf)
    /* Only need to call the old QFSInfo if failed
    on newer one */
-    if(rc)
+    if (rc)
-        if(pTcon->ses->capabilities & CAP_NT_SMBS)
+        if (pTcon->ses->capabilities & CAP_NT_SMBS)
                rc = CIFSSMBQFSInfo(xid, pTcon, buf); /* not supported by OS2 */
        /* Some old Windows servers also do not support level 103, retry with
           older level one if old server failed the previous call or we
           bypassed it because we detected that this was an older LANMAN sess */
-        if(rc)
+        if (rc)
                rc = SMBOldQFSInfo(xid, pTcon, buf);
        /*     
           int f_type;
@@ -301,11 +301,19 @@ cifs_show_options(struct seq_file *s, struct vfsmount *m)
                                if (cifs_sb->tcon->ses->userName)
                                        seq_printf(s, ",username=%s",
                                           cifs_sb->tcon->ses->userName);
-                                if(cifs_sb->tcon->ses->domainName)
+                                if (cifs_sb->tcon->ses->domainName)
                                        seq_printf(s, ",domain=%s",
                                           cifs_sb->tcon->ses->domainName);
                        }
                }
+                if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_POSIX_PATHS)
+                        seq_printf(s, ",posixpaths");
+                if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_UID) ||
+                   !(cifs_sb->tcon->ses->capabilities & CAP_UNIX))
+                        seq_printf(s, ",uid=%d", cifs_sb->mnt_uid);
+                if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_GID) ||
+                   !(cifs_sb->tcon->ses->capabilities & CAP_UNIX))
+                        seq_printf(s, ",gid=%d", cifs_sb->mnt_gid);
                seq_printf(s, ",rsize=%d",cifs_sb->rsize);
                seq_printf(s, ",wsize=%d",cifs_sb->wsize);
        }
@@ -321,14 +329,14 @@ int cifs_xquota_set(struct super_block * sb, int quota_type, qid_t qid,
        struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
        struct cifsTconInfo *pTcon;
        
-        if(cifs_sb)
+        if (cifs_sb)
                pTcon = cifs_sb->tcon;
        else
                return -EIO;
        xid = GetXid();
-        if(pTcon) {
+        if (pTcon) {
                cFYI(1,("set type: 0x%x id: %d",quota_type,qid));               
        } else {
                return -EIO;
@@ -346,13 +354,13 @@ int cifs_xquota_get(struct super_block * sb, int quota_type, qid_t qid,
        struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
        struct cifsTconInfo *pTcon;
-        if(cifs_sb)
+        if (cifs_sb)
                pTcon = cifs_sb->tcon;
        else
                return -EIO;
        xid = GetXid();
-        if(pTcon) {
+        if (pTcon) {
                cFYI(1,("set type: 0x%x id: %d",quota_type,qid));
        } else {
                rc = -EIO;
@@ -369,13 +377,13 @@ int cifs_xstate_set(struct super_block * sb, unsigned int flags, int operation)
        struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
        struct cifsTconInfo *pTcon;
-        if(cifs_sb)
+        if (cifs_sb)
                pTcon = cifs_sb->tcon;
        else
                return -EIO;
        xid = GetXid();
-        if(pTcon) {
+        if (pTcon) {
                cFYI(1,("flags: 0x%x operation: 0x%x",flags,operation));
        } else {
                rc = -EIO;
@@ -392,13 +400,13 @@ int cifs_xstate_get(struct super_block * sb, struct fs_quota_stat *qstats)
        struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
        struct cifsTconInfo *pTcon;
-        if(cifs_sb) {
+        if (cifs_sb) {
                pTcon = cifs_sb->tcon;
        } else {
                return -EIO;
        }
        xid = GetXid();
-        if(pTcon) {
+        if (pTcon) {
                cFYI(1,("pqstats %p",qstats));          
        } else {
                rc = -EIO;
@@ -424,11 +432,11 @@ static void cifs_umount_begin(struct vfsmount * vfsmnt, int flags)
        if (!(flags & MNT_FORCE))
                return;
        cifs_sb = CIFS_SB(vfsmnt->mnt_sb);
-        if(cifs_sb == NULL)
+        if (cifs_sb == NULL)
                return;
        tcon = cifs_sb->tcon;
-        if(tcon == NULL)
+        if (tcon == NULL)
                return;
        down(&tcon->tconSem);
        if (atomic_read(&tcon->useCount) == 1)
@@ -437,7 +445,7 @@ static void cifs_umount_begin(struct vfsmount * vfsmnt, int flags)
        /* cancel_brl_requests(tcon); */ /* BB mark all brl mids as exiting */
        /* cancel_notify_requests(tcon); */
-        if(tcon->ses && tcon->ses->server)
+        if (tcon->ses && tcon->ses->server)
        {
                cFYI(1,("wake up tasks now - umount begin not complete"));
                wake_up_all(&tcon->ses->server->request_q);
@@ -529,8 +537,7 @@ static loff_t cifs_llseek(struct file *file, loff_t offset, int origin)
                /* some applications poll for the file length in this strange
                   way so we must seek to end on non-oplocked files by
                   setting the revalidate time to zero */
-                if(file->f_path.dentry->d_inode)                
+                CIFS_I(file->f_path.dentry->d_inode)->time = 0;
-                        CIFS_I(file->f_path.dentry->d_inode)->time = 0;
                retval = cifs_revalidate(file->f_path.dentry);
                if (retval < 0)
@@ -694,8 +701,7 @@ cifs_init_once(void *inode, struct kmem_cache * cachep, unsigned long flags)
 {
        struct cifsInodeInfo *cifsi = inode;
-        if ((flags & (SLAB_CTOR_VERIFY | SLAB_CTOR_CONSTRUCTOR)) ==
+        if (flags & SLAB_CTOR_CONSTRUCTOR) {
-            SLAB_CTOR_CONSTRUCTOR) {
                inode_init_once(&cifsi->vfs_inode);
                INIT_LIST_HEAD(&cifsi->lockList);
        }
@@ -724,7 +730,7 @@ cifs_destroy_inodecache(void)
 static int
 cifs_init_request_bufs(void)
 {
-        if(CIFSMaxBufSize < 8192) {
+        if (CIFSMaxBufSize < 8192) {
        /* Buffer size can not be smaller than 2 * PATH_MAX since maximum
        Unicode path name has to fit in any SMB/CIFS path based frames */
                CIFSMaxBufSize = 8192;
@@ -741,7 +747,7 @@ cifs_init_request_bufs(void)
        if (cifs_req_cachep == NULL)
                return -ENOMEM;
-        if(cifs_min_rcv < 1)
+        if (cifs_min_rcv < 1)
                cifs_min_rcv = 1;
        else if (cifs_min_rcv > 64) {
                cifs_min_rcv = 64;
@@ -751,7 +757,7 @@ cifs_init_request_bufs(void)
        cifs_req_poolp = mempool_create_slab_pool(cifs_min_rcv,
                                                  cifs_req_cachep);
-        if(cifs_req_poolp == NULL) {
+        if (cifs_req_poolp == NULL) {
                kmem_cache_destroy(cifs_req_cachep);
                return -ENOMEM;
        }
@@ -772,7 +778,7 @@ cifs_init_request_bufs(void)
                return -ENOMEM;              
        }
-        if(cifs_min_small < 2)
+        if (cifs_min_small < 2)
                cifs_min_small = 2;
        else if (cifs_min_small > 256) {
                cifs_min_small = 256;
@@ -782,7 +788,7 @@ cifs_init_request_bufs(void)
        cifs_sm_req_poolp = mempool_create_slab_pool(cifs_min_small,
                                                     cifs_sm_req_cachep);
-        if(cifs_sm_req_poolp == NULL) {
+        if (cifs_sm_req_poolp == NULL) {
                mempool_destroy(cifs_req_poolp);
                kmem_cache_destroy(cifs_req_cachep);
                kmem_cache_destroy(cifs_sm_req_cachep);
@@ -812,7 +818,7 @@ cifs_init_mids(void)
        /* 3 is a reasonable minimum number of simultaneous operations */
        cifs_mid_poolp = mempool_create_slab_pool(3, cifs_mid_cachep);
-        if(cifs_mid_poolp == NULL) {
+        if (cifs_mid_poolp == NULL) {
                kmem_cache_destroy(cifs_mid_cachep);
                return -ENOMEM;
        }
@@ -850,14 +856,14 @@ static int cifs_oplock_thread(void * dummyarg)
                        continue;
                
                spin_lock(&GlobalMid_Lock);
-                if(list_empty(&GlobalOplock_Q)) {
+                if (list_empty(&GlobalOplock_Q)) {
                        spin_unlock(&GlobalMid_Lock);
                        set_current_state(TASK_INTERRUPTIBLE);
                        schedule_timeout(39*HZ);
                } else {
                        oplock_item = list_entry(GlobalOplock_Q.next, 
                                struct oplock_q_entry, qhead);
-                        if(oplock_item) {
+                        if (oplock_item) {
                                cFYI(1,("found oplock item to write out")); 
                                pTcon = oplock_item->tcon;
                                inode = oplock_item->pinode;
@@ -871,7 +877,7 @@ static int cifs_oplock_thread(void * dummyarg)
                                /* mutex_lock(&inode->i_mutex);*/
                                if (S_ISREG(inode->i_mode)) {
                                        rc = filemap_fdatawrite(inode->i_mapping);
-                                        if(CIFS_I(inode)->clientCanCacheRead == 0) {
+                                        if (CIFS_I(inode)->clientCanCacheRead == 0) {
                                                filemap_fdatawait(inode->i_mapping);
                                                invalidate_remote_inode(inode);
                                        }
@@ -888,7 +894,7 @@ static int cifs_oplock_thread(void * dummyarg)
                                not bother sending an oplock release if session 
                                to server still is disconnected since oplock 
                                already released by the server in that case */
-                                if(pTcon->tidStatus != CifsNeedReconnect) {
+                                if (pTcon->tidStatus != CifsNeedReconnect) {
                                    rc = CIFSSMBLock(0, pTcon, netfid,
                                            0 /* len */ , 0 /* offset */, 0, 
                                            0, LOCKING_ANDX_OPLOCK_RELEASE,
@@ -922,7 +928,7 @@ static int cifs_dnotify_thread(void * dummyarg)
                list_for_each(tmp, &GlobalSMBSessionList) {
                        ses = list_entry(tmp, struct cifsSesInfo, 
                                cifsSessionList);
-                        if(ses && ses->server && 
+                        if (ses && ses->server && 
                             atomic_read(&ses->server->inFlight))
                                wake_up_all(&ses->server->response_q);
                }
@@ -971,10 +977,10 @@ init_cifs(void)
        rwlock_init(&GlobalSMBSeslock);
        spin_lock_init(&GlobalMid_Lock);
-        if(cifs_max_pending < 2) {
+        if (cifs_max_pending < 2) {
                cifs_max_pending = 2;
                cFYI(1,("cifs_max_pending set to min of 2"));
-        } else if(cifs_max_pending > 256) {
+        } else if (cifs_max_pending > 256) {
                cifs_max_pending = 256;
                cFYI(1,("cifs_max_pending set to max of 256"));
        }
diff --git a/fs/cifs/cifsfs.h b/fs/cifs/cifsfs.h
index 2c2c384894d8..c235d32ad4a8 100644
--- a/fs/cifs/cifsfs.h
+++ b/fs/cifs/cifsfs.h
@@ -100,5 +100,5 @@ extern ssize_t	cifs_getxattr(struct dentry *, const char *, void *, size_t);
 extern ssize_t  cifs_listxattr(struct dentry *, char *, size_t);
 extern int cifs_ioctl (struct inode * inode, struct file * filep,
                       unsigned int command, unsigned long arg);
-#define CIFS_VERSION   "1.48"
+#define CIFS_VERSION   "1.49"
 #endif                          /* _CIFSFS_H */
diff --git a/fs/cifs/cifsglob.h b/fs/cifs/cifsglob.h
index e4de8eba4780..23655de2f4a4 100644
--- a/fs/cifs/cifsglob.h
+++ b/fs/cifs/cifsglob.h
@@ -311,7 +311,7 @@ struct cifsFileInfo {
        /* lock scope id (0 if none) */
        struct file * pfile; /* needed for writepage */
        struct inode * pInode; /* needed for oplock break */
-        struct semaphore lock_sem;
+        struct mutex lock_mutex;
        struct list_head llist; /* list of byte range locks we have. */
        unsigned closePend:1;   /* file is marked to close */
        unsigned invalidHandle:1;  /* file closed via session abend */
diff --git a/fs/cifs/cifspdu.h b/fs/cifs/cifspdu.h
index 4d8948e8762c..d619ca7d1416 100644
--- a/fs/cifs/cifspdu.h
+++ b/fs/cifs/cifspdu.h
@@ -1388,7 +1388,7 @@ struct smb_t2_rsp {
 #define SMB_SET_POSIX_LOCK              0x208
 #define SMB_POSIX_OPEN                  0x209
 #define SMB_POSIX_UNLINK                0x20a
-#define SMB_SET_FILE_UNIX_INFO2
+#define SMB_SET_FILE_UNIX_INFO2         0x20b
 #define SMB_SET_FILE_BASIC_INFO2        0x3ec
 #define SMB_SET_FILE_RENAME_INFORMATION 0x3f2 /* BB check if qpathinfo too */
 #define SMB_FILE_ALL_INFO2              0x3fa
@@ -2109,22 +2109,40 @@ struct cifs_posix_acl { /* access conrol list  (ACL) */
 /* end of POSIX ACL definitions */
+/* POSIX Open Flags */
+#define SMB_O_RDONLY     0x1
+#define SMB_O_WRONLY    0x2
+#define SMB_O_RDWR      0x4
+#define SMB_O_CREAT     0x10
+#define SMB_O_EXCL      0x20
+#define SMB_O_TRUNC     0x40
+#define SMB_O_APPEND    0x80
+#define SMB_O_SYNC      0x100
+#define SMB_O_DIRECTORY 0x200
+#define SMB_O_NOFOLLOW  0x400
+#define SMB_O_DIRECT    0x800
 typedef struct {
-        __u32 OpenFlags; /* same as NT CreateX */
+        __le32 OpenFlags; /* same as NT CreateX */
-        __u32 PosixOpenFlags;
+        __le32 PosixOpenFlags;
-        __u32 Mode;
+        __le64 Permissions;
-        __u16 Level; /* reply level requested (see QPathInfo levels) */
+        __le16 Level; /* reply level requested (see QPathInfo levels) */
-        __u16 Pad;  /* reserved - MBZ */
 } __attribute__((packed)) OPEN_PSX_REQ; /* level 0x209 SetPathInfo data */
 typedef struct {
-        /* reply varies based on requested level */
+        __le16 OplockFlags;
+        __u16 Fid;
+        __le32 CreateAction;
+        __le16 ReturnedLevel;
+        __le16 Pad;
+        /* struct following varies based on requested level */
 } __attribute__((packed)) OPEN_PSX_RSP; /* level 0x209 SetPathInfo data */
 struct file_internal_info {
        __u64  UniqueId; /* inode number */
 } __attribute__((packed));      /* level 0x3ee */
 struct file_mode_info {
        __le32  Mode;
 } __attribute__((packed));      /* level 0x3f8 */
diff --git a/fs/cifs/cifsproto.h b/fs/cifs/cifsproto.h
index 32eb1acab630..5d163e2b6143 100644
--- a/fs/cifs/cifsproto.h
+++ b/fs/cifs/cifsproto.h
@@ -1,7 +1,7 @@
 /*
 *   fs/cifs/cifsproto.h
 *
- *   Copyright (c) International Business Machines  Corp., 2002,2006
+ *   Copyright (c) International Business Machines  Corp., 2002,2007
 *   Author(s): Steve French (sfrench@us.ibm.com)
 *
 *   This library is free software; you can redistribute it and/or modify
@@ -244,6 +244,11 @@ extern int SMBLegacyOpen(const int xid, struct cifsTconInfo *tcon,
                        const int access_flags, const int omode,
                        __u16 * netfid, int *pOplock, FILE_ALL_INFO *,
                        const struct nls_table *nls_codepage, int remap);
+extern int CIFSPOSIXCreate(const int xid, struct cifsTconInfo *tcon, 
+                        u32 posix_flags, __u64 mode, __u16 * netfid,
+                        FILE_UNIX_BASIC_INFO *pRetData,
+                        __u32 *pOplock, const char *name,
+                        const struct nls_table *nls_codepage, int remap);                       
 extern int CIFSSMBClose(const int xid, struct cifsTconInfo *tcon,
                        const int smb_file_id);
diff --git a/fs/cifs/cifssmb.c b/fs/cifs/cifssmb.c
index 48fc0c2ab0e5..14de58fa1437 100644
--- a/fs/cifs/cifssmb.c
+++ b/fs/cifs/cifssmb.c
@@ -1,7 +1,7 @@
 /*
 *   fs/cifs/cifssmb.c
 *
- *   Copyright (C) International Business Machines  Corp., 2002,2006
+ *   Copyright (C) International Business Machines  Corp., 2002,2007
 *   Author(s): Steve French (sfrench@us.ibm.com)
 *
 *   Contains the routines for constructing the SMB PDUs themselves
@@ -24,8 +24,8 @@
 /* SMB/CIFS PDU handling routines here - except for leftovers in connect.c   */
 /* These are mostly routines that operate on a pathname, or on a tree id     */
 /* (mounted volume), but there are eight handle based routines which must be */
- /* treated slightly different for reconnection purposes since we never want  */
+ /* treated slightly differently for reconnection purposes since we never     */
- /* to reuse a stale file handle and the caller knows the file handle */
+ /* want to reuse a stale file handle and only the caller knows the file info */
 #include <linux/fs.h>
 #include <linux/kernel.h>
@@ -913,6 +913,130 @@ MkDirRetry:
        return rc;
 }
+int
+CIFSPOSIXCreate(const int xid, struct cifsTconInfo *tcon, __u32 posix_flags,
+                __u64 mode, __u16 * netfid, FILE_UNIX_BASIC_INFO *pRetData,
+                __u32 *pOplock, const char *name, 
+                const struct nls_table *nls_codepage, int remap)
+{
+        TRANSACTION2_SPI_REQ *pSMB = NULL;
+        TRANSACTION2_SPI_RSP *pSMBr = NULL;
+        int name_len;
+        int rc = 0;
+        int bytes_returned = 0;
+        char *data_offset;
+        __u16 params, param_offset, offset, byte_count, count;
+        OPEN_PSX_REQ * pdata;
+        OPEN_PSX_RSP * psx_rsp;
+        cFYI(1, ("In POSIX Create"));
+PsxCreat:
+        rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
+                      (void **) &pSMBr);
+        if (rc)
+                return rc;
+        if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
+                name_len =
+                    cifsConvertToUCS((__le16 *) pSMB->FileName, name,
+                                     PATH_MAX, nls_codepage, remap);
+                name_len++;     /* trailing null */
+                name_len *= 2;
+        } else {        /* BB improve the check for buffer overruns BB */
+                name_len = strnlen(name, PATH_MAX);
+                name_len++;     /* trailing null */
+                strncpy(pSMB->FileName, name, name_len);
+        }
+        params = 6 + name_len;
+        count = sizeof(OPEN_PSX_REQ);
+        pSMB->MaxParameterCount = cpu_to_le16(2);
+        pSMB->MaxDataCount = cpu_to_le16(1000); /* large enough */
+        pSMB->MaxSetupCount = 0;
+        pSMB->Reserved = 0;
+        pSMB->Flags = 0;
+        pSMB->Timeout = 0;
+        pSMB->Reserved2 = 0;
+        param_offset = offsetof(struct smb_com_transaction2_spi_req,
+                                     InformationLevel) - 4;
+        offset = param_offset + params;
+        data_offset = (char *) (&pSMB->hdr.Protocol) + offset;
+        pdata = (OPEN_PSX_REQ *)(((char *)&pSMB->hdr.Protocol) + offset);
+        pdata->Level = SMB_QUERY_FILE_UNIX_BASIC;
+        pdata->Permissions = cpu_to_le64(mode);
+        pdata->PosixOpenFlags = cpu_to_le32(posix_flags); 
+        pdata->OpenFlags =  cpu_to_le32(*pOplock);
+        pSMB->ParameterOffset = cpu_to_le16(param_offset);
+        pSMB->DataOffset = cpu_to_le16(offset);
+        pSMB->SetupCount = 1;
+        pSMB->Reserved3 = 0;
+        pSMB->SubCommand = cpu_to_le16(TRANS2_SET_PATH_INFORMATION);
+        byte_count = 3 /* pad */  + params + count;
+        pSMB->DataCount = cpu_to_le16(count);
+        pSMB->ParameterCount = cpu_to_le16(params);
+        pSMB->TotalDataCount = pSMB->DataCount;
+        pSMB->TotalParameterCount = pSMB->ParameterCount;
+        pSMB->InformationLevel = cpu_to_le16(SMB_POSIX_OPEN);
+        pSMB->Reserved4 = 0;
+        pSMB->hdr.smb_buf_length += byte_count; 
+        pSMB->ByteCount = cpu_to_le16(byte_count);
+        rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
+                         (struct smb_hdr *) pSMBr, &bytes_returned, 0);
+        if (rc) {
+                cFYI(1, ("Posix create returned %d", rc));
+                goto psx_create_err;
+        }
+        cFYI(1,("copying inode info"));
+        rc = validate_t2((struct smb_t2_rsp *)pSMBr);
+        if (rc || (pSMBr->ByteCount < sizeof(OPEN_PSX_RSP))) {
+                rc = -EIO;      /* bad smb */
+                goto psx_create_err;
+        }
+        /* copy return information to pRetData */
+        psx_rsp = (OPEN_PSX_RSP *)((char *) &pSMBr->hdr.Protocol 
+                        + le16_to_cpu(pSMBr->t2.DataOffset));
+                
+        *pOplock = le16_to_cpu(psx_rsp->OplockFlags);
+        if(netfid)
+                *netfid = psx_rsp->Fid;   /* cifs fid stays in le */
+        /* Let caller know file was created so we can set the mode. */
+        /* Do we care about the CreateAction in any other cases? */
+        if(cpu_to_le32(FILE_CREATE) == psx_rsp->CreateAction)
+                *pOplock |= CIFS_CREATE_ACTION;
+        /* check to make sure response data is there */
+        if(psx_rsp->ReturnedLevel != SMB_QUERY_FILE_UNIX_BASIC) {
+                pRetData->Type = -1; /* unknown */
+#ifdef CONFIG_CIFS_DEBUG2
+                cFYI(1,("unknown type"));
+#endif
+        } else {
+                if(pSMBr->ByteCount < sizeof(OPEN_PSX_RSP) 
+                                        + sizeof(FILE_UNIX_BASIC_INFO)) {
+                        cERROR(1,("Open response data too small"));
+                        pRetData->Type = -1;
+                        goto psx_create_err;
+                }
+                memcpy((char *) pRetData, 
+                        (char *)psx_rsp + sizeof(OPEN_PSX_RSP),
+                        sizeof (FILE_UNIX_BASIC_INFO));
+        }
+                        
+psx_create_err:
+        cifs_buf_release(pSMB);
+        cifs_stats_inc(&tcon->num_mkdirs);
+        if (rc == -EAGAIN)
+                goto PsxCreat;
+        return rc;      
+}
 static __u16 convert_disposition(int disposition)
 {
        __u16 ofun = 0;
diff --git a/fs/cifs/connect.c b/fs/cifs/connect.c
index 20ba7dcc9959..216fb625843f 100644
--- a/fs/cifs/connect.c
+++ b/fs/cifs/connect.c
@@ -30,6 +30,7 @@
 #include <linux/mempool.h>
 #include <linux/delay.h>
 #include <linux/completion.h>
+#include <linux/kthread.h>
 #include <linux/pagevec.h>
 #include <linux/freezer.h>
 #include <asm/uaccess.h>
@@ -74,6 +75,8 @@ struct smb_vol {
        unsigned retry:1;
        unsigned intr:1;
        unsigned setuids:1;
+        unsigned override_uid:1;
+        unsigned override_gid:1;
        unsigned noperm:1;
        unsigned no_psx_acl:1; /* set if posix acl support should be disabled */
        unsigned cifs_acl:1;
@@ -120,7 +123,7 @@ cifs_reconnect(struct TCP_Server_Info *server)
        struct mid_q_entry * mid_entry;
        
        spin_lock(&GlobalMid_Lock);
-        if(server->tcpStatus == CifsExiting) {
+        if( kthread_should_stop() ) {
                /* the demux thread will exit normally 
                next time through the loop */
                spin_unlock(&GlobalMid_Lock);
@@ -182,7 +185,7 @@ cifs_reconnect(struct TCP_Server_Info *server)
        spin_unlock(&GlobalMid_Lock);
        up(&server->tcpSem); 
-        while ((server->tcpStatus != CifsExiting) && (server->tcpStatus != CifsGood))
+        while ( (!kthread_should_stop()) && (server->tcpStatus != CifsGood))
        {
                try_to_freeze();
                if(server->protocolType == IPV6) {
@@ -199,7 +202,7 @@ cifs_reconnect(struct TCP_Server_Info *server)
                } else {
                        atomic_inc(&tcpSesReconnectCount);
                        spin_lock(&GlobalMid_Lock);
-                        if(server->tcpStatus != CifsExiting)
+                        if( !kthread_should_stop() )
                                server->tcpStatus = CifsGood;
                        server->sequence_number = 0;
                        spin_unlock(&GlobalMid_Lock);                   
@@ -345,7 +348,6 @@ cifs_demultiplex_thread(struct TCP_Server_Info *server)
        int isMultiRsp;
        int reconnect;
-        daemonize("cifsd");
        allow_signal(SIGKILL);
        current->flags |= PF_MEMALLOC;
        server->tsk = current;  /* save process info to wake at shutdown */
@@ -361,7 +363,7 @@ cifs_demultiplex_thread(struct TCP_Server_Info *server)
                        GFP_KERNEL);
        }
-        while (server->tcpStatus != CifsExiting) {
+        while (!kthread_should_stop()) {
                if (try_to_freeze())
                        continue;
                if (bigbuf == NULL) {
@@ -400,7 +402,7 @@ cifs_demultiplex_thread(struct TCP_Server_Info *server)
                    kernel_recvmsg(csocket, &smb_msg,
                                 &iov, 1, 4, 0 /* BB see socket.h flags */);
-                if (server->tcpStatus == CifsExiting) {
+                if ( kthread_should_stop() ) {
                        break;
                } else if (server->tcpStatus == CifsNeedReconnect) {
                        cFYI(1, ("Reconnect after server stopped responding"));
@@ -524,7 +526,7 @@ cifs_demultiplex_thread(struct TCP_Server_Info *server)
                     total_read += length) {
                        length = kernel_recvmsg(csocket, &smb_msg, &iov, 1,
                                                pdu_length - total_read, 0);
-                        if((server->tcpStatus == CifsExiting) ||
+                        if( kthread_should_stop() ||
                            (length == -EINTR)) {
                                /* then will exit */
                                reconnect = 2;
@@ -757,7 +759,6 @@ multi_t2_fnd:
                        GFP_KERNEL);
        }
        
-        complete_and_exit(&cifsd_complete, 0);
        return 0;
 }
@@ -973,7 +974,7 @@ cifs_parse_mount_options(char *options, const char *devname,struct smb_vol *vol)
                        }
                        if ((temp_len = strnlen(value, 300)) < 300) {
                                vol->UNC = kmalloc(temp_len+1,GFP_KERNEL);
-                                if(vol->UNC == NULL)
+                                if (vol->UNC == NULL)
                                        return 1;
                                strcpy(vol->UNC,value);
                                if (strncmp(vol->UNC, "//", 2) == 0) {
@@ -1010,12 +1011,12 @@ cifs_parse_mount_options(char *options, const char *devname,struct smb_vol *vol)
                                return 1;       /* needs_arg; */
                        }
                        if ((temp_len = strnlen(value, 1024)) < 1024) {
-                                if(value[0] != '/')
+                                if (value[0] != '/')
                                        temp_len++;  /* missing leading slash */
                                vol->prepath = kmalloc(temp_len+1,GFP_KERNEL);
-                                if(vol->prepath == NULL)
+                                if (vol->prepath == NULL)
                                        return 1;
-                                if(value[0] != '/') {
+                                if (value[0] != '/') {
                                        vol->prepath[0] = '/';
                                        strcpy(vol->prepath+1,value);
                                } else
@@ -1031,7 +1032,7 @@ cifs_parse_mount_options(char *options, const char *devname,struct smb_vol *vol)
                                return 1;       /* needs_arg; */
                        }
                        if (strnlen(value, 65) < 65) {
-                                if(strnicmp(value,"default",7))
+                                if (strnicmp(value,"default",7))
                                        vol->iocharset = value;
                                /* if iocharset not set load_nls_default used by caller */
                                cFYI(1, ("iocharset set to %s",value));
@@ -1043,11 +1044,13 @@ cifs_parse_mount_options(char *options, const char *devname,struct smb_vol *vol)
                        if (value && *value) {
                                vol->linux_uid =
                                        simple_strtoul(value, &value, 0);
+                                vol->override_uid = 1;
                        }
                } else if (strnicmp(data, "gid", 3) == 0) {
                        if (value && *value) {
                                vol->linux_gid =
                                        simple_strtoul(value, &value, 0);
+                                vol->override_gid = 1;
                        }
                } else if (strnicmp(data, "file_mode", 4) == 0) {
                        if (value && *value) {
@@ -1102,7 +1105,7 @@ cifs_parse_mount_options(char *options, const char *devname,struct smb_vol *vol)
                                }
                                /* The string has 16th byte zero still from
                                set at top of the function  */
-                                if((i==15) && (value[i] != 0))
+                                if ((i==15) && (value[i] != 0))
                                        printk(KERN_WARNING "CIFS: netbiosname longer than 15 truncated.\n");
                        }
                } else if (strnicmp(data, "servern", 7) == 0) {
@@ -1126,7 +1129,7 @@ cifs_parse_mount_options(char *options, const char *devname,struct smb_vol *vol)
                                }
                                /* The string has 16th byte zero still from
                                   set at top of the function  */
-                                if((i==15) && (value[i] != 0))
+                                if ((i==15) && (value[i] != 0))
                                        printk(KERN_WARNING "CIFS: server netbiosname longer than 15 truncated.\n");
                        }
                } else if (strnicmp(data, "credentials", 4) == 0) {
@@ -1233,13 +1236,13 @@ cifs_parse_mount_options(char *options, const char *devname,struct smb_vol *vol)
                        printk(KERN_WARNING "CIFS: Unknown mount option %s\n",data);
        }
        if (vol->UNC == NULL) {
-                if(devname == NULL) {
+                if (devname == NULL) {
                        printk(KERN_WARNING "CIFS: Missing UNC name for mount target\n");
                        return 1;
                }
                if ((temp_len = strnlen(devname, 300)) < 300) {
                        vol->UNC = kmalloc(temp_len+1,GFP_KERNEL);
-                        if(vol->UNC == NULL)
+                        if (vol->UNC == NULL)
                                return 1;
                        strcpy(vol->UNC,devname);
                        if (strncmp(vol->UNC, "//", 2) == 0) {
@@ -1663,7 +1666,13 @@ void reset_cifs_unix_caps(int xid, struct cifsTconInfo * tcon,
                                CIFS_SB(sb)->mnt_cifs_flags |= 
                                        CIFS_MOUNT_POSIX_PATHS;
                }
-                        
+        
+                /* We might be setting the path sep back to a different
+                form if we are reconnecting and the server switched its
+                posix path capability for this share */ 
+                if(sb && (CIFS_SB(sb)->prepathlen > 0))
+                        CIFS_SB(sb)->prepath[0] = CIFS_DIR_SEP(CIFS_SB(sb));
+        
                cFYI(1,("Negotiate caps 0x%x",(int)cap));
 #ifdef CONFIG_CIFS_DEBUG2
                if(cap & CIFS_UNIX_FCNTL_CAP)
@@ -1712,12 +1721,12 @@ cifs_mount(struct super_block *sb, struct cifs_sb_info *cifs_sb,
                return -EINVAL;
        }
-        if (volume_info.username) {
+        if (volume_info.nullauth) {
+                cFYI(1,("null user"));
+                volume_info.username = NULL;
+        } else if (volume_info.username) {
                /* BB fixme parse for domain name here */
                cFYI(1, ("Username: %s ", volume_info.username));
-        } else if (volume_info.nullauth) {
-                cFYI(1,("null user"));
        } else {
                cifserror("No username specified");
        /* In userspace mount helper we can get user name from alternate
@@ -1791,11 +1800,12 @@ cifs_mount(struct super_block *sb, struct cifs_sb_info *cifs_sb,
                existingCifsSes = cifs_find_tcp_session(&sin_server.sin_addr,
                        NULL /* no ipv6 addr */,
                        volume_info.username, &srvTcp);
-        else if(address_type == AF_INET6)
+        else if(address_type == AF_INET6) {
+                cFYI(1,("looking for ipv6 address"));
                existingCifsSes = cifs_find_tcp_session(NULL /* no ipv4 addr */,
                        &sin_server6.sin6_addr,
                        volume_info.username, &srvTcp);
-        else {
+        } else {
                kfree(volume_info.UNC);
                kfree(volume_info.password);
                kfree(volume_info.prepath);
@@ -1807,17 +1817,23 @@ cifs_mount(struct super_block *sb, struct cifs_sb_info *cifs_sb,
        if (srvTcp) {
                cFYI(1, ("Existing tcp session with server found"));                
        } else {        /* create socket */
-                if(volume_info.port)
+                if (volume_info.port)
                        sin_server.sin_port = htons(volume_info.port);
                else
                        sin_server.sin_port = 0;
-                rc = ipv4_connect(&sin_server,&csocket,
+                if (address_type == AF_INET6) {
+                        cFYI(1,("attempting ipv6 connect"));
+                        /* BB should we allow ipv6 on port 139? */
+                        /* other OS never observed in Wild doing 139 with v6 */
+                        rc = ipv6_connect(&sin_server6,&csocket);
+                } else 
+                        rc = ipv4_connect(&sin_server,&csocket,
                                  volume_info.source_rfc1001_name,
                                  volume_info.target_rfc1001_name);
                if (rc < 0) {
                        cERROR(1,
-                               ("Error connecting to IPv4 socket. Aborting operation"));
+                               ("Error connecting to IPv4 socket. Aborting operation"));                               
-                        if(csocket != NULL)
+                        if (csocket != NULL)
                                sock_release(csocket);
                        kfree(volume_info.UNC);
                        kfree(volume_info.password);
@@ -1850,10 +1866,11 @@ cifs_mount(struct super_block *sb, struct cifs_sb_info *cifs_sb,
                        so no need to spinlock this init of tcpStatus */
                        srvTcp->tcpStatus = CifsNew;
                        init_MUTEX(&srvTcp->tcpSem);
-                        rc = (int)kernel_thread((void *)(void *)cifs_demultiplex_thread, srvTcp,
+                        srvTcp->tsk = kthread_run((void *)(void *)cifs_demultiplex_thread, srvTcp, "cifsd");
-                                      CLONE_FS | CLONE_FILES | CLONE_VM);
+                        if ( IS_ERR(srvTcp->tsk) ) {
-                        if(rc < 0) {
+                                rc = PTR_ERR(srvTcp->tsk);
-                                rc = -ENOMEM;
+                                cERROR(1,("error %d create cifsd thread", rc));
+                                srvTcp->tsk = NULL;
                                sock_release(csocket);
                                kfree(volume_info.UNC);
                                kfree(volume_info.password);
@@ -1896,7 +1913,7 @@ cifs_mount(struct super_block *sb, struct cifs_sb_info *cifs_sb,
                                int len = strlen(volume_info.domainname);
                                pSesInfo->domainName = 
                                        kmalloc(len + 1, GFP_KERNEL);
-                                if(pSesInfo->domainName)
+                                if (pSesInfo->domainName)
                                        strcpy(pSesInfo->domainName,
                                                volume_info.domainname);
                        }
@@ -1906,7 +1923,7 @@ cifs_mount(struct super_block *sb, struct cifs_sb_info *cifs_sb,
                        /* BB FIXME need to pass vol->secFlgs BB */
                        rc = cifs_setup_session(xid,pSesInfo, cifs_sb->local_nls);
                        up(&pSesInfo->sesSem);
-                        if(!rc)
+                        if (!rc)
                                atomic_inc(&srvTcp->socketUseCount);
                } else
                        kfree(volume_info.password);
@@ -1914,7 +1931,7 @@ cifs_mount(struct super_block *sb, struct cifs_sb_info *cifs_sb,
    
        /* search for existing tcon to this server share */
        if (!rc) {
-                if(volume_info.rsize > CIFSMaxBufSize) {
+                if (volume_info.rsize > CIFSMaxBufSize) {
                        cERROR(1,("rsize %d too large, using MaxBufSize",
                                volume_info.rsize));
                        cifs_sb->rsize = CIFSMaxBufSize;
@@ -1923,11 +1940,11 @@ cifs_mount(struct super_block *sb, struct cifs_sb_info *cifs_sb,
                else /* default */
                        cifs_sb->rsize = CIFSMaxBufSize;
-                if(volume_info.wsize > PAGEVEC_SIZE * PAGE_CACHE_SIZE) {
+                if (volume_info.wsize > PAGEVEC_SIZE * PAGE_CACHE_SIZE) {
                        cERROR(1,("wsize %d too large using 4096 instead",
                                  volume_info.wsize));
                        cifs_sb->wsize = 4096;
-                } else if(volume_info.wsize)
+                } else if (volume_info.wsize)
                        cifs_sb->wsize = volume_info.wsize;
                else
                        cifs_sb->wsize = 
@@ -1940,14 +1957,14 @@ cifs_mount(struct super_block *sb, struct cifs_sb_info *cifs_sb,
                           conjunction with 52K kvec constraint on arch with 4K
                           page size  */
-                if(cifs_sb->rsize < 2048) {
+                if (cifs_sb->rsize < 2048) {
                        cifs_sb->rsize = 2048; 
                        /* Windows ME may prefer this */
                        cFYI(1,("readsize set to minimum 2048"));
                }
                /* calculate prepath */
                cifs_sb->prepath = volume_info.prepath;
-                if(cifs_sb->prepath) {
+                if (cifs_sb->prepath) {
                        cifs_sb->prepathlen = strlen(cifs_sb->prepath);
                        cifs_sb->prepath[0] = CIFS_DIR_SEP(cifs_sb);
                        volume_info.prepath = NULL;
@@ -1960,24 +1977,27 @@ cifs_mount(struct super_block *sb, struct cifs_sb_info *cifs_sb,
                cFYI(1,("file mode: 0x%x  dir mode: 0x%x",
                        cifs_sb->mnt_file_mode,cifs_sb->mnt_dir_mode));
-                if(volume_info.noperm)
+                if (volume_info.noperm)
                        cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_PERM;
-                if(volume_info.setuids)
+                if (volume_info.setuids)
                        cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_SET_UID;
-                if(volume_info.server_ino)
+                if (volume_info.server_ino)
                        cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_SERVER_INUM;
-                if(volume_info.remap)
+                if (volume_info.remap)
                        cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_MAP_SPECIAL_CHR;
-                if(volume_info.no_xattr)
+                if (volume_info.no_xattr)
                        cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_XATTR;
-                if(volume_info.sfu_emul)
+                if (volume_info.sfu_emul)
                        cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_UNX_EMUL;
-                if(volume_info.nobrl)
+                if (volume_info.nobrl)
                        cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_BRL;
-                if(volume_info.cifs_acl)
+                if (volume_info.cifs_acl)
                        cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_CIFS_ACL;
+                if (volume_info.override_uid)
-                if(volume_info.direct_io) {
+                        cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_OVERR_UID;
+                if (volume_info.override_gid)
+                        cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_OVERR_GID;
+                if (volume_info.direct_io) {
                        cFYI(1,("mounting share using direct i/o"));
                        cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_DIRECT_IO;
                }
@@ -2030,7 +2050,7 @@ cifs_mount(struct super_block *sb, struct cifs_sb_info *cifs_sb,
                        }
                }
        }
-        if(pSesInfo) {
+        if (pSesInfo) {
                if (pSesInfo->capabilities & CAP_LARGE_FILES) {
                        sb->s_maxbytes = (u64) 1 << 63;
                } else
@@ -2044,13 +2064,13 @@ cifs_mount(struct super_block *sb, struct cifs_sb_info *cifs_sb,
        if (rc) {
                /* if session setup failed, use count is zero but
                we still need to free cifsd thread */
-                if(atomic_read(&srvTcp->socketUseCount) == 0) {
+                if (atomic_read(&srvTcp->socketUseCount) == 0) {
                        spin_lock(&GlobalMid_Lock);
                        srvTcp->tcpStatus = CifsExiting;
                        spin_unlock(&GlobalMid_Lock);
-                        if(srvTcp->tsk) {
+                        if (srvTcp->tsk) {
                                send_sig(SIGKILL,srvTcp->tsk,1);
-                                wait_for_completion(&cifsd_complete);
+                                kthread_stop(srvTcp->tsk);
                        }
                }
                 /* If find_unc succeeded then rc == 0 so we can not end */
@@ -2063,10 +2083,10 @@ cifs_mount(struct super_block *sb, struct cifs_sb_info *cifs_sb,
                                        int temp_rc;
                                        temp_rc = CIFSSMBLogoff(xid, pSesInfo);
                                        /* if the socketUseCount is now zero */
-                                        if((temp_rc == -ESHUTDOWN) &&
+                                        if ((temp_rc == -ESHUTDOWN) &&
-                                           (pSesInfo->server->tsk)) {
+                                           (pSesInfo->server) && (pSesInfo->server->tsk)) {
                                                send_sig(SIGKILL,pSesInfo->server->tsk,1);
-                                                wait_for_completion(&cifsd_complete);
+                                                kthread_stop(pSesInfo->server->tsk);
                                        }
                                } else
                                        cFYI(1, ("No session or bad tcon"));
@@ -2127,7 +2147,7 @@ CIFSSessSetup(unsigned int xid, struct cifsSesInfo *ses,
        __u16 count;
        cFYI(1, ("In sesssetup"));
-        if(ses == NULL)
+        if (ses == NULL)
                return -EINVAL;
        user = ses->userName;
        domain = ses->domainName;
@@ -2182,7 +2202,7 @@ CIFSSessSetup(unsigned int xid, struct cifsSesInfo *ses,
                        *bcc_ptr = 0;
                        bcc_ptr++;
                }
-                if(user == NULL)
+                if (user == NULL)
                        bytes_returned = 0; /* skip null user */
                else
                        bytes_returned =
@@ -2216,7 +2236,7 @@ CIFSSessSetup(unsigned int xid, struct cifsSesInfo *ses,
                bcc_ptr += 2 * bytes_returned;
                bcc_ptr += 2;
        } else {
-                if(user != NULL) {                
+                if (user != NULL) {                
                    strncpy(bcc_ptr, user, 200);
                    bcc_ptr += strnlen(user, 200);
                }
@@ -3316,7 +3336,7 @@ cifs_umount(struct super_block *sb, struct cifs_sb_info *cifs_sb)
                                cFYI(1,("Waking up socket by sending it signal"));
                                if(cifsd_task) {
                                        send_sig(SIGKILL,cifsd_task,1);
-                                        wait_for_completion(&cifsd_complete);
+                                        kthread_stop(cifsd_task);
                                }
                                rc = 0;
                        } /* else - we have an smb session
diff --git a/fs/cifs/dir.c b/fs/cifs/dir.c
index 3fad638d26d3..e5210519ac4b 100644
--- a/fs/cifs/dir.c
+++ b/fs/cifs/dir.c
@@ -274,7 +274,7 @@ cifs_create(struct inode *inode, struct dentry *direntry, int mode,
                        pCifsFile->invalidHandle = FALSE;
                        pCifsFile->closePend     = FALSE;
                        init_MUTEX(&pCifsFile->fh_sem);
-                        init_MUTEX(&pCifsFile->lock_sem);
+                        mutex_init(&pCifsFile->lock_mutex);
                        INIT_LIST_HEAD(&pCifsFile->llist);
                        atomic_set(&pCifsFile->wrtPending,0);
diff --git a/fs/cifs/file.c b/fs/cifs/file.c
index 2d3275bedb55..b570530f97bf 100644
--- a/fs/cifs/file.c
+++ b/fs/cifs/file.c
@@ -48,7 +48,7 @@ static inline struct cifsFileInfo *cifs_init_private(
        private_data->netfid = netfid;
        private_data->pid = current->tgid;      
        init_MUTEX(&private_data->fh_sem);
-        init_MUTEX(&private_data->lock_sem);
+        mutex_init(&private_data->lock_mutex);
        INIT_LIST_HEAD(&private_data->llist);
        private_data->pfile = file; /* needed for writepage */
        private_data->pInode = inode;
@@ -338,8 +338,7 @@ static int cifs_relock_file(struct cifsFileInfo *cifsFile)
        return rc;
 }
-static int cifs_reopen_file(struct inode *inode, struct file *file, 
+static int cifs_reopen_file(struct file *file, int can_flush)
-        int can_flush)
 {
        int rc = -EACCES;
        int xid, oplock;
@@ -347,13 +346,12 @@ static int cifs_reopen_file(struct inode *inode, struct file *file,
        struct cifsTconInfo *pTcon;
        struct cifsFileInfo *pCifsFile;
        struct cifsInodeInfo *pCifsInode;
+        struct inode * inode;
        char *full_path = NULL;
        int desiredAccess;
        int disposition = FILE_OPEN;
        __u16 netfid;
-        if (inode == NULL)
-                return -EBADF;
        if (file->private_data) {
                pCifsFile = (struct cifsFileInfo *)file->private_data;
        } else
@@ -368,25 +366,37 @@ static int cifs_reopen_file(struct inode *inode, struct file *file,
        }
        if (file->f_path.dentry == NULL) {
-                up(&pCifsFile->fh_sem);
+                cERROR(1, ("no valid name if dentry freed"));
-                cFYI(1, ("failed file reopen, no valid name if dentry freed"));
+                dump_stack();
-                FreeXid(xid);
+                rc = -EBADF;
-                return -EBADF;
+                goto reopen_error_exit;
        }
+        inode = file->f_path.dentry->d_inode;
+        if(inode == NULL) {
+                cERROR(1, ("inode not valid"));
+                dump_stack();
+                rc = -EBADF;
+                goto reopen_error_exit;
+        }
+                
        cifs_sb = CIFS_SB(inode->i_sb);
        pTcon = cifs_sb->tcon;
 /* can not grab rename sem here because various ops, including
   those that already have the rename sem can end up causing writepage
   to get called and if the server was down that means we end up here,
   and we can never tell if the caller already has the rename_sem */
        full_path = build_path_from_dentry(file->f_path.dentry);
        if (full_path == NULL) {
+                rc = -ENOMEM;
+reopen_error_exit:
                up(&pCifsFile->fh_sem);
                FreeXid(xid);
-                return -ENOMEM;
+                return rc;
        }
-        cFYI(1, (" inode = 0x%p file flags are 0x%x for %s",
+        cFYI(1, ("inode = 0x%p file flags 0x%x for %s",
                 inode, file->f_flags,full_path));
        desiredAccess = cifs_convert_flags(file->f_flags);
@@ -401,13 +411,6 @@ static int cifs_reopen_file(struct inode *inode, struct file *file,
           and server version of file size can be stale. If we knew for sure
           that inode was not dirty locally we could do this */
-/*      buf = kmalloc(sizeof(FILE_ALL_INFO), GFP_KERNEL);
-        if (buf == 0) {
-                up(&pCifsFile->fh_sem);
-                kfree(full_path);
-                FreeXid(xid);
-                return -ENOMEM;
-        } */
        rc = CIFSSMBOpen(xid, pTcon, full_path, disposition, desiredAccess,
                         CREATE_NOT_DIR, &netfid, &oplock, NULL,
                         cifs_sb->local_nls, cifs_sb->mnt_cifs_flags & 
@@ -508,12 +511,12 @@ int cifs_close(struct inode *inode, struct file *file)
                /* Delete any outstanding lock records.
                   We'll lose them when the file is closed anyway. */
-                down(&pSMBFile->lock_sem);
+                mutex_lock(&pSMBFile->lock_mutex);
                list_for_each_entry_safe(li, tmp, &pSMBFile->llist, llist) {
                        list_del(&li->llist);
                        kfree(li);
                }
-                up(&pSMBFile->lock_sem);
+                mutex_unlock(&pSMBFile->lock_mutex);
                write_lock(&GlobalSMBSeslock);
                list_del(&pSMBFile->flist);
@@ -598,9 +601,9 @@ static int store_file_lock(struct cifsFileInfo *fid, __u64 len,
        li->offset = offset;
        li->length = len;
        li->type = lockType;
-        down(&fid->lock_sem);
+        mutex_lock(&fid->lock_mutex);
        list_add(&li->llist, &fid->llist);
-        up(&fid->lock_sem);
+        mutex_unlock(&fid->lock_mutex);
        return 0;
 }
@@ -757,7 +760,7 @@ int cifs_lock(struct file *file, int cmd, struct file_lock *pfLock)
                        struct cifsLockInfo *li, *tmp;
                        rc = 0;
-                        down(&fid->lock_sem);
+                        mutex_lock(&fid->lock_mutex);
                        list_for_each_entry_safe(li, tmp, &fid->llist, llist) {
                                if (pfLock->fl_start <= li->offset &&
                                                length >= li->length) {
@@ -771,7 +774,7 @@ int cifs_lock(struct file *file, int cmd, struct file_lock *pfLock)
                                        kfree(li);
                                }
                        }
-                        up(&fid->lock_sem);
+                        mutex_unlock(&fid->lock_mutex);
                }
        }
@@ -792,12 +795,7 @@ ssize_t cifs_user_write(struct file *file, const char __user *write_data,
        int xid, long_op;
        struct cifsFileInfo *open_file;
-        if (file->f_path.dentry == NULL)
-                return -EBADF;
        cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
-        if (cifs_sb == NULL)
-                return -EBADF;
        pTcon = cifs_sb->tcon;
@@ -807,14 +805,9 @@ ssize_t cifs_user_write(struct file *file, const char __user *write_data,
        if (file->private_data == NULL)
                return -EBADF;
-        else
+        open_file = (struct cifsFileInfo *) file->private_data;
-                open_file = (struct cifsFileInfo *) file->private_data;
        
        xid = GetXid();
-        if (file->f_path.dentry->d_inode == NULL) {
-                FreeXid(xid);
-                return -EBADF;
-        }
        if (*poffset > file->f_path.dentry->d_inode->i_size)
                long_op = 2; /* writes past end of file can take a long time */
@@ -841,17 +834,11 @@ ssize_t cifs_user_write(struct file *file, const char __user *write_data,
                                        return -EBADF;
                        }
                        if (open_file->invalidHandle) {
-                                if ((file->f_path.dentry == NULL) ||
-                                    (file->f_path.dentry->d_inode == NULL)) {
-                                        FreeXid(xid);
-                                        return total_written;
-                                }
                                /* we could deadlock if we called
                                   filemap_fdatawait from here so tell
                                   reopen_file not to flush data to server
                                   now */
-                                rc = cifs_reopen_file(file->f_path.dentry->d_inode,
+                                rc = cifs_reopen_file(file, FALSE);
-                                        file, FALSE);
                                if (rc != 0)
                                        break;
                        }
@@ -908,12 +895,7 @@ static ssize_t cifs_write(struct file *file, const char *write_data,
        int xid, long_op;
        struct cifsFileInfo *open_file;
-        if (file->f_path.dentry == NULL)
-                return -EBADF;
        cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
-        if (cifs_sb == NULL)
-                return -EBADF;
        pTcon = cifs_sb->tcon;
@@ -922,14 +904,9 @@ static ssize_t cifs_write(struct file *file, const char *write_data,
        if (file->private_data == NULL)
                return -EBADF;
-        else
+        open_file = (struct cifsFileInfo *)file->private_data;
-                open_file = (struct cifsFileInfo *)file->private_data;
        
        xid = GetXid();
-        if (file->f_path.dentry->d_inode == NULL) {
-                FreeXid(xid);
-                return -EBADF;
-        }
        if (*poffset > file->f_path.dentry->d_inode->i_size)
                long_op = 2; /* writes past end of file can take a long time */
@@ -957,17 +934,11 @@ static ssize_t cifs_write(struct file *file, const char *write_data,
                                        return -EBADF;
                        }
                        if (open_file->invalidHandle) {
-                                if ((file->f_path.dentry == NULL) ||
-                                   (file->f_path.dentry->d_inode == NULL)) {
-                                        FreeXid(xid);
-                                        return total_written;
-                                }
                                /* we could deadlock if we called
                                   filemap_fdatawait from here so tell
                                   reopen_file not to flush data to 
                                   server now */
-                                rc = cifs_reopen_file(file->f_path.dentry->d_inode,
+                                rc = cifs_reopen_file(file, FALSE);
-                                        file, FALSE);
                                if (rc != 0)
                                        break;
                        }
@@ -1056,8 +1027,7 @@ struct cifsFileInfo *find_writable_file(struct cifsInodeInfo *cifs_inode)
                        read_unlock(&GlobalSMBSeslock);
                        if((open_file->invalidHandle) && 
                           (!open_file->closePend) /* BB fixme -since the second clause can not be true remove it BB */) {
-                                rc = cifs_reopen_file(&cifs_inode->vfs_inode, 
+                                rc = cifs_reopen_file(open_file->pfile, FALSE);
-                                                      open_file->pfile, FALSE);
                                /* if it fails, try another handle - might be */
                                /* dangerous to hold up writepages with retry */
                                if(rc) {
@@ -1404,32 +1374,6 @@ static int cifs_commit_write(struct file *file, struct page *page,
        spin_lock(&inode->i_lock);
        if (position > inode->i_size) {
                i_size_write(inode, position);
-                /* if (file->private_data == NULL) {
-                        rc = -EBADF;
-                } else {
-                        open_file = (struct cifsFileInfo *)file->private_data;
-                        cifs_sb = CIFS_SB(inode->i_sb);
-                        rc = -EAGAIN;
-                        while (rc == -EAGAIN) {
-                                if ((open_file->invalidHandle) && 
-                                    (!open_file->closePend)) {
-                                        rc = cifs_reopen_file(
-                                                file->f_path.dentry->d_inode, file);
-                                        if (rc != 0)
-                                                break;
-                                }
-                                if (!open_file->closePend) {
-                                        rc = CIFSSMBSetFileSize(xid,
-                                                cifs_sb->tcon, position,
-                                                open_file->netfid,
-                                                open_file->pid, FALSE);
-                                } else {
-                                        rc = -EBADF;
-                                        break;
-                                }
-                        }
-                        cFYI(1, (" SetEOF (commit write) rc = %d", rc));
-                } */
        }
        spin_unlock(&inode->i_lock);
        if (!PageUptodate(page)) {
@@ -1573,8 +1517,7 @@ ssize_t cifs_user_read(struct file *file, char __user *read_data,
                        int buf_type = CIFS_NO_BUFFER;
                        if ((open_file->invalidHandle) && 
                            (!open_file->closePend)) {
-                                rc = cifs_reopen_file(file->f_path.dentry->d_inode,
+                                rc = cifs_reopen_file(file, TRUE);
-                                        file, TRUE);
                                if (rc != 0)
                                        break;
                        }
@@ -1660,8 +1603,7 @@ static ssize_t cifs_read(struct file *file, char *read_data, size_t read_size,
                while (rc == -EAGAIN) {
                        if ((open_file->invalidHandle) && 
                            (!open_file->closePend)) {
-                                rc = cifs_reopen_file(file->f_path.dentry->d_inode,
+                                rc = cifs_reopen_file(file, TRUE);
-                                        file, TRUE);
                                if (rc != 0)
                                        break;
                        }
@@ -1817,8 +1759,7 @@ static int cifs_readpages(struct file *file, struct address_space *mapping,
                while (rc == -EAGAIN) {
                        if ((open_file->invalidHandle) && 
                            (!open_file->closePend)) {
-                                rc = cifs_reopen_file(file->f_path.dentry->d_inode,
+                                rc = cifs_reopen_file(file, TRUE);
-                                        file, TRUE);
                                if (rc != 0)
                                        break;
                        }
diff --git a/fs/cifs/inode.c b/fs/cifs/inode.c
index f414526e476a..3e87dad3367c 100644
--- a/fs/cifs/inode.c
+++ b/fs/cifs/inode.c
@@ -1,7 +1,7 @@
 /*
 *   fs/cifs/inode.c
 *
- *   Copyright (C) International Business Machines  Corp., 2002,2005
+ *   Copyright (C) International Business Machines  Corp., 2002,2007
 *   Author(s): Steve French (sfrench@us.ibm.com)
 *
 *   This library is free software; you can redistribute it and/or modify
@@ -90,7 +90,7 @@ int cifs_get_inode_info_unix(struct inode **pinode,
                                (*pinode)->i_ino =
                                        (unsigned long)findData.UniqueId;
                        } /* note ino incremented to unique num in new_inode */
-                        if(sb->s_flags & MS_NOATIME)
+                        if (sb->s_flags & MS_NOATIME)
                                (*pinode)->i_flags |= S_NOATIME | S_NOCMTIME;
                                
                        insert_inode_hash(*pinode);
@@ -139,8 +139,17 @@ int cifs_get_inode_info_unix(struct inode **pinode,
                        inode->i_mode |= S_IFREG;
                        cFYI(1,("unknown type %d",type));
                }
-                inode->i_uid = le64_to_cpu(findData.Uid);
+                
-                inode->i_gid = le64_to_cpu(findData.Gid);
+                if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_UID)
+                        inode->i_uid = cifs_sb->mnt_uid;
+                else
+                        inode->i_uid = le64_to_cpu(findData.Uid);
+                if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_GID)
+                        inode->i_gid = cifs_sb->mnt_gid;
+                else
+                        inode->i_gid = le64_to_cpu(findData.Gid);
+                        
                inode->i_nlink = le64_to_cpu(findData.Nlinks);
                spin_lock(&inode->i_lock);
@@ -178,13 +187,13 @@ int cifs_get_inode_info_unix(struct inode **pinode,
                                                &cifs_file_direct_nobrl_ops;
                                else
                                        inode->i_fop = &cifs_file_direct_ops;
-                        } else if(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_BRL)
+                        } else if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_BRL)
                                inode->i_fop = &cifs_file_nobrl_ops;
                        else /* not direct, send byte range locks */ 
                                inode->i_fop = &cifs_file_ops;
                        /* check if server can support readpages */
-                        if(pTcon->ses->server->maxBuf < 
+                        if (pTcon->ses->server->maxBuf < 
                            PAGE_CACHE_SIZE + MAX_CIFS_HDR_SIZE)
                                inode->i_data.a_ops = &cifs_addr_ops_smallbuf;
                        else
@@ -220,7 +229,7 @@ static int decode_sfu_inode(struct inode * inode, __u64 size,
        pbuf = buf;
-        if(size == 0) {
+        if (size == 0) {
                inode->i_mode |= S_IFIFO;
                return 0;
        } else if (size < 8) {
@@ -239,11 +248,11 @@ static int decode_sfu_inode(struct inode * inode, __u64 size,
                                 netfid,
                                 24 /* length */, 0 /* offset */,
                                 &bytes_read, &pbuf, &buf_type);
-                if((rc == 0) && (bytes_read >= 8)) {
+                if ((rc == 0) && (bytes_read >= 8)) {
-                        if(memcmp("IntxBLK", pbuf, 8) == 0) {
+                        if (memcmp("IntxBLK", pbuf, 8) == 0) {
                                cFYI(1,("Block device"));
                                inode->i_mode |= S_IFBLK;
-                                if(bytes_read == 24) {
+                                if (bytes_read == 24) {
                                        /* we have enough to decode dev num */
                                        __u64 mjr; /* major */
                                        __u64 mnr; /* minor */
@@ -251,10 +260,10 @@ static int decode_sfu_inode(struct inode * inode, __u64 size,
                                        mnr = le64_to_cpu(*(__le64 *)(pbuf+16));
                                        inode->i_rdev = MKDEV(mjr, mnr);
                                }
-                        } else if(memcmp("IntxCHR", pbuf, 8) == 0) {
+                        } else if (memcmp("IntxCHR", pbuf, 8) == 0) {
                                cFYI(1,("Char device"));
                                inode->i_mode |= S_IFCHR;
-                                if(bytes_read == 24) {
+                                if (bytes_read == 24) {
                                        /* we have enough to decode dev num */
                                        __u64 mjr; /* major */
                                        __u64 mnr; /* minor */
@@ -262,7 +271,7 @@ static int decode_sfu_inode(struct inode * inode, __u64 size,
                                        mnr = le64_to_cpu(*(__le64 *)(pbuf+16));
                                        inode->i_rdev = MKDEV(mjr, mnr);
                                }
-                        } else if(memcmp("IntxLNK", pbuf, 7) == 0) {
+                        } else if (memcmp("IntxLNK", pbuf, 7) == 0) {
                                cFYI(1,("Symlink"));
                                inode->i_mode |= S_IFLNK;
                        } else {
@@ -293,7 +302,7 @@ static int get_sfu_uid_mode(struct inode * inode,
        rc = CIFSSMBQueryEA(xid, cifs_sb->tcon, path, "SETFILEBITS",
                        ea_value, 4 /* size of buf */, cifs_sb->local_nls,
                        cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR);
-        if(rc < 0)
+        if (rc < 0)
                return (int)rc;
        else if (rc > 3) {
                mode = le32_to_cpu(*((__le32 *)ea_value));
@@ -348,7 +357,7 @@ int cifs_get_inode_info(struct inode **pinode,
                /* BB optimize code so we do not make the above call
                when server claims no NT SMB support and the above call
                failed at least once - set flag in tcon or mount */
-                if((rc == -EOPNOTSUPP) || (rc == -EINVAL)) {
+                if ((rc == -EOPNOTSUPP) || (rc == -EINVAL)) {
                        rc = SMBQueryInformation(xid, pTcon, search_path,
                                        pfindData, cifs_sb->local_nls, 
                                        cifs_sb->mnt_cifs_flags &
@@ -425,7 +434,7 @@ int cifs_get_inode_info(struct inode **pinode,
                                } else /* do we need cast or hash to ino? */
                                        (*pinode)->i_ino = inode_num;
                        } /* else ino incremented to unique num in new_inode*/
-                        if(sb->s_flags & MS_NOATIME)
+                        if (sb->s_flags & MS_NOATIME)
                                (*pinode)->i_flags |= S_NOATIME | S_NOCMTIME;
                        insert_inode_hash(*pinode);
                }
@@ -442,7 +451,7 @@ int cifs_get_inode_info(struct inode **pinode,
                (pTcon->ses->server->maxBuf - MAX_CIFS_HDR_SIZE) & 0xFFFFFE00;*/
                /* Linux can not store file creation time so ignore it */
-                if(pfindData->LastAccessTime)
+                if (pfindData->LastAccessTime)
                        inode->i_atime = cifs_NTtimeToUnix
                                (le64_to_cpu(pfindData->LastAccessTime));
                else /* do not need to use current_fs_time - time not stored */
@@ -452,7 +461,7 @@ int cifs_get_inode_info(struct inode **pinode,
                inode->i_ctime =
                    cifs_NTtimeToUnix(le64_to_cpu(pfindData->ChangeTime));
                cFYI(0, ("Attributes came in as 0x%x", attr));
-                if(adjustTZ && (pTcon->ses) && (pTcon->ses->server)) {
+                if (adjustTZ && (pTcon->ses) && (pTcon->ses->server)) {
                        inode->i_ctime.tv_sec += pTcon->ses->server->timeAdj;
                        inode->i_mtime.tv_sec += pTcon->ses->server->timeAdj;
                }
@@ -521,8 +530,10 @@ int cifs_get_inode_info(struct inode **pinode,
                /* BB fill in uid and gid here? with help from winbind? 
                   or retrieve from NTFS stream extended attribute */
-                if(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_UNX_EMUL) {
+                if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_UNX_EMUL) {
                        /* fill in uid, gid, mode from server ACL */
+                        /* BB FIXME this should also take into account the
+                         * default uid specified on mount if present */
                        get_sfu_uid_mode(inode, search_path, cifs_sb, xid);
                } else if (atomic_read(&cifsInfo->inUse) == 0) {
                        inode->i_uid = cifs_sb->mnt_uid;
@@ -541,12 +552,12 @@ int cifs_get_inode_info(struct inode **pinode,
                                                &cifs_file_direct_nobrl_ops;
                                else
                                        inode->i_fop = &cifs_file_direct_ops;
-                        } else if(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_BRL)
+                        } else if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_BRL)
                                inode->i_fop = &cifs_file_nobrl_ops;
                        else /* not direct, send byte range locks */
                                inode->i_fop = &cifs_file_ops;
-                        if(pTcon->ses->server->maxBuf < 
+                        if (pTcon->ses->server->maxBuf < 
                             PAGE_CACHE_SIZE + MAX_CIFS_HDR_SIZE)
                                inode->i_data.a_ops = &cifs_addr_ops_smallbuf;
                        else
@@ -597,7 +608,7 @@ int cifs_unlink(struct inode *inode, struct dentry *direntry)
        xid = GetXid();
-        if(inode)
+        if (inode)
                cifs_sb = CIFS_SB(inode->i_sb);
        else
                cifs_sb = CIFS_SB(direntry->d_sb);
@@ -723,7 +734,7 @@ int cifs_unlink(struct inode *inode, struct dentry *direntry)
                                           when needed */
                direntry->d_inode->i_ctime = current_fs_time(inode->i_sb);
        }
-        if(inode) {
+        if (inode) {
                inode->i_ctime = inode->i_mtime = current_fs_time(inode->i_sb);
                cifsInode = CIFS_I(inode);
                cifsInode->time = 0;    /* force revalidate of dir as well */
@@ -734,6 +745,136 @@ int cifs_unlink(struct inode *inode, struct dentry *direntry)
        return rc;
 }
+static void posix_fill_in_inode(struct inode *tmp_inode,
+        FILE_UNIX_BASIC_INFO *pData, int *pobject_type, int isNewInode)
+{
+        loff_t local_size;
+        struct timespec local_mtime;
+        struct cifsInodeInfo *cifsInfo = CIFS_I(tmp_inode);
+        struct cifs_sb_info *cifs_sb = CIFS_SB(tmp_inode->i_sb);
+        __u32 type = le32_to_cpu(pData->Type);
+        __u64 num_of_bytes = le64_to_cpu(pData->NumOfBytes);
+        __u64 end_of_file = le64_to_cpu(pData->EndOfFile);
+        cifsInfo->time = jiffies;
+        atomic_inc(&cifsInfo->inUse);
+        /* save mtime and size */
+        local_mtime = tmp_inode->i_mtime;
+        local_size  = tmp_inode->i_size;
+        tmp_inode->i_atime =
+            cifs_NTtimeToUnix(le64_to_cpu(pData->LastAccessTime));
+        tmp_inode->i_mtime =
+            cifs_NTtimeToUnix(le64_to_cpu(pData->LastModificationTime));
+        tmp_inode->i_ctime =
+            cifs_NTtimeToUnix(le64_to_cpu(pData->LastStatusChange));
+        tmp_inode->i_mode = le64_to_cpu(pData->Permissions);
+        /* since we set the inode type below we need to mask off type
+           to avoid strange results if bits above were corrupt */
+        tmp_inode->i_mode &= ~S_IFMT;
+        if (type == UNIX_FILE) {
+                *pobject_type = DT_REG;
+                tmp_inode->i_mode |= S_IFREG;
+        } else if (type == UNIX_SYMLINK) {
+                *pobject_type = DT_LNK;
+                tmp_inode->i_mode |= S_IFLNK;
+        } else if (type == UNIX_DIR) {
+                *pobject_type = DT_DIR;
+                tmp_inode->i_mode |= S_IFDIR;
+        } else if (type == UNIX_CHARDEV) {
+                *pobject_type = DT_CHR;
+                tmp_inode->i_mode |= S_IFCHR;
+                tmp_inode->i_rdev = MKDEV(le64_to_cpu(pData->DevMajor),
+                                le64_to_cpu(pData->DevMinor) & MINORMASK);
+        } else if (type == UNIX_BLOCKDEV) {
+                *pobject_type = DT_BLK;
+                tmp_inode->i_mode |= S_IFBLK;
+                tmp_inode->i_rdev = MKDEV(le64_to_cpu(pData->DevMajor),
+                                le64_to_cpu(pData->DevMinor) & MINORMASK);
+        } else if (type == UNIX_FIFO) {
+                *pobject_type = DT_FIFO;
+                tmp_inode->i_mode |= S_IFIFO;
+        } else if (type == UNIX_SOCKET) {
+                *pobject_type = DT_SOCK;
+                tmp_inode->i_mode |= S_IFSOCK;
+        } else {
+                /* safest to just call it a file */
+                *pobject_type = DT_REG;
+                tmp_inode->i_mode |= S_IFREG;
+                cFYI(1,("unknown inode type %d",type)); 
+        }
+#ifdef CONFIG_CIFS_DEBUG2
+        cFYI(1,("object type: %d", type));
+#endif
+        tmp_inode->i_uid = le64_to_cpu(pData->Uid);
+        tmp_inode->i_gid = le64_to_cpu(pData->Gid);
+        tmp_inode->i_nlink = le64_to_cpu(pData->Nlinks);
+        spin_lock(&tmp_inode->i_lock);
+        if (is_size_safe_to_change(cifsInfo, end_of_file)) {
+                /* can not safely change the file size here if the 
+                client is writing to it due to potential races */
+                i_size_write(tmp_inode, end_of_file);
+        /* 512 bytes (2**9) is the fake blocksize that must be used */
+        /* for this calculation, not the real blocksize */
+                tmp_inode->i_blocks = (512 - 1 + num_of_bytes) >> 9;
+        }
+        spin_unlock(&tmp_inode->i_lock);
+        if (S_ISREG(tmp_inode->i_mode)) {
+                cFYI(1, ("File inode"));
+                tmp_inode->i_op = &cifs_file_inode_ops;
+                if(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DIRECT_IO) {
+                        if(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_BRL)
+                                tmp_inode->i_fop = &cifs_file_direct_nobrl_ops;
+                        else
+                                tmp_inode->i_fop = &cifs_file_direct_ops;
+                
+                } else if(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_BRL)
+                        tmp_inode->i_fop = &cifs_file_nobrl_ops;
+                else
+                        tmp_inode->i_fop = &cifs_file_ops;
+                if((cifs_sb->tcon) && (cifs_sb->tcon->ses) &&
+                   (cifs_sb->tcon->ses->server->maxBuf < 
+                        PAGE_CACHE_SIZE + MAX_CIFS_HDR_SIZE))
+                        tmp_inode->i_data.a_ops = &cifs_addr_ops_smallbuf;
+                else
+                        tmp_inode->i_data.a_ops = &cifs_addr_ops;
+                if(isNewInode)
+                        return; /* No sense invalidating pages for new inode since we
+                                           have not started caching readahead file data yet */
+                if (timespec_equal(&tmp_inode->i_mtime, &local_mtime) &&
+                        (local_size == tmp_inode->i_size)) {
+                        cFYI(1, ("inode exists but unchanged"));
+                } else {
+                        /* file may have changed on server */
+                        cFYI(1, ("invalidate inode, readdir detected change"));
+                        invalidate_remote_inode(tmp_inode);
+                }
+        } else if (S_ISDIR(tmp_inode->i_mode)) {
+                cFYI(1, ("Directory inode"));
+                tmp_inode->i_op = &cifs_dir_inode_ops;
+                tmp_inode->i_fop = &cifs_dir_ops;
+        } else if (S_ISLNK(tmp_inode->i_mode)) {
+                cFYI(1, ("Symbolic Link inode"));
+                tmp_inode->i_op = &cifs_symlink_inode_ops;
+/* tmp_inode->i_fop = *//* do not need to set to anything */
+        } else {
+                cFYI(1, ("Special inode")); 
+                init_special_inode(tmp_inode, tmp_inode->i_mode,
+                                   tmp_inode->i_rdev);
+        }       
+}
 int cifs_mkdir(struct inode *inode, struct dentry *direntry, int mode)
 {
        int rc = 0;
@@ -755,6 +896,71 @@ int cifs_mkdir(struct inode *inode, struct dentry *direntry, int mode)
                FreeXid(xid);
                return -ENOMEM;
        }
+        
+        if((pTcon->ses->capabilities & CAP_UNIX) && 
+                (CIFS_UNIX_POSIX_PATH_OPS_CAP & 
+                        le64_to_cpu(pTcon->fsUnixInfo.Capability))) {
+                u32 oplock = 0;
+                FILE_UNIX_BASIC_INFO * pInfo = 
+                        kzalloc(sizeof(FILE_UNIX_BASIC_INFO), GFP_KERNEL);
+                if(pInfo == NULL) {
+                        rc = -ENOMEM;
+                        goto mkdir_out;
+                }
+                        
+                rc = CIFSPOSIXCreate(xid, pTcon, SMB_O_DIRECTORY | SMB_O_CREAT,
+                                mode, NULL /* netfid */, pInfo, &oplock,
+                                full_path, cifs_sb->local_nls, 
+                                cifs_sb->mnt_cifs_flags & 
+                                        CIFS_MOUNT_MAP_SPECIAL_CHR);
+                if (rc) {
+                        cFYI(1, ("posix mkdir returned 0x%x", rc));
+                        d_drop(direntry);
+                } else {
+                        int obj_type;
+                        if (pInfo->Type == -1) /* no return info - go query */
+                                goto mkdir_get_info; 
+/*BB check (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID ) to see if need to set uid/gid */
+                        inc_nlink(inode);
+                        if (pTcon->nocase)
+                                direntry->d_op = &cifs_ci_dentry_ops;
+                        else
+                                direntry->d_op = &cifs_dentry_ops;
+                        newinode = new_inode(inode->i_sb);
+                        if (newinode == NULL)
+                                goto mkdir_get_info;
+                        /* Is an i_ino of zero legal? */
+                        /* Are there sanity checks we can use to ensure that
+                           the server is really filling in that field? */
+                        if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM) {
+                                newinode->i_ino =
+                                        (unsigned long)pInfo->UniqueId;
+                        } /* note ino incremented to unique num in new_inode */
+                        if(inode->i_sb->s_flags & MS_NOATIME)
+                                newinode->i_flags |= S_NOATIME | S_NOCMTIME;
+                        newinode->i_nlink = 2;
+                        insert_inode_hash(newinode);
+                        d_instantiate(direntry, newinode);
+                        /* we already checked in POSIXCreate whether
+                           frame was long enough */
+                        posix_fill_in_inode(direntry->d_inode,
+                                        pInfo, &obj_type, 1 /* NewInode */);
+#ifdef CONFIG_CIFS_DEBUG2
+                        cFYI(1,("instantiated dentry %p %s to inode %p",
+                                direntry, direntry->d_name.name, newinode));
+                        if(newinode->i_nlink != 2)
+                                cFYI(1,("unexpected number of links %d",
+                                        newinode->i_nlink));
+#endif
+                }
+                kfree(pInfo);
+                goto mkdir_out;
+        }       
+        
        /* BB add setting the equivalent of mode via CreateX w/ACLs */
        rc = CIFSSMBMkDir(xid, pTcon, full_path, cifs_sb->local_nls,
                          cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR);
@@ -762,6 +968,7 @@ int cifs_mkdir(struct inode *inode, struct dentry *direntry, int mode)
                cFYI(1, ("cifs_mkdir returned 0x%x", rc));
                d_drop(direntry);
        } else {
+mkdir_get_info:         
                inc_nlink(inode);
                if (pTcon->ses->capabilities & CAP_UNIX)
                        rc = cifs_get_inode_info_unix(&newinode, full_path,
@@ -775,8 +982,10 @@ int cifs_mkdir(struct inode *inode, struct dentry *direntry, int mode)
                else
                        direntry->d_op = &cifs_dentry_ops;
                d_instantiate(direntry, newinode);
-                if (direntry->d_inode)
+                 /* setting nlink not necessary except in cases where we
-                        direntry->d_inode->i_nlink = 2;
+                  * failed to get it from the server or was set bogus */ 
+                if ((direntry->d_inode) && (direntry->d_inode->i_nlink < 2))
+                                direntry->d_inode->i_nlink = 2; 
                if (cifs_sb->tcon->ses->capabilities & CAP_UNIX)
                        if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID) {
                                CIFSSMBUnixSetPerms(xid, pTcon, full_path,
@@ -812,6 +1021,7 @@ int cifs_mkdir(struct inode *inode, struct dentry *direntry, int mode)
                        }
                }
        }
+mkdir_out:      
        kfree(full_path);
        FreeXid(xid);
        return rc;
@@ -1339,17 +1549,17 @@ int cifs_setattr(struct dentry *direntry, struct iattr *attrs)
                                        cpu_to_le32(cifsInode->cifsAttrs |
                                                    ATTR_READONLY);
                        }
-                } else if ((mode & S_IWUGO) == S_IWUGO) {
+                } else if (cifsInode->cifsAttrs & ATTR_READONLY) {
-                        if (cifsInode->cifsAttrs & ATTR_READONLY) {
+                        /* If file is readonly on server, we would
-                                set_dosattr = TRUE;
+                        not be able to write to it - so if any write
-                                time_buf.Attributes =
+                        bit is enabled for user or group or other we
-                                        cpu_to_le32(cifsInode->cifsAttrs &
+                        need to at least try to remove r/o dos attr */
-                                                    (~ATTR_READONLY));
+                        set_dosattr = TRUE;
-                                /* Windows ignores set to zero */
+                        time_buf.Attributes = cpu_to_le32(cifsInode->cifsAttrs &
-                                if(time_buf.Attributes == 0)
+                                            (~ATTR_READONLY));
-                                        time_buf.Attributes |= 
+                        /* Windows ignores set to zero */
-                                                cpu_to_le32(ATTR_NORMAL);
+                        if(time_buf.Attributes == 0)
-                        }
+                                time_buf.Attributes |= cpu_to_le32(ATTR_NORMAL);
                }
                /* BB to be implemented -
                   via Windows security descriptors or streams */
diff --git a/fs/cifs/netmisc.c b/fs/cifs/netmisc.c
index 992e80edc720..53e304d59544 100644
--- a/fs/cifs/netmisc.c
+++ b/fs/cifs/netmisc.c
@@ -30,6 +30,9 @@
 #include <linux/fs.h>
 #include <asm/div64.h>
 #include <asm/byteorder.h>
+#ifdef CONFIG_CIFS_EXPERIMENTAL
+#include <linux/inet.h>
+#endif
 #include "cifsfs.h"
 #include "cifspdu.h"
 #include "cifsglob.h"
@@ -129,11 +132,27 @@ static const struct smb_to_posix_error mapping_table_ERRHRD[] = {
 /* Convert string containing dotted ip address to binary form */
 /* returns 0 if invalid address */
-/* BB add address family, change rc to status flag and return union or for ipv6 */
-/*  will need parent to call something like inet_pton to convert ipv6 address  BB */
 int
 cifs_inet_pton(int address_family, char *cp,void *dst)
 {
+#ifdef CONFIG_CIFS_EXPERIMENTAL
+        int ret = 0;
+        /* calculate length by finding first slash or NULL */
+        /* BB Should we convert '/' slash to '\' here since it seems already done
+           before this */
+        if( address_family == AF_INET ){
+                ret = in4_pton(cp, -1 /* len */, dst , '\\', NULL);     
+        } else if( address_family == AF_INET6 ){
+                ret = in6_pton(cp, -1 /* len */, dst , '\\', NULL);
+        }
+#ifdef CONFIG_CIFS_DEBUG2
+        cFYI(1,("address conversion returned %d for %s", ret, cp));
+#endif
+        if (ret > 0)
+                ret = 1;
+        return ret;
+#else
        int value;
        int digit;
        int i;
@@ -192,6 +211,7 @@ cifs_inet_pton(int address_family, char *cp,void *dst)
        *((__be32 *)dst) = *((__be32 *) bytes) | htonl(value);
        return 1; /* success */
+#endif /* EXPERIMENTAL */       
 }
 /*****************************************************************************
diff --git a/fs/cifs/readdir.c b/fs/cifs/readdir.c
index 2a374d5215ab..b5364f90d551 100644
--- a/fs/cifs/readdir.c
+++ b/fs/cifs/readdir.c
@@ -37,19 +37,19 @@ static void dump_cifs_file_struct(struct file *file, char *label)
 {
        struct cifsFileInfo * cf;
-        if(file) {
+        if (file) {
                cf = file->private_data;
-                if(cf == NULL) {
+                if (cf == NULL) {
                        cFYI(1,("empty cifs private file data"));
                        return;
                }
-                if(cf->invalidHandle) {
+                if (cf->invalidHandle) {
                        cFYI(1,("invalid handle"));
                }
-                if(cf->srch_inf.endOfSearch) {
+                if (cf->srch_inf.endOfSearch) {
                        cFYI(1,("end of search"));
                }
-                if(cf->srch_inf.emptyDir) {
+                if (cf->srch_inf.emptyDir) {
                        cFYI(1,("empty dir"));
                }
                
@@ -77,17 +77,17 @@ static int construct_dentry(struct qstr *qstring, struct file *file,
                cFYI(0, ("existing dentry with inode 0x%p", tmp_dentry->d_inode));
                *ptmp_inode = tmp_dentry->d_inode;
 /* BB overwrite old name? i.e. tmp_dentry->d_name and tmp_dentry->d_name.len??*/
-                if(*ptmp_inode == NULL) {
+                if (*ptmp_inode == NULL) {
                        *ptmp_inode = new_inode(file->f_path.dentry->d_sb);
-                        if(*ptmp_inode == NULL)
+                        if (*ptmp_inode == NULL)
                                return rc;
                        rc = 1;
                }
-                if(file->f_path.dentry->d_sb->s_flags & MS_NOATIME)
+                if (file->f_path.dentry->d_sb->s_flags & MS_NOATIME)
                        (*ptmp_inode)->i_flags |= S_NOATIME | S_NOCMTIME;
        } else {
                tmp_dentry = d_alloc(file->f_path.dentry, qstring);
-                if(tmp_dentry == NULL) {
+                if (tmp_dentry == NULL) {
                        cERROR(1,("Failed allocating dentry"));
                        *ptmp_inode = NULL;
                        return rc;
@@ -98,9 +98,9 @@ static int construct_dentry(struct qstr *qstring, struct file *file,
                        tmp_dentry->d_op = &cifs_ci_dentry_ops;
                else
                        tmp_dentry->d_op = &cifs_dentry_ops;
-                if(*ptmp_inode == NULL)
+                if (*ptmp_inode == NULL)
                        return rc;
-                if(file->f_path.dentry->d_sb->s_flags & MS_NOATIME)
+                if (file->f_path.dentry->d_sb->s_flags & MS_NOATIME)
                        (*ptmp_inode)->i_flags |= S_NOATIME | S_NOCMTIME;                       
                rc = 2;
        }
@@ -112,7 +112,7 @@ static int construct_dentry(struct qstr *qstring, struct file *file,
 static void AdjustForTZ(struct cifsTconInfo * tcon, struct inode * inode)
 {
-        if((tcon) && (tcon->ses) && (tcon->ses->server)) {
+        if ((tcon) && (tcon->ses) && (tcon->ses->server)) {
                inode->i_ctime.tv_sec += tcon->ses->server->timeAdj;
                inode->i_mtime.tv_sec += tcon->ses->server->timeAdj;
                inode->i_atime.tv_sec += tcon->ses->server->timeAdj;
@@ -137,7 +137,7 @@ static void fill_in_inode(struct inode *tmp_inode, int new_buf_type,
        local_mtime = tmp_inode->i_mtime;
        local_size  = tmp_inode->i_size;
-        if(new_buf_type) {
+        if (new_buf_type) {
                FILE_DIRECTORY_INFO *pfindData = (FILE_DIRECTORY_INFO *)buf;
                attr = le32_to_cpu(pfindData->ExtFileAttributes);
@@ -193,7 +193,7 @@ static void fill_in_inode(struct inode *tmp_inode, int new_buf_type,
        if (attr & ATTR_DIRECTORY) {
                *pobject_type = DT_DIR;
                /* override default perms since we do not lock dirs */
-                if(atomic_read(&cifsInfo->inUse) == 0) {
+                if (atomic_read(&cifsInfo->inUse) == 0) {
                        tmp_inode->i_mode = cifs_sb->mnt_dir_mode;
                }
                tmp_inode->i_mode |= S_IFDIR;
@@ -250,25 +250,25 @@ static void fill_in_inode(struct inode *tmp_inode, int new_buf_type,
        if (S_ISREG(tmp_inode->i_mode)) {
                cFYI(1, ("File inode"));
                tmp_inode->i_op = &cifs_file_inode_ops;
-                if(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DIRECT_IO) {
+                if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DIRECT_IO) {
-                        if(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_BRL)
+                        if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_BRL)
                                tmp_inode->i_fop = &cifs_file_direct_nobrl_ops;
                        else
                                tmp_inode->i_fop = &cifs_file_direct_ops;
                
-                } else if(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_BRL)
+                } else if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_BRL)
                        tmp_inode->i_fop = &cifs_file_nobrl_ops;
                else
                        tmp_inode->i_fop = &cifs_file_ops;
-                if((cifs_sb->tcon) && (cifs_sb->tcon->ses) &&
+                if ((cifs_sb->tcon) && (cifs_sb->tcon->ses) &&
                   (cifs_sb->tcon->ses->server->maxBuf <
                        PAGE_CACHE_SIZE + MAX_CIFS_HDR_SIZE))
                        tmp_inode->i_data.a_ops = &cifs_addr_ops_smallbuf;
                else
                        tmp_inode->i_data.a_ops = &cifs_addr_ops;
-                if(isNewInode)
+                if (isNewInode)
                        return; /* No sense invalidating pages for new inode
                                   since have not started caching readahead file
                                   data yet */
@@ -357,8 +357,14 @@ static void unix_fill_in_inode(struct inode *tmp_inode,
                cFYI(1,("unknown inode type %d",type)); 
        }
-        tmp_inode->i_uid = le64_to_cpu(pfindData->Uid);
+        if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_UID)
-        tmp_inode->i_gid = le64_to_cpu(pfindData->Gid);
+                tmp_inode->i_uid = cifs_sb->mnt_uid;
+        else
+                tmp_inode->i_uid = le64_to_cpu(pfindData->Uid);
+        if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_GID)
+                tmp_inode->i_gid = cifs_sb->mnt_gid;
+        else
+                tmp_inode->i_gid = le64_to_cpu(pfindData->Gid);
        tmp_inode->i_nlink = le64_to_cpu(pfindData->Nlinks);
        spin_lock(&tmp_inode->i_lock);
@@ -377,25 +383,24 @@ static void unix_fill_in_inode(struct inode *tmp_inode,
                cFYI(1, ("File inode"));
                tmp_inode->i_op = &cifs_file_inode_ops;
-                if(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DIRECT_IO) {
+                if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DIRECT_IO) {
-                        if(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_BRL)
+                        if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_BRL)
                                tmp_inode->i_fop = &cifs_file_direct_nobrl_ops;
                        else
                                tmp_inode->i_fop = &cifs_file_direct_ops;
-                
+                } else if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_BRL)
-                } else if(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_BRL)
                        tmp_inode->i_fop = &cifs_file_nobrl_ops;
                else
                        tmp_inode->i_fop = &cifs_file_ops;
-                if((cifs_sb->tcon) && (cifs_sb->tcon->ses) &&
+                if ((cifs_sb->tcon) && (cifs_sb->tcon->ses) &&
                   (cifs_sb->tcon->ses->server->maxBuf < 
                        PAGE_CACHE_SIZE + MAX_CIFS_HDR_SIZE))
                        tmp_inode->i_data.a_ops = &cifs_addr_ops_smallbuf;
                else
                        tmp_inode->i_data.a_ops = &cifs_addr_ops;
-                if(isNewInode)
+                if (isNewInode)
                        return; /* No sense invalidating pages for new inode since we
                                           have not started caching readahead file data yet */
@@ -430,34 +435,28 @@ static int initiate_cifs_search(const int xid, struct file *file)
        struct cifs_sb_info *cifs_sb;
        struct cifsTconInfo *pTcon;
-        if(file->private_data == NULL) {
+        if (file->private_data == NULL) {
                file->private_data = 
-                        kmalloc(sizeof(struct cifsFileInfo),GFP_KERNEL);
+                        kzalloc(sizeof(struct cifsFileInfo),GFP_KERNEL);
        }
-        if(file->private_data == NULL) {
+        if (file->private_data == NULL)
                return -ENOMEM;
-        } else {
-                memset(file->private_data,0,sizeof(struct cifsFileInfo));
-        }
        cifsFile = file->private_data;
        cifsFile->invalidHandle = TRUE;
        cifsFile->srch_inf.endOfSearch = FALSE;
-        if(file->f_path.dentry == NULL)
-                return -ENOENT;
        cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
-        if(cifs_sb == NULL)
+        if (cifs_sb == NULL)
                return -EINVAL;
        pTcon = cifs_sb->tcon;
-        if(pTcon == NULL)
+        if (pTcon == NULL)
                return -EINVAL;
        full_path = build_path_from_dentry(file->f_path.dentry);
-        if(full_path == NULL) {
+        if (full_path == NULL) {
                return -ENOMEM;
        }
@@ -480,9 +479,9 @@ ffirst_retry:
                &cifsFile->netfid, &cifsFile->srch_inf,
                cifs_sb->mnt_cifs_flags & 
                        CIFS_MOUNT_MAP_SPECIAL_CHR, CIFS_DIR_SEP(cifs_sb));
-        if(rc == 0)
+        if (rc == 0)
                cifsFile->invalidHandle = FALSE;
-        if((rc == -EOPNOTSUPP) && 
+        if ((rc == -EOPNOTSUPP) && 
                (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM)) {
                cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_SERVER_INUM;
                goto ffirst_retry;
@@ -498,7 +497,7 @@ static int cifs_unicode_bytelen(char *str)
        __le16 * ustr = (__le16 *)str;
        for(len=0;len <= PATH_MAX;len++) {
-                if(ustr[len] == 0)
+                if (ustr[len] == 0)
                        return len << 1;
        }
        cFYI(1,("Unicode string longer than PATH_MAX found"));
@@ -510,7 +509,7 @@ static char *nxt_dir_entry(char *old_entry, char *end_of_smb, int level)
        char * new_entry;
        FILE_DIRECTORY_INFO * pDirInfo = (FILE_DIRECTORY_INFO *)old_entry;
-        if(level == SMB_FIND_FILE_INFO_STANDARD) {
+        if (level == SMB_FIND_FILE_INFO_STANDARD) {
                FIND_FILE_STANDARD_INFO * pfData;
                pfData = (FIND_FILE_STANDARD_INFO *)pDirInfo;
@@ -520,12 +519,12 @@ static char *nxt_dir_entry(char *old_entry, char *end_of_smb, int level)
                new_entry = old_entry + le32_to_cpu(pDirInfo->NextEntryOffset);
        cFYI(1,("new entry %p old entry %p",new_entry,old_entry));
        /* validate that new_entry is not past end of SMB */
-        if(new_entry >= end_of_smb) {
+        if (new_entry >= end_of_smb) {
                cERROR(1,
                      ("search entry %p began after end of SMB %p old entry %p",
                        new_entry, end_of_smb, old_entry)); 
                return NULL;
-        } else if(((level == SMB_FIND_FILE_INFO_STANDARD) &&
+        } else if (((level == SMB_FIND_FILE_INFO_STANDARD) &&
                   (new_entry + sizeof(FIND_FILE_STANDARD_INFO) > end_of_smb)) ||
                  ((level != SMB_FIND_FILE_INFO_STANDARD) &&
                   (new_entry + sizeof(FILE_DIRECTORY_INFO) > end_of_smb)))  {
@@ -546,39 +545,39 @@ static int cifs_entry_is_dot(char *current_entry, struct cifsFileInfo *cfile)
        char * filename = NULL;
        int len = 0; 
-        if(cfile->srch_inf.info_level == SMB_FIND_FILE_UNIX) {
+        if (cfile->srch_inf.info_level == SMB_FIND_FILE_UNIX) {
                FILE_UNIX_INFO * pFindData = (FILE_UNIX_INFO *)current_entry;
                filename = &pFindData->FileName[0];
-                if(cfile->srch_inf.unicode) {
+                if (cfile->srch_inf.unicode) {
                        len = cifs_unicode_bytelen(filename);
                } else {
                        /* BB should we make this strnlen of PATH_MAX? */
                        len = strnlen(filename, 5);
                }
-        } else if(cfile->srch_inf.info_level == SMB_FIND_FILE_DIRECTORY_INFO) {
+        } else if (cfile->srch_inf.info_level == SMB_FIND_FILE_DIRECTORY_INFO) {
                FILE_DIRECTORY_INFO * pFindData = 
                        (FILE_DIRECTORY_INFO *)current_entry;
                filename = &pFindData->FileName[0];
                len = le32_to_cpu(pFindData->FileNameLength);
-        } else if(cfile->srch_inf.info_level == 
+        } else if (cfile->srch_inf.info_level == 
                        SMB_FIND_FILE_FULL_DIRECTORY_INFO) {
                FILE_FULL_DIRECTORY_INFO * pFindData = 
                        (FILE_FULL_DIRECTORY_INFO *)current_entry;
                filename = &pFindData->FileName[0];
                len = le32_to_cpu(pFindData->FileNameLength);
-        } else if(cfile->srch_inf.info_level ==
+        } else if (cfile->srch_inf.info_level ==
                        SMB_FIND_FILE_ID_FULL_DIR_INFO) {
                SEARCH_ID_FULL_DIR_INFO * pFindData = 
                        (SEARCH_ID_FULL_DIR_INFO *)current_entry;
                filename = &pFindData->FileName[0];
                len = le32_to_cpu(pFindData->FileNameLength);
-        } else if(cfile->srch_inf.info_level == 
+        } else if (cfile->srch_inf.info_level == 
                        SMB_FIND_FILE_BOTH_DIRECTORY_INFO) {
                FILE_BOTH_DIRECTORY_INFO * pFindData = 
                        (FILE_BOTH_DIRECTORY_INFO *)current_entry;
                filename = &pFindData->FileName[0];
                len = le32_to_cpu(pFindData->FileNameLength);
-        } else if(cfile->srch_inf.info_level == SMB_FIND_FILE_INFO_STANDARD) {
+        } else if (cfile->srch_inf.info_level == SMB_FIND_FILE_INFO_STANDARD) {
                FIND_FILE_STANDARD_INFO * pFindData =
                        (FIND_FILE_STANDARD_INFO *)current_entry;
                filename = &pFindData->FileName[0];
@@ -587,25 +586,25 @@ static int cifs_entry_is_dot(char *current_entry, struct cifsFileInfo *cfile)
                cFYI(1,("Unknown findfirst level %d",cfile->srch_inf.info_level));
        }
-        if(filename) {
+        if (filename) {
-                if(cfile->srch_inf.unicode) {
+                if (cfile->srch_inf.unicode) {
                        __le16 *ufilename = (__le16 *)filename;
-                        if(len == 2) {
+                        if (len == 2) {
                                /* check for . */
-                                if(ufilename[0] == UNICODE_DOT)
+                                if (ufilename[0] == UNICODE_DOT)
                                        rc = 1;
-                        } else if(len == 4) {
+                        } else if (len == 4) {
                                /* check for .. */
-                                if((ufilename[0] == UNICODE_DOT)
+                                if ((ufilename[0] == UNICODE_DOT)
                                   &&(ufilename[1] == UNICODE_DOT))
                                        rc = 2;
                        }
                } else /* ASCII */ {
-                        if(len == 1) {
+                        if (len == 1) {
-                                if(filename[0] == '.') 
+                                if (filename[0] == '.') 
                                        rc = 1;
-                        } else if(len == 2) {
+                        } else if (len == 2) {
-                                if((filename[0] == '.') && (filename[1] == '.')) 
+                                if((filename[0] == '.') && (filename[1] == '.'))
                                        rc = 2;
                        }
                }
@@ -618,20 +617,10 @@ static int cifs_entry_is_dot(char *current_entry, struct cifsFileInfo *cfile)
   whether we can use the cached search results from the previous search */
 static int is_dir_changed(struct file * file)
 {
-        struct inode * inode;
+        struct inode *inode = file->f_path.dentry->d_inode;
-        struct cifsInodeInfo *cifsInfo;
+        struct cifsInodeInfo *cifsInfo = CIFS_I(inode);
-        if(file->f_path.dentry == NULL)
+        if (cifsInfo->time == 0)
-                return 0;
-        inode = file->f_path.dentry->d_inode;
-        if(inode == NULL)
-                return 0;
-        cifsInfo = CIFS_I(inode);
-        if(cifsInfo->time == 0)
                return 1; /* directory was changed, perhaps due to unlink */
        else
                return 0;
@@ -654,7 +643,7 @@ static int find_cifs_entry(const int xid, struct cifsTconInfo *pTcon,
        struct cifsFileInfo * cifsFile = file->private_data;
        /* check if index in the buffer */
        
-        if((cifsFile == NULL) || (ppCurrentEntry == NULL) || 
+        if ((cifsFile == NULL) || (ppCurrentEntry == NULL) || 
           (num_to_ret == NULL))
                return -ENOENT;
        
@@ -672,7 +661,7 @@ static int find_cifs_entry(const int xid, struct cifsTconInfo *pTcon,
 #ifdef CONFIG_CIFS_DEBUG2
        dump_cifs_file_struct(file, "In fce ");
 #endif
-        if(((index_to_find < cifsFile->srch_inf.index_of_last_entry) && 
+        if (((index_to_find < cifsFile->srch_inf.index_of_last_entry) && 
             is_dir_changed(file)) || 
           (index_to_find < first_entry_in_buffer)) {
                /* close and restart search */
@@ -681,9 +670,9 @@ static int find_cifs_entry(const int xid, struct cifsTconInfo *pTcon,
                CIFSFindClose(xid, pTcon, cifsFile->netfid);
                kfree(cifsFile->search_resume_name);
                cifsFile->search_resume_name = NULL;
-                if(cifsFile->srch_inf.ntwrk_buf_start) {
+                if (cifsFile->srch_inf.ntwrk_buf_start) {
                        cFYI(1,("freeing SMB ff cache buf on search rewind"));
-                        if(cifsFile->srch_inf.smallBuf)
+                        if (cifsFile->srch_inf.smallBuf)
                                cifs_small_buf_release(cifsFile->srch_inf.
                                                ntwrk_buf_start);
                        else
@@ -691,7 +680,7 @@ static int find_cifs_entry(const int xid, struct cifsTconInfo *pTcon,
                                                ntwrk_buf_start);
                }
                rc = initiate_cifs_search(xid,file);
-                if(rc) {
+                if (rc) {
                        cFYI(1,("error %d reinitiating a search on rewind",rc));
                        return rc;
                }
@@ -702,10 +691,10 @@ static int find_cifs_entry(const int xid, struct cifsTconInfo *pTcon,
                cFYI(1,("calling findnext2"));
                rc = CIFSFindNext(xid,pTcon,cifsFile->netfid, 
                                  &cifsFile->srch_inf);
-                if(rc)
+                if (rc)
                        return -ENOENT;
        }
-        if(index_to_find < cifsFile->srch_inf.index_of_last_entry) {
+        if (index_to_find < cifsFile->srch_inf.index_of_last_entry) {
                /* we found the buffer that contains the entry */
                /* scan and find it */
                int i;
@@ -851,9 +840,6 @@ static int cifs_filldir(char *pfindEntry, struct file *file,
        if((scratch_buf == NULL) || (pfindEntry == NULL) || (pCifsF == NULL))
                return -ENOENT;
-        if(file->f_path.dentry == NULL)
-                return -ENOENT;
        rc = cifs_entry_is_dot(pfindEntry,pCifsF);
        /* skip . and .. since we added them first */
        if(rc != 0) 
@@ -997,11 +983,6 @@ int cifs_readdir(struct file *file, void *direntry, filldir_t filldir)
        xid = GetXid();
-        if(file->f_path.dentry == NULL) {
-                FreeXid(xid);
-                return -EIO;
-        }
        cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
        pTcon = cifs_sb->tcon;
        if(pTcon == NULL)
diff --git a/fs/coda/inode.c b/fs/coda/inode.c
index 614175a3b02e..0aaff3651d14 100644
--- a/fs/coda/inode.c
+++ b/fs/coda/inode.c
@@ -62,8 +62,7 @@ static void init_once(void * foo, struct kmem_cache * cachep, unsigned long flag
 {
        struct coda_inode_info *ei = (struct coda_inode_info *) foo;
-        if ((flags & (SLAB_CTOR_VERIFY|SLAB_CTOR_CONSTRUCTOR)) ==
+        if (flags & SLAB_CTOR_CONSTRUCTOR)
-            SLAB_CTOR_CONSTRUCTOR)
                inode_init_once(&ei->vfs_inode);
 }
 
diff --git a/fs/compat.c b/fs/compat.c
index 040a8be38a48..72e5e6923828 100644
--- a/fs/compat.c
+++ b/fs/compat.c
@@ -371,13 +371,14 @@ static void compat_ioctl_error(struct file *filp, unsigned int fd,
                        fn = "?";
        }
-        sprintf(buf,"'%c'", (cmd>>24) & 0x3f);
+        sprintf(buf,"'%c'", (cmd>>_IOC_TYPESHIFT) & _IOC_TYPEMASK);
        if (!isprint(buf[1]))
                sprintf(buf, "%02x", buf[1]);
        compat_printk("ioctl32(%s:%d): Unknown cmd fd(%d) "
-                        "cmd(%08x){%s} arg(%08x) on %s\n",
+                        "cmd(%08x){t:%s;sz:%u} arg(%08x) on %s\n",
                        current->comm, current->pid,
                        (int)fd, (unsigned int)cmd, buf,
+                        (cmd >> _IOC_SIZESHIFT) & _IOC_SIZEMASK,
                        (unsigned int)arg, fn);
        if (path)
diff --git a/fs/compat_ioctl.c b/fs/compat_ioctl.c
index c68b055fa26e..464c04a9541d 100644
--- a/fs/compat_ioctl.c
+++ b/fs/compat_ioctl.c
@@ -2396,6 +2396,14 @@ lp_timeout_trans(unsigned int fd, unsigned int cmd, unsigned long arg)
 #define ULONG_IOCTL(cmd) \
        { (cmd), (ioctl_trans_handler_t)sys_ioctl },
+/* ioctl should not be warned about even if it's not implemented.
+   Valid reasons to use this:
+   - It is implemented with ->compat_ioctl on some device, but programs
+   call it on others too.
+   - The ioctl is not implemented in the native kernel, but programs
+   call it commonly anyways.
+   Most other reasons are not valid. */
+#define IGNORE_IOCTL(cmd) COMPATIBLE_IOCTL(cmd)
 struct ioctl_trans ioctl_start[] = {
 #include <linux/compat_ioctl.h>
@@ -2594,6 +2602,8 @@ HANDLE_IOCTL(SIOCGIWENCODEEXT, do_wireless_ioctl)
 HANDLE_IOCTL(SIOCSIWPMKSA, do_wireless_ioctl)
 HANDLE_IOCTL(SIOCSIFBR, old_bridge_ioctl)
 HANDLE_IOCTL(SIOCGIFBR, old_bridge_ioctl)
+/* Not implemented in the native kernel */
+IGNORE_IOCTL(SIOCGIFCOUNT)
 HANDLE_IOCTL(RTC_IRQP_READ32, rtc_ioctl)
 HANDLE_IOCTL(RTC_IRQP_SET32, rtc_ioctl)
 HANDLE_IOCTL(RTC_EPOCH_READ32, rtc_ioctl)
@@ -2617,6 +2627,15 @@ COMPATIBLE_IOCTL(LPRESET)
 /*LPGETSTATS not implemented, but no kernels seem to compile it in anyways*/
 COMPATIBLE_IOCTL(LPGETFLAGS)
 HANDLE_IOCTL(LPSETTIMEOUT, lp_timeout_trans)
+/* fat 'r' ioctls. These are handled by fat with ->compat_ioctl,
+   but we don't want warnings on other file systems. So declare
+   them as compatible here. */
+#define VFAT_IOCTL_READDIR_BOTH32       _IOR('r', 1, struct compat_dirent[2])
+#define VFAT_IOCTL_READDIR_SHORT32      _IOR('r', 2, struct compat_dirent[2])
+IGNORE_IOCTL(VFAT_IOCTL_READDIR_BOTH32)
+IGNORE_IOCTL(VFAT_IOCTL_READDIR_SHORT32)
 };
 int ioctl_table_size = ARRAY_SIZE(ioctl_start);
diff --git a/fs/configfs/mount.c b/fs/configfs/mount.c
index 6f573004cd7d..b00d962de833 100644
--- a/fs/configfs/mount.c
+++ b/fs/configfs/mount.c
@@ -140,7 +140,7 @@ static int __init configfs_init(void)
        if (!configfs_dir_cachep)
                goto out;
-        kset_set_kset_s(&config_subsys, kernel_subsys);
+        kobj_set_kset_s(&config_subsys, kernel_subsys);
        err = subsystem_register(&config_subsys);
        if (err) {
                kmem_cache_destroy(configfs_dir_cachep);
diff --git a/fs/cramfs/inode.c b/fs/cramfs/inode.c
index facd0c89be8f..3d194a2be3f5 100644
--- a/fs/cramfs/inode.c
+++ b/fs/cramfs/inode.c
@@ -180,7 +180,8 @@ static void *cramfs_read(struct super_block *sb, unsigned int offset, unsigned i
                struct page *page = NULL;
                if (blocknr + i < devsize) {
-                        page = read_mapping_page(mapping, blocknr + i, NULL);
+                        page = read_mapping_page_async(mapping, blocknr + i,
+                                                                        NULL);
                        /* synchronous error? */
                        if (IS_ERR(page))
                                page = NULL;
diff --git a/fs/dcache.c b/fs/dcache.c
index d68631f18df1..d1bf5d8aeb5a 100644
--- a/fs/dcache.c
+++ b/fs/dcache.c
@@ -2052,12 +2052,8 @@ static void __init dcache_init(unsigned long mempages)
         * but it is probably not worth it because of the cache nature
         * of the dcache. 
         */
-        dentry_cache = kmem_cache_create("dentry_cache",
+        dentry_cache = KMEM_CACHE(dentry,
-                                         sizeof(struct dentry),
+                SLAB_RECLAIM_ACCOUNT|SLAB_PANIC|SLAB_MEM_SPREAD);
-                                         0,
-                                         (SLAB_RECLAIM_ACCOUNT|SLAB_PANIC|
-                                         SLAB_MEM_SPREAD),
-                                         NULL, NULL);
        
        set_shrinker(DEFAULT_SEEKS, shrink_dcache_memory);
diff --git a/fs/debugfs/inode.c b/fs/debugfs/inode.c
index 7b324cfebcb1..ec8896b264de 100644
--- a/fs/debugfs/inode.c
+++ b/fs/debugfs/inode.c
@@ -374,7 +374,7 @@ static int __init debugfs_init(void)
 {
        int retval;
-        kset_set_kset_s(&debug_subsys, kernel_subsys);
+        kobj_set_kset_s(&debug_subsys, kernel_subsys);
        retval = subsystem_register(&debug_subsys);
        if (retval)
                return retval;
diff --git a/fs/dlm/lockspace.c b/fs/dlm/lockspace.c
index f607ca2f0792..a677b2a5eed4 100644
--- a/fs/dlm/lockspace.c
+++ b/fs/dlm/lockspace.c
@@ -167,7 +167,6 @@ static struct kobj_type dlm_ktype = {
 };
 static struct kset dlm_kset = {
-        .subsys = &kernel_subsys,
        .kobj   = {.name = "dlm",},
        .ktype  = &dlm_ktype,
 };
@@ -218,6 +217,7 @@ int dlm_lockspace_init(void)
        INIT_LIST_HEAD(&lslist);
        spin_lock_init(&lslist_lock);
+        kobj_set_kset_s(&dlm_kset, kernel_subsys);
        error = kset_register(&dlm_kset);
        if (error)
                printk("dlm_lockspace_init: cannot register kset %d\n", error);
diff --git a/fs/dquot.c b/fs/dquot.c
index b16f991662c1..0a5febc159f2 100644
--- a/fs/dquot.c
+++ b/fs/dquot.c
@@ -1432,7 +1432,7 @@ int vfs_quota_off(struct super_block *sb, int type)
                        mutex_unlock(&dqopt->dqonoff_mutex);
                }
        if (sb->s_bdev)
-                invalidate_bdev(sb->s_bdev, 0);
+                invalidate_bdev(sb->s_bdev);
        return 0;
 }
@@ -1468,7 +1468,7 @@ static int vfs_quota_on_inode(struct inode *inode, int type, int format_id)
         * we see all the changes from userspace... */
        write_inode_now(inode, 1);
        /* And now flush the block cache so that kernel sees the changes */
-        invalidate_bdev(sb->s_bdev, 0);
+        invalidate_bdev(sb->s_bdev);
        mutex_lock(&inode->i_mutex);
        mutex_lock(&dqopt->dqonoff_mutex);
        if (sb_has_quota_enabled(sb, type)) {
diff --git a/fs/ecryptfs/main.c b/fs/ecryptfs/main.c
index fc4a3a224641..8cbf3f69ebe5 100644
--- a/fs/ecryptfs/main.c
+++ b/fs/ecryptfs/main.c
@@ -583,8 +583,7 @@ inode_info_init_once(void *vptr, struct kmem_cache *cachep, unsigned long flags)
 {
        struct ecryptfs_inode_info *ei = (struct ecryptfs_inode_info *)vptr;
-        if ((flags & (SLAB_CTOR_VERIFY | SLAB_CTOR_CONSTRUCTOR)) ==
+        if (flags & SLAB_CTOR_CONSTRUCTOR)
-            SLAB_CTOR_CONSTRUCTOR)
                inode_init_once(&ei->vfs_inode);
 }
@@ -793,7 +792,7 @@ static int do_sysfs_registration(void)
                       "Unable to register ecryptfs sysfs subsystem\n");
                goto out;
        }
-        rc = sysfs_create_file(&ecryptfs_subsys.kset.kobj,
+        rc = sysfs_create_file(&ecryptfs_subsys.kobj,
                               &sysfs_attr_version.attr);
        if (rc) {
                printk(KERN_ERR
@@ -801,12 +800,12 @@ static int do_sysfs_registration(void)
                subsystem_unregister(&ecryptfs_subsys);
                goto out;
        }
-        rc = sysfs_create_file(&ecryptfs_subsys.kset.kobj,
+        rc = sysfs_create_file(&ecryptfs_subsys.kobj,
                               &sysfs_attr_version_str.attr);
        if (rc) {
                printk(KERN_ERR
                       "Unable to create ecryptfs version_str attribute\n");
-                sysfs_remove_file(&ecryptfs_subsys.kset.kobj,
+                sysfs_remove_file(&ecryptfs_subsys.kobj,
                                  &sysfs_attr_version.attr);
                subsystem_unregister(&ecryptfs_subsys);
                goto out;
@@ -841,7 +840,7 @@ static int __init ecryptfs_init(void)
                ecryptfs_free_kmem_caches();
                goto out;
        }
-        kset_set_kset_s(&ecryptfs_subsys, fs_subsys);
+        kobj_set_kset_s(&ecryptfs_subsys, fs_subsys);
        sysfs_attr_version.attr.owner = THIS_MODULE;
        sysfs_attr_version_str.attr.owner = THIS_MODULE;
        rc = do_sysfs_registration();
@@ -862,9 +861,9 @@ out:
 static void __exit ecryptfs_exit(void)
 {
-        sysfs_remove_file(&ecryptfs_subsys.kset.kobj,
+        sysfs_remove_file(&ecryptfs_subsys.kobj,
                          &sysfs_attr_version.attr);
-        sysfs_remove_file(&ecryptfs_subsys.kset.kobj,
+        sysfs_remove_file(&ecryptfs_subsys.kobj,
                          &sysfs_attr_version_str.attr);
        subsystem_unregister(&ecryptfs_subsys);
        ecryptfs_release_messaging(ecryptfs_transport);
diff --git a/fs/ecryptfs/mmap.c b/fs/ecryptfs/mmap.c
index b731b09499cb..0770c4b66f53 100644
--- a/fs/ecryptfs/mmap.c
+++ b/fs/ecryptfs/mmap.c
@@ -46,7 +46,6 @@ struct kmem_cache *ecryptfs_lower_page_cache;
 */
 static struct page *ecryptfs_get1page(struct file *file, int index)
 {
-        struct page *page;
        struct dentry *dentry;
        struct inode *inode;
        struct address_space *mapping;
@@ -54,14 +53,7 @@ static struct page *ecryptfs_get1page(struct file *file, int index)
        dentry = file->f_path.dentry;
        inode = dentry->d_inode;
        mapping = inode->i_mapping;
-        page = read_cache_page(mapping, index,
+        return read_mapping_page(mapping, index, (void *)file);
-                               (filler_t *)mapping->a_ops->readpage,
-                               (void *)file);
-        if (IS_ERR(page))
-                goto out;
-        wait_on_page_locked(page);
-out:
-        return page;
 }
 static
@@ -233,7 +225,6 @@ int ecryptfs_do_readpage(struct file *file, struct page *page,
                ecryptfs_printk(KERN_ERR, "Error reading from page cache\n");
                goto out;
        }
-        wait_on_page_locked(lower_page);
        page_data = kmap_atomic(page, KM_USER0);
        lower_page_data = kmap_atomic(lower_page, KM_USER1);
        memcpy(page_data, lower_page_data, PAGE_CACHE_SIZE);
diff --git a/fs/efs/super.c b/fs/efs/super.c
index c2235e46edcd..ba7a8b9da0c1 100644
--- a/fs/efs/super.c
+++ b/fs/efs/super.c
@@ -72,8 +72,7 @@ static void init_once(void * foo, struct kmem_cache * cachep, unsigned long flag
 {
        struct efs_inode_info *ei = (struct efs_inode_info *) foo;
-        if ((flags & (SLAB_CTOR_VERIFY|SLAB_CTOR_CONSTRUCTOR)) ==
+        if (flags & SLAB_CTOR_CONSTRUCTOR)
-            SLAB_CTOR_CONSTRUCTOR)
                inode_init_once(&ei->vfs_inode);
 }
 
diff --git a/fs/ext2/dir.c b/fs/ext2/dir.c
index e89bfc8cf957..1d1e7e30d70e 100644
--- a/fs/ext2/dir.c
+++ b/fs/ext2/dir.c
@@ -161,10 +161,7 @@ static struct page * ext2_get_page(struct inode *dir, unsigned long n)
        struct address_space *mapping = dir->i_mapping;
        struct page *page = read_mapping_page(mapping, n, NULL);
        if (!IS_ERR(page)) {
-                wait_on_page_locked(page);
                kmap(page);
-                if (!PageUptodate(page))
-                        goto fail;
                if (!PageChecked(page))
                        ext2_check_page(page);
                if (PageError(page))
diff --git a/fs/ext2/super.c b/fs/ext2/super.c
index a046a419d8af..685a1c287177 100644
--- a/fs/ext2/super.c
+++ b/fs/ext2/super.c
@@ -160,8 +160,7 @@ static void init_once(void * foo, struct kmem_cache * cachep, unsigned long flag
 {
        struct ext2_inode_info *ei = (struct ext2_inode_info *) foo;
-        if ((flags & (SLAB_CTOR_VERIFY|SLAB_CTOR_CONSTRUCTOR)) ==
+        if (flags & SLAB_CTOR_CONSTRUCTOR) {
-            SLAB_CTOR_CONSTRUCTOR) {
                rwlock_init(&ei->i_meta_lock);
 #ifdef CONFIG_EXT2_FS_XATTR
                init_rwsem(&ei->xattr_sem);
diff --git a/fs/ext3/super.c b/fs/ext3/super.c
index 4a4fcd6868c7..54d3c9041259 100644
--- a/fs/ext3/super.c
+++ b/fs/ext3/super.c
@@ -420,7 +420,7 @@ static void ext3_put_super (struct super_block * sb)
                dump_orphan_list(sb, sbi);
        J_ASSERT(list_empty(&sbi->s_orphan));
-        invalidate_bdev(sb->s_bdev, 0);
+        invalidate_bdev(sb->s_bdev);
        if (sbi->journal_bdev && sbi->journal_bdev != sb->s_bdev) {
                /*
                 * Invalidate the journal device's buffers.  We don't want them
@@ -428,7 +428,7 @@ static void ext3_put_super (struct super_block * sb)
                 * hotswapped, and it breaks the `ro-after' testing code.
                 */
                sync_blockdev(sbi->journal_bdev);
-                invalidate_bdev(sbi->journal_bdev, 0);
+                invalidate_bdev(sbi->journal_bdev);
                ext3_blkdev_remove(sbi);
        }
        sb->s_fs_info = NULL;
@@ -466,8 +466,7 @@ static void init_once(void * foo, struct kmem_cache * cachep, unsigned long flag
 {
        struct ext3_inode_info *ei = (struct ext3_inode_info *) foo;
-        if ((flags & (SLAB_CTOR_VERIFY|SLAB_CTOR_CONSTRUCTOR)) ==
+        if (flags & SLAB_CTOR_CONSTRUCTOR) {
-            SLAB_CTOR_CONSTRUCTOR) {
                INIT_LIST_HEAD(&ei->i_orphan);
 #ifdef CONFIG_EXT3_FS_XATTR
                init_rwsem(&ei->xattr_sem);
diff --git a/fs/ext4/super.c b/fs/ext4/super.c
index 61c4718e4a53..719126932354 100644
--- a/fs/ext4/super.c
+++ b/fs/ext4/super.c
@@ -470,7 +470,7 @@ static void ext4_put_super (struct super_block * sb)
                dump_orphan_list(sb, sbi);
        J_ASSERT(list_empty(&sbi->s_orphan));
-        invalidate_bdev(sb->s_bdev, 0);
+        invalidate_bdev(sb->s_bdev);
        if (sbi->journal_bdev && sbi->journal_bdev != sb->s_bdev) {
                /*
                 * Invalidate the journal device's buffers.  We don't want them
@@ -478,7 +478,7 @@ static void ext4_put_super (struct super_block * sb)
                 * hotswapped, and it breaks the `ro-after' testing code.
                 */
                sync_blockdev(sbi->journal_bdev);
-                invalidate_bdev(sbi->journal_bdev, 0);
+                invalidate_bdev(sbi->journal_bdev);
                ext4_blkdev_remove(sbi);
        }
        sb->s_fs_info = NULL;
@@ -517,8 +517,7 @@ static void init_once(void * foo, struct kmem_cache * cachep, unsigned long flag
 {
        struct ext4_inode_info *ei = (struct ext4_inode_info *) foo;
-        if ((flags & (SLAB_CTOR_VERIFY|SLAB_CTOR_CONSTRUCTOR)) ==
+        if (flags & SLAB_CTOR_CONSTRUCTOR) {
-            SLAB_CTOR_CONSTRUCTOR) {
                INIT_LIST_HEAD(&ei->i_orphan);
 #ifdef CONFIG_EXT4DEV_FS_XATTR
                init_rwsem(&ei->xattr_sem);
diff --git a/fs/fat/cache.c b/fs/fat/cache.c
index 05c2941c74f2..1959143c1d27 100644
--- a/fs/fat/cache.c
+++ b/fs/fat/cache.c
@@ -40,8 +40,7 @@ static void init_once(void *foo, struct kmem_cache *cachep, unsigned long flags)
 {
        struct fat_cache *cache = (struct fat_cache *)foo;
-        if ((flags & (SLAB_CTOR_VERIFY|SLAB_CTOR_CONSTRUCTOR)) ==
+        if (flags & SLAB_CTOR_CONSTRUCTOR)
-            SLAB_CTOR_CONSTRUCTOR)
                INIT_LIST_HEAD(&cache->cache_list);
 }
diff --git a/fs/fat/inode.c b/fs/fat/inode.c
index 9bfe607c892e..65cb54bde481 100644
--- a/fs/fat/inode.c
+++ b/fs/fat/inode.c
@@ -499,8 +499,7 @@ static void init_once(void * foo, struct kmem_cache * cachep, unsigned long flag
 {
        struct msdos_inode_info *ei = (struct msdos_inode_info *)foo;
-        if ((flags & (SLAB_CTOR_VERIFY|SLAB_CTOR_CONSTRUCTOR)) ==
+        if (flags & SLAB_CTOR_CONSTRUCTOR) {
-            SLAB_CTOR_CONSTRUCTOR) {
                spin_lock_init(&ei->cache_lru_lock);
                ei->nr_caches = 0;
                ei->cache_valid_id = FAT_CACHE_VALID + 1;
diff --git a/fs/freevxfs/vxfs_subr.c b/fs/freevxfs/vxfs_subr.c
index decac62efe57..ed8f0b0dd880 100644
--- a/fs/freevxfs/vxfs_subr.c
+++ b/fs/freevxfs/vxfs_subr.c
@@ -74,10 +74,7 @@ vxfs_get_page(struct address_space *mapping, u_long n)
        pp = read_mapping_page(mapping, n, NULL);
        if (!IS_ERR(pp)) {
-                wait_on_page_locked(pp);
                kmap(pp);
-                if (!PageUptodate(pp))
-                        goto fail;
                /** if (!PageChecked(pp)) **/
                        /** vxfs_check_page(pp); **/
                if (PageError(pp))
diff --git a/fs/fuse/inode.c b/fs/fuse/inode.c
index 608db81219a0..d8003be56e05 100644
--- a/fs/fuse/inode.c
+++ b/fs/fuse/inode.c
@@ -685,8 +685,7 @@ static void fuse_inode_init_once(void *foo, struct kmem_cache *cachep,
 {
        struct inode * inode = foo;
-        if ((flags & (SLAB_CTOR_VERIFY|SLAB_CTOR_CONSTRUCTOR)) ==
+        if (flags & SLAB_CTOR_CONSTRUCTOR)
-            SLAB_CTOR_CONSTRUCTOR)
                inode_init_once(inode);
 }
@@ -731,12 +730,12 @@ static int fuse_sysfs_init(void)
 {
        int err;
-        kset_set_kset_s(&fuse_subsys, fs_subsys);
+        kobj_set_kset_s(&fuse_subsys, fs_subsys);
        err = subsystem_register(&fuse_subsys);
        if (err)
                goto out_err;
-        kset_set_kset_s(&connections_subsys, fuse_subsys);
+        kobj_set_kset_s(&connections_subsys, fuse_subsys);
        err = subsystem_register(&connections_subsys);
        if (err)
                goto out_fuse_unregister;
diff --git a/fs/gfs2/locking/dlm/sysfs.c b/fs/gfs2/locking/dlm/sysfs.c
index 4746b884662d..d9fe3ca40e18 100644
--- a/fs/gfs2/locking/dlm/sysfs.c
+++ b/fs/gfs2/locking/dlm/sysfs.c
@@ -190,7 +190,6 @@ static struct kobj_type gdlm_ktype = {
 };
 static struct kset gdlm_kset = {
-        .subsys = &kernel_subsys,
        .kobj   = {.name = "lock_dlm",},
        .ktype  = &gdlm_ktype,
 };
@@ -225,6 +224,7 @@ int gdlm_sysfs_init(void)
 {
        int error;
+        kobj_set_kset_s(&gdlm_kset, kernel_subsys);
        error = kset_register(&gdlm_kset);
        if (error)
                printk("lock_dlm: cannot register kset %d\n", error);
diff --git a/fs/gfs2/main.c b/fs/gfs2/main.c
index c4bb374eaf92..e460487c0557 100644
--- a/fs/gfs2/main.c
+++ b/fs/gfs2/main.c
@@ -27,8 +27,7 @@
 static void gfs2_init_inode_once(void *foo, struct kmem_cache *cachep, unsigned long flags)
 {
        struct gfs2_inode *ip = foo;
-        if ((flags & (SLAB_CTOR_VERIFY|SLAB_CTOR_CONSTRUCTOR)) ==
+        if (flags & SLAB_CTOR_CONSTRUCTOR) {
-            SLAB_CTOR_CONSTRUCTOR) {
                inode_init_once(&ip->i_inode);
                spin_lock_init(&ip->i_spin);
                init_rwsem(&ip->i_rw_mutex);
@@ -39,8 +38,7 @@ static void gfs2_init_inode_once(void *foo, struct kmem_cache *cachep, unsigned
 static void gfs2_init_glock_once(void *foo, struct kmem_cache *cachep, unsigned long flags)
 {
        struct gfs2_glock *gl = foo;
-        if ((flags & (SLAB_CTOR_VERIFY|SLAB_CTOR_CONSTRUCTOR)) ==
+        if (flags & SLAB_CTOR_CONSTRUCTOR) {
-            SLAB_CTOR_CONSTRUCTOR) {
                INIT_HLIST_NODE(&gl->gl_list);
                spin_lock_init(&gl->gl_spin);
                INIT_LIST_HEAD(&gl->gl_holders);
diff --git a/fs/gfs2/sys.c b/fs/gfs2/sys.c
index d01f9f0fda26..c26c21b53c19 100644
--- a/fs/gfs2/sys.c
+++ b/fs/gfs2/sys.c
@@ -222,7 +222,6 @@ static struct kobj_type gfs2_ktype = {
 };
 static struct kset gfs2_kset = {
-        .subsys = &fs_subsys,
        .kobj   = {.name = "gfs2"},
        .ktype  = &gfs2_ktype,
 };
@@ -554,6 +553,7 @@ int gfs2_sys_init(void)
 {
        gfs2_sys_margs = NULL;
        spin_lock_init(&gfs2_sys_margs_lock);
+        kobj_set_kset_s(&gfs2_kset, fs_subsys);
        return kset_register(&gfs2_kset);
 }
diff --git a/fs/hfs/super.c b/fs/hfs/super.c
index 623f509f1d47..4f1888f16cf0 100644
--- a/fs/hfs/super.c
+++ b/fs/hfs/super.c
@@ -434,7 +434,7 @@ static void hfs_init_once(void *p, struct kmem_cache *cachep, unsigned long flag
 {
        struct hfs_inode_info *i = p;
-        if ((flags & (SLAB_CTOR_VERIFY|SLAB_CTOR_CONSTRUCTOR)) == SLAB_CTOR_CONSTRUCTOR)
+        if (flags & SLAB_CTOR_CONSTRUCTOR)
                inode_init_once(&i->vfs_inode);
 }
diff --git a/fs/hfsplus/super.c b/fs/hfsplus/super.c
index 1a97f9293447..37afbec8a761 100644
--- a/fs/hfsplus/super.c
+++ b/fs/hfsplus/super.c
@@ -470,7 +470,7 @@ static void hfsplus_init_once(void *p, struct kmem_cache *cachep, unsigned long
 {
        struct hfsplus_inode_info *i = p;
-        if ((flags & (SLAB_CTOR_VERIFY|SLAB_CTOR_CONSTRUCTOR)) == SLAB_CTOR_CONSTRUCTOR)
+        if (flags & SLAB_CTOR_CONSTRUCTOR)
                inode_init_once(&i->vfs_inode);
 }
diff --git a/fs/hpfs/super.c b/fs/hpfs/super.c
index e0174e338526..1b95f39fbc37 100644
--- a/fs/hpfs/super.c
+++ b/fs/hpfs/super.c
@@ -176,8 +176,7 @@ static void init_once(void * foo, struct kmem_cache * cachep, unsigned long flag
 {
        struct hpfs_inode_info *ei = (struct hpfs_inode_info *) foo;
-        if ((flags & (SLAB_CTOR_VERIFY|SLAB_CTOR_CONSTRUCTOR)) ==
+        if (flags & SLAB_CTOR_CONSTRUCTOR) {
-            SLAB_CTOR_CONSTRUCTOR) {
                mutex_init(&ei->i_mutex);
                mutex_init(&ei->i_parent_mutex);
                inode_init_once(&ei->vfs_inode);
diff --git a/fs/hugetlbfs/inode.c b/fs/hugetlbfs/inode.c
index 8c718a3d413f..98959b87cdf8 100644
--- a/fs/hugetlbfs/inode.c
+++ b/fs/hugetlbfs/inode.c
@@ -22,6 +22,7 @@
 #include <linux/backing-dev.h>
 #include <linux/hugetlb.h>
 #include <linux/pagevec.h>
+#include <linux/mman.h>
 #include <linux/quotaops.h>
 #include <linux/slab.h>
 #include <linux/dnotify.h>
@@ -98,10 +99,7 @@ out:
 * Called under down_write(mmap_sem).
 */
-#ifdef HAVE_ARCH_HUGETLB_UNMAPPED_AREA
+#ifndef HAVE_ARCH_HUGETLB_UNMAPPED_AREA
-unsigned long hugetlb_get_unmapped_area(struct file *file, unsigned long addr,
-                unsigned long len, unsigned long pgoff, unsigned long flags);
-#else
 static unsigned long
 hugetlb_get_unmapped_area(struct file *file, unsigned long addr,
                unsigned long len, unsigned long pgoff, unsigned long flags)
@@ -115,6 +113,12 @@ hugetlb_get_unmapped_area(struct file *file, unsigned long addr,
        if (len > TASK_SIZE)
                return -ENOMEM;
+        if (flags & MAP_FIXED) {
+                if (prepare_hugepage_range(addr, len, pgoff))
+                        return -EINVAL;
+                return addr;
+        }
        if (addr) {
                addr = ALIGN(addr, HPAGE_SIZE);
                vma = find_vma(mm, addr);
@@ -453,7 +457,7 @@ static int hugetlbfs_symlink(struct inode *dir,
 */
 static int hugetlbfs_set_page_dirty(struct page *page)
 {
-        struct page *head = (struct page *)page_private(page);
+        struct page *head = compound_head(page);
        SetPageDirty(head);
        return 0;
@@ -552,8 +556,7 @@ static void init_once(void *foo, struct kmem_cache *cachep, unsigned long flags)
 {
        struct hugetlbfs_inode_info *ei = (struct hugetlbfs_inode_info *)foo;
-        if ((flags & (SLAB_CTOR_VERIFY|SLAB_CTOR_CONSTRUCTOR)) ==
+        if (flags & SLAB_CTOR_CONSTRUCTOR)
-            SLAB_CTOR_CONSTRUCTOR)
                inode_init_once(&ei->vfs_inode);
 }
@@ -744,6 +747,9 @@ struct file *hugetlb_zero_setup(size_t size)
        char buf[16];
        static atomic_t counter;
+        if (!hugetlbfs_vfsmount)
+                return ERR_PTR(-ENOENT);
        if (!can_do_hugetlb_shm())
                return ERR_PTR(-EPERM);
diff --git a/fs/inode.c b/fs/inode.c
index 5abb097ab1b0..b4296bf62739 100644
--- a/fs/inode.c
+++ b/fs/inode.c
@@ -213,8 +213,7 @@ static void init_once(void * foo, struct kmem_cache * cachep, unsigned long flag
 {
        struct inode * inode = (struct inode *) foo;
-        if ((flags & (SLAB_CTOR_VERIFY|SLAB_CTOR_CONSTRUCTOR)) ==
+        if (flags & SLAB_CTOR_CONSTRUCTOR)
-            SLAB_CTOR_CONSTRUCTOR)
                inode_init_once(inode);
 }
diff --git a/fs/isofs/inode.c b/fs/isofs/inode.c
index 64a96cdfe3a4..e99f7ff4ecb4 100644
--- a/fs/isofs/inode.c
+++ b/fs/isofs/inode.c
@@ -77,8 +77,7 @@ static void init_once(void *foo, struct kmem_cache * cachep, unsigned long flags
 {
        struct iso_inode_info *ei = foo;
-        if ((flags & (SLAB_CTOR_VERIFY|SLAB_CTOR_CONSTRUCTOR)) ==
+        if (flags & SLAB_CTOR_CONSTRUCTOR)
-            SLAB_CTOR_CONSTRUCTOR)
                inode_init_once(&ei->vfs_inode);
 }
 
diff --git a/fs/jffs2/super.c b/fs/jffs2/super.c
index e51164a8a8d4..45368f8bbe72 100644
--- a/fs/jffs2/super.c
+++ b/fs/jffs2/super.c
@@ -47,8 +47,7 @@ static void jffs2_i_init_once(void * foo, struct kmem_cache * cachep, unsigned l
 {
        struct jffs2_inode_info *ei = (struct jffs2_inode_info *) foo;
-        if ((flags & (SLAB_CTOR_VERIFY|SLAB_CTOR_CONSTRUCTOR)) ==
+        if (flags & SLAB_CTOR_CONSTRUCTOR) {
-            SLAB_CTOR_CONSTRUCTOR) {
                init_MUTEX(&ei->sem);
                inode_init_once(&ei->vfs_inode);
        }
diff --git a/fs/jfs/jfs_metapage.c b/fs/jfs/jfs_metapage.c
index 58deae007507..6b3acb0b5781 100644
--- a/fs/jfs/jfs_metapage.c
+++ b/fs/jfs/jfs_metapage.c
@@ -184,8 +184,7 @@ static void init_once(void *foo, struct kmem_cache *cachep, unsigned long flags)
 {
        struct metapage *mp = (struct metapage *)foo;
-        if ((flags & (SLAB_CTOR_VERIFY|SLAB_CTOR_CONSTRUCTOR)) ==
+        if (flags & SLAB_CTOR_CONSTRUCTOR) {
-            SLAB_CTOR_CONSTRUCTOR) {
                mp->lid = 0;
                mp->lsn = 0;
                mp->flag = 0;
diff --git a/fs/jfs/super.c b/fs/jfs/super.c
index 52d73d54a931..ea9dc3e65dcf 100644
--- a/fs/jfs/super.c
+++ b/fs/jfs/super.c
@@ -752,8 +752,7 @@ static void init_once(void *foo, struct kmem_cache * cachep, unsigned long flags
 {
        struct jfs_inode_info *jfs_ip = (struct jfs_inode_info *) foo;
-        if ((flags & (SLAB_CTOR_VERIFY | SLAB_CTOR_CONSTRUCTOR)) ==
+        if (flags & SLAB_CTOR_CONSTRUCTOR) {
-            SLAB_CTOR_CONSTRUCTOR) {
                memset(jfs_ip, 0, sizeof(struct jfs_inode_info));
                INIT_LIST_HEAD(&jfs_ip->anon_inode_list);
                init_rwsem(&jfs_ip->rdwrlock);
diff --git a/fs/lockd/mon.c b/fs/lockd/mon.c
index eb243edf8932..2102e2d0134d 100644
--- a/fs/lockd/mon.c
+++ b/fs/lockd/mon.c
@@ -225,16 +225,13 @@ xdr_decode_stat(struct rpc_rqst *rqstp, __be32 *p, struct nsm_res *resp)
 #define SM_monres_sz    2
 #define SM_unmonres_sz  1
-#ifndef MAX
-# define MAX(a, b)      (((a) > (b))? (a) : (b))
-#endif
 static struct rpc_procinfo      nsm_procedures[] = {
 [SM_MON] = {
                .p_proc         = SM_MON,
                .p_encode       = (kxdrproc_t) xdr_encode_mon,
                .p_decode       = (kxdrproc_t) xdr_decode_stat_res,
-                .p_bufsiz       = MAX(SM_mon_sz, SM_monres_sz) << 2,
+                .p_arglen       = SM_mon_sz,
+                .p_replen       = SM_monres_sz,
                .p_statidx      = SM_MON,
                .p_name         = "MONITOR",
        },
@@ -242,7 +239,8 @@ static struct rpc_procinfo	nsm_procedures[] = {
                .p_proc         = SM_UNMON,
                .p_encode       = (kxdrproc_t) xdr_encode_unmon,
                .p_decode       = (kxdrproc_t) xdr_decode_stat,
-                .p_bufsiz       = MAX(SM_mon_id_sz, SM_unmonres_sz) << 2,
+                .p_arglen       = SM_mon_id_sz,
+                .p_replen       = SM_unmonres_sz,
                .p_statidx      = SM_UNMON,
                .p_name         = "UNMONITOR",
        },
diff --git a/fs/lockd/xdr.c b/fs/lockd/xdr.c
index 34dae5d70738..9702956d206c 100644
--- a/fs/lockd/xdr.c
+++ b/fs/lockd/xdr.c
@@ -510,17 +510,20 @@ nlmclt_decode_res(struct rpc_rqst *req, __be32 *p, struct nlm_res *resp)
        return 0;
 }
+#if (NLMCLNT_OHSIZE > XDR_MAX_NETOBJ)
+#  error "NLM host name cannot be larger than XDR_MAX_NETOBJ!"
+#endif
 /*
 * Buffer requirements for NLM
 */
 #define NLM_void_sz             0
 #define NLM_cookie_sz           1+XDR_QUADLEN(NLM_MAXCOOKIELEN)
-#define NLM_caller_sz           1+XDR_QUADLEN(sizeof(utsname()->nodename))
+#define NLM_caller_sz           1+XDR_QUADLEN(NLMCLNT_OHSIZE)
-#define NLM_netobj_sz           1+XDR_QUADLEN(XDR_MAX_NETOBJ)
+#define NLM_owner_sz            1+XDR_QUADLEN(NLMCLNT_OHSIZE)
-/* #define NLM_owner_sz         1+XDR_QUADLEN(NLM_MAXOWNER) */
 #define NLM_fhandle_sz          1+XDR_QUADLEN(NFS2_FHSIZE)
-#define NLM_lock_sz             3+NLM_caller_sz+NLM_netobj_sz+NLM_fhandle_sz
+#define NLM_lock_sz             3+NLM_caller_sz+NLM_owner_sz+NLM_fhandle_sz
-#define NLM_holder_sz           4+NLM_netobj_sz
+#define NLM_holder_sz           4+NLM_owner_sz
 #define NLM_testargs_sz         NLM_cookie_sz+1+NLM_lock_sz
 #define NLM_lockargs_sz         NLM_cookie_sz+4+NLM_lock_sz
@@ -531,10 +534,6 @@ nlmclt_decode_res(struct rpc_rqst *req, __be32 *p, struct nlm_res *resp)
 #define NLM_res_sz              NLM_cookie_sz+1
 #define NLM_norep_sz            0
-#ifndef MAX
-# define MAX(a, b)              (((a) > (b))? (a) : (b))
-#endif
 /*
 * For NLM, a void procedure really returns nothing
 */
@@ -545,7 +544,8 @@ nlmclt_decode_res(struct rpc_rqst *req, __be32 *p, struct nlm_res *resp)
        .p_proc      = NLMPROC_##proc,                                  \
        .p_encode    = (kxdrproc_t) nlmclt_encode_##argtype,            \
        .p_decode    = (kxdrproc_t) nlmclt_decode_##restype,            \
-        .p_bufsiz    = MAX(NLM_##argtype##_sz, NLM_##restype##_sz) << 2,        \
+        .p_arglen    = NLM_##argtype##_sz,                              \
+        .p_replen    = NLM_##restype##_sz,                              \
        .p_statidx   = NLMPROC_##proc,                                  \
        .p_name      = #proc,                                           \
        }
diff --git a/fs/lockd/xdr4.c b/fs/lockd/xdr4.c
index a78240551219..ce1efdbe1b3a 100644
--- a/fs/lockd/xdr4.c
+++ b/fs/lockd/xdr4.c
@@ -516,17 +516,24 @@ nlm4clt_decode_res(struct rpc_rqst *req, __be32 *p, struct nlm_res *resp)
        return 0;
 }
+#if (NLMCLNT_OHSIZE > XDR_MAX_NETOBJ)
+#  error "NLM host name cannot be larger than XDR_MAX_NETOBJ!"
+#endif
+#if (NLMCLNT_OHSIZE > NLM_MAXSTRLEN)
+#  error "NLM host name cannot be larger than NLM's maximum string length!"
+#endif
 /*
 * Buffer requirements for NLM
 */
 #define NLM4_void_sz            0
 #define NLM4_cookie_sz          1+XDR_QUADLEN(NLM_MAXCOOKIELEN)
-#define NLM4_caller_sz          1+XDR_QUADLEN(NLM_MAXSTRLEN)
+#define NLM4_caller_sz          1+XDR_QUADLEN(NLMCLNT_OHSIZE)
-#define NLM4_netobj_sz          1+XDR_QUADLEN(XDR_MAX_NETOBJ)
+#define NLM4_owner_sz           1+XDR_QUADLEN(NLMCLNT_OHSIZE)
-/* #define NLM4_owner_sz                1+XDR_QUADLEN(NLM4_MAXOWNER) */
 #define NLM4_fhandle_sz         1+XDR_QUADLEN(NFS3_FHSIZE)
-#define NLM4_lock_sz            5+NLM4_caller_sz+NLM4_netobj_sz+NLM4_fhandle_sz
+#define NLM4_lock_sz            5+NLM4_caller_sz+NLM4_owner_sz+NLM4_fhandle_sz
-#define NLM4_holder_sz          6+NLM4_netobj_sz
+#define NLM4_holder_sz          6+NLM4_owner_sz
 #define NLM4_testargs_sz        NLM4_cookie_sz+1+NLM4_lock_sz
 #define NLM4_lockargs_sz        NLM4_cookie_sz+4+NLM4_lock_sz
@@ -537,10 +544,6 @@ nlm4clt_decode_res(struct rpc_rqst *req, __be32 *p, struct nlm_res *resp)
 #define NLM4_res_sz             NLM4_cookie_sz+1
 #define NLM4_norep_sz           0
-#ifndef MAX
-# define MAX(a,b)               (((a) > (b))? (a) : (b))
-#endif
 /*
 * For NLM, a void procedure really returns nothing
 */
@@ -551,7 +554,8 @@ nlm4clt_decode_res(struct rpc_rqst *req, __be32 *p, struct nlm_res *resp)
        .p_proc      = NLMPROC_##proc,                                  \
        .p_encode    = (kxdrproc_t) nlm4clt_encode_##argtype,           \
        .p_decode    = (kxdrproc_t) nlm4clt_decode_##restype,           \
-        .p_bufsiz    = MAX(NLM4_##argtype##_sz, NLM4_##restype##_sz) << 2,      \
+        .p_arglen    = NLM4_##argtype##_sz,                             \
+        .p_replen    = NLM4_##restype##_sz,                             \
        .p_statidx   = NLMPROC_##proc,                                  \
        .p_name      = #proc,                                           \
        }
diff --git a/fs/locks.c b/fs/locks.c
index 52a81005dab4..325578074742 100644
--- a/fs/locks.c
+++ b/fs/locks.c
@@ -203,8 +203,7 @@ static void init_once(void *foo, struct kmem_cache *cache, unsigned long flags)
 {
        struct file_lock *lock = (struct file_lock *) foo;
-        if ((flags & (SLAB_CTOR_VERIFY|SLAB_CTOR_CONSTRUCTOR)) !=
+        if (!(flags & SLAB_CTOR_CONSTRUCTOR))
-                                        SLAB_CTOR_CONSTRUCTOR)
                return;
        locks_init_lock(lock);
diff --git a/fs/minix/dir.c b/fs/minix/dir.c
index cb4cb571fddf..e207cbe70951 100644
--- a/fs/minix/dir.c
+++ b/fs/minix/dir.c
@@ -65,7 +65,6 @@ static struct page * dir_get_page(struct inode *dir, unsigned long n)
        struct address_space *mapping = dir->i_mapping;
        struct page *page = read_mapping_page(mapping, n, NULL);
        if (!IS_ERR(page)) {
-                wait_on_page_locked(page);
                kmap(page);
                if (!PageUptodate(page))
                        goto fail;
diff --git a/fs/minix/inode.c b/fs/minix/inode.c
index 92e383af3709..2f4d43a2a310 100644
--- a/fs/minix/inode.c
+++ b/fs/minix/inode.c
@@ -73,8 +73,7 @@ static void init_once(void * foo, struct kmem_cache * cachep, unsigned long flag
 {
        struct minix_inode_info *ei = (struct minix_inode_info *) foo;
-        if ((flags & (SLAB_CTOR_VERIFY|SLAB_CTOR_CONSTRUCTOR)) ==
+        if (flags & SLAB_CTOR_CONSTRUCTOR)
-            SLAB_CTOR_CONSTRUCTOR)
                inode_init_once(&ei->vfs_inode);
 }
 
diff --git a/fs/namei.c b/fs/namei.c
index 880052cadbcd..94b2f60aec22 100644
--- a/fs/namei.c
+++ b/fs/namei.c
@@ -2671,19 +2671,9 @@ static char *page_getlink(struct dentry * dentry, struct page **ppage)
        struct address_space *mapping = dentry->d_inode->i_mapping;
        page = read_mapping_page(mapping, 0, NULL);
        if (IS_ERR(page))
-                goto sync_fail;
+                return (char*)page;
-        wait_on_page_locked(page);
-        if (!PageUptodate(page))
-                goto async_fail;
        *ppage = page;
        return kmap(page);
-async_fail:
-        page_cache_release(page);
-        return ERR_PTR(-EIO);
-sync_fail:
-        return (char*)page;
 }
 int page_readlink(struct dentry *dentry, char __user *buffer, int buflen)
diff --git a/fs/ncpfs/inode.c b/fs/ncpfs/inode.c
index 7285c94956c4..c29f00ad495d 100644
--- a/fs/ncpfs/inode.c
+++ b/fs/ncpfs/inode.c
@@ -60,8 +60,7 @@ static void init_once(void * foo, struct kmem_cache * cachep, unsigned long flag
 {
        struct ncp_inode_info *ei = (struct ncp_inode_info *) foo;
-        if ((flags & (SLAB_CTOR_VERIFY|SLAB_CTOR_CONSTRUCTOR)) ==
+        if (flags & SLAB_CTOR_CONSTRUCTOR) {
-            SLAB_CTOR_CONSTRUCTOR) {
                mutex_init(&ei->open_mutex);
                inode_init_once(&ei->vfs_inode);
        }
diff --git a/fs/nfs/client.c b/fs/nfs/client.c
index 2190e6c2792e..5bd03b97002e 100644
--- a/fs/nfs/client.c
+++ b/fs/nfs/client.c
@@ -618,7 +618,8 @@ static int nfs_init_server(struct nfs_server *server, const struct nfs_mount_dat
        if (clp->cl_nfsversion == 3) {
                if (server->namelen == 0 || server->namelen > NFS3_MAXNAMLEN)
                        server->namelen = NFS3_MAXNAMLEN;
-                server->caps |= NFS_CAP_READDIRPLUS;
+                if (!(data->flags & NFS_MOUNT_NORDIRPLUS))
+                        server->caps |= NFS_CAP_READDIRPLUS;
        } else {
                if (server->namelen == 0 || server->namelen > NFS2_MAXNAMLEN)
                        server->namelen = NFS2_MAXNAMLEN;
diff --git a/fs/nfs/dir.c b/fs/nfs/dir.c
index cd3469720cbf..625d8e5fb39d 100644
--- a/fs/nfs/dir.c
+++ b/fs/nfs/dir.c
@@ -154,6 +154,8 @@ typedef struct {
        decode_dirent_t decode;
        int             plus;
        int             error;
+        unsigned long   timestamp;
+        int             timestamp_valid;
 } nfs_readdir_descriptor_t;
 /* Now we cache directories properly, by stuffing the dirent
@@ -195,6 +197,8 @@ int nfs_readdir_filler(nfs_readdir_descriptor_t *desc, struct page *page)
                }
                goto error;
        }
+        desc->timestamp = timestamp;
+        desc->timestamp_valid = 1;
        SetPageUptodate(page);
        spin_lock(&inode->i_lock);
        NFS_I(inode)->cache_validity |= NFS_INO_INVALID_ATIME;
@@ -225,6 +229,10 @@ int dir_decode(nfs_readdir_descriptor_t *desc)
        if (IS_ERR(p))
                return PTR_ERR(p);
        desc->ptr = p;
+        if (desc->timestamp_valid)
+                desc->entry->fattr->time_start = desc->timestamp;
+        else
+                desc->entry->fattr->valid &= ~NFS_ATTR_FATTR;
        return 0;
 }
@@ -316,14 +324,16 @@ int find_dirent_page(nfs_readdir_descriptor_t *desc)
                        __FUNCTION__, desc->page_index,
                        (long long) *desc->dir_cookie);
+        /* If we find the page in the page_cache, we cannot be sure
+         * how fresh the data is, so we will ignore readdir_plus attributes.
+         */
+        desc->timestamp_valid = 0;
        page = read_cache_page(inode->i_mapping, desc->page_index,
                               (filler_t *)nfs_readdir_filler, desc);
        if (IS_ERR(page)) {
                status = PTR_ERR(page);
                goto out;
        }
-        if (!PageUptodate(page))
-                goto read_error;
        /* NOTE: Someone else may have changed the READDIRPLUS flag */
        desc->page = page;
@@ -337,9 +347,6 @@ int find_dirent_page(nfs_readdir_descriptor_t *desc)
 out:
        dfprintk(DIRCACHE, "NFS: %s: returns %d\n", __FUNCTION__, status);
        return status;
- read_error:
-        page_cache_release(page);
-        return -EIO;
 }
 /*
@@ -468,6 +475,7 @@ int uncached_readdir(nfs_readdir_descriptor_t *desc, void *dirent,
        struct rpc_cred *cred = nfs_file_cred(file);
        struct page     *page = NULL;
        int             status;
+        unsigned long   timestamp;
        dfprintk(DIRCACHE, "NFS: uncached_readdir() searching for cookie %Lu\n",
                        (unsigned long long)*desc->dir_cookie);
@@ -477,6 +485,7 @@ int uncached_readdir(nfs_readdir_descriptor_t *desc, void *dirent,
                status = -ENOMEM;
                goto out;
        }
+        timestamp = jiffies;
        desc->error = NFS_PROTO(inode)->readdir(file->f_path.dentry, cred, *desc->dir_cookie,
                                                page,
                                                NFS_SERVER(inode)->dtsize,
@@ -487,6 +496,8 @@ int uncached_readdir(nfs_readdir_descriptor_t *desc, void *dirent,
        desc->page = page;
        desc->ptr = kmap(page);         /* matching kunmap in nfs_do_filldir */
        if (desc->error >= 0) {
+                desc->timestamp = timestamp;
+                desc->timestamp_valid = 1;
                if ((status = dir_decode(desc)) == 0)
                        desc->entry->prev_cookie = *desc->dir_cookie;
        } else
@@ -849,6 +860,10 @@ static int nfs_dentry_delete(struct dentry *dentry)
 static void nfs_dentry_iput(struct dentry *dentry, struct inode *inode)
 {
        nfs_inode_return_delegation(inode);
+        if (S_ISDIR(inode->i_mode))
+                /* drop any readdir cache as it could easily be old */
+                NFS_I(inode)->cache_validity |= NFS_INO_INVALID_DATA;
        if (dentry->d_flags & DCACHE_NFSFS_RENAMED) {
                lock_kernel();
                drop_nlink(inode);
diff --git a/fs/nfs/direct.c b/fs/nfs/direct.c
index 2877744cb606..889de60f8a84 100644
--- a/fs/nfs/direct.c
+++ b/fs/nfs/direct.c
@@ -54,6 +54,7 @@
 #include <asm/uaccess.h>
 #include <asm/atomic.h>
+#include "internal.h"
 #include "iostat.h"
 #define NFSDBG_FACILITY         NFSDBG_VFS
@@ -271,7 +272,7 @@ static ssize_t nfs_direct_read_schedule(struct nfs_direct_req *dreq, unsigned lo
                bytes = min(rsize,count);
                result = -ENOMEM;
-                data = nfs_readdata_alloc(pgbase + bytes);
+                data = nfs_readdata_alloc(nfs_page_array_len(pgbase, bytes));
                if (unlikely(!data))
                        break;
@@ -602,7 +603,7 @@ static ssize_t nfs_direct_write_schedule(struct nfs_direct_req *dreq, unsigned l
                bytes = min(wsize,count);
                result = -ENOMEM;
-                data = nfs_writedata_alloc(pgbase + bytes);
+                data = nfs_writedata_alloc(nfs_page_array_len(pgbase, bytes));
                if (unlikely(!data))
                        break;
diff --git a/fs/nfs/inode.c b/fs/nfs/inode.c
index 44aa9b726573..1e9a915d1fea 100644
--- a/fs/nfs/inode.c
+++ b/fs/nfs/inode.c
@@ -1167,8 +1167,7 @@ static void init_once(void * foo, struct kmem_cache * cachep, unsigned long flag
 {
        struct nfs_inode *nfsi = (struct nfs_inode *) foo;
-        if ((flags & (SLAB_CTOR_VERIFY|SLAB_CTOR_CONSTRUCTOR)) ==
+        if (flags & SLAB_CTOR_CONSTRUCTOR) {
-            SLAB_CTOR_CONSTRUCTOR) {
                inode_init_once(&nfsi->vfs_inode);
                spin_lock_init(&nfsi->req_lock);
                INIT_LIST_HEAD(&nfsi->dirty);
diff --git a/fs/nfs/internal.h b/fs/nfs/internal.h
index 6610f2b02077..ad2b40db1e65 100644
--- a/fs/nfs/internal.h
+++ b/fs/nfs/internal.h
@@ -231,3 +231,15 @@ unsigned int nfs_page_length(struct page *page)
        }
        return 0;
 }
+/*
+ * Determine the number of pages in an array of length 'len' and
+ * with a base offset of 'base'
+ */
+static inline
+unsigned int nfs_page_array_len(unsigned int base, size_t len)
+{
+        return ((unsigned long)len + (unsigned long)base +
+                PAGE_SIZE - 1) >> PAGE_SHIFT;
+}
diff --git a/fs/nfs/mount_clnt.c b/fs/nfs/mount_clnt.c
index f75fe72b4160..ca5a266a3140 100644
--- a/fs/nfs/mount_clnt.c
+++ b/fs/nfs/mount_clnt.c
@@ -133,13 +133,15 @@ xdr_decode_fhstatus3(struct rpc_rqst *req, __be32 *p, struct mnt_fhstatus *res)
 #define MNT_dirpath_sz          (1 + 256)
 #define MNT_fhstatus_sz         (1 + 8)
+#define MNT_fhstatus3_sz        (1 + 16)
 static struct rpc_procinfo      mnt_procedures[] = {
 [MNTPROC_MNT] = {
          .p_proc               = MNTPROC_MNT,
          .p_encode             = (kxdrproc_t) xdr_encode_dirpath,      
          .p_decode             = (kxdrproc_t) xdr_decode_fhstatus,
-          .p_bufsiz             = MNT_dirpath_sz << 2,
+          .p_arglen             = MNT_dirpath_sz,
+          .p_replen             = MNT_fhstatus_sz,
          .p_statidx            = MNTPROC_MNT,
          .p_name               = "MOUNT",
        },
@@ -150,7 +152,8 @@ static struct rpc_procinfo mnt3_procedures[] = {
          .p_proc               = MOUNTPROC3_MNT,
          .p_encode             = (kxdrproc_t) xdr_encode_dirpath,
          .p_decode             = (kxdrproc_t) xdr_decode_fhstatus3,
-          .p_bufsiz             = MNT_dirpath_sz << 2,
+          .p_arglen             = MNT_dirpath_sz,
+          .p_replen             = MNT_fhstatus3_sz,
          .p_statidx            = MOUNTPROC3_MNT,
          .p_name               = "MOUNT",
        },
diff --git a/fs/nfs/nfs2xdr.c b/fs/nfs/nfs2xdr.c
index 3be4e72a0227..abd9f8b48943 100644
--- a/fs/nfs/nfs2xdr.c
+++ b/fs/nfs/nfs2xdr.c
@@ -687,16 +687,13 @@ nfs_stat_to_errno(int stat)
        return nfs_errtbl[i].errno;
 }
-#ifndef MAX
-# define MAX(a, b)      (((a) > (b))? (a) : (b))
-#endif
 #define PROC(proc, argtype, restype, timer)                             \
 [NFSPROC_##proc] = {                                                    \
        .p_proc     =  NFSPROC_##proc,                                  \
        .p_encode   =  (kxdrproc_t) nfs_xdr_##argtype,                  \
        .p_decode   =  (kxdrproc_t) nfs_xdr_##restype,                  \
-        .p_bufsiz   =  MAX(NFS_##argtype##_sz,NFS_##restype##_sz) << 2, \
+        .p_arglen   =  NFS_##argtype##_sz,                              \
+        .p_replen   =  NFS_##restype##_sz,                              \
        .p_timer    =  timer,                                           \
        .p_statidx  =  NFSPROC_##proc,                                  \
        .p_name     =  #proc,                                           \
diff --git a/fs/nfs/nfs3xdr.c b/fs/nfs/nfs3xdr.c
index 0ace092d126f..b51df8eb9f01 100644
--- a/fs/nfs/nfs3xdr.c
+++ b/fs/nfs/nfs3xdr.c
@@ -1102,16 +1102,13 @@ nfs3_xdr_setaclres(struct rpc_rqst *req, __be32 *p, struct nfs_fattr *fattr)
 }
 #endif  /* CONFIG_NFS_V3_ACL */
-#ifndef MAX
-# define MAX(a, b)      (((a) > (b))? (a) : (b))
-#endif
 #define PROC(proc, argtype, restype, timer)                             \
 [NFS3PROC_##proc] = {                                                   \
        .p_proc      = NFS3PROC_##proc,                                 \
        .p_encode    = (kxdrproc_t) nfs3_xdr_##argtype,                 \
        .p_decode    = (kxdrproc_t) nfs3_xdr_##restype,                 \
-        .p_bufsiz    = MAX(NFS3_##argtype##_sz,NFS3_##restype##_sz) << 2,       \
+        .p_arglen    = NFS3_##argtype##_sz,                             \
+        .p_replen    = NFS3_##restype##_sz,                             \
        .p_timer     = timer,                                           \
        .p_statidx   = NFS3PROC_##proc,                                 \
        .p_name      = #proc,                                           \
@@ -1153,7 +1150,8 @@ static struct rpc_procinfo	nfs3_acl_procedures[] = {
                .p_proc = ACLPROC3_GETACL,
                .p_encode = (kxdrproc_t) nfs3_xdr_getaclargs,
                .p_decode = (kxdrproc_t) nfs3_xdr_getaclres,
-                .p_bufsiz = MAX(ACL3_getaclargs_sz, ACL3_getaclres_sz) << 2,
+                .p_arglen = ACL3_getaclargs_sz,
+                .p_replen = ACL3_getaclres_sz,
                .p_timer = 1,
                .p_name = "GETACL",
        },
@@ -1161,7 +1159,8 @@ static struct rpc_procinfo	nfs3_acl_procedures[] = {
                .p_proc = ACLPROC3_SETACL,
                .p_encode = (kxdrproc_t) nfs3_xdr_setaclargs,
                .p_decode = (kxdrproc_t) nfs3_xdr_setaclres,
-                .p_bufsiz = MAX(ACL3_setaclargs_sz, ACL3_setaclres_sz) << 2,
+                .p_arglen = ACL3_setaclargs_sz,
+                .p_replen = ACL3_setaclres_sz,
                .p_timer = 0,
                .p_name = "SETACL",
        },
diff --git a/fs/nfs/nfs4proc.c b/fs/nfs/nfs4proc.c
index f52cf5c33c6c..3b5ca1b15fe9 100644
--- a/fs/nfs/nfs4proc.c
+++ b/fs/nfs/nfs4proc.c
@@ -2647,8 +2647,7 @@ static int __nfs4_proc_set_acl(struct inode *inode, const void *buf, size_t bufl
        nfs_inode_return_delegation(inode);
        buf_to_pages(buf, buflen, arg.acl_pages, &arg.acl_pgbase);
        ret = rpc_call_sync(NFS_CLIENT(inode), &msg, 0);
-        if (ret == 0)
+        nfs_zap_caches(inode);
-                nfs4_write_cached_acl(inode, buf, buflen);
        return ret;
 }
diff --git a/fs/nfs/nfs4xdr.c b/fs/nfs/nfs4xdr.c
index f02d522fd788..b8c28f2380a5 100644
--- a/fs/nfs/nfs4xdr.c
+++ b/fs/nfs/nfs4xdr.c
@@ -4546,16 +4546,13 @@ nfs4_stat_to_errno(int stat)
        return stat;
 }
-#ifndef MAX
-# define MAX(a, b)      (((a) > (b))? (a) : (b))
-#endif
 #define PROC(proc, argtype, restype)                            \
 [NFSPROC4_CLNT_##proc] = {                                      \
        .p_proc   = NFSPROC4_COMPOUND,                          \
        .p_encode = (kxdrproc_t) nfs4_xdr_##argtype,            \
        .p_decode = (kxdrproc_t) nfs4_xdr_##restype,            \
-        .p_bufsiz = MAX(NFS4_##argtype##_sz,NFS4_##restype##_sz) << 2,  \
+        .p_arglen = NFS4_##argtype##_sz,                        \
+        .p_replen = NFS4_##restype##_sz,                        \
        .p_statidx = NFSPROC4_CLNT_##proc,                      \
        .p_name   = #proc,                                      \
    }
diff --git a/fs/nfs/nfsroot.c b/fs/nfs/nfsroot.c
index 75f819dc0255..49d1008ce1d7 100644
--- a/fs/nfs/nfsroot.c
+++ b/fs/nfs/nfsroot.c
@@ -428,7 +428,7 @@ static int __init root_nfs_getport(int program, int version, int proto)
        printk(KERN_NOTICE "Looking up port of RPC %d/%d on %u.%u.%u.%u\n",
                program, version, NIPQUAD(servaddr));
        set_sockaddr(&sin, servaddr, 0);
-        return rpc_getport_external(&sin, program, version, proto);
+        return rpcb_getport_external(&sin, program, version, proto);
 }
diff --git a/fs/nfs/pagelist.c b/fs/nfs/pagelist.c
index ca4b1d4ff42b..388950118f59 100644
--- a/fs/nfs/pagelist.c
+++ b/fs/nfs/pagelist.c
@@ -17,7 +17,8 @@
 #include <linux/nfs_page.h>
 #include <linux/nfs_fs.h>
 #include <linux/nfs_mount.h>
-#include <linux/writeback.h>
+#include "internal.h"
 #define NFS_PARANOIA 1
@@ -50,9 +51,7 @@ nfs_page_free(struct nfs_page *p)
 * @count: number of bytes to read/write
 *
 * The page must be locked by the caller. This makes sure we never
- * create two different requests for the same page, and avoids
+ * create two different requests for the same page.
- * a possible deadlock when we reach the hard limit on the number
- * of dirty pages.
 * User should ensure it is safe to sleep in this function.
 */
 struct nfs_page *
@@ -63,16 +62,12 @@ nfs_create_request(struct nfs_open_context *ctx, struct inode *inode,
        struct nfs_server *server = NFS_SERVER(inode);
        struct nfs_page         *req;
-        /* Deal with hard limits.  */
        for (;;) {
                /* try to allocate the request struct */
                req = nfs_page_alloc();
                if (req != NULL)
                        break;
-                /* Try to free up at least one request in order to stay
-                 * below the hard limit
-                 */
                if (signalled() && (server->flags & NFS_MOUNT_INTR))
                        return ERR_PTR(-ERESTARTSYS);
                yield();
@@ -223,124 +218,151 @@ out:
 }
 /**
- * nfs_coalesce_requests - Split coalesced requests out from a list.
+ * nfs_pageio_init - initialise a page io descriptor
- * @head: source list
+ * @desc: pointer to descriptor
- * @dst: destination list
+ * @inode: pointer to inode
- * @nmax: maximum number of requests to coalesce
+ * @doio: pointer to io function
- *
+ * @bsize: io block size
- * Moves a maximum of 'nmax' elements from one list to another.
+ * @io_flags: extra parameters for the io function
- * The elements are checked to ensure that they form a contiguous set
- * of pages, and that the RPC credentials are the same.
 */
-int
+void nfs_pageio_init(struct nfs_pageio_descriptor *desc,
-nfs_coalesce_requests(struct list_head *head, struct list_head *dst,
+                     struct inode *inode,
-                      unsigned int nmax)
+                     int (*doio)(struct inode *, struct list_head *, unsigned int, size_t, int),
+                     size_t bsize,
+                     int io_flags)
 {
-        struct nfs_page         *req = NULL;
+        INIT_LIST_HEAD(&desc->pg_list);
-        unsigned int            npages = 0;
+        desc->pg_bytes_written = 0;
+        desc->pg_count = 0;
-        while (!list_empty(head)) {
+        desc->pg_bsize = bsize;
-                struct nfs_page *prev = req;
+        desc->pg_base = 0;
+        desc->pg_inode = inode;
-                req = nfs_list_entry(head->next);
+        desc->pg_doio = doio;
-                if (prev) {
+        desc->pg_ioflags = io_flags;
-                        if (req->wb_context->cred != prev->wb_context->cred)
+        desc->pg_error = 0;
-                                break;
-                        if (req->wb_context->lockowner != prev->wb_context->lockowner)
-                                break;
-                        if (req->wb_context->state != prev->wb_context->state)
-                                break;
-                        if (req->wb_index != (prev->wb_index + 1))
-                                break;
-                        if (req->wb_pgbase != 0)
-                                break;
-                }
-                nfs_list_remove_request(req);
-                nfs_list_add_request(req, dst);
-                npages++;
-                if (req->wb_pgbase + req->wb_bytes != PAGE_CACHE_SIZE)
-                        break;
-                if (npages >= nmax)
-                        break;
-        }
-        return npages;
 }
-#define NFS_SCAN_MAXENTRIES 16
 /**
- * nfs_scan_dirty - Scan the radix tree for dirty requests
+ * nfs_can_coalesce_requests - test two requests for compatibility
- * @mapping: pointer to address space
+ * @prev: pointer to nfs_page
- * @wbc: writeback_control structure
+ * @req: pointer to nfs_page
- * @dst: Destination list
 *
- * Moves elements from one of the inode request lists.
+ * The nfs_page structures 'prev' and 'req' are compared to ensure that the
- * If the number of requests is set to 0, the entire address_space
+ * page data area they describe is contiguous, and that their RPC
- * starting at index idx_start, is scanned.
+ * credentials, NFSv4 open state, and lockowners are the same.
- * The requests are *not* checked to ensure that they form a contiguous set.
+ *
- * You must be holding the inode's req_lock when calling this function
+ * Return 'true' if this is the case, else return 'false'.
 */
-long nfs_scan_dirty(struct address_space *mapping,
+static int nfs_can_coalesce_requests(struct nfs_page *prev,
-                        struct writeback_control *wbc,
+                                     struct nfs_page *req)
-                        struct list_head *dst)
 {
-        struct nfs_inode *nfsi = NFS_I(mapping->host);
+        if (req->wb_context->cred != prev->wb_context->cred)
-        struct nfs_page *pgvec[NFS_SCAN_MAXENTRIES];
-        struct nfs_page *req;
-        pgoff_t idx_start, idx_end;
-        long res = 0;
-        int found, i;
-        if (nfsi->ndirty == 0)
                return 0;
-        if (wbc->range_cyclic) {
+        if (req->wb_context->lockowner != prev->wb_context->lockowner)
-                idx_start = 0;
+                return 0;
-                idx_end = ULONG_MAX;
+        if (req->wb_context->state != prev->wb_context->state)
-        } else if (wbc->range_end == 0) {
+                return 0;
-                idx_start = wbc->range_start >> PAGE_CACHE_SHIFT;
+        if (req->wb_index != (prev->wb_index + 1))
-                idx_end = ULONG_MAX;
+                return 0;
-        } else {
+        if (req->wb_pgbase != 0)
-                idx_start = wbc->range_start >> PAGE_CACHE_SHIFT;
+                return 0;
-                idx_end = wbc->range_end >> PAGE_CACHE_SHIFT;
+        if (prev->wb_pgbase + prev->wb_bytes != PAGE_CACHE_SIZE)
-        }
+                return 0;
+        return 1;
+}
-        for (;;) {
+/**
-                unsigned int toscan = NFS_SCAN_MAXENTRIES;
+ * nfs_pageio_do_add_request - Attempt to coalesce a request into a page list.
+ * @desc: destination io descriptor
+ * @req: request
+ *
+ * Returns true if the request 'req' was successfully coalesced into the
+ * existing list of pages 'desc'.
+ */
+static int nfs_pageio_do_add_request(struct nfs_pageio_descriptor *desc,
+                                     struct nfs_page *req)
+{
+        size_t newlen = req->wb_bytes;
-                found = radix_tree_gang_lookup_tag(&nfsi->nfs_page_tree,
+        if (desc->pg_count != 0) {
-                                (void **)&pgvec[0], idx_start, toscan,
+                struct nfs_page *prev;
-                                NFS_PAGE_TAG_DIRTY);
-                /* Did we make progress? */
+                /*
-                if (found <= 0)
+                 * FIXME: ideally we should be able to coalesce all requests
-                        break;
+                 * that are not block boundary aligned, but currently this
+                 * is problematic for the case of bsize < PAGE_CACHE_SIZE,
+                 * since nfs_flush_multi and nfs_pagein_multi assume you
+                 * can have only one struct nfs_page.
+                 */
+                if (desc->pg_bsize < PAGE_SIZE)
+                        return 0;
+                newlen += desc->pg_count;
+                if (newlen > desc->pg_bsize)
+                        return 0;
+                prev = nfs_list_entry(desc->pg_list.prev);
+                if (!nfs_can_coalesce_requests(prev, req))
+                        return 0;
+        } else
+                desc->pg_base = req->wb_pgbase;
+        nfs_list_remove_request(req);
+        nfs_list_add_request(req, &desc->pg_list);
+        desc->pg_count = newlen;
+        return 1;
+}
-                for (i = 0; i < found; i++) {
+/*
-                        req = pgvec[i];
+ * Helper for nfs_pageio_add_request and nfs_pageio_complete
-                        if (!wbc->range_cyclic && req->wb_index > idx_end)
+ */
-                                goto out;
+static void nfs_pageio_doio(struct nfs_pageio_descriptor *desc)
+{
+        if (!list_empty(&desc->pg_list)) {
+                int error = desc->pg_doio(desc->pg_inode,
+                                          &desc->pg_list,
+                                          nfs_page_array_len(desc->pg_base,
+                                                             desc->pg_count),
+                                          desc->pg_count,
+                                          desc->pg_ioflags);
+                if (error < 0)
+                        desc->pg_error = error;
+                else
+                        desc->pg_bytes_written += desc->pg_count;
+        }
+        if (list_empty(&desc->pg_list)) {
+                desc->pg_count = 0;
+                desc->pg_base = 0;
+        }
+}
-                        /* Try to lock request and mark it for writeback */
+/**
-                        if (!nfs_set_page_writeback_locked(req))
+ * nfs_pageio_add_request - Attempt to coalesce a request into a page list.
-                                goto next;
+ * @desc: destination io descriptor
-                        radix_tree_tag_clear(&nfsi->nfs_page_tree,
+ * @req: request
-                                        req->wb_index, NFS_PAGE_TAG_DIRTY);
+ *
-                        nfsi->ndirty--;
+ * Returns true if the request 'req' was successfully coalesced into the
-                        nfs_list_remove_request(req);
+ * existing list of pages 'desc'.
-                        nfs_list_add_request(req, dst);
+ */
-                        res++;
+int nfs_pageio_add_request(struct nfs_pageio_descriptor *desc,
-                        if (res == LONG_MAX)
+                           struct nfs_page *req)
-                                goto out;
+{
-next:
+        while (!nfs_pageio_do_add_request(desc, req)) {
-                        idx_start = req->wb_index + 1;
+                nfs_pageio_doio(desc);
-                }
+                if (desc->pg_error < 0)
+                        return 0;
        }
-out:
+        return 1;
-        WARN_ON ((nfsi->ndirty == 0) != list_empty(&nfsi->dirty));
-        return res;
 }
 /**
+ * nfs_pageio_complete - Complete I/O on an nfs_pageio_descriptor
+ * @desc: pointer to io descriptor
+ */
+void nfs_pageio_complete(struct nfs_pageio_descriptor *desc)
+{
+        nfs_pageio_doio(desc);
+}
+#define NFS_SCAN_MAXENTRIES 16
+/**
 * nfs_scan_list - Scan a list for matching requests
 * @nfsi: NFS inode
 * @head: One of the NFS inode request lists
@@ -355,12 +377,12 @@ out:
 * You must be holding the inode's req_lock when calling this function
 */
 int nfs_scan_list(struct nfs_inode *nfsi, struct list_head *head,
-                struct list_head *dst, unsigned long idx_start,
+                struct list_head *dst, pgoff_t idx_start,
                unsigned int npages)
 {
        struct nfs_page *pgvec[NFS_SCAN_MAXENTRIES];
        struct nfs_page *req;
-        unsigned long idx_end;
+        pgoff_t idx_end;
        int found, i;
        int res;
diff --git a/fs/nfs/read.c b/fs/nfs/read.c
index 6ab4d5a9edf2..9a55807b2a70 100644
--- a/fs/nfs/read.c
+++ b/fs/nfs/read.c
@@ -27,7 +27,8 @@
 #define NFSDBG_FACILITY         NFSDBG_PAGECACHE
-static int nfs_pagein_one(struct list_head *, struct inode *);
+static int nfs_pagein_multi(struct inode *, struct list_head *, unsigned int, size_t, int);
+static int nfs_pagein_one(struct inode *, struct list_head *, unsigned int, size_t, int);
 static const struct rpc_call_ops nfs_read_partial_ops;
 static const struct rpc_call_ops nfs_read_full_ops;
@@ -36,9 +37,8 @@ static mempool_t *nfs_rdata_mempool;
 #define MIN_POOL_READ   (32)
-struct nfs_read_data *nfs_readdata_alloc(size_t len)
+struct nfs_read_data *nfs_readdata_alloc(unsigned int pagecount)
 {
-        unsigned int pagecount = (len + PAGE_SIZE - 1) >> PAGE_SHIFT;
        struct nfs_read_data *p = mempool_alloc(nfs_rdata_mempool, GFP_NOFS);
        if (p) {
@@ -133,7 +133,10 @@ static int nfs_readpage_async(struct nfs_open_context *ctx, struct inode *inode,
                memclear_highpage_flush(page, len, PAGE_CACHE_SIZE - len);
        nfs_list_add_request(new, &one_request);
-        nfs_pagein_one(&one_request, inode);
+        if (NFS_SERVER(inode)->rsize < PAGE_CACHE_SIZE)
+                nfs_pagein_multi(inode, &one_request, 1, len, 0);
+        else
+                nfs_pagein_one(inode, &one_request, 1, len, 0);
        return 0;
 }
@@ -230,7 +233,7 @@ static void nfs_execute_read(struct nfs_read_data *data)
 * won't see the new data until our attribute cache is updated.  This is more
 * or less conventional NFS client behavior.
 */
-static int nfs_pagein_multi(struct list_head *head, struct inode *inode)
+static int nfs_pagein_multi(struct inode *inode, struct list_head *head, unsigned int npages, size_t count, int flags)
 {
        struct nfs_page *req = nfs_list_entry(head->next);
        struct page *page = req->wb_page;
@@ -242,11 +245,11 @@ static int nfs_pagein_multi(struct list_head *head, struct inode *inode)
        nfs_list_remove_request(req);
-        nbytes = req->wb_bytes;
+        nbytes = count;
        do {
                size_t len = min(nbytes,rsize);
-                data = nfs_readdata_alloc(len);
+                data = nfs_readdata_alloc(1);
                if (!data)
                        goto out_bad;
                INIT_LIST_HEAD(&data->pages);
@@ -258,23 +261,19 @@ static int nfs_pagein_multi(struct list_head *head, struct inode *inode)
        ClearPageError(page);
        offset = 0;
-        nbytes = req->wb_bytes;
+        nbytes = count;
        do {
                data = list_entry(list.next, struct nfs_read_data, pages);
                list_del_init(&data->pages);
                data->pagevec[0] = page;
-                if (nbytes > rsize) {
+                if (nbytes < rsize)
-                        nfs_read_rpcsetup(req, data, &nfs_read_partial_ops,
+                        rsize = nbytes;
-                                        rsize, offset);
+                nfs_read_rpcsetup(req, data, &nfs_read_partial_ops,
-                        offset += rsize;
+                                  rsize, offset);
-                        nbytes -= rsize;
+                offset += rsize;
-                } else {
+                nbytes -= rsize;
-                        nfs_read_rpcsetup(req, data, &nfs_read_partial_ops,
-                                        nbytes, offset);
-                        nbytes = 0;
-                }
                nfs_execute_read(data);
        } while (nbytes != 0);
@@ -291,30 +290,24 @@ out_bad:
        return -ENOMEM;
 }
-static int nfs_pagein_one(struct list_head *head, struct inode *inode)
+static int nfs_pagein_one(struct inode *inode, struct list_head *head, unsigned int npages, size_t count, int flags)
 {
        struct nfs_page         *req;
        struct page             **pages;
        struct nfs_read_data    *data;
-        unsigned int            count;
-        if (NFS_SERVER(inode)->rsize < PAGE_CACHE_SIZE)
+        data = nfs_readdata_alloc(npages);
-                return nfs_pagein_multi(head, inode);
-        data = nfs_readdata_alloc(NFS_SERVER(inode)->rsize);
        if (!data)
                goto out_bad;
        INIT_LIST_HEAD(&data->pages);
        pages = data->pagevec;
-        count = 0;
        while (!list_empty(head)) {
                req = nfs_list_entry(head->next);
                nfs_list_remove_request(req);
                nfs_list_add_request(req, &data->pages);
                ClearPageError(req->wb_page);
                *pages++ = req->wb_page;
-                count += req->wb_bytes;
        }
        req = nfs_list_entry(data->pages.next);
@@ -327,28 +320,6 @@ out_bad:
        return -ENOMEM;
 }
-static int
-nfs_pagein_list(struct list_head *head, int rpages)
-{
-        LIST_HEAD(one_request);
-        struct nfs_page         *req;
-        int                     error = 0;
-        unsigned int            pages = 0;
-        while (!list_empty(head)) {
-                pages += nfs_coalesce_requests(head, &one_request, rpages);
-                req = nfs_list_entry(one_request.next);
-                error = nfs_pagein_one(&one_request, req->wb_context->dentry->d_inode);
-                if (error < 0)
-                        break;
-        }
-        if (error >= 0)
-                return pages;
-        nfs_async_read_error(head);
-        return error;
-}
 /*
 * This is the callback from RPC telling us whether a reply was
 * received or some error occurred (timeout or socket shutdown).
@@ -538,7 +509,7 @@ out_error:
 }
 struct nfs_readdesc {
-        struct list_head *head;
+        struct nfs_pageio_descriptor *pgio;
        struct nfs_open_context *ctx;
 };
@@ -562,19 +533,21 @@ readpage_async_filler(void *data, struct page *page)
        }
        if (len < PAGE_CACHE_SIZE)
                memclear_highpage_flush(page, len, PAGE_CACHE_SIZE - len);
-        nfs_list_add_request(new, desc->head);
+        nfs_pageio_add_request(desc->pgio, new);
        return 0;
 }
 int nfs_readpages(struct file *filp, struct address_space *mapping,
                struct list_head *pages, unsigned nr_pages)
 {
-        LIST_HEAD(head);
+        struct nfs_pageio_descriptor pgio;
        struct nfs_readdesc desc = {
-                .head           = &head,
+                .pgio = &pgio,
        };
        struct inode *inode = mapping->host;
        struct nfs_server *server = NFS_SERVER(inode);
+        size_t rsize = server->rsize;
+        unsigned long npages;
        int ret = -ESTALE;
        dprintk("NFS: nfs_readpages (%s/%Ld %d)\n",
@@ -593,13 +566,16 @@ int nfs_readpages(struct file *filp, struct address_space *mapping,
        } else
                desc.ctx = get_nfs_open_context((struct nfs_open_context *)
                                filp->private_data);
+        if (rsize < PAGE_CACHE_SIZE)
+                nfs_pageio_init(&pgio, inode, nfs_pagein_multi, rsize, 0);
+        else
+                nfs_pageio_init(&pgio, inode, nfs_pagein_one, rsize, 0);
        ret = read_cache_pages(mapping, pages, readpage_async_filler, &desc);
-        if (!list_empty(&head)) {
-                int err = nfs_pagein_list(&head, server->rpages);
+        nfs_pageio_complete(&pgio);
-                if (!ret)
+        npages = (pgio.pg_bytes_written + PAGE_CACHE_SIZE - 1) >> PAGE_CACHE_SHIFT;
-                        nfs_add_stats(inode, NFSIOS_READPAGES, err);
+        nfs_add_stats(inode, NFSIOS_READPAGES, npages);
-                        ret = err;
-        }
        put_nfs_open_context(desc.ctx);
 out:
        return ret;
diff --git a/fs/nfs/super.c b/fs/nfs/super.c
index f1eae44b9a1a..ca20d3cc2609 100644
--- a/fs/nfs/super.c
+++ b/fs/nfs/super.c
@@ -204,9 +204,9 @@ static int nfs_statfs(struct dentry *dentry, struct kstatfs *buf)
        lock_kernel();
        error = server->nfs_client->rpc_ops->statfs(server, fh, &res);
-        buf->f_type = NFS_SUPER_MAGIC;
        if (error < 0)
                goto out_err;
+        buf->f_type = NFS_SUPER_MAGIC;
        /*
         * Current versions of glibc do not correctly handle the
@@ -233,15 +233,14 @@ static int nfs_statfs(struct dentry *dentry, struct kstatfs *buf)
        buf->f_ffree = res.afiles;
        buf->f_namelen = server->namelen;
- out:
        unlock_kernel();
        return 0;
 out_err:
        dprintk("%s: statfs error = %d\n", __FUNCTION__, -error);
-        buf->f_bsize = buf->f_blocks = buf->f_bfree = buf->f_bavail = -1;
+        unlock_kernel();
-        goto out;
+        return error;
 }
 /*
@@ -291,6 +290,7 @@ static void nfs_show_mount_options(struct seq_file *m, struct nfs_server *nfss,
                { NFS_MOUNT_NOAC, ",noac", "" },
                { NFS_MOUNT_NONLM, ",nolock", "" },
                { NFS_MOUNT_NOACL, ",noacl", "" },
+                { NFS_MOUNT_NORDIRPLUS, ",nordirplus", "" },
                { 0, NULL, NULL }
        };
        const struct proc_nfs_info *nfs_infop;
diff --git a/fs/nfs/symlink.c b/fs/nfs/symlink.c
index f4a0548b9ce8..bc2821331c29 100644
--- a/fs/nfs/symlink.c
+++ b/fs/nfs/symlink.c
@@ -61,15 +61,9 @@ static void *nfs_follow_link(struct dentry *dentry, struct nameidata *nd)
                err = page;
                goto read_failed;
        }
-        if (!PageUptodate(page)) {
-                err = ERR_PTR(-EIO);
-                goto getlink_read_error;
-        }
        nd_set_link(nd, kmap(page));
        return page;
-getlink_read_error:
-        page_cache_release(page);
 read_failed:
        nd_set_link(nd, err);
        return NULL;
diff --git a/fs/nfs/write.c b/fs/nfs/write.c
index 797558941745..5d44b8bd1070 100644
--- a/fs/nfs/write.c
+++ b/fs/nfs/write.c
@@ -38,7 +38,8 @@
 static struct nfs_page * nfs_update_request(struct nfs_open_context*,
                                            struct page *,
                                            unsigned int, unsigned int);
-static long nfs_flush_mapping(struct address_space *mapping, struct writeback_control *wbc, int how);
+static void nfs_pageio_init_write(struct nfs_pageio_descriptor *desc,
+                                  struct inode *inode, int ioflags);
 static const struct rpc_call_ops nfs_write_partial_ops;
 static const struct rpc_call_ops nfs_write_full_ops;
 static const struct rpc_call_ops nfs_commit_ops;
@@ -71,9 +72,8 @@ void nfs_commit_free(struct nfs_write_data *wdata)
        call_rcu_bh(&wdata->task.u.tk_rcu, nfs_commit_rcu_free);
 }
-struct nfs_write_data *nfs_writedata_alloc(size_t len)
+struct nfs_write_data *nfs_writedata_alloc(unsigned int pagecount)
 {
-        unsigned int pagecount = (len + PAGE_SIZE - 1) >> PAGE_SHIFT;
        struct nfs_write_data *p = mempool_alloc(nfs_wdata_mempool, GFP_NOFS);
        if (p) {
@@ -139,7 +139,7 @@ static void nfs_grow_file(struct page *page, unsigned int offset, unsigned int c
 {
        struct inode *inode = page->mapping->host;
        loff_t end, i_size = i_size_read(inode);
-        unsigned long end_index = (i_size - 1) >> PAGE_CACHE_SHIFT;
+        pgoff_t end_index = (i_size - 1) >> PAGE_CACHE_SHIFT;
        if (i_size > 0 && page->index < end_index)
                return;
@@ -201,7 +201,7 @@ static int nfs_writepage_setup(struct nfs_open_context *ctx, struct page *page,
 static int wb_priority(struct writeback_control *wbc)
 {
        if (wbc->for_reclaim)
-                return FLUSH_HIGHPRI;
+                return FLUSH_HIGHPRI | FLUSH_STABLE;
        if (wbc->for_kupdate)
                return FLUSH_LOWPRI;
        return 0;
@@ -251,7 +251,8 @@ static void nfs_end_page_writeback(struct page *page)
 * was not tagged.
 * May also return an error if the user signalled nfs_wait_on_request().
 */
-static int nfs_page_mark_flush(struct page *page)
+static int nfs_page_async_flush(struct nfs_pageio_descriptor *pgio,
+                                struct page *page)
 {
        struct nfs_page *req;
        struct nfs_inode *nfsi = NFS_I(page->mapping->host);
@@ -273,6 +274,8 @@ static int nfs_page_mark_flush(struct page *page)
                 *       request as dirty (in which case we don't care).
                 */
                spin_unlock(req_lock);
+                /* Prevent deadlock! */
+                nfs_pageio_complete(pgio);
                ret = nfs_wait_on_request(req);
                nfs_release_request(req);
                if (ret != 0)
@@ -283,21 +286,18 @@ static int nfs_page_mark_flush(struct page *page)
                /* This request is marked for commit */
                spin_unlock(req_lock);
                nfs_unlock_request(req);
+                nfs_pageio_complete(pgio);
                return 1;
        }
-        if (nfs_set_page_writeback(page) == 0) {
+        if (nfs_set_page_writeback(page) != 0) {
-                nfs_list_remove_request(req);
-                /* add the request to the inode's dirty list. */
-                radix_tree_tag_set(&nfsi->nfs_page_tree,
-                                req->wb_index, NFS_PAGE_TAG_DIRTY);
-                nfs_list_add_request(req, &nfsi->dirty);
-                nfsi->ndirty++;
-                spin_unlock(req_lock);
-                __mark_inode_dirty(page->mapping->host, I_DIRTY_PAGES);
-        } else
                spin_unlock(req_lock);
+                BUG();
+        }
+        radix_tree_tag_set(&nfsi->nfs_page_tree, req->wb_index,
+                        NFS_PAGE_TAG_WRITEBACK);
        ret = test_bit(PG_NEED_FLUSH, &req->wb_flags);
-        nfs_unlock_request(req);
+        spin_unlock(req_lock);
+        nfs_pageio_add_request(pgio, req);
        return ret;
 }
@@ -306,6 +306,7 @@ static int nfs_page_mark_flush(struct page *page)
 */
 static int nfs_writepage_locked(struct page *page, struct writeback_control *wbc)
 {
+        struct nfs_pageio_descriptor mypgio, *pgio;
        struct nfs_open_context *ctx;
        struct inode *inode = page->mapping->host;
        unsigned offset;
@@ -314,7 +315,14 @@ static int nfs_writepage_locked(struct page *page, struct writeback_control *wbc
        nfs_inc_stats(inode, NFSIOS_VFSWRITEPAGE);
        nfs_add_stats(inode, NFSIOS_WRITEPAGES, 1);
-        err = nfs_page_mark_flush(page);
+        if (wbc->for_writepages)
+                pgio = wbc->fs_private;
+        else {
+                nfs_pageio_init_write(&mypgio, inode, wb_priority(wbc));
+                pgio = &mypgio;
+        }
+        err = nfs_page_async_flush(pgio, page);
        if (err <= 0)
                goto out;
        err = 0;
@@ -331,12 +339,12 @@ static int nfs_writepage_locked(struct page *page, struct writeback_control *wbc
        put_nfs_open_context(ctx);
        if (err != 0)
                goto out;
-        err = nfs_page_mark_flush(page);
+        err = nfs_page_async_flush(pgio, page);
        if (err > 0)
                err = 0;
 out:
        if (!wbc->for_writepages)
-                nfs_flush_mapping(page->mapping, wbc, FLUSH_STABLE|wb_priority(wbc));
+                nfs_pageio_complete(pgio);
        return err;
 }
@@ -352,20 +360,20 @@ int nfs_writepage(struct page *page, struct writeback_control *wbc)
 int nfs_writepages(struct address_space *mapping, struct writeback_control *wbc)
 {
        struct inode *inode = mapping->host;
+        struct nfs_pageio_descriptor pgio;
        int err;
        nfs_inc_stats(inode, NFSIOS_VFSWRITEPAGES);
+        nfs_pageio_init_write(&pgio, inode, wb_priority(wbc));
+        wbc->fs_private = &pgio;
        err = generic_writepages(mapping, wbc);
+        nfs_pageio_complete(&pgio);
        if (err)
                return err;
-        err = nfs_flush_mapping(mapping, wbc, wb_priority(wbc));
+        if (pgio.pg_error)
-        if (err < 0)
+                return pgio.pg_error;
-                goto out;
+        return 0;
-        nfs_add_stats(inode, NFSIOS_WRITEPAGES, err);
-        err = 0;
-out:
-        return err;
 }
 /*
@@ -503,11 +511,11 @@ int nfs_reschedule_unstable_write(struct nfs_page *req)
 *
 * Interruptible by signals only if mounted with intr flag.
 */
-static int nfs_wait_on_requests_locked(struct inode *inode, unsigned long idx_start, unsigned int npages)
+static int nfs_wait_on_requests_locked(struct inode *inode, pgoff_t idx_start, unsigned int npages)
 {
        struct nfs_inode *nfsi = NFS_I(inode);
        struct nfs_page *req;
-        unsigned long           idx_end, next;
+        pgoff_t idx_end, next;
        unsigned int            res = 0;
        int                     error;
@@ -536,18 +544,6 @@ static int nfs_wait_on_requests_locked(struct inode *inode, unsigned long idx_st
        return res;
 }
-static void nfs_cancel_dirty_list(struct list_head *head)
-{
-        struct nfs_page *req;
-        while(!list_empty(head)) {
-                req = nfs_list_entry(head->next);
-                nfs_list_remove_request(req);
-                nfs_end_page_writeback(req->wb_page);
-                nfs_inode_remove_request(req);
-                nfs_clear_page_writeback(req);
-        }
-}
 static void nfs_cancel_commit_list(struct list_head *head)
 {
        struct nfs_page *req;
@@ -574,7 +570,7 @@ static void nfs_cancel_commit_list(struct list_head *head)
 * The requests are *not* checked to ensure that they form a contiguous set.
 */
 static int
-nfs_scan_commit(struct inode *inode, struct list_head *dst, unsigned long idx_start, unsigned int npages)
+nfs_scan_commit(struct inode *inode, struct list_head *dst, pgoff_t idx_start, unsigned int npages)
 {
        struct nfs_inode *nfsi = NFS_I(inode);
        int res = 0;
@@ -588,40 +584,12 @@ nfs_scan_commit(struct inode *inode, struct list_head *dst, unsigned long idx_st
        return res;
 }
 #else
-static inline int nfs_scan_commit(struct inode *inode, struct list_head *dst, unsigned long idx_start, unsigned int npages)
+static inline int nfs_scan_commit(struct inode *inode, struct list_head *dst, pgoff_t idx_start, unsigned int npages)
 {
        return 0;
 }
 #endif
-static int nfs_wait_on_write_congestion(struct address_space *mapping)
-{
-        struct inode *inode = mapping->host;
-        struct backing_dev_info *bdi = mapping->backing_dev_info;
-        int ret = 0;
-        might_sleep();
-        if (!bdi_write_congested(bdi))
-                return 0;
-        nfs_inc_stats(inode, NFSIOS_CONGESTIONWAIT);
-        do {
-                struct rpc_clnt *clnt = NFS_CLIENT(inode);
-                sigset_t oldset;
-                rpc_clnt_sigmask(clnt, &oldset);
-                ret = congestion_wait_interruptible(WRITE, HZ/10);
-                rpc_clnt_sigunmask(clnt, &oldset);
-                if (ret == -ERESTARTSYS)
-                        break;
-                ret = 0;
-        } while (bdi_write_congested(bdi));
-        return ret;
-}
 /*
 * Try to update any existing write request, or create one if there is none.
 * In order to match, the request's credentials must match those of
@@ -636,12 +604,10 @@ static struct nfs_page * nfs_update_request(struct nfs_open_context* ctx,
        struct inode *inode = mapping->host;
        struct nfs_inode *nfsi = NFS_I(inode);
        struct nfs_page         *req, *new = NULL;
-        unsigned long           rqend, end;
+        pgoff_t         rqend, end;
        end = offset + bytes;
-        if (nfs_wait_on_write_congestion(mapping))
-                return ERR_PTR(-ERESTARTSYS);
        for (;;) {
                /* Loop over all inode entries and see if we find
                 * A request for the page we wish to update
@@ -865,7 +831,7 @@ static void nfs_execute_write(struct nfs_write_data *data)
 * Generate multiple small requests to write out a single
 * contiguous dirty area on one page.
 */
-static int nfs_flush_multi(struct inode *inode, struct list_head *head, int how)
+static int nfs_flush_multi(struct inode *inode, struct list_head *head, unsigned int npages, size_t count, int how)
 {
        struct nfs_page *req = nfs_list_entry(head->next);
        struct page *page = req->wb_page;
@@ -877,11 +843,11 @@ static int nfs_flush_multi(struct inode *inode, struct list_head *head, int how)
        nfs_list_remove_request(req);
-        nbytes = req->wb_bytes;
+        nbytes = count;
        do {
                size_t len = min(nbytes, wsize);
-                data = nfs_writedata_alloc(len);
+                data = nfs_writedata_alloc(1);
                if (!data)
                        goto out_bad;
                list_add(&data->pages, &list);
@@ -892,23 +858,19 @@ static int nfs_flush_multi(struct inode *inode, struct list_head *head, int how)
        ClearPageError(page);
        offset = 0;
-        nbytes = req->wb_bytes;
+        nbytes = count;
        do {
                data = list_entry(list.next, struct nfs_write_data, pages);
                list_del_init(&data->pages);
                data->pagevec[0] = page;
-                if (nbytes > wsize) {
+                if (nbytes < wsize)
-                        nfs_write_rpcsetup(req, data, &nfs_write_partial_ops,
+                        wsize = nbytes;
-                                        wsize, offset, how);
+                nfs_write_rpcsetup(req, data, &nfs_write_partial_ops,
-                        offset += wsize;
+                                   wsize, offset, how);
-                        nbytes -= wsize;
+                offset += wsize;
-                } else {
+                nbytes -= wsize;
-                        nfs_write_rpcsetup(req, data, &nfs_write_partial_ops,
-                                        nbytes, offset, how);
-                        nbytes = 0;
-                }
                nfs_execute_write(data);
        } while (nbytes != 0);
@@ -934,26 +896,23 @@ out_bad:
 * This is the case if nfs_updatepage detects a conflicting request
 * that has been written but not committed.
 */
-static int nfs_flush_one(struct inode *inode, struct list_head *head, int how)
+static int nfs_flush_one(struct inode *inode, struct list_head *head, unsigned int npages, size_t count, int how)
 {
        struct nfs_page         *req;
        struct page             **pages;
        struct nfs_write_data   *data;
-        unsigned int            count;
-        data = nfs_writedata_alloc(NFS_SERVER(inode)->wsize);
+        data = nfs_writedata_alloc(npages);
        if (!data)
                goto out_bad;
        pages = data->pagevec;
-        count = 0;
        while (!list_empty(head)) {
                req = nfs_list_entry(head->next);
                nfs_list_remove_request(req);
                nfs_list_add_request(req, &data->pages);
                ClearPageError(req->wb_page);
                *pages++ = req->wb_page;
-                count += req->wb_bytes;
        }
        req = nfs_list_entry(data->pages.next);
@@ -973,40 +932,15 @@ static int nfs_flush_one(struct inode *inode, struct list_head *head, int how)
        return -ENOMEM;
 }
-static int nfs_flush_list(struct inode *inode, struct list_head *head, int npages, int how)
+static void nfs_pageio_init_write(struct nfs_pageio_descriptor *pgio,
+                                  struct inode *inode, int ioflags)
 {
-        LIST_HEAD(one_request);
-        int (*flush_one)(struct inode *, struct list_head *, int);
-        struct nfs_page *req;
-        int wpages = NFS_SERVER(inode)->wpages;
        int wsize = NFS_SERVER(inode)->wsize;
-        int error;
-        flush_one = nfs_flush_one;
        if (wsize < PAGE_CACHE_SIZE)
-                flush_one = nfs_flush_multi;
+                nfs_pageio_init(pgio, inode, nfs_flush_multi, wsize, ioflags);
-        /* For single writes, FLUSH_STABLE is more efficient */
+        else
-        if (npages <= wpages && npages == NFS_I(inode)->npages
+                nfs_pageio_init(pgio, inode, nfs_flush_one, wsize, ioflags);
-                        && nfs_list_entry(head->next)->wb_bytes <= wsize)
-                how |= FLUSH_STABLE;
-        do {
-                nfs_coalesce_requests(head, &one_request, wpages);
-                req = nfs_list_entry(one_request.next);
-                error = flush_one(inode, &one_request, how);
-                if (error < 0)
-                        goto out_err;
-        } while (!list_empty(head));
-        return 0;
-out_err:
-        while (!list_empty(head)) {
-                req = nfs_list_entry(head->next);
-                nfs_list_remove_request(req);
-                nfs_redirty_request(req);
-                nfs_end_page_writeback(req->wb_page);
-                nfs_clear_page_writeback(req);
-        }
-        return error;
 }
 /*
@@ -1330,31 +1264,7 @@ static const struct rpc_call_ops nfs_commit_ops = {
        .rpc_call_done = nfs_commit_done,
        .rpc_release = nfs_commit_release,
 };
-#else
-static inline int nfs_commit_list(struct inode *inode, struct list_head *head, int how)
-{
-        return 0;
-}
-#endif
-static long nfs_flush_mapping(struct address_space *mapping, struct writeback_control *wbc, int how)
-{
-        struct nfs_inode *nfsi = NFS_I(mapping->host);
-        LIST_HEAD(head);
-        long res;
-        spin_lock(&nfsi->req_lock);
-        res = nfs_scan_dirty(mapping, wbc, &head);
-        spin_unlock(&nfsi->req_lock);
-        if (res) {
-                int error = nfs_flush_list(mapping->host, &head, res, how);
-                if (error < 0)
-                        return error;
-        }
-        return res;
-}
-#if defined(CONFIG_NFS_V3) || defined(CONFIG_NFS_V4)
 int nfs_commit_inode(struct inode *inode, int how)
 {
        struct nfs_inode *nfsi = NFS_I(inode);
@@ -1371,13 +1281,18 @@ int nfs_commit_inode(struct inode *inode, int how)
        }
        return res;
 }
+#else
+static inline int nfs_commit_list(struct inode *inode, struct list_head *head, int how)
+{
+        return 0;
+}
 #endif
 long nfs_sync_mapping_wait(struct address_space *mapping, struct writeback_control *wbc, int how)
 {
        struct inode *inode = mapping->host;
        struct nfs_inode *nfsi = NFS_I(inode);
-        unsigned long idx_start, idx_end;
+        pgoff_t idx_start, idx_end;
        unsigned int npages = 0;
        LIST_HEAD(head);
        int nocommit = how & FLUSH_NOCOMMIT;
@@ -1390,41 +1305,24 @@ long nfs_sync_mapping_wait(struct address_space *mapping, struct writeback_contr
                idx_start = wbc->range_start >> PAGE_CACHE_SHIFT;
                idx_end = wbc->range_end >> PAGE_CACHE_SHIFT;
                if (idx_end > idx_start) {
-                        unsigned long l_npages = 1 + idx_end - idx_start;
+                        pgoff_t l_npages = 1 + idx_end - idx_start;
                        npages = l_npages;
                        if (sizeof(npages) != sizeof(l_npages) &&
-                                        (unsigned long)npages != l_npages)
+                                        (pgoff_t)npages != l_npages)
                                npages = 0;
                }
        }
        how &= ~FLUSH_NOCOMMIT;
        spin_lock(&nfsi->req_lock);
        do {
-                wbc->pages_skipped = 0;
                ret = nfs_wait_on_requests_locked(inode, idx_start, npages);
                if (ret != 0)
                        continue;
-                pages = nfs_scan_dirty(mapping, wbc, &head);
-                if (pages != 0) {
-                        spin_unlock(&nfsi->req_lock);
-                        if (how & FLUSH_INVALIDATE) {
-                                nfs_cancel_dirty_list(&head);
-                                ret = pages;
-                        } else
-                                ret = nfs_flush_list(inode, &head, pages, how);
-                        spin_lock(&nfsi->req_lock);
-                        continue;
-                }
-                if (wbc->pages_skipped != 0)
-                        continue;
                if (nocommit)
                        break;
                pages = nfs_scan_commit(inode, &head, idx_start, npages);
-                if (pages == 0) {
+                if (pages == 0)
-                        if (wbc->pages_skipped != 0)
-                                continue;
                        break;
-                }
                if (how & FLUSH_INVALIDATE) {
                        spin_unlock(&nfsi->req_lock);
                        nfs_cancel_commit_list(&head);
@@ -1456,7 +1354,7 @@ int nfs_wb_all(struct inode *inode)
        };
        int ret;
-        ret = generic_writepages(mapping, &wbc);
+        ret = nfs_writepages(mapping, &wbc);
        if (ret < 0)
                goto out;
        ret = nfs_sync_mapping_wait(mapping, &wbc, 0);
@@ -1479,11 +1377,9 @@ int nfs_sync_mapping_range(struct address_space *mapping, loff_t range_start, lo
        };
        int ret;
-        if (!(how & FLUSH_NOWRITEPAGE)) {
+        ret = nfs_writepages(mapping, &wbc);
-                ret = generic_writepages(mapping, &wbc);
+        if (ret < 0)
-                if (ret < 0)
+                goto out;
-                        goto out;
-        }
        ret = nfs_sync_mapping_wait(mapping, &wbc, how);
        if (ret >= 0)
                return 0;
@@ -1506,7 +1402,7 @@ int nfs_wb_page_priority(struct inode *inode, struct page *page, int how)
        int ret;
        BUG_ON(!PageLocked(page));
-        if (!(how & FLUSH_NOWRITEPAGE) && clear_page_dirty_for_io(page)) {
+        if (clear_page_dirty_for_io(page)) {
                ret = nfs_writepage_locked(page, &wbc);
                if (ret < 0)
                        goto out;
@@ -1531,10 +1427,18 @@ int nfs_wb_page(struct inode *inode, struct page* page)
 int nfs_set_page_dirty(struct page *page)
 {
-        spinlock_t *req_lock = &NFS_I(page->mapping->host)->req_lock;
+        struct address_space *mapping = page->mapping;
+        struct inode *inode;
+        spinlock_t *req_lock;
        struct nfs_page *req;
        int ret;
+        if (!mapping)
+                goto out_raced;
+        inode = mapping->host;
+        if (!inode)
+                goto out_raced;
+        req_lock = &NFS_I(inode)->req_lock;
        spin_lock(req_lock);
        req = nfs_page_find_request_locked(page);
        if (req != NULL) {
@@ -1547,6 +1451,8 @@ int nfs_set_page_dirty(struct page *page)
        ret = __set_page_dirty_nobuffers(page);
        spin_unlock(req_lock);
        return ret;
+out_raced:
+        return !TestSetPageDirty(page);
 }
diff --git a/fs/nfsd/nfs4callback.c b/fs/nfsd/nfs4callback.c
index fb14d68eacab..32ffea033c7a 100644
--- a/fs/nfsd/nfs4callback.c
+++ b/fs/nfsd/nfs4callback.c
@@ -315,16 +315,13 @@ out:
 /*
 * RPC procedure tables
 */
-#ifndef MAX
-# define MAX(a, b)      (((a) > (b))? (a) : (b))
-#endif
 #define PROC(proc, call, argtype, restype)                              \
 [NFSPROC4_CLNT_##proc] = {                                              \
        .p_proc   = NFSPROC4_CB_##call,                                 \
        .p_encode = (kxdrproc_t) nfs4_xdr_##argtype,                    \
        .p_decode = (kxdrproc_t) nfs4_xdr_##restype,                    \
-        .p_bufsiz = MAX(NFS4_##argtype##_sz,NFS4_##restype##_sz) << 2,  \
+        .p_arglen = NFS4_##argtype##_sz,                                \
+        .p_replen = NFS4_##restype##_sz,                                \
        .p_statidx = NFSPROC4_CB_##call,                                \
        .p_name   = #proc,                                              \
 }
diff --git a/fs/ntfs/aops.h b/fs/ntfs/aops.h
index 9393f4b1e298..caecc58f529c 100644
--- a/fs/ntfs/aops.h
+++ b/fs/ntfs/aops.h
@@ -89,9 +89,8 @@ static inline struct page *ntfs_map_page(struct address_space *mapping,
        struct page *page = read_mapping_page(mapping, index, NULL);
        if (!IS_ERR(page)) {
-                wait_on_page_locked(page);
                kmap(page);
-                if (PageUptodate(page) && !PageError(page))
+                if (!PageError(page))
                        return page;
                ntfs_unmap_page(page);
                return ERR_PTR(-EIO);
diff --git a/fs/ntfs/attrib.c b/fs/ntfs/attrib.c
index 7659cc192995..1c08fefe487a 100644
--- a/fs/ntfs/attrib.c
+++ b/fs/ntfs/attrib.c
@@ -2532,14 +2532,7 @@ int ntfs_attr_set(ntfs_inode *ni, const s64 ofs, const s64 cnt, const u8 val)
                page = read_mapping_page(mapping, idx, NULL);
                if (IS_ERR(page)) {
                        ntfs_error(vol->sb, "Failed to read first partial "
-                                        "page (sync error, index 0x%lx).", idx);
+                                        "page (error, index 0x%lx).", idx);
-                        return PTR_ERR(page);
-                }
-                wait_on_page_locked(page);
-                if (unlikely(!PageUptodate(page))) {
-                        ntfs_error(vol->sb, "Failed to read first partial page "
-                                        "(async error, index 0x%lx).", idx);
-                        page_cache_release(page);
                        return PTR_ERR(page);
                }
                /*
@@ -2602,14 +2595,7 @@ int ntfs_attr_set(ntfs_inode *ni, const s64 ofs, const s64 cnt, const u8 val)
                page = read_mapping_page(mapping, idx, NULL);
                if (IS_ERR(page)) {
                        ntfs_error(vol->sb, "Failed to read last partial page "
-                                        "(sync error, index 0x%lx).", idx);
+                                        "(error, index 0x%lx).", idx);
-                        return PTR_ERR(page);
-                }
-                wait_on_page_locked(page);
-                if (unlikely(!PageUptodate(page))) {
-                        ntfs_error(vol->sb, "Failed to read last partial page "
-                                        "(async error, index 0x%lx).", idx);
-                        page_cache_release(page);
                        return PTR_ERR(page);
                }
                kaddr = kmap_atomic(page, KM_USER0);
diff --git a/fs/ntfs/file.c b/fs/ntfs/file.c
index d69c4595ccd0..dbbac5593106 100644
--- a/fs/ntfs/file.c
+++ b/fs/ntfs/file.c
@@ -236,8 +236,7 @@ do_non_resident_extend:
                        err = PTR_ERR(page);
                        goto init_err_out;
                }
-                wait_on_page_locked(page);
+                if (unlikely(PageError(page))) {
-                if (unlikely(!PageUptodate(page) || PageError(page))) {
                        page_cache_release(page);
                        err = -EIO;
                        goto init_err_out;
diff --git a/fs/ntfs/super.c b/fs/ntfs/super.c
index 1594c90b7164..21d834e5ed73 100644
--- a/fs/ntfs/super.c
+++ b/fs/ntfs/super.c
@@ -2471,7 +2471,6 @@ static s64 get_nr_free_clusters(ntfs_volume *vol)
        s64 nr_free = vol->nr_clusters;
        u32 *kaddr;
        struct address_space *mapping = vol->lcnbmp_ino->i_mapping;
-        filler_t *readpage = (filler_t*)mapping->a_ops->readpage;
        struct page *page;
        pgoff_t index, max_index;
@@ -2494,24 +2493,14 @@ static s64 get_nr_free_clusters(ntfs_volume *vol)
                 * Read the page from page cache, getting it from backing store
                 * if necessary, and increment the use count.
                 */
-                page = read_cache_page(mapping, index, (filler_t*)readpage,
+                page = read_mapping_page(mapping, index, NULL);
-                                NULL);
                /* Ignore pages which errored synchronously. */
                if (IS_ERR(page)) {
-                        ntfs_debug("Sync read_cache_page() error. Skipping "
+                        ntfs_debug("read_mapping_page() error. Skipping "
                                        "page (index 0x%lx).", index);
                        nr_free -= PAGE_CACHE_SIZE * 8;
                        continue;
                }
-                wait_on_page_locked(page);
-                /* Ignore pages which errored asynchronously. */
-                if (!PageUptodate(page)) {
-                        ntfs_debug("Async read_cache_page() error. Skipping "
-                                        "page (index 0x%lx).", index);
-                        page_cache_release(page);
-                        nr_free -= PAGE_CACHE_SIZE * 8;
-                        continue;
-                }
                kaddr = (u32*)kmap_atomic(page, KM_USER0);
                /*
                 * For each 4 bytes, subtract the number of set bits. If this
@@ -2562,7 +2551,6 @@ static unsigned long __get_nr_free_mft_records(ntfs_volume *vol,
 {
        u32 *kaddr;
        struct address_space *mapping = vol->mftbmp_ino->i_mapping;
-        filler_t *readpage = (filler_t*)mapping->a_ops->readpage;
        struct page *page;
        pgoff_t index;
@@ -2576,21 +2564,11 @@ static unsigned long __get_nr_free_mft_records(ntfs_volume *vol,
                 * Read the page from page cache, getting it from backing store
                 * if necessary, and increment the use count.
                 */
-                page = read_cache_page(mapping, index, (filler_t*)readpage,
+                page = read_mapping_page(mapping, index, NULL);
-                                NULL);
                /* Ignore pages which errored synchronously. */
                if (IS_ERR(page)) {
-                        ntfs_debug("Sync read_cache_page() error. Skipping "
+                        ntfs_debug("read_mapping_page() error. Skipping "
-                                        "page (index 0x%lx).", index);
-                        nr_free -= PAGE_CACHE_SIZE * 8;
-                        continue;
-                }
-                wait_on_page_locked(page);
-                /* Ignore pages which errored asynchronously. */
-                if (!PageUptodate(page)) {
-                        ntfs_debug("Async read_cache_page() error. Skipping "
                                        "page (index 0x%lx).", index);
-                        page_cache_release(page);
                        nr_free -= PAGE_CACHE_SIZE * 8;
                        continue;
                }
@@ -3107,8 +3085,7 @@ static void ntfs_big_inode_init_once(void *foo, struct kmem_cache *cachep,
 {
        ntfs_inode *ni = (ntfs_inode *)foo;
-        if ((flags & (SLAB_CTOR_VERIFY|SLAB_CTOR_CONSTRUCTOR)) ==
+        if (flags & SLAB_CTOR_CONSTRUCTOR)
-                        SLAB_CTOR_CONSTRUCTOR)
                inode_init_once(VFS_I(ni));
 }
diff --git a/fs/ocfs2/alloc.c b/fs/ocfs2/alloc.c
index a0c8667caa72..19712a7d145f 100644
--- a/fs/ocfs2/alloc.c
+++ b/fs/ocfs2/alloc.c
@@ -2869,7 +2869,7 @@ int ocfs2_complete_truncate_log_recovery(struct ocfs2_super *osb,
        tl = &tl_copy->id2.i_dealloc;
        num_recs = le16_to_cpu(tl->tl_used);
        mlog(0, "cleanup %u records from %llu\n", num_recs,
-             (unsigned long long)tl_copy->i_blkno);
+             (unsigned long long)le64_to_cpu(tl_copy->i_blkno));
        mutex_lock(&tl_inode->i_mutex);
        for(i = 0; i < num_recs; i++) {
@@ -3801,8 +3801,8 @@ int ocfs2_prepare_truncate(struct ocfs2_super *osb,
        fe = (struct ocfs2_dinode *) fe_bh->b_data;
        mlog(0, "fe->i_clusters = %u, new_i_clusters = %u, fe->i_size ="
-             "%llu\n", fe->i_clusters, new_i_clusters,
+             "%llu\n", le32_to_cpu(fe->i_clusters), new_i_clusters,
-             (unsigned long long)fe->i_size);
+             (unsigned long long)le64_to_cpu(fe->i_size));
        *tc = kzalloc(sizeof(struct ocfs2_truncate_context), GFP_KERNEL);
        if (!(*tc)) {
diff --git a/fs/ocfs2/aops.c b/fs/ocfs2/aops.c
index 56963e6c46c0..8e7cafb5fc6c 100644
--- a/fs/ocfs2/aops.c
+++ b/fs/ocfs2/aops.c
@@ -78,7 +78,8 @@ static int ocfs2_symlink_get_block(struct inode *inode, sector_t iblock,
        if (!OCFS2_IS_VALID_DINODE(fe)) {
                mlog(ML_ERROR, "Invalid dinode #%llu: signature = %.*s\n",
-                     (unsigned long long)fe->i_blkno, 7, fe->i_signature);
+                     (unsigned long long)le64_to_cpu(fe->i_blkno), 7,
+                     fe->i_signature);
                goto bail;
        }
@@ -939,9 +940,9 @@ out:
 * Returns a negative error code or the number of bytes copied into
 * the page.
 */
-int ocfs2_write_data_page(struct inode *inode, handle_t *handle,
+static int ocfs2_write_data_page(struct inode *inode, handle_t *handle,
-                          u64 *p_blkno, struct page *page,
+                                 u64 *p_blkno, struct page *page,
-                          struct ocfs2_write_ctxt *wc, int new)
+                                 struct ocfs2_write_ctxt *wc, int new)
 {
        int ret, copied = 0;
        unsigned int from = 0, to = 0;
@@ -1086,7 +1087,7 @@ static ssize_t ocfs2_write(struct file *file, u32 phys, handle_t *handle,
        for(i = 0; i < numpages; i++) {
                index = start + i;
-                cpages[i] = grab_cache_page(mapping, index);
+                cpages[i] = find_or_create_page(mapping, index, GFP_NOFS);
                if (!cpages[i]) {
                        ret = -ENOMEM;
                        mlog_errno(ret);
diff --git a/fs/ocfs2/cluster/heartbeat.c b/fs/ocfs2/cluster/heartbeat.c
index eba282da500e..979113479c66 100644
--- a/fs/ocfs2/cluster/heartbeat.c
+++ b/fs/ocfs2/cluster/heartbeat.c
@@ -438,7 +438,7 @@ static inline void o2hb_prepare_block(struct o2hb_region *reg,
                                                                   hb_block));
        mlog(ML_HB_BIO, "our node generation = 0x%llx, cksum = 0x%x\n",
-             (long long)cpu_to_le64(generation),
+             (long long)generation,
             le32_to_cpu(hb_block->hb_cksum));
 }
diff --git a/fs/ocfs2/cluster/masklog.c b/fs/ocfs2/cluster/masklog.c
index 636593bf4d17..2e975c0a35e1 100644
--- a/fs/ocfs2/cluster/masklog.c
+++ b/fs/ocfs2/cluster/masklog.c
@@ -147,7 +147,7 @@ static struct kset mlog_kset = {
        .kobj   = {.name = "logmask", .ktype = &mlog_ktype},
 };
-int mlog_sys_init(struct subsystem *o2cb_subsys)
+int mlog_sys_init(struct kset *o2cb_subsys)
 {
        int i = 0;
@@ -157,7 +157,7 @@ int mlog_sys_init(struct subsystem *o2cb_subsys)
        }
        mlog_attr_ptrs[i] = NULL;
-        mlog_kset.subsys = o2cb_subsys;
+        kobj_set_kset_s(&mlog_kset, o2cb_subsys);
        return kset_register(&mlog_kset);
 }
diff --git a/fs/ocfs2/cluster/masklog.h b/fs/ocfs2/cluster/masklog.h
index a42628ba9ddf..75cd877f6d42 100644
--- a/fs/ocfs2/cluster/masklog.h
+++ b/fs/ocfs2/cluster/masklog.h
@@ -278,7 +278,7 @@ extern struct mlog_bits mlog_and_bits, mlog_not_bits;
 #include <linux/kobject.h>
 #include <linux/sysfs.h>
-int mlog_sys_init(struct subsystem *o2cb_subsys);
+int mlog_sys_init(struct kset *o2cb_subsys);
 void mlog_sys_shutdown(void);
 #endif /* O2CLUSTER_MASKLOG_H */
diff --git a/fs/ocfs2/cluster/sys.c b/fs/ocfs2/cluster/sys.c
index 1d9f6acafa2e..64f6f378fd09 100644
--- a/fs/ocfs2/cluster/sys.c
+++ b/fs/ocfs2/cluster/sys.c
@@ -42,7 +42,6 @@ struct o2cb_attribute {
 #define O2CB_ATTR(_name, _mode, _show, _store)  \
 struct o2cb_attribute o2cb_attr_##_name = __ATTR(_name, _mode, _show, _store)
-#define to_o2cb_subsys(k) container_of(to_kset(k), struct subsystem, kset)
 #define to_o2cb_attr(_attr) container_of(_attr, struct o2cb_attribute, attr)
 static ssize_t o2cb_interface_revision_show(char *buf)
@@ -79,7 +78,7 @@ static ssize_t
 o2cb_show(struct kobject * kobj, struct attribute * attr, char * buffer)
 {
        struct o2cb_attribute *o2cb_attr = to_o2cb_attr(attr);
-        struct subsystem *sbs = to_o2cb_subsys(kobj);
+        struct kset *sbs = to_kset(kobj);
        BUG_ON(sbs != &o2cb_subsys);
@@ -93,7 +92,7 @@ o2cb_store(struct kobject * kobj, struct attribute * attr,
             const char * buffer, size_t count)
 {
        struct o2cb_attribute *o2cb_attr = to_o2cb_attr(attr);
-        struct subsystem *sbs = to_o2cb_subsys(kobj);
+        struct kset *sbs = to_kset(kobj);
        BUG_ON(sbs != &o2cb_subsys);
@@ -112,7 +111,7 @@ int o2cb_sys_init(void)
 {
        int ret;
-        o2cb_subsys.kset.kobj.ktype = &o2cb_subsys_type;
+        o2cb_subsys.kobj.ktype = &o2cb_subsys_type;
        ret = subsystem_register(&o2cb_subsys);
        if (ret)
                return ret;
diff --git a/fs/ocfs2/cluster/tcp.c b/fs/ocfs2/cluster/tcp.c
index 69caf3e12fea..0b229a9c7952 100644
--- a/fs/ocfs2/cluster/tcp.c
+++ b/fs/ocfs2/cluster/tcp.c
@@ -1496,7 +1496,7 @@ static void o2net_start_connect(struct work_struct *work)
        sock->sk->sk_allocation = GFP_ATOMIC;
        myaddr.sin_family = AF_INET;
-        myaddr.sin_addr.s_addr = (__force u32)mynode->nd_ipv4_address;
+        myaddr.sin_addr.s_addr = mynode->nd_ipv4_address;
        myaddr.sin_port = (__force u16)htons(0); /* any port */
        ret = sock->ops->bind(sock, (struct sockaddr *)&myaddr,
@@ -1521,8 +1521,8 @@ static void o2net_start_connect(struct work_struct *work)
        spin_unlock(&nn->nn_lock);
        remoteaddr.sin_family = AF_INET;
-        remoteaddr.sin_addr.s_addr = (__force u32)node->nd_ipv4_address;
+        remoteaddr.sin_addr.s_addr = node->nd_ipv4_address;
-        remoteaddr.sin_port = (__force u16)node->nd_ipv4_port;
+        remoteaddr.sin_port = node->nd_ipv4_port;
        ret = sc->sc_sock->ops->connect(sc->sc_sock,
                                        (struct sockaddr *)&remoteaddr,
@@ -1810,8 +1810,8 @@ static int o2net_open_listening_sock(__be32 addr, __be16 port)
        int ret;
        struct sockaddr_in sin = {
                .sin_family = PF_INET,
-                .sin_addr = { .s_addr = (__force u32)addr },
+                .sin_addr = { .s_addr = addr },
-                .sin_port = (__force u16)port,
+                .sin_port = port,
        };
        ret = sock_create(PF_INET, SOCK_STREAM, IPPROTO_TCP, &sock);
diff --git a/fs/ocfs2/dir.c b/fs/ocfs2/dir.c
index 67e6866a2a4f..c441ef1f2bad 100644
--- a/fs/ocfs2/dir.c
+++ b/fs/ocfs2/dir.c
@@ -403,7 +403,7 @@ static int ocfs2_extend_dir(struct ocfs2_super *osb,
                            struct buffer_head **new_de_bh)
 {
        int status = 0;
-        int credits, num_free_extents;
+        int credits, num_free_extents, drop_alloc_sem = 0;
        loff_t dir_i_size;
        struct ocfs2_dinode *fe = (struct ocfs2_dinode *) parent_fe_bh->b_data;
        struct ocfs2_alloc_context *data_ac = NULL;
@@ -452,6 +452,9 @@ static int ocfs2_extend_dir(struct ocfs2_super *osb,
                credits = OCFS2_SIMPLE_DIR_EXTEND_CREDITS;
        }
+        down_write(&OCFS2_I(dir)->ip_alloc_sem);
+        drop_alloc_sem = 1;
        handle = ocfs2_start_trans(osb, credits);
        if (IS_ERR(handle)) {
                status = PTR_ERR(handle);
@@ -497,6 +500,8 @@ static int ocfs2_extend_dir(struct ocfs2_super *osb,
        *new_de_bh = new_bh;
        get_bh(*new_de_bh);
 bail:
+        if (drop_alloc_sem)
+                up_write(&OCFS2_I(dir)->ip_alloc_sem);
        if (handle)
                ocfs2_commit_trans(osb, handle);
diff --git a/fs/ocfs2/dlm/dlmast.c b/fs/ocfs2/dlm/dlmast.c
index 241cad342a48..2fd8bded38f3 100644
--- a/fs/ocfs2/dlm/dlmast.c
+++ b/fs/ocfs2/dlm/dlmast.c
@@ -312,8 +312,8 @@ int dlm_proxy_ast_handler(struct o2net_msg *msg, u32 len, void *data,
            past->type != DLM_BAST) {
                mlog(ML_ERROR, "Unknown ast type! %d, cookie=%u:%llu"
                     "name=%.*s\n", past->type, 
-                     dlm_get_lock_cookie_node(be64_to_cpu(cookie)),
+                     dlm_get_lock_cookie_node(cookie),
-                     dlm_get_lock_cookie_seq(be64_to_cpu(cookie)),
+                     dlm_get_lock_cookie_seq(cookie),
                     locklen, name);
                ret = DLM_IVLOCKID;
                goto leave;
@@ -324,8 +324,8 @@ int dlm_proxy_ast_handler(struct o2net_msg *msg, u32 len, void *data,
                mlog(0, "got %sast for unknown lockres! "
                     "cookie=%u:%llu, name=%.*s, namelen=%u\n",
                     past->type == DLM_AST ? "" : "b",
-                     dlm_get_lock_cookie_node(be64_to_cpu(cookie)),
+                     dlm_get_lock_cookie_node(cookie),
-                     dlm_get_lock_cookie_seq(be64_to_cpu(cookie)),
+                     dlm_get_lock_cookie_seq(cookie),
                     locklen, name, locklen);
                ret = DLM_IVLOCKID;
                goto leave;
@@ -370,8 +370,8 @@ int dlm_proxy_ast_handler(struct o2net_msg *msg, u32 len, void *data,
        mlog(0, "got %sast for unknown lock!  cookie=%u:%llu, "
             "name=%.*s, namelen=%u\n", past->type == DLM_AST ? "" : "b", 
-             dlm_get_lock_cookie_node(be64_to_cpu(cookie)),
+             dlm_get_lock_cookie_node(cookie),
-             dlm_get_lock_cookie_seq(be64_to_cpu(cookie)),
+             dlm_get_lock_cookie_seq(cookie),
             locklen, name, locklen);
        ret = DLM_NORMAL;
diff --git a/fs/ocfs2/dlm/dlmfs.c b/fs/ocfs2/dlm/dlmfs.c
index de952eba29a9..d4e46d067edd 100644
--- a/fs/ocfs2/dlm/dlmfs.c
+++ b/fs/ocfs2/dlm/dlmfs.c
@@ -263,8 +263,7 @@ static void dlmfs_init_once(void *foo,
        struct dlmfs_inode_private *ip =
                (struct dlmfs_inode_private *) foo;
-        if ((flags & (SLAB_CTOR_VERIFY|SLAB_CTOR_CONSTRUCTOR)) ==
+        if (flags & SLAB_CTOR_CONSTRUCTOR) {
-            SLAB_CTOR_CONSTRUCTOR) {
                ip->ip_dlm = NULL;
                ip->ip_parent = NULL;
diff --git a/fs/ocfs2/dlm/dlmrecovery.c b/fs/ocfs2/dlm/dlmrecovery.c
index c1807a42c49f..671c4ed58ee2 100644
--- a/fs/ocfs2/dlm/dlmrecovery.c
+++ b/fs/ocfs2/dlm/dlmrecovery.c
@@ -1769,7 +1769,7 @@ static int dlm_process_recovery_data(struct dlm_ctxt *dlm,
                        /* lock is always created locally first, and
                         * destroyed locally last.  it must be on the list */
                        if (!lock) {
-                                u64 c = ml->cookie;
+                                __be64 c = ml->cookie;
                                mlog(ML_ERROR, "could not find local lock "
                                               "with cookie %u:%llu!\n",
                                     dlm_get_lock_cookie_node(be64_to_cpu(c)),
@@ -1878,7 +1878,7 @@ skip_lvb:
                spin_lock(&res->spinlock);
                list_for_each_entry(lock, queue, list) {
                        if (lock->ml.cookie == ml->cookie) {
-                                u64 c = lock->ml.cookie;
+                                __be64 c = lock->ml.cookie;
                                mlog(ML_ERROR, "%s:%.*s: %u:%llu: lock already "
                                     "exists on this lockres!\n", dlm->name,
                                     res->lockname.len, res->lockname.name,
diff --git a/fs/ocfs2/dlm/dlmthread.c b/fs/ocfs2/dlm/dlmthread.c
index 2b264c6ba039..cebd089f8955 100644
--- a/fs/ocfs2/dlm/dlmthread.c
+++ b/fs/ocfs2/dlm/dlmthread.c
@@ -76,7 +76,7 @@ repeat:
                goto repeat;
        }
        remove_wait_queue(&res->wq, &wait);
-        current->state = TASK_RUNNING;
+        __set_current_state(TASK_RUNNING);
 }
 int __dlm_lockres_has_locks(struct dlm_lock_resource *res)
diff --git a/fs/ocfs2/dlmglue.c b/fs/ocfs2/dlmglue.c
index 27e43b0c0eae..024777abc8e3 100644
--- a/fs/ocfs2/dlmglue.c
+++ b/fs/ocfs2/dlmglue.c
@@ -104,6 +104,35 @@ static int ocfs2_dentry_convert_worker(struct ocfs2_lock_res *lockres,
 static void ocfs2_dentry_post_unlock(struct ocfs2_super *osb,
                                     struct ocfs2_lock_res *lockres);
+#define mlog_meta_lvb(__level, __lockres) ocfs2_dump_meta_lvb_info(__level, __PRETTY_FUNCTION__, __LINE__, __lockres)
+/* This aids in debugging situations where a bad LVB might be involved. */
+static void ocfs2_dump_meta_lvb_info(u64 level,
+                                     const char *function,
+                                     unsigned int line,
+                                     struct ocfs2_lock_res *lockres)
+{
+        struct ocfs2_meta_lvb *lvb = (struct ocfs2_meta_lvb *) lockres->l_lksb.lvb;
+        mlog(level, "LVB information for %s (called from %s:%u):\n",
+             lockres->l_name, function, line);
+        mlog(level, "version: %u, clusters: %u, generation: 0x%x\n",
+             lvb->lvb_version, be32_to_cpu(lvb->lvb_iclusters),
+             be32_to_cpu(lvb->lvb_igeneration));
+        mlog(level, "size: %llu, uid %u, gid %u, mode 0x%x\n",
+             (unsigned long long)be64_to_cpu(lvb->lvb_isize),
+             be32_to_cpu(lvb->lvb_iuid), be32_to_cpu(lvb->lvb_igid),
+             be16_to_cpu(lvb->lvb_imode));
+        mlog(level, "nlink %u, atime_packed 0x%llx, ctime_packed 0x%llx, "
+             "mtime_packed 0x%llx iattr 0x%x\n", be16_to_cpu(lvb->lvb_inlink),
+             (long long)be64_to_cpu(lvb->lvb_iatime_packed),
+             (long long)be64_to_cpu(lvb->lvb_ictime_packed),
+             (long long)be64_to_cpu(lvb->lvb_imtime_packed),
+             be32_to_cpu(lvb->lvb_iattr));
+}
 /*
 * OCFS2 Lock Resource Operations
 *
@@ -3078,28 +3107,3 @@ static void ocfs2_schedule_blocked_lock(struct ocfs2_super *osb,
        mlog_exit_void();
 }
-/* This aids in debugging situations where a bad LVB might be involved. */
-void ocfs2_dump_meta_lvb_info(u64 level,
-                              const char *function,
-                              unsigned int line,
-                              struct ocfs2_lock_res *lockres)
-{
-        struct ocfs2_meta_lvb *lvb = (struct ocfs2_meta_lvb *) lockres->l_lksb.lvb;
-        mlog(level, "LVB information for %s (called from %s:%u):\n",
-             lockres->l_name, function, line);
-        mlog(level, "version: %u, clusters: %u, generation: 0x%x\n",
-             lvb->lvb_version, be32_to_cpu(lvb->lvb_iclusters),
-             be32_to_cpu(lvb->lvb_igeneration));
-        mlog(level, "size: %llu, uid %u, gid %u, mode 0x%x\n",
-             (unsigned long long)be64_to_cpu(lvb->lvb_isize),
-             be32_to_cpu(lvb->lvb_iuid), be32_to_cpu(lvb->lvb_igid),
-             be16_to_cpu(lvb->lvb_imode));
-        mlog(level, "nlink %u, atime_packed 0x%llx, ctime_packed 0x%llx, "
-             "mtime_packed 0x%llx iattr 0x%x\n", be16_to_cpu(lvb->lvb_inlink),
-             (long long)be64_to_cpu(lvb->lvb_iatime_packed),
-             (long long)be64_to_cpu(lvb->lvb_ictime_packed),
-             (long long)be64_to_cpu(lvb->lvb_imtime_packed),
-             be32_to_cpu(lvb->lvb_iattr));
-}
diff --git a/fs/ocfs2/dlmglue.h b/fs/ocfs2/dlmglue.h
index 59cb566e7983..492bad32a8c0 100644
--- a/fs/ocfs2/dlmglue.h
+++ b/fs/ocfs2/dlmglue.h
@@ -119,11 +119,4 @@ void ocfs2_process_blocked_lock(struct ocfs2_super *osb,
 struct ocfs2_dlm_debug *ocfs2_new_dlm_debug(void);
 void ocfs2_put_dlm_debug(struct ocfs2_dlm_debug *dlm_debug);
-/* aids in debugging and tracking lvbs */
-void ocfs2_dump_meta_lvb_info(u64 level,
-                              const char *function,
-                              unsigned int line,
-                              struct ocfs2_lock_res *lockres);
-#define mlog_meta_lvb(__level, __lockres) ocfs2_dump_meta_lvb_info(__level, __PRETTY_FUNCTION__, __LINE__, __lockres)
 #endif  /* DLMGLUE_H */
diff --git a/fs/ocfs2/export.c b/fs/ocfs2/export.c
index 56e1fefc1205..bc48177bd183 100644
--- a/fs/ocfs2/export.c
+++ b/fs/ocfs2/export.c
@@ -140,7 +140,7 @@ bail:
        return parent;
 }
-static int ocfs2_encode_fh(struct dentry *dentry, __be32 *fh, int *max_len,
+static int ocfs2_encode_fh(struct dentry *dentry, u32 *fh_in, int *max_len,
                           int connectable)
 {
        struct inode *inode = dentry->d_inode;
@@ -148,6 +148,7 @@ static int ocfs2_encode_fh(struct dentry *dentry, __be32 *fh, int *max_len,
        int type = 1;
        u64 blkno;
        u32 generation;
+        __le32 *fh = (__force __le32 *) fh_in;
        mlog_entry("(0x%p, '%.*s', 0x%p, %d, %d)\n", dentry,
                   dentry->d_name.len, dentry->d_name.name,
@@ -199,7 +200,7 @@ bail:
        return type;
 }
-static struct dentry *ocfs2_decode_fh(struct super_block *sb, __be32 *fh,
+static struct dentry *ocfs2_decode_fh(struct super_block *sb, u32 *fh_in,
                                      int fh_len, int fileid_type,
                                      int (*acceptable)(void *context,
                                                        struct dentry *de),
@@ -207,6 +208,7 @@ static struct dentry *ocfs2_decode_fh(struct super_block *sb, __be32 *fh,
 {
        struct ocfs2_inode_handle handle, parent;
        struct dentry *ret = NULL;
+        __le32 *fh = (__force __le32 *) fh_in;
        mlog_entry("(0x%p, 0x%p, %d, %d, 0x%p, 0x%p)\n",
                   sb, fh, fh_len, fileid_type, acceptable, context);
diff --git a/fs/ocfs2/file.c b/fs/ocfs2/file.c
index 520a2a6d7670..9395b4fa547d 100644
--- a/fs/ocfs2/file.c
+++ b/fs/ocfs2/file.c
@@ -207,10 +207,10 @@ out:
        return ret;
 }
-int ocfs2_set_inode_size(handle_t *handle,
+static int ocfs2_set_inode_size(handle_t *handle,
-                         struct inode *inode,
+                                struct inode *inode,
-                         struct buffer_head *fe_bh,
+                                struct buffer_head *fe_bh,
-                         u64 new_i_size)
+                                u64 new_i_size)
 {
        int status;
@@ -713,7 +713,8 @@ restarted_transaction:
        }
        mlog(0, "fe: i_clusters = %u, i_size=%llu\n",
-             fe->i_clusters, (unsigned long long)fe->i_size);
+             le32_to_cpu(fe->i_clusters),
+             (unsigned long long)le64_to_cpu(fe->i_size));
        mlog(0, "inode: ip_clusters=%u, i_size=%lld\n",
             OCFS2_I(inode)->ip_clusters, i_size_read(inode));
@@ -1853,6 +1854,9 @@ const struct file_operations ocfs2_fops = {
        .aio_read       = ocfs2_file_aio_read,
        .aio_write      = ocfs2_file_aio_write,
        .ioctl          = ocfs2_ioctl,
+#ifdef CONFIG_COMPAT
+        .compat_ioctl   = ocfs2_compat_ioctl,
+#endif
        .splice_read    = ocfs2_file_splice_read,
        .splice_write   = ocfs2_file_splice_write,
 };
@@ -1862,4 +1866,7 @@ const struct file_operations ocfs2_dops = {
        .readdir        = ocfs2_readdir,
        .fsync          = ocfs2_sync_file,
        .ioctl          = ocfs2_ioctl,
+#ifdef CONFIG_COMPAT
+        .compat_ioctl   = ocfs2_compat_ioctl,
+#endif
 };
diff --git a/fs/ocfs2/file.h b/fs/ocfs2/file.h
index 2c4460fced52..a4dd1fa1822b 100644
--- a/fs/ocfs2/file.h
+++ b/fs/ocfs2/file.h
@@ -56,11 +56,6 @@ int ocfs2_getattr(struct vfsmount *mnt, struct dentry *dentry,
 int ocfs2_permission(struct inode *inode, int mask,
                     struct nameidata *nd);
-int ocfs2_set_inode_size(handle_t *handle,
-                         struct inode *inode,
-                         struct buffer_head *fe_bh,
-                         u64 new_i_size);
 int ocfs2_should_update_atime(struct inode *inode,
                              struct vfsmount *vfsmnt);
 int ocfs2_update_inode_atime(struct inode *inode,
diff --git a/fs/ocfs2/inode.c b/fs/ocfs2/inode.c
index 21a605079c62..bc844bfe607c 100644
--- a/fs/ocfs2/inode.c
+++ b/fs/ocfs2/inode.c
@@ -89,6 +89,25 @@ void ocfs2_set_inode_flags(struct inode *inode)
                inode->i_flags |= S_DIRSYNC;
 }
+/* Propagate flags from i_flags to OCFS2_I(inode)->ip_attr */
+void ocfs2_get_inode_flags(struct ocfs2_inode_info *oi)
+{
+        unsigned int flags = oi->vfs_inode.i_flags;
+        oi->ip_attr &= ~(OCFS2_SYNC_FL|OCFS2_APPEND_FL|
+                        OCFS2_IMMUTABLE_FL|OCFS2_NOATIME_FL|OCFS2_DIRSYNC_FL);
+        if (flags & S_SYNC)
+                oi->ip_attr |= OCFS2_SYNC_FL;
+        if (flags & S_APPEND)
+                oi->ip_attr |= OCFS2_APPEND_FL;
+        if (flags & S_IMMUTABLE)
+                oi->ip_attr |= OCFS2_IMMUTABLE_FL;
+        if (flags & S_NOATIME)
+                oi->ip_attr |= OCFS2_NOATIME_FL;
+        if (flags & S_DIRSYNC)
+                oi->ip_attr |= OCFS2_DIRSYNC_FL;
+}
 struct inode *ocfs2_iget(struct ocfs2_super *osb, u64 blkno, int flags)
 {
        struct inode *inode = NULL;
@@ -196,7 +215,7 @@ int ocfs2_populate_inode(struct inode *inode, struct ocfs2_dinode *fe,
        int status = -EINVAL;
        mlog_entry("(0x%p, size:%llu)\n", inode,
-                   (unsigned long long)fe->i_size);
+                   (unsigned long long)le64_to_cpu(fe->i_size));
        sb = inode->i_sb;
        osb = OCFS2_SB(sb);
@@ -248,7 +267,7 @@ int ocfs2_populate_inode(struct inode *inode, struct ocfs2_dinode *fe,
                mlog(ML_ERROR,
                     "ip_blkno %llu != i_blkno %llu!\n",
                     (unsigned long long)OCFS2_I(inode)->ip_blkno,
-                     (unsigned long long)fe->i_blkno);
+                     (unsigned long long)le64_to_cpu(fe->i_blkno));
        inode->i_nlink = le16_to_cpu(fe->i_links_count);
@@ -301,7 +320,7 @@ int ocfs2_populate_inode(struct inode *inode, struct ocfs2_dinode *fe,
                 * the generation argument to
                 * ocfs2_inode_lock_res_init() will have to change.
                 */
-                BUG_ON(fe->i_flags & cpu_to_le32(OCFS2_SYSTEM_FL));
+                BUG_ON(le32_to_cpu(fe->i_flags) & OCFS2_SYSTEM_FL);
                ocfs2_inode_lock_res_init(&OCFS2_I(inode)->ip_meta_lockres,
                                          OCFS2_LOCK_TYPE_META, 0, inode);
@@ -437,7 +456,8 @@ static int ocfs2_read_locked_inode(struct inode *inode,
        fe = (struct ocfs2_dinode *) bh->b_data;
        if (!OCFS2_IS_VALID_DINODE(fe)) {
                mlog(ML_ERROR, "Invalid dinode #%llu: signature = %.*s\n",
-                     (unsigned long long)fe->i_blkno, 7, fe->i_signature);
+                     (unsigned long long)le64_to_cpu(fe->i_blkno), 7,
+                     fe->i_signature);
                goto bail;
        }
@@ -812,8 +832,8 @@ static int ocfs2_query_inode_wipe(struct inode *inode,
                     "Inode %llu (on-disk %llu) not orphaned! "
                     "Disk flags  0x%x, inode flags 0x%x\n",
                     (unsigned long long)oi->ip_blkno,
-                     (unsigned long long)di->i_blkno, di->i_flags,
+                     (unsigned long long)le64_to_cpu(di->i_blkno),
-                     oi->ip_flags);
+                     le32_to_cpu(di->i_flags), oi->ip_flags);
                goto bail;
        }
@@ -1106,8 +1126,10 @@ struct buffer_head *ocfs2_bread(struct inode *inode,
                return NULL;
        }
+        down_read(&OCFS2_I(inode)->ip_alloc_sem);
        tmperr = ocfs2_extent_map_get_blocks(inode, block, &p_blkno, NULL,
                                             NULL);
+        up_read(&OCFS2_I(inode)->ip_alloc_sem);
        if (tmperr < 0) {
                mlog_errno(tmperr);
                goto fail;
@@ -1197,6 +1219,7 @@ int ocfs2_mark_inode_dirty(handle_t *handle,
        spin_lock(&OCFS2_I(inode)->ip_lock);
        fe->i_clusters = cpu_to_le32(OCFS2_I(inode)->ip_clusters);
+        ocfs2_get_inode_flags(OCFS2_I(inode));
        fe->i_attr = cpu_to_le32(OCFS2_I(inode)->ip_attr);
        spin_unlock(&OCFS2_I(inode)->ip_lock);
diff --git a/fs/ocfs2/inode.h b/fs/ocfs2/inode.h
index 03ae075869ee..a41d0817121b 100644
--- a/fs/ocfs2/inode.h
+++ b/fs/ocfs2/inode.h
@@ -141,6 +141,7 @@ int ocfs2_aio_read(struct file *file, struct kiocb *req, struct iocb *iocb);
 int ocfs2_aio_write(struct file *file, struct kiocb *req, struct iocb *iocb);
 void ocfs2_set_inode_flags(struct inode *inode);
+void ocfs2_get_inode_flags(struct ocfs2_inode_info *oi);
 static inline blkcnt_t ocfs2_inode_sector_count(struct inode *inode)
 {
diff --git a/fs/ocfs2/ioctl.c b/fs/ocfs2/ioctl.c
index 4768be5f3086..f3ad21ad9aed 100644
--- a/fs/ocfs2/ioctl.c
+++ b/fs/ocfs2/ioctl.c
@@ -31,6 +31,7 @@ static int ocfs2_get_inode_attr(struct inode *inode, unsigned *flags)
                mlog_errno(status);
                return status;
        }
+        ocfs2_get_inode_flags(OCFS2_I(inode));
        *flags = OCFS2_I(inode)->ip_attr;
        ocfs2_meta_unlock(inode, 0);
@@ -134,3 +135,26 @@ int ocfs2_ioctl(struct inode * inode, struct file * filp,
        }
 }
+#ifdef CONFIG_COMPAT
+long ocfs2_compat_ioctl(struct file *file, unsigned cmd, unsigned long arg)
+{
+        struct inode *inode = file->f_path.dentry->d_inode;
+        int ret;
+        switch (cmd) {
+        case OCFS2_IOC32_GETFLAGS:
+                cmd = OCFS2_IOC_GETFLAGS;
+                break;
+        case OCFS2_IOC32_SETFLAGS:
+                cmd = OCFS2_IOC_SETFLAGS;
+                break;
+        default:
+                return -ENOIOCTLCMD;
+        }
+        lock_kernel();
+        ret = ocfs2_ioctl(inode, file, cmd, arg);
+        unlock_kernel();
+        return ret;
+}
+#endif
diff --git a/fs/ocfs2/ioctl.h b/fs/ocfs2/ioctl.h
index 4a7c82931dba..4d6c4f430d0d 100644
--- a/fs/ocfs2/ioctl.h
+++ b/fs/ocfs2/ioctl.h
@@ -12,5 +12,6 @@
 int ocfs2_ioctl(struct inode * inode, struct file * filp,
        unsigned int cmd, unsigned long arg);
+long ocfs2_compat_ioctl(struct file *file, unsigned cmd, unsigned long arg);
 #endif /* OCFS2_IOCTL_H */
diff --git a/fs/ocfs2/journal.c b/fs/ocfs2/journal.c
index 5a8a90d1c787..dc1188081720 100644
--- a/fs/ocfs2/journal.c
+++ b/fs/ocfs2/journal.c
@@ -435,7 +435,8 @@ static int ocfs2_journal_toggle_dirty(struct ocfs2_super *osb,
                 * handle the errors in a specific manner, so no need
                 * to call ocfs2_error() here. */
                mlog(ML_ERROR, "Journal dinode %llu  has invalid "
-                     "signature: %.*s", (unsigned long long)fe->i_blkno, 7,
+                     "signature: %.*s",
+                     (unsigned long long)le64_to_cpu(fe->i_blkno), 7,
                     fe->i_signature);
                status = -EIO;
                goto out;
@@ -742,7 +743,7 @@ void ocfs2_complete_recovery(struct work_struct *work)
                la_dinode = item->lri_la_dinode;
                if (la_dinode) {
                        mlog(0, "Clean up local alloc %llu\n",
-                             (unsigned long long)la_dinode->i_blkno);
+                             (unsigned long long)le64_to_cpu(la_dinode->i_blkno));
                        ret = ocfs2_complete_local_alloc_recovery(osb,
                                                                  la_dinode);
@@ -755,7 +756,7 @@ void ocfs2_complete_recovery(struct work_struct *work)
                tl_dinode = item->lri_tl_dinode;
                if (tl_dinode) {
                        mlog(0, "Clean up truncate log %llu\n",
-                             (unsigned long long)tl_dinode->i_blkno);
+                             (unsigned long long)le64_to_cpu(tl_dinode->i_blkno));
                        ret = ocfs2_complete_truncate_log_recovery(osb,
                                                                   tl_dinode);
diff --git a/fs/ocfs2/namei.c b/fs/ocfs2/namei.c
index 2bcf353fd7c5..36289e6295ce 100644
--- a/fs/ocfs2/namei.c
+++ b/fs/ocfs2/namei.c
@@ -578,8 +578,9 @@ static int ocfs2_mknod_locked(struct ocfs2_super *osb,
        if (ocfs2_populate_inode(inode, fe, 1) < 0) {
                mlog(ML_ERROR, "populate inode failed! bh->b_blocknr=%llu, "
                     "i_blkno=%llu, i_ino=%lu\n",
-                     (unsigned long long) (*new_fe_bh)->b_blocknr,
+                     (unsigned long long)(*new_fe_bh)->b_blocknr,
-                     (unsigned long long)fe->i_blkno, inode->i_ino);
+                     (unsigned long long)le64_to_cpu(fe->i_blkno),
+                     inode->i_ino);
                BUG();
        }
diff --git a/fs/ocfs2/ocfs2.h b/fs/ocfs2/ocfs2.h
index 82cc92dcf8a6..a860633e833f 100644
--- a/fs/ocfs2/ocfs2.h
+++ b/fs/ocfs2/ocfs2.h
@@ -363,9 +363,9 @@ static inline int ocfs2_mount_local(struct ocfs2_super *osb)
        typeof(__di) ____di = (__di);                                   \
        ocfs2_error((__sb),                                             \
                "Dinode # %llu has bad signature %.*s",                 \
-                (unsigned long long)(____di)->i_blkno, 7,               \
+                (unsigned long long)le64_to_cpu((____di)->i_blkno), 7,  \
                (____di)->i_signature);                                 \
-} while (0);
+} while (0)
 #define OCFS2_IS_VALID_EXTENT_BLOCK(ptr)                                \
        (!strcmp((ptr)->h_signature, OCFS2_EXTENT_BLOCK_SIGNATURE))
@@ -374,9 +374,9 @@ static inline int ocfs2_mount_local(struct ocfs2_super *osb)
        typeof(__eb) ____eb = (__eb);                                   \
        ocfs2_error((__sb),                                             \
                "Extent Block # %llu has bad signature %.*s",           \
-                (unsigned long long)(____eb)->h_blkno, 7,               \
+                (unsigned long long)le64_to_cpu((____eb)->h_blkno), 7,  \
                (____eb)->h_signature);                                 \
-} while (0);
+} while (0)
 #define OCFS2_IS_VALID_GROUP_DESC(ptr)                                  \
        (!strcmp((ptr)->bg_signature, OCFS2_GROUP_DESC_SIGNATURE))
@@ -385,9 +385,9 @@ static inline int ocfs2_mount_local(struct ocfs2_super *osb)
        typeof(__gd) ____gd = (__gd);                                   \
                ocfs2_error((__sb),                                     \
                "Group Descriptor # %llu has bad signature %.*s",       \
-                (unsigned long long)(____gd)->bg_blkno, 7,              \
+                (unsigned long long)le64_to_cpu((____gd)->bg_blkno), 7, \
                (____gd)->bg_signature);                                \
-} while (0);
+} while (0)
 static inline unsigned long ino_from_blkno(struct super_block *sb,
                                           u64 blkno)
diff --git a/fs/ocfs2/ocfs2_fs.h b/fs/ocfs2/ocfs2_fs.h
index 71306479c68f..f0d9eb08547a 100644
--- a/fs/ocfs2/ocfs2_fs.h
+++ b/fs/ocfs2/ocfs2_fs.h
@@ -166,6 +166,8 @@
 */
 #define OCFS2_IOC_GETFLAGS      _IOR('f', 1, long)
 #define OCFS2_IOC_SETFLAGS      _IOW('f', 2, long)
+#define OCFS2_IOC32_GETFLAGS    _IOR('f', 1, int)
+#define OCFS2_IOC32_SETFLAGS    _IOW('f', 2, int)
 /*
 * Journal Flags (ocfs2_dinode.id1.journal1.i_flags)
diff --git a/fs/ocfs2/suballoc.c b/fs/ocfs2/suballoc.c
index 0da655ae5d6f..e3437626d183 100644
--- a/fs/ocfs2/suballoc.c
+++ b/fs/ocfs2/suballoc.c
@@ -849,9 +849,9 @@ static int ocfs2_relink_block_group(handle_t *handle,
        }
        mlog(0, "Suballoc %llu, chain %u, move group %llu to top, prev = %llu\n",
-             (unsigned long long)fe->i_blkno, chain,
+             (unsigned long long)le64_to_cpu(fe->i_blkno), chain,
-             (unsigned long long)bg->bg_blkno,
+             (unsigned long long)le64_to_cpu(bg->bg_blkno),
-             (unsigned long long)prev_bg->bg_blkno);
+             (unsigned long long)le64_to_cpu(prev_bg->bg_blkno));
        fe_ptr = le64_to_cpu(fe->id2.i_chain.cl_recs[chain].c_blkno);
        bg_ptr = le64_to_cpu(bg->bg_next_group);
@@ -1162,7 +1162,7 @@ static int ocfs2_search_chain(struct ocfs2_alloc_context *ac,
        }
        mlog(0, "alloc succeeds: we give %u bits from block group %llu\n",
-             tmp_bits, (unsigned long long)bg->bg_blkno);
+             tmp_bits, (unsigned long long)le64_to_cpu(bg->bg_blkno));
        *num_bits = tmp_bits;
@@ -1227,7 +1227,7 @@ static int ocfs2_search_chain(struct ocfs2_alloc_context *ac,
        }
        mlog(0, "Allocated %u bits from suballocator %llu\n", *num_bits,
-             (unsigned long long)fe->i_blkno);
+             (unsigned long long)le64_to_cpu(fe->i_blkno));
        *bg_blkno = le64_to_cpu(bg->bg_blkno);
        *bits_left = le16_to_cpu(bg->bg_free_bits_count);
diff --git a/fs/ocfs2/super.c b/fs/ocfs2/super.c
index 5c9e8243691f..7c5e3f5d6634 100644
--- a/fs/ocfs2/super.c
+++ b/fs/ocfs2/super.c
@@ -937,8 +937,7 @@ static void ocfs2_inode_init_once(void *data,
 {
        struct ocfs2_inode_info *oi = data;
-        if ((flags & (SLAB_CTOR_VERIFY|SLAB_CTOR_CONSTRUCTOR)) ==
+        if (flags & SLAB_CTOR_CONSTRUCTOR) {
-            SLAB_CTOR_CONSTRUCTOR) {
                oi->ip_flags = 0;
                oi->ip_open_count = 0;
                spin_lock_init(&oi->ip_lock);
@@ -1538,7 +1537,7 @@ static int ocfs2_verify_volume(struct ocfs2_dinode *di,
                } else if (bh->b_blocknr != le64_to_cpu(di->i_blkno)) {
                        mlog(ML_ERROR, "bad block number on superblock: "
                             "found %llu, should be %llu\n",
-                             (unsigned long long)di->i_blkno,
+                             (unsigned long long)le64_to_cpu(di->i_blkno),
                             (unsigned long long)bh->b_blocknr);
                } else if (le32_to_cpu(di->id2.i_super.s_clustersize_bits) < 12 ||
                            le32_to_cpu(di->id2.i_super.s_clustersize_bits) > 20) {
diff --git a/fs/ocfs2/symlink.c b/fs/ocfs2/symlink.c
index 40dc1a51f4a9..7134007ba22f 100644
--- a/fs/ocfs2/symlink.c
+++ b/fs/ocfs2/symlink.c
@@ -67,16 +67,9 @@ static char *ocfs2_page_getlink(struct dentry * dentry,
        page = read_mapping_page(mapping, 0, NULL);
        if (IS_ERR(page))
                goto sync_fail;
-        wait_on_page_locked(page);
-        if (!PageUptodate(page))
-                goto async_fail;
        *ppage = page;
        return kmap(page);
-async_fail:
-        page_cache_release(page);
-        return ERR_PTR(-EIO);
 sync_fail:
        return (char*)page;
 }
diff --git a/fs/openpromfs/inode.c b/fs/openpromfs/inode.c
index bde1c164417d..731a90e9f0cd 100644
--- a/fs/openpromfs/inode.c
+++ b/fs/openpromfs/inode.c
@@ -419,8 +419,7 @@ static void op_inode_init_once(void *data, struct kmem_cache * cachep, unsigned
 {
        struct op_inode_info *oi = (struct op_inode_info *) data;
-        if ((flags & (SLAB_CTOR_VERIFY|SLAB_CTOR_CONSTRUCTOR)) ==
+        if (flags & SLAB_CTOR_CONSTRUCTOR)
-            SLAB_CTOR_CONSTRUCTOR)
                inode_init_once(&oi->vfs_inode);
 }
diff --git a/fs/partitions/acorn.c b/fs/partitions/acorn.c
index 1bc9f372c7d4..e3491328596b 100644
--- a/fs/partitions/acorn.c
+++ b/fs/partitions/acorn.c
@@ -271,7 +271,7 @@ adfspart_check_ADFS(struct parsed_partitions *state, struct block_device *bdev)
                extern void xd_set_geometry(struct block_device *,
                        unsigned char, unsigned char, unsigned int);
                xd_set_geometry(bdev, dr->secspertrack, heads, 1);
-                invalidate_bdev(bdev, 1);
+                invalidate_bh_lrus();
                truncate_inode_pages(bdev->bd_inode->i_mapping, 0);
        }
 #endif
diff --git a/fs/partitions/check.c b/fs/partitions/check.c
index 8a7d0035ad7a..6b9dae3f0e6c 100644
--- a/fs/partitions/check.c
+++ b/fs/partitions/check.c
@@ -312,7 +312,7 @@ static struct attribute * default_attrs[] = {
        NULL,
 };
-extern struct subsystem block_subsys;
+extern struct kset block_subsys;
 static void part_release(struct kobject *kobj)
 {
@@ -388,7 +388,7 @@ void add_partition(struct gendisk *disk, int part, sector_t start, sector_t len,
        kobject_add(&p->kobj);
        if (!disk->part_uevent_suppress)
                kobject_uevent(&p->kobj, KOBJ_ADD);
-        sysfs_create_link(&p->kobj, &block_subsys.kset.kobj, "subsystem");
+        sysfs_create_link(&p->kobj, &block_subsys.kobj, "subsystem");
        if (flags & ADDPART_FLAG_WHOLEDISK) {
                static struct attribute addpartattr = {
                        .name = "whole_disk",
@@ -444,7 +444,7 @@ static int disk_sysfs_symlinks(struct gendisk *disk)
                        goto err_out_dev_link;
        }
-        err = sysfs_create_link(&disk->kobj, &block_subsys.kset.kobj,
+        err = sysfs_create_link(&disk->kobj, &block_subsys.kobj,
                                "subsystem");
        if (err)
                goto err_out_disk_name_lnk;
@@ -569,9 +569,6 @@ unsigned char *read_dev_sector(struct block_device *bdev, sector_t n, Sector *p)
        page = read_mapping_page(mapping, (pgoff_t)(n >> (PAGE_CACHE_SHIFT-9)),
                                 NULL);
        if (!IS_ERR(page)) {
-                wait_on_page_locked(page);
-                if (!PageUptodate(page))
-                        goto fail;
                if (PageError(page))
                        goto fail;
                p->v = page;
diff --git a/fs/proc/base.c b/fs/proc/base.c
index 989af5e55d1b..ec158dd02b3a 100644
--- a/fs/proc/base.c
+++ b/fs/proc/base.c
@@ -715,6 +715,40 @@ static const struct file_operations proc_oom_adjust_operations = {
        .write          = oom_adjust_write,
 };
+static ssize_t clear_refs_write(struct file *file, const char __user *buf,
+                                size_t count, loff_t *ppos)
+{
+        struct task_struct *task;
+        char buffer[PROC_NUMBUF], *end;
+        struct mm_struct *mm;
+        memset(buffer, 0, sizeof(buffer));
+        if (count > sizeof(buffer) - 1)
+                count = sizeof(buffer) - 1;
+        if (copy_from_user(buffer, buf, count))
+                return -EFAULT;
+        if (!simple_strtol(buffer, &end, 0))
+                return -EINVAL;
+        if (*end == '\n')
+                end++;
+        task = get_proc_task(file->f_path.dentry->d_inode);
+        if (!task)
+                return -ESRCH;
+        mm = get_task_mm(task);
+        if (mm) {
+                clear_refs_smap(mm);
+                mmput(mm);
+        }
+        put_task_struct(task);
+        if (end - buffer == 0)
+                return -EIO;
+        return end - buffer;
+}
+static struct file_operations proc_clear_refs_operations = {
+        .write          = clear_refs_write,
+};
 #ifdef CONFIG_AUDITSYSCALL
 #define TMPBUFLEN 21
 static ssize_t proc_loginuid_read(struct file * file, char __user * buf,
@@ -1851,6 +1885,7 @@ static struct pid_entry tgid_base_stuff[] = {
        REG("mounts",     S_IRUGO, mounts),
        REG("mountstats", S_IRUSR, mountstats),
 #ifdef CONFIG_MMU
+        REG("clear_refs", S_IWUSR, clear_refs),
        REG("smaps",      S_IRUGO, smaps),
 #endif
 #ifdef CONFIG_SECURITY
@@ -2132,6 +2167,7 @@ static struct pid_entry tid_base_stuff[] = {
        LNK("exe",       exe),
        REG("mounts",    S_IRUGO, mounts),
 #ifdef CONFIG_MMU
+        REG("clear_refs", S_IWUSR, clear_refs),
        REG("smaps",     S_IRUGO, smaps),
 #endif
 #ifdef CONFIG_SECURITY
diff --git a/fs/proc/inode.c b/fs/proc/inode.c
index c372eb151a3a..22b1158389ae 100644
--- a/fs/proc/inode.c
+++ b/fs/proc/inode.c
@@ -109,8 +109,7 @@ static void init_once(void * foo, struct kmem_cache * cachep, unsigned long flag
 {
        struct proc_inode *ei = (struct proc_inode *) foo;
-        if ((flags & (SLAB_CTOR_VERIFY|SLAB_CTOR_CONSTRUCTOR)) ==
+        if (flags & SLAB_CTOR_CONSTRUCTOR)
-            SLAB_CTOR_CONSTRUCTOR)
                inode_init_once(&ei->vfs_inode);
 }
 
diff --git a/fs/proc/proc_misc.c b/fs/proc/proc_misc.c
index e2c4c0a5c90d..75ec6523d29a 100644
--- a/fs/proc/proc_misc.c
+++ b/fs/proc/proc_misc.c
@@ -398,8 +398,6 @@ static const struct file_operations proc_modules_operations = {
 #endif
 #ifdef CONFIG_SLAB
-extern struct seq_operations slabinfo_op;
-extern ssize_t slabinfo_write(struct file *, const char __user *, size_t, loff_t *);
 static int slabinfo_open(struct inode *inode, struct file *file)
 {
        return seq_open(file, &slabinfo_op);
diff --git a/fs/proc/task_mmu.c b/fs/proc/task_mmu.c
index 7445980c8022..4008c060f7ef 100644
--- a/fs/proc/task_mmu.c
+++ b/fs/proc/task_mmu.c
@@ -120,6 +120,14 @@ struct mem_size_stats
        unsigned long shared_dirty;
        unsigned long private_clean;
        unsigned long private_dirty;
+        unsigned long referenced;
+};
+struct pmd_walker {
+        struct vm_area_struct *vma;
+        void *private;
+        void (*action)(struct vm_area_struct *, pmd_t *, unsigned long,
+                       unsigned long, void *);
 };
 static int show_map_internal(struct seq_file *m, void *v, struct mem_size_stats *mss)
@@ -181,18 +189,20 @@ static int show_map_internal(struct seq_file *m, void *v, struct mem_size_stats
        if (mss)
                seq_printf(m,
-                           "Size:          %8lu kB\n"
+                           "Size:           %8lu kB\n"
-                           "Rss:           %8lu kB\n"
+                           "Rss:            %8lu kB\n"
-                           "Shared_Clean:  %8lu kB\n"
+                           "Shared_Clean:   %8lu kB\n"
-                           "Shared_Dirty:  %8lu kB\n"
+                           "Shared_Dirty:   %8lu kB\n"
-                           "Private_Clean: %8lu kB\n"
+                           "Private_Clean:  %8lu kB\n"
-                           "Private_Dirty: %8lu kB\n",
+                           "Private_Dirty:  %8lu kB\n"
+                           "Referenced:     %8lu kB\n",
                           (vma->vm_end - vma->vm_start) >> 10,
                           mss->resident >> 10,
                           mss->shared_clean  >> 10,
                           mss->shared_dirty  >> 10,
                           mss->private_clean >> 10,
-                           mss->private_dirty >> 10);
+                           mss->private_dirty >> 10,
+                           mss->referenced >> 10);
        if (m->count < m->size)  /* vma is copied successfully */
                m->version = (vma != get_gate_vma(task))? vma->vm_start: 0;
@@ -205,15 +215,16 @@ static int show_map(struct seq_file *m, void *v)
 }
 static void smaps_pte_range(struct vm_area_struct *vma, pmd_t *pmd,
-                                unsigned long addr, unsigned long end,
+                            unsigned long addr, unsigned long end,
-                                struct mem_size_stats *mss)
+                            void *private)
 {
+        struct mem_size_stats *mss = private;
        pte_t *pte, ptent;
        spinlock_t *ptl;
        struct page *page;
        pte = pte_offset_map_lock(vma->vm_mm, pmd, addr, &ptl);
-        do {
+        for (; addr != end; pte++, addr += PAGE_SIZE) {
                ptent = *pte;
                if (!pte_present(ptent))
                        continue;
@@ -224,6 +235,9 @@ static void smaps_pte_range(struct vm_area_struct *vma, pmd_t *pmd,
                if (!page)
                        continue;
+                /* Accumulate the size in pages that have been accessed. */
+                if (pte_young(ptent) || PageReferenced(page))
+                        mss->referenced += PAGE_SIZE;
                if (page_mapcount(page) >= 2) {
                        if (pte_dirty(ptent))
                                mss->shared_dirty += PAGE_SIZE;
@@ -235,57 +249,99 @@ static void smaps_pte_range(struct vm_area_struct *vma, pmd_t *pmd,
                        else
                                mss->private_clean += PAGE_SIZE;
                }
-        } while (pte++, addr += PAGE_SIZE, addr != end);
+        }
        pte_unmap_unlock(pte - 1, ptl);
        cond_resched();
 }
-static inline void smaps_pmd_range(struct vm_area_struct *vma, pud_t *pud,
+static void clear_refs_pte_range(struct vm_area_struct *vma, pmd_t *pmd,
-                                unsigned long addr, unsigned long end,
+                                 unsigned long addr, unsigned long end,
-                                struct mem_size_stats *mss)
+                                 void *private)
+{
+        pte_t *pte, ptent;
+        spinlock_t *ptl;
+        struct page *page;
+        pte = pte_offset_map_lock(vma->vm_mm, pmd, addr, &ptl);
+        for (; addr != end; pte++, addr += PAGE_SIZE) {
+                ptent = *pte;
+                if (!pte_present(ptent))
+                        continue;
+                page = vm_normal_page(vma, addr, ptent);
+                if (!page)
+                        continue;
+                /* Clear accessed and referenced bits. */
+                ptep_test_and_clear_young(vma, addr, pte);
+                ClearPageReferenced(page);
+        }
+        pte_unmap_unlock(pte - 1, ptl);
+        cond_resched();
+}
+static inline void walk_pmd_range(struct pmd_walker *walker, pud_t *pud,
+                                  unsigned long addr, unsigned long end)
 {
        pmd_t *pmd;
        unsigned long next;
-        pmd = pmd_offset(pud, addr);
+        for (pmd = pmd_offset(pud, addr); addr != end;
-        do {
+             pmd++, addr = next) {
                next = pmd_addr_end(addr, end);
                if (pmd_none_or_clear_bad(pmd))
                        continue;
-                smaps_pte_range(vma, pmd, addr, next, mss);
+                walker->action(walker->vma, pmd, addr, next, walker->private);
-        } while (pmd++, addr = next, addr != end);
+        }
 }
-static inline void smaps_pud_range(struct vm_area_struct *vma, pgd_t *pgd,
+static inline void walk_pud_range(struct pmd_walker *walker, pgd_t *pgd,
-                                unsigned long addr, unsigned long end,
+                                  unsigned long addr, unsigned long end)
-                                struct mem_size_stats *mss)
 {
        pud_t *pud;
        unsigned long next;
-        pud = pud_offset(pgd, addr);
+        for (pud = pud_offset(pgd, addr); addr != end;
-        do {
+             pud++, addr = next) {
                next = pud_addr_end(addr, end);
                if (pud_none_or_clear_bad(pud))
                        continue;
-                smaps_pmd_range(vma, pud, addr, next, mss);
+                walk_pmd_range(walker, pud, addr, next);
-        } while (pud++, addr = next, addr != end);
+        }
 }
-static inline void smaps_pgd_range(struct vm_area_struct *vma,
+/*
-                                unsigned long addr, unsigned long end,
+ * walk_page_range - walk the page tables of a VMA with a callback
-                                struct mem_size_stats *mss)
+ * @vma - VMA to walk
+ * @action - callback invoked for every bottom-level (PTE) page table
+ * @private - private data passed to the callback function
+ *
+ * Recursively walk the page table for the memory area in a VMA, calling
+ * a callback for every bottom-level (PTE) page table.
+ */
+static inline void walk_page_range(struct vm_area_struct *vma,
+                                   void (*action)(struct vm_area_struct *,
+                                                  pmd_t *, unsigned long,
+                                                  unsigned long, void *),
+                                   void *private)
 {
+        unsigned long addr = vma->vm_start;
+        unsigned long end = vma->vm_end;
+        struct pmd_walker walker = {
+                .vma            = vma,
+                .private        = private,
+                .action         = action,
+        };
        pgd_t *pgd;
        unsigned long next;
-        pgd = pgd_offset(vma->vm_mm, addr);
+        for (pgd = pgd_offset(vma->vm_mm, addr); addr != end;
-        do {
+             pgd++, addr = next) {
                next = pgd_addr_end(addr, end);
                if (pgd_none_or_clear_bad(pgd))
                        continue;
-                smaps_pud_range(vma, pgd, addr, next, mss);
+                walk_pud_range(&walker, pgd, addr, next);
-        } while (pgd++, addr = next, addr != end);
+        }
 }
 static int show_smap(struct seq_file *m, void *v)
@@ -295,10 +351,22 @@ static int show_smap(struct seq_file *m, void *v)
        memset(&mss, 0, sizeof mss);
        if (vma->vm_mm && !is_vm_hugetlb_page(vma))
-                smaps_pgd_range(vma, vma->vm_start, vma->vm_end, &mss);
+                walk_page_range(vma, smaps_pte_range, &mss);
        return show_map_internal(m, v, &mss);
 }
+void clear_refs_smap(struct mm_struct *mm)
+{
+        struct vm_area_struct *vma;
+        down_read(&mm->mmap_sem);
+        for (vma = mm->mmap; vma; vma = vma->vm_next)
+                if (vma->vm_mm && !is_vm_hugetlb_page(vma))
+                        walk_page_range(vma, clear_refs_pte_range, NULL);
+        flush_tlb_mm(mm);
+        up_read(&mm->mmap_sem);
+}
 static void *m_start(struct seq_file *m, loff_t *pos)
 {
        struct proc_maps_private *priv = m->private;
diff --git a/fs/proc/vmcore.c b/fs/proc/vmcore.c
index d96050728c43..523e1098ae88 100644
--- a/fs/proc/vmcore.c
+++ b/fs/proc/vmcore.c
@@ -514,7 +514,7 @@ static int __init parse_crash_elf64_headers(void)
        /* Do some basic Verification. */
        if (memcmp(ehdr.e_ident, ELFMAG, SELFMAG) != 0 ||
                (ehdr.e_type != ET_CORE) ||
-                !elf_check_arch(&ehdr) ||
+                !vmcore_elf_check_arch(&ehdr) ||
                ehdr.e_ident[EI_CLASS] != ELFCLASS64 ||
                ehdr.e_ident[EI_VERSION] != EV_CURRENT ||
                ehdr.e_version != EV_CURRENT ||
diff --git a/fs/qnx4/inode.c b/fs/qnx4/inode.c
index 83bc8e7824cd..75fc8498f2e2 100644
--- a/fs/qnx4/inode.c
+++ b/fs/qnx4/inode.c
@@ -536,8 +536,7 @@ static void init_once(void *foo, struct kmem_cache * cachep,
 {
        struct qnx4_inode_info *ei = (struct qnx4_inode_info *) foo;
-        if ((flags & (SLAB_CTOR_VERIFY | SLAB_CTOR_CONSTRUCTOR)) ==
+        if (flags & SLAB_CTOR_CONSTRUCTOR)
-            SLAB_CTOR_CONSTRUCTOR)
                inode_init_once(&ei->vfs_inode);
 }
diff --git a/fs/reiserfs/super.c b/fs/reiserfs/super.c
index f13a7f164dc6..7054aaef0493 100644
--- a/fs/reiserfs/super.c
+++ b/fs/reiserfs/super.c
@@ -511,8 +511,7 @@ static void init_once(void *foo, struct kmem_cache * cachep, unsigned long flags
 {
        struct reiserfs_inode_info *ei = (struct reiserfs_inode_info *)foo;
-        if ((flags & (SLAB_CTOR_VERIFY | SLAB_CTOR_CONSTRUCTOR)) ==
+        if (flags & SLAB_CTOR_CONSTRUCTOR) {
-            SLAB_CTOR_CONSTRUCTOR) {
                INIT_LIST_HEAD(&ei->i_prealloc_list);
                inode_init_once(&ei->vfs_inode);
 #ifdef CONFIG_REISERFS_FS_POSIX_ACL
diff --git a/fs/reiserfs/xattr.c b/fs/reiserfs/xattr.c
index 2cac56210e2b..bf6e58214538 100644
--- a/fs/reiserfs/xattr.c
+++ b/fs/reiserfs/xattr.c
@@ -410,11 +410,7 @@ static struct page *reiserfs_get_page(struct inode *dir, unsigned long n)
        mapping_set_gfp_mask(mapping, GFP_NOFS);
        page = read_mapping_page(mapping, n, NULL);
        if (!IS_ERR(page)) {
-                wait_on_page_locked(page);
                kmap(page);
-                if (!PageUptodate(page))
-                        goto fail;
                if (PageError(page))
                        goto fail;
        }
diff --git a/fs/romfs/inode.c b/fs/romfs/inode.c
index fd601014813e..804285190271 100644
--- a/fs/romfs/inode.c
+++ b/fs/romfs/inode.c
@@ -570,8 +570,7 @@ static void init_once(void * foo, struct kmem_cache * cachep, unsigned long flag
 {
        struct romfs_inode_info *ei = (struct romfs_inode_info *) foo;
-        if ((flags & (SLAB_CTOR_VERIFY|SLAB_CTOR_CONSTRUCTOR)) ==
+        if (flags & SLAB_CTOR_CONSTRUCTOR)
-            SLAB_CTOR_CONSTRUCTOR)
                inode_init_once(&ei->vfs_inode);
 }
 
diff --git a/fs/smbfs/inode.c b/fs/smbfs/inode.c
index 5faba4f1c9ab..424a3ddf86dd 100644
--- a/fs/smbfs/inode.c
+++ b/fs/smbfs/inode.c
@@ -69,9 +69,8 @@ static void smb_destroy_inode(struct inode *inode)
 static void init_once(void * foo, struct kmem_cache * cachep, unsigned long flags)
 {
        struct smb_inode_info *ei = (struct smb_inode_info *) foo;
-        unsigned long flagmask = SLAB_CTOR_VERIFY|SLAB_CTOR_CONSTRUCTOR;
-        if ((flags & flagmask) == SLAB_CTOR_CONSTRUCTOR)
+        if (flags & SLAB_CTOR_CONSTRUCTOR)
                inode_init_once(&ei->vfs_inode);
 }
 
diff --git a/fs/sysfs/bin.c b/fs/sysfs/bin.c
index 8ea2a51ce883..d3b9f5f07db1 100644
--- a/fs/sysfs/bin.c
+++ b/fs/sysfs/bin.c
@@ -59,7 +59,7 @@ read(struct file * file, char __user * userbuf, size_t count, loff_t * off)
        if (copy_to_user(userbuf, buffer, count))
                return -EFAULT;
-        pr_debug("offs = %lld, *off = %lld, count = %d\n", offs, *off, count);
+        pr_debug("offs = %lld, *off = %lld, count = %zd\n", offs, *off, count);
        *off = offs + count;
diff --git a/fs/sysfs/file.c b/fs/sysfs/file.c
index db0413a411d6..0e637adc2b87 100644
--- a/fs/sysfs/file.c
+++ b/fs/sysfs/file.c
@@ -13,8 +13,7 @@
 #include "sysfs.h"
-#define to_subsys(k) container_of(k,struct subsystem,kset.kobj)
+#define to_sattr(a) container_of(a,struct subsys_attribute, attr)
-#define to_sattr(a) container_of(a,struct subsys_attribute,attr)
 /*
 * Subsystem file operations.
@@ -24,12 +23,12 @@
 static ssize_t 
 subsys_attr_show(struct kobject * kobj, struct attribute * attr, char * page)
 {
-        struct subsystem * s = to_subsys(kobj);
+        struct kset *kset = to_kset(kobj);
        struct subsys_attribute * sattr = to_sattr(attr);
        ssize_t ret = -EIO;
        if (sattr->show)
-                ret = sattr->show(s,page);
+                ret = sattr->show(kset, page);
        return ret;
 }
@@ -37,12 +36,12 @@ static ssize_t
 subsys_attr_store(struct kobject * kobj, struct attribute * attr, 
                  const char * page, size_t count)
 {
-        struct subsystem * s = to_subsys(kobj);
+        struct kset *kset = to_kset(kobj);
        struct subsys_attribute * sattr = to_sattr(attr);
        ssize_t ret = -EIO;
        if (sattr->store)
-                ret = sattr->store(s,page,count);
+                ret = sattr->store(kset, page, count);
        return ret;
 }
diff --git a/fs/sysv/dir.c b/fs/sysv/dir.c
index ebf7007fa161..e566b387fcf9 100644
--- a/fs/sysv/dir.c
+++ b/fs/sysv/dir.c
@@ -54,17 +54,9 @@ static struct page * dir_get_page(struct inode *dir, unsigned long n)
 {
        struct address_space *mapping = dir->i_mapping;
        struct page *page = read_mapping_page(mapping, n, NULL);
-        if (!IS_ERR(page)) {
+        if (!IS_ERR(page))
-                wait_on_page_locked(page);
                kmap(page);
-                if (!PageUptodate(page))
-                        goto fail;
-        }
        return page;
-fail:
-        dir_put_page(page);
-        return ERR_PTR(-EIO);
 }
 static int sysv_readdir(struct file * filp, void * dirent, filldir_t filldir)
diff --git a/fs/sysv/inode.c b/fs/sysv/inode.c
index 9311cac186fe..3152d7415606 100644
--- a/fs/sysv/inode.c
+++ b/fs/sysv/inode.c
@@ -322,8 +322,7 @@ static void init_once(void *p, struct kmem_cache *cachep, unsigned long flags)
 {
        struct sysv_inode_info *si = (struct sysv_inode_info *)p;
-        if ((flags & (SLAB_CTOR_VERIFY|SLAB_CTOR_CONSTRUCTOR)) ==
+        if (flags & SLAB_CTOR_CONSTRUCTOR)
-                        SLAB_CTOR_CONSTRUCTOR)
                inode_init_once(&si->vfs_inode);
 }
diff --git a/fs/udf/super.c b/fs/udf/super.c
index 8672b88f7ff2..023b304fdd99 100644
--- a/fs/udf/super.c
+++ b/fs/udf/super.c
@@ -134,9 +134,7 @@ static void init_once(void * foo, struct kmem_cache * cachep, unsigned long flag
 {
        struct udf_inode_info *ei = (struct udf_inode_info *) foo;
-        if ((flags & (SLAB_CTOR_VERIFY|SLAB_CTOR_CONSTRUCTOR)) ==
+        if (flags & SLAB_CTOR_CONSTRUCTOR) {
-            SLAB_CTOR_CONSTRUCTOR)
-        {
                ei->i_ext.i_data = NULL;
                inode_init_once(&ei->vfs_inode);
        }
diff --git a/fs/ufs/dir.c b/fs/ufs/dir.c
index 4890ddf1518e..4fb8b2e077ee 100644
--- a/fs/ufs/dir.c
+++ b/fs/ufs/dir.c
@@ -180,13 +180,9 @@ fail:
 static struct page *ufs_get_page(struct inode *dir, unsigned long n)
 {
        struct address_space *mapping = dir->i_mapping;
-        struct page *page = read_cache_page(mapping, n,
+        struct page *page = read_mapping_page(mapping, n, NULL);
-                                (filler_t*)mapping->a_ops->readpage, NULL);
        if (!IS_ERR(page)) {
-                wait_on_page_locked(page);
                kmap(page);
-                if (!PageUptodate(page))
-                        goto fail;
                if (!PageChecked(page))
                        ufs_check_page(page);
                if (PageError(page))
diff --git a/fs/ufs/super.c b/fs/ufs/super.c
index b5a6461ec66b..be7c48c5f203 100644
--- a/fs/ufs/super.c
+++ b/fs/ufs/super.c
@@ -1237,8 +1237,7 @@ static void init_once(void * foo, struct kmem_cache * cachep, unsigned long flag
 {
        struct ufs_inode_info *ei = (struct ufs_inode_info *) foo;
-        if ((flags & (SLAB_CTOR_VERIFY|SLAB_CTOR_CONSTRUCTOR)) ==
+        if (flags & SLAB_CTOR_CONSTRUCTOR)
-            SLAB_CTOR_CONSTRUCTOR)
                inode_init_once(&ei->vfs_inode);
 }
 
diff --git a/fs/ufs/util.c b/fs/ufs/util.c
index 17437574f79c..84357f1ff0ec 100644
--- a/fs/ufs/util.c
+++ b/fs/ufs/util.c
@@ -251,13 +251,11 @@ struct page *ufs_get_locked_page(struct address_space *mapping,
        page = find_lock_page(mapping, index);
        if (!page) {
-                page = read_cache_page(mapping, index,
+                page = read_mapping_page(mapping, index, NULL);
-                                       (filler_t*)mapping->a_ops->readpage,
-                                       NULL);
                if (IS_ERR(page)) {
                        printk(KERN_ERR "ufs_change_blocknr: "
-                               "read_cache_page error: ino %lu, index: %lu\n",
+                               "read_mapping_page error: ino %lu, index: %lu\n",
                               mapping->host->i_ino, index);
                        goto out;
                }
diff --git a/fs/xfs/linux-2.6/xfs_super.c b/fs/xfs/linux-2.6/xfs_super.c
index 2f2c40db562e..14e2cbe5a8d5 100644
--- a/fs/xfs/linux-2.6/xfs_super.c
+++ b/fs/xfs/linux-2.6/xfs_super.c
@@ -360,8 +360,7 @@ xfs_fs_inode_init_once(
        kmem_zone_t             *zonep,
        unsigned long           flags)
 {
-        if ((flags & (SLAB_CTOR_VERIFY|SLAB_CTOR_CONSTRUCTOR)) ==
+        if (flags & SLAB_CTOR_CONSTRUCTOR)
-                      SLAB_CTOR_CONSTRUCTOR)
                inode_init_once(vn_to_inode((bhv_vnode_t *)vnode));
 }