inetpeer.c 16.8 KB
Newer Older
Linus Torvalds's avatar
Linus Torvalds committed
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19
/*
 *		INETPEER - A storage for permanent information about peers
 *
 *  This source is covered by the GNU GPL, the same as all kernel sources.
 *
 *  Authors:	Andrey V. Savochkin <saw@msu.ru>
 */

#include <linux/module.h>
#include <linux/types.h>
#include <linux/slab.h>
#include <linux/interrupt.h>
#include <linux/spinlock.h>
#include <linux/random.h>
#include <linux/timer.h>
#include <linux/time.h>
#include <linux/kernel.h>
#include <linux/mm.h>
#include <linux/net.h>
20
#include <net/ip.h>
Linus Torvalds's avatar
Linus Torvalds committed
21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53
#include <net/inetpeer.h>

/*
 *  Theory of operations.
 *  We keep one entry for each peer IP address.  The nodes contains long-living
 *  information about the peer which doesn't depend on routes.
 *  At this moment this information consists only of ID field for the next
 *  outgoing IP packet.  This field is incremented with each packet as encoded
 *  in inet_getid() function (include/net/inetpeer.h).
 *  At the moment of writing this notes identifier of IP packets is generated
 *  to be unpredictable using this code only for packets subjected
 *  (actually or potentially) to defragmentation.  I.e. DF packets less than
 *  PMTU in size uses a constant ID and do not use this code (see
 *  ip_select_ident() in include/net/ip.h).
 *
 *  Route cache entries hold references to our nodes.
 *  New cache entries get references via lookup by destination IP address in
 *  the avl tree.  The reference is grabbed only when it's needed i.e. only
 *  when we try to output IP packet which needs an unpredictable ID (see
 *  __ip_select_ident() in net/ipv4/route.c).
 *  Nodes are removed only when reference counter goes to 0.
 *  When it's happened the node may be removed when a sufficient amount of
 *  time has been passed since its last use.  The less-recently-used entry can
 *  also be removed if the pool is overloaded i.e. if the total amount of
 *  entries is greater-or-equal than the threshold.
 *
 *  Node pool is organised as an AVL tree.
 *  Such an implementation has been chosen not just for fun.  It's a way to
 *  prevent easy and efficient DoS attacks by creating hash collisions.  A huge
 *  amount of long living nodes in a single hash slot would significantly delay
 *  lookups performed with disabled BHs.
 *
 *  Serialisation issues.
Eric Dumazet's avatar
Eric Dumazet committed
54 55
 *  1.  Nodes may appear in the tree only with the pool lock held.
 *  2.  Nodes may disappear from the tree only with the pool lock held
Linus Torvalds's avatar
Linus Torvalds committed
56 57 58 59 60 61
 *      AND reference count being 0.
 *  3.  Nodes appears and disappears from unused node list only under
 *      "inet_peer_unused_lock".
 *  4.  Global variable peer_total is modified under the pool lock.
 *  5.  struct inet_peer fields modification:
 *		avl_left, avl_right, avl_parent, avl_height: pool lock
62
 *		unused: unused node list lock
Linus Torvalds's avatar
Linus Torvalds committed
63 64 65 66
 *		refcnt: atomically against modifications on other CPU;
 *		   usually under some other lock to prevent node disappearing
 *		dtime: unused node list lock
 *		v4daddr: unchangeable
67
 *		ip_id_count: atomic value (no lock needed)
Linus Torvalds's avatar
Linus Torvalds committed
68 69
 */

70
static struct kmem_cache *peer_cachep __read_mostly;
Linus Torvalds's avatar
Linus Torvalds committed
71 72

#define node_height(x) x->avl_height
Eric Dumazet's avatar
Eric Dumazet committed
73 74

#define peer_avl_empty ((struct inet_peer *)&peer_fake_node)
Eric Dumazet's avatar
Eric Dumazet committed
75
#define peer_avl_empty_rcu ((struct inet_peer __rcu __force *)&peer_fake_node)
Eric Dumazet's avatar
Eric Dumazet committed
76
static const struct inet_peer peer_fake_node = {
Eric Dumazet's avatar
Eric Dumazet committed
77 78
	.avl_left	= peer_avl_empty_rcu,
	.avl_right	= peer_avl_empty_rcu,
Linus Torvalds's avatar
Linus Torvalds committed
79 80
	.avl_height	= 0
};
Eric Dumazet's avatar
Eric Dumazet committed
81 82

