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 | |
Florian Westphal | ab1c724 | 2014-07-24 16:50:36 +0200 | [diff] [blame] | 71 | write_seqlock_bh(&f->rnd_seqlock); |
Florian Westphal | e3a57d1 | 2014-07-24 16:50:35 +0200 | [diff] [blame] | 72 | |
| 73 | if (!inet_frag_may_rebuild(f)) |
| 74 | goto out; |
Jesper Dangaard Brouer | 19952cc4 | 2013-04-03 23:38:16 +0000 | [diff] [blame] | 75 | |
Pavel Emelyanov | 321a3a9 | 2007-10-15 02:38:08 -0700 | [diff] [blame] | 76 | get_random_bytes(&f->rnd, sizeof(u32)); |
Florian Westphal | e3a57d1 | 2014-07-24 16:50:35 +0200 | [diff] [blame] | 77 | |
Pavel Emelyanov | 321a3a9 | 2007-10-15 02:38:08 -0700 | [diff] [blame] | 78 | for (i = 0; i < INETFRAGS_HASHSZ; i++) { |
Jesper Dangaard Brouer | 19952cc4 | 2013-04-03 23:38:16 +0000 | [diff] [blame] | 79 | struct inet_frag_bucket *hb; |
Pavel Emelyanov | 321a3a9 | 2007-10-15 02:38:08 -0700 | [diff] [blame] | 80 | struct inet_frag_queue *q; |
Sasha Levin | b67bfe0 | 2013-02-27 17:06:00 -0800 | [diff] [blame] | 81 | struct hlist_node *n; |
Pavel Emelyanov | 321a3a9 | 2007-10-15 02:38:08 -0700 | [diff] [blame] | 82 | |
Jesper Dangaard Brouer | 19952cc4 | 2013-04-03 23:38:16 +0000 | [diff] [blame] | 83 | hb = &f->hash[i]; |
Florian Westphal | ab1c724 | 2014-07-24 16:50:36 +0200 | [diff] [blame] | 84 | spin_lock(&hb->chain_lock); |
| 85 | |
Jesper Dangaard Brouer | 19952cc4 | 2013-04-03 23:38:16 +0000 | [diff] [blame] | 86 | hlist_for_each_entry_safe(q, n, &hb->chain, list) { |
Florian Westphal | fb3cfe6 | 2014-07-24 16:50:30 +0200 | [diff] [blame] | 87 | unsigned int hval = inet_frag_hashfn(f, q); |
Pavel Emelyanov | 321a3a9 | 2007-10-15 02:38:08 -0700 | [diff] [blame] | 88 | |
| 89 | if (hval != i) { |
Jesper Dangaard Brouer | 19952cc4 | 2013-04-03 23:38:16 +0000 | [diff] [blame] | 90 | struct inet_frag_bucket *hb_dest; |
| 91 | |
Pavel Emelyanov | 321a3a9 | 2007-10-15 02:38:08 -0700 | [diff] [blame] | 92 | hlist_del(&q->list); |
| 93 | |
| 94 | /* Relink to new hash chain. */ |
Jesper Dangaard Brouer | 19952cc4 | 2013-04-03 23:38:16 +0000 | [diff] [blame] | 95 | hb_dest = &f->hash[hval]; |
Florian Westphal | ab1c724 | 2014-07-24 16:50:36 +0200 | [diff] [blame] | 96 | |
| 97 | /* This is the only place where we take |
| 98 | * another chain_lock while already holding |
| 99 | * one. As this will not run concurrently, |
| 100 | * we cannot deadlock on hb_dest lock below, if its |
| 101 | * already locked it will be released soon since |
| 102 | * other caller cannot be waiting for hb lock |
| 103 | * that we've taken above. |
| 104 | */ |
| 105 | spin_lock_nested(&hb_dest->chain_lock, |
| 106 | SINGLE_DEPTH_NESTING); |
Jesper Dangaard Brouer | 19952cc4 | 2013-04-03 23:38:16 +0000 | [diff] [blame] | 107 | hlist_add_head(&q->list, &hb_dest->chain); |
Florian Westphal | ab1c724 | 2014-07-24 16:50:36 +0200 | [diff] [blame] | 108 | spin_unlock(&hb_dest->chain_lock); |
Pavel Emelyanov | 321a3a9 | 2007-10-15 02:38:08 -0700 | [diff] [blame] | 109 | } |
| 110 | } |
Florian Westphal | ab1c724 | 2014-07-24 16:50:36 +0200 | [diff] [blame] | 111 | spin_unlock(&hb->chain_lock); |
Pavel Emelyanov | 321a3a9 | 2007-10-15 02:38:08 -0700 | [diff] [blame] | 112 | } |
Pavel Emelyanov | 321a3a9 | 2007-10-15 02:38:08 -0700 | [diff] [blame] | 113 | |
Florian Westphal | e3a57d1 | 2014-07-24 16:50:35 +0200 | [diff] [blame] | 114 | f->rebuild = false; |
| 115 | f->last_rebuild_jiffies = jiffies; |
| 116 | out: |
Florian Westphal | ab1c724 | 2014-07-24 16:50:36 +0200 | [diff] [blame] | 117 | write_sequnlock_bh(&f->rnd_seqlock); |
Pavel Emelyanov | 321a3a9 | 2007-10-15 02:38:08 -0700 | [diff] [blame] | 118 | } |
| 119 | |
Florian Westphal | b13d3cb | 2014-07-24 16:50:32 +0200 | [diff] [blame] | 120 | static bool inet_fragq_should_evict(const struct inet_frag_queue *q) |
| 121 | { |
| 122 | return q->net->low_thresh == 0 || |
| 123 | frag_mem_limit(q->net) >= q->net->low_thresh; |
| 124 | } |
| 125 | |
| 126 | static unsigned int |
| 127 | inet_evict_bucket(struct inet_frags *f, struct inet_frag_bucket *hb) |
| 128 | { |
| 129 | struct inet_frag_queue *fq; |
| 130 | struct hlist_node *n; |
| 131 | unsigned int evicted = 0; |
| 132 | HLIST_HEAD(expired); |
| 133 | |
Florian Westphal | b13d3cb | 2014-07-24 16:50:32 +0200 | [diff] [blame] | 134 | spin_lock(&hb->chain_lock); |
| 135 | |
| 136 | hlist_for_each_entry_safe(fq, n, &hb->chain, list) { |
| 137 | if (!inet_fragq_should_evict(fq)) |
| 138 | continue; |
| 139 | |
Florian Westphal | 5719b29 | 2015-07-23 12:05:39 +0200 | [diff] [blame] | 140 | if (!del_timer(&fq->timer)) |
| 141 | continue; |
Florian Westphal | b13d3cb | 2014-07-24 16:50:32 +0200 | [diff] [blame] | 142 | |
Florian Westphal | d1fe194 | 2015-07-23 12:05:37 +0200 | [diff] [blame] | 143 | hlist_add_head(&fq->list_evictor, &expired); |
Florian Westphal | b13d3cb | 2014-07-24 16:50:32 +0200 | [diff] [blame] | 144 | ++evicted; |
| 145 | } |
| 146 | |
| 147 | spin_unlock(&hb->chain_lock); |
| 148 | |
Florian Westphal | d1fe194 | 2015-07-23 12:05:37 +0200 | [diff] [blame] | 149 | hlist_for_each_entry_safe(fq, n, &expired, list_evictor) |
Florian Westphal | b13d3cb | 2014-07-24 16:50:32 +0200 | [diff] [blame] | 150 | f->frag_expire((unsigned long) fq); |
| 151 | |
| 152 | return evicted; |
| 153 | } |
| 154 | |
| 155 | static void inet_frag_worker(struct work_struct *work) |
| 156 | { |
| 157 | unsigned int budget = INETFRAGS_EVICT_BUCKETS; |
| 158 | unsigned int i, evicted = 0; |
| 159 | struct inet_frags *f; |
| 160 | |
| 161 | f = container_of(work, struct inet_frags, frags_work); |
| 162 | |
| 163 | BUILD_BUG_ON(INETFRAGS_EVICT_BUCKETS >= INETFRAGS_HASHSZ); |
| 164 | |
Florian Westphal | ab1c724 | 2014-07-24 16:50:36 +0200 | [diff] [blame] | 165 | local_bh_disable(); |
Florian Westphal | b13d3cb | 2014-07-24 16:50:32 +0200 | [diff] [blame] | 166 | |
| 167 | for (i = ACCESS_ONCE(f->next_bucket); budget; --budget) { |
| 168 | evicted += inet_evict_bucket(f, &f->hash[i]); |
| 169 | i = (i + 1) & (INETFRAGS_HASHSZ - 1); |
| 170 | if (evicted > INETFRAGS_EVICT_MAX) |
| 171 | break; |
| 172 | } |
| 173 | |
| 174 | f->next_bucket = i; |
| 175 | |
Florian Westphal | ab1c724 | 2014-07-24 16:50:36 +0200 | [diff] [blame] | 176 | local_bh_enable(); |
| 177 | |
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 | |
Nikolay Aleksandrov | d4ad4d2 | 2014-08-01 12:29:48 +0200 | [diff] [blame] | 188 | int inet_frags_init(struct inet_frags *f) |
Pavel Emelyanov | 7eb9515 | 2007-10-15 02:31:52 -0700 | [diff] [blame] | 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 | } |
Florian Westphal | ab1c724 | 2014-07-24 16:50:36 +0200 | [diff] [blame] | 200 | |
| 201 | seqlock_init(&f->rnd_seqlock); |
Florian Westphal | e3a57d1 | 2014-07-24 16:50:35 +0200 | [diff] [blame] | 202 | f->last_rebuild_jiffies = 0; |
Nikolay Aleksandrov | d4ad4d2 | 2014-08-01 12:29:48 +0200 | [diff] [blame] | 203 | f->frags_cachep = kmem_cache_create(f->frags_cache_name, f->qsize, 0, 0, |
| 204 | NULL); |
| 205 | if (!f->frags_cachep) |
| 206 | return -ENOMEM; |
| 207 | |
| 208 | return 0; |
Pavel Emelyanov | 7eb9515 | 2007-10-15 02:31:52 -0700 | [diff] [blame] | 209 | } |
| 210 | EXPORT_SYMBOL(inet_frags_init); |
| 211 | |
| 212 | void inet_frags_fini(struct inet_frags *f) |
| 213 | { |
Florian Westphal | b13d3cb | 2014-07-24 16:50:32 +0200 | [diff] [blame] | 214 | cancel_work_sync(&f->frags_work); |
Nikolay Aleksandrov | d4ad4d2 | 2014-08-01 12:29:48 +0200 | [diff] [blame] | 215 | kmem_cache_destroy(f->frags_cachep); |
Pavel Emelyanov | 7eb9515 | 2007-10-15 02:31:52 -0700 | [diff] [blame] | 216 | } |
| 217 | EXPORT_SYMBOL(inet_frags_fini); |
Pavel Emelyanov | 277e650 | 2007-10-15 02:37:18 -0700 | [diff] [blame] | 218 | |
Pavel Emelyanov | 81566e8 | 2008-01-22 06:12:39 -0800 | [diff] [blame] | 219 | void inet_frags_exit_net(struct netns_frags *nf, struct inet_frags *f) |
| 220 | { |
Florian Westphal | ab1c724 | 2014-07-24 16:50:36 +0200 | [diff] [blame] | 221 | unsigned int seq; |
Florian Westphal | b13d3cb | 2014-07-24 16:50:32 +0200 | [diff] [blame] | 222 | int i; |
| 223 | |
Pavel Emelyanov | 81566e8 | 2008-01-22 06:12:39 -0800 | [diff] [blame] | 224 | nf->low_thresh = 0; |
David S. Miller | e8e16b70 | 2008-03-28 17:30:18 -0700 | [diff] [blame] | 225 | |
Florian Westphal | ab1c724 | 2014-07-24 16:50:36 +0200 | [diff] [blame] | 226 | evict_again: |
Florian Westphal | 5719b29 | 2015-07-23 12:05:39 +0200 | [diff] [blame] | 227 | local_bh_disable(); |
Florian Westphal | ab1c724 | 2014-07-24 16:50:36 +0200 | [diff] [blame] | 228 | seq = read_seqbegin(&f->rnd_seqlock); |
Florian Westphal | b13d3cb | 2014-07-24 16:50:32 +0200 | [diff] [blame] | 229 | |
| 230 | for (i = 0; i < INETFRAGS_HASHSZ ; i++) |
| 231 | inet_evict_bucket(f, &f->hash[i]); |
| 232 | |
Florian Westphal | ab1c724 | 2014-07-24 16:50:36 +0200 | [diff] [blame] | 233 | local_bh_enable(); |
Florian Westphal | 5719b29 | 2015-07-23 12:05:39 +0200 | [diff] [blame] | 234 | cond_resched(); |
| 235 | |
| 236 | if (read_seqretry(&f->rnd_seqlock, seq) || |
| 237 | percpu_counter_sum(&nf->mem)) |
| 238 | goto evict_again; |
Jesper Dangaard Brouer | 6d7b857 | 2013-01-28 23:45:33 +0000 | [diff] [blame] | 239 | |
| 240 | percpu_counter_destroy(&nf->mem); |
Pavel Emelyanov | 81566e8 | 2008-01-22 06:12:39 -0800 | [diff] [blame] | 241 | } |
| 242 | EXPORT_SYMBOL(inet_frags_exit_net); |
| 243 | |
Florian Westphal | ab1c724 | 2014-07-24 16:50:36 +0200 | [diff] [blame] | 244 | static struct inet_frag_bucket * |
| 245 | get_frag_bucket_locked(struct inet_frag_queue *fq, struct inet_frags *f) |
| 246 | __acquires(hb->chain_lock) |
Pavel Emelyanov | 277e650 | 2007-10-15 02:37:18 -0700 | [diff] [blame] | 247 | { |
Jesper Dangaard Brouer | 19952cc4 | 2013-04-03 23:38:16 +0000 | [diff] [blame] | 248 | struct inet_frag_bucket *hb; |
Florian Westphal | ab1c724 | 2014-07-24 16:50:36 +0200 | [diff] [blame] | 249 | unsigned int seq, hash; |
Jesper Dangaard Brouer | 19952cc4 | 2013-04-03 23:38:16 +0000 | [diff] [blame] | 250 | |
Florian Westphal | ab1c724 | 2014-07-24 16:50:36 +0200 | [diff] [blame] | 251 | restart: |
| 252 | seq = read_seqbegin(&f->rnd_seqlock); |
| 253 | |
Florian Westphal | fb3cfe6 | 2014-07-24 16:50:30 +0200 | [diff] [blame] | 254 | hash = inet_frag_hashfn(f, fq); |
Jesper Dangaard Brouer | 19952cc4 | 2013-04-03 23:38:16 +0000 | [diff] [blame] | 255 | hb = &f->hash[hash]; |
| 256 | |
| 257 | spin_lock(&hb->chain_lock); |
Florian Westphal | ab1c724 | 2014-07-24 16:50:36 +0200 | [diff] [blame] | 258 | if (read_seqretry(&f->rnd_seqlock, seq)) { |
| 259 | spin_unlock(&hb->chain_lock); |
| 260 | goto restart; |
| 261 | } |
| 262 | |
| 263 | return hb; |
| 264 | } |
| 265 | |
| 266 | static inline void fq_unlink(struct inet_frag_queue *fq, struct inet_frags *f) |
| 267 | { |
| 268 | struct inet_frag_bucket *hb; |
| 269 | |
| 270 | hb = get_frag_bucket_locked(fq, f); |
Florian Westphal | d1fe194 | 2015-07-23 12:05:37 +0200 | [diff] [blame] | 271 | hlist_del(&fq->list); |
Florian Westphal | 5719b29 | 2015-07-23 12:05:39 +0200 | [diff] [blame] | 272 | fq->flags |= INET_FRAG_COMPLETE; |
Jesper Dangaard Brouer | 19952cc4 | 2013-04-03 23:38:16 +0000 | [diff] [blame] | 273 | spin_unlock(&hb->chain_lock); |
Pavel Emelyanov | 277e650 | 2007-10-15 02:37:18 -0700 | [diff] [blame] | 274 | } |
| 275 | |
| 276 | void inet_frag_kill(struct inet_frag_queue *fq, struct inet_frags *f) |
| 277 | { |
| 278 | if (del_timer(&fq->timer)) |
| 279 | atomic_dec(&fq->refcnt); |
| 280 | |
Nikolay Aleksandrov | 06aa8b8 | 2014-08-01 12:29:44 +0200 | [diff] [blame] | 281 | if (!(fq->flags & INET_FRAG_COMPLETE)) { |
Pavel Emelyanov | 277e650 | 2007-10-15 02:37:18 -0700 | [diff] [blame] | 282 | fq_unlink(fq, f); |
| 283 | atomic_dec(&fq->refcnt); |
Pavel Emelyanov | 277e650 | 2007-10-15 02:37:18 -0700 | [diff] [blame] | 284 | } |
| 285 | } |
Pavel Emelyanov | 277e650 | 2007-10-15 02:37:18 -0700 | [diff] [blame] | 286 | EXPORT_SYMBOL(inet_frag_kill); |
Pavel Emelyanov | 1e4b828 | 2007-10-15 02:39:14 -0700 | [diff] [blame] | 287 | |
Florian Westphal | 3fd588e | 2014-07-24 16:50:34 +0200 | [diff] [blame] | 288 | 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] | 289 | { |
| 290 | struct sk_buff *fp; |
Pavel Emelyanov | 6ddc082 | 2008-01-22 06:07:25 -0800 | [diff] [blame] | 291 | struct netns_frags *nf; |
Jesper Dangaard Brouer | d433673 | 2013-01-28 23:45:12 +0000 | [diff] [blame] | 292 | unsigned int sum, sum_truesize = 0; |
Pavel Emelyanov | 1e4b828 | 2007-10-15 02:39:14 -0700 | [diff] [blame] | 293 | |
Nikolay Aleksandrov | 06aa8b8 | 2014-08-01 12:29:44 +0200 | [diff] [blame] | 294 | WARN_ON(!(q->flags & INET_FRAG_COMPLETE)); |
Ilpo Järvinen | 547b792 | 2008-07-25 21:43:18 -0700 | [diff] [blame] | 295 | WARN_ON(del_timer(&q->timer) != 0); |
Pavel Emelyanov | 1e4b828 | 2007-10-15 02:39:14 -0700 | [diff] [blame] | 296 | |
| 297 | /* Release all fragment data. */ |
| 298 | fp = q->fragments; |
Pavel Emelyanov | 6ddc082 | 2008-01-22 06:07:25 -0800 | [diff] [blame] | 299 | nf = q->net; |
Pavel Emelyanov | 1e4b828 | 2007-10-15 02:39:14 -0700 | [diff] [blame] | 300 | while (fp) { |
| 301 | struct sk_buff *xp = fp->next; |
| 302 | |
Jesper Dangaard Brouer | d433673 | 2013-01-28 23:45:12 +0000 | [diff] [blame] | 303 | sum_truesize += fp->truesize; |
Florian Westphal | a72a5e2 | 2016-01-05 22:17:55 +0100 | [diff] [blame] | 304 | kfree_skb(fp); |
Pavel Emelyanov | 1e4b828 | 2007-10-15 02:39:14 -0700 | [diff] [blame] | 305 | fp = xp; |
| 306 | } |
Jesper Dangaard Brouer | d433673 | 2013-01-28 23:45:12 +0000 | [diff] [blame] | 307 | sum = sum_truesize + f->qsize; |
Pavel Emelyanov | 1e4b828 | 2007-10-15 02:39:14 -0700 | [diff] [blame] | 308 | |
Pavel Emelyanov | c954770 | 2007-10-17 19:48:26 -0700 | [diff] [blame] | 309 | if (f->destructor) |
| 310 | f->destructor(q); |
Nikolay Aleksandrov | d4ad4d2 | 2014-08-01 12:29:48 +0200 | [diff] [blame] | 311 | kmem_cache_free(f->frags_cachep, q); |
Florian Westphal | 5719b29 | 2015-07-23 12:05:39 +0200 | [diff] [blame] | 312 | |
| 313 | sub_frag_mem_limit(nf, sum); |
Pavel Emelyanov | 1e4b828 | 2007-10-15 02:39:14 -0700 | [diff] [blame] | 314 | } |
| 315 | EXPORT_SYMBOL(inet_frag_destroy); |
Pavel Emelyanov | 8e7999c | 2007-10-15 02:40:06 -0700 | [diff] [blame] | 316 | |
Pavel Emelyanov | ac18e75 | 2008-01-22 06:02:14 -0800 | [diff] [blame] | 317 | static struct inet_frag_queue *inet_frag_intern(struct netns_frags *nf, |
Nikolay Aleksandrov | f926e23 | 2014-08-01 12:29:46 +0200 | [diff] [blame] | 318 | struct inet_frag_queue *qp_in, |
| 319 | struct inet_frags *f, |
| 320 | void *arg) |
Pavel Emelyanov | 2588fe1 | 2007-10-17 19:44:34 -0700 | [diff] [blame] | 321 | { |
Florian Westphal | ab1c724 | 2014-07-24 16:50:36 +0200 | [diff] [blame] | 322 | struct inet_frag_bucket *hb = get_frag_bucket_locked(qp_in, f); |
Pavel Emelyanov | 2588fe1 | 2007-10-17 19:44:34 -0700 | [diff] [blame] | 323 | struct inet_frag_queue *qp; |
Jesper Dangaard Brouer | 19952cc4 | 2013-04-03 23:38:16 +0000 | [diff] [blame] | 324 | |
Pavel Emelyanov | 2588fe1 | 2007-10-17 19:44:34 -0700 | [diff] [blame] | 325 | #ifdef CONFIG_SMP |
| 326 | /* With SMP race we have to recheck hash table, because |
Florian Westphal | ab1c724 | 2014-07-24 16:50:36 +0200 | [diff] [blame] | 327 | * such entry could have been created on other cpu before |
| 328 | * we acquired hash bucket lock. |
Pavel Emelyanov | 2588fe1 | 2007-10-17 19:44:34 -0700 | [diff] [blame] | 329 | */ |
Jesper Dangaard Brouer | 19952cc4 | 2013-04-03 23:38:16 +0000 | [diff] [blame] | 330 | hlist_for_each_entry(qp, &hb->chain, list) { |
Pavel Emelyanov | ac18e75 | 2008-01-22 06:02:14 -0800 | [diff] [blame] | 331 | if (qp->net == nf && f->match(qp, arg)) { |
Pavel Emelyanov | 2588fe1 | 2007-10-17 19:44:34 -0700 | [diff] [blame] | 332 | atomic_inc(&qp->refcnt); |
Jesper Dangaard Brouer | 19952cc4 | 2013-04-03 23:38:16 +0000 | [diff] [blame] | 333 | spin_unlock(&hb->chain_lock); |
Nikolay Aleksandrov | 06aa8b8 | 2014-08-01 12:29:44 +0200 | [diff] [blame] | 334 | qp_in->flags |= INET_FRAG_COMPLETE; |
Pavel Emelyanov | 2588fe1 | 2007-10-17 19:44:34 -0700 | [diff] [blame] | 335 | inet_frag_put(qp_in, f); |
| 336 | return qp; |
| 337 | } |
| 338 | } |
| 339 | #endif |
| 340 | qp = qp_in; |
Pavel Emelyanov | b2fd532 | 2008-01-22 06:09:37 -0800 | [diff] [blame] | 341 | if (!mod_timer(&qp->timer, jiffies + nf->timeout)) |
Pavel Emelyanov | 2588fe1 | 2007-10-17 19:44:34 -0700 | [diff] [blame] | 342 | atomic_inc(&qp->refcnt); |
| 343 | |
| 344 | atomic_inc(&qp->refcnt); |
Jesper Dangaard Brouer | 19952cc4 | 2013-04-03 23:38:16 +0000 | [diff] [blame] | 345 | hlist_add_head(&qp->list, &hb->chain); |
Florian Westphal | 3fd588e | 2014-07-24 16:50:34 +0200 | [diff] [blame] | 346 | |
Jesper Dangaard Brouer | 19952cc4 | 2013-04-03 23:38:16 +0000 | [diff] [blame] | 347 | spin_unlock(&hb->chain_lock); |
Nikolay Aleksandrov | 24b9bf4 | 2014-03-03 23:19:18 +0100 | [diff] [blame] | 348 | |
Pavel Emelyanov | 2588fe1 | 2007-10-17 19:44:34 -0700 | [diff] [blame] | 349 | return qp; |
| 350 | } |
Pavel Emelyanov | e521db9 | 2007-10-17 19:45:23 -0700 | [diff] [blame] | 351 | |
Pavel Emelyanov | ac18e75 | 2008-01-22 06:02:14 -0800 | [diff] [blame] | 352 | static struct inet_frag_queue *inet_frag_alloc(struct netns_frags *nf, |
Nikolay Aleksandrov | f926e23 | 2014-08-01 12:29:46 +0200 | [diff] [blame] | 353 | struct inet_frags *f, |
| 354 | void *arg) |
Pavel Emelyanov | e521db9 | 2007-10-17 19:45:23 -0700 | [diff] [blame] | 355 | { |
| 356 | struct inet_frag_queue *q; |
| 357 | |
Michal Kubeček | 30759219 | 2016-05-27 17:53:52 +0200 | [diff] [blame^] | 358 | if (!nf->high_thresh || frag_mem_limit(nf) > nf->high_thresh) { |
Florian Westphal | b13d3cb | 2014-07-24 16:50:32 +0200 | [diff] [blame] | 359 | inet_frag_schedule_worker(f); |
Florian Westphal | 86e93e4 | 2014-07-24 16:50:31 +0200 | [diff] [blame] | 360 | return NULL; |
Florian Westphal | b13d3cb | 2014-07-24 16:50:32 +0200 | [diff] [blame] | 361 | } |
Florian Westphal | 86e93e4 | 2014-07-24 16:50:31 +0200 | [diff] [blame] | 362 | |
Nikolay Aleksandrov | d4ad4d2 | 2014-08-01 12:29:48 +0200 | [diff] [blame] | 363 | q = kmem_cache_zalloc(f->frags_cachep, GFP_ATOMIC); |
Ian Morris | 51456b2 | 2015-04-03 09:17:26 +0100 | [diff] [blame] | 364 | if (!q) |
Pavel Emelyanov | e521db9 | 2007-10-17 19:45:23 -0700 | [diff] [blame] | 365 | return NULL; |
| 366 | |
Gao feng | 54db0cc | 2012-06-08 01:21:40 +0000 | [diff] [blame] | 367 | q->net = nf; |
Pavel Emelyanov | c6fda28 | 2007-10-17 19:46:47 -0700 | [diff] [blame] | 368 | f->constructor(q, arg); |
Florian Westphal | 0e60d24 | 2015-07-23 12:05:38 +0200 | [diff] [blame] | 369 | add_frag_mem_limit(nf, f->qsize); |
Jesper Dangaard Brouer | d433673 | 2013-01-28 23:45:12 +0000 | [diff] [blame] | 370 | |
Pavel Emelyanov | e521db9 | 2007-10-17 19:45:23 -0700 | [diff] [blame] | 371 | setup_timer(&q->timer, f->frag_expire, (unsigned long)q); |
| 372 | spin_lock_init(&q->lock); |
| 373 | atomic_set(&q->refcnt, 1); |
| 374 | |
| 375 | return q; |
| 376 | } |
Pavel Emelyanov | c6fda28 | 2007-10-17 19:46:47 -0700 | [diff] [blame] | 377 | |
Pavel Emelyanov | ac18e75 | 2008-01-22 06:02:14 -0800 | [diff] [blame] | 378 | static struct inet_frag_queue *inet_frag_create(struct netns_frags *nf, |
Nikolay Aleksandrov | f926e23 | 2014-08-01 12:29:46 +0200 | [diff] [blame] | 379 | struct inet_frags *f, |
| 380 | void *arg) |
Pavel Emelyanov | c6fda28 | 2007-10-17 19:46:47 -0700 | [diff] [blame] | 381 | { |
| 382 | struct inet_frag_queue *q; |
| 383 | |
Pavel Emelyanov | ac18e75 | 2008-01-22 06:02:14 -0800 | [diff] [blame] | 384 | q = inet_frag_alloc(nf, f, arg); |
Ian Morris | 51456b2 | 2015-04-03 09:17:26 +0100 | [diff] [blame] | 385 | if (!q) |
Pavel Emelyanov | c6fda28 | 2007-10-17 19:46:47 -0700 | [diff] [blame] | 386 | return NULL; |
| 387 | |
Pavel Emelyanov | 9a37580 | 2008-06-27 20:06:08 -0700 | [diff] [blame] | 388 | return inet_frag_intern(nf, q, f, arg); |
Pavel Emelyanov | c6fda28 | 2007-10-17 19:46:47 -0700 | [diff] [blame] | 389 | } |
Pavel Emelyanov | abd6523 | 2007-10-17 19:47:21 -0700 | [diff] [blame] | 390 | |
Pavel Emelyanov | ac18e75 | 2008-01-22 06:02:14 -0800 | [diff] [blame] | 391 | struct inet_frag_queue *inet_frag_find(struct netns_frags *nf, |
Nikolay Aleksandrov | f926e23 | 2014-08-01 12:29:46 +0200 | [diff] [blame] | 392 | struct inet_frags *f, void *key, |
| 393 | unsigned int hash) |
Pavel Emelyanov | abd6523 | 2007-10-17 19:47:21 -0700 | [diff] [blame] | 394 | { |
Jesper Dangaard Brouer | 19952cc4 | 2013-04-03 23:38:16 +0000 | [diff] [blame] | 395 | struct inet_frag_bucket *hb; |
Pavel Emelyanov | abd6523 | 2007-10-17 19:47:21 -0700 | [diff] [blame] | 396 | struct inet_frag_queue *q; |
Hannes Frederic Sowa | 5a3da1f | 2013-03-15 11:32:30 +0000 | [diff] [blame] | 397 | int depth = 0; |
Pavel Emelyanov | abd6523 | 2007-10-17 19:47:21 -0700 | [diff] [blame] | 398 | |
Florian Westphal | b13d3cb | 2014-07-24 16:50:32 +0200 | [diff] [blame] | 399 | if (frag_mem_limit(nf) > nf->low_thresh) |
| 400 | inet_frag_schedule_worker(f); |
Florian Westphal | 86e93e4 | 2014-07-24 16:50:31 +0200 | [diff] [blame] | 401 | |
Florian Westphal | fb3cfe6 | 2014-07-24 16:50:30 +0200 | [diff] [blame] | 402 | hash &= (INETFRAGS_HASHSZ - 1); |
Jesper Dangaard Brouer | 19952cc4 | 2013-04-03 23:38:16 +0000 | [diff] [blame] | 403 | hb = &f->hash[hash]; |
| 404 | |
| 405 | spin_lock(&hb->chain_lock); |
| 406 | hlist_for_each_entry(q, &hb->chain, list) { |
Pavel Emelyanov | ac18e75 | 2008-01-22 06:02:14 -0800 | [diff] [blame] | 407 | if (q->net == nf && f->match(q, key)) { |
Pavel Emelyanov | abd6523 | 2007-10-17 19:47:21 -0700 | [diff] [blame] | 408 | atomic_inc(&q->refcnt); |
Jesper Dangaard Brouer | 19952cc4 | 2013-04-03 23:38:16 +0000 | [diff] [blame] | 409 | spin_unlock(&hb->chain_lock); |
Pavel Emelyanov | abd6523 | 2007-10-17 19:47:21 -0700 | [diff] [blame] | 410 | return q; |
| 411 | } |
Hannes Frederic Sowa | 5a3da1f | 2013-03-15 11:32:30 +0000 | [diff] [blame] | 412 | depth++; |
Pavel Emelyanov | abd6523 | 2007-10-17 19:47:21 -0700 | [diff] [blame] | 413 | } |
Jesper Dangaard Brouer | 19952cc4 | 2013-04-03 23:38:16 +0000 | [diff] [blame] | 414 | spin_unlock(&hb->chain_lock); |
Pavel Emelyanov | abd6523 | 2007-10-17 19:47:21 -0700 | [diff] [blame] | 415 | |
Hannes Frederic Sowa | 5a3da1f | 2013-03-15 11:32:30 +0000 | [diff] [blame] | 416 | if (depth <= INETFRAGS_MAXDEPTH) |
| 417 | return inet_frag_create(nf, f, key); |
Florian Westphal | e3a57d1 | 2014-07-24 16:50:35 +0200 | [diff] [blame] | 418 | |
| 419 | if (inet_frag_may_rebuild(f)) { |
Florian Westphal | ab1c724 | 2014-07-24 16:50:36 +0200 | [diff] [blame] | 420 | if (!f->rebuild) |
| 421 | f->rebuild = true; |
Florian Westphal | e3a57d1 | 2014-07-24 16:50:35 +0200 | [diff] [blame] | 422 | inet_frag_schedule_worker(f); |
| 423 | } |
| 424 | |
| 425 | return ERR_PTR(-ENOBUFS); |
Pavel Emelyanov | abd6523 | 2007-10-17 19:47:21 -0700 | [diff] [blame] | 426 | } |
| 427 | EXPORT_SYMBOL(inet_frag_find); |
Hannes Frederic Sowa | 5a3da1f | 2013-03-15 11:32:30 +0000 | [diff] [blame] | 428 | |
| 429 | void inet_frag_maybe_warn_overflow(struct inet_frag_queue *q, |
| 430 | const char *prefix) |
| 431 | { |
| 432 | static const char msg[] = "inet_frag_find: Fragment hash bucket" |
| 433 | " list length grew over limit " __stringify(INETFRAGS_MAXDEPTH) |
| 434 | ". Dropping fragment.\n"; |
| 435 | |
| 436 | if (PTR_ERR(q) == -ENOBUFS) |
Joe Perches | ba7a46f | 2014-11-11 10:59:17 -0800 | [diff] [blame] | 437 | net_dbg_ratelimited("%s%s", prefix, msg); |
Hannes Frederic Sowa | 5a3da1f | 2013-03-15 11:32:30 +0000 | [diff] [blame] | 438 | } |
| 439 | EXPORT_SYMBOL(inet_frag_maybe_warn_overflow); |