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/mutex.h>
   6 #include <linux/shrinker.h>
   7
   8 #include "tools-util.h"
   9
  10 static LIST_HEAD(shrinker_list);
  11 static DEFINE_MUTEX(shrinker_lock);
  12
  13 int register_shrinker(struct shrinker *shrinker)
  14 {
  15         mutex_lock(&shrinker_lock);
  16         list_add_tail(&shrinker->list, &shrinker_list);
  17         mutex_unlock(&shrinker_lock);
  18         return 0;
  19 }
  20
  21 void unregister_shrinker(struct shrinker *shrinker)
  22 {
  23         mutex_lock(&shrinker_lock);
  24         list_del(&shrinker->list);
  25         mutex_unlock(&shrinker_lock);
  26 }
  27
  28 struct meminfo {
  29         u64             total;
  30         u64             available;
  31 };
  32
  33 static u64 parse_meminfo_line(const char *line)
  34 {
  35         u64 v;
  36
  37         if (sscanf(line, " %llu kB", &v) < 1)
  38                 die("sscanf error");
  39         return v << 10;
  40 }
  41
  42 static struct meminfo read_meminfo(void)
  43 {
  44         struct meminfo ret = { 0 };
  45         size_t len, n = 0;
  46         char *line = NULL;
  47         const char *v;
  48         FILE *f;
  49
  50         f = fopen("/proc/meminfo", "r");
  51         if (!f)
  52                 return ret;
  53
  54         while ((len = getline(&line, &n, f)) != -1) {
  55                 if ((v = strcmp_prefix(line, "MemTotal:")))
  56                         ret.total = parse_meminfo_line(v);
  57
  58                 if ((v = strcmp_prefix(line, "MemAvailable:")))
  59                         ret.available = parse_meminfo_line(v);
  60         }
  61
  62         fclose(f);
  63         free(line);
  64
  65         return ret;
  66 }
  67
  68 void run_shrinkers(void)
  69 {
  70         struct shrinker *shrinker;
  71         struct meminfo info;
  72         s64 want_shrink;
  73
  74         /* Fast out if there are no shrinkers to run. */
  75         if (list_empty(&shrinker_list))
  76                 return;
  77
  78         info = read_meminfo();
  79
  80         if (info.total && info.available) {
  81                 want_shrink = (info.total >> 2) - info.available;
  82
  83                 if (want_shrink <= 0)
  84                         return;
  85         } else {
  86                 /* If we weren't able to read /proc/meminfo, we must be pretty
  87                  * low: */
  88
  89                 want_shrink = 8 << 20;
  90         }
  91
  92         mutex_lock(&shrinker_lock);
  93         list_for_each_entry(shrinker, &shrinker_list, list) {
  94                 struct shrink_control sc = {
  95                         .nr_to_scan = want_shrink >> PAGE_SHIFT
  96                 };
  97
  98                 shrinker->scan_objects(shrinker, &sc);
  99         }
 100         mutex_unlock(&shrinker_lock);
 101 }