fsverity: Remove inode parameter from fsverity_hash_block()

Due to the conversion from crypto_shash to the library API,
fsverity_hash_block() can no longer fail.  Therefore, the inode
parameter, which was used only to print an error message in the case of
a failure, is no longer necessary.  Remove it.

Reviewed-by: Ard Biesheuvel <ardb@kernel.org>
Link: https://lore.kernel.org/r/20250915160819.140019-6-ebiggers@kernel.org
Signed-off-by: Eric Biggers <ebiggers@kernel.org>

diff --git a/fs/verity/enable.c b/fs/verity/enable.c
index 89eccc4becf902518bf6671b5ea1bf0fae25913a..95ec42b847972c1b9bb14c5053a3dbbb85ed651d 100644 (file)
--- a/fs/verity/enable.c
+++ b/fs/verity/enable.c
@@ -19,8 +19,7 @@ struct block_buffer {
 };
 
 /* Hash a block, writing the result to the next level's pending block buffer. */
-static int hash_one_block(struct inode *inode,
-                         const struct merkle_tree_params *params,
+static int hash_one_block(const struct merkle_tree_params *params,
                          struct block_buffer *cur)
 {
        struct block_buffer *next = cur + 1;
@@ -36,8 +35,7 @@ static int hash_one_block(struct inode *inode,
        /* Zero-pad the block if it's shorter than the block size. */
        memset(&cur->data[cur->filled], 0, params->block_size - cur->filled);
 
-       fsverity_hash_block(params, inode, cur->data,
-                           &next->data[next->filled]);
+       fsverity_hash_block(params, cur->data, &next->data[next->filled]);
        next->filled += params->digest_size;
        cur->filled = 0;
        return 0;
@@ -123,7 +121,7 @@ static int build_merkle_tree(struct file *filp,
                        fsverity_err(inode, "Short read of file data");
                        goto out;
                }
-               err = hash_one_block(inode, params, &buffers[-1]);
+               err = hash_one_block(params, &buffers[-1]);
                if (err)
                        goto out;
                for (level = 0; level < num_levels; level++) {
@@ -134,7 +132,7 @@ static int build_merkle_tree(struct file *filp,
                        }
                        /* Next block at @level is full */
 
-                       err = hash_one_block(inode, params, &buffers[level]);
+                       err = hash_one_block(params, &buffers[level]);
                        if (err)
                                goto out;
                        err = write_merkle_tree_block(inode,
@@ -154,7 +152,7 @@ static int build_merkle_tree(struct file *filp,
        /* Finish all nonempty pending tree blocks. */
        for (level = 0; level < num_levels; level++) {
                if (buffers[level].filled != 0) {
-                       err = hash_one_block(inode, params, &buffers[level]);
+                       err = hash_one_block(params, &buffers[level]);
                        if (err)
                                goto out;
                        err = write_merkle_tree_block(inode,

diff --git a/fs/verity/fsverity_private.h b/fs/verity/fsverity_private.h
index bc1d887c532e74da245551ad9ebc3413e291c34f..dd20b138d452fa61db532467f925044dd627b8c7 100644 (file)
--- a/fs/verity/fsverity_private.h
+++ b/fs/verity/fsverity_private.h
@@ -90,7 +90,7 @@ union fsverity_hash_ctx *
 fsverity_prepare_hash_state(const struct fsverity_hash_alg *alg,
                            const u8 *salt, size_t salt_size);
 void fsverity_hash_block(const struct merkle_tree_params *params,
-                        const struct inode *inode, const void *data, u8 *out);
+                        const void *data, u8 *out);
 void fsverity_hash_buffer(const struct fsverity_hash_alg *alg,
                          const void *data, size_t size, u8 *out);
 void __init fsverity_check_hash_algs(void);

diff --git a/fs/verity/hash_algs.c b/fs/verity/hash_algs.c
index 9bb3c6344907e9549fe24f7d4b71d30f2da45997..de53e14c8aa78b46bd9c02517c88c0fef1f9beb8 100644 (file)
--- a/fs/verity/hash_algs.c
+++ b/fs/verity/hash_algs.c
@@ -94,7 +94,6 @@ fsverity_prepare_hash_state(const struct fsverity_hash_alg *alg,
 /**
  * fsverity_hash_block() - hash a single data or hash block
  * @params: the Merkle tree's parameters
- * @inode: inode for which the hashing is being done
  * @data: virtual address of a buffer containing the block to hash
  * @out: output digest, size 'params->digest_size' bytes
  *
@@ -102,7 +101,7 @@ fsverity_prepare_hash_state(const struct fsverity_hash_alg *alg,
  * in the Merkle tree parameters.
  */
 void fsverity_hash_block(const struct merkle_tree_params *params,
-                        const struct inode *inode, const void *data, u8 *out)
+                        const void *data, u8 *out)
 {
        union fsverity_hash_ctx ctx;
 

diff --git a/fs/verity/verify.c b/fs/verity/verify.c
index affc307eb6a6b16e9ef9a5adbce1901c8c33c0f4..cbb75f7bc9bf73d6f4a7831f4df3ea7311f2731e 100644 (file)
--- a/fs/verity/verify.c
+++ b/fs/verity/verify.c
@@ -202,7 +202,7 @@ descend:
                unsigned long hblock_idx = hblocks[level - 1].index;
                unsigned int hoffset = hblocks[level - 1].hoffset;
 
-               fsverity_hash_block(params, inode, haddr, real_hash);
+               fsverity_hash_block(params, haddr, real_hash);
                if (memcmp(want_hash, real_hash, hsize) != 0)
                        goto corrupted;
                /*
@@ -221,7 +221,7 @@ descend:
        }
 
        /* Finally, verify the data block. */
-       fsverity_hash_block(params, inode, data, real_hash);
+       fsverity_hash_block(params, data, real_hash);
        if (memcmp(want_hash, real_hash, hsize) != 0)
                goto corrupted;
        return true;