| From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001 |
| From: Daniel Rosenberg <drosen@google.com> |
| Date: Mon, 27 Jan 2020 20:04:40 -0800 |
| Subject: FROMLIST: fscrypt: Have filesystems handle their d_ops |
| |
| This shifts the responsibility of setting up dentry operations from |
| fscrypt to the individual filesystems, allowing them to have their own |
| operations while still setting fscrypt's d_revalidate as appropriate. |
| |
| Also added helper function to libfs to unify ext4 and f2fs |
| implementations. |
| |
| Signed-off-by: Daniel Rosenberg <drosen@google.com> |
| Test: Boots, /data/media is case insensitive |
| Bug: 138322712 |
| Link: https://lore.kernel.org/linux-f2fs-devel/20200208013552.241832-1-drosen@google.com/T/#t |
| Change-Id: Iaf77f8c5961ecf22e22478701ab0b7fe2025225d |
| --- |
| fs/crypto/fname.c | 7 ++---- |
| fs/crypto/fscrypt_private.h | 1 - |
| fs/crypto/hooks.c | 1 - |
| fs/ext4/dir.c | 7 ------ |
| fs/ext4/namei.c | 1 + |
| fs/ext4/super.c | 5 ---- |
| fs/f2fs/dir.c | 7 ------ |
| fs/f2fs/f2fs.h | 3 --- |
| fs/f2fs/namei.c | 1 + |
| fs/f2fs/super.c | 1 - |
| fs/libfs.c | 50 +++++++++++++++++++++++++++++++++++++ |
| fs/ubifs/dir.c | 18 +++++++++++++ |
| include/linux/fs.h | 2 ++ |
| include/linux/fscrypt.h | 6 +++-- |
| 14 files changed, 78 insertions(+), 32 deletions(-) |
| |
| diff --git a/fs/crypto/fname.c b/fs/crypto/fname.c |
| --- a/fs/crypto/fname.c |
| +++ b/fs/crypto/fname.c |
| @@ -562,7 +562,7 @@ EXPORT_SYMBOL_GPL(fscrypt_fname_siphash); |
| * Validate dentries in encrypted directories to make sure we aren't potentially |
| * caching stale dentries after a key has been added. |
| */ |
| -static int fscrypt_d_revalidate(struct dentry *dentry, unsigned int flags) |
| +int fscrypt_d_revalidate(struct dentry *dentry, unsigned int flags) |
| { |
| struct dentry *dir; |
| int err; |
| @@ -601,7 +601,4 @@ static int fscrypt_d_revalidate(struct dentry *dentry, unsigned int flags) |
| |
| return valid; |
| } |
| - |
| -const struct dentry_operations fscrypt_d_ops = { |
| - .d_revalidate = fscrypt_d_revalidate, |
| -}; |
| +EXPORT_SYMBOL(fscrypt_d_revalidate); |
| diff --git a/fs/crypto/fscrypt_private.h b/fs/crypto/fscrypt_private.h |
| --- a/fs/crypto/fscrypt_private.h |
| +++ b/fs/crypto/fscrypt_private.h |
| @@ -295,7 +295,6 @@ int fscrypt_fname_encrypt(const struct inode *inode, const struct qstr *iname, |
| u8 *out, unsigned int olen); |
| bool fscrypt_fname_encrypted_size(const struct inode *inode, u32 orig_len, |
| u32 max_len, u32 *encrypted_len_ret); |
| -extern const struct dentry_operations fscrypt_d_ops; |
| |
| /* hkdf.c */ |
| |
| diff --git a/fs/crypto/hooks.c b/fs/crypto/hooks.c |
| --- a/fs/crypto/hooks.c |
| +++ b/fs/crypto/hooks.c |
| @@ -118,7 +118,6 @@ int __fscrypt_prepare_lookup(struct inode *dir, struct dentry *dentry, |
| spin_lock(&dentry->d_lock); |
| dentry->d_flags |= DCACHE_ENCRYPTED_NAME; |
| spin_unlock(&dentry->d_lock); |
| - d_set_d_op(dentry, &fscrypt_d_ops); |
| } |
| return err; |
| } |
| diff --git a/fs/ext4/dir.c b/fs/ext4/dir.c |
| --- a/fs/ext4/dir.c |
| +++ b/fs/ext4/dir.c |
| @@ -667,10 +667,3 @@ const struct file_operations ext4_dir_operations = { |
| .open = ext4_dir_open, |
| .release = ext4_release_dir, |
| }; |
| - |
| -#ifdef CONFIG_UNICODE |
| -const struct dentry_operations ext4_dentry_ops = { |
| - .d_hash = generic_ci_d_hash, |
| - .d_compare = generic_ci_d_compare, |
| -}; |
| -#endif |
| diff --git a/fs/ext4/namei.c b/fs/ext4/namei.c |
| --- a/fs/ext4/namei.c |
| +++ b/fs/ext4/namei.c |
| @@ -1615,6 +1615,7 @@ static struct buffer_head *ext4_lookup_entry(struct inode *dir, |
| struct buffer_head *bh; |
| |
| err = ext4_fname_prepare_lookup(dir, dentry, &fname); |
| + generic_set_encrypted_ci_d_ops(dir, dentry); |
| if (err == -ENOENT) |
| return NULL; |
| if (err) |
| diff --git a/fs/ext4/super.c b/fs/ext4/super.c |
| --- a/fs/ext4/super.c |
| +++ b/fs/ext4/super.c |
| @@ -4629,11 +4629,6 @@ static int ext4_fill_super(struct super_block *sb, void *data, int silent) |
| goto failed_mount4; |
| } |
| |
| -#ifdef CONFIG_UNICODE |
| - if (sb->s_encoding) |
| - sb->s_d_op = &ext4_dentry_ops; |
| -#endif |
| - |
| sb->s_root = d_make_root(root); |
| if (!sb->s_root) { |
| ext4_msg(sb, KERN_ERR, "get root dentry failed"); |
| diff --git a/fs/f2fs/dir.c b/fs/f2fs/dir.c |
| --- a/fs/f2fs/dir.c |
| +++ b/fs/f2fs/dir.c |
| @@ -1075,10 +1075,3 @@ const struct file_operations f2fs_dir_operations = { |
| .compat_ioctl = f2fs_compat_ioctl, |
| #endif |
| }; |
| - |
| -#ifdef CONFIG_UNICODE |
| -const struct dentry_operations f2fs_dentry_ops = { |
| - .d_hash = generic_ci_d_hash, |
| - .d_compare = generic_ci_d_compare, |
| -}; |
| -#endif |
| diff --git a/fs/f2fs/f2fs.h b/fs/f2fs/f2fs.h |
| --- a/fs/f2fs/f2fs.h |
| +++ b/fs/f2fs/f2fs.h |
| @@ -3658,9 +3658,6 @@ static inline void update_sit_info(struct f2fs_sb_info *sbi) {} |
| #endif |
| |
| extern const struct file_operations f2fs_dir_operations; |
| -#ifdef CONFIG_UNICODE |
| -extern const struct dentry_operations f2fs_dentry_ops; |
| -#endif |
| extern const struct file_operations f2fs_file_operations; |
| extern const struct inode_operations f2fs_file_inode_operations; |
| extern const struct address_space_operations f2fs_dblock_aops; |
| diff --git a/fs/f2fs/namei.c b/fs/f2fs/namei.c |
| --- a/fs/f2fs/namei.c |
| +++ b/fs/f2fs/namei.c |
| @@ -492,6 +492,7 @@ static struct dentry *f2fs_lookup(struct inode *dir, struct dentry *dentry, |
| } |
| |
| err = fscrypt_prepare_lookup(dir, dentry, &fname); |
| + generic_set_encrypted_ci_d_ops(dir, dentry); |
| if (err == -ENOENT) |
| goto out_splice; |
| if (err) |
| diff --git a/fs/f2fs/super.c b/fs/f2fs/super.c |
| --- a/fs/f2fs/super.c |
| +++ b/fs/f2fs/super.c |
| @@ -3348,7 +3348,6 @@ static int f2fs_setup_casefold(struct f2fs_sb_info *sbi) |
| |
| sbi->sb->s_encoding = encoding; |
| sbi->sb->s_encoding_flags = encoding_flags; |
| - sbi->sb->s_d_op = &f2fs_dentry_ops; |
| } |
| #else |
| if (f2fs_sb_has_casefold(sbi)) { |
| diff --git a/fs/libfs.c b/fs/libfs.c |
| --- a/fs/libfs.c |
| +++ b/fs/libfs.c |
| @@ -1423,4 +1423,54 @@ int generic_ci_d_hash(const struct dentry *dentry, struct qstr *str) |
| return ret; |
| } |
| EXPORT_SYMBOL(generic_ci_d_hash); |
| + |
| +static const struct dentry_operations generic_ci_dentry_ops = { |
| + .d_hash = generic_ci_d_hash, |
| + .d_compare = generic_ci_d_compare, |
| +}; |
| +#endif |
| + |
| +#ifdef CONFIG_FS_ENCRYPTION |
| +static const struct dentry_operations generic_encrypted_dentry_ops = { |
| + .d_revalidate = fscrypt_d_revalidate, |
| +}; |
| +#endif |
| + |
| +#if IS_ENABLED(CONFIG_UNICODE) && IS_ENABLED(CONFIG_FS_ENCRYPTION) |
| +static const struct dentry_operations generic_encrypted_ci_dentry_ops = { |
| + .d_hash = generic_ci_d_hash, |
| + .d_compare = generic_ci_d_compare, |
| + .d_revalidate = fscrypt_d_revalidate, |
| +}; |
| +#endif |
| + |
| +/** |
| + * generic_set_encrypted_ci_d_ops - helper for setting d_ops for given dentry |
| + * @dir: parent of dentry whose ops to set |
| + * @dentry: detnry to set ops on |
| + * |
| + * This function sets the dentry ops for the given dentry to handle both |
| + * casefolding and encryption of the dentry name. |
| + */ |
| +void generic_set_encrypted_ci_d_ops(struct inode *dir, struct dentry *dentry) |
| +{ |
| +#ifdef CONFIG_FS_ENCRYPTION |
| + if (dentry->d_flags & DCACHE_ENCRYPTED_NAME) { |
| +#ifdef CONFIG_UNICODE |
| + if (dir->i_sb->s_encoding) { |
| + d_set_d_op(dentry, &generic_encrypted_ci_dentry_ops); |
| + return; |
| + } |
| #endif |
| + d_set_d_op(dentry, &generic_encrypted_dentry_ops); |
| + return; |
| + } |
| +#endif |
| +#ifdef CONFIG_UNICODE |
| + if (dir->i_sb->s_encoding) { |
| + d_set_d_op(dentry, &generic_ci_dentry_ops); |
| + return; |
| + } |
| +#endif |
| +} |
| +EXPORT_SYMBOL(generic_set_encrypted_ci_d_ops); |
| diff --git a/fs/ubifs/dir.c b/fs/ubifs/dir.c |
| --- a/fs/ubifs/dir.c |
| +++ b/fs/ubifs/dir.c |
| @@ -196,6 +196,7 @@ static int dbg_check_name(const struct ubifs_info *c, |
| return 0; |
| } |
| |
| +static void ubifs_set_d_ops(struct inode *dir, struct dentry *dentry); |
| static struct dentry *ubifs_lookup(struct inode *dir, struct dentry *dentry, |
| unsigned int flags) |
| { |
| @@ -209,6 +210,7 @@ static struct dentry *ubifs_lookup(struct inode *dir, struct dentry *dentry, |
| dbg_gen("'%pd' in dir ino %lu", dentry, dir->i_ino); |
| |
| err = fscrypt_prepare_lookup(dir, dentry, &nm); |
| + ubifs_set_d_ops(dir, dentry); |
| if (err == -ENOENT) |
| return d_splice_alias(NULL, dentry); |
| if (err) |
| @@ -1655,3 +1657,19 @@ const struct file_operations ubifs_dir_operations = { |
| .compat_ioctl = ubifs_compat_ioctl, |
| #endif |
| }; |
| + |
| +#ifdef CONFIG_FS_ENCRYPTION |
| +static const struct dentry_operations ubifs_encrypted_dentry_ops = { |
| + .d_revalidate = fscrypt_d_revalidate, |
| +}; |
| +#endif |
| + |
| +static void ubifs_set_d_ops(struct inode *dir, struct dentry *dentry) |
| +{ |
| +#ifdef CONFIG_FS_ENCRYPTION |
| + if (dentry->d_flags & DCACHE_ENCRYPTED_NAME) { |
| + d_set_d_op(dentry, &ubifs_encrypted_dentry_ops); |
| + return; |
| + } |
| +#endif |
| +} |
| diff --git a/include/linux/fs.h b/include/linux/fs.h |
| --- a/include/linux/fs.h |
| +++ b/include/linux/fs.h |
| @@ -3402,6 +3402,8 @@ static inline bool needs_casefold(const struct inode *dir) |
| return 0; |
| } |
| #endif |
| +extern void generic_set_encrypted_ci_d_ops(struct inode *dir, |
| + struct dentry *dentry); |
| |
| #ifdef CONFIG_MIGRATION |
| extern int buffer_migrate_page(struct address_space *, |
| diff --git a/include/linux/fscrypt.h b/include/linux/fscrypt.h |
| --- a/include/linux/fscrypt.h |
| +++ b/include/linux/fscrypt.h |
| @@ -145,6 +145,7 @@ static inline struct page *fscrypt_pagecache_page(struct page *bounce_page) |
| } |
| |
| void fscrypt_free_bounce_page(struct page *bounce_page); |
| +int fscrypt_d_revalidate(struct dentry *dentry, unsigned int flags); |
| |
| /* policy.c */ |
| int fscrypt_ioctl_set_policy(struct file *filp, const void __user *arg); |
| @@ -724,8 +725,9 @@ static inline int fscrypt_prepare_rename(struct inode *old_dir, |
| * filenames are presented in encrypted form. Therefore, we'll try to set up |
| * the directory's encryption key, but even without it the lookup can continue. |
| * |
| - * This also installs a custom ->d_revalidate() method which will invalidate the |
| - * dentry if it was created without the key and the key is later added. |
| + * After calling this function, a filesystem should ensure that it's dentry |
| + * operations contain fscrypt_d_revalidate if DCACHE_ENCRYPTED_NAME was set, |
| + * so that the dentry can be invalidated if the key is later added. |
| * |
| * Return: 0 on success; -ENOENT if key is unavailable but the filename isn't a |
| * correctly formed encoded ciphertext name, so a negative dentry should be |