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