blob: b99c7c7ffce2b72b0089ba8c53d4de6e5b131059 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
2 * net/core/dst.c Protocol independent destination cache.
3 *
4 * Authors: Alexey Kuznetsov, <kuznet@ms2.inr.ac.ru>
5 *
6 */
7
8#include <linux/bitops.h>
9#include <linux/errno.h>
10#include <linux/init.h>
11#include <linux/kernel.h>
Eric Dumazet86bba262007-09-12 14:29:01 +020012#include <linux/workqueue.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070013#include <linux/mm.h>
14#include <linux/module.h>
Tejun Heo5a0e3ad2010-03-24 17:04:11 +090015#include <linux/slab.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070016#include <linux/netdevice.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070017#include <linux/skbuff.h>
18#include <linux/string.h>
19#include <linux/types.h>
Eric W. Biedermane9dc8652007-09-12 13:02:17 +020020#include <net/net_namespace.h>
Eric Dumazet2fc1b5d2010-02-08 15:00:39 -080021#include <linux/sched.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070022
23#include <net/dst.h>
24
Eric Dumazet86bba262007-09-12 14:29:01 +020025/*
26 * Theory of operations:
27 * 1) We use a list, protected by a spinlock, to add
28 * new entries from both BH and non-BH context.
29 * 2) In order to keep spinlock held for a small delay,
30 * we use a second list where are stored long lived
31 * entries, that are handled by the garbage collect thread
32 * fired by a workqueue.
33 * 3) This list is guarded by a mutex,
34 * so that the gc_task and dst_dev_event() can be synchronized.
Linus Torvalds1da177e2005-04-16 15:20:36 -070035 */
YOSHIFUJI Hideaki4ec93ed2007-02-09 23:24:36 +090036#if RT_CACHE_DEBUG >= 2
Linus Torvalds1da177e2005-04-16 15:20:36 -070037static atomic_t dst_total = ATOMIC_INIT(0);
38#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -070039
Eric Dumazet86bba262007-09-12 14:29:01 +020040/*
41 * We want to keep lock & list close together
42 * to dirty as few cache lines as possible in __dst_free().
43 * As this is not a very strong hint, we dont force an alignment on SMP.
44 */
45static struct {
46 spinlock_t lock;
laurent chavey598ed932010-03-29 10:41:36 +000047 struct dst_entry *list;
Eric Dumazet86bba262007-09-12 14:29:01 +020048 unsigned long timer_inc;
49 unsigned long timer_expires;
50} dst_garbage = {
51 .lock = __SPIN_LOCK_UNLOCKED(dst_garbage.lock),
52 .timer_inc = DST_GC_MAX,
53};
54static void dst_gc_task(struct work_struct *work);
laurent chavey598ed932010-03-29 10:41:36 +000055static void ___dst_free(struct dst_entry *dst);
Linus Torvalds1da177e2005-04-16 15:20:36 -070056
Eric Dumazet86bba262007-09-12 14:29:01 +020057static DECLARE_DELAYED_WORK(dst_gc_work, dst_gc_task);
Linus Torvalds1da177e2005-04-16 15:20:36 -070058
Eric Dumazet86bba262007-09-12 14:29:01 +020059static DEFINE_MUTEX(dst_gc_mutex);
60/*
61 * long lived entries are maintained in this list, guarded by dst_gc_mutex
62 */
63static struct dst_entry *dst_busy_list;
64
65static void dst_gc_task(struct work_struct *work)
Linus Torvalds1da177e2005-04-16 15:20:36 -070066{
67 int delayed = 0;
Eric Dumazet86bba262007-09-12 14:29:01 +020068 int work_performed = 0;
69 unsigned long expires = ~0L;
70 struct dst_entry *dst, *next, head;
71 struct dst_entry *last = &head;
72#if RT_CACHE_DEBUG >= 2
73 ktime_t time_start = ktime_get();
74 struct timespec elapsed;
75#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -070076
Eric Dumazet86bba262007-09-12 14:29:01 +020077 mutex_lock(&dst_gc_mutex);
78 next = dst_busy_list;
Linus Torvalds1da177e2005-04-16 15:20:36 -070079
Eric Dumazet86bba262007-09-12 14:29:01 +020080loop:
81 while ((dst = next) != NULL) {
82 next = dst->next;
83 prefetch(&next->next);
Eric Dumazet2fc1b5d2010-02-08 15:00:39 -080084 cond_resched();
Eric Dumazet86bba262007-09-12 14:29:01 +020085 if (likely(atomic_read(&dst->__refcnt))) {
86 last->next = dst;
87 last = dst;
Linus Torvalds1da177e2005-04-16 15:20:36 -070088 delayed++;
89 continue;
90 }
Eric Dumazet86bba262007-09-12 14:29:01 +020091 work_performed++;
Linus Torvalds1da177e2005-04-16 15:20:36 -070092
93 dst = dst_destroy(dst);
94 if (dst) {
95 /* NOHASH and still referenced. Unless it is already
96 * on gc list, invalidate it and add to gc list.
97 *
98 * Note: this is temporary. Actually, NOHASH dst's
99 * must be obsoleted when parent is obsoleted.
100 * But we do not have state "obsoleted, but
101 * referenced by parent", so it is right.
102 */
103 if (dst->obsolete > 1)
104 continue;
105
106 ___dst_free(dst);
Eric Dumazet86bba262007-09-12 14:29:01 +0200107 dst->next = next;
108 next = dst;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700109 }
110 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700111
Eric Dumazet86bba262007-09-12 14:29:01 +0200112 spin_lock_bh(&dst_garbage.lock);
113 next = dst_garbage.list;
114 if (next) {
115 dst_garbage.list = NULL;
116 spin_unlock_bh(&dst_garbage.lock);
117 goto loop;
118 }
119 last->next = NULL;
120 dst_busy_list = head.next;
121 if (!dst_busy_list)
122 dst_garbage.timer_inc = DST_GC_MAX;
123 else {
124 /*
125 * if we freed less than 1/10 of delayed entries,
126 * we can sleep longer.
127 */
128 if (work_performed <= delayed/10) {
129 dst_garbage.timer_expires += dst_garbage.timer_inc;
130 if (dst_garbage.timer_expires > DST_GC_MAX)
131 dst_garbage.timer_expires = DST_GC_MAX;
132 dst_garbage.timer_inc += DST_GC_INC;
133 } else {
134 dst_garbage.timer_inc = DST_GC_INC;
135 dst_garbage.timer_expires = DST_GC_MIN;
136 }
137 expires = dst_garbage.timer_expires;
138 /*
laurent chavey598ed932010-03-29 10:41:36 +0000139 * if the next desired timer is more than 4 seconds in the
140 * future then round the timer to whole seconds
Eric Dumazet86bba262007-09-12 14:29:01 +0200141 */
142 if (expires > 4*HZ)
143 expires = round_jiffies_relative(expires);
144 schedule_delayed_work(&dst_gc_work, expires);
145 }
146
147 spin_unlock_bh(&dst_garbage.lock);
148 mutex_unlock(&dst_gc_mutex);
149#if RT_CACHE_DEBUG >= 2
150 elapsed = ktime_to_timespec(ktime_sub(ktime_get(), time_start));
151 printk(KERN_DEBUG "dst_total: %d delayed: %d work_perf: %d"
152 " expires: %lu elapsed: %lu us\n",
153 atomic_read(&dst_total), delayed, work_performed,
154 expires,
laurent chavey598ed932010-03-29 10:41:36 +0000155 elapsed.tv_sec * USEC_PER_SEC +
156 elapsed.tv_nsec / NSEC_PER_USEC);
Eric Dumazet86bba262007-09-12 14:29:01 +0200157#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700158}
159
Herbert Xu352e5122007-11-13 21:34:06 -0800160int dst_discard(struct sk_buff *skb)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700161{
162 kfree_skb(skb);
163 return 0;
164}
Herbert Xu352e5122007-11-13 21:34:06 -0800165EXPORT_SYMBOL(dst_discard);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700166
laurent chavey598ed932010-03-29 10:41:36 +0000167void *dst_alloc(struct dst_ops *ops)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700168{
laurent chavey598ed932010-03-29 10:41:36 +0000169 struct dst_entry *dst;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700170
Eric Dumazetfc66f952010-10-08 06:37:34 +0000171 if (ops->gc && dst_entries_get_fast(ops) > ops->gc_thresh) {
Daniel Lezcano569d3642008-01-18 03:56:57 -0800172 if (ops->gc(ops))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700173 return NULL;
174 }
Robert P. J. Dayc3762222007-02-10 01:45:03 -0800175 dst = kmem_cache_zalloc(ops->kmem_cachep, GFP_ATOMIC);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700176 if (!dst)
177 return NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700178 atomic_set(&dst->__refcnt, 0);
179 dst->ops = ops;
180 dst->lastuse = jiffies;
181 dst->path = dst;
Denis Chengc4b10102007-06-05 00:06:57 -0700182 dst->input = dst->output = dst_discard;
YOSHIFUJI Hideaki4ec93ed2007-02-09 23:24:36 +0900183#if RT_CACHE_DEBUG >= 2
Linus Torvalds1da177e2005-04-16 15:20:36 -0700184 atomic_inc(&dst_total);
185#endif
Eric Dumazetfc66f952010-10-08 06:37:34 +0000186 dst_entries_add(ops, 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700187 return dst;
188}
laurent chavey598ed932010-03-29 10:41:36 +0000189EXPORT_SYMBOL(dst_alloc);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700190
laurent chavey598ed932010-03-29 10:41:36 +0000191static void ___dst_free(struct dst_entry *dst)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700192{
193 /* The first case (dev==NULL) is required, when
194 protocol module is unloaded.
195 */
laurent chavey598ed932010-03-29 10:41:36 +0000196 if (dst->dev == NULL || !(dst->dev->flags&IFF_UP))
Denis Chengc4b10102007-06-05 00:06:57 -0700197 dst->input = dst->output = dst_discard;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700198 dst->obsolete = 2;
199}
200
laurent chavey598ed932010-03-29 10:41:36 +0000201void __dst_free(struct dst_entry *dst)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700202{
Eric Dumazet86bba262007-09-12 14:29:01 +0200203 spin_lock_bh(&dst_garbage.lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700204 ___dst_free(dst);
Eric Dumazet86bba262007-09-12 14:29:01 +0200205 dst->next = dst_garbage.list;
206 dst_garbage.list = dst;
207 if (dst_garbage.timer_inc > DST_GC_INC) {
208 dst_garbage.timer_inc = DST_GC_INC;
209 dst_garbage.timer_expires = DST_GC_MIN;
Benjamin Theryf262b592008-09-12 16:16:37 -0700210 cancel_delayed_work(&dst_gc_work);
Eric Dumazet86bba262007-09-12 14:29:01 +0200211 schedule_delayed_work(&dst_gc_work, dst_garbage.timer_expires);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700212 }
Eric Dumazet86bba262007-09-12 14:29:01 +0200213 spin_unlock_bh(&dst_garbage.lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700214}
Nicolas Dichteld79d9912010-07-19 23:51:38 +0000215EXPORT_SYMBOL(__dst_free);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700216
217struct dst_entry *dst_destroy(struct dst_entry * dst)
218{
219 struct dst_entry *child;
220 struct neighbour *neigh;
221 struct hh_cache *hh;
222
223 smp_rmb();
224
225again:
226 neigh = dst->neighbour;
227 hh = dst->hh;
228 child = dst->child;
229
230 dst->hh = NULL;
Eric Dumazet34d101d2010-10-11 09:16:57 -0700231 if (hh)
232 hh_cache_put(hh);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700233
234 if (neigh) {
235 dst->neighbour = NULL;
236 neigh_release(neigh);
237 }
238
Eric Dumazetfc66f952010-10-08 06:37:34 +0000239 dst_entries_add(dst->ops, -1);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700240
241 if (dst->ops->destroy)
242 dst->ops->destroy(dst);
243 if (dst->dev)
244 dev_put(dst->dev);
YOSHIFUJI Hideaki4ec93ed2007-02-09 23:24:36 +0900245#if RT_CACHE_DEBUG >= 2
Linus Torvalds1da177e2005-04-16 15:20:36 -0700246 atomic_dec(&dst_total);
247#endif
248 kmem_cache_free(dst->ops->kmem_cachep, dst);
249
250 dst = child;
251 if (dst) {
Herbert Xu6775cab2005-04-16 15:24:10 -0700252 int nohash = dst->flags & DST_NOHASH;
253
Linus Torvalds1da177e2005-04-16 15:20:36 -0700254 if (atomic_dec_and_test(&dst->__refcnt)) {
255 /* We were real parent of this dst, so kill child. */
Herbert Xu6775cab2005-04-16 15:24:10 -0700256 if (nohash)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700257 goto again;
258 } else {
259 /* Child is still referenced, return it for freeing. */
Herbert Xu6775cab2005-04-16 15:24:10 -0700260 if (nohash)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700261 return dst;
262 /* Child is still in his hash table */
263 }
264 }
265 return NULL;
266}
laurent chavey598ed932010-03-29 10:41:36 +0000267EXPORT_SYMBOL(dst_destroy);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700268
Ilpo Järvinen8d330862008-03-27 17:53:31 -0700269void dst_release(struct dst_entry *dst)
270{
271 if (dst) {
laurent chavey598ed932010-03-29 10:41:36 +0000272 int newrefcnt;
Eric Dumazetef711cf2008-11-14 00:53:54 -0800273
laurent chavey598ed932010-03-29 10:41:36 +0000274 newrefcnt = atomic_dec_return(&dst->__refcnt);
275 WARN_ON(newrefcnt < 0);
Eric Dumazet27b75c92010-10-15 05:44:11 +0000276 if (unlikely(dst->flags & DST_NOCACHE) && !newrefcnt) {
277 dst = dst_destroy(dst);
278 if (dst)
279 __dst_free(dst);
280 }
Ilpo Järvinen8d330862008-03-27 17:53:31 -0700281 }
282}
283EXPORT_SYMBOL(dst_release);
284
Eric Dumazet27b75c92010-10-15 05:44:11 +0000285/**
286 * skb_dst_set_noref - sets skb dst, without a reference
287 * @skb: buffer
288 * @dst: dst entry
289 *
290 * Sets skb dst, assuming a reference was not taken on dst
291 * skb_dst_drop() should not dst_release() this dst
292 */
293void skb_dst_set_noref(struct sk_buff *skb, struct dst_entry *dst)
294{
295 WARN_ON(!rcu_read_lock_held() && !rcu_read_lock_bh_held());
296 /* If dst not in cache, we must take a reference, because
297 * dst_release() will destroy dst as soon as its refcount becomes zero
298 */
299 if (unlikely(dst->flags & DST_NOCACHE)) {
300 dst_hold(dst);
301 skb_dst_set(skb, dst);
302 } else {
303 skb->_skb_refdst = (unsigned long)dst | SKB_DST_NOREF;
304 }
305}
306EXPORT_SYMBOL(skb_dst_set_noref);
307
Linus Torvalds1da177e2005-04-16 15:20:36 -0700308/* Dirty hack. We did it in 2.2 (in __dst_free),
309 * we have _very_ good reasons not to repeat
310 * this mistake in 2.3, but we have no choice
311 * now. _It_ _is_ _explicit_ _deliberate_
312 * _race_ _condition_.
313 *
314 * Commented and originally written by Alexey.
315 */
stephen hemminger56115512010-04-12 07:38:05 +0000316static void dst_ifdown(struct dst_entry *dst, struct net_device *dev,
317 int unregister)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700318{
319 if (dst->ops->ifdown)
320 dst->ops->ifdown(dst, dev, unregister);
321
322 if (dev != dst->dev)
323 return;
324
325 if (!unregister) {
Denis Chengc4b10102007-06-05 00:06:57 -0700326 dst->input = dst->output = dst_discard;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700327 } else {
YOSHIFUJI Hideakic346dca2008-03-25 21:47:49 +0900328 dst->dev = dev_net(dst->dev)->loopback_dev;
Daniel Lezcanode3cb742007-09-25 19:16:28 -0700329 dev_hold(dst->dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700330 dev_put(dev);
331 if (dst->neighbour && dst->neighbour->dev == dev) {
Denis V. Lunev5a3e55d2007-12-07 00:38:10 -0800332 dst->neighbour->dev = dst->dev;
Eric Dumazet64b7d962007-12-11 02:00:30 -0800333 dev_hold(dst->dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700334 dev_put(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700335 }
336 }
337}
338
laurent chavey598ed932010-03-29 10:41:36 +0000339static int dst_dev_event(struct notifier_block *this, unsigned long event,
340 void *ptr)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700341{
342 struct net_device *dev = ptr;
Eric Dumazet86bba262007-09-12 14:29:01 +0200343 struct dst_entry *dst, *last = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700344
Linus Torvalds1da177e2005-04-16 15:20:36 -0700345 switch (event) {
346 case NETDEV_UNREGISTER:
347 case NETDEV_DOWN:
Eric Dumazet86bba262007-09-12 14:29:01 +0200348 mutex_lock(&dst_gc_mutex);
349 for (dst = dst_busy_list; dst; dst = dst->next) {
350 last = dst;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700351 dst_ifdown(dst, dev, event != NETDEV_DOWN);
352 }
Eric Dumazet86bba262007-09-12 14:29:01 +0200353
354 spin_lock_bh(&dst_garbage.lock);
355 dst = dst_garbage.list;
356 dst_garbage.list = NULL;
357 spin_unlock_bh(&dst_garbage.lock);
358
359 if (last)
360 last->next = dst;
361 else
362 dst_busy_list = dst;
laurent chavey598ed932010-03-29 10:41:36 +0000363 for (; dst; dst = dst->next)
Eric Dumazet86bba262007-09-12 14:29:01 +0200364 dst_ifdown(dst, dev, event != NETDEV_DOWN);
Eric Dumazet86bba262007-09-12 14:29:01 +0200365 mutex_unlock(&dst_gc_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700366 break;
367 }
368 return NOTIFY_DONE;
369}
370
371static struct notifier_block dst_dev_notifier = {
372 .notifier_call = dst_dev_event,
Eric Dumazet332dd962010-11-09 11:46:33 -0800373 .priority = -10, /* must be called after other network notifiers */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700374};
375
376void __init dst_init(void)
377{
378 register_netdevice_notifier(&dst_dev_notifier);
379}