Commit ad0d9da1 authored by Linus Torvalds's avatar Linus Torvalds
Browse files

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

Pull fsverity updates from Eric Biggers:
 "The main change this cycle is to stop using the PG_error flag to track
  verity failures, and instead just track failures at the bio level.
  This follows a similar fscrypt change that went into 6.1, and it is a
  step towards freeing up PG_error for other uses.

  There's also one other small cleanup"

* tag 'fsverity-for-linus' of git://git.kernel.org/pub/scm/fs/fscrypt/fscrypt:
  fsverity: simplify fsverity_get_digest()
  fsverity: stop using PG_error to track error status
parents 8129bac6 a4bbf53d

fs/ext4/readpage.c

+2 −6
Original line number Diff line number Diff line
@@ -75,14 +75,10 @@ static void __read_end_io(struct bio *bio) 
	bio_for_each_segment_all(bv, bio, iter_all) {

		page = bv->bv_page;



		/* PG_error was set if verity failed. */

		if (bio->bi_status || PageError(page)) {

		if (bio->bi_status)

			ClearPageUptodate(page);

			/* will re-read again later */

			ClearPageError(page);

		} else {

		else

			SetPageUptodate(page);

		}

		unlock_page(page);

	}

	if (bio->bi_private)

fs/f2fs/compress.c

+31 −33
Original line number Diff line number Diff line
@@ -1711,50 +1711,27 @@ static void f2fs_put_dic(struct decompress_io_ctx *dic, bool in_task) 
	}

}



/*

 * Update and unlock the cluster's pagecache pages, and release the reference to

 * the decompress_io_ctx that was being held for I/O completion.

 */

static void __f2fs_decompress_end_io(struct decompress_io_ctx *dic, bool failed,

				bool in_task)

static void f2fs_verify_cluster(struct work_struct *work)

{

	struct decompress_io_ctx *dic =

		container_of(work, struct decompress_io_ctx, verity_work);

	int i;



	/* Verify, update, and unlock the decompressed pages. */

	for (i = 0; i < dic->cluster_size; i++) {

		struct page *rpage = dic->rpages[i];



		if (!rpage)

			continue;



		/* PG_error was set if verity failed. */

		if (failed || PageError(rpage)) {

			ClearPageUptodate(rpage);

			/* will re-read again later */

			ClearPageError(rpage);

		} else {

		if (fsverity_verify_page(rpage))

			SetPageUptodate(rpage);

		}

		else

			ClearPageUptodate(rpage);

		unlock_page(rpage);

	}



	f2fs_put_dic(dic, in_task);

}



static void f2fs_verify_cluster(struct work_struct *work)

{

	struct decompress_io_ctx *dic =

		container_of(work, struct decompress_io_ctx, verity_work);

	int i;



	/* Verify the cluster's decompressed pages with fs-verity. */

	for (i = 0; i < dic->cluster_size; i++) {

		struct page *rpage = dic->rpages[i];



		if (rpage && !fsverity_verify_page(rpage))

			SetPageError(rpage);

	}



	__f2fs_decompress_end_io(dic, false, true);

	f2fs_put_dic(dic, true);

}



/*
@@ -1764,6 +1741,8 @@ static void f2fs_verify_cluster(struct work_struct *work) 
void f2fs_decompress_end_io(struct decompress_io_ctx *dic, bool failed,

				bool in_task)

{

	int i;



	if (!failed && dic->need_verity) {

		/*

		 * Note that to avoid deadlocks, the verity work can't be done
@@ -1773,9 +1752,28 @@ void f2fs_decompress_end_io(struct decompress_io_ctx *dic, bool failed, 
		 */

		INIT_WORK(&dic->verity_work, f2fs_verify_cluster);

		fsverity_enqueue_verify_work(&dic->verity_work);

	} else {

		__f2fs_decompress_end_io(dic, failed, in_task);

		return;

	}



	/* Update and unlock the cluster's pagecache pages. */

	for (i = 0; i < dic->cluster_size; i++) {

		struct page *rpage = dic->rpages[i];



		if (!rpage)

			continue;



		if (failed)

			ClearPageUptodate(rpage);

		else

			SetPageUptodate(rpage);

		unlock_page(rpage);

	}



	/*

	 * Release the reference to the decompress_io_ctx that was being held

	 * for I/O completion.

	 */

	f2fs_put_dic(dic, in_task);

}



