13c838a9fSAndrew Rybchenko /*-
23c838a9fSAndrew Rybchenko * Copyright 2006 Bob Jenkins
33c838a9fSAndrew Rybchenko *
43c838a9fSAndrew Rybchenko * Derived from public domain source, see
53c838a9fSAndrew Rybchenko * <http://burtleburtle.net/bob/c/lookup3.c>:
63c838a9fSAndrew Rybchenko *
73c838a9fSAndrew Rybchenko * "lookup3.c, by Bob Jenkins, May 2006, Public Domain.
83c838a9fSAndrew Rybchenko *
93c838a9fSAndrew Rybchenko * These are functions for producing 32-bit hashes for hash table lookup...
103c838a9fSAndrew Rybchenko * ...You can use this free for any purpose. It's in the public domain.
113c838a9fSAndrew Rybchenko * It has no warranty."
123c838a9fSAndrew Rybchenko *
13929c7febSAndrew Rybchenko * Copyright (c) 2014-2016 Solarflare Communications Inc.
143c838a9fSAndrew Rybchenko * All rights reserved.
153c838a9fSAndrew Rybchenko *
163c838a9fSAndrew Rybchenko * Redistribution and use in source and binary forms, with or without
173c838a9fSAndrew Rybchenko * modification, are permitted provided that the following conditions are met:
183c838a9fSAndrew Rybchenko *
193c838a9fSAndrew Rybchenko * 1. Redistributions of source code must retain the above copyright notice,
203c838a9fSAndrew Rybchenko * this list of conditions and the following disclaimer.
213c838a9fSAndrew Rybchenko * 2. Redistributions in binary form must reproduce the above copyright notice,
223c838a9fSAndrew Rybchenko * this list of conditions and the following disclaimer in the documentation
233c838a9fSAndrew Rybchenko * and/or other materials provided with the distribution.
243c838a9fSAndrew Rybchenko *
253c838a9fSAndrew Rybchenko * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
263c838a9fSAndrew Rybchenko * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
273c838a9fSAndrew Rybchenko * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
283c838a9fSAndrew Rybchenko * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
293c838a9fSAndrew Rybchenko * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
303c838a9fSAndrew Rybchenko * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
313c838a9fSAndrew Rybchenko * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
323c838a9fSAndrew Rybchenko * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
333c838a9fSAndrew Rybchenko * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
343c838a9fSAndrew Rybchenko * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
353c838a9fSAndrew Rybchenko * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
363c838a9fSAndrew Rybchenko *
373c838a9fSAndrew Rybchenko * The views and conclusions contained in the software and documentation are
383c838a9fSAndrew Rybchenko * those of the authors and should not be interpreted as representing official
393c838a9fSAndrew Rybchenko * policies, either expressed or implied, of the FreeBSD Project.
403c838a9fSAndrew Rybchenko */
413c838a9fSAndrew Rybchenko
423c838a9fSAndrew Rybchenko #include <sys/cdefs.h>
433c838a9fSAndrew Rybchenko #include "efx.h"
443c838a9fSAndrew Rybchenko #include "efx_impl.h"
453c838a9fSAndrew Rybchenko
463c838a9fSAndrew Rybchenko /* Hash initial value */
473c838a9fSAndrew Rybchenko #define EFX_HASH_INITIAL_VALUE 0xdeadbeef
483c838a9fSAndrew Rybchenko
493c838a9fSAndrew Rybchenko /*
503c838a9fSAndrew Rybchenko * Rotate a 32-bit value left
513c838a9fSAndrew Rybchenko *
523c838a9fSAndrew Rybchenko * Allow platform to provide an intrinsic or optimised routine and
533c838a9fSAndrew Rybchenko * fall-back to a simple shift based implementation.
543c838a9fSAndrew Rybchenko */
553c838a9fSAndrew Rybchenko #if EFSYS_HAS_ROTL_DWORD
563c838a9fSAndrew Rybchenko
573c838a9fSAndrew Rybchenko #define EFX_HASH_ROTATE(_value, _shift) \
583c838a9fSAndrew Rybchenko EFSYS_ROTL_DWORD(_value, _shift)
593c838a9fSAndrew Rybchenko
603c838a9fSAndrew Rybchenko #else
613c838a9fSAndrew Rybchenko
623c838a9fSAndrew Rybchenko #define EFX_HASH_ROTATE(_value, _shift) \
633c838a9fSAndrew Rybchenko (((_value) << (_shift)) | ((_value) >> (32 - (_shift))))
643c838a9fSAndrew Rybchenko
653c838a9fSAndrew Rybchenko #endif
663c838a9fSAndrew Rybchenko
673c838a9fSAndrew Rybchenko /* Mix three 32-bit values reversibly */
683c838a9fSAndrew Rybchenko #define EFX_HASH_MIX(_a, _b, _c) \
693c838a9fSAndrew Rybchenko do { \
703c838a9fSAndrew Rybchenko _a -= _c; \
713c838a9fSAndrew Rybchenko _a ^= EFX_HASH_ROTATE(_c, 4); \
723c838a9fSAndrew Rybchenko _c += _b; \
733c838a9fSAndrew Rybchenko _b -= _a; \
743c838a9fSAndrew Rybchenko _b ^= EFX_HASH_ROTATE(_a, 6); \
753c838a9fSAndrew Rybchenko _a += _c; \
763c838a9fSAndrew Rybchenko _c -= _b; \
773c838a9fSAndrew Rybchenko _c ^= EFX_HASH_ROTATE(_b, 8); \
783c838a9fSAndrew Rybchenko _b += _a; \
793c838a9fSAndrew Rybchenko _a -= _c; \
803c838a9fSAndrew Rybchenko _a ^= EFX_HASH_ROTATE(_c, 16); \
813c838a9fSAndrew Rybchenko _c += _b; \
823c838a9fSAndrew Rybchenko _b -= _a; \
833c838a9fSAndrew Rybchenko _b ^= EFX_HASH_ROTATE(_a, 19); \
843c838a9fSAndrew Rybchenko _a += _c; \
853c838a9fSAndrew Rybchenko _c -= _b; \
863c838a9fSAndrew Rybchenko _c ^= EFX_HASH_ROTATE(_b, 4); \
873c838a9fSAndrew Rybchenko _b += _a; \
883c838a9fSAndrew Rybchenko _NOTE(CONSTANTCONDITION) \
893c838a9fSAndrew Rybchenko } while (B_FALSE)
903c838a9fSAndrew Rybchenko
913c838a9fSAndrew Rybchenko /* Final mixing of three 32-bit values into one (_c) */
923c838a9fSAndrew Rybchenko #define EFX_HASH_FINALISE(_a, _b, _c) \
933c838a9fSAndrew Rybchenko do { \
943c838a9fSAndrew Rybchenko _c ^= _b; \
953c838a9fSAndrew Rybchenko _c -= EFX_HASH_ROTATE(_b, 14); \
963c838a9fSAndrew Rybchenko _a ^= _c; \
973c838a9fSAndrew Rybchenko _a -= EFX_HASH_ROTATE(_c, 11); \
983c838a9fSAndrew Rybchenko _b ^= _a; \
993c838a9fSAndrew Rybchenko _b -= EFX_HASH_ROTATE(_a, 25); \
1003c838a9fSAndrew Rybchenko _c ^= _b; \
1013c838a9fSAndrew Rybchenko _c -= EFX_HASH_ROTATE(_b, 16); \
1023c838a9fSAndrew Rybchenko _a ^= _c; \
1033c838a9fSAndrew Rybchenko _a -= EFX_HASH_ROTATE(_c, 4); \
1043c838a9fSAndrew Rybchenko _b ^= _a; \
1053c838a9fSAndrew Rybchenko _b -= EFX_HASH_ROTATE(_a, 14); \
1063c838a9fSAndrew Rybchenko _c ^= _b; \
1073c838a9fSAndrew Rybchenko _c -= EFX_HASH_ROTATE(_b, 24); \
1083c838a9fSAndrew Rybchenko _NOTE(CONSTANTCONDITION) \
1093c838a9fSAndrew Rybchenko } while (B_FALSE)
1103c838a9fSAndrew Rybchenko
1113c838a9fSAndrew Rybchenko /* Produce a 32-bit hash from 32-bit aligned input */
1123c838a9fSAndrew Rybchenko __checkReturn uint32_t
efx_hash_dwords(__in_ecount (count)uint32_t const * input,__in size_t count,__in uint32_t init)1133c838a9fSAndrew Rybchenko efx_hash_dwords(
1143c838a9fSAndrew Rybchenko __in_ecount(count) uint32_t const *input,
1153c838a9fSAndrew Rybchenko __in size_t count,
1163c838a9fSAndrew Rybchenko __in uint32_t init)
1173c838a9fSAndrew Rybchenko {
1183c838a9fSAndrew Rybchenko uint32_t a;
1193c838a9fSAndrew Rybchenko uint32_t b;
1203c838a9fSAndrew Rybchenko uint32_t c;
1213c838a9fSAndrew Rybchenko
1223c838a9fSAndrew Rybchenko /* Set up the initial internal state */
1233c838a9fSAndrew Rybchenko a = b = c = EFX_HASH_INITIAL_VALUE +
1243c838a9fSAndrew Rybchenko (((uint32_t)count) * sizeof (uint32_t)) + init;
1253c838a9fSAndrew Rybchenko
1263c838a9fSAndrew Rybchenko /* Handle all but the last three dwords of the input */
1273c838a9fSAndrew Rybchenko while (count > 3) {
1283c838a9fSAndrew Rybchenko a += input[0];
1293c838a9fSAndrew Rybchenko b += input[1];
1303c838a9fSAndrew Rybchenko c += input[2];
1313c838a9fSAndrew Rybchenko EFX_HASH_MIX(a, b, c);
1323c838a9fSAndrew Rybchenko
1333c838a9fSAndrew Rybchenko count -= 3;
1343c838a9fSAndrew Rybchenko input += 3;
1353c838a9fSAndrew Rybchenko }
1363c838a9fSAndrew Rybchenko
1373c838a9fSAndrew Rybchenko /* Handle the left-overs */
1383c838a9fSAndrew Rybchenko switch (count) {
1393c838a9fSAndrew Rybchenko case 3:
1403c838a9fSAndrew Rybchenko c += input[2];
1413c838a9fSAndrew Rybchenko /* Fall-through */
1423c838a9fSAndrew Rybchenko case 2:
1433c838a9fSAndrew Rybchenko b += input[1];
1443c838a9fSAndrew Rybchenko /* Fall-through */
1453c838a9fSAndrew Rybchenko case 1:
1463c838a9fSAndrew Rybchenko a += input[0];
1473c838a9fSAndrew Rybchenko EFX_HASH_FINALISE(a, b, c);
1483c838a9fSAndrew Rybchenko break;
1493c838a9fSAndrew Rybchenko
1503c838a9fSAndrew Rybchenko case 0:
1513c838a9fSAndrew Rybchenko /* Should only get here if count parameter was zero */
1523c838a9fSAndrew Rybchenko break;
1533c838a9fSAndrew Rybchenko }
1543c838a9fSAndrew Rybchenko
1553c838a9fSAndrew Rybchenko return (c);
1563c838a9fSAndrew Rybchenko }
1573c838a9fSAndrew Rybchenko
1583c838a9fSAndrew Rybchenko #if EFSYS_IS_BIG_ENDIAN
1593c838a9fSAndrew Rybchenko
1603c838a9fSAndrew Rybchenko /* Produce a 32-bit hash from arbitrarily aligned input */
1613c838a9fSAndrew Rybchenko __checkReturn uint32_t
efx_hash_bytes(__in_ecount (length)uint8_t const * input,__in size_t length,__in uint32_t init)1623c838a9fSAndrew Rybchenko efx_hash_bytes(
1633c838a9fSAndrew Rybchenko __in_ecount(length) uint8_t const *input,
1643c838a9fSAndrew Rybchenko __in size_t length,
1653c838a9fSAndrew Rybchenko __in uint32_t init)
1663c838a9fSAndrew Rybchenko {
1673c838a9fSAndrew Rybchenko uint32_t a;
1683c838a9fSAndrew Rybchenko uint32_t b;
1693c838a9fSAndrew Rybchenko uint32_t c;
1703c838a9fSAndrew Rybchenko
1713c838a9fSAndrew Rybchenko /* Set up the initial internal state */
1723c838a9fSAndrew Rybchenko a = b = c = EFX_HASH_INITIAL_VALUE + (uint32_t)length + init;
1733c838a9fSAndrew Rybchenko
1743c838a9fSAndrew Rybchenko /* Handle all but the last twelve bytes of the input */
1753c838a9fSAndrew Rybchenko while (length > 12) {
1763c838a9fSAndrew Rybchenko a += ((uint32_t)input[0]) << 24;
1773c838a9fSAndrew Rybchenko a += ((uint32_t)input[1]) << 16;
1783c838a9fSAndrew Rybchenko a += ((uint32_t)input[2]) << 8;
1793c838a9fSAndrew Rybchenko a += ((uint32_t)input[3]);
1803c838a9fSAndrew Rybchenko b += ((uint32_t)input[4]) << 24;
1813c838a9fSAndrew Rybchenko b += ((uint32_t)input[5]) << 16;
1823c838a9fSAndrew Rybchenko b += ((uint32_t)input[6]) << 8;
1833c838a9fSAndrew Rybchenko b += ((uint32_t)input[7]);
1843c838a9fSAndrew Rybchenko c += ((uint32_t)input[8]) << 24;
1853c838a9fSAndrew Rybchenko c += ((uint32_t)input[9]) << 16;
1863c838a9fSAndrew Rybchenko c += ((uint32_t)input[10]) << 8;
1873c838a9fSAndrew Rybchenko c += ((uint32_t)input[11]);
1883c838a9fSAndrew Rybchenko EFX_HASH_MIX(a, b, c);
1893c838a9fSAndrew Rybchenko length -= 12;
1903c838a9fSAndrew Rybchenko input += 12;
1913c838a9fSAndrew Rybchenko }
1923c838a9fSAndrew Rybchenko
1933c838a9fSAndrew Rybchenko /* Handle the left-overs */
1943c838a9fSAndrew Rybchenko switch (length) {
1953c838a9fSAndrew Rybchenko case 12:
1963c838a9fSAndrew Rybchenko c += ((uint32_t)input[11]);
1973c838a9fSAndrew Rybchenko /* Fall-through */
1983c838a9fSAndrew Rybchenko case 11:
1993c838a9fSAndrew Rybchenko c += ((uint32_t)input[10]) << 8;
2003c838a9fSAndrew Rybchenko /* Fall-through */
2013c838a9fSAndrew Rybchenko case 10:
2023c838a9fSAndrew Rybchenko c += ((uint32_t)input[9]) << 16;
2033c838a9fSAndrew Rybchenko /* Fall-through */
2043c838a9fSAndrew Rybchenko case 9:
2053c838a9fSAndrew Rybchenko c += ((uint32_t)input[8]) << 24;
2063c838a9fSAndrew Rybchenko /* Fall-through */
2073c838a9fSAndrew Rybchenko case 8:
2083c838a9fSAndrew Rybchenko b += ((uint32_t)input[7]);
2093c838a9fSAndrew Rybchenko /* Fall-through */
2103c838a9fSAndrew Rybchenko case 7:
2113c838a9fSAndrew Rybchenko b += ((uint32_t)input[6]) << 8;
2123c838a9fSAndrew Rybchenko /* Fall-through */
2133c838a9fSAndrew Rybchenko case 6:
2143c838a9fSAndrew Rybchenko b += ((uint32_t)input[5]) << 16;
2153c838a9fSAndrew Rybchenko /* Fall-through */
2163c838a9fSAndrew Rybchenko case 5:
2173c838a9fSAndrew Rybchenko b += ((uint32_t)input[4]) << 24;
2183c838a9fSAndrew Rybchenko /* Fall-through */
2193c838a9fSAndrew Rybchenko case 4:
2203c838a9fSAndrew Rybchenko a += ((uint32_t)input[3]);
2213c838a9fSAndrew Rybchenko /* Fall-through */
2223c838a9fSAndrew Rybchenko case 3:
2233c838a9fSAndrew Rybchenko a += ((uint32_t)input[2]) << 8;
2243c838a9fSAndrew Rybchenko /* Fall-through */
2253c838a9fSAndrew Rybchenko case 2:
2263c838a9fSAndrew Rybchenko a += ((uint32_t)input[1]) << 16;
2273c838a9fSAndrew Rybchenko /* Fall-through */
2283c838a9fSAndrew Rybchenko case 1:
2293c838a9fSAndrew Rybchenko a += ((uint32_t)input[0]) << 24;
2303c838a9fSAndrew Rybchenko EFX_HASH_FINALISE(a, b, c);
2313c838a9fSAndrew Rybchenko break;
2323c838a9fSAndrew Rybchenko
2333c838a9fSAndrew Rybchenko case 0:
2343c838a9fSAndrew Rybchenko /* Should only get here if length parameter was zero */
2353c838a9fSAndrew Rybchenko break;
2363c838a9fSAndrew Rybchenko }
2373c838a9fSAndrew Rybchenko
2383c838a9fSAndrew Rybchenko return (c);
2393c838a9fSAndrew Rybchenko }
2403c838a9fSAndrew Rybchenko
2413c838a9fSAndrew Rybchenko #elif EFSYS_IS_LITTLE_ENDIAN
2423c838a9fSAndrew Rybchenko
2433c838a9fSAndrew Rybchenko /* Produce a 32-bit hash from arbitrarily aligned input */
2443c838a9fSAndrew Rybchenko __checkReturn uint32_t
efx_hash_bytes(__in_ecount (length)uint8_t const * input,__in size_t length,__in uint32_t init)2453c838a9fSAndrew Rybchenko efx_hash_bytes(
2463c838a9fSAndrew Rybchenko __in_ecount(length) uint8_t const *input,
2473c838a9fSAndrew Rybchenko __in size_t length,
2483c838a9fSAndrew Rybchenko __in uint32_t init)
2493c838a9fSAndrew Rybchenko {
2503c838a9fSAndrew Rybchenko uint32_t a;
2513c838a9fSAndrew Rybchenko uint32_t b;
2523c838a9fSAndrew Rybchenko uint32_t c;
2533c838a9fSAndrew Rybchenko
2543c838a9fSAndrew Rybchenko /* Set up the initial internal state */
2553c838a9fSAndrew Rybchenko a = b = c = EFX_HASH_INITIAL_VALUE + (uint32_t)length + init;
2563c838a9fSAndrew Rybchenko
2573c838a9fSAndrew Rybchenko /* Handle all but the last twelve bytes of the input */
2583c838a9fSAndrew Rybchenko while (length > 12) {
2593c838a9fSAndrew Rybchenko a += ((uint32_t)input[0]);
2603c838a9fSAndrew Rybchenko a += ((uint32_t)input[1]) << 8;
2613c838a9fSAndrew Rybchenko a += ((uint32_t)input[2]) << 16;
2623c838a9fSAndrew Rybchenko a += ((uint32_t)input[3]) << 24;
2633c838a9fSAndrew Rybchenko b += ((uint32_t)input[4]);
2643c838a9fSAndrew Rybchenko b += ((uint32_t)input[5]) << 8;
2653c838a9fSAndrew Rybchenko b += ((uint32_t)input[6]) << 16;
2663c838a9fSAndrew Rybchenko b += ((uint32_t)input[7]) << 24;
2673c838a9fSAndrew Rybchenko c += ((uint32_t)input[8]);
2683c838a9fSAndrew Rybchenko c += ((uint32_t)input[9]) << 8;
2693c838a9fSAndrew Rybchenko c += ((uint32_t)input[10]) << 16;
2703c838a9fSAndrew Rybchenko c += ((uint32_t)input[11]) << 24;
2713c838a9fSAndrew Rybchenko EFX_HASH_MIX(a, b, c);
2723c838a9fSAndrew Rybchenko length -= 12;
2733c838a9fSAndrew Rybchenko input += 12;
2743c838a9fSAndrew Rybchenko }
2753c838a9fSAndrew Rybchenko
2763c838a9fSAndrew Rybchenko /* Handle the left-overs */
2773c838a9fSAndrew Rybchenko switch (length) {
2783c838a9fSAndrew Rybchenko case 12:
2793c838a9fSAndrew Rybchenko c += ((uint32_t)input[11]) << 24;
2803c838a9fSAndrew Rybchenko /* Fall-through */
2813c838a9fSAndrew Rybchenko case 11:
2823c838a9fSAndrew Rybchenko c += ((uint32_t)input[10]) << 16;
2833c838a9fSAndrew Rybchenko /* Fall-through */
2843c838a9fSAndrew Rybchenko case 10:
2853c838a9fSAndrew Rybchenko c += ((uint32_t)input[9]) << 8;
2863c838a9fSAndrew Rybchenko /* Fall-through */
2873c838a9fSAndrew Rybchenko case 9:
2883c838a9fSAndrew Rybchenko c += ((uint32_t)input[8]);
2893c838a9fSAndrew Rybchenko /* Fall-through */
2903c838a9fSAndrew Rybchenko case 8:
2913c838a9fSAndrew Rybchenko b += ((uint32_t)input[7]) << 24;
2923c838a9fSAndrew Rybchenko /* Fall-through */
2933c838a9fSAndrew Rybchenko case 7:
2943c838a9fSAndrew Rybchenko b += ((uint32_t)input[6]) << 16;
2953c838a9fSAndrew Rybchenko /* Fall-through */
2963c838a9fSAndrew Rybchenko case 6:
2973c838a9fSAndrew Rybchenko b += ((uint32_t)input[5]) << 8;
2983c838a9fSAndrew Rybchenko /* Fall-through */
2993c838a9fSAndrew Rybchenko case 5:
3003c838a9fSAndrew Rybchenko b += ((uint32_t)input[4]);
3013c838a9fSAndrew Rybchenko /* Fall-through */
3023c838a9fSAndrew Rybchenko case 4:
3033c838a9fSAndrew Rybchenko a += ((uint32_t)input[3]) << 24;
3043c838a9fSAndrew Rybchenko /* Fall-through */
3053c838a9fSAndrew Rybchenko case 3:
3063c838a9fSAndrew Rybchenko a += ((uint32_t)input[2]) << 16;
3073c838a9fSAndrew Rybchenko /* Fall-through */
3083c838a9fSAndrew Rybchenko case 2:
3093c838a9fSAndrew Rybchenko a += ((uint32_t)input[1]) << 8;
3103c838a9fSAndrew Rybchenko /* Fall-through */
3113c838a9fSAndrew Rybchenko case 1:
3123c838a9fSAndrew Rybchenko a += ((uint32_t)input[0]);
3133c838a9fSAndrew Rybchenko EFX_HASH_FINALISE(a, b, c);
3143c838a9fSAndrew Rybchenko break;
3153c838a9fSAndrew Rybchenko
3163c838a9fSAndrew Rybchenko case 0:
3173c838a9fSAndrew Rybchenko /* Should only get here if length parameter was zero */
3183c838a9fSAndrew Rybchenko break;
3193c838a9fSAndrew Rybchenko }
3203c838a9fSAndrew Rybchenko
3213c838a9fSAndrew Rybchenko return (c);
3223c838a9fSAndrew Rybchenko }
3233c838a9fSAndrew Rybchenko
3243c838a9fSAndrew Rybchenko #else
3253c838a9fSAndrew Rybchenko
3263c838a9fSAndrew Rybchenko #error "Neither of EFSYS_IS_{BIG,LITTLE}_ENDIAN is set"
3273c838a9fSAndrew Rybchenko
3283c838a9fSAndrew Rybchenko #endif
329