lib/xxhash: remove unused functions

xxh32_digest() and xxh32_update() were added in 2017 in the original
xxhash commit, but have remained unused.

Remove them.

Link: https://lkml.kernel.org/r/20250716133245.243363-1-linux@treblig.org
Signed-off-by: Dr. David Alan Gilbert <linux@treblig.org>
Reviewed-by: Christoph Hellwig <hch@lst.de>
Cc: Dave Gilbert <linux@treblig.org>
Cc: Nick Terrell <terrelln@fb.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>

diff --git a/include/linux/xxhash.h b/include/linux/xxhash.h
index df42511438d0e727f592e19abfd398d6d6020ecd..27f57eca8cb12bdebc6e3742b55957b9f937d155 100644 (file)
--- a/include/linux/xxhash.h
+++ b/include/linux/xxhash.h
@@ -177,32 +177,6 @@ struct xxh64_state {
  */
 void xxh32_reset(struct xxh32_state *state, uint32_t seed);
 
-/**
- * xxh32_update() - hash the data given and update the xxh32 state
- *
- * @state:  The xxh32 state to update.
- * @input:  The data to hash.
- * @length: The length of the data to hash.
- *
- * After calling xxh32_reset() call xxh32_update() as many times as necessary.
- *
- * Return:  Zero on success, otherwise an error code.
- */
-int xxh32_update(struct xxh32_state *state, const void *input, size_t length);
-
-/**
- * xxh32_digest() - produce the current xxh32 hash
- *
- * @state: Produce the current xxh32 hash of this state.
- *
- * A hash value can be produced at any time. It is still possible to continue
- * inserting input into the hash state after a call to xxh32_digest(), and
- * generate new hashes later on, by calling xxh32_digest() again.
- *
- * Return: The xxh32 hash stored in the state.
- */
-uint32_t xxh32_digest(const struct xxh32_state *state);
-
 /**
  * xxh64_reset() - reset the xxh64 state to start a new hashing operation
  *

diff --git a/lib/xxhash.c b/lib/xxhash.c
index b5bd567aa6b3e6f2fca48e8085e1ee79b7237e37..cf629766f3762955c0d0c1d8d8139082606240b5 100644 (file)
--- a/lib/xxhash.c
+++ b/lib/xxhash.c
@@ -267,113 +267,6 @@ void xxh64_reset(struct xxh64_state *statePtr, const uint64_t seed)
 }
 EXPORT_SYMBOL(xxh64_reset);
 
-int xxh32_update(struct xxh32_state *state, const void *input, const size_t len)
-{
-       const uint8_t *p = (const uint8_t *)input;
-       const uint8_t *const b_end = p + len;
-
-       if (input == NULL)
-               return -EINVAL;
-
-       state->total_len_32 += (uint32_t)len;
-       state->large_len |= (len >= 16) | (state->total_len_32 >= 16);
-
-       if (state->memsize + len < 16) { /* fill in tmp buffer */
-               memcpy((uint8_t *)(state->mem32) + state->memsize, input, len);
-               state->memsize += (uint32_t)len;
-               return 0;
-       }
-
-       if (state->memsize) { /* some data left from previous update */
-               const uint32_t *p32 = state->mem32;
-
-               memcpy((uint8_t *)(state->mem32) + state->memsize, input,
-                       16 - state->memsize);
-
-               state->v1 = xxh32_round(state->v1, get_unaligned_le32(p32));
-               p32++;
-               state->v2 = xxh32_round(state->v2, get_unaligned_le32(p32));
-               p32++;
-               state->v3 = xxh32_round(state->v3, get_unaligned_le32(p32));
-               p32++;
-               state->v4 = xxh32_round(state->v4, get_unaligned_le32(p32));
-               p32++;
-
-               p += 16-state->memsize;
-               state->memsize = 0;
-       }
-
-       if (p <= b_end - 16) {
-               const uint8_t *const limit = b_end - 16;
-               uint32_t v1 = state->v1;
-               uint32_t v2 = state->v2;
-               uint32_t v3 = state->v3;
-               uint32_t v4 = state->v4;
-
-               do {
-                       v1 = xxh32_round(v1, get_unaligned_le32(p));
-                       p += 4;
-                       v2 = xxh32_round(v2, get_unaligned_le32(p));
-                       p += 4;
-                       v3 = xxh32_round(v3, get_unaligned_le32(p));
-                       p += 4;
-                       v4 = xxh32_round(v4, get_unaligned_le32(p));
-                       p += 4;
-               } while (p <= limit);
-
-               state->v1 = v1;
-               state->v2 = v2;
-               state->v3 = v3;
-               state->v4 = v4;
-       }
-
-       if (p < b_end) {
-               memcpy(state->mem32, p, (size_t)(b_end-p));
-               state->memsize = (uint32_t)(b_end-p);
-       }
-
-       return 0;
-}
-EXPORT_SYMBOL(xxh32_update);
-
-uint32_t xxh32_digest(const struct xxh32_state *state)
-{
-       const uint8_t *p = (const uint8_t *)state->mem32;
-       const uint8_t *const b_end = (const uint8_t *)(state->mem32) +
-               state->memsize;
-       uint32_t h32;
-
-       if (state->large_len) {
-               h32 = xxh_rotl32(state->v1, 1) + xxh_rotl32(state->v2, 7) +
-                       xxh_rotl32(state->v3, 12) + xxh_rotl32(state->v4, 18);
-       } else {
-               h32 = state->v3 /* == seed */ + PRIME32_5;
-       }
-
-       h32 += state->total_len_32;
-
-       while (p + 4 <= b_end) {
-               h32 += get_unaligned_le32(p) * PRIME32_3;
-               h32 = xxh_rotl32(h32, 17) * PRIME32_4;
-               p += 4;
-       }
-
-       while (p < b_end) {
-               h32 += (*p) * PRIME32_5;
-               h32 = xxh_rotl32(h32, 11) * PRIME32_1;
-               p++;
-       }
-
-       h32 ^= h32 >> 15;
-       h32 *= PRIME32_2;
-       h32 ^= h32 >> 13;
-       h32 *= PRIME32_3;
-       h32 ^= h32 >> 16;
-
-       return h32;
-}
-EXPORT_SYMBOL(xxh32_digest);
-
 int xxh64_update(struct xxh64_state *state, const void *input, const size_t len)
 {
        const uint8_t *p = (const uint8_t *)input;