- patches.suse/slab-handle-memoryless-nodes-v2a.patch: Refresh.

[linux-flexiantxendom0-3.2.10.git] / arch / x86 / mm / kmmio.c

diff --git a/arch/x86/mm/kmmio.c b/arch/x86/mm/kmmio.c
index 16ccbd7..536fb68 100644 (file)
--- a/arch/x86/mm/kmmio.c
+++ b/arch/x86/mm/kmmio.c
@@ -5,6 +5,8 @@
  *     2008 Pekka Paalanen <pq@iki.fi>
  */
 
+#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
+
 #include <linux/list.h>
 #include <linux/rculist.h>
 #include <linux/spinlock.h>
@@ -136,7 +138,7 @@ static int clear_page_presence(struct kmmio_fault_page *f, bool clear)
        pte_t *pte = lookup_address(f->page, &level);
 
        if (!pte) {
-               pr_err("kmmio: no pte for page 0x%08lx\n", f->page);
+               pr_err("no pte for page 0x%08lx\n", f->page);
                return -1;
        }
 
@@ -148,7 +150,7 @@ static int clear_page_presence(struct kmmio_fault_page *f, bool clear)
                clear_pte_presence(pte, clear, &f->old_presence);
                break;
        default:
-               pr_err("kmmio: unexpected page level 0x%x.\n", level);
+               pr_err("unexpected page level 0x%x.\n", level);
                return -1;
        }
 
@@ -170,13 +172,14 @@ static int clear_page_presence(struct kmmio_fault_page *f, bool clear)
 static int arm_kmmio_fault_page(struct kmmio_fault_page *f)
 {
        int ret;
-       WARN_ONCE(f->armed, KERN_ERR "kmmio page already armed.\n");
+       WARN_ONCE(f->armed, KERN_ERR pr_fmt("kmmio page already armed.\n"));
        if (f->armed) {
-               pr_warning("kmmio double-arm: page 0x%08lx, ref %d, old %d\n",
-                                       f->page, f->count, !!f->old_presence);
+               pr_warning("double-arm: page 0x%08lx, ref %d, old %d\n",
+                          f->page, f->count, !!f->old_presence);
        }
        ret = clear_page_presence(f, true);
-       WARN_ONCE(ret < 0, KERN_ERR "kmmio arming 0x%08lx failed.\n", f->page);
+       WARN_ONCE(ret < 0, KERN_ERR pr_fmt("arming 0x%08lx failed.\n"),
+                 f->page);
        f->armed = true;
        return ret;
 }
@@ -203,7 +206,7 @@ static void disarm_kmmio_fault_page(struct kmmio_fault_page *f)
  */
 /*
  * Interrupts are disabled on entry as trap3 is an interrupt gate
- * and they remain disabled thorough out this function.
+ * and they remain disabled throughout this function.
  */
 int kmmio_handler(struct pt_regs *regs, unsigned long addr)
 {
@@ -240,24 +243,21 @@ int kmmio_handler(struct pt_regs *regs, unsigned long addr)
                         * condition needs handling by do_page_fault(), the
                         * page really not being present is the most common.
                         */
-                       pr_debug("kmmio: secondary hit for 0x%08lx CPU %d.\n",
-                                       addr, smp_processor_id());
+                       pr_debug("secondary hit for 0x%08lx CPU %d.\n",
+                                addr, smp_processor_id());
 
                        if (!faultpage->old_presence)
-                               pr_info("kmmio: unexpected secondary hit for "
-                                       "address 0x%08lx on CPU %d.\n", addr,
-                                       smp_processor_id());
+                               pr_info("unexpected secondary hit for address 0x%08lx on CPU %d.\n",
+                                       addr, smp_processor_id());
                } else {
                        /*
                         * Prevent overwriting already in-flight context.
                         * This should not happen, let's hope disarming at
                         * least prevents a panic.
                         */
-                       pr_emerg("kmmio: recursive probe hit on CPU %d, "
-                                       "for address 0x%08lx. Ignoring.\n",
-                                       smp_processor_id(), addr);
-                       pr_emerg("kmmio: previous hit was at 0x%08lx.\n",
-                                               ctx->addr);
+                       pr_emerg("recursive probe hit on CPU %d, for address 0x%08lx. Ignoring.\n",
+                                smp_processor_id(), addr);
+                       pr_emerg("previous hit was at 0x%08lx.\n", ctx->addr);
                        disarm_kmmio_fault_page(faultpage);
                }
                goto no_kmmio_ctx;
@@ -302,7 +302,7 @@ no_kmmio:
 
 /*
  * Interrupts are disabled on entry as trap1 is an interrupt gate
- * and they remain disabled thorough out this function.
+ * and they remain disabled throughout this function.
  * This must always get called as the pair to kmmio_handler().
  */
 static int post_kmmio_handler(unsigned long condition, struct pt_regs *regs)
@@ -316,8 +316,8 @@ static int post_kmmio_handler(unsigned long condition, struct pt_regs *regs)
                 * something external causing them (f.e. using a debugger while
                 * mmio tracing enabled), or erroneous behaviour
                 */
-               pr_warning("kmmio: unexpected debug trap on CPU %d.\n",
-                                                       smp_processor_id());
+               pr_warning("unexpected debug trap on CPU %d.\n",
+                          smp_processor_id());
                goto out;
        }
 
@@ -425,7 +425,7 @@ int register_kmmio_probe(struct kmmio_probe *p)
        list_add_rcu(&p->list, &kmmio_probes);
        while (size < size_lim) {
                if (add_kmmio_fault_page(p->addr + size))
-                       pr_err("kmmio: Unable to set page fault.\n");
+                       pr_err("Unable to set page fault.\n");
                size += PAGE_SIZE;
        }
 out:
@@ -490,7 +490,7 @@ static void remove_kmmio_fault_pages(struct rcu_head *head)
  * 2. remove_kmmio_fault_pages()
  *    Remove the pages from kmmio_page_table.
  * 3. rcu_free_kmmio_fault_pages()
- *    Actally free the kmmio_fault_page structs as with RCU.
+ *    Actually free the kmmio_fault_page structs as with RCU.
  */
 void unregister_kmmio_probe(struct kmmio_probe *p)
 {
@@ -511,7 +511,7 @@ void unregister_kmmio_probe(struct kmmio_probe *p)
 
        drelease = kmalloc(sizeof(*drelease), GFP_ATOMIC);
        if (!drelease) {
-               pr_crit("kmmio: leaking kmmio_fault_page objects.\n");
+               pr_crit("leaking kmmio_fault_page objects.\n");
                return;
        }
        drelease->release_list = release_list;
@@ -538,10 +538,17 @@ static int
 kmmio_die_notifier(struct notifier_block *nb, unsigned long val, void *args)
 {
        struct die_args *arg = args;
+       unsigned long* dr6_p = (unsigned long *)ERR_PTR(arg->err);
 
-       if (val == DIE_DEBUG && (arg->err & DR_STEP))
-               if (post_kmmio_handler(arg->err, arg->regs) == 1)
+       if (val == DIE_DEBUG && (*dr6_p & DR_STEP))
+               if (post_kmmio_handler(*dr6_p, arg->regs) == 1) {
+                       /*
+                        * Reset the BS bit in dr6 (pointed by args->err) to
+                        * denote completion of processing
+                        */
+                       *dr6_p &= ~DR_STEP;
                        return NOTIFY_STOP;
+               }
 
        return NOTIFY_DONE;
 }