Merge branch 'for-linus' of git://one.firstfloor.org/home/andi/git/linux-2.6

* 'for-linus' of git://one.firstfloor.org/home/andi/git/linux-2.6: (225 commits)
  [PATCH] Don't set calgary iommu as default y
  [PATCH] i386/x86-64: New Intel feature flags
  [PATCH] x86: Add a cumulative thermal throttle event counter.
  [PATCH] i386: Make the jiffies compares use the 64bit safe macros.
  [PATCH] x86: Refactor thermal throttle processing
  [PATCH] Add 64bit jiffies compares (for use with get_jiffies_64)
  [PATCH] Fix unwinder warning in traps.c
  [PATCH] x86: Allow disabling early pci scans with pci=noearly or disallowing conf1
  [PATCH] x86: Move direct PCI scanning functions out of line
  [PATCH] i386/x86-64: Make all early PCI scans dependent on CONFIG_PCI
  [PATCH] Don't leak NT bit into next task
  [PATCH] i386/x86-64: Work around gcc bug with noreturn functions in unwinder
  [PATCH] Fix some broken white space in ia32_signal.c
  [PATCH] Initialize argument registers for 32bit signal handlers.
  [PATCH] Remove all traces of signal number conversion
  [PATCH] Don't synchronize time reading on single core AMD systems
  [PATCH] Remove outdated comment in x86-64 mmconfig code
  [PATCH] Use string instructions for Core2 copy/clear
  [PATCH] x86: - restore i8259A eoi status on resume
  [PATCH] i386: Split multi-line printk in oops output.
  ...

6 files changed, 254 insertions, 141 deletions

diff --git a/arch/i386/oprofile/nmi_int.c b/arch/i386/oprofile/nmi_int.c
index 5f8dc8a21bd7..3700eef78743 100644
--- a/arch/i386/oprofile/nmi_int.c
+++ b/arch/i386/oprofile/nmi_int.c
@@ -17,14 +17,15 @@
 #include <asm/nmi.h>
 #include <asm/msr.h>
 #include <asm/apic.h>
+#include <asm/kdebug.h>
  
 #include "op_counter.h"
 #include "op_x86_model.h"
- 
+
 static struct op_x86_model_spec const * model;
 static struct op_msrs cpu_msrs[NR_CPUS];
 static unsigned long saved_lvtpc[NR_CPUS];
- 
+
 static int nmi_start(void);
 static void nmi_stop(void);
 
@@ -82,13 +83,24 @@ static void exit_driverfs(void)
 #define exit_driverfs() do { } while (0)
 #endif /* CONFIG_PM */
 
-
-static int nmi_callback(struct pt_regs * regs, int cpu)
+static int profile_exceptions_notify(struct notifier_block *self,
+                                     unsigned long val, void *data)
 {
-        return model->check_ctrs(regs, &cpu_msrs[cpu]);
+        struct die_args *args = (struct die_args *)data;
+        int ret = NOTIFY_DONE;
+        int cpu = smp_processor_id();
+
+        switch(val) {
+        case DIE_NMI:
+                if (model->check_ctrs(args->regs, &cpu_msrs[cpu]))
+                        ret = NOTIFY_STOP;
+                break;
+        default:
+                break;
+        }
+        return ret;
 }
- 
- 
+
 static void nmi_cpu_save_registers(struct op_msrs * msrs)
 {
         unsigned int const nr_ctrs = model->num_counters;
@@ -98,15 +110,19 @@ static void nmi_cpu_save_registers(struct op_msrs * msrs)
         unsigned int i;
 
         for (i = 0; i < nr_ctrs; ++i) {
-                rdmsr(counters[i].addr,
-                        counters[i].saved.low,
-                        counters[i].saved.high);
+                if (counters[i].addr){
+                        rdmsr(counters[i].addr,
+                                counters[i].saved.low,
+                                counters[i].saved.high);
+                }
         }
  
         for (i = 0; i < nr_ctrls; ++i) {
-                rdmsr(controls[i].addr,
-                        controls[i].saved.low,
-                        controls[i].saved.high);
+                if (controls[i].addr){
+                        rdmsr(controls[i].addr,
+                                controls[i].saved.low,
+                                controls[i].saved.high);
+                }
         }
 }
 
@@ -170,27 +186,29 @@ static void nmi_cpu_setup(void * dummy)
         apic_write(APIC_LVTPC, APIC_DM_NMI);
 }
 
