Pavel Emelyanov | 7eb9515 | 2007-10-15 02:31:52 -0700 | [diff] [blame] | 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> |
Pavel Emelyanov | 321a3a9 | 2007-10-15 02:38:08 -0700 | [diff] [blame] | 19 | #include <linux/random.h> |
Pavel Emelyanov | 1e4b828 | 2007-10-15 02:39:14 -0700 | [diff] [blame] | 20 | #include <linux/skbuff.h> |
| 21 | #include <linux/rtnetlink.h> |
Tejun Heo | 5a0e3ad | 2010-03-24 17:04:11 +0900 | [diff] [blame] | 22 | #include <linux/slab.h> |
Pavel Emelyanov | 7eb9515 | 2007-10-15 02:31:52 -0700 | [diff] [blame] | 23 | |
Hannes Frederic Sowa | 5a3da1f | 2013-03-15 11:32:30 +0000 | [diff] [blame] | 24 | #include <net/sock.h> |
Pavel Emelyanov | 7eb9515 | 2007-10-15 02:31:52 -0700 | [diff] [blame] | 25 | #include <net/inet_frag.h> |
Hannes Frederic Sowa | be99197 | 2013-03-22 08:24:37 +0000 | [diff] [blame] | 26 | #include <net/inet_ecn.h> |
| 27 | |
Florian Westphal | b13d3cb | 2014-07-24 16:50:32 +0200 | [diff] [blame] | 28 | #define INETFRAGS_EVICT_BUCKETS 128 |
| 29 | #define INETFRAGS_EVICT_MAX 512 |
| 30 | |
Florian Westphal | e3a57d1 | 2014-07-24 16:50:35 +0200 | [diff] [blame^] | 31 | /* don't rebuild inetfrag table with new secret more often than this */ |
| 32 | #define INETFRAGS_MIN_REBUILD_INTERVAL (5 * HZ) |
| 33 | |
Hannes Frederic Sowa | be99197 | 2013-03-22 08:24:37 +0000 | [diff] [blame] | 34 | /* Given the OR values of all fragments, apply RFC 3168 5.3 requirements |
| 35 | * Value : 0xff if frame should be dropped. |
| 36 | * 0 or INET_ECN_CE value, to be ORed in to final iph->tos field |
| 37 | */ |
| 38 | const u8 ip_frag_ecn_table[16] = { |
| 39 | /* at least one fragment had CE, and others ECT_0 or ECT_1 */ |
| 40 | [IPFRAG_ECN_CE | IPFRAG_ECN_ECT_0] = INET_ECN_CE, |
| 41 | [IPFRAG_ECN_CE | IPFRAG_ECN_ECT_1] = INET_ECN_CE, |
| 42 | [IPFRAG_ECN_CE | IPFRAG_ECN_ECT_0 | IPFRAG_ECN_ECT_1] = INET_ECN_CE, |
| 43 | |
| 44 | /* invalid combinations : drop frame */ |
| 45 | [IPFRAG_ECN_NOT_ECT | IPFRAG_ECN_CE] = 0xff, |
| 46 | [IPFRAG_ECN_NOT_ECT | IPFRAG_ECN_ECT_0] = 0xff, |
| 47 | [IPFRAG_ECN_NOT_ECT | IPFRAG_ECN_ECT_1] = 0xff, |
| 48 | [IPFRAG_ECN_NOT_ECT | IPFRAG_ECN_ECT_0 | IPFRAG_ECN_ECT_1] = 0xff, |
| 49 | [IPFRAG_ECN_NOT_ECT | IPFRAG_ECN_CE | IPFRAG_ECN_ECT_0] = 0xff, |
| 50 | [IPFRAG_ECN_NOT_ECT | IPFRAG_ECN_CE | IPFRAG_ECN_ECT_1] = 0xff, |
| 51 | [IPFRAG_ECN_NOT_ECT | IPFRAG_ECN_CE | IPFRAG_ECN_ECT_0 | IPFRAG_ECN_ECT_1] = 0xff, |
| 52 | }; |
| 53 | EXPORT_SYMBOL(ip_frag_ecn_table); |
Pavel Emelyanov | 7eb9515 | 2007-10-15 02:31:52 -0700 | [diff] [blame] | 54 | |
Florian Westphal | fb3cfe6 | 2014-07-24 16:50:30 +0200 | [diff] [blame] | 55 | static unsigned int |
| 56 | inet_frag_hashfn(const struct inet_frags *f, const struct inet_frag_queue *q) |
| 57 | { |
| 58 | return f->hashfn(q) & (INETFRAGS_HASHSZ - 1); |
| 59 | } |
| 60 | |
Florian Westphal | e3a57d1 | 2014-07-24 16:50:35 +0200 | [diff] [blame^] | 61 | static bool inet_frag_may_rebuild(struct inet_frags *f) |
Pavel Emelyanov | 321a3a9 | 2007-10-15 02:38:08 -0700 | [diff] [blame] | 62 | { |
Florian Westphal | e3a57d1 | 2014-07-24 16:50:35 +0200 | [diff] [blame^] | 63 | return time_after(jiffies, |
| 64 | f->last_rebuild_jiffies + INETFRAGS_MIN_REBUILD_INTERVAL); |
| 65 | } |
| 66 | |
| 67 | static void inet_frag_secret_rebuild(struct inet_frags *f) |
| 68 | { |
Pavel Emelyanov | 321a3a9 | 2007-10-15 02:38:08 -0700 | [diff] [blame] | 69 | int i; |
| 70 | |
Jesper Dangaard Brouer | 19952cc4 | 2013-04-03 23:38:16 +0000 | [diff] [blame] | 71 | /* Per bucket lock NOT needed here, due to write lock protection */ |
Florian Westphal | e3a57d1 | 2014-07-24 16:50:35 +0200 | [diff] [blame^] | 72 | write_lock_bh(&f->lock); |
| 73 | |
| 74 | if (!inet_frag_may_rebuild(f)) |
| 75 | goto out; |
Jesper Dangaard Brouer | 19952cc4 | 2013-04-03 23:38:16 +0000 | [diff] [blame] | 76 | |
Pavel Emelyanov | 321a3a9 | 2007-10-15 02:38:08 -0700 | [diff] [blame] | 77 | get_random_bytes(&f->rnd, sizeof(u32)); |
Florian Westphal | e3a57d1 | 2014-07-24 16:50:35 +0200 | [diff] [blame^] | 78 | |
Pavel Emelyanov | 321a3a9 | 2007-10-15 02:38:08 -0700 | [diff] [blame] | 79 | for (i = 0; i < INETFRAGS_HASHSZ; i++) { |
Jesper Dangaard Brouer | 19952cc4 | 2013-04-03 23:38:16 +0000 | [diff] [blame] | 80 | struct inet_frag_bucket *hb; |
Pavel Emelyanov | 321a3a9 | 2007-10-15 02:38:08 -0700 | [diff] [blame] | 81 | struct inet_frag_queue *q; |
Sasha Levin | b67bfe0 | 2013-02-27 17:06:00 -0800 | [diff] [blame] | 82 | struct hlist_node *n; |
Pavel Emelyanov | 321a3a9 | 2007-10-15 02:38:08 -0700 | [diff] [blame] | 83 | |
Jesper Dangaard Brouer | 19952cc4 | 2013-04-03 23:38:16 +0000 | [diff] [blame] | 84 | hb = &f->hash[i]; |
| 85 | hlist_for_each_entry_safe(q, n, &hb->chain, list) { |
Florian Westphal | fb3cfe6 | 2014-07-24 16:50:30 +0200 | [diff] [blame] | 86 | unsigned int hval = inet_frag_hashfn(f, q); |
Pavel Emelyanov | 321a3a9 | 2007-10-15 02:38:08 -0700 | [diff] [blame] | 87 | |
| 88 | if (hval != i) { |
Jesper Dangaard Brouer | 19952cc4 | 2013-04-03 23:38:16 +0000 | [diff] [blame] | 89 | struct inet_frag_bucket *hb_dest; |
| 90 | |
Pavel Emelyanov | 321a3a9 | 2007-10-15 02:38:08 -0700 | [diff] [blame] | 91 | hlist_del(&q->list); |
| 92 | |
| 93 | /* Relink to new hash chain. */ |
Jesper Dangaard Brouer | 19952cc4 | 2013-04-03 23:38:16 +0000 | [diff] [blame] | 94 | hb_dest = &f->hash[hval]; |
| 95 | hlist_add_head(&q->list, &hb_dest->chain); |
Pavel Emelyanov | 321a3a9 | 2007-10-15 02:38:08 -0700 | [diff] [blame] | 96 | } |
| 97 | } |
| 98 | } |
Pavel Emelyanov | 321a3a9 | 2007-10-15 02:38:08 -0700 | [diff] [blame] | 99 | |
Florian Westphal | e3a57d1 | 2014-07-24 16:50:35 +0200 | [diff] [blame^] | 100 | f->rebuild = false; |
| 101 | f->last_rebuild_jiffies = jiffies; |
| 102 | out: |
| 103 | write_unlock_bh(&f->lock); |
Pavel Emelyanov | 321a3a9 | 2007-10-15 02:38:08 -0700 | [diff] [blame] | 104 | } |
| 105 | |
Florian Westphal | b13d3cb | 2014-07-24 16:50:32 +0200 | [diff] [blame] | 106 | static bool inet_fragq_should_evict(const struct inet_frag_queue *q) |
| 107 | { |
| 108 | return q->net->low_thresh == 0 || |
| 109 | frag_mem_limit(q->net) >= q->net->low_thresh; |
| 110 | } |
| 111 | |
| 112 | static unsigned int |
| 113 | inet_evict_bucket(struct inet_frags *f, struct inet_frag_bucket *hb) |
| 114 | { |
| 115 | struct inet_frag_queue *fq; |
| 116 | struct hlist_node *n; |
| 117 | unsigned int evicted = 0; |
| 118 | HLIST_HEAD(expired); |
| 119 | |
| 120 | evict_again: |
| 121 | spin_lock(&hb->chain_lock); |
| 122 | |
| 123 | hlist_for_each_entry_safe(fq, n, &hb->chain, list) { |
| 124 | if (!inet_fragq_should_evict(fq)) |
| 125 | continue; |
| 126 | |
| 127 | if (!del_timer(&fq->timer)) { |
| 128 | /* q expiring right now thus increment its refcount so |
| 129 | * it won't be freed under us and wait until the timer |
| 130 | * has finished executing then destroy it |
| 131 | */ |
| 132 | atomic_inc(&fq->refcnt); |
| 133 | spin_unlock(&hb->chain_lock); |
| 134 | del_timer_sync(&fq->timer); |
| 135 | WARN_ON(atomic_read(&fq->refcnt) != 1); |
| 136 | inet_frag_put(fq, f); |
| 137 | goto evict_again; |
| 138 | } |
| 139 | |
| 140 | /* suppress xmit of (icmp) error packet */ |
| 141 | fq->last_in &= ~INET_FRAG_FIRST_IN; |
| 142 | fq->last_in |= INET_FRAG_EVICTED; |
| 143 | hlist_del(&fq->list); |
| 144 | hlist_add_head(&fq->list, &expired); |
| 145 | ++evicted; |
| 146 | } |
| 147 | |
| 148 | spin_unlock(&hb->chain_lock); |
| 149 | |
| 150 | hlist_for_each_entry_safe(fq, n, &expired, list) |
| 151 | f->frag_expire((unsigned long) fq); |
| 152 | |
| 153 | return evicted; |
| 154 | } |
| 155 | |
| 156 | static void inet_frag_worker(struct work_struct *work) |
| 157 | { |
| 158 | unsigned int budget = INETFRAGS_EVICT_BUCKETS; |
| 159 | unsigned int i, evicted = 0; |
| 160 | struct inet_frags *f; |
| 161 | |
| 162 | f = container_of(work, struct inet_frags, frags_work); |
| 163 | |
| 164 | BUILD_BUG_ON(INETFRAGS_EVICT_BUCKETS >= INETFRAGS_HASHSZ); |
| 165 | |
| 166 | read_lock_bh(&f->lock); |
| 167 | |
| 168 | for (i = ACCESS_ONCE(f->next_bucket); budget; --budget) { |
| 169 | evicted += inet_evict_bucket(f, &f->hash[i]); |
| 170 | i = (i + 1) & (INETFRAGS_HASHSZ - 1); |
| 171 | if (evicted > INETFRAGS_EVICT_MAX) |
| 172 | break; |
| 173 | } |
| 174 | |
| 175 | f->next_bucket = i; |
| 176 | |
| 177 | read_unlock_bh(&f->lock); |
Florian Westphal | e3a57d1 | 2014-07-24 16:50:35 +0200 | [diff] [blame^] | 178 | if (f->rebuild && inet_frag_may_rebuild(f)) |
| 179 | inet_frag_secret_rebuild(f); |
Florian Westphal | b13d3cb | 2014-07-24 16:50:32 +0200 | [diff] [blame] | 180 | } |
| 181 | |
| 182 | static void inet_frag_schedule_worker(struct inet_frags *f) |
| 183 | { |
| 184 | if (unlikely(!work_pending(&f->frags_work))) |
| 185 | schedule_work(&f->frags_work); |
| 186 | } |
| 187 | |
Pavel Emelyanov | 7eb9515 | 2007-10-15 02:31:52 -0700 | [diff] [blame] | 188 | void inet_frags_init(struct inet_frags *f) |
| 189 | { |
| 190 | int i; |
| 191 | |
Florian Westphal | b13d3cb | 2014-07-24 16:50:32 +0200 | [diff] [blame] | 192 | INIT_WORK(&f->frags_work, inet_frag_worker); |
| 193 | |
Jesper Dangaard Brouer | 19952cc4 | 2013-04-03 23:38:16 +0000 | [diff] [blame] | 194 | for (i = 0; i < INETFRAGS_HASHSZ; i++) { |
| 195 | struct inet_frag_bucket *hb = &f->hash[i]; |
Pavel Emelyanov | 7eb9515 | 2007-10-15 02:31:52 -0700 | [diff] [blame] | 196 | |
Jesper Dangaard Brouer | 19952cc4 | 2013-04-03 23:38:16 +0000 | [diff] [blame] | 197 | spin_lock_init(&hb->chain_lock); |
| 198 | INIT_HLIST_HEAD(&hb->chain); |
| 199 | } |
Pavel Emelyanov | 7eb9515 | 2007-10-15 02:31:52 -0700 | [diff] [blame] | 200 | rwlock_init(&f->lock); |
Florian Westphal | e3a57d1 | 2014-07-24 16:50:35 +0200 | [diff] [blame^] | 201 | f->last_rebuild_jiffies = 0; |
Pavel Emelyanov | 7eb9515 | 2007-10-15 02:31:52 -0700 | [diff] [blame] | 202 | } |
| 203 | EXPORT_SYMBOL(inet_frags_init); |
| 204 | |
Pavel Emelyanov | e5a2bb8 | 2008-01-22 06:06:23 -0800 | [diff] [blame] | 205 | void inet_frags_init_net(struct netns_frags *nf) |
| 206 | { |
Jesper Dangaard Brouer | d433673 | 2013-01-28 23:45:12 +0000 | [diff] [blame] | 207 | init_frag_mem_limit(nf); |
Pavel Emelyanov | e5a2bb8 | 2008-01-22 06:06:23 -0800 | [diff] [blame] | 208 | } |
| 209 | EXPORT_SYMBOL(inet_frags_init_net); |
| 210 | |
Pavel Emelyanov | 7eb9515 | 2007-10-15 02:31:52 -0700 | [diff] [blame] | 211 | void inet_frags_fini(struct inet_frags *f) |
| 212 | { |
Florian Westphal | b13d3cb | 2014-07-24 16:50:32 +0200 | [diff] [blame] | 213 | cancel_work_sync(&f->frags_work); |
Pavel Emelyanov | 7eb9515 | 2007-10-15 02:31:52 -0700 | [diff] [blame] | 214 | } |
| 215 | EXPORT_SYMBOL(inet_frags_fini); |
Pavel Emelyanov | 277e650 | 2007-10-15 02:37:18 -0700 | [diff] [blame] | 216 | |
Pavel Emelyanov | 81566e8 | 2008-01-22 06:12:39 -0800 | [diff] [blame] | 217 | void inet_frags_exit_net(struct netns_frags *nf, struct inet_frags *f) |
| 218 | { |
Florian Westphal | b13d3cb | 2014-07-24 16:50:32 +0200 | [diff] [blame] | 219 | int i; |
| 220 | |
Pavel Emelyanov | 81566e8 | 2008-01-22 06:12:39 -0800 | [diff] [blame] | 221 | nf->low_thresh = 0; |
David S. Miller | e8e16b70 | 2008-03-28 17:30:18 -0700 | [diff] [blame] | 222 | |
Florian Westphal | b13d3cb | 2014-07-24 16:50:32 +0200 | [diff] [blame] | 223 | read_lock_bh(&f->lock); |
| 224 | |
| 225 | for (i = 0; i < INETFRAGS_HASHSZ ; i++) |
| 226 | inet_evict_bucket(f, &f->hash[i]); |
| 227 | |
| 228 | read_unlock_bh(&f->lock); |
Jesper Dangaard Brouer | 6d7b857 | 2013-01-28 23:45:33 +0000 | [diff] [blame] | 229 | |
| 230 | percpu_counter_destroy(&nf->mem); |
Pavel Emelyanov | 81566e8 | 2008-01-22 06:12:39 -0800 | [diff] [blame] | 231 | } |
| 232 | EXPORT_SYMBOL(inet_frags_exit_net); |
| 233 | |
Pavel Emelyanov | 277e650 | 2007-10-15 02:37:18 -0700 | [diff] [blame] | 234 | static inline void fq_unlink(struct inet_frag_queue *fq, struct inet_frags *f) |
| 235 | { |
Jesper Dangaard Brouer | 19952cc4 | 2013-04-03 23:38:16 +0000 | [diff] [blame] | 236 | struct inet_frag_bucket *hb; |
| 237 | unsigned int hash; |
| 238 | |
| 239 | read_lock(&f->lock); |
Florian Westphal | fb3cfe6 | 2014-07-24 16:50:30 +0200 | [diff] [blame] | 240 | hash = inet_frag_hashfn(f, fq); |
Jesper Dangaard Brouer | 19952cc4 | 2013-04-03 23:38:16 +0000 | [diff] [blame] | 241 | hb = &f->hash[hash]; |
| 242 | |
| 243 | spin_lock(&hb->chain_lock); |
Pavel Emelyanov | 277e650 | 2007-10-15 02:37:18 -0700 | [diff] [blame] | 244 | hlist_del(&fq->list); |
Jesper Dangaard Brouer | 19952cc4 | 2013-04-03 23:38:16 +0000 | [diff] [blame] | 245 | spin_unlock(&hb->chain_lock); |
| 246 | |
| 247 | read_unlock(&f->lock); |
Pavel Emelyanov | 277e650 | 2007-10-15 02:37:18 -0700 | [diff] [blame] | 248 | } |
| 249 | |
| 250 | void inet_frag_kill(struct inet_frag_queue *fq, struct inet_frags *f) |
| 251 | { |
| 252 | if (del_timer(&fq->timer)) |
| 253 | atomic_dec(&fq->refcnt); |
| 254 | |
Joe Perches | bc578a5 | 2008-03-28 16:35:27 -0700 | [diff] [blame] | 255 | if (!(fq->last_in & INET_FRAG_COMPLETE)) { |
Pavel Emelyanov | 277e650 | 2007-10-15 02:37:18 -0700 | [diff] [blame] | 256 | fq_unlink(fq, f); |
| 257 | atomic_dec(&fq->refcnt); |
Joe Perches | bc578a5 | 2008-03-28 16:35:27 -0700 | [diff] [blame] | 258 | fq->last_in |= INET_FRAG_COMPLETE; |
Pavel Emelyanov | 277e650 | 2007-10-15 02:37:18 -0700 | [diff] [blame] | 259 | } |
| 260 | } |
Pavel Emelyanov | 277e650 | 2007-10-15 02:37:18 -0700 | [diff] [blame] | 261 | EXPORT_SYMBOL(inet_frag_kill); |
Pavel Emelyanov | 1e4b828 | 2007-10-15 02:39:14 -0700 | [diff] [blame] | 262 | |
Pavel Emelyanov | 6ddc082 | 2008-01-22 06:07:25 -0800 | [diff] [blame] | 263 | static inline void frag_kfree_skb(struct netns_frags *nf, struct inet_frags *f, |
Jesper Dangaard Brouer | d433673 | 2013-01-28 23:45:12 +0000 | [diff] [blame] | 264 | struct sk_buff *skb) |
Pavel Emelyanov | 1e4b828 | 2007-10-15 02:39:14 -0700 | [diff] [blame] | 265 | { |
Pavel Emelyanov | 1e4b828 | 2007-10-15 02:39:14 -0700 | [diff] [blame] | 266 | if (f->skb_free) |
| 267 | f->skb_free(skb); |
| 268 | kfree_skb(skb); |
| 269 | } |
| 270 | |
Florian Westphal | 3fd588e | 2014-07-24 16:50:34 +0200 | [diff] [blame] | 271 | void inet_frag_destroy(struct inet_frag_queue *q, struct inet_frags *f) |
Pavel Emelyanov | 1e4b828 | 2007-10-15 02:39:14 -0700 | [diff] [blame] | 272 | { |
| 273 | struct sk_buff *fp; |
Pavel Emelyanov | 6ddc082 | 2008-01-22 06:07:25 -0800 | [diff] [blame] | 274 | struct netns_frags *nf; |
Jesper Dangaard Brouer | d433673 | 2013-01-28 23:45:12 +0000 | [diff] [blame] | 275 | unsigned int sum, sum_truesize = 0; |
Pavel Emelyanov | 1e4b828 | 2007-10-15 02:39:14 -0700 | [diff] [blame] | 276 | |
Ilpo Järvinen | 547b792 | 2008-07-25 21:43:18 -0700 | [diff] [blame] | 277 | WARN_ON(!(q->last_in & INET_FRAG_COMPLETE)); |
| 278 | WARN_ON(del_timer(&q->timer) != 0); |
Pavel Emelyanov | 1e4b828 | 2007-10-15 02:39:14 -0700 | [diff] [blame] | 279 | |
| 280 | /* Release all fragment data. */ |
| 281 | fp = q->fragments; |
Pavel Emelyanov | 6ddc082 | 2008-01-22 06:07:25 -0800 | [diff] [blame] | 282 | nf = q->net; |
Pavel Emelyanov | 1e4b828 | 2007-10-15 02:39:14 -0700 | [diff] [blame] | 283 | while (fp) { |
| 284 | struct sk_buff *xp = fp->next; |
| 285 | |
Jesper Dangaard Brouer | d433673 | 2013-01-28 23:45:12 +0000 | [diff] [blame] | 286 | sum_truesize += fp->truesize; |
| 287 | frag_kfree_skb(nf, f, fp); |
Pavel Emelyanov | 1e4b828 | 2007-10-15 02:39:14 -0700 | [diff] [blame] | 288 | fp = xp; |
| 289 | } |
Jesper Dangaard Brouer | d433673 | 2013-01-28 23:45:12 +0000 | [diff] [blame] | 290 | sum = sum_truesize + f->qsize; |
Jesper Dangaard Brouer | d433673 | 2013-01-28 23:45:12 +0000 | [diff] [blame] | 291 | sub_frag_mem_limit(q, sum); |
Pavel Emelyanov | 1e4b828 | 2007-10-15 02:39:14 -0700 | [diff] [blame] | 292 | |
Pavel Emelyanov | c954770 | 2007-10-17 19:48:26 -0700 | [diff] [blame] | 293 | if (f->destructor) |
| 294 | f->destructor(q); |
| 295 | kfree(q); |
Pavel Emelyanov | 1e4b828 | 2007-10-15 02:39:14 -0700 | [diff] [blame] | 296 | } |
| 297 | EXPORT_SYMBOL(inet_frag_destroy); |
Pavel Emelyanov | 8e7999c | 2007-10-15 02:40:06 -0700 | [diff] [blame] | 298 | |
Pavel Emelyanov | ac18e75 | 2008-01-22 06:02:14 -0800 | [diff] [blame] | 299 | static struct inet_frag_queue *inet_frag_intern(struct netns_frags *nf, |
| 300 | struct inet_frag_queue *qp_in, struct inet_frags *f, |
Pavel Emelyanov | 9a37580 | 2008-06-27 20:06:08 -0700 | [diff] [blame] | 301 | void *arg) |
Pavel Emelyanov | 2588fe1 | 2007-10-17 19:44:34 -0700 | [diff] [blame] | 302 | { |
Jesper Dangaard Brouer | 19952cc4 | 2013-04-03 23:38:16 +0000 | [diff] [blame] | 303 | struct inet_frag_bucket *hb; |
Pavel Emelyanov | 2588fe1 | 2007-10-17 19:44:34 -0700 | [diff] [blame] | 304 | struct inet_frag_queue *qp; |
Pavel Emelyanov | 9a37580 | 2008-06-27 20:06:08 -0700 | [diff] [blame] | 305 | unsigned int hash; |
Pavel Emelyanov | 2588fe1 | 2007-10-17 19:44:34 -0700 | [diff] [blame] | 306 | |
Jesper Dangaard Brouer | 19952cc4 | 2013-04-03 23:38:16 +0000 | [diff] [blame] | 307 | read_lock(&f->lock); /* Protects against hash rebuild */ |
Pavel Emelyanov | 9a37580 | 2008-06-27 20:06:08 -0700 | [diff] [blame] | 308 | /* |
| 309 | * While we stayed w/o the lock other CPU could update |
| 310 | * the rnd seed, so we need to re-calculate the hash |
| 311 | * chain. Fortunatelly the qp_in can be used to get one. |
| 312 | */ |
Florian Westphal | fb3cfe6 | 2014-07-24 16:50:30 +0200 | [diff] [blame] | 313 | hash = inet_frag_hashfn(f, qp_in); |
Jesper Dangaard Brouer | 19952cc4 | 2013-04-03 23:38:16 +0000 | [diff] [blame] | 314 | hb = &f->hash[hash]; |
| 315 | spin_lock(&hb->chain_lock); |
| 316 | |
Pavel Emelyanov | 2588fe1 | 2007-10-17 19:44:34 -0700 | [diff] [blame] | 317 | #ifdef CONFIG_SMP |
| 318 | /* With SMP race we have to recheck hash table, because |
| 319 | * such entry could be created on other cpu, while we |
Jesper Dangaard Brouer | 19952cc4 | 2013-04-03 23:38:16 +0000 | [diff] [blame] | 320 | * released the hash bucket lock. |
Pavel Emelyanov | 2588fe1 | 2007-10-17 19:44:34 -0700 | [diff] [blame] | 321 | */ |
Jesper Dangaard Brouer | 19952cc4 | 2013-04-03 23:38:16 +0000 | [diff] [blame] | 322 | hlist_for_each_entry(qp, &hb->chain, list) { |
Pavel Emelyanov | ac18e75 | 2008-01-22 06:02:14 -0800 | [diff] [blame] | 323 | if (qp->net == nf && f->match(qp, arg)) { |
Pavel Emelyanov | 2588fe1 | 2007-10-17 19:44:34 -0700 | [diff] [blame] | 324 | atomic_inc(&qp->refcnt); |
Jesper Dangaard Brouer | 19952cc4 | 2013-04-03 23:38:16 +0000 | [diff] [blame] | 325 | spin_unlock(&hb->chain_lock); |
| 326 | read_unlock(&f->lock); |
Joe Perches | bc578a5 | 2008-03-28 16:35:27 -0700 | [diff] [blame] | 327 | qp_in->last_in |= INET_FRAG_COMPLETE; |
Pavel Emelyanov | 2588fe1 | 2007-10-17 19:44:34 -0700 | [diff] [blame] | 328 | inet_frag_put(qp_in, f); |
| 329 | return qp; |
| 330 | } |
| 331 | } |
| 332 | #endif |
| 333 | qp = qp_in; |
Pavel Emelyanov | b2fd532 | 2008-01-22 06:09:37 -0800 | [diff] [blame] | 334 | if (!mod_timer(&qp->timer, jiffies + nf->timeout)) |
Pavel Emelyanov | 2588fe1 | 2007-10-17 19:44:34 -0700 | [diff] [blame] | 335 | atomic_inc(&qp->refcnt); |
| 336 | |
| 337 | atomic_inc(&qp->refcnt); |
Jesper Dangaard Brouer | 19952cc4 | 2013-04-03 23:38:16 +0000 | [diff] [blame] | 338 | hlist_add_head(&qp->list, &hb->chain); |
Florian Westphal | 3fd588e | 2014-07-24 16:50:34 +0200 | [diff] [blame] | 339 | |
Jesper Dangaard Brouer | 19952cc4 | 2013-04-03 23:38:16 +0000 | [diff] [blame] | 340 | spin_unlock(&hb->chain_lock); |
| 341 | read_unlock(&f->lock); |
Nikolay Aleksandrov | 24b9bf4 | 2014-03-03 23:19:18 +0100 | [diff] [blame] | 342 | |
Pavel Emelyanov | 2588fe1 | 2007-10-17 19:44:34 -0700 | [diff] [blame] | 343 | return qp; |
| 344 | } |
Pavel Emelyanov | e521db9 | 2007-10-17 19:45:23 -0700 | [diff] [blame] | 345 | |
Pavel Emelyanov | ac18e75 | 2008-01-22 06:02:14 -0800 | [diff] [blame] | 346 | static struct inet_frag_queue *inet_frag_alloc(struct netns_frags *nf, |
| 347 | struct inet_frags *f, void *arg) |
Pavel Emelyanov | e521db9 | 2007-10-17 19:45:23 -0700 | [diff] [blame] | 348 | { |
| 349 | struct inet_frag_queue *q; |
| 350 | |
Florian Westphal | b13d3cb | 2014-07-24 16:50:32 +0200 | [diff] [blame] | 351 | if (frag_mem_limit(nf) > nf->high_thresh) { |
| 352 | inet_frag_schedule_worker(f); |
Florian Westphal | 86e93e4 | 2014-07-24 16:50:31 +0200 | [diff] [blame] | 353 | return NULL; |
Florian Westphal | b13d3cb | 2014-07-24 16:50:32 +0200 | [diff] [blame] | 354 | } |
Florian Westphal | 86e93e4 | 2014-07-24 16:50:31 +0200 | [diff] [blame] | 355 | |
Pavel Emelyanov | e521db9 | 2007-10-17 19:45:23 -0700 | [diff] [blame] | 356 | q = kzalloc(f->qsize, GFP_ATOMIC); |
| 357 | if (q == NULL) |
| 358 | return NULL; |
| 359 | |
Gao feng | 54db0cc | 2012-06-08 01:21:40 +0000 | [diff] [blame] | 360 | q->net = nf; |
Pavel Emelyanov | c6fda28 | 2007-10-17 19:46:47 -0700 | [diff] [blame] | 361 | f->constructor(q, arg); |
Jesper Dangaard Brouer | d433673 | 2013-01-28 23:45:12 +0000 | [diff] [blame] | 362 | add_frag_mem_limit(q, f->qsize); |
| 363 | |
Pavel Emelyanov | e521db9 | 2007-10-17 19:45:23 -0700 | [diff] [blame] | 364 | setup_timer(&q->timer, f->frag_expire, (unsigned long)q); |
| 365 | spin_lock_init(&q->lock); |
| 366 | atomic_set(&q->refcnt, 1); |
| 367 | |
| 368 | return q; |
| 369 | } |
Pavel Emelyanov | c6fda28 | 2007-10-17 19:46:47 -0700 | [diff] [blame] | 370 | |
Pavel Emelyanov | ac18e75 | 2008-01-22 06:02:14 -0800 | [diff] [blame] | 371 | static struct inet_frag_queue *inet_frag_create(struct netns_frags *nf, |
Pavel Emelyanov | 9a37580 | 2008-06-27 20:06:08 -0700 | [diff] [blame] | 372 | struct inet_frags *f, void *arg) |
Pavel Emelyanov | c6fda28 | 2007-10-17 19:46:47 -0700 | [diff] [blame] | 373 | { |
| 374 | struct inet_frag_queue *q; |
| 375 | |
Pavel Emelyanov | ac18e75 | 2008-01-22 06:02:14 -0800 | [diff] [blame] | 376 | q = inet_frag_alloc(nf, f, arg); |
Pavel Emelyanov | c6fda28 | 2007-10-17 19:46:47 -0700 | [diff] [blame] | 377 | if (q == NULL) |
| 378 | return NULL; |
| 379 | |
Pavel Emelyanov | 9a37580 | 2008-06-27 20:06:08 -0700 | [diff] [blame] | 380 | return inet_frag_intern(nf, q, f, arg); |
Pavel Emelyanov | c6fda28 | 2007-10-17 19:46:47 -0700 | [diff] [blame] | 381 | } |
Pavel Emelyanov | abd6523 | 2007-10-17 19:47:21 -0700 | [diff] [blame] | 382 | |
Pavel Emelyanov | ac18e75 | 2008-01-22 06:02:14 -0800 | [diff] [blame] | 383 | struct inet_frag_queue *inet_frag_find(struct netns_frags *nf, |
| 384 | struct inet_frags *f, void *key, unsigned int hash) |
Hannes Eder | 56bca31 | 2009-02-25 10:32:52 +0000 | [diff] [blame] | 385 | __releases(&f->lock) |
Pavel Emelyanov | abd6523 | 2007-10-17 19:47:21 -0700 | [diff] [blame] | 386 | { |
Jesper Dangaard Brouer | 19952cc4 | 2013-04-03 23:38:16 +0000 | [diff] [blame] | 387 | struct inet_frag_bucket *hb; |
Pavel Emelyanov | abd6523 | 2007-10-17 19:47:21 -0700 | [diff] [blame] | 388 | struct inet_frag_queue *q; |
Hannes Frederic Sowa | 5a3da1f | 2013-03-15 11:32:30 +0000 | [diff] [blame] | 389 | int depth = 0; |
Pavel Emelyanov | abd6523 | 2007-10-17 19:47:21 -0700 | [diff] [blame] | 390 | |
Florian Westphal | b13d3cb | 2014-07-24 16:50:32 +0200 | [diff] [blame] | 391 | if (frag_mem_limit(nf) > nf->low_thresh) |
| 392 | inet_frag_schedule_worker(f); |
Florian Westphal | 86e93e4 | 2014-07-24 16:50:31 +0200 | [diff] [blame] | 393 | |
Florian Westphal | fb3cfe6 | 2014-07-24 16:50:30 +0200 | [diff] [blame] | 394 | hash &= (INETFRAGS_HASHSZ - 1); |
Jesper Dangaard Brouer | 19952cc4 | 2013-04-03 23:38:16 +0000 | [diff] [blame] | 395 | hb = &f->hash[hash]; |
| 396 | |
| 397 | spin_lock(&hb->chain_lock); |
| 398 | hlist_for_each_entry(q, &hb->chain, list) { |
Pavel Emelyanov | ac18e75 | 2008-01-22 06:02:14 -0800 | [diff] [blame] | 399 | if (q->net == nf && f->match(q, key)) { |
Pavel Emelyanov | abd6523 | 2007-10-17 19:47:21 -0700 | [diff] [blame] | 400 | atomic_inc(&q->refcnt); |
Jesper Dangaard Brouer | 19952cc4 | 2013-04-03 23:38:16 +0000 | [diff] [blame] | 401 | spin_unlock(&hb->chain_lock); |
Pavel Emelyanov | abd6523 | 2007-10-17 19:47:21 -0700 | [diff] [blame] | 402 | read_unlock(&f->lock); |
| 403 | return q; |
| 404 | } |
Hannes Frederic Sowa | 5a3da1f | 2013-03-15 11:32:30 +0000 | [diff] [blame] | 405 | depth++; |
Pavel Emelyanov | abd6523 | 2007-10-17 19:47:21 -0700 | [diff] [blame] | 406 | } |
Jesper Dangaard Brouer | 19952cc4 | 2013-04-03 23:38:16 +0000 | [diff] [blame] | 407 | spin_unlock(&hb->chain_lock); |
Pavel Emelyanov | abd6523 | 2007-10-17 19:47:21 -0700 | [diff] [blame] | 408 | read_unlock(&f->lock); |
| 409 | |
Hannes Frederic Sowa | 5a3da1f | 2013-03-15 11:32:30 +0000 | [diff] [blame] | 410 | if (depth <= INETFRAGS_MAXDEPTH) |
| 411 | return inet_frag_create(nf, f, key); |
Florian Westphal | e3a57d1 | 2014-07-24 16:50:35 +0200 | [diff] [blame^] | 412 | |
| 413 | if (inet_frag_may_rebuild(f)) { |
| 414 | f->rebuild = true; |
| 415 | inet_frag_schedule_worker(f); |
| 416 | } |
| 417 | |
| 418 | return ERR_PTR(-ENOBUFS); |
Pavel Emelyanov | abd6523 | 2007-10-17 19:47:21 -0700 | [diff] [blame] | 419 | } |
| 420 | EXPORT_SYMBOL(inet_frag_find); |
Hannes Frederic Sowa | 5a3da1f | 2013-03-15 11:32:30 +0000 | [diff] [blame] | 421 | |
| 422 | void inet_frag_maybe_warn_overflow(struct inet_frag_queue *q, |
| 423 | const char *prefix) |
| 424 | { |
| 425 | static const char msg[] = "inet_frag_find: Fragment hash bucket" |
| 426 | " list length grew over limit " __stringify(INETFRAGS_MAXDEPTH) |
| 427 | ". Dropping fragment.\n"; |
| 428 | |
| 429 | if (PTR_ERR(q) == -ENOBUFS) |
| 430 | LIMIT_NETDEBUG(KERN_WARNING "%s%s", prefix, msg); |
| 431 | } |
| 432 | EXPORT_SYMBOL(inet_frag_maybe_warn_overflow); |