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