| lists.openwall.net | lists / announce owl-users owl-dev john-users john-dev passwdqc-users yescrypt popa3d-users / oss-security kernel-hardening musl sabotage tlsify passwords / crypt-dev xvendor / Bugtraq Full-Disclosure linux-kernel linux-netdev linux-ext4 linux-hardening linux-cve-announce PHC | |
|
Open Source and information security mailing list archives
| ||
|
Message-Id: <20110201003358.98826457@kernel>
Date: Mon, 31 Jan 2011 16:33:58 -0800
From: Dave Hansen <dave@...ux.vnet.ibm.com>
To: linux-kernel@...r.kernel.org
Cc: linux-mm@...ck.org, Michael J Wolf <mjwolf@...ibm.com>,
Andrea Arcangeli <aarcange@...hat.com>,
Dave Hansen <dave@...ux.vnet.ibm.com>
Subject: [RFC][PATCH 1/6] count transparent hugepage splits
The khugepaged process collapses transparent hugepages for us. Whenever
it collapses a page into a transparent hugepage, we increment a nice
global counter exported in sysfs:
/sys/kernel/mm/transparent_hugepage/khugepaged/pages_collapsed
But, transparent hugepages also get broken down in quite a few
places in the kernel. We do not have a good idea how how many of
those collpased pages are "new" versus how many are just fixing up
spots that got split a moment before.
Note: "splits" and "collapses" are opposites in this context.
This patch adds a new sysfs file:
/sys/kernel/mm/transparent_hugepage/pages_split
It is global, like "pages_collapsed", and is incremented whenever any
transparent hugepage on the system has been broken down in to normal
PAGE_SIZE base pages. This way, we can get an idea how well khugepaged
is keeping up collapsing pages that have been split.
I put it under /sys/kernel/mm/transparent_hugepage/ instead of the
khugepaged/ directory since it is not strictly related to
khugepaged; it can get incremented on pages other than those
collapsed by khugepaged.
The variable storing this is a plain integer. I needs the same
amount of locking that 'khugepaged_pages_collapsed' has, for
instance.
Signed-off-by: Dave Hansen <dave@...ux.vnet.ibm.com>
---
linux-2.6.git-dave/Documentation/vm/transhuge.txt | 8 ++++++++
linux-2.6.git-dave/mm/huge_memory.c | 12 ++++++++++++
2 files changed, 20 insertions(+)
diff -puN mm/huge_memory.c~count-thp-splits mm/huge_memory.c
--- linux-2.6.git/mm/huge_memory.c~count-thp-splits 2011-01-31 11:05:51.484526127 -0800
+++ linux-2.6.git-dave/mm/huge_memory.c 2011-01-31 11:05:51.508526113 -0800
@@ -38,6 +38,8 @@ unsigned long transparent_hugepage_flags
(1<<TRANSPARENT_HUGEPAGE_DEFRAG_FLAG)|
(1<<TRANSPARENT_HUGEPAGE_DEFRAG_KHUGEPAGED_FLAG);
+static unsigned int huge_pages_split;
+
/* default scan 8*512 pte (or vmas) every 30 second */
static unsigned int khugepaged_pages_to_scan __read_mostly = HPAGE_PMD_NR*8;
static unsigned int khugepaged_pages_collapsed;
@@ -307,12 +309,20 @@ static struct kobj_attribute debug_cow_a
__ATTR(debug_cow, 0644, debug_cow_show, debug_cow_store);
#endif /* CONFIG_DEBUG_VM */
+static ssize_t pages_split_show(struct kobject *kobj,
+ struct kobj_attribute *attr, char *buf)
+{
+ return sprintf(buf, "%u\n", huge_pages_split);
+}
+static struct kobj_attribute pages_split_attr = __ATTR_RO(pages_split);
+
static struct attribute *hugepage_attr[] = {
&enabled_attr.attr,
&defrag_attr.attr,
#ifdef CONFIG_DEBUG_VM
&debug_cow_attr.attr,
#endif
+ &pages_split_attr.attr,
NULL,
};
@@ -1314,6 +1324,8 @@ static int __split_huge_page_map(struct
}
spin_unlock(&mm->page_table_lock);
+ if (ret)
+ huge_pages_split++;
return ret;
}
diff -puN fs/proc/meminfo.c~count-thp-splits fs/proc/meminfo.c
diff -puN Documentation/vm/transhuge.txt~count-thp-splits Documentation/vm/transhuge.txt
--- linux-2.6.git/Documentation/vm/transhuge.txt~count-thp-splits 2011-01-31 11:05:51.500526118 -0800
+++ linux-2.6.git-dave/Documentation/vm/transhuge.txt 2011-01-31 11:05:51.508526113 -0800
@@ -120,6 +120,14 @@ khugepaged will be automatically started
transparent_hugepage/enabled is set to "always" or "madvise, and it'll
be automatically shutdown if it's set to "never".
+Not all kernel code is aware of transparent hugepages. Sometimes,
+it is necessary to fall back to small pages so that this kernel
+code can deal with small pages. This might also happen if, for
+instance, munmap() was called in the middle of a transparent huge
+page. We track these splits in:
+
+ /sys/kernel/mm/transparent_hugepage/pages_split
+
khugepaged runs usually at low frequency so while one may not want to
invoke defrag algorithms synchronously during the page faults, it
should be worth invoking defrag at least in khugepaged. However it's
_
--
To unsubscribe from this list: send the line "unsubscribe linux-kernel" in
the body of a message to majordomo@...r.kernel.org
More majordomo info at http://vger.kernel.org/majordomo-info.html
Please read the FAQ at http://www.tux.org/lkml/
Powered by blists - more mailing lists