+
+For more information, see <http://unionfs.filesystems.org/>.
diff --git a/MAINTAINERS b/MAINTAINERS
-index 560ecce..09e38d6 100644
+index 9a648eb..81b24a8 100644
--- a/MAINTAINERS
+++ b/MAINTAINERS
-@@ -6276,6 +6276,14 @@ F: Documentation/cdrom/
+@@ -6765,6 +6765,14 @@ F: Documentation/cdrom/
F: drivers/cdrom/cdrom.c
F: include/linux/cdrom.h
M: Artem Bityutskiy <dedekind1@gmail.com>
W: http://www.linux-mtd.infradead.org/
diff --git a/fs/Kconfig b/fs/Kconfig
-index 3db9caa..3dc2dfd 100644
+index d621f02..c12677d 100644
--- a/fs/Kconfig
+++ b/fs/Kconfig
-@@ -170,6 +170,7 @@ if MISC_FILESYSTEMS
+@@ -194,6 +194,7 @@ if MISC_FILESYSTEMS
source "fs/adfs/Kconfig"
source "fs/affs/Kconfig"
source "fs/ecryptfs/Kconfig"
source "fs/hfsplus/Kconfig"
source "fs/befs/Kconfig"
diff --git a/fs/Makefile b/fs/Makefile
-index a7f7cef..672664b 100644
+index 93804d4..3ff10bb 100644
--- a/fs/Makefile
+++ b/fs/Makefile
-@@ -81,6 +81,7 @@ obj-$(CONFIG_ISO9660_FS) += isofs/
+@@ -83,6 +83,7 @@ obj-$(CONFIG_ISO9660_FS) += isofs/
obj-$(CONFIG_HFSPLUS_FS) += hfsplus/ # Before hfs to find wrapped HFS+
obj-$(CONFIG_HFS_FS) += hfs/
obj-$(CONFIG_ECRYPT_FS) += ecryptfs/
obj-$(CONFIG_NFS_FS) += nfs/
obj-$(CONFIG_EXPORTFS) += exportfs/
diff --git a/fs/namei.c b/fs/namei.c
-index 0087cf9..d3118a7 100644
+index 208c6aa..050eded 100644
--- a/fs/namei.c
+++ b/fs/namei.c
-@@ -562,6 +562,7 @@ void release_open_intent(struct nameidata *nd)
+@@ -491,6 +491,7 @@ void release_open_intent(struct nameidata *nd)
fput(file);
}
}
static inline int d_revalidate(struct dentry *dentry, struct nameidata *nd)
{
+@@ -1804,6 +1805,42 @@ struct dentry *lookup_one_len(const char *name, struct dentry *base, int len)
+ return __lookup_hash(&this, base, NULL);
+ }
+
++/* pass nameidata from caller (useful for NFS) */
++struct dentry *lookup_one_len_nd(const char *name, struct dentry *base,
++ int len, struct nameidata *nd)
++{
++ struct qstr this;
++ unsigned long hash;
++ unsigned int c;
++
++ WARN_ON_ONCE(!mutex_is_locked(&base->d_inode->i_mutex));
++
++ this.name = name;
++ this.len = len;
++ if (!len)
++ return ERR_PTR(-EACCES);
++
++ hash = init_name_hash();
++ while (len--) {
++ c = *(const unsigned char *)name++;
++ if (c == '/' || c == '\0')
++ return ERR_PTR(-EACCES);
++ hash = partial_name_hash(c, hash);
++ }
++ this.hash = end_name_hash(hash);
++ /*
++ * See if the low-level filesystem might want
++ * to use its own hash..
++ */
++ if (base->d_flags & DCACHE_OP_HASH) {
++ int err = base->d_op->d_hash(base, base->d_inode, &this);
++ if (err < 0)
++ return ERR_PTR(err);
++ }
++
++ return __lookup_hash(&this, base, nd);
++}
++
+ int user_path_at_empty(int dfd, const char __user *name, unsigned flags,
+ struct path *path, int *empty)
+ {
+@@ -3384,6 +3421,7 @@ EXPORT_SYMBOL(get_write_access); /* binfmt_aout */
+ EXPORT_SYMBOL(getname);
+ EXPORT_SYMBOL(lock_rename);
+ EXPORT_SYMBOL(lookup_one_len);
++EXPORT_SYMBOL(lookup_one_len_nd);
+ EXPORT_SYMBOL(page_follow_link_light);
+ EXPORT_SYMBOL(page_put_link);
+ EXPORT_SYMBOL(page_readlink);
diff --git a/fs/splice.c b/fs/splice.c
-index 50a5d97..a3af841 100644
+index 1ec0493..3215728 100644
--- a/fs/splice.c
+++ b/fs/splice.c
-@@ -1081,8 +1081,8 @@ EXPORT_SYMBOL(generic_splice_sendpage);
+@@ -1084,8 +1084,8 @@ EXPORT_SYMBOL(generic_splice_sendpage);
/*
* Attempt to initiate a splice from pipe to file.
*/
{
ssize_t (*splice_write)(struct pipe_inode_info *, struct file *,
loff_t *, size_t, unsigned int);
-@@ -1105,13 +1105,14 @@ static long do_splice_from(struct pipe_inode_info *pipe, struct file *out,
+@@ -1108,13 +1108,14 @@ static long do_splice_from(struct pipe_inode_info *pipe, struct file *out,
return splice_write(pipe, out, ppos, len, flags);
}
{
ssize_t (*splice_read)(struct file *, loff_t *,
struct pipe_inode_info *, size_t, unsigned int);
-@@ -1131,6 +1132,7 @@ static long do_splice_to(struct file *in, loff_t *ppos,
+@@ -1134,6 +1135,7 @@ static long do_splice_to(struct file *in, loff_t *ppos,
return splice_read(in, ppos, pipe, len, flags);
}
/**
* splice_direct_to_actor - splices data directly between two non-pipes
-@@ -1200,7 +1202,7 @@ ssize_t splice_direct_to_actor(struct file *in, struct splice_desc *sd,
+@@ -1203,7 +1205,7 @@ ssize_t splice_direct_to_actor(struct file *in, struct splice_desc *sd,
size_t read_len;
loff_t pos = sd->pos, prev_pos = pos;
if (unlikely(ret <= 0))
goto out_release;
-@@ -1259,8 +1261,8 @@ static int direct_splice_actor(struct pipe_inode_info *pipe,
+@@ -1262,8 +1264,8 @@ static int direct_splice_actor(struct pipe_inode_info *pipe,
{
struct file *file = sd->u.file;
}
/**
-@@ -1345,7 +1347,7 @@ static long do_splice(struct file *in, loff_t __user *off_in,
+@@ -1348,7 +1350,7 @@ static long do_splice(struct file *in, loff_t __user *off_in,
} else
off = &out->f_pos;
if (off_out && copy_to_user(off_out, off, sizeof(loff_t)))
ret = -EFAULT;
-@@ -1365,7 +1367,7 @@ static long do_splice(struct file *in, loff_t __user *off_in,
+@@ -1368,7 +1370,7 @@ static long do_splice(struct file *in, loff_t __user *off_in,
} else
off = &in->f_pos;
if (off_in && copy_to_user(off_in, off, sizeof(loff_t)))
ret = -EFAULT;
-diff --git a/fs/stack.c b/fs/stack.c
-index 4a6f7f4..7eeef12 100644
---- a/fs/stack.c
-+++ b/fs/stack.c
-@@ -1,8 +1,20 @@
-+/*
-+ * Copyright (c) 2006-2009 Erez Zadok
-+ * Copyright (c) 2006-2007 Josef 'Jeff' Sipek
-+ * Copyright (c) 2006-2009 Stony Brook University
-+ * Copyright (c) 2006-2009 The Research Foundation of SUNY
-+ *
-+ * This program is free software; you can redistribute it and/or modify
-+ * it under the terms of the GNU General Public License version 2 as
-+ * published by the Free Software Foundation.
-+ */
-+
- #include <linux/module.h>
- #include <linux/fs.h>
- #include <linux/fs_stack.h>
-
--/* does _NOT_ require i_mutex to be held.
-+/*
-+ * does _NOT_ require i_mutex to be held.
- *
- * This function cannot be inlined since i_size_{read,write} is rather
- * heavy-weight on 32-bit systems
diff --git a/fs/unionfs/Kconfig b/fs/unionfs/Kconfig
new file mode 100644
index 0000000..f3c1ac4
+ If you say Y here, you can turn on debugging output from Unionfs.
diff --git a/fs/unionfs/Makefile b/fs/unionfs/Makefile
new file mode 100644
-index 0000000..10a321a
+index 0000000..60b6060
--- /dev/null
+++ b/fs/unionfs/Makefile
@@ -0,0 +1,17 @@
-+UNIONFS_VERSION="2.5.8 (for 2.6.38-rc7)"
++UNIONFS_VERSION="2.5.11 (for 3.3.0-rc3)"
+
+EXTRA_CFLAGS += -DUNIONFS_VERSION=\"$(UNIONFS_VERSION)\"
+
+endif
diff --git a/fs/unionfs/commonfops.c b/fs/unionfs/commonfops.c
new file mode 100644
-index 0000000..51ea65e
+index 0000000..71cacfe
--- /dev/null
+++ b/fs/unionfs/commonfops.c
-@@ -0,0 +1,896 @@
+@@ -0,0 +1,901 @@
+/*
-+ * Copyright (c) 2003-2010 Erez Zadok
++ * Copyright (c) 2003-2011 Erez Zadok
+ * Copyright (c) 2003-2006 Charles P. Wright
+ * Copyright (c) 2005-2007 Josef 'Jeff' Sipek
+ * Copyright (c) 2005-2006 Junjiro Okajima
+ * Copyright (c) 2003-2004 Mohammad Nayyer Zubair
+ * Copyright (c) 2003 Puja Gupta
+ * Copyright (c) 2003 Harikesavan Krishnan
-+ * Copyright (c) 2003-2010 Stony Brook University
-+ * Copyright (c) 2003-2010 The Research Foundation of SUNY
++ * Copyright (c) 2003-2011 Stony Brook University
++ * Copyright (c) 2003-2011 The Research Foundation of SUNY
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+}
+
+/* unionfs_open helper function: open a directory */
-+static int __open_dir(struct inode *inode, struct file *file)
++static int __open_dir(struct inode *inode, struct file *file,
++ struct dentry *parent)
+{
+ struct dentry *lower_dentry;
+ struct file *lower_file;
+ int bindex, bstart, bend;
-+ struct vfsmount *mnt;
++ struct vfsmount *lower_mnt;
++ struct dentry *dentry = file->f_path.dentry;
+
-+ bstart = fbstart(file) = dbstart(file->f_path.dentry);
-+ bend = fbend(file) = dbend(file->f_path.dentry);
++ bstart = fbstart(file) = dbstart(dentry);
++ bend = fbend(file) = dbend(dentry);
+
+ for (bindex = bstart; bindex <= bend; bindex++) {
+ lower_dentry =
-+ unionfs_lower_dentry_idx(file->f_path.dentry, bindex);
++ unionfs_lower_dentry_idx(dentry, bindex);
+ if (!lower_dentry)
+ continue;
+
+ dget(lower_dentry);
-+ unionfs_mntget(file->f_path.dentry, bindex);
-+ mnt = unionfs_lower_mnt_idx(file->f_path.dentry, bindex);
-+ lower_file = dentry_open(lower_dentry, mnt, file->f_flags,
++ lower_mnt = unionfs_mntget(dentry, bindex);
++ if (!lower_mnt)
++ lower_mnt = unionfs_mntget(parent, bindex);
++ lower_file = dentry_open(lower_dentry, lower_mnt, file->f_flags,
+ current_cred());
+ if (IS_ERR(lower_file))
+ return PTR_ERR(lower_file);
+
+ unionfs_set_lower_file_idx(file, bindex, lower_file);
++ if (!unionfs_lower_mnt_idx(dentry, bindex))
++ unionfs_set_lower_mnt_idx(dentry, bindex, lower_mnt);
+
+ /*
+ * The branchget goes after the open, because otherwise
+ struct file *lower_file;
+ int lower_flags;
+ int bindex, bstart, bend;
++ struct dentry *dentry = file->f_path.dentry;
++ struct vfsmount *lower_mnt;
+
-+ lower_dentry = unionfs_lower_dentry(file->f_path.dentry);
++ lower_dentry = unionfs_lower_dentry(dentry);
+ lower_flags = file->f_flags;
+
-+ bstart = fbstart(file) = dbstart(file->f_path.dentry);
-+ bend = fbend(file) = dbend(file->f_path.dentry);
++ bstart = fbstart(file) = dbstart(dentry);
++ bend = fbend(file) = dbend(dentry);
+
+ /*
+ * check for the permission for lower file. If the error is
+ * COPYUP_ERR, copyup the file.
+ */
-+ if (lower_dentry->d_inode && is_robranch(file->f_path.dentry)) {
++ if (lower_dentry->d_inode && is_robranch(dentry)) {
+ /*
+ * if the open will change the file, copy it up otherwise
+ * defer it.
+ for (bindex = bstart - 1; bindex >= 0; bindex--) {
+ err = copyup_file(parent->d_inode, file,
+ bstart, bindex, size);
-+ if (!err)
++ if (!err) {
++ /* only one regular file open */
++ fbend(file) = fbstart(file);
+ break;
++ }
+ }
+ return err;
+ } else {
+ * dentry_open will decrement mnt refcnt if err.
+ * otherwise fput() will do an mntput() for us upon file close.
+ */
-+ unionfs_mntget(file->f_path.dentry, bstart);
-+ lower_file =
-+ dentry_open(lower_dentry,
-+ unionfs_lower_mnt_idx(file->f_path.dentry, bstart),
-+ lower_flags, current_cred());
++ lower_mnt = unionfs_mntget(dentry, bstart);
++ lower_file = dentry_open(lower_dentry, lower_mnt, lower_flags,
++ current_cred());
+ if (IS_ERR(lower_file))
+ return PTR_ERR(lower_file);
+
+ * these lower file structs
+ */
+ if (S_ISDIR(inode->i_mode))
-+ err = __open_dir(inode, file); /* open a dir */
++ err = __open_dir(inode, file, parent); /* open a dir */
+ else
+ err = __open_file(inode, file, parent); /* open a file */
+
+ struct dentry *dentry = file->f_path.dentry;
+ struct dentry *parent;
+ int bindex, bstart, bend;
-+ int fgen, err = 0;
++ int err = 0;
+
+ /*
+ * Since mm/memory.c:might_fault() (under PROVE_LOCKING) was
+ inodeinfo = UNIONFS_I(inode);
+
+ /* fput all the lower files */
-+ fgen = atomic_read(&fileinfo->generation);
+ bstart = fbstart(file);
+ bend = fbend(file);
+
+ if (lower_file->f_op->unlocked_ioctl) {
+ err = lower_file->f_op->unlocked_ioctl(lower_file, cmd, arg);
+#ifdef CONFIG_COMPAT
-+ } else if (lower_file->f_op->ioctl) {
-+ err = lower_file->f_op->compat_ioctl(
-+ lower_file->f_path.dentry->d_inode,
-+ lower_file, cmd, arg);
++ } else if (lower_file->f_op->compat_ioctl) {
++ err = lower_file->f_op->compat_ioctl(lower_file, cmd, arg);
+#endif
+ }
+
+}
diff --git a/fs/unionfs/copyup.c b/fs/unionfs/copyup.c
new file mode 100644
-index 0000000..bba3a75
+index 0000000..078ca27
--- /dev/null
+++ b/fs/unionfs/copyup.c
-@@ -0,0 +1,896 @@
+@@ -0,0 +1,899 @@
+/*
-+ * Copyright (c) 2003-2010 Erez Zadok
++ * Copyright (c) 2003-2011 Erez Zadok
+ * Copyright (c) 2003-2006 Charles P. Wright
+ * Copyright (c) 2005-2007 Josef 'Jeff' Sipek
+ * Copyright (c) 2005-2006 Junjiro Okajima
+ * Copyright (c) 2003-2004 Mohammad Nayyer Zubair
+ * Copyright (c) 2003 Puja Gupta
+ * Copyright (c) 2003 Harikesavan Krishnan
-+ * Copyright (c) 2003-2010 Stony Brook University
-+ * Copyright (c) 2003-2010 The Research Foundation of SUNY
++ * Copyright (c) 2003-2011 Stony Brook University
++ * Copyright (c) 2003-2011 The Research Foundation of SUNY
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+
+ kfree(buf);
+
++#if 0
++ /* XXX: code no longer needed? */
+ if (!err)
+ err = output_file->f_op->fsync(output_file, 0);
++#endif
+
+ if (err)
+ goto out_close_out;
+}
diff --git a/fs/unionfs/debug.c b/fs/unionfs/debug.c
new file mode 100644
-index 0000000..a76f92a
+index 0000000..21ce90c
--- /dev/null
+++ b/fs/unionfs/debug.c
-@@ -0,0 +1,548 @@
+@@ -0,0 +1,551 @@
+/*
-+ * Copyright (c) 2003-2010 Erez Zadok
++ * Copyright (c) 2003-2011 Erez Zadok
+ * Copyright (c) 2005-2007 Josef 'Jeff' Sipek
-+ * Copyright (c) 2003-2010 Stony Brook University
-+ * Copyright (c) 2003-2010 The Research Foundation of SUNY
++ * Copyright (c) 2003-2011 Stony Brook University
++ * Copyright (c) 2003-2011 The Research Foundation of SUNY
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ */
+
+#include "union.h"
++#include "../mount.h"
+
+/*
+ * Helper debugging functions for maintainers (and for users to report back
+ pr_debug(" CF0: file/dentry=%p:%p fstart/end=%d:%d\n",
+ file, dentry, fstart, fend);
+ }
-+ if (unlikely(fstart != dstart)) {
++ /* d_deleted dentries can be ignored for this test */
++ if (unlikely(fstart != dstart) && !d_deleted(dentry)) {
+ PRINT_CALLER(fname, fxn, line);
+ pr_debug(" CF1: file/dentry=%p:%p fstart=%d dstart=%d\n",
+ file, dentry, fstart, dstart);
+ }
-+ if (unlikely(fend != dend)) {
++ if (unlikely(fend != dend) && !d_deleted(dentry)) {
+ PRINT_CALLER(fname, fxn, line);
+ pr_debug(" CF2: file/dentry=%p:%p fend=%d dend=%d\n",
+ file, dentry, fend, dend);
+
+static unsigned int __mnt_get_count(struct vfsmount *mnt)
+{
++ struct mount *m = real_mount(mnt);
+#ifdef CONFIG_SMP
+ unsigned int count = 0;
+ int cpu;
+
+ for_each_possible_cpu(cpu) {
-+ count += per_cpu_ptr(mnt->mnt_pcp, cpu)->mnt_count;
++ count += per_cpu_ptr(m->mnt_pcp, cpu)->mnt_count;
+ }
+
+ return count;
+#else
-+ return mnt->mnt_count;
++ return m->mnt_count;
+#endif
+}
+
+}
diff --git a/fs/unionfs/dentry.c b/fs/unionfs/dentry.c
new file mode 100644
-index 0000000..a0c3bba
+index 0000000..1628dad
--- /dev/null
+++ b/fs/unionfs/dentry.c
-@@ -0,0 +1,397 @@
+@@ -0,0 +1,409 @@
+/*
-+ * Copyright (c) 2003-2010 Erez Zadok
++ * Copyright (c) 2003-2011 Erez Zadok
+ * Copyright (c) 2003-2006 Charles P. Wright
+ * Copyright (c) 2005-2007 Josef 'Jeff' Sipek
+ * Copyright (c) 2005-2006 Junjiro Okajima
+ * Copyright (c) 2003-2004 Mohammad Nayyer Zubair
+ * Copyright (c) 2003 Puja Gupta
+ * Copyright (c) 2003 Harikesavan Krishnan
-+ * Copyright (c) 2003-2010 Stony Brook University
-+ * Copyright (c) 2003-2010 The Research Foundation of SUNY
++ * Copyright (c) 2003-2011 Stony Brook University
++ * Copyright (c) 2003-2011 The Research Foundation of SUNY
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ bend = dbend(dentry);
+ BUG_ON(bstart == -1);
+ for (bindex = bstart; bindex <= bend; bindex++) {
++ int err;
++ struct nameidata lower_nd;
++
+ lower_dentry = unionfs_lower_dentry_idx(dentry, bindex);
+ if (!lower_dentry || !lower_dentry->d_op
+ || !lower_dentry->d_op->d_revalidate)
+ * invariants). We will open lower files as and when needed
+ * later on.
+ */
-+ if (!lower_dentry->d_op->d_revalidate(lower_dentry, NULL))
++ err = init_lower_nd(&lower_nd, LOOKUP_OPEN);
++ if (unlikely(err < 0)) {
++ valid = false;
++ break;
++ }
++ if (!lower_dentry->d_op->d_revalidate(lower_dentry, &lower_nd))
+ valid = false;
++ release_lower_nd(&lower_nd, err);
+ }
+
+ if (!dentry->d_inode ||
+}
+
+static int unionfs_d_revalidate(struct dentry *dentry,
-+ struct nameidata *nd_unused)
++ struct nameidata *nd)
+{
+ bool valid = true;
+ int err = 1; /* 1 means valid for the VFS */
+ struct dentry *parent;
+
++ if (nd && nd->flags & LOOKUP_RCU)
++ return -ECHILD;
++
+ unionfs_read_lock(dentry->d_sb, UNIONFS_SMUTEX_CHILD);
+ parent = unionfs_lock_parent(dentry, UNIONFS_DMUTEX_PARENT);
+ unionfs_lock_dentry(dentry, UNIONFS_DMUTEX_CHILD);
+};
diff --git a/fs/unionfs/dirfops.c b/fs/unionfs/dirfops.c
new file mode 100644
-index 0000000..7da0ff0
+index 0000000..72a9c1a
--- /dev/null
+++ b/fs/unionfs/dirfops.c
@@ -0,0 +1,302 @@
+/*
-+ * Copyright (c) 2003-2010 Erez Zadok
++ * Copyright (c) 2003-2011 Erez Zadok
+ * Copyright (c) 2003-2006 Charles P. Wright
+ * Copyright (c) 2005-2007 Josef 'Jeff' Sipek
+ * Copyright (c) 2005-2006 Junjiro Okajima
+ * Copyright (c) 2003-2004 Mohammad Nayyer Zubair
+ * Copyright (c) 2003 Puja Gupta
+ * Copyright (c) 2003 Harikesavan Krishnan
-+ * Copyright (c) 2003-2010 Stony Brook University
-+ * Copyright (c) 2003-2010 The Research Foundation of SUNY
++ * Copyright (c) 2003-2011 Stony Brook University
++ * Copyright (c) 2003-2011 The Research Foundation of SUNY
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+};
diff --git a/fs/unionfs/dirhelper.c b/fs/unionfs/dirhelper.c
new file mode 100644
-index 0000000..033343b
+index 0000000..62ec9af
--- /dev/null
+++ b/fs/unionfs/dirhelper.c
@@ -0,0 +1,158 @@
+/*
-+ * Copyright (c) 2003-2010 Erez Zadok
++ * Copyright (c) 2003-2011 Erez Zadok
+ * Copyright (c) 2003-2006 Charles P. Wright
+ * Copyright (c) 2005-2007 Josef 'Jeff' Sipek
+ * Copyright (c) 2005-2006 Junjiro Okajima
+ * Copyright (c) 2003-2004 Mohammad Nayyer Zubair
+ * Copyright (c) 2003 Puja Gupta
+ * Copyright (c) 2003 Harikesavan Krishnan
-+ * Copyright (c) 2003-2010 Stony Brook University
-+ * Copyright (c) 2003-2010 The Research Foundation of SUNY
++ * Copyright (c) 2003-2011 Stony Brook University
++ * Copyright (c) 2003-2011 The Research Foundation of SUNY
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+}
diff --git a/fs/unionfs/fanout.h b/fs/unionfs/fanout.h
new file mode 100644
-index 0000000..5b77eac
+index 0000000..ae1b86a
--- /dev/null
+++ b/fs/unionfs/fanout.h
@@ -0,0 +1,407 @@
+/*
-+ * Copyright (c) 2003-2010 Erez Zadok
++ * Copyright (c) 2003-2011 Erez Zadok
+ * Copyright (c) 2003-2006 Charles P. Wright
+ * Copyright (c) 2005-2007 Josef 'Jeff' Sipek
+ * Copyright (c) 2005 Arun M. Krishnakumar
+ * Copyright (c) 2003-2004 Mohammad Nayyer Zubair
+ * Copyright (c) 2003 Puja Gupta
+ * Copyright (c) 2003 Harikesavan Krishnan
-+ * Copyright (c) 2003-2010 Stony Brook University
-+ * Copyright (c) 2003-2010 The Research Foundation of SUNY
++ * Copyright (c) 2003-2011 Stony Brook University
++ * Copyright (c) 2003-2011 The Research Foundation of SUNY
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+#endif /* not _FANOUT_H */
diff --git a/fs/unionfs/file.c b/fs/unionfs/file.c
new file mode 100644
-index 0000000..1c694c3
+index 0000000..f583c8f
--- /dev/null
+++ b/fs/unionfs/file.c
-@@ -0,0 +1,382 @@
+@@ -0,0 +1,386 @@
+/*
-+ * Copyright (c) 2003-2010 Erez Zadok
++ * Copyright (c) 2003-2011 Erez Zadok
+ * Copyright (c) 2003-2006 Charles P. Wright
+ * Copyright (c) 2005-2007 Josef 'Jeff' Sipek
+ * Copyright (c) 2005-2006 Junjiro Okajima
+ * Copyright (c) 2003-2004 Mohammad Nayyer Zubair
+ * Copyright (c) 2003 Puja Gupta
+ * Copyright (c) 2003 Harikesavan Krishnan
-+ * Copyright (c) 2003-2010 Stony Brook University
-+ * Copyright (c) 2003-2010 The Research Foundation of SUNY
++ * Copyright (c) 2003-2011 Stony Brook University
++ * Copyright (c) 2003-2011 The Research Foundation of SUNY
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ return err;
+}
+
-+int unionfs_fsync(struct file *file, int datasync)
++int unionfs_fsync(struct file *file, loff_t start, loff_t end, int datasync)
+{
+ int bindex, bstart, bend;
+ struct file *lower_file;
+ struct inode *lower_inode, *inode;
+ int err = -EINVAL;
+
++ lockdep_off();
+ unionfs_read_lock(dentry->d_sb, UNIONFS_SMUTEX_PARENT);
+ parent = unionfs_lock_parent(dentry, UNIONFS_DMUTEX_PARENT);
+ unionfs_lock_dentry(dentry, UNIONFS_DMUTEX_CHILD);
+ goto out;
+ unionfs_check_file(file);
+
++ err = generic_file_fsync(file, start, end, datasync);
++ if (err)
++ goto out;
++
+ bstart = fbstart(file);
+ bend = fbend(file);
+ if (bstart < 0 || bend < 0)
+ continue;
+ lower_file = unionfs_lower_file_idx(file, bindex);
+ lower_dentry = unionfs_lower_dentry_idx(dentry, bindex);
-+ mutex_lock(&lower_inode->i_mutex);
-+ err = lower_inode->i_fop->fsync(lower_file, datasync);
++ err = vfs_fsync_range(lower_file, start, end, datasync);
+ if (!err && bindex == bstart)
+ fsstack_copy_attr_times(inode, lower_inode);
-+ mutex_unlock(&lower_inode->i_mutex);
+ if (err)
+ goto out;
+ }
+ unionfs_unlock_dentry(dentry);
+ unionfs_unlock_parent(dentry, parent);
+ unionfs_read_unlock(dentry->d_sb);
++ lockdep_on();
+ return err;
+}
+
+};
diff --git a/fs/unionfs/inode.c b/fs/unionfs/inode.c
new file mode 100644
-index 0000000..0066238
+index 0000000..dd522c2
--- /dev/null
+++ b/fs/unionfs/inode.c
-@@ -0,0 +1,1077 @@
+@@ -0,0 +1,1085 @@
+/*
-+ * Copyright (c) 2003-2010 Erez Zadok
++ * Copyright (c) 2003-2011 Erez Zadok
+ * Copyright (c) 2003-2006 Charles P. Wright
+ * Copyright (c) 2005-2007 Josef 'Jeff' Sipek
+ * Copyright (c) 2005-2006 Junjiro Okajima
+ * Copyright (c) 2003-2004 Mohammad Nayyer Zubair
+ * Copyright (c) 2003 Puja Gupta
+ * Copyright (c) 2003 Harikesavan Krishnan
-+ * Copyright (c) 2003-2010 Stony Brook University
-+ * Copyright (c) 2003-2010 The Research Foundation of SUNY
++ * Copyright (c) 2003-2011 Stony Brook University
++ * Copyright (c) 2003-2011 The Research Foundation of SUNY
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+}
+
+static int unionfs_create(struct inode *dir, struct dentry *dentry,
-+ int mode, struct nameidata *nd_unused)
++ umode_t mode, struct nameidata *nd_unused)
+{
+ int err = 0;
+ struct dentry *lower_dentry = NULL;
+ fsstack_copy_inode_size(dir,
+ lower_parent_dentry->d_inode);
+ /* update no. of links on parent directory */
-+ dir->i_nlink = unionfs_get_nlinks(dir);
++ set_nlink(dir, unionfs_get_nlinks(dir));
+ }
+ }
+
+ lower_dir_dentry = dget_parent(lower_new_dentry);
+ fsstack_copy_attr_times(dir, lower_dir_dentry->d_inode);
+ dput(lower_dir_dentry);
-+ dir->i_nlink = unionfs_get_nlinks(dir);
++ set_nlink(dir, unionfs_get_nlinks(dir));
+ err = 0;
+ }
+ if (err)
+ fsstack_copy_inode_size(dir, lower_new_dentry->d_parent->d_inode);
+
+ /* propagate number of hard-links */
-+ old_dentry->d_inode->i_nlink = unionfs_get_nlinks(old_dentry->d_inode);
++ set_nlink(old_dentry->d_inode,
++ unionfs_get_nlinks(old_dentry->d_inode));
+ /* new dentry's ctime may have changed due to hard-link counts */
+ unionfs_copy_attr_times(new_dentry->d_inode);
+
+ fsstack_copy_inode_size(dir,
+ lower_parent_dentry->d_inode);
+ /* update no. of links on parent directory */
-+ dir->i_nlink = unionfs_get_nlinks(dir);
++ set_nlink(dir, unionfs_get_nlinks(dir));
+ }
+ }
+
+ return err;
+}
+
-+static int unionfs_mkdir(struct inode *dir, struct dentry *dentry, int mode)
++static int unionfs_mkdir(struct inode *dir, struct dentry *dentry, umode_t mode)
+{
+ int err = 0;
+ struct dentry *lower_dentry = NULL;
+ lower_parent_dentry->d_inode);
+
+ /* update number of links on parent directory */
-+ dir->i_nlink = unionfs_get_nlinks(dir);
++ set_nlink(dir, unionfs_get_nlinks(dir));
+ }
+
+ err = make_dir_opaque(dentry, dbstart(dentry));
+ return err;
+}
+
-+static int unionfs_mknod(struct inode *dir, struct dentry *dentry, int mode,
++static int unionfs_mknod(struct inode *dir, struct dentry *dentry, umode_t mode,
+ dev_t dev)
+{
+ int err = 0;
+ fsstack_copy_inode_size(dir,
+ lower_parent_dentry->d_inode);
+ /* update no. of links on parent directory */
-+ dir->i_nlink = unionfs_get_nlinks(dir);
++ set_nlink(dir, unionfs_get_nlinks(dir));
+ }
+ }
+
+ * This is a variant of fs/namei.c:permission() or inode_permission() which
+ * skips over EROFS tests (because we perform copyup on EROFS).
+ */
-+static int __inode_permission(struct inode *inode, int mask, unsigned int flags)
++static int __inode_permission(struct inode *inode, int mask)
+{
+ int retval;
+
+
+ /* Ordinary permission routines do not understand MAY_APPEND. */
+ if (inode->i_op && inode->i_op->permission) {
-+ retval = inode->i_op->permission(inode, mask, flags);
++ retval = inode->i_op->permission(inode, mask);
+ if (!retval) {
+ /*
+ * Exec permission on a regular file is denied if none
+ return -EACCES;
+ }
+ } else {
-+ retval = generic_permission(inode, mask, flags, NULL);
++ retval = generic_permission(inode, mask);
+ }
+ if (retval)
+ return retval;
+ * unionfs_permission, or anything it calls, will use stale branch
+ * information.
+ */
-+static int unionfs_permission(struct inode *inode, int mask, unsigned int flags)
++static int unionfs_permission(struct inode *inode, int mask)
+{
+ struct inode *lower_inode = NULL;
+ int err = 0;
+ int bindex, bstart, bend;
-+ const int is_file = !S_ISDIR(inode->i_mode);
++ int is_file;
+ const int write_mask = (mask & MAY_WRITE) && !(mask & MAY_READ);
-+ struct inode *inode_grabbed = igrab(inode);
-+ struct dentry *dentry = d_find_alias(inode);
-+
-+ if (flags & IPERM_FLAG_RCU)
-+ return -ECHILD;
++ struct inode *inode_grabbed;
+
-+ if (dentry)
-+ unionfs_lock_dentry(dentry, UNIONFS_DMUTEX_CHILD);
++ inode_grabbed = igrab(inode);
++ is_file = !S_ISDIR(inode->i_mode);
+
+ if (!UNIONFS_I(inode)->lower_inodes) {
+ if (is_file) /* dirs can be unlinked but chdir'ed to */
+ * copyup taking place later on. However, if user never had
+ * access to the file, then no copyup could ever take place.
+ */
-+ err = __inode_permission(lower_inode, mask, flags);
++ err = __inode_permission(lower_inode, mask);
+ if (err && err != -EACCES && err != EPERM && bindex > 0) {
+ umode_t mode = lower_inode->i_mode;
+ if ((is_robranch_super(inode->i_sb, bindex) ||
+ if (err && err == -EACCES &&
+ is_robranch_super(inode->i_sb, bindex) &&
+ lower_inode->i_sb->s_magic == NFS_SUPER_MAGIC)
-+ err = generic_permission(lower_inode, mask, flags, NULL);
++ err = generic_permission(lower_inode, mask);
+
+ /*
+ * The permissions are an intersection of the overall directory
+
+out:
+ unionfs_check_inode(inode);
-+ if (dentry) {
-+ unionfs_unlock_dentry(dentry);
-+ dput(dentry);
-+ }
+ iput(inode_grabbed);
+ return err;
+}
+ err = -EINVAL;
+ goto out;
+ }
-+ lower_inode = unionfs_lower_inode(inode);
++
++ /*
++ * Get the lower inode directly from lower dentry, in case ibstart
++ * is -1 (which happens when the file is open but unlinked.
++ */
++ lower_inode = lower_dentry->d_inode;
+
+ /* check if user has permission to change lower inode */
+ err = inode_change_ok(lower_inode, ia);
+ /* get updated lower_dentry/inode after copyup */
+ lower_dentry = unionfs_lower_dentry(dentry);
+ lower_inode = unionfs_lower_inode(inode);
++ /*
++ * check for whiteouts in writeable branch, and remove them
++ * if necessary.
++ */
++ if (lower_dentry) {
++ err = check_unlink_whiteout(dentry, lower_dentry,
++ bindex);
++ if (err > 0) /* ignore if whiteout found and removed */
++ err = 0;
++ }
+ }
+
+ /*
+};
diff --git a/fs/unionfs/lookup.c b/fs/unionfs/lookup.c
new file mode 100644
-index 0000000..b63c17e
+index 0000000..041d674
--- /dev/null
+++ b/fs/unionfs/lookup.c
-@@ -0,0 +1,569 @@
+@@ -0,0 +1,570 @@
+/*
-+ * Copyright (c) 2003-2010 Erez Zadok
++ * Copyright (c) 2003-2011 Erez Zadok
+ * Copyright (c) 2003-2006 Charles P. Wright
+ * Copyright (c) 2005-2007 Josef 'Jeff' Sipek
+ * Copyright (c) 2005-2006 Junjiro Okajima
+ * Copyright (c) 2003-2004 Mohammad Nayyer Zubair
+ * Copyright (c) 2003 Puja Gupta
+ * Copyright (c) 2003 Harikesavan Krishnan
-+ * Copyright (c) 2003-2010 Stony Brook University
-+ * Copyright (c) 2003-2010 The Research Foundation of SUNY
++ * Copyright (c) 2003-2011 Stony Brook University
++ * Copyright (c) 2003-2011 The Research Foundation of SUNY
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ const char *name, struct vfsmount **new_mnt)
+{
+ struct dentry *dentry = NULL;
-+ struct nameidata lower_nd;
++ struct path lower_path = {NULL, NULL};
+ int err;
+
+ /* we use flags=0 to get basic lookup */
-+ err = vfs_path_lookup(base, mnt, name, 0, &lower_nd);
++ err = vfs_path_lookup(base, mnt, name, 0, &lower_path);
+
+ switch (err) {
+ case 0: /* no error */
-+ dentry = lower_nd.path.dentry;
++ dentry = lower_path.dentry;
+ if (new_mnt)
-+ *new_mnt = lower_nd.path.mnt; /* rc already inc'ed */
++ *new_mnt = lower_path.mnt; /* rc already inc'ed */
+ break;
+ case -ENOENT:
+ /*
+ */
+ dentry = lookup_lck_len(name, base, strlen(name));
+ if (new_mnt)
-+ *new_mnt = mntget(lower_nd.path.mnt);
++ *new_mnt = mntget(lower_path.mnt);
+ break;
+ default: /* all other real errors */
+ dentry = ERR_PTR(err);
+ verify_locked(parent);
+
+ /* must initialize dentry operations */
-+ dentry->d_op = &unionfs_dops;
++ if (lookupmode == INTERPOSE_LOOKUP)
++ d_set_d_op(dentry, &unionfs_dops);
+
+ /* We never partial lookup the root directory. */
+ if (IS_ROOT(dentry))
+}
diff --git a/fs/unionfs/main.c b/fs/unionfs/main.c
new file mode 100644
-index 0000000..9ee58eb
+index 0000000..ee78f1d
--- /dev/null
+++ b/fs/unionfs/main.c
-@@ -0,0 +1,762 @@
+@@ -0,0 +1,752 @@
+/*
-+ * Copyright (c) 2003-2010 Erez Zadok
++ * Copyright (c) 2003-2011 Erez Zadok
+ * Copyright (c) 2003-2006 Charles P. Wright
+ * Copyright (c) 2005-2007 Josef 'Jeff' Sipek
+ * Copyright (c) 2005-2006 Junjiro Okajima
+ * Copyright (c) 2003-2004 Mohammad Nayyer Zubair
+ * Copyright (c) 2003 Puja Gupta
+ * Copyright (c) 2003 Harikesavan Krishnan
-+ * Copyright (c) 2003-2010 Stony Brook University
-+ * Copyright (c) 2003-2010 The Research Foundation of SUNY
++ * Copyright (c) 2003-2011 Stony Brook University
++ * Copyright (c) 2003-2011 The Research Foundation of SUNY
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * properly. Finally we must return this new
+ * dentry.
+ */
-+ spliced->d_op = &unionfs_dops;
++ d_set_d_op(spliced, &unionfs_dops);
+ spliced->d_fsdata = dentry->d_fsdata;
+ dentry->d_fsdata = NULL;
+ dentry = spliced;
+ * 2) it exists
+ * 3) is a directory
+ */
-+int check_branch(struct nameidata *nd)
++int check_branch(const struct path *path)
+{
+ /* XXX: remove in ODF code -- stacking unions allowed there */
-+ if (!strcmp(nd->path.dentry->d_sb->s_type->name, UNIONFS_NAME))
++ if (!strcmp(path->dentry->d_sb->s_type->name, UNIONFS_NAME))
+ return -EINVAL;
-+ if (!nd->path.dentry->d_inode)
++ if (!path->dentry->d_inode)
+ return -ENOENT;
-+ if (!S_ISDIR(nd->path.dentry->d_inode->i_mode))
++ if (!S_ISDIR(path->dentry->d_inode->i_mode))
+ return -ENOTDIR;
+ return 0;
+}
+static int parse_dirs_option(struct super_block *sb, struct unionfs_dentry_info
+ *lower_root_info, char *options)
+{
-+ struct nameidata nd;
++ struct path path;
+ char *name;
+ int err = 0;
+ int branches = 1;
+ goto out;
+ }
+
-+ err = path_lookup(name, LOOKUP_FOLLOW, &nd);
++ err = kern_path(name, LOOKUP_FOLLOW, &path);
+ if (err) {
+ printk(KERN_ERR "unionfs: error accessing "
+ "lower directory '%s' (error %d)\n",
+ goto out;
+ }
+
-+ err = check_branch(&nd);
++ err = check_branch(&path);
+ if (err) {
+ printk(KERN_ERR "unionfs: lower directory "
+ "'%s' is not a valid branch\n", name);
-+ path_put(&nd.path);
++ path_put(&path);
+ goto out;
+ }
+
-+ lower_root_info->lower_paths[bindex].dentry = nd.path.dentry;
-+ lower_root_info->lower_paths[bindex].mnt = nd.path.mnt;
++ lower_root_info->lower_paths[bindex].dentry = path.dentry;
++ lower_root_info->lower_paths[bindex].mnt = path.mnt;
+
+ set_branchperms(sb, bindex, perms);
+ set_branch_count(sb, bindex, 0);
+}
+
+/*
-+ * our custom d_alloc_root work-alike
-+ *
-+ * we can't use d_alloc_root if we want to use our own interpose function
-+ * unchanged, so we simply call our own "fake" d_alloc_root
-+ */
-+static struct dentry *unionfs_d_alloc_root(struct super_block *sb)
-+{
-+ struct dentry *ret = NULL;
-+
-+ if (sb) {
-+ static const struct qstr name = {
-+ .name = "/",
-+ .len = 1
-+ };
-+
-+ ret = d_alloc(NULL, &name);
-+ if (likely(ret)) {
-+ ret->d_op = &unionfs_dops;
-+ ret->d_sb = sb;
-+ ret->d_parent = ret;
-+ }
-+ }
-+ return ret;
-+}
-+
-+/*
+ * There is no need to lock the unionfs_super_info's rwsem as there is no
+ * way anyone can have a reference to the superblock at this point in time.
+ */
+ int err = 0;
+ struct unionfs_dentry_info *lower_root_info = NULL;
+ int bindex, bstart, bend;
++ struct inode *inode = NULL;
+
+ if (!raw_data) {
+ printk(KERN_ERR
+
+ sb->s_op = &unionfs_sops;
+
-+ /* See comment next to the definition of unionfs_d_alloc_root */
-+ sb->s_root = unionfs_d_alloc_root(sb);
++ /* get a new inode and allocate our root dentry */
++ inode = unionfs_iget(sb, iunique(sb, UNIONFS_ROOT_INO));
++ if (IS_ERR(inode)) {
++ err = PTR_ERR(inode);
++ goto out_dput;
++ }
++ sb->s_root = d_make_root(inode);
+ if (unlikely(!sb->s_root)) {
+ err = -ENOMEM;
+ goto out_dput;
+ }
++ d_set_d_op(sb->s_root, &unionfs_dops);
+
+ /* link the upper and lower dentries */
+ sb->s_root->d_fsdata = NULL;
+ if (unlikely(err))
+ goto out_freedpd;
+
++ /* if get here: cannot have error */
++
+ /* Set the lower dentries for s_root */
+ for (bindex = bstart; bindex <= bend; bindex++) {
+ struct dentry *d;
+ /* Set the generation number to one, since this is for the mount. */
+ atomic_set(&UNIONFS_D(sb->s_root)->generation, 1);
+
++ if (atomic_read(&inode->i_count) <= 1)
++ unionfs_fill_inode(sb->s_root, inode);
++
+ /*
-+ * Call interpose to create the upper level inode. Only
-+ * INTERPOSE_LOOKUP can return a value other than 0 on err.
++ * No need to call interpose because we already have a positive
++ * dentry, which was instantiated by d_alloc_root. Just need to
++ * d_rehash it.
+ */
-+ err = PTR_ERR(unionfs_interpose(sb->s_root, sb, 0));
++ d_rehash(sb->s_root);
++
+ unionfs_unlock_dentry(sb->s_root);
-+ if (!err)
-+ goto out;
-+ /* else fall through */
++ goto out; /* all is well */
+
+out_freedpd:
+ if (UNIONFS_D(sb->s_root)) {
+ }
+ dput(sb->s_root);
+
++out_iput:
++ iput(inode);
++
+out_dput:
+ if (lower_root_info && !IS_ERR(lower_root_info)) {
+ for (bindex = lower_root_info->bstart;
+ return err;
+}
+
-+static int unionfs_get_sb(struct file_system_type *fs_type,
-+ int flags, const char *dev_name,
-+ void *raw_data, struct vfsmount *mnt)
++static struct dentry *unionfs_mount(struct file_system_type *fs_type,
++ int flags, const char *dev_name,
++ void *raw_data)
+{
-+ int err;
-+ err = get_sb_nodev(fs_type, flags, raw_data, unionfs_read_super, mnt);
-+ if (!err)
-+ UNIONFS_SB(mnt->mnt_sb)->dev_name =
++ struct dentry *dentry;
++
++ dentry = mount_nodev(fs_type, flags, raw_data, unionfs_read_super);
++ if (!IS_ERR(dentry))
++ UNIONFS_SB(dentry->d_sb)->dev_name =
+ kstrdup(dev_name, GFP_KERNEL);
-+ return err;
++ return dentry;
+}
+
+static struct file_system_type unionfs_fs_type = {
+ .owner = THIS_MODULE,
+ .name = UNIONFS_NAME,
-+ .get_sb = unionfs_get_sb,
++ .mount = unionfs_mount,
+ .kill_sb = generic_shutdown_super,
+ .fs_flags = FS_REVAL_DOT,
+};
+module_exit(exit_unionfs_fs);
diff --git a/fs/unionfs/mmap.c b/fs/unionfs/mmap.c
new file mode 100644
-index 0000000..1f70535
+index 0000000..bcc5652
--- /dev/null
+++ b/fs/unionfs/mmap.c
@@ -0,0 +1,89 @@
+/*
-+ * Copyright (c) 2003-2010 Erez Zadok
++ * Copyright (c) 2003-2011 Erez Zadok
+ * Copyright (c) 2003-2006 Charles P. Wright
+ * Copyright (c) 2005-2007 Josef 'Jeff' Sipek
+ * Copyright (c) 2005-2006 Junjiro Okajima
+ * Copyright (c) 2003-2004 Mohammad Nayyer Zubair
+ * Copyright (c) 2003 Puja Gupta
+ * Copyright (c) 2003 Harikesavan Krishnan
-+ * Copyright (c) 2003-2010 Stony Brook University
-+ * Copyright (c) 2003-2010 The Research Foundation of SUNY
++ * Copyright (c) 2003-2011 Stony Brook University
++ * Copyright (c) 2003-2011 The Research Foundation of SUNY
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+};
diff --git a/fs/unionfs/rdstate.c b/fs/unionfs/rdstate.c
new file mode 100644
-index 0000000..d57f1f8
+index 0000000..59b7333
--- /dev/null
+++ b/fs/unionfs/rdstate.c
@@ -0,0 +1,285 @@
+/*
-+ * Copyright (c) 2003-2010 Erez Zadok
++ * Copyright (c) 2003-2011 Erez Zadok
+ * Copyright (c) 2003-2006 Charles P. Wright
+ * Copyright (c) 2005-2007 Josef 'Jeff' Sipek
+ * Copyright (c) 2005-2006 Junjiro Okajima
+ * Copyright (c) 2003-2004 Mohammad Nayyer Zubair
+ * Copyright (c) 2003 Puja Gupta
+ * Copyright (c) 2003 Harikesavan Krishnan
-+ * Copyright (c) 2003-2010 Stony Brook University
-+ * Copyright (c) 2003-2010 The Research Foundation of SUNY
++ * Copyright (c) 2003-2011 Stony Brook University
++ * Copyright (c) 2003-2011 The Research Foundation of SUNY
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+}
diff --git a/fs/unionfs/rename.c b/fs/unionfs/rename.c
new file mode 100644
-index 0000000..936700e
+index 0000000..ce85b84
--- /dev/null
+++ b/fs/unionfs/rename.c
-@@ -0,0 +1,517 @@
+@@ -0,0 +1,522 @@
+/*
-+ * Copyright (c) 2003-2010 Erez Zadok
++ * Copyright (c) 2003-2011 Erez Zadok
+ * Copyright (c) 2003-2006 Charles P. Wright
+ * Copyright (c) 2005-2007 Josef 'Jeff' Sipek
+ * Copyright (c) 2005-2006 Junjiro Okajima
+ * Copyright (c) 2003-2004 Mohammad Nayyer Zubair
+ * Copyright (c) 2003 Puja Gupta
+ * Copyright (c) 2003 Harikesavan Krishnan
-+ * Copyright (c) 2003-2010 Stony Brook University
-+ * Copyright (c) 2003-2010 The Research Foundation of SUNY
++ * Copyright (c) 2003-2011 Stony Brook University
++ * Copyright (c) 2003-2011 The Research Foundation of SUNY
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ struct dentry *lower_dentry;
+ struct dentry *lower_parent;
+ int err = 0;
++ struct nameidata lower_nd;
+
+ verify_locked(dentry);
+
+
+ BUG_ON(!S_ISDIR(lower_parent->d_inode->i_mode));
+
-+ lower_dentry = lookup_one_len(dentry->d_name.name, lower_parent,
-+ dentry->d_name.len);
++ err = init_lower_nd(&lower_nd, LOOKUP_OPEN);
++ if (unlikely(err < 0))
++ goto out;
++ lower_dentry = lookup_one_len_nd(dentry->d_name.name, lower_parent,
++ dentry->d_name.len, &lower_nd);
++ release_lower_nd(&lower_nd, err);
+ if (IS_ERR(lower_dentry)) {
+ err = PTR_ERR(lower_dentry);
+ goto out;
+ fsstack_copy_attr_times(new_parent->d_inode,
+ unlink_dir_dentry->d_inode);
+ /* propagate number of hard-links */
-+ new_parent->d_inode->i_nlink =
-+ unionfs_get_nlinks(new_parent->d_inode);
++ set_nlink(new_parent->d_inode,
++ unionfs_get_nlinks(new_parent->d_inode));
+
+ unlock_dir(unlink_dir_dentry);
+ if (!err) {
+}
diff --git a/fs/unionfs/sioq.c b/fs/unionfs/sioq.c
new file mode 100644
-index 0000000..760c580
+index 0000000..b923742
--- /dev/null
+++ b/fs/unionfs/sioq.c
@@ -0,0 +1,101 @@
+/*
-+ * Copyright (c) 2006-2010 Erez Zadok
++ * Copyright (c) 2006-2011 Erez Zadok
+ * Copyright (c) 2006 Charles P. Wright
+ * Copyright (c) 2006-2007 Josef 'Jeff' Sipek
+ * Copyright (c) 2006 Junjiro Okajima
+ * Copyright (c) 2006 David P. Quigley
-+ * Copyright (c) 2006-2010 Stony Brook University
-+ * Copyright (c) 2006-2010 The Research Foundation of SUNY
++ * Copyright (c) 2006-2011 Stony Brook University
++ * Copyright (c) 2006-2011 The Research Foundation of SUNY
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+}
diff --git a/fs/unionfs/sioq.h b/fs/unionfs/sioq.h
new file mode 100644
-index 0000000..b26d248
+index 0000000..c2dfb94
--- /dev/null
+++ b/fs/unionfs/sioq.h
@@ -0,0 +1,91 @@
+/*
-+ * Copyright (c) 2006-2010 Erez Zadok
++ * Copyright (c) 2006-2011 Erez Zadok
+ * Copyright (c) 2006 Charles P. Wright
+ * Copyright (c) 2006-2007 Josef 'Jeff' Sipek
+ * Copyright (c) 2006 Junjiro Okajima
+ * Copyright (c) 2006 David P. Quigley
-+ * Copyright (c) 2006-2010 Stony Brook University
-+ * Copyright (c) 2006-2010 The Research Foundation of SUNY
++ * Copyright (c) 2006-2011 Stony Brook University
++ * Copyright (c) 2006-2011 The Research Foundation of SUNY
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+#endif /* not _SIOQ_H */
diff --git a/fs/unionfs/subr.c b/fs/unionfs/subr.c
new file mode 100644
-index 0000000..570a344
+index 0000000..e7fc5a5
--- /dev/null
+++ b/fs/unionfs/subr.c
@@ -0,0 +1,95 @@
+/*
-+ * Copyright (c) 2003-2010 Erez Zadok
++ * Copyright (c) 2003-2011 Erez Zadok
+ * Copyright (c) 2003-2006 Charles P. Wright
+ * Copyright (c) 2005-2007 Josef 'Jeff' Sipek
+ * Copyright (c) 2005-2006 Junjiro Okajima
+ * Copyright (c) 2003-2004 Mohammad Nayyer Zubair
+ * Copyright (c) 2003 Puja Gupta
+ * Copyright (c) 2003 Harikesavan Krishnan
-+ * Copyright (c) 2003-2010 Stony Brook University
-+ * Copyright (c) 2003-2010 The Research Foundation of SUNY
++ * Copyright (c) 2003-2011 Stony Brook University
++ * Copyright (c) 2003-2011 The Research Foundation of SUNY
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * Update the nlinks AFTER updating the above fields, because the
+ * get_links callback may depend on them.
+ */
-+ dest->i_nlink = unionfs_get_nlinks(dest);
++ set_nlink(dest, unionfs_get_nlinks(dest));
+}
diff --git a/fs/unionfs/super.c b/fs/unionfs/super.c
new file mode 100644
-index 0000000..45bb9bf
+index 0000000..b99f14d
--- /dev/null
+++ b/fs/unionfs/super.c
-@@ -0,0 +1,1029 @@
+@@ -0,0 +1,1030 @@
+/*
-+ * Copyright (c) 2003-2010 Erez Zadok
++ * Copyright (c) 2003-2011 Erez Zadok
+ * Copyright (c) 2003-2006 Charles P. Wright
+ * Copyright (c) 2005-2007 Josef 'Jeff' Sipek
+ * Copyright (c) 2005-2006 Junjiro Okajima
+ * Copyright (c) 2003-2004 Mohammad Nayyer Zubair
+ * Copyright (c) 2003 Puja Gupta
+ * Copyright (c) 2003 Harikesavan Krishnan
-+ * Copyright (c) 2003-2010 Stony Brook University
-+ * Copyright (c) 2003-2010 The Research Foundation of SUNY
++ * Copyright (c) 2003-2011 Stony Brook University
++ * Copyright (c) 2003-2011 The Research Foundation of SUNY
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ int err = -EINVAL;
+ int perms, idx;
+ char *modename = strchr(optarg, '=');
-+ struct nameidata nd;
++ struct path path;
+
+ /* by now, optarg contains the branch name */
+ if (!*optarg) {
+ * and cache-coherency resolved, we'll address the branch-path
+ * uniqueness.
+ */
-+ err = path_lookup(optarg, LOOKUP_FOLLOW, &nd);
++ err = kern_path(optarg, LOOKUP_FOLLOW, &path);
+ if (err) {
+ printk(KERN_ERR "unionfs: error accessing "
+ "lower directory \"%s\" (error %d)\n",
+ goto out;
+ }
+ for (idx = 0; idx < cur_branches; idx++)
-+ if (nd.path.mnt == new_lower_paths[idx].mnt &&
-+ nd.path.dentry == new_lower_paths[idx].dentry)
++ if (path.mnt == new_lower_paths[idx].mnt &&
++ path.dentry == new_lower_paths[idx].dentry)
+ break;
-+ path_put(&nd.path); /* no longer needed */
++ path_put(&path); /* no longer needed */
+ if (idx == cur_branches) {
+ err = -ENOENT; /* err may have been reset above */
+ printk(KERN_ERR "unionfs: branch \"%s\" "
+{
+ int err = -EINVAL;
+ int idx;
-+ struct nameidata nd;
++ struct path path;
+
+ /* optarg contains the branch name to delete */
+
+ * and cache-coherency resolved, we'll address the branch-path
+ * uniqueness.
+ */
-+ err = path_lookup(optarg, LOOKUP_FOLLOW, &nd);
++ err = kern_path(optarg, LOOKUP_FOLLOW, &path);
+ if (err) {
+ printk(KERN_ERR "unionfs: error accessing "
+ "lower directory \"%s\" (error %d)\n",
+ goto out;
+ }
+ for (idx = 0; idx < cur_branches; idx++)
-+ if (nd.path.mnt == new_lower_paths[idx].mnt &&
-+ nd.path.dentry == new_lower_paths[idx].dentry)
++ if (path.mnt == new_lower_paths[idx].mnt &&
++ path.dentry == new_lower_paths[idx].dentry)
+ break;
-+ path_put(&nd.path); /* no longer needed */
++ path_put(&path); /* no longer needed */
+ if (idx == cur_branches) {
+ printk(KERN_ERR "unionfs: branch \"%s\" "
+ "not found\n", optarg);
+ int perms;
+ int idx = 0; /* default: insert at beginning */
+ char *new_branch , *modename = NULL;
-+ struct nameidata nd;
++ struct path path;
+
+ /*
+ * optarg can be of several forms:
+ * and cache-coherency resolved, we'll address the branch-path
+ * uniqueness.
+ */
-+ err = path_lookup(optarg, LOOKUP_FOLLOW, &nd);
++ err = kern_path(optarg, LOOKUP_FOLLOW, &path);
+ if (err) {
+ printk(KERN_ERR "unionfs: error accessing "
+ "lower directory \"%s\" (error %d)\n",
+ goto out;
+ }
+ for (idx = 0; idx < cur_branches; idx++)
-+ if (nd.path.mnt == new_lower_paths[idx].mnt &&
-+ nd.path.dentry == new_lower_paths[idx].dentry)
++ if (path.mnt == new_lower_paths[idx].mnt &&
++ path.dentry == new_lower_paths[idx].dentry)
+ break;
-+ path_put(&nd.path); /* no longer needed */
++ path_put(&path); /* no longer needed */
+ if (idx == cur_branches) {
+ printk(KERN_ERR "unionfs: branch \"%s\" "
+ "not found\n", optarg);
+ "branch \"%s\"\n", modename, new_branch);
+ goto out;
+ }
-+ err = path_lookup(new_branch, LOOKUP_FOLLOW, &nd);
++ err = kern_path(new_branch, LOOKUP_FOLLOW, &path);
+ if (err) {
+ printk(KERN_ERR "unionfs: error accessing "
+ "lower directory \"%s\" (error %d)\n",
+ * because this code base doesn't support stacking unionfs: the ODF
+ * code base supports that correctly.
+ */
-+ err = check_branch(&nd);
++ err = check_branch(&path);
+ if (err) {
+ printk(KERN_ERR "unionfs: lower directory "
+ "\"%s\" is not a valid branch\n", optarg);
-+ path_put(&nd.path);
++ path_put(&path);
+ goto out;
+ }
+
+ memmove(&new_lower_paths[idx+1], &new_lower_paths[idx],
+ (cur_branches - idx) * sizeof(struct path));
+ }
-+ new_lower_paths[idx].dentry = nd.path.dentry;
-+ new_lower_paths[idx].mnt = nd.path.mnt;
++ new_lower_paths[idx].dentry = path.dentry;
++ new_lower_paths[idx].mnt = path.mnt;
+
-+ new_data[idx].sb = nd.path.dentry->d_sb;
++ new_data[idx].sb = path.dentry->d_sb;
+ atomic_set(&new_data[idx].open_files, 0);
+ new_data[idx].branchperms = perms;
+ new_data[idx].branch_id = ++*high_branch_id; /* assign new branch ID */
+ path_get(&tmp_lower_paths[i]); /* drop refs at end of fxn */
+
+ /*******************************************************************
-+ * For each branch command, do path_lookup on the requested branch,
++ * For each branch command, do kern_path on the requested branch,
+ * and apply the change to a temp branch list. To handle errors, we
+ * already dup'ed the old arrays (above), and increased the refcnts
-+ * on various f/s objects. So now we can do all the path_lookups
++ * on various f/s objects. So now we can do all the kern_path'ss
+ * and branch-management commands on the new arrays. If it fail mid
+ * way, we free the tmp arrays and *put all objects. If we succeed,
+ * then we free old arrays and *put its objects, and then replace
+ unionfs_read_unlock(sb);
+}
+
-+static int unionfs_show_options(struct seq_file *m, struct vfsmount *mnt)
++static int unionfs_show_options(struct seq_file *m, struct dentry *root)
+{
-+ struct super_block *sb = mnt->mnt_sb;
++ struct super_block *sb = root->d_sb;
+ int ret = 0;
+ char *tmp_page;
+ char *path;
+ int bindex, bstart, bend;
+ int perms;
+
++ /* to prevent a silly lockdep warning with namespace_sem */
++ lockdep_off();
+ unionfs_read_lock(sb, UNIONFS_SMUTEX_CHILD);
-+
+ unionfs_lock_dentry(sb->s_root, UNIONFS_DMUTEX_CHILD);
+
+ tmp_page = (char *) __get_free_page(GFP_KERNEL);
+ free_page((unsigned long) tmp_page);
+
+ unionfs_unlock_dentry(sb->s_root);
-+
+ unionfs_read_unlock(sb);
++ lockdep_on();
+
+ return ret;
+}
+};
diff --git a/fs/unionfs/union.h b/fs/unionfs/union.h
new file mode 100644
-index 0000000..6c7b9aa
+index 0000000..8e7fcfb
--- /dev/null
+++ b/fs/unionfs/union.h
-@@ -0,0 +1,669 @@
+@@ -0,0 +1,681 @@
+/*
-+ * Copyright (c) 2003-2010 Erez Zadok
++ * Copyright (c) 2003-2011 Erez Zadok
+ * Copyright (c) 2003-2006 Charles P. Wright
+ * Copyright (c) 2005-2007 Josef 'Jeff' Sipek
+ * Copyright (c) 2005 Arun M. Krishnakumar
+ * Copyright (c) 2003-2004 Mohammad Nayyer Zubair
+ * Copyright (c) 2003 Puja Gupta
+ * Copyright (c) 2003 Harikesavan Krishnan
-+ * Copyright (c) 2003-2010 Stony Brook University
-+ * Copyright (c) 2003-2010 The Research Foundation of SUNY
++ * Copyright (c) 2003-2011 Stony Brook University
++ * Copyright (c) 2003-2011 The Research Foundation of SUNY
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+#include <linux/seq_file.h>
+#include <linux/slab.h>
+#include <linux/spinlock.h>
-+#include <linux/smp_lock.h>
+#include <linux/statfs.h>
+#include <linux/string.h>
+#include <linux/vmalloc.h>
+#include <linux/mman.h>
+#include <linux/backing-dev.h>
+#include <linux/splice.h>
++#include <linux/sched.h>
++
+
-+#include <asm/system.h>
+
+#include <linux/union_fs.h>
+
+extern int unionfs_flush(struct file *file, fl_owner_t id);
+extern long unionfs_ioctl(struct file *file, unsigned int cmd,
+ unsigned long arg);
-+extern int unionfs_fsync(struct file *file, int datasync);
++extern int unionfs_fsync(struct file *file, loff_t start, loff_t end,
++ int datasync);
+extern int unionfs_fasync(int fd, struct file *file, int flag);
+
+/* Inode operations */
+/*
+ * EXTERNALS:
+ */
-+extern int check_branch(struct nameidata *nd);
++extern int check_branch(const struct path *path);
+extern int parse_branch_mode(const char *name, int *perms);
+
+/* locking helpers */
+ struct dentry *base, int len)
+{
+ struct dentry *d;
++ struct nameidata lower_nd;
++ int err;
++
++ err = init_lower_nd(&lower_nd, LOOKUP_OPEN);
++ if (unlikely(err < 0)) {
++ d = ERR_PTR(err);
++ goto out;
++ }
+ mutex_lock(&base->d_inode->i_mutex);
-+ d = lookup_one_len(name, base, len);
++ d = lookup_one_len_nd(name, base, len, &lower_nd);
++ release_lower_nd(&lower_nd, err);
+ mutex_unlock(&base->d_inode->i_mutex);
++out:
+ return d;
+}
+
+#define show_inode_times(i) do { } while (0)
+#define show_dinode_times(d) do { } while (0)
+#define show_inode_counts(i) do { } while (0)
++#define UDBG do { } while (0)
+
+#endif /* not CONFIG_UNION_FS_DEBUG */
+
+#endif /* not _UNION_H_ */
diff --git a/fs/unionfs/unlink.c b/fs/unionfs/unlink.c
new file mode 100644
-index 0000000..542c513
+index 0000000..25943a5
--- /dev/null
+++ b/fs/unionfs/unlink.c
@@ -0,0 +1,278 @@
+/*
-+ * Copyright (c) 2003-2010 Erez Zadok
++ * Copyright (c) 2003-2011 Erez Zadok
+ * Copyright (c) 2003-2006 Charles P. Wright
+ * Copyright (c) 2005-2007 Josef 'Jeff' Sipek
+ * Copyright (c) 2005-2006 Junjiro Okajima
+ * Copyright (c) 2003-2004 Mohammad Nayyer Zubair
+ * Copyright (c) 2003 Puja Gupta
+ * Copyright (c) 2003 Harikesavan Krishnan
-+ * Copyright (c) 2003-2010 Stony Brook University
-+ * Copyright (c) 2003-2010 The Research Foundation of SUNY
++ * Copyright (c) 2003-2011 Stony Brook University
++ * Copyright (c) 2003-2011 The Research Foundation of SUNY
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+
+ fsstack_copy_attr_times(dir, lower_dir_dentry->d_inode);
+ /* propagate number of hard-links */
-+ dentry->d_inode->i_nlink = unionfs_get_nlinks(dentry->d_inode);
++ set_nlink(dentry->d_inode, unionfs_get_nlinks(dentry->d_inode));
+
+out:
+ if (lower_dir_dentry)
+}
diff --git a/fs/unionfs/whiteout.c b/fs/unionfs/whiteout.c
new file mode 100644
-index 0000000..405073a
+index 0000000..582cef2
--- /dev/null
+++ b/fs/unionfs/whiteout.c
-@@ -0,0 +1,584 @@
+@@ -0,0 +1,601 @@
+/*
-+ * Copyright (c) 2003-2010 Erez Zadok
++ * Copyright (c) 2003-2011 Erez Zadok
+ * Copyright (c) 2003-2006 Charles P. Wright
+ * Copyright (c) 2005-2007 Josef 'Jeff' Sipek
+ * Copyright (c) 2005-2006 Junjiro Okajima
+ * Copyright (c) 2003-2004 Mohammad Nayyer Zubair
+ * Copyright (c) 2003 Puja Gupta
+ * Copyright (c) 2003 Harikesavan Krishnan
-+ * Copyright (c) 2003-2010 Stony Brook University
-+ * Copyright (c) 2003-2010 The Research Foundation of SUNY
++ * Copyright (c) 2003-2011 Stony Brook University
++ * Copyright (c) 2003-2011 The Research Foundation of SUNY
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * Checks to see if there's a whiteout in @lower_dentry's parent directory,
+ * whose name is taken from @dentry. Then tries to remove that whiteout, if
+ * found. If <dentry,bindex> is a branch marked readonly, return -EROFS.
-+ * If it finds both a regular file and a whiteout, return -EIO (this should
-+ * never happen).
++ * If it finds both a regular file and a whiteout, delete whiteout (this
++ * should never happen).
+ *
+ * Return 0 if no whiteout was found. Return 1 if one was found and
+ * successfully removed. Therefore a value >= 0 tells the caller that
+ }
+
+ /* check if regular file and whiteout were both found */
-+ if (unlikely(lower_dentry->d_inode)) {
-+ err = -EIO;
-+ printk(KERN_ERR "unionfs: found both whiteout and regular "
-+ "file in directory %s (branch %d)\n",
++ if (unlikely(lower_dentry->d_inode))
++ printk(KERN_WARNING "unionfs: removing whiteout; regular "
++ "file exists in directory %s (branch %d)\n",
+ lower_dir_dentry->d_name.name, bindex);
-+ goto out_dput;
-+ }
+
+ /* check if branch is writeable */
+ err = is_robranch_super(dentry->d_sb, bindex);
+ struct dentry *wh_lower_dentry;
+ struct inode *lower_inode;
+ struct sioq_args args;
++ struct nameidata lower_nd;
+
+ lower_dentry = unionfs_lower_dentry_idx(dentry, bindex);
+ lower_inode = lower_dentry->d_inode;
+ mutex_lock(&lower_inode->i_mutex);
+
+ if (!inode_permission(lower_inode, MAY_EXEC)) {
++ err = init_lower_nd(&lower_nd, LOOKUP_OPEN);
++ if (unlikely(err < 0)) {
++ mutex_unlock(&lower_inode->i_mutex);
++ goto out;
++ }
+ wh_lower_dentry =
-+ lookup_one_len(UNIONFS_DIR_OPAQUE, lower_dentry,
-+ sizeof(UNIONFS_DIR_OPAQUE) - 1);
++ lookup_one_len_nd(UNIONFS_DIR_OPAQUE, lower_dentry,
++ sizeof(UNIONFS_DIR_OPAQUE) - 1,
++ &lower_nd);
++ release_lower_nd(&lower_nd, err);
+ } else {
+ args.is_opaque.dentry = lower_dentry;
+ run_sioq(__is_opaque_dir, &args);
+void __is_opaque_dir(struct work_struct *work)
+{
+ struct sioq_args *args = container_of(work, struct sioq_args, work);
++ struct nameidata lower_nd;
++ int err;
+
-+ args->ret = lookup_one_len(UNIONFS_DIR_OPAQUE, args->is_opaque.dentry,
-+ sizeof(UNIONFS_DIR_OPAQUE) - 1);
++ err = init_lower_nd(&lower_nd, LOOKUP_OPEN);
++ if (unlikely(err < 0))
++ return;
++ args->ret = lookup_one_len_nd(UNIONFS_DIR_OPAQUE,
++ args->is_opaque.dentry,
++ sizeof(UNIONFS_DIR_OPAQUE) - 1,
++ &lower_nd);
++ release_lower_nd(&lower_nd, err);
+ complete(&args->comp);
+}
+
+ !S_ISDIR(lower_dir->i_mode));
+
+ mutex_lock(&lower_dir->i_mutex);
-+ diropq = lookup_one_len(UNIONFS_DIR_OPAQUE, lower_dentry,
-+ sizeof(UNIONFS_DIR_OPAQUE) - 1);
++ err = init_lower_nd(&nd, LOOKUP_OPEN);
++ if (unlikely(err < 0))
++ goto out;
++ diropq = lookup_one_len_nd(UNIONFS_DIR_OPAQUE, lower_dentry,
++ sizeof(UNIONFS_DIR_OPAQUE) - 1, &nd);
++ release_lower_nd(&nd, err);
+ if (IS_ERR(diropq)) {
+ err = PTR_ERR(diropq);
+ goto out;
+}
diff --git a/fs/unionfs/xattr.c b/fs/unionfs/xattr.c
new file mode 100644
-index 0000000..9002e06
+index 0000000..a93d803
--- /dev/null
+++ b/fs/unionfs/xattr.c
@@ -0,0 +1,173 @@
+/*
-+ * Copyright (c) 2003-2010 Erez Zadok
++ * Copyright (c) 2003-2011 Erez Zadok
+ * Copyright (c) 2003-2006 Charles P. Wright
+ * Copyright (c) 2005-2007 Josef 'Jeff' Sipek
+ * Copyright (c) 2005-2006 Junjiro Okajima
+ * Copyright (c) 2003-2004 Mohammad Nayyer Zubair
+ * Copyright (c) 2003 Puja Gupta
+ * Copyright (c) 2003 Harikesavan Krishnan
-+ * Copyright (c) 2003-2010 Stony Brook University
-+ * Copyright (c) 2003-2010 The Research Foundation of SUNY
++ * Copyright (c) 2003-2011 Stony Brook University
++ * Copyright (c) 2003-2011 The Research Foundation of SUNY
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
*/
diff --git a/include/linux/magic.h b/include/linux/magic.h
-index 62730ea..bd9832b 100644
+index 2d4beab..39f5798 100644
--- a/include/linux/magic.h
+++ b/include/linux/magic.h
-@@ -48,6 +48,8 @@
+@@ -50,6 +50,8 @@
#define REISER2FS_SUPER_MAGIC_STRING "ReIsEr2Fs"
#define REISER2FS_JR_SUPER_MAGIC_STRING "ReIsEr3Fs"
#define USBDEVICE_SUPER_MAGIC 0x9fa2
#define CGROUP_SUPER_MAGIC 0x27e0eb
diff --git a/include/linux/namei.h b/include/linux/namei.h
-index f276d4f..cf4ec6c 100644
+index ffc0213..99802c3 100644
--- a/include/linux/namei.h
+++ b/include/linux/namei.h
-@@ -78,6 +78,7 @@ extern int vfs_path_lookup(struct dentry *, struct vfsmount *,
+@@ -84,8 +84,11 @@ extern int vfs_path_lookup(struct dentry *, struct vfsmount *,
extern struct file *lookup_instantiate_filp(struct nameidata *nd, struct dentry *dentry,
int (*open)(struct inode *, struct file *));
+extern void release_open_intent(struct nameidata *);
extern struct dentry *lookup_one_len(const char *, struct dentry *, int);
++extern struct dentry *lookup_one_len_nd(const char *, struct dentry *, int,
++ struct nameidata *nd);
+ extern int follow_down_one(struct path *);
+ extern int follow_down(struct path *);
diff --git a/include/linux/splice.h b/include/linux/splice.h
-index 997c3b4..54f5501 100644
+index 26e5b61..28213e6 100644
--- a/include/linux/splice.h
+++ b/include/linux/splice.h
@@ -81,6 +81,11 @@ extern ssize_t splice_to_pipe(struct pipe_inode_info *,
+#endif /* _LINUX_UNIONFS_H */
+
diff --git a/security/security.c b/security/security.c
-index 7b7308a..abdb5a5 100644
+index d754249..f7e8373 100644
--- a/security/security.c
+++ b/security/security.c
-@@ -511,6 +511,7 @@ int security_inode_permission(struct inode *inode, int mask)
+@@ -538,6 +538,7 @@ int security_inode_permission(struct inode *inode, int mask)
return 0;
return security_ops->inode_permission(inode, mask);
}
+EXPORT_SYMBOL(security_inode_permission);
- int security_inode_exec_permission(struct inode *inode, unsigned int flags)
+ int security_inode_setattr(struct dentry *dentry, struct iattr *attr)
{
projects / packages / kernel.git / blobdiff