+static struct notifier_block profile_exceptions_nb = {
+        .notifier_call = profile_exceptions_notify,
+        .next = NULL,
+        .priority = 0
+};
 
 static int nmi_setup(void)
 {
+        int err=0;
+
         if (!allocate_msrs())
                 return -ENOMEM;
 
-        /* We walk a thin line between law and rape here.
-         * We need to be careful to install our NMI handler
-         * without actually triggering any NMIs as this will
-         * break the core code horrifically.
-         */
-        if (reserve_lapic_nmi() < 0) {
+        if ((err = register_die_notifier(&profile_exceptions_nb))){
                 free_msrs();
-                return -EBUSY;
+                return err;
         }
+
         /* We need to serialize save and setup for HT because the subset
          * of msrs are distinct for save and setup operations
          */
         on_each_cpu(nmi_save_registers, NULL, 0, 1);
         on_each_cpu(nmi_cpu_setup, NULL, 0, 1);
-        set_nmi_callback(nmi_callback);
         nmi_enabled = 1;
         return 0;
 }
@@ -205,15 +223,19 @@ static void nmi_restore_registers(struct op_msrs * msrs)
         unsigned int i;
 
         for (i = 0; i < nr_ctrls; ++i) {
-                wrmsr(controls[i].addr,
-                        controls[i].saved.low,
-                        controls[i].saved.high);
+                if (controls[i].addr){
+                        wrmsr(controls[i].addr,
+                                controls[i].saved.low,
+                                controls[i].saved.high);
+                }
         }
  
         for (i = 0; i < nr_ctrs; ++i) {
-                wrmsr(counters[i].addr,
-                        counters[i].saved.low,
-                        counters[i].saved.high);
+                if (counters[i].addr){
+                        wrmsr(counters[i].addr,
+                                counters[i].saved.low,
+                                counters[i].saved.high);
+                }
         }
 }
  
@@ -234,6 +256,7 @@ static void nmi_cpu_shutdown(void * dummy)
         apic_write(APIC_LVTPC, saved_lvtpc[cpu]);
         apic_write(APIC_LVTERR, v);
         nmi_restore_registers(msrs);
+        model->shutdown(msrs);
 }
 
  
@@ -241,8 +264,7 @@ static void nmi_shutdown(void)
 {
         nmi_enabled = 0;
         on_each_cpu(nmi_cpu_shutdown, NULL, 0, 1);
-        unset_nmi_callback();
-        release_lapic_nmi();
+        unregister_die_notifier(&profile_exceptions_nb);
         free_msrs();
 }
 
@@ -284,6 +306,14 @@ static int nmi_create_files(struct super_block * sb, struct dentry * root)
                 struct dentry * dir;
                 char buf[4];
  
+                /* quick little hack to _not_ expose a counter if it is not
+                 * available for use.  This should protect userspace app.
+                 * NOTE:  assumes 1:1 mapping here (that counters are organized
+                 *        sequentially in their struct assignment).
+                 */
+                if (unlikely(!avail_to_resrv_perfctr_nmi_bit(i)))
+                        continue;
+
                 snprintf(buf,  sizeof(buf), "%d", i);
                 dir = oprofilefs_mkdir(sb, root, buf);
                 oprofilefs_create_ulong(sb, dir, "enabled", &counter_config[i].enabled); 
diff --git a/arch/i386/oprofile/nmi_timer_int.c b/arch/i386/oprofile/nmi_timer_int.c
index 930a1127bb30..abf0ba52a635 100644
--- a/arch/i386/oprofile/nmi_timer_int.c
+++ b/arch/i386/oprofile/nmi_timer_int.c
@@ -17,34 +17,49 @@
 #include <asm/nmi.h>
 #include <asm/apic.h>
 #include <asm/ptrace.h>
+#include <asm/kdebug.h>
  
-static int nmi_timer_callback(struct pt_regs * regs, int cpu)
+static int profile_timer_exceptions_notify(struct notifier_block *self,
+                                           unsigned long val, void *data)
 {
-        oprofile_add_sample(regs, 0);
-        return 1;
+        struct die_args *args = (struct die_args *)data;
+        int ret = NOTIFY_DONE;
+
+        switch(val) {
+        case DIE_NMI:
+                oprofile_add_sample(args->regs, 0);
+                ret = NOTIFY_STOP;
+                break;
+        default:
+                break;
+        }
+        return ret;
 }
 
