mm/list_lru.c

   1 /*
   2  * Copyright (c) 2013 Red Hat, Inc. and Parallels Inc. All rights reserved.
   3  * Authors: David Chinner and Glauber Costa
   4  *
   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>
  14
  15 #if defined(CONFIG_MEMCG) && !defined(CONFIG_SLOB)
  16 static LIST_HEAD(list_lrus);
  17 static DEFINE_MUTEX(list_lrus_mutex);
  18
  19 static void list_lru_register(struct list_lru *lru)
  20 {
  21         mutex_lock(&list_lrus_mutex);
  22         list_add(&lru->list, &list_lrus);
  23         mutex_unlock(&list_lrus_mutex);
  24 }
  25
  26 static void list_lru_unregister(struct list_lru *lru)
  27 {
  28         mutex_lock(&list_lrus_mutex);
  29         list_del(&lru->list);
  30         mutex_unlock(&list_lrus_mutex);
  31 }
  32 #else
  33 static void list_lru_register(struct list_lru *lru)
  34 {
  35 }
  36
  37 static void list_lru_unregister(struct list_lru *lru)
  38 {
  39 }
  40 #endif /* CONFIG_MEMCG && !CONFIG_SLOB */
  41
  42 #if defined(CONFIG_MEMCG) && !defined(CONFIG_SLOB)
  43 static inline bool list_lru_memcg_aware(struct list_lru *lru)
  44 {
  45         /*
  46          * This needs node 0 to be always present, even
  47          * in the systems supporting sparse numa ids.
  48          */
  49         return !!lru->node[0].memcg_lrus;
  50 }
  51
  52 static inline struct list_lru_one *
  53 list_lru_from_memcg_idx(struct list_lru_node *nlru, int idx)
  54 {
  55         struct list_lru_memcg *memcg_lrus;
  56         /*
  57          * Either lock or RCU protects the array of per cgroup lists
  58          * from relocation (see memcg_update_list_lru_node).
  59          */
  60         memcg_lrus = rcu_dereference_check(nlru->memcg_lrus,
  61                                            lockdep_is_held(&nlru->lock));
  62         if (memcg_lrus && idx >= 0)
  63                 return memcg_lrus->lru[idx];
  64         return &nlru->lru;
  65 }
  66
  67 static __always_inline struct mem_cgroup *mem_cgroup_from_kmem(void *ptr)
  68 {
  69         struct page *page;
  70
  71         if (!memcg_kmem_enabled())
  72                 return NULL;
  73         page = virt_to_head_page(ptr);
  74         return page->mem_cgroup;
  75 }
  76
  77 static inline struct list_lru_one *
  78 list_lru_from_kmem(struct list_lru_node *nlru, void *ptr)
  79 {
  80         struct mem_cgroup *memcg;
  81
  82         if (!nlru->memcg_lrus)
  83                 return &nlru->lru;
  84
  85         memcg = mem_cgroup_from_kmem(ptr);
  86         if (!memcg)
  87                 return &nlru->lru;
  88
  89         return list_lru_from_memcg_idx(nlru, memcg_cache_id(memcg));
  90 }
  91 #else
  92 static inline bool list_lru_memcg_aware(struct list_lru *lru)
  93 {
  94         return false;
  95 }
  96
  97 static inline struct list_lru_one *
  98 list_lru_from_memcg_idx(struct list_lru_node *nlru, int idx)
  99 {
 100         return &nlru->lru;
 101 }
 102
 103 static inline struct list_lru_one *
 104 list_lru_from_kmem(struct list_lru_node *nlru, void *ptr)
 105 {
 106         return &nlru->lru;
 107 }
 108 #endif /* CONFIG_MEMCG && !CONFIG_SLOB */
 109
 110 bool list_lru_add(struct list_lru *lru, struct list_head *item)
 111 {
 112         int nid = page_to_nid(virt_to_page(item));
 113         struct list_lru_node *nlru = &lru->node[nid];
 114         struct list_lru_one *l;
 115
 116         spin_lock(&nlru->lock);
 117         if (list_empty(item)) {
 118                 l = list_lru_from_kmem(nlru, item);
 119                 list_add_tail(item, &l->list);
 120                 l->nr_items++;
 121                 nlru->nr_items++;
 122                 spin_unlock(&nlru->lock);
 123                 return true;
 124         }
 125         spin_unlock(&nlru->lock);
 126         return false;
 127 }
 128 EXPORT_SYMBOL_GPL(list_lru_add);
 129
 130 bool list_lru_del(struct list_lru *lru, struct list_head *item)
 131 {
 132         int nid = page_to_nid(virt_to_page(item));
 133         struct list_lru_node *nlru = &lru->node[nid];
 134         struct list_lru_one *l;
 135
 136         spin_lock(&nlru->lock);
 137         if (!list_empty(item)) {
 138                 l = list_lru_from_kmem(nlru, item);
 139                 list_del_init(item);
 140                 l->nr_items--;
 141                 nlru->nr_items--;
 142                 spin_unlock(&nlru->lock);
 143                 return true;
 144         }
 145         spin_unlock(&nlru->lock);
 146         return false;
 147 }
 148 EXPORT_SYMBOL_GPL(list_lru_del);
 149
 150 void list_lru_isolate(struct list_lru_one *list, struct list_head *item)
 151 {
 152         list_del_init(item);
 153         list->nr_items--;
 154 }
 155 EXPORT_SYMBOL_GPL(list_lru_isolate);
 156
 157 void list_lru_isolate_move(struct list_lru_one *list, struct list_head *item,
 158                            struct list_head *head)
 159 {
 160         list_move(item, head);
 161         list->nr_items--;
 162 }
 163 EXPORT_SYMBOL_GPL(list_lru_isolate_move);
 164
 165 unsigned long list_lru_count_one(struct list_lru *lru,
 166                                  int nid, struct mem_cgroup *memcg)
 167 {
 168         struct list_lru_node *nlru = &lru->node[nid];
 169         struct list_lru_one *l;
 170         unsigned long count;
 171
 172         rcu_read_lock();
 173         l = list_lru_from_memcg_idx(nlru, memcg_cache_id(memcg));
 174         count = l->nr_items;
 175         rcu_read_unlock();
 176
 177         return count;
 178 }
 179 EXPORT_SYMBOL_GPL(list_lru_count_one);
 180
 181 unsigned long list_lru_count_node(struct list_lru *lru, int nid)
 182 {
 183         struct list_lru_node *nlru;
 184
 185         nlru = &lru->node[nid];
 186         return nlru->nr_items;
 187 }
 188 EXPORT_SYMBOL_GPL(list_lru_count_node);
 189
 190 static unsigned long
 191 __list_lru_walk_one(struct list_lru *lru, int nid, int memcg_idx,
 192                     list_lru_walk_cb isolate, void *cb_arg,
 193                     unsigned long *nr_to_walk)
 194 {
 195
 196         struct list_lru_node *nlru = &lru->node[nid];
 197         struct list_lru_one *l;
 198         struct list_head *item, *n;
 199         unsigned long isolated = 0;
 200
 201         spin_lock(&nlru->lock);
 202         l = list_lru_from_memcg_idx(nlru, memcg_idx);
 203 restart:
 204         list_for_each_safe(item, n, &l->list) {
 205                 enum lru_status ret;
 206
 207                 /*
 208                  * decrement nr_to_walk first so that we don't livelock if we
 209                  * get stuck on large numbesr of LRU_RETRY items
 210                  */
 211                 if (!*nr_to_walk)
 212                         break;
 213                 --*nr_to_walk;
 214
 215                 ret = isolate(item, l, &nlru->lock, cb_arg);
 216                 switch (ret) {
 217                 case LRU_REMOVED_RETRY:
 218                         assert_spin_locked(&nlru->lock);
 219                         /* fall through */
 220                 case LRU_REMOVED:
 221                         isolated++;
 222                         nlru->nr_items--;
 223                         /*
 224                          * If the lru lock has been dropped, our list
 225                          * traversal is now invalid and so we have to
 226                          * restart from scratch.
 227                          */
 228                         if (ret == LRU_REMOVED_RETRY)
 229                                 goto restart;
 230                         break;
 231                 case LRU_ROTATE:
 232                         list_move_tail(item, &l->list);
 233                         break;
 234                 case LRU_SKIP:
 235                         break;
 236                 case LRU_RETRY:
 237                         /*
 238                          * The lru lock has been dropped, our list traversal is
 239                          * now invalid and so we have to restart from scratch.
 240                          */
 241                         assert_spin_locked(&nlru->lock);
 242                         goto restart;
 243                 default:
 244                         BUG();
 245                 }
 246         }
 247
 248         spin_unlock(&nlru->lock);
 249         return isolated;
 250 }
 251
 252 unsigned long
 253 list_lru_walk_one(struct list_lru *lru, int nid, struct mem_cgroup *memcg,
 254                   list_lru_walk_cb isolate, void *cb_arg,
 255                   unsigned long *nr_to_walk)
 256 {
 257         return __list_lru_walk_one(lru, nid, memcg_cache_id(memcg),
 258                                    isolate, cb_arg, nr_to_walk);
 259 }
 260 EXPORT_SYMBOL_GPL(list_lru_walk_one);
 261
 262 unsigned long list_lru_walk_node(struct list_lru *lru, int nid,
 263                                  list_lru_walk_cb isolate, void *cb_arg,
 264                                  unsigned long *nr_to_walk)
 265 {
 266         long isolated = 0;
 267         int memcg_idx;
 268
 269         isolated += __list_lru_walk_one(lru, nid, -1, isolate, cb_arg,
 270                                         nr_to_walk);
 271         if (*nr_to_walk > 0 && list_lru_memcg_aware(lru)) {
 272                 for_each_memcg_cache_index(memcg_idx) {
 273                         isolated += __list_lru_walk_one(lru, nid, memcg_idx,
 274                                                 isolate, cb_arg, nr_to_walk);
 275                         if (*nr_to_walk <= 0)
 276                                 break;
 277                 }
 278         }
 279         return isolated;
 280 }
 281 EXPORT_SYMBOL_GPL(list_lru_walk_node);
 282
 283 static void init_one_lru(struct list_lru_one *l)
 284 {
 285         INIT_LIST_HEAD(&l->list);
 286         l->nr_items = 0;
 287 }
 288
 289 #if defined(CONFIG_MEMCG) && !defined(CONFIG_SLOB)
 290 static void __memcg_destroy_list_lru_node(struct list_lru_memcg *memcg_lrus,
 291                                           int begin, int end)
 292 {
 293         int i;
 294
 295         for (i = begin; i < end; i++)
 296                 kfree(memcg_lrus->lru[i]);
 297 }
 298
 299 static int __memcg_init_list_lru_node(struct list_lru_memcg *memcg_lrus,
 300                                       int begin, int end)
 301 {
 302         int i;
 303
 304         for (i = begin; i < end; i++) {
 305                 struct list_lru_one *l;
 306
 307                 l = kmalloc(sizeof(struct list_lru_one), GFP_KERNEL);
 308                 if (!l)
 309                         goto fail;
 310
 311                 init_one_lru(l);
 312                 memcg_lrus->lru[i] = l;
 313         }
 314         return 0;
 315 fail:
 316         __memcg_destroy_list_lru_node(memcg_lrus, begin, i - 1);
 317         return -ENOMEM;
 318 }
 319
 320 static int memcg_init_list_lru_node(struct list_lru_node *nlru)
 321 {
 322         struct list_lru_memcg *memcg_lrus;
 323         int size = memcg_nr_cache_ids;
 324
 325         memcg_lrus = kvmalloc(sizeof(*memcg_lrus) +
 326                               size * sizeof(void *), GFP_KERNEL);
 327         if (!memcg_lrus)
 328                 return -ENOMEM;
 329
 330         if (__memcg_init_list_lru_node(memcg_lrus, 0, size)) {
 331                 kvfree(memcg_lrus);
 332                 return -ENOMEM;
 333         }
 334         RCU_INIT_POINTER(nlru->memcg_lrus, memcg_lrus);
 335
 336         return 0;
 337 }
 338
 339 static void memcg_destroy_list_lru_node(struct list_lru_node *nlru)
 340 {
 341         struct list_lru_memcg *memcg_lrus;
 342         /*
 343          * This is called when shrinker has already been unregistered,
 344          * and nobody can use it. So, there is no need to use kvfree_rcu().
 345          */
 346         memcg_lrus = rcu_dereference_protected(nlru->memcg_lrus, true);
 347         __memcg_destroy_list_lru_node(memcg_lrus, 0, memcg_nr_cache_ids);
 348         kvfree(memcg_lrus);
 349 }
 350
 351 static void kvfree_rcu(struct rcu_head *head)
 352 {
 353         struct list_lru_memcg *mlru;
 354
 355         mlru = container_of(head, struct list_lru_memcg, rcu);
 356         kvfree(mlru);
 357 }
 358
 359 static int memcg_update_list_lru_node(struct list_lru_node *nlru,
 360                                       int old_size, int new_size)
 361 {
 362         struct list_lru_memcg *old, *new;
 363
 364         BUG_ON(old_size > new_size);
 365
 366         old = rcu_dereference_protected(nlru->memcg_lrus,
 367                                         lockdep_is_held(&list_lrus_mutex));
 368         new = kvmalloc(sizeof(*new) + new_size * sizeof(void *), GFP_KERNEL);
 369         if (!new)
 370                 return -ENOMEM;
 371
 372         if (__memcg_init_list_lru_node(new, old_size, new_size)) {
 373                 kvfree(new);
 374                 return -ENOMEM;
 375         }
 376
 377         memcpy(&new->lru, &old->lru, old_size * sizeof(void *));
 378
 379         /*
 380          * The locking below allows readers that hold nlru->lock avoid taking
 381          * rcu_read_lock (see list_lru_from_memcg_idx).
 382          *
 383          * Since list_lru_{add,del} may be called under an IRQ-safe lock,
 384          * we have to use IRQ-safe primitives here to avoid deadlock.
 385          */
 386         spin_lock_irq(&nlru->lock);
 387         rcu_assign_pointer(nlru->memcg_lrus, new);
 388         spin_unlock_irq(&nlru->lock);
 389
 390         call_rcu(&old->rcu, kvfree_rcu);
 391         return 0;
 392 }
 393
 394 static void memcg_cancel_update_list_lru_node(struct list_lru_node *nlru,
 395                                               int old_size, int new_size)
 396 {
 397         struct list_lru_memcg *memcg_lrus;
 398
 399         memcg_lrus = rcu_dereference_protected(nlru->memcg_lrus,
 400                                                lockdep_is_held(&list_lrus_mutex));
 401         /* do not bother shrinking the array back to the old size, because we
 402          * cannot handle allocation failures here */
 403         __memcg_destroy_list_lru_node(memcg_lrus, old_size, new_size);
 404 }
 405
 406 static int memcg_init_list_lru(struct list_lru *lru, bool memcg_aware)
 407 {
 408         int i;
 409
 410         if (!memcg_aware)
 411                 return 0;
 412
 413         for_each_node(i) {
 414                 if (memcg_init_list_lru_node(&lru->node[i]))
 415                         goto fail;
 416         }
 417         return 0;
 418 fail:
 419         for (i = i - 1; i >= 0; i--) {
 420                 if (!lru->node[i].memcg_lrus)
 421                         continue;
 422                 memcg_destroy_list_lru_node(&lru->node[i]);
 423         }
 424         return -ENOMEM;
 425 }
 426
 427 static void memcg_destroy_list_lru(struct list_lru *lru)
 428 {
 429         int i;
 430
 431         if (!list_lru_memcg_aware(lru))
 432                 return;
 433
 434         for_each_node(i)
 435                 memcg_destroy_list_lru_node(&lru->node[i]);
 436 }
 437
 438 static int memcg_update_list_lru(struct list_lru *lru,
 439                                  int old_size, int new_size)
 440 {
 441         int i;
 442
 443         if (!list_lru_memcg_aware(lru))
 444                 return 0;
 445
 446         for_each_node(i) {
 447                 if (memcg_update_list_lru_node(&lru->node[i],
 448                                                old_size, new_size))
 449                         goto fail;
 450         }
 451         return 0;
 452 fail:
 453         for (i = i - 1; i >= 0; i--) {
 454                 if (!lru->node[i].memcg_lrus)
 455                         continue;
 456
 457                 memcg_cancel_update_list_lru_node(&lru->node[i],
 458                                                   old_size, new_size);
 459         }
 460         return -ENOMEM;
 461 }
 462
 463 static void memcg_cancel_update_list_lru(struct list_lru *lru,
 464                                          int old_size, int new_size)
 465 {
 466         int i;
 467
 468         if (!list_lru_memcg_aware(lru))
 469                 return;
 470
 471         for_each_node(i)
 472                 memcg_cancel_update_list_lru_node(&lru->node[i],
 473                                                   old_size, new_size);
 474 }
 475
 476 int memcg_update_all_list_lrus(int new_size)
 477 {
 478         int ret = 0;
 479         struct list_lru *lru;
 480         int old_size = memcg_nr_cache_ids;
 481
 482         mutex_lock(&list_lrus_mutex);
 483         list_for_each_entry(lru, &list_lrus, list) {
 484                 ret = memcg_update_list_lru(lru, old_size, new_size);
 485                 if (ret)
 486                         goto fail;
 487         }
 488 out:
 489         mutex_unlock(&list_lrus_mutex);
 490         return ret;
 491 fail:
 492         list_for_each_entry_continue_reverse(lru, &list_lrus, list)
 493                 memcg_cancel_update_list_lru(lru, old_size, new_size);
 494         goto out;
 495 }
 496
 497 static void memcg_drain_list_lru_node(struct list_lru_node *nlru,
 498                                       int src_idx, int dst_idx)
 499 {
 500         struct list_lru_one *src, *dst;
 501
 502         /*
 503          * Since list_lru_{add,del} may be called under an IRQ-safe lock,
 504          * we have to use IRQ-safe primitives here to avoid deadlock.
 505          */
 506         spin_lock_irq(&nlru->lock);
 507
 508         src = list_lru_from_memcg_idx(nlru, src_idx);
 509         dst = list_lru_from_memcg_idx(nlru, dst_idx);
 510
 511         list_splice_init(&src->list, &dst->list);
 512         dst->nr_items += src->nr_items;
 513         src->nr_items = 0;
 514
 515         spin_unlock_irq(&nlru->lock);
 516 }
 517
 518 static void memcg_drain_list_lru(struct list_lru *lru,
 519                                  int src_idx, int dst_idx)
 520 {
 521         int i;
 522
 523         if (!list_lru_memcg_aware(lru))
 524                 return;
 525
 526         for_each_node(i)
 527                 memcg_drain_list_lru_node(&lru->node[i], src_idx, dst_idx);
 528 }
 529
 530 void memcg_drain_all_list_lrus(int src_idx, int dst_idx)
 531 {
 532         struct list_lru *lru;
 533
 534         mutex_lock(&list_lrus_mutex);
 535         list_for_each_entry(lru, &list_lrus, list)
 536                 memcg_drain_list_lru(lru, src_idx, dst_idx);
 537         mutex_unlock(&list_lrus_mutex);
 538 }
 539 #else
 540 static int memcg_init_list_lru(struct list_lru *lru, bool memcg_aware)
 541 {
 542         return 0;
 543 }
 544
 545 static void memcg_destroy_list_lru(struct list_lru *lru)
 546 {
 547 }
 548 #endif /* CONFIG_MEMCG && !CONFIG_SLOB */
 549
 550 int __list_lru_init(struct list_lru *lru, bool memcg_aware,
 551                     struct lock_class_key *key)
 552 {
 553         int i;
 554         size_t size = sizeof(*lru->node) * nr_node_ids;
 555         int err = -ENOMEM;
 556
 557         memcg_get_cache_ids();
 558
 559         lru->node = kzalloc(size, GFP_KERNEL);
 560         if (!lru->node)
 561                 goto out;
 562
 563         for_each_node(i) {
 564                 spin_lock_init(&lru->node[i].lock);
 565                 if (key)
 566                         lockdep_set_class(&lru->node[i].lock, key);
 567                 init_one_lru(&lru->node[i].lru);
 568         }
 569
 570         err = memcg_init_list_lru(lru, memcg_aware);
 571         if (err) {
 572                 kfree(lru->node);
 573                 /* Do this so a list_lru_destroy() doesn't crash: */
 574                 lru->node = NULL;
 575                 goto out;
 576         }
 577
 578         list_lru_register(lru);
 579 out:
 580         memcg_put_cache_ids();
 581         return err;
 582 }
 583 EXPORT_SYMBOL_GPL(__list_lru_init);
 584
 585 void list_lru_destroy(struct list_lru *lru)
 586 {
 587         /* Already destroyed or not yet initialized? */
 588         if (!lru->node)
 589                 return;
 590
 591         memcg_get_cache_ids();
 592
 593         list_lru_unregister(lru);
 594
 595         memcg_destroy_list_lru(lru);
 596         kfree(lru->node);
 597         lru->node = NULL;
 598
 599         memcg_put_cache_ids();
 600 }
 601 EXPORT_SYMBOL_GPL(list_lru_destroy);