mirror of
https://github.com/koverstreet/bcachefs-tools.git
synced 2025-02-02 00:00:03 +03:00
1a9d73b5c0
After memory allocation failure, don't rely on /proc/meminfo to figure out how much memory we should free - instead unconditionally free 1/8th of each cache. Signed-off-by: Kent Overstreet <kent.overstreet@gmail.com>
125 lines
2.4 KiB
C
125 lines
2.4 KiB
C
|
|
#include <stdio.h>
|
|
|
|
#include <linux/list.h>
|
|
#include <linux/mutex.h>
|
|
#include <linux/shrinker.h>
|
|
|
|
#include "tools-util.h"
|
|
|
|
static LIST_HEAD(shrinker_list);
|
|
static DEFINE_MUTEX(shrinker_lock);
|
|
|
|
int register_shrinker(struct shrinker *shrinker)
|
|
{
|
|
mutex_lock(&shrinker_lock);
|
|
list_add_tail(&shrinker->list, &shrinker_list);
|
|
mutex_unlock(&shrinker_lock);
|
|
return 0;
|
|
}
|
|
|
|
void unregister_shrinker(struct shrinker *shrinker)
|
|
{
|
|
mutex_lock(&shrinker_lock);
|
|
list_del(&shrinker->list);
|
|
mutex_unlock(&shrinker_lock);
|
|
}
|
|
|
|
struct meminfo {
|
|
u64 total;
|
|
u64 available;
|
|
};
|
|
|
|
static u64 parse_meminfo_line(const char *line)
|
|
{
|
|
u64 v;
|
|
|
|
if (sscanf(line, " %llu kB", &v) < 1)
|
|
die("sscanf error");
|
|
return v << 10;
|
|
}
|
|
|
|
static struct meminfo read_meminfo(void)
|
|
{
|
|
struct meminfo ret = { 0 };
|
|
size_t len, n = 0;
|
|
char *line = NULL;
|
|
const char *v;
|
|
FILE *f;
|
|
|
|
f = fopen("/proc/meminfo", "r");
|
|
if (!f)
|
|
return ret;
|
|
|
|
while ((len = getline(&line, &n, f)) != -1) {
|
|
if ((v = strcmp_prefix(line, "MemTotal:")))
|
|
ret.total = parse_meminfo_line(v);
|
|
|
|
if ((v = strcmp_prefix(line, "MemAvailable:")))
|
|
ret.available = parse_meminfo_line(v);
|
|
}
|
|
|
|
fclose(f);
|
|
free(line);
|
|
|
|
return ret;
|
|
}
|
|
|
|
static void run_shrinkers_allocation_failed(gfp_t gfp_mask)
|
|
{
|
|
struct shrinker *shrinker;
|
|
|
|
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(gfp_t gfp_mask, bool allocation_failed)
|
|
{
|
|
struct shrinker *shrinker;
|
|
struct meminfo info;
|
|
s64 want_shrink;
|
|
|
|
/* Fast out if there are no shrinkers to run. */
|
|
if (list_empty(&shrinker_list))
|
|
return;
|
|
|
|
if (allocation_failed) {
|
|
run_shrinkers_allocation_failed(gfp_mask);
|
|
return;
|
|
}
|
|
|
|
info = read_meminfo();
|
|
|
|
if (info.total && info.available) {
|
|
want_shrink = (info.total >> 2) - info.available;
|
|
|
|
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 = {
|
|
.gfp_mask = gfp_mask,
|
|
.nr_to_scan = want_shrink >> PAGE_SHIFT
|
|
};
|
|
|
|
shrinker->scan_objects(shrinker, &sc);
|
|
}
|
|
mutex_unlock(&shrinker_lock);
|
|
}
|