lkml.org 
[lkml]   [2017]   [Sep]   [17]   [last100]   RSS Feed
Views: [wrap][no wrap]   [headers]  [forward] 
 
Messages in this thread
Patch in this message
/
From
Subject[PATCH] mm: introduce sanity check on dirty ratio sysctl value
Date
we can find the logic in domain_dirty_limits() that
when dirty bg_thresh is bigger than dirty thresh,
bg_thresh will be set as thresh * 1 / 2.
if (bg_thresh >= thresh)
bg_thresh = thresh / 2;

But actually we can set dirty_background_raio bigger than
dirty_ratio successfully. This behavior may mislead us.
So we should do this sanity check at the beginning.

Signed-off-by: Yafang Shao <laoar.shao@gmail.com>
---
Documentation/sysctl/vm.txt | 5 +++
mm/page-writeback.c | 84 ++++++++++++++++++++++++++++++++++++++++-----
2 files changed, 81 insertions(+), 8 deletions(-)

diff --git a/Documentation/sysctl/vm.txt b/Documentation/sysctl/vm.txt
index 9baf66a..b87e238 100644
--- a/Documentation/sysctl/vm.txt
+++ b/Documentation/sysctl/vm.txt
@@ -156,6 +156,8 @@ read.
Note: the minimum value allowed for dirty_bytes is two pages (in bytes); any
value lower than this limit will be ignored and the old configuration will be
retained.
+dirty_bytes can't less than dirty_background_bytes or
+dirty_ratio * available_memory / 100.

==============================================================

@@ -176,6 +178,9 @@ generating disk writes will itself start writing out dirty data.

The total available memory is not equal to total system memory.

+Note: dirty_ratio can't less than dirty_background_ratio or
+dirty_background_bytes / available_memory * 100.
+
==============================================================

dirty_writeback_centisecs
diff --git a/mm/page-writeback.c b/mm/page-writeback.c
index 0b9c5cb..1dcb8f7 100644
--- a/mm/page-writeback.c
+++ b/mm/page-writeback.c
@@ -515,11 +515,29 @@ int dirty_background_ratio_handler(struct ctl_table *table, int write,
void __user *buffer, size_t *lenp,
loff_t *ppos)
{
+ int old_ratio = dirty_background_ratio;
+ unsigned long bytes;
int ret;

ret = proc_dointvec_minmax(table, write, buffer, lenp, ppos);
- if (ret == 0 && write)
- dirty_background_bytes = 0;
+
+ if (ret == 0 && write) {
+ if (vm_dirty_ratio > 0) {
+ if (dirty_background_ratio >= vm_dirty_ratio)
+ ret = -EINVAL;
+ } else if (vm_dirty_bytes > 0) {
+ bytes = global_dirtyable_memory() * PAGE_SIZE *
+ dirty_background_ratio / 100;
+ if (bytes >= vm_dirty_bytes)
+ ret = -EINVAL;
+ }
+
+ if (ret == 0)
+ dirty_background_bytes = 0;
+ else
+ dirty_background_ratio = old_ratio;
+ }
+
return ret;
}

@@ -527,11 +545,29 @@ int dirty_background_bytes_handler(struct ctl_table *table, int write,
void __user *buffer, size_t *lenp,
loff_t *ppos)
{
+ unsigned long old_bytes = dirty_background_bytes;
+ unsigned long bytes;
int ret;

ret = proc_doulongvec_minmax(table, write, buffer, lenp, ppos);
- if (ret == 0 && write)
- dirty_background_ratio = 0;
+
+ if (ret == 0 && write) {
+ if (vm_dirty_bytes > 0) {
+ if (dirty_background_bytes >= vm_dirty_bytes)
+ ret = -EINVAL;
+ } else if (vm_dirty_ratio > 0) {
+ bytes = global_dirtyable_memory() * PAGE_SIZE *
+ vm_dirty_ratio / 100;
+ if (dirty_background_bytes >= bytes)
+ ret = -EINVAL;
+ }
+
+ if (ret == 0)
+ dirty_background_ratio = 0;
+ else
+ dirty_background_bytes = old_bytes;
+ }
+
return ret;
}

@@ -540,13 +576,29 @@ int dirty_ratio_handler(struct ctl_table *table, int write,
loff_t *ppos)
{
int old_ratio = vm_dirty_ratio;
+ unsigned long bytes;
int ret;

ret = proc_dointvec_minmax(table, write, buffer, lenp, ppos);
+
if (ret == 0 && write && vm_dirty_ratio != old_ratio) {
- writeback_set_ratelimit();
- vm_dirty_bytes = 0;
+ if (dirty_background_ratio > 0) {
+ if (vm_dirty_ratio <= dirty_background_ratio)
+ ret = -EINVAL;
+ } else if (dirty_background_bytes > 0) {
+ bytes = global_dirtyable_memory() * PAGE_SIZE *
+ vm_dirty_ratio / 100;
+ if (bytes <= dirty_background_bytes)
+ ret = -EINVAL;
+ }
+
+ if (ret == 0) {
+ writeback_set_ratelimit();
+ vm_dirty_bytes = 0;
+ } else
+ vm_dirty_ratio = old_ratio;
}
+
return ret;
}

@@ -555,13 +607,29 @@ int dirty_bytes_handler(struct ctl_table *table, int write,
loff_t *ppos)
{
unsigned long old_bytes = vm_dirty_bytes;
+ unsigned long bytes;
int ret;

ret = proc_doulongvec_minmax(table, write, buffer, lenp, ppos);
+
if (ret == 0 && write && vm_dirty_bytes != old_bytes) {
- writeback_set_ratelimit();
- vm_dirty_ratio = 0;
+ if (dirty_background_ratio > 0) {
+ bytes = global_dirtyable_memory() * PAGE_SIZE *
+ dirty_background_ratio / 100;
+ if (vm_dirty_bytes <= bytes)
+ ret = -EINVAL;
+ } else if (dirty_background_bytes > 0) {
+ if (vm_dirty_bytes <= dirty_background_bytes)
+ ret = -EINVAL;
+ }
+
+ if (ret == 0) {
+ writeback_set_ratelimit();
+ vm_dirty_ratio = 0;
+ } else
+ vm_dirty_bytes = old_bytes;
}
+
return ret;
}

--
1.8.3.1
\
 
 \ /
  Last update: 2017-09-17 11:53    [W:0.098 / U:1.728 seconds]
©2003-2017 Jasper Spaans. hosted at Digital OceanAdvertise on this site