1// SPDX-License-Identifier: GPL-2.0 2/* 3 * INET An implementation of the TCP/IP protocol suite for the LINUX 4 * operating system. INET is implemented using the BSD Socket 5 * interface as the means of communication with the user level. 6 * 7 * The IP fragmentation functionality. 8 * 9 * Authors: Fred N. van Kempen <waltje@uWalt.NL.Mugnet.ORG> 10 * Alan Cox <alan@lxorguk.ukuu.org.uk> 11 * 12 * Fixes: 13 * Alan Cox : Split from ip.c , see ip_input.c for history. 14 * David S. Miller : Begin massive cleanup... 15 * Andi Kleen : Add sysctls. 16 * xxxx : Overlapfrag bug. 17 * Ultima : ip_expire() kernel panic. 18 * Bill Hawes : Frag accounting and evictor fixes. 19 * John McDonald : 0 length frag bug. 20 * Alexey Kuznetsov: SMP races, threading, cleanup. 21 * Patrick McHardy : LRU queue of frag heads for evictor. 22 */ 23 24#define pr_fmt(fmt) "IPv4: " fmt 25 26#include <linux/compiler.h> 27#include <linux/module.h> 28#include <linux/types.h> 29#include <linux/mm.h> 30#include <linux/jiffies.h> 31#include <linux/skbuff.h> 32#include <linux/list.h> 33#include <linux/ip.h> 34#include <linux/icmp.h> 35#include <linux/netdevice.h> 36#include <linux/jhash.h> 37#include <linux/random.h> 38#include <linux/slab.h> 39#include <net/route.h> 40#include <net/dst.h> 41#include <net/sock.h> 42#include <net/ip.h> 43#include <net/icmp.h> 44#include <net/checksum.h> 45#include <net/inetpeer.h> 46#include <net/inet_frag.h> 47#include <linux/tcp.h> 48#include <linux/udp.h> 49#include <linux/inet.h> 50#include <linux/netfilter_ipv4.h> 51#include <net/inet_ecn.h> 52#include <net/l3mdev.h> 53 54/* NOTE. Logic of IP defragmentation is parallel to corresponding IPv6 55 * code now. If you change something here, _PLEASE_ update ipv6/reassembly.c 56 * as well. Or notify me, at least. --ANK 57 */ 58static const char ip_frag_cache_name[] = "ip4-frags"; 59 60/* Describe an entry in the "incomplete datagrams" queue. */ 61struct ipq { 62 struct inet_frag_queue q; 63 64 u8 ecn; /* RFC3168 support */ 65 u16 max_df_size; /* largest frag with DF set seen */ 66 int iif; 67 unsigned int rid; 68 struct inet_peer *peer; 69}; 70 71static u8 ip4_frag_ecn(u8 tos) 72{ 73 return 1 << (tos & INET_ECN_MASK); 74} 75 76static struct inet_frags ip4_frags; 77 78static int ip_frag_reasm(struct ipq *qp, struct sk_buff *skb, 79 struct sk_buff *prev_tail, struct net_device *dev); 80 81 82static void ip4_frag_init(struct inet_frag_queue *q, const void *a) 83{ 84 struct ipq *qp = container_of(q, struct ipq, q); 85 struct net *net = q->fqdir->net; 86 87 const struct frag_v4_compare_key *key = a; 88 89 q->key.v4 = *key; 90 qp->ecn = 0; 91 qp->peer = q->fqdir->max_dist ? 92 inet_getpeer_v4(net->ipv4.peers, key->saddr, key->vif, 1) : 93 NULL; 94} 95 96static void ip4_frag_free(struct inet_frag_queue *q) 97{ 98 struct ipq *qp; 99 100 qp = container_of(q, struct ipq, q); 101 if (qp->peer) 102 inet_putpeer(qp->peer); 103} 104 105 106/* Destruction primitives. */ 107 108static void ipq_put(struct ipq *ipq) 109{ 110 inet_frag_put(&ipq->q); 111} 112 113/* Kill ipq entry. It is not destroyed immediately, 114 * because caller (and someone more) holds reference count. 115 */ 116static void ipq_kill(struct ipq *ipq) 117{ 118 inet_frag_kill(&ipq->q); 119} 120 121static bool frag_expire_skip_icmp(u32 user) 122{ 123 return user == IP_DEFRAG_AF_PACKET || 124 ip_defrag_user_in_between(user, IP_DEFRAG_CONNTRACK_IN, 125 __IP_DEFRAG_CONNTRACK_IN_END) || 126 ip_defrag_user_in_between(user, IP_DEFRAG_CONNTRACK_BRIDGE_IN, 127 __IP_DEFRAG_CONNTRACK_BRIDGE_IN); 128} 129 130/* 131 * Oops, a fragment queue timed out. Kill it and send an ICMP reply. 132 */ 133static void ip_expire(struct timer_list *t) 134{ 135 struct inet_frag_queue *frag = from_timer(frag, t, timer); 136 const struct iphdr *iph; 137 struct sk_buff *head = NULL; 138 struct net *net; 139 struct ipq *qp; 140 int err; 141 142 qp = container_of(frag, struct ipq, q); 143 net = qp->q.fqdir->net; 144 145 rcu_read_lock(); 146 147 /* Paired with WRITE_ONCE() in fqdir_pre_exit(). */ 148 if (READ_ONCE(qp->q.fqdir->dead)) 149 goto out_rcu_unlock; 150 151 spin_lock(&qp->q.lock); 152 153 if (qp->q.flags & INET_FRAG_COMPLETE) 154 goto out; 155 156 ipq_kill(qp); 157 __IP_INC_STATS(net, IPSTATS_MIB_REASMFAILS); 158 __IP_INC_STATS(net, IPSTATS_MIB_REASMTIMEOUT); 159 160 if (!(qp->q.flags & INET_FRAG_FIRST_IN)) 161 goto out; 162 163 /* sk_buff::dev and sk_buff::rbnode are unionized. So we 164 * pull the head out of the tree in order to be able to 165 * deal with head->dev. 166 */ 167 head = inet_frag_pull_head(&qp->q); 168 if (!head) 169 goto out; 170 head->dev = dev_get_by_index_rcu(net, qp->iif); 171 if (!head->dev) 172 goto out; 173 174 175 /* skb has no dst, perform route lookup again */ 176 iph = ip_hdr(head); 177 err = ip_route_input_noref(head, iph->daddr, iph->saddr, 178 iph->tos, head->dev); 179 if (err) 180 goto out; 181 182 /* Only an end host needs to send an ICMP 183 * "Fragment Reassembly Timeout" message, per RFC792. 184 */ 185 if (frag_expire_skip_icmp(qp->q.key.v4.user) && 186 (skb_rtable(head)->rt_type != RTN_LOCAL)) 187 goto out; 188 189 spin_unlock(&qp->q.lock); 190 icmp_send(head, ICMP_TIME_EXCEEDED, ICMP_EXC_FRAGTIME, 0); 191 goto out_rcu_unlock; 192 193out: 194 spin_unlock(&qp->q.lock); 195out_rcu_unlock: 196 rcu_read_unlock(); 197 kfree_skb(head); 198 ipq_put(qp); 199} 200 201/* Find the correct entry in the "incomplete datagrams" queue for 202 * this IP datagram, and create new one, if nothing is found. 203 */ 204static struct ipq *ip_find(struct net *net, struct iphdr *iph, 205 u32 user, int vif) 206{ 207 struct frag_v4_compare_key key = { 208 .saddr = iph->saddr, 209 .daddr = iph->daddr, 210 .user = user, 211 .vif = vif, 212 .id = iph->id, 213 .protocol = iph->protocol, 214 }; 215 struct inet_frag_queue *q; 216 217 q = inet_frag_find(net->ipv4.fqdir, &key); 218 if (!q) 219 return NULL; 220 221 return container_of(q, struct ipq, q); 222} 223 224/* Is the fragment too far ahead to be part of ipq? */ 225static int ip_frag_too_far(struct ipq *qp) 226{ 227 struct inet_peer *peer = qp->peer; 228 unsigned int max = qp->q.fqdir->max_dist; 229 unsigned int start, end; 230 231 int rc; 232 233 if (!peer || !max) 234 return 0; 235 236 start = qp->rid; 237 end = atomic_inc_return(&peer->rid); 238 qp->rid = end; 239 240 rc = qp->q.fragments_tail && (end - start) > max; 241 242 if (rc) 243 __IP_INC_STATS(qp->q.fqdir->net, IPSTATS_MIB_REASMFAILS); 244 245 return rc; 246} 247 248static int ip_frag_reinit(struct ipq *qp) 249{ 250 unsigned int sum_truesize = 0; 251 252 if (!mod_timer(&qp->q.timer, jiffies + qp->q.fqdir->timeout)) { 253 refcount_inc(&qp->q.refcnt); 254 return -ETIMEDOUT; 255 } 256 257 sum_truesize = inet_frag_rbtree_purge(&qp->q.rb_fragments); 258 sub_frag_mem_limit(qp->q.fqdir, sum_truesize); 259 260 qp->q.flags = 0; 261 qp->q.len = 0; 262 qp->q.meat = 0; 263 qp->q.rb_fragments = RB_ROOT; 264 qp->q.fragments_tail = NULL; 265 qp->q.last_run_head = NULL; 266 qp->iif = 0; 267 qp->ecn = 0; 268 269 return 0; 270} 271 272/* Add new segment to existing queue. */ 273static int ip_frag_queue(struct ipq *qp, struct sk_buff *skb) 274{ 275 struct net *net = qp->q.fqdir->net; 276 int ihl, end, flags, offset; 277 struct sk_buff *prev_tail; 278 struct net_device *dev; 279 unsigned int fragsize; 280 int err = -ENOENT; 281 u8 ecn; 282 283 if (qp->q.flags & INET_FRAG_COMPLETE) 284 goto err; 285 286 if (!(IPCB(skb)->flags & IPSKB_FRAG_COMPLETE) && 287 unlikely(ip_frag_too_far(qp)) && 288 unlikely(err = ip_frag_reinit(qp))) { 289 ipq_kill(qp); 290 goto err; 291 } 292 293 ecn = ip4_frag_ecn(ip_hdr(skb)->tos); 294 offset = ntohs(ip_hdr(skb)->frag_off); 295 flags = offset & ~IP_OFFSET; 296 offset &= IP_OFFSET; 297 offset <<= 3; /* offset is in 8-byte chunks */ 298 ihl = ip_hdrlen(skb); 299 300 /* Determine the position of this fragment. */ 301 end = offset + skb->len - skb_network_offset(skb) - ihl; 302 err = -EINVAL; 303 304 /* Is this the final fragment? */ 305 if ((flags & IP_MF) == 0) { 306 /* If we already have some bits beyond end 307 * or have different end, the segment is corrupted. 308 */ 309 if (end < qp->q.len || 310 ((qp->q.flags & INET_FRAG_LAST_IN) && end != qp->q.len)) 311 goto discard_qp; 312 qp->q.flags |= INET_FRAG_LAST_IN; 313 qp->q.len = end; 314 } else { 315 if (end&7) { 316 end &= ~7; 317 if (skb->ip_summed != CHECKSUM_UNNECESSARY) 318 skb->ip_summed = CHECKSUM_NONE; 319 } 320 if (end > qp->q.len) { 321 /* Some bits beyond end -> corruption. */ 322 if (qp->q.flags & INET_FRAG_LAST_IN) 323 goto discard_qp; 324 qp->q.len = end; 325 } 326 } 327 if (end == offset) 328 goto discard_qp; 329 330 err = -ENOMEM; 331 if (!pskb_pull(skb, skb_network_offset(skb) + ihl)) 332 goto discard_qp; 333 334 err = pskb_trim_rcsum(skb, end - offset); 335 if (err) 336 goto discard_qp; 337 338 /* Note : skb->rbnode and skb->dev share the same location. */ 339 dev = skb->dev; 340 /* Makes sure compiler wont do silly aliasing games */ 341 barrier(); 342 343 prev_tail = qp->q.fragments_tail; 344 err = inet_frag_queue_insert(&qp->q, skb, offset, end); 345 if (err) 346 goto insert_error; 347 348 if (dev) 349 qp->iif = dev->ifindex; 350 351 qp->q.stamp = skb->tstamp; 352 qp->q.meat += skb->len; 353 qp->ecn |= ecn; 354 add_frag_mem_limit(qp->q.fqdir, skb->truesize); 355 if (offset == 0) 356 qp->q.flags |= INET_FRAG_FIRST_IN; 357 358 fragsize = skb->len + ihl; 359 360 if (fragsize > qp->q.max_size) 361 qp->q.max_size = fragsize; 362 363 if (ip_hdr(skb)->frag_off & htons(IP_DF) && 364 fragsize > qp->max_df_size) 365 qp->max_df_size = fragsize; 366 367 if (qp->q.flags == (INET_FRAG_FIRST_IN | INET_FRAG_LAST_IN) && 368 qp->q.meat == qp->q.len) { 369 unsigned long orefdst = skb->_skb_refdst; 370 371 skb->_skb_refdst = 0UL; 372 err = ip_frag_reasm(qp, skb, prev_tail, dev); 373 skb->_skb_refdst = orefdst; 374 if (err) 375 inet_frag_kill(&qp->q); 376 return err; 377 } 378 379 skb_dst_drop(skb); 380 return -EINPROGRESS; 381 382insert_error: 383 if (err == IPFRAG_DUP) { 384 kfree_skb(skb); 385 return -EINVAL; 386 } 387 err = -EINVAL; 388 __IP_INC_STATS(net, IPSTATS_MIB_REASM_OVERLAPS); 389discard_qp: 390 inet_frag_kill(&qp->q); 391 __IP_INC_STATS(net, IPSTATS_MIB_REASMFAILS); 392err: 393 kfree_skb(skb); 394 return err; 395} 396 397static bool ip_frag_coalesce_ok(const struct ipq *qp) 398{ 399 return qp->q.key.v4.user == IP_DEFRAG_LOCAL_DELIVER; 400} 401 402/* Build a new IP datagram from all its fragments. */ 403static int ip_frag_reasm(struct ipq *qp, struct sk_buff *skb, 404 struct sk_buff *prev_tail, struct net_device *dev) 405{ 406 struct net *net = qp->q.fqdir->net; 407 struct iphdr *iph; 408 void *reasm_data; 409 int len, err; 410 u8 ecn; 411 412 ipq_kill(qp); 413 414 ecn = ip_frag_ecn_table[qp->ecn]; 415 if (unlikely(ecn == 0xff)) { 416 err = -EINVAL; 417 goto out_fail; 418 } 419 420 /* Make the one we just received the head. */ 421 reasm_data = inet_frag_reasm_prepare(&qp->q, skb, prev_tail); 422 if (!reasm_data) 423 goto out_nomem; 424 425 len = ip_hdrlen(skb) + qp->q.len; 426 err = -E2BIG; 427 if (len > 65535) 428 goto out_oversize; 429 430 inet_frag_reasm_finish(&qp->q, skb, reasm_data, 431 ip_frag_coalesce_ok(qp)); 432 433 skb->dev = dev; 434 IPCB(skb)->frag_max_size = max(qp->max_df_size, qp->q.max_size); 435 436 iph = ip_hdr(skb); 437 iph->tot_len = htons(len); 438 iph->tos |= ecn; 439 440 /* When we set IP_DF on a refragmented skb we must also force a 441 * call to ip_fragment to avoid forwarding a DF-skb of size s while 442 * original sender only sent fragments of size f (where f < s). 443 * 444 * We only set DF/IPSKB_FRAG_PMTU if such DF fragment was the largest 445 * frag seen to avoid sending tiny DF-fragments in case skb was built 446 * from one very small df-fragment and one large non-df frag. 447 */ 448 if (qp->max_df_size == qp->q.max_size) { 449 IPCB(skb)->flags |= IPSKB_FRAG_PMTU; 450 iph->frag_off = htons(IP_DF); 451 } else { 452 iph->frag_off = 0; 453 } 454 455 ip_send_check(iph); 456 457 __IP_INC_STATS(net, IPSTATS_MIB_REASMOKS); 458 qp->q.rb_fragments = RB_ROOT; 459 qp->q.fragments_tail = NULL; 460 qp->q.last_run_head = NULL; 461 return 0; 462 463out_nomem: 464 net_dbg_ratelimited("queue_glue: no memory for gluing queue %p\n", qp); 465 err = -ENOMEM; 466 goto out_fail; 467out_oversize: 468 net_info_ratelimited("Oversized IP packet from %pI4\n", &qp->q.key.v4.saddr); 469out_fail: 470 __IP_INC_STATS(net, IPSTATS_MIB_REASMFAILS); 471 return err; 472} 473 474/* Process an incoming IP datagram fragment. */ 475int ip_defrag(struct net *net, struct sk_buff *skb, u32 user) 476{ 477 struct net_device *dev = skb->dev ? : skb_dst(skb)->dev; 478 int vif = l3mdev_master_ifindex_rcu(dev); 479 struct ipq *qp; 480 481 __IP_INC_STATS(net, IPSTATS_MIB_REASMREQDS); 482 skb_orphan(skb); 483 484 /* Lookup (or create) queue header */ 485 qp = ip_find(net, ip_hdr(skb), user, vif); 486 if (qp) { 487 int ret; 488 489 spin_lock(&qp->q.lock); 490 491 ret = ip_frag_queue(qp, skb); 492 493 spin_unlock(&qp->q.lock); 494 ipq_put(qp); 495 return ret; 496 } 497 498 __IP_INC_STATS(net, IPSTATS_MIB_REASMFAILS); 499 kfree_skb(skb); 500 return -ENOMEM; 501} 502EXPORT_SYMBOL(ip_defrag); 503 504struct sk_buff *ip_check_defrag(struct net *net, struct sk_buff *skb, u32 user) 505{ 506 struct iphdr iph; 507 int netoff; 508 u32 len; 509 510 if (skb->protocol != htons(ETH_P_IP)) 511 return skb; 512 513 netoff = skb_network_offset(skb); 514 515 if (skb_copy_bits(skb, netoff, &iph, sizeof(iph)) < 0) 516 return skb; 517 518 if (iph.ihl < 5 || iph.version != 4) 519 return skb; 520 521 len = ntohs(iph.tot_len); 522 if (skb->len < netoff + len || len < (iph.ihl * 4)) 523 return skb; 524 525 if (ip_is_fragment(&iph)) { 526 skb = skb_share_check(skb, GFP_ATOMIC); 527 if (skb) { 528 if (!pskb_may_pull(skb, netoff + iph.ihl * 4)) { 529 kfree_skb(skb); 530 return NULL; 531 } 532 if (pskb_trim_rcsum(skb, netoff + len)) { 533 kfree_skb(skb); 534 return NULL; 535 } 536 memset(IPCB(skb), 0, sizeof(struct inet_skb_parm)); 537 if (ip_defrag(net, skb, user)) 538 return NULL; 539 skb_clear_hash(skb); 540 } 541 } 542 return skb; 543} 544EXPORT_SYMBOL(ip_check_defrag); 545 546#ifdef CONFIG_SYSCTL 547static int dist_min; 548 549static struct ctl_table ip4_frags_ns_ctl_table[] = { 550 { 551 .procname = "ipfrag_high_thresh", 552 .maxlen = sizeof(unsigned long), 553 .mode = 0644, 554 .proc_handler = proc_doulongvec_minmax, 555 }, 556 { 557 .procname = "ipfrag_low_thresh", 558 .maxlen = sizeof(unsigned long), 559 .mode = 0644, 560 .proc_handler = proc_doulongvec_minmax, 561 }, 562 { 563 .procname = "ipfrag_time", 564 .maxlen = sizeof(int), 565 .mode = 0644, 566 .proc_handler = proc_dointvec_jiffies, 567 }, 568 { 569 .procname = "ipfrag_max_dist", 570 .maxlen = sizeof(int), 571 .mode = 0644, 572 .proc_handler = proc_dointvec_minmax, 573 .extra1 = &dist_min, 574 }, 575 { } 576}; 577 578/* secret interval has been deprecated */ 579static int ip4_frags_secret_interval_unused; 580static struct ctl_table ip4_frags_ctl_table[] = { 581 { 582 .procname = "ipfrag_secret_interval", 583 .data = &ip4_frags_secret_interval_unused, 584 .maxlen = sizeof(int), 585 .mode = 0644, 586 .proc_handler = proc_dointvec_jiffies, 587 }, 588 { } 589}; 590 591static int __net_init ip4_frags_ns_ctl_register(struct net *net) 592{ 593 struct ctl_table *table; 594 struct ctl_table_header *hdr; 595 596 table = ip4_frags_ns_ctl_table; 597 if (!net_eq(net, &init_net)) { 598 table = kmemdup(table, sizeof(ip4_frags_ns_ctl_table), GFP_KERNEL); 599 if (!table) 600 goto err_alloc; 601 602 } 603 table[0].data = &net->ipv4.fqdir->high_thresh; 604 table[0].extra1 = &net->ipv4.fqdir->low_thresh; 605 table[1].data = &net->ipv4.fqdir->low_thresh; 606 table[1].extra2 = &net->ipv4.fqdir->high_thresh; 607 table[2].data = &net->ipv4.fqdir->timeout; 608 table[3].data = &net->ipv4.fqdir->max_dist; 609 610 hdr = register_net_sysctl(net, "net/ipv4", table); 611 if (!hdr) 612 goto err_reg; 613 614 net->ipv4.frags_hdr = hdr; 615 return 0; 616 617err_reg: 618 if (!net_eq(net, &init_net)) 619 kfree(table); 620err_alloc: 621 return -ENOMEM; 622} 623 624static void __net_exit ip4_frags_ns_ctl_unregister(struct net *net) 625{ 626 struct ctl_table *table; 627 628 table = net->ipv4.frags_hdr->ctl_table_arg; 629 unregister_net_sysctl_table(net->ipv4.frags_hdr); 630 kfree(table); 631} 632 633static void __init ip4_frags_ctl_register(void) 634{ 635 register_net_sysctl(&init_net, "net/ipv4", ip4_frags_ctl_table); 636} 637#else 638static int ip4_frags_ns_ctl_register(struct net *net) 639{ 640 return 0; 641} 642 643static void ip4_frags_ns_ctl_unregister(struct net *net) 644{ 645} 646 647static void __init ip4_frags_ctl_register(void) 648{ 649} 650#endif 651 652static int __net_init ipv4_frags_init_net(struct net *net) 653{ 654 int res; 655 656 res = fqdir_init(&net->ipv4.fqdir, &ip4_frags, net); 657 if (res < 0) 658 return res; 659 /* Fragment cache limits. 660 * 661 * The fragment memory accounting code, (tries to) account for 662 * the real memory usage, by measuring both the size of frag 663 * queue struct (inet_frag_queue (ipv4:ipq/ipv6:frag_queue)) 664 * and the SKB's truesize. 665 * 666 * A 64K fragment consumes 129736 bytes (44*2944)+200 667 * (1500 truesize == 2944, sizeof(struct ipq) == 200) 668 * 669 * We will commit 4MB at one time. Should we cross that limit 670 * we will prune down to 3MB, making room for approx 8 big 64K 671 * fragments 8x128k. 672 */ 673 net->ipv4.fqdir->high_thresh = 4 * 1024 * 1024; 674 net->ipv4.fqdir->low_thresh = 3 * 1024 * 1024; 675 /* 676 * Important NOTE! Fragment queue must be destroyed before MSL expires. 677 * RFC791 is wrong proposing to prolongate timer each fragment arrival 678 * by TTL. 679 */ 680 net->ipv4.fqdir->timeout = IP_FRAG_TIME; 681 682 net->ipv4.fqdir->max_dist = 64; 683 684 res = ip4_frags_ns_ctl_register(net); 685 if (res < 0) 686 fqdir_exit(net->ipv4.fqdir); 687 return res; 688} 689 690static void __net_exit ipv4_frags_pre_exit_net(struct net *net) 691{ 692 fqdir_pre_exit(net->ipv4.fqdir); 693} 694 695static void __net_exit ipv4_frags_exit_net(struct net *net) 696{ 697 ip4_frags_ns_ctl_unregister(net); 698 fqdir_exit(net->ipv4.fqdir); 699} 700 701static struct pernet_operations ip4_frags_ops = { 702 .init = ipv4_frags_init_net, 703 .pre_exit = ipv4_frags_pre_exit_net, 704 .exit = ipv4_frags_exit_net, 705}; 706 707 708static u32 ip4_key_hashfn(const void *data, u32 len, u32 seed) 709{ 710 return jhash2(data, 711 sizeof(struct frag_v4_compare_key) / sizeof(u32), seed); 712} 713 714static u32 ip4_obj_hashfn(const void *data, u32 len, u32 seed) 715{ 716 const struct inet_frag_queue *fq = data; 717 718 return jhash2((const u32 *)&fq->key.v4, 719 sizeof(struct frag_v4_compare_key) / sizeof(u32), seed); 720} 721 722static int ip4_obj_cmpfn(struct rhashtable_compare_arg *arg, const void *ptr) 723{ 724 const struct frag_v4_compare_key *key = arg->key; 725 const struct inet_frag_queue *fq = ptr; 726 727 return !!memcmp(&fq->key, key, sizeof(*key)); 728} 729 730static const struct rhashtable_params ip4_rhash_params = { 731 .head_offset = offsetof(struct inet_frag_queue, node), 732 .key_offset = offsetof(struct inet_frag_queue, key), 733 .key_len = sizeof(struct frag_v4_compare_key), 734 .hashfn = ip4_key_hashfn, 735 .obj_hashfn = ip4_obj_hashfn, 736 .obj_cmpfn = ip4_obj_cmpfn, 737 .automatic_shrinking = true, 738}; 739 740void __init ipfrag_init(void) 741{ 742 ip4_frags.constructor = ip4_frag_init; 743 ip4_frags.destructor = ip4_frag_free; 744 ip4_frags.qsize = sizeof(struct ipq); 745 ip4_frags.frag_expire = ip_expire; 746 ip4_frags.frags_cache_name = ip_frag_cache_name; 747 ip4_frags.rhash_params = ip4_rhash_params; 748 if (inet_frags_init(&ip4_frags)) 749 panic("IP: failed to allocate ip4_frags cache\n"); 750 ip4_frags_ctl_register(); 751 register_pernet_subsys(&ip4_frags_ops); 752} 753