47 files changed, 1429 insertions, 608 deletions

diff --git a/fs/9p/Makefile b/fs/9p/Makefile
index 3d023089707e..2f4ce43f7b6c 100644
--- a/fs/9p/Makefile
+++ b/fs/9p/Makefile
@@ -8,6 +8,7 @@ obj-$(CONFIG_9P_FS) := 9p2000.o
         conv.o \
         vfs_super.o \
         vfs_inode.o \
+        vfs_addr.o \
         vfs_file.o \
         vfs_dir.o \
         vfs_dentry.o \
diff --git a/fs/9p/v9fs_vfs.h b/fs/9p/v9fs_vfs.h
index c78502ad00ed..69cf2905dc90 100644
--- a/fs/9p/v9fs_vfs.h
+++ b/fs/9p/v9fs_vfs.h
@@ -39,6 +39,7 @@
  */
 
 extern struct file_system_type v9fs_fs_type;
+extern struct address_space_operations v9fs_addr_operations;
 extern struct file_operations v9fs_file_operations;
 extern struct file_operations v9fs_dir_operations;
 extern struct dentry_operations v9fs_dentry_operations;
diff --git a/fs/9p/vfs_addr.c b/fs/9p/vfs_addr.c
new file mode 100644
index 000000000000..8100fb5171b7
--- /dev/null
+++ b/fs/9p/vfs_addr.c
@@ -0,0 +1,109 @@
+/*
+ *  linux/fs/9p/vfs_addr.c
+ *
+ * This file contians vfs address (mmap) ops for 9P2000.
+ *
+ *  Copyright (C) 2005 by Eric Van Hensbergen <ericvh@gmail.com>
+ *  Copyright (C) 2002 by Ron Minnich <rminnich@lanl.gov>
+ *
+ *  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.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to:
+ *  Free Software Foundation
+ *  51 Franklin Street, Fifth Floor
+ *  Boston, MA  02111-1301  USA
+ *
+ */
+
+#include <linux/module.h>
+#include <linux/errno.h>
+#include <linux/fs.h>
+#include <linux/file.h>
+#include <linux/stat.h>
+#include <linux/string.h>
+#include <linux/smp_lock.h>
+#include <linux/inet.h>
+#include <linux/version.h>
+#include <linux/pagemap.h>
+#include <linux/idr.h>
+
+#include "debug.h"
+#include "v9fs.h"
+#include "9p.h"
+#include "v9fs_vfs.h"
+#include "fid.h"
+
+/**
+ * v9fs_vfs_readpage - read an entire page in from 9P
+ *
+ * @file: file being read
+ * @page: structure to page
+ *
+ */
+
+static int v9fs_vfs_readpage(struct file *filp, struct page *page)
+{
+        char *buffer = NULL;
+        int retval = -EIO;
+        loff_t offset = page_offset(page);
+        int count = PAGE_CACHE_SIZE;
+        struct inode *inode = filp->f_dentry->d_inode;
+        struct v9fs_session_info *v9ses = v9fs_inode2v9ses(inode);
+        int rsize = v9ses->maxdata - V9FS_IOHDRSZ;
+        struct v9fs_fid *v9f = filp->private_data;
+        struct v9fs_fcall *fcall = NULL;
+        int fid = v9f->fid;
+        int total = 0;
+        int result = 0;
+
+        buffer = kmap(page);
+        do {
+                if (count < rsize)
+                        rsize = count;
+
+                result = v9fs_t_read(v9ses, fid, offset, rsize, &fcall);
+
+                if (result < 0) {
+                        printk(KERN_ERR "v9fs_t_read returned %d\n",
+                               result);
+
+                        kfree(fcall);
+                        goto UnmapAndUnlock;
+                } else
+                        offset += result;
+
+                memcpy(buffer, fcall->params.rread.data, result);
+
+                count -= result;
+                buffer += result;
+                total += result;
+
+                kfree(fcall);
+
+                if (result < rsize)
+                        break;
+        } while (count);
+
+        memset(buffer, 0, count);
+        flush_dcache_page(page);
+        SetPageUptodate(page);
+        retval = 0;
+
+UnmapAndUnlock:
+        kunmap(page);
+        unlock_page(page);
+        return retval;
+}
+
+struct address_space_operations v9fs_addr_operations = {
+      .readpage = v9fs_vfs_readpage,
+};
diff --git a/fs/9p/vfs_file.c b/fs/9p/vfs_file.c
index 6852f0eb96ed..c7e14d917215 100644
--- a/fs/9p/vfs_file.c
+++ b/fs/9p/vfs_file.c
@@ -289,6 +289,9 @@ v9fs_file_write(struct file *filp, const char __user * data,
                 total += result;
         } while (count);
 
+        if(inode->i_mapping->nrpages)
+                invalidate_inode_pages2(inode->i_mapping);
+
         return total;
 }
 
@@ -299,4 +302,5 @@ struct file_operations v9fs_file_operations = {
         .open = v9fs_file_open,
         .release = v9fs_dir_release,
         .lock = v9fs_file_lock,
+        .mmap = generic_file_mmap,
 };
diff --git a/fs/9p/vfs_inode.c b/fs/9p/vfs_inode.c
index a17b28854288..91f552454c76 100644
--- a/fs/9p/vfs_inode.c
+++ b/fs/9p/vfs_inode.c
@@ -177,6 +177,7 @@ struct inode *v9fs_get_inode(struct super_block *sb, int mode)
                 inode->i_blocks = 0;
                 inode->i_rdev = 0;
                 inode->i_atime = inode->i_mtime = inode->i_ctime = CURRENT_TIME;
+                inode->i_mapping->a_ops = &v9fs_addr_operations;
 
                 switch (mode & S_IFMT) {
                 case S_IFIFO:
diff --git a/fs/compat.c b/fs/compat.c
index 2468ac1df2f0..18b21b4c9e3a 100644
--- a/fs/compat.c
+++ b/fs/compat.c
@@ -53,6 +53,8 @@
 #include <asm/mmu_context.h>
 #include <asm/ioctls.h>
 
+extern void sigset_from_compat(sigset_t *set, compat_sigset_t *compat);
+
 /*
  * Not all architectures have sys_utime, so implement this in terms
  * of sys_utimes.
@@ -68,10 +70,10 @@ asmlinkage long compat_sys_utime(char __user *filename, struct compat_utimbuf __
                 tv[0].tv_usec = 0;
                 tv[1].tv_usec = 0;
         }
-        return do_utimes(filename, t ? tv : NULL);
+        return do_utimes(AT_FDCWD, filename, t ? tv : NULL);
 }
 
-asmlinkage long compat_sys_utimes(char __user *filename, struct compat_timeval __user *t)
+asmlinkage long compat_sys_futimesat(int dfd, char __user *filename, struct compat_timeval __user *t)
 {
         struct timeval tv[2];
 
@@ -82,14 +84,19 @@ asmlinkage long compat_sys_utimes(char __user *filename, struct compat_timeval _
                     get_user(tv[1].tv_usec, &t[1].tv_usec))
                         return -EFAULT; 
         } 
-        return do_utimes(filename, t ? tv : NULL);
+        return do_utimes(dfd, filename, t ? tv : NULL);
+}
+
+asmlinkage long compat_sys_utimes(char __user *filename, struct compat_timeval __user *t)
+{
+        return compat_sys_futimesat(AT_FDCWD, filename, t);
 }
 
 asmlinkage long compat_sys_newstat(char __user * filename,
                 struct compat_stat __user *statbuf)
 {
         struct kstat stat;
-        int error = vfs_stat(filename, &stat);
+        int error = vfs_stat_fd(AT_FDCWD, filename, &stat);
 
         if (!error)
                 error = cp_compat_stat(&stat, statbuf);
@@ -100,10 +107,31 @@ asmlinkage long compat_sys_newlstat(char __user * filename,
                 struct compat_stat __user *statbuf)
 {
         struct kstat stat;
-        int error = vfs_lstat(filename, &stat);
+        int error = vfs_lstat_fd(AT_FDCWD, filename, &stat);
+
+        if (!error)
+                error = cp_compat_stat(&stat, statbuf);
+        return error;
+}
+
+asmlinkage long compat_sys_newfstatat(int dfd, char __user *filename,
+                struct compat_stat __user *statbuf, int flag)
+{
+        struct kstat stat;
+        int error = -EINVAL;
+
+        if ((flag & ~AT_SYMLINK_NOFOLLOW) != 0)
+                goto out;
+
+        if (flag & AT_SYMLINK_NOFOLLOW)
+                error = vfs_lstat_fd(dfd, filename, &stat);
+        else
+                error = vfs_stat_fd(dfd, filename, &stat);
 
         if (!error)
                 error = cp_compat_stat(&stat, statbuf);
+
+out:
         return error;
 }
 
@@ -1290,7 +1318,17 @@ out:
 asmlinkage long
 compat_sys_open(const char __user *filename, int flags, int mode)
 {
-        return do_sys_open(filename, flags, mode);
+        return do_sys_open(AT_FDCWD, filename, flags, mode);
+}
+
+/*
+ * Exactly like fs/open.c:sys_openat(), except that it doesn't set the
+ * O_LARGEFILE flag.
+ */
+asmlinkage long
+compat_sys_openat(int dfd, const char __user *filename, int flags, int mode)
+{
+        return do_sys_open(dfd, filename, flags, mode);
 }
 
 /*
@@ -1621,36 +1659,14 @@ static void select_bits_free(void *bits, int size)
 #define MAX_SELECT_SECONDS \
         ((unsigned long) (MAX_SCHEDULE_TIMEOUT / HZ)-1)
 
-asmlinkage long
-compat_sys_select(int n, compat_ulong_t __user *inp, compat_ulong_t __user *outp,
-                compat_ulong_t __user *exp, struct compat_timeval __user *tvp)
+int compat_core_sys_select(int n, compat_ulong_t __user *inp,
+        compat_ulong_t __user *outp, compat_ulong_t __user *exp, s64 *timeout)
 {
         fd_set_bits fds;
         char *bits;
-        long timeout;
         int size, max_fdset, ret = -EINVAL;
         struct fdtable *fdt;
 
-        timeout = MAX_SCHEDULE_TIMEOUT;
-        if (tvp) {
-                time_t sec, usec;
-
-                if (!access_ok(VERIFY_READ, tvp, sizeof(*tvp))
-                    || __get_user(sec, &tvp->tv_sec)
-                    || __get_user(usec, &tvp->tv_usec)) {
-                        ret = -EFAULT;
-                        goto out_nofds;
-                }
-
-                if (sec < 0 || usec < 0)
-                        goto out_nofds;
-
-                if ((unsigned long) sec < MAX_SELECT_SECONDS) {
-                        timeout = ROUND_UP(usec, 1000000/HZ);
-                        timeout += sec * (unsigned long) HZ;
-                }
-        }
-
         if (n < 0)
                 goto out_nofds;
 
@@ -1687,19 +1703,7 @@ compat_sys_select(int n, compat_ulong_t __user *inp, compat_ulong_t __user *outp
         zero_fd_set(n, fds.res_out);
         zero_fd_set(n, fds.res_ex);
 
-        ret = do_select(n, &fds, &timeout);
-
-        if (tvp && !(current->personality & STICKY_TIMEOUTS)) {
-                time_t sec = 0, usec = 0;
-                if (timeout) {
-                        sec = timeout / HZ;
-                        usec = timeout % HZ;
-                        usec *= (1000000/HZ);
-                }
-                if (put_user(sec, &tvp->tv_sec) ||
-                    put_user(usec, &tvp->tv_usec))
-                        ret = -EFAULT;
-        }
+        ret = do_select(n, &fds, timeout);
 
         if (ret < 0)
                 goto out;
@@ -1720,6 +1724,224 @@ out_nofds:
         return ret;
 }
 
+asmlinkage long compat_sys_select(int n, compat_ulong_t __user *inp,
+        compat_ulong_t __user *outp, compat_ulong_t __user *exp,
+        struct compat_timeval __user *tvp)
+{
+        s64 timeout = -1;
+        struct compat_timeval tv;
+        int ret;
+
+        if (tvp) {
+                if (copy_from_user(&tv, tvp, sizeof(tv)))
+                        return -EFAULT;
+
+                if (tv.tv_sec < 0 || tv.tv_usec < 0)
+                        return -EINVAL;
+
+                /* Cast to u64 to make GCC stop complaining */
+                if ((u64)tv.tv_sec >= (u64)MAX_INT64_SECONDS)
+                        timeout = -1;   /* infinite */
+                else {
+                        timeout = ROUND_UP(tv.tv_sec, 1000000/HZ);
+                        timeout += tv.tv_sec * HZ;
+                }
+        }
+
+        ret = compat_core_sys_select(n, inp, outp, exp, &timeout);
+
+        if (tvp) {
+                if (current->personality & STICKY_TIMEOUTS)
+                        goto sticky;
+                tv.tv_usec = jiffies_to_usecs(do_div((*(u64*)&timeout), HZ));
+                tv.tv_sec = timeout;
+                if (copy_to_user(tvp, &tv, sizeof(tv))) {
+sticky:
+                        /*
+                         * If an application puts its timeval in read-only
+                         * memory, we don't want the Linux-specific update to
+                         * the timeval to cause a fault after the select has
+                         * completed successfully. However, because we're not
+                         * updating the timeval, we can't restart the system
+                         * call.
+                         */
+                        if (ret == -ERESTARTNOHAND)
+                                ret = -EINTR;
+                }
+        }
+
+        return ret;
+}
+
+#ifdef TIF_RESTORE_SIGMASK
+asmlinkage long compat_sys_pselect7(int n, compat_ulong_t __user *inp,
+        compat_ulong_t __user *outp, compat_ulong_t __user *exp,
+        struct compat_timespec __user *tsp, compat_sigset_t __user *sigmask,
+        compat_size_t sigsetsize)
+{
+        compat_sigset_t ss32;
+        sigset_t ksigmask, sigsaved;
+        long timeout = MAX_SCHEDULE_TIMEOUT;
+        struct compat_timespec ts;
+        int ret;
+
+        if (tsp) {
+                if (copy_from_user(&ts, tsp, sizeof(ts)))
+                        return -EFAULT;
+
+                if (ts.tv_sec < 0 || ts.tv_nsec < 0)
+                        return -EINVAL;
+        }
+
+        if (sigmask) {
+                if (sigsetsize != sizeof(compat_sigset_t))
+                        return -EINVAL;
+                if (copy_from_user(&ss32, sigmask, sizeof(ss32)))
+                        return -EFAULT;
+                sigset_from_compat(&ksigmask, &ss32);
+
+                sigdelsetmask(&ksigmask, sigmask(SIGKILL)|sigmask(SIGSTOP));
+                sigprocmask(SIG_SETMASK, &ksigmask, &sigsaved);
+        }
+
+        do {
+                if (tsp) {
+                        if ((unsigned long)ts.tv_sec < MAX_SELECT_SECONDS) {
+                                timeout = ROUND_UP(ts.tv_nsec, 1000000000/HZ);
+                                timeout += ts.tv_sec * (unsigned long)HZ;
+                                ts.tv_sec = 0;
+                                ts.tv_nsec = 0;
+                        } else {
+                                ts.tv_sec -= MAX_SELECT_SECONDS;
+                                timeout = MAX_SELECT_SECONDS * HZ;
+                        }
+                }
+
+                ret = compat_core_sys_select(n, inp, outp, exp, &timeout);
+
+        } while (!ret && !timeout && tsp && (ts.tv_sec || ts.tv_nsec));
+
+        if (tsp && !(current->personality & STICKY_TIMEOUTS)) {
+                ts.tv_sec += timeout / HZ;
+                ts.tv_nsec += (timeout % HZ) * (1000000000/HZ);
+                if (ts.tv_nsec >= 1000000000) {
+                        ts.tv_sec++;
+                        ts.tv_nsec -= 1000000000;
+                }
+                (void)copy_to_user(tsp, &ts, sizeof(ts));
+        }
+
+        if (ret == -ERESTARTNOHAND) {
+                /*
+                 * Don't restore the signal mask yet. Let do_signal() deliver
+                 * the signal on the way back to userspace, before the signal
+                 * mask is restored.
+                 */
+                if (sigmask) {
+                        memcpy(&current->saved_sigmask, &sigsaved,
+                                        sizeof(sigsaved));
+                        set_thread_flag(TIF_RESTORE_SIGMASK);
+                }
+        } else if (sigmask)
+                sigprocmask(SIG_SETMASK, &sigsaved, NULL);
+
+        return ret;
+}
+
+asmlinkage long compat_sys_pselect6(int n, compat_ulong_t __user *inp,
+        compat_ulong_t __user *outp, compat_ulong_t __user *exp,
+        struct compat_timespec __user *tsp, void __user *sig)
+{
+        compat_size_t sigsetsize = 0;
+        compat_uptr_t up = 0;
+
+        if (sig) {
+                if (!access_ok(VERIFY_READ, sig,
+                                sizeof(compat_uptr_t)+sizeof(compat_size_t)) ||
+                        __get_user(up, (compat_uptr_t __user *)sig) ||
+                        __get_user(sigsetsize,
+                                (compat_size_t __user *)(sig+sizeof(up))))
+                        return -EFAULT;
+        }
+        return compat_sys_pselect7(n, inp, outp, exp, tsp, compat_ptr(up),
+                                        sigsetsize);
+}
+
+asmlinkage long compat_sys_ppoll(struct pollfd __user *ufds,
+        unsigned int nfds, struct compat_timespec __user *tsp,
+        const compat_sigset_t __user *sigmask, compat_size_t sigsetsize)
+{
+        compat_sigset_t ss32;
+        sigset_t ksigmask, sigsaved;
+        struct compat_timespec ts;
+        s64 timeout = -1;
+        int ret;
+
+        if (tsp) {
+                if (copy_from_user(&ts, tsp, sizeof(ts)))
+                        return -EFAULT;
+
+                /* We assume that ts.tv_sec is always lower than
+                   the number of seconds that can be expressed in
+                   an s64. Otherwise the compiler bitches at us */
+                timeout = ROUND_UP(ts.tv_sec, 1000000000/HZ);
+                timeout += ts.tv_sec * HZ;
+        }
+
+        if (sigmask) {
+                if (sigsetsize |= sizeof(compat_sigset_t))
+                        return -EINVAL;
+                if (copy_from_user(&ss32, sigmask, sizeof(ss32)))
+                        return -EFAULT;
+                sigset_from_compat(&ksigmask, &ss32);
+
+                sigdelsetmask(&ksigmask, sigmask(SIGKILL)|sigmask(SIGSTOP));
+                sigprocmask(SIG_SETMASK, &ksigmask, &sigsaved);
+        }
+
+        ret = do_sys_poll(ufds, nfds, &timeout);
+
+        /* We can restart this syscall, usually */
+        if (ret == -EINTR) {
+                /*
+                 * Don't restore the signal mask yet. Let do_signal() deliver
+                 * the signal on the way back to userspace, before the signal
+                 * mask is restored.
+                 */
+                if (sigmask) {
+                        memcpy(&current->saved_sigmask, &sigsaved,
+                                sizeof(sigsaved));
+                        set_thread_flag(TIF_RESTORE_SIGMASK);
+                }
+                ret = -ERESTARTNOHAND;
+        } else if (sigmask)
+                sigprocmask(SIG_SETMASK, &sigsaved, NULL);
+
+        if (tsp && timeout >= 0) {
+                if (current->personality & STICKY_TIMEOUTS)
+                        goto sticky;
+                /* Yes, we know it's actually an s64, but it's also positive. */
+                ts.tv_nsec = jiffies_to_usecs(do_div((*(u64*)&timeout), HZ)) * 1000;
+                ts.tv_sec = timeout;
+                if (copy_to_user(tsp, &ts, sizeof(ts))) {
+sticky:
+                        /*
+                         * If an application puts its timeval in read-only
+                         * memory, we don't want the Linux-specific update to
+                         * the timeval to cause a fault after the select has
+                         * completed successfully. However, because we're not
+                         * updating the timeval, we can't restart the system
+                         * call.
+                         */
+                        if (ret == -ERESTARTNOHAND && timeout >= 0)
+                                ret = -EINTR;
+                }
+        }
+
+        return ret;
+}
+#endif /* TIF_RESTORE_SIGMASK */
+
 #if defined(CONFIG_NFSD) || defined(CONFIG_NFSD_MODULE)
 /* Stuff for NFS server syscalls... */
 struct compat_nfsctl_svc {
diff --git a/fs/exec.c b/fs/exec.c
index 62b40af68cc4..055378d2513e 100644
--- a/fs/exec.c
+++ b/fs/exec.c
@@ -477,7 +477,7 @@ struct file *open_exec(const char *name)
         int err;
         struct file *file;
 
-        err = path_lookup_open(name, LOOKUP_FOLLOW, &nd, FMODE_READ);
+        err = path_lookup_open(AT_FDCWD, name, LOOKUP_FOLLOW, &nd, FMODE_READ);
         file = ERR_PTR(err);
 
         if (!err) {
diff --git a/fs/exportfs/expfs.c b/fs/exportfs/expfs.c
index 5bfe40085fbc..b06b54f1bbbb 100644
--- a/fs/exportfs/expfs.c
+++ b/fs/exportfs/expfs.c
@@ -11,6 +11,33 @@ struct export_operations export_op_default;
 
 #define dprintk(fmt, args...) do{}while(0)
 
+static struct dentry *
+find_acceptable_alias(struct dentry *result,
+                int (*acceptable)(void *context, struct dentry *dentry),
+                void *context)
+{
+        struct dentry *dentry, *toput = NULL;
+
+        spin_lock(&dcache_lock);
+        list_for_each_entry(dentry, &result->d_inode->i_dentry, d_alias) {
+                dget_locked(dentry);
+                spin_unlock(&dcache_lock);
+                if (toput)
+                        dput(toput);
+                if (dentry != result && acceptable(context, dentry)) {
+                        dput(result);
+                        return dentry;
+                }
+                spin_lock(&dcache_lock);
+                toput = dentry;
+        }
+        spin_unlock(&dcache_lock);
+
+        if (toput)
+                dput(toput);
+        return NULL;
+}
+
 /**
  * find_exported_dentry - helper routine to implement export_operations->decode_fh
  * @sb:         The &super_block identifying the filesystem
@@ -52,8 +79,7 @@ find_exported_dentry(struct super_block *sb, void *obj, void *parent,
         struct dentry *target_dir;
         int err;
         struct export_operations *nops = sb->s_export_op;
-        struct list_head *le, *head;
-        struct dentry *toput = NULL;
+        struct dentry *alias;
         int noprogress;
         char nbuf[NAME_MAX+1];
 
@@ -79,27 +105,10 @@ find_exported_dentry(struct super_block *sb, void *obj, void *parent,
                         /* there is no other dentry, so fail */
                         goto err_result;
                 }
-                /* try any other aliases */
-                spin_lock(&dcache_lock);
-                head = &result->d_inode->i_dentry;
-                list_for_each(le, head) {
-                        struct dentry *dentry = list_entry(le, struct dentry, d_alias);
-                        dget_locked(dentry);
-                        spin_unlock(&dcache_lock);
-                        if (toput)
-                                dput(toput);
-                        toput = NULL;
-                        if (dentry != result &&
-                            acceptable(context, dentry)) {
-                                dput(result);
-                                return dentry;
-                        }
-                        spin_lock(&dcache_lock);
-                        toput = dentry;
-                }
-                spin_unlock(&dcache_lock);
-                if (toput)
-                        dput(toput);
+
+                alias = find_acceptable_alias(result, acceptable, context);
+                if (alias)
+                        return alias;
         }                       
 
         /* It's a directory, or we are required to confirm the file's
@@ -258,26 +267,10 @@ find_exported_dentry(struct super_block *sb, void *obj, void *parent,
         /* now result is properly connected, it is our best bet */
         if (acceptable(context, result))
                 return result;