static struct {
Eric Dumazet's avatar
Eric Dumazet committed
83
	struct inet_peer __rcu *root;
Eric Dumazet's avatar
Eric Dumazet committed
84
	spinlock_t	lock;
Eric Dumazet's avatar
Eric Dumazet committed
85 86
	int		total;
} peers = {
Eric Dumazet's avatar
Eric Dumazet committed
87
	.root		= peer_avl_empty_rcu,
Eric Dumazet's avatar
Eric Dumazet committed
88
	.lock		= __SPIN_LOCK_UNLOCKED(peers.lock),
Eric Dumazet's avatar
Eric Dumazet committed
89 90
	.total		= 0,
};
Linus Torvalds's avatar
Linus Torvalds committed
91 92 93
#define PEER_MAXDEPTH 40 /* sufficient for about 2^27 nodes */

/* Exported for sysctl_net_ipv4.  */
Eric Dumazet's avatar
Eric Dumazet committed
94
int inet_peer_threshold __read_mostly = 65536 + 128;	/* start to throw entries more
Linus Torvalds's avatar
Linus Torvalds committed
95
					 * aggressively at this stage */
Eric Dumazet's avatar
Eric Dumazet committed
96 97 98 99
int inet_peer_minttl __read_mostly = 120 * HZ;	/* TTL under high load: 120 sec */
int inet_peer_maxttl __read_mostly = 10 * 60 * HZ;	/* usual time to live: 10 min */
int inet_peer_gc_mintime __read_mostly = 10 * HZ;
int inet_peer_gc_maxtime __read_mostly = 120 * HZ;
Linus Torvalds's avatar
Linus Torvalds committed
100

Eric Dumazet's avatar
Eric Dumazet committed
101 102 103 104 105 106 107
static struct {
	struct list_head	list;
	spinlock_t		lock;
} unused_peers = {
	.list			= LIST_HEAD_INIT(unused_peers.list),
	.lock			= __SPIN_LOCK_UNLOCKED(unused_peers.lock),
};
Linus Torvalds's avatar
Linus Torvalds committed
108 109

static void peer_check_expire(unsigned long dummy);
110
static DEFINE_TIMER(peer_periodic_timer, peer_check_expire, 0, 0);
Linus Torvalds's avatar
Linus Torvalds committed
111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132


/* Called from ip_output.c:ip_init  */
void __init inet_initpeers(void)
{
	struct sysinfo si;

	/* Use the straight interface to information about memory. */
	si_meminfo(&si);
	/* The values below were suggested by Alexey Kuznetsov
	 * <kuznet@ms2.inr.ac.ru>.  I don't have any opinion about the values
	 * myself.  --SAW
	 */
	if (si.totalram <= (32768*1024)/PAGE_SIZE)
		inet_peer_threshold >>= 1; /* max pool size about 1MB on IA32 */
	if (si.totalram <= (16384*1024)/PAGE_SIZE)
		inet_peer_threshold >>= 1; /* about 512KB */
	if (si.totalram <= (8192*1024)/PAGE_SIZE)
		inet_peer_threshold >>= 2; /* about 128KB */

	peer_cachep = kmem_cache_create("inet_peer_cache",
			sizeof(struct inet_peer),
133
			0, SLAB_HWCACHE_ALIGN | SLAB_PANIC,
134
			NULL);
Linus Torvalds's avatar
Linus Torvalds committed
135 136 137 138 139 140 141 142 143 144 145 146 147

	/* All the timers, started at system startup tend
	   to synchronize. Perturb it a bit.
	 */
	peer_periodic_timer.expires = jiffies
		+ net_random() % inet_peer_gc_maxtime
		+ inet_peer_gc_maxtime;
	add_timer(&peer_periodic_timer);
}

