@@ -813,7 +813,7 @@ static struct dentry *ceph_lookup(struct inode *dir, struct dentry *dentry,
if (IS_ENCRYPTED(dir)) {
bool had_key = fscrypt_has_encryption_key(dir);
- err = fscrypt_prepare_lookup_partial(dir, dentry);
+ err = fscrypt_prepare_lookup_dentry(dir, dentry);
if (err < 0)
return ERR_PTR(err);
@@ -812,7 +812,7 @@ int ceph_atomic_open(struct inode *dir, struct dentry *dentry,
ihold(dir);
if (IS_ENCRYPTED(dir)) {
set_bit(CEPH_MDS_R_FSCRYPT_FILE, &req->r_req_flags);
- err = fscrypt_prepare_lookup_partial(dir, dentry);
+ err = fscrypt_prepare_lookup_dentry(dir, dentry);
if (err < 0)
goto out_req;
}
@@ -94,52 +94,45 @@ int __fscrypt_prepare_rename(struct inode *old_dir, struct dentry *old_dentry,
}
EXPORT_SYMBOL_GPL(__fscrypt_prepare_rename);
-int __fscrypt_prepare_lookup(struct inode *dir, struct dentry *dentry,
- struct fscrypt_name *fname)
-{
- int err = fscrypt_setup_filename(dir, &dentry->d_name, 1, fname);
-
- if (err && err != -ENOENT)
- return err;
-
- if (fname->is_nokey_name) {
- spin_lock(&dentry->d_lock);
- dentry->d_flags |= DCACHE_NOKEY_NAME;
- spin_unlock(&dentry->d_lock);
- }
- return err;
-}
-EXPORT_SYMBOL_GPL(__fscrypt_prepare_lookup);
-
/**
- * fscrypt_prepare_lookup_partial() - prepare lookup without filename setup
+ * fscrypt_prepare_lookup_dentry() - prepare lookup without filename setup
* @dir: the encrypted directory being searched
* @dentry: the dentry being looked up in @dir
*
- * This function should be used by the ->lookup and ->atomic_open methods of
- * filesystems that handle filename encryption and no-key name encoding
- * themselves and thus can't use fscrypt_prepare_lookup(). Like
- * fscrypt_prepare_lookup(), this will try to set up the directory's encryption
- * key and will set DCACHE_NOKEY_NAME on the dentry if the key is unavailable.
- * However, this function doesn't set up a struct fscrypt_name for the filename.
+ * This function should be used by the ->lookup and ->atomic_open
+ * methods of filesystems that handle filename encryption and no-key
+ * name encoding themselves and thus can't use fscrypt_prepare_lookup()
+ * directly. This will try to set up the directory's encryption key and
+ * will set DCACHE_NOKEY_NAME on the dentry if the key is unavailable.
+ * However, this function doesn't set up a struct fscrypt_name for the
+ * filename.
*
* Return: 0 on success; -errno on error. Note that the encryption key being
* unavailable is not considered an error. It is also not an error if
* the encryption policy is unsupported by this kernel; that is treated
* like the key being unavailable, so that files can still be deleted.
*/
-int fscrypt_prepare_lookup_partial(struct inode *dir, struct dentry *dentry)
+int fscrypt_prepare_lookup_dentry(struct inode *dir,
+ struct dentry *dentry)
{
- int err = fscrypt_get_encryption_info(dir, true);
+ bool nokey_name = false;
+ int err = 0;
- if (!err && !fscrypt_has_encryption_key(dir)) {
- spin_lock(&dentry->d_lock);
+ if (IS_ENCRYPTED(dir)) {
+ err = fscrypt_get_encryption_info(dir, true);
+ if (!err && !fscrypt_has_encryption_key(dir))
+ nokey_name = true;
+ }
+
+ spin_lock(&dentry->d_lock);
+ if (nokey_name) {
dentry->d_flags |= DCACHE_NOKEY_NAME;
- spin_unlock(&dentry->d_lock);
}
+ spin_unlock(&dentry->d_lock);
+
return err;
}
-EXPORT_SYMBOL_GPL(fscrypt_prepare_lookup_partial);
+EXPORT_SYMBOL_GPL(fscrypt_prepare_lookup_dentry);
int __fscrypt_prepare_readdir(struct inode *dir)
{
@@ -382,9 +382,7 @@ int __fscrypt_prepare_link(struct inode *inode, struct inode *dir,
int __fscrypt_prepare_rename(struct inode *old_dir, struct dentry *old_dentry,
struct inode *new_dir, struct dentry *new_dentry,
unsigned int flags);
-int __fscrypt_prepare_lookup(struct inode *dir, struct dentry *dentry,
- struct fscrypt_name *fname);
-int fscrypt_prepare_lookup_partial(struct inode *dir, struct dentry *dentry);
+int fscrypt_prepare_lookup_dentry(struct inode *dir, struct dentry *dentry);
int __fscrypt_prepare_readdir(struct inode *dir);
int __fscrypt_prepare_setattr(struct dentry *dentry, struct iattr *attr);
int fscrypt_prepare_setflags(struct inode *inode,
@@ -704,14 +702,7 @@ static inline int __fscrypt_prepare_rename(struct inode *old_dir,
return -EOPNOTSUPP;
}
-static inline int __fscrypt_prepare_lookup(struct inode *dir,
- struct dentry *dentry,
- struct fscrypt_name *fname)
-{
- return -EOPNOTSUPP;
-}
-
-static inline int fscrypt_prepare_lookup_partial(struct inode *dir,
+static inline int fscrypt_prepare_lookup_dentry(struct inode *dir,
struct dentry *dentry)
{
return -EOPNOTSUPP;
@@ -975,14 +966,27 @@ static inline int fscrypt_prepare_lookup(struct inode *dir,
struct dentry *dentry,
struct fscrypt_name *fname)
{
- if (IS_ENCRYPTED(dir))
- return __fscrypt_prepare_lookup(dir, dentry, fname);
+ int ret, err = 0;
+
+ if (IS_ENCRYPTED(dir)) {
+ err = fscrypt_setup_filename(dir, &dentry->d_name, 1, fname);
+ if (err && err != -ENOENT)
+ return err;
+ } else {
+ memset(fname, 0, sizeof(*fname));
+ fname->usr_fname = &dentry->d_name;
+ fname->disk_name.name = (unsigned char *)dentry->d_name.name;
+ fname->disk_name.len = dentry->d_name.len;
+ }
- memset(fname, 0, sizeof(*fname));
- fname->usr_fname = &dentry->d_name;
- fname->disk_name.name = (unsigned char *)dentry->d_name.name;
- fname->disk_name.len = dentry->d_name.len;
- return 0;
+ /*
+ * fscrypt_prepare_lookup_dentry will succeed even if the
+ * directory key is unavailable but the filename isn't a valid
+ * no-key name (-ENOENT). Thus, propagate the previous
+ * error, if any.
+ */
+ ret = fscrypt_prepare_lookup_dentry(dir, dentry);
+ return err ? err : ret;
}
/**
Right now, we have two functions that can be called by the filesystem during lookup to set up fscrypt internal state for the dentry and inode under lookup: 1) fscrypt_prepare_lookup_dentry_partial: used only by ceph. It sets encryption information in the inode and sets the dentry flag if the key is not available. 2) fscrypt_prepare_lookup: used by everything else. Does all the above, plus also sets struct fname. This patch refactors the code to implement the later using the former. This way, we'll have a single place where we set DCACHE_NOKEY_NAME, in preparation to add more churn to that condition in the following patch. To make the patch simpler, we now call fscrypt_get_encryption_info twice for fscrypt_prepare_lookup, once inside fscrypt_setup_filename and once inside fscrypt_prepare_lookup_dentry. It seems safe to do, and considering it will bail early in the second lookup and most lookups should go to the dcache anyway, it doesn't seem problematic for performance. In addition, we add a function call for the unencrypted case, also during lookup. Apart from the above, it should have no behavior change. I tested ext4/f2fs manually and with fstests, which yielded no regressions. Signed-off-by: Gabriel Krisman Bertazi <krisman@suse.de> --- fs/ceph/dir.c | 2 +- fs/ceph/file.c | 2 +- fs/crypto/hooks.c | 53 ++++++++++++++++++----------------------- include/linux/fscrypt.h | 40 +++++++++++++++++-------------- 4 files changed, 47 insertions(+), 50 deletions(-)