-        /* one last try of the aliases.. */
-        spin_lock(&dcache_lock);
-        toput = NULL;
-        head = &result->d_inode->i_dentry;
-        list_for_each(le, head) {
-                struct dentry *dentry = list_entry(le, struct dentry, d_alias);
-                dget_locked(dentry);
-                spin_unlock(&dcache_lock);
-                if (toput) dput(toput);
-                if (dentry != result &&
-                    acceptable(context, dentry)) {
-                        dput(result);
-                        return dentry;
-                }
-                spin_lock(&dcache_lock);
-                toput = dentry;
-        }
-        spin_unlock(&dcache_lock);
-        if (toput)
-                dput(toput);
+
+        alias = find_acceptable_alias(result, acceptable, context);
+        if (alias)
+                return alias;
 
         /* drat - I just cannot find anything acceptable */
         dput(result);
diff --git a/fs/hfs/bfind.c b/fs/hfs/bfind.c
index 89450ae32228..f13f1494d4fe 100644
--- a/fs/hfs/bfind.c
+++ b/fs/hfs/bfind.c
@@ -64,7 +64,6 @@ int __hfs_brec_find(struct hfs_bnode *bnode, struct hfs_find_data *fd)
                 else
                         e = rec - 1;
         } while (b <= e);
-        //printk("%d: %d,%d,%d\n", bnode->this, b, e, rec);
         if (rec != e && e >= 0) {
                 len = hfs_brec_lenoff(bnode, e, &off);
                 keylen = hfs_brec_keylen(bnode, e);
@@ -127,7 +126,7 @@ int hfs_brec_find(struct hfs_find_data *fd)
         return res;
 
 invalid:
-        printk("HFS: inconsistency in B*Tree (%d,%d,%d,%u,%u)\n",
+        printk(KERN_ERR "hfs: inconsistency in B*Tree (%d,%d,%d,%u,%u)\n",
                 height, bnode->height, bnode->type, nidx, parent);
         res = -EIO;
 release:
diff --git a/fs/hfs/bnode.c b/fs/hfs/bnode.c
index 3d5cdc6847c0..a7a7d77f3fd3 100644
--- a/fs/hfs/bnode.c
+++ b/fs/hfs/bnode.c
@@ -198,7 +198,7 @@ void hfs_bnode_unlink(struct hfs_bnode *node)
 
         // move down?
         if (!node->prev && !node->next) {
-                printk("hfs_btree_del_level\n");
+                printk(KERN_DEBUG "hfs_btree_del_level\n");
         }
         if (!node->parent) {
                 tree->root = 0;
@@ -219,7 +219,7 @@ struct hfs_bnode *hfs_bnode_findhash(struct hfs_btree *tree, u32 cnid)
         struct hfs_bnode *node;
 
         if (cnid >= tree->node_count) {
-                printk("HFS: request for non-existent node %d in B*Tree\n", cnid);
+                printk(KERN_ERR "hfs: request for non-existent node %d in B*Tree\n", cnid);
                 return NULL;
         }
 
@@ -242,7 +242,7 @@ static struct hfs_bnode *__hfs_bnode_create(struct hfs_btree *tree, u32 cnid)
         loff_t off;
 
         if (cnid >= tree->node_count) {
-                printk("HFS: request for non-existent node %d in B*Tree\n", cnid);
+                printk(KERN_ERR "hfs: request for non-existent node %d in B*Tree\n", cnid);
                 return NULL;
         }
 
diff --git a/fs/hfs/brec.c b/fs/hfs/brec.c
index 7d8fff2c25fc..5c87cf4801fc 100644
--- a/fs/hfs/brec.c
+++ b/fs/hfs/brec.c
@@ -362,7 +362,7 @@ again:
                 end_off = hfs_bnode_read_u16(parent, end_rec_off);
                 if (end_rec_off - end_off < diff) {
 
-                        printk("splitting index node...\n");
+                        printk(KERN_DEBUG "hfs: splitting index node...\n");
                         fd->bnode = parent;
                         new_node = hfs_bnode_split(fd);
                         if (IS_ERR(new_node))
diff --git a/fs/hfs/btree.c b/fs/hfs/btree.c
index 394725efa1c8..7bb11edd1488 100644
--- a/fs/hfs/btree.c
+++ b/fs/hfs/btree.c
@@ -111,7 +111,7 @@ void hfs_btree_close(struct hfs_btree *tree)
                 while ((node = tree->node_hash[i])) {
                         tree->node_hash[i] = node->next_hash;
                         if (atomic_read(&node->refcnt))
-                                printk("HFS: node %d:%d still has %d user(s)!\n",
+                                printk(KERN_ERR "hfs: node %d:%d still has %d user(s)!\n",
                                         node->tree->cnid, node->this, atomic_read(&node->refcnt));
                         hfs_bnode_free(node);
                         tree->node_hash_cnt--;
@@ -252,7 +252,7 @@ struct hfs_bnode *hfs_bmap_alloc(struct hfs_btree *tree)
                 kunmap(*pagep);
                 nidx = node->next;
                 if (!nidx) {
-                        printk("create new bmap node...\n");
+                        printk(KERN_DEBUG "hfs: create new bmap node...\n");
                         next_node = hfs_bmap_new_bmap(node, idx);
                 } else
                         next_node = hfs_bnode_find(tree, nidx);
@@ -292,7 +292,7 @@ void hfs_bmap_free(struct hfs_bnode *node)
                 hfs_bnode_put(node);
                 if (!i) {
                         /* panic */;
-                        printk("HFS: unable to free bnode %u. bmap not found!\n", node->this);
+                        printk(KERN_CRIT "hfs: unable to free bnode %u. bmap not found!\n", node->this);
                         return;
                 }
                 node = hfs_bnode_find(tree, i);
@@ -300,7 +300,7 @@ void hfs_bmap_free(struct hfs_bnode *node)
                         return;
                 if (node->type != HFS_NODE_MAP) {
                         /* panic */;
-                        printk("HFS: invalid bmap found! (%u,%d)\n", node->this, node->type);
+                        printk(KERN_CRIT "hfs: invalid bmap found! (%u,%d)\n", node->this, node->type);
                         hfs_bnode_put(node);
                         return;
                 }
@@ -313,7 +313,7 @@ void hfs_bmap_free(struct hfs_bnode *node)
         m = 1 << (~nidx & 7);
         byte = data[off];
         if (!(byte & m)) {
-                printk("HFS: trying to free free bnode %u(%d)\n", node->this, node->type);
+                printk(KERN_CRIT "hfs: trying to free free bnode %u(%d)\n", node->this, node->type);
                 kunmap(page);
                 hfs_bnode_put(node);
                 return;
diff --git a/fs/hfs/catalog.c b/fs/hfs/catalog.c
index 2fcd679f0238..ba851576ebb1 100644
--- a/fs/hfs/catalog.c
+++ b/fs/hfs/catalog.c
@@ -184,7 +184,7 @@ int hfs_cat_find_brec(struct super_block *sb, u32 cnid,
 
         type = rec.type;
         if (type != HFS_CDR_THD && type != HFS_CDR_FTH) {
-                printk("HFS-fs: Found bad thread record in catalog\n");
+                printk(KERN_ERR "hfs: found bad thread record in catalog\n");
                 return -EIO;
         }
 
diff --git a/fs/hfs/dir.c b/fs/hfs/dir.c
index e1f24befba58..534e5a7480ef 100644
--- a/fs/hfs/dir.c
+++ b/fs/hfs/dir.c
@@ -81,12 +81,12 @@ static int hfs_readdir(struct file *filp, void *dirent, filldir_t filldir)
         case 1:
                 hfs_bnode_read(fd.bnode, &entry, fd.entryoffset, fd.entrylength);
                 if (entry.type != HFS_CDR_THD) {
-                        printk("HFS: bad catalog folder thread\n");
+                        printk(KERN_ERR "hfs: bad catalog folder thread\n");
                         err = -EIO;
                         goto out;
                 }
                 //if (fd.entrylength < HFS_MIN_THREAD_SZ) {
-                //      printk("HFS: truncated catalog thread\n");
+                //      printk(KERN_ERR "hfs: truncated catalog thread\n");
                 //      err = -EIO;
                 //      goto out;
                 //}
@@ -105,7 +105,7 @@ static int hfs_readdir(struct file *filp, void *dirent, filldir_t filldir)
 
         for (;;) {
                 if (be32_to_cpu(fd.key->cat.ParID) != inode->i_ino) {
-                        printk("HFS: walked past end of dir\n");
+                        printk(KERN_ERR "hfs: walked past end of dir\n");
                         err = -EIO;
                         goto out;
                 }
@@ -114,7 +114,7 @@ static int hfs_readdir(struct file *filp, void *dirent, filldir_t filldir)
                 len = hfs_mac2asc(sb, strbuf, &fd.key->cat.CName);
                 if (type == HFS_CDR_DIR) {
                         if (fd.entrylength < sizeof(struct hfs_cat_dir)) {
-                                printk("HFS: small dir entry\n");
+                                printk(KERN_ERR "hfs: small dir entry\n");
                                 err = -EIO;
                                 goto out;
                         }
@@ -123,7 +123,7 @@ static int hfs_readdir(struct file *filp, void *dirent, filldir_t filldir)
                                 break;
                 } else if (type == HFS_CDR_FIL) {
                         if (fd.entrylength < sizeof(struct hfs_cat_file)) {
-                                printk("HFS: small file entry\n");
+                                printk(KERN_ERR "hfs: small file entry\n");
                                 err = -EIO;
                                 goto out;
                         }
@@ -131,7 +131,7 @@ static int hfs_readdir(struct file *filp, void *dirent, filldir_t filldir)
                                     be32_to_cpu(entry.file.FlNum), DT_REG))
                                 break;
                 } else {
-                        printk("HFS: bad catalog entry type %d\n", type);
+                        printk(KERN_ERR "hfs: bad catalog entry type %d\n", type);
                         err = -EIO;
                         goto out;
                 }
diff --git a/fs/hfs/hfs_fs.h b/fs/hfs/hfs_fs.h
index cc5dcd52e23d..18ce47ab1b71 100644
--- a/fs/hfs/hfs_fs.h
+++ b/fs/hfs/hfs_fs.h
@@ -35,9 +35,6 @@
 #define dprint(flg, fmt, args...) \
         if (flg & DBG_MASK) printk(fmt , ## args)
 
-#define hfs_warn(format, args...) printk(KERN_WARNING format , ## args)
-#define hfs_error(format, args...) printk(KERN_ERR format , ## args)
-
 /*
  * struct hfs_inode_info
  *
diff --git a/fs/hfs/inode.c b/fs/hfs/inode.c
index 050a49276499..39fd85b9b916 100644
--- a/fs/hfs/inode.c
+++ b/fs/hfs/inode.c
@@ -95,7 +95,6 @@ static int hfs_releasepage(struct page *page, gfp_t mask)
                 } while (--i && nidx < tree->node_count);
                 spin_unlock(&tree->hash_lock);
         }
-        //printk("releasepage: %lu,%x = %d\n", page->index, mask, res);
         return res ? try_to_free_buffers(page) : 0;
 }
 
diff --git a/fs/hfs/mdb.c b/fs/hfs/mdb.c
index 0a473f79c89f..b4651e128d7f 100644
--- a/fs/hfs/mdb.c
+++ b/fs/hfs/mdb.c
@@ -47,7 +47,7 @@ static int hfs_get_last_session(struct super_block *sb,
                         *start = (sector_t)te.cdte_addr.lba << 2;
                         return 0;
                 }
-                printk(KERN_ERR "HFS: Invalid session number or type of track\n");
+                printk(KERN_ERR "hfs: invalid session number or type of track\n");
                 return -EINVAL;
         }
         ms_info.addr_format = CDROM_LBA;
@@ -100,7 +100,7 @@ int hfs_mdb_get(struct super_block *sb)
 
         HFS_SB(sb)->alloc_blksz = size = be32_to_cpu(mdb->drAlBlkSiz);
         if (!size || (size & (HFS_SECTOR_SIZE - 1))) {
-                hfs_warn("hfs_fs: bad allocation block size %d\n", size);
+                printk(KERN_ERR "hfs: bad allocation block size %d\n", size);
                 goto out_bh;
         }
 
@@ -117,7 +117,7 @@ int hfs_mdb_get(struct super_block *sb)
                 size >>= 1;
         brelse(bh);
         if (!sb_set_blocksize(sb, size)) {
-                printk("hfs_fs: unable to set blocksize to %u\n", size);
+                printk(KERN_ERR "hfs: unable to set blocksize to %u\n", size);
                 goto out;
         }
 
@@ -161,8 +161,8 @@ int hfs_mdb_get(struct super_block *sb)
         }
 
         if (!HFS_SB(sb)->alt_mdb) {
-                hfs_warn("hfs_fs: unable to locate alternate MDB\n");
-                hfs_warn("hfs_fs: continuing without an alternate MDB\n");
+                printk(KERN_WARNING "hfs: unable to locate alternate MDB\n");
+                printk(KERN_WARNING "hfs: continuing without an alternate MDB\n");
         }
 
         HFS_SB(sb)->bitmap = (__be32 *)__get_free_pages(GFP_KERNEL, PAGE_SIZE < 8192 ? 1 : 0);
@@ -177,7 +177,7 @@ int hfs_mdb_get(struct super_block *sb)
         while (size) {
                 bh = sb_bread(sb, off >> sb->s_blocksize_bits);
                 if (!bh) {
-                        hfs_warn("hfs_fs: unable to read volume bitmap\n");
+                        printk(KERN_ERR "hfs: unable to read volume bitmap\n");
                         goto out;
                 }
                 off2 = off & (sb->s_blocksize - 1);
@@ -191,23 +191,23 @@ int hfs_mdb_get(struct super_block *sb)
 
         HFS_SB(sb)->ext_tree = hfs_btree_open(sb, HFS_EXT_CNID, hfs_ext_keycmp);
         if (!HFS_SB(sb)->ext_tree) {
-                hfs_warn("hfs_fs: unable to open extent tree\n");
+                printk(KERN_ERR "hfs: unable to open extent tree\n");
                 goto out;
         }
         HFS_SB(sb)->cat_tree = hfs_btree_open(sb, HFS_CAT_CNID, hfs_cat_keycmp);
         if (!HFS_SB(sb)->cat_tree) {
-                hfs_warn("hfs_fs: unable to open catalog tree\n");
+                printk(KERN_ERR "hfs: unable to open catalog tree\n");
                 goto out;
         }
 
         attrib = mdb->drAtrb;
         if (!(attrib & cpu_to_be16(HFS_SB_ATTRIB_UNMNT))) {
-                hfs_warn("HFS-fs warning: Filesystem was not cleanly unmounted, "
+                printk(KERN_WARNING "hfs: filesystem was not cleanly unmounted, "
                          "running fsck.hfs is recommended.  mounting read-only.\n");
                 sb->s_flags |= MS_RDONLY;
         }
         if ((attrib & cpu_to_be16(HFS_SB_ATTRIB_SLOCK))) {
-                hfs_warn("HFS-fs: Filesystem is marked locked, mounting read-only.\n");
+                printk(KERN_WARNING "hfs: filesystem is marked locked, mounting read-only.\n");
                 sb->s_flags |= MS_RDONLY;
         }
         if (!(sb->s_flags & MS_RDONLY)) {
@@ -303,7 +303,7 @@ void hfs_mdb_commit(struct super_block *sb)
                 while (size) {
                         bh = sb_bread(sb, block);
                         if (!bh) {
-                                hfs_warn("hfs_fs: unable to read volume bitmap\n");
+                                printk(KERN_ERR "hfs: unable to read volume bitmap\n");
                                 break;
                         }
                         len = min((int)sb->s_blocksize - off, size);
diff --git a/fs/hfs/super.c b/fs/hfs/super.c
index c5074aeafcae..1181d116117d 100644
--- a/fs/hfs/super.c
+++ b/fs/hfs/super.c
@@ -101,12 +101,12 @@ static int hfs_remount(struct super_block *sb, int *flags, char *data)
                 return 0;
         if (!(*flags & MS_RDONLY)) {
                 if (!(HFS_SB(sb)->mdb->drAtrb & cpu_to_be16(HFS_SB_ATTRIB_UNMNT))) {
-                        printk("HFS-fs warning: Filesystem was not cleanly unmounted, "
+                        printk(KERN_WARNING "hfs: filesystem was not cleanly unmounted, "
                                "running fsck.hfs is recommended.  leaving read-only.\n");
                         sb->s_flags |= MS_RDONLY;
                         *flags |= MS_RDONLY;
                 } else if (HFS_SB(sb)->mdb->drAtrb & cpu_to_be16(HFS_SB_ATTRIB_SLOCK)) {
-                        printk("HFS-fs: Filesystem is marked locked, leaving read-only.\n");
+                        printk(KERN_WARNING "hfs: filesystem is marked locked, leaving read-only.\n");
                         sb->s_flags |= MS_RDONLY;
                         *flags |= MS_RDONLY;
                 }
@@ -229,21 +229,21 @@ static int parse_options(char *options, struct hfs_sb_info *hsb)
                 switch (token) {
                 case opt_uid:
                         if (match_int(&args[0], &tmp)) {
-                                printk("HFS: uid requires an argument\n");
+                                printk(KERN_ERR "hfs: uid requires an argument\n");
                                 return 0;
                         }
                         hsb->s_uid = (uid_t)tmp;
                         break;
                 case opt_gid:
                         if (match_int(&args[0], &tmp)) {
-                                printk("HFS: gid requires an argument\n");
+                                printk(KERN_ERR "hfs: gid requires an argument\n");
                                 return 0;
                         }
                         hsb->s_gid = (gid_t)tmp;
                         break;
                 case opt_umask:
                         if (match_octal(&args[0], &tmp)) {
-                                printk("HFS: umask requires a value\n");
+                                printk(KERN_ERR "hfs: umask requires a value\n");
                                 return 0;
                         }
                         hsb->s_file_umask = (umode_t)tmp;
@@ -251,39 +251,39 @@ static int parse_options(char *options, struct hfs_sb_info *hsb)
                         break;
                 case opt_file_umask:
                         if (match_octal(&args[0], &tmp)) {
-                                printk("HFS: file_umask requires a value\n");
+                                printk(KERN_ERR "hfs: file_umask requires a value\n");
                                 return 0;
                         }
                         hsb->s_file_umask = (umode_t)tmp;
                         break;
                 case opt_dir_umask:
                         if (match_octal(&args[0], &tmp)) {
-                                printk("HFS: dir_umask requires a value\n");
+                                printk(KERN_ERR "hfs: dir_umask requires a value\n");
                                 return 0;
                         }
                         hsb->s_dir_umask = (umode_t)tmp;
                         break;
                 case opt_part:
                         if (match_int(&args[0], &hsb->part)) {
-                                printk("HFS: part requires an argument\n");
+                                printk(KERN_ERR "hfs: part requires an argument\n");
                                 return 0;
                         }
                         break;
                 case opt_session:
                         if (match_int(&args[0], &hsb->session)) {
-                                printk("HFS: session requires an argument\n");
+                                printk(KERN_ERR "hfs: session requires an argument\n");
                                 return 0;
                         }
                         break;
                 case opt_type:
                         if (match_fourchar(&args[0], &hsb->s_type)) {
-                                printk("HFS+-fs: type requires a 4 character value\n");
+                                printk(KERN_ERR "hfs: type requires a 4 character value\n");
                                 return 0;
                         }
                         break;
                 case opt_creator:
                         if (match_fourchar(&args[0], &hsb->s_creator)) {
-                                printk("HFS+-fs: creator requires a 4 character value\n");
+                                printk(KERN_ERR "hfs: creator requires a 4 character value\n");
                                 return 0;
                         }
                         break;
@@ -292,13 +292,13 @@ static int parse_options(char *options, struct hfs_sb_info *hsb)
                         break;
                 case opt_codepage:
                         if (hsb->nls_disk) {
-                                printk("HFS+-fs: unable to change codepage\n");
+                                printk(KERN_ERR "hfs: unable to change codepage\n");
                                 return 0;
                         }
                         p = match_strdup(&args[0]);
                         hsb->nls_disk = load_nls(p);
                         if (!hsb->nls_disk) {
-                                printk("HFS+-fs: unable to load codepage \"%s\"\n", p);
+                                printk(KERN_ERR "hfs: unable to load codepage \"%s\"\n", p);
                                 kfree(p);
                                 return 0;
                         }
@@ -306,13 +306,13 @@ static int parse_options(char *options, struct hfs_sb_info *hsb)
                         break;
                 case opt_iocharset:
                         if (hsb->nls_io) {
-                                printk("HFS: unable to change iocharset\n");
+                                printk(KERN_ERR "hfs: unable to change iocharset\n");
                                 return 0;
                         }
                         p = match_strdup(&args[0]);
                         hsb->nls_io = load_nls(p);
                         if (!hsb->nls_io) {
-                                printk("HFS: unable to load iocharset \"%s\"\n", p);
+                                printk(KERN_ERR "hfs: unable to load iocharset \"%s\"\n", p);
                                 kfree(p);
                                 return 0;
                         }
@@ -326,7 +326,7 @@ static int parse_options(char *options, struct hfs_sb_info *hsb)
         if (hsb->nls_disk && !hsb->nls_io) {
                 hsb->nls_io = load_nls_default();
                 if (!hsb->nls_io) {
-                        printk("HFS: unable to load default iocharset\n");
+                        printk(KERN_ERR "hfs: unable to load default iocharset\n");
                         return 0;
                 }
         }
@@ -364,7 +364,7 @@ static int hfs_fill_super(struct super_block *sb, void *data, int silent)
 
         res = -EINVAL;
         if (!parse_options((char *)data, sbi)) {
-                hfs_warn("hfs_fs: unable to parse mount options.\n");
+                printk(KERN_ERR "hfs: unable to parse mount options.\n");
                 goto bail;
         }
 
@@ -375,7 +375,7 @@ static int hfs_fill_super(struct super_block *sb, void *data, int silent)
         res = hfs_mdb_get(sb);
         if (res) {
                 if (!silent)
-                        hfs_warn("VFS: Can't find a HFS filesystem on dev %s.\n",
+                        printk(KERN_WARNING "hfs: can't find a HFS filesystem on dev %s.\n",
                                 hfs_mdb_name(sb));
                 res = -EINVAL;
                 goto bail;
@@ -407,7 +407,7 @@ static int hfs_fill_super(struct super_block *sb, void *data, int silent)
 bail_iput:
         iput(root_inode);
 bail_no_root:
-        hfs_warn("hfs_fs: get root inode failed.\n");
+        printk(KERN_ERR "hfs: get root inode failed.\n");
 bail:
         hfs_mdb_put(sb);
         return res;
@@ -454,7 +454,7 @@ static void __exit exit_hfs_fs(void)
 {
         unregister_filesystem(&hfs_fs_type);
         if (kmem_cache_destroy(hfs_inode_cachep))
-                printk(KERN_INFO "hfs_inode_cache: not all structures were freed\n");
+                printk(KERN_ERR "hfs_inode_cache: not all structures were freed\n");
 }
 
 module_init(init_hfs_fs)
diff --git a/fs/hfsplus/bfind.c b/fs/hfsplus/bfind.c
index 257cdde0514b..5007a41f1be9 100644
--- a/fs/hfsplus/bfind.c
+++ b/fs/hfsplus/bfind.c
@@ -64,7 +64,6 @@ int __hfs_brec_find(struct hfs_bnode *bnode, struct hfs_find_data *fd)
                 else
                         e = rec - 1;
         } while (b <= e);
-        //printk("%d: %d,%d,%d\n", bnode->this, b, e, rec);
         if (rec != e && e >= 0) {
                 len = hfs_brec_lenoff(bnode, e, &off);
                 keylen = hfs_brec_keylen(bnode, e);
@@ -127,7 +126,7 @@ int hfs_brec_find(struct hfs_find_data *fd)
         return res;
 
 invalid:
-        printk("HFS+-fs: inconsistency in B*Tree (%d,%d,%d,%u,%u)\n",
+        printk(KERN_ERR "hfs: inconsistency in B*Tree (%d,%d,%d,%u,%u)\n",
                 height, bnode->height, bnode->type, nidx, parent);
         res = -EIO;
 release:
diff --git a/fs/hfsplus/bnode.c b/fs/hfsplus/bnode.c
index 930cd9212de8..8f07e8fbd03d 100644
--- a/fs/hfsplus/bnode.c
+++ b/fs/hfsplus/bnode.c
@@ -358,7 +358,7 @@ void hfs_bnode_unlink(struct hfs_bnode *node)
 
         // move down?
         if (!node->prev && !node->next) {
-                printk("hfs_btree_del_level\n");
+                printk(KERN_DEBUG "hfs_btree_del_level\n");
         }
         if (!node->parent) {
                 tree->root = 0;
@@ -379,7 +379,7 @@ struct hfs_bnode *hfs_bnode_findhash(struct hfs_btree *tree, u32 cnid)
         struct hfs_bnode *node;
 
         if (cnid >= tree->node_count) {
-                printk("HFS+-fs: request for non-existent node %d in B*Tree\n", cnid);
+                printk(KERN_ERR "hfs: request for non-existent node %d in B*Tree\n", cnid);
                 return NULL;
         }
 
@@ -402,7 +402,7 @@ static struct hfs_bnode *__hfs_bnode_create(struct hfs_btree *tree, u32 cnid)
         loff_t off;
 
         if (cnid >= tree->node_count) {
-                printk("HFS+-fs: request for non-existent node %d in B*Tree\n", cnid);
+                printk(KERN_ERR "hfs: request for non-existent node %d in B*Tree\n", cnid);
                 return NULL;
         }
 
@@ -576,8 +576,9 @@ struct hfs_bnode *hfs_bnode_create(struct hfs_btree *tree, u32 num)
         node = hfs_bnode_findhash(tree, num);
         spin_unlock(&tree->hash_lock);
         if (node) {
-                printk("new node %u already hashed?\n", num);
-                BUG();
+                printk(KERN_CRIT "new node %u already hashed?\n", num);
+                WARN_ON(1);
+                return node;
         }
         node = __hfs_bnode_create(tree, num);
         if (!node)
diff --git a/fs/hfsplus/brec.c b/fs/hfsplus/brec.c
index 0ccef2ab790c..c88e5d72a402 100644
--- a/fs/hfsplus/brec.c
+++ b/fs/hfsplus/brec.c
@@ -360,7 +360,7 @@ again:
                 end_off = hfs_bnode_read_u16(parent, end_rec_off);
                 if (end_rec_off - end_off < diff) {
 
-                        printk("splitting index node...\n");
+                        printk(KERN_DEBUG "hfs: splitting index node...\n");
                         fd->bnode = parent;
                         new_node = hfs_bnode_split(fd);
                         if (IS_ERR(new_node))
diff --git a/fs/hfsplus/btree.c b/fs/hfsplus/btree.c
index 44326aa2bd34..a67edfa34e9e 100644
--- a/fs/hfsplus/btree.c
+++ b/fs/hfsplus/btree.c
@@ -31,17 +31,8 @@ struct hfs_btree *hfs_btree_open(struct super_block *sb, u32 id)
 
         init_MUTEX(&tree->tree_lock);
         spin_lock_init(&tree->hash_lock);
-        /* Set the correct compare function */
         tree->sb = sb;
         tree->cnid = id;
-        if (id == HFSPLUS_EXT_CNID) {
-                tree->keycmp = hfsplus_ext_cmp_key;
-        } else if (id == HFSPLUS_CAT_CNID) {
-                tree->keycmp = hfsplus_cat_cmp_key;
-        } else {
-                printk("HFS+-fs: unknown B*Tree requested\n");
-                goto free_tree;
-        }
         tree->inode = iget(sb, id);
         if (!tree->inode)
                 goto free_tree;
@@ -64,6 +55,20 @@ struct hfs_btree *hfs_btree_open(struct super_block *sb, u32 id)
         tree->max_key_len = be16_to_cpu(head->max_key_len);
         tree->depth = be16_to_cpu(head->depth);
 
+        /* Set the correct compare function */
+        if (id == HFSPLUS_EXT_CNID) {
+                tree->keycmp = hfsplus_ext_cmp_key;
+        } else if (id == HFSPLUS_CAT_CNID) {
+                if ((HFSPLUS_SB(sb).flags & HFSPLUS_SB_HFSX) &&
+                    (head->key_type == HFSPLUS_KEY_BINARY))
+                        tree->keycmp = hfsplus_cat_bin_cmp_key;
+                else
+                        tree->keycmp = hfsplus_cat_case_cmp_key;
+        } else {
+                printk(KERN_ERR "hfs: unknown B*Tree requested\n");
+                goto fail_page;
+        }
+
         size = tree->node_size;
         if (!size || size & (size - 1))
                 goto fail_page;
@@ -99,7 +104,7 @@ void hfs_btree_close(struct hfs_btree *tree)
                 while ((node = tree->node_hash[i])) {
                         tree->node_hash[i] = node->next_hash;
                         if (atomic_read(&node->refcnt))
-                                printk("HFS+: node %d:%d still has %d user(s)!\n",
+                                printk(KERN_CRIT "hfs: node %d:%d still has %d user(s)!\n",
                                         node->tree->cnid, node->this, atomic_read(&node->refcnt));
                         hfs_bnode_free(node);
                         tree->node_hash_cnt--;
@@ -223,10 +228,6 @@ struct hfs_bnode *hfs_bmap_alloc(struct hfs_btree *tree)
                                                 tree->free_nodes--;
                                                 mark_inode_dirty(tree->inode);
                                                 hfs_bnode_put(node);
-                                                if (!idx) {
-                                                        printk("unexpected idx %u (%u)\n", idx, node->this);
-                                                        BUG();
-                                                }
                                                 return hfs_bnode_create(tree, idx);
                                         }
                                 }
@@ -242,7 +243,7 @@ struct hfs_bnode *hfs_bmap_alloc(struct hfs_btree *tree)
                 kunmap(*pagep);
                 nidx = node->next;
                 if (!nidx) {
-                        printk("create new bmap node...\n");
+                        printk(KERN_DEBUG "hfs: create new bmap node...\n");
                         next_node = hfs_bmap_new_bmap(node, idx);
                 } else
                         next_node = hfs_bnode_find(tree, nidx);
@@ -284,7 +285,7 @@ void hfs_bmap_free(struct hfs_bnode *node)
                 hfs_bnode_put(node);
                 if (!i) {
                         /* panic */;
-                        printk("HFS: unable to free bnode %u. bmap not found!\n", node->this);
+                        printk(KERN_CRIT "hfs: unable to free bnode %u. bmap not found!\n", node->this);
                         return;
                 }
                 node = hfs_bnode_find(tree, i);
@@ -292,7 +293,7 @@ void hfs_bmap_free(struct hfs_bnode *node)
                         return;
                 if (node->type != HFS_NODE_MAP) {
                         /* panic */;
-                        printk("HFS: invalid bmap found! (%u,%d)\n", node->this, node->type);
+                        printk(KERN_CRIT "hfs: invalid bmap found! (%u,%d)\n", node->this, node->type);
                         hfs_bnode_put(node);
                         return;
                 }
@@ -305,7 +306,7 @@ void hfs_bmap_free(struct hfs_bnode *node)
         m = 1 << (~nidx & 7);
         byte = data[off];
         if (!(byte & m)) {
-                printk("HFS: trying to free free bnode %u(%d)\n", node->this, node->type);
+                printk(KERN_CRIT "hfs: trying to free free bnode %u(%d)\n", node->this, node->type);
                 kunmap(page);
                 hfs_bnode_put(node);
                 return;
diff --git a/fs/hfsplus/catalog.c b/fs/hfsplus/catalog.c
index 94712790c8b3..f2d7c49ce759 100644
--- a/fs/hfsplus/catalog.c
+++ b/fs/hfsplus/catalog.c
@@ -13,7 +13,8 @@
 #include "hfsplus_fs.h"
 #include "hfsplus_raw.h"
 
-int hfsplus_cat_cmp_key(hfsplus_btree_key *k1, hfsplus_btree_key *k2)
+int hfsplus_cat_case_cmp_key(const hfsplus_btree_key *k1,
+                             const hfsplus_btree_key *k2)
 {
         __be32 k1p, k2p;
 
@@ -22,7 +23,20 @@ int hfsplus_cat_cmp_key(hfsplus_btree_key *k1, hfsplus_btree_key *k2)
         if (k1p != k2p)
                 return be32_to_cpu(k1p) < be32_to_cpu(k2p) ? -1 : 1;
 
-        return hfsplus_unistrcmp(&k1->cat.name, &k2->cat.name);
+        return hfsplus_strcasecmp(&k1->cat.name, &k2->cat.name);
+}
+
+int hfsplus_cat_bin_cmp_key(const hfsplus_btree_key *k1,
+                            const hfsplus_btree_key *k2)
+{
+        __be32 k1p, k2p;
+
+        k1p = k1->cat.parent;
+        k2p = k2->cat.parent;
+        if (k1p != k2p)
+                return be32_to_cpu(k1p) < be32_to_cpu(k2p) ? -1 : 1;
+
+        return hfsplus_strcmp(&k1->cat.name, &k2->cat.name);
 }
 
 void hfsplus_cat_build_key(struct super_block *sb, hfsplus_btree_key *key,
@@ -80,8 +94,11 @@ static int hfsplus_cat_build_record(hfsplus_cat_entry *entry, u32 cnid, struct i
                 memset(folder, 0, sizeof(*folder));
                 folder->type = cpu_to_be16(HFSPLUS_FOLDER);
                 folder->id = cpu_to_be32(inode->i_ino);
-                folder->create_date = folder->content_mod_date =
-                        folder->attribute_mod_date = folder->access_date = hfsp_now2mt();
+                HFSPLUS_I(inode).create_date =
+                        folder->create_date =
+                        folder->content_mod_date =
+                        folder->attribute_mod_date =
+                        folder->access_date = hfsp_now2mt();
                 hfsplus_set_perms(inode, &folder->permissions);
                 if (inode == HFSPLUS_SB(inode->i_sb).hidden_dir)
                         /* invisible and namelocked */
@@ -95,18 +112,27 @@ static int hfsplus_cat_build_record(hfsplus_cat_entry *entry, u32 cnid, struct i
                 file->type = cpu_to_be16(HFSPLUS_FILE);
                 file->flags = cpu_to_be16(HFSPLUS_FILE_THREAD_EXISTS);
                 file->id = cpu_to_be32(cnid);
-                file->create_date = file->content_mod_date =
-                        file->attribute_mod_date = file->access_date = hfsp_now2mt();
+                HFSPLUS_I(inode).create_date =
+                        file->create_date =
+                        file->content_mod_date =
+                        file->attribute_mod_date =
+                        file->access_date = hfsp_now2mt();
                 if (cnid == inode->i_ino) {
                         hfsplus_set_perms(inode, &file->permissions);
-                        file->user_info.fdType = cpu_to_be32(HFSPLUS_SB(inode->i_sb).type);
-                        file->user_info.fdCreator = cpu_to_be32(HFSPLUS_SB(inode->i_sb).creator);
+                        if (S_ISLNK(inode->i_mode)) {
+                                file->user_info.fdType = cpu_to_be32(HFSP_SYMLINK_TYPE);
+                                file->user_info.fdCreator = cpu_to_be32(HFSP_SYMLINK_CREATOR);
+                        } else {
+                                file->user_info.fdType = cpu_to_be32(HFSPLUS_SB(inode->i_sb).type);
+                                file->user_info.fdCreator = cpu_to_be32(HFSPLUS_SB(inode->i_sb).creator);
+                        }
                         if ((file->permissions.rootflags | file->permissions.userflags) & HFSPLUS_FLG_IMMUTABLE)
                                 file->flags |= cpu_to_be16(HFSPLUS_FILE_LOCKED);
                 } else {
                         file->user_info.fdType = cpu_to_be32(HFSP_HARDLINK_TYPE);
                         file->user_info.fdCreator = cpu_to_be32(HFSP_HFSPLUS_CREATOR);
                         file->user_info.fdFlags = cpu_to_be16(0x100);
+                        file->create_date = HFSPLUS_I(HFSPLUS_SB(inode->i_sb).hidden_dir).create_date;
                         file->permissions.dev = cpu_to_be32(HFSPLUS_I(inode).dev);
                 }
                 return sizeof(*file);
@@ -139,7 +165,7 @@ int hfsplus_find_cat(struct super_block *sb, u32 cnid,
 
         type = be16_to_cpu(tmp.type);
         if (type != HFSPLUS_FOLDER_THREAD && type != HFSPLUS_FILE_THREAD) {
-                printk("HFS+-fs: Found bad thread record in catalog\n");
+                printk(KERN_ERR "hfs: found bad thread record in catalog\n");
                 return -EIO;
         }
 
diff --git a/fs/hfsplus/dir.c b/fs/hfsplus/dir.c
index 50c8f44b6c66..01a6fe3a395c 100644
--- a/fs/hfsplus/dir.c
+++ b/fs/hfsplus/dir.c
@@ -66,25 +66,32 @@ again:
                 }
                 cnid = be32_to_cpu(entry.file.id);
                 if (entry.file.user_info.fdType == cpu_to_be32(HFSP_HARDLINK_TYPE) &&
-                    entry.file.user_info.fdCreator == cpu_to_be32(HFSP_HFSPLUS_CREATOR)) {
+                    entry.file.user_info.fdCreator == cpu_to_be32(HFSP_HFSPLUS_CREATOR) &&
+                    (entry.file.create_date == HFSPLUS_I(HFSPLUS_SB(sb).hidden_dir).create_date ||
+                     entry.file.create_date == HFSPLUS_I(sb->s_root->d_inode).create_date) &&
+                    HFSPLUS_SB(sb).hidden_dir) {
                         struct qstr str;
                         char name[32];
 
                         if (dentry->d_fsdata) {
-                                err = -ENOENT;
-                                inode = NULL;
-                                goto out;
+                                /*
+                                 * We found a link pointing to another link,
+                                 * so ignore it and treat it as regular file.
+                                 */
+                                cnid = (unsigned long)dentry->d_fsdata;
+                                linkid = 0;
+                        } else {
+                                dentry->d_fsdata = (void *)(unsigned long)cnid;
+                                linkid = be32_to_cpu(entry.file.permissions.dev);
+                                str.len = sprintf(name, "iNode%d", linkid);
+                                str.name = name;
+                                hfsplus_cat_build_key(sb, fd.search_key, HFSPLUS_SB(sb).hidden_dir->i_ino, &str);
+                                goto again;
                         }
-                        dentry->d_fsdata = (void *)(unsigned long)cnid;
-                        linkid = be32_to_cpu(entry.file.permissions.dev);
-                        str.len = sprintf(name, "iNode%d", linkid);
-                        str.name = name;
-                        hfsplus_cat_build_key(sb, fd.search_key, HFSPLUS_SB(sb).hidden_dir->i_ino, &str);
-                        goto again;
                 } else if (!dentry->d_fsdata)
                         dentry->d_fsdata = (void *)(unsigned long)cnid;
         } else {
-                printk("HFS+-fs: Illegal catalog entry type in lookup\n");
+                printk(KERN_ERR "hfs: invalid catalog entry type in lookup\n");
                 err = -EIO;
                 goto fail;
         }
@@ -132,12 +139,12 @@ static int hfsplus_readdir(struct file *filp, void *dirent, filldir_t filldir)
         case 1:
                 hfs_bnode_read(fd.bnode, &entry, fd.entryoffset, fd.entrylength);
                 if (be16_to_cpu(entry.type) != HFSPLUS_FOLDER_THREAD) {
-                        printk("HFS+-fs: bad catalog folder thread\n");
+                        printk(KERN_ERR "hfs: bad catalog folder thread\n");
                         err = -EIO;
                         goto out;
                 }
                 if (fd.entrylength < HFSPLUS_MIN_THREAD_SZ) {
-                        printk("HFS+-fs: truncated catalog thread\n");
+                        printk(KERN_ERR "hfs: truncated catalog thread\n");
                         err = -EIO;
                         goto out;
                 }
@@ -156,7 +163,7 @@ static int hfsplus_readdir(struct file *filp, void *dirent, filldir_t filldir)
 
         for (;;) {
                 if (be32_to_cpu(fd.key->cat.parent) != inode->i_ino) {
-                        printk("HFS+-fs: walked past end of dir\n");
+                        printk(KERN_ERR "hfs: walked past end of dir\n");
                         err = -EIO;
                         goto out;
                 }
@@ -168,7 +175,7 @@ static int hfsplus_readdir(struct file *filp, void *dirent, filldir_t filldir)
                         goto out;
                 if (type == HFSPLUS_FOLDER) {
                         if (fd.entrylength < sizeof(struct hfsplus_cat_folder)) {
-                                printk("HFS+-fs: small dir entry\n");
+                                printk(KERN_ERR "hfs: small dir entry\n");
                                 err = -EIO;
                                 goto out;
                         }
@@ -180,7 +187,7 @@ static int hfsplus_readdir(struct file *filp, void *dirent, filldir_t filldir)
                                 break;
                 } else if (type == HFSPLUS_FILE) {
                         if (fd.entrylength < sizeof(struct hfsplus_cat_file)) {
-                                printk("HFS+-fs: small file entry\n");
+                                printk(KERN_ERR "hfs: small file entry\n");
                                 err = -EIO;
                                 goto out;
                         }
@@ -188,7 +195,7 @@ static int hfsplus_readdir(struct file *filp, void *dirent, filldir_t filldir)
                                     be32_to_cpu(entry.file.id), DT_REG))
                                 break;
                 } else {
-                        printk("HFS+-fs: bad catalog entry type\n");
+                        printk(KERN_ERR "hfs: bad catalog entry type\n");
                         err = -EIO;
                         goto out;
                 }
@@ -330,7 +337,8 @@ static int hfsplus_unlink(struct inode *dir, struct dentry *dentry)
         if (res)
                 return res;
 
-        inode->i_nlink--;
+        if (inode->i_nlink > 0)
+                inode->i_nlink--;
         hfsplus_delete_inode(inode);
         if (inode->i_ino != cnid && !inode->i_nlink) {
                 if (!atomic_read(&HFSPLUS_I(inode).opencnt)) {
@@ -339,7 +347,8 @@ static int hfsplus_unlink(struct inode *dir, struct dentry *dentry)
                                 hfsplus_delete_inode(inode);
                 } else
                         inode->i_flags |= S_DEAD;
-        }
+        } else
+                inode->i_nlink = 0;
         inode->i_ctime = CURRENT_TIME_SEC;
         mark_inode_dirty(inode);
 
diff --git a/fs/hfsplus/extents.c b/fs/hfsplus/extents.c
index e3ff56a03011..1a7480089e82 100644
--- a/fs/hfsplus/extents.c
+++ b/fs/hfsplus/extents.c
@@ -16,7 +16,8 @@
 #include "hfsplus_raw.h"
 
 /* Compare two extents keys, returns 0 on same, pos/neg for difference */
-int hfsplus_ext_cmp_key(hfsplus_btree_key *k1, hfsplus_btree_key *k2)
+int hfsplus_ext_cmp_key(const hfsplus_btree_key *k1,
+                        const hfsplus_btree_key *k2)
 {
         __be32 k1id, k2id;
         __be32 k1s, k2s;
@@ -349,10 +350,9 @@ int hfsplus_file_extend(struct inode *inode)
 
         if (HFSPLUS_SB(sb).alloc_file->i_size * 8 < HFSPLUS_SB(sb).total_blocks - HFSPLUS_SB(sb).free_blocks + 8) {
                 // extend alloc file
-                printk("extend alloc file! (%Lu,%u,%u)\n", HFSPLUS_SB(sb).alloc_file->i_size * 8,
+                printk(KERN_ERR "hfs: extend alloc file! (%Lu,%u,%u)\n", HFSPLUS_SB(sb).alloc_file->i_size * 8,
                         HFSPLUS_SB(sb).total_blocks, HFSPLUS_SB(sb).free_blocks);
                 return -ENOSPC;
-                //BUG();
         }
 
         down(&HFSPLUS_I(inode).extents_lock);
diff --git a/fs/hfsplus/hfsplus_fs.h b/fs/hfsplus/hfsplus_fs.h
index 0fa1ab6250bf..7ae393637a0c 100644
--- a/fs/hfsplus/hfsplus_fs.h
+++ b/fs/hfsplus/hfsplus_fs.h
@@ -36,7 +36,7 @@
 #define HFSPLUS_TYPE_DATA 0x00
 #define HFSPLUS_TYPE_RSRC 0xFF
 
-typedef int (*btree_keycmp)(hfsplus_btree_key *, hfsplus_btree_key *);
+typedef int (*btree_keycmp)(const hfsplus_btree_key *, const hfsplus_btree_key *);
 
 #define NODE_HASH_SIZE  256
 
@@ -149,6 +149,7 @@ struct hfsplus_sb_info {
 #define HFSPLUS_SB_WRITEBACKUP  0x0001
 #define HFSPLUS_SB_NODECOMPOSE  0x0002
 #define HFSPLUS_SB_FORCE        0x0004
+#define HFSPLUS_SB_HFSX         0x0008
 
 
 struct hfsplus_inode_info {
@@ -165,6 +166,7 @@ struct hfsplus_inode_info {
         struct inode *rsrc_inode;
         unsigned long flags;
 
+        __be32 create_date;
         /* Device number in hfsplus_permissions in catalog */
         u32 dev;
         /* BSD system and user file flags */
@@ -303,7 +305,8 @@ int hfs_brec_read(struct hfs_find_data *, void *, int);
 int hfs_brec_goto(struct hfs_find_data *, int);
 
 /* catalog.c */
-int hfsplus_cat_cmp_key(hfsplus_btree_key *, hfsplus_btree_key *);
+int hfsplus_cat_case_cmp_key(const hfsplus_btree_key *, const hfsplus_btree_key *);
+int hfsplus_cat_bin_cmp_key(const hfsplus_btree_key *, const hfsplus_btree_key *);
 void hfsplus_cat_build_key(struct super_block *sb, hfsplus_btree_key *, u32, struct qstr *);
 int hfsplus_find_cat(struct super_block *, u32, struct hfs_find_data *);
 int hfsplus_create_cat(u32, struct inode *, struct qstr *, struct inode *);
@@ -312,7 +315,7 @@ int hfsplus_rename_cat(u32, struct inode *, struct qstr *,
                        struct inode *, struct qstr *);
 
 /* extents.c */
-int hfsplus_ext_cmp_key(hfsplus_btree_key *, hfsplus_btree_key *);
+int hfsplus_ext_cmp_key(const hfsplus_btree_key *, const hfsplus_btree_key *);
 void hfsplus_ext_write_extent(struct inode *);
 int hfsplus_get_block(struct inode *, sector_t, struct buffer_head *, int);
 int hfsplus_free_fork(struct super_block *, u32, struct hfsplus_fork_raw *, int);
@@ -350,7 +353,8 @@ extern u16 hfsplus_decompose_table[];
 extern u16 hfsplus_compose_table[];
 
 /* unicode.c */
-int hfsplus_unistrcmp(const struct hfsplus_unistr *, const struct hfsplus_unistr *);
+int hfsplus_strcasecmp(const struct hfsplus_unistr *, const struct hfsplus_unistr *);
+int hfsplus_strcmp(const struct hfsplus_unistr *, const struct hfsplus_unistr *);
 int hfsplus_uni2asc(struct super_block *, const struct hfsplus_unistr *, char *, int *);
 int hfsplus_asc2uni(struct super_block *, struct hfsplus_unistr *, const char *, int);
 
diff --git a/fs/hfsplus/hfsplus_raw.h b/fs/hfsplus/hfsplus_raw.h
index b4fbed633219..49205531a500 100644
--- a/fs/hfsplus/hfsplus_raw.h
+++ b/fs/hfsplus/hfsplus_raw.h
@@ -22,8 +22,10 @@
 #define HFSPLUS_SECTOR_SHIFT         9
 #define HFSPLUS_VOLHEAD_SECTOR       2
 #define HFSPLUS_VOLHEAD_SIG     0x482b
+#define HFSPLUS_VOLHEAD_SIGX    0x4858
 #define HFSPLUS_SUPER_MAGIC     0x482b
-#define HFSPLUS_CURRENT_VERSION      4
+#define HFSPLUS_MIN_VERSION          4
+#define HFSPLUS_CURRENT_VERSION      5
 
 #define HFSP_WRAP_MAGIC         0x4244
 #define HFSP_WRAP_ATTRIB_SLOCK  0x8000
@@ -41,6 +43,9 @@
 #define HFSP_HARDLINK_TYPE      0x686c6e6b      /* 'hlnk' */
 #define HFSP_HFSPLUS_CREATOR    0x6866732b      /* 'hfs+' */
 
+#define HFSP_SYMLINK_TYPE       0x736c6e6b      /* 'slnk' */
+#define HFSP_SYMLINK_CREATOR    0x72686170      /* 'rhap' */
+
 #define HFSP_MOUNT_VERSION      0x482b4c78      /* 'H+Lx' */
 
 /* Structures used on disk */
@@ -161,7 +166,7 @@ struct hfs_btree_header_rec {
         u16 reserved1;
         __be32 clump_size;
         u8 btree_type;
-        u8 reserved2;
+        u8 key_type;
         __be32 attributes;
         u32 reserved3[16];
 } __packed;
@@ -186,6 +191,10 @@ struct hfs_btree_header_rec {
 #define HFSPLUS_EXCH_CNID               15      /* ExchangeFiles temp id */
 #define HFSPLUS_FIRSTUSER_CNID          16      /* first available user id */
 
+/* btree key type */
+#define HFSPLUS_KEY_CASEFOLDING         0xCF    /* case-insensitive */
+#define HFSPLUS_KEY_BINARY              0xBC    /* case-sensitive */
+
 /* HFS+ catalog entry key */
 struct hfsplus_cat_key {
         __be16 key_len;
diff --git a/fs/hfsplus/inode.c b/fs/hfsplus/inode.c
index 7acff6c5464f..12ed2b7d046b 100644
--- a/fs/hfsplus/inode.c
+++ b/fs/hfsplus/inode.c
@@ -18,13 +18,11 @@
 
 static int hfsplus_readpage(struct file *file, struct page *page)
 {
-        //printk("readpage: %lu\n", page->index);
         return block_read_full_page(page, hfsplus_get_block);
 }
 
 static int hfsplus_writepage(struct page *page, struct writeback_control *wbc)
 {
-        //printk("writepage: %lu\n", page->index);
         return block_write_full_page(page, hfsplus_get_block, wbc);
 }
 
@@ -92,7 +90,6 @@ static int hfsplus_releasepage(struct page *page, gfp_t mask)
                 } while (--i && nidx < tree->node_count);
                 spin_unlock(&tree->hash_lock);
         }
-        //printk("releasepage: %lu,%x = %d\n", page->index, mask, res);
         return res ? try_to_free_buffers(page) : 0;
 }
 
@@ -434,7 +431,8 @@ int hfsplus_cat_read_inode(struct inode *inode, struct hfs_find_data *fd)
                 inode->i_size = 2 + be32_to_cpu(folder->valence);
                 inode->i_atime = hfsp_mt2ut(folder->access_date);
                 inode->i_mtime = hfsp_mt2ut(folder->content_mod_date);
-                inode->i_ctime = inode->i_mtime;
+                inode->i_ctime = hfsp_mt2ut(folder->attribute_mod_date);
+                HFSPLUS_I(inode).create_date = folder->create_date;
                 HFSPLUS_I(inode).fs_blocks = 0;
                 inode->i_op = &hfsplus_dir_inode_operations;
                 inode->i_fop = &hfsplus_dir_operations;
@@ -465,9 +463,10 @@ int hfsplus_cat_read_inode(struct inode *inode, struct hfs_find_data *fd)
                 }
                 inode->i_atime = hfsp_mt2ut(file->access_date);
                 inode->i_mtime = hfsp_mt2ut(file->content_mod_date);
-                inode->i_ctime = inode->i_mtime;
+                inode->i_ctime = hfsp_mt2ut(file->attribute_mod_date);
+                HFSPLUS_I(inode).create_date = file->create_date;
         } else {
-                printk("HFS+-fs: bad catalog entry used to create inode\n");
+                printk(KERN_ERR "hfs: bad catalog entry used to create inode\n");
                 res = -EIO;
         }
         return res;
diff --git a/fs/hfsplus/options.c b/fs/hfsplus/options.c
index 935dafba0078..dc64fac00831 100644
--- a/fs/hfsplus/options.c
+++ b/fs/hfsplus/options.c
@@ -83,58 +83,58 @@ int hfsplus_parse_options(char *input, struct hfsplus_sb_info *sbi)
                 switch (token) {
                 case opt_creator:
                         if (match_fourchar(&args[0], &sbi->creator)) {
-                                printk("HFS+-fs: creator requires a 4 character value\n");
+                                printk(KERN_ERR "hfs: creator requires a 4 character value\n");
                                 return 0;
                         }
                         break;
                 case opt_type:
                         if (match_fourchar(&args[0], &sbi->type)) {
-                                printk("HFS+-fs: type requires a 4 character value\n");
+                                printk(KERN_ERR "hfs: type requires a 4 character value\n");
                                 return 0;
                         }
                         break;
                 case opt_umask:
                         if (match_octal(&args[0], &tmp)) {
-                                printk("HFS+-fs: umask requires a value\n");
+                                printk(KERN_ERR "hfs: umask requires a value\n");
                                 return 0;
                         }
                         sbi->umask = (umode_t)tmp;
                         break;
                 case opt_uid:
                         if (match_int(&args[0], &tmp)) {
-                                printk("HFS+-fs: uid requires an argument\n");
+                                printk(KERN_ERR "hfs: uid requires an argument\n");
                                 return 0;
                         }
                         sbi->uid = (uid_t)tmp;
                         break;
                 case opt_gid:
                         if (match_int(&args[0], &tmp)) {
-                                printk("HFS+-fs: gid requires an argument\n");
+                                printk(KERN_ERR "hfs: gid requires an argument\n");
                                 return 0;
                         }
                         sbi->gid = (gid_t)tmp;
                         break;
                 case opt_part:
                         if (match_int(&args[0], &sbi->part)) {
-                                printk("HFS+-fs: part requires an argument\n");
+                                printk(KERN_ERR "hfs: part requires an argument\n");
                                 return 0;
                         }
                         break;
                 case opt_session:
                         if (match_int(&args[0], &sbi->session)) {
-                                printk("HFS+-fs: session requires an argument\n");
+                                printk(KERN_ERR "hfs: session requires an argument\n");
                                 return 0;
                         }
                         break;
                 case opt_nls:
                         if (sbi->nls) {
-                                printk("HFS+-fs: unable to change nls mapping\n");
+                                printk(KERN_ERR "hfs: unable to change nls mapping\n");
                                 return 0;
                         }
                         p = match_strdup(&args[0]);
                         sbi->nls = load_nls(p);
                         if (!sbi->nls) {
-                                printk("HFS+-fs: unable to load nls mapping \"%s\"\n", p);
+                                printk(KERN_ERR "hfs: unable to load nls mapping \"%s\"\n", p);
                                 kfree(p);
                                 return 0;
                         }
diff --git a/fs/hfsplus/super.c b/fs/hfsplus/super.c
index d791780def50..7843f792a4b7 100644
--- a/fs/hfsplus/super.c
+++ b/fs/hfsplus/super.c
@@ -169,7 +169,7 @@ static void hfsplus_write_super(struct super_block *sb)
                         block = HFSPLUS_SB(sb).blockoffset;
                         block += (HFSPLUS_SB(sb).sect_count - 2) >> (sb->s_blocksize_bits - 9);
                         offset = ((HFSPLUS_SB(sb).sect_count - 2) << 9) & (sb->s_blocksize - 1);
-                        printk("backup: %u,%u,%u,%u\n", HFSPLUS_SB(sb).blockoffset,
+                        printk(KERN_DEBUG "hfs: backup: %u,%u,%u,%u\n", HFSPLUS_SB(sb).blockoffset,
                                 HFSPLUS_SB(sb).sect_count, block, offset);
                         bh = sb_bread(sb, block);
                         if (bh) {
@@ -179,7 +179,7 @@ static void hfsplus_write_super(struct super_block *sb)
                                         mark_buffer_dirty(bh);
                                         brelse(bh);
                                 } else
-                                        printk("backup not found!\n");
+                                        printk(KERN_WARNING "hfs: backup not found!\n");
                         }
                 }
                 HFSPLUS_SB(sb).flags &= ~HFSPLUS_SB_WRITEBACKUP;
@@ -240,18 +240,18 @@ static int hfsplus_remount(struct super_block *sb, int *flags, char *data)
                         return -EINVAL;
 
                 if (!(vhdr->attributes & cpu_to_be32(HFSPLUS_VOL_UNMNT))) {
-                        printk("HFS+-fs warning: Filesystem was not cleanly unmounted, "
+                        printk(KERN_WARNING "hfs: filesystem was not cleanly unmounted, "
                                "running fsck.hfsplus is recommended.  leaving read-only.\n");
                         sb->s_flags |= MS_RDONLY;
                         *flags |= MS_RDONLY;
                 } else if (sbi.flags & HFSPLUS_SB_FORCE) {
                         /* nothing */
                 } else if (vhdr->attributes & cpu_to_be32(HFSPLUS_VOL_SOFTLOCK)) {
-                        printk("HFS+-fs: Filesystem is marked locked, leaving read-only.\n");
+                        printk(KERN_WARNING "hfs: filesystem is marked locked, leaving read-only.\n");
                         sb->s_flags |= MS_RDONLY;
                         *flags |= MS_RDONLY;
                 } else if (vhdr->attributes & cpu_to_be32(HFSPLUS_VOL_JOURNALED)) {
-                        printk("HFS+-fs: Filesystem is marked journaled, leaving read-only.\n");
+                        printk(KERN_WARNING "hfs: filesystem is marked journaled, leaving read-only.\n");
                         sb->s_flags |= MS_RDONLY;
                         *flags |= MS_RDONLY;
                 }
@@ -292,8 +292,7 @@ static int hfsplus_fill_super(struct super_block *sb, void *data, int silent)
         INIT_HLIST_HEAD(&sbi->rsrc_inodes);
         hfsplus_fill_defaults(sbi);
         if (!hfsplus_parse_options(data, sbi)) {
-                if (!silent)
-                        printk("HFS+-fs: unable to parse mount options\n");
+                printk(KERN_ERR "hfs: unable to parse mount options\n");
                 err = -EINVAL;
                 goto cleanup;
         }
@@ -302,7 +301,7 @@ static int hfsplus_fill_super(struct super_block *sb, void *data, int silent)
         nls = sbi->nls;
         sbi->nls = load_nls("utf8");
         if (!sbi->nls) {
-                printk("HFS+: unable to load nls for utf8\n");
+                printk(KERN_ERR "hfs: unable to load nls for utf8\n");
                 err = -EINVAL;
                 goto cleanup;
         }
@@ -310,17 +309,17 @@ static int hfsplus_fill_super(struct super_block *sb, void *data, int silent)
         /* Grab the volume header */
         if (hfsplus_read_wrapper(sb)) {
                 if (!silent)
-                        printk("HFS+-fs: unable to find HFS+ superblock\n");
+                        printk(KERN_WARNING "hfs: unable to find HFS+ superblock\n");
                 err = -EINVAL;
                 goto cleanup;
         }
         vhdr = HFSPLUS_SB(sb).s_vhdr;
 
         /* Copy parts of the volume header into the superblock */
-        sb->s_magic = be16_to_cpu(vhdr->signature);
-        if (be16_to_cpu(vhdr->version) != HFSPLUS_CURRENT_VERSION) {
-                if (!silent)
-                        printk("HFS+-fs: wrong filesystem version\n");
+        sb->s_magic = HFSPLUS_VOLHEAD_SIG;
+        if (be16_to_cpu(vhdr->version) < HFSPLUS_MIN_VERSION ||
+            be16_to_cpu(vhdr->version) > HFSPLUS_CURRENT_VERSION) {
+                printk(KERN_ERR "hfs: wrong filesystem version\n");
                 goto cleanup;
         }
         HFSPLUS_SB(sb).total_blocks = be32_to_cpu(vhdr->total_blocks);
@@ -341,20 +340,17 @@ static int hfsplus_fill_super(struct super_block *sb, void *data, int silent)
         sb->s_maxbytes = MAX_LFS_FILESIZE;
 
         if (!(vhdr->attributes & cpu_to_be32(HFSPLUS_VOL_UNMNT))) {
-                if (!silent)
-                        printk("HFS+-fs warning: Filesystem was not cleanly unmounted, "
-                               "running fsck.hfsplus is recommended.  mounting read-only.\n");
+                printk(KERN_WARNING "hfs: Filesystem was not cleanly unmounted, "
+                       "running fsck.hfsplus is recommended.  mounting read-only.\n");
                 sb->s_flags |= MS_RDONLY;
         } else if (sbi->flags & HFSPLUS_SB_FORCE) {
                 /* nothing */
         } else if (vhdr->attributes & cpu_to_be32(HFSPLUS_VOL_SOFTLOCK)) {
-                if (!silent)
-                        printk("HFS+-fs: Filesystem is marked locked, mounting read-only.\n");
+                printk(KERN_WARNING "hfs: Filesystem is marked locked, mounting read-only.\n");
                 sb->s_flags |= MS_RDONLY;
         } else if (vhdr->attributes & cpu_to_be32(HFSPLUS_VOL_JOURNALED)) {
-                if (!silent)
-                        printk("HFS+-fs: write access to a jounaled filesystem is not supported, "
-                               "use the force option at your own risk, mounting read-only.\n");
+                printk(KERN_WARNING "hfs: write access to a jounaled filesystem is not supported, "
+                       "use the force option at your own risk, mounting read-only.\n");
                 sb->s_flags |= MS_RDONLY;
         }
         sbi->flags &= ~HFSPLUS_SB_FORCE;
@@ -362,21 +358,18 @@ static int hfsplus_fill_super(struct super_block *sb, void *data, int silent)
         /* Load metadata objects (B*Trees) */
         HFSPLUS_SB(sb).ext_tree = hfs_btree_open(sb, HFSPLUS_EXT_CNID);
         if (!HFSPLUS_SB(sb).ext_tree) {
-                if (!silent)
-                        printk("HFS+-fs: failed to load extents file\n");
+                printk(KERN_ERR "hfs: failed to load extents file\n");
                 goto cleanup;
         }
         HFSPLUS_SB(sb).cat_tree = hfs_btree_open(sb, HFSPLUS_CAT_CNID);
         if (!HFSPLUS_SB(sb).cat_tree) {
-                if (!silent)
-                        printk("HFS+-fs: failed to load catalog file\n");
+                printk(KERN_ERR "hfs: failed to load catalog file\n");
                 goto cleanup;
         }
 
         HFSPLUS_SB(sb).alloc_file = iget(sb, HFSPLUS_ALLOC_CNID);
         if (!HFSPLUS_SB(sb).alloc_file) {
-                if (!silent)
-                        printk("HFS+-fs: failed to load allocation file\n");
+                printk(KERN_ERR "hfs: failed to load allocation file\n");
                 goto cleanup;
         }
 
@@ -384,8 +377,7 @@ static int hfsplus_fill_super(struct super_block *sb, void *data, int silent)
         root = iget(sb, HFSPLUS_ROOT_CNID);
         sb->s_root = d_alloc_root(root);
         if (!sb->s_root) {
-                if (!silent)
-                        printk("HFS+-fs: failed to load root directory\n");
+                printk(KERN_ERR "hfs: failed to load root directory\n");
                 iput(root);
                 goto cleanup;
         }
@@ -419,7 +411,7 @@ static int hfsplus_fill_super(struct super_block *sb, void *data, int silent)
         sync_dirty_buffer(HFSPLUS_SB(sb).s_vhbh);
 
         if (!HFSPLUS_SB(sb).hidden_dir) {
-                printk("HFS+: create hidden dir...\n");
+                printk(KERN_DEBUG "hfs: create hidden dir...\n");
                 HFSPLUS_SB(sb).hidden_dir = hfsplus_new_inode(sb, S_IFDIR);
                 hfsplus_create_cat(HFSPLUS_SB(sb).hidden_dir->i_ino, sb->s_root->d_inode,
                                    &str, HFSPLUS_SB(sb).hidden_dir);
@@ -499,7 +491,7 @@ static void __exit exit_hfsplus_fs(void)
 {
         unregister_filesystem(&hfsplus_fs_type);
         if (kmem_cache_destroy(hfsplus_inode_cachep))
-                printk(KERN_INFO "hfsplus_inode_cache: not all structures were freed\n");
+                printk(KERN_ERR "hfsplus_inode_cache: not all structures were freed\n");
 }
 
 module_init(init_hfsplus_fs)
diff --git a/fs/hfsplus/unicode.c b/fs/hfsplus/unicode.c
index 060c69048c3d..689c8bd721fb 100644
--- a/fs/hfsplus/unicode.c
+++ b/fs/hfsplus/unicode.c
@@ -28,7 +28,8 @@ static inline u16 case_fold(u16 c)
 }
 
 /* Compare unicode strings, return values like normal strcmp */
-int hfsplus_unistrcmp(const struct hfsplus_unistr *s1, const struct hfsplus_unistr *s2)
+int hfsplus_strcasecmp(const struct hfsplus_unistr *s1,
+                       const struct hfsplus_unistr *s2)
 {
         u16 len1, len2, c1, c2;
         const hfsplus_unichr *p1, *p2;
@@ -59,6 +60,33 @@ int hfsplus_unistrcmp(const struct hfsplus_unistr *s1, const struct hfsplus_unis
         }
 }
 
+/* Compare names as a sequence of 16-bit unsigned integers */
+int hfsplus_strcmp(const struct hfsplus_unistr *s1,
+                   const struct hfsplus_unistr *s2)
+{
+        u16 len1, len2, c1, c2;
+        const hfsplus_unichr *p1, *p2;
+        int len;
+
+        len1 = be16_to_cpu(s1->length);
+        len2 = be16_to_cpu(s2->length);
+        p1 = s1->unicode;
+        p2 = s2->unicode;
+
+        for (len = min(len1, len2); len > 0; len--) {
+                c1 = be16_to_cpu(*p1);
+                c2 = be16_to_cpu(*p2);
+                if (c1 != c2)
+                        return c1 < c2 ? -1 : 1;
+                p1++;
+                p2++;
+        }
+
+        return len1 < len2 ? -1 :
+               len1 > len2 ? 1 : 0;
+}
+
+
 #define Hangul_SBase    0xac00
 #define Hangul_LBase    0x1100
 #define Hangul_VBase    0x1161
diff --git a/fs/hfsplus/wrapper.c b/fs/hfsplus/wrapper.c
index 95455e839231..72cab78f0509 100644
--- a/fs/hfsplus/wrapper.c
+++ b/fs/hfsplus/wrapper.c
@@ -28,8 +28,11 @@ static int hfsplus_read_mdb(void *bufptr, struct hfsplus_wd *wd)
 {
         u32 extent;
         u16 attrib;
+        __be16 sig;
 
-        if (be16_to_cpu(*(__be16 *)(bufptr + HFSP_WRAPOFF_EMBEDSIG)) != HFSPLUS_VOLHEAD_SIG)
+        sig = *(__be16 *)(bufptr + HFSP_WRAPOFF_EMBEDSIG);
+        if (sig != cpu_to_be16(HFSPLUS_VOLHEAD_SIG) &&
+            sig != cpu_to_be16(HFSPLUS_VOLHEAD_SIGX))
                 return 0;
 
         attrib = be16_to_cpu(*(__be16 *)(bufptr + HFSP_WRAPOFF_ATTRIB));
@@ -70,7 +73,7 @@ static int hfsplus_get_last_session(struct super_block *sb,
                         *start = (sector_t)te.cdte_addr.lba << 2;
                         return 0;
                 }
-                printk(KERN_ERR "HFS: Invalid session number or type of track\n");
+                printk(KERN_ERR "hfs: invalid session number or type of track\n");
                 return -EINVAL;
         }
         ms_info.addr_format = CDROM_LBA;
@@ -114,6 +117,10 @@ int hfsplus_read_wrapper(struct super_block *sb)
                 }
                 if (vhdr->signature == cpu_to_be16(HFSPLUS_VOLHEAD_SIG))
                         break;
+                if (vhdr->signature == cpu_to_be16(HFSPLUS_VOLHEAD_SIGX)) {
+                        HFSPLUS_SB(sb).flags |= HFSPLUS_SB_HFSX;
+                        break;
+                }
                 brelse(bh);
 
                 /* check for a partition block
@@ -143,7 +150,7 @@ int hfsplus_read_wrapper(struct super_block *sb)
                 blocksize >>= 1;
 
         if (sb_set_blocksize(sb, blocksize) != blocksize) {
-                printk("HFS+: unable to blocksize to %u!\n", blocksize);
+                printk(KERN_ERR "hfs: unable to set blocksize to %u!\n", blocksize);
                 return -EINVAL;
         }
 
@@ -158,7 +165,9 @@ int hfsplus_read_wrapper(struct super_block *sb)
                 return -EIO;
 
         /* should still be the same... */
-        if (be16_to_cpu(vhdr->signature) != HFSPLUS_VOLHEAD_SIG)
+        if (vhdr->signature != (HFSPLUS_SB(sb).flags & HFSPLUS_SB_HFSX ?
+                                cpu_to_be16(HFSPLUS_VOLHEAD_SIGX) :
+                                cpu_to_be16(HFSPLUS_VOLHEAD_SIG)))
                 goto error;
         HFSPLUS_SB(sb).s_vhbh = bh;
         HFSPLUS_SB(sb).s_vhdr = vhdr;
diff --git a/fs/inotify.c b/fs/inotify.c
index 2fecb7af4a77..878ccca61213 100644
--- a/fs/inotify.c
+++ b/fs/inotify.c
@@ -33,6 +33,7 @@
 #include <linux/list.h>
 #include <linux/writeback.h>
 #include <linux/inotify.h>
+#include <linux/syscalls.h>
 
 #include <asm/ioctls.h>
 
diff --git a/fs/jbd/checkpoint.c b/fs/jbd/checkpoint.c
index cb3cef525c3b..e6265a0b56b8 100644
--- a/fs/jbd/checkpoint.c
+++ b/fs/jbd/checkpoint.c
@@ -338,7 +338,7 @@ restart:
          * done (maybe it's a new transaction, but it fell at the same
          * address).
          */
-        if (journal->j_checkpoint_transactions == transaction ||
+        if (journal->j_checkpoint_transactions == transaction &&
                         transaction->t_tid == this_tid) {
                 int batch_count = 0;
                 struct buffer_head *bhs[NR_BATCH];
diff --git a/fs/jbd/commit.c b/fs/jbd/commit.c
index 002ad2bbc769..29e62d98bae6 100644
--- a/fs/jbd/commit.c
+++ b/fs/jbd/commit.c
@@ -829,7 +829,8 @@ restart_loop:
         journal->j_committing_transaction = NULL;
         spin_unlock(&journal->j_state_lock);
 
-        if (commit_transaction->t_checkpoint_list == NULL) {
+        if (commit_transaction->t_checkpoint_list == NULL &&
+            commit_transaction->t_checkpoint_io_list == NULL) {
                 __journal_drop_transaction(journal, commit_transaction);
         } else {
                 if (journal->j_checkpoint_transactions == NULL) {
diff --git a/fs/namei.c b/fs/namei.c
index 33fb5bd34a81..4acdac043b6b 100644
--- a/fs/namei.c
+++ b/fs/namei.c
@@ -30,6 +30,8 @@
 #include <linux/audit.h>
 #include <linux/capability.h>
 #include <linux/file.h>
+#include <linux/fcntl.h>
+#include <linux/namei.h>
 #include <asm/namei.h>
 #include <asm/uaccess.h>
 
@@ -1063,7 +1065,8 @@ set_it:
 }
 
 /* Returns 0 and nd will be valid on success; Retuns error, otherwise. */
-int fastcall path_lookup(const char *name, unsigned int flags, struct nameidata *nd)
+static int fastcall do_path_lookup(int dfd, const char *name,
+                                unsigned int flags, struct nameidata *nd)
 {
         int retval = 0;
 
@@ -1083,9 +1086,38 @@ int fastcall path_lookup(const char *name, unsigned int flags, struct nameidata
                 }
                 nd->mnt = mntget(current->fs->rootmnt);
                 nd->dentry = dget(current->fs->root);
-        } else {
+        } else if (dfd == AT_FDCWD) {
                 nd->mnt = mntget(current->fs->pwdmnt);
                 nd->dentry = dget(current->fs->pwd);
+        } else {
+                struct file *file;
+                int fput_needed;
+                struct dentry *dentry;
+
+                file = fget_light(dfd, &fput_needed);
+                if (!file) {
+                        retval = -EBADF;
+                        goto out_fail;
+                }
+
+                dentry = file->f_dentry;
+
+                if (!S_ISDIR(dentry->d_inode->i_mode)) {
+                        retval = -ENOTDIR;
+                        fput_light(file, fput_needed);
+                        goto out_fail;
+                }
+
+                retval = file_permission(file, MAY_EXEC);
+                if (retval) {
+                        fput_light(file, fput_needed);
+                        goto out_fail;
+                }
+
+                nd->mnt = mntget(file->f_vfsmnt);
+                nd->dentry = dget(dentry);
+
+                fput_light(file, fput_needed);
         }
         read_unlock(&current->fs->lock);
         current->total_link_count = 0;
@@ -1094,11 +1126,19 @@ out:
         if (unlikely(current->audit_context
                      && nd && nd->dentry && nd->dentry->d_inode))
                 audit_inode(name, nd->dentry->d_inode, flags);
+out_fail:
         return retval;
 }
 
-static int __path_lookup_intent_open(const char *name, unsigned int lookup_flags,
-                struct nameidata *nd, int open_flags, int create_mode)
+int fastcall path_lookup(const char *name, unsigned int flags,
+                        struct nameidata *nd)
+{
+        return do_path_lookup(AT_FDCWD, name, flags, nd);
+}
+
+static int __path_lookup_intent_open(int dfd, const char *name,
+                unsigned int lookup_flags, struct nameidata *nd,
+                int open_flags, int create_mode)
 {
         struct file *filp = get_empty_filp();
         int err;
@@ -1108,7 +1148,7 @@ static int __path_lookup_intent_open(const char *name, unsigned int lookup_flags
         nd->intent.open.file = filp;
         nd->intent.open.flags = open_flags;
         nd->intent.open.create_mode = create_mode;
-        err = path_lookup(name, lookup_flags|LOOKUP_OPEN, nd);
+        err = do_path_lookup(dfd, name, lookup_flags|LOOKUP_OPEN, nd);
         if (IS_ERR(nd->intent.open.file)) {
                 if (err == 0) {
                         err = PTR_ERR(nd->intent.open.file);
@@ -1126,10 +1166,10 @@ static int __path_lookup_intent_open(const char *name, unsigned int lookup_flags
  * @nd: pointer to nameidata
  * @open_flags: open intent flags
  */
-int path_lookup_open(const char *name, unsigned int lookup_flags,
+int path_lookup_open(int dfd, const char *name, unsigned int lookup_flags,
                 struct nameidata *nd, int open_flags)
 {
-        return __path_lookup_intent_open(name, lookup_flags, nd,
+        return __path_lookup_intent_open(dfd, name, lookup_flags, nd,
                         open_flags, 0);
 }
 
@@ -1141,12 +1181,12 @@ int path_lookup_open(const char *name, unsigned int lookup_flags,
  * @open_flags: open intent flags
  * @create_mode: create intent flags
  */
-static int path_lookup_create(const char *name, unsigned int lookup_flags,
-                              struct nameidata *nd, int open_flags,
-                              int create_mode)
+static int path_lookup_create(int dfd, const char *name,
+                              unsigned int lookup_flags, struct nameidata *nd,
+                              int open_flags, int create_mode)
 {
-        return __path_lookup_intent_open(name, lookup_flags|LOOKUP_CREATE, nd,
-                        open_flags, create_mode);
+        return __path_lookup_intent_open(dfd, name, lookup_flags|LOOKUP_CREATE,
+                        nd, open_flags, create_mode);
 }
 
 int __user_path_lookup_open(const char __user *name, unsigned int lookup_flags,
@@ -1156,7 +1196,7 @@ int __user_path_lookup_open(const char __user *name, unsigned int lookup_flags,
         int err = PTR_ERR(tmp);
 
         if (!IS_ERR(tmp)) {
-                err = __path_lookup_intent_open(tmp, lookup_flags, nd, open_flags, 0);
+                err = __path_lookup_intent_open(AT_FDCWD, tmp, lookup_flags, nd, open_flags, 0);
                 putname(tmp);
         }
         return err;
@@ -1248,18 +1288,24 @@ access:
  * that namei follows links, while lnamei does not.
  * SMP-safe
  */
-int fastcall __user_walk(const char __user *name, unsigned flags, struct nameidata *nd)
+int fastcall __user_walk_fd(int dfd, const char __user *name, unsigned flags,
+                            struct nameidata *nd)
 {
         char *tmp = getname(name);
         int err = PTR_ERR(tmp);
 
         if (!IS_ERR(tmp)) {
-                err = path_lookup(tmp, flags, nd);
+                err = do_path_lookup(dfd, tmp, flags, nd);
                 putname(tmp);
         }
         return err;
 }
 
+int fastcall __user_walk(const char __user *name, unsigned flags, struct nameidata *nd)
+{
+        return __user_walk_fd(AT_FDCWD, name, flags, nd);
+}
+
 /*
  * It's inline, so penalty for filesystems that don't use sticky bit is
  * minimal.
@@ -1518,7 +1564,8 @@ int may_open(struct nameidata *nd, int acc_mode, int flag)
  * for symlinks (where the permissions are checked later).
  * SMP-safe
  */
-int open_namei(const char * pathname, int flag, int mode, struct nameidata *nd)
+int open_namei(int dfd, const char *pathname, int flag,
+                int mode, struct nameidata *nd)
 {
         int acc_mode, error;
         struct path path;
@@ -1540,7 +1587,8 @@ int open_namei(const char * pathname, int flag, int mode, struct nameidata *nd)
          * The simplest case - just a plain lookup.
          */
         if (!(flag & O_CREAT)) {
-                error = path_lookup_open(pathname, lookup_flags(flag), nd, flag);
+                error = path_lookup_open(dfd, pathname, lookup_flags(flag),
+                                         nd, flag);
                 if (error)
                         return error;
                 goto ok;
@@ -1549,7 +1597,7 @@ int open_namei(const char * pathname, int flag, int mode, struct nameidata *nd)
         /*
          * Create - we need to know the parent.
          */
-        error = path_lookup_create(pathname, LOOKUP_PARENT, nd, flag, mode);
+        error = path_lookup_create(dfd,pathname,LOOKUP_PARENT,nd,flag,mode);
         if (error)
                 return error;
 
@@ -1744,7 +1792,8 @@ int vfs_mknod(struct inode *dir, struct dentry *dentry, int mode, dev_t dev)
         return error;
 }
 
-asmlinkage long sys_mknod(const char __user * filename, int mode, unsigned dev)
+asmlinkage long sys_mknodat(int dfd, const char __user *filename, int mode,
+                                unsigned dev)
 {
         int error = 0;
         char * tmp;
@@ -1757,7 +1806,7 @@ asmlinkage long sys_mknod(const char __user * filename, int mode, unsigned dev)
         if (IS_ERR(tmp))
                 return PTR_ERR(tmp);
 
-        error = path_lookup(tmp, LOOKUP_PARENT, &nd);
+        error = do_path_lookup(dfd, tmp, LOOKUP_PARENT, &nd);
         if (error)
                 goto out;
         dentry = lookup_create(&nd, 0);
@@ -1793,6 +1842,11 @@ out:
         return error;
 }
 
+asmlinkage long sys_mknod(const char __user *filename, int mode, unsigned dev)
+{
+        return sys_mknodat(AT_FDCWD, filename, mode, dev);
+}
+
 int vfs_mkdir(struct inode *dir, struct dentry *dentry, int mode)
 {
         int error = may_create(dir, dentry, NULL);
@@ -1815,7 +1869,7 @@ int vfs_mkdir(struct inode *dir, struct dentry *dentry, int mode)
         return error;
 }
 
-asmlinkage long sys_mkdir(const char __user * pathname, int mode)
+asmlinkage long sys_mkdirat(int dfd, const char __user *pathname, int mode)
 {
         int error = 0;
         char * tmp;
@@ -1826,7 +1880,7 @@ asmlinkage long sys_mkdir(const char __user * pathname, int mode)
                 struct dentry *dentry;
                 struct nameidata nd;
 
-                error = path_lookup(tmp, LOOKUP_PARENT, &nd);
+                error = do_path_lookup(dfd, tmp, LOOKUP_PARENT, &nd);
                 if (error)
                         goto out;
                 dentry = lookup_create(&nd, 1);
@@ -1846,6 +1900,11 @@ out:
         return error;
 }
 
+asmlinkage long sys_mkdir(const char __user *pathname, int mode)
+{
+        return sys_mkdirat(AT_FDCWD, pathname, mode);
+}
+
 /*
  * We try to drop the dentry early: we should have
  * a usage count of 2 if we're the only user of this
@@ -1907,7 +1966,7 @@ int vfs_rmdir(struct inode *dir, struct dentry *dentry)
         return error;
 }
 
-asmlinkage long sys_rmdir(const char __user * pathname)
+static long do_rmdir(int dfd, const char __user *pathname)
 {
         int error = 0;
         char * name;
@@ -1918,7 +1977,7 @@ asmlinkage long sys_rmdir(const char __user * pathname)
         if(IS_ERR(name))
                 return PTR_ERR(name);
 
-        error = path_lookup(name, LOOKUP_PARENT, &nd);
+        error = do_path_lookup(dfd, name, LOOKUP_PARENT, &nd);
         if (error)
                 goto exit;
 
@@ -1948,6 +2007,11 @@ exit:
         return error;
 }
 
+asmlinkage long sys_rmdir(const char __user *pathname)
+{
+        return do_rmdir(AT_FDCWD, pathname);
+}
+
 int vfs_unlink(struct inode *dir, struct dentry *dentry)
 {
         int error = may_delete(dir, dentry, 0);
@@ -1984,7 +2048,7 @@ int vfs_unlink(struct inode *dir, struct dentry *dentry)
  * writeout happening, and we don't want to prevent access to the directory
  * while waiting on the I/O.
  */
-asmlinkage long sys_unlink(const char __user * pathname)
+static long do_unlinkat(int dfd, const char __user *pathname)
 {
         int error = 0;
         char * name;
@@ -1996,7 +2060,7 @@ asmlinkage long sys_unlink(const char __user * pathname)
         if(IS_ERR(name))
                 return PTR_ERR(name);
 
-        error = path_lookup(name, LOOKUP_PARENT, &nd);
+        error = do_path_lookup(dfd, name, LOOKUP_PARENT, &nd);
         if (error)
                 goto exit;
         error = -EISDIR;
@@ -2031,6 +2095,22 @@ slashes:
         goto exit2;
 }
 
+asmlinkage long sys_unlinkat(int dfd, const char __user *pathname, int flag)
+{
+        if ((flag & ~AT_REMOVEDIR) != 0)
+                return -EINVAL;
+
+        if (flag & AT_REMOVEDIR)
+                return do_rmdir(dfd, pathname);
+
+        return do_unlinkat(dfd, pathname);
+}
+
+asmlinkage long sys_unlink(const char __user *pathname)
+{
+        return do_unlinkat(AT_FDCWD, pathname);
+}
+
 int vfs_symlink(struct inode *dir, struct dentry *dentry, const char *oldname, int mode)
 {
         int error = may_create(dir, dentry, NULL);
@@ -2052,7 +2132,8 @@ int vfs_symlink(struct inode *dir, struct dentry *dentry, const char *oldname, i
         return error;
 }
 
-asmlinkage long sys_symlink(const char __user * oldname, const char __user * newname)
+asmlinkage long sys_symlinkat(const char __user *oldname,
+                              int newdfd, const char __user *newname)
 {
         int error = 0;
         char * from;
@@ -2067,7 +2148,7 @@ asmlinkage long sys_symlink(const char __user * oldname, const char __user * new
                 struct dentry *dentry;
                 struct nameidata nd;
 
-                error = path_lookup(to, LOOKUP_PARENT, &nd);
+                error = do_path_lookup(newdfd, to, LOOKUP_PARENT, &nd);
                 if (error)
                         goto out;
                 dentry = lookup_create(&nd, 0);
@@ -2085,6 +2166,11 @@ out:
         return error;
 }
 
+asmlinkage long sys_symlink(const char __user *oldname, const char __user *newname)
+{
+        return sys_symlinkat(oldname, AT_FDCWD, newname);
+}
+
 int vfs_link(struct dentry *old_dentry, struct inode *dir, struct dentry *new_dentry)
 {
         struct inode *inode = old_dentry->d_inode;
@@ -2132,7 +2218,8 @@ int vfs_link(struct dentry *old_dentry, struct inode *dir, struct dentry *new_de
  * with linux 2.0, and to avoid hard-linking to directories
  * and other special files.  --ADM
  */
-asmlinkage long sys_link(const char __user * oldname, const char __user * newname)
+asmlinkage long sys_linkat(int olddfd, const char __user *oldname,
+                           int newdfd, const char __user *newname)
 {
         struct dentry *new_dentry;
         struct nameidata nd, old_nd;
@@ -2143,10 +2230,10 @@ asmlinkage long sys_link(const char __user * oldname, const char __user * newnam
         if (IS_ERR(to))
                 return PTR_ERR(to);
 
-        error = __user_walk(oldname, 0, &old_nd);
+        error = __user_walk_fd(olddfd, oldname, 0, &old_nd);
         if (error)
                 goto exit;
-        error = path_lookup(to, LOOKUP_PARENT, &nd);
+        error = do_path_lookup(newdfd, to, LOOKUP_PARENT, &nd);
         if (error)
                 goto out;
         error = -EXDEV;
@@ -2169,6 +2256,11 @@ exit:
         return error;
 }
 
+asmlinkage long sys_link(const char __user *oldname, const char __user *newname)
+{
+        return sys_linkat(AT_FDCWD, oldname, AT_FDCWD, newname);
+}
+
 /*
  * The worst of all namespace operations - renaming directory. "Perverted"
  * doesn't even start to describe it. Somebody in UCB had a heck of a trip...
@@ -2315,7 +2407,8 @@ int vfs_rename(struct inode *old_dir, struct dentry *old_dentry,
         return error;
 }
 
-static int do_rename(const char * oldname, const char * newname)
+static int do_rename(int olddfd, const char *oldname,
+                        int newdfd, const char *newname)
 {
         int error = 0;
         struct dentry * old_dir, * new_dir;
@@ -2323,11 +2416,11 @@ static int do_rename(const char * oldname, const char * newname)
         struct dentry * trap;
         struct nameidata oldnd, newnd;
 
-        error = path_lookup(oldname, LOOKUP_PARENT, &oldnd);
+        error = do_path_lookup(olddfd, oldname, LOOKUP_PARENT, &oldnd);
         if (error)
                 goto exit;
 
-        error = path_lookup(newname, LOOKUP_PARENT, &newnd);
+        error = do_path_lookup(newdfd, newname, LOOKUP_PARENT, &newnd);
         if (error)
                 goto exit1;
 
@@ -2391,7 +2484,8 @@ exit:
         return error;
 }
 
-asmlinkage long sys_rename(const char __user * oldname, const char __user * newname)
+asmlinkage long sys_renameat(int olddfd, const char __user *oldname,
+                             int newdfd, const char __user *newname)
 {
         int error;
         char * from;
@@ -2403,13 +2497,18 @@ asmlinkage long sys_rename(const char __user * oldname, const char __user * newn
         to = getname(newname);
         error = PTR_ERR(to);
         if (!IS_ERR(to)) {
-                error = do_rename(from,to);
+                error = do_rename(olddfd, from, newdfd, to);
                 putname(to);
         }
         putname(from);
         return error;
 }
 
+asmlinkage long sys_rename(const char __user *oldname, const char __user *newname)
+{
+        return sys_renameat(AT_FDCWD, oldname, AT_FDCWD, newname);
+}
+
 int vfs_readlink(struct dentry *dentry, char __user *buffer, int buflen, const char *link)
 {
         int len;
@@ -2553,6 +2652,7 @@ struct inode_operations page_symlink_inode_operations = {
 };
 
 EXPORT_SYMBOL(__user_walk);
+EXPORT_SYMBOL(__user_walk_fd);
 EXPORT_SYMBOL(follow_down);
 EXPORT_SYMBOL(follow_up);
 EXPORT_SYMBOL(get_write_access); /* binfmt_aout */
diff --git a/fs/nfsctl.c b/fs/nfsctl.c
index 0b14938b5b62..0d4cf9486068 100644
--- a/fs/nfsctl.c
+++ b/fs/nfsctl.c
@@ -5,6 +5,7 @@
  *
  */
 #include <linux/config.h>
+#include <linux/types.h>
 #include <linux/file.h>
 #include <linux/fs.h>
 #include <linux/sunrpc/svc.h>
diff --git a/fs/nfsd/nfs4proc.c b/fs/nfsd/nfs4proc.c
index 361b4007d4a0..a00fe8686293 100644
--- a/fs/nfsd/nfs4proc.c
+++ b/fs/nfsd/nfs4proc.c
@@ -192,6 +192,14 @@ nfsd4_open(struct svc_rqst *rqstp, struct svc_fh *current_fh, struct nfsd4_open
         }
         if (status)
                 goto out;
+
+        /* Openowner is now set, so sequence id will get bumped.  Now we need
+         * these checks before we do any creates: */
+        if (nfs4_in_grace() && open->op_claim_type != NFS4_OPEN_CLAIM_PREVIOUS)
+                return nfserr_grace;
+        if (!nfs4_in_grace() && open->op_claim_type == NFS4_OPEN_CLAIM_PREVIOUS)
+                return nfserr_no_grace;
+
         switch (open->op_claim_type) {
                 case NFS4_OPEN_CLAIM_DELEGATE_CUR:
                         status = nfserr_inval;
@@ -210,6 +218,7 @@ nfsd4_open(struct svc_rqst *rqstp, struct svc_fh *current_fh, struct nfsd4_open
                                 goto out;
                         break;
                 case NFS4_OPEN_CLAIM_PREVIOUS:
+                        open->op_stateowner->so_confirmed = 1;
                         /*
                          * The CURRENT_FH is already set to the file being
                          * opened.  (1) set open->op_cinfo, (2) set
@@ -221,6 +230,7 @@ nfsd4_open(struct svc_rqst *rqstp, struct svc_fh *current_fh, struct nfsd4_open
                                 goto out;
                         break;
                 case NFS4_OPEN_CLAIM_DELEGATE_PREV:
+                        open->op_stateowner->so_confirmed = 1;
                         printk("NFSD: unsupported OPEN claim type %d\n",
                                 open->op_claim_type);
                         status = nfserr_notsupp;
@@ -584,31 +594,23 @@ nfsd4_setattr(struct svc_rqst *rqstp, struct svc_fh *current_fh, struct nfsd4_se
 {
         int status = nfs_ok;
 
-        if (!current_fh->fh_dentry)
-                return nfserr_nofilehandle;
-
-        status = nfs_ok;
         if (setattr->sa_iattr.ia_valid & ATTR_SIZE) {
                 nfs4_lock_state();
-                if ((status = nfs4_preprocess_stateid_op(current_fh,
-                                                &setattr->sa_stateid,
-                                                CHECK_FH | WR_STATE, NULL))) {
-                        dprintk("NFSD: nfsd4_setattr: couldn't process stateid!\n");
-                        goto out_unlock;
-                }
+                status = nfs4_preprocess_stateid_op(current_fh,
+                        &setattr->sa_stateid, CHECK_FH | WR_STATE, NULL);
                 nfs4_unlock_state();
+                if (status) {
+                        dprintk("NFSD: nfsd4_setattr: couldn't process stateid!");
+                        return status;
+                }
         }
         status = nfs_ok;
         if (setattr->sa_acl != NULL)
                 status = nfsd4_set_nfs4_acl(rqstp, current_fh, setattr->sa_acl);
         if (status)
-                goto out;
+                return status;
         status = nfsd_setattr(rqstp, current_fh, &setattr->sa_iattr,
                                 0, (time_t)0);
-out:
-        return status;
-out_unlock:
-        nfs4_unlock_state();
         return status;
 }
 
@@ -626,15 +628,17 @@ nfsd4_write(struct svc_rqst *rqstp, struct svc_fh *current_fh, struct nfsd4_writ
                 return nfserr_inval;
 
         nfs4_lock_state();
-        if ((status = nfs4_preprocess_stateid_op(current_fh, stateid,
-                                        CHECK_FH | WR_STATE, &filp))) {
-                dprintk("NFSD: nfsd4_write: couldn't process stateid!\n");
-                goto out;
-        }
+        status = nfs4_preprocess_stateid_op(current_fh, stateid,
+                                        CHECK_FH | WR_STATE, &filp);
         if (filp)
                 get_file(filp);
         nfs4_unlock_state();
 
+        if (status) {
+                dprintk("NFSD: nfsd4_write: couldn't process stateid!\n");
+                return status;
+        }
+
         write->wr_bytes_written = write->wr_buflen;
         write->wr_how_written = write->wr_stable_how;
         p = (u32 *)write->wr_verifier.data;
@@ -650,9 +654,6 @@ nfsd4_write(struct svc_rqst *rqstp, struct svc_fh *current_fh, struct nfsd4_writ
         if (status == nfserr_symlink)
                 status = nfserr_inval;
         return status;
-out:
-        nfs4_unlock_state();
-        return status;
 }
 
 /* This routine never returns NFS_OK!  If there are no other errors, it
@@ -768,6 +769,8 @@ nfsd4_proc_compound(struct svc_rqst *rqstp,
         while (!status && resp->opcnt < args->opcnt) {
                 op = &args->ops[resp->opcnt++];
 
+                dprintk("nfsv4 compound op #%d: %d\n", resp->opcnt, op->opnum);
+
                 /*
                  * The XDR decode routines may have pre-set op->status;
                  * for example, if there is a miscellaneous XDR error
@@ -792,17 +795,13 @@ nfsd4_proc_compound(struct svc_rqst *rqstp,
                 /* All operations except RENEW, SETCLIENTID, RESTOREFH
                 * SETCLIENTID_CONFIRM, PUTFH and PUTROOTFH
                 * require a valid current filehandle
-                *
-                * SETATTR NOFILEHANDLE error handled in nfsd4_setattr
-                * due to required returned bitmap argument
                 */
                 if ((!current_fh->fh_dentry) &&
                    !((op->opnum == OP_PUTFH) || (op->opnum == OP_PUTROOTFH) ||
                    (op->opnum == OP_SETCLIENTID) ||
                    (op->opnum == OP_SETCLIENTID_CONFIRM) ||
                    (op->opnum == OP_RENEW) || (op->opnum == OP_RESTOREFH) ||
-                   (op->opnum == OP_RELEASE_LOCKOWNER) ||
-                   (op->opnum == OP_SETATTR))) {
+                   (op->opnum == OP_RELEASE_LOCKOWNER))) {
                         op->status = nfserr_nofilehandle;
                         goto encode_op;
                 }
diff --git a/fs/nfsd/nfs4recover.c b/fs/nfsd/nfs4recover.c
index be963a133aaa..06da7506363c 100644
--- a/fs/nfsd/nfs4recover.c
+++ b/fs/nfsd/nfs4recover.c
@@ -222,8 +222,7 @@ nfsd4_list_rec_dir(struct dentry *dir, recdir_func *f)
 
         nfs4_save_user(&uid, &gid);
 
-        filp = dentry_open(dget(dir), mntget(rec_dir.mnt),
-                        O_RDWR);
+        filp = dentry_open(dget(dir), mntget(rec_dir.mnt), O_RDONLY);
         status = PTR_ERR(filp);
         if (IS_ERR(filp))
                 goto out;
@@ -400,9 +399,10 @@ nfsd4_init_recdir(char *rec_dirname)
 
         nfs4_save_user(&uid, &gid);
 
-        status = path_lookup(rec_dirname, LOOKUP_FOLLOW, &rec_dir);
-        if (status == -ENOENT)
-                printk("NFSD: recovery directory %s doesn't exist\n",
+        status = path_lookup(rec_dirname, LOOKUP_FOLLOW | LOOKUP_DIRECTORY,
+                        &rec_dir);
+        if (status)
+                printk("NFSD: unable to find recovery directory %s\n",
                                 rec_dirname);
 
         if (!status)
diff --git a/fs/nfsd/nfs4state.c b/fs/nfsd/nfs4state.c
index 6bbefd06f10d..1143cfb64549 100644
--- a/fs/nfsd/nfs4state.c
+++ b/fs/nfsd/nfs4state.c
@@ -1088,7 +1088,7 @@ alloc_init_open_stateowner(unsigned int strhashval, struct nfs4_client *clp, str
         sop->so_seqid = open->op_seqid;
         sop->so_confirmed = 0;
         rp = &sop->so_replay;
-        rp->rp_status = NFSERR_SERVERFAULT;
+        rp->rp_status = nfserr_serverfault;
         rp->rp_buflen = 0;
         rp->rp_buf = rp->rp_ibuf;
         return sop;
@@ -1178,7 +1178,6 @@ release_stateid(struct nfs4_stateid *stp, int flags)
                 locks_remove_posix(filp, (fl_owner_t) stp->st_stateowner);
         put_nfs4_file(stp->st_file);
         kmem_cache_free(stateid_slab, stp);
-        stp = NULL;
 }
 
 static void
@@ -1191,22 +1190,6 @@ move_to_close_lru(struct nfs4_stateowner *sop)
         sop->so_time = get_seconds();
 }
 
-static void
-release_state_owner(struct nfs4_stateid *stp, int flag)
-{
-        struct nfs4_stateowner *sop = stp->st_stateowner;
-
-        dprintk("NFSD: release_state_owner\n");
-        release_stateid(stp, flag);
-
-        /* place unused nfs4_stateowners on so_close_lru list to be
-         * released by the laundromat service after the lease period
-         * to enable us to handle CLOSE replay
-         */
-        if (sop->so_confirmed && list_empty(&sop->so_stateids))
-                move_to_close_lru(sop);
-}
-
 static int
 cmp_owner_str(struct nfs4_stateowner *sop, struct xdr_netobj *owner, clientid_t *clid) {
         return ((sop->so_owner.len == owner->len) && 
@@ -1446,92 +1429,61 @@ static struct lock_manager_operations nfsd_lease_mng_ops = {
 };
 
 
-/*
- * nfsd4_process_open1()
- *      lookup stateowner.
- *              found:
- *                      check confirmed 
- *                              confirmed:
- *                                      check seqid
- *                              not confirmed:
- *                                      delete owner
- *                                      create new owner
- *              notfound:
- *                      verify clientid
- *                      create new owner
- *
- * called with nfs4_lock_state() held.
- */
 int
 nfsd4_process_open1(struct nfsd4_open *open)
 {
-        int status;
         clientid_t *clientid = &open->op_clientid;
         struct nfs4_client *clp = NULL;
         unsigned int strhashval;
         struct nfs4_stateowner *sop = NULL;
 
-        status = nfserr_inval;
         if (!check_name(open->op_owner))
-                goto out;
+                return nfserr_inval;
 
         if (STALE_CLIENTID(&open->op_clientid))
                 return nfserr_stale_clientid;
 
         strhashval = ownerstr_hashval(clientid->cl_id, open->op_owner);
         sop = find_openstateowner_str(strhashval, open);
-        if (sop) {
-                open->op_stateowner = sop;
-                /* check for replay */
-                if (open->op_seqid == sop->so_seqid - 1){
-                        if (sop->so_replay.rp_buflen)
-                                return NFSERR_REPLAY_ME;
-                        else {
-                                /* The original OPEN failed so spectacularly
-                                 * that we don't even have replay data saved!
-                                 * Therefore, we have no choice but to continue
-                                 * processing this OPEN; presumably, we'll
-                                 * fail again for the same reason.
-                                 */
-                                dprintk("nfsd4_process_open1:"
-                                        " replay with no replay cache\n");
-                                goto renew;
-                        }
-                } else if (sop->so_confirmed) {
-                        if (open->op_seqid == sop->so_seqid)
-                                goto renew;
-                        status = nfserr_bad_seqid;
-                        goto out;
-                } else {
-                        /* If we get here, we received an OPEN for an
-                         * unconfirmed nfs4_stateowner. Since the seqid's are
-                         * different, purge the existing nfs4_stateowner, and
-                         * instantiate a new one.
-                         */
-                        clp = sop->so_client;
-                        release_stateowner(sop);
-                }
-        } else {
-                /* nfs4_stateowner not found.
-                 * Verify clientid and instantiate new nfs4_stateowner.
-                 * If verify fails this is presumably the result of the
-                 * client's lease expiring.
-                 */
-                status = nfserr_expired;
+        open->op_stateowner = sop;
+        if (!sop) {
+                /* Make sure the client's lease hasn't expired. */
                 clp = find_confirmed_client(clientid);
                 if (clp == NULL)
-                        goto out;
+                        return nfserr_expired;
+                goto renew;
         }
-        status = nfserr_resource;
-        sop = alloc_init_open_stateowner(strhashval, clp, open);
-        if (sop == NULL)
-                goto out;
-        open->op_stateowner = sop;
+        if (!sop->so_confirmed) {
+                /* Replace unconfirmed owners without checking for replay. */
+                clp = sop->so_client;
+                release_stateowner(sop);
+                open->op_stateowner = NULL;
+                goto renew;
+        }
+        if (open->op_seqid == sop->so_seqid - 1) {
+                if (sop->so_replay.rp_buflen)
+                        return NFSERR_REPLAY_ME;
+                /* The original OPEN failed so spectacularly
+                 * that we don't even have replay data saved!
+                 * Therefore, we have no choice but to continue
+                 * processing this OPEN; presumably, we'll
+                 * fail again for the same reason.
+                 */
+                dprintk("nfsd4_process_open1: replay with no replay cache\n");
+                goto renew;
+        }
+        if (open->op_seqid != sop->so_seqid)
+                return nfserr_bad_seqid;
 renew:
-        status = nfs_ok;
+        if (open->op_stateowner == NULL) {
+                sop = alloc_init_open_stateowner(strhashval, clp, open);
+                if (sop == NULL)
+                        return nfserr_resource;
+                open->op_stateowner = sop;
+        }
+        list_del_init(&sop->so_close_lru);
         renew_client(sop->so_client);
-out:
-        return status;
+        return nfs_ok;
 }
 
 static inline int
@@ -1648,7 +1600,7 @@ nfsd4_truncate(struct svc_rqst *rqstp, struct svc_fh *fh,
         if (!open->op_truncate)
                 return 0;
         if (!(open->op_share_access & NFS4_SHARE_ACCESS_WRITE))
-                return -EINVAL;
+                return nfserr_inval;
         return nfsd_setattr(rqstp, fh, &iattr, 0, (time_t)0);
 }
 
@@ -1657,26 +1609,26 @@ nfs4_upgrade_open(struct svc_rqst *rqstp, struct svc_fh *cur_fh, struct nfs4_sta
 {
         struct file *filp = stp->st_vfs_file;
         struct inode *inode = filp->f_dentry->d_inode;
-        unsigned int share_access;
+        unsigned int share_access, new_writer;
         int status;
 
         set_access(&share_access, stp->st_access_bmap);
-        share_access = ~share_access;
-        share_access &= open->op_share_access;
-
-        if (!(share_access & NFS4_SHARE_ACCESS_WRITE))
-                return nfsd4_truncate(rqstp, cur_fh, open);
+        new_writer = (~share_access) & open->op_share_access
+                        & NFS4_SHARE_ACCESS_WRITE;
 
-        status = get_write_access(inode);
-        if (status)
-                return nfserrno(status);
+        if (new_writer) {
+                status = get_write_access(inode);
+                if (status)
+                        return nfserrno(status);
+        }
         status = nfsd4_truncate(rqstp, cur_fh, open);
         if (status) {
-                put_write_access(inode);
+                if (new_writer)
+                        put_write_access(inode);
                 return status;
         }
         /* remember the open */
-        filp->f_mode = (filp->f_mode | FMODE_WRITE) & ~FMODE_READ;
+        filp->f_mode |= open->op_share_access;
         set_bit(open->op_share_access, &stp->st_access_bmap);
         set_bit(open->op_share_deny, &stp->st_deny_bmap);
 
@@ -1780,12 +1732,6 @@ nfsd4_process_open2(struct svc_rqst *rqstp, struct svc_fh *current_fh, struct nf
         struct nfs4_delegation *dp = NULL;
         int status;
 
-        if (nfs4_in_grace() && open->op_claim_type != NFS4_OPEN_CLAIM_PREVIOUS)
-                return nfserr_grace;
-
-        if (!nfs4_in_grace() && open->op_claim_type == NFS4_OPEN_CLAIM_PREVIOUS)
-                return nfserr_no_grace;
-
         status = nfserr_inval;
         if (!TEST_ACCESS(open->op_share_access) || !TEST_DENY(open->op_share_deny))
                 goto out;
@@ -2423,15 +2369,19 @@ nfsd4_close(struct svc_rqst *rqstp, struct svc_fh *current_fh, struct nfsd4_clos
                                         CHECK_FH | OPEN_STATE | CLOSE_STATE,
                                         &close->cl_stateowner, &stp, NULL)))
                 goto out; 
-        /*
-        *  Return success, but first update the stateid.
-        */
         status = nfs_ok;
         update_stateid(&stp->st_stateid);
         memcpy(&close->cl_stateid, &stp->st_stateid, sizeof(stateid_t));
 
-        /* release_state_owner() calls nfsd_close() if needed */
-        release_state_owner(stp, OPEN_STATE);
+        /* release_stateid() calls nfsd_close() if needed */
+        release_stateid(stp, OPEN_STATE);
+
+        /* place unused nfs4_stateowners on so_close_lru list to be
+         * released by the laundromat service after the lease period
+         * to enable us to handle CLOSE replay
+         */
+        if (list_empty(&close->cl_stateowner->so_stateids))
+                move_to_close_lru(close->cl_stateowner);
 out:
         if (close->cl_stateowner) {
                 nfs4_get_stateowner(close->cl_stateowner);
@@ -2633,7 +2583,7 @@ alloc_init_lock_stateowner(unsigned int strhashval, struct nfs4_client *clp, str
         sop->so_seqid = lock->lk_new_lock_seqid + 1;
         sop->so_confirmed = 1;
         rp = &sop->so_replay;
-        rp->rp_status = NFSERR_SERVERFAULT;
+        rp->rp_status = nfserr_serverfault;
         rp->rp_buflen = 0;
         rp->rp_buf = rp->rp_ibuf;
         return sop;
@@ -2700,6 +2650,11 @@ nfsd4_lock(struct svc_rqst *rqstp, struct svc_fh *current_fh, struct nfsd4_lock
         if (check_lock_length(lock->lk_offset, lock->lk_length))
                  return nfserr_inval;
 
+        if ((status = fh_verify(rqstp, current_fh, S_IFREG, MAY_LOCK))) {
+                dprintk("NFSD: nfsd4_lock: permission denied!\n");
+                return status;
+        }
+
         nfs4_lock_state();
 
         if (lock->lk_is_new) {
@@ -2720,11 +2675,11 @@ nfsd4_lock(struct svc_rqst *rqstp, struct svc_fh *current_fh, struct nfsd4_lock
                                         lock->lk_new_open_seqid,
                                         &lock->lk_new_open_stateid,
                                         CHECK_FH | OPEN_STATE,
-                                        &lock->lk_stateowner, &open_stp,
+                                        &lock->lk_replay_owner, &open_stp,
                                         lock);
                 if (status)
                         goto out;
-                open_sop = lock->lk_stateowner;
+                open_sop = lock->lk_replay_owner;
                 /* create lockowner and lock stateid */
                 fp = open_stp->st_file;
                 strhashval = lock_ownerstr_hashval(fp->fi_inode, 
@@ -2739,29 +2694,22 @@ nfsd4_lock(struct svc_rqst *rqstp, struct svc_fh *current_fh, struct nfsd4_lock
                 if (lock_sop == NULL)
                         goto out;
                 lock_stp = alloc_init_lock_stateid(lock_sop, fp, open_stp);
-                if (lock_stp == NULL) {
-                        release_stateowner(lock_sop);
+                if (lock_stp == NULL)
                         goto out;
-                }
         } else {
                 /* lock (lock owner + lock stateid) already exists */
                 status = nfs4_preprocess_seqid_op(current_fh,
                                        lock->lk_old_lock_seqid, 
                                        &lock->lk_old_lock_stateid, 
                                        CHECK_FH | LOCK_STATE, 
-                                       &lock->lk_stateowner, &lock_stp, lock);
+                                       &lock->lk_replay_owner, &lock_stp, lock);
                 if (status)
                         goto out;
-                lock_sop = lock->lk_stateowner;
+                lock_sop = lock->lk_replay_owner;
         }
-        /* lock->lk_stateowner and lock_stp have been created or found */
+        /* lock->lk_replay_owner and lock_stp have been created or found */
         filp = lock_stp->st_vfs_file;
 
-        if ((status = fh_verify(rqstp, current_fh, S_IFREG, MAY_LOCK))) {
-                dprintk("NFSD: nfsd4_lock: permission denied!\n");
-                goto out;
-        }
-
         status = nfserr_grace;
         if (nfs4_in_grace() && !lock->lk_reclaim)
                 goto out;
@@ -2802,8 +2750,6 @@ nfsd4_lock(struct svc_rqst *rqstp, struct svc_fh *current_fh, struct nfsd4_lock
         */
 
         status = posix_lock_file(filp, &file_lock);
-        if (file_lock.fl_ops && file_lock.fl_ops->fl_release_private)
-                file_lock.fl_ops->fl_release_private(&file_lock);
         dprintk("NFSD: nfsd4_lock: posix_lock_file status %d\n",status);
         switch (-status) {
         case 0: /* success! */
@@ -2815,9 +2761,12 @@ nfsd4_lock(struct svc_rqst *rqstp, struct svc_fh *current_fh, struct nfsd4_lock
                 goto conflicting_lock;
         case (EDEADLK):
                 status = nfserr_deadlock;
+                dprintk("NFSD: nfsd4_lock: posix_lock_file() failed! status %d\n",status);
+                goto out;
         default:        
+                status = nfserrno(status);
                 dprintk("NFSD: nfsd4_lock: posix_lock_file() failed! status %d\n",status);
-                goto out_destroy_new_stateid;
+                goto out;
         }
 
 conflicting_lock:
@@ -2831,20 +2780,12 @@ conflicting_lock:
                 goto out;
         }
         nfs4_set_lock_denied(conflock, &lock->lk_denied);
-
-out_destroy_new_stateid:
-        if (lock->lk_is_new) {
-                dprintk("NFSD: nfsd4_lock: destroy new stateid!\n");
-                /*
-                 * An error encountered after instantiation of the new
-                 * stateid has forced us to destroy it.
-                 */
-                release_state_owner(lock_stp, LOCK_STATE);
-        }
 out:
-        if (lock->lk_stateowner) {
-                nfs4_get_stateowner(lock->lk_stateowner);
-                *replay_owner = lock->lk_stateowner;
+        if (status && lock->lk_is_new && lock_sop)
+                release_stateowner(lock_sop);
+        if (lock->lk_replay_owner) {
+                nfs4_get_stateowner(lock->lk_replay_owner);
+                *replay_owner = lock->lk_replay_owner;
         }
         nfs4_unlock_state();
         return status;
@@ -2977,8 +2918,6 @@ nfsd4_locku(struct svc_rqst *rqstp, struct svc_fh *current_fh, struct nfsd4_lock
         *  Try to unlock the file in the VFS.
         */
         status = posix_lock_file(filp, &file_lock); 
-        if (file_lock.fl_ops && file_lock.fl_ops->fl_release_private)
-                file_lock.fl_ops->fl_release_private(&file_lock);
         if (status) {
                 dprintk("NFSD: nfs4_locku: posix_lock_file failed!\n");
                 goto out_nfserr;
@@ -3016,9 +2955,10 @@ check_for_locks(struct file *filp, struct nfs4_stateowner *lowner)
 
         lock_kernel();
         for (flpp = &inode->i_flock; *flpp != NULL; flpp = &(*flpp)->fl_next) {
-                if ((*flpp)->fl_owner == (fl_owner_t)lowner)
+                if ((*flpp)->fl_owner == (fl_owner_t)lowner) {
                         status = 1;
                         goto out;
+                }
         }
 out:
         unlock_kernel();
diff --git a/fs/nfsd/nfs4xdr.c b/fs/nfsd/nfs4xdr.c
index dcd673186944..69d3501173a8 100644
--- a/fs/nfsd/nfs4xdr.c
+++ b/fs/nfsd/nfs4xdr.c
@@ -528,7 +528,7 @@ nfsd4_decode_lock(struct nfsd4_compoundargs *argp, struct nfsd4_lock *lock)
 {
         DECODE_HEAD;
 
-        lock->lk_stateowner = NULL;
+        lock->lk_replay_owner = NULL;
         /*
         * type, reclaim(boolean), offset, length, new_lock_owner(boolean)
         */
@@ -1764,10 +1764,11 @@ nfsd4_encode_dirent(struct readdir_cd *ccd, const char *name, int namlen,
                  */
                 if (!(cd->rd_bmval[0] & FATTR4_WORD0_RDATTR_ERROR))
                         goto fail;
-                nfserr = nfserr_toosmall;
                 p = nfsd4_encode_rdattr_error(p, buflen, nfserr);
-                if (p == NULL)
+                if (p == NULL) {
+                        nfserr = nfserr_toosmall;
                         goto fail;
+                }
         }
         cd->buflen -= (p - cd->buffer);
         cd->buffer = p;
@@ -1895,7 +1896,6 @@ nfsd4_encode_lock_denied(struct nfsd4_compoundres *resp, struct nfsd4_lock_denie
 static void
 nfsd4_encode_lock(struct nfsd4_compoundres *resp, int nfserr, struct nfsd4_lock *lock)
 {
-
         ENCODE_SEQID_OP_HEAD;
 
         if (!nfserr) {
@@ -1906,7 +1906,7 @@ nfsd4_encode_lock(struct nfsd4_compoundres *resp, int nfserr, struct nfsd4_lock
         } else if (nfserr == nfserr_denied)
                 nfsd4_encode_lock_denied(resp, &lock->lk_denied);
 
-        ENCODE_SEQID_OP_TAIL(lock->lk_stateowner);
+        ENCODE_SEQID_OP_TAIL(lock->lk_replay_owner);
 }
 
 static void
diff --git a/fs/nfsd/nfsproc.c b/fs/nfsd/nfsproc.c
index 0aa1b9603d7f..3e6b75cd90fd 100644
--- a/fs/nfsd/nfsproc.c
+++ b/fs/nfsd/nfsproc.c
@@ -36,6 +36,22 @@ nfsd_proc_null(struct svc_rqst *rqstp, void *argp, void *resp)
         return nfs_ok;
 }
 
+static int
+nfsd_return_attrs(int err, struct nfsd_attrstat *resp)
+{
+        if (err) return err;
+        return nfserrno(vfs_getattr(resp->fh.fh_export->ex_mnt,
+                                    resp->fh.fh_dentry,
+                                    &resp->stat));
+}
+static int
+nfsd_return_dirop(int err, struct nfsd_diropres *resp)
+{
+        if (err) return err;
+        return nfserrno(vfs_getattr(resp->fh.fh_export->ex_mnt,
+                                    resp->fh.fh_dentry,
+                                    &resp->stat));
+}
 /*
  * Get a file's attributes
  * N.B. After this call resp->fh needs an fh_put
@@ -44,10 +60,12 @@ static int
 nfsd_proc_getattr(struct svc_rqst *rqstp, struct nfsd_fhandle  *argp,
                                           struct nfsd_attrstat *resp)
 {
+        int nfserr;
         dprintk("nfsd: GETATTR  %s\n", SVCFH_fmt(&argp->fh));
 
         fh_copy(&resp->fh, &argp->fh);
-        return fh_verify(rqstp, &resp->fh, 0, MAY_NOP);
+        nfserr = fh_verify(rqstp, &resp->fh, 0, MAY_NOP);
+        return nfsd_return_attrs(nfserr, resp);
 }
 
 /*
@@ -58,12 +76,14 @@ static int
 nfsd_proc_setattr(struct svc_rqst *rqstp, struct nfsd_sattrargs *argp,
                                           struct nfsd_attrstat  *resp)
 {
+        int nfserr;
         dprintk("nfsd: SETATTR  %s, valid=%x, size=%ld\n",
                 SVCFH_fmt(&argp->fh),
                 argp->attrs.ia_valid, (long) argp->attrs.ia_size);
 
         fh_copy(&resp->fh, &argp->fh);
-        return nfsd_setattr(rqstp, &resp->fh, &argp->attrs,0, (time_t)0);
+        nfserr = nfsd_setattr(rqstp, &resp->fh, &argp->attrs,0, (time_t)0);
+        return nfsd_return_attrs(nfserr, resp);
 }
 
 /*
@@ -86,7 +106,7 @@ nfsd_proc_lookup(struct svc_rqst *rqstp, struct nfsd_diropargs *argp,
                                  &resp->fh);
 
         fh_put(&argp->fh);
-        return nfserr;
+        return nfsd_return_dirop(nfserr, resp);
 }
 
 /*
@@ -142,7 +162,10 @@ nfsd_proc_read(struct svc_rqst *rqstp, struct nfsd_readargs *argp,
                                   argp->vec, argp->vlen,
                                   &resp->count);
 
-        return nfserr;
+        if (nfserr) return nfserr;
+        return nfserrno(vfs_getattr(resp->fh.fh_export->ex_mnt,
+                                    resp->fh.fh_dentry,
+                                    &resp->stat));
 }
 
 /*
@@ -165,7 +188,7 @@ nfsd_proc_write(struct svc_rqst *rqstp, struct nfsd_writeargs *argp,
                                    argp->vec, argp->vlen,
                                    argp->len,
                                    &stable);
-        return nfserr;
+        return nfsd_return_attrs(nfserr, resp);
 }
 
 /*
@@ -322,7 +345,7 @@ out_unlock:
 
 done:
         fh_put(dirfhp);
-        return nfserr;
+        return nfsd_return_dirop(nfserr, resp);
 }
 
 static int
@@ -425,7 +448,7 @@ nfsd_proc_mkdir(struct svc_rqst *rqstp, struct nfsd_createargs *argp,
         nfserr = nfsd_create(rqstp, &argp->fh, argp->name, argp->len,
                                     &argp->attrs, S_IFDIR, 0, &resp->fh);
         fh_put(&argp->fh);
-        return nfserr;
+        return nfsd_return_dirop(nfserr, resp);
 }
 
 /*
diff --git a/fs/nfsd/vfs.c b/fs/nfsd/vfs.c
index eef0576a7785..5320e5afaddb 100644
--- a/fs/nfsd/vfs.c
+++ b/fs/nfsd/vfs.c
@@ -710,14 +710,15 @@ static inline int nfsd_dosync(struct file *filp, struct dentry *dp,
 {
         struct inode *inode = dp->d_inode;
         int (*fsync) (struct file *, struct dentry *, int);
-        int err = nfs_ok;
+        int err;
 
-        filemap_fdatawrite(inode->i_mapping);
-        if (fop && (fsync = fop->fsync))
-                err=fsync(filp, dp, 0);
-        filemap_fdatawait(inode->i_mapping);
+        err = filemap_fdatawrite(inode->i_mapping);
+        if (err == 0 && fop && (fsync = fop->fsync))
+                err = fsync(filp, dp, 0);
+        if (err == 0)
+                err = filemap_fdatawait(inode->i_mapping);
 
-        return nfserrno(err);
+        return err;
 }
         
 
@@ -734,10 +735,10 @@ nfsd_sync(struct file *filp)
         return err;
 }
 
-void
+int
 nfsd_sync_dir(struct dentry *dp)
 {
-        nfsd_dosync(NULL, dp, dp->d_inode->i_fop);
+        return nfsd_dosync(NULL, dp, dp->d_inode->i_fop);
 }
 
 /*
@@ -814,7 +815,7 @@ nfsd_read_actor(read_descriptor_t *desc, struct page *page, unsigned long offset
         return size;
 }
 
-static inline int
+static int
 nfsd_vfs_read(struct svc_rqst *rqstp, struct svc_fh *fhp, struct file *file,
               loff_t offset, struct kvec *vec, int vlen, unsigned long *count)
 {
@@ -878,7 +879,7 @@ static void kill_suid(struct dentry *dentry)
         mutex_unlock(&dentry->d_inode->i_mutex);
 }
 
-static inline int
+static int
 nfsd_vfs_write(struct svc_rqst *rqstp, struct svc_fh *fhp, struct file *file,
                                 loff_t offset, struct kvec *vec, int vlen,
                                 unsigned long cnt, int *stablep)
@@ -890,9 +891,9 @@ nfsd_vfs_write(struct svc_rqst *rqstp, struct svc_fh *fhp, struct file *file,
         int                     err = 0;
         int                     stable = *stablep;
 
+#ifdef MSNFS
         err = nfserr_perm;
 
-#ifdef MSNFS
         if ((fhp->fh_export->ex_flags & NFSEXP_MSNFS) &&
                 (!lock_may_write(file->f_dentry->d_inode, offset, cnt)))
                 goto out;
@@ -1064,7 +1065,7 @@ nfsd_commit(struct svc_rqst *rqstp, struct svc_fh *fhp,
                 return err;
         if (EX_ISSYNC(fhp->fh_export)) {
                 if (file->f_op && file->f_op->fsync) {
-                        err = nfsd_sync(file);
+                        err = nfserrno(nfsd_sync(file));
                 } else {
                         err = nfserr_notsupp;
                 }
@@ -1132,7 +1133,7 @@ nfsd_create(struct svc_rqst *rqstp, struct svc_fh *fhp,
                                 "nfsd_create: parent %s/%s not locked!\n",
                                 dentry->d_parent->d_name.name,
                                 dentry->d_name.name);
-                        err = -EIO;
+                        err = nfserr_io;
                         goto out;
                 }
         }
@@ -1175,7 +1176,7 @@ nfsd_create(struct svc_rqst *rqstp, struct svc_fh *fhp,
                 goto out_nfserr;
 
         if (EX_ISSYNC(fhp->fh_export)) {
-                nfsd_sync_dir(dentry);
+                err = nfserrno(nfsd_sync_dir(dentry));
                 write_inode_now(dchild->d_inode, 1);
         }
 
@@ -1185,9 +1186,11 @@ nfsd_create(struct svc_rqst *rqstp, struct svc_fh *fhp,
          * send along the gid when it tries to implement setgid
          * directories via NFS.
          */
-        err = 0;
-        if ((iap->ia_valid &= ~(ATTR_UID|ATTR_GID|ATTR_MODE)) != 0)
-                err = nfsd_setattr(rqstp, resfhp, iap, 0, (time_t)0);
+        if ((iap->ia_valid &= ~(ATTR_UID|ATTR_GID|ATTR_MODE)) != 0) {
+                int err2 = nfsd_setattr(rqstp, resfhp, iap, 0, (time_t)0);
+                if (err2)
+                        err = err2;
+        }
         /*
          * Update the file handle to get the new inode info.
          */
@@ -1306,17 +1309,10 @@ nfsd_create_v3(struct svc_rqst *rqstp, struct svc_fh *fhp,
                 goto out_nfserr;
 
         if (EX_ISSYNC(fhp->fh_export)) {
-                nfsd_sync_dir(dentry);
+                err = nfserrno(nfsd_sync_dir(dentry));
                 /* setattr will sync the child (or not) */
         }
 
-        /*
-         * Update the filehandle to get the new inode info.
-         */
-        err = fh_update(resfhp);
-        if (err)
-                goto out;
-
         if (createmode == NFS3_CREATE_EXCLUSIVE) {
                 /* Cram the verifier into atime/mtime/mode */
                 iap->ia_valid = ATTR_MTIME|ATTR_ATIME
@@ -1337,8 +1333,17 @@ nfsd_create_v3(struct svc_rqst *rqstp, struct svc_fh *fhp,
          * implement setgid directories via NFS. Clear out all that cruft.
          */
  set_attr:
-        if ((iap->ia_valid &= ~(ATTR_UID|ATTR_GID)) != 0)
-                err = nfsd_setattr(rqstp, resfhp, iap, 0, (time_t)0);
+        if ((iap->ia_valid &= ~(ATTR_UID|ATTR_GID)) != 0) {
+                int err2 = nfsd_setattr(rqstp, resfhp, iap, 0, (time_t)0);
+                if (err2)
+                        err = err2;
+        }
+
+        /*
+         * Update the filehandle to get the new inode info.
+         */
+        if (!err)
+                err = fh_update(resfhp);
 
  out:
         fh_unlock(fhp);
@@ -1447,10 +1452,10 @@ nfsd_symlink(struct svc_rqst *rqstp, struct svc_fh *fhp,
         } else
                 err = vfs_symlink(dentry->d_inode, dnew, path, mode);
 
-        if (!err) {
+        if (!err)
                 if (EX_ISSYNC(fhp->fh_export))
-                        nfsd_sync_dir(dentry);
-        } else
+                        err = nfsd_sync_dir(dentry);
+        if (err)
                 err = nfserrno(err);
         fh_unlock(fhp);
 
@@ -1506,7 +1511,7 @@ nfsd_link(struct svc_rqst *rqstp, struct svc_fh *ffhp,
         err = vfs_link(dold, dirp, dnew);
         if (!err) {
                 if (EX_ISSYNC(ffhp->fh_export)) {
-                        nfsd_sync_dir(ddir);
+                        err = nfserrno(nfsd_sync_dir(ddir));
                         write_inode_now(dest, 1);
                 }
         } else {
@@ -1590,13 +1595,14 @@ nfsd_rename(struct svc_rqst *rqstp, struct svc_fh *ffhp, char *fname, int flen,
         if ((ffhp->fh_export->ex_flags & NFSEXP_MSNFS) &&
                 ((atomic_read(&odentry->d_count) > 1)
                  || (atomic_read(&ndentry->d_count) > 1))) {
-                        err = nfserr_perm;
+                        err = -EPERM;
         } else
 #endif
         err = vfs_rename(fdir, odentry, tdir, ndentry);
         if (!err && EX_ISSYNC(tfhp->fh_export)) {
-                nfsd_sync_dir(tdentry);
-                nfsd_sync_dir(fdentry);
+                err = nfsd_sync_dir(tdentry);
+                if (!err)
+                        err = nfsd_sync_dir(fdentry);
         }
 
  out_dput_new:
@@ -1661,7 +1667,7 @@ nfsd_unlink(struct svc_rqst *rqstp, struct svc_fh *fhp, int type,
 #ifdef MSNFS
                 if ((fhp->fh_export->ex_flags & NFSEXP_MSNFS) &&
                         (atomic_read(&rdentry->d_count) > 1)) {
-                        err = nfserr_perm;
+                        err = -EPERM;
                 } else
 #endif
                 err = vfs_unlink(dirp, rdentry);
@@ -1671,17 +1677,14 @@ nfsd_unlink(struct svc_rqst *rqstp, struct svc_fh *fhp, int type,
 
         dput(rdentry);
 
-        if (err)
-                goto out_nfserr;
-        if (EX_ISSYNC(fhp->fh_export)) 
-                nfsd_sync_dir(dentry);
-
-out:
-        return err;
+        if (err == 0 &&
+            EX_ISSYNC(fhp->fh_export))
+                        err = nfsd_sync_dir(dentry);
 
 out_nfserr:
         err = nfserrno(err);
-        goto out;
+out:
+        return err;
 }
 
 /*
diff --git a/fs/open.c b/fs/open.c
index 8e20c1f32563..70e0230d8e77 100644
--- a/fs/open.c
+++ b/fs/open.c
@@ -20,6 +20,7 @@
 #include <linux/security.h>
 #include <linux/mount.h>
 #include <linux/vfs.h>
+#include <linux/fcntl.h>
 #include <asm/uaccess.h>
 #include <linux/fs.h>
 #include <linux/personality.h>
@@ -383,7 +384,7 @@ asmlinkage long sys_utime(char __user * filename, struct utimbuf __user * times)
 
                 error = get_user(newattrs.ia_atime.tv_sec, &times->actime);
                 newattrs.ia_atime.tv_nsec = 0;
-                if (!error) 
+                if (!error)
                         error = get_user(newattrs.ia_mtime.tv_sec, &times->modtime);
                 newattrs.ia_mtime.tv_nsec = 0;
                 if (error)
@@ -414,14 +415,14 @@ out:
  * must be owner or have write permission.
  * Else, update from *times, must be owner or super user.
  */
-long do_utimes(char __user * filename, struct timeval * times)
+long do_utimes(int dfd, char __user *filename, struct timeval *times)
 {
         int error;
         struct nameidata nd;
         struct inode * inode;
         struct iattr newattrs;
 
-        error = user_path_walk(filename, &nd);
+        error = __user_walk_fd(dfd, filename, LOOKUP_FOLLOW, &nd);
 
         if (error)
                 goto out;
@@ -461,13 +462,18 @@ out:
         return error;
 }
 
-asmlinkage long sys_utimes(char __user * filename, struct timeval __user * utimes)
+asmlinkage long sys_futimesat(int dfd, char __user *filename, struct timeval __user *utimes)
 {
         struct timeval times[2];
 
         if (utimes && copy_from_user(&times, utimes, sizeof(times)))
                 return -EFAULT;
-        return do_utimes(filename, utimes ? times : NULL);
+        return do_utimes(dfd, filename, utimes ? times : NULL);
+}
+
+asmlinkage long sys_utimes(char __user *filename, struct timeval __user *utimes)
+{
+        return sys_futimesat(AT_FDCWD, filename, utimes);
 }
 
 
@@ -476,7 +482,7 @@ asmlinkage long sys_utimes(char __user * filename, struct timeval __user * utime
  * We do this by temporarily clearing all FS-related capabilities and
  * switching the fsuid/fsgid around to the real ones.
  */
-asmlinkage long sys_access(const char __user * filename, int mode)
+asmlinkage long sys_faccessat(int dfd, const char __user *filename, int mode)
 {
         struct nameidata nd;
         int old_fsuid, old_fsgid;
@@ -506,7 +512,7 @@ asmlinkage long sys_access(const char __user * filename, int mode)
         else
                 current->cap_effective = current->cap_permitted;
 
-        res = __user_walk(filename, LOOKUP_FOLLOW|LOOKUP_ACCESS, &nd);
+        res = __user_walk_fd(dfd, filename, LOOKUP_FOLLOW|LOOKUP_ACCESS, &nd);
         if (!res) {
                 res = vfs_permission(&nd, mode);
                 /* SuS v2 requires we report a read only fs too */
@@ -523,6 +529,11 @@ asmlinkage long sys_access(const char __user * filename, int mode)
         return res;
 }
 
+asmlinkage long sys_access(const char __user *filename, int mode)
+{
+        return sys_faccessat(AT_FDCWD, filename, mode);
+}
+
 asmlinkage long sys_chdir(const char __user * filename)
 {
         struct nameidata nd;
@@ -635,14 +646,15 @@ out:
         return err;
 }
 
-asmlinkage long sys_chmod(const char __user * filename, mode_t mode)
+asmlinkage long sys_fchmodat(int dfd, const char __user *filename,
+                             mode_t mode)
 {
         struct nameidata nd;
         struct inode * inode;
         int error;
         struct iattr newattrs;
 
-        error = user_path_walk(filename, &nd);
+        error = __user_walk_fd(dfd, filename, LOOKUP_FOLLOW, &nd);
         if (error)
                 goto out;
         inode = nd.dentry->d_inode;
@@ -669,6 +681,11 @@ out:
         return error;
 }
 
+asmlinkage long sys_chmod(const char __user *filename, mode_t mode)
+{
+        return sys_fchmodat(AT_FDCWD, filename, mode);
+}
+
 static int chown_common(struct dentry * dentry, uid_t user, gid_t group)
 {
         struct inode * inode;
@@ -717,6 +734,26 @@ asmlinkage long sys_chown(const char __user * filename, uid_t user, gid_t group)
         return error;
 }
 
+asmlinkage long sys_fchownat(int dfd, const char __user *filename, uid_t user,
+                             gid_t group, int flag)
+{
+        struct nameidata nd;
+        int error = -EINVAL;
+        int follow;
+
+        if ((flag & ~AT_SYMLINK_NOFOLLOW) != 0)
+                goto out;
+
+        follow = (flag & AT_SYMLINK_NOFOLLOW) ? 0 : LOOKUP_FOLLOW;
+        error = __user_walk_fd(dfd, filename, follow, &nd);
+        if (!error) {
+                error = chown_common(nd.dentry, user, group);
+                path_release(&nd);
+        }
+out:
+        return error;
+}
+
 asmlinkage long sys_lchown(const char __user * filename, uid_t user, gid_t group)
 {
         struct nameidata nd;
@@ -820,7 +857,8 @@ cleanup_file:
  * for the internal routines (ie open_namei()/follow_link() etc). 00 is
  * used by symlinks.
  */
-struct file *filp_open(const char * filename, int flags, int mode)
+static struct file *do_filp_open(int dfd, const char *filename, int flags,
+                                 int mode)
 {
         int namei_flags, error;
         struct nameidata nd;
@@ -829,12 +867,17 @@ struct file *filp_open(const char * filename, int flags, int mode)
         if ((namei_flags+1) & O_ACCMODE)
                 namei_flags++;
 
-        error = open_namei(filename, namei_flags, mode, &nd);
+        error = open_namei(dfd, filename, namei_flags, mode, &nd);
         if (!error)
                 return nameidata_to_filp(&nd, flags);
 
         return ERR_PTR(error);
 }
+
+struct file *filp_open(const char *filename, int flags, int mode)
+{
+        return do_filp_open(AT_FDCWD, filename, flags, mode);
+}
 EXPORT_SYMBOL(filp_open);
 
 /**
@@ -991,7 +1034,7 @@ void fastcall put_unused_fd(unsigned int fd)
 EXPORT_SYMBOL(put_unused_fd);
 
 /*
- * Install a file pointer in the fd array.  
+ * Install a file pointer in the fd array.
  *
  * The VFS is full of places where we drop the files lock between
  * setting the open_fds bitmap and installing the file in the file
@@ -1016,7 +1059,7 @@ void fastcall fd_install(unsigned int fd, struct file * file)
 
 EXPORT_SYMBOL(fd_install);
 
-long do_sys_open(const char __user *filename, int flags, int mode)
+long do_sys_open(int dfd, const char __user *filename, int flags, int mode)
 {
         char *tmp = getname(filename);
         int fd = PTR_ERR(tmp);
@@ -1024,7 +1067,7 @@ long do_sys_open(const char __user *filename, int flags, int mode)
         if (!IS_ERR(tmp)) {
                 fd = get_unused_fd();
                 if (fd >= 0) {
-                        struct file *f = filp_open(tmp, flags, mode);
+                        struct file *f = do_filp_open(dfd, tmp, flags, mode);
                         if (IS_ERR(f)) {
                                 put_unused_fd(fd);
                                 fd = PTR_ERR(f);
@@ -1043,10 +1086,20 @@ asmlinkage long sys_open(const char __user *filename, int flags, int mode)
         if (force_o_largefile())
                 flags |= O_LARGEFILE;
 
-        return do_sys_open(filename, flags, mode);
+        return do_sys_open(AT_FDCWD, filename, flags, mode);
 }
 EXPORT_SYMBOL_GPL(sys_open);
 
+asmlinkage long sys_openat(int dfd, const char __user *filename, int flags,
+                           int mode)
+{
+        if (force_o_largefile())
+                flags |= O_LARGEFILE;
+
+        return do_sys_open(dfd, filename, flags, mode);
+}
+EXPORT_SYMBOL_GPL(sys_openat);
+
 #ifndef __alpha__
 
 /*
diff --git a/fs/select.c b/fs/select.c
index f10a10317d54..c0f02d36c60e 100644
--- a/fs/select.c
+++ b/fs/select.c
@@ -179,12 +179,11 @@ get_max:
 #define POLLOUT_SET (POLLWRBAND | POLLWRNORM | POLLOUT | POLLERR)
 #define POLLEX_SET (POLLPRI)
 
-int do_select(int n, fd_set_bits *fds, long *timeout)
+int do_select(int n, fd_set_bits *fds, s64 *timeout)
 {
         struct poll_wqueues table;
         poll_table *wait;
         int retval, i;
-        long __timeout = *timeout;
 
         rcu_read_lock();
         retval = max_select_fd(n, fds);
@@ -196,11 +195,12 @@ int do_select(int n, fd_set_bits *fds, long *timeout)
 
         poll_initwait(&table);
         wait = &table.pt;
-        if (!__timeout)
+        if (!*timeout)
                 wait = NULL;
         retval = 0;
         for (;;) {
                 unsigned long *rinp, *routp, *rexp, *inp, *outp, *exp;
+                long __timeout;
 
                 set_current_state(TASK_INTERRUPTIBLE);
 
@@ -255,22 +255,32 @@ int do_select(int n, fd_set_bits *fds, long *timeout)
                                 *rexp = res_ex;
                 }
                 wait = NULL;
-                if (retval || !__timeout || signal_pending(current))
+                if (retval || !*timeout || signal_pending(current))
                         break;
                 if(table.error) {
                         retval = table.error;
                         break;
                 }
+
+                if (*timeout < 0) {
+                        /* Wait indefinitely */
+                        __timeout = MAX_SCHEDULE_TIMEOUT;
+                } else if (unlikely(*timeout >= (s64)MAX_SCHEDULE_TIMEOUT - 1)) {
+                        /* Wait for longer than MAX_SCHEDULE_TIMEOUT. Do it in a loop */
+                        __timeout = MAX_SCHEDULE_TIMEOUT - 1;
+                        *timeout -= __timeout;
+                } else {
+                        __timeout = *timeout;
+                        *timeout = 0;
+                }
                 __timeout = schedule_timeout(__timeout);
+                if (*timeout >= 0)
+                        *timeout += __timeout;
         }
         __set_current_state(TASK_RUNNING);
 
         poll_freewait(&table);
 
-        /*
-         * Up-to-date the caller timeout.
-         */
-        *timeout = __timeout;
         return retval;
 }
 
@@ -295,36 +305,14 @@ static void select_bits_free(void *bits, int size)
 #define MAX_SELECT_SECONDS \
         ((unsigned long) (MAX_SCHEDULE_TIMEOUT / HZ)-1)
 
-asmlinkage long
-sys_select(int n, fd_set __user *inp, fd_set __user *outp, fd_set __user *exp, struct timeval __user *tvp)
+static int core_sys_select(int n, fd_set __user *inp, fd_set __user *outp,
+                           fd_set __user *exp, s64 *timeout)
 {
         fd_set_bits fds;
         char *bits;
-        long timeout;
         int ret, size, max_fdset;
         struct fdtable *fdt;
 
-        timeout = MAX_SCHEDULE_TIMEOUT;
-        if (tvp) {
-                time_t sec, usec;
-
-                if (!access_ok(VERIFY_READ, tvp, sizeof(*tvp))
-                    || __get_user(sec, &tvp->tv_sec)
-                    || __get_user(usec, &tvp->tv_usec)) {
-                        ret = -EFAULT;
-                        goto out_nofds;
-                }
-
-                ret = -EINVAL;
-                if (sec < 0 || usec < 0)
-                        goto out_nofds;
-
-                if ((unsigned long) sec < MAX_SELECT_SECONDS) {
-                        timeout = ROUND_UP(usec, 1000000/HZ);
-                        timeout += sec * (unsigned long) HZ;
-                }
-        }
-
         ret = -EINVAL;
         if (n < 0)
                 goto out_nofds;
@@ -362,18 +350,7 @@ sys_select(int n, fd_set __user *inp, fd_set __user *outp, fd_set __user *exp, s
         zero_fd_set(n, fds.res_out);
         zero_fd_set(n, fds.res_ex);
 
-        ret = do_select(n, &fds, &timeout);
-
-        if (tvp && !(current->personality & STICKY_TIMEOUTS)) {
-                time_t sec = 0, usec = 0;
-                if (timeout) {
-                        sec = timeout / HZ;
-                        usec = timeout % HZ;
-                        usec *= (1000000/HZ);
-                }
-                put_user(sec, &tvp->tv_sec);
-                put_user(usec, &tvp->tv_usec);
-        }
+        ret = do_select(n, &fds, timeout);
 
         if (ret < 0)
                 goto out;
@@ -395,6 +372,154 @@ out_nofds:
         return ret;
 }
 
+asmlinkage long sys_select(int n, fd_set __user *inp, fd_set __user *outp,
+                        fd_set __user *exp, struct timeval __user *tvp)
+{
+        s64 timeout = -1;
+        struct timeval tv;
+        int ret;
+
+        if (tvp) {
+                if (copy_from_user(&tv, tvp, sizeof(tv)))
+                        return -EFAULT;
+
+                if (tv.tv_sec < 0 || tv.tv_usec < 0)
+                        return -EINVAL;
+
+                /* Cast to u64 to make GCC stop complaining */
+                if ((u64)tv.tv_sec >= (u64)MAX_INT64_SECONDS)
+                        timeout = -1;   /* infinite */
+                else {
+                        timeout = ROUND_UP(tv.tv_usec, USEC_PER_SEC/HZ);
+                        timeout += tv.tv_sec * HZ;
+                }
+        }
+
+        ret = core_sys_select(n, inp, outp, exp, &timeout);
+
+        if (tvp) {
+                if (current->personality & STICKY_TIMEOUTS)
+                        goto sticky;
+                tv.tv_usec = jiffies_to_usecs(do_div((*(u64*)&timeout), HZ));
+                tv.tv_sec = timeout;
+                if (copy_to_user(tvp, &tv, sizeof(tv))) {
+sticky:
+                        /*
+                         * If an application puts its timeval in read-only
+                         * memory, we don't want the Linux-specific update to
+                         * the timeval to cause a fault after the select has
+                         * completed successfully. However, because we're not
+                         * updating the timeval, we can't restart the system
+                         * call.
+                         */
+                        if (ret == -ERESTARTNOHAND)
+                                ret = -EINTR;
+                }
+        }
+
+        return ret;
+}
+
+#ifdef TIF_RESTORE_SIGMASK
+asmlinkage long sys_pselect7(int n, fd_set __user *inp, fd_set __user *outp,
+                fd_set __user *exp, struct timespec __user *tsp,
+                const sigset_t __user *sigmask, size_t sigsetsize)
+{
+        s64 timeout = MAX_SCHEDULE_TIMEOUT;
+        sigset_t ksigmask, sigsaved;
+        struct timespec ts;
+        int ret;
+
+        if (tsp) {
+                if (copy_from_user(&ts, tsp, sizeof(ts)))
+                        return -EFAULT;
+
+                if (ts.tv_sec < 0 || ts.tv_nsec < 0)
+                        return -EINVAL;
+
+                /* Cast to u64 to make GCC stop complaining */
+                if ((u64)ts.tv_sec >= (u64)MAX_INT64_SECONDS)
+                        timeout = -1;   /* infinite */
+                else {
+                        timeout = ROUND_UP(ts.tv_nsec, NSEC_PER_SEC/HZ);
+                        timeout += ts.tv_sec * HZ;
+                }
+        }
+
+        if (sigmask) {
+                /* XXX: Don't preclude handling different sized sigset_t's.  */
+                if (sigsetsize != sizeof(sigset_t))
+                        return -EINVAL;
+                if (copy_from_user(&ksigmask, sigmask, sizeof(ksigmask)))
+                        return -EFAULT;
+
+                sigdelsetmask(&ksigmask, sigmask(SIGKILL)|sigmask(SIGSTOP));
+                sigprocmask(SIG_SETMASK, &ksigmask, &sigsaved);
+        }
+
+        ret = core_sys_select(n, inp, outp, exp, &timeout);
+
+        if (tsp) {
+                if (current->personality & STICKY_TIMEOUTS)
+                        goto sticky;
+                ts.tv_nsec = jiffies_to_usecs(do_div((*(u64*)&timeout), HZ)) * 1000;
+                ts.tv_sec = timeout;
+                if (copy_to_user(tsp, &ts, sizeof(ts))) {
+sticky:
+                        /*
+                         * If an application puts its timeval in read-only
+                         * memory, we don't want the Linux-specific update to
+                         * the timeval to cause a fault after the select has
+                         * completed successfully. However, because we're not
+                         * updating the timeval, we can't restart the system
+                         * call.
+                         */
+                        if (ret == -ERESTARTNOHAND)
+                                ret = -EINTR;
+                }
+        }
+
+        if (ret == -ERESTARTNOHAND) {
+                /*
+                 * Don't restore the signal mask yet. Let do_signal() deliver
+                 * the signal on the way back to userspace, before the signal
+                 * mask is restored.
+                 */
+                if (sigmask) {
+                        memcpy(&current->saved_sigmask, &sigsaved,
+                                        sizeof(sigsaved));
+                        set_thread_flag(TIF_RESTORE_SIGMASK);
+                }
+        } else if (sigmask)
+                sigprocmask(SIG_SETMASK, &sigsaved, NULL);
+
+        return ret;
+}
+
+/*
+ * Most architectures can't handle 7-argument syscalls. So we provide a
+ * 6-argument version where the sixth argument is a pointer to a structure
+ * which has a pointer to the sigset_t itself followed by a size_t containing
+ * the sigset size.
+ */
+asmlinkage long sys_pselect6(int n, fd_set __user *inp, fd_set __user *outp,
+        fd_set __user *exp, struct timespec __user *tsp, void __user *sig)
+{
+        size_t sigsetsize = 0;
+        sigset_t __user *up = NULL;
+
+        if (sig) {
+                if (!access_ok(VERIFY_READ, sig, sizeof(void *)+sizeof(size_t))
+                    || __get_user(up, (sigset_t * __user *)sig)
+                    || __get_user(sigsetsize,
+                                (size_t * __user)(sig+sizeof(void *))))
+                        return -EFAULT;
+        }
+
+        return sys_pselect7(n, inp, outp, exp, tsp, up, sigsetsize);
+}
+#endif /* TIF_RESTORE_SIGMASK */
+
 struct poll_list {
         struct poll_list *next;
         int len;
@@ -436,16 +561,19 @@ static void do_pollfd(unsigned int num, struct pollfd * fdpage,
 }
 
 static int do_poll(unsigned int nfds,  struct poll_list *list,
-                        struct poll_wqueues *wait, long timeout)
+                   struct poll_wqueues *wait, s64 *timeout)
 {
         int count = 0;
         poll_table* pt = &wait->pt;
 
-        if (!timeout)
+        /* Optimise the no-wait case */
+        if (!(*timeout))
                 pt = NULL;
  
         for (;;) {
                 struct poll_list *walk;
+                long __timeout;
+
                 set_current_state(TASK_INTERRUPTIBLE);
                 walk = list;
                 while(walk != NULL) {
@@ -453,18 +581,36 @@ static int do_poll(unsigned int nfds,  struct poll_list *list,
                         walk = walk->next;
                 }
                 pt = NULL;
-                if (count || !timeout || signal_pending(current))
+                if (count || !*timeout || signal_pending(current))
                         break;
                 count = wait->error;
                 if (count)
                         break;
-                timeout = schedule_timeout(timeout);
+
+                if (*timeout < 0) {
+                        /* Wait indefinitely */
+                        __timeout = MAX_SCHEDULE_TIMEOUT;
+                } else if (unlikely(*timeout >= (s64)MAX_SCHEDULE_TIMEOUT-1)) {
+                        /*
+                         * Wait for longer than MAX_SCHEDULE_TIMEOUT. Do it in
+                         * a loop
+                         */
+                        __timeout = MAX_SCHEDULE_TIMEOUT - 1;
+                        *timeout -= __timeout;
+                } else {
+                        __timeout = *timeout;
+                        *timeout = 0;
+                }
+
+                __timeout = schedule_timeout(__timeout);
+                if (*timeout >= 0)
+                        *timeout += __timeout;
         }
         __set_current_state(TASK_RUNNING);
         return count;
 }
 
-asmlinkage long sys_poll(struct pollfd __user * ufds, unsigned int nfds, long timeout)
+int do_sys_poll(struct pollfd __user *ufds, unsigned int nfds, s64 *timeout)
 {
         struct poll_wqueues table;
         int fdcount, err;
@@ -482,14 +628,6 @@ asmlinkage long sys_poll(struct pollfd __user * ufds, unsigned int nfds, long ti
         if (nfds > max_fdset && nfds > OPEN_MAX)
                 return -EINVAL;
 
-        if (timeout) {
-                /* Careful about overflow in the intermediate values */
-                if ((unsigned long) timeout < MAX_SCHEDULE_TIMEOUT / HZ)
-                        timeout = (unsigned long)(timeout*HZ+999)/1000+1;
-                else /* Negative or overflow */
-                        timeout = MAX_SCHEDULE_TIMEOUT;
-        }
-
         poll_initwait(&table);
 
         head = NULL;
@@ -519,6 +657,7 @@ asmlinkage long sys_poll(struct pollfd __user * ufds, unsigned int nfds, long ti
                 }
                 i -= pp->len;
         }
+
         fdcount = do_poll(nfds, head, &table, timeout);
 
         /* OK, now copy the revents fields back to user space. */
@@ -547,3 +686,98 @@ out_fds:
         poll_freewait(&table);
         return err;
 }
+
+asmlinkage long sys_poll(struct pollfd __user *ufds, unsigned int nfds,
+                        long timeout_msecs)
+{
+        s64 timeout_jiffies = 0;
+
+        if (timeout_msecs) {
+#if HZ > 1000
+                /* We can only overflow if HZ > 1000 */
+                if (timeout_msecs / 1000 > (s64)0x7fffffffffffffffULL / (s64)HZ)
+                        timeout_jiffies = -1;
+                else
+#endif
+                        timeout_jiffies = msecs_to_jiffies(timeout_msecs);
+        }
+
+        return do_sys_poll(ufds, nfds, &timeout_jiffies);
+}
+
+#ifdef TIF_RESTORE_SIGMASK
+asmlinkage long sys_ppoll(struct pollfd __user *ufds, unsigned int nfds,
+        struct timespec __user *tsp, const sigset_t __user *sigmask,
+        size_t sigsetsize)
+{
+        sigset_t ksigmask, sigsaved;
+        struct timespec ts;
+        s64 timeout = -1;
+        int ret;
+
+        if (tsp) {
+                if (copy_from_user(&ts, tsp, sizeof(ts)))
+                        return -EFAULT;
+
+                /* Cast to u64 to make GCC stop complaining */
+                if ((u64)ts.tv_sec >= (u64)MAX_INT64_SECONDS)
+                        timeout = -1;   /* infinite */
+                else {
+                        timeout = ROUND_UP(ts.tv_nsec, NSEC_PER_SEC/HZ);
+                        timeout += ts.tv_sec * HZ;
+                }
+        }
+
+        if (sigmask) {
+                /* XXX: Don't preclude handling different sized sigset_t's.  */
+                if (sigsetsize != sizeof(sigset_t))
+                        return -EINVAL;
+                if (copy_from_user(&ksigmask, sigmask, sizeof(ksigmask)))
+                        return -EFAULT;
+
+                sigdelsetmask(&ksigmask, sigmask(SIGKILL)|sigmask(SIGSTOP));
+                sigprocmask(SIG_SETMASK, &ksigmask, &sigsaved);
+        }
+
+        ret = do_sys_poll(ufds, nfds, &timeout);
+
+        /* We can restart this syscall, usually */
+        if (ret == -EINTR) {
+                /*
+                 * Don't restore the signal mask yet. Let do_signal() deliver
+                 * the signal on the way back to userspace, before the signal
+                 * mask is restored.
+                 */
+                if (sigmask) {
+                        memcpy(&current->saved_sigmask, &sigsaved,
+                                        sizeof(sigsaved));
+                        set_thread_flag(TIF_RESTORE_SIGMASK);
+                }
+                ret = -ERESTARTNOHAND;
+        } else if (sigmask)
+                sigprocmask(SIG_SETMASK, &sigsaved, NULL);
+
+        if (tsp && timeout >= 0) {
+                if (current->personality & STICKY_TIMEOUTS)
+                        goto sticky;
+                /* Yes, we know it's actually an s64, but it's also positive. */
+                ts.tv_nsec = jiffies_to_usecs(do_div((*(u64*)&timeout), HZ)) * 1000;
+                ts.tv_sec = timeout;
+                if (copy_to_user(tsp, &ts, sizeof(ts))) {
+                sticky:
+                        /*
+                         * If an application puts its timeval in read-only
+                         * memory, we don't want the Linux-specific update to
+                         * the timeval to cause a fault after the select has
+                         * completed successfully. However, because we're not
+                         * updating the timeval, we can't restart the system
+                         * call.
+                         */
+                        if (ret == -ERESTARTNOHAND && timeout >= 0)
+                                ret = -EINTR;
+                }
+        }
+
+        return ret;
+}
+#endif /* TIF_RESTORE_SIGMASK */
diff --git a/fs/stat.c b/fs/stat.c
index b8a0e5110ab2..24211b030f39 100644
--- a/fs/stat.c
+++ b/fs/stat.c
@@ -63,12 +63,12 @@ int vfs_getattr(struct vfsmount *mnt, struct dentry *dentry, struct kstat *stat)
 
 EXPORT_SYMBOL(vfs_getattr);
 
-int vfs_stat(char __user *name, struct kstat *stat)
+int vfs_stat_fd(int dfd, char __user *name, struct kstat *stat)
 {
         struct nameidata nd;
         int error;
 
-        error = user_path_walk(name, &nd);
+        error = __user_walk_fd(dfd, name, LOOKUP_FOLLOW, &nd);
         if (!error) {
                 error = vfs_getattr(nd.mnt, nd.dentry, stat);
                 path_release(&nd);
@@ -76,14 +76,19 @@ int vfs_stat(char __user *name, struct kstat *stat)
         return error;
 }
 
+int vfs_stat(char __user *name, struct kstat *stat)
+{
+        return vfs_stat_fd(AT_FDCWD, name, stat);
+}
+
 EXPORT_SYMBOL(vfs_stat);
 
-int vfs_lstat(char __user *name, struct kstat *stat)
+int vfs_lstat_fd(int dfd, char __user *name, struct kstat *stat)
 {
         struct nameidata nd;
         int error;
 
-        error = user_path_walk_link(name, &nd);
+        error = __user_walk_fd(dfd, name, 0, &nd);
         if (!error) {
                 error = vfs_getattr(nd.mnt, nd.dentry, stat);
                 path_release(&nd);
@@ -91,6 +96,11 @@ int vfs_lstat(char __user *name, struct kstat *stat)
         return error;
 }
 
+int vfs_lstat(char __user *name, struct kstat *stat)
+{
+        return vfs_lstat_fd(AT_FDCWD, name, stat);
+}
+
 EXPORT_SYMBOL(vfs_lstat);
 
 int vfs_fstat(unsigned int fd, struct kstat *stat)
@@ -151,7 +161,7 @@ static int cp_old_stat(struct kstat *stat, struct __old_kernel_stat __user * sta
 asmlinkage long sys_stat(char __user * filename, struct __old_kernel_stat __user * statbuf)
 {
         struct kstat stat;
-        int error = vfs_stat(filename, &stat);
+        int error = vfs_stat_fd(AT_FDCWD, filename, &stat);
 
         if (!error)
                 error = cp_old_stat(&stat, statbuf);
@@ -161,7 +171,7 @@ asmlinkage long sys_stat(char __user * filename, struct __old_kernel_stat __user
 asmlinkage long sys_lstat(char __user * filename, struct __old_kernel_stat __user * statbuf)
 {
         struct kstat stat;
-        int error = vfs_lstat(filename, &stat);
+        int error = vfs_lstat_fd(AT_FDCWD, filename, &stat);
 
         if (!error)
                 error = cp_old_stat(&stat, statbuf);
@@ -229,27 +239,50 @@ static int cp_new_stat(struct kstat *stat, struct stat __user *statbuf)
         return copy_to_user(statbuf,&tmp,sizeof(tmp)) ? -EFAULT : 0;
 }
 
-asmlinkage long sys_newstat(char __user * filename, struct stat __user * statbuf)
+asmlinkage long sys_newstat(char __user *filename, struct stat __user *statbuf)
 {
         struct kstat stat;
-        int error = vfs_stat(filename, &stat);
+        int error = vfs_stat_fd(AT_FDCWD, filename, &stat);
 
         if (!error)
                 error = cp_new_stat(&stat, statbuf);
 
         return error;
 }
-asmlinkage long sys_newlstat(char __user * filename, struct stat __user * statbuf)
+
+asmlinkage long sys_newlstat(char __user *filename, struct stat __user *statbuf)
 {
         struct kstat stat;
-        int error = vfs_lstat(filename, &stat);
+        int error = vfs_lstat_fd(AT_FDCWD, filename, &stat);
 
         if (!error)
                 error = cp_new_stat(&stat, statbuf);
 
         return error;
 }
-asmlinkage long sys_newfstat(unsigned int fd, struct stat __user * statbuf)
+
+asmlinkage long sys_newfstatat(int dfd, char __user *filename,
+                                struct stat __user *statbuf, int flag)
+{
+        struct kstat stat;
+        int error = -EINVAL;
+
+        if ((flag & ~AT_SYMLINK_NOFOLLOW) != 0)
+                goto out;
+
+        if (flag & AT_SYMLINK_NOFOLLOW)
+                error = vfs_lstat_fd(dfd, filename, &stat);
+        else
+                error = vfs_stat_fd(dfd, filename, &stat);
+
+        if (!error)
+                error = cp_new_stat(&stat, statbuf);
+
+out:
+        return error;
+}
+
+asmlinkage long sys_newfstat(unsigned int fd, struct stat __user *statbuf)
 {
         struct kstat stat;
         int error = vfs_fstat(fd, &stat);
@@ -260,7 +293,8 @@ asmlinkage long sys_newfstat(unsigned int fd, struct stat __user * statbuf)
         return error;
 }
 
-asmlinkage long sys_readlink(const char __user * path, char __user * buf, int bufsiz)
+asmlinkage long sys_readlinkat(int dfd, const char __user *path,
+                                char __user *buf, int bufsiz)
 {
         struct nameidata nd;
         int error;
@@ -268,7 +302,7 @@ asmlinkage long sys_readlink(const char __user * path, char __user * buf, int bu
         if (bufsiz <= 0)
                 return -EINVAL;
 
-        error = user_path_walk_link(path, &nd);
+        error = __user_walk_fd(dfd, path, 0, &nd);
         if (!error) {
                 struct inode * inode = nd.dentry->d_inode;
 
@@ -285,6 +319,12 @@ asmlinkage long sys_readlink(const char __user * path, char __user * buf, int bu
         return error;
 }
 
+asmlinkage long sys_readlink(const char __user *path, char __user *buf,
+                                int bufsiz)
+{
+        return sys_readlinkat(AT_FDCWD, path, buf, bufsiz);
+}
+
 
 /* ---------- LFS-64 ----------- */
 #ifdef __ARCH_WANT_STAT64
diff --git a/fs/xfs/linux-2.6/xfs_aops.c b/fs/xfs/linux-2.6/xfs_aops.c
index d1db8c17a74e..120626789406 100644
--- a/fs/xfs/linux-2.6/xfs_aops.c
+++ b/fs/xfs/linux-2.6/xfs_aops.c
@@ -336,24 +336,47 @@ static inline int bio_add_buffer(struct bio *bio, struct buffer_head *bh)
 }
 
 /*
- * Submit all of the bios for all of the ioends we have saved up,
- * covering the initial writepage page and also any probed pages.
+ * Submit all of the bios for all of the ioends we have saved up, covering the
+ * initial writepage page and also any probed pages.
+ *
+ * Because we may have multiple ioends spanning a page, we need to start
+ * writeback on all the buffers before we submit them for I/O. If we mark the
+ * buffers as we got, then we can end up with a page that only has buffers
+ * marked async write and I/O complete on can occur before we mark the other
+ * buffers async write.
+ *
+ * The end result of this is that we trip a bug in end_page_writeback() because
+ * we call it twice for the one page as the code in end_buffer_async_write()
+ * assumes that all buffers on the page are started at the same time.
+ *
+ * The fix is two passes across the ioend list - one to start writeback on the
+ * bufferheads, and then the second one submit them for I/O.
  */
 STATIC void
 xfs_submit_ioend(
         xfs_ioend_t             *ioend)
 {
+        xfs_ioend_t             *head = ioend;
         xfs_ioend_t             *next;
         struct buffer_head      *bh;
         struct bio              *bio;
         sector_t                lastblock = 0;
 
+        /* Pass 1 - start writeback */
+        do {
+                next = ioend->io_list;
+                for (bh = ioend->io_buffer_head; bh; bh = bh->b_private) {
+                        xfs_start_buffer_writeback(bh);
+                }
+        } while ((ioend = next) != NULL);
+
+        /* Pass 2 - submit I/O */
+        ioend = head;
         do {
                 next = ioend->io_list;
                 bio = NULL;
 
                 for (bh = ioend->io_buffer_head; bh; bh = bh->b_private) {
-                        xfs_start_buffer_writeback(bh);
 
                         if (!bio) {
  retry: