blob: 978a1ee1f7d0a1f2aae6692c46f6a39b40a12feb [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
171 if (ops->gc && atomic_read(&ops->entries) > 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
186 atomic_inc(&ops->entries);
187 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
239 atomic_dec(&dst->ops->entries);
240
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
Ilpo Järvinen8d330862008-03-27 17:53:31 -0700274 smp_mb__before_atomic_dec();
laurent chavey598ed932010-03-29 10:41:36 +0000275 newrefcnt = atomic_dec_return(&dst->__refcnt);
276 WARN_ON(newrefcnt < 0);
Ilpo Järvinen8d330862008-03-27 17:53:31 -0700277 }
278}
279EXPORT_SYMBOL(dst_release);
280
Linus Torvalds1da177e2005-04-16 15:20:36 -0700281/* Dirty hack. We did it in 2.2 (in __dst_free),
282 * we have _very_ good reasons not to repeat
283 * this mistake in 2.3, but we have no choice
284 * now. _It_ _is_ _explicit_ _deliberate_
285 * _race_ _condition_.
286 *
287 * Commented and originally written by Alexey.
288 */
stephen hemminger56115512010-04-12 07:38:05 +0000289static void dst_ifdown(struct dst_entry *dst, struct net_device *dev,
290 int unregister)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700291{
292 if (dst->ops->ifdown)
293 dst->ops->ifdown(dst, dev, unregister);
294
295 if (dev != dst->dev)
296 return;
297
298 if (!unregister) {
Denis Chengc4b10102007-06-05 00:06:57 -0700299 dst->input = dst->output = dst_discard;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700300 } else {
YOSHIFUJI Hideakic346dca2008-03-25 21:47:49 +0900301 dst->dev = dev_net(dst->dev)->loopback_dev;
Daniel Lezcanode3cb742007-09-25 19:16:28 -0700302 dev_hold(dst->dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700303 dev_put(dev);
304 if (dst->neighbour && dst->neighbour->dev == dev) {
Denis V. Lunev5a3e55d2007-12-07 00:38:10 -0800305 dst->neighbour->dev = dst->dev;
Eric Dumazet64b7d962007-12-11 02:00:30 -0800306 dev_hold(dst->dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700307 dev_put(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700308 }
309 }
310}
311
laurent chavey598ed932010-03-29 10:41:36 +0000312static int dst_dev_event(struct notifier_block *this, unsigned long event,
313 void *ptr)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700314{
315 struct net_device *dev = ptr;
Eric Dumazet86bba262007-09-12 14:29:01 +0200316 struct dst_entry *dst, *last = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700317
Linus Torvalds1da177e2005-04-16 15:20:36 -0700318 switch (event) {
319 case NETDEV_UNREGISTER:
320 case NETDEV_DOWN:
Eric Dumazet86bba262007-09-12 14:29:01 +0200321 mutex_lock(&dst_gc_mutex);
322 for (dst = dst_busy_list; dst; dst = dst->next) {
323 last = dst;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700324 dst_ifdown(dst, dev, event != NETDEV_DOWN);
325 }
Eric Dumazet86bba262007-09-12 14:29:01 +0200326
327 spin_lock_bh(&dst_garbage.lock);
328 dst = dst_garbage.list;
329 dst_garbage.list = NULL;
330 spin_unlock_bh(&dst_garbage.lock);
331
332 if (last)
333 last->next = dst;
334 else
335 dst_busy_list = dst;
laurent chavey598ed932010-03-29 10:41:36 +0000336 for (; dst; dst = dst->next)
Eric Dumazet86bba262007-09-12 14:29:01 +0200337 dst_ifdown(dst, dev, event != NETDEV_DOWN);
Eric Dumazet86bba262007-09-12 14:29:01 +0200338 mutex_unlock(&dst_gc_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700339 break;
340 }
341 return NOTIFY_DONE;
342}
343
344static struct notifier_block dst_dev_notifier = {
345 .notifier_call = dst_dev_event,
346};
347
348void __init dst_init(void)
349{
350 register_netdevice_notifier(&dst_dev_notifier);
351}