1 // SPDX-License-Identifier: GPL-2.0-only 2 3 /* PIPAPO: PIle PAcket POlicies: set for arbitrary concatenations of ranges 4 * 5 * Copyright (c) 2019-2020 Red Hat GmbH 6 * 7 * Author: Stefano Brivio <sbrivio@redhat.com> 8 */ 9 10 /** 11 * DOC: Theory of Operation 12 * 13 * 14 * Problem 15 * ------- 16 * 17 * Match packet bytes against entries composed of ranged or non-ranged packet 18 * field specifiers, mapping them to arbitrary references. For example: 19 * 20 * :: 21 * 22 * --- fields ---> 23 * | [net],[port],[net]... => [reference] 24 * entries [net],[port],[net]... => [reference] 25 * | [net],[port],[net]... => [reference] 26 * V ... 27 * 28 * where [net] fields can be IP ranges or netmasks, and [port] fields are port 29 * ranges. Arbitrary packet fields can be matched. 30 * 31 * 32 * Algorithm Overview 33 * ------------------ 34 * 35 * This algorithm is loosely inspired by [Ligatti 2010], and fundamentally 36 * relies on the consideration that every contiguous range in a space of b bits 37 * can be converted into b * 2 netmasks, from Theorem 3 in [Rottenstreich 2010], 38 * as also illustrated in Section 9 of [Kogan 2014]. 39 * 40 * Classification against a number of entries, that require matching given bits 41 * of a packet field, is performed by grouping those bits in sets of arbitrary 42 * size, and classifying packet bits one group at a time. 43 * 44 * Example: 45 * to match the source port (16 bits) of a packet, we can divide those 16 bits 46 * in 4 groups of 4 bits each. Given the entry: 47 * 0000 0001 0101 1001 48 * and a packet with source port: 49 * 0000 0001 1010 1001 50 * first and second groups match, but the third doesn't. We conclude that the 51 * packet doesn't match the given entry. 52 * 53 * Translate the set to a sequence of lookup tables, one per field. Each table 54 * has two dimensions: bit groups to be matched for a single packet field, and 55 * all the possible values of said groups (buckets). Input entries are 56 * represented as one or more rules, depending on the number of composing 57 * netmasks for the given field specifier, and a group match is indicated as a 58 * set bit, with number corresponding to the rule index, in all the buckets 59 * whose value matches the entry for a given group. 60 * 61 * Rules are mapped between fields through an array of x, n pairs, with each 62 * item mapping a matched rule to one or more rules. The position of the pair in 63 * the array indicates the matched rule to be mapped to the next field, x 64 * indicates the first rule index in the next field, and n the amount of 65 * next-field rules the current rule maps to. 66 * 67 * The mapping array for the last field maps to the desired references. 68 * 69 * To match, we perform table lookups using the values of grouped packet bits, 70 * and use a sequence of bitwise operations to progressively evaluate rule 71 * matching. 72 * 73 * A stand-alone, reference implementation, also including notes about possible 74 * future optimisations, is available at: 75 * https://pipapo.lameexcu.se/ 76 * 77 * Insertion 78 * --------- 79 * 80 * - For each packet field: 81 * 82 * - divide the b packet bits we want to classify into groups of size t, 83 * obtaining ceil(b / t) groups 84 * 85 * Example: match on destination IP address, with t = 4: 32 bits, 8 groups 86 * of 4 bits each 87 * 88 * - allocate a lookup table with one column ("bucket") for each possible 89 * value of a group, and with one row for each group 90 * 91 * Example: 8 groups, 2^4 buckets: 92 * 93 * :: 94 * 95 * bucket 96 * group 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 97 * 0 98 * 1 99 * 2 100 * 3 101 * 4 102 * 5 103 * 6 104 * 7 105 * 106 * - map the bits we want to classify for the current field, for a given 107 * entry, to a single rule for non-ranged and netmask set items, and to one 108 * or multiple rules for ranges. Ranges are expanded to composing netmasks 109 * by pipapo_expand(). 110 * 111 * Example: 2 entries, 10.0.0.5:1024 and 192.168.1.0-192.168.2.1:2048 112 * - rule #0: 10.0.0.5 113 * - rule #1: 192.168.1.0/24 114 * - rule #2: 192.168.2.0/31 115 * 116 * - insert references to the rules in the lookup table, selecting buckets 117 * according to bit values of a rule in the given group. This is done by 118 * pipapo_insert(). 119 * 120 * Example: given: 121 * - rule #0: 10.0.0.5 mapping to buckets 122 * < 0 10 0 0 0 0 0 5 > 123 * - rule #1: 192.168.1.0/24 mapping to buckets 124 * < 12 0 10 8 0 1 < 0..15 > < 0..15 > > 125 * - rule #2: 192.168.2.0/31 mapping to buckets 126 * < 12 0 10 8 0 2 0 < 0..1 > > 127 * 128 * these bits are set in the lookup table: 129 * 130 * :: 131 * 132 * bucket 133 * group 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 134 * 0 0 1,2 135 * 1 1,2 0 136 * 2 0 1,2 137 * 3 0 1,2 138 * 4 0,1,2 139 * 5 0 1 2 140 * 6 0,1,2 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 141 * 7 1,2 1,2 1 1 1 0,1 1 1 1 1 1 1 1 1 1 1 142 * 143 * - if this is not the last field in the set, fill a mapping array that maps 144 * rules from the lookup table to rules belonging to the same entry in 145 * the next lookup table, done by pipapo_map(). 146 * 147 * Note that as rules map to contiguous ranges of rules, given how netmask 148 * expansion and insertion is performed, &union nft_pipapo_map_bucket stores 149 * this information as pairs of first rule index, rule count. 150 * 151 * Example: 2 entries, 10.0.0.5:1024 and 192.168.1.0-192.168.2.1:2048, 152 * given lookup table #0 for field 0 (see example above): 153 * 154 * :: 155 * 156 * bucket 157 * group 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 158 * 0 0 1,2 159 * 1 1,2 0 160 * 2 0 1,2 161 * 3 0 1,2 162 * 4 0,1,2 163 * 5 0 1 2 164 * 6 0,1,2 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 165 * 7 1,2 1,2 1 1 1 0,1 1 1 1 1 1 1 1 1 1 1 166 * 167 * and lookup table #1 for field 1 with: 168 * - rule #0: 1024 mapping to buckets 169 * < 0 0 4 0 > 170 * - rule #1: 2048 mapping to buckets 171 * < 0 0 5 0 > 172 * 173 * :: 174 * 175 * bucket 176 * group 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 177 * 0 0,1 178 * 1 0,1 179 * 2 0 1 180 * 3 0,1 181 * 182 * we need to map rules for 10.0.0.5 in lookup table #0 (rule #0) to 1024 183 * in lookup table #1 (rule #0) and rules for 192.168.1.0-192.168.2.1 184 * (rules #1, #2) to 2048 in lookup table #2 (rule #1): 185 * 186 * :: 187 * 188 * rule indices in current field: 0 1 2 189 * map to rules in next field: 0 1 1 190 * 191 * - if this is the last field in the set, fill a mapping array that maps 192 * rules from the last lookup table to element pointers, also done by 193 * pipapo_map(). 194 * 195 * Note that, in this implementation, we have two elements (start, end) for 196 * each entry. The pointer to the end element is stored in this array, and 197 * the pointer to the start element is linked from it. 198 * 199 * Example: entry 10.0.0.5:1024 has a corresponding &struct nft_pipapo_elem 200 * pointer, 0x66, and element for 192.168.1.0-192.168.2.1:2048 is at 0x42. 201 * From the rules of lookup table #1 as mapped above: 202 * 203 * :: 204 * 205 * rule indices in last field: 0 1 206 * map to elements: 0x66 0x42 207 * 208 * 209 * Matching 210 * -------- 211 * 212 * We use a result bitmap, with the size of a single lookup table bucket, to 213 * represent the matching state that applies at every algorithm step. This is 214 * done by pipapo_lookup(). 215 * 216 * - For each packet field: 217 * 218 * - start with an all-ones result bitmap (res_map in pipapo_lookup()) 219 * 220 * - perform a lookup into the table corresponding to the current field, 221 * for each group, and at every group, AND the current result bitmap with 222 * the value from the lookup table bucket 223 * 224 * :: 225 * 226 * Example: 192.168.1.5 < 12 0 10 8 0 1 0 5 >, with lookup table from 227 * insertion examples. 228 * Lookup table buckets are at least 3 bits wide, we'll assume 8 bits for 229 * convenience in this example. Initial result bitmap is 0xff, the steps 230 * below show the value of the result bitmap after each group is processed: 231 * 232 * bucket 233 * group 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 234 * 0 0 1,2 235 * result bitmap is now: 0xff & 0x6 [bucket 12] = 0x6 236 * 237 * 1 1,2 0 238 * result bitmap is now: 0x6 & 0x6 [bucket 0] = 0x6 239 * 240 * 2 0 1,2 241 * result bitmap is now: 0x6 & 0x6 [bucket 10] = 0x6 242 * 243 * 3 0 1,2 244 * result bitmap is now: 0x6 & 0x6 [bucket 8] = 0x6 245 * 246 * 4 0,1,2 247 * result bitmap is now: 0x6 & 0x7 [bucket 0] = 0x6 248 * 249 * 5 0 1 2 250 * result bitmap is now: 0x6 & 0x2 [bucket 1] = 0x2 251 * 252 * 6 0,1,2 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 253 * result bitmap is now: 0x2 & 0x7 [bucket 0] = 0x2 254 * 255 * 7 1,2 1,2 1 1 1 0,1 1 1 1 1 1 1 1 1 1 1 256 * final result bitmap for this field is: 0x2 & 0x3 [bucket 5] = 0x2 257 * 258 * - at the next field, start with a new, all-zeroes result bitmap. For each 259 * bit set in the previous result bitmap, fill the new result bitmap 260 * (fill_map in pipapo_lookup()) with the rule indices from the 261 * corresponding buckets of the mapping field for this field, done by 262 * pipapo_refill() 263 * 264 * Example: with mapping table from insertion examples, with the current 265 * result bitmap from the previous example, 0x02: 266 * 267 * :: 268 * 269 * rule indices in current field: 0 1 2 270 * map to rules in next field: 0 1 1 271 * 272 * the new result bitmap will be 0x02: rule 1 was set, and rule 1 will be 273 * set. 274 * 275 * We can now extend this example to cover the second iteration of the step 276 * above (lookup and AND bitmap): assuming the port field is 277 * 2048 < 0 0 5 0 >, with starting result bitmap 0x2, and lookup table 278 * for "port" field from pre-computation example: 279 * 280 * :: 281 * 282 * bucket 283 * group 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 284 * 0 0,1 285 * 1 0,1 286 * 2 0 1 287 * 3 0,1 288 * 289 * operations are: 0x2 & 0x3 [bucket 0] & 0x3 [bucket 0] & 0x2 [bucket 5] 290 * & 0x3 [bucket 0], resulting bitmap is 0x2. 291 * 292 * - if this is the last field in the set, look up the value from the mapping 293 * array corresponding to the final result bitmap 294 * 295 * Example: 0x2 resulting bitmap from 192.168.1.5:2048, mapping array for 296 * last field from insertion example: 297 * 298 * :: 299 * 300 * rule indices in last field: 0 1 301 * map to elements: 0x66 0x42 302 * 303 * the matching element is at 0x42. 304 * 305 * 306 * References 307 * ---------- 308 * 309 * [Ligatti 2010] 310 * A Packet-classification Algorithm for Arbitrary Bitmask Rules, with 311 * Automatic Time-space Tradeoffs 312 * Jay Ligatti, Josh Kuhn, and Chris Gage. 313 * Proceedings of the IEEE International Conference on Computer 314 * Communication Networks (ICCCN), August 2010. 315 * https://www.cse.usf.edu/~ligatti/papers/grouper-conf.pdf 316 * 317 * [Rottenstreich 2010] 318 * Worst-Case TCAM Rule Expansion 319 * Ori Rottenstreich and Isaac Keslassy. 320 * 2010 Proceedings IEEE INFOCOM, San Diego, CA, 2010. 321 * http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.212.4592&rep=rep1&type=pdf 322 * 323 * [Kogan 2014] 324 * SAX-PAC (Scalable And eXpressive PAcket Classification) 325 * Kirill Kogan, Sergey Nikolenko, Ori Rottenstreich, William Culhane, 326 * and Patrick Eugster. 327 * Proceedings of the 2014 ACM conference on SIGCOMM, August 2014. 328 * https://www.sigcomm.org/sites/default/files/ccr/papers/2014/August/2619239-2626294.pdf 329 */ 330 331 #include <linux/kernel.h> 332 #include <linux/init.h> 333 #include <linux/module.h> 334 #include <linux/netlink.h> 335 #include <linux/netfilter.h> 336 #include <linux/netfilter/nf_tables.h> 337 #include <net/netfilter/nf_tables_core.h> 338 #include <uapi/linux/netfilter/nf_tables.h> 339 #include <linux/bitmap.h> 340 #include <linux/bitops.h> 341 342 #include "nft_set_pipapo_avx2.h" 343 #include "nft_set_pipapo.h" 344 345 /* Current working bitmap index, toggled between field matches */ 346 static DEFINE_PER_CPU(bool, nft_pipapo_scratch_index); 347 348 /** 349 * pipapo_refill() - For each set bit, set bits from selected mapping table item 350 * @map: Bitmap to be scanned for set bits 351 * @len: Length of bitmap in longs 352 * @rules: Number of rules in field 353 * @dst: Destination bitmap 354 * @mt: Mapping table containing bit set specifiers 355 * @match_only: Find a single bit and return, don't fill 356 * 357 * Iteration over set bits with __builtin_ctzl(): Daniel Lemire, public domain. 358 * 359 * For each bit set in map, select the bucket from mapping table with index 360 * corresponding to the position of the bit set. Use start bit and amount of 361 * bits specified in bucket to fill region in dst. 362 * 363 * Return: -1 on no match, bit position on 'match_only', 0 otherwise. 364 */ 365 int pipapo_refill(unsigned long *map, int len, int rules, unsigned long *dst, 366 union nft_pipapo_map_bucket *mt, bool match_only) 367 { 368 unsigned long bitset; 369 int k, ret = -1; 370 371 for (k = 0; k < len; k++) { 372 bitset = map[k]; 373 while (bitset) { 374 unsigned long t = bitset & -bitset; 375 int r = __builtin_ctzl(bitset); 376 int i = k * BITS_PER_LONG + r; 377 378 if (unlikely(i >= rules)) { 379 map[k] = 0; 380 return -1; 381 } 382 383 if (match_only) { 384 bitmap_clear(map, i, 1); 385 return i; 386 } 387 388 ret = 0; 389 390 bitmap_set(dst, mt[i].to, mt[i].n); 391 392 bitset ^= t; 393 } 394 map[k] = 0; 395 } 396 397 return ret; 398 } 399 400 /** 401 * nft_pipapo_lookup() - Lookup function 402 * @net: Network namespace 403 * @set: nftables API set representation 404 * @key: nftables API element representation containing key data 405 * @ext: nftables API extension pointer, filled with matching reference 406 * 407 * For more details, see DOC: Theory of Operation. 408 * 409 * Return: true on match, false otherwise. 410 */ 411 bool nft_pipapo_lookup(const struct net *net, const struct nft_set *set, 412 const u32 *key, const struct nft_set_ext **ext) 413 { 414 struct nft_pipapo *priv = nft_set_priv(set); 415 unsigned long *res_map, *fill_map; 416 u8 genmask = nft_genmask_cur(net); 417 const u8 *rp = (const u8 *)key; 418 struct nft_pipapo_match *m; 419 struct nft_pipapo_field *f; 420 bool map_index; 421 int i; 422 423 local_bh_disable(); 424 425 map_index = raw_cpu_read(nft_pipapo_scratch_index); 426 427 m = rcu_dereference(priv->match); 428 429 if (unlikely(!m || !*raw_cpu_ptr(m->scratch))) 430 goto out; 431 432 res_map = *raw_cpu_ptr(m->scratch) + (map_index ? m->bsize_max : 0); 433 fill_map = *raw_cpu_ptr(m->scratch) + (map_index ? 0 : m->bsize_max); 434 435 memset(res_map, 0xff, m->bsize_max * sizeof(*res_map)); 436 437 nft_pipapo_for_each_field(f, i, m) { 438 bool last = i == m->field_count - 1; 439 int b; 440 441 /* For each bit group: select lookup table bucket depending on 442 * packet bytes value, then AND bucket value 443 */ 444 if (likely(f->bb == 8)) 445 pipapo_and_field_buckets_8bit(f, res_map, rp); 446 else 447 pipapo_and_field_buckets_4bit(f, res_map, rp); 448 NFT_PIPAPO_GROUP_BITS_ARE_8_OR_4; 449 450 rp += f->groups / NFT_PIPAPO_GROUPS_PER_BYTE(f); 451 452 /* Now populate the bitmap for the next field, unless this is 453 * the last field, in which case return the matched 'ext' 454 * pointer if any. 455 * 456 * Now res_map contains the matching bitmap, and fill_map is the 457 * bitmap for the next field. 458 */ 459 next_match: 460 b = pipapo_refill(res_map, f->bsize, f->rules, fill_map, f->mt, 461 last); 462 if (b < 0) { 463 raw_cpu_write(nft_pipapo_scratch_index, map_index); 464 local_bh_enable(); 465 466 return false; 467 } 468 469 if (last) { 470 *ext = &f->mt[b].e->ext; 471 if (unlikely(nft_set_elem_expired(*ext) || 472 !nft_set_elem_active(*ext, genmask))) 473 goto next_match; 474 475 /* Last field: we're just returning the key without 476 * filling the initial bitmap for the next field, so the 477 * current inactive bitmap is clean and can be reused as 478 * *next* bitmap (not initial) for the next packet. 479 */ 480 raw_cpu_write(nft_pipapo_scratch_index, map_index); 481 local_bh_enable(); 482 483 return true; 484 } 485 486 /* Swap bitmap indices: res_map is the initial bitmap for the 487 * next field, and fill_map is guaranteed to be all-zeroes at 488 * this point. 489 */ 490 map_index = !map_index; 491 swap(res_map, fill_map); 492 493 rp += NFT_PIPAPO_GROUPS_PADDING(f); 494 } 495 496 out: 497 local_bh_enable(); 498 return false; 499 } 500 501 /** 502 * pipapo_get() - Get matching element reference given key data 503 * @net: Network namespace 504 * @set: nftables API set representation 505 * @data: Key data to be matched against existing elements 506 * @genmask: If set, check that element is active in given genmask 507 * 508 * This is essentially the same as the lookup function, except that it matches 509 * key data against the uncommitted copy and doesn't use preallocated maps for 510 * bitmap results. 511 * 512 * Return: pointer to &struct nft_pipapo_elem on match, error pointer otherwise. 513 */ 514 static struct nft_pipapo_elem *pipapo_get(const struct net *net, 515 const struct nft_set *set, 516 const u8 *data, u8 genmask) 517 { 518 struct nft_pipapo_elem *ret = ERR_PTR(-ENOENT); 519 struct nft_pipapo *priv = nft_set_priv(set); 520 struct nft_pipapo_match *m = priv->clone; 521 unsigned long *res_map, *fill_map = NULL; 522 struct nft_pipapo_field *f; 523 int i; 524 525 res_map = kmalloc_array(m->bsize_max, sizeof(*res_map), GFP_ATOMIC); 526 if (!res_map) { 527 ret = ERR_PTR(-ENOMEM); 528 goto out; 529 } 530 531 fill_map = kcalloc(m->bsize_max, sizeof(*res_map), GFP_ATOMIC); 532 if (!fill_map) { 533 ret = ERR_PTR(-ENOMEM); 534 goto out; 535 } 536 537 memset(res_map, 0xff, m->bsize_max * sizeof(*res_map)); 538 539 nft_pipapo_for_each_field(f, i, m) { 540 bool last = i == m->field_count - 1; 541 int b; 542 543 /* For each bit group: select lookup table bucket depending on 544 * packet bytes value, then AND bucket value 545 */ 546 if (f->bb == 8) 547 pipapo_and_field_buckets_8bit(f, res_map, data); 548 else if (f->bb == 4) 549 pipapo_and_field_buckets_4bit(f, res_map, data); 550 else 551 BUG(); 552 553 data += f->groups / NFT_PIPAPO_GROUPS_PER_BYTE(f); 554 555 /* Now populate the bitmap for the next field, unless this is 556 * the last field, in which case return the matched 'ext' 557 * pointer if any. 558 * 559 * Now res_map contains the matching bitmap, and fill_map is the 560 * bitmap for the next field. 561 */ 562 next_match: 563 b = pipapo_refill(res_map, f->bsize, f->rules, fill_map, f->mt, 564 last); 565 if (b < 0) 566 goto out; 567 568 if (last) { 569 if (nft_set_elem_expired(&f->mt[b].e->ext)) 570 goto next_match; 571 if ((genmask && 572 !nft_set_elem_active(&f->mt[b].e->ext, genmask))) 573 goto next_match; 574 575 ret = f->mt[b].e; 576 goto out; 577 } 578 579 data += NFT_PIPAPO_GROUPS_PADDING(f); 580 581 /* Swap bitmap indices: fill_map will be the initial bitmap for 582 * the next field (i.e. the new res_map), and res_map is 583 * guaranteed to be all-zeroes at this point, ready to be filled 584 * according to the next mapping table. 585 */ 586 swap(res_map, fill_map); 587 } 588 589 out: 590 kfree(fill_map); 591 kfree(res_map); 592 return ret; 593 } 594 595 /** 596 * nft_pipapo_get() - Get matching element reference given key data 597 * @net: Network namespace 598 * @set: nftables API set representation 599 * @elem: nftables API element representation containing key data 600 * @flags: Unused 601 */ 602 static void *nft_pipapo_get(const struct net *net, const struct nft_set *set, 603 const struct nft_set_elem *elem, unsigned int flags) 604 { 605 return pipapo_get(net, set, (const u8 *)elem->key.val.data, 606 nft_genmask_cur(net)); 607 } 608 609 /** 610 * pipapo_resize() - Resize lookup or mapping table, or both 611 * @f: Field containing lookup and mapping tables 612 * @old_rules: Previous amount of rules in field 613 * @rules: New amount of rules 614 * 615 * Increase, decrease or maintain tables size depending on new amount of rules, 616 * and copy data over. In case the new size is smaller, throw away data for 617 * highest-numbered rules. 618 * 619 * Return: 0 on success, -ENOMEM on allocation failure. 620 */ 621 static int pipapo_resize(struct nft_pipapo_field *f, int old_rules, int rules) 622 { 623 long *new_lt = NULL, *new_p, *old_lt = f->lt, *old_p; 624 union nft_pipapo_map_bucket *new_mt, *old_mt = f->mt; 625 size_t new_bucket_size, copy; 626 int group, bucket; 627 628 new_bucket_size = DIV_ROUND_UP(rules, BITS_PER_LONG); 629 #ifdef NFT_PIPAPO_ALIGN 630 new_bucket_size = roundup(new_bucket_size, 631 NFT_PIPAPO_ALIGN / sizeof(*new_lt)); 632 #endif 633 634 if (new_bucket_size == f->bsize) 635 goto mt; 636 637 if (new_bucket_size > f->bsize) 638 copy = f->bsize; 639 else 640 copy = new_bucket_size; 641 642 new_lt = kvzalloc(f->groups * NFT_PIPAPO_BUCKETS(f->bb) * 643 new_bucket_size * sizeof(*new_lt) + 644 NFT_PIPAPO_ALIGN_HEADROOM, 645 GFP_KERNEL); 646 if (!new_lt) 647 return -ENOMEM; 648 649 new_p = NFT_PIPAPO_LT_ALIGN(new_lt); 650 old_p = NFT_PIPAPO_LT_ALIGN(old_lt); 651 652 for (group = 0; group < f->groups; group++) { 653 for (bucket = 0; bucket < NFT_PIPAPO_BUCKETS(f->bb); bucket++) { 654 memcpy(new_p, old_p, copy * sizeof(*new_p)); 655 new_p += copy; 656 old_p += copy; 657 658 if (new_bucket_size > f->bsize) 659 new_p += new_bucket_size - f->bsize; 660 else 661 old_p += f->bsize - new_bucket_size; 662 } 663 } 664 665 mt: 666 new_mt = kvmalloc(rules * sizeof(*new_mt), GFP_KERNEL); 667 if (!new_mt) { 668 kvfree(new_lt); 669 return -ENOMEM; 670 } 671 672 memcpy(new_mt, f->mt, min(old_rules, rules) * sizeof(*new_mt)); 673 if (rules > old_rules) { 674 memset(new_mt + old_rules, 0, 675 (rules - old_rules) * sizeof(*new_mt)); 676 } 677 678 if (new_lt) { 679 f->bsize = new_bucket_size; 680 NFT_PIPAPO_LT_ASSIGN(f, new_lt); 681 kvfree(old_lt); 682 } 683 684 f->mt = new_mt; 685 kvfree(old_mt); 686 687 return 0; 688 } 689 690 /** 691 * pipapo_bucket_set() - Set rule bit in bucket given group and group value 692 * @f: Field containing lookup table 693 * @rule: Rule index 694 * @group: Group index 695 * @v: Value of bit group 696 */ 697 static void pipapo_bucket_set(struct nft_pipapo_field *f, int rule, int group, 698 int v) 699 { 700 unsigned long *pos; 701 702 pos = NFT_PIPAPO_LT_ALIGN(f->lt); 703 pos += f->bsize * NFT_PIPAPO_BUCKETS(f->bb) * group; 704 pos += f->bsize * v; 705 706 __set_bit(rule, pos); 707 } 708 709 /** 710 * pipapo_lt_4b_to_8b() - Switch lookup table group width from 4 bits to 8 bits 711 * @old_groups: Number of current groups 712 * @bsize: Size of one bucket, in longs 713 * @old_lt: Pointer to the current lookup table 714 * @new_lt: Pointer to the new, pre-allocated lookup table 715 * 716 * Each bucket with index b in the new lookup table, belonging to group g, is 717 * filled with the bit intersection between: 718 * - bucket with index given by the upper 4 bits of b, from group g, and 719 * - bucket with index given by the lower 4 bits of b, from group g + 1 720 * 721 * That is, given buckets from the new lookup table N(x, y) and the old lookup 722 * table O(x, y), with x bucket index, and y group index: 723 * 724 * N(b, g) := O(b / 16, g) & O(b % 16, g + 1) 725 * 726 * This ensures equivalence of the matching results on lookup. Two examples in 727 * pictures: 728 * 729 * bucket 730 * group 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 ... 254 255 731 * 0 ^ 732 * 1 | ^ 733 * ... ( & ) | 734 * / \ | 735 * / \ .-( & )-. 736 * / bucket \ | | 737 * group 0 / 1 2 3 \ 4 5 6 7 8 9 10 11 12 13 |14 15 | 738 * 0 / \ | | 739 * 1 \ | | 740 * 2 | --' 741 * 3 '- 742 * ... 743 */ 744 static void pipapo_lt_4b_to_8b(int old_groups, int bsize, 745 unsigned long *old_lt, unsigned long *new_lt) 746 { 747 int g, b, i; 748 749 for (g = 0; g < old_groups / 2; g++) { 750 int src_g0 = g * 2, src_g1 = g * 2 + 1; 751 752 for (b = 0; b < NFT_PIPAPO_BUCKETS(8); b++) { 753 int src_b0 = b / NFT_PIPAPO_BUCKETS(4); 754 int src_b1 = b % NFT_PIPAPO_BUCKETS(4); 755 int src_i0 = src_g0 * NFT_PIPAPO_BUCKETS(4) + src_b0; 756 int src_i1 = src_g1 * NFT_PIPAPO_BUCKETS(4) + src_b1; 757 758 for (i = 0; i < bsize; i++) { 759 *new_lt = old_lt[src_i0 * bsize + i] & 760 old_lt[src_i1 * bsize + i]; 761 new_lt++; 762 } 763 } 764 } 765 } 766 767 /** 768 * pipapo_lt_8b_to_4b() - Switch lookup table group width from 8 bits to 4 bits 769 * @old_groups: Number of current groups 770 * @bsize: Size of one bucket, in longs 771 * @old_lt: Pointer to the current lookup table 772 * @new_lt: Pointer to the new, pre-allocated lookup table 773 * 774 * Each bucket with index b in the new lookup table, belonging to group g, is 775 * filled with the bit union of: 776 * - all the buckets with index such that the upper four bits of the lower byte 777 * equal b, from group g, with g odd 778 * - all the buckets with index such that the lower four bits equal b, from 779 * group g, with g even 780 * 781 * That is, given buckets from the new lookup table N(x, y) and the old lookup 782 * table O(x, y), with x bucket index, and y group index: 783 * 784 * - with g odd: N(b, g) := U(O(x, g) for each x : x = (b & 0xf0) >> 4) 785 * - with g even: N(b, g) := U(O(x, g) for each x : x = b & 0x0f) 786 * 787 * where U() denotes the arbitrary union operation (binary OR of n terms). This 788 * ensures equivalence of the matching results on lookup. 789 */ 790 static void pipapo_lt_8b_to_4b(int old_groups, int bsize, 791 unsigned long *old_lt, unsigned long *new_lt) 792 { 793 int g, b, bsrc, i; 794 795 memset(new_lt, 0, old_groups * 2 * NFT_PIPAPO_BUCKETS(4) * bsize * 796 sizeof(unsigned long)); 797 798 for (g = 0; g < old_groups * 2; g += 2) { 799 int src_g = g / 2; 800 801 for (b = 0; b < NFT_PIPAPO_BUCKETS(4); b++) { 802 for (bsrc = NFT_PIPAPO_BUCKETS(8) * src_g; 803 bsrc < NFT_PIPAPO_BUCKETS(8) * (src_g + 1); 804 bsrc++) { 805 if (((bsrc & 0xf0) >> 4) != b) 806 continue; 807 808 for (i = 0; i < bsize; i++) 809 new_lt[i] |= old_lt[bsrc * bsize + i]; 810 } 811 812 new_lt += bsize; 813 } 814 815 for (b = 0; b < NFT_PIPAPO_BUCKETS(4); b++) { 816 for (bsrc = NFT_PIPAPO_BUCKETS(8) * src_g; 817 bsrc < NFT_PIPAPO_BUCKETS(8) * (src_g + 1); 818 bsrc++) { 819 if ((bsrc & 0x0f) != b) 820 continue; 821 822 for (i = 0; i < bsize; i++) 823 new_lt[i] |= old_lt[bsrc * bsize + i]; 824 } 825 826 new_lt += bsize; 827 } 828 } 829 } 830 831 /** 832 * pipapo_lt_bits_adjust() - Adjust group size for lookup table if needed 833 * @f: Field containing lookup table 834 */ 835 static void pipapo_lt_bits_adjust(struct nft_pipapo_field *f) 836 { 837 unsigned long *new_lt; 838 int groups, bb; 839 size_t lt_size; 840 841 lt_size = f->groups * NFT_PIPAPO_BUCKETS(f->bb) * f->bsize * 842 sizeof(*f->lt); 843 844 if (f->bb == NFT_PIPAPO_GROUP_BITS_SMALL_SET && 845 lt_size > NFT_PIPAPO_LT_SIZE_HIGH) { 846 groups = f->groups * 2; 847 bb = NFT_PIPAPO_GROUP_BITS_LARGE_SET; 848 849 lt_size = groups * NFT_PIPAPO_BUCKETS(bb) * f->bsize * 850 sizeof(*f->lt); 851 } else if (f->bb == NFT_PIPAPO_GROUP_BITS_LARGE_SET && 852 lt_size < NFT_PIPAPO_LT_SIZE_LOW) { 853 groups = f->groups / 2; 854 bb = NFT_PIPAPO_GROUP_BITS_SMALL_SET; 855 856 lt_size = groups * NFT_PIPAPO_BUCKETS(bb) * f->bsize * 857 sizeof(*f->lt); 858 859 /* Don't increase group width if the resulting lookup table size 860 * would exceed the upper size threshold for a "small" set. 861 */ 862 if (lt_size > NFT_PIPAPO_LT_SIZE_HIGH) 863 return; 864 } else { 865 return; 866 } 867 868 new_lt = kvzalloc(lt_size + NFT_PIPAPO_ALIGN_HEADROOM, GFP_KERNEL); 869 if (!new_lt) 870 return; 871 872 NFT_PIPAPO_GROUP_BITS_ARE_8_OR_4; 873 if (f->bb == 4 && bb == 8) { 874 pipapo_lt_4b_to_8b(f->groups, f->bsize, 875 NFT_PIPAPO_LT_ALIGN(f->lt), 876 NFT_PIPAPO_LT_ALIGN(new_lt)); 877 } else if (f->bb == 8 && bb == 4) { 878 pipapo_lt_8b_to_4b(f->groups, f->bsize, 879 NFT_PIPAPO_LT_ALIGN(f->lt), 880 NFT_PIPAPO_LT_ALIGN(new_lt)); 881 } else { 882 BUG(); 883 } 884 885 f->groups = groups; 886 f->bb = bb; 887 kvfree(f->lt); 888 NFT_PIPAPO_LT_ASSIGN(f, new_lt); 889 } 890 891 /** 892 * pipapo_insert() - Insert new rule in field given input key and mask length 893 * @f: Field containing lookup table 894 * @k: Input key for classification, without nftables padding 895 * @mask_bits: Length of mask; matches field length for non-ranged entry 896 * 897 * Insert a new rule reference in lookup buckets corresponding to k and 898 * mask_bits. 899 * 900 * Return: 1 on success (one rule inserted), negative error code on failure. 901 */ 902 static int pipapo_insert(struct nft_pipapo_field *f, const uint8_t *k, 903 int mask_bits) 904 { 905 int rule = f->rules, group, ret, bit_offset = 0; 906 907 ret = pipapo_resize(f, f->rules, f->rules + 1); 908 if (ret) 909 return ret; 910 911 f->rules++; 912 913 for (group = 0; group < f->groups; group++) { 914 int i, v; 915 u8 mask; 916 917 v = k[group / (BITS_PER_BYTE / f->bb)]; 918 v &= GENMASK(BITS_PER_BYTE - bit_offset - 1, 0); 919 v >>= (BITS_PER_BYTE - bit_offset) - f->bb; 920 921 bit_offset += f->bb; 922 bit_offset %= BITS_PER_BYTE; 923 924 if (mask_bits >= (group + 1) * f->bb) { 925 /* Not masked */ 926 pipapo_bucket_set(f, rule, group, v); 927 } else if (mask_bits <= group * f->bb) { 928 /* Completely masked */ 929 for (i = 0; i < NFT_PIPAPO_BUCKETS(f->bb); i++) 930 pipapo_bucket_set(f, rule, group, i); 931 } else { 932 /* The mask limit falls on this group */ 933 mask = GENMASK(f->bb - 1, 0); 934 mask >>= mask_bits - group * f->bb; 935 for (i = 0; i < NFT_PIPAPO_BUCKETS(f->bb); i++) { 936 if ((i & ~mask) == (v & ~mask)) 937 pipapo_bucket_set(f, rule, group, i); 938 } 939 } 940 } 941 942 pipapo_lt_bits_adjust(f); 943 944 return 1; 945 } 946 947 /** 948 * pipapo_step_diff() - Check if setting @step bit in netmask would change it 949 * @base: Mask we are expanding 950 * @step: Step bit for given expansion step 951 * @len: Total length of mask space (set and unset bits), bytes 952 * 953 * Convenience function for mask expansion. 954 * 955 * Return: true if step bit changes mask (i.e. isn't set), false otherwise. 956 */ 957 static bool pipapo_step_diff(u8 *base, int step, int len) 958 { 959 /* Network order, byte-addressed */ 960 #ifdef __BIG_ENDIAN__ 961 return !(BIT(step % BITS_PER_BYTE) & base[step / BITS_PER_BYTE]); 962 #else 963 return !(BIT(step % BITS_PER_BYTE) & 964 base[len - 1 - step / BITS_PER_BYTE]); 965 #endif 966 } 967 968 /** 969 * pipapo_step_after_end() - Check if mask exceeds range end with given step 970 * @base: Mask we are expanding 971 * @end: End of range 972 * @step: Step bit for given expansion step, highest bit to be set 973 * @len: Total length of mask space (set and unset bits), bytes 974 * 975 * Convenience function for mask expansion. 976 * 977 * Return: true if mask exceeds range setting step bits, false otherwise. 978 */ 979 static bool pipapo_step_after_end(const u8 *base, const u8 *end, int step, 980 int len) 981 { 982 u8 tmp[NFT_PIPAPO_MAX_BYTES]; 983 int i; 984 985 memcpy(tmp, base, len); 986 987 /* Network order, byte-addressed */ 988 for (i = 0; i <= step; i++) 989 #ifdef __BIG_ENDIAN__ 990 tmp[i / BITS_PER_BYTE] |= BIT(i % BITS_PER_BYTE); 991 #else 992 tmp[len - 1 - i / BITS_PER_BYTE] |= BIT(i % BITS_PER_BYTE); 993 #endif 994 995 return memcmp(tmp, end, len) > 0; 996 } 997 998 /** 999 * pipapo_base_sum() - Sum step bit to given len-sized netmask base with carry 1000 * @base: Netmask base 1001 * @step: Step bit to sum 1002 * @len: Netmask length, bytes 1003 */ 1004 static void pipapo_base_sum(u8 *base, int step, int len) 1005 { 1006 bool carry = false; 1007 int i; 1008 1009 /* Network order, byte-addressed */ 1010 #ifdef __BIG_ENDIAN__ 1011 for (i = step / BITS_PER_BYTE; i < len; i++) { 1012 #else 1013 for (i = len - 1 - step / BITS_PER_BYTE; i >= 0; i--) { 1014 #endif 1015 if (carry) 1016 base[i]++; 1017 else 1018 base[i] += 1 << (step % BITS_PER_BYTE); 1019 1020 if (base[i]) 1021 break; 1022 1023 carry = true; 1024 } 1025 } 1026 1027 /** 1028 * pipapo_expand() - Expand to composing netmasks, insert into lookup table 1029 * @f: Field containing lookup table 1030 * @start: Start of range 1031 * @end: End of range 1032 * @len: Length of value in bits 1033 * 1034 * Expand range to composing netmasks and insert corresponding rule references 1035 * in lookup buckets. 1036 * 1037 * Return: number of inserted rules on success, negative error code on failure. 1038 */ 1039 static int pipapo_expand(struct nft_pipapo_field *f, 1040 const u8 *start, const u8 *end, int len) 1041 { 1042 int step, masks = 0, bytes = DIV_ROUND_UP(len, BITS_PER_BYTE); 1043 u8 base[NFT_PIPAPO_MAX_BYTES]; 1044 1045 memcpy(base, start, bytes); 1046 while (memcmp(base, end, bytes) <= 0) { 1047 int err; 1048 1049 step = 0; 1050 while (pipapo_step_diff(base, step, bytes)) { 1051 if (pipapo_step_after_end(base, end, step, bytes)) 1052 break; 1053 1054 step++; 1055 if (step >= len) { 1056 if (!masks) { 1057 err = pipapo_insert(f, base, 0); 1058 if (err < 0) 1059 return err; 1060 masks = 1; 1061 } 1062 goto out; 1063 } 1064 } 1065 1066 err = pipapo_insert(f, base, len - step); 1067 1068 if (err < 0) 1069 return err; 1070 1071 masks++; 1072 pipapo_base_sum(base, step, bytes); 1073 } 1074 out: 1075 return masks; 1076 } 1077 1078 /** 1079 * pipapo_map() - Insert rules in mapping tables, mapping them between fields 1080 * @m: Matching data, including mapping table 1081 * @map: Table of rule maps: array of first rule and amount of rules 1082 * in next field a given rule maps to, for each field 1083 * @e: For last field, nft_set_ext pointer matching rules map to 1084 */ 1085 static void pipapo_map(struct nft_pipapo_match *m, 1086 union nft_pipapo_map_bucket map[NFT_PIPAPO_MAX_FIELDS], 1087 struct nft_pipapo_elem *e) 1088 { 1089 struct nft_pipapo_field *f; 1090 int i, j; 1091 1092 for (i = 0, f = m->f; i < m->field_count - 1; i++, f++) { 1093 for (j = 0; j < map[i].n; j++) { 1094 f->mt[map[i].to + j].to = map[i + 1].to; 1095 f->mt[map[i].to + j].n = map[i + 1].n; 1096 } 1097 } 1098 1099 /* Last field: map to ext instead of mapping to next field */ 1100 for (j = 0; j < map[i].n; j++) 1101 f->mt[map[i].to + j].e = e; 1102 } 1103 1104 /** 1105 * pipapo_realloc_scratch() - Reallocate scratch maps for partial match results 1106 * @clone: Copy of matching data with pending insertions and deletions 1107 * @bsize_max: Maximum bucket size, scratch maps cover two buckets 1108 * 1109 * Return: 0 on success, -ENOMEM on failure. 1110 */ 1111 static int pipapo_realloc_scratch(struct nft_pipapo_match *clone, 1112 unsigned long bsize_max) 1113 { 1114 int i; 1115 1116 for_each_possible_cpu(i) { 1117 unsigned long *scratch; 1118 #ifdef NFT_PIPAPO_ALIGN 1119 unsigned long *scratch_aligned; 1120 #endif 1121 1122 scratch = kzalloc_node(bsize_max * sizeof(*scratch) * 2 + 1123 NFT_PIPAPO_ALIGN_HEADROOM, 1124 GFP_KERNEL, cpu_to_node(i)); 1125 if (!scratch) { 1126 /* On failure, there's no need to undo previous 1127 * allocations: this means that some scratch maps have 1128 * a bigger allocated size now (this is only called on 1129 * insertion), but the extra space won't be used by any 1130 * CPU as new elements are not inserted and m->bsize_max 1131 * is not updated. 1132 */ 1133 return -ENOMEM; 1134 } 1135 1136 kfree(*per_cpu_ptr(clone->scratch, i)); 1137 1138 *per_cpu_ptr(clone->scratch, i) = scratch; 1139 1140 #ifdef NFT_PIPAPO_ALIGN 1141 scratch_aligned = NFT_PIPAPO_LT_ALIGN(scratch); 1142 *per_cpu_ptr(clone->scratch_aligned, i) = scratch_aligned; 1143 #endif 1144 } 1145 1146 return 0; 1147 } 1148 1149 /** 1150 * nft_pipapo_insert() - Validate and insert ranged elements 1151 * @net: Network namespace 1152 * @set: nftables API set representation 1153 * @elem: nftables API element representation containing key data 1154 * @ext2: Filled with pointer to &struct nft_set_ext in inserted element 1155 * 1156 * Return: 0 on success, error pointer on failure. 1157 */ 1158 static int nft_pipapo_insert(const struct net *net, const struct nft_set *set, 1159 const struct nft_set_elem *elem, 1160 struct nft_set_ext **ext2) 1161 { 1162 const struct nft_set_ext *ext = nft_set_elem_ext(set, elem->priv); 1163 union nft_pipapo_map_bucket rulemap[NFT_PIPAPO_MAX_FIELDS]; 1164 const u8 *start = (const u8 *)elem->key.val.data, *end; 1165 struct nft_pipapo_elem *e = elem->priv, *dup; 1166 struct nft_pipapo *priv = nft_set_priv(set); 1167 struct nft_pipapo_match *m = priv->clone; 1168 u8 genmask = nft_genmask_next(net); 1169 struct nft_pipapo_field *f; 1170 const u8 *start_p, *end_p; 1171 int i, bsize_max, err = 0; 1172 1173 if (nft_set_ext_exists(ext, NFT_SET_EXT_KEY_END)) 1174 end = (const u8 *)nft_set_ext_key_end(ext)->data; 1175 else 1176 end = start; 1177 1178 dup = pipapo_get(net, set, start, genmask); 1179 if (!IS_ERR(dup)) { 1180 /* Check if we already have the same exact entry */ 1181 const struct nft_data *dup_key, *dup_end; 1182 1183 dup_key = nft_set_ext_key(&dup->ext); 1184 if (nft_set_ext_exists(&dup->ext, NFT_SET_EXT_KEY_END)) 1185 dup_end = nft_set_ext_key_end(&dup->ext); 1186 else 1187 dup_end = dup_key; 1188 1189 if (!memcmp(start, dup_key->data, sizeof(*dup_key->data)) && 1190 !memcmp(end, dup_end->data, sizeof(*dup_end->data))) { 1191 *ext2 = &dup->ext; 1192 return -EEXIST; 1193 } 1194 1195 return -ENOTEMPTY; 1196 } 1197 1198 if (PTR_ERR(dup) == -ENOENT) { 1199 /* Look for partially overlapping entries */ 1200 dup = pipapo_get(net, set, end, nft_genmask_next(net)); 1201 } 1202 1203 if (PTR_ERR(dup) != -ENOENT) { 1204 if (IS_ERR(dup)) 1205 return PTR_ERR(dup); 1206 *ext2 = &dup->ext; 1207 return -ENOTEMPTY; 1208 } 1209 1210 /* Validate */ 1211 start_p = start; 1212 end_p = end; 1213 nft_pipapo_for_each_field(f, i, m) { 1214 if (f->rules >= (unsigned long)NFT_PIPAPO_RULE0_MAX) 1215 return -ENOSPC; 1216 1217 if (memcmp(start_p, end_p, 1218 f->groups / NFT_PIPAPO_GROUPS_PER_BYTE(f)) > 0) 1219 return -EINVAL; 1220 1221 start_p += NFT_PIPAPO_GROUPS_PADDED_SIZE(f); 1222 end_p += NFT_PIPAPO_GROUPS_PADDED_SIZE(f); 1223 } 1224 1225 /* Insert */ 1226 priv->dirty = true; 1227 1228 bsize_max = m->bsize_max; 1229 1230 nft_pipapo_for_each_field(f, i, m) { 1231 int ret; 1232 1233 rulemap[i].to = f->rules; 1234 1235 ret = memcmp(start, end, 1236 f->groups / NFT_PIPAPO_GROUPS_PER_BYTE(f)); 1237 if (!ret) 1238 ret = pipapo_insert(f, start, f->groups * f->bb); 1239 else 1240 ret = pipapo_expand(f, start, end, f->groups * f->bb); 1241 1242 if (ret < 0) 1243 return ret; 1244 1245 if (f->bsize > bsize_max) 1246 bsize_max = f->bsize; 1247 1248 rulemap[i].n = ret; 1249 1250 start += NFT_PIPAPO_GROUPS_PADDED_SIZE(f); 1251 end += NFT_PIPAPO_GROUPS_PADDED_SIZE(f); 1252 } 1253 1254 if (!*get_cpu_ptr(m->scratch) || bsize_max > m->bsize_max) { 1255 put_cpu_ptr(m->scratch); 1256 1257 err = pipapo_realloc_scratch(m, bsize_max); 1258 if (err) 1259 return err; 1260 1261 m->bsize_max = bsize_max; 1262 } else { 1263 put_cpu_ptr(m->scratch); 1264 } 1265 1266 *ext2 = &e->ext; 1267 1268 pipapo_map(m, rulemap, e); 1269 1270 return 0; 1271 } 1272 1273 /** 1274 * pipapo_clone() - Clone matching data to create new working copy 1275 * @old: Existing matching data 1276 * 1277 * Return: copy of matching data passed as 'old', error pointer on failure 1278 */ 1279 static struct nft_pipapo_match *pipapo_clone(struct nft_pipapo_match *old) 1280 { 1281 struct nft_pipapo_field *dst, *src; 1282 struct nft_pipapo_match *new; 1283 int i; 1284 1285 new = kmalloc(struct_size(new, f, old->field_count), GFP_KERNEL); 1286 if (!new) 1287 return ERR_PTR(-ENOMEM); 1288 1289 new->field_count = old->field_count; 1290 new->bsize_max = old->bsize_max; 1291 1292 new->scratch = alloc_percpu(*new->scratch); 1293 if (!new->scratch) 1294 goto out_scratch; 1295 1296 #ifdef NFT_PIPAPO_ALIGN 1297 new->scratch_aligned = alloc_percpu(*new->scratch_aligned); 1298 if (!new->scratch_aligned) 1299 goto out_scratch; 1300 #endif 1301 for_each_possible_cpu(i) 1302 *per_cpu_ptr(new->scratch, i) = NULL; 1303 1304 if (pipapo_realloc_scratch(new, old->bsize_max)) 1305 goto out_scratch_realloc; 1306 1307 rcu_head_init(&new->rcu); 1308 1309 src = old->f; 1310 dst = new->f; 1311 1312 for (i = 0; i < old->field_count; i++) { 1313 unsigned long *new_lt; 1314 1315 memcpy(dst, src, offsetof(struct nft_pipapo_field, lt)); 1316 1317 new_lt = kvzalloc(src->groups * NFT_PIPAPO_BUCKETS(src->bb) * 1318 src->bsize * sizeof(*dst->lt) + 1319 NFT_PIPAPO_ALIGN_HEADROOM, 1320 GFP_KERNEL); 1321 if (!new_lt) 1322 goto out_lt; 1323 1324 NFT_PIPAPO_LT_ASSIGN(dst, new_lt); 1325 1326 memcpy(NFT_PIPAPO_LT_ALIGN(new_lt), 1327 NFT_PIPAPO_LT_ALIGN(src->lt), 1328 src->bsize * sizeof(*dst->lt) * 1329 src->groups * NFT_PIPAPO_BUCKETS(src->bb)); 1330 1331 dst->mt = kvmalloc(src->rules * sizeof(*src->mt), GFP_KERNEL); 1332 if (!dst->mt) 1333 goto out_mt; 1334 1335 memcpy(dst->mt, src->mt, src->rules * sizeof(*src->mt)); 1336 src++; 1337 dst++; 1338 } 1339 1340 return new; 1341 1342 out_mt: 1343 kvfree(dst->lt); 1344 out_lt: 1345 for (dst--; i > 0; i--) { 1346 kvfree(dst->mt); 1347 kvfree(dst->lt); 1348 dst--; 1349 } 1350 out_scratch_realloc: 1351 for_each_possible_cpu(i) 1352 kfree(*per_cpu_ptr(new->scratch, i)); 1353 #ifdef NFT_PIPAPO_ALIGN 1354 free_percpu(new->scratch_aligned); 1355 #endif 1356 out_scratch: 1357 free_percpu(new->scratch); 1358 kfree(new); 1359 1360 return ERR_PTR(-ENOMEM); 1361 } 1362 1363 /** 1364 * pipapo_rules_same_key() - Get number of rules originated from the same entry 1365 * @f: Field containing mapping table 1366 * @first: Index of first rule in set of rules mapping to same entry 1367 * 1368 * Using the fact that all rules in a field that originated from the same entry 1369 * will map to the same set of rules in the next field, or to the same element 1370 * reference, return the cardinality of the set of rules that originated from 1371 * the same entry as the rule with index @first, @first rule included. 1372 * 1373 * In pictures: 1374 * rules 1375 * field #0 0 1 2 3 4 1376 * map to: 0 1 2-4 2-4 5-9 1377 * . . ....... . ... 1378 * | | | | \ \ 1379 * | | | | \ \ 1380 * | | | | \ \ 1381 * ' ' ' ' ' \ 1382 * in field #1 0 1 2 3 4 5 ... 1383 * 1384 * if this is called for rule 2 on field #0, it will return 3, as also rules 2 1385 * and 3 in field 0 map to the same set of rules (2, 3, 4) in the next field. 1386 * 1387 * For the last field in a set, we can rely on associated entries to map to the 1388 * same element references. 1389 * 1390 * Return: Number of rules that originated from the same entry as @first. 1391 */ 1392 static int pipapo_rules_same_key(struct nft_pipapo_field *f, int first) 1393 { 1394 struct nft_pipapo_elem *e = NULL; /* Keep gcc happy */ 1395 int r; 1396 1397 for (r = first; r < f->rules; r++) { 1398 if (r != first && e != f->mt[r].e) 1399 return r - first; 1400 1401 e = f->mt[r].e; 1402 } 1403 1404 if (r != first) 1405 return r - first; 1406 1407 return 0; 1408 } 1409 1410 /** 1411 * pipapo_unmap() - Remove rules from mapping tables, renumber remaining ones 1412 * @mt: Mapping array 1413 * @rules: Original amount of rules in mapping table 1414 * @start: First rule index to be removed 1415 * @n: Amount of rules to be removed 1416 * @to_offset: First rule index, in next field, this group of rules maps to 1417 * @is_last: If this is the last field, delete reference from mapping array 1418 * 1419 * This is used to unmap rules from the mapping table for a single field, 1420 * maintaining consistency and compactness for the existing ones. 1421 * 1422 * In pictures: let's assume that we want to delete rules 2 and 3 from the 1423 * following mapping array: 1424 * 1425 * rules 1426 * 0 1 2 3 4 1427 * map to: 4-10 4-10 11-15 11-15 16-18 1428 * 1429 * the result will be: 1430 * 1431 * rules 1432 * 0 1 2 1433 * map to: 4-10 4-10 11-13 1434 * 1435 * for fields before the last one. In case this is the mapping table for the 1436 * last field in a set, and rules map to pointers to &struct nft_pipapo_elem: 1437 * 1438 * rules 1439 * 0 1 2 3 4 1440 * element pointers: 0x42 0x42 0x33 0x33 0x44 1441 * 1442 * the result will be: 1443 * 1444 * rules 1445 * 0 1 2 1446 * element pointers: 0x42 0x42 0x44 1447 */ 1448 static void pipapo_unmap(union nft_pipapo_map_bucket *mt, int rules, 1449 int start, int n, int to_offset, bool is_last) 1450 { 1451 int i; 1452 1453 memmove(mt + start, mt + start + n, (rules - start - n) * sizeof(*mt)); 1454 memset(mt + rules - n, 0, n * sizeof(*mt)); 1455 1456 if (is_last) 1457 return; 1458 1459 for (i = start; i < rules - n; i++) 1460 mt[i].to -= to_offset; 1461 } 1462 1463 /** 1464 * pipapo_drop() - Delete entry from lookup and mapping tables, given rule map 1465 * @m: Matching data 1466 * @rulemap: Table of rule maps, arrays of first rule and amount of rules 1467 * in next field a given entry maps to, for each field 1468 * 1469 * For each rule in lookup table buckets mapping to this set of rules, drop 1470 * all bits set in lookup table mapping. In pictures, assuming we want to drop 1471 * rules 0 and 1 from this lookup table: 1472 * 1473 * bucket 1474 * group 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 1475 * 0 0 1,2 1476 * 1 1,2 0 1477 * 2 0 1,2 1478 * 3 0 1,2 1479 * 4 0,1,2 1480 * 5 0 1 2 1481 * 6 0,1,2 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1482 * 7 1,2 1,2 1 1 1 0,1 1 1 1 1 1 1 1 1 1 1 1483 * 1484 * rule 2 becomes rule 0, and the result will be: 1485 * 1486 * bucket 1487 * group 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 1488 * 0 0 1489 * 1 0 1490 * 2 0 1491 * 3 0 1492 * 4 0 1493 * 5 0 1494 * 6 0 1495 * 7 0 0 1496 * 1497 * once this is done, call unmap() to drop all the corresponding rule references 1498 * from mapping tables. 1499 */ 1500 static void pipapo_drop(struct nft_pipapo_match *m, 1501 union nft_pipapo_map_bucket rulemap[]) 1502 { 1503 struct nft_pipapo_field *f; 1504 int i; 1505 1506 nft_pipapo_for_each_field(f, i, m) { 1507 int g; 1508 1509 for (g = 0; g < f->groups; g++) { 1510 unsigned long *pos; 1511 int b; 1512 1513 pos = NFT_PIPAPO_LT_ALIGN(f->lt) + g * 1514 NFT_PIPAPO_BUCKETS(f->bb) * f->bsize; 1515 1516 for (b = 0; b < NFT_PIPAPO_BUCKETS(f->bb); b++) { 1517 bitmap_cut(pos, pos, rulemap[i].to, 1518 rulemap[i].n, 1519 f->bsize * BITS_PER_LONG); 1520 1521 pos += f->bsize; 1522 } 1523 } 1524 1525 pipapo_unmap(f->mt, f->rules, rulemap[i].to, rulemap[i].n, 1526 rulemap[i + 1].n, i == m->field_count - 1); 1527 if (pipapo_resize(f, f->rules, f->rules - rulemap[i].n)) { 1528 /* We can ignore this, a failure to shrink tables down 1529 * doesn't make tables invalid. 1530 */ 1531 ; 1532 } 1533 f->rules -= rulemap[i].n; 1534 1535 pipapo_lt_bits_adjust(f); 1536 } 1537 } 1538 1539 static void nft_pipapo_gc_deactivate(struct net *net, struct nft_set *set, 1540 struct nft_pipapo_elem *e) 1541 1542 { 1543 struct nft_set_elem elem = { 1544 .priv = e, 1545 }; 1546 1547 nft_setelem_data_deactivate(net, set, &elem); 1548 } 1549 1550 /** 1551 * pipapo_gc() - Drop expired entries from set, destroy start and end elements 1552 * @_set: nftables API set representation 1553 * @m: Matching data 1554 */ 1555 static void pipapo_gc(const struct nft_set *_set, struct nft_pipapo_match *m) 1556 { 1557 struct nft_set *set = (struct nft_set *) _set; 1558 struct nft_pipapo *priv = nft_set_priv(set); 1559 struct net *net = read_pnet(&set->net); 1560 int rules_f0, first_rule = 0; 1561 struct nft_pipapo_elem *e; 1562 struct nft_trans_gc *gc; 1563 1564 gc = nft_trans_gc_alloc(set, 0, GFP_KERNEL); 1565 if (!gc) 1566 return; 1567 1568 while ((rules_f0 = pipapo_rules_same_key(m->f, first_rule))) { 1569 union nft_pipapo_map_bucket rulemap[NFT_PIPAPO_MAX_FIELDS]; 1570 struct nft_pipapo_field *f; 1571 int i, start, rules_fx; 1572 1573 start = first_rule; 1574 rules_fx = rules_f0; 1575 1576 nft_pipapo_for_each_field(f, i, m) { 1577 rulemap[i].to = start; 1578 rulemap[i].n = rules_fx; 1579 1580 if (i < m->field_count - 1) { 1581 rules_fx = f->mt[start].n; 1582 start = f->mt[start].to; 1583 } 1584 } 1585 1586 /* Pick the last field, and its last index */ 1587 f--; 1588 i--; 1589 e = f->mt[rulemap[i].to].e; 1590 1591 /* synchronous gc never fails, there is no need to set on 1592 * NFT_SET_ELEM_DEAD_BIT. 1593 */ 1594 if (nft_set_elem_expired(&e->ext)) { 1595 priv->dirty = true; 1596 1597 gc = nft_trans_gc_queue_sync(gc, GFP_ATOMIC); 1598 if (!gc) 1599 return; 1600 1601 nft_pipapo_gc_deactivate(net, set, e); 1602 pipapo_drop(m, rulemap); 1603 nft_trans_gc_elem_add(gc, e); 1604 1605 /* And check again current first rule, which is now the 1606 * first we haven't checked. 1607 */ 1608 } else { 1609 first_rule += rules_f0; 1610 } 1611 } 1612 1613 gc = nft_trans_gc_catchall_sync(gc); 1614 if (gc) { 1615 nft_trans_gc_queue_sync_done(gc); 1616 priv->last_gc = jiffies; 1617 } 1618 } 1619 1620 /** 1621 * pipapo_free_fields() - Free per-field tables contained in matching data 1622 * @m: Matching data 1623 */ 1624 static void pipapo_free_fields(struct nft_pipapo_match *m) 1625 { 1626 struct nft_pipapo_field *f; 1627 int i; 1628 1629 nft_pipapo_for_each_field(f, i, m) { 1630 kvfree(f->lt); 1631 kvfree(f->mt); 1632 } 1633 } 1634 1635 static void pipapo_free_match(struct nft_pipapo_match *m) 1636 { 1637 int i; 1638 1639 for_each_possible_cpu(i) 1640 kfree(*per_cpu_ptr(m->scratch, i)); 1641 1642 #ifdef NFT_PIPAPO_ALIGN 1643 free_percpu(m->scratch_aligned); 1644 #endif 1645 free_percpu(m->scratch); 1646 1647 pipapo_free_fields(m); 1648 1649 kfree(m); 1650 } 1651 1652 /** 1653 * pipapo_reclaim_match - RCU callback to free fields from old matching data 1654 * @rcu: RCU head 1655 */ 1656 static void pipapo_reclaim_match(struct rcu_head *rcu) 1657 { 1658 struct nft_pipapo_match *m; 1659 1660 m = container_of(rcu, struct nft_pipapo_match, rcu); 1661 pipapo_free_match(m); 1662 } 1663 1664 /** 1665 * nft_pipapo_commit() - Replace lookup data with current working copy 1666 * @set: nftables API set representation 1667 * 1668 * While at it, check if we should perform garbage collection on the working 1669 * copy before committing it for lookup, and don't replace the table if the 1670 * working copy doesn't have pending changes. 1671 * 1672 * We also need to create a new working copy for subsequent insertions and 1673 * deletions. 1674 */ 1675 static void nft_pipapo_commit(const struct nft_set *set) 1676 { 1677 struct nft_pipapo *priv = nft_set_priv(set); 1678 struct nft_pipapo_match *new_clone, *old; 1679 1680 if (time_after_eq(jiffies, priv->last_gc + nft_set_gc_interval(set))) 1681 pipapo_gc(set, priv->clone); 1682 1683 if (!priv->dirty) 1684 return; 1685 1686 new_clone = pipapo_clone(priv->clone); 1687 if (IS_ERR(new_clone)) 1688 return; 1689 1690 priv->dirty = false; 1691 1692 old = rcu_access_pointer(priv->match); 1693 rcu_assign_pointer(priv->match, priv->clone); 1694 if (old) 1695 call_rcu(&old->rcu, pipapo_reclaim_match); 1696 1697 priv->clone = new_clone; 1698 } 1699 1700 static bool nft_pipapo_transaction_mutex_held(const struct nft_set *set) 1701 { 1702 #ifdef CONFIG_PROVE_LOCKING 1703 const struct net *net = read_pnet(&set->net); 1704 1705 return lockdep_is_held(&nft_pernet(net)->commit_mutex); 1706 #else 1707 return true; 1708 #endif 1709 } 1710 1711 static void nft_pipapo_abort(const struct nft_set *set) 1712 { 1713 struct nft_pipapo *priv = nft_set_priv(set); 1714 struct nft_pipapo_match *new_clone, *m; 1715 1716 if (!priv->dirty) 1717 return; 1718 1719 m = rcu_dereference_protected(priv->match, nft_pipapo_transaction_mutex_held(set)); 1720 1721 new_clone = pipapo_clone(m); 1722 if (IS_ERR(new_clone)) 1723 return; 1724 1725 priv->dirty = false; 1726 1727 pipapo_free_match(priv->clone); 1728 priv->clone = new_clone; 1729 } 1730 1731 /** 1732 * nft_pipapo_activate() - Mark element reference as active given key, commit 1733 * @net: Network namespace 1734 * @set: nftables API set representation 1735 * @elem: nftables API element representation containing key data 1736 * 1737 * On insertion, elements are added to a copy of the matching data currently 1738 * in use for lookups, and not directly inserted into current lookup data. Both 1739 * nft_pipapo_insert() and nft_pipapo_activate() are called once for each 1740 * element, hence we can't purpose either one as a real commit operation. 1741 */ 1742 static void nft_pipapo_activate(const struct net *net, 1743 const struct nft_set *set, 1744 const struct nft_set_elem *elem) 1745 { 1746 struct nft_pipapo_elem *e = elem->priv; 1747 1748 nft_set_elem_change_active(net, set, &e->ext); 1749 } 1750 1751 /** 1752 * pipapo_deactivate() - Check that element is in set, mark as inactive 1753 * @net: Network namespace 1754 * @set: nftables API set representation 1755 * @data: Input key data 1756 * @ext: nftables API extension pointer, used to check for end element 1757 * 1758 * This is a convenience function that can be called from both 1759 * nft_pipapo_deactivate() and nft_pipapo_flush(), as they are in fact the same 1760 * operation. 1761 * 1762 * Return: deactivated element if found, NULL otherwise. 1763 */ 1764 static void *pipapo_deactivate(const struct net *net, const struct nft_set *set, 1765 const u8 *data, const struct nft_set_ext *ext) 1766 { 1767 struct nft_pipapo_elem *e; 1768 1769 e = pipapo_get(net, set, data, nft_genmask_next(net)); 1770 if (IS_ERR(e)) 1771 return NULL; 1772 1773 nft_set_elem_change_active(net, set, &e->ext); 1774 1775 return e; 1776 } 1777 1778 /** 1779 * nft_pipapo_deactivate() - Call pipapo_deactivate() to make element inactive 1780 * @net: Network namespace 1781 * @set: nftables API set representation 1782 * @elem: nftables API element representation containing key data 1783 * 1784 * Return: deactivated element if found, NULL otherwise. 1785 */ 1786 static void *nft_pipapo_deactivate(const struct net *net, 1787 const struct nft_set *set, 1788 const struct nft_set_elem *elem) 1789 { 1790 const struct nft_set_ext *ext = nft_set_elem_ext(set, elem->priv); 1791 1792 return pipapo_deactivate(net, set, (const u8 *)elem->key.val.data, ext); 1793 } 1794 1795 /** 1796 * nft_pipapo_flush() - Call pipapo_deactivate() to make element inactive 1797 * @net: Network namespace 1798 * @set: nftables API set representation 1799 * @elem: nftables API element representation containing key data 1800 * 1801 * This is functionally the same as nft_pipapo_deactivate(), with a slightly 1802 * different interface, and it's also called once for each element in a set 1803 * being flushed, so we can't implement, strictly speaking, a flush operation, 1804 * which would otherwise be as simple as allocating an empty copy of the 1805 * matching data. 1806 * 1807 * Note that we could in theory do that, mark the set as flushed, and ignore 1808 * subsequent calls, but we would leak all the elements after the first one, 1809 * because they wouldn't then be freed as result of API calls. 1810 * 1811 * Return: true if element was found and deactivated. 1812 */ 1813 static bool nft_pipapo_flush(const struct net *net, const struct nft_set *set, 1814 void *elem) 1815 { 1816 struct nft_pipapo_elem *e = elem; 1817 1818 return pipapo_deactivate(net, set, (const u8 *)nft_set_ext_key(&e->ext), 1819 &e->ext); 1820 } 1821 1822 /** 1823 * pipapo_get_boundaries() - Get byte interval for associated rules 1824 * @f: Field including lookup table 1825 * @first_rule: First rule (lowest index) 1826 * @rule_count: Number of associated rules 1827 * @left: Byte expression for left boundary (start of range) 1828 * @right: Byte expression for right boundary (end of range) 1829 * 1830 * Given the first rule and amount of rules that originated from the same entry, 1831 * build the original range associated with the entry, and calculate the length 1832 * of the originating netmask. 1833 * 1834 * In pictures: 1835 * 1836 * bucket 1837 * group 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 1838 * 0 1,2 1839 * 1 1,2 1840 * 2 1,2 1841 * 3 1,2 1842 * 4 1,2 1843 * 5 1 2 1844 * 6 1,2 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1845 * 7 1,2 1,2 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1846 * 1847 * this is the lookup table corresponding to the IPv4 range 1848 * 192.168.1.0-192.168.2.1, which was expanded to the two composing netmasks, 1849 * rule #1: 192.168.1.0/24, and rule #2: 192.168.2.0/31. 1850 * 1851 * This function fills @left and @right with the byte values of the leftmost 1852 * and rightmost bucket indices for the lowest and highest rule indices, 1853 * respectively. If @first_rule is 1 and @rule_count is 2, we obtain, in 1854 * nibbles: 1855 * left: < 12, 0, 10, 8, 0, 1, 0, 0 > 1856 * right: < 12, 0, 10, 8, 0, 2, 2, 1 > 1857 * corresponding to bytes: 1858 * left: < 192, 168, 1, 0 > 1859 * right: < 192, 168, 2, 1 > 1860 * with mask length irrelevant here, unused on return, as the range is already 1861 * defined by its start and end points. The mask length is relevant for a single 1862 * ranged entry instead: if @first_rule is 1 and @rule_count is 1, we ignore 1863 * rule 2 above: @left becomes < 192, 168, 1, 0 >, @right becomes 1864 * < 192, 168, 1, 255 >, and the mask length, calculated from the distances 1865 * between leftmost and rightmost bucket indices for each group, would be 24. 1866 * 1867 * Return: mask length, in bits. 1868 */ 1869 static int pipapo_get_boundaries(struct nft_pipapo_field *f, int first_rule, 1870 int rule_count, u8 *left, u8 *right) 1871 { 1872 int g, mask_len = 0, bit_offset = 0; 1873 u8 *l = left, *r = right; 1874 1875 for (g = 0; g < f->groups; g++) { 1876 int b, x0, x1; 1877 1878 x0 = -1; 1879 x1 = -1; 1880 for (b = 0; b < NFT_PIPAPO_BUCKETS(f->bb); b++) { 1881 unsigned long *pos; 1882 1883 pos = NFT_PIPAPO_LT_ALIGN(f->lt) + 1884 (g * NFT_PIPAPO_BUCKETS(f->bb) + b) * f->bsize; 1885 if (test_bit(first_rule, pos) && x0 == -1) 1886 x0 = b; 1887 if (test_bit(first_rule + rule_count - 1, pos)) 1888 x1 = b; 1889 } 1890 1891 *l |= x0 << (BITS_PER_BYTE - f->bb - bit_offset); 1892 *r |= x1 << (BITS_PER_BYTE - f->bb - bit_offset); 1893 1894 bit_offset += f->bb; 1895 if (bit_offset >= BITS_PER_BYTE) { 1896 bit_offset %= BITS_PER_BYTE; 1897 l++; 1898 r++; 1899 } 1900 1901 if (x1 - x0 == 0) 1902 mask_len += 4; 1903 else if (x1 - x0 == 1) 1904 mask_len += 3; 1905 else if (x1 - x0 == 3) 1906 mask_len += 2; 1907 else if (x1 - x0 == 7) 1908 mask_len += 1; 1909 } 1910 1911 return mask_len; 1912 } 1913 1914 /** 1915 * pipapo_match_field() - Match rules against byte ranges 1916 * @f: Field including the lookup table 1917 * @first_rule: First of associated rules originating from same entry 1918 * @rule_count: Amount of associated rules 1919 * @start: Start of range to be matched 1920 * @end: End of range to be matched 1921 * 1922 * Return: true on match, false otherwise. 1923 */ 1924 static bool pipapo_match_field(struct nft_pipapo_field *f, 1925 int first_rule, int rule_count, 1926 const u8 *start, const u8 *end) 1927 { 1928 u8 right[NFT_PIPAPO_MAX_BYTES] = { 0 }; 1929 u8 left[NFT_PIPAPO_MAX_BYTES] = { 0 }; 1930 1931 pipapo_get_boundaries(f, first_rule, rule_count, left, right); 1932 1933 return !memcmp(start, left, 1934 f->groups / NFT_PIPAPO_GROUPS_PER_BYTE(f)) && 1935 !memcmp(end, right, f->groups / NFT_PIPAPO_GROUPS_PER_BYTE(f)); 1936 } 1937 1938 /** 1939 * nft_pipapo_remove() - Remove element given key, commit 1940 * @net: Network namespace 1941 * @set: nftables API set representation 1942 * @elem: nftables API element representation containing key data 1943 * 1944 * Similarly to nft_pipapo_activate(), this is used as commit operation by the 1945 * API, but it's called once per element in the pending transaction, so we can't 1946 * implement this as a single commit operation. Closest we can get is to remove 1947 * the matched element here, if any, and commit the updated matching data. 1948 */ 1949 static void nft_pipapo_remove(const struct net *net, const struct nft_set *set, 1950 const struct nft_set_elem *elem) 1951 { 1952 struct nft_pipapo *priv = nft_set_priv(set); 1953 struct nft_pipapo_match *m = priv->clone; 1954 struct nft_pipapo_elem *e = elem->priv; 1955 int rules_f0, first_rule = 0; 1956 const u8 *data; 1957 1958 data = (const u8 *)nft_set_ext_key(&e->ext); 1959 1960 while ((rules_f0 = pipapo_rules_same_key(m->f, first_rule))) { 1961 union nft_pipapo_map_bucket rulemap[NFT_PIPAPO_MAX_FIELDS]; 1962 const u8 *match_start, *match_end; 1963 struct nft_pipapo_field *f; 1964 int i, start, rules_fx; 1965 1966 match_start = data; 1967 1968 if (nft_set_ext_exists(&e->ext, NFT_SET_EXT_KEY_END)) 1969 match_end = (const u8 *)nft_set_ext_key_end(&e->ext)->data; 1970 else 1971 match_end = data; 1972 1973 start = first_rule; 1974 rules_fx = rules_f0; 1975 1976 nft_pipapo_for_each_field(f, i, m) { 1977 if (!pipapo_match_field(f, start, rules_fx, 1978 match_start, match_end)) 1979 break; 1980 1981 rulemap[i].to = start; 1982 rulemap[i].n = rules_fx; 1983 1984 rules_fx = f->mt[start].n; 1985 start = f->mt[start].to; 1986 1987 match_start += NFT_PIPAPO_GROUPS_PADDED_SIZE(f); 1988 match_end += NFT_PIPAPO_GROUPS_PADDED_SIZE(f); 1989 } 1990 1991 if (i == m->field_count) { 1992 priv->dirty = true; 1993 pipapo_drop(m, rulemap); 1994 return; 1995 } 1996 1997 first_rule += rules_f0; 1998 } 1999 } 2000 2001 /** 2002 * nft_pipapo_walk() - Walk over elements 2003 * @ctx: nftables API context 2004 * @set: nftables API set representation 2005 * @iter: Iterator 2006 * 2007 * As elements are referenced in the mapping array for the last field, directly 2008 * scan that array: there's no need to follow rule mappings from the first 2009 * field. 2010 */ 2011 static void nft_pipapo_walk(const struct nft_ctx *ctx, struct nft_set *set, 2012 struct nft_set_iter *iter) 2013 { 2014 struct nft_pipapo *priv = nft_set_priv(set); 2015 struct net *net = read_pnet(&set->net); 2016 struct nft_pipapo_match *m; 2017 struct nft_pipapo_field *f; 2018 int i, r; 2019 2020 rcu_read_lock(); 2021 if (iter->genmask == nft_genmask_cur(net)) 2022 m = rcu_dereference(priv->match); 2023 else 2024 m = priv->clone; 2025 2026 if (unlikely(!m)) 2027 goto out; 2028 2029 for (i = 0, f = m->f; i < m->field_count - 1; i++, f++) 2030 ; 2031 2032 for (r = 0; r < f->rules; r++) { 2033 struct nft_pipapo_elem *e; 2034 struct nft_set_elem elem; 2035 2036 if (r < f->rules - 1 && f->mt[r + 1].e == f->mt[r].e) 2037 continue; 2038 2039 if (iter->count < iter->skip) 2040 goto cont; 2041 2042 e = f->mt[r].e; 2043 2044 elem.priv = e; 2045 2046 iter->err = iter->fn(ctx, set, iter, &elem); 2047 if (iter->err < 0) 2048 goto out; 2049 2050 cont: 2051 iter->count++; 2052 } 2053 2054 out: 2055 rcu_read_unlock(); 2056 } 2057 2058 /** 2059 * nft_pipapo_privsize() - Return the size of private data for the set 2060 * @nla: netlink attributes, ignored as size doesn't depend on them 2061 * @desc: Set description, ignored as size doesn't depend on it 2062 * 2063 * Return: size of private data for this set implementation, in bytes 2064 */ 2065 static u64 nft_pipapo_privsize(const struct nlattr * const nla[], 2066 const struct nft_set_desc *desc) 2067 { 2068 return sizeof(struct nft_pipapo); 2069 } 2070 2071 /** 2072 * nft_pipapo_estimate() - Set size, space and lookup complexity 2073 * @desc: Set description, element count and field description used 2074 * @features: Flags: NFT_SET_INTERVAL needs to be there 2075 * @est: Storage for estimation data 2076 * 2077 * Return: true if set description is compatible, false otherwise 2078 */ 2079 static bool nft_pipapo_estimate(const struct nft_set_desc *desc, u32 features, 2080 struct nft_set_estimate *est) 2081 { 2082 if (!(features & NFT_SET_INTERVAL) || 2083 desc->field_count < NFT_PIPAPO_MIN_FIELDS) 2084 return false; 2085 2086 est->size = pipapo_estimate_size(desc); 2087 if (!est->size) 2088 return false; 2089 2090 est->lookup = NFT_SET_CLASS_O_LOG_N; 2091 2092 est->space = NFT_SET_CLASS_O_N; 2093 2094 return true; 2095 } 2096 2097 /** 2098 * nft_pipapo_init() - Initialise data for a set instance 2099 * @set: nftables API set representation 2100 * @desc: Set description 2101 * @nla: netlink attributes 2102 * 2103 * Validate number and size of fields passed as NFTA_SET_DESC_CONCAT netlink 2104 * attributes, initialise internal set parameters, current instance of matching 2105 * data and a copy for subsequent insertions. 2106 * 2107 * Return: 0 on success, negative error code on failure. 2108 */ 2109 static int nft_pipapo_init(const struct nft_set *set, 2110 const struct nft_set_desc *desc, 2111 const struct nlattr * const nla[]) 2112 { 2113 struct nft_pipapo *priv = nft_set_priv(set); 2114 struct nft_pipapo_match *m; 2115 struct nft_pipapo_field *f; 2116 int err, i, field_count; 2117 2118 field_count = desc->field_count ? : 1; 2119 2120 if (field_count > NFT_PIPAPO_MAX_FIELDS) 2121 return -EINVAL; 2122 2123 m = kmalloc(struct_size(m, f, field_count), GFP_KERNEL); 2124 if (!m) 2125 return -ENOMEM; 2126 2127 m->field_count = field_count; 2128 m->bsize_max = 0; 2129 2130 m->scratch = alloc_percpu(unsigned long *); 2131 if (!m->scratch) { 2132 err = -ENOMEM; 2133 goto out_scratch; 2134 } 2135 for_each_possible_cpu(i) 2136 *per_cpu_ptr(m->scratch, i) = NULL; 2137 2138 #ifdef NFT_PIPAPO_ALIGN 2139 m->scratch_aligned = alloc_percpu(unsigned long *); 2140 if (!m->scratch_aligned) { 2141 err = -ENOMEM; 2142 goto out_free; 2143 } 2144 for_each_possible_cpu(i) 2145 *per_cpu_ptr(m->scratch_aligned, i) = NULL; 2146 #endif 2147 2148 rcu_head_init(&m->rcu); 2149 2150 nft_pipapo_for_each_field(f, i, m) { 2151 int len = desc->field_len[i] ? : set->klen; 2152 2153 f->bb = NFT_PIPAPO_GROUP_BITS_INIT; 2154 f->groups = len * NFT_PIPAPO_GROUPS_PER_BYTE(f); 2155 2156 priv->width += round_up(len, sizeof(u32)); 2157 2158 f->bsize = 0; 2159 f->rules = 0; 2160 NFT_PIPAPO_LT_ASSIGN(f, NULL); 2161 f->mt = NULL; 2162 } 2163 2164 /* Create an initial clone of matching data for next insertion */ 2165 priv->clone = pipapo_clone(m); 2166 if (IS_ERR(priv->clone)) { 2167 err = PTR_ERR(priv->clone); 2168 goto out_free; 2169 } 2170 2171 priv->dirty = false; 2172 2173 rcu_assign_pointer(priv->match, m); 2174 2175 return 0; 2176 2177 out_free: 2178 #ifdef NFT_PIPAPO_ALIGN 2179 free_percpu(m->scratch_aligned); 2180 #endif 2181 free_percpu(m->scratch); 2182 out_scratch: 2183 kfree(m); 2184 2185 return err; 2186 } 2187 2188 /** 2189 * nft_set_pipapo_match_destroy() - Destroy elements from key mapping array 2190 * @ctx: context 2191 * @set: nftables API set representation 2192 * @m: matching data pointing to key mapping array 2193 */ 2194 static void nft_set_pipapo_match_destroy(const struct nft_ctx *ctx, 2195 const struct nft_set *set, 2196 struct nft_pipapo_match *m) 2197 { 2198 struct nft_pipapo_field *f; 2199 int i, r; 2200 2201 for (i = 0, f = m->f; i < m->field_count - 1; i++, f++) 2202 ; 2203 2204 for (r = 0; r < f->rules; r++) { 2205 struct nft_pipapo_elem *e; 2206 2207 if (r < f->rules - 1 && f->mt[r + 1].e == f->mt[r].e) 2208 continue; 2209 2210 e = f->mt[r].e; 2211 2212 nf_tables_set_elem_destroy(ctx, set, e); 2213 } 2214 } 2215 2216 /** 2217 * nft_pipapo_destroy() - Free private data for set and all committed elements 2218 * @ctx: context 2219 * @set: nftables API set representation 2220 */ 2221 static void nft_pipapo_destroy(const struct nft_ctx *ctx, 2222 const struct nft_set *set) 2223 { 2224 struct nft_pipapo *priv = nft_set_priv(set); 2225 struct nft_pipapo_match *m; 2226 int cpu; 2227 2228 m = rcu_dereference_protected(priv->match, true); 2229 if (m) { 2230 rcu_barrier(); 2231 2232 nft_set_pipapo_match_destroy(ctx, set, m); 2233 2234 #ifdef NFT_PIPAPO_ALIGN 2235 free_percpu(m->scratch_aligned); 2236 #endif 2237 for_each_possible_cpu(cpu) 2238 kfree(*per_cpu_ptr(m->scratch, cpu)); 2239 free_percpu(m->scratch); 2240 pipapo_free_fields(m); 2241 kfree(m); 2242 priv->match = NULL; 2243 } 2244 2245 if (priv->clone) { 2246 m = priv->clone; 2247 2248 if (priv->dirty) 2249 nft_set_pipapo_match_destroy(ctx, set, m); 2250 2251 #ifdef NFT_PIPAPO_ALIGN 2252 free_percpu(priv->clone->scratch_aligned); 2253 #endif 2254 for_each_possible_cpu(cpu) 2255 kfree(*per_cpu_ptr(priv->clone->scratch, cpu)); 2256 free_percpu(priv->clone->scratch); 2257 2258 pipapo_free_fields(priv->clone); 2259 kfree(priv->clone); 2260 priv->clone = NULL; 2261 } 2262 } 2263 2264 /** 2265 * nft_pipapo_gc_init() - Initialise garbage collection 2266 * @set: nftables API set representation 2267 * 2268 * Instead of actually setting up a periodic work for garbage collection, as 2269 * this operation requires a swap of matching data with the working copy, we'll 2270 * do that opportunistically with other commit operations if the interval is 2271 * elapsed, so we just need to set the current jiffies timestamp here. 2272 */ 2273 static void nft_pipapo_gc_init(const struct nft_set *set) 2274 { 2275 struct nft_pipapo *priv = nft_set_priv(set); 2276 2277 priv->last_gc = jiffies; 2278 } 2279 2280 const struct nft_set_type nft_set_pipapo_type = { 2281 .features = NFT_SET_INTERVAL | NFT_SET_MAP | NFT_SET_OBJECT | 2282 NFT_SET_TIMEOUT, 2283 .ops = { 2284 .lookup = nft_pipapo_lookup, 2285 .insert = nft_pipapo_insert, 2286 .activate = nft_pipapo_activate, 2287 .deactivate = nft_pipapo_deactivate, 2288 .flush = nft_pipapo_flush, 2289 .remove = nft_pipapo_remove, 2290 .walk = nft_pipapo_walk, 2291 .get = nft_pipapo_get, 2292 .privsize = nft_pipapo_privsize, 2293 .estimate = nft_pipapo_estimate, 2294 .init = nft_pipapo_init, 2295 .destroy = nft_pipapo_destroy, 2296 .gc_init = nft_pipapo_gc_init, 2297 .commit = nft_pipapo_commit, 2298 .abort = nft_pipapo_abort, 2299 .elemsize = offsetof(struct nft_pipapo_elem, ext), 2300 }, 2301 }; 2302 2303 #if defined(CONFIG_X86_64) && !defined(CONFIG_UML) 2304 const struct nft_set_type nft_set_pipapo_avx2_type = { 2305 .features = NFT_SET_INTERVAL | NFT_SET_MAP | NFT_SET_OBJECT | 2306 NFT_SET_TIMEOUT, 2307 .ops = { 2308 .lookup = nft_pipapo_avx2_lookup, 2309 .insert = nft_pipapo_insert, 2310 .activate = nft_pipapo_activate, 2311 .deactivate = nft_pipapo_deactivate, 2312 .flush = nft_pipapo_flush, 2313 .remove = nft_pipapo_remove, 2314 .walk = nft_pipapo_walk, 2315 .get = nft_pipapo_get, 2316 .privsize = nft_pipapo_privsize, 2317 .estimate = nft_pipapo_avx2_estimate, 2318 .init = nft_pipapo_init, 2319 .destroy = nft_pipapo_destroy, 2320 .gc_init = nft_pipapo_gc_init, 2321 .commit = nft_pipapo_commit, 2322 .abort = nft_pipapo_abort, 2323 .elemsize = offsetof(struct nft_pipapo_elem, ext), 2324 }, 2325 }; 2326 #endif 2327