Commit 6c6d8f8b authored by Dr. David Alan Gilbert's avatar Dr. David Alan Gilbert Committed by Andrew Morton
Browse files

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: default avatarDr. David Alan Gilbert <linux@treblig.org>
Reviewed-by: default avatarChristoph Hellwig <hch@lst.de>
Cc: Dave Gilbert <linux@treblig.org>
Cc: Nick Terrell <terrelln@fb.com>
Signed-off-by: default avatarAndrew Morton <akpm@linux-foundation.org>
parent fefbeed8

include/linux/xxhash.h

+0 −26
Original line number Diff line number Diff line
@@ -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

 *

lib/xxhash.c

+0 −107
Original line number Diff line number Diff line
@@ -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;