/* Called with or without local BH being disabled. */
static void unlink_from_unused(struct inet_peer *p)
{
Eric Dumazet's avatar
Eric Dumazet committed
148 149 150 151 152
	if (!list_empty(&p->unused)) {
		spin_lock_bh(&unused_peers.lock);
		list_del_init(&p->unused);
		spin_unlock_bh(&unused_peers.lock);
	}
Linus Torvalds's avatar
Linus Torvalds committed
153 154
}

Eric Dumazet's avatar
Eric Dumazet committed
155 156 157
/*
 * Called with local BH disabled and the pool lock held.
 */
158
#define lookup(_daddr, _stack) 					\
Linus Torvalds's avatar
Linus Torvalds committed
159
({								\
Eric Dumazet's avatar
Eric Dumazet committed
160 161
	struct inet_peer *u;					\
	struct inet_peer __rcu **v;				\
Eric Dumazet's avatar
Eric Dumazet committed
162 163 164
								\
	stackptr = _stack;					\
	*stackptr++ = &peers.root;				\
Eric Dumazet's avatar
Eric Dumazet committed
165 166 167
	for (u = rcu_dereference_protected(peers.root,		\
			lockdep_is_held(&peers.lock));		\
	     u != peer_avl_empty; ) {				\
Eric Dumazet's avatar
Eric Dumazet committed
168
		if (_daddr == u->v4daddr)			\
Linus Torvalds's avatar
Linus Torvalds committed
169
			break;					\
Eric Dumazet's avatar
Eric Dumazet committed
170
		if ((__force __u32)_daddr < (__force __u32)u->v4daddr)	\
Linus Torvalds's avatar
Linus Torvalds committed
171 172 173
			v = &u->avl_left;			\
		else						\
			v = &u->avl_right;			\
Eric Dumazet's avatar
Eric Dumazet committed
174
		*stackptr++ = v;				\
Eric Dumazet's avatar
Eric Dumazet committed
175 176
		u = rcu_dereference_protected(*v,		\
			lockdep_is_held(&peers.lock));		\
Linus Torvalds's avatar
Linus Torvalds committed
177 178 179 180
	}							\
	u;							\
})

Eric Dumazet's avatar
Eric Dumazet committed
181 182 183 184 185 186 187 188 189 190 191 192 193 194
/*
 * Called with rcu_read_lock_bh()
 * Because we hold no lock against a writer, its quite possible we fall
 * in an endless loop.
 * But every pointer we follow is guaranteed to be valid thanks to RCU.
 * We exit from this function if number of links exceeds PEER_MAXDEPTH
 */
static struct inet_peer *lookup_rcu_bh(__be32 daddr)
{
	struct inet_peer *u = rcu_dereference_bh(peers.root);
	int count = 0;

	while (u != peer_avl_empty) {
		if (daddr == u->v4daddr) {
195 196 197 198 199 200
			/* Before taking a reference, check if this entry was
			 * deleted, unlink_from_pool() sets refcnt=-1 to make
			 * distinction between an unused entry (refcnt=0) and
			 * a freed one.
			 */
			if (unlikely(!atomic_add_unless(&u->refcnt, 1, -1)))
Eric Dumazet's avatar
Eric Dumazet committed
201 202 203 204 205 206 207 208 209 210 211 212 213 214
				u = NULL;
			return u;
		}
		if ((__force __u32)daddr < (__force __u32)u->v4daddr)
			u = rcu_dereference_bh(u->avl_left);
		else
			u = rcu_dereference_bh(u->avl_right);
		if (unlikely(++count == PEER_MAXDEPTH))
			break;
	}
	return NULL;
}

/* Called with local BH disabled and the pool lock held. */
Linus Torvalds's avatar
Linus Torvalds committed
215 216
#define lookup_rightempty(start)				\
({								\
Eric Dumazet's avatar
Eric Dumazet committed
217 218
	struct inet_peer *u;					\
	struct inet_peer __rcu **v;				\
Linus Torvalds's avatar
Linus Torvalds committed
219 220
	*stackptr++ = &start->avl_left;				\
	v = &start->avl_left;					\
Eric Dumazet's avatar
Eric Dumazet committed
221 222 223
	for (u = rcu_dereference_protected(*v,			\
			lockdep_is_held(&peers.lock));		\
	     u->avl_right != peer_avl_empty_rcu; ) {		\
Linus Torvalds's avatar
Linus Torvalds committed
224 225
		v = &u->avl_right;				\
		*stackptr++ = v;				\
Eric Dumazet's avatar
Eric Dumazet committed
226 227
		u = rcu_dereference_protected(*v,		\
			lockdep_is_held(&peers.lock));		\
Linus Torvalds's avatar
Linus Torvalds committed
228 229 230 231
	}							\
	u;							\
})

