Merge branches 'x86/alternatives', 'x86/cleanups', 'x86/commandline', 'x86/crashdump...

diff --cc Documentation/kernel-parameters.txt
Simple merge

diff --cc arch/x86/Kconfig
index ebfd7ff,ac2fb06,8e5e45a,fbcb79b,ed92864,ed92864,962388c,765ef6a,ed92864,ac2fb06,ed92864,ed92864,09f6b7f,ed92864,68d91c8,3d0f2b6,68d91c8,ed92864,ed92864,ed92864,68d91c8..97f0d2b
--- 1/arch/x86/Kconfig
--- 2/arch/x86/Kconfig
--- 3/arch/x86/Kconfig
--- 4/arch/x86/Kconfig
--- 5/arch/x86/Kconfig
--- 6/arch/x86/Kconfig
--- 7/arch/x86/Kconfig
--- 8/arch/x86/Kconfig
--- 9/arch/x86/Kconfig
--- 10/arch/x86/Kconfig
--- 11/arch/x86/Kconfig
--- 12/arch/x86/Kconfig
--- 13/arch/x86/Kconfig
--- 14/arch/x86/Kconfig
--- 15/arch/x86/Kconfig
--- 16/arch/x86/Kconfig
--- 17/arch/x86/Kconfig
--- 18/arch/x86/Kconfig
--- 19/arch/x86/Kconfig
--- 20/arch/x86/Kconfig
--- 21/arch/x86/Kconfig
+++ b/arch/x86/Kconfig
@@@@@@@@@@@@@@@@@@@@@@ -587,11 -585,17 -586,11 -585,17 -586,11 -586,11 -586,11 -585,17 -586,11 -585,17 -586,11 -586,11 -586,11 -586,11 -585,17 -586,17 -585,17 -586,11 -586,11 -586,11 -585,17 +587,11 @@@@@@@@@@@@@@@@@@@@@@ config MAXSM
                          Configure maximum number of CPUS and NUMA Nodes for this architecture.
                          If unsure, say N.
                     
 - -   - -    ---   -if MAXSMP
   -                 config NR_CPUS
   -                    int
   -                    default "4096"
   -                 endif
   -                 
   -                 if !MAXSMP
                     config NR_CPUS
 -     - -    ---   -   int
 -     - -    ---   -   default "4096"
 -     - -    ---   -endif
 -     - -    ---   -
 -     - -    ---   -if !MAXSMP
 -     - -    ---   -config NR_CPUS
 - -   - -    ---   -   int "Maximum number of CPUs (2-4096)"
 - -   - -    ---   -   range 2 4096
 + +   + +    +++   +   int "Maximum number of CPUs (2-512)" if !MAXSMP
 + +   + +    +++   +   range 2 512
                        depends on SMP
 + +   + +    +++   +   default "4096" if MAXSMP
                        default "32" if X86_NUMAQ || X86_SUMMIT || X86_BIGSMP || X86_ES7000
                        default "8"
                        help
@@@@@@@@@@@@@@@@@@@@@@ -1118,10 -1131,10 -1117,10 -1131,10 -1117,10 -1117,10 -1117,10 -1131,10 -1117,10 -1131,10 -1117,10 -1117,10 -1117,10 -1117,10 -1131,10 -1132,10 -1131,10 -1117,10 -1117,10 -1117,10 -1131,10 +1118,10 @@@@@@@@@@@@@@@@@@@@@@ config MTR
                          You can safely say Y even if your machine doesn't have MTRRs, you'll
                          just add about 9 KB to your kernel.
                     
------- -------------     See <file:Documentation/mtrr.txt> for more information.
+++++++ +++++++++++++     See <file:Documentation/x86/mtrr.txt> for more information.
                     
                     config MTRR_SANITIZER
------------ --------   bool
++++++++++++ ++++++++   def_bool y
                        prompt "MTRR cleanup support"
                        depends on MTRR
                        help

diff --cc arch/x86/boot/compressed/misc.c
Simple merge

diff --cc arch/x86/kernel/alternative.c
Simple merge

diff --cc arch/x86/kernel/apm_32.c
Simple merge

diff --cc arch/x86/kernel/cpu/mtrr/main.c
index 5df16d8,6f23969,8a7c792,6f23969,b117d7f,b117d7f,b117d7f,6f23969,b117d7f,6f23969,b117d7f,b117d7f,5994a9f,b117d7f,6f23969,6f23969,b117d7f,b117d7f,b117d7f,885c826,6f23969..c78c048
--- 1/arch/x86/kernel/cpu/mtrr/main.c
--- 2/arch/x86/kernel/cpu/mtrr/main.c
--- 3/arch/x86/kernel/cpu/mtrr/main.c
--- 4/arch/x86/kernel/cpu/mtrr/main.c
--- 5/arch/x86/kernel/cpu/mtrr/main.c
--- 6/arch/x86/kernel/cpu/mtrr/main.c
--- 7/arch/x86/kernel/cpu/mtrr/main.c
--- 8/arch/x86/kernel/cpu/mtrr/main.c
--- 9/arch/x86/kernel/cpu/mtrr/main.c
--- 10/arch/x86/kernel/cpu/mtrr/main.c
--- 11/arch/x86/kernel/cpu/mtrr/main.c
--- 12/arch/x86/kernel/cpu/mtrr/main.c
--- 13/arch/x86/kernel/cpu/mtrr/main.c
--- 14/arch/x86/kernel/cpu/mtrr/main.c
--- 15/arch/x86/kernel/cpu/mtrr/main.c
--- 16/arch/x86/kernel/cpu/mtrr/main.c
--- 17/arch/x86/kernel/cpu/mtrr/main.c
--- 18/arch/x86/kernel/cpu/mtrr/main.c
--- 19/arch/x86/kernel/cpu/mtrr/main.c
--- 20/arch/x86/kernel/cpu/mtrr/main.c
--- 21/arch/x86/kernel/cpu/mtrr/main.c
+++ b/arch/x86/kernel/cpu/mtrr/main.c
@@@@@@@@@@@@@@@@@@@@@@ -834,8 -834,8 -834,8 -834,8 -834,8 -834,8 -834,8 -834,8 -834,8 -834,8 -834,8 -834,8 -835,15 -834,8 -834,8 -834,8 -834,8 -834,8 -834,8 -834,8 -834,8 +835,15 @@@@@@@@@@@@@@@@@@@@@@ static int __init enable_mtrr_cleanup_s
                                enable_mtrr_cleanup = 1;
                        return 0;
                     }
 ------------------ -early_param("enble_mtrr_cleanup", enable_mtrr_cleanup_setup);
 ++++++++++++++++++ +early_param("enable_mtrr_cleanup", enable_mtrr_cleanup_setup);
 +++++++++++ ++++++ +
++++++++++++ ++++++++static int __init mtrr_cleanup_debug_setup(char *str)
++++++++++++ ++++++++{
++++++++++++ ++++++++   debug_print = 1;
++++++++++++ ++++++++   return 0;
++++++++++++ ++++++++}
++++++++++++ ++++++++early_param("mtrr_cleanup_debug", mtrr_cleanup_debug_setup);
+                  + 
                     struct var_mtrr_state {
                        unsigned long   range_startk;
                        unsigned long   range_sizek;
@@@@@@@@@@@@@@@@@@@@@@ -996,50 -996,50 -996,50 -996,50 -996,50 -996,50 -996,50 -996,50 -996,50 -996,50 -996,50 -996,50 -1062,28 -996,50 -996,50 -996,50 -996,50 -996,50 -996,50 -996,50 -996,50 +1062,28 @@@@@@@@@@@@@@@@@@@@@@ second_try
                                                (range0_basek + range0_sizek)<<10);
                                state->reg = range_to_mtrr(state->reg, range0_basek,
                                                range0_sizek, MTRR_TYPE_WRBACK);
-   --- - -- -  ---- 
-   --- - -- -  ----    }
-   --- - -- -  ---- 
-   --- - -- -  ----    range_basek = range0_basek + range0_sizek;
-   --- - -- -  ----    range_sizek = chunk_sizek;
------------ --------
-   --- - -- -  ----    if (range_basek + range_sizek > basek &&
-   --- - -- -  ----        range_basek + range_sizek <= (basek + sizek)) {
-   --- - -- -  ----            /* one hole */
-   --- - -- -  ----            second_basek = basek;
-   --- - -- -  ----            second_sizek = range_basek + range_sizek - basek;
                        }
                     
 ---   - -    --    -   range_basek = range0_basek + range0_sizek;
 ---   - -    --    -   range_sizek = chunk_sizek;
 ---   - -    --    -
 ---   - -    --    -   if (range_basek + range_sizek > basek &&
 ---   - -    --    -       range_basek + range_sizek <= (basek + sizek)) {
 ---   - -    --    -           /* one hole */
 ---   - -    --    -           second_basek = basek;
 ---   - -    --    -           second_sizek = range_basek + range_sizek - basek;
 ---   - -    --    -   }
 ---   - -    --    -
