From patchwork Mon Sep 11 16:40:24 2023 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Nhat Pham X-Patchwork-Id: 13379519 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from kanga.kvack.org (kanga.kvack.org [205.233.56.17]) by smtp.lore.kernel.org (Postfix) with ESMTP id 6B417EE7FF4 for ; Mon, 11 Sep 2023 16:40:32 +0000 (UTC) Received: by kanga.kvack.org (Postfix) id E8A816B02A8; Mon, 11 Sep 2023 12:40:30 -0400 (EDT) Received: by kanga.kvack.org (Postfix, from userid 40) id E14F66B02AA; Mon, 11 Sep 2023 12:40:30 -0400 (EDT) X-Delivered-To: int-list-linux-mm@kvack.org Received: by kanga.kvack.org (Postfix, from userid 63042) id C44D86B02AE; Mon, 11 Sep 2023 12:40:30 -0400 (EDT) X-Delivered-To: linux-mm@kvack.org Received: from relay.hostedemail.com (smtprelay0011.hostedemail.com [216.40.44.11]) by kanga.kvack.org (Postfix) with ESMTP id A9FB06B02A8 for ; Mon, 11 Sep 2023 12:40:30 -0400 (EDT) Received: from smtpin13.hostedemail.com (a10.router.float.18 [10.200.18.1]) by unirelay03.hostedemail.com (Postfix) with ESMTP id 82A9AA0A46 for ; Mon, 11 Sep 2023 16:40:30 +0000 (UTC) X-FDA: 81224879820.13.21A9453 Received: from mail-pf1-f170.google.com (mail-pf1-f170.google.com [209.85.210.170]) by imf02.hostedemail.com (Postfix) with ESMTP id 883F380023 for ; Mon, 11 Sep 2023 16:40:28 +0000 (UTC) Authentication-Results: imf02.hostedemail.com; dkim=pass header.d=gmail.com header.s=20221208 header.b=WW5GbZx5; spf=pass (imf02.hostedemail.com: domain of nphamcs@gmail.com designates 209.85.210.170 as permitted sender) smtp.mailfrom=nphamcs@gmail.com; dmarc=pass (policy=none) header.from=gmail.com ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=hostedemail.com; s=arc-20220608; t=1694450428; h=from:from:sender:reply-to:subject:subject:date:date: message-id:message-id:to:to:cc:cc:mime-version:mime-version: content-type:content-transfer-encoding:content-transfer-encoding: in-reply-to:in-reply-to:references:references:dkim-signature; bh=2+yJbtWq/JU7nHDuM4OdJdhnMoOlk0TeKkMt9I/sAHU=; b=6pAOzf/moOUvoe6Uf1AMfviE1yNKs48Oo6O37Ngk+0RS+ytoYLz2PqPHsbQ5y4uSgwA+iA qWkRV5NGgCyxKURXT568EOLB5svRqZArVBmWC3LY1oS9BEF/XdGqUtRJbY38iTN35lkoa2 T50+gV50E1XAPcxDzBUPHJWxPwFDchE= ARC-Seal: i=1; s=arc-20220608; d=hostedemail.com; t=1694450428; a=rsa-sha256; cv=none; b=2L45FEm0cP78ZJu1B1PParzLzWnEaQ0EkIQ2yY3gkAd7WbDt9OAUfkBbkfgLNtaSjpjc+j yU6dS/+/xZIGvO8JXsFZyEGRgXrd/T2vex0yJ5JW+gXaXcD6mSwNjCF+lWK9I7z+CvBDSX bwjWDcA2CEE6SLXYZrm8Tj6SYdS71zg= ARC-Authentication-Results: i=1; imf02.hostedemail.com; dkim=pass header.d=gmail.com header.s=20221208 header.b=WW5GbZx5; spf=pass (imf02.hostedemail.com: domain of nphamcs@gmail.com designates 209.85.210.170 as permitted sender) smtp.mailfrom=nphamcs@gmail.com; dmarc=pass (policy=none) header.from=gmail.com Received: by mail-pf1-f170.google.com with SMTP id d2e1a72fcca58-68fac16ee5fso1425749b3a.1 for ; Mon, 11 Sep 2023 09:40:28 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20221208; t=1694450427; x=1695055227; darn=kvack.org; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:from:to:cc:subject:date :message-id:reply-to; bh=2+yJbtWq/JU7nHDuM4OdJdhnMoOlk0TeKkMt9I/sAHU=; b=WW5GbZx50TdR4q0Ayyj9ouhIdh6LutUy4Lm/1RoNHvDO/62rZ+Ed35vlJFLFa7eImw +KgtXesUstTbqIGvpS5MKyVA9jRLjqh1Viw91HUIx5pDi6qFRhfS6zsnscPNwW78lFsz ePx18xcmx4h9AnKSqDY9OueFb87zqr0gD9NgWR2sW3y5q7Ma//ww17RqltczN4UVN066 kWC+1GcUJBdxPTOvG2Jb687pxZdJjEYISqsf6/Ipmb+7fIosc99xFTbt85J1dfaCc/LC pqlKLgtpvPMtu7C7lJuzqQP6JMM5svrbY4v3fW+17FJgN3d9YS1hbtc5VI0cD3cc+IJY 77zQ== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1694450427; x=1695055227; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:x-gm-message-state:from:to:cc :subject:date:message-id:reply-to; bh=2+yJbtWq/JU7nHDuM4OdJdhnMoOlk0TeKkMt9I/sAHU=; b=jAFssaBT2HMYSbJ/0SD4/pkI0AS1CVaWw9d8TbTwuI2yDr5BoCMigVWjf60TfmNoc2 S+s6gs1Lw4exTd3ebF8hvJKgtqyAc5TYtN4LJ0nSCApx2c8wF4oDwNaxWMicIcjRGG3a lUgIUG9lK26r43H4wd/iCmSLZ5QlIOx1v+VBk8IsjS9pbP67WIalAEoPMOQN3KQzLzyM l4VdNuqx0rgtMvlODTKU2iFXfNGWRpO5jQC+lyBng18Z9kIdKELD9Pdg8yOFCtFh+kl+ zGUOqRqsdL5kPiBGs4AdeoOd99K206cbgPrt7p6xD+yDv7UqAxxWz8TJjZ7LRGfzUuK5 jfpQ== X-Gm-Message-State: AOJu0YxkQs+oJGkQKE3wC6YoJbdOYJq3X6DU77msVnkYjBTPqKjTtEF9 0btY8glBRKg5rn0POcw8Si4= X-Google-Smtp-Source: AGHT+IGSFNBh+NQ+J2iMV/t2bf9GVX+gHQMsdjUCWqBXO5mSokmZ4++l9CNS6ACNGAKWoxtsJV6GKQ== X-Received: by 2002:a05:6a20:2584:b0:133:c12a:4d6 with SMTP id k4-20020a056a20258400b00133c12a04d6mr10139982pzd.1.1694450427153; Mon, 11 Sep 2023 09:40:27 -0700 (PDT) Received: from localhost (fwdproxy-prn-020.fbsv.net. [2a03:2880:ff:14::face:b00c]) by smtp.gmail.com with ESMTPSA id a5-20020aa780c5000000b0068be7119e55sm5735252pfn.122.2023.09.11.09.40.26 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Mon, 11 Sep 2023 09:40:26 -0700 (PDT) From: Nhat Pham To: akpm@linux-foundation.org Cc: hannes@cmpxchg.org, cerasuolodomenico@gmail.com, yosryahmed@google.com, sjenning@redhat.com, ddstreet@ieee.org, vitaly.wool@konsulko.com, mhocko@kernel.org, roman.gushchin@linux.dev, shakeelb@google.com, muchun.song@linux.dev, linux-mm@kvack.org, kernel-team@meta.com, linux-kernel@vger.kernel.org, cgroups@vger.kernel.org Subject: [PATCH 2/2] zswap: shrinks zswap pool based on memory pressure Date: Mon, 11 Sep 2023 09:40:24 -0700 Message-Id: <20230911164024.2541401-3-nphamcs@gmail.com> X-Mailer: git-send-email 2.34.1 In-Reply-To: <20230911164024.2541401-1-nphamcs@gmail.com> References: <20230911164024.2541401-1-nphamcs@gmail.com> MIME-Version: 1.0 X-Rspamd-Queue-Id: 883F380023 X-Rspam-User: X-Stat-Signature: m4gbd7mdtdwe13i3uki4ah1rgtxi37g9 X-Rspamd-Server: rspam03 X-HE-Tag: 1694450428-500386 X-HE-Meta: U2FsdGVkX181oH+wesDN5kta4GTDR1hfAU96DaY9a8HPOrJJbiZZ+UP0lQ4PxvY6XHwynZ9RAFR83076CKc6e8zweoUwKmEC6nZauN+TTb7ICwIeeS7S5T6RgzklMUWd8cFqKp+357sPRcJ7nZikOLoaUZWvmGDPfF/rwgRm3dv6yFtQOITnDtbSP6UayHwxvIyB+ecpq0jNrvTX67oTBNNR+h/zieliEOzEXvKT94udqAAgpMGCIYNc0PukzanYyCKu/qx7GQDtagCJB7jh50BpRaXiqT0gWHsmobsZJcP48Oi9x9y4bzthrp/6JAf3VlLIEo4+wyqK6fbu7kmyMvO2EZ/tMmwKfRCJsxJ8eqCRkdXTQAHd2UyPnnR8FU0Yz9bUtkJaodgkPOdNZw0nc9MPg1d5XJvCHrQV5inBmsxuTcOqvB93PAQz2tR5Dk5AuqxfNK+VvMcqDmjXrib5hH139JdYvlQF7FM6glv9h3D/XGou4w0wGB440zlcNVu2EreW4H4TNg8RlGR7UPT6DbdH5hQpwyoWoRE7qJuMHFSdy34cfWHGclnVIcWI53b1+bS0ZCMjcIKS5tKthSqSujjwO7ZLTtn2QaZmFnJy9hEOh3uMEpPG/zC1yyaw0tdH0GbnONOhOD8hyMKUj3rn/OPfqa6KnjvcHEGCSQx8jh31gL1hy/ZBqFJNkgSb0kc8I4uBnUQmks/q+PRry1xa+r1aNVnaqD9gm7+dINJwWLmIwzT+p0Ur/nvvvXwFOmb0pPVZu/FCP2zPx+9GeAVnoO3csGj6QZ23/jzS4DDK+IjTU81qKWIiA0NWszCVFwSYGs1waSBydu73cRymhLQaUXvmvq8Qvylm2qFhTRQToBKf63dEyAlWqAYIcaqwdBqMMAvJeqagQyFhn9E8uyiEzrOZAy5/aUIDIOc6caOzX5WJ0HJhV0QMfg57RDfoQaDd3PpZqLnVrfu5fhkrgv9 uBSz1x5d Pr/Wt/q7geis9cMeQvyKX9A+7m5xvywDoP7OB1WRHiohwzHCTJpiVdy+hIwiW2bUjK+6RGCPKbs9SNDlSlUmAlbU6+mOg6YE1apspkqlu3tHk0VOZNipeG+IkJ0NLhOEhN8+/hg+gOrcJp4gT0IVEGHc9BJ/0a8eOEqYsbT+POy0twncxEqvLx8h7qmgpmsL35mtks2A3iGTRR5LTsA8dpidVCNs9EUmVZlnUIVGgV+ZhF6XcCD6g0Swjh4AW+EBWjSsyaVqvuHXEhxXFCdO58xWP0gznNhE0tLnZjNN16F4craQ9nQoGTob/rdoD8DWCYAsmi1uVT7AiRWh/8+Tj+FNDsD6+4DRy7PdO5aBF43LVzHQMsqqo2Dniidk5pO5gHJs9j7xfD0/qtYX7BiKyxilkFqje6ZV2sJRVE0lYkRDNrjf5zcdlNQn9nlVWB2x71JRJ74VImxVpXoDSiLGfbkI1nuifrmwxkBh1OEnJTApTwKE= X-Bogosity: Ham, tests=bogofilter, spamicity=0.000000, version=1.2.4 Sender: owner-linux-mm@kvack.org Precedence: bulk X-Loop: owner-majordomo@kvack.org List-ID: Currently, we only shrink the zswap pool when the user-defined limit is hit. This means that if we set the limit too high, cold data that are unlikely to be used again will reside in the pool, wasting precious memory. It is hard to predict how much zswap space will be needed ahead of time, as this depends on the workload (specifically, on factors such as memory access patterns and compressibility of the memory pages). This patch implements a memcg- and NUMA-aware shrinker for zswap, that is initiated when there is memory pressure. The shrinker does not have any parameter that must be tuned by the user, and can be opted in or out on a per-memcg basis. Furthermore, to make it more robust for many workloads and prevent overshrinking (i.e evicting warm pages that might be refaulted into memory), we build in the following heuristics: * Estimate the number of warm pages residing in zswap, and attempt to protect this region of the zswap LRU. * Scale the number of freeable objects by an estimate of the memory saving factor. The better zswap compresses the data, the fewer pages we will evict to swap (as we will otherwise incur IO for relatively small memory saving). * During reclaim, if the shrinker encounters a page that is also being brought into memory, the shrinker will cautiously terminate its shrinking action, as this is a sign that it is touching the warmer region of the zswap LRU. On a benchmark that we have run: (without the shrinker) real -- mean: 153.27s, median: 153.199s sys -- mean: 541.652s, median: 541.903s user -- mean: 4384.9673999999995s, median: 4385.471s (with the shrinker) real -- mean: 151.4956s, median: 151.456s sys -- mean: 461.14639999999997s, median: 465.656s user -- mean: 4384.7118s, median: 4384.675s We observed a 14-15% reduction in kernel CPU time, which translated to over 1% reduction in real time. On another benchmark, where there was a lot more cold memory residing in zswap, we observed even more pronounced gains: (without the shrinker) real -- mean: 157.52519999999998s, median: 157.281s sys -- mean: 769.3082s, median: 780.545s user -- mean: 4378.1622s, median: 4378.286s (with the shrinker) real -- mean: 152.9608s, median: 152.845s sys -- mean: 517.4446s, median: 506.749s user -- mean: 4387.694s, median: 4387.935s Here, we saw around 32-35% reduction in kernel CPU time, which translated to 2.8% reduction in real time. These results confirm our hypothesis that the shrinker is more helpful the more cold memory we have. Suggested-by: Johannes Weiner Signed-off-by: Nhat Pham --- Documentation/admin-guide/mm/zswap.rst | 12 ++ include/linux/memcontrol.h | 1 + include/linux/mmzone.h | 14 +++ mm/memcontrol.c | 33 ++++++ mm/swap_state.c | 31 ++++- mm/zswap.c | 152 ++++++++++++++++++++++++- 6 files changed, 238 insertions(+), 5 deletions(-) diff --git a/Documentation/admin-guide/mm/zswap.rst b/Documentation/admin-guide/mm/zswap.rst index 45b98390e938..ae8597a67804 100644 --- a/Documentation/admin-guide/mm/zswap.rst +++ b/Documentation/admin-guide/mm/zswap.rst @@ -153,6 +153,18 @@ attribute, e. g.:: Setting this parameter to 100 will disable the hysteresis. +When there is a sizable amount of cold memory residing in the zswap pool, it +can be advantageous to proactively write these cold pages to swap and reclaim +the memory for other use cases. By default, the zswap shrinker is disabled. +User can enable it by first switching on the global knob: + + echo Y > /sys/module/zswap/par meters/shrinker_enabled + +When the kernel is compiled with CONFIG_MEMCG_KMEM, user needs to further turn +it on for each cgroup that the shrinker should target: + + echo 1 > /sys/fs/cgroup//memory.zswap.shrinker.enabled + A debugfs interface is provided for various statistic about pool size, number of pages stored, same-value filled pages and various counters for the reasons pages are rejected. diff --git a/include/linux/memcontrol.h b/include/linux/memcontrol.h index 11810a2cfd2d..a8f133ee87ee 100644 --- a/include/linux/memcontrol.h +++ b/include/linux/memcontrol.h @@ -229,6 +229,7 @@ struct mem_cgroup { #if defined(CONFIG_MEMCG_KMEM) && defined(CONFIG_ZSWAP) unsigned long zswap_max; + atomic_t zswap_shrinker_enabled; #endif unsigned long soft_limit; diff --git a/include/linux/mmzone.h b/include/linux/mmzone.h index 4106fbc5b4b3..81f4c5ea3e16 100644 --- a/include/linux/mmzone.h +++ b/include/linux/mmzone.h @@ -637,6 +637,20 @@ struct lruvec { #ifdef CONFIG_MEMCG struct pglist_data *pgdat; #endif +#ifdef CONFIG_ZSWAP + /* + * Number of pages in zswap that should be protected from the shrinker. + * This number is an estimate of the following counts: + * + * a) Recent page faults. + * b) Recent insertion to the zswap LRU. This includes new zswap stores, + * as well as recent zswap LRU rotations. + * + * These pages are likely to be warm, and might incur IO if the are written + * to swap. + */ + unsigned long nr_zswap_protected; +#endif }; /* Isolate unmapped pages */ diff --git a/mm/memcontrol.c b/mm/memcontrol.c index a4d3282493b6..6132ef80da92 100644 --- a/mm/memcontrol.c +++ b/mm/memcontrol.c @@ -5350,6 +5350,8 @@ mem_cgroup_css_alloc(struct cgroup_subsys_state *parent_css) WRITE_ONCE(memcg->soft_limit, PAGE_COUNTER_MAX); #if defined(CONFIG_MEMCG_KMEM) && defined(CONFIG_ZSWAP) memcg->zswap_max = PAGE_COUNTER_MAX; + /* Disable the shrinker by default */ + atomic_set(&memcg->zswap_shrinker_enabled, 0); #endif page_counter_set_high(&memcg->swap, PAGE_COUNTER_MAX); if (parent) { @@ -7867,6 +7869,31 @@ static ssize_t zswap_max_write(struct kernfs_open_file *of, return nbytes; } +static int zswap_shrinker_enabled_show(struct seq_file *m, void *v) +{ + struct mem_cgroup *memcg = mem_cgroup_from_seq(m); + + seq_printf(m, "%d\n", atomic_read(&memcg->zswap_shrinker_enabled)); + return 0; +} + +static ssize_t zswap_shrinker_enabled_write(struct kernfs_open_file *of, + char *buf, size_t nbytes, loff_t off) +{ + struct mem_cgroup *memcg = mem_cgroup_from_css(of_css(of)); + int zswap_shrinker_enabled; + ssize_t parse_ret = kstrtoint(strstrip(buf), 0, &zswap_shrinker_enabled); + + if (parse_ret) + return parse_ret; + + if (zswap_shrinker_enabled < 0 || zswap_shrinker_enabled > 1) + return -ERANGE; + + atomic_set(&memcg->zswap_shrinker_enabled, zswap_shrinker_enabled); + return nbytes; +} + static struct cftype zswap_files[] = { { .name = "zswap.current", @@ -7879,6 +7906,12 @@ static struct cftype zswap_files[] = { .seq_show = zswap_max_show, .write = zswap_max_write, }, + { + .name = "zswap.shrinker.enabled", + .flags = CFTYPE_NOT_ON_ROOT, + .seq_show = zswap_shrinker_enabled_show, + .write = zswap_shrinker_enabled_write, + }, { } /* terminate */ }; #endif /* CONFIG_MEMCG_KMEM && CONFIG_ZSWAP */ diff --git a/mm/swap_state.c b/mm/swap_state.c index 1c826737aacb..788e36a06c34 100644 --- a/mm/swap_state.c +++ b/mm/swap_state.c @@ -618,6 +618,22 @@ static unsigned long swapin_nr_pages(unsigned long offset) return pages; } +#ifdef CONFIG_ZSWAP +/* + * Refault is an indication that warmer pages are not resident in memory. + * Increase the size of zswap's protected area. + */ +static void inc_nr_protected(struct page *page) +{ + struct lruvec *lruvec = folio_lruvec(page_folio(page)); + unsigned long flags; + + spin_lock_irqsave(&lruvec->lru_lock, flags); + lruvec->nr_zswap_protected++; + spin_unlock_irqrestore(&lruvec->lru_lock, flags); +} +#endif + /** * swap_cluster_readahead - swap in pages in hope we need them soon * @entry: swap entry of this memory @@ -686,7 +702,12 @@ struct page *swap_cluster_readahead(swp_entry_t entry, gfp_t gfp_mask, lru_add_drain(); /* Push any new pages onto the LRU now */ skip: /* The page was likely read above, so no need for plugging here */ - return read_swap_cache_async(entry, gfp_mask, vma, addr, NULL); + page = read_swap_cache_async(entry, gfp_mask, vma, addr, NULL); +#ifdef CONFIG_ZSWAP + if (page) + inc_nr_protected(page); +#endif + return page; } int init_swap_address_space(unsigned int type, unsigned long nr_pages) @@ -853,8 +874,12 @@ static struct page *swap_vma_readahead(swp_entry_t fentry, gfp_t gfp_mask, lru_add_drain(); skip: /* The page was likely read above, so no need for plugging here */ - return read_swap_cache_async(fentry, gfp_mask, vma, vmf->address, - NULL); + page = read_swap_cache_async(fentry, gfp_mask, vma, vmf->address, NULL); +#ifdef CONFIG_ZSWAP + if (page) + inc_nr_protected(page); +#endif + return page; } /** diff --git a/mm/zswap.c b/mm/zswap.c index 83386200222a..ee4909891cce 100644 --- a/mm/zswap.c +++ b/mm/zswap.c @@ -145,6 +145,26 @@ module_param_named(exclusive_loads, zswap_exclusive_loads_enabled, bool, 0644); /* Number of zpools in zswap_pool (empirically determined for scalability) */ #define ZSWAP_NR_ZPOOLS 32 +/* + * Global flag to enable/disable memory pressure-based shrinker for all memcgs. + * If CONFIG_MEMCG_KMEM is on, we can further selectively disable + * the shrinker for each memcg. + */ +static bool zswap_shrinker_enabled; +module_param_named(shrinker_enabled, zswap_shrinker_enabled, bool, 0644); +#ifdef CONFIG_MEMCG_KMEM +static bool is_shrinker_enabled(struct mem_cgroup *memcg) +{ + return zswap_shrinker_enabled && + atomic_read(&memcg->zswap_shrinker_enabled); +} +#else +static bool is_shrinker_enabled(struct mem_cgroup *memcg) +{ + return zswap_shrinker_enabled; +} +#endif + /********************************* * data structures **********************************/ @@ -174,6 +194,7 @@ struct zswap_pool { char tfm_name[CRYPTO_MAX_ALG_NAME]; struct list_lru list_lru; struct mem_cgroup *next_shrink; + struct shrinker shrinker; }; /* @@ -318,8 +339,23 @@ static bool zswap_lru_add(struct list_lru *list_lru, struct zswap_entry *entry) { struct mem_cgroup *memcg = entry->objcg ? get_mem_cgroup_from_objcg(entry->objcg) : NULL; + struct lruvec *lruvec = mem_cgroup_lruvec(memcg, NODE_DATA(entry->nid)); bool added = __list_lru_add(list_lru, &entry->lru, entry->nid, memcg); + unsigned long flags, lru_size; + if (added) { + lru_size = list_lru_count_one(list_lru, entry->nid, memcg); + spin_lock_irqsave(&lruvec->lru_lock, flags); + lruvec->nr_zswap_protected++; + + /* + * Decay to avoid overflow and adapt to changing workloads. + * This is based on LRU reclaim cost decaying heuristics. + */ + if (lruvec->nr_zswap_protected > lru_size / 4) + lruvec->nr_zswap_protected /= 2; + spin_unlock_irqrestore(&lruvec->lru_lock, flags); + } mem_cgroup_put(memcg); return added; } @@ -461,6 +497,89 @@ static struct zswap_entry *zswap_entry_find_get(struct rb_root *root, return entry; } +/********************************* +* shrinker functions +**********************************/ +static enum lru_status shrink_memcg_cb(struct list_head *item, struct list_lru_one *l, + spinlock_t *lock, void *arg); + +static unsigned long zswap_shrinker_scan(struct shrinker *shrinker, + struct shrink_control *sc) +{ + struct zswap_pool *pool = container_of(shrinker, typeof(*pool), shrinker); + unsigned long shrink_ret, nr_zswap_protected, flags, + lru_size = list_lru_shrink_count(&pool->list_lru, sc); + struct lruvec *lruvec = mem_cgroup_lruvec(sc->memcg, NODE_DATA(sc->nid)); + bool encountered_page_in_swapcache = false; + + spin_lock_irqsave(&lruvec->lru_lock, flags); + nr_zswap_protected = lruvec->nr_zswap_protected; + spin_unlock_irqrestore(&lruvec->lru_lock, flags); + + /* + * Abort if the shrinker is disabled or if we are shrinking into the + * protected region. + */ + if (!is_shrinker_enabled(sc->memcg) || + nr_zswap_protected >= lru_size - sc->nr_to_scan) { + sc->nr_scanned = 0; + return SHRINK_STOP; + } + + shrink_ret = list_lru_shrink_walk(&pool->list_lru, sc, &shrink_memcg_cb, + &encountered_page_in_swapcache); + + if (encountered_page_in_swapcache) + return SHRINK_STOP; + + return shrink_ret ? shrink_ret : SHRINK_STOP; +} + +static unsigned long zswap_shrinker_count(struct shrinker *shrinker, + struct shrink_control *sc) +{ + struct zswap_pool *pool = container_of(shrinker, typeof(*pool), shrinker); + struct mem_cgroup *memcg = sc->memcg; + struct lruvec *lruvec = mem_cgroup_lruvec(memcg, NODE_DATA(sc->nid)); + unsigned long nr_backing, nr_stored, nr_freeable, flags; + + cgroup_rstat_flush(memcg->css.cgroup); + nr_backing = memcg_page_state(memcg, MEMCG_ZSWAP_B) >> PAGE_SHIFT; + nr_stored = memcg_page_state(memcg, MEMCG_ZSWAPPED); + + if (!is_shrinker_enabled(memcg) || !nr_stored) + return 0; + + nr_freeable = list_lru_shrink_count(&pool->list_lru, sc); + /* + * Subtract the lru size by an estimate of the number of pages + * that should be protected. + */ + spin_lock_irqsave(&lruvec->lru_lock, flags); + nr_freeable = nr_freeable > lruvec->nr_zswap_protected ? + nr_freeable - lruvec->nr_zswap_protected : 0; + spin_unlock_irqrestore(&lruvec->lru_lock, flags); + + /* + * Scale the number of freeable pages by the memory saving factor. + * This ensures that the better zswap compresses memory, the fewer + * pages we will evict to swap (as it will otherwise incur IO for + * relatively small memory saving). + */ + return mult_frac(nr_freeable, nr_backing, nr_stored); +} + +static int zswap_prealloc_shrinker(struct zswap_pool *pool) +{ + pool->shrinker.scan_objects = zswap_shrinker_scan; + pool->shrinker.count_objects = zswap_shrinker_count; + pool->shrinker.batch = 0; + pool->shrinker.seeks = DEFAULT_SEEKS; + pool->shrinker.flags = SHRINKER_NUMA_AWARE | SHRINKER_MEMCG_AWARE; + + return prealloc_shrinker(&pool->shrinker, "mm-zswap"); +} + /********************************* * per-cpu code **********************************/ @@ -656,11 +775,14 @@ static enum lru_status shrink_memcg_cb(struct list_head *item, struct list_lru_o spinlock_t *lock, void *arg) { struct zswap_entry *entry = container_of(item, struct zswap_entry, lru); + bool *encountered_page_in_swapcache = (bool *)arg; struct mem_cgroup *memcg; struct zswap_tree *tree; + struct lruvec *lruvec; pgoff_t swpoffset; enum lru_status ret = LRU_REMOVED_RETRY; int writeback_result; + unsigned long flags; /* * Once the lru lock is dropped, the entry might get freed. The @@ -696,8 +818,24 @@ static enum lru_status shrink_memcg_cb(struct list_head *item, struct list_lru_o /* we cannot use zswap_lru_add here, because it increments node's lru count */ list_lru_putback(&entry->pool->list_lru, item, entry->nid, memcg); spin_unlock(lock); - mem_cgroup_put(memcg); ret = LRU_RETRY; + + /* + * Encountering a page already in swap cache is a sign that we are shrinking + * into the warmer region. We should terminate shrinking (if we're in the dynamic + * shrinker context). + */ + if (writeback_result == -EEXIST && encountered_page_in_swapcache) { + ret = LRU_SKIP; + *encountered_page_in_swapcache = true; + } + lruvec = mem_cgroup_lruvec(memcg, NODE_DATA(entry->nid)); + spin_lock_irqsave(&lruvec->lru_lock, flags); + /* Increment the protection area to account for the LRU rotation. */ + lruvec->nr_zswap_protected++; + spin_unlock_irqrestore(&lruvec->lru_lock, flags); + + mem_cgroup_put(memcg); goto put_unlock; } @@ -828,6 +966,10 @@ static struct zswap_pool *zswap_pool_create(char *type, char *compressor) &pool->node); if (ret) goto error; + + if (zswap_prealloc_shrinker(pool)) + goto error; + pr_debug("using %s compressor\n", pool->tfm_name); /* being the current pool takes 1 ref; this func expects the @@ -836,12 +978,17 @@ static struct zswap_pool *zswap_pool_create(char *type, char *compressor) kref_init(&pool->kref); INIT_LIST_HEAD(&pool->list); INIT_WORK(&pool->shrink_work, shrink_worker); - list_lru_init_memcg(&pool->list_lru, NULL); + if (list_lru_init_memcg(&pool->list_lru, &pool->shrinker)) + goto lru_fail; + register_shrinker_prepared(&pool->shrinker); zswap_pool_debug("created", pool); return pool; +lru_fail: + list_lru_destroy(&pool->list_lru); + free_prealloced_shrinker(&pool->shrinker); error: if (pool->acomp_ctx) free_percpu(pool->acomp_ctx); @@ -899,6 +1046,7 @@ static void zswap_pool_destroy(struct zswap_pool *pool) zswap_pool_debug("destroying", pool); + unregister_shrinker(&pool->shrinker); cpuhp_state_remove_instance(CPUHP_MM_ZSWP_POOL_PREPARE, &pool->node); free_percpu(pool->acomp_ctx); list_lru_destroy(&pool->list_lru);