Eric Dumazet's avatar
Eric Dumazet committed
232
/* Called with local BH disabled and the pool lock held.
Linus Torvalds's avatar
Linus Torvalds committed
233
 * Variable names are the proof of operation correctness.
Eric Dumazet's avatar
Eric Dumazet committed
234 235
 * Look into mm/map_avl.c for more detail description of the ideas.
 */
Eric Dumazet's avatar
Eric Dumazet committed
236 237
static void peer_avl_rebalance(struct inet_peer __rcu **stack[],
		struct inet_peer __rcu ***stackend)
Linus Torvalds's avatar
Linus Torvalds committed
238
{
Eric Dumazet's avatar
Eric Dumazet committed
239 240
	struct inet_peer __rcu **nodep;
	struct inet_peer *node, *l, *r;
Linus Torvalds's avatar
Linus Torvalds committed
241 242 243 244
	int lh, rh;

	while (stackend > stack) {
		nodep = *--stackend;
Eric Dumazet's avatar
Eric Dumazet committed
245 246 247 248 249 250
		node = rcu_dereference_protected(*nodep,
				lockdep_is_held(&peers.lock));
		l = rcu_dereference_protected(node->avl_left,
				lockdep_is_held(&peers.lock));
		r = rcu_dereference_protected(node->avl_right,
				lockdep_is_held(&peers.lock));
Linus Torvalds's avatar
Linus Torvalds committed
251 252 253 254 255
		lh = node_height(l);
		rh = node_height(r);
		if (lh > rh + 1) { /* l: RH+2 */
			struct inet_peer *ll, *lr, *lrl, *lrr;
			int lrh;
Eric Dumazet's avatar
Eric Dumazet committed
256 257 258 259
			ll = rcu_dereference_protected(l->avl_left,
				lockdep_is_held(&peers.lock));
			lr = rcu_dereference_protected(l->avl_right,
				lockdep_is_held(&peers.lock));
Linus Torvalds's avatar
Linus Torvalds committed
260 261
			lrh = node_height(lr);
			if (lrh <= node_height(ll)) {	/* ll: RH+1 */
Eric Dumazet's avatar
Eric Dumazet committed
262 263
				RCU_INIT_POINTER(node->avl_left, lr);	/* lr: RH or RH+1 */
				RCU_INIT_POINTER(node->avl_right, r);	/* r: RH */
Linus Torvalds's avatar
Linus Torvalds committed
264
				node->avl_height = lrh + 1; /* RH+1 or RH+2 */
Eric Dumazet's avatar
Eric Dumazet committed
265 266
				RCU_INIT_POINTER(l->avl_left, ll);       /* ll: RH+1 */
				RCU_INIT_POINTER(l->avl_right, node);	/* node: RH+1 or RH+2 */
Linus Torvalds's avatar
Linus Torvalds committed
267
				l->avl_height = node->avl_height + 1;
Eric Dumazet's avatar
Eric Dumazet committed
268
				RCU_INIT_POINTER(*nodep, l);
Linus Torvalds's avatar
Linus Torvalds committed
269
			} else { /* ll: RH, lr: RH+1 */
Eric Dumazet's avatar
Eric Dumazet committed
270 271 272 273 274 275
				lrl = rcu_dereference_protected(lr->avl_left,
					lockdep_is_held(&peers.lock));	/* lrl: RH or RH-1 */
				lrr = rcu_dereference_protected(lr->avl_right,
					lockdep_is_held(&peers.lock));	/* lrr: RH or RH-1 */
				RCU_INIT_POINTER(node->avl_left, lrr);	/* lrr: RH or RH-1 */
				RCU_INIT_POINTER(node->avl_right, r);	/* r: RH */
Linus Torvalds's avatar
Linus Torvalds committed
276
				node->avl_height = rh + 1; /* node: RH+1 */
Eric Dumazet's avatar
Eric Dumazet committed
277 278
				RCU_INIT_POINTER(l->avl_left, ll);	/* ll: RH */
				RCU_INIT_POINTER(l->avl_right, lrl);	/* lrl: RH or RH-1 */
Linus Torvalds's avatar
Linus Torvalds committed
279
				l->avl_height = rh + 1;	/* l: RH+1 */
Eric Dumazet's avatar
Eric Dumazet committed
280 281
				RCU_INIT_POINTER(lr->avl_left, l);	/* l: RH+1 */
				RCU_INIT_POINTER(lr->avl_right, node);	/* node: RH+1 */
Linus Torvalds's avatar
Linus Torvalds committed
282
				lr->avl_height = rh + 2;
Eric Dumazet's avatar
Eric Dumazet committed
283
				RCU_INIT_POINTER(*nodep, lr);
Linus Torvalds's avatar
Linus Torvalds committed
284 285 286 287
			}
		} else if (rh > lh + 1) { /* r: LH+2 */
			struct inet_peer *rr, *rl, *rlr, *rll;
			int rlh;
Eric Dumazet's avatar
Eric Dumazet committed
288 289 290 291
			rr = rcu_dereference_protected(r->avl_right,
				lockdep_is_held(&peers.lock));
			rl = rcu_dereference_protected(r->avl_left,
				lockdep_is_held(&peers.lock));
Linus Torvalds's avatar
Linus Torvalds committed
292 293
			rlh = node_height(rl);
			if (rlh <= node_height(rr)) {	/* rr: LH+1 */
Eric Dumazet's avatar
Eric Dumazet committed
294 295
				RCU_INIT_POINTER(node->avl_right, rl);	/* rl: LH or LH+1 */
				RCU_INIT_POINTER(node->avl_left, l);	/* l: LH */
Linus Torvalds's avatar
Linus Torvalds committed
296
				node->avl_height = rlh + 1; /* LH+1 or LH+2 */
Eric Dumazet's avatar
Eric Dumazet committed
297 298
				RCU_INIT_POINTER(r->avl_right, rr);	/* rr: LH+1 */
				RCU_INIT_POINTER(r->avl_left, node);	/* node: LH+1 or LH+2 */
Linus Torvalds's avatar
Linus Torvalds committed
299
				r->avl_height = node->avl_height + 1;
Eric Dumazet's avatar
Eric Dumazet committed
300
				RCU_INIT_POINTER(*nodep, r);
Linus Torvalds's avatar
Linus Torvalds committed
301
			} else { /* rr: RH, rl: RH+1 */
Eric Dumazet's avatar
Eric Dumazet committed
302 303 304 305 306 307
				rlr = rcu_dereference_protected(rl->avl_right,
					lockdep_is_held(&peers.lock));	/* rlr: LH or LH-1 */
				rll = rcu_dereference_protected(rl->avl_left,
					lockdep_is_held(&peers.lock));	/* rll: LH or LH-1 */
				RCU_INIT_POINTER(node->avl_right, rll);	/* rll: LH or LH-1 */
				RCU_INIT_POINTER(node->avl_left, l);	/* l: LH */
Linus Torvalds's avatar
Linus Torvalds committed
308
				node->avl_height = lh + 1; /* node: LH+1 */
Eric Dumazet's avatar
Eric Dumazet committed
309 310
				RCU_INIT_POINTER(r->avl_right, rr);	/* rr: LH */
				RCU_INIT_POINTER(r->avl_left, rlr);	/* rlr: LH or LH-1 */
Linus Torvalds's avatar
Linus Torvalds committed
311
				r->avl_height = lh + 1;	/* r: LH+1 */
Eric Dumazet's avatar
Eric Dumazet committed
312 313
				RCU_INIT_POINTER(rl->avl_right, r);	/* r: LH+1 */
				RCU_INIT_POINTER(rl->avl_left, node);	/* node: LH+1 */
Linus Torvalds's avatar
Linus Torvalds committed
314
				rl->avl_height = lh + 2;
Eric Dumazet's avatar
Eric Dumazet committed
315
				RCU_INIT_POINTER(*nodep, rl);
Linus Torvalds's avatar
Linus Torvalds committed
316 317 318 319 320 321 322
			}
		} else {
			node->avl_height = (lh > rh ? lh : rh) + 1;
		}
	}
}

