Linux Kernel  3.7.1
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
inet_fragment.c
Go to the documentation of this file.
1 /*
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 <[email protected]>
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>
19 #include <linux/random.h>
20 #include <linux/skbuff.h>
21 #include <linux/rtnetlink.h>
22 #include <linux/slab.h>
23 
24 #include <net/inet_frag.h>
25 
26 static void inet_frag_secret_rebuild(unsigned long dummy)
27 {
28  struct inet_frags *f = (struct inet_frags *)dummy;
29  unsigned long now = jiffies;
30  int i;
31 
32  write_lock(&f->lock);
33  get_random_bytes(&f->rnd, sizeof(u32));
34  for (i = 0; i < INETFRAGS_HASHSZ; i++) {
35  struct inet_frag_queue *q;
36  struct hlist_node *p, *n;
37 
38  hlist_for_each_entry_safe(q, p, n, &f->hash[i], list) {
39  unsigned int hval = f->hashfn(q);
40 
41  if (hval != i) {
42  hlist_del(&q->list);
43 
44  /* Relink to new hash chain. */
45  hlist_add_head(&q->list, &f->hash[hval]);
46  }
47  }
48  }
49  write_unlock(&f->lock);
50 
51  mod_timer(&f->secret_timer, now + f->secret_interval);
52 }
53 
54 void inet_frags_init(struct inet_frags *f)
55 {
56  int i;
57 
58  for (i = 0; i < INETFRAGS_HASHSZ; i++)
59  INIT_HLIST_HEAD(&f->hash[i]);
60 
61  rwlock_init(&f->lock);
62 
63  f->rnd = (u32) ((num_physpages ^ (num_physpages>>7)) ^
64  (jiffies ^ (jiffies >> 6)));
65 
66  setup_timer(&f->secret_timer, inet_frag_secret_rebuild,
67  (unsigned long)f);
68  f->secret_timer.expires = jiffies + f->secret_interval;
69  add_timer(&f->secret_timer);
70 }
72 
74 {
75  nf->nqueues = 0;
76  atomic_set(&nf->mem, 0);
77  INIT_LIST_HEAD(&nf->lru_list);
78 }
80 
81 void inet_frags_fini(struct inet_frags *f)
82 {
84 }
86 
87 void inet_frags_exit_net(struct netns_frags *nf, struct inet_frags *f)
88 {
89  nf->low_thresh = 0;
90 
92  inet_frag_evictor(nf, f, true);
94 }
96 
97 static inline void fq_unlink(struct inet_frag_queue *fq, struct inet_frags *f)
98 {
99  write_lock(&f->lock);
100  hlist_del(&fq->list);
101  list_del(&fq->lru_list);
102  fq->net->nqueues--;
103  write_unlock(&f->lock);
104 }
105 
106 void inet_frag_kill(struct inet_frag_queue *fq, struct inet_frags *f)
107 {
108  if (del_timer(&fq->timer))
109  atomic_dec(&fq->refcnt);
110 
111  if (!(fq->last_in & INET_FRAG_COMPLETE)) {
112  fq_unlink(fq, f);
113  atomic_dec(&fq->refcnt);
115  }
116 }
118 
119 static inline void frag_kfree_skb(struct netns_frags *nf, struct inet_frags *f,
120  struct sk_buff *skb, int *work)
121 {
122  if (work)
123  *work -= skb->truesize;
124 
125  atomic_sub(skb->truesize, &nf->mem);
126  if (f->skb_free)
127  f->skb_free(skb);
128  kfree_skb(skb);
129 }
130 
131 void inet_frag_destroy(struct inet_frag_queue *q, struct inet_frags *f,
132  int *work)
133 {
134  struct sk_buff *fp;
135  struct netns_frags *nf;
136 
138  WARN_ON(del_timer(&q->timer) != 0);
139 
140  /* Release all fragment data. */
141  fp = q->fragments;
142  nf = q->net;
143  while (fp) {
144  struct sk_buff *xp = fp->next;
145 
146  frag_kfree_skb(nf, f, fp, work);
147  fp = xp;
148  }
149 
150  if (work)
151  *work -= f->qsize;
152  atomic_sub(f->qsize, &nf->mem);
153 
154  if (f->destructor)
155  f->destructor(q);
156  kfree(q);
157 
158 }
160 
161 int inet_frag_evictor(struct netns_frags *nf, struct inet_frags *f, bool force)
162 {
163  struct inet_frag_queue *q;
164  int work, evicted = 0;
165 
166  if (!force) {
167  if (atomic_read(&nf->mem) <= nf->high_thresh)
168  return 0;
169  }
170 
171  work = atomic_read(&nf->mem) - nf->low_thresh;
172  while (work > 0) {
173  read_lock(&f->lock);
174  if (list_empty(&nf->lru_list)) {
175  read_unlock(&f->lock);
176  break;
177  }
178 
179  q = list_first_entry(&nf->lru_list,
180  struct inet_frag_queue, lru_list);
181  atomic_inc(&q->refcnt);
182  read_unlock(&f->lock);
183 
184  spin_lock(&q->lock);
185  if (!(q->last_in & INET_FRAG_COMPLETE))
186  inet_frag_kill(q, f);
187  spin_unlock(&q->lock);
188 
189  if (atomic_dec_and_test(&q->refcnt))
190  inet_frag_destroy(q, f, &work);
191  evicted++;
192  }
193 
194  return evicted;
195 }
197 
198 static struct inet_frag_queue *inet_frag_intern(struct netns_frags *nf,
199  struct inet_frag_queue *qp_in, struct inet_frags *f,
200  void *arg)
201 {
202  struct inet_frag_queue *qp;
203 #ifdef CONFIG_SMP
204  struct hlist_node *n;
205 #endif
206  unsigned int hash;
207 
208  write_lock(&f->lock);
209  /*
210  * While we stayed w/o the lock other CPU could update
211  * the rnd seed, so we need to re-calculate the hash
212  * chain. Fortunatelly the qp_in can be used to get one.
213  */
214  hash = f->hashfn(qp_in);
215 #ifdef CONFIG_SMP
216  /* With SMP race we have to recheck hash table, because
217  * such entry could be created on other cpu, while we
218  * promoted read lock to write lock.
219  */
220  hlist_for_each_entry(qp, n, &f->hash[hash], list) {
221  if (qp->net == nf && f->match(qp, arg)) {
222  atomic_inc(&qp->refcnt);
223  write_unlock(&f->lock);
224  qp_in->last_in |= INET_FRAG_COMPLETE;
225  inet_frag_put(qp_in, f);
226  return qp;
227  }
228  }
229 #endif
230  qp = qp_in;
231  if (!mod_timer(&qp->timer, jiffies + nf->timeout))
232  atomic_inc(&qp->refcnt);
233 
234  atomic_inc(&qp->refcnt);
235  hlist_add_head(&qp->list, &f->hash[hash]);
236  list_add_tail(&qp->lru_list, &nf->lru_list);
237  nf->nqueues++;
238  write_unlock(&f->lock);
239  return qp;
240 }
241 
242 static struct inet_frag_queue *inet_frag_alloc(struct netns_frags *nf,
243  struct inet_frags *f, void *arg)
244 {
245  struct inet_frag_queue *q;
246 
247  q = kzalloc(f->qsize, GFP_ATOMIC);
248  if (q == NULL)
249  return NULL;
250 
251  q->net = nf;
252  f->constructor(q, arg);
253  atomic_add(f->qsize, &nf->mem);
254  setup_timer(&q->timer, f->frag_expire, (unsigned long)q);
255  spin_lock_init(&q->lock);
256  atomic_set(&q->refcnt, 1);
257 
258  return q;
259 }
260 
261 static struct inet_frag_queue *inet_frag_create(struct netns_frags *nf,
262  struct inet_frags *f, void *arg)
263 {
264  struct inet_frag_queue *q;
265 
266  q = inet_frag_alloc(nf, f, arg);
267  if (q == NULL)
268  return NULL;
269 
270  return inet_frag_intern(nf, q, f, arg);
271 }
272 
274  struct inet_frags *f, void *key, unsigned int hash)
275  __releases(&f->lock)
276 {
277  struct inet_frag_queue *q;
278  struct hlist_node *n;
279 
280  hlist_for_each_entry(q, n, &f->hash[hash], list) {
281  if (q->net == nf && f->match(q, key)) {
282  atomic_inc(&q->refcnt);
283  read_unlock(&f->lock);
284  return q;
285  }
286  }
287  read_unlock(&f->lock);
288 
289  return inet_frag_create(nf, f, key);
290 }