mm/damon/paddr.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * DAMON Primitives for The Physical Address Space
   4  *
   5  * Author: SeongJae Park <[email protected]>
   6  */
   7
   8 #define pr_fmt(fmt) "damon-pa: " fmt
   9
  10 #include <linux/mmu_notifier.h>
  11 #include <linux/page_idle.h>
  12 #include <linux/pagemap.h>
  13 #include <linux/rmap.h>
  14 #include <linux/swap.h>
  15
  16 #include "../internal.h"
  17 #include "ops-common.h"
  18
  19 static bool __damon_pa_mkold(struct folio *folio, struct vm_area_struct *vma,
  20                 unsigned long addr, void *arg)
  21 {
  22         DEFINE_FOLIO_VMA_WALK(pvmw, folio, vma, addr, 0);
  23
  24         while (page_vma_mapped_walk(&pvmw)) {
  25                 addr = pvmw.address;
  26                 if (pvmw.pte)
  27                         damon_ptep_mkold(pvmw.pte, vma, addr);
  28                 else
  29                         damon_pmdp_mkold(pvmw.pmd, vma, addr);
  30         }
  31         return true;
  32 }
  33
  34 static void damon_pa_mkold(unsigned long paddr)
  35 {
  36         struct folio *folio = damon_get_folio(PHYS_PFN(paddr));
  37         struct rmap_walk_control rwc = {
  38                 .rmap_one = __damon_pa_mkold,
  39                 .anon_lock = folio_lock_anon_vma_read,
  40         };
  41         bool need_lock;
  42
  43         if (!folio)
  44                 return;
  45
  46         if (!folio_mapped(folio) || !folio_raw_mapping(folio)) {
  47                 folio_set_idle(folio);
  48                 goto out;
  49         }
  50
  51         need_lock = !folio_test_anon(folio) || folio_test_ksm(folio);
  52         if (need_lock && !folio_trylock(folio))
  53                 goto out;
  54
  55         rmap_walk(folio, &rwc);
  56
  57         if (need_lock)
  58                 folio_unlock(folio);
  59
  60 out:
  61         folio_put(folio);
  62 }
  63
  64 static void __damon_pa_prepare_access_check(struct damon_region *r)
  65 {
  66         r->sampling_addr = damon_rand(r->ar.start, r->ar.end);
  67
  68         damon_pa_mkold(r->sampling_addr);
  69 }
  70
  71 static void damon_pa_prepare_access_checks(struct damon_ctx *ctx)
  72 {
  73         struct damon_target *t;
  74         struct damon_region *r;
  75
  76         damon_for_each_target(t, ctx) {
  77                 damon_for_each_region(r, t)
  78                         __damon_pa_prepare_access_check(r);
  79         }
  80 }
  81
  82 static bool __damon_pa_young(struct folio *folio, struct vm_area_struct *vma,
  83                 unsigned long addr, void *arg)
  84 {
  85         bool *accessed = arg;
  86         DEFINE_FOLIO_VMA_WALK(pvmw, folio, vma, addr, 0);
  87
  88         *accessed = false;
  89         while (page_vma_mapped_walk(&pvmw)) {
  90                 addr = pvmw.address;
  91                 if (pvmw.pte) {
  92                         *accessed = pte_young(ptep_get(pvmw.pte)) ||
  93                                 !folio_test_idle(folio) ||
  94                                 mmu_notifier_test_young(vma->vm_mm, addr);
  95                 } else {
  96 #ifdef CONFIG_TRANSPARENT_HUGEPAGE
  97                         *accessed = pmd_young(pmdp_get(pvmw.pmd)) ||
  98                                 !folio_test_idle(folio) ||
  99                                 mmu_notifier_test_young(vma->vm_mm, addr);
 100 #else
 101                         WARN_ON_ONCE(1);
 102 #endif  /* CONFIG_TRANSPARENT_HUGEPAGE */
 103                 }
 104                 if (*accessed) {
 105                         page_vma_mapped_walk_done(&pvmw);
 106                         break;
 107                 }
 108         }
 109
 110         /* If accessed, stop walking */
 111         return *accessed == false;
 112 }
 113
 114 static bool damon_pa_young(unsigned long paddr, unsigned long *folio_sz)
 115 {
 116         struct folio *folio = damon_get_folio(PHYS_PFN(paddr));
 117         bool accessed = false;
 118         struct rmap_walk_control rwc = {
 119                 .arg = &accessed,
 120                 .rmap_one = __damon_pa_young,
 121                 .anon_lock = folio_lock_anon_vma_read,
 122         };
 123         bool need_lock;
 124
 125         if (!folio)
 126                 return false;
 127
 128         if (!folio_mapped(folio) || !folio_raw_mapping(folio)) {
 129                 if (folio_test_idle(folio))
 130                         accessed = false;
 131                 else
 132                         accessed = true;
 133                 goto out;
 134         }
 135
 136         need_lock = !folio_test_anon(folio) || folio_test_ksm(folio);
 137         if (need_lock && !folio_trylock(folio))
 138                 goto out;
 139
 140         rmap_walk(folio, &rwc);
 141
 142         if (need_lock)
 143                 folio_unlock(folio);
 144
 145 out:
 146         *folio_sz = folio_size(folio);
 147         folio_put(folio);
 148         return accessed;
 149 }
 150
 151 static void __damon_pa_check_access(struct damon_region *r)
 152 {
 153         static unsigned long last_addr;
 154         static unsigned long last_folio_sz = PAGE_SIZE;
 155         static bool last_accessed;
 156
 157         /* If the region is in the last checked page, reuse the result */
 158         if (ALIGN_DOWN(last_addr, last_folio_sz) ==
 159                                 ALIGN_DOWN(r->sampling_addr, last_folio_sz)) {
 160                 if (last_accessed)
 161                         r->nr_accesses++;
 162                 return;
 163         }
 164
 165         last_accessed = damon_pa_young(r->sampling_addr, &last_folio_sz);
 166         if (last_accessed)
 167                 r->nr_accesses++;
 168
 169         last_addr = r->sampling_addr;
 170 }
 171
 172 static unsigned int damon_pa_check_accesses(struct damon_ctx *ctx)
 173 {
 174         struct damon_target *t;
 175         struct damon_region *r;
 176         unsigned int max_nr_accesses = 0;
 177
 178         damon_for_each_target(t, ctx) {
 179                 damon_for_each_region(r, t) {
 180                         __damon_pa_check_access(r);
 181                         max_nr_accesses = max(r->nr_accesses, max_nr_accesses);
 182                 }
 183         }
 184
 185         return max_nr_accesses;
 186 }
 187
 188 static bool __damos_pa_filter_out(struct damos_filter *filter,
 189                 struct folio *folio)
 190 {
 191         bool matched = false;
 192         struct mem_cgroup *memcg;
 193
 194         switch (filter->type) {
 195         case DAMOS_FILTER_TYPE_ANON:
 196                 matched = folio_test_anon(folio);
 197                 break;
 198         case DAMOS_FILTER_TYPE_MEMCG:
 199                 rcu_read_lock();
 200                 memcg = folio_memcg_check(folio);
 201                 if (!memcg)
 202                         matched = false;
 203                 else
 204                         matched = filter->memcg_id == mem_cgroup_id(memcg);
 205                 rcu_read_unlock();
 206                 break;
 207         default:
 208                 break;
 209         }
 210
 211         return matched == filter->matching;
 212 }
 213
 214 /*
 215  * damos_pa_filter_out - Return true if the page should be filtered out.
 216  */
 217 static bool damos_pa_filter_out(struct damos *scheme, struct folio *folio)
 218 {
 219         struct damos_filter *filter;
 220
 221         damos_for_each_filter(filter, scheme) {
 222                 if (__damos_pa_filter_out(filter, folio))
 223                         return true;
 224         }
 225         return false;
 226 }
 227
 228 static unsigned long damon_pa_pageout(struct damon_region *r, struct damos *s)
 229 {
 230         unsigned long addr, applied;
 231         LIST_HEAD(folio_list);
 232
 233         for (addr = r->ar.start; addr < r->ar.end; addr += PAGE_SIZE) {
 234                 struct folio *folio = damon_get_folio(PHYS_PFN(addr));
 235
 236                 if (!folio)
 237                         continue;
 238
 239                 if (damos_pa_filter_out(s, folio))
 240                         goto put_folio;
 241
 242                 folio_clear_referenced(folio);
 243                 folio_test_clear_young(folio);
 244                 if (!folio_isolate_lru(folio))
 245                         goto put_folio;
 246                 if (folio_test_unevictable(folio))
 247                         folio_putback_lru(folio);
 248                 else
 249                         list_add(&folio->lru, &folio_list);
 250 put_folio:
 251                 folio_put(folio);
 252         }
 253         applied = reclaim_pages(&folio_list);
 254         cond_resched();
 255         return applied * PAGE_SIZE;
 256 }
 257
 258 static inline unsigned long damon_pa_mark_accessed_or_deactivate(
 259                 struct damon_region *r, struct damos *s, bool mark_accessed)
 260 {
 261         unsigned long addr, applied = 0;
 262
 263         for (addr = r->ar.start; addr < r->ar.end; addr += PAGE_SIZE) {
 264                 struct folio *folio = damon_get_folio(PHYS_PFN(addr));
 265
 266                 if (!folio)
 267                         continue;
 268
 269                 if (damos_pa_filter_out(s, folio))
 270                         goto put_folio;
 271
 272                 if (mark_accessed)
 273                         folio_mark_accessed(folio);
 274                 else
 275                         folio_deactivate(folio);
 276                 applied += folio_nr_pages(folio);
 277 put_folio:
 278                 folio_put(folio);
 279         }
 280         return applied * PAGE_SIZE;
 281 }
 282
 283 static unsigned long damon_pa_mark_accessed(struct damon_region *r,
 284         struct damos *s)
 285 {
 286         return damon_pa_mark_accessed_or_deactivate(r, s, true);
 287 }
 288
 289 static unsigned long damon_pa_deactivate_pages(struct damon_region *r,
 290         struct damos *s)
 291 {
 292         return damon_pa_mark_accessed_or_deactivate(r, s, false);
 293 }
 294
 295 static unsigned long damon_pa_apply_scheme(struct damon_ctx *ctx,
 296                 struct damon_target *t, struct damon_region *r,
 297                 struct damos *scheme)
 298 {
 299         switch (scheme->action) {
 300         case DAMOS_PAGEOUT:
 301                 return damon_pa_pageout(r, scheme);
 302         case DAMOS_LRU_PRIO:
 303                 return damon_pa_mark_accessed(r, scheme);
 304         case DAMOS_LRU_DEPRIO:
 305                 return damon_pa_deactivate_pages(r, scheme);
 306         case DAMOS_STAT:
 307                 break;
 308         default:
 309                 /* DAMOS actions that not yet supported by 'paddr'. */
 310                 break;
 311         }
 312         return 0;
 313 }
 314
 315 static int damon_pa_scheme_score(struct damon_ctx *context,
 316                 struct damon_target *t, struct damon_region *r,
 317                 struct damos *scheme)
 318 {
 319         switch (scheme->action) {
 320         case DAMOS_PAGEOUT:
 321                 return damon_cold_score(context, r, scheme);
 322         case DAMOS_LRU_PRIO:
 323                 return damon_hot_score(context, r, scheme);
 324         case DAMOS_LRU_DEPRIO:
 325                 return damon_cold_score(context, r, scheme);
 326         default:
 327                 break;
 328         }
 329
 330         return DAMOS_MAX_SCORE;
 331 }
 332
 333 static int __init damon_pa_initcall(void)
 334 {
 335         struct damon_operations ops = {
 336                 .id = DAMON_OPS_PADDR,
 337                 .init = NULL,
 338                 .update = NULL,
 339                 .prepare_access_checks = damon_pa_prepare_access_checks,
 340                 .check_accesses = damon_pa_check_accesses,
 341                 .reset_aggregated = NULL,
 342                 .target_valid = NULL,
 343                 .cleanup = NULL,
 344                 .apply_scheme = damon_pa_apply_scheme,
 345                 .get_scheme_score = damon_pa_scheme_score,
 346         };
 347
 348         return damon_register_ops(&ops);
 349 };
 350
 351 subsys_initcall(damon_pa_initcall);