/*

fs/f2fs/data.c

+33 −20
Original line number Diff line number Diff line
@@ -116,43 +116,56 @@ struct bio_post_read_ctx { 
	struct f2fs_sb_info *sbi;

	struct work_struct work;

	unsigned int enabled_steps;

	/*

	 * decompression_attempted keeps track of whether

	 * f2fs_end_read_compressed_page() has been called on the pages in the

	 * bio that belong to a compressed cluster yet.

	 */

	bool decompression_attempted;

	block_t fs_blkaddr;

};



/*

 * Update and unlock a bio's pages, and free the bio.

 *

 * This marks pages up-to-date only if there was no error in the bio (I/O error,

 * decryption error, or verity error), as indicated by bio->bi_status.

 *

 * "Compressed pages" (pagecache pages backed by a compressed cluster on-disk)

 * aren't marked up-to-date here, as decompression is done on a per-compression-

 * cluster basis rather than a per-bio basis.  Instead, we only must do two

 * things for each compressed page here: call f2fs_end_read_compressed_page()

 * with failed=true if an error occurred before it would have normally gotten

 * called (i.e., I/O error or decryption error, but *not* verity error), and

 * release the bio's reference to the decompress_io_ctx of the page's cluster.

 */

static void f2fs_finish_read_bio(struct bio *bio, bool in_task)

