git.sesse.net Git - bcachefs-tools-debian/blob - linux/shrinker.c

   1
   2 #include <stdio.h>
   3
   4 #include <linux/list.h>
   5 #include <linux/mm.h>
   6 #include <linux/mutex.h>
   7 #include <linux/shrinker.h>
   8
   9 #include "tools-util.h"
  10
  11 static LIST_HEAD(shrinker_list);
  12 static DEFINE_MUTEX(shrinker_lock);
  13
  14 int register_shrinker(struct shrinker *shrinker, const char *fmt, ...)
  15 {
  16         mutex_lock(&shrinker_lock);
  17         list_add_tail(&shrinker->list, &shrinker_list);
  18         mutex_unlock(&shrinker_lock);
  19         return 0;
  20 }
  21
  22 void unregister_shrinker(struct shrinker *shrinker)
  23 {
  24         mutex_lock(&shrinker_lock);
  25         list_del(&shrinker->list);
  26         mutex_unlock(&shrinker_lock);
  27 }
  28
  29 struct meminfo {
  30         u64             total;
  31         u64             available;
  32 };
  33
  34 static u64 parse_meminfo_line(const char *line)
  35 {
  36         u64 v;
  37
  38         if (sscanf(line, " %llu kB", &v) < 1)
  39                 die("sscanf error");
  40         return v << 10;
  41 }
  42
  43 void si_meminfo(struct sysinfo *val)
  44 {
  45         size_t len, n = 0;
  46         char *line = NULL;
  47         const char *v;
  48         FILE *f;
  49
  50         memset(val, 0, sizeof(*val));
  51         val->mem_unit = 1;
  52
  53         f = fopen("/proc/meminfo", "r");
  54         if (!f)
  55                 return;
  56
  57         while ((len = getline(&line, &n, f)) != -1) {
  58                 if ((v = strcmp_prefix(line, "MemTotal:")))
  59                         val->totalram = parse_meminfo_line(v);
  60
  61                 if ((v = strcmp_prefix(line, "MemAvailable:")))
  62                         val->freeram = parse_meminfo_line(v);
  63         }
  64
  65         fclose(f);
  66         free(line);
  67 }
  68
  69 static void run_shrinkers_allocation_failed(gfp_t gfp_mask)
  70 {
  71         struct shrinker *shrinker;
  72
  73         mutex_lock(&shrinker_lock);
  74         list_for_each_entry(shrinker, &shrinker_list, list) {
  75                 struct shrink_control sc = { .gfp_mask  = gfp_mask, };
  76
  77                 unsigned long have = shrinker->count_objects(shrinker, &sc);
  78
  79                 sc.nr_to_scan = have / 8;
  80
  81                 shrinker->scan_objects(shrinker, &sc);
  82         }
  83         mutex_unlock(&shrinker_lock);
  84 }
  85
  86 void run_shrinkers(gfp_t gfp_mask, bool allocation_failed)
  87 {
  88         struct shrinker *shrinker;
  89         struct sysinfo info;
  90         s64 want_shrink;
  91
  92         if (!(gfp_mask & GFP_KERNEL))
  93                 return;
  94
  95         /* Fast out if there are no shrinkers to run. */
  96         if (list_empty(&shrinker_list))
  97                 return;
  98
  99         if (allocation_failed) {
 100                 run_shrinkers_allocation_failed(gfp_mask);
 101                 return;
 102         }
 103
 104         si_meminfo(&info);
 105
 106         if (info.totalram && info.freeram) {
 107                 want_shrink = (info.totalram >> 2) - info.freeram;
 108
 109                 if (want_shrink <= 0)
 110                         return;
 111         } else {
 112                 /* If we weren't able to read /proc/meminfo, we must be pretty
 113                  * low: */
 114
 115                 want_shrink = 8 << 20;
 116         }
 117
 118         mutex_lock(&shrinker_lock);
 119         list_for_each_entry(shrinker, &shrinker_list, list) {
 120                 struct shrink_control sc = {
 121                         .gfp_mask       = gfp_mask,
 122                         .nr_to_scan     = want_shrink >> PAGE_SHIFT
 123                 };
 124
 125                 shrinker->scan_objects(shrinker, &sc);
 126         }
 127         mutex_unlock(&shrinker_lock);
 128 }