Commit 933db18a authored by Chen Wandun's avatar Chen Wandun Committed by Zheng Zengkai
Browse files

mm/page_cache_limit: add pagecache limit proc interface 

hulk inclusion
category: feature
bugzilla: https://gitee.com/openeuler/kernel/issues/I4HOXK



------------------------------------------

Add 3 proc interface to control page cache limit behavior:
1. switch of the this feature
2. control the page cache limit
3. control the ratio to reclaim when page cache beyond page cache limit

Signed-off-by: default avatarChen Wandun <chenwandun@huawei.com>
Reviewed-by: default avatarKefeng Wang <wangkefeng.wang@huawei.com>
Signed-off-by: default avatarZheng Zengkai <zhengzengkai@huawei.com>
parent 3bc1783c

include/linux/page_cache_limit.h

0 → 100644
+14 −0
Original line number Diff line number Diff line 
#ifndef _PAGECACHE_H

#define _PAGECACHE_H



#ifdef CONFIG_SHRINK_PAGECACHE

extern int pagecache_reclaim_enable;

extern int pagecache_limit_ratio;

extern int pagecache_reclaim_ratio;



int proc_page_cache_limit(struct ctl_table *table, int write,

		void __user *buffer, size_t *lenp, loff_t *ppos);

#else

#endif



#endif

kernel/sysctl.c

+32 −0
Original line number Diff line number Diff line
@@ -103,6 +103,9 @@ 
#ifdef CONFIG_LOCKUP_DETECTOR

#include <linux/nmi.h>

#endif

#ifdef CONFIG_SHRINK_PAGECACHE

#include <linux/page_cache_limit.h>

#endif



#if defined(CONFIG_SYSCTL)
@@ -3192,6 +3195,35 @@ static struct ctl_table vm_table[] = { 
		.extra1		= SYSCTL_ZERO,

		.extra2		= SYSCTL_ONE,

	},

#endif

#ifdef CONFIG_SHRINK_PAGECACHE

	{

		.procname	= "cache_reclaim_enable",

		.data		= &pagecache_reclaim_enable,

		.maxlen		= sizeof(pagecache_reclaim_enable),

		.mode		= 0600,

		.proc_handler	= proc_dointvec_minmax,

		.extra1		= SYSCTL_ZERO,

		.extra2		= SYSCTL_ONE,

	},

	{

		.procname	= "cache_limit_ratio",

		.data		= &pagecache_limit_ratio,

		.maxlen		= sizeof(pagecache_limit_ratio),

		.mode		= 0600,

		.proc_handler	= proc_page_cache_limit,

		.extra1		= SYSCTL_ZERO,

		.extra2		= (void *)&one_hundred,

	},

	{

		.procname	= "cache_reclaim_ratio",

		.data		= &pagecache_reclaim_ratio,

		.maxlen		= sizeof(pagecache_reclaim_ratio),

		.mode		= 0600,

		.proc_handler	= proc_dointvec_minmax,

		.extra1		= SYSCTL_ZERO,

		.extra2		= (void *)&one_hundred,

	},

#endif

	{ }

};

mm/Kconfig

+12 −0
Original line number Diff line number Diff line
@@ -486,6 +486,18 @@ config FRONTSWAP 


	  If unsure, say Y to enable frontswap.



config SHRINK_PAGECACHE

        bool "Enable shrinking the page cache"

        depends on MMU

        default n

        help

          SHRINK_PAGECACHE means that we do not want to keep the large number

          of page cache in the system, even though page cache can greatly improve

	  the performance of the machine. Large number of page cache may result

	  in short of memory, which will result OOM at the same time, so in order

	  to keep page cache in a reasonable range, the number of page cache

	  should be limited, and that is what SHRINK_PAGECACHE does.



config MEMCG_QOS

	bool "Enable Memory Cgroup Priority"

	depends on MEMCG

mm/Makefile

+1 −0
Original line number Diff line number Diff line
@@ -125,3 +125,4 @@ obj-$(CONFIG_PTDUMP_CORE) += ptdump.o 
obj-$(CONFIG_PAGE_REPORTING) += page_reporting.o

obj-$(CONFIG_HAVE_BOOTMEM_INFO_NODE) += bootmem_info.o

obj-$(CONFIG_PIN_MEMORY) += pin_mem.o

obj-$(CONFIG_SHRINK_PAGECACHE) += page_cache_limit.o

mm/page_cache_limit.c

0 → 100644
+51 −0
Original line number Diff line number Diff line 
#include <linux/mm.h>

#include <linux/sysctl.h>



int pagecache_reclaim_enable;

int pagecache_limit_ratio;

int pagecache_reclaim_ratio;



static unsigned long pagecache_limit_pages;

static unsigned long node_pagecache_limit_pages[MAX_NUMNODES];



static unsigned long get_node_total_pages(int nid)

{

	int zone_type;

	unsigned long managed_pages = 0;

	pg_data_t *pgdat = NODE_DATA(nid);



	if (!pgdat)

		return 0;



	for (zone_type = 0; zone_type < MAX_NR_ZONES; zone_type++)

		managed_pages += zone_managed_pages(&pgdat->node_zones[zone_type]);



	return managed_pages;

}



static void setup_pagecache_limit(void)

{

	int i;

	unsigned long node_total_pages;



	pagecache_limit_pages = pagecache_limit_ratio * totalram_pages() / 100;



	for (i = 0; i < MAX_NUMNODES; i++) {

		node_total_pages = get_node_total_pages(i);

		node_pagecache_limit_pages[i] = node_total_pages *

						pagecache_limit_ratio / 100;

	}

}



int proc_page_cache_limit(struct ctl_table *table, int write,

		   void __user *buffer, size_t *lenp, loff_t *ppos)

{

	int ret;



	ret = proc_dointvec_minmax(table, write, buffer, lenp, ppos);



	if (write && !ret)

		setup_pagecache_limit();



	return ret;

}