{

	struct bio_vec *bv;

	struct bvec_iter_all iter_all;

	struct bio_post_read_ctx *ctx = bio->bi_private;



	/*

	 * Update and unlock the bio's pagecache pages, and put the

	 * decompression context for any compressed pages.

	 */

	bio_for_each_segment_all(bv, bio, iter_all) {

		struct page *page = bv->bv_page;



		if (f2fs_is_compressed_page(page)) {

			if (bio->bi_status)

			if (ctx && !ctx->decompression_attempted)

				f2fs_end_read_compressed_page(page, true, 0,

							in_task);

			f2fs_put_page_dic(page, in_task);

			continue;

		}



		/* PG_error was set if verity failed. */

		if (bio->bi_status || PageError(page)) {

		if (bio->bi_status)

			ClearPageUptodate(page);

			/* will re-read again later */

			ClearPageError(page);

		} else {

		else

			SetPageUptodate(page);

		}

		dec_page_count(F2FS_P_SB(page), __read_io_type(page));

		unlock_page(page);

	}



	if (bio->bi_private)

		mempool_free(bio->bi_private, bio_post_read_ctx_pool);

	if (ctx)

		mempool_free(ctx, bio_post_read_ctx_pool);

	bio_put(bio);

}
@@ -185,8 +198,10 @@ static void f2fs_verify_bio(struct work_struct *work) 
			struct page *page = bv->bv_page;



			if (!f2fs_is_compressed_page(page) &&

			    !fsverity_verify_page(page))

				SetPageError(page);

			    !fsverity_verify_page(page)) {

				bio->bi_status = BLK_STS_IOERR;

				break;

			}

		}

	} else {

		fsverity_verify_bio(bio);
@@ -245,6 +260,8 @@ static void f2fs_handle_step_decompress(struct bio_post_read_ctx *ctx, 
		blkaddr++;

	}



	ctx->decompression_attempted = true;



	/*

	 * Optimization: if all the bio's pages are compressed, then scheduling

	 * the per-bio verity work is unnecessary, as verity will be fully
@@ -1062,6 +1079,7 @@ static struct bio *f2fs_grab_read_bio(struct inode *inode, block_t blkaddr, 
		ctx->sbi = sbi;

		ctx->enabled_steps = post_read_steps;

		ctx->fs_blkaddr = blkaddr;

		ctx->decompression_attempted = false;

		bio->bi_private = ctx;

	}

	iostat_alloc_and_bind_ctx(sbi, bio, ctx);
@@ -1089,7 +1107,6 @@ static int f2fs_submit_page_read(struct inode *inode, struct page *page, 
		bio_put(bio);

		return -EFAULT;

	}

	ClearPageError(page);

	inc_page_count(sbi, F2FS_RD_DATA);

	f2fs_update_iostat(sbi, NULL, FS_DATA_READ_IO, F2FS_BLKSIZE);

	__submit_bio(sbi, bio, DATA);
@@ -2141,7 +2158,6 @@ static int f2fs_read_single_page(struct inode *inode, struct page *page, 
	inc_page_count(F2FS_I_SB(inode), F2FS_RD_DATA);

	f2fs_update_iostat(F2FS_I_SB(inode), NULL, FS_DATA_READ_IO,

							F2FS_BLKSIZE);

	ClearPageError(page);

	*last_block_in_bio = block_nr;

	goto out;

out:
@@ -2289,7 +2305,6 @@ int f2fs_read_multi_pages(struct compress_ctx *cc, struct bio **bio_ret, 


		inc_page_count(sbi, F2FS_RD_DATA);

		f2fs_update_iostat(sbi, inode, FS_DATA_READ_IO, F2FS_BLKSIZE);

		ClearPageError(page);

		*last_block_in_bio = blkaddr;

	}
@@ -2306,7 +2321,6 @@ int f2fs_read_multi_pages(struct compress_ctx *cc, struct bio **bio_ret, 
	for (i = 0; i < cc->cluster_size; i++) {

		if (cc->rpages[i]) {

			ClearPageUptodate(cc->rpages[i]);

			ClearPageError(cc->rpages[i]);

			unlock_page(cc->rpages[i]);

		}

	}
@@ -2403,7 +2417,6 @@ static int f2fs_mpage_readpages(struct inode *inode, 
#ifdef CONFIG_F2FS_FS_COMPRESSION

set_error_page:

#endif

			SetPageError(page);

			zero_user_segment(page, 0, PAGE_SIZE);

			unlock_page(page);

		}

fs/verity/fsverity_private.h

+5 −0
Original line number Diff line number Diff line
@@ -32,6 +32,11 @@ struct fsverity_hash_alg { 
	unsigned int digest_size; /* digest size in bytes, e.g. 32 for SHA-256 */

	unsigned int block_size;  /* block size in bytes, e.g. 64 for SHA-256 */

	mempool_t req_pool;	  /* mempool with a preallocated hash request */

	/*

	 * The HASH_ALGO_* constant for this algorithm.  This is different from

	 * FS_VERITY_HASH_ALG_*, which uses a different numbering scheme.

	 */

	enum hash_algo algo_id;

};



/* Merkle tree parameters: hash algorithm, initial hash state, and topology */

fs/verity/hash_algs.c

+6 −0
Original line number Diff line number Diff line
@@ -16,11 +16,13 @@ struct fsverity_hash_alg fsverity_hash_algs[] = { 
		.name = "sha256",

		.digest_size = SHA256_DIGEST_SIZE,

		.block_size = SHA256_BLOCK_SIZE,

		.algo_id = HASH_ALGO_SHA256,

	},

	[FS_VERITY_HASH_ALG_SHA512] = {

		.name = "sha512",

		.digest_size = SHA512_DIGEST_SIZE,

		.block_size = SHA512_BLOCK_SIZE,

		.algo_id = HASH_ALGO_SHA512,

	},

};
@@ -324,5 +326,9 @@ void __init fsverity_check_hash_algs(void) 
		 */

		BUG_ON(!is_power_of_2(alg->digest_size));

		BUG_ON(!is_power_of_2(alg->block_size));



		/* Verify that there is a valid mapping to HASH_ALGO_*. */

		BUG_ON(alg->algo_id == 0);

		BUG_ON(alg->digest_size != hash_digest_size[alg->algo_id]);

	}

}