blob: f307bc18f6a0002a0a1f7d1c2268a8cc260e0805 [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;
47 struct dst_entry *list;
48 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);
Linus Torvalds1da177e2005-04-16 15:20:36 -070055static void ___dst_free(struct dst_entry * dst);
56
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 /*
139 * if the next desired timer is more than 4 seconds in the future
140 * then round the timer to whole seconds
141 */
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,
155 elapsed.tv_sec * USEC_PER_SEC + elapsed.tv_nsec / NSEC_PER_USEC);
156#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700157}
158
Herbert Xu352e5122007-11-13 21:34:06 -0800159int dst_discard(struct sk_buff *skb)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700160{
161 kfree_skb(skb);
162 return 0;
163}
Herbert Xu352e5122007-11-13 21:34:06 -0800164EXPORT_SYMBOL(dst_discard);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700165
166void * dst_alloc(struct dst_ops * ops)
167{
168 struct dst_entry * dst;
169
170 if (ops->gc && atomic_read(&ops->entries) > ops->gc_thresh) {
Daniel Lezcano569d3642008-01-18 03:56:57 -0800171 if (ops->gc(ops))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700172 return NULL;
173 }
Robert P. J. Dayc3762222007-02-10 01:45:03 -0800174 dst = kmem_cache_zalloc(ops->kmem_cachep, GFP_ATOMIC);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700175 if (!dst)
176 return NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700177 atomic_set(&dst->__refcnt, 0);
178 dst->ops = ops;
179 dst->lastuse = jiffies;
180 dst->path = dst;
Denis Chengc4b10102007-06-05 00:06:57 -0700181 dst->input = dst->output = dst_discard;
YOSHIFUJI Hideaki4ec93ed2007-02-09 23:24:36 +0900182#if RT_CACHE_DEBUG >= 2
Linus Torvalds1da177e2005-04-16 15:20:36 -0700183 atomic_inc(&dst_total);
184#endif
185 atomic_inc(&ops->entries);
186 return dst;
187}
188
189static void ___dst_free(struct dst_entry * dst)
190{
191 /* The first case (dev==NULL) is required, when
192 protocol module is unloaded.
193 */
194 if (dst->dev == NULL || !(dst->dev->flags&IFF_UP)) {
Denis Chengc4b10102007-06-05 00:06:57 -0700195 dst->input = dst->output = dst_discard;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700196 }
197 dst->obsolete = 2;
198}
199
200void __dst_free(struct dst_entry * dst)
201{
Eric Dumazet86bba262007-09-12 14:29:01 +0200202 spin_lock_bh(&dst_garbage.lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700203 ___dst_free(dst);
Eric Dumazet86bba262007-09-12 14:29:01 +0200204 dst->next = dst_garbage.list;
205 dst_garbage.list = dst;
206 if (dst_garbage.timer_inc > DST_GC_INC) {
207 dst_garbage.timer_inc = DST_GC_INC;
208 dst_garbage.timer_expires = DST_GC_MIN;
Benjamin Theryf262b592008-09-12 16:16:37 -0700209 cancel_delayed_work(&dst_gc_work);
Eric Dumazet86bba262007-09-12 14:29:01 +0200210 schedule_delayed_work(&dst_gc_work, dst_garbage.timer_expires);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700211 }
Eric Dumazet86bba262007-09-12 14:29:01 +0200212 spin_unlock_bh(&dst_garbage.lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700213}
214
215struct dst_entry *dst_destroy(struct dst_entry * dst)
216{
217 struct dst_entry *child;
218 struct neighbour *neigh;
219 struct hh_cache *hh;
220
221 smp_rmb();
222
223again:
224 neigh = dst->neighbour;
225 hh = dst->hh;
226 child = dst->child;
227
228 dst->hh = NULL;
229 if (hh && atomic_dec_and_test(&hh->hh_refcnt))
230 kfree(hh);
231
232 if (neigh) {
233 dst->neighbour = NULL;
234 neigh_release(neigh);
235 }
236
237 atomic_dec(&dst->ops->entries);
238
239 if (dst->ops->destroy)
240 dst->ops->destroy(dst);
241 if (dst->dev)
242 dev_put(dst->dev);
YOSHIFUJI Hideaki4ec93ed2007-02-09 23:24:36 +0900243#if RT_CACHE_DEBUG >= 2
Linus Torvalds1da177e2005-04-16 15:20:36 -0700244 atomic_dec(&dst_total);
245#endif
246 kmem_cache_free(dst->ops->kmem_cachep, dst);
247
248 dst = child;
249 if (dst) {
Herbert Xu6775cab2005-04-16 15:24:10 -0700250 int nohash = dst->flags & DST_NOHASH;
251
Linus Torvalds1da177e2005-04-16 15:20:36 -0700252 if (atomic_dec_and_test(&dst->__refcnt)) {
253 /* We were real parent of this dst, so kill child. */
Herbert Xu6775cab2005-04-16 15:24:10 -0700254 if (nohash)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700255 goto again;
256 } else {
257 /* Child is still referenced, return it for freeing. */
Herbert Xu6775cab2005-04-16 15:24:10 -0700258 if (nohash)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700259 return dst;
260 /* Child is still in his hash table */
261 }
262 }
263 return NULL;
264}
265
Ilpo Järvinen8d330862008-03-27 17:53:31 -0700266void dst_release(struct dst_entry *dst)
267{
268 if (dst) {
Eric Dumazetef711cf2008-11-14 00:53:54 -0800269 int newrefcnt;
270
Ilpo Järvinen8d330862008-03-27 17:53:31 -0700271 smp_mb__before_atomic_dec();
Eric Dumazetef711cf2008-11-14 00:53:54 -0800272 newrefcnt = atomic_dec_return(&dst->__refcnt);
273 WARN_ON(newrefcnt < 0);
Ilpo Järvinen8d330862008-03-27 17:53:31 -0700274 }
275}
276EXPORT_SYMBOL(dst_release);
277
Linus Torvalds1da177e2005-04-16 15:20:36 -0700278/* Dirty hack. We did it in 2.2 (in __dst_free),
279 * we have _very_ good reasons not to repeat
280 * this mistake in 2.3, but we have no choice
281 * now. _It_ _is_ _explicit_ _deliberate_
282 * _race_ _condition_.
283 *
284 * Commented and originally written by Alexey.
285 */
286static inline void dst_ifdown(struct dst_entry *dst, struct net_device *dev,
287 int unregister)
288{
289 if (dst->ops->ifdown)
290 dst->ops->ifdown(dst, dev, unregister);
291
292 if (dev != dst->dev)
293 return;
294
295 if (!unregister) {
Denis Chengc4b10102007-06-05 00:06:57 -0700296 dst->input = dst->output = dst_discard;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700297 } else {
YOSHIFUJI Hideakic346dca2008-03-25 21:47:49 +0900298 dst->dev = dev_net(dst->dev)->loopback_dev;
Daniel Lezcanode3cb742007-09-25 19:16:28 -0700299 dev_hold(dst->dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700300 dev_put(dev);
301 if (dst->neighbour && dst->neighbour->dev == dev) {
Denis V. Lunev5a3e55d2007-12-07 00:38:10 -0800302 dst->neighbour->dev = dst->dev;
Eric Dumazet64b7d962007-12-11 02:00:30 -0800303 dev_hold(dst->dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700304 dev_put(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700305 }
306 }
307}
308
309static int dst_dev_event(struct notifier_block *this, unsigned long event, void *ptr)
310{
311 struct net_device *dev = ptr;
Eric Dumazet86bba262007-09-12 14:29:01 +0200312 struct dst_entry *dst, *last = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700313
Linus Torvalds1da177e2005-04-16 15:20:36 -0700314 switch (event) {
315 case NETDEV_UNREGISTER:
316 case NETDEV_DOWN:
Eric Dumazet86bba262007-09-12 14:29:01 +0200317 mutex_lock(&dst_gc_mutex);
318 for (dst = dst_busy_list; dst; dst = dst->next) {
319 last = dst;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700320 dst_ifdown(dst, dev, event != NETDEV_DOWN);
321 }
Eric Dumazet86bba262007-09-12 14:29:01 +0200322
323 spin_lock_bh(&dst_garbage.lock);
324 dst = dst_garbage.list;
325 dst_garbage.list = NULL;
326 spin_unlock_bh(&dst_garbage.lock);
327
328 if (last)
329 last->next = dst;
330 else
331 dst_busy_list = dst;
332 for (; dst; dst = dst->next) {
333 dst_ifdown(dst, dev, event != NETDEV_DOWN);
334 }
335 mutex_unlock(&dst_gc_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700336 break;
337 }
338 return NOTIFY_DONE;
339}
340
341static struct notifier_block dst_dev_notifier = {
342 .notifier_call = dst_dev_event,
343};
344
345void __init dst_init(void)
346{
347 register_netdevice_notifier(&dst_dev_notifier);
348}
349
350EXPORT_SYMBOL(__dst_free);
351EXPORT_SYMBOL(dst_alloc);
352EXPORT_SYMBOL(dst_destroy);