+static struct notifier_block profile_timer_exceptions_nb = {
+        .notifier_call = profile_timer_exceptions_notify,
+        .next = NULL,
+        .priority = 0
+};
+
 static int timer_start(void)
 {
-        disable_timer_nmi_watchdog();
-        set_nmi_callback(nmi_timer_callback);
+        if (register_die_notifier(&profile_timer_exceptions_nb))
+                return 1;
         return 0;
 }
 
 
 static void timer_stop(void)
 {
-        enable_timer_nmi_watchdog();
-        unset_nmi_callback();
+        unregister_die_notifier(&profile_timer_exceptions_nb);
         synchronize_sched();  /* Allow already-started NMIs to complete. */
 }
 
 
 int __init op_nmi_timer_init(struct oprofile_operations * ops)
 {
-        extern int nmi_active;
-
-        if (nmi_active <= 0)
+        if ((nmi_watchdog != NMI_IO_APIC) || (atomic_read(&nmi_active) <= 0))
                 return -ENODEV;
 
         ops->start = timer_start;
diff --git a/arch/i386/oprofile/op_model_athlon.c b/arch/i386/oprofile/op_model_athlon.c
index 693bdea4a52b..3057a19e4641 100644
--- a/arch/i386/oprofile/op_model_athlon.c
+++ b/arch/i386/oprofile/op_model_athlon.c
@@ -21,10 +21,12 @@
 #define NUM_COUNTERS 4
 #define NUM_CONTROLS 4
 
+#define CTR_IS_RESERVED(msrs,c) (msrs->counters[(c)].addr ? 1 : 0)
 #define CTR_READ(l,h,msrs,c) do {rdmsr(msrs->counters[(c)].addr, (l), (h));} while (0)
 #define CTR_WRITE(l,msrs,c) do {wrmsr(msrs->counters[(c)].addr, -(unsigned int)(l), -1);} while (0)
 #define CTR_OVERFLOWED(n) (!((n) & (1U<<31)))
 
+#define CTRL_IS_RESERVED(msrs,c) (msrs->controls[(c)].addr ? 1 : 0)
 #define CTRL_READ(l,h,msrs,c) do {rdmsr(msrs->controls[(c)].addr, (l), (h));} while (0)
 #define CTRL_WRITE(l,h,msrs,c) do {wrmsr(msrs->controls[(c)].addr, (l), (h));} while (0)
 #define CTRL_SET_ACTIVE(n) (n |= (1<<22))
@@ -40,15 +42,21 @@ static unsigned long reset_value[NUM_COUNTERS];
  
 static void athlon_fill_in_addresses(struct op_msrs * const msrs)
 {
-        msrs->counters[0].addr = MSR_K7_PERFCTR0;
-        msrs->counters[1].addr = MSR_K7_PERFCTR1;
-        msrs->counters[2].addr = MSR_K7_PERFCTR2;
-        msrs->counters[3].addr = MSR_K7_PERFCTR3;
-
-        msrs->controls[0].addr = MSR_K7_EVNTSEL0;
-        msrs->controls[1].addr = MSR_K7_EVNTSEL1;
-        msrs->controls[2].addr = MSR_K7_EVNTSEL2;
-        msrs->controls[3].addr = MSR_K7_EVNTSEL3;
+        int i;
+
+        for (i=0; i < NUM_COUNTERS; i++) {
+                if (reserve_perfctr_nmi(MSR_K7_PERFCTR0 + i))
+                        msrs->counters[i].addr = MSR_K7_PERFCTR0 + i;
+                else
+                        msrs->counters[i].addr = 0;
+        }
+
+        for (i=0; i < NUM_CONTROLS; i++) {
+                if (reserve_evntsel_nmi(MSR_K7_EVNTSEL0 + i))
+                        msrs->controls[i].addr = MSR_K7_EVNTSEL0 + i;
+                else
+                        msrs->controls[i].addr = 0;
+        }
 }
 
  
@@ -59,19 +67,23 @@ static void athlon_setup_ctrs(struct op_msrs const * const msrs)
  
         /* clear all counters */
         for (i = 0 ; i < NUM_CONTROLS; ++i) {
+                if (unlikely(!CTRL_IS_RESERVED(msrs,i)))
+                        continue;
                 CTRL_READ(low, high, msrs, i);
                 CTRL_CLEAR(low);
                 CTRL_WRITE(low, high, msrs, i);
         }
-        
+
         /* avoid a false detection of ctr overflows in NMI handler */
         for (i = 0; i < NUM_COUNTERS; ++i) {
+                if (unlikely(!CTR_IS_RESERVED(msrs,i)))
+                        continue;
                 CTR_WRITE(1, msrs, i);
         }
 
         /* enable active counters */
         for (i = 0; i < NUM_COUNTERS; ++i) {
-                if (counter_config[i].enabled) {
+                if ((counter_config[i].enabled) && (CTR_IS_RESERVED(msrs,i))) {
                         reset_value[i] = counter_config[i].count;
 
                         CTR_WRITE(counter_config[i].count, msrs, i);
@@ -98,6 +110,8 @@ static int athlon_check_ctrs(struct pt_regs * const regs,
         int i;
 
         for (i = 0 ; i < NUM_COUNTERS; ++i) {
+                if (!reset_value[i])
+                        continue;
                 CTR_READ(low, high, msrs, i);
                 if (CTR_OVERFLOWED(low)) {
                         oprofile_add_sample(regs, i);
@@ -132,12 +146,27 @@ static void athlon_stop(struct op_msrs const * const msrs)
         /* Subtle: stop on all counters to avoid race with
          * setting our pm callback */
         for (i = 0 ; i < NUM_COUNTERS ; ++i) {
+                if (!reset_value[i])
+                        continue;
                 CTRL_READ(low, high, msrs, i);
                 CTRL_SET_INACTIVE(low);
                 CTRL_WRITE(low, high, msrs, i);
         }
 }
 
+static void athlon_shutdown(struct op_msrs const * const msrs)
+{
+        int i;
+
+        for (i = 0 ; i < NUM_COUNTERS ; ++i) {
+                if (CTR_IS_RESERVED(msrs,i))
+                        release_perfctr_nmi(MSR_K7_PERFCTR0 + i);
+        }
+        for (i = 0 ; i < NUM_CONTROLS ; ++i) {
+                if (CTRL_IS_RESERVED(msrs,i))
+                        release_evntsel_nmi(MSR_K7_EVNTSEL0 + i);
+        }
+}
 
 struct op_x86_model_spec const op_athlon_spec = {
         .num_counters = NUM_COUNTERS,
@@ -146,5 +175,6 @@ struct op_x86_model_spec const op_athlon_spec = {
         .setup_ctrs = &athlon_setup_ctrs,
         .check_ctrs = &athlon_check_ctrs,
         .start = &athlon_start,
-        .stop = &athlon_stop
+        .stop = &athlon_stop,
+        .shutdown = &athlon_shutdown
 };
diff --git a/arch/i386/oprofile/op_model_p4.c b/arch/i386/oprofile/op_model_p4.c
index 7c61d357b82b..47925927b12f 100644
--- a/arch/i386/oprofile/op_model_p4.c
+++ b/arch/i386/oprofile/op_model_p4.c
@@ -32,7 +32,7 @@
 #define NUM_CONTROLS_HT2 (NUM_ESCRS_HT2 + NUM_CCCRS_HT2)
 
 static unsigned int num_counters = NUM_COUNTERS_NON_HT;
-
+static unsigned int num_controls = NUM_CONTROLS_NON_HT;
 
 /* this has to be checked dynamically since the
    hyper-threadedness of a chip is discovered at
@@ -40,8 +40,10 @@ static unsigned int num_counters = NUM_COUNTERS_NON_HT;
 static inline void setup_num_counters(void)
 {
 #ifdef CONFIG_SMP
-        if (smp_num_siblings == 2)
+        if (smp_num_siblings == 2){
                 num_counters = NUM_COUNTERS_HT2;
+                num_controls = NUM_CONTROLS_HT2;
+        }
 #endif
 }
 
@@ -97,15 +99,6 @@ static struct p4_counter_binding p4_counters [NUM_COUNTERS_NON_HT] = {
 
 #define NUM_UNUSED_CCCRS        NUM_CCCRS_NON_HT - NUM_COUNTERS_NON_HT
 
-/* All cccr we don't use. */
-static int p4_unused_cccr[NUM_UNUSED_CCCRS] = {
-        MSR_P4_BPU_CCCR1,       MSR_P4_BPU_CCCR3,
-        MSR_P4_MS_CCCR1,        MSR_P4_MS_CCCR3,
-        MSR_P4_FLAME_CCCR1,     MSR_P4_FLAME_CCCR3,
-        MSR_P4_IQ_CCCR0,        MSR_P4_IQ_CCCR1,
-        MSR_P4_IQ_CCCR2,        MSR_P4_IQ_CCCR3
-};
-
 /* p4 event codes in libop/op_event.h are indices into this table. */
 
 static struct p4_event_binding p4_events[NUM_EVENTS] = {
@@ -372,6 +365,8 @@ static struct p4_event_binding p4_events[NUM_EVENTS] = {
 #define CCCR_OVF_P(cccr) ((cccr) & (1U<<31))
 #define CCCR_CLEAR_OVF(cccr) ((cccr) &= (~(1U<<31)))
 
+#define CTRL_IS_RESERVED(msrs,c) (msrs->controls[(c)].addr ? 1 : 0)
+#define CTR_IS_RESERVED(msrs,c) (msrs->counters[(c)].addr ? 1 : 0)
 #define CTR_READ(l,h,i) do {rdmsr(p4_counters[(i)].counter_address, (l), (h));} while (0)
 #define CTR_WRITE(l,i) do {wrmsr(p4_counters[(i)].counter_address, -(u32)(l), -1);} while (0)
 #define CTR_OVERFLOW_P(ctr) (!((ctr) & 0x80000000))
@@ -401,29 +396,34 @@ static unsigned long reset_value[NUM_COUNTERS_NON_HT];
 static void p4_fill_in_addresses(struct op_msrs * const msrs)
 {
         unsigned int i; 
-        unsigned int addr, stag;
+        unsigned int addr, cccraddr, stag;
 
         setup_num_counters();
         stag = get_stagger();
 
-        /* the counter registers we pay attention to */
+        /* initialize some registers */
         for (i = 0; i < num_counters; ++i) {
-                msrs->counters[i].addr = 
-                        p4_counters[VIRT_CTR(stag, i)].counter_address;
+                msrs->counters[i].addr = 0;
         }
-
-        /* FIXME: bad feeling, we don't save the 10 counters we don't use. */
-
-        /* 18 CCCR registers */
-        for (i = 0, addr = MSR_P4_BPU_CCCR0 + stag;
-             addr <= MSR_P4_IQ_CCCR5; ++i, addr += addr_increment()) {
-                msrs->controls[i].addr = addr;
+        for (i = 0; i < num_controls; ++i) {
+                msrs->controls[i].addr = 0;
         }
         
+        /* the counter & cccr registers we pay attention to */
+        for (i = 0; i < num_counters; ++i) {
+                addr = p4_counters[VIRT_CTR(stag, i)].counter_address;
+                cccraddr = p4_counters[VIRT_CTR(stag, i)].cccr_address;
+                if (reserve_perfctr_nmi(addr)){
+                        msrs->counters[i].addr = addr;
+                        msrs->controls[i].addr = cccraddr;
+                }
+        }
+
         /* 43 ESCR registers in three or four discontiguous group */
         for (addr = MSR_P4_BSU_ESCR0 + stag;
              addr < MSR_P4_IQ_ESCR0; ++i, addr += addr_increment()) {
-                msrs->controls[i].addr = addr;
+                if (reserve_evntsel_nmi(addr))
+                        msrs->controls[i].addr = addr;
         }
 
         /* no IQ_ESCR0/1 on some models, we save a seconde time BSU_ESCR0/1
@@ -431,47 +431,57 @@ static void p4_fill_in_addresses(struct op_msrs * const msrs)
         if (boot_cpu_data.x86_model >= 0x3) {
                 for (addr = MSR_P4_BSU_ESCR0 + stag;
                      addr <= MSR_P4_BSU_ESCR1; ++i, addr += addr_increment()) {
-                        msrs->controls[i].addr = addr;
+                        if (reserve_evntsel_nmi(addr))
+                                msrs->controls[i].addr = addr;
                 }
         } else {
                 for (addr = MSR_P4_IQ_ESCR0 + stag;
                      addr <= MSR_P4_IQ_ESCR1; ++i, addr += addr_increment()) {
-                        msrs->controls[i].addr = addr;
+                        if (reserve_evntsel_nmi(addr))
+                                msrs->controls[i].addr = addr;
                 }
         }
 
         for (addr = MSR_P4_RAT_ESCR0 + stag;
              addr <= MSR_P4_SSU_ESCR0; ++i, addr += addr_increment()) {
-                msrs->controls[i].addr = addr;
+                if (reserve_evntsel_nmi(addr))
+                        msrs->controls[i].addr = addr;
         }
         
         for (addr = MSR_P4_MS_ESCR0 + stag;
              addr <= MSR_P4_TC_ESCR1; ++i, addr += addr_increment()) { 
-                msrs->controls[i].addr = addr;
+                if (reserve_evntsel_nmi(addr))
+                        msrs->controls[i].addr = addr;
         }
         
         for (addr = MSR_P4_IX_ESCR0 + stag;
              addr <= MSR_P4_CRU_ESCR3; ++i, addr += addr_increment()) { 
-                msrs->controls[i].addr = addr;
+                if (reserve_evntsel_nmi(addr))
+                        msrs->controls[i].addr = addr;
         }
 
         /* there are 2 remaining non-contiguously located ESCRs */
 
         if (num_counters == NUM_COUNTERS_NON_HT) {              
                 /* standard non-HT CPUs handle both remaining ESCRs*/
-                msrs->controls[i++].addr = MSR_P4_CRU_ESCR5;
-                msrs->controls[i++].addr = MSR_P4_CRU_ESCR4;
+                if (reserve_evntsel_nmi(MSR_P4_CRU_ESCR5))
+                        msrs->controls[i++].addr = MSR_P4_CRU_ESCR5;
+                if (reserve_evntsel_nmi(MSR_P4_CRU_ESCR4))
+                        msrs->controls[i++].addr = MSR_P4_CRU_ESCR4;
 
         } else if (stag == 0) {
                 /* HT CPUs give the first remainder to the even thread, as
                    the 32nd control register */
-                msrs->controls[i++].addr = MSR_P4_CRU_ESCR4;
+                if (reserve_evntsel_nmi(MSR_P4_CRU_ESCR4))
+                        msrs->controls[i++].addr = MSR_P4_CRU_ESCR4;
 
         } else {
                 /* and two copies of the second to the odd thread,
                    for the 22st and 23nd control registers */
-                msrs->controls[i++].addr = MSR_P4_CRU_ESCR5;
-                msrs->controls[i++].addr = MSR_P4_CRU_ESCR5;
+                if (reserve_evntsel_nmi(MSR_P4_CRU_ESCR5)) {
+                        msrs->controls[i++].addr = MSR_P4_CRU_ESCR5;
+                        msrs->controls[i++].addr = MSR_P4_CRU_ESCR5;
+                }
         }
 }
 
@@ -544,7 +554,6 @@ static void p4_setup_ctrs(struct op_msrs const * const msrs)
 {
         unsigned int i;
         unsigned int low, high;
-        unsigned int addr;
         unsigned int stag;
 
         stag = get_stagger();
@@ -557,59 +566,24 @@ static void p4_setup_ctrs(struct op_msrs const * const msrs)
 
         /* clear the cccrs we will use */
         for (i = 0 ; i < num_counters ; i++) {
+                if (unlikely(!CTRL_IS_RESERVED(msrs,i)))
+                        continue;
                 rdmsr(p4_counters[VIRT_CTR(stag, i)].cccr_address, low, high);
                 CCCR_CLEAR(low);
                 CCCR_SET_REQUIRED_BITS(low);
                 wrmsr(p4_counters[VIRT_CTR(stag, i)].cccr_address, low, high);
         }
 
-        /* clear cccrs outside our concern */
-        for (i = stag ; i < NUM_UNUSED_CCCRS ; i += addr_increment()) {
-                rdmsr(p4_unused_cccr[i], low, high);
-                CCCR_CLEAR(low);
-                CCCR_SET_REQUIRED_BITS(low);
-                wrmsr(p4_unused_cccr[i], low, high);
-        }
-
         /* clear all escrs (including those outside our concern) */
-        for (addr = MSR_P4_BSU_ESCR0 + stag;
-             addr <  MSR_P4_IQ_ESCR0; addr += addr_increment()) {
-                wrmsr(addr, 0, 0);
-        }
-
-        /* On older models clear also MSR_P4_IQ_ESCR0/1 */
-        if (boot_cpu_data.x86_model < 0x3) {
-                wrmsr(MSR_P4_IQ_ESCR0, 0, 0);
-                wrmsr(MSR_P4_IQ_ESCR1, 0, 0);
-        }
-
-        for (addr = MSR_P4_RAT_ESCR0 + stag;
-             addr <= MSR_P4_SSU_ESCR0; ++i, addr += addr_increment()) {
-                wrmsr(addr, 0, 0);
-        }
-        
-        for (addr = MSR_P4_MS_ESCR0 + stag;
-             addr <= MSR_P4_TC_ESCR1; addr += addr_increment()){ 
-                wrmsr(addr, 0, 0);
-        }
-        
-        for (addr = MSR_P4_IX_ESCR0 + stag;
-             addr <= MSR_P4_CRU_ESCR3; addr += addr_increment()){ 
-                wrmsr(addr, 0, 0);
+        for (i = num_counters; i < num_controls; i++) {
+                if (unlikely(!CTRL_IS_RESERVED(msrs,i)))
+                        continue;
+                wrmsr(msrs->controls[i].addr, 0, 0);
         }
 
-        if (num_counters == NUM_COUNTERS_NON_HT) {              
-                wrmsr(MSR_P4_CRU_ESCR4, 0, 0);
-                wrmsr(MSR_P4_CRU_ESCR5, 0, 0);
-        } else if (stag == 0) {
-                wrmsr(MSR_P4_CRU_ESCR4, 0, 0);
-        } else {
-                wrmsr(MSR_P4_CRU_ESCR5, 0, 0);
-        }               
-        
         /* setup all counters */
         for (i = 0 ; i < num_counters ; ++i) {
-                if (counter_config[i].enabled) {
+                if ((counter_config[i].enabled) && (CTRL_IS_RESERVED(msrs,i))) {
                         reset_value[i] = counter_config[i].count;
                         pmc_setup_one_p4_counter(i);
                         CTR_WRITE(counter_config[i].count, VIRT_CTR(stag, i));
@@ -696,12 +670,32 @@ static void p4_stop(struct op_msrs const * const msrs)
         stag = get_stagger();
 
         for (i = 0; i < num_counters; ++i) {
+                if (!reset_value[i])
+                        continue;
                 CCCR_READ(low, high, VIRT_CTR(stag, i));
                 CCCR_SET_DISABLE(low);
                 CCCR_WRITE(low, high, VIRT_CTR(stag, i));
         }
 }
 
+static void p4_shutdown(struct op_msrs const * const msrs)
+{
+        int i;
+
+        for (i = 0 ; i < num_counters ; ++i) {
+                if (CTR_IS_RESERVED(msrs,i))
+                        release_perfctr_nmi(msrs->counters[i].addr);
+        }
+        /* some of the control registers are specially reserved in
+         * conjunction with the counter registers (hence the starting offset).
+         * This saves a few bits.
+         */
+        for (i = num_counters ; i < num_controls ; ++i) {
+                if (CTRL_IS_RESERVED(msrs,i))
+                        release_evntsel_nmi(msrs->controls[i].addr);
+        }
+}
+
 
 #ifdef CONFIG_SMP
 struct op_x86_model_spec const op_p4_ht2_spec = {
@@ -711,7 +705,8 @@ struct op_x86_model_spec const op_p4_ht2_spec = {
         .setup_ctrs = &p4_setup_ctrs,
         .check_ctrs = &p4_check_ctrs,
         .start = &p4_start,
-        .stop = &p4_stop
+        .stop = &p4_stop,
+        .shutdown = &p4_shutdown
 };
 #endif
 
@@ -722,5 +717,6 @@ struct op_x86_model_spec const op_p4_spec = {
         .setup_ctrs = &p4_setup_ctrs,
         .check_ctrs = &p4_check_ctrs,
         .start = &p4_start,
-        .stop = &p4_stop
+        .stop = &p4_stop,
+        .shutdown = &p4_shutdown
 };
diff --git a/arch/i386/oprofile/op_model_ppro.c b/arch/i386/oprofile/op_model_ppro.c
index 5c3ab4b027ad..f88e05ba8eb3 100644
--- a/arch/i386/oprofile/op_model_ppro.c
+++ b/arch/i386/oprofile/op_model_ppro.c
@@ -22,10 +22,12 @@
 #define NUM_COUNTERS 2
 #define NUM_CONTROLS 2
 
+#define CTR_IS_RESERVED(msrs,c) (msrs->counters[(c)].addr ? 1 : 0)
 #define CTR_READ(l,h,msrs,c) do {rdmsr(msrs->counters[(c)].addr, (l), (h));} while (0)
 #define CTR_WRITE(l,msrs,c) do {wrmsr(msrs->counters[(c)].addr, -(u32)(l), -1);} while (0)
 #define CTR_OVERFLOWED(n) (!((n) & (1U<<31)))
 
+#define CTRL_IS_RESERVED(msrs,c) (msrs->controls[(c)].addr ? 1 : 0)
 #define CTRL_READ(l,h,msrs,c) do {rdmsr((msrs->controls[(c)].addr), (l), (h));} while (0)
 #define CTRL_WRITE(l,h,msrs,c) do {wrmsr((msrs->controls[(c)].addr), (l), (h));} while (0)
 #define CTRL_SET_ACTIVE(n) (n |= (1<<22))
@@ -41,11 +43,21 @@ static unsigned long reset_value[NUM_COUNTERS];
  
 static void ppro_fill_in_addresses(struct op_msrs * const msrs)
 {
-        msrs->counters[0].addr = MSR_P6_PERFCTR0;
-        msrs->counters[1].addr = MSR_P6_PERFCTR1;
+        int i;
+
+        for (i=0; i < NUM_COUNTERS; i++) {
+                if (reserve_perfctr_nmi(MSR_P6_PERFCTR0 + i))
+                        msrs->counters[i].addr = MSR_P6_PERFCTR0 + i;
+                else
+                        msrs->counters[i].addr = 0;
+        }
         
-        msrs->controls[0].addr = MSR_P6_EVNTSEL0;
-        msrs->controls[1].addr = MSR_P6_EVNTSEL1;
+        for (i=0; i < NUM_CONTROLS; i++) {
+                if (reserve_evntsel_nmi(MSR_P6_EVNTSEL0 + i))
+                        msrs->controls[i].addr = MSR_P6_EVNTSEL0 + i;
+                else
+                        msrs->controls[i].addr = 0;
+        }
 }
 
 
@@ -56,6 +68,8 @@ static void ppro_setup_ctrs(struct op_msrs const * const msrs)
 
         /* clear all counters */
         for (i = 0 ; i < NUM_CONTROLS; ++i) {
+                if (unlikely(!CTRL_IS_RESERVED(msrs,i)))
+                        continue;
                 CTRL_READ(low, high, msrs, i);
                 CTRL_CLEAR(low);
                 CTRL_WRITE(low, high, msrs, i);
@@ -63,12 +77,14 @@ static void ppro_setup_ctrs(struct op_msrs const * const msrs)
         
         /* avoid a false detection of ctr overflows in NMI handler */
         for (i = 0; i < NUM_COUNTERS; ++i) {
+                if (unlikely(!CTR_IS_RESERVED(msrs,i)))
+                        continue;
                 CTR_WRITE(1, msrs, i);
         }
 
         /* enable active counters */
         for (i = 0; i < NUM_COUNTERS; ++i) {
-                if (counter_config[i].enabled) {
+                if ((counter_config[i].enabled) && (CTR_IS_RESERVED(msrs,i))) {
                         reset_value[i] = counter_config[i].count;
 
                         CTR_WRITE(counter_config[i].count, msrs, i);
@@ -81,6 +97,8 @@ static void ppro_setup_ctrs(struct op_msrs const * const msrs)
                         CTRL_SET_UM(low, counter_config[i].unit_mask);
                         CTRL_SET_EVENT(low, counter_config[i].event);
                         CTRL_WRITE(low, high, msrs, i);
+                } else {
+                        reset_value[i] = 0;
                 }
         }
 }
@@ -93,6 +111,8 @@ static int ppro_check_ctrs(struct pt_regs * const regs,
         int i;
  
         for (i = 0 ; i < NUM_COUNTERS; ++i) {
+                if (!reset_value[i])
+                        continue;
                 CTR_READ(low, high, msrs, i);
                 if (CTR_OVERFLOWED(low)) {
                         oprofile_add_sample(regs, i);
@@ -118,18 +138,38 @@ static int ppro_check_ctrs(struct pt_regs * const regs,
 static void ppro_start(struct op_msrs const * const msrs)
 {
         unsigned int low,high;
-        CTRL_READ(low, high, msrs, 0);
-        CTRL_SET_ACTIVE(low);
-        CTRL_WRITE(low, high, msrs, 0);
+
+        if (reset_value[0]) {
+                CTRL_READ(low, high, msrs, 0);
+                CTRL_SET_ACTIVE(low);
+                CTRL_WRITE(low, high, msrs, 0);
+        }
 }
 
 
 static void ppro_stop(struct op_msrs const * const msrs)
 {
         unsigned int low,high;
-        CTRL_READ(low, high, msrs, 0);
-        CTRL_SET_INACTIVE(low);
-        CTRL_WRITE(low, high, msrs, 0);
+
+        if (reset_value[0]) {
+                CTRL_READ(low, high, msrs, 0);
+                CTRL_SET_INACTIVE(low);
+                CTRL_WRITE(low, high, msrs, 0);
+        }
+}
+
+static void ppro_shutdown(struct op_msrs const * const msrs)
+{
+        int i;
+
+        for (i = 0 ; i < NUM_COUNTERS ; ++i) {
+                if (CTR_IS_RESERVED(msrs,i))
+                        release_perfctr_nmi(MSR_P6_PERFCTR0 + i);
+        }
+        for (i = 0 ; i < NUM_CONTROLS ; ++i) {
+                if (CTRL_IS_RESERVED(msrs,i))
+                        release_evntsel_nmi(MSR_P6_EVNTSEL0 + i);
+        }
 }
 
 
@@ -140,5 +180,6 @@ struct op_x86_model_spec const op_ppro_spec = {
         .setup_ctrs = &ppro_setup_ctrs,
         .check_ctrs = &ppro_check_ctrs,
         .start = &ppro_start,
-        .stop = &ppro_stop
+        .stop = &ppro_stop,
+        .shutdown = &ppro_shutdown
 };
diff --git a/arch/i386/oprofile/op_x86_model.h b/arch/i386/oprofile/op_x86_model.h
index 123b7e90a9ee..abb1aa95b979 100644
--- a/arch/i386/oprofile/op_x86_model.h
+++ b/arch/i386/oprofile/op_x86_model.h
@@ -40,6 +40,7 @@ struct op_x86_model_spec {
                 struct op_msrs const * const msrs);
         void (*start)(struct op_msrs const * const msrs);
         void (*stop)(struct op_msrs const * const msrs);
+        void (*shutdown)(struct op_msrs const * const msrs);
 };
 
 extern struct op_x86_model_spec const op_ppro_spec;