linux/blkdev.c: Fall back to buffered IO when O_DIRECT fails

[bcachefs-tools-debian] / linux / shrinker.c

diff --git a/linux/shrinker.c b/linux/shrinker.c
index b8fc2464e20f55781349ca769fe73082beea5556..23e288d845cb67da8030672e58038cbe5b49d2df 100644 (file)
--- a/linux/shrinker.c
+++ b/linux/shrinker.c
@@ -2,6 +2,7 @@
 #include <stdio.h>
 
 #include <linux/list.h>
+#include <linux/mm.h>
 #include <linux/mutex.h>
 #include <linux/shrinker.h>
 
@@ -10,7 +11,7 @@
 static LIST_HEAD(shrinker_list);
 static DEFINE_MUTEX(shrinker_lock);
 
-int register_shrinker(struct shrinker *shrinker)
+int register_shrinker(struct shrinker *shrinker, const char *fmt, ...)
 {
        mutex_lock(&shrinker_lock);
        list_add_tail(&shrinker->list, &shrinker_list);
@@ -28,7 +29,6 @@ void unregister_shrinker(struct shrinker *shrinker)
 struct meminfo {
        u64             total;
        u64             available;
-
 };
 
 static u64 parse_meminfo_line(const char *line)
@@ -40,45 +40,86 @@ static u64 parse_meminfo_line(const char *line)
        return v << 10;
 }
 
-static struct meminfo read_meminfo(void)
+void si_meminfo(struct sysinfo *val)
 {
-       struct meminfo ret = { 0 };
        size_t len, n = 0;
        char *line = NULL;
        const char *v;
        FILE *f;
 
+       memset(val, 0, sizeof(*val));
+       val->mem_unit = 1;
+
        f = fopen("/proc/meminfo", "r");
        if (!f)
-               die("error opening /proc/meminfo: %m");
+               return;
 
        while ((len = getline(&line, &n, f)) != -1) {
                if ((v = strcmp_prefix(line, "MemTotal:")))
-                       ret.total = parse_meminfo_line(v);
+                       val->totalram = parse_meminfo_line(v);
 
                if ((v = strcmp_prefix(line, "MemAvailable:")))
-                       ret.available = parse_meminfo_line(v);
+                       val->freeram = parse_meminfo_line(v);
        }
 
        fclose(f);
        free(line);
+}
+
+static void run_shrinkers_allocation_failed(gfp_t gfp_mask)
+{
+       struct shrinker *shrinker;
 
-       return ret;
+       mutex_lock(&shrinker_lock);
+       list_for_each_entry(shrinker, &shrinker_list, list) {
+               struct shrink_control sc = { .gfp_mask  = gfp_mask, };
+
+               unsigned long have = shrinker->count_objects(shrinker, &sc);
+
+               sc.nr_to_scan = have / 8;
+
+               shrinker->scan_objects(shrinker, &sc);
+       }
+       mutex_unlock(&shrinker_lock);
 }
 
-void run_shrinkers(void)
+void run_shrinkers(gfp_t gfp_mask, bool allocation_failed)
 {
        struct shrinker *shrinker;
-       struct meminfo info = read_meminfo();
-       s64 want_shrink = (info.total >> 2) - info.available;
+       struct sysinfo info;
+       s64 want_shrink;
+
+       if (!(gfp_mask & GFP_KERNEL))
+               return;
+
+       /* Fast out if there are no shrinkers to run. */
+       if (list_empty(&shrinker_list))
+               return;
 
-       if (want_shrink <= 0)
+       if (allocation_failed) {
+               run_shrinkers_allocation_failed(gfp_mask);
                return;
+       }
+
+       si_meminfo(&info);
+
+       if (info.totalram && info.freeram) {
+               want_shrink = (info.totalram >> 2) - info.freeram;
+
+               if (want_shrink <= 0)
+                       return;
+       } else {
+               /* If we weren't able to read /proc/meminfo, we must be pretty
+                * low: */
+
+               want_shrink = 8 << 20;
+       }
 
        mutex_lock(&shrinker_lock);
        list_for_each_entry(shrinker, &shrinker_list, list) {
                struct shrink_control sc = {
-                       .nr_to_scan = want_shrink >> PAGE_SHIFT
+                       .gfp_mask       = gfp_mask,
+                       .nr_to_scan     = want_shrink >> PAGE_SHIFT
                };
 
                shrinker->scan_objects(shrinker, &sc);