inetpeer.c 15 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471
  1. /*
  2. * INETPEER - A storage for permanent information about peers
  3. *
  4. * This source is covered by the GNU GPL, the same as all kernel sources.
  5. *
  6. * Version: $Id: inetpeer.c,v 1.1.1.1 2007/06/12 07:27:14 eyryu Exp $
  7. *
  8. * Authors: Andrey V. Savochkin <saw@msu.ru>
  9. */
  10. #include <linux/module.h>
  11. #include <linux/types.h>
  12. #include <linux/slab.h>
  13. #include <linux/interrupt.h>
  14. #include <linux/spinlock.h>
  15. #include <linux/random.h>
  16. #include <linux/timer.h>
  17. #include <linux/time.h>
  18. #include <linux/kernel.h>
  19. #include <linux/mm.h>
  20. #include <linux/net.h>
  21. #include <net/ip.h>
  22. #include <net/inetpeer.h>
  23. /*
  24. * Theory of operations.
  25. * We keep one entry for each peer IP address. The nodes contains long-living
  26. * information about the peer which doesn't depend on routes.
  27. * At this moment this information consists only of ID field for the next
  28. * outgoing IP packet. This field is incremented with each packet as encoded
  29. * in inet_getid() function (include/net/inetpeer.h).
  30. * At the moment of writing this notes identifier of IP packets is generated
  31. * to be unpredictable using this code only for packets subjected
  32. * (actually or potentially) to defragmentation. I.e. DF packets less than
  33. * PMTU in size uses a constant ID and do not use this code (see
  34. * ip_select_ident() in include/net/ip.h).
  35. *
  36. * Route cache entries hold references to our nodes.
  37. * New cache entries get references via lookup by destination IP address in
  38. * the avl tree. The reference is grabbed only when it's needed i.e. only
  39. * when we try to output IP packet which needs an unpredictable ID (see
  40. * __ip_select_ident() in net/ipv4/route.c).
  41. * Nodes are removed only when reference counter goes to 0.
  42. * When it's happened the node may be removed when a sufficient amount of
  43. * time has been passed since its last use. The less-recently-used entry can
  44. * also be removed if the pool is overloaded i.e. if the total amount of
  45. * entries is greater-or-equal than the threshold.
  46. *
  47. * Node pool is organised as an AVL tree.
  48. * Such an implementation has been chosen not just for fun. It's a way to
  49. * prevent easy and efficient DoS attacks by creating hash collisions. A huge
  50. * amount of long living nodes in a single hash slot would significantly delay
  51. * lookups performed with disabled BHs.
  52. *
  53. * Serialisation issues.
  54. * 1. Nodes may appear in the tree only with the pool write lock held.
  55. * 2. Nodes may disappear from the tree only with the pool write lock held
  56. * AND reference count being 0.
  57. * 3. Nodes appears and disappears from unused node list only under
  58. * "inet_peer_unused_lock".
  59. * 4. Global variable peer_total is modified under the pool lock.
  60. * 5. struct inet_peer fields modification:
  61. * avl_left, avl_right, avl_parent, avl_height: pool lock
  62. * unused_next, unused_prevp: unused node list lock
  63. * refcnt: atomically against modifications on other CPU;
  64. * usually under some other lock to prevent node disappearing
  65. * dtime: unused node list lock
  66. * v4daddr: unchangeable
  67. * ip_id_count: idlock
  68. */
  69. /* Exported for inet_getid inline function. */
  70. DEFINE_SPINLOCK(inet_peer_idlock);
  71. static struct kmem_cache *peer_cachep __read_mostly;
  72. #define node_height(x) x->avl_height
  73. static struct inet_peer peer_fake_node = {
  74. .avl_left = &peer_fake_node,
  75. .avl_right = &peer_fake_node,
  76. .avl_height = 0
  77. };
  78. #define peer_avl_empty (&peer_fake_node)
  79. static struct inet_peer *peer_root = peer_avl_empty;
  80. static DEFINE_RWLOCK(peer_pool_lock);
  81. #define PEER_MAXDEPTH 40 /* sufficient for about 2^27 nodes */
  82. static int peer_total;
  83. /* Exported for sysctl_net_ipv4. */
  84. int inet_peer_threshold = 65536 + 128; /* start to throw entries more
  85. * aggressively at this stage */
  86. int inet_peer_minttl = 120 * HZ; /* TTL under high load: 120 sec */
  87. int inet_peer_maxttl = 10 * 60 * HZ; /* usual time to live: 10 min */
  88. static struct inet_peer *inet_peer_unused_head;
  89. static struct inet_peer **inet_peer_unused_tailp = &inet_peer_unused_head;
  90. static DEFINE_SPINLOCK(inet_peer_unused_lock);
  91. static void peer_check_expire(unsigned long dummy);
  92. static DEFINE_TIMER(peer_periodic_timer, peer_check_expire, 0, 0);
  93. /* Exported for sysctl_net_ipv4. */
  94. int inet_peer_gc_mintime = 10 * HZ,
  95. inet_peer_gc_maxtime = 120 * HZ;
  96. /* Called from ip_output.c:ip_init */
  97. void __init inet_initpeers(void)
  98. {
  99. struct sysinfo si;
  100. /* Use the straight interface to information about memory. */
  101. si_meminfo(&si);
  102. /* The values below were suggested by Alexey Kuznetsov
  103. * <kuznet@ms2.inr.ac.ru>. I don't have any opinion about the values
  104. * myself. --SAW
  105. */
  106. if (si.totalram <= (32768*1024)/PAGE_SIZE)
  107. inet_peer_threshold >>= 1; /* max pool size about 1MB on IA32 */
  108. if (si.totalram <= (16384*1024)/PAGE_SIZE)
  109. inet_peer_threshold >>= 1; /* about 512KB */
  110. if (si.totalram <= (8192*1024)/PAGE_SIZE)
  111. inet_peer_threshold >>= 2; /* about 128KB */
  112. peer_cachep = kmem_cache_create("inet_peer_cache",
  113. sizeof(struct inet_peer),
  114. 0, SLAB_HWCACHE_ALIGN|SLAB_PANIC,
  115. NULL, NULL);
  116. /* All the timers, started at system startup tend
  117. to synchronize. Perturb it a bit.
  118. */
  119. peer_periodic_timer.expires = jiffies
  120. + net_random() % inet_peer_gc_maxtime
  121. + inet_peer_gc_maxtime;
  122. add_timer(&peer_periodic_timer);
  123. }
  124. /* Called with or without local BH being disabled. */
  125. static void unlink_from_unused(struct inet_peer *p)
  126. {
  127. spin_lock_bh(&inet_peer_unused_lock);
  128. if (p->unused_prevp != NULL) {
  129. /* On unused list. */
  130. *p->unused_prevp = p->unused_next;
  131. if (p->unused_next != NULL)
  132. p->unused_next->unused_prevp = p->unused_prevp;
  133. else
  134. inet_peer_unused_tailp = p->unused_prevp;
  135. p->unused_prevp = NULL; /* mark it as removed */
  136. }
  137. spin_unlock_bh(&inet_peer_unused_lock);
  138. }
  139. /* Called with local BH disabled and the pool lock held. */
  140. #define lookup(daddr) \
  141. ({ \
  142. struct inet_peer *u, **v; \
  143. stackptr = stack; \
  144. *stackptr++ = &peer_root; \
  145. for (u = peer_root; u != peer_avl_empty; ) { \
  146. if (daddr == u->v4daddr) \
  147. break; \
  148. if ((__force __u32)daddr < (__force __u32)u->v4daddr) \
  149. v = &u->avl_left; \
  150. else \
  151. v = &u->avl_right; \
  152. *stackptr++ = v; \
  153. u = *v; \
  154. } \
  155. u; \
  156. })
  157. /* Called with local BH disabled and the pool write lock held. */
  158. #define lookup_rightempty(start) \
  159. ({ \
  160. struct inet_peer *u, **v; \
  161. *stackptr++ = &start->avl_left; \
  162. v = &start->avl_left; \
  163. for (u = *v; u->avl_right != peer_avl_empty; ) { \
  164. v = &u->avl_right; \
  165. *stackptr++ = v; \
  166. u = *v; \
  167. } \
  168. u; \
  169. })
  170. /* Called with local BH disabled and the pool write lock held.
  171. * Variable names are the proof of operation correctness.
  172. * Look into mm/map_avl.c for more detail description of the ideas. */
  173. static void peer_avl_rebalance(struct inet_peer **stack[],
  174. struct inet_peer ***stackend)
  175. {
  176. struct inet_peer **nodep, *node, *l, *r;
  177. int lh, rh;
  178. while (stackend > stack) {
  179. nodep = *--stackend;
  180. node = *nodep;
  181. l = node->avl_left;
  182. r = node->avl_right;
  183. lh = node_height(l);
  184. rh = node_height(r);
  185. if (lh > rh + 1) { /* l: RH+2 */
  186. struct inet_peer *ll, *lr, *lrl, *lrr;
  187. int lrh;
  188. ll = l->avl_left;
  189. lr = l->avl_right;
  190. lrh = node_height(lr);
  191. if (lrh <= node_height(ll)) { /* ll: RH+1 */
  192. node->avl_left = lr; /* lr: RH or RH+1 */
  193. node->avl_right = r; /* r: RH */
  194. node->avl_height = lrh + 1; /* RH+1 or RH+2 */
  195. l->avl_left = ll; /* ll: RH+1 */
  196. l->avl_right = node; /* node: RH+1 or RH+2 */
  197. l->avl_height = node->avl_height + 1;
  198. *nodep = l;
  199. } else { /* ll: RH, lr: RH+1 */
  200. lrl = lr->avl_left; /* lrl: RH or RH-1 */
  201. lrr = lr->avl_right; /* lrr: RH or RH-1 */
  202. node->avl_left = lrr; /* lrr: RH or RH-1 */
  203. node->avl_right = r; /* r: RH */
  204. node->avl_height = rh + 1; /* node: RH+1 */
  205. l->avl_left = ll; /* ll: RH */
  206. l->avl_right = lrl; /* lrl: RH or RH-1 */
  207. l->avl_height = rh + 1; /* l: RH+1 */
  208. lr->avl_left = l; /* l: RH+1 */
  209. lr->avl_right = node; /* node: RH+1 */
  210. lr->avl_height = rh + 2;
  211. *nodep = lr;
  212. }
  213. } else if (rh > lh + 1) { /* r: LH+2 */
  214. struct inet_peer *rr, *rl, *rlr, *rll;
  215. int rlh;
  216. rr = r->avl_right;
  217. rl = r->avl_left;
  218. rlh = node_height(rl);
  219. if (rlh <= node_height(rr)) { /* rr: LH+1 */
  220. node->avl_right = rl; /* rl: LH or LH+1 */
  221. node->avl_left = l; /* l: LH */
  222. node->avl_height = rlh + 1; /* LH+1 or LH+2 */
  223. r->avl_right = rr; /* rr: LH+1 */
  224. r->avl_left = node; /* node: LH+1 or LH+2 */
  225. r->avl_height = node->avl_height + 1;
  226. *nodep = r;
  227. } else { /* rr: RH, rl: RH+1 */
  228. rlr = rl->avl_right; /* rlr: LH or LH-1 */
  229. rll = rl->avl_left; /* rll: LH or LH-1 */
  230. node->avl_right = rll; /* rll: LH or LH-1 */
  231. node->avl_left = l; /* l: LH */
  232. node->avl_height = lh + 1; /* node: LH+1 */
  233. r->avl_right = rr; /* rr: LH */
  234. r->avl_left = rlr; /* rlr: LH or LH-1 */
  235. r->avl_height = lh + 1; /* r: LH+1 */
  236. rl->avl_right = r; /* r: LH+1 */
  237. rl->avl_left = node; /* node: LH+1 */
  238. rl->avl_height = lh + 2;
  239. *nodep = rl;
  240. }
  241. } else {
  242. node->avl_height = (lh > rh ? lh : rh) + 1;
  243. }
  244. }
  245. }
  246. /* Called with local BH disabled and the pool write lock held. */
  247. #define link_to_pool(n) \
  248. do { \
  249. n->avl_height = 1; \
  250. n->avl_left = peer_avl_empty; \
  251. n->avl_right = peer_avl_empty; \
  252. **--stackptr = n; \
  253. peer_avl_rebalance(stack, stackptr); \
  254. } while(0)
  255. /* May be called with local BH enabled. */
  256. static void unlink_from_pool(struct inet_peer *p)
  257. {
  258. int do_free;
  259. do_free = 0;
  260. write_lock_bh(&peer_pool_lock);
  261. /* Check the reference counter. It was artificially incremented by 1
  262. * in cleanup() function to prevent sudden disappearing. If the
  263. * reference count is still 1 then the node is referenced only as `p'
  264. * here and from the pool. So under the exclusive pool lock it's safe
  265. * to remove the node and free it later. */
  266. if (atomic_read(&p->refcnt) == 1) {
  267. struct inet_peer **stack[PEER_MAXDEPTH];
  268. struct inet_peer ***stackptr, ***delp;
  269. if (lookup(p->v4daddr) != p)
  270. BUG();
  271. delp = stackptr - 1; /* *delp[0] == p */
  272. if (p->avl_left == peer_avl_empty) {
  273. *delp[0] = p->avl_right;
  274. --stackptr;
  275. } else {
  276. /* look for a node to insert instead of p */
  277. struct inet_peer *t;
  278. t = lookup_rightempty(p);
  279. BUG_ON(*stackptr[-1] != t);
  280. **--stackptr = t->avl_left;
  281. /* t is removed, t->v4daddr > x->v4daddr for any
  282. * x in p->avl_left subtree.
  283. * Put t in the old place of p. */
  284. *delp[0] = t;
  285. t->avl_left = p->avl_left;
  286. t->avl_right = p->avl_right;
  287. t->avl_height = p->avl_height;
  288. BUG_ON(delp[1] != &p->avl_left);
  289. delp[1] = &t->avl_left; /* was &p->avl_left */
  290. }
  291. peer_avl_rebalance(stack, stackptr);
  292. peer_total--;
  293. do_free = 1;
  294. }
  295. write_unlock_bh(&peer_pool_lock);
  296. if (do_free)
  297. kmem_cache_free(peer_cachep, p);
  298. else
  299. /* The node is used again. Decrease the reference counter
  300. * back. The loop "cleanup -> unlink_from_unused
  301. * -> unlink_from_pool -> putpeer -> link_to_unused
  302. * -> cleanup (for the same node)"
  303. * doesn't really exist because the entry will have a
  304. * recent deletion time and will not be cleaned again soon. */
  305. inet_putpeer(p);
  306. }
  307. /* May be called with local BH enabled. */
  308. static int cleanup_once(unsigned long ttl)
  309. {
  310. struct inet_peer *p;
  311. /* Remove the first entry from the list of unused nodes. */
  312. spin_lock_bh(&inet_peer_unused_lock);
  313. p = inet_peer_unused_head;
  314. if (p != NULL) {
  315. __u32 delta = (__u32)jiffies - p->dtime;
  316. if (delta < ttl) {
  317. /* Do not prune fresh entries. */
  318. spin_unlock_bh(&inet_peer_unused_lock);
  319. return -1;
  320. }
  321. inet_peer_unused_head = p->unused_next;
  322. if (p->unused_next != NULL)
  323. p->unused_next->unused_prevp = p->unused_prevp;
  324. else
  325. inet_peer_unused_tailp = p->unused_prevp;
  326. p->unused_prevp = NULL; /* mark as not on the list */
  327. /* Grab an extra reference to prevent node disappearing
  328. * before unlink_from_pool() call. */
  329. atomic_inc(&p->refcnt);
  330. }
  331. spin_unlock_bh(&inet_peer_unused_lock);
  332. if (p == NULL)
  333. /* It means that the total number of USED entries has
  334. * grown over inet_peer_threshold. It shouldn't really
  335. * happen because of entry limits in route cache. */
  336. return -1;
  337. unlink_from_pool(p);
  338. return 0;
  339. }
  340. /* Called with or without local BH being disabled. */
  341. struct inet_peer *inet_getpeer(__be32 daddr, int create)
  342. {
  343. struct inet_peer *p, *n;
  344. struct inet_peer **stack[PEER_MAXDEPTH], ***stackptr;
  345. /* Look up for the address quickly. */
  346. read_lock_bh(&peer_pool_lock);
  347. p = lookup(daddr);
  348. if (p != peer_avl_empty)
  349. atomic_inc(&p->refcnt);
  350. read_unlock_bh(&peer_pool_lock);
  351. if (p != peer_avl_empty) {
  352. /* The existing node has been found. */
  353. /* Remove the entry from unused list if it was there. */
  354. unlink_from_unused(p);
  355. return p;
  356. }
  357. if (!create)
  358. return NULL;
  359. /* Allocate the space outside the locked region. */
  360. n = kmem_cache_alloc(peer_cachep, GFP_ATOMIC);
  361. if (n == NULL)
  362. return NULL;
  363. n->v4daddr = daddr;
  364. atomic_set(&n->refcnt, 1);
  365. atomic_set(&n->rid, 0);
  366. n->ip_id_count = secure_ip_id(daddr);
  367. n->tcp_ts_stamp = 0;
  368. write_lock_bh(&peer_pool_lock);
  369. /* Check if an entry has suddenly appeared. */
  370. p = lookup(daddr);
  371. if (p != peer_avl_empty)
  372. goto out_free;
  373. /* Link the node. */
  374. link_to_pool(n);
  375. n->unused_prevp = NULL; /* not on the list */
  376. peer_total++;
  377. write_unlock_bh(&peer_pool_lock);
  378. if (peer_total >= inet_peer_threshold)
  379. /* Remove one less-recently-used entry. */
  380. cleanup_once(0);
  381. return n;
  382. out_free:
  383. /* The appropriate node is already in the pool. */
  384. atomic_inc(&p->refcnt);
  385. write_unlock_bh(&peer_pool_lock);
  386. /* Remove the entry from unused list if it was there. */
  387. unlink_from_unused(p);
  388. /* Free preallocated the preallocated node. */
  389. kmem_cache_free(peer_cachep, n);
  390. return p;
  391. }
  392. /* Called with local BH disabled. */
  393. static void peer_check_expire(unsigned long dummy)
  394. {
  395. unsigned long now = jiffies;
  396. int ttl;
  397. if (peer_total >= inet_peer_threshold)
  398. ttl = inet_peer_minttl;
  399. else
  400. ttl = inet_peer_maxttl
  401. - (inet_peer_maxttl - inet_peer_minttl) / HZ *
  402. peer_total / inet_peer_threshold * HZ;
  403. while (!cleanup_once(ttl)) {
  404. if (jiffies != now)
  405. break;
  406. }
  407. /* Trigger the timer after inet_peer_gc_mintime .. inet_peer_gc_maxtime
  408. * interval depending on the total number of entries (more entries,
  409. * less interval). */
  410. if (peer_total >= inet_peer_threshold)
  411. peer_periodic_timer.expires = jiffies + inet_peer_gc_mintime;
  412. else
  413. peer_periodic_timer.expires = jiffies
  414. + inet_peer_gc_maxtime
  415. - (inet_peer_gc_maxtime - inet_peer_gc_mintime) / HZ *
  416. peer_total / inet_peer_threshold * HZ;
  417. add_timer(&peer_periodic_timer);
  418. }
  419. void inet_putpeer(struct inet_peer *p)
  420. {
  421. spin_lock_bh(&inet_peer_unused_lock);
  422. if (atomic_dec_and_test(&p->refcnt)) {
  423. p->unused_prevp = inet_peer_unused_tailp;
  424. p->unused_next = NULL;
  425. *inet_peer_unused_tailp = p;
  426. inet_peer_unused_tailp = &p->unused_next;
  427. p->dtime = (__u32)jiffies;
  428. }
  429. spin_unlock_bh(&inet_peer_unused_lock);
  430. }