Eric Dumazet's avatar
Eric Dumazet committed
323
/* Called with local BH disabled and the pool lock held. */
Linus Torvalds's avatar
Linus Torvalds committed
324 325 326
#define link_to_pool(n)						\
do {								\
	n->avl_height = 1;					\
Eric Dumazet's avatar
Eric Dumazet committed
327 328 329 330
	n->avl_left = peer_avl_empty_rcu;			\
	n->avl_right = peer_avl_empty_rcu;			\
	/* lockless readers can catch us now */			\
	rcu_assign_pointer(**--stackptr, n);			\
Linus Torvalds's avatar
Linus Torvalds committed
331
	peer_avl_rebalance(stack, stackptr);			\
Eric Dumazet's avatar
Eric Dumazet committed
332
} while (0)
Linus Torvalds's avatar
Linus Torvalds committed
333

Eric Dumazet's avatar
Eric Dumazet committed
334 335 336 337 338
static void inetpeer_free_rcu(struct rcu_head *head)
{
	kmem_cache_free(peer_cachep, container_of(head, struct inet_peer, rcu));
}

Linus Torvalds's avatar
Linus Torvalds committed
339 340 341 342 343 344 345
/* May be called with local BH enabled. */
static void unlink_from_pool(struct inet_peer *p)
{
	int do_free;

	do_free = 0;

Eric Dumazet's avatar
Eric Dumazet committed
346
	spin_lock_bh(&peers.lock);
Linus Torvalds's avatar
Linus Torvalds committed
347
	/* Check the reference counter.  It was artificially incremented by 1
Eric Dumazet's avatar
Eric Dumazet committed
348 349 350
	 * in cleanup() function to prevent sudden disappearing.  If we can
	 * atomically (because of lockless readers) take this last reference,
	 * it's safe to remove the node and free it later.
351
	 * We use refcnt=-1 to alert lockless readers this entry is deleted.
Eric Dumazet's avatar
Eric Dumazet committed
352
	 */
353
	if (atomic_cmpxchg(&p->refcnt, 1, -1) == 1) {
Eric Dumazet's avatar
Eric Dumazet committed
354 355
		struct inet_peer __rcu **stack[PEER_MAXDEPTH];
		struct inet_peer __rcu ***stackptr, ***delp;
Eric Dumazet's avatar
Eric Dumazet committed
356
		if (lookup(p->v4daddr, stack) != p)
Linus Torvalds's avatar
Linus Torvalds committed
357 358
			BUG();
		delp = stackptr - 1; /* *delp[0] == p */
Eric Dumazet's avatar
Eric Dumazet committed
359
		if (p->avl_left == peer_avl_empty_rcu) {
Linus Torvalds's avatar
Linus Torvalds committed
360 361 362 363 364 365
			*delp[0] = p->avl_right;
			--stackptr;
		} else {
			/* look for a node to insert instead of p */
			struct inet_peer *t;
			t = lookup_rightempty(p);
Eric Dumazet's avatar
Eric Dumazet committed
366 367
			BUG_ON(rcu_dereference_protected(*stackptr[-1],
					lockdep_is_held(&peers.lock)) != t);
Linus Torvalds's avatar
Linus Torvalds committed
368 369 370 371
			**--stackptr = t->avl_left;
			/* t is removed, t->v4daddr > x->v4daddr for any
			 * x in p->avl_left subtree.
			 * Put t in the old place of p. */
Eric Dumazet's avatar
Eric Dumazet committed
372
			RCU_INIT_POINTER(*delp[0], t);
Linus Torvalds's avatar
Linus Torvalds committed
373 374 375
			t->avl_left = p->avl_left;
			t->avl_right = p->avl_right;
			t->avl_height = p->avl_height;
376
			BUG_ON(delp[1] != &p->avl_left);
Linus Torvalds's avatar
Linus Torvalds committed
377 378 379
			delp[1] = &t->avl_left; /* was &p->avl_left */
		}
		peer_avl_rebalance(stack, stackptr);
Eric Dumazet's avatar
Eric Dumazet committed
380
		peers.total--;
Linus Torvalds's avatar
Linus Torvalds committed
381 382
		do_free = 1;
	}
Eric Dumazet's avatar
Eric Dumazet committed
383
	spin_unlock_bh(&peers.lock);
Linus Torvalds's avatar
Linus Torvalds committed
384 385

	if (do_free)
Eric Dumazet's avatar
Eric Dumazet committed
386
		call_rcu_bh(&p->rcu, inetpeer_free_rcu);
Linus Torvalds's avatar
Linus Torvalds committed
387 388 389 390 391 392
	else
		/* The node is used again.  Decrease the reference counter
		 * back.  The loop "cleanup -> unlink_from_unused
		 *   -> unlink_from_pool -> putpeer -> link_to_unused
		 *   -> cleanup (for the same node)"
		 * doesn't really exist because the entry will have a
Eric Dumazet's avatar
Eric Dumazet committed
393 394
		 * recent deletion time and will not be cleaned again soon.
		 */
Linus Torvalds's avatar
Linus Torvalds committed
395 396 397 398 399 400
		inet_putpeer(p);
}

