f4dc879e258eafc5b09c0ead319c7a4d0e61d6a3
[linux-3.10.git] / net / ipv4 / ip_fragment.c
1 /*
2  * INET         An implementation of the TCP/IP protocol suite for the LINUX
3  *              operating system.  INET is implemented using the  BSD Socket
4  *              interface as the means of communication with the user level.
5  *
6  *              The IP fragmentation functionality.
7  *
8  * Authors:     Fred N. van Kempen <waltje@uWalt.NL.Mugnet.ORG>
9  *              Alan Cox <alan@lxorguk.ukuu.org.uk>
10  *
11  * Fixes:
12  *              Alan Cox        :       Split from ip.c , see ip_input.c for history.
13  *              David S. Miller :       Begin massive cleanup...
14  *              Andi Kleen      :       Add sysctls.
15  *              xxxx            :       Overlapfrag bug.
16  *              Ultima          :       ip_expire() kernel panic.
17  *              Bill Hawes      :       Frag accounting and evictor fixes.
18  *              John McDonald   :       0 length frag bug.
19  *              Alexey Kuznetsov:       SMP races, threading, cleanup.
20  *              Patrick McHardy :       LRU queue of frag heads for evictor.
21  */
22
23 #include <linux/compiler.h>
24 #include <linux/module.h>
25 #include <linux/types.h>
26 #include <linux/mm.h>
27 #include <linux/jiffies.h>
28 #include <linux/skbuff.h>
29 #include <linux/list.h>
30 #include <linux/ip.h>
31 #include <linux/icmp.h>
32 #include <linux/netdevice.h>
33 #include <linux/jhash.h>
34 #include <linux/random.h>
35 #include <linux/slab.h>
36 #include <net/route.h>
37 #include <net/dst.h>
38 #include <net/sock.h>
39 #include <net/ip.h>
40 #include <net/icmp.h>
41 #include <net/checksum.h>
42 #include <net/inetpeer.h>
43 #include <net/inet_frag.h>
44 #include <linux/tcp.h>
45 #include <linux/udp.h>
46 #include <linux/inet.h>
47 #include <linux/netfilter_ipv4.h>
48
49 /* NOTE. Logic of IP defragmentation is parallel to corresponding IPv6
50  * code now. If you change something here, _PLEASE_ update ipv6/reassembly.c
51  * as well. Or notify me, at least. --ANK
52  */
53
54 static int sysctl_ipfrag_max_dist __read_mostly = 64;
55
56 struct ipfrag_skb_cb
57 {
58         struct inet_skb_parm    h;
59         int                     offset;
60 };
61
62 #define FRAG_CB(skb)    ((struct ipfrag_skb_cb *)((skb)->cb))
63
64 /* Describe an entry in the "incomplete datagrams" queue. */
65 struct ipq {
66         struct inet_frag_queue q;
67
68         u32             user;
69         __be32          saddr;
70         __be32          daddr;
71         __be16          id;
72         u8              protocol;
73         int             iif;
74         unsigned int    rid;
75         struct inet_peer *peer;
76 };
77
78 static struct inet_frags ip4_frags;
79
80 int ip_frag_nqueues(struct net *net)
81 {
82         return net->ipv4.frags.nqueues;
83 }
84
85 int ip_frag_mem(struct net *net)
86 {
87         return atomic_read(&net->ipv4.frags.mem);
88 }
89
90 static int ip_frag_reasm(struct ipq *qp, struct sk_buff *prev,
91                          struct net_device *dev);
92
93 struct ip4_create_arg {
94         struct iphdr *iph;
95         u32 user;
96 };
97
98 static unsigned int ipqhashfn(__be16 id, __be32 saddr, __be32 daddr, u8 prot)
99 {
100         return jhash_3words((__force u32)id << 16 | prot,
101                             (__force u32)saddr, (__force u32)daddr,
102                             ip4_frags.rnd) & (INETFRAGS_HASHSZ - 1);
103 }
104
105 static unsigned int ip4_hashfn(struct inet_frag_queue *q)
106 {
107         struct ipq *ipq;
108
109         ipq = container_of(q, struct ipq, q);
110         return ipqhashfn(ipq->id, ipq->saddr, ipq->daddr, ipq->protocol);
111 }
112
113 static int ip4_frag_match(struct inet_frag_queue *q, void *a)
114 {
115         struct ipq *qp;
116         struct ip4_create_arg *arg = a;
117
118         qp = container_of(q, struct ipq, q);
119         return (qp->id == arg->iph->id &&
120                         qp->saddr == arg->iph->saddr &&
121                         qp->daddr == arg->iph->daddr &&
122                         qp->protocol == arg->iph->protocol &&
123                         qp->user == arg->user);
124 }
125
126 /* Memory Tracking Functions. */
127 static void frag_kfree_skb(struct netns_frags *nf, struct sk_buff *skb)
128 {
129         atomic_sub(skb->truesize, &nf->mem);
130         kfree_skb(skb);
131 }
132
133 static void ip4_frag_init(struct inet_frag_queue *q, void *a)
134 {
135         struct ipq *qp = container_of(q, struct ipq, q);
136         struct ip4_create_arg *arg = a;
137
138         qp->protocol = arg->iph->protocol;
139         qp->id = arg->iph->id;
140         qp->saddr = arg->iph->saddr;
141         qp->daddr = arg->iph->daddr;
142         qp->user = arg->user;
143         qp->peer = sysctl_ipfrag_max_dist ?
144                 inet_getpeer(arg->iph->saddr, 1) : NULL;
145 }
146
147 static __inline__ void ip4_frag_free(struct inet_frag_queue *q)
148 {
149         struct ipq *qp;
150
151         qp = container_of(q, struct ipq, q);
152         if (qp->peer)
153                 inet_putpeer(qp->peer);
154 }
155
156
157 /* Destruction primitives. */
158
159 static __inline__ void ipq_put(struct ipq *ipq)
160 {
161         inet_frag_put(&ipq->q, &ip4_frags);
162 }
163
164 /* Kill ipq entry. It is not destroyed immediately,
165  * because caller (and someone more) holds reference count.
166  */
167 static void ipq_kill(struct ipq *ipq)
168 {
169         inet_frag_kill(&ipq->q, &ip4_frags);
170 }
171
172 /* Memory limiting on fragments.  Evictor trashes the oldest
173  * fragment queue until we are back under the threshold.
174  */
175 static void ip_evictor(struct net *net)
176 {
177         int evicted;
178
179         evicted = inet_frag_evictor(&net->ipv4.frags, &ip4_frags);
180         if (evicted)
181                 IP_ADD_STATS_BH(net, IPSTATS_MIB_REASMFAILS, evicted);
182 }
183
184 /*
185  * Oops, a fragment queue timed out.  Kill it and send an ICMP reply.
186  */
187 static void ip_expire(unsigned long arg)
188 {
189         struct ipq *qp;
190         struct net *net;
191
192         qp = container_of((struct inet_frag_queue *) arg, struct ipq, q);
193         net = container_of(qp->q.net, struct net, ipv4.frags);
194
195         spin_lock(&qp->q.lock);
196
197         if (qp->q.last_in & INET_FRAG_COMPLETE)
198                 goto out;
199
200         ipq_kill(qp);
201
202         IP_INC_STATS_BH(net, IPSTATS_MIB_REASMTIMEOUT);
203         IP_INC_STATS_BH(net, IPSTATS_MIB_REASMFAILS);
204
205         if ((qp->q.last_in & INET_FRAG_FIRST_IN) && qp->q.fragments != NULL) {
206                 struct sk_buff *head = qp->q.fragments;
207
208                 rcu_read_lock();
209                 head->dev = dev_get_by_index_rcu(net, qp->iif);
210                 if (!head->dev)
211                         goto out_rcu_unlock;
212
213                 /*
214                  * Only search router table for the head fragment,
215                  * when defraging timeout at PRE_ROUTING HOOK.
216                  */
217                 if (qp->user == IP_DEFRAG_CONNTRACK_IN && !skb_dst(head)) {
218                         const struct iphdr *iph = ip_hdr(head);
219                         int err = ip_route_input(head, iph->daddr, iph->saddr,
220                                                  iph->tos, head->dev);
221                         if (unlikely(err))
222                                 goto out_rcu_unlock;
223
224                         /*
225                          * Only an end host needs to send an ICMP
226                          * "Fragment Reassembly Timeout" message, per RFC792.
227                          */
228                         if (skb_rtable(head)->rt_type != RTN_LOCAL)
229                                 goto out_rcu_unlock;
230
231                 }
232
233                 /* Send an ICMP "Fragment Reassembly Timeout" message. */
234                 icmp_send(head, ICMP_TIME_EXCEEDED, ICMP_EXC_FRAGTIME, 0);
235 out_rcu_unlock:
236                 rcu_read_unlock();
237         }
238 out:
239         spin_unlock(&qp->q.lock);
240         ipq_put(qp);
241 }
242
243 /* Find the correct entry in the "incomplete datagrams" queue for
244  * this IP datagram, and create new one, if nothing is found.
245  */
246 static inline struct ipq *ip_find(struct net *net, struct iphdr *iph, u32 user)
247 {
248         struct inet_frag_queue *q;
249         struct ip4_create_arg arg;
250         unsigned int hash;
251
252         arg.iph = iph;
253         arg.user = user;
254
255         read_lock(&ip4_frags.lock);
256         hash = ipqhashfn(iph->id, iph->saddr, iph->daddr, iph->protocol);
257
258         q = inet_frag_find(&net->ipv4.frags, &ip4_frags, &arg, hash);
259         if (q == NULL)
260                 goto out_nomem;
261
262         return container_of(q, struct ipq, q);
263
264 out_nomem:
265         LIMIT_NETDEBUG(KERN_ERR "ip_frag_create: no memory left !\n");
266         return NULL;
267 }
268
269 /* Is the fragment too far ahead to be part of ipq? */
270 static inline int ip_frag_too_far(struct ipq *qp)
271 {
272         struct inet_peer *peer = qp->peer;
273         unsigned int max = sysctl_ipfrag_max_dist;
274         unsigned int start, end;
275
276         int rc;
277
278         if (!peer || !max)
279                 return 0;
280
281         start = qp->rid;
282         end = atomic_inc_return(&peer->rid);
283         qp->rid = end;
284
285         rc = qp->q.fragments && (end - start) > max;
286
287         if (rc) {
288                 struct net *net;
289
290                 net = container_of(qp->q.net, struct net, ipv4.frags);
291                 IP_INC_STATS_BH(net, IPSTATS_MIB_REASMFAILS);
292         }
293
294         return rc;
295 }
296
297 static int ip_frag_reinit(struct ipq *qp)
298 {
299         struct sk_buff *fp;
300
301         if (!mod_timer(&qp->q.timer, jiffies + qp->q.net->timeout)) {
302                 atomic_inc(&qp->q.refcnt);
303                 return -ETIMEDOUT;
304         }
305
306         fp = qp->q.fragments;
307         do {
308                 struct sk_buff *xp = fp->next;
309                 frag_kfree_skb(qp->q.net, fp);
310                 fp = xp;
311         } while (fp);
312
313         qp->q.last_in = 0;
314         qp->q.len = 0;
315         qp->q.meat = 0;
316         qp->q.fragments = NULL;
317         qp->q.fragments_tail = NULL;
318         qp->iif = 0;
319
320         return 0;
321 }
322
323 /* Add new segment to existing queue. */
324 static int ip_frag_queue(struct ipq *qp, struct sk_buff *skb)
325 {
326         struct sk_buff *prev, *next;
327         struct net_device *dev;
328         int flags, offset;
329         int ihl, end;
330         int err = -ENOENT;
331
332         if (qp->q.last_in & INET_FRAG_COMPLETE)
333                 goto err;
334
335         if (!(IPCB(skb)->flags & IPSKB_FRAG_COMPLETE) &&
336             unlikely(ip_frag_too_far(qp)) &&
337             unlikely(err = ip_frag_reinit(qp))) {
338                 ipq_kill(qp);
339                 goto err;
340         }
341
342         offset = ntohs(ip_hdr(skb)->frag_off);
343         flags = offset & ~IP_OFFSET;
344         offset &= IP_OFFSET;
345         offset <<= 3;           /* offset is in 8-byte chunks */
346         ihl = ip_hdrlen(skb);
347
348         /* Determine the position of this fragment. */
349         end = offset + skb->len - ihl;
350         err = -EINVAL;
351
352         /* Is this the final fragment? */
353         if ((flags & IP_MF) == 0) {
354                 /* If we already have some bits beyond end
355                  * or have different end, the segment is corrrupted.
356                  */
357                 if (end < qp->q.len ||
358                     ((qp->q.last_in & INET_FRAG_LAST_IN) && end != qp->q.len))
359                         goto err;
360                 qp->q.last_in |= INET_FRAG_LAST_IN;
361                 qp->q.len = end;
362         } else {
363                 if (end&7) {
364                         end &= ~7;
365                         if (skb->ip_summed != CHECKSUM_UNNECESSARY)
366                                 skb->ip_summed = CHECKSUM_NONE;
367                 }
368                 if (end > qp->q.len) {
369                         /* Some bits beyond end -> corruption. */
370                         if (qp->q.last_in & INET_FRAG_LAST_IN)
371                                 goto err;
372                         qp->q.len = end;
373                 }
374         }
375         if (end == offset)
376                 goto err;
377
378         err = -ENOMEM;
379         if (pskb_pull(skb, ihl) == NULL)
380                 goto err;
381
382         err = pskb_trim_rcsum(skb, end - offset);
383         if (err)
384                 goto err;
385
386         /* Find out which fragments are in front and at the back of us
387          * in the chain of fragments so far.  We must know where to put
388          * this fragment, right?
389          */
390         prev = qp->q.fragments_tail;
391         if (!prev || FRAG_CB(prev)->offset < offset) {
392                 next = NULL;
393                 goto found;
394         }
395         prev = NULL;
396         for (next = qp->q.fragments; next != NULL; next = next->next) {
397                 if (FRAG_CB(next)->offset >= offset)
398                         break;  /* bingo! */
399                 prev = next;
400         }
401
402 found:
403         /* We found where to put this one.  Check for overlap with
404          * preceding fragment, and, if needed, align things so that
405          * any overlaps are eliminated.
406          */
407         if (prev) {
408                 int i = (FRAG_CB(prev)->offset + prev->len) - offset;
409
410                 if (i > 0) {
411                         offset += i;
412                         err = -EINVAL;
413                         if (end <= offset)
414                                 goto err;
415                         err = -ENOMEM;
416                         if (!pskb_pull(skb, i))
417                                 goto err;
418                         if (skb->ip_summed != CHECKSUM_UNNECESSARY)
419                                 skb->ip_summed = CHECKSUM_NONE;
420                 }
421         }
422
423         err = -ENOMEM;
424
425         while (next && FRAG_CB(next)->offset < end) {
426                 int i = end - FRAG_CB(next)->offset; /* overlap is 'i' bytes */
427
428                 if (i < next->len) {
429                         /* Eat head of the next overlapped fragment
430                          * and leave the loop. The next ones cannot overlap.
431                          */
432                         if (!pskb_pull(next, i))
433                                 goto err;
434                         FRAG_CB(next)->offset += i;
435                         qp->q.meat -= i;
436                         if (next->ip_summed != CHECKSUM_UNNECESSARY)
437                                 next->ip_summed = CHECKSUM_NONE;
438                         break;
439                 } else {
440                         struct sk_buff *free_it = next;
441
442                         /* Old fragment is completely overridden with
443                          * new one drop it.
444                          */
445                         next = next->next;
446
447                         if (prev)
448                                 prev->next = next;
449                         else
450                                 qp->q.fragments = next;
451
452                         qp->q.meat -= free_it->len;
453                         frag_kfree_skb(qp->q.net, free_it);
454                 }
455         }
456
457         FRAG_CB(skb)->offset = offset;
458
459         /* Insert this fragment in the chain of fragments. */
460         skb->next = next;
461         if (!next)
462                 qp->q.fragments_tail = skb;
463         if (prev)
464                 prev->next = skb;
465         else
466                 qp->q.fragments = skb;
467
468         dev = skb->dev;
469         if (dev) {
470                 qp->iif = dev->ifindex;
471                 skb->dev = NULL;
472         }
473         qp->q.stamp = skb->tstamp;
474         qp->q.meat += skb->len;
475         atomic_add(skb->truesize, &qp->q.net->mem);
476         if (offset == 0)
477                 qp->q.last_in |= INET_FRAG_FIRST_IN;
478
479         if (qp->q.last_in == (INET_FRAG_FIRST_IN | INET_FRAG_LAST_IN) &&
480             qp->q.meat == qp->q.len)
481                 return ip_frag_reasm(qp, prev, dev);
482
483         write_lock(&ip4_frags.lock);
484         list_move_tail(&qp->q.lru_list, &qp->q.net->lru_list);
485         write_unlock(&ip4_frags.lock);
486         return -EINPROGRESS;
487
488 err:
489         kfree_skb(skb);
490         return err;
491 }
492
493
494 /* Build a new IP datagram from all its fragments. */
495
496 static int ip_frag_reasm(struct ipq *qp, struct sk_buff *prev,
497                          struct net_device *dev)
498 {
499         struct net *net = container_of(qp->q.net, struct net, ipv4.frags);
500         struct iphdr *iph;
501         struct sk_buff *fp, *head = qp->q.fragments;
502         int len;
503         int ihlen;
504         int err;
505
506         ipq_kill(qp);
507
508         /* Make the one we just received the head. */
509         if (prev) {
510                 head = prev->next;
511                 fp = skb_clone(head, GFP_ATOMIC);
512                 if (!fp)
513                         goto out_nomem;
514
515                 fp->next = head->next;
516                 if (!fp->next)
517                         qp->q.fragments_tail = fp;
518                 prev->next = fp;
519
520                 skb_morph(head, qp->q.fragments);
521                 head->next = qp->q.fragments->next;
522
523                 kfree_skb(qp->q.fragments);
524                 qp->q.fragments = head;
525         }
526
527         WARN_ON(head == NULL);
528         WARN_ON(FRAG_CB(head)->offset != 0);
529
530         /* Allocate a new buffer for the datagram. */
531         ihlen = ip_hdrlen(head);
532         len = ihlen + qp->q.len;
533
534         err = -E2BIG;
535         if (len > 65535)
536                 goto out_oversize;
537
538         /* Head of list must not be cloned. */
539         if (skb_cloned(head) && pskb_expand_head(head, 0, 0, GFP_ATOMIC))
540                 goto out_nomem;
541
542         /* If the first fragment is fragmented itself, we split
543          * it to two chunks: the first with data and paged part
544          * and the second, holding only fragments. */
545         if (skb_has_frag_list(head)) {
546                 struct sk_buff *clone;
547                 int i, plen = 0;
548
549                 if ((clone = alloc_skb(0, GFP_ATOMIC)) == NULL)
550                         goto out_nomem;
551                 clone->next = head->next;
552                 head->next = clone;
553                 skb_shinfo(clone)->frag_list = skb_shinfo(head)->frag_list;
554                 skb_frag_list_init(head);
555                 for (i=0; i<skb_shinfo(head)->nr_frags; i++)
556                         plen += skb_shinfo(head)->frags[i].size;
557                 clone->len = clone->data_len = head->data_len - plen;
558                 head->data_len -= clone->len;
559                 head->len -= clone->len;
560                 clone->csum = 0;
561                 clone->ip_summed = head->ip_summed;
562                 atomic_add(clone->truesize, &qp->q.net->mem);
563         }
564
565         skb_shinfo(head)->frag_list = head->next;
566         skb_push(head, head->data - skb_network_header(head));
567
568         for (fp=head->next; fp; fp = fp->next) {
569                 head->data_len += fp->len;
570                 head->len += fp->len;
571                 if (head->ip_summed != fp->ip_summed)
572                         head->ip_summed = CHECKSUM_NONE;
573                 else if (head->ip_summed == CHECKSUM_COMPLETE)
574                         head->csum = csum_add(head->csum, fp->csum);
575                 head->truesize += fp->truesize;
576         }
577         atomic_sub(head->truesize, &qp->q.net->mem);
578
579         head->next = NULL;
580         head->dev = dev;
581         head->tstamp = qp->q.stamp;
582
583         iph = ip_hdr(head);
584         iph->frag_off = 0;
585         iph->tot_len = htons(len);
586         IP_INC_STATS_BH(net, IPSTATS_MIB_REASMOKS);
587         qp->q.fragments = NULL;
588         qp->q.fragments_tail = NULL;
589         return 0;
590
591 out_nomem:
592         LIMIT_NETDEBUG(KERN_ERR "IP: queue_glue: no memory for gluing "
593                               "queue %p\n", qp);
594         err = -ENOMEM;
595         goto out_fail;
596 out_oversize:
597         if (net_ratelimit())
598                 printk(KERN_INFO "Oversized IP packet from %pI4.\n",
599                         &qp->saddr);
600 out_fail:
601         IP_INC_STATS_BH(net, IPSTATS_MIB_REASMFAILS);
602         return err;
603 }
604
605 /* Process an incoming IP datagram fragment. */
606 int ip_defrag(struct sk_buff *skb, u32 user)
607 {
608         struct ipq *qp;
609         struct net *net;
610
611         net = skb->dev ? dev_net(skb->dev) : dev_net(skb_dst(skb)->dev);
612         IP_INC_STATS_BH(net, IPSTATS_MIB_REASMREQDS);
613
614         /* Start by cleaning up the memory. */
615         if (atomic_read(&net->ipv4.frags.mem) > net->ipv4.frags.high_thresh)
616                 ip_evictor(net);
617
618         /* Lookup (or create) queue header */
619         if ((qp = ip_find(net, ip_hdr(skb), user)) != NULL) {
620                 int ret;
621
622                 spin_lock(&qp->q.lock);
623
624                 ret = ip_frag_queue(qp, skb);
625
626                 spin_unlock(&qp->q.lock);
627                 ipq_put(qp);
628                 return ret;
629         }
630
631         IP_INC_STATS_BH(net, IPSTATS_MIB_REASMFAILS);
632         kfree_skb(skb);
633         return -ENOMEM;
634 }
635 EXPORT_SYMBOL(ip_defrag);
636
637 #ifdef CONFIG_SYSCTL
638 static int zero;
639
640 static struct ctl_table ip4_frags_ns_ctl_table[] = {
641         {
642                 .procname       = "ipfrag_high_thresh",
643                 .data           = &init_net.ipv4.frags.high_thresh,
644                 .maxlen         = sizeof(int),
645                 .mode           = 0644,
646                 .proc_handler   = proc_dointvec
647         },
648         {
649                 .procname       = "ipfrag_low_thresh",
650                 .data           = &init_net.ipv4.frags.low_thresh,
651                 .maxlen         = sizeof(int),
652                 .mode           = 0644,
653                 .proc_handler   = proc_dointvec
654         },
655         {
656                 .procname       = "ipfrag_time",
657                 .data           = &init_net.ipv4.frags.timeout,
658                 .maxlen         = sizeof(int),
659                 .mode           = 0644,
660                 .proc_handler   = proc_dointvec_jiffies,
661         },
662         { }
663 };
664
665 static struct ctl_table ip4_frags_ctl_table[] = {
666         {
667                 .procname       = "ipfrag_secret_interval",
668                 .data           = &ip4_frags.secret_interval,
669                 .maxlen         = sizeof(int),
670                 .mode           = 0644,
671                 .proc_handler   = proc_dointvec_jiffies,
672         },
673         {
674                 .procname       = "ipfrag_max_dist",
675                 .data           = &sysctl_ipfrag_max_dist,
676                 .maxlen         = sizeof(int),
677                 .mode           = 0644,
678                 .proc_handler   = proc_dointvec_minmax,
679                 .extra1         = &zero
680         },
681         { }
682 };
683
684 static int __net_init ip4_frags_ns_ctl_register(struct net *net)
685 {
686         struct ctl_table *table;
687         struct ctl_table_header *hdr;
688
689         table = ip4_frags_ns_ctl_table;
690         if (!net_eq(net, &init_net)) {
691                 table = kmemdup(table, sizeof(ip4_frags_ns_ctl_table), GFP_KERNEL);
692                 if (table == NULL)
693                         goto err_alloc;
694
695                 table[0].data = &net->ipv4.frags.high_thresh;
696                 table[1].data = &net->ipv4.frags.low_thresh;
697                 table[2].data = &net->ipv4.frags.timeout;
698         }
699
700         hdr = register_net_sysctl_table(net, net_ipv4_ctl_path, table);
701         if (hdr == NULL)
702                 goto err_reg;
703
704         net->ipv4.frags_hdr = hdr;
705         return 0;
706
707 err_reg:
708         if (!net_eq(net, &init_net))
709                 kfree(table);
710 err_alloc:
711         return -ENOMEM;
712 }
713
714 static void __net_exit ip4_frags_ns_ctl_unregister(struct net *net)
715 {
716         struct ctl_table *table;
717
718         table = net->ipv4.frags_hdr->ctl_table_arg;
719         unregister_net_sysctl_table(net->ipv4.frags_hdr);
720         kfree(table);
721 }
722
723 static void ip4_frags_ctl_register(void)
724 {
725         register_net_sysctl_rotable(net_ipv4_ctl_path, ip4_frags_ctl_table);
726 }
727 #else
728 static inline int ip4_frags_ns_ctl_register(struct net *net)
729 {
730         return 0;
731 }
732
733 static inline void ip4_frags_ns_ctl_unregister(struct net *net)
734 {
735 }
736
737 static inline void ip4_frags_ctl_register(void)
738 {
739 }
740 #endif
741
742 static int __net_init ipv4_frags_init_net(struct net *net)
743 {
744         /*
745          * Fragment cache limits. We will commit 256K at one time. Should we
746          * cross that limit we will prune down to 192K. This should cope with
747          * even the most extreme cases without allowing an attacker to
748          * measurably harm machine performance.
749          */
750         net->ipv4.frags.high_thresh = 256 * 1024;
751         net->ipv4.frags.low_thresh = 192 * 1024;
752         /*
753          * Important NOTE! Fragment queue must be destroyed before MSL expires.
754          * RFC791 is wrong proposing to prolongate timer each fragment arrival
755          * by TTL.
756          */
757         net->ipv4.frags.timeout = IP_FRAG_TIME;
758
759         inet_frags_init_net(&net->ipv4.frags);
760
761         return ip4_frags_ns_ctl_register(net);
762 }
763
764 static void __net_exit ipv4_frags_exit_net(struct net *net)
765 {
766         ip4_frags_ns_ctl_unregister(net);
767         inet_frags_exit_net(&net->ipv4.frags, &ip4_frags);
768 }
769
770 static struct pernet_operations ip4_frags_ops = {
771         .init = ipv4_frags_init_net,
772         .exit = ipv4_frags_exit_net,
773 };
774
775 void __init ipfrag_init(void)
776 {
777         ip4_frags_ctl_register();
778         register_pernet_subsys(&ip4_frags_ops);
779         ip4_frags.hashfn = ip4_hashfn;
780         ip4_frags.constructor = ip4_frag_init;
781         ip4_frags.destructor = ip4_frag_free;
782         ip4_frags.skb_free = NULL;
783         ip4_frags.qsize = sizeof(struct ipq);
784         ip4_frags.match = ip4_frag_match;
785         ip4_frags.frag_expire = ip_expire;
786         ip4_frags.secret_interval = 10 * 60 * HZ;
787         inet_frags_init(&ip4_frags);
788 }