Merge tag 'fscrypt-for-linus' of git://git.kernel.org/pub/scm/fs/fscrypt/fscrypt

  may be used to overwrite the source files but isn't guaranteed to be

  effective on all filesystems and storage devices.

- Direct I/O is not supported on encrypted files.  Attempts to use

  direct I/O on such files will fall back to buffered I/O.

- Direct I/O is supported on encrypted files only under some

  circumstances.  For details, see `Direct I/O support`_.

- The fallocate operations FALLOC_FL_COLLAPSE_RANGE and

  FALLOC_FL_INSERT_RANGE are not supported on encrypted files and will

the on-disk format, so users may freely switch back and forth between

using "inlinecrypt" and not using "inlinecrypt".

Direct I/O support

==================

For direct I/O on an encrypted file to work, the following conditions

must be met (in addition to the conditions for direct I/O on an

unencrypted file):

* The file must be using inline encryption.  Usually this means that

  the filesystem must be mounted with ``-o inlinecrypt`` and inline

  encryption hardware must be present.  However, a software fallback

  is also available.  For details, see `Inline encryption support`_.

* The I/O request must be fully aligned to the filesystem block size.

  This means that the file position the I/O is targeting, the lengths

  of all I/O segments, and the memory addresses of all I/O buffers

  must be multiples of this value.  Note that the filesystem block

  size may be greater than the logical block size of the block device.

If either of the above conditions is not met, then direct I/O on the

encrypted file will fall back to buffered I/O.

Implementation details

======================

}

EXPORT_SYMBOL(fscrypt_free_bounce_page);

/*

 * Generate the IV for the given logical block number within the given file.

 * For filenames encryption, lblk_num == 0.

 *

 * Keep this in sync with fscrypt_limit_io_blocks().  fscrypt_limit_io_blocks()

 * needs to know about any IV generation methods where the low bits of IV don't

 * simply contain the lblk_num (e.g., IV_INO_LBLK_32).

 */

void fscrypt_generate_iv(union fscrypt_iv *iv, u64 lblk_num,

			 const struct fscrypt_info *ci)

