128 lines
3.4 KiB
C
128 lines
3.4 KiB
C
// SPDX-License-Identifier: GPL-2.0
|
|
|
|
#include <linux/quotaops.h>
|
|
|
|
#include "ext4.h"
|
|
#include "xattr.h"
|
|
#include "ext4_jbd2.h"
|
|
|
|
static int ext4_get_context(struct inode *inode, void *ctx, size_t len)
|
|
{
|
|
return ext4_xattr_get(inode, EXT4_XATTR_INDEX_ENCRYPTION,
|
|
EXT4_XATTR_NAME_ENCRYPTION_CONTEXT, ctx, len);
|
|
}
|
|
|
|
static int ext4_set_context(struct inode *inode, const void *ctx, size_t len,
|
|
void *fs_data)
|
|
{
|
|
handle_t *handle = fs_data;
|
|
int res, res2, credits, retries = 0;
|
|
|
|
/*
|
|
* Encrypting the root directory is not allowed because e2fsck expects
|
|
* lost+found to exist and be unencrypted, and encrypting the root
|
|
* directory would imply encrypting the lost+found directory as well as
|
|
* the filename "lost+found" itself.
|
|
*/
|
|
if (inode->i_ino == EXT4_ROOT_INO)
|
|
return -EPERM;
|
|
|
|
if (WARN_ON_ONCE(IS_DAX(inode) && i_size_read(inode)))
|
|
return -EINVAL;
|
|
|
|
if (ext4_test_inode_flag(inode, EXT4_INODE_DAX))
|
|
return -EOPNOTSUPP;
|
|
|
|
res = ext4_convert_inline_data(inode);
|
|
if (res)
|
|
return res;
|
|
|
|
/*
|
|
* If a journal handle was specified, then the encryption context is
|
|
* being set on a new inode via inheritance and is part of a larger
|
|
* transaction to create the inode. Otherwise the encryption context is
|
|
* being set on an existing inode in its own transaction. Only in the
|
|
* latter case should the "retry on ENOSPC" logic be used.
|
|
*/
|
|
|
|
if (handle) {
|
|
res = ext4_xattr_set_handle(handle, inode,
|
|
EXT4_XATTR_INDEX_ENCRYPTION,
|
|
EXT4_XATTR_NAME_ENCRYPTION_CONTEXT,
|
|
ctx, len, 0);
|
|
if (!res) {
|
|
ext4_set_inode_flag(inode, EXT4_INODE_ENCRYPT);
|
|
ext4_clear_inode_state(inode,
|
|
EXT4_STATE_MAY_INLINE_DATA);
|
|
/*
|
|
* Update inode->i_flags - S_ENCRYPTED will be enabled,
|
|
* S_DAX may be disabled
|
|
*/
|
|
ext4_set_inode_flags(inode, false);
|
|
}
|
|
return res;
|
|
}
|
|
|
|
res = dquot_initialize(inode);
|
|
if (res)
|
|
return res;
|
|
retry:
|
|
res = ext4_xattr_set_credits(inode, len, false /* is_create */,
|
|
&credits);
|
|
if (res)
|
|
return res;
|
|
|
|
handle = ext4_journal_start(inode, EXT4_HT_MISC, credits);
|
|
if (IS_ERR(handle))
|
|
return PTR_ERR(handle);
|
|
|
|
res = ext4_xattr_set_handle(handle, inode, EXT4_XATTR_INDEX_ENCRYPTION,
|
|
EXT4_XATTR_NAME_ENCRYPTION_CONTEXT,
|
|
ctx, len, 0);
|
|
if (!res) {
|
|
ext4_set_inode_flag(inode, EXT4_INODE_ENCRYPT);
|
|
/*
|
|
* Update inode->i_flags - S_ENCRYPTED will be enabled,
|
|
* S_DAX may be disabled
|
|
*/
|
|
ext4_set_inode_flags(inode, false);
|
|
res = ext4_mark_inode_dirty(handle, inode);
|
|
if (res)
|
|
EXT4_ERROR_INODE(inode, "Failed to mark inode dirty");
|
|
}
|
|
res2 = ext4_journal_stop(handle);
|
|
|
|
if (res == -ENOSPC && ext4_should_retry_alloc(inode->i_sb, &retries))
|
|
goto retry;
|
|
if (!res)
|
|
res = res2;
|
|
return res;
|
|
}
|
|
|
|
static const union fscrypt_policy *ext4_get_dummy_policy(struct super_block *sb)
|
|
{
|
|
return EXT4_SB(sb)->s_dummy_enc_policy.policy;
|
|
}
|
|
|
|
static bool ext4_has_stable_inodes(struct super_block *sb)
|
|
{
|
|
return ext4_has_feature_stable_inodes(sb);
|
|
}
|
|
|
|
static void ext4_get_ino_and_lblk_bits(struct super_block *sb,
|
|
int *ino_bits_ret, int *lblk_bits_ret)
|
|
{
|
|
*ino_bits_ret = 8 * sizeof(EXT4_SB(sb)->s_es->s_inodes_count);
|
|
*lblk_bits_ret = 8 * sizeof(ext4_lblk_t);
|
|
}
|
|
|
|
const struct fscrypt_operations ext4_cryptops = {
|
|
.key_prefix = "ext4:",
|
|
.get_context = ext4_get_context,
|
|
.set_context = ext4_set_context,
|
|
.get_dummy_policy = ext4_get_dummy_policy,
|
|
.empty_dir = ext4_empty_dir,
|
|
.has_stable_inodes = ext4_has_stable_inodes,
|
|
.get_ino_and_lblk_bits = ext4_get_ino_and_lblk_bits,
|
|
};
|