/* May be called with local BH enabled. */
static int cleanup_once(unsigned long ttl)
{
401
	struct inet_peer *p = NULL;
Linus Torvalds's avatar
Linus Torvalds committed
402 403

	/* Remove the first entry from the list of unused nodes. */
Eric Dumazet's avatar
Eric Dumazet committed
404 405
	spin_lock_bh(&unused_peers.lock);
	if (!list_empty(&unused_peers.list)) {
406 407
		__u32 delta;

Eric Dumazet's avatar
Eric Dumazet committed
408
		p = list_first_entry(&unused_peers.list, struct inet_peer, unused);
409 410
		delta = (__u32)jiffies - p->dtime;

411
		if (delta < ttl) {
Linus Torvalds's avatar
Linus Torvalds committed
412
			/* Do not prune fresh entries. */
Eric Dumazet's avatar
Eric Dumazet committed
413
			spin_unlock_bh(&unused_peers.lock);
Linus Torvalds's avatar
Linus Torvalds committed
414 415
			return -1;
		}
416 417 418

		list_del_init(&p->unused);

Linus Torvalds's avatar
Linus Torvalds committed
419 420 421 422
		/* Grab an extra reference to prevent node disappearing
		 * before unlink_from_pool() call. */
		atomic_inc(&p->refcnt);
	}
Eric Dumazet's avatar
Eric Dumazet committed
423
	spin_unlock_bh(&unused_peers.lock);
Linus Torvalds's avatar
Linus Torvalds committed
424 425 426 427 428 429 430 431 432 433 434 435

	if (p == NULL)
		/* It means that the total number of USED entries has
		 * grown over inet_peer_threshold.  It shouldn't really
		 * happen because of entry limits in route cache. */
		return -1;

	unlink_from_pool(p);
	return 0;
}

