mm/damon/ops-common.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * Common Primitives for Data Access Monitoring
   4  *
   5  * Author: SeongJae Park <sj@kernel.org>
   6  */
   7
   8 #include <linux/mmu_notifier.h>
   9 #include <linux/page_idle.h>
  10 #include <linux/pagemap.h>
  11 #include <linux/rmap.h>
  12
  13 #include "ops-common.h"
  14
  15 /*
  16  * Get an online page for a pfn if it's in the LRU list.  Otherwise, returns
  17  * NULL.
  18  *
  19  * The body of this function is stolen from the 'page_idle_get_folio()'.  We
  20  * steal rather than reuse it because the code is quite simple.
  21  */
  22 struct folio *damon_get_folio(unsigned long pfn)
  23 {
  24         struct page *page = pfn_to_online_page(pfn);
  25         struct folio *folio;
  26
  27         if (!page || PageTail(page))
  28                 return NULL;
  29
  30         folio = page_folio(page);
  31         if (!folio_test_lru(folio) || !folio_try_get(folio))
  32                 return NULL;
  33         if (unlikely(page_folio(page) != folio || !folio_test_lru(folio))) {
  34                 folio_put(folio);
  35                 folio = NULL;
  36         }
  37         return folio;
  38 }
  39
  40 void damon_ptep_mkold(pte_t *pte, struct vm_area_struct *vma, unsigned long addr)
  41 {
  42         bool referenced = false;
  43         struct folio *folio = damon_get_folio(pte_pfn(*pte));
  44
  45         if (!folio)
  46                 return;
  47
  48         if (ptep_test_and_clear_young(vma, addr, pte))
  49                 referenced = true;
  50
  51 #ifdef CONFIG_MMU_NOTIFIER
  52         if (mmu_notifier_clear_young(vma->vm_mm, addr, addr + PAGE_SIZE))
  53                 referenced = true;
  54 #endif /* CONFIG_MMU_NOTIFIER */
  55
  56         if (referenced)
  57                 folio_set_young(folio);
  58
  59         folio_set_idle(folio);
  60         folio_put(folio);
  61 }
  62
  63 void damon_pmdp_mkold(pmd_t *pmd, struct vm_area_struct *vma, unsigned long addr)
  64 {
  65 #ifdef CONFIG_TRANSPARENT_HUGEPAGE
  66         bool referenced = false;
  67         struct folio *folio = damon_get_folio(pmd_pfn(*pmd));
  68
  69         if (!folio)
  70                 return;
  71
  72         if (pmdp_test_and_clear_young(vma, addr, pmd))
  73                 referenced = true;
  74
  75 #ifdef CONFIG_MMU_NOTIFIER
  76         if (mmu_notifier_clear_young(vma->vm_mm, addr, addr + HPAGE_PMD_SIZE))
  77                 referenced = true;
  78 #endif /* CONFIG_MMU_NOTIFIER */
  79
  80         if (referenced)
  81                 folio_set_young(folio);
  82
  83         folio_set_idle(folio);
  84         folio_put(folio);
  85 #endif /* CONFIG_TRANSPARENT_HUGEPAGE */
  86 }
  87
  88 #define DAMON_MAX_SUBSCORE      (100)
  89 #define DAMON_MAX_AGE_IN_LOG    (32)
  90
  91 int damon_hot_score(struct damon_ctx *c, struct damon_region *r,
  92                         struct damos *s)
  93 {
  94         unsigned int max_nr_accesses;
  95         int freq_subscore;
  96         unsigned int age_in_sec;
  97         int age_in_log, age_subscore;
  98         unsigned int freq_weight = s->quota.weight_nr_accesses;
  99         unsigned int age_weight = s->quota.weight_age;
 100         int hotness;
 101
 102         max_nr_accesses = c->attrs.aggr_interval / c->attrs.sample_interval;
 103         freq_subscore = r->nr_accesses * DAMON_MAX_SUBSCORE / max_nr_accesses;
 104
 105         age_in_sec = (unsigned long)r->age * c->attrs.aggr_interval / 1000000;
 106         for (age_in_log = 0; age_in_log < DAMON_MAX_AGE_IN_LOG && age_in_sec;
 107                         age_in_log++, age_in_sec >>= 1)
 108                 ;
 109
 110         /* If frequency is 0, higher age means it's colder */
 111         if (freq_subscore == 0)
 112                 age_in_log *= -1;
 113
 114         /*
 115          * Now age_in_log is in [-DAMON_MAX_AGE_IN_LOG, DAMON_MAX_AGE_IN_LOG].
 116          * Scale it to be in [0, 100] and set it as age subscore.
 117          */
 118         age_in_log += DAMON_MAX_AGE_IN_LOG;
 119         age_subscore = age_in_log * DAMON_MAX_SUBSCORE /
 120                 DAMON_MAX_AGE_IN_LOG / 2;
 121
 122         hotness = (freq_weight * freq_subscore + age_weight * age_subscore);
 123         if (freq_weight + age_weight)
 124                 hotness /= freq_weight + age_weight;
 125         /*
 126          * Transform it to fit in [0, DAMOS_MAX_SCORE]
 127          */
 128         hotness = hotness * DAMOS_MAX_SCORE / DAMON_MAX_SUBSCORE;
 129
 130         return hotness;
 131 }
 132
 133 int damon_cold_score(struct damon_ctx *c, struct damon_region *r,
 134                         struct damos *s)
 135 {
 136         int hotness = damon_hot_score(c, r, s);
 137
 138         /* Return coldness of the region */
 139         return DAMOS_MAX_SCORE - hotness;
 140 }