blob: 724d69aed031974234501ff024852b7a55ea1810 [file] [log] [blame]
Pavel Emelyanov7eb95152007-10-15 02:31:52 -07001/*
2 * inet fragments management
3 *
4 * This program is free software; you can redistribute it and/or
5 * modify it under the terms of the GNU General Public License
6 * as published by the Free Software Foundation; either version
7 * 2 of the License, or (at your option) any later version.
8 *
9 * Authors: Pavel Emelyanov <xemul@openvz.org>
10 * Started as consolidation of ipv4/ip_fragment.c,
11 * ipv6/reassembly. and ipv6 nf conntrack reassembly
12 */
13
14#include <linux/list.h>
15#include <linux/spinlock.h>
16#include <linux/module.h>
17#include <linux/timer.h>
18#include <linux/mm.h>
Pavel Emelyanov321a3a92007-10-15 02:38:08 -070019#include <linux/random.h>
Pavel Emelyanov1e4b8282007-10-15 02:39:14 -070020#include <linux/skbuff.h>
21#include <linux/rtnetlink.h>
Pavel Emelyanov7eb95152007-10-15 02:31:52 -070022
23#include <net/inet_frag.h>
24
Pavel Emelyanov321a3a92007-10-15 02:38:08 -070025static void inet_frag_secret_rebuild(unsigned long dummy)
26{
27 struct inet_frags *f = (struct inet_frags *)dummy;
28 unsigned long now = jiffies;
29 int i;
30
31 write_lock(&f->lock);
32 get_random_bytes(&f->rnd, sizeof(u32));
33 for (i = 0; i < INETFRAGS_HASHSZ; i++) {
34 struct inet_frag_queue *q;
35 struct hlist_node *p, *n;
36
37 hlist_for_each_entry_safe(q, p, n, &f->hash[i], list) {
38 unsigned int hval = f->hashfn(q);
39
40 if (hval != i) {
41 hlist_del(&q->list);
42
43 /* Relink to new hash chain. */
44 hlist_add_head(&q->list, &f->hash[hval]);
45 }
46 }
47 }
48 write_unlock(&f->lock);
49
Pavel Emelyanov3b4bc4a2008-01-22 06:11:04 -080050 mod_timer(&f->secret_timer, now + f->secret_interval);
Pavel Emelyanov321a3a92007-10-15 02:38:08 -070051}
52
Pavel Emelyanov7eb95152007-10-15 02:31:52 -070053void inet_frags_init(struct inet_frags *f)
54{
55 int i;
56
57 for (i = 0; i < INETFRAGS_HASHSZ; i++)
58 INIT_HLIST_HEAD(&f->hash[i]);
59
Pavel Emelyanov7eb95152007-10-15 02:31:52 -070060 rwlock_init(&f->lock);
61
62 f->rnd = (u32) ((num_physpages ^ (num_physpages>>7)) ^
63 (jiffies ^ (jiffies >> 6)));
64
Pavel Emelyanovb24b8a22008-01-23 21:20:07 -080065 setup_timer(&f->secret_timer, inet_frag_secret_rebuild,
66 (unsigned long)f);
Pavel Emelyanov3b4bc4a2008-01-22 06:11:04 -080067 f->secret_timer.expires = jiffies + f->secret_interval;
Pavel Emelyanov321a3a92007-10-15 02:38:08 -070068 add_timer(&f->secret_timer);
Pavel Emelyanov7eb95152007-10-15 02:31:52 -070069}
70EXPORT_SYMBOL(inet_frags_init);
71
Pavel Emelyanove5a2bb82008-01-22 06:06:23 -080072void inet_frags_init_net(struct netns_frags *nf)
73{
74 nf->nqueues = 0;
Pavel Emelyanov6ddc0822008-01-22 06:07:25 -080075 atomic_set(&nf->mem, 0);
Pavel Emelyanov3140c252008-01-22 06:11:48 -080076 INIT_LIST_HEAD(&nf->lru_list);
Pavel Emelyanove5a2bb82008-01-22 06:06:23 -080077}
78EXPORT_SYMBOL(inet_frags_init_net);
79
Pavel Emelyanov7eb95152007-10-15 02:31:52 -070080void inet_frags_fini(struct inet_frags *f)
81{
Pavel Emelyanov321a3a92007-10-15 02:38:08 -070082 del_timer(&f->secret_timer);
Pavel Emelyanov7eb95152007-10-15 02:31:52 -070083}
84EXPORT_SYMBOL(inet_frags_fini);
Pavel Emelyanov277e6502007-10-15 02:37:18 -070085
Pavel Emelyanov81566e82008-01-22 06:12:39 -080086void inet_frags_exit_net(struct netns_frags *nf, struct inet_frags *f)
87{
88 nf->low_thresh = 0;
89 inet_frag_evictor(nf, f);
90}
91EXPORT_SYMBOL(inet_frags_exit_net);
92
Pavel Emelyanov277e6502007-10-15 02:37:18 -070093static inline void fq_unlink(struct inet_frag_queue *fq, struct inet_frags *f)
94{
95 write_lock(&f->lock);
96 hlist_del(&fq->list);
97 list_del(&fq->lru_list);
Pavel Emelyanove5a2bb82008-01-22 06:06:23 -080098 fq->net->nqueues--;
Pavel Emelyanov277e6502007-10-15 02:37:18 -070099 write_unlock(&f->lock);
100}
101
102void inet_frag_kill(struct inet_frag_queue *fq, struct inet_frags *f)
103{
104 if (del_timer(&fq->timer))
105 atomic_dec(&fq->refcnt);
106
107 if (!(fq->last_in & COMPLETE)) {
108 fq_unlink(fq, f);
109 atomic_dec(&fq->refcnt);
110 fq->last_in |= COMPLETE;
111 }
112}
113
114EXPORT_SYMBOL(inet_frag_kill);
Pavel Emelyanov1e4b8282007-10-15 02:39:14 -0700115
Pavel Emelyanov6ddc0822008-01-22 06:07:25 -0800116static inline void frag_kfree_skb(struct netns_frags *nf, struct inet_frags *f,
117 struct sk_buff *skb, int *work)
Pavel Emelyanov1e4b8282007-10-15 02:39:14 -0700118{
119 if (work)
120 *work -= skb->truesize;
121
Pavel Emelyanov6ddc0822008-01-22 06:07:25 -0800122 atomic_sub(skb->truesize, &nf->mem);
Pavel Emelyanov1e4b8282007-10-15 02:39:14 -0700123 if (f->skb_free)
124 f->skb_free(skb);
125 kfree_skb(skb);
126}
127
128void inet_frag_destroy(struct inet_frag_queue *q, struct inet_frags *f,
129 int *work)
130{
131 struct sk_buff *fp;
Pavel Emelyanov6ddc0822008-01-22 06:07:25 -0800132 struct netns_frags *nf;
Pavel Emelyanov1e4b8282007-10-15 02:39:14 -0700133
134 BUG_TRAP(q->last_in & COMPLETE);
135 BUG_TRAP(del_timer(&q->timer) == 0);
136
137 /* Release all fragment data. */
138 fp = q->fragments;
Pavel Emelyanov6ddc0822008-01-22 06:07:25 -0800139 nf = q->net;
Pavel Emelyanov1e4b8282007-10-15 02:39:14 -0700140 while (fp) {
141 struct sk_buff *xp = fp->next;
142
Pavel Emelyanov6ddc0822008-01-22 06:07:25 -0800143 frag_kfree_skb(nf, f, fp, work);
Pavel Emelyanov1e4b8282007-10-15 02:39:14 -0700144 fp = xp;
145 }
146
147 if (work)
148 *work -= f->qsize;
Pavel Emelyanov6ddc0822008-01-22 06:07:25 -0800149 atomic_sub(f->qsize, &nf->mem);
Pavel Emelyanov1e4b8282007-10-15 02:39:14 -0700150
Pavel Emelyanovc9547702007-10-17 19:48:26 -0700151 if (f->destructor)
152 f->destructor(q);
153 kfree(q);
Pavel Emelyanov1e4b8282007-10-15 02:39:14 -0700154
155}
156EXPORT_SYMBOL(inet_frag_destroy);
Pavel Emelyanov8e7999c2007-10-15 02:40:06 -0700157
Pavel Emelyanov6ddc0822008-01-22 06:07:25 -0800158int inet_frag_evictor(struct netns_frags *nf, struct inet_frags *f)
Pavel Emelyanov8e7999c2007-10-15 02:40:06 -0700159{
160 struct inet_frag_queue *q;
161 int work, evicted = 0;
162
Pavel Emelyanove31e0bdc72008-01-22 06:10:13 -0800163 work = atomic_read(&nf->mem) - nf->low_thresh;
Pavel Emelyanov8e7999c2007-10-15 02:40:06 -0700164 while (work > 0) {
165 read_lock(&f->lock);
Pavel Emelyanov3140c252008-01-22 06:11:48 -0800166 if (list_empty(&nf->lru_list)) {
Pavel Emelyanov8e7999c2007-10-15 02:40:06 -0700167 read_unlock(&f->lock);
168 break;
169 }
170
Pavel Emelyanov3140c252008-01-22 06:11:48 -0800171 q = list_first_entry(&nf->lru_list,
Pavel Emelyanov8e7999c2007-10-15 02:40:06 -0700172 struct inet_frag_queue, lru_list);
173 atomic_inc(&q->refcnt);
174 read_unlock(&f->lock);
175
176 spin_lock(&q->lock);
177 if (!(q->last_in & COMPLETE))
178 inet_frag_kill(q, f);
179 spin_unlock(&q->lock);
180
181 if (atomic_dec_and_test(&q->refcnt))
182 inet_frag_destroy(q, f, &work);
183 evicted++;
184 }
185
186 return evicted;
187}
188EXPORT_SYMBOL(inet_frag_evictor);
Pavel Emelyanov2588fe12007-10-17 19:44:34 -0700189
Pavel Emelyanovac18e752008-01-22 06:02:14 -0800190static struct inet_frag_queue *inet_frag_intern(struct netns_frags *nf,
191 struct inet_frag_queue *qp_in, struct inet_frags *f,
192 unsigned int hash, void *arg)
Pavel Emelyanov2588fe12007-10-17 19:44:34 -0700193{
194 struct inet_frag_queue *qp;
195#ifdef CONFIG_SMP
196 struct hlist_node *n;
197#endif
198
199 write_lock(&f->lock);
200#ifdef CONFIG_SMP
201 /* With SMP race we have to recheck hash table, because
202 * such entry could be created on other cpu, while we
203 * promoted read lock to write lock.
204 */
205 hlist_for_each_entry(qp, n, &f->hash[hash], list) {
Pavel Emelyanovac18e752008-01-22 06:02:14 -0800206 if (qp->net == nf && f->match(qp, arg)) {
Pavel Emelyanov2588fe12007-10-17 19:44:34 -0700207 atomic_inc(&qp->refcnt);
208 write_unlock(&f->lock);
209 qp_in->last_in |= COMPLETE;
210 inet_frag_put(qp_in, f);
211 return qp;
212 }
213 }
214#endif
215 qp = qp_in;
Pavel Emelyanovb2fd5322008-01-22 06:09:37 -0800216 if (!mod_timer(&qp->timer, jiffies + nf->timeout))
Pavel Emelyanov2588fe12007-10-17 19:44:34 -0700217 atomic_inc(&qp->refcnt);
218
219 atomic_inc(&qp->refcnt);
220 hlist_add_head(&qp->list, &f->hash[hash]);
Pavel Emelyanov3140c252008-01-22 06:11:48 -0800221 list_add_tail(&qp->lru_list, &nf->lru_list);
Pavel Emelyanove5a2bb82008-01-22 06:06:23 -0800222 nf->nqueues++;
Pavel Emelyanov2588fe12007-10-17 19:44:34 -0700223 write_unlock(&f->lock);
224 return qp;
225}
Pavel Emelyanove521db92007-10-17 19:45:23 -0700226
Pavel Emelyanovac18e752008-01-22 06:02:14 -0800227static struct inet_frag_queue *inet_frag_alloc(struct netns_frags *nf,
228 struct inet_frags *f, void *arg)
Pavel Emelyanove521db92007-10-17 19:45:23 -0700229{
230 struct inet_frag_queue *q;
231
232 q = kzalloc(f->qsize, GFP_ATOMIC);
233 if (q == NULL)
234 return NULL;
235
Pavel Emelyanovc6fda282007-10-17 19:46:47 -0700236 f->constructor(q, arg);
Pavel Emelyanov6ddc0822008-01-22 06:07:25 -0800237 atomic_add(f->qsize, &nf->mem);
Pavel Emelyanove521db92007-10-17 19:45:23 -0700238 setup_timer(&q->timer, f->frag_expire, (unsigned long)q);
239 spin_lock_init(&q->lock);
240 atomic_set(&q->refcnt, 1);
Pavel Emelyanovac18e752008-01-22 06:02:14 -0800241 q->net = nf;
Pavel Emelyanove521db92007-10-17 19:45:23 -0700242
243 return q;
244}
Pavel Emelyanovc6fda282007-10-17 19:46:47 -0700245
Pavel Emelyanovac18e752008-01-22 06:02:14 -0800246static struct inet_frag_queue *inet_frag_create(struct netns_frags *nf,
247 struct inet_frags *f, void *arg, unsigned int hash)
Pavel Emelyanovc6fda282007-10-17 19:46:47 -0700248{
249 struct inet_frag_queue *q;
250
Pavel Emelyanovac18e752008-01-22 06:02:14 -0800251 q = inet_frag_alloc(nf, f, arg);
Pavel Emelyanovc6fda282007-10-17 19:46:47 -0700252 if (q == NULL)
253 return NULL;
254
Pavel Emelyanovac18e752008-01-22 06:02:14 -0800255 return inet_frag_intern(nf, q, f, hash, arg);
Pavel Emelyanovc6fda282007-10-17 19:46:47 -0700256}
Pavel Emelyanovabd65232007-10-17 19:47:21 -0700257
Pavel Emelyanovac18e752008-01-22 06:02:14 -0800258struct inet_frag_queue *inet_frag_find(struct netns_frags *nf,
259 struct inet_frags *f, void *key, unsigned int hash)
Pavel Emelyanovabd65232007-10-17 19:47:21 -0700260{
261 struct inet_frag_queue *q;
262 struct hlist_node *n;
263
264 read_lock(&f->lock);
265 hlist_for_each_entry(q, n, &f->hash[hash], list) {
Pavel Emelyanovac18e752008-01-22 06:02:14 -0800266 if (q->net == nf && f->match(q, key)) {
Pavel Emelyanovabd65232007-10-17 19:47:21 -0700267 atomic_inc(&q->refcnt);
268 read_unlock(&f->lock);
269 return q;
270 }
271 }
272 read_unlock(&f->lock);
273
Pavel Emelyanovac18e752008-01-22 06:02:14 -0800274 return inet_frag_create(nf, f, key, hash);
Pavel Emelyanovabd65232007-10-17 19:47:21 -0700275}
276EXPORT_SYMBOL(inet_frag_find);