Merge branch 'core/locking' of git://git.kernel.org/pub/scm/linux/kernel/git/tip...

[linux-2.6-omap-h63xx.git] / arch / x86 / mm / pageattr-test.c

diff --git a/arch/x86/mm/pageattr-test.c b/arch/x86/mm/pageattr-test.c
index 7573e786d2f202d98754f2a484220c75b1250c31..0dcd42eb94e66fd8650422cb25e348cc18da3cf5 100644 (file)
--- a/arch/x86/mm/pageattr-test.c
+++ b/arch/x86/mm/pageattr-test.c
@@ -1,10 +1,11 @@
 /*
  * self test for change_page_attr.
  *
- * Clears the global bit on random pages in the direct mapping, then reverts
- * and compares page tables forwards and afterwards.
+ * Clears the a test pte bit on random pages in the direct mapping,
+ * then reverts and compares page tables forwards and afterwards.
  */
 #include <linux/bootmem.h>
+#include <linux/kthread.h>
 #include <linux/random.h>
 #include <linux/kernel.h>
 #include <linux/init.h>
@@ -14,8 +15,13 @@
 #include <asm/pgtable.h>
 #include <asm/kdebug.h>
 
+/*
+ * Only print the results of the first pass:
+ */
+static __read_mostly int print = 1;
+
 enum {
-       NTEST                   = 4000,
+       NTEST                   = 400,
 #ifdef CONFIG_X86_64
        LPS                     = (1 << PMD_SHIFT),
 #elif defined(CONFIG_X86_PAE)
@@ -26,15 +32,21 @@ enum {
        GPS                     = (1<<30)
 };
 
+#define PAGE_TESTBIT   __pgprot(_PAGE_UNUSED1)
+
+static int pte_testbit(pte_t pte)
+{
+       return pte_flags(pte) & _PAGE_UNUSED1;
+}
+
 struct split_state {
        long lpg, gpg, spg, exec;
        long min_exec, max_exec;
 };
 
-static __init int print_split(struct split_state *s)
+static int print_split(struct split_state *s)
 {
        long i, expected, missed = 0;
-       int printed = 0;
        int err = 0;
 
        s->lpg = s->gpg = s->spg = s->exec = 0;
@@ -47,12 +59,6 @@ static __init int print_split(struct split_state *s)
 
                pte = lookup_address(addr, &level);
                if (!pte) {
-                       if (!printed) {
-                               dump_pagetable(addr);
-                               printk(KERN_INFO "CPA %lx no pte level %d\n",
-                                       addr, level);
-                               printed = 1;
-                       }
                        missed++;
                        i++;
                        continue;
@@ -82,10 +88,13 @@ static __init int print_split(struct split_state *s)
                                s->max_exec = addr;
                }
        }
-       printk(KERN_INFO
-               "CPA mapping 4k %lu large %lu gb %lu x %lu[%lx-%lx] miss %lu\n",
-               s->spg, s->lpg, s->gpg, s->exec,
-               s->min_exec != ~0UL ? s->min_exec : 0, s->max_exec, missed);
+       if (print) {
+               printk(KERN_INFO
+                       " 4k %lu large %lu gb %lu x %lu[%lx-%lx] miss %lu\n",
+                       s->spg, s->lpg, s->gpg, s->exec,
+                       s->min_exec != ~0UL ? s->min_exec : 0,
+                       s->max_exec, missed);
+       }
 
        expected = (s->gpg*GPS + s->lpg*LPS)/PAGE_SIZE + s->spg + missed;
        if (expected != i) {
@@ -96,11 +105,11 @@ static __init int print_split(struct split_state *s)
        return err;
 }
 
-static unsigned long __initdata addr[NTEST];
-static unsigned int __initdata len[NTEST];
+static unsigned long addr[NTEST];
+static unsigned int len[NTEST];
 
 /* Change the global bit on random pages in the direct mapping */
-static __init int exercise_pageattr(void)
+static int pageattr_test(void)
 {
        struct split_state sa, sb, sc;
        unsigned long *bm;
@@ -110,7 +119,8 @@ static __init int exercise_pageattr(void)
        int i, k;
        int err;
 
-       printk(KERN_INFO "CPA exercising pageattr\n");
+       if (print)
+               printk(KERN_INFO "CPA self-test:\n");
 
        bm = vmalloc((max_pfn_mapped + 7) / 8);
        if (!bm) {
@@ -137,7 +147,8 @@ static __init int exercise_pageattr(void)
 
                for (k = 0; k < len[i]; k++) {
                        pte = lookup_address(addr[i] + k*PAGE_SIZE, &level);
-                       if (!pte || pgprot_val(pte_pgprot(*pte)) == 0) {
+                       if (!pte || pgprot_val(pte_pgprot(*pte)) == 0 ||
+                           !(pte_val(*pte) & _PAGE_PRESENT)) {
                                addr[i] = 0;
                                break;
                        }
@@ -161,15 +172,14 @@ static __init int exercise_pageattr(void)
                        continue;
                }
 
-               err = change_page_attr_clear(addr[i], len[i],
-                                              __pgprot(_PAGE_GLOBAL));
+               err = change_page_attr_set(addr[i], len[i], PAGE_TESTBIT);
                if (err < 0) {
                        printk(KERN_ERR "CPA %d failed %d\n", i, err);
                        failed++;
                }
 
                pte = lookup_address(addr[i], &level);
-               if (!pte || pte_global(*pte) || pte_huge(*pte)) {
+               if (!pte || !pte_testbit(*pte) || pte_huge(*pte)) {
                        printk(KERN_ERR "CPA %lx: bad pte %Lx\n", addr[i],
                                pte ? (u64)pte_val(*pte) : 0ULL);
                        failed++;
@@ -185,7 +195,6 @@ static __init int exercise_pageattr(void)
 
        failed += print_split(&sb);
 
-       printk(KERN_INFO "CPA reverting everything\n");
        for (i = 0; i < NTEST; i++) {
                if (!addr[i])
                        continue;
@@ -195,14 +204,13 @@ static __init int exercise_pageattr(void)
                        failed++;
                        continue;
                }
-               err = change_page_attr_set(addr[i], len[i],
-                                            __pgprot(_PAGE_GLOBAL));
+               err = change_page_attr_clear(addr[i], len[i], PAGE_TESTBIT);
                if (err < 0) {
                        printk(KERN_ERR "CPA reverting failed: %d\n", err);
                        failed++;
                }
                pte = lookup_address(addr[i], &level);
-               if (!pte || !pte_global(*pte)) {
+               if (!pte || pte_testbit(*pte)) {
                        printk(KERN_ERR "CPA %lx: bad pte after revert %Lx\n",
                                addr[i], pte ? (u64)pte_val(*pte) : 0ULL);
                        failed++;
@@ -213,12 +221,40 @@ static __init int exercise_pageattr(void)
        failed += print_split(&sc);
 
        if (failed) {
-               printk(KERN_ERR "CPA selftests NOT PASSED. Please report.\n");
+               printk(KERN_ERR "NOT PASSED. Please report.\n");
                WARN_ON(1);
+               return -EINVAL;
        } else {
-               printk(KERN_INFO "CPA selftests PASSED\n");
+               if (print)
+                       printk(KERN_INFO "ok.\n");
+       }
+
+       return 0;
+}
+
+static int do_pageattr_test(void *__unused)
+{
+       while (!kthread_should_stop()) {
+               schedule_timeout_interruptible(HZ*30);
+               if (pageattr_test() < 0)
+                       break;
+               if (print)
+                       print--;
        }
+       return 0;
+}
+
+static int start_pageattr_test(void)
+{
+       struct task_struct *p;
+
+       p = kthread_create(do_pageattr_test, NULL, "pageattr-test");
+       if (!IS_ERR(p))
+               wake_up_process(p);
+       else
+               WARN_ON(1);
 
        return 0;
 }
-module_init(exercise_pageattr);
+
+module_init(start_pageattr_test);