mm/memcontrol.c

   1 // SPDX-License-Identifier: GPL-2.0-or-later
   2 /* memcontrol.c - Memory Controller
   3  *
   4  * Copyright IBM Corporation, 2007
   5  * Author Balbir Singh <balbir@linux.vnet.ibm.com>
   6  *
   7  * Copyright 2007 OpenVZ SWsoft Inc
   8  * Author: Pavel Emelianov <xemul@openvz.org>
   9  *
  10  * Memory thresholds
  11  * Copyright (C) 2009 Nokia Corporation
  12  * Author: Kirill A. Shutemov
  13  *
  14  * Kernel Memory Controller
  15  * Copyright (C) 2012 Parallels Inc. and Google Inc.
  16  * Authors: Glauber Costa and Suleiman Souhlal
  17  *
  18  * Native page reclaim
  19  * Charge lifetime sanitation
  20  * Lockless page tracking & accounting
  21  * Unified hierarchy configuration model
  22  * Copyright (C) 2015 Red Hat, Inc., Johannes Weiner
  23  *
  24  * Per memcg lru locking
  25  * Copyright (C) 2020 Alibaba, Inc, Alex Shi
  26  */
  27
  28 #include <linux/page_counter.h>
  29 #include <linux/memcontrol.h>
  30 #include <linux/cgroup.h>
  31 #include <linux/pagewalk.h>
  32 #include <linux/sched/mm.h>
  33 #include <linux/shmem_fs.h>
  34 #include <linux/hugetlb.h>
  35 #include <linux/pagemap.h>
  36 #include <linux/vm_event_item.h>
  37 #include <linux/smp.h>
  38 #include <linux/page-flags.h>
  39 #include <linux/backing-dev.h>
  40 #include <linux/bit_spinlock.h>
  41 #include <linux/rcupdate.h>
  42 #include <linux/limits.h>
  43 #include <linux/export.h>
  44 #include <linux/mutex.h>
  45 #include <linux/rbtree.h>
  46 #include <linux/slab.h>
  47 #include <linux/swap.h>
  48 #include <linux/swapops.h>
  49 #include <linux/spinlock.h>
  50 #include <linux/eventfd.h>
  51 #include <linux/poll.h>
  52 #include <linux/sort.h>
  53 #include <linux/fs.h>
  54 #include <linux/seq_file.h>
  55 #include <linux/vmpressure.h>
  56 #include <linux/mm_inline.h>
  57 #include <linux/swap_cgroup.h>
  58 #include <linux/cpu.h>
  59 #include <linux/oom.h>
  60 #include <linux/lockdep.h>
  61 #include <linux/file.h>
  62 #include <linux/tracehook.h>
  63 #include <linux/psi.h>
  64 #include <linux/seq_buf.h>
  65 #include "internal.h"
  66 #include <net/sock.h>
  67 #include <net/ip.h>
  68 #include "slab.h"
  69
  70 #include <linux/uaccess.h>
  71
  72 #include <trace/events/vmscan.h>
  73
  74 struct cgroup_subsys memory_cgrp_subsys __read_mostly;
  75 EXPORT_SYMBOL(memory_cgrp_subsys);
  76
  77 struct mem_cgroup *root_mem_cgroup __read_mostly;
  78
  79 /* Active memory cgroup to use from an interrupt context */
  80 DEFINE_PER_CPU(struct mem_cgroup *, int_active_memcg);
  81 EXPORT_PER_CPU_SYMBOL_GPL(int_active_memcg);
  82
  83 /* Socket memory accounting disabled? */
  84 static bool cgroup_memory_nosocket __ro_after_init;
  85
  86 /* Kernel memory accounting disabled? */
  87 bool cgroup_memory_nokmem __ro_after_init;
  88
  89 /* Whether the swap controller is active */
  90 #ifdef CONFIG_MEMCG_SWAP
  91 bool cgroup_memory_noswap __ro_after_init;
  92 #else
  93 #define cgroup_memory_noswap            1
  94 #endif
  95
  96 #ifdef CONFIG_CGROUP_WRITEBACK
  97 static DECLARE_WAIT_QUEUE_HEAD(memcg_cgwb_frn_waitq);
  98 #endif
  99
 100 /* Whether legacy memory+swap accounting is active */
 101 static bool do_memsw_account(void)
 102 {
 103         return !cgroup_subsys_on_dfl(memory_cgrp_subsys) && !cgroup_memory_noswap;
 104 }
 105
 106 #define THRESHOLDS_EVENTS_TARGET 128
 107 #define SOFTLIMIT_EVENTS_TARGET 1024
 108
 109 /*
 110  * Cgroups above their limits are maintained in a RB-Tree, independent of
 111  * their hierarchy representation
 112  */
 113
 114 struct mem_cgroup_tree_per_node {
 115         struct rb_root rb_root;
 116         struct rb_node *rb_rightmost;
 117         spinlock_t lock;
 118 };
 119
 120 struct mem_cgroup_tree {
 121         struct mem_cgroup_tree_per_node *rb_tree_per_node[MAX_NUMNODES];
 122 };
 123
 124 static struct mem_cgroup_tree soft_limit_tree __read_mostly;
 125
 126 /* for OOM */
 127 struct mem_cgroup_eventfd_list {
 128         struct list_head list;
 129         struct eventfd_ctx *eventfd;
 130 };
 131
 132 /*
 133  * cgroup_event represents events which userspace want to receive.
 134  */
 135 struct mem_cgroup_event {
 136         /*
 137          * memcg which the event belongs to.
 138          */
 139         struct mem_cgroup *memcg;
 140         /*
 141          * eventfd to signal userspace about the event.
 142          */
 143         struct eventfd_ctx *eventfd;
 144         /*
 145          * Each of these stored in a list by the cgroup.
 146          */
 147         struct list_head list;
 148         /*
 149          * register_event() callback will be used to add new userspace
 150          * waiter for changes related to this event.  Use eventfd_signal()
 151          * on eventfd to send notification to userspace.
 152          */
 153         int (*register_event)(struct mem_cgroup *memcg,
 154                               struct eventfd_ctx *eventfd, const char *args);
 155         /*
 156          * unregister_event() callback will be called when userspace closes
 157          * the eventfd or on cgroup removing.  This callback must be set,
 158          * if you want provide notification functionality.
 159          */
 160         void (*unregister_event)(struct mem_cgroup *memcg,
 161                                  struct eventfd_ctx *eventfd);
 162         /*
 163          * All fields below needed to unregister event when
 164          * userspace closes eventfd.
 165          */
 166         poll_table pt;
 167         wait_queue_head_t *wqh;
 168         wait_queue_entry_t wait;
 169         struct work_struct remove;
 170 };
 171
 172 static void mem_cgroup_threshold(struct mem_cgroup *memcg);
 173 static void mem_cgroup_oom_notify(struct mem_cgroup *memcg);
 174
 175 /* Stuffs for move charges at task migration. */
 176 /*
 177  * Types of charges to be moved.
 178  */
 179 #define MOVE_ANON       0x1U
 180 #define MOVE_FILE       0x2U
 181 #define MOVE_MASK       (MOVE_ANON | MOVE_FILE)
 182
 183 /* "mc" and its members are protected by cgroup_mutex */
 184 static struct move_charge_struct {
 185         spinlock_t        lock; /* for from, to */
 186         struct mm_struct  *mm;
 187         struct mem_cgroup *from;
 188         struct mem_cgroup *to;
 189         unsigned long flags;
 190         unsigned long precharge;
 191         unsigned long moved_charge;
 192         unsigned long moved_swap;
 193         struct task_struct *moving_task;        /* a task moving charges */
 194         wait_queue_head_t waitq;                /* a waitq for other context */
 195 } mc = {
 196         .lock = __SPIN_LOCK_UNLOCKED(mc.lock),
 197         .waitq = __WAIT_QUEUE_HEAD_INITIALIZER(mc.waitq),
 198 };
 199
 200 /*
 201  * Maximum loops in mem_cgroup_hierarchical_reclaim(), used for soft
 202  * limit reclaim to prevent infinite loops, if they ever occur.
 203  */
 204 #define MEM_CGROUP_MAX_RECLAIM_LOOPS            100
 205 #define MEM_CGROUP_MAX_SOFT_LIMIT_RECLAIM_LOOPS 2
 206
 207 /* for encoding cft->private value on file */
 208 enum res_type {
 209         _MEM,
 210         _MEMSWAP,
 211         _OOM_TYPE,
 212         _KMEM,
 213         _TCP,
 214 };
 215
 216 #define MEMFILE_PRIVATE(x, val) ((x) << 16 | (val))
 217 #define MEMFILE_TYPE(val)       ((val) >> 16 & 0xffff)
 218 #define MEMFILE_ATTR(val)       ((val) & 0xffff)
 219 /* Used for OOM notifier */
 220 #define OOM_CONTROL             (0)
 221
 222 /*
 223  * Iteration constructs for visiting all cgroups (under a tree).  If
 224  * loops are exited prematurely (break), mem_cgroup_iter_break() must
 225  * be used for reference counting.
 226  */
 227 #define for_each_mem_cgroup_tree(iter, root)            \
 228         for (iter = mem_cgroup_iter(root, NULL, NULL);  \
 229              iter != NULL;                              \
 230              iter = mem_cgroup_iter(root, iter, NULL))
 231
 232 #define for_each_mem_cgroup(iter)                       \
 233         for (iter = mem_cgroup_iter(NULL, NULL, NULL);  \
 234              iter != NULL;                              \
 235              iter = mem_cgroup_iter(NULL, iter, NULL))
 236
 237 static inline bool task_is_dying(void)
 238 {
 239         return tsk_is_oom_victim(current) || fatal_signal_pending(current) ||
 240                 (current->flags & PF_EXITING);
 241 }
 242
 243 /* Some nice accessors for the vmpressure. */
 244 struct vmpressure *memcg_to_vmpressure(struct mem_cgroup *memcg)
 245 {
 246         if (!memcg)
 247                 memcg = root_mem_cgroup;
 248         return &memcg->vmpressure;
 249 }
 250
 251 struct mem_cgroup *vmpressure_to_memcg(struct vmpressure *vmpr)
 252 {
 253         return container_of(vmpr, struct mem_cgroup, vmpressure);
 254 }
 255
 256 #ifdef CONFIG_MEMCG_KMEM
 257 static DEFINE_SPINLOCK(objcg_lock);
 258
 259 bool mem_cgroup_kmem_disabled(void)
 260 {
 261         return cgroup_memory_nokmem;
 262 }
 263
 264 static void obj_cgroup_uncharge_pages(struct obj_cgroup *objcg,
 265                                       unsigned int nr_pages);
 266
 267 static void obj_cgroup_release(struct percpu_ref *ref)
 268 {
 269         struct obj_cgroup *objcg = container_of(ref, struct obj_cgroup, refcnt);
 270         unsigned int nr_bytes;
 271         unsigned int nr_pages;
 272         unsigned long flags;
 273
 274         /*
 275          * At this point all allocated objects are freed, and
 276          * objcg->nr_charged_bytes can't have an arbitrary byte value.
 277          * However, it can be PAGE_SIZE or (x * PAGE_SIZE).
 278          *
 279          * The following sequence can lead to it:
 280          * 1) CPU0: objcg == stock->cached_objcg
 281          * 2) CPU1: we do a small allocation (e.g. 92 bytes),
 282          *          PAGE_SIZE bytes are charged
 283          * 3) CPU1: a process from another memcg is allocating something,
 284          *          the stock if flushed,
 285          *          objcg->nr_charged_bytes = PAGE_SIZE - 92
 286          * 5) CPU0: we do release this object,
 287          *          92 bytes are added to stock->nr_bytes
 288          * 6) CPU0: stock is flushed,
 289          *          92 bytes are added to objcg->nr_charged_bytes
 290          *
 291          * In the result, nr_charged_bytes == PAGE_SIZE.
 292          * This page will be uncharged in obj_cgroup_release().
 293          */
 294         nr_bytes = atomic_read(&objcg->nr_charged_bytes);
 295         WARN_ON_ONCE(nr_bytes & (PAGE_SIZE - 1));
 296         nr_pages = nr_bytes >> PAGE_SHIFT;
 297
 298         if (nr_pages)
 299                 obj_cgroup_uncharge_pages(objcg, nr_pages);
 300
 301         spin_lock_irqsave(&objcg_lock, flags);
 302         list_del(&objcg->list);
 303         spin_unlock_irqrestore(&objcg_lock, flags);
 304
 305         percpu_ref_exit(ref);
 306         kfree_rcu(objcg, rcu);
 307 }
 308
 309 static struct obj_cgroup *obj_cgroup_alloc(void)
 310 {
 311         struct obj_cgroup *objcg;
 312         int ret;
 313
 314         objcg = kzalloc(sizeof(struct obj_cgroup), GFP_KERNEL);
 315         if (!objcg)
 316                 return NULL;
 317
 318         ret = percpu_ref_init(&objcg->refcnt, obj_cgroup_release, 0,
 319                               GFP_KERNEL);
 320         if (ret) {
 321                 kfree(objcg);
 322                 return NULL;
 323         }
 324         INIT_LIST_HEAD(&objcg->list);
 325         return objcg;
 326 }
 327
 328 static void memcg_reparent_objcgs(struct mem_cgroup *memcg,
 329                                   struct mem_cgroup *parent)
 330 {
 331         struct obj_cgroup *objcg, *iter;
 332
 333         objcg = rcu_replace_pointer(memcg->objcg, NULL, true);
 334
 335         spin_lock_irq(&objcg_lock);
 336
 337         /* 1) Ready to reparent active objcg. */
 338         list_add(&objcg->list, &memcg->objcg_list);
 339         /* 2) Reparent active objcg and already reparented objcgs to parent. */
 340         list_for_each_entry(iter, &memcg->objcg_list, list)
 341                 WRITE_ONCE(iter->memcg, parent);
 342         /* 3) Move already reparented objcgs to the parent's list */
 343         list_splice(&memcg->objcg_list, &parent->objcg_list);
 344
 345         spin_unlock_irq(&objcg_lock);
 346
 347         percpu_ref_kill(&objcg->refcnt);
 348 }
 349
 350 /*
 351  * This will be used as a shrinker list's index.
 352  * The main reason for not using cgroup id for this:
 353  *  this works better in sparse environments, where we have a lot of memcgs,
 354  *  but only a few kmem-limited. Or also, if we have, for instance, 200
 355  *  memcgs, and none but the 200th is kmem-limited, we'd have to have a
 356  *  200 entry array for that.
 357  *
 358  * The current size of the caches array is stored in memcg_nr_cache_ids. It
 359  * will double each time we have to increase it.
 360  */
 361 static DEFINE_IDA(memcg_cache_ida);
 362 int memcg_nr_cache_ids;
 363
 364 /* Protects memcg_nr_cache_ids */
 365 static DECLARE_RWSEM(memcg_cache_ids_sem);
 366
 367 void memcg_get_cache_ids(void)
 368 {
 369         down_read(&memcg_cache_ids_sem);
 370 }
 371
 372 void memcg_put_cache_ids(void)
 373 {
 374         up_read(&memcg_cache_ids_sem);
 375 }
 376
 377 /*
 378  * MIN_SIZE is different than 1, because we would like to avoid going through
 379  * the alloc/free process all the time. In a small machine, 4 kmem-limited
 380  * cgroups is a reasonable guess. In the future, it could be a parameter or
 381  * tunable, but that is strictly not necessary.
 382  *
 383  * MAX_SIZE should be as large as the number of cgrp_ids. Ideally, we could get
 384  * this constant directly from cgroup, but it is understandable that this is
 385  * better kept as an internal representation in cgroup.c. In any case, the
 386  * cgrp_id space is not getting any smaller, and we don't have to necessarily
 387  * increase ours as well if it increases.
 388  */
 389 #define MEMCG_CACHES_MIN_SIZE 4
 390 #define MEMCG_CACHES_MAX_SIZE MEM_CGROUP_ID_MAX
 391
 392 /*
 393  * A lot of the calls to the cache allocation functions are expected to be
 394  * inlined by the compiler. Since the calls to memcg_slab_pre_alloc_hook() are
 395  * conditional to this static branch, we'll have to allow modules that does
 396  * kmem_cache_alloc and the such to see this symbol as well
 397  */
 398 DEFINE_STATIC_KEY_FALSE(memcg_kmem_enabled_key);
 399 EXPORT_SYMBOL(memcg_kmem_enabled_key);
 400 #endif
 401
 402 /**
 403  * mem_cgroup_css_from_page - css of the memcg associated with a page
 404  * @page: page of interest
 405  *
 406  * If memcg is bound to the default hierarchy, css of the memcg associated
 407  * with @page is returned.  The returned css remains associated with @page
 408  * until it is released.
 409  *
 410  * If memcg is bound to a traditional hierarchy, the css of root_mem_cgroup
 411  * is returned.
 412  */
 413 struct cgroup_subsys_state *mem_cgroup_css_from_page(struct page *page)
 414 {
 415         struct mem_cgroup *memcg;
 416
 417         memcg = page_memcg(page);
 418
 419         if (!memcg || !cgroup_subsys_on_dfl(memory_cgrp_subsys))
 420                 memcg = root_mem_cgroup;
 421
 422         return &memcg->css;
 423 }
 424
 425 /**
 426  * page_cgroup_ino - return inode number of the memcg a page is charged to
 427  * @page: the page
 428  *
 429  * Look up the closest online ancestor of the memory cgroup @page is charged to
 430  * and return its inode number or 0 if @page is not charged to any cgroup. It
 431  * is safe to call this function without holding a reference to @page.
 432  *
 433  * Note, this function is inherently racy, because there is nothing to prevent
 434  * the cgroup inode from getting torn down and potentially reallocated a moment
 435  * after page_cgroup_ino() returns, so it only should be used by callers that
 436  * do not care (such as procfs interfaces).
 437  */
 438 ino_t page_cgroup_ino(struct page *page)
 439 {
 440         struct mem_cgroup *memcg;
 441         unsigned long ino = 0;
 442
 443         rcu_read_lock();
 444         memcg = page_memcg_check(page);
 445
 446         while (memcg && !(memcg->css.flags & CSS_ONLINE))
 447                 memcg = parent_mem_cgroup(memcg);
 448         if (memcg)
 449                 ino = cgroup_ino(memcg->css.cgroup);
 450         rcu_read_unlock();
 451         return ino;
 452 }
 453
 454 static struct mem_cgroup_per_node *
 455 mem_cgroup_page_nodeinfo(struct mem_cgroup *memcg, struct page *page)
 456 {
 457         int nid = page_to_nid(page);
 458
 459         return memcg->nodeinfo[nid];
 460 }
 461
 462 static struct mem_cgroup_tree_per_node *
 463 soft_limit_tree_node(int nid)
 464 {
 465         return soft_limit_tree.rb_tree_per_node[nid];
 466 }
 467
 468 static struct mem_cgroup_tree_per_node *
 469 soft_limit_tree_from_page(struct page *page)
 470 {
 471         int nid = page_to_nid(page);
 472
 473         return soft_limit_tree.rb_tree_per_node[nid];
 474 }
 475
 476 static void __mem_cgroup_insert_exceeded(struct mem_cgroup_per_node *mz,
 477                                          struct mem_cgroup_tree_per_node *mctz,
 478                                          unsigned long new_usage_in_excess)
 479 {
 480         struct rb_node **p = &mctz->rb_root.rb_node;
 481         struct rb_node *parent = NULL;
 482         struct mem_cgroup_per_node *mz_node;
 483         bool rightmost = true;
 484
 485         if (mz->on_tree)
 486                 return;
 487
 488         mz->usage_in_excess = new_usage_in_excess;
 489         if (!mz->usage_in_excess)
 490                 return;
 491         while (*p) {
 492                 parent = *p;
 493                 mz_node = rb_entry(parent, struct mem_cgroup_per_node,
 494                                         tree_node);
 495                 if (mz->usage_in_excess < mz_node->usage_in_excess) {
 496                         p = &(*p)->rb_left;
 497                         rightmost = false;
 498                 } else {
 499                         p = &(*p)->rb_right;
 500                 }
 501         }
 502
 503         if (rightmost)
 504                 mctz->rb_rightmost = &mz->tree_node;
 505
 506         rb_link_node(&mz->tree_node, parent, p);
 507         rb_insert_color(&mz->tree_node, &mctz->rb_root);
 508         mz->on_tree = true;
 509 }
 510
 511 static void __mem_cgroup_remove_exceeded(struct mem_cgroup_per_node *mz,
 512                                          struct mem_cgroup_tree_per_node *mctz)
 513 {
 514         if (!mz->on_tree)
 515                 return;
 516
 517         if (&mz->tree_node == mctz->rb_rightmost)
 518                 mctz->rb_rightmost = rb_prev(&mz->tree_node);
 519
 520         rb_erase(&mz->tree_node, &mctz->rb_root);
 521         mz->on_tree = false;
 522 }
 523
 524 static void mem_cgroup_remove_exceeded(struct mem_cgroup_per_node *mz,
 525                                        struct mem_cgroup_tree_per_node *mctz)
 526 {
 527         unsigned long flags;
 528
 529         spin_lock_irqsave(&mctz->lock, flags);
 530         __mem_cgroup_remove_exceeded(mz, mctz);
 531         spin_unlock_irqrestore(&mctz->lock, flags);
 532 }
 533
 534 static unsigned long soft_limit_excess(struct mem_cgroup *memcg)
 535 {
 536         unsigned long nr_pages = page_counter_read(&memcg->memory);
 537         unsigned long soft_limit = READ_ONCE(memcg->soft_limit);
 538         unsigned long excess = 0;
 539
 540         if (nr_pages > soft_limit)
 541                 excess = nr_pages - soft_limit;
 542
 543         return excess;
 544 }
 545
 546 static void mem_cgroup_update_tree(struct mem_cgroup *memcg, struct page *page)
 547 {
 548         unsigned long excess;
 549         struct mem_cgroup_per_node *mz;
 550         struct mem_cgroup_tree_per_node *mctz;
 551
 552         mctz = soft_limit_tree_from_page(page);
 553         if (!mctz)
 554                 return;
 555         /*
 556          * Necessary to update all ancestors when hierarchy is used.
 557          * because their event counter is not touched.
 558          */
 559         for (; memcg; memcg = parent_mem_cgroup(memcg)) {
 560                 mz = mem_cgroup_page_nodeinfo(memcg, page);
 561                 excess = soft_limit_excess(memcg);
 562                 /*
 563                  * We have to update the tree if mz is on RB-tree or
 564                  * mem is over its softlimit.
 565                  */
 566                 if (excess || mz->on_tree) {
 567                         unsigned long flags;
 568
 569                         spin_lock_irqsave(&mctz->lock, flags);
 570                         /* if on-tree, remove it */
 571                         if (mz->on_tree)
 572                                 __mem_cgroup_remove_exceeded(mz, mctz);
 573                         /*
 574                          * Insert again. mz->usage_in_excess will be updated.
 575                          * If excess is 0, no tree ops.
 576                          */
 577                         __mem_cgroup_insert_exceeded(mz, mctz, excess);
 578                         spin_unlock_irqrestore(&mctz->lock, flags);
 579                 }
 580         }
 581 }
 582
 583 static void mem_cgroup_remove_from_trees(struct mem_cgroup *memcg)
 584 {
 585         struct mem_cgroup_tree_per_node *mctz;
 586         struct mem_cgroup_per_node *mz;
 587         int nid;
 588
 589         for_each_node(nid) {
 590                 mz = memcg->nodeinfo[nid];
 591                 mctz = soft_limit_tree_node(nid);
 592                 if (mctz)
 593                         mem_cgroup_remove_exceeded(mz, mctz);
 594         }
 595 }
 596
 597 static struct mem_cgroup_per_node *
 598 __mem_cgroup_largest_soft_limit_node(struct mem_cgroup_tree_per_node *mctz)
 599 {
 600         struct mem_cgroup_per_node *mz;
 601
 602 retry:
 603         mz = NULL;
 604         if (!mctz->rb_rightmost)
 605                 goto done;              /* Nothing to reclaim from */
 606
 607         mz = rb_entry(mctz->rb_rightmost,
 608                       struct mem_cgroup_per_node, tree_node);
 609         /*
 610          * Remove the node now but someone else can add it back,
 611          * we will to add it back at the end of reclaim to its correct
 612          * position in the tree.
 613          */
 614         __mem_cgroup_remove_exceeded(mz, mctz);
 615         if (!soft_limit_excess(mz->memcg) ||
 616             !css_tryget(&mz->memcg->css))
 617                 goto retry;
 618 done:
 619         return mz;
 620 }
 621
 622 static struct mem_cgroup_per_node *
 623 mem_cgroup_largest_soft_limit_node(struct mem_cgroup_tree_per_node *mctz)
 624 {
 625         struct mem_cgroup_per_node *mz;
 626
 627         spin_lock_irq(&mctz->lock);
 628         mz = __mem_cgroup_largest_soft_limit_node(mctz);
 629         spin_unlock_irq(&mctz->lock);
 630         return mz;
 631 }
 632
 633 /*
 634  * memcg and lruvec stats flushing
 635  *
 636  * Many codepaths leading to stats update or read are performance sensitive and
 637  * adding stats flushing in such codepaths is not desirable. So, to optimize the
 638  * flushing the kernel does:
 639  *
 640  * 1) Periodically and asynchronously flush the stats every 2 seconds to not let
 641  *    rstat update tree grow unbounded.
 642  *
 643  * 2) Flush the stats synchronously on reader side only when there are more than
 644  *    (MEMCG_CHARGE_BATCH * nr_cpus) update events. Though this optimization
 645  *    will let stats be out of sync by atmost (MEMCG_CHARGE_BATCH * nr_cpus) but
 646  *    only for 2 seconds due to (1).
 647  */
 648 static void flush_memcg_stats_dwork(struct work_struct *w);
 649 static DECLARE_DEFERRABLE_WORK(stats_flush_dwork, flush_memcg_stats_dwork);
 650 static DEFINE_SPINLOCK(stats_flush_lock);
 651 static DEFINE_PER_CPU(unsigned int, stats_updates);
 652 static atomic_t stats_flush_threshold = ATOMIC_INIT(0);
 653 static u64 flush_next_time;
 654
 655 #define FLUSH_TIME (2UL*HZ)
 656
 657 /*
 658  * Accessors to ensure that preemption is disabled on PREEMPT_RT because it can
 659  * not rely on this as part of an acquired spinlock_t lock. These functions are
 660  * never used in hardirq context on PREEMPT_RT and therefore disabling preemtion
 661  * is sufficient.
 662  */
 663 static void memcg_stats_lock(void)
 664 {
 665 #ifdef CONFIG_PREEMPT_RT
 666       preempt_disable();
 667 #else
 668       VM_BUG_ON(!irqs_disabled());
 669 #endif
 670 }
 671
 672 static void __memcg_stats_lock(void)
 673 {
 674 #ifdef CONFIG_PREEMPT_RT
 675       preempt_disable();
 676 #endif
 677 }
 678
 679 static void memcg_stats_unlock(void)
 680 {
 681 #ifdef CONFIG_PREEMPT_RT
 682       preempt_enable();
 683 #endif
 684 }
 685
 686 static inline void memcg_rstat_updated(struct mem_cgroup *memcg, int val)
 687 {
 688         unsigned int x;
 689
 690         cgroup_rstat_updated(memcg->css.cgroup, smp_processor_id());
 691
 692         x = __this_cpu_add_return(stats_updates, abs(val));
 693         if (x > MEMCG_CHARGE_BATCH) {
 694                 atomic_add(x / MEMCG_CHARGE_BATCH, &stats_flush_threshold);
 695                 __this_cpu_write(stats_updates, 0);
 696         }
 697 }
 698
 699 static void __mem_cgroup_flush_stats(void)
 700 {
 701         unsigned long flag;
 702
 703         if (!spin_trylock_irqsave(&stats_flush_lock, flag))
 704                 return;
 705
 706         flush_next_time = jiffies_64 + 2*FLUSH_TIME;
 707         cgroup_rstat_flush_irqsafe(root_mem_cgroup->css.cgroup);
 708         atomic_set(&stats_flush_threshold, 0);
 709         spin_unlock_irqrestore(&stats_flush_lock, flag);
 710 }
 711
 712 void mem_cgroup_flush_stats(void)
 713 {
 714         if (atomic_read(&stats_flush_threshold) > num_online_cpus())
 715                 __mem_cgroup_flush_stats();
 716 }
 717
 718 void mem_cgroup_flush_stats_delayed(void)
 719 {
 720         if (time_after64(jiffies_64, flush_next_time))
 721                 mem_cgroup_flush_stats();
 722 }
 723
 724 static void flush_memcg_stats_dwork(struct work_struct *w)
 725 {
 726         __mem_cgroup_flush_stats();
 727         queue_delayed_work(system_unbound_wq, &stats_flush_dwork, FLUSH_TIME);
 728 }
 729
 730 /**
 731  * __mod_memcg_state - update cgroup memory statistics
 732  * @memcg: the memory cgroup
 733  * @idx: the stat item - can be enum memcg_stat_item or enum node_stat_item
 734  * @val: delta to add to the counter, can be negative
 735  */
 736 void __mod_memcg_state(struct mem_cgroup *memcg, int idx, int val)
 737 {
 738         if (mem_cgroup_disabled())
 739                 return;
 740
 741         __this_cpu_add(memcg->vmstats_percpu->state[idx], val);
 742         memcg_rstat_updated(memcg, val);
 743 }
 744
 745 /* idx can be of type enum memcg_stat_item or node_stat_item. */
 746 static unsigned long memcg_page_state_local(struct mem_cgroup *memcg, int idx)
 747 {
 748         long x = 0;
 749         int cpu;
 750
 751         for_each_possible_cpu(cpu)
 752                 x += per_cpu(memcg->vmstats_percpu->state[idx], cpu);
 753 #ifdef CONFIG_SMP
 754         if (x < 0)
 755                 x = 0;
 756 #endif
 757         return x;
 758 }
 759
 760 void __mod_memcg_lruvec_state(struct lruvec *lruvec, enum node_stat_item idx,
 761                               int val)
 762 {
 763         struct mem_cgroup_per_node *pn;
 764         struct mem_cgroup *memcg;
 765
 766         pn = container_of(lruvec, struct mem_cgroup_per_node, lruvec);
 767         memcg = pn->memcg;
 768
 769         /*
 770          * The caller from rmap relay on disabled preemption becase they never
 771          * update their counter from in-interrupt context. For these two
 772          * counters we check that the update is never performed from an
 773          * interrupt context while other caller need to have disabled interrupt.
 774          */
 775         __memcg_stats_lock();
 776         if (IS_ENABLED(CONFIG_DEBUG_VM) && !IS_ENABLED(CONFIG_PREEMPT_RT)) {
 777                 switch (idx) {
 778                 case NR_ANON_MAPPED:
 779                 case NR_FILE_MAPPED:
 780                 case NR_ANON_THPS:
 781                 case NR_SHMEM_PMDMAPPED:
 782                 case NR_FILE_PMDMAPPED:
 783                         WARN_ON_ONCE(!in_task());
 784                         break;
 785                 default:
 786                         WARN_ON_ONCE(!irqs_disabled());
 787                 }
 788         }
 789
 790         /* Update memcg */
 791         __this_cpu_add(memcg->vmstats_percpu->state[idx], val);
 792
 793         /* Update lruvec */
 794         __this_cpu_add(pn->lruvec_stats_percpu->state[idx], val);
 795
 796         memcg_rstat_updated(memcg, val);
 797         memcg_stats_unlock();
 798 }
 799
 800 /**
 801  * __mod_lruvec_state - update lruvec memory statistics
 802  * @lruvec: the lruvec
 803  * @idx: the stat item
 804  * @val: delta to add to the counter, can be negative
 805  *
 806  * The lruvec is the intersection of the NUMA node and a cgroup. This
 807  * function updates the all three counters that are affected by a
 808  * change of state at this level: per-node, per-cgroup, per-lruvec.
 809  */
 810 void __mod_lruvec_state(struct lruvec *lruvec, enum node_stat_item idx,
 811                         int val)
 812 {
 813         /* Update node */
 814         __mod_node_page_state(lruvec_pgdat(lruvec), idx, val);
 815
 816         /* Update memcg and lruvec */
 817         if (!mem_cgroup_disabled())
 818                 __mod_memcg_lruvec_state(lruvec, idx, val);
 819 }
 820
 821 void __mod_lruvec_page_state(struct page *page, enum node_stat_item idx,
 822                              int val)
 823 {
 824         struct page *head = compound_head(page); /* rmap on tail pages */
 825         struct mem_cgroup *memcg;
 826         pg_data_t *pgdat = page_pgdat(page);
 827         struct lruvec *lruvec;
 828
 829         rcu_read_lock();
 830         memcg = page_memcg(head);
 831         /* Untracked pages have no memcg, no lruvec. Update only the node */
 832         if (!memcg) {
 833                 rcu_read_unlock();
 834                 __mod_node_page_state(pgdat, idx, val);
 835                 return;
 836         }
 837
 838         lruvec = mem_cgroup_lruvec(memcg, pgdat);
 839         __mod_lruvec_state(lruvec, idx, val);
 840         rcu_read_unlock();
 841 }
 842 EXPORT_SYMBOL(__mod_lruvec_page_state);
 843
 844 void __mod_lruvec_kmem_state(void *p, enum node_stat_item idx, int val)
 845 {
 846         pg_data_t *pgdat = page_pgdat(virt_to_page(p));
 847         struct mem_cgroup *memcg;
 848         struct lruvec *lruvec;
 849
 850         rcu_read_lock();
 851         memcg = mem_cgroup_from_obj(p);
 852
 853         /*
 854          * Untracked pages have no memcg, no lruvec. Update only the
 855          * node. If we reparent the slab objects to the root memcg,
 856          * when we free the slab object, we need to update the per-memcg
 857          * vmstats to keep it correct for the root memcg.
 858          */
 859         if (!memcg) {
 860                 __mod_node_page_state(pgdat, idx, val);
 861         } else {
 862                 lruvec = mem_cgroup_lruvec(memcg, pgdat);
 863                 __mod_lruvec_state(lruvec, idx, val);
 864         }
 865         rcu_read_unlock();
 866 }
 867
 868 /*
 869  * mod_objcg_mlstate() may be called with irq enabled, so
 870  * mod_memcg_lruvec_state() should be used.
 871  */
 872 static inline void mod_objcg_mlstate(struct obj_cgroup *objcg,
 873                                      struct pglist_data *pgdat,
 874                                      enum node_stat_item idx, int nr)
 875 {
 876         struct mem_cgroup *memcg;
 877         struct lruvec *lruvec;
 878
 879         rcu_read_lock();
 880         memcg = obj_cgroup_memcg(objcg);
 881         lruvec = mem_cgroup_lruvec(memcg, pgdat);
 882         mod_memcg_lruvec_state(lruvec, idx, nr);
 883         rcu_read_unlock();
 884 }
 885
 886 /**
 887  * __count_memcg_events - account VM events in a cgroup
 888  * @memcg: the memory cgroup
 889  * @idx: the event item
 890  * @count: the number of events that occurred
 891  */
 892 void __count_memcg_events(struct mem_cgroup *memcg, enum vm_event_item idx,
 893                           unsigned long count)
 894 {
 895         if (mem_cgroup_disabled())
 896                 return;
 897
 898         memcg_stats_lock();
 899         __this_cpu_add(memcg->vmstats_percpu->events[idx], count);
 900         memcg_rstat_updated(memcg, count);
 901         memcg_stats_unlock();
 902 }
 903
 904 static unsigned long memcg_events(struct mem_cgroup *memcg, int event)
 905 {
 906         return READ_ONCE(memcg->vmstats.events[event]);
 907 }
 908
 909 static unsigned long memcg_events_local(struct mem_cgroup *memcg, int event)
 910 {
 911         long x = 0;
 912         int cpu;
 913
 914         for_each_possible_cpu(cpu)
 915                 x += per_cpu(memcg->vmstats_percpu->events[event], cpu);
 916         return x;
 917 }
 918
 919 static void mem_cgroup_charge_statistics(struct mem_cgroup *memcg,
 920                                          struct page *page,
 921                                          int nr_pages)
 922 {
 923         /* pagein of a big page is an event. So, ignore page size */
 924         if (nr_pages > 0)
 925                 __count_memcg_events(memcg, PGPGIN, 1);
 926         else {
 927                 __count_memcg_events(memcg, PGPGOUT, 1);
 928                 nr_pages = -nr_pages; /* for event */
 929         }
 930
 931         __this_cpu_add(memcg->vmstats_percpu->nr_page_events, nr_pages);
 932 }
 933
 934 static bool mem_cgroup_event_ratelimit(struct mem_cgroup *memcg,
 935                                        enum mem_cgroup_events_target target)
 936 {
 937         unsigned long val, next;
 938
 939         val = __this_cpu_read(memcg->vmstats_percpu->nr_page_events);
 940         next = __this_cpu_read(memcg->vmstats_percpu->targets[target]);
 941         /* from time_after() in jiffies.h */
 942         if ((long)(next - val) < 0) {
 943                 switch (target) {
 944                 case MEM_CGROUP_TARGET_THRESH:
 945                         next = val + THRESHOLDS_EVENTS_TARGET;
 946                         break;
 947                 case MEM_CGROUP_TARGET_SOFTLIMIT:
 948                         next = val + SOFTLIMIT_EVENTS_TARGET;
 949                         break;
 950                 default:
 951                         break;
 952                 }
 953                 __this_cpu_write(memcg->vmstats_percpu->targets[target], next);
 954                 return true;
 955         }
 956         return false;
 957 }
 958
 959 /*
 960  * Check events in order.
 961  *
 962  */
 963 static void memcg_check_events(struct mem_cgroup *memcg, struct page *page)
 964 {
 965         if (IS_ENABLED(CONFIG_PREEMPT_RT))
 966                 return;
 967
 968         /* threshold event is triggered in finer grain than soft limit */
 969         if (unlikely(mem_cgroup_event_ratelimit(memcg,
 970                                                 MEM_CGROUP_TARGET_THRESH))) {
 971                 bool do_softlimit;
 972
 973                 do_softlimit = mem_cgroup_event_ratelimit(memcg,
 974                                                 MEM_CGROUP_TARGET_SOFTLIMIT);
 975                 mem_cgroup_threshold(memcg);
 976                 if (unlikely(do_softlimit))
 977                         mem_cgroup_update_tree(memcg, page);
 978         }
 979 }
 980
 981 struct mem_cgroup *mem_cgroup_from_task(struct task_struct *p)
 982 {
 983         /*
 984          * mm_update_next_owner() may clear mm->owner to NULL
 985          * if it races with swapoff, page migration, etc.
 986          * So this can be called with p == NULL.
 987          */
 988         if (unlikely(!p))
 989                 return NULL;
 990
 991         return mem_cgroup_from_css(task_css(p, memory_cgrp_id));
 992 }
 993 EXPORT_SYMBOL(mem_cgroup_from_task);
 994
 995 static __always_inline struct mem_cgroup *active_memcg(void)
 996 {
 997         if (!in_task())
 998                 return this_cpu_read(int_active_memcg);
 999         else
1000                 return current->active_memcg;
1001 }
1002
1003 /**
1004  * get_mem_cgroup_from_mm: Obtain a reference on given mm_struct's memcg.
1005  * @mm: mm from which memcg should be extracted. It can be NULL.
1006  *
1007  * Obtain a reference on mm->memcg and returns it if successful. If mm
1008  * is NULL, then the memcg is chosen as follows:
1009  * 1) The active memcg, if set.
1010  * 2) current->mm->memcg, if available
1011  * 3) root memcg
1012  * If mem_cgroup is disabled, NULL is returned.
1013  */
1014 struct mem_cgroup *get_mem_cgroup_from_mm(struct mm_struct *mm)
1015 {
1016         struct mem_cgroup *memcg;
1017
1018         if (mem_cgroup_disabled())
1019                 return NULL;
1020
1021         /*
1022          * Page cache insertions can happen without an
1023          * actual mm context, e.g. during disk probing
1024          * on boot, loopback IO, acct() writes etc.
1025          *
1026          * No need to css_get on root memcg as the reference
1027          * counting is disabled on the root level in the
1028          * cgroup core. See CSS_NO_REF.
1029          */
1030         if (unlikely(!mm)) {
1031                 memcg = active_memcg();
1032                 if (unlikely(memcg)) {
1033                         /* remote memcg must hold a ref */
1034                         css_get(&memcg->css);
1035                         return memcg;
1036                 }
1037                 mm = current->mm;
1038                 if (unlikely(!mm))
1039                         return root_mem_cgroup;
1040         }
1041
1042         rcu_read_lock();
1043         do {
1044                 memcg = mem_cgroup_from_task(rcu_dereference(mm->owner));
1045                 if (unlikely(!memcg))
1046                         memcg = root_mem_cgroup;
1047         } while (!css_tryget(&memcg->css));
1048         rcu_read_unlock();
1049         return memcg;
1050 }
1051 EXPORT_SYMBOL(get_mem_cgroup_from_mm);
1052
1053 static __always_inline bool memcg_kmem_bypass(void)
1054 {
1055         /* Allow remote memcg charging from any context. */
1056         if (unlikely(active_memcg()))
1057                 return false;
1058
1059         /* Memcg to charge can't be determined. */
1060         if (!in_task() || !current->mm || (current->flags & PF_KTHREAD))
1061                 return true;
1062
1063         return false;
1064 }
1065
1066 /**
1067  * mem_cgroup_iter - iterate over memory cgroup hierarchy
1068  * @root: hierarchy root
1069  * @prev: previously returned memcg, NULL on first invocation
1070  * @reclaim: cookie for shared reclaim walks, NULL for full walks
1071  *
1072  * Returns references to children of the hierarchy below @root, or
1073  * @root itself, or %NULL after a full round-trip.
1074  *
1075  * Caller must pass the return value in @prev on subsequent
1076  * invocations for reference counting, or use mem_cgroup_iter_break()
1077  * to cancel a hierarchy walk before the round-trip is complete.
1078  *
1079  * Reclaimers can specify a node in @reclaim to divide up the memcgs
1080  * in the hierarchy among all concurrent reclaimers operating on the
1081  * same node.
1082  */
1083 struct mem_cgroup *mem_cgroup_iter(struct mem_cgroup *root,
1084                                    struct mem_cgroup *prev,
1085                                    struct mem_cgroup_reclaim_cookie *reclaim)
1086 {
1087         struct mem_cgroup_reclaim_iter *iter;
1088         struct cgroup_subsys_state *css = NULL;
1089         struct mem_cgroup *memcg = NULL;
1090         struct mem_cgroup *pos = NULL;
1091
1092         if (mem_cgroup_disabled())
1093                 return NULL;
1094
1095         if (!root)
1096                 root = root_mem_cgroup;
1097
1098         if (prev && !reclaim)
1099                 pos = prev;
1100
1101         rcu_read_lock();
1102
1103         if (reclaim) {
1104                 struct mem_cgroup_per_node *mz;
1105
1106                 mz = root->nodeinfo[reclaim->pgdat->node_id];
1107                 iter = &mz->iter;
1108
1109                 if (prev && reclaim->generation != iter->generation)
1110                         goto out_unlock;
1111
1112                 while (1) {
1113                         pos = READ_ONCE(iter->position);
1114                         if (!pos || css_tryget(&pos->css))
1115                                 break;
1116                         /*
1117                          * css reference reached zero, so iter->position will
1118                          * be cleared by ->css_released. However, we should not
1119                          * rely on this happening soon, because ->css_released
1120                          * is called from a work queue, and by busy-waiting we
1121                          * might block it. So we clear iter->position right
1122                          * away.
1123                          */
1124                         (void)cmpxchg(&iter->position, pos, NULL);
1125                 }
1126         }
1127
1128         if (pos)
1129                 css = &pos->css;
1130
1131         for (;;) {
1132                 css = css_next_descendant_pre(css, &root->css);
1133                 if (!css) {
1134                         /*
1135                          * Reclaimers share the hierarchy walk, and a
1136                          * new one might jump in right at the end of
1137                          * the hierarchy - make sure they see at least
1138                          * one group and restart from the beginning.
1139                          */
1140                         if (!prev)
1141                                 continue;
1142                         break;
1143                 }
1144
1145                 /*
1146                  * Verify the css and acquire a reference.  The root
1147                  * is provided by the caller, so we know it's alive
1148                  * and kicking, and don't take an extra reference.
1149                  */
1150                 memcg = mem_cgroup_from_css(css);
1151
1152                 if (css == &root->css)
1153                         break;
1154
1155                 if (css_tryget(css))
1156                         break;
1157
1158                 memcg = NULL;
1159         }
1160
1161         if (reclaim) {
1162                 /*
1163                  * The position could have already been updated by a competing
1164                  * thread, so check that the value hasn't changed since we read
1165                  * it to avoid reclaiming from the same cgroup twice.
1166                  */
1167                 (void)cmpxchg(&iter->position, pos, memcg);
1168
1169                 if (pos)
1170                         css_put(&pos->css);
1171
1172                 if (!memcg)
1173                         iter->generation++;
1174                 else if (!prev)
1175                         reclaim->generation = iter->generation;
1176         }
1177
1178 out_unlock:
1179         rcu_read_unlock();
1180         if (prev && prev != root)
1181                 css_put(&prev->css);
1182
1183         return memcg;
1184 }
1185
1186 /**
1187  * mem_cgroup_iter_break - abort a hierarchy walk prematurely
1188  * @root: hierarchy root
1189  * @prev: last visited hierarchy member as returned by mem_cgroup_iter()
1190  */
1191 void mem_cgroup_iter_break(struct mem_cgroup *root,
1192                            struct mem_cgroup *prev)
1193 {
1194         if (!root)
1195                 root = root_mem_cgroup;
1196         if (prev && prev != root)
1197                 css_put(&prev->css);
1198 }
1199
1200 static void __invalidate_reclaim_iterators(struct mem_cgroup *from,
1201                                         struct mem_cgroup *dead_memcg)
1202 {
1203         struct mem_cgroup_reclaim_iter *iter;
1204         struct mem_cgroup_per_node *mz;
1205         int nid;
1206
1207         for_each_node(nid) {
1208                 mz = from->nodeinfo[nid];
1209                 iter = &mz->iter;
1210                 cmpxchg(&iter->position, dead_memcg, NULL);
1211         }
1212 }
1213
1214 static void invalidate_reclaim_iterators(struct mem_cgroup *dead_memcg)
1215 {
1216         struct mem_cgroup *memcg = dead_memcg;
1217         struct mem_cgroup *last;
1218
1219         do {
1220                 __invalidate_reclaim_iterators(memcg, dead_memcg);
1221                 last = memcg;
1222         } while ((memcg = parent_mem_cgroup(memcg)));
1223
1224         /*
1225          * When cgruop1 non-hierarchy mode is used,
1226          * parent_mem_cgroup() does not walk all the way up to the
1227          * cgroup root (root_mem_cgroup). So we have to handle
1228          * dead_memcg from cgroup root separately.
1229          */
1230         if (last != root_mem_cgroup)
1231                 __invalidate_reclaim_iterators(root_mem_cgroup,
1232                                                 dead_memcg);
1233 }
1234
1235 /**
1236  * mem_cgroup_scan_tasks - iterate over tasks of a memory cgroup hierarchy
1237  * @memcg: hierarchy root
1238  * @fn: function to call for each task
1239  * @arg: argument passed to @fn
1240  *
1241  * This function iterates over tasks attached to @memcg or to any of its
1242  * descendants and calls @fn for each task. If @fn returns a non-zero
1243  * value, the function breaks the iteration loop and returns the value.
1244  * Otherwise, it will iterate over all tasks and return 0.
1245  *
1246  * This function must not be called for the root memory cgroup.
1247  */
1248 int mem_cgroup_scan_tasks(struct mem_cgroup *memcg,
1249                           int (*fn)(struct task_struct *, void *), void *arg)
1250 {
1251         struct mem_cgroup *iter;
1252         int ret = 0;
1253
1254         BUG_ON(memcg == root_mem_cgroup);
1255
1256         for_each_mem_cgroup_tree(iter, memcg) {
1257                 struct css_task_iter it;
1258                 struct task_struct *task;
1259
1260                 css_task_iter_start(&iter->css, CSS_TASK_ITER_PROCS, &it);
1261                 while (!ret && (task = css_task_iter_next(&it)))
1262                         ret = fn(task, arg);
1263                 css_task_iter_end(&it);
1264                 if (ret) {
1265                         mem_cgroup_iter_break(memcg, iter);
1266                         break;
1267                 }
1268         }
1269         return ret;
1270 }
1271
1272 #ifdef CONFIG_DEBUG_VM
1273 void lruvec_memcg_debug(struct lruvec *lruvec, struct page *page)
1274 {
1275         struct mem_cgroup *memcg;
1276
1277         if (mem_cgroup_disabled())
1278                 return;
1279
1280         memcg = page_memcg(page);
1281
1282         if (!memcg)
1283                 VM_BUG_ON_PAGE(lruvec_memcg(lruvec) != root_mem_cgroup, page);
1284         else
1285                 VM_BUG_ON_PAGE(lruvec_memcg(lruvec) != memcg, page);
1286 }
1287 #endif
1288
1289 /**
1290  * lock_page_lruvec - lock and return lruvec for a given page.
1291  * @page: the page
1292  *
1293  * These functions are safe to use under any of the following conditions:
1294  * - page locked
1295  * - PageLRU cleared
1296  * - lock_page_memcg()
1297  * - page->_refcount is zero
1298  */
1299 struct lruvec *lock_page_lruvec(struct page *page)
1300 {
1301         struct lruvec *lruvec;
1302
1303         lruvec = mem_cgroup_page_lruvec(page);
1304         spin_lock(&lruvec->lru_lock);
1305
1306         lruvec_memcg_debug(lruvec, page);
1307
1308         return lruvec;
1309 }
1310
1311 struct lruvec *lock_page_lruvec_irq(struct page *page)
1312 {
1313         struct lruvec *lruvec;
1314
1315         lruvec = mem_cgroup_page_lruvec(page);
1316         spin_lock_irq(&lruvec->lru_lock);
1317
1318         lruvec_memcg_debug(lruvec, page);
1319
1320         return lruvec;
1321 }
1322
1323 struct lruvec *lock_page_lruvec_irqsave(struct page *page, unsigned long *flags)
1324 {
1325         struct lruvec *lruvec;
1326
1327         lruvec = mem_cgroup_page_lruvec(page);
1328         spin_lock_irqsave(&lruvec->lru_lock, *flags);
1329
1330         lruvec_memcg_debug(lruvec, page);
1331
1332         return lruvec;
1333 }
1334
1335 /**
1336  * mem_cgroup_update_lru_size - account for adding or removing an lru page
1337  * @lruvec: mem_cgroup per zone lru vector
1338  * @lru: index of lru list the page is sitting on
1339  * @zid: zone id of the accounted pages
1340  * @nr_pages: positive when adding or negative when removing
1341  *
1342  * This function must be called under lru_lock, just before a page is added
1343  * to or just after a page is removed from an lru list (that ordering being
1344  * so as to allow it to check that lru_size 0 is consistent with list_empty).
1345  */
1346 void mem_cgroup_update_lru_size(struct lruvec *lruvec, enum lru_list lru,
1347                                 int zid, int nr_pages)
1348 {
1349         struct mem_cgroup_per_node *mz;
1350         unsigned long *lru_size;
1351         long size;
1352
1353         if (mem_cgroup_disabled())
1354                 return;
1355
1356         mz = container_of(lruvec, struct mem_cgroup_per_node, lruvec);
1357         lru_size = &mz->lru_zone_size[zid][lru];
1358
1359         if (nr_pages < 0)
1360                 *lru_size += nr_pages;
1361
1362         size = *lru_size;
1363         if (WARN_ONCE(size < 0,
1364                 "%s(%p, %d, %d): lru_size %ld\n",
1365                 __func__, lruvec, lru, nr_pages, size)) {
1366                 VM_BUG_ON(1);
1367                 *lru_size = 0;
1368         }
1369
1370         if (nr_pages > 0)
1371                 *lru_size += nr_pages;
1372 }
1373
1374 /**
1375  * mem_cgroup_margin - calculate chargeable space of a memory cgroup
1376  * @memcg: the memory cgroup
1377  *
1378  * Returns the maximum amount of memory @mem can be charged with, in
1379  * pages.
1380  */
1381 static unsigned long mem_cgroup_margin(struct mem_cgroup *memcg)
1382 {
1383         unsigned long margin = 0;
1384         unsigned long count;
1385         unsigned long limit;
1386
1387         count = page_counter_read(&memcg->memory);
1388         limit = READ_ONCE(memcg->memory.max);
1389         if (count < limit)
1390                 margin = limit - count;
1391
1392         if (do_memsw_account()) {
1393                 count = page_counter_read(&memcg->memsw);
1394                 limit = READ_ONCE(memcg->memsw.max);
1395                 if (count < limit)
1396                         margin = min(margin, limit - count);
1397                 else
1398                         margin = 0;
1399         }
1400
1401         return margin;
1402 }
1403
1404 /*
1405  * A routine for checking "mem" is under move_account() or not.
1406  *
1407  * Checking a cgroup is mc.from or mc.to or under hierarchy of
1408  * moving cgroups. This is for waiting at high-memory pressure
1409  * caused by "move".
1410  */
1411 static bool mem_cgroup_under_move(struct mem_cgroup *memcg)
1412 {
1413         struct mem_cgroup *from;
1414         struct mem_cgroup *to;
1415         bool ret = false;
1416         /*
1417          * Unlike task_move routines, we access mc.to, mc.from not under
1418          * mutual exclusion by cgroup_mutex. Here, we take spinlock instead.
1419          */
1420         spin_lock(&mc.lock);
1421         from = mc.from;
1422         to = mc.to;
1423         if (!from)
1424                 goto unlock;
1425
1426         ret = mem_cgroup_is_descendant(from, memcg) ||
1427                 mem_cgroup_is_descendant(to, memcg);
1428 unlock:
1429         spin_unlock(&mc.lock);
1430         return ret;
1431 }
1432
1433 static bool mem_cgroup_wait_acct_move(struct mem_cgroup *memcg)
1434 {
1435         if (mc.moving_task && current != mc.moving_task) {
1436                 if (mem_cgroup_under_move(memcg)) {
1437                         DEFINE_WAIT(wait);
1438                         prepare_to_wait(&mc.waitq, &wait, TASK_INTERRUPTIBLE);
1439                         /* moving charge context might have finished. */
1440                         if (mc.moving_task)
1441                                 schedule();
1442                         finish_wait(&mc.waitq, &wait);
1443                         return true;
1444                 }
1445         }
1446         return false;
1447 }
1448
1449 struct memory_stat {
1450         const char *name;
1451         unsigned int idx;
1452 };
1453
1454 static const struct memory_stat memory_stats[] = {
1455         { "anon",                       NR_ANON_MAPPED                  },
1456         { "file",                       NR_FILE_PAGES                   },
1457         { "kernel_stack",               NR_KERNEL_STACK_KB              },
1458         { "pagetables",                 NR_PAGETABLE                    },
1459         { "percpu",                     MEMCG_PERCPU_B                  },
1460         { "sock",                       MEMCG_SOCK                      },
1461         { "shmem",                      NR_SHMEM                        },
1462         { "file_mapped",                NR_FILE_MAPPED                  },
1463         { "file_dirty",                 NR_FILE_DIRTY                   },
1464         { "file_writeback",             NR_WRITEBACK                    },
1465 #ifdef CONFIG_SWAP
1466         { "swapcached",                 NR_SWAPCACHE                    },
1467 #endif
1468 #ifdef CONFIG_TRANSPARENT_HUGEPAGE
1469         { "anon_thp",                   NR_ANON_THPS                    },
1470         { "file_thp",                   NR_FILE_THPS                    },
1471         { "shmem_thp",                  NR_SHMEM_THPS                   },
1472 #endif
1473         { "inactive_anon",              NR_INACTIVE_ANON                },
1474         { "active_anon",                NR_ACTIVE_ANON                  },
1475         { "inactive_file",              NR_INACTIVE_FILE                },
1476         { "active_file",                NR_ACTIVE_FILE                  },
1477         { "unevictable",                NR_UNEVICTABLE                  },
1478         { "slab_reclaimable",           NR_SLAB_RECLAIMABLE_B           },
1479         { "slab_unreclaimable",         NR_SLAB_UNRECLAIMABLE_B         },
1480
1481         /* The memory events */
1482         { "workingset_refault_anon",    WORKINGSET_REFAULT_ANON         },
1483         { "workingset_refault_file",    WORKINGSET_REFAULT_FILE         },
1484         { "workingset_activate_anon",   WORKINGSET_ACTIVATE_ANON        },
1485         { "workingset_activate_file",   WORKINGSET_ACTIVATE_FILE        },
1486         { "workingset_restore_anon",    WORKINGSET_RESTORE_ANON         },
1487         { "workingset_restore_file",    WORKINGSET_RESTORE_FILE         },
1488         { "workingset_nodereclaim",     WORKINGSET_NODERECLAIM          },
1489 };
1490
1491 /* Translate stat items to the correct unit for memory.stat output */
1492 static int memcg_page_state_unit(int item)
1493 {
1494         switch (item) {
1495         case MEMCG_PERCPU_B:
1496         case NR_SLAB_RECLAIMABLE_B:
1497         case NR_SLAB_UNRECLAIMABLE_B:
1498         case WORKINGSET_REFAULT_ANON:
1499         case WORKINGSET_REFAULT_FILE:
1500         case WORKINGSET_ACTIVATE_ANON:
1501         case WORKINGSET_ACTIVATE_FILE:
1502         case WORKINGSET_RESTORE_ANON:
1503         case WORKINGSET_RESTORE_FILE:
1504         case WORKINGSET_NODERECLAIM:
1505                 return 1;
1506         case NR_KERNEL_STACK_KB:
1507                 return SZ_1K;
1508         default:
1509                 return PAGE_SIZE;
1510         }
1511 }
1512
1513 static inline unsigned long memcg_page_state_output(struct mem_cgroup *memcg,
1514                                                     int item)
1515 {
1516         return memcg_page_state(memcg, item) * memcg_page_state_unit(item);
1517 }
1518
1519 static char *memory_stat_format(struct mem_cgroup *memcg)
1520 {
1521         struct seq_buf s;
1522         int i;
1523
1524         seq_buf_init(&s, kmalloc(PAGE_SIZE, GFP_KERNEL), PAGE_SIZE);
1525         if (!s.buffer)
1526                 return NULL;
1527
1528         /*
1529          * Provide statistics on the state of the memory subsystem as
1530          * well as cumulative event counters that show past behavior.
1531          *
1532          * This list is ordered following a combination of these gradients:
1533          * 1) generic big picture -> specifics and details
1534          * 2) reflecting userspace activity -> reflecting kernel heuristics
1535          *
1536          * Current memory state:
1537          */
1538         mem_cgroup_flush_stats();
1539
1540         for (i = 0; i < ARRAY_SIZE(memory_stats); i++) {
1541                 u64 size;
1542
1543                 size = memcg_page_state_output(memcg, memory_stats[i].idx);
1544                 seq_buf_printf(&s, "%s %llu\n", memory_stats[i].name, size);
1545
1546                 if (unlikely(memory_stats[i].idx == NR_SLAB_UNRECLAIMABLE_B)) {
1547                         size += memcg_page_state_output(memcg,
1548                                                         NR_SLAB_RECLAIMABLE_B);
1549                         seq_buf_printf(&s, "slab %llu\n", size);
1550                 }
1551         }
1552
1553         /* Accumulated memory events */
1554
1555         seq_buf_printf(&s, "%s %lu\n", vm_event_name(PGFAULT),
1556                        memcg_events(memcg, PGFAULT));
1557         seq_buf_printf(&s, "%s %lu\n", vm_event_name(PGMAJFAULT),
1558                        memcg_events(memcg, PGMAJFAULT));
1559         seq_buf_printf(&s, "%s %lu\n",  vm_event_name(PGREFILL),
1560                        memcg_events(memcg, PGREFILL));
1561         seq_buf_printf(&s, "pgscan %lu\n",
1562                        memcg_events(memcg, PGSCAN_KSWAPD) +
1563                        memcg_events(memcg, PGSCAN_DIRECT));
1564         seq_buf_printf(&s, "pgsteal %lu\n",
1565                        memcg_events(memcg, PGSTEAL_KSWAPD) +
1566                        memcg_events(memcg, PGSTEAL_DIRECT));
1567         seq_buf_printf(&s, "%s %lu\n", vm_event_name(PGACTIVATE),
1568                        memcg_events(memcg, PGACTIVATE));
1569         seq_buf_printf(&s, "%s %lu\n", vm_event_name(PGDEACTIVATE),
1570                        memcg_events(memcg, PGDEACTIVATE));
1571         seq_buf_printf(&s, "%s %lu\n", vm_event_name(PGLAZYFREE),
1572                        memcg_events(memcg, PGLAZYFREE));
1573         seq_buf_printf(&s, "%s %lu\n", vm_event_name(PGLAZYFREED),
1574                        memcg_events(memcg, PGLAZYFREED));
1575
1576 #ifdef CONFIG_TRANSPARENT_HUGEPAGE
1577         seq_buf_printf(&s, "%s %lu\n", vm_event_name(THP_FAULT_ALLOC),
1578                        memcg_events(memcg, THP_FAULT_ALLOC));
1579         seq_buf_printf(&s, "%s %lu\n", vm_event_name(THP_COLLAPSE_ALLOC),
1580                        memcg_events(memcg, THP_COLLAPSE_ALLOC));
1581 #endif /* CONFIG_TRANSPARENT_HUGEPAGE */
1582
1583         /* The above should easily fit into one page */
1584         WARN_ON_ONCE(seq_buf_has_overflowed(&s));
1585
1586         return s.buffer;
1587 }
1588
1589 #define K(x) ((x) << (PAGE_SHIFT-10))
1590 /**
1591  * mem_cgroup_print_oom_context: Print OOM information relevant to
1592  * memory controller.
1593  * @memcg: The memory cgroup that went over limit
1594  * @p: Task that is going to be killed
1595  *
1596  * NOTE: @memcg and @p's mem_cgroup can be different when hierarchy is
1597  * enabled
1598  */
1599 void mem_cgroup_print_oom_context(struct mem_cgroup *memcg, struct task_struct *p)
1600 {
1601         rcu_read_lock();
1602
1603         if (memcg) {
1604                 pr_cont(",oom_memcg=");
1605                 pr_cont_cgroup_path(memcg->css.cgroup);
1606         } else
1607                 pr_cont(",global_oom");
1608         if (p) {
1609                 pr_cont(",task_memcg=");
1610                 pr_cont_cgroup_path(task_cgroup(p, memory_cgrp_id));
1611         }
1612         rcu_read_unlock();
1613 }
1614
1615 /**
1616  * mem_cgroup_print_oom_meminfo: Print OOM memory information relevant to
1617  * memory controller.
1618  * @memcg: The memory cgroup that went over limit
1619  */
1620 void mem_cgroup_print_oom_meminfo(struct mem_cgroup *memcg)
1621 {
1622         char *buf;
1623
1624         pr_info("memory: usage %llukB, limit %llukB, failcnt %lu\n",
1625                 K((u64)page_counter_read(&memcg->memory)),
1626                 K((u64)READ_ONCE(memcg->memory.max)), memcg->memory.failcnt);
1627         if (cgroup_subsys_on_dfl(memory_cgrp_subsys))
1628                 pr_info("swap: usage %llukB, limit %llukB, failcnt %lu\n",
1629                         K((u64)page_counter_read(&memcg->swap)),
1630                         K((u64)READ_ONCE(memcg->swap.max)), memcg->swap.failcnt);
1631         else {
1632                 pr_info("memory+swap: usage %llukB, limit %llukB, failcnt %lu\n",
1633                         K((u64)page_counter_read(&memcg->memsw)),
1634                         K((u64)memcg->memsw.max), memcg->memsw.failcnt);
1635                 pr_info("kmem: usage %llukB, limit %llukB, failcnt %lu\n",
1636                         K((u64)page_counter_read(&memcg->kmem)),
1637                         K((u64)memcg->kmem.max), memcg->kmem.failcnt);
1638         }
1639
1640         pr_info("Memory cgroup stats for ");
1641         pr_cont_cgroup_path(memcg->css.cgroup);
1642         pr_cont(":");
1643         buf = memory_stat_format(memcg);
1644         if (!buf)
1645                 return;
1646         pr_info("%s", buf);
1647         kfree(buf);
1648 }
1649
1650 /*
1651  * Return the memory (and swap, if configured) limit for a memcg.
1652  */
1653 unsigned long mem_cgroup_get_max(struct mem_cgroup *memcg)
1654 {
1655         unsigned long max = READ_ONCE(memcg->memory.max);
1656
1657         if (cgroup_subsys_on_dfl(memory_cgrp_subsys)) {
1658                 if (mem_cgroup_swappiness(memcg))
1659                         max += min(READ_ONCE(memcg->swap.max),
1660                                    (unsigned long)total_swap_pages);
1661         } else { /* v1 */
1662                 if (mem_cgroup_swappiness(memcg)) {
1663                         /* Calculate swap excess capacity from memsw limit */
1664                         unsigned long swap = READ_ONCE(memcg->memsw.max) - max;
1665
1666                         max += min(swap, (unsigned long)total_swap_pages);
1667                 }
1668         }
1669         return max;
1670 }
1671
1672 unsigned long mem_cgroup_size(struct mem_cgroup *memcg)
1673 {
1674         return page_counter_read(&memcg->memory);
1675 }
1676
1677 static bool mem_cgroup_out_of_memory(struct mem_cgroup *memcg, gfp_t gfp_mask,
1678                                      int order)
1679 {
1680         struct oom_control oc = {
1681                 .zonelist = NULL,
1682                 .nodemask = NULL,
1683                 .memcg = memcg,
1684                 .gfp_mask = gfp_mask,
1685                 .order = order,
1686         };
1687         bool ret = true;
1688
1689         if (mutex_lock_killable(&oom_lock))
1690                 return true;
1691
1692         if (mem_cgroup_margin(memcg) >= (1 << order))
1693                 goto unlock;
1694
1695         /*
1696          * A few threads which were not waiting at mutex_lock_killable() can
1697          * fail to bail out. Therefore, check again after holding oom_lock.
1698          */
1699         ret = task_is_dying() || out_of_memory(&oc);
1700
1701 unlock:
1702         mutex_unlock(&oom_lock);
1703         return ret;
1704 }
1705
1706 static int mem_cgroup_soft_reclaim(struct mem_cgroup *root_memcg,
1707                                    pg_data_t *pgdat,
1708                                    gfp_t gfp_mask,
1709                                    unsigned long *total_scanned)
1710 {
1711         struct mem_cgroup *victim = NULL;
1712         int total = 0;
1713         int loop = 0;
1714         unsigned long excess;
1715         unsigned long nr_scanned;
1716         struct mem_cgroup_reclaim_cookie reclaim = {
1717                 .pgdat = pgdat,
1718         };
1719
1720         excess = soft_limit_excess(root_memcg);
1721
1722         while (1) {
1723                 victim = mem_cgroup_iter(root_memcg, victim, &reclaim);
1724                 if (!victim) {
1725                         loop++;
1726                         if (loop >= 2) {
1727                                 /*
1728                                  * If we have not been able to reclaim
1729                                  * anything, it might because there are
1730                                  * no reclaimable pages under this hierarchy
1731                                  */
1732                                 if (!total)
1733                                         break;
1734                                 /*
1735                                  * We want to do more targeted reclaim.
1736                                  * excess >> 2 is not to excessive so as to
1737                                  * reclaim too much, nor too less that we keep
1738                                  * coming back to reclaim from this cgroup
1739                                  */
1740                                 if (total >= (excess >> 2) ||
1741                                         (loop > MEM_CGROUP_MAX_RECLAIM_LOOPS))
1742                                         break;
1743                         }
1744                         continue;
1745                 }
1746                 total += mem_cgroup_shrink_node(victim, gfp_mask, false,
1747                                         pgdat, &nr_scanned);
1748                 *total_scanned += nr_scanned;
1749                 if (!soft_limit_excess(root_memcg))
1750                         break;
1751         }
1752         mem_cgroup_iter_break(root_memcg, victim);
1753         return total;
1754 }
1755
1756 #ifdef CONFIG_LOCKDEP
1757 static struct lockdep_map memcg_oom_lock_dep_map = {
1758         .name = "memcg_oom_lock",
1759 };
1760 #endif
1761
1762 static DEFINE_SPINLOCK(memcg_oom_lock);
1763
1764 /*
1765  * Check OOM-Killer is already running under our hierarchy.
1766  * If someone is running, return false.
1767  */
1768 static bool mem_cgroup_oom_trylock(struct mem_cgroup *memcg)
1769 {
1770         struct mem_cgroup *iter, *failed = NULL;
1771
1772         spin_lock(&memcg_oom_lock);
1773
1774         for_each_mem_cgroup_tree(iter, memcg) {
1775                 if (iter->oom_lock) {
1776                         /*
1777                          * this subtree of our hierarchy is already locked
1778                          * so we cannot give a lock.
1779                          */
1780                         failed = iter;
1781                         mem_cgroup_iter_break(memcg, iter);
1782                         break;
1783                 } else
1784                         iter->oom_lock = true;
1785         }
1786
1787         if (failed) {
1788                 /*
1789                  * OK, we failed to lock the whole subtree so we have
1790                  * to clean up what we set up to the failing subtree
1791                  */
1792                 for_each_mem_cgroup_tree(iter, memcg) {
1793                         if (iter == failed) {
1794                                 mem_cgroup_iter_break(memcg, iter);
1795                                 break;
1796                         }
1797                         iter->oom_lock = false;
1798                 }
1799         } else
1800                 mutex_acquire(&memcg_oom_lock_dep_map, 0, 1, _RET_IP_);
1801
1802         spin_unlock(&memcg_oom_lock);
1803
1804         return !failed;
1805 }
1806
1807 static void mem_cgroup_oom_unlock(struct mem_cgroup *memcg)
1808 {
1809         struct mem_cgroup *iter;
1810
1811         spin_lock(&memcg_oom_lock);
1812         mutex_release(&memcg_oom_lock_dep_map, _RET_IP_);
1813         for_each_mem_cgroup_tree(iter, memcg)
1814                 iter->oom_lock = false;
1815         spin_unlock(&memcg_oom_lock);
1816 }
1817
1818 static void mem_cgroup_mark_under_oom(struct mem_cgroup *memcg)
1819 {
1820         struct mem_cgroup *iter;
1821
1822         spin_lock(&memcg_oom_lock);
1823         for_each_mem_cgroup_tree(iter, memcg)
1824                 iter->under_oom++;
1825         spin_unlock(&memcg_oom_lock);
1826 }
1827
1828 static void mem_cgroup_unmark_under_oom(struct mem_cgroup *memcg)
1829 {
1830         struct mem_cgroup *iter;
1831
1832         /*
1833          * Be careful about under_oom underflows because a child memcg
1834          * could have been added after mem_cgroup_mark_under_oom.
1835          */
1836         spin_lock(&memcg_oom_lock);
1837         for_each_mem_cgroup_tree(iter, memcg)
1838                 if (iter->under_oom > 0)
1839                         iter->under_oom--;
1840         spin_unlock(&memcg_oom_lock);
1841 }
1842
1843 static DECLARE_WAIT_QUEUE_HEAD(memcg_oom_waitq);
1844
1845 struct oom_wait_info {
1846         struct mem_cgroup *memcg;
1847         wait_queue_entry_t      wait;
1848 };
1849
1850 static int memcg_oom_wake_function(wait_queue_entry_t *wait,
1851         unsigned mode, int sync, void *arg)
1852 {
1853         struct mem_cgroup *wake_memcg = (struct mem_cgroup *)arg;
1854         struct mem_cgroup *oom_wait_memcg;
1855         struct oom_wait_info *oom_wait_info;
1856
1857         oom_wait_info = container_of(wait, struct oom_wait_info, wait);
1858         oom_wait_memcg = oom_wait_info->memcg;
1859
1860         if (!mem_cgroup_is_descendant(wake_memcg, oom_wait_memcg) &&
1861             !mem_cgroup_is_descendant(oom_wait_memcg, wake_memcg))
1862                 return 0;
1863         return autoremove_wake_function(wait, mode, sync, arg);
1864 }
1865
1866 static void memcg_oom_recover(struct mem_cgroup *memcg)
1867 {
1868         /*
1869          * For the following lockless ->under_oom test, the only required
1870          * guarantee is that it must see the state asserted by an OOM when
1871          * this function is called as a result of userland actions
1872          * triggered by the notification of the OOM.  This is trivially
1873          * achieved by invoking mem_cgroup_mark_under_oom() before
1874          * triggering notification.
1875          */
1876         if (memcg && memcg->under_oom)
1877                 __wake_up(&memcg_oom_waitq, TASK_NORMAL, 0, memcg);
1878 }
1879
1880 enum oom_status {
1881         OOM_SUCCESS,
1882         OOM_FAILED,
1883         OOM_ASYNC,
1884         OOM_SKIPPED
1885 };
1886
1887 static enum oom_status mem_cgroup_oom(struct mem_cgroup *memcg, gfp_t mask, int order)
1888 {
1889         enum oom_status ret;
1890         bool locked;
1891
1892         if (order > PAGE_ALLOC_COSTLY_ORDER)
1893                 return OOM_SKIPPED;
1894
1895         memcg_memory_event(memcg, MEMCG_OOM);
1896
1897         /*
1898          * We are in the middle of the charge context here, so we
1899          * don't want to block when potentially sitting on a callstack
1900          * that holds all kinds of filesystem and mm locks.
1901          *
1902          * cgroup1 allows disabling the OOM killer and waiting for outside
1903          * handling until the charge can succeed; remember the context and put
1904          * the task to sleep at the end of the page fault when all locks are
1905          * released.
1906          *
1907          * On the other hand, in-kernel OOM killer allows for an async victim
1908          * memory reclaim (oom_reaper) and that means that we are not solely
1909          * relying on the oom victim to make a forward progress and we can
1910          * invoke the oom killer here.
1911          *
1912          * Please note that mem_cgroup_out_of_memory might fail to find a
1913          * victim and then we have to bail out from the charge path.
1914          */
1915         if (memcg->oom_kill_disable) {
1916                 if (!current->in_user_fault)
1917                         return OOM_SKIPPED;
1918                 css_get(&memcg->css);
1919                 current->memcg_in_oom = memcg;
1920                 current->memcg_oom_gfp_mask = mask;
1921                 current->memcg_oom_order = order;
1922
1923                 return OOM_ASYNC;
1924         }
1925
1926         mem_cgroup_mark_under_oom(memcg);
1927
1928         locked = mem_cgroup_oom_trylock(memcg);
1929
1930         if (locked)
1931                 mem_cgroup_oom_notify(memcg);
1932
1933         mem_cgroup_unmark_under_oom(memcg);
1934         if (mem_cgroup_out_of_memory(memcg, mask, order))
1935                 ret = OOM_SUCCESS;
1936         else
1937                 ret = OOM_FAILED;
1938
1939         if (locked)
1940                 mem_cgroup_oom_unlock(memcg);
1941
1942         return ret;
1943 }
1944
1945 /**
1946  * mem_cgroup_oom_synchronize - complete memcg OOM handling
1947  * @handle: actually kill/wait or just clean up the OOM state
1948  *
1949  * This has to be called at the end of a page fault if the memcg OOM
1950  * handler was enabled.
1951  *
1952  * Memcg supports userspace OOM handling where failed allocations must
1953  * sleep on a waitqueue until the userspace task resolves the
1954  * situation.  Sleeping directly in the charge context with all kinds
1955  * of locks held is not a good idea, instead we remember an OOM state
1956  * in the task and mem_cgroup_oom_synchronize() has to be called at
1957  * the end of the page fault to complete the OOM handling.
1958  *
1959  * Returns %true if an ongoing memcg OOM situation was detected and
1960  * completed, %false otherwise.
1961  */
1962 bool mem_cgroup_oom_synchronize(bool handle)
1963 {
1964         struct mem_cgroup *memcg = current->memcg_in_oom;
1965         struct oom_wait_info owait;
1966         bool locked;
1967
1968         /* OOM is global, do not handle */
1969         if (!memcg)
1970                 return false;
1971
1972         if (!handle)
1973                 goto cleanup;
1974
1975         owait.memcg = memcg;
1976         owait.wait.flags = 0;
1977         owait.wait.func = memcg_oom_wake_function;
1978         owait.wait.private = current;
1979         INIT_LIST_HEAD(&owait.wait.entry);
1980
1981         prepare_to_wait(&memcg_oom_waitq, &owait.wait, TASK_KILLABLE);
1982         mem_cgroup_mark_under_oom(memcg);
1983
1984         locked = mem_cgroup_oom_trylock(memcg);
1985
1986         if (locked)
1987                 mem_cgroup_oom_notify(memcg);
1988
1989         if (locked && !memcg->oom_kill_disable) {
1990                 mem_cgroup_unmark_under_oom(memcg);
1991                 finish_wait(&memcg_oom_waitq, &owait.wait);
1992                 mem_cgroup_out_of_memory(memcg, current->memcg_oom_gfp_mask,
1993                                          current->memcg_oom_order);
1994         } else {
1995                 schedule();
1996                 mem_cgroup_unmark_under_oom(memcg);
1997                 finish_wait(&memcg_oom_waitq, &owait.wait);
1998         }
1999
2000         if (locked) {
2001                 mem_cgroup_oom_unlock(memcg);
2002                 /*
2003                  * There is no guarantee that an OOM-lock contender
2004                  * sees the wakeups triggered by the OOM kill
2005                  * uncharges.  Wake any sleepers explicitly.
2006                  */
2007                 memcg_oom_recover(memcg);
2008         }
2009 cleanup:
2010         current->memcg_in_oom = NULL;
2011         css_put(&memcg->css);
2012         return true;
2013 }
2014
2015 /**
2016  * mem_cgroup_get_oom_group - get a memory cgroup to clean up after OOM
2017  * @victim: task to be killed by the OOM killer
2018  * @oom_domain: memcg in case of memcg OOM, NULL in case of system-wide OOM
2019  *
2020  * Returns a pointer to a memory cgroup, which has to be cleaned up
2021  * by killing all belonging OOM-killable tasks.
2022  *
2023  * Caller has to call mem_cgroup_put() on the returned non-NULL memcg.
2024  */
2025 struct mem_cgroup *mem_cgroup_get_oom_group(struct task_struct *victim,
2026                                             struct mem_cgroup *oom_domain)
2027 {
2028         struct mem_cgroup *oom_group = NULL;
2029         struct mem_cgroup *memcg;
2030
2031         if (!cgroup_subsys_on_dfl(memory_cgrp_subsys))
2032                 return NULL;
2033
2034         if (!oom_domain)
2035                 oom_domain = root_mem_cgroup;
2036
2037         rcu_read_lock();
2038
2039         memcg = mem_cgroup_from_task(victim);
2040         if (memcg == root_mem_cgroup)
2041                 goto out;
2042
2043         /*
2044          * If the victim task has been asynchronously moved to a different
2045          * memory cgroup, we might end up killing tasks outside oom_domain.
2046          * In this case it's better to ignore memory.group.oom.
2047          */
2048         if (unlikely(!mem_cgroup_is_descendant(memcg, oom_domain)))
2049                 goto out;
2050
2051         /*
2052          * Traverse the memory cgroup hierarchy from the victim task's
2053          * cgroup up to the OOMing cgroup (or root) to find the
2054          * highest-level memory cgroup with oom.group set.
2055          */
2056         for (; memcg; memcg = parent_mem_cgroup(memcg)) {
2057                 if (memcg->oom_group)
2058                         oom_group = memcg;
2059
2060                 if (memcg == oom_domain)
2061                         break;
2062         }
2063
2064         if (oom_group)
2065                 css_get(&oom_group->css);
2066 out:
2067         rcu_read_unlock();
2068
2069         return oom_group;
2070 }
2071
2072 void mem_cgroup_print_oom_group(struct mem_cgroup *memcg)
2073 {
2074         pr_info("Tasks in ");
2075         pr_cont_cgroup_path(memcg->css.cgroup);
2076         pr_cont(" are going to be killed due to memory.oom.group set\n");
2077 }
2078
2079 /**
2080  * lock_page_memcg - lock a page and memcg binding
2081  * @page: the page
2082  *
2083  * This function protects unlocked LRU pages from being moved to
2084  * another cgroup.
2085  *
2086  * It ensures lifetime of the locked memcg. Caller is responsible
2087  * for the lifetime of the page.
2088  */
2089 void lock_page_memcg(struct page *page)
2090 {
2091         struct page *head = compound_head(page); /* rmap on tail pages */
2092         struct mem_cgroup *memcg;
2093         unsigned long flags;
2094
2095         /*
2096          * The RCU lock is held throughout the transaction.  The fast
2097          * path can get away without acquiring the memcg->move_lock
2098          * because page moving starts with an RCU grace period.
2099          */
2100         rcu_read_lock();
2101
2102         if (mem_cgroup_disabled())
2103                 return;
2104 again:
2105         memcg = page_memcg(head);
2106         if (unlikely(!memcg))
2107                 return;
2108
2109 #ifdef CONFIG_PROVE_LOCKING
2110         local_irq_save(flags);
2111         might_lock(&memcg->move_lock);
2112         local_irq_restore(flags);
2113 #endif
2114
2115         if (atomic_read(&memcg->moving_account) <= 0)
2116                 return;
2117
2118         spin_lock_irqsave(&memcg->move_lock, flags);
2119         if (memcg != page_memcg(head)) {
2120                 spin_unlock_irqrestore(&memcg->move_lock, flags);
2121                 goto again;
2122         }
2123
2124         /*
2125          * When charge migration first begins, we can have multiple
2126          * critical sections holding the fast-path RCU lock and one
2127          * holding the slowpath move_lock. Track the task who has the
2128          * move_lock for unlock_page_memcg().
2129          */
2130         memcg->move_lock_task = current;
2131         memcg->move_lock_flags = flags;
2132 }
2133 EXPORT_SYMBOL(lock_page_memcg);
2134
2135 static void __unlock_page_memcg(struct mem_cgroup *memcg)
2136 {
2137         if (memcg && memcg->move_lock_task == current) {
2138                 unsigned long flags = memcg->move_lock_flags;
2139
2140                 memcg->move_lock_task = NULL;
2141                 memcg->move_lock_flags = 0;
2142
2143                 spin_unlock_irqrestore(&memcg->move_lock, flags);
2144         }
2145
2146         rcu_read_unlock();
2147 }
2148
2149 /**
2150  * unlock_page_memcg - unlock a page and memcg binding
2151  * @page: the page
2152  */
2153 void unlock_page_memcg(struct page *page)
2154 {
2155         struct page *head = compound_head(page);
2156
2157         __unlock_page_memcg(page_memcg(head));
2158 }
2159 EXPORT_SYMBOL(unlock_page_memcg);
2160
2161 struct memcg_stock_pcp {
2162         local_lock_t stock_lock;
2163         struct mem_cgroup *cached; /* this never be root cgroup */
2164         unsigned int nr_pages;
2165
2166 #ifdef CONFIG_MEMCG_KMEM
2167         struct obj_cgroup *cached_objcg;
2168         struct pglist_data *cached_pgdat;
2169         unsigned int nr_bytes;
2170         int nr_slab_reclaimable_b;
2171         int nr_slab_unreclaimable_b;
2172 #endif
2173
2174         struct work_struct work;
2175         unsigned long flags;
2176 #define FLUSHING_CACHED_CHARGE  0
2177 };
2178 static DEFINE_PER_CPU(struct memcg_stock_pcp, memcg_stock) = {
2179         .stock_lock = INIT_LOCAL_LOCK(stock_lock),
2180 };
2181 static DEFINE_MUTEX(percpu_charge_mutex);
2182
2183 #ifdef CONFIG_MEMCG_KMEM
2184 static struct obj_cgroup *drain_obj_stock(struct memcg_stock_pcp *stock);
2185 static bool obj_stock_flush_required(struct memcg_stock_pcp *stock,
2186                                      struct mem_cgroup *root_memcg);
2187
2188 #else
2189 static inline struct obj_cgroup *drain_obj_stock(struct memcg_stock_pcp *stock)
2190 {
2191         return NULL;
2192 }
2193 static bool obj_stock_flush_required(struct memcg_stock_pcp *stock,
2194                                      struct mem_cgroup *root_memcg)
2195 {
2196         return false;
2197 }
2198 #endif
2199
2200 /*
2201  * consume_stock: Try to consume stocked charge on this cpu.
2202  * @memcg: memcg to consume from.
2203  * @nr_pages: how many pages to charge.
2204  *
2205  * The charges will only happen if @memcg matches the current cpu's memcg
2206  * stock, and at least @nr_pages are available in that stock.  Failure to
2207  * service an allocation will refill the stock.
2208  *
2209  * returns true if successful, false otherwise.
2210  */
2211 static bool consume_stock(struct mem_cgroup *memcg, unsigned int nr_pages)
2212 {
2213         struct memcg_stock_pcp *stock;
2214         unsigned long flags;
2215         bool ret = false;
2216
2217         if (nr_pages > MEMCG_CHARGE_BATCH)
2218                 return ret;
2219
2220         local_lock_irqsave(&memcg_stock.stock_lock, flags);
2221
2222         stock = this_cpu_ptr(&memcg_stock);
2223         if (memcg == stock->cached && stock->nr_pages >= nr_pages) {
2224                 stock->nr_pages -= nr_pages;
2225                 ret = true;
2226         }
2227
2228         local_unlock_irqrestore(&memcg_stock.stock_lock, flags);
2229
2230         return ret;
2231 }
2232
2233 /*
2234  * Returns stocks cached in percpu and reset cached information.
2235  */
2236 static void drain_stock(struct memcg_stock_pcp *stock)
2237 {
2238         struct mem_cgroup *old = stock->cached;
2239
2240         if (!old)
2241                 return;
2242
2243         if (stock->nr_pages) {
2244                 page_counter_uncharge(&old->memory, stock->nr_pages);
2245                 if (do_memsw_account())
2246                         page_counter_uncharge(&old->memsw, stock->nr_pages);
2247                 stock->nr_pages = 0;
2248         }
2249
2250         css_put(&old->css);
2251         stock->cached = NULL;
2252 }
2253
2254 static void drain_local_stock(struct work_struct *dummy)
2255 {
2256         struct memcg_stock_pcp *stock;
2257         struct obj_cgroup *old = NULL;
2258         unsigned long flags;
2259
2260         /*
2261          * The only protection from cpu hotplug (memcg_hotplug_cpu_dead) vs.
2262          * drain_stock races is that we always operate on local CPU stock
2263          * here with IRQ disabled
2264          */
2265         local_lock_irqsave(&memcg_stock.stock_lock, flags);
2266
2267         stock = this_cpu_ptr(&memcg_stock);
2268         old = drain_obj_stock(stock);
2269         drain_stock(stock);
2270         clear_bit(FLUSHING_CACHED_CHARGE, &stock->flags);
2271
2272         local_unlock_irqrestore(&memcg_stock.stock_lock, flags);
2273         if (old)
2274                 obj_cgroup_put(old);
2275 }
2276
2277 /*
2278  * Cache charges(val) to local per_cpu area.
2279  * This will be consumed by consume_stock() function, later.
2280  */
2281 static void __refill_stock(struct mem_cgroup *memcg, unsigned int nr_pages)
2282 {
2283         struct memcg_stock_pcp *stock;
2284
2285         stock = this_cpu_ptr(&memcg_stock);
2286         if (stock->cached != memcg) { /* reset if necessary */
2287                 drain_stock(stock);
2288                 css_get(&memcg->css);
2289                 stock->cached = memcg;
2290         }
2291         stock->nr_pages += nr_pages;
2292
2293         if (stock->nr_pages > MEMCG_CHARGE_BATCH)
2294                 drain_stock(stock);
2295 }
2296
2297 static void refill_stock(struct mem_cgroup *memcg, unsigned int nr_pages)
2298 {
2299         unsigned long flags;
2300
2301         local_lock_irqsave(&memcg_stock.stock_lock, flags);
2302         __refill_stock(memcg, nr_pages);
2303         local_unlock_irqrestore(&memcg_stock.stock_lock, flags);
2304 }
2305
2306 /*
2307  * Drains all per-CPU charge caches for given root_memcg resp. subtree
2308  * of the hierarchy under it.
2309  */
2310 static void drain_all_stock(struct mem_cgroup *root_memcg)
2311 {
2312         int cpu, curcpu;
2313
2314         /* If someone's already draining, avoid adding running more workers. */
2315         if (!mutex_trylock(&percpu_charge_mutex))
2316                 return;
2317         /*
2318          * Notify other cpus that system-wide "drain" is running
2319          * We do not care about races with the cpu hotplug because cpu down
2320          * as well as workers from this path always operate on the local
2321          * per-cpu data. CPU up doesn't touch memcg_stock at all.
2322          */
2323         migrate_disable();
2324         curcpu = smp_processor_id();
2325         for_each_online_cpu(cpu) {
2326                 struct memcg_stock_pcp *stock = &per_cpu(memcg_stock, cpu);
2327                 struct mem_cgroup *memcg;
2328                 bool flush = false;
2329
2330                 rcu_read_lock();
2331                 memcg = stock->cached;
2332                 if (memcg && stock->nr_pages &&
2333                     mem_cgroup_is_descendant(memcg, root_memcg))
2334                         flush = true;
2335                 else if (obj_stock_flush_required(stock, root_memcg))
2336                         flush = true;
2337                 rcu_read_unlock();
2338
2339                 if (flush &&
2340                     !test_and_set_bit(FLUSHING_CACHED_CHARGE, &stock->flags)) {
2341                         if (cpu == curcpu)
2342                                 drain_local_stock(&stock->work);
2343                         else
2344                                 schedule_work_on(cpu, &stock->work);
2345                 }
2346         }
2347         migrate_enable();
2348         mutex_unlock(&percpu_charge_mutex);
2349 }
2350
2351 static int memcg_hotplug_cpu_dead(unsigned int cpu)
2352 {
2353         struct memcg_stock_pcp *stock;
2354
2355         stock = &per_cpu(memcg_stock, cpu);
2356         drain_stock(stock);
2357
2358         return 0;
2359 }
2360
2361 static unsigned long reclaim_high(struct mem_cgroup *memcg,
2362                                   unsigned int nr_pages,
2363                                   gfp_t gfp_mask)
2364 {
2365         unsigned long nr_reclaimed = 0;
2366
2367         do {
2368                 unsigned long pflags;
2369
2370                 if (page_counter_read(&memcg->memory) <=
2371                     READ_ONCE(memcg->memory.high))
2372                         continue;
2373
2374                 memcg_memory_event(memcg, MEMCG_HIGH);
2375
2376                 psi_memstall_enter(&pflags);
2377                 nr_reclaimed += try_to_free_mem_cgroup_pages(memcg, nr_pages,
2378                                                              gfp_mask, true);
2379                 psi_memstall_leave(&pflags);
2380         } while ((memcg = parent_mem_cgroup(memcg)) &&
2381                  !mem_cgroup_is_root(memcg));
2382
2383         return nr_reclaimed;
2384 }
2385
2386 static void high_work_func(struct work_struct *work)
2387 {
2388         struct mem_cgroup *memcg;
2389
2390         memcg = container_of(work, struct mem_cgroup, high_work);
2391         reclaim_high(memcg, MEMCG_CHARGE_BATCH, GFP_KERNEL);
2392 }
2393
2394 /*
2395  * Clamp the maximum sleep time per allocation batch to 2 seconds. This is
2396  * enough to still cause a significant slowdown in most cases, while still
2397  * allowing diagnostics and tracing to proceed without becoming stuck.
2398  */
2399 #define MEMCG_MAX_HIGH_DELAY_JIFFIES (2UL*HZ)
2400
2401 /*
2402  * When calculating the delay, we use these either side of the exponentiation to
2403  * maintain precision and scale to a reasonable number of jiffies (see the table
2404  * below.
2405  *
2406  * - MEMCG_DELAY_PRECISION_SHIFT: Extra precision bits while translating the
2407  *   overage ratio to a delay.
2408  * - MEMCG_DELAY_SCALING_SHIFT: The number of bits to scale down the
2409  *   proposed penalty in order to reduce to a reasonable number of jiffies, and
2410  *   to produce a reasonable delay curve.
2411  *
2412  * MEMCG_DELAY_SCALING_SHIFT just happens to be a number that produces a
2413  * reasonable delay curve compared to precision-adjusted overage, not
2414  * penalising heavily at first, but still making sure that growth beyond the
2415  * limit penalises misbehaviour cgroups by slowing them down exponentially. For
2416  * example, with a high of 100 megabytes:
2417  *
2418  *  +-------+------------------------+
2419  *  | usage | time to allocate in ms |
2420  *  +-------+------------------------+
2421  *  | 100M  |                      0 |
2422  *  | 101M  |                      6 |
2423  *  | 102M  |                     25 |
2424  *  | 103M  |                     57 |
2425  *  | 104M  |                    102 |
2426  *  | 105M  |                    159 |
2427  *  | 106M  |                    230 |
2428  *  | 107M  |                    313 |
2429  *  | 108M  |                    409 |
2430  *  | 109M  |                    518 |
2431  *  | 110M  |                    639 |
2432  *  | 111M  |                    774 |
2433  *  | 112M  |                    921 |
2434  *  | 113M  |                   1081 |
2435  *  | 114M  |                   1254 |
2436  *  | 115M  |                   1439 |
2437  *  | 116M  |                   1638 |
2438  *  | 117M  |                   1849 |
2439  *  | 118M  |                   2000 |
2440  *  | 119M  |                   2000 |
2441  *  | 120M  |                   2000 |
2442  *  +-------+------------------------+
2443  */
2444  #define MEMCG_DELAY_PRECISION_SHIFT 20
2445  #define MEMCG_DELAY_SCALING_SHIFT 14
2446
2447 static u64 calculate_overage(unsigned long usage, unsigned long high)
2448 {
2449         u64 overage;
2450
2451         if (usage <= high)
2452                 return 0;
2453
2454         /*
2455          * Prevent division by 0 in overage calculation by acting as if
2456          * it was a threshold of 1 page
2457          */
2458         high = max(high, 1UL);
2459
2460         overage = usage - high;
2461         overage <<= MEMCG_DELAY_PRECISION_SHIFT;
2462         return div64_u64(overage, high);
2463 }
2464
2465 static u64 mem_find_max_overage(struct mem_cgroup *memcg)
2466 {
2467         u64 overage, max_overage = 0;
2468
2469         do {
2470                 overage = calculate_overage(page_counter_read(&memcg->memory),
2471                                             READ_ONCE(memcg->memory.high));
2472                 max_overage = max(overage, max_overage);
2473         } while ((memcg = parent_mem_cgroup(memcg)) &&
2474                  !mem_cgroup_is_root(memcg));
2475
2476         return max_overage;
2477 }
2478
2479 static u64 swap_find_max_overage(struct mem_cgroup *memcg)
2480 {
2481         u64 overage, max_overage = 0;
2482
2483         do {
2484                 overage = calculate_overage(page_counter_read(&memcg->swap),
2485                                             READ_ONCE(memcg->swap.high));
2486                 if (overage)
2487                         memcg_memory_event(memcg, MEMCG_SWAP_HIGH);
2488                 max_overage = max(overage, max_overage);
2489         } while ((memcg = parent_mem_cgroup(memcg)) &&
2490                  !mem_cgroup_is_root(memcg));
2491
2492         return max_overage;
2493 }
2494
2495 /*
2496  * Get the number of jiffies that we should penalise a mischievous cgroup which
2497  * is exceeding its memory.high by checking both it and its ancestors.
2498  */
2499 static unsigned long calculate_high_delay(struct mem_cgroup *memcg,
2500                                           unsigned int nr_pages,
2501                                           u64 max_overage)
2502 {
2503         unsigned long penalty_jiffies;
2504
2505         if (!max_overage)
2506                 return 0;
2507
2508         /*
2509          * We use overage compared to memory.high to calculate the number of
2510          * jiffies to sleep (penalty_jiffies). Ideally this value should be
2511          * fairly lenient on small overages, and increasingly harsh when the
2512          * memcg in question makes it clear that it has no intention of stopping
2513          * its crazy behaviour, so we exponentially increase the delay based on
2514          * overage amount.
2515          */
2516         penalty_jiffies = max_overage * max_overage * HZ;
2517         penalty_jiffies >>= MEMCG_DELAY_PRECISION_SHIFT;
2518         penalty_jiffies >>= MEMCG_DELAY_SCALING_SHIFT;
2519
2520         /*
2521          * Factor in the task's own contribution to the overage, such that four
2522          * N-sized allocations are throttled approximately the same as one
2523          * 4N-sized allocation.
2524          *
2525          * MEMCG_CHARGE_BATCH pages is nominal, so work out how much smaller or
2526          * larger the current charge patch is than that.
2527          */
2528         return penalty_jiffies * nr_pages / MEMCG_CHARGE_BATCH;
2529 }
2530
2531 /*
2532  * Scheduled by try_charge() to be executed from the userland return path
2533  * and reclaims memory over the high limit.
2534  */
2535 void mem_cgroup_handle_over_high(void)
2536 {
2537         unsigned long penalty_jiffies;
2538         unsigned long pflags;
2539         unsigned long nr_reclaimed;
2540         unsigned int nr_pages = current->memcg_nr_pages_over_high;
2541         int nr_retries = MAX_RECLAIM_RETRIES;
2542         struct mem_cgroup *memcg;
2543         bool in_retry = false;
2544
2545         if (likely(!nr_pages))
2546                 return;
2547
2548         memcg = get_mem_cgroup_from_mm(current->mm);
2549         current->memcg_nr_pages_over_high = 0;
2550
2551 retry_reclaim:
2552         /*
2553          * The allocating task should reclaim at least the batch size, but for
2554          * subsequent retries we only want to do what's necessary to prevent oom
2555          * or breaching resource isolation.
2556          *
2557          * This is distinct from memory.max or page allocator behaviour because
2558          * memory.high is currently batched, whereas memory.max and the page
2559          * allocator run every time an allocation is made.
2560          */
2561         nr_reclaimed = reclaim_high(memcg,
2562                                     in_retry ? SWAP_CLUSTER_MAX : nr_pages,
2563                                     GFP_KERNEL);
2564
2565         /*
2566          * memory.high is breached and reclaim is unable to keep up. Throttle
2567          * allocators proactively to slow down excessive growth.
2568          */
2569         penalty_jiffies = calculate_high_delay(memcg, nr_pages,
2570                                                mem_find_max_overage(memcg));
2571
2572         penalty_jiffies += calculate_high_delay(memcg, nr_pages,
2573                                                 swap_find_max_overage(memcg));
2574
2575         /*
2576          * Clamp the max delay per usermode return so as to still keep the
2577          * application moving forwards and also permit diagnostics, albeit
2578          * extremely slowly.
2579          */
2580         penalty_jiffies = min(penalty_jiffies, MEMCG_MAX_HIGH_DELAY_JIFFIES);
2581
2582         /*
2583          * Don't sleep if the amount of jiffies this memcg owes us is so low
2584          * that it's not even worth doing, in an attempt to be nice to those who
2585          * go only a small amount over their memory.high value and maybe haven't
2586          * been aggressively reclaimed enough yet.
2587          */
2588         if (penalty_jiffies <= HZ / 100)
2589                 goto out;
2590
2591         /*
2592          * If reclaim is making forward progress but we're still over
2593          * memory.high, we want to encourage that rather than doing allocator
2594          * throttling.
2595          */
2596         if (nr_reclaimed || nr_retries--) {
2597                 in_retry = true;
2598                 goto retry_reclaim;
2599         }
2600
2601         /*
2602          * If we exit early, we're guaranteed to die (since
2603          * schedule_timeout_killable sets TASK_KILLABLE). This means we don't
2604          * need to account for any ill-begotten jiffies to pay them off later.
2605          */
2606         psi_memstall_enter(&pflags);
2607         schedule_timeout_killable(penalty_jiffies);
2608         psi_memstall_leave(&pflags);
2609
2610 out:
2611         css_put(&memcg->css);
2612 }
2613
2614 static int try_charge_memcg(struct mem_cgroup *memcg, gfp_t gfp_mask,
2615                         unsigned int nr_pages)
2616 {
2617         unsigned int batch = max(MEMCG_CHARGE_BATCH, nr_pages);
2618         int nr_retries = MAX_RECLAIM_RETRIES;
2619         struct mem_cgroup *mem_over_limit;
2620         struct page_counter *counter;
2621         enum oom_status oom_status;
2622         unsigned long nr_reclaimed;
2623         bool passed_oom = false;
2624         bool may_swap = true;
2625         bool drained = false;
2626         unsigned long pflags;
2627
2628 retry:
2629         if (consume_stock(memcg, nr_pages))
2630                 return 0;
2631
2632         if (!do_memsw_account() ||
2633             page_counter_try_charge(&memcg->memsw, batch, &counter)) {
2634                 if (page_counter_try_charge(&memcg->memory, batch, &counter))
2635                         goto done_restock;
2636                 if (do_memsw_account())
2637                         page_counter_uncharge(&memcg->memsw, batch);
2638                 mem_over_limit = mem_cgroup_from_counter(counter, memory);
2639         } else {
2640                 mem_over_limit = mem_cgroup_from_counter(counter, memsw);
2641                 may_swap = false;
2642         }
2643
2644         if (batch > nr_pages) {
2645                 batch = nr_pages;
2646                 goto retry;
2647         }
2648
2649         /*
2650          * Memcg doesn't have a dedicated reserve for atomic
2651          * allocations. But like the global atomic pool, we need to
2652          * put the burden of reclaim on regular allocation requests
2653          * and let these go through as privileged allocations.
2654          */
2655         if (gfp_mask & __GFP_ATOMIC)
2656                 goto force;
2657
2658         /*
2659          * Prevent unbounded recursion when reclaim operations need to
2660          * allocate memory. This might exceed the limits temporarily,
2661          * but we prefer facilitating memory reclaim and getting back
2662          * under the limit over triggering OOM kills in these cases.
2663          */
2664         if (unlikely(current->flags & PF_MEMALLOC))
2665                 goto force;
2666
2667         if (unlikely(task_in_memcg_oom(current)))
2668                 goto nomem;
2669
2670         if (!gfpflags_allow_blocking(gfp_mask))
2671                 goto nomem;
2672
2673         memcg_memory_event(mem_over_limit, MEMCG_MAX);
2674
2675         psi_memstall_enter(&pflags);
2676         nr_reclaimed = try_to_free_mem_cgroup_pages(mem_over_limit, nr_pages,
2677                                                     gfp_mask, may_swap);
2678         psi_memstall_leave(&pflags);
2679
2680         if (mem_cgroup_margin(mem_over_limit) >= nr_pages)
2681                 goto retry;
2682
2683         if (!drained) {
2684                 drain_all_stock(mem_over_limit);
2685                 drained = true;
2686                 goto retry;
2687         }
2688
2689         if (gfp_mask & __GFP_NORETRY)
2690                 goto nomem;
2691         /*
2692          * Even though the limit is exceeded at this point, reclaim
2693          * may have been able to free some pages.  Retry the charge
2694          * before killing the task.
2695          *
2696          * Only for regular pages, though: huge pages are rather
2697          * unlikely to succeed so close to the limit, and we fall back
2698          * to regular pages anyway in case of failure.
2699          */
2700         if (nr_reclaimed && nr_pages <= (1 << PAGE_ALLOC_COSTLY_ORDER))
2701                 goto retry;
2702         /*
2703          * At task move, charge accounts can be doubly counted. So, it's
2704          * better to wait until the end of task_move if something is going on.
2705          */
2706         if (mem_cgroup_wait_acct_move(mem_over_limit))
2707                 goto retry;
2708
2709         if (nr_retries--)
2710                 goto retry;
2711
2712         if (gfp_mask & __GFP_RETRY_MAYFAIL)
2713                 goto nomem;
2714
2715         /* Avoid endless loop for tasks bypassed by the oom killer */
2716         if (passed_oom && task_is_dying())
2717                 goto nomem;
2718
2719         /*
2720          * keep retrying as long as the memcg oom killer is able to make
2721          * a forward progress or bypass the charge if the oom killer
2722          * couldn't make any progress.
2723          */
2724         oom_status = mem_cgroup_oom(mem_over_limit, gfp_mask,
2725                        get_order(nr_pages * PAGE_SIZE));
2726         if (oom_status == OOM_SUCCESS) {
2727                 passed_oom = true;
2728                 nr_retries = MAX_RECLAIM_RETRIES;
2729                 goto retry;
2730         }
2731 nomem:
2732         if (!(gfp_mask & __GFP_NOFAIL))
2733                 return -ENOMEM;
2734 force:
2735         /*
2736          * The allocation either can't fail or will lead to more memory
2737          * being freed very soon.  Allow memory usage go over the limit
2738          * temporarily by force charging it.
2739          */
2740         page_counter_charge(&memcg->memory, nr_pages);
2741         if (do_memsw_account())
2742                 page_counter_charge(&memcg->memsw, nr_pages);
2743
2744         return 0;
2745
2746 done_restock:
2747         if (batch > nr_pages)
2748                 refill_stock(memcg, batch - nr_pages);
2749
2750         /*
2751          * If the hierarchy is above the normal consumption range, schedule
2752          * reclaim on returning to userland.  We can perform reclaim here
2753          * if __GFP_RECLAIM but let's always punt for simplicity and so that
2754          * GFP_KERNEL can consistently be used during reclaim.  @memcg is
2755          * not recorded as it most likely matches current's and won't
2756          * change in the meantime.  As high limit is checked again before
2757          * reclaim, the cost of mismatch is negligible.
2758          */
2759         do {
2760                 bool mem_high, swap_high;
2761
2762                 mem_high = page_counter_read(&memcg->memory) >
2763                         READ_ONCE(memcg->memory.high);
2764                 swap_high = page_counter_read(&memcg->swap) >
2765                         READ_ONCE(memcg->swap.high);
2766
2767                 /* Don't bother a random interrupted task */
2768                 if (in_interrupt()) {
2769                         if (mem_high) {
2770                                 schedule_work(&memcg->high_work);
2771                                 break;
2772                         }
2773                         continue;
2774                 }
2775
2776                 if (mem_high || swap_high) {
2777                         /*
2778                          * The allocating tasks in this cgroup will need to do
2779                          * reclaim or be throttled to prevent further growth
2780                          * of the memory or swap footprints.
2781                          *
2782                          * Target some best-effort fairness between the tasks,
2783                          * and distribute reclaim work and delay penalties
2784                          * based on how much each task is actually allocating.
2785                          */
2786                         current->memcg_nr_pages_over_high += batch;
2787                         set_notify_resume(current);
2788                         break;
2789                 }
2790         } while ((memcg = parent_mem_cgroup(memcg)));
2791
2792         return 0;
2793 }
2794
2795 static inline int try_charge(struct mem_cgroup *memcg, gfp_t gfp_mask,
2796                              unsigned int nr_pages)
2797 {
2798         if (mem_cgroup_is_root(memcg))
2799                 return 0;
2800
2801         return try_charge_memcg(memcg, gfp_mask, nr_pages);
2802 }
2803
2804 #if defined(CONFIG_MEMCG_KMEM) || defined(CONFIG_MMU)
2805 static void cancel_charge(struct mem_cgroup *memcg, unsigned int nr_pages)
2806 {
2807         if (mem_cgroup_is_root(memcg))
2808                 return;
2809
2810         page_counter_uncharge(&memcg->memory, nr_pages);
2811         if (do_memsw_account())
2812                 page_counter_uncharge(&memcg->memsw, nr_pages);
2813 }
2814 #endif
2815
2816 static void commit_charge(struct page *page, struct mem_cgroup *memcg)
2817 {
2818         VM_BUG_ON_PAGE(page_memcg(page), page);
2819         /*
2820          * Any of the following ensures page's memcg stability:
2821          *
2822          * - the page lock
2823          * - LRU isolation
2824          * - lock_page_memcg()
2825          * - exclusive reference
2826          */
2827         page->memcg_data = (unsigned long)memcg;
2828 }
2829
2830 static struct mem_cgroup *get_mem_cgroup_from_objcg(struct obj_cgroup *objcg)
2831 {
2832         struct mem_cgroup *memcg;
2833
2834         rcu_read_lock();
2835 retry:
2836         memcg = obj_cgroup_memcg(objcg);
2837         if (unlikely(!css_tryget(&memcg->css)))
2838                 goto retry;
2839         rcu_read_unlock();
2840
2841         return memcg;
2842 }
2843
2844 #ifdef CONFIG_MEMCG_KMEM
2845 /*
2846  * The allocated objcg pointers array is not accounted directly.
2847  * Moreover, it should not come from DMA buffer and is not readily
2848  * reclaimable. So those GFP bits should be masked off.
2849  */
2850 #define OBJCGS_CLEAR_MASK       (__GFP_DMA | __GFP_RECLAIMABLE | __GFP_ACCOUNT)
2851
2852 int memcg_alloc_page_obj_cgroups(struct page *page, struct kmem_cache *s,
2853                                  gfp_t gfp, bool new_page)
2854 {
2855         unsigned int objects = objs_per_slab_page(s, page);
2856         unsigned long memcg_data;
2857         void *vec;
2858
2859         gfp &= ~OBJCGS_CLEAR_MASK;
2860         vec = kcalloc_node(objects, sizeof(struct obj_cgroup *), gfp,
2861                            page_to_nid(page));
2862         if (!vec)
2863                 return -ENOMEM;
2864
2865         memcg_data = (unsigned long) vec | MEMCG_DATA_OBJCGS;
2866         if (new_page) {
2867                 /*
2868                  * If the slab page is brand new and nobody can yet access
2869                  * it's memcg_data, no synchronization is required and
2870                  * memcg_data can be simply assigned.
2871                  */
2872                 page->memcg_data = memcg_data;
2873         } else if (cmpxchg(&page->memcg_data, 0, memcg_data)) {
2874                 /*
2875                  * If the slab page is already in use, somebody can allocate
2876                  * and assign obj_cgroups in parallel. In this case the existing
2877                  * objcg vector should be reused.
2878                  */
2879                 kfree(vec);
2880                 return 0;
2881         }
2882
2883         kmemleak_not_leak(vec);
2884         return 0;
2885 }
2886
2887 /*
2888  * Returns a pointer to the memory cgroup to which the kernel object is charged.
2889  *
2890  * A passed kernel object can be a slab object or a generic kernel page, so
2891  * different mechanisms for getting the memory cgroup pointer should be used.
2892  * In certain cases (e.g. kernel stacks or large kmallocs with SLUB) the caller
2893  * can not know for sure how the kernel object is implemented.
2894  * mem_cgroup_from_obj() can be safely used in such cases.
2895  *
2896  * The caller must ensure the memcg lifetime, e.g. by taking rcu_read_lock(),
2897  * cgroup_mutex, etc.
2898  */
2899 struct mem_cgroup *mem_cgroup_from_obj(void *p)
2900 {
2901         struct page *page;
2902
2903         if (mem_cgroup_disabled())
2904                 return NULL;
2905
2906         page = virt_to_head_page(p);
2907
2908         /*
2909          * Slab objects are accounted individually, not per-page.
2910          * Memcg membership data for each individual object is saved in
2911          * the page->obj_cgroups.
2912          */
2913         if (page_objcgs_check(page)) {
2914                 struct obj_cgroup *objcg;
2915                 unsigned int off;
2916
2917                 off = obj_to_index(page->slab_cache, page, p);
2918                 objcg = page_objcgs(page)[off];
2919                 if (objcg)
2920                         return obj_cgroup_memcg(objcg);
2921
2922                 return NULL;
2923         }
2924
2925         /*
2926          * page_memcg_check() is used here, because page_has_obj_cgroups()
2927          * check above could fail because the object cgroups vector wasn't set
2928          * at that moment, but it can be set concurrently.
2929          * page_memcg_check(page) will guarantee that a proper memory
2930          * cgroup pointer or NULL will be returned.
2931          */
2932         return page_memcg_check(page);
2933 }
2934
2935 __always_inline struct obj_cgroup *get_obj_cgroup_from_current(void)
2936 {
2937         struct obj_cgroup *objcg = NULL;
2938         struct mem_cgroup *memcg;
2939
2940         if (memcg_kmem_bypass())
2941                 return NULL;
2942
2943         rcu_read_lock();
2944         if (unlikely(active_memcg()))
2945                 memcg = active_memcg();
2946         else
2947                 memcg = mem_cgroup_from_task(current);
2948
2949         for (; memcg != root_mem_cgroup; memcg = parent_mem_cgroup(memcg)) {
2950                 objcg = rcu_dereference(memcg->objcg);
2951                 if (objcg && obj_cgroup_tryget(objcg))
2952                         break;
2953                 objcg = NULL;
2954         }
2955         rcu_read_unlock();
2956
2957         return objcg;
2958 }
2959
2960 static int memcg_alloc_cache_id(void)
2961 {
2962         int id, size;
2963         int err;
2964
2965         id = ida_simple_get(&memcg_cache_ida,
2966                             0, MEMCG_CACHES_MAX_SIZE, GFP_KERNEL);
2967         if (id < 0)
2968                 return id;
2969
2970         if (id < memcg_nr_cache_ids)
2971                 return id;
2972
2973         /*
2974          * There's no space for the new id in memcg_caches arrays,
2975          * so we have to grow them.
2976          */
2977         down_write(&memcg_cache_ids_sem);
2978
2979         size = 2 * (id + 1);
2980         if (size < MEMCG_CACHES_MIN_SIZE)
2981                 size = MEMCG_CACHES_MIN_SIZE;
2982         else if (size > MEMCG_CACHES_MAX_SIZE)
2983                 size = MEMCG_CACHES_MAX_SIZE;
2984
2985         err = memcg_update_all_list_lrus(size);
2986         if (!err)
2987                 memcg_nr_cache_ids = size;
2988
2989         up_write(&memcg_cache_ids_sem);
2990
2991         if (err) {
2992                 ida_simple_remove(&memcg_cache_ida, id);
2993                 return err;
2994         }
2995         return id;
2996 }
2997
2998 static void memcg_free_cache_id(int id)
2999 {
3000         ida_simple_remove(&memcg_cache_ida, id);
3001 }
3002
3003 /*
3004  * obj_cgroup_uncharge_pages: uncharge a number of kernel pages from a objcg
3005  * @objcg: object cgroup to uncharge
3006  * @nr_pages: number of pages to uncharge
3007  */
3008 static void obj_cgroup_uncharge_pages(struct obj_cgroup *objcg,
3009                                       unsigned int nr_pages)
3010 {
3011         struct mem_cgroup *memcg;
3012
3013         memcg = get_mem_cgroup_from_objcg(objcg);
3014
3015         if (!cgroup_subsys_on_dfl(memory_cgrp_subsys))
3016                 page_counter_uncharge(&memcg->kmem, nr_pages);
3017         refill_stock(memcg, nr_pages);
3018
3019         css_put(&memcg->css);
3020 }
3021
3022 /*
3023  * obj_cgroup_charge_pages: charge a number of kernel pages to a objcg
3024  * @objcg: object cgroup to charge
3025  * @gfp: reclaim mode
3026  * @nr_pages: number of pages to charge
3027  *
3028  * Returns 0 on success, an error code on failure.
3029  */
3030 static int obj_cgroup_charge_pages(struct obj_cgroup *objcg, gfp_t gfp,
3031                                    unsigned int nr_pages)
3032 {
3033         struct page_counter *counter;
3034         struct mem_cgroup *memcg;
3035         int ret;
3036
3037         memcg = get_mem_cgroup_from_objcg(objcg);
3038
3039         ret = try_charge_memcg(memcg, gfp, nr_pages);
3040         if (ret)
3041                 goto out;
3042
3043         if (!cgroup_subsys_on_dfl(memory_cgrp_subsys) &&
3044             !page_counter_try_charge(&memcg->kmem, nr_pages, &counter)) {
3045
3046                 /*
3047                  * Enforce __GFP_NOFAIL allocation because callers are not
3048                  * prepared to see failures and likely do not have any failure
3049                  * handling code.
3050                  */
3051                 if (gfp & __GFP_NOFAIL) {
3052                         page_counter_charge(&memcg->kmem, nr_pages);
3053                         goto out;
3054                 }
3055                 cancel_charge(memcg, nr_pages);
3056                 ret = -ENOMEM;
3057         }
3058 out:
3059         css_put(&memcg->css);
3060
3061         return ret;
3062 }
3063
3064 /**
3065  * __memcg_kmem_charge_page: charge a kmem page to the current memory cgroup
3066  * @page: page to charge
3067  * @gfp: reclaim mode
3068  * @order: allocation order
3069  *
3070  * Returns 0 on success, an error code on failure.
3071  */
3072 int __memcg_kmem_charge_page(struct page *page, gfp_t gfp, int order)
3073 {
3074         struct obj_cgroup *objcg;
3075         int ret = 0;
3076
3077         objcg = get_obj_cgroup_from_current();
3078         if (objcg) {
3079                 ret = obj_cgroup_charge_pages(objcg, gfp, 1 << order);
3080                 if (!ret) {
3081                         page->memcg_data = (unsigned long)objcg |
3082                                 MEMCG_DATA_KMEM;
3083                         return 0;
3084                 }
3085                 obj_cgroup_put(objcg);
3086         }
3087         return ret;
3088 }
3089
3090 /**
3091  * __memcg_kmem_uncharge_page: uncharge a kmem page
3092  * @page: page to uncharge
3093  * @order: allocation order
3094  */
3095 void __memcg_kmem_uncharge_page(struct page *page, int order)
3096 {
3097         struct obj_cgroup *objcg;
3098         unsigned int nr_pages = 1 << order;
3099
3100         if (!PageMemcgKmem(page))
3101                 return;
3102
3103         objcg = __page_objcg(page);
3104         obj_cgroup_uncharge_pages(objcg, nr_pages);
3105         page->memcg_data = 0;
3106         obj_cgroup_put(objcg);
3107 }
3108
3109 void mod_objcg_state(struct obj_cgroup *objcg, struct pglist_data *pgdat,
3110                      enum node_stat_item idx, int nr)
3111 {
3112         struct memcg_stock_pcp *stock;
3113         struct obj_cgroup *old = NULL;
3114         unsigned long flags;
3115         int *bytes;
3116
3117         local_lock_irqsave(&memcg_stock.stock_lock, flags);
3118         stock = this_cpu_ptr(&memcg_stock);
3119
3120         /*
3121          * Save vmstat data in stock and skip vmstat array update unless
3122          * accumulating over a page of vmstat data or when pgdat or idx
3123          * changes.
3124          */
3125         if (stock->cached_objcg != objcg) {
3126                 old = drain_obj_stock(stock);
3127                 obj_cgroup_get(objcg);
3128                 stock->nr_bytes = atomic_read(&objcg->nr_charged_bytes)
3129                                 ? atomic_xchg(&objcg->nr_charged_bytes, 0) : 0;
3130                 stock->cached_objcg = objcg;
3131                 stock->cached_pgdat = pgdat;
3132         } else if (stock->cached_pgdat != pgdat) {
3133                 /* Flush the existing cached vmstat data */
3134                 struct pglist_data *oldpg = stock->cached_pgdat;
3135
3136                 if (stock->nr_slab_reclaimable_b) {
3137                         mod_objcg_mlstate(objcg, oldpg, NR_SLAB_RECLAIMABLE_B,
3138                                           stock->nr_slab_reclaimable_b);
3139                         stock->nr_slab_reclaimable_b = 0;
3140                 }
3141                 if (stock->nr_slab_unreclaimable_b) {
3142                         mod_objcg_mlstate(objcg, oldpg, NR_SLAB_UNRECLAIMABLE_B,
3143                                           stock->nr_slab_unreclaimable_b);
3144                         stock->nr_slab_unreclaimable_b = 0;
3145                 }
3146                 stock->cached_pgdat = pgdat;
3147         }
3148
3149         bytes = (idx == NR_SLAB_RECLAIMABLE_B) ? &stock->nr_slab_reclaimable_b
3150                                                : &stock->nr_slab_unreclaimable_b;
3151         /*
3152          * Even for large object >= PAGE_SIZE, the vmstat data will still be
3153          * cached locally at least once before pushing it out.
3154          */
3155         if (!*bytes) {
3156                 *bytes = nr;
3157                 nr = 0;
3158         } else {
3159                 *bytes += nr;
3160                 if (abs(*bytes) > PAGE_SIZE) {
3161                         nr = *bytes;
3162                         *bytes = 0;
3163                 } else {
3164                         nr = 0;
3165                 }
3166         }
3167         if (nr)
3168                 mod_objcg_mlstate(objcg, pgdat, idx, nr);
3169
3170         local_unlock_irqrestore(&memcg_stock.stock_lock, flags);
3171         if (old)
3172                 obj_cgroup_put(old);
3173 }
3174
3175 static bool consume_obj_stock(struct obj_cgroup *objcg, unsigned int nr_bytes)
3176 {
3177         struct memcg_stock_pcp *stock;
3178         unsigned long flags;
3179         bool ret = false;
3180
3181         local_lock_irqsave(&memcg_stock.stock_lock, flags);
3182
3183         stock = this_cpu_ptr(&memcg_stock);
3184         if (objcg == stock->cached_objcg && stock->nr_bytes >= nr_bytes) {
3185                 stock->nr_bytes -= nr_bytes;
3186                 ret = true;
3187         }
3188
3189         local_unlock_irqrestore(&memcg_stock.stock_lock, flags);
3190
3191         return ret;
3192 }
3193
3194 static struct obj_cgroup *drain_obj_stock(struct memcg_stock_pcp *stock)
3195 {
3196         struct obj_cgroup *old = stock->cached_objcg;
3197
3198         if (!old)
3199                 return NULL;
3200
3201         if (stock->nr_bytes) {
3202                 unsigned int nr_pages = stock->nr_bytes >> PAGE_SHIFT;
3203                 unsigned int nr_bytes = stock->nr_bytes & (PAGE_SIZE - 1);
3204
3205                 if (nr_pages) {
3206                         struct mem_cgroup *memcg;
3207
3208                         memcg = get_mem_cgroup_from_objcg(old);
3209
3210                         if (!cgroup_subsys_on_dfl(memory_cgrp_subsys))
3211                                 page_counter_uncharge(&memcg->kmem, nr_pages);
3212
3213                         __refill_stock(memcg, nr_pages);
3214
3215                         css_put(&memcg->css);
3216                 }
3217
3218                 /*
3219                  * The leftover is flushed to the centralized per-memcg value.
3220                  * On the next attempt to refill obj stock it will be moved
3221                  * to a per-cpu stock (probably, on an other CPU), see
3222                  * refill_obj_stock().
3223                  *
3224                  * How often it's flushed is a trade-off between the memory
3225                  * limit enforcement accuracy and potential CPU contention,
3226                  * so it might be changed in the future.
3227                  */
3228                 atomic_add(nr_bytes, &old->nr_charged_bytes);
3229                 stock->nr_bytes = 0;
3230         }
3231
3232         /*
3233          * Flush the vmstat data in current stock
3234          */
3235         if (stock->nr_slab_reclaimable_b || stock->nr_slab_unreclaimable_b) {
3236                 if (stock->nr_slab_reclaimable_b) {
3237                         mod_objcg_mlstate(old, stock->cached_pgdat,
3238                                           NR_SLAB_RECLAIMABLE_B,
3239                                           stock->nr_slab_reclaimable_b);
3240                         stock->nr_slab_reclaimable_b = 0;
3241                 }
3242                 if (stock->nr_slab_unreclaimable_b) {
3243                         mod_objcg_mlstate(old, stock->cached_pgdat,
3244                                           NR_SLAB_UNRECLAIMABLE_B,
3245                                           stock->nr_slab_unreclaimable_b);
3246                         stock->nr_slab_unreclaimable_b = 0;
3247                 }
3248                 stock->cached_pgdat = NULL;
3249         }
3250
3251         stock->cached_objcg = NULL;
3252         /*
3253          * The `old' objects needs to be released by the caller via
3254          * obj_cgroup_put() outside of memcg_stock_pcp::stock_lock.
3255          */
3256         return old;
3257 }
3258
3259 static bool obj_stock_flush_required(struct memcg_stock_pcp *stock,
3260                                      struct mem_cgroup *root_memcg)
3261 {
3262         struct mem_cgroup *memcg;
3263
3264         if (stock->cached_objcg) {
3265                 memcg = obj_cgroup_memcg(stock->cached_objcg);
3266                 if (memcg && mem_cgroup_is_descendant(memcg, root_memcg))
3267                         return true;
3268         }
3269
3270         return false;
3271 }
3272
3273 static void refill_obj_stock(struct obj_cgroup *objcg, unsigned int nr_bytes,
3274                              bool allow_uncharge)
3275 {
3276         struct memcg_stock_pcp *stock;
3277         struct obj_cgroup *old = NULL;
3278         unsigned long flags;
3279         unsigned int nr_pages = 0;
3280
3281         local_lock_irqsave(&memcg_stock.stock_lock, flags);
3282
3283         stock = this_cpu_ptr(&memcg_stock);
3284         if (stock->cached_objcg != objcg) { /* reset if necessary */
3285                 old = drain_obj_stock(stock);
3286                 obj_cgroup_get(objcg);
3287                 stock->cached_objcg = objcg;
3288                 stock->nr_bytes = atomic_read(&objcg->nr_charged_bytes)
3289                                 ? atomic_xchg(&objcg->nr_charged_bytes, 0) : 0;
3290                 allow_uncharge = true;  /* Allow uncharge when objcg changes */
3291         }
3292         stock->nr_bytes += nr_bytes;
3293
3294         if (allow_uncharge && (stock->nr_bytes > PAGE_SIZE)) {
3295                 nr_pages = stock->nr_bytes >> PAGE_SHIFT;
3296                 stock->nr_bytes &= (PAGE_SIZE - 1);
3297         }
3298
3299         local_unlock_irqrestore(&memcg_stock.stock_lock, flags);
3300         if (old)
3301                 obj_cgroup_put(old);
3302
3303         if (nr_pages)
3304                 obj_cgroup_uncharge_pages(objcg, nr_pages);
3305 }
3306
3307 int obj_cgroup_charge(struct obj_cgroup *objcg, gfp_t gfp, size_t size)
3308 {
3309         unsigned int nr_pages, nr_bytes;
3310         int ret;
3311
3312         if (consume_obj_stock(objcg, size))
3313                 return 0;
3314
3315         /*
3316          * In theory, objcg->nr_charged_bytes can have enough
3317          * pre-charged bytes to satisfy the allocation. However,
3318          * flushing objcg->nr_charged_bytes requires two atomic
3319          * operations, and objcg->nr_charged_bytes can't be big.
3320          * The shared objcg->nr_charged_bytes can also become a
3321          * performance bottleneck if all tasks of the same memcg are
3322          * trying to update it. So it's better to ignore it and try
3323          * grab some new pages. The stock's nr_bytes will be flushed to
3324          * objcg->nr_charged_bytes later on when objcg changes.
3325          *
3326          * The stock's nr_bytes may contain enough pre-charged bytes
3327          * to allow one less page from being charged, but we can't rely
3328          * on the pre-charged bytes not being changed outside of
3329          * consume_obj_stock() or refill_obj_stock(). So ignore those
3330          * pre-charged bytes as well when charging pages. To avoid a
3331          * page uncharge right after a page charge, we set the
3332          * allow_uncharge flag to false when calling refill_obj_stock()
3333          * to temporarily allow the pre-charged bytes to exceed the page
3334          * size limit. The maximum reachable value of the pre-charged
3335          * bytes is (sizeof(object) + PAGE_SIZE - 2) if there is no data
3336          * race.
3337          */
3338         nr_pages = size >> PAGE_SHIFT;
3339         nr_bytes = size & (PAGE_SIZE - 1);
3340
3341         if (nr_bytes)
3342                 nr_pages += 1;
3343
3344         ret = obj_cgroup_charge_pages(objcg, gfp, nr_pages);
3345         if (!ret && nr_bytes)
3346                 refill_obj_stock(objcg, PAGE_SIZE - nr_bytes, false);
3347
3348         return ret;
3349 }
3350
3351 void obj_cgroup_uncharge(struct obj_cgroup *objcg, size_t size)
3352 {
3353         refill_obj_stock(objcg, size, true);
3354 }
3355
3356 #endif /* CONFIG_MEMCG_KMEM */
3357
3358 /*
3359  * Because page_memcg(head) is not set on tails, set it now.
3360  */
3361 void split_page_memcg(struct page *head, unsigned int nr)
3362 {
3363         struct mem_cgroup *memcg = page_memcg(head);
3364         int i;
3365
3366         if (mem_cgroup_disabled() || !memcg)
3367                 return;
3368
3369         for (i = 1; i < nr; i++)
3370                 head[i].memcg_data = head->memcg_data;
3371
3372         if (PageMemcgKmem(head))
3373                 obj_cgroup_get_many(__page_objcg(head), nr - 1);
3374         else
3375                 css_get_many(&memcg->css, nr - 1);
3376 }
3377
3378 #ifdef CONFIG_MEMCG_SWAP
3379 /**
3380  * mem_cgroup_move_swap_account - move swap charge and swap_cgroup's record.
3381  * @entry: swap entry to be moved
3382  * @from:  mem_cgroup which the entry is moved from
3383  * @to:  mem_cgroup which the entry is moved to
3384  *
3385  * It succeeds only when the swap_cgroup's record for this entry is the same
3386  * as the mem_cgroup's id of @from.
3387  *
3388  * Returns 0 on success, -EINVAL on failure.
3389  *
3390  * The caller must have charged to @to, IOW, called page_counter_charge() about
3391  * both res and memsw, and called css_get().
3392  */
3393 static int mem_cgroup_move_swap_account(swp_entry_t entry,
3394                                 struct mem_cgroup *from, struct mem_cgroup *to)
3395 {
3396         unsigned short old_id, new_id;
3397
3398         old_id = mem_cgroup_id(from);
3399         new_id = mem_cgroup_id(to);
3400
3401         if (swap_cgroup_cmpxchg(entry, old_id, new_id) == old_id) {
3402                 mod_memcg_state(from, MEMCG_SWAP, -1);
3403                 mod_memcg_state(to, MEMCG_SWAP, 1);
3404                 return 0;
3405         }
3406         return -EINVAL;
3407 }
3408 #else
3409 static inline int mem_cgroup_move_swap_account(swp_entry_t entry,
3410                                 struct mem_cgroup *from, struct mem_cgroup *to)
3411 {
3412         return -EINVAL;
3413 }
3414 #endif
3415
3416 static DEFINE_MUTEX(memcg_max_mutex);
3417
3418 static int mem_cgroup_resize_max(struct mem_cgroup *memcg,
3419                                  unsigned long max, bool memsw)
3420 {
3421         bool enlarge = false;
3422         bool drained = false;
3423         int ret;
3424         bool limits_invariant;
3425         struct page_counter *counter = memsw ? &memcg->memsw : &memcg->memory;
3426
3427         do {
3428                 if (signal_pending(current)) {
3429                         ret = -EINTR;
3430                         break;
3431                 }
3432
3433                 mutex_lock(&memcg_max_mutex);
3434                 /*
3435                  * Make sure that the new limit (memsw or memory limit) doesn't
3436                  * break our basic invariant rule memory.max <= memsw.max.
3437                  */
3438                 limits_invariant = memsw ? max >= READ_ONCE(memcg->memory.max) :
3439                                            max <= memcg->memsw.max;
3440                 if (!limits_invariant) {
3441                         mutex_unlock(&memcg_max_mutex);
3442                         ret = -EINVAL;
3443                         break;
3444                 }
3445                 if (max > counter->max)
3446                         enlarge = true;
3447                 ret = page_counter_set_max(counter, max);
3448                 mutex_unlock(&memcg_max_mutex);
3449
3450                 if (!ret)
3451                         break;
3452
3453                 if (!drained) {
3454                         drain_all_stock(memcg);
3455                         drained = true;
3456                         continue;
3457                 }
3458
3459                 if (!try_to_free_mem_cgroup_pages(memcg, 1,
3460                                         GFP_KERNEL, !memsw)) {
3461                         ret = -EBUSY;
3462                         break;
3463                 }
3464         } while (true);
3465
3466         if (!ret && enlarge)
3467                 memcg_oom_recover(memcg);
3468
3469         return ret;
3470 }
3471
3472 unsigned long mem_cgroup_soft_limit_reclaim(pg_data_t *pgdat, int order,
3473                                             gfp_t gfp_mask,
3474                                             unsigned long *total_scanned)
3475 {
3476         unsigned long nr_reclaimed = 0;
3477         struct mem_cgroup_per_node *mz, *next_mz = NULL;
3478         unsigned long reclaimed;
3479         int loop = 0;
3480         struct mem_cgroup_tree_per_node *mctz;
3481         unsigned long excess;
3482         unsigned long nr_scanned;
3483
3484         if (order > 0)
3485                 return 0;
3486
3487         mctz = soft_limit_tree_node(pgdat->node_id);
3488
3489         /*
3490          * Do not even bother to check the largest node if the root
3491          * is empty. Do it lockless to prevent lock bouncing. Races
3492          * are acceptable as soft limit is best effort anyway.
3493          */
3494         if (!mctz || RB_EMPTY_ROOT(&mctz->rb_root))
3495                 return 0;
3496
3497         /*
3498          * This loop can run a while, specially if mem_cgroup's continuously
3499          * keep exceeding their soft limit and putting the system under
3500          * pressure
3501          */
3502         do {
3503                 if (next_mz)
3504                         mz = next_mz;
3505                 else
3506                         mz = mem_cgroup_largest_soft_limit_node(mctz);
3507                 if (!mz)
3508                         break;
3509
3510                 nr_scanned = 0;
3511                 reclaimed = mem_cgroup_soft_reclaim(mz->memcg, pgdat,
3512                                                     gfp_mask, &nr_scanned);
3513                 nr_reclaimed += reclaimed;
3514                 *total_scanned += nr_scanned;
3515                 spin_lock_irq(&mctz->lock);
3516                 __mem_cgroup_remove_exceeded(mz, mctz);
3517
3518                 /*
3519                  * If we failed to reclaim anything from this memory cgroup
3520                  * it is time to move on to the next cgroup
3521                  */
3522                 next_mz = NULL;
3523                 if (!reclaimed)
3524                         next_mz = __mem_cgroup_largest_soft_limit_node(mctz);
3525
3526                 excess = soft_limit_excess(mz->memcg);
3527                 /*
3528                  * One school of thought says that we should not add
3529                  * back the node to the tree if reclaim returns 0.
3530                  * But our reclaim could return 0, simply because due
3531                  * to priority we are exposing a smaller subset of
3532                  * memory to reclaim from. Consider this as a longer
3533                  * term TODO.
3534                  */
3535                 /* If excess == 0, no tree ops */
3536                 __mem_cgroup_insert_exceeded(mz, mctz, excess);
3537                 spin_unlock_irq(&mctz->lock);
3538                 css_put(&mz->memcg->css);
3539                 loop++;
3540                 /*
3541                  * Could not reclaim anything and there are no more
3542                  * mem cgroups to try or we seem to be looping without
3543                  * reclaiming anything.
3544                  */
3545                 if (!nr_reclaimed &&
3546                         (next_mz == NULL ||
3547                         loop > MEM_CGROUP_MAX_SOFT_LIMIT_RECLAIM_LOOPS))
3548                         break;
3549         } while (!nr_reclaimed);
3550         if (next_mz)
3551                 css_put(&next_mz->memcg->css);
3552         return nr_reclaimed;
3553 }
3554
3555 /*
3556  * Reclaims as many pages from the given memcg as possible.
3557  *
3558  * Caller is responsible for holding css reference for memcg.
3559  */
3560 static int mem_cgroup_force_empty(struct mem_cgroup *memcg)
3561 {
3562         int nr_retries = MAX_RECLAIM_RETRIES;
3563
3564         /* we call try-to-free pages for make this cgroup empty */
3565         lru_add_drain_all();
3566
3567         drain_all_stock(memcg);
3568
3569         /* try to free all pages in this cgroup */
3570         while (nr_retries && page_counter_read(&memcg->memory)) {
3571                 int progress;
3572
3573                 if (signal_pending(current))
3574                         return -EINTR;
3575
3576                 progress = try_to_free_mem_cgroup_pages(memcg, 1,
3577                                                         GFP_KERNEL, true);
3578                 if (!progress) {
3579                         nr_retries--;
3580                         /* maybe some writeback is necessary */
3581                         congestion_wait(BLK_RW_ASYNC, HZ/10);
3582                 }
3583
3584         }
3585
3586         return 0;
3587 }
3588
3589 static ssize_t mem_cgroup_force_empty_write(struct kernfs_open_file *of,
3590                                             char *buf, size_t nbytes,
3591                                             loff_t off)
3592 {
3593         struct mem_cgroup *memcg = mem_cgroup_from_css(of_css(of));
3594
3595         if (mem_cgroup_is_root(memcg))
3596                 return -EINVAL;
3597         return mem_cgroup_force_empty(memcg) ?: nbytes;
3598 }
3599
3600 #ifdef CONFIG_MEMCG_SWAP
3601 static int mem_cgroup_force_reclaim(struct cgroup_subsys_state *css,
3602                                struct cftype *cft, u64 val)
3603 {
3604         struct mem_cgroup *memcg = mem_cgroup_from_css(css);
3605         unsigned long nr_to_reclaim = val;
3606         unsigned long total = 0;
3607         int loop;
3608
3609         for (loop = 0; loop < MEM_CGROUP_MAX_RECLAIM_LOOPS; loop++) {
3610                 total += try_to_free_mem_cgroup_pages(memcg, nr_to_reclaim,
3611                                                 GFP_KERNEL, true);
3612
3613                 /*
3614                  * If nothing was reclaimed after two attempts, there
3615                  * may be no reclaimable pages in this hierarchy.
3616                  * If more than nr_to_reclaim pages were already reclaimed,
3617                  * finish force reclaim.
3618                  */
3619                 if (loop && (!total || total > nr_to_reclaim))
3620                         break;
3621         }
3622
3623         pr_info("%s: [Mem_reclaim] Loop: %d - Total_reclaimed: %lu - nr_to_reclaim: %lu\n",
3624                 __func__, loop, total, nr_to_reclaim);
3625
3626         return total;
3627 }
3628 #endif
3629
3630 static u64 mem_cgroup_hierarchy_read(struct cgroup_subsys_state *css,
3631                                      struct cftype *cft)
3632 {
3633         return 1;
3634 }
3635
3636 static int mem_cgroup_hierarchy_write(struct cgroup_subsys_state *css,
3637                                       struct cftype *cft, u64 val)
3638 {
3639         if (val == 1)
3640                 return 0;
3641
3642         pr_warn_once("Non-hierarchical mode is deprecated. "
3643                      "Please report your usecase to linux-mm@kvack.org if you "
3644                      "depend on this functionality.\n");
3645
3646         return -EINVAL;
3647 }
3648
3649 static unsigned long mem_cgroup_usage(struct mem_cgroup *memcg, bool swap)
3650 {
3651         unsigned long val;
3652
3653         if (mem_cgroup_is_root(memcg)) {
3654                 mem_cgroup_flush_stats();
3655                 val = memcg_page_state(memcg, NR_FILE_PAGES) +
3656                         memcg_page_state(memcg, NR_ANON_MAPPED);
3657                 if (swap)
3658                         val += memcg_page_state(memcg, MEMCG_SWAP);
3659         } else {
3660                 if (!swap)
3661                         val = page_counter_read(&memcg->memory);
3662                 else
3663                         val = page_counter_read(&memcg->memsw);
3664         }
3665         return val;
3666 }
3667
3668 enum {
3669         RES_USAGE,
3670         RES_LIMIT,
3671         RES_MAX_USAGE,
3672         RES_FAILCNT,
3673         RES_SOFT_LIMIT,
3674 };
3675
3676 static u64 mem_cgroup_read_u64(struct cgroup_subsys_state *css,
3677                                struct cftype *cft)
3678 {
3679         struct mem_cgroup *memcg = mem_cgroup_from_css(css);
3680         struct page_counter *counter;
3681
3682         switch (MEMFILE_TYPE(cft->private)) {
3683         case _MEM:
3684                 counter = &memcg->memory;
3685                 break;
3686         case _MEMSWAP:
3687                 counter = &memcg->memsw;
3688                 break;
3689         case _KMEM:
3690                 counter = &memcg->kmem;
3691                 break;
3692         case _TCP:
3693                 counter = &memcg->tcpmem;
3694                 break;
3695         default:
3696                 BUG();
3697         }
3698
3699         switch (MEMFILE_ATTR(cft->private)) {
3700         case RES_USAGE:
3701                 if (counter == &memcg->memory)
3702                         return (u64)mem_cgroup_usage(memcg, false) * PAGE_SIZE;
3703                 if (counter == &memcg->memsw)
3704                         return (u64)mem_cgroup_usage(memcg, true) * PAGE_SIZE;
3705                 return (u64)page_counter_read(counter) * PAGE_SIZE;
3706         case RES_LIMIT:
3707                 return (u64)counter->max * PAGE_SIZE;
3708         case RES_MAX_USAGE:
3709                 return (u64)counter->watermark * PAGE_SIZE;
3710         case RES_FAILCNT:
3711                 return counter->failcnt;
3712         case RES_SOFT_LIMIT:
3713                 return (u64)memcg->soft_limit * PAGE_SIZE;
3714         default:
3715                 BUG();
3716         }
3717 }
3718
3719 #ifdef CONFIG_MEMCG_KMEM
3720 static int memcg_online_kmem(struct mem_cgroup *memcg)
3721 {
3722         struct obj_cgroup *objcg;
3723         int memcg_id;
3724
3725         if (cgroup_memory_nokmem)
3726                 return 0;
3727
3728         BUG_ON(memcg->kmemcg_id >= 0);
3729         BUG_ON(memcg->kmem_state);
3730
3731         memcg_id = memcg_alloc_cache_id();
3732         if (memcg_id < 0)
3733                 return memcg_id;
3734
3735         objcg = obj_cgroup_alloc();
3736         if (!objcg) {
3737                 memcg_free_cache_id(memcg_id);
3738                 return -ENOMEM;
3739         }
3740         objcg->memcg = memcg;
3741         rcu_assign_pointer(memcg->objcg, objcg);
3742
3743         static_branch_enable(&memcg_kmem_enabled_key);
3744
3745         memcg->kmemcg_id = memcg_id;
3746         memcg->kmem_state = KMEM_ONLINE;
3747
3748         return 0;
3749 }
3750
3751 static void memcg_offline_kmem(struct mem_cgroup *memcg)
3752 {
3753         struct cgroup_subsys_state *css;
3754         struct mem_cgroup *parent, *child;
3755         int kmemcg_id;
3756
3757         if (memcg->kmem_state != KMEM_ONLINE)
3758                 return;
3759
3760         memcg->kmem_state = KMEM_ALLOCATED;
3761
3762         parent = parent_mem_cgroup(memcg);
3763         if (!parent)
3764                 parent = root_mem_cgroup;
3765
3766         memcg_reparent_objcgs(memcg, parent);
3767
3768         kmemcg_id = memcg->kmemcg_id;
3769         BUG_ON(kmemcg_id < 0);
3770
3771         /*
3772          * Change kmemcg_id of this cgroup and all its descendants to the
3773          * parent's id, and then move all entries from this cgroup's list_lrus
3774          * to ones of the parent. After we have finished, all list_lrus
3775          * corresponding to this cgroup are guaranteed to remain empty. The
3776          * ordering is imposed by list_lru_node->lock taken by
3777          * memcg_drain_all_list_lrus().
3778          */
3779         rcu_read_lock(); /* can be called from css_free w/o cgroup_mutex */
3780         css_for_each_descendant_pre(css, &memcg->css) {
3781                 child = mem_cgroup_from_css(css);
3782                 BUG_ON(child->kmemcg_id != kmemcg_id);
3783                 child->kmemcg_id = parent->kmemcg_id;
3784         }
3785         rcu_read_unlock();
3786
3787         memcg_drain_all_list_lrus(kmemcg_id, parent);
3788
3789         memcg_free_cache_id(kmemcg_id);
3790 }
3791
3792 static void memcg_free_kmem(struct mem_cgroup *memcg)
3793 {
3794         /* css_alloc() failed, offlining didn't happen */
3795         if (unlikely(memcg->kmem_state == KMEM_ONLINE))
3796                 memcg_offline_kmem(memcg);
3797 }
3798 #else
3799 static int memcg_online_kmem(struct mem_cgroup *memcg)
3800 {
3801         return 0;
3802 }
3803 static void memcg_offline_kmem(struct mem_cgroup *memcg)
3804 {
3805 }
3806 static void memcg_free_kmem(struct mem_cgroup *memcg)
3807 {
3808 }
3809 #endif /* CONFIG_MEMCG_KMEM */
3810
3811 static int memcg_update_kmem_max(struct mem_cgroup *memcg,
3812                                  unsigned long max)
3813 {
3814         int ret;
3815
3816         mutex_lock(&memcg_max_mutex);
3817         ret = page_counter_set_max(&memcg->kmem, max);
3818         mutex_unlock(&memcg_max_mutex);
3819         return ret;
3820 }
3821
3822 static int memcg_update_tcp_max(struct mem_cgroup *memcg, unsigned long max)
3823 {
3824         int ret;
3825
3826         mutex_lock(&memcg_max_mutex);
3827
3828         ret = page_counter_set_max(&memcg->tcpmem, max);
3829         if (ret)
3830                 goto out;
3831
3832         if (!memcg->tcpmem_active) {
3833                 /*
3834                  * The active flag needs to be written after the static_key
3835                  * update. This is what guarantees that the socket activation
3836                  * function is the last one to run. See mem_cgroup_sk_alloc()
3837                  * for details, and note that we don't mark any socket as
3838                  * belonging to this memcg until that flag is up.
3839                  *
3840                  * We need to do this, because static_keys will span multiple
3841                  * sites, but we can't control their order. If we mark a socket
3842                  * as accounted, but the accounting functions are not patched in
3843                  * yet, we'll lose accounting.
3844                  *
3845                  * We never race with the readers in mem_cgroup_sk_alloc(),
3846                  * because when this value change, the code to process it is not
3847                  * patched in yet.
3848                  */
3849                 static_branch_inc(&memcg_sockets_enabled_key);
3850                 memcg->tcpmem_active = true;
3851         }
3852 out:
3853         mutex_unlock(&memcg_max_mutex);
3854         return ret;
3855 }
3856
3857 /*
3858  * The user of this function is...
3859  * RES_LIMIT.
3860  */
3861 static ssize_t mem_cgroup_write(struct kernfs_open_file *of,
3862                                 char *buf, size_t nbytes, loff_t off)
3863 {
3864         struct mem_cgroup *memcg = mem_cgroup_from_css(of_css(of));
3865         unsigned long nr_pages;
3866         int ret;
3867
3868         buf = strstrip(buf);
3869         ret = page_counter_memparse(buf, "-1", &nr_pages);
3870         if (ret)
3871                 return ret;
3872
3873         switch (MEMFILE_ATTR(of_cft(of)->private)) {
3874         case RES_LIMIT:
3875                 if (mem_cgroup_is_root(memcg)) { /* Can't set limit on root */
3876                         ret = -EINVAL;
3877                         break;
3878                 }
3879                 switch (MEMFILE_TYPE(of_cft(of)->private)) {
3880                 case _MEM:
3881                         ret = mem_cgroup_resize_max(memcg, nr_pages, false);
3882                         break;
3883                 case _MEMSWAP:
3884                         ret = mem_cgroup_resize_max(memcg, nr_pages, true);
3885                         break;
3886                 case _KMEM:
3887                         pr_warn_once("kmem.limit_in_bytes is deprecated and will be removed. "
3888                                      "Please report your usecase to linux-mm@kvack.org if you "
3889                                      "depend on this functionality.\n");
3890                         ret = memcg_update_kmem_max(memcg, nr_pages);
3891                         break;
3892                 case _TCP:
3893                         ret = memcg_update_tcp_max(memcg, nr_pages);
3894                         break;
3895                 }
3896                 break;
3897         case RES_SOFT_LIMIT:
3898                 if (IS_ENABLED(CONFIG_PREEMPT_RT)) {
3899                         ret = -EOPNOTSUPP;
3900                 } else {
3901                         memcg->soft_limit = nr_pages;
3902                         ret = 0;
3903                 }
3904                 break;
3905         }
3906         return ret ?: nbytes;
3907 }
3908
3909 static ssize_t mem_cgroup_reset(struct kernfs_open_file *of, char *buf,
3910                                 size_t nbytes, loff_t off)
3911 {
3912         struct mem_cgroup *memcg = mem_cgroup_from_css(of_css(of));
3913         struct page_counter *counter;
3914
3915         switch (MEMFILE_TYPE(of_cft(of)->private)) {
3916         case _MEM:
3917                 counter = &memcg->memory;
3918                 break;
3919         case _MEMSWAP:
3920                 counter = &memcg->memsw;
3921                 break;
3922         case _KMEM:
3923                 counter = &memcg->kmem;
3924                 break;
3925         case _TCP:
3926                 counter = &memcg->tcpmem;
3927                 break;
3928         default:
3929                 BUG();
3930         }
3931
3932         switch (MEMFILE_ATTR(of_cft(of)->private)) {
3933         case RES_MAX_USAGE:
3934                 page_counter_reset_watermark(counter);
3935                 break;
3936         case RES_FAILCNT:
3937                 counter->failcnt = 0;
3938                 break;
3939         default:
3940                 BUG();
3941         }
3942
3943         return nbytes;
3944 }
3945
3946 static u64 mem_cgroup_move_charge_read(struct cgroup_subsys_state *css,
3947                                         struct cftype *cft)
3948 {
3949         return mem_cgroup_from_css(css)->move_charge_at_immigrate;
3950 }
3951
3952 #ifdef CONFIG_MMU
3953 static int mem_cgroup_move_charge_write(struct cgroup_subsys_state *css,
3954                                         struct cftype *cft, u64 val)
3955 {
3956         struct mem_cgroup *memcg = mem_cgroup_from_css(css);
3957
3958         if (val & ~MOVE_MASK)
3959                 return -EINVAL;
3960
3961         /*
3962          * No kind of locking is needed in here, because ->can_attach() will
3963          * check this value once in the beginning of the process, and then carry
3964          * on with stale data. This means that changes to this value will only
3965          * affect task migrations starting after the change.
3966          */
3967         memcg->move_charge_at_immigrate = val;
3968         return 0;
3969 }
3970 #else
3971 static int mem_cgroup_move_charge_write(struct cgroup_subsys_state *css,
3972                                         struct cftype *cft, u64 val)
3973 {
3974         return -ENOSYS;
3975 }
3976 #endif
3977
3978 #ifdef CONFIG_NUMA
3979
3980 #define LRU_ALL_FILE (BIT(LRU_INACTIVE_FILE) | BIT(LRU_ACTIVE_FILE))
3981 #define LRU_ALL_ANON (BIT(LRU_INACTIVE_ANON) | BIT(LRU_ACTIVE_ANON))
3982 #define LRU_ALL      ((1 << NR_LRU_LISTS) - 1)
3983
3984 static unsigned long mem_cgroup_node_nr_lru_pages(struct mem_cgroup *memcg,
3985                                 int nid, unsigned int lru_mask, bool tree)
3986 {
3987         struct lruvec *lruvec = mem_cgroup_lruvec(memcg, NODE_DATA(nid));
3988         unsigned long nr = 0;
3989         enum lru_list lru;
3990
3991         VM_BUG_ON((unsigned)nid >= nr_node_ids);
3992
3993         for_each_lru(lru) {
3994                 if (!(BIT(lru) & lru_mask))
3995                         continue;
3996                 if (tree)
3997                         nr += lruvec_page_state(lruvec, NR_LRU_BASE + lru);
3998                 else
3999                         nr += lruvec_page_state_local(lruvec, NR_LRU_BASE + lru);
4000         }
4001         return nr;
4002 }
4003
4004 static unsigned long mem_cgroup_nr_lru_pages(struct mem_cgroup *memcg,
4005                                              unsigned int lru_mask,
4006                                              bool tree)
4007 {
4008         unsigned long nr = 0;
4009         enum lru_list lru;
4010
4011         for_each_lru(lru) {
4012                 if (!(BIT(lru) & lru_mask))
4013                         continue;
4014                 if (tree)
4015                         nr += memcg_page_state(memcg, NR_LRU_BASE + lru);
4016                 else
4017                         nr += memcg_page_state_local(memcg, NR_LRU_BASE + lru);
4018         }
4019         return nr;
4020 }
4021
4022 static int memcg_numa_stat_show(struct seq_file *m, void *v)
4023 {
4024         struct numa_stat {
4025                 const char *name;
4026                 unsigned int lru_mask;
4027         };
4028
4029         static const struct numa_stat stats[] = {
4030                 { "total", LRU_ALL },
4031                 { "file", LRU_ALL_FILE },
4032                 { "anon", LRU_ALL_ANON },
4033                 { "unevictable", BIT(LRU_UNEVICTABLE) },
4034         };
4035         const struct numa_stat *stat;
4036         int nid;
4037         struct mem_cgroup *memcg = mem_cgroup_from_seq(m);
4038
4039         mem_cgroup_flush_stats();
4040
4041         for (stat = stats; stat < stats + ARRAY_SIZE(stats); stat++) {
4042                 seq_printf(m, "%s=%lu", stat->name,
4043                            mem_cgroup_nr_lru_pages(memcg, stat->lru_mask,
4044                                                    false));
4045                 for_each_node_state(nid, N_MEMORY)
4046                         seq_printf(m, " N%d=%lu", nid,
4047                                    mem_cgroup_node_nr_lru_pages(memcg, nid,
4048                                                         stat->lru_mask, false));
4049                 seq_putc(m, '\n');
4050         }
4051
4052         for (stat = stats; stat < stats + ARRAY_SIZE(stats); stat++) {
4053
4054                 seq_printf(m, "hierarchical_%s=%lu", stat->name,
4055                            mem_cgroup_nr_lru_pages(memcg, stat->lru_mask,
4056                                                    true));
4057                 for_each_node_state(nid, N_MEMORY)
4058                         seq_printf(m, " N%d=%lu", nid,
4059                                    mem_cgroup_node_nr_lru_pages(memcg, nid,
4060                                                         stat->lru_mask, true));
4061                 seq_putc(m, '\n');
4062         }
4063
4064         return 0;
4065 }
4066 #endif /* CONFIG_NUMA */
4067
4068 static const unsigned int memcg1_stats[] = {
4069         NR_FILE_PAGES,
4070         NR_ANON_MAPPED,
4071 #ifdef CONFIG_TRANSPARENT_HUGEPAGE
4072         NR_ANON_THPS,
4073 #endif
4074         NR_SHMEM,
4075         NR_FILE_MAPPED,
4076         NR_FILE_DIRTY,
4077         NR_WRITEBACK,
4078         MEMCG_SWAP,
4079 };
4080
4081 static const char *const memcg1_stat_names[] = {
4082         "cache",
4083         "rss",
4084 #ifdef CONFIG_TRANSPARENT_HUGEPAGE
4085         "rss_huge",
4086 #endif
4087         "shmem",
4088         "mapped_file",
4089         "dirty",
4090         "writeback",
4091         "swap",
4092 };
4093
4094 /* Universal VM events cgroup1 shows, original sort order */
4095 static const unsigned int memcg1_events[] = {
4096         PGPGIN,
4097         PGPGOUT,
4098         PGFAULT,
4099         PGMAJFAULT,
4100 };
4101
4102 static int memcg_stat_show(struct seq_file *m, void *v)
4103 {
4104         struct mem_cgroup *memcg = mem_cgroup_from_seq(m);
4105         unsigned long memory, memsw;
4106         struct mem_cgroup *mi;
4107         unsigned int i;
4108
4109         BUILD_BUG_ON(ARRAY_SIZE(memcg1_stat_names) != ARRAY_SIZE(memcg1_stats));
4110
4111         mem_cgroup_flush_stats();
4112
4113         for (i = 0; i < ARRAY_SIZE(memcg1_stats); i++) {
4114                 unsigned long nr;
4115
4116                 if (memcg1_stats[i] == MEMCG_SWAP && !do_memsw_account())
4117                         continue;
4118                 nr = memcg_page_state_local(memcg, memcg1_stats[i]);
4119                 seq_printf(m, "%s %lu\n", memcg1_stat_names[i], nr * PAGE_SIZE);
4120         }
4121
4122         for (i = 0; i < ARRAY_SIZE(memcg1_events); i++)
4123                 seq_printf(m, "%s %lu\n", vm_event_name(memcg1_events[i]),
4124                            memcg_events_local(memcg, memcg1_events[i]));
4125
4126         for (i = 0; i < NR_LRU_LISTS; i++)
4127                 seq_printf(m, "%s %lu\n", lru_list_name(i),
4128                            memcg_page_state_local(memcg, NR_LRU_BASE + i) *
4129                            PAGE_SIZE);
4130
4131         /* Hierarchical information */
4132         memory = memsw = PAGE_COUNTER_MAX;
4133         for (mi = memcg; mi; mi = parent_mem_cgroup(mi)) {
4134                 memory = min(memory, READ_ONCE(mi->memory.max));
4135                 memsw = min(memsw, READ_ONCE(mi->memsw.max));
4136         }
4137         seq_printf(m, "hierarchical_memory_limit %llu\n",
4138                    (u64)memory * PAGE_SIZE);
4139         if (do_memsw_account())
4140                 seq_printf(m, "hierarchical_memsw_limit %llu\n",
4141                            (u64)memsw * PAGE_SIZE);
4142
4143         for (i = 0; i < ARRAY_SIZE(memcg1_stats); i++) {
4144                 unsigned long nr;
4145
4146                 if (memcg1_stats[i] == MEMCG_SWAP && !do_memsw_account())
4147                         continue;
4148                 nr = memcg_page_state(memcg, memcg1_stats[i]);
4149                 seq_printf(m, "total_%s %llu\n", memcg1_stat_names[i],
4150                                                 (u64)nr * PAGE_SIZE);
4151         }
4152
4153         for (i = 0; i < ARRAY_SIZE(memcg1_events); i++)
4154                 seq_printf(m, "total_%s %llu\n",
4155                            vm_event_name(memcg1_events[i]),
4156                            (u64)memcg_events(memcg, memcg1_events[i]));
4157
4158         for (i = 0; i < NR_LRU_LISTS; i++)
4159                 seq_printf(m, "total_%s %llu\n", lru_list_name(i),
4160                            (u64)memcg_page_state(memcg, NR_LRU_BASE + i) *
4161                            PAGE_SIZE);
4162
4163 #ifdef CONFIG_DEBUG_VM
4164         {
4165                 pg_data_t *pgdat;
4166                 struct mem_cgroup_per_node *mz;
4167                 unsigned long anon_cost = 0;
4168                 unsigned long file_cost = 0;
4169
4170                 for_each_online_pgdat(pgdat) {
4171                         mz = memcg->nodeinfo[pgdat->node_id];
4172
4173                         anon_cost += mz->lruvec.anon_cost;
4174                         file_cost += mz->lruvec.file_cost;
4175                 }
4176                 seq_printf(m, "anon_cost %lu\n", anon_cost);
4177                 seq_printf(m, "file_cost %lu\n", file_cost);
4178         }
4179 #endif
4180
4181         return 0;
4182 }
4183
4184 static u64 mem_cgroup_swappiness_read(struct cgroup_subsys_state *css,
4185                                       struct cftype *cft)
4186 {
4187         struct mem_cgroup *memcg = mem_cgroup_from_css(css);
4188
4189         return mem_cgroup_swappiness(memcg);
4190 }
4191
4192 static int mem_cgroup_swappiness_write(struct cgroup_subsys_state *css,
4193                                        struct cftype *cft, u64 val)
4194 {
4195         struct mem_cgroup *memcg = mem_cgroup_from_css(css);
4196
4197         if (val > 200)
4198                 return -EINVAL;
4199
4200         if (!mem_cgroup_is_root(memcg))
4201                 memcg->swappiness = val;
4202         else
4203                 vm_swappiness = val;
4204
4205         return 0;
4206 }
4207
4208 static void __mem_cgroup_threshold(struct mem_cgroup *memcg, bool swap)
4209 {
4210         struct mem_cgroup_threshold_ary *t;
4211         unsigned long usage;
4212         int i;
4213
4214         rcu_read_lock();
4215         if (!swap)
4216                 t = rcu_dereference(memcg->thresholds.primary);
4217         else
4218                 t = rcu_dereference(memcg->memsw_thresholds.primary);
4219
4220         if (!t)
4221                 goto unlock;
4222
4223         usage = mem_cgroup_usage(memcg, swap);
4224
4225         /*
4226          * current_threshold points to threshold just below or equal to usage.
4227          * If it's not true, a threshold was crossed after last
4228          * call of __mem_cgroup_threshold().
4229          */
4230         i = t->current_threshold;
4231
4232         /*
4233          * Iterate backward over array of thresholds starting from
4234          * current_threshold and check if a threshold is crossed.
4235          * If none of thresholds below usage is crossed, we read
4236          * only one element of the array here.
4237          */
4238         for (; i >= 0 && unlikely(t->entries[i].threshold > usage); i--)
4239                 eventfd_signal(t->entries[i].eventfd, 1);
4240
4241         /* i = current_threshold + 1 */
4242         i++;
4243
4244         /*
4245          * Iterate forward over array of thresholds starting from
4246          * current_threshold+1 and check if a threshold is crossed.
4247          * If none of thresholds above usage is crossed, we read
4248          * only one element of the array here.
4249          */
4250         for (; i < t->size && unlikely(t->entries[i].threshold <= usage); i++)
4251                 eventfd_signal(t->entries[i].eventfd, 1);
4252
4253         /* Update current_threshold */
4254         t->current_threshold = i - 1;
4255 unlock:
4256         rcu_read_unlock();
4257 }
4258
4259 static void mem_cgroup_threshold(struct mem_cgroup *memcg)
4260 {
4261         while (memcg) {
4262                 __mem_cgroup_threshold(memcg, false);
4263                 if (do_memsw_account())
4264                         __mem_cgroup_threshold(memcg, true);
4265
4266                 memcg = parent_mem_cgroup(memcg);
4267         }
4268 }
4269
4270 static int compare_thresholds(const void *a, const void *b)
4271 {
4272         const struct mem_cgroup_threshold *_a = a;
4273         const struct mem_cgroup_threshold *_b = b;
4274
4275         if (_a->threshold > _b->threshold)
4276                 return 1;
4277
4278         if (_a->threshold < _b->threshold)
4279                 return -1;
4280
4281         return 0;
4282 }
4283
4284 static int mem_cgroup_oom_notify_cb(struct mem_cgroup *memcg)
4285 {
4286         struct mem_cgroup_eventfd_list *ev;
4287
4288         spin_lock(&memcg_oom_lock);
4289
4290         list_for_each_entry(ev, &memcg->oom_notify, list)
4291                 eventfd_signal(ev->eventfd, 1);
4292
4293         spin_unlock(&memcg_oom_lock);
4294         return 0;
4295 }
4296
4297 static void mem_cgroup_oom_notify(struct mem_cgroup *memcg)
4298 {
4299         struct mem_cgroup *iter;
4300
4301         for_each_mem_cgroup_tree(iter, memcg)
4302                 mem_cgroup_oom_notify_cb(iter);
4303 }
4304
4305 static int __mem_cgroup_usage_register_event(struct mem_cgroup *memcg,
4306         struct eventfd_ctx *eventfd, const char *args, enum res_type type)
4307 {
4308         struct mem_cgroup_thresholds *thresholds;
4309         struct mem_cgroup_threshold_ary *new;
4310         unsigned long threshold;
4311         unsigned long usage;
4312         int i, size, ret;
4313
4314         ret = page_counter_memparse(args, "-1", &threshold);
4315         if (ret)
4316                 return ret;
4317
4318         mutex_lock(&memcg->thresholds_lock);
4319
4320         if (type == _MEM) {
4321                 thresholds = &memcg->thresholds;
4322                 usage = mem_cgroup_usage(memcg, false);
4323         } else if (type == _MEMSWAP) {
4324                 thresholds = &memcg->memsw_thresholds;
4325                 usage = mem_cgroup_usage(memcg, true);
4326         } else
4327                 BUG();
4328
4329         /* Check if a threshold crossed before adding a new one */
4330         if (thresholds->primary)
4331                 __mem_cgroup_threshold(memcg, type == _MEMSWAP);
4332
4333         size = thresholds->primary ? thresholds->primary->size + 1 : 1;
4334
4335         /* Allocate memory for new array of thresholds */
4336         new = kmalloc(struct_size(new, entries, size), GFP_KERNEL);
4337         if (!new) {
4338                 ret = -ENOMEM;
4339                 goto unlock;
4340         }
4341         new->size = size;
4342
4343         /* Copy thresholds (if any) to new array */
4344         if (thresholds->primary)
4345                 memcpy(new->entries, thresholds->primary->entries,
4346                        flex_array_size(new, entries, size - 1));
4347
4348         /* Add new threshold */
4349         new->entries[size - 1].eventfd = eventfd;
4350         new->entries[size - 1].threshold = threshold;
4351
4352         /* Sort thresholds. Registering of new threshold isn't time-critical */
4353         sort(new->entries, size, sizeof(*new->entries),
4354                         compare_thresholds, NULL);
4355
4356         /* Find current threshold */
4357         new->current_threshold = -1;
4358         for (i = 0; i < size; i++) {
4359                 if (new->entries[i].threshold <= usage) {
4360                         /*
4361                          * new->current_threshold will not be used until
4362                          * rcu_assign_pointer(), so it's safe to increment
4363                          * it here.
4364                          */
4365                         ++new->current_threshold;
4366                 } else
4367                         break;
4368         }
4369
4370         /* Free old spare buffer and save old primary buffer as spare */
4371         kfree(thresholds->spare);
4372         thresholds->spare = thresholds->primary;
4373
4374         rcu_assign_pointer(thresholds->primary, new);
4375
4376         /* To be sure that nobody uses thresholds */
4377         synchronize_rcu();
4378
4379 unlock:
4380         mutex_unlock(&memcg->thresholds_lock);
4381
4382         return ret;
4383 }
4384
4385 static int mem_cgroup_usage_register_event(struct mem_cgroup *memcg,
4386         struct eventfd_ctx *eventfd, const char *args)
4387 {
4388         return __mem_cgroup_usage_register_event(memcg, eventfd, args, _MEM);
4389 }
4390
4391 static int memsw_cgroup_usage_register_event(struct mem_cgroup *memcg,
4392         struct eventfd_ctx *eventfd, const char *args)
4393 {
4394         return __mem_cgroup_usage_register_event(memcg, eventfd, args, _MEMSWAP);
4395 }
4396
4397 static void __mem_cgroup_usage_unregister_event(struct mem_cgroup *memcg,
4398         struct eventfd_ctx *eventfd, enum res_type type)
4399 {
4400         struct mem_cgroup_thresholds *thresholds;
4401         struct mem_cgroup_threshold_ary *new;
4402         unsigned long usage;
4403         int i, j, size, entries;
4404
4405         mutex_lock(&memcg->thresholds_lock);
4406
4407         if (type == _MEM) {
4408                 thresholds = &memcg->thresholds;
4409                 usage = mem_cgroup_usage(memcg, false);
4410         } else if (type == _MEMSWAP) {
4411                 thresholds = &memcg->memsw_thresholds;
4412                 usage = mem_cgroup_usage(memcg, true);
4413         } else
4414                 BUG();
4415
4416         if (!thresholds->primary)
4417                 goto unlock;
4418
4419         /* Check if a threshold crossed before removing */
4420         __mem_cgroup_threshold(memcg, type == _MEMSWAP);
4421
4422         /* Calculate new number of threshold */
4423         size = entries = 0;
4424         for (i = 0; i < thresholds->primary->size; i++) {
4425                 if (thresholds->primary->entries[i].eventfd != eventfd)
4426                         size++;
4427                 else
4428                         entries++;
4429         }
4430
4431         new = thresholds->spare;
4432
4433         /* If no items related to eventfd have been cleared, nothing to do */
4434         if (!entries)
4435                 goto unlock;
4436
4437         /* Set thresholds array to NULL if we don't have thresholds */
4438         if (!size) {
4439                 kfree(new);
4440                 new = NULL;
4441                 goto swap_buffers;
4442         }
4443
4444         new->size = size;
4445
4446         /* Copy thresholds and find current threshold */
4447         new->current_threshold = -1;
4448         for (i = 0, j = 0; i < thresholds->primary->size; i++) {
4449                 if (thresholds->primary->entries[i].eventfd == eventfd)
4450                         continue;
4451
4452                 new->entries[j] = thresholds->primary->entries[i];
4453                 if (new->entries[j].threshold <= usage) {
4454                         /*
4455                          * new->current_threshold will not be used
4456                          * until rcu_assign_pointer(), so it's safe to increment
4457                          * it here.
4458                          */
4459                         ++new->current_threshold;
4460                 }
4461                 j++;
4462         }
4463
4464 swap_buffers:
4465         /* Swap primary and spare array */
4466         thresholds->spare = thresholds->primary;
4467
4468         rcu_assign_pointer(thresholds->primary, new);
4469
4470         /* To be sure that nobody uses thresholds */
4471         synchronize_rcu();
4472
4473         /* If all events are unregistered, free the spare array */
4474         if (!new) {
4475                 kfree(thresholds->spare);
4476                 thresholds->spare = NULL;
4477         }
4478 unlock:
4479         mutex_unlock(&memcg->thresholds_lock);
4480 }
4481
4482 static void mem_cgroup_usage_unregister_event(struct mem_cgroup *memcg,
4483         struct eventfd_ctx *eventfd)
4484 {
4485         return __mem_cgroup_usage_unregister_event(memcg, eventfd, _MEM);
4486 }
4487
4488 static void memsw_cgroup_usage_unregister_event(struct mem_cgroup *memcg,
4489         struct eventfd_ctx *eventfd)
4490 {
4491         return __mem_cgroup_usage_unregister_event(memcg, eventfd, _MEMSWAP);
4492 }
4493
4494 static int mem_cgroup_oom_register_event(struct mem_cgroup *memcg,
4495         struct eventfd_ctx *eventfd, const char *args)
4496 {
4497         struct mem_cgroup_eventfd_list *event;
4498
4499         event = kmalloc(sizeof(*event), GFP_KERNEL);
4500         if (!event)
4501                 return -ENOMEM;
4502
4503         spin_lock(&memcg_oom_lock);
4504
4505         event->eventfd = eventfd;
4506         list_add(&event->list, &memcg->oom_notify);
4507
4508         /* already in OOM ? */
4509         if (memcg->under_oom)
4510                 eventfd_signal(eventfd, 1);
4511         spin_unlock(&memcg_oom_lock);
4512
4513         return 0;
4514 }
4515
4516 static void mem_cgroup_oom_unregister_event(struct mem_cgroup *memcg,
4517         struct eventfd_ctx *eventfd)
4518 {
4519         struct mem_cgroup_eventfd_list *ev, *tmp;
4520
4521         spin_lock(&memcg_oom_lock);
4522
4523         list_for_each_entry_safe(ev, tmp, &memcg->oom_notify, list) {
4524                 if (ev->eventfd == eventfd) {
4525                         list_del(&ev->list);
4526                         kfree(ev);
4527                 }
4528         }
4529
4530         spin_unlock(&memcg_oom_lock);
4531 }
4532
4533 static int mem_cgroup_oom_control_read(struct seq_file *sf, void *v)
4534 {
4535         struct mem_cgroup *memcg = mem_cgroup_from_seq(sf);
4536
4537         seq_printf(sf, "oom_kill_disable %d\n", memcg->oom_kill_disable);
4538         seq_printf(sf, "under_oom %d\n", (bool)memcg->under_oom);
4539         seq_printf(sf, "oom_kill %lu\n",
4540                    atomic_long_read(&memcg->memory_events[MEMCG_OOM_KILL]));
4541         return 0;
4542 }
4543
4544 static int mem_cgroup_oom_control_write(struct cgroup_subsys_state *css,
4545         struct cftype *cft, u64 val)
4546 {
4547         struct mem_cgroup *memcg = mem_cgroup_from_css(css);
4548
4549         /* cannot set to root cgroup and only 0 and 1 are allowed */
4550         if (mem_cgroup_is_root(memcg) || !((val == 0) || (val == 1)))
4551                 return -EINVAL;
4552
4553         memcg->oom_kill_disable = val;
4554         if (!val)
4555                 memcg_oom_recover(memcg);
4556
4557         return 0;
4558 }
4559
4560 #ifdef CONFIG_CGROUP_WRITEBACK
4561
4562 #include <trace/events/writeback.h>
4563
4564 static int memcg_wb_domain_init(struct mem_cgroup *memcg, gfp_t gfp)
4565 {
4566         return wb_domain_init(&memcg->cgwb_domain, gfp);
4567 }
4568
4569 static void memcg_wb_domain_exit(struct mem_cgroup *memcg)
4570 {
4571         wb_domain_exit(&memcg->cgwb_domain);
4572 }
4573
4574 static void memcg_wb_domain_size_changed(struct mem_cgroup *memcg)
4575 {
4576         wb_domain_size_changed(&memcg->cgwb_domain);
4577 }
4578
4579 struct wb_domain *mem_cgroup_wb_domain(struct bdi_writeback *wb)
4580 {
4581         struct mem_cgroup *memcg = mem_cgroup_from_css(wb->memcg_css);
4582
4583         if (!memcg->css.parent)
4584                 return NULL;
4585
4586         return &memcg->cgwb_domain;
4587 }
4588
4589 /**
4590  * mem_cgroup_wb_stats - retrieve writeback related stats from its memcg
4591  * @wb: bdi_writeback in question
4592  * @pfilepages: out parameter for number of file pages
4593  * @pheadroom: out parameter for number of allocatable pages according to memcg
4594  * @pdirty: out parameter for number of dirty pages
4595  * @pwriteback: out parameter for number of pages under writeback
4596  *
4597  * Determine the numbers of file, headroom, dirty, and writeback pages in
4598  * @wb's memcg.  File, dirty and writeback are self-explanatory.  Headroom
4599  * is a bit more involved.
4600  *
4601  * A memcg's headroom is "min(max, high) - used".  In the hierarchy, the
4602  * headroom is calculated as the lowest headroom of itself and the
4603  * ancestors.  Note that this doesn't consider the actual amount of
4604  * available memory in the system.  The caller should further cap
4605  * *@pheadroom accordingly.
4606  */
4607 void mem_cgroup_wb_stats(struct bdi_writeback *wb, unsigned long *pfilepages,
4608                          unsigned long *pheadroom, unsigned long *pdirty,
4609                          unsigned long *pwriteback)
4610 {
4611         struct mem_cgroup *memcg = mem_cgroup_from_css(wb->memcg_css);
4612         struct mem_cgroup *parent;
4613
4614         mem_cgroup_flush_stats();
4615
4616         *pdirty = memcg_page_state(memcg, NR_FILE_DIRTY);
4617         *pwriteback = memcg_page_state(memcg, NR_WRITEBACK);
4618         *pfilepages = memcg_page_state(memcg, NR_INACTIVE_FILE) +
4619                         memcg_page_state(memcg, NR_ACTIVE_FILE);
4620
4621         *pheadroom = PAGE_COUNTER_MAX;
4622         while ((parent = parent_mem_cgroup(memcg))) {
4623                 unsigned long ceiling = min(READ_ONCE(memcg->memory.max),
4624                                             READ_ONCE(memcg->memory.high));
4625                 unsigned long used = page_counter_read(&memcg->memory);
4626
4627                 *pheadroom = min(*pheadroom, ceiling - min(ceiling, used));
4628                 memcg = parent;
4629         }
4630 }
4631
4632 /*
4633  * Foreign dirty flushing
4634  *
4635  * There's an inherent mismatch between memcg and writeback.  The former
4636  * tracks ownership per-page while the latter per-inode.  This was a
4637  * deliberate design decision because honoring per-page ownership in the
4638  * writeback path is complicated, may lead to higher CPU and IO overheads
4639  * and deemed unnecessary given that write-sharing an inode across
4640  * different cgroups isn't a common use-case.
4641  *
4642  * Combined with inode majority-writer ownership switching, this works well
4643  * enough in most cases but there are some pathological cases.  For
4644  * example, let's say there are two cgroups A and B which keep writing to
4645  * different but confined parts of the same inode.  B owns the inode and
4646  * A's memory is limited far below B's.  A's dirty ratio can rise enough to
4647  * trigger balance_dirty_pages() sleeps but B's can be low enough to avoid
4648  * triggering background writeback.  A will be slowed down without a way to
4649  * make writeback of the dirty pages happen.
4650  *
4651  * Conditions like the above can lead to a cgroup getting repeatedly and
4652  * severely throttled after making some progress after each
4653  * dirty_expire_interval while the underlying IO device is almost
4654  * completely idle.
4655  *
4656  * Solving this problem completely requires matching the ownership tracking
4657  * granularities between memcg and writeback in either direction.  However,
4658  * the more egregious behaviors can be avoided by simply remembering the
4659  * most recent foreign dirtying events and initiating remote flushes on
4660  * them when local writeback isn't enough to keep the memory clean enough.
4661  *
4662  * The following two functions implement such mechanism.  When a foreign
4663  * page - a page whose memcg and writeback ownerships don't match - is
4664  * dirtied, mem_cgroup_track_foreign_dirty() records the inode owning
4665  * bdi_writeback on the page owning memcg.  When balance_dirty_pages()
4666  * decides that the memcg needs to sleep due to high dirty ratio, it calls
4667  * mem_cgroup_flush_foreign() which queues writeback on the recorded
4668  * foreign bdi_writebacks which haven't expired.  Both the numbers of
4669  * recorded bdi_writebacks and concurrent in-flight foreign writebacks are
4670  * limited to MEMCG_CGWB_FRN_CNT.
4671  *
4672  * The mechanism only remembers IDs and doesn't hold any object references.
4673  * As being wrong occasionally doesn't matter, updates and accesses to the
4674  * records are lockless and racy.
4675  */
4676 void mem_cgroup_track_foreign_dirty_slowpath(struct page *page,
4677                                              struct bdi_writeback *wb)
4678 {
4679         struct mem_cgroup *memcg = page_memcg(page);
4680         struct memcg_cgwb_frn *frn;
4681         u64 now = get_jiffies_64();
4682         u64 oldest_at = now;
4683         int oldest = -1;
4684         int i;
4685
4686         trace_track_foreign_dirty(page, wb);
4687
4688         /*
4689          * Pick the slot to use.  If there is already a slot for @wb, keep
4690          * using it.  If not replace the oldest one which isn't being
4691          * written out.
4692          */
4693         for (i = 0; i < MEMCG_CGWB_FRN_CNT; i++) {
4694                 frn = &memcg->cgwb_frn[i];
4695                 if (frn->bdi_id == wb->bdi->id &&
4696                     frn->memcg_id == wb->memcg_css->id)
4697                         break;
4698                 if (time_before64(frn->at, oldest_at) &&
4699                     atomic_read(&frn->done.cnt) == 1) {
4700                         oldest = i;
4701                         oldest_at = frn->at;
4702                 }
4703         }
4704
4705         if (i < MEMCG_CGWB_FRN_CNT) {
4706                 /*
4707                  * Re-using an existing one.  Update timestamp lazily to
4708                  * avoid making the cacheline hot.  We want them to be
4709                  * reasonably up-to-date and significantly shorter than
4710                  * dirty_expire_interval as that's what expires the record.
4711                  * Use the shorter of 1s and dirty_expire_interval / 8.
4712                  */
4713                 unsigned long update_intv =
4714                         min_t(unsigned long, HZ,
4715                               msecs_to_jiffies(dirty_expire_interval * 10) / 8);
4716
4717                 if (time_before64(frn->at, now - update_intv))
4718                         frn->at = now;
4719         } else if (oldest >= 0) {
4720                 /* replace the oldest free one */
4721                 frn = &memcg->cgwb_frn[oldest];
4722                 frn->bdi_id = wb->bdi->id;
4723                 frn->memcg_id = wb->memcg_css->id;
4724                 frn->at = now;
4725         }
4726 }
4727
4728 /* issue foreign writeback flushes for recorded foreign dirtying events */
4729 void mem_cgroup_flush_foreign(struct bdi_writeback *wb)
4730 {
4731         struct mem_cgroup *memcg = mem_cgroup_from_css(wb->memcg_css);
4732         unsigned long intv = msecs_to_jiffies(dirty_expire_interval * 10);
4733         u64 now = jiffies_64;
4734         int i;
4735
4736         for (i = 0; i < MEMCG_CGWB_FRN_CNT; i++) {
4737                 struct memcg_cgwb_frn *frn = &memcg->cgwb_frn[i];
4738
4739                 /*
4740                  * If the record is older than dirty_expire_interval,
4741                  * writeback on it has already started.  No need to kick it
4742                  * off again.  Also, don't start a new one if there's
4743                  * already one in flight.
4744                  */
4745                 if (time_after64(frn->at, now - intv) &&
4746                     atomic_read(&frn->done.cnt) == 1) {
4747                         frn->at = 0;
4748                         trace_flush_foreign(wb, frn->bdi_id, frn->memcg_id);
4749                         cgroup_writeback_by_id(frn->bdi_id, frn->memcg_id,
4750                                                WB_REASON_FOREIGN_FLUSH,
4751                                                &frn->done);
4752                 }
4753         }
4754 }
4755
4756 #else   /* CONFIG_CGROUP_WRITEBACK */
4757
4758 static int memcg_wb_domain_init(struct mem_cgroup *memcg, gfp_t gfp)
4759 {
4760         return 0;
4761 }
4762
4763 static void memcg_wb_domain_exit(struct mem_cgroup *memcg)
4764 {
4765 }
4766
4767 static void memcg_wb_domain_size_changed(struct mem_cgroup *memcg)
4768 {
4769 }
4770
4771 #endif  /* CONFIG_CGROUP_WRITEBACK */
4772
4773 /*
4774  * DO NOT USE IN NEW FILES.
4775  *
4776  * "cgroup.event_control" implementation.
4777  *
4778  * This is way over-engineered.  It tries to support fully configurable
4779  * events for each user.  Such level of flexibility is completely
4780  * unnecessary especially in the light of the planned unified hierarchy.
4781  *
4782  * Please deprecate this and replace with something simpler if at all
4783  * possible.
4784  */
4785
4786 /*
4787  * Unregister event and free resources.
4788  *
4789  * Gets called from workqueue.
4790  */
4791 static void memcg_event_remove(struct work_struct *work)
4792 {
4793         struct mem_cgroup_event *event =
4794                 container_of(work, struct mem_cgroup_event, remove);
4795         struct mem_cgroup *memcg = event->memcg;
4796
4797         remove_wait_queue(event->wqh, &event->wait);
4798
4799         event->unregister_event(memcg, event->eventfd);
4800
4801         /* Notify userspace the event is going away. */
4802         eventfd_signal(event->eventfd, 1);
4803
4804         eventfd_ctx_put(event->eventfd);
4805         kfree(event);
4806         css_put(&memcg->css);
4807 }
4808
4809 /*
4810  * Gets called on EPOLLHUP on eventfd when user closes it.
4811  *
4812  * Called with wqh->lock held and interrupts disabled.
4813  */
4814 static int memcg_event_wake(wait_queue_entry_t *wait, unsigned mode,
4815                             int sync, void *key)
4816 {
4817         struct mem_cgroup_event *event =
4818                 container_of(wait, struct mem_cgroup_event, wait);
4819         struct mem_cgroup *memcg = event->memcg;
4820         __poll_t flags = key_to_poll(key);
4821
4822         if (flags & EPOLLHUP) {
4823                 /*
4824                  * If the event has been detached at cgroup removal, we
4825                  * can simply return knowing the other side will cleanup
4826                  * for us.
4827                  *
4828                  * We can't race against event freeing since the other
4829                  * side will require wqh->lock via remove_wait_queue(),
4830                  * which we hold.
4831                  */
4832                 spin_lock(&memcg->event_list_lock);
4833                 if (!list_empty(&event->list)) {
4834                         list_del_init(&event->list);
4835                         /*
4836                          * We are in atomic context, but cgroup_event_remove()
4837                          * may sleep, so we have to call it in workqueue.
4838                          */
4839                         schedule_work(&event->remove);
4840                 }
4841                 spin_unlock(&memcg->event_list_lock);
4842         }
4843
4844         return 0;
4845 }
4846
4847 static void memcg_event_ptable_queue_proc(struct file *file,
4848                 wait_queue_head_t *wqh, poll_table *pt)
4849 {
4850         struct mem_cgroup_event *event =
4851                 container_of(pt, struct mem_cgroup_event, pt);
4852
4853         event->wqh = wqh;
4854         add_wait_queue(wqh, &event->wait);
4855 }
4856
4857 /*
4858  * DO NOT USE IN NEW FILES.
4859  *
4860  * Parse input and register new cgroup event handler.
4861  *
4862  * Input must be in format '<event_fd> <control_fd> <args>'.
4863  * Interpretation of args is defined by control file implementation.
4864  */
4865 static ssize_t memcg_write_event_control(struct kernfs_open_file *of,
4866                                          char *buf, size_t nbytes, loff_t off)
4867 {
4868         struct cgroup_subsys_state *css = of_css(of);
4869         struct mem_cgroup *memcg = mem_cgroup_from_css(css);
4870         struct mem_cgroup_event *event;
4871         struct cgroup_subsys_state *cfile_css;
4872         unsigned int efd, cfd;
4873         struct fd efile;
4874         struct fd cfile;
4875         struct dentry *cdentry;
4876         const char *name;
4877         char *endp;
4878         int ret;
4879
4880         if (IS_ENABLED(CONFIG_PREEMPT_RT))
4881                 return -EOPNOTSUPP;
4882
4883         buf = strstrip(buf);
4884
4885         efd = simple_strtoul(buf, &endp, 10);
4886         if (*endp != ' ')
4887                 return -EINVAL;
4888         buf = endp + 1;
4889
4890         cfd = simple_strtoul(buf, &endp, 10);
4891         if ((*endp != ' ') && (*endp != '\0'))
4892                 return -EINVAL;
4893         buf = endp + 1;
4894
4895         event = kzalloc(sizeof(*event), GFP_KERNEL);
4896         if (!event)
4897                 return -ENOMEM;
4898
4899         event->memcg = memcg;
4900         INIT_LIST_HEAD(&event->list);
4901         init_poll_funcptr(&event->pt, memcg_event_ptable_queue_proc);
4902         init_waitqueue_func_entry(&event->wait, memcg_event_wake);
4903         INIT_WORK(&event->remove, memcg_event_remove);
4904
4905         efile = fdget(efd);
4906         if (!efile.file) {
4907                 ret = -EBADF;
4908                 goto out_kfree;
4909         }
4910
4911         event->eventfd = eventfd_ctx_fileget(efile.file);
4912         if (IS_ERR(event->eventfd)) {
4913                 ret = PTR_ERR(event->eventfd);
4914                 goto out_put_efile;
4915         }
4916
4917         cfile = fdget(cfd);
4918         if (!cfile.file) {
4919                 ret = -EBADF;
4920                 goto out_put_eventfd;
4921         }
4922
4923         /* the process need read permission on control file */
4924         /* AV: shouldn't we check that it's been opened for read instead? */
4925         ret = file_permission(cfile.file, MAY_READ);
4926         if (ret < 0)
4927                 goto out_put_cfile;
4928
4929         /*
4930          * The control file must be a regular cgroup1 file. As a regular cgroup
4931          * file can't be renamed, it's safe to access its name afterwards.
4932          */
4933         cdentry = cfile.file->f_path.dentry;
4934         if (cdentry->d_sb->s_type != &cgroup_fs_type || !d_is_reg(cdentry)) {
4935                 ret = -EINVAL;
4936                 goto out_put_cfile;
4937         }
4938
4939         /*
4940          * Determine the event callbacks and set them in @event.  This used
4941          * to be done via struct cftype but cgroup core no longer knows
4942          * about these events.  The following is crude but the whole thing
4943          * is for compatibility anyway.
4944          *
4945          * DO NOT ADD NEW FILES.
4946          */
4947         name = cdentry->d_name.name;
4948
4949         if (!strcmp(name, "memory.usage_in_bytes")) {
4950                 event->register_event = mem_cgroup_usage_register_event;
4951                 event->unregister_event = mem_cgroup_usage_unregister_event;
4952         } else if (!strcmp(name, "memory.oom_control")) {
4953                 event->register_event = mem_cgroup_oom_register_event;
4954                 event->unregister_event = mem_cgroup_oom_unregister_event;
4955         } else if (!strcmp(name, "memory.pressure_level")) {
4956                 event->register_event = vmpressure_register_event;
4957                 event->unregister_event = vmpressure_unregister_event;
4958         } else if (!strcmp(name, "memory.memsw.usage_in_bytes")) {
4959                 event->register_event = memsw_cgroup_usage_register_event;
4960                 event->unregister_event = memsw_cgroup_usage_unregister_event;
4961         } else {
4962                 ret = -EINVAL;
4963                 goto out_put_cfile;
4964         }
4965
4966         /*
4967          * Verify @cfile should belong to @css.  Also, remaining events are
4968          * automatically removed on cgroup destruction but the removal is
4969          * asynchronous, so take an extra ref on @css.
4970          */
4971         cfile_css = css_tryget_online_from_dir(cdentry->d_parent,
4972                                                &memory_cgrp_subsys);
4973         ret = -EINVAL;
4974         if (IS_ERR(cfile_css))
4975                 goto out_put_cfile;
4976         if (cfile_css != css) {
4977                 css_put(cfile_css);
4978                 goto out_put_cfile;
4979         }
4980
4981         ret = event->register_event(memcg, event->eventfd, buf);
4982         if (ret)
4983                 goto out_put_css;
4984
4985         vfs_poll(efile.file, &event->pt);
4986
4987         spin_lock_irq(&memcg->event_list_lock);
4988         list_add(&event->list, &memcg->event_list);
4989         spin_unlock_irq(&memcg->event_list_lock);
4990
4991         fdput(cfile);
4992         fdput(efile);
4993
4994         return nbytes;
4995
4996 out_put_css:
4997         css_put(css);
4998 out_put_cfile:
4999         fdput(cfile);
5000 out_put_eventfd:
5001         eventfd_ctx_put(event->eventfd);
5002 out_put_efile:
5003         fdput(efile);
5004 out_kfree:
5005         kfree(event);
5006
5007         return ret;
5008 }
5009
5010 static struct cftype mem_cgroup_legacy_files[] = {
5011         {
5012                 .name = "usage_in_bytes",
5013                 .private = MEMFILE_PRIVATE(_MEM, RES_USAGE),
5014                 .read_u64 = mem_cgroup_read_u64,
5015         },
5016         {
5017                 .name = "max_usage_in_bytes",
5018                 .private = MEMFILE_PRIVATE(_MEM, RES_MAX_USAGE),
5019                 .write = mem_cgroup_reset,
5020                 .read_u64 = mem_cgroup_read_u64,
5021         },
5022         {
5023                 .name = "limit_in_bytes",
5024                 .private = MEMFILE_PRIVATE(_MEM, RES_LIMIT),
5025                 .write = mem_cgroup_write,
5026                 .read_u64 = mem_cgroup_read_u64,
5027         },
5028         {
5029                 .name = "soft_limit_in_bytes",
5030                 .private = MEMFILE_PRIVATE(_MEM, RES_SOFT_LIMIT),
5031                 .write = mem_cgroup_write,
5032                 .read_u64 = mem_cgroup_read_u64,
5033         },
5034         {
5035                 .name = "failcnt",
5036                 .private = MEMFILE_PRIVATE(_MEM, RES_FAILCNT),
5037                 .write = mem_cgroup_reset,
5038                 .read_u64 = mem_cgroup_read_u64,
5039         },
5040         {
5041                 .name = "stat",
5042                 .seq_show = memcg_stat_show,
5043         },
5044         {
5045                 .name = "force_empty",
5046                 .write = mem_cgroup_force_empty_write,
5047         },
5048         {
5049                 .name = "use_hierarchy",
5050                 .write_u64 = mem_cgroup_hierarchy_write,
5051                 .read_u64 = mem_cgroup_hierarchy_read,
5052         },
5053         {
5054                 .name = "cgroup.event_control",         /* XXX: for compat */
5055                 .write = memcg_write_event_control,
5056                 .flags = CFTYPE_NO_PREFIX | CFTYPE_WORLD_WRITABLE,
5057         },
5058         {
5059                 .name = "swappiness",
5060                 .read_u64 = mem_cgroup_swappiness_read,
5061                 .write_u64 = mem_cgroup_swappiness_write,
5062         },
5063         {
5064                 .name = "move_charge_at_immigrate",
5065                 .read_u64 = mem_cgroup_move_charge_read,
5066                 .write_u64 = mem_cgroup_move_charge_write,
5067         },
5068         {
5069                 .name = "oom_control",
5070                 .seq_show = mem_cgroup_oom_control_read,
5071                 .write_u64 = mem_cgroup_oom_control_write,
5072                 .private = MEMFILE_PRIVATE(_OOM_TYPE, OOM_CONTROL),
5073         },
5074         {
5075                 .name = "pressure_level",
5076         },
5077 #ifdef CONFIG_NUMA
5078         {
5079                 .name = "numa_stat",
5080                 .seq_show = memcg_numa_stat_show,
5081         },
5082 #endif
5083         {
5084                 .name = "kmem.limit_in_bytes",
5085                 .private = MEMFILE_PRIVATE(_KMEM, RES_LIMIT),
5086                 .write = mem_cgroup_write,
5087                 .read_u64 = mem_cgroup_read_u64,
5088         },
5089         {
5090                 .name = "kmem.usage_in_bytes",
5091                 .private = MEMFILE_PRIVATE(_KMEM, RES_USAGE),
5092                 .read_u64 = mem_cgroup_read_u64,
5093         },
5094         {
5095                 .name = "kmem.failcnt",
5096                 .private = MEMFILE_PRIVATE(_KMEM, RES_FAILCNT),
5097                 .write = mem_cgroup_reset,
5098                 .read_u64 = mem_cgroup_read_u64,
5099         },
5100         {
5101                 .name = "kmem.max_usage_in_bytes",
5102                 .private = MEMFILE_PRIVATE(_KMEM, RES_MAX_USAGE),
5103                 .write = mem_cgroup_reset,
5104                 .read_u64 = mem_cgroup_read_u64,
5105         },
5106 #if defined(CONFIG_MEMCG_KMEM) && \
5107         (defined(CONFIG_SLAB) || defined(CONFIG_SLUB_DEBUG))
5108         {
5109                 .name = "kmem.slabinfo",
5110                 .seq_show = memcg_slab_show,
5111         },
5112 #endif
5113         {
5114                 .name = "kmem.tcp.limit_in_bytes",
5115                 .private = MEMFILE_PRIVATE(_TCP, RES_LIMIT),
5116                 .write = mem_cgroup_write,
5117                 .read_u64 = mem_cgroup_read_u64,
5118         },
5119         {
5120                 .name = "kmem.tcp.usage_in_bytes",
5121                 .private = MEMFILE_PRIVATE(_TCP, RES_USAGE),
5122                 .read_u64 = mem_cgroup_read_u64,
5123         },
5124         {
5125                 .name = "kmem.tcp.failcnt",
5126                 .private = MEMFILE_PRIVATE(_TCP, RES_FAILCNT),
5127                 .write = mem_cgroup_reset,
5128                 .read_u64 = mem_cgroup_read_u64,
5129         },
5130         {
5131                 .name = "kmem.tcp.max_usage_in_bytes",
5132                 .private = MEMFILE_PRIVATE(_TCP, RES_MAX_USAGE),
5133                 .write = mem_cgroup_reset,
5134                 .read_u64 = mem_cgroup_read_u64,
5135         },
5136         { },    /* terminate */
5137 };
5138
5139 /*
5140  * Private memory cgroup IDR
5141  *
5142  * Swap-out records and page cache shadow entries need to store memcg
5143  * references in constrained space, so we maintain an ID space that is
5144  * limited to 16 bit (MEM_CGROUP_ID_MAX), limiting the total number of
5145  * memory-controlled cgroups to 64k.
5146  *
5147  * However, there usually are many references to the offline CSS after
5148  * the cgroup has been destroyed, such as page cache or reclaimable
5149  * slab objects, that don't need to hang on to the ID. We want to keep
5150  * those dead CSS from occupying IDs, or we might quickly exhaust the
5151  * relatively small ID space and prevent the creation of new cgroups
5152  * even when there are much fewer than 64k cgroups - possibly none.
5153  *
5154  * Maintain a private 16-bit ID space for memcg, and allow the ID to
5155  * be freed and recycled when it's no longer needed, which is usually
5156  * when the CSS is offlined.
5157  *
5158  * The only exception to that are records of swapped out tmpfs/shmem
5159  * pages that need to be attributed to live ancestors on swapin. But
5160  * those references are manageable from userspace.
5161  */
5162
5163 static DEFINE_IDR(mem_cgroup_idr);
5164
5165 static void mem_cgroup_id_remove(struct mem_cgroup *memcg)
5166 {
5167         if (memcg->id.id > 0) {
5168                 idr_remove(&mem_cgroup_idr, memcg->id.id);
5169                 memcg->id.id = 0;
5170         }
5171 }
5172
5173 static void __maybe_unused mem_cgroup_id_get_many(struct mem_cgroup *memcg,
5174                                                   unsigned int n)
5175 {
5176         refcount_add(n, &memcg->id.ref);
5177 }
5178
5179 static void mem_cgroup_id_put_many(struct mem_cgroup *memcg, unsigned int n)
5180 {
5181         if (refcount_sub_and_test(n, &memcg->id.ref)) {
5182                 mem_cgroup_id_remove(memcg);
5183
5184                 /* Memcg ID pins CSS */
5185                 css_put(&memcg->css);
5186         }
5187 }
5188
5189 static inline void mem_cgroup_id_put(struct mem_cgroup *memcg)
5190 {
5191         mem_cgroup_id_put_many(memcg, 1);
5192 }
5193
5194 /**
5195  * mem_cgroup_from_id - look up a memcg from a memcg id
5196  * @id: the memcg id to look up
5197  *
5198  * Caller must hold rcu_read_lock().
5199  */
5200 struct mem_cgroup *mem_cgroup_from_id(unsigned short id)
5201 {
5202         WARN_ON_ONCE(!rcu_read_lock_held());
5203         return idr_find(&mem_cgroup_idr, id);
5204 }
5205
5206 static int alloc_mem_cgroup_per_node_info(struct mem_cgroup *memcg, int node)
5207 {
5208         struct mem_cgroup_per_node *pn;
5209         int tmp = node;
5210         /*
5211          * This routine is called against possible nodes.
5212          * But it's BUG to call kmalloc() against offline node.
5213          *
5214          * TODO: this routine can waste much memory for nodes which will
5215          *       never be onlined. It's better to use memory hotplug callback
5216          *       function.
5217          */
5218         if (!node_state(node, N_NORMAL_MEMORY))
5219                 tmp = -1;
5220         pn = kzalloc_node(sizeof(*pn), GFP_KERNEL, tmp);
5221         if (!pn)
5222                 return 1;
5223
5224         pn->lruvec_stats_percpu = alloc_percpu_gfp(struct lruvec_stats_percpu,
5225                                                    GFP_KERNEL_ACCOUNT);
5226         if (!pn->lruvec_stats_percpu) {
5227                 kfree(pn);
5228                 return 1;
5229         }
5230
5231         lruvec_init(&pn->lruvec);
5232         pn->usage_in_excess = 0;
5233         pn->on_tree = false;
5234         pn->memcg = memcg;
5235
5236         memcg->nodeinfo[node] = pn;
5237         return 0;
5238 }
5239
5240 static void free_mem_cgroup_per_node_info(struct mem_cgroup *memcg, int node)
5241 {
5242         struct mem_cgroup_per_node *pn = memcg->nodeinfo[node];
5243
5244         if (!pn)
5245                 return;
5246
5247         free_percpu(pn->lruvec_stats_percpu);
5248         kfree(pn);
5249 }
5250
5251 static void __mem_cgroup_free(struct mem_cgroup *memcg)
5252 {
5253         int node;
5254
5255         for_each_node(node)
5256                 free_mem_cgroup_per_node_info(memcg, node);
5257         free_percpu(memcg->vmstats_percpu);
5258         kfree(memcg);
5259 }
5260
5261 static void mem_cgroup_free(struct mem_cgroup *memcg)
5262 {
5263         memcg_wb_domain_exit(memcg);
5264         __mem_cgroup_free(memcg);
5265 }
5266
5267 static struct mem_cgroup *mem_cgroup_alloc(void)
5268 {
5269         struct mem_cgroup *memcg;
5270         unsigned int size;
5271         int node;
5272         int __maybe_unused i;
5273         long error = -ENOMEM;
5274
5275         size = sizeof(struct mem_cgroup);
5276         size += nr_node_ids * sizeof(struct mem_cgroup_per_node *);
5277
5278         memcg = kzalloc(size, GFP_KERNEL);
5279         if (!memcg)
5280                 return ERR_PTR(error);
5281
5282         memcg->id.id = idr_alloc(&mem_cgroup_idr, NULL,
5283                                  1, MEM_CGROUP_ID_MAX,
5284                                  GFP_KERNEL);
5285         if (memcg->id.id < 0) {
5286                 error = memcg->id.id;
5287                 goto fail;
5288         }
5289
5290         memcg->vmstats_percpu = alloc_percpu_gfp(struct memcg_vmstats_percpu,
5291                                                  GFP_KERNEL_ACCOUNT);
5292         if (!memcg->vmstats_percpu)
5293                 goto fail;
5294
5295         for_each_node(node)
5296                 if (alloc_mem_cgroup_per_node_info(memcg, node))
5297                         goto fail;
5298
5299         if (memcg_wb_domain_init(memcg, GFP_KERNEL))
5300                 goto fail;
5301
5302         INIT_WORK(&memcg->high_work, high_work_func);
5303         INIT_LIST_HEAD(&memcg->oom_notify);
5304         mutex_init(&memcg->thresholds_lock);
5305         spin_lock_init(&memcg->move_lock);
5306         vmpressure_init(&memcg->vmpressure);
5307         INIT_LIST_HEAD(&memcg->event_list);
5308         spin_lock_init(&memcg->event_list_lock);
5309         memcg->socket_pressure = jiffies;
5310 #ifdef CONFIG_MEMCG_KMEM
5311         memcg->kmemcg_id = -1;
5312         INIT_LIST_HEAD(&memcg->objcg_list);
5313 #endif
5314 #ifdef CONFIG_CGROUP_WRITEBACK
5315         INIT_LIST_HEAD(&memcg->cgwb_list);
5316         for (i = 0; i < MEMCG_CGWB_FRN_CNT; i++)
5317                 memcg->cgwb_frn[i].done =
5318                         __WB_COMPLETION_INIT(&memcg_cgwb_frn_waitq);
5319 #endif
5320 #ifdef CONFIG_TRANSPARENT_HUGEPAGE
5321         spin_lock_init(&memcg->deferred_split_queue.split_queue_lock);
5322         INIT_LIST_HEAD(&memcg->deferred_split_queue.split_queue);
5323         memcg->deferred_split_queue.split_queue_len = 0;
5324 #endif
5325         idr_replace(&mem_cgroup_idr, memcg, memcg->id.id);
5326         return memcg;
5327 fail:
5328         mem_cgroup_id_remove(memcg);
5329         __mem_cgroup_free(memcg);
5330         return ERR_PTR(error);
5331 }
5332
5333 static struct cgroup_subsys_state * __ref
5334 mem_cgroup_css_alloc(struct cgroup_subsys_state *parent_css)
5335 {
5336         struct mem_cgroup *parent = mem_cgroup_from_css(parent_css);
5337         struct mem_cgroup *memcg, *old_memcg;
5338         long error = -ENOMEM;
5339
5340         old_memcg = set_active_memcg(parent);
5341         memcg = mem_cgroup_alloc();
5342         set_active_memcg(old_memcg);
5343         if (IS_ERR(memcg))
5344                 return ERR_CAST(memcg);
5345
5346         page_counter_set_high(&memcg->memory, PAGE_COUNTER_MAX);
5347         memcg->soft_limit = PAGE_COUNTER_MAX;
5348         page_counter_set_high(&memcg->swap, PAGE_COUNTER_MAX);
5349         if (parent) {
5350                 memcg->swappiness = mem_cgroup_swappiness(parent);
5351                 memcg->oom_kill_disable = parent->oom_kill_disable;
5352
5353                 page_counter_init(&memcg->memory, &parent->memory);
5354                 page_counter_init(&memcg->swap, &parent->swap);
5355                 page_counter_init(&memcg->kmem, &parent->kmem);
5356                 page_counter_init(&memcg->tcpmem, &parent->tcpmem);
5357         } else {
5358                 page_counter_init(&memcg->memory, NULL);
5359                 page_counter_init(&memcg->swap, NULL);
5360                 page_counter_init(&memcg->kmem, NULL);
5361                 page_counter_init(&memcg->tcpmem, NULL);
5362
5363                 root_mem_cgroup = memcg;
5364                 return &memcg->css;
5365         }
5366
5367         /* The following stuff does not apply to the root */
5368         error = memcg_online_kmem(memcg);
5369         if (error)
5370                 goto fail;
5371
5372         if (cgroup_subsys_on_dfl(memory_cgrp_subsys) && !cgroup_memory_nosocket)
5373                 static_branch_inc(&memcg_sockets_enabled_key);
5374
5375         return &memcg->css;
5376 fail:
5377         mem_cgroup_id_remove(memcg);
5378         mem_cgroup_free(memcg);
5379         return ERR_PTR(error);
5380 }
5381
5382 static int mem_cgroup_css_online(struct cgroup_subsys_state *css)
5383 {
5384         struct mem_cgroup *memcg = mem_cgroup_from_css(css);
5385
5386         /*
5387          * A memcg must be visible for expand_shrinker_info()
5388          * by the time the maps are allocated. So, we allocate maps
5389          * here, when for_each_mem_cgroup() can't skip it.
5390          */
5391         if (alloc_shrinker_info(memcg)) {
5392                 mem_cgroup_id_remove(memcg);
5393                 return -ENOMEM;
5394         }
5395
5396         /* Online state pins memcg ID, memcg ID pins CSS */
5397         refcount_set(&memcg->id.ref, 1);
5398         css_get(css);
5399
5400         if (unlikely(mem_cgroup_is_root(memcg)))
5401                 queue_delayed_work(system_unbound_wq, &stats_flush_dwork,
5402                                    2UL*HZ);
5403         return 0;
5404 }
5405
5406 static void mem_cgroup_css_offline(struct cgroup_subsys_state *css)
5407 {
5408         struct mem_cgroup *memcg = mem_cgroup_from_css(css);
5409         struct mem_cgroup_event *event, *tmp;
5410
5411         /*
5412          * Unregister events and notify userspace.
5413          * Notify userspace about cgroup removing only after rmdir of cgroup
5414          * directory to avoid race between userspace and kernelspace.
5415          */
5416         spin_lock_irq(&memcg->event_list_lock);
5417         list_for_each_entry_safe(event, tmp, &memcg->event_list, list) {
5418                 list_del_init(&event->list);
5419                 schedule_work(&event->remove);
5420         }
5421         spin_unlock_irq(&memcg->event_list_lock);
5422
5423         page_counter_set_min(&memcg->memory, 0);
5424         page_counter_set_low(&memcg->memory, 0);
5425
5426         memcg_offline_kmem(memcg);
5427         reparent_shrinker_deferred(memcg);
5428         wb_memcg_offline(memcg);
5429
5430         drain_all_stock(memcg);
5431
5432         mem_cgroup_id_put(memcg);
5433 }
5434
5435 static void mem_cgroup_css_released(struct cgroup_subsys_state *css)
5436 {
5437         struct mem_cgroup *memcg = mem_cgroup_from_css(css);
5438
5439         invalidate_reclaim_iterators(memcg);
5440 }
5441
5442 static void mem_cgroup_css_free(struct cgroup_subsys_state *css)
5443 {
5444         struct mem_cgroup *memcg = mem_cgroup_from_css(css);
5445         int __maybe_unused i;
5446
5447 #ifdef CONFIG_CGROUP_WRITEBACK
5448         for (i = 0; i < MEMCG_CGWB_FRN_CNT; i++)
5449                 wb_wait_for_completion(&memcg->cgwb_frn[i].done);
5450 #endif
5451         if (cgroup_subsys_on_dfl(memory_cgrp_subsys) && !cgroup_memory_nosocket)
5452                 static_branch_dec(&memcg_sockets_enabled_key);
5453
5454         if (!cgroup_subsys_on_dfl(memory_cgrp_subsys) && memcg->tcpmem_active)
5455                 static_branch_dec(&memcg_sockets_enabled_key);
5456
5457         vmpressure_cleanup(&memcg->vmpressure);
5458         cancel_work_sync(&memcg->high_work);
5459         mem_cgroup_remove_from_trees(memcg);
5460         free_shrinker_info(memcg);
5461         memcg_free_kmem(memcg);
5462         mem_cgroup_free(memcg);
5463 }
5464
5465 /**
5466  * mem_cgroup_css_reset - reset the states of a mem_cgroup
5467  * @css: the target css
5468  *
5469  * Reset the states of the mem_cgroup associated with @css.  This is
5470  * invoked when the userland requests disabling on the default hierarchy
5471  * but the memcg is pinned through dependency.  The memcg should stop
5472  * applying policies and should revert to the vanilla state as it may be
5473  * made visible again.
5474  *
5475  * The current implementation only resets the essential configurations.
5476  * This needs to be expanded to cover all the visible parts.
5477  */
5478 static void mem_cgroup_css_reset(struct cgroup_subsys_state *css)
5479 {
5480         struct mem_cgroup *memcg = mem_cgroup_from_css(css);
5481
5482         page_counter_set_max(&memcg->memory, PAGE_COUNTER_MAX);
5483         page_counter_set_max(&memcg->swap, PAGE_COUNTER_MAX);
5484         page_counter_set_max(&memcg->kmem, PAGE_COUNTER_MAX);
5485         page_counter_set_max(&memcg->tcpmem, PAGE_COUNTER_MAX);
5486         page_counter_set_min(&memcg->memory, 0);
5487         page_counter_set_low(&memcg->memory, 0);
5488         page_counter_set_high(&memcg->memory, PAGE_COUNTER_MAX);
5489         memcg->soft_limit = PAGE_COUNTER_MAX;
5490         page_counter_set_high(&memcg->swap, PAGE_COUNTER_MAX);
5491         memcg_wb_domain_size_changed(memcg);
5492 }
5493
5494 static void mem_cgroup_css_rstat_flush(struct cgroup_subsys_state *css, int cpu)
5495 {
5496         struct mem_cgroup *memcg = mem_cgroup_from_css(css);
5497         struct mem_cgroup *parent = parent_mem_cgroup(memcg);
5498         struct memcg_vmstats_percpu *statc;
5499         long delta, v;
5500         int i, nid;
5501
5502         statc = per_cpu_ptr(memcg->vmstats_percpu, cpu);
5503
5504         for (i = 0; i < MEMCG_NR_STAT; i++) {
5505                 /*
5506                  * Collect the aggregated propagation counts of groups
5507                  * below us. We're in a per-cpu loop here and this is
5508                  * a global counter, so the first cycle will get them.
5509                  */
5510                 delta = memcg->vmstats.state_pending[i];
5511                 if (delta)
5512                         memcg->vmstats.state_pending[i] = 0;
5513
5514                 /* Add CPU changes on this level since the last flush */
5515                 v = READ_ONCE(statc->state[i]);
5516                 if (v != statc->state_prev[i]) {
5517                         delta += v - statc->state_prev[i];
5518                         statc->state_prev[i] = v;
5519                 }
5520
5521                 if (!delta)
5522                         continue;
5523
5524                 /* Aggregate counts on this level and propagate upwards */
5525                 memcg->vmstats.state[i] += delta;
5526                 if (parent)
5527                         parent->vmstats.state_pending[i] += delta;
5528         }
5529
5530         for (i = 0; i < NR_VM_EVENT_ITEMS; i++) {
5531                 delta = memcg->vmstats.events_pending[i];
5532                 if (delta)
5533                         memcg->vmstats.events_pending[i] = 0;
5534
5535                 v = READ_ONCE(statc->events[i]);
5536                 if (v != statc->events_prev[i]) {
5537                         delta += v - statc->events_prev[i];
5538                         statc->events_prev[i] = v;
5539                 }
5540
5541                 if (!delta)
5542                         continue;
5543
5544                 memcg->vmstats.events[i] += delta;
5545                 if (parent)
5546                         parent->vmstats.events_pending[i] += delta;
5547         }
5548
5549         for_each_node_state(nid, N_MEMORY) {
5550                 struct mem_cgroup_per_node *pn = memcg->nodeinfo[nid];
5551                 struct mem_cgroup_per_node *ppn = NULL;
5552                 struct lruvec_stats_percpu *lstatc;
5553
5554                 if (parent)
5555                         ppn = parent->nodeinfo[nid];
5556
5557                 lstatc = per_cpu_ptr(pn->lruvec_stats_percpu, cpu);
5558
5559                 for (i = 0; i < NR_VM_NODE_STAT_ITEMS; i++) {
5560                         delta = pn->lruvec_stats.state_pending[i];
5561                         if (delta)
5562                                 pn->lruvec_stats.state_pending[i] = 0;
5563
5564                         v = READ_ONCE(lstatc->state[i]);
5565                         if (v != lstatc->state_prev[i]) {
5566                                 delta += v - lstatc->state_prev[i];
5567                                 lstatc->state_prev[i] = v;
5568                         }
5569
5570                         if (!delta)
5571                                 continue;
5572
5573                         pn->lruvec_stats.state[i] += delta;
5574                         if (ppn)
5575                                 ppn->lruvec_stats.state_pending[i] += delta;
5576                 }
5577         }
5578 }
5579
5580 #ifdef CONFIG_MMU
5581 /* Handlers for move charge at task migration. */
5582 static int mem_cgroup_do_precharge(unsigned long count)
5583 {
5584         int ret;
5585
5586         /* Try a single bulk charge without reclaim first, kswapd may wake */
5587         ret = try_charge(mc.to, GFP_KERNEL & ~__GFP_DIRECT_RECLAIM, count);
5588         if (!ret) {
5589                 mc.precharge += count;
5590                 return ret;
5591         }
5592
5593         /* Try charges one by one with reclaim, but do not retry */
5594         while (count--) {
5595                 ret = try_charge(mc.to, GFP_KERNEL | __GFP_NORETRY, 1);
5596                 if (ret)
5597                         return ret;
5598                 mc.precharge++;
5599                 cond_resched();
5600         }
5601         return 0;
5602 }
5603
5604 union mc_target {
5605         struct page     *page;
5606         swp_entry_t     ent;
5607 };
5608
5609 enum mc_target_type {
5610         MC_TARGET_NONE = 0,
5611         MC_TARGET_PAGE,
5612         MC_TARGET_SWAP,
5613         MC_TARGET_DEVICE,
5614 };
5615
5616 static struct page *mc_handle_present_pte(struct vm_area_struct *vma,
5617                                                 unsigned long addr, pte_t ptent)
5618 {
5619         struct page *page = vm_normal_page(vma, addr, ptent);
5620
5621         if (!page || !page_mapped(page))
5622                 return NULL;
5623         if (PageAnon(page)) {
5624                 if (!(mc.flags & MOVE_ANON))
5625                         return NULL;
5626         } else {
5627                 if (!(mc.flags & MOVE_FILE))
5628                         return NULL;
5629         }
5630         if (!get_page_unless_zero(page))
5631                 return NULL;
5632
5633         return page;
5634 }
5635
5636 #if defined(CONFIG_SWAP) || defined(CONFIG_DEVICE_PRIVATE)
5637 static struct page *mc_handle_swap_pte(struct vm_area_struct *vma,
5638                         pte_t ptent, swp_entry_t *entry)
5639 {
5640         struct page *page = NULL;
5641         swp_entry_t ent = pte_to_swp_entry(ptent);
5642
5643         if (!(mc.flags & MOVE_ANON))
5644                 return NULL;
5645
5646         /*
5647          * Handle MEMORY_DEVICE_PRIVATE which are ZONE_DEVICE page belonging to
5648          * a device and because they are not accessible by CPU they are store
5649          * as special swap entry in the CPU page table.
5650          */
5651         if (is_device_private_entry(ent)) {
5652                 page = pfn_swap_entry_to_page(ent);
5653                 /*
5654                  * MEMORY_DEVICE_PRIVATE means ZONE_DEVICE page and which have
5655                  * a refcount of 1 when free (unlike normal page)
5656                  */
5657                 if (!page_ref_add_unless(page, 1, 1))
5658                         return NULL;
5659                 return page;
5660         }
5661
5662         if (non_swap_entry(ent))
5663                 return NULL;
5664
5665         /*
5666          * Because lookup_swap_cache() updates some statistics counter,
5667          * we call find_get_page() with swapper_space directly.
5668          */
5669         page = find_get_page(swap_address_space(ent), swp_offset(ent));
5670         entry->val = ent.val;
5671
5672         return page;
5673 }
5674 #else
5675 static struct page *mc_handle_swap_pte(struct vm_area_struct *vma,
5676                         pte_t ptent, swp_entry_t *entry)
5677 {
5678         return NULL;
5679 }
5680 #endif
5681
5682 static struct page *mc_handle_file_pte(struct vm_area_struct *vma,
5683                         unsigned long addr, pte_t ptent, swp_entry_t *entry)
5684 {
5685         if (!vma->vm_file) /* anonymous vma */
5686                 return NULL;
5687         if (!(mc.flags & MOVE_FILE))
5688                 return NULL;
5689
5690         /* page is moved even if it's not RSS of this task(page-faulted). */
5691         /* shmem/tmpfs may report page out on swap: account for that too. */
5692         return find_get_incore_page(vma->vm_file->f_mapping,
5693                         linear_page_index(vma, addr));
5694 }
5695
5696 /**
5697  * mem_cgroup_move_account - move account of the page
5698  * @page: the page
5699  * @compound: charge the page as compound or small page
5700  * @from: mem_cgroup which the page is moved from.
5701  * @to: mem_cgroup which the page is moved to. @from != @to.
5702  *
5703  * The caller must make sure the page is not on LRU (isolate_page() is useful.)
5704  *
5705  * This function doesn't do "charge" to new cgroup and doesn't do "uncharge"
5706  * from old cgroup.
5707  */
5708 static int mem_cgroup_move_account(struct page *page,
5709                                    bool compound,
5710                                    struct mem_cgroup *from,
5711                                    struct mem_cgroup *to)
5712 {
5713         struct lruvec *from_vec, *to_vec;
5714         struct pglist_data *pgdat;
5715         unsigned int nr_pages = compound ? thp_nr_pages(page) : 1;
5716         int ret;
5717
5718         VM_BUG_ON(from == to);
5719         VM_BUG_ON_PAGE(PageLRU(page), page);
5720         VM_BUG_ON(compound && !PageTransHuge(page));
5721
5722         /*
5723          * Prevent mem_cgroup_migrate() from looking at
5724          * page's memory cgroup of its source page while we change it.
5725          */
5726         ret = -EBUSY;
5727         if (!trylock_page(page))
5728                 goto out;
5729
5730         ret = -EINVAL;
5731         if (page_memcg(page) != from)
5732                 goto out_unlock;
5733
5734         pgdat = page_pgdat(page);
5735         from_vec = mem_cgroup_lruvec(from, pgdat);
5736         to_vec = mem_cgroup_lruvec(to, pgdat);
5737
5738         lock_page_memcg(page);
5739
5740         if (PageAnon(page)) {
5741                 if (page_mapped(page)) {
5742                         __mod_lruvec_state(from_vec, NR_ANON_MAPPED, -nr_pages);
5743                         __mod_lruvec_state(to_vec, NR_ANON_MAPPED, nr_pages);
5744                         if (PageTransHuge(page)) {
5745                                 __mod_lruvec_state(from_vec, NR_ANON_THPS,
5746                                                    -nr_pages);
5747                                 __mod_lruvec_state(to_vec, NR_ANON_THPS,
5748                                                    nr_pages);
5749                         }
5750                 }
5751         } else {
5752                 __mod_lruvec_state(from_vec, NR_FILE_PAGES, -nr_pages);
5753                 __mod_lruvec_state(to_vec, NR_FILE_PAGES, nr_pages);
5754
5755                 if (PageSwapBacked(page)) {
5756                         __mod_lruvec_state(from_vec, NR_SHMEM, -nr_pages);
5757                         __mod_lruvec_state(to_vec, NR_SHMEM, nr_pages);
5758                 }
5759
5760                 if (page_mapped(page)) {
5761                         __mod_lruvec_state(from_vec, NR_FILE_MAPPED, -nr_pages);
5762                         __mod_lruvec_state(to_vec, NR_FILE_MAPPED, nr_pages);
5763                 }
5764
5765                 if (PageDirty(page)) {
5766                         struct address_space *mapping = page_mapping(page);
5767
5768                         if (mapping_can_writeback(mapping)) {
5769                                 __mod_lruvec_state(from_vec, NR_FILE_DIRTY,
5770                                                    -nr_pages);
5771                                 __mod_lruvec_state(to_vec, NR_FILE_DIRTY,
5772                                                    nr_pages);
5773                         }
5774                 }
5775         }
5776
5777         if (PageWriteback(page)) {
5778                 __mod_lruvec_state(from_vec, NR_WRITEBACK, -nr_pages);
5779                 __mod_lruvec_state(to_vec, NR_WRITEBACK, nr_pages);
5780         }
5781
5782         /*
5783          * All state has been migrated, let's switch to the new memcg.
5784          *
5785          * It is safe to change page's memcg here because the page
5786          * is referenced, charged, isolated, and locked: we can't race
5787          * with (un)charging, migration, LRU putback, or anything else
5788          * that would rely on a stable page's memory cgroup.
5789          *
5790          * Note that lock_page_memcg is a memcg lock, not a page lock,
5791          * to save space. As soon as we switch page's memory cgroup to a
5792          * new memcg that isn't locked, the above state can change
5793          * concurrently again. Make sure we're truly done with it.
5794          */
5795         smp_mb();
5796
5797         css_get(&to->css);
5798         css_put(&from->css);
5799
5800         page->memcg_data = (unsigned long)to;
5801
5802         __unlock_page_memcg(from);
5803
5804         ret = 0;
5805
5806         local_irq_disable();
5807         mem_cgroup_charge_statistics(to, page, nr_pages);
5808         memcg_check_events(to, page);
5809         mem_cgroup_charge_statistics(from, page, -nr_pages);
5810         memcg_check_events(from, page);
5811         local_irq_enable();
5812 out_unlock:
5813         unlock_page(page);
5814 out:
5815         return ret;
5816 }
5817
5818 /**
5819  * get_mctgt_type - get target type of moving charge
5820  * @vma: the vma the pte to be checked belongs
5821  * @addr: the address corresponding to the pte to be checked
5822  * @ptent: the pte to be checked
5823  * @target: the pointer the target page or swap ent will be stored(can be NULL)
5824  *
5825  * Returns
5826  *   0(MC_TARGET_NONE): if the pte is not a target for move charge.
5827  *   1(MC_TARGET_PAGE): if the page corresponding to this pte is a target for
5828  *     move charge. if @target is not NULL, the page is stored in target->page
5829  *     with extra refcnt got(Callers should handle it).
5830  *   2(MC_TARGET_SWAP): if the swap entry corresponding to this pte is a
5831  *     target for charge migration. if @target is not NULL, the entry is stored
5832  *     in target->ent.
5833  *   3(MC_TARGET_DEVICE): like MC_TARGET_PAGE  but page is MEMORY_DEVICE_PRIVATE
5834  *     (so ZONE_DEVICE page and thus not on the lru).
5835  *     For now we such page is charge like a regular page would be as for all
5836  *     intent and purposes it is just special memory taking the place of a
5837  *     regular page.
5838  *
5839  *     See Documentations/vm/hmm.txt and include/linux/hmm.h
5840  *
5841  * Called with pte lock held.
5842  */
5843
5844 static enum mc_target_type get_mctgt_type(struct vm_area_struct *vma,
5845                 unsigned long addr, pte_t ptent, union mc_target *target)
5846 {
5847         struct page *page = NULL;
5848         enum mc_target_type ret = MC_TARGET_NONE;
5849         swp_entry_t ent = { .val = 0 };
5850
5851         if (pte_present(ptent))
5852                 page = mc_handle_present_pte(vma, addr, ptent);
5853         else if (is_swap_pte(ptent))
5854                 page = mc_handle_swap_pte(vma, ptent, &ent);
5855         else if (pte_none(ptent))
5856                 page = mc_handle_file_pte(vma, addr, ptent, &ent);
5857
5858         if (!page && !ent.val)
5859                 return ret;
5860         if (page) {
5861                 /*
5862                  * Do only loose check w/o serialization.
5863                  * mem_cgroup_move_account() checks the page is valid or
5864                  * not under LRU exclusion.
5865                  */
5866                 if (page_memcg(page) == mc.from) {
5867                         ret = MC_TARGET_PAGE;
5868                         if (is_device_private_page(page))
5869                                 ret = MC_TARGET_DEVICE;
5870                         if (target)
5871                                 target->page = page;
5872                 }
5873                 if (!ret || !target)
5874                         put_page(page);
5875         }
5876         /*
5877          * There is a swap entry and a page doesn't exist or isn't charged.
5878          * But we cannot move a tail-page in a THP.
5879          */
5880         if (ent.val && !ret && (!page || !PageTransCompound(page)) &&
5881             mem_cgroup_id(mc.from) == lookup_swap_cgroup_id(ent)) {
5882                 ret = MC_TARGET_SWAP;
5883                 if (target)
5884                         target->ent = ent;
5885         }
5886         return ret;
5887 }
5888
5889 #ifdef CONFIG_TRANSPARENT_HUGEPAGE
5890 /*
5891  * We don't consider PMD mapped swapping or file mapped pages because THP does
5892  * not support them for now.
5893  * Caller should make sure that pmd_trans_huge(pmd) is true.
5894  */
5895 static enum mc_target_type get_mctgt_type_thp(struct vm_area_struct *vma,
5896                 unsigned long addr, pmd_t pmd, union mc_target *target)
5897 {
5898         struct page *page = NULL;
5899         enum mc_target_type ret = MC_TARGET_NONE;
5900
5901         if (unlikely(is_swap_pmd(pmd))) {
5902                 VM_BUG_ON(thp_migration_supported() &&
5903                                   !is_pmd_migration_entry(pmd));
5904                 return ret;
5905         }
5906         page = pmd_page(pmd);
5907         VM_BUG_ON_PAGE(!page || !PageHead(page), page);
5908         if (!(mc.flags & MOVE_ANON))
5909                 return ret;
5910         if (page_memcg(page) == mc.from) {
5911                 ret = MC_TARGET_PAGE;
5912                 if (target) {
5913                         get_page(page);
5914                         target->page = page;
5915                 }
5916         }
5917         return ret;
5918 }
5919 #else
5920 static inline enum mc_target_type get_mctgt_type_thp(struct vm_area_struct *vma,
5921                 unsigned long addr, pmd_t pmd, union mc_target *target)
5922 {
5923         return MC_TARGET_NONE;
5924 }
5925 #endif
5926
5927 static int mem_cgroup_count_precharge_pte_range(pmd_t *pmd,
5928                                         unsigned long addr, unsigned long end,
5929                                         struct mm_walk *walk)
5930 {
5931         struct vm_area_struct *vma = walk->vma;
5932         pte_t *pte;
5933         spinlock_t *ptl;
5934
5935         ptl = pmd_trans_huge_lock(pmd, vma);
5936         if (ptl) {
5937                 /*
5938                  * Note their can not be MC_TARGET_DEVICE for now as we do not
5939                  * support transparent huge page with MEMORY_DEVICE_PRIVATE but
5940                  * this might change.
5941                  */
5942                 if (get_mctgt_type_thp(vma, addr, *pmd, NULL) == MC_TARGET_PAGE)
5943                         mc.precharge += HPAGE_PMD_NR;
5944                 spin_unlock(ptl);
5945                 return 0;
5946         }
5947
5948         if (pmd_trans_unstable(pmd))
5949                 return 0;
5950         pte = pte_offset_map_lock(vma->vm_mm, pmd, addr, &ptl);
5951         for (; addr != end; pte++, addr += PAGE_SIZE)
5952                 if (get_mctgt_type(vma, addr, *pte, NULL))
5953                         mc.precharge++; /* increment precharge temporarily */
5954         pte_unmap_unlock(pte - 1, ptl);
5955         cond_resched();
5956
5957         return 0;
5958 }
5959
5960 static const struct mm_walk_ops precharge_walk_ops = {
5961         .pmd_entry      = mem_cgroup_count_precharge_pte_range,
5962 };
5963
5964 static unsigned long mem_cgroup_count_precharge(struct mm_struct *mm)
5965 {
5966         unsigned long precharge;
5967
5968         mmap_read_lock(mm);
5969         walk_page_range(mm, 0, mm->highest_vm_end, &precharge_walk_ops, NULL);
5970         mmap_read_unlock(mm);
5971
5972         precharge = mc.precharge;
5973         mc.precharge = 0;
5974
5975         return precharge;
5976 }
5977
5978 static int mem_cgroup_precharge_mc(struct mm_struct *mm)
5979 {
5980         unsigned long precharge = mem_cgroup_count_precharge(mm);
5981
5982         VM_BUG_ON(mc.moving_task);
5983         mc.moving_task = current;
5984         return mem_cgroup_do_precharge(precharge);
5985 }
5986
5987 /* cancels all extra charges on mc.from and mc.to, and wakes up all waiters. */
5988 static void __mem_cgroup_clear_mc(void)
5989 {
5990         struct mem_cgroup *from = mc.from;
5991         struct mem_cgroup *to = mc.to;
5992
5993         /* we must uncharge all the leftover precharges from mc.to */
5994         if (mc.precharge) {
5995                 cancel_charge(mc.to, mc.precharge);
5996                 mc.precharge = 0;
5997         }
5998         /*
5999          * we didn't uncharge from mc.from at mem_cgroup_move_account(), so
6000          * we must uncharge here.
6001          */
6002         if (mc.moved_charge) {
6003                 cancel_charge(mc.from, mc.moved_charge);
6004                 mc.moved_charge = 0;
6005         }
6006         /* we must fixup refcnts and charges */
6007         if (mc.moved_swap) {
6008                 /* uncharge swap account from the old cgroup */
6009                 if (!mem_cgroup_is_root(mc.from))
6010                         page_counter_uncharge(&mc.from->memsw, mc.moved_swap);
6011
6012                 mem_cgroup_id_put_many(mc.from, mc.moved_swap);
6013
6014                 /*
6015                  * we charged both to->memory and to->memsw, so we
6016                  * should uncharge to->memory.
6017                  */
6018                 if (!mem_cgroup_is_root(mc.to))
6019                         page_counter_uncharge(&mc.to->memory, mc.moved_swap);
6020
6021                 mc.moved_swap = 0;
6022         }
6023         memcg_oom_recover(from);
6024         memcg_oom_recover(to);
6025         wake_up_all(&mc.waitq);
6026 }
6027
6028 static void mem_cgroup_clear_mc(void)
6029 {
6030         struct mm_struct *mm = mc.mm;
6031
6032         /*
6033          * we must clear moving_task before waking up waiters at the end of
6034          * task migration.
6035          */
6036         mc.moving_task = NULL;
6037         __mem_cgroup_clear_mc();
6038         spin_lock(&mc.lock);
6039         mc.from = NULL;
6040         mc.to = NULL;
6041         mc.mm = NULL;
6042         spin_unlock(&mc.lock);
6043
6044         mmput(mm);
6045 }
6046
6047 static int mem_cgroup_can_attach(struct cgroup_taskset *tset)
6048 {
6049         struct cgroup_subsys_state *css;
6050         struct mem_cgroup *memcg = NULL; /* unneeded init to make gcc happy */
6051         struct mem_cgroup *from;
6052         struct task_struct *leader, *p;
6053         struct mm_struct *mm;
6054         unsigned long move_flags;
6055         int ret = 0;
6056
6057         /* charge immigration isn't supported on the default hierarchy */
6058         if (cgroup_subsys_on_dfl(memory_cgrp_subsys))
6059                 return 0;
6060
6061         /*
6062          * Multi-process migrations only happen on the default hierarchy
6063          * where charge immigration is not used.  Perform charge
6064          * immigration if @tset contains a leader and whine if there are
6065          * multiple.
6066          */
6067         p = NULL;
6068         cgroup_taskset_for_each_leader(leader, css, tset) {
6069                 WARN_ON_ONCE(p);
6070                 p = leader;
6071                 memcg = mem_cgroup_from_css(css);
6072         }
6073         if (!p)
6074                 return 0;
6075
6076         /*
6077          * We are now committed to this value whatever it is. Changes in this
6078          * tunable will only affect upcoming migrations, not the current one.
6079          * So we need to save it, and keep it going.
6080          */
6081         move_flags = READ_ONCE(memcg->move_charge_at_immigrate);
6082         if (!move_flags)
6083                 return 0;
6084
6085         from = mem_cgroup_from_task(p);
6086
6087         VM_BUG_ON(from == memcg);
6088
6089         mm = get_task_mm(p);
6090         if (!mm)
6091                 return 0;
6092         /* We move charges only when we move a owner of the mm */
6093         if (mm->owner == p) {
6094                 VM_BUG_ON(mc.from);
6095                 VM_BUG_ON(mc.to);
6096                 VM_BUG_ON(mc.precharge);
6097                 VM_BUG_ON(mc.moved_charge);
6098                 VM_BUG_ON(mc.moved_swap);
6099
6100                 spin_lock(&mc.lock);
6101                 mc.mm = mm;
6102                 mc.from = from;
6103                 mc.to = memcg;
6104                 mc.flags = move_flags;
6105                 spin_unlock(&mc.lock);
6106                 /* We set mc.moving_task later */
6107
6108                 ret = mem_cgroup_precharge_mc(mm);
6109                 if (ret)
6110                         mem_cgroup_clear_mc();
6111         } else {
6112                 mmput(mm);
6113         }
6114         return ret;
6115 }
6116
6117 static void mem_cgroup_cancel_attach(struct cgroup_taskset *tset)
6118 {
6119         if (mc.to)
6120                 mem_cgroup_clear_mc();
6121 }
6122
6123 static int mem_cgroup_move_charge_pte_range(pmd_t *pmd,
6124                                 unsigned long addr, unsigned long end,
6125                                 struct mm_walk *walk)
6126 {
6127         int ret = 0;
6128         struct vm_area_struct *vma = walk->vma;
6129         pte_t *pte;
6130         spinlock_t *ptl;
6131         enum mc_target_type target_type;
6132         union mc_target target;
6133         struct page *page;
6134
6135         ptl = pmd_trans_huge_lock(pmd, vma);
6136         if (ptl) {
6137                 if (mc.precharge < HPAGE_PMD_NR) {
6138                         spin_unlock(ptl);
6139                         return 0;
6140                 }
6141                 target_type = get_mctgt_type_thp(vma, addr, *pmd, &target);
6142                 if (target_type == MC_TARGET_PAGE) {
6143                         page = target.page;
6144                         if (!isolate_lru_page(page)) {
6145                                 if (!mem_cgroup_move_account(page, true,
6146                                                              mc.from, mc.to)) {
6147                                         mc.precharge -= HPAGE_PMD_NR;
6148                                         mc.moved_charge += HPAGE_PMD_NR;
6149                                 }
6150                                 putback_lru_page(page);
6151                         }
6152                         put_page(page);
6153                 } else if (target_type == MC_TARGET_DEVICE) {
6154                         page = target.page;
6155                         if (!mem_cgroup_move_account(page, true,
6156                                                      mc.from, mc.to)) {
6157                                 mc.precharge -= HPAGE_PMD_NR;
6158                                 mc.moved_charge += HPAGE_PMD_NR;
6159                         }
6160                         put_page(page);
6161                 }
6162                 spin_unlock(ptl);
6163                 return 0;
6164         }
6165
6166         if (pmd_trans_unstable(pmd))
6167                 return 0;
6168 retry:
6169         pte = pte_offset_map_lock(vma->vm_mm, pmd, addr, &ptl);
6170         for (; addr != end; addr += PAGE_SIZE) {
6171                 pte_t ptent = *(pte++);
6172                 bool device = false;
6173                 swp_entry_t ent;
6174
6175                 if (!mc.precharge)
6176                         break;
6177
6178                 switch (get_mctgt_type(vma, addr, ptent, &target)) {
6179                 case MC_TARGET_DEVICE:
6180                         device = true;
6181                         fallthrough;
6182                 case MC_TARGET_PAGE:
6183                         page = target.page;
6184                         /*
6185                          * We can have a part of the split pmd here. Moving it
6186                          * can be done but it would be too convoluted so simply
6187                          * ignore such a partial THP and keep it in original
6188                          * memcg. There should be somebody mapping the head.
6189                          */
6190                         if (PageTransCompound(page))
6191                                 goto put;
6192                         if (!device && isolate_lru_page(page))
6193                                 goto put;
6194                         if (!mem_cgroup_move_account(page, false,
6195                                                 mc.from, mc.to)) {
6196                                 mc.precharge--;
6197                                 /* we uncharge from mc.from later. */
6198                                 mc.moved_charge++;
6199                         }
6200                         if (!device)
6201                                 putback_lru_page(page);
6202 put:                    /* get_mctgt_type() gets the page */
6203                         put_page(page);
6204                         break;
6205                 case MC_TARGET_SWAP:
6206                         ent = target.ent;
6207                         if (!mem_cgroup_move_swap_account(ent, mc.from, mc.to)) {
6208                                 mc.precharge--;
6209                                 mem_cgroup_id_get_many(mc.to, 1);
6210                                 /* we fixup other refcnts and charges later. */
6211                                 mc.moved_swap++;
6212                         }
6213                         break;
6214                 default:
6215                         break;
6216                 }
6217         }
6218         pte_unmap_unlock(pte - 1, ptl);
6219         cond_resched();
6220
6221         if (addr != end) {
6222                 /*
6223                  * We have consumed all precharges we got in can_attach().
6224                  * We try charge one by one, but don't do any additional
6225                  * charges to mc.to if we have failed in charge once in attach()
6226                  * phase.
6227                  */
6228                 ret = mem_cgroup_do_precharge(1);
6229                 if (!ret)
6230                         goto retry;
6231         }
6232
6233         return ret;
6234 }
6235
6236 static const struct mm_walk_ops charge_walk_ops = {
6237         .pmd_entry      = mem_cgroup_move_charge_pte_range,
6238 };
6239
6240 static void mem_cgroup_move_charge(void)
6241 {
6242         lru_add_drain_all();
6243         /*
6244          * Signal lock_page_memcg() to take the memcg's move_lock
6245          * while we're moving its pages to another memcg. Then wait
6246          * for already started RCU-only updates to finish.
6247          */
6248         atomic_inc(&mc.from->moving_account);
6249         synchronize_rcu();
6250 retry:
6251         if (unlikely(!mmap_read_trylock(mc.mm))) {
6252                 /*
6253                  * Someone who are holding the mmap_lock might be waiting in
6254                  * waitq. So we cancel all extra charges, wake up all waiters,
6255                  * and retry. Because we cancel precharges, we might not be able
6256                  * to move enough charges, but moving charge is a best-effort
6257                  * feature anyway, so it wouldn't be a big problem.
6258                  */
6259                 __mem_cgroup_clear_mc();
6260                 cond_resched();
6261                 goto retry;
6262         }
6263         /*
6264          * When we have consumed all precharges and failed in doing
6265          * additional charge, the page walk just aborts.
6266          */
6267         walk_page_range(mc.mm, 0, mc.mm->highest_vm_end, &charge_walk_ops,
6268                         NULL);
6269
6270         mmap_read_unlock(mc.mm);
6271         atomic_dec(&mc.from->moving_account);
6272 }
6273
6274 static void mem_cgroup_move_task(void)
6275 {
6276         if (mc.to) {
6277                 mem_cgroup_move_charge();
6278                 mem_cgroup_clear_mc();
6279         }
6280 }
6281 #else   /* !CONFIG_MMU */
6282 static int mem_cgroup_can_attach(struct cgroup_taskset *tset)
6283 {
6284         return 0;
6285 }
6286 static void mem_cgroup_cancel_attach(struct cgroup_taskset *tset)
6287 {
6288 }
6289 static void mem_cgroup_move_task(void)
6290 {
6291 }
6292 #endif
6293
6294 static int seq_puts_memcg_tunable(struct seq_file *m, unsigned long value)
6295 {
6296         if (value == PAGE_COUNTER_MAX)
6297                 seq_puts(m, "max\n");
6298         else
6299                 seq_printf(m, "%llu\n", (u64)value * PAGE_SIZE);
6300
6301         return 0;
6302 }
6303
6304 static u64 memory_current_read(struct cgroup_subsys_state *css,
6305                                struct cftype *cft)
6306 {
6307         struct mem_cgroup *memcg = mem_cgroup_from_css(css);
6308
6309         return (u64)page_counter_read(&memcg->memory) * PAGE_SIZE;
6310 }
6311
6312 static int memory_min_show(struct seq_file *m, void *v)
6313 {
6314         return seq_puts_memcg_tunable(m,
6315                 READ_ONCE(mem_cgroup_from_seq(m)->memory.min));
6316 }
6317
6318 static ssize_t memory_min_write(struct kernfs_open_file *of,
6319                                 char *buf, size_t nbytes, loff_t off)
6320 {
6321         struct mem_cgroup *memcg = mem_cgroup_from_css(of_css(of));
6322         unsigned long min;
6323         int err;
6324
6325         buf = strstrip(buf);
6326         err = page_counter_memparse(buf, "max", &min);
6327         if (err)
6328                 return err;
6329
6330         page_counter_set_min(&memcg->memory, min);
6331
6332         return nbytes;
6333 }
6334
6335 static int memory_low_show(struct seq_file *m, void *v)
6336 {
6337         return seq_puts_memcg_tunable(m,
6338                 READ_ONCE(mem_cgroup_from_seq(m)->memory.low));
6339 }
6340
6341 static ssize_t memory_low_write(struct kernfs_open_file *of,
6342                                 char *buf, size_t nbytes, loff_t off)
6343 {
6344         struct mem_cgroup *memcg = mem_cgroup_from_css(of_css(of));
6345         unsigned long low;
6346         int err;
6347
6348         buf = strstrip(buf);
6349         err = page_counter_memparse(buf, "max", &low);
6350         if (err)
6351                 return err;
6352
6353         page_counter_set_low(&memcg->memory, low);
6354
6355         return nbytes;
6356 }
6357
6358 static int memory_high_show(struct seq_file *m, void *v)
6359 {
6360         return seq_puts_memcg_tunable(m,
6361                 READ_ONCE(mem_cgroup_from_seq(m)->memory.high));
6362 }
6363
6364 static ssize_t memory_high_write(struct kernfs_open_file *of,
6365                                  char *buf, size_t nbytes, loff_t off)
6366 {
6367         struct mem_cgroup *memcg = mem_cgroup_from_css(of_css(of));
6368         unsigned int nr_retries = MAX_RECLAIM_RETRIES;
6369         bool drained = false;
6370         unsigned long high;
6371         int err;
6372
6373         buf = strstrip(buf);
6374         err = page_counter_memparse(buf, "max", &high);
6375         if (err)
6376                 return err;
6377
6378         page_counter_set_high(&memcg->memory, high);
6379
6380         for (;;) {
6381                 unsigned long nr_pages = page_counter_read(&memcg->memory);
6382                 unsigned long reclaimed;
6383
6384                 if (nr_pages <= high)
6385                         break;
6386
6387                 if (signal_pending(current))
6388                         break;
6389
6390                 if (!drained) {
6391                         drain_all_stock(memcg);
6392                         drained = true;
6393                         continue;
6394                 }
6395
6396                 reclaimed = try_to_free_mem_cgroup_pages(memcg, nr_pages - high,
6397                                                          GFP_KERNEL, true);
6398
6399                 if (!reclaimed && !nr_retries--)
6400                         break;
6401         }
6402
6403         memcg_wb_domain_size_changed(memcg);
6404         return nbytes;
6405 }
6406
6407 static int memory_max_show(struct seq_file *m, void *v)
6408 {
6409         return seq_puts_memcg_tunable(m,
6410                 READ_ONCE(mem_cgroup_from_seq(m)->memory.max));
6411 }
6412
6413 static ssize_t memory_max_write(struct kernfs_open_file *of,
6414                                 char *buf, size_t nbytes, loff_t off)
6415 {
6416         struct mem_cgroup *memcg = mem_cgroup_from_css(of_css(of));
6417         unsigned int nr_reclaims = MAX_RECLAIM_RETRIES;
6418         bool drained = false;
6419         unsigned long max;
6420         int err;
6421
6422         buf = strstrip(buf);
6423         err = page_counter_memparse(buf, "max", &max);
6424         if (err)
6425                 return err;
6426
6427         xchg(&memcg->memory.max, max);
6428
6429         for (;;) {
6430                 unsigned long nr_pages = page_counter_read(&memcg->memory);
6431
6432                 if (nr_pages <= max)
6433                         break;
6434
6435                 if (signal_pending(current))
6436                         break;
6437
6438                 if (!drained) {
6439                         drain_all_stock(memcg);
6440                         drained = true;
6441                         continue;
6442                 }
6443
6444                 if (nr_reclaims) {
6445                         if (!try_to_free_mem_cgroup_pages(memcg, nr_pages - max,
6446                                                           GFP_KERNEL, true))
6447                                 nr_reclaims--;
6448                         continue;
6449                 }
6450
6451                 memcg_memory_event(memcg, MEMCG_OOM);
6452                 if (!mem_cgroup_out_of_memory(memcg, GFP_KERNEL, 0))
6453                         break;
6454         }
6455
6456         memcg_wb_domain_size_changed(memcg);
6457         return nbytes;
6458 }
6459
6460 static void __memory_events_show(struct seq_file *m, atomic_long_t *events)
6461 {
6462         seq_printf(m, "low %lu\n", atomic_long_read(&events[MEMCG_LOW]));
6463         seq_printf(m, "high %lu\n", atomic_long_read(&events[MEMCG_HIGH]));
6464         seq_printf(m, "max %lu\n", atomic_long_read(&events[MEMCG_MAX]));
6465         seq_printf(m, "oom %lu\n", atomic_long_read(&events[MEMCG_OOM]));
6466         seq_printf(m, "oom_kill %lu\n",
6467                    atomic_long_read(&events[MEMCG_OOM_KILL]));
6468 }
6469
6470 static int memory_events_show(struct seq_file *m, void *v)
6471 {
6472         struct mem_cgroup *memcg = mem_cgroup_from_seq(m);
6473
6474         __memory_events_show(m, memcg->memory_events);
6475         return 0;
6476 }
6477
6478 static int memory_events_local_show(struct seq_file *m, void *v)
6479 {
6480         struct mem_cgroup *memcg = mem_cgroup_from_seq(m);
6481
6482         __memory_events_show(m, memcg->memory_events_local);
6483         return 0;
6484 }
6485
6486 static int memory_stat_show(struct seq_file *m, void *v)
6487 {
6488         struct mem_cgroup *memcg = mem_cgroup_from_seq(m);
6489         char *buf;
6490
6491         buf = memory_stat_format(memcg);
6492         if (!buf)
6493                 return -ENOMEM;
6494         seq_puts(m, buf);
6495         kfree(buf);
6496         return 0;
6497 }
6498
6499 #ifdef CONFIG_NUMA
6500 static inline unsigned long lruvec_page_state_output(struct lruvec *lruvec,
6501                                                      int item)
6502 {
6503         return lruvec_page_state(lruvec, item) * memcg_page_state_unit(item);
6504 }
6505
6506 static int memory_numa_stat_show(struct seq_file *m, void *v)
6507 {
6508         int i;
6509         struct mem_cgroup *memcg = mem_cgroup_from_seq(m);
6510
6511         mem_cgroup_flush_stats();
6512
6513         for (i = 0; i < ARRAY_SIZE(memory_stats); i++) {
6514                 int nid;
6515
6516                 if (memory_stats[i].idx >= NR_VM_NODE_STAT_ITEMS)
6517                         continue;
6518
6519                 seq_printf(m, "%s", memory_stats[i].name);
6520                 for_each_node_state(nid, N_MEMORY) {
6521                         u64 size;
6522                         struct lruvec *lruvec;
6523
6524                         lruvec = mem_cgroup_lruvec(memcg, NODE_DATA(nid));
6525                         size = lruvec_page_state_output(lruvec,
6526                                                         memory_stats[i].idx);
6527                         seq_printf(m, " N%d=%llu", nid, size);
6528                 }
6529                 seq_putc(m, '\n');
6530         }
6531
6532         return 0;
6533 }
6534 #endif
6535
6536 static int memory_oom_group_show(struct seq_file *m, void *v)
6537 {
6538         struct mem_cgroup *memcg = mem_cgroup_from_seq(m);
6539
6540         seq_printf(m, "%d\n", memcg->oom_group);
6541
6542         return 0;
6543 }
6544
6545 static ssize_t memory_oom_group_write(struct kernfs_open_file *of,
6546                                       char *buf, size_t nbytes, loff_t off)
6547 {
6548         struct mem_cgroup *memcg = mem_cgroup_from_css(of_css(of));
6549         int ret, oom_group;
6550
6551         buf = strstrip(buf);
6552         if (!buf)
6553                 return -EINVAL;
6554
6555         ret = kstrtoint(buf, 0, &oom_group);
6556         if (ret)
6557                 return ret;
6558
6559         if (oom_group != 0 && oom_group != 1)
6560                 return -EINVAL;
6561
6562         memcg->oom_group = oom_group;
6563
6564         return nbytes;
6565 }
6566
6567 static struct cftype memory_files[] = {
6568         {
6569                 .name = "current",
6570                 .flags = CFTYPE_NOT_ON_ROOT,
6571                 .read_u64 = memory_current_read,
6572         },
6573         {
6574                 .name = "min",
6575                 .flags = CFTYPE_NOT_ON_ROOT,
6576                 .seq_show = memory_min_show,
6577                 .write = memory_min_write,
6578         },
6579         {
6580                 .name = "low",
6581                 .flags = CFTYPE_NOT_ON_ROOT,
6582                 .seq_show = memory_low_show,
6583                 .write = memory_low_write,
6584         },
6585         {
6586                 .name = "high",
6587                 .flags = CFTYPE_NOT_ON_ROOT,
6588                 .seq_show = memory_high_show,
6589                 .write = memory_high_write,
6590         },
6591         {
6592                 .name = "max",
6593                 .flags = CFTYPE_NOT_ON_ROOT,
6594                 .seq_show = memory_max_show,
6595                 .write = memory_max_write,
6596         },
6597         {
6598                 .name = "events",
6599                 .flags = CFTYPE_NOT_ON_ROOT,
6600                 .file_offset = offsetof(struct mem_cgroup, events_file),
6601                 .seq_show = memory_events_show,
6602         },
6603         {
6604                 .name = "events.local",
6605                 .flags = CFTYPE_NOT_ON_ROOT,
6606                 .file_offset = offsetof(struct mem_cgroup, events_local_file),
6607                 .seq_show = memory_events_local_show,
6608         },
6609         {
6610                 .name = "stat",
6611                 .seq_show = memory_stat_show,
6612         },
6613 #ifdef CONFIG_NUMA
6614         {
6615                 .name = "numa_stat",
6616                 .seq_show = memory_numa_stat_show,
6617         },
6618 #endif
6619         {
6620                 .name = "oom.group",
6621                 .flags = CFTYPE_NOT_ON_ROOT | CFTYPE_NS_DELEGATABLE,
6622                 .seq_show = memory_oom_group_show,
6623                 .write = memory_oom_group_write,
6624         },
6625         { }     /* terminate */
6626 };
6627
6628 struct cgroup_subsys memory_cgrp_subsys = {
6629         .css_alloc = mem_cgroup_css_alloc,
6630         .css_online = mem_cgroup_css_online,
6631         .css_offline = mem_cgroup_css_offline,
6632         .css_released = mem_cgroup_css_released,
6633         .css_free = mem_cgroup_css_free,
6634         .css_reset = mem_cgroup_css_reset,
6635         .css_rstat_flush = mem_cgroup_css_rstat_flush,
6636         .can_attach = mem_cgroup_can_attach,
6637         .cancel_attach = mem_cgroup_cancel_attach,
6638         .post_attach = mem_cgroup_move_task,
6639         .dfl_cftypes = memory_files,
6640         .legacy_cftypes = mem_cgroup_legacy_files,
6641         .early_init = 0,
6642 };
6643
6644 /*
6645  * This function calculates an individual cgroup's effective
6646  * protection which is derived from its own memory.min/low, its
6647  * parent's and siblings' settings, as well as the actual memory
6648  * distribution in the tree.
6649  *
6650  * The following rules apply to the effective protection values:
6651  *
6652  * 1. At the first level of reclaim, effective protection is equal to
6653  *    the declared protection in memory.min and memory.low.
6654  *
6655  * 2. To enable safe delegation of the protection configuration, at
6656  *    subsequent levels the effective protection is capped to the
6657  *    parent's effective protection.
6658  *
6659  * 3. To make complex and dynamic subtrees easier to configure, the
6660  *    user is allowed to overcommit the declared protection at a given
6661  *    level. If that is the case, the parent's effective protection is
6662  *    distributed to the children in proportion to how much protection
6663  *    they have declared and how much of it they are utilizing.
6664  *
6665  *    This makes distribution proportional, but also work-conserving:
6666  *    if one cgroup claims much more protection than it uses memory,
6667  *    the unused remainder is available to its siblings.
6668  *
6669  * 4. Conversely, when the declared protection is undercommitted at a
6670  *    given level, the distribution of the larger parental protection
6671  *    budget is NOT proportional. A cgroup's protection from a sibling
6672  *    is capped to its own memory.min/low setting.
6673  *
6674  * 5. However, to allow protecting recursive subtrees from each other
6675  *    without having to declare each individual cgroup's fixed share
6676  *    of the ancestor's claim to protection, any unutilized -
6677  *    "floating" - protection from up the tree is distributed in
6678  *    proportion to each cgroup's *usage*. This makes the protection
6679  *    neutral wrt sibling cgroups and lets them compete freely over
6680  *    the shared parental protection budget, but it protects the
6681  *    subtree as a whole from neighboring subtrees.
6682  *
6683  * Note that 4. and 5. are not in conflict: 4. is about protecting
6684  * against immediate siblings whereas 5. is about protecting against
6685  * neighboring subtrees.
6686  */
6687 static unsigned long effective_protection(unsigned long usage,
6688                                           unsigned long parent_usage,
6689                                           unsigned long setting,
6690                                           unsigned long parent_effective,
6691                                           unsigned long siblings_protected)
6692 {
6693         unsigned long protected;
6694         unsigned long ep;
6695
6696         protected = min(usage, setting);
6697         /*
6698          * If all cgroups at this level combined claim and use more
6699          * protection then what the parent affords them, distribute
6700          * shares in proportion to utilization.
6701          *
6702          * We are using actual utilization rather than the statically
6703          * claimed protection in order to be work-conserving: claimed
6704          * but unused protection is available to siblings that would
6705          * otherwise get a smaller chunk than what they claimed.
6706          */
6707         if (siblings_protected > parent_effective)
6708                 return protected * parent_effective / siblings_protected;
6709
6710         /*
6711          * Ok, utilized protection of all children is within what the
6712          * parent affords them, so we know whatever this child claims
6713          * and utilizes is effectively protected.
6714          *
6715          * If there is unprotected usage beyond this value, reclaim
6716          * will apply pressure in proportion to that amount.
6717          *
6718          * If there is unutilized protection, the cgroup will be fully
6719          * shielded from reclaim, but we do return a smaller value for
6720          * protection than what the group could enjoy in theory. This
6721          * is okay. With the overcommit distribution above, effective
6722          * protection is always dependent on how memory is actually
6723          * consumed among the siblings anyway.
6724          */
6725         ep = protected;
6726
6727         /*
6728          * If the children aren't claiming (all of) the protection
6729          * afforded to them by the parent, distribute the remainder in
6730          * proportion to the (unprotected) memory of each cgroup. That
6731          * way, cgroups that aren't explicitly prioritized wrt each
6732          * other compete freely over the allowance, but they are
6733          * collectively protected from neighboring trees.
6734          *
6735          * We're using unprotected memory for the weight so that if
6736          * some cgroups DO claim explicit protection, we don't protect
6737          * the same bytes twice.
6738          *
6739          * Check both usage and parent_usage against the respective
6740          * protected values. One should imply the other, but they
6741          * aren't read atomically - make sure the division is sane.
6742          */
6743         if (!(cgrp_dfl_root.flags & CGRP_ROOT_MEMORY_RECURSIVE_PROT))
6744                 return ep;
6745         if (parent_effective > siblings_protected &&
6746             parent_usage > siblings_protected &&
6747             usage > protected) {
6748                 unsigned long unclaimed;
6749
6750                 unclaimed = parent_effective - siblings_protected;
6751                 unclaimed *= usage - protected;
6752                 unclaimed /= parent_usage - siblings_protected;
6753
6754                 ep += unclaimed;
6755         }
6756
6757         return ep;
6758 }
6759
6760 /**
6761  * mem_cgroup_calculate_protection - check if memory consumption is in the normal range
6762  * @root: the top ancestor of the sub-tree being checked
6763  * @memcg: the memory cgroup to check
6764  *
6765  * WARNING: This function is not stateless! It can only be used as part
6766  *          of a top-down tree iteration, not for isolated queries.
6767  */
6768 void mem_cgroup_calculate_protection(struct mem_cgroup *root,
6769                                      struct mem_cgroup *memcg)
6770 {
6771         unsigned long usage, parent_usage;
6772         struct mem_cgroup *parent;
6773
6774         if (mem_cgroup_disabled())
6775                 return;
6776
6777         if (!root)
6778                 root = root_mem_cgroup;
6779
6780         /*
6781          * Effective values of the reclaim targets are ignored so they
6782          * can be stale. Have a look at mem_cgroup_protection for more
6783          * details.
6784          * TODO: calculation should be more robust so that we do not need
6785          * that special casing.
6786          */
6787         if (memcg == root)
6788                 return;
6789
6790         usage = page_counter_read(&memcg->memory);
6791         if (!usage)
6792                 return;
6793
6794         parent = parent_mem_cgroup(memcg);
6795         /* No parent means a non-hierarchical mode on v1 memcg */
6796         if (!parent)
6797                 return;
6798
6799         if (parent == root) {
6800                 memcg->memory.emin = READ_ONCE(memcg->memory.min);
6801                 memcg->memory.elow = READ_ONCE(memcg->memory.low);
6802                 return;
6803         }
6804
6805         parent_usage = page_counter_read(&parent->memory);
6806
6807         WRITE_ONCE(memcg->memory.emin, effective_protection(usage, parent_usage,
6808                         READ_ONCE(memcg->memory.min),
6809                         READ_ONCE(parent->memory.emin),
6810                         atomic_long_read(&parent->memory.children_min_usage)));
6811
6812         WRITE_ONCE(memcg->memory.elow, effective_protection(usage, parent_usage,
6813                         READ_ONCE(memcg->memory.low),
6814                         READ_ONCE(parent->memory.elow),
6815                         atomic_long_read(&parent->memory.children_low_usage)));
6816 }
6817
6818 static int charge_memcg(struct page *page, struct mem_cgroup *memcg, gfp_t gfp)
6819 {
6820         unsigned int nr_pages = thp_nr_pages(page);
6821         int ret;
6822
6823         ret = try_charge(memcg, gfp, nr_pages);
6824         if (ret)
6825                 goto out;
6826
6827         css_get(&memcg->css);
6828         commit_charge(page, memcg);
6829
6830         local_irq_disable();
6831         mem_cgroup_charge_statistics(memcg, page, nr_pages);
6832         memcg_check_events(memcg, page);
6833         local_irq_enable();
6834 out:
6835         return ret;
6836 }
6837
6838 /**
6839  * __mem_cgroup_charge - charge a newly allocated page to a cgroup
6840  * @page: page to charge
6841  * @mm: mm context of the victim
6842  * @gfp_mask: reclaim mode
6843  *
6844  * Try to charge @page to the memcg that @mm belongs to, reclaiming
6845  * pages according to @gfp_mask if necessary. if @mm is NULL, try to
6846  * charge to the active memcg.
6847  *
6848  * Do not use this for pages allocated for swapin.
6849  *
6850  * Returns 0 on success. Otherwise, an error code is returned.
6851  */
6852 int __mem_cgroup_charge(struct page *page, struct mm_struct *mm,
6853                         gfp_t gfp_mask)
6854 {
6855         struct mem_cgroup *memcg;
6856         int ret;
6857
6858         memcg = get_mem_cgroup_from_mm(mm);
6859         ret = charge_memcg(page, memcg, gfp_mask);
6860         css_put(&memcg->css);
6861
6862         return ret;
6863 }
6864
6865 /**
6866  * mem_cgroup_swapin_charge_page - charge a newly allocated page for swapin
6867  * @page: page to charge
6868  * @mm: mm context of the victim
6869  * @gfp: reclaim mode
6870  * @entry: swap entry for which the page is allocated
6871  *
6872  * This function charges a page allocated for swapin. Please call this before
6873  * adding the page to the swapcache.
6874  *
6875  * Returns 0 on success. Otherwise, an error code is returned.
6876  */
6877 int mem_cgroup_swapin_charge_page(struct page *page, struct mm_struct *mm,
6878                                   gfp_t gfp, swp_entry_t entry)
6879 {
6880         struct mem_cgroup *memcg;
6881         unsigned short id;
6882         int ret;
6883
6884         if (mem_cgroup_disabled())
6885                 return 0;
6886
6887         id = lookup_swap_cgroup_id(entry);
6888         rcu_read_lock();
6889         memcg = mem_cgroup_from_id(id);
6890         if (!memcg || !css_tryget_online(&memcg->css))
6891                 memcg = get_mem_cgroup_from_mm(mm);
6892         rcu_read_unlock();
6893
6894         ret = charge_memcg(page, memcg, gfp);
6895
6896         css_put(&memcg->css);
6897         return ret;
6898 }
6899
6900 /*
6901  * mem_cgroup_swapin_uncharge_swap - uncharge swap slot
6902  * @entry: swap entry for which the page is charged
6903  *
6904  * Call this function after successfully adding the charged page to swapcache.
6905  *
6906  * Note: This function assumes the page for which swap slot is being uncharged
6907  * is order 0 page.
6908  */
6909 void mem_cgroup_swapin_uncharge_swap(swp_entry_t entry)
6910 {
6911         /*
6912          * Cgroup1's unified memory+swap counter has been charged with the
6913          * new swapcache page, finish the transfer by uncharging the swap
6914          * slot. The swap slot would also get uncharged when it dies, but
6915          * it can stick around indefinitely and we'd count the page twice
6916          * the entire time.
6917          *
6918          * Cgroup2 has separate resource counters for memory and swap,
6919          * so this is a non-issue here. Memory and swap charge lifetimes
6920          * correspond 1:1 to page and swap slot lifetimes: we charge the
6921          * page to memory here, and uncharge swap when the slot is freed.
6922          */
6923         if (!mem_cgroup_disabled() && do_memsw_account()) {
6924                 /*
6925                  * The swap entry might not get freed for a long time,
6926                  * let's not wait for it.  The page already received a
6927                  * memory+swap charge, drop the swap entry duplicate.
6928                  */
6929                 mem_cgroup_uncharge_swap(entry, 1);
6930         }
6931 }
6932
6933 struct uncharge_gather {
6934         struct mem_cgroup *memcg;
6935         unsigned long nr_memory;
6936         unsigned long pgpgout;
6937         unsigned long nr_kmem;
6938         struct page *dummy_page;
6939 };
6940
6941 static inline void uncharge_gather_clear(struct uncharge_gather *ug)
6942 {
6943         memset(ug, 0, sizeof(*ug));
6944 }
6945
6946 static void uncharge_batch(const struct uncharge_gather *ug)
6947 {
6948         unsigned long flags;
6949
6950         if (ug->nr_memory) {
6951                 page_counter_uncharge(&ug->memcg->memory, ug->nr_memory);
6952                 if (do_memsw_account())
6953                         page_counter_uncharge(&ug->memcg->memsw, ug->nr_memory);
6954                 if (!cgroup_subsys_on_dfl(memory_cgrp_subsys) && ug->nr_kmem)
6955                         page_counter_uncharge(&ug->memcg->kmem, ug->nr_kmem);
6956                 memcg_oom_recover(ug->memcg);
6957         }
6958
6959         local_irq_save(flags);
6960         __count_memcg_events(ug->memcg, PGPGOUT, ug->pgpgout);
6961         __this_cpu_add(ug->memcg->vmstats_percpu->nr_page_events, ug->nr_memory);
6962         memcg_check_events(ug->memcg, ug->dummy_page);
6963         local_irq_restore(flags);
6964
6965         /* drop reference from uncharge_page */
6966         css_put(&ug->memcg->css);
6967 }
6968
6969 static void uncharge_page(struct page *page, struct uncharge_gather *ug)
6970 {
6971         unsigned long nr_pages;
6972         struct mem_cgroup *memcg;
6973         struct obj_cgroup *objcg;
6974
6975         VM_BUG_ON_PAGE(PageLRU(page), page);
6976
6977         /*
6978          * Nobody should be changing or seriously looking at
6979          * page memcg or objcg at this point, we have fully
6980          * exclusive access to the page.
6981          */
6982         if (PageMemcgKmem(page)) {
6983                 objcg = __page_objcg(page);
6984                 /*
6985                  * This get matches the put at the end of the function and
6986                  * kmem pages do not hold memcg references anymore.
6987                  */
6988                 memcg = get_mem_cgroup_from_objcg(objcg);
6989         } else {
6990                 memcg = __page_memcg(page);
6991         }
6992
6993         if (!memcg)
6994                 return;
6995
6996         if (ug->memcg != memcg) {
6997                 if (ug->memcg) {
6998                         uncharge_batch(ug);
6999                         uncharge_gather_clear(ug);
7000                 }
7001                 ug->memcg = memcg;
7002                 ug->dummy_page = page;
7003
7004                 /* pairs with css_put in uncharge_batch */
7005                 css_get(&memcg->css);
7006         }
7007
7008         nr_pages = compound_nr(page);
7009
7010         if (PageMemcgKmem(page)) {
7011                 ug->nr_memory += nr_pages;
7012                 ug->nr_kmem += nr_pages;
7013
7014                 page->memcg_data = 0;
7015                 obj_cgroup_put(objcg);
7016         } else {
7017                 /* LRU pages aren't accounted at the root level */
7018                 if (!mem_cgroup_is_root(memcg))
7019                         ug->nr_memory += nr_pages;
7020                 ug->pgpgout++;
7021
7022                 page->memcg_data = 0;
7023         }
7024
7025         css_put(&memcg->css);
7026 }
7027
7028 /**
7029  * __mem_cgroup_uncharge - uncharge a page
7030  * @page: page to uncharge
7031  *
7032  * Uncharge a page previously charged with __mem_cgroup_charge().
7033  */
7034 void __mem_cgroup_uncharge(struct page *page)
7035 {
7036         struct uncharge_gather ug;
7037
7038         /* Don't touch page->lru of any random page, pre-check: */
7039         if (!page_memcg(page))
7040                 return;
7041
7042         uncharge_gather_clear(&ug);
7043         uncharge_page(page, &ug);
7044         uncharge_batch(&ug);
7045 }
7046
7047 /**
7048  * __mem_cgroup_uncharge_list - uncharge a list of page
7049  * @page_list: list of pages to uncharge
7050  *
7051  * Uncharge a list of pages previously charged with
7052  * __mem_cgroup_charge().
7053  */
7054 void __mem_cgroup_uncharge_list(struct list_head *page_list)
7055 {
7056         struct uncharge_gather ug;
7057         struct page *page;
7058
7059         uncharge_gather_clear(&ug);
7060         list_for_each_entry(page, page_list, lru)
7061                 uncharge_page(page, &ug);
7062         if (ug.memcg)
7063                 uncharge_batch(&ug);
7064 }
7065
7066 /**
7067  * mem_cgroup_migrate - charge a page's replacement
7068  * @oldpage: currently circulating page
7069  * @newpage: replacement page
7070  *
7071  * Charge @newpage as a replacement page for @oldpage. @oldpage will
7072  * be uncharged upon free.
7073  *
7074  * Both pages must be locked, @newpage->mapping must be set up.
7075  */
7076 void mem_cgroup_migrate(struct page *oldpage, struct page *newpage)
7077 {
7078         struct mem_cgroup *memcg;
7079         unsigned int nr_pages;
7080         unsigned long flags;
7081
7082         VM_BUG_ON_PAGE(!PageLocked(oldpage), oldpage);
7083         VM_BUG_ON_PAGE(!PageLocked(newpage), newpage);
7084         VM_BUG_ON_PAGE(PageAnon(oldpage) != PageAnon(newpage), newpage);
7085         VM_BUG_ON_PAGE(PageTransHuge(oldpage) != PageTransHuge(newpage),
7086                        newpage);
7087
7088         if (mem_cgroup_disabled())
7089                 return;
7090
7091         /* Page cache replacement: new page already charged? */
7092         if (page_memcg(newpage))
7093                 return;
7094
7095         memcg = page_memcg(oldpage);
7096         VM_WARN_ON_ONCE_PAGE(!memcg, oldpage);
7097         if (!memcg)
7098                 return;
7099
7100         /* Force-charge the new page. The old one will be freed soon */
7101         nr_pages = thp_nr_pages(newpage);
7102
7103         if (!mem_cgroup_is_root(memcg)) {
7104                 page_counter_charge(&memcg->memory, nr_pages);
7105                 if (do_memsw_account())
7106                         page_counter_charge(&memcg->memsw, nr_pages);
7107         }
7108
7109         css_get(&memcg->css);
7110         commit_charge(newpage, memcg);
7111
7112         local_irq_save(flags);
7113         mem_cgroup_charge_statistics(memcg, newpage, nr_pages);
7114         memcg_check_events(memcg, newpage);
7115         local_irq_restore(flags);
7116 }
7117
7118 DEFINE_STATIC_KEY_FALSE(memcg_sockets_enabled_key);
7119 EXPORT_SYMBOL(memcg_sockets_enabled_key);
7120
7121 void mem_cgroup_sk_alloc(struct sock *sk)
7122 {
7123         struct mem_cgroup *memcg;
7124
7125         if (!mem_cgroup_sockets_enabled)
7126                 return;
7127
7128         /* Do not associate the sock with unrelated interrupted task's memcg. */
7129         if (in_interrupt())
7130                 return;
7131
7132         rcu_read_lock();
7133         memcg = mem_cgroup_from_task(current);
7134         if (memcg == root_mem_cgroup)
7135                 goto out;
7136         if (!cgroup_subsys_on_dfl(memory_cgrp_subsys) && !memcg->tcpmem_active)
7137                 goto out;
7138         if (css_tryget(&memcg->css))
7139                 sk->sk_memcg = memcg;
7140 out:
7141         rcu_read_unlock();
7142 }
7143
7144 void mem_cgroup_sk_free(struct sock *sk)
7145 {
7146         if (sk->sk_memcg)
7147                 css_put(&sk->sk_memcg->css);
7148 }
7149
7150 /**
7151  * mem_cgroup_charge_skmem - charge socket memory
7152  * @memcg: memcg to charge
7153  * @nr_pages: number of pages to charge
7154  * @gfp_mask: reclaim mode
7155  *
7156  * Charges @nr_pages to @memcg. Returns %true if the charge fit within
7157  * @memcg's configured limit, %false if it doesn't.
7158  */
7159 bool mem_cgroup_charge_skmem(struct mem_cgroup *memcg, unsigned int nr_pages,
7160                              gfp_t gfp_mask)
7161 {
7162         if (!cgroup_subsys_on_dfl(memory_cgrp_subsys)) {
7163                 struct page_counter *fail;
7164
7165                 if (page_counter_try_charge(&memcg->tcpmem, nr_pages, &fail)) {
7166                         memcg->tcpmem_pressure = 0;
7167                         return true;
7168                 }
7169                 memcg->tcpmem_pressure = 1;
7170                 if (gfp_mask & __GFP_NOFAIL) {
7171                         page_counter_charge(&memcg->tcpmem, nr_pages);
7172                         return true;
7173                 }
7174                 return false;
7175         }
7176
7177         if (try_charge(memcg, gfp_mask, nr_pages) == 0) {
7178                 mod_memcg_state(memcg, MEMCG_SOCK, nr_pages);
7179                 return true;
7180         }
7181
7182         return false;
7183 }
7184
7185 /**
7186  * mem_cgroup_uncharge_skmem - uncharge socket memory
7187  * @memcg: memcg to uncharge
7188  * @nr_pages: number of pages to uncharge
7189  */
7190 void mem_cgroup_uncharge_skmem(struct mem_cgroup *memcg, unsigned int nr_pages)
7191 {
7192         if (!cgroup_subsys_on_dfl(memory_cgrp_subsys)) {
7193                 page_counter_uncharge(&memcg->tcpmem, nr_pages);
7194                 return;
7195         }
7196
7197         mod_memcg_state(memcg, MEMCG_SOCK, -nr_pages);
7198
7199         refill_stock(memcg, nr_pages);
7200 }
7201
7202 static int __init cgroup_memory(char *s)
7203 {
7204         char *token;
7205
7206         while ((token = strsep(&s, ",")) != NULL) {
7207                 if (!*token)
7208                         continue;
7209                 if (!strcmp(token, "nosocket"))
7210                         cgroup_memory_nosocket = true;
7211                 if (!strcmp(token, "nokmem"))
7212                         cgroup_memory_nokmem = true;
7213         }
7214         return 1;
7215 }
7216 __setup("cgroup.memory=", cgroup_memory);
7217
7218 /*
7219  * subsys_initcall() for memory controller.
7220  *
7221  * Some parts like memcg_hotplug_cpu_dead() have to be initialized from this
7222  * context because of lock dependencies (cgroup_lock -> cpu hotplug) but
7223  * basically everything that doesn't depend on a specific mem_cgroup structure
7224  * should be initialized from here.
7225  */
7226 static int __init mem_cgroup_init(void)
7227 {
7228         int cpu, node;
7229
7230         /*
7231          * Currently s32 type (can refer to struct batched_lruvec_stat) is
7232          * used for per-memcg-per-cpu caching of per-node statistics. In order
7233          * to work fine, we should make sure that the overfill threshold can't
7234          * exceed S32_MAX / PAGE_SIZE.
7235          */
7236         BUILD_BUG_ON(MEMCG_CHARGE_BATCH > S32_MAX / PAGE_SIZE);
7237
7238         cpuhp_setup_state_nocalls(CPUHP_MM_MEMCQ_DEAD, "mm/memctrl:dead", NULL,
7239                                   memcg_hotplug_cpu_dead);
7240
7241         for_each_possible_cpu(cpu)
7242                 INIT_WORK(&per_cpu_ptr(&memcg_stock, cpu)->work,
7243                           drain_local_stock);
7244
7245         for_each_node(node) {
7246                 struct mem_cgroup_tree_per_node *rtpn;
7247
7248                 rtpn = kzalloc_node(sizeof(*rtpn), GFP_KERNEL,
7249                                     node_online(node) ? node : NUMA_NO_NODE);
7250
7251                 rtpn->rb_root = RB_ROOT;
7252                 rtpn->rb_rightmost = NULL;
7253                 spin_lock_init(&rtpn->lock);
7254                 soft_limit_tree.rb_tree_per_node[node] = rtpn;
7255         }
7256
7257         return 0;
7258 }
7259 subsys_initcall(mem_cgroup_init);
7260
7261 #ifdef CONFIG_MEMCG_SWAP
7262 static struct mem_cgroup *mem_cgroup_id_get_online(struct mem_cgroup *memcg)
7263 {
7264         while (!refcount_inc_not_zero(&memcg->id.ref)) {
7265                 /*
7266                  * The root cgroup cannot be destroyed, so it's refcount must
7267                  * always be >= 1.
7268                  */
7269                 if (WARN_ON_ONCE(memcg == root_mem_cgroup)) {
7270                         VM_BUG_ON(1);
7271                         break;
7272                 }
7273                 memcg = parent_mem_cgroup(memcg);
7274                 if (!memcg)
7275                         memcg = root_mem_cgroup;
7276         }
7277         return memcg;
7278 }
7279
7280 /**
7281  * mem_cgroup_swapout - transfer a memsw charge to swap
7282  * @page: page whose memsw charge to transfer
7283  * @entry: swap entry to move the charge to
7284  *
7285  * Transfer the memsw charge of @page to @entry.
7286  */
7287 void mem_cgroup_swapout(struct page *page, swp_entry_t entry)
7288 {
7289         struct mem_cgroup *memcg, *swap_memcg;
7290         unsigned int nr_entries;
7291         unsigned short oldid;
7292
7293         VM_BUG_ON_PAGE(PageLRU(page), page);
7294         VM_BUG_ON_PAGE(page_count(page), page);
7295
7296         if (mem_cgroup_disabled())
7297                 return;
7298
7299         if (cgroup_subsys_on_dfl(memory_cgrp_subsys))
7300                 return;
7301
7302         memcg = page_memcg(page);
7303
7304         VM_WARN_ON_ONCE_PAGE(!memcg, page);
7305         if (!memcg)
7306                 return;
7307
7308         /*
7309          * In case the memcg owning these pages has been offlined and doesn't
7310          * have an ID allocated to it anymore, charge the closest online
7311          * ancestor for the swap instead and transfer the memory+swap charge.
7312          */
7313         swap_memcg = mem_cgroup_id_get_online(memcg);
7314         nr_entries = thp_nr_pages(page);
7315         /* Get references for the tail pages, too */
7316         if (nr_entries > 1)
7317                 mem_cgroup_id_get_many(swap_memcg, nr_entries - 1);
7318         oldid = swap_cgroup_record(entry, mem_cgroup_id(swap_memcg),
7319                                    nr_entries);
7320         VM_BUG_ON_PAGE(oldid, page);
7321         mod_memcg_state(swap_memcg, MEMCG_SWAP, nr_entries);
7322
7323         page->memcg_data = 0;
7324
7325         if (!mem_cgroup_is_root(memcg))
7326                 page_counter_uncharge(&memcg->memory, nr_entries);
7327
7328         if (!cgroup_memory_noswap && memcg != swap_memcg) {
7329                 if (!mem_cgroup_is_root(swap_memcg))
7330                         page_counter_charge(&swap_memcg->memsw, nr_entries);
7331                 page_counter_uncharge(&memcg->memsw, nr_entries);
7332         }
7333
7334         /*
7335          * Interrupts should be disabled here because the caller holds the
7336          * i_pages lock which is taken with interrupts-off. It is
7337          * important here to have the interrupts disabled because it is the
7338          * only synchronisation we have for updating the per-CPU variables.
7339          */
7340         memcg_stats_lock();
7341         mem_cgroup_charge_statistics(memcg, page, -nr_entries);
7342         memcg_stats_unlock();
7343         memcg_check_events(memcg, page);
7344
7345         css_put(&memcg->css);
7346 }
7347
7348 /**
7349  * __mem_cgroup_try_charge_swap - try charging swap space for a page
7350  * @page: page being added to swap
7351  * @entry: swap entry to charge
7352  *
7353  * Try to charge @page's memcg for the swap space at @entry.
7354  *
7355  * Returns 0 on success, -ENOMEM on failure.
7356  */
7357 int __mem_cgroup_try_charge_swap(struct page *page, swp_entry_t entry)
7358 {
7359         unsigned int nr_pages = thp_nr_pages(page);
7360         struct page_counter *counter;
7361         struct mem_cgroup *memcg;
7362         unsigned short oldid;
7363
7364         if (!cgroup_subsys_on_dfl(memory_cgrp_subsys))
7365                 return 0;
7366
7367         memcg = page_memcg(page);
7368
7369         VM_WARN_ON_ONCE_PAGE(!memcg, page);
7370         if (!memcg)
7371                 return 0;
7372
7373         if (!entry.val) {
7374                 memcg_memory_event(memcg, MEMCG_SWAP_FAIL);
7375                 return 0;
7376         }
7377
7378         memcg = mem_cgroup_id_get_online(memcg);
7379
7380         if (!cgroup_memory_noswap && !mem_cgroup_is_root(memcg) &&
7381             !page_counter_try_charge(&memcg->swap, nr_pages, &counter)) {
7382                 memcg_memory_event(memcg, MEMCG_SWAP_MAX);
7383                 memcg_memory_event(memcg, MEMCG_SWAP_FAIL);
7384                 mem_cgroup_id_put(memcg);
7385                 return -ENOMEM;
7386         }
7387
7388         /* Get references for the tail pages, too */
7389         if (nr_pages > 1)
7390                 mem_cgroup_id_get_many(memcg, nr_pages - 1);
7391         oldid = swap_cgroup_record(entry, mem_cgroup_id(memcg), nr_pages);
7392         VM_BUG_ON_PAGE(oldid, page);
7393         mod_memcg_state(memcg, MEMCG_SWAP, nr_pages);
7394
7395         return 0;
7396 }
7397
7398 /**
7399  * __mem_cgroup_uncharge_swap - uncharge swap space
7400  * @entry: swap entry to uncharge
7401  * @nr_pages: the amount of swap space to uncharge
7402  */
7403 void __mem_cgroup_uncharge_swap(swp_entry_t entry, unsigned int nr_pages)
7404 {
7405         struct mem_cgroup *memcg;
7406         unsigned short id;
7407
7408         id = swap_cgroup_record(entry, 0, nr_pages);
7409         rcu_read_lock();
7410         memcg = mem_cgroup_from_id(id);
7411         if (memcg) {
7412                 if (!cgroup_memory_noswap && !mem_cgroup_is_root(memcg)) {
7413                         if (cgroup_subsys_on_dfl(memory_cgrp_subsys))
7414                                 page_counter_uncharge(&memcg->swap, nr_pages);
7415                         else
7416                                 page_counter_uncharge(&memcg->memsw, nr_pages);
7417                 }
7418                 mod_memcg_state(memcg, MEMCG_SWAP, -nr_pages);
7419                 mem_cgroup_id_put_many(memcg, nr_pages);
7420         }
7421         rcu_read_unlock();
7422 }
7423
7424 long mem_cgroup_get_nr_swap_pages(struct mem_cgroup *memcg)
7425 {
7426         long nr_swap_pages = get_nr_swap_pages();
7427
7428         if (cgroup_memory_noswap || !cgroup_subsys_on_dfl(memory_cgrp_subsys))
7429                 return nr_swap_pages;
7430         for (; memcg != root_mem_cgroup; memcg = parent_mem_cgroup(memcg))
7431                 nr_swap_pages = min_t(long, nr_swap_pages,
7432                                       READ_ONCE(memcg->swap.max) -
7433                                       page_counter_read(&memcg->swap));
7434         return nr_swap_pages;
7435 }
7436
7437 bool mem_cgroup_swap_full(struct page *page)
7438 {
7439         struct mem_cgroup *memcg;
7440
7441         VM_BUG_ON_PAGE(!PageLocked(page), page);
7442
7443         if (vm_swap_full())
7444                 return true;
7445         if (cgroup_memory_noswap || !cgroup_subsys_on_dfl(memory_cgrp_subsys))
7446                 return false;
7447
7448         memcg = page_memcg(page);
7449         if (!memcg)
7450                 return false;
7451
7452         for (; memcg != root_mem_cgroup; memcg = parent_mem_cgroup(memcg)) {
7453                 unsigned long usage = page_counter_read(&memcg->swap);
7454
7455                 if (usage * 2 >= READ_ONCE(memcg->swap.high) ||
7456                     usage * 2 >= READ_ONCE(memcg->swap.max))
7457                         return true;
7458         }
7459
7460         return false;
7461 }
7462
7463 static int __init setup_swap_account(char *s)
7464 {
7465         if (!strcmp(s, "1"))
7466                 cgroup_memory_noswap = false;
7467         else if (!strcmp(s, "0"))
7468                 cgroup_memory_noswap = true;
7469         return 1;
7470 }
7471 __setup("swapaccount=", setup_swap_account);
7472
7473 static u64 swap_current_read(struct cgroup_subsys_state *css,
7474                              struct cftype *cft)
7475 {
7476         struct mem_cgroup *memcg = mem_cgroup_from_css(css);
7477
7478         return (u64)page_counter_read(&memcg->swap) * PAGE_SIZE;
7479 }
7480
7481 static int swap_high_show(struct seq_file *m, void *v)
7482 {
7483         return seq_puts_memcg_tunable(m,
7484                 READ_ONCE(mem_cgroup_from_seq(m)->swap.high));
7485 }
7486
7487 static ssize_t swap_high_write(struct kernfs_open_file *of,
7488                                char *buf, size_t nbytes, loff_t off)
7489 {
7490         struct mem_cgroup *memcg = mem_cgroup_from_css(of_css(of));
7491         unsigned long high;
7492         int err;
7493
7494         buf = strstrip(buf);
7495         err = page_counter_memparse(buf, "max", &high);
7496         if (err)
7497                 return err;
7498
7499         page_counter_set_high(&memcg->swap, high);
7500
7501         return nbytes;
7502 }
7503
7504 static int swap_max_show(struct seq_file *m, void *v)
7505 {
7506         return seq_puts_memcg_tunable(m,
7507                 READ_ONCE(mem_cgroup_from_seq(m)->swap.max));
7508 }
7509
7510 static ssize_t swap_max_write(struct kernfs_open_file *of,
7511                               char *buf, size_t nbytes, loff_t off)
7512 {
7513         struct mem_cgroup *memcg = mem_cgroup_from_css(of_css(of));
7514         unsigned long max;
7515         int err;
7516
7517         buf = strstrip(buf);
7518         err = page_counter_memparse(buf, "max", &max);
7519         if (err)
7520                 return err;
7521
7522         xchg(&memcg->swap.max, max);
7523
7524         return nbytes;
7525 }
7526
7527 static int swap_events_show(struct seq_file *m, void *v)
7528 {
7529         struct mem_cgroup *memcg = mem_cgroup_from_seq(m);
7530
7531         seq_printf(m, "high %lu\n",
7532                    atomic_long_read(&memcg->memory_events[MEMCG_SWAP_HIGH]));
7533         seq_printf(m, "max %lu\n",
7534                    atomic_long_read(&memcg->memory_events[MEMCG_SWAP_MAX]));
7535         seq_printf(m, "fail %lu\n",
7536                    atomic_long_read(&memcg->memory_events[MEMCG_SWAP_FAIL]));
7537
7538         return 0;
7539 }
7540
7541 static struct cftype swap_files[] = {
7542         {
7543                 .name = "swap.current",
7544                 .flags = CFTYPE_NOT_ON_ROOT,
7545                 .read_u64 = swap_current_read,
7546         },
7547         {
7548                 .name = "swap.high",
7549                 .flags = CFTYPE_NOT_ON_ROOT,
7550                 .seq_show = swap_high_show,
7551                 .write = swap_high_write,
7552         },
7553         {
7554                 .name = "swap.max",
7555                 .flags = CFTYPE_NOT_ON_ROOT,
7556                 .seq_show = swap_max_show,
7557                 .write = swap_max_write,
7558         },
7559         {
7560                 .name = "swap.events",
7561                 .flags = CFTYPE_NOT_ON_ROOT,
7562                 .file_offset = offsetof(struct mem_cgroup, swap_events_file),
7563                 .seq_show = swap_events_show,
7564         },
7565         { }     /* terminate */
7566 };
7567
7568 static struct cftype memsw_files[] = {
7569         {
7570                 .name = "memsw.usage_in_bytes",
7571                 .private = MEMFILE_PRIVATE(_MEMSWAP, RES_USAGE),
7572                 .read_u64 = mem_cgroup_read_u64,
7573         },
7574         {
7575                 .name = "memsw.max_usage_in_bytes",
7576                 .private = MEMFILE_PRIVATE(_MEMSWAP, RES_MAX_USAGE),
7577                 .write = mem_cgroup_reset,
7578                 .read_u64 = mem_cgroup_read_u64,
7579         },
7580         {
7581                 .name = "memsw.limit_in_bytes",
7582                 .private = MEMFILE_PRIVATE(_MEMSWAP, RES_LIMIT),
7583                 .write = mem_cgroup_write,
7584                 .read_u64 = mem_cgroup_read_u64,
7585         },
7586         {
7587                 .name = "memsw.failcnt",
7588                 .private = MEMFILE_PRIVATE(_MEMSWAP, RES_FAILCNT),
7589                 .write = mem_cgroup_reset,
7590                 .read_u64 = mem_cgroup_read_u64,
7591         },
7592         {
7593                 .name = "force_reclaim",
7594                 .write_u64 = mem_cgroup_force_reclaim,
7595         },
7596         { },    /* terminate */
7597 };
7598
7599 /*
7600  * If mem_cgroup_swap_init() is implemented as a subsys_initcall()
7601  * instead of a core_initcall(), this could mean cgroup_memory_noswap still
7602  * remains set to false even when memcg is disabled via "cgroup_disable=memory"
7603  * boot parameter. This may result in premature OOPS inside
7604  * mem_cgroup_get_nr_swap_pages() function in corner cases.
7605  */
7606 static int __init mem_cgroup_swap_init(void)
7607 {
7608         /* No memory control -> no swap control */
7609         if (mem_cgroup_disabled())
7610                 cgroup_memory_noswap = true;
7611
7612         if (cgroup_memory_noswap)
7613                 return 0;
7614
7615         WARN_ON(cgroup_add_dfl_cftypes(&memory_cgrp_subsys, swap_files));
7616         WARN_ON(cgroup_add_legacy_cftypes(&memory_cgrp_subsys, memsw_files));
7617
7618         return 0;
7619 }
7620 core_initcall(mem_cgroup_swap_init);
7621
7622 #endif /* CONFIG_MEMCG_SWAP */