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