fs: limit filesystem stacking depth
authorMiklos Szeredi <mszeredi@suse.cz>
Thu, 23 Oct 2014 22:14:39 +0000 (00:14 +0200)
committerMiklos Szeredi <mszeredi@suse.cz>
Thu, 23 Oct 2014 22:14:39 +0000 (00:14 +0200)
Add a simple read-only counter to super_block that indicates how deep this
is in the stack of filesystems.  Previously ecryptfs was the only stackable
filesystem and it explicitly disallowed multiple layers of itself.

Overlayfs, however, can be stacked recursively and also may be stacked
on top of ecryptfs or vice versa.

To limit the kernel stack usage we must limit the depth of the
filesystem stack.  Initially the limit is set to 2.

Signed-off-by: Miklos Szeredi <mszeredi@suse.cz>
fs/ecryptfs/main.c
fs/overlayfs/super.c
include/linux/fs.h

index 1b119d3bf924d16eea7f91f52449b122ecb5dcb1..c4cd1fd86cc2ffd4a09beddd3aca3f25d1fdb06f 100644 (file)
@@ -566,6 +566,13 @@ static struct dentry *ecryptfs_mount(struct file_system_type *fs_type, int flags
        s->s_maxbytes = path.dentry->d_sb->s_maxbytes;
        s->s_blocksize = path.dentry->d_sb->s_blocksize;
        s->s_magic = ECRYPTFS_SUPER_MAGIC;
        s->s_maxbytes = path.dentry->d_sb->s_maxbytes;
        s->s_blocksize = path.dentry->d_sb->s_blocksize;
        s->s_magic = ECRYPTFS_SUPER_MAGIC;
+       s->s_stack_depth = path.dentry->d_sb->s_stack_depth + 1;
+
+       rc = -EINVAL;
+       if (s->s_stack_depth > FILESYSTEM_MAX_STACK_DEPTH) {
+               pr_err("eCryptfs: maximum fs stacking depth exceeded\n");
+               goto out_free;
+       }
 
        inode = ecryptfs_get_inode(path.dentry->d_inode, s);
        rc = PTR_ERR(inode);
 
        inode = ecryptfs_get_inode(path.dentry->d_inode, s);
        rc = PTR_ERR(inode);
index 7dcc24e844179ee792a170135e864f7697f29f0d..08b704cebfc4f8819944e09b05f5f7de35659b92 100644 (file)
@@ -677,6 +677,15 @@ static int ovl_fill_super(struct super_block *sb, void *data, int silent)
        }
        ufs->lower_namelen = statfs.f_namelen;
 
        }
        ufs->lower_namelen = statfs.f_namelen;
 
+       sb->s_stack_depth = max(upperpath.mnt->mnt_sb->s_stack_depth,
+                               lowerpath.mnt->mnt_sb->s_stack_depth) + 1;
+
+       err = -EINVAL;
+       if (sb->s_stack_depth > FILESYSTEM_MAX_STACK_DEPTH) {
+               pr_err("overlayfs: maximum fs stacking depth exceeded\n");
+               goto out_put_workpath;
+       }
+
        ufs->upper_mnt = clone_private_mount(&upperpath);
        err = PTR_ERR(ufs->upper_mnt);
        if (IS_ERR(ufs->upper_mnt)) {
        ufs->upper_mnt = clone_private_mount(&upperpath);
        err = PTR_ERR(ufs->upper_mnt);
        if (IS_ERR(ufs->upper_mnt)) {
index 69118b3cb917b447731ab8ff420c57122898cf37..4e41a4a331bbf96c4b59c05cd9a0c522efec92ca 100644 (file)
@@ -261,6 +261,12 @@ struct iattr {
  */
 #include <linux/quota.h>
 
  */
 #include <linux/quota.h>
 
+/*
+ * Maximum number of layers of fs stack.  Needs to be limited to
+ * prevent kernel stack overflow
+ */
+#define FILESYSTEM_MAX_STACK_DEPTH 2
+
 /** 
  * enum positive_aop_returns - aop return codes with specific semantics
  *
 /** 
  * enum positive_aop_returns - aop return codes with specific semantics
  *
@@ -1273,6 +1279,11 @@ struct super_block {
        struct list_lru         s_dentry_lru ____cacheline_aligned_in_smp;
        struct list_lru         s_inode_lru ____cacheline_aligned_in_smp;
        struct rcu_head         rcu;
        struct list_lru         s_dentry_lru ____cacheline_aligned_in_smp;
        struct list_lru         s_inode_lru ____cacheline_aligned_in_smp;
        struct rcu_head         rcu;
+
+       /*
+        * Indicates how deep in a filesystem stack this SB is
+        */
+       int s_stack_depth;
 };
 
 extern struct timespec current_fs_time(struct super_block *sb);
 };
 
 extern struct timespec current_fs_time(struct super_block *sb);