tree f169eb1702e7e1369fa6d25bcec2b79359bad94a
parent bf70030dc0b031f000c74721f2e9c88686b7da6d
parent d0ed0c32662e756e7daf85e70a5a27a9c1111331
author Linus Torvalds <torvalds@linux-foundation.org> 1287692432 -0700
committer Linus Torvalds <torvalds@linux-foundation.org> 1287692432 -0700

Merge branch 'x86-debug-for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/tip/linux-2.6-tip

* 'x86-debug-for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/tip/linux-2.6-tip:
  x86: Remove pr_<level> uses of KERN_<level>
  therm_throt.c: Trivial printk message fix for a unsuitable abbreviation of 'thermal'
  x86: Use {push,pop}{l,q}_cfi in more places
  i386: Add unwind directives to syscall ptregs stubs
  x86-64: Use symbolics instead of raw numbers in entry_64.S
  x86-64: Adjust frame type at paranoid_exit:
  x86-64: Fix unwind annotations in syscall stubs