{

#include <linux/buffer_head.h>

#include <linux/sched/mm.h>

#include <linux/slab.h>

#include <linux/uio.h>

#include "fscrypt_private.h"

 *

 * fscrypt_set_bio_crypt_ctx() must have already been called on the bio.

 *

 * This function isn't required in cases where crypto-mergeability is ensured in

 * another way, such as I/O targeting only a single file (and thus a single key)

 * combined with fscrypt_limit_io_blocks() to ensure DUN contiguity.

 *

 * Return: true iff the I/O is mergeable

 */

bool fscrypt_mergeable_bio(struct bio *bio, const struct inode *inode,

	return fscrypt_mergeable_bio(bio, inode, next_lblk);

}

EXPORT_SYMBOL_GPL(fscrypt_mergeable_bio_bh);

/**

 * fscrypt_dio_supported() - check whether a DIO (direct I/O) request is

 *			     supported as far as encryption is concerned

 * @iocb: the file and position the I/O is targeting

 * @iter: the I/O data segment(s)

 *

 * Return: %true if there are no encryption constraints that prevent DIO from

 *	   being supported; %false if DIO is unsupported.  (Note that in the

 *	   %true case, the filesystem might have other, non-encryption-related

 *	   constraints that prevent DIO from actually being supported.)

 */

bool fscrypt_dio_supported(struct kiocb *iocb, struct iov_iter *iter)

{

	const struct inode *inode = file_inode(iocb->ki_filp);

	const unsigned int blocksize = i_blocksize(inode);

	/* If the file is unencrypted, no veto from us. */

	if (!fscrypt_needs_contents_encryption(inode))

		return true;

	/* We only support DIO with inline crypto, not fs-layer crypto. */

	if (!fscrypt_inode_uses_inline_crypto(inode))

		return false;

	/*

	 * Since the granularity of encryption is filesystem blocks, the file

	 * position and total I/O length must be aligned to the filesystem block

	 * size -- not just to the block device's logical block size as is

	 * traditionally the case for DIO on many filesystems.

	 *

	 * We require that the user-provided memory buffers be filesystem block

	 * aligned too.  It is simpler to have a single alignment value required

	 * for all properties of the I/O, as is normally the case for DIO.

	 * Also, allowing less aligned buffers would imply that data units could

	 * cross bvecs, which would greatly complicate the I/O stack, which

	 * assumes that bios can be split at any bvec boundary.

	 */

	if (!IS_ALIGNED(iocb->ki_pos | iov_iter_alignment(iter), blocksize))

		return false;

	return true;

}

EXPORT_SYMBOL_GPL(fscrypt_dio_supported);

/**

 * fscrypt_limit_io_blocks() - limit I/O blocks to avoid discontiguous DUNs

 * @inode: the file on which I/O is being done

 * @lblk: the block at which the I/O is being started from

 * @nr_blocks: the number of blocks we want to submit starting at @lblk

 *

 * Determine the limit to the number of blocks that can be submitted in a bio

 * targeting @lblk without causing a data unit number (DUN) discontiguity.

 *

 * This is normally just @nr_blocks, as normally the DUNs just increment along

 * with the logical blocks.  (Or the file is not encrypted.)

 *

 * In rare cases, fscrypt can be using an IV generation method that allows the

 * DUN to wrap around within logically contiguous blocks, and that wraparound

 * will occur.  If this happens, a value less than @nr_blocks will be returned

 * so that the wraparound doesn't occur in the middle of a bio, which would

 * cause encryption/decryption to produce wrong results.

 *

 * Return: the actual number of blocks that can be submitted

 */

u64 fscrypt_limit_io_blocks(const struct inode *inode, u64 lblk, u64 nr_blocks)

{

	const struct fscrypt_info *ci;

	u32 dun;

	if (!fscrypt_inode_uses_inline_crypto(inode))

		return nr_blocks;

	if (nr_blocks <= 1)

		return nr_blocks;

	ci = inode->i_crypt_info;

	if (!(fscrypt_policy_flags(&ci->ci_policy) &

	      FSCRYPT_POLICY_FLAG_IV_INO_LBLK_32))

		return nr_blocks;

	/* With IV_INO_LBLK_32, the DUN can wrap around from U32_MAX to 0. */

	dun = ci->ci_hashed_ino + lblk;

	return min_t(u64, nr_blocks, (u64)U32_MAX + 1 - dun);

}

EXPORT_SYMBOL_GPL(fscrypt_limit_io_blocks);

#include "acl.h"

#include "truncate.h"

static bool ext4_dio_supported(struct inode *inode)

static bool ext4_dio_supported(struct kiocb *iocb, struct iov_iter *iter)

{

	if (IS_ENABLED(CONFIG_FS_ENCRYPTION) && IS_ENCRYPTED(inode))

	struct inode *inode = file_inode(iocb->ki_filp);

	if (!fscrypt_dio_supported(iocb, iter))

		return false;

	if (fsverity_active(inode))

		return false;

		inode_lock_shared(inode);

	}

	if (!ext4_dio_supported(inode)) {

	if (!ext4_dio_supported(iocb, to)) {

		inode_unlock_shared(inode);

		/*

		 * Fallback to buffered I/O if the operation being performed on

	}

	/* Fallback to buffered I/O if the inode does not support direct I/O. */

	if (!ext4_dio_supported(inode)) {

	if (!ext4_dio_supported(iocb, from)) {

		if (ilock_shared)

			inode_unlock_shared(inode);

		else

	if (ret < 0)

		return ret;

out:

	/*

	 * When inline encryption is enabled, sometimes I/O to an encrypted file

	 * has to be broken up to guarantee DUN contiguity.  Handle this by

	 * limiting the length of the mapping returned.

	 */

	map.m_len = fscrypt_limit_io_blocks(inode, map.m_lblk, map.m_len);

	ext4_set_iomap(inode, iomap, &map, offset, length, flags);

	return 0;