* [PATCH 01/76] VFS: Make clone_mnt()/copy_tree()/collect_mounts() return errors
2011-06-17 16:00 [RFC][PATCH 00/76] Union Mount David Howells
@ 2011-06-17 16:00 ` David Howells
2011-06-17 16:00 ` [PATCH 02/76] VFS: Add hard read-only users count to superblock David Howells
` (75 subsequent siblings)
76 siblings, 0 replies; 79+ messages in thread
From: David Howells @ 2011-06-17 16:00 UTC (permalink / raw)
To: linux-fsdevel; +Cc: hch
From: Valerie Aurora <vaurora@redhat.com>
copy_tree() can theoretically fail in a case other than ENOMEM, but
always returns NULL which is interpreted by callers as -ENOMEM.
Convert to return an explicit error. Convert clone_mnt() for
consistency and because union mounts will add new error cases.
Thanks to Andreas Gruenbacher <agruen@suse.de> for a bug fix.
Cc: Andreas Gruenbacher <agruen@suse.de>
---
fs/namespace.c | 113 ++++++++++++++++++++++++++++-----------------------
fs/pnode.c | 5 +-
kernel/audit_tree.c | 10 ++---
3 files changed, 69 insertions(+), 59 deletions(-)
diff --git a/fs/namespace.c b/fs/namespace.c
index fe59bd1..c9ed64b 100644
--- a/fs/namespace.c
+++ b/fs/namespace.c
@@ -704,53 +704,57 @@ static struct vfsmount *clone_mnt(struct vfsmount *old, struct dentry *root,
int flag)
{
struct super_block *sb = old->mnt_sb;
- struct vfsmount *mnt = alloc_vfsmnt(old->mnt_devname);
+ struct vfsmount *mnt;
+ int err;
- if (mnt) {
- if (flag & (CL_SLAVE | CL_PRIVATE))
- mnt->mnt_group_id = 0; /* not a peer of original */
- else
- mnt->mnt_group_id = old->mnt_group_id;
-
- if ((flag & CL_MAKE_SHARED) && !mnt->mnt_group_id) {
- int err = mnt_alloc_group_id(mnt);
- if (err)
- goto out_free;
- }
+ mnt = alloc_vfsmnt(old->mnt_devname);
+ if (!mnt)
+ return ERR_PTR(-ENOMEM);
- mnt->mnt_flags = old->mnt_flags & ~MNT_WRITE_HOLD;
- atomic_inc(&sb->s_active);
- mnt->mnt_sb = sb;
- mnt->mnt_root = dget(root);
- mnt->mnt_mountpoint = mnt->mnt_root;
- mnt->mnt_parent = mnt;
-
- if (flag & CL_SLAVE) {
- list_add(&mnt->mnt_slave, &old->mnt_slave_list);
- mnt->mnt_master = old;
- CLEAR_MNT_SHARED(mnt);
- } else if (!(flag & CL_PRIVATE)) {
- if ((flag & CL_MAKE_SHARED) || IS_MNT_SHARED(old))
- list_add(&mnt->mnt_share, &old->mnt_share);
- if (IS_MNT_SLAVE(old))
- list_add(&mnt->mnt_slave, &old->mnt_slave);
- mnt->mnt_master = old->mnt_master;
- }
- if (flag & CL_MAKE_SHARED)
- set_mnt_shared(mnt);
-
- /* stick the duplicate mount on the same expiry list
- * as the original if that was on one */
- if (flag & CL_EXPIRE) {
- if (!list_empty(&old->mnt_expire))
- list_add(&mnt->mnt_expire, &old->mnt_expire);
- }
+ if (flag & (CL_SLAVE | CL_PRIVATE))
+ mnt->mnt_group_id = 0; /* not a peer of original */
+ else
+ mnt->mnt_group_id = old->mnt_group_id;
+
+ if ((flag & CL_MAKE_SHARED) && !mnt->mnt_group_id) {
+ err = mnt_alloc_group_id(mnt);
+ if (err)
+ goto out_free;
+ }
+
+ mnt->mnt_flags = old->mnt_flags & ~MNT_WRITE_HOLD;
+ atomic_inc(&sb->s_active);
+ mnt->mnt_sb = sb;
+ mnt->mnt_root = dget(root);
+ mnt->mnt_mountpoint = mnt->mnt_root;
+ mnt->mnt_parent = mnt;
+
+ if (flag & CL_SLAVE) {
+ list_add(&mnt->mnt_slave, &old->mnt_slave_list);
+ mnt->mnt_master = old;
+ CLEAR_MNT_SHARED(mnt);
+ } else if (!(flag & CL_PRIVATE)) {
+ if ((flag & CL_MAKE_SHARED) || IS_MNT_SHARED(old))
+ list_add(&mnt->mnt_share, &old->mnt_share);
+ if (IS_MNT_SLAVE(old))
+ list_add(&mnt->mnt_slave, &old->mnt_slave);
+ mnt->mnt_master = old->mnt_master;
}
+ if (flag & CL_MAKE_SHARED)
+ set_mnt_shared(mnt);
+
+ /* stick the duplicate mount on the same expiry list as the
+ * original if that was on one */
+ if (flag & CL_EXPIRE) {
+ if (!list_empty(&old->mnt_expire))
+ list_add(&mnt->mnt_expire, &old->mnt_expire);
+ }
+
return mnt;
out_free:
free_vfsmnt(mnt);
- return NULL;
+ return ERR_PTR(err);
}
static inline void mntfree(struct vfsmount *mnt)
@@ -1429,11 +1433,12 @@ struct vfsmount *copy_tree(struct vfsmount *mnt, struct dentry *dentry,
struct path path;
if (!(flag & CL_COPY_ALL) && IS_MNT_UNBINDABLE(mnt))
- return NULL;
+ return ERR_PTR(-EINVAL);
res = q = clone_mnt(mnt, dentry, flag);
- if (!q)
- goto Enomem;
+ if (IS_ERR(q))
+ return q;
+
q->mnt_mountpoint = mnt->mnt_mountpoint;
p = mnt;
@@ -1454,8 +1459,8 @@ struct vfsmount *copy_tree(struct vfsmount *mnt, struct dentry *dentry,
path.mnt = q;
path.dentry = p->mnt_mountpoint;
q = clone_mnt(p, p->mnt_root, flag);
- if (!q)
- goto Enomem;
+ if (IS_ERR(q))
+ goto out;
br_write_lock(vfsmount_lock);
list_add_tail(&q->mnt_list, &res->mnt_list);
attach_mnt(q, &path);
@@ -1463,7 +1468,7 @@ struct vfsmount *copy_tree(struct vfsmount *mnt, struct dentry *dentry,
}
}
return res;
-Enomem:
+out:
if (res) {
LIST_HEAD(umount_list);
br_write_lock(vfsmount_lock);
@@ -1471,9 +1476,11 @@ Enomem:
br_write_unlock(vfsmount_lock);
release_mounts(&umount_list);
}
- return NULL;
+ return q;
}
+/* Caller should check returned pointer for errors */
+
struct vfsmount *collect_mounts(struct path *path)
{
struct vfsmount *tree;
@@ -1772,14 +1779,15 @@ static int do_loopback(struct path *path, char *old_name,
if (!check_mnt(path->mnt) || !check_mnt(old_path.mnt))
goto out2;
- err = -ENOMEM;
if (recurse)
mnt = copy_tree(old_path.mnt, old_path.dentry, 0);
else
mnt = clone_mnt(old_path.mnt, old_path.dentry, 0);
- if (!mnt)
- goto out2;
+ if (IS_ERR(mnt)) {
+ err = PTR_ERR(mnt);
+ goto out;
+ }
err = graft_tree(mnt, path);
if (err) {
@@ -2405,10 +2413,11 @@ static struct mnt_namespace *dup_mnt_ns(struct mnt_namespace *mnt_ns,
/* First pass: copy the tree topology */
new_ns->root = copy_tree(mnt_ns->root, mnt_ns->root->mnt_root,
CL_COPY_ALL | CL_EXPIRE);
- if (!new_ns->root) {
+ if (IS_ERR(new_ns->root)) {
+ int err = PTR_ERR(new_ns->root);
up_write(&namespace_sem);
kfree(new_ns);
- return ERR_PTR(-ENOMEM);
+ return ERR_PTR(err);
}
br_write_lock(vfsmount_lock);
list_add_tail(&new_ns->list, &new_ns->root->mnt_list);
diff --git a/fs/pnode.c b/fs/pnode.c
index d42514e..8b53484 100644
--- a/fs/pnode.c
+++ b/fs/pnode.c
@@ -253,8 +253,9 @@ int propagate_mnt(struct vfsmount *dest_mnt, struct dentry *dest_dentry,
source = get_source(m, prev_dest_mnt, prev_src_mnt, &type);
- if (!(child = copy_tree(source, source->mnt_root, type))) {
- ret = -ENOMEM;
+ child = copy_tree(source, source->mnt_root, type);
+ if (IS_ERR(child)) {
+ ret = PTR_ERR(child);
list_splice(tree_list, tmp_list.prev);
goto out;
}
diff --git a/kernel/audit_tree.c b/kernel/audit_tree.c
index e99dda0..7a9da96 100644
--- a/kernel/audit_tree.c
+++ b/kernel/audit_tree.c
@@ -601,7 +601,7 @@ void audit_trim_trees(void)
root_mnt = collect_mounts(&path);
path_put(&path);
- if (!root_mnt)
+ if (IS_ERR(root_mnt))
goto skip_it;
spin_lock(&hash_lock);
@@ -675,8 +675,8 @@ int audit_add_tree_rule(struct audit_krule *rule)
goto Err;
mnt = collect_mounts(&path);
path_put(&path);
- if (!mnt) {
- err = -ENOMEM;
+ if (IS_ERR(mnt)) {
+ err = PTR_ERR(mnt);
goto Err;
}
@@ -725,8 +725,8 @@ int audit_tag_tree(char *old, char *new)
return err;
tagged = collect_mounts(&path2);
path_put(&path2);
- if (!tagged)
- return -ENOMEM;
+ if (IS_ERR(tagged))
+ return PTR_ERR(tagged);
err = kern_path(old, 0, &path1);
if (err) {
^ permalink raw reply related [flat|nested] 79+ messages in thread* [PATCH 02/76] VFS: Add hard read-only users count to superblock
2011-06-17 16:00 [RFC][PATCH 00/76] Union Mount David Howells
2011-06-17 16:00 ` [PATCH 01/76] VFS: Make clone_mnt()/copy_tree()/collect_mounts() return errors David Howells
@ 2011-06-17 16:00 ` David Howells
2011-06-17 16:00 ` [PATCH 03/76] VFS: Add CL_NO_SHARED flag to clone_mnt()/copy_tree() David Howells
` (74 subsequent siblings)
76 siblings, 0 replies; 79+ messages in thread
From: David Howells @ 2011-06-17 16:00 UTC (permalink / raw)
To: linux-fsdevel; +Cc: hch
From: Valerie Aurora <vaurora@redhat.com>
While we can check if a file system is currently read-only, we can't
guarantee that it will stay read-only. The file system can be mounted
or remounted read-write at any time. This is a problem for union
mounts, which require the underlying file system be read-only for the
entire duration of the union mount.
Add a hard read-only users count to the superblock. When this count
is non-zero, don't allow any read-write mounts of this super, or any
read-write remounts of existing mounts.
---
fs/super.c | 11 +++++++++++
include/linux/fs.h | 7 +++++++
2 files changed, 18 insertions(+), 0 deletions(-)
diff --git a/fs/super.c b/fs/super.c
index ab3d672..511f657 100644
--- a/fs/super.c
+++ b/fs/super.c
@@ -130,6 +130,7 @@ static inline void destroy_super(struct super_block *s)
#ifdef CONFIG_SMP
free_percpu(s->s_files);
#endif
+ BUG_ON(s->s_hard_readonly_users);
security_sb_free(s);
kfree(s->s_subtype);
kfree(s->s_options);
@@ -587,6 +588,9 @@ int do_remount_sb(struct super_block *sb, int flags, void *data, int force)
return -EBUSY;
}
+ if (!(flags & MS_RDONLY) && sb->s_hard_readonly_users)
+ return -EROFS;
+
if (sb->s_op->remount_fs) {
retval = sb->s_op->remount_fs(sb, &flags, data);
if (retval)
@@ -956,9 +960,16 @@ mount_fs(struct file_system_type *type, int flags, const char *name, void *data)
WARN((sb->s_maxbytes < 0), "%s set sb->s_maxbytes to "
"negative value (%lld)\n", type->name, sb->s_maxbytes);
+ if (!(flags & MS_RDONLY) && sb->s_hard_readonly_users)
+ goto out_sb_is_hard_ro;
+
up_write(&sb->s_umount);
free_secdata(secdata);
return root;
+
+out_sb_is_hard_ro:
+ up_write(&sb->s_umount);
+ error = -EROFS;
out_sb:
dput(root);
deactivate_locked_super(sb);
diff --git a/include/linux/fs.h b/include/linux/fs.h
index 1c77787..43c17d0 100644
--- a/include/linux/fs.h
+++ b/include/linux/fs.h
@@ -1437,6 +1437,13 @@ struct super_block {
* Saved pool identifier for cleancache (-1 means none)
*/
int cleancache_poolid;
+
+ /*
+ * Number of mounts requiring that the underlying file system never
+ * transition to read-write. Protected by s_umount. Decremented by
+ * free_vfsmnt() if MNT_HARD_READONLY is set.
+ */
+ int s_hard_readonly_users;
};
extern struct timespec current_fs_time(struct super_block *sb);
^ permalink raw reply related [flat|nested] 79+ messages in thread* [PATCH 03/76] VFS: Add CL_NO_SHARED flag to clone_mnt()/copy_tree()
2011-06-17 16:00 [RFC][PATCH 00/76] Union Mount David Howells
2011-06-17 16:00 ` [PATCH 01/76] VFS: Make clone_mnt()/copy_tree()/collect_mounts() return errors David Howells
2011-06-17 16:00 ` [PATCH 02/76] VFS: Add hard read-only users count to superblock David Howells
@ 2011-06-17 16:00 ` David Howells
2011-06-17 16:00 ` [PATCH 04/76] VFS: Add CL_NO_SLAVE " David Howells
` (73 subsequent siblings)
76 siblings, 0 replies; 79+ messages in thread
From: David Howells @ 2011-06-17 16:00 UTC (permalink / raw)
To: linux-fsdevel; +Cc: hch
From: Valerie Aurora <vaurora@redhat.com>
Passing the CL_NO_SHARED flag to clone_mnt() causes the clone to fail
if the source mnt is shared.
Cc: Ram Pai <linuxram@us.ibm.com>
---
fs/namespace.c | 3 +++
fs/pnode.h | 1 +
2 files changed, 4 insertions(+), 0 deletions(-)
diff --git a/fs/namespace.c b/fs/namespace.c
index c9ed64b..c10394d 100644
--- a/fs/namespace.c
+++ b/fs/namespace.c
@@ -707,6 +707,9 @@ static struct vfsmount *clone_mnt(struct vfsmount *old, struct dentry *root,
struct vfsmount *mnt;
int err;
+ if ((flag & CL_NO_SHARED) && IS_MNT_SHARED(old))
+ return ERR_PTR(-EINVAL);
+
mnt = alloc_vfsmnt(old->mnt_devname);
if (!mnt)
return ERR_PTR(-ENOMEM);
diff --git a/fs/pnode.h b/fs/pnode.h
index 1ea4ae1..bcb3c47 100644
--- a/fs/pnode.h
+++ b/fs/pnode.h
@@ -22,6 +22,7 @@
#define CL_COPY_ALL 0x04
#define CL_MAKE_SHARED 0x08
#define CL_PRIVATE 0x10
+#define CL_NO_SHARED 0x20
static inline void set_mnt_shared(struct vfsmount *mnt)
{
^ permalink raw reply related [flat|nested] 79+ messages in thread* [PATCH 04/76] VFS: Add CL_NO_SLAVE flag to clone_mnt()/copy_tree()
2011-06-17 16:00 [RFC][PATCH 00/76] Union Mount David Howells
` (2 preceding siblings ...)
2011-06-17 16:00 ` [PATCH 03/76] VFS: Add CL_NO_SHARED flag to clone_mnt()/copy_tree() David Howells
@ 2011-06-17 16:00 ` David Howells
2011-06-17 16:00 ` [PATCH 05/76] VFS: Add CL_MAKE_HARD_READONLY " David Howells
` (72 subsequent siblings)
76 siblings, 0 replies; 79+ messages in thread
From: David Howells @ 2011-06-17 16:00 UTC (permalink / raw)
To: linux-fsdevel; +Cc: hch
From: Valerie Aurora <vaurora@redhat.com>
Passing the CL_NO_SLAVE flag to clone_mnt() causes the clone
to fail if the source mnt is a slave.
Cc: Ram Pai <linuxram@us.ibm.com>
---
fs/namespace.c | 3 +++
fs/pnode.h | 1 +
2 files changed, 4 insertions(+), 0 deletions(-)
diff --git a/fs/namespace.c b/fs/namespace.c
index c10394d..a9e5e06 100644
--- a/fs/namespace.c
+++ b/fs/namespace.c
@@ -710,6 +710,9 @@ static struct vfsmount *clone_mnt(struct vfsmount *old, struct dentry *root,
if ((flag & CL_NO_SHARED) && IS_MNT_SHARED(old))
return ERR_PTR(-EINVAL);
+ if ((flag & CL_NO_SLAVE) && IS_MNT_SLAVE(old))
+ return ERR_PTR(-EINVAL);
+
mnt = alloc_vfsmnt(old->mnt_devname);
if (!mnt)
return ERR_PTR(-ENOMEM);
diff --git a/fs/pnode.h b/fs/pnode.h
index bcb3c47..8920e47 100644
--- a/fs/pnode.h
+++ b/fs/pnode.h
@@ -23,6 +23,7 @@
#define CL_MAKE_SHARED 0x08
#define CL_PRIVATE 0x10
#define CL_NO_SHARED 0x20
+#define CL_NO_SLAVE 0x40
static inline void set_mnt_shared(struct vfsmount *mnt)
{
^ permalink raw reply related [flat|nested] 79+ messages in thread* [PATCH 05/76] VFS: Add CL_MAKE_HARD_READONLY flag to clone_mnt()/copy_tree()
2011-06-17 16:00 [RFC][PATCH 00/76] Union Mount David Howells
` (3 preceding siblings ...)
2011-06-17 16:00 ` [PATCH 04/76] VFS: Add CL_NO_SLAVE " David Howells
@ 2011-06-17 16:00 ` David Howells
2011-06-17 16:01 ` [PATCH 06/76] VFS: Comment follow_mount() and friends David Howells
` (71 subsequent siblings)
76 siblings, 0 replies; 79+ messages in thread
From: David Howells @ 2011-06-17 16:00 UTC (permalink / raw)
To: linux-fsdevel; +Cc: hch
From: Valerie Aurora <vaurora@redhat.com>
Passing the CL_MAKE_HARD_READONLY flag to clone_mnt() causes the clone
to fail if the source superblock is not read-only. If it is
read-only, it increments the hard read-only users and sets the
MNT_HARD_READONLY flag in the vfsmount. When the mount is freed via
free_vfsmnt(), automatically decrement the hard read-only users count.
Cc: Ram Pai <linuxram@us.ibm.com>
---
fs/namespace.c | 18 ++++++++++++++++++
fs/pnode.h | 1 +
include/linux/mount.h | 1 +
3 files changed, 20 insertions(+), 0 deletions(-)
diff --git a/fs/namespace.c b/fs/namespace.c
index a9e5e06..8306871 100644
--- a/fs/namespace.c
+++ b/fs/namespace.c
@@ -469,6 +469,12 @@ static void __mnt_unmake_readonly(struct vfsmount *mnt)
static void free_vfsmnt(struct vfsmount *mnt)
{
kfree(mnt->mnt_devname);
+ if (mnt->mnt_flags & MNT_HARD_READONLY) {
+ BUG_ON(mnt->mnt_sb->s_hard_readonly_users <= 0);
+ down_write(&mnt->mnt_sb->s_umount);
+ mnt->mnt_sb->s_hard_readonly_users--;
+ up_write(&mnt->mnt_sb->s_umount);
+ }
mnt_free_id(mnt);
#ifdef CONFIG_SMP
free_percpu(mnt->mnt_pcp);
@@ -713,6 +719,16 @@ static struct vfsmount *clone_mnt(struct vfsmount *old, struct dentry *root,
if ((flag & CL_NO_SLAVE) && IS_MNT_SLAVE(old))
return ERR_PTR(-EINVAL);
+ if (flag & CL_MAKE_HARD_READONLY) {
+ down_write(&sb->s_umount);
+ if (!(sb->s_flags & MS_RDONLY)) {
+ up_write(&sb->s_umount);
+ return ERR_PTR(-EBUSY);
+ }
+ sb->s_hard_readonly_users++;
+ up_write(&sb->s_umount);
+ }
+
mnt = alloc_vfsmnt(old->mnt_devname);
if (!mnt)
return ERR_PTR(-ENOMEM);
@@ -748,6 +764,8 @@ static struct vfsmount *clone_mnt(struct vfsmount *old, struct dentry *root,
}
if (flag & CL_MAKE_SHARED)
set_mnt_shared(mnt);
+ if (flag & CL_MAKE_HARD_READONLY)
+ mnt->mnt_flags |= MNT_HARD_READONLY;
/* stick the duplicate mount on the same expiry list as the
* original if that was on one */
diff --git a/fs/pnode.h b/fs/pnode.h
index 8920e47..dc7b468 100644
--- a/fs/pnode.h
+++ b/fs/pnode.h
@@ -24,6 +24,7 @@
#define CL_PRIVATE 0x10
#define CL_NO_SHARED 0x20
#define CL_NO_SLAVE 0x40
+#define CL_MAKE_HARD_READONLY 0x80
static inline void set_mnt_shared(struct vfsmount *mnt)
{
diff --git a/include/linux/mount.h b/include/linux/mount.h
index 604f122..7101157 100644
--- a/include/linux/mount.h
+++ b/include/linux/mount.h
@@ -46,6 +46,7 @@ struct mnt_namespace;
#define MNT_INTERNAL 0x4000
+#define MNT_HARD_READONLY 0x8000 /* has a hard read-only ref on the sb */
struct mnt_pcp {
int mnt_count;
^ permalink raw reply related [flat|nested] 79+ messages in thread* [PATCH 06/76] VFS: Comment follow_mount() and friends
2011-06-17 16:00 [RFC][PATCH 00/76] Union Mount David Howells
` (4 preceding siblings ...)
2011-06-17 16:00 ` [PATCH 05/76] VFS: Add CL_MAKE_HARD_READONLY " David Howells
@ 2011-06-17 16:01 ` David Howells
2011-06-17 16:53 ` Christoph Hellwig
2011-06-17 16:01 ` [PATCH 07/76] VFS: Make lookup_hash() return a struct path David Howells
` (70 subsequent siblings)
76 siblings, 1 reply; 79+ messages in thread
From: David Howells @ 2011-06-17 16:01 UTC (permalink / raw)
To: linux-fsdevel; +Cc: hch
From: Valerie Aurora <vaurora@redhat.com>
Add comments describing what the directions "up" and "down" mean and
ref count handling to the VFS follow_mount() family of functions.
Signed-off-by: Valerie Aurora <vaurora@redhat.com>
Cc: Alexander Viro <viro@zeniv.linux.org.uk>
---
fs/namei.c | 10 ++++++++++
fs/namespace.c | 16 ++++++++++++++--
2 files changed, 24 insertions(+), 2 deletions(-)
diff --git a/fs/namei.c b/fs/namei.c
index 9802345..9c4c331 100644
--- a/fs/namei.c
+++ b/fs/namei.c
@@ -735,6 +735,16 @@ static int follow_up_rcu(struct path *path)
return 1;
}
+/*
+ * follow_up - Find the mountpoint of path's vfsmount
+ *
+ * Given a path, find the mountpoint of its source file system.
+ * Replace @path with the path of the mountpoint in the parent mount.
+ * Up is towards /.
+ *
+ * Return 1 if we went up a level and 0 if we were already at the
+ * root.
+ */
int follow_up(struct path *path)
{
struct vfsmount *parent;
diff --git a/fs/namespace.c b/fs/namespace.c
index 8306871..b1ffb3b 100644
--- a/fs/namespace.c
+++ b/fs/namespace.c
@@ -509,8 +509,20 @@ struct vfsmount *__lookup_mnt(struct vfsmount *mnt, struct dentry *dentry,
}
/*
- * lookup_mnt increments the ref count before returning
- * the vfsmount struct.
+ * lookup_mnt - Return the first child mount mounted at path
+ *
+ * "First" means first mounted chronologically. If you create the
+ * following mounts:
+ *
+ * mount /dev/sda1 /mnt
+ * mount /dev/sda2 /mnt
+ * mount /dev/sda3 /mnt
+ *
+ * Then lookup_mnt() on the base /mnt dentry in the root mount will
+ * return successively the root dentry and vfsmount of /dev/sda1, then
+ * /dev/sda2, then /dev/sda3, then NULL.
+ *
+ * lookup_mnt takes a reference to the found vfsmount.
*/
struct vfsmount *lookup_mnt(struct path *path)
{
^ permalink raw reply related [flat|nested] 79+ messages in thread* [PATCH 07/76] VFS: Make lookup_hash() return a struct path
2011-06-17 16:00 [RFC][PATCH 00/76] Union Mount David Howells
` (5 preceding siblings ...)
2011-06-17 16:01 ` [PATCH 06/76] VFS: Comment follow_mount() and friends David Howells
@ 2011-06-17 16:01 ` David Howells
2011-06-17 16:01 ` [PATCH 08/76] whiteout/NFSD: Don't return information about whiteouts to userspace David Howells
` (69 subsequent siblings)
76 siblings, 0 replies; 79+ messages in thread
From: David Howells @ 2011-06-17 16:01 UTC (permalink / raw)
To: linux-fsdevel; +Cc: hch
From: Jan Blunck <jblunck@suse.de>
Signed-off-by: Jan Blunck <jblunck@suse.de>
Signed-off-by: Valerie Aurora <vaurora@redhat.com>
Cc: Alexander Viro <viro@zeniv.linux.org.uk>
---
fs/namei.c | 127 +++++++++++++++++++++++++++++++-----------------------------
1 files changed, 65 insertions(+), 62 deletions(-)
diff --git a/fs/namei.c b/fs/namei.c
index 9c4c331..272bead 100644
--- a/fs/namei.c
+++ b/fs/namei.c
@@ -1694,9 +1694,20 @@ static struct dentry *__lookup_hash(struct qstr *name,
* needs parent already locked. Doesn't follow mounts.
* SMP-safe.
*/
-static struct dentry *lookup_hash(struct nameidata *nd)
+static int lookup_hash(struct nameidata *nd, struct qstr *name,
+ struct path *path)
{
- return __lookup_hash(&nd->last, nd->path.dentry, nd);
+ struct dentry *result;
+
+ result = __lookup_hash(name, nd->path.dentry, nd);
+ if (IS_ERR(result)) {
+ path->mnt = NULL;
+ path->dentry = NULL;
+ return PTR_ERR(result);
+ }
+ path->mnt = nd->path.mnt;
+ path->dentry = result;
+ return 0;
}
/**
@@ -2040,7 +2051,6 @@ static struct file *do_last(struct nameidata *nd, struct path *path,
const struct open_flags *op, const char *pathname)
{
struct dentry *dir = nd->path.dentry;
- struct dentry *dentry;
int open_flag = op->open_flag;
int will_truncate = open_flag & O_TRUNC;
int want_write = 0;
@@ -2116,18 +2126,14 @@ static struct file *do_last(struct nameidata *nd, struct path *path,
mutex_lock(&dir->d_inode->i_mutex);
- dentry = lookup_hash(nd);
- error = PTR_ERR(dentry);
- if (IS_ERR(dentry)) {
+ error = lookup_hash(nd, &nd->last, path);
+ if (error) {
mutex_unlock(&dir->d_inode->i_mutex);
goto exit;
}
- path->dentry = dentry;
- path->mnt = nd->path.mnt;
-
/* Negative dentry, just create the file */
- if (!dentry->d_inode) {
+ if (!path->dentry->d_inode) {
int mode = op->mode;
if (!IS_POSIXACL(dir->d_inode))
mode &= ~current_umask();
@@ -2146,15 +2152,15 @@ static struct file *do_last(struct nameidata *nd, struct path *path,
open_flag &= ~O_TRUNC;
will_truncate = 0;
acc_mode = MAY_OPEN;
- error = security_path_mknod(&nd->path, dentry, mode, 0);
+ error = security_path_mknod(&nd->path, path->dentry, mode, 0);
if (error)
goto exit_mutex_unlock;
- error = vfs_create(dir->d_inode, dentry, mode, nd);
+ error = vfs_create(dir->d_inode, path->dentry, mode, nd);
if (error)
goto exit_mutex_unlock;
mutex_unlock(&dir->d_inode->i_mutex);
dput(nd->path.dentry);
- nd->path.dentry = dentry;
+ nd->path.dentry = path->dentry;
goto common;
}
@@ -2332,11 +2338,13 @@ struct file *do_file_open_root(struct dentry *dentry, struct vfsmount *mnt,
* Simple function to lookup and return a dentry and create it
* if it doesn't exist. Is SMP-safe.
*
- * Returns with nd->path.dentry->d_inode->i_mutex locked.
+ * Returns with nd->path.dentry->d_inode->i_mutex locked, even in the case of
+ * an error.
*/
struct dentry *lookup_create(struct nameidata *nd, int is_dir)
{
- struct dentry *dentry = ERR_PTR(-EEXIST);
+ struct path path;
+ int err;
mutex_lock_nested(&nd->path.dentry->d_inode->i_mutex, I_MUTEX_PARENT);
/*
@@ -2344,7 +2352,7 @@ struct dentry *lookup_create(struct nameidata *nd, int is_dir)
* (foo/., foo/.., /////)
*/
if (nd->last_type != LAST_NORM)
- goto fail;
+ return ERR_PTR(-EEXIST);
nd->flags &= ~LOOKUP_PARENT;
nd->flags |= LOOKUP_CREATE | LOOKUP_EXCL;
nd->intent.open.flags = O_EXCL;
@@ -2352,11 +2360,11 @@ struct dentry *lookup_create(struct nameidata *nd, int is_dir)
/*
* Do the final lookup.
*/
- dentry = lookup_hash(nd);
- if (IS_ERR(dentry))
- goto fail;
+ err = lookup_hash(nd, &nd->last, &path);
+ if (err)
+ return ERR_PTR(err);
- if (dentry->d_inode)
+ if (path.dentry->d_inode)
goto eexist;
/*
* Special case - lookup gave negative, but... we had foo/bar/
@@ -2365,15 +2373,14 @@ struct dentry *lookup_create(struct nameidata *nd, int is_dir)
* been asking for (non-existent) directory. -ENOENT for you.
*/
if (unlikely(!is_dir && nd->last.name[nd->last.len])) {
- dput(dentry);
- dentry = ERR_PTR(-ENOENT);
+ dput(path.dentry);
+ return ERR_PTR(-ENOENT);
}
- return dentry;
+
+ return path.dentry;
eexist:
- dput(dentry);
- dentry = ERR_PTR(-EEXIST);
-fail:
- return dentry;
+ path_put_conditional(&path, nd);
+ return ERR_PTR(-EEXIST);
}
EXPORT_SYMBOL_GPL(lookup_create);
@@ -2608,7 +2615,7 @@ static long do_rmdir(int dfd, const char __user *pathname)
{
int error = 0;
char * name;
- struct dentry *dentry;
+ struct path path;
struct nameidata nd;
error = user_path_parent(dfd, pathname, &nd, &name);
@@ -2630,25 +2637,24 @@ static long do_rmdir(int dfd, const char __user *pathname)
nd.flags &= ~LOOKUP_PARENT;
mutex_lock_nested(&nd.path.dentry->d_inode->i_mutex, I_MUTEX_PARENT);
- dentry = lookup_hash(&nd);
- error = PTR_ERR(dentry);
- if (IS_ERR(dentry))
+ error = lookup_hash(&nd, &nd.last, &path);
+ if (error)
goto exit2;
- if (!dentry->d_inode) {
+ if (!path.dentry->d_inode) {
error = -ENOENT;
goto exit3;
}
error = mnt_want_write(nd.path.mnt);
if (error)
goto exit3;
- error = security_path_rmdir(&nd.path, dentry);
+ error = security_path_rmdir(&nd.path, path.dentry);
if (error)
goto exit4;
- error = vfs_rmdir(nd.path.dentry->d_inode, dentry);
+ error = vfs_rmdir(nd.path.dentry->d_inode, path.dentry);
exit4:
mnt_drop_write(nd.path.mnt);
exit3:
- dput(dentry);
+ path_put_conditional(&path, &nd);
exit2:
mutex_unlock(&nd.path.dentry->d_inode->i_mutex);
exit1:
@@ -2704,7 +2710,7 @@ static long do_unlinkat(int dfd, const char __user *pathname)
{
int error;
char *name;
- struct dentry *dentry;
+ struct path path;
struct nameidata nd;
struct inode *inode = NULL;
@@ -2719,25 +2725,24 @@ static long do_unlinkat(int dfd, const char __user *pathname)
nd.flags &= ~LOOKUP_PARENT;
mutex_lock_nested(&nd.path.dentry->d_inode->i_mutex, I_MUTEX_PARENT);
- dentry = lookup_hash(&nd);
- error = PTR_ERR(dentry);
- if (!IS_ERR(dentry)) {
+ error = lookup_hash(&nd, &nd.last, &path);
+ if (!error) {
/* Why not before? Because we want correct error value */
- inode = dentry->d_inode;
+ inode = path.dentry->d_inode;
if (nd.last.name[nd.last.len] || !inode)
goto slashes;
ihold(inode);
error = mnt_want_write(nd.path.mnt);
if (error)
goto exit2;
- error = security_path_unlink(&nd.path, dentry);
+ error = security_path_unlink(&nd.path, path.dentry);
if (error)
goto exit3;
- error = vfs_unlink(nd.path.dentry->d_inode, dentry);
+ error = vfs_unlink(nd.path.dentry->d_inode, path.dentry);
exit3:
mnt_drop_write(nd.path.mnt);
exit2:
- dput(dentry);
+ path_put_conditional(&path, &nd);
}
mutex_unlock(&nd.path.dentry->d_inode->i_mutex);
if (inode)
@@ -2748,8 +2753,8 @@ exit1:
return error;
slashes:
- error = !dentry->d_inode ? -ENOENT :
- S_ISDIR(dentry->d_inode->i_mode) ? -EISDIR : -ENOTDIR;
+ error = !path.dentry->d_inode ? -ENOENT :
+ S_ISDIR(path.dentry->d_inode->i_mode) ? -EISDIR : -ENOTDIR;
goto exit2;
}
@@ -3101,7 +3106,7 @@ SYSCALL_DEFINE4(renameat, int, olddfd, const char __user *, oldname,
int, newdfd, const char __user *, newname)
{
struct dentry *old_dir, *new_dir;
- struct dentry *old_dentry, *new_dentry;
+ struct path old, new;
struct dentry *trap;
struct nameidata oldnd, newnd;
char *from;
@@ -3135,16 +3140,15 @@ SYSCALL_DEFINE4(renameat, int, olddfd, const char __user *, oldname,
trap = lock_rename(new_dir, old_dir);
- old_dentry = lookup_hash(&oldnd);
- error = PTR_ERR(old_dentry);
- if (IS_ERR(old_dentry))
+ error = lookup_hash(&oldnd, &oldnd.last, &old);
+ if (error)
goto exit3;
/* source must exist */
error = -ENOENT;
- if (!old_dentry->d_inode)
+ if (!old.dentry->d_inode)
goto exit4;
/* unless the source is a directory trailing slashes give -ENOTDIR */
- if (!S_ISDIR(old_dentry->d_inode->i_mode)) {
+ if (!S_ISDIR(old.dentry->d_inode->i_mode)) {
error = -ENOTDIR;
if (oldnd.last.name[oldnd.last.len])
goto exit4;
@@ -3153,32 +3157,31 @@ SYSCALL_DEFINE4(renameat, int, olddfd, const char __user *, oldname,
}
/* source should not be ancestor of target */
error = -EINVAL;
- if (old_dentry == trap)
+ if (old.dentry == trap)
goto exit4;
- new_dentry = lookup_hash(&newnd);
- error = PTR_ERR(new_dentry);
- if (IS_ERR(new_dentry))
+ error = lookup_hash(&newnd, &newnd.last, &new);
+ if (error)
goto exit4;
/* target should not be an ancestor of source */
error = -ENOTEMPTY;
- if (new_dentry == trap)
+ if (new.dentry == trap)
goto exit5;
error = mnt_want_write(oldnd.path.mnt);
if (error)
goto exit5;
- error = security_path_rename(&oldnd.path, old_dentry,
- &newnd.path, new_dentry);
+ error = security_path_rename(&oldnd.path, old.dentry,
+ &newnd.path, new.dentry);
if (error)
goto exit6;
- error = vfs_rename(old_dir->d_inode, old_dentry,
- new_dir->d_inode, new_dentry);
+ error = vfs_rename(old_dir->d_inode, old.dentry,
+ new_dir->d_inode, new.dentry);
exit6:
mnt_drop_write(oldnd.path.mnt);
exit5:
- dput(new_dentry);
+ path_put_conditional(&new, &newnd);
exit4:
- dput(old_dentry);
+ path_put_conditional(&old, &oldnd);
exit3:
unlock_rename(new_dir, old_dir);
exit2:
^ permalink raw reply related [flat|nested] 79+ messages in thread* [PATCH 08/76] whiteout/NFSD: Don't return information about whiteouts to userspace
2011-06-17 16:00 [RFC][PATCH 00/76] Union Mount David Howells
` (6 preceding siblings ...)
2011-06-17 16:01 ` [PATCH 07/76] VFS: Make lookup_hash() return a struct path David Howells
@ 2011-06-17 16:01 ` David Howells
2011-06-17 16:01 ` [PATCH 09/76] whiteout: Define flags and operations for opaque inodes David Howells
` (68 subsequent siblings)
76 siblings, 0 replies; 79+ messages in thread
From: David Howells @ 2011-06-17 16:01 UTC (permalink / raw)
To: linux-fsdevel; +Cc: hch
From: Jan Blunck <jblunck@suse.de>
Userspace isn't ready for handling another file type, so silently drop
whiteout directory entries before they leave the kernel.
Signed-off-by: Jan Blunck <jblunck@suse.de>
Signed-off-by: David Woodhouse <dwmw2@infradead.org>
Signed-off-by: Valerie Aurora <vaurora@redhat.com>
Acked-by: J. Bruce Fields <bfields@redhat.com>
Cc: linux-nfs@vger.kernel.org
Cc: Neil Brown <neilb@suse.de>
---
fs/compat.c | 9 +++++++++
fs/nfsd/nfs3xdr.c | 5 +++++
fs/nfsd/nfs4xdr.c | 5 +++++
fs/nfsd/nfsxdr.c | 4 ++++
fs/readdir.c | 9 +++++++++
5 files changed, 32 insertions(+), 0 deletions(-)
diff --git a/fs/compat.c b/fs/compat.c
index 0ea0083..10839d7 100644
--- a/fs/compat.c
+++ b/fs/compat.c
@@ -858,6 +858,9 @@ static int compat_fillonedir(void *__buf, const char *name, int namlen,
struct compat_old_linux_dirent __user *dirent;
compat_ulong_t d_ino;
+ if (d_type == DT_WHT)
+ return 0;
+
if (buf->result)
return -EINVAL;
d_ino = ino;
@@ -930,6 +933,9 @@ static int compat_filldir(void *__buf, const char *name, int namlen,
int reclen = ALIGN(offsetof(struct compat_linux_dirent, d_name) +
namlen + 2, sizeof(compat_long_t));
+ if (d_type == DT_WHT)
+ return 0;
+
buf->error = -EINVAL; /* only used if we fail.. */
if (reclen > buf->count)
return -EINVAL;
@@ -1019,6 +1025,9 @@ static int compat_filldir64(void * __buf, const char * name, int namlen, loff_t
sizeof(u64));
u64 off;
+ if (d_type == DT_WHT)
+ return 0;
+
buf->error = -EINVAL; /* only used if we fail.. */
if (reclen > buf->count)
return -EINVAL;
diff --git a/fs/nfsd/nfs3xdr.c b/fs/nfsd/nfs3xdr.c
index 08c6e36..69a60b6 100644
--- a/fs/nfsd/nfs3xdr.c
+++ b/fs/nfsd/nfs3xdr.c
@@ -887,6 +887,11 @@ encode_entry(struct readdir_cd *ccd, const char *name, int namlen,
int elen; /* estimated entry length in words */
int num_entry_words = 0; /* actual number of words */
+ if (d_type == DT_WHT) {
+ cd->common.err = nfs_ok;
+ return 0;
+ }
+
if (cd->offset) {
u64 offset64 = offset;
diff --git a/fs/nfsd/nfs4xdr.c b/fs/nfsd/nfs4xdr.c
index 9901811..84022ba 100644
--- a/fs/nfsd/nfs4xdr.c
+++ b/fs/nfsd/nfs4xdr.c
@@ -2316,6 +2316,11 @@ nfsd4_encode_dirent(void *ccdv, const char *name, int namlen,
return 0;
}
+ if (d_type == DT_WHT) {
+ cd->common.err = nfs_ok;
+ return 0;
+ }
+
if (cd->offset)
xdr_encode_hyper(cd->offset, (u64) offset);
diff --git a/fs/nfsd/nfsxdr.c b/fs/nfsd/nfsxdr.c
index 65ec595..2af74b2 100644
--- a/fs/nfsd/nfsxdr.c
+++ b/fs/nfsd/nfsxdr.c
@@ -503,6 +503,10 @@ nfssvc_encode_entry(void *ccdv, const char *name,
namlen, name, offset, ino);
*/
+ if (d_type == DT_WHT) {
+ cd->common.err = nfs_ok;
+ return 0;
+ }
if (offset > ~((u32) 0)) {
cd->common.err = nfserr_fbig;
return -EINVAL;
diff --git a/fs/readdir.c b/fs/readdir.c
index 356f715..de703d6 100644
--- a/fs/readdir.c
+++ b/fs/readdir.c
@@ -77,6 +77,9 @@ static int fillonedir(void * __buf, const char * name, int namlen, loff_t offset
struct old_linux_dirent __user * dirent;
unsigned long d_ino;
+ if (d_type == DT_WHT)
+ return 0;
+
if (buf->result)
return -EINVAL;
d_ino = ino;
@@ -155,6 +158,9 @@ static int filldir(void * __buf, const char * name, int namlen, loff_t offset,
int reclen = ALIGN(offsetof(struct linux_dirent, d_name) + namlen + 2,
sizeof(long));
+ if (d_type == DT_WHT)
+ return 0;
+
buf->error = -EINVAL; /* only used if we fail.. */
if (reclen > buf->count)
return -EINVAL;
@@ -241,6 +247,9 @@ static int filldir64(void * __buf, const char * name, int namlen, loff_t offset,
int reclen = ALIGN(offsetof(struct linux_dirent64, d_name) + namlen + 1,
sizeof(u64));
+ if (d_type == DT_WHT)
+ return 0;
+
buf->error = -EINVAL; /* only used if we fail.. */
if (reclen > buf->count)
return -EINVAL;
^ permalink raw reply related [flat|nested] 79+ messages in thread* [PATCH 09/76] whiteout: Define flags and operations for opaque inodes
2011-06-17 16:00 [RFC][PATCH 00/76] Union Mount David Howells
` (7 preceding siblings ...)
2011-06-17 16:01 ` [PATCH 08/76] whiteout/NFSD: Don't return information about whiteouts to userspace David Howells
@ 2011-06-17 16:01 ` David Howells
2011-06-17 16:01 ` [PATCH 10/76] whiteout: Add vfs_whiteout() and whiteout inode operation David Howells
` (67 subsequent siblings)
76 siblings, 0 replies; 79+ messages in thread
From: David Howells @ 2011-06-17 16:01 UTC (permalink / raw)
To: linux-fsdevel; +Cc: hch
From: Valerie Aurora <vaurora@redhat.com>
Opaque directories are the directory equivalent of whiteouts. Define the
generic opaque inode flags and operations.
---
include/linux/fs.h | 4 ++++
1 files changed, 4 insertions(+), 0 deletions(-)
diff --git a/include/linux/fs.h b/include/linux/fs.h
index 43c17d0..1429326 100644
--- a/include/linux/fs.h
+++ b/include/linux/fs.h
@@ -239,6 +239,7 @@ struct inodes_stat_t {
#define S_IMA 1024 /* Inode has an associated IMA struct */
#define S_AUTOMOUNT 2048 /* Automount/referral quasi-directory */
#define S_NOSEC 4096 /* no suid or xattr security attributes */
+#define S_OPAQUE 8192 /* Directory is opaque */
/*
* Note that nosuid etc flags are inode-specific: setting some file-system
@@ -276,6 +277,7 @@ struct inodes_stat_t {
#define IS_IMA(inode) ((inode)->i_flags & S_IMA)
#define IS_AUTOMOUNT(inode) ((inode)->i_flags & S_AUTOMOUNT)
#define IS_NOSEC(inode) ((inode)->i_flags & S_NOSEC)
+#define IS_OPAQUE(inode) ((inode)->i_flags & S_OPAQUE)
/* the read-only stuff doesn't really belong here, but any other place is
probably as bad and I don't want to create yet another include file. */
@@ -359,9 +361,11 @@ struct inodes_stat_t {
#define FS_NOTAIL_FL 0x00008000 /* file tail should not be merged */
#define FS_DIRSYNC_FL 0x00010000 /* dirsync behaviour (directories only) */
#define FS_TOPDIR_FL 0x00020000 /* Top of directory hierarchies*/
+/* 0x00040000 is used by ext4 */
#define FS_EXTENT_FL 0x00080000 /* Extents */
#define FS_DIRECTIO_FL 0x00100000 /* Use direct i/o */
#define FS_NOCOW_FL 0x00800000 /* Do not cow file */
+#define FS_OPAQUE_FL 0x04000000 /* Dir is opaque */
#define FS_RESERVED_FL 0x80000000 /* reserved for ext2 lib */
#define FS_FL_USER_VISIBLE 0x0003DFFF /* User visible flags */
^ permalink raw reply related [flat|nested] 79+ messages in thread* [PATCH 10/76] whiteout: Add vfs_whiteout() and whiteout inode operation
2011-06-17 16:00 [RFC][PATCH 00/76] Union Mount David Howells
` (8 preceding siblings ...)
2011-06-17 16:01 ` [PATCH 09/76] whiteout: Define flags and operations for opaque inodes David Howells
@ 2011-06-17 16:01 ` David Howells
2011-06-17 16:01 ` [PATCH 11/76] whiteout: Allow removal of a directory with whiteouts David Howells
` (66 subsequent siblings)
76 siblings, 0 replies; 79+ messages in thread
From: David Howells @ 2011-06-17 16:01 UTC (permalink / raw)
To: linux-fsdevel; +Cc: hch
From: Jan Blunck <jblunck@suse.de>
Whiteout a given directory entry. File systems that support whiteouts
must implement the new ->whiteout() directory inode operation.
XXX - Only whiteout when there is a matching entry in a lower layer.
Signed-off-by: Jan Blunck <jblunck@suse.de>
Signed-off-by: David Woodhouse <dwmw2@infradead.org>
Signed-off-by: Valerie Aurora <vaurora@redhat.com>
---
Documentation/filesystems/vfs.txt | 10 ++++
fs/dcache.c | 1
fs/namei.c | 89 +++++++++++++++++++++++++++++++++++++
include/linux/dcache.h | 6 ++
include/linux/fs.h | 2 +
5 files changed, 106 insertions(+), 2 deletions(-)
diff --git a/Documentation/filesystems/vfs.txt b/Documentation/filesystems/vfs.txt
index 88b9f55..d9a43db 100644
--- a/Documentation/filesystems/vfs.txt
+++ b/Documentation/filesystems/vfs.txt
@@ -316,7 +316,7 @@ struct inode_operations
-----------------------
This describes how the VFS can manipulate an inode in your
-filesystem. As of kernel 2.6.22, the following members are defined:
+filesystem. As of kernel 2.6.34, the following members are defined:
struct inode_operations {
int (*create) (struct inode *,struct dentry *,int, struct nameidata *);
@@ -327,6 +327,7 @@ struct inode_operations {
int (*mkdir) (struct inode *,struct dentry *,int);
int (*rmdir) (struct inode *,struct dentry *);
int (*mknod) (struct inode *,struct dentry *,int,dev_t);
+ int (*whiteout) (struct inode *, struct dentry *, struct dentry *);
int (*rename) (struct inode *, struct dentry *,
struct inode *, struct dentry *);
int (*readlink) (struct dentry *, char __user *,int);
@@ -391,6 +392,13 @@ otherwise noted.
will probably need to call d_instantiate() just as you would
in the create() method
+ whiteout: called by the rmdir(2) and unlink(2) system calls on a
+ layered file system. Only required if you want to support
+ whiteouts. The first dentry passed in is that for the old
+ dentry if it exists, and a negative dentry otherwise. The
+ second is the dentry for the whiteout itself. This method
+ must unlink() or rmdir() the original entry if it exists.
+
rename: called by the rename(2) system call to rename the object to
have the parent and name given by the second inode and dentry.
diff --git a/fs/dcache.c b/fs/dcache.c
index 37f72ee..06ba068 100644
--- a/fs/dcache.c
+++ b/fs/dcache.c
@@ -1371,6 +1371,7 @@ static void __d_instantiate(struct dentry *dentry, struct inode *inode)
{
spin_lock(&dentry->d_lock);
if (inode) {
+ dentry->d_flags &= ~DCACHE_WHITEOUT;
if (unlikely(IS_AUTOMOUNT(inode)))
dentry->d_flags |= DCACHE_NEED_AUTOMOUNT;
list_add(&dentry->d_alias, &inode->i_dentry);
diff --git a/fs/namei.c b/fs/namei.c
index 272bead..99ca663 100644
--- a/fs/namei.c
+++ b/fs/namei.c
@@ -1838,7 +1838,6 @@ static int may_delete(struct inode *dir,struct dentry *victim,int isdir)
if (!victim->d_inode)
return -ENOENT;
- BUG_ON(victim->d_parent->d_inode != dir);
audit_inode_child(victim, dir);
error = inode_permission(dir, MAY_WRITE | MAY_EXEC);
@@ -2552,6 +2551,94 @@ SYSCALL_DEFINE2(mkdir, const char __user *, pathname, int, mode)
return sys_mkdirat(AT_FDCWD, pathname, mode);
}
+/**
+ * vfs_whiteout: Create a whiteout for the given directory entry
+ * @dir: Parent inode
+ * @dentry: Directory entry to whiteout
+ *
+ * Create a whiteout for the given directory entry. A whiteout prevents lookup
+ * from dropping down to a lower layer of a union mounted file system.
+ *
+ * There are two important cases: (a) The directory entry to be whited-out may
+ * already exist, in which case it must first be deleted before we create the
+ * whiteout, and (b) no such directory entry exists and we only have to create
+ * the whiteout itself.
+ *
+ * The caller must pass in a dentry for the directory entry to be whited-out -
+ * a positive one if it exists, and a negative if not. When this function
+ * returns, the caller should dput() the old, now defunct dentry it passed in.
+ * The dentry for the whiteout itself is created inside this function.
+ */
+static int vfs_whiteout(struct inode *dir, struct dentry *old_dentry, int isdir)
+{
+ struct inode *old_inode = old_dentry->d_inode;
+ struct dentry *parent, *whiteout;
+ bool do_dput = false;
+ int err = 0;
+
+ BUG_ON(old_dentry->d_parent->d_inode != dir);
+
+ if (!dir->i_op || !dir->i_op->whiteout)
+ return -EOPNOTSUPP;
+
+ /* If the old dentry is positive, then we have to delete this entry
+ * before we create the whiteout. The file system ->whiteout() op does
+ * the actual delete, but we do all the VFS-level checks and changes
+ * here.
+ */
+ if (old_inode) {
+ mutex_lock(&old_inode->i_mutex);
+ if (d_mountpoint(old_dentry)) {
+ mutex_unlock(&old_inode->i_mutex);
+ return -EBUSY;
+ }
+ if (isdir)
+ err = security_inode_rmdir(dir, old_dentry);
+ else
+ err = security_inode_unlink(dir, old_dentry);
+ if (err)
+ goto error_unlock;
+ }
+
+ parent = dget_parent(old_dentry);
+ err = -ENOMEM;
+ whiteout = d_alloc_name(parent, old_dentry->d_name.name);
+ if (!whiteout)
+ goto error_put_parent;
+
+ if (old_inode && isdir) {
+ dentry_unhash(old_dentry);
+ do_dput = true;
+ }
+
+ err = dir->i_op->whiteout(dir, old_dentry, whiteout);
+ if (err)
+ goto error_put_whiteout;
+
+ if (old_inode) {
+ mutex_unlock(&old_inode->i_mutex);
+ fsnotify_link_count(old_inode);
+ d_delete(old_dentry);
+ if (do_dput)
+ dput(old_dentry);
+ }
+
+ dput(whiteout);
+ dput(parent);
+ return err;
+
+error_put_whiteout:
+ dput(whiteout);
+error_put_parent:
+ dput(parent);
+error_unlock:
+ if (old_inode)
+ mutex_unlock(&old_inode->i_mutex);
+ if (do_dput)
+ dput(old_dentry);
+ return err;
+}
+
/*
* The dentry_unhash() helper will try to drop the dentry early: we
* should have a usage count of 2 if we're the only user of this
diff --git a/include/linux/dcache.h b/include/linux/dcache.h
index 19d90a5..98187cf 100644
--- a/include/linux/dcache.h
+++ b/include/linux/dcache.h
@@ -207,6 +207,7 @@ struct dentry_operations {
#define DCACHE_CANT_MOUNT 0x0100
#define DCACHE_GENOCIDE 0x0200
+#define DCACHE_WHITEOUT 0x0400 /* Stop lookup in a unioned file system */
#define DCACHE_OP_HASH 0x1000
#define DCACHE_OP_COMPARE 0x2000
@@ -411,6 +412,11 @@ static inline bool d_managed(struct dentry *dentry)
return dentry->d_flags & DCACHE_MANAGED_DENTRY;
}
+static inline int d_is_whiteout(struct dentry *dentry)
+{
+ return dentry->d_flags & DCACHE_WHITEOUT;
+}
+
static inline bool d_mountpoint(struct dentry *dentry)
{
return dentry->d_flags & DCACHE_MOUNTED;
diff --git a/include/linux/fs.h b/include/linux/fs.h
index 1429326..134b5d7 100644
--- a/include/linux/fs.h
+++ b/include/linux/fs.h
@@ -208,6 +208,7 @@ struct inodes_stat_t {
#define MS_KERNMOUNT (1<<22) /* this is a kern_mount call */
#define MS_I_VERSION (1<<23) /* Update inode I_version field */
#define MS_STRICTATIME (1<<24) /* Always perform atime updates */
+#define MS_WHITEOUT (1<<25) /* FS supports whiteout filetype */
#define MS_NOSEC (1<<28)
#define MS_BORN (1<<29)
#define MS_ACTIVE (1<<30)
@@ -1601,6 +1602,7 @@ struct inode_operations {
int (*mkdir) (struct inode *,struct dentry *,int);
int (*rmdir) (struct inode *,struct dentry *);
int (*mknod) (struct inode *,struct dentry *,int,dev_t);
+ int (*whiteout) (struct inode *, struct dentry *, struct dentry *);
int (*rename) (struct inode *, struct dentry *,
struct inode *, struct dentry *);
void (*truncate) (struct inode *);
^ permalink raw reply related [flat|nested] 79+ messages in thread* [PATCH 11/76] whiteout: Allow removal of a directory with whiteouts
2011-06-17 16:00 [RFC][PATCH 00/76] Union Mount David Howells
` (9 preceding siblings ...)
2011-06-17 16:01 ` [PATCH 10/76] whiteout: Add vfs_whiteout() and whiteout inode operation David Howells
@ 2011-06-17 16:01 ` David Howells
2011-06-17 16:01 ` [PATCH 12/76] tmpfs: Add whiteout support David Howells
` (65 subsequent siblings)
76 siblings, 0 replies; 79+ messages in thread
From: David Howells @ 2011-06-17 16:01 UTC (permalink / raw)
To: linux-fsdevel; +Cc: hch
From: Jan Blunck <jblunck@suse.de>
do_whiteout() allows removal of a directory when it has whiteouts but
is logically empty.
XXX - This patch abuses readdir() to check if the union directory is
logically empty - that is, all the entries are whiteouts (or "." or
".."). Currently, we have no clean VFS interface to ask the lower
file system if a directory is empty.
Fixes:
- Add ->is_directory_empty() op
- Add is_directory_empty flag to dentry (ugly dcache populate)
- Ask underlying fs to remove it and look for an error return
- (your idea here)
Signed-off-by: Jan Blunck <jblunck@suse.de>
Signed-off-by: Valerie Aurora <vaurora@redhat.com>
---
fs/namei.c | 90 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
1 files changed, 90 insertions(+), 0 deletions(-)
diff --git a/fs/namei.c b/fs/namei.c
index 99ca663..0014052 100644
--- a/fs/namei.c
+++ b/fs/namei.c
@@ -32,6 +32,7 @@
#include <linux/fcntl.h>
#include <linux/device_cgroup.h>
#include <linux/fs_struct.h>
+#include <linux/init_task.h>
#include <asm/uaccess.h>
#include "internal.h"
@@ -2645,6 +2646,95 @@ error_unlock:
* dentry, and if that is true (possibly after pruning the dcache),
* then we drop the dentry now.
*
+ * XXX - We are abusing readdir to check if a union directory is
+ * logically empty.
+ */
+static int filldir_is_empty(void *__buf, const char *name, int namelen,
+ loff_t offset, u64 ino, unsigned int d_type)
+{
+ int *is_empty = __buf;
+
+ switch (namelen) {
+ case 2:
+ if (name[1] != '.')
+ break;
+ case 1:
+ if (name[0] != '.')
+ break;
+ return 0;
+ }
+
+ if (d_type == DT_WHT)
+ return 0;
+
+ *is_empty = 0;
+ return 1; /* no point scanning further */
+}
+
+static int directory_is_empty(struct path *path)
+{
+ struct file *file;
+ int err;
+ int is_empty = 1;
+
+ BUG_ON(!S_ISDIR(path->dentry->d_inode->i_mode));
+
+ /* references for the file pointer */
+ path_get(path);
+
+ file = dentry_open(path->dentry, path->mnt, O_RDONLY, &init_cred);
+ if (IS_ERR(file))
+ return 0;
+
+ err = vfs_readdir(file, filldir_is_empty, &is_empty);
+
+ fput(file);
+ return is_empty;
+}
+
+static int do_whiteout(struct nameidata *nd, struct path *path, int isdir)
+{
+ struct path safe = nd->path;
+ struct dentry *dentry = path->dentry;
+ int err;
+
+ path_get(&safe);
+
+ err = may_delete(nd->path.dentry->d_inode, dentry, isdir);
+ if (err)
+ goto out;
+
+ err = -ENOTEMPTY;
+ if (isdir && !directory_is_empty(path))
+ goto out;
+
+ if (nd->path.dentry != dentry->d_parent) {
+ dentry = __lookup_hash(&path->dentry->d_name, nd->path.dentry,
+ nd);
+ err = PTR_ERR(dentry);
+ if (IS_ERR(dentry))
+ goto out;
+
+ dput(path->dentry);
+ if (path->mnt != safe.mnt)
+ mntput(path->mnt);
+ path->mnt = nd->path.mnt;
+ path->dentry = dentry;
+ }
+
+ err = vfs_whiteout(nd->path.dentry->d_inode, dentry, isdir);
+
+out:
+ path_put(&safe);
+ return err;
+}
+
+/*
+ * We try to drop the dentry early: we should have
+ * a usage count of 2 if we're the only user of this
+ * dentry, and if that is true (possibly after pruning
+ * the dcache), then we drop the dentry now.
+ *
* A low-level filesystem can, if it choses, legally
* do a
*
^ permalink raw reply related [flat|nested] 79+ messages in thread* [PATCH 12/76] tmpfs: Add whiteout support
2011-06-17 16:00 [RFC][PATCH 00/76] Union Mount David Howells
` (10 preceding siblings ...)
2011-06-17 16:01 ` [PATCH 11/76] whiteout: Allow removal of a directory with whiteouts David Howells
@ 2011-06-17 16:01 ` David Howells
2011-06-17 16:02 ` [PATCH 13/76] ext2: Add ext2_dirent_in_use() David Howells
` (64 subsequent siblings)
76 siblings, 0 replies; 79+ messages in thread
From: David Howells @ 2011-06-17 16:01 UTC (permalink / raw)
To: linux-fsdevel; +Cc: hch
From: Jan Blunck <jblunck@suse.de>
Add support for whiteout dentries to tmpfs. This includes adding support for
whiteouts to d_genocide(), which is called to tear down pinned tmpfs dentries.
Whiteouts have to be persistent, so they have a pinning extra ref count that
needs to be dropped by d_genocide().
Signed-off-by: Jan Blunck <jblunck@suse.de>
Signed-off-by: David Woodhouse <dwmw2@infradead.org>
Signed-off-by: Valerie Aurora <vaurora@redhat.com>
Cc: Hugh Dickins <hugh.dickins@tiscali.co.uk>
Cc: linux-mm@kvack.org
---
fs/dcache.c | 12 +++++
mm/shmem.c | 144 +++++++++++++++++++++++++++++++++++++++++++++++++++++------
2 files changed, 141 insertions(+), 15 deletions(-)
diff --git a/fs/dcache.c b/fs/dcache.c
index 06ba068..1974031 100644
--- a/fs/dcache.c
+++ b/fs/dcache.c
@@ -2915,7 +2915,17 @@ resume:
next = tmp->next;
spin_lock_nested(&dentry->d_lock, DENTRY_D_LOCK_NESTED);
- if (d_unhashed(dentry) || !dentry->d_inode) {
+
+ /* Skip unhashed and negative dentries, but process positive
+ * dentries and whiteouts. A whiteout looks kind of like a
+ * negative dentry for purposes of lookup, but it has an extra
+ * pinning ref count because it can't be evicted like a
+ * negative dentry can. What we care about here is ref counts
+ * - and we need to drop the ref count on a whiteout before we
+ * can evict it.
+ */
+ if (d_unhashed(dentry) ||
+ (!dentry->d_inode && !d_is_whiteout(dentry))) {
spin_unlock(&dentry->d_lock);
continue;
}
diff --git a/mm/shmem.c b/mm/shmem.c
index d221a1c..7e795e3 100644
--- a/mm/shmem.c
+++ b/mm/shmem.c
@@ -1865,6 +1865,76 @@ static int shmem_statfs(struct dentry *dentry, struct kstatfs *buf)
return 0;
}
+static int shmem_rmdir(struct inode *dir, struct dentry *dentry);
+static int shmem_unlink(struct inode *dir, struct dentry *dentry);
+
+/*
+ * This is the whiteout support for tmpfs. It uses one singleton whiteout
+ * inode per superblock thus it is very similar to shmem_link().
+ */
+static int shmem_whiteout(struct inode *dir, struct dentry *old_dentry,
+ struct dentry *new_dentry)
+{
+ struct shmem_sb_info *sbinfo = SHMEM_SB(dir->i_sb);
+ struct dentry *dentry;
+
+ if (!(dir->i_sb->s_flags & MS_WHITEOUT))
+ return -EPERM;
+
+ /* This gives us a proper initialized negative dentry */
+ dentry = simple_lookup(dir, new_dentry, NULL);
+ if (dentry && IS_ERR(dentry))
+ return PTR_ERR(dentry);
+
+ /*
+ * No ordinary (disk based) filesystem counts whiteouts as inodes;
+ * but each new link needs a new dentry, pinning lowmem, and
+ * tmpfs dentries cannot be pruned until they are unlinked.
+ */
+ if (sbinfo->max_inodes) {
+ spin_lock(&sbinfo->stat_lock);
+ if (!sbinfo->free_inodes) {
+ spin_unlock(&sbinfo->stat_lock);
+ return -ENOSPC;
+ }
+ sbinfo->free_inodes--;
+ spin_unlock(&sbinfo->stat_lock);
+ }
+
+ if (old_dentry->d_inode) {
+ if (S_ISDIR(old_dentry->d_inode->i_mode))
+ shmem_rmdir(dir, old_dentry);
+ else
+ shmem_unlink(dir, old_dentry);
+ }
+
+ dir->i_size += BOGO_DIRENT_SIZE;
+ dir->i_ctime = dir->i_mtime = CURRENT_TIME;
+ /* Extra pinning count for the created dentry */
+ dget(new_dentry);
+ spin_lock(&new_dentry->d_lock);
+ new_dentry->d_flags |= DCACHE_WHITEOUT;
+ spin_unlock(&new_dentry->d_lock);
+ return 0;
+}
+
+static void shmem_d_instantiate(struct inode *dir, struct dentry *dentry,
+ struct inode *inode)
+{
+ if (d_is_whiteout(dentry)) {
+ /* Re-using an existing whiteout */
+ shmem_free_inode(dir->i_sb);
+ if (S_ISDIR(inode->i_mode))
+ inode->i_mode |= S_OPAQUE;
+ } else {
+ /* New dentry */
+ dir->i_size += BOGO_DIRENT_SIZE;
+ dget(dentry); /* Extra count - pin the dentry in core */
+ }
+ /* Will clear DCACHE_WHITEOUT flag */
+ d_instantiate(dentry, inode);
+
+}
/*
* File creation. Allocate an inode, and we're done..
*/
@@ -1894,10 +1964,8 @@ shmem_mknod(struct inode *dir, struct dentry *dentry, int mode, dev_t dev)
#else
error = 0;
#endif
- dir->i_size += BOGO_DIRENT_SIZE;
dir->i_ctime = dir->i_mtime = CURRENT_TIME;
- d_instantiate(dentry, inode);
- dget(dentry); /* Extra count - pin the dentry in core */
+ shmem_d_instantiate(dir, dentry, inode);
}
return error;
}
@@ -1935,12 +2003,10 @@ static int shmem_link(struct dentry *old_dentry, struct inode *dir, struct dentr
if (ret)
goto out;
- dir->i_size += BOGO_DIRENT_SIZE;
inode->i_ctime = dir->i_ctime = dir->i_mtime = CURRENT_TIME;
inc_nlink(inode);
ihold(inode); /* New dentry reference */
- dget(dentry); /* Extra pinning count for the created dentry */
- d_instantiate(dentry, inode);
+ shmem_d_instantiate(dir, dentry, inode);
out:
return ret;
}
@@ -1949,21 +2015,61 @@ static int shmem_unlink(struct inode *dir, struct dentry *dentry)
{
struct inode *inode = dentry->d_inode;
- if (inode->i_nlink > 1 && !S_ISDIR(inode->i_mode))
- shmem_free_inode(inode->i_sb);
+ if (d_is_whiteout(dentry) || (inode->i_nlink > 1 && !S_ISDIR(inode->i_mode)))
+ shmem_free_inode(dir->i_sb);
+ if (inode) {
+ inode->i_ctime = dir->i_ctime = dir->i_mtime = CURRENT_TIME;
+ drop_nlink(inode);
+ }
dir->i_size -= BOGO_DIRENT_SIZE;
- inode->i_ctime = dir->i_ctime = dir->i_mtime = CURRENT_TIME;
- drop_nlink(inode);
dput(dentry); /* Undo the count from "create" - this does all the work */
return 0;
}
+static void shmem_dir_unlink_whiteouts(struct inode *dir, struct dentry *dentry)
+{
+ if (!dentry->d_inode)
+ return;
+
+ /* Remove whiteouts from logical empty directory */
+ if (S_ISDIR(dentry->d_inode->i_mode) &&
+ dentry->d_inode->i_sb->s_flags & MS_WHITEOUT) {
+ struct dentry *child, *next;
+ LIST_HEAD(list);
+
+ spin_lock(&dentry->d_lock);
+ list_for_each_entry(child, &dentry->d_subdirs, d_u.d_child) {
+ spin_lock(&child->d_lock);
+ if (d_is_whiteout(child)) {
+ __d_drop(child);
+ if (!list_empty(&child->d_lru)) {
+ list_del(&child->d_lru);
+ dentry_stat.nr_unused--;
+ }
+ list_add(&child->d_lru, &list);
+ }
+ spin_unlock(&child->d_lock);
+ }
+ spin_unlock(&dentry->d_lock);
+
+ list_for_each_entry_safe(child, next, &list, d_lru) {
+ spin_lock(&child->d_lock);
+ list_del_init(&child->d_lru);
+ spin_unlock(&child->d_lock);
+
+ shmem_unlink(dentry->d_inode, child);
+ }
+ }
+}
+
static int shmem_rmdir(struct inode *dir, struct dentry *dentry)
{
if (!simple_empty(dentry))
return -ENOTEMPTY;
+ /* Remove whiteouts from logical empty directory */
+ shmem_dir_unlink_whiteouts(dir, dentry);
drop_nlink(dentry->d_inode);
drop_nlink(dir);
return shmem_unlink(dir, dentry);
@@ -1972,7 +2078,7 @@ static int shmem_rmdir(struct inode *dir, struct dentry *dentry)
/*
* The VFS layer already does all the dentry stuff for rename,
* we just have to decrement the usage count for the target if
- * it exists so that the VFS layer correctly free's it when it
+ * it exists so that the VFS layer correctly frees it when it
* gets overwritten.
*/
static int shmem_rename(struct inode *old_dir, struct dentry *old_dentry, struct inode *new_dir, struct dentry *new_dentry)
@@ -1983,7 +2089,12 @@ static int shmem_rename(struct inode *old_dir, struct dentry *old_dentry, struct
if (!simple_empty(new_dentry))
return -ENOTEMPTY;
+ if (d_is_whiteout(new_dentry))
+ shmem_unlink(new_dir, new_dentry);
+
if (new_dentry->d_inode) {
+ /* Remove whiteouts from logical empty directory */
+ shmem_dir_unlink_whiteouts(new_dir, new_dentry);
(void) shmem_unlink(new_dir, new_dentry);
if (they_are_dirs)
drop_nlink(old_dir);
@@ -2048,10 +2159,8 @@ static int shmem_symlink(struct inode *dir, struct dentry *dentry, const char *s
unlock_page(page);
page_cache_release(page);
}
- dir->i_size += BOGO_DIRENT_SIZE;
dir->i_ctime = dir->i_mtime = CURRENT_TIME;
- d_instantiate(dentry, inode);
- dget(dentry);
+ shmem_d_instantiate(dir, dentry, inode);
return 0;
}
@@ -2623,6 +2732,12 @@ int shmem_fill_super(struct super_block *sb, void *data, int silent)
if (!root)
goto failed_iput;
sb->s_root = root;
+
+#ifdef CONFIG_TMPFS
+ if (!(sb->s_flags & MS_NOUSER))
+ sb->s_flags |= MS_WHITEOUT;
+#endif
+
return 0;
failed_iput:
@@ -2731,6 +2846,7 @@ static const struct inode_operations shmem_dir_inode_operations = {
.rmdir = shmem_rmdir,
.mknod = shmem_mknod,
.rename = shmem_rename,
+ .whiteout = shmem_whiteout,
#endif
#ifdef CONFIG_TMPFS_XATTR
.setxattr = shmem_setxattr,
^ permalink raw reply related [flat|nested] 79+ messages in thread* [PATCH 13/76] ext2: Add ext2_dirent_in_use()
2011-06-17 16:00 [RFC][PATCH 00/76] Union Mount David Howells
` (11 preceding siblings ...)
2011-06-17 16:01 ` [PATCH 12/76] tmpfs: Add whiteout support David Howells
@ 2011-06-17 16:02 ` David Howells
2011-06-17 16:02 ` [PATCH 14/76] ext2: Split ext2_add_entry() from ext2_add_link() David Howells
` (63 subsequent siblings)
76 siblings, 0 replies; 79+ messages in thread
From: David Howells @ 2011-06-17 16:02 UTC (permalink / raw)
To: linux-fsdevel; +Cc: hch
From: Valerie Aurora <vaurora@redhat.com>
Currently ext2 checks if a directory entry is in-use by checking if the inode
is non-zero. Fallthrus and whiteouts will have zero inode but be in-use. Add
a function to abstract out the directory entry in-use test.
---
fs/ext2/dir.c | 12 +++++++++---
1 files changed, 9 insertions(+), 3 deletions(-)
diff --git a/fs/ext2/dir.c b/fs/ext2/dir.c
index 47cda41..e8702cf 100644
--- a/fs/ext2/dir.c
+++ b/fs/ext2/dir.c
@@ -218,6 +218,11 @@ fail:
return ERR_PTR(-EIO);
}
+static inline int ext2_dirent_in_use(struct ext2_dir_entry_2 *de)
+{
+ return de->inode != 0;
+}
+
/*
* NOTE! unlike strncmp, ext2_match returns 1 for success, 0 for failure.
*
@@ -228,7 +233,7 @@ static inline int ext2_match (int len, const char * const name,
{
if (len != de->name_len)
return 0;
- if (!de->inode)
+ if (!ext2_dirent_in_use(de))
return 0;
return !memcmp(name, de->name, len);
}
@@ -527,6 +532,7 @@ int ext2_add_link (struct dentry *dentry, struct inode *inode)
rec_len = chunk_size;
de->rec_len = ext2_rec_len_to_disk(chunk_size);
de->inode = 0;
+ de->file_type = 0;
goto got_it;
}
if (de->rec_len == 0) {
@@ -540,7 +546,7 @@ int ext2_add_link (struct dentry *dentry, struct inode *inode)
goto out_unlock;
name_len = EXT2_DIR_REC_LEN(de->name_len);
rec_len = ext2_rec_len_from_disk(de->rec_len);
- if (!de->inode && rec_len >= reclen)
+ if (!ext2_dirent_in_use(de) && rec_len >= reclen)
goto got_it;
if (rec_len >= name_len + reclen)
goto got_it;
@@ -558,7 +564,7 @@ got_it:
err = ext2_prepare_chunk(page, pos, rec_len);
if (err)
goto out_unlock;
- if (de->inode) {
+ if (ext2_dirent_in_use(de)) {
ext2_dirent *de1 = (ext2_dirent *) ((char *) de + name_len);
de1->rec_len = ext2_rec_len_to_disk(rec_len - name_len);
de->rec_len = ext2_rec_len_to_disk(name_len);
^ permalink raw reply related [flat|nested] 79+ messages in thread* [PATCH 14/76] ext2: Split ext2_add_entry() from ext2_add_link()
2011-06-17 16:00 [RFC][PATCH 00/76] Union Mount David Howells
` (12 preceding siblings ...)
2011-06-17 16:02 ` [PATCH 13/76] ext2: Add ext2_dirent_in_use() David Howells
@ 2011-06-17 16:02 ` David Howells
2011-06-17 16:02 ` [PATCH 15/76] ext2: Add whiteout support David Howells
` (62 subsequent siblings)
76 siblings, 0 replies; 79+ messages in thread
From: David Howells @ 2011-06-17 16:02 UTC (permalink / raw)
To: linux-fsdevel; +Cc: hch
From: Valerie Aurora <vaurora@redhat.com>
Allow future code to use the guts of ext2_add_link().
Cc: Jan Kara <jack@suse.cz>
Cc: linux-ext4@kernel.org
---
fs/ext2/dir.c | 10 ++++++----
1 files changed, 6 insertions(+), 4 deletions(-)
diff --git a/fs/ext2/dir.c b/fs/ext2/dir.c
index e8702cf..850a081 100644
--- a/fs/ext2/dir.c
+++ b/fs/ext2/dir.c
@@ -489,10 +489,7 @@ void ext2_set_link(struct inode *dir, struct ext2_dir_entry_2 *de,
mark_inode_dirty(dir);
}
-/*
- * Parent is locked.
- */
-int ext2_add_link (struct dentry *dentry, struct inode *inode)
+int ext2_add_entry (struct dentry *dentry, struct inode *inode)
{
struct inode *dir = dentry->d_parent->d_inode;
const char *name = dentry->d_name.name;
@@ -588,6 +585,11 @@ out_unlock:
goto out_put;
}
+int ext2_add_link (struct dentry *dentry, struct inode *inode)
+{
+ return ext2_add_entry(dentry, inode);
+}
+
/*
* ext2_delete_entry deletes a directory entry by merging it with the
* previous entry. Page is up-to-date. Releases the page.
^ permalink raw reply related [flat|nested] 79+ messages in thread* [PATCH 15/76] ext2: Add whiteout support
2011-06-17 16:00 [RFC][PATCH 00/76] Union Mount David Howells
` (13 preceding siblings ...)
2011-06-17 16:02 ` [PATCH 14/76] ext2: Split ext2_add_entry() from ext2_add_link() David Howells
@ 2011-06-17 16:02 ` David Howells
2011-06-17 16:02 ` [PATCH 16/76] jffs2: " David Howells
` (61 subsequent siblings)
76 siblings, 0 replies; 79+ messages in thread
From: David Howells @ 2011-06-17 16:02 UTC (permalink / raw)
To: linux-fsdevel; +Cc: hch
From: Valerie Aurora <vaurora@redhat.com>
Add support for whiteouts to ext2.
---
fs/ext2/dir.c | 64 +++++++++++++++++++++++++++++++++++++++++------
fs/ext2/ext2.h | 2 +
fs/ext2/inode.c | 11 ++++++--
fs/ext2/namei.c | 63 ++++++++++++++++++++++++++++++++++++++++++++--
fs/ext2/super.c | 4 +++
include/linux/ext2_fs.h | 4 +++
6 files changed, 134 insertions(+), 14 deletions(-)
diff --git a/fs/ext2/dir.c b/fs/ext2/dir.c
index 850a081..4ef5777 100644
--- a/fs/ext2/dir.c
+++ b/fs/ext2/dir.c
@@ -220,7 +220,7 @@ fail:
static inline int ext2_dirent_in_use(struct ext2_dir_entry_2 *de)
{
- return de->inode != 0;
+ return de->inode != 0 || de->file_type == EXT2_FT_WHT;
}
/*
@@ -269,6 +269,7 @@ static unsigned char ext2_filetype_table[EXT2_FT_MAX] = {
[EXT2_FT_FIFO] = DT_FIFO,
[EXT2_FT_SOCK] = DT_SOCK,
[EXT2_FT_SYMLINK] = DT_LNK,
+ [EXT2_FT_WHT] = DT_WHT,
};
#define S_SHIFT 12
@@ -467,6 +468,26 @@ static int ext2_prepare_chunk(struct page *page, loff_t pos, unsigned len)
return __block_write_begin(page, pos, len, ext2_get_block);
}
+/* Special version for filetype based whiteout support */
+ino_t ext2_inode_by_dentry(struct inode *dir, struct dentry *dentry)
+{
+ ino_t res = 0;
+ struct ext2_dir_entry_2 *de;
+ struct page *page;
+
+ de = ext2_find_entry (dir, &dentry->d_name, &page);
+ if (de) {
+ res = le32_to_cpu(de->inode);
+ if (!res && de->file_type == EXT2_FT_WHT) {
+ spin_lock(&dentry->d_lock);
+ dentry->d_flags |= DCACHE_WHITEOUT;
+ spin_unlock(&dentry->d_lock);
+ }
+ ext2_put_page(page);
+ }
+ return res;
+}
+
/* Releases the page */
void ext2_set_link(struct inode *dir, struct ext2_dir_entry_2 *de,
struct page *page, struct inode *inode, int update_times)
@@ -489,7 +510,9 @@ void ext2_set_link(struct inode *dir, struct ext2_dir_entry_2 *de,
mark_inode_dirty(dir);
}
-int ext2_add_entry (struct dentry *dentry, struct inode *inode)
+int ext2_add_entry (struct dentry *dentry, struct inode *inode,
+ ext2_dirent *de, struct page *page,
+ int new_file_type)
{
struct inode *dir = dentry->d_parent->d_inode;
const char *name = dentry->d_name.name;
@@ -497,8 +520,6 @@ int ext2_add_entry (struct dentry *dentry, struct inode *inode)
unsigned chunk_size = ext2_chunk_size(dir);
unsigned reclen = EXT2_DIR_REC_LEN(namelen);
unsigned short rec_len, name_len;
- struct page *page = NULL;
- ext2_dirent * de;
unsigned long npages = dir_pages(dir);
unsigned long n;
char *kaddr;
@@ -556,12 +577,27 @@ int ext2_add_entry (struct dentry *dentry, struct inode *inode)
return -EINVAL;
got_it:
+ /*
+ * Pre-existing entries with the same name are allowable
+ * depending on the type of the entry being created. Regular
+ * entries replace whiteouts. Whiteouts replace regular
+ * entries.
+ */
+ err = -EEXIST;
+ if (ext2_match(namelen, name, de)) {
+ if (new_file_type == EXT2_FT_WHT) {
+ if (de->file_type == EXT2_FT_WHT)
+ goto out_unlock;
+ } else if (de->file_type != EXT2_FT_WHT) {
+ goto out_unlock;
+ }
+ }
pos = page_offset(page) +
(char*)de - (char*)page_address(page);
err = ext2_prepare_chunk(page, pos, rec_len);
if (err)
goto out_unlock;
- if (ext2_dirent_in_use(de)) {
+ if (ext2_dirent_in_use(de) && !ext2_match (namelen, name, de)) {
ext2_dirent *de1 = (ext2_dirent *) ((char *) de + name_len);
de1->rec_len = ext2_rec_len_to_disk(rec_len - name_len);
de->rec_len = ext2_rec_len_to_disk(name_len);
@@ -569,8 +605,13 @@ got_it:
}
de->name_len = namelen;
memcpy(de->name, name, namelen);
- de->inode = cpu_to_le32(inode->i_ino);
- ext2_set_de_type (de, inode);
+ if (inode) {
+ de->inode = cpu_to_le32(inode->i_ino);
+ ext2_set_de_type (de, inode);
+ } else {
+ de->inode = 0;
+ de->file_type = new_file_type;
+ }
err = ext2_commit_chunk(page, pos, rec_len);
dir->i_mtime = dir->i_ctime = CURRENT_TIME_SEC;
EXT2_I(dir)->i_flags &= ~EXT2_BTREE_FL;
@@ -587,7 +628,14 @@ out_unlock:
int ext2_add_link (struct dentry *dentry, struct inode *inode)
{
- return ext2_add_entry(dentry, inode);
+ ext2_dirent *de = NULL;
+ struct page *page = NULL;
+ return ext2_add_entry(dentry, inode, de, page, 0);
+}
+
+int ext2_whiteout_entry (struct dentry *dentry, ext2_dirent *de, struct page *page)
+{
+ return ext2_add_entry(dentry, NULL, de, page, EXT2_FT_WHT);
}
/*
diff --git a/fs/ext2/ext2.h b/fs/ext2/ext2.h
index 645be9e..78719f4 100644
--- a/fs/ext2/ext2.h
+++ b/fs/ext2/ext2.h
@@ -102,9 +102,11 @@ extern void ext2_rsv_window_add(struct super_block *sb, struct ext2_reserve_wind
/* dir.c */
extern int ext2_add_link (struct dentry *, struct inode *);
extern ino_t ext2_inode_by_name(struct inode *, struct qstr *);
+extern ino_t ext2_inode_by_dentry(struct inode *, struct dentry *);
extern int ext2_make_empty(struct inode *, struct inode *);
extern struct ext2_dir_entry_2 * ext2_find_entry (struct inode *,struct qstr *, struct page **);
extern int ext2_delete_entry (struct ext2_dir_entry_2 *, struct page *);
+extern int ext2_whiteout_entry (struct dentry *, struct ext2_dir_entry_2 *, struct page *);
extern int ext2_empty_dir (struct inode *);
extern struct ext2_dir_entry_2 * ext2_dotdot (struct inode *, struct page **);
extern void ext2_set_link(struct inode *, struct ext2_dir_entry_2 *, struct page *, struct inode *, int);
diff --git a/fs/ext2/inode.c b/fs/ext2/inode.c
index 788e09a..42c8b8d 100644
--- a/fs/ext2/inode.c
+++ b/fs/ext2/inode.c
@@ -1256,7 +1256,8 @@ void ext2_set_inode_flags(struct inode *inode)
{
unsigned int flags = EXT2_I(inode)->i_flags;
- inode->i_flags &= ~(S_SYNC|S_APPEND|S_IMMUTABLE|S_NOATIME|S_DIRSYNC);
+ inode->i_flags &= ~(S_SYNC|S_APPEND|S_IMMUTABLE|S_NOATIME|S_DIRSYNC|
+ S_OPAQUE);
if (flags & EXT2_SYNC_FL)
inode->i_flags |= S_SYNC;
if (flags & EXT2_APPEND_FL)
@@ -1267,6 +1268,8 @@ void ext2_set_inode_flags(struct inode *inode)
inode->i_flags |= S_NOATIME;
if (flags & EXT2_DIRSYNC_FL)
inode->i_flags |= S_DIRSYNC;
+ if (flags & EXT2_OPAQUE_FL)
+ inode->i_flags |= S_OPAQUE;
}
/* Propagate flags from i_flags to EXT2_I(inode)->i_flags */
@@ -1274,8 +1277,8 @@ void ext2_get_inode_flags(struct ext2_inode_info *ei)
{
unsigned int flags = ei->vfs_inode.i_flags;
- ei->i_flags &= ~(EXT2_SYNC_FL|EXT2_APPEND_FL|
- EXT2_IMMUTABLE_FL|EXT2_NOATIME_FL|EXT2_DIRSYNC_FL);
+ ei->i_flags &= ~(EXT2_SYNC_FL|EXT2_APPEND_FL|EXT2_IMMUTABLE_FL|
+ EXT2_NOATIME_FL|EXT2_DIRSYNC_FL|EXT2_OPAQUE_FL);
if (flags & S_SYNC)
ei->i_flags |= EXT2_SYNC_FL;
if (flags & S_APPEND)
@@ -1286,6 +1289,8 @@ void ext2_get_inode_flags(struct ext2_inode_info *ei)
ei->i_flags |= EXT2_NOATIME_FL;
if (flags & S_DIRSYNC)
ei->i_flags |= EXT2_DIRSYNC_FL;
+ if (flags & S_OPAQUE)
+ ei->i_flags |= EXT2_OPAQUE_FL;
}
struct inode *ext2_iget (struct super_block *sb, unsigned long ino)
diff --git a/fs/ext2/namei.c b/fs/ext2/namei.c
index ed5c5d4..a17c9c8 100644
--- a/fs/ext2/namei.c
+++ b/fs/ext2/namei.c
@@ -55,15 +55,16 @@ static inline int ext2_add_nondir(struct dentry *dentry, struct inode *inode)
* Methods themselves.
*/
-static struct dentry *ext2_lookup(struct inode * dir, struct dentry *dentry, struct nameidata *nd)
+static struct dentry *ext2_lookup(struct inode * dir, struct dentry *dentry,
+ struct nameidata *nd)
{
struct inode * inode;
ino_t ino;
-
+
if (dentry->d_name.len > EXT2_NAME_LEN)
return ERR_PTR(-ENAMETOOLONG);
- ino = ext2_inode_by_name(dir, &dentry->d_name);
+ ino = ext2_inode_by_dentry(dir, dentry);
inode = NULL;
if (ino) {
inode = ext2_iget(dir->i_sb, ino);
@@ -307,6 +308,61 @@ static int ext2_rmdir (struct inode * dir, struct dentry *dentry)
return err;
}
+/*
+ * Create a whiteout for the dentry
+ */
+static int ext2_whiteout(struct inode *dir, struct dentry *dentry,
+ struct dentry *new_dentry)
+{
+ struct inode * inode = dentry->d_inode;
+ struct ext2_dir_entry_2 * de = NULL;
+ struct page * page;
+ int err = -ENOTEMPTY;
+
+ if (!EXT2_HAS_INCOMPAT_FEATURE(dir->i_sb,
+ EXT2_FEATURE_INCOMPAT_FILETYPE)) {
+ ext2_error (dir->i_sb, "ext2_whiteout",
+ "can't set whiteout filetype");
+ err = -EPERM;
+ goto out;
+ }
+
+ dquot_initialize(dir);
+
+ if (inode) {
+ if (S_ISDIR(inode->i_mode) && !ext2_empty_dir(inode))
+ goto out;
+
+ err = -ENOENT;
+ de = ext2_find_entry(dir, &dentry->d_name, &page);
+ if (!de)
+ goto out;
+ lock_page(page);
+ }
+
+ err = ext2_whiteout_entry(dentry, de, page);
+ if (err)
+ goto out;
+
+ spin_lock(&new_dentry->d_lock);
+ new_dentry->d_flags |= DCACHE_WHITEOUT;
+ spin_unlock(&new_dentry->d_lock);
+ d_add(new_dentry, NULL);
+
+ if (inode) {
+ inode->i_ctime = dir->i_ctime;
+ inode_dec_link_count(inode);
+ if (S_ISDIR(inode->i_mode)) {
+ inode->i_size = 0;
+ inode_dec_link_count(inode);
+ inode_dec_link_count(dir);
+ }
+ }
+ err = 0;
+out:
+ return err;
+}
+
static int ext2_rename (struct inode * old_dir, struct dentry * old_dentry,
struct inode * new_dir, struct dentry * new_dentry )
{
@@ -404,6 +460,7 @@ const struct inode_operations ext2_dir_inode_operations = {
.mkdir = ext2_mkdir,
.rmdir = ext2_rmdir,
.mknod = ext2_mknod,
+ .whiteout = ext2_whiteout,
.rename = ext2_rename,
#ifdef CONFIG_EXT2_FS_XATTR
.setxattr = generic_setxattr,
diff --git a/fs/ext2/super.c b/fs/ext2/super.c
index 1dd62ed..6167ff3 100644
--- a/fs/ext2/super.c
+++ b/fs/ext2/super.c
@@ -1098,6 +1098,10 @@ static int ext2_fill_super(struct super_block *sb, void *data, int silent)
if (EXT2_HAS_COMPAT_FEATURE(sb, EXT3_FEATURE_COMPAT_HAS_JOURNAL))
ext2_msg(sb, KERN_WARNING,
"warning: mounting ext3 filesystem as ext2");
+
+ if (EXT2_HAS_INCOMPAT_FEATURE(sb, EXT2_FEATURE_INCOMPAT_WHITEOUT))
+ sb->s_flags |= MS_WHITEOUT;
+
if (ext2_setup_super (sb, es, sb->s_flags & MS_RDONLY))
sb->s_flags |= MS_RDONLY;
ext2_write_super(sb);
diff --git a/include/linux/ext2_fs.h b/include/linux/ext2_fs.h
index 2dfa707..b0fb356 100644
--- a/include/linux/ext2_fs.h
+++ b/include/linux/ext2_fs.h
@@ -189,6 +189,7 @@ struct ext2_group_desc
#define EXT2_NOTAIL_FL FS_NOTAIL_FL /* file tail should not be merged */
#define EXT2_DIRSYNC_FL FS_DIRSYNC_FL /* dirsync behaviour (directories only) */
#define EXT2_TOPDIR_FL FS_TOPDIR_FL /* Top of directory hierarchies*/
+#define EXT2_OPAQUE_FL FS_OPAQUE_FL /* Dir is opaque */
#define EXT2_RESERVED_FL FS_RESERVED_FL /* reserved for ext2 lib */
#define EXT2_FL_USER_VISIBLE FS_FL_USER_VISIBLE /* User visible flags */
@@ -503,10 +504,12 @@ struct ext2_super_block {
#define EXT3_FEATURE_INCOMPAT_RECOVER 0x0004
#define EXT3_FEATURE_INCOMPAT_JOURNAL_DEV 0x0008
#define EXT2_FEATURE_INCOMPAT_META_BG 0x0010
+#define EXT2_FEATURE_INCOMPAT_WHITEOUT 0x0020
#define EXT2_FEATURE_INCOMPAT_ANY 0xffffffff
#define EXT2_FEATURE_COMPAT_SUPP EXT2_FEATURE_COMPAT_EXT_ATTR
#define EXT2_FEATURE_INCOMPAT_SUPP (EXT2_FEATURE_INCOMPAT_FILETYPE| \
+ EXT2_FEATURE_INCOMPAT_WHITEOUT| \
EXT2_FEATURE_INCOMPAT_META_BG)
#define EXT2_FEATURE_RO_COMPAT_SUPP (EXT2_FEATURE_RO_COMPAT_SPARSE_SUPER| \
EXT2_FEATURE_RO_COMPAT_LARGE_FILE| \
@@ -573,6 +576,7 @@ enum {
EXT2_FT_FIFO = 5,
EXT2_FT_SOCK = 6,
EXT2_FT_SYMLINK = 7,
+ EXT2_FT_WHT = 8,
EXT2_FT_MAX
};
^ permalink raw reply related [flat|nested] 79+ messages in thread* [PATCH 16/76] jffs2: Add whiteout support
2011-06-17 16:00 [RFC][PATCH 00/76] Union Mount David Howells
` (14 preceding siblings ...)
2011-06-17 16:02 ` [PATCH 15/76] ext2: Add whiteout support David Howells
@ 2011-06-17 16:02 ` David Howells
2011-06-17 16:02 ` [PATCH 17/76] VFS: Basic fallthru definitions David Howells
` (60 subsequent siblings)
76 siblings, 0 replies; 79+ messages in thread
From: David Howells @ 2011-06-17 16:02 UTC (permalink / raw)
To: linux-fsdevel; +Cc: hch
From: Felix Fietkau <nbd@openwrt.org>
Add support for whiteout dentries to jffs2.
XXX - David Woodhouse suggests several changes and provides an untested patch.
See:
http://patchwork.ozlabs.org/patch/50466/
XXX - Backward compatibility? Creating a whiteout on a JFFS2 file system can
only happen if it is deliberately mounted "-o union" so there is some way to
prevent creation of whiteouts on a file system you want to later mount with an
earlier (no support for whiteout) file system. However, ext2/3 has much more
robust methods (explicit fs feature flag) to prevent such an occurance.
Signed-off-by: Felix Fietkau <nbd@openwrt.org>
Signed-off-by: Valerie Aurora <vaurora@redhat.com>
Cc: David Woodhouse <dwmw2@infradead.org>
Cc: linux-mtd@lists.infradead.org
---
fs/jffs2/dir.c | 72 ++++++++++++++++++++++++++++++++++++++++++++++++-
fs/jffs2/fs.c | 4 +++
fs/jffs2/super.c | 2 +
include/linux/jffs2.h | 2 +
4 files changed, 77 insertions(+), 3 deletions(-)
diff --git a/fs/jffs2/dir.c b/fs/jffs2/dir.c
index 4bca6a2..db79fdc 100644
--- a/fs/jffs2/dir.c
+++ b/fs/jffs2/dir.c
@@ -35,6 +35,8 @@ static int jffs2_mknod (struct inode *,struct dentry *,int,dev_t);
static int jffs2_rename (struct inode *, struct dentry *,
struct inode *, struct dentry *);
+static int jffs2_whiteout (struct inode *, struct dentry *, struct dentry *);
+
const struct file_operations jffs2_dir_operations =
{
.read = generic_read_dir,
@@ -57,6 +59,7 @@ const struct inode_operations jffs2_dir_inode_operations =
.mknod = jffs2_mknod,
.rename = jffs2_rename,
.check_acl = jffs2_check_acl,
+ .whiteout = jffs2_whiteout,
.setattr = jffs2_setattr,
.setxattr = jffs2_setxattr,
.getxattr = jffs2_getxattr,
@@ -97,8 +100,14 @@ static struct dentry *jffs2_lookup(struct inode *dir_i, struct dentry *target,
fd = fd_list;
}
}
- if (fd)
- ino = fd->ino;
+ if (fd) {
+ spin_lock(&target->d_lock);
+ if (fd->type == DT_WHT)
+ target->d_flags |= DCACHE_WHITEOUT;
+ else
+ ino = fd->ino;
+ spin_unlock(&target->d_lock);
+ }
mutex_unlock(&dir_f->sem);
if (ino) {
inode = jffs2_iget(dir_i->i_sb, ino);
@@ -493,6 +502,11 @@ static int jffs2_mkdir (struct inode *dir_i, struct dentry *dentry, int mode)
return PTR_ERR(inode);
}
+ if (dentry->d_flags & DCACHE_WHITEOUT) {
+ inode->i_flags |= S_OPAQUE;
+ ri->flags = cpu_to_je16(JFFS2_INO_FLAG_OPAQUE);
+ }
+
inode->i_op = &jffs2_dir_inode_operations;
inode->i_fop = &jffs2_dir_operations;
@@ -771,6 +785,60 @@ static int jffs2_mknod (struct inode *dir_i, struct dentry *dentry, int mode, de
return ret;
}
+static int jffs2_whiteout (struct inode *dir, struct dentry *old_dentry,
+ struct dentry *new_dentry)
+{
+ struct jffs2_sb_info *c = JFFS2_SB_INFO(dir->i_sb);
+ struct jffs2_inode_info *victim_f = NULL;
+ uint32_t now;
+ int ret;
+
+ /* If it's a directory, then check whether it is really empty */
+ if (new_dentry->d_inode) {
+ victim_f = JFFS2_INODE_INFO(old_dentry->d_inode);
+ if (S_ISDIR(old_dentry->d_inode->i_mode)) {
+ struct jffs2_full_dirent *fd;
+
+ mutex_lock(&victim_f->sem);
+ for (fd = victim_f->dents; fd; fd = fd->next) {
+ if (fd->ino) {
+ mutex_unlock(&victim_f->sem);
+ return -ENOTEMPTY;
+ }
+ }
+ mutex_unlock(&victim_f->sem);
+ }
+ }
+
+ now = get_seconds();
+ ret = jffs2_do_link(c, JFFS2_INODE_INFO(dir), 0, DT_WHT,
+ new_dentry->d_name.name, new_dentry->d_name.len, now);
+ if (ret)
+ return ret;
+
+ spin_lock(&new_dentry->d_lock);
+ new_dentry->d_flags |= DCACHE_WHITEOUT;
+ spin_unlock(&new_dentry->d_lock);
+ d_add(new_dentry, NULL);
+
+ if (victim_f) {
+ /* There was a victim. Kill it off nicely */
+ drop_nlink(old_dentry->d_inode);
+ /* Don't oops if the victim was a dirent pointing to an
+ inode which didn't exist. */
+ if (victim_f->inocache) {
+ mutex_lock(&victim_f->sem);
+ if (S_ISDIR(old_dentry->d_inode->i_mode))
+ victim_f->inocache->pino_nlink = 0;
+ else
+ victim_f->inocache->pino_nlink--;
+ mutex_unlock(&victim_f->sem);
+ }
+ }
+
+ return 0;
+}
+
static int jffs2_rename (struct inode *old_dir_i, struct dentry *old_dentry,
struct inode *new_dir_i, struct dentry *new_dentry)
{
diff --git a/fs/jffs2/fs.c b/fs/jffs2/fs.c
index 46ad619..ff4e6eb 100644
--- a/fs/jffs2/fs.c
+++ b/fs/jffs2/fs.c
@@ -303,6 +303,10 @@ struct inode *jffs2_iget(struct super_block *sb, unsigned long ino)
inode->i_op = &jffs2_dir_inode_operations;
inode->i_fop = &jffs2_dir_operations;
+
+ if (je16_to_cpu(latest_node.flags) & JFFS2_INO_FLAG_OPAQUE)
+ inode->i_flags |= S_OPAQUE;
+
break;
}
case S_IFREG:
diff --git a/fs/jffs2/super.c b/fs/jffs2/super.c
index 853b8e3..40c26a0 100644
--- a/fs/jffs2/super.c
+++ b/fs/jffs2/super.c
@@ -177,7 +177,7 @@ static int jffs2_fill_super(struct super_block *sb, void *data, int silent)
sb->s_op = &jffs2_super_operations;
sb->s_export_op = &jffs2_export_ops;
- sb->s_flags = sb->s_flags | MS_NOATIME;
+ sb->s_flags = sb->s_flags | MS_NOATIME | MS_WHITEOUT;
sb->s_xattr = jffs2_xattr_handlers;
#ifdef CONFIG_JFFS2_FS_POSIX_ACL
sb->s_flags |= MS_POSIXACL;
diff --git a/include/linux/jffs2.h b/include/linux/jffs2.h
index a18b719..6404e01 100644
--- a/include/linux/jffs2.h
+++ b/include/linux/jffs2.h
@@ -88,6 +88,8 @@
#define JFFS2_INO_FLAG_USERCOMPR 2 /* User has requested a specific
compression type */
+#define JFFS2_INO_FLAG_OPAQUE 4 /* Directory is opaque (for union mounts) */
+
/* These can go once we've made sure we've caught all uses without
byteswapping */
^ permalink raw reply related [flat|nested] 79+ messages in thread* [PATCH 17/76] VFS: Basic fallthru definitions
2011-06-17 16:00 [RFC][PATCH 00/76] Union Mount David Howells
` (15 preceding siblings ...)
2011-06-17 16:02 ` [PATCH 16/76] jffs2: " David Howells
@ 2011-06-17 16:02 ` David Howells
2011-06-17 16:02 ` [PATCH 18/76] ext2: Add fallthru support David Howells
` (59 subsequent siblings)
76 siblings, 0 replies; 79+ messages in thread
From: David Howells @ 2011-06-17 16:02 UTC (permalink / raw)
To: linux-fsdevel; +Cc: hch
From: Valerie Aurora <vaurora@redhat.com>
Define the fallthru dcache flag and file system op. Mask out the
DCACHE_FALLTHRU flag on dentry creation.
Actual users and changes to lookup come in later patches.
Signed-off-by: Valerie Aurora <vaurora@redhat.com>
---
Documentation/filesystems/vfs.txt | 6 ++++++
fs/dcache.c | 2 +-
include/linux/dcache.h | 6 ++++++
include/linux/fs.h | 2 ++
4 files changed, 15 insertions(+), 1 deletions(-)
diff --git a/Documentation/filesystems/vfs.txt b/Documentation/filesystems/vfs.txt
index d9a43db..3335773 100644
--- a/Documentation/filesystems/vfs.txt
+++ b/Documentation/filesystems/vfs.txt
@@ -328,6 +328,7 @@ struct inode_operations {
int (*rmdir) (struct inode *,struct dentry *);
int (*mknod) (struct inode *,struct dentry *,int,dev_t);
int (*whiteout) (struct inode *, struct dentry *, struct dentry *);
+ int (*fallthru) (struct inode *, struct dentry *);
int (*rename) (struct inode *, struct dentry *,
struct inode *, struct dentry *);
int (*readlink) (struct dentry *, char __user *,int);
@@ -399,6 +400,11 @@ otherwise noted.
second is the dentry for the whiteout itself. This method
must unlink() or rmdir() the original entry if it exists.
+ fallthru: called by the readdir(2) system call on a layered file
+ system. Only required if you want to support fallthrus.
+ Fallthrus are place-holders for directory entries visible from
+ a lower level file system.
+
rename: called by the rename(2) system call to rename the object to
have the parent and name given by the second inode and dentry.
diff --git a/fs/dcache.c b/fs/dcache.c
index 1974031..41278d7 100644
--- a/fs/dcache.c
+++ b/fs/dcache.c
@@ -1371,7 +1371,7 @@ static void __d_instantiate(struct dentry *dentry, struct inode *inode)
{
spin_lock(&dentry->d_lock);
if (inode) {
- dentry->d_flags &= ~DCACHE_WHITEOUT;
+ dentry->d_flags &= ~(DCACHE_WHITEOUT | DCACHE_FALLTHRU);
if (unlikely(IS_AUTOMOUNT(inode)))
dentry->d_flags |= DCACHE_NEED_AUTOMOUNT;
list_add(&dentry->d_alias, &inode->i_dentry);
diff --git a/include/linux/dcache.h b/include/linux/dcache.h
index 98187cf..1c4ad1b 100644
--- a/include/linux/dcache.h
+++ b/include/linux/dcache.h
@@ -208,6 +208,7 @@ struct dentry_operations {
#define DCACHE_CANT_MOUNT 0x0100
#define DCACHE_GENOCIDE 0x0200
#define DCACHE_WHITEOUT 0x0400 /* Stop lookup in a unioned file system */
+#define DCACHE_FALLTHRU 0x0800 /* Continue lookup below an opaque dir */
#define DCACHE_OP_HASH 0x1000
#define DCACHE_OP_COMPARE 0x2000
@@ -417,6 +418,11 @@ static inline int d_is_whiteout(struct dentry *dentry)
return dentry->d_flags & DCACHE_WHITEOUT;
}
+static inline int d_is_fallthru(struct dentry *dentry)
+{
+ return dentry->d_flags & DCACHE_FALLTHRU;
+}
+
static inline bool d_mountpoint(struct dentry *dentry)
{
return dentry->d_flags & DCACHE_MOUNTED;
diff --git a/include/linux/fs.h b/include/linux/fs.h
index 134b5d7..b21aed3 100644
--- a/include/linux/fs.h
+++ b/include/linux/fs.h
@@ -209,6 +209,7 @@ struct inodes_stat_t {
#define MS_I_VERSION (1<<23) /* Update inode I_version field */
#define MS_STRICTATIME (1<<24) /* Always perform atime updates */
#define MS_WHITEOUT (1<<25) /* FS supports whiteout filetype */
+#define MS_FALLTHRU (1<<26) /* FS supports fallthru filetype */
#define MS_NOSEC (1<<28)
#define MS_BORN (1<<29)
#define MS_ACTIVE (1<<30)
@@ -1603,6 +1604,7 @@ struct inode_operations {
int (*rmdir) (struct inode *,struct dentry *);
int (*mknod) (struct inode *,struct dentry *,int,dev_t);
int (*whiteout) (struct inode *, struct dentry *, struct dentry *);
+ int (*fallthru) (struct inode *, struct dentry *);
int (*rename) (struct inode *, struct dentry *,
struct inode *, struct dentry *);
void (*truncate) (struct inode *);
^ permalink raw reply related [flat|nested] 79+ messages in thread* [PATCH 18/76] ext2: Add fallthru support
2011-06-17 16:00 [RFC][PATCH 00/76] Union Mount David Howells
` (16 preceding siblings ...)
2011-06-17 16:02 ` [PATCH 17/76] VFS: Basic fallthru definitions David Howells
@ 2011-06-17 16:02 ` David Howells
2011-06-17 16:03 ` [PATCH 19/76] tmpfs: " David Howells
` (58 subsequent siblings)
76 siblings, 0 replies; 79+ messages in thread
From: David Howells @ 2011-06-17 16:02 UTC (permalink / raw)
To: linux-fsdevel; +Cc: hch
From: Valerie Aurora <vaurora@redhat.com>
Add support for fallthru directory entries to ext2.
Cc: Jan Kara <jack@suse.cz>
Cc: linux-ext4@vger.kernel.org
Signed-off-by: Valerie Aurora <vaurora@redhat.com>
Signed-off-by: Jan Blunck <jblunck@suse.de>
---
fs/ext2/dir.c | 44 ++++++++++++++++++++++++++++++++++++++------
fs/ext2/ext2.h | 1 +
fs/ext2/namei.c | 22 ++++++++++++++++++++++
fs/ext2/super.c | 2 ++
include/linux/ext2_fs.h | 4 ++++
5 files changed, 67 insertions(+), 6 deletions(-)
diff --git a/fs/ext2/dir.c b/fs/ext2/dir.c
index 4ef5777..0a95eea 100644
--- a/fs/ext2/dir.c
+++ b/fs/ext2/dir.c
@@ -220,7 +220,9 @@ fail:
static inline int ext2_dirent_in_use(struct ext2_dir_entry_2 *de)
{
- return de->inode != 0 || de->file_type == EXT2_FT_WHT;
+ return de->inode != 0 ||
+ de->file_type == EXT2_FT_WHT ||
+ de->file_type == EXT2_FT_FALLTHRU;
}
/*
@@ -270,6 +272,7 @@ static unsigned char ext2_filetype_table[EXT2_FT_MAX] = {
[EXT2_FT_SOCK] = DT_SOCK,
[EXT2_FT_SYMLINK] = DT_LNK,
[EXT2_FT_WHT] = DT_WHT,
+ [EXT2_FT_FALLTHRU] = DT_UNKNOWN,
};
#define S_SHIFT 12
@@ -350,8 +353,20 @@ ext2_readdir (struct file * filp, void * dirent, filldir_t filldir)
offset = (char *)de - kaddr;
over = filldir(dirent, de->name, de->name_len,
- (n<<PAGE_CACHE_SHIFT) | offset,
- le32_to_cpu(de->inode), d_type);
+ (n << PAGE_CACHE_SHIFT) | offset,
+ le32_to_cpu(de->inode), d_type);
+ if (over) {
+ ext2_put_page(page);
+ return 0;
+ }
+ } else if (de->file_type == EXT2_FT_FALLTHRU) {
+ int over;
+
+ offset = (char *)de - kaddr;
+ /* XXX placeholder until generic_readdir_fallthru() arrives */
+ over = filldir(dirent, de->name, de->name_len,
+ (n<<PAGE_CACHE_SHIFT) | offset,
+ 1, DT_UNKNOWN); /* XXX */
if (over) {
ext2_put_page(page);
return 0;
@@ -482,6 +497,10 @@ ino_t ext2_inode_by_dentry(struct inode *dir, struct dentry *dentry)
spin_lock(&dentry->d_lock);
dentry->d_flags |= DCACHE_WHITEOUT;
spin_unlock(&dentry->d_lock);
+ } else if (!res && de->file_type == EXT2_FT_FALLTHRU) {
+ spin_lock(&dentry->d_lock);
+ dentry->d_flags |= DCACHE_FALLTHRU;
+ spin_unlock(&dentry->d_lock);
}
ext2_put_page(page);
}
@@ -580,15 +599,18 @@ got_it:
/*
* Pre-existing entries with the same name are allowable
* depending on the type of the entry being created. Regular
- * entries replace whiteouts. Whiteouts replace regular
- * entries.
+ * entries replace whiteouts and fallthrus. Whiteouts replace
+ * regular entries. Fallthrus replace nothing.
*/
err = -EEXIST;
if (ext2_match(namelen, name, de)) {
if (new_file_type == EXT2_FT_WHT) {
if (de->file_type == EXT2_FT_WHT)
goto out_unlock;
- } else if (de->file_type != EXT2_FT_WHT) {
+ } else if (new_file_type == EXT2_FT_FALLTHRU) {
+ goto out_unlock;
+ } else if ((de->file_type != EXT2_FT_WHT) &&
+ (de->file_type != EXT2_FT_FALLTHRU)) {
goto out_unlock;
}
}
@@ -639,6 +661,16 @@ int ext2_whiteout_entry (struct dentry *dentry, ext2_dirent *de, struct page *pa
}
/*
+ * Create a fallthru entry.
+ */
+int ext2_fallthru_entry (struct dentry *dentry)
+{
+ ext2_dirent *de = NULL;
+ struct page *page = NULL;
+ return ext2_add_entry(dentry, NULL, de, page, EXT2_FT_FALLTHRU);
+}
+
+/*
* ext2_delete_entry deletes a directory entry by merging it with the
* previous entry. Page is up-to-date. Releases the page.
*/
diff --git a/fs/ext2/ext2.h b/fs/ext2/ext2.h
index 78719f4..cd538b5 100644
--- a/fs/ext2/ext2.h
+++ b/fs/ext2/ext2.h
@@ -107,6 +107,7 @@ extern int ext2_make_empty(struct inode *, struct inode *);
extern struct ext2_dir_entry_2 * ext2_find_entry (struct inode *,struct qstr *, struct page **);
extern int ext2_delete_entry (struct ext2_dir_entry_2 *, struct page *);
extern int ext2_whiteout_entry (struct dentry *, struct ext2_dir_entry_2 *, struct page *);
+extern int ext2_fallthru_entry (struct dentry *);
extern int ext2_empty_dir (struct inode *);
extern struct ext2_dir_entry_2 * ext2_dotdot (struct inode *, struct page **);
extern void ext2_set_link(struct inode *, struct ext2_dir_entry_2 *, struct page *, struct inode *, int);
diff --git a/fs/ext2/namei.c b/fs/ext2/namei.c
index a17c9c8..61db2dd 100644
--- a/fs/ext2/namei.c
+++ b/fs/ext2/namei.c
@@ -345,6 +345,7 @@ static int ext2_whiteout(struct inode *dir, struct dentry *dentry,
goto out;
spin_lock(&new_dentry->d_lock);
+ new_dentry->d_flags &= ~DCACHE_FALLTHRU;
new_dentry->d_flags |= DCACHE_WHITEOUT;
spin_unlock(&new_dentry->d_lock);
d_add(new_dentry, NULL);
@@ -363,6 +364,26 @@ out:
return err;
}
+/*
+ * Create a fallthru entry.
+ */
+static int ext2_fallthru (struct inode *dir, struct dentry *dentry)
+{
+ int err;
+
+ dquot_initialize(dir);
+
+ err = ext2_fallthru_entry(dentry);
+ if (err)
+ return err;
+
+ d_instantiate(dentry, NULL);
+ spin_lock(&dentry->d_lock);
+ dentry->d_flags |= DCACHE_FALLTHRU;
+ spin_unlock(&dentry->d_lock);
+ return 0;
+}
+
static int ext2_rename (struct inode * old_dir, struct dentry * old_dentry,
struct inode * new_dir, struct dentry * new_dentry )
{
@@ -461,6 +482,7 @@ const struct inode_operations ext2_dir_inode_operations = {
.rmdir = ext2_rmdir,
.mknod = ext2_mknod,
.whiteout = ext2_whiteout,
+ .fallthru = ext2_fallthru,
.rename = ext2_rename,
#ifdef CONFIG_EXT2_FS_XATTR
.setxattr = generic_setxattr,
diff --git a/fs/ext2/super.c b/fs/ext2/super.c
index 6167ff3..797f47d 100644
--- a/fs/ext2/super.c
+++ b/fs/ext2/super.c
@@ -1101,6 +1101,8 @@ static int ext2_fill_super(struct super_block *sb, void *data, int silent)
if (EXT2_HAS_INCOMPAT_FEATURE(sb, EXT2_FEATURE_INCOMPAT_WHITEOUT))
sb->s_flags |= MS_WHITEOUT;
+ if (EXT2_HAS_INCOMPAT_FEATURE(sb, EXT2_FEATURE_INCOMPAT_FALLTHRU))
+ sb->s_flags |= MS_FALLTHRU;
if (ext2_setup_super (sb, es, sb->s_flags & MS_RDONLY))
sb->s_flags |= MS_RDONLY;
diff --git a/include/linux/ext2_fs.h b/include/linux/ext2_fs.h
index b0fb356..1a6f929 100644
--- a/include/linux/ext2_fs.h
+++ b/include/linux/ext2_fs.h
@@ -505,11 +505,14 @@ struct ext2_super_block {
#define EXT3_FEATURE_INCOMPAT_JOURNAL_DEV 0x0008
#define EXT2_FEATURE_INCOMPAT_META_BG 0x0010
#define EXT2_FEATURE_INCOMPAT_WHITEOUT 0x0020
+/* ext3/4 incompat flags take up the intervening constants */
+#define EXT2_FEATURE_INCOMPAT_FALLTHRU 0x2000
#define EXT2_FEATURE_INCOMPAT_ANY 0xffffffff
#define EXT2_FEATURE_COMPAT_SUPP EXT2_FEATURE_COMPAT_EXT_ATTR
#define EXT2_FEATURE_INCOMPAT_SUPP (EXT2_FEATURE_INCOMPAT_FILETYPE| \
EXT2_FEATURE_INCOMPAT_WHITEOUT| \
+ EXT2_FEATURE_INCOMPAT_FALLTHRU| \
EXT2_FEATURE_INCOMPAT_META_BG)
#define EXT2_FEATURE_RO_COMPAT_SUPP (EXT2_FEATURE_RO_COMPAT_SPARSE_SUPER| \
EXT2_FEATURE_RO_COMPAT_LARGE_FILE| \
@@ -577,6 +580,7 @@ enum {
EXT2_FT_SOCK = 6,
EXT2_FT_SYMLINK = 7,
EXT2_FT_WHT = 8,
+ EXT2_FT_FALLTHRU = 9,
EXT2_FT_MAX
};
^ permalink raw reply related [flat|nested] 79+ messages in thread* [PATCH 19/76] tmpfs: Add fallthru support
2011-06-17 16:00 [RFC][PATCH 00/76] Union Mount David Howells
` (17 preceding siblings ...)
2011-06-17 16:02 ` [PATCH 18/76] ext2: Add fallthru support David Howells
@ 2011-06-17 16:03 ` David Howells
2011-06-17 16:03 ` [PATCH 20/76] jffs2: " David Howells
` (57 subsequent siblings)
76 siblings, 0 replies; 79+ messages in thread
From: David Howells @ 2011-06-17 16:03 UTC (permalink / raw)
To: linux-fsdevel; +Cc: hch
From: Valerie Aurora <vaurora@redhat.com>
Add support for fallthru directory entries to tmpfs.
---
fs/dcache.c | 4 +++-
fs/libfs.c | 16 ++++++++++++---
mm/shmem.c | 64 ++++++++++++++++++++++++++++++++++++++++++++++++++++-------
3 files changed, 72 insertions(+), 12 deletions(-)
diff --git a/fs/dcache.c b/fs/dcache.c
index 41278d7..039a243 100644
--- a/fs/dcache.c
+++ b/fs/dcache.c
@@ -2925,7 +2925,9 @@ resume:
* can evict it.
*/
if (d_unhashed(dentry) ||
- (!dentry->d_inode && !d_is_whiteout(dentry))) {
+ (!dentry->d_inode &&
+ !d_is_whiteout(dentry) &&
+ !d_is_fallthru(dentry))) {
spin_unlock(&dentry->d_lock);
continue;
}
diff --git a/fs/libfs.c b/fs/libfs.c
index c88eab5..ce46b8e 100644
--- a/fs/libfs.c
+++ b/fs/libfs.c
@@ -139,6 +139,7 @@ int dcache_readdir(struct file * filp, void * dirent, filldir_t filldir)
struct dentry *cursor = filp->private_data;
struct list_head *p, *q = &cursor->d_u.d_child;
ino_t ino;
+ char d_type;
int i = filp->f_pos;
switch (i) {
@@ -165,17 +166,26 @@ int dcache_readdir(struct file * filp, void * dirent, filldir_t filldir)
struct dentry *next;
next = list_entry(p, struct dentry, d_u.d_child);
spin_lock_nested(&next->d_lock, DENTRY_D_LOCK_NESTED);
- if (!simple_positive(next)) {
+ if (d_unhashed(next) ||
+ (!next->d_inode && !d_is_fallthru(next))) {
spin_unlock(&next->d_lock);
continue;
}
spin_unlock(&next->d_lock);
spin_unlock(&dentry->d_lock);
+ if (d_is_fallthru(next)) {
+ /* XXX placeholder until generic_readdir_fallthru() arrives */
+ ino = 1;
+ d_type = DT_UNKNOWN;
+ } else {
+ ino = next->d_inode->i_ino;
+ d_type = dt_type(next->d_inode);
+ }
+
if (filldir(dirent, next->d_name.name,
next->d_name.len, filp->f_pos,
- next->d_inode->i_ino,
- dt_type(next->d_inode)) < 0)
+ ino, d_type) < 0)
return 0;
spin_lock(&dentry->d_lock);
spin_lock_nested(&next->d_lock, DENTRY_D_LOCK_NESTED);
diff --git a/mm/shmem.c b/mm/shmem.c
index 7e795e3..fa800f3 100644
--- a/mm/shmem.c
+++ b/mm/shmem.c
@@ -1869,8 +1869,7 @@ static int shmem_rmdir(struct inode *dir, struct dentry *dentry);
static int shmem_unlink(struct inode *dir, struct dentry *dentry);
/*
- * This is the whiteout support for tmpfs. It uses one singleton whiteout
- * inode per superblock thus it is very similar to shmem_link().
+ * Create a dentry to signify a whiteout.
*/
static int shmem_whiteout(struct inode *dir, struct dentry *old_dentry,
struct dentry *new_dentry)
@@ -1901,8 +1900,10 @@ static int shmem_whiteout(struct inode *dir, struct dentry *old_dentry,
spin_unlock(&sbinfo->stat_lock);
}
- if (old_dentry->d_inode) {
- if (S_ISDIR(old_dentry->d_inode->i_mode))
+ if (old_dentry->d_inode || d_is_fallthru(old_dentry)) {
+ /* A fallthru for a dir is treated like a regular link */
+ if (old_dentry->d_inode &&
+ S_ISDIR(old_dentry->d_inode->i_mode))
shmem_rmdir(dir, old_dentry);
else
shmem_unlink(dir, old_dentry);
@@ -1919,6 +1920,48 @@ static int shmem_whiteout(struct inode *dir, struct dentry *old_dentry,
}
static void shmem_d_instantiate(struct inode *dir, struct dentry *dentry,
+ struct inode *inode);
+
+/*
+ * Create a dentry to signify a fallthru. A fallthru in tmpfs is the
+ * logical equivalent of an in-kernel readdir() cache. It can't be
+ * deleted until the file system is unmounted.
+ */
+static int shmem_fallthru(struct inode *dir, struct dentry *dentry)
+{
+ struct shmem_sb_info *sbinfo = SHMEM_SB(dir->i_sb);
+
+ /* FIXME: this is stupid */
+ if (!(dir->i_sb->s_flags & MS_WHITEOUT))
+ return -EPERM;
+
+ if (dentry->d_inode || d_is_fallthru(dentry) || d_is_whiteout(dentry))
+ return -EEXIST;
+
+ /*
+ * Each new link needs a new dentry, pinning lowmem, and tmpfs
+ * dentries cannot be pruned until they are unlinked.
+ */
+ if (sbinfo->max_inodes) {
+ spin_lock(&sbinfo->stat_lock);
+ if (!sbinfo->free_inodes) {
+ spin_unlock(&sbinfo->stat_lock);
+ return -ENOSPC;
+ }
+ sbinfo->free_inodes--;
+ spin_unlock(&sbinfo->stat_lock);
+ }
+
+ shmem_d_instantiate(dir, dentry, NULL);
+ dir->i_ctime = dir->i_mtime = CURRENT_TIME;
+
+ spin_lock(&dentry->d_lock);
+ dentry->d_flags |= DCACHE_FALLTHRU;
+ spin_unlock(&dentry->d_lock);
+ return 0;
+}
+
+static void shmem_d_instantiate(struct inode *dir, struct dentry *dentry,
struct inode *inode)
{
if (d_is_whiteout(dentry)) {
@@ -1926,14 +1969,15 @@ static void shmem_d_instantiate(struct inode *dir, struct dentry *dentry,
shmem_free_inode(dir->i_sb);
if (S_ISDIR(inode->i_mode))
inode->i_mode |= S_OPAQUE;
+ } else if (d_is_fallthru(dentry)) {
+ shmem_free_inode(dir->i_sb);
} else {
/* New dentry */
dir->i_size += BOGO_DIRENT_SIZE;
dget(dentry); /* Extra count - pin the dentry in core */
}
- /* Will clear DCACHE_WHITEOUT flag */
+ /* Will clear DCACHE_WHITEOUT and DCACHE_FALLTHRU flags */
d_instantiate(dentry, inode);
-
}
/*
* File creation. Allocate an inode, and we're done..
@@ -2015,7 +2059,8 @@ static int shmem_unlink(struct inode *dir, struct dentry *dentry)
{
struct inode *inode = dentry->d_inode;
- if (d_is_whiteout(dentry) || (inode->i_nlink > 1 && !S_ISDIR(inode->i_mode)))
+ if (d_is_whiteout(dentry) || d_is_fallthru(dentry) ||
+ (inode->i_nlink > 1 && !S_ISDIR(inode->i_mode)))
shmem_free_inode(dir->i_sb);
if (inode) {
@@ -2734,8 +2779,10 @@ int shmem_fill_super(struct super_block *sb, void *data, int silent)
sb->s_root = root;
#ifdef CONFIG_TMPFS
- if (!(sb->s_flags & MS_NOUSER))
+ if (!(sb->s_flags & MS_NOUSER)) {
sb->s_flags |= MS_WHITEOUT;
+ sb->s_flags |= MS_FALLTHRU;
+ }
#endif
return 0;
@@ -2847,6 +2894,7 @@ static const struct inode_operations shmem_dir_inode_operations = {
.mknod = shmem_mknod,
.rename = shmem_rename,
.whiteout = shmem_whiteout,
+ .fallthru = shmem_fallthru,
#endif
#ifdef CONFIG_TMPFS_XATTR
.setxattr = shmem_setxattr,
^ permalink raw reply related [flat|nested] 79+ messages in thread* [PATCH 20/76] jffs2: Add fallthru support
2011-06-17 16:00 [RFC][PATCH 00/76] Union Mount David Howells
` (18 preceding siblings ...)
2011-06-17 16:03 ` [PATCH 19/76] tmpfs: " David Howells
@ 2011-06-17 16:03 ` David Howells
2011-06-17 16:03 ` [PATCH 21/76] union-mount: Union mounts documentation David Howells
` (56 subsequent siblings)
76 siblings, 0 replies; 79+ messages in thread
From: David Howells @ 2011-06-17 16:03 UTC (permalink / raw)
To: linux-fsdevel; +Cc: hch
From: Felix Fietkau <nbd@openwrt.org>
Add support for fallthru dentries to jffs2.
XXX - untested changes from David Woodhouse and Valerie Aurora.
Cc: David Woodhouse <dwmw2@infradead.org>
Cc: linux-mtd@lists.infradead.org
Signed-off-by: Felix Fietkau <nbd@openwrt.org>
Signed-off-by: Valerie Aurora <vaurora@redhat.com>
---
fs/jffs2/dir.c | 44 ++++++++++++++++++++++++++++++++++++++++----
include/linux/jffs2.h | 6 ++++++
2 files changed, 46 insertions(+), 4 deletions(-)
diff --git a/fs/jffs2/dir.c b/fs/jffs2/dir.c
index db79fdc..5f79789 100644
--- a/fs/jffs2/dir.c
+++ b/fs/jffs2/dir.c
@@ -36,6 +36,7 @@ static int jffs2_rename (struct inode *, struct dentry *,
struct inode *, struct dentry *);
static int jffs2_whiteout (struct inode *, struct dentry *, struct dentry *);
+static int jffs2_fallthru (struct inode *, struct dentry *);
const struct file_operations jffs2_dir_operations =
{
@@ -60,6 +61,7 @@ const struct inode_operations jffs2_dir_inode_operations =
.rename = jffs2_rename,
.check_acl = jffs2_check_acl,
.whiteout = jffs2_whiteout,
+ .fallthru = jffs2_fallthru,
.setattr = jffs2_setattr,
.setxattr = jffs2_setxattr,
.getxattr = jffs2_getxattr,
@@ -102,10 +104,14 @@ static struct dentry *jffs2_lookup(struct inode *dir_i, struct dentry *target,
}
if (fd) {
spin_lock(&target->d_lock);
- if (fd->type == DT_WHT)
+ switch (fd->type) {
+ case DT_WHT:
target->d_flags |= DCACHE_WHITEOUT;
- else
+ case JFFS2_DT_FALLTHRU:
+ target->d_flags |= DCACHE_FALLTHRU;
+ default:
ino = fd->ino;
+ }
spin_unlock(&target->d_lock);
}
mutex_unlock(&dir_f->sem);
@@ -129,6 +135,8 @@ static int jffs2_readdir(struct file *filp, void *dirent, filldir_t filldir)
struct inode *inode = filp->f_path.dentry->d_inode;
struct jffs2_full_dirent *fd;
unsigned long offset, curofs;
+ ino_t ino;
+ char d_type;
D1(printk(KERN_DEBUG "jffs2_readdir() for dir_i #%lu\n", filp->f_path.dentry->d_inode->i_ino));
@@ -161,13 +169,20 @@ static int jffs2_readdir(struct file *filp, void *dirent, filldir_t filldir)
fd->name, fd->ino, fd->type, curofs, offset));
continue;
}
- if (!fd->ino) {
+ if (fd->type == JFFS2_DT_FALLTHRU) {
+ /* XXX placeholder until generic_readdir_fallthru() arrives */
+ ino = 1;
+ d_type = DT_UNKNOWN;
+ } else if (!fd->ino && (fd->type != DT_WHT)) {
D2(printk(KERN_DEBUG "Skipping deletion dirent \"%s\"\n", fd->name));
offset++;
continue;
+ } else {
+ ino = fd->ino;
+ d_type = fd->type;
}
D2(printk(KERN_DEBUG "Dirent %ld: \"%s\", ino #%u, type %d\n", offset, fd->name, fd->ino, fd->type));
- if (filldir(dirent, fd->name, strlen(fd->name), offset, fd->ino, fd->type) < 0)
+ if (filldir(dirent, fd->name, strlen(fd->name), offset, ino, d_type) < 0)
break;
offset++;
}
@@ -785,6 +800,26 @@ static int jffs2_mknod (struct inode *dir_i, struct dentry *dentry, int mode, de
return ret;
}
+static int jffs2_fallthru (struct inode *dir, struct dentry *dentry)
+{
+ struct jffs2_sb_info *c = JFFS2_SB_INFO(dir->i_sb);
+ uint32_t now;
+ int ret;
+
+ now = get_seconds();
+ ret = jffs2_do_link(c, JFFS2_INODE_INFO(dir), 0, DT_UNKNOWN,
+ dentry->d_name.name, dentry->d_name.len, now);
+ if (ret)
+ return ret;
+
+ d_instantiate(dentry, NULL);
+ spin_lock(&dentry->d_lock);
+ dentry->d_flags |= DCACHE_FALLTHRU;
+ spin_unlock(&dentry->d_lock);
+
+ return 0;
+}
+
static int jffs2_whiteout (struct inode *dir, struct dentry *old_dentry,
struct dentry *new_dentry)
{
@@ -817,6 +852,7 @@ static int jffs2_whiteout (struct inode *dir, struct dentry *old_dentry,
return ret;
spin_lock(&new_dentry->d_lock);
+ new_dentry->d_flags &= ~DCACHE_FALLTHRU;
new_dentry->d_flags |= DCACHE_WHITEOUT;
spin_unlock(&new_dentry->d_lock);
d_add(new_dentry, NULL);
diff --git a/include/linux/jffs2.h b/include/linux/jffs2.h
index 6404e01..1749127 100644
--- a/include/linux/jffs2.h
+++ b/include/linux/jffs2.h
@@ -115,6 +115,12 @@ struct jffs2_unknown_node
jint32_t hdr_crc;
};
+/*
+ * Non-standard directory entry type(s), for on-disk use
+ */
+
+#define JFFS2_DT_FALLTHRU (DT_WHT + 1)
+
struct jffs2_raw_dirent
{
jint16_t magic;
^ permalink raw reply related [flat|nested] 79+ messages in thread* [PATCH 21/76] union-mount: Union mounts documentation
2011-06-17 16:00 [RFC][PATCH 00/76] Union Mount David Howells
` (19 preceding siblings ...)
2011-06-17 16:03 ` [PATCH 20/76] jffs2: " David Howells
@ 2011-06-17 16:03 ` David Howells
2011-06-17 16:03 ` [PATCH 22/76] union-mount: Introduce MNT_UNION and MS_UNION flags David Howells
` (55 subsequent siblings)
76 siblings, 0 replies; 79+ messages in thread
From: David Howells @ 2011-06-17 16:03 UTC (permalink / raw)
To: linux-fsdevel; +Cc: hch
From: Valerie Aurora <vaurora@redhat.com>
Document design and implementation of union mounts (a.k.a. writable overlays).
With corrections from Andreas Gruenbacher <agruen@suse.de>.
---
Documentation/filesystems/union-mounts.txt | 712 ++++++++++++++++++++++++++++
1 files changed, 712 insertions(+), 0 deletions(-)
create mode 100644 Documentation/filesystems/union-mounts.txt
diff --git a/Documentation/filesystems/union-mounts.txt b/Documentation/filesystems/union-mounts.txt
new file mode 100644
index 0000000..596bfe6
--- /dev/null
+++ b/Documentation/filesystems/union-mounts.txt
@@ -0,0 +1,712 @@
+Union mounts (a.k.a. writable overlays)
+=======================================
+
+This document describes the architecture and current status of union mounts,
+also known as writable overlays.
+
+In this document:
+ - Overview of union mounts
+ - Terminology
+ - VFS implementation
+ - Locking strategy
+ - VFS/file system interface
+ - Userland interface
+ - NFS interaction
+ - Status
+ - Contributing to union mounts
+
+Overview
+========
+
+A union mount layers one read-write file system over one or more read-only file
+systems, with all writes going to the writable file system. The namespace of
+both file systems appears as a combined whole to userland, with files and
+directories on the writable file system covering up any files or directories
+with matching pathnames on the read-only file system. The read-write file
+system is the "topmost" or "upper" file system and the read-only file systems
+are the "lower" file systems. A few use cases:
+
+- Root file system on CD with writes saved to hard drive (LiveCD)
+- Multiple virtual machines with the same starting root file system
+- Cluster with NFS mounted root on clients
+
+Most if not all of these problems could be solved with a COW block device or a
+clustered file system (include NFS mounts). However, for some use cases,
+sharing is more efficient and better performing if done at the file system
+namespace level. COW block devices only increase their divergence as time goes
+on, and a fully coherent writable file system is unnecessary synchronization
+overhead if no other client needs to see the writes.
+
+What union mounts are not
+-------------------------
+
+Union mounts are not a general-purpose unioning file system. They do not
+provide a generic "union of namespaces" operation for an arbitrary number of
+file systems. Many interesting features can be implemented with a generic
+unioning facility: dynamic insertion and removal of branches, write policies
+based on space available, online upgrade, etc. Some unioning file systems that
+do this are UnionFS and AUFS.
+
+Terminology
+===========
+
+The main physical metaphor for union mounts is that a writable file system is
+mounted "on top" of a read-only file system. Lookups start at the "topmost"
+read-write file system and travel "down" to the "bottom" read-only file system
+only if no blocking entry exists on the top layer.
+
+Topmost layer: The read-write file system. Lookups begin here.
+
+Bottom layer: The read-only file system. Lookups end here.
+
+Path: Combination of the vfsmount and dentry structure.
+
+Follow down: Given a path from the top layer, find the corresponding path on
+the bottom layer.
+
+Follow up: Given a path from the bottom layer, find the corresponding path on
+the top layer.
+
+Whiteout: A directory entry in the top layer that prevents lookups from
+travelling down to the bottom layer. Created on unlink()/rmdir() if a
+corresponding directory entry exists in the bottom layer.
+
+Opaque flag: A flag on a directory in the top layer that prevents lookups of
+entries in this directory from travelling down to the bottom layer (unless
+there is an explicit fallthru entry allowing that for a particular entry). Set
+on creation of any new directory in in the topmost layer (that is, a directory
+that does not have any matching visible directory below it).
+
+Fallthru: A directory entry which allows lookups to "fall through" to the
+bottom layer for that exact directory entry. This serves as a placeholder for
+directory entries from the bottom layer during readdir(). Fallthrus override
+opaque flags.
+
+File copyup: Create a file on the top layer that has the same metadata and
+contents as the file with the same pathname on the bottom layer.
+
+Directory copyup: Copy up the visible directory entries from the bottom layer
+as fallthrus in the matching top layer directory. Mark the directory opaque to
+avoid unnecessary negative lookups on the bottom layer.
+
+Examples
+========
+
+What happens when I...
+
+- creat() /newfile -> creates on topmost layer
+- unlink() /oldfile -> creates a whiteout on topmost layer
+- Edit /existingfile -> copies up to top layer at open(O_WR) time
+- truncate /existingfile -> copies up to topmost layer + N bytes if specified
+- touch()/chmod()/chown()/etc. -> copies up to topmost layer
+- mkdir() /newdir -> creates opaque dir on topmost layer
+- rmdir() /olddir -> creates a whiteout on topmost layer
+- mkdir() /olddir after above -> creates opaque dir on topmost layer
+- readdir() /shareddir -> copies up entries from bottom layer as
+ fallthrus, processes duplicates and whiteouts
+- link() /oldfile /newlink -> copies up /oldfile, creates /newlink on
+ topmost layer
+- symlink() /oldfile /symlink -> nothing special
+- rename() /oldfile /newfile -> copies up /oldfile to /newfile on top layer,
+ whiteouts /oldfile
+- rename() /olddir /newdir -> EXDEV
+- rename() /topmost_only_dir /topmost_only_dir2 -> success
+- stat() /oldfile - inode & dev from lower layer
+- stat() /newfile - inode & dev from topmost layer
+- readdir() /shareddir - d_ino & d_type from lower layer on fallthrus
+
+Getting to a root file system with union mounts:
+
+- Mount the base read-only file system as the root file system
+- Mount the read-only file system again on /newroot
+- Mount the read-write layer on /newroot:
+ # mount -o union /dev/sda /newroot
+- pivot_root to /newroot
+- Start init
+
+See scripts/pivot.sh in the UML devkit linked to from:
+
+http://valerieaurora.org/union/
+
+VFS implementation
+==================
+
+Union mounts are implemented as an integral part of the VFS, rather than as a
+VFS client file system (i.e., a stacked file system like unionfs or ecryptfs).
+Implementing unioning inside the VFS eliminates the need for duplicate copies
+of VFS data structures, unnecessary indirection, and code duplication, but
+requires very maintainable, low overhead code. Union mounts require no change
+to file systems serving as the read-only layer, and requires some minor support
+from file systems serving as the read-write layer. File systems that want to
+be the writable layer must implement the new ->whiteout() and ->fallthru()
+inode operations, which create special dummy directory entries.
+
+The union mounts code must accomplish the following major tasks:
+
+1) Pass lookups through to the lower level file system.
+2) Copy files and directories up to the topmost layer when written.
+3) Create whiteouts and fallthrus as necessary.
+
+VFS objects and union mounts
+----------------------------
+
+First, some VFS basics:
+
+The VFS allows multiple mounts of the same file system. For example, /dev/sda
+can be mounted at /usr and also at /mnt. The same file system can be mounted
+read-only at one point and read-write at another. Each of these mounts has its
+own vfsmount data structure in the kernel. However, each underlying file
+system has exactly one in-kernel superblock structure no matter how many times
+it is mounted. All the separate vfsmounts for the same file system reference
+the same superblock data structure.
+
+Directory entries are cached by the VFS in dentry structures. The VFS keeps
+one dentry structure for each file or directory in a file system, no matter how
+many times it is mounted. Each dentry represents only one element of a path
+name. When the VFS looks up a pathname (e.g., "/sbin/init"), the result is a
+combination of vfsmount and dentry. This <mnt,dentry> pair is usually stored
+in a kernel structure named "path", which is simply two pointers, one to the
+vfsmount and one to the dentry. A "struct path" is this structure; a pathname
+is a string like "/etc/fstab".
+
+In union mounts, a file system can only be the topmost layer for one union
+mount. A file system can be part of multiple union mounts if it is a read-only
+layer. So dentries in the read-only layers can be part of multiple unions,
+while a dentry in the read-write layer can only be part of one unin.
+
+union_dir structure
+---------------------
+
+The first job of union mounts is to map directories from the topmost layer to
+directories with the same pathname in the lower layer. That is, given the
+<mnt,dentry> pair for a directory pathname in the topmost layer, we need to
+find all the <mnt,dentry> pairs for the directory with the same pathname in the
+lower layer. We do this with the union_dir structure, which is an array
+containing struct paths (mnt, dentry pointer pairs) for each directory unioned
+with the topmost union. The array is pointed to from the new d_union_stack
+member of struct dentry.
+
+/*
+ * The union_stack structure. It is an array of struct paths of
+ * directories below the topmost directory in a unioned directory, The
+ * topmost dentry has a pointer to this structure. The topmost dentry
+ * can only be part of one union, so we can reference it from the
+ * dentry, but lower dentries can be part of multiple union stacks.
+ *
+ * The number of dirs actually allocated is kept in the superblock,
+ * s_union_count.
+ */
+struct union_stack {
+ struct path u_dirs[0];
+};
+
+This structure is flexible enough to support an arbitrary number of layers of
+unioned file systems. Since there can be more than two layers, this section
+will talk about mapping "upper" directories to "lower" directories, instead of
+"topmost" directories to "bottom" directories.
+
+Traversing the union stack
+--------------------------
+
+The set of union_dir structures referring to a particular pathname are called
+collectively the union stack for that directory. To traverse the union stack,
+iterate through the number of layers in the union (stored in sb->s_union_count)
+with union_find_dir(). Example: freeing the union stack:
+
+void d_free_unions(struct dentry *topmost)
+{
+ struct path *path;
+ unsigned int i, layers = topmost->d_sb->s_union_count;
+
+ if (!IS_DIR_UNIONED(topmost))
+ return;
+
+ for (i = 0; i < layers; i++) {
+ path = union_find_dir(topmost, i);
+ if (path->mnt)
+ path_put(path);
+ }
+ kfree(topmost->d_union_stack);
+ topmost->d_union_stack = NULL;
+}
+
+Code paths
+----------
+
+Union mounts modify the following key code paths in the VFS:
+
+- mount()/umount()
+- Pathname lookup
+- Any path that modifies an existing file
+
+Mount
+-----
+
+Union mounts are created in two steps:
+
+1. Mount the read-only layer file systems read-only in the usual manner, all on
+the same mountpoint. Submounts are permitted as long as they are also
+read-only and not shared (part of a mount propagation group).
+
+2. Mount the top layer with the "-o union" option at the same mountpoint. All
+read-only file systems mounted at this mountpoint will be included in the union
+mount.
+
+The bottom layers must be read-only and the top layer must be read-write and
+support whiteouts and fallthrus. A file system that supports whiteouts and
+fallthrus indicates this by setting the MS_WHITEOUT and MS_FALLTHRU flags in
+the superblock. Currently, the top layer is forced to "noatime" to avoid a
+copyup on every access of a file. Supporting atime with the current
+infrastructure would require a copyup on every open(). The "relatime" option
+would be equally efficient if the atime is the same or more recent than the
+mtime/ctime for every object on the read-only file system, and if the 24-hour
+timeout on relatime was disabled. However, this is probably not worthwhile for
+the majority of union mount use cases.
+
+File systems can only be union mounted at their root directories, for
+simplicity and performance.
+
+pivot_root() to a union mounted file system is supported. The recommended way
+to get to a union mounted root file system is to boot with the read-only mount
+as the root file system, construct the union mount on an entirely new mount,
+and pivot_root() to the new union mount root. Attempting to union mount the
+root file system later in boot will result in covering other file systems,
+e.g., /proc, which isn't permitted in the current code and is a bad idea
+anyway.
+
+Hard read-only file systems
+---------------------------
+
+Union mounts require the lower layer of the file system to be read-only.
+However, in Linux, any individual file system may be mounted at multiple places
+in the namespace, and a file system can be changed from read-only to read-write
+while still mounted. Thus, simply checking that the bottom layer is read-only
+at the time the writable overlay is mounted over it is pointless, since at any
+time the bottom layer may become read-write.
+
+We have to guarantee that a file system will be read-only for as long as it is
+the bottom layer of a union mount. To do this, we track the number of hard
+read-only users of a file system in its VFS superblock structure. When we
+union mount a writable overlay over a file system, we increment its read-only
+user count. The file system can only be mounted read-write if its read-only
+users count is zero.
+
+Todo:
+
+- Support hard read-only NFS mounts. See discussion here:
+
+ http://markmail.org/message/3mkgnvo4pswxd7lp
+
+Pathname lookup
+---------------
+
+Pathname lookup in a unioned directory traverses down the union stack for the
+parent directory, looking up each pathname element in each layer of the file
+system (according to the rules of whiteouts, fallthrus, and opaque flags). At
+mount time, the union stack for the root directory of the file system is
+created, and the union stack creation for every other unioned directory in the
+file system is boot-strapped using the already-existing union stack of the
+directory's parent. In order to simplify the code greatly, every visible
+directory on the lower file system is required to have a matching directory on
+the upper file system. If this matching directory does not already exist, it
+is created during pathname lookup. Therefore, each unioned directory is the
+child of another unioned directory (or is the root directory of the file
+system).
+
+The actual union lookup function is called in the following code paths:
+
+do_lookup()->do_union_lookup()->lookup_union()->__lookup_union()
+lookup_hash()->lookup_union()->__lookup_union()
+
+__lookup_union() is where the rules of whiteouts, fallthrus, and opaque flags
+are actually implemented. __lookup_union() returns either the first visible
+dentry, or a negative dentry from the topmost file system if no matching dentry
+exists. If it finds a directory, it looks up any potential matching lower
+layer directories. If it finds a lower layer directory, it first creates the
+topmost dir if necessary via union_create_topmost_dir(), and then calls
+union_add_dir() to append the lower directory to the end of the union stack.
+
+Note that not all directories in a union mount are unioned, only those with
+matching directories on the lower layer. The macro IS_DIR_UNIONED() is a
+cheap, constant time way to check if a directory is unioned, while
+IS_MNT_UNION() checks if the entire mount is unioned (and therefore whether the
+directory in question is potentially unioned).
+
+Currently, lookup of a negative dentry or a directory with no matching
+directories below it requires a lookup in every directory in the union stack
+every time it is looked up. We could avoid subsequent lookups by adding the
+equivalent of a negative dcache entry.
+
+File copyup
+-----------
+
+Any system call that alters the data or metadata of a file on the bottom layer,
+or creates or changes a hard link to it will trigger a copyup of the target
+file from the lower layer to the topmost layer
+
+ - open(O_WRITE | O_RDWR | O_APPEND)
+ - truncate()/open(O_TRUNC)
+ - link()
+ - rename()
+ - chmod()
+ - chown()/lchown()
+ - utimes()
+ - setxattr()/lsetxattr()
+
+Copyup of a file due to open(O_WRITE) has already occurred when:
+
+ - write()
+ - ftruncate()
+ - writable mmap()
+
+The following system calls will fail on an fd opened O_RDONLY:
+
+ - fchmod()
+ - fchown()
+ - fsetxattr()
+ - futimensat()
+
+Contrary to common sense, the above system calls are defined to succeed on
+O_RDONLY fds. The idea seems to be that the O_RDONLY/O_RDWR/O_WRITE flags only
+apply to the actual file data, not to any form of metadata (times, owner, mode,
+or even extended attributes). Applications making these system calls on
+O_RDONLY fds are correct according to the standard and work on non-union
+mounts. They will need to be rewritten (O_RDONLY -> O_RDWR) to work on union
+mounts. We suspect this usage is uncommon.
+
+This deviation from standard is due to technical limitations of the union mount
+implementation. Specifically, we would need to replace an open file descriptor
+from the lower layer with an open file descriptor for a file with matching
+pathname and contents on the upper layer, which is difficult to do. We avoid
+this in other system calls by doing the copyup before the file is opened.
+Unionfs doesn't encounter this problem because it creates a dummy file struct
+which redirects or fans out operations to the struct files for the underlying
+file systems.
+
+From an application's point of view, the result of an in-kernel file copyup is
+the logical equivalent of another application updating the file via the
+rename() pattern: creat() a new file, copy the data over, make changes the
+copy, and rename() over the old version. Any existing open file descriptors
+for that file (including those in the same application) refer to a now
+invisible object that used to have the same pathname. Only opens that occur
+after the copyup will see updates to the file.
+
+Permission checks
+-----------------
+
+We want to be sure we have the correct permissions to actually succeed in a
+system call before copying a file up to avoid unnecessary IO. At present, the
+permission check for a single system call may be spread out over many hundreds
+of lines of code (e.g., open()). In order to check permissions, we
+occasionally need to determine if there is a writable overlay on top of this
+inode. This requires a full path, but often we only have the inode at this
+point. In particular, inode_permission() returns EROFS if the inode is on a
+read-only file system, which is the wrong answer if there is a writable overlay
+mounted on top of it.
+
+The current solution is to split out the file-system-wide permission checks
+from the per-inode permission checks. inode_permission() becomes:
+
+sb_permission()
+__inode_permission()
+
+inode_permission() calls sb_permission() and __inode_permission() on the same
+path. We create path_permission() which calls sb_permission() on the parent
+directory from the top layer, and __inode_permission() on the target on the
+lower layer. This gets us the correct write permissions consdering that the
+file will be copied up.
+
+Todo:
+
+ - Currently, we don't deal with differing directory permissions at
+ different levels of the stack. This is a bug.
+
+Impact on non-union kernels and mounts
+--------------------------------------
+
+Union-related data structures, extra fields, and function calls are #ifdef'd
+out at the function/macro level with CONFIG_UNION_MOUNT in nearly all cases
+(see fs/union.h). When CONFIG_UNION_MOUNT is enabled, struct dentry has one
+more pointer, reducing the size of dentry names stored in the dentry itself by
+4 to 8 bytes.
+
+Todo:
+
+ - Do performance tests
+
+Locking strategy
+================
+
+The current union mount locking strategy is based on the following
+rules:
+
+* The lower layer file system is always read-only
+* The topmost file system is always read-write
+ => A file system can never a topmost and lower layer at the same time
+
+Additionally, the topmost layer may only be mounted exactly once. Don't think
+of the topmost layer as a separate independent file system; when it is part of
+a union mount, it is only a file system in conjunction with the read-only
+bottom layer. The read-only bottom layer is an independent file system in and
+of itself and can be mounted elsewhere, including as the bottom layer for
+another union mount.
+
+Thus, we may define a stable locking order in terms of top layer and bottom
+layer locks, since a top layer is never a bottom layer and a bottom layer is
+never a top layer. Another simplifying assumption is that all directories in a
+pathname exist on the top layer, as they are created step-by-step during
+lookup. This prevents us from ever having to walk backwards up the path
+creating directory entries, which can get complicated. By implication, parent
+directories paths during any operation (rename(), unlink(),etc.) are from the
+top layer. Dentries for directories from the bottom layer are only ever seen
+or used by the lookup code.
+
+The two major problems we avoid with the above rules are:
+
+Lock ordering: Imagine two union stacks with the same two file systems: A
+mounted over B, and B mounted over A. Sometimes locks on objects in both A and
+B will have to be held simultanously. What order should they be acquired in?
+Simply acquiring them from top to bottom will create a lock-ordering problem -
+one thread acquires lock on object from A and then tries for a lock on object
+from B, while another thread grabs the lock on object from B and then waits for
+the lock on object from A. Some other lock ordering must be defined.
+
+Movement/change/disappearance of objects on multiple layers: A variety of nasty
+corner cases arise when more than one layer is changing at the same time.
+Changes in the directory topology and their effect on inheritance are of
+special concern. Al Viro's canonical email on the subject:
+
+http://lkml.indiana.edu/hypermail/linux/kernel/0802.0/0839.html
+
+We don't try to solve any of these cases, just avoid them in the first place.
+
+Todo: Prevent top layer from being mounted more than once.
+
+Cross-layer interactions
+------------------------
+
+The VFS code simultaneously holds references to and/or modifies objects from
+both the top and bottom layers in the following cases:
+
+Path lookup:
+
+Grabs i_mutex on bottom layer while holding i_mutex on top layer directory
+inode.
+
+File copyup:
+
+Holds i_mutex on the parent directory from the top layer while copying up file
+from lower layer.
+
+link():
+
+File copyup of target while holding i_mutex on parent directory on top layer.
+Followed by a normal link() operation.
+
+rename():
+
+Holds s_vfs_rename_mutex on the top layer, i_mutex of the source's parent dir
+(top layer), and i_mutex of the target's parent dir (also top layer) while
+looking up and copying the bottom layer target and also creating the whiteout.
+
+Notes on rename():
+
+First, renaming of directories returns EXDEV. It's not at all reasonable to
+recursively copy directory trees and userspace has to handle this case anyway.
+An exception is rename() of directories that exist only on the topmost layer;
+this succeeds.
+
+Rename involves three steps on a union mount: (1) copyup of the file from the
+bottom layer, (2) rename of the new top-layer copy to the target in the usual
+manner, (3) creation of a whiteout covering the source of the rename.
+
+Directory copyup:
+
+Directory entries are copied up on the first readdir(). We hold the top layer
+directory i_mutex throughout and sequentially acquire and drop the i_mutex for
+each lower layer directory.
+
+VFS-fs interface
+================
+
+Read-only layer: No support necessary other than enforcement of really really
+read-only semantics (done by VFS for local file systems).
+
+Writable layer: Must implement two new inode operations:
+
+int (*whiteout) (struct inode *, struct dentry *, struct dentry *);
+int (*fallthru) (struct inode *, struct dentry *);
+
+And set the MS_WHITEOUT and MS_FALLTHRU flags to indicate support of
+these operations.
+
+Todo:
+
+- Implement whiteouts and fallthrus in ext3
+- Implement whiteouts and fallthrus in btrfs
+
+Supported file systems
+----------------------
+
+Any file system can be a read-only layer. File systems must explicitly support
+whiteouts and fallthrus in order to be a read-write layer. This patch set
+implements whiteouts for ext2, tmpfs, and jffs2. We have tested ext2, tmpfs,
+and iso9660 as the read-only layer.
+
+Todo:
+ - Test corner cases of case-insensitive/oversensitive file systems
+
+NFS interaction
+===============
+
+NFS is currently not supported as either type of layer. NFS as read-only layer
+requires support from the server to honor the read-only guarantee needed for
+the bottom layer. To do this, the server needs to revoke access to clients
+requesting read-only file systems if the exported file system is remounted
+read-write or unmounted (during which arbitrary changes can occur). Some
+recent discussion:
+
+http://markmail.org/message/3mkgnvo4pswxd7lp
+
+NFS as the read-write layer would require implementation of the ->whiteout()
+and ->fallthru() methods. DT_WHT directory entries are theoretically already
+supported.
+
+Also, technically the requirement for a readdir() cookie that is stable across
+reboots comes only from file systems exported via NFSv2:
+
+http://oss.oracle.com/pipermail/btrfs-devel/2008-January/000463.html
+
+Todo:
+
+- Guarantee really really read-only on NFS exports
+- Implement whiteout()/fallthru() for NFS
+
+Userland support
+================
+
+The mount command must support the "-o union" mount option and pass the
+corresponding MS_UNION flag to the kerel. A util-linux git tree with union
+mount support is here:
+
+git://git.kernel.org/pub/scm/utils/util-linux-ng/val/util-linux-ng.git
+
+File system utilities must support whiteouts and fallthrus. An e2fsprogs git
+tree with union mount support is here:
+
+git://git.kernel.org/pub/scm/fs/ext2/val/e2fsprogs.git
+
+Currently, whiteout directory entries are not returned to userland. While the
+directory type for whiteouts, DT_WHT, has been defined for many years, very
+little userland code handles them. Userland will never see fallthru directory
+entries.
+
+Known non-POSIX behaviors
+-------------------------
+
+- Any writing system call (unlink()/chmod()/etc.) can return ENOSPC or EIO
+
+ Most programs are not tested and don't work well under conditions of ENOSPC.
+ The solution is to add more disk space.
+
+- Link count may be wrong for files on bottom layer with > 1 link count
+
+ A file may have more than one hard link to it. When a file with multiple
+ hard links is copied up, any other hard links pointing to the same inode will
+ remain unchanged. If the file is looked up via one of the hard links on the
+ read-only layer, it will have the original link count (which is off by one at
+ this point). An example:
+
+ /bin/link1 -> inode 100
+ /etc/link2 -> inode 100
+
+ inode 100 will have link count 2.
+
+ # echo "blah" > /bin/link1
+
+ Now /bin/link1 will be copied up to the topmost layer. But /etc/link2 will
+ still point to the original inode 100, and its link count will still be 2.
+
+- Link count on directories will be wrong before readdir() (fixable)
+- File copyup is the logical equivalent of an update via copy +
+ rename(). Any existing open file descriptors will continue to refer
+ to the read-only copy on the bottom layer and will not see any
+ changes that occur after the copy-up.
+- rename() of directory may fail with EXDEV
+- fchmod()/fchown()/futimensat()/fsetattr() fail on O_RDONLY fds
+
+Status
+======
+
+The current union mounts implementation is feature-complete on local file
+systems and passes an extensive union mounts test suite, available in the union
+mounts Usermode Linux-based development kit:
+
+http://valerieaurora.org/union/union_mount_devkit.tar.gz
+
+The whiteout code has had some non-trivial level of review and testing, but
+much of the code has had no external review or testing outside the authors'
+machines.
+
+The latest version is available at:
+
+git://git.kernel.org/pub/scm/linux/kernel/git/val/linux-2.6.git
+
+Check the union mounts web page for the name of the latest branch:
+
+http://valerieaurora.org/union/
+
+Todo:
+
+- Run more tests (e.g., XFS test suite)
+- Get review from VFS maintainers
+
+Non-features
+------------
+
+Features we do not currently plan to support in union mounts:
+
+Online upgrade: E.g., installing software on a file system NFS exported to
+clients while the clients are still up and running. Allowing the read-only
+bottom layer of a union mount to change invalidates our locking strategy.
+
+Recursive copying of directories: E.g., implementing rename() across layers for
+directories. Doing an in-kernel copy of a single file is bad enough.
+Recursively copying a directory is a big no-no.
+
+Read-only top layer: The readdir() strategy fundamentally requires the ability
+to create persistent directory entries on the top layer file system (which may
+be tmpfs). However, you can union two read-only file systems by union mounting
+a third file system (such as tmpfs) over the two read-onlly file systems.
+Numerous alternatives to this readdir() strategy (including in-kernel or
+in-application caching) exist and are compatible with union mounts with its
+writing-readdir() implementation disabled. Creating a readdir() cookie that is
+stable across multiple readdir()s requires one of:
+
+- Write to stable storage (e.g., fallthru dentries)
+- Non-evictable kernel memory cache (doesn't handle NFS server reboot)
+- Per-application caching by glibc readdir()
+
+Often these features are supported by other unioning file systems or by other
+versions of union mounts.
+
+Contributing to union mounts
+============================
+
+The union mounts web page is here:
+
+http://valerieaurora.org/union/
+
+It links to:
+
+ - All git repositories
+ - Documentation
+ - An entire self-contained UML-based dev kit with README, etc.
+
+The best mailing list for discussing union mounts is:
+
+linux-fsdevel@vger.kernel.org
+
+http://vger.kernel.org/vger-lists.html#linux-fsdevel
+
+Thank you for reading!
^ permalink raw reply related [flat|nested] 79+ messages in thread* [PATCH 22/76] union-mount: Introduce MNT_UNION and MS_UNION flags
2011-06-17 16:00 [RFC][PATCH 00/76] Union Mount David Howells
` (20 preceding siblings ...)
2011-06-17 16:03 ` [PATCH 21/76] union-mount: Union mounts documentation David Howells
@ 2011-06-17 16:03 ` David Howells
2011-06-17 16:03 ` [PATCH 23/76] union-mount: Add CONFIG_UNION_MOUNT option David Howells
` (54 subsequent siblings)
76 siblings, 0 replies; 79+ messages in thread
From: David Howells @ 2011-06-17 16:03 UTC (permalink / raw)
To: linux-fsdevel; +Cc: hch
From: Jan Blunck <jblunck@suse.de>
Add per mountpoint flag for Union Mount support. You need additional patches
to util-linux for that to work - see:
git://git.kernel.org/pub/scm/utils/util-linux-ng/val/util-linux-ng.git
Signed-off-by: Jan Blunck <jblunck@suse.de>
Signed-off-by: Valerie Aurora <vaurora@redhat.com>
---
fs/namespace.c | 5 ++++-
include/linux/fs.h | 1 +
include/linux/mount.h | 1 +
3 files changed, 6 insertions(+), 1 deletions(-)
diff --git a/fs/namespace.c b/fs/namespace.c
index b1ffb3b..06819db 100644
--- a/fs/namespace.c
+++ b/fs/namespace.c
@@ -1015,6 +1015,7 @@ static void show_mnt_opts(struct seq_file *m, struct vfsmount *mnt)
{ MNT_NOATIME, ",noatime" },
{ MNT_NODIRATIME, ",nodiratime" },
{ MNT_RELATIME, ",relatime" },
+ { MNT_UNION, ",union" },
{ 0, NULL }
};
const struct proc_fs_info *fs_infop;
@@ -2377,10 +2378,12 @@ long do_mount(char *dev_name, char *dir_name, char *type_page,
mnt_flags &= ~(MNT_RELATIME | MNT_NOATIME);
if (flags & MS_RDONLY)
mnt_flags |= MNT_READONLY;
+ if (flags & MS_UNION)
+ mnt_flags |= MNT_UNION;
flags &= ~(MS_NOSUID | MS_NOEXEC | MS_NODEV | MS_ACTIVE | MS_BORN |
MS_NOATIME | MS_NODIRATIME | MS_RELATIME| MS_KERNMOUNT |
- MS_STRICTATIME);
+ MS_STRICTATIME | MS_UNION);
if (flags & MS_REMOUNT)
retval = do_remount(&path, flags & ~MS_REMOUNT, mnt_flags,
diff --git a/include/linux/fs.h b/include/linux/fs.h
index b21aed3..97ce78c 100644
--- a/include/linux/fs.h
+++ b/include/linux/fs.h
@@ -191,6 +191,7 @@ struct inodes_stat_t {
#define MS_REMOUNT 32 /* Alter flags of a mounted FS */
#define MS_MANDLOCK 64 /* Allow mandatory locks on an FS */
#define MS_DIRSYNC 128 /* Directory modifications are synchronous */
+#define MS_UNION 256 /* Merge namespace with FS mounted below */
#define MS_NOATIME 1024 /* Do not update access times. */
#define MS_NODIRATIME 2048 /* Do not update directory access times */
#define MS_BIND 4096
diff --git a/include/linux/mount.h b/include/linux/mount.h
index 7101157..3bd75e2 100644
--- a/include/linux/mount.h
+++ b/include/linux/mount.h
@@ -47,6 +47,7 @@ struct mnt_namespace;
#define MNT_INTERNAL 0x4000
#define MNT_HARD_READONLY 0x8000 /* has a hard read-only ref on the sb */
+#define MNT_UNION 0x10000 /* top layer of a union mount */
struct mnt_pcp {
int mnt_count;
^ permalink raw reply related [flat|nested] 79+ messages in thread* [PATCH 23/76] union-mount: Add CONFIG_UNION_MOUNT option
2011-06-17 16:00 [RFC][PATCH 00/76] Union Mount David Howells
` (21 preceding siblings ...)
2011-06-17 16:03 ` [PATCH 22/76] union-mount: Introduce MNT_UNION and MS_UNION flags David Howells
@ 2011-06-17 16:03 ` David Howells
2011-06-17 16:03 ` [PATCH 24/76] union-mount: Create union_stack structure David Howells
` (53 subsequent siblings)
76 siblings, 0 replies; 79+ messages in thread
From: David Howells @ 2011-06-17 16:03 UTC (permalink / raw)
To: linux-fsdevel; +Cc: hch
From: Valerie Aurora <vaurora@redhat.com>
Add CONFIG_UNION_MOUNT option.
---
fs/Kconfig | 12 ++++++++++++
1 files changed, 12 insertions(+), 0 deletions(-)
diff --git a/fs/Kconfig b/fs/Kconfig
index 19891aa..28518c3 100644
--- a/fs/Kconfig
+++ b/fs/Kconfig
@@ -61,6 +61,18 @@ source "fs/notify/Kconfig"
source "fs/quota/Kconfig"
+config UNION_MOUNT
+ bool "Union mounts (writable overlays) (EXPERIMENTAL)"
+ depends on EXPERIMENTAL
+ help
+ Union mounts allow you to mount a transparent writable layer over a
+ read-only file system, for example, an ext3 partition on a hard drive
+ over a CD-ROM root file system image.
+
+ See <file:Documentation/filesystems/union-mounts.txt> for details.
+
+ If unsure, say N.
+
source "fs/autofs4/Kconfig"
source "fs/fuse/Kconfig"
^ permalink raw reply related [flat|nested] 79+ messages in thread* [PATCH 24/76] union-mount: Create union_stack structure
2011-06-17 16:00 [RFC][PATCH 00/76] Union Mount David Howells
` (22 preceding siblings ...)
2011-06-17 16:03 ` [PATCH 23/76] union-mount: Add CONFIG_UNION_MOUNT option David Howells
@ 2011-06-17 16:03 ` David Howells
2011-06-17 16:03 ` [PATCH 25/76] union-mount: Add two superblock fields for union mounts David Howells
` (52 subsequent siblings)
76 siblings, 0 replies; 79+ messages in thread
From: David Howells @ 2011-06-17 16:03 UTC (permalink / raw)
To: linux-fsdevel; +Cc: hch
From: Valerie Aurora <vaurora@redhat.com>
struct union_stack records the stack of directories unioned at this
directory. A union_stack is an array of struct paths, dynamically
allocated when the dentry for the topmost directory is created. The
topmost dentry contains a pointer to the union_stack.
---
fs/dcache.c | 3 +++
fs/union.h | 54 ++++++++++++++++++++++++++++++++++++++++++++++++
include/linux/dcache.h | 25 +++++++++++++++++++++-
3 files changed, 81 insertions(+), 1 deletions(-)
create mode 100644 fs/union.h
diff --git a/fs/dcache.c b/fs/dcache.c
index 039a243..05b0a8b 100644
--- a/fs/dcache.c
+++ b/fs/dcache.c
@@ -1300,6 +1300,9 @@ struct dentry *d_alloc(struct dentry * parent, const struct qstr *name)
INIT_LIST_HEAD(&dentry->d_subdirs);
INIT_LIST_HEAD(&dentry->d_alias);
INIT_LIST_HEAD(&dentry->d_u.d_child);
+#ifdef CONFIG_UNION_MOUNT
+ dentry->d_union_stack = NULL;
+#endif
if (parent) {
spin_lock(&parent->d_lock);
diff --git a/fs/union.h b/fs/union.h
new file mode 100644
index 0000000..38b26fd
--- /dev/null
+++ b/fs/union.h
@@ -0,0 +1,54 @@
+ /*
+ * VFS-based union mounts for Linux
+ *
+ * Copyright (C) 2004-2007 IBM Corporation, IBM Deutschland Entwicklung GmbH.
+ * Copyright (C) 2007-2009 Novell Inc.
+ * Copyright (C) 2009-2010 Red Hat, Inc.
+ *
+ * Author(s): Jan Blunck (j.blunck@tu-harburg.de)
+ * Valerie Aurora <vaurora@redhat.com>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; version 2
+ * of the License.
+ */
+#ifndef __LINUX_UNION_H
+#define __LINUX_UNION_H
+#ifdef __KERNEL__
+
+#ifdef CONFIG_UNION_MOUNT
+
+/*
+ * WARNING! Confusing terminology alert.
+ *
+ * Note that the directions "up" and "down" in union mounts are the
+ * opposite of "up" and "down" in normal VFS operation terminology.
+ * "up" in the rest of the VFS means "towards the root of the mount
+ * tree." If you mount B on top of A, following B "up" will get you
+ * A. In union mounts, "up" means "towards the most recently mounted
+ * layer of the union stack." If you union mount B on top of A,
+ * following A "up" will get you to B. Another way to put it is that
+ * "up" in the VFS means going from this mount towards the direction
+ * of its mnt->mnt_parent pointer, but "up" in union mounts means
+ * going in the opposite direction (until you run out of union
+ * layers).
+ */
+
+/*
+ * The union_stack structure. It is an array of struct paths of
+ * directories below the topmost directory in a unioned directory, The
+ * topmost dentry has a pointer to this structure. The topmost dentry
+ * can only be part of one union, so we can reference it from the
+ * dentry, but lower dentries can be part of multiple union stacks.
+ *
+ * The number of dirs actually allocated is kept in the superblock,
+ * s_union_count.
+ */
+struct union_stack {
+ struct path u_dirs[0];
+};
+
+#endif /* CONFIG_UNION_MOUNT */
+#endif /* __KERNEL__ */
+#endif /* __LINUX_UNION_H */
diff --git a/include/linux/dcache.h b/include/linux/dcache.h
index 1c4ad1b..eb8fbf8 100644
--- a/include/linux/dcache.h
+++ b/include/linux/dcache.h
@@ -102,16 +102,36 @@ full_name_hash(const unsigned char *name, unsigned int len)
* Try to keep struct dentry aligned on 64 byte cachelines (this will
* give reasonable cacheline footprint with larger lines without the
* large memory footprint increase).
+ *
+ * XXX DNAME_INLINE_LEN_MIN is kind of pitiful on 64bit + union
+ * mounts. May be worth tuning up, but either we go to 256 bytes and
+ * a wasteful 88 bytes of d_iname, or we lose 64-byte aligment.
*/
#ifdef CONFIG_64BIT
+
+#ifdef CONFIG_UNION_MOUNT
+# define DNAME_INLINE_LEN 24 /* 192 bytes */
+#else
# define DNAME_INLINE_LEN 32 /* 192 bytes */
+#endif /* CONFIG_UNION_MOUNT */
+
+#else
+
+#ifdef CONFIG_UNION_MOUNT
+# ifdef CONFIG_SMP
+# define DNAME_INLINE_LEN 32 /* 128 bytes */
+# else
+# define DNAME_INLINE_LEN 36 /* 128 bytes */
+# endif
#else
# ifdef CONFIG_SMP
# define DNAME_INLINE_LEN 36 /* 128 bytes */
# else
# define DNAME_INLINE_LEN 40 /* 128 bytes */
# endif
-#endif
+#endif /* CONFIG_UNION_MOUNT */
+
+#endif /* CONFIG_64BIT */
struct dentry {
/* RCU lookup touched fields */
@@ -132,6 +152,9 @@ struct dentry {
unsigned long d_time; /* used by d_revalidate */
void *d_fsdata; /* fs-specific data */
+#ifdef CONFIG_UNION_MOUNT
+ struct union_stack *d_union_stack; /* dirs in union stack */
+#endif
struct list_head d_lru; /* LRU list */
/*
* d_child and d_rcu can share memory
^ permalink raw reply related [flat|nested] 79+ messages in thread* [PATCH 25/76] union-mount: Add two superblock fields for union mounts
2011-06-17 16:00 [RFC][PATCH 00/76] Union Mount David Howells
` (23 preceding siblings ...)
2011-06-17 16:03 ` [PATCH 24/76] union-mount: Create union_stack structure David Howells
@ 2011-06-17 16:03 ` David Howells
2011-06-17 16:04 ` [PATCH 26/76] union-mount: Add union_alloc() David Howells
` (51 subsequent siblings)
76 siblings, 0 replies; 79+ messages in thread
From: David Howells @ 2011-06-17 16:03 UTC (permalink / raw)
To: linux-fsdevel; +Cc: hch
From: Valerie Aurora <vaurora@redhat.com>
Add two fields to struct super_block to support union mounts.
s_union_lower_mnts is a pointer to a cloned vfsmount tree of all the
lower (read-only) mounts unioned with the topmost (read-write)
vfsmount. These mounts may have submounts which will also be unioned;
hence we copy the entire vfsmount tree, not just the root vfsmounts.
s_union_count is the number of lower mounts unioned at the root of the
file system. This count is the maximum number of directories that
will ever be unioned with a single directory. We use it to allocate a
union stack of the correct size for each directory.
---
include/linux/fs.h | 12 ++++++++++++
1 files changed, 12 insertions(+), 0 deletions(-)
diff --git a/include/linux/fs.h b/include/linux/fs.h
index 97ce78c..918946f 100644
--- a/include/linux/fs.h
+++ b/include/linux/fs.h
@@ -1451,6 +1451,18 @@ struct super_block {
* free_vfsmnt() if MNT_HARD_READONLY is set.
*/
int s_hard_readonly_users;
+
+ /*
+ * Root of the private cloned vfsmount tree of the read-only
+ * mounts in this union (set in topmost vfsmount only)
+ */
+ struct vfsmount *s_union_lower_mnts;
+
+ /*
+ * Number of layers in this union, not counting the topmost or
+ * submounts.
+ */
+ unsigned int s_union_count;
};
extern struct timespec current_fs_time(struct super_block *sb);
^ permalink raw reply related [flat|nested] 79+ messages in thread* [PATCH 26/76] union-mount: Add union_alloc()
2011-06-17 16:00 [RFC][PATCH 00/76] Union Mount David Howells
` (24 preceding siblings ...)
2011-06-17 16:03 ` [PATCH 25/76] union-mount: Add two superblock fields for union mounts David Howells
@ 2011-06-17 16:04 ` David Howells
2011-06-17 16:04 ` [PATCH 27/76] union-mount: Add union_find_dir() David Howells
` (50 subsequent siblings)
76 siblings, 0 replies; 79+ messages in thread
From: David Howells @ 2011-06-17 16:04 UTC (permalink / raw)
To: linux-fsdevel; +Cc: hch
From: Valerie Aurora <vaurora@redhat.com>
union_alloc() allocates a union stack with enough entries for the
maximum possible number of directories that might be unioned at this
point.
The union_stack may be larger than strictly necessary if this
directory does not exist on all layers, but allocating exactly the
right number would require keeping the number of layers in the
union_stack structure. We optimize for the case of unioning two file
systems and keep the count of layers in the superblock.
---
fs/Makefile | 1 +
fs/union.c | 38 ++++++++++++++++++++++++++++++++++++++
2 files changed, 39 insertions(+), 0 deletions(-)
create mode 100644 fs/union.c
diff --git a/fs/Makefile b/fs/Makefile
index fb68c2b..db5e9dc 100644
--- a/fs/Makefile
+++ b/fs/Makefile
@@ -51,6 +51,7 @@ obj-$(CONFIG_GENERIC_ACL) += generic_acl.o
obj-$(CONFIG_FHANDLE) += fhandle.o
obj-y += quota/
+obj-$(CONFIG_UNION_MOUNT) += union.o
obj-$(CONFIG_PROC_FS) += proc/
obj-y += partitions/
diff --git a/fs/union.c b/fs/union.c
new file mode 100644
index 0000000..c8d7766
--- /dev/null
+++ b/fs/union.c
@@ -0,0 +1,38 @@
+/*
+ * VFS-based union mounts for Linux
+ *
+ * Copyright (C) 2004-2007 IBM Corporation, IBM Deutschland Entwicklung GmbH.
+ * Copyright (C) 2007-2009 Novell Inc.
+ * Copyright (C) 2009-2010 Red Hat, Inc.
+ *
+ * Author(s): Jan Blunck (j.blunck@tu-harburg.de)
+ * Valerie Aurora <vaurora@redhat.com>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; version 2
+ * of the License.
+ */
+
+#include <linux/module.h>
+#include <linux/fs.h>
+#include <linux/mount.h>
+#include <linux/fs_struct.h>
+#include <linux/slab.h>
+
+#include "union.h"
+
+/**
+ * union_alloc - allocate a union stack
+ * @path: path of topmost directory
+ *
+ * Allocate a union_stack large enough to contain the maximum number
+ * of layers in this union mount.
+ */
+static struct union_stack *union_alloc(struct path *topmost)
+{
+ unsigned int layers = topmost->dentry->d_sb->s_union_count;
+ BUG_ON(!S_ISDIR(topmost->dentry->d_inode->i_mode));
+
+ return kcalloc(sizeof(struct path), layers, GFP_KERNEL);
+}
^ permalink raw reply related [flat|nested] 79+ messages in thread* [PATCH 27/76] union-mount: Add union_find_dir()
2011-06-17 16:00 [RFC][PATCH 00/76] Union Mount David Howells
` (25 preceding siblings ...)
2011-06-17 16:04 ` [PATCH 26/76] union-mount: Add union_alloc() David Howells
@ 2011-06-17 16:04 ` David Howells
2011-06-17 16:04 ` [PATCH 28/76] union-mount: Create d_free_unions() David Howells
` (49 subsequent siblings)
76 siblings, 0 replies; 79+ messages in thread
From: David Howells @ 2011-06-17 16:04 UTC (permalink / raw)
To: linux-fsdevel; +Cc: hch
From: Valerie Aurora <vaurora@redhat.com>
union_find_dir() returns the path of the directory at the specified
layer in a unioned directory.
---
fs/union.h | 11 +++++++++++
1 files changed, 11 insertions(+), 0 deletions(-)
diff --git a/fs/union.h b/fs/union.h
index 38b26fd..bd9c2b0 100644
--- a/fs/union.h
+++ b/fs/union.h
@@ -49,6 +49,17 @@ struct union_stack {
struct path u_dirs[0];
};
+static inline
+struct path *union_find_dir(struct dentry *dentry, unsigned int layer)
+{
+ BUG_ON(layer >= dentry->d_sb->s_union_count);
+ return &dentry->d_union_stack->u_dirs[layer];
+}
+
+#else /* CONFIG_UNION_MOUNT */
+
+#define union_find_dir(x, y) ({ BUG(); (NULL); })
+
#endif /* CONFIG_UNION_MOUNT */
#endif /* __KERNEL__ */
#endif /* __LINUX_UNION_H */
^ permalink raw reply related [flat|nested] 79+ messages in thread* [PATCH 28/76] union-mount: Create d_free_unions()
2011-06-17 16:00 [RFC][PATCH 00/76] Union Mount David Howells
` (26 preceding siblings ...)
2011-06-17 16:04 ` [PATCH 27/76] union-mount: Add union_find_dir() David Howells
@ 2011-06-17 16:04 ` David Howells
2011-06-17 16:04 ` [PATCH 29/76] union-mount: Free union stack on removal of topmost dentry from dcache David Howells
` (48 subsequent siblings)
76 siblings, 0 replies; 79+ messages in thread
From: David Howells @ 2011-06-17 16:04 UTC (permalink / raw)
To: linux-fsdevel; +Cc: hch
From: Valerie Aurora <vaurora@redhat.com>
d_free_unions() frees the union stack associated with a directory.
---
fs/union.c | 24 ++++++++++++++++++++++++
fs/union.h | 7 +++++++
2 files changed, 31 insertions(+), 0 deletions(-)
diff --git a/fs/union.c b/fs/union.c
index c8d7766..77d6a74 100644
--- a/fs/union.c
+++ b/fs/union.c
@@ -19,6 +19,7 @@
#include <linux/mount.h>
#include <linux/fs_struct.h>
#include <linux/slab.h>
+#include <linux/namei.h>
#include "union.h"
@@ -36,3 +37,26 @@ static struct union_stack *union_alloc(struct path *topmost)
return kcalloc(sizeof(struct path), layers, GFP_KERNEL);
}
+
+/**
+ * d_free_unions - free all unions for this dentry
+ * @dentry: topmost dentry in the union stack to remove
+ *
+ * This must be called when freeing a dentry.
+ */
+void d_free_unions(struct dentry *topmost)
+{
+ struct path *path;
+ unsigned int i, layers = topmost->d_sb->s_union_count;
+
+ if (!IS_DIR_UNIONED(topmost))
+ return;
+
+ for (i = 0; i < layers; i++) {
+ path = union_find_dir(topmost, i);
+ if (path->mnt)
+ path_put(path);
+ }
+ kfree(topmost->d_union_stack);
+ topmost->d_union_stack = NULL;
+}
diff --git a/fs/union.h b/fs/union.h
index bd9c2b0..5b79131 100644
--- a/fs/union.h
+++ b/fs/union.h
@@ -49,6 +49,10 @@ struct union_stack {
struct path u_dirs[0];
};
+#define IS_DIR_UNIONED(dentry) ((dentry)->d_union_stack)
+
+extern void d_free_unions(struct dentry *);
+
static inline
struct path *union_find_dir(struct dentry *dentry, unsigned int layer)
{
@@ -58,6 +62,9 @@ struct path *union_find_dir(struct dentry *dentry, unsigned int layer)
#else /* CONFIG_UNION_MOUNT */
+#define IS_DIR_UNIONED(x) (0)
+
+#define d_free_unions(x) do { } while (0)
#define union_find_dir(x, y) ({ BUG(); (NULL); })
#endif /* CONFIG_UNION_MOUNT */
^ permalink raw reply related [flat|nested] 79+ messages in thread* [PATCH 29/76] union-mount: Free union stack on removal of topmost dentry from dcache
2011-06-17 16:00 [RFC][PATCH 00/76] Union Mount David Howells
` (27 preceding siblings ...)
2011-06-17 16:04 ` [PATCH 28/76] union-mount: Create d_free_unions() David Howells
@ 2011-06-17 16:04 ` David Howells
2011-06-17 16:04 ` [PATCH 30/76] union-mount: Create union_add_dir() David Howells
` (47 subsequent siblings)
76 siblings, 0 replies; 79+ messages in thread
From: David Howells @ 2011-06-17 16:04 UTC (permalink / raw)
To: linux-fsdevel; +Cc: hch
From: Jan Blunck <jblunck@suse.de>
If a dentry is removed from dentry cache because its usage count drops
to zero, its union stack is freed too.
---
fs/dcache.c | 11 +++++++++++
fs/namespace.c | 2 ++
2 files changed, 13 insertions(+), 0 deletions(-)
diff --git a/fs/dcache.c b/fs/dcache.c
index 05b0a8b..4848d8b 100644
--- a/fs/dcache.c
+++ b/fs/dcache.c
@@ -37,6 +37,7 @@
#include <linux/rculist_bl.h>
#include <linux/prefetch.h>
#include "internal.h"
+#include "union.h"
/*
* Usage:
@@ -293,6 +294,7 @@ static struct dentry *d_kill(struct dentry *dentry, struct dentry *parent)
if (parent)
spin_unlock(&parent->d_lock);
dentry_iput(dentry);
+ d_free_unions(dentry);
/*
* dentry_iput drops the locks, at which point nobody (except
* transient RCU lookups) can reach this dentry.
@@ -949,6 +951,7 @@ static void shrink_dcache_for_umount_subtree(struct dentry *dentry)
iput(inode);
}
+ d_free_unions(dentry);
d_free(dentry);
/* finished when we fall off the top of the tree,
@@ -2059,6 +2062,7 @@ again:
}
dentry->d_flags &= ~DCACHE_CANT_MOUNT;
dentry_unlink_inode(dentry);
+ d_free_unions(dentry);
fsnotify_nameremove(dentry, isdir);
return;
}
@@ -2068,6 +2072,13 @@ again:
spin_unlock(&dentry->d_lock);
+ /*
+ * Remove any associated unions. While someone still has this
+ * directory open (ref count > 0), we could not have deleted
+ * it unless it was empty, and therefore has no references to
+ * directories below it. So we don't need the unions.
+ */
+ d_free_unions(dentry);
fsnotify_nameremove(dentry, isdir);
}
EXPORT_SYMBOL(d_delete);
diff --git a/fs/namespace.c b/fs/namespace.c
index 06819db..dbb32f4 100644
--- a/fs/namespace.c
+++ b/fs/namespace.c
@@ -35,6 +35,7 @@
#include <asm/unistd.h>
#include "pnode.h"
#include "internal.h"
+#include "union.h"
#define HASH_SHIFT ilog2(PAGE_SIZE / sizeof(struct list_head))
#define HASH_SIZE (1UL << HASH_SHIFT)
@@ -1284,6 +1285,7 @@ void umount_tree(struct vfsmount *mnt, int propagate, struct list_head *kill)
propagate_umount(&tmp_list);
list_for_each_entry(p, &tmp_list, mnt_hash) {
+ d_free_unions(p->mnt_root);
list_del_init(&p->mnt_expire);
list_del_init(&p->mnt_list);
__touch_mnt_namespace(p->mnt_ns);
^ permalink raw reply related [flat|nested] 79+ messages in thread* [PATCH 30/76] union-mount: Create union_add_dir()
2011-06-17 16:00 [RFC][PATCH 00/76] Union Mount David Howells
` (28 preceding siblings ...)
2011-06-17 16:04 ` [PATCH 29/76] union-mount: Free union stack on removal of topmost dentry from dcache David Howells
@ 2011-06-17 16:04 ` David Howells
2011-06-17 16:04 ` [PATCH 31/76] union-mount: Add union_create_topmost_dir() David Howells
` (46 subsequent siblings)
76 siblings, 0 replies; 79+ messages in thread
From: David Howells @ 2011-06-17 16:04 UTC (permalink / raw)
To: linux-fsdevel; +Cc: hch
From: Valerie Aurora <vaurora@redhat.com>
union_add_dir() fills out the union stack for the topmost dentry with
the path of the directory in this layer of the union.
---
fs/union.c | 27 +++++++++++++++++++++++++++
fs/union.h | 2 ++
2 files changed, 29 insertions(+), 0 deletions(-)
diff --git a/fs/union.c b/fs/union.c
index 77d6a74..ee4613b 100644
--- a/fs/union.c
+++ b/fs/union.c
@@ -60,3 +60,30 @@ void d_free_unions(struct dentry *topmost)
kfree(topmost->d_union_stack);
topmost->d_union_stack = NULL;
}
+
+/**
+ * union_add_dir - Add another layer to a unioned directory
+ * @topmost: topmost directory
+ * @lower: directory in the current layer
+ * @layer: index of layer to add this at
+ *
+ * @layer counts starting at 0 for the dir below the topmost dir. Must take a
+ * reference to @lower (call path_get()) before calling this function.
+ */
+int union_add_dir(struct path *topmost, struct path *lower,
+ unsigned int layer)
+{
+ struct dentry *dentry = topmost->dentry;
+ struct path *path;
+
+ BUG_ON(layer >= dentry->d_sb->s_union_count);
+
+ if (!dentry->d_union_stack)
+ dentry->d_union_stack = union_alloc(topmost);
+ if (!dentry->d_union_stack)
+ return -ENOMEM;
+
+ path = union_find_dir(dentry, layer);
+ *path = *lower;
+ return 0;
+}
diff --git a/fs/union.h b/fs/union.h
index 5b79131..51a851b 100644
--- a/fs/union.h
+++ b/fs/union.h
@@ -52,6 +52,7 @@ struct union_stack {
#define IS_DIR_UNIONED(dentry) ((dentry)->d_union_stack)
extern void d_free_unions(struct dentry *);
+extern int union_add_dir(struct path *, struct path *, unsigned int);
static inline
struct path *union_find_dir(struct dentry *dentry, unsigned int layer)
@@ -65,6 +66,7 @@ struct path *union_find_dir(struct dentry *dentry, unsigned int layer)
#define IS_DIR_UNIONED(x) (0)
#define d_free_unions(x) do { } while (0)
+#define union_add_dir(x, y, z) ({ BUG(); (0); })
#define union_find_dir(x, y) ({ BUG(); (NULL); })
#endif /* CONFIG_UNION_MOUNT */
^ permalink raw reply related [flat|nested] 79+ messages in thread* [PATCH 31/76] union-mount: Add union_create_topmost_dir()
2011-06-17 16:00 [RFC][PATCH 00/76] Union Mount David Howells
` (29 preceding siblings ...)
2011-06-17 16:04 ` [PATCH 30/76] union-mount: Create union_add_dir() David Howells
@ 2011-06-17 16:04 ` David Howells
2011-06-17 16:04 ` [PATCH 32/76] union-mount: Create IS_MNT_UNION() David Howells
` (45 subsequent siblings)
76 siblings, 0 replies; 79+ messages in thread
From: David Howells @ 2011-06-17 16:04 UTC (permalink / raw)
To: linux-fsdevel; +Cc: hch
From: Valerie Aurora <vaurora@redhat.com>
Union mounts design requires that the topmost directory exist for
every single directory at the time lookup completes. This is so that
we don't have to double back and create a whole path's worth of
directories whenever we copy up a file in a directory for the first
time. This greatly simplifies locking and error handling.
---
fs/union.c | 114 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
fs/union.h | 3 ++
2 files changed, 117 insertions(+), 0 deletions(-)
diff --git a/fs/union.c b/fs/union.c
index ee4613b..e0b1678 100644
--- a/fs/union.c
+++ b/fs/union.c
@@ -20,6 +20,8 @@
#include <linux/fs_struct.h>
#include <linux/slab.h>
#include <linux/namei.h>
+#include <linux/fsnotify.h>
+#include <linux/xattr.h>
#include "union.h"
@@ -87,3 +89,115 @@ int union_add_dir(struct path *topmost, struct path *lower,
*path = *lower;
return 0;
}
+
+/**
+ * union_copyup_xattr
+ * @old: dentry of original file
+ * @new: dentry of new copy
+ *
+ * Copy up extended attributes from the original file to the new one.
+ *
+ * XXX - Permissions? For now, copying up every xattr.
+ */
+static int union_copyup_xattr(struct dentry *old, struct dentry *new)
+{
+ ssize_t list_size, size;
+ char *buf, *name, *value;
+ int error;
+
+ /* Check for xattr support */
+ if (!old->d_inode->i_op->getxattr ||
+ !new->d_inode->i_op->getxattr)
+ return 0;
+
+ /* Find out how big the list of xattrs is */
+ list_size = vfs_listxattr(old, NULL, 0);
+ if (list_size <= 0)
+ return list_size;
+
+ /* Allocate memory for the list */
+ buf = kzalloc(list_size, GFP_KERNEL);
+ if (!buf)
+ return -ENOMEM;
+
+ /* Allocate memory for the xattr's value */
+ error = -ENOMEM;
+ value = kmalloc(XATTR_SIZE_MAX, GFP_KERNEL);
+ if (!value)
+ goto out;
+
+ /* Actually get the list of xattrs */
+ list_size = vfs_listxattr(old, buf, list_size);
+ if (list_size <= 0) {
+ error = list_size;
+ goto out_free_value;
+ }
+
+ for (name = buf; name < (buf + list_size); name += strlen(name) + 1) {
+ /* XXX Locking? old is on read-only fs */
+ size = vfs_getxattr(old, name, value, XATTR_SIZE_MAX);
+ if (size <= 0) {
+ error = size;
+ goto out_free_value;
+ }
+ /* XXX do we really need to check for size overflow? */
+ /* XXX locks new dentry, lock ordering problems? */
+ error = vfs_setxattr(new, name, value, size, 0);
+ if (error)
+ goto out_free_value;
+ }
+
+out_free_value:
+ kfree(value);
+out:
+ kfree(buf);
+ return error;
+}
+
+/**
+ * union_create_topmost_dir - Create a matching dir in the topmost file system
+ * @parent - parent of target on topmost layer
+ * @name - name of target
+ * @topmost - path of target on topmost layer
+ * @lower - path of source on lower layer
+ *
+ * As we lookup each directory on the lower layer of a union, we create a
+ * matching directory on the topmost layer if it does not already exist.
+ *
+ * We don't use vfs_mkdir() for a few reasons: don't want to do the security
+ * check, don't want to make the dir opaque, don't need to sanitize the mode.
+ *
+ * XXX - owner is wrong, set credentials properly
+ * XXX - rmdir() directory on failure of xattr copyup
+ * XXX - not atomic w/ respect to crash
+ */
+int union_create_topmost_dir(struct path *parent, struct qstr *name,
+ struct path *topmost, struct path *lower)
+{
+ struct inode *dir = parent->dentry->d_inode;
+ int mode = lower->dentry->d_inode->i_mode;
+ int error;
+
+ BUG_ON(topmost->dentry->d_inode);
+
+ /* XXX - Do we even need to check this? */
+ if (!dir->i_op->mkdir)
+ return -EPERM;
+
+ error = mnt_want_write(parent->mnt);
+ if (error)
+ return error;
+
+ error = dir->i_op->mkdir(dir, topmost->dentry, mode);
+ if (error)
+ goto out;
+
+ error = union_copyup_xattr(lower->dentry, topmost->dentry);
+ if (error)
+ dput(topmost->dentry);
+
+ fsnotify_mkdir(dir, topmost->dentry);
+out:
+ mnt_drop_write(parent->mnt);
+ return error;
+}
diff --git a/fs/union.h b/fs/union.h
index 51a851b..db7c70c 100644
--- a/fs/union.h
+++ b/fs/union.h
@@ -53,6 +53,8 @@ struct union_stack {
extern void d_free_unions(struct dentry *);
extern int union_add_dir(struct path *, struct path *, unsigned int);
+extern int union_create_topmost_dir(struct path *, struct qstr *, struct path *,
+ struct path *);
static inline
struct path *union_find_dir(struct dentry *dentry, unsigned int layer)
@@ -68,6 +70,7 @@ struct path *union_find_dir(struct dentry *dentry, unsigned int layer)
#define d_free_unions(x) do { } while (0)
#define union_add_dir(x, y, z) ({ BUG(); (0); })
#define union_find_dir(x, y) ({ BUG(); (NULL); })
+#define union_create_topmost_dir(w, x, y, z) ({ BUG(); (0); })
#endif /* CONFIG_UNION_MOUNT */
#endif /* __KERNEL__ */
^ permalink raw reply related [flat|nested] 79+ messages in thread* [PATCH 32/76] union-mount: Create IS_MNT_UNION()
2011-06-17 16:00 [RFC][PATCH 00/76] Union Mount David Howells
` (30 preceding siblings ...)
2011-06-17 16:04 ` [PATCH 31/76] union-mount: Add union_create_topmost_dir() David Howells
@ 2011-06-17 16:04 ` David Howells
2011-06-17 16:05 ` [PATCH 33/76] union-mount: Create needs_lookup_union() David Howells
` (44 subsequent siblings)
76 siblings, 0 replies; 79+ messages in thread
From: David Howells @ 2011-06-17 16:04 UTC (permalink / raw)
To: linux-fsdevel; +Cc: hch
From: Jan Blunck <jblunck@suse.de>
IS_MNT_UNION() tests whether a vfsmount is a union. Note that a
directory in a union mounted file system is not necessarily unioned.
Use IS_DIR_UNIONED() to test that.
---
fs/union.h | 2 ++
1 files changed, 2 insertions(+), 0 deletions(-)
diff --git a/fs/union.h b/fs/union.h
index db7c70c..89527b7 100644
--- a/fs/union.h
+++ b/fs/union.h
@@ -49,6 +49,7 @@ struct union_stack {
struct path u_dirs[0];
};
+#define IS_MNT_UNION(mnt) ((mnt)->mnt_flags & MNT_UNION)
#define IS_DIR_UNIONED(dentry) ((dentry)->d_union_stack)
extern void d_free_unions(struct dentry *);
@@ -65,6 +66,7 @@ struct path *union_find_dir(struct dentry *dentry, unsigned int layer)
#else /* CONFIG_UNION_MOUNT */
+#define IS_MNT_UNION(x) (0)
#define IS_DIR_UNIONED(x) (0)
#define d_free_unions(x) do { } while (0)
^ permalink raw reply related [flat|nested] 79+ messages in thread* [PATCH 33/76] union-mount: Create needs_lookup_union()
2011-06-17 16:00 [RFC][PATCH 00/76] Union Mount David Howells
` (31 preceding siblings ...)
2011-06-17 16:04 ` [PATCH 32/76] union-mount: Create IS_MNT_UNION() David Howells
@ 2011-06-17 16:05 ` David Howells
2011-06-17 16:05 ` [PATCH 34/76] union-mount: Create check_topmost_union_mnt() David Howells
` (43 subsequent siblings)
76 siblings, 0 replies; 79+ messages in thread
From: David Howells @ 2011-06-17 16:05 UTC (permalink / raw)
To: linux-fsdevel; +Cc: hch
From: Valerie Aurora <vaurora@redhat.com>
needs_lookup_union() tests if a path could possibly require a union
lookup.
---
fs/union.h | 17 +++++++++++++++++
include/linux/dcache.h | 2 ++
2 files changed, 19 insertions(+), 0 deletions(-)
diff --git a/fs/union.h b/fs/union.h
index 89527b7..54427ba 100644
--- a/fs/union.h
+++ b/fs/union.h
@@ -64,6 +64,22 @@ struct path *union_find_dir(struct dentry *dentry, unsigned int layer)
return &dentry->d_union_stack->u_dirs[layer];
}
+static inline
+int needs_lookup_union(struct path *parent_path, struct path *path)
+{
+ if (!IS_DIR_UNIONED(parent_path->dentry))
+ return 0;
+
+ /* Either already built or crossed a mountpoint to not-unioned mnt */
+ /* XXX are bind mounts root? think not */
+ if (IS_ROOT(path->dentry))
+ return 0;
+
+ /* It's okay not to have the lock; will recheck in lookup_union() */
+ /* XXX set for root dentry at mount? */
+ return !(path->dentry->d_flags & DCACHE_UNION_LOOKUP_DONE);
+}
+
#else /* CONFIG_UNION_MOUNT */
#define IS_MNT_UNION(x) (0)
@@ -73,6 +89,7 @@ struct path *union_find_dir(struct dentry *dentry, unsigned int layer)
#define union_add_dir(x, y, z) ({ BUG(); (0); })
#define union_find_dir(x, y) ({ BUG(); (NULL); })
#define union_create_topmost_dir(w, x, y, z) ({ BUG(); (0); })
+#define needs_lookup_union(x, y) ({ (0); })
#endif /* CONFIG_UNION_MOUNT */
#endif /* __KERNEL__ */
diff --git a/include/linux/dcache.h b/include/linux/dcache.h
index eb8fbf8..f5442ec 100644
--- a/include/linux/dcache.h
+++ b/include/linux/dcache.h
@@ -244,6 +244,8 @@ struct dentry_operations {
#define DCACHE_MANAGED_DENTRY \
(DCACHE_MOUNTED|DCACHE_NEED_AUTOMOUNT|DCACHE_MANAGE_TRANSIT)
+#define DCACHE_UNION_LOOKUP_DONE 0x080000 /* Union lookup was called on this dentry */
+
extern seqlock_t rename_lock;
static inline int dname_external(struct dentry *dentry)
^ permalink raw reply related [flat|nested] 79+ messages in thread* [PATCH 34/76] union-mount: Create check_topmost_union_mnt()
2011-06-17 16:00 [RFC][PATCH 00/76] Union Mount David Howells
` (32 preceding siblings ...)
2011-06-17 16:05 ` [PATCH 33/76] union-mount: Create needs_lookup_union() David Howells
@ 2011-06-17 16:05 ` David Howells
2011-06-17 16:05 ` [PATCH 35/76] union-mount: Add clone_union_tree() and put_union_sb() David Howells
` (42 subsequent siblings)
76 siblings, 0 replies; 79+ messages in thread
From: David Howells @ 2011-06-17 16:05 UTC (permalink / raw)
To: linux-fsdevel; +Cc: hch
From: Valerie Aurora <vaurora@redhat.com>
check_topmost_union_mnt() checks that the topmost layer of a proposed
union mount is read-write, supports fallthrus and whiteouts, and isn't
mounted elsewhere.
---
fs/namespace.c | 40 ++++++++++++++++++++++++++++++++++++++++
1 files changed, 40 insertions(+), 0 deletions(-)
diff --git a/fs/namespace.c b/fs/namespace.c
index dbb32f4..7a237f62 100644
--- a/fs/namespace.c
+++ b/fs/namespace.c
@@ -1582,6 +1582,46 @@ static int invent_group_ids(struct vfsmount *mnt, bool recurse)
return 0;
}
+/**
+ * check_topmost_union_mnt - mount-time checks for union mount
+ * @topmost_mnt: vfsmount of the topmost union filed system
+ * @mnt_flags: mount flags for the topmost mount
+ *
+ * Our readdir() solution of copying up directory entries requires
+ * that the topmost layer be writeable and support whiteouts and
+ * fallthrus. The topmost file system can't be mounted elsewhere
+ * because it's Too Hard(tm).
+ */
+static int check_topmost_union_mnt(struct vfsmount *topmost_mnt, int mnt_flags)
+{
+ struct super_block *sb = topmost_mnt->mnt_sb;
+
+#ifndef CONFIG_UNION_MOUNT
+ printk(KERN_INFO "union mount: not supported by the kernel\n");
+ return -EINVAL;
+#else
+ if (mnt_flags & MNT_READONLY)
+ return -EROFS;
+
+ if (atomic_read(&sb->s_active) != 1) {
+ printk(KERN_INFO "union mount: topmost fs mounted elsewhere\n");
+ return -EBUSY;
+ }
+
+ if (!(sb->s_flags & MS_WHITEOUT)) {
+ printk(KERN_INFO "union mount: whiteouts not supported by fs\n");
+ return -EINVAL;
+ }
+
+ if (!(sb->s_flags & MS_FALLTHRU)) {
+ printk(KERN_INFO "union mount: fallthrus not supported by fs\n");
+ return -EINVAL;
+ }
+
+ return 0;
+#endif
+}
+
/*
* @source_mnt : mount tree to be attached
* @nd : place the mount tree @source_mnt is attached
^ permalink raw reply related [flat|nested] 79+ messages in thread* [PATCH 35/76] union-mount: Add clone_union_tree() and put_union_sb()
2011-06-17 16:00 [RFC][PATCH 00/76] Union Mount David Howells
` (33 preceding siblings ...)
2011-06-17 16:05 ` [PATCH 34/76] union-mount: Create check_topmost_union_mnt() David Howells
@ 2011-06-17 16:05 ` David Howells
2011-06-17 16:05 ` [PATCH 36/76] union-mount: Create build_root_union() David Howells
` (41 subsequent siblings)
76 siblings, 0 replies; 79+ messages in thread
From: David Howells @ 2011-06-17 16:05 UTC (permalink / raw)
To: linux-fsdevel; +Cc: hch
From: Valerie Aurora <vaurora@redhat.com>
A union mount clones the vfsmount tree of all of the read-only layers
of the union and keeps a reference to it in the vfsmount of the
topmost layer of the union.
clone_union_tree() takes the path of the proposed union mountpoint and
attempts to clones every vfsmount mounted at that same pathname, as
well as their submounts. All these mounts must be read-only, not
slave, and not shared.
put_union_sb() unwinds everything clone_union_tree() does. It is
called when the superblock is deactivated. Thus, you can lazy unmount
a union mount and when the last reference goes away, the union will be
torn down.
---
fs/namespace.c | 67 +++++++++++++++++++++++++++++++++++++++++++++++++
include/linux/mount.h | 2 +
2 files changed, 69 insertions(+), 0 deletions(-)
diff --git a/fs/namespace.c b/fs/namespace.c
index 7a237f62..ed8390f 100644
--- a/fs/namespace.c
+++ b/fs/namespace.c
@@ -1622,6 +1622,73 @@ static int check_topmost_union_mnt(struct vfsmount *topmost_mnt, int mnt_flags)
#endif
}
+void put_union_sb(struct super_block *sb)
+{
+ struct vfsmount *mnt = sb->s_union_lower_mnts;
+ LIST_HEAD(umount_list);
+
+ if (!mnt)
+ return;
+ br_write_lock(vfsmount_lock);
+ umount_tree(mnt, 0, &umount_list);
+ br_write_unlock(vfsmount_lock);
+ release_mounts(&umount_list);
+ sb->s_union_lower_mnts = 0;
+ sb->s_union_count = 0;
+}
+
+/**
+ * clone_union_tree - Clone all union-able mounts at this mountpoint
+ * @topmost: vfsmount of topmost layer
+ * @mntpnt: target of union mount
+ *
+ * Given the target mountpoint of a union mount, clone all the mounts at that
+ * mountpoint (well, pathname) that qualify as a union lower layer. Increment
+ * the hard readonly count of the lower layer superblocks.
+ *
+ * Returns error if any of the mounts or submounts mounted on or below this
+ * pathname are unsuitable for union mounting. This means you can't construct
+ * a union mount at the root of an existing mount without unioning it.
+ *
+ * XXX - Maybe should take # of layers to go down as an argument. But how to
+ * pass this in through mount options? All solutions look ugly. Currently you
+ * express your intention through mounting file systems on the same mountpoint,
+ * which is pretty elegant.
+ */
+static int clone_union_tree(struct vfsmount *topmost, struct path *mntpnt)
+{
+ struct vfsmount *mnt, *cloned_tree;
+
+ if (!IS_ROOT(mntpnt->dentry)) {
+ printk(KERN_INFO "union mount: mount point must be a root dir\n");
+ return -EINVAL;
+ }
+
+ /* Look for the "lowest" layer to union. */
+ mnt = mntpnt->mnt;
+ while (mnt->mnt_parent->mnt_root == mnt->mnt_mountpoint) {
+ /* Got root (mnt)? */
+ if (mnt->mnt_parent == mnt)
+ break;
+ mnt = mnt->mnt_parent;
+ }
+
+ /* Clone all the read-only mounts and submounts, only if they
+ * are not shared or slave, and increment the hard read-only
+ * users count on each one. If this can't be done for every
+ * mount and submount below this one, fail.
+ */
+ cloned_tree = copy_tree(mnt, mnt->mnt_root,
+ CL_COPY_ALL | CL_PRIVATE |
+ CL_NO_SHARED | CL_NO_SLAVE |
+ CL_MAKE_HARD_READONLY);
+ if (IS_ERR(cloned_tree))
+ return PTR_ERR(cloned_tree);
+
+ topmost->mnt_sb->s_union_lower_mnts = cloned_tree;
+ return 0;
+}
+
/*
* @source_mnt : mount tree to be attached
* @nd : place the mount tree @source_mnt is attached
diff --git a/include/linux/mount.h b/include/linux/mount.h
index 3bd75e2..7f4ef7e 100644
--- a/include/linux/mount.h
+++ b/include/linux/mount.h
@@ -115,4 +115,6 @@ extern void mark_mounts_for_expiry(struct list_head *mounts);
extern dev_t name_to_dev_t(char *name);
+extern void put_union_sb(struct super_block *sb);
+
#endif /* _LINUX_MOUNT_H */
^ permalink raw reply related [flat|nested] 79+ messages in thread* [PATCH 36/76] union-mount: Create build_root_union()
2011-06-17 16:00 [RFC][PATCH 00/76] Union Mount David Howells
` (34 preceding siblings ...)
2011-06-17 16:05 ` [PATCH 35/76] union-mount: Add clone_union_tree() and put_union_sb() David Howells
@ 2011-06-17 16:05 ` David Howells
2011-06-17 16:05 ` [PATCH 37/76] union-mount: Create prepare_mnt_union() and cleanup_mnt_union() David Howells
` (40 subsequent siblings)
76 siblings, 0 replies; 79+ messages in thread
From: David Howells @ 2011-06-17 16:05 UTC (permalink / raw)
To: linux-fsdevel; +Cc: hch
From: Valerie Aurora <vaurora@redhat.com>
During mount(), build_root_union() creates the union stack for the
root directory. All other directory union stacks are bootstrapped
from their parents' union stacks during path lookup.
---
fs/namespace.c | 46 ++++++++++++++++++++++++++++++++++++++++++++++
1 files changed, 46 insertions(+), 0 deletions(-)
diff --git a/fs/namespace.c b/fs/namespace.c
index ed8390f..9dbdd10 100644
--- a/fs/namespace.c
+++ b/fs/namespace.c
@@ -1689,6 +1689,52 @@ static int clone_union_tree(struct vfsmount *topmost, struct path *mntpnt)
return 0;
}
+/**
+ * build_root_union - Create the union stack for the root dir
+ * @topmost_mnt - vfsmount of topmost mount
+ *
+ * Build the union stack for the root dir. Annoyingly, we have to traverse
+ * union "up" from the root of the cloned tree to find the topmost read-only
+ * mount, and then traverse back "down" to build the stack.
+ */
+static int build_root_union(struct vfsmount *topmost_mnt)
+{
+ struct path lower, topmost_path;
+ struct vfsmount *mnt, *topmost_ro_mnt;
+ unsigned int i, layers = 1;
+ int err = 0;
+
+ /* Find the topmost read-only mount */
+ topmost_ro_mnt = topmost_mnt->mnt_sb->s_union_lower_mnts;
+ for (mnt = topmost_ro_mnt; mnt; mnt = next_mnt(mnt, topmost_ro_mnt)) {
+ if (mnt->mnt_parent == topmost_ro_mnt &&
+ mnt->mnt_mountpoint == topmost_ro_mnt->mnt_root) {
+ topmost_ro_mnt = mnt;
+ layers++;
+ }
+ }
+ topmost_mnt->mnt_sb->s_union_count = layers;
+
+ /* Build the root dir's union stack from the top down */
+ topmost_path.mnt = topmost_mnt;
+ topmost_path.dentry = topmost_mnt->mnt_root;
+ mnt = topmost_ro_mnt;
+ for (i = 0; i < layers; i++) {
+ lower.mnt = mntget(mnt);
+ lower.dentry = dget(mnt->mnt_root);
+ err = union_add_dir(&topmost_path, &lower, i);
+ if (err)
+ goto out;
+ mnt = mnt->mnt_parent;
+ }
+ return 0;
+
+out:
+ d_free_unions(topmost_path.dentry);
+ topmost_mnt->mnt_sb->s_union_count = 0;
+ return err;
+}
+
/*
* @source_mnt : mount tree to be attached
* @nd : place the mount tree @source_mnt is attached
^ permalink raw reply related [flat|nested] 79+ messages in thread* [PATCH 37/76] union-mount: Create prepare_mnt_union() and cleanup_mnt_union()
2011-06-17 16:00 [RFC][PATCH 00/76] Union Mount David Howells
` (35 preceding siblings ...)
2011-06-17 16:05 ` [PATCH 36/76] union-mount: Create build_root_union() David Howells
@ 2011-06-17 16:05 ` David Howells
2011-06-17 16:05 ` [PATCH 38/76] union-mount: Prevent improper union-related remounts David Howells
` (39 subsequent siblings)
76 siblings, 0 replies; 79+ messages in thread
From: David Howells @ 2011-06-17 16:05 UTC (permalink / raw)
To: linux-fsdevel; +Cc: hch
From: Valerie Aurora <vaurora@redhat.com>
prepare_mnt_union() ties together all the mount-time checks and setup
for union mounts. It tests the layers for suitability and builds the
root union stack.
cleanup_mnt_union() unwinds everything prepare_mnt_union() does.
---
fs/namespace.c | 40 ++++++++++++++++++++++++++++++++++++++++
1 files changed, 40 insertions(+), 0 deletions(-)
diff --git a/fs/namespace.c b/fs/namespace.c
index 9dbdd10..f34146b 100644
--- a/fs/namespace.c
+++ b/fs/namespace.c
@@ -1735,6 +1735,46 @@ out:
return err;
}
+/**
+ * prepare_mnt_union - do setup necessary for a union mount
+ * @topmost_mnt: vfsmount of topmost layer
+ * @mntpnt: path of requested mountpoint
+ *
+ * We union every underlying file system that is mounted on the same mountpoint
+ * (well, pathname), read-only, and not shared. If we get at least one layer,
+ * we don't return an error, although we will complain in the kernel log if we
+ * hit a mount that can't be unioned.
+ *
+ * Caller needs namespace_sem, but can't have vfsmount_lock.
+ */
+static int prepare_mnt_union(struct vfsmount *topmost_mnt, struct path *mntpnt)
+{
+ int err;
+
+ err = check_topmost_union_mnt(topmost_mnt, topmost_mnt->mnt_flags);
+ if (err)
+ return err;
+
+ err = clone_union_tree(topmost_mnt, mntpnt);
+ if (err)
+ return err;
+
+ err = build_root_union(topmost_mnt);
+ if (err)
+ goto out;
+ return 0;
+
+out:
+ put_union_sb(topmost_mnt->mnt_sb);
+ return err;
+}
+
+static void cleanup_mnt_union(struct vfsmount *topmost_mnt)
+{
+ d_free_unions(topmost_mnt->mnt_root);
+ put_union_sb(topmost_mnt->mnt_sb);
+}
+
/*
* @source_mnt : mount tree to be attached
* @nd : place the mount tree @source_mnt is attached
^ permalink raw reply related [flat|nested] 79+ messages in thread* [PATCH 38/76] union-mount: Prevent improper union-related remounts
2011-06-17 16:00 [RFC][PATCH 00/76] Union Mount David Howells
` (36 preceding siblings ...)
2011-06-17 16:05 ` [PATCH 37/76] union-mount: Create prepare_mnt_union() and cleanup_mnt_union() David Howells
@ 2011-06-17 16:05 ` David Howells
2011-06-17 16:05 ` [PATCH 39/76] union-mount: Prevent topmost file system from being mounted elsewhere David Howells
` (38 subsequent siblings)
76 siblings, 0 replies; 79+ messages in thread
From: David Howells @ 2011-06-17 16:05 UTC (permalink / raw)
To: linux-fsdevel; +Cc: hch
From: Valerie Aurora <vaurora@redhat.com>
A remount request must (a) not convert a union to a non-union (or vice
versa), or (b) make the topmost layer of a union read-only.
Note that we only have to worry about attempts to remount the vfsmount
of the topmost read-write of the union (the one with MNT_UNION set).
The vfsmounts of the read-only layers are hidden in a cloned tree
hanging of the superblock of the topmost layer and aren't visible to
userspace.
---
fs/namespace.c | 12 ++++++++++++
1 files changed, 12 insertions(+), 0 deletions(-)
diff --git a/fs/namespace.c b/fs/namespace.c
index f34146b..e88c72a 100644
--- a/fs/namespace.c
+++ b/fs/namespace.c
@@ -2069,6 +2069,18 @@ static int do_remount(struct path *path, int flags, int mnt_flags,
if (!check_mnt(path->mnt))
return -EINVAL;
+ if ((path->mnt->mnt_flags & MNT_UNION) &&
+ !(mnt_flags & MNT_UNION))
+ return -EINVAL;
+
+ if ((mnt_flags & MNT_UNION) &&
+ !(path->mnt->mnt_flags & MNT_UNION))
+ return -EINVAL;
+
+ if ((path->mnt->mnt_flags & MNT_UNION) &&
+ (mnt_flags & MNT_READONLY))
+ return -EINVAL;
+
if (path->dentry != path->mnt->mnt_root)
return -EINVAL;
^ permalink raw reply related [flat|nested] 79+ messages in thread* [PATCH 39/76] union-mount: Prevent topmost file system from being mounted elsewhere
2011-06-17 16:00 [RFC][PATCH 00/76] Union Mount David Howells
` (37 preceding siblings ...)
2011-06-17 16:05 ` [PATCH 38/76] union-mount: Prevent improper union-related remounts David Howells
@ 2011-06-17 16:05 ` David Howells
2011-06-17 16:06 ` [PATCH 40/76] union-mount: Prevent bind mounts of union mounts David Howells
` (37 subsequent siblings)
76 siblings, 0 replies; 79+ messages in thread
From: David Howells @ 2011-06-17 16:05 UTC (permalink / raw)
To: linux-fsdevel; +Cc: hch
From: Valerie Aurora <vaurora@redhat.com>
The device underlying the topmost read-write layer of a file system
cannot be mounted anywhere else on the system. We keep a pointer to
the union stack in the dentry of the topmost directory, so that dentry
can't be part of a different mount, since dentries are shared between
different mounts of the same device.
---
fs/namespace.c | 5 +++++
1 files changed, 5 insertions(+), 0 deletions(-)
diff --git a/fs/namespace.c b/fs/namespace.c
index e88c72a..402fb29 100644
--- a/fs/namespace.c
+++ b/fs/namespace.c
@@ -2252,6 +2252,11 @@ static int do_add_mount(struct vfsmount *newmnt, struct path *path, int mnt_flag
if (S_ISLNK(newmnt->mnt_root->d_inode->i_mode))
goto unlock;
+ /* Top layers of union mounts can't be mounted elsewhere */
+ err = -EBUSY;
+ if (newmnt->mnt_sb->s_union_lower_mnts)
+ goto unlock;
+
newmnt->mnt_flags = mnt_flags;
err = graft_tree(newmnt, path);
^ permalink raw reply related [flat|nested] 79+ messages in thread* [PATCH 40/76] union-mount: Prevent bind mounts of union mounts
2011-06-17 16:00 [RFC][PATCH 00/76] Union Mount David Howells
` (38 preceding siblings ...)
2011-06-17 16:05 ` [PATCH 39/76] union-mount: Prevent topmost file system from being mounted elsewhere David Howells
@ 2011-06-17 16:06 ` David Howells
2011-06-17 16:06 ` [PATCH 41/76] union-mount: Implement union mount David Howells
` (36 subsequent siblings)
76 siblings, 0 replies; 79+ messages in thread
From: David Howells @ 2011-06-17 16:06 UTC (permalink / raw)
To: linux-fsdevel; +Cc: hch
From: Valerie Aurora <vaurora@redhat.com>
Prevent bind mounts of parts of union mounts.
XXX - Bind mounting parts of union mounts is probably easy to
implement, but requires some careful thought about corner cases,
extensive testing, and some refactoring of the code.
---
fs/namespace.c | 6 ++++++
1 files changed, 6 insertions(+), 0 deletions(-)
diff --git a/fs/namespace.c b/fs/namespace.c
index 402fb29..d95b31d 100644
--- a/fs/namespace.c
+++ b/fs/namespace.c
@@ -2008,6 +2008,12 @@ static int do_loopback(struct path *path, char *old_name,
if (IS_MNT_UNBINDABLE(old_path.mnt))
goto out2;
+ /* XXX - Mounting a subtree of a union mount elsewhere requires careful
+ * thought and some refactoring.
+ */
+ if (IS_MNT_UNION(old_path.mnt))
+ goto out2;
+
if (!check_mnt(path->mnt) || !check_mnt(old_path.mnt))
goto out2;
^ permalink raw reply related [flat|nested] 79+ messages in thread* [PATCH 41/76] union-mount: Implement union mount
2011-06-17 16:00 [RFC][PATCH 00/76] Union Mount David Howells
` (39 preceding siblings ...)
2011-06-17 16:06 ` [PATCH 40/76] union-mount: Prevent bind mounts of union mounts David Howells
@ 2011-06-17 16:06 ` David Howells
2011-06-17 16:06 ` [PATCH 42/76] union-mount: Temporarily disable some syscalls David Howells
` (35 subsequent siblings)
76 siblings, 0 replies; 79+ messages in thread
From: David Howells @ 2011-06-17 16:06 UTC (permalink / raw)
To: linux-fsdevel; +Cc: hch
From: Valerie Aurora <vaurora@redhat.com>
Up till this commit, mount with MS_UNION flag succeeded but didn't
actually union the file systems. Now call the functions to check
the source mounts and create/destroy the per-vfsmount union structures.
---
fs/namespace.c | 13 ++++++++++++-
fs/super.c | 1 +
2 files changed, 13 insertions(+), 1 deletions(-)
diff --git a/fs/namespace.c b/fs/namespace.c
index d95b31d..cd28af0 100644
--- a/fs/namespace.c
+++ b/fs/namespace.c
@@ -1852,9 +1852,17 @@ static int attach_recursive_mnt(struct vfsmount *source_mnt,
if (err)
goto out;
}
+
+ /* parent_path means we are moving an existing unioned mount */
+ if (!parent_path && IS_MNT_UNION(source_mnt)) {
+ err = prepare_mnt_union(source_mnt, path);
+ if (err)
+ goto out_cleanup_ids;
+ }
+
err = propagate_mnt(dest_mnt, dest_dentry, source_mnt, &tree_list);
if (err)
- goto out_cleanup_ids;
+ goto out_cleanup_union;
br_write_lock(vfsmount_lock);
@@ -1879,6 +1887,9 @@ static int attach_recursive_mnt(struct vfsmount *source_mnt,
return 0;
+ out_cleanup_union:
+ if (!parent_path && IS_MNT_UNION(source_mnt))
+ cleanup_mnt_union(source_mnt);
out_cleanup_ids:
if (IS_MNT_SHARED(dest_mnt))
cleanup_group_ids(source_mnt, NULL);
diff --git a/fs/super.c b/fs/super.c
index 511f657..162e8a2 100644
--- a/fs/super.c
+++ b/fs/super.c
@@ -188,6 +188,7 @@ void deactivate_locked_super(struct super_block *s)
*/
rcu_barrier();
put_filesystem(fs);
+ put_union_sb(s);
put_super(s);
} else {
up_write(&s->s_umount);
^ permalink raw reply related [flat|nested] 79+ messages in thread* [PATCH 42/76] union-mount: Temporarily disable some syscalls
2011-06-17 16:00 [RFC][PATCH 00/76] Union Mount David Howells
` (40 preceding siblings ...)
2011-06-17 16:06 ` [PATCH 41/76] union-mount: Implement union mount David Howells
@ 2011-06-17 16:06 ` David Howells
2011-06-17 16:06 ` [PATCH 43/76] union-mount: Basic infrastructure of __lookup_union() David Howells
` (34 subsequent siblings)
76 siblings, 0 replies; 79+ messages in thread
From: David Howells @ 2011-06-17 16:06 UTC (permalink / raw)
To: linux-fsdevel; +Cc: hch
From: Valerie Aurora <vaurora@redhat.com>
After some of the following patches in this series, a few system calls
will crash the kernel if called on union-mounted file systems.
Temporarily disable rename(), unlink(), and rmdir() on unioned file
systems until they are correctly implemented by later patches.
---
fs/namei.c | 17 +++++++++++++++++
1 files changed, 17 insertions(+), 0 deletions(-)
diff --git a/fs/namei.c b/fs/namei.c
index 0014052..ce14b07 100644
--- a/fs/namei.c
+++ b/fs/namei.c
@@ -36,6 +36,7 @@
#include <asm/uaccess.h>
#include "internal.h"
+#include "union.h"
/* [Feb-1997 T. Schoebel-Theuer]
* Fundamental changes in the pathname lookup mechanisms (namei)
@@ -2799,6 +2800,11 @@ static long do_rmdir(int dfd, const char __user *pathname)
if (error)
return error;
+ /* rmdir() on union mounts not implemented yet */
+ error = -EINVAL;
+ if (IS_DIR_UNIONED(nd.path.dentry))
+ goto exit1;
+
switch(nd.last_type) {
case LAST_DOTDOT:
error = -ENOTEMPTY;
@@ -2899,6 +2905,11 @@ static long do_unlinkat(int dfd, const char __user *pathname)
if (nd.last_type != LAST_NORM)
goto exit1;
+ /* unlink() on union mounts not implemented yet */
+ error = -EINVAL;
+ if (IS_DIR_UNIONED(nd.path.dentry))
+ goto exit1;
+
nd.flags &= ~LOOKUP_PARENT;
mutex_lock_nested(&nd.path.dentry->d_inode->i_mutex, I_MUTEX_PARENT);
@@ -3302,6 +3313,12 @@ SYSCALL_DEFINE4(renameat, int, olddfd, const char __user *, oldname,
if (oldnd.path.mnt != newnd.path.mnt)
goto exit2;
+ /* rename() on union mounts not implemented yet */
+ error = -EXDEV;
+ if (IS_DIR_UNIONED(oldnd.path.dentry) ||
+ IS_DIR_UNIONED(newnd.path.dentry))
+ goto exit2;
+
old_dir = oldnd.path.dentry;
error = -EBUSY;
if (oldnd.last_type != LAST_NORM)
^ permalink raw reply related [flat|nested] 79+ messages in thread* [PATCH 43/76] union-mount: Basic infrastructure of __lookup_union()
2011-06-17 16:00 [RFC][PATCH 00/76] Union Mount David Howells
` (41 preceding siblings ...)
2011-06-17 16:06 ` [PATCH 42/76] union-mount: Temporarily disable some syscalls David Howells
@ 2011-06-17 16:06 ` David Howells
2011-06-17 16:06 ` [PATCH 44/76] union-mount: Process negative dentries in __lookup_union() David Howells
` (33 subsequent siblings)
76 siblings, 0 replies; 79+ messages in thread
From: David Howells @ 2011-06-17 16:06 UTC (permalink / raw)
To: linux-fsdevel; +Cc: hch
From: Valerie Aurora <vaurora@redhat.com>
Create a very simple version of union lookup. This patch only looks
up the target in each layer of the union but does not process it in
any way. Patches to do whiteouts, etc. follow.
---
fs/namei.c | 75 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
1 files changed, 75 insertions(+), 0 deletions(-)
diff --git a/fs/namei.c b/fs/namei.c
index ce14b07..8f0b504 100644
--- a/fs/namei.c
+++ b/fs/namei.c
@@ -1103,6 +1103,81 @@ static void follow_dotdot(struct nameidata *nd)
nd->inode = nd->path.dentry->d_inode;
}
+static struct dentry *__lookup_hash(struct qstr *name, struct dentry *base,
+ struct nameidata *nd);
+
+/**
+ * __lookup_union - Lookup and build union stack
+ * @nd - nameidata for the parent of @topmost
+ * @name - name of target
+ * @topmost - path of the target on the topmost file system
+ *
+ * Do the "union" part of lookup for @topmost - that is, look it up in the
+ * lower layers of its parent directory's union stack. If @topmost is a
+ * directory, build its union stack. @topmost is the path of the target in the
+ * topmost layer of the union file system. It is either a directory or a
+ * negative (non-whiteout) dentry.
+ *
+ * This function may stomp nd->path with the path of the parent directory of
+ * the lower layers, so the caller must save nd->path and restore it
+ * afterwards.
+ */
+static int __lookup_union(struct nameidata *nd, struct qstr *name,
+ struct path *topmost)
+{
+ struct path lower, parent = nd->path;
+ struct path *path;
+ unsigned int i, layers = parent.dentry->d_sb->s_union_count;
+ int err = 0;
+
+ if (!topmost->dentry->d_inode) {
+ if (d_is_whiteout(topmost->dentry))
+ return 0;
+ if (IS_OPAQUE(parent.dentry->d_inode) &&
+ !d_is_fallthru(topmost->dentry))
+ return 0;
+ }
+
+ /* If it's positive and not a dir, no lookup needed */
+ if (topmost->dentry->d_inode &&
+ !S_ISDIR(topmost->dentry->d_inode->i_mode))
+ return 0;
+
+ /* Note: This loop iterates through the union stack of the parent of
+ * the target, not the target itself. This function builds the union
+ * stack of the target (if any). The union stack of the root directory
+ * is built at mount.
+ */
+ for (i = 0; i < layers; i++) {
+ /* Get the parent directory for this layer and lookup
+ * the target in it.
+ */
+ path = union_find_dir(parent.dentry, i);
+ if (!path->mnt)
+ continue;
+
+ nd->path = *path;
+ lower.mnt = mntget(nd->path.mnt);
+ mutex_lock(&nd->path.dentry->d_inode->i_mutex);
+ lower.dentry = __lookup_hash(name, nd->path.dentry, nd);
+ mutex_unlock(&nd->path.dentry->d_inode->i_mutex);
+
+ if (IS_ERR(lower.dentry)) {
+ mntput(lower.mnt);
+ err = PTR_ERR(lower.dentry);
+ goto out_err;
+ }
+ /* XXX - do nothing, lookup rule processing in later patches */
+ path_put(&lower);
+ }
+ return 0;
+
+out_err:
+ d_free_unions(topmost->dentry);
+ path_put(&lower);
+ return err;
+}
+
/*
* Allocate a dentry with name and parent, and perform a parent
* directory ->lookup on it. Returns the new dentry, or ERR_PTR
^ permalink raw reply related [flat|nested] 79+ messages in thread* [PATCH 44/76] union-mount: Process negative dentries in __lookup_union()
2011-06-17 16:00 [RFC][PATCH 00/76] Union Mount David Howells
` (42 preceding siblings ...)
2011-06-17 16:06 ` [PATCH 43/76] union-mount: Basic infrastructure of __lookup_union() David Howells
@ 2011-06-17 16:06 ` David Howells
2011-06-17 16:06 ` [PATCH 45/76] union-mount: Return files found in lower layers " David Howells
` (32 subsequent siblings)
76 siblings, 0 replies; 79+ messages in thread
From: David Howells @ 2011-06-17 16:06 UTC (permalink / raw)
To: linux-fsdevel; +Cc: hch
From: Valerie Aurora <vaurora@redhat.com>
Whiteouts end a union lookup. So do opaque directories, unless
specific fallthru entry exists for this name.
---
fs/namei.c | 22 +++++++++++++++++++++-
1 files changed, 21 insertions(+), 1 deletions(-)
diff --git a/fs/namei.c b/fs/namei.c
index 8f0b504..e8871e7 100644
--- a/fs/namei.c
+++ b/fs/namei.c
@@ -1167,11 +1167,31 @@ static int __lookup_union(struct nameidata *nd, struct qstr *name,
err = PTR_ERR(lower.dentry);
goto out_err;
}
- /* XXX - do nothing, lookup rule processing in later patches */
+
+ /* A negative dentry can mean several things. A plain negative
+ * dentry is ignored and lookup continues to the next layer.
+ * But a whiteout or a non-fallthru in an opaque dir covers
+ * everything below it.
+ */
+ if (!lower.dentry->d_inode) {
+ if (d_is_whiteout(lower.dentry))
+ goto out_lookup_done;
+ if (IS_OPAQUE(nd->path.dentry->d_inode) &&
+ !d_is_fallthru(lower.dentry))
+ goto out_lookup_done;
+ path_put(&lower);
+ continue;
+ }
+
+ /* XXX - do nothing, more in later patches */
path_put(&lower);
}
return 0;
+out_lookup_done:
+ path_put(&lower);
+ return 0;
+
out_err:
d_free_unions(topmost->dentry);
path_put(&lower);
^ permalink raw reply related [flat|nested] 79+ messages in thread* [PATCH 45/76] union-mount: Return files found in lower layers in __lookup_union()
2011-06-17 16:00 [RFC][PATCH 00/76] Union Mount David Howells
` (43 preceding siblings ...)
2011-06-17 16:06 ` [PATCH 44/76] union-mount: Process negative dentries in __lookup_union() David Howells
@ 2011-06-17 16:06 ` David Howells
2011-06-17 16:06 ` [PATCH 46/76] union-mount: Build union stack " David Howells
` (31 subsequent siblings)
76 siblings, 0 replies; 79+ messages in thread
From: David Howells @ 2011-06-17 16:06 UTC (permalink / raw)
To: linux-fsdevel; +Cc: hch
From: Valerie Aurora <vaurora@redhat.com>
If we find a file during union lookup, don't look in any lower layers
and replace the topmost path with the file's path.
---
fs/namei.c | 20 ++++++++++++++++++++
1 files changed, 20 insertions(+), 0 deletions(-)
diff --git a/fs/namei.c b/fs/namei.c
index e8871e7..9ae58a3e 100644
--- a/fs/namei.c
+++ b/fs/namei.c
@@ -1183,11 +1183,31 @@ static int __lookup_union(struct nameidata *nd, struct qstr *name,
continue;
}
+ /* Files block everything below them. Special case: If we find
+ * a file below a directory (which makes no sense), just ignore
+ * the file and return the directory above it.
+ */
+ if (!S_ISDIR(lower.dentry->d_inode->i_mode)) {
+ if (topmost->dentry->d_inode &&
+ S_ISDIR(topmost->dentry->d_inode->i_mode))
+ goto out_lookup_done;
+ goto out_found_file;
+ }
+
/* XXX - do nothing, more in later patches */
path_put(&lower);
}
return 0;
+out_found_file:
+ /* Swap out the positive lower dentry with the negative upper
+ * dentry for this file. Note that the matching mntput() is done
+ * in link_path_walk().
+ */
+ dput(topmost->dentry);
+ *topmost = lower;
+ return 0;
+
out_lookup_done:
path_put(&lower);
return 0;
^ permalink raw reply related [flat|nested] 79+ messages in thread* [PATCH 46/76] union-mount: Build union stack in __lookup_union()
2011-06-17 16:00 [RFC][PATCH 00/76] Union Mount David Howells
` (44 preceding siblings ...)
2011-06-17 16:06 ` [PATCH 45/76] union-mount: Return files found in lower layers " David Howells
@ 2011-06-17 16:06 ` David Howells
2011-06-17 16:07 ` [PATCH 47/76] union-mount: Follow mount " David Howells
` (30 subsequent siblings)
76 siblings, 0 replies; 79+ messages in thread
From: David Howells @ 2011-06-17 16:06 UTC (permalink / raw)
To: linux-fsdevel; +Cc: hch
From: Valerie Aurora <vaurora@redhat.com>
Build the union stack for directories as we look them up. Create the
topmost directory if it doesn't exist.
---
fs/namei.c | 17 +++++++++++++++--
1 files changed, 15 insertions(+), 2 deletions(-)
diff --git a/fs/namei.c b/fs/namei.c
index 9ae58a3e..65bc835 100644
--- a/fs/namei.c
+++ b/fs/namei.c
@@ -1194,8 +1194,21 @@ static int __lookup_union(struct nameidata *nd, struct qstr *name,
goto out_found_file;
}
- /* XXX - do nothing, more in later patches */
- path_put(&lower);
+ /* Now we know the target is a directory. Create a matching
+ * topmost directory if one doesn't already exist, and add this
+ * layer's directory to the union stack for the topmost
+ * directory.
+ */
+ if (!topmost->dentry->d_inode) {
+ err = union_create_topmost_dir(&parent, name, topmost,
+ &lower);
+ if (err)
+ goto out_err;
+ }
+
+ err = union_add_dir(topmost, &lower, i);
+ if (err)
+ goto out_err;
}
return 0;
^ permalink raw reply related [flat|nested] 79+ messages in thread* [PATCH 47/76] union-mount: Follow mount in __lookup_union()
2011-06-17 16:00 [RFC][PATCH 00/76] Union Mount David Howells
` (45 preceding siblings ...)
2011-06-17 16:06 ` [PATCH 46/76] union-mount: Build union stack " David Howells
@ 2011-06-17 16:07 ` David Howells
2011-06-17 16:07 ` [PATCH 48/76] union-mount: Add lookup_union() David Howells
` (29 subsequent siblings)
76 siblings, 0 replies; 79+ messages in thread
From: David Howells @ 2011-06-17 16:07 UTC (permalink / raw)
To: linux-fsdevel; +Cc: hch
From: Valerie Aurora <vaurora@redhat.com>
In order for read-only layers of a union to have submounts, we have to
follow mounts on directories in union lookup.
---
fs/namei.c | 2 ++
1 files changed, 2 insertions(+), 0 deletions(-)
diff --git a/fs/namei.c b/fs/namei.c
index 65bc835..35dc710 100644
--- a/fs/namei.c
+++ b/fs/namei.c
@@ -1199,6 +1199,8 @@ static int __lookup_union(struct nameidata *nd, struct qstr *name,
* layer's directory to the union stack for the topmost
* directory.
*/
+ follow_mount(&lower);
+
if (!topmost->dentry->d_inode) {
err = union_create_topmost_dir(&parent, name, topmost,
&lower);
^ permalink raw reply related [flat|nested] 79+ messages in thread* [PATCH 48/76] union-mount: Add lookup_union()
2011-06-17 16:00 [RFC][PATCH 00/76] Union Mount David Howells
` (46 preceding siblings ...)
2011-06-17 16:07 ` [PATCH 47/76] union-mount: Follow mount " David Howells
@ 2011-06-17 16:07 ` David Howells
2011-06-17 16:07 ` [PATCH 49/76] union-mount: Add do_lookup_union() wrapper for __lookup_union() David Howells
` (28 subsequent siblings)
76 siblings, 0 replies; 79+ messages in thread
From: David Howells @ 2011-06-17 16:07 UTC (permalink / raw)
To: linux-fsdevel; +Cc: hch
From: Valerie Aurora <vaurora@redhat.com>
lookup_union() checks if union lookup is actually necessary for this
dentry, and marks the dentry to show that the union lookup has been
performed.
__lookup_union() may overwrite the parent's path in the nameidata
struct for the entry being looked up. This is because it reuses the
same nameidata to do lookups in each of the lower layer directories.
lookup_union() saves and restores the original parent's path in the
nameidata.
---
fs/namei.c | 47 +++++++++++++++++++++++++++++++++++++++++++++++
1 files changed, 47 insertions(+), 0 deletions(-)
diff --git a/fs/namei.c b/fs/namei.c
index 35dc710..957466d 100644
--- a/fs/namei.c
+++ b/fs/namei.c
@@ -1233,6 +1233,53 @@ out_err:
return err;
}
+/**
+ * lookup_union - Lookup and/or build union stack if needed
+ * @nd - nameidata for the parent of @topmost
+ * @name - name of target
+ * @topmost - path of the target on the topmost file system
+ *
+ * Check if we need to do a union lookup on this target. Mark dentry
+ * to show lookup union has been performed.
+ *
+ * We borrow the nameidata struct from the topmost layer to do the
+ * revalidation on lower dentries, replacing the topmost parent
+ * directory's path with that of the matching parent dir in each lower
+ * layer. This wrapper for __lookup_union() saves the topmost layer's
+ * path and restores it when we are done.
+ *
+ * Caller must hold parent i_mutex.
+ */
+static int lookup_union(struct nameidata *nd, struct qstr *name,
+ struct path *topmost)
+{
+ struct path saved_path;
+ int err = 0;
+
+ BUG_ON(!IS_MNT_UNION(nd->path.mnt) && !IS_MNT_UNION(topmost->mnt));
+ BUG_ON(!mutex_is_locked(&nd->path.dentry->d_inode->i_mutex));
+
+ /* Initial test done outside of parent i_mutex lock, recheck it. We
+ * only set this flag inside parent i_mutex so it's safe to check it
+ * here (only need d_lock when setting to avoid squashing other flags).
+ */
+ if (topmost->dentry->d_flags & DCACHE_UNION_LOOKUP_DONE)
+ return 0;
+
+ saved_path = nd->path;
+
+ err = __lookup_union(nd, name, topmost);
+
+ nd->path = saved_path;
+
+ /* XXX move into dcache.h */
+ spin_lock(&topmost->dentry->d_lock);
+ topmost->dentry->d_flags |= DCACHE_UNION_LOOKUP_DONE;
+ spin_unlock(&topmost->dentry->d_lock);
+
+ return err;
+}
+
/*
* Allocate a dentry with name and parent, and perform a parent
* directory ->lookup on it. Returns the new dentry, or ERR_PTR
^ permalink raw reply related [flat|nested] 79+ messages in thread* [PATCH 49/76] union-mount: Add do_lookup_union() wrapper for __lookup_union()
2011-06-17 16:00 [RFC][PATCH 00/76] Union Mount David Howells
` (47 preceding siblings ...)
2011-06-17 16:07 ` [PATCH 48/76] union-mount: Add lookup_union() David Howells
@ 2011-06-17 16:07 ` David Howells
2011-06-17 16:07 ` [PATCH 50/76] union-mount: Call union lookup functions in lookup path David Howells
` (27 subsequent siblings)
76 siblings, 0 replies; 79+ messages in thread
From: David Howells @ 2011-06-17 16:07 UTC (permalink / raw)
To: linux-fsdevel; +Cc: hch
From: Valerie Aurora <vaurora@redhat.com>
do_lookup_union() locks the parent directory and follows the mount
after lookup. It is appropriate for calling from do_lookup().
---
fs/namei.c | 149 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++-
1 files changed, 147 insertions(+), 2 deletions(-)
diff --git a/fs/namei.c b/fs/namei.c
index 957466d..efd1937 100644
--- a/fs/namei.c
+++ b/fs/namei.c
@@ -1199,6 +1199,9 @@ static int __lookup_union(struct nameidata *nd, struct qstr *name,
* layer's directory to the union stack for the topmost
* directory.
*/
+#warning what if the directory is managed?
+#warning should we d_revalidate the lower dentry?
+#warning how to handle automounts?
follow_mount(&lower);
if (!topmost->dentry->d_inode) {
@@ -1281,6 +1284,144 @@ static int lookup_union(struct nameidata *nd, struct qstr *name,
}
/*
+ * do_lookup_union - union mount-aware part of do_lookup()
+ *
+ * do_lookup()-style wrapper for lookup_union(). Follows mounts.
+ */
+static int do_lookup_union(struct nameidata *nd, struct qstr *name,
+ struct path *topmost)
+{
+ struct dentry *parent = nd->path.dentry;
+ struct inode *dir = parent->d_inode;
+ int err;
+
+ mutex_lock(&dir->i_mutex);
+ err = lookup_union(nd, name, topmost);
+ mutex_unlock(&dir->i_mutex);
+ if (err)
+ return err;
+
+ return follow_managed(topmost, nd->flags);
+}
+
+/*
+ * lookup_union_rcu - Handle union mounted dentries in RCU-walk mode
+ * @nd: The current pathwalk state (refers to @parent currently)
+ * @parent: The parent directory (holds the union stack)
+ * @path: The point just looked up in @parent
+ * @parent_seq: The d_seq of @parent at the point of lookup
+ * @inode: The inode at @dentry (*@inode is NULL if negative dentry)
+ *
+ * Handle a dentry that represents a non-directory file or a hole/reference in
+ * a union mount upperfs. This involves transiting to the lower file, provided
+ * we aren't going to open the lower file for writing - otherwise we have to
+ * copy the file up (which we can't do in rcuwalk mode).
+ *
+ * Directories are handled differently: they're unconditionally and completely
+ * mirrored from the lowerfs to the upperfs as soon as we encounter them in a
+ * lookup. However, since we don't create dentries in rcuwalk mode, this will
+ * be handled automatically by refwalk mode.
+ *
+ * We return true if we don't need to do anything or if we've successfully
+ * updated the path. If we need to drop out of RCU-walk and go to refwalk
+ * mode, we return false.
+ */
+static bool lookup_union_rcu(struct nameidata *nd,
+ struct dentry *parent,
+ struct path *path,
+ unsigned parent_seq,
+ struct inode **inode)
+{
+ struct dentry *dentry = path->dentry;
+ struct inode *parent_inode = nd->inode;
+ unsigned layer, layers;
+
+ /* Handle non-unionmount dentries first. The union stack will have
+ * been built during the initial lookup of the parent dir, so if it's
+ * not there, it's not unioned.
+ */
+ if (!IS_DIR_UNIONED(parent))
+ return true;
+
+ /* If it's positive then no further lookup is needed: the file or
+ * directory has been copied up and the user gets to play with that.
+ */
+ if (*inode)
+ return true;
+
+ /* If this dentry is a blocker, then stop here. */
+ if (d_is_whiteout(dentry) ||
+ (IS_OPAQUE(parent_inode) && !d_is_fallthru(dentry)))
+ return true;
+
+ /* At this point we have a negative dentry in the unionmount that may
+ * be overlaying a non-directory file in a lower filesystem, so we loop
+ * through the union stack of the parent directory to try to find a
+ * usable dentry further down.
+ */
+ layers = parent->d_sb->s_union_count;
+ for (layer = 0; layer < layers; layer++) {
+ /* Look for the a matching dentry in this layer, assuming it's
+ * still valid. Since the lower fs is hard locked R/O,
+ * revalidation ought to be unnecessary.
+ */
+ unsigned ldseq, seq;
+ struct dentry *lower_dir, *lower;
+ struct path *lower_path = union_find_dir(parent, layer);
+ if (!lower_path->mnt)
+ continue;
+
+ lower_dir = lower_path->dentry;
+ ldseq = read_seqcount_begin(&lower_dir->d_seq);
+
+ if (unlikely(lower_dir->d_flags & DCACHE_OP_REVALIDATE)) {
+ if (unlikely(d_revalidate(lower_dir, nd) <= 0) ||
+ __read_seqcount_retry(&lower_dir->d_seq, ldseq))
+ return false;
+ }
+
+ lower = __d_lookup_rcu(lower_dir, &dentry->d_name, &seq, inode);
+ if (!lower)
+ return false;
+
+ /* We've got a negative dentry which can mean several things: a
+ * plain negative dentry is ignored and lookup continues to the
+ * next layer; but a whiteout or a non-fallthru in an opaque
+ * dir covers everything below it.
+ */
+ if (!*inode) {
+ if (d_is_whiteout(lower) ||
+ (IS_OPAQUE(parent_inode) && !d_is_fallthru(lower))) {
+ if (read_seqcount_retry(&lower_dir->d_seq,
+ ldseq))
+ return false;
+ return true;
+ }
+ continue;
+ }
+
+ /* If the lower dentry is a directory then it will need copying
+ * up before we can make use of it.
+ */
+ if (S_ISDIR((*inode)->i_mode))
+ return false;
+
+ /* We have a file in a lower fs that we can use */
+ if (read_seqcount_retry(&lower_dir->d_seq, ldseq) ||
+ __read_seqcount_retry(&parent->d_seq, parent_seq))
+ return false;
+
+ path->mnt = lower_path->mnt;
+ path->dentry = lower;
+ nd->seq = seq;
+ return true;
+ }
+
+ /* Found nothing, so just use the top negative dentry */
+ return dentry;
+}
+
+/*
* Allocate a dentry with name and parent, and perform a parent
* directory ->lookup on it. Returns the new dentry, or ERR_PTR
* on error. parent->d_inode->i_mutex must be held. d_lookup must
@@ -1329,14 +1470,15 @@ static int do_lookup(struct nameidata *nd, struct qstr *name,
* do the non-racy lookup, below.
*/
if (nd->flags & LOOKUP_RCU) {
- unsigned seq;
+ unsigned seq, pseq;
*inode = nd->inode;
dentry = __d_lookup_rcu(parent, name, &seq, inode);
if (!dentry)
goto unlazy;
/* Memory barrier in read_seqcount_begin of child is enough */
- if (__read_seqcount_retry(&parent->d_seq, nd->seq))
+ pseq = nd->seq;
+ if (__read_seqcount_retry(&parent->d_seq, pseq))
return -ECHILD;
nd->seq = seq;
@@ -1348,8 +1490,11 @@ static int do_lookup(struct nameidata *nd, struct qstr *name,
goto unlazy;
}
}
+
path->mnt = mnt;
path->dentry = dentry;
+ if (unlikely(!lookup_union_rcu(nd, parent, path, pseq, inode)))
+ goto unlazy;
if (unlikely(!__follow_mount_rcu(nd, path, inode)))
goto unlazy;
if (unlikely(path->dentry->d_flags & DCACHE_NEED_AUTOMOUNT))
^ permalink raw reply related [flat|nested] 79+ messages in thread* [PATCH 50/76] union-mount: Call union lookup functions in lookup path
2011-06-17 16:00 [RFC][PATCH 00/76] Union Mount David Howells
` (48 preceding siblings ...)
2011-06-17 16:07 ` [PATCH 49/76] union-mount: Add do_lookup_union() wrapper for __lookup_union() David Howells
@ 2011-06-17 16:07 ` David Howells
2011-06-17 16:07 ` [PATCH 51/76] union-mount: Create whiteout on unlink() David Howells
` (26 subsequent siblings)
76 siblings, 0 replies; 79+ messages in thread
From: David Howells @ 2011-06-17 16:07 UTC (permalink / raw)
To: linux-fsdevel; +Cc: hch
From: Valerie Aurora <vaurora@redhat.com>
Union mounts hook into the lookup path in two places: do_lookup() and
lookup_hash().
---
fs/namei.c | 12 ++++++++++++
1 files changed, 12 insertions(+), 0 deletions(-)
diff --git a/fs/namei.c b/fs/namei.c
index efd1937..4a01441 100644
--- a/fs/namei.c
+++ b/fs/namei.c
@@ -1548,6 +1548,14 @@ retry:
path_put_conditional(path, nd);
return err;
}
+
+ if (needs_lookup_union(&nd->path, path)) {
+ int err = do_lookup_union(nd, name, path);
+ if (err < 0)
+ return err;
+#warning which inode?
+ }
+
*inode = path->dentry->d_inode;
return 0;
}
@@ -2029,8 +2037,12 @@ static int lookup_hash(struct nameidata *nd, struct qstr *name,
path->dentry = NULL;
return PTR_ERR(result);
}
+
path->mnt = nd->path.mnt;
path->dentry = result;
+
+ if (needs_lookup_union(&nd->path, path))
+ return lookup_union(nd, name, path);
return 0;
}
^ permalink raw reply related [flat|nested] 79+ messages in thread* [PATCH 51/76] union-mount: Create whiteout on unlink()
2011-06-17 16:00 [RFC][PATCH 00/76] Union Mount David Howells
` (49 preceding siblings ...)
2011-06-17 16:07 ` [PATCH 50/76] union-mount: Call union lookup functions in lookup path David Howells
@ 2011-06-17 16:07 ` David Howells
2011-06-17 16:07 ` [PATCH 52/76] union-mount: Create whiteout on rmdir() David Howells
` (25 subsequent siblings)
76 siblings, 0 replies; 79+ messages in thread
From: David Howells @ 2011-06-17 16:07 UTC (permalink / raw)
To: linux-fsdevel; +Cc: hch
From: Valerie Aurora <vaurora@redhat.com>
Whiteout an unlinked directory entry in a union mounted file system.
---
fs/namei.c | 9 ++++-----
1 files changed, 4 insertions(+), 5 deletions(-)
diff --git a/fs/namei.c b/fs/namei.c
index 4a01441..a168681 100644
--- a/fs/namei.c
+++ b/fs/namei.c
@@ -3239,11 +3239,6 @@ static long do_unlinkat(int dfd, const char __user *pathname)
if (nd.last_type != LAST_NORM)
goto exit1;
- /* unlink() on union mounts not implemented yet */
- error = -EINVAL;
- if (IS_DIR_UNIONED(nd.path.dentry))
- goto exit1;
-
nd.flags &= ~LOOKUP_PARENT;
mutex_lock_nested(&nd.path.dentry->d_inode->i_mutex, I_MUTEX_PARENT);
@@ -3260,6 +3255,10 @@ static long do_unlinkat(int dfd, const char __user *pathname)
error = security_path_unlink(&nd.path, path.dentry);
if (error)
goto exit3;
+ if (IS_DIR_UNIONED(nd.path.dentry)) {
+ error = do_whiteout(&nd, &path, 0);
+ goto exit3;
+ }
error = vfs_unlink(nd.path.dentry->d_inode, path.dentry);
exit3:
mnt_drop_write(nd.path.mnt);
^ permalink raw reply related [flat|nested] 79+ messages in thread* [PATCH 52/76] union-mount: Create whiteout on rmdir()
2011-06-17 16:00 [RFC][PATCH 00/76] Union Mount David Howells
` (50 preceding siblings ...)
2011-06-17 16:07 ` [PATCH 51/76] union-mount: Create whiteout on unlink() David Howells
@ 2011-06-17 16:07 ` David Howells
2011-06-17 16:07 ` [PATCH 53/76] union-mount: Set opaque flag on new directories in unioned file systems David Howells
` (24 subsequent siblings)
76 siblings, 0 replies; 79+ messages in thread
From: David Howells @ 2011-06-17 16:07 UTC (permalink / raw)
To: linux-fsdevel; +Cc: hch
From: Valerie Aurora <vaurora@redhat.com>
Whiteout a deleted directory in a union mounted file system.
---
fs/namei.c | 9 ++++-----
1 files changed, 4 insertions(+), 5 deletions(-)
diff --git a/fs/namei.c b/fs/namei.c
index a168681..3983468 100644
--- a/fs/namei.c
+++ b/fs/namei.c
@@ -3134,11 +3134,6 @@ static long do_rmdir(int dfd, const char __user *pathname)
if (error)
return error;
- /* rmdir() on union mounts not implemented yet */
- error = -EINVAL;
- if (IS_DIR_UNIONED(nd.path.dentry))
- goto exit1;
-
switch(nd.last_type) {
case LAST_DOTDOT:
error = -ENOTEMPTY;
@@ -3167,6 +3162,10 @@ static long do_rmdir(int dfd, const char __user *pathname)
error = security_path_rmdir(&nd.path, path.dentry);
if (error)
goto exit4;
+ if (IS_DIR_UNIONED(nd.path.dentry)) {
+ error = do_whiteout(&nd, &path, 1);
+ goto exit4;
+ }
error = vfs_rmdir(nd.path.dentry->d_inode, path.dentry);
exit4:
mnt_drop_write(nd.path.mnt);
^ permalink raw reply related [flat|nested] 79+ messages in thread* [PATCH 53/76] union-mount: Set opaque flag on new directories in unioned file systems
2011-06-17 16:00 [RFC][PATCH 00/76] Union Mount David Howells
` (51 preceding siblings ...)
2011-06-17 16:07 ` [PATCH 52/76] union-mount: Create whiteout on rmdir() David Howells
@ 2011-06-17 16:07 ` David Howells
2011-06-17 16:08 ` [PATCH 54/76] union-mount: Copy up directory entries on first readdir() David Howells
` (23 subsequent siblings)
76 siblings, 0 replies; 79+ messages in thread
From: David Howells @ 2011-06-17 16:07 UTC (permalink / raw)
To: linux-fsdevel; +Cc: hch
From: Valerie Aurora <vaurora@redhat.com>
If we mkdir() a directory on the top layer of a union, we don't want
entries from a matching directory on the lower layer to "show through"
suddenly. To prevent this, we set the opaque flag on a directory in a
union mount if there is no matching directory on the lower layers.
Signed-off-by: Jan Blunck <jblunck@suse.de>
Signed-off-by: Valerie Aurora <vaurora@redhat.com>
---
fs/namei.c | 13 +++++++++++--
1 files changed, 11 insertions(+), 2 deletions(-)
diff --git a/fs/namei.c b/fs/namei.c
index 3983468..199d385 100644
--- a/fs/namei.c
+++ b/fs/namei.c
@@ -2840,8 +2840,17 @@ int vfs_mkdir(struct inode *dir, struct dentry *dentry, int mode)
return error;
error = dir->i_op->mkdir(dir, dentry, mode);
- if (!error)
- fsnotify_mkdir(dir, dentry);
+ if (error)
+ return error;
+
+ /* XXX racy - crash now and dir isn't opaque */
+ if (IS_DIR_UNIONED(dentry->d_parent)) {
+ dentry->d_inode->i_flags |= S_OPAQUE;
+ mark_inode_dirty(dentry->d_inode);
+ }
+
+ fsnotify_mkdir(dir, dentry);
+
return error;
}
^ permalink raw reply related [flat|nested] 79+ messages in thread* [PATCH 54/76] union-mount: Copy up directory entries on first readdir()
2011-06-17 16:00 [RFC][PATCH 00/76] Union Mount David Howells
` (52 preceding siblings ...)
2011-06-17 16:07 ` [PATCH 53/76] union-mount: Set opaque flag on new directories in unioned file systems David Howells
@ 2011-06-17 16:08 ` David Howells
2011-06-17 16:08 ` [PATCH 55/76] union-mount: Add generic_readdir_fallthru() helper David Howells
` (22 subsequent siblings)
76 siblings, 0 replies; 79+ messages in thread
From: David Howells @ 2011-06-17 16:08 UTC (permalink / raw)
To: linux-fsdevel; +Cc: hch
From: Valerie Aurora <vaurora@redhat.com>
readdir() in union mounts is implemented by copying up all visible
directory entries from the lower level directories to the topmost
directory. Directory entries that refer to lower level file system
objects are marked as "fallthru" in the topmost directory.
Thanks to Felix Fietkau <nbd@openwrt.org> for a bug fix.
Signed-off-by: Valerie Aurora <vaurora@redhat.com>
---
fs/readdir.c | 9 +++
fs/union.c | 184 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
fs/union.h | 2 +
3 files changed, 195 insertions(+), 0 deletions(-)
diff --git a/fs/readdir.c b/fs/readdir.c
index de703d6..a87ae02 100644
--- a/fs/readdir.c
+++ b/fs/readdir.c
@@ -20,6 +20,8 @@
#include <asm/uaccess.h>
+#include "union.h"
+
int vfs_readdir(struct file *file, filldir_t filler, void *buf)
{
struct inode *inode = file->f_path.dentry->d_inode;
@@ -37,9 +39,16 @@ int vfs_readdir(struct file *file, filldir_t filler, void *buf)
res = -ENOENT;
if (!IS_DEADDIR(inode)) {
+ if (IS_DIR_UNIONED(file->f_path.dentry) && !IS_OPAQUE(inode)) {
+ res = union_copyup_dir(&file->f_path);
+ if (res)
+ goto out_unlock;
+ }
+
res = file->f_op->readdir(file, buf, filler);
file_accessed(file);
}
+out_unlock:
mutex_unlock(&inode->i_mutex);
out:
return res;
diff --git a/fs/union.c b/fs/union.c
index e0b1678..430b1b4 100644
--- a/fs/union.c
+++ b/fs/union.c
@@ -22,6 +22,8 @@
#include <linux/namei.h>
#include <linux/fsnotify.h>
#include <linux/xattr.h>
+#include <linux/file.h>
+#include <linux/security.h>
#include "union.h"
@@ -201,3 +203,185 @@ out:
mnt_drop_write(parent->mnt);
return error;
}
+
+struct union_filldir_info {
+ struct dentry *topmost_dentry;
+ int error;
+};
+
+/**
+ * union_copyup_dir_one - copy up a single directory entry
+ *
+ * Individual directory entry copyup function for union_copyup_dir.
+ * We get the entries from higher level layers first.
+ */
+static int union_copyup_dir_one(void *buf, const char *name, int namlen,
+ loff_t offset, u64 ino, unsigned int d_type)
+{
+ struct union_filldir_info *ufi = (struct union_filldir_info *) buf;
+ struct dentry *topmost_dentry = ufi->topmost_dentry;
+ struct dentry *dentry;
+ int err = 0;
+
+ switch (namlen) {
+ case 2:
+ if (name[1] != '.')
+ break;
+ case 1:
+ if (name[0] != '.')
+ break;
+ return 0;
+ }
+
+ /* Lookup this entry in the topmost directory */
+ dentry = lookup_one_len(name, topmost_dentry, namlen);
+
+ if (IS_ERR(dentry)) {
+ printk(KERN_WARNING "%s: error looking up %s\n", __func__,
+ dentry->d_name.name);
+ err = PTR_ERR(dentry);
+ goto out;
+ }
+
+ /* XXX do we need to revalidate on readdir anyway? think NFS */
+ if (dentry->d_op && dentry->d_op->d_revalidate)
+ goto fallthru;
+
+ /* If the entry already exists, one of the following is true: it was
+ * already copied up (due to an earlier lookup), an entry with the same
+ * name already exists on the topmost file system, it is a whiteout, or
+ * it is a fallthru. In each case, the top level entry masks any
+ * entries from lower file systems, so don't copy up this entry.
+ */
+ if (dentry->d_inode || d_is_whiteout(dentry) || d_is_fallthru(dentry))
+ goto out_dput;
+
+ /* If the entry doesn't exist, create a fallthru entry in the topmost
+ * file system. All possible directory types are used, so each file
+ * system must implement its own way of storing a fallthru entry.
+ */
+fallthru:
+ err = topmost_dentry->d_inode->i_op->fallthru(topmost_dentry->d_inode,
+ dentry);
+
+ /* It's okay if it exists, ultimate responsibility rests with
+ * ->fallthru() */
+ if (err == -EEXIST)
+ err = 0;
+out_dput:
+ dput(dentry);
+out:
+ if (err)
+ ufi->error = err;
+ return err;
+}
+
+/**
+ * union_copyup_dir - copy up low-level directory entries to topmost dir
+ *
+ * readdir() is difficult to support on union file systems for two reasons: We
+ * must eliminate duplicates and apply whiteouts, and we must return something
+ * in f_pos that lets us restart in the same place when we return. Our
+ * solution is to, on first readdir() of the directory, copy up all visible
+ * entries from the low-level file systems and mark the entries that refer to
+ * low-level file system objects as "fallthru" entries.
+ *
+ * Locking strategy: We hold the topmost dir's i_mutex on entry. We grab the
+ * i_mutex on lower directories one by one. So the locking order is:
+ *
+ * Writable/topmost layers > Read-only/lower layers
+ *
+ * So there is no problem with lock ordering for union stacks with
+ * multiple lower layers. E.g.:
+ *
+ * (topmost) A->B->C (bottom)
+ * (topmost) D->C->B (bottom)
+ *
+ */
+int union_copyup_dir(struct path *topmost_path)
+{
+ struct union_filldir_info ufi;
+ struct dentry *topmost_dentry = topmost_path->dentry;
+ unsigned int i, layers = topmost_dentry->d_sb->s_union_count;
+ int error = 0;
+
+ BUG_ON(IS_OPAQUE(topmost_dentry->d_inode));
+
+ if (!topmost_dentry->d_inode->i_op ||
+ !topmost_dentry->d_inode->i_op->fallthru)
+ return -EOPNOTSUPP;
+
+ error = mnt_want_write(topmost_path->mnt);
+ if (error)
+ return error;
+
+ for (i = 0; i < layers; i++) {
+ struct file * ftmp;
+ struct inode * inode;
+ struct path *path;
+
+ path = union_find_dir(topmost_dentry, i);
+ if (!path->mnt)
+ continue;
+
+ /* dentry_open() doesn't get a path reference itself */
+ path_get(path);
+ ftmp = dentry_open(path->dentry, path->mnt,
+ O_RDONLY | O_DIRECTORY | O_NOATIME,
+ current_cred());
+ if (IS_ERR(ftmp)) {
+ printk (KERN_ERR "unable to open dir %s for "
+ "directory copyup: %ld\n",
+ path->dentry->d_name.name, PTR_ERR(ftmp));
+ path_put(path);
+ error = PTR_ERR(ftmp);
+ break;
+ }
+
+ inode = path->dentry->d_inode;
+ mutex_lock(&inode->i_mutex);
+
+ error = -ENOENT;
+ if (IS_DEADDIR(inode))
+ goto out_fput;
+
+ /* Read the whole directory, calling our directory entry copyup
+ * function on each entry.
+ */
+ ufi.topmost_dentry = topmost_dentry;
+ ufi.error = 0;
+ error = ftmp->f_op->readdir(ftmp, &ufi, union_copyup_dir_one);
+out_fput:
+ mutex_unlock(&inode->i_mutex);
+ fput(ftmp);
+
+ if (ufi.error)
+ error = ufi.error;
+ if (error)
+ break;
+
+ /* XXX Should process directories below an opaque directory in
+ * case there are fallthrus in it
+ */
+ if (IS_OPAQUE(path->dentry->d_inode))
+ break;
+ }
+
+ /* Mark this dir opaque to show that we have already copied up the
+ * lower entries. Be sure to do this AFTER the directory entries have
+ * been copied up so that if we crash in the middle of copyup, we will
+ * try to copyup the dir next time we read it.
+ *
+ * XXX - Could leave directory non-opaque, and force reread/copyup of
+ * directory each time it is read in from disk. That would make it
+ * easy to update lower file systems (when not union mounted) and have
+ * the changes show up when union mounted again.
+ */
+ if (!error) {
+ topmost_dentry->d_inode->i_flags |= S_OPAQUE;
+ mark_inode_dirty(topmost_dentry->d_inode);
+ }
+
+ mnt_drop_write(topmost_path->mnt);
+ return error;
+}
diff --git a/fs/union.h b/fs/union.h
index 54427ba..8ee4ad6 100644
--- a/fs/union.h
+++ b/fs/union.h
@@ -56,6 +56,7 @@ extern void d_free_unions(struct dentry *);
extern int union_add_dir(struct path *, struct path *, unsigned int);
extern int union_create_topmost_dir(struct path *, struct qstr *, struct path *,
struct path *);
+extern int union_copyup_dir(struct path *);
static inline
struct path *union_find_dir(struct dentry *dentry, unsigned int layer)
@@ -90,6 +91,7 @@ int needs_lookup_union(struct path *parent_path, struct path *path)
#define union_find_dir(x, y) ({ BUG(); (NULL); })
#define union_create_topmost_dir(w, x, y, z) ({ BUG(); (0); })
#define needs_lookup_union(x, y) ({ (0); })
+#define union_copyup_dir(x) ({ BUG(); (0); })
#endif /* CONFIG_UNION_MOUNT */
#endif /* __KERNEL__ */
^ permalink raw reply related [flat|nested] 79+ messages in thread* [PATCH 55/76] union-mount: Add generic_readdir_fallthru() helper
2011-06-17 16:00 [RFC][PATCH 00/76] Union Mount David Howells
` (53 preceding siblings ...)
2011-06-17 16:08 ` [PATCH 54/76] union-mount: Copy up directory entries on first readdir() David Howells
@ 2011-06-17 16:08 ` David Howells
2011-06-17 16:08 ` [PATCH 56/76] fallthru: ext2 support for lookup of d_type/d_ino in fallthrus David Howells
` (21 subsequent siblings)
76 siblings, 0 replies; 79+ messages in thread
From: David Howells @ 2011-06-17 16:08 UTC (permalink / raw)
To: linux-fsdevel; +Cc: hch
From: Valerie Aurora <vaurora@redhat.com>
In readdir(), client file systems need to lookup the target of a
fallthru in a lower layer for three reasons: (1) fill in d_ino, (2)
fill in d_type, (2) make sure there is something to fall through to
(and if not, don't return this dentry). Create a generic helper
function.
---
fs/union.c | 53 ++++++++++++++++++++++++++++++++++++++++++++++++++++
fs/union.h | 3 +++
include/linux/fs.h | 15 +++++++++++++++
3 files changed, 71 insertions(+), 0 deletions(-)
diff --git a/fs/union.c b/fs/union.c
index 430b1b4..68a52ee 100644
--- a/fs/union.c
+++ b/fs/union.c
@@ -385,3 +385,56 @@ out_fput:
mnt_drop_write(topmost_path->mnt);
return error;
}
+
+/* Relationship between i_mode and the DT_xxx types */
+static inline unsigned char dt_type(struct inode *inode)
+{
+ return (inode->i_mode >> 12) & 15;
+}
+
+/**
+ * generic_readdir_fallthru - Helper to lookup target of a fallthru
+ * @topmost_dentry: dentry for the topmost dentry of the dir being read
+ * @name: name of fallthru dirent
+ * @namelen: length of @name
+ * @ino: return inode number of target, if found
+ * @d_type: return directory type of target, if found
+ *
+ * In readdir(), client file systems need to lookup the target of a
+ * fallthru in a lower layer for three reasons: (1) fill in d_ino, (2)
+ * fill in d_type, (2) make sure there is something to fall through to
+ * (and if not, don't return this dentry). Upon detecting a fallthru
+ * dentry in readdir(), the client file system should call this function.
+ *
+ * Returns 0 on success and -ENOENT if no matching directory entry was
+ * found (which can happen when the topmost file system is unmounted
+ * and remounted over a different file system than). Any other errors
+ * are unexpected.
+ */
+int generic_readdir_fallthru(struct dentry *topmost_dentry, const char *name,
+ int namlen, ino_t *ino, unsigned char *d_type)
+{
+ struct path *parent;
+ struct dentry *dentry;
+ unsigned int i, layers = topmost_dentry->d_sb->s_union_count;
+
+ BUG_ON(!mutex_is_locked(&topmost_dentry->d_inode->i_mutex));
+
+ for (i = 0; i < layers; i++) {
+ parent = union_find_dir(topmost_dentry, i);
+ mutex_lock(&parent->dentry->d_inode->i_mutex);
+ dentry = lookup_one_len(name, parent->dentry, namlen);
+ mutex_unlock(&parent->dentry->d_inode->i_mutex);
+ if (IS_ERR(dentry))
+ return PTR_ERR(dentry);
+ if (dentry->d_inode) {
+ *ino = dentry->d_inode->i_ino;
+ *d_type = dt_type(dentry->d_inode);
+ dput(dentry);
+ return 0;
+ }
+ dput(dentry);
+ }
+ return -ENOENT;
+}
+EXPORT_SYMBOL(generic_readdir_fallthru);
diff --git a/fs/union.h b/fs/union.h
index 8ee4ad6..c5e0d42 100644
--- a/fs/union.h
+++ b/fs/union.h
@@ -57,6 +57,8 @@ extern int union_add_dir(struct path *, struct path *, unsigned int);
extern int union_create_topmost_dir(struct path *, struct qstr *, struct path *,
struct path *);
extern int union_copyup_dir(struct path *);
+extern int generic_readdir_fallthru(struct dentry *topmost_dentry, const char *name,
+ int namlen, ino_t *ino, unsigned char *d_type);
static inline
struct path *union_find_dir(struct dentry *dentry, unsigned int layer)
@@ -92,6 +94,7 @@ int needs_lookup_union(struct path *parent_path, struct path *path)
#define union_create_topmost_dir(w, x, y, z) ({ BUG(); (0); })
#define needs_lookup_union(x, y) ({ (0); })
#define union_copyup_dir(x) ({ BUG(); (0); })
+#define generic_readdir_fallthru(w, x, y, z) ({ BUG(); (0); })
#endif /* CONFIG_UNION_MOUNT */
#endif /* __KERNEL__ */
diff --git a/include/linux/fs.h b/include/linux/fs.h
index 918946f..4065898 100644
--- a/include/linux/fs.h
+++ b/include/linux/fs.h
@@ -2500,6 +2500,21 @@ extern int generic_file_fsync(struct file *, int);
extern int generic_check_addressable(unsigned, u64);
+#ifdef CONFIG_UNION_MOUNT
+extern int generic_readdir_fallthru(struct dentry *topmost_dentry, const char *name,
+ int namlen, ino_t *ino, unsigned char *d_type);
+#else
+static inline int generic_readdir_fallthru(struct dentry *topmost_dentry, const char *name,
+ int namlen, ino_t *ino, unsigned char *d_type)
+{
+ /*
+ * Found a fallthru on a kernel without union support.
+ * There's nothing to fall through to, so return -ENOENT.
+ */
+ return -ENOENT;
+}
+#endif
+
#ifdef CONFIG_MIGRATION
extern int buffer_migrate_page(struct address_space *,
struct page *, struct page *);
^ permalink raw reply related [flat|nested] 79+ messages in thread* [PATCH 56/76] fallthru: ext2 support for lookup of d_type/d_ino in fallthrus
2011-06-17 16:00 [RFC][PATCH 00/76] Union Mount David Howells
` (54 preceding siblings ...)
2011-06-17 16:08 ` [PATCH 55/76] union-mount: Add generic_readdir_fallthru() helper David Howells
@ 2011-06-17 16:08 ` David Howells
2011-06-17 16:08 ` [PATCH 57/76] fallthru: tmpfs " David Howells
` (20 subsequent siblings)
76 siblings, 0 replies; 79+ messages in thread
From: David Howells @ 2011-06-17 16:08 UTC (permalink / raw)
To: linux-fsdevel; +Cc: hch
From: Valerie Aurora <vaurora@redhat.com>
Now that we have full union lookup support, lookup the true d_type and
d_ino of a fallthru.
---
fs/ext2/dir.c | 20 +++++++++++++-------
1 files changed, 13 insertions(+), 7 deletions(-)
diff --git a/fs/ext2/dir.c b/fs/ext2/dir.c
index 0a95eea..be6e397 100644
--- a/fs/ext2/dir.c
+++ b/fs/ext2/dir.c
@@ -361,15 +361,21 @@ ext2_readdir (struct file * filp, void * dirent, filldir_t filldir)
}
} else if (de->file_type == EXT2_FT_FALLTHRU) {
int over;
+ unsigned char d_type = DT_UNKNOWN;
+ ino_t ino;
+ int err;
offset = (char *)de - kaddr;
- /* XXX placeholder until generic_readdir_fallthru() arrives */
- over = filldir(dirent, de->name, de->name_len,
- (n<<PAGE_CACHE_SHIFT) | offset,
- 1, DT_UNKNOWN); /* XXX */
- if (over) {
- ext2_put_page(page);
- return 0;
+ err = generic_readdir_fallthru(filp->f_path.dentry, de->name,
+ de->name_len, &ino, &d_type);
+ if (!err) {
+ over = filldir(dirent, de->name, de->name_len,
+ (n<<PAGE_CACHE_SHIFT) | offset,
+ ino, d_type);
+ if (over) {
+ ext2_put_page(page);
+ return 0;
+ }
}
}
filp->f_pos += ext2_rec_len_from_disk(de->rec_len);
^ permalink raw reply related [flat|nested] 79+ messages in thread* [PATCH 57/76] fallthru: tmpfs support for lookup of d_type/d_ino in fallthrus
2011-06-17 16:00 [RFC][PATCH 00/76] Union Mount David Howells
` (55 preceding siblings ...)
2011-06-17 16:08 ` [PATCH 56/76] fallthru: ext2 support for lookup of d_type/d_ino in fallthrus David Howells
@ 2011-06-17 16:08 ` David Howells
2011-06-17 16:08 ` [PATCH 58/76] fallthru: jffs2 " David Howells
` (19 subsequent siblings)
76 siblings, 0 replies; 79+ messages in thread
From: David Howells @ 2011-06-17 16:08 UTC (permalink / raw)
To: linux-fsdevel; +Cc: hch
From: Valerie Aurora <vaurora@redhat.com>
Now that we have full union lookup support, lookup the true d_type and
d_ino of a fallthru.
Cc: Hugh Dickins <hughd@google.com>
Cc: linux-mm@kvack.org
---
fs/libfs.c | 11 ++++++++---
1 files changed, 8 insertions(+), 3 deletions(-)
diff --git a/fs/libfs.c b/fs/libfs.c
index ce46b8e..05f40d0 100644
--- a/fs/libfs.c
+++ b/fs/libfs.c
@@ -141,6 +141,7 @@ int dcache_readdir(struct file * filp, void * dirent, filldir_t filldir)
ino_t ino;
char d_type;
int i = filp->f_pos;
+ int err = 0;
switch (i) {
case 0:
@@ -175,9 +176,13 @@ int dcache_readdir(struct file * filp, void * dirent, filldir_t filldir)
spin_unlock(&next->d_lock);
spin_unlock(&dentry->d_lock);
if (d_is_fallthru(next)) {
- /* XXX placeholder until generic_readdir_fallthru() arrives */
- ino = 1;
- d_type = DT_UNKNOWN;
+ /* On tmpfs, should only fail with ENOMEM, EIO, etc. */
+ err = generic_readdir_fallthru(filp->f_path.dentry,
+ next->d_name.name,
+ next->d_name.len,
+ &ino, &d_type);
+ if (err)
+ return err;
} else {
ino = next->d_inode->i_ino;
d_type = dt_type(next->d_inode);
^ permalink raw reply related [flat|nested] 79+ messages in thread* [PATCH 58/76] fallthru: jffs2 support for lookup of d_type/d_ino in fallthrus
2011-06-17 16:00 [RFC][PATCH 00/76] Union Mount David Howells
` (56 preceding siblings ...)
2011-06-17 16:08 ` [PATCH 57/76] fallthru: tmpfs " David Howells
@ 2011-06-17 16:08 ` David Howells
2011-06-17 16:08 ` [PATCH 59/76] VFS: Split inode_permission() and create path_permission() David Howells
` (18 subsequent siblings)
76 siblings, 0 replies; 79+ messages in thread
From: David Howells @ 2011-06-17 16:08 UTC (permalink / raw)
To: linux-fsdevel; +Cc: hch
From: Valerie Aurora <vaurora@redhat.com>
Now that we have full union lookup support, lookup the true d_type and
d_ino of a fallthru.
---
fs/jffs2/dir.c | 11 ++++++++---
1 files changed, 8 insertions(+), 3 deletions(-)
diff --git a/fs/jffs2/dir.c b/fs/jffs2/dir.c
index 5f79789..3ff82b7 100644
--- a/fs/jffs2/dir.c
+++ b/fs/jffs2/dir.c
@@ -170,9 +170,14 @@ static int jffs2_readdir(struct file *filp, void *dirent, filldir_t filldir)
continue;
}
if (fd->type == JFFS2_DT_FALLTHRU) {
- /* XXX placeholder until generic_readdir_fallthru() arrives */
- ino = 1;
- d_type = DT_UNKNOWN;
+ int err;
+ err = generic_readdir_fallthru(filp->f_path.dentry, fd->name, strlen(fd->name),
+ &ino, &d_type);
+ if (err) {
+ D2(printk(KERN_DEBUG "Skipping fallthru dirent \"%s\"\n", fd->name));
+ offset++;
+ continue;
+ }
} else if (!fd->ino && (fd->type != DT_WHT)) {
D2(printk(KERN_DEBUG "Skipping deletion dirent \"%s\"\n", fd->name));
offset++;
^ permalink raw reply related [flat|nested] 79+ messages in thread* [PATCH 59/76] VFS: Split inode_permission() and create path_permission()
2011-06-17 16:00 [RFC][PATCH 00/76] Union Mount David Howells
` (57 preceding siblings ...)
2011-06-17 16:08 ` [PATCH 58/76] fallthru: jffs2 " David Howells
@ 2011-06-17 16:08 ` David Howells
2011-06-17 16:09 ` [PATCH 60/76] VFS: Create user_path_nd() to lookup both parent and target David Howells
` (17 subsequent siblings)
76 siblings, 0 replies; 79+ messages in thread
From: David Howells @ 2011-06-17 16:08 UTC (permalink / raw)
To: linux-fsdevel; +Cc: hch
From: Valerie Aurora <vaurora@redhat.com>
Split inode_permission() into inode and file-system-dependent parts.
Create path_permission() to check permission based on the path to the
inode. This is for union mounts, in which an inode can be located on
a read-only lower layer file system but is still writable, since we
will copy it up to the writable top layer file system. So in that
case, we want to ignore MS_RDONLY on the lower layer. To make this
decision, we must know the path (vfsmount, dentry) of both the target
and its parent.
XXX - so ugly!
---
fs/namei.c | 91 ++++++++++++++++++++++++++++++++++++++++++++--------
include/linux/fs.h | 1 +
2 files changed, 78 insertions(+), 14 deletions(-)
diff --git a/fs/namei.c b/fs/namei.c
index 199d385..ce681ca 100644
--- a/fs/namei.c
+++ b/fs/namei.c
@@ -258,29 +258,20 @@ int generic_permission(struct inode *inode, int mask, unsigned int flags,
}
/**
- * inode_permission - check for access rights to a given inode
+ * __inode_permission - check for access rights to a given inode
* @inode: inode to check permission on
* @mask: right to check for (%MAY_READ, %MAY_WRITE, %MAY_EXEC)
*
* Used to check for read/write/execute permissions on an inode.
- * We use "fsuid" for this, letting us set arbitrary permissions
- * for filesystem access without changing the "normal" uids which
- * are used for other things.
+ *
+ * This does not check for a read-only file system. You probably want
+ * inode_permission().
*/
-int inode_permission(struct inode *inode, int mask)
+static int __inode_permission(struct inode *inode, int mask)
{
int retval;
if (mask & MAY_WRITE) {
- umode_t mode = inode->i_mode;
-
- /*
- * Nobody gets write access to a read-only fs.
- */
- if (IS_RDONLY(inode) &&
- (S_ISREG(mode) || S_ISDIR(mode) || S_ISLNK(mode)))
- return -EROFS;
-
/*
* Nobody gets write access to an immutable file.
*/
@@ -305,6 +296,78 @@ int inode_permission(struct inode *inode, int mask)
}
/**
+ * sb_permission - check superblock-level permissions
+ * @sb: superblock of inode to check permission on
+ * @mask: right to check for (%MAY_READ, %MAY_WRITE, %MAY_EXEC)
+ *
+ * Separate out file-system wide checks from inode-specific permission
+ * checks. In particular, union mounts want to check the read-only
+ * status of the top-level file system, not the lower.
+ */
+int sb_permission(struct super_block *sb, struct inode *inode, int mask)
+{
+ if (mask & MAY_WRITE) {
+ umode_t mode = inode->i_mode;
+
+ /*
+ * Nobody gets write access to a read-only fs.
+ */
+ if ((sb->s_flags & MS_RDONLY) &&
+ (S_ISREG(mode) || S_ISDIR(mode) || S_ISLNK(mode)))
+ return -EROFS;
+ }
+ return 0;
+}
+
+/**
+ * inode_permission - check for access rights to a given inode
+ * @inode: inode to check permission on
+ * @mask: right to check for (%MAY_READ, %MAY_WRITE, %MAY_EXEC)
+ *
+ * Used to check for read/write/execute permissions on an inode.
+ * We use "fsuid" for this, letting us set arbitrary permissions
+ * for filesystem access without changing the "normal" uids which
+ * are used for other things.
+ */
+int inode_permission(struct inode *inode, int mask)
+{
+ int retval;
+
+ retval = sb_permission(inode->i_sb, inode, mask);
+ if (retval)
+ return retval;
+ return __inode_permission(inode, mask);
+}
+
+/**
+ * path_permission - check for inode access rights depending on path
+ * @path: path of inode to check
+ * @parent_path: path of inode's parent
+ * @mask: right to check for (%MAY_READ, %MAY_WRITE, %MAY_EXEC)
+ *
+ * Like inode_permission, but used to check for permission when the
+ * file may potentially be copied up between union layers.
+ */
+int path_permission(struct path *path, struct path *parent_path, int mask)
+{
+ struct vfsmount *mnt;
+ int retval;
+
+ /* Catch some reversal of args */
+ BUG_ON(!S_ISDIR(parent_path->dentry->d_inode->i_mode));
+
+ if (IS_MNT_UNION(parent_path->mnt))
+ mnt = parent_path->mnt;
+ else
+ mnt = path->mnt;
+
+ retval = sb_permission(mnt->mnt_sb, path->dentry->d_inode, mask);
+ if (retval)
+ return retval;
+ return __inode_permission(path->dentry->d_inode, mask);
+}
+
+/**
* file_permission - check for additional access rights to a given file
* @file: file to check access rights for
* @mask: right to check for (%MAY_READ, %MAY_WRITE, %MAY_EXEC)
diff --git a/include/linux/fs.h b/include/linux/fs.h
index 4065898..3665799 100644
--- a/include/linux/fs.h
+++ b/include/linux/fs.h
@@ -2217,6 +2217,7 @@ extern int notify_change(struct dentry *, struct iattr *);
extern int inode_permission(struct inode *, int);
extern int generic_permission(struct inode *, int, unsigned int,
int (*check_acl)(struct inode *, int, unsigned int));
+extern int path_permission(struct path *, struct path *, int);
static inline bool execute_ok(struct inode *inode)
{
^ permalink raw reply related [flat|nested] 79+ messages in thread* [PATCH 60/76] VFS: Create user_path_nd() to lookup both parent and target
2011-06-17 16:00 [RFC][PATCH 00/76] Union Mount David Howells
` (58 preceding siblings ...)
2011-06-17 16:08 ` [PATCH 59/76] VFS: Split inode_permission() and create path_permission() David Howells
@ 2011-06-17 16:09 ` David Howells
2011-06-17 16:09 ` [PATCH 61/76] union-mount: In-kernel file copyup routines David Howells
` (16 subsequent siblings)
76 siblings, 0 replies; 79+ messages in thread
From: David Howells @ 2011-06-17 16:09 UTC (permalink / raw)
To: linux-fsdevel; +Cc: hch
From: Valerie Aurora <vaurora@redhat.com>
Proof-of-concept implementation of user_path_nd(). Lookup both the
parent and the target of a user-supplied filename, to supply later to
union copyup routines.
XXX - Inefficient, racy, gets the parent of the symlink instead of the
parent of the target. Al Viro would like to see something more like
this:
user_path_mumble() looks up and returns:
parent nameidata
positive topmost dentry of target
negative dentry of target from the topmost layer (if it doesn't exist on top)
Both the positive lower dentry and negative topmost dentry are passed
to the following code, like do_chown(). The tests for permissions and
such-like are performed on the positive lower dentry. When it comes
time to actually modify the target, we call union_copyup() with both
positive and negative dentries (and the parent nameidata).
---
fs/namei.c | 31 +++++++++++++++++++++++++++++++
include/linux/namei.h | 2 ++
2 files changed, 33 insertions(+), 0 deletions(-)
diff --git a/fs/namei.c b/fs/namei.c
index ce681ca..fafd352 100644
--- a/fs/namei.c
+++ b/fs/namei.c
@@ -2190,6 +2190,37 @@ static int user_path_parent(int dfd, const char __user *path,
return error;
}
+int user_path_nd(int dfd, const char __user *filename,
+ unsigned flags, struct nameidata *parent_nd,
+ struct path *child, char **tmp)
+{
+ struct nameidata child_nd;
+ char *s = getname(filename);
+ int error;
+
+ if (IS_ERR(s))
+ return PTR_ERR(s);
+
+ /* Lookup parent */
+ error = do_path_lookup(dfd, s, LOOKUP_PARENT, parent_nd);
+ if (error)
+ goto out_putname;
+
+ /* Lookup child - XXX optimize, racy */
+ error = do_path_lookup(dfd, s, flags, &child_nd);
+ if (error)
+ goto out_path_put;
+ *child = child_nd.path;
+ *tmp = s;
+ return 0;
+
+out_path_put:
+ path_put(&parent_nd->path);
+out_putname:
+ putname(s);
+ return error;
+}
+
/*
* It's inline, so penalty for filesystems that don't use sticky bit is
* minimal.
diff --git a/include/linux/namei.h b/include/linux/namei.h
index eba45ea..c32c987 100644
--- a/include/linux/namei.h
+++ b/include/linux/namei.h
@@ -67,6 +67,8 @@ enum {LAST_NORM, LAST_ROOT, LAST_DOT, LAST_DOTDOT, LAST_BIND};
#define LOOKUP_EMPTY 0x4000
extern int user_path_at(int, const char __user *, unsigned, struct path *);
+extern int user_path_nd(int, const char __user *, unsigned,
+ struct nameidata *, struct path *, char **);
#define user_path(name, path) user_path_at(AT_FDCWD, name, LOOKUP_FOLLOW, path)
#define user_lpath(name, path) user_path_at(AT_FDCWD, name, 0, path)
^ permalink raw reply related [flat|nested] 79+ messages in thread* [PATCH 61/76] union-mount: In-kernel file copyup routines
2011-06-17 16:00 [RFC][PATCH 00/76] Union Mount David Howells
` (59 preceding siblings ...)
2011-06-17 16:09 ` [PATCH 60/76] VFS: Create user_path_nd() to lookup both parent and target David Howells
@ 2011-06-17 16:09 ` David Howells
2011-06-17 16:09 ` [PATCH 62/76] union-mount: Implement union-aware access()/faccessat() David Howells
` (15 subsequent siblings)
76 siblings, 0 replies; 79+ messages in thread
From: David Howells @ 2011-06-17 16:09 UTC (permalink / raw)
To: linux-fsdevel; +Cc: hch
From: Valerie Aurora <vaurora@redhat.com>
When a file on the read-only layer of a union mount is altered, it
must be copied up to the topmost read-write layer. This patch creates
union_copyup() and its supporting routines.
Thanks to Valdis Kletnieks <Valdis.Kletnieks@vt.edu> for a bug fix.
XXX - split up
XXX - If dir xattr copyup fails, delete the newly created dir
XXX - set correct owner after copyup
XXX - reimplement with get_unlinked_inode()
---
fs/union.c | 247 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
fs/union.h | 6 +
2 files changed, 252 insertions(+), 1 deletions(-)
diff --git a/fs/union.c b/fs/union.c
index 68a52ee..34e9709 100644
--- a/fs/union.c
+++ b/fs/union.c
@@ -24,6 +24,8 @@
#include <linux/xattr.h>
#include <linux/file.h>
#include <linux/security.h>
+#include <linux/splice.h>
+#include <linux/xattr.h>
#include "union.h"
@@ -196,9 +198,16 @@ int union_create_topmost_dir(struct path *parent, struct qstr *name,
error = union_copyup_xattr(lower->dentry, topmost->dentry);
if (error)
- dput(topmost->dentry);
+ goto out_rmdir;
fsnotify_mkdir(dir, topmost->dentry);
+
+ mnt_drop_write(parent->mnt);
+
+ return 0;
+out_rmdir:
+ /* XXX rm created dir */
+ dput(topmost->dentry);
out:
mnt_drop_write(parent->mnt);
return error;
@@ -438,3 +447,239 @@ int generic_readdir_fallthru(struct dentry *topmost_dentry, const char *name,
return -ENOENT;
}
EXPORT_SYMBOL(generic_readdir_fallthru);
+
+/**
+ * union_create_file
+ * @nd: namediata for source file
+ * @old: path of the source file
+ * @new: path of the new file, negative dentry
+ *
+ * Must already have mnt_want_write() on the mnt and the parent's i_mutex.
+ */
+static int union_create_file(struct nameidata *nd, struct path *old,
+ struct dentry *new)
+{
+ struct path *parent = &nd->path;
+ BUG_ON(!mutex_is_locked(&parent->dentry->d_inode->i_mutex));
+
+ return vfs_create(parent->dentry->d_inode, new,
+ old->dentry->d_inode->i_mode, nd);
+}
+
+/**
+ * union_create_symlink
+ * @nd: namediata for source symlink
+ * @old: path of the source symlink
+ * @new: path of the new symlink, negative dentry
+ *
+ * Must already have mnt_want_write() on the mnt and the parent's i_mutex.
+ */
+static int union_create_symlink(struct nameidata *nd, struct path *old,
+ struct dentry *new)
+{
+ void *cookie;
+ int error;
+
+ BUG_ON(!mutex_is_locked(&nd->path.dentry->d_inode->i_mutex));
+ /*
+ * We want the contents of this symlink, not to follow it, so
+ * this is modeled on generic_readlink() rather than
+ * do_follow_link().
+ */
+ nd->depth = 0;
+ cookie = old->dentry->d_inode->i_op->follow_link(old->dentry, nd);
+ if (IS_ERR(cookie))
+ return PTR_ERR(cookie);
+ /* Create a copy of the link on the top layer */
+ error = vfs_symlink(nd->path.dentry->d_inode, new,
+ nd_get_link(nd));
+ if (old->dentry->d_inode->i_op->put_link)
+ old->dentry->d_inode->i_op->put_link(old->dentry, nd, cookie);
+ return error;
+}
+
+/**
+ * union_copyup_data - Copy up len bytes of old's data to new
+ * @old: path of source file
+ * @new_mnt: vfsmount of target file
+ * @new_dentry: dentry of target file
+ * @len: number of bytes to copy
+ */
+static int union_copyup_data(struct path *old, struct vfsmount *new_mnt,
+ struct dentry *new_dentry, size_t len)
+{
+ struct file *old_file;
+ struct file *new_file;
+ const struct cred *cred = current_cred();
+ loff_t offset = 0;
+ long bytes;
+ int error = 0;
+
+ if (len == 0)
+ return 0;
+
+ /* Get reference to balance later fput() */
+ path_get(old);
+ old_file = dentry_open(old->dentry, old->mnt, O_RDONLY, cred);
+ if (IS_ERR(old_file))
+ return PTR_ERR(old_file);
+
+ mntget(new_mnt);
+ dget(new_dentry);
+ new_file = dentry_open(new_dentry, new_mnt, O_WRONLY, cred);
+ if (IS_ERR(new_file)) {
+ error = PTR_ERR(new_file);
+ goto out_fput;
+ }
+
+ bytes = do_splice_direct(old_file, &offset, new_file, len,
+ SPLICE_F_MOVE);
+ if (bytes < 0)
+ error = bytes;
+
+ fput(new_file);
+out_fput:
+ fput(old_file);
+ return error;
+}
+
+/**
+ * __union_copyup_len - Copy up a file and len bytes of data
+ * @nd: nameidata for topmost parent dir
+ * @path: path of file to be copied up
+ * @len: number of bytes of file data to copy up
+ *
+ * Parent's i_mutex must be held by caller. Newly copied up path is
+ * returned in @path and original is path_put().
+ */
+static int __union_copyup_len(struct nameidata *nd, struct path *path,
+ size_t len)
+{
+ struct path *parent = &nd->path;
+ struct dentry *dentry;
+ int error;
+
+ BUG_ON(!mutex_is_locked(&parent->dentry->d_inode->i_mutex));
+
+ dentry = lookup_one_len(path->dentry->d_name.name, parent->dentry,
+ path->dentry->d_name.len);
+ if (IS_ERR(dentry))
+ return PTR_ERR(dentry);
+
+ if (dentry->d_inode) {
+ /*
+ * We raced with someone else and "lost." That's
+ * okay, they did all the work of copying up the file.
+ * Note that currently data copyup happens under the
+ * parent dir's i_mutex. If we move it outside that,
+ * we'll need some way of waiting for the data copyup
+ * to complete here.
+ */
+ error = 0;
+ goto out_newpath;
+ }
+ if (S_ISREG(path->dentry->d_inode->i_mode)) {
+ /* Create file */
+ error = union_create_file(nd, path, dentry);
+ if (error)
+ goto out_dput;
+ /* Copyup data */
+ error = union_copyup_data(path, parent->mnt, dentry, len);
+ } else {
+ BUG_ON(!S_ISLNK(path->dentry->d_inode->i_mode));
+ error = union_create_symlink(nd, path, dentry);
+ }
+ if (error) {
+ /* Most likely error: ENOSPC */
+ vfs_unlink(parent->dentry->d_inode, dentry);
+ goto out_dput;
+ }
+ /* XXX Copyup xattrs and any other dangly bits */
+ error = union_copyup_xattr(path->dentry, dentry);
+ if (error)
+ goto out_dput;
+out_newpath:
+ /* path_put() of original must happen before we copy in new */
+ path_put(path);
+ path->dentry = dentry;
+ path->mnt = mntget(parent->mnt);
+ return error;
+out_dput:
+ /* Don't path_put(path), let caller unwind */
+ dput(dentry);
+ return error;
+}
+
+/**
+ * do_union_copyup_len - Copy up a file given its path (and its parent's)
+ * @nd: nameidata for topmost parent dir
+ * @path: path of file to be copied up
+ * @copy_all: if set, copy all of the file's data and ignore @len
+ * @len: if @copy_all is not set, number of bytes of file data to copy up
+ *
+ * Newly copied up path is returned in @path.
+ */
+static int do_union_copyup_len(struct nameidata *nd, struct path *path,
+ int copy_all, size_t len)
+{
+ struct path *parent = &nd->path;
+ int error;
+
+ if (!IS_DIR_UNIONED(parent->dentry))
+ return 0;
+ if (parent->mnt == path->mnt)
+ return 0;
+ if (!S_ISREG(path->dentry->d_inode->i_mode) &&
+ !S_ISLNK(path->dentry->d_inode->i_mode))
+ return 0;
+
+ BUG_ON(!S_ISDIR(parent->dentry->d_inode->i_mode));
+
+ mutex_lock(&parent->dentry->d_inode->i_mutex);
+ error = -ENOENT;
+ if (IS_DEADDIR(parent->dentry->d_inode))
+ goto out_unlock;
+
+ if (copy_all && S_ISREG(path->dentry->d_inode->i_mode)) {
+ error = -EFBIG;
+ len = i_size_read(path->dentry->d_inode);
+ /* Check for overflow of file size */
+ if (((size_t)len != len) || ((ssize_t)len != len))
+ goto out_unlock;
+ }
+
+ error = __union_copyup_len(nd, path, len);
+
+out_unlock:
+ mutex_unlock(&parent->dentry->d_inode->i_mutex);
+ return error;
+}
+
+/*
+ * Helper function to copy up all of a file
+ */
+int union_copyup(struct nameidata *nd, struct path *path)
+{
+ return do_union_copyup_len(nd, path, 1, 0);
+}
+
+/*
+ * Unlocked helper function to copy up all of a file
+ */
+int __union_copyup(struct nameidata *nd, struct path *path)
+{
+ loff_t len;
+ len = i_size_read(path->dentry->d_inode);
+ if (((size_t)len != len) || ((ssize_t)len != len))
+ return -EFBIG;
+
+ return __union_copyup_len(nd, path, len);
+}
+
+/*
+ * Helper function to copy up part of a file
+ */
+int union_copyup_len(struct nameidata *nd, struct path *path, size_t len)
+{
+ return do_union_copyup_len(nd, path, 0, len);
+}
diff --git a/fs/union.h b/fs/union.h
index c5e0d42..b0c0a56 100644
--- a/fs/union.h
+++ b/fs/union.h
@@ -59,6 +59,9 @@ extern int union_create_topmost_dir(struct path *, struct qstr *, struct path *,
extern int union_copyup_dir(struct path *);
extern int generic_readdir_fallthru(struct dentry *topmost_dentry, const char *name,
int namlen, ino_t *ino, unsigned char *d_type);
+extern int union_copyup(struct nameidata *, struct path *);
+extern int __union_copyup(struct nameidata *, struct path *);
+extern int union_copyup_len(struct nameidata *, struct path *, size_t len);
static inline
struct path *union_find_dir(struct dentry *dentry, unsigned int layer)
@@ -95,6 +98,9 @@ int needs_lookup_union(struct path *parent_path, struct path *path)
#define needs_lookup_union(x, y) ({ (0); })
#define union_copyup_dir(x) ({ BUG(); (0); })
#define generic_readdir_fallthru(w, x, y, z) ({ BUG(); (0); })
+#define union_copyup(x, y) ({ BUG(); (0); })
+#define __union_copyup(x, y) ({ BUG(); (0); })
+#define union_copyup_len(x, y, z) ({ BUG(); (0); })
#endif /* CONFIG_UNION_MOUNT */
#endif /* __KERNEL__ */
^ permalink raw reply related [flat|nested] 79+ messages in thread* [PATCH 62/76] union-mount: Implement union-aware access()/faccessat()
2011-06-17 16:00 [RFC][PATCH 00/76] Union Mount David Howells
` (60 preceding siblings ...)
2011-06-17 16:09 ` [PATCH 61/76] union-mount: In-kernel file copyup routines David Howells
@ 2011-06-17 16:09 ` David Howells
2011-06-17 16:09 ` [PATCH 63/76] union-mount: Implement union-aware link() David Howells
` (14 subsequent siblings)
76 siblings, 0 replies; 79+ messages in thread
From: David Howells @ 2011-06-17 16:09 UTC (permalink / raw)
To: linux-fsdevel; +Cc: hch
From: Valerie Aurora <vaurora@redhat.com>
For union mounts, a file located on the lower layer will incorrectly
return EROFS on an access check. To fix this, use the new
path_permission() call, which ignores a read-only lower layer file
system if the target will be copied up to the topmost file system.
---
fs/open.c | 21 +++++++++++++++++----
1 files changed, 17 insertions(+), 4 deletions(-)
diff --git a/fs/open.c b/fs/open.c
index b52cf01..0407f4c 100644
--- a/fs/open.c
+++ b/fs/open.c
@@ -32,6 +32,7 @@
#include <linux/dnotify.h>
#include "internal.h"
+#include "union.h"
int do_truncate(struct dentry *dentry, loff_t length, unsigned int time_attrs,
struct file *filp)
@@ -301,7 +302,10 @@ SYSCALL_DEFINE3(faccessat, int, dfd, const char __user *, filename, int, mode)
const struct cred *old_cred;
struct cred *override_cred;
struct path path;
+ struct nameidata nd;
+ struct vfsmount *mnt;
struct inode *inode;
+ char *tmp;
int res;
if (mode & ~S_IRWXO) /* where's F_OK, X_OK, W_OK, R_OK? */
@@ -325,10 +329,17 @@ SYSCALL_DEFINE3(faccessat, int, dfd, const char __user *, filename, int, mode)
old_cred = override_creds(override_cred);
- res = user_path_at(dfd, filename, LOOKUP_FOLLOW, &path);
+ res = user_path_nd(dfd, filename, LOOKUP_FOLLOW,
+ &nd, &path, &tmp);
if (res)
goto out;
+ /* For union mounts, use the topmost mnt's permissions */
+ if (IS_DIR_UNIONED(nd.path.dentry))
+ mnt = nd.path.mnt;
+ else
+ mnt = path.mnt;
+
inode = path.dentry->d_inode;
if ((mode & MAY_EXEC) && S_ISREG(inode->i_mode)) {
@@ -337,11 +348,11 @@ SYSCALL_DEFINE3(faccessat, int, dfd, const char __user *, filename, int, mode)
* with the "noexec" flag.
*/
res = -EACCES;
- if (path.mnt->mnt_flags & MNT_NOEXEC)
+ if (mnt->mnt_flags & MNT_NOEXEC)
goto out_path_release;
}
- res = inode_permission(inode, mode | MAY_ACCESS);
+ res = path_permission(&path, &nd.path, mode | MAY_ACCESS);
/* SuS v2 requires we report a read only fs too */
if (res || !(mode & S_IWOTH) || special_file(inode->i_mode))
goto out_path_release;
@@ -355,11 +366,13 @@ SYSCALL_DEFINE3(faccessat, int, dfd, const char __user *, filename, int, mode)
* inherently racy and know that the fs may change
* state before we even see this result.
*/
- if (__mnt_is_readonly(path.mnt))
+ if (__mnt_is_readonly(mnt))
res = -EROFS;
out_path_release:
path_put(&path);
+ path_put(&nd.path);
+ putname(tmp);
out:
revert_creds(old_cred);
put_cred(override_cred);
^ permalink raw reply related [flat|nested] 79+ messages in thread* [PATCH 63/76] union-mount: Implement union-aware link()
2011-06-17 16:00 [RFC][PATCH 00/76] Union Mount David Howells
` (61 preceding siblings ...)
2011-06-17 16:09 ` [PATCH 62/76] union-mount: Implement union-aware access()/faccessat() David Howells
@ 2011-06-17 16:09 ` David Howells
2011-06-17 16:09 ` [PATCH 64/76] union-mount: Implement union-aware rename() David Howells
` (13 subsequent siblings)
76 siblings, 0 replies; 79+ messages in thread
From: David Howells @ 2011-06-17 16:09 UTC (permalink / raw)
To: linux-fsdevel; +Cc: hch
From: Valerie Aurora <vaurora@redhat.com>
---
fs/namei.c | 23 ++++++++++++++++++++---
1 files changed, 20 insertions(+), 3 deletions(-)
diff --git a/fs/namei.c b/fs/namei.c
index fafd352..2b4780a 100644
--- a/fs/namei.c
+++ b/fs/namei.c
@@ -3519,10 +3519,12 @@ SYSCALL_DEFINE5(linkat, int, olddfd, const char __user *, oldname,
{
struct dentry *new_dentry;
struct nameidata nd;
+ struct nameidata old_nd;
struct path old_path;
int how = 0;
int error;
char *to;
+ char *from;
if ((flags & ~(AT_SYMLINK_FOLLOW | AT_EMPTY_PATH)) != 0)
return -EINVAL;
@@ -3540,7 +3542,8 @@ SYSCALL_DEFINE5(linkat, int, olddfd, const char __user *, oldname,
if (flags & AT_SYMLINK_FOLLOW)
how |= LOOKUP_FOLLOW;
- error = user_path_at(olddfd, oldname, how, &old_path);
+ error = user_path_nd(olddfd, oldname, how,
+ &old_nd, &old_path, &from);
if (error)
return error;
@@ -3548,8 +3551,20 @@ SYSCALL_DEFINE5(linkat, int, olddfd, const char __user *, oldname,
if (error)
goto out;
error = -EXDEV;
- if (old_path.mnt != nd.path.mnt)
- goto out_release;
+ if (old_path.mnt != nd.path.mnt) {
+ if (IS_DIR_UNIONED(old_nd.path.dentry) &&
+ (old_nd.path.mnt == nd.path.mnt)) {
+ error = mnt_want_write(old_nd.path.mnt);
+ if (error)
+ goto out_release;
+ error = union_copyup(&old_nd, &old_path);
+ mnt_drop_write(old_nd.path.mnt);
+ if (error)
+ goto out_release;
+ } else {
+ goto out_release;
+ }
+ }
new_dentry = lookup_create(&nd, 0);
error = PTR_ERR(new_dentry);
if (IS_ERR(new_dentry))
@@ -3572,6 +3587,8 @@ out_release:
putname(to);
out:
path_put(&old_path);
+ path_put(&old_nd.path);
+ putname(from);
return error;
}
^ permalink raw reply related [flat|nested] 79+ messages in thread* [PATCH 64/76] union-mount: Implement union-aware rename()
2011-06-17 16:00 [RFC][PATCH 00/76] Union Mount David Howells
` (62 preceding siblings ...)
2011-06-17 16:09 ` [PATCH 63/76] union-mount: Implement union-aware link() David Howells
@ 2011-06-17 16:09 ` David Howells
2011-06-17 16:09 ` [PATCH 65/76] union-mount: Implement union-aware writable open() David Howells
` (12 subsequent siblings)
76 siblings, 0 replies; 79+ messages in thread
From: David Howells @ 2011-06-17 16:09 UTC (permalink / raw)
To: linux-fsdevel; +Cc: hch
From: Valerie Aurora <vaurora@redhat.com>
On rename() of a file on union mount, copyup and whiteout the source
file.
XXX - fix comments and make more readable
XXX - Convert newly empty unioned dirs to not-unioned
---
fs/namei.c | 75 ++++++++++++++++++++++++++++++++++++++++++++++++++++++------
1 files changed, 68 insertions(+), 7 deletions(-)
diff --git a/fs/namei.c b/fs/namei.c
index 2b4780a..b2548e9 100644
--- a/fs/namei.c
+++ b/fs/namei.c
@@ -3747,6 +3747,7 @@ SYSCALL_DEFINE4(renameat, int, olddfd, const char __user *, oldname,
{
struct dentry *old_dir, *new_dir;
struct path old, new;
+ struct path to_whiteout = {NULL, NULL};
struct dentry *trap;
struct nameidata oldnd, newnd;
char *from;
@@ -3764,13 +3765,6 @@ SYSCALL_DEFINE4(renameat, int, olddfd, const char __user *, oldname,
error = -EXDEV;
if (oldnd.path.mnt != newnd.path.mnt)
goto exit2;
-
- /* rename() on union mounts not implemented yet */
- error = -EXDEV;
- if (IS_DIR_UNIONED(oldnd.path.dentry) ||
- IS_DIR_UNIONED(newnd.path.dentry))
- goto exit2;
-
old_dir = oldnd.path.dentry;
error = -EBUSY;
if (oldnd.last_type != LAST_NORM)
@@ -3805,6 +3799,11 @@ SYSCALL_DEFINE4(renameat, int, olddfd, const char __user *, oldname,
error = -EINVAL;
if (old.dentry == trap)
goto exit4;
+ error = -EXDEV;
+ /* Can't rename a directory from a lower layer */
+ if (IS_DIR_UNIONED(oldnd.path.dentry) &&
+ IS_DIR_UNIONED(old.dentry))
+ goto exit4;
error = lookup_hash(&newnd, &newnd.last, &new);
if (error)
goto exit4;
@@ -3812,6 +3811,48 @@ SYSCALL_DEFINE4(renameat, int, olddfd, const char __user *, oldname,
error = -ENOTEMPTY;
if (new.dentry == trap)
goto exit5;
+ error = -EXDEV;
+ /* Can't rename over directories on the lower layer */
+ if (IS_DIR_UNIONED(newnd.path.dentry) &&
+ IS_DIR_UNIONED(new.dentry))
+ goto exit5;
+
+ /* If source is on lower layer, copy up */
+ if (IS_DIR_UNIONED(oldnd.path.dentry) &&
+ (old.mnt != oldnd.path.mnt)) {
+ /* Save the lower path to avoid a second lookup for whiteout */
+ to_whiteout.mnt = mntget(old.mnt);
+ to_whiteout.dentry = dget(old.dentry);
+ error = __union_copyup(&oldnd, &old);
+ if (error)
+ goto exit5;
+ }
+
+ /* If target is on lower layer, get negative dentry for topmost */
+ if (IS_DIR_UNIONED(newnd.path.dentry) &&
+ (new.mnt != newnd.path.mnt)) {
+ struct dentry *dentry;
+ /*
+ * At this point, source and target are both files,
+ * the source is on the topmost layer, and the target
+ * is on a lower layer. We want the target dentry to
+ * disappear from the namespace, and give vfs_rename a
+ * negative dentry from the topmost layer.
+ */
+ /* We already did lookup once, no need to check perm */
+ dentry = __lookup_hash(&newnd.last, newnd.path.dentry, &newnd);
+ if (IS_ERR(dentry)) {
+ error = PTR_ERR(dentry);
+ goto exit5;
+ }
+ /* We no longer need the lower target dentry. It
+ * definitely should be removed from the hash table */
+ /* XXX what about failure case? */
+ d_delete(new.dentry);
+ mntput(new.mnt);
+ new.mnt = mntget(newnd.path.mnt);
+ new.dentry = dentry;
+ }
error = mnt_want_write(oldnd.path.mnt);
if (error)
@@ -3822,6 +3863,26 @@ SYSCALL_DEFINE4(renameat, int, olddfd, const char __user *, oldname,
goto exit6;
error = vfs_rename(old_dir->d_inode, old.dentry,
new_dir->d_inode, new.dentry);
+ if (error)
+ goto exit6;
+ /* Now whiteout the source */
+ if (IS_DIR_UNIONED(oldnd.path.dentry)) {
+ if (!to_whiteout.dentry) {
+ struct dentry *dentry;
+ /* We could have exposed a lower level entry */
+ dentry = __lookup_hash(&oldnd.last, oldnd.path.dentry, &oldnd);
+ if (IS_ERR(dentry)) {
+ error = PTR_ERR(dentry);
+ goto exit6;
+ }
+ to_whiteout.dentry = dentry;
+ to_whiteout.mnt = mntget(oldnd.path.mnt);
+ }
+
+ if (to_whiteout.dentry->d_inode)
+ error = do_whiteout(&oldnd, &to_whiteout, 0);
+ path_put(&to_whiteout);
+ }
exit6:
mnt_drop_write(oldnd.path.mnt);
exit5:
^ permalink raw reply related [flat|nested] 79+ messages in thread* [PATCH 65/76] union-mount: Implement union-aware writable open()
2011-06-17 16:00 [RFC][PATCH 00/76] Union Mount David Howells
` (63 preceding siblings ...)
2011-06-17 16:09 ` [PATCH 64/76] union-mount: Implement union-aware rename() David Howells
@ 2011-06-17 16:09 ` David Howells
2011-06-17 16:09 ` [PATCH 66/76] union-mount: Implement union-aware chown() David Howells
` (11 subsequent siblings)
76 siblings, 0 replies; 79+ messages in thread
From: David Howells @ 2011-06-17 16:09 UTC (permalink / raw)
To: linux-fsdevel; +Cc: hch
From: Valerie Aurora <vaurora@redhat.com>
Copy up a file when opened with write permissions. Does not copy up
the file data when O_TRUNC is specified.
---
fs/namei.c | 31 +++++++++++++++++++++++++++++++
1 files changed, 31 insertions(+), 0 deletions(-)
diff --git a/fs/namei.c b/fs/namei.c
index b2548e9..d52b800 100644
--- a/fs/namei.c
+++ b/fs/namei.c
@@ -2473,6 +2473,24 @@ static inline int open_to_namei_flags(int flag)
return flag;
}
+static int open_union_copyup(struct nameidata *nd, struct path *path,
+ int open_flag)
+{
+ struct vfsmount *oldmnt = path->mnt;
+ int error;
+
+ if (open_flag & O_TRUNC)
+ error = union_copyup_len(nd, path, 0);
+ else
+ error = union_copyup(nd, path);
+ if (error)
+ return error;
+ if (oldmnt != path->mnt)
+ mntput(nd->path.mnt);
+
+ return error;
+}
+
/*
* Handle the last step of open()
*/
@@ -2538,6 +2556,13 @@ static struct file *do_last(struct nameidata *nd, struct path *path,
if (!nd->inode->i_op->lookup)
goto exit;
}
+
+ if (acc_mode & MAY_WRITE) {
+ error = open_union_copyup(nd, &nd->path, open_flag);
+ if (error)
+ goto exit;
+ }
+
audit_inode(pathname, nd->path.dentry);
goto ok;
}
@@ -2614,6 +2639,12 @@ static struct file *do_last(struct nameidata *nd, struct path *path,
if (path->dentry->d_inode->i_op->follow_link)
return NULL;
+ if (acc_mode & MAY_WRITE) {
+ error = open_union_copyup(nd, path, open_flag);
+ if (error)
+ goto exit_dput;
+ }
+
path_to_nameidata(path, nd);
nd->inode = path->dentry->d_inode;
error = -EISDIR;
^ permalink raw reply related [flat|nested] 79+ messages in thread* [PATCH 66/76] union-mount: Implement union-aware chown()
2011-06-17 16:00 [RFC][PATCH 00/76] Union Mount David Howells
` (64 preceding siblings ...)
2011-06-17 16:09 ` [PATCH 65/76] union-mount: Implement union-aware writable open() David Howells
@ 2011-06-17 16:09 ` David Howells
2011-06-17 16:10 ` [PATCH 67/76] union-mount: Implement union-aware truncate() David Howells
` (10 subsequent siblings)
76 siblings, 0 replies; 79+ messages in thread
From: David Howells @ 2011-06-17 16:09 UTC (permalink / raw)
To: linux-fsdevel; +Cc: hch
From: Valerie Aurora <vaurora@redhat.com>
---
fs/open.c | 23 ++++++++++++++++++++---
1 files changed, 20 insertions(+), 3 deletions(-)
diff --git a/fs/open.c b/fs/open.c
index 0407f4c..3909546 100644
--- a/fs/open.c
+++ b/fs/open.c
@@ -565,18 +565,35 @@ static int chown_common(struct path *path, uid_t user, gid_t group)
SYSCALL_DEFINE3(chown, const char __user *, filename, uid_t, user, gid_t, group)
{
struct path path;
+ struct nameidata nd;
+ struct vfsmount *mnt;
+ char *tmp;
int error;
- error = user_path(filename, &path);
+ error = user_path_nd(AT_FDCWD, filename, LOOKUP_FOLLOW,
+ &nd, &path, &tmp);
if (error)
goto out;
- error = mnt_want_write(path.mnt);
+
+ if (IS_DIR_UNIONED(nd.path.dentry))
+ mnt = nd.path.mnt;
+ else
+ mnt = path.mnt;
+
+ error = mnt_want_write(mnt);
if (error)
goto out_release;
+
+ error = union_copyup(&nd, &path);
+ if (error)
+ goto out_drop_write;
error = chown_common(&path, user, group);
- mnt_drop_write(path.mnt);
+out_drop_write:
+ mnt_drop_write(mnt);
out_release:
path_put(&path);
+ path_put(&nd.path);
+ putname(tmp);
out:
return error;
}
^ permalink raw reply related [flat|nested] 79+ messages in thread* [PATCH 67/76] union-mount: Implement union-aware truncate()
2011-06-17 16:00 [RFC][PATCH 00/76] Union Mount David Howells
` (65 preceding siblings ...)
2011-06-17 16:09 ` [PATCH 66/76] union-mount: Implement union-aware chown() David Howells
@ 2011-06-17 16:10 ` David Howells
2011-06-17 16:10 ` [PATCH 68/76] union-mount: Implement union-aware chmod()/fchmodat() David Howells
` (9 subsequent siblings)
76 siblings, 0 replies; 79+ messages in thread
From: David Howells @ 2011-06-17 16:10 UTC (permalink / raw)
To: linux-fsdevel; +Cc: hch
From: Valerie Aurora <vaurora@redhat.com>
---
fs/open.c | 24 ++++++++++++++++++++----
1 files changed, 20 insertions(+), 4 deletions(-)
diff --git a/fs/open.c b/fs/open.c
index 3909546..bf8a931 100644
--- a/fs/open.c
+++ b/fs/open.c
@@ -65,14 +65,17 @@ int do_truncate(struct dentry *dentry, loff_t length, unsigned int time_attrs,
static long do_sys_truncate(const char __user *pathname, loff_t length)
{
struct path path;
+ struct nameidata nd;
+ struct vfsmount *mnt;
struct inode *inode;
+ char *tmp;
int error;
error = -EINVAL;
if (length < 0) /* sorry, but loff_t says... */
goto out;
- error = user_path(pathname, &path);
+ error = user_path_nd(AT_FDCWD, pathname, 0, &nd, &path, &tmp);
if (error)
goto out;
inode = path.dentry->d_inode;
@@ -86,11 +89,16 @@ static long do_sys_truncate(const char __user *pathname, loff_t length)
if (!S_ISREG(inode->i_mode))
goto dput_and_out;
- error = mnt_want_write(path.mnt);
+ if (IS_DIR_UNIONED(nd.path.dentry))
+ mnt = nd.path.mnt;
+ else
+ mnt = path.mnt;
+
+ error = mnt_want_write(mnt);
if (error)
goto dput_and_out;
- error = inode_permission(inode, MAY_WRITE);
+ error = path_permission(&path, &nd.path, MAY_WRITE);
if (error)
goto mnt_drop_write_and_out;
@@ -98,6 +106,12 @@ static long do_sys_truncate(const char __user *pathname, loff_t length)
if (IS_APPEND(inode))
goto mnt_drop_write_and_out;
+ error = union_copyup_len(&nd, &path, length);
+ if (error)
+ goto mnt_drop_write_and_out;
+
+ /* path may have changed after copyup */
+ inode = path.dentry->d_inode;
error = get_write_access(inode);
if (error)
goto mnt_drop_write_and_out;
@@ -119,9 +133,11 @@ static long do_sys_truncate(const char __user *pathname, loff_t length)
put_write_and_out:
put_write_access(inode);
mnt_drop_write_and_out:
- mnt_drop_write(path.mnt);
+ mnt_drop_write(mnt);
dput_and_out:
path_put(&path);
+ path_put(&nd.path);
+ putname(tmp);
out:
return error;
}
^ permalink raw reply related [flat|nested] 79+ messages in thread* [PATCH 68/76] union-mount: Implement union-aware chmod()/fchmodat()
2011-06-17 16:00 [RFC][PATCH 00/76] Union Mount David Howells
` (66 preceding siblings ...)
2011-06-17 16:10 ` [PATCH 67/76] union-mount: Implement union-aware truncate() David Howells
@ 2011-06-17 16:10 ` David Howells
2011-06-17 16:10 ` [PATCH 69/76] union-mount: Implement union-aware lchown() David Howells
` (8 subsequent siblings)
76 siblings, 0 replies; 79+ messages in thread
From: David Howells @ 2011-06-17 16:10 UTC (permalink / raw)
To: linux-fsdevel; +Cc: hch
From: Valerie Aurora <vaurora@redhat.com>
---
fs/open.c | 25 +++++++++++++++++++++----
1 files changed, 21 insertions(+), 4 deletions(-)
diff --git a/fs/open.c b/fs/open.c
index bf8a931..1ce2da3 100644
--- a/fs/open.c
+++ b/fs/open.c
@@ -516,18 +516,32 @@ out:
SYSCALL_DEFINE3(fchmodat, int, dfd, const char __user *, filename, mode_t, mode)
{
struct path path;
+ struct nameidata nd;
+ struct vfsmount *mnt;
struct inode *inode;
+ char *tmp;
int error;
struct iattr newattrs;
- error = user_path_at(dfd, filename, LOOKUP_FOLLOW, &path);
+ error = user_path_nd(dfd, filename, LOOKUP_FOLLOW, &nd,
+ &path, &tmp);
if (error)
goto out;
- inode = path.dentry->d_inode;
- error = mnt_want_write(path.mnt);
+ if (IS_DIR_UNIONED(nd.path.dentry))
+ mnt = nd.path.mnt;
+ else
+ mnt = path.mnt;
+
+ error = mnt_want_write(mnt);
if (error)
goto dput_and_out;
+
+ error = union_copyup(&nd, &path);
+ if (error)
+ goto mnt_drop_write_and_out;
+
+ inode = path.dentry->d_inode;
mutex_lock(&inode->i_mutex);
error = security_path_chmod(path.dentry, path.mnt, mode);
if (error)
@@ -539,9 +553,12 @@ SYSCALL_DEFINE3(fchmodat, int, dfd, const char __user *, filename, mode_t, mode)
error = notify_change(path.dentry, &newattrs);
out_unlock:
mutex_unlock(&inode->i_mutex);
- mnt_drop_write(path.mnt);
+mnt_drop_write_and_out:
+ mnt_drop_write(mnt);
dput_and_out:
path_put(&path);
+ path_put(&nd.path);
+ putname(tmp);
out:
return error;
}
^ permalink raw reply related [flat|nested] 79+ messages in thread* [PATCH 69/76] union-mount: Implement union-aware lchown()
2011-06-17 16:00 [RFC][PATCH 00/76] Union Mount David Howells
` (67 preceding siblings ...)
2011-06-17 16:10 ` [PATCH 68/76] union-mount: Implement union-aware chmod()/fchmodat() David Howells
@ 2011-06-17 16:10 ` David Howells
2011-06-17 16:10 ` [PATCH 70/76] union-mount: Implement union-aware utimensat() David Howells
` (7 subsequent siblings)
76 siblings, 0 replies; 79+ messages in thread
From: David Howells @ 2011-06-17 16:10 UTC (permalink / raw)
To: linux-fsdevel; +Cc: hch
From: Valerie Aurora <vaurora@redhat.com>
---
fs/open.c | 23 ++++++++++++++++++++---
1 files changed, 20 insertions(+), 3 deletions(-)
diff --git a/fs/open.c b/fs/open.c
index 1ce2da3..8dca771 100644
--- a/fs/open.c
+++ b/fs/open.c
@@ -661,18 +661,35 @@ out:
SYSCALL_DEFINE3(lchown, const char __user *, filename, uid_t, user, gid_t, group)
{
struct path path;
+ struct nameidata nd;
+ struct vfsmount *mnt;
+ char *tmp;
int error;
- error = user_lpath(filename, &path);
+ error = user_path_nd(AT_FDCWD, filename, 0, &nd, &path, &tmp);
if (error)
goto out;
- error = mnt_want_write(path.mnt);
+
+ if (IS_DIR_UNIONED(nd.path.dentry))
+ mnt = nd.path.mnt;
+ else
+ mnt = path.mnt;
+
+ error = mnt_want_write(mnt);
if (error)
goto out_release;
+
+ error = union_copyup(&nd, &path);
+ if (error)
+ goto out_drop_write;
+
error = chown_common(&path, user, group);
- mnt_drop_write(path.mnt);
+out_drop_write:
+ mnt_drop_write(mnt);
out_release:
path_put(&path);
+ path_put(&nd.path);
+ putname(tmp);
out:
return error;
}
^ permalink raw reply related [flat|nested] 79+ messages in thread* [PATCH 70/76] union-mount: Implement union-aware utimensat()
2011-06-17 16:00 [RFC][PATCH 00/76] Union Mount David Howells
` (68 preceding siblings ...)
2011-06-17 16:10 ` [PATCH 69/76] union-mount: Implement union-aware lchown() David Howells
@ 2011-06-17 16:10 ` David Howells
2011-06-17 16:10 ` [PATCH 71/76] union-mount: Implement union-aware setxattr() David Howells
` (6 subsequent siblings)
76 siblings, 0 replies; 79+ messages in thread
From: David Howells @ 2011-06-17 16:10 UTC (permalink / raw)
To: linux-fsdevel; +Cc: hch
From: Valerie Aurora <vaurora@redhat.com>
---
fs/utimes.c | 14 ++++++++++++--
1 files changed, 12 insertions(+), 2 deletions(-)
diff --git a/fs/utimes.c b/fs/utimes.c
index ba653f3..1ec3a4a 100644
--- a/fs/utimes.c
+++ b/fs/utimes.c
@@ -8,8 +8,10 @@
#include <linux/stat.h>
#include <linux/utime.h>
#include <linux/syscalls.h>
+#include <linux/slab.h>
#include <asm/uaccess.h>
#include <asm/unistd.h>
+#include "union.h"
#ifdef __ARCH_WANT_SYS_UTIME
@@ -153,18 +155,26 @@ long do_utimes(int dfd, const char __user *filename, struct timespec *times,
error = utimes_common(&file->f_path, times);
fput(file);
} else {
+ struct nameidata nd;
+ char *tmp;
struct path path;
int lookup_flags = 0;
if (!(flags & AT_SYMLINK_NOFOLLOW))
lookup_flags |= LOOKUP_FOLLOW;
- error = user_path_at(dfd, filename, lookup_flags, &path);
+ error = user_path_nd(dfd, filename, lookup_flags, &nd, &path,
+ &tmp);
if (error)
goto out;
- error = utimes_common(&path, times);
+ error = union_copyup(&nd, &path);
+
+ if (!error)
+ error = utimes_common(&path, times);
path_put(&path);
+ path_put(&nd.path);
+ putname(tmp);
}
out:
^ permalink raw reply related [flat|nested] 79+ messages in thread* [PATCH 71/76] union-mount: Implement union-aware setxattr()
2011-06-17 16:00 [RFC][PATCH 00/76] Union Mount David Howells
` (69 preceding siblings ...)
2011-06-17 16:10 ` [PATCH 70/76] union-mount: Implement union-aware utimensat() David Howells
@ 2011-06-17 16:10 ` David Howells
2011-06-17 16:10 ` [PATCH 72/76] union-mount: Implement union-aware lsetxattr() David Howells
` (5 subsequent siblings)
76 siblings, 0 replies; 79+ messages in thread
From: David Howells @ 2011-06-17 16:10 UTC (permalink / raw)
To: linux-fsdevel; +Cc: hch
From: Valerie Aurora <vaurora@redhat.com>
---
fs/xattr.c | 34 +++++++++++++++++++++++++++-------
1 files changed, 27 insertions(+), 7 deletions(-)
diff --git a/fs/xattr.c b/fs/xattr.c
index f060663..3363aa4 100644
--- a/fs/xattr.c
+++ b/fs/xattr.c
@@ -19,7 +19,7 @@
#include <linux/fsnotify.h>
#include <linux/audit.h>
#include <asm/uaccess.h>
-
+#include "union.h"
/*
* Check permissions for extended attribute access. This is a bit complicated
@@ -288,17 +288,37 @@ SYSCALL_DEFINE5(setxattr, const char __user *, pathname,
size_t, size, int, flags)
{
struct path path;
+ struct nameidata nd;
+ struct vfsmount *mnt;
+ char *tmp;
int error;
- error = user_path(pathname, &path);
+ error = user_path_nd(AT_FDCWD, pathname, LOOKUP_FOLLOW, &nd, &path,
+ &tmp);
if (error)
return error;
- error = mnt_want_write(path.mnt);
- if (!error) {
- error = setxattr(path.dentry, name, value, size, flags);
- mnt_drop_write(path.mnt);
- }
+
+ if (IS_DIR_UNIONED(nd.path.dentry))
+ mnt = nd.path.mnt;
+ else
+ mnt = path.mnt;
+
+ error = mnt_want_write(mnt);
+ if (error)
+ goto out;
+
+ error = union_copyup(&nd, &path);
+ if (error)
+ goto out_drop_write;
+
+ error = setxattr(path.dentry, name, value, size, flags);
+
+out_drop_write:
+ mnt_drop_write(mnt);
+out:
path_put(&path);
+ path_put(&nd.path);
+ putname(tmp);
return error;
}
^ permalink raw reply related [flat|nested] 79+ messages in thread* [PATCH 72/76] union-mount: Implement union-aware lsetxattr()
2011-06-17 16:00 [RFC][PATCH 00/76] Union Mount David Howells
` (70 preceding siblings ...)
2011-06-17 16:10 ` [PATCH 71/76] union-mount: Implement union-aware setxattr() David Howells
@ 2011-06-17 16:10 ` David Howells
2011-06-17 16:10 ` [PATCH 73/76] union-mount: Pass mount flags to sget() David Howells
` (4 subsequent siblings)
76 siblings, 0 replies; 79+ messages in thread
From: David Howells @ 2011-06-17 16:10 UTC (permalink / raw)
To: linux-fsdevel; +Cc: hch
From: Valerie Aurora <vaurora@redhat.com>
---
fs/xattr.c | 31 +++++++++++++++++++++++++------
1 files changed, 25 insertions(+), 6 deletions(-)
diff --git a/fs/xattr.c b/fs/xattr.c
index 3363aa4..b59534c 100644
--- a/fs/xattr.c
+++ b/fs/xattr.c
@@ -327,17 +327,36 @@ SYSCALL_DEFINE5(lsetxattr, const char __user *, pathname,
size_t, size, int, flags)
{
struct path path;
+ struct nameidata nd;
+ struct vfsmount *mnt;
+ char *tmp;
int error;
- error = user_lpath(pathname, &path);
+ error = user_path_nd(AT_FDCWD, pathname, 0, &nd, &path, &tmp);
if (error)
return error;
- error = mnt_want_write(path.mnt);
- if (!error) {
- error = setxattr(path.dentry, name, value, size, flags);
- mnt_drop_write(path.mnt);
- }
+
+ if (IS_DIR_UNIONED(nd.path.dentry))
+ mnt = nd.path.mnt;
+ else
+ mnt = path.mnt;
+
+ error = mnt_want_write(mnt);
+ if (error)
+ goto out;
+
+ error = union_copyup(&nd, &path);
+ if (error)
+ goto out_drop_write;
+
+ error = setxattr(path.dentry, name, value, size, flags);
+
+out_drop_write:
+ mnt_drop_write(mnt);
+out:
path_put(&path);
+ path_put(&nd.path);
+ putname(tmp);
return error;
}
^ permalink raw reply related [flat|nested] 79+ messages in thread* [PATCH 73/76] union-mount: Pass mount flags to sget()
2011-06-17 16:00 [RFC][PATCH 00/76] Union Mount David Howells
` (71 preceding siblings ...)
2011-06-17 16:10 ` [PATCH 72/76] union-mount: Implement union-aware lsetxattr() David Howells
@ 2011-06-17 16:10 ` David Howells
2011-06-17 16:11 ` [PATCH 74/76] union-mount: Duplicate the i_{, dir_}mutex lock classes and use for upper layer David Howells
` (3 subsequent siblings)
76 siblings, 0 replies; 79+ messages in thread
From: David Howells @ 2011-06-17 16:10 UTC (permalink / raw)
To: linux-fsdevel; +Cc: hch
Pass mount flags to sget() so that it can use them in initialising a new
superblock.
Signed-off-by: David Howells <dhowells@redhat.com>
---
drivers/mtd/mtdsuper.c | 4 +---
fs/9p/vfs_super.c | 4 ++--
fs/afs/super.c | 3 +--
fs/btrfs/super.c | 4 ++--
fs/ceph/super.c | 2 +-
fs/cifs/cifsfs.c | 8 ++++----
fs/devpts/inode.c | 6 +++---
fs/ecryptfs/main.c | 3 +--
fs/gfs2/ops_fstype.c | 5 ++---
fs/libfs.c | 4 ++--
fs/logfs/super.c | 3 +--
fs/nfs/super.c | 10 +++++-----
fs/nilfs2/super.c | 4 ++--
fs/proc/root.c | 3 +--
fs/reiserfs/procfs.c | 2 +-
fs/super.c | 22 +++++++++++-----------
fs/sysfs/mount.c | 3 +--
fs/ubifs/super.c | 3 +--
include/linux/fs.h | 2 +-
kernel/cgroup.c | 2 +-
20 files changed, 44 insertions(+), 53 deletions(-)
diff --git a/drivers/mtd/mtdsuper.c b/drivers/mtd/mtdsuper.c
index 16b02a1..45ade10 100644
--- a/drivers/mtd/mtdsuper.c
+++ b/drivers/mtd/mtdsuper.c
@@ -62,7 +62,7 @@ static struct dentry *mount_mtd_aux(struct file_system_type *fs_type, int flags,
struct super_block *sb;
int ret;
- sb = sget(fs_type, get_sb_mtd_compare, get_sb_mtd_set, mtd);
+ sb = sget(fs_type, get_sb_mtd_compare, get_sb_mtd_set, flags, mtd);
if (IS_ERR(sb))
goto out_error;
@@ -73,8 +73,6 @@ static struct dentry *mount_mtd_aux(struct file_system_type *fs_type, int flags,
DEBUG(1, "MTDSB: New superblock for device %d (\"%s\")\n",
mtd->index, mtd->name);
- sb->s_flags = flags;
-
ret = fill_super(sb, data, flags & MS_SILENT ? 1 : 0);
if (ret < 0) {
deactivate_locked_super(sb);
diff --git a/fs/9p/vfs_super.c b/fs/9p/vfs_super.c
index feef6cd..0d163c5 100644
--- a/fs/9p/vfs_super.c
+++ b/fs/9p/vfs_super.c
@@ -89,7 +89,7 @@ v9fs_fill_super(struct super_block *sb, struct v9fs_session_info *v9ses,
if (v9ses->cache)
sb->s_bdi->ra_pages = (VM_MAX_READAHEAD * 1024)/PAGE_CACHE_SIZE;
- sb->s_flags = flags | MS_ACTIVE | MS_DIRSYNC | MS_NOATIME;
+ sb->s_flags |= MS_ACTIVE | MS_DIRSYNC | MS_NOATIME;
if (!v9ses->cache)
sb->s_flags |= MS_SYNCHRONOUS;
@@ -137,7 +137,7 @@ static struct dentry *v9fs_mount(struct file_system_type *fs_type, int flags,
goto close_session;
}
- sb = sget(fs_type, NULL, v9fs_set_super, v9ses);
+ sb = sget(fs_type, NULL, v9fs_set_super, flags, v9ses);
if (IS_ERR(sb)) {
retval = PTR_ERR(sb);
goto clunk_fid;
diff --git a/fs/afs/super.c b/fs/afs/super.c
index fb240e8..a494ca9 100644
--- a/fs/afs/super.c
+++ b/fs/afs/super.c
@@ -402,7 +402,7 @@ static struct dentry *afs_mount(struct file_system_type *fs_type,
params.volume = vol;
/* allocate a deviceless superblock */
- sb = sget(fs_type, afs_test_super, set_anon_super, ¶ms);
+ sb = sget(fs_type, afs_test_super, set_anon_super, flags, ¶ms);
if (IS_ERR(sb)) {
ret = PTR_ERR(sb);
goto error;
@@ -411,7 +411,6 @@ static struct dentry *afs_mount(struct file_system_type *fs_type,
if (!sb->s_root) {
/* initial superblock/root creation */
_debug("create");
- sb->s_flags = flags;
ret = afs_fill_super(sb, ¶ms);
if (ret < 0) {
deactivate_locked_super(sb);
diff --git a/fs/btrfs/super.c b/fs/btrfs/super.c
index 0bb4ebb..c6d6836 100644
--- a/fs/btrfs/super.c
+++ b/fs/btrfs/super.c
@@ -808,7 +808,8 @@ static struct dentry *btrfs_mount(struct file_system_type *fs_type, int flags,
tree_root->fs_info = fs_info;
bdev = fs_devices->latest_bdev;
- s = sget(fs_type, btrfs_test_super, btrfs_set_super, tree_root);
+ s = sget(fs_type, btrfs_test_super, btrfs_set_super, flags | MS_NOSEC,
+ tree_root);
if (IS_ERR(s))
goto error_s;
@@ -825,7 +826,6 @@ static struct dentry *btrfs_mount(struct file_system_type *fs_type, int flags,
} else {
char b[BDEVNAME_SIZE];
- s->s_flags = flags | MS_NOSEC;
strlcpy(s->s_id, bdevname(bdev, b), sizeof(s->s_id));
error = btrfs_fill_super(s, fs_devices, data,
flags & MS_SILENT ? 1 : 0);
diff --git a/fs/ceph/super.c b/fs/ceph/super.c
index f2f77fd..82710f6 100644
--- a/fs/ceph/super.c
+++ b/fs/ceph/super.c
@@ -823,7 +823,7 @@ static struct dentry *ceph_mount(struct file_system_type *fs_type,
if (ceph_test_opt(fsc->client, NOSHARE))
compare_super = NULL;
- sb = sget(fs_type, compare_super, ceph_set_super, fsc);
+ sb = sget(fs_type, compare_super, ceph_set_super, flags, fsc);
if (IS_ERR(sb)) {
res = ERR_CAST(sb);
goto out;
diff --git a/fs/cifs/cifsfs.c b/fs/cifs/cifsfs.c
index e9def99..9823940 100644
--- a/fs/cifs/cifsfs.c
+++ b/fs/cifs/cifsfs.c
@@ -692,7 +692,10 @@ cifs_do_mount(struct file_system_type *fs_type,
mnt_data.cifs_sb = cifs_sb;
mnt_data.flags = flags;
- sb = sget(fs_type, cifs_match_super, set_anon_super, &mnt_data);
+ /* BB should we make this contingent on mount parm? */
+ flags |= MS_NODIRATIME | MS_NOATIME;
+
+ sb = sget(fs_type, cifs_match_super, set_anon_super, flags, &mnt_data);
if (IS_ERR(sb)) {
root = ERR_CAST(sb);
goto out_cifs_sb;
@@ -714,9 +717,6 @@ cifs_do_mount(struct file_system_type *fs_type,
goto out_super;
}
- sb->s_flags = flags;
- /* BB should we make this contingent on mount parm? */
- sb->s_flags |= MS_NODIRATIME | MS_NOATIME;
sb->s_fs_info = cifs_sb;
rc = cifs_read_super(sb, volume_info, dev_name,
diff --git a/fs/devpts/inode.c b/fs/devpts/inode.c
index 2f27e57..4154d08 100644
--- a/fs/devpts/inode.c
+++ b/fs/devpts/inode.c
@@ -369,15 +369,15 @@ static struct dentry *devpts_mount(struct file_system_type *fs_type,
return ERR_PTR(error);
if (opts.newinstance)
- s = sget(fs_type, NULL, set_anon_super, NULL);
+ s = sget(fs_type, NULL, set_anon_super, flags, NULL);
else
- s = sget(fs_type, compare_init_pts_sb, set_anon_super, NULL);
+ s = sget(fs_type, compare_init_pts_sb, set_anon_super, flags,
+ NULL);
if (IS_ERR(s))
return ERR_CAST(s);
if (!s->s_root) {
- s->s_flags = flags;
error = devpts_fill_super(s, data, flags & MS_SILENT ? 1 : 0);
if (error)
goto out_undo_sget;
diff --git a/fs/ecryptfs/main.c b/fs/ecryptfs/main.c
index 9f1bb74..46ac2b2 100644
--- a/fs/ecryptfs/main.c
+++ b/fs/ecryptfs/main.c
@@ -489,13 +489,12 @@ static struct dentry *ecryptfs_mount(struct file_system_type *fs_type, int flags
goto out;
}
- s = sget(fs_type, NULL, set_anon_super, NULL);
+ s = sget(fs_type, NULL, set_anon_super, flags, NULL);
if (IS_ERR(s)) {
rc = PTR_ERR(s);
goto out;
}
- s->s_flags = flags;
rc = bdi_setup_and_register(&sbi->bdi, "ecryptfs", BDI_CAP_MAP_COPY);
if (rc)
goto out1;
diff --git a/fs/gfs2/ops_fstype.c b/fs/gfs2/ops_fstype.c
index 8ac9ae1..80f24ce 100644
--- a/fs/gfs2/ops_fstype.c
+++ b/fs/gfs2/ops_fstype.c
@@ -1278,7 +1278,7 @@ static struct dentry *gfs2_mount(struct file_system_type *fs_type, int flags,
error = -EBUSY;
goto error_bdev;
}
- s = sget(fs_type, test_gfs2_super, set_gfs2_super, bdev);
+ s = sget(fs_type, test_gfs2_super, set_gfs2_super, flags, bdev);
mutex_unlock(&bdev->bd_fsfreeze_mutex);
error = PTR_ERR(s);
if (IS_ERR(s))
@@ -1308,7 +1308,6 @@ static struct dentry *gfs2_mount(struct file_system_type *fs_type, int flags,
} else {
char b[BDEVNAME_SIZE];
- s->s_flags = flags;
s->s_mode = mode;
strlcpy(s->s_id, bdevname(bdev, b), sizeof(s->s_id));
sb_set_blocksize(s, block_size(bdev));
@@ -1352,7 +1351,7 @@ static struct dentry *gfs2_mount_meta(struct file_system_type *fs_type,
dev_name, error);
return ERR_PTR(error);
}
- s = sget(&gfs2_fs_type, test_gfs2_super, set_meta_super,
+ s = sget(&gfs2_fs_type, test_gfs2_super, set_meta_super, flags,
path.dentry->d_inode->i_sb->s_bdev);
path_put(&path);
if (IS_ERR(s)) {
diff --git a/fs/libfs.c b/fs/libfs.c
index 05f40d0..481beff 100644
--- a/fs/libfs.c
+++ b/fs/libfs.c
@@ -235,15 +235,15 @@ struct dentry *mount_pseudo(struct file_system_type *fs_type, char *name,
const struct super_operations *ops,
const struct dentry_operations *dops, unsigned long magic)
{
- struct super_block *s = sget(fs_type, NULL, set_anon_super, NULL);
+ struct super_block *s;
struct dentry *dentry;
struct inode *root;
struct qstr d_name = {.name = name, .len = strlen(name)};
+ s = sget(fs_type, NULL, set_anon_super, MS_NOUSER, NULL);
if (IS_ERR(s))
return ERR_CAST(s);
- s->s_flags = MS_NOUSER;
s->s_maxbytes = MAX_LFS_FILESIZE;
s->s_blocksize = PAGE_SIZE;
s->s_blocksize_bits = PAGE_SHIFT;
diff --git a/fs/logfs/super.c b/fs/logfs/super.c
index ce03a18..322888a 100644
--- a/fs/logfs/super.c
+++ b/fs/logfs/super.c
@@ -541,7 +541,7 @@ static struct dentry *logfs_get_sb_device(struct logfs_super *super,
log_super("LogFS: Start mount %x\n", mount_count++);
err = -EINVAL;
- sb = sget(type, logfs_sb_test, logfs_sb_set, super);
+ sb = sget(type, logfs_sb_test, logfs_sb_set, flags | MS_NOATIME, super);
if (IS_ERR(sb)) {
super->s_devops->put_device(super);
kfree(super);
@@ -563,7 +563,6 @@ static struct dentry *logfs_get_sb_device(struct logfs_super *super,
*/
sb->s_maxbytes = (1ull << 43) - 1;
sb->s_op = &logfs_super_operations;
- sb->s_flags = flags | MS_NOATIME;
err = logfs_read_sb(sb, sb->s_flags & MS_RDONLY);
if (err)
diff --git a/fs/nfs/super.c b/fs/nfs/super.c
index ce40e5c..4d2ea32 100644
--- a/fs/nfs/super.c
+++ b/fs/nfs/super.c
@@ -2250,7 +2250,7 @@ static struct dentry *nfs_fs_mount(struct file_system_type *fs_type,
compare_super = NULL;
/* Get a superblock - note that we may end up sharing one that already exists */
- s = sget(fs_type, compare_super, nfs_set_super, &sb_mntdata);
+ s = sget(fs_type, compare_super, nfs_set_super, flags, &sb_mntdata);
if (IS_ERR(s)) {
mntroot = ERR_CAST(s);
goto out_err_nosb;
@@ -2362,7 +2362,7 @@ nfs_xdev_mount(struct file_system_type *fs_type, int flags,
compare_super = NULL;
/* Get a superblock - note that we may end up sharing one that already exists */
- s = sget(&nfs_fs_type, compare_super, nfs_set_super, &sb_mntdata);
+ s = sget(&nfs_fs_type, compare_super, nfs_set_super, flags, &sb_mntdata);
if (IS_ERR(s)) {
error = PTR_ERR(s);
goto out_err_nosb;
@@ -2629,7 +2629,7 @@ nfs4_remote_mount(struct file_system_type *fs_type, int flags,
compare_super = NULL;
/* Get a superblock - note that we may end up sharing one that already exists */
- s = sget(&nfs4_fs_type, compare_super, nfs_set_super, &sb_mntdata);
+ s = sget(&nfs4_fs_type, compare_super, nfs_set_super, flags, &sb_mntdata);
if (IS_ERR(s)) {
error = PTR_ERR(s);
goto out_free;
@@ -2923,7 +2923,7 @@ nfs4_xdev_mount(struct file_system_type *fs_type, int flags,
compare_super = NULL;
/* Get a superblock - note that we may end up sharing one that already exists */
- s = sget(&nfs4_fs_type, compare_super, nfs_set_super, &sb_mntdata);
+ s = sget(&nfs4_fs_type, compare_super, nfs_set_super, flags, &sb_mntdata);
if (IS_ERR(s)) {
error = PTR_ERR(s);
goto out_err_nosb;
@@ -3010,7 +3010,7 @@ nfs4_remote_referral_mount(struct file_system_type *fs_type, int flags,
compare_super = NULL;
/* Get a superblock - note that we may end up sharing one that already exists */
- s = sget(&nfs4_fs_type, compare_super, nfs_set_super, &sb_mntdata);
+ s = sget(&nfs4_fs_type, compare_super, nfs_set_super, flags, &sb_mntdata);
if (IS_ERR(s)) {
error = PTR_ERR(s);
goto out_err_nosb;
diff --git a/fs/nilfs2/super.c b/fs/nilfs2/super.c
index 8351c44..1a36d5d 100644
--- a/fs/nilfs2/super.c
+++ b/fs/nilfs2/super.c
@@ -1290,7 +1290,8 @@ nilfs_mount(struct file_system_type *fs_type, int flags,
err = -EBUSY;
goto failed;
}
- s = sget(fs_type, nilfs_test_bdev_super, nilfs_set_bdev_super, sd.bdev);
+ s = sget(fs_type, nilfs_test_bdev_super, nilfs_set_bdev_super, flags,
+ sd.bdev);
mutex_unlock(&sd.bdev->bd_fsfreeze_mutex);
if (IS_ERR(s)) {
err = PTR_ERR(s);
@@ -1303,7 +1304,6 @@ nilfs_mount(struct file_system_type *fs_type, int flags,
s_new = true;
/* New superblock instance created */
- s->s_flags = flags;
s->s_mode = mode;
strlcpy(s->s_id, bdevname(sd.bdev, b), sizeof(s->s_id));
sb_set_blocksize(s, block_size(sd.bdev));
diff --git a/fs/proc/root.c b/fs/proc/root.c
index a9000e9..7a848cc 100644
--- a/fs/proc/root.c
+++ b/fs/proc/root.c
@@ -48,12 +48,11 @@ static struct dentry *proc_mount(struct file_system_type *fs_type,
else
ns = current->nsproxy->pid_ns;
- sb = sget(fs_type, proc_test_super, proc_set_super, ns);
+ sb = sget(fs_type, proc_test_super, proc_set_super, flags, ns);
if (IS_ERR(sb))
return ERR_CAST(sb);
if (!sb->s_root) {
- sb->s_flags = flags;
err = proc_fill_super(sb);
if (err) {
deactivate_locked_super(sb);
diff --git a/fs/reiserfs/procfs.c b/fs/reiserfs/procfs.c
index 7a99811..de42b03 100644
--- a/fs/reiserfs/procfs.c
+++ b/fs/reiserfs/procfs.c
@@ -404,7 +404,7 @@ static void *r_start(struct seq_file *m, loff_t * pos)
if (l)
return NULL;
- if (IS_ERR(sget(&reiserfs_fs_type, test_sb, set_sb, s)))
+ if (IS_ERR(sget(&reiserfs_fs_type, test_sb, set_sb, 0, s)))
return NULL;
up_write(&s->s_umount);
diff --git a/fs/super.c b/fs/super.c
index 162e8a2..95a2ebc 100644
--- a/fs/super.c
+++ b/fs/super.c
@@ -41,11 +41,12 @@ DEFINE_SPINLOCK(sb_lock);
/**
* alloc_super - create new superblock
* @type: filesystem type superblock should belong to
+ * @flags: the mount flags
*
* Allocates and initializes a new &struct super_block. alloc_super()
* returns a pointer new superblock or %NULL if allocation had failed.
*/
-static struct super_block *alloc_super(struct file_system_type *type)
+static struct super_block *alloc_super(struct file_system_type *type, int flags)
{
struct super_block *s = kzalloc(sizeof(struct super_block), GFP_USER);
static const struct super_operations default_op;
@@ -72,6 +73,7 @@ static struct super_block *alloc_super(struct file_system_type *type)
#else
INIT_LIST_HEAD(&s->s_files);
#endif
+ s->s_flags = flags;
s->s_bdi = &default_backing_dev_info;
INIT_LIST_HEAD(&s->s_instances);
INIT_HLIST_BL_HEAD(&s->s_anon);
@@ -313,11 +315,13 @@ EXPORT_SYMBOL(generic_shutdown_super);
* @type: filesystem type superblock should belong to
* @test: comparison callback
* @set: setup callback
+ * @flags: mount flags
* @data: argument to each of them
*/
struct super_block *sget(struct file_system_type *type,
int (*test)(struct super_block *,void *),
int (*set)(struct super_block *,void *),
+ int flags,
void *data)
{
struct super_block *s = NULL;
@@ -347,7 +351,7 @@ retry:
}
if (!s) {
spin_unlock(&sb_lock);
- s = alloc_super(type);
+ s = alloc_super(type, flags);
if (!s)
return ERR_PTR(-ENOMEM);
goto retry;
@@ -735,13 +739,12 @@ struct dentry *mount_ns(struct file_system_type *fs_type, int flags,
{
struct super_block *sb;
- sb = sget(fs_type, ns_test_super, ns_set_super, data);
+ sb = sget(fs_type, ns_test_super, ns_set_super, flags, data);
if (IS_ERR(sb))
return ERR_CAST(sb);
if (!sb->s_root) {
int err;
- sb->s_flags = flags;
err = fill_super(sb, data, flags & MS_SILENT ? 1 : 0);
if (err) {
deactivate_locked_super(sb);
@@ -802,7 +805,8 @@ struct dentry *mount_bdev(struct file_system_type *fs_type,
error = -EBUSY;
goto error_bdev;
}
- s = sget(fs_type, test_bdev_super, set_bdev_super, bdev);
+ s = sget(fs_type, test_bdev_super, set_bdev_super, flags | MS_NOSEC,
+ bdev);
mutex_unlock(&bdev->bd_fsfreeze_mutex);
if (IS_ERR(s))
goto error_s;
@@ -827,7 +831,6 @@ struct dentry *mount_bdev(struct file_system_type *fs_type,
} else {
char b[BDEVNAME_SIZE];
- s->s_flags = flags | MS_NOSEC;
s->s_mode = mode;
strlcpy(s->s_id, bdevname(bdev, b), sizeof(s->s_id));
sb_set_blocksize(s, block_size(bdev));
@@ -872,13 +875,11 @@ struct dentry *mount_nodev(struct file_system_type *fs_type,
int (*fill_super)(struct super_block *, void *, int))
{
int error;
- struct super_block *s = sget(fs_type, NULL, set_anon_super, NULL);
+ struct super_block *s = sget(fs_type, NULL, set_anon_super, flags, NULL);
if (IS_ERR(s))
return ERR_CAST(s);
- s->s_flags = flags;
-
error = fill_super(s, data, flags & MS_SILENT ? 1 : 0);
if (error) {
deactivate_locked_super(s);
@@ -901,11 +902,10 @@ struct dentry *mount_single(struct file_system_type *fs_type,
struct super_block *s;
int error;
- s = sget(fs_type, compare_single, set_anon_super, NULL);
+ s = sget(fs_type, compare_single, set_anon_super, flags, NULL);
if (IS_ERR(s))
return ERR_CAST(s);
if (!s->s_root) {
- s->s_flags = flags;
error = fill_super(s, data, flags & MS_SILENT ? 1 : 0);
if (error) {
deactivate_locked_super(s);
diff --git a/fs/sysfs/mount.c b/fs/sysfs/mount.c
index 2668957..fd222aa 100644
--- a/fs/sysfs/mount.c
+++ b/fs/sysfs/mount.c
@@ -110,13 +110,12 @@ static struct dentry *sysfs_mount(struct file_system_type *fs_type,
for (type = KOBJ_NS_TYPE_NONE; type < KOBJ_NS_TYPES; type++)
info->ns[type] = kobj_ns_current(type);
- sb = sget(fs_type, sysfs_test_super, sysfs_set_super, info);
+ sb = sget(fs_type, sysfs_test_super, sysfs_set_super, flags, info);
if (IS_ERR(sb) || sb->s_fs_info != info)
kfree(info);
if (IS_ERR(sb))
return ERR_CAST(sb);
if (!sb->s_root) {
- sb->s_flags = flags;
error = sysfs_fill_super(sb, data, flags & MS_SILENT ? 1 : 0);
if (error) {
deactivate_locked_super(sb);
diff --git a/fs/ubifs/super.c b/fs/ubifs/super.c
index b5aeb5a..e832986 100644
--- a/fs/ubifs/super.c
+++ b/fs/ubifs/super.c
@@ -2129,7 +2129,7 @@ static struct dentry *ubifs_mount(struct file_system_type *fs_type, int flags,
dbg_gen("opened ubi%d_%d", vi.ubi_num, vi.vol_id);
- sb = sget(fs_type, &sb_test, &set_anon_super, &vi.cdev);
+ sb = sget(fs_type, &sb_test, &set_anon_super, flags, &vi.cdev);
if (IS_ERR(sb)) {
err = PTR_ERR(sb);
goto out_close;
@@ -2145,7 +2145,6 @@ static struct dentry *ubifs_mount(struct file_system_type *fs_type, int flags,
goto out_deact;
}
} else {
- sb->s_flags = flags;
/*
* Pass 'ubi' to 'fill_super()' in sb->s_fs_info where it is
* replaced by 'c'.
diff --git a/include/linux/fs.h b/include/linux/fs.h
index 3665799..86fccfe 100644
--- a/include/linux/fs.h
+++ b/include/linux/fs.h
@@ -1867,7 +1867,7 @@ int set_anon_super(struct super_block *s, void *data);
struct super_block *sget(struct file_system_type *type,
int (*test)(struct super_block *,void *),
int (*set)(struct super_block *,void *),
- void *data);
+ int flags, void *data);
extern struct dentry *mount_pseudo(struct file_system_type *, char *,
const struct super_operations *ops,
const struct dentry_operations *dops,
diff --git a/kernel/cgroup.c b/kernel/cgroup.c
index 2731d11..916924a 100644
--- a/kernel/cgroup.c
+++ b/kernel/cgroup.c
@@ -1499,7 +1499,7 @@ static struct dentry *cgroup_mount(struct file_system_type *fs_type,
opts.new_root = new_root;
/* Locate an existing or new sb for this hierarchy */
- sb = sget(fs_type, cgroup_test_super, cgroup_set_super, &opts);
+ sb = sget(fs_type, cgroup_test_super, cgroup_set_super, 0, &opts);
if (IS_ERR(sb)) {
ret = PTR_ERR(sb);
cgroup_drop_root(opts.new_root);
^ permalink raw reply related [flat|nested] 79+ messages in thread* [PATCH 74/76] union-mount: Duplicate the i_{, dir_}mutex lock classes and use for upper layer
2011-06-17 16:00 [RFC][PATCH 00/76] Union Mount David Howells
` (72 preceding siblings ...)
2011-06-17 16:10 ` [PATCH 73/76] union-mount: Pass mount flags to sget() David Howells
@ 2011-06-17 16:11 ` David Howells
2011-06-17 16:11 ` [PATCH 76/76] Temporary commit David Howells
` (2 subsequent siblings)
76 siblings, 0 replies; 79+ messages in thread
From: David Howells @ 2011-06-17 16:11 UTC (permalink / raw)
To: linux-fsdevel; +Cc: hch
Duplicate the i_mutex and i_dir_mutex lock classes and use for unionmount upper
layer superblock instead of the normal lock classes. This solves some of the
lockdep noise when the VFS tries to hold locks on inodes in both layers at the
same time. Note these only occur if both layers are of the same filesystem
type.
As far as I can tell, most of the lockdep warnings are false positives since
the inodes being locked are part of different superblocks; however, because
lockdep works on lock *classes*, it can't determine this.
I suspect that giving each superblock its own lock class would overextend
lockdep.
---
fs/inode.c | 48 ++++++++++++++++++++++++++++++++++++------------
fs/namespace.c | 2 +-
fs/super.c | 8 ++++++++
include/linux/fs.h | 5 +++--
4 files changed, 48 insertions(+), 15 deletions(-)
diff --git a/fs/inode.c b/fs/inode.c
index 0f7e88a..0c93cce 100644
--- a/fs/inode.c
+++ b/fs/inode.c
@@ -173,8 +173,14 @@ int inode_init_always(struct super_block *sb, struct inode *inode)
spin_lock_init(&inode->i_lock);
lockdep_set_class(&inode->i_lock, &sb->s_type->i_lock_key);
+ /* Duplicate the code with separate indices so that when lockdep print
+ * a warning, the numeric index is seen.
+ */
mutex_init(&inode->i_mutex);
- lockdep_set_class(&inode->i_mutex, &sb->s_type->i_mutex_key);
+ if (sb->s_lock_class == 0)
+ lockdep_set_class(&inode->i_mutex, &sb->s_type->i_mutex_key[0]);
+ else
+ lockdep_set_class(&inode->i_mutex, &sb->s_type->i_mutex_key[1]);
init_rwsem(&inode->i_alloc_sem);
lockdep_set_class(&inode->i_alloc_sem, &sb->s_type->i_alloc_sem_key);
@@ -875,18 +881,36 @@ void unlock_new_inode(struct inode *inode)
{
#ifdef CONFIG_DEBUG_LOCK_ALLOC
if (S_ISDIR(inode->i_mode)) {
- struct file_system_type *type = inode->i_sb->s_type;
+ struct super_block *sb = inode->i_sb;
+ struct file_system_type *type = sb->s_type;
- /* Set new key only if filesystem hasn't already changed it */
- if (!lockdep_match_class(&inode->i_mutex,
- &type->i_mutex_key)) {
- /*
- * ensure nobody is actually holding i_mutex
- */
- mutex_destroy(&inode->i_mutex);
- mutex_init(&inode->i_mutex);
- lockdep_set_class(&inode->i_mutex,
- &type->i_mutex_dir_key);
+ /* Set new key only if filesystem hasn't already changed it
+ *
+ * Duplicate the code with separate indices so that when
+ * lockdep print a warning, the numeric index is seen.
+ */
+ if (sb->s_lock_class == 0) {
+ if (!lockdep_match_class(&inode->i_mutex,
+ &type->i_mutex_key[0])) {
+ /*
+ * ensure nobody is actually holding i_mutex
+ */
+ mutex_destroy(&inode->i_mutex);
+ mutex_init(&inode->i_mutex);
+ lockdep_set_class(&inode->i_mutex,
+ &type->i_mutex_dir_key[0]);
+ }
+ } else {
+ if (!lockdep_match_class(&inode->i_mutex,
+ &type->i_mutex_key[1])) {
+ /*
+ * ensure nobody is actually holding i_mutex
+ */
+ mutex_destroy(&inode->i_mutex);
+ mutex_init(&inode->i_mutex);
+ lockdep_set_class(&inode->i_mutex,
+ &type->i_mutex_dir_key[1]);
+ }
}
}
#endif
diff --git a/fs/namespace.c b/fs/namespace.c
index cd28af0..1411078 100644
--- a/fs/namespace.c
+++ b/fs/namespace.c
@@ -2612,7 +2612,7 @@ long do_mount(char *dev_name, char *dir_name, char *type_page,
flags &= ~(MS_NOSUID | MS_NOEXEC | MS_NODEV | MS_ACTIVE | MS_BORN |
MS_NOATIME | MS_NODIRATIME | MS_RELATIME| MS_KERNMOUNT |
- MS_STRICTATIME | MS_UNION);
+ MS_STRICTATIME);
if (flags & MS_REMOUNT)
retval = do_remount(&path, flags & ~MS_REMOUNT, mnt_flags,
diff --git a/fs/super.c b/fs/super.c
index 95a2ebc..cd60a34 100644
--- a/fs/super.c
+++ b/fs/super.c
@@ -74,6 +74,7 @@ static struct super_block *alloc_super(struct file_system_type *type, int flags)
INIT_LIST_HEAD(&s->s_files);
#endif
s->s_flags = flags;
+ s->s_lock_class = (flags & MS_UNION) ? 1 : 0;
s->s_bdi = &default_backing_dev_info;
INIT_LIST_HEAD(&s->s_instances);
INIT_HLIST_BL_HEAD(&s->s_anon);
@@ -346,6 +347,13 @@ retry:
deactivate_locked_super(old);
goto retry;
}
+#ifdef CONFIG_UNION_MOUNT
+ if (unlikely((old->s_flags | flags) & MS_UNION)) {
+ up_write(&old->s_umount);
+ deactivate_locked_super(old);
+ return ERR_PTR(-EINVAL);
+ }
+#endif
return old;
}
}
diff --git a/include/linux/fs.h b/include/linux/fs.h
index 86fccfe..6779eea 100644
--- a/include/linux/fs.h
+++ b/include/linux/fs.h
@@ -1372,6 +1372,7 @@ struct super_block {
dev_t s_dev; /* search index; _not_ kdev_t */
unsigned char s_dirt;
unsigned char s_blocksize_bits;
+ u8 s_lock_class; /* Set of lock classes to use */
unsigned long s_blocksize;
loff_t s_maxbytes; /* Max file size */
struct file_system_type *s_type;
@@ -1841,8 +1842,8 @@ struct file_system_type {
struct lock_class_key s_vfs_rename_key;
struct lock_class_key i_lock_key;
- struct lock_class_key i_mutex_key;
- struct lock_class_key i_mutex_dir_key;
+ struct lock_class_key i_mutex_key[2];
+ struct lock_class_key i_mutex_dir_key[2];
struct lock_class_key i_alloc_sem_key;
};
^ permalink raw reply related [flat|nested] 79+ messages in thread* [PATCH 76/76] Temporary commit
2011-06-17 16:00 [RFC][PATCH 00/76] Union Mount David Howells
` (73 preceding siblings ...)
2011-06-17 16:11 ` [PATCH 74/76] union-mount: Duplicate the i_{, dir_}mutex lock classes and use for upper layer David Howells
@ 2011-06-17 16:11 ` David Howells
2011-06-17 16:23 ` [PATCH 75/76] Ext2: Unionmount devel David Howells
2011-06-17 16:44 ` [RFC][PATCH 00/76] Union Mount Sedat Dilek
76 siblings, 0 replies; 79+ messages in thread
From: David Howells @ 2011-06-17 16:11 UTC (permalink / raw)
To: linux-fsdevel; +Cc: hch
From: Valerie Aurora <vaurora@redhat.com>
---
fs/ext2/dir.c | 50 +++++++++++++++++++-------------------------------
fs/ext2/namei.c | 12 ++----------
2 files changed, 21 insertions(+), 41 deletions(-)
diff --git a/fs/ext2/dir.c b/fs/ext2/dir.c
index 4b9cca8..f577cbd 100644
--- a/fs/ext2/dir.c
+++ b/fs/ext2/dir.c
@@ -286,13 +286,19 @@ static unsigned char ext2_type_by_mode[S_IFMT >> S_SHIFT] = {
[S_IFLNK >> S_SHIFT] = EXT2_FT_SYMLINK,
};
-static inline void ext2_set_de_type(ext2_dirent *de, struct inode *inode)
+static inline void ext2_set_de_type(ext2_dirent *de, struct inode *inode,
+ unsigned char file_type)
{
mode_t mode = inode->i_mode;
- if (EXT2_HAS_INCOMPAT_FEATURE(inode->i_sb, EXT2_FEATURE_INCOMPAT_FILETYPE))
- de->file_type = ext2_type_by_mode[(mode & S_IFMT)>>S_SHIFT];
- else
+ if (!EXT2_HAS_INCOMPAT_FEATURE(inode->i_sb, EXT2_FEATURE_INCOMPAT_FILETYPE)) {
de->file_type = 0;
+ return;
+ }
+
+ if (file_type)
+ de->file_type = file_type;
+ else
+ de->file_type = ext2_type_by_mode[(mode & S_IFMT)>>S_SHIFT];
}
static int
@@ -526,7 +532,7 @@ void ext2_set_link(struct inode *dir, struct ext2_dir_entry_2 *de,
err = ext2_prepare_chunk(page, pos, len);
BUG_ON(err);
de->inode = cpu_to_le32(inode->i_ino);
- ext2_set_de_type(de, inode);
+ ext2_set_de_type(de, inode, 0);
err = ext2_commit_chunk(page, pos, len);
ext2_put_page(page);
if (update_times)
@@ -547,7 +553,6 @@ void ext2_set_link(struct inode *dir, struct ext2_dir_entry_2 *de,
*/
int ext2_add_entry (struct dentry *dentry, struct inode *inode,
- ext2_dirent *de, struct page *page,
int new_file_type)
{
struct inode *dir = dentry->d_parent->d_inode;
@@ -558,17 +563,12 @@ int ext2_add_entry (struct dentry *dentry, struct inode *inode,
unsigned short rec_len, name_len;
unsigned long npages = dir_pages(dir);
unsigned long n;
+ ext2_dirent *de;
+ struct page *page;
char *kaddr;
loff_t pos;
int err;
- if (de) {
- name_len = EXT2_DIR_REC_LEN(de->name_len);
- rec_len = ext2_rec_len_from_disk(de->rec_len);
- printk("%s: given de\n", dentry->d_name.name);
- goto got_it;
- }
-
/*
* We take care of directory expansion in the same loop.
* This code plays outside i_size, so it locks the page
@@ -657,13 +657,8 @@ got_it:
}
de->name_len = namelen;
memcpy(de->name, name, namelen);
- if (inode) {
- de->inode = cpu_to_le32(inode->i_ino);
- ext2_set_de_type (de, inode);
- } else {
- de->inode = 0;
- de->file_type = new_file_type;
- }
+ de->inode = cpu_to_le32(ino);
+ ext2_set_de_type(de, inode, new_file_type);
err = ext2_commit_chunk(page, pos, rec_len);
dir->i_mtime = dir->i_ctime = CURRENT_TIME_SEC;
EXT2_I(dir)->i_flags &= ~EXT2_BTREE_FL;
@@ -680,24 +675,17 @@ out_unlock:
int ext2_add_link (struct dentry *dentry, struct inode *inode)
{
- ext2_dirent *de = NULL;
- struct page *page = NULL;
- return ext2_add_entry(dentry, inode, de, page, 0);
+ return ext2_add_entry(dentry, inode->i_ino, 0);
}
-int ext2_whiteout_entry (struct dentry *dentry, ext2_dirent *de, struct page *page)
+int ext2_whiteout_entry (struct dentry *dentry)
{
- return ext2_add_entry(dentry, NULL, de, page, EXT2_FT_WHT);
+ return ext2_add_entry(dentry, 0, EXT2_FT_WHT);
}
-/*
- * Create a fallthru entry.
- */
int ext2_fallthru_entry (struct dentry *dentry)
{
- ext2_dirent *de = NULL;
- struct page *page = NULL;
- return ext2_add_entry(dentry, NULL, de, page, EXT2_FT_FALLTHRU);
+ return ext2_add_entry(dentry, 0, EXT2_FT_FALLTHRU);
}
/*
diff --git a/fs/ext2/namei.c b/fs/ext2/namei.c
index 61db2dd..beb77f2 100644
--- a/fs/ext2/namei.c
+++ b/fs/ext2/namei.c
@@ -329,16 +329,8 @@ static int ext2_whiteout(struct inode *dir, struct dentry *dentry,
dquot_initialize(dir);
- if (inode) {
- if (S_ISDIR(inode->i_mode) && !ext2_empty_dir(inode))
- goto out;
-
- err = -ENOENT;
- de = ext2_find_entry(dir, &dentry->d_name, &page);
- if (!de)
- goto out;
- lock_page(page);
- }
+ if (inode && S_ISDIR(inode->i_mode) && !ext2_empty_dir(inode))
+ goto out;
err = ext2_whiteout_entry(dentry, de, page);
if (err)
^ permalink raw reply related [flat|nested] 79+ messages in thread* [PATCH 75/76] Ext2: Unionmount devel
2011-06-17 16:00 [RFC][PATCH 00/76] Union Mount David Howells
` (74 preceding siblings ...)
2011-06-17 16:11 ` [PATCH 76/76] Temporary commit David Howells
@ 2011-06-17 16:23 ` David Howells
2011-06-17 16:44 ` [RFC][PATCH 00/76] Union Mount Sedat Dilek
76 siblings, 0 replies; 79+ messages in thread
From: David Howells @ 2011-06-17 16:23 UTC (permalink / raw)
To: linux-fsdevel; +Cc: hch, dhowells
From: Valerie Aurora <vaurora@redhat.com>
XXX - works but needs whiteout find entry removed
---
fs/ext2/dir.c | 62 ++++++++++++++++++++++++++++++++++++++++-----------------
1 files changed, 43 insertions(+), 19 deletions(-)
diff --git a/fs/ext2/dir.c b/fs/ext2/dir.c
index be6e397..4b9cca8 100644
--- a/fs/ext2/dir.c
+++ b/fs/ext2/dir.c
@@ -535,6 +535,17 @@ void ext2_set_link(struct inode *dir, struct ext2_dir_entry_2 *de,
mark_inode_dirty(dir);
}
+/*
+ * Called from three settings:
+ *
+ * - Creating a regular entry - de/page NULL, doesn't exist
+ * - Creating a fallthru - de/page NULL, doesn't exist
+ * - Creating a whiteout - de/page set if it exists
+ *
+ * @new_file_type is either EXT2_FT_WHT, EXT2_FT_FALLTHRU, or 0. If
+ * 0, file type is determined by inode->i_mode.
+ */
+
int ext2_add_entry (struct dentry *dentry, struct inode *inode,
ext2_dirent *de, struct page *page,
int new_file_type)
@@ -551,6 +562,13 @@ int ext2_add_entry (struct dentry *dentry, struct inode *inode,
loff_t pos;
int err;
+ if (de) {
+ name_len = EXT2_DIR_REC_LEN(de->name_len);
+ rec_len = ext2_rec_len_from_disk(de->rec_len);
+ printk("%s: given de\n", dentry->d_name.name);
+ goto got_it;
+ }
+
/*
* We take care of directory expansion in the same loop.
* This code plays outside i_size, so it locks the page
@@ -576,6 +594,7 @@ int ext2_add_entry (struct dentry *dentry, struct inode *inode,
de->rec_len = ext2_rec_len_to_disk(chunk_size);
de->inode = 0;
de->file_type = 0;
+ printk("%s: allocated new de\n", dentry->d_name.name);
goto got_it;
}
if (de->rec_len == 0) {
@@ -584,15 +603,24 @@ int ext2_add_entry (struct dentry *dentry, struct inode *inode,
err = -EIO;
goto out_unlock;
}
- err = -EEXIST;
- if (ext2_match (namelen, name, de))
- goto out_unlock;
name_len = EXT2_DIR_REC_LEN(de->name_len);
rec_len = ext2_rec_len_from_disk(de->rec_len);
- if (!ext2_dirent_in_use(de) && rec_len >= reclen)
+ if (ext2_match(namelen, name, de)) {
+ err = -EEXIST;
+ /* XXX handle whiteouts here too */
+ if (de->file_type != EXT2_FT_FALLTHRU)
+ goto out_unlock;
+ printk("%s: found existing de\n", dentry->d_name.name);
+ goto got_it;
+ }
+ if (!ext2_dirent_in_use(de) && rec_len >= reclen) {
+ printk("%s: reusing empty de\n", dentry->d_name.name);
goto got_it;
- if (rec_len >= name_len + reclen)
+ }
+ if (rec_len >= name_len + reclen) {
+ printk("%s: carving off end of in-use de\n", dentry->d_name.name);
goto got_it;
+ }
de = (ext2_dirent *) ((char *) de + rec_len);
}
unlock_page(page);
@@ -603,22 +631,18 @@ int ext2_add_entry (struct dentry *dentry, struct inode *inode,
got_it:
/*
- * Pre-existing entries with the same name are allowable
- * depending on the type of the entry being created. Regular
- * entries replace whiteouts and fallthrus. Whiteouts replace
- * regular entries. Fallthrus replace nothing.
+ * Sanity check what we got. Not allowed:
+ * - fallthru replaced by fallthru
+ * - whiteout replaced by whiteout or fallthru
+ * - not-fallthru replaced by fallthru
*/
- err = -EEXIST;
if (ext2_match(namelen, name, de)) {
- if (new_file_type == EXT2_FT_WHT) {
- if (de->file_type == EXT2_FT_WHT)
- goto out_unlock;
- } else if (new_file_type == EXT2_FT_FALLTHRU) {
- goto out_unlock;
- } else if ((de->file_type != EXT2_FT_WHT) &&
- (de->file_type != EXT2_FT_FALLTHRU)) {
- goto out_unlock;
- }
+ BUG_ON((de->file_type == EXT2_FT_FALLTHRU) &&
+ (new_file_type == EXT2_FT_FALLTHRU));
+ BUG_ON((de->file_type == EXT2_FT_WHT) &&
+ (new_file_type == EXT2_FT_FALLTHRU));
+ BUG_ON((de->file_type == EXT2_FT_WHT) &&
+ (new_file_type = EXT2_FT_WHT));
}
pos = page_offset(page) +
(char*)de - (char*)page_address(page);
^ permalink raw reply related [flat|nested] 79+ messages in thread* Re: [RFC][PATCH 00/76] Union Mount
2011-06-17 16:00 [RFC][PATCH 00/76] Union Mount David Howells
` (75 preceding siblings ...)
2011-06-17 16:23 ` [PATCH 75/76] Ext2: Unionmount devel David Howells
@ 2011-06-17 16:44 ` Sedat Dilek
76 siblings, 0 replies; 79+ messages in thread
From: Sedat Dilek @ 2011-06-17 16:44 UTC (permalink / raw)
To: David Howells; +Cc: linux-fsdevel, hch
On Fri, Jun 17, 2011 at 6:00 PM, David Howells <dhowells@redhat.com> wrote:
>
>
> Here are the unionmount patches brought up to date wrt RCU walk pathwalk and
> other changes.
>
Thanks for reworking the patchset.
Is there a GIT repository around?
- Sedat -
^ permalink raw reply [flat|nested] 79+ messages in thread