x86/mm: Initialize 'page_offset_base' at boot-time
[linux/fpc-iii.git] / mm / list_lru.c
blobfd41e969ede520f535dced835cd69e1e74a02951
1 /*
2 * Copyright (c) 2013 Red Hat, Inc. and Parallels Inc. All rights reserved.
3 * Authors: David Chinner and Glauber Costa
5 * Generic LRU infrastructure
6 */
7 #include <linux/kernel.h>
8 #include <linux/module.h>
9 #include <linux/mm.h>
10 #include <linux/list_lru.h>
11 #include <linux/slab.h>
12 #include <linux/mutex.h>
13 #include <linux/memcontrol.h>
15 #if defined(CONFIG_MEMCG) && !defined(CONFIG_SLOB)
16 static LIST_HEAD(list_lrus);
17 static DEFINE_MUTEX(list_lrus_mutex);
19 static void list_lru_register(struct list_lru *lru)
21 mutex_lock(&list_lrus_mutex);
22 list_add(&lru->list, &list_lrus);
23 mutex_unlock(&list_lrus_mutex);
26 static void list_lru_unregister(struct list_lru *lru)
28 mutex_lock(&list_lrus_mutex);
29 list_del(&lru->list);
30 mutex_unlock(&list_lrus_mutex);
32 #else
33 static void list_lru_register(struct list_lru *lru)
37 static void list_lru_unregister(struct list_lru *lru)
40 #endif /* CONFIG_MEMCG && !CONFIG_SLOB */
42 #if defined(CONFIG_MEMCG) && !defined(CONFIG_SLOB)
43 static inline bool list_lru_memcg_aware(struct list_lru *lru)
46 * This needs node 0 to be always present, even
47 * in the systems supporting sparse numa ids.
49 return !!lru->node[0].memcg_lrus;
52 static inline struct list_lru_one *
53 list_lru_from_memcg_idx(struct list_lru_node *nlru, int idx)
56 * The lock protects the array of per cgroup lists from relocation
57 * (see memcg_update_list_lru_node).
59 lockdep_assert_held(&nlru->lock);
60 if (nlru->memcg_lrus && idx >= 0)
61 return nlru->memcg_lrus->lru[idx];
63 return &nlru->lru;
66 static __always_inline struct mem_cgroup *mem_cgroup_from_kmem(void *ptr)
68 struct page *page;
70 if (!memcg_kmem_enabled())
71 return NULL;
72 page = virt_to_head_page(ptr);
73 return page->mem_cgroup;
76 static inline struct list_lru_one *
77 list_lru_from_kmem(struct list_lru_node *nlru, void *ptr)
79 struct mem_cgroup *memcg;
81 if (!nlru->memcg_lrus)
82 return &nlru->lru;
84 memcg = mem_cgroup_from_kmem(ptr);
85 if (!memcg)
86 return &nlru->lru;
88 return list_lru_from_memcg_idx(nlru, memcg_cache_id(memcg));
90 #else
91 static inline bool list_lru_memcg_aware(struct list_lru *lru)
93 return false;
96 static inline struct list_lru_one *
97 list_lru_from_memcg_idx(struct list_lru_node *nlru, int idx)
99 return &nlru->lru;
102 static inline struct list_lru_one *
103 list_lru_from_kmem(struct list_lru_node *nlru, void *ptr)
105 return &nlru->lru;
107 #endif /* CONFIG_MEMCG && !CONFIG_SLOB */
109 bool list_lru_add(struct list_lru *lru, struct list_head *item)
111 int nid = page_to_nid(virt_to_page(item));
112 struct list_lru_node *nlru = &lru->node[nid];
113 struct list_lru_one *l;
115 spin_lock(&nlru->lock);
116 if (list_empty(item)) {
117 l = list_lru_from_kmem(nlru, item);
118 list_add_tail(item, &l->list);
119 l->nr_items++;
120 nlru->nr_items++;
121 spin_unlock(&nlru->lock);
122 return true;
124 spin_unlock(&nlru->lock);
125 return false;
127 EXPORT_SYMBOL_GPL(list_lru_add);
129 bool list_lru_del(struct list_lru *lru, struct list_head *item)
131 int nid = page_to_nid(virt_to_page(item));
132 struct list_lru_node *nlru = &lru->node[nid];
133 struct list_lru_one *l;
135 spin_lock(&nlru->lock);
136 if (!list_empty(item)) {
137 l = list_lru_from_kmem(nlru, item);
138 list_del_init(item);
139 l->nr_items--;
140 nlru->nr_items--;
141 spin_unlock(&nlru->lock);
142 return true;
144 spin_unlock(&nlru->lock);
145 return false;
147 EXPORT_SYMBOL_GPL(list_lru_del);
149 void list_lru_isolate(struct list_lru_one *list, struct list_head *item)
151 list_del_init(item);
152 list->nr_items--;
154 EXPORT_SYMBOL_GPL(list_lru_isolate);
156 void list_lru_isolate_move(struct list_lru_one *list, struct list_head *item,
157 struct list_head *head)
159 list_move(item, head);
160 list->nr_items--;
162 EXPORT_SYMBOL_GPL(list_lru_isolate_move);
164 static unsigned long __list_lru_count_one(struct list_lru *lru,
165 int nid, int memcg_idx)
167 struct list_lru_node *nlru = &lru->node[nid];
168 struct list_lru_one *l;
169 unsigned long count;
171 spin_lock(&nlru->lock);
172 l = list_lru_from_memcg_idx(nlru, memcg_idx);
173 count = l->nr_items;
174 spin_unlock(&nlru->lock);
176 return count;
179 unsigned long list_lru_count_one(struct list_lru *lru,
180 int nid, struct mem_cgroup *memcg)
182 return __list_lru_count_one(lru, nid, memcg_cache_id(memcg));
184 EXPORT_SYMBOL_GPL(list_lru_count_one);
186 unsigned long list_lru_count_node(struct list_lru *lru, int nid)
188 struct list_lru_node *nlru;
190 nlru = &lru->node[nid];
191 return nlru->nr_items;
193 EXPORT_SYMBOL_GPL(list_lru_count_node);
195 static unsigned long
196 __list_lru_walk_one(struct list_lru *lru, int nid, int memcg_idx,
197 list_lru_walk_cb isolate, void *cb_arg,
198 unsigned long *nr_to_walk)
201 struct list_lru_node *nlru = &lru->node[nid];
202 struct list_lru_one *l;
203 struct list_head *item, *n;
204 unsigned long isolated = 0;
206 spin_lock(&nlru->lock);
207 l = list_lru_from_memcg_idx(nlru, memcg_idx);
208 restart:
209 list_for_each_safe(item, n, &l->list) {
210 enum lru_status ret;
213 * decrement nr_to_walk first so that we don't livelock if we
214 * get stuck on large numbesr of LRU_RETRY items
216 if (!*nr_to_walk)
217 break;
218 --*nr_to_walk;
220 ret = isolate(item, l, &nlru->lock, cb_arg);
221 switch (ret) {
222 case LRU_REMOVED_RETRY:
223 assert_spin_locked(&nlru->lock);
224 /* fall through */
225 case LRU_REMOVED:
226 isolated++;
227 nlru->nr_items--;
229 * If the lru lock has been dropped, our list
230 * traversal is now invalid and so we have to
231 * restart from scratch.
233 if (ret == LRU_REMOVED_RETRY)
234 goto restart;
235 break;
236 case LRU_ROTATE:
237 list_move_tail(item, &l->list);
238 break;
239 case LRU_SKIP:
240 break;
241 case LRU_RETRY:
243 * The lru lock has been dropped, our list traversal is
244 * now invalid and so we have to restart from scratch.
246 assert_spin_locked(&nlru->lock);
247 goto restart;
248 default:
249 BUG();
253 spin_unlock(&nlru->lock);
254 return isolated;
257 unsigned long
258 list_lru_walk_one(struct list_lru *lru, int nid, struct mem_cgroup *memcg,
259 list_lru_walk_cb isolate, void *cb_arg,
260 unsigned long *nr_to_walk)
262 return __list_lru_walk_one(lru, nid, memcg_cache_id(memcg),
263 isolate, cb_arg, nr_to_walk);
265 EXPORT_SYMBOL_GPL(list_lru_walk_one);
267 unsigned long list_lru_walk_node(struct list_lru *lru, int nid,
268 list_lru_walk_cb isolate, void *cb_arg,
269 unsigned long *nr_to_walk)
271 long isolated = 0;
272 int memcg_idx;
274 isolated += __list_lru_walk_one(lru, nid, -1, isolate, cb_arg,
275 nr_to_walk);
276 if (*nr_to_walk > 0 && list_lru_memcg_aware(lru)) {
277 for_each_memcg_cache_index(memcg_idx) {
278 isolated += __list_lru_walk_one(lru, nid, memcg_idx,
279 isolate, cb_arg, nr_to_walk);
280 if (*nr_to_walk <= 0)
281 break;
284 return isolated;
286 EXPORT_SYMBOL_GPL(list_lru_walk_node);
288 static void init_one_lru(struct list_lru_one *l)
290 INIT_LIST_HEAD(&l->list);
291 l->nr_items = 0;
294 #if defined(CONFIG_MEMCG) && !defined(CONFIG_SLOB)
295 static void __memcg_destroy_list_lru_node(struct list_lru_memcg *memcg_lrus,
296 int begin, int end)
298 int i;
300 for (i = begin; i < end; i++)
301 kfree(memcg_lrus->lru[i]);
304 static int __memcg_init_list_lru_node(struct list_lru_memcg *memcg_lrus,
305 int begin, int end)
307 int i;
309 for (i = begin; i < end; i++) {
310 struct list_lru_one *l;
312 l = kmalloc(sizeof(struct list_lru_one), GFP_KERNEL);
313 if (!l)
314 goto fail;
316 init_one_lru(l);
317 memcg_lrus->lru[i] = l;
319 return 0;
320 fail:
321 __memcg_destroy_list_lru_node(memcg_lrus, begin, i - 1);
322 return -ENOMEM;
325 static int memcg_init_list_lru_node(struct list_lru_node *nlru)
327 int size = memcg_nr_cache_ids;
329 nlru->memcg_lrus = kvmalloc(size * sizeof(void *), GFP_KERNEL);
330 if (!nlru->memcg_lrus)
331 return -ENOMEM;
333 if (__memcg_init_list_lru_node(nlru->memcg_lrus, 0, size)) {
334 kvfree(nlru->memcg_lrus);
335 return -ENOMEM;
338 return 0;
341 static void memcg_destroy_list_lru_node(struct list_lru_node *nlru)
343 __memcg_destroy_list_lru_node(nlru->memcg_lrus, 0, memcg_nr_cache_ids);
344 kvfree(nlru->memcg_lrus);
347 static int memcg_update_list_lru_node(struct list_lru_node *nlru,
348 int old_size, int new_size)
350 struct list_lru_memcg *old, *new;
352 BUG_ON(old_size > new_size);
354 old = nlru->memcg_lrus;
355 new = kvmalloc(new_size * sizeof(void *), GFP_KERNEL);
356 if (!new)
357 return -ENOMEM;
359 if (__memcg_init_list_lru_node(new, old_size, new_size)) {
360 kvfree(new);
361 return -ENOMEM;
364 memcpy(new, old, old_size * sizeof(void *));
367 * The lock guarantees that we won't race with a reader
368 * (see list_lru_from_memcg_idx).
370 * Since list_lru_{add,del} may be called under an IRQ-safe lock,
371 * we have to use IRQ-safe primitives here to avoid deadlock.
373 spin_lock_irq(&nlru->lock);
374 nlru->memcg_lrus = new;
375 spin_unlock_irq(&nlru->lock);
377 kvfree(old);
378 return 0;
381 static void memcg_cancel_update_list_lru_node(struct list_lru_node *nlru,
382 int old_size, int new_size)
384 /* do not bother shrinking the array back to the old size, because we
385 * cannot handle allocation failures here */
386 __memcg_destroy_list_lru_node(nlru->memcg_lrus, old_size, new_size);
389 static int memcg_init_list_lru(struct list_lru *lru, bool memcg_aware)
391 int i;
393 if (!memcg_aware)
394 return 0;
396 for_each_node(i) {
397 if (memcg_init_list_lru_node(&lru->node[i]))
398 goto fail;
400 return 0;
401 fail:
402 for (i = i - 1; i >= 0; i--) {
403 if (!lru->node[i].memcg_lrus)
404 continue;
405 memcg_destroy_list_lru_node(&lru->node[i]);
407 return -ENOMEM;
410 static void memcg_destroy_list_lru(struct list_lru *lru)
412 int i;
414 if (!list_lru_memcg_aware(lru))
415 return;
417 for_each_node(i)
418 memcg_destroy_list_lru_node(&lru->node[i]);
421 static int memcg_update_list_lru(struct list_lru *lru,
422 int old_size, int new_size)
424 int i;
426 if (!list_lru_memcg_aware(lru))
427 return 0;
429 for_each_node(i) {
430 if (memcg_update_list_lru_node(&lru->node[i],
431 old_size, new_size))
432 goto fail;
434 return 0;
435 fail:
436 for (i = i - 1; i >= 0; i--) {
437 if (!lru->node[i].memcg_lrus)
438 continue;
440 memcg_cancel_update_list_lru_node(&lru->node[i],
441 old_size, new_size);
443 return -ENOMEM;
446 static void memcg_cancel_update_list_lru(struct list_lru *lru,
447 int old_size, int new_size)
449 int i;
451 if (!list_lru_memcg_aware(lru))
452 return;
454 for_each_node(i)
455 memcg_cancel_update_list_lru_node(&lru->node[i],
456 old_size, new_size);
459 int memcg_update_all_list_lrus(int new_size)
461 int ret = 0;
462 struct list_lru *lru;
463 int old_size = memcg_nr_cache_ids;
465 mutex_lock(&list_lrus_mutex);
466 list_for_each_entry(lru, &list_lrus, list) {
467 ret = memcg_update_list_lru(lru, old_size, new_size);
468 if (ret)
469 goto fail;
471 out:
472 mutex_unlock(&list_lrus_mutex);
473 return ret;
474 fail:
475 list_for_each_entry_continue_reverse(lru, &list_lrus, list)
476 memcg_cancel_update_list_lru(lru, old_size, new_size);
477 goto out;
480 static void memcg_drain_list_lru_node(struct list_lru_node *nlru,
481 int src_idx, int dst_idx)
483 struct list_lru_one *src, *dst;
486 * Since list_lru_{add,del} may be called under an IRQ-safe lock,
487 * we have to use IRQ-safe primitives here to avoid deadlock.
489 spin_lock_irq(&nlru->lock);
491 src = list_lru_from_memcg_idx(nlru, src_idx);
492 dst = list_lru_from_memcg_idx(nlru, dst_idx);
494 list_splice_init(&src->list, &dst->list);
495 dst->nr_items += src->nr_items;
496 src->nr_items = 0;
498 spin_unlock_irq(&nlru->lock);
501 static void memcg_drain_list_lru(struct list_lru *lru,
502 int src_idx, int dst_idx)
504 int i;
506 if (!list_lru_memcg_aware(lru))
507 return;
509 for_each_node(i)
510 memcg_drain_list_lru_node(&lru->node[i], src_idx, dst_idx);
513 void memcg_drain_all_list_lrus(int src_idx, int dst_idx)
515 struct list_lru *lru;
517 mutex_lock(&list_lrus_mutex);
518 list_for_each_entry(lru, &list_lrus, list)
519 memcg_drain_list_lru(lru, src_idx, dst_idx);
520 mutex_unlock(&list_lrus_mutex);
522 #else
523 static int memcg_init_list_lru(struct list_lru *lru, bool memcg_aware)
525 return 0;
528 static void memcg_destroy_list_lru(struct list_lru *lru)
531 #endif /* CONFIG_MEMCG && !CONFIG_SLOB */
533 int __list_lru_init(struct list_lru *lru, bool memcg_aware,
534 struct lock_class_key *key)
536 int i;
537 size_t size = sizeof(*lru->node) * nr_node_ids;
538 int err = -ENOMEM;
540 memcg_get_cache_ids();
542 lru->node = kzalloc(size, GFP_KERNEL);
543 if (!lru->node)
544 goto out;
546 for_each_node(i) {
547 spin_lock_init(&lru->node[i].lock);
548 if (key)
549 lockdep_set_class(&lru->node[i].lock, key);
550 init_one_lru(&lru->node[i].lru);
553 err = memcg_init_list_lru(lru, memcg_aware);
554 if (err) {
555 kfree(lru->node);
556 /* Do this so a list_lru_destroy() doesn't crash: */
557 lru->node = NULL;
558 goto out;
561 list_lru_register(lru);
562 out:
563 memcg_put_cache_ids();
564 return err;
566 EXPORT_SYMBOL_GPL(__list_lru_init);
568 void list_lru_destroy(struct list_lru *lru)
570 /* Already destroyed or not yet initialized? */
571 if (!lru->node)
572 return;
574 memcg_get_cache_ids();
576 list_lru_unregister(lru);
578 memcg_destroy_list_lru(lru);
579 kfree(lru->node);
580 lru->node = NULL;
582 memcg_put_cache_ids();
584 EXPORT_SYMBOL_GPL(list_lru_destroy);