------------ --------   /* if last piece, only could one hole near end */
------------ --------   if ((second_basek || !basek) &&
------------ --------       range_sizek - (state->range_sizek - range0_sizek) - second_sizek <
------------ --------       (chunk_sizek >> 1)) {
------------ --------           /*
------------ --------            * one hole in middle (second_sizek is 0) or at end
------------ --------            * (second_sizek is 0 )
------------ --------            */
------------ --------           hole_sizek = range_sizek - (state->range_sizek - range0_sizek)
------------ --------                            - second_sizek;
------------ --------           hole_basek = range_basek + range_sizek - hole_sizek
------------ --------                            - second_sizek;
------------ --------   } else {
------------ --------           /* fallback for big hole, or several holes */
++++++++++++ ++++++++   if (range0_sizek < state->range_sizek) {
++++++++++++ ++++++++           /* need to handle left over */
                                range_sizek = state->range_sizek - range0_sizek;
------------ --------           second_basek = 0;
------------ --------           second_sizek = 0;
++++++++++++ ++++++++
++++++++++++ ++++++++           if (debug_print)
++++++++++++ ++++++++                   printk(KERN_DEBUG "range: %016lx - %016lx\n",
++++++++++++ ++++++++                            range_basek<<10,
++++++++++++ ++++++++                            (range_basek + range_sizek)<<10);
++++++++++++ ++++++++           state->reg = range_to_mtrr(state->reg, range_basek,
++++++++++++ ++++++++                            range_sizek, MTRR_TYPE_WRBACK);
                        }
                     
------------ --------   if (debug_print)
------------ --------           printk(KERN_DEBUG "range: %016lx - %016lx\n", range_basek<<10,
------------ --------                    (range_basek + range_sizek)<<10);
------------ --------   state->reg = range_to_mtrr(state->reg, range_basek, range_sizek,
------------ --------                                    MTRR_TYPE_WRBACK);
                        if (hole_sizek) {
++++++++++++ ++++++++           hole_basek = range_basek - hole_sizek - second_sizek;
                                if (debug_print)
                                        printk(KERN_DEBUG "hole: %016lx - %016lx\n",
------------ --------                            hole_basek<<10, (hole_basek + hole_sizek)<<10);
------------ --------           state->reg = range_to_mtrr(state->reg, hole_basek, hole_sizek,
------------ --------                                            MTRR_TYPE_UNCACHABLE);
------------ --------
++++++++++++ ++++++++                            hole_basek<<10,
++++++++++++ ++++++++                            (hole_basek + hole_sizek)<<10);
++++++++++++ ++++++++           state->reg = range_to_mtrr(state->reg, hole_basek,
++++++++++++ ++++++++                            hole_sizek, MTRR_TYPE_UNCACHABLE);
                        }
                     
                        return second_sizek;
@@@@@@@@@@@@@@@@@@@@@@ -1216,15 -1216,15 -1216,14 -1216,15 -1216,15 -1216,15 -1216,15 -1216,15 -1216,15 -1216,15 -1216,15 -1216,15 -1263,48 -1216,15 -1216,15 -1216,15 -1216,15 -1216,15 -1216,15 -1216,15 -1216,15 +1263,47 @@@@@@@@@@@@@@@@@@@@@@ static int __init mtrr_cleanup(unsigne
                                num_var_ranges - num[MTRR_NUM_TYPES])
                                return 0;
                     
++++++++++++ ++++++++   /* print original var MTRRs at first, for debugging: */
++++++++++++ ++++++++   printk(KERN_DEBUG "original variable MTRRs\n");
++++++++++++ ++++++++   for (i = 0; i < num_var_ranges; i++) {
++++++++++++ ++++++++           char start_factor = 'K', size_factor = 'K';
++++++++++++ ++++++++           unsigned long start_base, size_base;
++++++++++++ ++++++++
++++++++++++ ++++++++           size_base = range_state[i].size_pfn << (PAGE_SHIFT - 10);
++++++++++++ ++++++++           if (!size_base)
++++++++++++ ++++++++                   continue;
++++++++++++ ++++++++
++++++++++++ ++++++++           size_base = to_size_factor(size_base, &size_factor),
++++++++++++ ++++++++           start_base = range_state[i].base_pfn << (PAGE_SHIFT - 10);
++++++++++++ ++++++++           start_base = to_size_factor(start_base, &start_factor),
++++++++++++ ++++++++           type = range_state[i].type;
++++++++++++ ++++++++
++++++++++++ ++++++++           printk(KERN_DEBUG "reg %d, base: %ld%cB, range: %ld%cB, type %s\n",
++++++++++++ ++++++++                   i, start_base, start_factor,
++++++++++++ ++++++++                   size_base, size_factor,
++++++++++++ ++++++++                   (type == MTRR_TYPE_UNCACHABLE) ? "UC" :
++++++++++++ ++++++++                       ((type == MTRR_TYPE_WRPROT) ? "WP" :
++++++++++++ ++++++++                        ((type == MTRR_TYPE_WRBACK) ? "WB" : "Other"))
++++++++++++ ++++++++                   );
++++++++++++ ++++++++   }
++++++++++++ ++++++++
                        memset(range, 0, sizeof(range));
                        extra_remove_size = 0;
-- ------------------   if (mtrr_tom2) {
-- ------------------           extra_remove_base = 1 << (32 - PAGE_SHIFT);
++ ++++++++++++++++++   extra_remove_base = 1 << (32 - PAGE_SHIFT);
++ ++++++++++++++++++   if (mtrr_tom2)
                                extra_remove_size =
                                        (mtrr_tom2 >> PAGE_SHIFT) - extra_remove_base;
-- ------------------   }
                        nr_range = x86_get_mtrr_mem_range(range, 0, extra_remove_base,
                                                          extra_remove_size);
++++++++++++ ++++++++   /*
++++++++++++ ++++++++    * [0, 1M) should always be coverred by var mtrr with WB
++++++++++++ ++++++++    * and fixed mtrrs should take effective before var mtrr for it
++++++++++++ ++++++++    */
++++++++++++ ++++++++   nr_range = add_range_with_merge(range, nr_range, 0,
++++++++++++ ++++++++                                   (1ULL<<(20 - PAGE_SHIFT)) - 1);
++++++++++++ ++++++++   /* sort the ranges */
++++++++++++ ++++++++   sort(range, nr_range, sizeof(struct res_range), cmp_range, NULL);
++++++++++++ ++++++++
                        range_sums = sum_ranges(range, nr_range);
                        printk(KERN_INFO "total RAM coverred: %ldM\n",
                               range_sums >> (20 - PAGE_SHIFT));

diff --cc arch/x86/kernel/crash_dump_64.c
Simple merge

diff --cc arch/x86/kernel/pci-gart_64.c
Simple merge

diff --cc arch/x86/kernel/process.c
Simple merge

diff --cc arch/x86/kernel/process_32.c
index c8609de,53bc653,3b7a1dd,53bc653,3b7a1dd,62a4790,3b7a1dd,3b7a1dd,31f40b2,53bc653,3b7a1dd,3b7a1dd,31f40b2,3b7a1dd,3b7a1dd,53bc653,3b7a1dd,4b3cfdf,3b7a1dd,31f40b2,3b7a1dd..205188d
--- 1/arch/x86/kernel/process_32.c
--- 2/arch/x86/kernel/process_32.c
--- 3/arch/x86/kernel/process_32.c
--- 4/arch/x86/kernel/process_32.c
--- 5/arch/x86/kernel/process_32.c
--- 6/arch/x86/kernel/process_32.c
--- 7/arch/x86/kernel/process_32.c
--- 8/arch/x86/kernel/process_32.c
--- 9/arch/x86/kernel/process_32.c
--- 10/arch/x86/kernel/process_32.c
--- 11/arch/x86/kernel/process_32.c
--- 12/arch/x86/kernel/process_32.c
--- 13/arch/x86/kernel/process_32.c
--- 14/arch/x86/kernel/process_32.c
--- 15/arch/x86/kernel/process_32.c
--- 16/arch/x86/kernel/process_32.c
--- 17/arch/x86/kernel/process_32.c
--- 18/arch/x86/kernel/process_32.c
--- 19/arch/x86/kernel/process_32.c
--- 20/arch/x86/kernel/process_32.c
--- 21/arch/x86/kernel/process_32.c
+++ b/arch/x86/kernel/process_32.c
@@@@@@@@@@@@@@@@@@@@@@ -55,9 -55,6 -55,6 -55,6 -55,6 -56,6 -55,6 -55,6 -55,7 -55,6 -55,6 -55,6 -55,7 -55,6 -55,6 -55,6 -55,6 -55,6 -55,6 -55,7 -55,6 +56,9 @@@@@@@@@@@@@@@@@@@@@@
                     #include <asm/tlbflush.h>
                     #include <asm/cpu.h>
                     #include <asm/kdebug.h>
 +++++++ +++ ++++++ +#include <asm/idle.h>
 ++++++++++++++++++++#include <asm/syscalls.h>
 ++++++++++++++++++++#include <asm/smp.h>
                     
                     asmlinkage void ret_from_fork(void) __asm__("ret_from_fork");
                     

