btrfs: add fscrypt support
Subsystems (4)
v3 cover btrfs: add fscrypt support
Hello,
v1 and v2 of these patches can be found here
https://lore.kernel.org/linux-btrfs/[email protected]/
https://lore.kernel.org/linux-btrfs/[email protected]/
v2->v3:
- Rebased onto Eric's "fscrypt: track master key presence separately from secret" patch.
- Fixed a problem where we weren't setting the logical offset for split bios properly, resulting in csum corruptions.
- Updated the documentation and changelog to call out that inline encryption was required for extent based encryption and why.
- Folded "fscrypt: disable all but standard v2 policies for extent encryption" into "fscrypt: add per-extent encryption support" per Eric's request.
- Changed the behavior of the secret clearing to only do this when we're using extent based encryption.
- Updated the blk-crypto patch to have a helper that made sure we're using the fallback profile instead of adding a flag to the profile.
I've run this through the tests and everything came out fine. Thanks,
Josef
Josef Bacik (19):
fscrypt: add per-extent encryption support
fscrypt: conditionally don't wipe mk secret until the last active user
is done
blk-crypto: add a process bio callback
fscrypt: add documentation about extent encryption
btrfs: add infrastructure for safe em freeing
btrfs: add fscrypt_info and encryption_type to ordered_extent
btrfs: plumb through setting the fscrypt_info for ordered extents
btrfs: populate the ordered_extent with the fscrypt context
btrfs: keep track of fscrypt info and orig_start for dio reads
btrfs: add an optional encryption context to the end of file extents
btrfs: pass through fscrypt_extent_info to the file extent helpers
btrfs: pass the fscrypt_info through the replace extent infrastructure
btrfs: implement the fscrypt extent encryption hooks
btrfs: setup fscrypt_extent_info for new extents
btrfs: populate ordered_extent with the orig offset
btrfs: set the bio fscrypt context when applicable
btrfs: add a bio argument to btrfs_csum_one_bio
btrfs: add orig_logical to btrfs_bio
btrfs: implement process_bio cb for fscrypt
Omar Sandoval (7):
fscrypt: expose fscrypt_nokey_name
btrfs: disable various operations on encrypted inodes
btrfs: start using fscrypt hooks
btrfs: add inode encryption contexts
btrfs: add new FEATURE_INCOMPAT_ENCRYPT flag
btrfs: adapt readdir for encrypted and nokey names
btrfs: implement fscrypt ioctls
Sweet Tea Dorminy (8):
btrfs: disable verity on encrypted inodes
btrfs: handle nokey names.
btrfs: add encryption to CONFIG_BTRFS_DEBUG
btrfs: add get_devices hook for fscrypt
btrfs: turn on inlinecrypt mount option for encrypt
btrfs: set file extent encryption excplicitly
btrfs: add fscrypt_info and encryption_type to extent_map
btrfs: explicitly track file extent length for replace and drop
Documentation/filesystems/fscrypt.rst | 41 +++ block/blk-crypto-fallback.c | 40 +++ block/blk-crypto-internal.h | 8 + block/blk-crypto-profile.c | 2 + block/blk-crypto.c | 6 +- fs/btrfs/Makefile | 1 + fs/btrfs/accessors.h | 50 +++ fs/btrfs/bio.c | 46 ++- fs/btrfs/bio.h | 6 + fs/btrfs/btrfs_inode.h | 3 +- fs/btrfs/compression.c | 6 + fs/btrfs/ctree.h | 4 + fs/btrfs/defrag.c | 10 +- fs/btrfs/delayed-inode.c | 29 +- fs/btrfs/delayed-inode.h | 6 +- fs/btrfs/dir-item.c | 108 +++++- fs/btrfs/dir-item.h | 11 +- fs/btrfs/extent_io.c | 81 ++++- fs/btrfs/extent_io.h | 3 + fs/btrfs/extent_map.c | 106 +++++- fs/btrfs/extent_map.h | 12 + fs/btrfs/file-item.c | 17 +- fs/btrfs/file-item.h | 7 +- fs/btrfs/file.c | 16 +- fs/btrfs/fs.h | 3 +- fs/btrfs/fscrypt.c | 326 ++++++++++++++++++ fs/btrfs/fscrypt.h | 95 +++++ fs/btrfs/inode.c | 476 ++++++++++++++++++++------ fs/btrfs/ioctl.c | 41 ++- fs/btrfs/ordered-data.c | 26 +- fs/btrfs/ordered-data.h | 21 +- fs/btrfs/reflink.c | 8 + fs/btrfs/root-tree.c | 8 +- fs/btrfs/root-tree.h | 2 +- fs/btrfs/super.c | 17 + fs/btrfs/sysfs.c | 6 + fs/btrfs/tree-checker.c | 66 +++- fs/btrfs/tree-log.c | 26 +- fs/btrfs/verity.c | 3 + fs/crypto/crypto.c | 10 +- fs/crypto/fname.c | 39 +-- fs/crypto/fscrypt_private.h | 44 +++ fs/crypto/inline_crypt.c | 87 ++++- fs/crypto/keyring.c | 18 +- fs/crypto/keysetup.c | 155 +++++++++ fs/crypto/policy.c | 59 ++++ include/linux/blk-crypto.h | 9 +- include/linux/fscrypt.h | 122 +++++++ include/uapi/linux/btrfs.h | 1 + include/uapi/linux/btrfs_tree.h | 35 +- 50 files changed, 2105 insertions(+), 217 deletions(-) create mode 100644 fs/btrfs/fscrypt.c create mode 100644 fs/btrfs/fscrypt.h
Signature · 1 line
2.41.0
PATCH v3 1/34 fscrypt: add per-extent encryption support
This adds the code necessary for per-extent encryption. We will store a nonce for every extent we create, and then use the inode's policy and the extents nonce to derive a per-extent key.
This is meant to be flexible, if we choose to expand the on-disk extent information in the future we have a version number we can use to change what exists on disk.
The file system indicates it wants to use per-extent encryption by setting s_cop->set_extent_context. This also requires the use of inline block encryption.
The support is relatively straightforward, the only "extra" bit is we're deriving a per-extent key to use for the encryption, the inode still controls the policy and access to the master key.
Since extent based encryption uses a lot of keys, we're requiring the use of inline block crypto if you use extent-based encryption. This enables us to take advantage of the built in pooling and reclamation of the crypto structures that underpin all of the encryption.
The different encryption related options for fscrypt are too numerous to support for extent based encryption. Support for a few of these options could possibly be added, but since they're niche options simply reject them for file systems using extent based encryption.
--- fs/crypto/crypto.c | 10 ++- fs/crypto/fscrypt_private.h | 44 ++++++++++ fs/crypto/inline_crypt.c | 84 +++++++++++++++++++ fs/crypto/keysetup.c | 155 ++++++++++++++++++++++++++++++++++++ fs/crypto/policy.c | 59 ++++++++++++++ include/linux/fscrypt.h | 71 +++++++++++++++++ 6 files changed, 422 insertions(+), 1 deletion(-)
fs/crypto/crypto.c +9 -1
@@ -40,6 +40,7 @@ static struct workqueue_struct *fscrypt_read_workqueue;static DEFINE_MUTEX (fscrypt_init_mutex);struct kmem_cache *fscrypt_inode_info_cachep; +struct kmem_cache *fscrypt_extent_info_cachep;void fscrypt_enqueue_decrypt_work (struct work_struct *work) {
@@ -414,12 +415,19 @@ static int __init fscrypt_init(void)if (!fscrypt_inode_info_cachep) goto fail_free_queue; + fscrypt_extent_info_cachep =KMEM_CACHE (fscrypt_extent_info, +SLAB_RECLAIM_ACCOUNT ); +if (!fscrypt_extent_info_cachep) + goto fail_free_inode_info; + err =fscrypt_init_keyring ();if (err) - goto fail_free_inode_info; + goto fail_free_extent_info;return 0 ; +fail_free_extent_info: +kmem_cache_destroy (fscrypt_extent_info_cachep); fail_free_inode_info:kmem_cache_destroy (fscrypt_inode_info_cachep); fail_free_queue:
fs/crypto/fscrypt_private.h +44 -0
68 lines not on this page · raw message
fs/crypto/inline_crypt.c +84 -0
96 lines not on this page · raw message
fs/crypto/keysetup.c +155 -0
158 lines not on this page · raw message
fs/crypto/policy.c +59 -0
77 lines not on this page · raw message
include/linux/fscrypt.h +71 -0
131 lines not on this page · raw message
Signature · 1 line
2.41.0
PATCH v3 2/34 fscrypt: conditionally don't wipe mk secret until the last active user is done
In reply to Josef BacikPreviously we were wiping the master key secret when we do FS_IOC_REMOVE_ENCRYPTION_KEY, and then using the fact that it was cleared as the mechanism from keeping new users from being setup. This works with inode based encryption, as the per-inode key is derived at setup time, so the secret disappearing doesn't affect any currently open files from being able to continue working.
However for extent based encryption we do our key derivation at page writeout and readpage time, which means we need the master key secret to be available while we still have our file open.
Since the master key lifetime is controlled by a flag, move the clearing of the secret to the mk_active_users cleanup stage if we have extent based encryption enabled on this super block. This counter represents the actively open files that still exist on the file system, and thus should still be able to operate normally. Once the last user is closed we can clear the secret. Until then no new users are allowed, and this allows currently open files to continue to operate until they're closed.
--- fs/crypto/keyring.c | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-)
fs/crypto/keyring.c +17 -1
@@ -105,6 +105,14 @@ void fscrypt_put_master_key_activeref(struct super_block *sb,WARN_ON_ONCE (mk->mk_present);WARN_ON_ONCE (!list_empty (&mk->mk_decrypted_inodes)); +/* We can't wipe the master key secret until the last activeref is +* dropped on the master key with per-extent encryption since the key +* derivation continues to happen as long as there are active refs. +* Wipe it here now that we're done using it. +*/ +if (sb->s_cop->has_per_extent_encryption) +wipe_master_key_secret (&mk->mk_secret); +for (i =0 ; i <=FSCRYPT_MODE_MAX ; i++) {fscrypt_destroy_prepared_key ( sb, &mk->mk_direct_keys[i]);
@@ -129,7 +137,15 @@ static void fscrypt_initiate_key_removal(struct super_block *sb, struct fscrypt_master_key *mk) {WRITE_ONCE (mk->mk_present, false); -wipe_master_key_secret (&mk->mk_secret); + +/* +* Per-extent encryption requires the master key to stick around until +* writeout has completed as we derive the per-extent keys at writeout +* time. Once the activeref drops to 0 we'll wipe the master secret +* key. +*/ +if (!sb->s_cop->has_per_extent_encryption) +wipe_master_key_secret (&mk->mk_secret);fscrypt_put_master_key_activeref (sb, mk); }
Signature · 1 line
2.41.0
PATCH v3 3/34 blk-crypto: add a process bio callback
In reply to Josef BacikBtrfs does checksumming, and the checksums need to match the bytes on disk. In order to facilitate this add a process bio callback for the blk-crypto layer. This allows the file system to specify a callback and then can process the encrypted bio as necessary.
For btrfs, writes will have the checksums calculated and saved into our relevant data structures for storage once the write completes. For reads we will validate the checksums match what is on disk and error out if there is a mismatch.
This is incompatible with native encryption obviously, so make sure we don't use native encryption if this callback is set.
--- block/blk-crypto-fallback.c | 40 +++++++++++++++++++++++++++++++++++++ block/blk-crypto-internal.h | 8 ++++++++ block/blk-crypto-profile.c | 2 ++ block/blk-crypto.c | 6 +++++- fs/crypto/inline_crypt.c | 3 ++- include/linux/blk-crypto.h | 9 +++++++-- include/linux/fscrypt.h | 14 +++++++++++++ 7 files changed, 78 insertions(+), 4 deletions(-)
block/blk-crypto-fallback.c +40 -0
@@ -346,6 +346,15 @@ static bool blk_crypto_fallback_encrypt_bio(struct bio **bio_ptr) } } +/* Process the encrypted bio before we submit it. */ +if (bc->bc_key->crypto_cfg.process_bio) { + blk_st = bc->bc_key->crypto_cfg.process_bio (src_bio, enc_bio); +if (blk_st !=BLK_STS_OK ) { + src_bio->bi_status = blk_st; + goto out_free_bounce_pages; + } + } + enc_bio->bi_private = src_bio; enc_bio->bi_end_io = blk_crypto_fallback_encrypt_endio; *bio_ptr = enc_bio;
@@ -391,6 +400,24 @@ static void blk_crypto_fallback_decrypt_bio(struct work_struct *work)unsigned int i;blk_status_t blk_st; +/* +* Process the bio first before trying to decrypt. +* +* NOTE: btrfs expects that this bio is the same that was submitted. If +* at any point this changes we will need to update process_bio to take +* f_ctx->crypt_iter in order to make sure we can iterate the pages for +* checksumming. We're currently saving this in our btrfs_bio, so this +* works, but if at any point in the future we start allocating a bounce +* bio or something we need to update this callback. +*/ +if (bc->bc_key->crypto_cfg.process_bio) { + blk_st = bc->bc_key->crypto_cfg.process_bio (bio, bio); +if (blk_st !=BLK_STS_OK ) { + bio->bi_status = blk_st; + goto out_no_keyslot; + } + } +/* * Get a blk-crypto-fallback keyslot that contains a crypto_skcipher for * this bio's algorithm and key.
@@ -440,6 +467,19 @@ static void blk_crypto_fallback_decrypt_bio(struct work_struct *work)bio_endio (bio); } +/** +* blk_crypto_cfg_supports_process_bio - check if this config supports +* process_bio +* @profile: the profile we're checking +* +* This is just a quick check to make sure @profile is the fallback profile, as +* no other offload implementations support process_bio. +*/ +bool blk_crypto_cfg_supports_process_bio (struct blk_crypto_profile *profile) +{ +return profile == blk_crypto_fallback_profile; +} +/** * blk_crypto_fallback_decrypt_endio - queue bio for fallback decryption *
block/blk-crypto-internal.h +8 -0
@@ -213,6 +213,8 @@ bool blk_crypto_fallback_bio_prep(struct bio **bio_ptr);int blk_crypto_fallback_evict_key (const struct blk_crypto_key *key); +bool blk_crypto_cfg_supports_process_bio (struct blk_crypto_profile *profile); +#else /* CONFIG_BLK_INLINE_ENCRYPTION_FALLBACK */ static inline int
@@ -235,6 +237,12 @@ blk_crypto_fallback_evict_key(const struct blk_crypto_key *key)return 0 ; } +static inline bool +blk_crypto_cfg_supports_process_bio (struct blk_crypto_profile *profile) +{ +return false; +} +#endif /* CONFIG_BLK_INLINE_ENCRYPTION_FALLBACK */ #endif /* __LINUX_BLK_CRYPTO_INTERNAL_H */
block/blk-crypto-profile.c +2 -0
@@ -352,6 +352,8 @@ bool __blk_crypto_cfg_supported(struct blk_crypto_profile *profile,return false;if (profile->max_dun_bytes_supported < cfg->dun_bytes)return false; +if (cfg->process_bio && !blk_crypto_cfg_supports_process_bio (profile)) +return false;return true; }
block/blk-crypto.c +5 -1
@@ -321,6 +321,8 @@ int __blk_crypto_rq_bio_prep(struct request *rq, struct bio *bio,* @dun_bytes: number of bytes that will be used to specify the DUN when this * key is used * @data_unit_size: the data unit size to use for en/decryption +* @process_bio: the call back if the upper layer needs to process the encrypted +* bio * * Return: 0 on success, -errno on failure. The caller is responsible for * zeroizing both blk_key and raw_key when done with them.
@@ -328,7 +330,8 @@ int __blk_crypto_rq_bio_prep(struct request *rq, struct bio *bio,int blk_crypto_init_key (struct blk_crypto_key *blk_key,const u8 *raw_key,enum blk_crypto_mode_num crypto_mode,unsigned int dun_bytes, -unsigned int data_unit_size) +unsigned int data_unit_size, +blk_crypto_process_bio_t process_bio) {const struct blk_crypto_mode *mode;
@@ -350,6 +353,7 @@ int blk_crypto_init_key(struct blk_crypto_key *blk_key, const u8 *raw_key, blk_key->crypto_cfg.crypto_mode = crypto_mode; blk_key->crypto_cfg.dun_bytes = dun_bytes; blk_key->crypto_cfg.data_unit_size = data_unit_size; + blk_key->crypto_cfg.process_bio = process_bio; blk_key->data_unit_size_bits =ilog2 (data_unit_size); blk_key->size = mode->keysize;memcpy (blk_key->raw, raw_key, mode->keysize);
fs/crypto/inline_crypt.c +2 -1
@@ -168,7 +168,8 @@ int fscrypt_prepare_inline_crypt_key(struct fscrypt_prepared_key *prep_key, err =blk_crypto_init_key (blk_key, raw_key, crypto_mode,fscrypt_get_dun_bytes (ci), -1U << ci->ci_data_unit_bits); +1U << ci->ci_data_unit_bits, + sb->s_cop->process_bio);if (err) {fscrypt_err (inode,"error %d initializing blk-crypto key" , err); goto fail;
include/linux/blk-crypto.h +7 -2
@@ -6,7 +6,7 @@#ifndef __LINUX_BLK_CRYPTO_H#define __LINUX_BLK_CRYPTO_H -#include <linux/types.h> +#include <linux/blk_types.h> enum blk_crypto_mode_num { BLK_ENCRYPTION_MODE_INVALID,
@@ -17,6 +17,9 @@ enum blk_crypto_mode_num { BLK_ENCRYPTION_MODE_MAX, }; +typedef blk_status_t (blk_crypto_process_bio_t )(struct bio *orig_bio, +struct bio *enc_bio); +#define BLK_CRYPTO_MAX_KEY_SIZE 64/** * struct blk_crypto_config - an inline encryption key's crypto configuration
@@ -31,6 +34,7 @@ struct blk_crypto_config {enum blk_crypto_mode_num crypto_mode;unsigned int data_unit_size;unsigned int dun_bytes; +blk_crypto_process_bio_t *process_bio; };/**
@@ -90,7 +94,8 @@ bool bio_crypt_dun_is_contiguous(const struct bio_crypt_ctx *bc,int blk_crypto_init_key (struct blk_crypto_key *blk_key,const u8 *raw_key,enum blk_crypto_mode_num crypto_mode,unsigned int dun_bytes, -unsigned int data_unit_size); +unsigned int data_unit_size, +blk_crypto_process_bio_t process_bio);int blk_crypto_start_using_key (struct block_device *bdev,const struct blk_crypto_key *key);
include/linux/fscrypt.h +14 -0
@@ -16,6 +16,7 @@#include <linux/fs.h> #include <linux/mm.h> #include <linux/slab.h> +#include <linux/blk-crypto.h> #include <uapi/linux/fscrypt.h> /*
@@ -199,6 +200,19 @@ struct fscrypt_operations {*/ struct block_device **(*get_devices)(struct super_block *sb,unsigned int *num_devs); + +/* +* A callback if the file system requires the ability to process the +* encrypted bio. +* +* @orig_bio: the original bio submitted. +* @enc_bio: the encrypted bio. +* +* For writes the enc_bio will be different from the orig_bio, for reads +* they will be the same. For reads we get the bio before it is +* decrypted, for writes we get the bio before it is submitted. +*/ +blk_crypto_process_bio_t *process_bio; }; static inline struct fscrypt_inode_info *
Signature · 1 line
2.41.0
PATCH v3 4/34 fscrypt: expose fscrypt_nokey_name
In reply to Josef BacikFrom: Omar Sandoval <[email protected]>
btrfs stores its data structures, including filenames in directories, in its own buffer implementation, struct extent_buffer, composed of several non-contiguous pages. We could copy filenames into a temporary buffer and use fscrypt_match_name() against that buffer, such extensive memcpying would be expensive. Instead, exposing fscrypt_nokey_name as in this change allows btrfs to recapitulate fscrypt_match_name() using methods on struct extent_buffer instead of dealing with a raw byte array.
--- fs/crypto/fname.c | 39 +-------------------------------------- include/linux/fscrypt.h | 37 +++++++++++++++++++++++++++++++++++++ 2 files changed, 38 insertions(+), 38 deletions(-)
fs/crypto/fname.c +1 -38
@@ -14,7 +14,6 @@#include <linux/namei.h> #include <linux/scatterlist.h> #include <crypto/hash.h> -#include <crypto/sha2.h> #include <crypto/skcipher.h> #include "fscrypt_private.h"
@@ -26,43 +25,7 @@#define FSCRYPT_FNAME_MIN_MSG_LEN 16/* -* struct fscrypt_nokey_name - identifier for directory entry when key is absent -* -* When userspace lists an encrypted directory without access to the key, the -* filesystem must present a unique "no-key name" for each filename that allows -* it to find the directory entry again if requested. Naively, that would just -* mean using the ciphertext filenames. However, since the ciphertext filenames -* can contain illegal characters ('\0' and '/'), they must be encoded in some -* way. We use base64url. But that can cause names to exceed NAME_MAX (255 -* bytes), so we also need to use a strong hash to abbreviate long names. -* -* The filesystem may also need another kind of hash, the "dirhash", to quickly -* find the directory entry. Since filesystems normally compute the dirhash -* over the on-disk filename (i.e. the ciphertext), it's not computable from -* no-key names that abbreviate the ciphertext using the strong hash to fit in -* NAME_MAX. It's also not computable if it's a keyed hash taken over the -* plaintext (but it may still be available in the on-disk directory entry); -* casefolded directories use this type of dirhash. At least in these cases, -* each no-key name must include the name's dirhash too. -* -* To meet all these requirements, we base64url-encode the following -* variable-length structure. It contains the dirhash, or 0's if the filesystem -* didn't provide one; up to 149 bytes of the ciphertext name; and for -* ciphertexts longer than 149 bytes, also the SHA-256 of the remaining bytes. -* -* This ensures that each no-key name contains everything needed to find the -* directory entry again, contains only legal characters, doesn't exceed -* NAME_MAX, is unambiguous unless there's a SHA-256 collision, and that we only -* take the performance hit of SHA-256 on very long filenames (which are rare). -*/ -struct fscrypt_nokey_name { -u32 dirhash[2 ]; -u8 bytes[149 ]; -u8 sha256[SHA256_DIGEST_SIZE ]; -};/* 189 bytes => 252 bytes base64url-encoded, which is <= NAME_MAX (255) */ - -/* -* Decoded size of max-size no-key name, i.e. a name that was abbreviated using +* Decoded size of max-size nokey name, i.e. a name that was abbreviated using * the strong hash and thus includes the 'sha256' field. This isn't simply * sizeof(struct fscrypt_nokey_name), as the padding at the end isn't included. */
include/linux/fscrypt.h +37 -0
@@ -17,6 +17,7 @@#include <linux/mm.h> #include <linux/slab.h> #include <linux/blk-crypto.h> +#include <crypto/sha2.h> #include <uapi/linux/fscrypt.h> /*
@@ -56,6 +57,42 @@ struct fscrypt_name {#define fname_name (p) ((p)->disk_name.name)#define fname_len (p) ((p)->disk_name.len) +/* +* struct fscrypt_nokey_name - identifier for directory entry when key is absent +* +* When userspace lists an encrypted directory without access to the key, the +* filesystem must present a unique "no-key name" for each filename that allows +* it to find the directory entry again if requested. Naively, that would just +* mean using the ciphertext filenames. However, since the ciphertext filenames +* can contain illegal characters ('\0' and '/'), they must be encoded in some +* way. We use base64url. But that can cause names to exceed NAME_MAX (255 +* bytes), so we also need to use a strong hash to abbreviate long names. +* +* The filesystem may also need another kind of hash, the "dirhash", to quickly +* find the directory entry. Since filesystems normally compute the dirhash +* over the on-disk filename (i.e. the ciphertext), it's not computable from +* no-key names that abbreviate the ciphertext using the strong hash to fit in +* NAME_MAX. It's also not computable if it's a keyed hash taken over the +* plaintext (but it may still be available in the on-disk directory entry); +* casefolded directories use this type of dirhash. At least in these cases, +* each no-key name must include the name's dirhash too. +* +* To meet all these requirements, we base64url-encode the following +* variable-length structure. It contains the dirhash, or 0's if the filesystem +* didn't provide one; up to 149 bytes of the ciphertext name; and for +* ciphertexts longer than 149 bytes, also the SHA-256 of the remaining bytes. +* +* This ensures that each no-key name contains everything needed to find the +* directory entry again, contains only legal characters, doesn't exceed +* NAME_MAX, is unambiguous unless there's a SHA-256 collision, and that we only +* take the performance hit of SHA-256 on very long filenames (which are rare). +*/ +struct fscrypt_nokey_name { +u32 dirhash[2 ]; +u8 bytes[149 ]; +u8 sha256[SHA256_DIGEST_SIZE ]; +};/* 189 bytes => 252 bytes base64url-encoded, which is <= NAME_MAX (255) */ +/* Maximum value for the third parameter of fscrypt_operations.set_context(). */ #define FSCRYPT_SET_CONTEXT_MAX_SIZE 40
Signature · 1 line
2.41.0
PATCH v3 5/34 fscrypt: add documentation about extent encryption
In reply to Josef BacikAdd a couple of sections to the fscrypt documentation about per-extent encryption.
--- Documentation/filesystems/fscrypt.rst | 41 +++++++++++++++++++++++++++ 1 file changed, 41 insertions(+)
Documentation/filesystems/fscrypt.rst +41 -0
@@ -256,6 +256,21 @@ alternative master keys or to support rotating master keys. Instead, the master keys may be wrapped in userspace, e.g. as is done by the `fscrypt <https://github.com/google/fscrypt>`_ tool. +Per-extent encryption keys +-------------------------- + +For certain file systems, such as btrfs, it's desired to derive a +per-extent encryption key. This is to enable features such as snapshots +and reflink, where you could have different inodes pointing at the same +extent. When a new extent is created fscrypt randomly generates a +16-byte nonce and the file system stores it along side the extent. +Then, it uses a KDF (as described in `Key derivation function`_) to +derive the extent's key from the master key and nonce. + +Currently the inode's master key and encryption policy must match the +extent, so you cannot share extents between inodes that were encrypted +differently. + DIRECT_KEY policies -------------------
@@ -1394,6 +1409,27 @@ by the kernel and is used as KDF input or as a tweak to cause different files to be encrypted differently; see `Per-file encryption keys`_ and `DIRECT_KEY policies`_. +Extent encryption context +------------------------- + +The extent encryption context mirrors the important parts of the above +`Encryption context`_, with a few ommisions. The struct is defined as +follows:: + + struct fscrypt_extent_context { + u8 version; + u8 encryption_mode; + u8 master_key_identifier[FSCRYPT_KEY_IDENTIFIER_SIZE]; + u8 nonce[FSCRYPT_FILE_NONCE_SIZE]; + }; + +Currently all fields much match the containing inode's encryption +context, with the exception of the nonce. + +Additionally extent encryption is only supported with +FSCRYPT_EXTENT_CONTEXT_V2 using the standard policy, all other policies +are disallowed. + Data path changes -----------------
@@ -1417,6 +1453,11 @@ buffer. Some filesystems, such as UBIFS, already use temporary buffers regardless of encryption. Other filesystems, such as ext4 and F2FS, have to allocate bounce pages specially for encryption. +Inline encryption is not optional for extent encryption based file +systems, the amount of objects required to be kept around is too much. +Inline encryption handles the object lifetime details which results in a +cleaner implementation. + Filename hashing and encoding -----------------------------
Signature · 1 line
2.41.0
PATCH v3 6/34 btrfs: add infrastructure for safe em freeing
In reply to Josef BacikWhen we add fscrypt support we're going to have fscrypt objects hanging off of extent_maps. This includes a block key, which if we're the last one freeing the key we may have to unregister it from the block layer. This requires taking a semaphore in the block layer, which means we can't free em's under the extent map tree lock.
Thankfully we only do this in two places, one where we're dropping a range of extent maps, and when we're freeing logged extents. Add a free_extent_map_safe() which will add the em to a list in the em_tree if we free'd the object. Currently this is unconditional but will be changed to conditional on the fscrypt object we will add in a later patch.
To process these delayed objects add a free_pending_extent_maps() that is called after the lock has been dropped on the em_tree. This will process the extent maps on the freed list and do the appropriate freeing work in a safe manner.
--- fs/btrfs/extent_map.c | 80 ++++++++++++++++++++++++++++++++++++++++--- fs/btrfs/extent_map.h | 10 ++++++ fs/btrfs/tree-log.c | 6 ++-- 3 files changed, 89 insertions(+), 7 deletions(-)
fs/btrfs/extent_map.c +75 -5
@@ -35,7 +35,9 @@ void __cold extent_map_exit(void)void extent_map_tree_init (struct extent_map_tree *tree) { tree->map =RB_ROOT_CACHED ; + tree->flags =0 ;INIT_LIST_HEAD (&tree->modified_extents); +INIT_LIST_HEAD (&tree->freed_extents);rwlock_init (&tree->lock); }
@@ -53,9 +55,17 @@ struct extent_map *alloc_extent_map(void) em->compress_type =BTRFS_COMPRESS_NONE ;refcount_set (&em->refs,1 );INIT_LIST_HEAD (&em->list); +INIT_LIST_HEAD (&em->free_list);return em; } +static void __free_extent_map (struct extent_map *em) +{ +if (test_bit (EXTENT_FLAG_FS_MAPPING , &em->flags)) +kfree (em->map_lookup); +kmem_cache_free (extent_map_cache, em); +} +/* * Drop the reference out on @em by one and free the structure if the reference * count hits zero.
@@ -67,12 +77,69 @@ void free_extent_map(struct extent_map *em)if (refcount_dec_and_test (&em->refs)) {WARN_ON (extent_map_in_tree (em));WARN_ON (!list_empty (&em->list)); -if (test_bit (EXTENT_FLAG_FS_MAPPING , &em->flags)) -kfree (em->map_lookup); -kmem_cache_free (extent_map_cache, em); +__free_extent_map (em); } } +/* +* Drop a ref for the extent map in the given tree. +* +* @tree: tree that the em is a part of. +* @em: the em to drop the reference to. +* +* Drop the reference count on @em by one, if the reference count hits 0 and +* there is an object on the em that can't be safely freed in the current +* context (if we are holding the extent_map_tree->lock for example), then add +* it to the freed_extents list on the extent_map_tree for later processing. +* +* This must be followed by a free_pending_extent_maps() to clear the pending +* frees. +*/ +void free_extent_map_safe (struct extent_map_tree *tree, +struct extent_map *em) +{ +lockdep_assert_held_write (&tree->lock); + +if (!em) +return ; + +if (refcount_dec_and_test (&em->refs)) { +WARN_ON (extent_map_in_tree (em)); +WARN_ON (!list_empty (&em->list)); +list_add_tail (&em->free_list, &tree->freed_extents); +set_bit (EXTENT_MAP_TREE_PENDING_FREES , &tree->flags); + } +} + +/* +* Free the em objects that exist on the em tree +* +* @tree: the tree to free the objects from. +* +* If there are any objects on the em->freed_extents list go ahead and free them +* here in a safe way. This is to be coupled with any uses of +* free_extent_map_safe(). +*/ +void free_pending_extent_maps (struct extent_map_tree *tree) +{ +struct extent_map *em; + +/* Avoid taking the write lock if we don't have any pending frees. */ +if (!test_and_clear_bit (EXTENT_MAP_TREE_PENDING_FREES , &tree->flags)) +return ; + +write_lock (&tree->lock); +while ((em =list_first_entry_or_null (&tree->freed_extents, + struct extent_map, free_list))) { +list_del_init (&em->free_list); +write_unlock (&tree->lock); +__free_extent_map (em); +cond_resched (); +write_lock (&tree->lock); + } +write_unlock (&tree->lock); +} +/* Do the math around the end of an extent, handling wrapping. */ static u64 range_end (u64 start,u64 len) {
@@ -684,10 +751,12 @@ static void drop_all_extent_maps_fast(struct extent_map_tree *tree)clear_bit (EXTENT_FLAG_PINNED , &em->flags);clear_bit (EXTENT_FLAG_LOGGING , &em->flags);remove_extent_mapping (tree, em); -free_extent_map (em); +free_extent_map_safe (tree, em);cond_resched_rwlock_write (&tree->lock); }write_unlock (&tree->lock); + +free_pending_extent_maps (tree); }/*
@@ -908,13 +977,14 @@ void btrfs_drop_extent_map_range(struct btrfs_inode *inode, u64 start, u64 end,free_extent_map (em); next:/* Once for us (for our lookup reference). */ -free_extent_map (em); +free_extent_map_safe (em_tree, em); em = next_em; }write_unlock (&em_tree->lock); +free_pending_extent_maps (em_tree);free_extent_map (split);free_extent_map (split2); }
fs/btrfs/extent_map.h +10 -0
@@ -55,11 +55,18 @@ struct extent_map {refcount_t refs;unsigned int compress_type;struct list_head list; +struct list_head free_list; +}; + +enum extent_map_flags { +EXTENT_MAP_TREE_PENDING_FREES , };struct extent_map_tree {struct rb_root_cached map; +unsigned long flags;struct list_head modified_extents; +struct list_head freed_extents;rwlock_t lock; };
@@ -95,6 +102,9 @@ int split_extent_map(struct btrfs_inode *inode, u64 start, u64 len, u64 pre,struct extent_map *alloc_extent_map (void );void free_extent_map (struct extent_map *em); +void free_extent_map_safe (struct extent_map_tree *tree, +struct extent_map *em); +void free_pending_extent_maps (struct extent_map_tree *tree);int __init extent_map_init (void );void __cold extent_map_exit (void );int unpin_extent_cache (struct extent_map_tree *tree,u64 start,u64 len,u64 gen);
fs/btrfs/tree-log.c +4 -2
@@ -4884,7 +4884,7 @@ static int btrfs_log_changed_extents(struct btrfs_trans_handle *trans,*/ if (ret) {clear_em_logging (tree, em); -free_extent_map (em); +free_extent_map_safe (tree, em);continue ; }
@@ -4893,11 +4893,13 @@ static int btrfs_log_changed_extents(struct btrfs_trans_handle *trans, ret =log_one_extent (trans, inode, em, path, ctx);write_lock (&tree->lock);clear_em_logging (tree, em); -free_extent_map (em); +free_extent_map_safe (tree, em); }WARN_ON (!list_empty (&extents));write_unlock (&tree->lock); +free_pending_extent_maps (tree); +if (!ret) ret =btrfs_log_prealloc_extents (trans, inode, path);if (ret)
Signature · 1 line
2.41.0
PATCH v3 7/34 btrfs: disable various operations on encrypted inodes
In reply to Josef BacikFrom: Omar Sandoval <[email protected]>
Initially, only normal data extents will be encrypted. This change forbids various other bits:
- allows reflinking only if both inodes have the same encryption status
- disable inline data on encrypted inodes
--- fs/btrfs/inode.c | 3 ++- fs/btrfs/reflink.c | 7 +++++++ 2 files changed, 9 insertions(+), 1 deletion(-)
fs/btrfs/inode.c +2 -1
@@ -630,7 +630,8 @@ static noinline int cow_file_range_inline(struct btrfs_inode *inode, u64 size,* compressed) data fits in a leaf and the configured maximum inline * size. */ -if (size <i_size_read (&inode->vfs_inode) || +if (IS_ENCRYPTED (&inode->vfs_inode) || + size <i_size_read (&inode->vfs_inode) || size > fs_info->sectorsize || data_len >BTRFS_MAX_INLINE_DATA_SIZE (fs_info) || data_len > fs_info->max_inline)
fs/btrfs/reflink.c +7 -0
@@ -1,6 +1,7 @@// SPDX-License-Identifier: GPL-2.0 #include <linux/blkdev.h> +#include <linux/fscrypt.h> #include <linux/iversion.h> #include "ctree.h" #include "fs.h"
@@ -809,6 +810,12 @@ static int btrfs_remap_file_range_prep(struct file *file_in, loff_t pos_in,ASSERT (inode_in->i_sb == inode_out->i_sb); } +/* +* Can only reflink encrypted files if both files are encrypted. +*/ +if (IS_ENCRYPTED (inode_in) !=IS_ENCRYPTED (inode_out)) +return -EINVAL ; +/* Don't make the dst file partly checksummed */ if ((BTRFS_I (inode_in)->flags &BTRFS_INODE_NODATASUM ) != (BTRFS_I (inode_out)->flags &BTRFS_INODE_NODATASUM )) {
Signature · 1 line
2.41.0
PATCH v3 8/34 btrfs: disable verity on encrypted inodes
In reply to Josef BacikFrom: Sweet Tea Dorminy <[email protected]>
Right now there isn't a way to encrypt things that aren't either filenames in directories or data on blocks on disk with extent encryption, so for now, disable verity usage with encryption on btrfs.
--- fs/btrfs/verity.c | 3 +++ 1 file changed, 3 insertions(+)
fs/btrfs/verity.c +3 -0
@@ -588,6 +588,9 @@ static int btrfs_begin_enable_verity(struct file *filp)ASSERT (inode_is_locked (file_inode (filp))); +if (IS_ENCRYPTED (&inode->vfs_inode)) +return -EINVAL ; +if (test_bit (BTRFS_INODE_VERITY_IN_PROGRESS , &inode->runtime_flags))return -EBUSY ;
Signature · 1 line
2.41.0
PATCH v3 9/34 btrfs: start using fscrypt hooks
In reply to Josef BacikFrom: Omar Sandoval <[email protected]>
In order to appropriately encrypt, create, open, rename, and various symlink operations must call fscrypt hooks. These determine whether the inode should be encrypted and do other preparatory actions. The superblock must have fscrypt operations registered, so implement the minimal set also, and introduce the new fscrypt.[ch] files to hold the fscrypt-specific functionality.
--- fs/btrfs/Makefile | 1 + fs/btrfs/btrfs_inode.h | 1 + fs/btrfs/file.c | 3 ++ fs/btrfs/fscrypt.c | 7 +++ fs/btrfs/fscrypt.h | 10 ++++ fs/btrfs/inode.c | 110 ++++++++++++++++++++++++++++++++++------- fs/btrfs/super.c | 2 + 7 files changed, 116 insertions(+), 18 deletions(-) create mode 100644 fs/btrfs/fscrypt.c create mode 100644 fs/btrfs/fscrypt.h
fs/btrfs/Makefile +1 -0
@@ -39,6 +39,7 @@ btrfs-$(CONFIG_BTRFS_FS_POSIX_ACL) += acl.o btrfs-$(CONFIG_BTRFS_FS_REF_VERIFY) += ref-verify.o btrfs-$(CONFIG_BLK_DEV_ZONED) += zoned.o btrfs-$(CONFIG_FS_VERITY) += verity.o +btrfs-$(CONFIG_FS_ENCRYPTION) += fscrypt.o btrfs-$(CONFIG_BTRFS_FS_RUN_SANITY_TESTS) += tests/free-space-tests.o \ tests/extent-buffer-tests.o tests/btrfs-tests.o \
fs/btrfs/btrfs_inode.h +1 -0
@@ -455,6 +455,7 @@ struct btrfs_new_inode_args {struct posix_acl *default_acl;struct posix_acl *acl;struct fscrypt_name fname; +bool encrypt; }; int btrfs_new_inode_prepare(struct btrfs_new_inode_args *args,
fs/btrfs/file.c +3 -0
@@ -3709,6 +3709,9 @@ static int btrfs_file_open(struct inode *inode, struct file *filp) filp->f_mode |=FMODE_NOWAIT |FMODE_BUF_RASYNC |FMODE_BUF_WASYNC |FMODE_CAN_ODIRECT ; + ret =fscrypt_file_open (inode, filp); +if (ret) +return ret; ret =fsverity_file_open (inode, filp);if (ret)
fs/btrfs/fscrypt.c new file +7 -0
@@ -0,0 +1,7 @@ +// SPDX-License-Identifier: GPL-2.0 + +#include "ctree.h" +#include "fscrypt.h" + +const struct fscrypt_operations btrfs_fscrypt_ops = { +};
fs/btrfs/fscrypt.h new file +10 -0
@@ -0,0 +1,10 @@ +/* SPDX-License-Identifier: GPL-2.0 */ + +#ifndef BTRFS_FSCRYPT_H +#define BTRFS_FSCRYPT_H + +#include <linux/fscrypt.h> + +extern const struct fscrypt_operations btrfs_fscrypt_ops; + +#endif /* BTRFS_FSCRYPT_H */
fs/btrfs/inode.c +92 -18
210 lines not on this page · raw message
fs/btrfs/super.c +2 -0
@@ -49,6 +49,7 @@#include "tests/btrfs-tests.h" #include "block-group.h" #include "discard.h" +#include "fscrypt.h" #include "qgroup.h" #include "raid56.h" #include "fs.h"
@@ -1099,6 +1100,7 @@ static int btrfs_fill_super(struct super_block *sb, sb->s_vop = &btrfs_verityops;#endif sb->s_xattr = btrfs_xattr_handlers; +fscrypt_set_ops (sb, &btrfs_fscrypt_ops); sb->s_time_gran =1 ;#ifdef CONFIG_BTRFS_FS_POSIX_ACL sb->s_flags |=SB_POSIXACL ;
Signature · 1 line
2.41.0
PATCH v3 10/34 btrfs: add inode encryption contexts
In reply to Josef BacikFrom: Omar Sandoval <[email protected]>
In order to store encryption information for directories, symlinks, etc., fscrypt stores a context item with each encrypted non-regular inode. fscrypt provides an arbitrary blob for the filesystem to store, and it does not clearly fit into an existing structure, so this goes in a new item type.
--- fs/btrfs/fscrypt.c | 117 ++++++++++++++++++++++++++++++++ fs/btrfs/fscrypt.h | 2 + fs/btrfs/inode.c | 19 ++++++ fs/btrfs/ioctl.c | 8 ++- include/uapi/linux/btrfs_tree.h | 10 +++ 5 files changed, 154 insertions(+), 2 deletions(-)
fs/btrfs/fscrypt.c +117 -0
@@ -1,7 +1,124 @@// SPDX-License-Identifier: GPL-2.0 +#include <linux/iversion.h> #include "ctree.h" +#include "accessors.h" +#include "btrfs_inode.h" +#include "disk-io.h" +#include "fs.h" #include "fscrypt.h" +#include "ioctl.h" +#include "messages.h" +#include "transaction.h" +#include "xattr.h" + +static int btrfs_fscrypt_get_context (struct inode *inode,void *ctx,size_t len) +{ +struct btrfs_key key = { + .objectid =btrfs_ino (BTRFS_I (inode)), + .type =BTRFS_FSCRYPT_CTX_ITEM_KEY , + .offset =0 , + }; +struct btrfs_path *path; +struct extent_buffer *leaf; +unsigned long ptr; +int ret; + + + path =btrfs_alloc_path (); +if (!path) +return -ENOMEM ; + + ret =btrfs_search_slot (NULL ,BTRFS_I (inode)->root, &key, path,0 ,0 ); +if (ret) { + len = -ENOENT ; + goto out; + } + + leaf = path->nodes[0 ]; + ptr =btrfs_item_ptr_offset (leaf, path->slots[0 ]); +/* fscrypt provides max context length, but it could be less */ + len =min_t (size_t, len,btrfs_item_size (leaf, path->slots[0 ])); +read_extent_buffer (leaf, ctx, ptr, len); + +out: +btrfs_free_path (path); +return len; +} + +static int btrfs_fscrypt_set_context (struct inode *inode,const void *ctx, +size_t len,void *fs_data) +{ +struct btrfs_trans_handle *trans = fs_data; +struct btrfs_key key = { + .objectid =btrfs_ino (BTRFS_I (inode)), + .type =BTRFS_FSCRYPT_CTX_ITEM_KEY , + .offset =0 , + }; +struct btrfs_path *path =NULL ; +struct extent_buffer *leaf; +unsigned long ptr; +int ret; + +if (!trans) + trans =btrfs_start_transaction (BTRFS_I (inode)->root,2 ); +if (IS_ERR (trans)) +return PTR_ERR (trans); + + path =btrfs_alloc_path (); +if (!path) { + ret = -ENOMEM ; + goto out_err; + } + + ret =btrfs_search_slot (trans,BTRFS_I (inode)->root, &key, path,0 ,1 ); +if (ret <0 ) + goto out_err; + +if (ret >0 ) { +btrfs_release_path (path); + ret =btrfs_insert_empty_item (trans,BTRFS_I (inode)->root, path, &key, len); +if (ret) + goto out_err; + } + + leaf = path->nodes[0 ]; + ptr =btrfs_item_ptr_offset (leaf, path->slots[0 ]); + + len =min_t (size_t, len,btrfs_item_size (leaf, path->slots[0 ])); +write_extent_buffer (leaf, ctx, ptr, len); +btrfs_mark_buffer_dirty (trans, leaf); +btrfs_release_path (path); + +if (fs_data) +return ret; + +BTRFS_I (inode)->flags |=BTRFS_INODE_ENCRYPT ; +btrfs_sync_inode_flags_to_i_flags (inode); +inode_inc_iversion (inode); +inode_set_ctime_current (inode); + ret =btrfs_update_inode (trans,BTRFS_I (inode)); +if (ret) + goto out_abort; +btrfs_free_path (path); +btrfs_end_transaction (trans); +return 0 ; +out_abort: +btrfs_abort_transaction (trans, ret); +out_err: +if (!fs_data) +btrfs_end_transaction (trans); +btrfs_free_path (path); +return ret; +} + +static bool btrfs_fscrypt_empty_dir (struct inode *inode) +{ +return inode->i_size ==BTRFS_EMPTY_DIR_SIZE ; +}const struct fscrypt_operations btrfs_fscrypt_ops = { + .get_context = btrfs_fscrypt_get_context, + .set_context = btrfs_fscrypt_set_context, + .empty_dir = btrfs_fscrypt_empty_dir, };
fs/btrfs/fscrypt.h +2 -0
@@ -5,6 +5,8 @@#include <linux/fscrypt.h> +#include "fs.h" +extern const struct fscrypt_operations btrfs_fscrypt_ops;#endif /* BTRFS_FSCRYPT_H */
fs/btrfs/inode.c +19 -0
@@ -62,6 +62,7 @@#include "defrag.h" #include "dir-item.h" #include "file-item.h" +#include "fscrypt.h" #include "uuid-tree.h" #include "ioctl.h" #include "file.h"
@@ -6087,6 +6088,9 @@ int btrfs_new_inode_prepare(struct btrfs_new_inode_args *args,struct inode *inode = args->inode;int ret; +if (fscrypt_is_nokey_name (args->dentry)) +return -ENOKEY ; +if (!args->orphan) { ret =fscrypt_setup_filename (dir, &args->dentry->d_name,0 , &args->fname);
@@ -6122,6 +6126,9 @@ int btrfs_new_inode_prepare(struct btrfs_new_inode_args *args,if (dir->i_security) (*trans_num_items)++;#endif +/* 1 to add fscrypt item */ +if (args->encrypt) + (*trans_num_items)++;if (args->orphan) {/* 1 to add orphan item */ (*trans_num_items)++;
@@ -6299,6 +6306,11 @@ int btrfs_create_new_inode(struct btrfs_trans_handle *trans, inode->i_atime = inode->i_mtime;BTRFS_I (inode)->i_otime = inode->i_mtime; +if (args->encrypt) { +BTRFS_I (inode)->flags |=BTRFS_INODE_ENCRYPT ; +btrfs_sync_inode_flags_to_i_flags (inode); + } +/* * We're going to fill the inode item now, so at this point the inode * must be fully initialized.
@@ -6373,6 +6385,13 @@ int btrfs_create_new_inode(struct btrfs_trans_handle *trans, goto discard; } } +if (args->encrypt) { + ret =fscrypt_set_context (inode, trans); +if (ret) { +btrfs_abort_transaction (trans, ret); + goto discard; + } + }inode_tree_add (BTRFS_I (inode));
fs/btrfs/ioctl.c +6 -2
@@ -156,6 +156,8 @@ static unsigned int btrfs_inode_flags_to_fsflags(struct btrfs_inode *binode) iflags |=FS_DIRSYNC_FL ;if (flags &BTRFS_INODE_NODATACOW ) iflags |=FS_NOCOW_FL ; +if (flags &BTRFS_INODE_ENCRYPT ) + iflags |=FS_ENCRYPT_FL ;if (ro_flags &BTRFS_INODE_RO_VERITY ) iflags |=FS_VERITY_FL ;
@@ -185,12 +187,14 @@ void btrfs_sync_inode_flags_to_i_flags(struct inode *inode) new_fl |=S_NOATIME ;if (binode->flags &BTRFS_INODE_DIRSYNC ) new_fl |=S_DIRSYNC ; +if (binode->flags &BTRFS_INODE_ENCRYPT ) + new_fl |=S_ENCRYPTED ;if (binode->ro_flags &BTRFS_INODE_RO_VERITY ) new_fl |=S_VERITY ;set_mask_bits (&inode->i_flags,S_SYNC |S_APPEND |S_IMMUTABLE |S_NOATIME |S_DIRSYNC | -S_VERITY , new_fl); +S_VERITY |S_ENCRYPTED , new_fl); }/*
@@ -203,7 +207,7 @@ static int check_fsflags(unsigned int old_flags, unsigned int flags)FS_NOATIME_FL |FS_NODUMP_FL | \FS_SYNC_FL |FS_DIRSYNC_FL | \FS_NOCOMP_FL |FS_COMPR_FL | - FS_NOCOW_FL)) + FS_NOCOW_FL | FS_ENCRYPT_FL)) return -EOPNOTSUPP;/* COMPR and NOCOMP on new/old are valid */
include/uapi/linux/btrfs_tree.h +10 -0
@@ -164,6 +164,8 @@#define BTRFS_VERITY_DESC_ITEM_KEY 36#define BTRFS_VERITY_MERKLE_ITEM_KEY 37 +#define BTRFS_FSCRYPT_CTX_ITEM_KEY 41 +#define BTRFS_ORPHAN_ITEM_KEY 48/* reserve 2-15 close to the inode for later flexibility */
@@ -416,6 +418,7 @@ static inline __u8 btrfs_dir_flags_to_ftype(__u8 flags)#define BTRFS_INODE_NOATIME (1U << 9)#define BTRFS_INODE_DIRSYNC (1U << 10)#define BTRFS_INODE_COMPRESS (1U << 11) +#define BTRFS_INODE_ENCRYPT (1U << 12)#define BTRFS_INODE_ROOT_ITEM_INIT (1U << 31)
@@ -432,6 +435,7 @@ static inline __u8 btrfs_dir_flags_to_ftype(__u8 flags)BTRFS_INODE_NOATIME | \BTRFS_INODE_DIRSYNC | \BTRFS_INODE_COMPRESS | \ +BTRFS_INODE_ENCRYPT | \ BTRFS_INODE_ROOT_ITEM_INIT) #define BTRFS_INODE_RO_VERITY (1U << 0)
@@ -1061,6 +1065,12 @@ enum { BTRFS_NR_FILE_EXTENT_TYPES = 3, }; +enum { +BTRFS_ENCRYPTION_NONE , +BTRFS_ENCRYPTION_FSCRYPT , +BTRFS_NR_ENCRYPTION_TYPES , +}; +struct btrfs_file_extent_item {/* * transaction id that created this extent
Signature · 1 line
2.41.0
PATCH v3 11/34 btrfs: add new FEATURE_INCOMPAT_ENCRYPT flag
In reply to Josef BacikFrom: Omar Sandoval <[email protected]>
As encrypted files will be incompatible with older filesystem versions, new filesystems should be created with an incompat flag for fscrypt, which will gate access to the encryption ioctls.
--- fs/btrfs/fs.h | 3 ++- fs/btrfs/super.c | 5 +++++ fs/btrfs/sysfs.c | 6 ++++++ include/uapi/linux/btrfs.h | 1 + 4 files changed, 14 insertions(+), 1 deletion(-)
fs/btrfs/fs.h +2 -1
@@ -231,7 +231,8 @@ enum {#define BTRFS_FEATURE_INCOMPAT_SUPP \ (BTRFS_FEATURE_INCOMPAT_SUPP_STABLE | \ BTRFS_FEATURE_INCOMPAT_RAID_STRIPE_TREE | \ - BTRFS_FEATURE_INCOMPAT_EXTENT_TREE_V2) + BTRFS_FEATURE_INCOMPAT_EXTENT_TREE_V2 | \ + BTRFS_FEATURE_INCOMPAT_ENCRYPT)#else
fs/btrfs/super.c +5 -0
@@ -2379,6 +2379,11 @@ static int __init btrfs_print_mod_info(void)", fsverity=yes" #else ", fsverity=no" +#endif +#ifdef CONFIG_FS_ENCRYPTION +", fscrypt=yes" +#else + ", fscrypt=no"#endif ;pr_info ("Btrfs loaded%s\n" , options);
fs/btrfs/sysfs.c +6 -0
@@ -304,6 +304,9 @@ BTRFS_FEAT_ATTR_INCOMPAT(raid_stripe_tree, RAID_STRIPE_TREE);#ifdef CONFIG_FS_VERITY BTRFS_FEAT_ATTR_COMPAT_RO (verity,VERITY );#endif +#ifdef CONFIG_FS_ENCRYPTION +BTRFS_FEAT_ATTR_INCOMPAT (encryption,ENCRYPT ); +#endif /* CONFIG_FS_ENCRYPTION */ /* * Features which depend on feature bits and may differ between each fs.
@@ -336,6 +339,9 @@ static struct attribute *btrfs_supported_feature_attrs[] = {#ifdef CONFIG_FS_VERITY BTRFS_FEAT_ATTR_PTR(verity),#endif +#ifdef CONFIG_FS_ENCRYPTION +BTRFS_FEAT_ATTR_PTR (encryption), +#endif /* CONFIG_FS_ENCRYPTION */NULL };
include/uapi/linux/btrfs.h +1 -0
@@ -334,6 +334,7 @@ struct btrfs_ioctl_fs_info_args {#define BTRFS_FEATURE_INCOMPAT_ZONED (1ULL << 12)#define BTRFS_FEATURE_INCOMPAT_EXTENT_TREE_V2 (1ULL << 13)#define BTRFS_FEATURE_INCOMPAT_RAID_STRIPE_TREE (1ULL << 14) +#define BTRFS_FEATURE_INCOMPAT_ENCRYPT (1ULL << 15)#define BTRFS_FEATURE_INCOMPAT_SIMPLE_QUOTA (1ULL << 16)struct btrfs_ioctl_feature_flags {
Signature · 1 line
2.41.0
PATCH v3 12/34 btrfs: adapt readdir for encrypted and nokey names
In reply to Josef BacikFrom: Omar Sandoval <[email protected]>
Deleting an encrypted file must always be permitted, even if the user does not have the appropriate key. Therefore, for listing an encrypted directory, so-called 'nokey' names are provided, and these nokey names must be sufficient to look up and delete the appropriate encrypted files. See 'struct fscrypt_nokey_name' for more information on the format of these names.
The first part of supporting nokey names is allowing lookups by nokey name. Only a few entry points need to support these: deleting a directory, file, or subvolume -- each of these call fscrypt_setup_filename() with a '1' argument, indicating that the key is not required and therefore a nokey name may be provided. If a nokey name is provided, the fscrypt_name returned by fscrypt_setup_filename() will not have its disk_name field populated, but will have various other fields set.
This change alters the relevant codepaths to pass a complete fscrypt_name anywhere that it might contain a nokey name. When it does contain a nokey name, the first time the name is successfully matched to a stored name populates the disk name field of the fscrypt_name, allowing the caller to use the normal disk name codepaths afterward. Otherwise, the matching functionality is in close analogue to the function fscrypt_match_name().
Functions where most callers are providing a fscrypt_str are duplicated and adapted for a fscrypt_name, and functions where most callers are providing a fscrypt_name are changed to so require at all callsites.
--- fs/btrfs/btrfs_inode.h | 2 +- fs/btrfs/delayed-inode.c | 29 ++++++- fs/btrfs/delayed-inode.h | 6 +- fs/btrfs/dir-item.c | 77 ++++++++++++++++--- fs/btrfs/dir-item.h | 11 ++- fs/btrfs/extent_io.c | 18 +++++ fs/btrfs/extent_io.h | 3 + fs/btrfs/fscrypt.c | 34 +++++++++ fs/btrfs/fscrypt.h | 19 +++++ fs/btrfs/inode.c | 158 ++++++++++++++++++++++++++------------- fs/btrfs/root-tree.c | 8 +- fs/btrfs/root-tree.h | 2 +- fs/btrfs/tree-log.c | 3 +- 13 files changed, 297 insertions(+), 73 deletions(-)
fs/btrfs/btrfs_inode.h +1 -1
@@ -428,7 +428,7 @@ struct inode *btrfs_lookup_dentry(struct inode *dir, struct dentry *dentry);int btrfs_set_inode_index (struct btrfs_inode *dir,u64 *index);int btrfs_unlink_inode (struct btrfs_trans_handle *trans,struct btrfs_inode *dir,struct btrfs_inode *inode, -const struct fscrypt_str *name); +struct fscrypt_name *name);int btrfs_add_link (struct btrfs_trans_handle *trans,struct btrfs_inode *parent_inode,struct btrfs_inode *inode,const struct fscrypt_str *name,int add_backref,u64 index);
fs/btrfs/delayed-inode.c +26 -3
@@ -1762,7 +1762,9 @@ int btrfs_should_delete_dir_index(struct list_head *del_list,/* * Read dir info stored in the delayed tree. */ -int btrfs_readdir_delayed_dir_index (struct dir_context *ctx, +int btrfs_readdir_delayed_dir_index (struct inode *inode, +struct fscrypt_str *fstr, +struct dir_context *ctx,struct list_head *ins_list) {struct btrfs_dir_item *di;
@@ -1772,6 +1774,7 @@ int btrfs_readdir_delayed_dir_index(struct dir_context *ctx,int name_len;int over =0 ;unsigned char d_type; +size_t fstr_len = fstr->len;/* * Changing the data of the delayed item is impossible. So
@@ -1796,8 +1799,28 @@ int btrfs_readdir_delayed_dir_index(struct dir_context *ctx, d_type =fs_ftype_to_dtype (btrfs_dir_flags_to_ftype (di->type));btrfs_disk_key_to_cpu (&location, &di->location); - over = !dir_emit (ctx, name, name_len, - location.objectid, d_type); +if (di->type &BTRFS_FT_ENCRYPTED ) { +int ret; +struct fscrypt_str iname =FSTR_INIT (name, name_len); + + fstr->len = fstr_len; +/* +* The hash is only used when the encryption key is not +* available. But if we have delayed insertions, then we +* must have the encryption key available or we wouldn't +* have been able to create entries in the directory. +* So, we don't calculate the hash. +*/ + ret =fscrypt_fname_disk_to_usr (inode,0 ,0 , &iname, + fstr); +if (ret) +return ret; + over = !dir_emit (ctx, fstr->name, fstr->len, + location.objectid, d_type); + }else { + over = !dir_emit (ctx, name, name_len, location.objectid, + d_type); + }if (refcount_dec_and_test (&curr->refs))kfree (curr);
fs/btrfs/delayed-inode.h +5 -1
@@ -16,6 +16,8 @@#include <linux/refcount.h> #include "ctree.h" +struct fscrypt_str ; +enum btrfs_delayed_item_type {BTRFS_DELAYED_INSERTION_ITEM ,BTRFS_DELAYED_DELETION_ITEM
@@ -155,7 +157,9 @@ void btrfs_readdir_put_delayed_items(struct inode *inode, struct list_head *del_list);int btrfs_should_delete_dir_index (struct list_head *del_list,u64 index); -int btrfs_readdir_delayed_dir_index (struct dir_context *ctx, +int btrfs_readdir_delayed_dir_index (struct inode *inode, +struct fscrypt_str *fstr, +struct dir_context *ctx,struct list_head *ins_list);/* Used during directory logging. */
fs/btrfs/dir-item.c +66 -11
126 lines not on this page · raw message
fs/btrfs/dir-item.h +10 -1
@@ -6,6 +6,7 @@#include <linux/crc32c.h> struct fscrypt_str ; +struct fscrypt_name ;int btrfs_check_dir_item_collision (struct btrfs_root *root,u64 dir,const struct fscrypt_str *name);
@@ -16,6 +17,11 @@ struct btrfs_dir_item *btrfs_lookup_dir_item(struct btrfs_trans_handle *trans,struct btrfs_root *root, struct btrfs_path *path, u64 dir, const struct fscrypt_str *name, int mod); +struct btrfs_dir_item *btrfs_lookup_dir_item_fname ( +struct btrfs_trans_handle *trans, +struct btrfs_root *root, +struct btrfs_path *path,u64 dir, +struct fscrypt_name *name,int mod); struct btrfs_dir_item *btrfs_lookup_dir_index_item( struct btrfs_trans_handle *trans, struct btrfs_root *root,
@@ -23,7 +29,7 @@ struct btrfs_dir_item *btrfs_lookup_dir_index_item( u64 index, const struct fscrypt_str *name, int mod);struct btrfs_dir_item *btrfs_search_dir_index_item (struct btrfs_root *root,struct btrfs_path *path,u64 dirid, -const struct fscrypt_str *name); +struct fscrypt_name *name); int btrfs_delete_one_dir_name(struct btrfs_trans_handle *trans, struct btrfs_root *root, struct btrfs_path *path,
@@ -42,6 +48,9 @@ struct btrfs_dir_item *btrfs_match_dir_item_name(struct btrfs_fs_info *fs_info,struct btrfs_path *path, const char *name, int name_len); +struct btrfs_dir_item *btrfs_match_dir_item_fname (struct btrfs_fs_info *fs_info, +struct btrfs_path *path, +struct fscrypt_name *name);static inline u64 btrfs_name_hash (const char *name,int len) {
fs/btrfs/extent_io.c +18 -0
@@ -4135,6 +4135,24 @@ static void assert_eb_page_uptodate(const struct extent_buffer *eb, } } +/* Take a sha256 of a portion of an extent buffer. */ +void extent_buffer_sha256 (const struct extent_buffer *eb, +unsigned long start, +unsigned long len,u8 *out) +{ +void *eb_addr =btrfs_get_eb_addr (eb); + +if (check_eb_range (eb, start, len)) +return ; + +/* +* TODO: This should maybe be using the crypto API, not the fallback, +* but fscrypt uses the fallback and this is only used in emulation of +* fscrypt's buffer sha256 method. +*/ +sha256 (eb_addr + start, len, out); +} +void write_extent_buffer (const struct extent_buffer *eb,const void *srcv,unsigned long start,unsigned long len) {
fs/btrfs/extent_io.h +3 -0
@@ -254,6 +254,9 @@ static inline int extent_buffer_uptodate(const struct extent_buffer *eb)int memcmp_extent_buffer (const struct extent_buffer *eb,const void *ptrv,unsigned long start,unsigned long len); +void extent_buffer_sha256 (const struct extent_buffer *eb, +unsigned long start, +unsigned long len,u8 *out);void read_extent_buffer (const struct extent_buffer *eb,void *dst,unsigned long start,unsigned long len);
fs/btrfs/fscrypt.c +34 -0
@@ -5,13 +5,47 @@#include "accessors.h" #include "btrfs_inode.h" #include "disk-io.h" +#include "ioctl.h" #include "fs.h" #include "fscrypt.h" #include "ioctl.h" #include "messages.h" +#include "root-tree.h" #include "transaction.h" #include "xattr.h" +/* +* This function is extremely similar to fscrypt_match_name() but uses an +* extent_buffer. +*/ +bool btrfs_fscrypt_match_name (struct fscrypt_name *fname, +struct extent_buffer *leaf,unsigned long de_name, +u32 de_name_len) +{ +const struct fscrypt_nokey_name *nokey_name = + (const struct fscrypt_nokey_name *)fname->crypto_buf.name; +u8 digest[SHA256_DIGEST_SIZE ]; + +if (likely (fname->disk_name.name)) { +if (de_name_len != fname->disk_name.len) +return false; +return !memcmp_extent_buffer (leaf, fname->disk_name.name, + de_name, de_name_len); + } + +if (de_name_len <=sizeof (nokey_name->bytes)) +return false; + +if (memcmp_extent_buffer (leaf, nokey_name->bytes, de_name, +sizeof (nokey_name->bytes))) +return false; + +extent_buffer_sha256 (leaf, de_name +sizeof (nokey_name->bytes), + de_name_len -sizeof (nokey_name->bytes), digest); + +return !memcmp (digest, nokey_name->sha256,sizeof (digest)); +} +static int btrfs_fscrypt_get_context (struct inode *inode,void *ctx,size_t len) {struct btrfs_key key = {
fs/btrfs/fscrypt.h +19 -0
@@ -4,9 +4,28 @@#define BTRFS_FSCRYPT_H #include <linux/fscrypt.h> +#include "extent_io.h" #include "fs.h" +#ifdef CONFIG_FS_ENCRYPTION +bool btrfs_fscrypt_match_name (struct fscrypt_name *fname, +struct extent_buffer *leaf, +unsigned long de_name,u32 de_name_len); + +#else +static inline bool btrfs_fscrypt_match_name (struct fscrypt_name *fname, +struct extent_buffer *leaf, +unsigned long de_name, +u32 de_name_len) +{ +if (de_name_len !=fname_len (fname)) +return false; +return !memcmp_extent_buffer (leaf, fname->disk_name.name, de_name, + de_name_len); +} +#endif /* CONFIG_FS_ENCRYPTION */ +extern const struct fscrypt_operations btrfs_fscrypt_ops;#endif /* BTRFS_FSCRYPT_H */
fs/btrfs/inode.c +107 -51
379 lines not on this page · raw message
fs/btrfs/root-tree.c +5 -3
@@ -10,6 +10,7 @@#include "messages.h" #include "transaction.h" #include "disk-io.h" +#include "fscrypt.h" #include "print-tree.h" #include "qgroup.h" #include "space-info.h"
@@ -334,7 +335,7 @@ int btrfs_del_root(struct btrfs_trans_handle *trans,int btrfs_del_root_ref (struct btrfs_trans_handle *trans,u64 root_id,u64 ref_id,u64 dirid,u64 *sequence, -const struct fscrypt_str *name) +struct fscrypt_name *name) {struct btrfs_root *tree_root = trans->fs_info->tree_root;struct btrfs_path *path;
@@ -356,13 +357,14 @@ int btrfs_del_root_ref(struct btrfs_trans_handle *trans, u64 root_id,if (ret <0 ) { goto out; }else if (ret ==0 ) { +u32 name_len; leaf = path->nodes[0 ]; ref =btrfs_item_ptr (leaf, path->slots[0 ], struct btrfs_root_ref); ptr = (unsigned long )(ref +1 ); + name_len =btrfs_root_ref_name_len (leaf, ref);if ((btrfs_root_ref_dirid (leaf, ref) != dirid) || - (btrfs_root_ref_name_len (leaf, ref) != name->len) || -memcmp_extent_buffer (leaf, name->name, ptr, name->len)) { + !btrfs_fscrypt_match_name (name, leaf, ptr, name_len)) { ret = -ENOENT ; goto out; }
fs/btrfs/root-tree.h +1 -1
@@ -15,7 +15,7 @@ int btrfs_add_root_ref(struct btrfs_trans_handle *trans, u64 root_id, const struct fscrypt_str *name);int btrfs_del_root_ref (struct btrfs_trans_handle *trans,u64 root_id,u64 ref_id,u64 dirid,u64 *sequence, -const struct fscrypt_str *name); +struct fscrypt_name *name);int btrfs_del_root (struct btrfs_trans_handle *trans,const struct btrfs_key *key); int btrfs_insert_root(struct btrfs_trans_handle *trans, struct btrfs_root *root, const struct btrfs_key *key,
fs/btrfs/tree-log.c +2 -1
@@ -901,9 +901,10 @@ static int unlink_inode_for_log_replay(struct btrfs_trans_handle *trans,struct btrfs_inode *inode, const struct fscrypt_str *name) { + struct fscrypt_name fname = { .disk_name = *name, };int ret; - ret =btrfs_unlink_inode (trans, dir, inode, name); + ret =btrfs_unlink_inode (trans, dir, inode, &fname);if (ret)return ret;/*
Signature · 1 line
2.41.0
PATCH v3 13/34 btrfs: handle nokey names.
In reply to Josef BacikFrom: Sweet Tea Dorminy <[email protected]>
For encrypted or unencrypted names, we calculate the offset for the dir item by hashing the name for the dir item. However, this doesn't work for a long nokey name, where we do not have the complete ciphertext. Instead, fscrypt stores the filesystem-provided hash in the nokey name, and we can extract it from the fscrypt_name structure in such a case.
Additionally, for nokey names, if we find the nokey name on disk we can update the fscrypt_name with the disk name, so add that to searching for diritems.
--- fs/btrfs/dir-item.c | 37 +++++++++++++++++++++++++++++++++++-- fs/btrfs/fscrypt.c | 27 +++++++++++++++++++++++++++ fs/btrfs/fscrypt.h | 11 +++++++++++ 3 files changed, 73 insertions(+), 2 deletions(-)
fs/btrfs/dir-item.c +35 -2
@@ -231,6 +231,28 @@ struct btrfs_dir_item *btrfs_lookup_dir_item(struct btrfs_trans_handle *trans,return di; } +/* +* If appropriate, populate the disk name for a fscrypt_name looked up without +* a key. +* +* @path: The path to the extent buffer in which the name was found. +* @di: The dir item corresponding. +* @fname: The fscrypt_name to perhaps populate. +* +* Returns: 0 if the name is already populated or the dir item doesn't exist +* or the name was successfully populated, else an error code. +*/ +static int ensure_disk_name_from_dir_item (struct btrfs_path *path, +struct btrfs_dir_item *di, +struct fscrypt_name *name) +{ +if (name->disk_name.name || !di) +return 0 ; + +return btrfs_fscrypt_get_disk_name (path->nodes[0 ], di, + &name->disk_name); +} +/* * Lookup for a directory item by fscrypt_name. *
@@ -257,8 +279,12 @@ struct btrfs_dir_item *btrfs_lookup_dir_item_fname(struct btrfs_trans_handle *tr key.objectid = dir; key.type =BTRFS_DIR_ITEM_KEY ; - key.offset =btrfs_name_hash (name->disk_name.name, name->disk_name.len); -/* XXX get the right hash for no-key names */ + +if (!name->disk_name.name) + key.offset = name->hash | ((u64 )name->minor_hash <<32 ); +else + key.offset =btrfs_name_hash (name->disk_name.name, + name->disk_name.len); ret =btrfs_search_slot (trans, root, &key, path, mod, -mod);if (ret ==0 )
@@ -266,6 +292,8 @@ struct btrfs_dir_item *btrfs_lookup_dir_item_fname(struct btrfs_trans_handle *trif (ret == -ENOENT || (di &&IS_ERR (di) &&PTR_ERR (di) == -ENOENT ))return NULL ; +if (ret ==0 ) + ret =ensure_disk_name_from_dir_item (path, di, name);if (ret <0 ) di =ERR_PTR (ret);
@@ -382,7 +410,12 @@ btrfs_search_dir_index_item(struct btrfs_root *root, struct btrfs_path *path,btrfs_for_each_slot (root, &key, &key, path, ret) {if (key.objectid != dirid || key.type !=BTRFS_DIR_INDEX_KEY )break ; + di =btrfs_match_dir_item_fname (root->fs_info, path, name); +if (di) + ret =ensure_disk_name_from_dir_item (path, di, name); +if (ret) +break ;if (di)return di; }
fs/btrfs/fscrypt.c +27 -0
@@ -14,6 +14,33 @@#include "transaction.h" #include "xattr.h" +/* +* From a given location in a leaf, read a name into a qstr (usually a +* fscrypt_name's disk_name), allocating the required buffer. Used for +* nokey names. +*/ +int btrfs_fscrypt_get_disk_name (struct extent_buffer *leaf, +struct btrfs_dir_item *dir_item, +struct fscrypt_str *name) +{ +unsigned long de_name_len =btrfs_dir_name_len (leaf, dir_item); +unsigned long de_name = (unsigned long )(dir_item +1 ); +/* +* For no-key names, we use this opportunity to find the disk +* name, so future searches don't need to deal with nokey names +* and we know what the encrypted size is. +*/ + name->name =kmalloc (de_name_len,GFP_NOFS ); + +if (!name->name) +return -ENOMEM ; + +read_extent_buffer (leaf, name->name, de_name, de_name_len); + + name->len = de_name_len; +return 0 ; +} +/* * This function is extremely similar to fscrypt_match_name() but uses an * extent_buffer.
fs/btrfs/fscrypt.h +11 -0
@@ -9,11 +9,22 @@#include "fs.h" #ifdef CONFIG_FS_ENCRYPTION +int btrfs_fscrypt_get_disk_name (struct extent_buffer *leaf, +struct btrfs_dir_item *di, +struct fscrypt_str *qstr); +bool btrfs_fscrypt_match_name (struct fscrypt_name *fname,struct extent_buffer *leaf,unsigned long de_name,u32 de_name_len);#else +static inline int btrfs_fscrypt_get_disk_name (struct extent_buffer *leaf, +struct btrfs_dir_item *di, +struct fscrypt_str *qstr) +{ +return 0 ; +} + static inline bool btrfs_fscrypt_match_name(struct fscrypt_name *fname, struct extent_buffer *leaf, unsigned long de_name,
Signature · 1 line
2.41.0
PATCH v3 14/34 btrfs: implement fscrypt ioctls
In reply to Josef BacikFrom: Omar Sandoval <[email protected]>
These ioctls allow encryption to actually be used.
The set_encryption_policy ioctl is the thing which actually turns on encryption, and therefore sets the ENCRYPT flag in the superblock. This prevents the filesystem from being loaded on older kernels.
fscrypt provides CONFIG_FS_ENCRYPTION-disabled versions of all these functions which just return -EOPNOTSUPP, so the ioctls don't need to be compiled out if CONFIG_FS_ENCRYPTION isn't enabled.
We could instead gate this ioctl on the superblock having the flag set, if we wanted to require mkfs with the encrypt flag in order to have a filesystem with any encryption.
--- fs/btrfs/ioctl.c | 28 ++++++++++++++++++++++++++++ 1 file changed, 28 insertions(+)
fs/btrfs/ioctl.c +28 -0
@@ -4575,6 +4575,34 @@ long btrfs_ioctl(struct file *file, unsigned intreturn btrfs_ioctl_get_fslabel (fs_info, argp);case FS_IOC_SETFSLABEL :return btrfs_ioctl_set_fslabel (file, argp); +case FS_IOC_SET_ENCRYPTION_POLICY : { +if (!IS_ENABLED (CONFIG_FS_ENCRYPTION )) +return -EOPNOTSUPP ; +if (sb_rdonly (fs_info->sb)) +return -EROFS ; +/* +* If we crash before we commit, nothing encrypted could have +* been written so it doesn't matter whether the encrypted +* state persists. +*/ +btrfs_set_fs_incompat (fs_info,ENCRYPT ); +return fscrypt_ioctl_set_policy (file, (const void __user *)arg); + } +case FS_IOC_GET_ENCRYPTION_POLICY : +return fscrypt_ioctl_get_policy (file, (void __user *)arg); +case FS_IOC_GET_ENCRYPTION_POLICY_EX : +return fscrypt_ioctl_get_policy_ex (file, (void __user *)arg); +case FS_IOC_ADD_ENCRYPTION_KEY : +return fscrypt_ioctl_add_key (file, (void __user *)arg); +case FS_IOC_REMOVE_ENCRYPTION_KEY : +return fscrypt_ioctl_remove_key (file, (void __user *)arg); +case FS_IOC_REMOVE_ENCRYPTION_KEY_ALL_USERS : +return fscrypt_ioctl_remove_key_all_users (file, + (void __user *)arg); +case FS_IOC_GET_ENCRYPTION_KEY_STATUS : +return fscrypt_ioctl_get_key_status (file, (void __user *)arg); +case FS_IOC_GET_ENCRYPTION_NONCE : +return fscrypt_ioctl_get_nonce (file, (void __user *)arg);case FITRIM :return btrfs_ioctl_fitrim (fs_info, argp);case BTRFS_IOC_SNAP_CREATE :
Signature · 1 line
2.41.0
PATCH v3 15/34 btrfs: add encryption to CONFIG_BTRFS_DEBUG
In reply to Josef BacikFrom: Sweet Tea Dorminy <[email protected]>
Since encryption is currently under BTRFS_DEBUG, this adds its
dependencies: inline encryption from fscrypt, and the inline encryption fallback path from the block layer.
--- fs/btrfs/ioctl.c | 2 ++ 1 file changed, 2 insertions(+)
fs/btrfs/ioctl.c +2 -0
@@ -4575,6 +4575,7 @@ long btrfs_ioctl(struct file *file, unsigned intreturn btrfs_ioctl_get_fslabel (fs_info, argp);case FS_IOC_SETFSLABEL :return btrfs_ioctl_set_fslabel (file, argp); +#ifdef CONFIG_BTRFS_DEBUG case FS_IOC_SET_ENCRYPTION_POLICY : {if (!IS_ENABLED (CONFIG_FS_ENCRYPTION ))return -EOPNOTSUPP ;
@@ -4603,6 +4604,7 @@ long btrfs_ioctl(struct file *file, unsigned intreturn fscrypt_ioctl_get_key_status (file, (void __user *)arg);case FS_IOC_GET_ENCRYPTION_NONCE :return fscrypt_ioctl_get_nonce (file, (void __user *)arg); +#endif /* CONFIG_BTRFS_DEBUG */ case FITRIM :return btrfs_ioctl_fitrim (fs_info, argp);case BTRFS_IOC_SNAP_CREATE :
Signature · 1 line
2.41.0
PATCH v3 16/34 btrfs: add get_devices hook for fscrypt
In reply to Josef BacikFrom: Sweet Tea Dorminy <[email protected]>
Since extent encryption requires inline encryption, even though we expect to use the inlinecrypt software fallback most of the time, we need to enumerate all the devices in use by btrfs.
--- fs/btrfs/fscrypt.c | 37 +++++++++++++++++++++++++++++++++++++ 1 file changed, 37 insertions(+)
fs/btrfs/fscrypt.c +37 -0
@@ -11,7 +11,9 @@#include "ioctl.h" #include "messages.h" #include "root-tree.h" +#include "super.h" #include "transaction.h" +#include "volumes.h" #include "xattr.h" /*
@@ -178,8 +180,43 @@ static bool btrfs_fscrypt_empty_dir(struct inode *inode)return inode->i_size ==BTRFS_EMPTY_DIR_SIZE ; } +static struct block_device **btrfs_fscrypt_get_devices (struct super_block *sb, +unsigned int *num_devs) +{ +struct btrfs_fs_info *fs_info =btrfs_sb (sb); +struct btrfs_fs_devices *fs_devices = fs_info->fs_devices; +int nr_devices = fs_devices->open_devices; +struct block_device **devs; +struct btrfs_device *device; +int i =0 ; + + devs =kmalloc_array (nr_devices,sizeof (*devs),GFP_NOFS |GFP_NOWAIT ); +if (!devs) +return ERR_PTR (-ENOMEM ); + +rcu_read_lock (); +list_for_each_entry_rcu (device, &fs_devices->devices, dev_list) { +if (!test_bit (BTRFS_DEV_STATE_IN_FS_METADATA , + &device->dev_state) || + !device->bdev || +test_bit (BTRFS_DEV_STATE_REPLACE_TGT , &device->dev_state)) +continue ; + + devs[i++] = device->bdev; + +if (i >= nr_devices) +break ; + + } +rcu_read_unlock (); + + *num_devs = i; +return devs; +} +const struct fscrypt_operations btrfs_fscrypt_ops = { .get_context = btrfs_fscrypt_get_context, .set_context = btrfs_fscrypt_set_context, .empty_dir = btrfs_fscrypt_empty_dir, + .get_devices = btrfs_fscrypt_get_devices, };
Signature · 1 line
2.41.0
PATCH v3 17/34 btrfs: turn on inlinecrypt mount option for encrypt
In reply to Josef BacikFrom: Sweet Tea Dorminy <[email protected]>
fscrypt's extent encryption requires the use of inline encryption or the software fallback that the block layer provides; it is rather complicated to allow software encryption with extent encryption due to the timing of memory allocations. Thus, if btrfs has ever had a encrypted file, or when encryption is enabled on a directory, update the mount flags to include inlinecrypt.
--- fs/btrfs/ioctl.c | 3 +++ fs/btrfs/super.c | 10 ++++++++++ 2 files changed, 13 insertions(+)
fs/btrfs/ioctl.c +3 -0
@@ -4587,6 +4587,9 @@ long btrfs_ioctl(struct file *file, unsigned int* state persists. */ btrfs_set_fs_incompat (fs_info,ENCRYPT ); +if (!(inode->i_sb->s_flags &SB_INLINECRYPT )) { + inode->i_sb->s_flags |=SB_INLINECRYPT ; + }return fscrypt_ioctl_set_policy (file, (const void __user *)arg); }case FS_IOC_GET_ENCRYPTION_POLICY :
fs/btrfs/super.c +10 -0
@@ -1120,6 +1120,16 @@ static int btrfs_fill_super(struct super_block *sb,return err; } +if (btrfs_fs_incompat (fs_info,ENCRYPT )) { +if (IS_ENABLED (CONFIG_FS_ENCRYPTION_INLINE_CRYPT )) { + sb->s_flags |=SB_INLINECRYPT ; + }else { +btrfs_err (fs_info,"encryption not supported" ); + err = -EINVAL ; + goto fail_close; + } + } + inode =btrfs_iget (sb,BTRFS_FIRST_FREE_OBJECTID , fs_info->fs_root);if (IS_ERR (inode)) { err =PTR_ERR (inode);
Signature · 1 line
2.41.0
PATCH v3 18/34 btrfs: set file extent encryption excplicitly
In reply to Josef BacikFrom: Sweet Tea Dorminy <[email protected]>
This puts the long-preserved 1-byte encryption field to work, storing whether the extent is encrypted. Update the tree-checker to allow for the encryption bit to be set to our valid types.
--- fs/btrfs/accessors.h | 2 ++ fs/btrfs/inode.c | 8 ++++++-- fs/btrfs/tree-checker.c | 8 +++++--- fs/btrfs/tree-log.c | 2 ++ include/uapi/linux/btrfs_tree.h | 8 +++++++- 5 files changed, 22 insertions(+), 6 deletions(-)
fs/btrfs/accessors.h +2 -0
@@ -949,6 +949,8 @@ BTRFS_SETGET_STACK_FUNCS(stack_file_extent_disk_num_bytes, struct btrfs_file_extent_item, disk_num_bytes, 64);BTRFS_SETGET_STACK_FUNCS (stack_file_extent_compression , struct btrfs_file_extent_item, compression, 8); +BTRFS_SETGET_STACK_FUNCS (stack_file_extent_encryption, + struct btrfs_file_extent_item, encryption, 8); BTRFS_SETGET_FUNCS(file_extent_type, struct btrfs_file_extent_item, type, 8);
fs/btrfs/inode.c +6 -2
@@ -2992,7 +2992,9 @@ static int insert_ordered_extent_file_extent(struct btrfs_trans_handle *trans,btrfs_set_stack_file_extent_num_bytes (&stack_fi, num_bytes);btrfs_set_stack_file_extent_ram_bytes (&stack_fi, ram_bytes);btrfs_set_stack_file_extent_compression (&stack_fi, oe->compress_type); -/* Encryption and other encoding is reserved and all 0 */ +btrfs_set_stack_file_extent_encryption (&stack_fi, +BTRFS_ENCRYPTION_NONE ); +/* Other encoding is reserved and always 0 */ /* * For delalloc, when completing an ordered extent we update the inode's
@@ -9640,7 +9642,9 @@ static struct btrfs_trans_handle *insert_prealloc_file_extent(btrfs_set_stack_file_extent_num_bytes (&stack_fi, len);btrfs_set_stack_file_extent_ram_bytes (&stack_fi, len);btrfs_set_stack_file_extent_compression (&stack_fi,BTRFS_COMPRESS_NONE ); -/* Encryption and other encoding is reserved and all 0 */ +btrfs_set_stack_file_extent_encryption (&stack_fi, +BTRFS_ENCRYPTION_NONE ); +/* Other encoding is reserved and always 0 */ qgroup_released =btrfs_qgroup_release_data (inode, file_offset, len);if (qgroup_released <0 )
fs/btrfs/tree-checker.c +5 -3
@@ -210,6 +210,7 @@ static int check_extent_data_item(struct extent_buffer *leaf,u32 sectorsize = fs_info->sectorsize;u32 item_size =btrfs_item_size (leaf, slot);u64 extent_end; +u8 policy;if (unlikely (!IS_ALIGNED (key->offset, sectorsize))) { file_extent_err(leaf, slot,
@@ -261,10 +262,11 @@ static int check_extent_data_item(struct extent_buffer *leaf, BTRFS_NR_COMPRESS_TYPES - 1);return -EUCLEAN ; } -if (unlikely (btrfs_file_extent_encryption (leaf, fi))) { + policy =btrfs_file_extent_encryption (leaf, fi); +if (unlikely (policy >=BTRFS_NR_ENCRYPTION_TYPES )) {file_extent_err (leaf, slot, -"invalid encryption for file extent, have %u expect 0" , -btrfs_file_extent_encryption (leaf, fi)); +"invalid encryption for file extent, have %u expect range [0, %u]" , + policy,BTRFS_NR_ENCRYPTION_TYPES -1 );return -EUCLEAN ; }if (btrfs_file_extent_type (leaf, fi) ==BTRFS_FILE_EXTENT_INLINE ) {
fs/btrfs/tree-log.c +2 -0
@@ -4628,6 +4628,7 @@ static int log_one_extent(struct btrfs_trans_handle *trans,u64 extent_offset = em->start - em->orig_start;u64 block_len;int ret; +u8 encryption =BTRFS_ENCRYPTION_NONE ;btrfs_set_stack_file_extent_generation (&fi, trans->transid);if (test_bit (EXTENT_FLAG_PREALLOC , &em->flags))
@@ -4649,6 +4650,7 @@ static int log_one_extent(struct btrfs_trans_handle *trans,btrfs_set_stack_file_extent_num_bytes (&fi, em->len);btrfs_set_stack_file_extent_ram_bytes (&fi, em->ram_bytes);btrfs_set_stack_file_extent_compression (&fi, em->compress_type); +btrfs_set_stack_file_extent_encryption (&fi, encryption); ret =log_extent_csums (trans, inode, log, em, ctx);if (ret)
include/uapi/linux/btrfs_tree.h +7 -1
@@ -1093,8 +1093,14 @@ struct btrfs_file_extent_item {* but not for stat. */ __u8 compression; + +/* +* Type of encryption in use. Unencrypted value is 0. +*/ __u8 encryption; -__le16 other_encoding;/* spare for later use */ + +/* spare for later use */ +__le16 other_encoding;/* are we inline data or a real extent? */ __u8 type;
Signature · 1 line
2.41.0
PATCH v3 19/34 btrfs: add fscrypt_info and encryption_type to extent_map
In reply to Josef BacikFrom: Sweet Tea Dorminy <[email protected]>
Each extent_map will end up with a pointer to its associated fscrypt_info if any, which should have the same lifetime as the extent_map. We are also going to need to track the encryption_type for the file extent items. Add the fscrypt_info to the extent_map, and the subsequent code for transferring it in the split and merge cases, as well as the code necessary to free them. A future patch will add the code to load them as appropriate.
--- fs/btrfs/extent_map.c | 32 +++++++++++++++++++++++++++++--- fs/btrfs/extent_map.h | 2 ++ fs/btrfs/file-item.c | 1 + fs/btrfs/inode.c | 1 + 4 files changed, 33 insertions(+), 3 deletions(-)
fs/btrfs/extent_map.c +29 -3
@@ -61,6 +61,7 @@ struct extent_map *alloc_extent_map(void)static void __free_extent_map (struct extent_map *em) { +fscrypt_put_extent_info (em->fscrypt_info);if (test_bit (EXTENT_FLAG_FS_MAPPING , &em->flags))kfree (em->map_lookup);kmem_cache_free (extent_map_cache, em);
@@ -103,12 +104,24 @@ void free_extent_map_safe(struct extent_map_tree *tree,if (!em)return ; -if (refcount_dec_and_test (&em->refs)) { -WARN_ON (extent_map_in_tree (em)); -WARN_ON (!list_empty (&em->list)); +if (!refcount_dec_and_test (&em->refs)) +return ; + +WARN_ON (extent_map_in_tree (em)); +WARN_ON (!list_empty (&em->list)); + +/* +* We could take a lock freeing the fscrypt_info, so add this to the +* list of freed_extents to be freed later. +*/ +if (em->fscrypt_info) {list_add_tail (&em->free_list, &tree->freed_extents);set_bit (EXTENT_MAP_TREE_PENDING_FREES , &tree->flags); +return ; } + +/* Nothing scary here, just free the object. */ +__free_extent_map (em); }/*
@@ -274,6 +287,12 @@ static int mergable_maps(struct extent_map *prev, struct extent_map *next)if (!list_empty (&prev->list) || !list_empty (&next->list))return 0 ; +/* +* Don't merge adjacent encrypted maps. +*/ +if (prev->fscrypt_info || next->fscrypt_info) +return 0 ; +ASSERT (next->block_start !=EXTENT_MAP_DELALLOC && prev->block_start !=EXTENT_MAP_DELALLOC );
@@ -884,6 +903,8 @@ void btrfs_drop_extent_map_range(struct btrfs_inode *inode, u64 start, u64 end, split->generation = gen; split->flags = flags; split->compress_type = em->compress_type; + split->fscrypt_info = +fscrypt_get_extent_info (em->fscrypt_info);replace_extent_mapping (em_tree, em, split, modified);free_extent_map (split); split = split2;
@@ -925,6 +946,8 @@ void btrfs_drop_extent_map_range(struct btrfs_inode *inode, u64 start, u64 end, split->orig_block_len =0 ; } + split->fscrypt_info = +fscrypt_get_extent_info (em->fscrypt_info);if (extent_map_in_tree (em)) {replace_extent_mapping (em_tree, em, split, modified);
@@ -1087,6 +1110,7 @@ int split_extent_map(struct btrfs_inode *inode, u64 start, u64 len, u64 pre, split_pre->flags = flags; split_pre->compress_type = em->compress_type; split_pre->generation = em->generation; + split_pre->fscrypt_info =fscrypt_get_extent_info (em->fscrypt_info);replace_extent_mapping (em_tree, em, split_pre,1 );
@@ -1106,6 +1130,8 @@ int split_extent_map(struct btrfs_inode *inode, u64 start, u64 len, u64 pre, split_mid->flags = flags; split_mid->compress_type = em->compress_type; split_mid->generation = em->generation; + split_mid->fscrypt_info =fscrypt_get_extent_info (em->fscrypt_info); +add_extent_mapping (em_tree, split_mid,1 );/* Once for us */
fs/btrfs/extent_map.h +2 -0
@@ -50,10 +50,12 @@ struct extent_map {*/ u64 generation;unsigned long flags; +struct fscrypt_extent_info *fscrypt_info;/* Used for chunk mappings, flag EXTENT_FLAG_FS_MAPPING must be set */ struct map_lookup *map_lookup;refcount_t refs;unsigned int compress_type; +unsigned int encryption_type;struct list_head list;struct list_head free_list; };
fs/btrfs/file-item.c +1 -0
@@ -1305,6 +1305,7 @@ void btrfs_extent_item_to_extent_map(struct btrfs_inode *inode,if (type ==BTRFS_FILE_EXTENT_PREALLOC )set_bit (EXTENT_FLAG_PREALLOC , &em->flags); } + em->encryption_type =btrfs_file_extent_encryption (leaf, fi); }else if (type ==BTRFS_FILE_EXTENT_INLINE ) { em->block_start =EXTENT_MAP_INLINE ; em->start = extent_start;
fs/btrfs/inode.c +1 -0
@@ -7348,6 +7348,7 @@ static struct extent_map *create_io_em(struct btrfs_inode *inode, u64 start,set_bit (EXTENT_FLAG_COMPRESSED , &em->flags); em->compress_type = compress_type; } + em->encryption_type =BTRFS_ENCRYPTION_NONE ; ret =btrfs_replace_extent_map_range (inode, em, true);if (ret) {
Signature · 1 line
2.41.0
PATCH v3 20/34 btrfs: add fscrypt_info and encryption_type to ordered_extent
In reply to Josef BacikWe're going to need these to update the file extent items once the writes are complete. Add them and add the pieces necessary to assign them and free everything.
--- fs/btrfs/ordered-data.c | 2 ++ fs/btrfs/ordered-data.h | 6 ++++++ 2 files changed, 8 insertions(+)
fs/btrfs/ordered-data.c +2 -0
@@ -181,6 +181,7 @@ static struct btrfs_ordered_extent *alloc_ordered_extent( entry->bytes_left = num_bytes; entry->inode =igrab (&inode->vfs_inode); entry->compress_type = compress_type; + entry->encryption_type =BTRFS_ENCRYPTION_NONE ; entry->truncated_len = (u64)-1 ; entry->qgroup_rsv = ret; entry->flags = flags;
@@ -564,6 +565,7 @@ void btrfs_put_ordered_extent(struct btrfs_ordered_extent *entry)list_del (&sum->list);kvfree (sum); } +fscrypt_put_extent_info (entry->fscrypt_info);kmem_cache_free (btrfs_ordered_extent_cache, entry); } }
fs/btrfs/ordered-data.h +6 -0
@@ -115,6 +115,9 @@ struct btrfs_ordered_extent {/* compression algorithm */ int compress_type; +/* encryption mode */ +int encryption_type; +/* Qgroup reserved space */ int qgroup_rsv;
@@ -124,6 +127,9 @@ struct btrfs_ordered_extent {/* the inode we belong to */ struct inode *inode; +/* the fscrypt_info for this extent, if necessary */ +struct fscrypt_extent_info *fscrypt_info; +/* list of checksums for insertion when the extent io is done */ struct list_head list;
Signature · 1 line
2.41.0
PATCH v3 21/34 btrfs: plumb through setting the fscrypt_info for ordered extents
In reply to Josef BacikWe're going to be getting fscrypt_info from the extent maps, update the helpers to take an fscrypt_info argument and use that to set the encryption type on the ordered extent.
--- fs/btrfs/inode.c | 20 +++++++++++--------- fs/btrfs/ordered-data.c | 32 ++++++++++++++++++++------------ fs/btrfs/ordered-data.h | 9 +++++---- 3 files changed, 36 insertions(+), 25 deletions(-)
fs/btrfs/inode.c +11 -9
@@ -1162,7 +1162,8 @@ static void submit_one_async_extent(struct async_chunk *async_chunk, }free_extent_map (em); - ordered = btrfs_alloc_ordered_extent(inode, start, /* file_offset */ + ordered = btrfs_alloc_ordered_extent(inode, NULL, + start, /* file_offset */ async_extent->ram_size, /* num_bytes */ async_extent->ram_size, /* ram_bytes */ ins.objectid, /* disk_bytenr */
@@ -1425,9 +1426,10 @@ static noinline int cow_file_range(struct btrfs_inode *inode, }free_extent_map (em); - ordered =btrfs_alloc_ordered_extent (inode, start, ram_size, - ram_size, ins.objectid, cur_alloc_size, -0 ,1 <<BTRFS_ORDERED_REGULAR , + ordered =btrfs_alloc_ordered_extent (inode,NULL , + start, ram_size, ram_size, ins.objectid, + cur_alloc_size,0 , +1 <<BTRFS_ORDERED_REGULAR ,BTRFS_COMPRESS_NONE );if (IS_ERR (ordered)) { ret =PTR_ERR (ordered);
@@ -2158,7 +2160,7 @@ static noinline int run_delalloc_nocow(struct btrfs_inode *inode,free_extent_map (em); } - ordered =btrfs_alloc_ordered_extent (inode, cur_offset, + ordered =btrfs_alloc_ordered_extent (inode,NULL , cur_offset, nocow_args.num_bytes, nocow_args.num_bytes, nocow_args.disk_bytenr, nocow_args.num_bytes,0 , is_prealloc
@@ -7040,7 +7042,7 @@ static struct extent_map *btrfs_create_dio_extent(struct btrfs_inode *inode,if (IS_ERR (em)) goto out; } - ordered = btrfs_alloc_ordered_extent(inode, start, len, len, + ordered = btrfs_alloc_ordered_extent(inode, NULL, start, len, len, block_start, block_len, 0, (1 << type) | (1 << BTRFS_ORDERED_DIRECT),
@@ -10512,9 +10514,9 @@ ssize_t btrfs_do_encoded_write(struct kiocb *iocb, struct iov_iter *from, }free_extent_map (em); - ordered =btrfs_alloc_ordered_extent (inode, start, num_bytes, ram_bytes, - ins.objectid, ins.offset, - encoded->unencoded_offset, + ordered =btrfs_alloc_ordered_extent (inode,NULL , start, + num_bytes, ram_bytes, ins.objectid, + ins.offset, encoded->unencoded_offset, (1 <<BTRFS_ORDERED_ENCODED ) | (1 <<BTRFS_ORDERED_COMPRESSED ), compression);
fs/btrfs/ordered-data.c +20 -12
@@ -146,9 +146,11 @@ static inline struct rb_node *ordered_tree_search(struct btrfs_inode *inode, }static struct btrfs_ordered_extent *alloc_ordered_extent ( -struct btrfs_inode *inode,u64 file_offset,u64 num_bytes, -u64 ram_bytes,u64 disk_bytenr,u64 disk_num_bytes, -u64 offset,unsigned long flags,int compress_type) +struct btrfs_inode *inode, +struct fscrypt_extent_info *fscrypt_info, +u64 file_offset,u64 num_bytes,u64 ram_bytes, +u64 disk_bytenr,u64 disk_num_bytes,u64 offset, +unsigned long flags,int compress_type) {struct btrfs_ordered_extent *entry;int ret;
@@ -181,10 +183,12 @@ static struct btrfs_ordered_extent *alloc_ordered_extent( entry->bytes_left = num_bytes; entry->inode =igrab (&inode->vfs_inode); entry->compress_type = compress_type; - entry->encryption_type =BTRFS_ENCRYPTION_NONE ; entry->truncated_len = (u64)-1 ; entry->qgroup_rsv = ret; entry->flags = flags; + entry->fscrypt_info =fscrypt_get_extent_info (fscrypt_info); + entry->encryption_type = entry->fscrypt_info ? +BTRFS_ENCRYPTION_FSCRYPT :BTRFS_ENCRYPTION_NONE ;refcount_set (&entry->refs,1 );init_waitqueue_head (&entry->wait);INIT_LIST_HEAD (&entry->list);
@@ -247,6 +251,7 @@ static void insert_ordered_extent(struct btrfs_ordered_extent *entry)* Add an ordered extent to the per-inode tree. * * @inode: Inode that this extent is for. +* @fscrypt_info: The fscrypt_extent_info for this extent, if necessary. * @file_offset: Logical offset in file where the extent starts. * @num_bytes: Logical length of extent in file. * @ram_bytes: Full length of unencoded data.
@@ -263,17 +268,19 @@ static void insert_ordered_extent(struct btrfs_ordered_extent *entry)* Return: the new ordered extent or error pointer. */ struct btrfs_ordered_extent *btrfs_alloc_ordered_extent ( -struct btrfs_inode *inode,u64 file_offset, -u64 num_bytes,u64 ram_bytes,u64 disk_bytenr, -u64 disk_num_bytes,u64 offset,unsigned long flags, -int compress_type) +struct btrfs_inode *inode, +struct fscrypt_extent_info *fscrypt_info, +u64 file_offset,u64 num_bytes,u64 ram_bytes, +u64 disk_bytenr,u64 disk_num_bytes,u64 offset, +unsigned long flags,int compress_type) {struct btrfs_ordered_extent *entry;ASSERT ((flags & ~BTRFS_ORDERED_TYPE_FLAGS ) ==0 ); - entry =alloc_ordered_extent (inode, file_offset, num_bytes, ram_bytes, - disk_bytenr, disk_num_bytes, offset, flags, + entry =alloc_ordered_extent (inode, fscrypt_info, file_offset, + num_bytes, ram_bytes, disk_bytenr, + disk_num_bytes, offset, flags, compress_type);if (!IS_ERR (entry))insert_ordered_extent (entry);
@@ -1166,8 +1173,9 @@ struct btrfs_ordered_extent *btrfs_split_ordered_extent(if (WARN_ON_ONCE (ordered->disk_num_bytes != ordered->num_bytes))return ERR_PTR (-EINVAL ); - new =alloc_ordered_extent (inode, file_offset, len, len, disk_bytenr, - len,0 , flags, ordered->compress_type); + new =alloc_ordered_extent (inode, ordered->fscrypt_info, file_offset, + len, len, disk_bytenr, len,0 , flags, + ordered->compress_type);if (IS_ERR (new))return new;
fs/btrfs/ordered-data.h +5 -4
@@ -170,10 +170,11 @@ bool btrfs_dec_test_ordered_pending(struct btrfs_inode *inode,struct btrfs_ordered_extent **cached, u64 file_offset, u64 io_size);struct btrfs_ordered_extent *btrfs_alloc_ordered_extent ( -struct btrfs_inode *inode,u64 file_offset, -u64 num_bytes,u64 ram_bytes,u64 disk_bytenr, -u64 disk_num_bytes,u64 offset,unsigned long flags, -int compress_type); +struct btrfs_inode *inode, +struct fscrypt_extent_info *fscrypt_info, +u64 file_offset,u64 num_bytes,u64 ram_bytes, +u64 disk_bytenr,u64 disk_num_bytes,u64 offset, +unsigned long flags,int compress_type);void btrfs_add_ordered_sum (struct btrfs_ordered_extent *entry,struct btrfs_ordered_sum *sum); struct btrfs_ordered_extent *btrfs_lookup_ordered_extent(struct btrfs_inode *inode,
Signature · 1 line
2.41.0
PATCH v3 22/34 btrfs: populate the ordered_extent with the fscrypt context
In reply to Josef BacikThe fscrypt_extent_info will be tied to the extent_map lifetime, so it will be created when we create the IO em, or it'll already exist in the NOCOW case. Use this fscrypt_info when creating the ordered extent to make sure everything is passed through properly.
--- fs/btrfs/inode.c | 62 +++++++++++++++++++++++++++++++++--------------- 1 file changed, 43 insertions(+), 19 deletions(-)
fs/btrfs/inode.c +43 -19
@@ -1160,9 +1160,8 @@ static void submit_one_async_extent(struct async_chunk *async_chunk, ret =PTR_ERR (em); goto out_free_reserve; } -free_extent_map (em); - ordered = btrfs_alloc_ordered_extent(inode, NULL, + ordered = btrfs_alloc_ordered_extent(inode, em->fscrypt_info, start, /* file_offset */ async_extent->ram_size, /* num_bytes */ async_extent->ram_size, /* ram_bytes */
@@ -1171,6 +1170,7 @@ static void submit_one_async_extent(struct async_chunk *async_chunk,0 ,/* offset */ 1 <<BTRFS_ORDERED_COMPRESSED , async_extent->compress_type); +free_extent_map (em);if (IS_ERR (ordered)) {btrfs_drop_extent_map_range (inode, start, end, false); ret =PTR_ERR (ordered);
@@ -1424,13 +1424,13 @@ static noinline int cow_file_range(struct btrfs_inode *inode, ret =PTR_ERR (em); goto out_reserve; } -free_extent_map (em); - ordered =btrfs_alloc_ordered_extent (inode,NULL , + ordered =btrfs_alloc_ordered_extent (inode, em->fscrypt_info, start, ram_size, ram_size, ins.objectid, cur_alloc_size,0 ,1 <<BTRFS_ORDERED_REGULAR ,BTRFS_COMPRESS_NONE ); +free_extent_map (em);if (IS_ERR (ordered)) { ret =PTR_ERR (ordered); goto out_drop_extent_cache;
@@ -2003,6 +2003,8 @@ static noinline int run_delalloc_nocow(struct btrfs_inode *inode,struct btrfs_key found_key;struct btrfs_file_extent_item *fi;struct extent_buffer *leaf; +struct extent_map *em =NULL ; +struct fscrypt_extent_info *fscrypt_info =NULL ;u64 extent_end;u64 ram_bytes;u64 nocow_end;
@@ -2143,7 +2145,6 @@ static noinline int run_delalloc_nocow(struct btrfs_inode *inode, is_prealloc = extent_type ==BTRFS_FILE_EXTENT_PREALLOC ;if (is_prealloc) {u64 orig_start = found_key.offset - nocow_args.extent_offset; -struct extent_map *em; em = create_io_em(inode, cur_offset, nocow_args.num_bytes, orig_start,
@@ -2157,16 +2158,32 @@ static noinline int run_delalloc_nocow(struct btrfs_inode *inode, ret =PTR_ERR (em); goto error; } -free_extent_map (em); + fscrypt_info = em->fscrypt_info; + }else if (IS_ENCRYPTED (&inode->vfs_inode)) { +/* +* We only want to do this lookup if we're encrypted, +* otherwise fsrypt_info will be null and we can avoid +* this lookup. +*/ + em =btrfs_get_extent (inode,NULL ,0 , cur_offset, + nocow_args.num_bytes); +if (IS_ERR (em)) { +btrfs_dec_nocow_writers (nocow_bg); + ret =PTR_ERR (em); + goto error; + } + fscrypt_info = em->fscrypt_info; } - ordered =btrfs_alloc_ordered_extent (inode,NULL , cur_offset, - nocow_args.num_bytes, nocow_args.num_bytes, - nocow_args.disk_bytenr, nocow_args.num_bytes,0 , + ordered =btrfs_alloc_ordered_extent (inode, fscrypt_info, + cur_offset, nocow_args.num_bytes, + nocow_args.num_bytes, nocow_args.disk_bytenr, + nocow_args.num_bytes,0 , is_prealloc ? (1 <<BTRFS_ORDERED_PREALLOC ) : (1 <<BTRFS_ORDERED_NOCOW ),BTRFS_COMPRESS_NONE ); +free_extent_map (em);btrfs_dec_nocow_writers (nocow_bg);if (IS_ERR (ordered)) {if (is_prealloc) {
@@ -7022,6 +7039,7 @@ struct extent_map *btrfs_get_extent(struct btrfs_inode *inode, static struct extent_map *btrfs_create_dio_extent(struct btrfs_inode *inode, struct btrfs_dio_data *dio_data, + struct extent_map *orig_em, const u64 start, const u64 len, const u64 orig_start,
@@ -7033,6 +7051,7 @@ static struct extent_map *btrfs_create_dio_extent(struct btrfs_inode *inode, {struct extent_map *em =NULL ;struct btrfs_ordered_extent *ordered; +struct fscrypt_extent_info *fscrypt_info =NULL ;if (type !=BTRFS_ORDERED_NOCOW ) { em = create_io_em(inode, start, len, orig_start, block_start,
@@ -7041,9 +7060,13 @@ static struct extent_map *btrfs_create_dio_extent(struct btrfs_inode *inode, type);if (IS_ERR (em)) goto out; + fscrypt_info = em->fscrypt_info; + }else { + fscrypt_info = orig_em->fscrypt_info; } - ordered =btrfs_alloc_ordered_extent (inode,NULL , start, len, len, - block_start, block_len,0 , + + ordered =btrfs_alloc_ordered_extent (inode, fscrypt_info, start, len, + len, block_start, block_len,0 , (1 << type) | (1 <<BTRFS_ORDERED_DIRECT ),BTRFS_COMPRESS_NONE );
@@ -7080,9 +7103,10 @@ static struct extent_map *btrfs_new_extent_direct(struct btrfs_inode *inode,if (ret)return ERR_PTR (ret); - em =btrfs_create_dio_extent (inode, dio_data, start, ins.offset, start, - ins.objectid, ins.offset, ins.offset, - ins.offset,BTRFS_ORDERED_REGULAR ); + em =btrfs_create_dio_extent (inode, dio_data,NULL , start, ins.offset, + start, ins.objectid, ins.offset, + ins.offset, ins.offset, +BTRFS_ORDERED_REGULAR );btrfs_dec_block_group_reservations (fs_info, ins.objectid);if (IS_ERR (em)) btrfs_free_reserved_extent(fs_info, ins.objectid, ins.offset,
@@ -7426,9 +7450,9 @@ static int btrfs_get_blocks_direct_write(struct extent_map **map, } space_reserved = true; - em2 =btrfs_create_dio_extent (BTRFS_I (inode), dio_data, start, len, - orig_start, block_start, - len, orig_block_len, + em2 =btrfs_create_dio_extent (BTRFS_I (inode), dio_data, em, + start, len, orig_start, + block_start, len, orig_block_len, ram_bytes, type);btrfs_dec_nocow_writers (bg);if (type ==BTRFS_ORDERED_PREALLOC ) {
@@ -10512,14 +10536,14 @@ ssize_t btrfs_do_encoded_write(struct kiocb *iocb, struct iov_iter *from, ret =PTR_ERR (em); goto out_free_reserved; } -free_extent_map (em); - ordered =btrfs_alloc_ordered_extent (inode,NULL , start, + ordered =btrfs_alloc_ordered_extent (inode, em->fscrypt_info, start, num_bytes, ram_bytes, ins.objectid, ins.offset, encoded->unencoded_offset, (1 <<BTRFS_ORDERED_ENCODED ) | (1 <<BTRFS_ORDERED_COMPRESSED ), compression); +free_extent_map (em);if (IS_ERR (ordered)) {btrfs_drop_extent_map_range (inode, start, end, false); ret =PTR_ERR (ordered);
Signature · 1 line
2.41.0
PATCH v3 23/34 btrfs: keep track of fscrypt info and orig_start for dio reads
In reply to Josef BacikWe keep track of this information in the ordered extent for writes, but we need it for reads as well. Add fscrypt_extent_info and orig_start to the dio_data so we can populate this on reads. This will be used later when we attach the fscrypt context to the bios.
--- fs/btrfs/inode.c | 11 +++++++++++ 1 file changed, 11 insertions(+)
fs/btrfs/inode.c +11 -0
@@ -83,6 +83,8 @@ struct btrfs_dio_data {ssize_t submitted;struct extent_changeset *data_reserved;struct btrfs_ordered_extent *ordered; +struct fscrypt_extent_info *fscrypt_info; +u64 orig_start;bool data_space_reserved;bool nocow_done; };
@@ -7727,6 +7729,10 @@ static int btrfs_dio_iomap_begin(struct inode *inode, loff_t start, release_len); } }else { + dio_data->fscrypt_info = +fscrypt_get_extent_info (em->fscrypt_info); + dio_data->orig_start = em->orig_start; +/* * We need to unlock only the end area that we aren't using. * The rest is going to be unlocked by the endio routine.
@@ -7808,6 +7814,11 @@ static int btrfs_dio_iomap_end(struct inode *inode, loff_t pos, loff_t length, dio_data->ordered =NULL ; } +if (dio_data->fscrypt_info) { +fscrypt_put_extent_info (dio_data->fscrypt_info); + dio_data->fscrypt_info =NULL ; + } +if (write)extent_changeset_free (dio_data->data_reserved);return ret;
Signature · 1 line
2.41.0
PATCH v3 24/34 btrfs: add an optional encryption context to the end of file extents
In reply to Josef BacikThe fscrypt encryption context can be extended to include different things in the future. To facilitate future expansion add an optional btrfs_encryption_info to the end of the file extent. This will hold the size of the context and then will have the binary context tacked onto the end of the extent item.
Add the appropriate accessors to make it easy to read this information if we have encryption set, and then update the tree-checker to validate that if this is indeed set properly that the size matches properly.
--- fs/btrfs/accessors.h | 48 +++++++++++++++++++++++++++ fs/btrfs/tree-checker.c | 58 ++++++++++++++++++++++++++++----- include/uapi/linux/btrfs_tree.h | 17 +++++++++- 3 files changed, 113 insertions(+), 10 deletions(-)
fs/btrfs/accessors.h +48 -0
@@ -932,6 +932,10 @@ BTRFS_SETGET_STACK_FUNCS(super_uuid_tree_generation, struct btrfs_super_block, BTRFS_SETGET_STACK_FUNCS(super_nr_global_roots, struct btrfs_super_block, nr_global_roots,64 ); +/* struct btrfs_file_extent_encryption_info */ +BTRFS_SETGET_FUNCS(encryption_info_size, struct btrfs_encryption_info, size, +32 ); +/* struct btrfs_file_extent_item */ BTRFS_SETGET_STACK_FUNCS(stack_file_extent_type, struct btrfs_file_extent_item, type,8 );
@@ -973,6 +977,50 @@ BTRFS_SETGET_FUNCS(file_extent_encryption, struct btrfs_file_extent_item, BTRFS_SETGET_FUNCS(file_extent_other_encoding, struct btrfs_file_extent_item, other_encoding,16 ); +static inline struct btrfs_encryption_info *btrfs_file_extent_encryption_info ( +const struct btrfs_file_extent_item *ei) +{ +unsigned long offset = (unsigned long )ei; + + offset += offsetof(struct btrfs_file_extent_item , encryption_info); +return (struct btrfs_encryption_info *)offset; +} + +static inline unsigned long btrfs_file_extent_encryption_ctx_offset ( +const struct btrfs_file_extent_item *ei) +{ +unsigned long offset = (unsigned long )ei; + + offset += offsetof(struct btrfs_file_extent_item , encryption_info); +return offset + offsetof(struct btrfs_encryption_info , context); +} + +static inline u32 btrfs_file_extent_encryption_ctx_size ( +const struct extent_buffer *eb, +const struct btrfs_file_extent_item *ei) +{ +return btrfs_encryption_info_size (eb, +btrfs_file_extent_encryption_info (ei)); +} + +static inline void btrfs_set_file_extent_encryption_ctx_size ( +const struct extent_buffer *eb, +struct btrfs_file_extent_item *ei, +u32 val) +{ +btrfs_set_encryption_info_size (eb, +btrfs_file_extent_encryption_info (ei), + val); +} + +static inline u32 btrfs_file_extent_encryption_info_size ( +const struct extent_buffer *eb, +const struct btrfs_file_extent_item *ei) +{ +return btrfs_encryption_info_size (eb, +btrfs_file_extent_encryption_info (ei)); +} +/* btrfs_qgroup_status_item */ BTRFS_SETGET_FUNCS(qgroup_status_generation, struct btrfs_qgroup_status_item, generation,64 );
fs/btrfs/tree-checker.c +49 -9
79 lines not on this page · raw message
include/uapi/linux/btrfs_tree.h +16 -1
@@ -1065,12 +1065,24 @@ enum { BTRFS_NR_FILE_EXTENT_TYPES = 3, }; +/* +* Currently just the FSCRYPT_SET_CONTEXT_MAX_SIZE, which is larger than the +* current extent context size from fscrypt, so this should give us plenty of +* breathing room for expansion later. +*/ +#define BTRFS_MAX_EXTENT_CTX_SIZE 40 +enum {BTRFS_ENCRYPTION_NONE ,BTRFS_ENCRYPTION_FSCRYPT ,BTRFS_NR_ENCRYPTION_TYPES , }; +struct btrfs_encryption_info { +__le32 size; +__u8 context[0 ]; +}; +struct btrfs_file_extent_item {/* * transaction id that created this extent
@@ -1126,7 +1138,10 @@ struct btrfs_file_extent_item {* always reflects the size uncompressed and without encoding. */ __le64 num_bytes; - +/* +* the encryption info, if any +*/ +struct btrfs_encryption_info encryption_info[0 ]; } __attribute__ ((__packed__));struct btrfs_csum_item {
Signature · 1 line
2.41.0
PATCH v3 25/34 btrfs: explicitly track file extent length for replace and drop
In reply to Josef BacikFrom: Sweet Tea Dorminy <[email protected]>
With the advent of storing fscrypt contexts with each encrypted extent, extents will have a variable length depending on encryption status. Make sure the replace and drop file extent item helpers encode this information so that everything gets updated properly.
--- fs/btrfs/ctree.h | 2 ++ fs/btrfs/file.c | 4 ++-- fs/btrfs/inode.c | 7 +++++-- fs/btrfs/reflink.c | 1 + fs/btrfs/tree-log.c | 5 +++-- 5 files changed, 13 insertions(+), 6 deletions(-)
fs/btrfs/ctree.h +2 -0
@@ -372,6 +372,8 @@ struct btrfs_replace_extent_info {u64 file_offset;/* Pointer to a file extent item of type regular or prealloc. */ char *extent_buf; +/* The length of @extent_buf */ +u32 extent_buf_size;/* * Set to true when attempting to replace a file range with a new extent * described by this structure, set to false when attempting to clone an
fs/btrfs/file.c +2 -2
@@ -2261,14 +2261,14 @@ static int btrfs_insert_replace_extent(struct btrfs_trans_handle *trans, key.type =BTRFS_EXTENT_DATA_KEY ; key.offset = extent_info->file_offset; ret =btrfs_insert_empty_item (trans, root, path, &key, -sizeof (struct btrfs_file_extent_item )); + extent_info->extent_buf_size);if (ret)return ret; leaf = path->nodes[0 ]; slot = path->slots[0 ];write_extent_buffer (leaf, extent_info->extent_buf,btrfs_item_ptr_offset (leaf, slot), -sizeof (struct btrfs_file_extent_item )); + extent_info->extent_buf_size); extent = btrfs_item_ptr(leaf, slot, struct btrfs_file_extent_item);ASSERT (btrfs_file_extent_type (leaf, extent) !=BTRFS_FILE_EXTENT_INLINE );btrfs_set_file_extent_offset (leaf, extent, extent_info->data_offset);
fs/btrfs/inode.c +5 -2
@@ -2898,6 +2898,7 @@ static int insert_reserved_file_extent(struct btrfs_trans_handle *trans,u64 num_bytes =btrfs_stack_file_extent_num_bytes (stack_fi);u64 ram_bytes =btrfs_stack_file_extent_ram_bytes (stack_fi);struct btrfs_drop_extents_args drop_args = {0 }; +size_t fscrypt_context_size =0 ;int ret; path =btrfs_alloc_path ();
@@ -2917,7 +2918,7 @@ static int insert_reserved_file_extent(struct btrfs_trans_handle *trans, drop_args.start = file_pos; drop_args.end = file_pos + num_bytes; drop_args.replace_extent = true; - drop_args.extent_item_size =sizeof (*stack_fi); + drop_args.extent_item_size =sizeof (*stack_fi) + fscrypt_context_size; ret =btrfs_drop_extents (trans, root, inode, &drop_args);if (ret) goto out;
@@ -2928,7 +2929,7 @@ static int insert_reserved_file_extent(struct btrfs_trans_handle *trans, ins.type =BTRFS_EXTENT_DATA_KEY ; ret =btrfs_insert_empty_item (trans, root, path, &ins, -sizeof (*stack_fi)); +sizeof (*stack_fi) + fscrypt_context_size);if (ret) goto out; }
@@ -9671,6 +9672,7 @@ static struct btrfs_trans_handle *insert_prealloc_file_extent(u64 len = ins->offset;int qgroup_released;int ret; +size_t fscrypt_context_size =0 ;memset (&stack_fi,0 ,sizeof (stack_fi));
@@ -9703,6 +9705,7 @@ static struct btrfs_trans_handle *insert_prealloc_file_extent( extent_info.data_len = len; extent_info.file_offset = file_offset; extent_info.extent_buf = (char *)&stack_fi; + extent_info.extent_buf_size =sizeof (stack_fi) + fscrypt_context_size; extent_info.is_new_extent = true; extent_info.update_times = true; extent_info.qgroup_reserved = qgroup_released;
fs/btrfs/reflink.c +1 -0
@@ -500,6 +500,7 @@ static int btrfs_clone(struct inode *src, struct inode *inode, clone_info.data_len = datal; clone_info.file_offset = new_key.offset; clone_info.extent_buf = buf; + clone_info.extent_buf_size = size; clone_info.is_new_extent = false; clone_info.update_times = !no_time_update; ret = btrfs_replace_file_extents(BTRFS_I(inode), path,
fs/btrfs/tree-log.c +3 -2
@@ -4628,6 +4628,7 @@ static int log_one_extent(struct btrfs_trans_handle *trans,u64 extent_offset = em->start - em->orig_start;u64 block_len;int ret; +size_t fscrypt_context_size =0 ;u8 encryption =BTRFS_ENCRYPTION_NONE ;btrfs_set_stack_file_extent_generation (&fi, trans->transid);
@@ -4670,7 +4671,7 @@ static int log_one_extent(struct btrfs_trans_handle *trans, drop_args.start = em->start; drop_args.end = em->start + em->len; drop_args.replace_extent = true; - drop_args.extent_item_size =sizeof (fi); + drop_args.extent_item_size =sizeof (fi) + fscrypt_context_size; ret =btrfs_drop_extents (trans, log, inode, &drop_args);if (ret)return ret;
@@ -4682,7 +4683,7 @@ static int log_one_extent(struct btrfs_trans_handle *trans, key.offset = em->start; ret =btrfs_insert_empty_item (trans, log, path, &key, -sizeof (fi)); +sizeof (fi) + fscrypt_context_size);if (ret)return ret; }
Signature · 1 line
2.41.0
PATCH v3 26/34 btrfs: pass through fscrypt_extent_info to the file extent helpers
In reply to Josef BacikNow that we have the fscrypt_extnet_info in all of the supporting structures, pass this through and set the file extent encryption bit accordingly from the supporting structures. In subsequent patches code will be added to populate these appropriately.
--- fs/btrfs/inode.c | 18 +++++++++++------- fs/btrfs/tree-log.c | 2 +- 2 files changed, 12 insertions(+), 8 deletions(-)
fs/btrfs/inode.c +11 -7
@@ -2882,7 +2882,9 @@ int btrfs_writepage_cow_fixup(struct page *page) }static int insert_reserved_file_extent (struct btrfs_trans_handle *trans, -struct btrfs_inode *inode,u64 file_pos, +struct btrfs_inode *inode, +struct fscrypt_extent_info *fscrypt_info, +u64 file_pos,struct btrfs_file_extent_item *stack_fi,const bool update_inode_bytes,u64 qgroup_reserved)
@@ -3014,8 +3016,7 @@ static int insert_ordered_extent_file_extent(struct btrfs_trans_handle *trans,btrfs_set_stack_file_extent_num_bytes (&stack_fi, num_bytes);btrfs_set_stack_file_extent_ram_bytes (&stack_fi, ram_bytes);btrfs_set_stack_file_extent_compression (&stack_fi, oe->compress_type); -btrfs_set_stack_file_extent_encryption (&stack_fi, -BTRFS_ENCRYPTION_NONE ); +btrfs_set_stack_file_extent_encryption (&stack_fi, oe->encryption_type);/* Other encoding is reserved and always 0 */ /*
@@ -3029,8 +3030,9 @@ static int insert_ordered_extent_file_extent(struct btrfs_trans_handle *trans,test_bit (BTRFS_ORDERED_TRUNCATED , &oe->flags);return insert_reserved_file_extent (trans,BTRFS_I (oe->inode), - oe->file_offset, &stack_fi, - update_inode_bytes, oe->qgroup_rsv); + oe->fscrypt_info, oe->file_offset, + &stack_fi, update_inode_bytes, + oe->qgroup_rsv); }/*
@@ -9662,6 +9664,7 @@ static struct btrfs_trans_handle *insert_prealloc_file_extent(struct btrfs_trans_handle *trans_in, struct btrfs_inode *inode, struct btrfs_key *ins, + struct fscrypt_extent_info *fscrypt_info, u64 file_offset) { struct btrfs_file_extent_item stack_fi;
@@ -9683,6 +9686,7 @@ static struct btrfs_trans_handle *insert_prealloc_file_extent(btrfs_set_stack_file_extent_ram_bytes (&stack_fi, len);btrfs_set_stack_file_extent_compression (&stack_fi,BTRFS_COMPRESS_NONE );btrfs_set_stack_file_extent_encryption (&stack_fi, + fscrypt_info ?BTRFS_ENCRYPTION_FSCRYPT :BTRFS_ENCRYPTION_NONE );/* Other encoding is reserved and always 0 */
@@ -9691,7 +9695,7 @@ static struct btrfs_trans_handle *insert_prealloc_file_extent(return ERR_PTR (qgroup_released);if (trans) { - ret =insert_reserved_file_extent (trans, inode, + ret =insert_reserved_file_extent (trans, inode, fscrypt_info, file_offset, &stack_fi, true, qgroup_released);if (ret)
@@ -9785,7 +9789,7 @@ static int __btrfs_prealloc_file_range(struct inode *inode, int mode, last_alloc = ins.offset; trans =insert_prealloc_file_extent (trans,BTRFS_I (inode), - &ins, cur_offset); + &ins,NULL , cur_offset);/* * Now that we inserted the prealloc extent we can finally * decrement the number of reservations in the block group.
fs/btrfs/tree-log.c +1 -1
@@ -4629,7 +4629,7 @@ static int log_one_extent(struct btrfs_trans_handle *trans,u64 block_len;int ret;size_t fscrypt_context_size =0 ; -u8 encryption =BTRFS_ENCRYPTION_NONE ; +u8 encryption = em->encryption_type;btrfs_set_stack_file_extent_generation (&fi, trans->transid);if (test_bit (EXTENT_FLAG_PREALLOC , &em->flags))
Signature · 1 line
2.41.0
PATCH v3 27/34 btrfs: pass the fscrypt_info through the replace extent infrastructure
In reply to Josef BacikPrealloc uses the btrfs_replace_file_extents() infrastructure to insert its new extents. We need to set the fscrypt context on these extents, so pass this through the btrfs_replace_extent_info so it can be used in a later patch when we hook in this infrastructure.
--- fs/btrfs/ctree.h | 2 ++ fs/btrfs/inode.c | 1 + 2 files changed, 3 insertions(+)
fs/btrfs/ctree.h +2 -0
@@ -374,6 +374,8 @@ struct btrfs_replace_extent_info {char *extent_buf;/* The length of @extent_buf */ u32 extent_buf_size; +/* The fscrypt_extent_info for a new extent. */ +struct fscrypt_extent_info *fscrypt_info;/* * Set to true when attempting to replace a file range with a new extent * described by this structure, set to false when attempting to clone an
fs/btrfs/inode.c +1 -0
@@ -9714,6 +9714,7 @@ static struct btrfs_trans_handle *insert_prealloc_file_extent( extent_info.update_times = true; extent_info.qgroup_reserved = qgroup_released; extent_info.insertions =0 ; + extent_info.fscrypt_info = fscrypt_info; path =btrfs_alloc_path ();if (!path) {
Signature · 1 line
2.41.0
PATCH v3 28/34 btrfs: implement the fscrypt extent encryption hooks
In reply to Josef BacikThis patch implements the necessary hooks from fscrypt to support per-extent encryption. There's two main entry points
btrfs_fscrypt_load_extent_infobtrfs_fscrypt_save_extent_info
btrfs_fscrypt_load_extent_info gets called when we create the extent maps from the file extent item at btrfs_get_extent() time. We read the extent context, and pass it into fscrypt to create the appropriate fscrypt_extent_info structure. This is then used on the bio's to make sure the encryption is done properly.
btrfs_fscrypt_save_extent_info is used to generate the fscrypt context from fscrypt and save it into the file extent item when we create a new file extent item.
--- fs/btrfs/defrag.c | 10 ++++++++- fs/btrfs/file-item.c | 11 +++++++++- fs/btrfs/file-item.h | 5 ++++- fs/btrfs/file.c | 9 ++++++++ fs/btrfs/fscrypt.c | 49 ++++++++++++++++++++++++++++++++++++++++++++ fs/btrfs/fscrypt.h | 31 ++++++++++++++++++++++++++++ fs/btrfs/inode.c | 22 +++++++++++++++++++- fs/btrfs/tree-log.c | 10 +++++++++ 8 files changed, 143 insertions(+), 4 deletions(-)
fs/btrfs/defrag.c +9 -1
@@ -16,6 +16,7 @@#include "defrag.h" #include "file-item.h" #include "super.h" +#include "fscrypt.h" static struct kmem_cache *btrfs_inode_defrag_cachep;
@@ -631,9 +632,12 @@ static struct extent_map *defrag_get_extent(struct btrfs_inode *inode,struct btrfs_path path = {0 };struct extent_map *em;struct btrfs_key key; +struct btrfs_fscrypt_ctx ctx;u64 ino =btrfs_ino (inode);int ret; + ctx.size =0 ; + em =alloc_extent_map ();if (!em) { ret = -ENOMEM ;
@@ -728,7 +732,7 @@ static struct extent_map *defrag_get_extent(struct btrfs_inode *inode, goto next;/* Now this extent covers @start, convert it to em */ -btrfs_extent_item_to_extent_map (inode, &path, fi, em); +btrfs_extent_item_to_extent_map (inode, &path, fi, em, &ctx);break ; next: ret =btrfs_next_item (root, &path);
@@ -738,6 +742,10 @@ static struct extent_map *defrag_get_extent(struct btrfs_inode *inode, goto not_found; }btrfs_release_path (&path); + + ret =btrfs_fscrypt_load_extent_info (inode, em, &ctx); +if (ret) + goto err;return em; not_found:
fs/btrfs/file-item.c +10 -1
@@ -21,6 +21,7 @@#include "accessors.h" #include "file-item.h" #include "super.h" +#include "fscrypt.h" #define __MAX_CSUM_ITEMS (r, size) ((unsigned long)(((BTRFS_LEAF_DATA_SIZE(r) - \ sizeof(struct btrfs_item) * 2) / \
@@ -1264,7 +1265,8 @@ int btrfs_csum_file_blocks(struct btrfs_trans_handle *trans,void btrfs_extent_item_to_extent_map (struct btrfs_inode *inode,const struct btrfs_path *path,struct btrfs_file_extent_item *fi, -struct extent_map *em) +struct extent_map *em, +struct btrfs_fscrypt_ctx *ctx) {struct btrfs_fs_info *fs_info = inode->root->fs_info;struct btrfs_root *root = inode->root;
@@ -1306,6 +1308,13 @@ void btrfs_extent_item_to_extent_map(struct btrfs_inode *inode,set_bit (EXTENT_FLAG_PREALLOC , &em->flags); } em->encryption_type =btrfs_file_extent_encryption (leaf, fi); +if (em->encryption_type !=BTRFS_ENCRYPTION_NONE ) { + ctx->size = +btrfs_file_extent_encryption_ctx_size (leaf, fi); +read_extent_buffer (leaf, ctx->ctx, +btrfs_file_extent_encryption_ctx_offset (fi), + ctx->size); + } }else if (type ==BTRFS_FILE_EXTENT_INLINE ) { em->block_start =EXTENT_MAP_INLINE ; em->start = extent_start;
fs/btrfs/file-item.h +4 -1
@@ -5,6 +5,8 @@#include "accessors.h" +struct btrfs_fscrypt_ctx ; +#define BTRFS_FILE_EXTENT_INLINE_DATA_START \ (offsetof(struct btrfs_file_extent_item, disk_bytenr))
@@ -63,7 +65,8 @@ int btrfs_lookup_csums_bitmap(struct btrfs_root *root, struct btrfs_path *path,void btrfs_extent_item_to_extent_map (struct btrfs_inode *inode,const struct btrfs_path *path,struct btrfs_file_extent_item *fi, -struct extent_map *em); +struct extent_map *em, +struct btrfs_fscrypt_ctx *ctx);int btrfs_inode_clear_file_extent_range (struct btrfs_inode *inode,u64 start,u64 len);int btrfs_inode_set_file_extent_range (struct btrfs_inode *inode,u64 start,u64 len);
fs/btrfs/file.c +9 -0
@@ -38,6 +38,7 @@#include "ioctl.h" #include "file.h" #include "super.h" +#include "fscrypt.h" /* simple helper to fault in pages and copy. This should go away * and be replaced with calls into generic code.
@@ -2275,6 +2276,14 @@ static int btrfs_insert_replace_extent(struct btrfs_trans_handle *trans,btrfs_set_file_extent_num_bytes (leaf, extent, replace_len);if (extent_info->is_new_extent)btrfs_set_file_extent_generation (leaf, extent, trans->transid); +if (extent_info->fscrypt_info) { + ret =btrfs_fscrypt_save_extent_info (inode, path, + extent_info->fscrypt_info); +if (ret) { +btrfs_release_path (path); +return ret; + } + }btrfs_mark_buffer_dirty (trans, leaf);btrfs_release_path (path);
fs/btrfs/fscrypt.c +49 -0
56 lines not on this page · raw message
fs/btrfs/fscrypt.h +31 -0
@@ -8,6 +8,11 @@#include "fs.h" +struct btrfs_fscrypt_ctx { +u8 ctx[BTRFS_MAX_EXTENT_CTX_SIZE ]; +size_t size; +}; +#ifdef CONFIG_FS_ENCRYPTION int btrfs_fscrypt_get_disk_name(struct extent_buffer *leaf, struct btrfs_dir_item *di,
@@ -16,8 +21,29 @@ int btrfs_fscrypt_get_disk_name(struct extent_buffer *leaf,bool btrfs_fscrypt_match_name (struct fscrypt_name *fname,struct extent_buffer *leaf,unsigned long de_name,u32 de_name_len); +int btrfs_fscrypt_load_extent_info (struct btrfs_inode *inode, +struct extent_map *em, +struct btrfs_fscrypt_ctx *ctx); +int btrfs_fscrypt_save_extent_info (struct btrfs_inode *inode, +struct btrfs_path *path, +struct fscrypt_extent_info *fi); +size_t btrfs_fscrypt_extent_context_size (struct btrfs_inode *inode);#else +static inline int btrfs_fscrypt_save_extent_info (struct btrfs_inode *inode, +struct btrfs_path *path, +struct fscrypt_extent_info *fi) +{ +return 0 ; +} + +static inline int btrfs_fscrypt_load_extent_info (struct btrfs_inode *inode, +struct extent_map *em, +struct btrfs_fscrypt_ctx *ctx) +{ +return 0 ; +} +static inline int btrfs_fscrypt_get_disk_name (struct extent_buffer *leaf,struct btrfs_dir_item *di,struct fscrypt_str *qstr)
@@ -35,6 +61,11 @@ static inline bool btrfs_fscrypt_match_name(struct fscrypt_name *fname,return !memcmp_extent_buffer (leaf, fname->disk_name.name, de_name, de_name_len); } + +static inline size_t btrfs_fscrypt_extent_context_size (struct btrfs_inode *inode) +{ +return 0 ; +}#endif /* CONFIG_FS_ENCRYPTION */ extern const struct fscrypt_operations btrfs_fscrypt_ops;
fs/btrfs/inode.c +21 -1
@@ -2903,6 +2903,9 @@ static int insert_reserved_file_extent(struct btrfs_trans_handle *trans,size_t fscrypt_context_size =0 ;int ret; +if (btrfs_stack_file_extent_encryption (stack_fi)) + fscrypt_context_size =btrfs_fscrypt_extent_context_size (inode); + path =btrfs_alloc_path ();if (!path)return -ENOMEM ;
@@ -2941,6 +2944,12 @@ static int insert_reserved_file_extent(struct btrfs_trans_handle *trans,btrfs_item_ptr_offset (leaf, path->slots[0 ]), sizeof(struct btrfs_file_extent_item)); +if (fscrypt_context_size) { + ret =btrfs_fscrypt_save_extent_info (inode, path, fscrypt_info); +if (ret) + goto out; + } +btrfs_mark_buffer_dirty (trans, leaf);btrfs_release_path (path);
@@ -6865,6 +6874,7 @@ struct extent_map *btrfs_get_extent(struct btrfs_inode *inode,struct btrfs_key found_key;struct extent_map *em =NULL ;struct extent_map_tree *em_tree = &inode->extent_tree; +struct btrfs_fscrypt_ctx ctx;read_lock (&em_tree->lock); em =lookup_extent_mapping (em_tree, start, len);
@@ -6878,6 +6888,9 @@ struct extent_map *btrfs_get_extent(struct btrfs_inode *inode,else goto out; } + + ctx.size =0 ; + em =alloc_extent_map ();if (!em) { ret = -ENOMEM ;
@@ -6982,7 +6995,7 @@ struct extent_map *btrfs_get_extent(struct btrfs_inode *inode, goto insert; } -btrfs_extent_item_to_extent_map (inode, path, item, em); +btrfs_extent_item_to_extent_map (inode, path, item, em, &ctx);if (extent_type ==BTRFS_FILE_EXTENT_REG || extent_type ==BTRFS_FILE_EXTENT_PREALLOC ) {
@@ -7027,6 +7040,10 @@ struct extent_map *btrfs_get_extent(struct btrfs_inode *inode, goto out; } + ret =btrfs_fscrypt_load_extent_info (inode, em, &ctx); +if (ret) + goto out; +write_lock (&em_tree->lock); ret =btrfs_add_extent_mapping (fs_info, em_tree, &em, start, len);write_unlock (&em_tree->lock);
@@ -9703,6 +9720,9 @@ static struct btrfs_trans_handle *insert_prealloc_file_extent(return trans; } +if (fscrypt_info) + fscrypt_context_size =btrfs_fscrypt_extent_context_size (inode); + extent_info.disk_offset = start; extent_info.disk_len = len; extent_info.data_offset =0 ;
fs/btrfs/tree-log.c +10 -0
@@ -30,6 +30,7 @@#include "file.h" #include "orphan.h" #include "tree-checker.h" +#include "fscrypt.h" #define MAX_CONFLICT_INODES 10
@@ -4631,6 +4632,9 @@ static int log_one_extent(struct btrfs_trans_handle *trans,size_t fscrypt_context_size =0 ;u8 encryption = em->encryption_type; +if (encryption) + fscrypt_context_size =btrfs_fscrypt_extent_context_size (inode); +btrfs_set_stack_file_extent_generation (&fi, trans->transid);if (test_bit (EXTENT_FLAG_PREALLOC , &em->flags))btrfs_set_stack_file_extent_type (&fi,BTRFS_FILE_EXTENT_PREALLOC );
@@ -4691,6 +4695,12 @@ static int log_one_extent(struct btrfs_trans_handle *trans,write_extent_buffer (leaf, &fi,btrfs_item_ptr_offset (leaf, path->slots[0 ]),sizeof (fi)); +if (fscrypt_context_size) { + ret =btrfs_fscrypt_save_extent_info (inode, path, + em->fscrypt_info); +if (ret) +return ret; + }btrfs_mark_buffer_dirty (trans, leaf);btrfs_release_path (path);
Signature · 1 line
2.41.0
PATCH v3 29/34 btrfs: setup fscrypt_extent_info for new extents
In reply to Josef BacikNew extents for encrypted inodes must have a fscrypt_extent_info, which has the necessary keys and does all the registration at the block layer for them. This is passed through all of the infrastructure we've previously added to make sure the context gets saved properly with the file extents.
--- fs/btrfs/inode.c | 39 +++++++++++++++++++++++++++++++++++++-- 1 file changed, 37 insertions(+), 2 deletions(-)
fs/btrfs/inode.c +37 -2
@@ -7396,7 +7396,20 @@ static struct extent_map *create_io_em(struct btrfs_inode *inode, u64 start,set_bit (EXTENT_FLAG_COMPRESSED , &em->flags); em->compress_type = compress_type; } - em->encryption_type =BTRFS_ENCRYPTION_NONE ; + +if (IS_ENCRYPTED (&inode->vfs_inode)) { +struct fscrypt_extent_info *fscrypt_info; + + em->encryption_type =BTRFS_ENCRYPTION_FSCRYPT ; + fscrypt_info =fscrypt_prepare_new_extent (&inode->vfs_inode); +if (IS_ERR (fscrypt_info)) { +free_extent_map (em); +return ERR_CAST (fscrypt_info); + } + em->fscrypt_info = fscrypt_info; + }else { + em->encryption_type =BTRFS_ENCRYPTION_NONE ; + } ret =btrfs_replace_extent_map_range (inode, em, true);if (ret) {
@@ -9785,6 +9798,9 @@ static int __btrfs_prealloc_file_range(struct inode *inode, int mode,if (trans) own_trans = false;while (num_bytes >0 ) { +struct fscrypt_extent_info *fscrypt_info =NULL ; +int encryption_type =BTRFS_ENCRYPTION_NONE ; + cur_bytes =min_t (u64, num_bytes,SZ_256M ); cur_bytes =max (cur_bytes, min_size);/*
@@ -9799,6 +9815,20 @@ static int __btrfs_prealloc_file_range(struct inode *inode, int mode,if (ret)break ; +if (IS_ENCRYPTED (inode)) { + fscrypt_info =fscrypt_prepare_new_extent (inode); +if (IS_ERR (fscrypt_info)) { +btrfs_dec_block_group_reservations (fs_info, + ins.objectid); +btrfs_free_reserved_extent (fs_info, + ins.objectid, + ins.offset,0 ); + ret =PTR_ERR (fscrypt_info); +break ; + } + encryption_type =BTRFS_ENCRYPTION_FSCRYPT ; + } +/* * We've reserved this space, and thus converted it from * ->bytes_may_use to ->bytes_reserved. Any error that happens
@@ -9810,7 +9840,8 @@ static int __btrfs_prealloc_file_range(struct inode *inode, int mode, last_alloc = ins.offset; trans =insert_prealloc_file_extent (trans,BTRFS_I (inode), - &ins,NULL , cur_offset); + &ins, fscrypt_info, + cur_offset);/* * Now that we inserted the prealloc extent we can finally * decrement the number of reservations in the block group.
@@ -9820,6 +9851,7 @@ static int __btrfs_prealloc_file_range(struct inode *inode, int mode,btrfs_dec_block_group_reservations (fs_info, ins.objectid);if (IS_ERR (trans)) { ret =PTR_ERR (trans); +fscrypt_put_extent_info (fscrypt_info);btrfs_free_reserved_extent (fs_info, ins.objectid, ins.offset,0 );break ;
@@ -9827,6 +9859,7 @@ static int __btrfs_prealloc_file_range(struct inode *inode, int mode, em =alloc_extent_map ();if (!em) { +fscrypt_put_extent_info (fscrypt_info);btrfs_drop_extent_map_range (BTRFS_I (inode), cur_offset, cur_offset + ins.offset -1 , false);btrfs_set_inode_full_sync (BTRFS_I (inode));
@@ -9842,6 +9875,8 @@ static int __btrfs_prealloc_file_range(struct inode *inode, int mode, em->ram_bytes = ins.offset;set_bit (EXTENT_FLAG_PREALLOC , &em->flags); em->generation = trans->transid; + em->fscrypt_info = fscrypt_info; + em->encryption_type = encryption_type; ret =btrfs_replace_extent_map_range (BTRFS_I (inode), em, true);free_extent_map (em);
Signature · 1 line
2.41.0
PATCH v3 30/34 btrfs: populate ordered_extent with the orig offset
In reply to Josef BacikFor extent encryption we have to use a logical block nr as input for the IV. For btrfs we're using the offset into the extent we're operating on. For most ordered extents this is the same as the file_offset, however for prealloc and NOCOW we have to use the original offset.
Add this as an argument and plumb it through everywhere, this will be used when setting up the bio.
--- fs/btrfs/inode.c | 15 ++++++++++----- fs/btrfs/ordered-data.c | 22 ++++++++++++---------- fs/btrfs/ordered-data.h | 12 +++++++++--- 3 files changed, 31 insertions(+), 18 deletions(-)
fs/btrfs/inode.c +10 -5
@@ -1165,6 +1165,7 @@ static void submit_one_async_extent(struct async_chunk *async_chunk, ordered = btrfs_alloc_ordered_extent(inode, em->fscrypt_info, start, /* file_offset */ + start, /* orig_start */ async_extent->ram_size, /* num_bytes */ async_extent->ram_size, /* ram_bytes */ ins.objectid, /* disk_bytenr */
@@ -1428,8 +1429,8 @@ static noinline int cow_file_range(struct btrfs_inode *inode, } ordered =btrfs_alloc_ordered_extent (inode, em->fscrypt_info, - start, ram_size, ram_size, ins.objectid, - cur_alloc_size,0 , + start, start, ram_size, ram_size, + ins.objectid, cur_alloc_size,0 ,1 <<BTRFS_ORDERED_REGULAR ,BTRFS_COMPRESS_NONE );free_extent_map (em);
@@ -2178,7 +2179,9 @@ static noinline int run_delalloc_nocow(struct btrfs_inode *inode, } ordered =btrfs_alloc_ordered_extent (inode, fscrypt_info, - cur_offset, nocow_args.num_bytes, + cur_offset, + found_key.offset - nocow_args.extent_offset, + nocow_args.num_bytes, nocow_args.num_bytes, nocow_args.disk_bytenr, nocow_args.num_bytes,0 , is_prealloc
@@ -7087,8 +7090,9 @@ static struct extent_map *btrfs_create_dio_extent(struct btrfs_inode *inode, fscrypt_info = orig_em->fscrypt_info; } - ordered =btrfs_alloc_ordered_extent (inode, fscrypt_info, start, len, - len, block_start, block_len,0 , + ordered =btrfs_alloc_ordered_extent (inode, fscrypt_info, start, + orig_start, len, len, block_start, + block_len,0 , (1 << type) | (1 <<BTRFS_ORDERED_DIRECT ),BTRFS_COMPRESS_NONE );
@@ -10612,6 +10616,7 @@ ssize_t btrfs_do_encoded_write(struct kiocb *iocb, struct iov_iter *from, } ordered = btrfs_alloc_ordered_extent(inode, em->fscrypt_info, start, + start - encoded->unencoded_offset, num_bytes, ram_bytes, ins.objectid, ins.offset, encoded->unencoded_offset, (1 << BTRFS_ORDERED_ENCODED) |
fs/btrfs/ordered-data.c +12 -10
@@ -148,9 +148,9 @@ static inline struct rb_node *ordered_tree_search(struct btrfs_inode *inode,static struct btrfs_ordered_extent *alloc_ordered_extent (struct btrfs_inode *inode,struct fscrypt_extent_info *fscrypt_info, -u64 file_offset,u64 num_bytes,u64 ram_bytes, -u64 disk_bytenr,u64 disk_num_bytes,u64 offset, -unsigned long flags,int compress_type) +u64 file_offset,u64 orig_offset,u64 num_bytes, +u64 ram_bytes,u64 disk_bytenr,u64 disk_num_bytes, +u64 offset,unsigned long flags,int compress_type) {struct btrfs_ordered_extent *entry;int ret;
@@ -175,6 +175,7 @@ static struct btrfs_ordered_extent *alloc_ordered_extent(return ERR_PTR (-ENOMEM ); entry->file_offset = file_offset; + entry->orig_offset = orig_offset; entry->num_bytes = num_bytes; entry->ram_bytes = ram_bytes; entry->disk_bytenr = disk_bytenr;
@@ -253,6 +254,7 @@ static void insert_ordered_extent(struct btrfs_ordered_extent *entry)* @inode: Inode that this extent is for. * @fscrypt_info: The fscrypt_extent_info for this extent, if necessary. * @file_offset: Logical offset in file where the extent starts. +* @orig_offset: Logical offset of the original extent (PREALLOC or NOCOW) * @num_bytes: Logical length of extent in file. * @ram_bytes: Full length of unencoded data. * @disk_bytenr: Offset of extent on disk.
@@ -270,17 +272,17 @@ static void insert_ordered_extent(struct btrfs_ordered_extent *entry)struct btrfs_ordered_extent *btrfs_alloc_ordered_extent (struct btrfs_inode *inode,struct fscrypt_extent_info *fscrypt_info, -u64 file_offset,u64 num_bytes,u64 ram_bytes, -u64 disk_bytenr,u64 disk_num_bytes,u64 offset, -unsigned long flags,int compress_type) +u64 file_offset,u64 orig_offset,u64 num_bytes, +u64 ram_bytes,u64 disk_bytenr,u64 disk_num_bytes, +u64 offset,unsigned long flags,int compress_type) {struct btrfs_ordered_extent *entry;ASSERT ((flags & ~BTRFS_ORDERED_TYPE_FLAGS ) ==0 ); entry =alloc_ordered_extent (inode, fscrypt_info, file_offset, - num_bytes, ram_bytes, disk_bytenr, - disk_num_bytes, offset, flags, + orig_offset, num_bytes, ram_bytes, + disk_bytenr, disk_num_bytes, offset, flags, compress_type);if (!IS_ERR (entry))insert_ordered_extent (entry);
@@ -1174,8 +1176,8 @@ struct btrfs_ordered_extent *btrfs_split_ordered_extent(return ERR_PTR (-EINVAL ); new =alloc_ordered_extent (inode, ordered->fscrypt_info, file_offset, - len, len, disk_bytenr, len,0 , flags, - ordered->compress_type); + ordered->orig_offset, len, len, disk_bytenr, + len,0 , flags, ordered->compress_type);if (IS_ERR (new))return new;
fs/btrfs/ordered-data.h +9 -3
@@ -83,6 +83,12 @@ struct btrfs_ordered_extent {/* logical offset in the file */ u64 file_offset; +/* +* The original logical offset of the extent, this is for NOCOW and +* PREALLOC extents, otherwise it'll be the same as file_offset. +*/ +u64 orig_offset; +/* * These fields directly correspond to the same fields in * btrfs_file_extent_item.
@@ -172,9 +178,9 @@ bool btrfs_dec_test_ordered_pending(struct btrfs_inode *inode,struct btrfs_ordered_extent *btrfs_alloc_ordered_extent (struct btrfs_inode *inode,struct fscrypt_extent_info *fscrypt_info, -u64 file_offset,u64 num_bytes,u64 ram_bytes, -u64 disk_bytenr,u64 disk_num_bytes,u64 offset, -unsigned long flags,int compress_type); +u64 file_offset,u64 orig_offset,u64 num_bytes, +u64 ram_bytes,u64 disk_bytenr,u64 disk_num_bytes, +u64 offset,unsigned long flags,int compress_type);void btrfs_add_ordered_sum (struct btrfs_ordered_extent *entry,struct btrfs_ordered_sum *sum); struct btrfs_ordered_extent *btrfs_lookup_ordered_extent(struct btrfs_inode *inode,
Signature · 1 line
2.41.0
PATCH v3 31/34 btrfs: set the bio fscrypt context when applicable
In reply to Josef BacikNow that we have the fscrypt_info plumbed through everywhere, add the code to setup the bio encryption context from the extent context.
We use the per-extent fscrypt_extent_info for encryption/decryption. We use the offset into the extent as the lblk for fscrypt. So the start of the extent has the lblk of 0, 4k into the extent has the lblk of 4k, etc. This is done to allow things like relocation to continue to work properly.
--- fs/btrfs/compression.c | 6 ++++ fs/btrfs/extent_io.c | 63 +++++++++++++++++++++++++++++++++++++++++- fs/btrfs/fscrypt.c | 36 ++++++++++++++++++++++++ fs/btrfs/fscrypt.h | 22 +++++++++++++++ fs/btrfs/inode.c | 10 +++++++ 5 files changed, 136 insertions(+), 1 deletion(-)
fs/btrfs/compression.c +6 -0
@@ -36,6 +36,7 @@#include "zoned.h" #include "file-item.h" #include "super.h" +#include "fscrypt.h" static struct bio_set btrfs_compressed_bioset;
@@ -301,6 +302,9 @@ void btrfs_submit_compressed_write(struct btrfs_ordered_extent *ordered, cb->bbio.ordered = ordered;btrfs_add_compressed_bio_pages (cb); +btrfs_set_bio_crypt_ctx_from_extent (&cb->bbio.bio, inode, + ordered->fscrypt_info,0 ); +btrfs_submit_bio (&cb->bbio,0 ); }
@@ -504,6 +508,8 @@ void btrfs_submit_compressed_read(struct btrfs_bio *bbio) cb->compress_type = em->compress_type; cb->orig_bbio = bbio; +btrfs_set_bio_crypt_ctx_from_extent (&cb->bbio.bio, inode, + em->fscrypt_info,0 );free_extent_map (em); cb->nr_pages =DIV_ROUND_UP (compressed_len,PAGE_SIZE );
fs/btrfs/extent_io.c +62 -1
133 lines not on this page · raw message
fs/btrfs/fscrypt.c +36 -0
@@ -262,6 +262,42 @@ size_t btrfs_fscrypt_extent_context_size(struct btrfs_inode *inode)fscrypt_extent_context_size (&inode->vfs_inode); } +void btrfs_set_bio_crypt_ctx_from_extent (struct bio *bio, +struct btrfs_inode *inode, +struct fscrypt_extent_info *fi, +u64 logical_offset) +{ +if (!fi) +return ; + +/* +* fscrypt uses bytes >> s_blocksize_bits for the block numbers, so we +* have to adjust everything based on our sectorsize so that the DUN +* calculations are correct. +*/ + logical_offset =div64_u64 (logical_offset, + inode->root->fs_info->sectorsize); +fscrypt_set_bio_crypt_ctx_from_extent (bio, &inode->vfs_inode, fi, + logical_offset,GFP_NOFS ); +} + +bool btrfs_mergeable_encrypted_bio (struct bio *bio,struct inode *inode, +struct fscrypt_extent_info *fi, +u64 logical_offset) +{ +if (!fi) +return true; + +/* +* fscrypt uses bytes >> s_blocksize_bits for the block numbers, so we +* have to adjust everything based on our sectorsize so that the DUN +* calculations are correct. +*/ + logical_offset =div64_u64 (logical_offset, +BTRFS_I (inode)->root->fs_info->sectorsize); +return fscrypt_mergeable_extent_bio (bio, inode, fi, logical_offset); +} +const struct fscrypt_operations btrfs_fscrypt_ops = { .has_per_extent_encryption =1 , .get_context = btrfs_fscrypt_get_context,
fs/btrfs/fscrypt.h +22 -0
@@ -28,6 +28,13 @@ int btrfs_fscrypt_save_extent_info(struct btrfs_inode *inode,struct btrfs_path *path, struct fscrypt_extent_info *fi);size_t btrfs_fscrypt_extent_context_size (struct btrfs_inode *inode); +void btrfs_set_bio_crypt_ctx_from_extent (struct bio *bio, +struct btrfs_inode *inode, +struct fscrypt_extent_info *fi, +u64 logical_offset); +bool btrfs_mergeable_encrypted_bio (struct bio *bio,struct inode *inode, +struct fscrypt_extent_info *fi, +u64 logical_offset);#else static inline int btrfs_fscrypt_save_extent_info(struct btrfs_inode *inode,
@@ -66,6 +73,21 @@ static inline size_t btrfs_fscrypt_extent_context_size(struct btrfs_inode *inode {return 0 ; } + +static inline void btrfs_set_bio_crypt_ctx_from_extent (struct bio *bio, +struct btrfs_inode *inode, +struct fscrypt_extent_info *fi, +u64 logical_offset) +{ +} + +static inline bool btrfs_mergeable_encrypted_bio (struct bio *bio, +struct inode *inode, +struct fscrypt_extent_info *fi, +u64 logical_offset) +{ +return true; +}#endif /* CONFIG_FS_ENCRYPTION */ extern const struct fscrypt_operations btrfs_fscrypt_ops;
fs/btrfs/inode.c +10 -0
@@ -7895,6 +7895,8 @@ static void btrfs_dio_submit_io(const struct iomap_iter *iter, struct bio *bio,struct btrfs_dio_private *dip = container_of(bbio, struct btrfs_dio_private, bbio);struct btrfs_dio_data *dio_data = iter->private; +struct fscrypt_extent_info *fscrypt_info =NULL ; +u64 offset =0 ;btrfs_bio_init (bbio,BTRFS_I (iter->inode)->root->fs_info, btrfs_dio_end_io, bio->bi_private);
@@ -7916,6 +7918,9 @@ static void btrfs_dio_submit_io(const struct iomap_iter *iter, struct bio *bio,if (iter->flags &IOMAP_WRITE ) {int ret; + offset = file_offset - dio_data->ordered->orig_offset; + fscrypt_info = dio_data->ordered->fscrypt_info; + ret =btrfs_extract_ordered_extent (bbio, dio_data->ordered);if (ret) { btrfs_finish_ordered_extent(dio_data->ordered, NULL,
@@ -7925,8 +7930,13 @@ static void btrfs_dio_submit_io(const struct iomap_iter *iter, struct bio *bio,iomap_dio_bio_end_io (bio);return ; } + }else { + fscrypt_info = dio_data->fscrypt_info; + offset = file_offset - dio_data->orig_start; } +btrfs_set_bio_crypt_ctx_from_extent (&bbio->bio, bbio->inode, + fscrypt_info, offset);btrfs_submit_bio (bbio,0 ); }
Signature · 1 line
2.41.0
PATCH v3 32/34 btrfs: add a bio argument to btrfs_csum_one_bio
In reply to Josef BacikWe only ever needed the bbio in btrfs_csum_one_bio, since that has the bio embedded in it. However with encryption we'll have a different bio with the encrypted data in it, and the original bbio. Update btrfs_csum_one_bio to take the bio we're going to csum as an argument, which will allow us to csum the encrypted bio and stuff the csums into the corresponding bbio to be used later when the IO completes.
--- fs/btrfs/bio.c | 2 +- fs/btrfs/file-item.c | 3 +-- fs/btrfs/file-item.h | 2 +- 3 files changed, 3 insertions(+), 4 deletions(-)
fs/btrfs/bio.c +1 -1
@@ -533,7 +533,7 @@ static blk_status_t btrfs_bio_csum(struct btrfs_bio *bbio) {if (bbio->bio.bi_opf &REQ_META )return btree_csum_one_bio (bbio); -return btrfs_csum_one_bio (bbio); +return btrfs_csum_one_bio (bbio, &bbio->bio); }/*
fs/btrfs/file-item.c +1 -2
@@ -730,13 +730,12 @@ int btrfs_lookup_csums_bitmap(struct btrfs_root *root, struct btrfs_path *path,/* * Calculate checksums of the data contained inside a bio. */ -blk_status_t btrfs_csum_one_bio (struct btrfs_bio *bbio) +blk_status_t btrfs_csum_one_bio (struct btrfs_bio *bbio,struct bio *bio) {struct btrfs_ordered_extent *ordered = bbio->ordered;struct btrfs_inode *inode = bbio->inode;struct btrfs_fs_info *fs_info = inode->root->fs_info;SHASH_DESC_ON_STACK (shash, fs_info->csum_shash); -struct bio *bio = &bbio->bio;struct btrfs_ordered_sum *sums;char *data;struct bvec_iter iter;
fs/btrfs/file-item.h +1 -1
@@ -51,7 +51,7 @@ int btrfs_lookup_file_extent(struct btrfs_trans_handle *trans,int btrfs_csum_file_blocks (struct btrfs_trans_handle *trans,struct btrfs_root *root,struct btrfs_ordered_sum *sums); -blk_status_t btrfs_csum_one_bio (struct btrfs_bio *bbio); +blk_status_t btrfs_csum_one_bio (struct btrfs_bio *bbio,struct bio *bio);blk_status_t btrfs_alloc_dummy_sum (struct btrfs_bio *bbio); int btrfs_lookup_csums_range(struct btrfs_root *root, u64 start, u64 end, struct list_head *list, int search_commit,
Signature · 1 line
2.41.0
PATCH v3 33/34 btrfs: add orig_logical to btrfs_bio
In reply to Josef BacikWhen checksumming the encrypted bio on writes we need to know which logical address this checksum is for. At the point where we get the encrypted bio the bi_sector is the physical location on the target disk, so we need to save the original logical offset in the btrfs_bio. Then we can use this when csum'ing the bio instead of the bio->iter.bi_sector.
--- fs/btrfs/bio.c | 10 ++++++++++ fs/btrfs/bio.h | 3 +++ fs/btrfs/file-item.c | 2 +- 3 files changed, 14 insertions(+), 1 deletion(-)
fs/btrfs/bio.c +10 -0
@@ -96,6 +96,8 @@ static struct btrfs_bio *btrfs_split_bio(struct btrfs_fs_info *fs_info,if (bbio_has_ordered_extent (bbio)) {refcount_inc (&orig_bbio->ordered->refs); bbio->ordered = orig_bbio->ordered; + bbio->orig_logical = orig_bbio->orig_logical; + orig_bbio->orig_logical += map_length; }atomic_inc (&orig_bbio->pending_ios);return bbio;
@@ -674,6 +676,14 @@ static bool btrfs_submit_chunk(struct btrfs_bio *bbio, int mirror_num) goto fail; } +/* +* For fscrypt writes we will get the encrypted bio after we've remapped +* our bio to the physical disk location, so we need to save the +* original bytenr so we know what we're checksumming. +*/ +if (bio_op (bio) ==REQ_OP_WRITE &&is_data_bbio (bbio)) + bbio->orig_logical = logical; + map_length =min (map_length, length);if (use_append) map_length =min (map_length, fs_info->max_zone_append_size);
fs/btrfs/bio.h +3 -0
@@ -54,11 +54,14 @@ struct btrfs_bio {* - pointer to the checksums for this bio * - original physical address from the allocator * (for zone append only) +* - original logical address, used for checksumming fscrypt +* bios. */ struct {struct btrfs_ordered_extent *ordered;struct btrfs_ordered_sum *sums;u64 orig_physical; +u64 orig_logical; };/* For metadata reads: parentness verification. */
fs/btrfs/file-item.c +1 -1
@@ -756,7 +756,7 @@ blk_status_t btrfs_csum_one_bio(struct btrfs_bio *bbio, struct bio *bio) sums->len = bio->bi_iter.bi_size;INIT_LIST_HEAD (&sums->list); - sums->logical = bio->bi_iter.bi_sector <<SECTOR_SHIFT ; + sums->logical = bbio->orig_logical; index =0 ; shash->tfm = fs_info->csum_shash;
Signature · 1 line
2.41.0
PATCH v3 34/34 btrfs: implement process_bio cb for fscrypt
In reply to Josef BacikWe are going to be checksumming the encrypted data, so we have to implement the ->process_bio fscrypt callback. This will provide us with the original bio and the encrypted bio to do work on. For WRITE's this will happen after the encrypted bio has been encrypted. For READ's this will happen after the read has completed and before the decryption step is done.
For write's this is straightforward, we can just pass in the encrypted bio to btrfs_csum_one_bio and then the csums will be added to the bbio as normal.
For read's this is relatively straightforward, but requires some care. We assume (because that's how it works currently) that the encrypted bio match the original bio, this is important because we save the iter of the bio before we submit. If this changes in the future we'll need a hook to give us the bi_iter of the decryption bio before it's submitted. We check the csums before decryption. If it doesn't match we simply error out and we let the normal path handle the repair work.
--- fs/btrfs/bio.c | 34 +++++++++++++++++++++++++++++++++- fs/btrfs/bio.h | 3 +++ fs/btrfs/fscrypt.c | 19 +++++++++++++++++++ 3 files changed, 55 insertions(+), 1 deletion(-)
fs/btrfs/bio.c +33 -1
@@ -281,6 +281,34 @@ static struct btrfs_failed_bio *repair_one_sector(struct btrfs_bio *failed_bbio,return fbio; } +blk_status_t btrfs_check_encrypted_read_bio (struct btrfs_bio *bbio, +struct bio *enc_bio) +{ +struct btrfs_inode *inode = bbio->inode; +struct btrfs_fs_info *fs_info = inode->root->fs_info; +u32 sectorsize = fs_info->sectorsize; +struct bvec_iter iter = bbio->saved_iter; +struct btrfs_device *dev = bbio->bio.bi_private; +u32 offset =0 ; + +/* +* We have to use a copy of iter in case there's an error, +* btrfs_check_read_bio will handle submitting the repair bios. +*/ +while (iter.bi_size) { +struct bio_vec bv =bio_iter_iovec (enc_bio, iter); + + bv.bv_len =min (bv.bv_len, sectorsize); +if (!btrfs_data_csum_ok (bbio, dev, offset, &bv)) +return BLK_STS_IOERR ; +bio_advance_iter_single (enc_bio, &iter, sectorsize); + offset += sectorsize; + } + + bbio->csum_done = true; +return BLK_STS_OK ; +} +static void btrfs_check_read_bio (struct btrfs_bio *bbio,struct btrfs_device *dev) {struct btrfs_inode *inode = bbio->inode;
@@ -306,6 +334,10 @@ static void btrfs_check_read_bio(struct btrfs_bio *bbio, struct btrfs_device *de/* Clear the I/O error. A failed repair will reset it. */ bbio->bio.bi_status =BLK_STS_OK ; +/* This was an encrypted bio and we've already done the csum check. */ +if (status ==BLK_STS_OK && bbio->csum_done) + goto out; +while (iter->bi_size) {struct bio_vec bv =bio_iter_iovec (&bbio->bio, *iter);
@@ -316,7 +348,7 @@ static void btrfs_check_read_bio(struct btrfs_bio *bbio, struct btrfs_device *debio_advance_iter_single (&bbio->bio, iter, sectorsize); offset += sectorsize; } - +out:if (bbio->csum != bbio->csum_inline)kfree (bbio->csum);
fs/btrfs/bio.h +3 -0
@@ -45,6 +45,7 @@ struct btrfs_bio {struct {u8 *csum;u8 csum_inline[BTRFS_BIO_INLINE_CSUM_SIZE ]; +bool csum_done;struct bvec_iter saved_iter; };
@@ -110,5 +111,7 @@ void btrfs_submit_repair_write(struct btrfs_bio *bbio, int mirror_num, bool dev_int btrfs_repair_io_failure (struct btrfs_fs_info *fs_info,u64 ino,u64 start,u64 length,u64 logical,struct page *page,unsigned int pg_offset,int mirror_num); +blk_status_t btrfs_check_encrypted_read_bio (struct btrfs_bio *bbio, +struct bio *enc_bio);#endif
fs/btrfs/fscrypt.c +19 -0
@@ -15,6 +15,7 @@#include "transaction.h" #include "volumes.h" #include "xattr.h" +#include "file-item.h" /* * From a given location in a leaf, read a name into a qstr (usually a
@@ -214,6 +215,23 @@ static struct block_device **btrfs_fscrypt_get_devices(struct super_block *sb,return devs; } +static blk_status_t btrfs_process_encrypted_bio (struct bio *orig_bio, +struct bio *enc_bio) +{ +struct btrfs_bio *bbio =btrfs_bio (orig_bio); + +if (bio_op (orig_bio) ==REQ_OP_READ ) { +/* +* We have ->saved_iter based on the orig_bio, so if the block +* layer changes we need to notice this asap so we can update +* our code to handle the new world order. +*/ +ASSERT (orig_bio == enc_bio); +return btrfs_check_encrypted_read_bio (bbio, enc_bio); + } +return btrfs_csum_one_bio (bbio, enc_bio); +} +int btrfs_fscrypt_load_extent_info (struct btrfs_inode *inode,struct extent_map *em,struct btrfs_fscrypt_ctx *ctx)
@@ -304,4 +322,5 @@ const struct fscrypt_operations btrfs_fscrypt_ops = { .set_context = btrfs_fscrypt_set_context, .empty_dir = btrfs_fscrypt_empty_dir, .get_devices = btrfs_fscrypt_get_devices, + .process_bio = btrfs_process_encrypted_bio, };
Signature · 1 line
2.41.0