xfrm_hash.h 4.4 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192
  1. /* SPDX-License-Identifier: GPL-2.0 */
  2. #ifndef _XFRM_HASH_H
  3. #define _XFRM_HASH_H
  4. #include <linux/xfrm.h>
  5. #include <linux/socket.h>
  6. #include <linux/jhash.h>
  7. static inline unsigned int __xfrm4_addr_hash(const xfrm_address_t *addr)
  8. {
  9. return ntohl(addr->a4);
  10. }
  11. static inline unsigned int __xfrm6_addr_hash(const xfrm_address_t *addr)
  12. {
  13. return jhash2((__force u32 *)addr->a6, 4, 0);
  14. }
  15. static inline unsigned int __xfrm4_daddr_saddr_hash(const xfrm_address_t *daddr,
  16. const xfrm_address_t *saddr)
  17. {
  18. u32 sum = (__force u32)daddr->a4 + (__force u32)saddr->a4;
  19. return ntohl((__force __be32)sum);
  20. }
  21. static inline unsigned int __xfrm6_daddr_saddr_hash(const xfrm_address_t *daddr,
  22. const xfrm_address_t *saddr)
  23. {
  24. return __xfrm6_addr_hash(daddr) ^ __xfrm6_addr_hash(saddr);
  25. }
  26. static inline u32 __bits2mask32(__u8 bits)
  27. {
  28. u32 mask32 = 0xffffffff;
  29. if (bits == 0)
  30. mask32 = 0;
  31. else if (bits < 32)
  32. mask32 <<= (32 - bits);
  33. return mask32;
  34. }
  35. static inline unsigned int __xfrm4_dpref_spref_hash(const xfrm_address_t *daddr,
  36. const xfrm_address_t *saddr,
  37. __u8 dbits,
  38. __u8 sbits)
  39. {
  40. return jhash_2words(ntohl(daddr->a4) & __bits2mask32(dbits),
  41. ntohl(saddr->a4) & __bits2mask32(sbits),
  42. 0);
  43. }
  44. static inline unsigned int __xfrm6_pref_hash(const xfrm_address_t *addr,
  45. __u8 prefixlen)
  46. {
  47. unsigned int pdw;
  48. unsigned int pbi;
  49. u32 initval = 0;
  50. pdw = prefixlen >> 5; /* num of whole u32 in prefix */
  51. pbi = prefixlen & 0x1f; /* num of bits in incomplete u32 in prefix */
  52. if (pbi) {
  53. __be32 mask;
  54. mask = htonl((0xffffffff) << (32 - pbi));
  55. initval = (__force u32)(addr->a6[pdw] & mask);
  56. }
  57. return jhash2((__force u32 *)addr->a6, pdw, initval);
  58. }
  59. static inline unsigned int __xfrm6_dpref_spref_hash(const xfrm_address_t *daddr,
  60. const xfrm_address_t *saddr,
  61. __u8 dbits,
  62. __u8 sbits)
  63. {
  64. return __xfrm6_pref_hash(daddr, dbits) ^
  65. __xfrm6_pref_hash(saddr, sbits);
  66. }
  67. static inline unsigned int __xfrm_dst_hash(const xfrm_address_t *daddr,
  68. const xfrm_address_t *saddr,
  69. u32 reqid, unsigned short family,
  70. unsigned int hmask)
  71. {
  72. unsigned int h = family ^ reqid;
  73. switch (family) {
  74. case AF_INET:
  75. h ^= __xfrm4_daddr_saddr_hash(daddr, saddr);
  76. break;
  77. case AF_INET6:
  78. h ^= __xfrm6_daddr_saddr_hash(daddr, saddr);
  79. break;
  80. }
  81. return (h ^ (h >> 16)) & hmask;
  82. }
  83. static inline unsigned int __xfrm_src_hash(const xfrm_address_t *daddr,
  84. const xfrm_address_t *saddr,
  85. unsigned short family,
  86. unsigned int hmask)
  87. {
  88. unsigned int h = family;
  89. switch (family) {
  90. case AF_INET:
  91. h ^= __xfrm4_daddr_saddr_hash(daddr, saddr);
  92. break;
  93. case AF_INET6:
  94. h ^= __xfrm6_daddr_saddr_hash(daddr, saddr);
  95. break;
  96. }
  97. return (h ^ (h >> 16)) & hmask;
  98. }
  99. static inline unsigned int
  100. __xfrm_spi_hash(const xfrm_address_t *daddr, __be32 spi, u8 proto,
  101. unsigned short family, unsigned int hmask)
  102. {
  103. unsigned int h = (__force u32)spi ^ proto;
  104. switch (family) {
  105. case AF_INET:
  106. h ^= __xfrm4_addr_hash(daddr);
  107. break;
  108. case AF_INET6:
  109. h ^= __xfrm6_addr_hash(daddr);
  110. break;
  111. }
  112. return (h ^ (h >> 10) ^ (h >> 20)) & hmask;
  113. }
  114. static inline unsigned int __idx_hash(u32 index, unsigned int hmask)
  115. {
  116. return (index ^ (index >> 8)) & hmask;
  117. }
  118. static inline unsigned int __sel_hash(const struct xfrm_selector *sel,
  119. unsigned short family, unsigned int hmask,
  120. u8 dbits, u8 sbits)
  121. {
  122. const xfrm_address_t *daddr = &sel->daddr;
  123. const xfrm_address_t *saddr = &sel->saddr;
  124. unsigned int h = 0;
  125. switch (family) {
  126. case AF_INET:
  127. if (sel->prefixlen_d < dbits ||
  128. sel->prefixlen_s < sbits)
  129. return hmask + 1;
  130. h = __xfrm4_dpref_spref_hash(daddr, saddr, dbits, sbits);
  131. break;
  132. case AF_INET6:
  133. if (sel->prefixlen_d < dbits ||
  134. sel->prefixlen_s < sbits)
  135. return hmask + 1;
  136. h = __xfrm6_dpref_spref_hash(daddr, saddr, dbits, sbits);
  137. break;
  138. }
  139. h ^= (h >> 16);
  140. return h & hmask;
  141. }
  142. static inline unsigned int __addr_hash(const xfrm_address_t *daddr,
  143. const xfrm_address_t *saddr,
  144. unsigned short family,
  145. unsigned int hmask,
  146. u8 dbits, u8 sbits)
  147. {
  148. unsigned int h = 0;
  149. switch (family) {
  150. case AF_INET:
  151. h = __xfrm4_dpref_spref_hash(daddr, saddr, dbits, sbits);
  152. break;
  153. case AF_INET6:
  154. h = __xfrm6_dpref_spref_hash(daddr, saddr, dbits, sbits);
  155. break;
  156. }
  157. h ^= (h >> 16);
  158. return h & hmask;
  159. }
  160. struct hlist_head *xfrm_hash_alloc(unsigned int sz);
  161. void xfrm_hash_free(struct hlist_head *n, unsigned int sz);
  162. #endif /* _XFRM_HASH_H */