/* Called with or without local BH being disabled. */
Al Viro's avatar
Al Viro committed
436
struct inet_peer *inet_getpeer(__be32 daddr, int create)
Linus Torvalds's avatar
Linus Torvalds committed
437
{
Eric Dumazet's avatar
Eric Dumazet committed
438
	struct inet_peer *p;
Eric Dumazet's avatar
Eric Dumazet committed
439
	struct inet_peer __rcu **stack[PEER_MAXDEPTH], ***stackptr;
Linus Torvalds's avatar
Linus Torvalds committed
440

Eric Dumazet's avatar
Eric Dumazet committed
441 442 443 444 445 446 447 448 449 450 451 452 453 454
	/* Look up for the address quickly, lockless.
	 * Because of a concurrent writer, we might not find an existing entry.
	 */
	rcu_read_lock_bh();
	p = lookup_rcu_bh(daddr);
	rcu_read_unlock_bh();

	if (p) {
		/* The existing node has been found.
		 * Remove the entry from unused list if it was there.
		 */
		unlink_from_unused(p);
		return p;
	}
Linus Torvalds's avatar
Linus Torvalds committed
455

Eric Dumazet's avatar
Eric Dumazet committed
456 457 458 459 460
	/* retry an exact lookup, taking the lock before.
	 * At least, nodes should be hot in our cache.
	 */
	spin_lock_bh(&peers.lock);
	p = lookup(daddr, stack);
Linus Torvalds's avatar
Linus Torvalds committed
461
	if (p != peer_avl_empty) {
Eric Dumazet's avatar
Eric Dumazet committed
462 463
		atomic_inc(&p->refcnt);
		spin_unlock_bh(&peers.lock);
Linus Torvalds's avatar
Linus Torvalds committed
464 465 466 467
		/* Remove the entry from unused list if it was there. */
		unlink_from_unused(p);
		return p;
	}
Eric Dumazet's avatar
Eric Dumazet committed
468 469 470 471 472 473 474 475 476 477 478 479 480 481 482
	p = create ? kmem_cache_alloc(peer_cachep, GFP_ATOMIC) : NULL;
	if (p) {
		p->v4daddr = daddr;
		atomic_set(&p->refcnt, 1);
		atomic_set(&p->rid, 0);
		atomic_set(&p->ip_id_count, secure_ip_id(daddr));
		p->tcp_ts_stamp = 0;
		INIT_LIST_HEAD(&p->unused);


		/* Link the node. */
		link_to_pool(p);
		peers.total++;
	}
	spin_unlock_bh(&peers.lock);
Linus Torvalds's avatar
Linus Torvalds committed
483

Eric Dumazet's avatar
Eric Dumazet committed
484
	if (peers.total >= inet_peer_threshold)
Linus Torvalds's avatar
Linus Torvalds committed
485 486 487 488 489 490 491 492 493
		/* Remove one less-recently-used entry. */
		cleanup_once(0);

	return p;
}