diff --cc arch/x86/kernel/process_64.c
index 79e3e17,3fb62a7,e04134a,3fb62a7,71553b6,71553b6,71553b6,71553b6,e12e0e4,3fb62a7,71553b6,71553b6,e12e0e4,71553b6,71553b6,3fb62a7,71553b6,e12e0e4,71553b6,e12e0e4,71553b6..2a8ccb9
--- 1/arch/x86/kernel/process_64.c
--- 2/arch/x86/kernel/process_64.c
--- 3/arch/x86/kernel/process_64.c
--- 4/arch/x86/kernel/process_64.c
--- 5/arch/x86/kernel/process_64.c
--- 6/arch/x86/kernel/process_64.c
--- 7/arch/x86/kernel/process_64.c
--- 8/arch/x86/kernel/process_64.c
--- 9/arch/x86/kernel/process_64.c
--- 10/arch/x86/kernel/process_64.c
--- 11/arch/x86/kernel/process_64.c
--- 12/arch/x86/kernel/process_64.c
--- 13/arch/x86/kernel/process_64.c
--- 14/arch/x86/kernel/process_64.c
--- 15/arch/x86/kernel/process_64.c
--- 16/arch/x86/kernel/process_64.c
--- 17/arch/x86/kernel/process_64.c
--- 18/arch/x86/kernel/process_64.c
--- 19/arch/x86/kernel/process_64.c
--- 20/arch/x86/kernel/process_64.c
--- 21/arch/x86/kernel/process_64.c
+++ b/arch/x86/kernel/process_64.c
@@@@@@@@@@@@@@@@@@@@@@ -94,8 -93,7 -93,6 -93,7 -93,6 -93,6 -93,6 -93,6 -93,8 -93,7 -93,6 -93,6 -93,8 -93,6 -93,6 -93,7 -93,6 -93,8 -93,6 -93,8 -93,6 +94,8 @@@@@@@@@@@@@@@@@@@@@@ DECLARE_PER_CPU(int, cpu_state)
                     static inline void play_dead(void)
                     {
                        idle_task_exit();
 - -     -     -        wbinvd();
 +++++++ +++ ++++ + +   c1e_remove_cpu(raw_smp_processor_id());
 +++++++ +++ ++++ + +
                        mb();
                        /* Ack it */
                        __get_cpu_var(cpu_state) = CPU_DEAD;

diff --cc arch/x86/kernel/setup.c
index 9838f25,68b48e3,362d4e7,2f31cdd,9838f25,9838f25,362d4e7,a4656ad,9838f25,68b48e3,362d4e7,362d4e7,9838f25,9838f25,a4656ad,b520dae,362d4e7,9838f25,362d4e7,9838f25,a4656ad..141efab
--- 1/arch/x86/kernel/setup.c
--- 2/arch/x86/kernel/setup.c
--- 3/arch/x86/kernel/setup.c
--- 4/arch/x86/kernel/setup.c
--- 5/arch/x86/kernel/setup.c
--- 6/arch/x86/kernel/setup.c
--- 7/arch/x86/kernel/setup.c
--- 8/arch/x86/kernel/setup.c
--- 9/arch/x86/kernel/setup.c
--- 10/arch/x86/kernel/setup.c
--- 11/arch/x86/kernel/setup.c
--- 12/arch/x86/kernel/setup.c
--- 13/arch/x86/kernel/setup.c
--- 14/arch/x86/kernel/setup.c
--- 15/arch/x86/kernel/setup.c
--- 16/arch/x86/kernel/setup.c
--- 17/arch/x86/kernel/setup.c
--- 18/arch/x86/kernel/setup.c
--- 19/arch/x86/kernel/setup.c
--- 20/arch/x86/kernel/setup.c
--- 21/arch/x86/kernel/setup.c
+++ b/arch/x86/kernel/setup.c
@@@@@@@@@@@@@@@@@@@@@@ -670,18 -678,6 -670,14 -694,6 -670,18 -670,18 -670,14 -678,6 -670,18 -678,6 -670,14 -670,14 -670,18 -670,18 -678,6 -670,6 -670,14 -670,18 -670,14 -670,18 -678,6 +686,18 @@@@@@@@@@@@@@@@@@@@@@ void __init setup_arch(char **cmdline_p
                     
                        parse_early_param();
                     
 +++  ++ +++  +++ + +#ifdef CONFIG_X86_64
 +++  ++ +++  +++ + +   check_efer();
 +++  ++ +++  +++ + +#endif
 +++  ++ +++  +++ + +
 + +   + +    ++    +#if defined(CONFIG_VMI) && defined(CONFIG_X86_32)
 + +   + +    ++    +   /*
 + +   + +    ++    +    * Must be before kernel pagetables are setup
 + +   + +    ++    +    * or fixmap area is touched.
 + +   + +    ++    +    */
 + +   + +    ++    +   vmi_init();
 + +   + +    ++    +#endif
 + +   + +    ++    +
                        /* after early param, so could get panic from serial */
                        reserve_early_setup_data();
                     

diff --cc arch/x86/kernel/signal_64.c
index 4d32487,b45ef8d,162da79,b45ef8d,ca316b5,ca316b5,ca316b5,ca316b5,ca316b5,b45ef8d,ca316b5,ca316b5,ca316b5,ca316b5,ca316b5,b45ef8d,ca316b5,ca316b5,ca316b5,ca316b5,ca316b5..694aa88
--- 1/arch/x86/kernel/signal_64.c
--- 2/arch/x86/kernel/signal_64.c
--- 3/arch/x86/kernel/signal_64.c
--- 4/arch/x86/kernel/signal_64.c
--- 5/arch/x86/kernel/signal_64.c
--- 6/arch/x86/kernel/signal_64.c
--- 7/arch/x86/kernel/signal_64.c
--- 8/arch/x86/kernel/signal_64.c
--- 9/arch/x86/kernel/signal_64.c
--- 10/arch/x86/kernel/signal_64.c
--- 11/arch/x86/kernel/signal_64.c
--- 12/arch/x86/kernel/signal_64.c
--- 13/arch/x86/kernel/signal_64.c
--- 14/arch/x86/kernel/signal_64.c
--- 15/arch/x86/kernel/signal_64.c
--- 16/arch/x86/kernel/signal_64.c
--- 17/arch/x86/kernel/signal_64.c
--- 18/arch/x86/kernel/signal_64.c
--- 19/arch/x86/kernel/signal_64.c
--- 20/arch/x86/kernel/signal_64.c
--- 21/arch/x86/kernel/signal_64.c
+++ b/arch/x86/kernel/signal_64.c
@@@@@@@@@@@@@@@@@@@@@@ -357,9 -345,38 -351,38 -345,38 -354,38 -354,38 -354,38 -354,38 -354,38 -345,38 -354,38 -354,38 -354,38 -354,38 -354,38 -345,38 -354,38 -354,38 -354,38 -354,38 -354,38 +354,9 @@@@@@@@@@@@@@@@@@@@@@ give_sigsegv
                        return -EFAULT;
                     }
                     
 --------------------/*
 -------------------- * Return -1L or the syscall number that @regs is executing.
 -------------------- */
 --------------------static long current_syscall(struct pt_regs *regs)
 --------------------{
 --------------------   /*
 --------------------    * We always sign-extend a -1 value being set here,
 --------------------    * so this is always either -1L or a syscall number.
 --------------------    */
 --------------------   return regs->orig_ax;
 --------------------}
 --------------------
 --------------------/*
 -------------------- * Return a value that is -EFOO if the system call in @regs->orig_ax
 -------------------- * returned an error.  This only works for @regs from @current.
 -------------------- */
 --------------------static long current_syscall_ret(struct pt_regs *regs)
 --------------------{
 --------------------#ifdef CONFIG_IA32_EMULATION
 --------------------   if (test_thread_flag(TIF_IA32))
 --------------------           /*
 --------------------            * Sign-extend the value so (int)-EFOO becomes (long)-EFOO
 --------------------            * and will match correctly in comparisons.
 --------------------            */
 --------------------           return (int) regs->ax;
 --------------------#endif
 --------------------   return regs->ax;
 --------------------}
 --------------------
                     /*
                      * OK, we're invoking a handler
-- ------------------ */        
++ ++++++++++++++++++ */
                     
                     static int
                     handle_signal(unsigned long sig, siginfo_t *info, struct k_sigaction *ka,
@@@@@@@@@@@@@@@@@@@@@@ -427,16 -444,15 -450,15 -444,15 -453,15 -453,15 -453,15 -453,15 -453,15 -444,15 -453,15 -453,15 -453,15 -453,15 -453,15 -444,15 -453,15 -453,15 -453,15 -453,15 -453,15 +424,16 @@@@@@@@@@@@@@@@@@@@@@
                                 * handler too.
                                 */
                                regs->flags &= ~X86_EFLAGS_TF;
 --------------------           if (test_thread_flag(TIF_SINGLESTEP))
 --------------------                   ptrace_notify(SIGTRAP);
                     
                                spin_lock_irq(&current->sighand->siglock);
-- ------------------           sigorsets(&current->blocked,&current->blocked,&ka->sa.sa_mask);
++ ++++++++++++++++++           sigorsets(&current->blocked, &current->blocked, &ka->sa.sa_mask);
                                if (!(ka->sa.sa_flags & SA_NODEFER))
-- ------------------                   sigaddset(&current->blocked,sig);
++ ++++++++++++++++++                   sigaddset(&current->blocked, sig);
                                recalc_sigpending();
                                spin_unlock_irq(&current->sighand->siglock);
 ++++++++++++++++++++
 ++++++++++++++++++++           tracehook_signal_handler(sig, info, ka, regs,
 ++++++++++++++++++++                                    test_thread_flag(TIF_SINGLESTEP));
                        }
                     
                        return ret;

diff --cc arch/x86/kernel/smpboot.c
Simple merge

diff --cc arch/x86/kernel/sys_x86_64.c
index c9288c8,3b360ef,56eb8f9,3b360ef,3b360ef,3b360ef,3b360ef,3b360ef,3b360ef,3b360ef,3b360ef,3b360ef,3b360ef,3b360ef,3b360ef,3b360ef,3b360ef,3b360ef,3b360ef,3b360ef,3b360ef..6bc211a
--- 1/arch/x86/kernel/sys_x86_64.c
--- 2/arch/x86/kernel/sys_x86_64.c
--- 3/arch/x86/kernel/sys_x86_64.c
--- 4/arch/x86/kernel/sys_x86_64.c
--- 5/arch/x86/kernel/sys_x86_64.c
--- 6/arch/x86/kernel/sys_x86_64.c
--- 7/arch/x86/kernel/sys_x86_64.c
--- 8/arch/x86/kernel/sys_x86_64.c
--- 9/arch/x86/kernel/sys_x86_64.c
--- 10/arch/x86/kernel/sys_x86_64.c
--- 11/arch/x86/kernel/sys_x86_64.c
--- 12/arch/x86/kernel/sys_x86_64.c
--- 13/arch/x86/kernel/sys_x86_64.c
--- 14/arch/x86/kernel/sys_x86_64.c
--- 15/arch/x86/kernel/sys_x86_64.c
--- 16/arch/x86/kernel/sys_x86_64.c
--- 17/arch/x86/kernel/sys_x86_64.c
--- 18/arch/x86/kernel/sys_x86_64.c
--- 19/arch/x86/kernel/sys_x86_64.c
--- 20/arch/x86/kernel/sys_x86_64.c
--- 21/arch/x86/kernel/sys_x86_64.c
+++ b/arch/x86/kernel/sys_x86_64.c
@@@@@@@@@@@@@@@@@@@@@@ -13,16 -13,15 -13,16 -13,15 -13,15 -13,15 -13,15 -13,15 -13,15 -13,15 -13,15 -13,15 -13,15 -13,15 -13,15 -13,15 -13,15 -13,15 -13,15 -13,15 -13,15 +13,17 @@@@@@@@@@@@@@@@@@@@@@
                     #include <linux/utsname.h>
                     #include <linux/personality.h>
                     #include <linux/random.h>
++ ++++++++++++++++++#include <linux/uaccess.h>
                     
-- ------------------#include <asm/uaccess.h>
                     #include <asm/ia32.h>
 ++++++++++++++++++++#include <asm/syscalls.h>
                     
-- ------------------asmlinkage long sys_mmap(unsigned long addr, unsigned long len, unsigned long prot, unsigned long flags,
-- ------------------   unsigned long fd, unsigned long off)
++ ++++++++++++++++++asmlinkage long sys_mmap(unsigned long addr, unsigned long len,
++ ++++++++++++++++++           unsigned long prot, unsigned long flags,
++ ++++++++++++++++++           unsigned long fd, unsigned long off)
                     {
                        long error;
-- ------------------   struct file * file;
++ ++++++++++++++++++   struct file *file;
                     
                        error = -EINVAL;
                        if (off & ~PAGE_MASK)

diff --cc arch/x86/kernel/traps_64.c
Simple merge

diff --cc arch/x86/kernel/tsc.c
index 8f98e9d,7603c05,8f98e9d,7603c05,8f98e9d,8f98e9d,8f98e9d,46af716,8f98e9d,7603c05,8e786b0,8f98e9d,8f98e9d,8f98e9d,46af716,7603c05,46af716,8f98e9d,4847a92,8f98e9d,46af716..161bb85
--- 1/arch/x86/kernel/tsc.c
--- 2/arch/x86/kernel/tsc.c
--- 3/arch/x86/kernel/tsc.c
--- 4/arch/x86/kernel/tsc.c
--- 5/arch/x86/kernel/tsc.c
--- 6/arch/x86/kernel/tsc.c
--- 7/arch/x86/kernel/tsc.c
--- 8/arch/x86/kernel/tsc.c
--- 9/arch/x86/kernel/tsc.c
--- 10/arch/x86/kernel/tsc.c
--- 11/arch/x86/kernel/tsc.c
--- 12/arch/x86/kernel/tsc.c
--- 13/arch/x86/kernel/tsc.c
--- 14/arch/x86/kernel/tsc.c
--- 15/arch/x86/kernel/tsc.c
--- 16/arch/x86/kernel/tsc.c
--- 17/arch/x86/kernel/tsc.c
--- 18/arch/x86/kernel/tsc.c
--- 19/arch/x86/kernel/tsc.c
--- 20/arch/x86/kernel/tsc.c
--- 21/arch/x86/kernel/tsc.c
+++ b/arch/x86/kernel/tsc.c
@@@@@@@@@@@@@@@@@@@@@@ -104,7 -104,7 -104,7 -104,7 -104,7 -104,7 -104,7 -104,7 -104,7 -104,7 -104,7 -104,7 -104,7 -104,7 -104,7 -104,7 -104,7 -104,7 -104,7 -104,7 -104,7 +104,7 @@@@@@@@@@@@@@@@@@@@@@ __setup("notsc", notsc_setup)
                     /*
                      * Read TSC and the reference counters. Take care of SMI disturbance
                      */
- - ----- ----- -- --static u64 tsc_read_refs(u64 *pm, u64 *hpet)
 - -     -     -     static u64 __init tsc_read_refs(u64 *pm, u64 *hpet)
++++++++++++++++++ ++static u64 tsc_read_refs(u64 *p, int hpet)
                     {
                        u64 t1, t2;
                        int i;
@@@@@@@@@@@@@@@@@@@@@@ -122,216 -122,80 -122,216 -122,80 -122,216 -122,216 -122,216 -122,80 -122,216 -122,80 -122,80 -122,216 -122,216 -122,216 -122,80 -122,80 -122,80 -122,216 -122,391 -122,216 -122,80 +122,390 @@@@@@@@@@@@@@@@@@@@@@
                        return ULLONG_MAX;
                     }
                     
 - -   - --   ---   -/**
 - -   - --   ---   - * native_calibrate_tsc - calibrate the tsc on boot
++++++++++++++++++ ++/*
++++++++++++++++++ ++ * Calculate the TSC frequency from HPET reference
+ + +++ +  +++   + +  */
 - -   - --   ---   -unsigned long native_calibrate_tsc(void)
++++++++++++++++++ ++static unsigned long calc_hpet_ref(u64 deltatsc, u64 hpet1, u64 hpet2)
+ + +++ +  +++   + + {
 - -   - --   ---   -   unsigned long flags;
 - -   - --   ---   -   u64 tsc1, tsc2, tr1, tr2, delta, pm1, pm2, hpet1, hpet2;
 - -   - --   ---   -   int hpet = is_hpet_enabled();
 - -   - --   ---   -   unsigned int tsc_khz_val = 0;
++++++++++++++++++ ++   u64 tmp;
+ + +++ +  +++   + + 
 - -   - --   ---   -   local_irq_save(flags);
++++++++++++++++++ ++   if (hpet2 < hpet1)
++++++++++++++++++ ++           hpet2 += 0x100000000ULL;
++++++++++++++++++ ++   hpet2 -= hpet1;
++++++++++++++++++ ++   tmp = ((u64)hpet2 * hpet_readl(HPET_PERIOD));
++++++++++++++++++ ++   do_div(tmp, 1000000);
++++++++++++++++++ ++   do_div(deltatsc, tmp);
++++++++++++++++++ ++
++++++++++++++++++ ++   return (unsigned long) deltatsc;
++++++++++++++++++ ++}
++++++++++++++++++ ++
++++++++++++++++++ ++/*
++++++++++++++++++ ++ * Calculate the TSC frequency from PMTimer reference
++++++++++++++++++ ++ */
++++++++++++++++++ ++static unsigned long calc_pmtimer_ref(u64 deltatsc, u64 pm1, u64 pm2)
++++++++++++++++++ ++{
++++++++++++++++++ ++   u64 tmp;
+ + +++ + ++++   + + 
 - -   - -    ---   -   tsc1 = tsc_read_refs(&pm1, hpet ? &hpet1 : NULL);
++++++++++++++++++ ++   if (!pm1 && !pm2)
++++++++++++++++++ ++           return ULONG_MAX;
++++++++++++++++++ ++
++++++++++++++++++ ++   if (pm2 < pm1)
++++++++++++++++++ ++           pm2 += (u64)ACPI_PM_OVRRUN;
++++++++++++++++++ ++   pm2 -= pm1;
++++++++++++++++++ ++   tmp = pm2 * 1000000000LL;
++++++++++++++++++ ++   do_div(tmp, PMTMR_TICKS_PER_SEC);
++++++++++++++++++ ++   do_div(deltatsc, tmp);
++++++++++++++++++ ++
++++++++++++++++++ ++   return (unsigned long) deltatsc;
++++++++++++++++++ ++}
++++++++++++++++++ ++
++++++++++++++++++ ++#define CAL_MS             10
++++++++++++++++++ ++#define CAL_LATCH  (CLOCK_TICK_RATE / (1000 / CAL_MS))
++++++++++++++++++ ++#define CAL_PIT_LOOPS      1000
++++++++++++++++++ ++
++++++++++++++++++ ++#define CAL2_MS            50
++++++++++++++++++ ++#define CAL2_LATCH (CLOCK_TICK_RATE / (1000 / CAL2_MS))
++++++++++++++++++ ++#define CAL2_PIT_LOOPS     5000
++++++++++++++++++ ++
++++++++++++++++++ ++
 + +   + ++   +++   +/*
 + +   + ++   +++   + * Try to calibrate the TSC against the Programmable
 + +   + ++   +++   + * Interrupt Timer and return the frequency of the TSC
 + +   + ++   +++   + * in kHz.
 + +   + ++   +++   + *
 + +   + ++   +++   + * Return ULONG_MAX on failure to calibrate.
 + +   + ++   +++   + */
- - --- -  ---   - - static unsigned long pit_calibrate_tsc(void)
++++++++++++++++++ ++static unsigned long pit_calibrate_tsc(u32 latch, unsigned long ms, int loopmin)
 + +   + ++   +++   +{
 + +   + ++   +++   +   u64 tsc, t1, t2, delta;
 + +   + ++   +++   +   unsigned long tscmin, tscmax;
 + +   + ++   +++   +   int pitcnt;
          +          
 + +   + ++   +++   +   /* Set the Gate high, disable speaker */
          +             outb((inb(0x61) & ~0x02) | 0x01, 0x61);
          +          
 + +   + ++   +++   +   /*
 + +   + ++   +++   +    * Setup CTC channel 2* for mode 0, (interrupt on terminal
 + +   + ++   +++   +    * count mode), binary count. Set the latch register to 50ms
 + +   + ++   +++   +    * (LSB then MSB) to begin countdown.
 + +   + ++   +++   +    */
          +             outb(0xb0, 0x43);
---------- ------- --   outb((CLOCK_TICK_RATE / (1000 / 50)) & 0xff, 0x42);
---------- ------- --   outb((CLOCK_TICK_RATE / (1000 / 50)) >> 8, 0x42);
 - -   - -    ---   -   tr1 = get_cycles();
 - -   - -    ---   -   while ((inb(0x61) & 0x20) == 0);
 - -   - -    ---   -   tr2 = get_cycles();
++++++++++++++++++ ++   outb(latch & 0xff, 0x42);
++++++++++++++++++ ++   outb(latch >> 8, 0x42);
          +          
 - -   - -    ---   -   tsc2 = tsc_read_refs(&pm2, hpet ? &hpet2 : NULL);
 + +   + ++   +++   +   tsc = t1 = t2 = get_cycles();
 + +   + ++   +++   +
 + +   + ++   +++   +   pitcnt = 0;
 + +   + ++   +++   +   tscmax = 0;
 + +   + ++   +++   +   tscmin = ULONG_MAX;
 + +   + ++   +++   +   while ((inb(0x61) & 0x20) == 0) {
 + +   + ++   +++   +           t2 = get_cycles();
 + +   + ++   +++   +           delta = t2 - tsc;
 + +   + ++   +++   +           tsc = t2;
 + +   + ++   +++   +           if ((unsigned long) delta < tscmin)
 + +   + ++   +++   +                   tscmin = (unsigned int) delta;
 + +   + ++   +++   +           if ((unsigned long) delta > tscmax)
 + +   + ++   +++   +                   tscmax = (unsigned int) delta;
 + +   + ++   +++   +           pitcnt++;
 + +   + ++   +++   +   }
 + +   + ++   +++   +
 + +   + ++   +++   +   /*
 + +   + ++   +++   +    * Sanity checks:
 + +   + ++   +++   +    *
- - --- -  ---   - -     * If we were not able to read the PIT more than 5000
++++++++++++++++++ ++    * If we were not able to read the PIT more than loopmin
 + +   + ++   +++   +    * times, then we have been hit by a massive SMI
 + +   + ++   +++   +    *
 + +   + ++   +++   +    * If the maximum is 10 times larger than the minimum,
 + +   + ++   +++   +    * then we got hit by an SMI as well.
 + +   + ++   +++   +    */
- - --- -  ---   - -    if (pitcnt < 5000 || tscmax > 10 * tscmin)
++++++++++++++++++ ++   if (pitcnt < loopmin || tscmax > 10 * tscmin)
 + +   + ++   +++   +           return ULONG_MAX;
 + +   + ++   +++   +
 + +   + ++   +++   +   /* Calculate the PIT value */
 + +   + ++   +++   +   delta = t2 - t1;
- - --- -  ---   - -    do_div(delta, 50);
++++++++++++++++++ ++   do_div(delta, ms);
 + +   + ++   +++   +   return delta;
 + +   + ++   +++   +}
          +          
++++++++++++++++++ ++/*
++++++++++++++++++ ++ * This reads the current MSB of the PIT counter, and
++++++++++++++++++ ++ * checks if we are running on sufficiently fast and
++++++++++++++++++ ++ * non-virtualized hardware.
++++++++++++++++++ ++ *
++++++++++++++++++ ++ * Our expectations are:
++++++++++++++++++ ++ *
++++++++++++++++++ ++ *  - the PIT is running at roughly 1.19MHz
++++++++++++++++++ ++ *
++++++++++++++++++ ++ *  - each IO is going to take about 1us on real hardware,
++++++++++++++++++ ++ *    but we allow it to be much faster (by a factor of 10) or
++++++++++++++++++ ++ *    _slightly_ slower (ie we allow up to a 2us read+counter
++++++++++++++++++ ++ *    update - anything else implies a unacceptably slow CPU
++++++++++++++++++ ++ *    or PIT for the fast calibration to work.
++++++++++++++++++ ++ *
++++++++++++++++++ ++ *  - with 256 PIT ticks to read the value, we have 214us to
++++++++++++++++++ ++ *    see the same MSB (and overhead like doing a single TSC
++++++++++++++++++ ++ *    read per MSB value etc).
++++++++++++++++++ ++ *
++++++++++++++++++ ++ *  - We're doing 2 reads per loop (LSB, MSB), and we expect
++++++++++++++++++ ++ *    them each to take about a microsecond on real hardware.
++++++++++++++++++ ++ *    So we expect a count value of around 100. But we'll be
++++++++++++++++++ ++ *    generous, and accept anything over 50.
++++++++++++++++++ ++ *
++++++++++++++++++ ++ *  - if the PIT is stuck, and we see *many* more reads, we
++++++++++++++++++ ++ *    return early (and the next caller of pit_expect_msb()
++++++++++++++++++ ++ *    then consider it a failure when they don't see the
++++++++++++++++++ ++ *    next expected value).
++++++++++++++++++ ++ *
++++++++++++++++++ ++ * These expectations mean that we know that we have seen the
++++++++++++++++++ ++ * transition from one expected value to another with a fairly
++++++++++++++++++ ++ * high accuracy, and we didn't miss any events. We can thus
++++++++++++++++++ ++ * use the TSC value at the transitions to calculate a pretty
++++++++++++++++++ ++ * good value for the TSC frequencty.
++++++++++++++++++ ++ */
++++++++++++++++++ ++static inline int pit_expect_msb(unsigned char val)
++++++++++++++++++ ++{
++++++++++++++++++ ++   int count = 0;
++++++++++ +++++++ ++
          -             tsc1 = tsc_read_refs(&pm1, hpet ? &hpet1 : NULL);
++++++++++++++++++ ++   for (count = 0; count < 50000; count++) {
++++++++++++++++++ ++           /* Ignore LSB */
++++++++++++++++++ ++           inb(0x42);
++++++++++++++++++ ++           if (inb(0x42) != val)
++++++++++++++++++ ++                   break;
++++++++++++++++++ ++   }
++++++++++++++++++ ++   return count > 50;
++++++++++++++++++ ++}
++++++++++++++++++ ++
++++++++++++++++++ ++/*
++++++++++++++++++ ++ * How many MSB values do we want to see? We aim for a
++++++++++++++++++ ++ * 15ms calibration, which assuming a 2us counter read
++++++++++++++++++ ++ * error should give us roughly 150 ppm precision for
++++++++++++++++++ ++ * the calibration.
++++++++++++++++++ ++ */
++++++++++++++++++ ++#define QUICK_PIT_MS 15
++++++++++++++++++ ++#define QUICK_PIT_ITERATIONS (QUICK_PIT_MS * PIT_TICK_RATE / 1000 / 256)
++++++++++ +++++++ ++
++++++++++++++++++ ++static unsigned long quick_pit_calibrate(void)
++++++++++++++++++ ++{
++++++++++++++++++ ++   /* Set the Gate high, disable speaker */
++++++++++ +++++++ ++   outb((inb(0x61) & ~0x02) | 0x01, 0x61);
++++++++++ +++++++ ++
++++++++++++++++++ ++   /*
++++++++++++++++++ ++    * Counter 2, mode 0 (one-shot), binary count
++++++++++++++++++ ++    *
++++++++++++++++++ ++    * NOTE! Mode 2 decrements by two (and then the
++++++++++++++++++ ++    * output is flipped each time, giving the same
++++++++++++++++++ ++    * final output frequency as a decrement-by-one),
++++++++++++++++++ ++    * so mode 0 is much better when looking at the
++++++++++++++++++ ++    * individual counts.
++++++++++++++++++ ++    */
++++++++++ +++++++ ++   outb(0xb0, 0x43);
          -             outb((CLOCK_TICK_RATE / (1000 / 50)) & 0xff, 0x42);
          -             outb((CLOCK_TICK_RATE / (1000 / 50)) >> 8, 0x42);
          -             tr1 = get_cycles();
          -             while ((inb(0x61) & 0x20) == 0);
          -             tr2 = get_cycles();
++++++++++ +++++++ ++
          -             tsc2 = tsc_read_refs(&pm2, hpet ? &hpet2 : NULL);
++++++++++++++++++ ++   /* Start at 0xffff */
++++++++++++++++++ ++   outb(0xff, 0x42);
++++++++++++++++++ ++   outb(0xff, 0x42);
++++++++++++++++++ ++
++++++++++++++++++ ++   if (pit_expect_msb(0xff)) {
++++++++++++++++++ ++           int i;
++++++++++++++++++ ++           u64 t1, t2, delta;
++++++++++++++++++ ++           unsigned char expect = 0xfe;
++++++++++++++++++ ++
++++++++++++++++++ ++           t1 = get_cycles();
++++++++++++++++++ ++           for (i = 0; i < QUICK_PIT_ITERATIONS; i++, expect--) {
++++++++++++++++++ ++                   if (!pit_expect_msb(expect))
++++++++++++++++++ ++                           goto failed;
++++++++++++++++++ ++           }
++++++++++++++++++ ++           t2 = get_cycles();
++++++++++++++++++ ++
++++++++++++++++++ ++           /*
++++++++++++++++++ ++            * Make sure we can rely on the second TSC timestamp:
++++++++++++++++++ ++            */
++++++++++++++++++ ++           if (!pit_expect_msb(expect))
++++++++++++++++++ ++                   goto failed;
++++++++++++++++++ ++
++++++++++++++++++ ++           /*
++++++++++++++++++ ++            * Ok, if we get here, then we've seen the
++++++++++++++++++ ++            * MSB of the PIT decrement QUICK_PIT_ITERATIONS
++++++++++++++++++ ++            * times, and each MSB had many hits, so we never
++++++++++++++++++ ++            * had any sudden jumps.
++++++++++++++++++ ++            *
++++++++++++++++++ ++            * As a result, we can depend on there not being
++++++++++++++++++ ++            * any odd delays anywhere, and the TSC reads are
++++++++++++++++++ ++            * reliable.
++++++++++++++++++ ++            *
++++++++++++++++++ ++            * kHz = ticks / time-in-seconds / 1000;
++++++++++++++++++ ++            * kHz = (t2 - t1) / (QPI * 256 / PIT_TICK_RATE) / 1000
++++++++++++++++++ ++            * kHz = ((t2 - t1) * PIT_TICK_RATE) / (QPI * 256 * 1000)
++++++++++++++++++ ++            */
++++++++++++++++++ ++           delta = (t2 - t1)*PIT_TICK_RATE;
++++++++++++++++++ ++           do_div(delta, QUICK_PIT_ITERATIONS*256*1000);
++++++++++++++++++ ++           printk("Fast TSC calibration using PIT\n");
++++++++++++++++++ ++           return delta;
++++++++++++++++++ ++   }
++++++++++++++++++ ++failed:
++++++++++++++++++ ++   return 0;
++++++++++++++++++ ++}
 + +   + +    +++   +
 + +   + ++   +++   +/**
 + +   + ++   +++   + * native_calibrate_tsc - calibrate the tsc on boot
 + +   + ++   +++   + */
 + +   + ++   +++   +unsigned long native_calibrate_tsc(void)
 + +   + ++   +++   +{
- - --- -  ---   - -    u64 tsc1, tsc2, delta, pm1, pm2, hpet1, hpet2;
++++++++++++++++++ ++   u64 tsc1, tsc2, delta, ref1, ref2;
 + +   + ++   +++   +   unsigned long tsc_pit_min = ULONG_MAX, tsc_ref_min = ULONG_MAX;
- - --- -  ---   - -    unsigned long flags;
- - --- -  ---   - -    int hpet = is_hpet_enabled(), i;
++++++++++++++++++ ++   unsigned long flags, latch, ms, fast_calibrate;
++++++++++++++++++ ++   int hpet = is_hpet_enabled(), i, loopmin;
++++++++++++++++++ ++
++++++++++++++++++ ++   local_irq_save(flags);
++++++++++++++++++ ++   fast_calibrate = quick_pit_calibrate();
+ + +++ +  +++   + +    local_irq_restore(flags);
++++++++++++++++++ ++   if (fast_calibrate)
++++++++++++++++++ ++           return fast_calibrate;
                     
                        /*
 - -   - --   ---   -    * Preset the result with the raw and inaccurate PIT
 - -   - --   ---   -    * calibration value
 + +   + ++   +++   +    * Run 5 calibration loops to get the lowest frequency value
 + +   + ++   +++   +    * (the best estimate). We use two different calibration modes
 + +   + ++   +++   +    * here:
 + +   + ++   +++   +    *
 + +   + ++   +++   +    * 1) PIT loop. We set the PIT Channel 2 to oneshot mode and
 + +   + ++   +++   +    * load a timeout of 50ms. We read the time right after we
 + +   + ++   +++   +    * started the timer and wait until the PIT count down reaches
 + +   + ++   +++   +    * zero. In each wait loop iteration we read the TSC and check
 + +   + ++   +++   +    * the delta to the previous read. We keep track of the min
 + +   + ++   +++   +    * and max values of that delta. The delta is mostly defined
 + +   + ++   +++   +    * by the IO time of the PIT access, so we can detect when a
 + +   + ++   +++   +    * SMI/SMM disturbance happend between the two reads. If the
 + +   + ++   +++   +    * maximum time is significantly larger than the minimum time,
 + +   + ++   +++   +    * then we discard the result and have another try.
 + +   + ++   +++   +    *
 + +   + ++   +++   +    * 2) Reference counter. If available we use the HPET or the
 + +   + ++   +++   +    * PMTIMER as a reference to check the sanity of that value.
 + +   + ++   +++   +    * We use separate TSC readouts and check inside of the
 + +   + ++   +++   +    * reference read for a SMI/SMM disturbance. We dicard
 + +   + ++   +++   +    * disturbed values here as well. We do that around the PIT
 + +   + ++   +++   +    * calibration delay loop as we have to wait for a certain
 + +   + ++   +++   +    * amount of time anyway.
                         */
- - --- -  ---   - -    for (i = 0; i < 5; i++) {
 - -   - --   ---   -   delta = (tr2 - tr1);
 - -   - --   ---   -   do_div(delta, 50);
 - -   - --   ---   -   tsc_khz_val = delta;
 - -   - --   ---   -
 - -   - --   ---   -   /* hpet or pmtimer available ? */
 - -   - --   ---   -   if (!hpet && !pm1 && !pm2) {
 - -   - --   ---   -           printk(KERN_INFO "TSC calibrated against PIT\n");
 - -   - --   ---   -           goto out;
++++++++++++++++++ ++
++++++++++++++++++ ++   /* Preset PIT loop values */
++++++++++++++++++ ++   latch = CAL_LATCH;
++++++++++++++++++ ++   ms = CAL_MS;
++++++++++++++++++ ++   loopmin = CAL_PIT_LOOPS;
++++++++++++++++++ ++
++++++++++++++++++ ++   for (i = 0; i < 3; i++) {
 + +   + ++   +++   +           unsigned long tsc_pit_khz;
 + +   + ++   +++   +
 + +   + ++   +++   +           /*
 + +   + ++   +++   +            * Read the start value and the reference count of
 + +   + ++   +++   +            * hpet/pmtimer when available. Then do the PIT
 + +   + ++   +++   +            * calibration, which will take at least 50ms, and
 + +   + ++   +++   +            * read the end value.
 + +   + ++   +++   +            */
 + +   + ++   +++   +           local_irq_save(flags);
- - --- -  ---   - -            tsc1 = tsc_read_refs(&pm1, hpet ? &hpet1 : NULL);
- - --- -  ---   - -            tsc_pit_khz = pit_calibrate_tsc();
- - --- -  ---   - -            tsc2 = tsc_read_refs(&pm2, hpet ? &hpet2 : NULL);
++++++++++++++++++ ++           tsc1 = tsc_read_refs(&ref1, hpet);
++++++++++++++++++ ++           tsc_pit_khz = pit_calibrate_tsc(latch, ms, loopmin);
++++++++++++++++++ ++           tsc2 = tsc_read_refs(&ref2, hpet);
 + +   + ++   +++   +           local_irq_restore(flags);
 + +   + ++   +++   +
 + +   + ++   +++   +           /* Pick the lowest PIT TSC calibration so far */
 + +   + ++   +++   +           tsc_pit_min = min(tsc_pit_min, tsc_pit_khz);
 + +   + ++   +++   +
 + +   + ++   +++   +           /* hpet or pmtimer available ? */
- - --- -  ---   - -            if (!hpet && !pm1 && !pm2)
++++++++++++++++++ ++           if (!hpet && !ref1 && !ref2)
 + +   + ++   +++   +                   continue;
 + +   + ++   +++   +
 + +   + ++   +++   +           /* Check, whether the sampling was disturbed by an SMI */
 + +   + ++   +++   +           if (tsc1 == ULLONG_MAX || tsc2 == ULLONG_MAX)
 + +   + ++   +++   +                   continue;
 + +   + ++   +++   +
 + +   + ++   +++   +           tsc2 = (tsc2 - tsc1) * 1000000LL;
++++++++++++++++++ ++           if (hpet)
++++++++++++++++++ ++                   tsc2 = calc_hpet_ref(tsc2, ref1, ref2);
++++++++++++++++++ ++           else
++++++++++++++++++ ++                   tsc2 = calc_pmtimer_ref(tsc2, ref1, ref2);
 + +   + ++   +++   +
- - --- -  ---   - -            if (hpet) {
- - --- -  ---   - -                    if (hpet2 < hpet1)
- - --- -  ---   - -                            hpet2 += 0x100000000ULL;
- - --- -  ---   - -                    hpet2 -= hpet1;
- - --- -  ---   - -                    tsc1 = ((u64)hpet2 * hpet_readl(HPET_PERIOD));
- - --- -  ---   - -                    do_div(tsc1, 1000000);
- - --- -  ---   - -            } else {
- - --- -  ---   - -                    if (pm2 < pm1)
- - --- -  ---   - -                            pm2 += (u64)ACPI_PM_OVRRUN;
- - --- -  ---   - -                    pm2 -= pm1;
- - --- -  ---   - -                    tsc1 = pm2 * 1000000000LL;
- - --- -  ---   - -                    do_div(tsc1, PMTMR_TICKS_PER_SEC);
++++++++++++++++++ ++           tsc_ref_min = min(tsc_ref_min, (unsigned long) tsc2);
++++++++++++++++++ ++
++++++++++++++++++ ++           /* Check the reference deviation */
++++++++++++++++++ ++           delta = ((u64) tsc_pit_min) * 100;
++++++++++++++++++ ++           do_div(delta, tsc_ref_min);
++++++++++++++++++ ++
++++++++++++++++++ ++           /*
++++++++++++++++++ ++            * If both calibration results are inside a 10% window
++++++++++++++++++ ++            * then we can be sure, that the calibration
++++++++++++++++++ ++            * succeeded. We break out of the loop right away. We
++++++++++++++++++ ++            * use the reference value, as it is more precise.
++++++++++++++++++ ++            */
++++++++++++++++++ ++           if (delta >= 90 && delta <= 110) {
++++++++++++++++++ ++                   printk(KERN_INFO
++++++++++++++++++ ++                          "TSC: PIT calibration matches %s. %d loops\n",
++++++++++++++++++ ++                          hpet ? "HPET" : "PMTIMER", i + 1);
++++++++++++++++++ ++                   return tsc_ref_min;
 + +   + ++   +++   +           }
 + +   + ++   +++   +
- - --- -  ---   - -            do_div(tsc2, tsc1);
- - --- -  ---   - -            tsc_ref_min = min(tsc_ref_min, (unsigned long) tsc2);
++++++++++++++++++ ++           /*
++++++++++++++++++ ++            * Check whether PIT failed more than once. This
++++++++++++++++++ ++            * happens in virtualized environments. We need to
++++++++++++++++++ ++            * give the virtual PC a slightly longer timeframe for
++++++++++++++++++ ++            * the HPET/PMTIMER to make the result precise.
++++++++++++++++++ ++            */
++++++++++++++++++ ++           if (i == 1 && tsc_pit_min == ULONG_MAX) {
++++++++++++++++++ ++                   latch = CAL2_LATCH;
++++++++++++++++++ ++                   ms = CAL2_MS;
++++++++++++++++++ ++                   loopmin = CAL2_PIT_LOOPS;
++++++++++++++++++ ++           }
                        }
                     
 - -   - --   ---   -   /* Check, whether the sampling was disturbed by an SMI */
 - -   - --   ---   -   if (tsc1 == ULLONG_MAX || tsc2 == ULLONG_MAX) {
 - -   - --   ---   -           printk(KERN_WARNING "TSC calibration disturbed by SMI, "
 - -   - --   ---   -                           "using PIT calibration result\n");
 - -   - --   ---   -           goto out;
 + +   + ++   +++   +   /*
 + +   + ++   +++   +    * Now check the results.
 + +   + ++   +++   +    */
 + +   + ++   +++   +   if (tsc_pit_min == ULONG_MAX) {
 + +   + ++   +++   +           /* PIT gave no useful value */
                  -             printk(KERN_WARNING "TSC: PIT calibration failed due to "
                  -                    "SMI disturbance.\n");
 + +   + ++   +++ + +           printk(KERN_WARNING "TSC: Unable to calibrate against PIT\n");
 + +   + ++   +++   +
 + +   + ++   +++   +           /* We don't have an alternative source, disable TSC */
- - --- -  ---   - -            if (!hpet && !pm1 && !pm2) {
++++++++++++++++++ ++           if (!hpet && !ref1 && !ref2) {
 + +   + ++   +++   +                   printk("TSC: No reference (HPET/PMTIMER) available\n");
 + +   + ++   +++   +                   return 0;
 + +   + ++   +++   +           }
 + +   + ++   +++   +
 + +   + ++   +++   +           /* The alternative source failed as well, disable TSC */
 + +   + ++   +++   +           if (tsc_ref_min == ULONG_MAX) {
 + +   + ++   +++   +                   printk(KERN_WARNING "TSC: HPET/PMTIMER calibration "
- - --- -  ---   - -                           "failed due to SMI disturbance.\n");
++++++++++++++++++ ++                          "failed.\n");
 + +   + ++   +++   +                   return 0;
 + +   + ++   +++   +           }
 + +   + ++   +++   +
 + +   + ++   +++   +           /* Use the alternative source */
 + +   + ++   +++   +           printk(KERN_INFO "TSC: using %s reference calibration\n",
 + +   + ++   +++   +                  hpet ? "HPET" : "PMTIMER");
 + +   + ++   +++   +
 + +   + ++   +++   +           return tsc_ref_min;
                        }
                     
 - -   - --   ---   -   tsc2 = (tsc2 - tsc1) * 1000000LL;
 - -   - --   ---   -
 - -   - --   ---   -   if (hpet) {
 - -   - --   ---   -           printk(KERN_INFO "TSC calibrated against HPET\n");
 - -   - --   ---   -           if (hpet2 < hpet1)
 - -   - --   ---   -                   hpet2 += 0x100000000ULL;
 - -   - --   ---   -           hpet2 -= hpet1;
 - -   - --   ---   -           tsc1 = ((u64)hpet2 * hpet_readl(HPET_PERIOD));
 - -   - --   ---   -           do_div(tsc1, 1000000);
 - -   - --   ---   -   } else {
 - -   - --   ---   -           printk(KERN_INFO "TSC calibrated against PM_TIMER\n");
 - -   - --   ---   -           if (pm2 < pm1)
 - -   - --   ---   -                   pm2 += (u64)ACPI_PM_OVRRUN;
 - -   - --   ---   -           pm2 -= pm1;
 - -   - --   ---   -           tsc1 = pm2 * 1000000000LL;
 - -   - --   ---   -           do_div(tsc1, PMTMR_TICKS_PER_SEC);
 + +   + ++   +++   +   /* We don't have an alternative source, use the PIT calibration value */
- - --- -  ---   - -    if (!hpet && !pm1 && !pm2) {
++++++++++++++++++ ++   if (!hpet && !ref1 && !ref2) {
 + +   + ++   +++   +           printk(KERN_INFO "TSC: Using PIT calibration value\n");
 + +   + ++   +++   +           return tsc_pit_min;
                        }
                     
 - -   - --   ---   -   do_div(tsc2, tsc1);
 - -   - --   ---   -   tsc_khz_val = tsc2;
 + +   + ++   +++   +   /* The alternative source failed, use the PIT calibration value */
 + +   + ++   +++   +   if (tsc_ref_min == ULONG_MAX) {
- - --- -  ---   - -            printk(KERN_WARNING "TSC: HPET/PMTIMER calibration failed due "
- - --- -  ---   - -                   "to SMI disturbance. Using PIT calibration\n");
++++++++++++++++++ ++           printk(KERN_WARNING "TSC: HPET/PMTIMER calibration failed. "
++++++++++++++++++ ++                  "Using PIT calibration\n");
 + +   + ++   +++   +           return tsc_pit_min;
 + +   + ++   +++   +   }
                     
- - --- -  ---   - -    /* Check the reference deviation */
- - --- -  ---   - -    delta = ((u64) tsc_pit_min) * 100;
- - --- -  ---   - -    do_div(delta, tsc_ref_min);
- - --- -  ---   - - 
- - --- -  ---   - -    /*
- - --- -  ---   - -     * If both calibration results are inside a 5% window, the we
- - --- -  ---   - -     * use the lower frequency of those as it is probably the
- - --- -  ---   - -     * closest estimate.
- - --- -  ---   - -     */
- - --- -  ---   - -    if (delta >= 95 && delta <= 105) {
- - --- -  ---   - -            printk(KERN_INFO "TSC: PIT calibration confirmed by %s.\n",
- - --- -  ---   - -                   hpet ? "HPET" : "PMTIMER");
- - --- -  ---   - -            printk(KERN_INFO "TSC: using %s calibration value\n",
- - --- -  ---   - -                   tsc_pit_min <= tsc_ref_min ? "PIT" :
- - --- -  ---   - -                   hpet ? "HPET" : "PMTIMER");
- - --- -  ---   - -            return tsc_pit_min <= tsc_ref_min ? tsc_pit_min : tsc_ref_min;
- - --- -  ---   - -    }
- - --- -  ---   - - 
- - --- -  ---   - -    printk(KERN_WARNING "TSC: PIT calibration deviates from %s: %lu %lu.\n",
- - --- -  ---   - -           hpet ? "HPET" : "PMTIMER", tsc_pit_min, tsc_ref_min);
- - --- -  ---   - - 
 - -   - --   ---   -out:
 - -   - --   ---   -   return tsc_khz_val;
 + +   + ++   +++   +   /*
 + +   + ++   +++   +    * The calibration values differ too much. In doubt, we use
 + +   + ++   +++   +    * the PIT value as we know that there are PMTIMERs around
- - --- -  ---   - -     * running at double speed.
++++++++++++++++++ ++    * running at double speed. At least we let the user know:
 + +   + ++   +++   +    */
++++++++++++++++++ ++   printk(KERN_WARNING "TSC: PIT calibration deviates from %s: %lu %lu.\n",
++++++++++++++++++ ++          hpet ? "HPET" : "PMTIMER", tsc_pit_min, tsc_ref_min);
 + +   + ++   +++   +   printk(KERN_INFO "TSC: Using PIT calibration value\n");
 + +   + ++   +++   +   return tsc_pit_min;
                     }
                     
 - -   - --   ---   -
                     #ifdef CONFIG_X86_32
                     /* Only called from the Powernow K7 cpu freq driver */
                     int recalibrate_cpu_khz(void)

diff --cc arch/x86/kernel/vmi_32.c
Simple merge

diff --cc arch/x86/mm/pageattr.c
Simple merge

diff --cc arch/x86/xen/enlighten.c
Simple merge

diff --cc include/asm-x86/apic.h
Simple merge

diff --cc include/asm-x86/asm.h
Simple merge

diff --cc include/asm-x86/elf.h
Simple merge

diff --cc include/asm-x86/futex.h
Simple merge

diff --cc include/asm-x86/gart.h
Simple merge

diff --cc include/asm-x86/mach-rdc321x/gpio.h
index 6184561,acce0b7,acce0b7,acce0b7,acce0b7,3639ece,acce0b7,acce0b7,acce0b7,acce0b7,acce0b7,acce0b7,acce0b7,acce0b7,acce0b7,acce0b7,acce0b7,acce0b7,acce0b7,acce0b7,acce0b7..94b6cdf
--- 1/include/asm-x86/mach-rdc321x/gpio.h
--- 2/include/asm-x86/mach-rdc321x/gpio.h
--- 3/include/asm-x86/mach-rdc321x/gpio.h
--- 4/include/asm-x86/mach-rdc321x/gpio.h
--- 5/include/asm-x86/mach-rdc321x/gpio.h
--- 6/include/asm-x86/mach-rdc321x/gpio.h
--- 7/include/asm-x86/mach-rdc321x/gpio.h
--- 8/include/asm-x86/mach-rdc321x/gpio.h
--- 9/include/asm-x86/mach-rdc321x/gpio.h
--- 10/include/asm-x86/mach-rdc321x/gpio.h
--- 11/include/asm-x86/mach-rdc321x/gpio.h
--- 12/include/asm-x86/mach-rdc321x/gpio.h
--- 13/include/asm-x86/mach-rdc321x/gpio.h
--- 14/include/asm-x86/mach-rdc321x/gpio.h
--- 15/include/asm-x86/mach-rdc321x/gpio.h
--- 16/include/asm-x86/mach-rdc321x/gpio.h
--- 17/include/asm-x86/mach-rdc321x/gpio.h
--- 18/include/asm-x86/mach-rdc321x/gpio.h
--- 19/include/asm-x86/mach-rdc321x/gpio.h
--- 20/include/asm-x86/mach-rdc321x/gpio.h
--- 21/include/asm-x86/mach-rdc321x/gpio.h
+++ b/include/asm-x86/mach-rdc321x/gpio.h
@@@@@@@@@@@@@@@@@@@@@@ -1,6 -1,6 -1,6 -1,6 -1,6 -1,8 -1,6 -1,6 -1,6 -1,6 -1,6 -1,6 -1,6 -1,6 -1,6 -1,6 -1,6 -1,6 -1,6 -1,6 -1,6 +1,8 @@@@@@@@@@@@@@@@@@@@@@
 --------------------#ifndef _RDC321X_GPIO_H
 --------------------#define _RDC321X_GPIO_H
 ++++++++++++++++++++#ifndef ASM_X86__MACH_RDC321X__GPIO_H
 ++++++++++++++++++++#define ASM_X86__MACH_RDC321X__GPIO_H
 ++++ +++++++++++++++
+++++ +++++++++++++++#include <linux/kernel.h>
+                    
                     extern int rdc_gpio_get_value(unsigned gpio);
                     extern void rdc_gpio_set_value(unsigned gpio, int value);
                     extern int rdc_gpio_direction_input(unsigned gpio);

diff --cc include/asm-x86/mmu.h
Simple merge

diff --cc include/asm-x86/msr.h
index eee83f7,ca110ee,2362cfd,ca110ee,2362cfd,771bcb2,2362cfd,ca110ee,2362cfd,ca110ee,ca110ee,2362cfd,2362cfd,2362cfd,ca110ee,ca110ee,ca110ee,2362cfd,2362cfd,2362cfd,ca110ee..530af1f
--- 1/include/asm-x86/msr.h
--- 2/include/asm-x86/msr.h
--- 3/include/asm-x86/msr.h
--- 4/include/asm-x86/msr.h
--- 5/include/asm-x86/msr.h
--- 6/include/asm-x86/msr.h
--- 7/include/asm-x86/msr.h
--- 8/include/asm-x86/msr.h
--- 9/include/asm-x86/msr.h
--- 10/include/asm-x86/msr.h
--- 11/include/asm-x86/msr.h
--- 12/include/asm-x86/msr.h
--- 13/include/asm-x86/msr.h
--- 14/include/asm-x86/msr.h
--- 15/include/asm-x86/msr.h
--- 16/include/asm-x86/msr.h
--- 17/include/asm-x86/msr.h
--- 18/include/asm-x86/msr.h
--- 19/include/asm-x86/msr.h
--- 20/include/asm-x86/msr.h
--- 21/include/asm-x86/msr.h
+++ b/include/asm-x86/msr.h
@@@@@@@@@@@@@@@@@@@@@@ -52,17 -52,17 -52,17 -52,17 -52,17 -52,33 -52,17 -52,17 -52,17 -52,17 -52,17 -52,17 -52,17 -52,17 -52,17 -52,17 -52,17 -52,17 -52,17 -52,17 -52,17 +52,33 @@@@@@@@@@@@@@@@@@@@@@ static inline unsigned long long native
                     {
                        DECLARE_ARGS(val, low, high);
                     
 - -   - --   ---   -                : "c" (msr), "i" (-EFAULT));
 + +   + ++   +++   +   asm volatile("2: rdmsr ; xor %[err],%[err]\n"
 + +   + ++   +++   +                "1:\n\t"
 + +   + ++   +++   +                ".section .fixup,\"ax\"\n\t"
 + +   + ++   +++   +                "3:  mov %[fault],%[err] ; jmp 1b\n\t"
 + +   + ++   +++   +                ".previous\n\t"
 + +   + ++   +++   +                _ASM_EXTABLE(2b, 3b)
 + +   + ++   +++   +                : [err] "=r" (*err), EAX_EDX_RET(val, low, high)
 + +   + ++   +++   +                : "c" (msr), [fault] "i" (-EFAULT));
 + +   + ++   +++   +   return EAX_EDX_VAL(val, low, high);
 + +   + ++   +++   +}
 + +   + ++   +++   +
+++++ +++++++++++++++static inline unsigned long long native_read_msr_amd_safe(unsigned int msr,
+++++ +++++++++++++++                                                 int *err)
+++++ +++++++++++++++{
+++++ +++++++++++++++   DECLARE_ARGS(val, low, high);
+++++ +++++++++++++++
+ + + + +  +++   +++    asm volatile("2: rdmsr ; xor %0,%0\n"
+ + + + +  +++   +++                 "1:\n\t"
+ + + + +  +++   +++                 ".section .fixup,\"ax\"\n\t"
+ + + + +  +++   +++                 "3:  mov %3,%0 ; jmp 1b\n\t"
+ + + + +  +++   +++                 ".previous\n\t"
+ + + + +  +++   +++                 _ASM_EXTABLE(2b, 3b)
+ + + + +  +++   +++                 : "=r" (*err), EAX_EDX_RET(val, low, high)
+++++ +++++++++++++++                : "c" (msr), "D" (0x9c5a203a), "i" (-EFAULT));
+ + + + +  +++   +++    return EAX_EDX_VAL(val, low, high);
+ + + + +  +++   +++ }
+ + + + +  +++   +++ 
                     static inline void native_write_msr(unsigned int msr,
                                                    unsigned low, unsigned high)
                     {

diff --cc include/asm-x86/nmi.h
Simple merge

diff --cc include/asm-x86/page_32.h
Simple merge

diff --cc include/asm-x86/paravirt.h
Simple merge

diff --cc include/asm-x86/pgtable-2level.h
Simple merge

diff --cc include/asm-x86/pgtable-3level.h
Simple merge

diff --cc include/asm-x86/pgtable.h
Simple merge

diff --cc include/asm-x86/pgtable_32.h
Simple merge

diff --cc include/asm-x86/pgtable_64.h
Simple merge

diff --cc include/asm-x86/resume-trace.h
Simple merge

diff --cc include/asm-x86/spinlock.h
Simple merge