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 90 local_bh_disable(); 91 inet_frag_evictor(nf, f); 92 local_bh_enable(); 93 } 94 EXPORT_SYMBOL(inet_frags_exit_net); 95 96 static inline void fq_unlink(struct inet_frag_queue *fq, struct inet_frags *f) 97 { 98 write_lock(&f->lock); 99 hlist_del(&fq->list); 100 list_del(&fq->lru_list); 101 fq->net->nqueues--; 102 write_unlock(&f->lock); 103 } 104 105 void inet_frag_kill(struct inet_frag_queue *fq, struct inet_frags *f) 106 { 107 if (del_timer(&fq->timer)) 108 atomic_dec(&fq->refcnt); 109 110 if (!(fq->last_in & INET_FRAG_COMPLETE)) { 111 fq_unlink(fq, f); 112 atomic_dec(&fq->refcnt); 113 fq->last_in |= INET_FRAG_COMPLETE; 114 } 115 } 116 117 EXPORT_SYMBOL(inet_frag_kill); 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 137 BUG_TRAP(q->last_in & INET_FRAG_COMPLETE); 138 BUG_TRAP(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 } 159 EXPORT_SYMBOL(inet_frag_destroy); 160 161 int inet_frag_evictor(struct netns_frags *nf, struct inet_frags *f) 162 { 163 struct inet_frag_queue *q; 164 int work, evicted = 0; 165 166 work = atomic_read(&nf->mem) - nf->low_thresh; 167 while (work > 0) { 168 read_lock(&f->lock); 169 if (list_empty(&nf->lru_list)) { 170 read_unlock(&f->lock); 171 break; 172 } 173 174 q = list_first_entry(&nf->lru_list, 175 struct inet_frag_queue, lru_list); 176 atomic_inc(&q->refcnt); 177 read_unlock(&f->lock); 178 179 spin_lock(&q->lock); 180 if (!(q->last_in & INET_FRAG_COMPLETE)) 181 inet_frag_kill(q, f); 182 spin_unlock(&q->lock); 183 184 if (atomic_dec_and_test(&q->refcnt)) 185 inet_frag_destroy(q, f, &work); 186 evicted++; 187 } 188 189 return evicted; 190 } 191 EXPORT_SYMBOL(inet_frag_evictor); 192 193 static struct inet_frag_queue *inet_frag_intern(struct netns_frags *nf, 194 struct inet_frag_queue *qp_in, struct inet_frags *f, 195 unsigned int hash, void *arg) 196 { 197 struct inet_frag_queue *qp; 198 #ifdef CONFIG_SMP 199 struct hlist_node *n; 200 #endif 201 202 write_lock(&f->lock); 203 #ifdef CONFIG_SMP 204 /* With SMP race we have to recheck hash table, because 205 * such entry could be created on other cpu, while we 206 * promoted read lock to write lock. 207 */ 208 hlist_for_each_entry(qp, n, &f->hash[hash], list) { 209 if (qp->net == nf && f->match(qp, arg)) { 210 atomic_inc(&qp->refcnt); 211 write_unlock(&f->lock); 212 qp_in->last_in |= INET_FRAG_COMPLETE; 213 inet_frag_put(qp_in, f); 214 return qp; 215 } 216 } 217 #endif 218 qp = qp_in; 219 if (!mod_timer(&qp->timer, jiffies + nf->timeout)) 220 atomic_inc(&qp->refcnt); 221 222 atomic_inc(&qp->refcnt); 223 hlist_add_head(&qp->list, &f->hash[hash]); 224 list_add_tail(&qp->lru_list, &nf->lru_list); 225 nf->nqueues++; 226 write_unlock(&f->lock); 227 return qp; 228 } 229 230 static struct inet_frag_queue *inet_frag_alloc(struct netns_frags *nf, 231 struct inet_frags *f, void *arg) 232 { 233 struct inet_frag_queue *q; 234 235 q = kzalloc(f->qsize, GFP_ATOMIC); 236 if (q == NULL) 237 return NULL; 238 239 f->constructor(q, arg); 240 atomic_add(f->qsize, &nf->mem); 241 setup_timer(&q->timer, f->frag_expire, (unsigned long)q); 242 spin_lock_init(&q->lock); 243 atomic_set(&q->refcnt, 1); 244 q->net = nf; 245 246 return q; 247 } 248 249 static struct inet_frag_queue *inet_frag_create(struct netns_frags *nf, 250 struct inet_frags *f, void *arg, unsigned int hash) 251 { 252 struct inet_frag_queue *q; 253 254 q = inet_frag_alloc(nf, f, arg); 255 if (q == NULL) 256 return NULL; 257 258 return inet_frag_intern(nf, q, f, hash, arg); 259 } 260 261 struct inet_frag_queue *inet_frag_find(struct netns_frags *nf, 262 struct inet_frags *f, void *key, unsigned int hash) 263 { 264 struct inet_frag_queue *q; 265 struct hlist_node *n; 266 267 read_lock(&f->lock); 268 hlist_for_each_entry(q, n, &f->hash[hash], list) { 269 if (q->net == nf && f->match(q, key)) { 270 atomic_inc(&q->refcnt); 271 read_unlock(&f->lock); 272 return q; 273 } 274 } 275 read_unlock(&f->lock); 276 277 return inet_frag_create(nf, f, key, hash); 278 } 279 EXPORT_SYMBOL(inet_frag_find); 280