@@ -460,8 +460,8 @@ static struct bio *__bio_alloc(struct f2fs_io_info *fio, int npages)
return bio;
}
-static void f2fs_set_bio_crypt_ctx(struct bio *bio, const struct inode *inode,
- pgoff_t first_idx,
+static void f2fs_set_bio_crypt_ctx(struct bio *bio, block_t blk_addr,
+ const struct inode *inode, pgoff_t first_idx,
const struct f2fs_io_info *fio,
gfp_t gfp_mask)
{
@@ -470,7 +470,7 @@ static void f2fs_set_bio_crypt_ctx(struct bio *bio, const struct inode *inode,
* read/write raw data without encryption.
*/
if (!fio || !fio->encrypted_page)
- fscrypt_set_bio_crypt_ctx(bio, 0, inode, first_idx, gfp_mask);
+ fscrypt_set_bio_crypt_ctx(bio, blk_addr, inode, first_idx, gfp_mask);
}
static bool f2fs_crypt_mergeable_bio(struct bio *bio, const struct inode *inode,
@@ -712,7 +712,7 @@ int f2fs_submit_page_bio(struct f2fs_io_info *fio)
/* Allocate a new bio */
bio = __bio_alloc(fio, 1);
- f2fs_set_bio_crypt_ctx(bio, fio->page->mapping->host,
+ f2fs_set_bio_crypt_ctx(bio, fio->new_blkaddr, fio->page->mapping->host,
fio->page->index, fio, GFP_NOIO);
if (bio_add_page(bio, page, PAGE_SIZE, 0) < PAGE_SIZE) {
@@ -918,7 +918,8 @@ int f2fs_merge_page_bio(struct f2fs_io_info *fio)
if (!bio) {
bio = __bio_alloc(fio, BIO_MAX_PAGES);
__attach_io_flag(fio);
- f2fs_set_bio_crypt_ctx(bio, fio->page->mapping->host,
+ f2fs_set_bio_crypt_ctx(bio, fio->new_blkaddr,
+ fio->page->mapping->host,
fio->page->index, fio, GFP_NOIO);
bio_set_op_attrs(bio, fio->op, fio->op_flags);
@@ -992,7 +993,8 @@ void f2fs_submit_page_write(struct f2fs_io_info *fio)
goto skip;
}
io->bio = __bio_alloc(fio, BIO_MAX_PAGES);
- f2fs_set_bio_crypt_ctx(io->bio, fio->page->mapping->host,
+ f2fs_set_bio_crypt_ctx(io->bio, fio->new_blkaddr,
+ fio->page->mapping->host,
bio_page->index, fio, GFP_NOIO);
io->fio = *fio;
}
@@ -1039,9 +1041,8 @@ static struct bio *f2fs_grab_read_bio(struct inode *inode, block_t blkaddr,
if (!bio)
return ERR_PTR(-ENOMEM);
- f2fs_set_bio_crypt_ctx(bio, inode, first_idx, NULL, GFP_NOFS);
-
f2fs_target_device(sbi, blkaddr, bio);
+ f2fs_set_bio_crypt_ctx(bio, blkaddr, inode, first_idx, NULL, GFP_NOFS);
bio->bi_end_io = f2fs_read_end_io;
bio_set_op_attrs(bio, REQ_OP_READ, op_flag);
@@ -4122,6 +4122,8 @@ static inline bool f2fs_force_buffered_io(struct inode *inode,
if (f2fs_post_read_required(inode))
return true;
+ if (fscrypt_metadata_crypted(sbi->sb))
+ return true;
if (f2fs_is_multi_device(sbi))
return true;
/*
@@ -981,7 +981,6 @@ static int parse_options(struct super_block *sb, char *options, bool is_remount)
return -EINVAL;
}
#endif
-
if (F2FS_IO_SIZE_BITS(sbi) && !f2fs_lfs_mode(sbi)) {
f2fs_err(sbi, "Should set mode=lfs with %uKB-sized IO",
F2FS_IO_SIZE_KB(sbi));
@@ -1268,6 +1267,8 @@ static void f2fs_put_super(struct super_block *sb)
iput(sbi->meta_inode);
sbi->meta_inode = NULL;
+ fscrypt_free_metadata_encryption(sb);
+
/*
* iput() can update stat information, if f2fs_write_checkpoint()
* above failed with error.
@@ -2533,6 +2534,9 @@ static int f2fs_get_num_devices(struct super_block *sb)
{
struct f2fs_sb_info *sbi = F2FS_SB(sb);
+ if (!sbi)
+ return 0;
+
if (f2fs_is_multi_device(sbi))
return sbi->s_ndevs;
return 1;
@@ -2910,6 +2914,13 @@ static int sanity_check_raw_super(struct f2fs_sb_info *sbi,
return -EFSCORRUPTED;
}
+ /* Check if FS has metadata encryption if kernel doesn't support it */
+#ifndef CONFIG_FS_ENCRYPTION_METADATA
+ if (raw_super->metadata_crypt_alg) {
+ f2fs_err(sbi, "Filesystem has metadata encryption but kernel support for it wasn't enabled");
+ return -EINVAL;
+ }
+#endif
/* check CP/SIT/NAT/SSA/MAIN_AREA area boundary */
if (sanity_check_area_boundary(sbi, bh))
return -EFSCORRUPTED;
@@ -3510,6 +3521,21 @@ static int f2fs_fill_super(struct super_block *sb, void *data, int silent)
sizeof(raw_super->uuid));
default_options(sbi);
+
+#ifdef CONFIG_FS_ENCRYPTION
+ sb->s_cop = &f2fs_cryptops;
+#endif
+ if (sbi->raw_super->metadata_crypt_alg) {
+ err = fscrypt_setup_metadata_encryption(sb,
+ sbi->raw_super->metadata_crypt_key_ident,
+ le32_to_cpu(sbi->raw_super->metadata_crypt_alg),
+ sizeof(block_t));
+ if (err) {
+ f2fs_err(sbi, "Could not setup metadata encryption");
+ goto free_sb_buf;
+ }
+ }
+
/* parse mount options */
options = kstrdup((const char *)data, GFP_KERNEL);
if (data && !options) {
@@ -3544,9 +3570,6 @@ static int f2fs_fill_super(struct super_block *sb, void *data, int silent)
#endif
sb->s_op = &f2fs_sops;
-#ifdef CONFIG_FS_ENCRYPTION
- sb->s_cop = &f2fs_cryptops;
-#endif
#ifdef CONFIG_FS_VERITY
sb->s_vop = &f2fs_verityops;
#endif
@@ -3658,6 +3681,12 @@ static int f2fs_fill_super(struct super_block *sb, void *data, int silent)
goto free_devices;
}
+ err = fscrypt_metadata_crypt_prepare_all_devices(sb);
+ if (err) {
+ f2fs_err(sbi, "Failed to initialize metadata crypt on all devices");
+ goto free_devices;
+ }
+
err = f2fs_init_post_read_wq(sbi);
if (err) {
f2fs_err(sbi, "Failed to initialize post read workqueue");
@@ -3860,6 +3889,12 @@ static int f2fs_fill_super(struct super_block *sb, void *data, int silent)
f2fs_notice(sbi, "Mounted with checkpoint version = %llx",
cur_cp_version(F2FS_CKPT(sbi)));
+ if (fscrypt_metadata_crypted(sb)) {
+ f2fs_notice(sbi, "Mounted with metadata key identifier = %s%*phN",
+ FSCRYPT_KEY_DESC_PREFIX,
+ FSCRYPT_KEY_IDENTIFIER_SIZE,
+ sbi->raw_super->metadata_crypt_key_ident);
+ }
f2fs_update_time(sbi, CP_TIME);
f2fs_update_time(sbi, REQ_TIME);
clear_sbi_flag(sbi, SBI_CP_DISABLED_QUICK);
@@ -3931,6 +3966,7 @@ static int f2fs_fill_super(struct super_block *sb, void *data, int silent)
fscrypt_free_dummy_policy(&F2FS_OPTION(sbi).dummy_enc_policy);
kvfree(options);
free_sb_buf:
+ fscrypt_free_metadata_encryption(sb);
kfree(raw_super);
free_sbi:
if (sbi->s_chksum_driver)
@@ -10,6 +10,7 @@
#include <linux/pagemap.h>
#include <linux/types.h>
+#include <linux/fscrypt.h>
#define F2FS_SUPER_OFFSET 1024 /* byte-size offset */
#define F2FS_MIN_LOG_SECTOR_SIZE 9 /* 9 bits for 512 bytes */
@@ -115,7 +116,11 @@ struct f2fs_super_block {
__u8 hot_ext_count; /* # of hot file extension */
__le16 s_encoding; /* Filename charset encoding */
__le16 s_encoding_flags; /* Filename charset encoding flags */
- __u8 reserved[306]; /* valid reserved region */
+ /* The metadata encryption algorithm (FSCRYPT_MODE_*) */
+ __le32 metadata_crypt_alg;
+ /* The metadata encryption key identifier */
+ __u8 metadata_crypt_key_ident[FSCRYPT_KEY_IDENTIFIER_SIZE];
+ __u8 reserved[286]; /* valid reserved region */
__le32 crc; /* checksum of superblock */
} __packed;
Wire up metadata encryption support with the fscrypt metadata crypt additions. Note that this feature relies on the blk-crypto framework for encryption, and thus requires either hardware inline encryption support or the blk-crypto-fallback. Filesystems can be configured with metadata encryption support using the f2fs userspace tools (mkfs.f2fs). Once formatted, F2FS filesystems with metadata encryption can be mounted as long as the required key is present. fscrypt looks for a logon key with the key descriptor= fscrypt:<metadata_key_identifier>. The metadata_key_identifier is stored in the filesystem superblock (and the userspace tools print the required key descriptor). Right now, the superblock of the filesystem is itself not encrypted. F2FS reads the superblock using sb_bread, which uses the bd_inode of the block device as the address space for any data it reads from the block device - the data read under the bd_inode address space must be what is physically present on disk (i.e. if the superblock is encrypted, then the ciphertext of the superblock must be present in the page cache in the bd_inode's address space), but f2fs requires that the superblock is decrypted by blk-crypto, which would put the decrypted page contents into the page cache instead. We could make f2fs read the superblock by submitting bios directly with a separate address space, but we choose to just not encrypt the superblock for now. Not encrypting the superblock allows us to store the encryption algorithm used for metadata encryption within the superblock itself, which simplifies a few things. The userspace tools will store the encryption algorithm in the superblock when formatting the FS. Direct I/O with metadata encryption is also not supported for now. Attempts to do direct I/O on a metadata encrypted F2FS filesystem will fall back to using buffered I/O (just as attempts to do direct I/O on fscrypt encrypted files also fall back to buffered I/O). Signed-off-by: Satya Tangirala <satyat@google.com> --- fs/f2fs/data.c | 17 ++++++++-------- fs/f2fs/f2fs.h | 2 ++ fs/f2fs/super.c | 44 +++++++++++++++++++++++++++++++++++++---- include/linux/f2fs_fs.h | 7 ++++++- 4 files changed, 57 insertions(+), 13 deletions(-)