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 <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> 19 #include <linux/random.h> 20 #include <linux/skbuff.h> 21 #include <linux/rtnetlink.h> 22 23 #include <net/inet_frag.h> 24 25 static 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 50 mod_timer(&f->secret_timer, now + f->secret_interval); 51 } 52 53 void 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 60 rwlock_init(&f->lock); 61 62 f->rnd = (u32) ((num_physpages ^ (num_physpages>>7)) ^ 63 (jiffies ^ (jiffies >> 6))); 64 65 setup_timer(&f->secret_timer, inet_frag_secret_rebuild, 66 (unsigned long)f); 67 f->secret_timer.expires = jiffies + f->secret_interval; 68 add_timer(&f->secret_timer); 69 } 70 EXPORT_SYMBOL(inet_frags_init); 71 72 void inet_frags_init_net(struct netns_frags *nf) 73 { 74 nf->nqueues = 0; 75 atomic_set(&nf->mem, 0); 76 INIT_LIST_HEAD(&nf->lru_list); 77 } 78 EXPORT_SYMBOL(inet_frags_init_net); 79 80 void inet_frags_fini(struct inet_frags *f) 81 { 82 del_timer(&f->secret_timer); 83 } 84 EXPORT_SYMBOL(inet_frags_fini); 85 86 void 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 } 91 EXPORT_SYMBOL(inet_frags_exit_net); 92 93 static 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); 98 fq->net->nqueues--; 99 write_unlock(&f->lock); 100 } 101 102 void 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 114 EXPORT_SYMBOL(inet_frag_kill); 115 116 static inline void frag_kfree_skb(struct netns_frags *nf, struct inet_frags *f, 117 struct sk_buff *skb, int *work) 118 { 119 if (work) 120 *work -= skb->truesize; 121 122 atomic_sub(skb->truesize, &nf->mem); 123 if (f->skb_free) 124 f->skb_free(skb); 125 kfree_skb(skb); 126 } 127 128 void inet_frag_destroy(struct inet_frag_queue *q, struct inet_frags *f, 129 int *work) 130 { 131 struct sk_buff *fp; 132 struct netns_frags *nf; 133 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; 139 nf = q->net; 140 while (fp) { 141 struct sk_buff *xp = fp->next; 142 143 frag_kfree_skb(nf, f, fp, work); 144 fp = xp; 145 } 146 147 if (work) 148 *work -= f->qsize; 149 atomic_sub(f->qsize, &nf->mem); 150 151 if (f->destructor) 152 f->destructor(q); 153 kfree(q); 154 155 } 156 EXPORT_SYMBOL(inet_frag_destroy); 157 158 int inet_frag_evictor(struct netns_frags *nf, struct inet_frags *f) 159 { 160 struct inet_frag_queue *q; 161 int work, evicted = 0; 162 163 work = atomic_read(&nf->mem) - nf->low_thresh; 164 while (work > 0) { 165 read_lock(&f->lock); 166 if (list_empty(&nf->lru_list)) { 167 read_unlock(&f->lock); 168 break; 169 } 170 171 q = list_first_entry(&nf->lru_list, 172 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 } 188 EXPORT_SYMBOL(inet_frag_evictor); 189 190 static 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) 193 { 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) { 206 if (qp->net == nf && f->match(qp, arg)) { 207 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; 216 if (!mod_timer(&qp->timer, jiffies + nf->timeout)) 217 atomic_inc(&qp->refcnt); 218 219 atomic_inc(&qp->refcnt); 220 hlist_add_head(&qp->list, &f->hash[hash]); 221 list_add_tail(&qp->lru_list, &nf->lru_list); 222 nf->nqueues++; 223 write_unlock(&f->lock); 224 return qp; 225 } 226 227 static struct inet_frag_queue *inet_frag_alloc(struct netns_frags *nf, 228 struct inet_frags *f, void *arg) 229 { 230 struct inet_frag_queue *q; 231 232 q = kzalloc(f->qsize, GFP_ATOMIC); 233 if (q == NULL) 234 return NULL; 235 236 f->constructor(q, arg); 237 atomic_add(f->qsize, &nf->mem); 238 setup_timer(&q->timer, f->frag_expire, (unsigned long)q); 239 spin_lock_init(&q->lock); 240 atomic_set(&q->refcnt, 1); 241 q->net = nf; 242 243 return q; 244 } 245 246 static struct inet_frag_queue *inet_frag_create(struct netns_frags *nf, 247 struct inet_frags *f, void *arg, unsigned int hash) 248 { 249 struct inet_frag_queue *q; 250 251 q = inet_frag_alloc(nf, f, arg); 252 if (q == NULL) 253 return NULL; 254 255 return inet_frag_intern(nf, q, f, hash, arg); 256 } 257 258 struct inet_frag_queue *inet_frag_find(struct netns_frags *nf, 259 struct inet_frags *f, void *key, unsigned int hash) 260 { 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) { 266 if (q->net == nf && f->match(q, key)) { 267 atomic_inc(&q->refcnt); 268 read_unlock(&f->lock); 269 return q; 270 } 271 } 272 read_unlock(&f->lock); 273 274 return inet_frag_create(nf, f, key, hash); 275 } 276 EXPORT_SYMBOL(inet_frag_find); 277