/* Called with local BH disabled. */
static void peer_check_expire(unsigned long dummy)
{
494
	unsigned long now = jiffies;
Linus Torvalds's avatar
Linus Torvalds committed
495 496
	int ttl;

Eric Dumazet's avatar
Eric Dumazet committed
497
	if (peers.total >= inet_peer_threshold)
Linus Torvalds's avatar
Linus Torvalds committed
498 499 500 501
		ttl = inet_peer_minttl;
	else
		ttl = inet_peer_maxttl
				- (inet_peer_maxttl - inet_peer_minttl) / HZ *
Eric Dumazet's avatar
Eric Dumazet committed
502
					peers.total / inet_peer_threshold * HZ;
503 504 505 506
	while (!cleanup_once(ttl)) {
		if (jiffies != now)
			break;
	}
Linus Torvalds's avatar
Linus Torvalds committed
507 508 509 510

	/* Trigger the timer after inet_peer_gc_mintime .. inet_peer_gc_maxtime
	 * interval depending on the total number of entries (more entries,
	 * less interval). */
Eric Dumazet's avatar
Eric Dumazet committed
511
	if (peers.total >= inet_peer_threshold)
512 513 514 515 516
		peer_periodic_timer.expires = jiffies + inet_peer_gc_mintime;
	else
		peer_periodic_timer.expires = jiffies
			+ inet_peer_gc_maxtime
			- (inet_peer_gc_maxtime - inet_peer_gc_mintime) / HZ *
Eric Dumazet's avatar
Eric Dumazet committed
517
				peers.total / inet_peer_threshold * HZ;
Linus Torvalds's avatar
Linus Torvalds committed
518 519
	add_timer(&peer_periodic_timer);
}
520 521 522

void inet_putpeer(struct inet_peer *p)
{
Eric Dumazet's avatar
Eric Dumazet committed
523 524 525 526
	local_bh_disable();

	if (atomic_dec_and_lock(&p->refcnt, &unused_peers.lock)) {
		list_add_tail(&p->unused, &unused_peers.list);
527
		p->dtime = (__u32)jiffies;
Eric Dumazet's avatar
Eric Dumazet committed
528
		spin_unlock(&unused_peers.lock);
529
	}
Eric Dumazet's avatar
Eric Dumazet committed
530 531

	local_bh_enable();
532
}