[INET]: Consolidate the xxx_frag_kill
[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  * 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 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 struct inet_frags_ctl ip4_frags_ctl __read_mostly = {
78         /*
79          * Fragment cache limits. We will commit 256K at one time. Should we
80          * cross that limit we will prune down to 192K. This should cope with
81          * even the most extreme cases without allowing an attacker to
82          * measurably harm machine performance.
83          */
84         .high_thresh     = 256 * 1024,
85         .low_thresh      = 192 * 1024,
86
87         /*
88          * Important NOTE! Fragment queue must be destroyed before MSL expires.
89          * RFC791 is wrong proposing to prolongate timer each fragment arrival
90          * by TTL.
91          */
92         .timeout         = IP_FRAG_TIME,
93         .secret_interval = 10 * 60 * HZ,
94 };
95
96 static struct inet_frags ip4_frags;
97
98 int ip_frag_nqueues(void)
99 {
100         return ip4_frags.nqueues;
101 }
102
103 int ip_frag_mem(void)
104 {
105         return atomic_read(&ip4_frags.mem);
106 }
107
108 static int ip_frag_reasm(struct ipq *qp, struct sk_buff *prev,
109                          struct net_device *dev);
110
111 static unsigned int ipqhashfn(__be16 id, __be32 saddr, __be32 daddr, u8 prot)
112 {
113         return jhash_3words((__force u32)id << 16 | prot,
114                             (__force u32)saddr, (__force u32)daddr,
115                             ip4_frags.rnd) & (INETFRAGS_HASHSZ - 1);
116 }
117
118 static void ipfrag_secret_rebuild(unsigned long dummy)
119 {
120         unsigned long now = jiffies;
121         int i;
122
123         write_lock(&ip4_frags.lock);
124         get_random_bytes(&ip4_frags.rnd, sizeof(u32));
125         for (i = 0; i < INETFRAGS_HASHSZ; i++) {
126                 struct ipq *q;
127                 struct hlist_node *p, *n;
128
129                 hlist_for_each_entry_safe(q, p, n, &ip4_frags.hash[i], q.list) {
130                         unsigned int hval = ipqhashfn(q->id, q->saddr,
131                                                       q->daddr, q->protocol);
132
133                         if (hval != i) {
134                                 hlist_del(&q->q.list);
135
136                                 /* Relink to new hash chain. */
137                                 hlist_add_head(&q->q.list, &ip4_frags.hash[hval]);
138                         }
139                 }
140         }
141         write_unlock(&ip4_frags.lock);
142
143         mod_timer(&ip4_frags.secret_timer, now + ip4_frags_ctl.secret_interval);
144 }
145
146 /* Memory Tracking Functions. */
147 static __inline__ void frag_kfree_skb(struct sk_buff *skb, int *work)
148 {
149         if (work)
150                 *work -= skb->truesize;
151         atomic_sub(skb->truesize, &ip4_frags.mem);
152         kfree_skb(skb);
153 }
154
155 static __inline__ void frag_free_queue(struct ipq *qp, int *work)
156 {
157         if (work)
158                 *work -= sizeof(struct ipq);
159         atomic_sub(sizeof(struct ipq), &ip4_frags.mem);
160         kfree(qp);
161 }
162
163 static __inline__ struct ipq *frag_alloc_queue(void)
164 {
165         struct ipq *qp = kmalloc(sizeof(struct ipq), GFP_ATOMIC);
166
167         if (!qp)
168                 return NULL;
169         atomic_add(sizeof(struct ipq), &ip4_frags.mem);
170         return qp;
171 }
172
173
174 /* Destruction primitives. */
175
176 /* Complete destruction of ipq. */
177 static void ip_frag_destroy(struct ipq *qp, int *work)
178 {
179         struct sk_buff *fp;
180
181         BUG_TRAP(qp->q.last_in&COMPLETE);
182         BUG_TRAP(del_timer(&qp->q.timer) == 0);
183
184         if (qp->peer)
185                 inet_putpeer(qp->peer);
186
187         /* Release all fragment data. */
188         fp = qp->q.fragments;
189         while (fp) {
190                 struct sk_buff *xp = fp->next;
191
192                 frag_kfree_skb(fp, work);
193                 fp = xp;
194         }
195
196         /* Finally, release the queue descriptor itself. */
197         frag_free_queue(qp, work);
198 }
199
200 static __inline__ void ipq_put(struct ipq *ipq, int *work)
201 {
202         if (atomic_dec_and_test(&ipq->q.refcnt))
203                 ip_frag_destroy(ipq, work);
204 }
205
206 /* Kill ipq entry. It is not destroyed immediately,
207  * because caller (and someone more) holds reference count.
208  */
209 static void ipq_kill(struct ipq *ipq)
210 {
211         inet_frag_kill(&ipq->q, &ip4_frags);
212 }
213
214 /* Memory limiting on fragments.  Evictor trashes the oldest
215  * fragment queue until we are back under the threshold.
216  */
217 static void ip_evictor(void)
218 {
219         struct ipq *qp;
220         struct list_head *tmp;
221         int work;
222
223         work = atomic_read(&ip4_frags.mem) - ip4_frags_ctl.low_thresh;
224         if (work <= 0)
225                 return;
226
227         while (work > 0) {
228                 read_lock(&ip4_frags.lock);
229                 if (list_empty(&ip4_frags.lru_list)) {
230                         read_unlock(&ip4_frags.lock);
231                         return;
232                 }
233                 tmp = ip4_frags.lru_list.next;
234                 qp = list_entry(tmp, struct ipq, q.lru_list);
235                 atomic_inc(&qp->q.refcnt);
236                 read_unlock(&ip4_frags.lock);
237
238                 spin_lock(&qp->q.lock);
239                 if (!(qp->q.last_in&COMPLETE))
240                         ipq_kill(qp);
241                 spin_unlock(&qp->q.lock);
242
243                 ipq_put(qp, &work);
244                 IP_INC_STATS_BH(IPSTATS_MIB_REASMFAILS);
245         }
246 }
247
248 /*
249  * Oops, a fragment queue timed out.  Kill it and send an ICMP reply.
250  */
251 static void ip_expire(unsigned long arg)
252 {
253         struct ipq *qp = (struct ipq *) arg;
254
255         spin_lock(&qp->q.lock);
256
257         if (qp->q.last_in & COMPLETE)
258                 goto out;
259
260         ipq_kill(qp);
261
262         IP_INC_STATS_BH(IPSTATS_MIB_REASMTIMEOUT);
263         IP_INC_STATS_BH(IPSTATS_MIB_REASMFAILS);
264
265         if ((qp->q.last_in&FIRST_IN) && qp->q.fragments != NULL) {
266                 struct sk_buff *head = qp->q.fragments;
267                 /* Send an ICMP "Fragment Reassembly Timeout" message. */
268                 if ((head->dev = dev_get_by_index(&init_net, qp->iif)) != NULL) {
269                         icmp_send(head, ICMP_TIME_EXCEEDED, ICMP_EXC_FRAGTIME, 0);
270                         dev_put(head->dev);
271                 }
272         }
273 out:
274         spin_unlock(&qp->q.lock);
275         ipq_put(qp, NULL);
276 }
277
278 /* Creation primitives. */
279
280 static struct ipq *ip_frag_intern(struct ipq *qp_in)
281 {
282         struct ipq *qp;
283 #ifdef CONFIG_SMP
284         struct hlist_node *n;
285 #endif
286         unsigned int hash;
287
288         write_lock(&ip4_frags.lock);
289         hash = ipqhashfn(qp_in->id, qp_in->saddr, qp_in->daddr,
290                          qp_in->protocol);
291 #ifdef CONFIG_SMP
292         /* With SMP race we have to recheck hash table, because
293          * such entry could be created on other cpu, while we
294          * promoted read lock to write lock.
295          */
296         hlist_for_each_entry(qp, n, &ip4_frags.hash[hash], q.list) {
297                 if (qp->id == qp_in->id         &&
298                     qp->saddr == qp_in->saddr   &&
299                     qp->daddr == qp_in->daddr   &&
300                     qp->protocol == qp_in->protocol &&
301                     qp->user == qp_in->user) {
302                         atomic_inc(&qp->q.refcnt);
303                         write_unlock(&ip4_frags.lock);
304                         qp_in->q.last_in |= COMPLETE;
305                         ipq_put(qp_in, NULL);
306                         return qp;
307                 }
308         }
309 #endif
310         qp = qp_in;
311
312         if (!mod_timer(&qp->q.timer, jiffies + ip4_frags_ctl.timeout))
313                 atomic_inc(&qp->q.refcnt);
314
315         atomic_inc(&qp->q.refcnt);
316         hlist_add_head(&qp->q.list, &ip4_frags.hash[hash]);
317         INIT_LIST_HEAD(&qp->q.lru_list);
318         list_add_tail(&qp->q.lru_list, &ip4_frags.lru_list);
319         ip4_frags.nqueues++;
320         write_unlock(&ip4_frags.lock);
321         return qp;
322 }
323
324 /* Add an entry to the 'ipq' queue for a newly received IP datagram. */
325 static struct ipq *ip_frag_create(struct iphdr *iph, u32 user)
326 {
327         struct ipq *qp;
328
329         if ((qp = frag_alloc_queue()) == NULL)
330                 goto out_nomem;
331
332         qp->protocol = iph->protocol;
333         qp->q.last_in = 0;
334         qp->id = iph->id;
335         qp->saddr = iph->saddr;
336         qp->daddr = iph->daddr;
337         qp->user = user;
338         qp->q.len = 0;
339         qp->q.meat = 0;
340         qp->q.fragments = NULL;
341         qp->iif = 0;
342         qp->peer = sysctl_ipfrag_max_dist ? inet_getpeer(iph->saddr, 1) : NULL;
343
344         /* Initialize a timer for this entry. */
345         init_timer(&qp->q.timer);
346         qp->q.timer.data = (unsigned long) qp;  /* pointer to queue     */
347         qp->q.timer.function = ip_expire;               /* expire function      */
348         spin_lock_init(&qp->q.lock);
349         atomic_set(&qp->q.refcnt, 1);
350
351         return ip_frag_intern(qp);
352
353 out_nomem:
354         LIMIT_NETDEBUG(KERN_ERR "ip_frag_create: no memory left !\n");
355         return NULL;
356 }
357
358 /* Find the correct entry in the "incomplete datagrams" queue for
359  * this IP datagram, and create new one, if nothing is found.
360  */
361 static inline struct ipq *ip_find(struct iphdr *iph, u32 user)
362 {
363         __be16 id = iph->id;
364         __be32 saddr = iph->saddr;
365         __be32 daddr = iph->daddr;
366         __u8 protocol = iph->protocol;
367         unsigned int hash;
368         struct ipq *qp;
369         struct hlist_node *n;
370
371         read_lock(&ip4_frags.lock);
372         hash = ipqhashfn(id, saddr, daddr, protocol);
373         hlist_for_each_entry(qp, n, &ip4_frags.hash[hash], q.list) {
374                 if (qp->id == id                &&
375                     qp->saddr == saddr  &&
376                     qp->daddr == daddr  &&
377                     qp->protocol == protocol &&
378                     qp->user == user) {
379                         atomic_inc(&qp->q.refcnt);
380                         read_unlock(&ip4_frags.lock);
381                         return qp;
382                 }
383         }
384         read_unlock(&ip4_frags.lock);
385
386         return ip_frag_create(iph, user);
387 }
388
389 /* Is the fragment too far ahead to be part of ipq? */
390 static inline int ip_frag_too_far(struct ipq *qp)
391 {
392         struct inet_peer *peer = qp->peer;
393         unsigned int max = sysctl_ipfrag_max_dist;
394         unsigned int start, end;
395
396         int rc;
397
398         if (!peer || !max)
399                 return 0;
400
401         start = qp->rid;
402         end = atomic_inc_return(&peer->rid);
403         qp->rid = end;
404
405         rc = qp->q.fragments && (end - start) > max;
406
407         if (rc) {
408                 IP_INC_STATS_BH(IPSTATS_MIB_REASMFAILS);
409         }
410
411         return rc;
412 }
413
414 static int ip_frag_reinit(struct ipq *qp)
415 {
416         struct sk_buff *fp;
417
418         if (!mod_timer(&qp->q.timer, jiffies + ip4_frags_ctl.timeout)) {
419                 atomic_inc(&qp->q.refcnt);
420                 return -ETIMEDOUT;
421         }
422
423         fp = qp->q.fragments;
424         do {
425                 struct sk_buff *xp = fp->next;
426                 frag_kfree_skb(fp, NULL);
427                 fp = xp;
428         } while (fp);
429
430         qp->q.last_in = 0;
431         qp->q.len = 0;
432         qp->q.meat = 0;
433         qp->q.fragments = NULL;
434         qp->iif = 0;
435
436         return 0;
437 }
438
439 /* Add new segment to existing queue. */
440 static int ip_frag_queue(struct ipq *qp, struct sk_buff *skb)
441 {
442         struct sk_buff *prev, *next;
443         struct net_device *dev;
444         int flags, offset;
445         int ihl, end;
446         int err = -ENOENT;
447
448         if (qp->q.last_in & COMPLETE)
449                 goto err;
450
451         if (!(IPCB(skb)->flags & IPSKB_FRAG_COMPLETE) &&
452             unlikely(ip_frag_too_far(qp)) &&
453             unlikely(err = ip_frag_reinit(qp))) {
454                 ipq_kill(qp);
455                 goto err;
456         }
457
458         offset = ntohs(ip_hdr(skb)->frag_off);
459         flags = offset & ~IP_OFFSET;
460         offset &= IP_OFFSET;
461         offset <<= 3;           /* offset is in 8-byte chunks */
462         ihl = ip_hdrlen(skb);
463
464         /* Determine the position of this fragment. */
465         end = offset + skb->len - ihl;
466         err = -EINVAL;
467
468         /* Is this the final fragment? */
469         if ((flags & IP_MF) == 0) {
470                 /* If we already have some bits beyond end
471                  * or have different end, the segment is corrrupted.
472                  */
473                 if (end < qp->q.len ||
474                     ((qp->q.last_in & LAST_IN) && end != qp->q.len))
475                         goto err;
476                 qp->q.last_in |= LAST_IN;
477                 qp->q.len = end;
478         } else {
479                 if (end&7) {
480                         end &= ~7;
481                         if (skb->ip_summed != CHECKSUM_UNNECESSARY)
482                                 skb->ip_summed = CHECKSUM_NONE;
483                 }
484                 if (end > qp->q.len) {
485                         /* Some bits beyond end -> corruption. */
486                         if (qp->q.last_in & LAST_IN)
487                                 goto err;
488                         qp->q.len = end;
489                 }
490         }
491         if (end == offset)
492                 goto err;
493
494         err = -ENOMEM;
495         if (pskb_pull(skb, ihl) == NULL)
496                 goto err;
497
498         err = pskb_trim_rcsum(skb, end - offset);
499         if (err)
500                 goto err;
501
502         /* Find out which fragments are in front and at the back of us
503          * in the chain of fragments so far.  We must know where to put
504          * this fragment, right?
505          */
506         prev = NULL;
507         for (next = qp->q.fragments; next != NULL; next = next->next) {
508                 if (FRAG_CB(next)->offset >= offset)
509                         break;  /* bingo! */
510                 prev = next;
511         }
512
513         /* We found where to put this one.  Check for overlap with
514          * preceding fragment, and, if needed, align things so that
515          * any overlaps are eliminated.
516          */
517         if (prev) {
518                 int i = (FRAG_CB(prev)->offset + prev->len) - offset;
519
520                 if (i > 0) {
521                         offset += i;
522                         err = -EINVAL;
523                         if (end <= offset)
524                                 goto err;
525                         err = -ENOMEM;
526                         if (!pskb_pull(skb, i))
527                                 goto err;
528                         if (skb->ip_summed != CHECKSUM_UNNECESSARY)
529                                 skb->ip_summed = CHECKSUM_NONE;
530                 }
531         }
532
533         err = -ENOMEM;
534
535         while (next && FRAG_CB(next)->offset < end) {
536                 int i = end - FRAG_CB(next)->offset; /* overlap is 'i' bytes */
537
538                 if (i < next->len) {
539                         /* Eat head of the next overlapped fragment
540                          * and leave the loop. The next ones cannot overlap.
541                          */
542                         if (!pskb_pull(next, i))
543                                 goto err;
544                         FRAG_CB(next)->offset += i;
545                         qp->q.meat -= i;
546                         if (next->ip_summed != CHECKSUM_UNNECESSARY)
547                                 next->ip_summed = CHECKSUM_NONE;
548                         break;
549                 } else {
550                         struct sk_buff *free_it = next;
551
552                         /* Old fragment is completely overridden with
553                          * new one drop it.
554                          */
555                         next = next->next;
556
557                         if (prev)
558                                 prev->next = next;
559                         else
560                                 qp->q.fragments = next;
561
562                         qp->q.meat -= free_it->len;
563                         frag_kfree_skb(free_it, NULL);
564                 }
565         }
566
567         FRAG_CB(skb)->offset = offset;
568
569         /* Insert this fragment in the chain of fragments. */
570         skb->next = next;
571         if (prev)
572                 prev->next = skb;
573         else
574                 qp->q.fragments = skb;
575
576         dev = skb->dev;
577         if (dev) {
578                 qp->iif = dev->ifindex;
579                 skb->dev = NULL;
580         }
581         qp->q.stamp = skb->tstamp;
582         qp->q.meat += skb->len;
583         atomic_add(skb->truesize, &ip4_frags.mem);
584         if (offset == 0)
585                 qp->q.last_in |= FIRST_IN;
586
587         if (qp->q.last_in == (FIRST_IN | LAST_IN) && qp->q.meat == qp->q.len)
588                 return ip_frag_reasm(qp, prev, dev);
589
590         write_lock(&ip4_frags.lock);
591         list_move_tail(&qp->q.lru_list, &ip4_frags.lru_list);
592         write_unlock(&ip4_frags.lock);
593         return -EINPROGRESS;
594
595 err:
596         kfree_skb(skb);
597         return err;
598 }
599
600
601 /* Build a new IP datagram from all its fragments. */
602
603 static int ip_frag_reasm(struct ipq *qp, struct sk_buff *prev,
604                          struct net_device *dev)
605 {
606         struct iphdr *iph;
607         struct sk_buff *fp, *head = qp->q.fragments;
608         int len;
609         int ihlen;
610         int err;
611
612         ipq_kill(qp);
613
614         /* Make the one we just received the head. */
615         if (prev) {
616                 head = prev->next;
617                 fp = skb_clone(head, GFP_ATOMIC);
618
619                 if (!fp)
620                         goto out_nomem;
621
622                 fp->next = head->next;
623                 prev->next = fp;
624
625                 skb_morph(head, qp->q.fragments);
626                 head->next = qp->q.fragments->next;
627
628                 kfree_skb(qp->q.fragments);
629                 qp->q.fragments = head;
630         }
631
632         BUG_TRAP(head != NULL);
633         BUG_TRAP(FRAG_CB(head)->offset == 0);
634
635         /* Allocate a new buffer for the datagram. */
636         ihlen = ip_hdrlen(head);
637         len = ihlen + qp->q.len;
638
639         err = -E2BIG;
640         if (len > 65535)
641                 goto out_oversize;
642
643         /* Head of list must not be cloned. */
644         err = -ENOMEM;
645         if (skb_cloned(head) && pskb_expand_head(head, 0, 0, GFP_ATOMIC))
646                 goto out_nomem;
647
648         /* If the first fragment is fragmented itself, we split
649          * it to two chunks: the first with data and paged part
650          * and the second, holding only fragments. */
651         if (skb_shinfo(head)->frag_list) {
652                 struct sk_buff *clone;
653                 int i, plen = 0;
654
655                 if ((clone = alloc_skb(0, GFP_ATOMIC)) == NULL)
656                         goto out_nomem;
657                 clone->next = head->next;
658                 head->next = clone;
659                 skb_shinfo(clone)->frag_list = skb_shinfo(head)->frag_list;
660                 skb_shinfo(head)->frag_list = NULL;
661                 for (i=0; i<skb_shinfo(head)->nr_frags; i++)
662                         plen += skb_shinfo(head)->frags[i].size;
663                 clone->len = clone->data_len = head->data_len - plen;
664                 head->data_len -= clone->len;
665                 head->len -= clone->len;
666                 clone->csum = 0;
667                 clone->ip_summed = head->ip_summed;
668                 atomic_add(clone->truesize, &ip4_frags.mem);
669         }
670
671         skb_shinfo(head)->frag_list = head->next;
672         skb_push(head, head->data - skb_network_header(head));
673         atomic_sub(head->truesize, &ip4_frags.mem);
674
675         for (fp=head->next; fp; fp = fp->next) {
676                 head->data_len += fp->len;
677                 head->len += fp->len;
678                 if (head->ip_summed != fp->ip_summed)
679                         head->ip_summed = CHECKSUM_NONE;
680                 else if (head->ip_summed == CHECKSUM_COMPLETE)
681                         head->csum = csum_add(head->csum, fp->csum);
682                 head->truesize += fp->truesize;
683                 atomic_sub(fp->truesize, &ip4_frags.mem);
684         }
685
686         head->next = NULL;
687         head->dev = dev;
688         head->tstamp = qp->q.stamp;
689
690         iph = ip_hdr(head);
691         iph->frag_off = 0;
692         iph->tot_len = htons(len);
693         IP_INC_STATS_BH(IPSTATS_MIB_REASMOKS);
694         qp->q.fragments = NULL;
695         return 0;
696
697 out_nomem:
698         LIMIT_NETDEBUG(KERN_ERR "IP: queue_glue: no memory for gluing "
699                               "queue %p\n", qp);
700         goto out_fail;
701 out_oversize:
702         if (net_ratelimit())
703                 printk(KERN_INFO
704                         "Oversized IP packet from %d.%d.%d.%d.\n",
705                         NIPQUAD(qp->saddr));
706 out_fail:
707         IP_INC_STATS_BH(IPSTATS_MIB_REASMFAILS);
708         return err;
709 }
710
711 /* Process an incoming IP datagram fragment. */
712 int ip_defrag(struct sk_buff *skb, u32 user)
713 {
714         struct ipq *qp;
715
716         IP_INC_STATS_BH(IPSTATS_MIB_REASMREQDS);
717
718         /* Start by cleaning up the memory. */
719         if (atomic_read(&ip4_frags.mem) > ip4_frags_ctl.high_thresh)
720                 ip_evictor();
721
722         /* Lookup (or create) queue header */
723         if ((qp = ip_find(ip_hdr(skb), user)) != NULL) {
724                 int ret;
725
726                 spin_lock(&qp->q.lock);
727
728                 ret = ip_frag_queue(qp, skb);
729
730                 spin_unlock(&qp->q.lock);
731                 ipq_put(qp, NULL);
732                 return ret;
733         }
734
735         IP_INC_STATS_BH(IPSTATS_MIB_REASMFAILS);
736         kfree_skb(skb);
737         return -ENOMEM;
738 }
739
740 void __init ipfrag_init(void)
741 {
742         init_timer(&ip4_frags.secret_timer);
743         ip4_frags.secret_timer.function = ipfrag_secret_rebuild;
744         ip4_frags.secret_timer.expires = jiffies + ip4_frags_ctl.secret_interval;
745         add_timer(&ip4_frags.secret_timer);
746
747         ip4_frags.ctl = &ip4_frags_ctl;
748         inet_frags_init(&ip4_frags);
749 }
750
751 EXPORT_SYMBOL(ip_defrag);