FEX-Emu/linux
1
0
Fork 0
mirror of https://github.com/FEX-Emu/linux.git synced 2025-01-06 01:09:08 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

mm: fix calculation of dirtyable memory

Browse Source 
The system uses global_dirtyable_memory() to calculate number of
dirtyable pages/pages that can be allocated to the page cache.  A bug
causes an underflow thus making the page count look like a big unsigned
number.  This in turn confuses the dirty writeback throttling to
aggressively write back pages as they become dirty (usually 1 page at a
time).  This generally only affects systems with highmem because the
underflowed count gets subtracted from the global count of dirtyable
memory.

The problem was introduced with v3.2-4896-gab8fabd

Fix is to ensure we don't get an underflowed total of either highmem or
global dirtyable memory.

Signed-off-by: Sonny Rao <sonnyrao@chromium.org>
Signed-off-by: Puneet Kumar <puneetster@chromium.org>
Acked-by: Johannes Weiner <hannes@cmpxchg.org>
Tested-by: Damien Wyart <damien.wyart@free.fr>
Cc: <stable@vger.kernel.org>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
This commit is contained in:
Sonny Rao 2012-12-20 15:05:07 -08:00 committed by Linus Torvalds
parent 010fc29a45
commit c8b74c2f66
1 changed files with 20 additions and 5 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

25
mm/page-writeback.c
View File

@ -200,6 +200,18 @@ static unsigned long highmem_dirtyable_memory(unsigned long total)
x += zone_page_state(z, NR_FREE_PAGES) + x += zone_page_state(z, NR_FREE_PAGES) +
zone_reclaimable_pages(z) - z->dirty_balance_reserve; zone_reclaimable_pages(z) - z->dirty_balance_reserve;
} }
/*
* Unreclaimable memory (kernel memory or anonymous memory
* without swap) can bring down the dirtyable pages below
* the zone's dirty balance reserve and the above calculation
* will underflow. However we still want to add in nodes
* which are below threshold (negative values) to get a more
* accurate calculation but make sure that the total never
* underflows.
*/
if ((long)x < 0)
x = 0;
/* /*
* Make sure that the number of highmem pages is never larger * Make sure that the number of highmem pages is never larger
* than the number of the total dirtyable memory. This can only * than the number of the total dirtyable memory. This can only
@ -222,8 +234,8 @@ static unsigned long global_dirtyable_memory(void)
{ {
unsigned long x; unsigned long x;
x = global_page_state(NR_FREE_PAGES) + global_reclaimable_pages() - x = global_page_state(NR_FREE_PAGES) + global_reclaimable_pages();
dirty_balance_reserve; x -= min(x, dirty_balance_reserve);
if (!vm_highmem_is_dirtyable) if (!vm_highmem_is_dirtyable)
x -= highmem_dirtyable_memory(x); x -= highmem_dirtyable_memory(x);
@ -290,9 +302,12 @@ static unsigned long zone_dirtyable_memory(struct zone *zone)
* highmem zone can hold its share of dirty pages, so we don't * highmem zone can hold its share of dirty pages, so we don't
* care about vm_highmem_is_dirtyable here. * care about vm_highmem_is_dirtyable here.
*/ */
return zone_page_state(zone, NR_FREE_PAGES) + unsigned long nr_pages = zone_page_state(zone, NR_FREE_PAGES) +
zone_reclaimable_pages(zone) - zone_reclaimable_pages(zone);
zone->dirty_balance_reserve;
/* don't allow this to underflow */
nr_pages -= min(nr_pages, zone->dirty_balance_reserve);
return nr_pages;
} }
/** /**