278 files changed, 18033 insertions, 9400 deletions

diff --git a/Documentation/RCU/RTFP.txt b/Documentation/RCU/RTFP.txt
index 9f711d2df91b..d2b85237c76e 100644
--- a/Documentation/RCU/RTFP.txt
+++ b/Documentation/RCU/RTFP.txt
@@ -743,3 +743,80 @@ Revised:
         RCU, realtime RCU, sleepable RCU, performance.
 "
 }
+
+@article{PaulEMcKenney2008RCUOSR
+,author="Paul E. McKenney and Jonathan Walpole"
+,title="Introducing technology into the {Linux} kernel: a case study"
+,Year="2008"
+,journal="SIGOPS Oper. Syst. Rev."
+,volume="42"
+,number="5"
+,pages="4--17"
+,issn="0163-5980"
+,doi={http://doi.acm.org/10.1145/1400097.1400099}
+,publisher="ACM"
+,address="New York, NY, USA"
+,annotation={
+        Linux changed RCU to a far greater degree than RCU has changed Linux.
+}
+}
+
+@unpublished{PaulEMcKenney2008HierarchicalRCU
+,Author="Paul E. McKenney"
+,Title="Hierarchical {RCU}"
+,month="November"
+,day="3"
+,year="2008"
+,note="Available:
+\url{http://lwn.net/Articles/305782/}
+[Viewed November 6, 2008]"
+,annotation="
+        RCU with combining-tree-based grace-period detection,
+        permitting it to handle thousands of CPUs.
+"
+}
+
+@conference{PaulEMcKenney2009MaliciousURCU
+,Author="Paul E. McKenney"
+,Title="Using a Malicious User-Level {RCU} to Torture {RCU}-Based Algorithms"
+,Booktitle="linux.conf.au 2009"
+,month="January"
+,year="2009"
+,address="Hobart, Australia"
+,note="Available:
+\url{http://www.rdrop.com/users/paulmck/RCU/urcutorture.2009.01.22a.pdf}
+[Viewed February 2, 2009]"
+,annotation="
+        Realtime RCU and torture-testing RCU uses.
+"
+}
+
+@unpublished{MathieuDesnoyers2009URCU
+,Author="Mathieu Desnoyers"
+,Title="[{RFC} git tree] Userspace {RCU} (urcu) for {Linux}"
+,month="February"
+,day="5"
+,year="2009"
+,note="Available:
+\url{http://lkml.org/lkml/2009/2/5/572}
+\url{git://lttng.org/userspace-rcu.git}
+[Viewed February 20, 2009]"
+,annotation="
+        Mathieu Desnoyers's user-space RCU implementation.
+        git://lttng.org/userspace-rcu.git
+"
+}
+
+@unpublished{PaulEMcKenney2009BloatWatchRCU
+,Author="Paul E. McKenney"
+,Title="{RCU}: The {Bloatwatch} Edition"
+,month="March"
+,day="17"
+,year="2009"
+,note="Available:
+\url{http://lwn.net/Articles/323929/}
+[Viewed March 20, 2009]"
+,annotation="
+        Uniprocessor assumptions allow simplified RCU implementation.
+"
+}
diff --git a/Documentation/RCU/UP.txt b/Documentation/RCU/UP.txt
index aab4a9ec3931..90ec5341ee98 100644
--- a/Documentation/RCU/UP.txt
+++ b/Documentation/RCU/UP.txt
@@ -2,14 +2,13 @@ RCU on Uniprocessor Systems
 
 
 A common misconception is that, on UP systems, the call_rcu() primitive
-may immediately invoke its function, and that the synchronize_rcu()
-primitive may return immediately.  The basis of this misconception
+may immediately invoke its function.  The basis of this misconception
 is that since there is only one CPU, it should not be necessary to
 wait for anything else to get done, since there are no other CPUs for
 anything else to be happening on.  Although this approach will -sort- -of-
 work a surprising amount of the time, it is a very bad idea in general.
-This document presents three examples that demonstrate exactly how bad an
-idea this is.
+This document presents three examples that demonstrate exactly how bad
+an idea this is.
 
 
 Example 1: softirq Suicide
@@ -82,11 +81,18 @@ Quick Quiz #2: What locking restriction must RCU callbacks respect?
 
 Summary
 
-Permitting call_rcu() to immediately invoke its arguments or permitting
-synchronize_rcu() to immediately return breaks RCU, even on a UP system.
-So do not do it!  Even on a UP system, the RCU infrastructure -must-
-respect grace periods, and -must- invoke callbacks from a known environment
-in which no locks are held.
+Permitting call_rcu() to immediately invoke its arguments breaks RCU,
+even on a UP system.  So do not do it!  Even on a UP system, the RCU
+infrastructure -must- respect grace periods, and -must- invoke callbacks
+from a known environment in which no locks are held.
+
+It -is- safe for synchronize_sched() and synchronize_rcu_bh() to return
+immediately on an UP system.  It is also safe for synchronize_rcu()
+to return immediately on UP systems, except when running preemptable
+RCU.
+
+Quick Quiz #3: Why can't synchronize_rcu() return immediately on
+        UP systems running preemptable RCU?
 
 
 Answer to Quick Quiz #1:
@@ -117,3 +123,13 @@ Answer to Quick Quiz #2:
         callbacks acquire locks directly.  However, a great many RCU
         callbacks do acquire locks -indirectly-, for example, via
         the kfree() primitive.
+
+Answer to Quick Quiz #3:
+        Why can't synchronize_rcu() return immediately on UP systems
+        running preemptable RCU?
+
+        Because some other task might have been preempted in the middle
+        of an RCU read-side critical section.  If synchronize_rcu()
+        simply immediately returned, it would prematurely signal the
+        end of the grace period, which would come as a nasty shock to
+        that other thread when it started running again.
diff --git a/Documentation/RCU/checklist.txt b/Documentation/RCU/checklist.txt
index accfe2f5247d..51525a30e8b4 100644
--- a/Documentation/RCU/checklist.txt
+++ b/Documentation/RCU/checklist.txt
@@ -11,7 +11,10 @@ over a rather long period of time, but improvements are always welcome!
         structure is updated more than about 10% of the time, then
         you should strongly consider some other approach, unless
         detailed performance measurements show that RCU is nonetheless
-        the right tool for the job.
+        the right tool for the job.  Yes, you might think of RCU
+        as simply cutting overhead off of the readers and imposing it
+        on the writers.  That is exactly why normal uses of RCU will
+        do much more reading than updating.
 
         Another exception is where performance is not an issue, and RCU
         provides a simpler implementation.  An example of this situation
@@ -240,10 +243,11 @@ over a rather long period of time, but improvements are always welcome!
         instead need to use synchronize_irq() or synchronize_sched().
 
 12.     Any lock acquired by an RCU callback must be acquired elsewhere
-        with irq disabled, e.g., via spin_lock_irqsave().  Failing to
-        disable irq on a given acquisition of that lock will result in
-        deadlock as soon as the RCU callback happens to interrupt that
-        acquisition's critical section.
+        with softirq disabled, e.g., via spin_lock_irqsave(),
+        spin_lock_bh(), etc.  Failing to disable irq on a given
+        acquisition of that lock will result in deadlock as soon as the
+        RCU callback happens to interrupt that acquisition's critical
+        section.
 
 13.     RCU callbacks can be and are executed in parallel.  In many cases,
         the callback code simply wrappers around kfree(), so that this
@@ -310,3 +314,9 @@ over a rather long period of time, but improvements are always welcome!
         Because these primitives only wait for pre-existing readers,
         it is the caller's responsibility to guarantee safety to
         any subsequent readers.
+
+16.     The various RCU read-side primitives do -not- contain memory
+        barriers.  The CPU (and in some cases, the compiler) is free
+        to reorder code into and out of RCU read-side critical sections.
+        It is the responsibility of the RCU update-side primitives to
+        deal with this.
diff --git a/Documentation/RCU/rcu.txt b/Documentation/RCU/rcu.txt
index 7aa2002ade77..2a23523ce471 100644
--- a/Documentation/RCU/rcu.txt
+++ b/Documentation/RCU/rcu.txt
@@ -36,7 +36,7 @@ o	How can the updater tell when a grace period has completed
         executed in user mode, or executed in the idle loop, we can
         safely free up that item.
 
-        Preemptible variants of RCU (CONFIG_PREEMPT_RCU) get the
+        Preemptible variants of RCU (CONFIG_TREE_PREEMPT_RCU) get the
         same effect, but require that the readers manipulate CPU-local
         counters.  These counters allow limited types of blocking
         within RCU read-side critical sections.  SRCU also uses
@@ -79,10 +79,10 @@ o	I hear that RCU is patented?  What is with that?
 o       I hear that RCU needs work in order to support realtime kernels?
 
         This work is largely completed.  Realtime-friendly RCU can be
-        enabled via the CONFIG_PREEMPT_RCU kernel configuration parameter.
-        However, work is in progress for enabling priority boosting of
-        preempted RCU read-side critical sections.  This is needed if you
-        have CPU-bound realtime threads.
+        enabled via the CONFIG_TREE_PREEMPT_RCU kernel configuration
+        parameter.  However, work is in progress for enabling priority
+        boosting of preempted RCU read-side critical sections.  This is
+        needed if you have CPU-bound realtime threads.
 
 o       Where can I find more information on RCU?
 
diff --git a/Documentation/RCU/rcubarrier.txt b/Documentation/RCU/rcubarrier.txt
index 909602d409bb..e439a0edee22 100644
--- a/Documentation/RCU/rcubarrier.txt
+++ b/Documentation/RCU/rcubarrier.txt
@@ -170,6 +170,13 @@ module invokes call_rcu() from timers, you will need to first cancel all
 the timers, and only then invoke rcu_barrier() to wait for any remaining
 RCU callbacks to complete.
 
+Of course, if you module uses call_rcu_bh(), you will need to invoke
+rcu_barrier_bh() before unloading.  Similarly, if your module uses
+call_rcu_sched(), you will need to invoke rcu_barrier_sched() before
+unloading.  If your module uses call_rcu(), call_rcu_bh(), -and-
+call_rcu_sched(), then you will need to invoke each of rcu_barrier(),
+rcu_barrier_bh(), and rcu_barrier_sched().
+
 
 Implementing rcu_barrier()
 
diff --git a/Documentation/RCU/torture.txt b/Documentation/RCU/torture.txt
index a342b6e1cc10..9dba3bb90e60 100644
--- a/Documentation/RCU/torture.txt
+++ b/Documentation/RCU/torture.txt
@@ -76,8 +76,10 @@ torture_type	The type of RCU to test: "rcu" for the rcu_read_lock() API,
                 "rcu_sync" for rcu_read_lock() with synchronous reclamation,
                 "rcu_bh" for the rcu_read_lock_bh() API, "rcu_bh_sync" for
                 rcu_read_lock_bh() with synchronous reclamation, "srcu" for
-                the "srcu_read_lock()" API, and "sched" for the use of
-                preempt_disable() together with synchronize_sched().
+                the "srcu_read_lock()" API, "sched" for the use of
+                preempt_disable() together with synchronize_sched(),
+                and "sched_expedited" for the use of preempt_disable()
+                with synchronize_sched_expedited().
 
 verbose         Enable debug printk()s.  Default is disabled.
 
@@ -162,6 +164,23 @@ of the "old" and "current" counters for the corresponding CPU.  The
 "idx" value maps the "old" and "current" values to the underlying array,
 and is useful for debugging.
 
+Similarly, sched_expedited RCU provides the following:
+
+        sched_expedited-torture: rtc: d0000000016c1880 ver: 1090796 tfle: 0 rta: 1090796 rtaf: 0 rtf: 1090787 rtmbe: 0 nt: 27713319
+        sched_expedited-torture: Reader Pipe:  12660320201 95875 0 0 0 0 0 0 0 0 0
+        sched_expedited-torture: Reader Batch:  12660424885 0 0 0 0 0 0 0 0 0 0
+        sched_expedited-torture: Free-Block Circulation:  1090795 1090795 1090794 1090793 1090792 1090791 1090790 1090789 1090788 1090787 0
+        state: -1 / 0:0 3:0 4:0
+
+As before, the first four lines are similar to those for RCU.
+The last line shows the task-migration state.  The first number is
+-1 if synchronize_sched_expedited() is idle, -2 if in the process of
+posting wakeups to the migration kthreads, and N when waiting on CPU N.
+Each of the colon-separated fields following the "/" is a CPU:state pair.
+Valid states are "0" for idle, "1" for waiting for quiescent state,
+"2" for passed through quiescent state, and "3" when a race with a
+CPU-hotplug event forces use of the synchronize_sched() primitive.
+
 
 USAGE
 
diff --git a/Documentation/RCU/trace.txt b/Documentation/RCU/trace.txt
index 02cced183b2d..187bbf10c923 100644
--- a/Documentation/RCU/trace.txt
+++ b/Documentation/RCU/trace.txt
@@ -191,8 +191,7 @@ rcu/rcuhier (which displays the struct rcu_node hierarchy).
 
 The output of "cat rcu/rcudata" looks as follows:
 
-rcu:
-rcu:
+rcu_sched:
   0 c=17829 g=17829 pq=1 pqc=17829 qp=0 dt=10951/1 dn=0 df=1101 of=0 ri=36 ql=0 b=10
   1 c=17829 g=17829 pq=1 pqc=17829 qp=0 dt=16117/1 dn=0 df=1015 of=0 ri=0 ql=0 b=10
   2 c=17829 g=17829 pq=1 pqc=17829 qp=0 dt=1445/1 dn=0 df=1839 of=0 ri=0 ql=0 b=10
@@ -306,7 +305,7 @@ comma-separated-variable spreadsheet format.
 
 The output of "cat rcu/rcugp" looks as follows:
 
-rcu: completed=33062  gpnum=33063
+rcu_sched: completed=33062  gpnum=33063
 rcu_bh: completed=464  gpnum=464
 
 Again, this output is for both "rcu" and "rcu_bh".  The fields are
@@ -413,7 +412,7 @@ o	Each element of the form "1/1 0:127 ^0" represents one struct
 
 The output of "cat rcu/rcu_pending" looks as follows:
 
-rcu:
+rcu_sched:
   0 np=255892 qsp=53936 cbr=0 cng=14417 gpc=10033 gps=24320 nf=6445 nn=146741
   1 np=261224 qsp=54638 cbr=0 cng=25723 gpc=16310 gps=2849 nf=5912 nn=155792
   2 np=237496 qsp=49664 cbr=0 cng=2762 gpc=45478 gps=1762 nf=1201 nn=136629
diff --git a/Documentation/RCU/whatisRCU.txt b/Documentation/RCU/whatisRCU.txt
index 96170824a717..e41a7fecf0d3 100644
--- a/Documentation/RCU/whatisRCU.txt
+++ b/Documentation/RCU/whatisRCU.txt
@@ -136,10 +136,10 @@ rcu_read_lock()
         Used by a reader to inform the reclaimer that the reader is
         entering an RCU read-side critical section.  It is illegal
         to block while in an RCU read-side critical section, though
-        kernels built with CONFIG_PREEMPT_RCU can preempt RCU read-side
-        critical sections.  Any RCU-protected data structure accessed
-        during an RCU read-side critical section is guaranteed to remain
-        unreclaimed for the full duration of that critical section.
+        kernels built with CONFIG_TREE_PREEMPT_RCU can preempt RCU
+        read-side critical sections.  Any RCU-protected data structure
+        accessed during an RCU read-side critical section is guaranteed to
+        remain unreclaimed for the full duration of that critical section.
         Reference counts may be used in conjunction with RCU to maintain
         longer-term references to data structures.
 
@@ -785,6 +785,7 @@ RCU pointer/list traversal:
         rcu_dereference
         list_for_each_entry_rcu
         hlist_for_each_entry_rcu
+        hlist_nulls_for_each_entry_rcu
 
         list_for_each_continue_rcu      (to be deprecated in favor of new
                                          list_for_each_entry_continue_rcu)
@@ -807,19 +808,23 @@ RCU:	Critical sections	Grace period		Barrier
 
         rcu_read_lock           synchronize_net         rcu_barrier
         rcu_read_unlock         synchronize_rcu
+                                synchronize_rcu_expedited
                                 call_rcu
 
 
 bh:     Critical sections       Grace period            Barrier
 
         rcu_read_lock_bh        call_rcu_bh             rcu_barrier_bh
-        rcu_read_unlock_bh
+        rcu_read_unlock_bh      synchronize_rcu_bh
+                                synchronize_rcu_bh_expedited
 
 
 sched:  Critical sections       Grace period            Barrier
 
-        [preempt_disable]       synchronize_sched       rcu_barrier_sched
-        [and friends]           call_rcu_sched
+        rcu_read_lock_sched     synchronize_sched       rcu_barrier_sched
+        rcu_read_unlock_sched   call_rcu_sched
+        [preempt_disable]       synchronize_sched_expedited
+        [and friends]
 
 
 SRCU:   Critical sections       Grace period            Barrier
@@ -827,6 +832,9 @@ SRCU:	Critical sections	Grace period		Barrier
         srcu_read_lock          synchronize_srcu        N/A
         srcu_read_unlock
 
+SRCU:   Initialization/cleanup
+        init_srcu_struct
+        cleanup_srcu_struct
 
 See the comment headers in the source code (or the docbook generated
 from them) for more information.
diff --git a/Documentation/feature-removal-schedule.txt b/Documentation/feature-removal-schedule.txt
index f0690bbbd73c..bb3a53cdfbc3 100644
--- a/Documentation/feature-removal-schedule.txt
+++ b/Documentation/feature-removal-schedule.txt
@@ -206,24 +206,6 @@ Who:	Len Brown <len.brown@intel.com>
 
 ---------------------------
 
-What: libata spindown skipping and warning
-When: Dec 2008
-Why:  Some halt(8) implementations synchronize caches for and spin
-      down libata disks because libata didn't use to spin down disk on
-      system halt (only synchronized caches).
-      Spin down on system halt is now implemented.  sysfs node
-      /sys/class/scsi_disk/h:c:i:l/manage_start_stop is present if
-      spin down support is available.
-      Because issuing spin down command to an already spun down disk
-      makes some disks spin up just to spin down again, libata tracks
-      device spindown status to skip the extra spindown command and
-      warn about it.
-      This is to give userspace tools the time to get updated and will
-      be removed after userspace is reasonably updated.
-Who:  Tejun Heo <htejun@gmail.com>
-
----------------------------
-
 What:   i386/x86_64 bzImage symlinks
 When:   April 2010
 
@@ -394,15 +376,6 @@ Who:	Thomas Gleixner <tglx@linutronix.de>
 
 -----------------------------
 
-What:   obsolete generic irq defines and typedefs
-When:   2.6.30
-Why:    The defines and typedefs (hw_interrupt_type, no_irq_type, irq_desc_t)
-        have been kept around for migration reasons. After more than two years
-        it's time to remove them finally
-Who:    Thomas Gleixner <tglx@linutronix.de>
-
----------------------------
-
 What:   fakephp and associated sysfs files in /sys/bus/pci/slots/
 When:   2011
 Why:    In 2.6.27, the semantics of /sys/bus/pci/slots was redefined to
diff --git a/Documentation/kernel-parameters.txt b/Documentation/kernel-parameters.txt
index ce8853755814..5d4427d17281 100644
--- a/Documentation/kernel-parameters.txt
+++ b/Documentation/kernel-parameters.txt
@@ -2509,6 +2509,11 @@ and is between 256 and 4096 characters. It is defined in the file
         trace_buf_size=nn[KMG]
                         [FTRACE] will set tracing buffer size.
 
+        trace_event=[event-list]
+                        [FTRACE] Set and start specified trace events in order
+                        to facilitate early boot debugging.
+                        See also Documentation/trace/events.txt
+
         trix=           [HW,OSS] MediaTrix AudioTrix Pro
                         Format:
                         <io>,<irq>,<dma>,<dma2>,<sb_io>,<sb_irq>,<sb_dma>,<mpu_io>,<mpu_irq>
diff --git a/Documentation/trace/events.txt b/Documentation/trace/events.txt
index f157d7594ea7..2bcc8d4dea29 100644
--- a/Documentation/trace/events.txt
+++ b/Documentation/trace/events.txt
@@ -83,6 +83,15 @@ When reading one of these enable files, there are four results:
  X - there is a mixture of events enabled and disabled
  ? - this file does not affect any event
 
+2.3 Boot option
+---------------
+
+In order to facilitate early boot debugging, use boot option:
+
+        trace_event=[event-list]
+
+The format of this boot option is the same as described in section 2.1.
+
 3. Defining an event-enabled tracepoint
 =======================================
 
diff --git a/Documentation/trace/ftrace.txt b/Documentation/trace/ftrace.txt
index a39b3c749de5..355d0f1f8c50 100644
--- a/Documentation/trace/ftrace.txt
+++ b/Documentation/trace/ftrace.txt
@@ -85,26 +85,19 @@ of ftrace. Here is a list of some of the key files:
         This file holds the output of the trace in a human
         readable format (described below).
 
-  latency_trace:
-
-        This file shows the same trace but the information
-        is organized more to display possible latencies
-        in the system (described below).
-
   trace_pipe:
 
         The output is the same as the "trace" file but this
         file is meant to be streamed with live tracing.
-        Reads from this file will block until new data
-        is retrieved. Unlike the "trace" and "latency_trace"
-        files, this file is a consumer. This means reading
-        from this file causes sequential reads to display
-        more current data. Once data is read from this
-        file, it is consumed, and will not be read
-        again with a sequential read. The "trace" and
-        "latency_trace" files are static, and if the
-        tracer is not adding more data, they will display
-        the same information every time they are read.
+        Reads from this file will block until new data is
+        retrieved.  Unlike the "trace" file, this file is a
+        consumer. This means reading from this file causes
+        sequential reads to display more current data. Once
+        data is read from this file, it is consumed, and
+        will not be read again with a sequential read. The
+        "trace" file is static, and if the tracer is not
+        adding more data,they will display the same
+        information every time they are read.
 
   trace_options:
 
@@ -117,10 +110,10 @@ of ftrace. Here is a list of some of the key files:
         Some of the tracers record the max latency.
         For example, the time interrupts are disabled.
         This time is saved in this file. The max trace
-        will also be stored, and displayed by either
-        "trace" or "latency_trace".  A new max trace will
-        only be recorded if the latency is greater than
-        the value in this file. (in microseconds)
+        will also be stored, and displayed by "trace".
+        A new max trace will only be recorded if the
+        latency is greater than the value in this
+        file. (in microseconds)
 
   buffer_size_kb:
 
@@ -210,7 +203,7 @@ Here is the list of current tracers that may be configured.
         the trace with the longest max latency.
         See tracing_max_latency. When a new max is recorded,
         it replaces the old trace. It is best to view this
-        trace via the latency_trace file.
+        trace with the latency-format option enabled.
 
   "preemptoff"
 
@@ -307,8 +300,8 @@ the lowest priority thread (pid 0).
 Latency trace format
 --------------------
 
-For traces that display latency times, the latency_trace file
-gives somewhat more information to see why a latency happened.
+When the latency-format option is enabled, the trace file gives
+somewhat more information to see why a latency happened.
 Here is a typical trace.
 
 # tracer: irqsoff
@@ -380,9 +373,10 @@ explains which is which.
 
 The above is mostly meaningful for kernel developers.
 
-  time: This differs from the trace file output. The trace file output
-        includes an absolute timestamp. The timestamp used by the
-        latency_trace file is relative to the start of the trace.
+  time: When the latency-format option is enabled, the trace file
+        output includes a timestamp relative to the start of the
+        trace. This differs from the output when latency-format
+        is disabled, which includes an absolute timestamp.
 
   delay: This is just to help catch your eye a bit better. And
          needs to be fixed to be only relative to the same CPU.
@@ -440,7 +434,8 @@ Here are the available options:
   sym-addr:
    bash-4000  [01]  1477.606694: simple_strtoul <c0339346>
 
-  verbose - This deals with the latency_trace file.
+  verbose - This deals with the trace file when the
+            latency-format option is enabled.
 
     bash  4000 1 0 00000000 00010a95 [58127d26] 1720.415ms \
     (+0.000ms): simple_strtoul (strict_strtoul)
@@ -472,7 +467,7 @@ Here are the available options:
                 the app is no longer running
 
                 The lookup is performed when you read
-                trace,trace_pipe,latency_trace. Example:
+                trace,trace_pipe. Example:
 
                 a.out-1623  [000] 40874.465068: /root/a.out[+0x480] <-/root/a.out[+0
 x494] <- /root/a.out[+0x4a8] <- /lib/libc-2.7.so[+0x1e1a6]
@@ -481,6 +476,11 @@ x494] <- /root/a.out[+0x4a8] <- /lib/libc-2.7.so[+0x1e1a6]
                every scheduling event. Will add overhead if
                there's a lot of tasks running at once.
 
+  latency-format - This option changes the trace. When
+                   it is enabled, the trace displays
+                   additional information about the
+                   latencies, as described in "Latency
+                   trace format".
 
 sched_switch
 ------------
@@ -596,12 +596,13 @@ To reset the maximum, echo 0 into tracing_max_latency. Here is
 an example:
 
  # echo irqsoff > current_tracer
+ # echo latency-format > trace_options
  # echo 0 > tracing_max_latency
  # echo 1 > tracing_enabled
  # ls -ltr
  [...]
  # echo 0 > tracing_enabled
- # cat latency_trace
+ # cat trace
 # tracer: irqsoff
 #
 irqsoff latency trace v1.1.5 on 2.6.26
@@ -703,12 +704,13 @@ which preemption was disabled. The control of preemptoff tracer
 is much like the irqsoff tracer.
 
  # echo preemptoff > current_tracer
+ # echo latency-format > trace_options
  # echo 0 > tracing_max_latency
  # echo 1 > tracing_enabled
  # ls -ltr
  [...]
  # echo 0 > tracing_enabled
- # cat latency_trace
+ # cat trace
 # tracer: preemptoff
 #
 preemptoff latency trace v1.1.5 on 2.6.26-rc8
@@ -850,12 +852,13 @@ Again, using this trace is much like the irqsoff and preemptoff
 tracers.
 
  # echo preemptirqsoff > current_tracer
+ # echo latency-format > trace_options
  # echo 0 > tracing_max_latency
  # echo 1 > tracing_enabled
  # ls -ltr
  [...]
  # echo 0 > tracing_enabled
- # cat latency_trace
+ # cat trace
 # tracer: preemptirqsoff
 #
 preemptirqsoff latency trace v1.1.5 on 2.6.26-rc8
@@ -1012,11 +1015,12 @@ Instead of performing an 'ls', we will run 'sleep 1' under
 'chrt' which changes the priority of the task.
 
  # echo wakeup > current_tracer
+ # echo latency-format > trace_options
  # echo 0 > tracing_max_latency
  # echo 1 > tracing_enabled
  # chrt -f 5 sleep 1
  # echo 0 > tracing_enabled
- # cat latency_trace
+ # cat trace
 # tracer: wakeup
 #
 wakeup latency trace v1.1.5 on 2.6.26-rc8
diff --git a/Documentation/trace/function-graph-fold.vim b/Documentation/trace/function-graph-fold.vim
new file mode 100644
index 000000000000..0544b504c8b0
--- /dev/null
+++ b/Documentation/trace/function-graph-fold.vim
@@ -0,0 +1,42 @@
+" Enable folding for ftrace function_graph traces.
+"
+" To use, :source this file while viewing a function_graph trace, or use vim's
+" -S option to load from the command-line together with a trace.  You can then
+" use the usual vim fold commands, such as "za", to open and close nested
+" functions.  While closed, a fold will show the total time taken for a call,
+" as would normally appear on the line with the closing brace.  Folded
+" functions will not include finish_task_switch(), so folding should remain
+" relatively sane even through a context switch.
+"
+" Note that this will almost certainly only work well with a
+" single-CPU trace (e.g. trace-cmd report --cpu 1).
+
+function! FunctionGraphFoldExpr(lnum)
+  let line = getline(a:lnum)
+  if line[-1:] == '{'
+    if line =~ 'finish_task_switch() {$'
+      return '>1'
+    endif
+    return 'a1'
+  elseif line[-1:] == '}'
+    return 's1'
+  else
+    return '='
+  endif
+endfunction
+
+function! FunctionGraphFoldText()
+  let s = split(getline(v:foldstart), '|', 1)
+  if getline(v:foldend+1) =~ 'finish_task_switch() {$'
+    let s[2] = ' task switch  '
+  else
+    let e = split(getline(v:foldend), '|', 1)
+    let s[2] = e[2]
+  endif
+  return join(s, '|')
+endfunction
+
+setlocal foldexpr=FunctionGraphFoldExpr(v:lnum)
+setlocal foldtext=FunctionGraphFoldText()
+setlocal foldcolumn=12
+setlocal foldmethod=expr
diff --git a/Documentation/trace/ring-buffer-design.txt b/Documentation/trace/ring-buffer-design.txt
new file mode 100644
index 000000000000..5b1d23d604c5
--- /dev/null
+++ b/Documentation/trace/ring-buffer-design.txt
@@ -0,0 +1,955 @@
+                Lockless Ring Buffer Design
+                ===========================
+
+Copyright 2009 Red Hat Inc.
+   Author:   Steven Rostedt <srostedt@redhat.com>
+  License:   The GNU Free Documentation License, Version 1.2
+               (dual licensed under the GPL v2)
+Reviewers:   Mathieu Desnoyers, Huang Ying, Hidetoshi Seto,
+             and Frederic Weisbecker.
+
+
+Written for: 2.6.31
+
+Terminology used in this Document
+---------------------------------
+
+tail - where new writes happen in the ring buffer.
+
+head - where new reads happen in the ring buffer.
+
+producer - the task that writes into the ring buffer (same as writer)
+
+writer - same as producer
+
+consumer - the task that reads from the buffer (same as reader)
+
+reader - same as consumer.
+
+reader_page - A page outside the ring buffer used solely (for the most part)
+    by the reader.
+
+head_page - a pointer to the page that the reader will use next
+
+tail_page - a pointer to the page that will be written to next
+
+commit_page - a pointer to the page with the last finished non nested write.
+
+cmpxchg - hardware assisted atomic transaction that performs the following:
+
+   A = B iff previous A == C
+
+   R = cmpxchg(A, C, B) is saying that we replace A with B if and only if
+      current A is equal to C, and we put the old (current) A into R
+
+   R gets the previous A regardless if A is updated with B or not.
+
+   To see if the update was successful a compare of R == C may be used.
+
+The Generic Ring Buffer
+-----------------------
+
+The ring buffer can be used in either an overwrite mode or in
+producer/consumer mode.
+
+Producer/consumer mode is where the producer were to fill up the
+buffer before the consumer could free up anything, the producer
+will stop writing to the buffer. This will lose most recent events.
+
+Overwrite mode is where the produce were to fill up the buffer
+before the consumer could free up anything, the producer will
+overwrite the older data. This will lose the oldest events.
+
+No two writers can write at the same time (on the same per cpu buffer),
+but a writer may interrupt another writer, but it must finish writing
+before the previous writer may continue. This is very important to the
+algorithm. The writers act like a "stack". The way interrupts works
+enforces this behavior.
+
+
+  writer1 start
+     <preempted> writer2 start
+         <preempted> writer3 start
+                     writer3 finishes
+                 writer2 finishes
+  writer1 finishes
+
+This is very much like a writer being preempted by an interrupt and
+the interrupt doing a write as well.
+
+Readers can happen at any time. But no two readers may run at the
+same time, nor can a reader preempt/interrupt another reader. A reader
+can not preempt/interrupt a writer, but it may read/consume from the
+buffer at the same time as a writer is writing, but the reader must be
+on another processor to do so. A reader may read on its own processor
+and can be preempted by a writer.
+
+A writer can preempt a reader, but a reader can not preempt a writer.
+But a reader can read the buffer at the same time (on another processor)
+as a writer.
+
+The ring buffer is made up of a list of pages held together by a link list.
+
+At initialization a reader page is allocated for the reader that is not
+part of the ring buffer.
+
+The head_page, tail_page and commit_page are all initialized to point
+to the same page.
+
+The reader page is initialized to have its next pointer pointing to
+the head page, and its previous pointer pointing to a page before
+the head page.
+
+The reader has its own page to use. At start up time, this page is
+allocated but is not attached to the list. When the reader wants
+to read from the buffer, if its page is empty (like it is on start up)
+it will swap its page with the head_page. The old reader page will
+become part of the ring buffer and the head_page will be removed.
+The page after the inserted page (old reader_page) will become the
+new head page.
+
+Once the new page is given to the reader, the reader could do what
+it wants with it, as long as a writer has left that page.
+
+A sample of how the reader page is swapped: Note this does not
+show the head page in the buffer, it is for demonstrating a swap
+only.
+
+  +------+
+  |reader|          RING BUFFER
+  |page  |
+  +------+
+                  +---+   +---+   +---+
+                  |   |-->|   |-->|   |
+                  |   |<--|   |<--|   |
+                  +---+   +---+   +---+
+                   ^ |             ^ |
+                   | +-------------+ |
+                   +-----------------+
+
+
+  +------+
+  |reader|          RING BUFFER
+  |page  |-------------------+
+  +------+                   v
+    |             +---+   +---+   +---+
+    |             |   |-->|   |-->|   |
+    |             |   |<--|   |<--|   |<-+
+    |             +---+   +---+   +---+  |
+    |              ^ |             ^ |   |
+    |              | +-------------+ |   |
+    |              +-----------------+   |
+    +------------------------------------+
+
+  +------+
+  |reader|          RING BUFFER
+  |page  |-------------------+
+  +------+ <---------------+ v
+    |  ^          +---+   +---+   +---+
+    |  |          |   |-->|   |-->|   |
+    |  |          |   |   |   |<--|   |<-+
+    |  |          +---+   +---+   +---+  |
+    |  |             |             ^ |   |
+    |  |             +-------------+ |   |
+    |  +-----------------------------+   |
+    +------------------------------------+
+
+  +------+
+  |buffer|          RING BUFFER
+  |page  |-------------------+
+  +------+ <---------------+ v
+    |  ^          +---+   +---+   +---+
+    |  |          |   |   |   |-->|   |
+    |  |  New     |   |   |   |<--|   |<-+
+    |  | Reader   +---+   +---+   +---+  |
+    |  |  page ----^                 |   |
+    |  |                             |   |
+    |  +-----------------------------+   |
+    +------------------------------------+
+
+
+
+It is possible that the page swapped is the commit page and the tail page,
+if what is in the ring buffer is less than what is held in a buffer page.
+
+
+          reader page    commit page   tail page
+              |              |             |
+              v              |             |
+             +---+           |             |
+             |   |<----------+             |
+             |   |<------------------------+
+             |   |------+
+             +---+      |
+                        |
+                        v
+    +---+    +---+    +---+    +---+
+<---|   |--->|   |--->|   |--->|   |--->
+--->|   |<---|   |<---|   |<---|   |<---
+    +---+    +---+    +---+    +---+
+
+This case is still valid for this algorithm.
+When the writer leaves the page, it simply goes into the ring buffer
+since the reader page still points to the next location in the ring
+buffer.
+
+
+The main pointers:
+
+  reader page - The page used solely by the reader and is not part
+                of the ring buffer (may be swapped in)
+
+  head page - the next page in the ring buffer that will be swapped
+              with the reader page.
+
+  tail page - the page where the next write will take place.
+
+  commit page - the page that last finished a write.
+
+The commit page only is updated by the outer most writer in the
+writer stack. A writer that preempts another writer will not move the
+commit page.
+
+When data is written into the ring buffer, a position is reserved
+in the ring buffer and passed back to the writer. When the writer
+is finished writing data into that position, it commits the write.
+
+Another write (or a read) may take place at anytime during this
+transaction. If another write happens it must finish before continuing
+with the previous write.
+
+
+   Write reserve:
+
+       Buffer page
+      +---------+
+      |written  |
+      +---------+  <--- given back to writer (current commit)
+      |reserved |
+      +---------+ <--- tail pointer
+      | empty   |
+      +---------+
+
+   Write commit:
+
+       Buffer page
+      +---------+
+      |written  |
+      +---------+
+      |written  |
+      +---------+  <--- next positon for write (current commit)
+      | empty   |
+      +---------+
+
+
+ If a write happens after the first reserve:
+
+       Buffer page
+      +---------+
+      |written  |
+      +---------+  <-- current commit
+      |reserved |
+      +---------+  <--- given back to second writer
+      |reserved |
+      +---------+ <--- tail pointer
+
+  After second writer commits:
+
+
+       Buffer page
+      +---------+
+      |written  |
+      +---------+  <--(last full commit)
+      |reserved |
+      +---------+
+      |pending  |
+      |commit   |
+      +---------+ <--- tail pointer
+
+  When the first writer commits:
+
+       Buffer page
+      +---------+
+      |written  |
+      +---------+
+      |written  |
+      +---------+
+      |written  |
+      +---------+  <--(last full commit and tail pointer)
+
+
+The commit pointer points to the last write location that was
+committed without preempting another write. When a write that
+preempted another write is committed, it only becomes a pending commit
+and will not be a full commit till all writes have been committed.
+
+The commit page points to the page that has the last full commit.
+The tail page points to the page with the last write (before
+committing).
+
+The tail page is always equal to or after the commit page. It may
+be several pages ahead. If the tail page catches up to the commit
+page then no more writes may take place (regardless of the mode
+of the ring buffer: overwrite and produce/consumer).
+
+The order of pages are:
+
+ head page
+ commit page
+ tail page
+
+Possible scenario:
+                             tail page
+  head page         commit page  |
+      |                 |        |
+      v                 v        v
+    +---+    +---+    +---+    +---+
+<---|   |--->|   |--->|   |--->|   |--->
+--->|   |<---|   |<---|   |<---|   |<---
+    +---+    +---+    +---+    +---+
+
+There is a special case that the head page is after either the commit page
+and possibly the tail page. That is when the commit (and tail) page has been
+swapped with the reader page. This is because the head page is always
+part of the ring buffer, but the reader page is not. When ever there
+has been less than a full page that has been committed inside the ring buffer,
+and a reader swaps out a page, it will be swapping out the commit page.
+
+
+          reader page    commit page   tail page
+              |              |             |
+              v              |             |
+             +---+           |             |
+             |   |<----------+             |
+             |   |<------------------------+
+             |   |------+
+             +---+      |
+                        |
+                        v
+    +---+    +---+    +---+    +---+
+<---|   |--->|   |--->|   |--->|   |--->
+--->|   |<---|   |<---|   |<---|   |<---
+    +---+    +---+    +---+    +---+
+                        ^
+                        |
+                    head page
+
+
+In this case, the head page will not move when the tail and commit
+move back into the ring buffer.
+
+The reader can not swap a page into the ring buffer if the commit page
+is still on that page. If the read meets the last commit (real commit
+not pending or reserved), then there is nothing more to read.
+The buffer is considered empty until another full commit finishes.
+
+When the tail meets the head page, if the buffer is in overwrite mode,
+the head page will be pushed ahead one. If the buffer is in producer/consumer
+mode, the write will fail.
+
+Overwrite mode:
+
+            tail page
+               |
+               v
+    +---+    +---+    +---+    +---+
+<---|   |--->|   |--->|   |--->|   |--->
+--->|   |<---|   |<---|   |<---|   |<---
+    +---+    +---+    +---+    +---+
+                        ^
+                        |
+                    head page
+
+
+            tail page
+               |
+               v
+    +---+    +---+    +---+    +---+
+<---|   |--->|   |--->|   |--->|   |--->
+--->|   |<---|   |<---|   |<---|   |<---
+    +---+    +---+    +---+    +---+
+                                 ^
+                                 |
+                             head page
+
+
+                    tail page
+                        |
+                        v
+    +---+    +---+    +---+    +---+
+<---|   |--->|   |--->|   |--->|   |--->
+--->|   |<---|   |<---|   |<---|   |<---
+    +---+    +---+    +---+    +---+
+                                 ^
+                                 |
+                             head page
+
+Note, the reader page will still point to the previous head page.
+But when a swap takes place, it will use the most recent head page.
+
+
+Making the Ring Buffer Lockless:
+--------------------------------
+
+The main idea behind the lockless algorithm is to combine the moving
+of the head_page pointer with the swapping of pages with the reader.
+State flags are placed inside the pointer to the page. To do this,
+each page must be aligned in memory by 4 bytes. This will allow the 2
+least significant bits of the address to be used as flags. Since
+they will always be zero for the address. To get the address,
+simply mask out the flags.
+
+  MASK = ~3
+
+  address & MASK
+
+Two flags will be kept by these two bits:
+
+   HEADER - the page being pointed to is a head page
+
+   UPDATE - the page being pointed to is being updated by a writer
+          and was or is about to be a head page.
+
+
+          reader page
+              |
+              v
+             +---+
+             |   |------+
+             +---+      |
+                        |
+                        v
+    +---+    +---+    +---+    +---+
+<---|   |--->|   |-H->|   |--->|   |--->
+--->|   |<---|   |<---|   |<---|   |<---
+    +---+    +---+    +---+    +---+
+
+
+The above pointer "-H->" would have the HEADER flag set. That is
+the next page is the next page to be swapped out by the reader.
+This pointer means the next page is the head page.
+
+When the tail page meets the head pointer, it will use cmpxchg to
+change the pointer to the UPDATE state:
+
+
+            tail page
+               |
+               v
+    +---+    +---+    +---+    +---+
+<---|   |--->|   |-H->|   |--->|   |--->
+--->|   |<---|   |<---|   |<---|   |<---
+    +---+    +---+    +---+    +---+
+
+            tail page
+               |
+               v
+    +---+    +---+    +---+    +---+
+<---|   |--->|   |-U->|   |--->|   |--->
+--->|   |<---|   |<---|   |<---|   |<---
+    +---+    +---+    +---+    +---+
+
+"-U->" represents a pointer in the UPDATE state.
+
+Any access to the reader will need to take some sort of lock to serialize
+the readers. But the writers will never take a lock to write to the
+ring buffer. This means we only need to worry about a single reader,
+and writes only preempt in "stack" formation.
+
+When the reader tries to swap the page with the ring buffer, it
+will also use cmpxchg. If the flag bit in the pointer to the
+head page does not have the HEADER flag set, the compare will fail
+and the reader will need to look for the new head page and try again.
+Note, the flag UPDATE and HEADER are never set at the same time.
+
+The reader swaps the reader page as follows:
+
+  +------+
+  |reader|          RING BUFFER
+  |page  |
+  +------+
+                  +---+    +---+    +---+
+                  |   |--->|   |--->|   |
+                  |   |<---|   |<---|   |
+                  +---+    +---+    +---+
+                   ^ |               ^ |
+                   | +---------------+ |
+                   +-----H-------------+
+
+The reader sets the reader page next pointer as HEADER to the page after
+the head page.
+
+
+  +------+
+  |reader|          RING BUFFER
+  |page  |-------H-----------+
+  +------+                   v
+    |             +---+    +---+    +---+
+    |             |   |--->|   |--->|   |
+    |             |   |<---|   |<---|   |<-+
+    |             +---+    +---+    +---+  |
+    |              ^ |               ^ |   |
+    |              | +---------------+ |   |
+    |              +-----H-------------+   |
+    +--------------------------------------+
+
+It does a cmpxchg with the pointer to the previous head page to make it
+point to the reader page. Note that the new pointer does not have the HEADER
+flag set.  This action atomically moves the head page forward.
+
+  +------+
+  |reader|          RING BUFFER
+  |page  |-------H-----------+
+  +------+                   v
+    |  ^          +---+   +---+   +---+
+    |  |          |   |-->|   |-->|   |
+    |  |          |   |<--|   |<--|   |<-+
+    |  |          +---+   +---+   +---+  |
+    |  |             |             ^ |   |
+    |  |             +-------------+ |   |
+    |  +-----------------------------+   |
+    +------------------------------------+
+
+After the new head page is set, the previous pointer of the head page is
+updated to the reader page.
+
+  +------+
+  |reader|          RING BUFFER
+  |page  |-------H-----------+
+  +------+ <---------------+ v
+    |  ^          +---+   +---+   +---+
+    |  |          |   |-->|   |-->|   |
+    |  |          |   |   |   |<--|   |<-+
+    |  |          +---+   +---+   +---+  |
+    |  |             |             ^ |   |
+    |  |             +-------------+ |   |
+    |  +-----------------------------+   |
+    +------------------------------------+
+
+  +------+
+  |buffer|          RING BUFFER
+  |page  |-------H-----------+  <--- New head page
+  +------+ <---------------+ v
+    |  ^          +---+   +---+   +---+
+    |  |          |   |   |   |-->|   |
+    |  |  New     |   |   |   |<--|   |<-+
+    |  | Reader   +---+   +---+   +---+  |
+    |  |  page ----^                 |   |
+    |  |                             |   |
+    |  +-----------------------------+   |
+    +------------------------------------+
+
+Another important point. The page that the reader page points back to
+by its previous pointer (the one that now points to the new head page)
+never points back to the reader page. That is because the reader page is
+not part of the ring buffer. Traversing the ring buffer via the next pointers
+will always stay in the ring buffer. Traversing the ring buffer via the
+prev pointers may not.
+
+Note, the way to determine a reader page is simply by examining the previous
+pointer of the page. If the next pointer of the previous page does not
+point back to the original page, then the original page is a reader page:
+
+
+             +--------+
+             | reader |  next   +----+
+             |  page  |-------->|    |<====== (buffer page)
+             +--------+         +----+
+                 |                | ^
+                 |                v | next
+            prev |              +----+
+                 +------------->|    |
+                                +----+
+
+The way the head page moves forward:
+
+When the tail page meets the head page and the buffer is in overwrite mode
+and more writes take place, the head page must be moved forward before the
+writer may move the tail page. The way this is done is that the writer
+performs a cmpxchg to convert the pointer to the head page from the HEADER
+flag to have the UPDATE flag set. Once this is done, the reader will
+not be able to swap the head page from the buffer, nor will it be able to
+move the head page, until the writer is finished with the move.
+
+This eliminates any races that the reader can have on the writer. The reader
+must spin, and this is why the reader can not preempt the writer.
+
+            tail page
+               |
+               v
+    +---+    +---+    +---+    +---+
+<---|   |--->|   |-H->|   |--->|   |--->
+--->|   |<---|   |<---|   |<---|   |<---
+    +---+    +---+    +---+    +---+
+
+            tail page
+               |
+               v
+    +---+    +---+    +---+    +---+
+<---|   |--->|   |-U->|   |--->|   |--->
+--->|   |<---|   |<---|   |<---|   |<---
+    +---+    +---+    +---+    +---+
+
+The following page will be made into the new head page.
+
+           tail page
+               |
+               v
+    +---+    +---+    +---+    +---+
+<---|   |--->|   |-U->|   |-H->|   |--->
+--->|   |<---|   |<---|   |<---|   |<---
+    +---+    +---+    +---+    +---+
+
+After the new head page has been set, we can set the old head page
+pointer back to NORMAL.
+
+           tail page
+               |
+               v
+    +---+    +---+    +---+    +---+
+<---|   |--->|   |--->|   |-H->|   |--->
+--->|   |<---|   |<---|   |<---|   |<---
+    +---+    +---+    +---+    +---+
+
+After the head page has been moved, the tail page may now move forward.
+
+                    tail page
+                        |
+                        v
+    +---+    +---+    +---+    +---+
+<---|   |--->|   |--->|   |-H->|   |--->
+--->|   |<---|   |<---|   |<---|   |<---
+    +---+    +---+    +---+    +---+
+
+
+The above are the trivial updates. Now for the more complex scenarios.
+
+
+As stated before, if enough writes preempt the first write, the
+tail page may make it all the way around the buffer and meet the commit
+page. At this time, we must start dropping writes (usually with some kind
+of warning to the user). But what happens if the commit was still on the
+reader page? The commit page is not part of the ring buffer. The tail page
+must account for this.
+
+
+          reader page    commit page
+              |              |
+              v              |
+             +---+           |
+             |   |<----------+
+             |   |
+             |   |------+
+             +---+      |
+                        |
+                        v
+    +---+    +---+    +---+    +---+
+<---|   |--->|   |-H->|   |--->|   |--->
+--->|   |<---|   |<---|   |<---|   |<---
+    +---+    +---+    +---+    +---+
+               ^
+               |
+           tail page
+
+If the tail page were to simply push the head page forward, the commit when
+leaving the reader page would not be pointing to the correct page.
+
+The solution to this is to test if the commit page is on the reader page
+before pushing the head page. If it is, then it can be assumed that the
+tail page wrapped the buffer, and we must drop new writes.
+
+This is not a race condition, because the commit page can only be moved
+by the outter most writer (the writer that was preempted).
+This means that the commit will not move while a writer is moving the
+tail page. The reader can not swap the reader page if it is also being
+used as the commit page. The reader can simply check that the commit
+is off the reader page. Once the commit page leaves the reader page
+it will never go back on it unless a reader does another swap with the
+buffer page that is also the commit page.
+
+
+Nested writes
+-------------
+
+In the pushing forward of the tail page we must first push forward
+the head page if the head page is the next page. If the head page
+is not the next page, the tail page is simply updated with a cmpxchg.
+
+Only writers move the tail page. This must be done atomically to protect
+against nested writers.
+
+  temp_page = tail_page
+  next_page = temp_page->next
+  cmpxchg(tail_page, temp_page, next_page)
+
+The above will update the tail page if it is still pointing to the expected
+page. If this fails, a nested write pushed it forward, the the current write
+does not need to push it.
+
+
+           temp page
+               |
+               v
+            tail page
+               |
+               v
+    +---+    +---+    +---+    +---+
+<---|   |--->|   |--->|   |--->|   |--->
+--->|   |<---|   |<---|   |<---|   |<---
+    +---+    +---+    +---+    +---+
+
+Nested write comes in and moves the tail page forward:
+
+                    tail page (moved by nested writer)
+            temp page   |
+               |        |
+               v        v
+    +---+    +---+    +---+    +---+
+<---|   |--->|   |--->|   |--->|   |--->
+--->|   |<---|   |<---|   |<---|   |<---
+    +---+    +---+    +---+    +---+
+
+The above would fail the cmpxchg, but since the tail page has already
+been moved forward, the writer will just try again to reserve storage
+on the new tail page.
+
+But the moving of the head page is a bit more complex.
+
+            tail page
+               |
+               v
+    +---+    +---+    +---+    +---+
+<---|   |--->|   |-H->|   |--->|   |--->
+--->|   |<---|   |<---|   |<---|   |<---
+    +---+    +---+    +---+    +---+
+
+The write converts the head page pointer to UPDATE.
+
+            tail page
+               |
+               v
+    +---+    +---+    +---+    +---+
+<---|   |--->|   |-U->|   |--->|   |--->
+--->|   |<---|   |<---|   |<---|   |<---
+    +---+    +---+    +---+    +---+
+
+But if a nested writer preempts here. It will see that the next
+page is a head page, but it is also nested. It will detect that
+it is nested and will save that information. The detection is the
+fact that it sees the UPDATE flag instead of a HEADER or NORMAL
+pointer.
+
+The nested writer will set the new head page pointer.
+
+           tail page
+               |
+               v
+    +---+    +---+    +---+    +---+
+<---|   |--->|   |-U->|   |-H->|   |--->
+--->|   |<---|   |<---|   |<---|   |<---
+    +---+    +---+    +---+    +---+
+
+But it will not reset the update back to normal. Only the writer
+that converted a pointer from HEAD to UPDATE will convert it back
+to NORMAL.
+
+                    tail page
+                        |
+                        v
+    +---+    +---+    +---+    +---+
+<---|   |--->|   |-U->|   |-H->|   |--->
+--->|   |<---|   |<---|   |<---|   |<---
+    +---+    +---+    +---+    +---+
+
+After the nested writer finishes, the outer most writer will convert
+the UPDATE pointer to NORMAL.
+
+
+                    tail page
+                        |
+                        v
+    +---+    +---+    +---+    +---+
+<---|   |--->|   |--->|   |-H->|   |--->
+--->|   |<---|   |<---|   |<---|   |<---
+    +---+    +---+    +---+    +---+
+
+
+It can be even more complex if several nested writes came in and moved
+the tail page ahead several pages:
+
+
+(first writer)
+
+            tail page
+               |
+               v
+    +---+    +---+    +---+    +---+
+<---|   |--->|   |-H->|   |--->|   |--->
+--->|   |<---|   |<---|   |<---|   |<---
+    +---+    +---+    +---+    +---+
+
+The write converts the head page pointer to UPDATE.
+
+            tail page
+               |
+               v
+    +---+    +---+    +---+    +---+
+<---|   |--->|   |-U->|   |--->|   |--->
+--->|   |<---|   |<---|   |<---|   |<---
+    +---+    +---+    +---+    +---+
+
+Next writer comes in, and sees the update and sets up the new
+head page.
+
+(second writer)
+
+           tail page
+               |
+               v
+    +---+    +---+    +---+    +---+
+<---|   |--->|   |-U->|   |-H->|   |--->
+--->|   |<---|   |<---|   |<---|   |<---
+    +---+    +---+    +---+    +---+
+
+The nested writer moves the tail page forward. But does not set the old
+update page to NORMAL because it is not the outer most writer.
+
+                    tail page
+                        |
+                        v
+    +---+    +---+    +---+    +---+
+<---|   |--->|   |-U->|   |-H->|   |--->
+--->|   |<---|   |<---|   |<---|   |<---
+    +---+    +---+    +---+    +---+
+
+Another writer preempts and sees the page after the tail page is a head page.
+It changes it from HEAD to UPDATE.
+
+(third writer)
+
+                    tail page
+                        |
+                        v
+    +---+    +---+    +---+    +---+
+<---|   |--->|   |-U->|   |-U->|   |--->
+--->|   |<---|   |<---|   |<---|   |<---
+    +---+    +---+    +---+    +---+
+
+The writer will move the head page forward:
+
+
+(third writer)
+
+                    tail page
+                        |
+                        v
+    +---+    +---+    +---+    +---+
+<---|   |--->|   |-U->|   |-U->|   |-H->
+--->|   |<---|   |<---|   |<---|   |<---
+    +---+    +---+    +---+    +---+
+
+But now that the third writer did change the HEAD flag to UPDATE it
+will convert it to normal:
+
+
+(third writer)
+
+                    tail page
+                        |
+                        v
+    +---+    +---+    +---+    +---+
+<---|   |--->|   |-U->|   |--->|   |-H->
+--->|   |<---|   |<---|   |<---|   |<---
+    +---+    +---+    +---+    +---+
+
+
+Then it will move the tail page, and return back to the second writer.
+
+
+(second writer)
+
+                             tail page
+                                 |
+                                 v
+    +---+    +---+    +---+    +---+
+<---|   |--->|   |-U->|   |--->|   |-H->
+--->|   |<---|   |<---|   |<---|   |<---
+    +---+    +---+    +---+    +---+
+
+
+The second writer will fail to move the tail page because it was already
+moved, so it will try again and add its data to the new tail page.
+It will return to the first writer.
+
+
+(first writer)
+
+                             tail page
+                                 |
+                                 v
+    +---+    +---+    +---+    +---+
+<---|   |--->|   |-U->|   |--->|   |-H->
+--->|   |<---|   |<---|   |<---|   |<---
+    +---+    +---+    +---+    +---+
+
+The first writer can not know atomically test if the tail page moved
+while it updates the HEAD page. It will then update the head page to
+what it thinks is the new head page.
+
+
+(first writer)
+
+                             tail page
+                                 |
+                                 v
+    +---+    +---+    +---+    +---+
+<---|   |--->|   |-U->|   |-H->|   |-H->
+--->|   |<---|   |<---|   |<---|   |<---
+    +---+    +---+    +---+    +---+
+
+Since the cmpxchg returns the old value of the pointer the first writer
+will see it succeeded in updating the pointer from NORMAL to HEAD.
+But as we can see, this is not good enough. It must also check to see
+if the tail page is either where it use to be or on the next page:
+
+
+(first writer)
+
+               A        B    tail page
+               |        |        |
+               v        v        v
+    +---+    +---+    +---+    +---+
+<---|   |--->|   |-U->|   |-H->|   |-H->
+--->|   |<---|   |<---|   |<---|   |<---
+    +---+    +---+    +---+    +---+
+
+If tail page != A and tail page does not equal B, then it must reset the
+pointer back to NORMAL. The fact that it only needs to worry about
+nested writers, it only needs to check this after setting the HEAD page.
+
+
+(first writer)
+
+               A        B    tail page
+               |        |        |
+               v        v        v
+    +---+    +---+    +---+    +---+
+<---|   |--->|   |-U->|   |--->|   |-H->
+--->|   |<---|   |<---|   |<---|   |<---
+    +---+    +---+    +---+    +---+
+
+Now the writer can update the head page. This is also why the head page must
+remain in UPDATE and only reset by the outer most writer. This prevents
+the reader from seeing the incorrect head page.
+
+
+(first writer)
+
+               A        B    tail page
+               |        |        |
+               v        v        v
+    +---+    +---+    +---+    +---+
+<---|   |--->|   |--->|   |--->|   |-H->
+--->|   |<---|   |<---|   |<---|   |<---
+    +---+    +---+    +---+    +---+
+
diff --git a/arch/Kconfig b/arch/Kconfig
index 99193b160232..beea3ccebb5e 100644
--- a/arch/Kconfig
+++ b/arch/Kconfig
@@ -30,6 +30,18 @@ config OPROFILE_IBS
 
           If unsure, say N.
 
+config OPROFILE_EVENT_MULTIPLEX
+        bool "OProfile multiplexing support (EXPERIMENTAL)"
+        default n
+        depends on OPROFILE && X86
+        help
+          The number of hardware counters is limited. The multiplexing
+          feature enables OProfile to gather more events than counters
+          are provided by the hardware. This is realized by switching
+          between events at an user specified time interval.
+
+          If unsure, say N.
+
 config HAVE_OPROFILE
         bool
 
diff --git a/arch/ia64/include/asm/dma-mapping.h b/arch/ia64/include/asm/dma-mapping.h
index 5a61b5c2e18f..8d3c79cd81e7 100644
--- a/arch/ia64/include/asm/dma-mapping.h
+++ b/arch/ia64/include/asm/dma-mapping.h
@@ -44,7 +44,6 @@ static inline void dma_free_coherent(struct device *dev, size_t size,
 #define dma_free_noncoherent(d, s, v, h) dma_free_coherent(d, s, v, h)
 
 #define get_dma_ops(dev) platform_dma_get_ops(dev)
-#define flush_write_buffers()
 
 #include <asm-generic/dma-mapping-common.h>
 
@@ -69,6 +68,24 @@ dma_set_mask (struct device *dev, u64 mask)
         return 0;
 }
 
+static inline bool dma_capable(struct device *dev, dma_addr_t addr, size_t size)
+{
+        if (!dev->dma_mask)
+                return 0;
+
+        return addr + size <= *dev->dma_mask;
+}
+
+static inline dma_addr_t phys_to_dma(struct device *dev, phys_addr_t paddr)
+{
+        return paddr;
+}
+
+static inline phys_addr_t dma_to_phys(struct device *dev, dma_addr_t daddr)
+{
+        return daddr;
+}
+
 extern int dma_get_cache_alignment(void);
 
 static inline void
diff --git a/arch/ia64/xen/time.c b/arch/ia64/xen/time.c
index fb8332690179..dbeadb9c8e20 100644
--- a/arch/ia64/xen/time.c
+++ b/arch/ia64/xen/time.c
@@ -133,8 +133,7 @@ consider_steal_time(unsigned long new_itm)
                 account_idle_ticks(blocked);
                 run_local_timers();
 
-                if (rcu_pending(cpu))
-                        rcu_check_callbacks(cpu, user_mode(get_irq_regs()));
+                rcu_check_callbacks(cpu, user_mode(get_irq_regs()));
 
                 scheduler_tick();
                 run_posix_cpu_timers(p);
diff --git a/arch/m68k/include/asm/entry_mm.h b/arch/m68k/include/asm/entry_mm.h
index 5202f5a5b420..474125886218 100644
--- a/arch/m68k/include/asm/entry_mm.h
+++ b/arch/m68k/include/asm/entry_mm.h
@@ -46,7 +46,6 @@
 #define curptr a2
 
 LFLUSH_I_AND_D = 0x00000808
-LSIGTRAP = 5
 
 /* process bits for task_struct.ptrace */
 PT_TRACESYS_OFF = 3
@@ -118,9 +117,6 @@ PT_DTRACE_BIT = 2
 #define STR(X) STR1(X)
 #define STR1(X) #X
 
-#define PT_OFF_ORIG_D0   0x24
-#define PT_OFF_FORMATVEC 0x32
-#define PT_OFF_SR        0x2C
 #define SAVE_ALL_INT                            \
         "clrl   %%sp@-;"    /* stk_adj */       \
         "pea    -1:w;"      /* orig d0 = -1 */  \
diff --git a/arch/m68k/include/asm/entry_no.h b/arch/m68k/include/asm/entry_no.h
index c2553d26273d..907ed03d792f 100644
--- a/arch/m68k/include/asm/entry_no.h
+++ b/arch/m68k/include/asm/entry_no.h
@@ -72,8 +72,8 @@ LENOSYS = 38
         lea     %sp@(-32),%sp           /* space for 8 regs */
         moveml  %d1-%d5/%a0-%a2,%sp@
         movel   sw_usp,%a0              /* get usp */
-        movel   %a0@-,%sp@(PT_PC)       /* copy exception program counter */
-        movel   %a0@-,%sp@(PT_FORMATVEC)/* copy exception format/vector/sr */
+        movel   %a0@-,%sp@(PT_OFF_PC)   /* copy exception program counter */
+        movel   %a0@-,%sp@(PT_OFF_FORMATVEC)/*copy exception format/vector/sr */
         bra     7f
         6:
         clrl    %sp@-                   /* stkadj */
@@ -89,8 +89,8 @@ LENOSYS = 38
         bnes    8f                      /* no, skip */
         move    #0x2700,%sr             /* disable intrs */
         movel   sw_usp,%a0              /* get usp */
-        movel   %sp@(PT_PC),%a0@-       /* copy exception program counter */
-        movel   %sp@(PT_FORMATVEC),%a0@-/* copy exception format/vector/sr */
+        movel   %sp@(PT_OFF_PC),%a0@-   /* copy exception program counter */
+        movel   %sp@(PT_OFF_FORMATVEC),%a0@-/*copy exception format/vector/sr */
         moveml  %sp@,%d1-%d5/%a0-%a2
         lea     %sp@(32),%sp            /* space for 8 regs */
         movel   %sp@+,%d0
diff --git a/arch/m68k/include/asm/math-emu.h b/arch/m68k/include/asm/math-emu.h
index ddfab96403cb..5e9249b0014c 100644
--- a/arch/m68k/include/asm/math-emu.h
+++ b/arch/m68k/include/asm/math-emu.h
@@ -145,16 +145,16 @@ extern unsigned int fp_debugprint;
  * these are only used during instruction decoding
  * where we always know how deep we're on the stack.
  */
-#define FPS_DO          (PT_D0)
-#define FPS_D1          (PT_D1)
-#define FPS_D2          (PT_D2)
-#define FPS_A0          (PT_A0)
-#define FPS_A1          (PT_A1)
-#define FPS_A2          (PT_A2)
-#define FPS_SR          (PT_SR)
-#define FPS_PC          (PT_PC)
-#define FPS_EA          (PT_PC+6)
-#define FPS_PC2         (PT_PC+10)
+#define FPS_DO          (PT_OFF_D0)
+#define FPS_D1          (PT_OFF_D1)
+#define FPS_D2          (PT_OFF_D2)
+#define FPS_A0          (PT_OFF_A0)
+#define FPS_A1          (PT_OFF_A1)
+#define FPS_A2          (PT_OFF_A2)
+#define FPS_SR          (PT_OFF_SR)
+#define FPS_PC          (PT_OFF_PC)
+#define FPS_EA          (PT_OFF_PC+6)
+#define FPS_PC2         (PT_OFF_PC+10)
 
 .macro  fp_get_fp_reg
         lea     (FPD_FPREG,FPDATA,%d0.w*4),%a0
diff --git a/arch/m68k/include/asm/thread_info_mm.h b/arch/m68k/include/asm/thread_info_mm.h
index 6ea5c33b3c56..b6da3882be9b 100644
--- a/arch/m68k/include/asm/thread_info_mm.h
+++ b/arch/m68k/include/asm/thread_info_mm.h
@@ -1,6 +1,10 @@
 #ifndef _ASM_M68K_THREAD_INFO_H
 #define _ASM_M68K_THREAD_INFO_H
 
+#ifndef ASM_OFFSETS_C
+#include <asm/asm-offsets.h>
+#endif
+#include <asm/current.h>
 #include <asm/types.h>
 #include <asm/page.h>
 
@@ -31,7 +35,12 @@ struct thread_info {
 #define init_thread_info        (init_task.thread.info)
 #define init_stack              (init_thread_union.stack)
 
-#define task_thread_info(tsk)   (&(tsk)->thread.info)
+#ifdef ASM_OFFSETS_C
+#define task_thread_info(tsk)   ((struct thread_info *) NULL)
+#else
+#define task_thread_info(tsk)   ((struct thread_info *)((char *)tsk+TASK_TINFO))
+#endif
+
 #define task_stack_page(tsk)    ((tsk)->stack)
 #define current_thread_info()   task_thread_info(current)
 
diff --git a/arch/m68k/kernel/asm-offsets.c b/arch/m68k/kernel/asm-offsets.c
index b1f012f6c493..73e5e581245b 100644
--- a/arch/m68k/kernel/asm-offsets.c
+++ b/arch/m68k/kernel/asm-offsets.c
@@ -8,6 +8,8 @@
  * #defines from the assembly-language output.
  */
 
+#define ASM_OFFSETS_C
+
 #include <linux/stddef.h>
 #include <linux/sched.h>
 #include <linux/kernel_stat.h>
@@ -27,6 +29,9 @@ int main(void)
         DEFINE(TASK_INFO, offsetof(struct task_struct, thread.info));
         DEFINE(TASK_MM, offsetof(struct task_struct, mm));
         DEFINE(TASK_ACTIVE_MM, offsetof(struct task_struct, active_mm));
+#ifdef CONFIG_MMU
+        DEFINE(TASK_TINFO, offsetof(struct task_struct, thread.info));
+#endif
 
         /* offsets into the thread struct */
         DEFINE(THREAD_KSP, offsetof(struct thread_struct, ksp));
@@ -44,20 +49,20 @@ int main(void)
         DEFINE(TINFO_FLAGS, offsetof(struct thread_info, flags));
 
         /* offsets into the pt_regs */
-        DEFINE(PT_D0, offsetof(struct pt_regs, d0));
-        DEFINE(PT_ORIG_D0, offsetof(struct pt_regs, orig_d0));
-        DEFINE(PT_D1, offsetof(struct pt_regs, d1));
-        DEFINE(PT_D2, offsetof(struct pt_regs, d2));
-        DEFINE(PT_D3, offsetof(struct pt_regs, d3));
-        DEFINE(PT_D4, offsetof(struct pt_regs, d4));
-        DEFINE(PT_D5, offsetof(struct pt_regs, d5));
-        DEFINE(PT_A0, offsetof(struct pt_regs, a0));
-        DEFINE(PT_A1, offsetof(struct pt_regs, a1));
-        DEFINE(PT_A2, offsetof(struct pt_regs, a2));
-        DEFINE(PT_PC, offsetof(struct pt_regs, pc));
-        DEFINE(PT_SR, offsetof(struct pt_regs, sr));
+        DEFINE(PT_OFF_D0, offsetof(struct pt_regs, d0));
+        DEFINE(PT_OFF_ORIG_D0, offsetof(struct pt_regs, orig_d0));
+        DEFINE(PT_OFF_D1, offsetof(struct pt_regs, d1));
+        DEFINE(PT_OFF_D2, offsetof(struct pt_regs, d2));
+        DEFINE(PT_OFF_D3, offsetof(struct pt_regs, d3));
+        DEFINE(PT_OFF_D4, offsetof(struct pt_regs, d4));
+        DEFINE(PT_OFF_D5, offsetof(struct pt_regs, d5));
+        DEFINE(PT_OFF_A0, offsetof(struct pt_regs, a0));
+        DEFINE(PT_OFF_A1, offsetof(struct pt_regs, a1));
+        DEFINE(PT_OFF_A2, offsetof(struct pt_regs, a2));
+        DEFINE(PT_OFF_PC, offsetof(struct pt_regs, pc));
+        DEFINE(PT_OFF_SR, offsetof(struct pt_regs, sr));
         /* bitfields are a bit difficult */
-        DEFINE(PT_VECTOR, offsetof(struct pt_regs, pc) + 4);
+        DEFINE(PT_OFF_FORMATVEC, offsetof(struct pt_regs, pc) + 4);
 
         /* offsets into the irq_handler struct */
         DEFINE(IRQ_HANDLER, offsetof(struct irq_node, handler));
@@ -84,10 +89,10 @@ int main(void)
         DEFINE(FONT_DESC_PREF, offsetof(struct font_desc, pref));
 
         /* signal defines */
-        DEFINE(SIGSEGV, SIGSEGV);
-        DEFINE(SEGV_MAPERR, SEGV_MAPERR);
-        DEFINE(SIGTRAP, SIGTRAP);
-        DEFINE(TRAP_TRACE, TRAP_TRACE);
+        DEFINE(LSIGSEGV, SIGSEGV);
+        DEFINE(LSEGV_MAPERR, SEGV_MAPERR);
+        DEFINE(LSIGTRAP, SIGTRAP);
+        DEFINE(LTRAP_TRACE, TRAP_TRACE);
 
         /* offsets into the custom struct */
         DEFINE(CUSTOMBASE, &amiga_custom);
diff --git a/arch/m68k/kernel/entry.S b/arch/m68k/kernel/entry.S
index c3735cd6207e..922f52e7ed1a 100644
--- a/arch/m68k/kernel/entry.S
+++ b/arch/m68k/kernel/entry.S
@@ -77,17 +77,17 @@ ENTRY(ret_from_fork)
         jra     .Lret_from_exception
 
 do_trace_entry:
-        movel   #-ENOSYS,%sp@(PT_D0)    | needed for strace
+        movel   #-ENOSYS,%sp@(PT_OFF_D0)| needed for strace
         subql   #4,%sp
         SAVE_SWITCH_STACK
         jbsr    syscall_trace
         RESTORE_SWITCH_STACK
         addql   #4,%sp
-        movel   %sp@(PT_ORIG_D0),%d0
+        movel   %sp@(PT_OFF_ORIG_D0),%d0
         cmpl    #NR_syscalls,%d0
         jcs     syscall
 badsys:
-        movel   #-ENOSYS,%sp@(PT_D0)
+        movel   #-ENOSYS,%sp@(PT_OFF_D0)
         jra     ret_from_syscall
 
 do_trace_exit:
@@ -103,7 +103,7 @@ ENTRY(ret_from_signal)
         addql   #4,%sp
 /* on 68040 complete pending writebacks if any */
 #ifdef CONFIG_M68040
-        bfextu  %sp@(PT_VECTOR){#0,#4},%d0
+        bfextu  %sp@(PT_OFF_FORMATVEC){#0,#4},%d0
         subql   #7,%d0                          | bus error frame ?
         jbne    1f
         movel   %sp,%sp@-
@@ -127,7 +127,7 @@ ENTRY(system_call)
         jcc     badsys
 syscall:
         jbsr    @(sys_call_table,%d0:l:4)@(0)
-        movel   %d0,%sp@(PT_D0)         | save the return value
+        movel   %d0,%sp@(PT_OFF_D0)     | save the return value
 ret_from_syscall:
         |oriw   #0x0700,%sr
         movew   %curptr@(TASK_INFO+TINFO_FLAGS+2),%d0
@@ -135,7 +135,7 @@ ret_from_syscall:
 1:      RESTORE_ALL
 
 syscall_exit_work:
-        btst    #5,%sp@(PT_SR)          | check if returning to kernel
+        btst    #5,%sp@(PT_OFF_SR)      | check if returning to kernel
         bnes    1b                      | if so, skip resched, signals
         lslw    #1,%d0
         jcs     do_trace_exit
@@ -148,7 +148,7 @@ syscall_exit_work:
 
 ENTRY(ret_from_exception)
 .Lret_from_exception:
-        btst    #5,%sp@(PT_SR)          | check if returning to kernel
+        btst    #5,%sp@(PT_OFF_SR)      | check if returning to kernel
         bnes    1f                      | if so, skip resched, signals
         | only allow interrupts when we are really the last one on the
         | kernel stack, otherwise stack overflow can occur during
@@ -182,7 +182,7 @@ do_signal_return:
         jbra    resume_userspace
 
 do_delayed_trace:
-        bclr    #7,%sp@(PT_SR)          | clear trace bit in SR
+        bclr    #7,%sp@(PT_OFF_SR)      | clear trace bit in SR
         pea     1                       | send SIGTRAP
         movel   %curptr,%sp@-
         pea     LSIGTRAP
@@ -199,7 +199,7 @@ ENTRY(auto_inthandler)
         GET_CURRENT(%d0)
         addqb   #1,%curptr@(TASK_INFO+TINFO_PREEMPT+1)
                                         |  put exception # in d0
-        bfextu  %sp@(PT_VECTOR){#4,#10},%d0
+        bfextu  %sp@(PT_OFF_FORMATVEC){#4,#10},%d0
         subw    #VEC_SPUR,%d0
 
         movel   %sp,%sp@-
@@ -216,7 +216,7 @@ ret_from_interrupt:
         ALIGN
 ret_from_last_interrupt:
         moveq   #(~ALLOWINT>>8)&0xff,%d0
-        andb    %sp@(PT_SR),%d0
+        andb    %sp@(PT_OFF_SR),%d0
         jne     2b
 
         /* check if we need to do software interrupts */
@@ -232,7 +232,7 @@ ENTRY(user_inthandler)
         GET_CURRENT(%d0)
         addqb   #1,%curptr@(TASK_INFO+TINFO_PREEMPT+1)
                                         |  put exception # in d0
-        bfextu  %sp@(PT_VECTOR){#4,#10},%d0
+        bfextu  %sp@(PT_OFF_FORMATVEC){#4,#10},%d0
 user_irqvec_fixup = . + 2
         subw    #VEC_USER,%d0
 
diff --git a/arch/m68k/math-emu/fp_entry.S b/arch/m68k/math-emu/fp_entry.S
index 954b4f304a7d..a3fe1f348dfe 100644
--- a/arch/m68k/math-emu/fp_entry.S
+++ b/arch/m68k/math-emu/fp_entry.S
@@ -85,8 +85,8 @@ fp_err_ua2:
 fp_err_ua1:
         addq.l  #4,%sp
         move.l  %a0,-(%sp)
-        pea     SEGV_MAPERR
-        pea     SIGSEGV
+        pea     LSEGV_MAPERR
+        pea     LSIGSEGV
         jsr     fpemu_signal
         add.w   #12,%sp
         jra     ret_from_exception
@@ -96,8 +96,8 @@ fp_err_ua1:
         | it does not really belong here, but...
 fp_sendtrace060:
         move.l  (FPS_PC,%sp),-(%sp)
-        pea     TRAP_TRACE
-        pea     SIGTRAP
+        pea     LTRAP_TRACE
+        pea     LSIGTRAP
         jsr     fpemu_signal
         add.w   #12,%sp
         jra     ret_from_exception
@@ -122,17 +122,17 @@ fp_get_data_reg:
         .long   fp_get_d6, fp_get_d7
 
 fp_get_d0:
-        move.l  (PT_D0+8,%sp),%d0
+        move.l  (PT_OFF_D0+8,%sp),%d0
         printf  PREGISTER,"{d0->%08x}",1,%d0
         rts
 
 fp_get_d1:
-        move.l  (PT_D1+8,%sp),%d0
+        move.l  (PT_OFF_D1+8,%sp),%d0
         printf  PREGISTER,"{d1->%08x}",1,%d0
         rts
 
 fp_get_d2:
-        move.l  (PT_D2+8,%sp),%d0
+        move.l  (PT_OFF_D2+8,%sp),%d0
         printf  PREGISTER,"{d2->%08x}",1,%d0
         rts
 
@@ -173,35 +173,35 @@ fp_put_data_reg:
 
 fp_put_d0:
         printf  PREGISTER,"{d0<-%08x}",1,%d0
-        move.l  %d0,(PT_D0+8,%sp)
+        move.l  %d0,(PT_OFF_D0+8,%sp)
         rts
 
 fp_put_d1:
         printf  PREGISTER,"{d1<-%08x}",1,%d0
-        move.l  %d0,(PT_D1+8,%sp)
+        move.l  %d0,(PT_OFF_D1+8,%sp)
         rts
 
 fp_put_d2:
         printf  PREGISTER,"{d2<-%08x}",1,%d0
-        move.l  %d0,(PT_D2+8,%sp)
+        move.l  %d0,(PT_OFF_D2+8,%sp)
         rts
 
 fp_put_d3:
         printf  PREGISTER,"{d3<-%08x}",1,%d0
 |       move.l  %d0,%d3
-        move.l  %d0,(PT_D3+8,%sp)
+        move.l  %d0,(PT_OFF_D3+8,%sp)
         rts
 
 fp_put_d4:
         printf  PREGISTER,"{d4<-%08x}",1,%d0
 |       move.l  %d0,%d4
-        move.l  %d0,(PT_D4+8,%sp)
+        move.l  %d0,(PT_OFF_D4+8,%sp)
         rts
 
 fp_put_d5:
         printf  PREGISTER,"{d5<-%08x}",1,%d0
 |       move.l  %d0,%d5
-        move.l  %d0,(PT_D5+8,%sp)
+        move.l  %d0,(PT_OFF_D5+8,%sp)
         rts
 
 fp_put_d6:
@@ -225,17 +225,17 @@ fp_get_addr_reg:
         .long   fp_get_a6, fp_get_a7
 
 fp_get_a0:
-        move.l  (PT_A0+8,%sp),%a0
+        move.l  (PT_OFF_A0+8,%sp),%a0
         printf  PREGISTER,"{a0->%08x}",1,%a0
         rts
 
 fp_get_a1:
-        move.l  (PT_A1+8,%sp),%a0
+        move.l  (PT_OFF_A1+8,%sp),%a0
         printf  PREGISTER,"{a1->%08x}",1,%a0
         rts
 
 fp_get_a2:
-        move.l  (PT_A2+8,%sp),%a0
+        move.l  (PT_OFF_A2+8,%sp),%a0
         printf  PREGISTER,"{a2->%08x}",1,%a0
         rts
 
@@ -276,17 +276,17 @@ fp_put_addr_reg:
 
 fp_put_a0:
         printf  PREGISTER,"{a0<-%08x}",1,%a0
-        move.l  %a0,(PT_A0+8,%sp)
+        move.l  %a0,(PT_OFF_A0+8,%sp)
         rts
 
 fp_put_a1:
         printf  PREGISTER,"{a1<-%08x}",1,%a0
-        move.l  %a0,(PT_A1+8,%sp)
+        move.l  %a0,(PT_OFF_A1+8,%sp)
         rts
 
 fp_put_a2:
         printf  PREGISTER,"{a2<-%08x}",1,%a0
-        move.l  %a0,(PT_A2+8,%sp)
+        move.l  %a0,(PT_OFF_A2+8,%sp)
         rts
 
 fp_put_a3:
diff --git a/arch/powerpc/include/asm/dma-mapping.h b/arch/powerpc/include/asm/dma-mapping.h
index b44aaabdd1a6..0c34371ec49c 100644
--- a/arch/powerpc/include/asm/dma-mapping.h
+++ b/arch/powerpc/include/asm/dma-mapping.h
@@ -424,6 +424,29 @@ static inline int dma_mapping_error(struct device *dev, dma_addr_t dma_addr)
 #endif
 }
 
+static inline bool dma_capable(struct device *dev, dma_addr_t addr, size_t size)
+{
+        struct dma_mapping_ops *ops = get_dma_ops(dev);
+
+        if (ops->addr_needs_map && ops->addr_needs_map(dev, addr, size))
+                return 0;
+
+        if (!dev->dma_mask)
+                return 0;
+
+        return addr + size <= *dev->dma_mask;
+}
+
+static inline dma_addr_t phys_to_dma(struct device *dev, phys_addr_t paddr)
+{
+        return paddr + get_dma_direct_offset(dev);
+}
+
+static inline phys_addr_t dma_to_phys(struct device *dev, dma_addr_t daddr)
+{
+        return daddr - get_dma_direct_offset(dev);
+}
+
 #define dma_alloc_noncoherent(d, s, h, f) dma_alloc_coherent(d, s, h, f)
 #define dma_free_noncoherent(d, s, v, h) dma_free_coherent(d, s, v, h)
 #ifdef CONFIG_NOT_COHERENT_CACHE
diff --git a/arch/powerpc/include/asm/pgtable.h b/arch/powerpc/include/asm/pgtable.h
index eb17da781128..2a5da069714e 100644
--- a/arch/powerpc/include/asm/pgtable.h
+++ b/arch/powerpc/include/asm/pgtable.h
@@ -104,8 +104,8 @@ static inline void __set_pte_at(struct mm_struct *mm, unsigned long addr,
         else
                 pte_update(ptep, ~_PAGE_HASHPTE, pte_val(pte));
 
-#elif defined(CONFIG_PPC32) && defined(CONFIG_PTE_64BIT) && defined(CONFIG_SMP)
-        /* Second case is 32-bit with 64-bit PTE in SMP mode. In this case, we
+#elif defined(CONFIG_PPC32) && defined(CONFIG_PTE_64BIT)
+        /* Second case is 32-bit with 64-bit PTE.  In this case, we
          * can just store as long as we do the two halves in the right order
          * with a barrier in between. This is possible because we take care,
          * in the hash code, to pre-invalidate if the PTE was already hashed,
@@ -140,7 +140,7 @@ static inline void __set_pte_at(struct mm_struct *mm, unsigned long addr,
 
 #else
         /* Anything else just stores the PTE normally. That covers all 64-bit
-         * cases, and 32-bit non-hash with 64-bit PTEs in UP mode
+         * cases, and 32-bit non-hash with 32-bit PTEs.
          */
         *ptep = pte;
 #endif
diff --git a/arch/powerpc/include/asm/spinlock.h b/arch/powerpc/include/asm/spinlock.h
index c3b193121f81..198266cf9e2d 100644
--- a/arch/powerpc/include/asm/spinlock.h
+++ b/arch/powerpc/include/asm/spinlock.h
@@ -54,7 +54,7 @@
  * This returns the old value in the lock, so we succeeded
  * in getting the lock if the return value is 0.
  */
-static inline unsigned long __spin_trylock(raw_spinlock_t *lock)
+static inline unsigned long arch_spin_trylock(raw_spinlock_t *lock)
 {
         unsigned long tmp, token;
 
@@ -76,7 +76,7 @@ static inline unsigned long __spin_trylock(raw_spinlock_t *lock)
 static inline int __raw_spin_trylock(raw_spinlock_t *lock)
 {
         CLEAR_IO_SYNC;
-        return __spin_trylock(lock) == 0;
+        return arch_spin_trylock(lock) == 0;
 }
 
 /*
@@ -108,7 +108,7 @@ static inline void __raw_spin_lock(raw_spinlock_t *lock)
 {
         CLEAR_IO_SYNC;
         while (1) {
-                if (likely(__spin_trylock(lock) == 0))
+                if (likely(arch_spin_trylock(lock) == 0))
                         break;
                 do {
                         HMT_low();
@@ -126,7 +126,7 @@ void __raw_spin_lock_flags(raw_spinlock_t *lock, unsigned long flags)
 
         CLEAR_IO_SYNC;
         while (1) {
-                if (likely(__spin_trylock(lock) == 0))
+                if (likely(arch_spin_trylock(lock) == 0))
                         break;
                 local_save_flags(flags_dis);
                 local_irq_restore(flags);
@@ -181,7 +181,7 @@ extern void __raw_spin_unlock_wait(raw_spinlock_t *lock);
  * This returns the old value in the lock + 1,
  * so we got a read lock if the return value is > 0.
  */
-static inline long __read_trylock(raw_rwlock_t *rw)
+static inline long arch_read_trylock(raw_rwlock_t *rw)
 {
         long tmp;
 
@@ -205,7 +205,7 @@ static inline long __read_trylock(raw_rwlock_t *rw)
  * This returns the old value in the lock,
  * so we got the write lock if the return value is 0.
  */
-static inline long __write_trylock(raw_rwlock_t *rw)
+static inline long arch_write_trylock(raw_rwlock_t *rw)
 {
         long tmp, token;
 
@@ -228,7 +228,7 @@ static inline long __write_trylock(raw_rwlock_t *rw)
 static inline void __raw_read_lock(raw_rwlock_t *rw)
 {
         while (1) {
-                if (likely(__read_trylock(rw) > 0))
+                if (likely(arch_read_trylock(rw) > 0))
                         break;
                 do {
                         HMT_low();
@@ -242,7 +242,7 @@ static inline void __raw_read_lock(raw_rwlock_t *rw)
 static inline void __raw_write_lock(raw_rwlock_t *rw)
 {
         while (1) {
-                if (likely(__write_trylock(rw) == 0))
+                if (likely(arch_write_trylock(rw) == 0))
                         break;
                 do {
                         HMT_low();
@@ -255,12 +255,12 @@ static inline void __raw_write_lock(raw_rwlock_t *rw)
 
 static inline int __raw_read_trylock(raw_rwlock_t *rw)
 {
-        return __read_trylock(rw) > 0;
+        return arch_read_trylock(rw) > 0;
 }
 
 static inline int __raw_write_trylock(raw_rwlock_t *rw)
 {
-        return __write_trylock(rw) == 0;
+        return arch_write_trylock(rw) == 0;
 }
 
 static inline void __raw_read_unlock(raw_rwlock_t *rw)
diff --git a/arch/powerpc/kernel/Makefile b/arch/powerpc/kernel/Makefile
index b73396b93905..9619285f64e8 100644
--- a/arch/powerpc/kernel/Makefile
+++ b/arch/powerpc/kernel/Makefile
@@ -97,7 +97,7 @@ obj64-$(CONFIG_AUDIT)		+= compat_audit.o
 
 obj-$(CONFIG_DYNAMIC_FTRACE)    += ftrace.o
 obj-$(CONFIG_FUNCTION_GRAPH_TRACER)     += ftrace.o
-obj-$(CONFIG_PPC_PERF_CTRS)     += perf_counter.o
+obj-$(CONFIG_PPC_PERF_CTRS)     += perf_counter.o perf_callchain.o
 obj64-$(CONFIG_PPC_PERF_CTRS)   += power4-pmu.o ppc970-pmu.o power5-pmu.o \
                                    power5+-pmu.o power6-pmu.o power7-pmu.o
 obj32-$(CONFIG_PPC_PERF_CTRS)   += mpc7450-pmu.o
diff --git a/arch/powerpc/kernel/asm-offsets.c b/arch/powerpc/kernel/asm-offsets.c
index 561b64652311..197b15646eeb 100644
--- a/arch/powerpc/kernel/asm-offsets.c
+++ b/arch/powerpc/kernel/asm-offsets.c
@@ -67,6 +67,8 @@ int main(void)
         DEFINE(MMCONTEXTID, offsetof(struct mm_struct, context.id));
 #ifdef CONFIG_PPC64
         DEFINE(AUDITCONTEXT, offsetof(struct task_struct, audit_context));
+        DEFINE(SIGSEGV, SIGSEGV);
+        DEFINE(NMI_MASK, NMI_MASK);
 #else
         DEFINE(THREAD_INFO, offsetof(struct task_struct, stack));
 #endif /* CONFIG_PPC64 */
diff --git a/arch/powerpc/kernel/dma-swiotlb.c b/arch/powerpc/kernel/dma-swiotlb.c
index 68ccf11e4f19..e8a57de85bcf 100644
--- a/arch/powerpc/kernel/dma-swiotlb.c
+++ b/arch/powerpc/kernel/dma-swiotlb.c
@@ -24,50 +24,12 @@
 int swiotlb __read_mostly;
 unsigned int ppc_swiotlb_enable;
 
-void *swiotlb_bus_to_virt(struct device *hwdev, dma_addr_t addr)
-{
-        unsigned long pfn = PFN_DOWN(swiotlb_bus_to_phys(hwdev, addr));
-        void *pageaddr = page_address(pfn_to_page(pfn));
-
-        if (pageaddr != NULL)
-                return pageaddr + (addr % PAGE_SIZE);
-        return NULL;
-}
-
-dma_addr_t swiotlb_phys_to_bus(struct device *hwdev, phys_addr_t paddr)
-{
-        return paddr + get_dma_direct_offset(hwdev);
-}
-
-phys_addr_t swiotlb_bus_to_phys(struct device *hwdev, dma_addr_t baddr)
-
-{
-        return baddr - get_dma_direct_offset(hwdev);
-}
-
-/*
- * Determine if an address needs bounce buffering via swiotlb.
- * Going forward I expect the swiotlb code to generalize on using
- * a dma_ops->addr_needs_map, and this function will move from here to the
- * generic swiotlb code.
- */
-int
-swiotlb_arch_address_needs_mapping(struct device *hwdev, dma_addr_t addr,
-                                   size_t size)
-{
-        struct dma_mapping_ops *dma_ops = get_dma_ops(hwdev);
-
-        BUG_ON(!dma_ops);
-        return dma_ops->addr_needs_map(hwdev, addr, size);
-}
-
 /*
  * Determine if an address is reachable by a pci device, or if we must bounce.
  */
 static int
 swiotlb_pci_addr_needs_map(struct device *hwdev, dma_addr_t addr, size_t size)
 {
-        u64 mask = dma_get_mask(hwdev);
         dma_addr_t max;
         struct pci_controller *hose;
         struct pci_dev *pdev = to_pci_dev(hwdev);
@@ -79,16 +41,9 @@ swiotlb_pci_addr_needs_map(struct device *hwdev, dma_addr_t addr, size_t size)
         if ((addr + size > max) | (addr < hose->dma_window_base_cur))
                 return 1;
 
-        return !is_buffer_dma_capable(mask, addr, size);
-}
-
-static int
-swiotlb_addr_needs_map(struct device *hwdev, dma_addr_t addr, size_t size)
-{
-        return !is_buffer_dma_capable(dma_get_mask(hwdev), addr, size);
+        return 0;
 }
 
-
 /*
  * At the moment, all platforms that use this code only require
  * swiotlb to be used if we're operating on HIGHMEM.  Since
@@ -104,7 +59,6 @@ struct dma_mapping_ops swiotlb_dma_ops = {
         .dma_supported = swiotlb_dma_supported,
         .map_page = swiotlb_map_page,
         .unmap_page = swiotlb_unmap_page,
-        .addr_needs_map = swiotlb_addr_needs_map,
         .sync_single_range_for_cpu = swiotlb_sync_single_range_for_cpu,
         .sync_single_range_for_device = swiotlb_sync_single_range_for_device,
         .sync_sg_for_cpu = swiotlb_sync_sg_for_cpu,
diff --git a/arch/powerpc/kernel/exceptions-64s.S b/arch/powerpc/kernel/exceptions-64s.S
index eb898112e577..8ac85e08ffae 100644
--- a/arch/powerpc/kernel/exceptions-64s.S
+++ b/arch/powerpc/kernel/exceptions-64s.S
@@ -729,6 +729,11 @@ BEGIN_FTR_SECTION
         bne-    do_ste_alloc            /* If so handle it */
 END_FTR_SECTION_IFCLR(CPU_FTR_SLB)
 
+        clrrdi  r11,r1,THREAD_SHIFT
+        lwz     r0,TI_PREEMPT(r11)      /* If we're in an "NMI" */
+        andis.  r0,r0,NMI_MASK@h        /* (i.e. an irq when soft-disabled) */
+        bne     77f                     /* then don't call hash_page now */
+
         /*
          * On iSeries, we soft-disable interrupts here, then
          * hard-enable interrupts so that the hash_page code can spin on
@@ -833,6 +838,20 @@ handle_page_fault:
         bl      .low_hash_fault
         b       .ret_from_except
 
+/*
+ * We come here as a result of a DSI at a point where we don't want
+ * to call hash_page, such as when we are accessing memory (possibly
+ * user memory) inside a PMU interrupt that occurred while interrupts
+ * were soft-disabled.  We want to invoke the exception handler for
+ * the access, or panic if there isn't a handler.
+ */
+77:     bl      .save_nvgprs
+        mr      r4,r3
+        addi    r3,r1,STACK_FRAME_OVERHEAD
+        li      r5,SIGSEGV
+        bl      .bad_page_fault
+        b       .ret_from_except
+
         /* here we have a segment miss */
 do_ste_alloc:
         bl      .ste_allocate           /* try to insert stab entry */
diff --git a/arch/powerpc/kernel/perf_callchain.c b/arch/powerpc/kernel/perf_callchain.c
new file mode 100644
index 000000000000..f74b62c67511
--- /dev/null
+++ b/arch/powerpc/kernel/perf_callchain.c
@@ -0,0 +1,527 @@
+/*
+ * Performance counter callchain support - powerpc architecture code
+ *
+ * Copyright © 2009 Paul Mackerras, IBM Corporation.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version
+ * 2 of the License, or (at your option) any later version.
+ */
+#include <linux/kernel.h>
+#include <linux/sched.h>
+#include <linux/perf_counter.h>
+#include <linux/percpu.h>
+#include <linux/uaccess.h>
+#include <linux/mm.h>
+#include <asm/ptrace.h>
+#include <asm/pgtable.h>
+#include <asm/sigcontext.h>
+#include <asm/ucontext.h>
+#include <asm/vdso.h>
+#ifdef CONFIG_PPC64
+#include "ppc32.h"
+#endif
+
+/*
+ * Store another value in a callchain_entry.
+ */
+static inline void callchain_store(struct perf_callchain_entry *entry, u64 ip)
+{
+        unsigned int nr = entry->nr;
+
+        if (nr < PERF_MAX_STACK_DEPTH) {
+                entry->ip[nr] = ip;
+                entry->nr = nr + 1;
+        }
+}
+
+/*
+ * Is sp valid as the address of the next kernel stack frame after prev_sp?
+ * The next frame may be in a different stack area but should not go
+ * back down in the same stack area.
+ */
+static int valid_next_sp(unsigned long sp, unsigned long prev_sp)
+{
+        if (sp & 0xf)
+                return 0;               /* must be 16-byte aligned */
+        if (!validate_sp(sp, current, STACK_FRAME_OVERHEAD))
+                return 0;
+        if (sp >= prev_sp + STACK_FRAME_OVERHEAD)
+                return 1;
+        /*
+         * sp could decrease when we jump off an interrupt stack
+         * back to the regular process stack.
+         */
+        if ((sp & ~(THREAD_SIZE - 1)) != (prev_sp & ~(THREAD_SIZE - 1)))
+                return 1;
+        return 0;
+}
+
+static void perf_callchain_kernel(struct pt_regs *regs,
+                                  struct perf_callchain_entry *entry)
+{
+        unsigned long sp, next_sp;
+        unsigned long next_ip;
+        unsigned long lr;
+        long level = 0;
+        unsigned long *fp;
+
+        lr = regs->link;
+        sp = regs->gpr[1];
+        callchain_store(entry, PERF_CONTEXT_KERNEL);
+        callchain_store(entry, regs->nip);
+
+        if (!validate_sp(sp, current, STACK_FRAME_OVERHEAD))
+                return;
+
+        for (;;) {
+                fp = (unsigned long *) sp;
+                next_sp = fp[0];
+
+                if (next_sp == sp + STACK_INT_FRAME_SIZE &&
+                    fp[STACK_FRAME_MARKER] == STACK_FRAME_REGS_MARKER) {
+                        /*
+                         * This looks like an interrupt frame for an
+                         * interrupt that occurred in the kernel
+                         */
+                        regs = (struct pt_regs *)(sp + STACK_FRAME_OVERHEAD);
+                        next_ip = regs->nip;
+                        lr = regs->link;
+                        level = 0;
+                        callchain_store(entry, PERF_CONTEXT_KERNEL);
+
+                } else {
+                        if (level == 0)
+                                next_ip = lr;
+                        else
+                                next_ip = fp[STACK_FRAME_LR_SAVE];
+
+                        /*
+                         * We can't tell which of the first two addresses
+                         * we get are valid, but we can filter out the
+                         * obviously bogus ones here.  We replace them
+                         * with 0 rather than removing them entirely so
+                         * that userspace can tell which is which.
+                         */
+                        if ((level == 1 && next_ip == lr) ||
+                            (level <= 1 && !kernel_text_address(next_ip)))
+                                next_ip = 0;
+
+                        ++level;
+                }
+
+                callchain_store(entry, next_ip);
+                if (!valid_next_sp(next_sp, sp))
+                        return;
+                sp = next_sp;
+        }
+}
+
+#ifdef CONFIG_PPC64
+
+#ifdef CONFIG_HUGETLB_PAGE
+#define is_huge_psize(pagesize) (HPAGE_SHIFT && mmu_huge_psizes[pagesize])
+#else
+#define is_huge_psize(pagesize) 0
+#endif
+
+/*
+ * On 64-bit we don't want to invoke hash_page on user addresses from
+ * interrupt context, so if the access faults, we read the page tables
+ * to find which page (if any) is mapped and access it directly.
+ */
+static int read_user_stack_slow(void __user *ptr, void *ret, int nb)
+{
+        pgd_t *pgdir;
+        pte_t *ptep, pte;
+        int pagesize;
+        unsigned long addr = (unsigned long) ptr;
+        unsigned long offset;
+        unsigned long pfn;
+        void *kaddr;
+
+        pgdir = current->mm->pgd;
+        if (!pgdir)
+                return -EFAULT;
+
+        pagesize = get_slice_psize(current->mm, addr);
+
+        /* align address to page boundary */
+        offset = addr & ((1ul << mmu_psize_defs[pagesize].shift) - 1);
+        addr -= offset;
+
+        if (is_huge_psize(pagesize))
+                ptep = huge_pte_offset(current->mm, addr);
+        else
+                ptep = find_linux_pte(pgdir, addr);
+
+        if (ptep == NULL)
+                return -EFAULT;
+        pte = *ptep;
+        if (!pte_present(pte) || !(pte_val(pte) & _PAGE_USER))
+                return -EFAULT;
+        pfn = pte_pfn(pte);
+        if (!page_is_ram(pfn))
+                return -EFAULT;
+
+        /* no highmem to worry about here */
+        kaddr = pfn_to_kaddr(pfn);
+        memcpy(ret, kaddr + offset, nb);
+        return 0;
+}
+
+static int read_user_stack_64(unsigned long __user *ptr, unsigned long *ret)
+{
+        if ((unsigned long)ptr > TASK_SIZE - sizeof(unsigned long) ||
+            ((unsigned long)ptr & 7))
+                return -EFAULT;
+
+        if (!__get_user_inatomic(*ret, ptr))
+                return 0;
+
+        return read_user_stack_slow(ptr, ret, 8);
+}
+
+static int read_user_stack_32(unsigned int __user *ptr, unsigned int *ret)
+{
+        if ((unsigned long)ptr > TASK_SIZE - sizeof(unsigned int) ||
+            ((unsigned long)ptr & 3))
+                return -EFAULT;
+
+        if (!__get_user_inatomic(*ret, ptr))
+                return 0;
+
+        return read_user_stack_slow(ptr, ret, 4);
+}
+
+static inline int valid_user_sp(unsigned long sp, int is_64)
+{
+        if (!sp || (sp & 7) || sp > (is_64 ? TASK_SIZE : 0x100000000UL) - 32)
+                return 0;
+        return 1;
+}
+
+/*
+ * 64-bit user processes use the same stack frame for RT and non-RT signals.
+ */
+struct signal_frame_64 {
+        char            dummy[__SIGNAL_FRAMESIZE];
+        struct ucontext uc;
+        unsigned long   unused[2];
+        unsigned int    tramp[6];
+        struct siginfo  *pinfo;
+        void            *puc;
+        struct siginfo  info;
+        char            abigap[288];
+};
+
+static int is_sigreturn_64_address(unsigned long nip, unsigned long fp)
+{
+        if (nip == fp + offsetof(struct signal_frame_64, tramp))
+                return 1;
+        if (vdso64_rt_sigtramp && current->mm->context.vdso_base &&
+            nip == current->mm->context.vdso_base + vdso64_rt_sigtramp)
+                return 1;
+        return 0;
+}
+
+/*
+ * Do some sanity checking on the signal frame pointed to by sp.
+ * We check the pinfo and puc pointers in the frame.
+ */
+static int sane_signal_64_frame(unsigned long sp)
+{
+        struct signal_frame_64 __user *sf;
+        unsigned long pinfo, puc;
+
+        sf = (struct signal_frame_64 __user *) sp;
+        if (read_user_stack_64((unsigned long __user *) &sf->pinfo, &pinfo) ||
+            read_user_stack_64((unsigned long __user *) &sf->puc, &puc))
+                return 0;
+        return pinfo == (unsigned long) &sf->info &&
+                puc == (unsigned long) &sf->uc;
+}
+
+static void perf_callchain_user_64(struct pt_regs *regs,
+                                   struct perf_callchain_entry *entry)
+{
+        unsigned long sp, next_sp;
+        unsigned long next_ip;
+        unsigned long lr;
+        long level = 0;
+        struct signal_frame_64 __user *sigframe;
+        unsigned long __user *fp, *uregs;
+
+        next_ip = regs->nip;
+        lr = regs->link;
+        sp = regs->gpr[1];
+        callchain_store(entry, PERF_CONTEXT_USER);
+        callchain_store(entry, next_ip);
+
+        for (;;) {
+                fp = (unsigned long __user *) sp;
+                if (!valid_user_sp(sp, 1) || read_user_stack_64(fp, &next_sp))
+                        return;
+                if (level > 0 && read_user_stack_64(&fp[2], &next_ip))
+                        return;
+
+                /*
+                 * Note: the next_sp - sp >= signal frame size check
+                 * is true when next_sp < sp, which can happen when
+                 * transitioning from an alternate signal stack to the
+                 * normal stack.
+                 */
+                if (next_sp - sp >= sizeof(struct signal_frame_64) &&
+                    (is_sigreturn_64_address(next_ip, sp) ||
+                     (level <= 1 && is_sigreturn_64_address(lr, sp))) &&
+                    sane_signal_64_frame(sp)) {
+                        /*
+                         * This looks like an signal frame
+                         */
+                        sigframe = (struct signal_frame_64 __user *) sp;
+                        uregs = sigframe->uc.uc_mcontext.gp_regs;
+                        if (read_user_stack_64(&uregs[PT_NIP], &next_ip) ||
+                            read_user_stack_64(&uregs[PT_LNK], &lr) ||
+                            read_user_stack_64(&uregs[PT_R1], &sp))
+                                return;
+                        level = 0;
+                        callchain_store(entry, PERF_CONTEXT_USER);
+                        callchain_store(entry, next_ip);
+                        continue;
+                }
+
+                if (level == 0)
+                        next_ip = lr;
+                callchain_store(entry, next_ip);
+                ++level;
+                sp = next_sp;
+        }
+}
+
+static inline int current_is_64bit(void)
+{
+        /*
+         * We can't use test_thread_flag() here because we may be on an
+         * interrupt stack, and the thread flags don't get copied over
+         * from the thread_info on the main stack to the interrupt stack.
+         */
+        return !test_ti_thread_flag(task_thread_info(current), TIF_32BIT);
+}
+
+#else  /* CONFIG_PPC64 */
+/*
+ * On 32-bit we just access the address and let hash_page create a
+ * HPTE if necessary, so there is no need to fall back to reading
+ * the page tables.  Since this is called at interrupt level,
+ * do_page_fault() won't treat a DSI as a page fault.
+ */
+static int read_user_stack_32(unsigned int __user *ptr, unsigned int *ret)
+{
+        if ((unsigned long)ptr > TASK_SIZE - sizeof(unsigned int) ||
+            ((unsigned long)ptr & 3))
+                return -EFAULT;
+
+        return __get_user_inatomic(*ret, ptr);
+}
+
+static inline void perf_callchain_user_64(struct pt_regs *regs,
+                                          struct perf_callchain_entry *entry)
+{
+}
+
+static inline int current_is_64bit(void)
+{
+        return 0;
+}
+
+static inline int valid_user_sp(unsigned long sp, int is_64)
+{
+        if (!sp || (sp & 7) || sp > TASK_SIZE - 32)
+                return 0;
+        return 1;
+}
+
+#define __SIGNAL_FRAMESIZE32    __SIGNAL_FRAMESIZE
+#define sigcontext32            sigcontext
+#define mcontext32              mcontext
+#define ucontext32              ucontext
+#define compat_siginfo_t        struct siginfo
+
+#endif /* CONFIG_PPC64 */
+
+/*
+ * Layout for non-RT signal frames
+ */
+struct signal_frame_32 {
+        char                    dummy[__SIGNAL_FRAMESIZE32];
+        struct sigcontext32     sctx;
+        struct mcontext32       mctx;
+        int                     abigap[56];
+};
+
+/*
+ * Layout for RT signal frames
+ */
+struct rt_signal_frame_32 {
+        char                    dummy[__SIGNAL_FRAMESIZE32 + 16];
+        compat_siginfo_t        info;
+        struct ucontext32       uc;
+        int                     abigap[56];
+};
+
+static int is_sigreturn_32_address(unsigned int nip, unsigned int fp)
+{
+        if (nip == fp + offsetof(struct signal_frame_32, mctx.mc_pad))
+                return 1;
+        if (vdso32_sigtramp && current->mm->context.vdso_base &&
+            nip == current->mm->context.vdso_base + vdso32_sigtramp)
+                return 1;
+        return 0;
+}
+
+static int is_rt_sigreturn_32_address(unsigned int nip, unsigned int fp)
+{
+        if (nip == fp + offsetof(struct rt_signal_frame_32,
+                                 uc.uc_mcontext.mc_pad))
+                return 1;
+        if (vdso32_rt_sigtramp && current->mm->context.vdso_base &&
+            nip == current->mm->context.vdso_base + vdso32_rt_sigtramp)
+                return 1;
+        return 0;
+}
+
+static int sane_signal_32_frame(unsigned int sp)
+{
+        struct signal_frame_32 __user *sf;
+        unsigned int regs;
+
+        sf = (struct signal_frame_32 __user *) (unsigned long) sp;
+        if (read_user_stack_32((unsigned int __user *) &sf->sctx.regs, &regs))
+                return 0;
+        return regs == (unsigned long) &sf->mctx;
+}
+
+static int sane_rt_signal_32_frame(unsigned int sp)
+{
+        struct rt_signal_frame_32 __user *sf;
+        unsigned int regs;
+
+        sf = (struct rt_signal_frame_32 __user *) (unsigned long) sp;
+        if (read_user_stack_32((unsigned int __user *) &sf->uc.uc_regs, &regs))
+                return 0;
+        return regs == (unsigned long) &sf->uc.uc_mcontext;
+}
+
+static unsigned int __user *signal_frame_32_regs(unsigned int sp,
+                                unsigned int next_sp, unsigned int next_ip)
+{
+        struct mcontext32 __user *mctx = NULL;
+        struct signal_frame_32 __user *sf;
+        struct rt_signal_frame_32 __user *rt_sf;
+
+        /*
+         * Note: the next_sp - sp >= signal frame size check
+         * is true when next_sp < sp, for example, when
+         * transitioning from an alternate signal stack to the
+         * normal stack.
+         */
+        if (next_sp - sp >= sizeof(struct signal_frame_32) &&
+            is_sigreturn_32_address(next_ip, sp) &&
+            sane_signal_32_frame(sp)) {
+                sf = (struct signal_frame_32 __user *) (unsigned long) sp;
+                mctx = &sf->mctx;
+        }
+
+        if (!mctx && next_sp - sp >= sizeof(struct rt_signal_frame_32) &&
+            is_rt_sigreturn_32_address(next_ip, sp) &&
+            sane_rt_signal_32_frame(sp)) {
+                rt_sf = (struct rt_signal_frame_32 __user *) (unsigned long) sp;
+                mctx = &rt_sf->uc.uc_mcontext;
+        }
+
+        if (!mctx)
+                return NULL;
+        return mctx->mc_gregs;
+}
+
+static void perf_callchain_user_32(struct pt_regs *regs,
+                                   struct perf_callchain_entry *entry)
+{
+        unsigned int sp, next_sp;
+        unsigned int next_ip;
+        unsigned int lr;
+        long level = 0;
+        unsigned int __user *fp, *uregs;
+
+        next_ip = regs->nip;
+        lr = regs->link;
+        sp = regs->gpr[1];
+        callchain_store(entry, PERF_CONTEXT_USER);
+        callchain_store(entry, next_ip);
+
+        while (entry->nr < PERF_MAX_STACK_DEPTH) {
+                fp = (unsigned int __user *) (unsigned long) sp;
+                if (!valid_user_sp(sp, 0) || read_user_stack_32(fp, &next_sp))
+                        return;
+                if (level > 0 && read_user_stack_32(&fp[1], &next_ip))
+                        return;
+
+                uregs = signal_frame_32_regs(sp, next_sp, next_ip);
+                if (!uregs && level <= 1)
+                        uregs = signal_frame_32_regs(sp, next_sp, lr);
+                if (uregs) {
+                        /*
+                         * This looks like an signal frame, so restart
+                         * the stack trace with the values in it.
+                         */
+                        if (read_user_stack_32(&uregs[PT_NIP], &next_ip) ||
+                            read_user_stack_32(&uregs[PT_LNK], &lr) ||
+                            read_user_stack_32(&uregs[PT_R1], &sp))
+                                return;
+                        level = 0;
+                        callchain_store(entry, PERF_CONTEXT_USER);
+                        callchain_store(entry, next_ip);
+                        continue;
+                }
+
+                if (level == 0)
+                        next_ip = lr;
+                callchain_store(entry, next_ip);
+                ++level;
+                sp = next_sp;
+        }
+}
+
+/*
+ * Since we can't get PMU interrupts inside a PMU interrupt handler,
+ * we don't need separate irq and nmi entries here.
+ */
+static DEFINE_PER_CPU(struct perf_callchain_entry, callchain);
+
+struct perf_callchain_entry *perf_callchain(struct pt_regs *regs)
+{
+        struct perf_callchain_entry *entry = &__get_cpu_var(callchain);
+
+        entry->nr = 0;
+
+        if (current->pid == 0)          /* idle task? */
+                return entry;
+
+        if (!user_mode(regs)) {
+                perf_callchain_kernel(regs, entry);
+                if (current->mm)
+                        regs = task_pt_regs(current);
+                else
+                        regs = NULL;
+        }
+
+        if (regs) {
+                if (current_is_64bit())
+                        perf_callchain_user_64(regs, entry);
+                else
+                        perf_callchain_user_32(regs, entry);
+        }
+
+        return entry;
+}
diff --git a/arch/powerpc/mm/slb.c b/arch/powerpc/mm/slb.c
index 5b7038f248b6..a685652effeb 100644
--- a/arch/powerpc/mm/slb.c
+++ b/arch/powerpc/mm/slb.c
@@ -92,15 +92,13 @@ static inline void create_shadowed_slbe(unsigned long ea, int ssize,
                      : "memory" );
 }
 
-void slb_flush_and_rebolt(void)
+static void __slb_flush_and_rebolt(void)
 {
         /* If you change this make sure you change SLB_NUM_BOLTED
          * appropriately too. */
         unsigned long linear_llp, vmalloc_llp, lflags, vflags;
         unsigned long ksp_esid_data, ksp_vsid_data;
 
-        WARN_ON(!irqs_disabled());
-
         linear_llp = mmu_psize_defs[mmu_linear_psize].sllp;
         vmalloc_llp = mmu_psize_defs[mmu_vmalloc_psize].sllp;
         lflags = SLB_VSID_KERNEL | linear_llp;
@@ -117,12 +115,6 @@ void slb_flush_and_rebolt(void)
                 ksp_vsid_data = get_slb_shadow()->save_area[2].vsid;
         }
 
-        /*
-         * We can't take a PMU exception in the following code, so hard
-         * disable interrupts.
-         */
-        hard_irq_disable();
-
         /* We need to do this all in asm, so we're sure we don't touch
          * the stack between the slbia and rebolting it. */
         asm volatile("isync\n"
@@ -139,6 +131,21 @@ void slb_flush_and_rebolt(void)
                      : "memory");
 }
 
+void slb_flush_and_rebolt(void)
+{
+
+        WARN_ON(!irqs_disabled());
+
+        /*
+         * We can't take a PMU exception in the following code, so hard
+         * disable interrupts.
+         */
+        hard_irq_disable();
+
+        __slb_flush_and_rebolt();
+        get_paca()->slb_cache_ptr = 0;
+}
+
 void slb_vmalloc_update(void)
 {
         unsigned long vflags;
@@ -180,12 +187,20 @@ static inline int esids_match(unsigned long addr1, unsigned long addr2)
 /* Flush all user entries from the segment table of the current processor. */
 void switch_slb(struct task_struct *tsk, struct mm_struct *mm)
 {
-        unsigned long offset = get_paca()->slb_cache_ptr;
+        unsigned long offset;
         unsigned long slbie_data = 0;
         unsigned long pc = KSTK_EIP(tsk);
         unsigned long stack = KSTK_ESP(tsk);
         unsigned long unmapped_base;
 
+        /*
+         * We need interrupts hard-disabled here, not just soft-disabled,
+         * so that a PMU interrupt can't occur, which might try to access
+         * user memory (to get a stack trace) and possible cause an SLB miss
+         * which would update the slb_cache/slb_cache_ptr fields in the PACA.
+         */
+        hard_irq_disable();
+        offset = get_paca()->slb_cache_ptr;
         if (!cpu_has_feature(CPU_FTR_NO_SLBIE_B) &&
             offset <= SLB_CACHE_ENTRIES) {
                 int i;
@@ -200,7 +215,7 @@ void switch_slb(struct task_struct *tsk, struct mm_struct *mm)
                 }
                 asm volatile("isync" : : : "memory");
         } else {
-                slb_flush_and_rebolt();
+                __slb_flush_and_rebolt();
         }
 
         /* Workaround POWER5 < DD2.1 issue */
diff --git a/arch/powerpc/mm/stab.c b/arch/powerpc/mm/stab.c
index 98cd1dc2ae75..ab5fb48b3e90 100644
--- a/arch/powerpc/mm/stab.c
+++ b/arch/powerpc/mm/stab.c
@@ -164,7 +164,7 @@ void switch_stab(struct task_struct *tsk, struct mm_struct *mm)
 {
         struct stab_entry *stab = (struct stab_entry *) get_paca()->stab_addr;
         struct stab_entry *ste;
-        unsigned long offset = __get_cpu_var(stab_cache_ptr);
+        unsigned long offset;
         unsigned long pc = KSTK_EIP(tsk);
         unsigned long stack = KSTK_ESP(tsk);
         unsigned long unmapped_base;
@@ -172,6 +172,15 @@ void switch_stab(struct task_struct *tsk, struct mm_struct *mm)
         /* Force previous translations to complete. DRENG */
         asm volatile("isync" : : : "memory");
 
+        /*
+         * We need interrupts hard-disabled here, not just soft-disabled,
+         * so that a PMU interrupt can't occur, which might try to access
+         * user memory (to get a stack trace) and possible cause an STAB miss
+         * which would update the stab_cache/stab_cache_ptr per-cpu variables.
+         */
+        hard_irq_disable();
+
+        offset = __get_cpu_var(stab_cache_ptr);
         if (offset <= NR_STAB_CACHE_ENTRIES) {
                 int i;
 
diff --git a/arch/s390/Kconfig b/arch/s390/Kconfig
index e030e86ff6a3..1c866efd217d 100644
--- a/arch/s390/Kconfig
+++ b/arch/s390/Kconfig
@@ -84,7 +84,7 @@ config S390
         select HAVE_FUNCTION_TRACER
         select HAVE_FUNCTION_TRACE_MCOUNT_TEST
         select HAVE_FTRACE_MCOUNT_RECORD
-        select HAVE_FTRACE_SYSCALLS
+        select HAVE_SYSCALL_TRACEPOINTS
         select HAVE_DYNAMIC_FTRACE
         select HAVE_FUNCTION_GRAPH_TRACER
         select HAVE_DEFAULT_NO_SPIN_MUTEXES
diff --git a/arch/s390/defconfig b/arch/s390/defconfig
index fcba206529f3..4e91a2573cc4 100644
--- a/arch/s390/defconfig
+++ b/arch/s390/defconfig
@@ -900,7 +900,7 @@ CONFIG_HAVE_FUNCTION_GRAPH_TRACER=y
 CONFIG_HAVE_FUNCTION_TRACE_MCOUNT_TEST=y
 CONFIG_HAVE_DYNAMIC_FTRACE=y
 CONFIG_HAVE_FTRACE_MCOUNT_RECORD=y
-CONFIG_HAVE_FTRACE_SYSCALLS=y
+CONFIG_HAVE_SYSCALL_TRACEPOINTS=y
 CONFIG_TRACING_SUPPORT=y
 CONFIG_FTRACE=y
 # CONFIG_FUNCTION_TRACER is not set
diff --git a/arch/s390/include/asm/spinlock.h b/arch/s390/include/asm/spinlock.h
index c9af0d19c7ab..41ce6861174e 100644
--- a/arch/s390/include/asm/spinlock.h
+++ b/arch/s390/include/asm/spinlock.h
@@ -191,4 +191,33 @@ static inline int __raw_write_trylock(raw_rwlock_t *rw)
 #define _raw_read_relax(lock)   cpu_relax()
 #define _raw_write_relax(lock)  cpu_relax()
 
+#define __always_inline__spin_lock
+#define __always_inline__read_lock
+#define __always_inline__write_lock
+#define __always_inline__spin_lock_bh
+#define __always_inline__read_lock_bh
+#define __always_inline__write_lock_bh
+#define __always_inline__spin_lock_irq
+#define __always_inline__read_lock_irq
+#define __always_inline__write_lock_irq
+#define __always_inline__spin_lock_irqsave
+#define __always_inline__read_lock_irqsave
+#define __always_inline__write_lock_irqsave
+#define __always_inline__spin_trylock
+#define __always_inline__read_trylock
+#define __always_inline__write_trylock
+#define __always_inline__spin_trylock_bh
+#define __always_inline__spin_unlock
+#define __always_inline__read_unlock
+#define __always_inline__write_unlock
+#define __always_inline__spin_unlock_bh
+#define __always_inline__read_unlock_bh
+#define __always_inline__write_unlock_bh
+#define __always_inline__spin_unlock_irq
+#define __always_inline__read_unlock_irq
+#define __always_inline__write_unlock_irq
+#define __always_inline__spin_unlock_irqrestore
+#define __always_inline__read_unlock_irqrestore
+#define __always_inline__write_unlock_irqrestore
+
 #endif /* __ASM_SPINLOCK_H */
diff --git a/arch/s390/include/asm/thread_info.h b/arch/s390/include/asm/thread_info.h
index ba1cab9fc1f9..07eb61b2fb3a 100644
--- a/arch/s390/include/asm/thread_info.h
+++ b/arch/s390/include/asm/thread_info.h
@@ -92,7 +92,7 @@ static inline struct thread_info *current_thread_info(void)
 #define TIF_SYSCALL_TRACE       8       /* syscall trace active */
 #define TIF_SYSCALL_AUDIT       9       /* syscall auditing active */
 #define TIF_SECCOMP             10      /* secure computing */
-#define TIF_SYSCALL_FTRACE      11      /* ftrace syscall instrumentation */
+#define TIF_SYSCALL_TRACEPOINT  11      /* syscall tracepoint instrumentation */
 #define TIF_USEDFPU             16      /* FPU was used by this task this quantum (SMP) */
 #define TIF_POLLING_NRFLAG      17      /* true if poll_idle() is polling 
                                            TIF_NEED_RESCHED */
@@ -111,7 +111,7 @@ static inline struct thread_info *current_thread_info(void)
 #define _TIF_SYSCALL_TRACE      (1<<TIF_SYSCALL_TRACE)
 #define _TIF_SYSCALL_AUDIT      (1<<TIF_SYSCALL_AUDIT)
 #define _TIF_SECCOMP            (1<<TIF_SECCOMP)
-#define _TIF_SYSCALL_FTRACE     (1<<TIF_SYSCALL_FTRACE)
+#define _TIF_SYSCALL_TRACEPOINT (1<<TIF_SYSCALL_TRACEPOINT)
 #define _TIF_USEDFPU            (1<<TIF_USEDFPU)
 #define _TIF_POLLING_NRFLAG     (1<<TIF_POLLING_NRFLAG)
 #define _TIF_31BIT              (1<<TIF_31BIT)
diff --git a/arch/s390/kernel/entry.S b/arch/s390/kernel/entry.S
index f78580a74039..f43d2ee54464 100644
--- a/arch/s390/kernel/entry.S
+++ b/arch/s390/kernel/entry.S
@@ -54,7 +54,7 @@ _TIF_WORK_SVC = (_TIF_SIGPENDING | _TIF_NOTIFY_RESUME | _TIF_NEED_RESCHED | \
 _TIF_WORK_INT = (_TIF_SIGPENDING | _TIF_NOTIFY_RESUME | _TIF_NEED_RESCHED | \
                  _TIF_MCCK_PENDING)
 _TIF_SYSCALL = (_TIF_SYSCALL_TRACE>>8 | _TIF_SYSCALL_AUDIT>>8 | \
-                _TIF_SECCOMP>>8 | _TIF_SYSCALL_FTRACE>>8)
+                _TIF_SECCOMP>>8 | _TIF_SYSCALL_TRACEPOINT>>8)
 
 STACK_SHIFT = PAGE_SHIFT + THREAD_ORDER
 STACK_SIZE  = 1 << STACK_SHIFT
diff --git a/arch/s390/kernel/entry64.S b/arch/s390/kernel/entry64.S
index 009ca6175db9..a6f7b20df616 100644
--- a/arch/s390/kernel/entry64.S
+++ b/arch/s390/kernel/entry64.S
@@ -57,7 +57,7 @@ _TIF_WORK_SVC = (_TIF_SIGPENDING | _TIF_NOTIFY_RESUME | _TIF_NEED_RESCHED | \
 _TIF_WORK_INT = (_TIF_SIGPENDING | _TIF_NOTIFY_RESUME | _TIF_NEED_RESCHED | \
                  _TIF_MCCK_PENDING)
 _TIF_SYSCALL = (_TIF_SYSCALL_TRACE>>8 | _TIF_SYSCALL_AUDIT>>8 | \
-                _TIF_SECCOMP>>8 | _TIF_SYSCALL_FTRACE>>8)
+                _TIF_SECCOMP>>8 | _TIF_SYSCALL_TRACEPOINT>>8)
 
 #define BASED(name) name-system_call(%r13)
 
diff --git a/arch/s390/kernel/ftrace.c b/arch/s390/kernel/ftrace.c
index 3e298e64f0db..57bdcb1e3cdf 100644
--- a/arch/s390/kernel/ftrace.c
+++ b/arch/s390/kernel/ftrace.c
@@ -220,6 +220,29 @@ struct syscall_metadata *syscall_nr_to_meta(int nr)
         return syscalls_metadata[nr];
 }
 
+int syscall_name_to_nr(char *name)
+{
+        int i;
+
+        if (!syscalls_metadata)
+                return -1;
+        for (i = 0; i < NR_syscalls; i++)
+                if (syscalls_metadata[i])
+                        if (!strcmp(syscalls_metadata[i]->name, name))
+                                return i;
+        return -1;
+}
+
+void set_syscall_enter_id(int num, int id)
+{
+        syscalls_metadata[num]->enter_id = id;
+}
+
+void set_syscall_exit_id(int num, int id)
+{
+        syscalls_metadata[num]->exit_id = id;
+}
+
 static struct syscall_metadata *find_syscall_meta(unsigned long syscall)
 {
         struct syscall_metadata *start;
@@ -237,24 +260,19 @@ static struct syscall_metadata *find_syscall_meta(unsigned long syscall)
         return NULL;
 }
 
-void arch_init_ftrace_syscalls(void)
+static int __init arch_init_ftrace_syscalls(void)
 {
         struct syscall_metadata *meta;
         int i;
-        static atomic_t refs;
-
-        if (atomic_inc_return(&refs) != 1)
-                goto out;
         syscalls_metadata = kzalloc(sizeof(*syscalls_metadata) * NR_syscalls,
                                     GFP_KERNEL);
         if (!syscalls_metadata)
-                goto out;
+                return -ENOMEM;
         for (i = 0; i < NR_syscalls; i++) {
                 meta = find_syscall_meta((unsigned long)sys_call_table[i]);
                 syscalls_metadata[i] = meta;
         }
-        return;
-out:
-        atomic_dec(&refs);
+        return 0;
 }
+arch_initcall(arch_init_ftrace_syscalls);
 #endif
diff --git a/arch/s390/kernel/ptrace.c b/arch/s390/kernel/ptrace.c
index 43acd73105b7..f3ddd7ac06c5 100644
--- a/arch/s390/kernel/ptrace.c
+++ b/arch/s390/kernel/ptrace.c
@@ -51,6 +51,9 @@
 #include "compat_ptrace.h"
 #endif
 
+#define CREATE_TRACE_POINTS
+#include <trace/events/syscalls.h>
+
 enum s390_regset {
         REGSET_GENERAL,
         REGSET_FP,
@@ -661,8 +664,8 @@ asmlinkage long do_syscall_trace_enter(struct pt_regs *regs)
                 ret = -1;
         }
 
-        if (unlikely(test_thread_flag(TIF_SYSCALL_FTRACE)))
-                ftrace_syscall_enter(regs);
+        if (unlikely(test_thread_flag(TIF_SYSCALL_TRACEPOINT)))
+                trace_sys_enter(regs, regs->gprs[2]);
 
         if (unlikely(current->audit_context))
                 audit_syscall_entry(is_compat_task() ?
@@ -679,8 +682,8 @@ asmlinkage void do_syscall_trace_exit(struct pt_regs *regs)
                 audit_syscall_exit(AUDITSC_RESULT(regs->gprs[2]),
                                    regs->gprs[2]);
 
-        if (unlikely(test_thread_flag(TIF_SYSCALL_FTRACE)))
-                ftrace_syscall_exit(regs);
+        if (unlikely(test_thread_flag(TIF_SYSCALL_TRACEPOINT)))
+                trace_sys_exit(regs, regs->gprs[2]);
 
         if (test_thread_flag(TIF_SYSCALL_TRACE))
                 tracehook_report_syscall_exit(regs, 0);
diff --git a/arch/sparc/Kconfig b/arch/sparc/Kconfig
index 3f8b6a92eabd..233cff53a623 100644
--- a/arch/sparc/Kconfig
+++ b/arch/sparc/Kconfig
@@ -25,6 +25,8 @@ config SPARC
         select ARCH_WANT_OPTIONAL_GPIOLIB
         select RTC_CLASS
         select RTC_DRV_M48T59
+        select HAVE_DMA_ATTRS
+        select HAVE_DMA_API_DEBUG
 
 config SPARC32
         def_bool !64BIT
diff --git a/arch/sparc/include/asm/dma-mapping.h b/arch/sparc/include/asm/dma-mapping.h
index 204e4bf64438..5a8c308e2b5c 100644
--- a/arch/sparc/include/asm/dma-mapping.h
+++ b/arch/sparc/include/asm/dma-mapping.h
@@ -3,6 +3,7 @@
 
 #include <linux/scatterlist.h>
 #include <linux/mm.h>
+#include <linux/dma-debug.h>
 
 #define DMA_ERROR_CODE  (~(dma_addr_t)0x0)
 
@@ -13,142 +14,40 @@ extern int dma_set_mask(struct device *dev, u64 dma_mask);
 #define dma_free_noncoherent(d, s, v, h) dma_free_coherent(d, s, v, h)
 #define dma_is_consistent(d, h) (1)
 
-struct dma_ops {
-        void *(*alloc_coherent)(struct device *dev, size_t size,
-                                dma_addr_t *dma_handle, gfp_t flag);
-        void (*free_coherent)(struct device *dev, size_t size,
-                              void *cpu_addr, dma_addr_t dma_handle);
-        dma_addr_t (*map_page)(struct device *dev, struct page *page,
-                               unsigned long offset, size_t size,
-                               enum dma_data_direction direction);
-        void (*unmap_page)(struct device *dev, dma_addr_t dma_addr,
-                           size_t size,
-                           enum dma_data_direction direction);
-        int (*map_sg)(struct device *dev, struct scatterlist *sg, int nents,
-                      enum dma_data_direction direction);
-        void (*unmap_sg)(struct device *dev, struct scatterlist *sg,
-                         int nhwentries,
-                         enum dma_data_direction direction);
-        void (*sync_single_for_cpu)(struct device *dev,
-                                    dma_addr_t dma_handle, size_t size,
-                                    enum dma_data_direction direction);
-        void (*sync_single_for_device)(struct device *dev,
-                                       dma_addr_t dma_handle, size_t size,
-                                       enum dma_data_direction direction);
-        void (*sync_sg_for_cpu)(struct device *dev, struct scatterlist *sg,
-                                int nelems,
-                                enum dma_data_direction direction);
-        void (*sync_sg_for_device)(struct device *dev,
-                                   struct scatterlist *sg, int nents,
-                                   enum dma_data_direction dir);
-};
-extern const struct dma_ops *dma_ops;
+extern struct dma_map_ops *dma_ops, pci32_dma_ops;
+extern struct bus_type pci_bus_type;
 
-static inline void *dma_alloc_coherent(struct device *dev, size_t size,
-                                       dma_addr_t *dma_handle, gfp_t flag)
-{
-        return dma_ops->alloc_coherent(dev, size, dma_handle, flag);
-}
-
-static inline void dma_free_coherent(struct device *dev, size_t size,
-                                     void *cpu_addr, dma_addr_t dma_handle)
-{
-        dma_ops->free_coherent(dev, size, cpu_addr, dma_handle);
-}
-
-static inline dma_addr_t dma_map_single(struct device *dev, void *cpu_addr,
-                                        size_t size,
-                                        enum dma_data_direction direction)
-{
-        return dma_ops->map_page(dev, virt_to_page(cpu_addr),
-                                 (unsigned long)cpu_addr & ~PAGE_MASK, size,
-                                 direction);
-}
-
-static inline void dma_unmap_single(struct device *dev, dma_addr_t dma_addr,
-                                    size_t size,
-                                    enum dma_data_direction direction)
-{
-        dma_ops->unmap_page(dev, dma_addr, size, direction);
-}
-
-static inline dma_addr_t dma_map_page(struct device *dev, struct page *page,
-                                      unsigned long offset, size_t size,
-                                      enum dma_data_direction direction)
-{
-        return dma_ops->map_page(dev, page, offset, size, direction);
-}
-
-static inline void dma_unmap_page(struct device *dev, dma_addr_t dma_address,
-                                  size_t size,
-                                  enum dma_data_direction direction)
-{
-        dma_ops->unmap_page(dev, dma_address, size, direction);
-}
-
-static inline int dma_map_sg(struct device *dev, struct scatterlist *sg,
-                             int nents, enum dma_data_direction direction)
-{
-        return dma_ops->map_sg(dev, sg, nents, direction);
-}
-
-static inline void dma_unmap_sg(struct device *dev, struct scatterlist *sg,
-                                int nents, enum dma_data_direction direction)
+static inline struct dma_map_ops *get_dma_ops(struct device *dev)
 {
-        dma_ops->unmap_sg(dev, sg, nents, direction);
-}
-
-static inline void dma_sync_single_for_cpu(struct device *dev,
-                                           dma_addr_t dma_handle, size_t size,
-                                           enum dma_data_direction direction)
-{
-        dma_ops->sync_single_for_cpu(dev, dma_handle, size, direction);
+#if defined(CONFIG_SPARC32) && defined(CONFIG_PCI)
+        if (dev->bus == &pci_bus_type)
+                return &pci32_dma_ops;
+#endif
+        return dma_ops;
 }
 
-static inline void dma_sync_single_for_device(struct device *dev,
-                                              dma_addr_t dma_handle,
-                                              size_t size,
-                                              enum dma_data_direction direction)
-{
-        if (dma_ops->sync_single_for_device)
-                dma_ops->sync_single_for_device(dev, dma_handle, size,
-                                                direction);
-}
+#include <asm-generic/dma-mapping-common.h>
 
-static inline void dma_sync_sg_for_cpu(struct device *dev,
-                                       struct scatterlist *sg, int nelems,
-                                       enum dma_data_direction direction)
+static inline void *dma_alloc_coherent(struct device *dev, size_t size,
+                                       dma_addr_t *dma_handle, gfp_t flag)
 {
-        dma_ops->sync_sg_for_cpu(dev, sg, nelems, direction);
-}
+        struct dma_map_ops *ops = get_dma_ops(dev);
+        void *cpu_addr;
 
-static inline void dma_sync_sg_for_device(struct device *dev,
-                                          struct scatterlist *sg, int nelems,
-                                          enum dma_data_direction direction)
-{
-        if (dma_ops->sync_sg_for_device)
-                dma_ops->sync_sg_for_device(dev, sg, nelems, direction);
+        cpu_addr = ops->alloc_coherent(dev, size, dma_handle, flag);
+        debug_dma_alloc_coherent(dev, size, *dma_handle, cpu_addr);
+        return cpu_addr;
 }
 
-static inline void dma_sync_single_range_for_cpu(struct device *dev,
-                                                 dma_addr_t dma_handle,
-                                                 unsigned long offset,
-                                                 size_t size,
-                                                 enum dma_data_direction dir)
+static inline void dma_free_coherent(struct device *dev, size_t size,
+                                     void *cpu_addr, dma_addr_t dma_handle)
 {
-        dma_sync_single_for_cpu(dev, dma_handle+offset, size, dir);
-}
+        struct dma_map_ops *ops = get_dma_ops(dev);
 
-static inline void dma_sync_single_range_for_device(struct device *dev,
-                                                    dma_addr_t dma_handle,
-                                                    unsigned long offset,
-                                                    size_t size,
-                                                    enum dma_data_direction dir)
-{
-        dma_sync_single_for_device(dev, dma_handle+offset, size, dir);
+        debug_dma_free_coherent(dev, size, cpu_addr, dma_handle);
+        ops->free_coherent(dev, size, cpu_addr, dma_handle);
 }
 
-
 static inline int dma_mapping_error(struct device *dev, dma_addr_t dma_addr)
 {
         return (dma_addr == DMA_ERROR_CODE);
diff --git a/arch/sparc/include/asm/irq_64.h b/arch/sparc/include/asm/irq_64.h
index 1934f2cbf513..a0b443cb3c1f 100644
--- a/arch/sparc/include/asm/irq_64.h
+++ b/arch/sparc/include/asm/irq_64.h
@@ -89,8 +89,8 @@ static inline unsigned long get_softint(void)
         return retval;
 }
 
-void __trigger_all_cpu_backtrace(void);
-#define trigger_all_cpu_backtrace() __trigger_all_cpu_backtrace()
+void arch_trigger_all_cpu_backtrace(void);
+#define arch_trigger_all_cpu_backtrace arch_trigger_all_cpu_backtrace
 
 extern void *hardirq_stack[NR_CPUS];
 extern void *softirq_stack[NR_CPUS];
diff --git a/arch/sparc/include/asm/pci.h b/arch/sparc/include/asm/pci.h
index 6e14fd179335..d9c031f9910f 100644
--- a/arch/sparc/include/asm/pci.h
+++ b/arch/sparc/include/asm/pci.h
@@ -5,4 +5,7 @@
 #else
 #include <asm/pci_32.h>
 #endif
+
+#include <asm-generic/pci-dma-compat.h>
+
 #endif
diff --git a/arch/sparc/include/asm/pci_32.h b/arch/sparc/include/asm/pci_32.h
index b41c4c198159..ac0e8369fd97 100644
--- a/arch/sparc/include/asm/pci_32.h
+++ b/arch/sparc/include/asm/pci_32.h
@@ -31,42 +31,8 @@ static inline void pcibios_penalize_isa_irq(int irq, int active)
  */
 #define PCI_DMA_BUS_IS_PHYS     (0)
 
-#include <asm/scatterlist.h>
-
 struct pci_dev;
 
-/* Allocate and map kernel buffer using consistent mode DMA for a device.
- * hwdev should be valid struct pci_dev pointer for PCI devices.
- */
-extern void *pci_alloc_consistent(struct pci_dev *hwdev, size_t size, dma_addr_t *dma_handle);
-
-/* Free and unmap a consistent DMA buffer.
- * cpu_addr is what was returned from pci_alloc_consistent,
- * size must be the same as what as passed into pci_alloc_consistent,
- * and likewise dma_addr must be the same as what *dma_addrp was set to.
- *
- * References to the memory and mappings assosciated with cpu_addr/dma_addr
- * past this call are illegal.
- */
-extern void pci_free_consistent(struct pci_dev *hwdev, size_t size, void *vaddr, dma_addr_t dma_handle);
-
-/* Map a single buffer of the indicated size for DMA in streaming mode.
- * The 32-bit bus address to use is returned.
- *
- * Once the device is given the dma address, the device owns this memory
- * until either pci_unmap_single or pci_dma_sync_single_for_cpu is performed.
- */
-extern dma_addr_t pci_map_single(struct pci_dev *hwdev, void *ptr, size_t size, int direction);
-
-/* Unmap a single streaming mode DMA translation.  The dma_addr and size
- * must match what was provided for in a previous pci_map_single call.  All
- * other usages are undefined.
- *
- * After this call, reads by the cpu to the buffer are guaranteed to see
- * whatever the device wrote there.
- */
-extern void pci_unmap_single(struct pci_dev *hwdev, dma_addr_t dma_addr, size_t size, int direction);
-
 /* pci_unmap_{single,page} is not a nop, thus... */
 #define DECLARE_PCI_UNMAP_ADDR(ADDR_NAME)       \
         dma_addr_t ADDR_NAME;
@@ -81,69 +47,6 @@ extern void pci_unmap_single(struct pci_dev *hwdev, dma_addr_t dma_addr, size_t
 #define pci_unmap_len_set(PTR, LEN_NAME, VAL)           \
         (((PTR)->LEN_NAME) = (VAL))
 
-/*
- * Same as above, only with pages instead of mapped addresses.
- */
-extern dma_addr_t pci_map_page(struct pci_dev *hwdev, struct page *page,
-                        unsigned long offset, size_t size, int direction);
-extern void pci_unmap_page(struct pci_dev *hwdev,
-                        dma_addr_t dma_address, size_t size, int direction);
-
-/* Map a set of buffers described by scatterlist in streaming
- * mode for DMA.  This is the scather-gather version of the
- * above pci_map_single interface.  Here the scatter gather list
- * elements are each tagged with the appropriate dma address
- * and length.  They are obtained via sg_dma_{address,length}(SG).
- *
- * NOTE: An implementation may be able to use a smaller number of
- *       DMA address/length pairs than there are SG table elements.
- *       (for example via virtual mapping capabilities)
- *       The routine returns the number of addr/length pairs actually
- *       used, at most nents.
- *
- * Device ownership issues as mentioned above for pci_map_single are
- * the same here.
- */
-extern int pci_map_sg(struct pci_dev *hwdev, struct scatterlist *sg, int nents, int direction);
-
-/* Unmap a set of streaming mode DMA translations.
- * Again, cpu read rules concerning calls here are the same as for
- * pci_unmap_single() above.
- */
-extern void pci_unmap_sg(struct pci_dev *hwdev, struct scatterlist *sg, int nhwents, int direction);
-
-/* Make physical memory consistent for a single
- * streaming mode DMA translation after a transfer.
- *
- * If you perform a pci_map_single() but wish to interrogate the
- * buffer using the cpu, yet do not wish to teardown the PCI dma
- * mapping, you must call this function before doing so.  At the
- * next point you give the PCI dma address back to the card, you
- * must first perform a pci_dma_sync_for_device, and then the device
- * again owns the buffer.
- */
-extern void pci_dma_sync_single_for_cpu(struct pci_dev *hwdev, dma_addr_t dma_handle, size_t size, int direction);
-extern void pci_dma_sync_single_for_device(struct pci_dev *hwdev, dma_addr_t dma_handle, size_t size, int direction);
-
-/* Make physical memory consistent for a set of streaming
- * mode DMA translations after a transfer.
- *
- * The same as pci_dma_sync_single_* but for a scatter-gather list,
- * same rules and usage.
- */
-extern void pci_dma_sync_sg_for_cpu(struct pci_dev *hwdev, struct scatterlist *sg, int nelems, int direction);
-extern void pci_dma_sync_sg_for_device(struct pci_dev *hwdev, struct scatterlist *sg, int nelems, int direction);
-
-/* Return whether the given PCI device DMA address mask can
- * be supported properly.  For example, if your device can
- * only drive the low 24-bits during PCI bus mastering, then
- * you would pass 0x00ffffff as the mask to this function.
- */
-static inline int pci_dma_supported(struct pci_dev *hwdev, u64 mask)
-{
-        return 1;
-}
-
 #ifdef CONFIG_PCI
 static inline void pci_dma_burst_advice(struct pci_dev *pdev,
                                         enum pci_dma_burst_strategy *strat,
@@ -154,14 +57,6 @@ static inline void pci_dma_burst_advice(struct pci_dev *pdev,
 }
 #endif
 
-#define PCI_DMA_ERROR_CODE      (~(dma_addr_t)0x0)
-
-static inline int pci_dma_mapping_error(struct pci_dev *pdev,
-                                        dma_addr_t dma_addr)
-{
-        return (dma_addr == PCI_DMA_ERROR_CODE);
-}
-
 struct device_node;
 extern struct device_node *pci_device_to_OF_node(struct pci_dev *pdev);
 
diff --git a/arch/sparc/include/asm/pci_64.h b/arch/sparc/include/asm/pci_64.h
index 7a1e3566e59c..5cc9f6aa5494 100644
--- a/arch/sparc/include/asm/pci_64.h
+++ b/arch/sparc/include/asm/pci_64.h
@@ -35,37 +35,6 @@ static inline void pcibios_penalize_isa_irq(int irq, int active)
  */
 #define PCI_DMA_BUS_IS_PHYS     (0)
 
-static inline void *pci_alloc_consistent(struct pci_dev *pdev, size_t size,
-                                         dma_addr_t *dma_handle)
-{
-        return dma_alloc_coherent(&pdev->dev, size, dma_handle, GFP_ATOMIC);
-}
-
-static inline void pci_free_consistent(struct pci_dev *pdev, size_t size,
-                                       void *vaddr, dma_addr_t dma_handle)
-{
-        return dma_free_coherent(&pdev->dev, size, vaddr, dma_handle);
-}
-
-static inline dma_addr_t pci_map_single(struct pci_dev *pdev, void *ptr,
-                                        size_t size, int direction)
-{
-        return dma_map_single(&pdev->dev, ptr, size,
-                              (enum dma_data_direction) direction);
-}
-
-static inline void pci_unmap_single(struct pci_dev *pdev, dma_addr_t dma_addr,
-                                    size_t size, int direction)
-{
-        dma_unmap_single(&pdev->dev, dma_addr, size,
-                         (enum dma_data_direction) direction);
-}
-
-#define pci_map_page(dev, page, off, size, dir) \
-        pci_map_single(dev, (page_address(page) + (off)), size, dir)
-#define pci_unmap_page(dev,addr,sz,dir) \
-        pci_unmap_single(dev,addr,sz,dir)
-
 /* pci_unmap_{single,page} is not a nop, thus... */
 #define DECLARE_PCI_UNMAP_ADDR(ADDR_NAME)       \
         dma_addr_t ADDR_NAME;
@@ -80,57 +49,6 @@ static inline void pci_unmap_single(struct pci_dev *pdev, dma_addr_t dma_addr,
 #define pci_unmap_len_set(PTR, LEN_NAME, VAL)           \
         (((PTR)->LEN_NAME) = (VAL))
 
-static inline int pci_map_sg(struct pci_dev *pdev, struct scatterlist *sg,
-                             int nents, int direction)
-{
-        return dma_map_sg(&pdev->dev, sg, nents,
-                          (enum dma_data_direction) direction);
-}
-
-static inline void pci_unmap_sg(struct pci_dev *pdev, struct scatterlist *sg,
-                                int nents, int direction)
-{
-        dma_unmap_sg(&pdev->dev, sg, nents,
-                     (enum dma_data_direction) direction);
-}
-
-static inline void pci_dma_sync_single_for_cpu(struct pci_dev *pdev,
-                                               dma_addr_t dma_handle,
-                                               size_t size, int direction)
-{
-        dma_sync_single_for_cpu(&pdev->dev, dma_handle, size,
-                                (enum dma_data_direction) direction);
-}
-
-static inline void pci_dma_sync_single_for_device(struct pci_dev *pdev,
-                                                  dma_addr_t dma_handle,
-                                                  size_t size, int direction)
-{
-        /* No flushing needed to sync cpu writes to the device.  */
-}
-
-static inline void pci_dma_sync_sg_for_cpu(struct pci_dev *pdev,
-                                           struct scatterlist *sg,
-                                           int nents, int direction)
-{
-        dma_sync_sg_for_cpu(&pdev->dev, sg, nents,
-                            (enum dma_data_direction) direction);
-}
-
-static inline void pci_dma_sync_sg_for_device(struct pci_dev *pdev,
-                                              struct scatterlist *sg,
-                                              int nelems, int direction)
-{
-        /* No flushing needed to sync cpu writes to the device.  */
-}
-
-/* Return whether the given PCI device DMA address mask can
- * be supported properly.  For example, if your device can
- * only drive the low 24-bits during PCI bus mastering, then
- * you would pass 0x00ffffff as the mask to this function.
- */
-extern int pci_dma_supported(struct pci_dev *hwdev, u64 mask);
-
 /* PCI IOMMU mapping bypass support. */
 
 /* PCI 64-bit addressing works for all slots on all controller
@@ -140,12 +58,6 @@ extern int pci_dma_supported(struct pci_dev *hwdev, u64 mask);
 #define PCI64_REQUIRED_MASK     (~(dma64_addr_t)0)
 #define PCI64_ADDR_BASE         0xfffc000000000000UL
 
-static inline int pci_dma_mapping_error(struct pci_dev *pdev,
-                                        dma_addr_t dma_addr)
-{
-        return dma_mapping_error(&pdev->dev, dma_addr);
-}
-
 #ifdef CONFIG_PCI
 static inline void pci_dma_burst_advice(struct pci_dev *pdev,
                                         enum pci_dma_burst_strategy *strat,
diff --git a/arch/sparc/include/asm/spinlock_32.h b/arch/sparc/include/asm/spinlock_32.h
index 46f91ab66a50..857630cff636 100644
--- a/arch/sparc/include/asm/spinlock_32.h
+++ b/arch/sparc/include/asm/spinlock_32.h
@@ -76,7 +76,7 @@ static inline void __raw_spin_unlock(raw_spinlock_t *lock)
  *
  * Unfortunately this scheme limits us to ~16,000,000 cpus.
  */
-static inline void __read_lock(raw_rwlock_t *rw)
+static inline void arch_read_lock(raw_rwlock_t *rw)
 {
         register raw_rwlock_t *lp asm("g1");
         lp = rw;
@@ -92,11 +92,11 @@ static inline void __read_lock(raw_rwlock_t *rw)
 #define __raw_read_lock(lock) \
 do {    unsigned long flags; \
         local_irq_save(flags); \
-        __read_lock(lock); \
+        arch_read_lock(lock); \
         local_irq_restore(flags); \
 } while(0)
 
-static inline void __read_unlock(raw_rwlock_t *rw)
+static inline void arch_read_unlock(raw_rwlock_t *rw)
 {
         register raw_rwlock_t *lp asm("g1");
         lp = rw;
@@ -112,7 +112,7 @@ static inline void __read_unlock(raw_rwlock_t *rw)
 #define __raw_read_unlock(lock) \
 do {    unsigned long flags; \
         local_irq_save(flags); \
-        __read_unlock(lock); \
+        arch_read_unlock(lock); \
         local_irq_restore(flags); \
 } while(0)
 
@@ -150,7 +150,7 @@ static inline int __raw_write_trylock(raw_rwlock_t *rw)
         return (val == 0);
 }
 
-static inline int __read_trylock(raw_rwlock_t *rw)
+static inline int arch_read_trylock(raw_rwlock_t *rw)
 {
         register raw_rwlock_t *lp asm("g1");
         register int res asm("o0");
@@ -169,7 +169,7 @@ static inline int __read_trylock(raw_rwlock_t *rw)
 ({      unsigned long flags; \
         int res; \
         local_irq_save(flags); \
-        res = __read_trylock(lock); \
+        res = arch_read_trylock(lock); \
         local_irq_restore(flags); \
         res; \
 })
diff --git a/arch/sparc/include/asm/spinlock_64.h b/arch/sparc/include/asm/spinlock_64.h
index f6b2b92ad8d2..43e514783582 100644
--- a/arch/sparc/include/asm/spinlock_64.h
+++ b/arch/sparc/include/asm/spinlock_64.h
@@ -92,7 +92,7 @@ static inline void __raw_spin_lock_flags(raw_spinlock_t *lock, unsigned long fla
 
 /* Multi-reader locks, these are much saner than the 32-bit Sparc ones... */
 
-static void inline __read_lock(raw_rwlock_t *lock)
+static void inline arch_read_lock(raw_rwlock_t *lock)
 {
         unsigned long tmp1, tmp2;
 
@@ -115,7 +115,7 @@ static void inline __read_lock(raw_rwlock_t *lock)
         : "memory");
 }
 
-static int inline __read_trylock(raw_rwlock_t *lock)
+static int inline arch_read_trylock(raw_rwlock_t *lock)
 {
         int tmp1, tmp2;
 
@@ -136,7 +136,7 @@ static int inline __read_trylock(raw_rwlock_t *lock)
         return tmp1;
 }
 
-static void inline __read_unlock(raw_rwlock_t *lock)
+static void inline arch_read_unlock(raw_rwlock_t *lock)
 {
         unsigned long tmp1, tmp2;
 
@@ -152,7 +152,7 @@ static void inline __read_unlock(raw_rwlock_t *lock)
         : "memory");
 }
 
-static void inline __write_lock(raw_rwlock_t *lock)
+static void inline arch_write_lock(raw_rwlock_t *lock)
 {
         unsigned long mask, tmp1, tmp2;
 
@@ -177,7 +177,7 @@ static void inline __write_lock(raw_rwlock_t *lock)
         : "memory");
 }
 
-static void inline __write_unlock(raw_rwlock_t *lock)
+static void inline arch_write_unlock(raw_rwlock_t *lock)
 {
         __asm__ __volatile__(
 "       stw             %%g0, [%0]"
@@ -186,7 +186,7 @@ static void inline __write_unlock(raw_rwlock_t *lock)
         : "memory");
 }
 
-static int inline __write_trylock(raw_rwlock_t *lock)
+static int inline arch_write_trylock(raw_rwlock_t *lock)
 {
         unsigned long mask, tmp1, tmp2, result;
 
@@ -210,14 +210,14 @@ static int inline __write_trylock(raw_rwlock_t *lock)
         return result;
 }
 
-#define __raw_read_lock(p)      __read_lock(p)
-#define __raw_read_lock_flags(p, f) __read_lock(p)
-#define __raw_read_trylock(p)   __read_trylock(p)
-#define __raw_read_unlock(p)    __read_unlock(p)
-#define __raw_write_lock(p)     __write_lock(p)
-#define __raw_write_lock_flags(p, f) __write_lock(p)
-#define __raw_write_unlock(p)   __write_unlock(p)
-#define __raw_write_trylock(p)  __write_trylock(p)
+#define __raw_read_lock(p)      arch_read_lock(p)
+#define __raw_read_lock_flags(p, f) arch_read_lock(p)
+#define __raw_read_trylock(p)   arch_read_trylock(p)
+#define __raw_read_unlock(p)    arch_read_unlock(p)
+#define __raw_write_lock(p)     arch_write_lock(p)
+#define __raw_write_lock_flags(p, f) arch_write_lock(p)
+#define __raw_write_unlock(p)   arch_write_unlock(p)
+#define __raw_write_trylock(p)  arch_write_trylock(p)
 
 #define __raw_read_can_lock(rw)         (!((rw)->lock & 0x80000000UL))
 #define __raw_write_can_lock(rw)        (!(rw)->lock)
diff --git a/arch/sparc/kernel/Makefile b/arch/sparc/kernel/Makefile
index 475ce4696acd..29b88a580661 100644
--- a/arch/sparc/kernel/Makefile
+++ b/arch/sparc/kernel/Makefile
@@ -61,7 +61,7 @@ obj-$(CONFIG_SPARC64_SMP) += cpumap.o
 obj-$(CONFIG_SPARC32)     += devres.o
 devres-y                  := ../../../kernel/irq/devres.o
 
-obj-$(CONFIG_SPARC32)     += dma.o
+obj-y                     += dma.o
 
 obj-$(CONFIG_SPARC32_PCI) += pcic.o
 
diff --git a/arch/sparc/kernel/dma.c b/arch/sparc/kernel/dma.c
index 524c32f97c55..e1ba8ee21b9a 100644
--- a/arch/sparc/kernel/dma.c
+++ b/arch/sparc/kernel/dma.c
@@ -1,178 +1,13 @@
-/* dma.c: PCI and SBUS DMA accessors for 32-bit sparc.
- *
- * Copyright (C) 2008 David S. Miller <davem@davemloft.net>
- */
-
 #include <linux/kernel.h>
 #include <linux/module.h>
 #include <linux/dma-mapping.h>
-#include <linux/scatterlist.h>
-#include <linux/mm.h>
-
-#ifdef CONFIG_PCI
-#include <linux/pci.h>
-#endif
+#include <linux/dma-debug.h>
 
-#include "dma.h"
+#define PREALLOC_DMA_DEBUG_ENTRIES       (1 << 15)
 
-int dma_supported(struct device *dev, u64 mask)
+static int __init dma_init(void)
 {
-#ifdef CONFIG_PCI
-        if (dev->bus == &pci_bus_type)
-                return pci_dma_supported(to_pci_dev(dev), mask);
-#endif
+        dma_debug_init(PREALLOC_DMA_DEBUG_ENTRIES);
         return 0;
 }
-EXPORT_SYMBOL(dma_supported);
-
-int dma_set_mask(struct device *dev, u64 dma_mask)
-{
-#ifdef CONFIG_PCI
-        if (dev->bus == &pci_bus_type)
-                return pci_set_dma_mask(to_pci_dev(dev), dma_mask);
-#endif
-        return -EOPNOTSUPP;
-}
-EXPORT_SYMBOL(dma_set_mask);
-
-static void *dma32_alloc_coherent(struct device *dev, size_t size,
-                                  dma_addr_t *dma_handle, gfp_t flag)
-{
-#ifdef CONFIG_PCI
-        if (dev->bus == &pci_bus_type)
-                return pci_alloc_consistent(to_pci_dev(dev), size, dma_handle);
-#endif
-        return sbus_alloc_consistent(dev, size, dma_handle);
-}
-
-static void dma32_free_coherent(struct device *dev, size_t size,
-                                void *cpu_addr, dma_addr_t dma_handle)
-{
-#ifdef CONFIG_PCI
-        if (dev->bus == &pci_bus_type) {
-                pci_free_consistent(to_pci_dev(dev), size,
-                                    cpu_addr, dma_handle);
-                return;
-        }
-#endif
-        sbus_free_consistent(dev, size, cpu_addr, dma_handle);
-}
-
-static dma_addr_t dma32_map_page(struct device *dev, struct page *page,
-                                 unsigned long offset, size_t size,
-                                 enum dma_data_direction direction)
-{
-#ifdef CONFIG_PCI
-        if (dev->bus == &pci_bus_type)
-                return pci_map_page(to_pci_dev(dev), page, offset,
-                                    size, (int)direction);
-#endif
-        return sbus_map_single(dev, page_address(page) + offset,
-                               size, (int)direction);
-}
-
-static void dma32_unmap_page(struct device *dev, dma_addr_t dma_address,
-                             size_t size, enum dma_data_direction direction)
-{
-#ifdef CONFIG_PCI
-        if (dev->bus == &pci_bus_type) {
-                pci_unmap_page(to_pci_dev(dev), dma_address,
-                               size, (int)direction);
-                return;
-        }
-#endif
-        sbus_unmap_single(dev, dma_address, size, (int)direction);
-}
-
-static int dma32_map_sg(struct device *dev, struct scatterlist *sg,
-                        int nents, enum dma_data_direction direction)
-{
-#ifdef CONFIG_PCI
-        if (dev->bus == &pci_bus_type)
-                return pci_map_sg(to_pci_dev(dev), sg, nents, (int)direction);
-#endif
-        return sbus_map_sg(dev, sg, nents, direction);
-}
-
-void dma32_unmap_sg(struct device *dev, struct scatterlist *sg,
-                    int nents, enum dma_data_direction direction)
-{
-#ifdef CONFIG_PCI
-        if (dev->bus == &pci_bus_type) {
-                pci_unmap_sg(to_pci_dev(dev), sg, nents, (int)direction);
-                return;
-        }
-#endif
-        sbus_unmap_sg(dev, sg, nents, (int)direction);
-}
-
-static void dma32_sync_single_for_cpu(struct device *dev, dma_addr_t dma_handle,
-                                      size_t size,
-                                      enum dma_data_direction direction)
-{
-#ifdef CONFIG_PCI
-        if (dev->bus == &pci_bus_type) {
-                pci_dma_sync_single_for_cpu(to_pci_dev(dev), dma_handle,
-                                            size, (int)direction);
-                return;
-        }
-#endif
-        sbus_dma_sync_single_for_cpu(dev, dma_handle, size, (int) direction);
-}
-
-static void dma32_sync_single_for_device(struct device *dev,
-                                         dma_addr_t dma_handle, size_t size,
-                                         enum dma_data_direction direction)
-{
-#ifdef CONFIG_PCI
-        if (dev->bus == &pci_bus_type) {
-                pci_dma_sync_single_for_device(to_pci_dev(dev), dma_handle,
-                                               size, (int)direction);
-                return;
-        }
-#endif
-        sbus_dma_sync_single_for_device(dev, dma_handle, size, (int) direction);
-}
-
-static void dma32_sync_sg_for_cpu(struct device *dev, struct scatterlist *sg,
-                                  int nelems, enum dma_data_direction direction)
-{
-#ifdef CONFIG_PCI
-        if (dev->bus == &pci_bus_type) {
-                pci_dma_sync_sg_for_cpu(to_pci_dev(dev), sg,
-                                        nelems, (int)direction);
-                return;
-        }
-#endif
-        BUG();
-}
-
-static void dma32_sync_sg_for_device(struct device *dev,
-                                     struct scatterlist *sg, int nelems,
-                                     enum dma_data_direction direction)
-{
-#ifdef CONFIG_PCI
-        if (dev->bus == &pci_bus_type) {
-                pci_dma_sync_sg_for_device(to_pci_dev(dev), sg,
-                                           nelems, (int)direction);
-                return;
-        }
-#endif
-        BUG();
-}
-
-static const struct dma_ops dma32_dma_ops = {
-        .alloc_coherent         = dma32_alloc_coherent,
-        .free_coherent          = dma32_free_coherent,
-        .map_page               = dma32_map_page,
-        .unmap_page             = dma32_unmap_page,
-        .map_sg                 = dma32_map_sg,
-        .unmap_sg               = dma32_unmap_sg,
-        .sync_single_for_cpu    = dma32_sync_single_for_cpu,
-        .sync_single_for_device = dma32_sync_single_for_device,
-        .sync_sg_for_cpu        = dma32_sync_sg_for_cpu,
-        .sync_sg_for_device     = dma32_sync_sg_for_device,
-};
-
-const struct dma_ops *dma_ops = &dma32_dma_ops;
-EXPORT_SYMBOL(dma_ops);
+fs_initcall(dma_init);
diff --git a/arch/sparc/kernel/dma.h b/arch/sparc/kernel/dma.h
deleted file mode 100644
index f8d8951adb53..000000000000
--- a/arch/sparc/kernel/dma.h
+++ /dev/null
@@ -1,14 +0,0 @@
-void *sbus_alloc_consistent(struct device *dev, long len, u32 *dma_addrp);
-void sbus_free_consistent(struct device *dev, long n, void *p, u32 ba);
-dma_addr_t sbus_map_single(struct device *dev, void *va,
-                           size_t len, int direction);
-void sbus_unmap_single(struct device *dev, dma_addr_t ba,
-                       size_t n, int direction);
-int sbus_map_sg(struct device *dev, struct scatterlist *sg,
-                int n, int direction);
-void sbus_unmap_sg(struct device *dev, struct scatterlist *sg,
-                   int n, int direction);
-void sbus_dma_sync_single_for_cpu(struct device *dev, dma_addr_t ba,
-                                  size_t size, int direction);
-void sbus_dma_sync_single_for_device(struct device *dev, dma_addr_t ba,
-                                     size_t size, int direction);
diff --git a/arch/sparc/kernel/iommu.c b/arch/sparc/kernel/iommu.c
index 0aeaefe696b9..7690cc219ecc 100644
--- a/arch/sparc/kernel/iommu.c
+++ b/arch/sparc/kernel/iommu.c
@@ -353,7 +353,8 @@ static void dma_4u_free_coherent(struct device *dev, size_t size,
 
 static dma_addr_t dma_4u_map_page(struct device *dev, struct page *page,
                                   unsigned long offset, size_t sz,
-                                  enum dma_data_direction direction)
+                                  enum dma_data_direction direction,
+                                  struct dma_attrs *attrs)
 {
         struct iommu *iommu;
         struct strbuf *strbuf;
@@ -474,7 +475,8 @@ do_flush_sync:
 }
 
 static void dma_4u_unmap_page(struct device *dev, dma_addr_t bus_addr,
-                              size_t sz, enum dma_data_direction direction)
+                              size_t sz, enum dma_data_direction direction,
+                              struct dma_attrs *attrs)
 {
         struct iommu *iommu;
         struct strbuf *strbuf;
@@ -520,7 +522,8 @@ static void dma_4u_unmap_page(struct device *dev, dma_addr_t bus_addr,
 }
 
 static int dma_4u_map_sg(struct device *dev, struct scatterlist *sglist,
-                         int nelems, enum dma_data_direction direction)
+                         int nelems, enum dma_data_direction direction,
+                         struct dma_attrs *attrs)
 {
         struct scatterlist *s, *outs, *segstart;
         unsigned long flags, handle, prot, ctx;
@@ -691,7 +694,8 @@ static unsigned long fetch_sg_ctx(struct iommu *iommu, struct scatterlist *sg)
 }
 
 static void dma_4u_unmap_sg(struct device *dev, struct scatterlist *sglist,
-                            int nelems, enum dma_data_direction direction)
+                            int nelems, enum dma_data_direction direction,
+                            struct dma_attrs *attrs)
 {
         unsigned long flags, ctx;
         struct scatterlist *sg;
@@ -822,7 +826,7 @@ static void dma_4u_sync_sg_for_cpu(struct device *dev,
         spin_unlock_irqrestore(&iommu->lock, flags);
 }
 
-static const struct dma_ops sun4u_dma_ops = {
+static struct dma_map_ops sun4u_dma_ops = {
         .alloc_coherent         = dma_4u_alloc_coherent,
         .free_coherent          = dma_4u_free_coherent,
         .map_page               = dma_4u_map_page,
@@ -833,9 +837,11 @@ static const struct dma_ops sun4u_dma_ops = {
         .sync_sg_for_cpu        = dma_4u_sync_sg_for_cpu,
 };
 
-const struct dma_ops *dma_ops = &sun4u_dma_ops;
+struct dma_map_ops *dma_ops = &sun4u_dma_ops;
 EXPORT_SYMBOL(dma_ops);
 
+extern int pci64_dma_supported(struct pci_dev *pdev, u64 device_mask);
+
 int dma_supported(struct device *dev, u64 device_mask)
 {
         struct iommu *iommu = dev->archdata.iommu;
@@ -849,7 +855,7 @@ int dma_supported(struct device *dev, u64 device_mask)
 
 #ifdef CONFIG_PCI
         if (dev->bus == &pci_bus_type)
-                return pci_dma_supported(to_pci_dev(dev), device_mask);
+                return pci64_dma_supported(to_pci_dev(dev), device_mask);
 #endif
 
         return 0;
diff --git a/arch/sparc/kernel/ioport.c b/arch/sparc/kernel/ioport.c
index 87ea0d03d975..edbea232c617 100644
--- a/arch/sparc/kernel/ioport.c
+++ b/arch/sparc/kernel/ioport.c
@@ -48,8 +48,6 @@
 #include <asm/iommu.h>
 #include <asm/io-unit.h>
 
-#include "dma.h"
-
 #define mmu_inval_dma_area(p, l)        /* Anton pulled it out for 2.4.0-xx */
 
 static struct resource *_sparc_find_resource(struct resource *r,
@@ -246,7 +244,8 @@ EXPORT_SYMBOL(sbus_set_sbus64);
  * Typically devices use them for control blocks.
  * CPU may access them without any explicit flushing.
  */
-void *sbus_alloc_consistent(struct device *dev, long len, u32 *dma_addrp)
+static void *sbus_alloc_coherent(struct device *dev, size_t len,
+                                 dma_addr_t *dma_addrp, gfp_t gfp)
 {
         struct of_device *op = to_of_device(dev);
         unsigned long len_total = (len + PAGE_SIZE-1) & PAGE_MASK;
@@ -299,7 +298,8 @@ err_nopages:
         return NULL;
 }
 
-void sbus_free_consistent(struct device *dev, long n, void *p, u32 ba)
+static void sbus_free_coherent(struct device *dev, size_t n, void *p,
+                               dma_addr_t ba)
 {
         struct resource *res;
         struct page *pgv;
@@ -317,7 +317,7 @@ void sbus_free_consistent(struct device *dev, long n, void *p, u32 ba)
 
         n = (n + PAGE_SIZE-1) & PAGE_MASK;
         if ((res->end-res->start)+1 != n) {
-                printk("sbus_free_consistent: region 0x%lx asked 0x%lx\n",
+                printk("sbus_free_consistent: region 0x%lx asked 0x%zx\n",
                     (long)((res->end-res->start)+1), n);
                 return;
         }
@@ -337,8 +337,13 @@ void sbus_free_consistent(struct device *dev, long n, void *p, u32 ba)
  * CPU view of this memory may be inconsistent with
  * a device view and explicit flushing is necessary.
  */
-dma_addr_t sbus_map_single(struct device *dev, void *va, size_t len, int direction)
+static dma_addr_t sbus_map_page(struct device *dev, struct page *page,
+                                unsigned long offset, size_t len,
+                                enum dma_data_direction dir,
+                                struct dma_attrs *attrs)
 {
+        void *va = page_address(page) + offset;
+
         /* XXX why are some lengths signed, others unsigned? */
         if (len <= 0) {
                 return 0;
@@ -350,12 +355,14 @@ dma_addr_t sbus_map_single(struct device *dev, void *va, size_t len, int directi
         return mmu_get_scsi_one(dev, va, len);
 }
 
-void sbus_unmap_single(struct device *dev, dma_addr_t ba, size_t n, int direction)
+static void sbus_unmap_page(struct device *dev, dma_addr_t ba, size_t n,
+                            enum dma_data_direction dir, struct dma_attrs *attrs)
 {
         mmu_release_scsi_one(dev, ba, n);
 }
 
-int sbus_map_sg(struct device *dev, struct scatterlist *sg, int n, int direction)
+static int sbus_map_sg(struct device *dev, struct scatterlist *sg, int n,
+                       enum dma_data_direction dir, struct dma_attrs *attrs)
 {
         mmu_get_scsi_sgl(dev, sg, n);
 
@@ -366,19 +373,38 @@ int sbus_map_sg(struct device *dev, struct scatterlist *sg, int n, int direction
         return n;
 }
 
-void sbus_unmap_sg(struct device *dev, struct scatterlist *sg, int n, int direction)
+static void sbus_unmap_sg(struct device *dev, struct scatterlist *sg, int n,
+                          enum dma_data_direction dir, struct dma_attrs *attrs)
 {
         mmu_release_scsi_sgl(dev, sg, n);
 }
 
-void sbus_dma_sync_single_for_cpu(struct device *dev, dma_addr_t ba, size_t size, int direction)
+static void sbus_sync_sg_for_cpu(struct device *dev, struct scatterlist *sg,
+                                 int n, enum dma_data_direction dir)
 {
+        BUG();
 }
 
-void sbus_dma_sync_single_for_device(struct device *dev, dma_addr_t ba, size_t size, int direction)
+static void sbus_sync_sg_for_device(struct device *dev, struct scatterlist *sg,
+                                    int n, enum dma_data_direction dir)
 {
+        BUG();
 }
 
+struct dma_map_ops sbus_dma_ops = {
+        .alloc_coherent         = sbus_alloc_coherent,
+        .free_coherent          = sbus_free_coherent,
+        .map_page               = sbus_map_page,
+        .unmap_page             = sbus_unmap_page,
+        .map_sg                 = sbus_map_sg,
+        .unmap_sg               = sbus_unmap_sg,
+        .sync_sg_for_cpu        = sbus_sync_sg_for_cpu,
+        .sync_sg_for_device     = sbus_sync_sg_for_device,
+};
+
+struct dma_map_ops *dma_ops = &sbus_dma_ops;
+EXPORT_SYMBOL(dma_ops);
+
 static int __init sparc_register_ioport(void)
 {
         register_proc_sparc_ioport();
@@ -395,7 +421,8 @@ arch_initcall(sparc_register_ioport);
 /* Allocate and map kernel buffer using consistent mode DMA for a device.
  * hwdev should be valid struct pci_dev pointer for PCI devices.
  */
-void *pci_alloc_consistent(struct pci_dev *pdev, size_t len, dma_addr_t *pba)
+static void *pci32_alloc_coherent(struct device *dev, size_t len,
+                                  dma_addr_t *pba, gfp_t gfp)
 {
         unsigned long len_total = (len + PAGE_SIZE-1) & PAGE_MASK;
         unsigned long va;
@@ -439,7 +466,6 @@ void *pci_alloc_consistent(struct pci_dev *pdev, size_t len, dma_addr_t *pba)
         *pba = virt_to_phys(va); /* equals virt_to_bus (R.I.P.) for us. */
         return (void *) res->start;
 }
-EXPORT_SYMBOL(pci_alloc_consistent);
 
 /* Free and unmap a consistent DMA buffer.
  * cpu_addr is what was returned from pci_alloc_consistent,
@@ -449,7 +475,8 @@ EXPORT_SYMBOL(pci_alloc_consistent);
  * References to the memory and mappings associated with cpu_addr/dma_addr
  * past this call are illegal.
  */
-void pci_free_consistent(struct pci_dev *pdev, size_t n, void *p, dma_addr_t ba)
+static void pci32_free_coherent(struct device *dev, size_t n, void *p,
+                                dma_addr_t ba)
 {
         struct resource *res;
         unsigned long pgp;
@@ -481,60 +508,18 @@ void pci_free_consistent(struct pci_dev *pdev, size_t n, void *p, dma_addr_t ba)
 
         free_pages(pgp, get_order(n));
 }
-EXPORT_SYMBOL(pci_free_consistent);
-
-/* Map a single buffer of the indicated size for DMA in streaming mode.
- * The 32-bit bus address to use is returned.
- *
- * Once the device is given the dma address, the device owns this memory
- * until either pci_unmap_single or pci_dma_sync_single_* is performed.
- */
-dma_addr_t pci_map_single(struct pci_dev *hwdev, void *ptr, size_t size,
-    int direction)
-{
-        BUG_ON(direction == PCI_DMA_NONE);
-        /* IIep is write-through, not flushing. */
-        return virt_to_phys(ptr);
-}
-EXPORT_SYMBOL(pci_map_single);
-
-/* Unmap a single streaming mode DMA translation.  The dma_addr and size
- * must match what was provided for in a previous pci_map_single call.  All
- * other usages are undefined.
- *
- * After this call, reads by the cpu to the buffer are guaranteed to see
- * whatever the device wrote there.
- */
-void pci_unmap_single(struct pci_dev *hwdev, dma_addr_t ba, size_t size,
-    int direction)
-{
-        BUG_ON(direction == PCI_DMA_NONE);
-        if (direction != PCI_DMA_TODEVICE) {
-                mmu_inval_dma_area((unsigned long)phys_to_virt(ba),
-                    (size + PAGE_SIZE-1) & PAGE_MASK);
-        }
-}
-EXPORT_SYMBOL(pci_unmap_single);
 
 /*
  * Same as pci_map_single, but with pages.
  */
-dma_addr_t pci_map_page(struct pci_dev *hwdev, struct page *page,
-                        unsigned long offset, size_t size, int direction)
+static dma_addr_t pci32_map_page(struct device *dev, struct page *page,
+                                 unsigned long offset, size_t size,
+                                 enum dma_data_direction dir,
+                                 struct dma_attrs *attrs)
 {
-        BUG_ON(direction == PCI_DMA_NONE);
         /* IIep is write-through, not flushing. */
         return page_to_phys(page) + offset;
 }
-EXPORT_SYMBOL(pci_map_page);
-
-void pci_unmap_page(struct pci_dev *hwdev,
-                        dma_addr_t dma_address, size_t size, int direction)
-{
-        BUG_ON(direction == PCI_DMA_NONE);
-        /* mmu_inval_dma_area XXX */
-}
-EXPORT_SYMBOL(pci_unmap_page);
 
 /* Map a set of buffers described by scatterlist in streaming
  * mode for DMA.  This is the scather-gather version of the
@@ -551,13 +536,13 @@ EXPORT_SYMBOL(pci_unmap_page);
  * Device ownership issues as mentioned above for pci_map_single are
  * the same here.
  */
-int pci_map_sg(struct pci_dev *hwdev, struct scatterlist *sgl, int nents,
-    int direction)
+static int pci32_map_sg(struct device *device, struct scatterlist *sgl,
+                        int nents, enum dma_data_direction dir,
+                        struct dma_attrs *attrs)
 {
         struct scatterlist *sg;
         int n;
 
-        BUG_ON(direction == PCI_DMA_NONE);
         /* IIep is write-through, not flushing. */
         for_each_sg(sgl, sg, nents, n) {
                 BUG_ON(page_address(sg_page(sg)) == NULL);
@@ -566,20 +551,19 @@ int pci_map_sg(struct pci_dev *hwdev, struct scatterlist *sgl, int nents,
         }
         return nents;
 }
-EXPORT_SYMBOL(pci_map_sg);
 
 /* Unmap a set of streaming mode DMA translations.
  * Again, cpu read rules concerning calls here are the same as for
  * pci_unmap_single() above.
  */
-void pci_unmap_sg(struct pci_dev *hwdev, struct scatterlist *sgl, int nents,
-    int direction)
+static void pci32_unmap_sg(struct device *dev, struct scatterlist *sgl,
+                           int nents, enum dma_data_direction dir,
+                           struct dma_attrs *attrs)
 {
         struct scatterlist *sg;
         int n;
 
-        BUG_ON(direction == PCI_DMA_NONE);
-        if (direction != PCI_DMA_TODEVICE) {
+        if (dir != PCI_DMA_TODEVICE) {
                 for_each_sg(sgl, sg, nents, n) {
                         BUG_ON(page_address(sg_page(sg)) == NULL);
                         mmu_inval_dma_area(
@@ -588,7 +572,6 @@ void pci_unmap_sg(struct pci_dev *hwdev, struct scatterlist *sgl, int nents,
                 }
         }
 }
-EXPORT_SYMBOL(pci_unmap_sg);
 
 /* Make physical memory consistent for a single
  * streaming mode DMA translation before or after a transfer.
@@ -600,25 +583,23 @@ EXPORT_SYMBOL(pci_unmap_sg);
  * must first perform a pci_dma_sync_for_device, and then the
  * device again owns the buffer.
  */
-void pci_dma_sync_single_for_cpu(struct pci_dev *hwdev, dma_addr_t ba, size_t size, int direction)
+static void pci32_sync_single_for_cpu(struct device *dev, dma_addr_t ba,
+                                      size_t size, enum dma_data_direction dir)
 {
-        BUG_ON(direction == PCI_DMA_NONE);
-        if (direction != PCI_DMA_TODEVICE) {
+        if (dir != PCI_DMA_TODEVICE) {
                 mmu_inval_dma_area((unsigned long)phys_to_virt(ba),
                     (size + PAGE_SIZE-1) & PAGE_MASK);
         }
 }
-EXPORT_SYMBOL(pci_dma_sync_single_for_cpu);
 
-void pci_dma_sync_single_for_device(struct pci_dev *hwdev, dma_addr_t ba, size_t size, int direction)
+static void pci32_sync_single_for_device(struct device *dev, dma_addr_t ba,
+                                         size_t size, enum dma_data_direction dir)
 {
-        BUG_ON(direction == PCI_DMA_NONE);
-        if (direction != PCI_DMA_TODEVICE) {
+        if (dir != PCI_DMA_TODEVICE) {
                 mmu_inval_dma_area((unsigned long)phys_to_virt(ba),
                     (size + PAGE_SIZE-1) & PAGE_MASK);
         }
 }
-EXPORT_SYMBOL(pci_dma_sync_single_for_device);
 
 /* Make physical memory consistent for a set of streaming
  * mode DMA translations after a transfer.
@@ -626,13 +607,13 @@ EXPORT_SYMBOL(pci_dma_sync_single_for_device);
  * The same as pci_dma_sync_single_* but for a scatter-gather list,
  * same rules and usage.
  */
-void pci_dma_sync_sg_for_cpu(struct pci_dev *hwdev, struct scatterlist *sgl, int nents, int direction)
+static void pci32_sync_sg_for_cpu(struct device *dev, struct scatterlist *sgl,
+                                  int nents, enum dma_data_direction dir)
 {
         struct scatterlist *sg;
         int n;
 
-        BUG_ON(direction == PCI_DMA_NONE);
-        if (direction != PCI_DMA_TODEVICE) {
+        if (dir != PCI_DMA_TODEVICE) {
                 for_each_sg(sgl, sg, nents, n) {
                         BUG_ON(page_address(sg_page(sg)) == NULL);
                         mmu_inval_dma_area(
@@ -641,15 +622,14 @@ void pci_dma_sync_sg_for_cpu(struct pci_dev *hwdev, struct scatterlist *sgl, int
                 }
         }
 }
-EXPORT_SYMBOL(pci_dma_sync_sg_for_cpu);
 
-void pci_dma_sync_sg_for_device(struct pci_dev *hwdev, struct scatterlist *sgl, int nents, int direction)
+static void pci32_sync_sg_for_device(struct device *device, struct scatterlist *sgl,
+                                     int nents, enum dma_data_direction dir)
 {
         struct scatterlist *sg;
         int n;
 
-        BUG_ON(direction == PCI_DMA_NONE);
-        if (direction != PCI_DMA_TODEVICE) {
+        if (dir != PCI_DMA_TODEVICE) {
                 for_each_sg(sgl, sg, nents, n) {
                         BUG_ON(page_address(sg_page(sg)) == NULL);
                         mmu_inval_dma_area(
@@ -658,9 +638,49 @@ void pci_dma_sync_sg_for_device(struct pci_dev *hwdev, struct scatterlist *sgl,
                 }
         }
 }
-EXPORT_SYMBOL(pci_dma_sync_sg_for_device);
+
+struct dma_map_ops pci32_dma_ops = {
+        .alloc_coherent         = pci32_alloc_coherent,
+        .free_coherent          = pci32_free_coherent,
+        .map_page               = pci32_map_page,
+        .map_sg                 = pci32_map_sg,
+        .unmap_sg               = pci32_unmap_sg,
+        .sync_single_for_cpu    = pci32_sync_single_for_cpu,
+        .sync_single_for_device = pci32_sync_single_for_device,
+        .sync_sg_for_cpu        = pci32_sync_sg_for_cpu,
+        .sync_sg_for_device     = pci32_sync_sg_for_device,
+};
+EXPORT_SYMBOL(pci32_dma_ops);
+
 #endif /* CONFIG_PCI */
 
+/*
+ * Return whether the given PCI device DMA address mask can be
+ * supported properly.  For example, if your device can only drive the
+ * low 24-bits during PCI bus mastering, then you would pass
+ * 0x00ffffff as the mask to this function.
+ */
+int dma_supported(struct device *dev, u64 mask)
+{
+#ifdef CONFIG_PCI
+        if (dev->bus == &pci_bus_type)
+                return 1;
+#endif
+        return 0;
+}
+EXPORT_SYMBOL(dma_supported);
+
+int dma_set_mask(struct device *dev, u64 dma_mask)
+{
+#ifdef CONFIG_PCI
+        if (dev->bus == &pci_bus_type)
+                return pci_set_dma_mask(to_pci_dev(dev), dma_mask);
+#endif
+        return -EOPNOTSUPP;
+}
+EXPORT_SYMBOL(dma_set_mask);
+
+
 #ifdef CONFIG_PROC_FS
 
 static int
diff --git a/arch/sparc/kernel/pci.c b/arch/sparc/kernel/pci.c
index 57859ad23547..c68648662802 100644
--- a/arch/sparc/kernel/pci.c
+++ b/arch/sparc/kernel/pci.c
@@ -1039,7 +1039,7 @@ static void ali_sound_dma_hack(struct pci_dev *pdev, int set_bit)
         pci_dev_put(ali_isa_bridge);
 }
 
-int pci_dma_supported(struct pci_dev *pdev, u64 device_mask)
+int pci64_dma_supported(struct pci_dev *pdev, u64 device_mask)
 {
         u64 dma_addr_mask;
 
diff --git a/arch/sparc/kernel/pci_sun4v.c b/arch/sparc/kernel/pci_sun4v.c
index 2485eaa23101..23c33ff9c31e 100644
--- a/arch/sparc/kernel/pci_sun4v.c
+++ b/arch/sparc/kernel/pci_sun4v.c
@@ -232,7 +232,8 @@ static void dma_4v_free_coherent(struct device *dev, size_t size, void *cpu,
 
 static dma_addr_t dma_4v_map_page(struct device *dev, struct page *page,
                                   unsigned long offset, size_t sz,
-                                  enum dma_data_direction direction)
+                                  enum dma_data_direction direction,
+                                  struct dma_attrs *attrs)
 {
         struct iommu *iommu;
         unsigned long flags, npages, oaddr;
@@ -296,7 +297,8 @@ iommu_map_fail:
 }
 
 static void dma_4v_unmap_page(struct device *dev, dma_addr_t bus_addr,
-                              size_t sz, enum dma_data_direction direction)
+                              size_t sz, enum dma_data_direction direction,
+                              struct dma_attrs *attrs)
 {
         struct pci_pbm_info *pbm;
         struct iommu *iommu;
@@ -336,7 +338,8 @@ static void dma_4v_unmap_page(struct device *dev, dma_addr_t bus_addr,
 }
 
 static int dma_4v_map_sg(struct device *dev, struct scatterlist *sglist,
-                         int nelems, enum dma_data_direction direction)
+                         int nelems, enum dma_data_direction direction,
+                         struct dma_attrs *attrs)
 {
         struct scatterlist *s, *outs, *segstart;
         unsigned long flags, handle, prot;
@@ -478,7 +481,8 @@ iommu_map_failed:
 }
 
 static void dma_4v_unmap_sg(struct device *dev, struct scatterlist *sglist,
-                            int nelems, enum dma_data_direction direction)
+                            int nelems, enum dma_data_direction direction,
+                            struct dma_attrs *attrs)
 {
         struct pci_pbm_info *pbm;
         struct scatterlist *sg;
@@ -521,29 +525,13 @@ static void dma_4v_unmap_sg(struct device *dev, struct scatterlist *sglist,
         spin_unlock_irqrestore(&iommu->lock, flags);
 }
 
-static void dma_4v_sync_single_for_cpu(struct device *dev,
-                                       dma_addr_t bus_addr, size_t sz,
-                                       enum dma_data_direction direction)
-{
-        /* Nothing to do... */
-}
-
-static void dma_4v_sync_sg_for_cpu(struct device *dev,
-                                   struct scatterlist *sglist, int nelems,
-                                   enum dma_data_direction direction)
-{
-        /* Nothing to do... */
-}
-
-static const struct dma_ops sun4v_dma_ops = {
+static struct dma_map_ops sun4v_dma_ops = {
         .alloc_coherent                 = dma_4v_alloc_coherent,
         .free_coherent                  = dma_4v_free_coherent,
         .map_page                       = dma_4v_map_page,
         .unmap_page                     = dma_4v_unmap_page,
         .map_sg                         = dma_4v_map_sg,
         .unmap_sg                       = dma_4v_unmap_sg,
-        .sync_single_for_cpu            = dma_4v_sync_single_for_cpu,
-        .sync_sg_for_cpu                = dma_4v_sync_sg_for_cpu,
 };
 
 static void __devinit pci_sun4v_scan_bus(struct pci_pbm_info *pbm,
diff --git a/arch/sparc/kernel/process_64.c b/arch/sparc/kernel/process_64.c
index 4041f94e7724..18d67854a1b8 100644
--- a/arch/sparc/kernel/process_64.c
+++ b/arch/sparc/kernel/process_64.c
@@ -251,7 +251,7 @@ static void __global_reg_poll(struct global_reg_snapshot *gp)
         }
 }
 
-void __trigger_all_cpu_backtrace(void)
+void arch_trigger_all_cpu_backtrace(void)
 {
         struct thread_info *tp = current_thread_info();
         struct pt_regs *regs = get_irq_regs();
@@ -304,7 +304,7 @@ void __trigger_all_cpu_backtrace(void)
 
 static void sysrq_handle_globreg(int key, struct tty_struct *tty)
 {
-        __trigger_all_cpu_backtrace();
+        arch_trigger_all_cpu_backtrace();
 }
 
 static struct sysrq_key_op sparc_globalreg_op = {
diff --git a/arch/x86/Kconfig b/arch/x86/Kconfig
index 13ffa5df37d7..fc20fdc0f7f2 100644
--- a/arch/x86/Kconfig
+++ b/arch/x86/Kconfig
@@ -38,7 +38,7 @@ config X86
         select HAVE_FUNCTION_GRAPH_FP_TEST
         select HAVE_FUNCTION_TRACE_MCOUNT_TEST
         select HAVE_FTRACE_NMI_ENTER if DYNAMIC_FTRACE
-        select HAVE_FTRACE_SYSCALLS
+        select HAVE_SYSCALL_TRACEPOINTS
         select HAVE_KVM
         select HAVE_ARCH_KGDB
         select HAVE_ARCH_TRACEHOOK
@@ -586,7 +586,6 @@ config GART_IOMMU
         bool "GART IOMMU support" if EMBEDDED
         default y
         select SWIOTLB
-        select AGP
         depends on X86_64 && PCI
         ---help---
           Support for full DMA access of devices with 32bit memory access only
diff --git a/arch/x86/configs/i386_defconfig b/arch/x86/configs/i386_defconfig
index edb992ebef92..d28fad19654a 100644
--- a/arch/x86/configs/i386_defconfig
+++ b/arch/x86/configs/i386_defconfig
@@ -2355,7 +2355,7 @@ CONFIG_HAVE_FUNCTION_TRACE_MCOUNT_TEST=y
 CONFIG_HAVE_DYNAMIC_FTRACE=y
 CONFIG_HAVE_FTRACE_MCOUNT_RECORD=y
 CONFIG_HAVE_HW_BRANCH_TRACER=y
-CONFIG_HAVE_FTRACE_SYSCALLS=y
+CONFIG_HAVE_SYSCALL_TRACEPOINTS=y
 CONFIG_RING_BUFFER=y
 CONFIG_TRACING=y
 CONFIG_TRACING_SUPPORT=y
diff --git a/arch/x86/configs/x86_64_defconfig b/arch/x86/configs/x86_64_defconfig
index cee1dd2e69b2..6c86acd847a4 100644
--- a/arch/x86/configs/x86_64_defconfig
+++ b/arch/x86/configs/x86_64_defconfig
@@ -2329,7 +2329,7 @@ CONFIG_HAVE_FUNCTION_TRACE_MCOUNT_TEST=y
 CONFIG_HAVE_DYNAMIC_FTRACE=y
 CONFIG_HAVE_FTRACE_MCOUNT_RECORD=y
 CONFIG_HAVE_HW_BRANCH_TRACER=y
-CONFIG_HAVE_FTRACE_SYSCALLS=y
+CONFIG_HAVE_SYSCALL_TRACEPOINTS=y
 CONFIG_RING_BUFFER=y
 CONFIG_TRACING=y
 CONFIG_TRACING_SUPPORT=y
diff --git a/arch/x86/include/asm/amd_iommu.h b/arch/x86/include/asm/amd_iommu.h
index bdf96f119f06..ac95995b7bad 100644
--- a/arch/x86/include/asm/amd_iommu.h
+++ b/arch/x86/include/asm/amd_iommu.h
@@ -25,6 +25,7 @@
 #ifdef CONFIG_AMD_IOMMU
 extern int amd_iommu_init(void);
 extern int amd_iommu_init_dma_ops(void);
+extern int amd_iommu_init_passthrough(void);
 extern void amd_iommu_detect(void);
 extern irqreturn_t amd_iommu_int_handler(int irq, void *data);
 extern void amd_iommu_flush_all_domains(void);
diff --git a/arch/x86/include/asm/amd_iommu_types.h b/arch/x86/include/asm/amd_iommu_types.h
index 0c878caaa0a2..2a2cc7a78a81 100644
--- a/arch/x86/include/asm/amd_iommu_types.h
+++ b/arch/x86/include/asm/amd_iommu_types.h
@@ -143,22 +143,29 @@
 #define EVT_BUFFER_SIZE         8192 /* 512 entries */
 #define EVT_LEN_MASK            (0x9ULL << 56)
 
+#define PAGE_MODE_NONE    0x00
 #define PAGE_MODE_1_LEVEL 0x01
 #define PAGE_MODE_2_LEVEL 0x02
 #define PAGE_MODE_3_LEVEL 0x03
-
-#define IOMMU_PDE_NL_0   0x000ULL
-#define IOMMU_PDE_NL_1   0x200ULL
-#define IOMMU_PDE_NL_2   0x400ULL
-#define IOMMU_PDE_NL_3   0x600ULL
-
-#define IOMMU_PTE_L2_INDEX(address) (((address) >> 30) & 0x1ffULL)
-#define IOMMU_PTE_L1_INDEX(address) (((address) >> 21) & 0x1ffULL)
-#define IOMMU_PTE_L0_INDEX(address) (((address) >> 12) & 0x1ffULL)
-
-#define IOMMU_MAP_SIZE_L1 (1ULL << 21)
-#define IOMMU_MAP_SIZE_L2 (1ULL << 30)
-#define IOMMU_MAP_SIZE_L3 (1ULL << 39)
+#define PAGE_MODE_4_LEVEL 0x04
+#define PAGE_MODE_5_LEVEL 0x05
+#define PAGE_MODE_6_LEVEL 0x06
+
+#define PM_LEVEL_SHIFT(x)       (12 + ((x) * 9))
+#define PM_LEVEL_SIZE(x)        (((x) < 6) ? \
+                                  ((1ULL << PM_LEVEL_SHIFT((x))) - 1): \
+                                   (0xffffffffffffffffULL))
+#define PM_LEVEL_INDEX(x, a)    (((a) >> PM_LEVEL_SHIFT((x))) & 0x1ffULL)
+#define PM_LEVEL_ENC(x)         (((x) << 9) & 0xe00ULL)
+#define PM_LEVEL_PDE(x, a)      ((a) | PM_LEVEL_ENC((x)) | \
+                                 IOMMU_PTE_P | IOMMU_PTE_IR | IOMMU_PTE_IW)
+#define PM_PTE_LEVEL(pte)       (((pte) >> 9) & 0x7ULL)
+
+#define PM_MAP_4k               0
+#define PM_ADDR_MASK            0x000ffffffffff000ULL
+#define PM_MAP_MASK(lvl)        (PM_ADDR_MASK & \
+                                (~((1ULL << (12 + ((lvl) * 9))) - 1)))
+#define PM_ALIGNED(lvl, addr)   ((PM_MAP_MASK(lvl) & (addr)) == (addr))
 
 #define IOMMU_PTE_P  (1ULL << 0)
 #define IOMMU_PTE_TV (1ULL << 1)
@@ -167,11 +174,6 @@
 #define IOMMU_PTE_IR (1ULL << 61)
 #define IOMMU_PTE_IW (1ULL << 62)
 
-#define IOMMU_L1_PDE(address) \
-        ((address) | IOMMU_PDE_NL_1 | IOMMU_PTE_P | IOMMU_PTE_IR | IOMMU_PTE_IW)
-#define IOMMU_L2_PDE(address) \
-        ((address) | IOMMU_PDE_NL_2 | IOMMU_PTE_P | IOMMU_PTE_IR | IOMMU_PTE_IW)
-
 #define IOMMU_PAGE_MASK (((1ULL << 52) - 1) & ~0xfffULL)
 #define IOMMU_PTE_PRESENT(pte) ((pte) & IOMMU_PTE_P)
 #define IOMMU_PTE_PAGE(pte) (phys_to_virt((pte) & IOMMU_PAGE_MASK))
@@ -194,11 +196,14 @@
 #define PD_DMA_OPS_MASK         (1UL << 0) /* domain used for dma_ops */
 #define PD_DEFAULT_MASK         (1UL << 1) /* domain is a default dma_ops
                                               domain for an IOMMU */
+#define PD_PASSTHROUGH_MASK     (1UL << 2) /* domain has no page
+                                              translation */
+
 extern bool amd_iommu_dump;
 #define DUMP_printk(format, arg...)                                     \
         do {                                                            \
                 if (amd_iommu_dump)                                             \
-                        printk(KERN_INFO "AMD IOMMU: " format, ## arg); \
+                        printk(KERN_INFO "AMD-Vi: " format, ## arg);    \
         } while(0);
 
 /*
@@ -226,6 +231,7 @@ struct protection_domain {
         int mode;               /* paging mode (0-6 levels) */
         u64 *pt_root;           /* page table root pointer */
         unsigned long flags;    /* flags to find out type of domain */
+        bool updated;           /* complete domain flush required */
         unsigned dev_cnt;       /* devices assigned to this domain */
         void *priv;             /* private data */
 };
@@ -337,6 +343,9 @@ struct amd_iommu {
         /* if one, we need to send a completion wait command */
         bool need_sync;
 
+        /* becomes true if a command buffer reset is running */
+        bool reset_in_progress;
+
         /* default dma_ops domain for that IOMMU */
         struct dma_ops_domain *default_dom;
 };
@@ -457,4 +466,7 @@ static inline void amd_iommu_stats_init(void) { }
 
 #endif /* CONFIG_AMD_IOMMU_STATS */
 
+/* some function prototypes */
+extern void amd_iommu_reset_cmd_buffer(struct amd_iommu *iommu);
+
 #endif /* _ASM_X86_AMD_IOMMU_TYPES_H */
diff --git a/arch/x86/include/asm/dma-mapping.h b/arch/x86/include/asm/dma-mapping.h
index 1c3f9435f1c9..0ee770d23d0e 100644
--- a/arch/x86/include/asm/dma-mapping.h
+++ b/arch/x86/include/asm/dma-mapping.h
@@ -55,6 +55,24 @@ extern int dma_set_mask(struct device *dev, u64 mask);
 extern void *dma_generic_alloc_coherent(struct device *dev, size_t size,
                                         dma_addr_t *dma_addr, gfp_t flag);
 
+static inline bool dma_capable(struct device *dev, dma_addr_t addr, size_t size)
+{
+        if (!dev->dma_mask)
+                return 0;
+
+        return addr + size <= *dev->dma_mask;
+}
+
+static inline dma_addr_t phys_to_dma(struct device *dev, phys_addr_t paddr)
+{
+        return paddr;
+}
+
+static inline phys_addr_t dma_to_phys(struct device *dev, dma_addr_t daddr)
+{
+        return daddr;
+}
+
 static inline void
 dma_cache_sync(struct device *dev, void *vaddr, size_t size,
         enum dma_data_direction dir)
diff --git a/arch/x86/include/asm/ftrace.h b/arch/x86/include/asm/ftrace.h
index bd2c6511c887..db24c2278be0 100644
--- a/arch/x86/include/asm/ftrace.h
+++ b/arch/x86/include/asm/ftrace.h
@@ -28,13 +28,6 @@
 
 #endif
 
-/* FIXME: I don't want to stay hardcoded */
-#ifdef CONFIG_X86_64
-# define FTRACE_SYSCALL_MAX     296
-#else
-# define FTRACE_SYSCALL_MAX     333
-#endif
-
 #ifdef CONFIG_FUNCTION_TRACER
 #define MCOUNT_ADDR             ((long)(mcount))
 #define MCOUNT_INSN_SIZE        5 /* sizeof mcount call */
diff --git a/arch/x86/include/asm/nmi.h b/arch/x86/include/asm/nmi.h
index c86e5ed4af51..e63cf7d441e1 100644
--- a/arch/x86/include/asm/nmi.h
+++ b/arch/x86/include/asm/nmi.h
@@ -45,8 +45,8 @@ extern int proc_nmi_enabled(struct ctl_table *, int , struct file *,
                         void __user *, size_t *, loff_t *);
 extern int unknown_nmi_panic;
 
-void __trigger_all_cpu_backtrace(void);
-#define trigger_all_cpu_backtrace() __trigger_all_cpu_backtrace()
+void arch_trigger_all_cpu_backtrace(void);
+#define arch_trigger_all_cpu_backtrace arch_trigger_all_cpu_backtrace
 
 static inline void localise_nmi_watchdog(void)
 {
diff --git a/arch/x86/include/asm/perf_counter.h b/arch/x86/include/asm/perf_counter.h
index fa64e401589d..e7b7c938ae27 100644
--- a/arch/x86/include/asm/perf_counter.h
+++ b/arch/x86/include/asm/perf_counter.h
@@ -84,6 +84,16 @@ union cpuid10_edx {
 #define MSR_ARCH_PERFMON_FIXED_CTR2                     0x30b
 #define X86_PMC_IDX_FIXED_BUS_CYCLES                    (X86_PMC_IDX_FIXED + 2)
 
+/*
+ * We model BTS tracing as another fixed-mode PMC.
+ *
+ * We choose a value in the middle of the fixed counter range, since lower
+ * values are used by actual fixed counters and higher values are used
+ * to indicate other overflow conditions in the PERF_GLOBAL_STATUS msr.
+ */
+#define X86_PMC_IDX_FIXED_BTS                           (X86_PMC_IDX_FIXED + 16)
+
+
 #ifdef CONFIG_PERF_COUNTERS
 extern void init_hw_perf_counters(void);
 extern void perf_counters_lapic_init(void);
diff --git a/arch/x86/include/asm/thread_info.h b/arch/x86/include/asm/thread_info.h
index fad7d40b75f8..6f7786aea4fc 100644
--- a/arch/x86/include/asm/thread_info.h
+++ b/arch/x86/include/asm/thread_info.h
@@ -95,7 +95,7 @@ struct thread_info {
 #define TIF_DEBUGCTLMSR         25      /* uses thread_struct.debugctlmsr */
 #define TIF_DS_AREA_MSR         26      /* uses thread_struct.ds_area_msr */
 #define TIF_LAZY_MMU_UPDATES    27      /* task is updating the mmu lazily */
-#define TIF_SYSCALL_FTRACE      28      /* for ftrace syscall instrumentation */
+#define TIF_SYSCALL_TRACEPOINT  28      /* syscall tracepoint instrumentation */
 
 #define _TIF_SYSCALL_TRACE      (1 << TIF_SYSCALL_TRACE)
 #define _TIF_NOTIFY_RESUME      (1 << TIF_NOTIFY_RESUME)
@@ -118,17 +118,17 @@ struct thread_info {
 #define _TIF_DEBUGCTLMSR        (1 << TIF_DEBUGCTLMSR)
 #define _TIF_DS_AREA_MSR        (1 << TIF_DS_AREA_MSR)
 #define _TIF_LAZY_MMU_UPDATES   (1 << TIF_LAZY_MMU_UPDATES)
-#define _TIF_SYSCALL_FTRACE     (1 << TIF_SYSCALL_FTRACE)
+#define _TIF_SYSCALL_TRACEPOINT (1 << TIF_SYSCALL_TRACEPOINT)
 
 /* work to do in syscall_trace_enter() */
 #define _TIF_WORK_SYSCALL_ENTRY \
-        (_TIF_SYSCALL_TRACE | _TIF_SYSCALL_EMU | _TIF_SYSCALL_FTRACE |  \
-         _TIF_SYSCALL_AUDIT | _TIF_SECCOMP | _TIF_SINGLESTEP)
+        (_TIF_SYSCALL_TRACE | _TIF_SYSCALL_EMU | _TIF_SYSCALL_AUDIT |   \
+         _TIF_SECCOMP | _TIF_SINGLESTEP | _TIF_SYSCALL_TRACEPOINT)
 
 /* work to do in syscall_trace_leave() */
 #define _TIF_WORK_SYSCALL_EXIT  \
         (_TIF_SYSCALL_TRACE | _TIF_SYSCALL_AUDIT | _TIF_SINGLESTEP |    \
-         _TIF_SYSCALL_FTRACE)
+         _TIF_SYSCALL_TRACEPOINT)
 
 /* work to do on interrupt/exception return */
 #define _TIF_WORK_MASK                                                  \
@@ -137,7 +137,8 @@ struct thread_info {
            _TIF_SINGLESTEP|_TIF_SECCOMP|_TIF_SYSCALL_EMU))
 
 /* work to do on any return to user space */
-#define _TIF_ALLWORK_MASK ((0x0000FFFF & ~_TIF_SECCOMP) | _TIF_SYSCALL_FTRACE)
+#define _TIF_ALLWORK_MASK                                               \
+        ((0x0000FFFF & ~_TIF_SECCOMP) | _TIF_SYSCALL_TRACEPOINT)
 
 /* Only used for 64 bit */
 #define _TIF_DO_NOTIFY_MASK                                             \
diff --git a/arch/x86/include/asm/topology.h b/arch/x86/include/asm/topology.h
index 066ef590d7e0..26d06e052a18 100644
--- a/arch/x86/include/asm/topology.h
+++ b/arch/x86/include/asm/topology.h
@@ -129,25 +129,34 @@ extern unsigned long node_remap_size[];
 #endif
 
 /* sched_domains SD_NODE_INIT for NUMA machines */
-#define SD_NODE_INIT (struct sched_domain) {            \
-        .min_interval           = 8,                    \
-        .max_interval           = 32,                   \
-        .busy_factor            = 32,                   \
-        .imbalance_pct          = 125,                  \
-        .cache_nice_tries       = SD_CACHE_NICE_TRIES,  \
-        .busy_idx               = 3,                    \
-        .idle_idx               = SD_IDLE_IDX,          \
-        .newidle_idx            = SD_NEWIDLE_IDX,       \
-        .wake_idx               = 1,                    \
-        .forkexec_idx           = SD_FORKEXEC_IDX,      \
-        .flags                  = SD_LOAD_BALANCE       \
-                                | SD_BALANCE_EXEC       \
-                                | SD_BALANCE_FORK       \
-                                | SD_WAKE_AFFINE        \
-                                | SD_WAKE_BALANCE       \
-                                | SD_SERIALIZE,         \
-        .last_balance           = jiffies,              \
-        .balance_interval       = 1,                    \
+#define SD_NODE_INIT (struct sched_domain) {                            \
+        .min_interval           = 8,                                    \
+        .max_interval           = 32,                                   \
+        .busy_factor            = 32,                                   \
+        .imbalance_pct          = 125,                                  \
+        .cache_nice_tries       = SD_CACHE_NICE_TRIES,                  \
+        .busy_idx               = 3,                                    \
+        .idle_idx               = SD_IDLE_IDX,                          \
+        .newidle_idx            = SD_NEWIDLE_IDX,                       \
+        .wake_idx               = 1,                                    \
+        .forkexec_idx           = SD_FORKEXEC_IDX,                      \
+                                                                        \
+        .flags                  = 1*SD_LOAD_BALANCE                     \
+                                | 1*SD_BALANCE_NEWIDLE                  \
+                                | 1*SD_BALANCE_EXEC                     \
+                                | 1*SD_BALANCE_FORK                     \
+                                | 0*SD_WAKE_IDLE                        \
+                                | 1*SD_WAKE_AFFINE                      \
+                                | 1*SD_WAKE_BALANCE                     \
+                                | 0*SD_SHARE_CPUPOWER                   \
+                                | 0*SD_POWERSAVINGS_BALANCE             \
+                                | 0*SD_SHARE_PKG_RESOURCES              \
+                                | 1*SD_SERIALIZE                        \
+                                | 1*SD_WAKE_IDLE_FAR                    \
+                                | 0*SD_PREFER_SIBLING                   \
+                                ,                                       \
+        .last_balance           = jiffies,                              \
+        .balance_interval       = 1,                                    \
 }
 
 #ifdef CONFIG_X86_64_ACPI_NUMA
diff --git a/arch/x86/include/asm/unistd_32.h b/arch/x86/include/asm/unistd_32.h
index 732a30706153..8deaada61bc8 100644
--- a/arch/x86/include/asm/unistd_32.h
+++ b/arch/x86/include/asm/unistd_32.h
@@ -345,6 +345,8 @@
 
 #ifdef __KERNEL__
 
+#define NR_syscalls 337
+
 #define __ARCH_WANT_IPC_PARSE_VERSION
 #define __ARCH_WANT_OLD_READDIR
 #define __ARCH_WANT_OLD_STAT
diff --git a/arch/x86/include/asm/unistd_64.h b/arch/x86/include/asm/unistd_64.h
index 900e1617e672..b9f3c60de5f7 100644
--- a/arch/x86/include/asm/unistd_64.h
+++ b/arch/x86/include/asm/unistd_64.h
@@ -688,6 +688,12 @@ __SYSCALL(__NR_perf_counter_open, sys_perf_counter_open)
 #endif  /* __NO_STUBS */
 
 #ifdef __KERNEL__
+
+#ifndef COMPILE_OFFSETS
+#include <asm/asm-offsets.h>
+#define NR_syscalls (__NR_syscall_max + 1)
+#endif
+
 /*
  * "Conditional" syscalls
  *
diff --git a/arch/x86/kernel/amd_iommu.c b/arch/x86/kernel/amd_iommu.c
index 6c99f5037801..98f230f6a28d 100644
--- a/arch/x86/kernel/amd_iommu.c
+++ b/arch/x86/kernel/amd_iommu.c
@@ -41,9 +41,13 @@ static DEFINE_RWLOCK(amd_iommu_devtable_lock);
 static LIST_HEAD(iommu_pd_list);
 static DEFINE_SPINLOCK(iommu_pd_list_lock);
 
-#ifdef CONFIG_IOMMU_API
+/*
+ * Domain for untranslated devices - only allocated
+ * if iommu=pt passed on kernel cmd line.
+ */
+static struct protection_domain *pt_domain;
+
 static struct iommu_ops amd_iommu_ops;
-#endif
 
 /*
  * general struct to manage commands send to an IOMMU
@@ -55,16 +59,16 @@ struct iommu_cmd {
 static int dma_ops_unity_map(struct dma_ops_domain *dma_dom,
                              struct unity_map_entry *e);
 static struct dma_ops_domain *find_protection_domain(u16 devid);
-static u64* alloc_pte(struct protection_domain *dom,
-                      unsigned long address, u64
-                      **pte_page, gfp_t gfp);
+static u64 *alloc_pte(struct protection_domain *domain,
+                      unsigned long address, int end_lvl,
+                      u64 **pte_page, gfp_t gfp);
 static void dma_ops_reserve_addresses(struct dma_ops_domain *dom,
                                       unsigned long start_page,
                                       unsigned int pages);
-
-#ifndef BUS_NOTIFY_UNBOUND_DRIVER
-#define BUS_NOTIFY_UNBOUND_DRIVER 0x0005
-#endif
+static void reset_iommu_command_buffer(struct amd_iommu *iommu);
+static u64 *fetch_pte(struct protection_domain *domain,
+                      unsigned long address, int map_size);
+static void update_domain(struct protection_domain *domain);
 
 #ifdef CONFIG_AMD_IOMMU_STATS
 
@@ -138,7 +142,25 @@ static int iommu_has_npcache(struct amd_iommu *iommu)
  *
  ****************************************************************************/
 
-static void iommu_print_event(void *__evt)
+static void dump_dte_entry(u16 devid)
+{
+        int i;
+
+        for (i = 0; i < 8; ++i)
+                pr_err("AMD-Vi: DTE[%d]: %08x\n", i,
+                        amd_iommu_dev_table[devid].data[i]);
+}
+
+static void dump_command(unsigned long phys_addr)
+{
+        struct iommu_cmd *cmd = phys_to_virt(phys_addr);
+        int i;
+
+        for (i = 0; i < 4; ++i)
+                pr_err("AMD-Vi: CMD[%d]: %08x\n", i, cmd->data[i]);
+}
+
+static void iommu_print_event(struct amd_iommu *iommu, void *__evt)
 {
         u32 *event = __evt;
         int type  = (event[1] >> EVENT_TYPE_SHIFT)  & EVENT_TYPE_MASK;
@@ -147,7 +169,7 @@ static void iommu_print_event(void *__evt)
         int flags = (event[1] >> EVENT_FLAGS_SHIFT) & EVENT_FLAGS_MASK;
         u64 address = (u64)(((u64)event[3]) << 32) | event[2];
 
-        printk(KERN_ERR "AMD IOMMU: Event logged [");
+        printk(KERN_ERR "AMD-Vi: Event logged [");
 
         switch (type) {
         case EVENT_TYPE_ILL_DEV:
@@ -155,6 +177,7 @@ static void iommu_print_event(void *__evt)
                        "address=0x%016llx flags=0x%04x]\n",
                        PCI_BUS(devid), PCI_SLOT(devid), PCI_FUNC(devid),
                        address, flags);
+                dump_dte_entry(devid);
                 break;
         case EVENT_TYPE_IO_FAULT:
                 printk("IO_PAGE_FAULT device=%02x:%02x.%x "
@@ -176,6 +199,8 @@ static void iommu_print_event(void *__evt)
                 break;
         case EVENT_TYPE_ILL_CMD:
                 printk("ILLEGAL_COMMAND_ERROR address=0x%016llx]\n", address);
+                reset_iommu_command_buffer(iommu);
+                dump_command(address);
                 break;
         case EVENT_TYPE_CMD_HARD_ERR:
                 printk("COMMAND_HARDWARE_ERROR address=0x%016llx "
@@ -209,7 +234,7 @@ static void iommu_poll_events(struct amd_iommu *iommu)
         tail = readl(iommu->mmio_base + MMIO_EVT_TAIL_OFFSET);
 
         while (head != tail) {
-                iommu_print_event(iommu->evt_buf + head);
+                iommu_print_event(iommu, iommu->evt_buf + head);
                 head = (head + EVENT_ENTRY_SIZE) % iommu->evt_buf_size;
         }
 
@@ -296,8 +321,11 @@ static void __iommu_wait_for_completion(struct amd_iommu *iommu)
         status &= ~MMIO_STATUS_COM_WAIT_INT_MASK;
         writel(status, iommu->mmio_base + MMIO_STATUS_OFFSET);
 
-        if (unlikely(i == EXIT_LOOP_COUNT))
-                panic("AMD IOMMU: Completion wait loop failed\n");
+        if (unlikely(i == EXIT_LOOP_COUNT)) {
+                spin_unlock(&iommu->lock);
+                reset_iommu_command_buffer(iommu);
+                spin_lock(&iommu->lock);
+        }
 }
 
 /*
@@ -445,47 +473,78 @@ static void iommu_flush_tlb_pde(struct amd_iommu *iommu, u16 domid)
 }
 
 /*
+ * This function flushes one domain on one IOMMU
+ */
+static void flush_domain_on_iommu(struct amd_iommu *iommu, u16 domid)
+{
+        struct iommu_cmd cmd;
+        unsigned long flags;
+
+        __iommu_build_inv_iommu_pages(&cmd, CMD_INV_IOMMU_ALL_PAGES_ADDRESS,
+                                      domid, 1, 1);
+
+        spin_lock_irqsave(&iommu->lock, flags);
+        __iommu_queue_command(iommu, &cmd);
+        __iommu_completion_wait(iommu);
+        __iommu_wait_for_completion(iommu);
+        spin_unlock_irqrestore(&iommu->lock, flags);
+}
+
+static void flush_all_domains_on_iommu(struct amd_iommu *iommu)
+{
+        int i;
+
+        for (i = 1; i < MAX_DOMAIN_ID; ++i) {
+                if (!test_bit(i, amd_iommu_pd_alloc_bitmap))
+                        continue;
+                flush_domain_on_iommu(iommu, i);
+        }
+
+}
+
+/*
  * This function is used to flush the IO/TLB for a given protection domain
  * on every IOMMU in the system
  */
 static void iommu_flush_domain(u16 domid)
 {
-        unsigned long flags;
         struct amd_iommu *iommu;
-        struct iommu_cmd cmd;
 
         INC_STATS_COUNTER(domain_flush_all);
 
-        __iommu_build_inv_iommu_pages(&cmd, CMD_INV_IOMMU_ALL_PAGES_ADDRESS,
-                                      domid, 1, 1);
-
-        for_each_iommu(iommu) {
-                spin_lock_irqsave(&iommu->lock, flags);
-                __iommu_queue_command(iommu, &cmd);
-                __iommu_completion_wait(iommu);
-                __iommu_wait_for_completion(iommu);
-                spin_unlock_irqrestore(&iommu->lock, flags);
-        }
+        for_each_iommu(iommu)
+                flush_domain_on_iommu(iommu, domid);
 }
 
 void amd_iommu_flush_all_domains(void)
 {
+        struct amd_iommu *iommu;
+
+        for_each_iommu(iommu)
+                flush_all_domains_on_iommu(iommu);
+}
+
+static void flush_all_devices_for_iommu(struct amd_iommu *iommu)
+{
         int i;
 
-        for (i = 1; i < MAX_DOMAIN_ID; ++i) {
-                if (!test_bit(i, amd_iommu_pd_alloc_bitmap))
+        for (i = 0; i <= amd_iommu_last_bdf; ++i) {
+                if (iommu != amd_iommu_rlookup_table[i])
                         continue;
-                iommu_flush_domain(i);
+
+                iommu_queue_inv_dev_entry(iommu, i);
+                iommu_completion_wait(iommu);
         }
 }
 
-void amd_iommu_flush_all_devices(void)
+static void flush_devices_by_domain(struct protection_domain *domain)
 {
         struct amd_iommu *iommu;
         int i;
 
         for (i = 0; i <= amd_iommu_last_bdf; ++i) {
-                if (amd_iommu_pd_table[i] == NULL)
+                if ((domain == NULL && amd_iommu_pd_table[i] == NULL) ||
+                    (amd_iommu_pd_table[i] != domain))
                         continue;
 
                 iommu = amd_iommu_rlookup_table[i];
@@ -497,6 +556,27 @@ void amd_iommu_flush_all_devices(void)
         }
 }
 
+static void reset_iommu_command_buffer(struct amd_iommu *iommu)
+{
+        pr_err("AMD-Vi: Resetting IOMMU command buffer\n");
+
+        if (iommu->reset_in_progress)
+                panic("AMD-Vi: ILLEGAL_COMMAND_ERROR while resetting command buffer\n");
+
+        iommu->reset_in_progress = true;
+
+        amd_iommu_reset_cmd_buffer(iommu);
+        flush_all_devices_for_iommu(iommu);
+        flush_all_domains_on_iommu(iommu);
+
+        iommu->reset_in_progress = false;
+}
+
+void amd_iommu_flush_all_devices(void)
+{
+        flush_devices_by_domain(NULL);
+}
+
 /****************************************************************************
  *
  * The functions below are used the create the page table mappings for
@@ -514,18 +594,21 @@ void amd_iommu_flush_all_devices(void)
 static int iommu_map_page(struct protection_domain *dom,
                           unsigned long bus_addr,
                           unsigned long phys_addr,
-                          int prot)
+                          int prot,
+                          int map_size)
 {
         u64 __pte, *pte;
 
         bus_addr  = PAGE_ALIGN(bus_addr);
         phys_addr = PAGE_ALIGN(phys_addr);
 
-        /* only support 512GB address spaces for now */
-        if (bus_addr > IOMMU_MAP_SIZE_L3 || !(prot & IOMMU_PROT_MASK))
+        BUG_ON(!PM_ALIGNED(map_size, bus_addr));
+        BUG_ON(!PM_ALIGNED(map_size, phys_addr));
+
+        if (!(prot & IOMMU_PROT_MASK))
                 return -EINVAL;
 
-        pte = alloc_pte(dom, bus_addr, NULL, GFP_KERNEL);
+        pte = alloc_pte(dom, bus_addr, map_size, NULL, GFP_KERNEL);
 
         if (IOMMU_PTE_PRESENT(*pte))
                 return -EBUSY;
@@ -538,29 +621,18 @@ static int iommu_map_page(struct protection_domain *dom,
 
         *pte = __pte;
 
+        update_domain(dom);
+
         return 0;
 }
 
 static void iommu_unmap_page(struct protection_domain *dom,
-                             unsigned long bus_addr)
+                             unsigned long bus_addr, int map_size)
 {
-        u64 *pte;
-
-        pte = &dom->pt_root[IOMMU_PTE_L2_INDEX(bus_addr)];
-
-        if (!IOMMU_PTE_PRESENT(*pte))
-                return;
-
-        pte = IOMMU_PTE_PAGE(*pte);
-        pte = &pte[IOMMU_PTE_L1_INDEX(bus_addr)];
+        u64 *pte = fetch_pte(dom, bus_addr, map_size);
 
-        if (!IOMMU_PTE_PRESENT(*pte))
-                return;
-
-        pte = IOMMU_PTE_PAGE(*pte);
-        pte = &pte[IOMMU_PTE_L1_INDEX(bus_addr)];
-
-        *pte = 0;
+        if (pte)
+                *pte = 0;
 }
 
 /*
@@ -615,7 +687,8 @@ static int dma_ops_unity_map(struct dma_ops_domain *dma_dom,
 
         for (addr = e->address_start; addr < e->address_end;
              addr += PAGE_SIZE) {
-                ret = iommu_map_page(&dma_dom->domain, addr, addr, e->prot);
+                ret = iommu_map_page(&dma_dom->domain, addr, addr, e->prot,
+                                     PM_MAP_4k);
                 if (ret)
                         return ret;
                 /*
@@ -670,24 +743,29 @@ static int init_unity_mappings_for_device(struct dma_ops_domain *dma_dom,
  * This function checks if there is a PTE for a given dma address. If
  * there is one, it returns the pointer to it.
  */
-static u64* fetch_pte(struct protection_domain *domain,
-                      unsigned long address)
+static u64 *fetch_pte(struct protection_domain *domain,
+                      unsigned long address, int map_size)
 {
+        int level;
         u64 *pte;
 
-        pte = &domain->pt_root[IOMMU_PTE_L2_INDEX(address)];
+        level =  domain->mode - 1;
+        pte   = &domain->pt_root[PM_LEVEL_INDEX(level, address)];
 
-        if (!IOMMU_PTE_PRESENT(*pte))
-                return NULL;
+        while (level > map_size) {
+                if (!IOMMU_PTE_PRESENT(*pte))
+                        return NULL;
 
-        pte = IOMMU_PTE_PAGE(*pte);
-        pte = &pte[IOMMU_PTE_L1_INDEX(address)];
+                level -= 1;
 
-        if (!IOMMU_PTE_PRESENT(*pte))
-                return NULL;
+                pte = IOMMU_PTE_PAGE(*pte);
+                pte = &pte[PM_LEVEL_INDEX(level, address)];
 
-        pte = IOMMU_PTE_PAGE(*pte);
-        pte = &pte[IOMMU_PTE_L0_INDEX(address)];
+                if ((PM_PTE_LEVEL(*pte) == 0) && level != map_size) {
+                        pte = NULL;
+                        break;
+                }
+        }
 
         return pte;
 }
@@ -727,7 +805,7 @@ static int alloc_new_range(struct amd_iommu *iommu,
                 u64 *pte, *pte_page;
 
                 for (i = 0; i < num_ptes; ++i) {
-                        pte = alloc_pte(&dma_dom->domain, address,
+                        pte = alloc_pte(&dma_dom->domain, address, PM_MAP_4k,
                                         &pte_page, gfp);
                         if (!pte)
                                 goto out_free;
@@ -760,16 +838,20 @@ static int alloc_new_range(struct amd_iommu *iommu,
         for (i = dma_dom->aperture[index]->offset;
              i < dma_dom->aperture_size;
              i += PAGE_SIZE) {
-                u64 *pte = fetch_pte(&dma_dom->domain, i);
+                u64 *pte = fetch_pte(&dma_dom->domain, i, PM_MAP_4k);
                 if (!pte || !IOMMU_PTE_PRESENT(*pte))
                         continue;
 
                 dma_ops_reserve_addresses(dma_dom, i << PAGE_SHIFT, 1);
         }
 
+        update_domain(&dma_dom->domain);
+
         return 0;
 
 out_free:
+        update_domain(&dma_dom->domain);
+
         free_page((unsigned long)dma_dom->aperture[index]->bitmap);
 
         kfree(dma_dom->aperture[index]);
@@ -1009,7 +1091,7 @@ static struct dma_ops_domain *dma_ops_domain_alloc(struct amd_iommu *iommu)
         dma_dom->domain.id = domain_id_alloc();
         if (dma_dom->domain.id == 0)
                 goto free_dma_dom;
-        dma_dom->domain.mode = PAGE_MODE_3_LEVEL;
+        dma_dom->domain.mode = PAGE_MODE_2_LEVEL;
         dma_dom->domain.pt_root = (void *)get_zeroed_page(GFP_KERNEL);
         dma_dom->domain.flags = PD_DMA_OPS_MASK;
         dma_dom->domain.priv = dma_dom;
@@ -1063,6 +1145,41 @@ static struct protection_domain *domain_for_device(u16 devid)
         return dom;
 }
 
+static void set_dte_entry(u16 devid, struct protection_domain *domain)
+{
+        u64 pte_root = virt_to_phys(domain->pt_root);
+
+        pte_root |= (domain->mode & DEV_ENTRY_MODE_MASK)
+                    << DEV_ENTRY_MODE_SHIFT;
+        pte_root |= IOMMU_PTE_IR | IOMMU_PTE_IW | IOMMU_PTE_P | IOMMU_PTE_TV;
+
+        amd_iommu_dev_table[devid].data[2] = domain->id;
+        amd_iommu_dev_table[devid].data[1] = upper_32_bits(pte_root);
+        amd_iommu_dev_table[devid].data[0] = lower_32_bits(pte_root);
+
+        amd_iommu_pd_table[devid] = domain;
+}
+
+/*
+ * If a device is not yet associated with a domain, this function does
+ * assigns it visible for the hardware
+ */
+static void __attach_device(struct amd_iommu *iommu,
+                            struct protection_domain *domain,
+                            u16 devid)
+{
+        /* lock domain */
+        spin_lock(&domain->lock);
+
+        /* update DTE entry */
+        set_dte_entry(devid, domain);
+
+        domain->dev_cnt += 1;
+
+        /* ready */
+        spin_unlock(&domain->lock);
+}
+
 /*
  * If a device is not yet associated with a domain, this function does
  * assigns it visible for the hardware
@@ -1072,27 +1189,16 @@ static void attach_device(struct amd_iommu *iommu,
                           u16 devid)
 {
         unsigned long flags;
-        u64 pte_root = virt_to_phys(domain->pt_root);
-
-        domain->dev_cnt += 1;
-
-        pte_root |= (domain->mode & DEV_ENTRY_MODE_MASK)
-                    << DEV_ENTRY_MODE_SHIFT;
-        pte_root |= IOMMU_PTE_IR | IOMMU_PTE_IW | IOMMU_PTE_P | IOMMU_PTE_TV;
 
         write_lock_irqsave(&amd_iommu_devtable_lock, flags);
-        amd_iommu_dev_table[devid].data[0] = lower_32_bits(pte_root);
-        amd_iommu_dev_table[devid].data[1] = upper_32_bits(pte_root);
-        amd_iommu_dev_table[devid].data[2] = domain->id;
-
-        amd_iommu_pd_table[devid] = domain;
+        __attach_device(iommu, domain, devid);
         write_unlock_irqrestore(&amd_iommu_devtable_lock, flags);
 
-       /*
-        * We might boot into a crash-kernel here. The crashed kernel
-        * left the caches in the IOMMU dirty. So we have to flush
-        * here to evict all dirty stuff.
-        */
+        /*
+         * We might boot into a crash-kernel here. The crashed kernel
+         * left the caches in the IOMMU dirty. So we have to flush
+         * here to evict all dirty stuff.
+         */
         iommu_queue_inv_dev_entry(iommu, devid);
         iommu_flush_tlb_pde(iommu, domain->id);
 }
@@ -1119,6 +1225,15 @@ static void __detach_device(struct protection_domain *domain, u16 devid)
 
         /* ready */
         spin_unlock(&domain->lock);
+
+        /*
+         * If we run in passthrough mode the device must be assigned to the
+         * passthrough domain if it is detached from any other domain
+         */
+        if (iommu_pass_through) {
+                struct amd_iommu *iommu = amd_iommu_rlookup_table[devid];
+                __attach_device(iommu, pt_domain, devid);
+        }
 }
 
 /*
@@ -1164,6 +1279,8 @@ static int device_change_notifier(struct notifier_block *nb,
         case BUS_NOTIFY_UNBOUND_DRIVER:
                 if (!domain)
                         goto out;
+                if (iommu_pass_through)
+                        break;
                 detach_device(domain, devid);
                 break;
         case BUS_NOTIFY_ADD_DEVICE:
@@ -1292,39 +1409,91 @@ static int get_device_resources(struct device *dev,
         return 1;
 }
 
+static void update_device_table(struct protection_domain *domain)
+{
+        unsigned long flags;
+        int i;
+
+        for (i = 0; i <= amd_iommu_last_bdf; ++i) {
+                if (amd_iommu_pd_table[i] != domain)
+                        continue;
+                write_lock_irqsave(&amd_iommu_devtable_lock, flags);
+                set_dte_entry(i, domain);
+                write_unlock_irqrestore(&amd_iommu_devtable_lock, flags);
+        }
+}
+
+static void update_domain(struct protection_domain *domain)
+{
+        if (!domain->updated)
+                return;
+
+        update_device_table(domain);
+        flush_devices_by_domain(domain);
+        iommu_flush_domain(domain->id);
+
+        domain->updated = false;
+}
+
 /*
- * If the pte_page is not yet allocated this function is called
+ * This function is used to add another level to an IO page table. Adding
+ * another level increases the size of the address space by 9 bits to a size up
+ * to 64 bits.
  */
-static u64* alloc_pte(struct protection_domain *dom,
-                      unsigned long address, u64 **pte_page, gfp_t gfp)
+static bool increase_address_space(struct protection_domain *domain,
+                                   gfp_t gfp)
+{
+        u64 *pte;
+
+        if (domain->mode == PAGE_MODE_6_LEVEL)
+                /* address space already 64 bit large */
+                return false;
+
+        pte = (void *)get_zeroed_page(gfp);
+        if (!pte)
+                return false;
+
+        *pte             = PM_LEVEL_PDE(domain->mode,
+                                        virt_to_phys(domain->pt_root));
+        domain->pt_root  = pte;
+        domain->mode    += 1;
+        domain->updated  = true;
+
+        return true;
+}
+
+static u64 *alloc_pte(struct protection_domain *domain,
+                      unsigned long address,
+                      int end_lvl,
+                      u64 **pte_page,
+                      gfp_t gfp)
 {
         u64 *pte, *page;
+        int level;
 
-        pte = &dom->pt_root[IOMMU_PTE_L2_INDEX(address)];
+        while (address > PM_LEVEL_SIZE(domain->mode))
+                increase_address_space(domain, gfp);
 
-        if (!IOMMU_PTE_PRESENT(*pte)) {
-                page = (u64 *)get_zeroed_page(gfp);
-                if (!page)
-                        return NULL;
-                *pte = IOMMU_L2_PDE(virt_to_phys(page));
-        }
+        level =  domain->mode - 1;
+        pte   = &domain->pt_root[PM_LEVEL_INDEX(level, address)];
 
-        pte = IOMMU_PTE_PAGE(*pte);
-        pte = &pte[IOMMU_PTE_L1_INDEX(address)];
+        while (level > end_lvl) {
+                if (!IOMMU_PTE_PRESENT(*pte)) {
+                        page = (u64 *)get_zeroed_page(gfp);
+                        if (!page)
+                                return NULL;
+                        *pte = PM_LEVEL_PDE(level, virt_to_phys(page));
+                }
 
-        if (!IOMMU_PTE_PRESENT(*pte)) {
-                page = (u64 *)get_zeroed_page(gfp);
-                if (!page)
-                        return NULL;
-                *pte = IOMMU_L1_PDE(virt_to_phys(page));
-        }
+                level -= 1;
 
-        pte = IOMMU_PTE_PAGE(*pte);
+                pte = IOMMU_PTE_PAGE(*pte);
 
-        if (pte_page)
-                *pte_page = pte;
+                if (pte_page && level == end_lvl)
+                        *pte_page = pte;
 
-        pte = &pte[IOMMU_PTE_L0_INDEX(address)];
+                pte = &pte[PM_LEVEL_INDEX(level, address)];
+        }
 
         return pte;
 }
@@ -1344,10 +1513,13 @@ static u64* dma_ops_get_pte(struct dma_ops_domain *dom,
 
         pte = aperture->pte_pages[APERTURE_PAGE_INDEX(address)];
         if (!pte) {
-                pte = alloc_pte(&dom->domain, address, &pte_page, GFP_ATOMIC);
+                pte = alloc_pte(&dom->domain, address, PM_MAP_4k, &pte_page,
+                                GFP_ATOMIC);
                 aperture->pte_pages[APERTURE_PAGE_INDEX(address)] = pte_page;
         } else
-                pte += IOMMU_PTE_L0_INDEX(address);
+                pte += PM_LEVEL_INDEX(0, address);
+
+        update_domain(&dom->domain);
 
         return pte;
 }
@@ -1409,7 +1581,7 @@ static void dma_ops_domain_unmap(struct amd_iommu *iommu,
         if (!pte)
                 return;
 
-        pte += IOMMU_PTE_L0_INDEX(address);
+        pte += PM_LEVEL_INDEX(0, address);
 
         WARN_ON(!*pte);
 
@@ -1988,19 +2160,47 @@ static void cleanup_domain(struct protection_domain *domain)
         write_unlock_irqrestore(&amd_iommu_devtable_lock, flags);
 }
 
-static int amd_iommu_domain_init(struct iommu_domain *dom)
+static void protection_domain_free(struct protection_domain *domain)
+{
+        if (!domain)
+                return;
+
+        if (domain->id)
+                domain_id_free(domain->id);
+
+        kfree(domain);
+}
+
+static struct protection_domain *protection_domain_alloc(void)
 {
         struct protection_domain *domain;
 
         domain = kzalloc(sizeof(*domain), GFP_KERNEL);
         if (!domain)
-                return -ENOMEM;
+                return NULL;
 
         spin_lock_init(&domain->lock);
-        domain->mode = PAGE_MODE_3_LEVEL;
         domain->id = domain_id_alloc();
         if (!domain->id)
+                goto out_err;
+
+        return domain;
+
+out_err:
+        kfree(domain);
+
+        return NULL;
+}
+
+static int amd_iommu_domain_init(struct iommu_domain *dom)
+{
+        struct protection_domain *domain;
+
+        domain = protection_domain_alloc();
+        if (!domain)
                 goto out_free;
+
+        domain->mode    = PAGE_MODE_3_LEVEL;
         domain->pt_root = (void *)get_zeroed_page(GFP_KERNEL);
         if (!domain->pt_root)
                 goto out_free;
@@ -2010,7 +2210,7 @@ static int amd_iommu_domain_init(struct iommu_domain *dom)
         return 0;
 
 out_free:
-        kfree(domain);
+        protection_domain_free(domain);
 
         return -ENOMEM;
 }
@@ -2115,7 +2315,7 @@ static int amd_iommu_map_range(struct iommu_domain *dom,
         paddr &= PAGE_MASK;
 
         for (i = 0; i < npages; ++i) {
-                ret = iommu_map_page(domain, iova, paddr, prot);
+                ret = iommu_map_page(domain, iova, paddr, prot, PM_MAP_4k);
                 if (ret)
                         return ret;
 
@@ -2136,7 +2336,7 @@ static void amd_iommu_unmap_range(struct iommu_domain *dom,
         iova  &= PAGE_MASK;
 
         for (i = 0; i < npages; ++i) {
-                iommu_unmap_page(domain, iova);
+                iommu_unmap_page(domain, iova, PM_MAP_4k);
                 iova  += PAGE_SIZE;
         }
 
@@ -2151,21 +2351,9 @@ static phys_addr_t amd_iommu_iova_to_phys(struct iommu_domain *dom,
         phys_addr_t paddr;
         u64 *pte;
 
-        pte = &domain->pt_root[IOMMU_PTE_L2_INDEX(iova)];
-
-        if (!IOMMU_PTE_PRESENT(*pte))
-                return 0;
-
-        pte = IOMMU_PTE_PAGE(*pte);
-        pte = &pte[IOMMU_PTE_L1_INDEX(iova)];
-
-        if (!IOMMU_PTE_PRESENT(*pte))
-                return 0;
-
-        pte = IOMMU_PTE_PAGE(*pte);
-        pte = &pte[IOMMU_PTE_L0_INDEX(iova)];
+        pte = fetch_pte(domain, iova, PM_MAP_4k);
 
-        if (!IOMMU_PTE_PRESENT(*pte))
+        if (!pte || !IOMMU_PTE_PRESENT(*pte))
                 return 0;
 
         paddr  = *pte & IOMMU_PAGE_MASK;
@@ -2191,3 +2379,46 @@ static struct iommu_ops amd_iommu_ops = {
         .domain_has_cap = amd_iommu_domain_has_cap,
 };
 
+/*****************************************************************************
+ *
+ * The next functions do a basic initialization of IOMMU for pass through
+ * mode
+ *
+ * In passthrough mode the IOMMU is initialized and enabled but not used for
+ * DMA-API translation.
+ *
+ *****************************************************************************/
+
+int __init amd_iommu_init_passthrough(void)
+{
+        struct pci_dev *dev = NULL;
+        u16 devid, devid2;
+
+        /* allocate passthroug domain */
+        pt_domain = protection_domain_alloc();
+        if (!pt_domain)
+                return -ENOMEM;
+
+        pt_domain->mode |= PAGE_MODE_NONE;
+
+        while ((dev = pci_get_device(PCI_ANY_ID, PCI_ANY_ID, dev)) != NULL) {
+                struct amd_iommu *iommu;
+
+                devid = calc_devid(dev->bus->number, dev->devfn);
+                if (devid > amd_iommu_last_bdf)
+                        continue;
+
+                devid2 = amd_iommu_alias_table[devid];
+
+                iommu = amd_iommu_rlookup_table[devid2];
+                if (!iommu)
+                        continue;
+
+                __attach_device(iommu, pt_domain, devid);
+                __attach_device(iommu, pt_domain, devid2);
+        }
+
+        pr_info("AMD-Vi: Initialized for Passthrough Mode\n");
+
+        return 0;
+}
diff --git a/arch/x86/kernel/amd_iommu_init.c b/arch/x86/kernel/amd_iommu_init.c
index c1b17e97252e..b4b61d462dcc 100644
--- a/arch/x86/kernel/amd_iommu_init.c
+++ b/arch/x86/kernel/amd_iommu_init.c
@@ -252,7 +252,7 @@ static void __init iommu_feature_disable(struct amd_iommu *iommu, u8 bit)
 /* Function to enable the hardware */
 static void iommu_enable(struct amd_iommu *iommu)
 {
-        printk(KERN_INFO "AMD IOMMU: Enabling IOMMU at %s cap 0x%hx\n",
+        printk(KERN_INFO "AMD-Vi: Enabling IOMMU at %s cap 0x%hx\n",
                dev_name(&iommu->dev->dev), iommu->cap_ptr);
 
         iommu_feature_enable(iommu, CONTROL_IOMMU_EN);
@@ -435,6 +435,20 @@ static u8 * __init alloc_command_buffer(struct amd_iommu *iommu)
 }
 
 /*
+ * This function resets the command buffer if the IOMMU stopped fetching
+ * commands from it.
+ */
+void amd_iommu_reset_cmd_buffer(struct amd_iommu *iommu)
+{
+        iommu_feature_disable(iommu, CONTROL_CMDBUF_EN);
+
+        writel(0x00, iommu->mmio_base + MMIO_CMD_HEAD_OFFSET);
+        writel(0x00, iommu->mmio_base + MMIO_CMD_TAIL_OFFSET);
+
+        iommu_feature_enable(iommu, CONTROL_CMDBUF_EN);
+}
+
+/*
  * This function writes the command buffer address to the hardware and
  * enables it.
  */
@@ -450,11 +464,7 @@ static void iommu_enable_command_buffer(struct amd_iommu *iommu)
         memcpy_toio(iommu->mmio_base + MMIO_CMD_BUF_OFFSET,
                     &entry, sizeof(entry));
 
-        /* set head and tail to zero manually */
-        writel(0x00, iommu->mmio_base + MMIO_CMD_HEAD_OFFSET);
-        writel(0x00, iommu->mmio_base + MMIO_CMD_TAIL_OFFSET);
-
-        iommu_feature_enable(iommu, CONTROL_CMDBUF_EN);
+        amd_iommu_reset_cmd_buffer(iommu);
 }
 
 static void __init free_command_buffer(struct amd_iommu *iommu)
@@ -858,7 +868,7 @@ static int __init init_iommu_all(struct acpi_table_header *table)
                 switch (*p) {
                 case ACPI_IVHD_TYPE:
 
-                        DUMP_printk("IOMMU: device: %02x:%02x.%01x cap: %04x "
+                        DUMP_printk("device: %02x:%02x.%01x cap: %04x "
                                     "seg: %d flags: %01x info %04x\n",
                                     PCI_BUS(h->devid), PCI_SLOT(h->devid),
                                     PCI_FUNC(h->devid), h->cap_ptr,
@@ -902,7 +912,7 @@ static int __init iommu_setup_msi(struct amd_iommu *iommu)
 
         r = request_irq(iommu->dev->irq, amd_iommu_int_handler,
                         IRQF_SAMPLE_RANDOM,
-                        "AMD IOMMU",
+                        "AMD-Vi",
                         NULL);
 
         if (r) {
@@ -1150,7 +1160,7 @@ int __init amd_iommu_init(void)
 
 
         if (no_iommu) {
-                printk(KERN_INFO "AMD IOMMU disabled by kernel command line\n");
+                printk(KERN_INFO "AMD-Vi disabled by kernel command line\n");
                 return 0;
         }
 
@@ -1242,22 +1252,28 @@ int __init amd_iommu_init(void)
         if (ret)
                 goto free;
 
-        ret = amd_iommu_init_dma_ops();
+        if (iommu_pass_through)
+                ret = amd_iommu_init_passthrough();
+        else
+                ret = amd_iommu_init_dma_ops();
         if (ret)
                 goto free;
 
         enable_iommus();
 
-        printk(KERN_INFO "AMD IOMMU: device isolation ");
+        if (iommu_pass_through)
+                goto out;
+
+        printk(KERN_INFO "AMD-Vi: device isolation ");
         if (amd_iommu_isolate)
                 printk("enabled\n");
         else
                 printk("disabled\n");
 
         if (amd_iommu_unmap_flush)
-                printk(KERN_INFO "AMD IOMMU: IO/TLB flush on unmap enabled\n");
+                printk(KERN_INFO "AMD-Vi: IO/TLB flush on unmap enabled\n");
         else
-                printk(KERN_INFO "AMD IOMMU: Lazy IO/TLB flushing enabled\n");
+                printk(KERN_INFO "AMD-Vi: Lazy IO/TLB flushing enabled\n");
 
 out:
         return ret;
diff --git a/arch/x86/kernel/apic/nmi.c b/arch/x86/kernel/apic/nmi.c
index b3025b43b63a..db7220220d09 100644
--- a/arch/x86/kernel/apic/nmi.c
+++ b/arch/x86/kernel/apic/nmi.c
@@ -39,7 +39,7 @@
 int unknown_nmi_panic;
 int nmi_watchdog_enabled;
 
-static cpumask_var_t backtrace_mask;
+static cpumask_t backtrace_mask __read_mostly;
 
 /* nmi_active:
  * >0: the lapic NMI watchdog is active, but can be disabled
@@ -138,7 +138,6 @@ int __init check_nmi_watchdog(void)
         if (!prev_nmi_count)
                 goto error;
 
-        alloc_cpumask_var(&backtrace_mask, GFP_KERNEL|__GFP_ZERO);
         printk(KERN_INFO "Testing NMI watchdog ... ");
 
 #ifdef CONFIG_SMP
@@ -415,14 +414,17 @@ nmi_watchdog_tick(struct pt_regs *regs, unsigned reason)
         }
 
         /* We can be called before check_nmi_watchdog, hence NULL check. */
-        if (backtrace_mask != NULL && cpumask_test_cpu(cpu, backtrace_mask)) {
+        if (cpumask_test_cpu(cpu, &backtrace_mask)) {
                 static DEFINE_SPINLOCK(lock);   /* Serialise the printks */
 
                 spin_lock(&lock);
                 printk(KERN_WARNING "NMI backtrace for cpu %d\n", cpu);
+                show_regs(regs);
                 dump_stack();
                 spin_unlock(&lock);
-                cpumask_clear_cpu(cpu, backtrace_mask);
+                cpumask_clear_cpu(cpu, &backtrace_mask);
+
+                rc = 1;
         }
 
         /* Could check oops_in_progress here too, but it's safer not to */
@@ -552,14 +554,18 @@ int do_nmi_callback(struct pt_regs *regs, int cpu)
         return 0;
 }
 
-void __trigger_all_cpu_backtrace(void)
+void arch_trigger_all_cpu_backtrace(void)
 {
         int i;
 
-        cpumask_copy(backtrace_mask, cpu_online_mask);
+        cpumask_copy(&backtrace_mask, cpu_online_mask);
+
+        printk(KERN_INFO "sending NMI to all CPUs:\n");
+        apic->send_IPI_all(NMI_VECTOR);
+
         /* Wait for up to 10 seconds for all CPUs to do the backtrace */
         for (i = 0; i < 10 * 1000; i++) {
-                if (cpumask_empty(backtrace_mask))
+                if (cpumask_empty(&backtrace_mask))
                         break;
                 mdelay(1);
         }
diff --git a/arch/x86/kernel/asm-offsets_64.c b/arch/x86/kernel/asm-offsets_64.c
index 898ecc47e129..4a6aeedcd965 100644
--- a/arch/x86/kernel/asm-offsets_64.c
+++ b/arch/x86/kernel/asm-offsets_64.c
@@ -3,6 +3,7 @@
  * This code generates raw asm output which is post-processed to extract
  * and format the required data.
  */
+#define COMPILE_OFFSETS
 
 #include <linux/crypto.h>
 #include <linux/sched.h> 
diff --git a/arch/x86/kernel/cpu/perf_counter.c b/arch/x86/kernel/cpu/perf_counter.c
index 900332b800f8..f9cd0849bd42 100644
--- a/arch/x86/kernel/cpu/perf_counter.c
+++ b/arch/x86/kernel/cpu/perf_counter.c
@@ -6,6 +6,7 @@
  *  Copyright (C) 2009 Jaswinder Singh Rajput
  *  Copyright (C) 2009 Advanced Micro Devices, Inc., Robert Richter
  *  Copyright (C) 2008-2009 Red Hat, Inc., Peter Zijlstra <pzijlstr@redhat.com>
+ *  Copyright (C) 2009 Intel Corporation, <markus.t.metzger@intel.com>
  *
  *  For licencing details see kernel-base/COPYING
  */
@@ -20,6 +21,7 @@
 #include <linux/sched.h>
 #include <linux/uaccess.h>
 #include <linux/highmem.h>
+#include <linux/cpu.h>
 
 #include <asm/apic.h>
 #include <asm/stacktrace.h>
@@ -27,12 +29,52 @@
 
 static u64 perf_counter_mask __read_mostly;
 
+/* The maximal number of PEBS counters: */
+#define MAX_PEBS_COUNTERS       4
+
+/* The size of a BTS record in bytes: */
+#define BTS_RECORD_SIZE         24
+
+/* The size of a per-cpu BTS buffer in bytes: */
+#define BTS_BUFFER_SIZE         (BTS_RECORD_SIZE * 1024)
+
+/* The BTS overflow threshold in bytes from the end of the buffer: */
+#define BTS_OVFL_TH             (BTS_RECORD_SIZE * 64)
+
+
+/*
+ * Bits in the debugctlmsr controlling branch tracing.
+ */
+#define X86_DEBUGCTL_TR                 (1 << 6)
+#define X86_DEBUGCTL_BTS                (1 << 7)
+#define X86_DEBUGCTL_BTINT              (1 << 8)
+#define X86_DEBUGCTL_BTS_OFF_OS         (1 << 9)
+#define X86_DEBUGCTL_BTS_OFF_USR        (1 << 10)
+
+/*
+ * A debug store configuration.
+ *
+ * We only support architectures that use 64bit fields.
+ */
+struct debug_store {
+        u64     bts_buffer_base;
+        u64     bts_index;
+        u64     bts_absolute_maximum;
+        u64     bts_interrupt_threshold;
+        u64     pebs_buffer_base;
+        u64     pebs_index;
+        u64     pebs_absolute_maximum;
+        u64     pebs_interrupt_threshold;
+        u64     pebs_counter_reset[MAX_PEBS_COUNTERS];
+};
+
 struct cpu_hw_counters {
         struct perf_counter     *counters[X86_PMC_IDX_MAX];
         unsigned long           used_mask[BITS_TO_LONGS(X86_PMC_IDX_MAX)];
         unsigned long           active_mask[BITS_TO_LONGS(X86_PMC_IDX_MAX)];
         unsigned long           interrupts;
         int                     enabled;
+        struct debug_store      *ds;
 };
 
 /*
@@ -58,6 +100,8 @@ struct x86_pmu {
         int             apic;
         u64             max_period;
         u64             intel_ctrl;
+        void            (*enable_bts)(u64 config);
+        void            (*disable_bts)(void);
 };
 
 static struct x86_pmu x86_pmu __read_mostly;
@@ -577,6 +621,9 @@ x86_perf_counter_update(struct perf_counter *counter,
         u64 prev_raw_count, new_raw_count;
         s64 delta;
 
+        if (idx == X86_PMC_IDX_FIXED_BTS)
+                return 0;
+
         /*
          * Careful: an NMI might modify the previous counter value.
          *
@@ -666,10 +713,110 @@ static void release_pmc_hardware(void)
 #endif
 }
 
+static inline bool bts_available(void)
+{
+        return x86_pmu.enable_bts != NULL;
+}
+
+static inline void init_debug_store_on_cpu(int cpu)
+{
+        struct debug_store *ds = per_cpu(cpu_hw_counters, cpu).ds;
+
+        if (!ds)
+                return;
+
+        wrmsr_on_cpu(cpu, MSR_IA32_DS_AREA,
+                     (u32)((u64)(unsigned long)ds),
+                     (u32)((u64)(unsigned long)ds >> 32));
+}
+
+static inline void fini_debug_store_on_cpu(int cpu)
+{
+        if (!per_cpu(cpu_hw_counters, cpu).ds)
+                return;
+
+        wrmsr_on_cpu(cpu, MSR_IA32_DS_AREA, 0, 0);
+}
+
+static void release_bts_hardware(void)
+{
+        int cpu;
+
+        if (!bts_available())
+                return;
+
+        get_online_cpus();
+
+        for_each_online_cpu(cpu)
+                fini_debug_store_on_cpu(cpu);
+
+        for_each_possible_cpu(cpu) {
+                struct debug_store *ds = per_cpu(cpu_hw_counters, cpu).ds;
+
+                if (!ds)
+                        continue;
+
+                per_cpu(cpu_hw_counters, cpu).ds = NULL;
+
+                kfree((void *)(unsigned long)ds->bts_buffer_base);
+                kfree(ds);
+        }
+
+        put_online_cpus();
+}
+
+static int reserve_bts_hardware(void)
+{
+        int cpu, err = 0;
+
+        if (!bts_available())
+                return 0;
+
+        get_online_cpus();
+
+        for_each_possible_cpu(cpu) {
+                struct debug_store *ds;
+                void *buffer;
+
+                err = -ENOMEM;
+                buffer = kzalloc(BTS_BUFFER_SIZE, GFP_KERNEL);
+                if (unlikely(!buffer))
+                        break;
+
+                ds = kzalloc(sizeof(*ds), GFP_KERNEL);
+                if (unlikely(!ds)) {
+                        kfree(buffer);
+                        break;
+                }
+
+                ds->bts_buffer_base = (u64)(unsigned long)buffer;
+                ds->bts_index = ds->bts_buffer_base;
+                ds->bts_absolute_maximum =
+                        ds->bts_buffer_base + BTS_BUFFER_SIZE;
+                ds->bts_interrupt_threshold =
+                        ds->bts_absolute_maximum - BTS_OVFL_TH;
+
+                per_cpu(cpu_hw_counters, cpu).ds = ds;
+                err = 0;
+        }
+
+        if (err)
+                release_bts_hardware();
+        else {
+                for_each_online_cpu(cpu)
+                        init_debug_store_on_cpu(cpu);
+        }
+
+        put_online_cpus();
+
+        return err;
+}
+
 static void hw_perf_counter_destroy(struct perf_counter *counter)
 {
         if (atomic_dec_and_mutex_lock(&active_counters, &pmc_reserve_mutex)) {
                 release_pmc_hardware();
+                release_bts_hardware();
                 mutex_unlock(&pmc_reserve_mutex);
         }
 }
@@ -712,6 +859,42 @@ set_ext_hw_attr(struct hw_perf_counter *hwc, struct perf_counter_attr *attr)
         return 0;
 }
 
+static void intel_pmu_enable_bts(u64 config)
+{
+        unsigned long debugctlmsr;
+
+        debugctlmsr = get_debugctlmsr();
+
+        debugctlmsr |= X86_DEBUGCTL_TR;
+        debugctlmsr |= X86_DEBUGCTL_BTS;
+        debugctlmsr |= X86_DEBUGCTL_BTINT;
+
+        if (!(config & ARCH_PERFMON_EVENTSEL_OS))
+                debugctlmsr |= X86_DEBUGCTL_BTS_OFF_OS;
+
+        if (!(config & ARCH_PERFMON_EVENTSEL_USR))
+                debugctlmsr |= X86_DEBUGCTL_BTS_OFF_USR;
+
+        update_debugctlmsr(debugctlmsr);
+}
+
+static void intel_pmu_disable_bts(void)
+{
+        struct cpu_hw_counters *cpuc = &__get_cpu_var(cpu_hw_counters);
+        unsigned long debugctlmsr;
+
+        if (!cpuc->ds)
+                return;
+
+        debugctlmsr = get_debugctlmsr();
+
+        debugctlmsr &=
+                ~(X86_DEBUGCTL_TR | X86_DEBUGCTL_BTS | X86_DEBUGCTL_BTINT |
+                  X86_DEBUGCTL_BTS_OFF_OS | X86_DEBUGCTL_BTS_OFF_USR);
+
+        update_debugctlmsr(debugctlmsr);
+}
+
 /*
  * Setup the hardware configuration for a given attr_type
  */
@@ -728,9 +911,13 @@ static int __hw_perf_counter_init(struct perf_counter *counter)
         err = 0;
         if (!atomic_inc_not_zero(&active_counters)) {
                 mutex_lock(&pmc_reserve_mutex);
-                if (atomic_read(&active_counters) == 0 && !reserve_pmc_hardware())
-                        err = -EBUSY;
-                else
+                if (atomic_read(&active_counters) == 0) {
+                        if (!reserve_pmc_hardware())
+                                err = -EBUSY;
+                        else
+                                err = reserve_bts_hardware();
+                }
+                if (!err)
                         atomic_inc(&active_counters);
                 mutex_unlock(&pmc_reserve_mutex);
         }
@@ -793,6 +980,20 @@ static int __hw_perf_counter_init(struct perf_counter *counter)
         if (config == -1LL)
                 return -EINVAL;
 
+        /*
+         * Branch tracing:
+         */
+        if ((attr->config == PERF_COUNT_HW_BRANCH_INSTRUCTIONS) &&
+            (hwc->sample_period == 1)) {
+                /* BTS is not supported by this architecture. */
+                if (!bts_available())
+                        return -EOPNOTSUPP;
+
+                /* BTS is currently only allowed for user-mode. */
+                if (hwc->config & ARCH_PERFMON_EVENTSEL_OS)
+                        return -EOPNOTSUPP;
+        }
+
         hwc->config |= config;
 
         return 0;
@@ -817,7 +1018,18 @@ static void p6_pmu_disable_all(void)
 
 static void intel_pmu_disable_all(void)
 {
+        struct cpu_hw_counters *cpuc = &__get_cpu_var(cpu_hw_counters);
+
+        if (!cpuc->enabled)
+                return;
+
+        cpuc->enabled = 0;
+        barrier();
+
         wrmsrl(MSR_CORE_PERF_GLOBAL_CTRL, 0);
+
+        if (test_bit(X86_PMC_IDX_FIXED_BTS, cpuc->active_mask))
+                intel_pmu_disable_bts();
 }
 
 static void amd_pmu_disable_all(void)
@@ -875,7 +1087,25 @@ static void p6_pmu_enable_all(void)
 
 static void intel_pmu_enable_all(void)
 {
+        struct cpu_hw_counters *cpuc = &__get_cpu_var(cpu_hw_counters);
+
+        if (cpuc->enabled)
+                return;
+
+        cpuc->enabled = 1;
+        barrier();
+
         wrmsrl(MSR_CORE_PERF_GLOBAL_CTRL, x86_pmu.intel_ctrl);
+
+        if (test_bit(X86_PMC_IDX_FIXED_BTS, cpuc->active_mask)) {
+                struct perf_counter *counter =
+                        cpuc->counters[X86_PMC_IDX_FIXED_BTS];
+
+                if (WARN_ON_ONCE(!counter))
+                        return;
+
+                intel_pmu_enable_bts(counter->hw.config);
+        }
 }
 
 static void amd_pmu_enable_all(void)
@@ -962,6 +1192,11 @@ p6_pmu_disable_counter(struct hw_perf_counter *hwc, int idx)
 static inline void
 intel_pmu_disable_counter(struct hw_perf_counter *hwc, int idx)
 {
+        if (unlikely(idx == X86_PMC_IDX_FIXED_BTS)) {
+                intel_pmu_disable_bts();
+                return;
+        }
+
         if (unlikely(hwc->config_base == MSR_ARCH_PERFMON_FIXED_CTR_CTRL)) {
                 intel_pmu_disable_fixed(hwc, idx);
                 return;
@@ -990,6 +1225,9 @@ x86_perf_counter_set_period(struct perf_counter *counter,
         s64 period = hwc->sample_period;
         int err, ret = 0;
 
+        if (idx == X86_PMC_IDX_FIXED_BTS)
+                return 0;
+
         /*
          * If we are way outside a reasoable range then just skip forward:
          */
@@ -1072,6 +1310,14 @@ static void p6_pmu_enable_counter(struct hw_perf_counter *hwc, int idx)
 
 static void intel_pmu_enable_counter(struct hw_perf_counter *hwc, int idx)
 {
+        if (unlikely(idx == X86_PMC_IDX_FIXED_BTS)) {
+                if (!__get_cpu_var(cpu_hw_counters).enabled)
+                        return;
+
+                intel_pmu_enable_bts(hwc->config);
+                return;
+        }
+
         if (unlikely(hwc->config_base == MSR_ARCH_PERFMON_FIXED_CTR_CTRL)) {
                 intel_pmu_enable_fixed(hwc, idx);
                 return;
@@ -1093,11 +1339,16 @@ fixed_mode_idx(struct perf_counter *counter, struct hw_perf_counter *hwc)
 {
         unsigned int event;
 
+        event = hwc->config & ARCH_PERFMON_EVENT_MASK;
+
+        if (unlikely((event ==
+                      x86_pmu.event_map(PERF_COUNT_HW_BRANCH_INSTRUCTIONS)) &&
+                     (hwc->sample_period == 1)))
+                return X86_PMC_IDX_FIXED_BTS;
+
         if (!x86_pmu.num_counters_fixed)
                 return -1;
 
-        event = hwc->config & ARCH_PERFMON_EVENT_MASK;
-
         if (unlikely(event == x86_pmu.event_map(PERF_COUNT_HW_INSTRUCTIONS)))
                 return X86_PMC_IDX_FIXED_INSTRUCTIONS;
         if (unlikely(event == x86_pmu.event_map(PERF_COUNT_HW_CPU_CYCLES)))
@@ -1118,7 +1369,15 @@ static int x86_pmu_enable(struct perf_counter *counter)
         int idx;
 
         idx = fixed_mode_idx(counter, hwc);
-        if (idx >= 0) {
+        if (idx == X86_PMC_IDX_FIXED_BTS) {
+                /* BTS is already occupied. */
+                if (test_and_set_bit(idx, cpuc->used_mask))
+                        return -EAGAIN;
+
+                hwc->config_base        = 0;
+                hwc->counter_base       = 0;
+                hwc->idx                = idx;
+        } else if (idx >= 0) {
                 /*
                  * Try to get the fixed counter, if that is already taken
                  * then try to get a generic counter:
@@ -1229,6 +1488,44 @@ void perf_counter_print_debug(void)
         local_irq_restore(flags);
 }
 
+static void intel_pmu_drain_bts_buffer(struct cpu_hw_counters *cpuc,
+                                       struct perf_sample_data *data)
+{
+        struct debug_store *ds = cpuc->ds;
+        struct bts_record {
+                u64     from;
+                u64     to;
+                u64     flags;
+        };
+        struct perf_counter *counter = cpuc->counters[X86_PMC_IDX_FIXED_BTS];
+        unsigned long orig_ip = data->regs->ip;
+        struct bts_record *at, *top;
+
+        if (!counter)
+                return;
+
+        if (!ds)
+                return;
+
+        at  = (struct bts_record *)(unsigned long)ds->bts_buffer_base;
+        top = (struct bts_record *)(unsigned long)ds->bts_index;
+
+        ds->bts_index = ds->bts_buffer_base;
+
+        for (; at < top; at++) {
+                data->regs->ip  = at->from;
+                data->addr      = at->to;
+
+                perf_counter_output(counter, 1, data);
+        }
+
+        data->regs->ip  = orig_ip;
+        data->addr      = 0;
+
+        /* There's new data available. */
+        counter->pending_kill = POLL_IN;
+}
+
 static void x86_pmu_disable(struct perf_counter *counter)
 {
         struct cpu_hw_counters *cpuc = &__get_cpu_var(cpu_hw_counters);
@@ -1253,6 +1550,15 @@ static void x86_pmu_disable(struct perf_counter *counter)
          * that we are disabling:
          */
         x86_perf_counter_update(counter, hwc, idx);
+
+        /* Drain the remaining BTS records. */
+        if (unlikely(idx == X86_PMC_IDX_FIXED_BTS)) {
+                struct perf_sample_data data;
+                struct pt_regs regs;
+
+                data.regs = &regs;
+                intel_pmu_drain_bts_buffer(cpuc, &data);
+        }
         cpuc->counters[idx] = NULL;
         clear_bit(idx, cpuc->used_mask);
 
@@ -1280,6 +1586,7 @@ static int intel_pmu_save_and_restart(struct perf_counter *counter)
 
 static void intel_pmu_reset(void)
 {
+        struct debug_store *ds = __get_cpu_var(cpu_hw_counters).ds;
         unsigned long flags;
         int idx;
 
@@ -1297,6 +1604,8 @@ static void intel_pmu_reset(void)
         for (idx = 0; idx < x86_pmu.num_counters_fixed; idx++) {
                 checking_wrmsrl(MSR_ARCH_PERFMON_FIXED_CTR0 + idx, 0ull);
         }
+        if (ds)
+                ds->bts_index = ds->bts_buffer_base;
 
         local_irq_restore(flags);
 }
@@ -1362,6 +1671,7 @@ static int intel_pmu_handle_irq(struct pt_regs *regs)
         cpuc = &__get_cpu_var(cpu_hw_counters);
 
         perf_disable();
+        intel_pmu_drain_bts_buffer(cpuc, &data);
         status = intel_pmu_get_status();
         if (!status) {
                 perf_enable();
@@ -1571,6 +1881,8 @@ static struct x86_pmu intel_pmu = {
          * the generic counter period:
          */
         .max_period             = (1ULL << 31) - 1,
+        .enable_bts             = intel_pmu_enable_bts,
+        .disable_bts            = intel_pmu_disable_bts,
 };
 
 static struct x86_pmu amd_pmu = {
@@ -1962,3 +2274,8 @@ struct perf_callchain_entry *perf_callchain(struct pt_regs *regs)
 
         return entry;
 }
+
+void hw_perf_counter_setup_online(int cpu)
+{
+        init_debug_store_on_cpu(cpu);
+}
diff --git a/arch/x86/kernel/ftrace.c b/arch/x86/kernel/ftrace.c
index d94e1ea3b9fe..9dbb527e1652 100644
--- a/arch/x86/kernel/ftrace.c
+++ b/arch/x86/kernel/ftrace.c
@@ -417,10 +417,6 @@ void prepare_ftrace_return(unsigned long *parent, unsigned long self_addr,
         unsigned long return_hooker = (unsigned long)
                                 &return_to_handler;
 
-        /* Nmi's are currently unsupported */
-        if (unlikely(in_nmi()))
-                return;
-
         if (unlikely(atomic_read(&current->tracing_graph_pause)))
                 return;
 
@@ -498,37 +494,56 @@ static struct syscall_metadata *find_syscall_meta(unsigned long *syscall)
 
 struct syscall_metadata *syscall_nr_to_meta(int nr)
 {
-        if (!syscalls_metadata || nr >= FTRACE_SYSCALL_MAX || nr < 0)
+        if (!syscalls_metadata || nr >= NR_syscalls || nr < 0)
                 return NULL;
 
         return syscalls_metadata[nr];
 }
 
-void arch_init_ftrace_syscalls(void)
+int syscall_name_to_nr(char *name)
+{
+        int i;
+
+        if (!syscalls_metadata)
+                return -1;
+
+        for (i = 0; i < NR_syscalls; i++) {
+                if (syscalls_metadata[i]) {
+                        if (!strcmp(syscalls_metadata[i]->name, name))
+                                return i;
+                }
+        }
+        return -1;
+}
+
+void set_syscall_enter_id(int num, int id)
+{
+        syscalls_metadata[num]->enter_id = id;
+}
+
+void set_syscall_exit_id(int num, int id)
+{
+        syscalls_metadata[num]->exit_id = id;
+}
+
+static int __init arch_init_ftrace_syscalls(void)
 {
         int i;
         struct syscall_metadata *meta;
         unsigned long **psys_syscall_table = &sys_call_table;
-        static atomic_t refs;
-
-        if (atomic_inc_return(&refs) != 1)
-                goto end;
 
         syscalls_metadata = kzalloc(sizeof(*syscalls_metadata) *
-                                        FTRACE_SYSCALL_MAX, GFP_KERNEL);
+                                        NR_syscalls, GFP_KERNEL);
         if (!syscalls_metadata) {
                 WARN_ON(1);
-                return;
+                return -ENOMEM;
         }
 
-        for (i = 0; i < FTRACE_SYSCALL_MAX; i++) {
+        for (i = 0; i < NR_syscalls; i++) {
                 meta = find_syscall_meta(psys_syscall_table[i]);
                 syscalls_metadata[i] = meta;
         }
-        return;
-
-        /* Paranoid: avoid overflow */
-end:
-        atomic_dec(&refs);
+        return 0;
 }
+arch_initcall(arch_init_ftrace_syscalls);
 #endif
diff --git a/arch/x86/kernel/pci-dma.c b/arch/x86/kernel/pci-dma.c
index fa80f60e9607..d71c8655905b 100644
--- a/arch/x86/kernel/pci-dma.c
+++ b/arch/x86/kernel/pci-dma.c
@@ -33,7 +33,14 @@ int no_iommu __read_mostly;
 /* Set this to 1 if there is a HW IOMMU in the system */
 int iommu_detected __read_mostly = 0;
 
-int iommu_pass_through;
+/*
+ * This variable becomes 1 if iommu=pt is passed on the kernel command line.
+ * If this variable is 1, IOMMU implementations do no DMA ranslation for
+ * devices and allow every device to access to whole physical memory. This is
+ * useful if a user want to use an IOMMU only for KVM device assignment to
+ * guests and not for driver dma translation.
+ */
+int iommu_pass_through __read_mostly;
 
 dma_addr_t bad_dma_address __read_mostly = 0;
 EXPORT_SYMBOL(bad_dma_address);
@@ -153,7 +160,7 @@ again:
                 return NULL;
 
         addr = page_to_phys(page);
-        if (!is_buffer_dma_capable(dma_mask, addr, size)) {
+        if (addr + size > dma_mask) {
                 __free_pages(page, get_order(size));
 
                 if (dma_mask < DMA_BIT_MASK(32) && !(flag & GFP_DMA)) {
diff --git a/arch/x86/kernel/pci-gart_64.c b/arch/x86/kernel/pci-gart_64.c
index d2e56b8f48e7..98a827ee9ed7 100644
--- a/arch/x86/kernel/pci-gart_64.c
+++ b/arch/x86/kernel/pci-gart_64.c
@@ -190,14 +190,13 @@ static void iommu_full(struct device *dev, size_t size, int dir)
 static inline int
 need_iommu(struct device *dev, unsigned long addr, size_t size)
 {
-        return force_iommu ||
-                !is_buffer_dma_capable(*dev->dma_mask, addr, size);
+        return force_iommu || !dma_capable(dev, addr, size);
 }
 
 static inline int
 nonforced_iommu(struct device *dev, unsigned long addr, size_t size)
 {
-        return !is_buffer_dma_capable(*dev->dma_mask, addr, size);
+        return !dma_capable(dev, addr, size);
 }
 
 /* Map a single continuous physical area into the IOMMU.
diff --git a/arch/x86/kernel/pci-nommu.c b/arch/x86/kernel/pci-nommu.c
index 71d412a09f30..a3933d4330cd 100644
--- a/arch/x86/kernel/pci-nommu.c
+++ b/arch/x86/kernel/pci-nommu.c
@@ -14,7 +14,7 @@
 static int
 check_addr(char *name, struct device *hwdev, dma_addr_t bus, size_t size)
 {
-        if (hwdev && !is_buffer_dma_capable(*hwdev->dma_mask, bus, size)) {
+        if (hwdev && !dma_capable(hwdev, bus, size)) {
                 if (*hwdev->dma_mask >= DMA_BIT_MASK(32))
                         printk(KERN_ERR
                             "nommu_%s: overflow %Lx+%zu of device mask %Lx\n",
@@ -79,12 +79,29 @@ static void nommu_free_coherent(struct device *dev, size_t size, void *vaddr,
         free_pages((unsigned long)vaddr, get_order(size));
 }
 
+static void nommu_sync_single_for_device(struct device *dev,
+                        dma_addr_t addr, size_t size,
+                        enum dma_data_direction dir)
+{
+        flush_write_buffers();
+}
+
+
+static void nommu_sync_sg_for_device(struct device *dev,
+                        struct scatterlist *sg, int nelems,
+                        enum dma_data_direction dir)
+{
+        flush_write_buffers();
+}
+
 struct dma_map_ops nommu_dma_ops = {
-        .alloc_coherent = dma_generic_alloc_coherent,
-        .free_coherent  = nommu_free_coherent,
-        .map_sg         = nommu_map_sg,
-        .map_page       = nommu_map_page,
-        .is_phys        = 1,
+        .alloc_coherent         = dma_generic_alloc_coherent,
+        .free_coherent          = nommu_free_coherent,
+        .map_sg                 = nommu_map_sg,
+        .map_page               = nommu_map_page,
+        .sync_single_for_device = nommu_sync_single_for_device,
+        .sync_sg_for_device     = nommu_sync_sg_for_device,
+        .is_phys                = 1,
 };
 
 void __init no_iommu_init(void)
diff --git a/arch/x86/kernel/pci-swiotlb.c b/arch/x86/kernel/pci-swiotlb.c
index 6af96ee44200..e8a35016115f 100644
--- a/arch/x86/kernel/pci-swiotlb.c
+++ b/arch/x86/kernel/pci-swiotlb.c
@@ -13,31 +13,6 @@
 
 int swiotlb __read_mostly;
 
-void * __init swiotlb_alloc_boot(size_t size, unsigned long nslabs)
-{
-        return alloc_bootmem_low_pages(size);
-}
-
-void *swiotlb_alloc(unsigned order, unsigned long nslabs)
-{
-        return (void *)__get_free_pages(GFP_DMA | __GFP_NOWARN, order);
-}
-
-dma_addr_t swiotlb_phys_to_bus(struct device *hwdev, phys_addr_t paddr)
-{
-        return paddr;
-}
-
-phys_addr_t swiotlb_bus_to_phys(struct device *hwdev, dma_addr_t baddr)
-{
-        return baddr;
-}
-
-int __weak swiotlb_arch_range_needs_mapping(phys_addr_t paddr, size_t size)
-{
-        return 0;
-}
-
 static void *x86_swiotlb_alloc_coherent(struct device *hwdev, size_t size,
                                         dma_addr_t *dma_handle, gfp_t flags)
 {
diff --git a/arch/x86/kernel/ptrace.c b/arch/x86/kernel/ptrace.c
index 09ecbde91c13..8d7d5c9c1be3 100644
--- a/arch/x86/kernel/ptrace.c
+++ b/arch/x86/kernel/ptrace.c
@@ -35,10 +35,11 @@
 #include <asm/proto.h>
 #include <asm/ds.h>
 
-#include <trace/syscall.h>
-
 #include "tls.h"
 
+#define CREATE_TRACE_POINTS
+#include <trace/events/syscalls.h>
+
 enum x86_regset {
         REGSET_GENERAL,
         REGSET_FP,
@@ -1497,8 +1498,8 @@ asmregparm long syscall_trace_enter(struct pt_regs *regs)
             tracehook_report_syscall_entry(regs))
                 ret = -1L;
 
-        if (unlikely(test_thread_flag(TIF_SYSCALL_FTRACE)))
-                ftrace_syscall_enter(regs);
+        if (unlikely(test_thread_flag(TIF_SYSCALL_TRACEPOINT)))
+                trace_sys_enter(regs, regs->orig_ax);
 
         if (unlikely(current->audit_context)) {
                 if (IS_IA32)
@@ -1523,8 +1524,8 @@ asmregparm void syscall_trace_leave(struct pt_regs *regs)
         if (unlikely(current->audit_context))
                 audit_syscall_exit(AUDITSC_RESULT(regs->ax), regs->ax);
 
-        if (unlikely(test_thread_flag(TIF_SYSCALL_FTRACE)))
-                ftrace_syscall_exit(regs);
+        if (unlikely(test_thread_flag(TIF_SYSCALL_TRACEPOINT)))
+                trace_sys_exit(regs, regs->ax);
 
         if (test_thread_flag(TIF_SYSCALL_TRACE))
                 tracehook_report_syscall_exit(regs, 0);
diff --git a/arch/x86/kernel/sys_x86_64.c b/arch/x86/kernel/sys_x86_64.c
index 6bc211accf08..45e00eb09c3a 100644
--- a/arch/x86/kernel/sys_x86_64.c
+++ b/arch/x86/kernel/sys_x86_64.c
@@ -18,9 +18,9 @@
 #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)
+SYSCALL_DEFINE6(mmap, unsigned long, addr, unsigned long, len,
+                unsigned long, prot, unsigned long, flags,
+                unsigned long, fd, unsigned long, off)
 {
         long error;
         struct file *file;
@@ -226,7 +226,7 @@ bottomup:
 }
 
 
-asmlinkage long sys_uname(struct new_utsname __user *name)
+SYSCALL_DEFINE1(uname, struct new_utsname __user *, name)
 {
         int err;
         down_read(&uts_sem);
diff --git a/arch/x86/oprofile/nmi_int.c b/arch/x86/oprofile/nmi_int.c
index 89b9a5cd63da..cb88b1a0bd5f 100644
--- a/arch/x86/oprofile/nmi_int.c
+++ b/arch/x86/oprofile/nmi_int.c
@@ -1,11 +1,14 @@
 /**
  * @file nmi_int.c
  *
- * @remark Copyright 2002-2008 OProfile authors
+ * @remark Copyright 2002-2009 OProfile authors
  * @remark Read the file COPYING
  *
  * @author John Levon <levon@movementarian.org>
  * @author Robert Richter <robert.richter@amd.com>
+ * @author Barry Kasindorf <barry.kasindorf@amd.com>
+ * @author Jason Yeh <jason.yeh@amd.com>
+ * @author Suravee Suthikulpanit <suravee.suthikulpanit@amd.com>
  */
 
 #include <linux/init.h>
@@ -24,13 +27,35 @@
 #include "op_counter.h"
 #include "op_x86_model.h"
 
-static struct op_x86_model_spec const *model;
+static struct op_x86_model_spec *model;
 static DEFINE_PER_CPU(struct op_msrs, cpu_msrs);
 static DEFINE_PER_CPU(unsigned long, saved_lvtpc);
 
 /* 0 == registered but off, 1 == registered and on */
 static int nmi_enabled = 0;
 
+struct op_counter_config counter_config[OP_MAX_COUNTER];
+
+/* common functions */
+
+u64 op_x86_get_ctrl(struct op_x86_model_spec const *model,
+                    struct op_counter_config *counter_config)
+{
+        u64 val = 0;
+        u16 event = (u16)counter_config->event;
+
+        val |= ARCH_PERFMON_EVENTSEL_INT;
+        val |= counter_config->user ? ARCH_PERFMON_EVENTSEL_USR : 0;
+        val |= counter_config->kernel ? ARCH_PERFMON_EVENTSEL_OS : 0;
+        val |= (counter_config->unit_mask & 0xFF) << 8;
+        event &= model->event_mask ? model->event_mask : 0xFF;
+        val |= event & 0xFF;
+        val |= (event & 0x0F00) << 24;
+
+        return val;
+}
+
+
 static int profile_exceptions_notify(struct notifier_block *self,
                                      unsigned long val, void *data)
 {
@@ -52,36 +77,214 @@ static int profile_exceptions_notify(struct notifier_block *self,
 
 static void nmi_cpu_save_registers(struct op_msrs *msrs)
 {
-        unsigned int const nr_ctrs = model->num_counters;
-        unsigned int const nr_ctrls = model->num_controls;
         struct op_msr *counters = msrs->counters;
         struct op_msr *controls = msrs->controls;
         unsigned int i;
 
-        for (i = 0; i < nr_ctrs; ++i) {
-                if (counters[i].addr) {
-                        rdmsr(counters[i].addr,
-                                counters[i].saved.low,
-                                counters[i].saved.high);
-                }
+        for (i = 0; i < model->num_counters; ++i) {
+                if (counters[i].addr)
+                        rdmsrl(counters[i].addr, counters[i].saved);
+        }
+
+        for (i = 0; i < model->num_controls; ++i) {
+                if (controls[i].addr)
+                        rdmsrl(controls[i].addr, controls[i].saved);
+        }
+}
+
+static void nmi_cpu_start(void *dummy)
+{
+        struct op_msrs const *msrs = &__get_cpu_var(cpu_msrs);
+        model->start(msrs);
+}
+
+static int nmi_start(void)
+{
+        on_each_cpu(nmi_cpu_start, NULL, 1);
+        return 0;
+}
+
+static void nmi_cpu_stop(void *dummy)
+{
+        struct op_msrs const *msrs = &__get_cpu_var(cpu_msrs);
+        model->stop(msrs);
+}
+
+static void nmi_stop(void)
+{
+        on_each_cpu(nmi_cpu_stop, NULL, 1);
+}
+
+#ifdef CONFIG_OPROFILE_EVENT_MULTIPLEX
+
+static DEFINE_PER_CPU(int, switch_index);
+
+static inline int has_mux(void)
+{
+        return !!model->switch_ctrl;
+}
+
+inline int op_x86_phys_to_virt(int phys)
+{
+        return __get_cpu_var(switch_index) + phys;
+}
+
+inline int op_x86_virt_to_phys(int virt)
+{
+        return virt % model->num_counters;
+}
+
+static void nmi_shutdown_mux(void)
+{
+        int i;
+
+        if (!has_mux())
+                return;
+
+        for_each_possible_cpu(i) {
+                kfree(per_cpu(cpu_msrs, i).multiplex);
+                per_cpu(cpu_msrs, i).multiplex = NULL;
+                per_cpu(switch_index, i) = 0;
         }
+}
+
+static int nmi_setup_mux(void)
+{
+        size_t multiplex_size =
+                sizeof(struct op_msr) * model->num_virt_counters;
+        int i;
+
+        if (!has_mux())
+                return 1;
+
+        for_each_possible_cpu(i) {
+                per_cpu(cpu_msrs, i).multiplex =
+                        kmalloc(multiplex_size, GFP_KERNEL);
+                if (!per_cpu(cpu_msrs, i).multiplex)
+                        return 0;
+        }
+
+        return 1;
+}
+
+static void nmi_cpu_setup_mux(int cpu, struct op_msrs const * const msrs)
+{
+        int i;
+        struct op_msr *multiplex = msrs->multiplex;
+
+        if (!has_mux())
+                return;
 
-        for (i = 0; i < nr_ctrls; ++i) {
-                if (controls[i].addr) {
-                        rdmsr(controls[i].addr,
-                                controls[i].saved.low,
-                                controls[i].saved.high);
+        for (i = 0; i < model->num_virt_counters; ++i) {
+                if (counter_config[i].enabled) {
+                        multiplex[i].saved = -(u64)counter_config[i].count;
+                } else {
+                        multiplex[i].addr  = 0;
+                        multiplex[i].saved = 0;
                 }
         }
+
+        per_cpu(switch_index, cpu) = 0;
+}
+
+static void nmi_cpu_save_mpx_registers(struct op_msrs *msrs)
+{
+        struct op_msr *multiplex = msrs->multiplex;
+        int i;
+
+        for (i = 0; i < model->num_counters; ++i) {
+                int virt = op_x86_phys_to_virt(i);
+                if (multiplex[virt].addr)
+                        rdmsrl(multiplex[virt].addr, multiplex[virt].saved);
+        }
+}
+
+static void nmi_cpu_restore_mpx_registers(struct op_msrs *msrs)
+{
+        struct op_msr *multiplex = msrs->multiplex;
+        int i;
+
+        for (i = 0; i < model->num_counters; ++i) {
+                int virt = op_x86_phys_to_virt(i);
+                if (multiplex[virt].addr)
+                        wrmsrl(multiplex[virt].addr, multiplex[virt].saved);
+        }
 }
 
-static void nmi_save_registers(void *dummy)
+static void nmi_cpu_switch(void *dummy)
 {
         int cpu = smp_processor_id();
+        int si = per_cpu(switch_index, cpu);
         struct op_msrs *msrs = &per_cpu(cpu_msrs, cpu);
-        nmi_cpu_save_registers(msrs);
+
+        nmi_cpu_stop(NULL);
+        nmi_cpu_save_mpx_registers(msrs);
+
+        /* move to next set */
+        si += model->num_counters;
+        if ((si > model->num_virt_counters) || (counter_config[si].count == 0))
+                per_cpu(switch_index, cpu) = 0;
+        else
+                per_cpu(switch_index, cpu) = si;
+
+        model->switch_ctrl(model, msrs);
+        nmi_cpu_restore_mpx_registers(msrs);
+
+        nmi_cpu_start(NULL);
+}
+
+
+/*
+ * Quick check to see if multiplexing is necessary.
+ * The check should be sufficient since counters are used
+ * in ordre.
+ */
+static int nmi_multiplex_on(void)
+{
+        return counter_config[model->num_counters].count ? 0 : -EINVAL;
+}
+
+static int nmi_switch_event(void)
+{
+        if (!has_mux())
+                return -ENOSYS;         /* not implemented */
+        if (nmi_multiplex_on() < 0)
+                return -EINVAL;         /* not necessary */
+
+        on_each_cpu(nmi_cpu_switch, NULL, 1);
+
+        return 0;
+}
+
+static inline void mux_init(struct oprofile_operations *ops)
+{
+        if (has_mux())
+                ops->switch_events = nmi_switch_event;
+}
+
+static void mux_clone(int cpu)
+{
+        if (!has_mux())
+                return;
+
+        memcpy(per_cpu(cpu_msrs, cpu).multiplex,
+               per_cpu(cpu_msrs, 0).multiplex,
+               sizeof(struct op_msr) * model->num_virt_counters);
 }
 
+#else
+
+inline int op_x86_phys_to_virt(int phys) { return phys; }
+inline int op_x86_virt_to_phys(int virt) { return virt; }
+static inline void nmi_shutdown_mux(void) { }
+static inline int nmi_setup_mux(void) { return 1; }
+static inline void
+nmi_cpu_setup_mux(int cpu, struct op_msrs const * const msrs) { }
+static inline void mux_init(struct oprofile_operations *ops) { }
+static void mux_clone(int cpu) { }
+
+#endif
+
 static void free_msrs(void)
 {
         int i;
@@ -95,38 +298,32 @@ static void free_msrs(void)
 
 static int allocate_msrs(void)
 {
-        int success = 1;
         size_t controls_size = sizeof(struct op_msr) * model->num_controls;
         size_t counters_size = sizeof(struct op_msr) * model->num_counters;
 
         int i;
         for_each_possible_cpu(i) {
                 per_cpu(cpu_msrs, i).counters = kmalloc(counters_size,
-                                                                GFP_KERNEL);
-                if (!per_cpu(cpu_msrs, i).counters) {
-                        success = 0;
-                        break;
-                }
+                                                        GFP_KERNEL);
+                if (!per_cpu(cpu_msrs, i).counters)
+                        return 0;
                 per_cpu(cpu_msrs, i).controls = kmalloc(controls_size,
-                                                                GFP_KERNEL);
-                if (!per_cpu(cpu_msrs, i).controls) {
-                        success = 0;
-                        break;
-                }
+                                                        GFP_KERNEL);
+                if (!per_cpu(cpu_msrs, i).controls)
+                        return 0;
         }
 
-        if (!success)
-                free_msrs();
-
-        return success;
+        return 1;
 }
 
 static void nmi_cpu_setup(void *dummy)
 {
         int cpu = smp_processor_id();
         struct op_msrs *msrs = &per_cpu(cpu_msrs, cpu);
+        nmi_cpu_save_registers(msrs);
         spin_lock(&oprofilefs_lock);
-        model->setup_ctrs(msrs);
+        model->setup_ctrs(model, msrs);
+        nmi_cpu_setup_mux(cpu, msrs);
         spin_unlock(&oprofilefs_lock);
         per_cpu(saved_lvtpc, cpu) = apic_read(APIC_LVTPC);
         apic_write(APIC_LVTPC, APIC_DM_NMI);
@@ -144,11 +341,15 @@ static int nmi_setup(void)
         int cpu;
 
         if (!allocate_msrs())
-                return -ENOMEM;
+                err = -ENOMEM;
+        else if (!nmi_setup_mux())
+                err = -ENOMEM;
+        else
+                err = register_die_notifier(&profile_exceptions_nb);
 
-        err = register_die_notifier(&profile_exceptions_nb);
         if (err) {
                 free_msrs();
+                nmi_shutdown_mux();
                 return err;
         }
 
@@ -159,45 +360,38 @@ static int nmi_setup(void)
         /* Assume saved/restored counters are the same on all CPUs */
         model->fill_in_addresses(&per_cpu(cpu_msrs, 0));
         for_each_possible_cpu(cpu) {
-                if (cpu != 0) {
-                        memcpy(per_cpu(cpu_msrs, cpu).counters,
-                                per_cpu(cpu_msrs, 0).counters,
-                                sizeof(struct op_msr) * model->num_counters);
-
-                        memcpy(per_cpu(cpu_msrs, cpu).controls,
-                                per_cpu(cpu_msrs, 0).controls,
-                                sizeof(struct op_msr) * model->num_controls);
-                }
+                if (!cpu)
+                        continue;
+
+                memcpy(per_cpu(cpu_msrs, cpu).counters,
+                       per_cpu(cpu_msrs, 0).counters,
+                       sizeof(struct op_msr) * model->num_counters);
+
+                memcpy(per_cpu(cpu_msrs, cpu).controls,
+                       per_cpu(cpu_msrs, 0).controls,
+                       sizeof(struct op_msr) * model->num_controls);
 
+                mux_clone(cpu);
         }
-        on_each_cpu(nmi_save_registers, NULL, 1);
         on_each_cpu(nmi_cpu_setup, NULL, 1);
         nmi_enabled = 1;
         return 0;
 }
 
-static void nmi_restore_registers(struct op_msrs *msrs)
+static void nmi_cpu_restore_registers(struct op_msrs *msrs)
 {
-        unsigned int const nr_ctrs = model->num_counters;
-        unsigned int const nr_ctrls = model->num_controls;
         struct op_msr *counters = msrs->counters;
         struct op_msr *controls = msrs->controls;
         unsigned int i;
 
-        for (i = 0; i < nr_ctrls; ++i) {
-                if (controls[i].addr) {
-                        wrmsr(controls[i].addr,
-                                controls[i].saved.low,
-                                controls[i].saved.high);
-                }
+        for (i = 0; i < model->num_controls; ++i) {
+                if (controls[i].addr)
+                        wrmsrl(controls[i].addr, controls[i].saved);
         }
 
-        for (i = 0; i < nr_ctrs; ++i) {
-                if (counters[i].addr) {
-                        wrmsr(counters[i].addr,
-                                counters[i].saved.low,
-                                counters[i].saved.high);
-                }
+        for (i = 0; i < model->num_counters; ++i) {
+                if (counters[i].addr)
+                        wrmsrl(counters[i].addr, counters[i].saved);
         }
 }
 
@@ -205,7 +399,7 @@ static void nmi_cpu_shutdown(void *dummy)
 {
         unsigned int v;
         int cpu = smp_processor_id();
-        struct op_msrs *msrs = &__get_cpu_var(cpu_msrs);
+        struct op_msrs *msrs = &per_cpu(cpu_msrs, cpu);
 
         /* restoring APIC_LVTPC can trigger an apic error because the delivery
          * mode and vector nr combination can be illegal. That's by design: on
@@ -216,7 +410,7 @@ static void nmi_cpu_shutdown(void *dummy)
         apic_write(APIC_LVTERR, v | APIC_LVT_MASKED);
         apic_write(APIC_LVTPC, per_cpu(saved_lvtpc, cpu));
         apic_write(APIC_LVTERR, v);
-        nmi_restore_registers(msrs);
+        nmi_cpu_restore_registers(msrs);
 }
 
 static void nmi_shutdown(void)
@@ -226,42 +420,18 @@ static void nmi_shutdown(void)
         nmi_enabled = 0;
         on_each_cpu(nmi_cpu_shutdown, NULL, 1);
         unregister_die_notifier(&profile_exceptions_nb);
+        nmi_shutdown_mux();
         msrs = &get_cpu_var(cpu_msrs);
         model->shutdown(msrs);
         free_msrs();
         put_cpu_var(cpu_msrs);
 }
 
-static void nmi_cpu_start(void *dummy)
-{
-        struct op_msrs const *msrs = &__get_cpu_var(cpu_msrs);
-        model->start(msrs);
-}
-
-static int nmi_start(void)
-{
-        on_each_cpu(nmi_cpu_start, NULL, 1);
-        return 0;
-}
-
-static void nmi_cpu_stop(void *dummy)
-{
-        struct op_msrs const *msrs = &__get_cpu_var(cpu_msrs);
-        model->stop(msrs);
-}
-
-static void nmi_stop(void)
-{
-        on_each_cpu(nmi_cpu_stop, NULL, 1);
-}
-
-struct op_counter_config counter_config[OP_MAX_COUNTER];
-
 static int nmi_create_files(struct super_block *sb, struct dentry *root)
 {
         unsigned int i;
 
-        for (i = 0; i < model->num_counters; ++i) {
+        for (i = 0; i < model->num_virt_counters; ++i) {
                 struct dentry *dir;
                 char buf[4];
 
@@ -270,7 +440,7 @@ static int nmi_create_files(struct super_block *sb, struct dentry *root)
                  * NOTE:  assumes 1:1 mapping here (that counters are organized
                  *        sequentially in their struct assignment).
                  */
-                if (unlikely(!avail_to_resrv_perfctr_nmi_bit(i)))
+                if (!avail_to_resrv_perfctr_nmi_bit(op_x86_virt_to_phys(i)))
                         continue;
 
                 snprintf(buf,  sizeof(buf), "%d", i);
@@ -402,6 +572,7 @@ module_param_call(cpu_type, force_cpu_type, NULL, NULL, 0);
 static int __init ppro_init(char **cpu_type)
 {
         __u8 cpu_model = boot_cpu_data.x86_model;
+        struct op_x86_model_spec *spec = &op_ppro_spec; /* default */
 
         if (force_arch_perfmon && cpu_has_arch_perfmon)
                 return 0;
@@ -428,7 +599,7 @@ static int __init ppro_init(char **cpu_type)
                 *cpu_type = "i386/core_2";
                 break;
         case 26:
-                arch_perfmon_setup_counters();
+                spec = &op_arch_perfmon_spec;
                 *cpu_type = "i386/core_i7";
                 break;
         case 28:
@@ -439,17 +610,7 @@ static int __init ppro_init(char **cpu_type)
                 return 0;
         }
 
-        model = &op_ppro_spec;
-        return 1;
-}
-
-static int __init arch_perfmon_init(char **cpu_type)
-{
-        if (!cpu_has_arch_perfmon)
-                return 0;
-        *cpu_type = "i386/arch_perfmon";
-        model = &op_arch_perfmon_spec;
-        arch_perfmon_setup_counters();
+        model = spec;
         return 1;
 }
 
@@ -471,27 +632,26 @@ int __init op_nmi_init(struct oprofile_operations *ops)
                 /* Needs to be at least an Athlon (or hammer in 32bit mode) */
 
                 switch (family) {
-                default:
-                        return -ENODEV;
                 case 6:
-                        model = &op_amd_spec;
                         cpu_type = "i386/athlon";
                         break;
                 case 0xf:
-                        model = &op_amd_spec;
-                        /* Actually it could be i386/hammer too, but give
-                         user space an consistent name. */
+                        /*
+                         * Actually it could be i386/hammer too, but
+                         * give user space an consistent name.
+                         */
                         cpu_type = "x86-64/hammer";
                         break;
                 case 0x10:
-                        model = &op_amd_spec;
                         cpu_type = "x86-64/family10";
                         break;
                 case 0x11:
-                        model = &op_amd_spec;
                         cpu_type = "x86-64/family11h";
                         break;
+                default:
+                        return -ENODEV;
                 }
+                model = &op_amd_spec;
                 break;
 
         case X86_VENDOR_INTEL:
@@ -510,8 +670,15 @@ int __init op_nmi_init(struct oprofile_operations *ops)
                         break;
                 }
 
-                if (!cpu_type && !arch_perfmon_init(&cpu_type))
+                if (cpu_type)
+                        break;
+
+                if (!cpu_has_arch_perfmon)
                         return -ENODEV;
+
+                /* use arch perfmon as fallback */
+                cpu_type = "i386/arch_perfmon";
+                model = &op_arch_perfmon_spec;
                 break;
 
         default:
@@ -522,18 +689,23 @@ int __init op_nmi_init(struct oprofile_operations *ops)
         register_cpu_notifier(&oprofile_cpu_nb);
 #endif
         /* default values, can be overwritten by model */
-        ops->create_files = nmi_create_files;
-        ops->setup = nmi_setup;
-        ops->shutdown = nmi_shutdown;
-        ops->start = nmi_start;
-        ops->stop = nmi_stop;
-        ops->cpu_type = cpu_type;
+        ops->create_files       = nmi_create_files;
+        ops->setup              = nmi_setup;
+        ops->shutdown           = nmi_shutdown;
+        ops->start              = nmi_start;
+        ops->stop               = nmi_stop;
+        ops->cpu_type           = cpu_type;
 
         if (model->init)
                 ret = model->init(ops);
         if (ret)
                 return ret;
 
+        if (!model->num_virt_counters)
+                model->num_virt_counters = model->num_counters;
+
+        mux_init(ops);
+
         init_sysfs();
         using_nmi = 1;
         printk(KERN_INFO "oprofile: using NMI interrupt.\n");
diff --git a/arch/x86/oprofile/op_counter.h b/arch/x86/oprofile/op_counter.h
index 91b6a116165e..e28398df0df2 100644
--- a/arch/x86/oprofile/op_counter.h
+++ b/arch/x86/oprofile/op_counter.h
@@ -10,7 +10,7 @@
 #ifndef OP_COUNTER_H
 #define OP_COUNTER_H
 
-#define OP_MAX_COUNTER 8
+#define OP_MAX_COUNTER 32
 
 /* Per-perfctr configuration as set via
  * oprofilefs.
diff --git a/arch/x86/oprofile/op_model_amd.c b/arch/x86/oprofile/op_model_amd.c
index 8fdf06e4edf9..39686c29f03a 100644
--- a/arch/x86/oprofile/op_model_amd.c
+++ b/arch/x86/oprofile/op_model_amd.c
@@ -9,12 +9,15 @@
  * @author Philippe Elie
  * @author Graydon Hoare
  * @author Robert Richter <robert.richter@amd.com>
- * @author Barry Kasindorf
+ * @author Barry Kasindorf <barry.kasindorf@amd.com>
+ * @author Jason Yeh <jason.yeh@amd.com>
+ * @author Suravee Suthikulpanit <suravee.suthikulpanit@amd.com>
  */
 
 #include <linux/oprofile.h>
 #include <linux/device.h>
 #include <linux/pci.h>
+#include <linux/percpu.h>
 
 #include <asm/ptrace.h>
 #include <asm/msr.h>
@@ -25,43 +28,36 @@
 
 #define NUM_COUNTERS 4
 #define NUM_CONTROLS 4
+#ifdef CONFIG_OPROFILE_EVENT_MULTIPLEX
+#define NUM_VIRT_COUNTERS 32
+#define NUM_VIRT_CONTROLS 32
+#else
+#define NUM_VIRT_COUNTERS NUM_COUNTERS
+#define NUM_VIRT_CONTROLS NUM_CONTROLS
+#endif
+
+#define OP_EVENT_MASK                   0x0FFF
+#define OP_CTR_OVERFLOW                 (1ULL<<31)
 
-#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))
-#define CTRL_SET_INACTIVE(n) (n &= ~(1<<22))
-#define CTRL_CLEAR_LO(x) (x &= (1<<21))
-#define CTRL_CLEAR_HI(x) (x &= 0xfffffcf0)
-#define CTRL_SET_ENABLE(val) (val |= 1<<20)
-#define CTRL_SET_USR(val, u) (val |= ((u & 1) << 16))
-#define CTRL_SET_KERN(val, k) (val |= ((k & 1) << 17))
-#define CTRL_SET_UM(val, m) (val |= (m << 8))
-#define CTRL_SET_EVENT_LOW(val, e) (val |= (e & 0xff))
-#define CTRL_SET_EVENT_HIGH(val, e) (val |= ((e >> 8) & 0xf))
-#define CTRL_SET_HOST_ONLY(val, h) (val |= ((h & 1) << 9))
-#define CTRL_SET_GUEST_ONLY(val, h) (val |= ((h & 1) << 8))
-
-static unsigned long reset_value[NUM_COUNTERS];
+#define MSR_AMD_EVENTSEL_RESERVED       ((0xFFFFFCF0ULL<<32)|(1ULL<<21))
+
+static unsigned long reset_value[NUM_VIRT_COUNTERS];
 
 #ifdef CONFIG_OPROFILE_IBS
 
 /* IbsFetchCtl bits/masks */
-#define IBS_FETCH_HIGH_VALID_BIT        (1UL << 17)     /* bit 49 */
-#define IBS_FETCH_HIGH_ENABLE           (1UL << 16)     /* bit 48 */
-#define IBS_FETCH_LOW_MAX_CNT_MASK      0x0000FFFFUL    /* MaxCnt mask */
+#define IBS_FETCH_RAND_EN               (1ULL<<57)
+#define IBS_FETCH_VAL                   (1ULL<<49)
+#define IBS_FETCH_ENABLE                (1ULL<<48)
+#define IBS_FETCH_CNT_MASK              0xFFFF0000ULL
 
 /*IbsOpCtl bits */
-#define IBS_OP_LOW_VALID_BIT            (1ULL<<18)      /* bit 18 */
-#define IBS_OP_LOW_ENABLE               (1ULL<<17)      /* bit 17 */
+#define IBS_OP_CNT_CTL                  (1ULL<<19)
+#define IBS_OP_VAL                      (1ULL<<18)
+#define IBS_OP_ENABLE                   (1ULL<<17)
 
-#define IBS_FETCH_SIZE  6
-#define IBS_OP_SIZE     12
+#define IBS_FETCH_SIZE                  6
+#define IBS_OP_SIZE                     12
 
 static int has_ibs;     /* AMD Family10h and later */
 
@@ -78,6 +74,45 @@ static struct op_ibs_config ibs_config;
 
 #endif
 
+#ifdef CONFIG_OPROFILE_EVENT_MULTIPLEX
+
+static void op_mux_fill_in_addresses(struct op_msrs * const msrs)
+{
+        int i;
+
+        for (i = 0; i < NUM_VIRT_COUNTERS; i++) {
+                int hw_counter = op_x86_virt_to_phys(i);
+                if (reserve_perfctr_nmi(MSR_K7_PERFCTR0 + i))
+                        msrs->multiplex[i].addr = MSR_K7_PERFCTR0 + hw_counter;
+                else
+                        msrs->multiplex[i].addr = 0;
+        }
+}
+
+static void op_mux_switch_ctrl(struct op_x86_model_spec const *model,
+                               struct op_msrs const * const msrs)
+{
+        u64 val;
+        int i;
+
+        /* enable active counters */
+        for (i = 0; i < NUM_COUNTERS; ++i) {
+                int virt = op_x86_phys_to_virt(i);
+                if (!counter_config[virt].enabled)
+                        continue;
+                rdmsrl(msrs->controls[i].addr, val);
+                val &= model->reserved;
+                val |= op_x86_get_ctrl(model, &counter_config[virt]);
+                wrmsrl(msrs->controls[i].addr, val);
+        }
+}
+
+#else
+
+static inline void op_mux_fill_in_addresses(struct op_msrs * const msrs) { }
+
+#endif
+
 /* functions for op_amd_spec */
 
 static void op_amd_fill_in_addresses(struct op_msrs * const msrs)
@@ -97,150 +132,174 @@ static void op_amd_fill_in_addresses(struct op_msrs * const msrs)
                 else
                         msrs->controls[i].addr = 0;
         }
-}
 
+        op_mux_fill_in_addresses(msrs);
+}
 
-static void op_amd_setup_ctrs(struct op_msrs const * const msrs)
+static void op_amd_setup_ctrs(struct op_x86_model_spec const *model,
+                              struct op_msrs const * const msrs)
 {
-        unsigned int low, high;
+        u64 val;
         int i;
 
+        /* setup reset_value */
+        for (i = 0; i < NUM_VIRT_COUNTERS; ++i) {
+                if (counter_config[i].enabled)
+                        reset_value[i] = counter_config[i].count;
+                else
+                        reset_value[i] = 0;
+        }
+
         /* clear all counters */
-        for (i = 0 ; i < NUM_CONTROLS; ++i) {
-                if (unlikely(!CTRL_IS_RESERVED(msrs, i)))
+        for (i = 0; i < NUM_CONTROLS; ++i) {
+                if (unlikely(!msrs->controls[i].addr))
                         continue;
-                CTRL_READ(low, high, msrs, i);
-                CTRL_CLEAR_LO(low);
-                CTRL_CLEAR_HI(high);
-                CTRL_WRITE(low, high, msrs, i);
+                rdmsrl(msrs->controls[i].addr, val);
+                val &= model->reserved;
+                wrmsrl(msrs->controls[i].addr, val);
         }
 
         /* avoid a false detection of ctr overflows in NMI handler */
         for (i = 0; i < NUM_COUNTERS; ++i) {
-                if (unlikely(!CTR_IS_RESERVED(msrs, i)))
+                if (unlikely(!msrs->counters[i].addr))
                         continue;
-                CTR_WRITE(1, msrs, i);
+                wrmsrl(msrs->counters[i].addr, -1LL);
         }
 
         /* enable active counters */
         for (i = 0; i < NUM_COUNTERS; ++i) {
-                if ((counter_config[i].enabled) && (CTR_IS_RESERVED(msrs, i))) {
-                        reset_value[i] = counter_config[i].count;
+                int virt = op_x86_phys_to_virt(i);
+                if (!counter_config[virt].enabled)
+                        continue;
+                if (!msrs->counters[i].addr)
+                        continue;
 
-                        CTR_WRITE(counter_config[i].count, msrs, i);
-
-                        CTRL_READ(low, high, msrs, i);
-                        CTRL_CLEAR_LO(low);
-                        CTRL_CLEAR_HI(high);
-                        CTRL_SET_ENABLE(low);
-                        CTRL_SET_USR(low, counter_config[i].user);
-                        CTRL_SET_KERN(low, counter_config[i].kernel);
-                        CTRL_SET_UM(low, counter_config[i].unit_mask);
-                        CTRL_SET_EVENT_LOW(low, counter_config[i].event);
-                        CTRL_SET_EVENT_HIGH(high, counter_config[i].event);
-                        CTRL_SET_HOST_ONLY(high, 0);
-                        CTRL_SET_GUEST_ONLY(high, 0);
-
-                        CTRL_WRITE(low, high, msrs, i);
-                } else {
-                        reset_value[i] = 0;
-                }
+                /* setup counter registers */
+                wrmsrl(msrs->counters[i].addr, -(u64)reset_value[virt]);
+
+                /* setup control registers */
+                rdmsrl(msrs->controls[i].addr, val);
+                val &= model->reserved;
+                val |= op_x86_get_ctrl(model, &counter_config[virt]);
+                wrmsrl(msrs->controls[i].addr, val);
         }
 }
 
 #ifdef CONFIG_OPROFILE_IBS
 
-static inline int
+static inline void
 op_amd_handle_ibs(struct pt_regs * const regs,
                   struct op_msrs const * const msrs)
 {
-        u32 low, high;
-        u64 msr;
+        u64 val, ctl;
         struct op_entry entry;
 
         if (!has_ibs)
-                return 1;
+                return;
 
         if (ibs_config.fetch_enabled) {
-                rdmsr(MSR_AMD64_IBSFETCHCTL, low, high);
-                if (high & IBS_FETCH_HIGH_VALID_BIT) {
-                        rdmsrl(MSR_AMD64_IBSFETCHLINAD, msr);
-                        oprofile_write_reserve(&entry, regs, msr,
+                rdmsrl(MSR_AMD64_IBSFETCHCTL, ctl);
+                if (ctl & IBS_FETCH_VAL) {
+                        rdmsrl(MSR_AMD64_IBSFETCHLINAD, val);
+                        oprofile_write_reserve(&entry, regs, val,
                                                IBS_FETCH_CODE, IBS_FETCH_SIZE);
-                        oprofile_add_data(&entry, (u32)msr);
-                        oprofile_add_data(&entry, (u32)(msr >> 32));
-                        oprofile_add_data(&entry, low);
-                        oprofile_add_data(&entry, high);
-                        rdmsrl(MSR_AMD64_IBSFETCHPHYSAD, msr);
-                        oprofile_add_data(&entry, (u32)msr);
-                        oprofile_add_data(&entry, (u32)(msr >> 32));
+                        oprofile_add_data64(&entry, val);
+                        oprofile_add_data64(&entry, ctl);
+                        rdmsrl(MSR_AMD64_IBSFETCHPHYSAD, val);
+                        oprofile_add_data64(&entry, val);
                         oprofile_write_commit(&entry);
 
                         /* reenable the IRQ */
-                        high &= ~IBS_FETCH_HIGH_VALID_BIT;
-                        high |= IBS_FETCH_HIGH_ENABLE;
-                        low &= IBS_FETCH_LOW_MAX_CNT_MASK;
-                        wrmsr(MSR_AMD64_IBSFETCHCTL, low, high);
+                        ctl &= ~(IBS_FETCH_VAL | IBS_FETCH_CNT_MASK);
+                        ctl |= IBS_FETCH_ENABLE;
+                        wrmsrl(MSR_AMD64_IBSFETCHCTL, ctl);
                 }
         }
 
         if (ibs_config.op_enabled) {
-                rdmsr(MSR_AMD64_IBSOPCTL, low, high);
-                if (low & IBS_OP_LOW_VALID_BIT) {
-                        rdmsrl(MSR_AMD64_IBSOPRIP, msr);
-                        oprofile_write_reserve(&entry, regs, msr,
+                rdmsrl(MSR_AMD64_IBSOPCTL, ctl);
+                if (ctl & IBS_OP_VAL) {
+                        rdmsrl(MSR_AMD64_IBSOPRIP, val);
+                        oprofile_write_reserve(&entry, regs, val,
                                                IBS_OP_CODE, IBS_OP_SIZE);
-                        oprofile_add_data(&entry, (u32)msr);
-                        oprofile_add_data(&entry, (u32)(msr >> 32));
-                        rdmsrl(MSR_AMD64_IBSOPDATA, msr);
-                        oprofile_add_data(&entry, (u32)msr);
-                        oprofile_add_data(&entry, (u32)(msr >> 32));
-                        rdmsrl(MSR_AMD64_IBSOPDATA2, msr);
-                        oprofile_add_data(&entry, (u32)msr);
-                        oprofile_add_data(&entry, (u32)(msr >> 32));
-                        rdmsrl(MSR_AMD64_IBSOPDATA3, msr);
-                        oprofile_add_data(&entry, (u32)msr);
-                        oprofile_add_data(&entry, (u32)(msr >> 32));
-                        rdmsrl(MSR_AMD64_IBSDCLINAD, msr);
-                        oprofile_add_data(&entry, (u32)msr);
-                        oprofile_add_data(&entry, (u32)(msr >> 32));
-                        rdmsrl(MSR_AMD64_IBSDCPHYSAD, msr);
-                        oprofile_add_data(&entry, (u32)msr);
-                        oprofile_add_data(&entry, (u32)(msr >> 32));
+                        oprofile_add_data64(&entry, val);
+                        rdmsrl(MSR_AMD64_IBSOPDATA, val);
+                        oprofile_add_data64(&entry, val);
+                        rdmsrl(MSR_AMD64_IBSOPDATA2, val);
+                        oprofile_add_data64(&entry, val);
+                        rdmsrl(MSR_AMD64_IBSOPDATA3, val);
+                        oprofile_add_data64(&entry, val);
+                        rdmsrl(MSR_AMD64_IBSDCLINAD, val);
+                        oprofile_add_data64(&entry, val);
+                        rdmsrl(MSR_AMD64_IBSDCPHYSAD, val);
+                        oprofile_add_data64(&entry, val);
                         oprofile_write_commit(&entry);
 
                         /* reenable the IRQ */
-                        high = 0;
-                        low &= ~IBS_OP_LOW_VALID_BIT;
-                        low |= IBS_OP_LOW_ENABLE;
-                        wrmsr(MSR_AMD64_IBSOPCTL, low, high);
+                        ctl &= ~IBS_OP_VAL & 0xFFFFFFFF;
+                        ctl |= IBS_OP_ENABLE;
+                        wrmsrl(MSR_AMD64_IBSOPCTL, ctl);
                 }
         }
+}
 
-        return 1;
+static inline void op_amd_start_ibs(void)
+{
+        u64 val;
+        if (has_ibs && ibs_config.fetch_enabled) {
+                val = (ibs_config.max_cnt_fetch >> 4) & 0xFFFF;
+                val |= ibs_config.rand_en ? IBS_FETCH_RAND_EN : 0;
+                val |= IBS_FETCH_ENABLE;
+                wrmsrl(MSR_AMD64_IBSFETCHCTL, val);
+        }
+
+        if (has_ibs && ibs_config.op_enabled) {
+                val = (ibs_config.max_cnt_op >> 4) & 0xFFFF;
+                val |= ibs_config.dispatched_ops ? IBS_OP_CNT_CTL : 0;
+                val |= IBS_OP_ENABLE;
+                wrmsrl(MSR_AMD64_IBSOPCTL, val);
+        }
+}
+
+static void op_amd_stop_ibs(void)
+{
+        if (has_ibs && ibs_config.fetch_enabled)
+                /* clear max count and enable */
+                wrmsrl(MSR_AMD64_IBSFETCHCTL, 0);
+
+        if (has_ibs && ibs_config.op_enabled)
+                /* clear max count and enable */
+                wrmsrl(MSR_AMD64_IBSOPCTL, 0);
 }
 
+#else
+
+static inline void op_amd_handle_ibs(struct pt_regs * const regs,
+                                    struct op_msrs const * const msrs) { }
+static inline void op_amd_start_ibs(void) { }
+static inline void op_amd_stop_ibs(void) { }
+
 #endif
 
 static int op_amd_check_ctrs(struct pt_regs * const regs,
                              struct op_msrs const * const msrs)
 {
-        unsigned int low, high;
+        u64 val;
         int i;
 
-        for (i = 0 ; i < NUM_COUNTERS; ++i) {
-                if (!reset_value[i])
+        for (i = 0; i < NUM_COUNTERS; ++i) {
+                int virt = op_x86_phys_to_virt(i);
+                if (!reset_value[virt])
                         continue;
-                CTR_READ(low, high, msrs, i);
-                if (CTR_OVERFLOWED(low)) {
-                        oprofile_add_sample(regs, i);
-                        CTR_WRITE(reset_value[i], msrs, i);
-                }
+                rdmsrl(msrs->counters[i].addr, val);
+                /* bit is clear if overflowed: */
+                if (val & OP_CTR_OVERFLOW)
+                        continue;
+                oprofile_add_sample(regs, virt);
+                wrmsrl(msrs->counters[i].addr, -(u64)reset_value[virt]);
         }
 
-#ifdef CONFIG_OPROFILE_IBS
         op_amd_handle_ibs(regs, msrs);
-#endif
 
         /* See op_model_ppro.c */
         return 1;
@@ -248,79 +307,50 @@ static int op_amd_check_ctrs(struct pt_regs * const regs,
 
 static void op_amd_start(struct op_msrs const * const msrs)
 {
-        unsigned int low, high;
+        u64 val;
         int i;
-        for (i = 0 ; i < NUM_COUNTERS ; ++i) {
-                if (reset_value[i]) {
-                        CTRL_READ(low, high, msrs, i);
-                        CTRL_SET_ACTIVE(low);
-                        CTRL_WRITE(low, high, msrs, i);
-                }
-        }
 
-#ifdef CONFIG_OPROFILE_IBS
-        if (has_ibs && ibs_config.fetch_enabled) {
-                low = (ibs_config.max_cnt_fetch >> 4) & 0xFFFF;
-                high = ((ibs_config.rand_en & 0x1) << 25) /* bit 57 */
-                        + IBS_FETCH_HIGH_ENABLE;
-                wrmsr(MSR_AMD64_IBSFETCHCTL, low, high);
+        for (i = 0; i < NUM_COUNTERS; ++i) {
+                if (!reset_value[op_x86_phys_to_virt(i)])
+                        continue;
+                rdmsrl(msrs->controls[i].addr, val);
+                val |= ARCH_PERFMON_EVENTSEL0_ENABLE;
+                wrmsrl(msrs->controls[i].addr, val);
         }
 
-        if (has_ibs && ibs_config.op_enabled) {
-                low = ((ibs_config.max_cnt_op >> 4) & 0xFFFF)
-                        + ((ibs_config.dispatched_ops & 0x1) << 19) /* bit 19 */
-                        + IBS_OP_LOW_ENABLE;
-                high = 0;
-                wrmsr(MSR_AMD64_IBSOPCTL, low, high);
-        }
-#endif
+        op_amd_start_ibs();
 }
 
-
 static void op_amd_stop(struct op_msrs const * const msrs)
 {
-        unsigned int low, high;
+        u64 val;
         int i;
 
         /*
          * Subtle: stop on all counters to avoid race with setting our
          * pm callback
          */
-        for (i = 0 ; i < NUM_COUNTERS ; ++i) {
-                if (!reset_value[i])
+        for (i = 0; i < NUM_COUNTERS; ++i) {
+                if (!reset_value[op_x86_phys_to_virt(i)])
                         continue;
-                CTRL_READ(low, high, msrs, i);
-                CTRL_SET_INACTIVE(low);
-                CTRL_WRITE(low, high, msrs, i);
-        }
-
-#ifdef CONFIG_OPROFILE_IBS
-        if (has_ibs && ibs_config.fetch_enabled) {
-                /* clear max count and enable */
-                low = 0;
-                high = 0;
-                wrmsr(MSR_AMD64_IBSFETCHCTL, low, high);
+                rdmsrl(msrs->controls[i].addr, val);
+                val &= ~ARCH_PERFMON_EVENTSEL0_ENABLE;
+                wrmsrl(msrs->controls[i].addr, val);
         }
 
-        if (has_ibs && ibs_config.op_enabled) {
-                /* clear max count and enable */
-                low = 0;
-                high = 0;
-                wrmsr(MSR_AMD64_IBSOPCTL, low, high);
-        }
-#endif
+        op_amd_stop_ibs();
 }
 
 static void op_amd_shutdown(struct op_msrs const * const msrs)
 {
         int i;
 
-        for (i = 0 ; i < NUM_COUNTERS ; ++i) {
-                if (CTR_IS_RESERVED(msrs, i))
+        for (i = 0; i < NUM_COUNTERS; ++i) {
+                if (msrs->counters[i].addr)
                         release_perfctr_nmi(MSR_K7_PERFCTR0 + i);
         }
-        for (i = 0 ; i < NUM_CONTROLS ; ++i) {
-                if (CTRL_IS_RESERVED(msrs, i))
+        for (i = 0; i < NUM_CONTROLS; ++i) {
+                if (msrs->controls[i].addr)
                         release_evntsel_nmi(MSR_K7_EVNTSEL0 + i);
         }
 }
@@ -490,15 +520,21 @@ static void op_amd_exit(void) {}
 
 #endif /* CONFIG_OPROFILE_IBS */
 
-struct op_x86_model_spec const op_amd_spec = {
-        .init                   = op_amd_init,
-        .exit                   = op_amd_exit,
+struct op_x86_model_spec op_amd_spec = {
         .num_counters           = NUM_COUNTERS,
         .num_controls           = NUM_CONTROLS,
+        .num_virt_counters      = NUM_VIRT_COUNTERS,
+        .reserved               = MSR_AMD_EVENTSEL_RESERVED,
+        .event_mask             = OP_EVENT_MASK,
+        .init                   = op_amd_init,
+        .exit                   = op_amd_exit,
         .fill_in_addresses      = &op_amd_fill_in_addresses,
         .setup_ctrs             = &op_amd_setup_ctrs,
         .check_ctrs             = &op_amd_check_ctrs,
         .start                  = &op_amd_start,
         .stop                   = &op_amd_stop,
-        .shutdown               = &op_amd_shutdown
+        .shutdown               = &op_amd_shutdown,
+#ifdef CONFIG_OPROFILE_EVENT_MULTIPLEX
+        .switch_ctrl            = &op_mux_switch_ctrl,
+#endif
 };
diff --git a/arch/x86/oprofile/op_model_p4.c b/arch/x86/oprofile/op_model_p4.c
index 819b131fd752..ac6b354becdf 100644
--- a/arch/x86/oprofile/op_model_p4.c
+++ b/arch/x86/oprofile/op_model_p4.c
@@ -32,6 +32,8 @@
 #define NUM_CCCRS_HT2 9
 #define NUM_CONTROLS_HT2 (NUM_ESCRS_HT2 + NUM_CCCRS_HT2)
 
+#define OP_CTR_OVERFLOW                 (1ULL<<31)
+
 static unsigned int num_counters = NUM_COUNTERS_NON_HT;
 static unsigned int num_controls = NUM_CONTROLS_NON_HT;
 
@@ -350,8 +352,6 @@ static struct p4_event_binding p4_events[NUM_EVENTS] = {
 #define ESCR_SET_OS_1(escr, os) ((escr) |= (((os) & 1) << 1))
 #define ESCR_SET_EVENT_SELECT(escr, sel) ((escr) |= (((sel) & 0x3f) << 25))
 #define ESCR_SET_EVENT_MASK(escr, mask) ((escr) |= (((mask) & 0xffff) << 9))
-#define ESCR_READ(escr, high, ev, i) do {rdmsr(ev->bindings[(i)].escr_address, (escr), (high)); } while (0)
-#define ESCR_WRITE(escr, high, ev, i) do {wrmsr(ev->bindings[(i)].escr_address, (escr), (high)); } while (0)
 
 #define CCCR_RESERVED_BITS 0x38030FFF
 #define CCCR_CLEAR(cccr) ((cccr) &= CCCR_RESERVED_BITS)
@@ -361,17 +361,9 @@ static struct p4_event_binding p4_events[NUM_EVENTS] = {
 #define CCCR_SET_PMI_OVF_1(cccr) ((cccr) |= (1<<27))
 #define CCCR_SET_ENABLE(cccr) ((cccr) |= (1<<12))
 #define CCCR_SET_DISABLE(cccr) ((cccr) &= ~(1<<12))
-#define CCCR_READ(low, high, i) do {rdmsr(p4_counters[(i)].cccr_address, (low), (high)); } while (0)
-#define CCCR_WRITE(low, high, i) do {wrmsr(p4_counters[(i)].cccr_address, (low), (high)); } while (0)
 #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))
-
 
 /* this assigns a "stagger" to the current CPU, which is used throughout
    the code in this module as an extra array offset, to select the "even"
@@ -515,7 +507,7 @@ static void pmc_setup_one_p4_counter(unsigned int ctr)
                 if (ev->bindings[i].virt_counter & counter_bit) {
 
                         /* modify ESCR */
-                        ESCR_READ(escr, high, ev, i);
+                        rdmsr(ev->bindings[i].escr_address, escr, high);
                         ESCR_CLEAR(escr);
                         if (stag == 0) {
                                 ESCR_SET_USR_0(escr, counter_config[ctr].user);
@@ -526,10 +518,11 @@ static void pmc_setup_one_p4_counter(unsigned int ctr)
                         }
                         ESCR_SET_EVENT_SELECT(escr, ev->event_select);
                         ESCR_SET_EVENT_MASK(escr, counter_config[ctr].unit_mask);
-                        ESCR_WRITE(escr, high, ev, i);
+                        wrmsr(ev->bindings[i].escr_address, escr, high);
 
                         /* modify CCCR */
-                        CCCR_READ(cccr, high, VIRT_CTR(stag, ctr));
+                        rdmsr(p4_counters[VIRT_CTR(stag, ctr)].cccr_address,
+                              cccr, high);
                         CCCR_CLEAR(cccr);
                         CCCR_SET_REQUIRED_BITS(cccr);
                         CCCR_SET_ESCR_SELECT(cccr, ev->escr_select);
@@ -537,7 +530,8 @@ static void pmc_setup_one_p4_counter(unsigned int ctr)
                                 CCCR_SET_PMI_OVF_0(cccr);
                         else
                                 CCCR_SET_PMI_OVF_1(cccr);
-                        CCCR_WRITE(cccr, high, VIRT_CTR(stag, ctr));
+                        wrmsr(p4_counters[VIRT_CTR(stag, ctr)].cccr_address,
+                              cccr, high);
                         return;
                 }
         }
@@ -548,7 +542,8 @@ static void pmc_setup_one_p4_counter(unsigned int ctr)
 }
 
 
-static void p4_setup_ctrs(struct op_msrs const * const msrs)
+static void p4_setup_ctrs(struct op_x86_model_spec const *model,
+                          struct op_msrs const * const msrs)
 {
         unsigned int i;
         unsigned int low, high;
@@ -563,8 +558,8 @@ 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)))
+        for (i = 0; i < num_counters; i++) {
+                if (unlikely(!msrs->controls[i].addr))
                         continue;
                 rdmsr(p4_counters[VIRT_CTR(stag, i)].cccr_address, low, high);
                 CCCR_CLEAR(low);
@@ -574,17 +569,18 @@ static void p4_setup_ctrs(struct op_msrs const * const msrs)
 
         /* clear all escrs (including those outside our concern) */
         for (i = num_counters; i < num_controls; i++) {
-                if (unlikely(!CTRL_IS_RESERVED(msrs, i)))
+                if (unlikely(!msrs->controls[i].addr))
                         continue;
                 wrmsr(msrs->controls[i].addr, 0, 0);
         }
 
         /* setup all counters */
-        for (i = 0 ; i < num_counters ; ++i) {
-                if ((counter_config[i].enabled) && (CTRL_IS_RESERVED(msrs, i))) {
+        for (i = 0; i < num_counters; ++i) {
+                if (counter_config[i].enabled && msrs->controls[i].addr) {
                         reset_value[i] = counter_config[i].count;
                         pmc_setup_one_p4_counter(i);
-                        CTR_WRITE(counter_config[i].count, VIRT_CTR(stag, i));
+                        wrmsrl(p4_counters[VIRT_CTR(stag, i)].counter_address,
+                               -(u64)counter_config[i].count);
                 } else {
                         reset_value[i] = 0;
                 }
@@ -624,14 +620,16 @@ static int p4_check_ctrs(struct pt_regs * const regs,
 
                 real = VIRT_CTR(stag, i);
 
-                CCCR_READ(low, high, real);
-                CTR_READ(ctr, high, real);
-                if (CCCR_OVF_P(low) || CTR_OVERFLOW_P(ctr)) {
+                rdmsr(p4_counters[real].cccr_address, low, high);
+                rdmsr(p4_counters[real].counter_address, ctr, high);
+                if (CCCR_OVF_P(low) || !(ctr & OP_CTR_OVERFLOW)) {
                         oprofile_add_sample(regs, i);
-                        CTR_WRITE(reset_value[i], real);
+                        wrmsrl(p4_counters[real].counter_address,
+                               -(u64)reset_value[i]);
                         CCCR_CLEAR_OVF(low);
-                        CCCR_WRITE(low, high, real);
-                        CTR_WRITE(reset_value[i], real);
+                        wrmsr(p4_counters[real].cccr_address, low, high);
+                        wrmsrl(p4_counters[real].counter_address,
+                               -(u64)reset_value[i]);
                 }
         }
 
@@ -653,9 +651,9 @@ static void p4_start(struct op_msrs const * const msrs)
         for (i = 0; i < num_counters; ++i) {
                 if (!reset_value[i])
                         continue;
-                CCCR_READ(low, high, VIRT_CTR(stag, i));
+                rdmsr(p4_counters[VIRT_CTR(stag, i)].cccr_address, low, high);
                 CCCR_SET_ENABLE(low);
-                CCCR_WRITE(low, high, VIRT_CTR(stag, i));
+                wrmsr(p4_counters[VIRT_CTR(stag, i)].cccr_address, low, high);
         }
 }
 
@@ -670,9 +668,9 @@ static void p4_stop(struct op_msrs const * const msrs)
         for (i = 0; i < num_counters; ++i) {
                 if (!reset_value[i])
                         continue;
-                CCCR_READ(low, high, VIRT_CTR(stag, i));
+                rdmsr(p4_counters[VIRT_CTR(stag, i)].cccr_address, low, high);
                 CCCR_SET_DISABLE(low);
-                CCCR_WRITE(low, high, VIRT_CTR(stag, i));
+                wrmsr(p4_counters[VIRT_CTR(stag, i)].cccr_address, low, high);
         }
 }
 
@@ -680,8 +678,8 @@ 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))
+        for (i = 0; i < num_counters; ++i) {
+                if (msrs->counters[i].addr)
                         release_perfctr_nmi(msrs->counters[i].addr);
         }
         /*
@@ -689,15 +687,15 @@ static void p4_shutdown(struct op_msrs const * const msrs)
          * 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))
+        for (i = num_counters; i < num_controls; ++i) {
+                if (msrs->controls[i].addr)
                         release_evntsel_nmi(msrs->controls[i].addr);
         }
 }
 
 
 #ifdef CONFIG_SMP
-struct op_x86_model_spec const op_p4_ht2_spec = {
+struct op_x86_model_spec op_p4_ht2_spec = {
         .num_counters           = NUM_COUNTERS_HT2,
         .num_controls           = NUM_CONTROLS_HT2,
         .fill_in_addresses      = &p4_fill_in_addresses,
@@ -709,7 +707,7 @@ struct op_x86_model_spec const op_p4_ht2_spec = {
 };
 #endif
 
-struct op_x86_model_spec const op_p4_spec = {
+struct op_x86_model_spec op_p4_spec = {
         .num_counters           = NUM_COUNTERS_NON_HT,
         .num_controls           = NUM_CONTROLS_NON_HT,
         .fill_in_addresses      = &p4_fill_in_addresses,
diff --git a/arch/x86/oprofile/op_model_ppro.c b/arch/x86/oprofile/op_model_ppro.c
index 4da7230b3d17..4899215999de 100644
--- a/arch/x86/oprofile/op_model_ppro.c
+++ b/arch/x86/oprofile/op_model_ppro.c
@@ -10,6 +10,7 @@
  * @author Philippe Elie
  * @author Graydon Hoare
  * @author Andi Kleen
+ * @author Robert Richter <robert.richter@amd.com>
  */
 
 #include <linux/oprofile.h>
@@ -18,7 +19,6 @@
 #include <asm/msr.h>
 #include <asm/apic.h>
 #include <asm/nmi.h>
-#include <asm/perf_counter.h>
 
 #include "op_x86_model.h"
 #include "op_counter.h"
@@ -26,20 +26,7 @@
 static int num_counters = 2;
 static int counter_width = 32;
 
-#define CTR_IS_RESERVED(msrs, c) (msrs->counters[(c)].addr ? 1 : 0)
-#define CTR_OVERFLOWED(n) (!((n) & (1ULL<<(counter_width-1))))
-
-#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))
-#define CTRL_SET_INACTIVE(n) (n &= ~(1<<22))
-#define CTRL_CLEAR(x) (x &= (1<<21))
-#define CTRL_SET_ENABLE(val) (val |= 1<<20)
-#define CTRL_SET_USR(val, u) (val |= ((u & 1) << 16))
-#define CTRL_SET_KERN(val, k) (val |= ((k & 1) << 17))
-#define CTRL_SET_UM(val, m) (val |= (m << 8))
-#define CTRL_SET_EVENT(val, e) (val |= e)
+#define MSR_PPRO_EVENTSEL_RESERVED      ((0xFFFFFFFFULL<<32)|(1ULL<<21))
 
 static u64 *reset_value;
 
@@ -63,9 +50,10 @@ static void ppro_fill_in_addresses(struct op_msrs * const msrs)
 }
 
 
-static void ppro_setup_ctrs(struct op_msrs const * const msrs)
+static void ppro_setup_ctrs(struct op_x86_model_spec const *model,
+                            struct op_msrs const * const msrs)
 {
-        unsigned int low, high;
+        u64 val;
         int i;
 
         if (!reset_value) {
@@ -93,36 +81,30 @@ static void ppro_setup_ctrs(struct op_msrs const * const msrs)
         }
 
         /* clear all counters */
-        for (i = 0 ; i < num_counters; ++i) {
-                if (unlikely(!CTRL_IS_RESERVED(msrs, i)))
+        for (i = 0; i < num_counters; ++i) {
+                if (unlikely(!msrs->controls[i].addr))
                         continue;
-                CTRL_READ(low, high, msrs, i);
-                CTRL_CLEAR(low);
-                CTRL_WRITE(low, high, msrs, i);
+                rdmsrl(msrs->controls[i].addr, val);
+                val &= model->reserved;
+                wrmsrl(msrs->controls[i].addr, val);
         }
 
         /* avoid a false detection of ctr overflows in NMI handler */
         for (i = 0; i < num_counters; ++i) {
-                if (unlikely(!CTR_IS_RESERVED(msrs, i)))
+                if (unlikely(!msrs->counters[i].addr))
                         continue;
                 wrmsrl(msrs->counters[i].addr, -1LL);
         }
 
         /* enable active counters */
         for (i = 0; i < num_counters; ++i) {
-                if ((counter_config[i].enabled) && (CTR_IS_RESERVED(msrs, i))) {
+                if (counter_config[i].enabled && msrs->counters[i].addr) {
                         reset_value[i] = counter_config[i].count;
-
                         wrmsrl(msrs->counters[i].addr, -reset_value[i]);
-
-                        CTRL_READ(low, high, msrs, i);
-                        CTRL_CLEAR(low);
-                        CTRL_SET_ENABLE(low);
-                        CTRL_SET_USR(low, counter_config[i].user);
-                        CTRL_SET_KERN(low, counter_config[i].kernel);
-                        CTRL_SET_UM(low, counter_config[i].unit_mask);
-                        CTRL_SET_EVENT(low, counter_config[i].event);
-                        CTRL_WRITE(low, high, msrs, i);
+                        rdmsrl(msrs->controls[i].addr, val);
+                        val &= model->reserved;
+                        val |= op_x86_get_ctrl(model, &counter_config[i]);
+                        wrmsrl(msrs->controls[i].addr, val);
                 } else {
                         reset_value[i] = 0;
                 }
@@ -143,14 +125,14 @@ static int ppro_check_ctrs(struct pt_regs * const regs,
         if (unlikely(!reset_value))
                 goto out;
 
-        for (i = 0 ; i < num_counters; ++i) {
+        for (i = 0; i < num_counters; ++i) {
                 if (!reset_value[i])
                         continue;
                 rdmsrl(msrs->counters[i].addr, val);
-                if (CTR_OVERFLOWED(val)) {
-                        oprofile_add_sample(regs, i);
-                        wrmsrl(msrs->counters[i].addr, -reset_value[i]);
-                }
+                if (val & (1ULL << (counter_width - 1)))
+                        continue;
+                oprofile_add_sample(regs, i);
+                wrmsrl(msrs->counters[i].addr, -reset_value[i]);
         }
 
 out:
@@ -171,16 +153,16 @@ out:
 
 static void ppro_start(struct op_msrs const * const msrs)
 {
-        unsigned int low, high;
+        u64 val;
         int i;
 
         if (!reset_value)
                 return;
         for (i = 0; i < num_counters; ++i) {
                 if (reset_value[i]) {
-                        CTRL_READ(low, high, msrs, i);
-                        CTRL_SET_ACTIVE(low);
-                        CTRL_WRITE(low, high, msrs, i);
+                        rdmsrl(msrs->controls[i].addr, val);
+                        val |= ARCH_PERFMON_EVENTSEL0_ENABLE;
+                        wrmsrl(msrs->controls[i].addr, val);
                 }
         }
 }
@@ -188,7 +170,7 @@ static void ppro_start(struct op_msrs const * const msrs)
 
 static void ppro_stop(struct op_msrs const * const msrs)
 {
-        unsigned int low, high;
+        u64 val;
         int i;
 
         if (!reset_value)
@@ -196,9 +178,9 @@ static void ppro_stop(struct op_msrs const * const msrs)
         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);
+                rdmsrl(msrs->controls[i].addr, val);
+                val &= ~ARCH_PERFMON_EVENTSEL0_ENABLE;
+                wrmsrl(msrs->controls[i].addr, val);
         }
 }
 
@@ -206,12 +188,12 @@ 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))
+        for (i = 0; i < num_counters; ++i) {
+                if (msrs->counters[i].addr)
                         release_perfctr_nmi(MSR_P6_PERFCTR0 + i);
         }
-        for (i = 0 ; i < num_counters ; ++i) {
-                if (CTRL_IS_RESERVED(msrs, i))
+        for (i = 0; i < num_counters; ++i) {
+                if (msrs->controls[i].addr)
                         release_evntsel_nmi(MSR_P6_EVNTSEL0 + i);
         }
         if (reset_value) {
@@ -222,8 +204,9 @@ static void ppro_shutdown(struct op_msrs const * const msrs)
 
 
 struct op_x86_model_spec op_ppro_spec = {
-        .num_counters           = 2,    /* can be overriden */
-        .num_controls           = 2,    /* dito */
+        .num_counters           = 2,
+        .num_controls           = 2,
+        .reserved               = MSR_PPRO_EVENTSEL_RESERVED,
         .fill_in_addresses      = &ppro_fill_in_addresses,
         .setup_ctrs             = &ppro_setup_ctrs,
         .check_ctrs             = &ppro_check_ctrs,
@@ -241,7 +224,7 @@ struct op_x86_model_spec op_ppro_spec = {
  * the specific CPU.
  */
 
-void arch_perfmon_setup_counters(void)
+static void arch_perfmon_setup_counters(void)
 {
         union cpuid10_eax eax;
 
@@ -259,11 +242,17 @@ void arch_perfmon_setup_counters(void)
 
         op_arch_perfmon_spec.num_counters = num_counters;
         op_arch_perfmon_spec.num_controls = num_counters;
-        op_ppro_spec.num_counters = num_counters;
-        op_ppro_spec.num_controls = num_counters;
+}
+
+static int arch_perfmon_init(struct oprofile_operations *ignore)
+{
+        arch_perfmon_setup_counters();
+        return 0;
 }
 
 struct op_x86_model_spec op_arch_perfmon_spec = {
+        .reserved               = MSR_PPRO_EVENTSEL_RESERVED,
+        .init                   = &arch_perfmon_init,
         /* num_counters/num_controls filled in at runtime */
         .fill_in_addresses      = &ppro_fill_in_addresses,
         /* user space does the cpuid check for available events */
diff --git a/arch/x86/oprofile/op_x86_model.h b/arch/x86/oprofile/op_x86_model.h
index 825e79064d64..b83776180c7f 100644
--- a/arch/x86/oprofile/op_x86_model.h
+++ b/arch/x86/oprofile/op_x86_model.h
@@ -6,51 +6,66 @@
  * @remark Read the file COPYING
  *
  * @author Graydon Hoare
+ * @author Robert Richter <robert.richter@amd.com>
  */
 
 #ifndef OP_X86_MODEL_H
 #define OP_X86_MODEL_H
 
-struct op_saved_msr {
-        unsigned int high;
-        unsigned int low;
-};
+#include <asm/types.h>
+#include <asm/perf_counter.h>
 
 struct op_msr {
-        unsigned long addr;
-        struct op_saved_msr saved;
+        unsigned long   addr;
+        u64             saved;
 };
 
 struct op_msrs {
         struct op_msr *counters;
         struct op_msr *controls;
+        struct op_msr *multiplex;
 };
 
 struct pt_regs;
 
+struct oprofile_operations;
+
 /* The model vtable abstracts the differences between
  * various x86 CPU models' perfctr support.
  */
 struct op_x86_model_spec {
-        int (*init)(struct oprofile_operations *ops);
-        void (*exit)(void);
-        unsigned int num_counters;
-        unsigned int num_controls;
-        void (*fill_in_addresses)(struct op_msrs * const msrs);
-        void (*setup_ctrs)(struct op_msrs const * const msrs);
-        int (*check_ctrs)(struct pt_regs * const regs,
-                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);
+        unsigned int    num_counters;
+        unsigned int    num_controls;
+        unsigned int    num_virt_counters;
+        u64             reserved;
+        u16             event_mask;
+        int             (*init)(struct oprofile_operations *ops);
+        void            (*exit)(void);
+        void            (*fill_in_addresses)(struct op_msrs * const msrs);
+        void            (*setup_ctrs)(struct op_x86_model_spec const *model,
+                                      struct op_msrs const * const msrs);
+        int             (*check_ctrs)(struct pt_regs * const regs,
+                                      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);
+#ifdef CONFIG_OPROFILE_EVENT_MULTIPLEX
+        void            (*switch_ctrl)(struct op_x86_model_spec const *model,
+                                       struct op_msrs const * const msrs);
+#endif
 };
 
+struct op_counter_config;
+
+extern u64 op_x86_get_ctrl(struct op_x86_model_spec const *model,
+                           struct op_counter_config *counter_config);
+extern int op_x86_phys_to_virt(int phys);
+extern int op_x86_virt_to_phys(int virt);
+
 extern struct op_x86_model_spec op_ppro_spec;
-extern struct op_x86_model_spec const op_p4_spec;
-extern struct op_x86_model_spec const op_p4_ht2_spec;
-extern struct op_x86_model_spec const op_amd_spec;
+extern struct op_x86_model_spec op_p4_spec;
+extern struct op_x86_model_spec op_p4_ht2_spec;
+extern struct op_x86_model_spec op_amd_spec;
 extern struct op_x86_model_spec op_arch_perfmon_spec;
 
-extern void arch_perfmon_setup_counters(void);
-
 #endif /* OP_X86_MODEL_H */
diff --git a/arch/x86/pci/direct.c b/arch/x86/pci/direct.c
index bd13c3e4c6db..347d882b3bb3 100644
--- a/arch/x86/pci/direct.c
+++ b/arch/x86/pci/direct.c
@@ -192,13 +192,14 @@ struct pci_raw_ops pci_direct_conf2 = {
 static int __init pci_sanity_check(struct pci_raw_ops *o)
 {
         u32 x = 0;
-        int devfn;
+        int year, devfn;
 
         if (pci_probe & PCI_NO_CHECKS)
                 return 1;
         /* Assume Type 1 works for newer systems.
            This handles machines that don't have anything on PCI Bus 0. */
-        if (dmi_get_year(DMI_BIOS_DATE) >= 2001)
+        dmi_get_date(DMI_BIOS_DATE, &year, NULL, NULL);
+        if (year >= 2001)
                 return 1;
 
         for (devfn = 0; devfn < 0x100; devfn++) {
diff --git a/drivers/acpi/blacklist.c b/drivers/acpi/blacklist.c
index f6baa77deefb..0c4ca4d318b3 100644
--- a/drivers/acpi/blacklist.c
+++ b/drivers/acpi/blacklist.c
@@ -78,9 +78,10 @@ static struct acpi_blacklist_item acpi_blacklist[] __initdata = {
 
 static int __init blacklist_by_year(void)
 {
-        int year = dmi_get_year(DMI_BIOS_DATE);
+        int year;
+
         /* Doesn't exist? Likely an old system */
-        if (year == -1) {
+        if (!dmi_get_date(DMI_BIOS_DATE, &year, NULL, NULL)) {
                 printk(KERN_ERR PREFIX "no DMI BIOS year, "
                         "acpi=force is required to enable ACPI\n" );
                 return 1;
diff --git a/drivers/ata/Kconfig b/drivers/ata/Kconfig
index b17c57f85032..ab2fa4eeb364 100644
--- a/drivers/ata/Kconfig
+++ b/drivers/ata/Kconfig
@@ -26,6 +26,17 @@ config ATA_NONSTANDARD
        bool
        default n
 
+config ATA_VERBOSE_ERROR
+        bool "Verbose ATA error reporting"
+        default y
+        help
+          This option adds parsing of ATA command descriptions and error bits
+          in libata kernel output, making it easier to interpret.
+          This option will enlarge the kernel by approx. 6KB. Disable it only
+          if kernel size is more important than ease of debugging.
+
+          If unsure, say Y.
+
 config ATA_ACPI
         bool "ATA ACPI Support"
         depends on ACPI && PCI
@@ -586,6 +597,16 @@ config PATA_RB532
 
           If unsure, say N.
 
+config PATA_RDC
+        tristate "RDC PATA support"
+        depends on PCI
+        help
+          This option enables basic support for the later RDC PATA controllers
+          controllers via the new ATA layer. For the RDC 1010, you need to
+          enable the IT821X driver instead.
+
+          If unsure, say N.
+
 config PATA_RZ1000
         tristate "PC Tech RZ1000 PATA support"
         depends on PCI
diff --git a/drivers/ata/Makefile b/drivers/ata/Makefile
index 38906f9bbb4e..463eb52236aa 100644
--- a/drivers/ata/Makefile
+++ b/drivers/ata/Makefile
@@ -57,6 +57,7 @@ obj-$(CONFIG_PATA_PDC_OLD)	+= pata_pdc202xx_old.o
 obj-$(CONFIG_PATA_QDI)          += pata_qdi.o
 obj-$(CONFIG_PATA_RADISYS)      += pata_radisys.o
 obj-$(CONFIG_PATA_RB532)        += pata_rb532_cf.o
+obj-$(CONFIG_PATA_RDC)          += pata_rdc.o
 obj-$(CONFIG_PATA_RZ1000)       += pata_rz1000.o
 obj-$(CONFIG_PATA_SC1200)       += pata_sc1200.o
 obj-$(CONFIG_PATA_SERVERWORKS)  += pata_serverworks.o
diff --git a/drivers/ata/ahci.c b/drivers/ata/ahci.c
index fe3eba5d6b3e..d4cd9c203314 100644
--- a/drivers/ata/ahci.c
+++ b/drivers/ata/ahci.c
@@ -329,10 +329,24 @@ static ssize_t ahci_activity_store(struct ata_device *dev,
                                    enum sw_activity val);
 static void ahci_init_sw_activity(struct ata_link *link);
 
+static ssize_t ahci_show_host_caps(struct device *dev,
+                                   struct device_attribute *attr, char *buf);
+static ssize_t ahci_show_host_version(struct device *dev,
+                                      struct device_attribute *attr, char *buf);
+static ssize_t ahci_show_port_cmd(struct device *dev,
+                                  struct device_attribute *attr, char *buf);
+
+DEVICE_ATTR(ahci_host_caps, S_IRUGO, ahci_show_host_caps, NULL);
+DEVICE_ATTR(ahci_host_version, S_IRUGO, ahci_show_host_version, NULL);
+DEVICE_ATTR(ahci_port_cmd, S_IRUGO, ahci_show_port_cmd, NULL);
+
 static struct device_attribute *ahci_shost_attrs[] = {
         &dev_attr_link_power_management_policy,
         &dev_attr_em_message_type,
         &dev_attr_em_message,
+        &dev_attr_ahci_host_caps,
+        &dev_attr_ahci_host_version,
+        &dev_attr_ahci_port_cmd,
         NULL
 };
 
@@ -539,6 +553,12 @@ static const struct pci_device_id ahci_pci_tbl[] = {
         { PCI_VDEVICE(ATI, 0x4394), board_ahci_sb700 }, /* ATI SB700/800 */
         { PCI_VDEVICE(ATI, 0x4395), board_ahci_sb700 }, /* ATI SB700/800 */
 
+        /* AMD */
+        { PCI_VDEVICE(AMD, 0x7800), board_ahci }, /* AMD SB900 */
+        /* AMD is using RAID class only for ahci controllers */
+        { PCI_VENDOR_ID_AMD, PCI_ANY_ID, PCI_ANY_ID, PCI_ANY_ID,
+          PCI_CLASS_STORAGE_RAID << 8, 0xffffff, board_ahci },
+
         /* VIA */
         { PCI_VDEVICE(VIA, 0x3349), board_ahci_vt8251 }, /* VIA VT8251 */
         { PCI_VDEVICE(VIA, 0x6287), board_ahci_vt8251 }, /* VIA VT8251 */
@@ -702,6 +722,36 @@ static void ahci_enable_ahci(void __iomem *mmio)
         WARN_ON(1);
 }
 
+static ssize_t ahci_show_host_caps(struct device *dev,
+                                   struct device_attribute *attr, char *buf)
+{
+        struct Scsi_Host *shost = class_to_shost(dev);
+        struct ata_port *ap = ata_shost_to_port(shost);
+        struct ahci_host_priv *hpriv = ap->host->private_data;
+
+        return sprintf(buf, "%x\n", hpriv->cap);
+}
+
+static ssize_t ahci_show_host_version(struct device *dev,
+                                   struct device_attribute *attr, char *buf)
+{
+        struct Scsi_Host *shost = class_to_shost(dev);
+        struct ata_port *ap = ata_shost_to_port(shost);
+        void __iomem *mmio = ap->host->iomap[AHCI_PCI_BAR];
+
+        return sprintf(buf, "%x\n", readl(mmio + HOST_VERSION));
+}
+
+static ssize_t ahci_show_port_cmd(struct device *dev,
+                                  struct device_attribute *attr, char *buf)
+{
+        struct Scsi_Host *shost = class_to_shost(dev);
+        struct ata_port *ap = ata_shost_to_port(shost);
+        void __iomem *port_mmio = ahci_port_base(ap);
+
+        return sprintf(buf, "%x\n", readl(port_mmio + PORT_CMD));
+}
+
 /**
  *      ahci_save_initial_config - Save and fixup initial config values
  *      @pdev: target PCI device
@@ -1584,7 +1634,7 @@ static void ahci_fill_cmd_slot(struct ahci_port_priv *pp, unsigned int tag,
         pp->cmd_slot[tag].tbl_addr_hi = cpu_to_le32((cmd_tbl_dma >> 16) >> 16);
 }
 
-static int ahci_kick_engine(struct ata_port *ap, int force_restart)
+static int ahci_kick_engine(struct ata_port *ap)
 {
         void __iomem *port_mmio = ahci_port_base(ap);
         struct ahci_host_priv *hpriv = ap->host->private_data;
@@ -1592,18 +1642,16 @@ static int ahci_kick_engine(struct ata_port *ap, int force_restart)
         u32 tmp;
         int busy, rc;
 
-        /* do we need to kick the port? */
-        busy = status & (ATA_BUSY | ATA_DRQ);
-        if (!busy && !force_restart)
-                return 0;
-
         /* stop engine */
         rc = ahci_stop_engine(ap);
         if (rc)
                 goto out_restart;
 
-        /* need to do CLO? */
-        if (!busy) {
+        /* need to do CLO?
+         * always do CLO if PMP is attached (AHCI-1.3 9.2)
+         */
+        busy = status & (ATA_BUSY | ATA_DRQ);
+        if (!busy && !sata_pmp_attached(ap)) {
                 rc = 0;
                 goto out_restart;
         }
@@ -1651,7 +1699,7 @@ static int ahci_exec_polled_cmd(struct ata_port *ap, int pmp,
                 tmp = ata_wait_register(port_mmio + PORT_CMD_ISSUE, 0x1, 0x1,
                                         1, timeout_msec);
                 if (tmp & 0x1) {
-                        ahci_kick_engine(ap, 1);
+                        ahci_kick_engine(ap);
                         return -EBUSY;
                 }
         } else
@@ -1674,7 +1722,7 @@ static int ahci_do_softreset(struct ata_link *link, unsigned int *class,
         DPRINTK("ENTER\n");
 
         /* prepare for SRST (AHCI-1.1 10.4.1) */
-        rc = ahci_kick_engine(ap, 1);
+        rc = ahci_kick_engine(ap);
         if (rc && rc != -EOPNOTSUPP)
                 ata_link_printk(link, KERN_WARNING,
                                 "failed to reset engine (errno=%d)\n", rc);
@@ -1890,7 +1938,7 @@ static int ahci_p5wdh_hardreset(struct ata_link *link, unsigned int *class,
                 rc = ata_wait_after_reset(link, jiffies + 2 * HZ,
                                           ahci_check_ready);
                 if (rc)
-                        ahci_kick_engine(ap, 0);
+                        ahci_kick_engine(ap);
         }
         return rc;
 }
@@ -2271,7 +2319,7 @@ static void ahci_post_internal_cmd(struct ata_queued_cmd *qc)
 
         /* make DMA engine forget about the failed command */
         if (qc->flags & ATA_QCFLAG_FAILED)
-                ahci_kick_engine(ap, 1);
+                ahci_kick_engine(ap);
 }
 
 static void ahci_pmp_attach(struct ata_port *ap)
@@ -2603,14 +2651,18 @@ static void ahci_p5wdh_workaround(struct ata_host *host)
 }
 
 /*
- * SB600 ahci controller on ASUS M2A-VM can't do 64bit DMA with older
- * BIOS.  The oldest version known to be broken is 0901 and working is
- * 1501 which was released on 2007-10-26.  Force 32bit DMA on anything
- * older than 1501.  Please read bko#9412 for more info.
+ * SB600 ahci controller on certain boards can't do 64bit DMA with
+ * older BIOS.
  */
-static bool ahci_asus_m2a_vm_32bit_only(struct pci_dev *pdev)
+static bool ahci_sb600_32bit_only(struct pci_dev *pdev)
 {
         static const struct dmi_system_id sysids[] = {
+                /*
+                 * The oldest version known to be broken is 0901 and
+                 * working is 1501 which was released on 2007-10-26.
+                 * Force 32bit DMA on anything older than 1501.
+                 * Please read bko#9412 for more info.
+                 */
                 {
                         .ident = "ASUS M2A-VM",
                         .matches = {
@@ -2618,31 +2670,48 @@ static bool ahci_asus_m2a_vm_32bit_only(struct pci_dev *pdev)
                                           "ASUSTeK Computer INC."),
                                 DMI_MATCH(DMI_BOARD_NAME, "M2A-VM"),
                         },
+                        .driver_data = "20071026",      /* yyyymmdd */
+                },
+                /*
+                 * It's yet unknown whether more recent BIOS fixes the
+                 * problem.  Blacklist the whole board for the time
+                 * being.  Please read the following thread for more
+                 * info.
+                 *
+                 * http://thread.gmane.org/gmane.linux.ide/42326
+                 */
+                {
+                        .ident = "Gigabyte GA-MA69VM-S2",
+                        .matches = {
+                                DMI_MATCH(DMI_BOARD_VENDOR,
+                                          "Gigabyte Technology Co., Ltd."),
+                                DMI_MATCH(DMI_BOARD_NAME, "GA-MA69VM-S2"),
+                        },
                 },
                 { }
         };
-        const char *cutoff_mmdd = "10/26";
-        const char *date;
-        int year;
+        const struct dmi_system_id *match;
 
+        match = dmi_first_match(sysids);
         if (pdev->bus->number != 0 || pdev->devfn != PCI_DEVFN(0x12, 0) ||
-            !dmi_check_system(sysids))
+            !match)
                 return false;
 
-        /*
-         * Argh.... both version and date are free form strings.
-         * Let's hope they're using the same date format across
-         * different versions.
-         */
-        date = dmi_get_system_info(DMI_BIOS_DATE);
-        year = dmi_get_year(DMI_BIOS_DATE);
-        if (date && strlen(date) >= 10 && date[2] == '/' && date[5] == '/' &&
-            (year > 2007 ||
-             (year == 2007 && strncmp(date, cutoff_mmdd, 5) >= 0)))
-                return false;
+        if (match->driver_data) {
+                int year, month, date;
+                char buf[9];
+
+                dmi_get_date(DMI_BIOS_DATE, &year, &month, &date);
+                snprintf(buf, sizeof(buf), "%04d%02d%02d", year, month, date);
 
-        dev_printk(KERN_WARNING, &pdev->dev, "ASUS M2A-VM: BIOS too old, "
-                   "forcing 32bit DMA, update BIOS\n");
+                if (strcmp(buf, match->driver_data) >= 0)
+                        return false;
+
+                dev_printk(KERN_WARNING, &pdev->dev, "%s: BIOS too old, "
+                           "forcing 32bit DMA, update BIOS\n", match->ident);
+        } else
+                dev_printk(KERN_WARNING, &pdev->dev, "%s: this board can't "
+                           "do 64bit DMA, forcing 32bit\n", match->ident);
 
         return true;
 }
@@ -2857,8 +2926,8 @@ static int ahci_init_one(struct pci_dev *pdev, const struct pci_device_id *ent)
         if (board_id == board_ahci_sb700 && pdev->revision >= 0x40)
                 hpriv->flags &= ~AHCI_HFLAG_IGN_SERR_INTERNAL;
 
-        /* apply ASUS M2A_VM quirk */
-        if (ahci_asus_m2a_vm_32bit_only(pdev))
+        /* apply sb600 32bit only quirk */
+        if (ahci_sb600_32bit_only(pdev))
                 hpriv->flags |= AHCI_HFLAG_32BIT_ONLY;
 
         if (!(hpriv->flags & AHCI_HFLAG_NO_MSI))
@@ -2869,7 +2938,7 @@ static int ahci_init_one(struct pci_dev *pdev, const struct pci_device_id *ent)
 
         /* prepare host */
         if (hpriv->cap & HOST_CAP_NCQ)
-                pi.flags |= ATA_FLAG_NCQ;
+                pi.flags |= ATA_FLAG_NCQ | ATA_FLAG_FPDMA_AA;
 
         if (hpriv->cap & HOST_CAP_PMP)
                 pi.flags |= ATA_FLAG_PMP;
diff --git a/drivers/ata/libata-acpi.c b/drivers/ata/libata-acpi.c
index ac176da1f94e..01964b6e6f6b 100644
--- a/drivers/ata/libata-acpi.c
+++ b/drivers/ata/libata-acpi.c
@@ -689,6 +689,7 @@ static int ata_acpi_run_tf(struct ata_device *dev,
         struct ata_taskfile tf, ptf, rtf;
         unsigned int err_mask;
         const char *level;
+        const char *descr;
         char msg[60];
         int rc;
 
@@ -736,11 +737,13 @@ static int ata_acpi_run_tf(struct ata_device *dev,
                 snprintf(msg, sizeof(msg), "filtered out");
                 rc = 0;
         }
+        descr = ata_get_cmd_descript(tf.command);
 
         ata_dev_printk(dev, level,
-                       "ACPI cmd %02x/%02x:%02x:%02x:%02x:%02x:%02x %s\n",
+                       "ACPI cmd %02x/%02x:%02x:%02x:%02x:%02x:%02x (%s) %s\n",
                        tf.command, tf.feature, tf.nsect, tf.lbal,
-                       tf.lbam, tf.lbah, tf.device, msg);
+                       tf.lbam, tf.lbah, tf.device,
+                       (descr ? descr : "unknown"), msg);
 
         return rc;
 }
diff --git a/drivers/ata/libata-core.c b/drivers/ata/libata-core.c
index 072ba5ea138f..df31deac5c82 100644
--- a/drivers/ata/libata-core.c
+++ b/drivers/ata/libata-core.c
@@ -709,7 +709,13 @@ u64 ata_tf_read_block(struct ata_taskfile *tf, struct ata_device *dev)
                 head = tf->device & 0xf;
                 sect = tf->lbal;
 
-                block = (cyl * dev->heads + head) * dev->sectors + sect;
+                if (!sect) {
+                        ata_dev_printk(dev, KERN_WARNING, "device reported "
+                                       "invalid CHS sector 0\n");
+                        sect = 1; /* oh well */
+                }
+
+                block = (cyl * dev->heads + head) * dev->sectors + sect - 1;
         }
 
         return block;
@@ -2299,29 +2305,49 @@ static inline u8 ata_dev_knobble(struct ata_device *dev)
         return ((ap->cbl == ATA_CBL_SATA) && (!ata_id_is_sata(dev->id)));
 }
 
-static void ata_dev_config_ncq(struct ata_device *dev,
+static int ata_dev_config_ncq(struct ata_device *dev,
                                char *desc, size_t desc_sz)
 {
         struct ata_port *ap = dev->link->ap;
         int hdepth = 0, ddepth = ata_id_queue_depth(dev->id);
+        unsigned int err_mask;
+        char *aa_desc = "";
 
         if (!ata_id_has_ncq(dev->id)) {
                 desc[0] = '\0';
-                return;
+                return 0;
         }
         if (dev->horkage & ATA_HORKAGE_NONCQ) {
                 snprintf(desc, desc_sz, "NCQ (not used)");
-                return;
+                return 0;
         }
         if (ap->flags & ATA_FLAG_NCQ) {
                 hdepth = min(ap->scsi_host->can_queue, ATA_MAX_QUEUE - 1);
                 dev->flags |= ATA_DFLAG_NCQ;
         }
 
+        if (!(dev->horkage & ATA_HORKAGE_BROKEN_FPDMA_AA) &&
+                (ap->flags & ATA_FLAG_FPDMA_AA) &&
+                ata_id_has_fpdma_aa(dev->id)) {
+                err_mask = ata_dev_set_feature(dev, SETFEATURES_SATA_ENABLE,
+                        SATA_FPDMA_AA);
+                if (err_mask) {
+                        ata_dev_printk(dev, KERN_ERR, "failed to enable AA"
+                                "(error_mask=0x%x)\n", err_mask);
+                        if (err_mask != AC_ERR_DEV) {
+                                dev->horkage |= ATA_HORKAGE_BROKEN_FPDMA_AA;
+                                return -EIO;
+                        }
+                } else
+                        aa_desc = ", AA";
+        }
+
         if (hdepth >= ddepth)
-                snprintf(desc, desc_sz, "NCQ (depth %d)", ddepth);
+                snprintf(desc, desc_sz, "NCQ (depth %d)%s", ddepth, aa_desc);
         else
-                snprintf(desc, desc_sz, "NCQ (depth %d/%d)", hdepth, ddepth);
+                snprintf(desc, desc_sz, "NCQ (depth %d/%d)%s", hdepth,
+                        ddepth, aa_desc);
+        return 0;
 }
 
 /**
@@ -2461,7 +2487,7 @@ int ata_dev_configure(struct ata_device *dev)
 
                 if (ata_id_has_lba(id)) {
                         const char *lba_desc;
-                        char ncq_desc[20];
+                        char ncq_desc[24];
 
                         lba_desc = "LBA";
                         dev->flags |= ATA_DFLAG_LBA;
@@ -2475,7 +2501,9 @@ int ata_dev_configure(struct ata_device *dev)
                         }
 
                         /* config NCQ */
-                        ata_dev_config_ncq(dev, ncq_desc, sizeof(ncq_desc));
+                        rc = ata_dev_config_ncq(dev, ncq_desc, sizeof(ncq_desc));
+                        if (rc)
+                                return rc;
 
                         /* print device info to dmesg */
                         if (ata_msg_drv(ap) && print_info) {
diff --git a/drivers/ata/libata-eh.c b/drivers/ata/libata-eh.c
index 79711b64054b..a04488f0de88 100644
--- a/drivers/ata/libata-eh.c
+++ b/drivers/ata/libata-eh.c
@@ -40,6 +40,7 @@
 #include <scsi/scsi_eh.h>
 #include <scsi/scsi_device.h>
 #include <scsi/scsi_cmnd.h>
+#include <scsi/scsi_dbg.h>
 #include "../scsi/scsi_transport_api.h"
 
 #include <linux/libata.h>
@@ -999,7 +1000,9 @@ static void __ata_port_freeze(struct ata_port *ap)
  *      ata_port_freeze - abort & freeze port
  *      @ap: ATA port to freeze
  *
- *      Abort and freeze @ap.
+ *      Abort and freeze @ap.  The freeze operation must be called
+ *      first, because some hardware requires special operations
+ *      before the taskfile registers are accessible.
  *
  *      LOCKING:
  *      spin_lock_irqsave(host lock)
@@ -1013,8 +1016,8 @@ int ata_port_freeze(struct ata_port *ap)
 
         WARN_ON(!ap->ops->error_handler);
 
-        nr_aborted = ata_port_abort(ap);
         __ata_port_freeze(ap);
+        nr_aborted = ata_port_abort(ap);
 
         return nr_aborted;
 }
@@ -2110,6 +2113,116 @@ void ata_eh_autopsy(struct ata_port *ap)
 }
 
 /**
+ *      ata_get_cmd_descript - get description for ATA command
+ *      @command: ATA command code to get description for
+ *
+ *      Return a textual description of the given command, or NULL if the
+ *      command is not known.
+ *
+ *      LOCKING:
+ *      None
+ */
+const char *ata_get_cmd_descript(u8 command)
+{
+#ifdef CONFIG_ATA_VERBOSE_ERROR
+        static const struct
+        {
+                u8 command;
+                const char *text;
+        } cmd_descr[] = {
+                { ATA_CMD_DEV_RESET,            "DEVICE RESET" },
+                { ATA_CMD_CHK_POWER,            "CHECK POWER MODE" },
+                { ATA_CMD_STANDBY,              "STANDBY" },
+                { ATA_CMD_IDLE,                 "IDLE" },
+                { ATA_CMD_EDD,                  "EXECUTE DEVICE DIAGNOSTIC" },
+                { ATA_CMD_DOWNLOAD_MICRO,       "DOWNLOAD MICROCODE" },
+                { ATA_CMD_NOP,                  "NOP" },
+                { ATA_CMD_FLUSH,                "FLUSH CACHE" },
+                { ATA_CMD_FLUSH_EXT,            "FLUSH CACHE EXT" },
+                { ATA_CMD_ID_ATA,               "IDENTIFY DEVICE" },
+                { ATA_CMD_ID_ATAPI,             "IDENTIFY PACKET DEVICE" },
+                { ATA_CMD_SERVICE,              "SERVICE" },
+                { ATA_CMD_READ,                 "READ DMA" },
+                { ATA_CMD_READ_EXT,             "READ DMA EXT" },
+                { ATA_CMD_READ_QUEUED,          "READ DMA QUEUED" },
+                { ATA_CMD_READ_STREAM_EXT,      "READ STREAM EXT" },
+                { ATA_CMD_READ_STREAM_DMA_EXT,  "READ STREAM DMA EXT" },
+                { ATA_CMD_WRITE,                "WRITE DMA" },
+                { ATA_CMD_WRITE_EXT,            "WRITE DMA EXT" },
+                { ATA_CMD_WRITE_QUEUED,         "WRITE DMA QUEUED EXT" },
+                { ATA_CMD_WRITE_STREAM_EXT,     "WRITE STREAM EXT" },
+                { ATA_CMD_WRITE_STREAM_DMA_EXT, "WRITE STREAM DMA EXT" },
+                { ATA_CMD_WRITE_FUA_EXT,        "WRITE DMA FUA EXT" },
+                { ATA_CMD_WRITE_QUEUED_FUA_EXT, "WRITE DMA QUEUED FUA EXT" },
+                { ATA_CMD_FPDMA_READ,           "READ FPDMA QUEUED" },
+                { ATA_CMD_FPDMA_WRITE,          "WRITE FPDMA QUEUED" },
+                { ATA_CMD_PIO_READ,             "READ SECTOR(S)" },
+                { ATA_CMD_PIO_READ_EXT,         "READ SECTOR(S) EXT" },
+                { ATA_CMD_PIO_WRITE,            "WRITE SECTOR(S)" },
+                { ATA_CMD_PIO_WRITE_EXT,        "WRITE SECTOR(S) EXT" },
+                { ATA_CMD_READ_MULTI,           "READ MULTIPLE" },
+                { ATA_CMD_READ_MULTI_EXT,       "READ MULTIPLE EXT" },
+                { ATA_CMD_WRITE_MULTI,          "WRITE MULTIPLE" },
+                { ATA_CMD_WRITE_MULTI_EXT,      "WRITE MULTIPLE EXT" },
+                { ATA_CMD_WRITE_MULTI_FUA_EXT,  "WRITE MULTIPLE FUA EXT" },
+                { ATA_CMD_SET_FEATURES,         "SET FEATURES" },
+                { ATA_CMD_SET_MULTI,            "SET MULTIPLE MODE" },
+                { ATA_CMD_VERIFY,               "READ VERIFY SECTOR(S)" },
+                { ATA_CMD_VERIFY_EXT,           "READ VERIFY SECTOR(S) EXT" },
+                { ATA_CMD_WRITE_UNCORR_EXT,     "WRITE UNCORRECTABLE EXT" },
+                { ATA_CMD_STANDBYNOW1,          "STANDBY IMMEDIATE" },
+                { ATA_CMD_IDLEIMMEDIATE,        "IDLE IMMEDIATE" },
+                { ATA_CMD_SLEEP,                "SLEEP" },
+                { ATA_CMD_INIT_DEV_PARAMS,      "INITIALIZE DEVICE PARAMETERS" },
+                { ATA_CMD_READ_NATIVE_MAX,      "READ NATIVE MAX ADDRESS" },
+                { ATA_CMD_READ_NATIVE_MAX_EXT,  "READ NATIVE MAX ADDRESS EXT" },
+                { ATA_CMD_SET_MAX,              "SET MAX ADDRESS" },
+                { ATA_CMD_SET_MAX_EXT,          "SET MAX ADDRESS EXT" },
+                { ATA_CMD_READ_LOG_EXT,         "READ LOG EXT" },
+                { ATA_CMD_WRITE_LOG_EXT,        "WRITE LOG EXT" },
+                { ATA_CMD_READ_LOG_DMA_EXT,     "READ LOG DMA EXT" },
+                { ATA_CMD_WRITE_LOG_DMA_EXT,    "WRITE LOG DMA EXT" },
+                { ATA_CMD_TRUSTED_RCV,          "TRUSTED RECEIVE" },
+                { ATA_CMD_TRUSTED_RCV_DMA,      "TRUSTED RECEIVE DMA" },
+                { ATA_CMD_TRUSTED_SND,          "TRUSTED SEND" },
+                { ATA_CMD_TRUSTED_SND_DMA,      "TRUSTED SEND DMA" },
+                { ATA_CMD_PMP_READ,             "READ BUFFER" },
+                { ATA_CMD_PMP_WRITE,            "WRITE BUFFER" },
+                { ATA_CMD_CONF_OVERLAY,         "DEVICE CONFIGURATION OVERLAY" },
+                { ATA_CMD_SEC_SET_PASS,         "SECURITY SET PASSWORD" },
+                { ATA_CMD_SEC_UNLOCK,           "SECURITY UNLOCK" },
+                { ATA_CMD_SEC_ERASE_PREP,       "SECURITY ERASE PREPARE" },
+                { ATA_CMD_SEC_ERASE_UNIT,       "SECURITY ERASE UNIT" },
+                { ATA_CMD_SEC_FREEZE_LOCK,      "SECURITY FREEZE LOCK" },
+                { ATA_CMD_SEC_DISABLE_PASS,     "SECURITY DISABLE PASSWORD" },
+                { ATA_CMD_CONFIG_STREAM,        "CONFIGURE STREAM" },
+                { ATA_CMD_SMART,                "SMART" },
+                { ATA_CMD_MEDIA_LOCK,           "DOOR LOCK" },
+                { ATA_CMD_MEDIA_UNLOCK,         "DOOR UNLOCK" },
+                { ATA_CMD_CHK_MED_CRD_TYP,      "CHECK MEDIA CARD TYPE" },
+                { ATA_CMD_CFA_REQ_EXT_ERR,      "CFA REQUEST EXTENDED ERROR" },
+                { ATA_CMD_CFA_WRITE_NE,         "CFA WRITE SECTORS WITHOUT ERASE" },
+                { ATA_CMD_CFA_TRANS_SECT,       "CFA TRANSLATE SECTOR" },
+                { ATA_CMD_CFA_ERASE,            "CFA ERASE SECTORS" },
+                { ATA_CMD_CFA_WRITE_MULT_NE,    "CFA WRITE MULTIPLE WITHOUT ERASE" },
+                { ATA_CMD_READ_LONG,            "READ LONG (with retries)" },
+                { ATA_CMD_READ_LONG_ONCE,       "READ LONG (without retries)" },
+                { ATA_CMD_WRITE_LONG,           "WRITE LONG (with retries)" },
+                { ATA_CMD_WRITE_LONG_ONCE,      "WRITE LONG (without retries)" },
+                { ATA_CMD_RESTORE,              "RECALIBRATE" },
+                { 0,                            NULL } /* terminate list */
+        };
+
+        unsigned int i;
+        for (i = 0; cmd_descr[i].text; i++)
+                if (cmd_descr[i].command == command)
+                        return cmd_descr[i].text;
+#endif
+
+        return NULL;
+}
+
+/**
  *      ata_eh_link_report - report error handling to user
  *      @link: ATA link EH is going on
  *
@@ -2175,6 +2288,7 @@ static void ata_eh_link_report(struct ata_link *link)
                         ata_link_printk(link, KERN_ERR, "%s\n", desc);
         }
 
+#ifdef CONFIG_ATA_VERBOSE_ERROR
         if (ehc->i.serror)
                 ata_link_printk(link, KERN_ERR,
                   "SError: { %s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s}\n",
@@ -2195,6 +2309,7 @@ static void ata_eh_link_report(struct ata_link *link)
                   ehc->i.serror & SERR_TRANS_ST_ERROR ? "TrStaTrns " : "",
                   ehc->i.serror & SERR_UNRECOG_FIS ? "UnrecFIS " : "",
                   ehc->i.serror & SERR_DEV_XCHG ? "DevExch " : "");
+#endif
 
         for (tag = 0; tag < ATA_MAX_QUEUE; tag++) {
                 struct ata_queued_cmd *qc = __ata_qc_from_tag(ap, tag);
@@ -2226,14 +2341,23 @@ static void ata_eh_link_report(struct ata_link *link)
                                  dma_str[qc->dma_dir]);
                 }
 
-                if (ata_is_atapi(qc->tf.protocol))
-                        snprintf(cdb_buf, sizeof(cdb_buf),
+                if (ata_is_atapi(qc->tf.protocol)) {
+                        if (qc->scsicmd)
+                                scsi_print_command(qc->scsicmd);
+                        else
+                                snprintf(cdb_buf, sizeof(cdb_buf),
                                  "cdb %02x %02x %02x %02x %02x %02x %02x %02x  "
                                  "%02x %02x %02x %02x %02x %02x %02x %02x\n         ",
                                  cdb[0], cdb[1], cdb[2], cdb[3],
                                  cdb[4], cdb[5], cdb[6], cdb[7],
                                  cdb[8], cdb[9], cdb[10], cdb[11],
                                  cdb[12], cdb[13], cdb[14], cdb[15]);
+                } else {
+                        const char *descr = ata_get_cmd_descript(cmd->command);
+                        if (descr)
+                                ata_dev_printk(qc->dev, KERN_ERR,
+                                        "failed command: %s\n", descr);
+                }
 
                 ata_dev_printk(qc->dev, KERN_ERR,
                         "cmd %02x/%02x:%02x:%02x:%02x:%02x/%02x:%02x:%02x:%02x:%02x/%02x "
@@ -2252,6 +2376,7 @@ static void ata_eh_link_report(struct ata_link *link)
                         res->device, qc->err_mask, ata_err_string(qc->err_mask),
                         qc->err_mask & AC_ERR_NCQ ? " <F>" : "");
 
+#ifdef CONFIG_ATA_VERBOSE_ERROR
                 if (res->command & (ATA_BUSY | ATA_DRDY | ATA_DF | ATA_DRQ |
                                     ATA_ERR)) {
                         if (res->command & ATA_BUSY)
@@ -2275,6 +2400,7 @@ static void ata_eh_link_report(struct ata_link *link)
                           res->feature & ATA_UNC ? "UNC " : "",
                           res->feature & ATA_IDNF ? "IDNF " : "",
                           res->feature & ATA_ABORTED ? "ABRT " : "");
+#endif
         }
 }
 
@@ -2574,11 +2700,17 @@ int ata_eh_reset(struct ata_link *link, int classify,
                         postreset(slave, classes);
         }
 
-        /* clear cached SError */
+        /*
+         * Some controllers can't be frozen very well and may set
+         * spuruious error conditions during reset.  Clear accumulated
+         * error information.  As reset is the final recovery action,
+         * nothing is lost by doing this.
+         */
         spin_lock_irqsave(link->ap->lock, flags);
-        link->eh_info.serror = 0;
+        memset(&link->eh_info, 0, sizeof(link->eh_info));
         if (slave)
-                slave->eh_info.serror = 0;
+                memset(&slave->eh_info, 0, sizeof(link->eh_info));
+        ap->pflags &= ~ATA_PFLAG_EH_PENDING;
         spin_unlock_irqrestore(link->ap->lock, flags);
 
         /* Make sure onlineness and classification result correspond.
diff --git a/drivers/ata/libata-pmp.c b/drivers/ata/libata-pmp.c
index 619f2c33950e..51f0ffb78cbd 100644
--- a/drivers/ata/libata-pmp.c
+++ b/drivers/ata/libata-pmp.c
@@ -221,6 +221,8 @@ static const char *sata_pmp_spec_rev_str(const u32 *gscr)
 {
         u32 rev = gscr[SATA_PMP_GSCR_REV];
 
+        if (rev & (1 << 3))
+                return "1.2";
         if (rev & (1 << 2))
                 return "1.1";
         if (rev & (1 << 1))
diff --git a/drivers/ata/libata-scsi.c b/drivers/ata/libata-scsi.c
index d0dfeef55db5..b4ee28dec521 100644
--- a/drivers/ata/libata-scsi.c
+++ b/drivers/ata/libata-scsi.c
@@ -1119,10 +1119,6 @@ static int ata_scsi_dev_config(struct scsi_device *sdev,
 
                 blk_queue_dma_drain(q, atapi_drain_needed, buf, ATAPI_MAX_DRAIN);
         } else {
-                if (ata_id_is_ssd(dev->id))
-                        queue_flag_set_unlocked(QUEUE_FLAG_NONROT,
-                                                sdev->request_queue);
-
                 /* ATA devices must be sector aligned */
                 blk_queue_update_dma_alignment(sdev->request_queue,
                                                ATA_SECT_SIZE - 1);
@@ -1257,23 +1253,6 @@ int ata_scsi_change_queue_depth(struct scsi_device *sdev, int queue_depth)
         return queue_depth;
 }
 
-/* XXX: for spindown warning */
-static void ata_delayed_done_timerfn(unsigned long arg)
-{
-        struct scsi_cmnd *scmd = (void *)arg;
-
-        scmd->scsi_done(scmd);
-}
-
-/* XXX: for spindown warning */
-static void ata_delayed_done(struct scsi_cmnd *scmd)
-{
-        static struct timer_list timer;
-
-        setup_timer(&timer, ata_delayed_done_timerfn, (unsigned long)scmd);
-        mod_timer(&timer, jiffies + 5 * HZ);
-}
-
 /**
  *      ata_scsi_start_stop_xlat - Translate SCSI START STOP UNIT command
  *      @qc: Storage for translated ATA taskfile
@@ -1338,32 +1317,6 @@ static unsigned int ata_scsi_start_stop_xlat(struct ata_queued_cmd *qc)
                      system_entering_hibernation())
                         goto skip;
 
-                /* XXX: This is for backward compatibility, will be
-                 * removed.  Read Documentation/feature-removal-schedule.txt
-                 * for more info.
-                 */
-                if ((qc->dev->flags & ATA_DFLAG_SPUNDOWN) &&
-                    (system_state == SYSTEM_HALT ||
-                     system_state == SYSTEM_POWER_OFF)) {
-                        static unsigned long warned;
-
-                        if (!test_and_set_bit(0, &warned)) {
-                                ata_dev_printk(qc->dev, KERN_WARNING,
-                                        "DISK MIGHT NOT BE SPUN DOWN PROPERLY. "
-                                        "UPDATE SHUTDOWN UTILITY\n");
-                                ata_dev_printk(qc->dev, KERN_WARNING,
-                                        "For more info, visit "
-                                        "http://linux-ata.org/shutdown.html\n");
-
-                                /* ->scsi_done is not used, use it for
-                                 * delayed completion.
-                                 */
-                                scmd->scsi_done = qc->scsidone;
-                                qc->scsidone = ata_delayed_done;
-                        }
-                        goto skip;
-                }
-
                 /* Issue ATA STANDBY IMMEDIATE command */
                 tf->command = ATA_CMD_STANDBYNOW1;
         }
@@ -1764,14 +1717,6 @@ static void ata_scsi_qc_complete(struct ata_queued_cmd *qc)
                 }
         }
 
-        /* XXX: track spindown state for spindown skipping and warning */
-        if (unlikely(qc->tf.command == ATA_CMD_STANDBY ||
-                     qc->tf.command == ATA_CMD_STANDBYNOW1))
-                qc->dev->flags |= ATA_DFLAG_SPUNDOWN;
-        else if (likely(system_state != SYSTEM_HALT &&
-                        system_state != SYSTEM_POWER_OFF))
-                qc->dev->flags &= ~ATA_DFLAG_SPUNDOWN;
-
         if (need_sense && !ap->ops->error_handler)
                 ata_dump_status(ap->print_id, &qc->result_tf);
 
@@ -2815,28 +2760,6 @@ static unsigned int ata_scsi_pass_thru(struct ata_queued_cmd *qc)
                 goto invalid_fld;
 
         /*
-         * Filter TPM commands by default. These provide an
-         * essentially uncontrolled encrypted "back door" between
-         * applications and the disk. Set libata.allow_tpm=1 if you
-         * have a real reason for wanting to use them. This ensures
-         * that installed software cannot easily mess stuff up without
-         * user intent. DVR type users will probably ship with this enabled
-         * for movie content management.
-         *
-         * Note that for ATA8 we can issue a DCS change and DCS freeze lock
-         * for this and should do in future but that it is not sufficient as
-         * DCS is an optional feature set. Thus we also do the software filter
-         * so that we comply with the TC consortium stated goal that the user
-         * can turn off TC features of their system.
-         */
-        if (tf->command >= 0x5C && tf->command <= 0x5F && !libata_allow_tpm)
-                goto invalid_fld;
-
-        /* We may not issue DMA commands if no DMA mode is set */
-        if (tf->protocol == ATA_PROT_DMA && dev->dma_mode == 0)
-                goto invalid_fld;
-
-        /*
          * 12 and 16 byte CDBs use different offsets to
          * provide the various register values.
          */
@@ -2885,6 +2808,41 @@ static unsigned int ata_scsi_pass_thru(struct ata_queued_cmd *qc)
         tf->device = dev->devno ?
                 tf->device | ATA_DEV1 : tf->device & ~ATA_DEV1;
 
+        /* READ/WRITE LONG use a non-standard sect_size */
+        qc->sect_size = ATA_SECT_SIZE;
+        switch (tf->command) {
+        case ATA_CMD_READ_LONG:
+        case ATA_CMD_READ_LONG_ONCE:
+        case ATA_CMD_WRITE_LONG:
+        case ATA_CMD_WRITE_LONG_ONCE:
+                if (tf->protocol != ATA_PROT_PIO || tf->nsect != 1)
+                        goto invalid_fld;
+                qc->sect_size = scsi_bufflen(scmd);
+        }
+
+        /*
+         * Set flags so that all registers will be written, pass on
+         * write indication (used for PIO/DMA setup), result TF is
+         * copied back and we don't whine too much about its failure.
+         */
+        tf->flags = ATA_TFLAG_ISADDR | ATA_TFLAG_DEVICE;
+        if (scmd->sc_data_direction == DMA_TO_DEVICE)
+                tf->flags |= ATA_TFLAG_WRITE;
+
+        qc->flags |= ATA_QCFLAG_RESULT_TF | ATA_QCFLAG_QUIET;
+
+        /*
+         * Set transfer length.
+         *
+         * TODO: find out if we need to do more here to
+         *       cover scatter/gather case.
+         */
+        ata_qc_set_pc_nbytes(qc);
+
+        /* We may not issue DMA commands if no DMA mode is set */
+        if (tf->protocol == ATA_PROT_DMA && dev->dma_mode == 0)
+                goto invalid_fld;
+
         /* sanity check for pio multi commands */
         if ((cdb[1] & 0xe0) && !is_multi_taskfile(tf))
                 goto invalid_fld;
@@ -2901,18 +2859,6 @@ static unsigned int ata_scsi_pass_thru(struct ata_queued_cmd *qc)
                                        multi_count);
         }
 
-        /* READ/WRITE LONG use a non-standard sect_size */
-        qc->sect_size = ATA_SECT_SIZE;
-        switch (tf->command) {
-        case ATA_CMD_READ_LONG:
-        case ATA_CMD_READ_LONG_ONCE:
-        case ATA_CMD_WRITE_LONG:
-        case ATA_CMD_WRITE_LONG_ONCE:
-                if (tf->protocol != ATA_PROT_PIO || tf->nsect != 1)
-                        goto invalid_fld;
-                qc->sect_size = scsi_bufflen(scmd);
-        }
-
         /*
          * Filter SET_FEATURES - XFER MODE command -- otherwise,
          * SET_FEATURES - XFER MODE must be preceded/succeeded
@@ -2920,30 +2866,27 @@ static unsigned int ata_scsi_pass_thru(struct ata_queued_cmd *qc)
          * controller (i.e. the reason for ->set_piomode(),
          * ->set_dmamode(), and ->post_set_mode() hooks).
          */
-        if ((tf->command == ATA_CMD_SET_FEATURES)
-         && (tf->feature == SETFEATURES_XFER))
+        if (tf->command == ATA_CMD_SET_FEATURES &&
+            tf->feature == SETFEATURES_XFER)
                 goto invalid_fld;
 
         /*
-         * Set flags so that all registers will be written,
-         * and pass on write indication (used for PIO/DMA
-         * setup.)
-         */
-        tf->flags |= (ATA_TFLAG_ISADDR | ATA_TFLAG_DEVICE);
-
-        if (scmd->sc_data_direction == DMA_TO_DEVICE)
-                tf->flags |= ATA_TFLAG_WRITE;
-
-        /*
-         * Set transfer length.
+         * Filter TPM commands by default. These provide an
+         * essentially uncontrolled encrypted "back door" between
+         * applications and the disk. Set libata.allow_tpm=1 if you
+         * have a real reason for wanting to use them. This ensures
+         * that installed software cannot easily mess stuff up without
+         * user intent. DVR type users will probably ship with this enabled
+         * for movie content management.
          *
-         * TODO: find out if we need to do more here to
-         *       cover scatter/gather case.
+         * Note that for ATA8 we can issue a DCS change and DCS freeze lock
+         * for this and should do in future but that it is not sufficient as
+         * DCS is an optional feature set. Thus we also do the software filter
+         * so that we comply with the TC consortium stated goal that the user
+         * can turn off TC features of their system.
          */
-        ata_qc_set_pc_nbytes(qc);
-
-        /* request result TF and be quiet about device error */
-        qc->flags |= ATA_QCFLAG_RESULT_TF | ATA_QCFLAG_QUIET;
+        if (tf->command >= 0x5C && tf->command <= 0x5F && !libata_allow_tpm)
+                goto invalid_fld;
 
         return 0;
 
diff --git a/drivers/ata/libata.h b/drivers/ata/libata.h
index 89a1e0018e71..be8e2628f82c 100644
--- a/drivers/ata/libata.h
+++ b/drivers/ata/libata.h
@@ -164,6 +164,7 @@ extern void ata_eh_about_to_do(struct ata_link *link, struct ata_device *dev,
 extern void ata_eh_done(struct ata_link *link, struct ata_device *dev,
                         unsigned int action);
 extern void ata_eh_autopsy(struct ata_port *ap);
+const char *ata_get_cmd_descript(u8 command);
 extern void ata_eh_report(struct ata_port *ap);
 extern int ata_eh_reset(struct ata_link *link, int classify,
                         ata_prereset_fn_t prereset, ata_reset_fn_t softreset,
diff --git a/drivers/ata/pata_atiixp.c b/drivers/ata/pata_atiixp.c
index 45915566e4e9..aa4b3f6ae771 100644
--- a/drivers/ata/pata_atiixp.c
+++ b/drivers/ata/pata_atiixp.c
@@ -246,6 +246,7 @@ static const struct pci_device_id atiixp[] = {
         { PCI_VDEVICE(ATI, PCI_DEVICE_ID_ATI_IXP400_IDE), },
         { PCI_VDEVICE(ATI, PCI_DEVICE_ID_ATI_IXP600_IDE), },
         { PCI_VDEVICE(ATI, PCI_DEVICE_ID_ATI_IXP700_IDE), },
+        { PCI_VDEVICE(AMD, PCI_DEVICE_ID_AMD_SB900_IDE), },
 
         { },
 };
diff --git a/drivers/ata/pata_cs5535.c b/drivers/ata/pata_cs5535.c
index d33aa28239a9..403f56165cec 100644
--- a/drivers/ata/pata_cs5535.c
+++ b/drivers/ata/pata_cs5535.c
@@ -202,7 +202,8 @@ static int cs5535_init_one(struct pci_dev *dev, const struct pci_device_id *id)
 }
 
 static const struct pci_device_id cs5535[] = {
-        { PCI_VDEVICE(NS, 0x002D), },
+        { PCI_VDEVICE(NS, PCI_DEVICE_ID_NS_CS5535_IDE), },
+        { PCI_VDEVICE(AMD, PCI_DEVICE_ID_AMD_CS5535_IDE), },
 
         { },
 };
diff --git a/drivers/ata/pata_octeon_cf.c b/drivers/ata/pata_octeon_cf.c
index abdd19fe990a..d6f69561dc86 100644
--- a/drivers/ata/pata_octeon_cf.c
+++ b/drivers/ata/pata_octeon_cf.c
@@ -213,7 +213,7 @@ static void octeon_cf_set_dmamode(struct ata_port *ap, struct ata_device *dev)
          * This is tI, C.F. spec. says 0, but Sony CF card requires
          * more, we use 20 nS.
          */
-        dma_tim.s.dmack_s = ns_to_tim_reg(tim_mult, 20);;
+        dma_tim.s.dmack_s = ns_to_tim_reg(tim_mult, 20);
         dma_tim.s.dmack_h = ns_to_tim_reg(tim_mult, dma_ackh);
 
         dma_tim.s.dmarq = dma_arq;
@@ -841,7 +841,7 @@ static int __devinit octeon_cf_probe(struct platform_device *pdev)
         ocd = pdev->dev.platform_data;
 
         cs0 = devm_ioremap_nocache(&pdev->dev, res_cs0->start,
-                                   res_cs0->end - res_cs0->start + 1);
+                                   resource_size(res_cs0));
 
         if (!cs0)
                 return -ENOMEM;
diff --git a/drivers/ata/pata_platform.c b/drivers/ata/pata_platform.c
index d8d743af3225..3f6ebc6c665a 100644
--- a/drivers/ata/pata_platform.c
+++ b/drivers/ata/pata_platform.c
@@ -151,14 +151,14 @@ int __devinit __pata_platform_probe(struct device *dev,
          */
         if (mmio) {
                 ap->ioaddr.cmd_addr = devm_ioremap(dev, io_res->start,
-                                io_res->end - io_res->start + 1);
+                                resource_size(io_res));
                 ap->ioaddr.ctl_addr = devm_ioremap(dev, ctl_res->start,
-                                ctl_res->end - ctl_res->start + 1);
+                                resource_size(ctl_res));
         } else {
                 ap->ioaddr.cmd_addr = devm_ioport_map(dev, io_res->start,
-                                io_res->end - io_res->start + 1);
+                                resource_size(io_res));
                 ap->ioaddr.ctl_addr = devm_ioport_map(dev, ctl_res->start,
-                                ctl_res->end - ctl_res->start + 1);
+                                resource_size(ctl_res));
         }
         if (!ap->ioaddr.cmd_addr || !ap->ioaddr.ctl_addr) {
                 dev_err(dev, "failed to map IO/CTL base\n");
diff --git a/drivers/ata/pata_rb532_cf.c b/drivers/ata/pata_rb532_cf.c
index 8e3cdef8a25f..45f1e10f917b 100644
--- a/drivers/ata/pata_rb532_cf.c
+++ b/drivers/ata/pata_rb532_cf.c
@@ -151,7 +151,7 @@ static __devinit int rb532_pata_driver_probe(struct platform_device *pdev)
         info->irq = irq;
 
         info->iobase = devm_ioremap_nocache(&pdev->dev, res->start,
-                                res->end - res->start + 1);
+                                resource_size(res));
         if (!info->iobase)
                 return -ENOMEM;
 
diff --git a/drivers/ata/pata_rdc.c b/drivers/ata/pata_rdc.c
new file mode 100644
index 000000000000..c843a1e07c4f
--- /dev/null
+++ b/drivers/ata/pata_rdc.c
@@ -0,0 +1,400 @@
+/*
+ *  pata_rdc            -       Driver for later RDC PATA controllers
+ *
+ *  This is actually a driver for hardware meeting
+ *  INCITS 370-2004 (1510D): ATA Host Adapter Standards
+ *
+ *  Based on ata_piix.
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2, or (at your option)
+ *  any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; see the file COPYING.  If not, write to
+ *  the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/pci.h>
+#include <linux/init.h>
+#include <linux/blkdev.h>
+#include <linux/delay.h>
+#include <linux/device.h>
+#include <scsi/scsi_host.h>
+#include <linux/libata.h>
+#include <linux/dmi.h>
+
+#define DRV_NAME        "pata_rdc"
+#define DRV_VERSION     "0.01"
+
+struct rdc_host_priv {
+        u32 saved_iocfg;
+};
+
+/**
+ *      rdc_pata_cable_detect - Probe host controller cable detect info
+ *      @ap: Port for which cable detect info is desired
+ *
+ *      Read 80c cable indicator from ATA PCI device's PCI config
+ *      register.  This register is normally set by firmware (BIOS).
+ *
+ *      LOCKING:
+ *      None (inherited from caller).
+ */
+
+static int rdc_pata_cable_detect(struct ata_port *ap)
+{
+        struct rdc_host_priv *hpriv = ap->host->private_data;
+        u8 mask;
+
+        /* check BIOS cable detect results */
+        mask = 0x30 << (2 * ap->port_no);
+        if ((hpriv->saved_iocfg & mask) == 0)
+                return ATA_CBL_PATA40;
+        return ATA_CBL_PATA80;
+}
+
+/**
+ *      rdc_pata_prereset - prereset for PATA host controller
+ *      @link: Target link
+ *      @deadline: deadline jiffies for the operation
+ *
+ *      LOCKING:
+ *      None (inherited from caller).
+ */
+static int rdc_pata_prereset(struct ata_link *link, unsigned long deadline)
+{
+        struct ata_port *ap = link->ap;
+        struct pci_dev *pdev = to_pci_dev(ap->host->dev);
+
+        static const struct pci_bits rdc_enable_bits[] = {
+                { 0x41U, 1U, 0x80UL, 0x80UL },  /* port 0 */
+                { 0x43U, 1U, 0x80UL, 0x80UL },  /* port 1 */
+        };
+
+        if (!pci_test_config_bits(pdev, &rdc_enable_bits[ap->port_no]))
+                return -ENOENT;
+        return ata_sff_prereset(link, deadline);
+}
+
+/**
+ *      rdc_set_piomode - Initialize host controller PATA PIO timings
+ *      @ap: Port whose timings we are configuring
+ *      @adev: um
+ *
+ *      Set PIO mode for device, in host controller PCI config space.
+ *
+ *      LOCKING:
+ *      None (inherited from caller).
+ */
+
+static void rdc_set_piomode(struct ata_port *ap, struct ata_device *adev)
+{
+        unsigned int pio        = adev->pio_mode - XFER_PIO_0;
+        struct pci_dev *dev     = to_pci_dev(ap->host->dev);
+        unsigned int is_slave   = (adev->devno != 0);
+        unsigned int master_port= ap->port_no ? 0x42 : 0x40;
+        unsigned int slave_port = 0x44;
+        u16 master_data;
+        u8 slave_data;
+        u8 udma_enable;
+        int control = 0;
+
+        static const     /* ISP  RTC */
+        u8 timings[][2] = { { 0, 0 },
+                            { 0, 0 },
+                            { 1, 0 },
+                            { 2, 1 },
+                            { 2, 3 }, };
+
+        if (pio >= 2)
+                control |= 1;   /* TIME1 enable */
+        if (ata_pio_need_iordy(adev))
+                control |= 2;   /* IE enable */
+
+        if (adev->class == ATA_DEV_ATA)
+                control |= 4;   /* PPE enable */
+
+        /* PIO configuration clears DTE unconditionally.  It will be
+         * programmed in set_dmamode which is guaranteed to be called
+         * after set_piomode if any DMA mode is available.
+         */
+        pci_read_config_word(dev, master_port, &master_data);
+        if (is_slave) {
+                /* clear TIME1|IE1|PPE1|DTE1 */
+                master_data &= 0xff0f;
+                /* Enable SITRE (separate slave timing register) */
+                master_data |= 0x4000;
+                /* enable PPE1, IE1 and TIME1 as needed */
+                master_data |= (control << 4);
+                pci_read_config_byte(dev, slave_port, &slave_data);
+                slave_data &= (ap->port_no ? 0x0f : 0xf0);
+                /* Load the timing nibble for this slave */
+                slave_data |= ((timings[pio][0] << 2) | timings[pio][1])
+                                                << (ap->port_no ? 4 : 0);
+        } else {
+                /* clear ISP|RCT|TIME0|IE0|PPE0|DTE0 */
+                master_data &= 0xccf0;
+                /* Enable PPE, IE and TIME as appropriate */
+                master_data |= control;
+                /* load ISP and RCT */
+                master_data |=
+                        (timings[pio][0] << 12) |
+                        (timings[pio][1] << 8);
+        }
+        pci_write_config_word(dev, master_port, master_data);
+        if (is_slave)
+                pci_write_config_byte(dev, slave_port, slave_data);
+
+        /* Ensure the UDMA bit is off - it will be turned back on if
+           UDMA is selected */
+
+        pci_read_config_byte(dev, 0x48, &udma_enable);
+        udma_enable &= ~(1 << (2 * ap->port_no + adev->devno));
+        pci_write_config_byte(dev, 0x48, udma_enable);
+}
+
+/**
+ *      rdc_set_dmamode - Initialize host controller PATA PIO timings
+ *      @ap: Port whose timings we are configuring
+ *      @adev: Drive in question
+ *
+ *      Set UDMA mode for device, in host controller PCI config space.
+ *
+ *      LOCKING:
+ *      None (inherited from caller).
+ */
+
+static void rdc_set_dmamode(struct ata_port *ap, struct ata_device *adev)
+{
+        struct pci_dev *dev     = to_pci_dev(ap->host->dev);
+        u8 master_port          = ap->port_no ? 0x42 : 0x40;
+        u16 master_data;
+        u8 speed                = adev->dma_mode;
+        int devid               = adev->devno + 2 * ap->port_no;
+        u8 udma_enable          = 0;
+
+        static const     /* ISP  RTC */
+        u8 timings[][2] = { { 0, 0 },
+                            { 0, 0 },
+                            { 1, 0 },
+                            { 2, 1 },
+                            { 2, 3 }, };
+
+        pci_read_config_word(dev, master_port, &master_data);
+        pci_read_config_byte(dev, 0x48, &udma_enable);
+
+        if (speed >= XFER_UDMA_0) {
+                unsigned int udma = adev->dma_mode - XFER_UDMA_0;
+                u16 udma_timing;
+                u16 ideconf;
+                int u_clock, u_speed;
+
+                /*
+                 * UDMA is handled by a combination of clock switching and
+                 * selection of dividers
+                 *
+                 * Handy rule: Odd modes are UDMATIMx 01, even are 02
+                 *             except UDMA0 which is 00
+                 */
+                u_speed = min(2 - (udma & 1), udma);
+                if (udma == 5)
+                        u_clock = 0x1000;       /* 100Mhz */
+                else if (udma > 2)
+                        u_clock = 1;            /* 66Mhz */
+                else
+                        u_clock = 0;            /* 33Mhz */
+
+                udma_enable |= (1 << devid);
+
+                /* Load the CT/RP selection */
+                pci_read_config_word(dev, 0x4A, &udma_timing);
+                udma_timing &= ~(3 << (4 * devid));
+                udma_timing |= u_speed << (4 * devid);
+                pci_write_config_word(dev, 0x4A, udma_timing);
+
+                /* Select a 33/66/100Mhz clock */
+                pci_read_config_word(dev, 0x54, &ideconf);
+                ideconf &= ~(0x1001 << devid);
+                ideconf |= u_clock << devid;
+                pci_write_config_word(dev, 0x54, ideconf);
+        } else {
+                /*
+                 * MWDMA is driven by the PIO timings. We must also enable
+                 * IORDY unconditionally along with TIME1. PPE has already
+                 * been set when the PIO timing was set.
+                 */
+                unsigned int mwdma      = adev->dma_mode - XFER_MW_DMA_0;
+                unsigned int control;
+                u8 slave_data;
+                const unsigned int needed_pio[3] = {
+                        XFER_PIO_0, XFER_PIO_3, XFER_PIO_4
+                };
+                int pio = needed_pio[mwdma] - XFER_PIO_0;
+
+                control = 3;    /* IORDY|TIME1 */
+
+                /* If the drive MWDMA is faster than it can do PIO then
+                   we must force PIO into PIO0 */
+
+                if (adev->pio_mode < needed_pio[mwdma])
+                        /* Enable DMA timing only */
+                        control |= 8;   /* PIO cycles in PIO0 */
+
+                if (adev->devno) {      /* Slave */
+                        master_data &= 0xFF4F;  /* Mask out IORDY|TIME1|DMAONLY */
+                        master_data |= control << 4;
+                        pci_read_config_byte(dev, 0x44, &slave_data);
+                        slave_data &= (ap->port_no ? 0x0f : 0xf0);
+                        /* Load the matching timing */
+                        slave_data |= ((timings[pio][0] << 2) | timings[pio][1]) << (ap->port_no ? 4 : 0);
+                        pci_write_config_byte(dev, 0x44, slave_data);
+                } else {        /* Master */
+                        master_data &= 0xCCF4;  /* Mask out IORDY|TIME1|DMAONLY
+                                                   and master timing bits */
+                        master_data |= control;
+                        master_data |=
+                                (timings[pio][0] << 12) |
+                                (timings[pio][1] << 8);
+                }
+
+                udma_enable &= ~(1 << devid);
+                pci_write_config_word(dev, master_port, master_data);
+        }
+        pci_write_config_byte(dev, 0x48, udma_enable);
+}
+
+static struct ata_port_operations rdc_pata_ops = {
+        .inherits               = &ata_bmdma32_port_ops,
+        .cable_detect           = rdc_pata_cable_detect,
+        .set_piomode            = rdc_set_piomode,
+        .set_dmamode            = rdc_set_dmamode,
+        .prereset               = rdc_pata_prereset,
+};
+
+static struct ata_port_info rdc_port_info = {
+
+        .flags          = ATA_FLAG_SLAVE_POSS,
+        .pio_mask       = ATA_PIO4,
+        .mwdma_mask     = ATA_MWDMA2,
+        .udma_mask      = ATA_UDMA5,
+        .port_ops       = &rdc_pata_ops,
+};
+
+static struct scsi_host_template rdc_sht = {
+        ATA_BMDMA_SHT(DRV_NAME),
+};
+
+/**
+ *      rdc_init_one - Register PIIX ATA PCI device with kernel services
+ *      @pdev: PCI device to register
+ *      @ent: Entry in rdc_pci_tbl matching with @pdev
+ *
+ *      Called from kernel PCI layer.  We probe for combined mode (sigh),
+ *      and then hand over control to libata, for it to do the rest.
+ *
+ *      LOCKING:
+ *      Inherited from PCI layer (may sleep).
+ *
+ *      RETURNS:
+ *      Zero on success, or -ERRNO value.
+ */
+
+static int __devinit rdc_init_one(struct pci_dev *pdev,
+                                   const struct pci_device_id *ent)
+{
+        static int printed_version;
+        struct device *dev = &pdev->dev;
+        struct ata_port_info port_info[2];
+        const struct ata_port_info *ppi[] = { &port_info[0], &port_info[1] };
+        unsigned long port_flags;
+        struct ata_host *host;
+        struct rdc_host_priv *hpriv;
+        int rc;
+
+        if (!printed_version++)
+                dev_printk(KERN_DEBUG, &pdev->dev,
+                           "version " DRV_VERSION "\n");
+
+        port_info[0] = rdc_port_info;
+        port_info[1] = rdc_port_info;
+
+        port_flags = port_info[0].flags;
+
+        /* enable device and prepare host */
+        rc = pcim_enable_device(pdev);
+        if (rc)
+                return rc;
+
+        hpriv = devm_kzalloc(dev, sizeof(*hpriv), GFP_KERNEL);
+        if (!hpriv)
+                return -ENOMEM;
+
+        /* Save IOCFG, this will be used for cable detection, quirk
+         * detection and restoration on detach.
+         */
+        pci_read_config_dword(pdev, 0x54, &hpriv->saved_iocfg);
+
+        rc = ata_pci_sff_prepare_host(pdev, ppi, &host);
+        if (rc)
+                return rc;
+        host->private_data = hpriv;
+
+        pci_intx(pdev, 1);
+
+        host->flags |= ATA_HOST_PARALLEL_SCAN;
+
+        pci_set_master(pdev);
+        return ata_pci_sff_activate_host(host, ata_sff_interrupt, &rdc_sht);
+}
+
+static void rdc_remove_one(struct pci_dev *pdev)
+{
+        struct ata_host *host = dev_get_drvdata(&pdev->dev);
+        struct rdc_host_priv *hpriv = host->private_data;
+
+        pci_write_config_dword(pdev, 0x54, hpriv->saved_iocfg);
+
+        ata_pci_remove_one(pdev);
+}
+
+static const struct pci_device_id rdc_pci_tbl[] = {
+        { PCI_DEVICE(0x17F3, 0x1011), },
+        { PCI_DEVICE(0x17F3, 0x1012), },
+        { }     /* terminate list */
+};
+
+static struct pci_driver rdc_pci_driver = {
+        .name                   = DRV_NAME,
+        .id_table               = rdc_pci_tbl,
+        .probe                  = rdc_init_one,
+        .remove                 = rdc_remove_one,
+};
+
+
+static int __init rdc_init(void)
+{
+        return pci_register_driver(&rdc_pci_driver);
+}
+
+static void __exit rdc_exit(void)
+{
+        pci_unregister_driver(&rdc_pci_driver);
+}
+
+module_init(rdc_init);
+module_exit(rdc_exit);
+
+MODULE_AUTHOR("Alan Cox (based on ata_piix)");
+MODULE_DESCRIPTION("SCSI low-level driver for RDC PATA controllers");
+MODULE_LICENSE("GPL");
+MODULE_DEVICE_TABLE(pci, rdc_pci_tbl);
+MODULE_VERSION(DRV_VERSION);
diff --git a/drivers/ata/pata_rz1000.c b/drivers/ata/pata_rz1000.c
index 0c574c065c62..a5e4dfe60b41 100644
--- a/drivers/ata/pata_rz1000.c
+++ b/drivers/ata/pata_rz1000.c
@@ -85,7 +85,6 @@ static int rz1000_fifo_disable(struct pci_dev *pdev)
 
 static int rz1000_init_one (struct pci_dev *pdev, const struct pci_device_id *ent)
 {
-        static int printed_version;
         static const struct ata_port_info info = {
                 .flags = ATA_FLAG_SLAVE_POSS,
                 .pio_mask = ATA_PIO4,
@@ -93,8 +92,7 @@ static int rz1000_init_one (struct pci_dev *pdev, const struct pci_device_id *en
         };
         const struct ata_port_info *ppi[] = { &info, NULL };
 
-        if (!printed_version++)
-                printk(KERN_DEBUG DRV_NAME " version " DRV_VERSION "\n");
+        printk_once(KERN_DEBUG DRV_NAME " version " DRV_VERSION "\n");
 
         if (rz1000_fifo_disable(pdev) == 0)
                 return ata_pci_sff_init_one(pdev, ppi, &rz1000_sht, NULL);
diff --git a/drivers/ata/sata_fsl.c b/drivers/ata/sata_fsl.c
index 94eaa432c40a..d344db42a002 100644
--- a/drivers/ata/sata_fsl.c
+++ b/drivers/ata/sata_fsl.c
@@ -1257,6 +1257,7 @@ static struct scsi_host_template sata_fsl_sht = {
 static struct ata_port_operations sata_fsl_ops = {
         .inherits               = &sata_pmp_port_ops,
 
+        .qc_defer = ata_std_qc_defer,
         .qc_prep = sata_fsl_qc_prep,
         .qc_issue = sata_fsl_qc_issue,
         .qc_fill_rtf = sata_fsl_qc_fill_rtf,
diff --git a/drivers/ata/sata_inic162x.c b/drivers/ata/sata_inic162x.c
index 8d890cc5a7ee..4406902b4293 100644
--- a/drivers/ata/sata_inic162x.c
+++ b/drivers/ata/sata_inic162x.c
@@ -405,7 +405,7 @@ static irqreturn_t inic_interrupt(int irq, void *dev_instance)
         struct ata_host *host = dev_instance;
         struct inic_host_priv *hpriv = host->private_data;
         u16 host_irq_stat;
-        int i, handled = 0;;
+        int i, handled = 0;
 
         host_irq_stat = readw(hpriv->mmio_base + HOST_IRQ_STAT);
 
diff --git a/drivers/ata/sata_mv.c b/drivers/ata/sata_mv.c
index c19417e02208..17f9ff9067a2 100644
--- a/drivers/ata/sata_mv.c
+++ b/drivers/ata/sata_mv.c
@@ -4013,7 +4013,7 @@ static int mv_platform_probe(struct platform_device *pdev)
 
         host->iomap = NULL;
         hpriv->base = devm_ioremap(&pdev->dev, res->start,
-                                   res->end - res->start + 1);
+                                   resource_size(res));
         hpriv->base -= SATAHC0_REG_BASE;
 
         /*
diff --git a/drivers/ata/sata_sil.c b/drivers/ata/sata_sil.c
index 35bd5cc7f285..3cb69d5fb817 100644
--- a/drivers/ata/sata_sil.c
+++ b/drivers/ata/sata_sil.c
@@ -565,6 +565,19 @@ static void sil_freeze(struct ata_port *ap)
         tmp |= SIL_MASK_IDE0_INT << ap->port_no;
         writel(tmp, mmio_base + SIL_SYSCFG);
         readl(mmio_base + SIL_SYSCFG);  /* flush */
+
+        /* Ensure DMA_ENABLE is off.
+         *
+         * This is because the controller will not give us access to the
+         * taskfile registers while a DMA is in progress
+         */
+        iowrite8(ioread8(ap->ioaddr.bmdma_addr) & ~SIL_DMA_ENABLE,
+                 ap->ioaddr.bmdma_addr);
+
+        /* According to ata_bmdma_stop, an HDMA transition requires
+         * on PIO cycle. But we can't read a taskfile register.
+         */
+        ioread8(ap->ioaddr.bmdma_addr);
 }
 
 static void sil_thaw(struct ata_port *ap)
diff --git a/drivers/ata/sata_sil24.c b/drivers/ata/sata_sil24.c
index 77aa8d7ecec4..e6946fc527d0 100644
--- a/drivers/ata/sata_sil24.c
+++ b/drivers/ata/sata_sil24.c
@@ -846,6 +846,17 @@ static void sil24_qc_prep(struct ata_queued_cmd *qc)
         if (!ata_is_atapi(qc->tf.protocol)) {
                 prb = &cb->ata.prb;
                 sge = cb->ata.sge;
+                if (ata_is_data(qc->tf.protocol)) {
+                        u16 prot = 0;
+                        ctrl = PRB_CTRL_PROTOCOL;
+                        if (ata_is_ncq(qc->tf.protocol))
+                                prot |= PRB_PROT_NCQ;
+                        if (qc->tf.flags & ATA_TFLAG_WRITE)
+                                prot |= PRB_PROT_WRITE;
+                        else
+                                prot |= PRB_PROT_READ;
+                        prb->prot = cpu_to_le16(prot);
+                }
         } else {
                 prb = &cb->atapi.prb;
                 sge = cb->atapi.sge;
diff --git a/drivers/ata/sata_sis.c b/drivers/ata/sata_sis.c
index 8f9833228619..f8a91bfd66a8 100644
--- a/drivers/ata/sata_sis.c
+++ b/drivers/ata/sata_sis.c
@@ -109,8 +109,9 @@ MODULE_LICENSE("GPL");
 MODULE_DEVICE_TABLE(pci, sis_pci_tbl);
 MODULE_VERSION(DRV_VERSION);
 
-static unsigned int get_scr_cfg_addr(struct ata_port *ap, unsigned int sc_reg)
+static unsigned int get_scr_cfg_addr(struct ata_link *link, unsigned int sc_reg)
 {
+        struct ata_port *ap = link->ap;
         struct pci_dev *pdev = to_pci_dev(ap->host->dev);
         unsigned int addr = SIS_SCR_BASE + (4 * sc_reg);
         u8 pmr;
@@ -131,6 +132,9 @@ static unsigned int get_scr_cfg_addr(struct ata_port *ap, unsigned int sc_reg)
                         break;
                 }
         }
+        if (link->pmp)
+                addr += 0x10;
+
         return addr;
 }
 
@@ -138,24 +142,12 @@ static u32 sis_scr_cfg_read(struct ata_link *link,
                             unsigned int sc_reg, u32 *val)
 {
         struct pci_dev *pdev = to_pci_dev(link->ap->host->dev);
-        unsigned int cfg_addr = get_scr_cfg_addr(link->ap, sc_reg);
-        u32 val2 = 0;
-        u8 pmr;
+        unsigned int cfg_addr = get_scr_cfg_addr(link, sc_reg);
 
         if (sc_reg == SCR_ERROR) /* doesn't exist in PCI cfg space */
                 return -EINVAL;
 
-        pci_read_config_byte(pdev, SIS_PMR, &pmr);
-
         pci_read_config_dword(pdev, cfg_addr, val);
-
-        if ((pdev->device == 0x0182) || (pdev->device == 0x0183) ||
-            (pdev->device == 0x1182) || (pmr & SIS_PMR_COMBINED))
-                pci_read_config_dword(pdev, cfg_addr+0x10, &val2);
-
-        *val |= val2;
-        *val &= 0xfffffffb;     /* avoid problems with powerdowned ports */
-
         return 0;
 }
 
@@ -163,28 +155,16 @@ static int sis_scr_cfg_write(struct ata_link *link,
                              unsigned int sc_reg, u32 val)
 {
         struct pci_dev *pdev = to_pci_dev(link->ap->host->dev);
-        unsigned int cfg_addr = get_scr_cfg_addr(link->ap, sc_reg);
-        u8 pmr;
-
-        if (sc_reg == SCR_ERROR) /* doesn't exist in PCI cfg space */
-                return -EINVAL;
-
-        pci_read_config_byte(pdev, SIS_PMR, &pmr);
+        unsigned int cfg_addr = get_scr_cfg_addr(link, sc_reg);
 
         pci_write_config_dword(pdev, cfg_addr, val);
-
-        if ((pdev->device == 0x0182) || (pdev->device == 0x0183) ||
-            (pdev->device == 0x1182) || (pmr & SIS_PMR_COMBINED))
-                pci_write_config_dword(pdev, cfg_addr+0x10, val);
-
         return 0;
 }
 
 static int sis_scr_read(struct ata_link *link, unsigned int sc_reg, u32 *val)
 {
         struct ata_port *ap = link->ap;
-        struct pci_dev *pdev = to_pci_dev(ap->host->dev);
-        u8 pmr;
+        void __iomem *base = ap->ioaddr.scr_addr + link->pmp * 0x10;
 
         if (sc_reg > SCR_CONTROL)
                 return -EINVAL;
@@ -192,39 +172,23 @@ static int sis_scr_read(struct ata_link *link, unsigned int sc_reg, u32 *val)
         if (ap->flags & SIS_FLAG_CFGSCR)
                 return sis_scr_cfg_read(link, sc_reg, val);
 
-        pci_read_config_byte(pdev, SIS_PMR, &pmr);
-
-        *val = ioread32(ap->ioaddr.scr_addr + (sc_reg * 4));
-
-        if ((pdev->device == 0x0182) || (pdev->device == 0x0183) ||
-            (pdev->device == 0x1182) || (pmr & SIS_PMR_COMBINED))
-                *val |= ioread32(ap->ioaddr.scr_addr + (sc_reg * 4) + 0x10);
-
-        *val &= 0xfffffffb;
-
+        *val = ioread32(base + sc_reg * 4);
         return 0;
 }
 
 static int sis_scr_write(struct ata_link *link, unsigned int sc_reg, u32 val)
 {
         struct ata_port *ap = link->ap;
-        struct pci_dev *pdev = to_pci_dev(ap->host->dev);
-        u8 pmr;
+        void __iomem *base = ap->ioaddr.scr_addr + link->pmp * 0x10;
 
         if (sc_reg > SCR_CONTROL)
                 return -EINVAL;
 
-        pci_read_config_byte(pdev, SIS_PMR, &pmr);
-
         if (ap->flags & SIS_FLAG_CFGSCR)
                 return sis_scr_cfg_write(link, sc_reg, val);
-        else {
-                iowrite32(val, ap->ioaddr.scr_addr + (sc_reg * 4));
-                if ((pdev->device == 0x0182) || (pdev->device == 0x0183) ||
-                    (pdev->device == 0x1182) || (pmr & SIS_PMR_COMBINED))
-                        iowrite32(val, ap->ioaddr.scr_addr + (sc_reg * 4)+0x10);
-                return 0;
-        }
+
+        iowrite32(val, base + (sc_reg * 4));
+        return 0;
 }
 
 static int sis_init_one(struct pci_dev *pdev, const struct pci_device_id *ent)
@@ -236,7 +200,7 @@ static int sis_init_one(struct pci_dev *pdev, const struct pci_device_id *ent)
         u32 genctl, val;
         u8 pmr;
         u8 port2_start = 0x20;
-        int rc;
+        int i, rc;
 
         if (!printed_version++)
                 dev_printk(KERN_INFO, &pdev->dev, "version " DRV_VERSION "\n");
@@ -319,6 +283,17 @@ static int sis_init_one(struct pci_dev *pdev, const struct pci_device_id *ent)
         if (rc)
                 return rc;
 
+        for (i = 0; i < 2; i++) {
+                struct ata_port *ap = host->ports[i];
+
+                if (ap->flags & ATA_FLAG_SATA &&
+                    ap->flags & ATA_FLAG_SLAVE_POSS) {
+                        rc = ata_slave_link_init(ap);
+                        if (rc)
+                                return rc;
+                }
+        }
+
         if (!(pi.flags & SIS_FLAG_CFGSCR)) {
                 void __iomem *mmio;
 
diff --git a/drivers/char/sysrq.c b/drivers/char/sysrq.c
index 5d7a02f63e1c..50eecfe1d724 100644
--- a/drivers/char/sysrq.c
+++ b/drivers/char/sysrq.c
@@ -24,6 +24,7 @@
 #include <linux/sysrq.h>
 #include <linux/kbd_kern.h>
 #include <linux/proc_fs.h>
+#include <linux/nmi.h>
 #include <linux/quotaops.h>
 #include <linux/perf_counter.h>
 #include <linux/kernel.h>
@@ -222,12 +223,20 @@ static DECLARE_WORK(sysrq_showallcpus, sysrq_showregs_othercpus);
 
 static void sysrq_handle_showallcpus(int key, struct tty_struct *tty)
 {
-        struct pt_regs *regs = get_irq_regs();
-        if (regs) {
-                printk(KERN_INFO "CPU%d:\n", smp_processor_id());
-                show_regs(regs);
+        /*
+         * Fall back to the workqueue based printing if the
+         * backtrace printing did not succeed or the
+         * architecture has no support for it:
+         */
+        if (!trigger_all_cpu_backtrace()) {
+                struct pt_regs *regs = get_irq_regs();
+
+                if (regs) {
+                        printk(KERN_INFO "CPU%d:\n", smp_processor_id());
+                        show_regs(regs);
+                }
+                schedule_work(&sysrq_showallcpus);
         }
-        schedule_work(&sysrq_showallcpus);
 }
 
 static struct sysrq_key_op sysrq_showallcpus_op = {
diff --git a/drivers/firmware/dmi_scan.c b/drivers/firmware/dmi_scan.c
index 24c84ae81527..938100f14b16 100644
--- a/drivers/firmware/dmi_scan.c
+++ b/drivers/firmware/dmi_scan.c
@@ -568,35 +568,76 @@ const struct dmi_device * dmi_find_device(int type, const char *name,
 EXPORT_SYMBOL(dmi_find_device);
 
 /**
- *      dmi_get_year - Return year of a DMI date
- *      @field: data index (like dmi_get_system_info)
+ *      dmi_get_date - parse a DMI date
+ *      @field: data index (see enum dmi_field)
+ *      @yearp: optional out parameter for the year
+ *      @monthp: optional out parameter for the month
+ *      @dayp: optional out parameter for the day
  *
- *      Returns -1 when the field doesn't exist. 0 when it is broken.
+ *      The date field is assumed to be in the form resembling
+ *      [mm[/dd]]/yy[yy] and the result is stored in the out
+ *      parameters any or all of which can be omitted.
+ *
+ *      If the field doesn't exist, all out parameters are set to zero
+ *      and false is returned.  Otherwise, true is returned with any
+ *      invalid part of date set to zero.
+ *
+ *      On return, year, month and day are guaranteed to be in the
+ *      range of [0,9999], [0,12] and [0,31] respectively.
  */
-int dmi_get_year(int field)
+bool dmi_get_date(int field, int *yearp, int *monthp, int *dayp)
 {
-        int year;
-        const char *s = dmi_get_system_info(field);
+        int year = 0, month = 0, day = 0;
+        bool exists;
+        const char *s, *y;
+        char *e;
 
-        if (!s)
-                return -1;
-        if (*s == '\0')
-                return 0;
-        s = strrchr(s, '/');
-        if (!s)
-                return 0;
+        s = dmi_get_system_info(field);
+        exists = s;
+        if (!exists)
+                goto out;
 
-        s += 1;
-        year = simple_strtoul(s, NULL, 0);
-        if (year && year < 100) {       /* 2-digit year */
+        /*
+         * Determine year first.  We assume the date string resembles
+         * mm/dd/yy[yy] but the original code extracted only the year
+         * from the end.  Keep the behavior in the spirit of no
+         * surprises.
+         */
+        y = strrchr(s, '/');
+        if (!y)
+                goto out;
+
+        y++;
+        year = simple_strtoul(y, &e, 10);
+        if (y != e && year < 100) {     /* 2-digit year */
                 year += 1900;
                 if (year < 1996)        /* no dates < spec 1.0 */
                         year += 100;
         }
+        if (year > 9999)                /* year should fit in %04d */
+                year = 0;
+
+        /* parse the mm and dd */
+        month = simple_strtoul(s, &e, 10);
+        if (s == e || *e != '/' || !month || month > 12) {
+                month = 0;
+                goto out;
+        }
 
-        return year;
+        s = e + 1;
+        day = simple_strtoul(s, &e, 10);
+        if (s == y || s == e || *e != '/' || day > 31)
+                day = 0;
+out:
+        if (yearp)
+                *yearp = year;
+        if (monthp)
+                *monthp = month;
+        if (dayp)
+                *dayp = day;
+        return exists;
 }
-EXPORT_SYMBOL(dmi_get_year);
+EXPORT_SYMBOL(dmi_get_date);
 
 /**
  *      dmi_walk - Walk the DMI table and get called back for every record
diff --git a/drivers/ide/atiixp.c b/drivers/ide/atiixp.c
index 923cbfe259d3..6396c3ad3252 100644
--- a/drivers/ide/atiixp.c
+++ b/drivers/ide/atiixp.c
@@ -177,6 +177,7 @@ static const struct pci_device_id atiixp_pci_tbl[] = {
         { PCI_VDEVICE(ATI, PCI_DEVICE_ID_ATI_IXP400_IDE), 0 },
         { PCI_VDEVICE(ATI, PCI_DEVICE_ID_ATI_IXP600_IDE), 1 },
         { PCI_VDEVICE(ATI, PCI_DEVICE_ID_ATI_IXP700_IDE), 0 },
+        { PCI_VDEVICE(AMD, PCI_DEVICE_ID_AMD_SB900_IDE), 0 },
         { 0, },
 };
 MODULE_DEVICE_TABLE(pci, atiixp_pci_tbl);
diff --git a/drivers/oprofile/cpu_buffer.c b/drivers/oprofile/cpu_buffer.c
index 242257b19441..a7aae24f2889 100644
--- a/drivers/oprofile/cpu_buffer.c
+++ b/drivers/oprofile/cpu_buffer.c
@@ -21,7 +21,6 @@
 
 #include <linux/sched.h>
 #include <linux/oprofile.h>
-#include <linux/vmalloc.h>
 #include <linux/errno.h>
 
 #include "event_buffer.h"
@@ -407,6 +406,21 @@ int oprofile_add_data(struct op_entry *entry, unsigned long val)
         return op_cpu_buffer_add_data(entry, val);
 }
 
+int oprofile_add_data64(struct op_entry *entry, u64 val)
+{
+        if (!entry->event)
+                return 0;
+        if (op_cpu_buffer_get_size(entry) < 2)
+                /*
+                 * the function returns 0 to indicate a too small
+                 * buffer, even if there is some space left
+                 */
+                return 0;
+        if (!op_cpu_buffer_add_data(entry, (u32)val))
+                return 0;
+        return op_cpu_buffer_add_data(entry, (u32)(val >> 32));
+}
+
 int oprofile_write_commit(struct op_entry *entry)
 {
         if (!entry->event)
diff --git a/drivers/oprofile/oprof.c b/drivers/oprofile/oprof.c
index 3cffce90f82a..dc8a0428260d 100644
--- a/drivers/oprofile/oprof.c
+++ b/drivers/oprofile/oprof.c
@@ -12,6 +12,8 @@
 #include <linux/init.h>
 #include <linux/oprofile.h>
 #include <linux/moduleparam.h>
+#include <linux/workqueue.h>
+#include <linux/time.h>
 #include <asm/mutex.h>
 
 #include "oprof.h"
@@ -87,6 +89,69 @@ out:
         return err;
 }
 
+#ifdef CONFIG_OPROFILE_EVENT_MULTIPLEX
+
+static void switch_worker(struct work_struct *work);
+static DECLARE_DELAYED_WORK(switch_work, switch_worker);
+
+static void start_switch_worker(void)
+{
+        if (oprofile_ops.switch_events)
+                schedule_delayed_work(&switch_work, oprofile_time_slice);
+}
+
+static void stop_switch_worker(void)
+{
+        cancel_delayed_work_sync(&switch_work);
+}
+
+static void switch_worker(struct work_struct *work)
+{
+        if (oprofile_ops.switch_events())
+                return;
+
+        atomic_inc(&oprofile_stats.multiplex_counter);
+        start_switch_worker();
+}
+
+/* User inputs in ms, converts to jiffies */
+int oprofile_set_timeout(unsigned long val_msec)
+{
+        int err = 0;
+        unsigned long time_slice;
+
+        mutex_lock(&start_mutex);
+
+        if (oprofile_started) {
+                err = -EBUSY;
+                goto out;
+        }
+
+        if (!oprofile_ops.switch_events) {
+                err = -EINVAL;
+                goto out;
+        }
+
+        time_slice = msecs_to_jiffies(val_msec);
+        if (time_slice == MAX_JIFFY_OFFSET) {
+                err = -EINVAL;
+                goto out;
+        }
+
+        oprofile_time_slice = time_slice;
+
+out:
+        mutex_unlock(&start_mutex);
+        return err;
+
+}
+
+#else
+
+static inline void start_switch_worker(void) { }
+static inline void stop_switch_worker(void) { }
+
+#endif
 
 /* Actually start profiling (echo 1>/dev/oprofile/enable) */
 int oprofile_start(void)
@@ -108,6 +173,8 @@ int oprofile_start(void)
         if ((err = oprofile_ops.start()))
                 goto out;
 
+        start_switch_worker();
+
         oprofile_started = 1;
 out:
         mutex_unlock(&start_mutex);
@@ -123,6 +190,9 @@ void oprofile_stop(void)
                 goto out;
         oprofile_ops.stop();
         oprofile_started = 0;
+
+        stop_switch_worker();
+
         /* wake up the daemon to read what remains */
         wake_up_buffer_waiter();
 out:
@@ -155,7 +225,6 @@ post_sync:
         mutex_unlock(&start_mutex);
 }
 
-
 int oprofile_set_backtrace(unsigned long val)
 {
         int err = 0;
diff --git a/drivers/oprofile/oprof.h b/drivers/oprofile/oprof.h
index c288d3c24b50..cb92f5c98c1a 100644
--- a/drivers/oprofile/oprof.h
+++ b/drivers/oprofile/oprof.h
@@ -24,6 +24,8 @@ struct oprofile_operations;
 extern unsigned long oprofile_buffer_size;
 extern unsigned long oprofile_cpu_buffer_size;
 extern unsigned long oprofile_buffer_watershed;
+extern unsigned long oprofile_time_slice;
+
 extern struct oprofile_operations oprofile_ops;
 extern unsigned long oprofile_started;
 extern unsigned long oprofile_backtrace_depth;
@@ -35,5 +37,6 @@ void oprofile_create_files(struct super_block *sb, struct dentry *root);
 void oprofile_timer_init(struct oprofile_operations *ops);
 
 int oprofile_set_backtrace(unsigned long depth);
+int oprofile_set_timeout(unsigned long time);
 
 #endif /* OPROF_H */
diff --git a/drivers/oprofile/oprofile_files.c b/drivers/oprofile/oprofile_files.c
index 5d36ffc30dd5..bbd7516e0869 100644
--- a/drivers/oprofile/oprofile_files.c
+++ b/drivers/oprofile/oprofile_files.c
@@ -9,6 +9,7 @@
 
 #include <linux/fs.h>
 #include <linux/oprofile.h>
+#include <linux/jiffies.h>
 
 #include "event_buffer.h"
 #include "oprofile_stats.h"
@@ -17,10 +18,51 @@
 #define BUFFER_SIZE_DEFAULT             131072
 #define CPU_BUFFER_SIZE_DEFAULT         8192
 #define BUFFER_WATERSHED_DEFAULT        32768   /* FIXME: tune */
+#define TIME_SLICE_DEFAULT              1
 
 unsigned long oprofile_buffer_size;
 unsigned long oprofile_cpu_buffer_size;
 unsigned long oprofile_buffer_watershed;
+unsigned long oprofile_time_slice;
+
+#ifdef CONFIG_OPROFILE_EVENT_MULTIPLEX
+
+static ssize_t timeout_read(struct file *file, char __user *buf,
+                size_t count, loff_t *offset)
+{
+        return oprofilefs_ulong_to_user(jiffies_to_msecs(oprofile_time_slice),
+                                        buf, count, offset);
+}
+
+
+static ssize_t timeout_write(struct file *file, char const __user *buf,
+                size_t count, loff_t *offset)
+{
+        unsigned long val;
+        int retval;
+
+        if (*offset)
+                return -EINVAL;
+
+        retval = oprofilefs_ulong_from_user(&val, buf, count);
+        if (retval)
+                return retval;
+
+        retval = oprofile_set_timeout(val);
+
+        if (retval)
+                return retval;
+        return count;
+}
+
+
+static const struct file_operations timeout_fops = {
+        .read           = timeout_read,
+        .write          = timeout_write,
+};
+
+#endif
+
 
 static ssize_t depth_read(struct file *file, char __user *buf, size_t count, loff_t *offset)
 {
@@ -129,6 +171,7 @@ void oprofile_create_files(struct super_block *sb, struct dentry *root)
         oprofile_buffer_size =          BUFFER_SIZE_DEFAULT;
         oprofile_cpu_buffer_size =      CPU_BUFFER_SIZE_DEFAULT;
         oprofile_buffer_watershed =     BUFFER_WATERSHED_DEFAULT;
+        oprofile_time_slice =           msecs_to_jiffies(TIME_SLICE_DEFAULT);
 
         oprofilefs_create_file(sb, root, "enable", &enable_fops);
         oprofilefs_create_file_perm(sb, root, "dump", &dump_fops, 0666);
@@ -139,6 +182,9 @@ void oprofile_create_files(struct super_block *sb, struct dentry *root)
         oprofilefs_create_file(sb, root, "cpu_type", &cpu_type_fops);
         oprofilefs_create_file(sb, root, "backtrace_depth", &depth_fops);
         oprofilefs_create_file(sb, root, "pointer_size", &pointer_size_fops);
+#ifdef CONFIG_OPROFILE_EVENT_MULTIPLEX
+        oprofilefs_create_file(sb, root, "time_slice", &timeout_fops);
+#endif
         oprofile_create_stats_files(sb, root);
         if (oprofile_ops.create_files)
                 oprofile_ops.create_files(sb, root);
diff --git a/drivers/oprofile/oprofile_stats.c b/drivers/oprofile/oprofile_stats.c
index 3c2270a8300c..61689e814d46 100644
--- a/drivers/oprofile/oprofile_stats.c
+++ b/drivers/oprofile/oprofile_stats.c
@@ -34,6 +34,7 @@ void oprofile_reset_stats(void)
         atomic_set(&oprofile_stats.sample_lost_no_mapping, 0);
         atomic_set(&oprofile_stats.event_lost_overflow, 0);
         atomic_set(&oprofile_stats.bt_lost_no_mapping, 0);
+        atomic_set(&oprofile_stats.multiplex_counter, 0);
 }
 
 
@@ -76,4 +77,8 @@ void oprofile_create_stats_files(struct super_block *sb, struct dentry *root)
                 &oprofile_stats.event_lost_overflow);
         oprofilefs_create_ro_atomic(sb, dir, "bt_lost_no_mapping",
                 &oprofile_stats.bt_lost_no_mapping);
+#ifdef CONFIG_OPROFILE_EVENT_MULTIPLEX
+        oprofilefs_create_ro_atomic(sb, dir, "multiplex_counter",
+                &oprofile_stats.multiplex_counter);
+#endif
 }
diff --git a/drivers/oprofile/oprofile_stats.h b/drivers/oprofile/oprofile_stats.h
index 3da0d08dc1f9..0b54e46c3c14 100644
--- a/drivers/oprofile/oprofile_stats.h
+++ b/drivers/oprofile/oprofile_stats.h
@@ -17,6 +17,7 @@ struct oprofile_stat_struct {
         atomic_t sample_lost_no_mapping;
         atomic_t bt_lost_no_mapping;
         atomic_t event_lost_overflow;
+        atomic_t multiplex_counter;
 };
 
 extern struct oprofile_stat_struct oprofile_stats;
diff --git a/drivers/pci/intr_remapping.c b/drivers/pci/intr_remapping.c
index 4f5b8712931f..44803644ca05 100644
--- a/drivers/pci/intr_remapping.c
+++ b/drivers/pci/intr_remapping.c
@@ -55,15 +55,12 @@ static struct irq_2_iommu *irq_2_iommu(unsigned int irq)
         return desc->irq_2_iommu;
 }
 
-static struct irq_2_iommu *irq_2_iommu_alloc_node(unsigned int irq, int node)
+static struct irq_2_iommu *irq_2_iommu_alloc(unsigned int irq)
 {
         struct irq_desc *desc;
         struct irq_2_iommu *irq_iommu;
 
-        /*
-         * alloc irq desc if not allocated already.
-         */
-        desc = irq_to_desc_alloc_node(irq, node);
+        desc = irq_to_desc(irq);
         if (!desc) {
                 printk(KERN_INFO "can not get irq_desc for %d\n", irq);
                 return NULL;
@@ -72,16 +69,11 @@ static struct irq_2_iommu *irq_2_iommu_alloc_node(unsigned int irq, int node)
         irq_iommu = desc->irq_2_iommu;
 
         if (!irq_iommu)
-                desc->irq_2_iommu = get_one_free_irq_2_iommu(node);
+                desc->irq_2_iommu = get_one_free_irq_2_iommu(irq_node(irq));
 
         return desc->irq_2_iommu;
 }
 
-static struct irq_2_iommu *irq_2_iommu_alloc(unsigned int irq)
-{
-        return irq_2_iommu_alloc_node(irq, cpu_to_node(boot_cpu_id));
-}
-
 #else /* !CONFIG_SPARSE_IRQ */
 
 static struct irq_2_iommu irq_2_iommuX[NR_IRQS];
diff --git a/drivers/pci/quirks.c b/drivers/pci/quirks.c
index 06b965623962..85ce23997be4 100644
--- a/drivers/pci/quirks.c
+++ b/drivers/pci/quirks.c
@@ -992,7 +992,7 @@ DECLARE_PCI_FIXUP_RESUME_EARLY(PCI_VENDOR_ID_INTEL,	PCI_DEVICE_ID_INTEL_82454NX,
 
 static void __devinit quirk_amd_ide_mode(struct pci_dev *pdev)
 {
-        /* set sb600/sb700/sb800 sata to ahci mode */
+        /* set SBX00 SATA in IDE mode to AHCI mode */
         u8 tmp;
 
         pci_read_config_byte(pdev, PCI_CLASS_DEVICE, &tmp);
@@ -1011,6 +1011,8 @@ DECLARE_PCI_FIXUP_HEADER(PCI_VENDOR_ID_ATI, PCI_DEVICE_ID_ATI_IXP600_SATA, quirk
 DECLARE_PCI_FIXUP_RESUME_EARLY(PCI_VENDOR_ID_ATI, PCI_DEVICE_ID_ATI_IXP600_SATA, quirk_amd_ide_mode);
 DECLARE_PCI_FIXUP_HEADER(PCI_VENDOR_ID_ATI, PCI_DEVICE_ID_ATI_IXP700_SATA, quirk_amd_ide_mode);
 DECLARE_PCI_FIXUP_RESUME_EARLY(PCI_VENDOR_ID_ATI, PCI_DEVICE_ID_ATI_IXP700_SATA, quirk_amd_ide_mode);
+DECLARE_PCI_FIXUP_HEADER(PCI_VENDOR_ID_AMD, PCI_DEVICE_ID_AMD_SB900_SATA_IDE, quirk_amd_ide_mode);
+DECLARE_PCI_FIXUP_RESUME_EARLY(PCI_VENDOR_ID_AMD, PCI_DEVICE_ID_AMD_SB900_SATA_IDE, quirk_amd_ide_mode);
 
 /*
  *      Serverworks CSB5 IDE does not fully support native mode
diff --git a/fs/dcache.c b/fs/dcache.c
index 9e5cd3c3a6ba..a100fa35a48f 100644
--- a/fs/dcache.c
+++ b/fs/dcache.c
@@ -32,6 +32,7 @@
 #include <linux/swap.h>
 #include <linux/bootmem.h>
 #include <linux/fs_struct.h>
+#include <linux/hardirq.h>
 #include "internal.h"
 
 int sysctl_vfs_cache_pressure __read_mostly = 100;
diff --git a/fs/locks.c b/fs/locks.c
index 52366e877d76..19ee18a6829b 100644
--- a/fs/locks.c
+++ b/fs/locks.c
@@ -768,7 +768,7 @@ static int flock_lock_file(struct file *filp, struct file_lock *request)
          * give it the opportunity to lock the file.
          */
         if (found)
-                cond_resched_bkl();
+                cond_resched();
 
 find_conflict:
         for_each_lock(inode, before) {
diff --git a/include/asm-generic/dma-mapping-common.h b/include/asm-generic/dma-mapping-common.h
index 5406a601185c..e694263445f7 100644
--- a/include/asm-generic/dma-mapping-common.h
+++ b/include/asm-generic/dma-mapping-common.h
@@ -103,7 +103,6 @@ static inline void dma_sync_single_for_cpu(struct device *dev, dma_addr_t addr,
         if (ops->sync_single_for_cpu)
                 ops->sync_single_for_cpu(dev, addr, size, dir);
         debug_dma_sync_single_for_cpu(dev, addr, size, dir);
-        flush_write_buffers();
 }
 
 static inline void dma_sync_single_for_device(struct device *dev,
@@ -116,7 +115,6 @@ static inline void dma_sync_single_for_device(struct device *dev,
         if (ops->sync_single_for_device)
                 ops->sync_single_for_device(dev, addr, size, dir);
         debug_dma_sync_single_for_device(dev, addr, size, dir);
-        flush_write_buffers();
 }
 
 static inline void dma_sync_single_range_for_cpu(struct device *dev,
@@ -132,7 +130,6 @@ static inline void dma_sync_single_range_for_cpu(struct device *dev,
                 ops->sync_single_range_for_cpu(dev, addr, offset, size, dir);
                 debug_dma_sync_single_range_for_cpu(dev, addr, offset, size, dir);
 
-                flush_write_buffers();
         } else
                 dma_sync_single_for_cpu(dev, addr, size, dir);
 }
@@ -150,7 +147,6 @@ static inline void dma_sync_single_range_for_device(struct device *dev,
                 ops->sync_single_range_for_device(dev, addr, offset, size, dir);
                 debug_dma_sync_single_range_for_device(dev, addr, offset, size, dir);
 
-                flush_write_buffers();
         } else
                 dma_sync_single_for_device(dev, addr, size, dir);
 }
@@ -165,7 +161,6 @@ dma_sync_sg_for_cpu(struct device *dev, struct scatterlist *sg,
         if (ops->sync_sg_for_cpu)
                 ops->sync_sg_for_cpu(dev, sg, nelems, dir);
         debug_dma_sync_sg_for_cpu(dev, sg, nelems, dir);
-        flush_write_buffers();
 }
 
 static inline void
@@ -179,7 +174,6 @@ dma_sync_sg_for_device(struct device *dev, struct scatterlist *sg,
                 ops->sync_sg_for_device(dev, sg, nelems, dir);
         debug_dma_sync_sg_for_device(dev, sg, nelems, dir);
 
-        flush_write_buffers();
 }
 
 #define dma_map_single(d, a, s, r) dma_map_single_attrs(d, a, s, r, NULL)
diff --git a/include/linux/ata.h b/include/linux/ata.h
index 9c75921f0c16..6299a259ed19 100644
--- a/include/linux/ata.h
+++ b/include/linux/ata.h
@@ -210,15 +210,25 @@ enum {
         ATA_CMD_STANDBY         = 0xE2, /* place in standby power mode */
         ATA_CMD_IDLE            = 0xE3, /* place in idle power mode */
         ATA_CMD_EDD             = 0x90, /* execute device diagnostic */
+        ATA_CMD_DOWNLOAD_MICRO  = 0x92,
+        ATA_CMD_NOP             = 0x00,
         ATA_CMD_FLUSH           = 0xE7,
         ATA_CMD_FLUSH_EXT       = 0xEA,
         ATA_CMD_ID_ATA          = 0xEC,
         ATA_CMD_ID_ATAPI        = 0xA1,
+        ATA_CMD_SERVICE         = 0xA2,
         ATA_CMD_READ            = 0xC8,
         ATA_CMD_READ_EXT        = 0x25,
+        ATA_CMD_READ_QUEUED     = 0x26,
+        ATA_CMD_READ_STREAM_EXT = 0x2B,
+        ATA_CMD_READ_STREAM_DMA_EXT = 0x2A,
         ATA_CMD_WRITE           = 0xCA,
         ATA_CMD_WRITE_EXT       = 0x35,
+        ATA_CMD_WRITE_QUEUED    = 0x36,
+        ATA_CMD_WRITE_STREAM_EXT = 0x3B,
+        ATA_CMD_WRITE_STREAM_DMA_EXT = 0x3A,
         ATA_CMD_WRITE_FUA_EXT   = 0x3D,
+        ATA_CMD_WRITE_QUEUED_FUA_EXT = 0x3E,
         ATA_CMD_FPDMA_READ      = 0x60,
         ATA_CMD_FPDMA_WRITE     = 0x61,
         ATA_CMD_PIO_READ        = 0x20,
@@ -235,6 +245,7 @@ enum {
         ATA_CMD_PACKET          = 0xA0,
         ATA_CMD_VERIFY          = 0x40,
         ATA_CMD_VERIFY_EXT      = 0x42,
+        ATA_CMD_WRITE_UNCORR_EXT = 0x45,
         ATA_CMD_STANDBYNOW1     = 0xE0,
         ATA_CMD_IDLEIMMEDIATE   = 0xE1,
         ATA_CMD_SLEEP           = 0xE6,
@@ -243,15 +254,34 @@ enum {
         ATA_CMD_READ_NATIVE_MAX_EXT = 0x27,
         ATA_CMD_SET_MAX         = 0xF9,
         ATA_CMD_SET_MAX_EXT     = 0x37,
-        ATA_CMD_READ_LOG_EXT    = 0x2f,
+        ATA_CMD_READ_LOG_EXT    = 0x2F,
+        ATA_CMD_WRITE_LOG_EXT   = 0x3F,
+        ATA_CMD_READ_LOG_DMA_EXT = 0x47,
+        ATA_CMD_WRITE_LOG_DMA_EXT = 0x57,
+        ATA_CMD_TRUSTED_RCV     = 0x5C,
+        ATA_CMD_TRUSTED_RCV_DMA = 0x5D,
+        ATA_CMD_TRUSTED_SND     = 0x5E,
+        ATA_CMD_TRUSTED_SND_DMA = 0x5F,
         ATA_CMD_PMP_READ        = 0xE4,
         ATA_CMD_PMP_WRITE       = 0xE8,
         ATA_CMD_CONF_OVERLAY    = 0xB1,
+        ATA_CMD_SEC_SET_PASS    = 0xF1,
+        ATA_CMD_SEC_UNLOCK      = 0xF2,
+        ATA_CMD_SEC_ERASE_PREP  = 0xF3,
+        ATA_CMD_SEC_ERASE_UNIT  = 0xF4,
         ATA_CMD_SEC_FREEZE_LOCK = 0xF5,
+        ATA_CMD_SEC_DISABLE_PASS = 0xF6,
+        ATA_CMD_CONFIG_STREAM   = 0x51,
         ATA_CMD_SMART           = 0xB0,
         ATA_CMD_MEDIA_LOCK      = 0xDE,
         ATA_CMD_MEDIA_UNLOCK    = 0xDF,
         ATA_CMD_DSM             = 0x06,
+        ATA_CMD_CHK_MED_CRD_TYP = 0xD1,
+        ATA_CMD_CFA_REQ_EXT_ERR = 0x03,
+        ATA_CMD_CFA_WRITE_NE    = 0x38,
+        ATA_CMD_CFA_TRANS_SECT  = 0x87,
+        ATA_CMD_CFA_ERASE       = 0xC0,
+        ATA_CMD_CFA_WRITE_MULT_NE = 0xCD,
         /* marked obsolete in the ATA/ATAPI-7 spec */
         ATA_CMD_RESTORE         = 0x10,
 
@@ -306,6 +336,7 @@ enum {
         /* SETFEATURE Sector counts for SATA features */
         SATA_AN                 = 0x05,  /* Asynchronous Notification */
         SATA_DIPM               = 0x03,  /* Device Initiated Power Management */
+        SATA_FPDMA_AA           = 0x02,  /* DMA Setup FIS Auto-Activate */
 
         /* feature values for SET_MAX */
         ATA_SET_MAX_ADDR        = 0x00,
@@ -525,6 +556,9 @@ static inline int ata_is_data(u8 prot)
 #define ata_id_has_atapi_AN(id) \
         ( (((id)[76] != 0x0000) && ((id)[76] != 0xffff)) && \
           ((id)[78] & (1 << 5)) )
+#define ata_id_has_fpdma_aa(id) \
+        ( (((id)[76] != 0x0000) && ((id)[76] != 0xffff)) && \
+          ((id)[78] & (1 << 2)) )
 #define ata_id_iordy_disable(id) ((id)[ATA_ID_CAPABILITY] & (1 << 10))
 #define ata_id_has_iordy(id) ((id)[ATA_ID_CAPABILITY] & (1 << 11))
 #define ata_id_u32(id,n)        \
diff --git a/include/linux/cpu.h b/include/linux/cpu.h
index 4d668e05d458..47536197ffdd 100644
--- a/include/linux/cpu.h
+++ b/include/linux/cpu.h
@@ -48,6 +48,15 @@ struct notifier_block;
 
 #ifdef CONFIG_SMP
 /* Need to know about CPUs going up/down? */
+#if defined(CONFIG_HOTPLUG_CPU) || !defined(MODULE)
+#define cpu_notifier(fn, pri) {                                 \
+        static struct notifier_block fn##_nb __cpuinitdata =    \
+                { .notifier_call = fn, .priority = pri };       \
+        register_cpu_notifier(&fn##_nb);                        \
+}
+#else /* #if defined(CONFIG_HOTPLUG_CPU) || !defined(MODULE) */
+#define cpu_notifier(fn, pri)   do { (void)(fn); } while (0)
+#endif /* #else #if defined(CONFIG_HOTPLUG_CPU) || !defined(MODULE) */
 #ifdef CONFIG_HOTPLUG_CPU
 extern int register_cpu_notifier(struct notifier_block *nb);
 extern void unregister_cpu_notifier(struct notifier_block *nb);
@@ -74,6 +83,8 @@ extern void cpu_maps_update_done(void);
 
 #else   /* CONFIG_SMP */
 
+#define cpu_notifier(fn, pri)   do { (void)(fn); } while (0)
+
 static inline int register_cpu_notifier(struct notifier_block *nb)
 {
         return 0;
@@ -99,11 +110,7 @@ extern struct sysdev_class cpu_sysdev_class;
 
 extern void get_online_cpus(void);
 extern void put_online_cpus(void);
-#define hotcpu_notifier(fn, pri) {                              \
-        static struct notifier_block fn##_nb __cpuinitdata =    \
-                { .notifier_call = fn, .priority = pri };       \
-        register_cpu_notifier(&fn##_nb);                        \
-}
+#define hotcpu_notifier(fn, pri)        cpu_notifier(fn, pri)
 #define register_hotcpu_notifier(nb)    register_cpu_notifier(nb)
 #define unregister_hotcpu_notifier(nb)  unregister_cpu_notifier(nb)
 int cpu_down(unsigned int cpu);
diff --git a/include/linux/dma-mapping.h b/include/linux/dma-mapping.h
index 07dfd460d286..c0f6c3cd788c 100644
--- a/include/linux/dma-mapping.h
+++ b/include/linux/dma-mapping.h
@@ -98,11 +98,6 @@ static inline int is_device_dma_capable(struct device *dev)
         return dev->dma_mask != NULL && *dev->dma_mask != DMA_MASK_NONE;
 }
 
-static inline int is_buffer_dma_capable(u64 mask, dma_addr_t addr, size_t size)
-{
-        return addr + size <= mask;
-}
-
 #ifdef CONFIG_HAS_DMA
 #include <asm/dma-mapping.h>
 #else
diff --git a/include/linux/dmi.h b/include/linux/dmi.h
index bb5489c82c99..a8a3e1ac281d 100644
--- a/include/linux/dmi.h
+++ b/include/linux/dmi.h
@@ -43,7 +43,7 @@ extern const char * dmi_get_system_info(int field);
 extern const struct dmi_device * dmi_find_device(int type, const char *name,
         const struct dmi_device *from);
 extern void dmi_scan_machine(void);
-extern int dmi_get_year(int field);
+extern bool dmi_get_date(int field, int *yearp, int *monthp, int *dayp);
 extern int dmi_name_in_vendors(const char *str);
 extern int dmi_name_in_serial(const char *str);
 extern int dmi_available;
@@ -58,7 +58,16 @@ static inline const char * dmi_get_system_info(int field) { return NULL; }
 static inline const struct dmi_device * dmi_find_device(int type, const char *name,
         const struct dmi_device *from) { return NULL; }
 static inline void dmi_scan_machine(void) { return; }
-static inline int dmi_get_year(int year) { return 0; }
+static inline bool dmi_get_date(int field, int *yearp, int *monthp, int *dayp)
+{
+        if (yearp)
+                *yearp = 0;
+        if (monthp)
+                *monthp = 0;
+        if (dayp)
+                *dayp = 0;
+        return false;
+}
 static inline int dmi_name_in_vendors(const char *s) { return 0; }
 static inline int dmi_name_in_serial(const char *s) { return 0; }
 #define dmi_available 0
diff --git a/include/linux/ftrace_event.h b/include/linux/ftrace_event.h
index a81170de7f6b..23f7179bf74e 100644
--- a/include/linux/ftrace_event.h
+++ b/include/linux/ftrace_event.h
@@ -93,16 +93,22 @@ void tracing_generic_entry_update(struct trace_entry *entry,
                                   unsigned long flags,
                                   int pc);
 struct ring_buffer_event *
-trace_current_buffer_lock_reserve(int type, unsigned long len,
+trace_current_buffer_lock_reserve(struct ring_buffer **current_buffer,
+                                  int type, unsigned long len,
                                   unsigned long flags, int pc);
-void trace_current_buffer_unlock_commit(struct ring_buffer_event *event,
+void trace_current_buffer_unlock_commit(struct ring_buffer *buffer,
+                                        struct ring_buffer_event *event,
                                         unsigned long flags, int pc);
-void trace_nowake_buffer_unlock_commit(struct ring_buffer_event *event,
+void trace_nowake_buffer_unlock_commit(struct ring_buffer *buffer,
+                                       struct ring_buffer_event *event,
                                         unsigned long flags, int pc);
-void trace_current_buffer_discard_commit(struct ring_buffer_event *event);
+void trace_current_buffer_discard_commit(struct ring_buffer *buffer,
+                                         struct ring_buffer_event *event);
 
 void tracing_record_cmdline(struct task_struct *tsk);
 
+struct event_filter;
+
 struct ftrace_event_call {
         struct list_head        list;
         char                    *name;
@@ -110,16 +116,18 @@ struct ftrace_event_call {
         struct dentry           *dir;
         struct trace_event      *event;
         int                     enabled;
-        int                     (*regfunc)(void);
-        void                    (*unregfunc)(void);
+        int                     (*regfunc)(void *);
+        void                    (*unregfunc)(void *);
         int                     id;
         int                     (*raw_init)(void);
-        int                     (*show_format)(struct trace_seq *s);
-        int                     (*define_fields)(void);
+        int                     (*show_format)(struct ftrace_event_call *call,
+                                               struct trace_seq *s);
+        int                     (*define_fields)(struct ftrace_event_call *);
         struct list_head        fields;
         int                     filter_active;
-        void                    *filter;
+        struct event_filter     *filter;
         void                    *mod;
+        void                    *data;
 
         atomic_t                profile_count;
         int                     (*profile_enable)(struct ftrace_event_call *);
@@ -129,15 +137,25 @@ struct ftrace_event_call {
 #define MAX_FILTER_PRED         32
 #define MAX_FILTER_STR_VAL      128
 
-extern int init_preds(struct ftrace_event_call *call);
 extern void destroy_preds(struct ftrace_event_call *call);
 extern int filter_match_preds(struct ftrace_event_call *call, void *rec);
-extern int filter_current_check_discard(struct ftrace_event_call *call,
+extern int filter_current_check_discard(struct ring_buffer *buffer,
+                                        struct ftrace_event_call *call,
                                         void *rec,
                                         struct ring_buffer_event *event);
 
-extern int trace_define_field(struct ftrace_event_call *call, char *type,
-                              char *name, int offset, int size, int is_signed);
+enum {
+        FILTER_OTHER = 0,
+        FILTER_STATIC_STRING,
+        FILTER_DYN_STRING,
+        FILTER_PTR_STRING,
+};
+
+extern int trace_define_field(struct ftrace_event_call *call,
+                              const char *type, const char *name,
+                              int offset, int size, int is_signed,
+                              int filter_type);
+extern int trace_define_common_fields(struct ftrace_event_call *call);
 
 #define is_signed_type(type)    (((type)(-1)) < 0)
 
@@ -162,11 +180,4 @@ do {									\
                 __trace_printk(ip, fmt, ##args);                        \
 } while (0)
 
-#define __common_field(type, item, is_signed)                           \
-        ret = trace_define_field(event_call, #type, "common_" #item,    \
-                                 offsetof(typeof(field.ent), item),     \
-                                 sizeof(field.ent.item), is_signed);    \
-        if (ret)                                                        \
-                return ret;
-
 #endif /* _LINUX_FTRACE_EVENT_H */
diff --git a/include/linux/hardirq.h b/include/linux/hardirq.h
index 8246c697863d..6d527ee82b2b 100644
--- a/include/linux/hardirq.h
+++ b/include/linux/hardirq.h
@@ -64,6 +64,12 @@
 #define HARDIRQ_OFFSET  (1UL << HARDIRQ_SHIFT)
 #define NMI_OFFSET      (1UL << NMI_SHIFT)
 
+#ifndef PREEMPT_ACTIVE
+#define PREEMPT_ACTIVE_BITS     1
+#define PREEMPT_ACTIVE_SHIFT    (NMI_SHIFT + NMI_BITS)
+#define PREEMPT_ACTIVE  (__IRQ_MASK(PREEMPT_ACTIVE_BITS) << PREEMPT_ACTIVE_SHIFT)
+#endif
+
 #if PREEMPT_ACTIVE < (1 << (NMI_SHIFT + NMI_BITS))
 #error PREEMPT_ACTIVE is too low!
 #endif
@@ -132,7 +138,7 @@ static inline void account_system_vtime(struct task_struct *tsk)
 }
 #endif
 
-#if defined(CONFIG_NO_HZ) && !defined(CONFIG_CLASSIC_RCU)
+#if defined(CONFIG_NO_HZ)
 extern void rcu_irq_enter(void);
 extern void rcu_irq_exit(void);
 extern void rcu_nmi_enter(void);
@@ -142,7 +148,7 @@ extern void rcu_nmi_exit(void);
 # define rcu_irq_exit() do { } while (0)
 # define rcu_nmi_enter() do { } while (0)
 # define rcu_nmi_exit() do { } while (0)
-#endif /* #if defined(CONFIG_NO_HZ) && !defined(CONFIG_CLASSIC_RCU) */
+#endif /* #if defined(CONFIG_NO_HZ) */
 
 /*
  * It is safe to do non-atomic ops on ->hardirq_context,
diff --git a/include/linux/init_task.h b/include/linux/init_task.h
index 7fc01b13be43..9e7f2e8fc66e 100644
--- a/include/linux/init_task.h
+++ b/include/linux/init_task.h
@@ -94,6 +94,16 @@ extern struct group_info init_groups;
 # define CAP_INIT_BSET  CAP_INIT_EFF_SET
 #endif
 
+#ifdef CONFIG_TREE_PREEMPT_RCU
+#define INIT_TASK_RCU_PREEMPT(tsk)                                      \
+        .rcu_read_lock_nesting = 0,                                     \
+        .rcu_read_unlock_special = 0,                                   \
+        .rcu_blocked_node = NULL,                                       \
+        .rcu_node_entry = LIST_HEAD_INIT(tsk.rcu_node_entry),
+#else
+#define INIT_TASK_RCU_PREEMPT(tsk)
+#endif
+
 extern struct cred init_cred;
 
 #ifdef CONFIG_PERF_COUNTERS
@@ -173,6 +183,7 @@ extern struct cred init_cred;
         INIT_LOCKDEP                                                    \
         INIT_FTRACE_GRAPH                                               \
         INIT_TRACE_RECURSION                                            \
+        INIT_TASK_RCU_PREEMPT(tsk)                                      \
 }
 
 
diff --git a/include/linux/interrupt.h b/include/linux/interrupt.h
index 35e7df1e9f30..1ac57e522a1f 100644
--- a/include/linux/interrupt.h
+++ b/include/linux/interrupt.h
@@ -50,6 +50,9 @@
  * IRQF_IRQPOLL - Interrupt is used for polling (only the interrupt that is
  *                registered first in an shared interrupt is considered for
  *                performance reasons)
+ * IRQF_ONESHOT - Interrupt is not reenabled after the hardirq handler finished.
+ *                Used by threaded interrupts which need to keep the
+ *                irq line disabled until the threaded handler has been run.
  */
 #define IRQF_DISABLED           0x00000020
 #define IRQF_SAMPLE_RANDOM      0x00000040
@@ -59,6 +62,7 @@
 #define IRQF_PERCPU             0x00000400
 #define IRQF_NOBALANCING        0x00000800
 #define IRQF_IRQPOLL            0x00001000
+#define IRQF_ONESHOT            0x00002000
 
 /*
  * Bits used by threaded handlers:
diff --git a/include/linux/irq.h b/include/linux/irq.h
index cb2e77a3f7f7..ae9653dbcd78 100644
--- a/include/linux/irq.h
+++ b/include/linux/irq.h
@@ -69,6 +69,8 @@ typedef	void (*irq_flow_handler_t)(unsigned int irq,
 #define IRQ_MOVE_PCNTXT         0x01000000      /* IRQ migration from process context */
 #define IRQ_AFFINITY_SET        0x02000000      /* IRQ affinity was set from userspace*/
 #define IRQ_SUSPENDED           0x04000000      /* IRQ has gone through suspend sequence */
+#define IRQ_ONESHOT             0x08000000      /* IRQ is not unmasked after hardirq */
+#define IRQ_NESTED_THREAD       0x10000000      /* IRQ is nested into another, no own handler thread */
 
 #ifdef CONFIG_IRQ_PER_CPU
 # define CHECK_IRQ_PER_CPU(var) ((var) & IRQ_PER_CPU)
@@ -100,6 +102,9 @@ struct msi_desc;
  * @set_type:           set the flow type (IRQ_TYPE_LEVEL/etc.) of an IRQ
  * @set_wake:           enable/disable power-management wake-on of an IRQ
  *
+ * @bus_lock:           function to lock access to slow bus (i2c) chips
+ * @bus_sync_unlock:    function to sync and unlock slow bus (i2c) chips
+ *
  * @release:            release function solely used by UML
  * @typename:           obsoleted by name, kept as migration helper
  */
@@ -123,6 +128,9 @@ struct irq_chip {
         int             (*set_type)(unsigned int irq, unsigned int flow_type);
         int             (*set_wake)(unsigned int irq, unsigned int on);
 
+        void            (*bus_lock)(unsigned int irq);
+        void            (*bus_sync_unlock)(unsigned int irq);
+
         /* Currently used only by UML, might disappear one day.*/
 #ifdef CONFIG_IRQ_RELEASE_METHOD
         void            (*release)(unsigned int irq, void *dev_id);
@@ -220,13 +228,6 @@ static inline struct irq_desc *move_irq_desc(struct irq_desc *desc, int node)
 extern struct irq_desc *irq_to_desc_alloc_node(unsigned int irq, int node);
 
 /*
- * Migration helpers for obsolete names, they will go away:
- */
-#define hw_interrupt_type       irq_chip
-#define no_irq_type             no_irq_chip
-typedef struct irq_desc         irq_desc_t;
-
-/*
  * Pick up the arch-dependent methods:
  */
 #include <asm/hw_irq.h>
@@ -289,6 +290,7 @@ extern void handle_edge_irq(unsigned int irq, struct irq_desc *desc);
 extern void handle_simple_irq(unsigned int irq, struct irq_desc *desc);
 extern void handle_percpu_irq(unsigned int irq, struct irq_desc *desc);
 extern void handle_bad_irq(unsigned int irq, struct irq_desc *desc);
+extern void handle_nested_irq(unsigned int irq);
 
 /*
  * Monolithic do_IRQ implementation.
@@ -379,6 +381,8 @@ set_irq_chained_handler(unsigned int irq,
         __set_irq_handler(irq, handle, 1, NULL);
 }
 
+extern void set_irq_nested_thread(unsigned int irq, int nest);
+
 extern void set_irq_noprobe(unsigned int irq);
 extern void set_irq_probe(unsigned int irq);
 
diff --git a/include/linux/irqnr.h b/include/linux/irqnr.h
index ec87b212ff7d..7bf89bc8cbca 100644
--- a/include/linux/irqnr.h
+++ b/include/linux/irqnr.h
@@ -41,6 +41,12 @@ extern struct irq_desc *irq_to_desc(unsigned int irq);
                         ;                                               \
                 else
 
+#ifdef CONFIG_SMP
+#define irq_node(irq)   (irq_to_desc(irq)->node)
+#else
+#define irq_node(irq)   0
+#endif
+
 #endif /* CONFIG_GENERIC_HARDIRQS */
 
 #define for_each_irq_nr(irq)                   \
diff --git a/include/linux/kernel.h b/include/linux/kernel.h
index d6320a3e8def..2b5b1e0899a8 100644
--- a/include/linux/kernel.h
+++ b/include/linux/kernel.h
@@ -125,7 +125,7 @@ extern int _cond_resched(void);
 #endif
 
 #ifdef CONFIG_DEBUG_SPINLOCK_SLEEP
-  void __might_sleep(char *file, int line);
+  void __might_sleep(char *file, int line, int preempt_offset);
 /**
  * might_sleep - annotation for functions that can sleep
  *
@@ -137,8 +137,9 @@ extern int _cond_resched(void);
  * supposed to.
  */
 # define might_sleep() \
-        do { __might_sleep(__FILE__, __LINE__); might_resched(); } while (0)
+        do { __might_sleep(__FILE__, __LINE__, 0); might_resched(); } while (0)
 #else
+  static inline void __might_sleep(char *file, int line, int preempt_offset) { }
 # define might_sleep() do { might_resched(); } while (0)
 #endif
 
diff --git a/include/linux/libata.h b/include/linux/libata.h
index e5b6e33c6571..76319bf03e37 100644
--- a/include/linux/libata.h
+++ b/include/linux/libata.h
@@ -143,7 +143,6 @@ enum {
 
         ATA_DFLAG_PIO           = (1 << 12), /* device limited to PIO mode */
         ATA_DFLAG_NCQ_OFF       = (1 << 13), /* device limited to non-NCQ mode */
-        ATA_DFLAG_SPUNDOWN      = (1 << 14), /* XXX: for spindown_compat */
         ATA_DFLAG_SLEEPING      = (1 << 15), /* device is sleeping */
         ATA_DFLAG_DUBIOUS_XFER  = (1 << 16), /* data transfer not verified */
         ATA_DFLAG_NO_UNLOAD     = (1 << 17), /* device doesn't support unload */
@@ -190,6 +189,7 @@ enum {
         ATA_FLAG_NO_POWEROFF_SPINDOWN = (1 << 11), /* don't spindown before poweroff */
         ATA_FLAG_NO_HIBERNATE_SPINDOWN = (1 << 12), /* don't spindown before hibernation */
         ATA_FLAG_DEBUGMSG       = (1 << 13),
+        ATA_FLAG_FPDMA_AA               = (1 << 14), /* driver supports Auto-Activate */
         ATA_FLAG_IGN_SIMPLEX    = (1 << 15), /* ignore SIMPLEX */
         ATA_FLAG_NO_IORDY       = (1 << 16), /* controller lacks iordy */
         ATA_FLAG_ACPI_SATA      = (1 << 17), /* need native SATA ACPI layout */
@@ -386,6 +386,7 @@ enum {
         ATA_HORKAGE_FIRMWARE_WARN = (1 << 12),  /* firmware update warning */
         ATA_HORKAGE_1_5_GBPS    = (1 << 13),    /* force 1.5 Gbps */
         ATA_HORKAGE_NOSETXFER   = (1 << 14),    /* skip SETXFER, SATA only */
+        ATA_HORKAGE_BROKEN_FPDMA_AA     = (1 << 15),    /* skip AA */
 
          /* DMA mask for user DMA control: User visible values; DO NOT
             renumber */
diff --git a/include/linux/lockdep.h b/include/linux/lockdep.h
index b25d1b53df0d..9ccf0e286b2a 100644
--- a/include/linux/lockdep.h
+++ b/include/linux/lockdep.h
@@ -149,6 +149,12 @@ struct lock_list {
         struct lock_class               *class;
         struct stack_trace              trace;
         int                             distance;
+
+        /*
+         * The parent field is used to implement breadth-first search, and the
+         * bit 0 is reused to indicate if the lock has been accessed in BFS.
+         */
+        struct lock_list                *parent;
 };
 
 /*
@@ -208,10 +214,12 @@ struct held_lock {
          * interrupt context:
          */
         unsigned int irq_context:2; /* bit 0 - soft, bit 1 - hard */
-        unsigned int trylock:1;
+        unsigned int trylock:1;                                         /* 16 bits */
+
         unsigned int read:2;        /* see lock_acquire() comment */
         unsigned int check:2;       /* see lock_acquire() comment */
         unsigned int hardirqs_off:1;
+        unsigned int references:11;                                     /* 32 bits */
 };
 
 /*
@@ -291,6 +299,10 @@ extern void lock_acquire(struct lockdep_map *lock, unsigned int subclass,
 extern void lock_release(struct lockdep_map *lock, int nested,
                          unsigned long ip);
 
+#define lockdep_is_held(lock)   lock_is_held(&(lock)->dep_map)
+
+extern int lock_is_held(struct lockdep_map *lock);
+
 extern void lock_set_class(struct lockdep_map *lock, const char *name,
                            struct lock_class_key *key, unsigned int subclass,
                            unsigned long ip);
@@ -309,6 +321,8 @@ extern void lockdep_trace_alloc(gfp_t mask);
 
 #define lockdep_depth(tsk)      (debug_locks ? (tsk)->lockdep_depth : 0)
 
+#define lockdep_assert_held(l)  WARN_ON(debug_locks && !lockdep_is_held(l))
+
 #else /* !LOCKDEP */
 
 static inline void lockdep_off(void)
@@ -353,6 +367,8 @@ struct lock_class_key { };
 
 #define lockdep_depth(tsk)      (0)
 
+#define lockdep_assert_held(l)                  do { } while (0)
+
 #endif /* !LOCKDEP */
 
 #ifdef CONFIG_LOCK_STAT
diff --git a/include/linux/module.h b/include/linux/module.h
index 098bdb7bfacf..f8f92d015efe 100644
--- a/include/linux/module.h
+++ b/include/linux/module.h
@@ -17,10 +17,12 @@
 #include <linux/moduleparam.h>
 #include <linux/marker.h>
 #include <linux/tracepoint.h>
-#include <asm/local.h>
 
+#include <asm/local.h>
 #include <asm/module.h>
 
+#include <trace/events/module.h>
+
 /* Not Yet Implemented */
 #define MODULE_SUPPORTED_DEVICE(name)
 
@@ -462,7 +464,10 @@ static inline local_t *__module_ref_addr(struct module *mod, int cpu)
 static inline void __module_get(struct module *module)
 {
         if (module) {
-                local_inc(__module_ref_addr(module, get_cpu()));
+                unsigned int cpu = get_cpu();
+                local_inc(__module_ref_addr(module, cpu));
+                trace_module_get(module, _THIS_IP_,
+                                 local_read(__module_ref_addr(module, cpu)));
                 put_cpu();
         }
 }
@@ -473,8 +478,11 @@ static inline int try_module_get(struct module *module)
 
         if (module) {
                 unsigned int cpu = get_cpu();
-                if (likely(module_is_live(module)))
+                if (likely(module_is_live(module))) {
                         local_inc(__module_ref_addr(module, cpu));
+                        trace_module_get(module, _THIS_IP_,
+                                local_read(__module_ref_addr(module, cpu)));
+                }
                 else
                         ret = 0;
                 put_cpu();
diff --git a/include/linux/nmi.h b/include/linux/nmi.h
index 29af2d5df097..b752e807adde 100644
--- a/include/linux/nmi.h
+++ b/include/linux/nmi.h
@@ -28,8 +28,23 @@ static inline void acpi_nmi_disable(void) { }
 static inline void acpi_nmi_enable(void) { }
 #endif
 
-#ifndef trigger_all_cpu_backtrace
-#define trigger_all_cpu_backtrace() do { } while (0)
+/*
+ * Create trigger_all_cpu_backtrace() out of the arch-provided
+ * base function. Return whether such support was available,
+ * to allow calling code to fall back to some other mechanism:
+ */
+#ifdef arch_trigger_all_cpu_backtrace
+static inline bool trigger_all_cpu_backtrace(void)
+{
+        arch_trigger_all_cpu_backtrace();
+
+        return true;
+}
+#else
+static inline bool trigger_all_cpu_backtrace(void)
+{
+        return false;
+}
 #endif
 
 #endif
diff --git a/include/linux/oprofile.h b/include/linux/oprofile.h
index 1d9518bc4c58..5171639ecf0f 100644
--- a/include/linux/oprofile.h
+++ b/include/linux/oprofile.h
@@ -67,6 +67,9 @@ struct oprofile_operations {
 
         /* Initiate a stack backtrace. Optional. */
         void (*backtrace)(struct pt_regs * const regs, unsigned int depth);
+
+        /* Multiplex between different events. Optional. */
+        int (*switch_events)(void);
         /* CPU identification string. */
         char * cpu_type;
 };
@@ -171,7 +174,6 @@ struct op_sample;
 struct op_entry {
         struct ring_buffer_event *event;
         struct op_sample *sample;
-        unsigned long irq_flags;
         unsigned long size;
         unsigned long *data;
 };
@@ -180,6 +182,7 @@ void oprofile_write_reserve(struct op_entry *entry,
                             struct pt_regs * const regs,
                             unsigned long pc, int code, int size);
 int oprofile_add_data(struct op_entry *entry, unsigned long val);
+int oprofile_add_data64(struct op_entry *entry, u64 val);
 int oprofile_write_commit(struct op_entry *entry);
 
 #endif /* OPROFILE_H */
diff --git a/include/linux/pagemap.h b/include/linux/pagemap.h
index aec3252afcf5..ed5d7501e181 100644
--- a/include/linux/pagemap.h
+++ b/include/linux/pagemap.h
@@ -132,7 +132,7 @@ static inline int page_cache_get_speculative(struct page *page)
 {
         VM_BUG_ON(in_interrupt());
 
-#if !defined(CONFIG_SMP) && defined(CONFIG_CLASSIC_RCU)
+#if !defined(CONFIG_SMP) && defined(CONFIG_TREE_RCU)
 # ifdef CONFIG_PREEMPT
         VM_BUG_ON(!in_atomic());
 # endif
@@ -170,7 +170,7 @@ static inline int page_cache_add_speculative(struct page *page, int count)
 {
         VM_BUG_ON(in_interrupt());
 
-#if !defined(CONFIG_SMP) && defined(CONFIG_CLASSIC_RCU)
+#if !defined(CONFIG_SMP) && defined(CONFIG_TREE_RCU)
 # ifdef CONFIG_PREEMPT
         VM_BUG_ON(!in_atomic());
 # endif
diff --git a/include/linux/pci_ids.h b/include/linux/pci_ids.h
index 73b46b6b904f..c8fdcadce437 100644
--- a/include/linux/pci_ids.h
+++ b/include/linux/pci_ids.h
@@ -376,6 +376,9 @@
 #define PCI_DEVICE_ID_ATI_IXP600_IDE    0x438c
 #define PCI_DEVICE_ID_ATI_IXP700_SATA   0x4390
 #define PCI_DEVICE_ID_ATI_IXP700_IDE    0x439c
+/* AMD SB Chipset */
+#define PCI_DEVICE_ID_AMD_SB900_IDE      0x780c
+#define PCI_DEVICE_ID_AMD_SB900_SATA_IDE 0x7800
 
 #define PCI_VENDOR_ID_VLSI              0x1004
 #define PCI_DEVICE_ID_VLSI_82C592       0x0005
@@ -537,6 +540,7 @@
 #define PCI_DEVICE_ID_AMD_8131_BRIDGE   0x7450
 #define PCI_DEVICE_ID_AMD_8131_APIC     0x7451
 #define PCI_DEVICE_ID_AMD_8132_BRIDGE   0x7458
+#define PCI_DEVICE_ID_AMD_CS5535_IDE    0x208F
 #define PCI_DEVICE_ID_AMD_CS5536_ISA    0x2090
 #define PCI_DEVICE_ID_AMD_CS5536_FLASH  0x2091
 #define PCI_DEVICE_ID_AMD_CS5536_AUDIO  0x2093
diff --git a/include/linux/perf_counter.h b/include/linux/perf_counter.h
index b53f7006cc4e..972f90d7a32f 100644
--- a/include/linux/perf_counter.h
+++ b/include/linux/perf_counter.h
@@ -216,6 +216,7 @@ struct perf_counter_attr {
 #define PERF_COUNTER_IOC_REFRESH        _IO ('$', 2)
 #define PERF_COUNTER_IOC_RESET          _IO ('$', 3)
 #define PERF_COUNTER_IOC_PERIOD         _IOW('$', 4, u64)
+#define PERF_COUNTER_IOC_SET_OUTPUT     _IO ('$', 5)
 
 enum perf_counter_ioc_flags {
         PERF_IOC_FLAG_GROUP             = 1U << 0,
@@ -415,6 +416,9 @@ enum perf_callchain_context {
         PERF_CONTEXT_MAX                = (__u64)-4095,
 };
 
+#define PERF_FLAG_FD_NO_GROUP   (1U << 0)
+#define PERF_FLAG_FD_OUTPUT     (1U << 1)
+
 #ifdef __KERNEL__
 /*
  * Kernel-internal data types and definitions:
@@ -536,6 +540,7 @@ struct perf_counter {
         struct list_head                sibling_list;
         int                             nr_siblings;
         struct perf_counter             *group_leader;
+        struct perf_counter             *output;
         const struct pmu                *pmu;
 
         enum perf_counter_active_state  state;
@@ -761,6 +766,8 @@ extern int sysctl_perf_counter_mlock;
 extern int sysctl_perf_counter_sample_rate;
 
 extern void perf_counter_init(void);
+extern void perf_tpcounter_event(int event_id, u64 addr, u64 count,
+                                 void *record, int entry_size);
 
 #ifndef perf_misc_flags
 #define perf_misc_flags(regs)   (user_mode(regs) ? PERF_EVENT_MISC_USER : \
diff --git a/include/linux/rcuclassic.h b/include/linux/rcuclassic.h
deleted file mode 100644
index bfd92e1e5d2c..000000000000
--- a/include/linux/rcuclassic.h
+++ /dev/null
@@ -1,178 +0,0 @@
-/*
- * Read-Copy Update mechanism for mutual exclusion (classic version)
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; either version 2 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
- *
- * Copyright IBM Corporation, 2001
- *
- * Author: Dipankar Sarma <dipankar@in.ibm.com>
- *
- * Based on the original work by Paul McKenney <paulmck@us.ibm.com>
- * and inputs from Rusty Russell, Andrea Arcangeli and Andi Kleen.
- * Papers:
- * http://www.rdrop.com/users/paulmck/paper/rclockpdcsproof.pdf
- * http://lse.sourceforge.net/locking/rclock_OLS.2001.05.01c.sc.pdf (OLS2001)
- *
- * For detailed explanation of Read-Copy Update mechanism see -
- *              Documentation/RCU
- *
- */
-
-#ifndef __LINUX_RCUCLASSIC_H
-#define __LINUX_RCUCLASSIC_H
-
-#include <linux/cache.h>
-#include <linux/spinlock.h>
-#include <linux/threads.h>
-#include <linux/cpumask.h>
-#include <linux/seqlock.h>
-
-#ifdef CONFIG_RCU_CPU_STALL_DETECTOR
-#define RCU_SECONDS_TILL_STALL_CHECK    (10 * HZ) /* for rcp->jiffies_stall */
-#define RCU_SECONDS_TILL_STALL_RECHECK  (30 * HZ) /* for rcp->jiffies_stall */
-#endif /* #ifdef CONFIG_RCU_CPU_STALL_DETECTOR */
-
-/* Global control variables for rcupdate callback mechanism. */
-struct rcu_ctrlblk {
-        long    cur;            /* Current batch number.                      */
-        long    completed;      /* Number of the last completed batch         */
-        long    pending;        /* Number of the last pending batch           */
-#ifdef CONFIG_RCU_CPU_STALL_DETECTOR
-        unsigned long gp_start; /* Time at which GP started in jiffies. */
-        unsigned long jiffies_stall;
-                                /* Time at which to check for CPU stalls. */
-#endif /* #ifdef CONFIG_RCU_CPU_STALL_DETECTOR */
-
-        int     signaled;
-
-        spinlock_t      lock    ____cacheline_internodealigned_in_smp;
-        DECLARE_BITMAP(cpumask, NR_CPUS); /* CPUs that need to switch for */
-                                          /* current batch to proceed.     */
-} ____cacheline_internodealigned_in_smp;
-
-/* Is batch a before batch b ? */
-static inline int rcu_batch_before(long a, long b)
-{
-        return (a - b) < 0;
-}
-
-/* Is batch a after batch b ? */
-static inline int rcu_batch_after(long a, long b)
-{
-        return (a - b) > 0;
-}
-
-/* Per-CPU data for Read-Copy UPdate. */
-struct rcu_data {
-        /* 1) quiescent state handling : */
-        long            quiescbatch;     /* Batch # for grace period */
-        int             passed_quiesc;   /* User-mode/idle loop etc. */
-        int             qs_pending;      /* core waits for quiesc state */
-
-        /* 2) batch handling */
-        /*
-         * if nxtlist is not NULL, then:
-         * batch:
-         *      The batch # for the last entry of nxtlist
-         * [*nxttail[1], NULL = *nxttail[2]):
-         *      Entries that batch # <= batch
-         * [*nxttail[0], *nxttail[1]):
-         *      Entries that batch # <= batch - 1
-         * [nxtlist, *nxttail[0]):
-         *      Entries that batch # <= batch - 2
-         *      The grace period for these entries has completed, and
-         *      the other grace-period-completed entries may be moved
-         *      here temporarily in rcu_process_callbacks().
-         */
-        long            batch;
-        struct rcu_head *nxtlist;
-        struct rcu_head **nxttail[3];
-        long            qlen;            /* # of queued callbacks */
-        struct rcu_head *donelist;
-        struct rcu_head **donetail;
-        long            blimit;          /* Upper limit on a processed batch */
-        int cpu;
-        struct rcu_head barrier;
-};
-
-/*
- * Increment the quiescent state counter.
- * The counter is a bit degenerated: We do not need to know
- * how many quiescent states passed, just if there was at least
- * one since the start of the grace period. Thus just a flag.
- */
-extern void rcu_qsctr_inc(int cpu);
-extern void rcu_bh_qsctr_inc(int cpu);
-
-extern int rcu_pending(int cpu);
-extern int rcu_needs_cpu(int cpu);
-
-#ifdef CONFIG_DEBUG_LOCK_ALLOC
-extern struct lockdep_map rcu_lock_map;
-# define rcu_read_acquire()     \
-                        lock_acquire(&rcu_lock_map, 0, 0, 2, 1, NULL, _THIS_IP_)
-# define rcu_read_release()     lock_release(&rcu_lock_map, 1, _THIS_IP_)
-#else
-# define rcu_read_acquire()     do { } while (0)
-# define rcu_read_release()     do { } while (0)
-#endif
-
-#define __rcu_read_lock() \
-        do { \
-                preempt_disable(); \
-                __acquire(RCU); \
-                rcu_read_acquire(); \
-        } while (0)
-#define __rcu_read_unlock() \
-        do { \
-                rcu_read_release(); \
-                __release(RCU); \
-                preempt_enable(); \
-        } while (0)
-#define __rcu_read_lock_bh() \
-        do { \
-                local_bh_disable(); \
-                __acquire(RCU_BH); \
-                rcu_read_acquire(); \
-        } while (0)
-#define __rcu_read_unlock_bh() \
-        do { \
-                rcu_read_release(); \
-                __release(RCU_BH); \
-                local_bh_enable(); \
-        } while (0)
-
-#define __synchronize_sched() synchronize_rcu()
-
-#define call_rcu_sched(head, func) call_rcu(head, func)
-
-extern void __rcu_init(void);
-#define rcu_init_sched()        do { } while (0)
-extern void rcu_check_callbacks(int cpu, int user);
-extern void rcu_restart_cpu(int cpu);
-
-extern long rcu_batches_completed(void);
-extern long rcu_batches_completed_bh(void);
-
-#define rcu_enter_nohz()        do { } while (0)
-#define rcu_exit_nohz()         do { } while (0)
-
-/* A context switch is a grace period for rcuclassic. */
-static inline int rcu_blocking_is_gp(void)
-{
-        return num_online_cpus() == 1;
-}
-
-#endif /* __LINUX_RCUCLASSIC_H */
diff --git a/include/linux/rcupdate.h b/include/linux/rcupdate.h
index 15fbb3ca634d..95e0615f4d75 100644
--- a/include/linux/rcupdate.h
+++ b/include/linux/rcupdate.h
@@ -51,18 +51,26 @@ struct rcu_head {
         void (*func)(struct rcu_head *head);
 };
 
-/* Internal to kernel, but needed by rcupreempt.h. */
+/* Exported common interfaces */
+extern void synchronize_rcu(void);
+extern void synchronize_rcu_bh(void);
+extern void rcu_barrier(void);
+extern void rcu_barrier_bh(void);
+extern void rcu_barrier_sched(void);
+extern void synchronize_sched_expedited(void);
+extern int sched_expedited_torture_stats(char *page);
+
+/* Internal to kernel */
+extern void rcu_init(void);
+extern void rcu_scheduler_starting(void);
+extern int rcu_needs_cpu(int cpu);
 extern int rcu_scheduler_active;
 
-#if defined(CONFIG_CLASSIC_RCU)
-#include <linux/rcuclassic.h>
-#elif defined(CONFIG_TREE_RCU)
+#if defined(CONFIG_TREE_RCU) || defined(CONFIG_TREE_PREEMPT_RCU)
 #include <linux/rcutree.h>
-#elif defined(CONFIG_PREEMPT_RCU)
-#include <linux/rcupreempt.h>
 #else
 #error "Unknown RCU implementation specified to kernel configuration"
-#endif /* #else #if defined(CONFIG_CLASSIC_RCU) */
+#endif
 
 #define RCU_HEAD_INIT   { .next = NULL, .func = NULL }
 #define RCU_HEAD(head) struct rcu_head head = RCU_HEAD_INIT
@@ -70,6 +78,16 @@ extern int rcu_scheduler_active;
        (ptr)->next = NULL; (ptr)->func = NULL; \
 } while (0)
 
+#ifdef CONFIG_DEBUG_LOCK_ALLOC
+extern struct lockdep_map rcu_lock_map;
+# define rcu_read_acquire()     \
+                        lock_acquire(&rcu_lock_map, 0, 0, 2, 1, NULL, _THIS_IP_)
+# define rcu_read_release()     lock_release(&rcu_lock_map, 1, _THIS_IP_)
+#else
+# define rcu_read_acquire()     do { } while (0)
+# define rcu_read_release()     do { } while (0)
+#endif
+
 /**
  * rcu_read_lock - mark the beginning of an RCU read-side critical section.
  *
@@ -99,7 +117,12 @@ extern int rcu_scheduler_active;
  *
  * It is illegal to block while in an RCU read-side critical section.
  */
-#define rcu_read_lock() __rcu_read_lock()
+static inline void rcu_read_lock(void)
+{
+        __rcu_read_lock();
+        __acquire(RCU);
+        rcu_read_acquire();
+}
 
 /**
  * rcu_read_unlock - marks the end of an RCU read-side critical section.
@@ -116,7 +139,12 @@ extern int rcu_scheduler_active;
  * used as well.  RCU does not care how the writers keep out of each
  * others' way, as long as they do so.
  */
-#define rcu_read_unlock() __rcu_read_unlock()
+static inline void rcu_read_unlock(void)
+{
+        rcu_read_release();
+        __release(RCU);
+        __rcu_read_unlock();
+}
 
 /**
  * rcu_read_lock_bh - mark the beginning of a softirq-only RCU critical section
@@ -129,14 +157,24 @@ extern int rcu_scheduler_active;
  * can use just rcu_read_lock().
  *
  */
-#define rcu_read_lock_bh() __rcu_read_lock_bh()
+static inline void rcu_read_lock_bh(void)
+{
+        __rcu_read_lock_bh();
+        __acquire(RCU_BH);
+        rcu_read_acquire();
+}
 
 /*
  * rcu_read_unlock_bh - marks the end of a softirq-only RCU critical section
  *
  * See rcu_read_lock_bh() for more information.
  */
-#define rcu_read_unlock_bh() __rcu_read_unlock_bh()
+static inline void rcu_read_unlock_bh(void)
+{
+        rcu_read_release();
+        __release(RCU_BH);
+        __rcu_read_unlock_bh();
+}
 
 /**
  * rcu_read_lock_sched - mark the beginning of a RCU-classic critical section
@@ -147,17 +185,34 @@ extern int rcu_scheduler_active;
  * - call_rcu_sched() and rcu_barrier_sched()
  * on the write-side to insure proper synchronization.
  */
-#define rcu_read_lock_sched() preempt_disable()
-#define rcu_read_lock_sched_notrace() preempt_disable_notrace()
+static inline void rcu_read_lock_sched(void)
+{
+        preempt_disable();
+        __acquire(RCU_SCHED);
+        rcu_read_acquire();
+}
+static inline notrace void rcu_read_lock_sched_notrace(void)
+{
+        preempt_disable_notrace();
+        __acquire(RCU_SCHED);
+}
 
 /*
  * rcu_read_unlock_sched - marks the end of a RCU-classic critical section
  *
  * See rcu_read_lock_sched for more information.
  */
-#define rcu_read_unlock_sched() preempt_enable()
-#define rcu_read_unlock_sched_notrace() preempt_enable_notrace()
-
+static inline void rcu_read_unlock_sched(void)
+{
+        rcu_read_release();
+        __release(RCU_SCHED);
+        preempt_enable();
+}
+static inline notrace void rcu_read_unlock_sched_notrace(void)
+{
+        __release(RCU_SCHED);
+        preempt_enable_notrace();
+}
 
 
 /**
@@ -259,15 +314,4 @@ extern void call_rcu(struct rcu_head *head,
 extern void call_rcu_bh(struct rcu_head *head,
                         void (*func)(struct rcu_head *head));
 
-/* Exported common interfaces */
-extern void synchronize_rcu(void);
-extern void rcu_barrier(void);
-extern void rcu_barrier_bh(void);
-extern void rcu_barrier_sched(void);
-
-/* Internal to kernel */
-extern void rcu_init(void);
-extern void rcu_scheduler_starting(void);
-extern int rcu_needs_cpu(int cpu);
-
 #endif /* __LINUX_RCUPDATE_H */
diff --git a/include/linux/rcupreempt.h b/include/linux/rcupreempt.h
deleted file mode 100644
index fce522782ffa..000000000000
--- a/include/linux/rcupreempt.h
+++ /dev/null
@@ -1,127 +0,0 @@
-/*
- * Read-Copy Update mechanism for mutual exclusion (RT implementation)
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; either version 2 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
- *
- * Copyright (C) IBM Corporation, 2006
- *
- * Author:  Paul McKenney <paulmck@us.ibm.com>
- *
- * Based on the original work by Paul McKenney <paul.mckenney@us.ibm.com>
- * and inputs from Rusty Russell, Andrea Arcangeli and Andi Kleen.
- * Papers:
- * http://www.rdrop.com/users/paulmck/paper/rclockpdcsproof.pdf
- * http://lse.sourceforge.net/locking/rclock_OLS.2001.05.01c.sc.pdf (OLS2001)
- *
- * For detailed explanation of Read-Copy Update mechanism see -
- *              Documentation/RCU
- *
- */
-
-#ifndef __LINUX_RCUPREEMPT_H
-#define __LINUX_RCUPREEMPT_H
-
-#include <linux/cache.h>
-#include <linux/spinlock.h>
-#include <linux/threads.h>
-#include <linux/smp.h>
-#include <linux/cpumask.h>
-#include <linux/seqlock.h>
-
-extern void rcu_qsctr_inc(int cpu);
-static inline void rcu_bh_qsctr_inc(int cpu) { }
-
-/*
- * Someone might want to pass call_rcu_bh as a function pointer.
- * So this needs to just be a rename and not a macro function.
- *  (no parentheses)
- */
-#define call_rcu_bh             call_rcu
-
-/**
- * call_rcu_sched - Queue RCU callback for invocation after sched grace period.
- * @head: structure to be used for queueing the RCU updates.
- * @func: actual update function to be invoked after the grace period
- *
- * The update function will be invoked some time after a full
- * synchronize_sched()-style grace period elapses, in other words after
- * all currently executing preempt-disabled sections of code (including
- * hardirq handlers, NMI handlers, and local_irq_save() blocks) have
- * completed.
- */
-extern void call_rcu_sched(struct rcu_head *head,
-                           void (*func)(struct rcu_head *head));
-
-extern void __rcu_read_lock(void)       __acquires(RCU);
-extern void __rcu_read_unlock(void)     __releases(RCU);
-extern int rcu_pending(int cpu);
-extern int rcu_needs_cpu(int cpu);
-
-#define __rcu_read_lock_bh()    { rcu_read_lock(); local_bh_disable(); }
-#define __rcu_read_unlock_bh()  { local_bh_enable(); rcu_read_unlock(); }
-
-extern void __synchronize_sched(void);
-
-extern void __rcu_init(void);
-extern void rcu_init_sched(void);
-extern void rcu_check_callbacks(int cpu, int user);
-extern void rcu_restart_cpu(int cpu);
-extern long rcu_batches_completed(void);
-
-/*
- * Return the number of RCU batches processed thus far. Useful for debug
- * and statistic. The _bh variant is identifcal to straight RCU
- */
-static inline long rcu_batches_completed_bh(void)
-{
-        return rcu_batches_completed();
-}
-
-#ifdef CONFIG_RCU_TRACE
-struct rcupreempt_trace;
-extern long *rcupreempt_flipctr(int cpu);
-extern long rcupreempt_data_completed(void);
-extern int rcupreempt_flip_flag(int cpu);
-extern int rcupreempt_mb_flag(int cpu);
-extern char *rcupreempt_try_flip_state_name(void);
-extern struct rcupreempt_trace *rcupreempt_trace_cpu(int cpu);
-#endif
-
-struct softirq_action;
-
-#ifdef CONFIG_NO_HZ
-extern void rcu_enter_nohz(void);
-extern void rcu_exit_nohz(void);
-#else
-# define rcu_enter_nohz()       do { } while (0)
-# define rcu_exit_nohz()        do { } while (0)
-#endif
-
-/*
- * A context switch is a grace period for rcupreempt synchronize_rcu()
- * only during early boot, before the scheduler has been initialized.
- * So, how the heck do we get a context switch?  Well, if the caller
- * invokes synchronize_rcu(), they are willing to accept a context
- * switch, so we simply pretend that one happened.
- *
- * After boot, there might be a blocked or preempted task in an RCU
- * read-side critical section, so we cannot then take the fastpath.
- */
-static inline int rcu_blocking_is_gp(void)
-{
-        return num_online_cpus() == 1 && !rcu_scheduler_active;
-}
-
-#endif /* __LINUX_RCUPREEMPT_H */
diff --git a/include/linux/rcupreempt_trace.h b/include/linux/rcupreempt_trace.h
deleted file mode 100644
index b99ae073192a..000000000000
--- a/include/linux/rcupreempt_trace.h
+++ /dev/null
@@ -1,97 +0,0 @@
-/*
- * Read-Copy Update mechanism for mutual exclusion (RT implementation)
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; either version 2 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
- *
- * Copyright (C) IBM Corporation, 2006
- *
- * Author:  Paul McKenney <paulmck@us.ibm.com>
- *
- * Based on the original work by Paul McKenney <paul.mckenney@us.ibm.com>
- * and inputs from Rusty Russell, Andrea Arcangeli and Andi Kleen.
- * Papers:
- * http://www.rdrop.com/users/paulmck/paper/rclockpdcsproof.pdf
- * http://lse.sourceforge.net/locking/rclock_OLS.2001.05.01c.sc.pdf (OLS2001)
- *
- * For detailed explanation of the Preemptible Read-Copy Update mechanism see -
- *               http://lwn.net/Articles/253651/
- */
-
-#ifndef __LINUX_RCUPREEMPT_TRACE_H
-#define __LINUX_RCUPREEMPT_TRACE_H
-
-#include <linux/types.h>
-#include <linux/kernel.h>
-
-#include <asm/atomic.h>
-
-/*
- * PREEMPT_RCU data structures.
- */
-
-struct rcupreempt_trace {
-        long            next_length;
-        long            next_add;
-        long            wait_length;
-        long            wait_add;
-        long            done_length;
-        long            done_add;
-        long            done_remove;
-        atomic_t        done_invoked;
-        long            rcu_check_callbacks;
-        atomic_t        rcu_try_flip_1;
-        atomic_t        rcu_try_flip_e1;
-        long            rcu_try_flip_i1;
-        long            rcu_try_flip_ie1;
-        long            rcu_try_flip_g1;
-        long            rcu_try_flip_a1;
-        long            rcu_try_flip_ae1;
-        long            rcu_try_flip_a2;
-        long            rcu_try_flip_z1;
-        long            rcu_try_flip_ze1;
-        long            rcu_try_flip_z2;
-        long            rcu_try_flip_m1;
-        long            rcu_try_flip_me1;
-        long            rcu_try_flip_m2;
-};
-
-#ifdef CONFIG_RCU_TRACE
-#define RCU_TRACE(fn, arg)      fn(arg);
-#else
-#define RCU_TRACE(fn, arg)
-#endif
-
-extern void rcupreempt_trace_move2done(struct rcupreempt_trace *trace);
-extern void rcupreempt_trace_move2wait(struct rcupreempt_trace *trace);
-extern void rcupreempt_trace_try_flip_1(struct rcupreempt_trace *trace);
-extern void rcupreempt_trace_try_flip_e1(struct rcupreempt_trace *trace);
-extern void rcupreempt_trace_try_flip_i1(struct rcupreempt_trace *trace);
-extern void rcupreempt_trace_try_flip_ie1(struct rcupreempt_trace *trace);
-extern void rcupreempt_trace_try_flip_g1(struct rcupreempt_trace *trace);
-extern void rcupreempt_trace_try_flip_a1(struct rcupreempt_trace *trace);
-extern void rcupreempt_trace_try_flip_ae1(struct rcupreempt_trace *trace);
-extern void rcupreempt_trace_try_flip_a2(struct rcupreempt_trace *trace);
-extern void rcupreempt_trace_try_flip_z1(struct rcupreempt_trace *trace);
-extern void rcupreempt_trace_try_flip_ze1(struct rcupreempt_trace *trace);
-extern void rcupreempt_trace_try_flip_z2(struct rcupreempt_trace *trace);
-extern void rcupreempt_trace_try_flip_m1(struct rcupreempt_trace *trace);
-extern void rcupreempt_trace_try_flip_me1(struct rcupreempt_trace *trace);
-extern void rcupreempt_trace_try_flip_m2(struct rcupreempt_trace *trace);
-extern void rcupreempt_trace_check_callbacks(struct rcupreempt_trace *trace);
-extern void rcupreempt_trace_done_remove(struct rcupreempt_trace *trace);
-extern void rcupreempt_trace_invoke(struct rcupreempt_trace *trace);
-extern void rcupreempt_trace_next_add(struct rcupreempt_trace *trace);
-
-#endif /* __LINUX_RCUPREEMPT_TRACE_H */
diff --git a/include/linux/rcutree.h b/include/linux/rcutree.h
index 5a5153806c42..a89307717825 100644
--- a/include/linux/rcutree.h
+++ b/include/linux/rcutree.h
@@ -30,264 +30,57 @@
 #ifndef __LINUX_RCUTREE_H
 #define __LINUX_RCUTREE_H
 
-#include <linux/cache.h>
-#include <linux/spinlock.h>
-#include <linux/threads.h>
-#include <linux/cpumask.h>
-#include <linux/seqlock.h>
+extern void rcu_sched_qs(int cpu);
+extern void rcu_bh_qs(int cpu);
 
-/*
- * Define shape of hierarchy based on NR_CPUS and CONFIG_RCU_FANOUT.
- * In theory, it should be possible to add more levels straightforwardly.
- * In practice, this has not been tested, so there is probably some
- * bug somewhere.
- */
-#define MAX_RCU_LVLS 3
-#define RCU_FANOUT            (CONFIG_RCU_FANOUT)
-#define RCU_FANOUT_SQ         (RCU_FANOUT * RCU_FANOUT)
-#define RCU_FANOUT_CUBE       (RCU_FANOUT_SQ * RCU_FANOUT)
-
-#if NR_CPUS <= RCU_FANOUT
-#  define NUM_RCU_LVLS        1
-#  define NUM_RCU_LVL_0       1
-#  define NUM_RCU_LVL_1       (NR_CPUS)
-#  define NUM_RCU_LVL_2       0
-#  define NUM_RCU_LVL_3       0
-#elif NR_CPUS <= RCU_FANOUT_SQ
-#  define NUM_RCU_LVLS        2
-#  define NUM_RCU_LVL_0       1
-#  define NUM_RCU_LVL_1       (((NR_CPUS) + RCU_FANOUT - 1) / RCU_FANOUT)
-#  define NUM_RCU_LVL_2       (NR_CPUS)
-#  define NUM_RCU_LVL_3       0
-#elif NR_CPUS <= RCU_FANOUT_CUBE
-#  define NUM_RCU_LVLS        3
-#  define NUM_RCU_LVL_0       1
-#  define NUM_RCU_LVL_1       (((NR_CPUS) + RCU_FANOUT_SQ - 1) / RCU_FANOUT_SQ)
-#  define NUM_RCU_LVL_2       (((NR_CPUS) + (RCU_FANOUT) - 1) / (RCU_FANOUT))
-#  define NUM_RCU_LVL_3       NR_CPUS
-#else
-# error "CONFIG_RCU_FANOUT insufficient for NR_CPUS"
-#endif /* #if (NR_CPUS) <= RCU_FANOUT */
-
-#define RCU_SUM (NUM_RCU_LVL_0 + NUM_RCU_LVL_1 + NUM_RCU_LVL_2 + NUM_RCU_LVL_3)
-#define NUM_RCU_NODES (RCU_SUM - NR_CPUS)
-
-/*
- * Dynticks per-CPU state.
- */
-struct rcu_dynticks {
-        int dynticks_nesting;   /* Track nesting level, sort of. */
-        int dynticks;           /* Even value for dynticks-idle, else odd. */
-        int dynticks_nmi;       /* Even value for either dynticks-idle or */
-                                /*  not in nmi handler, else odd.  So this */
-                                /*  remains even for nmi from irq handler. */
-};
-
-/*
- * Definition for node within the RCU grace-period-detection hierarchy.
- */
-struct rcu_node {
-        spinlock_t lock;
-        unsigned long qsmask;   /* CPUs or groups that need to switch in */
-                                /*  order for current grace period to proceed.*/
-        unsigned long qsmaskinit;
-                                /* Per-GP initialization for qsmask. */
-        unsigned long grpmask;  /* Mask to apply to parent qsmask. */
-        int     grplo;          /* lowest-numbered CPU or group here. */
-        int     grphi;          /* highest-numbered CPU or group here. */
-        u8      grpnum;         /* CPU/group number for next level up. */
-        u8      level;          /* root is at level 0. */
-        struct rcu_node *parent;
-} ____cacheline_internodealigned_in_smp;
-
-/* Index values for nxttail array in struct rcu_data. */
-#define RCU_DONE_TAIL           0       /* Also RCU_WAIT head. */
-#define RCU_WAIT_TAIL           1       /* Also RCU_NEXT_READY head. */
-#define RCU_NEXT_READY_TAIL     2       /* Also RCU_NEXT head. */
-#define RCU_NEXT_TAIL           3
-#define RCU_NEXT_SIZE           4
-
-/* Per-CPU data for read-copy update. */
-struct rcu_data {
-        /* 1) quiescent-state and grace-period handling : */
-        long            completed;      /* Track rsp->completed gp number */
-                                        /*  in order to detect GP end. */
-        long            gpnum;          /* Highest gp number that this CPU */
-                                        /*  is aware of having started. */
-        long            passed_quiesc_completed;
-                                        /* Value of completed at time of qs. */
-        bool            passed_quiesc;  /* User-mode/idle loop etc. */
-        bool            qs_pending;     /* Core waits for quiesc state. */
-        bool            beenonline;     /* CPU online at least once. */
-        struct rcu_node *mynode;        /* This CPU's leaf of hierarchy */
-        unsigned long grpmask;          /* Mask to apply to leaf qsmask. */
-
-        /* 2) batch handling */
-        /*
-         * If nxtlist is not NULL, it is partitioned as follows.
-         * Any of the partitions might be empty, in which case the
-         * pointer to that partition will be equal to the pointer for
-         * the following partition.  When the list is empty, all of
-         * the nxttail elements point to nxtlist, which is NULL.
-         *
-         * [*nxttail[RCU_NEXT_READY_TAIL], NULL = *nxttail[RCU_NEXT_TAIL]):
-         *      Entries that might have arrived after current GP ended
-         * [*nxttail[RCU_WAIT_TAIL], *nxttail[RCU_NEXT_READY_TAIL]):
-         *      Entries known to have arrived before current GP ended
-         * [*nxttail[RCU_DONE_TAIL], *nxttail[RCU_WAIT_TAIL]):
-         *      Entries that batch # <= ->completed - 1: waiting for current GP
-         * [nxtlist, *nxttail[RCU_DONE_TAIL]):
-         *      Entries that batch # <= ->completed
-         *      The grace period for these entries has completed, and
-         *      the other grace-period-completed entries may be moved
-         *      here temporarily in rcu_process_callbacks().
-         */
-        struct rcu_head *nxtlist;
-        struct rcu_head **nxttail[RCU_NEXT_SIZE];
-        long            qlen;           /* # of queued callbacks */
-        long            blimit;         /* Upper limit on a processed batch */
-
-#ifdef CONFIG_NO_HZ
-        /* 3) dynticks interface. */
-        struct rcu_dynticks *dynticks;  /* Shared per-CPU dynticks state. */
-        int dynticks_snap;              /* Per-GP tracking for dynticks. */
-        int dynticks_nmi_snap;          /* Per-GP tracking for dynticks_nmi. */
-#endif /* #ifdef CONFIG_NO_HZ */
-
-        /* 4) reasons this CPU needed to be kicked by force_quiescent_state */
-#ifdef CONFIG_NO_HZ
-        unsigned long dynticks_fqs;     /* Kicked due to dynticks idle. */
-#endif /* #ifdef CONFIG_NO_HZ */
-        unsigned long offline_fqs;      /* Kicked due to being offline. */
-        unsigned long resched_ipi;      /* Sent a resched IPI. */
-
-        /* 5) __rcu_pending() statistics. */
-        long n_rcu_pending;             /* rcu_pending() calls since boot. */
-        long n_rp_qs_pending;
-        long n_rp_cb_ready;
-        long n_rp_cpu_needs_gp;
-        long n_rp_gp_completed;
-        long n_rp_gp_started;
-        long n_rp_need_fqs;
-        long n_rp_need_nothing;
-
-        int cpu;
-};
-
-/* Values for signaled field in struct rcu_state. */
-#define RCU_GP_INIT             0       /* Grace period being initialized. */
-#define RCU_SAVE_DYNTICK        1       /* Need to scan dyntick state. */
-#define RCU_FORCE_QS            2       /* Need to force quiescent state. */
-#ifdef CONFIG_NO_HZ
-#define RCU_SIGNAL_INIT         RCU_SAVE_DYNTICK
-#else /* #ifdef CONFIG_NO_HZ */
-#define RCU_SIGNAL_INIT         RCU_FORCE_QS
-#endif /* #else #ifdef CONFIG_NO_HZ */
-
-#define RCU_JIFFIES_TILL_FORCE_QS        3      /* for rsp->jiffies_force_qs */
-#ifdef CONFIG_RCU_CPU_STALL_DETECTOR
-#define RCU_SECONDS_TILL_STALL_CHECK   (10 * HZ)  /* for rsp->jiffies_stall */
-#define RCU_SECONDS_TILL_STALL_RECHECK (30 * HZ)  /* for rsp->jiffies_stall */
-#define RCU_STALL_RAT_DELAY             2         /* Allow other CPUs time */
-                                                  /*  to take at least one */
-                                                  /*  scheduling clock irq */
-                                                  /*  before ratting on them. */
-
-#endif /* #ifdef CONFIG_RCU_CPU_STALL_DETECTOR */
-
-/*
- * RCU global state, including node hierarchy.  This hierarchy is
- * represented in "heap" form in a dense array.  The root (first level)
- * of the hierarchy is in ->node[0] (referenced by ->level[0]), the second
- * level in ->node[1] through ->node[m] (->node[1] referenced by ->level[1]),
- * and the third level in ->node[m+1] and following (->node[m+1] referenced
- * by ->level[2]).  The number of levels is determined by the number of
- * CPUs and by CONFIG_RCU_FANOUT.  Small systems will have a "hierarchy"
- * consisting of a single rcu_node.
- */
-struct rcu_state {
-        struct rcu_node node[NUM_RCU_NODES];    /* Hierarchy. */
-        struct rcu_node *level[NUM_RCU_LVLS];   /* Hierarchy levels. */
-        u32 levelcnt[MAX_RCU_LVLS + 1];         /* # nodes in each level. */
-        u8 levelspread[NUM_RCU_LVLS];           /* kids/node in each level. */
-        struct rcu_data *rda[NR_CPUS];          /* array of rdp pointers. */
-
-        /* The following fields are guarded by the root rcu_node's lock. */
-
-        u8      signaled ____cacheline_internodealigned_in_smp;
-                                                /* Force QS state. */
-        long    gpnum;                          /* Current gp number. */
-        long    completed;                      /* # of last completed gp. */
-        spinlock_t onofflock;                   /* exclude on/offline and */
-                                                /*  starting new GP. */
-        spinlock_t fqslock;                     /* Only one task forcing */
-                                                /*  quiescent states. */
-        unsigned long jiffies_force_qs;         /* Time at which to invoke */
-                                                /*  force_quiescent_state(). */
-        unsigned long n_force_qs;               /* Number of calls to */
-                                                /*  force_quiescent_state(). */
-        unsigned long n_force_qs_lh;            /* ~Number of calls leaving */
-                                                /*  due to lock unavailable. */
-        unsigned long n_force_qs_ngp;           /* Number of calls leaving */
-                                                /*  due to no GP active. */
-#ifdef CONFIG_RCU_CPU_STALL_DETECTOR
-        unsigned long gp_start;                 /* Time at which GP started, */
-                                                /*  but in jiffies. */
-        unsigned long jiffies_stall;            /* Time at which to check */
-                                                /*  for CPU stalls. */
-#endif /* #ifdef CONFIG_RCU_CPU_STALL_DETECTOR */
-#ifdef CONFIG_NO_HZ
-        long dynticks_completed;                /* Value of completed @ snap. */
-#endif /* #ifdef CONFIG_NO_HZ */
-};
+extern int rcu_needs_cpu(int cpu);
 
-extern void rcu_qsctr_inc(int cpu);
-extern void rcu_bh_qsctr_inc(int cpu);
+#ifdef CONFIG_TREE_PREEMPT_RCU
 
-extern int rcu_pending(int cpu);
-extern int rcu_needs_cpu(int cpu);
+extern void __rcu_read_lock(void);
+extern void __rcu_read_unlock(void);
+extern void exit_rcu(void);
 
-#ifdef CONFIG_DEBUG_LOCK_ALLOC
-extern struct lockdep_map rcu_lock_map;
-# define rcu_read_acquire()     \
-                        lock_acquire(&rcu_lock_map, 0, 0, 2, 1, NULL, _THIS_IP_)
-# define rcu_read_release()     lock_release(&rcu_lock_map, 1, _THIS_IP_)
-#else
-# define rcu_read_acquire()     do { } while (0)
-# define rcu_read_release()     do { } while (0)
-#endif
+#else /* #ifdef CONFIG_TREE_PREEMPT_RCU */
 
 static inline void __rcu_read_lock(void)
 {
         preempt_disable();
-        __acquire(RCU);
-        rcu_read_acquire();
 }
+
 static inline void __rcu_read_unlock(void)
 {
-        rcu_read_release();
-        __release(RCU);
         preempt_enable();
 }
+
+static inline void exit_rcu(void)
+{
+}
+
+#endif /* #else #ifdef CONFIG_TREE_PREEMPT_RCU */
+
 static inline void __rcu_read_lock_bh(void)
 {
         local_bh_disable();
-        __acquire(RCU_BH);
-        rcu_read_acquire();
 }
 static inline void __rcu_read_unlock_bh(void)
 {
-        rcu_read_release();
-        __release(RCU_BH);
         local_bh_enable();
 }
 
 #define __synchronize_sched() synchronize_rcu()
 
-#define call_rcu_sched(head, func) call_rcu(head, func)
+extern void call_rcu_sched(struct rcu_head *head,
+                           void (*func)(struct rcu_head *rcu));
 
-static inline void rcu_init_sched(void)
+static inline void synchronize_rcu_expedited(void)
 {
+        synchronize_sched_expedited();
+}
+
+static inline void synchronize_rcu_bh_expedited(void)
+{
+        synchronize_sched_expedited();
 }
 
 extern void __rcu_init(void);
@@ -296,6 +89,11 @@ extern void rcu_restart_cpu(int cpu);
 
 extern long rcu_batches_completed(void);
 extern long rcu_batches_completed_bh(void);
+extern long rcu_batches_completed_sched(void);
+
+static inline void rcu_init_sched(void)
+{
+}
 
 #ifdef CONFIG_NO_HZ
 void rcu_enter_nohz(void);
diff --git a/include/linux/ring_buffer.h b/include/linux/ring_buffer.h
index 29f8599e6bea..5fcc31ed5771 100644
--- a/include/linux/ring_buffer.h
+++ b/include/linux/ring_buffer.h
@@ -75,20 +75,6 @@ ring_buffer_event_time_delta(struct ring_buffer_event *event)
 }
 
 /*
- * ring_buffer_event_discard can discard any event in the ring buffer.
- *   it is up to the caller to protect against a reader from
- *   consuming it or a writer from wrapping and replacing it.
- *
- * No external protection is needed if this is called before
- * the event is commited. But in that case it would be better to
- * use ring_buffer_discard_commit.
- *
- * Note, if an event that has not been committed is discarded
- * with ring_buffer_event_discard, it must still be committed.
- */
-void ring_buffer_event_discard(struct ring_buffer_event *event);
-
-/*
  * ring_buffer_discard_commit will remove an event that has not
  *   ben committed yet. If this is used, then ring_buffer_unlock_commit
  *   must not be called on the discarded event. This function
@@ -154,8 +140,17 @@ unsigned long ring_buffer_size(struct ring_buffer *buffer);
 void ring_buffer_reset_cpu(struct ring_buffer *buffer, int cpu);
 void ring_buffer_reset(struct ring_buffer *buffer);
 
+#ifdef CONFIG_RING_BUFFER_ALLOW_SWAP
 int ring_buffer_swap_cpu(struct ring_buffer *buffer_a,
                          struct ring_buffer *buffer_b, int cpu);
+#else
+static inline int
+ring_buffer_swap_cpu(struct ring_buffer *buffer_a,
+                     struct ring_buffer *buffer_b, int cpu)
+{
+        return -ENODEV;
+}
+#endif
 
 int ring_buffer_empty(struct ring_buffer *buffer);
 int ring_buffer_empty_cpu(struct ring_buffer *buffer, int cpu);
@@ -170,7 +165,6 @@ unsigned long ring_buffer_overruns(struct ring_buffer *buffer);
 unsigned long ring_buffer_entries_cpu(struct ring_buffer *buffer, int cpu);
 unsigned long ring_buffer_overrun_cpu(struct ring_buffer *buffer, int cpu);
 unsigned long ring_buffer_commit_overrun_cpu(struct ring_buffer *buffer, int cpu);
-unsigned long ring_buffer_nmi_dropped_cpu(struct ring_buffer *buffer, int cpu);
 
 u64 ring_buffer_time_stamp(struct ring_buffer *buffer, int cpu);
 void ring_buffer_normalize_time_stamp(struct ring_buffer *buffer,
diff --git a/include/linux/sched.h b/include/linux/sched.h
index 9304027673b0..f3d74bd04d18 100644
--- a/include/linux/sched.h
+++ b/include/linux/sched.h
@@ -38,6 +38,8 @@
 #define SCHED_BATCH             3
 /* SCHED_ISO: reserved but not implemented yet */
 #define SCHED_IDLE              5
+/* Can be ORed in to make sure the process is reverted back to SCHED_NORMAL on fork */
+#define SCHED_RESET_ON_FORK     0x40000000
 
 #ifdef __KERNEL__
 
@@ -796,18 +798,19 @@ enum cpu_idle_type {
 #define SCHED_LOAD_SCALE_FUZZ   SCHED_LOAD_SCALE
 
 #ifdef CONFIG_SMP
-#define SD_LOAD_BALANCE         1       /* Do load balancing on this domain. */
-#define SD_BALANCE_NEWIDLE      2       /* Balance when about to become idle */
-#define SD_BALANCE_EXEC         4       /* Balance on exec */
-#define SD_BALANCE_FORK         8       /* Balance on fork, clone */
-#define SD_WAKE_IDLE            16      /* Wake to idle CPU on task wakeup */
-#define SD_WAKE_AFFINE          32      /* Wake task to waking CPU */
-#define SD_WAKE_BALANCE         64      /* Perform balancing at task wakeup */
-#define SD_SHARE_CPUPOWER       128     /* Domain members share cpu power */
-#define SD_POWERSAVINGS_BALANCE 256     /* Balance for power savings */
-#define SD_SHARE_PKG_RESOURCES  512     /* Domain members share cpu pkg resources */
-#define SD_SERIALIZE            1024    /* Only a single load balancing instance */
-#define SD_WAKE_IDLE_FAR        2048    /* Gain latency sacrificing cache hit */
+#define SD_LOAD_BALANCE         0x0001  /* Do load balancing on this domain. */
+#define SD_BALANCE_NEWIDLE      0x0002  /* Balance when about to become idle */
+#define SD_BALANCE_EXEC         0x0004  /* Balance on exec */
+#define SD_BALANCE_FORK         0x0008  /* Balance on fork, clone */
+#define SD_WAKE_IDLE            0x0010  /* Wake to idle CPU on task wakeup */
+#define SD_WAKE_AFFINE          0x0020  /* Wake task to waking CPU */
+#define SD_WAKE_BALANCE         0x0040  /* Perform balancing at task wakeup */
+#define SD_SHARE_CPUPOWER       0x0080  /* Domain members share cpu power */
+#define SD_POWERSAVINGS_BALANCE 0x0100  /* Balance for power savings */
+#define SD_SHARE_PKG_RESOURCES  0x0200  /* Domain members share cpu pkg resources */
+#define SD_SERIALIZE            0x0400  /* Only a single load balancing instance */
+#define SD_WAKE_IDLE_FAR        0x0800  /* Gain latency sacrificing cache hit */
+#define SD_PREFER_SIBLING       0x1000  /* Prefer to place tasks in a sibling domain */
 
 enum powersavings_balance_level {
         POWERSAVINGS_BALANCE_NONE = 0,  /* No power saving load balance */
@@ -827,7 +830,7 @@ static inline int sd_balance_for_mc_power(void)
         if (sched_smt_power_savings)
                 return SD_POWERSAVINGS_BALANCE;
 
-        return 0;
+        return SD_PREFER_SIBLING;
 }
 
 static inline int sd_balance_for_package_power(void)
@@ -835,7 +838,7 @@ static inline int sd_balance_for_package_power(void)
         if (sched_mc_power_savings | sched_smt_power_savings)
                 return SD_POWERSAVINGS_BALANCE;
 
-        return 0;
+        return SD_PREFER_SIBLING;
 }
 
 /*
@@ -857,15 +860,9 @@ struct sched_group {
 
         /*
          * CPU power of this group, SCHED_LOAD_SCALE being max power for a
-         * single CPU. This is read only (except for setup, hotplug CPU).
-         * Note : Never change cpu_power without recompute its reciprocal
+         * single CPU.
          */
-        unsigned int __cpu_power;
-        /*
-         * reciprocal value of cpu_power to avoid expensive divides
-         * (see include/linux/reciprocal_div.h)
-         */
-        u32 reciprocal_cpu_power;
+        unsigned int cpu_power;
 
         /*
          * The CPUs this group covers.
@@ -918,6 +915,7 @@ struct sched_domain {
         unsigned int newidle_idx;
         unsigned int wake_idx;
         unsigned int forkexec_idx;
+        unsigned int smt_gain;
         int flags;                      /* See SD_* */
         enum sched_domain_level level;
 
@@ -1045,7 +1043,6 @@ struct sched_class {
                               struct rq *busiest, struct sched_domain *sd,
                               enum cpu_idle_type idle);
         void (*pre_schedule) (struct rq *this_rq, struct task_struct *task);
-        int (*needs_post_schedule) (struct rq *this_rq);
         void (*post_schedule) (struct rq *this_rq);
         void (*task_wake_up) (struct rq *this_rq, struct task_struct *task);
 
@@ -1110,6 +1107,8 @@ struct sched_entity {
         u64                     wait_max;
         u64                     wait_count;
         u64                     wait_sum;
+        u64                     iowait_count;
+        u64                     iowait_sum;
 
         u64                     sleep_start;
         u64                     sleep_max;
@@ -1163,6 +1162,8 @@ struct sched_rt_entity {
 #endif
 };
 
+struct rcu_node;
+
 struct task_struct {
         volatile long state;    /* -1 unrunnable, 0 runnable, >0 stopped */
         void *stack;
@@ -1206,10 +1207,12 @@ struct task_struct {
         unsigned int policy;
         cpumask_t cpus_allowed;
 
-#ifdef CONFIG_PREEMPT_RCU
+#ifdef CONFIG_TREE_PREEMPT_RCU
         int rcu_read_lock_nesting;
-        int rcu_flipctr_idx;
-#endif /* #ifdef CONFIG_PREEMPT_RCU */
+        char rcu_read_unlock_special;
+        struct rcu_node *rcu_blocked_node;
+        struct list_head rcu_node_entry;
+#endif /* #ifdef CONFIG_TREE_PREEMPT_RCU */
 
 #if defined(CONFIG_SCHEDSTATS) || defined(CONFIG_TASK_DELAY_ACCT)
         struct sched_info sched_info;
@@ -1230,11 +1233,19 @@ struct task_struct {
         unsigned did_exec:1;
         unsigned in_execve:1;   /* Tell the LSMs that the process is doing an
                                  * execve */
+        unsigned in_iowait:1;
+
+
+        /* Revert to default priority/policy when forking */
+        unsigned sched_reset_on_fork:1;
+
         pid_t pid;
         pid_t tgid;
 
+#ifdef CONFIG_CC_STACKPROTECTOR
         /* Canary value for the -fstack-protector gcc feature */
         unsigned long stack_canary;
+#endif
 
         /* 
          * pointers to (original) parent process, youngest child, younger sibling,
@@ -1725,6 +1736,28 @@ extern cputime_t task_gtime(struct task_struct *p);
 #define tsk_used_math(p) ((p)->flags & PF_USED_MATH)
 #define used_math() tsk_used_math(current)
 
+#ifdef CONFIG_TREE_PREEMPT_RCU
+
+#define RCU_READ_UNLOCK_BLOCKED (1 << 0) /* blocked while in RCU read-side. */
+#define RCU_READ_UNLOCK_NEED_QS (1 << 1) /* RCU core needs CPU response. */
+#define RCU_READ_UNLOCK_GOT_QS  (1 << 2) /* CPU has responded to RCU core. */
+
+static inline void rcu_copy_process(struct task_struct *p)
+{
+        p->rcu_read_lock_nesting = 0;
+        p->rcu_read_unlock_special = 0;
+        p->rcu_blocked_node = NULL;
+        INIT_LIST_HEAD(&p->rcu_node_entry);
+}
+
+#else
+
+static inline void rcu_copy_process(struct task_struct *p)
+{
+}
+
+#endif
+
 #ifdef CONFIG_SMP
 extern int set_cpus_allowed_ptr(struct task_struct *p,
                                 const struct cpumask *new_mask);
@@ -1814,11 +1847,12 @@ extern unsigned int sysctl_sched_min_granularity;
 extern unsigned int sysctl_sched_wakeup_granularity;
 extern unsigned int sysctl_sched_shares_ratelimit;
 extern unsigned int sysctl_sched_shares_thresh;
-#ifdef CONFIG_SCHED_DEBUG
 extern unsigned int sysctl_sched_child_runs_first;
+#ifdef CONFIG_SCHED_DEBUG
 extern unsigned int sysctl_sched_features;
 extern unsigned int sysctl_sched_migration_cost;
 extern unsigned int sysctl_sched_nr_migrate;
+extern unsigned int sysctl_sched_time_avg;
 extern unsigned int sysctl_timer_migration;
 
 int sched_nr_latency_handler(struct ctl_table *table, int write,
@@ -2282,23 +2316,31 @@ static inline int need_resched(void)
  * cond_resched_softirq() will enable bhs before scheduling.
  */
 extern int _cond_resched(void);
-#ifdef CONFIG_PREEMPT_BKL
-static inline int cond_resched(void)
-{
-        return 0;
-}
+
+#define cond_resched() ({                       \
+        __might_sleep(__FILE__, __LINE__, 0);   \
+        _cond_resched();                        \
+})
+
+extern int __cond_resched_lock(spinlock_t *lock);
+
+#ifdef CONFIG_PREEMPT
+#define PREEMPT_LOCK_OFFSET     PREEMPT_OFFSET
 #else
-static inline int cond_resched(void)
-{
-        return _cond_resched();
-}
+#define PREEMPT_LOCK_OFFSET     0
 #endif
-extern int cond_resched_lock(spinlock_t * lock);
-extern int cond_resched_softirq(void);
-static inline int cond_resched_bkl(void)
-{
-        return _cond_resched();
-}
+
+#define cond_resched_lock(lock) ({                              \
+        __might_sleep(__FILE__, __LINE__, PREEMPT_LOCK_OFFSET); \
+        __cond_resched_lock(lock);                              \
+})
+
+extern int __cond_resched_softirq(void);
+
+#define cond_resched_softirq() ({                               \
+        __might_sleep(__FILE__, __LINE__, SOFTIRQ_OFFSET);      \
+        __cond_resched_softirq();                               \
+})
 
 /*
  * Does a critical section need to be broken due to another
diff --git a/include/linux/spinlock.h b/include/linux/spinlock.h
index 4be57ab03478..f0ca7a7a1757 100644
--- a/include/linux/spinlock.h
+++ b/include/linux/spinlock.h
@@ -143,15 +143,6 @@ static inline void smp_mb__after_lock(void) { smp_mb(); }
  */
 #define spin_unlock_wait(lock)  __raw_spin_unlock_wait(&(lock)->raw_lock)
 
-/*
- * Pull the _spin_*()/_read_*()/_write_*() functions/declarations:
- */
-#if defined(CONFIG_SMP) || defined(CONFIG_DEBUG_SPINLOCK)
-# include <linux/spinlock_api_smp.h>
-#else
-# include <linux/spinlock_api_up.h>
-#endif
-
 #ifdef CONFIG_DEBUG_SPINLOCK
  extern void _raw_spin_lock(spinlock_t *lock);
 #define _raw_spin_lock_flags(lock, flags) _raw_spin_lock(lock)
@@ -268,50 +259,16 @@ static inline void smp_mb__after_lock(void) { smp_mb(); }
 
 #define spin_lock_irq(lock)             _spin_lock_irq(lock)
 #define spin_lock_bh(lock)              _spin_lock_bh(lock)
-
 #define read_lock_irq(lock)             _read_lock_irq(lock)
 #define read_lock_bh(lock)              _read_lock_bh(lock)
-
 #define write_lock_irq(lock)            _write_lock_irq(lock)
 #define write_lock_bh(lock)             _write_lock_bh(lock)
-
-/*
- * We inline the unlock functions in the nondebug case:
- */
-#if defined(CONFIG_DEBUG_SPINLOCK) || defined(CONFIG_PREEMPT) || \
-        !defined(CONFIG_SMP)
-# define spin_unlock(lock)              _spin_unlock(lock)
-# define read_unlock(lock)              _read_unlock(lock)
-# define write_unlock(lock)             _write_unlock(lock)
-# define spin_unlock_irq(lock)          _spin_unlock_irq(lock)
-# define read_unlock_irq(lock)          _read_unlock_irq(lock)
-# define write_unlock_irq(lock)         _write_unlock_irq(lock)
-#else
-# define spin_unlock(lock) \
-    do {__raw_spin_unlock(&(lock)->raw_lock); __release(lock); } while (0)
-# define read_unlock(lock) \
-    do {__raw_read_unlock(&(lock)->raw_lock); __release(lock); } while (0)
-# define write_unlock(lock) \
-    do {__raw_write_unlock(&(lock)->raw_lock); __release(lock); } while (0)
-# define spin_unlock_irq(lock)                  \
-do {                                            \
-        __raw_spin_unlock(&(lock)->raw_lock);   \
-        __release(lock);                        \
-        local_irq_enable();                     \
-} while (0)
-# define read_unlock_irq(lock)                  \
-do {                                            \
-        __raw_read_unlock(&(lock)->raw_lock);   \
-        __release(lock);                        \
-        local_irq_enable();                     \
-} while (0)
-# define write_unlock_irq(lock)                 \
-do {                                            \
-        __raw_write_unlock(&(lock)->raw_lock);  \
-        __release(lock);                        \
-        local_irq_enable();                     \
-} while (0)
-#endif
+#define spin_unlock(lock)               _spin_unlock(lock)
+#define read_unlock(lock)               _read_unlock(lock)
+#define write_unlock(lock)              _write_unlock(lock)
+#define spin_unlock_irq(lock)           _spin_unlock_irq(lock)
+#define read_unlock_irq(lock)           _read_unlock_irq(lock)
+#define write_unlock_irq(lock)          _write_unlock_irq(lock)
 
 #define spin_unlock_irqrestore(lock, flags)             \
         do {                                            \
@@ -380,4 +337,13 @@ extern int _atomic_dec_and_lock(atomic_t *atomic, spinlock_t *lock);
  */
 #define spin_can_lock(lock)     (!spin_is_locked(lock))
 
+/*
+ * Pull the _spin_*()/_read_*()/_write_*() functions/declarations:
+ */
+#if defined(CONFIG_SMP) || defined(CONFIG_DEBUG_SPINLOCK)
+# include <linux/spinlock_api_smp.h>
+#else
+# include <linux/spinlock_api_up.h>
+#endif
+
 #endif /* __LINUX_SPINLOCK_H */
diff --git a/include/linux/spinlock_api_smp.h b/include/linux/spinlock_api_smp.h
index d79845d034b5..7a7e18fc2415 100644
--- a/include/linux/spinlock_api_smp.h
+++ b/include/linux/spinlock_api_smp.h
@@ -60,4 +60,398 @@ void __lockfunc _read_unlock_irqrestore(rwlock_t *lock, unsigned long flags)
 void __lockfunc _write_unlock_irqrestore(rwlock_t *lock, unsigned long flags)
                                                         __releases(lock);
 
+/*
+ * We inline the unlock functions in the nondebug case:
+ */
+#if !defined(CONFIG_DEBUG_SPINLOCK) && !defined(CONFIG_PREEMPT)
+#define __always_inline__spin_unlock
+#define __always_inline__read_unlock
+#define __always_inline__write_unlock
+#define __always_inline__spin_unlock_irq
+#define __always_inline__read_unlock_irq
+#define __always_inline__write_unlock_irq
+#endif
+
+#ifndef CONFIG_DEBUG_SPINLOCK
+#ifndef CONFIG_GENERIC_LOCKBREAK
+
+#ifdef __always_inline__spin_lock
+#define _spin_lock(lock) __spin_lock(lock)
+#endif
+
+#ifdef __always_inline__read_lock
+#define _read_lock(lock) __read_lock(lock)
+#endif
+
+#ifdef __always_inline__write_lock
+#define _write_lock(lock) __write_lock(lock)
+#endif
+
+#ifdef __always_inline__spin_lock_bh
+#define _spin_lock_bh(lock) __spin_lock_bh(lock)
+#endif
+
+#ifdef __always_inline__read_lock_bh
+#define _read_lock_bh(lock) __read_lock_bh(lock)
+#endif
+
+#ifdef __always_inline__write_lock_bh
+#define _write_lock_bh(lock) __write_lock_bh(lock)
+#endif
+
+#ifdef __always_inline__spin_lock_irq
+#define _spin_lock_irq(lock) __spin_lock_irq(lock)
+#endif
+
+#ifdef __always_inline__read_lock_irq
+#define _read_lock_irq(lock) __read_lock_irq(lock)
+#endif
+
+#ifdef __always_inline__write_lock_irq
+#define _write_lock_irq(lock) __write_lock_irq(lock)
+#endif
+
+#ifdef __always_inline__spin_lock_irqsave
+#define _spin_lock_irqsave(lock) __spin_lock_irqsave(lock)
+#endif
+
+#ifdef __always_inline__read_lock_irqsave
+#define _read_lock_irqsave(lock) __read_lock_irqsave(lock)
+#endif
+
+#ifdef __always_inline__write_lock_irqsave
+#define _write_lock_irqsave(lock) __write_lock_irqsave(lock)
+#endif
+
+#endif /* !CONFIG_GENERIC_LOCKBREAK */
+
+#ifdef __always_inline__spin_trylock
+#define _spin_trylock(lock) __spin_trylock(lock)
+#endif
+
+#ifdef __always_inline__read_trylock
+#define _read_trylock(lock) __read_trylock(lock)
+#endif
+
+#ifdef __always_inline__write_trylock
+#define _write_trylock(lock) __write_trylock(lock)
+#endif
+
+#ifdef __always_inline__spin_trylock_bh
+#define _spin_trylock_bh(lock) __spin_trylock_bh(lock)
+#endif
+
+#ifdef __always_inline__spin_unlock
+#define _spin_unlock(lock) __spin_unlock(lock)
+#endif
+
+#ifdef __always_inline__read_unlock
+#define _read_unlock(lock) __read_unlock(lock)
+#endif
+
+#ifdef __always_inline__write_unlock
+#define _write_unlock(lock) __write_unlock(lock)
+#endif
+
+#ifdef __always_inline__spin_unlock_bh
+#define _spin_unlock_bh(lock) __spin_unlock_bh(lock)
+#endif
+
+#ifdef __always_inline__read_unlock_bh
+#define _read_unlock_bh(lock) __read_unlock_bh(lock)
+#endif
+
+#ifdef __always_inline__write_unlock_bh
+#define _write_unlock_bh(lock) __write_unlock_bh(lock)
+#endif
+
+#ifdef __always_inline__spin_unlock_irq
+#define _spin_unlock_irq(lock) __spin_unlock_irq(lock)
+#endif
+
+#ifdef __always_inline__read_unlock_irq
+#define _read_unlock_irq(lock) __read_unlock_irq(lock)
+#endif
+
+#ifdef __always_inline__write_unlock_irq
+#define _write_unlock_irq(lock) __write_unlock_irq(lock)
+#endif
+
+#ifdef __always_inline__spin_unlock_irqrestore
+#define _spin_unlock_irqrestore(lock, flags) __spin_unlock_irqrestore(lock, flags)
+#endif
+
+#ifdef __always_inline__read_unlock_irqrestore
+#define _read_unlock_irqrestore(lock, flags) __read_unlock_irqrestore(lock, flags)
+#endif
+
+#ifdef __always_inline__write_unlock_irqrestore
+#define _write_unlock_irqrestore(lock, flags) __write_unlock_irqrestore(lock, flags)
+#endif
+
+#endif /* CONFIG_DEBUG_SPINLOCK */
+
+static inline int __spin_trylock(spinlock_t *lock)
+{
+        preempt_disable();
+        if (_raw_spin_trylock(lock)) {
+                spin_acquire(&lock->dep_map, 0, 1, _RET_IP_);
+                return 1;
+        }
+        preempt_enable();
+        return 0;
+}
+
+static inline int __read_trylock(rwlock_t *lock)
+{
+        preempt_disable();
+        if (_raw_read_trylock(lock)) {
+                rwlock_acquire_read(&lock->dep_map, 0, 1, _RET_IP_);
+                return 1;
+        }
+        preempt_enable();
+        return 0;
+}
+
+static inline int __write_trylock(rwlock_t *lock)
+{
+        preempt_disable();
+        if (_raw_write_trylock(lock)) {
+                rwlock_acquire(&lock->dep_map, 0, 1, _RET_IP_);
+                return 1;
+        }
+        preempt_enable();
+        return 0;
+}
+
+/*
+ * If lockdep is enabled then we use the non-preemption spin-ops
+ * even on CONFIG_PREEMPT, because lockdep assumes that interrupts are
+ * not re-enabled during lock-acquire (which the preempt-spin-ops do):
+ */
+#if !defined(CONFIG_GENERIC_LOCKBREAK) || defined(CONFIG_DEBUG_LOCK_ALLOC)
+
+static inline void __read_lock(rwlock_t *lock)
+{
+        preempt_disable();
+        rwlock_acquire_read(&lock->dep_map, 0, 0, _RET_IP_);
+        LOCK_CONTENDED(lock, _raw_read_trylock, _raw_read_lock);
+}
+
+static inline unsigned long __spin_lock_irqsave(spinlock_t *lock)
+{
+        unsigned long flags;
+
+        local_irq_save(flags);
+        preempt_disable();
+        spin_acquire(&lock->dep_map, 0, 0, _RET_IP_);
+        /*
+         * On lockdep we dont want the hand-coded irq-enable of
+         * _raw_spin_lock_flags() code, because lockdep assumes
+         * that interrupts are not re-enabled during lock-acquire:
+         */
+#ifdef CONFIG_LOCKDEP
+        LOCK_CONTENDED(lock, _raw_spin_trylock, _raw_spin_lock);
+#else
+        _raw_spin_lock_flags(lock, &flags);
+#endif
+        return flags;
+}
+
+static inline void __spin_lock_irq(spinlock_t *lock)
+{
+        local_irq_disable();
+        preempt_disable();
+        spin_acquire(&lock->dep_map, 0, 0, _RET_IP_);
+        LOCK_CONTENDED(lock, _raw_spin_trylock, _raw_spin_lock);
+}
+
+static inline void __spin_lock_bh(spinlock_t *lock)
+{
+        local_bh_disable();
+        preempt_disable();
+        spin_acquire(&lock->dep_map, 0, 0, _RET_IP_);
+        LOCK_CONTENDED(lock, _raw_spin_trylock, _raw_spin_lock);
+}
+
+static inline unsigned long __read_lock_irqsave(rwlock_t *lock)
+{
+        unsigned long flags;
+
+        local_irq_save(flags);
+        preempt_disable();
+        rwlock_acquire_read(&lock->dep_map, 0, 0, _RET_IP_);
+        LOCK_CONTENDED_FLAGS(lock, _raw_read_trylock, _raw_read_lock,
+                             _raw_read_lock_flags, &flags);
+        return flags;
+}
+
+static inline void __read_lock_irq(rwlock_t *lock)
+{
+        local_irq_disable();
+        preempt_disable();
+        rwlock_acquire_read(&lock->dep_map, 0, 0, _RET_IP_);
+        LOCK_CONTENDED(lock, _raw_read_trylock, _raw_read_lock);
+}
+
+static inline void __read_lock_bh(rwlock_t *lock)
+{
+        local_bh_disable();
+        preempt_disable();
+        rwlock_acquire_read(&lock->dep_map, 0, 0, _RET_IP_);
+        LOCK_CONTENDED(lock, _raw_read_trylock, _raw_read_lock);
+}
+
+static inline unsigned long __write_lock_irqsave(rwlock_t *lock)
+{
+        unsigned long flags;
+
+        local_irq_save(flags);
+        preempt_disable();
+        rwlock_acquire(&lock->dep_map, 0, 0, _RET_IP_);
+        LOCK_CONTENDED_FLAGS(lock, _raw_write_trylock, _raw_write_lock,
+                             _raw_write_lock_flags, &flags);
+        return flags;
+}
+
+static inline void __write_lock_irq(rwlock_t *lock)
+{
+        local_irq_disable();
+        preempt_disable();
+        rwlock_acquire(&lock->dep_map, 0, 0, _RET_IP_);
+        LOCK_CONTENDED(lock, _raw_write_trylock, _raw_write_lock);
+}
+
+static inline void __write_lock_bh(rwlock_t *lock)
+{
+        local_bh_disable();
+        preempt_disable();
+        rwlock_acquire(&lock->dep_map, 0, 0, _RET_IP_);
+        LOCK_CONTENDED(lock, _raw_write_trylock, _raw_write_lock);
+}
+
+static inline void __spin_lock(spinlock_t *lock)
+{
+        preempt_disable();
+        spin_acquire(&lock->dep_map, 0, 0, _RET_IP_);
+        LOCK_CONTENDED(lock, _raw_spin_trylock, _raw_spin_lock);
+}
+
+static inline void __write_lock(rwlock_t *lock)
+{
+        preempt_disable();
+        rwlock_acquire(&lock->dep_map, 0, 0, _RET_IP_);
+        LOCK_CONTENDED(lock, _raw_write_trylock, _raw_write_lock);
+}
+
+#endif /* CONFIG_PREEMPT */
+
+static inline void __spin_unlock(spinlock_t *lock)
+{
+        spin_release(&lock->dep_map, 1, _RET_IP_);
+        _raw_spin_unlock(lock);
+        preempt_enable();
+}
+
+static inline void __write_unlock(rwlock_t *lock)
+{
+        rwlock_release(&lock->dep_map, 1, _RET_IP_);
+        _raw_write_unlock(lock);
+        preempt_enable();
+}
+
+static inline void __read_unlock(rwlock_t *lock)
+{
+        rwlock_release(&lock->dep_map, 1, _RET_IP_);
+        _raw_read_unlock(lock);
+        preempt_enable();
+}
+
+static inline void __spin_unlock_irqrestore(spinlock_t *lock,
+                                            unsigned long flags)
+{
+        spin_release(&lock->dep_map, 1, _RET_IP_);
+        _raw_spin_unlock(lock);
+        local_irq_restore(flags);
+        preempt_enable();
+}
+
+static inline void __spin_unlock_irq(spinlock_t *lock)
+{
+        spin_release(&lock->dep_map, 1, _RET_IP_);
+        _raw_spin_unlock(lock);
+        local_irq_enable();
+        preempt_enable();
+}
+
+static inline void __spin_unlock_bh(spinlock_t *lock)
+{
+        spin_release(&lock->dep_map, 1, _RET_IP_);
+        _raw_spin_unlock(lock);
+        preempt_enable_no_resched();
+        local_bh_enable_ip((unsigned long)__builtin_return_address(0));
+}
+
+static inline void __read_unlock_irqrestore(rwlock_t *lock, unsigned long flags)
+{
+        rwlock_release(&lock->dep_map, 1, _RET_IP_);
+        _raw_read_unlock(lock);
+        local_irq_restore(flags);
+        preempt_enable();
+}
+
+static inline void __read_unlock_irq(rwlock_t *lock)
+{
+        rwlock_release(&lock->dep_map, 1, _RET_IP_);
+        _raw_read_unlock(lock);
+        local_irq_enable();
+        preempt_enable();
+}
+
+static inline void __read_unlock_bh(rwlock_t *lock)
+{
+        rwlock_release(&lock->dep_map, 1, _RET_IP_);
+        _raw_read_unlock(lock);
+        preempt_enable_no_resched();
+        local_bh_enable_ip((unsigned long)__builtin_return_address(0));
+}
+
+static inline void __write_unlock_irqrestore(rwlock_t *lock,
+                                             unsigned long flags)
+{
+        rwlock_release(&lock->dep_map, 1, _RET_IP_);
+        _raw_write_unlock(lock);
+        local_irq_restore(flags);
+        preempt_enable();
+}
+
+static inline void __write_unlock_irq(rwlock_t *lock)
+{
+        rwlock_release(&lock->dep_map, 1, _RET_IP_);
+        _raw_write_unlock(lock);
+        local_irq_enable();
+        preempt_enable();
+}
+
+static inline void __write_unlock_bh(rwlock_t *lock)
+{
+        rwlock_release(&lock->dep_map, 1, _RET_IP_);
+        _raw_write_unlock(lock);
+        preempt_enable_no_resched();
+        local_bh_enable_ip((unsigned long)__builtin_return_address(0));
+}
+
+static inline int __spin_trylock_bh(spinlock_t *lock)
+{
+        local_bh_disable();
+        preempt_disable();
+        if (_raw_spin_trylock(lock)) {
+                spin_acquire(&lock->dep_map, 0, 1, _RET_IP_);
+                return 1;
+        }
+        preempt_enable_no_resched();
+        local_bh_enable_ip((unsigned long)__builtin_return_address(0));
+        return 0;
+}
+
 #endif /* __LINUX_SPINLOCK_API_SMP_H */
diff --git a/include/linux/swiotlb.h b/include/linux/swiotlb.h
index cb1a6631b8f4..73b1f1cec423 100644
--- a/include/linux/swiotlb.h
+++ b/include/linux/swiotlb.h
@@ -14,7 +14,6 @@ struct scatterlist;
  */
 #define IO_TLB_SEGSIZE  128
 
-
 /*
  * log of the size of each IO TLB slab.  The number of slabs is command line
  * controllable.
@@ -24,16 +23,6 @@ struct scatterlist;
 extern void
 swiotlb_init(void);
 
-extern void *swiotlb_alloc_boot(size_t bytes, unsigned long nslabs);
-extern void *swiotlb_alloc(unsigned order, unsigned long nslabs);
-
-extern dma_addr_t swiotlb_phys_to_bus(struct device *hwdev,
-                                      phys_addr_t address);
-extern phys_addr_t swiotlb_bus_to_phys(struct device *hwdev,
-                                       dma_addr_t address);
-
-extern int swiotlb_arch_range_needs_mapping(phys_addr_t paddr, size_t size);
-
 extern void
 *swiotlb_alloc_coherent(struct device *hwdev, size_t size,
                         dma_addr_t *dma_handle, gfp_t flags);
diff --git a/include/linux/syscalls.h b/include/linux/syscalls.h
index 80de7003d8c2..a8e37821cc60 100644
--- a/include/linux/syscalls.h
+++ b/include/linux/syscalls.h
@@ -64,6 +64,7 @@ struct perf_counter_attr;
 #include <linux/sem.h>
 #include <asm/siginfo.h>
 #include <asm/signal.h>
+#include <linux/unistd.h>
 #include <linux/quota.h>
 #include <linux/key.h>
 #include <trace/syscall.h>
@@ -97,6 +98,53 @@ struct perf_counter_attr;
 #define __SC_TEST5(t5, a5, ...) __SC_TEST(t5); __SC_TEST4(__VA_ARGS__)
 #define __SC_TEST6(t6, a6, ...) __SC_TEST(t6); __SC_TEST5(__VA_ARGS__)
 
+#ifdef CONFIG_EVENT_PROFILE
+#define TRACE_SYS_ENTER_PROFILE(sname)                                         \
+static int prof_sysenter_enable_##sname(struct ftrace_event_call *event_call)  \
+{                                                                              \
+        int ret = 0;                                                           \
+        if (!atomic_inc_return(&event_enter_##sname.profile_count))            \
+                ret = reg_prof_syscall_enter("sys"#sname);                     \
+        return ret;                                                            \
+}                                                                              \
+                                                                               \
+static void prof_sysenter_disable_##sname(struct ftrace_event_call *event_call)\
+{                                                                              \
+        if (atomic_add_negative(-1, &event_enter_##sname.profile_count))       \
+                unreg_prof_syscall_enter("sys"#sname);                         \
+}
+
+#define TRACE_SYS_EXIT_PROFILE(sname)                                          \
+static int prof_sysexit_enable_##sname(struct ftrace_event_call *event_call)   \
+{                                                                              \
+        int ret = 0;                                                           \
+        if (!atomic_inc_return(&event_exit_##sname.profile_count))             \
+                ret = reg_prof_syscall_exit("sys"#sname);                      \
+        return ret;                                                            \
+}                                                                              \
+                                                                               \
+static void prof_sysexit_disable_##sname(struct ftrace_event_call *event_call) \
+{                                                                              \
+        if (atomic_add_negative(-1, &event_exit_##sname.profile_count))        \
+                unreg_prof_syscall_exit("sys"#sname);                          \
+}
+
+#define TRACE_SYS_ENTER_PROFILE_INIT(sname)                                    \
+        .profile_count = ATOMIC_INIT(-1),                                      \
+        .profile_enable = prof_sysenter_enable_##sname,                        \
+        .profile_disable = prof_sysenter_disable_##sname,
+
+#define TRACE_SYS_EXIT_PROFILE_INIT(sname)                                     \
+        .profile_count = ATOMIC_INIT(-1),                                      \
+        .profile_enable = prof_sysexit_enable_##sname,                         \
+        .profile_disable = prof_sysexit_disable_##sname,
+#else
+#define TRACE_SYS_ENTER_PROFILE(sname)
+#define TRACE_SYS_ENTER_PROFILE_INIT(sname)
+#define TRACE_SYS_EXIT_PROFILE(sname)
+#define TRACE_SYS_EXIT_PROFILE_INIT(sname)
+#endif
+
 #ifdef CONFIG_FTRACE_SYSCALLS
 #define __SC_STR_ADECL1(t, a)           #a
 #define __SC_STR_ADECL2(t, a, ...)      #a, __SC_STR_ADECL1(__VA_ARGS__)
@@ -112,7 +160,81 @@ struct perf_counter_attr;
 #define __SC_STR_TDECL5(t, a, ...)      #t, __SC_STR_TDECL4(__VA_ARGS__)
 #define __SC_STR_TDECL6(t, a, ...)      #t, __SC_STR_TDECL5(__VA_ARGS__)
 
+#define SYSCALL_TRACE_ENTER_EVENT(sname)                                \
+        static struct ftrace_event_call event_enter_##sname;            \
+        struct trace_event enter_syscall_print_##sname = {              \
+                .trace                  = print_syscall_enter,          \
+        };                                                              \
+        static int init_enter_##sname(void)                             \
+        {                                                               \
+                int num, id;                                            \
+                num = syscall_name_to_nr("sys"#sname);                  \
+                if (num < 0)                                            \
+                        return -ENOSYS;                                 \
+                id = register_ftrace_event(&enter_syscall_print_##sname);\
+                if (!id)                                                \
+                        return -ENODEV;                                 \
+                event_enter_##sname.id = id;                            \
+                set_syscall_enter_id(num, id);                          \
+                INIT_LIST_HEAD(&event_enter_##sname.fields);            \
+                return 0;                                               \
+        }                                                               \
+        TRACE_SYS_ENTER_PROFILE(sname);                                 \
+        static struct ftrace_event_call __used                          \
+          __attribute__((__aligned__(4)))                               \
+          __attribute__((section("_ftrace_events")))                    \
+          event_enter_##sname = {                                       \
+                .name                   = "sys_enter"#sname,            \
+                .system                 = "syscalls",                   \
+                .event                  = &event_syscall_enter,         \
+                .raw_init               = init_enter_##sname,           \
+                .show_format            = syscall_enter_format,         \
+                .define_fields          = syscall_enter_define_fields,  \
+                .regfunc                = reg_event_syscall_enter,      \
+                .unregfunc              = unreg_event_syscall_enter,    \
+                .data                   = "sys"#sname,                  \
+                TRACE_SYS_ENTER_PROFILE_INIT(sname)                     \
+        }
+
+#define SYSCALL_TRACE_EXIT_EVENT(sname)                                 \
+        static struct ftrace_event_call event_exit_##sname;             \
+        struct trace_event exit_syscall_print_##sname = {               \
+                .trace                  = print_syscall_exit,           \
+        };                                                              \
+        static int init_exit_##sname(void)                              \
+        {                                                               \
+                int num, id;                                            \
+                num = syscall_name_to_nr("sys"#sname);                  \
+                if (num < 0)                                            \
+                        return -ENOSYS;                                 \
+                id = register_ftrace_event(&exit_syscall_print_##sname);\
+                if (!id)                                                \
+                        return -ENODEV;                                 \
+                event_exit_##sname.id = id;                             \
+                set_syscall_exit_id(num, id);                           \
+                INIT_LIST_HEAD(&event_exit_##sname.fields);             \
+                return 0;                                               \
+        }                                                               \
+        TRACE_SYS_EXIT_PROFILE(sname);                                  \
+        static struct ftrace_event_call __used                          \
+          __attribute__((__aligned__(4)))                               \
+          __attribute__((section("_ftrace_events")))                    \
+          event_exit_##sname = {                                        \
+                .name                   = "sys_exit"#sname,             \
+                .system                 = "syscalls",                   \
+                .event                  = &event_syscall_exit,          \
+                .raw_init               = init_exit_##sname,            \
+                .show_format            = syscall_exit_format,          \
+                .define_fields          = syscall_exit_define_fields,   \
+                .regfunc                = reg_event_syscall_exit,       \
+                .unregfunc              = unreg_event_syscall_exit,     \
+                .data                   = "sys"#sname,                  \
+                TRACE_SYS_EXIT_PROFILE_INIT(sname)                      \
+        }
+
 #define SYSCALL_METADATA(sname, nb)                             \
+        SYSCALL_TRACE_ENTER_EVENT(sname);                       \
+        SYSCALL_TRACE_EXIT_EVENT(sname);                        \
         static const struct syscall_metadata __used             \
           __attribute__((__aligned__(4)))                       \
           __attribute__((section("__syscalls_metadata")))       \
@@ -121,18 +243,23 @@ struct perf_counter_attr;
                 .nb_args        = nb,                           \
                 .types          = types_##sname,                \
                 .args           = args_##sname,                 \
-        }
+                .enter_event    = &event_enter_##sname,         \
+                .exit_event     = &event_exit_##sname,          \
+        };
 
 #define SYSCALL_DEFINE0(sname)                                  \
+        SYSCALL_TRACE_ENTER_EVENT(_##sname);                    \
+        SYSCALL_TRACE_EXIT_EVENT(_##sname);                     \
         static const struct syscall_metadata __used             \
           __attribute__((__aligned__(4)))                       \
           __attribute__((section("__syscalls_metadata")))       \
           __syscall_meta_##sname = {                            \
                 .name           = "sys_"#sname,                 \
                 .nb_args        = 0,                            \
+                .enter_event    = &event_enter__##sname,        \
+                .exit_event     = &event_exit__##sname,         \
         };                                                      \
         asmlinkage long sys_##sname(void)
-
 #else
 #define SYSCALL_DEFINE0(name)      asmlinkage long sys_##name(void)
 #endif
diff --git a/include/linux/topology.h b/include/linux/topology.h
index 7402c1a27c4f..85e8cf7d393c 100644
--- a/include/linux/topology.h
+++ b/include/linux/topology.h
@@ -85,20 +85,29 @@ int arch_update_cpu_topology(void);
 #define ARCH_HAS_SCHED_WAKE_IDLE
 /* Common values for SMT siblings */
 #ifndef SD_SIBLING_INIT
-#define SD_SIBLING_INIT (struct sched_domain) {         \
-        .min_interval           = 1,                    \
-        .max_interval           = 2,                    \
-        .busy_factor            = 64,                   \
-        .imbalance_pct          = 110,                  \
-        .flags                  = SD_LOAD_BALANCE       \
-                                | SD_BALANCE_NEWIDLE    \
-                                | SD_BALANCE_FORK       \
-                                | SD_BALANCE_EXEC       \
-                                | SD_WAKE_AFFINE        \
-                                | SD_WAKE_BALANCE       \
-                                | SD_SHARE_CPUPOWER,    \
-        .last_balance           = jiffies,              \
-        .balance_interval       = 1,                    \
+#define SD_SIBLING_INIT (struct sched_domain) {                         \
+        .min_interval           = 1,                                    \
+        .max_interval           = 2,                                    \
+        .busy_factor            = 64,                                   \
+        .imbalance_pct          = 110,                                  \
+                                                                        \
+        .flags                  = 1*SD_LOAD_BALANCE                     \
+                                | 1*SD_BALANCE_NEWIDLE                  \
+                                | 1*SD_BALANCE_EXEC                     \
+                                | 1*SD_BALANCE_FORK                     \
+                                | 0*SD_WAKE_IDLE                        \
+                                | 1*SD_WAKE_AFFINE                      \
+                                | 1*SD_WAKE_BALANCE                     \
+                                | 1*SD_SHARE_CPUPOWER                   \
+                                | 0*SD_POWERSAVINGS_BALANCE             \
+                                | 0*SD_SHARE_PKG_RESOURCES              \
+                                | 0*SD_SERIALIZE                        \
+                                | 0*SD_WAKE_IDLE_FAR                    \
+                                | 0*SD_PREFER_SIBLING                   \
+                                ,                                       \
+        .last_balance           = jiffies,                              \
+        .balance_interval       = 1,                                    \
+        .smt_gain               = 1178, /* 15% */                       \
 }
 #endif
 #endif /* CONFIG_SCHED_SMT */
@@ -106,69 +115,94 @@ int arch_update_cpu_topology(void);
 #ifdef CONFIG_SCHED_MC
 /* Common values for MC siblings. for now mostly derived from SD_CPU_INIT */
 #ifndef SD_MC_INIT
-#define SD_MC_INIT (struct sched_domain) {              \
-        .min_interval           = 1,                    \
-        .max_interval           = 4,                    \
-        .busy_factor            = 64,                   \
-        .imbalance_pct          = 125,                  \
-        .cache_nice_tries       = 1,                    \
-        .busy_idx               = 2,                    \
-        .wake_idx               = 1,                    \
-        .forkexec_idx           = 1,                    \
-        .flags                  = SD_LOAD_BALANCE       \
-                                | SD_BALANCE_FORK       \
-                                | SD_BALANCE_EXEC       \
-                                | SD_WAKE_AFFINE        \
-                                | SD_WAKE_BALANCE       \
-                                | SD_SHARE_PKG_RESOURCES\
-                                | sd_balance_for_mc_power()\
-                                | sd_power_saving_flags(),\
-        .last_balance           = jiffies,              \
-        .balance_interval       = 1,                    \
+#define SD_MC_INIT (struct sched_domain) {                              \
+        .min_interval           = 1,                                    \
+        .max_interval           = 4,                                    \
+        .busy_factor            = 64,                                   \
+        .imbalance_pct          = 125,                                  \
+        .cache_nice_tries       = 1,                                    \
+        .busy_idx               = 2,                                    \
+        .wake_idx               = 1,                                    \
+        .forkexec_idx           = 1,                                    \
+                                                                        \
+        .flags                  = 1*SD_LOAD_BALANCE                     \
+                                | 1*SD_BALANCE_NEWIDLE                  \
+                                | 1*SD_BALANCE_EXEC                     \
+                                | 1*SD_BALANCE_FORK                     \
+                                | 1*SD_WAKE_IDLE                        \
+                                | 1*SD_WAKE_AFFINE                      \
+                                | 1*SD_WAKE_BALANCE                     \
+                                | 0*SD_SHARE_CPUPOWER                   \
+                                | 1*SD_SHARE_PKG_RESOURCES              \
+                                | 0*SD_SERIALIZE                        \
+                                | 0*SD_WAKE_IDLE_FAR                    \
+                                | sd_balance_for_mc_power()             \
+                                | sd_power_saving_flags()               \
+                                ,                                       \
+        .last_balance           = jiffies,                              \
+        .balance_interval       = 1,                                    \
 }
 #endif
 #endif /* CONFIG_SCHED_MC */
 
 /* Common values for CPUs */
 #ifndef SD_CPU_INIT
-#define SD_CPU_INIT (struct sched_domain) {             \
-        .min_interval           = 1,                    \
-        .max_interval           = 4,                    \
-        .busy_factor            = 64,                   \
-        .imbalance_pct          = 125,                  \
-        .cache_nice_tries       = 1,                    \
-        .busy_idx               = 2,                    \
-        .idle_idx               = 1,                    \
-        .newidle_idx            = 2,                    \
-        .wake_idx               = 1,                    \
-        .forkexec_idx           = 1,                    \
-        .flags                  = SD_LOAD_BALANCE       \
-                                | SD_BALANCE_EXEC       \
-                                | SD_BALANCE_FORK       \
-                                | SD_WAKE_AFFINE        \
-                                | SD_WAKE_BALANCE       \
-                                | sd_balance_for_package_power()\
-                                | sd_power_saving_flags(),\
-        .last_balance           = jiffies,              \
-        .balance_interval       = 1,                    \
+#define SD_CPU_INIT (struct sched_domain) {                             \
+        .min_interval           = 1,                                    \
+        .max_interval           = 4,                                    \
+        .busy_factor            = 64,                                   \
+        .imbalance_pct          = 125,                                  \
+        .cache_nice_tries       = 1,                                    \
+        .busy_idx               = 2,                                    \
+        .idle_idx               = 1,                                    \
+        .newidle_idx            = 2,                                    \
+        .wake_idx               = 1,                                    \
+        .forkexec_idx           = 1,                                    \
+                                                                        \
+        .flags                  = 1*SD_LOAD_BALANCE                     \
+                                | 1*SD_BALANCE_NEWIDLE                  \
+                                | 1*SD_BALANCE_EXEC                     \
+                                | 1*SD_BALANCE_FORK                     \
+                                | 1*SD_WAKE_IDLE                        \
+                                | 0*SD_WAKE_AFFINE                      \
+                                | 1*SD_WAKE_BALANCE                     \
+                                | 0*SD_SHARE_CPUPOWER                   \
+                                | 0*SD_SHARE_PKG_RESOURCES              \
+                                | 0*SD_SERIALIZE                        \
+                                | 0*SD_WAKE_IDLE_FAR                    \
+                                | sd_balance_for_package_power()        \
+                                | sd_power_saving_flags()               \
+                                ,                                       \
+        .last_balance           = jiffies,                              \
+        .balance_interval       = 1,                                    \
 }
 #endif
 
 /* sched_domains SD_ALLNODES_INIT for NUMA machines */
-#define SD_ALLNODES_INIT (struct sched_domain) {        \
-        .min_interval           = 64,                   \
-        .max_interval           = 64*num_online_cpus(), \
-        .busy_factor            = 128,                  \
-        .imbalance_pct          = 133,                  \
-        .cache_nice_tries       = 1,                    \
-        .busy_idx               = 3,                    \
-        .idle_idx               = 3,                    \
-        .flags                  = SD_LOAD_BALANCE       \
-                                | SD_BALANCE_NEWIDLE    \
-                                | SD_WAKE_AFFINE        \
-                                | SD_SERIALIZE,         \
-        .last_balance           = jiffies,              \
-        .balance_interval       = 64,                   \
+#define SD_ALLNODES_INIT (struct sched_domain) {                        \
+        .min_interval           = 64,                                   \
+        .max_interval           = 64*num_online_cpus(),                 \
+        .busy_factor            = 128,                                  \
+        .imbalance_pct          = 133,                                  \
+        .cache_nice_tries       = 1,                                    \
+        .busy_idx               = 3,                                    \
+        .idle_idx               = 3,                                    \
+        .flags                  = 1*SD_LOAD_BALANCE                     \
+                                | 1*SD_BALANCE_NEWIDLE                  \
+                                | 0*SD_BALANCE_EXEC                     \
+                                | 0*SD_BALANCE_FORK                     \
+                                | 0*SD_WAKE_IDLE                        \
+                                | 1*SD_WAKE_AFFINE                      \
+                                | 0*SD_WAKE_BALANCE                     \
+                                | 0*SD_SHARE_CPUPOWER                   \
+                                | 0*SD_POWERSAVINGS_BALANCE             \
+                                | 0*SD_SHARE_PKG_RESOURCES              \
+                                | 1*SD_SERIALIZE                        \
+                                | 1*SD_WAKE_IDLE_FAR                    \
+                                | 0*SD_PREFER_SIBLING                   \
+                                ,                                       \
+        .last_balance           = jiffies,                              \
+        .balance_interval       = 64,                                   \
 }
 
 #ifdef CONFIG_NUMA
diff --git a/include/linux/tracepoint.h b/include/linux/tracepoint.h
index b9dc4ca0246f..63a3f7a80580 100644
--- a/include/linux/tracepoint.h
+++ b/include/linux/tracepoint.h
@@ -23,6 +23,8 @@ struct tracepoint;
 struct tracepoint {
         const char *name;               /* Tracepoint name */
         int state;                      /* State. */
+        void (*regfunc)(void);
+        void (*unregfunc)(void);
         void **funcs;
 } __attribute__((aligned(32)));         /*
                                          * Aligned on 32 bytes because it is
@@ -78,12 +80,16 @@ struct tracepoint {
                 return tracepoint_probe_unregister(#name, (void *)probe);\
         }
 
-#define DEFINE_TRACE(name)                                              \
+
+#define DEFINE_TRACE_FN(name, reg, unreg)                               \
         static const char __tpstrtab_##name[]                           \
         __attribute__((section("__tracepoints_strings"))) = #name;      \
         struct tracepoint __tracepoint_##name                           \
         __attribute__((section("__tracepoints"), aligned(32))) =        \
-                { __tpstrtab_##name, 0, NULL }
+                { __tpstrtab_##name, 0, reg, unreg, NULL }
+
+#define DEFINE_TRACE(name)                                              \
+        DEFINE_TRACE_FN(name, NULL, NULL);
 
 #define EXPORT_TRACEPOINT_SYMBOL_GPL(name)                              \
         EXPORT_SYMBOL_GPL(__tracepoint_##name)
@@ -108,6 +114,7 @@ extern void tracepoint_update_probe_range(struct tracepoint *begin,
                 return -ENOSYS;                                         \
         }
 
+#define DEFINE_TRACE_FN(name, reg, unreg)
 #define DEFINE_TRACE(name)
 #define EXPORT_TRACEPOINT_SYMBOL_GPL(name)
 #define EXPORT_TRACEPOINT_SYMBOL(name)
@@ -158,6 +165,15 @@ static inline void tracepoint_synchronize_unregister(void)
 
 #define PARAMS(args...) args
 
+#endif /* _LINUX_TRACEPOINT_H */
+
+/*
+ * Note: we keep the TRACE_EVENT outside the include file ifdef protection.
+ *  This is due to the way trace events work. If a file includes two
+ *  trace event headers under one "CREATE_TRACE_POINTS" the first include
+ *  will override the TRACE_EVENT and break the second include.
+ */
+
 #ifndef TRACE_EVENT
 /*
  * For use with the TRACE_EVENT macro:
@@ -259,10 +275,15 @@ static inline void tracepoint_synchronize_unregister(void)
  * can also by used by generic instrumentation like SystemTap), and
  * it is also used to expose a structured trace record in
  * /sys/kernel/debug/tracing/events/.
+ *
+ * A set of (un)registration functions can be passed to the variant
+ * TRACE_EVENT_FN to perform any (un)registration work.
  */
 
 #define TRACE_EVENT(name, proto, args, struct, assign, print)   \
         DECLARE_TRACE(name, PARAMS(proto), PARAMS(args))
-#endif
+#define TRACE_EVENT_FN(name, proto, args, struct,               \
+                assign, print, reg, unreg)                      \
+        DECLARE_TRACE(name, PARAMS(proto), PARAMS(args))
 
-#endif
+#endif /* ifdef TRACE_EVENT (see note above) */
diff --git a/include/trace/define_trace.h b/include/trace/define_trace.h
index f7a7ae1e8f90..2a4b3bf74033 100644
--- a/include/trace/define_trace.h
+++ b/include/trace/define_trace.h
@@ -26,6 +26,11 @@
 #define TRACE_EVENT(name, proto, args, tstruct, assign, print)  \
         DEFINE_TRACE(name)
 
+#undef TRACE_EVENT_FN
+#define TRACE_EVENT_FN(name, proto, args, tstruct,              \
+                assign, print, reg, unreg)                      \
+        DEFINE_TRACE_FN(name, reg, unreg)
+
 #undef DECLARE_TRACE
 #define DECLARE_TRACE(name, proto, args)        \
         DEFINE_TRACE(name)
@@ -56,6 +61,8 @@
 #include <trace/ftrace.h>
 #endif
 
+#undef TRACE_EVENT
+#undef TRACE_EVENT_FN
 #undef TRACE_HEADER_MULTI_READ
 
 /* Only undef what we defined in this file */
diff --git a/include/trace/events/module.h b/include/trace/events/module.h
new file mode 100644
index 000000000000..84160fb18478
--- /dev/null
+++ b/include/trace/events/module.h
@@ -0,0 +1,126 @@
+#undef TRACE_SYSTEM
+#define TRACE_SYSTEM module
+
+#if !defined(_TRACE_MODULE_H) || defined(TRACE_HEADER_MULTI_READ)
+#define _TRACE_MODULE_H
+
+#include <linux/tracepoint.h>
+
+#ifdef CONFIG_MODULES
+
+struct module;
+
+#define show_module_flags(flags) __print_flags(flags, "",       \
+        { (1UL << TAINT_PROPRIETARY_MODULE),    "P" },          \
+        { (1UL << TAINT_FORCED_MODULE),         "F" },          \
+        { (1UL << TAINT_CRAP),                  "C" })
+
+TRACE_EVENT(module_load,
+
+        TP_PROTO(struct module *mod),
+
+        TP_ARGS(mod),
+
+        TP_STRUCT__entry(
+                __field(        unsigned int,   taints          )
+                __string(       name,           mod->name       )
+        ),
+
+        TP_fast_assign(
+                __entry->taints = mod->taints;
+                __assign_str(name, mod->name);
+        ),
+
+        TP_printk("%s %s", __get_str(name), show_module_flags(__entry->taints))
+);
+
+TRACE_EVENT(module_free,
+
+        TP_PROTO(struct module *mod),
+
+        TP_ARGS(mod),
+
+        TP_STRUCT__entry(
+                __string(       name,           mod->name       )
+        ),
+
+        TP_fast_assign(
+                __assign_str(name, mod->name);
+        ),
+
+        TP_printk("%s", __get_str(name))
+);
+
+TRACE_EVENT(module_get,
+
+        TP_PROTO(struct module *mod, unsigned long ip, int refcnt),
+
+        TP_ARGS(mod, ip, refcnt),
+
+        TP_STRUCT__entry(
+                __field(        unsigned long,  ip              )
+                __field(        int,            refcnt          )
+                __string(       name,           mod->name       )
+        ),
+
+        TP_fast_assign(
+                __entry->ip     = ip;
+                __entry->refcnt = refcnt;
+                __assign_str(name, mod->name);
+        ),
+
+        TP_printk("%s call_site=%pf refcnt=%d",
+                  __get_str(name), (void *)__entry->ip, __entry->refcnt)
+);
+
+TRACE_EVENT(module_put,
+
+        TP_PROTO(struct module *mod, unsigned long ip, int refcnt),
+
+        TP_ARGS(mod, ip, refcnt),
+
+        TP_STRUCT__entry(
+                __field(        unsigned long,  ip              )
+                __field(        int,            refcnt          )
+                __string(       name,           mod->name       )
+        ),
+
+        TP_fast_assign(
+                __entry->ip     = ip;
+                __entry->refcnt = refcnt;
+                __assign_str(name, mod->name);
+        ),
+
+        TP_printk("%s call_site=%pf refcnt=%d",
+                  __get_str(name), (void *)__entry->ip, __entry->refcnt)
+);
+
+TRACE_EVENT(module_request,
+
+        TP_PROTO(char *name, bool wait, unsigned long ip),
+
+        TP_ARGS(name, wait, ip),
+
+        TP_STRUCT__entry(
+                __field(        bool,           wait            )
+                __field(        unsigned long,  ip              )
+                __string(       name,           name            )
+        ),
+
+        TP_fast_assign(
+                __entry->wait   = wait;
+                __entry->ip     = ip;
+                __assign_str(name, name);
+        ),
+
+        TP_printk("%s wait=%d call_site=%pf",
+                  __get_str(name), (int)__entry->wait, (void *)__entry->ip)
+);
+
+#endif /* CONFIG_MODULES */
+
+#endif /* _TRACE_MODULE_H */
+
+/* This part must be outside protection */
+#include <trace/define_trace.h>
+
diff --git a/include/trace/events/sched.h b/include/trace/events/sched.h
index 8949bb7eb082..b48f1ad7c946 100644
--- a/include/trace/events/sched.h
+++ b/include/trace/events/sched.h
@@ -94,6 +94,7 @@ TRACE_EVENT(sched_wakeup,
                 __field(        pid_t,  pid                     )
                 __field(        int,    prio                    )
                 __field(        int,    success                 )
+                __field(        int,    cpu                     )
         ),
 
         TP_fast_assign(
@@ -101,11 +102,12 @@ TRACE_EVENT(sched_wakeup,
                 __entry->pid            = p->pid;
                 __entry->prio           = p->prio;
                 __entry->success        = success;
+                __entry->cpu            = task_cpu(p);
         ),
 
-        TP_printk("task %s:%d [%d] success=%d",
+        TP_printk("task %s:%d [%d] success=%d [%03d]",
                   __entry->comm, __entry->pid, __entry->prio,
-                  __entry->success)
+                  __entry->success, __entry->cpu)
 );
 
 /*
@@ -125,6 +127,7 @@ TRACE_EVENT(sched_wakeup_new,
                 __field(        pid_t,  pid                     )
                 __field(        int,    prio                    )
                 __field(        int,    success                 )
+                __field(        int,    cpu                     )
         ),
 
         TP_fast_assign(
@@ -132,11 +135,12 @@ TRACE_EVENT(sched_wakeup_new,
                 __entry->pid            = p->pid;
                 __entry->prio           = p->prio;
                 __entry->success        = success;
+                __entry->cpu            = task_cpu(p);
         ),
 
-        TP_printk("task %s:%d [%d] success=%d",
+        TP_printk("task %s:%d [%d] success=%d [%03d]",
                   __entry->comm, __entry->pid, __entry->prio,
-                  __entry->success)
+                  __entry->success, __entry->cpu)
 );
 
 /*
@@ -340,6 +344,101 @@ TRACE_EVENT(sched_signal_send,
                   __entry->sig, __entry->comm, __entry->pid)
 );
 
+/*
+ * XXX the below sched_stat tracepoints only apply to SCHED_OTHER/BATCH/IDLE
+ *     adding sched_stat support to SCHED_FIFO/RR would be welcome.
+ */
+
+/*
+ * Tracepoint for accounting wait time (time the task is runnable
+ * but not actually running due to scheduler contention).
+ */
+TRACE_EVENT(sched_stat_wait,
+
+        TP_PROTO(struct task_struct *tsk, u64 delay),
+
+        TP_ARGS(tsk, delay),
+
+        TP_STRUCT__entry(
+                __array( char,  comm,   TASK_COMM_LEN   )
+                __field( pid_t, pid                     )
+                __field( u64,   delay                   )
+        ),
+
+        TP_fast_assign(
+                memcpy(__entry->comm, tsk->comm, TASK_COMM_LEN);
+                __entry->pid    = tsk->pid;
+                __entry->delay  = delay;
+        )
+        TP_perf_assign(
+                __perf_count(delay);
+        ),
+
+        TP_printk("task: %s:%d wait: %Lu [ns]",
+                        __entry->comm, __entry->pid,
+                        (unsigned long long)__entry->delay)
+);
+
+/*
+ * Tracepoint for accounting sleep time (time the task is not runnable,
+ * including iowait, see below).
+ */
+TRACE_EVENT(sched_stat_sleep,
+
+        TP_PROTO(struct task_struct *tsk, u64 delay),
+
+        TP_ARGS(tsk, delay),
+
+        TP_STRUCT__entry(
+                __array( char,  comm,   TASK_COMM_LEN   )
+                __field( pid_t, pid                     )
+                __field( u64,   delay                   )
+        ),
+
+        TP_fast_assign(
+                memcpy(__entry->comm, tsk->comm, TASK_COMM_LEN);
+                __entry->pid    = tsk->pid;
+                __entry->delay  = delay;
+        )
+        TP_perf_assign(
+                __perf_count(delay);
+        ),
+
+        TP_printk("task: %s:%d sleep: %Lu [ns]",
+                        __entry->comm, __entry->pid,
+                        (unsigned long long)__entry->delay)
+);
+
+/*
+ * Tracepoint for accounting iowait time (time the task is not runnable
+ * due to waiting on IO to complete).
+ */
+TRACE_EVENT(sched_stat_iowait,
+
+        TP_PROTO(struct task_struct *tsk, u64 delay),
+
+        TP_ARGS(tsk, delay),
+
+        TP_STRUCT__entry(
+                __array( char,  comm,   TASK_COMM_LEN   )
+                __field( pid_t, pid                     )
+                __field( u64,   delay                   )
+        ),
+
+        TP_fast_assign(
+                memcpy(__entry->comm, tsk->comm, TASK_COMM_LEN);
+                __entry->pid    = tsk->pid;
+                __entry->delay  = delay;
+        )
+        TP_perf_assign(
+                __perf_count(delay);
+        ),
+
+        TP_printk("task: %s:%d iowait: %Lu [ns]",
+                        __entry->comm, __entry->pid,
+                        (unsigned long long)__entry->delay)
+);
+
 #endif /* _TRACE_SCHED_H */
 
 /* This part must be outside protection */
diff --git a/include/trace/events/syscalls.h b/include/trace/events/syscalls.h
new file mode 100644
index 000000000000..397dff2dbd5a
--- /dev/null
+++ b/include/trace/events/syscalls.h
@@ -0,0 +1,70 @@
+#undef TRACE_SYSTEM
+#define TRACE_SYSTEM syscalls
+
+#if !defined(_TRACE_EVENTS_SYSCALLS_H) || defined(TRACE_HEADER_MULTI_READ)
+#define _TRACE_EVENTS_SYSCALLS_H
+
+#include <linux/tracepoint.h>
+
+#include <asm/ptrace.h>
+#include <asm/syscall.h>
+
+
+#ifdef CONFIG_HAVE_SYSCALL_TRACEPOINTS
+
+extern void syscall_regfunc(void);
+extern void syscall_unregfunc(void);
+
+TRACE_EVENT_FN(sys_enter,
+
+        TP_PROTO(struct pt_regs *regs, long id),
+
+        TP_ARGS(regs, id),
+
+        TP_STRUCT__entry(
+                __field(        long,           id              )
+                __array(        unsigned long,  args,   6       )
+        ),
+
+        TP_fast_assign(
+                __entry->id     = id;
+                syscall_get_arguments(current, regs, 0, 6, __entry->args);
+        ),
+
+        TP_printk("NR %ld (%lx, %lx, %lx, %lx, %lx, %lx)",
+                  __entry->id,
+                  __entry->args[0], __entry->args[1], __entry->args[2],
+                  __entry->args[3], __entry->args[4], __entry->args[5]),
+
+        syscall_regfunc, syscall_unregfunc
+);
+
+TRACE_EVENT_FN(sys_exit,
+
+        TP_PROTO(struct pt_regs *regs, long ret),
+
+        TP_ARGS(regs, ret),
+
+        TP_STRUCT__entry(
+                __field(        long,   id      )
+                __field(        long,   ret     )
+        ),
+
+        TP_fast_assign(
+                __entry->id     = syscall_get_nr(current, regs);
+                __entry->ret    = ret;
+        ),
+
+        TP_printk("NR %ld = %ld",
+                  __entry->id, __entry->ret),
+
+        syscall_regfunc, syscall_unregfunc
+);
+
+#endif /* CONFIG_HAVE_SYSCALL_TRACEPOINTS */
+
+#endif /* _TRACE_EVENTS_SYSCALLS_H */
+
+/* This part must be outside protection */
+#include <trace/define_trace.h>
+
diff --git a/include/trace/ftrace.h b/include/trace/ftrace.h
index f64fbaae781a..308bafd93325 100644
--- a/include/trace/ftrace.h
+++ b/include/trace/ftrace.h
@@ -21,11 +21,14 @@
 #undef __field
 #define __field(type, item)             type    item;
 
+#undef __field_ext
+#define __field_ext(type, item, filter_type)    type    item;
+
 #undef __array
 #define __array(type, item, len)        type    item[len];
 
 #undef __dynamic_array
-#define __dynamic_array(type, item, len) unsigned short __data_loc_##item;
+#define __dynamic_array(type, item, len) u32 __data_loc_##item;
 
 #undef __string
 #define __string(item, src) __dynamic_array(char, item, -1)
@@ -42,6 +45,16 @@
         };                                                      \
         static struct ftrace_event_call event_##name
 
+#undef __cpparg
+#define __cpparg(arg...) arg
+
+/* Callbacks are meaningless to ftrace. */
+#undef TRACE_EVENT_FN
+#define TRACE_EVENT_FN(name, proto, args, tstruct,                      \
+                assign, print, reg, unreg)                              \
+        TRACE_EVENT(name, __cpparg(proto), __cpparg(args),              \
+                __cpparg(tstruct), __cpparg(assign), __cpparg(print))   \
+
 #include TRACE_INCLUDE(TRACE_INCLUDE_FILE)
 
 
@@ -51,23 +64,27 @@
  * Include the following:
  *
  * struct ftrace_data_offsets_<call> {
- *      int                             <item1>;
- *      int                             <item2>;
+ *      u32                             <item1>;
+ *      u32                             <item2>;
  *      [...]
  * };
  *
- * The __dynamic_array() macro will create each int <item>, this is
+ * The __dynamic_array() macro will create each u32 <item>, this is
  * to keep the offset of each array from the beginning of the event.
+ * The size of an array is also encoded, in the higher 16 bits of <item>.
  */
 
 #undef __field
-#define __field(type, item);
+#define __field(type, item)
+
+#undef __field_ext
+#define __field_ext(type, item, filter_type)
 
 #undef __array
 #define __array(type, item, len)
 
 #undef __dynamic_array
-#define __dynamic_array(type, item, len)        int item;
+#define __dynamic_array(type, item, len)        u32 item;
 
 #undef __string
 #define __string(item, src) __dynamic_array(char, item, -1)
@@ -109,6 +126,9 @@
         if (!ret)                                                       \
                 return 0;
 
+#undef __field_ext
+#define __field_ext(type, item, filter_type)    __field(type, item)
+
 #undef __array
 #define __array(type, item, len)                                                \
         ret = trace_seq_printf(s, "\tfield:" #type " " #item "[" #len "];\t"    \
@@ -120,7 +140,7 @@
 
 #undef __dynamic_array
 #define __dynamic_array(type, item, len)                                       \
-        ret = trace_seq_printf(s, "\tfield:__data_loc " #item ";\t"            \
+        ret = trace_seq_printf(s, "\tfield:__data_loc " #type "[] " #item ";\t"\
                                "offset:%u;\tsize:%u;\n",                       \
                                (unsigned int)offsetof(typeof(field),           \
                                         __data_loc_##item),                    \
@@ -150,7 +170,8 @@
 #undef TRACE_EVENT
 #define TRACE_EVENT(call, proto, args, tstruct, func, print)            \
 static int                                                              \
-ftrace_format_##call(struct trace_seq *s)                               \
+ftrace_format_##call(struct ftrace_event_call *unused,                  \
+                      struct trace_seq *s)                              \
 {                                                                       \
         struct ftrace_raw_##call field __attribute__((unused));         \
         int ret = 0;                                                    \
@@ -210,7 +231,7 @@ ftrace_format_##call(struct trace_seq *s)				\
 
 #undef __get_dynamic_array
 #define __get_dynamic_array(field)      \
-                ((void *)__entry + __entry->__data_loc_##field)
+                ((void *)__entry + (__entry->__data_loc_##field & 0xffff))
 
 #undef __get_str
 #define __get_str(field) (char *)__get_dynamic_array(field)
@@ -263,28 +284,33 @@ ftrace_raw_output_##call(struct trace_iterator *iter, int flags)	\
         
 #include TRACE_INCLUDE(TRACE_INCLUDE_FILE)
 
-#undef __field
-#define __field(type, item)                                             \
+#undef __field_ext
+#define __field_ext(type, item, filter_type)                            \
         ret = trace_define_field(event_call, #type, #item,              \
                                  offsetof(typeof(field), item),         \
-                                 sizeof(field.item), is_signed_type(type));     \
+                                 sizeof(field.item),                    \
+                                 is_signed_type(type), filter_type);    \
         if (ret)                                                        \
                 return ret;
 
+#undef __field
+#define __field(type, item)     __field_ext(type, item, FILTER_OTHER)
+
 #undef __array
 #define __array(type, item, len)                                        \
         BUILD_BUG_ON(len > MAX_FILTER_STR_VAL);                         \
         ret = trace_define_field(event_call, #type "[" #len "]", #item, \
                                  offsetof(typeof(field), item),         \
-                                 sizeof(field.item), 0);                \
+                                 sizeof(field.item), 0, FILTER_OTHER);  \
         if (ret)                                                        \
                 return ret;
 
 #undef __dynamic_array
 #define __dynamic_array(type, item, len)                                       \
-        ret = trace_define_field(event_call, "__data_loc" "[" #type "]", #item,\
-                                offsetof(typeof(field), __data_loc_##item),    \
-                                 sizeof(field.__data_loc_##item), 0);
+        ret = trace_define_field(event_call, "__data_loc " #type "[]", #item,  \
+                                 offsetof(typeof(field), __data_loc_##item),   \
+                                 sizeof(field.__data_loc_##item), 0,           \
+                                 FILTER_OTHER);
 
 #undef __string
 #define __string(item, src) __dynamic_array(char, item, -1)
@@ -292,17 +318,14 @@ ftrace_raw_output_##call(struct trace_iterator *iter, int flags)	\
 #undef TRACE_EVENT
 #define TRACE_EVENT(call, proto, args, tstruct, func, print)            \
 int                                                                     \
-ftrace_define_fields_##call(void)                                       \
+ftrace_define_fields_##call(struct ftrace_event_call *event_call)       \
 {                                                                       \
         struct ftrace_raw_##call field;                                 \
-        struct ftrace_event_call *event_call = &event_##call;           \
         int ret;                                                        \
                                                                         \
-        __common_field(int, type, 1);                                   \
-        __common_field(unsigned char, flags, 0);                        \
-        __common_field(unsigned char, preempt_count, 0);                \
-        __common_field(int, pid, 1);                                    \
-        __common_field(int, tgid, 1);                                   \
+        ret = trace_define_common_fields(event_call);                   \
+        if (ret)                                                        \
+                return ret;                                             \
                                                                         \
         tstruct;                                                        \
                                                                         \
@@ -321,6 +344,9 @@ ftrace_define_fields_##call(void)					\
 #undef __field
 #define __field(type, item)
 
+#undef __field_ext
+#define __field_ext(type, item, filter_type)
+
 #undef __array
 #define __array(type, item, len)
 
@@ -328,6 +354,7 @@ ftrace_define_fields_##call(void)					\
 #define __dynamic_array(type, item, len)                                \
         __data_offsets->item = __data_size +                            \
                                offsetof(typeof(*entry), __data);        \
+        __data_offsets->item |= (len * sizeof(type)) << 16;             \
         __data_size += (len) * sizeof(type);
 
 #undef __string
@@ -433,13 +460,15 @@ static void ftrace_profile_disable_##call(struct ftrace_event_call *event_call)\
  * {
  *      struct ring_buffer_event *event;
  *      struct ftrace_raw_<call> *entry; <-- defined in stage 1
+ *      struct ring_buffer *buffer;
  *      unsigned long irq_flags;
  *      int pc;
  *
  *      local_save_flags(irq_flags);
  *      pc = preempt_count();
  *
- *      event = trace_current_buffer_lock_reserve(event_<call>.id,
+ *      event = trace_current_buffer_lock_reserve(&buffer,
+ *                                event_<call>.id,
  *                                sizeof(struct ftrace_raw_<call>),
  *                                irq_flags, pc);
  *      if (!event)
@@ -449,7 +478,7 @@ static void ftrace_profile_disable_##call(struct ftrace_event_call *event_call)\
  *      <assign>;  <-- Here we assign the entries by the __field and
  *                      __array macros.
  *
- *      trace_current_buffer_unlock_commit(event, irq_flags, pc);
+ *      trace_current_buffer_unlock_commit(buffer, event, irq_flags, pc);
  * }
  *
  * static int ftrace_raw_reg_event_<call>(void)
@@ -541,6 +570,7 @@ static void ftrace_raw_event_##call(proto)				\
         struct ftrace_event_call *event_call = &event_##call;           \
         struct ring_buffer_event *event;                                \
         struct ftrace_raw_##call *entry;                                \
+        struct ring_buffer *buffer;                                     \
         unsigned long irq_flags;                                        \
         int __data_size;                                                \
         int pc;                                                         \
@@ -550,7 +580,8 @@ static void ftrace_raw_event_##call(proto)				\
                                                                         \
         __data_size = ftrace_get_offsets_##call(&__data_offsets, args); \
                                                                         \
-        event = trace_current_buffer_lock_reserve(event_##call.id,      \
+        event = trace_current_buffer_lock_reserve(&buffer,              \
+                                 event_##call.id,                       \
                                  sizeof(*entry) + __data_size,          \
                                  irq_flags, pc);                        \
         if (!event)                                                     \
@@ -562,11 +593,12 @@ static void ftrace_raw_event_##call(proto)				\
                                                                         \
         { assign; }                                                     \
                                                                         \
-        if (!filter_current_check_discard(event_call, entry, event))    \
-                trace_nowake_buffer_unlock_commit(event, irq_flags, pc); \
+        if (!filter_current_check_discard(buffer, event_call, entry, event)) \
+                trace_nowake_buffer_unlock_commit(buffer,               \
+                                                  event, irq_flags, pc); \
 }                                                                       \
                                                                         \
-static int ftrace_raw_reg_event_##call(void)                            \
+static int ftrace_raw_reg_event_##call(void *ptr)                       \
 {                                                                       \
         int ret;                                                        \
                                                                         \
@@ -577,7 +609,7 @@ static int ftrace_raw_reg_event_##call(void)				\
         return ret;                                                     \
 }                                                                       \
                                                                         \
-static void ftrace_raw_unreg_event_##call(void)                         \
+static void ftrace_raw_unreg_event_##call(void *ptr)                    \
 {                                                                       \
         unregister_trace_##call(ftrace_raw_event_##call);               \
 }                                                                       \
@@ -595,7 +627,6 @@ static int ftrace_raw_init_event_##call(void)				\
                 return -ENODEV;                                         \
         event_##call.id = id;                                           \
         INIT_LIST_HEAD(&event_##call.fields);                           \
-        init_preds(&event_##call);                                      \
         return 0;                                                       \
 }                                                                       \
                                                                         \
diff --git a/include/trace/syscall.h b/include/trace/syscall.h
index 8cfe515cbc47..5dc283ba5ae0 100644
--- a/include/trace/syscall.h
+++ b/include/trace/syscall.h
@@ -1,8 +1,13 @@
 #ifndef _TRACE_SYSCALL_H
 #define _TRACE_SYSCALL_H
 
+#include <linux/tracepoint.h>
+#include <linux/unistd.h>
+#include <linux/ftrace_event.h>
+
 #include <asm/ptrace.h>
 
+
 /*
  * A syscall entry in the ftrace syscalls array.
  *
@@ -10,26 +15,49 @@
  * @nb_args: number of parameters it takes
  * @types: list of types as strings
  * @args: list of args as strings (args[i] matches types[i])
+ * @enter_id: associated ftrace enter event id
+ * @exit_id: associated ftrace exit event id
+ * @enter_event: associated syscall_enter trace event
+ * @exit_event: associated syscall_exit trace event
  */
 struct syscall_metadata {
         const char      *name;
         int             nb_args;
         const char      **types;
         const char      **args;
+        int             enter_id;
+        int             exit_id;
+
+        struct ftrace_event_call *enter_event;
+        struct ftrace_event_call *exit_event;
 };
 
 #ifdef CONFIG_FTRACE_SYSCALLS
-extern void arch_init_ftrace_syscalls(void);
 extern struct syscall_metadata *syscall_nr_to_meta(int nr);
-extern void start_ftrace_syscalls(void);
-extern void stop_ftrace_syscalls(void);
-extern void ftrace_syscall_enter(struct pt_regs *regs);
-extern void ftrace_syscall_exit(struct pt_regs *regs);
-#else
-static inline void start_ftrace_syscalls(void)                  { }
-static inline void stop_ftrace_syscalls(void)                   { }
-static inline void ftrace_syscall_enter(struct pt_regs *regs)   { }
-static inline void ftrace_syscall_exit(struct pt_regs *regs)    { }
+extern int syscall_name_to_nr(char *name);
+void set_syscall_enter_id(int num, int id);
+void set_syscall_exit_id(int num, int id);
+extern struct trace_event event_syscall_enter;
+extern struct trace_event event_syscall_exit;
+extern int reg_event_syscall_enter(void *ptr);
+extern void unreg_event_syscall_enter(void *ptr);
+extern int reg_event_syscall_exit(void *ptr);
+extern void unreg_event_syscall_exit(void *ptr);
+extern int syscall_enter_format(struct ftrace_event_call *call,
+                                struct trace_seq *s);
+extern int syscall_exit_format(struct ftrace_event_call *call,
+                                struct trace_seq *s);
+extern int syscall_enter_define_fields(struct ftrace_event_call *call);
+extern int syscall_exit_define_fields(struct ftrace_event_call *call);
+enum print_line_t print_syscall_enter(struct trace_iterator *iter, int flags);
+enum print_line_t print_syscall_exit(struct trace_iterator *iter, int flags);
+#endif
+#ifdef CONFIG_EVENT_PROFILE
+int reg_prof_syscall_enter(char *name);
+void unreg_prof_syscall_enter(char *name);
+int reg_prof_syscall_exit(char *name);
+void unreg_prof_syscall_exit(char *name);
+
 #endif
 
 #endif /* _TRACE_SYSCALL_H */
diff --git a/init/Kconfig b/init/Kconfig
index 3f7e60995c80..8e8b76d8a272 100644
--- a/init/Kconfig
+++ b/init/Kconfig
@@ -316,38 +316,28 @@ choice
         prompt "RCU Implementation"
         default TREE_RCU
 
-config CLASSIC_RCU
-        bool "Classic RCU"
-        help
-          This option selects the classic RCU implementation that is
-          designed for best read-side performance on non-realtime
-          systems.
-
-          Select this option if you are unsure.
-
 config TREE_RCU
         bool "Tree-based hierarchical RCU"
         help
           This option selects the RCU implementation that is
           designed for very large SMP system with hundreds or
-          thousands of CPUs.
+          thousands of CPUs.  It also scales down nicely to
+          smaller systems.
 
-config PREEMPT_RCU
-        bool "Preemptible RCU"
+config TREE_PREEMPT_RCU
+        bool "Preemptable tree-based hierarchical RCU"
         depends on PREEMPT
         help
-          This option reduces the latency of the kernel by making certain
-          RCU sections preemptible. Normally RCU code is non-preemptible, if
-          this option is selected then read-only RCU sections become
-          preemptible. This helps latency, but may expose bugs due to
-          now-naive assumptions about each RCU read-side critical section
-          remaining on a given CPU through its execution.
+          This option selects the RCU implementation that is
+          designed for very large SMP systems with hundreds or
+          thousands of CPUs, but for which real-time response
+          is also required.
 
 endchoice
 
 config RCU_TRACE
         bool "Enable tracing for RCU"
-        depends on TREE_RCU || PREEMPT_RCU
+        depends on TREE_RCU || TREE_PREEMPT_RCU
         help
           This option provides tracing in RCU which presents stats
           in debugfs for debugging RCU implementation.
@@ -359,7 +349,7 @@ config RCU_FANOUT
         int "Tree-based hierarchical RCU fanout value"
         range 2 64 if 64BIT
         range 2 32 if !64BIT
-        depends on TREE_RCU
+        depends on TREE_RCU || TREE_PREEMPT_RCU
         default 64 if 64BIT
         default 32 if !64BIT
         help
@@ -374,7 +364,7 @@ config RCU_FANOUT
 
 config RCU_FANOUT_EXACT
         bool "Disable tree-based hierarchical RCU auto-balancing"
-        depends on TREE_RCU
+        depends on TREE_RCU || TREE_PREEMPT_RCU
         default n
         help
           This option forces use of the exact RCU_FANOUT value specified,
@@ -387,18 +377,12 @@ config RCU_FANOUT_EXACT
           Say N if unsure.
 
 config TREE_RCU_TRACE
-        def_bool RCU_TRACE && TREE_RCU
-        select DEBUG_FS
-        help
-          This option provides tracing for the TREE_RCU implementation,
-          permitting Makefile to trivially select kernel/rcutree_trace.c.
-
-config PREEMPT_RCU_TRACE
-        def_bool RCU_TRACE && PREEMPT_RCU
+        def_bool RCU_TRACE && ( TREE_RCU || TREE_PREEMPT_RCU )
         select DEBUG_FS
         help
-          This option provides tracing for the PREEMPT_RCU implementation,
-          permitting Makefile to trivially select kernel/rcupreempt_trace.c.
+          This option provides tracing for the TREE_RCU and
+          TREE_PREEMPT_RCU implementations, permitting Makefile to
+          trivially select kernel/rcutree_trace.c.
 
 endmenu # "RCU Subsystem"
 
diff --git a/init/main.c b/init/main.c
index 11f4f145be3f..b34fd8e5edef 100644
--- a/init/main.c
+++ b/init/main.c
@@ -451,6 +451,7 @@ static noinline void __init_refok rest_init(void)
 {
         int pid;
 
+        rcu_scheduler_starting();
         kernel_thread(kernel_init, NULL, CLONE_FS | CLONE_SIGHAND);
         numa_default_policy();
         pid = kernel_thread(kthreadd, NULL, CLONE_FS | CLONE_FILES);
@@ -462,7 +463,6 @@ static noinline void __init_refok rest_init(void)
          * at least once to get things moving:
          */
         init_idle_bootup_task(current);
-        rcu_scheduler_starting();
         preempt_enable_no_resched();
         schedule();
         preempt_disable();
@@ -631,7 +631,6 @@ asmlinkage void __init start_kernel(void)
         softirq_init();
         timekeeping_init();
         time_init();
-        sched_clock_init();
         profile_init();
         if (!irqs_disabled())
                 printk(KERN_CRIT "start_kernel(): bug: interrupts were "
@@ -682,6 +681,7 @@ asmlinkage void __init start_kernel(void)
         numa_policy_init();
         if (late_time_init)
                 late_time_init();
+        sched_clock_init();
         calibrate_delay();
         pidmap_init();
         anon_vma_init();
diff --git a/kernel/Makefile b/kernel/Makefile
index 2093a691f1c2..b833bd5cc127 100644
--- a/kernel/Makefile
+++ b/kernel/Makefile
@@ -80,11 +80,9 @@ obj-$(CONFIG_DETECT_HUNG_TASK) += hung_task.o
 obj-$(CONFIG_GENERIC_HARDIRQS) += irq/
 obj-$(CONFIG_SECCOMP) += seccomp.o
 obj-$(CONFIG_RCU_TORTURE_TEST) += rcutorture.o
-obj-$(CONFIG_CLASSIC_RCU) += rcuclassic.o
 obj-$(CONFIG_TREE_RCU) += rcutree.o
-obj-$(CONFIG_PREEMPT_RCU) += rcupreempt.o
+obj-$(CONFIG_TREE_PREEMPT_RCU) += rcutree.o
 obj-$(CONFIG_TREE_RCU_TRACE) += rcutree_trace.o
-obj-$(CONFIG_PREEMPT_RCU_TRACE) += rcupreempt_trace.o
 obj-$(CONFIG_RELAY) += relay.o
 obj-$(CONFIG_SYSCTL) += utsname_sysctl.o
 obj-$(CONFIG_TASK_DELAY_ACCT) += delayacct.o
diff --git a/kernel/exit.c b/kernel/exit.c
index c98ff7a8025f..ae5d8660ddff 100644
--- a/kernel/exit.c
+++ b/kernel/exit.c
@@ -1014,6 +1014,7 @@ NORET_TYPE void do_exit(long code)
         validate_creds_for_do_exit(tsk);
 
         preempt_disable();
+        exit_rcu();
         /* causes final put_task_struct in finish_task_switch(). */
         tsk->state = TASK_DEAD;
         schedule();
diff --git a/kernel/fork.c b/kernel/fork.c
index aab8579c6093..bfee931ee3fb 100644
--- a/kernel/fork.c
+++ b/kernel/fork.c
@@ -1007,10 +1007,7 @@ static struct task_struct *copy_process(unsigned long clone_flags,
         copy_flags(clone_flags, p);
         INIT_LIST_HEAD(&p->children);
         INIT_LIST_HEAD(&p->sibling);
-#ifdef CONFIG_PREEMPT_RCU
-        p->rcu_read_lock_nesting = 0;
-        p->rcu_flipctr_idx = 0;
-#endif /* #ifdef CONFIG_PREEMPT_RCU */
+        rcu_copy_process(p);
         p->vfork_done = NULL;
         spin_lock_init(&p->alloc_lock);
 
diff --git a/kernel/futex.c b/kernel/futex.c
index e18cfbdc7190..248dd119a86e 100644
--- a/kernel/futex.c
+++ b/kernel/futex.c
@@ -115,6 +115,9 @@ struct futex_q {
         /* rt_waiter storage for requeue_pi: */
         struct rt_mutex_waiter *rt_waiter;
 
+        /* The expected requeue pi target futex key: */
+        union futex_key *requeue_pi_key;
+
         /* Bitset for the optional bitmasked wakeup */
         u32 bitset;
 };
@@ -1089,6 +1092,10 @@ static int futex_proxy_trylock_atomic(u32 __user *pifutex,
         if (!top_waiter)
                 return 0;
 
+        /* Ensure we requeue to the expected futex. */
+        if (!match_futex(top_waiter->requeue_pi_key, key2))
+                return -EINVAL;
+
         /*
          * Try to take the lock for top_waiter.  Set the FUTEX_WAITERS bit in
          * the contended case or if set_waiters is 1.  The pi_state is returned
@@ -1276,6 +1283,12 @@ retry_private:
                         continue;
                 }
 
+                /* Ensure we requeue to the expected futex for requeue_pi. */
+                if (requeue_pi && !match_futex(this->requeue_pi_key, &key2)) {
+                        ret = -EINVAL;
+                        break;
+                }
+
                 /*
                  * Requeue nr_requeue waiters and possibly one more in the case
                  * of requeue_pi if we couldn't acquire the lock atomically.
@@ -1751,6 +1764,7 @@ static int futex_wait(u32 __user *uaddr, int fshared,
         q.pi_state = NULL;
         q.bitset = bitset;
         q.rt_waiter = NULL;
+        q.requeue_pi_key = NULL;
 
         if (abs_time) {
                 to = &timeout;
@@ -1858,6 +1872,7 @@ static int futex_lock_pi(u32 __user *uaddr, int fshared,
 
         q.pi_state = NULL;
         q.rt_waiter = NULL;
+        q.requeue_pi_key = NULL;
 retry:
         q.key = FUTEX_KEY_INIT;
         ret = get_futex_key(uaddr, fshared, &q.key, VERIFY_WRITE);
@@ -2118,11 +2133,11 @@ int handle_early_requeue_pi_wakeup(struct futex_hash_bucket *hb,
  * We call schedule in futex_wait_queue_me() when we enqueue and return there
  * via the following:
  * 1) wakeup on uaddr2 after an atomic lock acquisition by futex_requeue()
- * 2) wakeup on uaddr2 after a requeue and subsequent unlock
- * 3) signal (before or after requeue)
- * 4) timeout (before or after requeue)
+ * 2) wakeup on uaddr2 after a requeue
+ * 3) signal
+ * 4) timeout
  *
- * If 3, we setup a restart_block with futex_wait_requeue_pi() as the function.
+ * If 3, cleanup and return -ERESTARTNOINTR.
  *
  * If 2, we may then block on trying to take the rt_mutex and return via:
  * 5) successful lock
@@ -2130,7 +2145,7 @@ int handle_early_requeue_pi_wakeup(struct futex_hash_bucket *hb,
  * 7) timeout
  * 8) other lock acquisition failure
  *
- * If 6, we setup a restart_block with futex_lock_pi() as the function.
+ * If 6, return -EWOULDBLOCK (restarting the syscall would do the same).
  *
  * If 4 or 7, we cleanup and return with -ETIMEDOUT.
  *
@@ -2169,15 +2184,16 @@ static int futex_wait_requeue_pi(u32 __user *uaddr, int fshared,
         debug_rt_mutex_init_waiter(&rt_waiter);
         rt_waiter.task = NULL;
 
-        q.pi_state = NULL;
-        q.bitset = bitset;
-        q.rt_waiter = &rt_waiter;
-
         key2 = FUTEX_KEY_INIT;
         ret = get_futex_key(uaddr2, fshared, &key2, VERIFY_WRITE);
         if (unlikely(ret != 0))
                 goto out;
 
+        q.pi_state = NULL;
+        q.bitset = bitset;
+        q.rt_waiter = &rt_waiter;
+        q.requeue_pi_key = &key2;
+
         /* Prepare to wait on uaddr. */
         ret = futex_wait_setup(uaddr, val, fshared, &q, &hb);
         if (ret)
@@ -2248,14 +2264,11 @@ static int futex_wait_requeue_pi(u32 __user *uaddr, int fshared,
                         rt_mutex_unlock(pi_mutex);
         } else if (ret == -EINTR) {
                 /*
-                 * We've already been requeued, but we have no way to
-                 * restart by calling futex_lock_pi() directly. We
-                 * could restart the syscall, but that will look at
-                 * the user space value and return right away. So we
-                 * drop back with EWOULDBLOCK to tell user space that
-                 * "val" has been changed. That's the same what the
-                 * restart of the syscall would do in
-                 * futex_wait_setup().
+                 * We've already been requeued, but cannot restart by calling
+                 * futex_lock_pi() directly. We could restart this syscall, but
+                 * it would detect that the user space "val" changed and return
+                 * -EWOULDBLOCK.  Save the overhead of the restart and return
+                 * -EWOULDBLOCK directly.
                  */
                 ret = -EWOULDBLOCK;
         }
diff --git a/kernel/irq/chip.c b/kernel/irq/chip.c
index 13c68e71b726..c1660194d115 100644
--- a/kernel/irq/chip.c
+++ b/kernel/irq/chip.c
@@ -222,6 +222,34 @@ int set_irq_chip_data(unsigned int irq, void *data)
 }
 EXPORT_SYMBOL(set_irq_chip_data);
 
+/**
+ *      set_irq_nested_thread - Set/Reset the IRQ_NESTED_THREAD flag of an irq
+ *
+ *      @irq:   Interrupt number
+ *      @nest:  0 to clear / 1 to set the IRQ_NESTED_THREAD flag
+ *
+ *      The IRQ_NESTED_THREAD flag indicates that on
+ *      request_threaded_irq() no separate interrupt thread should be
+ *      created for the irq as the handler are called nested in the
+ *      context of a demultiplexing interrupt handler thread.
+ */
+void set_irq_nested_thread(unsigned int irq, int nest)
+{
+        struct irq_desc *desc = irq_to_desc(irq);
+        unsigned long flags;
+
+        if (!desc)
+                return;
+
+        spin_lock_irqsave(&desc->lock, flags);
+        if (nest)
+                desc->status |= IRQ_NESTED_THREAD;
+        else
+                desc->status &= ~IRQ_NESTED_THREAD;
+        spin_unlock_irqrestore(&desc->lock, flags);
+}
+EXPORT_SYMBOL_GPL(set_irq_nested_thread);
+
 /*
  * default enable function
  */
@@ -299,6 +327,45 @@ static inline void mask_ack_irq(struct irq_desc *desc, int irq)
         }
 }
 
+/*
+ *      handle_nested_irq - Handle a nested irq from a irq thread
+ *      @irq:   the interrupt number
+ *
+ *      Handle interrupts which are nested into a threaded interrupt
+ *      handler. The handler function is called inside the calling
+ *      threads context.
+ */
+void handle_nested_irq(unsigned int irq)
+{
+        struct irq_desc *desc = irq_to_desc(irq);
+        struct irqaction *action;
+        irqreturn_t action_ret;
+
+        might_sleep();
+
+        spin_lock_irq(&desc->lock);
+
+        kstat_incr_irqs_this_cpu(irq, desc);
+
+        action = desc->action;
+        if (unlikely(!action || (desc->status & IRQ_DISABLED)))
+                goto out_unlock;
+
+        desc->status |= IRQ_INPROGRESS;
+        spin_unlock_irq(&desc->lock);
+
+        action_ret = action->thread_fn(action->irq, action->dev_id);
+        if (!noirqdebug)
+                note_interrupt(irq, desc, action_ret);
+
+        spin_lock_irq(&desc->lock);
+        desc->status &= ~IRQ_INPROGRESS;
+
+out_unlock:
+        spin_unlock_irq(&desc->lock);
+}
+EXPORT_SYMBOL_GPL(handle_nested_irq);
+
 /**
  *      handle_simple_irq - Simple and software-decoded IRQs.
  *      @irq:   the interrupt number
@@ -382,7 +449,10 @@ handle_level_irq(unsigned int irq, struct irq_desc *desc)
 
         spin_lock(&desc->lock);
         desc->status &= ~IRQ_INPROGRESS;
-        if (!(desc->status & IRQ_DISABLED) && desc->chip->unmask)
+
+        if (unlikely(desc->status & IRQ_ONESHOT))
+                desc->status |= IRQ_MASKED;
+        else if (!(desc->status & IRQ_DISABLED) && desc->chip->unmask)
                 desc->chip->unmask(irq);
 out_unlock:
         spin_unlock(&desc->lock);
@@ -572,6 +642,7 @@ __set_irq_handler(unsigned int irq, irq_flow_handler_t handle, int is_chained,
                 desc->chip = &dummy_irq_chip;
         }
 
+        chip_bus_lock(irq, desc);
         spin_lock_irqsave(&desc->lock, flags);
 
         /* Uninstall? */
@@ -591,6 +662,7 @@ __set_irq_handler(unsigned int irq, irq_flow_handler_t handle, int is_chained,
                 desc->chip->startup(irq);
         }
         spin_unlock_irqrestore(&desc->lock, flags);
+        chip_bus_sync_unlock(irq, desc);
 }
 EXPORT_SYMBOL_GPL(__set_irq_handler);
 
diff --git a/kernel/irq/handle.c b/kernel/irq/handle.c
index 065205bdd920..a81cf80554db 100644
--- a/kernel/irq/handle.c
+++ b/kernel/irq/handle.c
@@ -161,7 +161,7 @@ int __init early_irq_init(void)
 
         desc = irq_desc_legacy;
         legacy_count = ARRAY_SIZE(irq_desc_legacy);
-        node = first_online_node;
+        node = first_online_node;
 
         /* allocate irq_desc_ptrs array based on nr_irqs */
         irq_desc_ptrs = kcalloc(nr_irqs, sizeof(void *), GFP_NOWAIT);
@@ -172,6 +172,9 @@ int __init early_irq_init(void)
 
         for (i = 0; i < legacy_count; i++) {
                 desc[i].irq = i;
+#ifdef CONFIG_SMP
+                desc[i].node = node;
+#endif
                 desc[i].kstat_irqs = kstat_irqs_legacy + i * nr_cpu_ids;
                 lockdep_set_class(&desc[i].lock, &irq_desc_lock_class);
                 alloc_desc_masks(&desc[i], node, true);
diff --git a/kernel/irq/internals.h b/kernel/irq/internals.h
index e70ed5592eb9..1b5d742c6a77 100644
--- a/kernel/irq/internals.h
+++ b/kernel/irq/internals.h
@@ -44,6 +44,19 @@ extern int irq_select_affinity_usr(unsigned int irq);
 
 extern void irq_set_thread_affinity(struct irq_desc *desc);
 
+/* Inline functions for support of irq chips on slow busses */
+static inline void chip_bus_lock(unsigned int irq, struct irq_desc *desc)
+{
+        if (unlikely(desc->chip->bus_lock))
+                desc->chip->bus_lock(irq);
+}
+
+static inline void chip_bus_sync_unlock(unsigned int irq, struct irq_desc *desc)
+{
+        if (unlikely(desc->chip->bus_sync_unlock))
+                desc->chip->bus_sync_unlock(irq);
+}
+
 /*
  * Debugging printout:
  */
diff --git a/kernel/irq/manage.c b/kernel/irq/manage.c
index 0ec9ed831737..bde4c667d24d 100644
--- a/kernel/irq/manage.c
+++ b/kernel/irq/manage.c
@@ -230,9 +230,11 @@ void disable_irq_nosync(unsigned int irq)
         if (!desc)
                 return;
 
+        chip_bus_lock(irq, desc);
         spin_lock_irqsave(&desc->lock, flags);
         __disable_irq(desc, irq, false);
         spin_unlock_irqrestore(&desc->lock, flags);
+        chip_bus_sync_unlock(irq, desc);
 }
 EXPORT_SYMBOL(disable_irq_nosync);
 
@@ -294,7 +296,8 @@ void __enable_irq(struct irq_desc *desc, unsigned int irq, bool resume)
  *      matches the last disable, processing of interrupts on this
  *      IRQ line is re-enabled.
  *
- *      This function may be called from IRQ context.
+ *      This function may be called from IRQ context only when
+ *      desc->chip->bus_lock and desc->chip->bus_sync_unlock are NULL !
  */
 void enable_irq(unsigned int irq)
 {
@@ -304,9 +307,11 @@ void enable_irq(unsigned int irq)
         if (!desc)
                 return;
 
+        chip_bus_lock(irq, desc);
         spin_lock_irqsave(&desc->lock, flags);
         __enable_irq(desc, irq, false);
         spin_unlock_irqrestore(&desc->lock, flags);
+        chip_bus_sync_unlock(irq, desc);
 }
 EXPORT_SYMBOL(enable_irq);
 
@@ -436,6 +441,26 @@ int __irq_set_trigger(struct irq_desc *desc, unsigned int irq,
         return ret;
 }
 
+/*
+ * Default primary interrupt handler for threaded interrupts. Is
+ * assigned as primary handler when request_threaded_irq is called
+ * with handler == NULL. Useful for oneshot interrupts.
+ */
+static irqreturn_t irq_default_primary_handler(int irq, void *dev_id)
+{
+        return IRQ_WAKE_THREAD;
+}
+
+/*
+ * Primary handler for nested threaded interrupts. Should never be
+ * called.
+ */
+static irqreturn_t irq_nested_primary_handler(int irq, void *dev_id)
+{
+        WARN(1, "Primary handler called for nested irq %d\n", irq);
+        return IRQ_NONE;
+}
+
 static int irq_wait_for_interrupt(struct irqaction *action)
 {
         while (!kthread_should_stop()) {
@@ -451,6 +476,23 @@ static int irq_wait_for_interrupt(struct irqaction *action)
         return -1;
 }
 
+/*
+ * Oneshot interrupts keep the irq line masked until the threaded
+ * handler finished. unmask if the interrupt has not been disabled and
+ * is marked MASKED.
+ */
+static void irq_finalize_oneshot(unsigned int irq, struct irq_desc *desc)
+{
+        chip_bus_lock(irq, desc);
+        spin_lock_irq(&desc->lock);
+        if (!(desc->status & IRQ_DISABLED) && (desc->status & IRQ_MASKED)) {
+                desc->status &= ~IRQ_MASKED;
+                desc->chip->unmask(irq);
+        }
+        spin_unlock_irq(&desc->lock);
+        chip_bus_sync_unlock(irq, desc);
+}
+
 #ifdef CONFIG_SMP
 /*
  * Check whether we need to change the affinity of the interrupt thread.
@@ -492,7 +534,7 @@ static int irq_thread(void *data)
         struct sched_param param = { .sched_priority = MAX_USER_RT_PRIO/2, };
         struct irqaction *action = data;
         struct irq_desc *desc = irq_to_desc(action->irq);
-        int wake;
+        int wake, oneshot = desc->status & IRQ_ONESHOT;
 
         sched_setscheduler(current, SCHED_FIFO, &param);
         current->irqaction = action;
@@ -518,6 +560,9 @@ static int irq_thread(void *data)
                         spin_unlock_irq(&desc->lock);
 
                         action->thread_fn(action->irq, action->dev_id);
+
+                        if (oneshot)
+                                irq_finalize_oneshot(action->irq, desc);
                 }
 
                 wake = atomic_dec_and_test(&desc->threads_active);
@@ -565,7 +610,7 @@ __setup_irq(unsigned int irq, struct irq_desc *desc, struct irqaction *new)
         struct irqaction *old, **old_ptr;
         const char *old_name = NULL;
         unsigned long flags;
-        int shared = 0;
+        int nested, shared = 0;
         int ret;
 
         if (!desc)
@@ -590,10 +635,32 @@ __setup_irq(unsigned int irq, struct irq_desc *desc, struct irqaction *new)
                 rand_initialize_irq(irq);
         }
 
+        /* Oneshot interrupts are not allowed with shared */
+        if ((new->flags & IRQF_ONESHOT) && (new->flags & IRQF_SHARED))
+                return -EINVAL;
+
+        /*
+         * Check whether the interrupt nests into another interrupt
+         * thread.
+         */
+        nested = desc->status & IRQ_NESTED_THREAD;
+        if (nested) {
+                if (!new->thread_fn)
+                        return -EINVAL;
+                /*
+                 * Replace the primary handler which was provided from
+                 * the driver for non nested interrupt handling by the
+                 * dummy function which warns when called.
+                 */
+                new->handler = irq_nested_primary_handler;
+        }
+
         /*
-         * Threaded handler ?
+         * Create a handler thread when a thread function is supplied
+         * and the interrupt does not nest into another interrupt
+         * thread.
          */
-        if (new->thread_fn) {
+        if (new->thread_fn && !nested) {
                 struct task_struct *t;
 
                 t = kthread_create(irq_thread, new, "irq/%d-%s", irq,
@@ -662,9 +729,12 @@ __setup_irq(unsigned int irq, struct irq_desc *desc, struct irqaction *new)
                         desc->status |= IRQ_PER_CPU;
 #endif
 
-                desc->status &= ~(IRQ_AUTODETECT | IRQ_WAITING |
+                desc->status &= ~(IRQ_AUTODETECT | IRQ_WAITING | IRQ_ONESHOT |
                                   IRQ_INPROGRESS | IRQ_SPURIOUS_DISABLED);
 
+                if (new->flags & IRQF_ONESHOT)
+                        desc->status |= IRQ_ONESHOT;
+
                 if (!(desc->status & IRQ_NOAUTOEN)) {
                         desc->depth = 0;
                         desc->status &= ~IRQ_DISABLED;
@@ -875,7 +945,14 @@ EXPORT_SYMBOL_GPL(remove_irq);
  */
 void free_irq(unsigned int irq, void *dev_id)
 {
+        struct irq_desc *desc = irq_to_desc(irq);
+
+        if (!desc)
+                return;
+
+        chip_bus_lock(irq, desc);
         kfree(__free_irq(irq, dev_id));
+        chip_bus_sync_unlock(irq, desc);
 }
 EXPORT_SYMBOL(free_irq);
 
@@ -884,6 +961,8 @@ EXPORT_SYMBOL(free_irq);
  *      @irq: Interrupt line to allocate
  *      @handler: Function to be called when the IRQ occurs.
  *                Primary handler for threaded interrupts
+ *                If NULL and thread_fn != NULL the default
+ *                primary handler is installed
  *      @thread_fn: Function called from the irq handler thread
  *                  If NULL, no irq thread is created
  *      @irqflags: Interrupt type flags
@@ -963,8 +1042,12 @@ int request_threaded_irq(unsigned int irq, irq_handler_t handler,
 
         if (desc->status & IRQ_NOREQUEST)
                 return -EINVAL;
-        if (!handler)
-                return -EINVAL;
+
+        if (!handler) {
+                if (!thread_fn)
+                        return -EINVAL;
+                handler = irq_default_primary_handler;
+        }
 
         action = kzalloc(sizeof(struct irqaction), GFP_KERNEL);
         if (!action)
@@ -976,7 +1059,10 @@ int request_threaded_irq(unsigned int irq, irq_handler_t handler,
         action->name = devname;
         action->dev_id = dev_id;
 
+        chip_bus_lock(irq, desc);
         retval = __setup_irq(irq, desc, action);
+        chip_bus_sync_unlock(irq, desc);
+
         if (retval)
                 kfree(action);
 
diff --git a/kernel/irq/pm.c b/kernel/irq/pm.c
index 638d8bedec14..a0bb09e79867 100644
--- a/kernel/irq/pm.c
+++ b/kernel/irq/pm.c
@@ -15,10 +15,10 @@
 /**
  * suspend_device_irqs - disable all currently enabled interrupt lines
  *
- * During system-wide suspend or hibernation device interrupts need to be
- * disabled at the chip level and this function is provided for this purpose.
- * It disables all interrupt lines that are enabled at the moment and sets the
- * IRQ_SUSPENDED flag for them.
+ * During system-wide suspend or hibernation device drivers need to be prevented
+ * from receiving interrupts and this function is provided for this purpose.
+ * It marks all interrupt lines in use, except for the timer ones, as disabled
+ * and sets the IRQ_SUSPENDED flag for each of them.
  */
 void suspend_device_irqs(void)
 {
diff --git a/kernel/irq/resend.c b/kernel/irq/resend.c
index 89c7117acf2b..090c3763f3a2 100644
--- a/kernel/irq/resend.c
+++ b/kernel/irq/resend.c
@@ -70,8 +70,7 @@ void check_irq_resend(struct irq_desc *desc, unsigned int irq)
         if ((status & (IRQ_LEVEL | IRQ_PENDING | IRQ_REPLAY)) == IRQ_PENDING) {
                 desc->status = (status & ~IRQ_PENDING) | IRQ_REPLAY;
 
-                if (!desc->chip || !desc->chip->retrigger ||
-                                        !desc->chip->retrigger(irq)) {
+                if (!desc->chip->retrigger || !desc->chip->retrigger(irq)) {
 #ifdef CONFIG_HARDIRQS_SW_RESEND
                         /* Set it pending and activate the softirq: */
                         set_bit(irq, irqs_resend);
diff --git a/kernel/irq/spurious.c b/kernel/irq/spurious.c
index 4d568294de3e..114e704760fe 100644
--- a/kernel/irq/spurious.c
+++ b/kernel/irq/spurious.c
@@ -297,7 +297,6 @@ static int __init irqfixup_setup(char *str)
 
 __setup("irqfixup", irqfixup_setup);
 module_param(irqfixup, int, 0644);
-MODULE_PARM_DESC("irqfixup", "0: No fixup, 1: irqfixup mode, 2: irqpoll mode");
 
 static int __init irqpoll_setup(char *str)
 {
diff --git a/kernel/kmod.c b/kernel/kmod.c
index 4e8cae2e9148..9fcb53a11f87 100644
--- a/kernel/kmod.c
+++ b/kernel/kmod.c
@@ -37,6 +37,8 @@
 #include <linux/suspend.h>
 #include <asm/uaccess.h>
 
+#include <trace/events/module.h>
+
 extern int max_threads;
 
 static struct workqueue_struct *khelper_wq;
@@ -112,6 +114,8 @@ int __request_module(bool wait, const char *fmt, ...)
                 return -ENOMEM;
         }
 
+        trace_module_request(module_name, wait, _RET_IP_);
+
         ret = call_usermodehelper(modprobe_path, argv, envp,
                         wait ? UMH_WAIT_PROC : UMH_WAIT_EXEC);
         atomic_dec(&kmod_concurrent);
diff --git a/kernel/kprobes.c b/kernel/kprobes.c
index 0540948e29ab..ef177d653b2c 100644
--- a/kernel/kprobes.c
+++ b/kernel/kprobes.c
@@ -103,7 +103,7 @@ static struct kprobe_blackpoint kprobe_blacklist[] = {
 #define INSNS_PER_PAGE  (PAGE_SIZE/(MAX_INSN_SIZE * sizeof(kprobe_opcode_t)))
 
 struct kprobe_insn_page {
-        struct hlist_node hlist;
+        struct list_head list;
         kprobe_opcode_t *insns;         /* Page of instruction slots */
         char slot_used[INSNS_PER_PAGE];
         int nused;
@@ -117,7 +117,7 @@ enum kprobe_slot_state {
 };
 
 static DEFINE_MUTEX(kprobe_insn_mutex); /* Protects kprobe_insn_pages */
-static struct hlist_head kprobe_insn_pages;
+static LIST_HEAD(kprobe_insn_pages);
 static int kprobe_garbage_slots;
 static int collect_garbage_slots(void);
 
@@ -152,10 +152,9 @@ loop_end:
 static kprobe_opcode_t __kprobes *__get_insn_slot(void)
 {
         struct kprobe_insn_page *kip;
-        struct hlist_node *pos;
 
  retry:
-        hlist_for_each_entry(kip, pos, &kprobe_insn_pages, hlist) {
+        list_for_each_entry(kip, &kprobe_insn_pages, list) {
                 if (kip->nused < INSNS_PER_PAGE) {
                         int i;
                         for (i = 0; i < INSNS_PER_PAGE; i++) {
@@ -189,8 +188,8 @@ static kprobe_opcode_t __kprobes *__get_insn_slot(void)
                 kfree(kip);
                 return NULL;
         }
-        INIT_HLIST_NODE(&kip->hlist);
-        hlist_add_head(&kip->hlist, &kprobe_insn_pages);
+        INIT_LIST_HEAD(&kip->list);
+        list_add(&kip->list, &kprobe_insn_pages);
         memset(kip->slot_used, SLOT_CLEAN, INSNS_PER_PAGE);
         kip->slot_used[0] = SLOT_USED;
         kip->nused = 1;
@@ -219,12 +218,8 @@ static int __kprobes collect_one_slot(struct kprobe_insn_page *kip, int idx)
                  * so as not to have to set it up again the
                  * next time somebody inserts a probe.
                  */
-                hlist_del(&kip->hlist);
-                if (hlist_empty(&kprobe_insn_pages)) {
-                        INIT_HLIST_NODE(&kip->hlist);
-                        hlist_add_head(&kip->hlist,
-                                       &kprobe_insn_pages);
-                } else {
+                if (!list_is_singular(&kprobe_insn_pages)) {
+                        list_del(&kip->list);
                         module_free(NULL, kip->insns);
                         kfree(kip);
                 }
@@ -235,14 +230,13 @@ static int __kprobes collect_one_slot(struct kprobe_insn_page *kip, int idx)
 
 static int __kprobes collect_garbage_slots(void)
 {
-        struct kprobe_insn_page *kip;
-        struct hlist_node *pos, *next;
+        struct kprobe_insn_page *kip, *next;
 
         /* Ensure no-one is preepmted on the garbages */
         if (check_safety())
                 return -EAGAIN;
 
-        hlist_for_each_entry_safe(kip, pos, next, &kprobe_insn_pages, hlist) {
+        list_for_each_entry_safe(kip, next, &kprobe_insn_pages, list) {
                 int i;
                 if (kip->ngarbage == 0)
                         continue;
@@ -260,19 +254,17 @@ static int __kprobes collect_garbage_slots(void)
 void __kprobes free_insn_slot(kprobe_opcode_t * slot, int dirty)
 {
         struct kprobe_insn_page *kip;
-        struct hlist_node *pos;
 
         mutex_lock(&kprobe_insn_mutex);
-        hlist_for_each_entry(kip, pos, &kprobe_insn_pages, hlist) {
+        list_for_each_entry(kip, &kprobe_insn_pages, list) {
                 if (kip->insns <= slot &&
                     slot < kip->insns + (INSNS_PER_PAGE * MAX_INSN_SIZE)) {
                         int i = (slot - kip->insns) / MAX_INSN_SIZE;
                         if (dirty) {
                                 kip->slot_used[i] = SLOT_DIRTY;
                                 kip->ngarbage++;
-                        } else {
+                        } else
                                 collect_one_slot(kip, i);
-                        }
                         break;
                 }
         }
diff --git a/kernel/kthread.c b/kernel/kthread.c
index eb8751aa0418..5fe709982caa 100644
--- a/kernel/kthread.c
+++ b/kernel/kthread.c
@@ -16,8 +16,6 @@
 #include <linux/mutex.h>
 #include <trace/events/sched.h>
 
-#define KTHREAD_NICE_LEVEL (-5)
-
 static DEFINE_SPINLOCK(kthread_create_lock);
 static LIST_HEAD(kthread_create_list);
 struct task_struct *kthreadd_task;
@@ -145,7 +143,6 @@ struct task_struct *kthread_create(int (*threadfn)(void *data),
                  * The kernel thread should not inherit these properties.
                  */
                 sched_setscheduler_nocheck(create.result, SCHED_NORMAL, &param);
-                set_user_nice(create.result, KTHREAD_NICE_LEVEL);
                 set_cpus_allowed_ptr(create.result, cpu_all_mask);
         }
         return create.result;
@@ -221,7 +218,6 @@ int kthreadd(void *unused)
         /* Setup a clean context for our children to inherit. */
         set_task_comm(tsk, "kthreadd");
         ignore_signals(tsk);
-        set_user_nice(tsk, KTHREAD_NICE_LEVEL);
         set_cpus_allowed_ptr(tsk, cpu_all_mask);
         set_mems_allowed(node_possible_map);
 
diff --git a/kernel/lockdep.c b/kernel/lockdep.c
index 8bbeef996c76..f74d2d7aa605 100644
--- a/kernel/lockdep.c
+++ b/kernel/lockdep.c
@@ -42,6 +42,7 @@
 #include <linux/hash.h>
 #include <linux/ftrace.h>
 #include <linux/stringify.h>
+#include <linux/bitops.h>
 
 #include <asm/sections.h>
 
@@ -366,11 +367,21 @@ static int save_trace(struct stack_trace *trace)
 
         save_stack_trace(trace);
 
+        /*
+         * Some daft arches put -1 at the end to indicate its a full trace.
+         *
+         * <rant> this is buggy anyway, since it takes a whole extra entry so a
+         * complete trace that maxes out the entries provided will be reported
+         * as incomplete, friggin useless </rant>
+         */
+        if (trace->entries[trace->nr_entries-1] == ULONG_MAX)
+                trace->nr_entries--;
+
         trace->max_entries = trace->nr_entries;
 
         nr_stack_trace_entries += trace->nr_entries;
 
-        if (nr_stack_trace_entries == MAX_STACK_TRACE_ENTRIES) {
+        if (nr_stack_trace_entries >= MAX_STACK_TRACE_ENTRIES-1) {
                 if (!debug_locks_off_graph_unlock())
                         return 0;
 
@@ -388,20 +399,6 @@ unsigned int nr_hardirq_chains;
 unsigned int nr_softirq_chains;
 unsigned int nr_process_chains;
 unsigned int max_lockdep_depth;
-unsigned int max_recursion_depth;
-
-static unsigned int lockdep_dependency_gen_id;
-
-static bool lockdep_dependency_visit(struct lock_class *source,
-                                     unsigned int depth)
-{
-        if (!depth)
-                lockdep_dependency_gen_id++;
-        if (source->dep_gen_id == lockdep_dependency_gen_id)
-                return true;
-        source->dep_gen_id = lockdep_dependency_gen_id;
-        return false;
-}
 
 #ifdef CONFIG_DEBUG_LOCKDEP
 /*
@@ -431,11 +428,8 @@ atomic_t redundant_softirqs_on;
 atomic_t redundant_softirqs_off;
 atomic_t nr_unused_locks;
 atomic_t nr_cyclic_checks;
-atomic_t nr_cyclic_check_recursions;
 atomic_t nr_find_usage_forwards_checks;
-atomic_t nr_find_usage_forwards_recursions;
 atomic_t nr_find_usage_backwards_checks;
-atomic_t nr_find_usage_backwards_recursions;
 #endif
 
 /*
@@ -551,58 +545,6 @@ static void lockdep_print_held_locks(struct task_struct *curr)
         }
 }
 
-static void print_lock_class_header(struct lock_class *class, int depth)
-{
-        int bit;
-
-        printk("%*s->", depth, "");
-        print_lock_name(class);
-        printk(" ops: %lu", class->ops);
-        printk(" {\n");
-
-        for (bit = 0; bit < LOCK_USAGE_STATES; bit++) {
-                if (class->usage_mask & (1 << bit)) {
-                        int len = depth;
-
-                        len += printk("%*s   %s", depth, "", usage_str[bit]);
-                        len += printk(" at:\n");
-                        print_stack_trace(class->usage_traces + bit, len);
-                }
-        }
-        printk("%*s }\n", depth, "");
-
-        printk("%*s ... key      at: ",depth,"");
-        print_ip_sym((unsigned long)class->key);
-}
-
-/*
- * printk all lock dependencies starting at <entry>:
- */
-static void __used
-print_lock_dependencies(struct lock_class *class, int depth)
-{
-        struct lock_list *entry;
-
-        if (lockdep_dependency_visit(class, depth))
-                return;
-
-        if (DEBUG_LOCKS_WARN_ON(depth >= 20))
-                return;
-
-        print_lock_class_header(class, depth);
-
-        list_for_each_entry(entry, &class->locks_after, entry) {
-                if (DEBUG_LOCKS_WARN_ON(!entry->class))
-                        return;
-
-                print_lock_dependencies(entry->class, depth + 1);
-
-                printk("%*s ... acquired at:\n",depth,"");
-                print_stack_trace(&entry->trace, 2);
-                printk("\n");
-        }
-}
-
 static void print_kernel_version(void)
 {
         printk("%s %.*s\n", init_utsname()->release,
@@ -898,22 +840,203 @@ static int add_lock_to_list(struct lock_class *class, struct lock_class *this,
 }
 
 /*
+ * For good efficiency of modular, we use power of 2
+ */
+#define MAX_CIRCULAR_QUEUE_SIZE         4096UL
+#define CQ_MASK                         (MAX_CIRCULAR_QUEUE_SIZE-1)
+
+/*
+ * The circular_queue and helpers is used to implement the
+ * breadth-first search(BFS)algorithem, by which we can build
+ * the shortest path from the next lock to be acquired to the
+ * previous held lock if there is a circular between them.
+ */
+struct circular_queue {
+        unsigned long element[MAX_CIRCULAR_QUEUE_SIZE];
+        unsigned int  front, rear;
+};
+
+static struct circular_queue lock_cq;
+
+unsigned int max_bfs_queue_depth;
+
+static unsigned int lockdep_dependency_gen_id;
+
+static inline void __cq_init(struct circular_queue *cq)
+{
+        cq->front = cq->rear = 0;
+        lockdep_dependency_gen_id++;
+}
+
+static inline int __cq_empty(struct circular_queue *cq)
+{
+        return (cq->front == cq->rear);
+}
+
+static inline int __cq_full(struct circular_queue *cq)
+{
+        return ((cq->rear + 1) & CQ_MASK) == cq->front;
+}
+
+static inline int __cq_enqueue(struct circular_queue *cq, unsigned long elem)
+{
+        if (__cq_full(cq))
+                return -1;
+
+        cq->element[cq->rear] = elem;
+        cq->rear = (cq->rear + 1) & CQ_MASK;
+        return 0;
+}
+
+static inline int __cq_dequeue(struct circular_queue *cq, unsigned long *elem)
+{
+        if (__cq_empty(cq))
+                return -1;
+
+        *elem = cq->element[cq->front];
+        cq->front = (cq->front + 1) & CQ_MASK;
+        return 0;
+}
+
+static inline unsigned int  __cq_get_elem_count(struct circular_queue *cq)
+{
+        return (cq->rear - cq->front) & CQ_MASK;
+}
+
+static inline void mark_lock_accessed(struct lock_list *lock,
+                                        struct lock_list *parent)
+{
+        unsigned long nr;
+
+        nr = lock - list_entries;
+        WARN_ON(nr >= nr_list_entries);
+        lock->parent = parent;
+        lock->class->dep_gen_id = lockdep_dependency_gen_id;
+}
+
+static inline unsigned long lock_accessed(struct lock_list *lock)
+{
+        unsigned long nr;
+
+        nr = lock - list_entries;
+        WARN_ON(nr >= nr_list_entries);
+        return lock->class->dep_gen_id == lockdep_dependency_gen_id;
+}
+
+static inline struct lock_list *get_lock_parent(struct lock_list *child)
+{
+        return child->parent;
+}
+
+static inline int get_lock_depth(struct lock_list *child)
+{
+        int depth = 0;
+        struct lock_list *parent;
+
+        while ((parent = get_lock_parent(child))) {
+                child = parent;
+                depth++;
+        }
+        return depth;
+}
+
+static int __bfs(struct lock_list *source_entry,
+                 void *data,
+                 int (*match)(struct lock_list *entry, void *data),
+                 struct lock_list **target_entry,
+                 int forward)
+{
+        struct lock_list *entry;
+        struct list_head *head;
+        struct circular_queue *cq = &lock_cq;
+        int ret = 1;
+
+        if (match(source_entry, data)) {
+                *target_entry = source_entry;
+                ret = 0;
+                goto exit;
+        }
+
+        if (forward)
+                head = &source_entry->class->locks_after;
+        else
+                head = &source_entry->class->locks_before;
+
+        if (list_empty(head))
+                goto exit;
+
+        __cq_init(cq);
+        __cq_enqueue(cq, (unsigned long)source_entry);
+
+        while (!__cq_empty(cq)) {
+                struct lock_list *lock;
+
+                __cq_dequeue(cq, (unsigned long *)&lock);
+
+                if (!lock->class) {
+                        ret = -2;
+                        goto exit;
+                }
+
+                if (forward)
+                        head = &lock->class->locks_after;
+                else
+                        head = &lock->class->locks_before;
+
+                list_for_each_entry(entry, head, entry) {
+                        if (!lock_accessed(entry)) {
+                                unsigned int cq_depth;
+                                mark_lock_accessed(entry, lock);
+                                if (match(entry, data)) {
+                                        *target_entry = entry;
+                                        ret = 0;
+                                        goto exit;
+                                }
+
+                                if (__cq_enqueue(cq, (unsigned long)entry)) {
+                                        ret = -1;
+                                        goto exit;
+                                }
+                                cq_depth = __cq_get_elem_count(cq);
+                                if (max_bfs_queue_depth < cq_depth)
+                                        max_bfs_queue_depth = cq_depth;
+                        }
+                }
+        }
+exit:
+        return ret;
+}
+
+static inline int __bfs_forwards(struct lock_list *src_entry,
+                        void *data,
+                        int (*match)(struct lock_list *entry, void *data),
+                        struct lock_list **target_entry)
+{
+        return __bfs(src_entry, data, match, target_entry, 1);
+
+}
+
+static inline int __bfs_backwards(struct lock_list *src_entry,
+                        void *data,
+                        int (*match)(struct lock_list *entry, void *data),
+                        struct lock_list **target_entry)
+{
+        return __bfs(src_entry, data, match, target_entry, 0);
+
+}
+
+/*
  * Recursive, forwards-direction lock-dependency checking, used for
  * both noncyclic checking and for hardirq-unsafe/softirq-unsafe
  * checking.
- *
- * (to keep the stackframe of the recursive functions small we
- *  use these global variables, and we also mark various helper
- *  functions as noinline.)
  */
-static struct held_lock *check_source, *check_target;
 
 /*
  * Print a dependency chain entry (this is only done when a deadlock
  * has been detected):
  */
 static noinline int
-print_circular_bug_entry(struct lock_list *target, unsigned int depth)
+print_circular_bug_entry(struct lock_list *target, int depth)
 {
         if (debug_locks_silent)
                 return 0;
@@ -930,11 +1053,13 @@ print_circular_bug_entry(struct lock_list *target, unsigned int depth)
  * header first:
  */
 static noinline int
-print_circular_bug_header(struct lock_list *entry, unsigned int depth)
+print_circular_bug_header(struct lock_list *entry, unsigned int depth,
+                        struct held_lock *check_src,
+                        struct held_lock *check_tgt)
 {
         struct task_struct *curr = current;
 
-        if (!debug_locks_off_graph_unlock() || debug_locks_silent)
+        if (debug_locks_silent)
                 return 0;
 
         printk("\n=======================================================\n");
@@ -943,9 +1068,9 @@ print_circular_bug_header(struct lock_list *entry, unsigned int depth)
         printk(  "-------------------------------------------------------\n");
         printk("%s/%d is trying to acquire lock:\n",
                 curr->comm, task_pid_nr(curr));
-        print_lock(check_source);
+        print_lock(check_src);
         printk("\nbut task is already holding lock:\n");
-        print_lock(check_target);
+        print_lock(check_tgt);
         printk("\nwhich lock already depends on the new lock.\n\n");
         printk("\nthe existing dependency chain (in reverse order) is:\n");
 
@@ -954,19 +1079,36 @@ print_circular_bug_header(struct lock_list *entry, unsigned int depth)
         return 0;
 }
 
-static noinline int print_circular_bug_tail(void)
+static inline int class_equal(struct lock_list *entry, void *data)
+{
+        return entry->class == data;
+}
+
+static noinline int print_circular_bug(struct lock_list *this,
+                                struct lock_list *target,
+                                struct held_lock *check_src,
+                                struct held_lock *check_tgt)
 {
         struct task_struct *curr = current;
-        struct lock_list this;
+        struct lock_list *parent;
+        int depth;
 
-        if (debug_locks_silent)
+        if (!debug_locks_off_graph_unlock() || debug_locks_silent)
                 return 0;
 
-        this.class = hlock_class(check_source);
-        if (!save_trace(&this.trace))
+        if (!save_trace(&this->trace))
                 return 0;
 
-        print_circular_bug_entry(&this, 0);
+        depth = get_lock_depth(target);
+
+        print_circular_bug_header(target, depth, check_src, check_tgt);
+
+        parent = get_lock_parent(target);
+
+        while (parent) {
+                print_circular_bug_entry(parent, --depth);
+                parent = get_lock_parent(parent);
+        }
 
         printk("\nother info that might help us debug this:\n\n");
         lockdep_print_held_locks(curr);
@@ -977,73 +1119,69 @@ static noinline int print_circular_bug_tail(void)
         return 0;
 }
 
-#define RECURSION_LIMIT 40
-
-static int noinline print_infinite_recursion_bug(void)
+static noinline int print_bfs_bug(int ret)
 {
         if (!debug_locks_off_graph_unlock())
                 return 0;
 
-        WARN_ON(1);
+        WARN(1, "lockdep bfs error:%d\n", ret);
 
         return 0;
 }
 
-unsigned long __lockdep_count_forward_deps(struct lock_class *class,
-                                           unsigned int depth)
+static int noop_count(struct lock_list *entry, void *data)
 {
-        struct lock_list *entry;
-        unsigned long ret = 1;
+        (*(unsigned long *)data)++;
+        return 0;
+}
 
-        if (lockdep_dependency_visit(class, depth))
-                return 0;
+unsigned long __lockdep_count_forward_deps(struct lock_list *this)
+{
+        unsigned long  count = 0;
+        struct lock_list *uninitialized_var(target_entry);
 
-        /*
-         * Recurse this class's dependency list:
-         */
-        list_for_each_entry(entry, &class->locks_after, entry)
-                ret += __lockdep_count_forward_deps(entry->class, depth + 1);
+        __bfs_forwards(this, (void *)&count, noop_count, &target_entry);
 
-        return ret;
+        return count;
 }
-
 unsigned long lockdep_count_forward_deps(struct lock_class *class)
 {
         unsigned long ret, flags;
+        struct lock_list this;
+
+        this.parent = NULL;
+        this.class = class;
 
         local_irq_save(flags);
         __raw_spin_lock(&lockdep_lock);
-        ret = __lockdep_count_forward_deps(class, 0);
+        ret = __lockdep_count_forward_deps(&this);
         __raw_spin_unlock(&lockdep_lock);
         local_irq_restore(flags);
 
         return ret;
 }
 
-unsigned long __lockdep_count_backward_deps(struct lock_class *class,
-                                            unsigned int depth)
+unsigned long __lockdep_count_backward_deps(struct lock_list *this)
 {
-        struct lock_list *entry;
-        unsigned long ret = 1;
+        unsigned long  count = 0;
+        struct lock_list *uninitialized_var(target_entry);
 
-        if (lockdep_dependency_visit(class, depth))
-                return 0;
-        /*
-         * Recurse this class's dependency list:
-         */
-        list_for_each_entry(entry, &class->locks_before, entry)
-                ret += __lockdep_count_backward_deps(entry->class, depth + 1);
+        __bfs_backwards(this, (void *)&count, noop_count, &target_entry);
 
-        return ret;
+        return count;
 }
 
 unsigned long lockdep_count_backward_deps(struct lock_class *class)
 {
         unsigned long ret, flags;
+        struct lock_list this;
+
+        this.parent = NULL;
+        this.class = class;
 
         local_irq_save(flags);
         __raw_spin_lock(&lockdep_lock);
-        ret = __lockdep_count_backward_deps(class, 0);
+        ret = __lockdep_count_backward_deps(&this);
         __raw_spin_unlock(&lockdep_lock);
         local_irq_restore(flags);
 
@@ -1055,29 +1193,16 @@ unsigned long lockdep_count_backward_deps(struct lock_class *class)
  * lead to <target>. Print an error and return 0 if it does.
  */
 static noinline int
-check_noncircular(struct lock_class *source, unsigned int depth)
+check_noncircular(struct lock_list *root, struct lock_class *target,
+                struct lock_list **target_entry)
 {
-        struct lock_list *entry;
+        int result;
 
-        if (lockdep_dependency_visit(source, depth))
-                return 1;
+        debug_atomic_inc(&nr_cyclic_checks);
 
-        debug_atomic_inc(&nr_cyclic_check_recursions);
-        if (depth > max_recursion_depth)
-                max_recursion_depth = depth;
-        if (depth >= RECURSION_LIMIT)
-                return print_infinite_recursion_bug();
-        /*
-         * Check this lock's dependency list:
-         */
-        list_for_each_entry(entry, &source->locks_after, entry) {
-                if (entry->class == hlock_class(check_target))
-                        return print_circular_bug_header(entry, depth+1);
-                debug_atomic_inc(&nr_cyclic_checks);
-                if (!check_noncircular(entry->class, depth+1))
-                        return print_circular_bug_entry(entry, depth+1);
-        }
-        return 1;
+        result = __bfs_forwards(root, target, class_equal, target_entry);
+
+        return result;
 }
 
 #if defined(CONFIG_TRACE_IRQFLAGS) && defined(CONFIG_PROVE_LOCKING)
@@ -1086,103 +1211,121 @@ check_noncircular(struct lock_class *source, unsigned int depth)
  * proving that two subgraphs can be connected by a new dependency
  * without creating any illegal irq-safe -> irq-unsafe lock dependency.
  */
-static enum lock_usage_bit find_usage_bit;
-static struct lock_class *forwards_match, *backwards_match;
+
+static inline int usage_match(struct lock_list *entry, void *bit)
+{
+        return entry->class->usage_mask & (1 << (enum lock_usage_bit)bit);
+}
+
+
 
 /*
  * Find a node in the forwards-direction dependency sub-graph starting
- * at <source> that matches <find_usage_bit>.
+ * at @root->class that matches @bit.
  *
- * Return 2 if such a node exists in the subgraph, and put that node
- * into <forwards_match>.
+ * Return 0 if such a node exists in the subgraph, and put that node
+ * into *@target_entry.
  *
- * Return 1 otherwise and keep <forwards_match> unchanged.
- * Return 0 on error.
+ * Return 1 otherwise and keep *@target_entry unchanged.
+ * Return <0 on error.
  */
-static noinline int
-find_usage_forwards(struct lock_class *source, unsigned int depth)
+static int
+find_usage_forwards(struct lock_list *root, enum lock_usage_bit bit,
+                        struct lock_list **target_entry)
 {
-        struct lock_list *entry;
-        int ret;
-
-        if (lockdep_dependency_visit(source, depth))
-                return 1;
-
-        if (depth > max_recursion_depth)
-                max_recursion_depth = depth;
-        if (depth >= RECURSION_LIMIT)
-                return print_infinite_recursion_bug();
+        int result;
 
         debug_atomic_inc(&nr_find_usage_forwards_checks);
-        if (source->usage_mask & (1 << find_usage_bit)) {
-                forwards_match = source;
-                return 2;
-        }
 
-        /*
-         * Check this lock's dependency list:
-         */
-        list_for_each_entry(entry, &source->locks_after, entry) {
-                debug_atomic_inc(&nr_find_usage_forwards_recursions);
-                ret = find_usage_forwards(entry->class, depth+1);
-                if (ret == 2 || ret == 0)
-                        return ret;
-        }
-        return 1;
+        result = __bfs_forwards(root, (void *)bit, usage_match, target_entry);
+
+        return result;
 }
 
 /*
  * Find a node in the backwards-direction dependency sub-graph starting
- * at <source> that matches <find_usage_bit>.
+ * at @root->class that matches @bit.
  *
- * Return 2 if such a node exists in the subgraph, and put that node
- * into <backwards_match>.
+ * Return 0 if such a node exists in the subgraph, and put that node
+ * into *@target_entry.
  *
- * Return 1 otherwise and keep <backwards_match> unchanged.
- * Return 0 on error.
+ * Return 1 otherwise and keep *@target_entry unchanged.
+ * Return <0 on error.
  */
-static noinline int
-find_usage_backwards(struct lock_class *source, unsigned int depth)
+static int
+find_usage_backwards(struct lock_list *root, enum lock_usage_bit bit,
+                        struct lock_list **target_entry)
 {
-        struct lock_list *entry;
-        int ret;
+        int result;
 
-        if (lockdep_dependency_visit(source, depth))
-                return 1;
+        debug_atomic_inc(&nr_find_usage_backwards_checks);
 
-        if (!__raw_spin_is_locked(&lockdep_lock))
-                return DEBUG_LOCKS_WARN_ON(1);
+        result = __bfs_backwards(root, (void *)bit, usage_match, target_entry);
 
-        if (depth > max_recursion_depth)
-                max_recursion_depth = depth;
-        if (depth >= RECURSION_LIMIT)
-                return print_infinite_recursion_bug();
+        return result;
+}
 
-        debug_atomic_inc(&nr_find_usage_backwards_checks);
-        if (source->usage_mask & (1 << find_usage_bit)) {
-                backwards_match = source;
-                return 2;
-        }
+static void print_lock_class_header(struct lock_class *class, int depth)
+{
+        int bit;
 
-        if (!source && debug_locks_off_graph_unlock()) {
-                WARN_ON(1);
-                return 0;
-        }
+        printk("%*s->", depth, "");
+        print_lock_name(class);
+        printk(" ops: %lu", class->ops);
+        printk(" {\n");
 
-        /*
-         * Check this lock's dependency list:
-         */
-        list_for_each_entry(entry, &source->locks_before, entry) {
-                debug_atomic_inc(&nr_find_usage_backwards_recursions);
-                ret = find_usage_backwards(entry->class, depth+1);
-                if (ret == 2 || ret == 0)
-                        return ret;
+        for (bit = 0; bit < LOCK_USAGE_STATES; bit++) {
+                if (class->usage_mask & (1 << bit)) {
+                        int len = depth;
+
+                        len += printk("%*s   %s", depth, "", usage_str[bit]);
+                        len += printk(" at:\n");
+                        print_stack_trace(class->usage_traces + bit, len);
+                }
         }
-        return 1;
+        printk("%*s }\n", depth, "");
+
+        printk("%*s ... key      at: ",depth,"");
+        print_ip_sym((unsigned long)class->key);
+}
+
+/*
+ * printk the shortest lock dependencies from @start to @end in reverse order:
+ */
+static void __used
+print_shortest_lock_dependencies(struct lock_list *leaf,
+                                struct lock_list *root)
+{
+        struct lock_list *entry = leaf;
+        int depth;
+
+        /*compute depth from generated tree by BFS*/
+        depth = get_lock_depth(leaf);
+
+        do {
+                print_lock_class_header(entry->class, depth);
+                printk("%*s ... acquired at:\n", depth, "");
+                print_stack_trace(&entry->trace, 2);
+                printk("\n");
+
+                if (depth == 0 && (entry != root)) {
+                        printk("lockdep:%s bad BFS generated tree\n", __func__);
+                        break;
+                }
+
+                entry = get_lock_parent(entry);
+                depth--;
+        } while (entry && (depth >= 0));
+
+        return;
 }
 
 static int
 print_bad_irq_dependency(struct task_struct *curr,
+                         struct lock_list *prev_root,
+                         struct lock_list *next_root,
+                         struct lock_list *backwards_entry,
+                         struct lock_list *forwards_entry,
                          struct held_lock *prev,
                          struct held_lock *next,
                          enum lock_usage_bit bit1,
@@ -1215,26 +1358,32 @@ print_bad_irq_dependency(struct task_struct *curr,
 
         printk("\nbut this new dependency connects a %s-irq-safe lock:\n",
                 irqclass);
-        print_lock_name(backwards_match);
+        print_lock_name(backwards_entry->class);
         printk("\n... which became %s-irq-safe at:\n", irqclass);
 
-        print_stack_trace(backwards_match->usage_traces + bit1, 1);
+        print_stack_trace(backwards_entry->class->usage_traces + bit1, 1);
 
         printk("\nto a %s-irq-unsafe lock:\n", irqclass);
-        print_lock_name(forwards_match);
+        print_lock_name(forwards_entry->class);
         printk("\n... which became %s-irq-unsafe at:\n", irqclass);
         printk("...");
 
-        print_stack_trace(forwards_match->usage_traces + bit2, 1);
+        print_stack_trace(forwards_entry->class->usage_traces + bit2, 1);
 
         printk("\nother info that might help us debug this:\n\n");
         lockdep_print_held_locks(curr);
 
-        printk("\nthe %s-irq-safe lock's dependencies:\n", irqclass);
-        print_lock_dependencies(backwards_match, 0);
+        printk("\nthe dependencies between %s-irq-safe lock", irqclass);
+        printk(" and the holding lock:\n");
+        if (!save_trace(&prev_root->trace))
+                return 0;
+        print_shortest_lock_dependencies(backwards_entry, prev_root);
 
-        printk("\nthe %s-irq-unsafe lock's dependencies:\n", irqclass);
-        print_lock_dependencies(forwards_match, 0);
+        printk("\nthe dependencies between the lock to be acquired");
+        printk(" and %s-irq-unsafe lock:\n", irqclass);
+        if (!save_trace(&next_root->trace))
+                return 0;
+        print_shortest_lock_dependencies(forwards_entry, next_root);
 
         printk("\nstack backtrace:\n");
         dump_stack();
@@ -1248,19 +1397,30 @@ check_usage(struct task_struct *curr, struct held_lock *prev,
             enum lock_usage_bit bit_forwards, const char *irqclass)
 {
         int ret;
+        struct lock_list this, that;
+        struct lock_list *uninitialized_var(target_entry);
+        struct lock_list *uninitialized_var(target_entry1);
 
-        find_usage_bit = bit_backwards;
-        /* fills in <backwards_match> */
-        ret = find_usage_backwards(hlock_class(prev), 0);
-        if (!ret || ret == 1)
+        this.parent = NULL;
+
+        this.class = hlock_class(prev);
+        ret = find_usage_backwards(&this, bit_backwards, &target_entry);
+        if (ret < 0)
+                return print_bfs_bug(ret);
+        if (ret == 1)
                 return ret;
 
-        find_usage_bit = bit_forwards;
-        ret = find_usage_forwards(hlock_class(next), 0);
-        if (!ret || ret == 1)
+        that.parent = NULL;
+        that.class = hlock_class(next);
+        ret = find_usage_forwards(&that, bit_forwards, &target_entry1);
+        if (ret < 0)
+                return print_bfs_bug(ret);
+        if (ret == 1)
                 return ret;
-        /* ret == 2 */
-        return print_bad_irq_dependency(curr, prev, next,
+
+        return print_bad_irq_dependency(curr, &this, &that,
+                        target_entry, target_entry1,
+                        prev, next,
                         bit_backwards, bit_forwards, irqclass);
 }
 
@@ -1472,6 +1632,8 @@ check_prev_add(struct task_struct *curr, struct held_lock *prev,
 {
         struct lock_list *entry;
         int ret;
+        struct lock_list this;
+        struct lock_list *uninitialized_var(target_entry);
 
         /*
          * Prove that the new <prev> -> <next> dependency would not
@@ -1482,10 +1644,13 @@ check_prev_add(struct task_struct *curr, struct held_lock *prev,
          * We are using global variables to control the recursion, to
          * keep the stackframe size of the recursive functions low:
          */
-        check_source = next;
-        check_target = prev;
-        if (!(check_noncircular(hlock_class(next), 0)))
-                return print_circular_bug_tail();
+        this.class = hlock_class(next);
+        this.parent = NULL;
+        ret = check_noncircular(&this, hlock_class(prev), &target_entry);
+        if (unlikely(!ret))
+                return print_circular_bug(&this, target_entry, next, prev);
+        else if (unlikely(ret < 0))
+                return print_bfs_bug(ret);
 
         if (!check_prev_add_irq(curr, prev, next))
                 return 0;
@@ -1884,7 +2049,8 @@ static int mark_lock(struct task_struct *curr, struct held_lock *this,
  * print irq inversion bug:
  */
 static int
-print_irq_inversion_bug(struct task_struct *curr, struct lock_class *other,
+print_irq_inversion_bug(struct task_struct *curr,
+                        struct lock_list *root, struct lock_list *other,
                         struct held_lock *this, int forwards,
                         const char *irqclass)
 {
@@ -1902,17 +2068,16 @@ print_irq_inversion_bug(struct task_struct *curr, struct lock_class *other,
                 printk("but this lock took another, %s-unsafe lock in the past:\n", irqclass);
         else
                 printk("but this lock was taken by another, %s-safe lock in the past:\n", irqclass);
-        print_lock_name(other);
+        print_lock_name(other->class);
         printk("\n\nand interrupts could create inverse lock ordering between them.\n\n");
 
         printk("\nother info that might help us debug this:\n");
         lockdep_print_held_locks(curr);
 
-        printk("\nthe first lock's dependencies:\n");
-        print_lock_dependencies(hlock_class(this), 0);
-
-        printk("\nthe second lock's dependencies:\n");
-        print_lock_dependencies(other, 0);
+        printk("\nthe shortest dependencies between 2nd lock and 1st lock:\n");
+        if (!save_trace(&root->trace))
+                return 0;
+        print_shortest_lock_dependencies(other, root);
 
         printk("\nstack backtrace:\n");
         dump_stack();
@@ -1929,14 +2094,19 @@ check_usage_forwards(struct task_struct *curr, struct held_lock *this,
                      enum lock_usage_bit bit, const char *irqclass)
 {
         int ret;
-
-        find_usage_bit = bit;
-        /* fills in <forwards_match> */
-        ret = find_usage_forwards(hlock_class(this), 0);
-        if (!ret || ret == 1)
+        struct lock_list root;
+        struct lock_list *uninitialized_var(target_entry);
+
+        root.parent = NULL;
+        root.class = hlock_class(this);
+        ret = find_usage_forwards(&root, bit, &target_entry);
+        if (ret < 0)
+                return print_bfs_bug(ret);
+        if (ret == 1)
                 return ret;
 
-        return print_irq_inversion_bug(curr, forwards_match, this, 1, irqclass);
+        return print_irq_inversion_bug(curr, &root, target_entry,
+                                        this, 1, irqclass);
 }
 
 /*
@@ -1948,14 +2118,19 @@ check_usage_backwards(struct task_struct *curr, struct held_lock *this,
                       enum lock_usage_bit bit, const char *irqclass)
 {
         int ret;
-
-        find_usage_bit = bit;
-        /* fills in <backwards_match> */
-        ret = find_usage_backwards(hlock_class(this), 0);
-        if (!ret || ret == 1)
+        struct lock_list root;
+        struct lock_list *uninitialized_var(target_entry);
+
+        root.parent = NULL;
+        root.class = hlock_class(this);
+        ret = find_usage_backwards(&root, bit, &target_entry);
+        if (ret < 0)
+                return print_bfs_bug(ret);
+        if (ret == 1)
                 return ret;
 
-        return print_irq_inversion_bug(curr, backwards_match, this, 0, irqclass);
+        return print_irq_inversion_bug(curr, &root, target_entry,
+                                        this, 1, irqclass);
 }
 
 void print_irqtrace_events(struct task_struct *curr)
@@ -2530,13 +2705,15 @@ EXPORT_SYMBOL_GPL(lockdep_init_map);
  */
 static int __lock_acquire(struct lockdep_map *lock, unsigned int subclass,
                           int trylock, int read, int check, int hardirqs_off,
-                          struct lockdep_map *nest_lock, unsigned long ip)
+                          struct lockdep_map *nest_lock, unsigned long ip,
+                          int references)
 {
         struct task_struct *curr = current;
         struct lock_class *class = NULL;
         struct held_lock *hlock;
         unsigned int depth, id;
         int chain_head = 0;
+        int class_idx;
         u64 chain_key;
 
         if (!prove_locking)
@@ -2584,10 +2761,24 @@ static int __lock_acquire(struct lockdep_map *lock, unsigned int subclass,
         if (DEBUG_LOCKS_WARN_ON(depth >= MAX_LOCK_DEPTH))
                 return 0;
 
+        class_idx = class - lock_classes + 1;
+
+        if (depth) {
+                hlock = curr->held_locks + depth - 1;
+                if (hlock->class_idx == class_idx && nest_lock) {
+                        if (hlock->references)
+                                hlock->references++;
+                        else
+                                hlock->references = 2;
+
+                        return 1;
+                }
+        }
+
         hlock = curr->held_locks + depth;
         if (DEBUG_LOCKS_WARN_ON(!class))
                 return 0;
-        hlock->class_idx = class - lock_classes + 1;
+        hlock->class_idx = class_idx;
         hlock->acquire_ip = ip;
         hlock->instance = lock;
         hlock->nest_lock = nest_lock;
@@ -2595,6 +2786,7 @@ static int __lock_acquire(struct lockdep_map *lock, unsigned int subclass,
         hlock->read = read;
         hlock->check = check;
         hlock->hardirqs_off = !!hardirqs_off;
+        hlock->references = references;
 #ifdef CONFIG_LOCK_STAT
         hlock->waittime_stamp = 0;
         hlock->holdtime_stamp = sched_clock();
@@ -2703,6 +2895,30 @@ static int check_unlock(struct task_struct *curr, struct lockdep_map *lock,
         return 1;
 }
 
+static int match_held_lock(struct held_lock *hlock, struct lockdep_map *lock)
+{
+        if (hlock->instance == lock)
+                return 1;
+
+        if (hlock->references) {
+                struct lock_class *class = lock->class_cache;
+
+                if (!class)
+                        class = look_up_lock_class(lock, 0);
+
+                if (DEBUG_LOCKS_WARN_ON(!class))
+                        return 0;
+
+                if (DEBUG_LOCKS_WARN_ON(!hlock->nest_lock))
+                        return 0;
+
+                if (hlock->class_idx == class - lock_classes + 1)
+                        return 1;
+        }
+
+        return 0;
+}
+
 static int
 __lock_set_class(struct lockdep_map *lock, const char *name,
                  struct lock_class_key *key, unsigned int subclass,
@@ -2726,7 +2942,7 @@ __lock_set_class(struct lockdep_map *lock, const char *name,
                  */
                 if (prev_hlock && prev_hlock->irq_context != hlock->irq_context)
                         break;
-                if (hlock->instance == lock)
+                if (match_held_lock(hlock, lock))
                         goto found_it;
                 prev_hlock = hlock;
         }
@@ -2745,7 +2961,8 @@ found_it:
                 if (!__lock_acquire(hlock->instance,
                         hlock_class(hlock)->subclass, hlock->trylock,
                                 hlock->read, hlock->check, hlock->hardirqs_off,
-                                hlock->nest_lock, hlock->acquire_ip))
+                                hlock->nest_lock, hlock->acquire_ip,
+                                hlock->references))
                         return 0;
         }
 
@@ -2784,20 +3001,34 @@ lock_release_non_nested(struct task_struct *curr,
                  */
                 if (prev_hlock && prev_hlock->irq_context != hlock->irq_context)
                         break;
-                if (hlock->instance == lock)
+                if (match_held_lock(hlock, lock))
                         goto found_it;
                 prev_hlock = hlock;
         }
         return print_unlock_inbalance_bug(curr, lock, ip);
 
 found_it:
-        lock_release_holdtime(hlock);
+        if (hlock->instance == lock)
+                lock_release_holdtime(hlock);
+
+        if (hlock->references) {
+                hlock->references--;
+                if (hlock->references) {
+                        /*
+                         * We had, and after removing one, still have
+                         * references, the current lock stack is still
+                         * valid. We're done!
+                         */
+                        return 1;
+                }
+        }
 
         /*
          * We have the right lock to unlock, 'hlock' points to it.
          * Now we remove it from the stack, and add back the other
          * entries (if any), recalculating the hash along the way:
          */
+
         curr->lockdep_depth = i;
         curr->curr_chain_key = hlock->prev_chain_key;
 
@@ -2806,7 +3037,8 @@ found_it:
                 if (!__lock_acquire(hlock->instance,
                         hlock_class(hlock)->subclass, hlock->trylock,
                                 hlock->read, hlock->check, hlock->hardirqs_off,
-                                hlock->nest_lock, hlock->acquire_ip))
+                                hlock->nest_lock, hlock->acquire_ip,
+                                hlock->references))
                         return 0;
         }
 
@@ -2836,7 +3068,7 @@ static int lock_release_nested(struct task_struct *curr,
         /*
          * Is the unlock non-nested:
          */
-        if (hlock->instance != lock)
+        if (hlock->instance != lock || hlock->references)
                 return lock_release_non_nested(curr, lock, ip);
         curr->lockdep_depth--;
 
@@ -2881,6 +3113,21 @@ __lock_release(struct lockdep_map *lock, int nested, unsigned long ip)
         check_chain_key(curr);
 }
 
+static int __lock_is_held(struct lockdep_map *lock)
+{
+        struct task_struct *curr = current;
+        int i;
+
+        for (i = 0; i < curr->lockdep_depth; i++) {
+                struct held_lock *hlock = curr->held_locks + i;
+
+                if (match_held_lock(hlock, lock))
+                        return 1;
+        }
+
+        return 0;
+}
+
 /*
  * Check whether we follow the irq-flags state precisely:
  */
@@ -2957,7 +3204,7 @@ void lock_acquire(struct lockdep_map *lock, unsigned int subclass,
 
         current->lockdep_recursion = 1;
         __lock_acquire(lock, subclass, trylock, read, check,
-                       irqs_disabled_flags(flags), nest_lock, ip);
+                       irqs_disabled_flags(flags), nest_lock, ip, 0);
         current->lockdep_recursion = 0;
         raw_local_irq_restore(flags);
 }
@@ -2982,6 +3229,26 @@ void lock_release(struct lockdep_map *lock, int nested,
 }
 EXPORT_SYMBOL_GPL(lock_release);
 
+int lock_is_held(struct lockdep_map *lock)
+{
+        unsigned long flags;
+        int ret = 0;
+
+        if (unlikely(current->lockdep_recursion))
+                return ret;
+
+        raw_local_irq_save(flags);
+        check_flags(flags);
+
+        current->lockdep_recursion = 1;
+        ret = __lock_is_held(lock);
+        current->lockdep_recursion = 0;
+        raw_local_irq_restore(flags);
+
+        return ret;
+}
+EXPORT_SYMBOL_GPL(lock_is_held);
+
 void lockdep_set_current_reclaim_state(gfp_t gfp_mask)
 {
         current->lockdep_reclaim_gfp = gfp_mask;
@@ -3041,7 +3308,7 @@ __lock_contended(struct lockdep_map *lock, unsigned long ip)
                  */
                 if (prev_hlock && prev_hlock->irq_context != hlock->irq_context)
                         break;
-                if (hlock->instance == lock)
+                if (match_held_lock(hlock, lock))
                         goto found_it;
                 prev_hlock = hlock;
         }
@@ -3049,6 +3316,9 @@ __lock_contended(struct lockdep_map *lock, unsigned long ip)
         return;
 
 found_it:
+        if (hlock->instance != lock)
+                return;
+
         hlock->waittime_stamp = sched_clock();
 
         contention_point = lock_point(hlock_class(hlock)->contention_point, ip);
@@ -3088,7 +3358,7 @@ __lock_acquired(struct lockdep_map *lock, unsigned long ip)
                  */
                 if (prev_hlock && prev_hlock->irq_context != hlock->irq_context)
                         break;
-                if (hlock->instance == lock)
+                if (match_held_lock(hlock, lock))
                         goto found_it;
                 prev_hlock = hlock;
         }
@@ -3096,6 +3366,9 @@ __lock_acquired(struct lockdep_map *lock, unsigned long ip)
         return;
 
 found_it:
+        if (hlock->instance != lock)
+                return;
+
         cpu = smp_processor_id();
         if (hlock->waittime_stamp) {
                 now = sched_clock();
@@ -3326,7 +3599,12 @@ void __init lockdep_info(void)
                 sizeof(struct list_head) * CLASSHASH_SIZE +
                 sizeof(struct lock_list) * MAX_LOCKDEP_ENTRIES +
                 sizeof(struct lock_chain) * MAX_LOCKDEP_CHAINS +
-                sizeof(struct list_head) * CHAINHASH_SIZE) / 1024);
+                sizeof(struct list_head) * CHAINHASH_SIZE
+#ifdef CONFIG_PROVE_LOCKING
+                + sizeof(struct circular_queue)
+#endif
+                ) / 1024
+                );
 
         printk(" per task-struct memory footprint: %lu bytes\n",
                 sizeof(struct held_lock) * MAX_LOCK_DEPTH);
diff --git a/kernel/lockdep_internals.h b/kernel/lockdep_internals.h
index 699a2ac3a0d7..a2ee95ad1313 100644
--- a/kernel/lockdep_internals.h
+++ b/kernel/lockdep_internals.h
@@ -91,6 +91,8 @@ extern unsigned int nr_process_chains;
 extern unsigned int max_lockdep_depth;
 extern unsigned int max_recursion_depth;
 
+extern unsigned int max_bfs_queue_depth;
+
 #ifdef CONFIG_PROVE_LOCKING
 extern unsigned long lockdep_count_forward_deps(struct lock_class *);
 extern unsigned long lockdep_count_backward_deps(struct lock_class *);
diff --git a/kernel/lockdep_proc.c b/kernel/lockdep_proc.c
index e94caa666dba..d4b3dbc79fdb 100644
--- a/kernel/lockdep_proc.c
+++ b/kernel/lockdep_proc.c
@@ -25,38 +25,12 @@
 
 static void *l_next(struct seq_file *m, void *v, loff_t *pos)
 {
-        struct lock_class *class;
-
-        (*pos)++;
-
-        if (v == SEQ_START_TOKEN)
-                class = m->private;
-        else {
-                class = v;
-
-                if (class->lock_entry.next != &all_lock_classes)
-                        class = list_entry(class->lock_entry.next,
-                                           struct lock_class, lock_entry);
-                else
-                        class = NULL;
-        }
-
-        return class;
+        return seq_list_next(v, &all_lock_classes, pos);
 }
 
 static void *l_start(struct seq_file *m, loff_t *pos)
 {
-        struct lock_class *class;
-        loff_t i = 0;
-
-        if (*pos == 0)
-                return SEQ_START_TOKEN;
-
-        list_for_each_entry(class, &all_lock_classes, lock_entry) {
-                if (++i == *pos)
-                return class;
-        }
-        return NULL;
+        return seq_list_start_head(&all_lock_classes, *pos);
 }
 
 static void l_stop(struct seq_file *m, void *v)
@@ -82,11 +56,11 @@ static void print_name(struct seq_file *m, struct lock_class *class)
 
 static int l_show(struct seq_file *m, void *v)
 {
-        struct lock_class *class = v;
+        struct lock_class *class = list_entry(v, struct lock_class, lock_entry);
         struct lock_list *entry;
         char usage[LOCK_USAGE_CHARS];
 
-        if (v == SEQ_START_TOKEN) {
+        if (v == &all_lock_classes) {
                 seq_printf(m, "all lock classes:\n");
                 return 0;
         }
@@ -128,17 +102,7 @@ static const struct seq_operations lockdep_ops = {
 
 static int lockdep_open(struct inode *inode, struct file *file)
 {
-        int res = seq_open(file, &lockdep_ops);
-        if (!res) {
-                struct seq_file *m = file->private_data;
-
-                if (!list_empty(&all_lock_classes))
-                        m->private = list_entry(all_lock_classes.next,
-                                        struct lock_class, lock_entry);
-                else
-                        m->private = NULL;
-        }
-        return res;
+        return seq_open(file, &lockdep_ops);
 }
 
 static const struct file_operations proc_lockdep_operations = {
@@ -149,37 +113,23 @@ static const struct file_operations proc_lockdep_operations = {
 };
 
 #ifdef CONFIG_PROVE_LOCKING
-static void *lc_next(struct seq_file *m, void *v, loff_t *pos)
-{
-        struct lock_chain *chain;
-
-        (*pos)++;
-
-        if (v == SEQ_START_TOKEN)
-                chain = m->private;
-        else {
-                chain = v;
-
-                if (*pos < nr_lock_chains)
-                        chain = lock_chains + *pos;
-                else
-                        chain = NULL;
-        }
-
-        return chain;
-}
-
 static void *lc_start(struct seq_file *m, loff_t *pos)
 {
         if (*pos == 0)
                 return SEQ_START_TOKEN;
 
-        if (*pos < nr_lock_chains)
-                return lock_chains + *pos;
+        if (*pos - 1 < nr_lock_chains)
+                return lock_chains + (*pos - 1);
 
         return NULL;
 }
 
+static void *lc_next(struct seq_file *m, void *v, loff_t *pos)
+{
+        (*pos)++;
+        return lc_start(m, pos);
+}
+
 static void lc_stop(struct seq_file *m, void *v)
 {
 }
@@ -220,16 +170,7 @@ static const struct seq_operations lockdep_chains_ops = {
 
 static int lockdep_chains_open(struct inode *inode, struct file *file)
 {
-        int res = seq_open(file, &lockdep_chains_ops);
-        if (!res) {
-                struct seq_file *m = file->private_data;
-
-                if (nr_lock_chains)
-                        m->private = lock_chains;
-                else
-                        m->private = NULL;
-        }
-        return res;
+        return seq_open(file, &lockdep_chains_ops);
 }
 
 static const struct file_operations proc_lockdep_chains_operations = {
@@ -258,16 +199,10 @@ static void lockdep_stats_debug_show(struct seq_file *m)
                 debug_atomic_read(&chain_lookup_hits));
         seq_printf(m, " cyclic checks:                 %11u\n",
                 debug_atomic_read(&nr_cyclic_checks));
-        seq_printf(m, " cyclic-check recursions:       %11u\n",
-                debug_atomic_read(&nr_cyclic_check_recursions));
         seq_printf(m, " find-mask forwards checks:     %11u\n",
                 debug_atomic_read(&nr_find_usage_forwards_checks));
-        seq_printf(m, " find-mask forwards recursions: %11u\n",
-                debug_atomic_read(&nr_find_usage_forwards_recursions));
         seq_printf(m, " find-mask backwards checks:    %11u\n",
                 debug_atomic_read(&nr_find_usage_backwards_checks));
-        seq_printf(m, " find-mask backwards recursions:%11u\n",
-                debug_atomic_read(&nr_find_usage_backwards_recursions));
 
         seq_printf(m, " hardirq on events:             %11u\n", hi1);
         seq_printf(m, " hardirq off events:            %11u\n", hi2);
@@ -409,8 +344,10 @@ static int lockdep_stats_show(struct seq_file *m, void *v)
                         nr_unused);
         seq_printf(m, " max locking depth:             %11u\n",
                         max_lockdep_depth);
-        seq_printf(m, " max recursion depth:           %11u\n",
-                        max_recursion_depth);
+#ifdef CONFIG_PROVE_LOCKING
+        seq_printf(m, " max bfs queue depth:           %11u\n",
+                        max_bfs_queue_depth);
+#endif
         lockdep_stats_debug_show(m);
         seq_printf(m, " debug_locks:                   %11u\n",
                         debug_locks);
@@ -438,7 +375,6 @@ struct lock_stat_data {
 };
 
 struct lock_stat_seq {
-        struct lock_stat_data *iter;
         struct lock_stat_data *iter_end;
         struct lock_stat_data stats[MAX_LOCKDEP_KEYS];
 };
@@ -626,34 +562,22 @@ static void seq_header(struct seq_file *m)
 static void *ls_start(struct seq_file *m, loff_t *pos)
 {
         struct lock_stat_seq *data = m->private;
+        struct lock_stat_data *iter;
 
         if (*pos == 0)
                 return SEQ_START_TOKEN;
 
-        data->iter = data->stats + *pos;
-        if (data->iter >= data->iter_end)
-                data->iter = NULL;
+        iter = data->stats + (*pos - 1);
+        if (iter >= data->iter_end)
+                iter = NULL;
 
-        return data->iter;
+        return iter;
 }
 
 static void *ls_next(struct seq_file *m, void *v, loff_t *pos)
 {
-        struct lock_stat_seq *data = m->private;
-
         (*pos)++;
-
-        if (v == SEQ_START_TOKEN)
-                data->iter = data->stats;
-        else {
-                data->iter = v;
-                data->iter++;
-        }
-
-        if (data->iter == data->iter_end)
-                data->iter = NULL;
-
-        return data->iter;
+        return ls_start(m, pos);
 }
 
 static void ls_stop(struct seq_file *m, void *v)
@@ -691,7 +615,6 @@ static int lock_stat_open(struct inode *inode, struct file *file)
                 struct lock_stat_data *iter = data->stats;
                 struct seq_file *m = file->private_data;
 
-                data->iter = iter;
                 list_for_each_entry(class, &all_lock_classes, lock_entry) {
                         iter->class = class;
                         iter->stats = lock_stats(class);
@@ -699,7 +622,7 @@ static int lock_stat_open(struct inode *inode, struct file *file)
                 }
                 data->iter_end = iter;
 
-                sort(data->stats, data->iter_end - data->iter,
+                sort(data->stats, data->iter_end - data->stats,
                                 sizeof(struct lock_stat_data),
                                 lock_stat_cmp, NULL);
 
@@ -734,7 +657,6 @@ static int lock_stat_release(struct inode *inode, struct file *file)
         struct seq_file *seq = file->private_data;
 
         vfree(seq->private);
-        seq->private = NULL;
         return seq_release(inode, file);
 }
 
diff --git a/kernel/module.c b/kernel/module.c
index 2d537186191f..46580edff0cb 100644
--- a/kernel/module.c
+++ b/kernel/module.c
@@ -55,6 +55,11 @@
 #include <linux/percpu.h>
 #include <linux/kmemleak.h>
 
+#define CREATE_TRACE_POINTS
+#include <trace/events/module.h>
+
+EXPORT_TRACEPOINT_SYMBOL(module_get);
+
 #if 0
 #define DEBUGP printk
 #else
@@ -942,6 +947,8 @@ void module_put(struct module *module)
         if (module) {
                 unsigned int cpu = get_cpu();
                 local_dec(__module_ref_addr(module, cpu));
+                trace_module_put(module, _RET_IP_,
+                                 local_read(__module_ref_addr(module, cpu)));
                 /* Maybe they're waiting for us to drop reference? */
                 if (unlikely(!module_is_live(module)))
                         wake_up_process(module->waiter);
@@ -1497,6 +1504,8 @@ static int __unlink_module(void *_mod)
 /* Free a module, remove from lists, etc (must hold module_mutex). */
 static void free_module(struct module *mod)
 {
+        trace_module_free(mod);
+
         /* Delete from various lists */
         stop_machine(__unlink_module, mod, NULL);
         remove_notes_attrs(mod);
@@ -2364,6 +2373,8 @@ static noinline struct module *load_module(void __user *umod,
         /* Get rid of temporary copy */
         vfree(hdr);
 
+        trace_module_load(mod);
+
         /* Done! */
         return mod;
 
diff --git a/kernel/perf_counter.c b/kernel/perf_counter.c
index d7cbc579fc80..e0d91fdf0c3c 100644
--- a/kernel/perf_counter.c
+++ b/kernel/perf_counter.c
@@ -46,12 +46,18 @@ static atomic_t nr_task_counters __read_mostly;
 
 /*
  * perf counter paranoia level:
- *  0 - not paranoid
- *  1 - disallow cpu counters to unpriv
- *  2 - disallow kernel profiling to unpriv
+ *  -1 - not paranoid at all
+ *   0 - disallow raw tracepoint access for unpriv
+ *   1 - disallow cpu counters for unpriv
+ *   2 - disallow kernel profiling for unpriv
  */
 int sysctl_perf_counter_paranoid __read_mostly = 1;
 
+static inline bool perf_paranoid_tracepoint_raw(void)
+{
+        return sysctl_perf_counter_paranoid > -1;
+}
+
 static inline bool perf_paranoid_cpu(void)
 {
         return sysctl_perf_counter_paranoid > 0;
@@ -469,7 +475,8 @@ static void update_counter_times(struct perf_counter *counter)
         struct perf_counter_context *ctx = counter->ctx;
         u64 run_end;
 
-        if (counter->state < PERF_COUNTER_STATE_INACTIVE)
+        if (counter->state < PERF_COUNTER_STATE_INACTIVE ||
+            counter->group_leader->state < PERF_COUNTER_STATE_INACTIVE)
                 return;
 
         counter->total_time_enabled = ctx->time - counter->tstamp_enabled;
@@ -518,7 +525,7 @@ static void __perf_counter_disable(void *info)
          */
         if (counter->state >= PERF_COUNTER_STATE_INACTIVE) {
                 update_context_time(ctx);
-                update_counter_times(counter);
+                update_group_times(counter);
                 if (counter == counter->group_leader)
                         group_sched_out(counter, cpuctx, ctx);
                 else
@@ -573,7 +580,7 @@ static void perf_counter_disable(struct perf_counter *counter)
          * in, so we can change the state safely.
          */
         if (counter->state == PERF_COUNTER_STATE_INACTIVE) {
-                update_counter_times(counter);
+                update_group_times(counter);
                 counter->state = PERF_COUNTER_STATE_OFF;
         }
 
@@ -851,6 +858,27 @@ retry:
 }
 
 /*
+ * Put a counter into inactive state and update time fields.
+ * Enabling the leader of a group effectively enables all
+ * the group members that aren't explicitly disabled, so we
+ * have to update their ->tstamp_enabled also.
+ * Note: this works for group members as well as group leaders
+ * since the non-leader members' sibling_lists will be empty.
+ */
+static void __perf_counter_mark_enabled(struct perf_counter *counter,
+                                        struct perf_counter_context *ctx)
+{
+        struct perf_counter *sub;
+
+        counter->state = PERF_COUNTER_STATE_INACTIVE;
+        counter->tstamp_enabled = ctx->time - counter->total_time_enabled;
+        list_for_each_entry(sub, &counter->sibling_list, list_entry)
+                if (sub->state >= PERF_COUNTER_STATE_INACTIVE)
+                        sub->tstamp_enabled =
+                                ctx->time - sub->total_time_enabled;
+}
+
+/*
  * Cross CPU call to enable a performance counter
  */
 static void __perf_counter_enable(void *info)
@@ -877,8 +905,7 @@ static void __perf_counter_enable(void *info)
 
         if (counter->state >= PERF_COUNTER_STATE_INACTIVE)
                 goto unlock;
-        counter->state = PERF_COUNTER_STATE_INACTIVE;
-        counter->tstamp_enabled = ctx->time - counter->total_time_enabled;
+        __perf_counter_mark_enabled(counter, ctx);
 
         /*
          * If the counter is in a group and isn't the group leader,
@@ -971,11 +998,9 @@ static void perf_counter_enable(struct perf_counter *counter)
          * Since we have the lock this context can't be scheduled
          * in, so we can change the state safely.
          */
-        if (counter->state == PERF_COUNTER_STATE_OFF) {
-                counter->state = PERF_COUNTER_STATE_INACTIVE;
-                counter->tstamp_enabled =
-                        ctx->time - counter->total_time_enabled;
-        }
+        if (counter->state == PERF_COUNTER_STATE_OFF)
+                __perf_counter_mark_enabled(counter, ctx);
+
  out:
         spin_unlock_irq(&ctx->lock);
 }
@@ -1479,9 +1504,7 @@ static void perf_counter_enable_on_exec(struct task_struct *task)
                 counter->attr.enable_on_exec = 0;
                 if (counter->state >= PERF_COUNTER_STATE_INACTIVE)
                         continue;
-                counter->state = PERF_COUNTER_STATE_INACTIVE;
-                counter->tstamp_enabled =
-                        ctx->time - counter->total_time_enabled;
+                __perf_counter_mark_enabled(counter, ctx);
                 enabled = 1;
         }
 
@@ -1675,6 +1698,11 @@ static void free_counter(struct perf_counter *counter)
                         atomic_dec(&nr_task_counters);
         }
 
+        if (counter->output) {
+                fput(counter->output->filp);
+                counter->output = NULL;
+        }
+
         if (counter->destroy)
                 counter->destroy(counter);
 
@@ -1960,6 +1988,8 @@ unlock:
         return ret;
 }
 
+int perf_counter_set_output(struct perf_counter *counter, int output_fd);
+
 static long perf_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
 {
         struct perf_counter *counter = file->private_data;
@@ -1983,6 +2013,9 @@ static long perf_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
         case PERF_COUNTER_IOC_PERIOD:
                 return perf_counter_period(counter, (u64 __user *)arg);
 
+        case PERF_COUNTER_IOC_SET_OUTPUT:
+                return perf_counter_set_output(counter, arg);
+
         default:
                 return -ENOTTY;
         }
@@ -2253,6 +2286,11 @@ static int perf_mmap(struct file *file, struct vm_area_struct *vma)
 
         WARN_ON_ONCE(counter->ctx->parent_ctx);
         mutex_lock(&counter->mmap_mutex);
+        if (counter->output) {
+                ret = -EINVAL;
+                goto unlock;
+        }
+
         if (atomic_inc_not_zero(&counter->mmap_count)) {
                 if (nr_pages != counter->data->nr_pages)
                         ret = -EINVAL;
@@ -2638,6 +2676,7 @@ static int perf_output_begin(struct perf_output_handle *handle,
                              struct perf_counter *counter, unsigned int size,
                              int nmi, int sample)
 {
+        struct perf_counter *output_counter;
         struct perf_mmap_data *data;
         unsigned int offset, head;
         int have_lost;
@@ -2647,13 +2686,17 @@ static int perf_output_begin(struct perf_output_handle *handle,
                 u64                      lost;
         } lost_event;
 
+        rcu_read_lock();
         /*
          * For inherited counters we send all the output towards the parent.
          */
         if (counter->parent)
                 counter = counter->parent;
 
-        rcu_read_lock();
+        output_counter = rcu_dereference(counter->output);
+        if (output_counter)
+                counter = output_counter;
+
         data = rcu_dereference(counter->data);
         if (!data)
                 goto out;
@@ -3934,6 +3977,7 @@ static const struct pmu *tp_perf_counter_init(struct perf_counter *counter)
          * have these.
          */
         if ((counter->attr.sample_type & PERF_SAMPLE_RAW) &&
+                        perf_paranoid_tracepoint_raw() &&
                         !capable(CAP_SYS_ADMIN))
                 return ERR_PTR(-EPERM);
 
@@ -4202,6 +4246,57 @@ err_size:
         goto out;
 }
 
+int perf_counter_set_output(struct perf_counter *counter, int output_fd)
+{
+        struct perf_counter *output_counter = NULL;
+        struct file *output_file = NULL;
+        struct perf_counter *old_output;
+        int fput_needed = 0;
+        int ret = -EINVAL;
+
+        if (!output_fd)
+                goto set;
+
+        output_file = fget_light(output_fd, &fput_needed);
+        if (!output_file)
+                return -EBADF;
+
+        if (output_file->f_op != &perf_fops)
+                goto out;
+
+        output_counter = output_file->private_data;
+
+        /* Don't chain output fds */
+        if (output_counter->output)
+                goto out;
+
+        /* Don't set an output fd when we already have an output channel */
+        if (counter->data)
+                goto out;
+
+        atomic_long_inc(&output_file->f_count);
+
+set:
+        mutex_lock(&counter->mmap_mutex);
+        old_output = counter->output;
+        rcu_assign_pointer(counter->output, output_counter);
+        mutex_unlock(&counter->mmap_mutex);
+
+        if (old_output) {
+                /*
+                 * we need to make sure no existing perf_output_*()
+                 * is still referencing this counter.
+                 */
+                synchronize_rcu();
+                fput(old_output->filp);
+        }
+
+        ret = 0;
+out:
+        fput_light(output_file, fput_needed);
+        return ret;
+}
+
 /**
  * sys_perf_counter_open - open a performance counter, associate it to a task/cpu
  *
@@ -4221,15 +4316,15 @@ SYSCALL_DEFINE5(perf_counter_open,
         struct file *group_file = NULL;
         int fput_needed = 0;
         int fput_needed2 = 0;
-        int ret;
+        int err;
 
         /* for future expandability... */
-        if (flags)
+        if (flags & ~(PERF_FLAG_FD_NO_GROUP | PERF_FLAG_FD_OUTPUT))
                 return -EINVAL;
 
-        ret = perf_copy_attr(attr_uptr, &attr);
-        if (ret)
-                return ret;
+        err = perf_copy_attr(attr_uptr, &attr);
+        if (err)
+                return err;
 
         if (!attr.exclude_kernel) {
                 if (perf_paranoid_kernel() && !capable(CAP_SYS_ADMIN))
@@ -4252,8 +4347,8 @@ SYSCALL_DEFINE5(perf_counter_open,
          * Look up the group leader (we will attach this counter to it):
          */
         group_leader = NULL;
-        if (group_fd != -1) {
-                ret = -EINVAL;
+        if (group_fd != -1 && !(flags & PERF_FLAG_FD_NO_GROUP)) {
+                err = -EINVAL;
                 group_file = fget_light(group_fd, &fput_needed);
                 if (!group_file)
                         goto err_put_context;
@@ -4282,18 +4377,24 @@ SYSCALL_DEFINE5(perf_counter_open,
 
         counter = perf_counter_alloc(&attr, cpu, ctx, group_leader,
                                      NULL, GFP_KERNEL);
-        ret = PTR_ERR(counter);
+        err = PTR_ERR(counter);
         if (IS_ERR(counter))
                 goto err_put_context;
 
-        ret = anon_inode_getfd("[perf_counter]", &perf_fops, counter, 0);
-        if (ret < 0)
+        err = anon_inode_getfd("[perf_counter]", &perf_fops, counter, 0);
+        if (err < 0)
                 goto err_free_put_context;
 
-        counter_file = fget_light(ret, &fput_needed2);
+        counter_file = fget_light(err, &fput_needed2);
         if (!counter_file)
                 goto err_free_put_context;
 
+        if (flags & PERF_FLAG_FD_OUTPUT) {
+                err = perf_counter_set_output(counter, group_fd);
+                if (err)
+                        goto err_fput_free_put_context;
+        }
+
         counter->filp = counter_file;
         WARN_ON_ONCE(ctx->parent_ctx);
         mutex_lock(&ctx->mutex);
@@ -4307,20 +4408,20 @@ SYSCALL_DEFINE5(perf_counter_open,
         list_add_tail(&counter->owner_entry, &current->perf_counter_list);
         mutex_unlock(&current->perf_counter_mutex);
 
+err_fput_free_put_context:
         fput_light(counter_file, fput_needed2);
 
-out_fput:
-        fput_light(group_file, fput_needed);
-
-        return ret;
-
 err_free_put_context:
-        kfree(counter);
+        if (err < 0)
+                kfree(counter);
 
 err_put_context:
-        put_ctx(ctx);
+        if (err < 0)
+                put_ctx(ctx);
+
+        fput_light(group_file, fput_needed);
 
-        goto out_fput;
+        return err;
 }
 
 /*
diff --git a/kernel/printk.c b/kernel/printk.c
index b4d97b54c1ec..e10d193a833a 100644
--- a/kernel/printk.c
+++ b/kernel/printk.c
@@ -37,6 +37,12 @@
 #include <asm/uaccess.h>
 
 /*
+ * for_each_console() allows you to iterate on each console
+ */
+#define for_each_console(con) \
+        for (con = console_drivers; con != NULL; con = con->next)
+
+/*
  * Architectures can override it:
  */
 void asmlinkage __attribute__((weak)) early_printk(const char *fmt, ...)
@@ -61,6 +67,8 @@ int console_printk[4] = {
         DEFAULT_CONSOLE_LOGLEVEL,       /* default_console_loglevel */
 };
 
+static int saved_console_loglevel = -1;
+
 /*
  * Low level drivers may need that to know if they can schedule in
  * their unblank() callback or not. So let's export it.
@@ -372,10 +380,15 @@ int do_syslog(int type, char __user *buf, int len)
                 logged_chars = 0;
                 break;
         case 6:         /* Disable logging to console */
+                if (saved_console_loglevel == -1)
+                        saved_console_loglevel = console_loglevel;
                 console_loglevel = minimum_console_loglevel;
                 break;
         case 7:         /* Enable logging to console */
-                console_loglevel = default_console_loglevel;
+                if (saved_console_loglevel != -1) {
+                        console_loglevel = saved_console_loglevel;
+                        saved_console_loglevel = -1;
+                }
                 break;
         case 8:         /* Set level of messages printed to console */
                 error = -EINVAL;
@@ -384,6 +397,8 @@ int do_syslog(int type, char __user *buf, int len)
                 if (len < minimum_console_loglevel)
                         len = minimum_console_loglevel;
                 console_loglevel = len;
+                /* Implicitly re-enable logging to console */
+                saved_console_loglevel = -1;
                 error = 0;
                 break;
         case 9:         /* Number of chars in the log buffer */
@@ -412,7 +427,7 @@ static void __call_console_drivers(unsigned start, unsigned end)
 {
         struct console *con;
 
-        for (con = console_drivers; con; con = con->next) {
+        for_each_console(con) {
                 if ((con->flags & CON_ENABLED) && con->write &&
                                 (cpu_online(smp_processor_id()) ||
                                 (con->flags & CON_ANYTIME)))
@@ -544,7 +559,7 @@ static int have_callable_console(void)
 {
         struct console *con;
 
-        for (con = console_drivers; con; con = con->next)
+        for_each_console(con)
                 if (con->flags & CON_ANYTIME)
                         return 1;
 
@@ -1082,7 +1097,7 @@ void console_unblank(void)
 
         console_locked = 1;
         console_may_schedule = 0;
-        for (c = console_drivers; c != NULL; c = c->next)
+        for_each_console(c)
                 if ((c->flags & CON_ENABLED) && c->unblank)
                         c->unblank();
         release_console_sem();
@@ -1097,7 +1112,7 @@ struct tty_driver *console_device(int *index)
         struct tty_driver *driver = NULL;
 
         acquire_console_sem();
-        for (c = console_drivers; c != NULL; c = c->next) {
+        for_each_console(c) {
                 if (!c->device)
                         continue;
                 driver = c->device(c, index);
@@ -1134,25 +1149,49 @@ EXPORT_SYMBOL(console_start);
  * to register the console printing procedure with printk() and to
  * print any messages that were printed by the kernel before the
  * console driver was initialized.
+ *
+ * This can happen pretty early during the boot process (because of
+ * early_printk) - sometimes before setup_arch() completes - be careful
+ * of what kernel features are used - they may not be initialised yet.
+ *
+ * There are two types of consoles - bootconsoles (early_printk) and
+ * "real" consoles (everything which is not a bootconsole) which are
+ * handled differently.
+ *  - Any number of bootconsoles can be registered at any time.
+ *  - As soon as a "real" console is registered, all bootconsoles
+ *    will be unregistered automatically.
+ *  - Once a "real" console is registered, any attempt to register a
+ *    bootconsoles will be rejected
  */
-void register_console(struct console *console)
+void register_console(struct console *newcon)
 {
         int i;
         unsigned long flags;
-        struct console *bootconsole = NULL;
+        struct console *bcon = NULL;
 
-        if (console_drivers) {
-                if (console->flags & CON_BOOT)
-                        return;
-                if (console_drivers->flags & CON_BOOT)
-                        bootconsole = console_drivers;
+        /*
+         * before we register a new CON_BOOT console, make sure we don't
+         * already have a valid console
+         */
+        if (console_drivers && newcon->flags & CON_BOOT) {
+                /* find the last or real console */
+                for_each_console(bcon) {
+                        if (!(bcon->flags & CON_BOOT)) {
+                                printk(KERN_INFO "Too late to register bootconsole %s%d\n",
+                                        newcon->name, newcon->index);
+                                return;
+                        }
+                }
         }
 
-        if (preferred_console < 0 || bootconsole || !console_drivers)
+        if (console_drivers && console_drivers->flags & CON_BOOT)
+                bcon = console_drivers;
+
+        if (preferred_console < 0 || bcon || !console_drivers)
                 preferred_console = selected_console;
 
-        if (console->early_setup)
-                console->early_setup();
+        if (newcon->early_setup)
+                newcon->early_setup();
 
         /*
          *      See if we want to use this console driver. If we
@@ -1160,13 +1199,13 @@ void register_console(struct console *console)
          *      that registers here.
          */
         if (preferred_console < 0) {
-                if (console->index < 0)
-                        console->index = 0;
-                if (console->setup == NULL ||
-                    console->setup(console, NULL) == 0) {
-                        console->flags |= CON_ENABLED;
-                        if (console->device) {
-                                console->flags |= CON_CONSDEV;
+                if (newcon->index < 0)
+                        newcon->index = 0;
+                if (newcon->setup == NULL ||
+                    newcon->setup(newcon, NULL) == 0) {
+                        newcon->flags |= CON_ENABLED;
+                        if (newcon->device) {
+                                newcon->flags |= CON_CONSDEV;
                                 preferred_console = 0;
                         }
                 }
@@ -1178,64 +1217,62 @@ void register_console(struct console *console)
          */
         for (i = 0; i < MAX_CMDLINECONSOLES && console_cmdline[i].name[0];
                         i++) {
-                if (strcmp(console_cmdline[i].name, console->name) != 0)
+                if (strcmp(console_cmdline[i].name, newcon->name) != 0)
                         continue;
-                if (console->index >= 0 &&
-                    console->index != console_cmdline[i].index)
+                if (newcon->index >= 0 &&
+                    newcon->index != console_cmdline[i].index)
                         continue;
-                if (console->index < 0)
-                        console->index = console_cmdline[i].index;
+                if (newcon->index < 0)
+                        newcon->index = console_cmdline[i].index;
 #ifdef CONFIG_A11Y_BRAILLE_CONSOLE
                 if (console_cmdline[i].brl_options) {
-                        console->flags |= CON_BRL;
-                        braille_register_console(console,
+                        newcon->flags |= CON_BRL;
+                        braille_register_console(newcon,
                                         console_cmdline[i].index,
                                         console_cmdline[i].options,
                                         console_cmdline[i].brl_options);
                         return;
                 }
 #endif
-                if (console->setup &&
-                    console->setup(console, console_cmdline[i].options) != 0)
+                if (newcon->setup &&
+                    newcon->setup(newcon, console_cmdline[i].options) != 0)
                         break;
-                console->flags |= CON_ENABLED;
-                console->index = console_cmdline[i].index;
+                newcon->flags |= CON_ENABLED;
+                newcon->index = console_cmdline[i].index;
                 if (i == selected_console) {
-                        console->flags |= CON_CONSDEV;
+                        newcon->flags |= CON_CONSDEV;
                         preferred_console = selected_console;
                 }
                 break;
         }
 
-        if (!(console->flags & CON_ENABLED))
+        if (!(newcon->flags & CON_ENABLED))
                 return;
 
-        if (bootconsole && (console->flags & CON_CONSDEV)) {
-                printk(KERN_INFO "console handover: boot [%s%d] -> real [%s%d]\n",
-                       bootconsole->name, bootconsole->index,
-                       console->name, console->index);
-                unregister_console(bootconsole);
-                console->flags &= ~CON_PRINTBUFFER;
-        } else {
-                printk(KERN_INFO "console [%s%d] enabled\n",
-                       console->name, console->index);
-        }
+        /*
+         * If we have a bootconsole, and are switching to a real console,
+         * don't print everything out again, since when the boot console, and
+         * the real console are the same physical device, it's annoying to
+         * see the beginning boot messages twice
+         */
+        if (bcon && ((newcon->flags & (CON_CONSDEV | CON_BOOT)) == CON_CONSDEV))
+                newcon->flags &= ~CON_PRINTBUFFER;
 
         /*
          *      Put this console in the list - keep the
          *      preferred driver at the head of the list.
          */
         acquire_console_sem();
-        if ((console->flags & CON_CONSDEV) || console_drivers == NULL) {
-                console->next = console_drivers;
-                console_drivers = console;
-                if (console->next)
-                        console->next->flags &= ~CON_CONSDEV;
+        if ((newcon->flags & CON_CONSDEV) || console_drivers == NULL) {
+                newcon->next = console_drivers;
+                console_drivers = newcon;
+                if (newcon->next)
+                        newcon->next->flags &= ~CON_CONSDEV;
         } else {
-                console->next = console_drivers->next;
-                console_drivers->next = console;
+                newcon->next = console_drivers->next;
+                console_drivers->next = newcon;
         }
-        if (console->flags & CON_PRINTBUFFER) {
+        if (newcon->flags & CON_PRINTBUFFER) {
                 /*
                  * release_console_sem() will print out the buffered messages
                  * for us.
@@ -1245,6 +1282,28 @@ void register_console(struct console *console)
                 spin_unlock_irqrestore(&logbuf_lock, flags);
         }
         release_console_sem();
+
+        /*
+         * By unregistering the bootconsoles after we enable the real console
+         * we get the "console xxx enabled" message on all the consoles -
+         * boot consoles, real consoles, etc - this is to ensure that end
+         * users know there might be something in the kernel's log buffer that
+         * went to the bootconsole (that they do not see on the real console)
+         */
+        if (bcon && ((newcon->flags & (CON_CONSDEV | CON_BOOT)) == CON_CONSDEV)) {
+                /* we need to iterate through twice, to make sure we print
+                 * everything out, before we unregister the console(s)
+                 */
+                printk(KERN_INFO "console [%s%d] enabled, bootconsole disabled\n",
+                        newcon->name, newcon->index);
+                for_each_console(bcon)
+                        if (bcon->flags & CON_BOOT)
+                                unregister_console(bcon);
+        } else {
+                printk(KERN_INFO "%sconsole [%s%d] enabled\n",
+                        (newcon->flags & CON_BOOT) ? "boot" : "" ,
+                        newcon->name, newcon->index);
+        }
 }
 EXPORT_SYMBOL(register_console);
 
@@ -1287,11 +1346,13 @@ EXPORT_SYMBOL(unregister_console);
 
 static int __init disable_boot_consoles(void)
 {
-        if (console_drivers != NULL) {
-                if (console_drivers->flags & CON_BOOT) {
+        struct console *con;
+
+        for_each_console(con) {
+                if (con->flags & CON_BOOT) {
                         printk(KERN_INFO "turn off boot console %s%d\n",
-                                console_drivers->name, console_drivers->index);
-                        return unregister_console(console_drivers);
+                                con->name, con->index);
+                        unregister_console(con);
                 }
         }
         return 0;
diff --git a/kernel/rcuclassic.c b/kernel/rcuclassic.c
deleted file mode 100644
index 0f2b0b311304..000000000000
--- a/kernel/rcuclassic.c
+++ /dev/null
@@ -1,807 +0,0 @@
-/*
- * Read-Copy Update mechanism for mutual exclusion
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; either version 2 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
- *
- * Copyright IBM Corporation, 2001
- *
- * Authors: Dipankar Sarma <dipankar@in.ibm.com>
- *          Manfred Spraul <manfred@colorfullife.com>
- *
- * Based on the original work by Paul McKenney <paulmck@us.ibm.com>
- * and inputs from Rusty Russell, Andrea Arcangeli and Andi Kleen.
- * Papers:
- * http://www.rdrop.com/users/paulmck/paper/rclockpdcsproof.pdf
- * http://lse.sourceforge.net/locking/rclock_OLS.2001.05.01c.sc.pdf (OLS2001)
- *
- * For detailed explanation of Read-Copy Update mechanism see -
- *              Documentation/RCU
- *
- */
-#include <linux/types.h>
-#include <linux/kernel.h>
-#include <linux/init.h>
-#include <linux/spinlock.h>
-#include <linux/smp.h>
-#include <linux/rcupdate.h>
-#include <linux/interrupt.h>
-#include <linux/sched.h>
-#include <asm/atomic.h>
-#include <linux/bitops.h>
-#include <linux/module.h>
-#include <linux/completion.h>
-#include <linux/moduleparam.h>
-#include <linux/percpu.h>
-#include <linux/notifier.h>
-#include <linux/cpu.h>
-#include <linux/mutex.h>
-#include <linux/time.h>
-
-#ifdef CONFIG_DEBUG_LOCK_ALLOC
-static struct lock_class_key rcu_lock_key;
-struct lockdep_map rcu_lock_map =
-        STATIC_LOCKDEP_MAP_INIT("rcu_read_lock", &rcu_lock_key);
-EXPORT_SYMBOL_GPL(rcu_lock_map);
-#endif
-
-
-/* Definition for rcupdate control block. */
-static struct rcu_ctrlblk rcu_ctrlblk = {
-        .cur = -300,
-        .completed = -300,
-        .pending = -300,
-        .lock = __SPIN_LOCK_UNLOCKED(&rcu_ctrlblk.lock),
-        .cpumask = CPU_BITS_NONE,
-};
-
-static struct rcu_ctrlblk rcu_bh_ctrlblk = {
-        .cur = -300,
-        .completed = -300,
-        .pending = -300,
-        .lock = __SPIN_LOCK_UNLOCKED(&rcu_bh_ctrlblk.lock),
-        .cpumask = CPU_BITS_NONE,
-};
-
-static DEFINE_PER_CPU(struct rcu_data, rcu_data);
-static DEFINE_PER_CPU(struct rcu_data, rcu_bh_data);
-
-/*
- * Increment the quiescent state counter.
- * The counter is a bit degenerated: We do not need to know
- * how many quiescent states passed, just if there was at least
- * one since the start of the grace period. Thus just a flag.
- */
-void rcu_qsctr_inc(int cpu)
-{
-        struct rcu_data *rdp = &per_cpu(rcu_data, cpu);
-        rdp->passed_quiesc = 1;
-}
-
-void rcu_bh_qsctr_inc(int cpu)
-{
-        struct rcu_data *rdp = &per_cpu(rcu_bh_data, cpu);
-        rdp->passed_quiesc = 1;
-}
-
-static int blimit = 10;
-static int qhimark = 10000;
-static int qlowmark = 100;
-
-#ifdef CONFIG_SMP
-static void force_quiescent_state(struct rcu_data *rdp,
-                        struct rcu_ctrlblk *rcp)
-{
-        int cpu;
-        unsigned long flags;
-
-        set_need_resched();
-        spin_lock_irqsave(&rcp->lock, flags);
-        if (unlikely(!rcp->signaled)) {
-                rcp->signaled = 1;
-                /*
-                 * Don't send IPI to itself. With irqs disabled,
-                 * rdp->cpu is the current cpu.
-                 *
-                 * cpu_online_mask is updated by the _cpu_down()
-                 * using __stop_machine(). Since we're in irqs disabled
-                 * section, __stop_machine() is not exectuting, hence
-                 * the cpu_online_mask is stable.
-                 *
-                 * However,  a cpu might have been offlined _just_ before
-                 * we disabled irqs while entering here.
-                 * And rcu subsystem might not yet have handled the CPU_DEAD
-                 * notification, leading to the offlined cpu's bit
-                 * being set in the rcp->cpumask.
-                 *
-                 * Hence cpumask = (rcp->cpumask & cpu_online_mask) to prevent
-                 * sending smp_reschedule() to an offlined CPU.
-                 */
-                for_each_cpu_and(cpu,
-                                  to_cpumask(rcp->cpumask), cpu_online_mask) {
-                        if (cpu != rdp->cpu)
-                                smp_send_reschedule(cpu);
-                }
-        }
-        spin_unlock_irqrestore(&rcp->lock, flags);
-}
-#else
-static inline void force_quiescent_state(struct rcu_data *rdp,
-                        struct rcu_ctrlblk *rcp)
-{
-        set_need_resched();
-}
-#endif
-
-static void __call_rcu(struct rcu_head *head, struct rcu_ctrlblk *rcp,
-                struct rcu_data *rdp)
-{
-        long batch;
-
-        head->next = NULL;
-        smp_mb(); /* Read of rcu->cur must happen after any change by caller. */
-
-        /*
-         * Determine the batch number of this callback.
-         *
-         * Using ACCESS_ONCE to avoid the following error when gcc eliminates
-         * local variable "batch" and emits codes like this:
-         *      1) rdp->batch = rcp->cur + 1 # gets old value
-         *      ......
-         *      2)rcu_batch_after(rcp->cur + 1, rdp->batch) # gets new value
-         * then [*nxttail[0], *nxttail[1]) may contain callbacks
-         * that batch# = rdp->batch, see the comment of struct rcu_data.
-         */
-        batch = ACCESS_ONCE(rcp->cur) + 1;
-
-        if (rdp->nxtlist && rcu_batch_after(batch, rdp->batch)) {
-                /* process callbacks */
-                rdp->nxttail[0] = rdp->nxttail[1];
-                rdp->nxttail[1] = rdp->nxttail[2];
-                if (rcu_batch_after(batch - 1, rdp->batch))
-                        rdp->nxttail[0] = rdp->nxttail[2];
-        }
-
-        rdp->batch = batch;
-        *rdp->nxttail[2] = head;
-        rdp->nxttail[2] = &head->next;
-
-        if (unlikely(++rdp->qlen > qhimark)) {
-                rdp->blimit = INT_MAX;
-                force_quiescent_state(rdp, &rcu_ctrlblk);
-        }
-}
-
-#ifdef CONFIG_RCU_CPU_STALL_DETECTOR
-
-static void record_gp_stall_check_time(struct rcu_ctrlblk *rcp)
-{
-        rcp->gp_start = jiffies;
-        rcp->jiffies_stall = jiffies + RCU_SECONDS_TILL_STALL_CHECK;
-}
-
-static void print_other_cpu_stall(struct rcu_ctrlblk *rcp)
-{
-        int cpu;
-        long delta;
-        unsigned long flags;
-
-        /* Only let one CPU complain about others per time interval. */
-
-        spin_lock_irqsave(&rcp->lock, flags);
-        delta = jiffies - rcp->jiffies_stall;
-        if (delta < 2 || rcp->cur != rcp->completed) {
-                spin_unlock_irqrestore(&rcp->lock, flags);
-                return;
-        }
-        rcp->jiffies_stall = jiffies + RCU_SECONDS_TILL_STALL_RECHECK;
-        spin_unlock_irqrestore(&rcp->lock, flags);
-
-        /* OK, time to rat on our buddy... */
-
-        printk(KERN_ERR "INFO: RCU detected CPU stalls:");
-        for_each_possible_cpu(cpu) {
-                if (cpumask_test_cpu(cpu, to_cpumask(rcp->cpumask)))
-                        printk(" %d", cpu);
-        }
-        printk(" (detected by %d, t=%ld jiffies)\n",
-               smp_processor_id(), (long)(jiffies - rcp->gp_start));
-}
-
-static void print_cpu_stall(struct rcu_ctrlblk *rcp)
-{
-        unsigned long flags;
-
-        printk(KERN_ERR "INFO: RCU detected CPU %d stall (t=%lu/%lu jiffies)\n",
-                        smp_processor_id(), jiffies,
-                        jiffies - rcp->gp_start);
-        dump_stack();
-        spin_lock_irqsave(&rcp->lock, flags);
-        if ((long)(jiffies - rcp->jiffies_stall) >= 0)
-                rcp->jiffies_stall =
-                        jiffies + RCU_SECONDS_TILL_STALL_RECHECK;
-        spin_unlock_irqrestore(&rcp->lock, flags);
-        set_need_resched();  /* kick ourselves to get things going. */
-}
-
-static void check_cpu_stall(struct rcu_ctrlblk *rcp)
-{
-        long delta;
-
-        delta = jiffies - rcp->jiffies_stall;
-        if (cpumask_test_cpu(smp_processor_id(), to_cpumask(rcp->cpumask)) &&
-                delta >= 0) {
-
-                /* We haven't checked in, so go dump stack. */
-                print_cpu_stall(rcp);
-
-        } else if (rcp->cur != rcp->completed && delta >= 2) {
-
-                /* They had two seconds to dump stack, so complain. */
-                print_other_cpu_stall(rcp);
-        }
-}
-
-#else /* #ifdef CONFIG_RCU_CPU_STALL_DETECTOR */
-
-static void record_gp_stall_check_time(struct rcu_ctrlblk *rcp)
-{
-}
-
-static inline void check_cpu_stall(struct rcu_ctrlblk *rcp)
-{
-}
-
-#endif /* #else #ifdef CONFIG_RCU_CPU_STALL_DETECTOR */
-
-/**
- * call_rcu - Queue an RCU callback for invocation after a grace period.
- * @head: structure to be used for queueing the RCU updates.
- * @func: actual update function to be invoked after the grace period
- *
- * The update function will be invoked some time after a full grace
- * period elapses, in other words after all currently executing RCU
- * read-side critical sections have completed.  RCU read-side critical
- * sections are delimited by rcu_read_lock() and rcu_read_unlock(),
- * and may be nested.
- */
-void call_rcu(struct rcu_head *head,
-                                void (*func)(struct rcu_head *rcu))
-{
-        unsigned long flags;
-
-        head->func = func;
-        local_irq_save(flags);
-        __call_rcu(head, &rcu_ctrlblk, &__get_cpu_var(rcu_data));
-        local_irq_restore(flags);
-}
-EXPORT_SYMBOL_GPL(call_rcu);
-
-/**
- * call_rcu_bh - Queue an RCU for invocation after a quicker grace period.
- * @head: structure to be used for queueing the RCU updates.
- * @func: actual update function to be invoked after the grace period
- *
- * The update function will be invoked some time after a full grace
- * period elapses, in other words after all currently executing RCU
- * read-side critical sections have completed. call_rcu_bh() assumes
- * that the read-side critical sections end on completion of a softirq
- * handler. This means that read-side critical sections in process
- * context must not be interrupted by softirqs. This interface is to be
- * used when most of the read-side critical sections are in softirq context.
- * RCU read-side critical sections are delimited by rcu_read_lock() and
- * rcu_read_unlock(), * if in interrupt context or rcu_read_lock_bh()
- * and rcu_read_unlock_bh(), if in process context. These may be nested.
- */
-void call_rcu_bh(struct rcu_head *head,
-                                void (*func)(struct rcu_head *rcu))
-{
-        unsigned long flags;
-
-        head->func = func;
-        local_irq_save(flags);
-        __call_rcu(head, &rcu_bh_ctrlblk, &__get_cpu_var(rcu_bh_data));
-        local_irq_restore(flags);
-}
-EXPORT_SYMBOL_GPL(call_rcu_bh);
-
-/*
- * Return the number of RCU batches processed thus far.  Useful
- * for debug and statistics.
- */
-long rcu_batches_completed(void)
-{
-        return rcu_ctrlblk.completed;
-}
-EXPORT_SYMBOL_GPL(rcu_batches_completed);
-
-/*
- * Return the number of RCU batches processed thus far.  Useful
- * for debug and statistics.
- */
-long rcu_batches_completed_bh(void)
-{
-        return rcu_bh_ctrlblk.completed;
-}
-EXPORT_SYMBOL_GPL(rcu_batches_completed_bh);
-
-/* Raises the softirq for processing rcu_callbacks. */
-static inline void raise_rcu_softirq(void)
-{
-        raise_softirq(RCU_SOFTIRQ);
-}
-
-/*
- * Invoke the completed RCU callbacks. They are expected to be in
- * a per-cpu list.
- */
-static void rcu_do_batch(struct rcu_data *rdp)
-{
-        unsigned long flags;
-        struct rcu_head *next, *list;
-        int count = 0;
-
-        list = rdp->donelist;
-        while (list) {
-                next = list->next;
-                prefetch(next);
-                list->func(list);
-                list = next;
-                if (++count >= rdp->blimit)
-                        break;
-        }
-        rdp->donelist = list;
-
-        local_irq_save(flags);
-        rdp->qlen -= count;
-        local_irq_restore(flags);
-        if (rdp->blimit == INT_MAX && rdp->qlen <= qlowmark)
-                rdp->blimit = blimit;
-
-        if (!rdp->donelist)
-                rdp->donetail = &rdp->donelist;
-        else
-                raise_rcu_softirq();
-}
-
-/*
- * Grace period handling:
- * The grace period handling consists out of two steps:
- * - A new grace period is started.
- *   This is done by rcu_start_batch. The start is not broadcasted to
- *   all cpus, they must pick this up by comparing rcp->cur with
- *   rdp->quiescbatch. All cpus are recorded  in the
- *   rcu_ctrlblk.cpumask bitmap.
- * - All cpus must go through a quiescent state.
- *   Since the start of the grace period is not broadcasted, at least two
- *   calls to rcu_check_quiescent_state are required:
- *   The first call just notices that a new grace period is running. The
- *   following calls check if there was a quiescent state since the beginning
- *   of the grace period. If so, it updates rcu_ctrlblk.cpumask. If
- *   the bitmap is empty, then the grace period is completed.
- *   rcu_check_quiescent_state calls rcu_start_batch(0) to start the next grace
- *   period (if necessary).
- */
-
-/*
- * Register a new batch of callbacks, and start it up if there is currently no
- * active batch and the batch to be registered has not already occurred.
- * Caller must hold rcu_ctrlblk.lock.
- */
-static void rcu_start_batch(struct rcu_ctrlblk *rcp)
-{
-        if (rcp->cur != rcp->pending &&
-                        rcp->completed == rcp->cur) {
-                rcp->cur++;
-                record_gp_stall_check_time(rcp);
-
-                /*
-                 * Accessing nohz_cpu_mask before incrementing rcp->cur needs a
-                 * Barrier  Otherwise it can cause tickless idle CPUs to be
-                 * included in rcp->cpumask, which will extend graceperiods
-                 * unnecessarily.
-                 */
-                smp_mb();
-                cpumask_andnot(to_cpumask(rcp->cpumask),
-                               cpu_online_mask, nohz_cpu_mask);
-
-                rcp->signaled = 0;
-        }
-}
-
-/*
- * cpu went through a quiescent state since the beginning of the grace period.
- * Clear it from the cpu mask and complete the grace period if it was the last
- * cpu. Start another grace period if someone has further entries pending
- */
-static void cpu_quiet(int cpu, struct rcu_ctrlblk *rcp)
-{
-        cpumask_clear_cpu(cpu, to_cpumask(rcp->cpumask));
-        if (cpumask_empty(to_cpumask(rcp->cpumask))) {
-                /* batch completed ! */
-                rcp->completed = rcp->cur;
-                rcu_start_batch(rcp);
-        }
-}
-
-/*
- * Check if the cpu has gone through a quiescent state (say context
- * switch). If so and if it already hasn't done so in this RCU
- * quiescent cycle, then indicate that it has done so.
- */
-static void rcu_check_quiescent_state(struct rcu_ctrlblk *rcp,
-                                        struct rcu_data *rdp)
-{
-        unsigned long flags;
-
-        if (rdp->quiescbatch != rcp->cur) {
-                /* start new grace period: */
-                rdp->qs_pending = 1;
-                rdp->passed_quiesc = 0;
-                rdp->quiescbatch = rcp->cur;
-                return;
-        }
-
-        /* Grace period already completed for this cpu?
-         * qs_pending is checked instead of the actual bitmap to avoid
-         * cacheline trashing.
-         */
-        if (!rdp->qs_pending)
-                return;
-
-        /*
-         * Was there a quiescent state since the beginning of the grace
-         * period? If no, then exit and wait for the next call.
-         */
-        if (!rdp->passed_quiesc)
-                return;
-        rdp->qs_pending = 0;
-
-        spin_lock_irqsave(&rcp->lock, flags);
-        /*
-         * rdp->quiescbatch/rcp->cur and the cpu bitmap can come out of sync
-         * during cpu startup. Ignore the quiescent state.
-         */
-        if (likely(rdp->quiescbatch == rcp->cur))
-                cpu_quiet(rdp->cpu, rcp);
-
-        spin_unlock_irqrestore(&rcp->lock, flags);
-}
-
-
-#ifdef CONFIG_HOTPLUG_CPU
-
-/* warning! helper for rcu_offline_cpu. do not use elsewhere without reviewing
- * locking requirements, the list it's pulling from has to belong to a cpu
- * which is dead and hence not processing interrupts.
- */
-static void rcu_move_batch(struct rcu_data *this_rdp, struct rcu_head *list,
-                                struct rcu_head **tail, long batch)
-{
-        unsigned long flags;
-
-        if (list) {
-                local_irq_save(flags);
-                this_rdp->batch = batch;
-                *this_rdp->nxttail[2] = list;
-                this_rdp->nxttail[2] = tail;
-                local_irq_restore(flags);
-        }
-}
-
-static void __rcu_offline_cpu(struct rcu_data *this_rdp,
-                                struct rcu_ctrlblk *rcp, struct rcu_data *rdp)
-{
-        unsigned long flags;
-
-        /*
-         * if the cpu going offline owns the grace period
-         * we can block indefinitely waiting for it, so flush
-         * it here
-         */
-        spin_lock_irqsave(&rcp->lock, flags);
-        if (rcp->cur != rcp->completed)
-                cpu_quiet(rdp->cpu, rcp);
-        rcu_move_batch(this_rdp, rdp->donelist, rdp->donetail, rcp->cur + 1);
-        rcu_move_batch(this_rdp, rdp->nxtlist, rdp->nxttail[2], rcp->cur + 1);
-        spin_unlock(&rcp->lock);
-
-        this_rdp->qlen += rdp->qlen;
-        local_irq_restore(flags);
-}
-
-static void rcu_offline_cpu(int cpu)
-{
-        struct rcu_data *this_rdp = &get_cpu_var(rcu_data);
-        struct rcu_data *this_bh_rdp = &get_cpu_var(rcu_bh_data);
-
-        __rcu_offline_cpu(this_rdp, &rcu_ctrlblk,
-                                        &per_cpu(rcu_data, cpu));
-        __rcu_offline_cpu(this_bh_rdp, &rcu_bh_ctrlblk,
-                                        &per_cpu(rcu_bh_data, cpu));
-        put_cpu_var(rcu_data);
-        put_cpu_var(rcu_bh_data);
-}
-
-#else
-
-static void rcu_offline_cpu(int cpu)
-{
-}
-
-#endif
-
-/*
- * This does the RCU processing work from softirq context.
- */
-static void __rcu_process_callbacks(struct rcu_ctrlblk *rcp,
-                                        struct rcu_data *rdp)
-{
-        unsigned long flags;
-        long completed_snap;
-
-        if (rdp->nxtlist) {
-                local_irq_save(flags);
-                completed_snap = ACCESS_ONCE(rcp->completed);
-
-                /*
-                 * move the other grace-period-completed entries to
-                 * [rdp->nxtlist, *rdp->nxttail[0]) temporarily
-                 */
-                if (!rcu_batch_before(completed_snap, rdp->batch))
-                        rdp->nxttail[0] = rdp->nxttail[1] = rdp->nxttail[2];
-                else if (!rcu_batch_before(completed_snap, rdp->batch - 1))
-                        rdp->nxttail[0] = rdp->nxttail[1];
-
-                /*
-                 * the grace period for entries in
-                 * [rdp->nxtlist, *rdp->nxttail[0]) has completed and
-                 * move these entries to donelist
-                 */
-                if (rdp->nxttail[0] != &rdp->nxtlist) {
-                        *rdp->donetail = rdp->nxtlist;
-                        rdp->donetail = rdp->nxttail[0];
-                        rdp->nxtlist = *rdp->nxttail[0];
-                        *rdp->donetail = NULL;
-
-                        if (rdp->nxttail[1] == rdp->nxttail[0])
-                                rdp->nxttail[1] = &rdp->nxtlist;
-                        if (rdp->nxttail[2] == rdp->nxttail[0])
-                                rdp->nxttail[2] = &rdp->nxtlist;
-                        rdp->nxttail[0] = &rdp->nxtlist;
-                }
-
-                local_irq_restore(flags);
-
-                if (rcu_batch_after(rdp->batch, rcp->pending)) {
-                        unsigned long flags2;
-
-                        /* and start it/schedule start if it's a new batch */
-                        spin_lock_irqsave(&rcp->lock, flags2);
-                        if (rcu_batch_after(rdp->batch, rcp->pending)) {
-                                rcp->pending = rdp->batch;
-                                rcu_start_batch(rcp);
-                        }
-                        spin_unlock_irqrestore(&rcp->lock, flags2);
-                }
-        }
-
-        rcu_check_quiescent_state(rcp, rdp);
-        if (rdp->donelist)
-                rcu_do_batch(rdp);
-}
-
-static void rcu_process_callbacks(struct softirq_action *unused)
-{
-        /*
-         * Memory references from any prior RCU read-side critical sections
-         * executed by the interrupted code must be see before any RCU
-         * grace-period manupulations below.
-         */
-
-        smp_mb(); /* See above block comment. */
-
-        __rcu_process_callbacks(&rcu_ctrlblk, &__get_cpu_var(rcu_data));
-        __rcu_process_callbacks(&rcu_bh_ctrlblk, &__get_cpu_var(rcu_bh_data));
-
-        /*
-         * Memory references from any later RCU read-side critical sections
-         * executed by the interrupted code must be see after any RCU
-         * grace-period manupulations above.
-         */
-
-        smp_mb(); /* See above block comment. */
-}
-
-static int __rcu_pending(struct rcu_ctrlblk *rcp, struct rcu_data *rdp)
-{
-        /* Check for CPU stalls, if enabled. */
-        check_cpu_stall(rcp);
-
-        if (rdp->nxtlist) {
-                long completed_snap = ACCESS_ONCE(rcp->completed);
-
-                /*
-                 * This cpu has pending rcu entries and the grace period
-                 * for them has completed.
-                 */
-                if (!rcu_batch_before(completed_snap, rdp->batch))
-                        return 1;
-                if (!rcu_batch_before(completed_snap, rdp->batch - 1) &&
-                                rdp->nxttail[0] != rdp->nxttail[1])
-                        return 1;
-                if (rdp->nxttail[0] != &rdp->nxtlist)
-                        return 1;
-
-                /*
-                 * This cpu has pending rcu entries and the new batch
-                 * for then hasn't been started nor scheduled start
-                 */
-                if (rcu_batch_after(rdp->batch, rcp->pending))
-                        return 1;
-        }
-
-        /* This cpu has finished callbacks to invoke */
-        if (rdp->donelist)
-                return 1;
-
-        /* The rcu core waits for a quiescent state from the cpu */
-        if (rdp->quiescbatch != rcp->cur || rdp->qs_pending)
-                return 1;
-
-        /* nothing to do */
-        return 0;
-}
-
-/*
- * Check to see if there is any immediate RCU-related work to be done
- * by the current CPU, returning 1 if so.  This function is part of the
- * RCU implementation; it is -not- an exported member of the RCU API.
- */
-int rcu_pending(int cpu)
-{
-        return __rcu_pending(&rcu_ctrlblk, &per_cpu(rcu_data, cpu)) ||
-                __rcu_pending(&rcu_bh_ctrlblk, &per_cpu(rcu_bh_data, cpu));
-}
-
-/*
- * Check to see if any future RCU-related work will need to be done
- * by the current CPU, even if none need be done immediately, returning
- * 1 if so.  This function is part of the RCU implementation; it is -not-
- * an exported member of the RCU API.
- */
-int rcu_needs_cpu(int cpu)
-{
-        struct rcu_data *rdp = &per_cpu(rcu_data, cpu);
-        struct rcu_data *rdp_bh = &per_cpu(rcu_bh_data, cpu);
-
-        return !!rdp->nxtlist || !!rdp_bh->nxtlist || rcu_pending(cpu);
-}
-
-/*
- * Top-level function driving RCU grace-period detection, normally
- * invoked from the scheduler-clock interrupt.  This function simply
- * increments counters that are read only from softirq by this same
- * CPU, so there are no memory barriers required.
- */
-void rcu_check_callbacks(int cpu, int user)
-{
-        if (user ||
-            (idle_cpu(cpu) && rcu_scheduler_active &&
-             !in_softirq() && hardirq_count() <= (1 << HARDIRQ_SHIFT))) {
-
-                /*
-                 * Get here if this CPU took its interrupt from user
-                 * mode or from the idle loop, and if this is not a
-                 * nested interrupt.  In this case, the CPU is in
-                 * a quiescent state, so count it.
-                 *
-                 * Also do a memory barrier.  This is needed to handle
-                 * the case where writes from a preempt-disable section
-                 * of code get reordered into schedule() by this CPU's
-                 * write buffer.  The memory barrier makes sure that
-                 * the rcu_qsctr_inc() and rcu_bh_qsctr_inc() are see
-                 * by other CPUs to happen after any such write.
-                 */
-
-                smp_mb();  /* See above block comment. */
-                rcu_qsctr_inc(cpu);
-                rcu_bh_qsctr_inc(cpu);
-
-        } else if (!in_softirq()) {
-
-                /*
-                 * Get here if this CPU did not take its interrupt from
-                 * softirq, in other words, if it is not interrupting
-                 * a rcu_bh read-side critical section.  This is an _bh
-                 * critical section, so count it.  The memory barrier
-                 * is needed for the same reason as is the above one.
-                 */
-
-                smp_mb();  /* See above block comment. */
-                rcu_bh_qsctr_inc(cpu);
-        }
-        raise_rcu_softirq();
-}
-
-static void __cpuinit rcu_init_percpu_data(int cpu, struct rcu_ctrlblk *rcp,
-                                                struct rcu_data *rdp)
-{
-        unsigned long flags;
-
-        spin_lock_irqsave(&rcp->lock, flags);
-        memset(rdp, 0, sizeof(*rdp));
-        rdp->nxttail[0] = rdp->nxttail[1] = rdp->nxttail[2] = &rdp->nxtlist;
-        rdp->donetail = &rdp->donelist;
-        rdp->quiescbatch = rcp->completed;
-        rdp->qs_pending = 0;
-        rdp->cpu = cpu;
-        rdp->blimit = blimit;
-        spin_unlock_irqrestore(&rcp->lock, flags);
-}
-
-static void __cpuinit rcu_online_cpu(int cpu)
-{
-        struct rcu_data *rdp = &per_cpu(rcu_data, cpu);
-        struct rcu_data *bh_rdp = &per_cpu(rcu_bh_data, cpu);
-
-        rcu_init_percpu_data(cpu, &rcu_ctrlblk, rdp);
-        rcu_init_percpu_data(cpu, &rcu_bh_ctrlblk, bh_rdp);
-        open_softirq(RCU_SOFTIRQ, rcu_process_callbacks);
-}
-
-static int __cpuinit rcu_cpu_notify(struct notifier_block *self,
-                                unsigned long action, void *hcpu)
-{
-        long cpu = (long)hcpu;
-
-        switch (action) {
-        case CPU_UP_PREPARE:
-        case CPU_UP_PREPARE_FROZEN:
-                rcu_online_cpu(cpu);
-                break;
-        case CPU_DEAD:
-        case CPU_DEAD_FROZEN:
-                rcu_offline_cpu(cpu);
-                break;
-        default:
-                break;
-        }
-        return NOTIFY_OK;
-}
-
-static struct notifier_block __cpuinitdata rcu_nb = {
-        .notifier_call  = rcu_cpu_notify,
-};
-
-/*
- * Initializes rcu mechanism.  Assumed to be called early.
- * That is before local timer(SMP) or jiffie timer (uniproc) is setup.
- * Note that rcu_qsctr and friends are implicitly
- * initialized due to the choice of ``0'' for RCU_CTR_INVALID.
- */
-void __init __rcu_init(void)
-{
-#ifdef CONFIG_RCU_CPU_STALL_DETECTOR
-        printk(KERN_INFO "RCU-based detection of stalled CPUs is enabled.\n");
-#endif /* #ifdef CONFIG_RCU_CPU_STALL_DETECTOR */
-        rcu_cpu_notify(&rcu_nb, CPU_UP_PREPARE,
-                        (void *)(long)smp_processor_id());
-        /* Register notifier for non-boot CPUs */
-        register_cpu_notifier(&rcu_nb);
-}
-
-module_param(blimit, int, 0);
-module_param(qhimark, int, 0);
-module_param(qlowmark, int, 0);
diff --git a/kernel/rcupdate.c b/kernel/rcupdate.c
index a967c9feb90a..bd5d5c8e5140 100644
--- a/kernel/rcupdate.c
+++ b/kernel/rcupdate.c
@@ -98,6 +98,30 @@ void synchronize_rcu(void)
 }
 EXPORT_SYMBOL_GPL(synchronize_rcu);
 
+/**
+ * synchronize_rcu_bh - wait until an rcu_bh grace period has elapsed.
+ *
+ * Control will return to the caller some time after a full rcu_bh grace
+ * period has elapsed, in other words after all currently executing rcu_bh
+ * read-side critical sections have completed.  RCU read-side critical
+ * sections are delimited by rcu_read_lock_bh() and rcu_read_unlock_bh(),
+ * and may be nested.
+ */
+void synchronize_rcu_bh(void)
+{
+        struct rcu_synchronize rcu;
+
+        if (rcu_blocking_is_gp())
+                return;
+
+        init_completion(&rcu.completion);
+        /* Will wake me after RCU finished. */
+        call_rcu_bh(&rcu.head, wakeme_after_rcu);
+        /* Wait for it. */
+        wait_for_completion(&rcu.completion);
+}
+EXPORT_SYMBOL_GPL(synchronize_rcu_bh);
+
 static void rcu_barrier_callback(struct rcu_head *notused)
 {
         if (atomic_dec_and_test(&rcu_barrier_cpu_count))
@@ -129,6 +153,7 @@ static void rcu_barrier_func(void *type)
 static inline void wait_migrated_callbacks(void)
 {
         wait_event(rcu_migrate_wq, !atomic_read(&rcu_migrate_type_count));
+        smp_mb(); /* In case we didn't sleep. */
 }
 
 /*
@@ -192,9 +217,13 @@ static void rcu_migrate_callback(struct rcu_head *notused)
                 wake_up(&rcu_migrate_wq);
 }
 
+extern int rcu_cpu_notify(struct notifier_block *self,
+                          unsigned long action, void *hcpu);
+
 static int __cpuinit rcu_barrier_cpu_hotplug(struct notifier_block *self,
                 unsigned long action, void *hcpu)
 {
+        rcu_cpu_notify(self, action, hcpu);
         if (action == CPU_DYING) {
                 /*
                  * preempt_disable() in on_each_cpu() prevents stop_machine(),
@@ -209,7 +238,8 @@ static int __cpuinit rcu_barrier_cpu_hotplug(struct notifier_block *self,
                 call_rcu_bh(rcu_migrate_head, rcu_migrate_callback);
                 call_rcu_sched(rcu_migrate_head + 1, rcu_migrate_callback);
                 call_rcu(rcu_migrate_head + 2, rcu_migrate_callback);
-        } else if (action == CPU_POST_DEAD) {
+        } else if (action == CPU_DOWN_PREPARE) {
+                /* Don't need to wait until next removal operation. */
                 /* rcu_migrate_head is protected by cpu_add_remove_lock */
                 wait_migrated_callbacks();
         }
@@ -219,8 +249,18 @@ static int __cpuinit rcu_barrier_cpu_hotplug(struct notifier_block *self,
 
 void __init rcu_init(void)
 {
+        int i;
+
         __rcu_init();
-        hotcpu_notifier(rcu_barrier_cpu_hotplug, 0);
+        cpu_notifier(rcu_barrier_cpu_hotplug, 0);
+
+        /*
+         * We don't need protection against CPU-hotplug here because
+         * this is called early in boot, before either interrupts
+         * or the scheduler are operational.
+         */
+        for_each_online_cpu(i)
+                rcu_barrier_cpu_hotplug(NULL, CPU_UP_PREPARE, (void *)(long)i);
 }
 
 void rcu_scheduler_starting(void)
diff --git a/kernel/rcupreempt.c b/kernel/rcupreempt.c
deleted file mode 100644
index beb0e659adcc..000000000000
--- a/kernel/rcupreempt.c
+++ /dev/null
@@ -1,1539 +0,0 @@
-/*
- * Read-Copy Update mechanism for mutual exclusion, realtime implementation
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; either version 2 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
- *
- * Copyright IBM Corporation, 2006
- *
- * Authors: Paul E. McKenney <paulmck@us.ibm.com>
- *              With thanks to Esben Nielsen, Bill Huey, and Ingo Molnar
- *              for pushing me away from locks and towards counters, and
- *              to Suparna Bhattacharya for pushing me completely away
- *              from atomic instructions on the read side.
- *
- *  - Added handling of Dynamic Ticks
- *      Copyright 2007 - Paul E. Mckenney <paulmck@us.ibm.com>
- *                     - Steven Rostedt <srostedt@redhat.com>
- *
- * Papers:  http://www.rdrop.com/users/paulmck/RCU
- *
- * Design Document: http://lwn.net/Articles/253651/
- *
- * For detailed explanation of Read-Copy Update mechanism see -
- *              Documentation/RCU/ *.txt
- *
- */
-#include <linux/types.h>
-#include <linux/kernel.h>
-#include <linux/init.h>
-#include <linux/spinlock.h>
-#include <linux/smp.h>
-#include <linux/rcupdate.h>
-#include <linux/interrupt.h>
-#include <linux/sched.h>
-#include <asm/atomic.h>
-#include <linux/bitops.h>
-#include <linux/module.h>
-#include <linux/kthread.h>
-#include <linux/completion.h>
-#include <linux/moduleparam.h>
-#include <linux/percpu.h>
-#include <linux/notifier.h>
-#include <linux/cpu.h>
-#include <linux/random.h>
-#include <linux/delay.h>
-#include <linux/cpumask.h>
-#include <linux/rcupreempt_trace.h>
-#include <asm/byteorder.h>
-
-/*
- * PREEMPT_RCU data structures.
- */
-
-/*
- * GP_STAGES specifies the number of times the state machine has
- * to go through the all the rcu_try_flip_states (see below)
- * in a single Grace Period.
- *
- * GP in GP_STAGES stands for Grace Period ;)
- */
-#define GP_STAGES    2
-struct rcu_data {
-        spinlock_t      lock;           /* Protect rcu_data fields. */
-        long            completed;      /* Number of last completed batch. */
-        int             waitlistcount;
-        struct rcu_head *nextlist;
-        struct rcu_head **nexttail;
-        struct rcu_head *waitlist[GP_STAGES];
-        struct rcu_head **waittail[GP_STAGES];
-        struct rcu_head *donelist;      /* from waitlist & waitschedlist */
-        struct rcu_head **donetail;
-        long rcu_flipctr[2];
-        struct rcu_head *nextschedlist;
-        struct rcu_head **nextschedtail;
-        struct rcu_head *waitschedlist;
-        struct rcu_head **waitschedtail;
-        int rcu_sched_sleeping;
-#ifdef CONFIG_RCU_TRACE
-        struct rcupreempt_trace trace;
-#endif /* #ifdef CONFIG_RCU_TRACE */
-};
-
-/*
- * States for rcu_try_flip() and friends.
- */
-
-enum rcu_try_flip_states {
-
-        /*
-         * Stay here if nothing is happening. Flip the counter if somthing
-         * starts happening. Denoted by "I"
-         */
-        rcu_try_flip_idle_state,
-
-        /*
-         * Wait here for all CPUs to notice that the counter has flipped. This
-         * prevents the old set of counters from ever being incremented once
-         * we leave this state, which in turn is necessary because we cannot
-         * test any individual counter for zero -- we can only check the sum.
-         * Denoted by "A".
-         */
-        rcu_try_flip_waitack_state,
-
-        /*
-         * Wait here for the sum of the old per-CPU counters to reach zero.
-         * Denoted by "Z".
-         */
-        rcu_try_flip_waitzero_state,
-
-        /*
-         * Wait here for each of the other CPUs to execute a memory barrier.
-         * This is necessary to ensure that these other CPUs really have
-         * completed executing their RCU read-side critical sections, despite
-         * their CPUs wildly reordering memory. Denoted by "M".
-         */
-        rcu_try_flip_waitmb_state,
-};
-
-/*
- * States for rcu_ctrlblk.rcu_sched_sleep.
- */
-
-enum rcu_sched_sleep_states {
-        rcu_sched_not_sleeping, /* Not sleeping, callbacks need GP.  */
-        rcu_sched_sleep_prep,   /* Thinking of sleeping, rechecking. */
-        rcu_sched_sleeping,     /* Sleeping, awaken if GP needed. */
-};
-
-struct rcu_ctrlblk {
-        spinlock_t      fliplock;       /* Protect state-machine transitions. */
-        long            completed;      /* Number of last completed batch. */
-        enum rcu_try_flip_states rcu_try_flip_state; /* The current state of
-                                                        the rcu state machine */
-        spinlock_t      schedlock;      /* Protect rcu_sched sleep state. */
-        enum rcu_sched_sleep_states sched_sleep; /* rcu_sched state. */
-        wait_queue_head_t sched_wq;     /* Place for rcu_sched to sleep. */
-};
-
-struct rcu_dyntick_sched {
-        int dynticks;
-        int dynticks_snap;
-        int sched_qs;
-        int sched_qs_snap;
-        int sched_dynticks_snap;
-};
-
-static DEFINE_PER_CPU_SHARED_ALIGNED(struct rcu_dyntick_sched, rcu_dyntick_sched) = {
-        .dynticks = 1,
-};
-
-void rcu_qsctr_inc(int cpu)
-{
-        struct rcu_dyntick_sched *rdssp = &per_cpu(rcu_dyntick_sched, cpu);
-
-        rdssp->sched_qs++;
-}
-
-#ifdef CONFIG_NO_HZ
-
-void rcu_enter_nohz(void)
-{
-        static DEFINE_RATELIMIT_STATE(rs, 10 * HZ, 1);
-
-        smp_mb(); /* CPUs seeing ++ must see prior RCU read-side crit sects */
-        __get_cpu_var(rcu_dyntick_sched).dynticks++;
-        WARN_ON_RATELIMIT(__get_cpu_var(rcu_dyntick_sched).dynticks & 0x1, &rs);
-}
-
-void rcu_exit_nohz(void)
-{
-        static DEFINE_RATELIMIT_STATE(rs, 10 * HZ, 1);
-
-        __get_cpu_var(rcu_dyntick_sched).dynticks++;
-        smp_mb(); /* CPUs seeing ++ must see later RCU read-side crit sects */
-        WARN_ON_RATELIMIT(!(__get_cpu_var(rcu_dyntick_sched).dynticks & 0x1),
-                                &rs);
-}
-
-#endif /* CONFIG_NO_HZ */
-
-
-static DEFINE_PER_CPU(struct rcu_data, rcu_data);
-
-static struct rcu_ctrlblk rcu_ctrlblk = {
-        .fliplock = __SPIN_LOCK_UNLOCKED(rcu_ctrlblk.fliplock),
-        .completed = 0,
-        .rcu_try_flip_state = rcu_try_flip_idle_state,
-        .schedlock = __SPIN_LOCK_UNLOCKED(rcu_ctrlblk.schedlock),
-        .sched_sleep = rcu_sched_not_sleeping,
-        .sched_wq = __WAIT_QUEUE_HEAD_INITIALIZER(rcu_ctrlblk.sched_wq),
-};
-
-static struct task_struct *rcu_sched_grace_period_task;
-
-#ifdef CONFIG_RCU_TRACE
-static char *rcu_try_flip_state_names[] =
-        { "idle", "waitack", "waitzero", "waitmb" };
-#endif /* #ifdef CONFIG_RCU_TRACE */
-
-static DECLARE_BITMAP(rcu_cpu_online_map, NR_CPUS) __read_mostly
-        = CPU_BITS_NONE;
-
-/*
- * Enum and per-CPU flag to determine when each CPU has seen
- * the most recent counter flip.
- */
-
-enum rcu_flip_flag_values {
-        rcu_flip_seen,          /* Steady/initial state, last flip seen. */
-                                /* Only GP detector can update. */
-        rcu_flipped             /* Flip just completed, need confirmation. */
-                                /* Only corresponding CPU can update. */
-};
-static DEFINE_PER_CPU_SHARED_ALIGNED(enum rcu_flip_flag_values, rcu_flip_flag)
-                                                                = rcu_flip_seen;
-
-/*
- * Enum and per-CPU flag to determine when each CPU has executed the
- * needed memory barrier to fence in memory references from its last RCU
- * read-side critical section in the just-completed grace period.
- */
-
-enum rcu_mb_flag_values {
-        rcu_mb_done,            /* Steady/initial state, no mb()s required. */
-                                /* Only GP detector can update. */
-        rcu_mb_needed           /* Flip just completed, need an mb(). */
-                                /* Only corresponding CPU can update. */
-};
-static DEFINE_PER_CPU_SHARED_ALIGNED(enum rcu_mb_flag_values, rcu_mb_flag)
-                                                                = rcu_mb_done;
-
-/*
- * RCU_DATA_ME: find the current CPU's rcu_data structure.
- * RCU_DATA_CPU: find the specified CPU's rcu_data structure.
- */
-#define RCU_DATA_ME()           (&__get_cpu_var(rcu_data))
-#define RCU_DATA_CPU(cpu)       (&per_cpu(rcu_data, cpu))
-
-/*
- * Helper macro for tracing when the appropriate rcu_data is not
- * cached in a local variable, but where the CPU number is so cached.
- */
-#define RCU_TRACE_CPU(f, cpu) RCU_TRACE(f, &(RCU_DATA_CPU(cpu)->trace));
-
-/*
- * Helper macro for tracing when the appropriate rcu_data is not
- * cached in a local variable.
- */
-#define RCU_TRACE_ME(f) RCU_TRACE(f, &(RCU_DATA_ME()->trace));
-
-/*
- * Helper macro for tracing when the appropriate rcu_data is pointed
- * to by a local variable.
- */
-#define RCU_TRACE_RDP(f, rdp) RCU_TRACE(f, &((rdp)->trace));
-
-#define RCU_SCHED_BATCH_TIME (HZ / 50)
-
-/*
- * Return the number of RCU batches processed thus far.  Useful
- * for debug and statistics.
- */
-long rcu_batches_completed(void)
-{
-        return rcu_ctrlblk.completed;
-}
-EXPORT_SYMBOL_GPL(rcu_batches_completed);
-
-void __rcu_read_lock(void)
-{
-        int idx;
-        struct task_struct *t = current;
-        int nesting;
-
-        nesting = ACCESS_ONCE(t->rcu_read_lock_nesting);
-        if (nesting != 0) {
-
-                /* An earlier rcu_read_lock() covers us, just count it. */
-
-                t->rcu_read_lock_nesting = nesting + 1;
-
-        } else {
-                unsigned long flags;
-
-                /*
-                 * We disable interrupts for the following reasons:
-                 * - If we get scheduling clock interrupt here, and we
-                 *   end up acking the counter flip, it's like a promise
-                 *   that we will never increment the old counter again.
-                 *   Thus we will break that promise if that
-                 *   scheduling clock interrupt happens between the time
-                 *   we pick the .completed field and the time that we
-                 *   increment our counter.
-                 *
-                 * - We don't want to be preempted out here.
-                 *
-                 * NMIs can still occur, of course, and might themselves
-                 * contain rcu_read_lock().
-                 */
-
-                local_irq_save(flags);
-
-                /*
-                 * Outermost nesting of rcu_read_lock(), so increment
-                 * the current counter for the current CPU.  Use volatile
-                 * casts to prevent the compiler from reordering.
-                 */
-
-                idx = ACCESS_ONCE(rcu_ctrlblk.completed) & 0x1;
-                ACCESS_ONCE(RCU_DATA_ME()->rcu_flipctr[idx])++;
-
-                /*
-                 * Now that the per-CPU counter has been incremented, we
-                 * are protected from races with rcu_read_lock() invoked
-                 * from NMI handlers on this CPU.  We can therefore safely
-                 * increment the nesting counter, relieving further NMIs
-                 * of the need to increment the per-CPU counter.
-                 */
-
-                ACCESS_ONCE(t->rcu_read_lock_nesting) = nesting + 1;
-
-                /*
-                 * Now that we have preventing any NMIs from storing
-                 * to the ->rcu_flipctr_idx, we can safely use it to
-                 * remember which counter to decrement in the matching
-                 * rcu_read_unlock().
-                 */
-
-                ACCESS_ONCE(t->rcu_flipctr_idx) = idx;
-                local_irq_restore(flags);
-        }
-}
-EXPORT_SYMBOL_GPL(__rcu_read_lock);
-
-void __rcu_read_unlock(void)
-{
-        int idx;
-        struct task_struct *t = current;
-        int nesting;
-
-        nesting = ACCESS_ONCE(t->rcu_read_lock_nesting);
-        if (nesting > 1) {
-
-                /*
-                 * We are still protected by the enclosing rcu_read_lock(),
-                 * so simply decrement the counter.
-                 */
-
-                t->rcu_read_lock_nesting = nesting - 1;
-
-        } else {
-                unsigned long flags;
-
-                /*
-                 * Disable local interrupts to prevent the grace-period
-                 * detection state machine from seeing us half-done.
-                 * NMIs can still occur, of course, and might themselves
-                 * contain rcu_read_lock() and rcu_read_unlock().
-                 */
-
-                local_irq_save(flags);
-
-                /*
-                 * Outermost nesting of rcu_read_unlock(), so we must
-                 * decrement the current counter for the current CPU.
-                 * This must be done carefully, because NMIs can
-                 * occur at any point in this code, and any rcu_read_lock()
-                 * and rcu_read_unlock() pairs in the NMI handlers
-                 * must interact non-destructively with this code.
-                 * Lots of volatile casts, and -very- careful ordering.
-                 *
-                 * Changes to this code, including this one, must be
-                 * inspected, validated, and tested extremely carefully!!!
-                 */
-
-                /*
-                 * First, pick up the index.
-                 */
-
-                idx = ACCESS_ONCE(t->rcu_flipctr_idx);
-
-                /*
-                 * Now that we have fetched the counter index, it is
-                 * safe to decrement the per-task RCU nesting counter.
-                 * After this, any interrupts or NMIs will increment and
-                 * decrement the per-CPU counters.
-                 */
-                ACCESS_ONCE(t->rcu_read_lock_nesting) = nesting - 1;
-
-                /*
-                 * It is now safe to decrement this task's nesting count.
-                 * NMIs that occur after this statement will route their
-                 * rcu_read_lock() calls through this "else" clause, and
-                 * will thus start incrementing the per-CPU counter on
-                 * their own.  They will also clobber ->rcu_flipctr_idx,
-                 * but that is OK, since we have already fetched it.
-                 */
-
-                ACCESS_ONCE(RCU_DATA_ME()->rcu_flipctr[idx])--;
-                local_irq_restore(flags);
-        }
-}
-EXPORT_SYMBOL_GPL(__rcu_read_unlock);
-
-/*
- * If a global counter flip has occurred since the last time that we
- * advanced callbacks, advance them.  Hardware interrupts must be
- * disabled when calling this function.
- */
-static void __rcu_advance_callbacks(struct rcu_data *rdp)
-{
-        int cpu;
-        int i;
-        int wlc = 0;
-
-        if (rdp->completed != rcu_ctrlblk.completed) {
-                if (rdp->waitlist[GP_STAGES - 1] != NULL) {
-                        *rdp->donetail = rdp->waitlist[GP_STAGES - 1];
-                        rdp->donetail = rdp->waittail[GP_STAGES - 1];
-                        RCU_TRACE_RDP(rcupreempt_trace_move2done, rdp);
-                }
-                for (i = GP_STAGES - 2; i >= 0; i--) {
-                        if (rdp->waitlist[i] != NULL) {
-                                rdp->waitlist[i + 1] = rdp->waitlist[i];
-                                rdp->waittail[i + 1] = rdp->waittail[i];
-                                wlc++;
-                        } else {
-                                rdp->waitlist[i + 1] = NULL;
-                                rdp->waittail[i + 1] =
-                                        &rdp->waitlist[i + 1];
-                        }
-                }
-                if (rdp->nextlist != NULL) {
-                        rdp->waitlist[0] = rdp->nextlist;
-                        rdp->waittail[0] = rdp->nexttail;
-                        wlc++;
-                        rdp->nextlist = NULL;
-                        rdp->nexttail = &rdp->nextlist;
-                        RCU_TRACE_RDP(rcupreempt_trace_move2wait, rdp);
-                } else {
-                        rdp->waitlist[0] = NULL;
-                        rdp->waittail[0] = &rdp->waitlist[0];
-                }
-                rdp->waitlistcount = wlc;
-                rdp->completed = rcu_ctrlblk.completed;
-        }
-
-        /*
-         * Check to see if this CPU needs to report that it has seen
-         * the most recent counter flip, thereby declaring that all
-         * subsequent rcu_read_lock() invocations will respect this flip.
-         */
-
-        cpu = raw_smp_processor_id();
-        if (per_cpu(rcu_flip_flag, cpu) == rcu_flipped) {
-                smp_mb();  /* Subsequent counter accesses must see new value */
-                per_cpu(rcu_flip_flag, cpu) = rcu_flip_seen;
-                smp_mb();  /* Subsequent RCU read-side critical sections */
-                           /*  seen -after- acknowledgement. */
-        }
-}
-
-#ifdef CONFIG_NO_HZ
-static DEFINE_PER_CPU(int, rcu_update_flag);
-
-/**
- * rcu_irq_enter - Called from Hard irq handlers and NMI/SMI.
- *
- * If the CPU was idle with dynamic ticks active, this updates the
- * rcu_dyntick_sched.dynticks to let the RCU handling know that the
- * CPU is active.
- */
-void rcu_irq_enter(void)
-{
-        int cpu = smp_processor_id();
-        struct rcu_dyntick_sched *rdssp = &per_cpu(rcu_dyntick_sched, cpu);
-
-        if (per_cpu(rcu_update_flag, cpu))
-                per_cpu(rcu_update_flag, cpu)++;
-
-        /*
-         * Only update if we are coming from a stopped ticks mode
-         * (rcu_dyntick_sched.dynticks is even).
-         */
-        if (!in_interrupt() &&
-            (rdssp->dynticks & 0x1) == 0) {
-                /*
-                 * The following might seem like we could have a race
-                 * with NMI/SMIs. But this really isn't a problem.
-                 * Here we do a read/modify/write, and the race happens
-                 * when an NMI/SMI comes in after the read and before
-                 * the write. But NMI/SMIs will increment this counter
-                 * twice before returning, so the zero bit will not
-                 * be corrupted by the NMI/SMI which is the most important
-                 * part.
-                 *
-                 * The only thing is that we would bring back the counter
-                 * to a postion that it was in during the NMI/SMI.
-                 * But the zero bit would be set, so the rest of the
-                 * counter would again be ignored.
-                 *
-                 * On return from the IRQ, the counter may have the zero
-                 * bit be 0 and the counter the same as the return from
-                 * the NMI/SMI. If the state machine was so unlucky to
-                 * see that, it still doesn't matter, since all
-                 * RCU read-side critical sections on this CPU would
-                 * have already completed.
-                 */
-                rdssp->dynticks++;
-                /*
-                 * The following memory barrier ensures that any
-                 * rcu_read_lock() primitives in the irq handler
-                 * are seen by other CPUs to follow the above
-                 * increment to rcu_dyntick_sched.dynticks. This is
-                 * required in order for other CPUs to correctly
-                 * determine when it is safe to advance the RCU
-                 * grace-period state machine.
-                 */
-                smp_mb(); /* see above block comment. */
-                /*
-                 * Since we can't determine the dynamic tick mode from
-                 * the rcu_dyntick_sched.dynticks after this routine,
-                 * we use a second flag to acknowledge that we came
-                 * from an idle state with ticks stopped.
-                 */
-                per_cpu(rcu_update_flag, cpu)++;
-                /*
-                 * If we take an NMI/SMI now, they will also increment
-                 * the rcu_update_flag, and will not update the
-                 * rcu_dyntick_sched.dynticks on exit. That is for
-                 * this IRQ to do.
-                 */
-        }
-}
-
-/**
- * rcu_irq_exit - Called from exiting Hard irq context.
- *
- * If the CPU was idle with dynamic ticks active, update the
- * rcu_dyntick_sched.dynticks to put let the RCU handling be
- * aware that the CPU is going back to idle with no ticks.
- */
-void rcu_irq_exit(void)
-{
-        int cpu = smp_processor_id();
-        struct rcu_dyntick_sched *rdssp = &per_cpu(rcu_dyntick_sched, cpu);
-
-        /*
-         * rcu_update_flag is set if we interrupted the CPU
-         * when it was idle with ticks stopped.
-         * Once this occurs, we keep track of interrupt nesting
-         * because a NMI/SMI could also come in, and we still
-         * only want the IRQ that started the increment of the
-         * rcu_dyntick_sched.dynticks to be the one that modifies
-         * it on exit.
-         */
-        if (per_cpu(rcu_update_flag, cpu)) {
-                if (--per_cpu(rcu_update_flag, cpu))
-                        return;
-
-                /* This must match the interrupt nesting */
-                WARN_ON(in_interrupt());
-
-                /*
-                 * If an NMI/SMI happens now we are still
-                 * protected by the rcu_dyntick_sched.dynticks being odd.
-                 */
-
-                /*
-                 * The following memory barrier ensures that any
-                 * rcu_read_unlock() primitives in the irq handler
-                 * are seen by other CPUs to preceed the following
-                 * increment to rcu_dyntick_sched.dynticks. This
-                 * is required in order for other CPUs to determine
-                 * when it is safe to advance the RCU grace-period
-                 * state machine.
-                 */
-                smp_mb(); /* see above block comment. */
-                rdssp->dynticks++;
-                WARN_ON(rdssp->dynticks & 0x1);
-        }
-}
-
-void rcu_nmi_enter(void)
-{
-        rcu_irq_enter();
-}
-
-void rcu_nmi_exit(void)
-{
-        rcu_irq_exit();
-}
-
-static void dyntick_save_progress_counter(int cpu)
-{
-        struct rcu_dyntick_sched *rdssp = &per_cpu(rcu_dyntick_sched, cpu);
-
-        rdssp->dynticks_snap = rdssp->dynticks;
-}
-
-static inline int
-rcu_try_flip_waitack_needed(int cpu)
-{
-        long curr;
-        long snap;
-        struct rcu_dyntick_sched *rdssp = &per_cpu(rcu_dyntick_sched, cpu);
-
-        curr = rdssp->dynticks;
-        snap = rdssp->dynticks_snap;
-        smp_mb(); /* force ordering with cpu entering/leaving dynticks. */
-
-        /*
-         * If the CPU remained in dynticks mode for the entire time
-         * and didn't take any interrupts, NMIs, SMIs, or whatever,
-         * then it cannot be in the middle of an rcu_read_lock(), so
-         * the next rcu_read_lock() it executes must use the new value
-         * of the counter.  So we can safely pretend that this CPU
-         * already acknowledged the counter.
-         */
-
-        if ((curr == snap) && ((curr & 0x1) == 0))
-                return 0;
-
-        /*
-         * If the CPU passed through or entered a dynticks idle phase with
-         * no active irq handlers, then, as above, we can safely pretend
-         * that this CPU already acknowledged the counter.
-         */
-
-        if ((curr - snap) > 2 || (curr & 0x1) == 0)
-                return 0;
-
-        /* We need this CPU to explicitly acknowledge the counter flip. */
-
-        return 1;
-}
-
-static inline int
-rcu_try_flip_waitmb_needed(int cpu)
-{
-        long curr;
-        long snap;
-        struct rcu_dyntick_sched *rdssp = &per_cpu(rcu_dyntick_sched, cpu);
-
-        curr = rdssp->dynticks;
-        snap = rdssp->dynticks_snap;
-        smp_mb(); /* force ordering with cpu entering/leaving dynticks. */
-
-        /*
-         * If the CPU remained in dynticks mode for the entire time
-         * and didn't take any interrupts, NMIs, SMIs, or whatever,
-         * then it cannot have executed an RCU read-side critical section
-         * during that time, so there is no need for it to execute a
-         * memory barrier.
-         */
-
-        if ((curr == snap) && ((curr & 0x1) == 0))
-                return 0;
-
-        /*
-         * If the CPU either entered or exited an outermost interrupt,
-         * SMI, NMI, or whatever handler, then we know that it executed
-         * a memory barrier when doing so.  So we don't need another one.
-         */
-        if (curr != snap)
-                return 0;
-
-        /* We need the CPU to execute a memory barrier. */
-
-        return 1;
-}
-
-static void dyntick_save_progress_counter_sched(int cpu)
-{
-        struct rcu_dyntick_sched *rdssp = &per_cpu(rcu_dyntick_sched, cpu);
-
-        rdssp->sched_dynticks_snap = rdssp->dynticks;
-}
-
-static int rcu_qsctr_inc_needed_dyntick(int cpu)
-{
-        long curr;
-        long snap;
-        struct rcu_dyntick_sched *rdssp = &per_cpu(rcu_dyntick_sched, cpu);
-
-        curr = rdssp->dynticks;
-        snap = rdssp->sched_dynticks_snap;
-        smp_mb(); /* force ordering with cpu entering/leaving dynticks. */
-
-        /*
-         * If the CPU remained in dynticks mode for the entire time
-         * and didn't take any interrupts, NMIs, SMIs, or whatever,
-         * then it cannot be in the middle of an rcu_read_lock(), so
-         * the next rcu_read_lock() it executes must use the new value
-         * of the counter.  Therefore, this CPU has been in a quiescent
-         * state the entire time, and we don't need to wait for it.
-         */
-
-        if ((curr == snap) && ((curr & 0x1) == 0))
-                return 0;
-
-        /*
-         * If the CPU passed through or entered a dynticks idle phase with
-         * no active irq handlers, then, as above, this CPU has already
-         * passed through a quiescent state.
-         */
-
-        if ((curr - snap) > 2 || (snap & 0x1) == 0)
-                return 0;
-
-        /* We need this CPU to go through a quiescent state. */
-
-        return 1;
-}
-
-#else /* !CONFIG_NO_HZ */
-
-# define dyntick_save_progress_counter(cpu)             do { } while (0)
-# define rcu_try_flip_waitack_needed(cpu)               (1)
-# define rcu_try_flip_waitmb_needed(cpu)                (1)
-
-# define dyntick_save_progress_counter_sched(cpu)       do { } while (0)
-# define rcu_qsctr_inc_needed_dyntick(cpu)              (1)
-
-#endif /* CONFIG_NO_HZ */
-
-static void save_qsctr_sched(int cpu)
-{
-        struct rcu_dyntick_sched *rdssp = &per_cpu(rcu_dyntick_sched, cpu);
-
-        rdssp->sched_qs_snap = rdssp->sched_qs;
-}
-
-static inline int rcu_qsctr_inc_needed(int cpu)
-{
-        struct rcu_dyntick_sched *rdssp = &per_cpu(rcu_dyntick_sched, cpu);
-
-        /*
-         * If there has been a quiescent state, no more need to wait
-         * on this CPU.
-         */
-
-        if (rdssp->sched_qs != rdssp->sched_qs_snap) {
-                smp_mb(); /* force ordering with cpu entering schedule(). */
-                return 0;
-        }
-
-        /* We need this CPU to go through a quiescent state. */
-
-        return 1;
-}
-
-/*
- * Get here when RCU is idle.  Decide whether we need to
- * move out of idle state, and return non-zero if so.
- * "Straightforward" approach for the moment, might later
- * use callback-list lengths, grace-period duration, or
- * some such to determine when to exit idle state.
- * Might also need a pre-idle test that does not acquire
- * the lock, but let's get the simple case working first...
- */
-
-static int
-rcu_try_flip_idle(void)
-{
-        int cpu;
-
-        RCU_TRACE_ME(rcupreempt_trace_try_flip_i1);
-        if (!rcu_pending(smp_processor_id())) {
-                RCU_TRACE_ME(rcupreempt_trace_try_flip_ie1);
-                return 0;
-        }
-
-        /*
-         * Do the flip.
-         */
-
-        RCU_TRACE_ME(rcupreempt_trace_try_flip_g1);
-        rcu_ctrlblk.completed++;  /* stands in for rcu_try_flip_g2 */
-
-        /*
-         * Need a memory barrier so that other CPUs see the new
-         * counter value before they see the subsequent change of all
-         * the rcu_flip_flag instances to rcu_flipped.
-         */
-
-        smp_mb();       /* see above block comment. */
-
-        /* Now ask each CPU for acknowledgement of the flip. */
-
-        for_each_cpu(cpu, to_cpumask(rcu_cpu_online_map)) {
-                per_cpu(rcu_flip_flag, cpu) = rcu_flipped;
-                dyntick_save_progress_counter(cpu);
-        }
-
-        return 1;
-}
-
-/*
- * Wait for CPUs to acknowledge the flip.
- */
-
-static int
-rcu_try_flip_waitack(void)
-{
-        int cpu;
-
-        RCU_TRACE_ME(rcupreempt_trace_try_flip_a1);
-        for_each_cpu(cpu, to_cpumask(rcu_cpu_online_map))
-                if (rcu_try_flip_waitack_needed(cpu) &&
-                    per_cpu(rcu_flip_flag, cpu) != rcu_flip_seen) {
-                        RCU_TRACE_ME(rcupreempt_trace_try_flip_ae1);
-                        return 0;
-                }
-
-        /*
-         * Make sure our checks above don't bleed into subsequent
-         * waiting for the sum of the counters to reach zero.
-         */
-
-        smp_mb();       /* see above block comment. */
-        RCU_TRACE_ME(rcupreempt_trace_try_flip_a2);
-        return 1;
-}
-
-/*
- * Wait for collective ``last'' counter to reach zero,
- * then tell all CPUs to do an end-of-grace-period memory barrier.
- */
-
-static int
-rcu_try_flip_waitzero(void)
-{
-        int cpu;
-        int lastidx = !(rcu_ctrlblk.completed & 0x1);
-        int sum = 0;
-
-        /* Check to see if the sum of the "last" counters is zero. */
-
-        RCU_TRACE_ME(rcupreempt_trace_try_flip_z1);
-        for_each_cpu(cpu, to_cpumask(rcu_cpu_online_map))
-                sum += RCU_DATA_CPU(cpu)->rcu_flipctr[lastidx];
-        if (sum != 0) {
-                RCU_TRACE_ME(rcupreempt_trace_try_flip_ze1);
-                return 0;
-        }
-
-        /*
-         * This ensures that the other CPUs see the call for
-         * memory barriers -after- the sum to zero has been
-         * detected here
-         */
-        smp_mb();  /*  ^^^^^^^^^^^^ */
-
-        /* Call for a memory barrier from each CPU. */
-        for_each_cpu(cpu, to_cpumask(rcu_cpu_online_map)) {
-                per_cpu(rcu_mb_flag, cpu) = rcu_mb_needed;
-                dyntick_save_progress_counter(cpu);
-        }
-
-        RCU_TRACE_ME(rcupreempt_trace_try_flip_z2);
-        return 1;
-}
-
-/*
- * Wait for all CPUs to do their end-of-grace-period memory barrier.
- * Return 0 once all CPUs have done so.
- */
-
-static int
-rcu_try_flip_waitmb(void)
-{
-        int cpu;
-
-        RCU_TRACE_ME(rcupreempt_trace_try_flip_m1);
-        for_each_cpu(cpu, to_cpumask(rcu_cpu_online_map))
-                if (rcu_try_flip_waitmb_needed(cpu) &&
-                    per_cpu(rcu_mb_flag, cpu) != rcu_mb_done) {
-                        RCU_TRACE_ME(rcupreempt_trace_try_flip_me1);
-                        return 0;
-                }
-
-        smp_mb(); /* Ensure that the above checks precede any following flip. */
-        RCU_TRACE_ME(rcupreempt_trace_try_flip_m2);
-        return 1;
-}
-
-/*
- * Attempt a single flip of the counters.  Remember, a single flip does
- * -not- constitute a grace period.  Instead, the interval between
- * at least GP_STAGES consecutive flips is a grace period.
- *
- * If anyone is nuts enough to run this CONFIG_PREEMPT_RCU implementation
- * on a large SMP, they might want to use a hierarchical organization of
- * the per-CPU-counter pairs.
- */
-static void rcu_try_flip(void)
-{
-        unsigned long flags;
-
-        RCU_TRACE_ME(rcupreempt_trace_try_flip_1);
-        if (unlikely(!spin_trylock_irqsave(&rcu_ctrlblk.fliplock, flags))) {
-                RCU_TRACE_ME(rcupreempt_trace_try_flip_e1);
-                return;
-        }
-
-        /*
-         * Take the next transition(s) through the RCU grace-period
-         * flip-counter state machine.
-         */
-
-        switch (rcu_ctrlblk.rcu_try_flip_state) {
-        case rcu_try_flip_idle_state:
-                if (rcu_try_flip_idle())
-                        rcu_ctrlblk.rcu_try_flip_state =
-                                rcu_try_flip_waitack_state;
-                break;
-        case rcu_try_flip_waitack_state:
-                if (rcu_try_flip_waitack())
-                        rcu_ctrlblk.rcu_try_flip_state =
-                                rcu_try_flip_waitzero_state;
-                break;
-        case rcu_try_flip_waitzero_state:
-                if (rcu_try_flip_waitzero())
-                        rcu_ctrlblk.rcu_try_flip_state =
-                                rcu_try_flip_waitmb_state;
-                break;
-        case rcu_try_flip_waitmb_state:
-                if (rcu_try_flip_waitmb())
-                        rcu_ctrlblk.rcu_try_flip_state =
-                                rcu_try_flip_idle_state;
-        }
-        spin_unlock_irqrestore(&rcu_ctrlblk.fliplock, flags);
-}
-
-/*
- * Check to see if this CPU needs to do a memory barrier in order to
- * ensure that any prior RCU read-side critical sections have committed
- * their counter manipulations and critical-section memory references
- * before declaring the grace period to be completed.
- */
-static void rcu_check_mb(int cpu)
-{
-        if (per_cpu(rcu_mb_flag, cpu) == rcu_mb_needed) {
-                smp_mb();  /* Ensure RCU read-side accesses are visible. */
-                per_cpu(rcu_mb_flag, cpu) = rcu_mb_done;
-        }
-}
-
-void rcu_check_callbacks(int cpu, int user)
-{
-        unsigned long flags;
-        struct rcu_data *rdp = RCU_DATA_CPU(cpu);
-
-        /*
-         * If this CPU took its interrupt from user mode or from the
-         * idle loop, and this is not a nested interrupt, then
-         * this CPU has to have exited all prior preept-disable
-         * sections of code.  So increment the counter to note this.
-         *
-         * The memory barrier is needed to handle the case where
-         * writes from a preempt-disable section of code get reordered
-         * into schedule() by this CPU's write buffer.  So the memory
-         * barrier makes sure that the rcu_qsctr_inc() is seen by other
-         * CPUs to happen after any such write.
-         */
-
-        if (user ||
-            (idle_cpu(cpu) && !in_softirq() &&
-             hardirq_count() <= (1 << HARDIRQ_SHIFT))) {
-                smp_mb();       /* Guard against aggressive schedule(). */
-                rcu_qsctr_inc(cpu);
-        }
-
-        rcu_check_mb(cpu);
-        if (rcu_ctrlblk.completed == rdp->completed)
-                rcu_try_flip();
-        spin_lock_irqsave(&rdp->lock, flags);
-        RCU_TRACE_RDP(rcupreempt_trace_check_callbacks, rdp);
-        __rcu_advance_callbacks(rdp);
-        if (rdp->donelist == NULL) {
-                spin_unlock_irqrestore(&rdp->lock, flags);
-        } else {
-                spin_unlock_irqrestore(&rdp->lock, flags);
-                raise_softirq(RCU_SOFTIRQ);
-        }
-}
-
-/*
- * Needed by dynticks, to make sure all RCU processing has finished
- * when we go idle:
- */
-void rcu_advance_callbacks(int cpu, int user)
-{
-        unsigned long flags;
-        struct rcu_data *rdp = RCU_DATA_CPU(cpu);
-
-        if (rcu_ctrlblk.completed == rdp->completed) {
-                rcu_try_flip();
-                if (rcu_ctrlblk.completed == rdp->completed)
-                        return;
-        }
-        spin_lock_irqsave(&rdp->lock, flags);
-        RCU_TRACE_RDP(rcupreempt_trace_check_callbacks, rdp);
-        __rcu_advance_callbacks(rdp);
-        spin_unlock_irqrestore(&rdp->lock, flags);
-}
-
-#ifdef CONFIG_HOTPLUG_CPU
-#define rcu_offline_cpu_enqueue(srclist, srctail, dstlist, dsttail) do { \
-                *dsttail = srclist; \
-                if (srclist != NULL) { \
-                        dsttail = srctail; \
-                        srclist = NULL; \
-                        srctail = &srclist;\
-                } \
-        } while (0)
-
-void rcu_offline_cpu(int cpu)
-{
-        int i;
-        struct rcu_head *list = NULL;
-        unsigned long flags;
-        struct rcu_data *rdp = RCU_DATA_CPU(cpu);
-        struct rcu_head *schedlist = NULL;
-        struct rcu_head **schedtail = &schedlist;
-        struct rcu_head **tail = &list;
-
-        /*
-         * Remove all callbacks from the newly dead CPU, retaining order.
-         * Otherwise rcu_barrier() will fail
-         */
-
-        spin_lock_irqsave(&rdp->lock, flags);
-        rcu_offline_cpu_enqueue(rdp->donelist, rdp->donetail, list, tail);
-        for (i = GP_STAGES - 1; i >= 0; i--)
-                rcu_offline_cpu_enqueue(rdp->waitlist[i], rdp->waittail[i],
-                                                list, tail);
-        rcu_offline_cpu_enqueue(rdp->nextlist, rdp->nexttail, list, tail);
-        rcu_offline_cpu_enqueue(rdp->waitschedlist, rdp->waitschedtail,
-                                schedlist, schedtail);
-        rcu_offline_cpu_enqueue(rdp->nextschedlist, rdp->nextschedtail,
-                                schedlist, schedtail);
-        rdp->rcu_sched_sleeping = 0;
-        spin_unlock_irqrestore(&rdp->lock, flags);
-        rdp->waitlistcount = 0;
-
-        /* Disengage the newly dead CPU from the grace-period computation. */
-
-        spin_lock_irqsave(&rcu_ctrlblk.fliplock, flags);
-        rcu_check_mb(cpu);
-        if (per_cpu(rcu_flip_flag, cpu) == rcu_flipped) {
-                smp_mb();  /* Subsequent counter accesses must see new value */
-                per_cpu(rcu_flip_flag, cpu) = rcu_flip_seen;
-                smp_mb();  /* Subsequent RCU read-side critical sections */
-                           /*  seen -after- acknowledgement. */
-        }
-
-        RCU_DATA_ME()->rcu_flipctr[0] += RCU_DATA_CPU(cpu)->rcu_flipctr[0];
-        RCU_DATA_ME()->rcu_flipctr[1] += RCU_DATA_CPU(cpu)->rcu_flipctr[1];
-
-        RCU_DATA_CPU(cpu)->rcu_flipctr[0] = 0;
-        RCU_DATA_CPU(cpu)->rcu_flipctr[1] = 0;
-
-        cpumask_clear_cpu(cpu, to_cpumask(rcu_cpu_online_map));
-
-        spin_unlock_irqrestore(&rcu_ctrlblk.fliplock, flags);
-
-        /*
-         * Place the removed callbacks on the current CPU's queue.
-         * Make them all start a new grace period: simple approach,
-         * in theory could starve a given set of callbacks, but
-         * you would need to be doing some serious CPU hotplugging
-         * to make this happen.  If this becomes a problem, adding
-         * a synchronize_rcu() to the hotplug path would be a simple
-         * fix.
-         */
-
-        local_irq_save(flags);  /* disable preempt till we know what lock. */
-        rdp = RCU_DATA_ME();
-        spin_lock(&rdp->lock);
-        *rdp->nexttail = list;
-        if (list)
-                rdp->nexttail = tail;
-        *rdp->nextschedtail = schedlist;
-        if (schedlist)
-                rdp->nextschedtail = schedtail;
-        spin_unlock_irqrestore(&rdp->lock, flags);
-}
-
-#else /* #ifdef CONFIG_HOTPLUG_CPU */
-
-void rcu_offline_cpu(int cpu)
-{
-}
-
-#endif /* #else #ifdef CONFIG_HOTPLUG_CPU */
-
-void __cpuinit rcu_online_cpu(int cpu)
-{
-        unsigned long flags;
-        struct rcu_data *rdp;
-
-        spin_lock_irqsave(&rcu_ctrlblk.fliplock, flags);
-        cpumask_set_cpu(cpu, to_cpumask(rcu_cpu_online_map));
-        spin_unlock_irqrestore(&rcu_ctrlblk.fliplock, flags);
-
-        /*
-         * The rcu_sched grace-period processing might have bypassed
-         * this CPU, given that it was not in the rcu_cpu_online_map
-         * when the grace-period scan started.  This means that the
-         * grace-period task might sleep.  So make sure that if this
-         * should happen, the first callback posted to this CPU will
-         * wake up the grace-period task if need be.
-         */
-
-        rdp = RCU_DATA_CPU(cpu);
-        spin_lock_irqsave(&rdp->lock, flags);
-        rdp->rcu_sched_sleeping = 1;
-        spin_unlock_irqrestore(&rdp->lock, flags);
-}
-
-static void rcu_process_callbacks(struct softirq_action *unused)
-{
-        unsigned long flags;
-        struct rcu_head *next, *list;
-        struct rcu_data *rdp;
-
-        local_irq_save(flags);
-        rdp = RCU_DATA_ME();
-        spin_lock(&rdp->lock);
-        list = rdp->donelist;
-        if (list == NULL) {
-                spin_unlock_irqrestore(&rdp->lock, flags);
-                return;
-        }
-        rdp->donelist = NULL;
-        rdp->donetail = &rdp->donelist;
-        RCU_TRACE_RDP(rcupreempt_trace_done_remove, rdp);
-        spin_unlock_irqrestore(&rdp->lock, flags);
-        while (list) {
-                next = list->next;
-                list->func(list);
-                list = next;
-                RCU_TRACE_ME(rcupreempt_trace_invoke);
-        }
-}
-
-void call_rcu(struct rcu_head *head, void (*func)(struct rcu_head *rcu))
-{
-        unsigned long flags;
-        struct rcu_data *rdp;
-
-        head->func = func;
-        head->next = NULL;
-        local_irq_save(flags);
-        rdp = RCU_DATA_ME();
-        spin_lock(&rdp->lock);
-        __rcu_advance_callbacks(rdp);
-        *rdp->nexttail = head;
-        rdp->nexttail = &head->next;
-        RCU_TRACE_RDP(rcupreempt_trace_next_add, rdp);
-        spin_unlock_irqrestore(&rdp->lock, flags);
-}
-EXPORT_SYMBOL_GPL(call_rcu);
-
-void call_rcu_sched(struct rcu_head *head, void (*func)(struct rcu_head *rcu))
-{
-        unsigned long flags;
-        struct rcu_data *rdp;
-        int wake_gp = 0;
-
-        head->func = func;
-        head->next = NULL;
-        local_irq_save(flags);
-        rdp = RCU_DATA_ME();
-        spin_lock(&rdp->lock);
-        *rdp->nextschedtail = head;
-        rdp->nextschedtail = &head->next;
-        if (rdp->rcu_sched_sleeping) {
-
-                /* Grace-period processing might be sleeping... */
-
-                rdp->rcu_sched_sleeping = 0;
-                wake_gp = 1;
-        }
-        spin_unlock_irqrestore(&rdp->lock, flags);
-        if (wake_gp) {
-
-                /* Wake up grace-period processing, unless someone beat us. */
-
-                spin_lock_irqsave(&rcu_ctrlblk.schedlock, flags);
-                if (rcu_ctrlblk.sched_sleep != rcu_sched_sleeping)
-                        wake_gp = 0;
-                rcu_ctrlblk.sched_sleep = rcu_sched_not_sleeping;
-                spin_unlock_irqrestore(&rcu_ctrlblk.schedlock, flags);
-                if (wake_gp)
-                        wake_up_interruptible(&rcu_ctrlblk.sched_wq);
-        }
-}
-EXPORT_SYMBOL_GPL(call_rcu_sched);
-
-/*
- * Wait until all currently running preempt_disable() code segments
- * (including hardware-irq-disable segments) complete.  Note that
- * in -rt this does -not- necessarily result in all currently executing
- * interrupt -handlers- having completed.
- */
-void __synchronize_sched(void)
-{
-        struct rcu_synchronize rcu;
-
-        if (num_online_cpus() == 1)
-                return;  /* blocking is gp if only one CPU! */
-
-        init_completion(&rcu.completion);
-        /* Will wake me after RCU finished. */
-        call_rcu_sched(&rcu.head, wakeme_after_rcu);
-        /* Wait for it. */
-        wait_for_completion(&rcu.completion);
-}
-EXPORT_SYMBOL_GPL(__synchronize_sched);
-
-/*
- * kthread function that manages call_rcu_sched grace periods.
- */
-static int rcu_sched_grace_period(void *arg)
-{
-        int couldsleep;         /* might sleep after current pass. */
-        int couldsleepnext = 0; /* might sleep after next pass. */
-        int cpu;
-        unsigned long flags;
-        struct rcu_data *rdp;
-        int ret;
-
-        /*
-         * Each pass through the following loop handles one
-         * rcu_sched grace period cycle.
-         */
-        do {
-                /* Save each CPU's current state. */
-
-                for_each_online_cpu(cpu) {
-                        dyntick_save_progress_counter_sched(cpu);
-                        save_qsctr_sched(cpu);
-                }
-
-                /*
-                 * Sleep for about an RCU grace-period's worth to
-                 * allow better batching and to consume less CPU.
-                 */
-                schedule_timeout_interruptible(RCU_SCHED_BATCH_TIME);
-
-                /*
-                 * If there was nothing to do last time, prepare to
-                 * sleep at the end of the current grace period cycle.
-                 */
-                couldsleep = couldsleepnext;
-                couldsleepnext = 1;
-                if (couldsleep) {
-                        spin_lock_irqsave(&rcu_ctrlblk.schedlock, flags);
-                        rcu_ctrlblk.sched_sleep = rcu_sched_sleep_prep;
-                        spin_unlock_irqrestore(&rcu_ctrlblk.schedlock, flags);
-                }
-
-                /*
-                 * Wait on each CPU in turn to have either visited
-                 * a quiescent state or been in dynticks-idle mode.
-                 */
-                for_each_online_cpu(cpu) {
-                        while (rcu_qsctr_inc_needed(cpu) &&
-                               rcu_qsctr_inc_needed_dyntick(cpu)) {
-                                /* resched_cpu(cpu); @@@ */
-                                schedule_timeout_interruptible(1);
-                        }
-                }
-
-                /* Advance callbacks for each CPU.  */
-
-                for_each_online_cpu(cpu) {
-
-                        rdp = RCU_DATA_CPU(cpu);
-                        spin_lock_irqsave(&rdp->lock, flags);
-
-                        /*
-                         * We are running on this CPU irq-disabled, so no
-                         * CPU can go offline until we re-enable irqs.
-                         * The current CPU might have already gone
-                         * offline (between the for_each_offline_cpu and
-                         * the spin_lock_irqsave), but in that case all its
-                         * callback lists will be empty, so no harm done.
-                         *
-                         * Advance the callbacks!  We share normal RCU's
-                         * donelist, since callbacks are invoked the
-                         * same way in either case.
-                         */
-                        if (rdp->waitschedlist != NULL) {
-                                *rdp->donetail = rdp->waitschedlist;
-                                rdp->donetail = rdp->waitschedtail;
-
-                                /*
-                                 * Next rcu_check_callbacks() will
-                                 * do the required raise_softirq().
-                                 */
-                        }
-                        if (rdp->nextschedlist != NULL) {
-                                rdp->waitschedlist = rdp->nextschedlist;
-                                rdp->waitschedtail = rdp->nextschedtail;
-                                couldsleep = 0;
-                                couldsleepnext = 0;
-                        } else {
-                                rdp->waitschedlist = NULL;
-                                rdp->waitschedtail = &rdp->waitschedlist;
-                        }
-                        rdp->nextschedlist = NULL;
-                        rdp->nextschedtail = &rdp->nextschedlist;
-
-                        /* Mark sleep intention. */
-
-                        rdp->rcu_sched_sleeping = couldsleep;
-
-                        spin_unlock_irqrestore(&rdp->lock, flags);
-                }
-
-                /* If we saw callbacks on the last scan, go deal with them. */
-
-                if (!couldsleep)
-                        continue;
-
-                /* Attempt to block... */
-
-                spin_lock_irqsave(&rcu_ctrlblk.schedlock, flags);
-                if (rcu_ctrlblk.sched_sleep != rcu_sched_sleep_prep) {
-
-                        /*
-                         * Someone posted a callback after we scanned.
-                         * Go take care of it.
-                         */
-                        spin_unlock_irqrestore(&rcu_ctrlblk.schedlock, flags);
-                        couldsleepnext = 0;
-                        continue;
-                }
-
-                /* Block until the next person posts a callback. */
-
-                rcu_ctrlblk.sched_sleep = rcu_sched_sleeping;
-                spin_unlock_irqrestore(&rcu_ctrlblk.schedlock, flags);
-                ret = 0; /* unused */
-                __wait_event_interruptible(rcu_ctrlblk.sched_wq,
-                        rcu_ctrlblk.sched_sleep != rcu_sched_sleeping,
-                        ret);
-
-                couldsleepnext = 0;
-
-        } while (!kthread_should_stop());
-
-        return (0);
-}
-
-/*
- * Check to see if any future RCU-related work will need to be done
- * by the current CPU, even if none need be done immediately, returning
- * 1 if so.  Assumes that notifiers would take care of handling any
- * outstanding requests from the RCU core.
- *
- * This function is part of the RCU implementation; it is -not-
- * an exported member of the RCU API.
- */
-int rcu_needs_cpu(int cpu)
-{
-        struct rcu_data *rdp = RCU_DATA_CPU(cpu);
-
-        return (rdp->donelist != NULL ||
-                !!rdp->waitlistcount ||
-                rdp->nextlist != NULL ||
-                rdp->nextschedlist != NULL ||
-                rdp->waitschedlist != NULL);
-}
-
-int rcu_pending(int cpu)
-{
-        struct rcu_data *rdp = RCU_DATA_CPU(cpu);
-
-        /* The CPU has at least one callback queued somewhere. */
-
-        if (rdp->donelist != NULL ||
-            !!rdp->waitlistcount ||
-            rdp->nextlist != NULL ||
-            rdp->nextschedlist != NULL ||
-            rdp->waitschedlist != NULL)
-                return 1;
-
-        /* The RCU core needs an acknowledgement from this CPU. */
-
-        if ((per_cpu(rcu_flip_flag, cpu) == rcu_flipped) ||
-            (per_cpu(rcu_mb_flag, cpu) == rcu_mb_needed))
-                return 1;
-
-        /* This CPU has fallen behind the global grace-period number. */
-
-        if (rdp->completed != rcu_ctrlblk.completed)
-                return 1;
-
-        /* Nothing needed from this CPU. */
-
-        return 0;
-}
-
-static int __cpuinit rcu_cpu_notify(struct notifier_block *self,
-                                unsigned long action, void *hcpu)
-{
-        long cpu = (long)hcpu;
-
-        switch (action) {
-        case CPU_UP_PREPARE:
-        case CPU_UP_PREPARE_FROZEN:
-                rcu_online_cpu(cpu);
-                break;
-        case CPU_UP_CANCELED:
-        case CPU_UP_CANCELED_FROZEN:
-        case CPU_DEAD:
-        case CPU_DEAD_FROZEN:
-                rcu_offline_cpu(cpu);
-                break;
-        default:
-                break;
-        }
-        return NOTIFY_OK;
-}
-
-static struct notifier_block __cpuinitdata rcu_nb = {
-        .notifier_call = rcu_cpu_notify,
-};
-
-void __init __rcu_init(void)
-{
-        int cpu;
-        int i;
-        struct rcu_data *rdp;
-
-        printk(KERN_NOTICE "Preemptible RCU implementation.\n");
-        for_each_possible_cpu(cpu) {
-                rdp = RCU_DATA_CPU(cpu);
-                spin_lock_init(&rdp->lock);
-                rdp->completed = 0;
-                rdp->waitlistcount = 0;
-                rdp->nextlist = NULL;
-                rdp->nexttail = &rdp->nextlist;
-                for (i = 0; i < GP_STAGES; i++) {
-                        rdp->waitlist[i] = NULL;
-                        rdp->waittail[i] = &rdp->waitlist[i];
-                }
-                rdp->donelist = NULL;
-                rdp->donetail = &rdp->donelist;
-                rdp->rcu_flipctr[0] = 0;
-                rdp->rcu_flipctr[1] = 0;
-                rdp->nextschedlist = NULL;
-                rdp->nextschedtail = &rdp->nextschedlist;
-                rdp->waitschedlist = NULL;
-                rdp->waitschedtail = &rdp->waitschedlist;
-                rdp->rcu_sched_sleeping = 0;
-        }
-        register_cpu_notifier(&rcu_nb);
-
-        /*
-         * We don't need protection against CPU-Hotplug here
-         * since
-         * a) If a CPU comes online while we are iterating over the
-         *    cpu_online_mask below, we would only end up making a
-         *    duplicate call to rcu_online_cpu() which sets the corresponding
-         *    CPU's mask in the rcu_cpu_online_map.
-         *
-         * b) A CPU cannot go offline at this point in time since the user
-         *    does not have access to the sysfs interface, nor do we
-         *    suspend the system.
-         */
-        for_each_online_cpu(cpu)
-                rcu_cpu_notify(&rcu_nb, CPU_UP_PREPARE, (void *)(long) cpu);
-
-        open_softirq(RCU_SOFTIRQ, rcu_process_callbacks);
-}
-
-/*
- * Late-boot-time RCU initialization that must wait until after scheduler
- * has been initialized.
- */
-void __init rcu_init_sched(void)
-{
-        rcu_sched_grace_period_task = kthread_run(rcu_sched_grace_period,
-                                                  NULL,
-                                                  "rcu_sched_grace_period");
-        WARN_ON(IS_ERR(rcu_sched_grace_period_task));
-}
-
-#ifdef CONFIG_RCU_TRACE
-long *rcupreempt_flipctr(int cpu)
-{
-        return &RCU_DATA_CPU(cpu)->rcu_flipctr[0];
-}
-EXPORT_SYMBOL_GPL(rcupreempt_flipctr);
-
-int rcupreempt_flip_flag(int cpu)
-{
-        return per_cpu(rcu_flip_flag, cpu);
-}
-EXPORT_SYMBOL_GPL(rcupreempt_flip_flag);
-
-int rcupreempt_mb_flag(int cpu)
-{
-        return per_cpu(rcu_mb_flag, cpu);
-}
-EXPORT_SYMBOL_GPL(rcupreempt_mb_flag);
-
-char *rcupreempt_try_flip_state_name(void)
-{
-        return rcu_try_flip_state_names[rcu_ctrlblk.rcu_try_flip_state];
-}
-EXPORT_SYMBOL_GPL(rcupreempt_try_flip_state_name);
-
-struct rcupreempt_trace *rcupreempt_trace_cpu(int cpu)
-{
-        struct rcu_data *rdp = RCU_DATA_CPU(cpu);
-
-        return &rdp->trace;
-}
-EXPORT_SYMBOL_GPL(rcupreempt_trace_cpu);
-
-#endif /* #ifdef RCU_TRACE */
diff --git a/kernel/rcupreempt_trace.c b/kernel/rcupreempt_trace.c
deleted file mode 100644
index 7c2665cac172..000000000000
--- a/kernel/rcupreempt_trace.c
+++ /dev/null
@@ -1,334 +0,0 @@
-/*
- * Read-Copy Update tracing for realtime implementation
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; either version 2 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
- *
- * Copyright IBM Corporation, 2006
- *
- * Papers:  http://www.rdrop.com/users/paulmck/RCU
- *
- * For detailed explanation of Read-Copy Update mechanism see -
- *              Documentation/RCU/ *.txt
- *
- */
-#include <linux/types.h>
-#include <linux/kernel.h>
-#include <linux/init.h>
-#include <linux/spinlock.h>
-#include <linux/smp.h>
-#include <linux/rcupdate.h>
-#include <linux/interrupt.h>
-#include <linux/sched.h>
-#include <asm/atomic.h>
-#include <linux/bitops.h>
-#include <linux/module.h>
-#include <linux/completion.h>
-#include <linux/moduleparam.h>
-#include <linux/percpu.h>
-#include <linux/notifier.h>
-#include <linux/cpu.h>
-#include <linux/mutex.h>
-#include <linux/rcupreempt_trace.h>
-#include <linux/debugfs.h>
-
-static struct mutex rcupreempt_trace_mutex;
-static char *rcupreempt_trace_buf;
-#define RCUPREEMPT_TRACE_BUF_SIZE 4096
-
-void rcupreempt_trace_move2done(struct rcupreempt_trace *trace)
-{
-        trace->done_length += trace->wait_length;
-        trace->done_add += trace->wait_length;
-        trace->wait_length = 0;
-}
-void rcupreempt_trace_move2wait(struct rcupreempt_trace *trace)
-{
-        trace->wait_length += trace->next_length;
-        trace->wait_add += trace->next_length;
-        trace->next_length = 0;
-}
-void rcupreempt_trace_try_flip_1(struct rcupreempt_trace *trace)
-{
-        atomic_inc(&trace->rcu_try_flip_1);
-}
-void rcupreempt_trace_try_flip_e1(struct rcupreempt_trace *trace)
-{
-        atomic_inc(&trace->rcu_try_flip_e1);
-}
-void rcupreempt_trace_try_flip_i1(struct rcupreempt_trace *trace)
-{
-        trace->rcu_try_flip_i1++;
-}
-void rcupreempt_trace_try_flip_ie1(struct rcupreempt_trace *trace)
-{
-        trace->rcu_try_flip_ie1++;
-}
-void rcupreempt_trace_try_flip_g1(struct rcupreempt_trace *trace)
-{
-        trace->rcu_try_flip_g1++;
-}
-void rcupreempt_trace_try_flip_a1(struct rcupreempt_trace *trace)
-{
-        trace->rcu_try_flip_a1++;
-}
-void rcupreempt_trace_try_flip_ae1(struct rcupreempt_trace *trace)
-{
-        trace->rcu_try_flip_ae1++;
-}
-void rcupreempt_trace_try_flip_a2(struct rcupreempt_trace *trace)
-{
-        trace->rcu_try_flip_a2++;
-}
-void rcupreempt_trace_try_flip_z1(struct rcupreempt_trace *trace)
-{
-        trace->rcu_try_flip_z1++;
-}
-void rcupreempt_trace_try_flip_ze1(struct rcupreempt_trace *trace)
-{
-        trace->rcu_try_flip_ze1++;
-}
-void rcupreempt_trace_try_flip_z2(struct rcupreempt_trace *trace)
-{
-        trace->rcu_try_flip_z2++;
-}
-void rcupreempt_trace_try_flip_m1(struct rcupreempt_trace *trace)
-{
-        trace->rcu_try_flip_m1++;
-}
-void rcupreempt_trace_try_flip_me1(struct rcupreempt_trace *trace)
-{
-        trace->rcu_try_flip_me1++;
-}
-void rcupreempt_trace_try_flip_m2(struct rcupreempt_trace *trace)
-{
-        trace->rcu_try_flip_m2++;
-}
-void rcupreempt_trace_check_callbacks(struct rcupreempt_trace *trace)
-{
-        trace->rcu_check_callbacks++;
-}
-void rcupreempt_trace_done_remove(struct rcupreempt_trace *trace)
-{
-        trace->done_remove += trace->done_length;
-        trace->done_length = 0;
-}
-void rcupreempt_trace_invoke(struct rcupreempt_trace *trace)
-{
-        atomic_inc(&trace->done_invoked);
-}
-void rcupreempt_trace_next_add(struct rcupreempt_trace *trace)
-{
-        trace->next_add++;
-        trace->next_length++;
-}
-
-static void rcupreempt_trace_sum(struct rcupreempt_trace *sp)
-{
-        struct rcupreempt_trace *cp;
-        int cpu;
-
-        memset(sp, 0, sizeof(*sp));
-        for_each_possible_cpu(cpu) {
-                cp = rcupreempt_trace_cpu(cpu);
-                sp->next_length += cp->next_length;
-                sp->next_add += cp->next_add;
-                sp->wait_length += cp->wait_length;
-                sp->wait_add += cp->wait_add;
-                sp->done_length += cp->done_length;
-                sp->done_add += cp->done_add;
-                sp->done_remove += cp->done_remove;
-                atomic_add(atomic_read(&cp->done_invoked), &sp->done_invoked);
-                sp->rcu_check_callbacks += cp->rcu_check_callbacks;
-                atomic_add(atomic_read(&cp->rcu_try_flip_1),
-                           &sp->rcu_try_flip_1);
-                atomic_add(atomic_read(&cp->rcu_try_flip_e1),
-                           &sp->rcu_try_flip_e1);
-                sp->rcu_try_flip_i1 += cp->rcu_try_flip_i1;
-                sp->rcu_try_flip_ie1 += cp->rcu_try_flip_ie1;
-                sp->rcu_try_flip_g1 += cp->rcu_try_flip_g1;
-                sp->rcu_try_flip_a1 += cp->rcu_try_flip_a1;
-                sp->rcu_try_flip_ae1 += cp->rcu_try_flip_ae1;
-                sp->rcu_try_flip_a2 += cp->rcu_try_flip_a2;
-                sp->rcu_try_flip_z1 += cp->rcu_try_flip_z1;
-                sp->rcu_try_flip_ze1 += cp->rcu_try_flip_ze1;
-                sp->rcu_try_flip_z2 += cp->rcu_try_flip_z2;
-                sp->rcu_try_flip_m1 += cp->rcu_try_flip_m1;
-                sp->rcu_try_flip_me1 += cp->rcu_try_flip_me1;
-                sp->rcu_try_flip_m2 += cp->rcu_try_flip_m2;
-        }
-}
-
-static ssize_t rcustats_read(struct file *filp, char __user *buffer,
-                                size_t count, loff_t *ppos)
-{
-        struct rcupreempt_trace trace;
-        ssize_t bcount;
-        int cnt = 0;
-
-        rcupreempt_trace_sum(&trace);
-        mutex_lock(&rcupreempt_trace_mutex);
-        snprintf(&rcupreempt_trace_buf[cnt], RCUPREEMPT_TRACE_BUF_SIZE - cnt,
-                 "ggp=%ld rcc=%ld\n",
-                 rcu_batches_completed(),
-                 trace.rcu_check_callbacks);
-        snprintf(&rcupreempt_trace_buf[cnt], RCUPREEMPT_TRACE_BUF_SIZE - cnt,
-                 "na=%ld nl=%ld wa=%ld wl=%ld da=%ld dl=%ld dr=%ld di=%d\n"
-                 "1=%d e1=%d i1=%ld ie1=%ld g1=%ld a1=%ld ae1=%ld a2=%ld\n"
-                 "z1=%ld ze1=%ld z2=%ld m1=%ld me1=%ld m2=%ld\n",
-
-                 trace.next_add, trace.next_length,
-                 trace.wait_add, trace.wait_length,
-                 trace.done_add, trace.done_length,
-                 trace.done_remove, atomic_read(&trace.done_invoked),
-                 atomic_read(&trace.rcu_try_flip_1),
-                 atomic_read(&trace.rcu_try_flip_e1),
-                 trace.rcu_try_flip_i1, trace.rcu_try_flip_ie1,
-                 trace.rcu_try_flip_g1,
-                 trace.rcu_try_flip_a1, trace.rcu_try_flip_ae1,
-                         trace.rcu_try_flip_a2,
-                 trace.rcu_try_flip_z1, trace.rcu_try_flip_ze1,
-                         trace.rcu_try_flip_z2,
-                 trace.rcu_try_flip_m1, trace.rcu_try_flip_me1,
-                        trace.rcu_try_flip_m2);
-        bcount = simple_read_from_buffer(buffer, count, ppos,
-                        rcupreempt_trace_buf, strlen(rcupreempt_trace_buf));
-        mutex_unlock(&rcupreempt_trace_mutex);
-        return bcount;
-}
-
-static ssize_t rcugp_read(struct file *filp, char __user *buffer,
-                                size_t count, loff_t *ppos)
-{
-        long oldgp = rcu_batches_completed();
-        ssize_t bcount;
-
-        mutex_lock(&rcupreempt_trace_mutex);
-        synchronize_rcu();
-        snprintf(rcupreempt_trace_buf, RCUPREEMPT_TRACE_BUF_SIZE,
-                "oldggp=%ld  newggp=%ld\n", oldgp, rcu_batches_completed());
-        bcount = simple_read_from_buffer(buffer, count, ppos,
-                        rcupreempt_trace_buf, strlen(rcupreempt_trace_buf));
-        mutex_unlock(&rcupreempt_trace_mutex);
-        return bcount;
-}
-
-static ssize_t rcuctrs_read(struct file *filp, char __user *buffer,
-                                size_t count, loff_t *ppos)
-{
-        int cnt = 0;
-        int cpu;
-        int f = rcu_batches_completed() & 0x1;
-        ssize_t bcount;
-
-        mutex_lock(&rcupreempt_trace_mutex);
-
-        cnt += snprintf(&rcupreempt_trace_buf[cnt], RCUPREEMPT_TRACE_BUF_SIZE,
-                                "CPU last cur F M\n");
-        for_each_online_cpu(cpu) {
-                long *flipctr = rcupreempt_flipctr(cpu);
-                cnt += snprintf(&rcupreempt_trace_buf[cnt],
-                                RCUPREEMPT_TRACE_BUF_SIZE - cnt,
-                                        "%3d %4ld %3ld %d %d\n",
-                               cpu,
-                               flipctr[!f],
-                               flipctr[f],
-                               rcupreempt_flip_flag(cpu),
-                               rcupreempt_mb_flag(cpu));
-        }
-        cnt += snprintf(&rcupreempt_trace_buf[cnt],
-                        RCUPREEMPT_TRACE_BUF_SIZE - cnt,
-                        "ggp = %ld, state = %s\n",
-                        rcu_batches_completed(),
-                        rcupreempt_try_flip_state_name());
-        cnt += snprintf(&rcupreempt_trace_buf[cnt],
-                        RCUPREEMPT_TRACE_BUF_SIZE - cnt,
-                        "\n");
-        bcount = simple_read_from_buffer(buffer, count, ppos,
-                        rcupreempt_trace_buf, strlen(rcupreempt_trace_buf));
-        mutex_unlock(&rcupreempt_trace_mutex);
-        return bcount;
-}
-
-static struct file_operations rcustats_fops = {
-        .owner = THIS_MODULE,
-        .read = rcustats_read,
-};
-
-static struct file_operations rcugp_fops = {
-        .owner = THIS_MODULE,
-        .read = rcugp_read,
-};
-
-static struct file_operations rcuctrs_fops = {
-        .owner = THIS_MODULE,
-        .read = rcuctrs_read,
-};
-
-static struct dentry *rcudir, *statdir, *ctrsdir, *gpdir;
-static int rcupreempt_debugfs_init(void)
-{
-        rcudir = debugfs_create_dir("rcu", NULL);
-        if (!rcudir)
-                goto out;
-        statdir = debugfs_create_file("rcustats", 0444, rcudir,
-                                                NULL, &rcustats_fops);
-        if (!statdir)
-                goto free_out;
-
-        gpdir = debugfs_create_file("rcugp", 0444, rcudir, NULL, &rcugp_fops);
-        if (!gpdir)
-                goto free_out;
-
-        ctrsdir = debugfs_create_file("rcuctrs", 0444, rcudir,
-                                                NULL, &rcuctrs_fops);
-        if (!ctrsdir)
-                goto free_out;
-        return 0;
-free_out:
-        if (statdir)
-                debugfs_remove(statdir);
-        if (gpdir)
-                debugfs_remove(gpdir);
-        debugfs_remove(rcudir);
-out:
-        return 1;
-}
-
-static int __init rcupreempt_trace_init(void)
-{
-        int ret;
-
-        mutex_init(&rcupreempt_trace_mutex);
-        rcupreempt_trace_buf = kmalloc(RCUPREEMPT_TRACE_BUF_SIZE, GFP_KERNEL);
-        if (!rcupreempt_trace_buf)
-                return 1;
-        ret = rcupreempt_debugfs_init();
-        if (ret)
-                kfree(rcupreempt_trace_buf);
-        return ret;
-}
-
-static void __exit rcupreempt_trace_cleanup(void)
-{
-        debugfs_remove(statdir);
-        debugfs_remove(gpdir);
-        debugfs_remove(ctrsdir);
-        debugfs_remove(rcudir);
-        kfree(rcupreempt_trace_buf);
-}
-
-
-module_init(rcupreempt_trace_init);
-module_exit(rcupreempt_trace_cleanup);
diff --git a/kernel/rcutorture.c b/kernel/rcutorture.c
index 9b4a975a4b4a..b33db539a8ad 100644
--- a/kernel/rcutorture.c
+++ b/kernel/rcutorture.c
@@ -257,14 +257,14 @@ struct rcu_torture_ops {
         void (*init)(void);
         void (*cleanup)(void);
         int (*readlock)(void);
-        void (*readdelay)(struct rcu_random_state *rrsp);
+        void (*read_delay)(struct rcu_random_state *rrsp);
         void (*readunlock)(int idx);
         int (*completed)(void);
-        void (*deferredfree)(struct rcu_torture *p);
+        void (*deferred_free)(struct rcu_torture *p);
         void (*sync)(void);
         void (*cb_barrier)(void);
         int (*stats)(char *page);
-        int irqcapable;
+        int irq_capable;
         char *name;
 };
 static struct rcu_torture_ops *cur_ops = NULL;
@@ -320,7 +320,7 @@ rcu_torture_cb(struct rcu_head *p)
                 rp->rtort_mbtest = 0;
                 rcu_torture_free(rp);
         } else
-                cur_ops->deferredfree(rp);
+                cur_ops->deferred_free(rp);
 }
 
 static void rcu_torture_deferred_free(struct rcu_torture *p)
@@ -329,18 +329,18 @@ static void rcu_torture_deferred_free(struct rcu_torture *p)
 }
 
 static struct rcu_torture_ops rcu_ops = {
-        .init = NULL,
-        .cleanup = NULL,
-        .readlock = rcu_torture_read_lock,
-        .readdelay = rcu_read_delay,
-        .readunlock = rcu_torture_read_unlock,
-        .completed = rcu_torture_completed,
-        .deferredfree = rcu_torture_deferred_free,
-        .sync = synchronize_rcu,
-        .cb_barrier = rcu_barrier,
-        .stats = NULL,
-        .irqcapable = 1,
-        .name = "rcu"
+        .init           = NULL,
+        .cleanup        = NULL,
+        .readlock       = rcu_torture_read_lock,
+        .read_delay     = rcu_read_delay,
+        .readunlock     = rcu_torture_read_unlock,
+        .completed      = rcu_torture_completed,
+        .deferred_free  = rcu_torture_deferred_free,
+        .sync           = synchronize_rcu,
+        .cb_barrier     = rcu_barrier,
+        .stats          = NULL,
+        .irq_capable    = 1,
+        .name           = "rcu"
 };
 
 static void rcu_sync_torture_deferred_free(struct rcu_torture *p)
@@ -370,18 +370,18 @@ static void rcu_sync_torture_init(void)
 }
 
 static struct rcu_torture_ops rcu_sync_ops = {
-        .init = rcu_sync_torture_init,
-        .cleanup = NULL,
-        .readlock = rcu_torture_read_lock,
-        .readdelay = rcu_read_delay,
-        .readunlock = rcu_torture_read_unlock,
-        .completed = rcu_torture_completed,
-        .deferredfree = rcu_sync_torture_deferred_free,
-        .sync = synchronize_rcu,
-        .cb_barrier = NULL,
-        .stats = NULL,
-        .irqcapable = 1,
-        .name = "rcu_sync"
+        .init           = rcu_sync_torture_init,
+        .cleanup        = NULL,
+        .readlock       = rcu_torture_read_lock,
+        .read_delay     = rcu_read_delay,
+        .readunlock     = rcu_torture_read_unlock,
+        .completed      = rcu_torture_completed,
+        .deferred_free  = rcu_sync_torture_deferred_free,
+        .sync           = synchronize_rcu,
+        .cb_barrier     = NULL,
+        .stats          = NULL,
+        .irq_capable    = 1,
+        .name           = "rcu_sync"
 };
 
 /*
@@ -432,33 +432,33 @@ static void rcu_bh_torture_synchronize(void)
 }
 
 static struct rcu_torture_ops rcu_bh_ops = {
-        .init = NULL,
-        .cleanup = NULL,
-        .readlock = rcu_bh_torture_read_lock,
-        .readdelay = rcu_read_delay,  /* just reuse rcu's version. */
-        .readunlock = rcu_bh_torture_read_unlock,
-        .completed = rcu_bh_torture_completed,
-        .deferredfree = rcu_bh_torture_deferred_free,
-        .sync = rcu_bh_torture_synchronize,
-        .cb_barrier = rcu_barrier_bh,
-        .stats = NULL,
-        .irqcapable = 1,
-        .name = "rcu_bh"
+        .init           = NULL,
+        .cleanup        = NULL,
+        .readlock       = rcu_bh_torture_read_lock,
+        .read_delay     = rcu_read_delay,  /* just reuse rcu's version. */
+        .readunlock     = rcu_bh_torture_read_unlock,
+        .completed      = rcu_bh_torture_completed,
+        .deferred_free  = rcu_bh_torture_deferred_free,
+        .sync           = rcu_bh_torture_synchronize,
+        .cb_barrier     = rcu_barrier_bh,
+        .stats          = NULL,
+        .irq_capable    = 1,
+        .name           = "rcu_bh"
 };
 
 static struct rcu_torture_ops rcu_bh_sync_ops = {
-        .init = rcu_sync_torture_init,
-        .cleanup = NULL,
-        .readlock = rcu_bh_torture_read_lock,
-        .readdelay = rcu_read_delay,  /* just reuse rcu's version. */
-        .readunlock = rcu_bh_torture_read_unlock,
-        .completed = rcu_bh_torture_completed,
-        .deferredfree = rcu_sync_torture_deferred_free,
-        .sync = rcu_bh_torture_synchronize,
-        .cb_barrier = NULL,
-        .stats = NULL,
-        .irqcapable = 1,
-        .name = "rcu_bh_sync"
+        .init           = rcu_sync_torture_init,
+        .cleanup        = NULL,
+        .readlock       = rcu_bh_torture_read_lock,
+        .read_delay     = rcu_read_delay,  /* just reuse rcu's version. */
+        .readunlock     = rcu_bh_torture_read_unlock,
+        .completed      = rcu_bh_torture_completed,
+        .deferred_free  = rcu_sync_torture_deferred_free,
+        .sync           = rcu_bh_torture_synchronize,
+        .cb_barrier     = NULL,
+        .stats          = NULL,
+        .irq_capable    = 1,
+        .name           = "rcu_bh_sync"
 };
 
 /*
@@ -530,17 +530,17 @@ static int srcu_torture_stats(char *page)
 }
 
 static struct rcu_torture_ops srcu_ops = {
-        .init = srcu_torture_init,
-        .cleanup = srcu_torture_cleanup,
-        .readlock = srcu_torture_read_lock,
-        .readdelay = srcu_read_delay,
-        .readunlock = srcu_torture_read_unlock,
-        .completed = srcu_torture_completed,
-        .deferredfree = rcu_sync_torture_deferred_free,
-        .sync = srcu_torture_synchronize,
-        .cb_barrier = NULL,
-        .stats = srcu_torture_stats,
-        .name = "srcu"
+        .init           = srcu_torture_init,
+        .cleanup        = srcu_torture_cleanup,
+        .readlock       = srcu_torture_read_lock,
+        .read_delay     = srcu_read_delay,
+        .readunlock     = srcu_torture_read_unlock,
+        .completed      = srcu_torture_completed,
+        .deferred_free  = rcu_sync_torture_deferred_free,
+        .sync           = srcu_torture_synchronize,
+        .cb_barrier     = NULL,
+        .stats          = srcu_torture_stats,
+        .name           = "srcu"
 };
 
 /*
@@ -574,32 +574,49 @@ static void sched_torture_synchronize(void)
 }
 
 static struct rcu_torture_ops sched_ops = {
-        .init = rcu_sync_torture_init,
-        .cleanup = NULL,
-        .readlock = sched_torture_read_lock,
-        .readdelay = rcu_read_delay,  /* just reuse rcu's version. */
-        .readunlock = sched_torture_read_unlock,
-        .completed = sched_torture_completed,
-        .deferredfree = rcu_sched_torture_deferred_free,
-        .sync = sched_torture_synchronize,
-        .cb_barrier = rcu_barrier_sched,
-        .stats = NULL,
-        .irqcapable = 1,
-        .name = "sched"
+        .init           = rcu_sync_torture_init,
+        .cleanup        = NULL,
+        .readlock       = sched_torture_read_lock,
+        .read_delay     = rcu_read_delay,  /* just reuse rcu's version. */
+        .readunlock     = sched_torture_read_unlock,
+        .completed      = sched_torture_completed,
+        .deferred_free  = rcu_sched_torture_deferred_free,
+        .sync           = sched_torture_synchronize,
+        .cb_barrier     = rcu_barrier_sched,
+        .stats          = NULL,
+        .irq_capable    = 1,
+        .name           = "sched"
 };
 
 static struct rcu_torture_ops sched_ops_sync = {
-        .init = rcu_sync_torture_init,
-        .cleanup = NULL,
-        .readlock = sched_torture_read_lock,
-        .readdelay = rcu_read_delay,  /* just reuse rcu's version. */
-        .readunlock = sched_torture_read_unlock,
-        .completed = sched_torture_completed,
-        .deferredfree = rcu_sync_torture_deferred_free,
-        .sync = sched_torture_synchronize,
-        .cb_barrier = NULL,
-        .stats = NULL,
-        .name = "sched_sync"
+        .init           = rcu_sync_torture_init,
+        .cleanup        = NULL,
+        .readlock       = sched_torture_read_lock,
+        .read_delay     = rcu_read_delay,  /* just reuse rcu's version. */
+        .readunlock     = sched_torture_read_unlock,
+        .completed      = sched_torture_completed,
+        .deferred_free  = rcu_sync_torture_deferred_free,
+        .sync           = sched_torture_synchronize,
+        .cb_barrier     = NULL,
+        .stats          = NULL,
+        .name           = "sched_sync"
+};
+
+extern int rcu_expedited_torture_stats(char *page);
+
+static struct rcu_torture_ops sched_expedited_ops = {
+        .init           = rcu_sync_torture_init,
+        .cleanup        = NULL,
+        .readlock       = sched_torture_read_lock,
+        .read_delay     = rcu_read_delay,  /* just reuse rcu's version. */
+        .readunlock     = sched_torture_read_unlock,
+        .completed      = sched_torture_completed,
+        .deferred_free  = rcu_sync_torture_deferred_free,
+        .sync           = synchronize_sched_expedited,
+        .cb_barrier     = NULL,
+        .stats          = rcu_expedited_torture_stats,
+        .irq_capable    = 1,
+        .name           = "sched_expedited"
 };
 
 /*
@@ -635,7 +652,7 @@ rcu_torture_writer(void *arg)
                                 i = RCU_TORTURE_PIPE_LEN;
                         atomic_inc(&rcu_torture_wcount[i]);
                         old_rp->rtort_pipe_count++;
-                        cur_ops->deferredfree(old_rp);
+                        cur_ops->deferred_free(old_rp);
                 }
                 rcu_torture_current_version++;
                 oldbatch = cur_ops->completed();
@@ -700,7 +717,7 @@ static void rcu_torture_timer(unsigned long unused)
         if (p->rtort_mbtest == 0)
                 atomic_inc(&n_rcu_torture_mberror);
         spin_lock(&rand_lock);
-        cur_ops->readdelay(&rand);
+        cur_ops->read_delay(&rand);
         n_rcu_torture_timers++;
         spin_unlock(&rand_lock);
         preempt_disable();
@@ -738,11 +755,11 @@ rcu_torture_reader(void *arg)
 
         VERBOSE_PRINTK_STRING("rcu_torture_reader task started");
         set_user_nice(current, 19);
-        if (irqreader && cur_ops->irqcapable)
+        if (irqreader && cur_ops->irq_capable)
                 setup_timer_on_stack(&t, rcu_torture_timer, 0);
 
         do {
-                if (irqreader && cur_ops->irqcapable) {
+                if (irqreader && cur_ops->irq_capable) {
                         if (!timer_pending(&t))
                                 mod_timer(&t, 1);
                 }
@@ -757,7 +774,7 @@ rcu_torture_reader(void *arg)
                 }
                 if (p->rtort_mbtest == 0)
                         atomic_inc(&n_rcu_torture_mberror);
-                cur_ops->readdelay(&rand);
+                cur_ops->read_delay(&rand);
                 preempt_disable();
                 pipe_count = p->rtort_pipe_count;
                 if (pipe_count > RCU_TORTURE_PIPE_LEN) {
@@ -778,7 +795,7 @@ rcu_torture_reader(void *arg)
         } while (!kthread_should_stop() && fullstop == FULLSTOP_DONTSTOP);
         VERBOSE_PRINTK_STRING("rcu_torture_reader task stopping");
         rcutorture_shutdown_absorb("rcu_torture_reader");
-        if (irqreader && cur_ops->irqcapable)
+        if (irqreader && cur_ops->irq_capable)
                 del_timer_sync(&t);
         while (!kthread_should_stop())
                 schedule_timeout_uninterruptible(1);
@@ -1078,6 +1095,7 @@ rcu_torture_init(void)
         int firsterr = 0;
         static struct rcu_torture_ops *torture_ops[] =
                 { &rcu_ops, &rcu_sync_ops, &rcu_bh_ops, &rcu_bh_sync_ops,
+                  &sched_expedited_ops,
                   &srcu_ops, &sched_ops, &sched_ops_sync, };
 
         mutex_lock(&fullstop_mutex);
diff --git a/kernel/rcutree.c b/kernel/rcutree.c
index 7717b95c2027..6b11b07cfe7f 100644
--- a/kernel/rcutree.c
+++ b/kernel/rcutree.c
@@ -35,6 +35,7 @@
 #include <linux/rcupdate.h>
 #include <linux/interrupt.h>
 #include <linux/sched.h>
+#include <linux/nmi.h>
 #include <asm/atomic.h>
 #include <linux/bitops.h>
 #include <linux/module.h>
@@ -46,6 +47,8 @@
 #include <linux/mutex.h>
 #include <linux/time.h>
 
+#include "rcutree.h"
+
 #ifdef CONFIG_DEBUG_LOCK_ALLOC
 static struct lock_class_key rcu_lock_key;
 struct lockdep_map rcu_lock_map =
@@ -72,30 +75,59 @@ EXPORT_SYMBOL_GPL(rcu_lock_map);
         .n_force_qs_ngp = 0, \
 }
 
-struct rcu_state rcu_state = RCU_STATE_INITIALIZER(rcu_state);
-DEFINE_PER_CPU(struct rcu_data, rcu_data);
+struct rcu_state rcu_sched_state = RCU_STATE_INITIALIZER(rcu_sched_state);
+DEFINE_PER_CPU(struct rcu_data, rcu_sched_data);
 
 struct rcu_state rcu_bh_state = RCU_STATE_INITIALIZER(rcu_bh_state);
 DEFINE_PER_CPU(struct rcu_data, rcu_bh_data);
 
+extern long rcu_batches_completed_sched(void);
+static struct rcu_node *rcu_get_root(struct rcu_state *rsp);
+static void cpu_quiet_msk(unsigned long mask, struct rcu_state *rsp,
+                          struct rcu_node *rnp, unsigned long flags);
+static void cpu_quiet_msk_finish(struct rcu_state *rsp, unsigned long flags);
+#ifdef CONFIG_HOTPLUG_CPU
+static void __rcu_offline_cpu(int cpu, struct rcu_state *rsp);
+#endif /* #ifdef CONFIG_HOTPLUG_CPU */
+static void __rcu_process_callbacks(struct rcu_state *rsp,
+                                    struct rcu_data *rdp);
+static void __call_rcu(struct rcu_head *head,
+                       void (*func)(struct rcu_head *rcu),
+                       struct rcu_state *rsp);
+static int __rcu_pending(struct rcu_state *rsp, struct rcu_data *rdp);
+static void __cpuinit rcu_init_percpu_data(int cpu, struct rcu_state *rsp,
+                                           int preemptable);
+
+#include "rcutree_plugin.h"
+
 /*
- * Increment the quiescent state counter.
- * The counter is a bit degenerated: We do not need to know
+ * Note a quiescent state.  Because we do not need to know
  * how many quiescent states passed, just if there was at least
- * one since the start of the grace period. Thus just a flag.
+ * one since the start of the grace period, this just sets a flag.
  */
-void rcu_qsctr_inc(int cpu)
+void rcu_sched_qs(int cpu)
 {
-        struct rcu_data *rdp = &per_cpu(rcu_data, cpu);
+        unsigned long flags;
+        struct rcu_data *rdp;
+
+        local_irq_save(flags);
+        rdp = &per_cpu(rcu_sched_data, cpu);
         rdp->passed_quiesc = 1;
         rdp->passed_quiesc_completed = rdp->completed;
+        rcu_preempt_qs(cpu);
+        local_irq_restore(flags);
 }
 
-void rcu_bh_qsctr_inc(int cpu)
+void rcu_bh_qs(int cpu)
 {
-        struct rcu_data *rdp = &per_cpu(rcu_bh_data, cpu);
+        unsigned long flags;
+        struct rcu_data *rdp;
+
+        local_irq_save(flags);
+        rdp = &per_cpu(rcu_bh_data, cpu);
         rdp->passed_quiesc = 1;
         rdp->passed_quiesc_completed = rdp->completed;
+        local_irq_restore(flags);
 }
 
 #ifdef CONFIG_NO_HZ
@@ -110,15 +142,16 @@ static int qhimark = 10000;	/* If this many pending, ignore blimit. */
 static int qlowmark = 100;      /* Once only this many pending, use blimit. */
 
 static void force_quiescent_state(struct rcu_state *rsp, int relaxed);
+static int rcu_pending(int cpu);
 
 /*
- * Return the number of RCU batches processed thus far for debug & stats.
+ * Return the number of RCU-sched batches processed thus far for debug & stats.
  */
-long rcu_batches_completed(void)
+long rcu_batches_completed_sched(void)
 {
-        return rcu_state.completed;
+        return rcu_sched_state.completed;
 }
-EXPORT_SYMBOL_GPL(rcu_batches_completed);
+EXPORT_SYMBOL_GPL(rcu_batches_completed_sched);
 
 /*
  * Return the number of RCU BH batches processed thus far for debug & stats.
@@ -181,6 +214,10 @@ static int rcu_implicit_offline_qs(struct rcu_data *rdp)
                 return 1;
         }
 
+        /* If preemptable RCU, no point in sending reschedule IPI. */
+        if (rdp->preemptable)
+                return 0;
+
         /* The CPU is online, so send it a reschedule IPI. */
         if (rdp->cpu != smp_processor_id())
                 smp_send_reschedule(rdp->cpu);
@@ -193,7 +230,6 @@ static int rcu_implicit_offline_qs(struct rcu_data *rdp)
 #endif /* #ifdef CONFIG_SMP */
 
 #ifdef CONFIG_NO_HZ
-static DEFINE_RATELIMIT_STATE(rcu_rs, 10 * HZ, 5);
 
 /**
  * rcu_enter_nohz - inform RCU that current CPU is entering nohz
@@ -213,7 +249,7 @@ void rcu_enter_nohz(void)
         rdtp = &__get_cpu_var(rcu_dynticks);
         rdtp->dynticks++;
         rdtp->dynticks_nesting--;
-        WARN_ON_RATELIMIT(rdtp->dynticks & 0x1, &rcu_rs);
+        WARN_ON_ONCE(rdtp->dynticks & 0x1);
         local_irq_restore(flags);
 }
 
@@ -232,7 +268,7 @@ void rcu_exit_nohz(void)
         rdtp = &__get_cpu_var(rcu_dynticks);
         rdtp->dynticks++;
         rdtp->dynticks_nesting++;
-        WARN_ON_RATELIMIT(!(rdtp->dynticks & 0x1), &rcu_rs);
+        WARN_ON_ONCE(!(rdtp->dynticks & 0x1));
         local_irq_restore(flags);
         smp_mb(); /* CPUs seeing ++ must see later RCU read-side crit sects */
 }
@@ -251,7 +287,7 @@ void rcu_nmi_enter(void)
         if (rdtp->dynticks & 0x1)
                 return;
         rdtp->dynticks_nmi++;
-        WARN_ON_RATELIMIT(!(rdtp->dynticks_nmi & 0x1), &rcu_rs);
+        WARN_ON_ONCE(!(rdtp->dynticks_nmi & 0x1));
         smp_mb(); /* CPUs seeing ++ must see later RCU read-side crit sects */
 }
 
@@ -270,7 +306,7 @@ void rcu_nmi_exit(void)
                 return;
         smp_mb(); /* CPUs seeing ++ must see prior RCU read-side crit sects */
         rdtp->dynticks_nmi++;
-        WARN_ON_RATELIMIT(rdtp->dynticks_nmi & 0x1, &rcu_rs);
+        WARN_ON_ONCE(rdtp->dynticks_nmi & 0x1);
 }
 
 /**
@@ -286,7 +322,7 @@ void rcu_irq_enter(void)
         if (rdtp->dynticks_nesting++)
                 return;
         rdtp->dynticks++;
-        WARN_ON_RATELIMIT(!(rdtp->dynticks & 0x1), &rcu_rs);
+        WARN_ON_ONCE(!(rdtp->dynticks & 0x1));
         smp_mb(); /* CPUs seeing ++ must see later RCU read-side crit sects */
 }
 
@@ -305,10 +341,10 @@ void rcu_irq_exit(void)
                 return;
         smp_mb(); /* CPUs seeing ++ must see prior RCU read-side crit sects */
         rdtp->dynticks++;
-        WARN_ON_RATELIMIT(rdtp->dynticks & 0x1, &rcu_rs);
+        WARN_ON_ONCE(rdtp->dynticks & 0x1);
 
         /* If the interrupt queued a callback, get out of dyntick mode. */
-        if (__get_cpu_var(rcu_data).nxtlist ||
+        if (__get_cpu_var(rcu_sched_data).nxtlist ||
             __get_cpu_var(rcu_bh_data).nxtlist)
                 set_need_resched();
 }
@@ -461,6 +497,7 @@ static void print_other_cpu_stall(struct rcu_state *rsp)
 
         printk(KERN_ERR "INFO: RCU detected CPU stalls:");
         for (; rnp_cur < rnp_end; rnp_cur++) {
+                rcu_print_task_stall(rnp);
                 if (rnp_cur->qsmask == 0)
                         continue;
                 for (cpu = 0; cpu <= rnp_cur->grphi - rnp_cur->grplo; cpu++)
@@ -469,6 +506,8 @@ static void print_other_cpu_stall(struct rcu_state *rsp)
         }
         printk(" (detected by %d, t=%ld jiffies)\n",
                smp_processor_id(), (long)(jiffies - rsp->gp_start));
+        trigger_all_cpu_backtrace();
+
         force_quiescent_state(rsp, 0);  /* Kick them all. */
 }
 
@@ -479,12 +518,14 @@ static void print_cpu_stall(struct rcu_state *rsp)
 
         printk(KERN_ERR "INFO: RCU detected CPU %d stall (t=%lu jiffies)\n",
                         smp_processor_id(), jiffies - rsp->gp_start);
-        dump_stack();
+        trigger_all_cpu_backtrace();
+
         spin_lock_irqsave(&rnp->lock, flags);
         if ((long)(jiffies - rsp->jiffies_stall) >= 0)
                 rsp->jiffies_stall =
                         jiffies + RCU_SECONDS_TILL_STALL_RECHECK;
         spin_unlock_irqrestore(&rnp->lock, flags);
+
         set_need_resched();  /* kick ourselves to get things going. */
 }
 
@@ -674,6 +715,19 @@ rcu_process_gp_end(struct rcu_state *rsp, struct rcu_data *rdp)
 }
 
 /*
+ * Clean up after the prior grace period and let rcu_start_gp() start up
+ * the next grace period if one is needed.  Note that the caller must
+ * hold rnp->lock, as required by rcu_start_gp(), which will release it.
+ */
+static void cpu_quiet_msk_finish(struct rcu_state *rsp, unsigned long flags)
+        __releases(rnp->lock)
+{
+        rsp->completed = rsp->gpnum;
+        rcu_process_gp_end(rsp, rsp->rda[smp_processor_id()]);
+        rcu_start_gp(rsp, flags);  /* releases root node's rnp->lock. */
+}
+
+/*
  * Similar to cpu_quiet(), for which it is a helper function.  Allows
  * a group of CPUs to be quieted at one go, though all the CPUs in the
  * group must be represented by the same leaf rcu_node structure.
@@ -694,7 +748,7 @@ cpu_quiet_msk(unsigned long mask, struct rcu_state *rsp, struct rcu_node *rnp,
                         return;
                 }
                 rnp->qsmask &= ~mask;
-                if (rnp->qsmask != 0) {
+                if (rnp->qsmask != 0 || rcu_preempted_readers(rnp)) {
 
                         /* Other bits still set at this level, so done. */
                         spin_unlock_irqrestore(&rnp->lock, flags);
@@ -714,14 +768,10 @@ cpu_quiet_msk(unsigned long mask, struct rcu_state *rsp, struct rcu_node *rnp,
 
         /*
          * Get here if we are the last CPU to pass through a quiescent
-         * state for this grace period.  Clean up and let rcu_start_gp()
-         * start up the next grace period if one is needed.  Note that
-         * we still hold rnp->lock, as required by rcu_start_gp(), which
-         * will release it.
+         * state for this grace period.  Invoke cpu_quiet_msk_finish()
+         * to clean up and start the next grace period if one is needed.
          */
-        rsp->completed = rsp->gpnum;
-        rcu_process_gp_end(rsp, rsp->rda[smp_processor_id()]);
-        rcu_start_gp(rsp, flags);  /* releases rnp->lock. */
+        cpu_quiet_msk_finish(rsp, flags); /* releases rnp->lock. */
 }
 
 /*
@@ -828,11 +878,12 @@ static void __rcu_offline_cpu(int cpu, struct rcu_state *rsp)
                 spin_lock(&rnp->lock);          /* irqs already disabled. */
                 rnp->qsmaskinit &= ~mask;
                 if (rnp->qsmaskinit != 0) {
-                        spin_unlock(&rnp->lock); /* irqs already disabled. */
+                        spin_unlock(&rnp->lock); /* irqs remain disabled. */
                         break;
                 }
+                rcu_preempt_offline_tasks(rsp, rnp);
                 mask = rnp->grpmask;
-                spin_unlock(&rnp->lock);        /* irqs already disabled. */
+                spin_unlock(&rnp->lock);        /* irqs remain disabled. */
                 rnp = rnp->parent;
         } while (rnp != NULL);
         lastcomp = rsp->completed;
@@ -845,7 +896,7 @@ static void __rcu_offline_cpu(int cpu, struct rcu_state *rsp)
         /*
          * Move callbacks from the outgoing CPU to the running CPU.
          * Note that the outgoing CPU is now quiscent, so it is now
-         * (uncharacteristically) safe to access it rcu_data structure.
+         * (uncharacteristically) safe to access its rcu_data structure.
          * Note also that we must carefully retain the order of the
          * outgoing CPU's callbacks in order for rcu_barrier() to work
          * correctly.  Finally, note that we start all the callbacks
@@ -876,8 +927,9 @@ static void __rcu_offline_cpu(int cpu, struct rcu_state *rsp)
  */
 static void rcu_offline_cpu(int cpu)
 {
-        __rcu_offline_cpu(cpu, &rcu_state);
+        __rcu_offline_cpu(cpu, &rcu_sched_state);
         __rcu_offline_cpu(cpu, &rcu_bh_state);
+        rcu_preempt_offline_cpu(cpu);
 }
 
 #else /* #ifdef CONFIG_HOTPLUG_CPU */
@@ -963,6 +1015,8 @@ static void rcu_do_batch(struct rcu_data *rdp)
  */
 void rcu_check_callbacks(int cpu, int user)
 {
+        if (!rcu_pending(cpu))
+                return; /* if nothing for RCU to do. */
         if (user ||
             (idle_cpu(cpu) && rcu_scheduler_active &&
              !in_softirq() && hardirq_count() <= (1 << HARDIRQ_SHIFT))) {
@@ -971,17 +1025,16 @@ void rcu_check_callbacks(int cpu, int user)
                  * Get here if this CPU took its interrupt from user
                  * mode or from the idle loop, and if this is not a
                  * nested interrupt.  In this case, the CPU is in
-                 * a quiescent state, so count it.
+                 * a quiescent state, so note it.
                  *
                  * No memory barrier is required here because both
-                 * rcu_qsctr_inc() and rcu_bh_qsctr_inc() reference
-                 * only CPU-local variables that other CPUs neither
-                 * access nor modify, at least not while the corresponding
-                 * CPU is online.
+                 * rcu_sched_qs() and rcu_bh_qs() reference only CPU-local
+                 * variables that other CPUs neither access nor modify,
+                 * at least not while the corresponding CPU is online.
                  */
 
-                rcu_qsctr_inc(cpu);
-                rcu_bh_qsctr_inc(cpu);
+                rcu_sched_qs(cpu);
+                rcu_bh_qs(cpu);
 
         } else if (!in_softirq()) {
 
@@ -989,11 +1042,12 @@ void rcu_check_callbacks(int cpu, int user)
                  * Get here if this CPU did not take its interrupt from
                  * softirq, in other words, if it is not interrupting
                  * a rcu_bh read-side critical section.  This is an _bh
-                 * critical section, so count it.
+                 * critical section, so note it.
                  */
 
-                rcu_bh_qsctr_inc(cpu);
+                rcu_bh_qs(cpu);
         }
+        rcu_preempt_check_callbacks(cpu);
         raise_softirq(RCU_SOFTIRQ);
 }
 
@@ -1132,6 +1186,8 @@ __rcu_process_callbacks(struct rcu_state *rsp, struct rcu_data *rdp)
 {
         unsigned long flags;
 
+        WARN_ON_ONCE(rdp->beenonline == 0);
+
         /*
          * If an RCU GP has gone long enough, go check for dyntick
          * idle CPUs and, if needed, send resched IPIs.
@@ -1170,8 +1226,10 @@ static void rcu_process_callbacks(struct softirq_action *unused)
          */
         smp_mb(); /* See above block comment. */
 
-        __rcu_process_callbacks(&rcu_state, &__get_cpu_var(rcu_data));
+        __rcu_process_callbacks(&rcu_sched_state,
+                                &__get_cpu_var(rcu_sched_data));
         __rcu_process_callbacks(&rcu_bh_state, &__get_cpu_var(rcu_bh_data));
+        rcu_preempt_process_callbacks();
 
         /*
          * Memory references from any later RCU read-side critical sections
@@ -1227,13 +1285,13 @@ __call_rcu(struct rcu_head *head, void (*func)(struct rcu_head *rcu),
 }
 
 /*
- * Queue an RCU callback for invocation after a grace period.
+ * Queue an RCU-sched callback for invocation after a grace period.
  */
-void call_rcu(struct rcu_head *head, void (*func)(struct rcu_head *rcu))
+void call_rcu_sched(struct rcu_head *head, void (*func)(struct rcu_head *rcu))
 {
-        __call_rcu(head, func, &rcu_state);
+        __call_rcu(head, func, &rcu_sched_state);
 }
-EXPORT_SYMBOL_GPL(call_rcu);
+EXPORT_SYMBOL_GPL(call_rcu_sched);
 
 /*
  * Queue an RCU for invocation after a quicker grace period.
@@ -1305,10 +1363,11 @@ static int __rcu_pending(struct rcu_state *rsp, struct rcu_data *rdp)
  * by the current CPU, returning 1 if so.  This function is part of the
  * RCU implementation; it is -not- an exported member of the RCU API.
  */
-int rcu_pending(int cpu)
+static int rcu_pending(int cpu)
 {
-        return __rcu_pending(&rcu_state, &per_cpu(rcu_data, cpu)) ||
-               __rcu_pending(&rcu_bh_state, &per_cpu(rcu_bh_data, cpu));
+        return __rcu_pending(&rcu_sched_state, &per_cpu(rcu_sched_data, cpu)) ||
+               __rcu_pending(&rcu_bh_state, &per_cpu(rcu_bh_data, cpu)) ||
+               rcu_preempt_pending(cpu);
 }
 
 /*
@@ -1320,27 +1379,46 @@ int rcu_pending(int cpu)
 int rcu_needs_cpu(int cpu)
 {
         /* RCU callbacks either ready or pending? */
-        return per_cpu(rcu_data, cpu).nxtlist ||
-               per_cpu(rcu_bh_data, cpu).nxtlist;
+        return per_cpu(rcu_sched_data, cpu).nxtlist ||
+               per_cpu(rcu_bh_data, cpu).nxtlist ||
+               rcu_preempt_needs_cpu(cpu);
 }
 
 /*
- * Initialize a CPU's per-CPU RCU data.  We take this "scorched earth"
- * approach so that we don't have to worry about how long the CPU has
- * been gone, or whether it ever was online previously.  We do trust the
- * ->mynode field, as it is constant for a given struct rcu_data and
- * initialized during early boot.
- *
- * Note that only one online or offline event can be happening at a given
- * time.  Note also that we can accept some slop in the rsp->completed
- * access due to the fact that this CPU cannot possibly have any RCU
- * callbacks in flight yet.
+ * Do boot-time initialization of a CPU's per-CPU RCU data.
  */
-static void __cpuinit
-rcu_init_percpu_data(int cpu, struct rcu_state *rsp)
+static void __init
+rcu_boot_init_percpu_data(int cpu, struct rcu_state *rsp)
 {
         unsigned long flags;
         int i;
+        struct rcu_data *rdp = rsp->rda[cpu];
+        struct rcu_node *rnp = rcu_get_root(rsp);
+
+        /* Set up local state, ensuring consistent view of global state. */
+        spin_lock_irqsave(&rnp->lock, flags);
+        rdp->grpmask = 1UL << (cpu - rdp->mynode->grplo);
+        rdp->nxtlist = NULL;
+        for (i = 0; i < RCU_NEXT_SIZE; i++)
+                rdp->nxttail[i] = &rdp->nxtlist;
+        rdp->qlen = 0;
+#ifdef CONFIG_NO_HZ
+        rdp->dynticks = &per_cpu(rcu_dynticks, cpu);
+#endif /* #ifdef CONFIG_NO_HZ */
+        rdp->cpu = cpu;
+        spin_unlock_irqrestore(&rnp->lock, flags);
+}
+
+/*
+ * Initialize a CPU's per-CPU RCU data.  Note that only one online or
+ * offline event can be happening at a given time.  Note also that we
+ * can accept some slop in the rsp->completed access due to the fact
+ * that this CPU cannot possibly have any RCU callbacks in flight yet.
+ */
+static void __cpuinit
+rcu_init_percpu_data(int cpu, struct rcu_state *rsp, int preemptable)
+{
+        unsigned long flags;
         long lastcomp;
         unsigned long mask;
         struct rcu_data *rdp = rsp->rda[cpu];
@@ -1354,17 +1432,9 @@ rcu_init_percpu_data(int cpu, struct rcu_state *rsp)
         rdp->passed_quiesc = 0;  /* We could be racing with new GP, */
         rdp->qs_pending = 1;     /*  so set up to respond to current GP. */
         rdp->beenonline = 1;     /* We have now been online. */
+        rdp->preemptable = preemptable;
         rdp->passed_quiesc_completed = lastcomp - 1;
-        rdp->grpmask = 1UL << (cpu - rdp->mynode->grplo);
-        rdp->nxtlist = NULL;
-        for (i = 0; i < RCU_NEXT_SIZE; i++)
-                rdp->nxttail[i] = &rdp->nxtlist;
-        rdp->qlen = 0;
         rdp->blimit = blimit;
-#ifdef CONFIG_NO_HZ
-        rdp->dynticks = &per_cpu(rcu_dynticks, cpu);
-#endif /* #ifdef CONFIG_NO_HZ */
-        rdp->cpu = cpu;
         spin_unlock(&rnp->lock);                /* irqs remain disabled. */
 
         /*
@@ -1405,16 +1475,16 @@ rcu_init_percpu_data(int cpu, struct rcu_state *rsp)
 
 static void __cpuinit rcu_online_cpu(int cpu)
 {
-        rcu_init_percpu_data(cpu, &rcu_state);
-        rcu_init_percpu_data(cpu, &rcu_bh_state);
-        open_softirq(RCU_SOFTIRQ, rcu_process_callbacks);
+        rcu_init_percpu_data(cpu, &rcu_sched_state, 0);
+        rcu_init_percpu_data(cpu, &rcu_bh_state, 0);
+        rcu_preempt_init_percpu_data(cpu);
 }
 
 /*
- * Handle CPU online/offline notifcation events.
+ * Handle CPU online/offline notification events.
  */
-static int __cpuinit rcu_cpu_notify(struct notifier_block *self,
-                                unsigned long action, void *hcpu)
+int __cpuinit rcu_cpu_notify(struct notifier_block *self,
+                             unsigned long action, void *hcpu)
 {
         long cpu = (long)hcpu;
 
@@ -1486,6 +1556,7 @@ static void __init rcu_init_one(struct rcu_state *rsp)
                 rnp = rsp->level[i];
                 for (j = 0; j < rsp->levelcnt[i]; j++, rnp++) {
                         spin_lock_init(&rnp->lock);
+                        rnp->gpnum = 0;
                         rnp->qsmask = 0;
                         rnp->qsmaskinit = 0;
                         rnp->grplo = j * cpustride;
@@ -1503,16 +1574,20 @@ static void __init rcu_init_one(struct rcu_state *rsp)
                                               j / rsp->levelspread[i - 1];
                         }
                         rnp->level = i;
+                        INIT_LIST_HEAD(&rnp->blocked_tasks[0]);
+                        INIT_LIST_HEAD(&rnp->blocked_tasks[1]);
                 }
         }
 }
 
 /*
- * Helper macro for __rcu_init().  To be used nowhere else!
- * Assigns leaf node pointers into each CPU's rcu_data structure.
+ * Helper macro for __rcu_init() and __rcu_init_preempt().  To be used
+ * nowhere else!  Assigns leaf node pointers into each CPU's rcu_data
+ * structure.
  */
-#define RCU_DATA_PTR_INIT(rsp, rcu_data) \
+#define RCU_INIT_FLAVOR(rsp, rcu_data) \
 do { \
+        rcu_init_one(rsp); \
         rnp = (rsp)->level[NUM_RCU_LVLS - 1]; \
         j = 0; \
         for_each_possible_cpu(i) { \
@@ -1520,32 +1595,43 @@ do { \
                         j++; \
                 per_cpu(rcu_data, i).mynode = &rnp[j]; \
                 (rsp)->rda[i] = &per_cpu(rcu_data, i); \
+                rcu_boot_init_percpu_data(i, rsp); \
         } \
 } while (0)
 
-static struct notifier_block __cpuinitdata rcu_nb = {
-        .notifier_call  = rcu_cpu_notify,
-};
+#ifdef CONFIG_TREE_PREEMPT_RCU
+
+void __init __rcu_init_preempt(void)
+{
+        int i;                  /* All used by RCU_INIT_FLAVOR(). */
+        int j;
+        struct rcu_node *rnp;
+
+        RCU_INIT_FLAVOR(&rcu_preempt_state, rcu_preempt_data);
+}
+
+#else /* #ifdef CONFIG_TREE_PREEMPT_RCU */
+
+void __init __rcu_init_preempt(void)
+{
+}
+
+#endif /* #else #ifdef CONFIG_TREE_PREEMPT_RCU */
 
 void __init __rcu_init(void)
 {
-        int i;                  /* All used by RCU_DATA_PTR_INIT(). */
+        int i;                  /* All used by RCU_INIT_FLAVOR(). */
         int j;
         struct rcu_node *rnp;
 
-        printk(KERN_INFO "Hierarchical RCU implementation.\n");
+        rcu_bootup_announce();
 #ifdef CONFIG_RCU_CPU_STALL_DETECTOR
         printk(KERN_INFO "RCU-based detection of stalled CPUs is enabled.\n");
 #endif /* #ifdef CONFIG_RCU_CPU_STALL_DETECTOR */
-        rcu_init_one(&rcu_state);
-        RCU_DATA_PTR_INIT(&rcu_state, rcu_data);
-        rcu_init_one(&rcu_bh_state);
-        RCU_DATA_PTR_INIT(&rcu_bh_state, rcu_bh_data);
-
-        for_each_online_cpu(i)
-                rcu_cpu_notify(&rcu_nb, CPU_UP_PREPARE, (void *)(long)i);
-        /* Register notifier for non-boot CPUs */
-        register_cpu_notifier(&rcu_nb);
+        RCU_INIT_FLAVOR(&rcu_sched_state, rcu_sched_data);
+        RCU_INIT_FLAVOR(&rcu_bh_state, rcu_bh_data);
+        __rcu_init_preempt();
+        open_softirq(RCU_SOFTIRQ, rcu_process_callbacks);
 }
 
 module_param(blimit, int, 0);
diff --git a/kernel/rcutree.h b/kernel/rcutree.h
index 5e872bbf07f5..bf8a6f9f134d 100644
--- a/kernel/rcutree.h
+++ b/kernel/rcutree.h
@@ -1,10 +1,259 @@
+/*
+ * Read-Copy Update mechanism for mutual exclusion (tree-based version)
+ * Internal non-public definitions.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+ *
+ * Copyright IBM Corporation, 2008
+ *
+ * Author: Ingo Molnar <mingo@elte.hu>
+ *         Paul E. McKenney <paulmck@linux.vnet.ibm.com>
+ */
+
+#include <linux/cache.h>
+#include <linux/spinlock.h>
+#include <linux/threads.h>
+#include <linux/cpumask.h>
+#include <linux/seqlock.h>
+
+/*
+ * Define shape of hierarchy based on NR_CPUS and CONFIG_RCU_FANOUT.
+ * In theory, it should be possible to add more levels straightforwardly.
+ * In practice, this has not been tested, so there is probably some
+ * bug somewhere.
+ */
+#define MAX_RCU_LVLS 3
+#define RCU_FANOUT            (CONFIG_RCU_FANOUT)
+#define RCU_FANOUT_SQ         (RCU_FANOUT * RCU_FANOUT)
+#define RCU_FANOUT_CUBE       (RCU_FANOUT_SQ * RCU_FANOUT)
+
+#if NR_CPUS <= RCU_FANOUT
+#  define NUM_RCU_LVLS        1
+#  define NUM_RCU_LVL_0       1
+#  define NUM_RCU_LVL_1       (NR_CPUS)
+#  define NUM_RCU_LVL_2       0
+#  define NUM_RCU_LVL_3       0
+#elif NR_CPUS <= RCU_FANOUT_SQ
+#  define NUM_RCU_LVLS        2
+#  define NUM_RCU_LVL_0       1
+#  define NUM_RCU_LVL_1       (((NR_CPUS) + RCU_FANOUT - 1) / RCU_FANOUT)
+#  define NUM_RCU_LVL_2       (NR_CPUS)
+#  define NUM_RCU_LVL_3       0
+#elif NR_CPUS <= RCU_FANOUT_CUBE
+#  define NUM_RCU_LVLS        3
+#  define NUM_RCU_LVL_0       1
+#  define NUM_RCU_LVL_1       (((NR_CPUS) + RCU_FANOUT_SQ - 1) / RCU_FANOUT_SQ)
+#  define NUM_RCU_LVL_2       (((NR_CPUS) + (RCU_FANOUT) - 1) / (RCU_FANOUT))
+#  define NUM_RCU_LVL_3       NR_CPUS
+#else
+# error "CONFIG_RCU_FANOUT insufficient for NR_CPUS"
+#endif /* #if (NR_CPUS) <= RCU_FANOUT */
+
+#define RCU_SUM (NUM_RCU_LVL_0 + NUM_RCU_LVL_1 + NUM_RCU_LVL_2 + NUM_RCU_LVL_3)
+#define NUM_RCU_NODES (RCU_SUM - NR_CPUS)
+
+/*
+ * Dynticks per-CPU state.
+ */
+struct rcu_dynticks {
+        int dynticks_nesting;   /* Track nesting level, sort of. */
+        int dynticks;           /* Even value for dynticks-idle, else odd. */
+        int dynticks_nmi;       /* Even value for either dynticks-idle or */
+                                /*  not in nmi handler, else odd.  So this */
+                                /*  remains even for nmi from irq handler. */
+};
+
+/*
+ * Definition for node within the RCU grace-period-detection hierarchy.
+ */
+struct rcu_node {
+        spinlock_t lock;
+        long    gpnum;          /* Current grace period for this node. */
+                                /*  This will either be equal to or one */
+                                /*  behind the root rcu_node's gpnum. */
+        unsigned long qsmask;   /* CPUs or groups that need to switch in */
+                                /*  order for current grace period to proceed.*/
+        unsigned long qsmaskinit;
+                                /* Per-GP initialization for qsmask. */
+        unsigned long grpmask;  /* Mask to apply to parent qsmask. */
+        int     grplo;          /* lowest-numbered CPU or group here. */
+        int     grphi;          /* highest-numbered CPU or group here. */
+        u8      grpnum;         /* CPU/group number for next level up. */
+        u8      level;          /* root is at level 0. */
+        struct rcu_node *parent;
+        struct list_head blocked_tasks[2];
+                                /* Tasks blocked in RCU read-side critsect. */
+} ____cacheline_internodealigned_in_smp;
+
+/* Index values for nxttail array in struct rcu_data. */
+#define RCU_DONE_TAIL           0       /* Also RCU_WAIT head. */
+#define RCU_WAIT_TAIL           1       /* Also RCU_NEXT_READY head. */
+#define RCU_NEXT_READY_TAIL     2       /* Also RCU_NEXT head. */
+#define RCU_NEXT_TAIL           3
+#define RCU_NEXT_SIZE           4
+
+/* Per-CPU data for read-copy update. */
+struct rcu_data {
+        /* 1) quiescent-state and grace-period handling : */
+        long            completed;      /* Track rsp->completed gp number */
+                                        /*  in order to detect GP end. */
+        long            gpnum;          /* Highest gp number that this CPU */
+                                        /*  is aware of having started. */
+        long            passed_quiesc_completed;
+                                        /* Value of completed at time of qs. */
+        bool            passed_quiesc;  /* User-mode/idle loop etc. */
+        bool            qs_pending;     /* Core waits for quiesc state. */
+        bool            beenonline;     /* CPU online at least once. */
+        bool            preemptable;    /* Preemptable RCU? */
+        struct rcu_node *mynode;        /* This CPU's leaf of hierarchy */
+        unsigned long grpmask;          /* Mask to apply to leaf qsmask. */
+
+        /* 2) batch handling */
+        /*
+         * If nxtlist is not NULL, it is partitioned as follows.
+         * Any of the partitions might be empty, in which case the
+         * pointer to that partition will be equal to the pointer for
+         * the following partition.  When the list is empty, all of
+         * the nxttail elements point to nxtlist, which is NULL.
+         *
+         * [*nxttail[RCU_NEXT_READY_TAIL], NULL = *nxttail[RCU_NEXT_TAIL]):
+         *      Entries that might have arrived after current GP ended
+         * [*nxttail[RCU_WAIT_TAIL], *nxttail[RCU_NEXT_READY_TAIL]):
+         *      Entries known to have arrived before current GP ended
+         * [*nxttail[RCU_DONE_TAIL], *nxttail[RCU_WAIT_TAIL]):
+         *      Entries that batch # <= ->completed - 1: waiting for current GP
+         * [nxtlist, *nxttail[RCU_DONE_TAIL]):
+         *      Entries that batch # <= ->completed
+         *      The grace period for these entries has completed, and
+         *      the other grace-period-completed entries may be moved
+         *      here temporarily in rcu_process_callbacks().
+         */
+        struct rcu_head *nxtlist;
+        struct rcu_head **nxttail[RCU_NEXT_SIZE];
+        long            qlen;           /* # of queued callbacks */
+        long            blimit;         /* Upper limit on a processed batch */
+
+#ifdef CONFIG_NO_HZ
+        /* 3) dynticks interface. */
+        struct rcu_dynticks *dynticks;  /* Shared per-CPU dynticks state. */
+        int dynticks_snap;              /* Per-GP tracking for dynticks. */
+        int dynticks_nmi_snap;          /* Per-GP tracking for dynticks_nmi. */
+#endif /* #ifdef CONFIG_NO_HZ */
+
+        /* 4) reasons this CPU needed to be kicked by force_quiescent_state */
+#ifdef CONFIG_NO_HZ
+        unsigned long dynticks_fqs;     /* Kicked due to dynticks idle. */
+#endif /* #ifdef CONFIG_NO_HZ */
+        unsigned long offline_fqs;      /* Kicked due to being offline. */
+        unsigned long resched_ipi;      /* Sent a resched IPI. */
+
+        /* 5) __rcu_pending() statistics. */
+        long n_rcu_pending;             /* rcu_pending() calls since boot. */
+        long n_rp_qs_pending;
+        long n_rp_cb_ready;
+        long n_rp_cpu_needs_gp;
+        long n_rp_gp_completed;
+        long n_rp_gp_started;
+        long n_rp_need_fqs;
+        long n_rp_need_nothing;
+
+        int cpu;
+};
+
+/* Values for signaled field in struct rcu_state. */
+#define RCU_GP_INIT             0       /* Grace period being initialized. */
+#define RCU_SAVE_DYNTICK        1       /* Need to scan dyntick state. */
+#define RCU_FORCE_QS            2       /* Need to force quiescent state. */
+#ifdef CONFIG_NO_HZ
+#define RCU_SIGNAL_INIT         RCU_SAVE_DYNTICK
+#else /* #ifdef CONFIG_NO_HZ */
+#define RCU_SIGNAL_INIT         RCU_FORCE_QS
+#endif /* #else #ifdef CONFIG_NO_HZ */
+
+#define RCU_JIFFIES_TILL_FORCE_QS        3      /* for rsp->jiffies_force_qs */
+#ifdef CONFIG_RCU_CPU_STALL_DETECTOR
+#define RCU_SECONDS_TILL_STALL_CHECK   (10 * HZ)  /* for rsp->jiffies_stall */
+#define RCU_SECONDS_TILL_STALL_RECHECK (30 * HZ)  /* for rsp->jiffies_stall */
+#define RCU_STALL_RAT_DELAY             2         /* Allow other CPUs time */
+                                                  /*  to take at least one */
+                                                  /*  scheduling clock irq */
+                                                  /*  before ratting on them. */
+
+#endif /* #ifdef CONFIG_RCU_CPU_STALL_DETECTOR */
+
+/*
+ * RCU global state, including node hierarchy.  This hierarchy is
+ * represented in "heap" form in a dense array.  The root (first level)
+ * of the hierarchy is in ->node[0] (referenced by ->level[0]), the second
+ * level in ->node[1] through ->node[m] (->node[1] referenced by ->level[1]),
+ * and the third level in ->node[m+1] and following (->node[m+1] referenced
+ * by ->level[2]).  The number of levels is determined by the number of
+ * CPUs and by CONFIG_RCU_FANOUT.  Small systems will have a "hierarchy"
+ * consisting of a single rcu_node.
+ */
+struct rcu_state {
+        struct rcu_node node[NUM_RCU_NODES];    /* Hierarchy. */
+        struct rcu_node *level[NUM_RCU_LVLS];   /* Hierarchy levels. */
+        u32 levelcnt[MAX_RCU_LVLS + 1];         /* # nodes in each level. */
+        u8 levelspread[NUM_RCU_LVLS];           /* kids/node in each level. */
+        struct rcu_data *rda[NR_CPUS];          /* array of rdp pointers. */
+
+        /* The following fields are guarded by the root rcu_node's lock. */
+
+        u8      signaled ____cacheline_internodealigned_in_smp;
+                                                /* Force QS state. */
+        long    gpnum;                          /* Current gp number. */
+        long    completed;                      /* # of last completed gp. */
+        spinlock_t onofflock;                   /* exclude on/offline and */
+                                                /*  starting new GP. */
+        spinlock_t fqslock;                     /* Only one task forcing */
+                                                /*  quiescent states. */
+        unsigned long jiffies_force_qs;         /* Time at which to invoke */
+                                                /*  force_quiescent_state(). */
+        unsigned long n_force_qs;               /* Number of calls to */
+                                                /*  force_quiescent_state(). */
+        unsigned long n_force_qs_lh;            /* ~Number of calls leaving */
+                                                /*  due to lock unavailable. */
+        unsigned long n_force_qs_ngp;           /* Number of calls leaving */
+                                                /*  due to no GP active. */
+#ifdef CONFIG_RCU_CPU_STALL_DETECTOR
+        unsigned long gp_start;                 /* Time at which GP started, */
+                                                /*  but in jiffies. */
+        unsigned long jiffies_stall;            /* Time at which to check */
+                                                /*  for CPU stalls. */
+#endif /* #ifdef CONFIG_RCU_CPU_STALL_DETECTOR */
+#ifdef CONFIG_NO_HZ
+        long dynticks_completed;                /* Value of completed @ snap. */
+#endif /* #ifdef CONFIG_NO_HZ */
+};
+
+#ifdef RCU_TREE_NONCORE
 
 /*
  * RCU implementation internal declarations:
  */
-extern struct rcu_state rcu_state;
-DECLARE_PER_CPU(struct rcu_data, rcu_data);
+extern struct rcu_state rcu_sched_state;
+DECLARE_PER_CPU(struct rcu_data, rcu_sched_data);
 
 extern struct rcu_state rcu_bh_state;
 DECLARE_PER_CPU(struct rcu_data, rcu_bh_data);
 
+#ifdef CONFIG_TREE_PREEMPT_RCU
+extern struct rcu_state rcu_preempt_state;
+DECLARE_PER_CPU(struct rcu_data, rcu_preempt_data);
+#endif /* #ifdef CONFIG_TREE_PREEMPT_RCU */
+
+#endif /* #ifdef RCU_TREE_NONCORE */
+
diff --git a/kernel/rcutree_plugin.h b/kernel/rcutree_plugin.h
new file mode 100644
index 000000000000..47789369ea59
--- /dev/null
+++ b/kernel/rcutree_plugin.h
@@ -0,0 +1,532 @@
+/*
+ * Read-Copy Update mechanism for mutual exclusion (tree-based version)
+ * Internal non-public definitions that provide either classic
+ * or preemptable semantics.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+ *
+ * Copyright Red Hat, 2009
+ * Copyright IBM Corporation, 2009
+ *
+ * Author: Ingo Molnar <mingo@elte.hu>
+ *         Paul E. McKenney <paulmck@linux.vnet.ibm.com>
+ */
+
+
+#ifdef CONFIG_TREE_PREEMPT_RCU
+
+struct rcu_state rcu_preempt_state = RCU_STATE_INITIALIZER(rcu_preempt_state);
+DEFINE_PER_CPU(struct rcu_data, rcu_preempt_data);
+
+/*
+ * Tell them what RCU they are running.
+ */
+static inline void rcu_bootup_announce(void)
+{
+        printk(KERN_INFO
+               "Experimental preemptable hierarchical RCU implementation.\n");
+}
+
+/*
+ * Return the number of RCU-preempt batches processed thus far
+ * for debug and statistics.
+ */
+long rcu_batches_completed_preempt(void)
+{
+        return rcu_preempt_state.completed;
+}
+EXPORT_SYMBOL_GPL(rcu_batches_completed_preempt);
+
+/*
+ * Return the number of RCU batches processed thus far for debug & stats.
+ */
+long rcu_batches_completed(void)
+{
+        return rcu_batches_completed_preempt();
+}
+EXPORT_SYMBOL_GPL(rcu_batches_completed);
+
+/*
+ * Record a preemptable-RCU quiescent state for the specified CPU.  Note
+ * that this just means that the task currently running on the CPU is
+ * not in a quiescent state.  There might be any number of tasks blocked
+ * while in an RCU read-side critical section.
+ */
+static void rcu_preempt_qs_record(int cpu)
+{
+        struct rcu_data *rdp = &per_cpu(rcu_preempt_data, cpu);
+        rdp->passed_quiesc = 1;
+        rdp->passed_quiesc_completed = rdp->completed;
+}
+
+/*
+ * We have entered the scheduler or are between softirqs in ksoftirqd.
+ * If we are in an RCU read-side critical section, we need to reflect
+ * that in the state of the rcu_node structure corresponding to this CPU.
+ * Caller must disable hardirqs.
+ */
+static void rcu_preempt_qs(int cpu)
+{
+        struct task_struct *t = current;
+        int phase;
+        struct rcu_data *rdp;
+        struct rcu_node *rnp;
+
+        if (t->rcu_read_lock_nesting &&
+            (t->rcu_read_unlock_special & RCU_READ_UNLOCK_BLOCKED) == 0) {
+
+                /* Possibly blocking in an RCU read-side critical section. */
+                rdp = rcu_preempt_state.rda[cpu];
+                rnp = rdp->mynode;
+                spin_lock(&rnp->lock);
+                t->rcu_read_unlock_special |= RCU_READ_UNLOCK_BLOCKED;
+                t->rcu_blocked_node = rnp;
+
+                /*
+                 * If this CPU has already checked in, then this task
+                 * will hold up the next grace period rather than the
+                 * current grace period.  Queue the task accordingly.
+                 * If the task is queued for the current grace period
+                 * (i.e., this CPU has not yet passed through a quiescent
+                 * state for the current grace period), then as long
+                 * as that task remains queued, the current grace period
+                 * cannot end.
+                 */
+                phase = !(rnp->qsmask & rdp->grpmask) ^ (rnp->gpnum & 0x1);
+                list_add(&t->rcu_node_entry, &rnp->blocked_tasks[phase]);
+                smp_mb();  /* Ensure later ctxt swtch seen after above. */
+                spin_unlock(&rnp->lock);
+        }
+
+        /*
+         * Either we were not in an RCU read-side critical section to
+         * begin with, or we have now recorded that critical section
+         * globally.  Either way, we can now note a quiescent state
+         * for this CPU.  Again, if we were in an RCU read-side critical
+         * section, and if that critical section was blocking the current
+         * grace period, then the fact that the task has been enqueued
+         * means that we continue to block the current grace period.
+         */
+        rcu_preempt_qs_record(cpu);
+        t->rcu_read_unlock_special &= ~(RCU_READ_UNLOCK_NEED_QS |
+                                        RCU_READ_UNLOCK_GOT_QS);
+}
+
+/*
+ * Tree-preemptable RCU implementation for rcu_read_lock().
+ * Just increment ->rcu_read_lock_nesting, shared state will be updated
+ * if we block.
+ */
+void __rcu_read_lock(void)
+{
+        ACCESS_ONCE(current->rcu_read_lock_nesting)++;
+        barrier();  /* needed if we ever invoke rcu_read_lock in rcutree.c */
+}
+EXPORT_SYMBOL_GPL(__rcu_read_lock);
+
+static void rcu_read_unlock_special(struct task_struct *t)
+{
+        int empty;
+        unsigned long flags;
+        unsigned long mask;
+        struct rcu_node *rnp;
+        int special;
+
+        /* NMI handlers cannot block and cannot safely manipulate state. */
+        if (in_nmi())
+                return;
+
+        local_irq_save(flags);
+
+        /*
+         * If RCU core is waiting for this CPU to exit critical section,
+         * let it know that we have done so.
+         */
+        special = t->rcu_read_unlock_special;
+        if (special & RCU_READ_UNLOCK_NEED_QS) {
+                t->rcu_read_unlock_special &= ~RCU_READ_UNLOCK_NEED_QS;
+                t->rcu_read_unlock_special |= RCU_READ_UNLOCK_GOT_QS;
+        }
+
+        /* Hardware IRQ handlers cannot block. */
+        if (in_irq()) {
+                local_irq_restore(flags);
+                return;
+        }
+
+        /* Clean up if blocked during RCU read-side critical section. */
+        if (special & RCU_READ_UNLOCK_BLOCKED) {
+                t->rcu_read_unlock_special &= ~RCU_READ_UNLOCK_BLOCKED;
+
+                /*
+                 * Remove this task from the list it blocked on.  The
+                 * task can migrate while we acquire the lock, but at
+                 * most one time.  So at most two passes through loop.
+                 */
+                for (;;) {
+                        rnp = t->rcu_blocked_node;
+                        spin_lock(&rnp->lock);
+                        if (rnp == t->rcu_blocked_node)
+                                break;
+                        spin_unlock(&rnp->lock);
+                }
+                empty = list_empty(&rnp->blocked_tasks[rnp->gpnum & 0x1]);
+                list_del_init(&t->rcu_node_entry);
+                t->rcu_blocked_node = NULL;
+
+                /*
+                 * If this was the last task on the current list, and if
+                 * we aren't waiting on any CPUs, report the quiescent state.
+                 * Note that both cpu_quiet_msk_finish() and cpu_quiet_msk()
+                 * drop rnp->lock and restore irq.
+                 */
+                if (!empty && rnp->qsmask == 0 &&
+                    list_empty(&rnp->blocked_tasks[rnp->gpnum & 0x1])) {
+                        t->rcu_read_unlock_special &=
+                                ~(RCU_READ_UNLOCK_NEED_QS |
+                                  RCU_READ_UNLOCK_GOT_QS);
+                        if (rnp->parent == NULL) {
+                                /* Only one rcu_node in the tree. */
+                                cpu_quiet_msk_finish(&rcu_preempt_state, flags);
+                                return;
+                        }
+                        /* Report up the rest of the hierarchy. */
+                        mask = rnp->grpmask;
+                        spin_unlock_irqrestore(&rnp->lock, flags);
+                        rnp = rnp->parent;
+                        spin_lock_irqsave(&rnp->lock, flags);
+                        cpu_quiet_msk(mask, &rcu_preempt_state, rnp, flags);
+                        return;
+                }
+                spin_unlock(&rnp->lock);
+        }
+        local_irq_restore(flags);
+}
+
+/*
+ * Tree-preemptable RCU implementation for rcu_read_unlock().
+ * Decrement ->rcu_read_lock_nesting.  If the result is zero (outermost
+ * rcu_read_unlock()) and ->rcu_read_unlock_special is non-zero, then
+ * invoke rcu_read_unlock_special() to clean up after a context switch
+ * in an RCU read-side critical section and other special cases.
+ */
+void __rcu_read_unlock(void)
+{
+        struct task_struct *t = current;
+
+        barrier();  /* needed if we ever invoke rcu_read_unlock in rcutree.c */
+        if (--ACCESS_ONCE(t->rcu_read_lock_nesting) == 0 &&
+            unlikely(ACCESS_ONCE(t->rcu_read_unlock_special)))
+                rcu_read_unlock_special(t);
+}
+EXPORT_SYMBOL_GPL(__rcu_read_unlock);
+
+#ifdef CONFIG_RCU_CPU_STALL_DETECTOR
+
+/*
+ * Scan the current list of tasks blocked within RCU read-side critical
+ * sections, printing out the tid of each.
+ */
+static void rcu_print_task_stall(struct rcu_node *rnp)
+{
+        unsigned long flags;
+        struct list_head *lp;
+        int phase = rnp->gpnum & 0x1;
+        struct task_struct *t;
+
+        if (!list_empty(&rnp->blocked_tasks[phase])) {
+                spin_lock_irqsave(&rnp->lock, flags);
+                phase = rnp->gpnum & 0x1; /* re-read under lock. */
+                lp = &rnp->blocked_tasks[phase];
+                list_for_each_entry(t, lp, rcu_node_entry)
+                        printk(" P%d", t->pid);
+                spin_unlock_irqrestore(&rnp->lock, flags);
+        }
+}
+
+#endif /* #ifdef CONFIG_RCU_CPU_STALL_DETECTOR */
+
+/*
+ * Check for preempted RCU readers for the specified rcu_node structure.
+ * If the caller needs a reliable answer, it must hold the rcu_node's
+ * >lock.
+ */
+static int rcu_preempted_readers(struct rcu_node *rnp)
+{
+        return !list_empty(&rnp->blocked_tasks[rnp->gpnum & 0x1]);
+}
+
+#ifdef CONFIG_HOTPLUG_CPU
+
+/*
+ * Handle tasklist migration for case in which all CPUs covered by the
+ * specified rcu_node have gone offline.  Move them up to the root
+ * rcu_node.  The reason for not just moving them to the immediate
+ * parent is to remove the need for rcu_read_unlock_special() to
+ * make more than two attempts to acquire the target rcu_node's lock.
+ *
+ * The caller must hold rnp->lock with irqs disabled.
+ */
+static void rcu_preempt_offline_tasks(struct rcu_state *rsp,
+                                      struct rcu_node *rnp)
+{
+        int i;
+        struct list_head *lp;
+        struct list_head *lp_root;
+        struct rcu_node *rnp_root = rcu_get_root(rsp);
+        struct task_struct *tp;
+
+        if (rnp == rnp_root) {
+                WARN_ONCE(1, "Last CPU thought to be offlined?");
+                return;  /* Shouldn't happen: at least one CPU online. */
+        }
+
+        /*
+         * Move tasks up to root rcu_node.  Rely on the fact that the
+         * root rcu_node can be at most one ahead of the rest of the
+         * rcu_nodes in terms of gp_num value.  This fact allows us to
+         * move the blocked_tasks[] array directly, element by element.
+         */
+        for (i = 0; i < 2; i++) {
+                lp = &rnp->blocked_tasks[i];
+                lp_root = &rnp_root->blocked_tasks[i];
+                while (!list_empty(lp)) {
+                        tp = list_entry(lp->next, typeof(*tp), rcu_node_entry);
+                        spin_lock(&rnp_root->lock); /* irqs already disabled */
+                        list_del(&tp->rcu_node_entry);
+                        tp->rcu_blocked_node = rnp_root;
+                        list_add(&tp->rcu_node_entry, lp_root);
+                        spin_unlock(&rnp_root->lock); /* irqs remain disabled */
+                }
+        }
+}
+
+/*
+ * Do CPU-offline processing for preemptable RCU.
+ */
+static void rcu_preempt_offline_cpu(int cpu)
+{
+        __rcu_offline_cpu(cpu, &rcu_preempt_state);
+}
+
+#endif /* #ifdef CONFIG_HOTPLUG_CPU */
+
+/*
+ * Check for a quiescent state from the current CPU.  When a task blocks,
+ * the task is recorded in the corresponding CPU's rcu_node structure,
+ * which is checked elsewhere.
+ *
+ * Caller must disable hard irqs.
+ */
+static void rcu_preempt_check_callbacks(int cpu)
+{
+        struct task_struct *t = current;
+
+        if (t->rcu_read_lock_nesting == 0) {
+                t->rcu_read_unlock_special &=
+                        ~(RCU_READ_UNLOCK_NEED_QS | RCU_READ_UNLOCK_GOT_QS);
+                rcu_preempt_qs_record(cpu);
+                return;
+        }
+        if (per_cpu(rcu_preempt_data, cpu).qs_pending) {
+                if (t->rcu_read_unlock_special & RCU_READ_UNLOCK_GOT_QS) {
+                        rcu_preempt_qs_record(cpu);
+                        t->rcu_read_unlock_special &= ~RCU_READ_UNLOCK_GOT_QS;
+                } else if (!(t->rcu_read_unlock_special &
+                             RCU_READ_UNLOCK_NEED_QS)) {
+                        t->rcu_read_unlock_special |= RCU_READ_UNLOCK_NEED_QS;
+                }
+        }
+}
+
+/*
+ * Process callbacks for preemptable RCU.
+ */
+static void rcu_preempt_process_callbacks(void)
+{
+        __rcu_process_callbacks(&rcu_preempt_state,
+                                &__get_cpu_var(rcu_preempt_data));
+}
+
+/*
+ * Queue a preemptable-RCU callback for invocation after a grace period.
+ */
+void call_rcu(struct rcu_head *head, void (*func)(struct rcu_head *rcu))
+{
+        __call_rcu(head, func, &rcu_preempt_state);
+}
+EXPORT_SYMBOL_GPL(call_rcu);
+
+/*
+ * Check to see if there is any immediate preemptable-RCU-related work
+ * to be done.
+ */
+static int rcu_preempt_pending(int cpu)
+{
+        return __rcu_pending(&rcu_preempt_state,
+                             &per_cpu(rcu_preempt_data, cpu));
+}
+
+/*
+ * Does preemptable RCU need the CPU to stay out of dynticks mode?
+ */
+static int rcu_preempt_needs_cpu(int cpu)
+{
+        return !!per_cpu(rcu_preempt_data, cpu).nxtlist;
+}
+
+/*
+ * Initialize preemptable RCU's per-CPU data.
+ */
+static void __cpuinit rcu_preempt_init_percpu_data(int cpu)
+{
+        rcu_init_percpu_data(cpu, &rcu_preempt_state, 1);
+}
+
+/*
+ * Check for a task exiting while in a preemptable-RCU read-side
+ * critical section, clean up if so.  No need to issue warnings,
+ * as debug_check_no_locks_held() already does this if lockdep
+ * is enabled.
+ */
+void exit_rcu(void)
+{
+        struct task_struct *t = current;
+
+        if (t->rcu_read_lock_nesting == 0)
+                return;
+        t->rcu_read_lock_nesting = 1;
+        rcu_read_unlock();
+}
+
+#else /* #ifdef CONFIG_TREE_PREEMPT_RCU */
+
+/*
+ * Tell them what RCU they are running.
+ */
+static inline void rcu_bootup_announce(void)
+{
+        printk(KERN_INFO "Hierarchical RCU implementation.\n");
+}
+
+/*
+ * Return the number of RCU batches processed thus far for debug & stats.
+ */
+long rcu_batches_completed(void)
+{
+        return rcu_batches_completed_sched();
+}
+EXPORT_SYMBOL_GPL(rcu_batches_completed);
+
+/*
+ * Because preemptable RCU does not exist, we never have to check for
+ * CPUs being in quiescent states.
+ */
+static void rcu_preempt_qs(int cpu)
+{
+}
+
+#ifdef CONFIG_RCU_CPU_STALL_DETECTOR
+
+/*
+ * Because preemptable RCU does not exist, we never have to check for
+ * tasks blocked within RCU read-side critical sections.
+ */
+static void rcu_print_task_stall(struct rcu_node *rnp)
+{
+}
+
+#endif /* #ifdef CONFIG_RCU_CPU_STALL_DETECTOR */
+
+/*
+ * Because preemptable RCU does not exist, there are never any preempted
+ * RCU readers.
+ */
+static int rcu_preempted_readers(struct rcu_node *rnp)
+{
+        return 0;
+}
+
+#ifdef CONFIG_HOTPLUG_CPU
+
+/*
+ * Because preemptable RCU does not exist, it never needs to migrate
+ * tasks that were blocked within RCU read-side critical sections.
+ */
+static void rcu_preempt_offline_tasks(struct rcu_state *rsp,
+                                      struct rcu_node *rnp)
+{
+}
+
+/*
+ * Because preemptable RCU does not exist, it never needs CPU-offline
+ * processing.
+ */
+static void rcu_preempt_offline_cpu(int cpu)
+{
+}
+
+#endif /* #ifdef CONFIG_HOTPLUG_CPU */
+
+/*
+ * Because preemptable RCU does not exist, it never has any callbacks
+ * to check.
+ */
+void rcu_preempt_check_callbacks(int cpu)
+{
+}
+
+/*
+ * Because preemptable RCU does not exist, it never has any callbacks
+ * to process.
+ */
+void rcu_preempt_process_callbacks(void)
+{
+}
+
+/*
+ * In classic RCU, call_rcu() is just call_rcu_sched().
+ */
+void call_rcu(struct rcu_head *head, void (*func)(struct rcu_head *rcu))
+{
+        call_rcu_sched(head, func);
+}
+EXPORT_SYMBOL_GPL(call_rcu);
+
+/*
+ * Because preemptable RCU does not exist, it never has any work to do.
+ */
+static int rcu_preempt_pending(int cpu)
+{
+        return 0;
+}
+
+/*
+ * Because preemptable RCU does not exist, it never needs any CPU.
+ */
+static int rcu_preempt_needs_cpu(int cpu)
+{
+        return 0;
+}
+
+/*
+ * Because preemptable RCU does not exist, there is no per-CPU
+ * data to initialize.
+ */
+static void __cpuinit rcu_preempt_init_percpu_data(int cpu)
+{
+}
+
+#endif /* #else #ifdef CONFIG_TREE_PREEMPT_RCU */
diff --git a/kernel/rcutree_trace.c b/kernel/rcutree_trace.c
index fe1dcdbf1ca3..0ea1bff69727 100644
--- a/kernel/rcutree_trace.c
+++ b/kernel/rcutree_trace.c
@@ -43,6 +43,7 @@
 #include <linux/debugfs.h>
 #include <linux/seq_file.h>
 
+#define RCU_TREE_NONCORE
 #include "rcutree.h"
 
 static void print_one_rcu_data(struct seq_file *m, struct rcu_data *rdp)
@@ -76,8 +77,12 @@ static void print_one_rcu_data(struct seq_file *m, struct rcu_data *rdp)
 
 static int show_rcudata(struct seq_file *m, void *unused)
 {
-        seq_puts(m, "rcu:\n");
-        PRINT_RCU_DATA(rcu_data, print_one_rcu_data, m);
+#ifdef CONFIG_TREE_PREEMPT_RCU
+        seq_puts(m, "rcu_preempt:\n");
+        PRINT_RCU_DATA(rcu_preempt_data, print_one_rcu_data, m);
+#endif /* #ifdef CONFIG_TREE_PREEMPT_RCU */
+        seq_puts(m, "rcu_sched:\n");
+        PRINT_RCU_DATA(rcu_sched_data, print_one_rcu_data, m);
         seq_puts(m, "rcu_bh:\n");
         PRINT_RCU_DATA(rcu_bh_data, print_one_rcu_data, m);
         return 0;
@@ -102,7 +107,7 @@ static void print_one_rcu_data_csv(struct seq_file *m, struct rcu_data *rdp)
                 return;
         seq_printf(m, "%d,%s,%ld,%ld,%d,%ld,%d",
                    rdp->cpu,
-                   cpu_is_offline(rdp->cpu) ? "\"Y\"" : "\"N\"",
+                   cpu_is_offline(rdp->cpu) ? "\"N\"" : "\"Y\"",
                    rdp->completed, rdp->gpnum,
                    rdp->passed_quiesc, rdp->passed_quiesc_completed,
                    rdp->qs_pending);
@@ -124,8 +129,12 @@ static int show_rcudata_csv(struct seq_file *m, void *unused)
         seq_puts(m, "\"dt\",\"dt nesting\",\"dn\",\"df\",");
 #endif /* #ifdef CONFIG_NO_HZ */
         seq_puts(m, "\"of\",\"ri\",\"ql\",\"b\"\n");
-        seq_puts(m, "\"rcu:\"\n");
-        PRINT_RCU_DATA(rcu_data, print_one_rcu_data_csv, m);
+#ifdef CONFIG_TREE_PREEMPT_RCU
+        seq_puts(m, "\"rcu_preempt:\"\n");
+        PRINT_RCU_DATA(rcu_preempt_data, print_one_rcu_data_csv, m);
+#endif /* #ifdef CONFIG_TREE_PREEMPT_RCU */
+        seq_puts(m, "\"rcu_sched:\"\n");
+        PRINT_RCU_DATA(rcu_sched_data, print_one_rcu_data_csv, m);
         seq_puts(m, "\"rcu_bh:\"\n");
         PRINT_RCU_DATA(rcu_bh_data, print_one_rcu_data_csv, m);
         return 0;
@@ -171,8 +180,12 @@ static void print_one_rcu_state(struct seq_file *m, struct rcu_state *rsp)
 
 static int show_rcuhier(struct seq_file *m, void *unused)
 {
-        seq_puts(m, "rcu:\n");
-        print_one_rcu_state(m, &rcu_state);
+#ifdef CONFIG_TREE_PREEMPT_RCU
+        seq_puts(m, "rcu_preempt:\n");
+        print_one_rcu_state(m, &rcu_preempt_state);
+#endif /* #ifdef CONFIG_TREE_PREEMPT_RCU */
+        seq_puts(m, "rcu_sched:\n");
+        print_one_rcu_state(m, &rcu_sched_state);
         seq_puts(m, "rcu_bh:\n");
         print_one_rcu_state(m, &rcu_bh_state);
         return 0;
@@ -193,8 +206,12 @@ static struct file_operations rcuhier_fops = {
 
 static int show_rcugp(struct seq_file *m, void *unused)
 {
-        seq_printf(m, "rcu: completed=%ld  gpnum=%ld\n",
-                   rcu_state.completed, rcu_state.gpnum);
+#ifdef CONFIG_TREE_PREEMPT_RCU
+        seq_printf(m, "rcu_preempt: completed=%ld  gpnum=%ld\n",
+                   rcu_preempt_state.completed, rcu_preempt_state.gpnum);
+#endif /* #ifdef CONFIG_TREE_PREEMPT_RCU */
+        seq_printf(m, "rcu_sched: completed=%ld  gpnum=%ld\n",
+                   rcu_sched_state.completed, rcu_sched_state.gpnum);
         seq_printf(m, "rcu_bh: completed=%ld  gpnum=%ld\n",
                    rcu_bh_state.completed, rcu_bh_state.gpnum);
         return 0;
@@ -243,8 +260,12 @@ static void print_rcu_pendings(struct seq_file *m, struct rcu_state *rsp)
 
 static int show_rcu_pending(struct seq_file *m, void *unused)
 {
-        seq_puts(m, "rcu:\n");
-        print_rcu_pendings(m, &rcu_state);
+#ifdef CONFIG_TREE_PREEMPT_RCU
+        seq_puts(m, "rcu_preempt:\n");
+        print_rcu_pendings(m, &rcu_preempt_state);
+#endif /* #ifdef CONFIG_TREE_PREEMPT_RCU */
+        seq_puts(m, "rcu_sched:\n");
+        print_rcu_pendings(m, &rcu_sched_state);
         seq_puts(m, "rcu_bh:\n");
         print_rcu_pendings(m, &rcu_bh_state);
         return 0;
@@ -264,62 +285,47 @@ static struct file_operations rcu_pending_fops = {
 };
 
 static struct dentry *rcudir;
-static struct dentry *datadir;
-static struct dentry *datadir_csv;
-static struct dentry *gpdir;
-static struct dentry *hierdir;
-static struct dentry *rcu_pendingdir;
 
 static int __init rcuclassic_trace_init(void)
 {
+        struct dentry *retval;
+
         rcudir = debugfs_create_dir("rcu", NULL);
         if (!rcudir)
-                goto out;
+                goto free_out;
 
-        datadir = debugfs_create_file("rcudata", 0444, rcudir,
+        retval = debugfs_create_file("rcudata", 0444, rcudir,
                                                 NULL, &rcudata_fops);
-        if (!datadir)
+        if (!retval)
                 goto free_out;
 
-        datadir_csv = debugfs_create_file("rcudata.csv", 0444, rcudir,
+        retval = debugfs_create_file("rcudata.csv", 0444, rcudir,
                                                 NULL, &rcudata_csv_fops);
-        if (!datadir_csv)
+        if (!retval)
                 goto free_out;
 
-        gpdir = debugfs_create_file("rcugp", 0444, rcudir, NULL, &rcugp_fops);
-        if (!gpdir)
+        retval = debugfs_create_file("rcugp", 0444, rcudir, NULL, &rcugp_fops);
+        if (!retval)
                 goto free_out;
 
-        hierdir = debugfs_create_file("rcuhier", 0444, rcudir,
+        retval = debugfs_create_file("rcuhier", 0444, rcudir,
                                                 NULL, &rcuhier_fops);
-        if (!hierdir)
+        if (!retval)
                 goto free_out;
 
-        rcu_pendingdir = debugfs_create_file("rcu_pending", 0444, rcudir,
+        retval = debugfs_create_file("rcu_pending", 0444, rcudir,
                                                 NULL, &rcu_pending_fops);
-        if (!rcu_pendingdir)
+        if (!retval)
                 goto free_out;
         return 0;
 free_out:
-        if (datadir)
-                debugfs_remove(datadir);
-        if (datadir_csv)
-                debugfs_remove(datadir_csv);
-        if (gpdir)
-                debugfs_remove(gpdir);
-        debugfs_remove(rcudir);
-out:
+        debugfs_remove_recursive(rcudir);
         return 1;
 }
 
 static void __exit rcuclassic_trace_cleanup(void)
 {
-        debugfs_remove(datadir);
-        debugfs_remove(datadir_csv);
-        debugfs_remove(gpdir);
-        debugfs_remove(hierdir);
-        debugfs_remove(rcu_pendingdir);
-        debugfs_remove(rcudir);
+        debugfs_remove_recursive(rcudir);
 }
 
 
diff --git a/kernel/sched.c b/kernel/sched.c
index 1b59e265273b..e27a53685ed9 100644
--- a/kernel/sched.c
+++ b/kernel/sched.c
@@ -64,7 +64,6 @@
 #include <linux/tsacct_kern.h>
 #include <linux/kprobes.h>
 #include <linux/delayacct.h>
-#include <linux/reciprocal_div.h>
 #include <linux/unistd.h>
 #include <linux/pagemap.h>
 #include <linux/hrtimer.h>
@@ -120,30 +119,8 @@
  */
 #define RUNTIME_INF     ((u64)~0ULL)
 
-#ifdef CONFIG_SMP
-
 static void double_rq_lock(struct rq *rq1, struct rq *rq2);
 
-/*
- * Divide a load by a sched group cpu_power : (load / sg->__cpu_power)
- * Since cpu_power is a 'constant', we can use a reciprocal divide.
- */
-static inline u32 sg_div_cpu_power(const struct sched_group *sg, u32 load)
-{
-        return reciprocal_divide(load, sg->reciprocal_cpu_power);
-}
-
-/*
- * Each time a sched group cpu_power is changed,
- * we must compute its reciprocal value
- */
-static inline void sg_inc_cpu_power(struct sched_group *sg, u32 val)
-{
-        sg->__cpu_power += val;
-        sg->reciprocal_cpu_power = reciprocal_value(sg->__cpu_power);
-}
-#endif
-
 static inline int rt_policy(int policy)
 {
         if (unlikely(policy == SCHED_FIFO || policy == SCHED_RR))
@@ -309,8 +286,8 @@ void set_tg_uid(struct user_struct *user)
 
 /*
  * Root task group.
- *      Every UID task group (including init_task_group aka UID-0) will
- *      be a child to this group.
+ *      Every UID task group (including init_task_group aka UID-0) will
+ *      be a child to this group.
  */
 struct task_group root_task_group;
 
@@ -318,7 +295,7 @@ struct task_group root_task_group;
 /* Default task group's sched entity on each cpu */
 static DEFINE_PER_CPU(struct sched_entity, init_sched_entity);
 /* Default task group's cfs_rq on each cpu */
-static DEFINE_PER_CPU(struct cfs_rq, init_cfs_rq) ____cacheline_aligned_in_smp;
+static DEFINE_PER_CPU(struct cfs_rq, init_tg_cfs_rq) ____cacheline_aligned_in_smp;
 #endif /* CONFIG_FAIR_GROUP_SCHED */
 
 #ifdef CONFIG_RT_GROUP_SCHED
@@ -616,6 +593,7 @@ struct rq {
 
         unsigned char idle_at_tick;
         /* For active balancing */
+        int post_schedule;
         int active_balance;
         int push_cpu;
         /* cpu of this runqueue: */
@@ -626,6 +604,9 @@ struct rq {
 
         struct task_struct *migration_thread;
         struct list_head migration_queue;
+
+        u64 rt_avg;
+        u64 age_stamp;
 #endif
 
         /* calc_load related fields */
@@ -693,6 +674,7 @@ static inline int cpu_of(struct rq *rq)
 #define this_rq()               (&__get_cpu_var(runqueues))
 #define task_rq(p)              cpu_rq(task_cpu(p))
 #define cpu_curr(cpu)           (cpu_rq(cpu)->curr)
+#define raw_rq()                (&__raw_get_cpu_var(runqueues))
 
 inline void update_rq_clock(struct rq *rq)
 {
@@ -861,6 +843,14 @@ unsigned int sysctl_sched_shares_ratelimit = 250000;
 unsigned int sysctl_sched_shares_thresh = 4;
 
 /*
+ * period over which we average the RT time consumption, measured
+ * in ms.
+ *
+ * default: 1s
+ */
+const_debug unsigned int sysctl_sched_time_avg = MSEC_PER_SEC;
+
+/*
  * period over which we measure -rt task cpu usage in us.
  * default: 1s
  */
@@ -1278,12 +1268,37 @@ void wake_up_idle_cpu(int cpu)
 }
 #endif /* CONFIG_NO_HZ */
 
+static u64 sched_avg_period(void)
+{
+        return (u64)sysctl_sched_time_avg * NSEC_PER_MSEC / 2;
+}
+
+static void sched_avg_update(struct rq *rq)
+{
+        s64 period = sched_avg_period();
+
+        while ((s64)(rq->clock - rq->age_stamp) > period) {
+                rq->age_stamp += period;
+                rq->rt_avg /= 2;
+        }
+}
+
+static void sched_rt_avg_update(struct rq *rq, u64 rt_delta)
+{
+        rq->rt_avg += rt_delta;
+        sched_avg_update(rq);
+}
+
 #else /* !CONFIG_SMP */
 static void resched_task(struct task_struct *p)
 {
         assert_spin_locked(&task_rq(p)->lock);
         set_tsk_need_resched(p);
 }
+
+static void sched_rt_avg_update(struct rq *rq, u64 rt_delta)
+{
+}
 #endif /* CONFIG_SMP */
 
 #if BITS_PER_LONG == 32
@@ -1513,28 +1528,35 @@ static unsigned long cpu_avg_load_per_task(int cpu)
 
 #ifdef CONFIG_FAIR_GROUP_SCHED
 
+struct update_shares_data {
+        unsigned long rq_weight[NR_CPUS];
+};
+
+static DEFINE_PER_CPU(struct update_shares_data, update_shares_data);
+
 static void __set_se_shares(struct sched_entity *se, unsigned long shares);
 
 /*
  * Calculate and set the cpu's group shares.
  */
-static void
-update_group_shares_cpu(struct task_group *tg, int cpu,
-                        unsigned long sd_shares, unsigned long sd_rq_weight)
+static void update_group_shares_cpu(struct task_group *tg, int cpu,
+                                    unsigned long sd_shares,
+                                    unsigned long sd_rq_weight,
+                                    struct update_shares_data *usd)
 {
-        unsigned long shares;
-        unsigned long rq_weight;
-
-        if (!tg->se[cpu])
-                return;
+        unsigned long shares, rq_weight;
+        int boost = 0;
 
-        rq_weight = tg->cfs_rq[cpu]->rq_weight;
+        rq_weight = usd->rq_weight[cpu];
+        if (!rq_weight) {
+                boost = 1;
+                rq_weight = NICE_0_LOAD;
+        }
 
         /*
-         *           \Sum shares * rq_weight
-         * shares =  -----------------------
-         *               \Sum rq_weight
-         *
+         *             \Sum_j shares_j * rq_weight_i
+         * shares_i =  -----------------------------
+         *                  \Sum_j rq_weight_j
          */
         shares = (sd_shares * rq_weight) / sd_rq_weight;
         shares = clamp_t(unsigned long, shares, MIN_SHARES, MAX_SHARES);
@@ -1545,8 +1567,8 @@ update_group_shares_cpu(struct task_group *tg, int cpu,
                 unsigned long flags;
 
                 spin_lock_irqsave(&rq->lock, flags);
-                tg->cfs_rq[cpu]->shares = shares;
-
+                tg->cfs_rq[cpu]->rq_weight = boost ? 0 : rq_weight;
+                tg->cfs_rq[cpu]->shares = boost ? 0 : shares;
                 __set_se_shares(tg->se[cpu], shares);
                 spin_unlock_irqrestore(&rq->lock, flags);
         }
@@ -1559,22 +1581,30 @@ update_group_shares_cpu(struct task_group *tg, int cpu,
  */
 static int tg_shares_up(struct task_group *tg, void *data)
 {
-        unsigned long weight, rq_weight = 0;
-        unsigned long shares = 0;
+        unsigned long weight, rq_weight = 0, shares = 0;
+        struct update_shares_data *usd;
         struct sched_domain *sd = data;
+        unsigned long flags;
         int i;
 
+        if (!tg->se[0])
+                return 0;
+
+        local_irq_save(flags);
+        usd = &__get_cpu_var(update_shares_data);
+
         for_each_cpu(i, sched_domain_span(sd)) {
+                weight = tg->cfs_rq[i]->load.weight;
+                usd->rq_weight[i] = weight;
+
                 /*
                  * If there are currently no tasks on the cpu pretend there
                  * is one of average load so that when a new task gets to
                  * run here it will not get delayed by group starvation.
                  */
-                weight = tg->cfs_rq[i]->load.weight;
                 if (!weight)
                         weight = NICE_0_LOAD;
 
-                tg->cfs_rq[i]->rq_weight = weight;
                 rq_weight += weight;
                 shares += tg->cfs_rq[i]->shares;
         }
@@ -1586,7 +1616,9 @@ static int tg_shares_up(struct task_group *tg, void *data)
                 shares = tg->shares;
 
         for_each_cpu(i, sched_domain_span(sd))
-                update_group_shares_cpu(tg, i, shares, rq_weight);
+                update_group_shares_cpu(tg, i, shares, rq_weight, usd);
+
+        local_irq_restore(flags);
 
         return 0;
 }
@@ -1616,8 +1648,14 @@ static int tg_load_down(struct task_group *tg, void *data)
 
 static void update_shares(struct sched_domain *sd)
 {
-        u64 now = cpu_clock(raw_smp_processor_id());
-        s64 elapsed = now - sd->last_update;
+        s64 elapsed;
+        u64 now;
+
+        if (root_task_group_empty())
+                return;
+
+        now = cpu_clock(raw_smp_processor_id());
+        elapsed = now - sd->last_update;
 
         if (elapsed >= (s64)(u64)sysctl_sched_shares_ratelimit) {
                 sd->last_update = now;
@@ -1627,6 +1665,9 @@ static void update_shares(struct sched_domain *sd)
 
 static void update_shares_locked(struct rq *rq, struct sched_domain *sd)
 {
+        if (root_task_group_empty())
+                return;
+
         spin_unlock(&rq->lock);
         update_shares(sd);
         spin_lock(&rq->lock);
@@ -1634,6 +1675,9 @@ static void update_shares_locked(struct rq *rq, struct sched_domain *sd)
 
 static void update_h_load(long cpu)
 {
+        if (root_task_group_empty())
+                return;
+
         walk_tg_tree(tg_load_down, tg_nop, (void *)cpu);
 }
 
@@ -2268,8 +2312,7 @@ find_idlest_group(struct sched_domain *sd, struct task_struct *p, int this_cpu)
                 }
 
                 /* Adjust by relative CPU power of the group */
-                avg_load = sg_div_cpu_power(group,
-                                avg_load * SCHED_LOAD_SCALE);
+                avg_load = (avg_load * SCHED_LOAD_SCALE) / group->cpu_power;
 
                 if (local_group) {
                         this_load = avg_load;
@@ -2637,9 +2680,32 @@ void sched_fork(struct task_struct *p, int clone_flags)
         set_task_cpu(p, cpu);
 
         /*
-         * Make sure we do not leak PI boosting priority to the child:
+         * Make sure we do not leak PI boosting priority to the child.
          */
         p->prio = current->normal_prio;
+
+        /*
+         * Revert to default priority/policy on fork if requested.
+         */
+        if (unlikely(p->sched_reset_on_fork)) {
+                if (p->policy == SCHED_FIFO || p->policy == SCHED_RR)
+                        p->policy = SCHED_NORMAL;
+
+                if (p->normal_prio < DEFAULT_PRIO)
+                        p->prio = DEFAULT_PRIO;
+
+                if (PRIO_TO_NICE(p->static_prio) < 0) {
+                        p->static_prio = NICE_TO_PRIO(0);
+                        set_load_weight(p);
+                }
+
+                /*
+                 * We don't need the reset flag anymore after the fork. It has
+                 * fulfilled its duty:
+                 */
+                p->sched_reset_on_fork = 0;
+        }
+
         if (!rt_prio(p->prio))
                 p->sched_class = &fair_sched_class;
 
@@ -2796,12 +2862,6 @@ static void finish_task_switch(struct rq *rq, struct task_struct *prev)
 {
         struct mm_struct *mm = rq->prev_mm;
         long prev_state;
-#ifdef CONFIG_SMP
-        int post_schedule = 0;
-
-        if (current->sched_class->needs_post_schedule)
-                post_schedule = current->sched_class->needs_post_schedule(rq);
-#endif
 
         rq->prev_mm = NULL;
 
@@ -2820,10 +2880,6 @@ static void finish_task_switch(struct rq *rq, struct task_struct *prev)
         finish_arch_switch(prev);
         perf_counter_task_sched_in(current, cpu_of(rq));
         finish_lock_switch(rq, prev);
-#ifdef CONFIG_SMP
-        if (post_schedule)
-                current->sched_class->post_schedule(rq);
-#endif
 
         fire_sched_in_preempt_notifiers(current);
         if (mm)
@@ -2838,6 +2894,42 @@ static void finish_task_switch(struct rq *rq, struct task_struct *prev)
         }
 }
 
+#ifdef CONFIG_SMP
+
+/* assumes rq->lock is held */
+static inline void pre_schedule(struct rq *rq, struct task_struct *prev)
+{
+        if (prev->sched_class->pre_schedule)
+                prev->sched_class->pre_schedule(rq, prev);
+}
+
+/* rq->lock is NOT held, but preemption is disabled */
+static inline void post_schedule(struct rq *rq)
+{
+        if (rq->post_schedule) {
+                unsigned long flags;
+
+                spin_lock_irqsave(&rq->lock, flags);
+                if (rq->curr->sched_class->post_schedule)
+                        rq->curr->sched_class->post_schedule(rq);
+                spin_unlock_irqrestore(&rq->lock, flags);
+
+                rq->post_schedule = 0;
+        }
+}
+
+#else
+
+static inline void pre_schedule(struct rq *rq, struct task_struct *p)
+{
+}
+
+static inline void post_schedule(struct rq *rq)
+{
+}
+
+#endif
+
 /**
  * schedule_tail - first thing a freshly forked thread must call.
  * @prev: the thread we just switched away from.
@@ -2848,6 +2940,13 @@ asmlinkage void schedule_tail(struct task_struct *prev)
         struct rq *rq = this_rq();
 
         finish_task_switch(rq, prev);
+
+        /*
+         * FIXME: do we need to worry about rq being invalidated by the
+         * task_switch?
+         */
+        post_schedule(rq);
+
 #ifdef __ARCH_WANT_UNLOCKED_CTXSW
         /* In this case, finish_task_switch does not reenable preemption */
         preempt_enable();
@@ -3379,9 +3478,10 @@ static int move_one_task(struct rq *this_rq, int this_cpu, struct rq *busiest,
 {
         const struct sched_class *class;
 
-        for (class = sched_class_highest; class; class = class->next)
+        for_each_class(class) {
                 if (class->move_one_task(this_rq, this_cpu, busiest, sd, idle))
                         return 1;
+        }
 
         return 0;
 }
@@ -3544,7 +3644,7 @@ static inline void update_sd_power_savings_stats(struct sched_group *group,
          * capacity but still has some space to pick up some load
          * from other group and save more power
          */
-        if (sgs->sum_nr_running > sgs->group_capacity - 1)
+        if (sgs->sum_nr_running + 1 > sgs->group_capacity)
                 return;
 
         if (sgs->sum_nr_running > sds->leader_nr_running ||
@@ -3611,6 +3711,77 @@ static inline int check_power_save_busiest_group(struct sd_lb_stats *sds,
 }
 #endif /* CONFIG_SCHED_MC || CONFIG_SCHED_SMT */
 
+unsigned long __weak arch_scale_smt_power(struct sched_domain *sd, int cpu)
+{
+        unsigned long weight = cpumask_weight(sched_domain_span(sd));
+        unsigned long smt_gain = sd->smt_gain;
+
+        smt_gain /= weight;
+
+        return smt_gain;
+}
+
+unsigned long scale_rt_power(int cpu)
+{
+        struct rq *rq = cpu_rq(cpu);
+        u64 total, available;
+
+        sched_avg_update(rq);
+
+        total = sched_avg_period() + (rq->clock - rq->age_stamp);
+        available = total - rq->rt_avg;
+
+        if (unlikely((s64)total < SCHED_LOAD_SCALE))
+                total = SCHED_LOAD_SCALE;
+
+        total >>= SCHED_LOAD_SHIFT;
+
+        return div_u64(available, total);
+}
+
+static void update_cpu_power(struct sched_domain *sd, int cpu)
+{
+        unsigned long weight = cpumask_weight(sched_domain_span(sd));
+        unsigned long power = SCHED_LOAD_SCALE;
+        struct sched_group *sdg = sd->groups;
+
+        /* here we could scale based on cpufreq */
+
+        if ((sd->flags & SD_SHARE_CPUPOWER) && weight > 1) {
+                power *= arch_scale_smt_power(sd, cpu);
+                power >>= SCHED_LOAD_SHIFT;
+        }
+
+        power *= scale_rt_power(cpu);
+        power >>= SCHED_LOAD_SHIFT;
+
+        if (!power)
+                power = 1;
+
+        sdg->cpu_power = power;
+}
+
+static void update_group_power(struct sched_domain *sd, int cpu)
+{
+        struct sched_domain *child = sd->child;
+        struct sched_group *group, *sdg = sd->groups;
+        unsigned long power;
+
+        if (!child) {
+                update_cpu_power(sd, cpu);
+                return;
+        }
+
+        power = 0;
+
+        group = child->groups;
+        do {
+                power += group->cpu_power;
+                group = group->next;
+        } while (group != child->groups);
+
+        sdg->cpu_power = power;
+}
 
 /**
  * update_sg_lb_stats - Update sched_group's statistics for load balancing.
@@ -3624,7 +3795,8 @@ static inline int check_power_save_busiest_group(struct sd_lb_stats *sds,
  * @balance: Should we balance.
  * @sgs: variable to hold the statistics for this group.
  */
-static inline void update_sg_lb_stats(struct sched_group *group, int this_cpu,
+static inline void update_sg_lb_stats(struct sched_domain *sd,
+                        struct sched_group *group, int this_cpu,
                         enum cpu_idle_type idle, int load_idx, int *sd_idle,
                         int local_group, const struct cpumask *cpus,
                         int *balance, struct sg_lb_stats *sgs)
@@ -3635,8 +3807,11 @@ static inline void update_sg_lb_stats(struct sched_group *group, int this_cpu,
         unsigned long sum_avg_load_per_task;
         unsigned long avg_load_per_task;
 
-        if (local_group)
+        if (local_group) {
                 balance_cpu = group_first_cpu(group);
+                if (balance_cpu == this_cpu)
+                        update_group_power(sd, this_cpu);
+        }
 
         /* Tally up the load of all CPUs in the group */
         sum_avg_load_per_task = avg_load_per_task = 0;
@@ -3685,8 +3860,7 @@ static inline void update_sg_lb_stats(struct sched_group *group, int this_cpu,
         }
 
         /* Adjust by relative CPU power of the group */
-        sgs->avg_load = sg_div_cpu_power(group,
-                        sgs->group_load * SCHED_LOAD_SCALE);
+        sgs->avg_load = (sgs->group_load * SCHED_LOAD_SCALE) / group->cpu_power;
 
 
         /*
@@ -3698,14 +3872,14 @@ static inline void update_sg_lb_stats(struct sched_group *group, int this_cpu,
          *      normalized nr_running number somewhere that negates
          *      the hierarchy?
          */
-        avg_load_per_task = sg_div_cpu_power(group,
-                        sum_avg_load_per_task * SCHED_LOAD_SCALE);
+        avg_load_per_task = (sum_avg_load_per_task * SCHED_LOAD_SCALE) /
+                group->cpu_power;
 
         if ((max_cpu_load - min_cpu_load) > 2*avg_load_per_task)
                 sgs->group_imb = 1;
 
-        sgs->group_capacity = group->__cpu_power / SCHED_LOAD_SCALE;
-
+        sgs->group_capacity =
+                DIV_ROUND_CLOSEST(group->cpu_power, SCHED_LOAD_SCALE);
 }
 
 /**
@@ -3723,9 +3897,13 @@ static inline void update_sd_lb_stats(struct sched_domain *sd, int this_cpu,
                         const struct cpumask *cpus, int *balance,
                         struct sd_lb_stats *sds)
 {
+        struct sched_domain *child = sd->child;
         struct sched_group *group = sd->groups;
         struct sg_lb_stats sgs;
-        int load_idx;
+        int load_idx, prefer_sibling = 0;
+
+        if (child && child->flags & SD_PREFER_SIBLING)
+                prefer_sibling = 1;
 
         init_sd_power_savings_stats(sd, sds, idle);
         load_idx = get_sd_load_idx(sd, idle);
@@ -3736,14 +3914,22 @@ static inline void update_sd_lb_stats(struct sched_domain *sd, int this_cpu,
                 local_group = cpumask_test_cpu(this_cpu,
                                                sched_group_cpus(group));
                 memset(&sgs, 0, sizeof(sgs));
-                update_sg_lb_stats(group, this_cpu, idle, load_idx, sd_idle,
+                update_sg_lb_stats(sd, group, this_cpu, idle, load_idx, sd_idle,
                                 local_group, cpus, balance, &sgs);
 
                 if (local_group && balance && !(*balance))
                         return;
 
                 sds->total_load += sgs.group_load;
-                sds->total_pwr += group->__cpu_power;
+                sds->total_pwr += group->cpu_power;
+
+                /*
+                 * In case the child domain prefers tasks go to siblings
+                 * first, lower the group capacity to one so that we'll try
+                 * and move all the excess tasks away.
+                 */
+                if (prefer_sibling)
+                        sgs.group_capacity = min(sgs.group_capacity, 1UL);
 
                 if (local_group) {
                         sds->this_load = sgs.avg_load;
@@ -3763,7 +3949,6 @@ static inline void update_sd_lb_stats(struct sched_domain *sd, int this_cpu,
                 update_sd_power_savings_stats(group, sds, local_group, &sgs);
                 group = group->next;
         } while (group != sd->groups);
-
 }
 
 /**
@@ -3801,28 +3986,28 @@ static inline void fix_small_imbalance(struct sd_lb_stats *sds,
          * moving them.
          */
 
-        pwr_now += sds->busiest->__cpu_power *
+        pwr_now += sds->busiest->cpu_power *
                         min(sds->busiest_load_per_task, sds->max_load);
-        pwr_now += sds->this->__cpu_power *
+        pwr_now += sds->this->cpu_power *
                         min(sds->this_load_per_task, sds->this_load);
         pwr_now /= SCHED_LOAD_SCALE;
 
         /* Amount of load we'd subtract */
-        tmp = sg_div_cpu_power(sds->busiest,
-                        sds->busiest_load_per_task * SCHED_LOAD_SCALE);
+        tmp = (sds->busiest_load_per_task * SCHED_LOAD_SCALE) /
+                sds->busiest->cpu_power;
         if (sds->max_load > tmp)
-                pwr_move += sds->busiest->__cpu_power *
+                pwr_move += sds->busiest->cpu_power *
                         min(sds->busiest_load_per_task, sds->max_load - tmp);
 
         /* Amount of load we'd add */
-        if (sds->max_load * sds->busiest->__cpu_power <
+        if (sds->max_load * sds->busiest->cpu_power <
                 sds->busiest_load_per_task * SCHED_LOAD_SCALE)
-                tmp = sg_div_cpu_power(sds->this,
-                        sds->max_load * sds->busiest->__cpu_power);
+                tmp = (sds->max_load * sds->busiest->cpu_power) /
+                        sds->this->cpu_power;
         else
-                tmp = sg_div_cpu_power(sds->this,
-                        sds->busiest_load_per_task * SCHED_LOAD_SCALE);
-        pwr_move += sds->this->__cpu_power *
+                tmp = (sds->busiest_load_per_task * SCHED_LOAD_SCALE) /
+                        sds->this->cpu_power;
+        pwr_move += sds->this->cpu_power *
                         min(sds->this_load_per_task, sds->this_load + tmp);
         pwr_move /= SCHED_LOAD_SCALE;
 
@@ -3857,8 +4042,8 @@ static inline void calculate_imbalance(struct sd_lb_stats *sds, int this_cpu,
                         sds->max_load - sds->busiest_load_per_task);
 
         /* How much load to actually move to equalise the imbalance */
-        *imbalance = min(max_pull * sds->busiest->__cpu_power,
-                (sds->avg_load - sds->this_load) * sds->this->__cpu_power)
+        *imbalance = min(max_pull * sds->busiest->cpu_power,
+                (sds->avg_load - sds->this_load) * sds->this->cpu_power)
                         / SCHED_LOAD_SCALE;
 
         /*
@@ -3976,6 +4161,26 @@ ret:
         return NULL;
 }
 
+static struct sched_group *group_of(int cpu)
+{
+        struct sched_domain *sd = rcu_dereference(cpu_rq(cpu)->sd);
+
+        if (!sd)
+                return NULL;
+
+        return sd->groups;
+}
+
+static unsigned long power_of(int cpu)
+{
+        struct sched_group *group = group_of(cpu);
+
+        if (!group)
+                return SCHED_LOAD_SCALE;
+
+        return group->cpu_power;
+}
+
 /*
  * find_busiest_queue - find the busiest runqueue among the cpus in group.
  */
@@ -3988,15 +4193,18 @@ find_busiest_queue(struct sched_group *group, enum cpu_idle_type idle,
         int i;
 
         for_each_cpu(i, sched_group_cpus(group)) {
+                unsigned long power = power_of(i);
+                unsigned long capacity = DIV_ROUND_CLOSEST(power, SCHED_LOAD_SCALE);
                 unsigned long wl;
 
                 if (!cpumask_test_cpu(i, cpus))
                         continue;
 
                 rq = cpu_rq(i);
-                wl = weighted_cpuload(i);
+                wl = weighted_cpuload(i) * SCHED_LOAD_SCALE;
+                wl /= power;
 
-                if (rq->nr_running == 1 && wl > imbalance)
+                if (capacity && rq->nr_running == 1 && wl > imbalance)
                         continue;
 
                 if (wl > max_load) {
@@ -5325,7 +5533,7 @@ need_resched:
         preempt_disable();
         cpu = smp_processor_id();
         rq = cpu_rq(cpu);
-        rcu_qsctr_inc(cpu);
+        rcu_sched_qs(cpu);
         prev = rq->curr;
         switch_count = &prev->nivcsw;
 
@@ -5349,10 +5557,7 @@ need_resched_nonpreemptible:
                 switch_count = &prev->nvcsw;
         }
 
-#ifdef CONFIG_SMP
-        if (prev->sched_class->pre_schedule)
-                prev->sched_class->pre_schedule(rq, prev);
-#endif
+        pre_schedule(rq, prev);
 
         if (unlikely(!rq->nr_running))
                 idle_balance(cpu, rq);
@@ -5378,6 +5583,8 @@ need_resched_nonpreemptible:
         } else
                 spin_unlock_irq(&rq->lock);
 
+        post_schedule(rq);
+
         if (unlikely(reacquire_kernel_lock(current) < 0))
                 goto need_resched_nonpreemptible;
 
@@ -6123,17 +6330,25 @@ static int __sched_setscheduler(struct task_struct *p, int policy,
         unsigned long flags;
         const struct sched_class *prev_class = p->sched_class;
         struct rq *rq;
+        int reset_on_fork;
 
         /* may grab non-irq protected spin_locks */
         BUG_ON(in_interrupt());
 recheck:
         /* double check policy once rq lock held */
-        if (policy < 0)
+        if (policy < 0) {
+                reset_on_fork = p->sched_reset_on_fork;
                 policy = oldpolicy = p->policy;
-        else if (policy != SCHED_FIFO && policy != SCHED_RR &&
-                        policy != SCHED_NORMAL && policy != SCHED_BATCH &&
-                        policy != SCHED_IDLE)
-                return -EINVAL;
+        } else {
+                reset_on_fork = !!(policy & SCHED_RESET_ON_FORK);
+                policy &= ~SCHED_RESET_ON_FORK;
+
+                if (policy != SCHED_FIFO && policy != SCHED_RR &&
+                                policy != SCHED_NORMAL && policy != SCHED_BATCH &&
+                                policy != SCHED_IDLE)
+                        return -EINVAL;
+        }
+
         /*
          * Valid priorities for SCHED_FIFO and SCHED_RR are
          * 1..MAX_USER_RT_PRIO-1, valid priority for SCHED_NORMAL,
@@ -6177,6 +6392,10 @@ recheck:
                 /* can't change other user's priorities */
                 if (!check_same_owner(p))
                         return -EPERM;
+
+                /* Normal users shall not reset the sched_reset_on_fork flag */
+                if (p->sched_reset_on_fork && !reset_on_fork)
+                        return -EPERM;
         }
 
         if (user) {
@@ -6220,6 +6439,8 @@ recheck:
         if (running)
                 p->sched_class->put_prev_task(rq, p);
 
+        p->sched_reset_on_fork = reset_on_fork;
+
         oldprio = p->prio;
         __setscheduler(rq, p, policy, param->sched_priority);
 
@@ -6336,14 +6557,15 @@ SYSCALL_DEFINE1(sched_getscheduler, pid_t, pid)
         if (p) {
                 retval = security_task_getscheduler(p);
                 if (!retval)
-                        retval = p->policy;
+                        retval = p->policy
+                                | (p->sched_reset_on_fork ? SCHED_RESET_ON_FORK : 0);
         }
         read_unlock(&tasklist_lock);
         return retval;
 }
 
 /**
- * sys_sched_getscheduler - get the RT priority of a thread
+ * sys_sched_getparam - get the RT priority of a thread
  * @pid: the pid in question.
  * @param: structure containing the RT priority.
  */
@@ -6571,19 +6793,9 @@ static inline int should_resched(void)
 
 static void __cond_resched(void)
 {
-#ifdef CONFIG_DEBUG_SPINLOCK_SLEEP
-        __might_sleep(__FILE__, __LINE__);
-#endif
-        /*
-         * The BKS might be reacquired before we have dropped
-         * PREEMPT_ACTIVE, which could trigger a second
-         * cond_resched() call.
-         */
-        do {
-                add_preempt_count(PREEMPT_ACTIVE);
-                schedule();
-                sub_preempt_count(PREEMPT_ACTIVE);
-        } while (need_resched());
+        add_preempt_count(PREEMPT_ACTIVE);
+        schedule();
+        sub_preempt_count(PREEMPT_ACTIVE);
 }
 
 int __sched _cond_resched(void)
@@ -6597,18 +6809,20 @@ int __sched _cond_resched(void)
 EXPORT_SYMBOL(_cond_resched);
 
 /*
- * cond_resched_lock() - if a reschedule is pending, drop the given lock,
+ * __cond_resched_lock() - if a reschedule is pending, drop the given lock,
  * call schedule, and on return reacquire the lock.
  *
  * This works OK both with and without CONFIG_PREEMPT. We do strange low-level
  * operations here to prevent schedule() from being called twice (once via
  * spin_unlock(), once by hand).
  */
-int cond_resched_lock(spinlock_t *lock)
+int __cond_resched_lock(spinlock_t *lock)
 {
         int resched = should_resched();
         int ret = 0;
 
+        lockdep_assert_held(lock);
+
         if (spin_needbreak(lock) || resched) {
                 spin_unlock(lock);
                 if (resched)
@@ -6620,9 +6834,9 @@ int cond_resched_lock(spinlock_t *lock)
         }
         return ret;
 }
-EXPORT_SYMBOL(cond_resched_lock);
+EXPORT_SYMBOL(__cond_resched_lock);
 
-int __sched cond_resched_softirq(void)
+int __sched __cond_resched_softirq(void)
 {
         BUG_ON(!in_softirq());
 
@@ -6634,7 +6848,7 @@ int __sched cond_resched_softirq(void)
         }
         return 0;
 }
-EXPORT_SYMBOL(cond_resched_softirq);
+EXPORT_SYMBOL(__cond_resched_softirq);
 
 /**
  * yield - yield the current processor to other threads.
@@ -6658,11 +6872,13 @@ EXPORT_SYMBOL(yield);
  */
 void __sched io_schedule(void)
 {
-        struct rq *rq = &__raw_get_cpu_var(runqueues);
+        struct rq *rq = raw_rq();
 
         delayacct_blkio_start();
         atomic_inc(&rq->nr_iowait);
+        current->in_iowait = 1;
         schedule();
+        current->in_iowait = 0;
         atomic_dec(&rq->nr_iowait);
         delayacct_blkio_end();
 }
@@ -6670,12 +6886,14 @@ EXPORT_SYMBOL(io_schedule);
 
 long __sched io_schedule_timeout(long timeout)
 {
-        struct rq *rq = &__raw_get_cpu_var(runqueues);
+        struct rq *rq = raw_rq();
         long ret;
 
         delayacct_blkio_start();
         atomic_inc(&rq->nr_iowait);
+        current->in_iowait = 1;
         ret = schedule_timeout(timeout);
+        current->in_iowait = 0;
         atomic_dec(&rq->nr_iowait);
         delayacct_blkio_end();
         return ret;
@@ -6992,8 +7210,12 @@ int set_cpus_allowed_ptr(struct task_struct *p, const struct cpumask *new_mask)
 
         if (migrate_task(p, cpumask_any_and(cpu_online_mask, new_mask), &req)) {
                 /* Need help from migration thread: drop lock and wait. */
+                struct task_struct *mt = rq->migration_thread;
+
+                get_task_struct(mt);
                 task_rq_unlock(rq, &flags);
                 wake_up_process(rq->migration_thread);
+                put_task_struct(mt);
                 wait_for_completion(&req.done);
                 tlb_migrate_finish(p->mm);
                 return 0;
@@ -7051,6 +7273,11 @@ fail:
         return ret;
 }
 
+#define RCU_MIGRATION_IDLE      0
+#define RCU_MIGRATION_NEED_QS   1
+#define RCU_MIGRATION_GOT_QS    2
+#define RCU_MIGRATION_MUST_SYNC 3
+
 /*
  * migration_thread - this is a highprio system thread that performs
  * thread migration by bumping thread off CPU then 'pushing' onto
@@ -7058,6 +7285,7 @@ fail:
  */
 static int migration_thread(void *data)
 {
+        int badcpu;
         int cpu = (long)data;
         struct rq *rq;
 
@@ -7092,8 +7320,17 @@ static int migration_thread(void *data)
                 req = list_entry(head->next, struct migration_req, list);
                 list_del_init(head->next);
 
-                spin_unlock(&rq->lock);
-                __migrate_task(req->task, cpu, req->dest_cpu);
+                if (req->task != NULL) {
+                        spin_unlock(&rq->lock);
+                        __migrate_task(req->task, cpu, req->dest_cpu);
+                } else if (likely(cpu == (badcpu = smp_processor_id()))) {
+                        req->dest_cpu = RCU_MIGRATION_GOT_QS;
+                        spin_unlock(&rq->lock);
+                } else {
+                        req->dest_cpu = RCU_MIGRATION_MUST_SYNC;
+                        spin_unlock(&rq->lock);
+                        WARN_ONCE(1, "migration_thread() on CPU %d, expected %d\n", badcpu, cpu);
+                }
                 local_irq_enable();
 
                 complete(&req->done);
@@ -7625,7 +7862,7 @@ static int __init migration_init(void)
         migration_call(&migration_notifier, CPU_ONLINE, cpu);
         register_cpu_notifier(&migration_notifier);
 
-        return err;
+        return 0;
 }
 early_initcall(migration_init);
 #endif
@@ -7672,7 +7909,7 @@ static int sched_domain_debug_one(struct sched_domain *sd, int cpu, int level,
                         break;
                 }
 
-                if (!group->__cpu_power) {
+                if (!group->cpu_power) {
                         printk(KERN_CONT "\n");
                         printk(KERN_ERR "ERROR: domain->cpu_power not "
                                         "set\n");
@@ -7696,9 +7933,9 @@ static int sched_domain_debug_one(struct sched_domain *sd, int cpu, int level,
                 cpulist_scnprintf(str, sizeof(str), sched_group_cpus(group));
 
                 printk(KERN_CONT " %s", str);
-                if (group->__cpu_power != SCHED_LOAD_SCALE) {
-                        printk(KERN_CONT " (__cpu_power = %d)",
-                                group->__cpu_power);
+                if (group->cpu_power != SCHED_LOAD_SCALE) {
+                        printk(KERN_CONT " (cpu_power = %d)",
+                                group->cpu_power);
                 }
 
                 group = group->next;
@@ -7841,7 +8078,7 @@ static void rq_attach_root(struct rq *rq, struct root_domain *rd)
         rq->rd = rd;
 
         cpumask_set_cpu(rq->cpu, rd->span);
-        if (cpumask_test_cpu(rq->cpu, cpu_online_mask))
+        if (cpumask_test_cpu(rq->cpu, cpu_active_mask))
                 set_rq_online(rq);
 
         spin_unlock_irqrestore(&rq->lock, flags);
@@ -7983,7 +8220,7 @@ init_sched_build_groups(const struct cpumask *span,
                         continue;
 
                 cpumask_clear(sched_group_cpus(sg));
-                sg->__cpu_power = 0;
+                sg->cpu_power = 0;
 
                 for_each_cpu(j, span) {
                         if (group_fn(j, cpu_map, NULL, tmpmask) != group)
@@ -8091,6 +8328,39 @@ struct static_sched_domain {
         DECLARE_BITMAP(span, CONFIG_NR_CPUS);
 };
 
+struct s_data {
+#ifdef CONFIG_NUMA
+        int                     sd_allnodes;
+        cpumask_var_t           domainspan;
+        cpumask_var_t           covered;
+        cpumask_var_t           notcovered;
+#endif
+        cpumask_var_t           nodemask;
+        cpumask_var_t           this_sibling_map;
+        cpumask_var_t           this_core_map;
+        cpumask_var_t           send_covered;
+        cpumask_var_t           tmpmask;
+        struct sched_group      **sched_group_nodes;
+        struct root_domain      *rd;
+};
+
+enum s_alloc {
+        sa_sched_groups = 0,
+        sa_rootdomain,
+        sa_tmpmask,
+        sa_send_covered,
+        sa_this_core_map,
+        sa_this_sibling_map,
+        sa_nodemask,
+        sa_sched_group_nodes,
+#ifdef CONFIG_NUMA
+        sa_notcovered,
+        sa_covered,
+        sa_domainspan,
+#endif
+        sa_none,
+};
+
 /*
  * SMT sched-domains:
  */
@@ -8208,11 +8478,76 @@ static void init_numa_sched_groups_power(struct sched_group *group_head)
                                 continue;
                         }
 
-                        sg_inc_cpu_power(sg, sd->groups->__cpu_power);
+                        sg->cpu_power += sd->groups->cpu_power;
                 }
                 sg = sg->next;
         } while (sg != group_head);
 }
+
+static int build_numa_sched_groups(struct s_data *d,
+                                   const struct cpumask *cpu_map, int num)
+{
+        struct sched_domain *sd;
+        struct sched_group *sg, *prev;
+        int n, j;
+
+        cpumask_clear(d->covered);
+        cpumask_and(d->nodemask, cpumask_of_node(num), cpu_map);
+        if (cpumask_empty(d->nodemask)) {
+                d->sched_group_nodes[num] = NULL;
+                goto out;
+        }
+
+        sched_domain_node_span(num, d->domainspan);
+        cpumask_and(d->domainspan, d->domainspan, cpu_map);
+
+        sg = kmalloc_node(sizeof(struct sched_group) + cpumask_size(),
+                          GFP_KERNEL, num);
+        if (!sg) {
+                printk(KERN_WARNING "Can not alloc domain group for node %d\n",
+                       num);
+                return -ENOMEM;
+        }
+        d->sched_group_nodes[num] = sg;
+
+        for_each_cpu(j, d->nodemask) {
+                sd = &per_cpu(node_domains, j).sd;
+                sd->groups = sg;
+        }
+
+        sg->cpu_power = 0;
+        cpumask_copy(sched_group_cpus(sg), d->nodemask);
+        sg->next = sg;
+        cpumask_or(d->covered, d->covered, d->nodemask);
+
+        prev = sg;
+        for (j = 0; j < nr_node_ids; j++) {
+                n = (num + j) % nr_node_ids;
+                cpumask_complement(d->notcovered, d->covered);
+                cpumask_and(d->tmpmask, d->notcovered, cpu_map);
+                cpumask_and(d->tmpmask, d->tmpmask, d->domainspan);
+                if (cpumask_empty(d->tmpmask))
+                        break;
+                cpumask_and(d->tmpmask, d->tmpmask, cpumask_of_node(n));
+                if (cpumask_empty(d->tmpmask))
+                        continue;
+                sg = kmalloc_node(sizeof(struct sched_group) + cpumask_size(),
+                                  GFP_KERNEL, num);
+                if (!sg) {
+                        printk(KERN_WARNING
+                               "Can not alloc domain group for node %d\n", j);
+                        return -ENOMEM;
+                }
+                sg->cpu_power = 0;
+                cpumask_copy(sched_group_cpus(sg), d->tmpmask);
+                sg->next = prev->next;
+                cpumask_or(d->covered, d->covered, d->tmpmask);
+                prev->next = sg;
+                prev = sg;
+        }
+out:
+        return 0;
+}
 #endif /* CONFIG_NUMA */
 
 #ifdef CONFIG_NUMA
@@ -8266,15 +8601,13 @@ static void free_sched_groups(const struct cpumask *cpu_map,
  * there are asymmetries in the topology. If there are asymmetries, group
  * having more cpu_power will pickup more load compared to the group having
  * less cpu_power.
- *
- * cpu_power will be a multiple of SCHED_LOAD_SCALE. This multiple represents
- * the maximum number of tasks a group can handle in the presence of other idle
- * or lightly loaded groups in the same sched domain.
  */
 static void init_sched_groups_power(int cpu, struct sched_domain *sd)
 {
         struct sched_domain *child;
         struct sched_group *group;
+        long power;
+        int weight;
 
         WARN_ON(!sd || !sd->groups);
 
@@ -8283,28 +8616,32 @@ static void init_sched_groups_power(int cpu, struct sched_domain *sd)
 
         child = sd->child;
 
-        sd->groups->__cpu_power = 0;
+        sd->groups->cpu_power = 0;
 
-        /*
-         * For perf policy, if the groups in child domain share resources
-         * (for example cores sharing some portions of the cache hierarchy
-         * or SMT), then set this domain groups cpu_power such that each group
-         * can handle only one task, when there are other idle groups in the
-         * same sched domain.
-         */
-        if (!child || (!(sd->flags & SD_POWERSAVINGS_BALANCE) &&
-                       (child->flags &
-                        (SD_SHARE_CPUPOWER | SD_SHARE_PKG_RESOURCES)))) {
-                sg_inc_cpu_power(sd->groups, SCHED_LOAD_SCALE);
+        if (!child) {
+                power = SCHED_LOAD_SCALE;
+                weight = cpumask_weight(sched_domain_span(sd));
+                /*
+                 * SMT siblings share the power of a single core.
+                 * Usually multiple threads get a better yield out of
+                 * that one core than a single thread would have,
+                 * reflect that in sd->smt_gain.
+                 */
+                if ((sd->flags & SD_SHARE_CPUPOWER) && weight > 1) {
+                        power *= sd->smt_gain;
+                        power /= weight;
+                        power >>= SCHED_LOAD_SHIFT;
+                }
+                sd->groups->cpu_power += power;
                 return;
         }
 
         /*
-         * add cpu_power of each child group to this groups cpu_power
+         * Add cpu_power of each child group to this groups cpu_power.
          */
         group = child->groups;
         do {
-                sg_inc_cpu_power(sd->groups, group->__cpu_power);
+                sd->groups->cpu_power += group->cpu_power;
                 group = group->next;
         } while (group != child->groups);
 }
@@ -8378,280 +8715,285 @@ static void set_domain_attribute(struct sched_domain *sd,
         }
 }
 
-/*
- * Build sched domains for a given set of cpus and attach the sched domains
- * to the individual cpus
- */
-static int __build_sched_domains(const struct cpumask *cpu_map,
-                                 struct sched_domain_attr *attr)
-{
-        int i, err = -ENOMEM;
-        struct root_domain *rd;
-        cpumask_var_t nodemask, this_sibling_map, this_core_map, send_covered,
-                tmpmask;
+static void __free_domain_allocs(struct s_data *d, enum s_alloc what,
+                                 const struct cpumask *cpu_map)
+{
+        switch (what) {
+        case sa_sched_groups:
+                free_sched_groups(cpu_map, d->tmpmask); /* fall through */
+                d->sched_group_nodes = NULL;
+        case sa_rootdomain:
+                free_rootdomain(d->rd); /* fall through */
+        case sa_tmpmask:
+                free_cpumask_var(d->tmpmask); /* fall through */
+        case sa_send_covered:
+                free_cpumask_var(d->send_covered); /* fall through */
+        case sa_this_core_map:
+                free_cpumask_var(d->this_core_map); /* fall through */
+        case sa_this_sibling_map:
+                free_cpumask_var(d->this_sibling_map); /* fall through */
+        case sa_nodemask:
+                free_cpumask_var(d->nodemask); /* fall through */
+        case sa_sched_group_nodes:
 #ifdef CONFIG_NUMA
-        cpumask_var_t domainspan, covered, notcovered;
-        struct sched_group **sched_group_nodes = NULL;
-        int sd_allnodes = 0;
-
-        if (!alloc_cpumask_var(&domainspan, GFP_KERNEL))
-                goto out;
-        if (!alloc_cpumask_var(&covered, GFP_KERNEL))
-                goto free_domainspan;
-        if (!alloc_cpumask_var(&notcovered, GFP_KERNEL))
-                goto free_covered;
-#endif
-
-        if (!alloc_cpumask_var(&nodemask, GFP_KERNEL))
-                goto free_notcovered;
-        if (!alloc_cpumask_var(&this_sibling_map, GFP_KERNEL))
-                goto free_nodemask;
-        if (!alloc_cpumask_var(&this_core_map, GFP_KERNEL))
-                goto free_this_sibling_map;
-        if (!alloc_cpumask_var(&send_covered, GFP_KERNEL))
-                goto free_this_core_map;
-        if (!alloc_cpumask_var(&tmpmask, GFP_KERNEL))
-                goto free_send_covered;
+                kfree(d->sched_group_nodes); /* fall through */
+        case sa_notcovered:
+                free_cpumask_var(d->notcovered); /* fall through */
+        case sa_covered:
+                free_cpumask_var(d->covered); /* fall through */
+        case sa_domainspan:
+                free_cpumask_var(d->domainspan); /* fall through */
+#endif
+        case sa_none:
+                break;
+        }
+}
 
+static enum s_alloc __visit_domain_allocation_hell(struct s_data *d,
+                                                   const struct cpumask *cpu_map)
+{
 #ifdef CONFIG_NUMA
-        /*
-         * Allocate the per-node list of sched groups
-         */
-        sched_group_nodes = kcalloc(nr_node_ids, sizeof(struct sched_group *),
-                                    GFP_KERNEL);
-        if (!sched_group_nodes) {
+        if (!alloc_cpumask_var(&d->domainspan, GFP_KERNEL))
+                return sa_none;
+        if (!alloc_cpumask_var(&d->covered, GFP_KERNEL))
+                return sa_domainspan;
+        if (!alloc_cpumask_var(&d->notcovered, GFP_KERNEL))
+                return sa_covered;
+        /* Allocate the per-node list of sched groups */
+        d->sched_group_nodes = kcalloc(nr_node_ids,
+                                      sizeof(struct sched_group *), GFP_KERNEL);
+        if (!d->sched_group_nodes) {
                 printk(KERN_WARNING "Can not alloc sched group node list\n");
-                goto free_tmpmask;
-        }
-#endif
-
-        rd = alloc_rootdomain();
-        if (!rd) {
+                return sa_notcovered;
+        }
+        sched_group_nodes_bycpu[cpumask_first(cpu_map)] = d->sched_group_nodes;
+#endif
+        if (!alloc_cpumask_var(&d->nodemask, GFP_KERNEL))
+                return sa_sched_group_nodes;
+        if (!alloc_cpumask_var(&d->this_sibling_map, GFP_KERNEL))
+                return sa_nodemask;
+        if (!alloc_cpumask_var(&d->this_core_map, GFP_KERNEL))
+                return sa_this_sibling_map;
+        if (!alloc_cpumask_var(&d->send_covered, GFP_KERNEL))
+                return sa_this_core_map;
+        if (!alloc_cpumask_var(&d->tmpmask, GFP_KERNEL))
+                return sa_send_covered;
+        d->rd = alloc_rootdomain();
+        if (!d->rd) {
                 printk(KERN_WARNING "Cannot alloc root domain\n");
-                goto free_sched_groups;
+                return sa_tmpmask;
         }
+        return sa_rootdomain;
+}
 
+static struct sched_domain *__build_numa_sched_domains(struct s_data *d,
+        const struct cpumask *cpu_map, struct sched_domain_attr *attr, int i)
+{
+        struct sched_domain *sd = NULL;
 #ifdef CONFIG_NUMA
-        sched_group_nodes_bycpu[cpumask_first(cpu_map)] = sched_group_nodes;
-#endif
-
-        /*
-         * Set up domains for cpus specified by the cpu_map.
-         */
-        for_each_cpu(i, cpu_map) {
-                struct sched_domain *sd = NULL, *p;
-
-                cpumask_and(nodemask, cpumask_of_node(cpu_to_node(i)), cpu_map);
-
-#ifdef CONFIG_NUMA
-                if (cpumask_weight(cpu_map) >
-                                SD_NODES_PER_DOMAIN*cpumask_weight(nodemask)) {
-                        sd = &per_cpu(allnodes_domains, i).sd;
-                        SD_INIT(sd, ALLNODES);
-                        set_domain_attribute(sd, attr);
-                        cpumask_copy(sched_domain_span(sd), cpu_map);
-                        cpu_to_allnodes_group(i, cpu_map, &sd->groups, tmpmask);
-                        p = sd;
-                        sd_allnodes = 1;
-                } else
-                        p = NULL;
+        struct sched_domain *parent;
 
-                sd = &per_cpu(node_domains, i).sd;
-                SD_INIT(sd, NODE);
+        d->sd_allnodes = 0;
+        if (cpumask_weight(cpu_map) >
+            SD_NODES_PER_DOMAIN * cpumask_weight(d->nodemask)) {
+                sd = &per_cpu(allnodes_domains, i).sd;
+                SD_INIT(sd, ALLNODES);
                 set_domain_attribute(sd, attr);
-                sched_domain_node_span(cpu_to_node(i), sched_domain_span(sd));
-                sd->parent = p;
-                if (p)
-                        p->child = sd;
-                cpumask_and(sched_domain_span(sd),
-                            sched_domain_span(sd), cpu_map);
+                cpumask_copy(sched_domain_span(sd), cpu_map);
+                cpu_to_allnodes_group(i, cpu_map, &sd->groups, d->tmpmask);
+                d->sd_allnodes = 1;
+        }
+        parent = sd;
+
+        sd = &per_cpu(node_domains, i).sd;
+        SD_INIT(sd, NODE);
+        set_domain_attribute(sd, attr);
+        sched_domain_node_span(cpu_to_node(i), sched_domain_span(sd));
+        sd->parent = parent;
+        if (parent)
+                parent->child = sd;
+        cpumask_and(sched_domain_span(sd), sched_domain_span(sd), cpu_map);
 #endif
+        return sd;
+}
 
-                p = sd;
-                sd = &per_cpu(phys_domains, i).sd;
-                SD_INIT(sd, CPU);
-                set_domain_attribute(sd, attr);
-                cpumask_copy(sched_domain_span(sd), nodemask);
-                sd->parent = p;
-                if (p)
-                        p->child = sd;
-                cpu_to_phys_group(i, cpu_map, &sd->groups, tmpmask);
+static struct sched_domain *__build_cpu_sched_domain(struct s_data *d,
+        const struct cpumask *cpu_map, struct sched_domain_attr *attr,
+        struct sched_domain *parent, int i)
+{
+        struct sched_domain *sd;
+        sd = &per_cpu(phys_domains, i).sd;
+        SD_INIT(sd, CPU);
+        set_domain_attribute(sd, attr);
+        cpumask_copy(sched_domain_span(sd), d->nodemask);
+        sd->parent = parent;
+        if (parent)
+                parent->child = sd;
+        cpu_to_phys_group(i, cpu_map, &sd->groups, d->tmpmask);
+        return sd;
+}
 
+static struct sched_domain *__build_mc_sched_domain(struct s_data *d,
+        const struct cpumask *cpu_map, struct sched_domain_attr *attr,
+        struct sched_domain *parent, int i)
+{
+        struct sched_domain *sd = parent;
 #ifdef CONFIG_SCHED_MC
-                p = sd;
-                sd = &per_cpu(core_domains, i).sd;
-                SD_INIT(sd, MC);
-                set_domain_attribute(sd, attr);
-                cpumask_and(sched_domain_span(sd), cpu_map,
-                                                   cpu_coregroup_mask(i));
-                sd->parent = p;
-                p->child = sd;
-                cpu_to_core_group(i, cpu_map, &sd->groups, tmpmask);
+        sd = &per_cpu(core_domains, i).sd;
+        SD_INIT(sd, MC);
+        set_domain_attribute(sd, attr);
+        cpumask_and(sched_domain_span(sd), cpu_map, cpu_coregroup_mask(i));
+        sd->parent = parent;
+        parent->child = sd;
+        cpu_to_core_group(i, cpu_map, &sd->groups, d->tmpmask);
 #endif
+        return sd;
+}
 
+static struct sched_domain *__build_smt_sched_domain(struct s_data *d,
+        const struct cpumask *cpu_map, struct sched_domain_attr *attr,
+        struct sched_domain *parent, int i)
+{
+        struct sched_domain *sd = parent;
 #ifdef CONFIG_SCHED_SMT
-                p = sd;
-                sd = &per_cpu(cpu_domains, i).sd;
-                SD_INIT(sd, SIBLING);
-                set_domain_attribute(sd, attr);
-                cpumask_and(sched_domain_span(sd),
-                            topology_thread_cpumask(i), cpu_map);
-                sd->parent = p;
-                p->child = sd;
-                cpu_to_cpu_group(i, cpu_map, &sd->groups, tmpmask);
+        sd = &per_cpu(cpu_domains, i).sd;
+        SD_INIT(sd, SIBLING);
+        set_domain_attribute(sd, attr);
+        cpumask_and(sched_domain_span(sd), cpu_map, topology_thread_cpumask(i));
+        sd->parent = parent;
+        parent->child = sd;
+        cpu_to_cpu_group(i, cpu_map, &sd->groups, d->tmpmask);
 #endif
-        }
+        return sd;
+}
 
+static void build_sched_groups(struct s_data *d, enum sched_domain_level l,
+                               const struct cpumask *cpu_map, int cpu)
+{
+        switch (l) {
 #ifdef CONFIG_SCHED_SMT
-        /* Set up CPU (sibling) groups */
-        for_each_cpu(i, cpu_map) {
-                cpumask_and(this_sibling_map,
-                            topology_thread_cpumask(i), cpu_map);
-                if (i != cpumask_first(this_sibling_map))
-                        continue;
-
-                init_sched_build_groups(this_sibling_map, cpu_map,
-                                        &cpu_to_cpu_group,
-                                        send_covered, tmpmask);
-        }
+        case SD_LV_SIBLING: /* set up CPU (sibling) groups */
+                cpumask_and(d->this_sibling_map, cpu_map,
+                            topology_thread_cpumask(cpu));
+                if (cpu == cpumask_first(d->this_sibling_map))
+                        init_sched_build_groups(d->this_sibling_map, cpu_map,
+                                                &cpu_to_cpu_group,
+                                                d->send_covered, d->tmpmask);
+                break;
 #endif
-
 #ifdef CONFIG_SCHED_MC
-        /* Set up multi-core groups */
-        for_each_cpu(i, cpu_map) {
-                cpumask_and(this_core_map, cpu_coregroup_mask(i), cpu_map);
-                if (i != cpumask_first(this_core_map))
-                        continue;
-
-                init_sched_build_groups(this_core_map, cpu_map,
-                                        &cpu_to_core_group,
-                                        send_covered, tmpmask);
-        }
+        case SD_LV_MC: /* set up multi-core groups */
+                cpumask_and(d->this_core_map, cpu_map, cpu_coregroup_mask(cpu));
+                if (cpu == cpumask_first(d->this_core_map))
+                        init_sched_build_groups(d->this_core_map, cpu_map,
+                                                &cpu_to_core_group,
+                                                d->send_covered, d->tmpmask);
+                break;
 #endif
-
-        /* Set up physical groups */
-        for (i = 0; i < nr_node_ids; i++) {
-                cpumask_and(nodemask, cpumask_of_node(i), cpu_map);
-                if (cpumask_empty(nodemask))
-                        continue;
-
-                init_sched_build_groups(nodemask, cpu_map,
-                                        &cpu_to_phys_group,
-                                        send_covered, tmpmask);
-        }
-
+        case SD_LV_CPU: /* set up physical groups */
+                cpumask_and(d->nodemask, cpumask_of_node(cpu), cpu_map);
+                if (!cpumask_empty(d->nodemask))
+                        init_sched_build_groups(d->nodemask, cpu_map,
+                                                &cpu_to_phys_group,
+                                                d->send_covered, d->tmpmask);
+                break;
 #ifdef CONFIG_NUMA
-        /* Set up node groups */
-        if (sd_allnodes) {
-                init_sched_build_groups(cpu_map, cpu_map,
-                                        &cpu_to_allnodes_group,
-                                        send_covered, tmpmask);
+        case SD_LV_ALLNODES:
+                init_sched_build_groups(cpu_map, cpu_map, &cpu_to_allnodes_group,
+                                        d->send_covered, d->tmpmask);
+                break;
+#endif
+        default:
+                break;
         }
+}
 
-        for (i = 0; i < nr_node_ids; i++) {
-                /* Set up node groups */
-                struct sched_group *sg, *prev;
-                int j;
-
-                cpumask_clear(covered);
-                cpumask_and(nodemask, cpumask_of_node(i), cpu_map);
-                if (cpumask_empty(nodemask)) {
-                        sched_group_nodes[i] = NULL;
-                        continue;
-                }
+/*
+ * Build sched domains for a given set of cpus and attach the sched domains
+ * to the individual cpus
+ */
+static int __build_sched_domains(const struct cpumask *cpu_map,
+                                 struct sched_domain_attr *attr)
+{
+        enum s_alloc alloc_state = sa_none;
+        struct s_data d;
+        struct sched_domain *sd;
+        int i;
+#ifdef CONFIG_NUMA
+        d.sd_allnodes = 0;
+#endif
 
-                sched_domain_node_span(i, domainspan);
-                cpumask_and(domainspan, domainspan, cpu_map);
+        alloc_state = __visit_domain_allocation_hell(&d, cpu_map);
+        if (alloc_state != sa_rootdomain)
+                goto error;
+        alloc_state = sa_sched_groups;
 
-                sg = kmalloc_node(sizeof(struct sched_group) + cpumask_size(),
-                                  GFP_KERNEL, i);
-                if (!sg) {
-                        printk(KERN_WARNING "Can not alloc domain group for "
-                                "node %d\n", i);
-                        goto error;
-                }
-                sched_group_nodes[i] = sg;
-                for_each_cpu(j, nodemask) {
-                        struct sched_domain *sd;
+        /*
+         * Set up domains for cpus specified by the cpu_map.
+         */
+        for_each_cpu(i, cpu_map) {
+                cpumask_and(d.nodemask, cpumask_of_node(cpu_to_node(i)),
+                            cpu_map);
 
-                        sd = &per_cpu(node_domains, j).sd;
-                        sd->groups = sg;
-                }
-                sg->__cpu_power = 0;
-                cpumask_copy(sched_group_cpus(sg), nodemask);
-                sg->next = sg;
-                cpumask_or(covered, covered, nodemask);
-                prev = sg;
+                sd = __build_numa_sched_domains(&d, cpu_map, attr, i);
+                sd = __build_cpu_sched_domain(&d, cpu_map, attr, sd, i);
+                sd = __build_mc_sched_domain(&d, cpu_map, attr, sd, i);
+                sd = __build_smt_sched_domain(&d, cpu_map, attr, sd, i);
+        }
 
-                for (j = 0; j < nr_node_ids; j++) {
-                        int n = (i + j) % nr_node_ids;
+        for_each_cpu(i, cpu_map) {
+                build_sched_groups(&d, SD_LV_SIBLING, cpu_map, i);
+                build_sched_groups(&d, SD_LV_MC, cpu_map, i);
+        }
 
-                        cpumask_complement(notcovered, covered);
-                        cpumask_and(tmpmask, notcovered, cpu_map);
-                        cpumask_and(tmpmask, tmpmask, domainspan);
-                        if (cpumask_empty(tmpmask))
-                                break;
+        /* Set up physical groups */
+        for (i = 0; i < nr_node_ids; i++)
+                build_sched_groups(&d, SD_LV_CPU, cpu_map, i);
 
-                        cpumask_and(tmpmask, tmpmask, cpumask_of_node(n));
-                        if (cpumask_empty(tmpmask))
-                                continue;
+#ifdef CONFIG_NUMA
+        /* Set up node groups */
+        if (d.sd_allnodes)
+                build_sched_groups(&d, SD_LV_ALLNODES, cpu_map, 0);
 
-                        sg = kmalloc_node(sizeof(struct sched_group) +
-                                          cpumask_size(),
-                                          GFP_KERNEL, i);
-                        if (!sg) {
-                                printk(KERN_WARNING
-                                "Can not alloc domain group for node %d\n", j);
-                                goto error;
-                        }
-                        sg->__cpu_power = 0;
-                        cpumask_copy(sched_group_cpus(sg), tmpmask);
-                        sg->next = prev->next;
-                        cpumask_or(covered, covered, tmpmask);
-                        prev->next = sg;
-                        prev = sg;
-                }
-        }
+        for (i = 0; i < nr_node_ids; i++)
+                if (build_numa_sched_groups(&d, cpu_map, i))
+                        goto error;
 #endif
 
         /* Calculate CPU power for physical packages and nodes */
 #ifdef CONFIG_SCHED_SMT
         for_each_cpu(i, cpu_map) {
-                struct sched_domain *sd = &per_cpu(cpu_domains, i).sd;
-
+                sd = &per_cpu(cpu_domains, i).sd;
                 init_sched_groups_power(i, sd);
         }
 #endif
 #ifdef CONFIG_SCHED_MC
         for_each_cpu(i, cpu_map) {
-                struct sched_domain *sd = &per_cpu(core_domains, i).sd;
-
+                sd = &per_cpu(core_domains, i).sd;
                 init_sched_groups_power(i, sd);
         }
 #endif
 
         for_each_cpu(i, cpu_map) {
-                struct sched_domain *sd = &per_cpu(phys_domains, i).sd;
-
+                sd = &per_cpu(phys_domains, i).sd;
                 init_sched_groups_power(i, sd);
         }
 
 #ifdef CONFIG_NUMA
         for (i = 0; i < nr_node_ids; i++)
-                init_numa_sched_groups_power(sched_group_nodes[i]);
+                init_numa_sched_groups_power(d.sched_group_nodes[i]);
 
-        if (sd_allnodes) {
+        if (d.sd_allnodes) {
                 struct sched_group *sg;
 
                 cpu_to_allnodes_group(cpumask_first(cpu_map), cpu_map, &sg,
-                                                                tmpmask);
+                                                                d.tmpmask);
                 init_numa_sched_groups_power(sg);
         }
 #endif
 
         /* Attach the domains */
         for_each_cpu(i, cpu_map) {
-                struct sched_domain *sd;
 #ifdef CONFIG_SCHED_SMT
                 sd = &per_cpu(cpu_domains, i).sd;
 #elif defined(CONFIG_SCHED_MC)
@@ -8659,44 +9001,16 @@ static int __build_sched_domains(const struct cpumask *cpu_map,
 #else
                 sd = &per_cpu(phys_domains, i).sd;
 #endif
-                cpu_attach_domain(sd, rd, i);
+                cpu_attach_domain(sd, d.rd, i);
         }
 
-        err = 0;
-
-free_tmpmask:
-        free_cpumask_var(tmpmask);
-free_send_covered:
-        free_cpumask_var(send_covered);
-free_this_core_map:
-        free_cpumask_var(this_core_map);
-free_this_sibling_map:
-        free_cpumask_var(this_sibling_map);
-free_nodemask:
-        free_cpumask_var(nodemask);
-free_notcovered:
-#ifdef CONFIG_NUMA
-        free_cpumask_var(notcovered);
-free_covered:
-        free_cpumask_var(covered);
-free_domainspan:
-        free_cpumask_var(domainspan);
-out:
-#endif
-        return err;
-
-free_sched_groups:
-#ifdef CONFIG_NUMA
-        kfree(sched_group_nodes);
-#endif
-        goto free_tmpmask;
+        d.sched_group_nodes = NULL; /* don't free this we still need it */
+        __free_domain_allocs(&d, sa_tmpmask, cpu_map);
+        return 0;
 
-#ifdef CONFIG_NUMA
 error:
-        free_sched_groups(cpu_map, tmpmask);
-        free_rootdomain(rd);
-        goto free_tmpmask;
-#endif
+        __free_domain_allocs(&d, alloc_state, cpu_map);
+        return -ENOMEM;
 }
 
 static int build_sched_domains(const struct cpumask *cpu_map)
@@ -9304,11 +9618,11 @@ void __init sched_init(void)
                  * system cpu resource, based on the weight assigned to root
                  * user's cpu share (INIT_TASK_GROUP_LOAD). This is accomplished
                  * by letting tasks of init_task_group sit in a separate cfs_rq
-                 * (init_cfs_rq) and having one entity represent this group of
+                 * (init_tg_cfs_rq) and having one entity represent this group of
                  * tasks in rq->cfs (i.e init_task_group->se[] != NULL).
                  */
                 init_tg_cfs_entry(&init_task_group,
-                                &per_cpu(init_cfs_rq, i),
+                                &per_cpu(init_tg_cfs_rq, i),
                                 &per_cpu(init_sched_entity, i), i, 1,
                                 root_task_group.se[i]);
 
@@ -9334,6 +9648,7 @@ void __init sched_init(void)
 #ifdef CONFIG_SMP
                 rq->sd = NULL;
                 rq->rd = NULL;
+                rq->post_schedule = 0;
                 rq->active_balance = 0;
                 rq->next_balance = jiffies;
                 rq->push_cpu = 0;
@@ -9398,13 +9713,20 @@ void __init sched_init(void)
 }
 
 #ifdef CONFIG_DEBUG_SPINLOCK_SLEEP
-void __might_sleep(char *file, int line)
+static inline int preempt_count_equals(int preempt_offset)
+{
+        int nested = preempt_count() & ~PREEMPT_ACTIVE;
+
+        return (nested == PREEMPT_INATOMIC_BASE + preempt_offset);
+}
+
+void __might_sleep(char *file, int line, int preempt_offset)
 {
 #ifdef in_atomic
         static unsigned long prev_jiffy;        /* ratelimiting */
 
-        if ((!in_atomic() && !irqs_disabled()) ||
-                    system_state != SYSTEM_RUNNING || oops_in_progress)
+        if ((preempt_count_equals(preempt_offset) && !irqs_disabled()) ||
+            system_state != SYSTEM_RUNNING || oops_in_progress)
                 return;
         if (time_before(jiffies, prev_jiffy + HZ) && prev_jiffy)
                 return;
@@ -10581,3 +10903,113 @@ struct cgroup_subsys cpuacct_subsys = {
         .subsys_id = cpuacct_subsys_id,
 };
 #endif  /* CONFIG_CGROUP_CPUACCT */
+
+#ifndef CONFIG_SMP
+
+int rcu_expedited_torture_stats(char *page)
+{
+        return 0;
+}
+EXPORT_SYMBOL_GPL(rcu_expedited_torture_stats);
+
+void synchronize_sched_expedited(void)
+{
+}
+EXPORT_SYMBOL_GPL(synchronize_sched_expedited);
+
+#else /* #ifndef CONFIG_SMP */
+
+static DEFINE_PER_CPU(struct migration_req, rcu_migration_req);
+static DEFINE_MUTEX(rcu_sched_expedited_mutex);
+
+#define RCU_EXPEDITED_STATE_POST -2
+#define RCU_EXPEDITED_STATE_IDLE -1
+
+static int rcu_expedited_state = RCU_EXPEDITED_STATE_IDLE;
+
+int rcu_expedited_torture_stats(char *page)
+{
+        int cnt = 0;
+        int cpu;
+
+        cnt += sprintf(&page[cnt], "state: %d /", rcu_expedited_state);
+        for_each_online_cpu(cpu) {
+                 cnt += sprintf(&page[cnt], " %d:%d",
+                                cpu, per_cpu(rcu_migration_req, cpu).dest_cpu);
+        }
+        cnt += sprintf(&page[cnt], "\n");
+        return cnt;
+}
+EXPORT_SYMBOL_GPL(rcu_expedited_torture_stats);
+
+static long synchronize_sched_expedited_count;
+
+/*
+ * Wait for an rcu-sched grace period to elapse, but use "big hammer"
+ * approach to force grace period to end quickly.  This consumes
+ * significant time on all CPUs, and is thus not recommended for
+ * any sort of common-case code.
+ *
+ * Note that it is illegal to call this function while holding any
+ * lock that is acquired by a CPU-hotplug notifier.  Failing to
+ * observe this restriction will result in deadlock.
+ */
+void synchronize_sched_expedited(void)
+{
+        int cpu;
+        unsigned long flags;
+        bool need_full_sync = 0;
+        struct rq *rq;
+        struct migration_req *req;
+        long snap;
+        int trycount = 0;
+
+        smp_mb();  /* ensure prior mod happens before capturing snap. */
+        snap = ACCESS_ONCE(synchronize_sched_expedited_count) + 1;
+        get_online_cpus();
+        while (!mutex_trylock(&rcu_sched_expedited_mutex)) {
+                put_online_cpus();
+                if (trycount++ < 10)
+                        udelay(trycount * num_online_cpus());
+                else {
+                        synchronize_sched();
+                        return;
+                }
+                if (ACCESS_ONCE(synchronize_sched_expedited_count) - snap > 0) {
+                        smp_mb(); /* ensure test happens before caller kfree */
+                        return;
+                }
+                get_online_cpus();
+        }
+        rcu_expedited_state = RCU_EXPEDITED_STATE_POST;
+        for_each_online_cpu(cpu) {
+                rq = cpu_rq(cpu);
+                req = &per_cpu(rcu_migration_req, cpu);
+                init_completion(&req->done);
+                req->task = NULL;
+                req->dest_cpu = RCU_MIGRATION_NEED_QS;
+                spin_lock_irqsave(&rq->lock, flags);
+                list_add(&req->list, &rq->migration_queue);
+                spin_unlock_irqrestore(&rq->lock, flags);
+                wake_up_process(rq->migration_thread);
+        }
+        for_each_online_cpu(cpu) {
+                rcu_expedited_state = cpu;
+                req = &per_cpu(rcu_migration_req, cpu);
+                rq = cpu_rq(cpu);
+                wait_for_completion(&req->done);
+                spin_lock_irqsave(&rq->lock, flags);
+                if (unlikely(req->dest_cpu == RCU_MIGRATION_MUST_SYNC))
+                        need_full_sync = 1;
+                req->dest_cpu = RCU_MIGRATION_IDLE;
+                spin_unlock_irqrestore(&rq->lock, flags);
+        }
+        rcu_expedited_state = RCU_EXPEDITED_STATE_IDLE;
+        mutex_unlock(&rcu_sched_expedited_mutex);
+        put_online_cpus();
+        if (need_full_sync)
+                synchronize_sched();
+}
+EXPORT_SYMBOL_GPL(synchronize_sched_expedited);
+
+#endif /* #else #ifndef CONFIG_SMP */
diff --git a/kernel/sched_cpupri.c b/kernel/sched_cpupri.c
index d014efbf947a..0f052fc674d5 100644
--- a/kernel/sched_cpupri.c
+++ b/kernel/sched_cpupri.c
@@ -127,21 +127,11 @@ void cpupri_set(struct cpupri *cp, int cpu, int newpri)
 
         /*
          * If the cpu was currently mapped to a different value, we
-         * first need to unmap the old value
+         * need to map it to the new value then remove the old value.
+         * Note, we must add the new value first, otherwise we risk the
+         * cpu being cleared from pri_active, and this cpu could be
+         * missed for a push or pull.
          */
-        if (likely(oldpri != CPUPRI_INVALID)) {
-                struct cpupri_vec *vec  = &cp->pri_to_cpu[oldpri];
-
-                spin_lock_irqsave(&vec->lock, flags);
-
-                vec->count--;
-                if (!vec->count)
-                        clear_bit(oldpri, cp->pri_active);
-                cpumask_clear_cpu(cpu, vec->mask);
-
-                spin_unlock_irqrestore(&vec->lock, flags);
-        }
-
         if (likely(newpri != CPUPRI_INVALID)) {
                 struct cpupri_vec *vec = &cp->pri_to_cpu[newpri];
 
@@ -154,6 +144,18 @@ void cpupri_set(struct cpupri *cp, int cpu, int newpri)
 
                 spin_unlock_irqrestore(&vec->lock, flags);
         }
+        if (likely(oldpri != CPUPRI_INVALID)) {
+                struct cpupri_vec *vec  = &cp->pri_to_cpu[oldpri];
+
+                spin_lock_irqsave(&vec->lock, flags);
+
+                vec->count--;
+                if (!vec->count)
+                        clear_bit(oldpri, cp->pri_active);
+                cpumask_clear_cpu(cpu, vec->mask);
+
+                spin_unlock_irqrestore(&vec->lock, flags);
+        }
 
         *currpri = newpri;
 }
diff --git a/kernel/sched_debug.c b/kernel/sched_debug.c
index 70c7e0b79946..5ddbd0891267 100644
--- a/kernel/sched_debug.c
+++ b/kernel/sched_debug.c
@@ -409,6 +409,8 @@ void proc_sched_show_task(struct task_struct *p, struct seq_file *m)
         PN(se.wait_max);
         PN(se.wait_sum);
         P(se.wait_count);
+        PN(se.iowait_sum);
+        P(se.iowait_count);
         P(sched_info.bkl_count);
         P(se.nr_migrations);
         P(se.nr_migrations_cold);
@@ -479,6 +481,8 @@ void proc_sched_set_task(struct task_struct *p)
         p->se.wait_max                          = 0;
         p->se.wait_sum                          = 0;
         p->se.wait_count                        = 0;
+        p->se.iowait_sum                        = 0;
+        p->se.iowait_count                      = 0;
         p->se.sleep_max                         = 0;
         p->se.sum_sleep_runtime                 = 0;
         p->se.block_max                         = 0;
diff --git a/kernel/sched_fair.c b/kernel/sched_fair.c
index 652e8bdef9aa..aa7f84121016 100644
--- a/kernel/sched_fair.c
+++ b/kernel/sched_fair.c
@@ -24,7 +24,7 @@
 
 /*
  * Targeted preemption latency for CPU-bound tasks:
- * (default: 20ms * (1 + ilog(ncpus)), units: nanoseconds)
+ * (default: 5ms * (1 + ilog(ncpus)), units: nanoseconds)
  *
  * NOTE: this latency value is not the same as the concept of
  * 'timeslice length' - timeslices in CFS are of variable length
@@ -34,13 +34,13 @@
  * (to see the precise effective timeslice length of your workload,
  *  run vmstat and monitor the context-switches (cs) field)
  */
-unsigned int sysctl_sched_latency = 20000000ULL;
+unsigned int sysctl_sched_latency = 5000000ULL;
 
 /*
  * Minimal preemption granularity for CPU-bound tasks:
- * (default: 4 msec * (1 + ilog(ncpus)), units: nanoseconds)
+ * (default: 1 msec * (1 + ilog(ncpus)), units: nanoseconds)
  */
-unsigned int sysctl_sched_min_granularity = 4000000ULL;
+unsigned int sysctl_sched_min_granularity = 1000000ULL;
 
 /*
  * is kept at sysctl_sched_latency / sysctl_sched_min_granularity
@@ -48,10 +48,10 @@ unsigned int sysctl_sched_min_granularity = 4000000ULL;
 static unsigned int sched_nr_latency = 5;
 
 /*
- * After fork, child runs first. (default) If set to 0 then
+ * After fork, child runs first. If set to 0 (default) then
  * parent will (try to) run first.
  */
-const_debug unsigned int sysctl_sched_child_runs_first = 1;
+unsigned int sysctl_sched_child_runs_first __read_mostly;
 
 /*
  * sys_sched_yield() compat mode
@@ -63,13 +63,13 @@ unsigned int __read_mostly sysctl_sched_compat_yield;
 
 /*
  * SCHED_OTHER wake-up granularity.
- * (default: 5 msec * (1 + ilog(ncpus)), units: nanoseconds)
+ * (default: 1 msec * (1 + ilog(ncpus)), units: nanoseconds)
  *
  * This option delays the preemption effects of decoupled workloads
  * and reduces their over-scheduling. Synchronous workloads will still
  * have immediate wakeup/sleep latencies.
  */
-unsigned int sysctl_sched_wakeup_granularity = 5000000UL;
+unsigned int sysctl_sched_wakeup_granularity = 1000000UL;
 
 const_debug unsigned int sysctl_sched_migration_cost = 500000UL;
 
@@ -79,11 +79,6 @@ static const struct sched_class fair_sched_class;
  * CFS operations on generic schedulable entities:
  */
 
-static inline struct task_struct *task_of(struct sched_entity *se)
-{
-        return container_of(se, struct task_struct, se);
-}
-
 #ifdef CONFIG_FAIR_GROUP_SCHED
 
 /* cpu runqueue to which this cfs_rq is attached */
@@ -95,6 +90,14 @@ static inline struct rq *rq_of(struct cfs_rq *cfs_rq)
 /* An entity is a task if it doesn't "own" a runqueue */
 #define entity_is_task(se)      (!se->my_q)
 
+static inline struct task_struct *task_of(struct sched_entity *se)
+{
+#ifdef CONFIG_SCHED_DEBUG
+        WARN_ON_ONCE(!entity_is_task(se));
+#endif
+        return container_of(se, struct task_struct, se);
+}
+
 /* Walk up scheduling entities hierarchy */
 #define for_each_sched_entity(se) \
                 for (; se; se = se->parent)
@@ -186,7 +189,12 @@ find_matching_se(struct sched_entity **se, struct sched_entity **pse)
         }
 }
 
-#else   /* CONFIG_FAIR_GROUP_SCHED */
+#else   /* !CONFIG_FAIR_GROUP_SCHED */
+
+static inline struct task_struct *task_of(struct sched_entity *se)
+{
+        return container_of(se, struct task_struct, se);
+}
 
 static inline struct rq *rq_of(struct cfs_rq *cfs_rq)
 {
@@ -537,6 +545,12 @@ update_stats_wait_end(struct cfs_rq *cfs_rq, struct sched_entity *se)
         schedstat_set(se->wait_count, se->wait_count + 1);
         schedstat_set(se->wait_sum, se->wait_sum +
                         rq_of(cfs_rq)->clock - se->wait_start);
+#ifdef CONFIG_SCHEDSTATS
+        if (entity_is_task(se)) {
+                trace_sched_stat_wait(task_of(se),
+                        rq_of(cfs_rq)->clock - se->wait_start);
+        }
+#endif
         schedstat_set(se->wait_start, 0);
 }
 
@@ -628,8 +642,10 @@ static void enqueue_sleeper(struct cfs_rq *cfs_rq, struct sched_entity *se)
                 se->sleep_start = 0;
                 se->sum_sleep_runtime += delta;
 
-                if (tsk)
+                if (tsk) {
                         account_scheduler_latency(tsk, delta >> 10, 1);
+                        trace_sched_stat_sleep(tsk, delta);
+                }
         }
         if (se->block_start) {
                 u64 delta = rq_of(cfs_rq)->clock - se->block_start;
@@ -644,6 +660,12 @@ static void enqueue_sleeper(struct cfs_rq *cfs_rq, struct sched_entity *se)
                 se->sum_sleep_runtime += delta;
 
                 if (tsk) {
+                        if (tsk->in_iowait) {
+                                se->iowait_sum += delta;
+                                se->iowait_count++;
+                                trace_sched_stat_iowait(tsk, delta);
+                        }
+
                         /*
                          * Blocking time is in units of nanosecs, so shift by
                          * 20 to get a milliseconds-range estimation of the
@@ -705,11 +727,11 @@ place_entity(struct cfs_rq *cfs_rq, struct sched_entity *se, int initial)
 
                         vruntime -= thresh;
                 }
-
-                /* ensure we never gain time by being placed backwards. */
-                vruntime = max_vruntime(se->vruntime, vruntime);
         }
 
+        /* ensure we never gain time by being placed backwards. */
+        vruntime = max_vruntime(se->vruntime, vruntime);
+
         se->vruntime = vruntime;
 }
 
@@ -1046,17 +1068,21 @@ static void yield_task_fair(struct rq *rq)
  * search starts with cpus closest then further out as needed,
  * so we always favor a closer, idle cpu.
  * Domains may include CPUs that are not usable for migration,
- * hence we need to mask them out (cpu_active_mask)
+ * hence we need to mask them out (rq->rd->online)
  *
  * Returns the CPU we should wake onto.
  */
 #if defined(ARCH_HAS_SCHED_WAKE_IDLE)
+
+#define cpu_rd_active(cpu, rq) cpumask_test_cpu(cpu, rq->rd->online)
+
 static int wake_idle(int cpu, struct task_struct *p)
 {
         struct sched_domain *sd;
         int i;
         unsigned int chosen_wakeup_cpu;
         int this_cpu;
+        struct rq *task_rq = task_rq(p);
 
         /*
          * At POWERSAVINGS_BALANCE_WAKEUP level, if both this_cpu and prev_cpu
@@ -1089,10 +1115,10 @@ static int wake_idle(int cpu, struct task_struct *p)
         for_each_domain(cpu, sd) {
                 if ((sd->flags & SD_WAKE_IDLE)
                     || ((sd->flags & SD_WAKE_IDLE_FAR)
-                        && !task_hot(p, task_rq(p)->clock, sd))) {
+                        && !task_hot(p, task_rq->clock, sd))) {
                         for_each_cpu_and(i, sched_domain_span(sd),
                                          &p->cpus_allowed) {
-                                if (cpu_active(i) && idle_cpu(i)) {
+                                if (cpu_rd_active(i, task_rq) && idle_cpu(i)) {
                                         if (i != task_cpu(p)) {
                                                 schedstat_inc(p,
                                                        se.nr_wakeups_idle);
@@ -1235,7 +1261,17 @@ wake_affine(struct sched_domain *this_sd, struct rq *this_rq,
         tg = task_group(p);
         weight = p->se.load.weight;
 
-        balanced = 100*(tl + effective_load(tg, this_cpu, weight, weight)) <=
+        /*
+         * In low-load situations, where prev_cpu is idle and this_cpu is idle
+         * due to the sync cause above having dropped tl to 0, we'll always have
+         * an imbalance, but there's really nothing you can do about that, so
+         * that's good too.
+         *
+         * Otherwise check if either cpus are near enough in load to allow this
+         * task to be woken on this_cpu.
+         */
+        balanced = !tl ||
+                100*(tl + effective_load(tg, this_cpu, weight, weight)) <=
                 imbalance*(load + effective_load(tg, prev_cpu, 0, weight));
 
         /*
@@ -1278,8 +1314,6 @@ static int select_task_rq_fair(struct task_struct *p, int sync)
         this_rq         = cpu_rq(this_cpu);
         new_cpu         = prev_cpu;
 
-        if (prev_cpu == this_cpu)
-                goto out;
         /*
          * 'this_sd' is the first domain that both
          * this_cpu and prev_cpu are present in:
@@ -1721,6 +1755,8 @@ static void task_new_fair(struct rq *rq, struct task_struct *p)
         sched_info_queued(p);
 
         update_curr(cfs_rq);
+        if (curr)
+                se->vruntime = curr->vruntime;
         place_entity(cfs_rq, se, 1);
 
         /* 'curr' will be NULL if the child belongs to a different group */
diff --git a/kernel/sched_features.h b/kernel/sched_features.h
index 4569bfa7df9b..e2dc63a5815d 100644
--- a/kernel/sched_features.h
+++ b/kernel/sched_features.h
@@ -1,4 +1,4 @@
-SCHED_FEAT(NEW_FAIR_SLEEPERS, 1)
+SCHED_FEAT(NEW_FAIR_SLEEPERS, 0)
 SCHED_FEAT(NORMALIZED_SLEEPER, 0)
 SCHED_FEAT(ADAPTIVE_GRAN, 1)
 SCHED_FEAT(WAKEUP_PREEMPT, 1)
diff --git a/kernel/sched_rt.c b/kernel/sched_rt.c
index 3918e01994e0..2eb4bd6a526c 100644
--- a/kernel/sched_rt.c
+++ b/kernel/sched_rt.c
@@ -3,15 +3,18 @@
  * policies)
  */
 
+#ifdef CONFIG_RT_GROUP_SCHED
+
+#define rt_entity_is_task(rt_se) (!(rt_se)->my_q)
+
 static inline struct task_struct *rt_task_of(struct sched_rt_entity *rt_se)
 {
+#ifdef CONFIG_SCHED_DEBUG
+        WARN_ON_ONCE(!rt_entity_is_task(rt_se));
+#endif
         return container_of(rt_se, struct task_struct, rt);
 }
 
-#ifdef CONFIG_RT_GROUP_SCHED
-
-#define rt_entity_is_task(rt_se) (!(rt_se)->my_q)
-
 static inline struct rq *rq_of_rt_rq(struct rt_rq *rt_rq)
 {
         return rt_rq->rq;
@@ -26,6 +29,11 @@ static inline struct rt_rq *rt_rq_of_se(struct sched_rt_entity *rt_se)
 
 #define rt_entity_is_task(rt_se) (1)
 
+static inline struct task_struct *rt_task_of(struct sched_rt_entity *rt_se)
+{
+        return container_of(rt_se, struct task_struct, rt);
+}
+
 static inline struct rq *rq_of_rt_rq(struct rt_rq *rt_rq)
 {
         return container_of(rt_rq, struct rq, rt);
@@ -128,6 +136,11 @@ static void dequeue_pushable_task(struct rq *rq, struct task_struct *p)
         plist_del(&p->pushable_tasks, &rq->rt.pushable_tasks);
 }
 
+static inline int has_pushable_tasks(struct rq *rq)
+{
+        return !plist_head_empty(&rq->rt.pushable_tasks);
+}
+
 #else
 
 static inline void enqueue_pushable_task(struct rq *rq, struct task_struct *p)
@@ -602,6 +615,8 @@ static void update_curr_rt(struct rq *rq)
         curr->se.exec_start = rq->clock;
         cpuacct_charge(curr, delta_exec);
 
+        sched_rt_avg_update(rq, delta_exec);
+
         if (!rt_bandwidth_enabled())
                 return;
 
@@ -874,8 +889,6 @@ static void enqueue_task_rt(struct rq *rq, struct task_struct *p, int wakeup)
 
         if (!task_current(rq, p) && p->rt.nr_cpus_allowed > 1)
                 enqueue_pushable_task(rq, p);
-
-        inc_cpu_load(rq, p->se.load.weight);
 }
 
 static void dequeue_task_rt(struct rq *rq, struct task_struct *p, int sleep)
@@ -886,8 +899,6 @@ static void dequeue_task_rt(struct rq *rq, struct task_struct *p, int sleep)
         dequeue_rt_entity(rt_se);
 
         dequeue_pushable_task(rq, p);
-
-        dec_cpu_load(rq, p->se.load.weight);
 }
 
 /*
@@ -1064,6 +1075,14 @@ static struct task_struct *pick_next_task_rt(struct rq *rq)
         if (p)
                 dequeue_pushable_task(rq, p);
 
+#ifdef CONFIG_SMP
+        /*
+         * We detect this state here so that we can avoid taking the RQ
+         * lock again later if there is no need to push
+         */
+        rq->post_schedule = has_pushable_tasks(rq);
+#endif
+
         return p;
 }
 
@@ -1162,13 +1181,6 @@ static int find_lowest_rq(struct task_struct *task)
                 return -1; /* No targets found */
 
         /*
-         * Only consider CPUs that are usable for migration.
-         * I guess we might want to change cpupri_find() to ignore those
-         * in the first place.
-         */
-        cpumask_and(lowest_mask, lowest_mask, cpu_active_mask);
-
-        /*
          * At this point we have built a mask of cpus representing the
          * lowest priority tasks in the system.  Now we want to elect
          * the best one based on our affinity and topology.
@@ -1262,11 +1274,6 @@ static struct rq *find_lock_lowest_rq(struct task_struct *task, struct rq *rq)
         return lowest_rq;
 }
 
-static inline int has_pushable_tasks(struct rq *rq)
-{
-        return !plist_head_empty(&rq->rt.pushable_tasks);
-}
-
 static struct task_struct *pick_next_pushable_task(struct rq *rq)
 {
         struct task_struct *p;
@@ -1466,23 +1473,9 @@ static void pre_schedule_rt(struct rq *rq, struct task_struct *prev)
                 pull_rt_task(rq);
 }
 
-/*
- * assumes rq->lock is held
- */
-static int needs_post_schedule_rt(struct rq *rq)
-{
-        return has_pushable_tasks(rq);
-}
-
 static void post_schedule_rt(struct rq *rq)
 {
-        /*
-         * This is only called if needs_post_schedule_rt() indicates that
-         * we need to push tasks away
-         */
-        spin_lock_irq(&rq->lock);
         push_rt_tasks(rq);
-        spin_unlock_irq(&rq->lock);
 }
 
 /*
@@ -1758,7 +1751,6 @@ static const struct sched_class rt_sched_class = {
         .rq_online              = rq_online_rt,
         .rq_offline             = rq_offline_rt,
         .pre_schedule           = pre_schedule_rt,
-        .needs_post_schedule    = needs_post_schedule_rt,
         .post_schedule          = post_schedule_rt,
         .task_wake_up           = task_wake_up_rt,
         .switched_from          = switched_from_rt,
diff --git a/kernel/softirq.c b/kernel/softirq.c
index eb5e131a0485..7db25067cd2d 100644
--- a/kernel/softirq.c
+++ b/kernel/softirq.c
@@ -227,7 +227,7 @@ restart:
                                 preempt_count() = prev_count;
                         }
 
-                        rcu_bh_qsctr_inc(cpu);
+                        rcu_bh_qs(cpu);
                 }
                 h++;
                 pending >>= 1;
@@ -721,7 +721,7 @@ static int ksoftirqd(void * __bind_cpu)
                         preempt_enable_no_resched();
                         cond_resched();
                         preempt_disable();
-                        rcu_qsctr_inc((long)__bind_cpu);
+                        rcu_sched_qs((long)__bind_cpu);
                 }
                 preempt_enable();
                 set_current_state(TASK_INTERRUPTIBLE);
diff --git a/kernel/spinlock.c b/kernel/spinlock.c
index 7932653c4ebd..5ddab730cb2f 100644
--- a/kernel/spinlock.c
+++ b/kernel/spinlock.c
@@ -21,44 +21,29 @@
 #include <linux/debug_locks.h>
 #include <linux/module.h>
 
+#ifndef _spin_trylock
 int __lockfunc _spin_trylock(spinlock_t *lock)
 {
-        preempt_disable();
-        if (_raw_spin_trylock(lock)) {
-                spin_acquire(&lock->dep_map, 0, 1, _RET_IP_);
-                return 1;
-        }
-        
-        preempt_enable();
-        return 0;
+        return __spin_trylock(lock);
 }
 EXPORT_SYMBOL(_spin_trylock);
+#endif
 
+#ifndef _read_trylock
 int __lockfunc _read_trylock(rwlock_t *lock)
 {
-        preempt_disable();
-        if (_raw_read_trylock(lock)) {
-                rwlock_acquire_read(&lock->dep_map, 0, 1, _RET_IP_);
-                return 1;
-        }
-
-        preempt_enable();
-        return 0;
+        return __read_trylock(lock);
 }
 EXPORT_SYMBOL(_read_trylock);
+#endif
 
+#ifndef _write_trylock
 int __lockfunc _write_trylock(rwlock_t *lock)
 {
-        preempt_disable();
-        if (_raw_write_trylock(lock)) {
-                rwlock_acquire(&lock->dep_map, 0, 1, _RET_IP_);
-                return 1;
-        }
-
-        preempt_enable();
-        return 0;
+        return __write_trylock(lock);
 }
 EXPORT_SYMBOL(_write_trylock);
+#endif
 
 /*
  * If lockdep is enabled then we use the non-preemption spin-ops
@@ -67,132 +52,101 @@ EXPORT_SYMBOL(_write_trylock);
  */
 #if !defined(CONFIG_GENERIC_LOCKBREAK) || defined(CONFIG_DEBUG_LOCK_ALLOC)
 
+#ifndef _read_lock
 void __lockfunc _read_lock(rwlock_t *lock)
 {
-        preempt_disable();
-        rwlock_acquire_read(&lock->dep_map, 0, 0, _RET_IP_);
-        LOCK_CONTENDED(lock, _raw_read_trylock, _raw_read_lock);
+        __read_lock(lock);
 }
 EXPORT_SYMBOL(_read_lock);
+#endif
 
+#ifndef _spin_lock_irqsave
 unsigned long __lockfunc _spin_lock_irqsave(spinlock_t *lock)
 {
-        unsigned long flags;
-
-        local_irq_save(flags);
-        preempt_disable();
-        spin_acquire(&lock->dep_map, 0, 0, _RET_IP_);
-        /*
-         * On lockdep we dont want the hand-coded irq-enable of
-         * _raw_spin_lock_flags() code, because lockdep assumes
-         * that interrupts are not re-enabled during lock-acquire:
-         */
-#ifdef CONFIG_LOCKDEP
-        LOCK_CONTENDED(lock, _raw_spin_trylock, _raw_spin_lock);
-#else
-        _raw_spin_lock_flags(lock, &flags);
-#endif
-        return flags;
+        return __spin_lock_irqsave(lock);
 }
 EXPORT_SYMBOL(_spin_lock_irqsave);
+#endif
 
+#ifndef _spin_lock_irq
 void __lockfunc _spin_lock_irq(spinlock_t *lock)
 {
-        local_irq_disable();
-        preempt_disable();
-        spin_acquire(&lock->dep_map, 0, 0, _RET_IP_);
-        LOCK_CONTENDED(lock, _raw_spin_trylock, _raw_spin_lock);
+        __spin_lock_irq(lock);
 }
 EXPORT_SYMBOL(_spin_lock_irq);
+#endif
 
+#ifndef _spin_lock_bh
 void __lockfunc _spin_lock_bh(spinlock_t *lock)
 {
-        local_bh_disable();
-        preempt_disable();
-        spin_acquire(&lock->dep_map, 0, 0, _RET_IP_);
-        LOCK_CONTENDED(lock, _raw_spin_trylock, _raw_spin_lock);
+        __spin_lock_bh(lock);
 }
 EXPORT_SYMBOL(_spin_lock_bh);
+#endif
 
+#ifndef _read_lock_irqsave
 unsigned long __lockfunc _read_lock_irqsave(rwlock_t *lock)
 {
-        unsigned long flags;
-
-        local_irq_save(flags);
-        preempt_disable();
-        rwlock_acquire_read(&lock->dep_map, 0, 0, _RET_IP_);
-        LOCK_CONTENDED_FLAGS(lock, _raw_read_trylock, _raw_read_lock,
-                             _raw_read_lock_flags, &flags);
-        return flags;
+        return __read_lock_irqsave(lock);
 }
 EXPORT_SYMBOL(_read_lock_irqsave);
+#endif
 
+#ifndef _read_lock_irq
 void __lockfunc _read_lock_irq(rwlock_t *lock)
 {
-        local_irq_disable();
-        preempt_disable();
-        rwlock_acquire_read(&lock->dep_map, 0, 0, _RET_IP_);
-        LOCK_CONTENDED(lock, _raw_read_trylock, _raw_read_lock);
+        __read_lock_irq(lock);
 }
 EXPORT_SYMBOL(_read_lock_irq);
+#endif
 
+#ifndef _read_lock_bh
 void __lockfunc _read_lock_bh(rwlock_t *lock)
 {
-        local_bh_disable();
-        preempt_disable();
-        rwlock_acquire_read(&lock->dep_map, 0, 0, _RET_IP_);
-        LOCK_CONTENDED(lock, _raw_read_trylock, _raw_read_lock);
+        __read_lock_bh(lock);
 }
 EXPORT_SYMBOL(_read_lock_bh);
+#endif
 
+#ifndef _write_lock_irqsave
 unsigned long __lockfunc _write_lock_irqsave(rwlock_t *lock)
 {
-        unsigned long flags;
-
-        local_irq_save(flags);
-        preempt_disable();
-        rwlock_acquire(&lock->dep_map, 0, 0, _RET_IP_);
-        LOCK_CONTENDED_FLAGS(lock, _raw_write_trylock, _raw_write_lock,
-                             _raw_write_lock_flags, &flags);
-        return flags;
+        return __write_lock_irqsave(lock);
 }
 EXPORT_SYMBOL(_write_lock_irqsave);
+#endif
 
+#ifndef _write_lock_irq
 void __lockfunc _write_lock_irq(rwlock_t *lock)
 {
-        local_irq_disable();
-        preempt_disable();
-        rwlock_acquire(&lock->dep_map, 0, 0, _RET_IP_);
-        LOCK_CONTENDED(lock, _raw_write_trylock, _raw_write_lock);
+        __write_lock_irq(lock);
 }
 EXPORT_SYMBOL(_write_lock_irq);
+#endif
 
+#ifndef _write_lock_bh
 void __lockfunc _write_lock_bh(rwlock_t *lock)
 {
-        local_bh_disable();
-        preempt_disable();
-        rwlock_acquire(&lock->dep_map, 0, 0, _RET_IP_);
-        LOCK_CONTENDED(lock, _raw_write_trylock, _raw_write_lock);
+        __write_lock_bh(lock);
 }
 EXPORT_SYMBOL(_write_lock_bh);
+#endif
 
+#ifndef _spin_lock
 void __lockfunc _spin_lock(spinlock_t *lock)
 {
-        preempt_disable();
-        spin_acquire(&lock->dep_map, 0, 0, _RET_IP_);
-        LOCK_CONTENDED(lock, _raw_spin_trylock, _raw_spin_lock);
+        __spin_lock(lock);
 }
-
 EXPORT_SYMBOL(_spin_lock);
+#endif
 
+#ifndef _write_lock
 void __lockfunc _write_lock(rwlock_t *lock)
 {
-        preempt_disable();
-        rwlock_acquire(&lock->dep_map, 0, 0, _RET_IP_);
-        LOCK_CONTENDED(lock, _raw_write_trylock, _raw_write_lock);
+        __write_lock(lock);
 }
-
 EXPORT_SYMBOL(_write_lock);
+#endif
 
 #else /* CONFIG_PREEMPT: */
 
@@ -318,125 +272,109 @@ EXPORT_SYMBOL(_spin_lock_nest_lock);
 
 #endif
 
+#ifndef _spin_unlock
 void __lockfunc _spin_unlock(spinlock_t *lock)
 {
-        spin_release(&lock->dep_map, 1, _RET_IP_);
-        _raw_spin_unlock(lock);
-        preempt_enable();
+        __spin_unlock(lock);
 }
 EXPORT_SYMBOL(_spin_unlock);
+#endif
 
+#ifndef _write_unlock
 void __lockfunc _write_unlock(rwlock_t *lock)
 {
-        rwlock_release(&lock->dep_map, 1, _RET_IP_);
-        _raw_write_unlock(lock);
-        preempt_enable();
+        __write_unlock(lock);
 }
 EXPORT_SYMBOL(_write_unlock);
+#endif
 
+#ifndef _read_unlock
 void __lockfunc _read_unlock(rwlock_t *lock)
 {
-        rwlock_release(&lock->dep_map, 1, _RET_IP_);
-        _raw_read_unlock(lock);
-        preempt_enable();
+        __read_unlock(lock);
 }
 EXPORT_SYMBOL(_read_unlock);
+#endif
 
+#ifndef _spin_unlock_irqrestore
 void __lockfunc _spin_unlock_irqrestore(spinlock_t *lock, unsigned long flags)
 {
-        spin_release(&lock->dep_map, 1, _RET_IP_);
-        _raw_spin_unlock(lock);
-        local_irq_restore(flags);
-        preempt_enable();
+        __spin_unlock_irqrestore(lock, flags);
 }
 EXPORT_SYMBOL(_spin_unlock_irqrestore);
+#endif
 
+#ifndef _spin_unlock_irq
 void __lockfunc _spin_unlock_irq(spinlock_t *lock)
 {
-        spin_release(&lock->dep_map, 1, _RET_IP_);
-        _raw_spin_unlock(lock);
-        local_irq_enable();
-        preempt_enable();
+        __spin_unlock_irq(lock);
 }
 EXPORT_SYMBOL(_spin_unlock_irq);
+#endif
 
+#ifndef _spin_unlock_bh
 void __lockfunc _spin_unlock_bh(spinlock_t *lock)
 {
-        spin_release(&lock->dep_map, 1, _RET_IP_);
-        _raw_spin_unlock(lock);
-        preempt_enable_no_resched();
-        local_bh_enable_ip((unsigned long)__builtin_return_address(0));
+        __spin_unlock_bh(lock);
 }
 EXPORT_SYMBOL(_spin_unlock_bh);
+#endif
 
+#ifndef _read_unlock_irqrestore
 void __lockfunc _read_unlock_irqrestore(rwlock_t *lock, unsigned long flags)
 {
-        rwlock_release(&lock->dep_map, 1, _RET_IP_);
-        _raw_read_unlock(lock);
-        local_irq_restore(flags);
-        preempt_enable();
+        __read_unlock_irqrestore(lock, flags);
 }
 EXPORT_SYMBOL(_read_unlock_irqrestore);
+#endif
 
+#ifndef _read_unlock_irq
 void __lockfunc _read_unlock_irq(rwlock_t *lock)
 {
-        rwlock_release(&lock->dep_map, 1, _RET_IP_);
-        _raw_read_unlock(lock);
-        local_irq_enable();
-        preempt_enable();
+        __read_unlock_irq(lock);
 }
 EXPORT_SYMBOL(_read_unlock_irq);
+#endif
 
+#ifndef _read_unlock_bh
 void __lockfunc _read_unlock_bh(rwlock_t *lock)
 {
-        rwlock_release(&lock->dep_map, 1, _RET_IP_);
-        _raw_read_unlock(lock);
-        preempt_enable_no_resched();
-        local_bh_enable_ip((unsigned long)__builtin_return_address(0));
+        __read_unlock_bh(lock);
 }
 EXPORT_SYMBOL(_read_unlock_bh);
+#endif
 
+#ifndef _write_unlock_irqrestore
 void __lockfunc _write_unlock_irqrestore(rwlock_t *lock, unsigned long flags)
 {
-        rwlock_release(&lock->dep_map, 1, _RET_IP_);
-        _raw_write_unlock(lock);
-        local_irq_restore(flags);
-        preempt_enable();
+        __write_unlock_irqrestore(lock, flags);
 }
 EXPORT_SYMBOL(_write_unlock_irqrestore);
+#endif
 
+#ifndef _write_unlock_irq
 void __lockfunc _write_unlock_irq(rwlock_t *lock)
 {
-        rwlock_release(&lock->dep_map, 1, _RET_IP_);
-        _raw_write_unlock(lock);
-        local_irq_enable();
-        preempt_enable();
+        __write_unlock_irq(lock);
 }
 EXPORT_SYMBOL(_write_unlock_irq);
+#endif
 
+#ifndef _write_unlock_bh
 void __lockfunc _write_unlock_bh(rwlock_t *lock)
 {
-        rwlock_release(&lock->dep_map, 1, _RET_IP_);
-        _raw_write_unlock(lock);
-        preempt_enable_no_resched();
-        local_bh_enable_ip((unsigned long)__builtin_return_address(0));
+        __write_unlock_bh(lock);
 }
 EXPORT_SYMBOL(_write_unlock_bh);
+#endif
 
+#ifndef _spin_trylock_bh
 int __lockfunc _spin_trylock_bh(spinlock_t *lock)
 {
-        local_bh_disable();
-        preempt_disable();
-        if (_raw_spin_trylock(lock)) {
-                spin_acquire(&lock->dep_map, 0, 1, _RET_IP_);
-                return 1;
-        }
-
-        preempt_enable_no_resched();
-        local_bh_enable_ip((unsigned long)__builtin_return_address(0));
-        return 0;
+        return __spin_trylock_bh(lock);
 }
 EXPORT_SYMBOL(_spin_trylock_bh);
+#endif
 
 notrace int in_lock_functions(unsigned long addr)
 {
diff --git a/kernel/sysctl.c b/kernel/sysctl.c
index 71d8dc7f9920..3125cff1c570 100644
--- a/kernel/sysctl.c
+++ b/kernel/sysctl.c
@@ -245,6 +245,14 @@ static int max_wakeup_granularity_ns = NSEC_PER_SEC;	/* 1 second */
 #endif
 
 static struct ctl_table kern_table[] = {
+        {
+                .ctl_name       = CTL_UNNUMBERED,
+                .procname       = "sched_child_runs_first",
+                .data           = &sysctl_sched_child_runs_first,
+                .maxlen         = sizeof(unsigned int),
+                .mode           = 0644,
+                .proc_handler   = &proc_dointvec,
+        },
 #ifdef CONFIG_SCHED_DEBUG
         {
                 .ctl_name       = CTL_UNNUMBERED,
@@ -299,14 +307,6 @@ static struct ctl_table kern_table[] = {
         },
         {
                 .ctl_name       = CTL_UNNUMBERED,
-                .procname       = "sched_child_runs_first",
-                .data           = &sysctl_sched_child_runs_first,
-                .maxlen         = sizeof(unsigned int),
-                .mode           = 0644,
-                .proc_handler   = &proc_dointvec,
-        },
-        {
-                .ctl_name       = CTL_UNNUMBERED,
                 .procname       = "sched_features",
                 .data           = &sysctl_sched_features,
                 .maxlen         = sizeof(unsigned int),
@@ -331,6 +331,14 @@ static struct ctl_table kern_table[] = {
         },
         {
                 .ctl_name       = CTL_UNNUMBERED,
+                .procname       = "sched_time_avg",
+                .data           = &sysctl_sched_time_avg,
+                .maxlen         = sizeof(unsigned int),
+                .mode           = 0644,
+                .proc_handler   = &proc_dointvec,
+        },
+        {
+                .ctl_name       = CTL_UNNUMBERED,
                 .procname       = "timer_migration",
                 .data           = &sysctl_timer_migration,
                 .maxlen         = sizeof(unsigned int),
diff --git a/kernel/timer.c b/kernel/timer.c
index a7f07d5a6241..a3d25f415019 100644
--- a/kernel/timer.c
+++ b/kernel/timer.c
@@ -1156,8 +1156,7 @@ void update_process_times(int user_tick)
         /* Note: this timer irq context must be accounted for as well. */
         account_process_tick(p, user_tick);
         run_local_timers();
-        if (rcu_pending(cpu))
-                rcu_check_callbacks(cpu, user_tick);
+        rcu_check_callbacks(cpu, user_tick);
         printk_tick();
         scheduler_tick();
         run_posix_cpu_timers(p);
diff --git a/kernel/trace/Kconfig b/kernel/trace/Kconfig
index 019f380fd764..1ea0d1234f4a 100644
--- a/kernel/trace/Kconfig
+++ b/kernel/trace/Kconfig
@@ -41,7 +41,7 @@ config HAVE_FTRACE_MCOUNT_RECORD
 config HAVE_HW_BRANCH_TRACER
         bool
 
-config HAVE_FTRACE_SYSCALLS
+config HAVE_SYSCALL_TRACEPOINTS
         bool
 
 config TRACER_MAX_TRACE
@@ -60,9 +60,14 @@ config EVENT_TRACING
         bool
 
 config CONTEXT_SWITCH_TRACER
-        select MARKERS
         bool
 
+config RING_BUFFER_ALLOW_SWAP
+        bool
+        help
+         Allow the use of ring_buffer_swap_cpu.
+         Adds a very slight overhead to tracing when enabled.
+
 # All tracer options should select GENERIC_TRACER. For those options that are
 # enabled by all tracers (context switch and event tracer) they select TRACING.
 # This allows those options to appear when no other tracer is selected. But the
@@ -147,6 +152,7 @@ config IRQSOFF_TRACER
         select TRACE_IRQFLAGS
         select GENERIC_TRACER
         select TRACER_MAX_TRACE
+        select RING_BUFFER_ALLOW_SWAP
         help
           This option measures the time spent in irqs-off critical
           sections, with microsecond accuracy.
@@ -168,6 +174,7 @@ config PREEMPT_TRACER
         depends on PREEMPT
         select GENERIC_TRACER
         select TRACER_MAX_TRACE
+        select RING_BUFFER_ALLOW_SWAP
         help
           This option measures the time spent in preemption off critical
           sections, with microsecond accuracy.
@@ -211,7 +218,7 @@ config ENABLE_DEFAULT_TRACERS
 
 config FTRACE_SYSCALLS
         bool "Trace syscalls"
-        depends on HAVE_FTRACE_SYSCALLS
+        depends on HAVE_SYSCALL_TRACEPOINTS
         select GENERIC_TRACER
         select KALLSYMS
         help
diff --git a/kernel/trace/blktrace.c b/kernel/trace/blktrace.c
index 7a34cb563fec..3eb159c277c8 100644
--- a/kernel/trace/blktrace.c
+++ b/kernel/trace/blktrace.c
@@ -65,13 +65,15 @@ static void trace_note(struct blk_trace *bt, pid_t pid, int action,
 {
         struct blk_io_trace *t;
         struct ring_buffer_event *event = NULL;
+        struct ring_buffer *buffer = NULL;
         int pc = 0;
         int cpu = smp_processor_id();
         bool blk_tracer = blk_tracer_enabled;
 
         if (blk_tracer) {
+                buffer = blk_tr->buffer;
                 pc = preempt_count();
-                event = trace_buffer_lock_reserve(blk_tr, TRACE_BLK,
+                event = trace_buffer_lock_reserve(buffer, TRACE_BLK,
                                                   sizeof(*t) + len,
                                                   0, pc);
                 if (!event)
@@ -96,7 +98,7 @@ record_it:
                 memcpy((void *) t + sizeof(*t), data, len);
 
                 if (blk_tracer)
-                        trace_buffer_unlock_commit(blk_tr, event, 0, pc);
+                        trace_buffer_unlock_commit(buffer, event, 0, pc);
         }
 }
 
@@ -179,6 +181,7 @@ static void __blk_add_trace(struct blk_trace *bt, sector_t sector, int bytes,
 {
         struct task_struct *tsk = current;
         struct ring_buffer_event *event = NULL;
+        struct ring_buffer *buffer = NULL;
         struct blk_io_trace *t;
         unsigned long flags = 0;
         unsigned long *sequence;
@@ -204,8 +207,9 @@ static void __blk_add_trace(struct blk_trace *bt, sector_t sector, int bytes,
         if (blk_tracer) {
                 tracing_record_cmdline(current);
 
+                buffer = blk_tr->buffer;
                 pc = preempt_count();
-                event = trace_buffer_lock_reserve(blk_tr, TRACE_BLK,
+                event = trace_buffer_lock_reserve(buffer, TRACE_BLK,
                                                   sizeof(*t) + pdu_len,
                                                   0, pc);
                 if (!event)
@@ -252,7 +256,7 @@ record_it:
                         memcpy((void *) t + sizeof(*t), pdu_data, pdu_len);
 
                 if (blk_tracer) {
-                        trace_buffer_unlock_commit(blk_tr, event, 0, pc);
+                        trace_buffer_unlock_commit(buffer, event, 0, pc);
                         return;
                 }
         }
diff --git a/kernel/trace/ftrace.c b/kernel/trace/ftrace.c
index 25edd5cc5935..8c804e24f96f 100644
--- a/kernel/trace/ftrace.c
+++ b/kernel/trace/ftrace.c
@@ -1016,71 +1016,35 @@ static int
 __ftrace_replace_code(struct dyn_ftrace *rec, int enable)
 {
         unsigned long ftrace_addr;
-        unsigned long ip, fl;
+        unsigned long flag = 0UL;
 
         ftrace_addr = (unsigned long)FTRACE_ADDR;
 
-        ip = rec->ip;
-
         /*
-         * If this record is not to be traced and
-         * it is not enabled then do nothing.
+         * If this record is not to be traced or we want to disable it,
+         * then disable it.
          *
-         * If this record is not to be traced and
-         * it is enabled then disable it.
+         * If we want to enable it and filtering is off, then enable it.
          *
+         * If we want to enable it and filtering is on, enable it only if
+         * it's filtered
          */
-        if (rec->flags & FTRACE_FL_NOTRACE) {
-                if (rec->flags & FTRACE_FL_ENABLED)
-                        rec->flags &= ~FTRACE_FL_ENABLED;
-                else
-                        return 0;
-
-        } else if (ftrace_filtered && enable) {
-                /*
-                 * Filtering is on:
-                 */
-
-                fl = rec->flags & (FTRACE_FL_FILTER | FTRACE_FL_ENABLED);
-
-                /* Record is filtered and enabled, do nothing */
-                if (fl == (FTRACE_FL_FILTER | FTRACE_FL_ENABLED))
-                        return 0;
-
-                /* Record is not filtered or enabled, do nothing */
-                if (!fl)
-                        return 0;
-
-                /* Record is not filtered but enabled, disable it */
-                if (fl == FTRACE_FL_ENABLED)
-                        rec->flags &= ~FTRACE_FL_ENABLED;
-                else
-                /* Otherwise record is filtered but not enabled, enable it */
-                        rec->flags |= FTRACE_FL_ENABLED;
-        } else {
-                /* Disable or not filtered */
-
-                if (enable) {
-                        /* if record is enabled, do nothing */
-                        if (rec->flags & FTRACE_FL_ENABLED)
-                                return 0;
-
-                        rec->flags |= FTRACE_FL_ENABLED;
-
-                } else {
+        if (enable && !(rec->flags & FTRACE_FL_NOTRACE)) {
+                if (!ftrace_filtered || (rec->flags & FTRACE_FL_FILTER))
+                        flag = FTRACE_FL_ENABLED;
+        }
 
-                        /* if record is not enabled, do nothing */
-                        if (!(rec->flags & FTRACE_FL_ENABLED))
-                                return 0;
+        /* If the state of this record hasn't changed, then do nothing */
+        if ((rec->flags & FTRACE_FL_ENABLED) == flag)
+                return 0;
 
-                        rec->flags &= ~FTRACE_FL_ENABLED;
-                }
+        if (flag) {
+                rec->flags |= FTRACE_FL_ENABLED;
+                return ftrace_make_call(rec, ftrace_addr);
         }
 
-        if (rec->flags & FTRACE_FL_ENABLED)
-                return ftrace_make_call(rec, ftrace_addr);
-        else
-                return ftrace_make_nop(NULL, rec, ftrace_addr);
+        rec->flags &= ~FTRACE_FL_ENABLED;
+        return ftrace_make_nop(NULL, rec, ftrace_addr);
 }
 
 static void ftrace_replace_code(int enable)
@@ -1375,7 +1339,6 @@ struct ftrace_iterator {
         unsigned                flags;
         unsigned char           buffer[FTRACE_BUFF_MAX+1];
         unsigned                buffer_idx;
-        unsigned                filtered;
 };
 
 static void *
@@ -1438,18 +1401,13 @@ static int t_hash_show(struct seq_file *m, void *v)
 {
         struct ftrace_func_probe *rec;
         struct hlist_node *hnd = v;
-        char str[KSYM_SYMBOL_LEN];
 
         rec = hlist_entry(hnd, struct ftrace_func_probe, node);
 
         if (rec->ops->print)
                 return rec->ops->print(m, rec->ip, rec->ops, rec->data);
 
-        kallsyms_lookup(rec->ip, NULL, NULL, NULL, str);
-        seq_printf(m, "%s:", str);
-
-        kallsyms_lookup((unsigned long)rec->ops->func, NULL, NULL, NULL, str);
-        seq_printf(m, "%s", str);
+        seq_printf(m, "%pf:%pf", (void *)rec->ip, (void *)rec->ops->func);
 
         if (rec->data)
                 seq_printf(m, ":%p", rec->data);
@@ -1547,7 +1505,6 @@ static int t_show(struct seq_file *m, void *v)
 {
         struct ftrace_iterator *iter = m->private;
         struct dyn_ftrace *rec = v;
-        char str[KSYM_SYMBOL_LEN];
 
         if (iter->flags & FTRACE_ITER_HASH)
                 return t_hash_show(m, v);
@@ -1560,9 +1517,7 @@ static int t_show(struct seq_file *m, void *v)
         if (!rec)
                 return 0;
 
-        kallsyms_lookup(rec->ip, NULL, NULL, NULL, str);
-
-        seq_printf(m, "%s\n", str);
+        seq_printf(m, "%pf\n", (void *)rec->ip);
 
         return 0;
 }
@@ -1601,17 +1556,6 @@ ftrace_avail_open(struct inode *inode, struct file *file)
         return ret;
 }
 
-int ftrace_avail_release(struct inode *inode, struct file *file)
-{
-        struct seq_file *m = (struct seq_file *)file->private_data;
-        struct ftrace_iterator *iter = m->private;
-
-        seq_release(inode, file);
-        kfree(iter);
-
-        return 0;
-}
-
 static int
 ftrace_failures_open(struct inode *inode, struct file *file)
 {
@@ -2317,7 +2261,6 @@ ftrace_regex_write(struct file *file, const char __user *ubuf,
         }
 
         if (isspace(ch)) {
-                iter->filtered++;
                 iter->buffer[iter->buffer_idx] = 0;
                 ret = ftrace_process_regex(iter->buffer,
                                            iter->buffer_idx, enable);
@@ -2448,7 +2391,6 @@ ftrace_regex_release(struct inode *inode, struct file *file, int enable)
                 iter = file->private_data;
 
         if (iter->buffer_idx) {
-                iter->filtered++;
                 iter->buffer[iter->buffer_idx] = 0;
                 ftrace_match_records(iter->buffer, iter->buffer_idx, enable);
         }
@@ -2479,14 +2421,14 @@ static const struct file_operations ftrace_avail_fops = {
         .open = ftrace_avail_open,
         .read = seq_read,
         .llseek = seq_lseek,
-        .release = ftrace_avail_release,
+        .release = seq_release_private,
 };
 
 static const struct file_operations ftrace_failures_fops = {
         .open = ftrace_failures_open,
         .read = seq_read,
         .llseek = seq_lseek,
-        .release = ftrace_avail_release,
+        .release = seq_release_private,
 };
 
 static const struct file_operations ftrace_filter_fops = {
@@ -2548,7 +2490,6 @@ static void g_stop(struct seq_file *m, void *p)
 static int g_show(struct seq_file *m, void *v)
 {
         unsigned long *ptr = v;
-        char str[KSYM_SYMBOL_LEN];
 
         if (!ptr)
                 return 0;
@@ -2558,9 +2499,7 @@ static int g_show(struct seq_file *m, void *v)
                 return 0;
         }
 
-        kallsyms_lookup(*ptr, NULL, NULL, NULL, str);
-
-        seq_printf(m, "%s\n", str);
+        seq_printf(m, "%pf\n", v);
 
         return 0;
 }
diff --git a/kernel/trace/kmemtrace.c b/kernel/trace/kmemtrace.c
index 1edaa9516e81..81b1645c8549 100644
--- a/kernel/trace/kmemtrace.c
+++ b/kernel/trace/kmemtrace.c
@@ -183,11 +183,9 @@ static void kmemtrace_stop_probes(void)
 
 static int kmem_trace_init(struct trace_array *tr)
 {
-        int cpu;
         kmemtrace_array = tr;
 
-        for_each_cpu(cpu, cpu_possible_mask)
-                tracing_reset(tr, cpu);
+        tracing_reset_online_cpus(tr);
 
         kmemtrace_start_probes();
 
@@ -239,12 +237,52 @@ struct kmemtrace_user_event_alloc {
 };
 
 static enum print_line_t
-kmemtrace_print_alloc_user(struct trace_iterator *iter,
-                           struct kmemtrace_alloc_entry *entry)
+kmemtrace_print_alloc(struct trace_iterator *iter, int flags)
 {
-        struct kmemtrace_user_event_alloc *ev_alloc;
         struct trace_seq *s = &iter->seq;
+        struct kmemtrace_alloc_entry *entry;
+        int ret;
+
+        trace_assign_type(entry, iter->ent);
+
+        ret = trace_seq_printf(s, "type_id %d call_site %pF ptr %lu "
+            "bytes_req %lu bytes_alloc %lu gfp_flags %lu node %d\n",
+            entry->type_id, (void *)entry->call_site, (unsigned long)entry->ptr,
+            (unsigned long)entry->bytes_req, (unsigned long)entry->bytes_alloc,
+            (unsigned long)entry->gfp_flags, entry->node);
+
+        if (!ret)
+                return TRACE_TYPE_PARTIAL_LINE;
+        return TRACE_TYPE_HANDLED;
+}
+
+static enum print_line_t
+kmemtrace_print_free(struct trace_iterator *iter, int flags)
+{
+        struct trace_seq *s = &iter->seq;
+        struct kmemtrace_free_entry *entry;
+        int ret;
+
+        trace_assign_type(entry, iter->ent);
+
+        ret = trace_seq_printf(s, "type_id %d call_site %pF ptr %lu\n",
+                               entry->type_id, (void *)entry->call_site,
+                               (unsigned long)entry->ptr);
+
+        if (!ret)
+                return TRACE_TYPE_PARTIAL_LINE;
+        return TRACE_TYPE_HANDLED;
+}
+
+static enum print_line_t
+kmemtrace_print_alloc_user(struct trace_iterator *iter, int flags)
+{
+        struct trace_seq *s = &iter->seq;
+        struct kmemtrace_alloc_entry *entry;
         struct kmemtrace_user_event *ev;
+        struct kmemtrace_user_event_alloc *ev_alloc;
+
+        trace_assign_type(entry, iter->ent);
 
         ev = trace_seq_reserve(s, sizeof(*ev));
         if (!ev)
@@ -271,12 +309,14 @@ kmemtrace_print_alloc_user(struct trace_iterator *iter,
 }
 
 static enum print_line_t
-kmemtrace_print_free_user(struct trace_iterator *iter,
-                          struct kmemtrace_free_entry *entry)
+kmemtrace_print_free_user(struct trace_iterator *iter, int flags)
 {
         struct trace_seq *s = &iter->seq;
+        struct kmemtrace_free_entry *entry;
         struct kmemtrace_user_event *ev;
 
+        trace_assign_type(entry, iter->ent);
+
         ev = trace_seq_reserve(s, sizeof(*ev));
         if (!ev)
                 return TRACE_TYPE_PARTIAL_LINE;
@@ -294,12 +334,14 @@ kmemtrace_print_free_user(struct trace_iterator *iter,
 
 /* The two other following provide a more minimalistic output */
 static enum print_line_t
-kmemtrace_print_alloc_compress(struct trace_iterator *iter,
-                                        struct kmemtrace_alloc_entry *entry)
+kmemtrace_print_alloc_compress(struct trace_iterator *iter)
 {
+        struct kmemtrace_alloc_entry *entry;
         struct trace_seq *s = &iter->seq;
         int ret;
 
+        trace_assign_type(entry, iter->ent);
+
         /* Alloc entry */
         ret = trace_seq_printf(s, "  +      ");
         if (!ret)
@@ -345,29 +387,24 @@ kmemtrace_print_alloc_compress(struct trace_iterator *iter,
         if (!ret)
                 return TRACE_TYPE_PARTIAL_LINE;
 
-        /* Node */
-        ret = trace_seq_printf(s, "%4d   ", entry->node);
-        if (!ret)
-                return TRACE_TYPE_PARTIAL_LINE;
-
-        /* Call site */
-        ret = seq_print_ip_sym(s, entry->call_site, 0);
+        /* Node and call site*/
+        ret = trace_seq_printf(s, "%4d   %pf\n", entry->node,
+                                                 (void *)entry->call_site);
         if (!ret)
                 return TRACE_TYPE_PARTIAL_LINE;
 
-        if (!trace_seq_printf(s, "\n"))
-                return TRACE_TYPE_PARTIAL_LINE;
-
         return TRACE_TYPE_HANDLED;
 }
 
 static enum print_line_t
-kmemtrace_print_free_compress(struct trace_iterator *iter,
-                              struct kmemtrace_free_entry *entry)
+kmemtrace_print_free_compress(struct trace_iterator *iter)
 {
+        struct kmemtrace_free_entry *entry;
         struct trace_seq *s = &iter->seq;
         int ret;
 
+        trace_assign_type(entry, iter->ent);
+
         /* Free entry */
         ret = trace_seq_printf(s, "  -      ");
         if (!ret)
@@ -401,19 +438,11 @@ kmemtrace_print_free_compress(struct trace_iterator *iter,
         if (!ret)
                 return TRACE_TYPE_PARTIAL_LINE;
 
-        /* Skip node */
-        ret = trace_seq_printf(s, "       ");
+        /* Skip node and print call site*/
+        ret = trace_seq_printf(s, "       %pf\n", (void *)entry->call_site);
         if (!ret)
                 return TRACE_TYPE_PARTIAL_LINE;
 
-        /* Call site */
-        ret = seq_print_ip_sym(s, entry->call_site, 0);
-        if (!ret)
-                return TRACE_TYPE_PARTIAL_LINE;
-
-        if (!trace_seq_printf(s, "\n"))
-                return TRACE_TYPE_PARTIAL_LINE;
-
         return TRACE_TYPE_HANDLED;
 }
 
@@ -421,32 +450,31 @@ static enum print_line_t kmemtrace_print_line(struct trace_iterator *iter)
 {
         struct trace_entry *entry = iter->ent;
 
-        switch (entry->type) {
-        case TRACE_KMEM_ALLOC: {
-                struct kmemtrace_alloc_entry *field;
-
-                trace_assign_type(field, entry);
-                if (kmem_tracer_flags.val & TRACE_KMEM_OPT_MINIMAL)
-                        return kmemtrace_print_alloc_compress(iter, field);
-                else
-                        return kmemtrace_print_alloc_user(iter, field);
-        }
-
-        case TRACE_KMEM_FREE: {
-                struct kmemtrace_free_entry *field;
-
-                trace_assign_type(field, entry);
-                if (kmem_tracer_flags.val & TRACE_KMEM_OPT_MINIMAL)
-                        return kmemtrace_print_free_compress(iter, field);
-                else
-                        return kmemtrace_print_free_user(iter, field);
-        }
+        if (!(kmem_tracer_flags.val & TRACE_KMEM_OPT_MINIMAL))
+                return TRACE_TYPE_UNHANDLED;
 
+        switch (entry->type) {
+        case TRACE_KMEM_ALLOC:
+                return kmemtrace_print_alloc_compress(iter);
+        case TRACE_KMEM_FREE:
+                return kmemtrace_print_free_compress(iter);
         default:
                 return TRACE_TYPE_UNHANDLED;
         }
 }
 
+static struct trace_event kmem_trace_alloc = {
+        .type                   = TRACE_KMEM_ALLOC,
+        .trace                  = kmemtrace_print_alloc,
+        .binary                 = kmemtrace_print_alloc_user,
+};
+
+static struct trace_event kmem_trace_free = {
+        .type                   = TRACE_KMEM_FREE,
+        .trace                  = kmemtrace_print_free,
+        .binary                 = kmemtrace_print_free_user,
+};
+
 static struct tracer kmem_tracer __read_mostly = {
         .name                   = "kmemtrace",
         .init                   = kmem_trace_init,
@@ -463,6 +491,21 @@ void kmemtrace_init(void)
 
 static int __init init_kmem_tracer(void)
 {
-        return register_tracer(&kmem_tracer);
+        if (!register_ftrace_event(&kmem_trace_alloc)) {
+                pr_warning("Warning: could not register kmem events\n");
+                return 1;
+        }
+
+        if (!register_ftrace_event(&kmem_trace_free)) {
+                pr_warning("Warning: could not register kmem events\n");
+                return 1;
+        }
+
+        if (!register_tracer(&kmem_tracer)) {
+                pr_warning("Warning: could not register the kmem tracer\n");
+                return 1;
+        }
+
+        return 0;
 }
 device_initcall(init_kmem_tracer);
diff --git a/kernel/trace/ring_buffer.c b/kernel/trace/ring_buffer.c
index a330513d96ce..454e74e718cf 100644
--- a/kernel/trace/ring_buffer.c
+++ b/kernel/trace/ring_buffer.c
@@ -218,17 +218,12 @@ enum {
 
 static inline int rb_null_event(struct ring_buffer_event *event)
 {
-        return event->type_len == RINGBUF_TYPE_PADDING
-                        && event->time_delta == 0;
-}
-
-static inline int rb_discarded_event(struct ring_buffer_event *event)
-{
-        return event->type_len == RINGBUF_TYPE_PADDING && event->time_delta;
+        return event->type_len == RINGBUF_TYPE_PADDING && !event->time_delta;
 }
 
 static void rb_event_set_padding(struct ring_buffer_event *event)
 {
+        /* padding has a NULL time_delta */
         event->type_len = RINGBUF_TYPE_PADDING;
         event->time_delta = 0;
 }
@@ -322,6 +317,14 @@ struct buffer_data_page {
         unsigned char    data[];        /* data of buffer page */
 };
 
+/*
+ * Note, the buffer_page list must be first. The buffer pages
+ * are allocated in cache lines, which means that each buffer
+ * page will be at the beginning of a cache line, and thus
+ * the least significant bits will be zero. We use this to
+ * add flags in the list struct pointers, to make the ring buffer
+ * lockless.
+ */
 struct buffer_page {
         struct list_head list;          /* list of buffer pages */
         local_t          write;         /* index for next write */
@@ -330,6 +333,21 @@ struct buffer_page {
         struct buffer_data_page *page;  /* Actual data page */
 };
 
+/*
+ * The buffer page counters, write and entries, must be reset
+ * atomically when crossing page boundaries. To synchronize this
+ * update, two counters are inserted into the number. One is
+ * the actual counter for the write position or count on the page.
+ *
+ * The other is a counter of updaters. Before an update happens
+ * the update partition of the counter is incremented. This will
+ * allow the updater to update the counter atomically.
+ *
+ * The counter is 20 bits, and the state data is 12.
+ */
+#define RB_WRITE_MASK           0xfffff
+#define RB_WRITE_INTCNT         (1 << 20)
+
 static void rb_init_page(struct buffer_data_page *bpage)
 {
         local_set(&bpage->commit, 0);
@@ -403,21 +421,20 @@ int ring_buffer_print_page_header(struct trace_seq *s)
 struct ring_buffer_per_cpu {
         int                             cpu;
         struct ring_buffer              *buffer;
-        spinlock_t                      reader_lock; /* serialize readers */
+        spinlock_t                      reader_lock;    /* serialize readers */
         raw_spinlock_t                  lock;
         struct lock_class_key           lock_key;
-        struct list_head                pages;
+        struct list_head                *pages;
         struct buffer_page              *head_page;     /* read from head */
         struct buffer_page              *tail_page;     /* write to tail */
         struct buffer_page              *commit_page;   /* committed pages */
         struct buffer_page              *reader_page;
-        unsigned long                   nmi_dropped;
-        unsigned long                   commit_overrun;
-        unsigned long                   overrun;
-        unsigned long                   read;
+        local_t                         commit_overrun;
+        local_t                         overrun;
         local_t                         entries;
         local_t                         committing;
         local_t                         commits;
+        unsigned long                   read;
         u64                             write_stamp;
         u64                             read_stamp;
         atomic_t                        record_disabled;
@@ -450,14 +467,19 @@ struct ring_buffer_iter {
 };
 
 /* buffer may be either ring_buffer or ring_buffer_per_cpu */
-#define RB_WARN_ON(buffer, cond)                                \
-        ({                                                      \
-                int _____ret = unlikely(cond);                  \
-                if (_____ret) {                                 \
-                        atomic_inc(&buffer->record_disabled);   \
-                        WARN_ON(1);                             \
-                }                                               \
-                _____ret;                                       \
+#define RB_WARN_ON(b, cond)                                             \
+        ({                                                              \
+                int _____ret = unlikely(cond);                          \
+                if (_____ret) {                                         \
+                        if (__same_type(*(b), struct ring_buffer_per_cpu)) { \
+                                struct ring_buffer_per_cpu *__b =       \
+                                        (void *)b;                      \
+                                atomic_inc(&__b->buffer->record_disabled); \
+                        } else                                          \
+                                atomic_inc(&b->record_disabled);        \
+                        WARN_ON(1);                                     \
+                }                                                       \
+                _____ret;                                               \
         })
 
 /* Up this if you want to test the TIME_EXTENTS and normalization */
@@ -489,6 +511,390 @@ void ring_buffer_normalize_time_stamp(struct ring_buffer *buffer,
 }
 EXPORT_SYMBOL_GPL(ring_buffer_normalize_time_stamp);
 
+/*
+ * Making the ring buffer lockless makes things tricky.
+ * Although writes only happen on the CPU that they are on,
+ * and they only need to worry about interrupts. Reads can
+ * happen on any CPU.
+ *
+ * The reader page is always off the ring buffer, but when the
+ * reader finishes with a page, it needs to swap its page with
+ * a new one from the buffer. The reader needs to take from
+ * the head (writes go to the tail). But if a writer is in overwrite
+ * mode and wraps, it must push the head page forward.
+ *
+ * Here lies the problem.
+ *
+ * The reader must be careful to replace only the head page, and
+ * not another one. As described at the top of the file in the
+ * ASCII art, the reader sets its old page to point to the next
+ * page after head. It then sets the page after head to point to
+ * the old reader page. But if the writer moves the head page
+ * during this operation, the reader could end up with the tail.
+ *
+ * We use cmpxchg to help prevent this race. We also do something
+ * special with the page before head. We set the LSB to 1.
+ *
+ * When the writer must push the page forward, it will clear the
+ * bit that points to the head page, move the head, and then set
+ * the bit that points to the new head page.
+ *
+ * We also don't want an interrupt coming in and moving the head
+ * page on another writer. Thus we use the second LSB to catch
+ * that too. Thus:
+ *
+ * head->list->prev->next        bit 1          bit 0
+ *                              -------        -------
+ * Normal page                     0              0
+ * Points to head page             0              1
+ * New head page                   1              0
+ *
+ * Note we can not trust the prev pointer of the head page, because:
+ *
+ * +----+       +-----+        +-----+
+ * |    |------>|  T  |---X--->|  N  |
+ * |    |<------|     |        |     |
+ * +----+       +-----+        +-----+
+ *   ^                           ^ |
+ *   |          +-----+          | |
+ *   +----------|  R  |----------+ |
+ *              |     |<-----------+
+ *              +-----+
+ *
+ * Key:  ---X-->  HEAD flag set in pointer
+ *         T      Tail page
+ *         R      Reader page
+ *         N      Next page
+ *
+ * (see __rb_reserve_next() to see where this happens)
+ *
+ *  What the above shows is that the reader just swapped out
+ *  the reader page with a page in the buffer, but before it
+ *  could make the new header point back to the new page added
+ *  it was preempted by a writer. The writer moved forward onto
+ *  the new page added by the reader and is about to move forward
+ *  again.
+ *
+ *  You can see, it is legitimate for the previous pointer of
+ *  the head (or any page) not to point back to itself. But only
+ *  temporarially.
+ */
+
+#define RB_PAGE_NORMAL          0UL
+#define RB_PAGE_HEAD            1UL
+#define RB_PAGE_UPDATE          2UL
+
+
+#define RB_FLAG_MASK            3UL
+
+/* PAGE_MOVED is not part of the mask */
+#define RB_PAGE_MOVED           4UL
+
+/*
+ * rb_list_head - remove any bit
+ */
+static struct list_head *rb_list_head(struct list_head *list)
+{
+        unsigned long val = (unsigned long)list;
+
+        return (struct list_head *)(val & ~RB_FLAG_MASK);
+}
+
+/*
+ * rb_is_head_page - test if the give page is the head page
+ *
+ * Because the reader may move the head_page pointer, we can
+ * not trust what the head page is (it may be pointing to
+ * the reader page). But if the next page is a header page,
+ * its flags will be non zero.
+ */
+static int inline
+rb_is_head_page(struct ring_buffer_per_cpu *cpu_buffer,
+                struct buffer_page *page, struct list_head *list)
+{
+        unsigned long val;
+
+        val = (unsigned long)list->next;
+
+        if ((val & ~RB_FLAG_MASK) != (unsigned long)&page->list)
+                return RB_PAGE_MOVED;
+
+        return val & RB_FLAG_MASK;
+}
+
+/*
+ * rb_is_reader_page
+ *
+ * The unique thing about the reader page, is that, if the
+ * writer is ever on it, the previous pointer never points
+ * back to the reader page.
+ */
+static int rb_is_reader_page(struct buffer_page *page)
+{
+        struct list_head *list = page->list.prev;
+
+        return rb_list_head(list->next) != &page->list;
+}
+
+/*
+ * rb_set_list_to_head - set a list_head to be pointing to head.
+ */
+static void rb_set_list_to_head(struct ring_buffer_per_cpu *cpu_buffer,
+                                struct list_head *list)
+{
+        unsigned long *ptr;
+
+        ptr = (unsigned long *)&list->next;
+        *ptr |= RB_PAGE_HEAD;
+        *ptr &= ~RB_PAGE_UPDATE;
+}
+
+/*
+ * rb_head_page_activate - sets up head page
+ */
+static void rb_head_page_activate(struct ring_buffer_per_cpu *cpu_buffer)
+{
+        struct buffer_page *head;
+
+        head = cpu_buffer->head_page;
+        if (!head)
+                return;
+
+        /*
+         * Set the previous list pointer to have the HEAD flag.
+         */
+        rb_set_list_to_head(cpu_buffer, head->list.prev);
+}
+
+static void rb_list_head_clear(struct list_head *list)
+{
+        unsigned long *ptr = (unsigned long *)&list->next;
+
+        *ptr &= ~RB_FLAG_MASK;
+}
+
+/*
+ * rb_head_page_dactivate - clears head page ptr (for free list)
+ */
+static void
+rb_head_page_deactivate(struct ring_buffer_per_cpu *cpu_buffer)
+{
+        struct list_head *hd;
+
+        /* Go through the whole list and clear any pointers found. */
+        rb_list_head_clear(cpu_buffer->pages);
+
+        list_for_each(hd, cpu_buffer->pages)
+                rb_list_head_clear(hd);
+}
+
+static int rb_head_page_set(struct ring_buffer_per_cpu *cpu_buffer,
+                            struct buffer_page *head,
+                            struct buffer_page *prev,
+                            int old_flag, int new_flag)
+{
+        struct list_head *list;
+        unsigned long val = (unsigned long)&head->list;
+        unsigned long ret;
+
+        list = &prev->list;
+
+        val &= ~RB_FLAG_MASK;
+
+        ret = (unsigned long)cmpxchg(&list->next,
+                                     val | old_flag, val | new_flag);
+
+        /* check if the reader took the page */
+        if ((ret & ~RB_FLAG_MASK) != val)
+                return RB_PAGE_MOVED;
+
+        return ret & RB_FLAG_MASK;
+}
+
+static int rb_head_page_set_update(struct ring_buffer_per_cpu *cpu_buffer,
+                                   struct buffer_page *head,
+                                   struct buffer_page *prev,
+                                   int old_flag)
+{
+        return rb_head_page_set(cpu_buffer, head, prev,
+                                old_flag, RB_PAGE_UPDATE);
+}
+
+static int rb_head_page_set_head(struct ring_buffer_per_cpu *cpu_buffer,
+                                 struct buffer_page *head,
+                                 struct buffer_page *prev,
+                                 int old_flag)
+{
+        return rb_head_page_set(cpu_buffer, head, prev,
+                                old_flag, RB_PAGE_HEAD);
+}
+
+static int rb_head_page_set_normal(struct ring_buffer_per_cpu *cpu_buffer,
+                                   struct buffer_page *head,
+                                   struct buffer_page *prev,
+                                   int old_flag)
+{
+        return rb_head_page_set(cpu_buffer, head, prev,
+                                old_flag, RB_PAGE_NORMAL);
+}
+
+static inline void rb_inc_page(struct ring_buffer_per_cpu *cpu_buffer,
+                               struct buffer_page **bpage)
+{
+        struct list_head *p = rb_list_head((*bpage)->list.next);
+
+        *bpage = list_entry(p, struct buffer_page, list);
+}
+
+static struct buffer_page *
+rb_set_head_page(struct ring_buffer_per_cpu *cpu_buffer)
+{
+        struct buffer_page *head;
+        struct buffer_page *page;
+        struct list_head *list;
+        int i;
+
+        if (RB_WARN_ON(cpu_buffer, !cpu_buffer->head_page))
+                return NULL;
+
+        /* sanity check */
+        list = cpu_buffer->pages;
+        if (RB_WARN_ON(cpu_buffer, rb_list_head(list->prev->next) != list))
+                return NULL;
+
+        page = head = cpu_buffer->head_page;
+        /*
+         * It is possible that the writer moves the header behind
+         * where we started, and we miss in one loop.
+         * A second loop should grab the header, but we'll do
+         * three loops just because I'm paranoid.
+         */
+        for (i = 0; i < 3; i++) {
+                do {
+                        if (rb_is_head_page(cpu_buffer, page, page->list.prev)) {
+                                cpu_buffer->head_page = page;
+                                return page;
+                        }
+                        rb_inc_page(cpu_buffer, &page);
+                } while (page != head);
+        }
+
+        RB_WARN_ON(cpu_buffer, 1);
+
+        return NULL;
+}
+
+static int rb_head_page_replace(struct buffer_page *old,
+                                struct buffer_page *new)
+{
+        unsigned long *ptr = (unsigned long *)&old->list.prev->next;
+        unsigned long val;
+        unsigned long ret;
+
+        val = *ptr & ~RB_FLAG_MASK;
+        val |= RB_PAGE_HEAD;
+
+        ret = cmpxchg(ptr, val, &new->list);
+
+        return ret == val;
+}
+
+/*
+ * rb_tail_page_update - move the tail page forward
+ *
+ * Returns 1 if moved tail page, 0 if someone else did.
+ */
+static int rb_tail_page_update(struct ring_buffer_per_cpu *cpu_buffer,
+                               struct buffer_page *tail_page,
+                               struct buffer_page *next_page)
+{
+        struct buffer_page *old_tail;
+        unsigned long old_entries;
+        unsigned long old_write;
+        int ret = 0;
+
+        /*
+         * The tail page now needs to be moved forward.
+         *
+         * We need to reset the tail page, but without messing
+         * with possible erasing of data brought in by interrupts
+         * that have moved the tail page and are currently on it.
+         *
+         * We add a counter to the write field to denote this.
+         */
+        old_write = local_add_return(RB_WRITE_INTCNT, &next_page->write);
+        old_entries = local_add_return(RB_WRITE_INTCNT, &next_page->entries);
+
+        /*
+         * Just make sure we have seen our old_write and synchronize
+         * with any interrupts that come in.
+         */
+        barrier();
+
+        /*
+         * If the tail page is still the same as what we think
+         * it is, then it is up to us to update the tail
+         * pointer.
+         */
+        if (tail_page == cpu_buffer->tail_page) {
+                /* Zero the write counter */
+                unsigned long val = old_write & ~RB_WRITE_MASK;
+                unsigned long eval = old_entries & ~RB_WRITE_MASK;
+
+                /*
+                 * This will only succeed if an interrupt did
+                 * not come in and change it. In which case, we
+                 * do not want to modify it.
+                 *
+                 * We add (void) to let the compiler know that we do not care
+                 * about the return value of these functions. We use the
+                 * cmpxchg to only update if an interrupt did not already
+                 * do it for us. If the cmpxchg fails, we don't care.
+                 */
+                (void)local_cmpxchg(&next_page->write, old_write, val);
+                (void)local_cmpxchg(&next_page->entries, old_entries, eval);
+
+                /*
+                 * No need to worry about races with clearing out the commit.
+                 * it only can increment when a commit takes place. But that
+                 * only happens in the outer most nested commit.
+                 */
+                local_set(&next_page->page->commit, 0);
+
+                old_tail = cmpxchg(&cpu_buffer->tail_page,
+                                   tail_page, next_page);
+
+                if (old_tail == tail_page)
+                        ret = 1;
+        }
+
+        return ret;
+}
+
+static int rb_check_bpage(struct ring_buffer_per_cpu *cpu_buffer,
+                          struct buffer_page *bpage)
+{
+        unsigned long val = (unsigned long)bpage;
+
+        if (RB_WARN_ON(cpu_buffer, val & RB_FLAG_MASK))
+                return 1;
+
+        return 0;
+}
+
+/**
+ * rb_check_list - make sure a pointer to a list has the last bits zero
+ */
+static int rb_check_list(struct ring_buffer_per_cpu *cpu_buffer,
+                         struct list_head *list)
+{
+        if (RB_WARN_ON(cpu_buffer, rb_list_head(list->prev) != list->prev))
+                return 1;
+        if (RB_WARN_ON(cpu_buffer, rb_list_head(list->next) != list->next))
+                return 1;
+        return 0;
+}
+
 /**
  * check_pages - integrity check of buffer pages
  * @cpu_buffer: CPU buffer with pages to test
@@ -498,14 +904,19 @@ EXPORT_SYMBOL_GPL(ring_buffer_normalize_time_stamp);
  */
 static int rb_check_pages(struct ring_buffer_per_cpu *cpu_buffer)
 {
-        struct list_head *head = &cpu_buffer->pages;
+        struct list_head *head = cpu_buffer->pages;
         struct buffer_page *bpage, *tmp;
 
+        rb_head_page_deactivate(cpu_buffer);
+
         if (RB_WARN_ON(cpu_buffer, head->next->prev != head))
                 return -1;
         if (RB_WARN_ON(cpu_buffer, head->prev->next != head))
                 return -1;
 
+        if (rb_check_list(cpu_buffer, head))
+                return -1;
+
         list_for_each_entry_safe(bpage, tmp, head, list) {
                 if (RB_WARN_ON(cpu_buffer,
                                bpage->list.next->prev != &bpage->list))
@@ -513,25 +924,33 @@ static int rb_check_pages(struct ring_buffer_per_cpu *cpu_buffer)
                 if (RB_WARN_ON(cpu_buffer,
                                bpage->list.prev->next != &bpage->list))
                         return -1;
+                if (rb_check_list(cpu_buffer, &bpage->list))
+                        return -1;
         }
 
+        rb_head_page_activate(cpu_buffer);
+
         return 0;
 }
 
 static int rb_allocate_pages(struct ring_buffer_per_cpu *cpu_buffer,
                              unsigned nr_pages)
 {
-        struct list_head *head = &cpu_buffer->pages;
         struct buffer_page *bpage, *tmp;
         unsigned long addr;
         LIST_HEAD(pages);
         unsigned i;
 
+        WARN_ON(!nr_pages);
+
         for (i = 0; i < nr_pages; i++) {
                 bpage = kzalloc_node(ALIGN(sizeof(*bpage), cache_line_size()),
                                     GFP_KERNEL, cpu_to_node(cpu_buffer->cpu));
                 if (!bpage)
                         goto free_pages;
+
+                rb_check_bpage(cpu_buffer, bpage);
+
                 list_add(&bpage->list, &pages);
 
                 addr = __get_free_page(GFP_KERNEL);
@@ -541,7 +960,13 @@ static int rb_allocate_pages(struct ring_buffer_per_cpu *cpu_buffer,
                 rb_init_page(bpage->page);
         }
 
-        list_splice(&pages, head);
+        /*
+         * The ring buffer page list is a circular list that does not
+         * start and end with a list head. All page list items point to
+         * other pages.
+         */
+        cpu_buffer->pages = pages.next;
+        list_del(&pages);
 
         rb_check_pages(cpu_buffer);
 
@@ -573,13 +998,14 @@ rb_allocate_cpu_buffer(struct ring_buffer *buffer, int cpu)
         spin_lock_init(&cpu_buffer->reader_lock);
         lockdep_set_class(&cpu_buffer->reader_lock, buffer->reader_lock_key);
         cpu_buffer->lock = (raw_spinlock_t)__RAW_SPIN_LOCK_UNLOCKED;
-        INIT_LIST_HEAD(&cpu_buffer->pages);
 
         bpage = kzalloc_node(ALIGN(sizeof(*bpage), cache_line_size()),
                             GFP_KERNEL, cpu_to_node(cpu));
         if (!bpage)
                 goto fail_free_buffer;
 
+        rb_check_bpage(cpu_buffer, bpage);
+
         cpu_buffer->reader_page = bpage;
         addr = __get_free_page(GFP_KERNEL);
         if (!addr)
@@ -594,9 +1020,11 @@ rb_allocate_cpu_buffer(struct ring_buffer *buffer, int cpu)
                 goto fail_free_reader;
 
         cpu_buffer->head_page
-                = list_entry(cpu_buffer->pages.next, struct buffer_page, list);
+                = list_entry(cpu_buffer->pages, struct buffer_page, list);
         cpu_buffer->tail_page = cpu_buffer->commit_page = cpu_buffer->head_page;
 
+        rb_head_page_activate(cpu_buffer);
+
         return cpu_buffer;
 
  fail_free_reader:
@@ -609,15 +1037,22 @@ rb_allocate_cpu_buffer(struct ring_buffer *buffer, int cpu)
 
 static void rb_free_cpu_buffer(struct ring_buffer_per_cpu *cpu_buffer)
 {
-        struct list_head *head = &cpu_buffer->pages;
+        struct list_head *head = cpu_buffer->pages;
         struct buffer_page *bpage, *tmp;
 
         free_buffer_page(cpu_buffer->reader_page);
 
-        list_for_each_entry_safe(bpage, tmp, head, list) {
-                list_del_init(&bpage->list);
+        rb_head_page_deactivate(cpu_buffer);
+
+        if (head) {
+                list_for_each_entry_safe(bpage, tmp, head, list) {
+                        list_del_init(&bpage->list);
+                        free_buffer_page(bpage);
+                }
+                bpage = list_entry(head, struct buffer_page, list);
                 free_buffer_page(bpage);
         }
+
         kfree(cpu_buffer);
 }
 
@@ -760,15 +1195,17 @@ rb_remove_pages(struct ring_buffer_per_cpu *cpu_buffer, unsigned nr_pages)
         atomic_inc(&cpu_buffer->record_disabled);
         synchronize_sched();
 
+        rb_head_page_deactivate(cpu_buffer);
+
         for (i = 0; i < nr_pages; i++) {
-                if (RB_WARN_ON(cpu_buffer, list_empty(&cpu_buffer->pages)))
+                if (RB_WARN_ON(cpu_buffer, list_empty(cpu_buffer->pages)))
                         return;
-                p = cpu_buffer->pages.next;
+                p = cpu_buffer->pages->next;
                 bpage = list_entry(p, struct buffer_page, list);
                 list_del_init(&bpage->list);
                 free_buffer_page(bpage);
         }
-        if (RB_WARN_ON(cpu_buffer, list_empty(&cpu_buffer->pages)))
+        if (RB_WARN_ON(cpu_buffer, list_empty(cpu_buffer->pages)))
                 return;
 
         rb_reset_cpu(cpu_buffer);
@@ -790,15 +1227,19 @@ rb_insert_pages(struct ring_buffer_per_cpu *cpu_buffer,
         atomic_inc(&cpu_buffer->record_disabled);
         synchronize_sched();
 
+        spin_lock_irq(&cpu_buffer->reader_lock);
+        rb_head_page_deactivate(cpu_buffer);
+
         for (i = 0; i < nr_pages; i++) {
                 if (RB_WARN_ON(cpu_buffer, list_empty(pages)))
                         return;
                 p = pages->next;
                 bpage = list_entry(p, struct buffer_page, list);
                 list_del_init(&bpage->list);
-                list_add_tail(&bpage->list, &cpu_buffer->pages);
+                list_add_tail(&bpage->list, cpu_buffer->pages);
         }
         rb_reset_cpu(cpu_buffer);
+        spin_unlock_irq(&cpu_buffer->reader_lock);
 
         rb_check_pages(cpu_buffer);
 
@@ -949,21 +1390,14 @@ rb_reader_event(struct ring_buffer_per_cpu *cpu_buffer)
 }
 
 static inline struct ring_buffer_event *
-rb_head_event(struct ring_buffer_per_cpu *cpu_buffer)
-{
-        return __rb_page_index(cpu_buffer->head_page,
-                               cpu_buffer->head_page->read);
-}
-
-static inline struct ring_buffer_event *
 rb_iter_head_event(struct ring_buffer_iter *iter)
 {
         return __rb_page_index(iter->head_page, iter->head);
 }
 
-static inline unsigned rb_page_write(struct buffer_page *bpage)
+static inline unsigned long rb_page_write(struct buffer_page *bpage)
 {
-        return local_read(&bpage->write);
+        return local_read(&bpage->write) & RB_WRITE_MASK;
 }
 
 static inline unsigned rb_page_commit(struct buffer_page *bpage)
@@ -971,6 +1405,11 @@ static inline unsigned rb_page_commit(struct buffer_page *bpage)
         return local_read(&bpage->page->commit);
 }
 
+static inline unsigned long rb_page_entries(struct buffer_page *bpage)
+{
+        return local_read(&bpage->entries) & RB_WRITE_MASK;
+}
+
 /* Size is determined by what has been commited */
 static inline unsigned rb_page_size(struct buffer_page *bpage)
 {
@@ -983,22 +1422,6 @@ rb_commit_index(struct ring_buffer_per_cpu *cpu_buffer)
         return rb_page_commit(cpu_buffer->commit_page);
 }
 
-static inline unsigned rb_head_size(struct ring_buffer_per_cpu *cpu_buffer)
-{
-        return rb_page_commit(cpu_buffer->head_page);
-}
-
-static inline void rb_inc_page(struct ring_buffer_per_cpu *cpu_buffer,
-                               struct buffer_page **bpage)
-{
-        struct list_head *p = (*bpage)->list.next;
-
-        if (p == &cpu_buffer->pages)
-                p = p->next;
-
-        *bpage = list_entry(p, struct buffer_page, list);
-}
-
 static inline unsigned
 rb_event_index(struct ring_buffer_event *event)
 {
@@ -1024,6 +1447,8 @@ rb_event_is_commit(struct ring_buffer_per_cpu *cpu_buffer,
 static void
 rb_set_commit_to_write(struct ring_buffer_per_cpu *cpu_buffer)
 {
+        unsigned long max_count;
+
         /*
          * We only race with interrupts and NMIs on this CPU.
          * If we own the commit event, then we can commit
@@ -1033,9 +1458,16 @@ rb_set_commit_to_write(struct ring_buffer_per_cpu *cpu_buffer)
          * assign the commit to the tail.
          */
  again:
+        max_count = cpu_buffer->buffer->pages * 100;
+
         while (cpu_buffer->commit_page != cpu_buffer->tail_page) {
-                cpu_buffer->commit_page->page->commit =
-                        cpu_buffer->commit_page->write;
+                if (RB_WARN_ON(cpu_buffer, !(--max_count)))
+                        return;
+                if (RB_WARN_ON(cpu_buffer,
+                               rb_is_reader_page(cpu_buffer->tail_page)))
+                        return;
+                local_set(&cpu_buffer->commit_page->page->commit,
+                          rb_page_write(cpu_buffer->commit_page));
                 rb_inc_page(cpu_buffer, &cpu_buffer->commit_page);
                 cpu_buffer->write_stamp =
                         cpu_buffer->commit_page->page->time_stamp;
@@ -1044,8 +1476,12 @@ rb_set_commit_to_write(struct ring_buffer_per_cpu *cpu_buffer)
         }
         while (rb_commit_index(cpu_buffer) !=
                rb_page_write(cpu_buffer->commit_page)) {
-                cpu_buffer->commit_page->page->commit =
-                        cpu_buffer->commit_page->write;
+
+                local_set(&cpu_buffer->commit_page->page->commit,
+                          rb_page_write(cpu_buffer->commit_page));
+                RB_WARN_ON(cpu_buffer,
+                           local_read(&cpu_buffer->commit_page->page->commit) &
+                           ~RB_WRITE_MASK);
                 barrier();
         }
 
@@ -1078,7 +1514,7 @@ static void rb_inc_iter(struct ring_buffer_iter *iter)
          * to the head page instead of next.
          */
         if (iter->head_page == cpu_buffer->reader_page)
-                iter->head_page = cpu_buffer->head_page;
+                iter->head_page = rb_set_head_page(cpu_buffer);
         else
                 rb_inc_page(cpu_buffer, &iter->head_page);
 
@@ -1122,6 +1558,163 @@ rb_update_event(struct ring_buffer_event *event,
         }
 }
 
+/*
+ * rb_handle_head_page - writer hit the head page
+ *
+ * Returns: +1 to retry page
+ *           0 to continue
+ *          -1 on error
+ */
+static int
+rb_handle_head_page(struct ring_buffer_per_cpu *cpu_buffer,
+                    struct buffer_page *tail_page,
+                    struct buffer_page *next_page)
+{
+        struct buffer_page *new_head;
+        int entries;
+        int type;
+        int ret;
+
+        entries = rb_page_entries(next_page);
+
+        /*
+         * The hard part is here. We need to move the head
+         * forward, and protect against both readers on
+         * other CPUs and writers coming in via interrupts.
+         */
+        type = rb_head_page_set_update(cpu_buffer, next_page, tail_page,
+                                       RB_PAGE_HEAD);
+
+        /*
+         * type can be one of four:
+         *  NORMAL - an interrupt already moved it for us
+         *  HEAD   - we are the first to get here.
+         *  UPDATE - we are the interrupt interrupting
+         *           a current move.
+         *  MOVED  - a reader on another CPU moved the next
+         *           pointer to its reader page. Give up
+         *           and try again.
+         */
+
+        switch (type) {
+        case RB_PAGE_HEAD:
+                /*
+                 * We changed the head to UPDATE, thus
+                 * it is our responsibility to update
+                 * the counters.
+                 */
+                local_add(entries, &cpu_buffer->overrun);
+
+                /*
+                 * The entries will be zeroed out when we move the
+                 * tail page.
+                 */
+
+                /* still more to do */
+                break;
+
+        case RB_PAGE_UPDATE:
+                /*
+                 * This is an interrupt that interrupt the
+                 * previous update. Still more to do.
+                 */
+                break;
+        case RB_PAGE_NORMAL:
+                /*
+                 * An interrupt came in before the update
+                 * and processed this for us.
+                 * Nothing left to do.
+                 */
+                return 1;
+        case RB_PAGE_MOVED:
+                /*
+                 * The reader is on another CPU and just did
+                 * a swap with our next_page.
+                 * Try again.
+                 */
+                return 1;
+        default:
+                RB_WARN_ON(cpu_buffer, 1); /* WTF??? */
+                return -1;
+        }
+
+        /*
+         * Now that we are here, the old head pointer is
+         * set to UPDATE. This will keep the reader from
+         * swapping the head page with the reader page.
+         * The reader (on another CPU) will spin till
+         * we are finished.
+         *
+         * We just need to protect against interrupts
+         * doing the job. We will set the next pointer
+         * to HEAD. After that, we set the old pointer
+         * to NORMAL, but only if it was HEAD before.
+         * otherwise we are an interrupt, and only
+         * want the outer most commit to reset it.
+         */
+        new_head = next_page;
+        rb_inc_page(cpu_buffer, &new_head);
+
+        ret = rb_head_page_set_head(cpu_buffer, new_head, next_page,
+                                    RB_PAGE_NORMAL);
+
+        /*
+         * Valid returns are:
+         *  HEAD   - an interrupt came in and already set it.
+         *  NORMAL - One of two things:
+         *            1) We really set it.
+         *            2) A bunch of interrupts came in and moved
+         *               the page forward again.
+         */
+        switch (ret) {
+        case RB_PAGE_HEAD:
+        case RB_PAGE_NORMAL:
+                /* OK */
+                break;
+        default:
+                RB_WARN_ON(cpu_buffer, 1);
+                return -1;
+        }
+
+        /*
+         * It is possible that an interrupt came in,
+         * set the head up, then more interrupts came in
+         * and moved it again. When we get back here,
+         * the page would have been set to NORMAL but we
+         * just set it back to HEAD.
+         *
+         * How do you detect this? Well, if that happened
+         * the tail page would have moved.
+         */
+        if (ret == RB_PAGE_NORMAL) {
+                /*
+                 * If the tail had moved passed next, then we need
+                 * to reset the pointer.
+                 */
+                if (cpu_buffer->tail_page != tail_page &&
+                    cpu_buffer->tail_page != next_page)
+                        rb_head_page_set_normal(cpu_buffer, new_head,
+                                                next_page,
+                                                RB_PAGE_HEAD);
+        }
+
+        /*
+         * If this was the outer most commit (the one that
+         * changed the original pointer from HEAD to UPDATE),
+         * then it is up to us to reset it to NORMAL.
+         */
+        if (type == RB_PAGE_HEAD) {
+                ret = rb_head_page_set_normal(cpu_buffer, next_page,
+                                              tail_page,
+                                              RB_PAGE_UPDATE);
+                if (RB_WARN_ON(cpu_buffer,
+                               ret != RB_PAGE_UPDATE))
+                        return -1;
+        }
+
+        return 0;
+}
+
 static unsigned rb_calculate_event_length(unsigned length)
 {
         struct ring_buffer_event event; /* Used only for sizeof array */
@@ -1185,9 +1778,6 @@ rb_reset_tail(struct ring_buffer_per_cpu *cpu_buffer,
         event->type_len = RINGBUF_TYPE_PADDING;
         /* time delta must be non zero */
         event->time_delta = 1;
-        /* Account for this as an entry */
-        local_inc(&tail_page->entries);
-        local_inc(&cpu_buffer->entries);
 
         /* Set write to end of buffer */
         length = (tail + length) - BUF_PAGE_SIZE;
@@ -1200,96 +1790,93 @@ rb_move_tail(struct ring_buffer_per_cpu *cpu_buffer,
              struct buffer_page *commit_page,
              struct buffer_page *tail_page, u64 *ts)
 {
-        struct buffer_page *next_page, *head_page, *reader_page;
         struct ring_buffer *buffer = cpu_buffer->buffer;
-        bool lock_taken = false;
-        unsigned long flags;
+        struct buffer_page *next_page;
+        int ret;
 
         next_page = tail_page;
 
-        local_irq_save(flags);
-        /*
-         * Since the write to the buffer is still not
-         * fully lockless, we must be careful with NMIs.
-         * The locks in the writers are taken when a write
-         * crosses to a new page. The locks protect against
-         * races with the readers (this will soon be fixed
-         * with a lockless solution).
-         *
-         * Because we can not protect against NMIs, and we
-         * want to keep traces reentrant, we need to manage
-         * what happens when we are in an NMI.
-         *
-         * NMIs can happen after we take the lock.
-         * If we are in an NMI, only take the lock
-         * if it is not already taken. Otherwise
-         * simply fail.
-         */
-        if (unlikely(in_nmi())) {
-                if (!__raw_spin_trylock(&cpu_buffer->lock)) {
-                        cpu_buffer->nmi_dropped++;
-                        goto out_reset;
-                }
-        } else
-                __raw_spin_lock(&cpu_buffer->lock);
-
-        lock_taken = true;
-
         rb_inc_page(cpu_buffer, &next_page);
 
-        head_page = cpu_buffer->head_page;
-        reader_page = cpu_buffer->reader_page;
-
-        /* we grabbed the lock before incrementing */
-        if (RB_WARN_ON(cpu_buffer, next_page == reader_page))
-                goto out_reset;
-
         /*
          * If for some reason, we had an interrupt storm that made
          * it all the way around the buffer, bail, and warn
          * about it.
          */
         if (unlikely(next_page == commit_page)) {
-                cpu_buffer->commit_overrun++;
+                local_inc(&cpu_buffer->commit_overrun);
                 goto out_reset;
         }
 
-        if (next_page == head_page) {
-                if (!(buffer->flags & RB_FL_OVERWRITE))
-                        goto out_reset;
-
-                /* tail_page has not moved yet? */
-                if (tail_page == cpu_buffer->tail_page) {
-                        /* count overflows */
-                        cpu_buffer->overrun +=
-                                local_read(&head_page->entries);
+        /*
+         * This is where the fun begins!
+         *
+         * We are fighting against races between a reader that
+         * could be on another CPU trying to swap its reader
+         * page with the buffer head.
+         *
+         * We are also fighting against interrupts coming in and
+         * moving the head or tail on us as well.
+         *
+         * If the next page is the head page then we have filled
+         * the buffer, unless the commit page is still on the
+         * reader page.
+         */
+        if (rb_is_head_page(cpu_buffer, next_page, &tail_page->list)) {
 
-                        rb_inc_page(cpu_buffer, &head_page);
-                        cpu_buffer->head_page = head_page;
-                        cpu_buffer->head_page->read = 0;
+                /*
+                 * If the commit is not on the reader page, then
+                 * move the header page.
+                 */
+                if (!rb_is_reader_page(cpu_buffer->commit_page)) {
+                        /*
+                         * If we are not in overwrite mode,
+                         * this is easy, just stop here.
+                         */
+                        if (!(buffer->flags & RB_FL_OVERWRITE))
+                                goto out_reset;
+
+                        ret = rb_handle_head_page(cpu_buffer,
+                                                  tail_page,
+                                                  next_page);
+                        if (ret < 0)
+                                goto out_reset;
+                        if (ret)
+                                goto out_again;
+                } else {
+                        /*
+                         * We need to be careful here too. The
+                         * commit page could still be on the reader
+                         * page. We could have a small buffer, and
+                         * have filled up the buffer with events
+                         * from interrupts and such, and wrapped.
+                         *
+                         * Note, if the tail page is also the on the
+                         * reader_page, we let it move out.
+                         */
+                        if (unlikely((cpu_buffer->commit_page !=
+                                      cpu_buffer->tail_page) &&
+                                     (cpu_buffer->commit_page ==
+                                      cpu_buffer->reader_page))) {
+                                local_inc(&cpu_buffer->commit_overrun);
+                                goto out_reset;
+                        }
                 }
         }
 
-        /*
-         * If the tail page is still the same as what we think
-         * it is, then it is up to us to update the tail
-         * pointer.
-         */
-        if (tail_page == cpu_buffer->tail_page) {
-                local_set(&next_page->write, 0);
-                local_set(&next_page->entries, 0);
-                local_set(&next_page->page->commit, 0);
-                cpu_buffer->tail_page = next_page;
-
-                /* reread the time stamp */
+        ret = rb_tail_page_update(cpu_buffer, tail_page, next_page);
+        if (ret) {
+                /*
+                 * Nested commits always have zero deltas, so
+                 * just reread the time stamp
+                 */
                 *ts = rb_time_stamp(buffer, cpu_buffer->cpu);
-                cpu_buffer->tail_page->page->time_stamp = *ts;
+                next_page->page->time_stamp = *ts;
         }
 
-        rb_reset_tail(cpu_buffer, tail_page, tail, length);
+ out_again:
 
-        __raw_spin_unlock(&cpu_buffer->lock);
-        local_irq_restore(flags);
+        rb_reset_tail(cpu_buffer, tail_page, tail, length);
 
         /* fail and let the caller try again */
         return ERR_PTR(-EAGAIN);
@@ -1298,9 +1885,6 @@ rb_move_tail(struct ring_buffer_per_cpu *cpu_buffer,
         /* reset write */
         rb_reset_tail(cpu_buffer, tail_page, tail, length);
 
-        if (likely(lock_taken))
-                __raw_spin_unlock(&cpu_buffer->lock);
-        local_irq_restore(flags);
         return NULL;
 }
 
@@ -1317,6 +1901,9 @@ __rb_reserve_next(struct ring_buffer_per_cpu *cpu_buffer,
         barrier();
         tail_page = cpu_buffer->tail_page;
         write = local_add_return(length, &tail_page->write);
+
+        /* set write to only the index of the write */
+        write &= RB_WRITE_MASK;
         tail = write - length;
 
         /* See if we shot pass the end of this buffer page */
@@ -1361,12 +1948,16 @@ rb_try_to_discard(struct ring_buffer_per_cpu *cpu_buffer,
         bpage = cpu_buffer->tail_page;
 
         if (bpage->page == (void *)addr && rb_page_write(bpage) == old_index) {
+                unsigned long write_mask =
+                        local_read(&bpage->write) & ~RB_WRITE_MASK;
                 /*
                  * This is on the tail page. It is possible that
                  * a write could come in and move the tail page
                  * and write to the next page. That is fine
                  * because we just shorten what is on this page.
                  */
+                old_index += write_mask;
+                new_index += write_mask;
                 index = local_cmpxchg(&bpage->write, old_index, new_index);
                 if (index == old_index)
                         return 1;
@@ -1482,7 +2073,8 @@ static void rb_end_commit(struct ring_buffer_per_cpu *cpu_buffer)
 }
 
 static struct ring_buffer_event *
-rb_reserve_next_event(struct ring_buffer_per_cpu *cpu_buffer,
+rb_reserve_next_event(struct ring_buffer *buffer,
+                      struct ring_buffer_per_cpu *cpu_buffer,
                       unsigned long length)
 {
         struct ring_buffer_event *event;
@@ -1492,6 +2084,21 @@ rb_reserve_next_event(struct ring_buffer_per_cpu *cpu_buffer,
 
         rb_start_commit(cpu_buffer);
 
+#ifdef CONFIG_RING_BUFFER_ALLOW_SWAP
+        /*
+         * Due to the ability to swap a cpu buffer from a buffer
+         * it is possible it was swapped before we committed.
+         * (committing stops a swap). We check for it here and
+         * if it happened, we have to fail the write.
+         */
+        barrier();
+        if (unlikely(ACCESS_ONCE(cpu_buffer->buffer) != buffer)) {
+                local_dec(&cpu_buffer->committing);
+                local_dec(&cpu_buffer->commits);
+                return NULL;
+        }
+#endif
+
         length = rb_calculate_event_length(length);
  again:
         /*
@@ -1652,7 +2259,7 @@ ring_buffer_lock_reserve(struct ring_buffer *buffer, unsigned long length)
         if (length > BUF_MAX_DATA_SIZE)
                 goto out;
 
-        event = rb_reserve_next_event(cpu_buffer, length);
+        event = rb_reserve_next_event(buffer, cpu_buffer, length);
         if (!event)
                 goto out;
 
@@ -1675,18 +2282,23 @@ ring_buffer_lock_reserve(struct ring_buffer *buffer, unsigned long length)
 }
 EXPORT_SYMBOL_GPL(ring_buffer_lock_reserve);
 
-static void rb_commit(struct ring_buffer_per_cpu *cpu_buffer,
+static void
+rb_update_write_stamp(struct ring_buffer_per_cpu *cpu_buffer,
                       struct ring_buffer_event *event)
 {
-        local_inc(&cpu_buffer->entries);
-
         /*
          * The event first in the commit queue updates the
          * time stamp.
          */
         if (rb_event_is_commit(cpu_buffer, event))
                 cpu_buffer->write_stamp += event->time_delta;
+}
 
+static void rb_commit(struct ring_buffer_per_cpu *cpu_buffer,
+                      struct ring_buffer_event *event)
+{
+        local_inc(&cpu_buffer->entries);
+        rb_update_write_stamp(cpu_buffer, event);
         rb_end_commit(cpu_buffer);
 }
 
@@ -1733,32 +2345,57 @@ static inline void rb_event_discard(struct ring_buffer_event *event)
                 event->time_delta = 1;
 }
 
-/**
- * ring_buffer_event_discard - discard any event in the ring buffer
- * @event: the event to discard
- *
- * Sometimes a event that is in the ring buffer needs to be ignored.
- * This function lets the user discard an event in the ring buffer
- * and then that event will not be read later.
- *
- * Note, it is up to the user to be careful with this, and protect
- * against races. If the user discards an event that has been consumed
- * it is possible that it could corrupt the ring buffer.
+/*
+ * Decrement the entries to the page that an event is on.
+ * The event does not even need to exist, only the pointer
+ * to the page it is on. This may only be called before the commit
+ * takes place.
  */
-void ring_buffer_event_discard(struct ring_buffer_event *event)
+static inline void
+rb_decrement_entry(struct ring_buffer_per_cpu *cpu_buffer,
+                   struct ring_buffer_event *event)
 {
-        rb_event_discard(event);
+        unsigned long addr = (unsigned long)event;
+        struct buffer_page *bpage = cpu_buffer->commit_page;
+        struct buffer_page *start;
+
+        addr &= PAGE_MASK;
+
+        /* Do the likely case first */
+        if (likely(bpage->page == (void *)addr)) {
+                local_dec(&bpage->entries);
+                return;
+        }
+
+        /*
+         * Because the commit page may be on the reader page we
+         * start with the next page and check the end loop there.
+         */
+        rb_inc_page(cpu_buffer, &bpage);
+        start = bpage;
+        do {
+                if (bpage->page == (void *)addr) {
+                        local_dec(&bpage->entries);
+                        return;
+                }
+                rb_inc_page(cpu_buffer, &bpage);
+        } while (bpage != start);
+
+        /* commit not part of this buffer?? */
+        RB_WARN_ON(cpu_buffer, 1);
 }
-EXPORT_SYMBOL_GPL(ring_buffer_event_discard);
 
 /**
  * ring_buffer_commit_discard - discard an event that has not been committed
  * @buffer: the ring buffer
  * @event: non committed event to discard
  *
- * This is similar to ring_buffer_event_discard but must only be
- * performed on an event that has not been committed yet. The difference
- * is that this will also try to free the event from the ring buffer
+ * Sometimes an event that is in the ring buffer needs to be ignored.
+ * This function lets the user discard an event in the ring buffer
+ * and then that event will not be read later.
+ *
+ * This function only works if it is called before the the item has been
+ * committed. It will try to free the event from the ring buffer
  * if another event has not been added behind it.
  *
  * If another event has been added behind it, it will set the event
@@ -1786,14 +2423,15 @@ void ring_buffer_discard_commit(struct ring_buffer *buffer,
          */
         RB_WARN_ON(buffer, !local_read(&cpu_buffer->committing));
 
+        rb_decrement_entry(cpu_buffer, event);
         if (rb_try_to_discard(cpu_buffer, event))
                 goto out;
 
         /*
          * The commit is still visible by the reader, so we
-         * must increment entries.
+         * must still update the timestamp.
          */
-        local_inc(&cpu_buffer->entries);
+        rb_update_write_stamp(cpu_buffer, event);
  out:
         rb_end_commit(cpu_buffer);
 
@@ -1854,7 +2492,7 @@ int ring_buffer_write(struct ring_buffer *buffer,
         if (length > BUF_MAX_DATA_SIZE)
                 goto out;
 
-        event = rb_reserve_next_event(cpu_buffer, length);
+        event = rb_reserve_next_event(buffer, cpu_buffer, length);
         if (!event)
                 goto out;
 
@@ -1875,9 +2513,13 @@ EXPORT_SYMBOL_GPL(ring_buffer_write);
 static int rb_per_cpu_empty(struct ring_buffer_per_cpu *cpu_buffer)
 {
         struct buffer_page *reader = cpu_buffer->reader_page;
-        struct buffer_page *head = cpu_buffer->head_page;
+        struct buffer_page *head = rb_set_head_page(cpu_buffer);
         struct buffer_page *commit = cpu_buffer->commit_page;
 
+        /* In case of error, head will be NULL */
+        if (unlikely(!head))
+                return 1;
+
         return reader->read == rb_page_commit(reader) &&
                 (commit == reader ||
                  (commit == head &&
@@ -1968,7 +2610,7 @@ unsigned long ring_buffer_entries_cpu(struct ring_buffer *buffer, int cpu)
                 return 0;
 
         cpu_buffer = buffer->buffers[cpu];
-        ret = (local_read(&cpu_buffer->entries) - cpu_buffer->overrun)
+        ret = (local_read(&cpu_buffer->entries) - local_read(&cpu_buffer->overrun))
                 - cpu_buffer->read;
 
         return ret;
@@ -1989,33 +2631,13 @@ unsigned long ring_buffer_overrun_cpu(struct ring_buffer *buffer, int cpu)
                 return 0;
 
         cpu_buffer = buffer->buffers[cpu];
-        ret = cpu_buffer->overrun;
+        ret = local_read(&cpu_buffer->overrun);
 
         return ret;
 }
 EXPORT_SYMBOL_GPL(ring_buffer_overrun_cpu);
 
 /**
- * ring_buffer_nmi_dropped_cpu - get the number of nmis that were dropped
- * @buffer: The ring buffer
- * @cpu: The per CPU buffer to get the number of overruns from
- */
-unsigned long ring_buffer_nmi_dropped_cpu(struct ring_buffer *buffer, int cpu)
-{
-        struct ring_buffer_per_cpu *cpu_buffer;
-        unsigned long ret;
-
-        if (!cpumask_test_cpu(cpu, buffer->cpumask))
-                return 0;
-
-        cpu_buffer = buffer->buffers[cpu];
-        ret = cpu_buffer->nmi_dropped;
-
-        return ret;
-}
-EXPORT_SYMBOL_GPL(ring_buffer_nmi_dropped_cpu);
-
-/**
  * ring_buffer_commit_overrun_cpu - get the number of overruns caused by commits
  * @buffer: The ring buffer
  * @cpu: The per CPU buffer to get the number of overruns from
@@ -2030,7 +2652,7 @@ ring_buffer_commit_overrun_cpu(struct ring_buffer *buffer, int cpu)
                 return 0;
 
         cpu_buffer = buffer->buffers[cpu];
-        ret = cpu_buffer->commit_overrun;
+        ret = local_read(&cpu_buffer->commit_overrun);
 
         return ret;
 }
@@ -2053,7 +2675,7 @@ unsigned long ring_buffer_entries(struct ring_buffer *buffer)
         for_each_buffer_cpu(buffer, cpu) {
                 cpu_buffer = buffer->buffers[cpu];
                 entries += (local_read(&cpu_buffer->entries) -
-                            cpu_buffer->overrun) - cpu_buffer->read;
+                            local_read(&cpu_buffer->overrun)) - cpu_buffer->read;
         }
 
         return entries;
@@ -2076,7 +2698,7 @@ unsigned long ring_buffer_overruns(struct ring_buffer *buffer)
         /* if you care about this being correct, lock the buffer */
         for_each_buffer_cpu(buffer, cpu) {
                 cpu_buffer = buffer->buffers[cpu];
-                overruns += cpu_buffer->overrun;
+                overruns += local_read(&cpu_buffer->overrun);
         }
 
         return overruns;
@@ -2089,8 +2711,10 @@ static void rb_iter_reset(struct ring_buffer_iter *iter)
 
         /* Iterator usage is expected to have record disabled */
         if (list_empty(&cpu_buffer->reader_page->list)) {
-                iter->head_page = cpu_buffer->head_page;
-                iter->head = cpu_buffer->head_page->read;
+                iter->head_page = rb_set_head_page(cpu_buffer);
+                if (unlikely(!iter->head_page))
+                        return;
+                iter->head = iter->head_page->read;
         } else {
                 iter->head_page = cpu_buffer->reader_page;
                 iter->head = cpu_buffer->reader_page->read;
@@ -2207,6 +2831,7 @@ rb_get_reader_page(struct ring_buffer_per_cpu *cpu_buffer)
         struct buffer_page *reader = NULL;
         unsigned long flags;
         int nr_loops = 0;
+        int ret;
 
         local_irq_save(flags);
         __raw_spin_lock(&cpu_buffer->lock);
@@ -2240,30 +2865,56 @@ rb_get_reader_page(struct ring_buffer_per_cpu *cpu_buffer)
                 goto out;
 
         /*
-         * Splice the empty reader page into the list around the head.
          * Reset the reader page to size zero.
          */
+        local_set(&cpu_buffer->reader_page->write, 0);
+        local_set(&cpu_buffer->reader_page->entries, 0);
+        local_set(&cpu_buffer->reader_page->page->commit, 0);
 
-        reader = cpu_buffer->head_page;
+ spin:
+        /*
+         * Splice the empty reader page into the list around the head.
+         */
+        reader = rb_set_head_page(cpu_buffer);
         cpu_buffer->reader_page->list.next = reader->list.next;
         cpu_buffer->reader_page->list.prev = reader->list.prev;
 
-        local_set(&cpu_buffer->reader_page->write, 0);
-        local_set(&cpu_buffer->reader_page->entries, 0);
-        local_set(&cpu_buffer->reader_page->page->commit, 0);
+        /*
+         * cpu_buffer->pages just needs to point to the buffer, it
+         *  has no specific buffer page to point to. Lets move it out
+         *  of our way so we don't accidently swap it.
+         */
+        cpu_buffer->pages = reader->list.prev;
 
-        /* Make the reader page now replace the head */
-        reader->list.prev->next = &cpu_buffer->reader_page->list;
-        reader->list.next->prev = &cpu_buffer->reader_page->list;
+        /* The reader page will be pointing to the new head */
+        rb_set_list_to_head(cpu_buffer, &cpu_buffer->reader_page->list);
 
         /*
-         * If the tail is on the reader, then we must set the head
-         * to the inserted page, otherwise we set it one before.
+         * Here's the tricky part.
+         *
+         * We need to move the pointer past the header page.
+         * But we can only do that if a writer is not currently
+         * moving it. The page before the header page has the
+         * flag bit '1' set if it is pointing to the page we want.
+         * but if the writer is in the process of moving it
+         * than it will be '2' or already moved '0'.
          */
-        cpu_buffer->head_page = cpu_buffer->reader_page;
 
-        if (cpu_buffer->commit_page != reader)
-                rb_inc_page(cpu_buffer, &cpu_buffer->head_page);
+        ret = rb_head_page_replace(reader, cpu_buffer->reader_page);
+
+        /*
+         * If we did not convert it, then we must try again.
+         */
+        if (!ret)
+                goto spin;
+
+        /*
+         * Yeah! We succeeded in replacing the page.
+         *
+         * Now make the new head point back to the reader page.
+         */
+        reader->list.next->prev = &cpu_buffer->reader_page->list;
+        rb_inc_page(cpu_buffer, &cpu_buffer->head_page);
 
         /* Finally update the reader page to the new head */
         cpu_buffer->reader_page = reader;
@@ -2292,8 +2943,7 @@ static void rb_advance_reader(struct ring_buffer_per_cpu *cpu_buffer)
 
         event = rb_reader_event(cpu_buffer);
 
-        if (event->type_len <= RINGBUF_TYPE_DATA_TYPE_LEN_MAX
-                        || rb_discarded_event(event))
+        if (event->type_len <= RINGBUF_TYPE_DATA_TYPE_LEN_MAX)
                 cpu_buffer->read++;
 
         rb_update_read_stamp(cpu_buffer, event);
@@ -2525,10 +3175,8 @@ ring_buffer_peek(struct ring_buffer *buffer, int cpu, u64 *ts)
                 spin_unlock(&cpu_buffer->reader_lock);
         local_irq_restore(flags);
 
-        if (event && event->type_len == RINGBUF_TYPE_PADDING) {
-                cpu_relax();
+        if (event && event->type_len == RINGBUF_TYPE_PADDING)
                 goto again;
-        }
 
         return event;
 }
@@ -2553,10 +3201,8 @@ ring_buffer_iter_peek(struct ring_buffer_iter *iter, u64 *ts)
         event = rb_iter_peek(iter, ts);
         spin_unlock_irqrestore(&cpu_buffer->reader_lock, flags);
 
-        if (event && event->type_len == RINGBUF_TYPE_PADDING) {
-                cpu_relax();
+        if (event && event->type_len == RINGBUF_TYPE_PADDING)
                 goto again;
-        }
 
         return event;
 }
@@ -2602,10 +3248,8 @@ ring_buffer_consume(struct ring_buffer *buffer, int cpu, u64 *ts)
  out:
         preempt_enable();
 
-        if (event && event->type_len == RINGBUF_TYPE_PADDING) {
-                cpu_relax();
+        if (event && event->type_len == RINGBUF_TYPE_PADDING)
                 goto again;
-        }
 
         return event;
 }
@@ -2685,21 +3329,19 @@ ring_buffer_read(struct ring_buffer_iter *iter, u64 *ts)
         struct ring_buffer_per_cpu *cpu_buffer = iter->cpu_buffer;
         unsigned long flags;
 
- again:
         spin_lock_irqsave(&cpu_buffer->reader_lock, flags);
+ again:
         event = rb_iter_peek(iter, ts);
         if (!event)
                 goto out;
 
+        if (event->type_len == RINGBUF_TYPE_PADDING)
+                goto again;
+
         rb_advance_iter(iter);
  out:
         spin_unlock_irqrestore(&cpu_buffer->reader_lock, flags);
 
-        if (event && event->type_len == RINGBUF_TYPE_PADDING) {
-                cpu_relax();
-                goto again;
-        }
-
         return event;
 }
 EXPORT_SYMBOL_GPL(ring_buffer_read);
@@ -2717,8 +3359,10 @@ EXPORT_SYMBOL_GPL(ring_buffer_size);
 static void
 rb_reset_cpu(struct ring_buffer_per_cpu *cpu_buffer)
 {
+        rb_head_page_deactivate(cpu_buffer);
+
         cpu_buffer->head_page
-                = list_entry(cpu_buffer->pages.next, struct buffer_page, list);
+                = list_entry(cpu_buffer->pages, struct buffer_page, list);
         local_set(&cpu_buffer->head_page->write, 0);
         local_set(&cpu_buffer->head_page->entries, 0);
         local_set(&cpu_buffer->head_page->page->commit, 0);
@@ -2734,16 +3378,17 @@ rb_reset_cpu(struct ring_buffer_per_cpu *cpu_buffer)
         local_set(&cpu_buffer->reader_page->page->commit, 0);
         cpu_buffer->reader_page->read = 0;
 
-        cpu_buffer->nmi_dropped = 0;
-        cpu_buffer->commit_overrun = 0;
-        cpu_buffer->overrun = 0;
-        cpu_buffer->read = 0;
+        local_set(&cpu_buffer->commit_overrun, 0);
+        local_set(&cpu_buffer->overrun, 0);
         local_set(&cpu_buffer->entries, 0);
         local_set(&cpu_buffer->committing, 0);
         local_set(&cpu_buffer->commits, 0);
+        cpu_buffer->read = 0;
 
         cpu_buffer->write_stamp = 0;
         cpu_buffer->read_stamp = 0;
+
+        rb_head_page_activate(cpu_buffer);
 }
 
 /**
@@ -2763,12 +3408,16 @@ void ring_buffer_reset_cpu(struct ring_buffer *buffer, int cpu)
 
         spin_lock_irqsave(&cpu_buffer->reader_lock, flags);
 
+        if (RB_WARN_ON(cpu_buffer, local_read(&cpu_buffer->committing)))
+                goto out;
+
         __raw_spin_lock(&cpu_buffer->lock);
 
         rb_reset_cpu(cpu_buffer);
 
         __raw_spin_unlock(&cpu_buffer->lock);
 
+ out:
         spin_unlock_irqrestore(&cpu_buffer->reader_lock, flags);
 
         atomic_dec(&cpu_buffer->record_disabled);
@@ -2851,6 +3500,7 @@ int ring_buffer_empty_cpu(struct ring_buffer *buffer, int cpu)
 }
 EXPORT_SYMBOL_GPL(ring_buffer_empty_cpu);
 
+#ifdef CONFIG_RING_BUFFER_ALLOW_SWAP
 /**
  * ring_buffer_swap_cpu - swap a CPU buffer between two ring buffers
  * @buffer_a: One buffer to swap with
@@ -2905,20 +3555,28 @@ int ring_buffer_swap_cpu(struct ring_buffer *buffer_a,
         atomic_inc(&cpu_buffer_a->record_disabled);
         atomic_inc(&cpu_buffer_b->record_disabled);
 
+        ret = -EBUSY;
+        if (local_read(&cpu_buffer_a->committing))
+                goto out_dec;
+        if (local_read(&cpu_buffer_b->committing))
+                goto out_dec;
+
         buffer_a->buffers[cpu] = cpu_buffer_b;
         buffer_b->buffers[cpu] = cpu_buffer_a;
 
         cpu_buffer_b->buffer = buffer_a;
         cpu_buffer_a->buffer = buffer_b;
 
+        ret = 0;
+
+out_dec:
         atomic_dec(&cpu_buffer_a->record_disabled);
         atomic_dec(&cpu_buffer_b->record_disabled);
-
-        ret = 0;
 out:
         return ret;
 }
 EXPORT_SYMBOL_GPL(ring_buffer_swap_cpu);
+#endif /* CONFIG_RING_BUFFER_ALLOW_SWAP */
 
 /**
  * ring_buffer_alloc_read_page - allocate a page to read from buffer
@@ -3091,7 +3749,7 @@ int ring_buffer_read_page(struct ring_buffer *buffer,
                 read = 0;
         } else {
                 /* update the entry counter */
-                cpu_buffer->read += local_read(&reader->entries);
+                cpu_buffer->read += rb_page_entries(reader);
 
                 /* swap the pages */
                 rb_init_page(bpage);
diff --git a/kernel/trace/trace.c b/kernel/trace/trace.c
index 8c358395d338..5c75deeefe30 100644
--- a/kernel/trace/trace.c
+++ b/kernel/trace/trace.c
@@ -43,14 +43,11 @@
 
 #define TRACE_BUFFER_FLAGS      (RB_FL_OVERWRITE)
 
-unsigned long __read_mostly     tracing_max_latency;
-unsigned long __read_mostly     tracing_thresh;
-
 /*
  * On boot up, the ring buffer is set to the minimum size, so that
  * we do not waste memory on systems that are not using tracing.
  */
-static int ring_buffer_expanded;
+int ring_buffer_expanded;
 
 /*
  * We need to change this state when a selftest is running.
@@ -64,7 +61,7 @@ static bool __read_mostly tracing_selftest_running;
 /*
  * If a tracer is running, we do not want to run SELFTEST.
  */
-static bool __read_mostly tracing_selftest_disabled;
+bool __read_mostly tracing_selftest_disabled;
 
 /* For tracers that don't implement custom flags */
 static struct tracer_opt dummy_tracer_opt[] = {
@@ -89,7 +86,7 @@ static int dummy_set_flag(u32 old_flags, u32 bit, int set)
  */
 static int tracing_disabled = 1;
 
-static DEFINE_PER_CPU(local_t, ftrace_cpu_disabled);
+DEFINE_PER_CPU(local_t, ftrace_cpu_disabled);
 
 static inline void ftrace_disable_cpu(void)
 {
@@ -172,10 +169,11 @@ static struct trace_array	global_trace;
 
 static DEFINE_PER_CPU(struct trace_array_cpu, global_trace_cpu);
 
-int filter_current_check_discard(struct ftrace_event_call *call, void *rec,
+int filter_current_check_discard(struct ring_buffer *buffer,
+                                 struct ftrace_event_call *call, void *rec,
                                  struct ring_buffer_event *event)
 {
-        return filter_check_discard(call, rec, global_trace.buffer, event);
+        return filter_check_discard(call, rec, buffer, event);
 }
 EXPORT_SYMBOL_GPL(filter_current_check_discard);
 
@@ -266,6 +264,9 @@ unsigned long trace_flags = TRACE_ITER_PRINT_PARENT | TRACE_ITER_PRINTK |
         TRACE_ITER_ANNOTATE | TRACE_ITER_CONTEXT_INFO | TRACE_ITER_SLEEP_TIME |
         TRACE_ITER_GRAPH_TIME;
 
+static int trace_stop_count;
+static DEFINE_SPINLOCK(tracing_start_lock);
+
 /**
  * trace_wake_up - wake up tasks waiting for trace input
  *
@@ -323,50 +324,20 @@ static const char *trace_options[] = {
         "printk-msg-only",
         "context-info",
         "latency-format",
-        "global-clock",
         "sleep-time",
         "graph-time",
         NULL
 };
 
-/*
- * ftrace_max_lock is used to protect the swapping of buffers
- * when taking a max snapshot. The buffers themselves are
- * protected by per_cpu spinlocks. But the action of the swap
- * needs its own lock.
- *
- * This is defined as a raw_spinlock_t in order to help
- * with performance when lockdep debugging is enabled.
- */
-static raw_spinlock_t ftrace_max_lock =
-        (raw_spinlock_t)__RAW_SPIN_LOCK_UNLOCKED;
-
-/*
- * Copy the new maximum trace into the separate maximum-trace
- * structure. (this way the maximum trace is permanently saved,
- * for later retrieval via /sys/kernel/debug/tracing/latency_trace)
- */
-static void
-__update_max_tr(struct trace_array *tr, struct task_struct *tsk, int cpu)
-{
-        struct trace_array_cpu *data = tr->data[cpu];
-
-        max_tr.cpu = cpu;
-        max_tr.time_start = data->preempt_timestamp;
+static struct {
+        u64 (*func)(void);
+        const char *name;
+} trace_clocks[] = {
+        { trace_clock_local,    "local" },
+        { trace_clock_global,   "global" },
+};
 
-        data = max_tr.data[cpu];
-        data->saved_latency = tracing_max_latency;
-
-        memcpy(data->comm, tsk->comm, TASK_COMM_LEN);
-        data->pid = tsk->pid;
-        data->uid = task_uid(tsk);
-        data->nice = tsk->static_prio - 20 - MAX_RT_PRIO;
-        data->policy = tsk->policy;
-        data->rt_priority = tsk->rt_priority;
-
-        /* record this tasks comm */
-        tracing_record_cmdline(tsk);
-}
+int trace_clock_id;
 
 ssize_t trace_seq_to_user(struct trace_seq *s, char __user *ubuf, size_t cnt)
 {
@@ -411,6 +382,56 @@ static ssize_t trace_seq_to_buffer(struct trace_seq *s, void *buf, size_t cnt)
         return cnt;
 }
 
+/*
+ * ftrace_max_lock is used to protect the swapping of buffers
+ * when taking a max snapshot. The buffers themselves are
+ * protected by per_cpu spinlocks. But the action of the swap
+ * needs its own lock.
+ *
+ * This is defined as a raw_spinlock_t in order to help
+ * with performance when lockdep debugging is enabled.
+ *
+ * It is also used in other places outside the update_max_tr
+ * so it needs to be defined outside of the
+ * CONFIG_TRACER_MAX_TRACE.
+ */
+static raw_spinlock_t ftrace_max_lock =
+        (raw_spinlock_t)__RAW_SPIN_LOCK_UNLOCKED;
+
+#ifdef CONFIG_TRACER_MAX_TRACE
+unsigned long __read_mostly     tracing_max_latency;
+unsigned long __read_mostly     tracing_thresh;
+
+/*
+ * Copy the new maximum trace into the separate maximum-trace
+ * structure. (this way the maximum trace is permanently saved,
+ * for later retrieval via /sys/kernel/debug/tracing/latency_trace)
+ */
+static void
+__update_max_tr(struct trace_array *tr, struct task_struct *tsk, int cpu)
+{
+        struct trace_array_cpu *data = tr->data[cpu];
+        struct trace_array_cpu *max_data = tr->data[cpu];
+
+        max_tr.cpu = cpu;
+        max_tr.time_start = data->preempt_timestamp;
+
+        max_data = max_tr.data[cpu];
+        max_data->saved_latency = tracing_max_latency;
+        max_data->critical_start = data->critical_start;
+        max_data->critical_end = data->critical_end;
+
+        memcpy(data->comm, tsk->comm, TASK_COMM_LEN);
+        max_data->pid = tsk->pid;
+        max_data->uid = task_uid(tsk);
+        max_data->nice = tsk->static_prio - 20 - MAX_RT_PRIO;
+        max_data->policy = tsk->policy;
+        max_data->rt_priority = tsk->rt_priority;
+
+        /* record this tasks comm */
+        tracing_record_cmdline(tsk);
+}
+
 /**
  * update_max_tr - snapshot all trace buffers from global_trace to max_tr
  * @tr: tracer
@@ -425,16 +446,15 @@ update_max_tr(struct trace_array *tr, struct task_struct *tsk, int cpu)
 {
         struct ring_buffer *buf = tr->buffer;
 
+        if (trace_stop_count)
+                return;
+
         WARN_ON_ONCE(!irqs_disabled());
         __raw_spin_lock(&ftrace_max_lock);
 
         tr->buffer = max_tr.buffer;
         max_tr.buffer = buf;
 
-        ftrace_disable_cpu();
-        ring_buffer_reset(tr->buffer);
-        ftrace_enable_cpu();
-
         __update_max_tr(tr, tsk, cpu);
         __raw_spin_unlock(&ftrace_max_lock);
 }
@@ -452,21 +472,35 @@ update_max_tr_single(struct trace_array *tr, struct task_struct *tsk, int cpu)
 {
         int ret;
 
+        if (trace_stop_count)
+                return;
+
         WARN_ON_ONCE(!irqs_disabled());
         __raw_spin_lock(&ftrace_max_lock);
 
         ftrace_disable_cpu();
 
-        ring_buffer_reset(max_tr.buffer);
         ret = ring_buffer_swap_cpu(max_tr.buffer, tr->buffer, cpu);
 
+        if (ret == -EBUSY) {
+                /*
+                 * We failed to swap the buffer due to a commit taking
+                 * place on this CPU. We fail to record, but we reset
+                 * the max trace buffer (no one writes directly to it)
+                 * and flag that it failed.
+                 */
+                trace_array_printk(&max_tr, _THIS_IP_,
+                        "Failed to swap buffers due to commit in progress\n");
+        }
+
         ftrace_enable_cpu();
 
-        WARN_ON_ONCE(ret && ret != -EAGAIN);
+        WARN_ON_ONCE(ret && ret != -EAGAIN && ret != -EBUSY);
 
         __update_max_tr(tr, tsk, cpu);
         __raw_spin_unlock(&ftrace_max_lock);
 }
+#endif /* CONFIG_TRACER_MAX_TRACE */
 
 /**
  * register_tracer - register a tracer with the ftrace system.
@@ -523,7 +557,6 @@ __acquires(kernel_lock)
         if (type->selftest && !tracing_selftest_disabled) {
                 struct tracer *saved_tracer = current_trace;
                 struct trace_array *tr = &global_trace;
-                int i;
 
                 /*
                  * Run a selftest on this tracer.
@@ -532,8 +565,7 @@ __acquires(kernel_lock)
                  * internal tracing to verify that everything is in order.
                  * If we fail, we do not register this tracer.
                  */
-                for_each_tracing_cpu(i)
-                        tracing_reset(tr, i);
+                tracing_reset_online_cpus(tr);
 
                 current_trace = type;
                 /* the test is responsible for initializing and enabling */
@@ -546,8 +578,7 @@ __acquires(kernel_lock)
                         goto out;
                 }
                 /* Only reset on passing, to avoid touching corrupted buffers */
-                for_each_tracing_cpu(i)
-                        tracing_reset(tr, i);
+                tracing_reset_online_cpus(tr);
 
                 printk(KERN_CONT "PASSED\n");
         }
@@ -622,21 +653,42 @@ void unregister_tracer(struct tracer *type)
         mutex_unlock(&trace_types_lock);
 }
 
-void tracing_reset(struct trace_array *tr, int cpu)
+static void __tracing_reset(struct trace_array *tr, int cpu)
 {
         ftrace_disable_cpu();
         ring_buffer_reset_cpu(tr->buffer, cpu);
         ftrace_enable_cpu();
 }
 
+void tracing_reset(struct trace_array *tr, int cpu)
+{
+        struct ring_buffer *buffer = tr->buffer;
+
+        ring_buffer_record_disable(buffer);
+
+        /* Make sure all commits have finished */
+        synchronize_sched();
+        __tracing_reset(tr, cpu);
+
+        ring_buffer_record_enable(buffer);
+}
+
 void tracing_reset_online_cpus(struct trace_array *tr)
 {
+        struct ring_buffer *buffer = tr->buffer;
         int cpu;
 
+        ring_buffer_record_disable(buffer);
+
+        /* Make sure all commits have finished */
+        synchronize_sched();
+
         tr->time_start = ftrace_now(tr->cpu);
 
         for_each_online_cpu(cpu)
-                tracing_reset(tr, cpu);
+                __tracing_reset(tr, cpu);
+
+        ring_buffer_record_enable(buffer);
 }
 
 void tracing_reset_current(int cpu)
@@ -667,9 +719,6 @@ static void trace_init_cmdlines(void)
         cmdline_idx = 0;
 }
 
-static int trace_stop_count;
-static DEFINE_SPINLOCK(tracing_start_lock);
-
 /**
  * ftrace_off_permanent - disable all ftrace code permanently
  *
@@ -850,14 +899,15 @@ tracing_generic_entry_update(struct trace_entry *entry, unsigned long flags,
 }
 EXPORT_SYMBOL_GPL(tracing_generic_entry_update);
 
-struct ring_buffer_event *trace_buffer_lock_reserve(struct trace_array *tr,
-                                                    int type,
-                                                    unsigned long len,
-                                                    unsigned long flags, int pc)
+struct ring_buffer_event *
+trace_buffer_lock_reserve(struct ring_buffer *buffer,
+                          int type,
+                          unsigned long len,
+                          unsigned long flags, int pc)
 {
         struct ring_buffer_event *event;
 
-        event = ring_buffer_lock_reserve(tr->buffer, len);
+        event = ring_buffer_lock_reserve(buffer, len);
         if (event != NULL) {
                 struct trace_entry *ent = ring_buffer_event_data(event);
 
@@ -867,58 +917,60 @@ struct ring_buffer_event *trace_buffer_lock_reserve(struct trace_array *tr,
 
         return event;
 }
-static void ftrace_trace_stack(struct trace_array *tr,
-                               unsigned long flags, int skip, int pc);
-static void ftrace_trace_userstack(struct trace_array *tr,
-                                   unsigned long flags, int pc);
 
-static inline void __trace_buffer_unlock_commit(struct trace_array *tr,
-                                        struct ring_buffer_event *event,
-                                        unsigned long flags, int pc,
-                                        int wake)
+static inline void
+__trace_buffer_unlock_commit(struct ring_buffer *buffer,
+                             struct ring_buffer_event *event,
+                             unsigned long flags, int pc,
+                             int wake)
 {
-        ring_buffer_unlock_commit(tr->buffer, event);
+        ring_buffer_unlock_commit(buffer, event);
 
-        ftrace_trace_stack(tr, flags, 6, pc);
-        ftrace_trace_userstack(tr, flags, pc);
+        ftrace_trace_stack(buffer, flags, 6, pc);
+        ftrace_trace_userstack(buffer, flags, pc);
 
         if (wake)
                 trace_wake_up();
 }
 
-void trace_buffer_unlock_commit(struct trace_array *tr,
-                                        struct ring_buffer_event *event,
-                                        unsigned long flags, int pc)
+void trace_buffer_unlock_commit(struct ring_buffer *buffer,
+                                struct ring_buffer_event *event,
+                                unsigned long flags, int pc)
 {
-        __trace_buffer_unlock_commit(tr, event, flags, pc, 1);
+        __trace_buffer_unlock_commit(buffer, event, flags, pc, 1);
 }
 
 struct ring_buffer_event *
-trace_current_buffer_lock_reserve(int type, unsigned long len,
+trace_current_buffer_lock_reserve(struct ring_buffer **current_rb,
+                                  int type, unsigned long len,
                                   unsigned long flags, int pc)
 {
-        return trace_buffer_lock_reserve(&global_trace,
+        *current_rb = global_trace.buffer;
+        return trace_buffer_lock_reserve(*current_rb,
                                          type, len, flags, pc);
 }
 EXPORT_SYMBOL_GPL(trace_current_buffer_lock_reserve);
 
-void trace_current_buffer_unlock_commit(struct ring_buffer_event *event,
+void trace_current_buffer_unlock_commit(struct ring_buffer *buffer,
+                                        struct ring_buffer_event *event,
                                         unsigned long flags, int pc)
 {
-        __trace_buffer_unlock_commit(&global_trace, event, flags, pc, 1);
+        __trace_buffer_unlock_commit(buffer, event, flags, pc, 1);
 }
 EXPORT_SYMBOL_GPL(trace_current_buffer_unlock_commit);
 
-void trace_nowake_buffer_unlock_commit(struct ring_buffer_event *event,
-                                        unsigned long flags, int pc)
+void trace_nowake_buffer_unlock_commit(struct ring_buffer *buffer,
+                                       struct ring_buffer_event *event,
+                                       unsigned long flags, int pc)
 {
-        __trace_buffer_unlock_commit(&global_trace, event, flags, pc, 0);
+        __trace_buffer_unlock_commit(buffer, event, flags, pc, 0);
 }
 EXPORT_SYMBOL_GPL(trace_nowake_buffer_unlock_commit);
 
-void trace_current_buffer_discard_commit(struct ring_buffer_event *event)
+void trace_current_buffer_discard_commit(struct ring_buffer *buffer,
+                                         struct ring_buffer_event *event)
 {
-        ring_buffer_discard_commit(global_trace.buffer, event);
+        ring_buffer_discard_commit(buffer, event);
 }
 EXPORT_SYMBOL_GPL(trace_current_buffer_discard_commit);
 
@@ -928,6 +980,7 @@ trace_function(struct trace_array *tr,
                int pc)
 {
         struct ftrace_event_call *call = &event_function;
+        struct ring_buffer *buffer = tr->buffer;
         struct ring_buffer_event *event;
         struct ftrace_entry *entry;
 
@@ -935,7 +988,7 @@ trace_function(struct trace_array *tr,
         if (unlikely(local_read(&__get_cpu_var(ftrace_cpu_disabled))))
                 return;
 
-        event = trace_buffer_lock_reserve(tr, TRACE_FN, sizeof(*entry),
+        event = trace_buffer_lock_reserve(buffer, TRACE_FN, sizeof(*entry),
                                           flags, pc);
         if (!event)
                 return;
@@ -943,58 +996,10 @@ trace_function(struct trace_array *tr,
         entry->ip                       = ip;
         entry->parent_ip                = parent_ip;
 
-        if (!filter_check_discard(call, entry, tr->buffer, event))
-                ring_buffer_unlock_commit(tr->buffer, event);
-}
-
-#ifdef CONFIG_FUNCTION_GRAPH_TRACER
-static int __trace_graph_entry(struct trace_array *tr,
-                                struct ftrace_graph_ent *trace,
-                                unsigned long flags,
-                                int pc)
-{
-        struct ftrace_event_call *call = &event_funcgraph_entry;
-        struct ring_buffer_event *event;
-        struct ftrace_graph_ent_entry *entry;
-
-        if (unlikely(local_read(&__get_cpu_var(ftrace_cpu_disabled))))
-                return 0;
-
-        event = trace_buffer_lock_reserve(&global_trace, TRACE_GRAPH_ENT,
-                                          sizeof(*entry), flags, pc);
-        if (!event)
-                return 0;
-        entry   = ring_buffer_event_data(event);
-        entry->graph_ent                        = *trace;
-        if (!filter_current_check_discard(call, entry, event))
-                ring_buffer_unlock_commit(global_trace.buffer, event);
-
-        return 1;
+        if (!filter_check_discard(call, entry, buffer, event))
+                ring_buffer_unlock_commit(buffer, event);
 }
 
-static void __trace_graph_return(struct trace_array *tr,
-                                struct ftrace_graph_ret *trace,
-                                unsigned long flags,
-                                int pc)
-{
-        struct ftrace_event_call *call = &event_funcgraph_exit;
-        struct ring_buffer_event *event;
-        struct ftrace_graph_ret_entry *entry;
-
-        if (unlikely(local_read(&__get_cpu_var(ftrace_cpu_disabled))))
-                return;
-
-        event = trace_buffer_lock_reserve(&global_trace, TRACE_GRAPH_RET,
-                                          sizeof(*entry), flags, pc);
-        if (!event)
-                return;
-        entry   = ring_buffer_event_data(event);
-        entry->ret                              = *trace;
-        if (!filter_current_check_discard(call, entry, event))
-                ring_buffer_unlock_commit(global_trace.buffer, event);
-}
-#endif
-
 void
 ftrace(struct trace_array *tr, struct trace_array_cpu *data,
        unsigned long ip, unsigned long parent_ip, unsigned long flags,
@@ -1004,17 +1009,17 @@ ftrace(struct trace_array *tr, struct trace_array_cpu *data,
                 trace_function(tr, ip, parent_ip, flags, pc);
 }
 
-static void __ftrace_trace_stack(struct trace_array *tr,
+#ifdef CONFIG_STACKTRACE
+static void __ftrace_trace_stack(struct ring_buffer *buffer,
                                  unsigned long flags,
                                  int skip, int pc)
 {
-#ifdef CONFIG_STACKTRACE
         struct ftrace_event_call *call = &event_kernel_stack;
         struct ring_buffer_event *event;
         struct stack_entry *entry;
         struct stack_trace trace;
 
-        event = trace_buffer_lock_reserve(tr, TRACE_STACK,
+        event = trace_buffer_lock_reserve(buffer, TRACE_STACK,
                                           sizeof(*entry), flags, pc);
         if (!event)
                 return;
@@ -1027,32 +1032,28 @@ static void __ftrace_trace_stack(struct trace_array *tr,
         trace.entries           = entry->caller;
 
         save_stack_trace(&trace);
-        if (!filter_check_discard(call, entry, tr->buffer, event))
-                ring_buffer_unlock_commit(tr->buffer, event);
-#endif
+        if (!filter_check_discard(call, entry, buffer, event))
+                ring_buffer_unlock_commit(buffer, event);
 }
 
-static void ftrace_trace_stack(struct trace_array *tr,
-                               unsigned long flags,
-                               int skip, int pc)
+void ftrace_trace_stack(struct ring_buffer *buffer, unsigned long flags,
+                        int skip, int pc)
 {
         if (!(trace_flags & TRACE_ITER_STACKTRACE))
                 return;
 
-        __ftrace_trace_stack(tr, flags, skip, pc);
+        __ftrace_trace_stack(buffer, flags, skip, pc);
 }
 
-void __trace_stack(struct trace_array *tr,
-                   unsigned long flags,
-                   int skip, int pc)
+void __trace_stack(struct trace_array *tr, unsigned long flags, int skip,
+                   int pc)
 {
-        __ftrace_trace_stack(tr, flags, skip, pc);
+        __ftrace_trace_stack(tr->buffer, flags, skip, pc);
 }
 
-static void ftrace_trace_userstack(struct trace_array *tr,
-                                   unsigned long flags, int pc)
+void
+ftrace_trace_userstack(struct ring_buffer *buffer, unsigned long flags, int pc)
 {
-#ifdef CONFIG_STACKTRACE
         struct ftrace_event_call *call = &event_user_stack;
         struct ring_buffer_event *event;
         struct userstack_entry *entry;
@@ -1061,7 +1062,7 @@ static void ftrace_trace_userstack(struct trace_array *tr,
         if (!(trace_flags & TRACE_ITER_USERSTACKTRACE))
                 return;
 
-        event = trace_buffer_lock_reserve(tr, TRACE_USER_STACK,
+        event = trace_buffer_lock_reserve(buffer, TRACE_USER_STACK,
                                           sizeof(*entry), flags, pc);
         if (!event)
                 return;
@@ -1075,9 +1076,8 @@ static void ftrace_trace_userstack(struct trace_array *tr,
         trace.entries           = entry->caller;
 
         save_stack_trace_user(&trace);
-        if (!filter_check_discard(call, entry, tr->buffer, event))
-                ring_buffer_unlock_commit(tr->buffer, event);
-#endif
+        if (!filter_check_discard(call, entry, buffer, event))
+                ring_buffer_unlock_commit(buffer, event);
 }
 
 #ifdef UNUSED
@@ -1087,6 +1087,8 @@ static void __trace_userstack(struct trace_array *tr, unsigned long flags)
 }
 #endif /* UNUSED */
 
+#endif /* CONFIG_STACKTRACE */
+
 static void
 ftrace_trace_special(void *__tr,
                      unsigned long arg1, unsigned long arg2, unsigned long arg3,
@@ -1094,9 +1096,10 @@ ftrace_trace_special(void *__tr,
 {
         struct ring_buffer_event *event;
         struct trace_array *tr = __tr;
+        struct ring_buffer *buffer = tr->buffer;
         struct special_entry *entry;
 
-        event = trace_buffer_lock_reserve(tr, TRACE_SPECIAL,
+        event = trace_buffer_lock_reserve(buffer, TRACE_SPECIAL,
                                           sizeof(*entry), 0, pc);
         if (!event)
                 return;
@@ -1104,7 +1107,7 @@ ftrace_trace_special(void *__tr,
         entry->arg1                     = arg1;
         entry->arg2                     = arg2;
         entry->arg3                     = arg3;
-        trace_buffer_unlock_commit(tr, event, 0, pc);
+        trace_buffer_unlock_commit(buffer, event, 0, pc);
 }
 
 void
@@ -1115,62 +1118,6 @@ __trace_special(void *__tr, void *__data,
 }
 
 void
-tracing_sched_switch_trace(struct trace_array *tr,
-                           struct task_struct *prev,
-                           struct task_struct *next,
-                           unsigned long flags, int pc)
-{
-        struct ftrace_event_call *call = &event_context_switch;
-        struct ring_buffer_event *event;
-        struct ctx_switch_entry *entry;
-
-        event = trace_buffer_lock_reserve(tr, TRACE_CTX,
-                                          sizeof(*entry), flags, pc);
-        if (!event)
-                return;
-        entry   = ring_buffer_event_data(event);
-        entry->prev_pid                 = prev->pid;
-        entry->prev_prio                = prev->prio;
-        entry->prev_state               = prev->state;
-        entry->next_pid                 = next->pid;
-        entry->next_prio                = next->prio;
-        entry->next_state               = next->state;
-        entry->next_cpu = task_cpu(next);
-
-        if (!filter_check_discard(call, entry, tr->buffer, event))
-                trace_buffer_unlock_commit(tr, event, flags, pc);
-}
-
-void
-tracing_sched_wakeup_trace(struct trace_array *tr,
-                           struct task_struct *wakee,
-                           struct task_struct *curr,
-                           unsigned long flags, int pc)
-{
-        struct ftrace_event_call *call = &event_wakeup;
-        struct ring_buffer_event *event;
-        struct ctx_switch_entry *entry;
-
-        event = trace_buffer_lock_reserve(tr, TRACE_WAKE,
-                                          sizeof(*entry), flags, pc);
-        if (!event)
-                return;
-        entry   = ring_buffer_event_data(event);
-        entry->prev_pid                 = curr->pid;
-        entry->prev_prio                = curr->prio;
-        entry->prev_state               = curr->state;
-        entry->next_pid                 = wakee->pid;
-        entry->next_prio                = wakee->prio;
-        entry->next_state               = wakee->state;
-        entry->next_cpu                 = task_cpu(wakee);
-
-        if (!filter_check_discard(call, entry, tr->buffer, event))
-                ring_buffer_unlock_commit(tr->buffer, event);
-        ftrace_trace_stack(tr, flags, 6, pc);
-        ftrace_trace_userstack(tr, flags, pc);
-}
-
-void
 ftrace_special(unsigned long arg1, unsigned long arg2, unsigned long arg3)
 {
         struct trace_array *tr = &global_trace;
@@ -1194,68 +1141,6 @@ ftrace_special(unsigned long arg1, unsigned long arg2, unsigned long arg3)
         local_irq_restore(flags);
 }
 
-#ifdef CONFIG_FUNCTION_GRAPH_TRACER
-int trace_graph_entry(struct ftrace_graph_ent *trace)
-{
-        struct trace_array *tr = &global_trace;
-        struct trace_array_cpu *data;
-        unsigned long flags;
-        long disabled;
-        int ret;
-        int cpu;
-        int pc;
-
-        if (!ftrace_trace_task(current))
-                return 0;
-
-        if (!ftrace_graph_addr(trace->func))
-                return 0;
-
-        local_irq_save(flags);
-        cpu = raw_smp_processor_id();
-        data = tr->data[cpu];
-        disabled = atomic_inc_return(&data->disabled);
-        if (likely(disabled == 1)) {
-                pc = preempt_count();
-                ret = __trace_graph_entry(tr, trace, flags, pc);
-        } else {
-                ret = 0;
-        }
-        /* Only do the atomic if it is not already set */
-        if (!test_tsk_trace_graph(current))
-                set_tsk_trace_graph(current);
-
-        atomic_dec(&data->disabled);
-        local_irq_restore(flags);
-
-        return ret;
-}
-
-void trace_graph_return(struct ftrace_graph_ret *trace)
-{
-        struct trace_array *tr = &global_trace;
-        struct trace_array_cpu *data;
-        unsigned long flags;
-        long disabled;
-        int cpu;
-        int pc;
-
-        local_irq_save(flags);
-        cpu = raw_smp_processor_id();
-        data = tr->data[cpu];
-        disabled = atomic_inc_return(&data->disabled);
-        if (likely(disabled == 1)) {
-                pc = preempt_count();
-                __trace_graph_return(tr, trace, flags, pc);
-        }
-        if (!trace->depth)
-                clear_tsk_trace_graph(current);
-        atomic_dec(&data->disabled);
-        local_irq_restore(flags);
-}
-#endif /* CONFIG_FUNCTION_GRAPH_TRACER */
-
-
 /**
  * trace_vbprintk - write binary msg to tracing buffer
  *
@@ -1268,6 +1153,7 @@ int trace_vbprintk(unsigned long ip, const char *fmt, va_list args)
 
         struct ftrace_event_call *call = &event_bprint;
         struct ring_buffer_event *event;
+        struct ring_buffer *buffer;
         struct trace_array *tr = &global_trace;
         struct trace_array_cpu *data;
         struct bprint_entry *entry;
@@ -1300,7 +1186,9 @@ int trace_vbprintk(unsigned long ip, const char *fmt, va_list args)
                 goto out_unlock;
 
         size = sizeof(*entry) + sizeof(u32) * len;
-        event = trace_buffer_lock_reserve(tr, TRACE_BPRINT, size, flags, pc);
+        buffer = tr->buffer;
+        event = trace_buffer_lock_reserve(buffer, TRACE_BPRINT, size,
+                                          flags, pc);
         if (!event)
                 goto out_unlock;
         entry = ring_buffer_event_data(event);
@@ -1308,8 +1196,8 @@ int trace_vbprintk(unsigned long ip, const char *fmt, va_list args)
         entry->fmt                      = fmt;
 
         memcpy(entry->buf, trace_buf, sizeof(u32) * len);
-        if (!filter_check_discard(call, entry, tr->buffer, event))
-                ring_buffer_unlock_commit(tr->buffer, event);
+        if (!filter_check_discard(call, entry, buffer, event))
+                ring_buffer_unlock_commit(buffer, event);
 
 out_unlock:
         __raw_spin_unlock(&trace_buf_lock);
@@ -1324,14 +1212,30 @@ out:
 }
 EXPORT_SYMBOL_GPL(trace_vbprintk);
 
-int trace_vprintk(unsigned long ip, const char *fmt, va_list args)
+int trace_array_printk(struct trace_array *tr,
+                       unsigned long ip, const char *fmt, ...)
+{
+        int ret;
+        va_list ap;
+
+        if (!(trace_flags & TRACE_ITER_PRINTK))
+                return 0;
+
+        va_start(ap, fmt);
+        ret = trace_array_vprintk(tr, ip, fmt, ap);
+        va_end(ap);
+        return ret;
+}
+
+int trace_array_vprintk(struct trace_array *tr,
+                        unsigned long ip, const char *fmt, va_list args)
 {
         static raw_spinlock_t trace_buf_lock = __RAW_SPIN_LOCK_UNLOCKED;
         static char trace_buf[TRACE_BUF_SIZE];
 
         struct ftrace_event_call *call = &event_print;
         struct ring_buffer_event *event;
-        struct trace_array *tr = &global_trace;
+        struct ring_buffer *buffer;
         struct trace_array_cpu *data;
         int cpu, len = 0, size, pc;
         struct print_entry *entry;
@@ -1359,7 +1263,9 @@ int trace_vprintk(unsigned long ip, const char *fmt, va_list args)
         trace_buf[len] = 0;
 
         size = sizeof(*entry) + len + 1;
-        event = trace_buffer_lock_reserve(tr, TRACE_PRINT, size, irq_flags, pc);
+        buffer = tr->buffer;
+        event = trace_buffer_lock_reserve(buffer, TRACE_PRINT, size,
+                                          irq_flags, pc);
         if (!event)
                 goto out_unlock;
         entry = ring_buffer_event_data(event);
@@ -1367,8 +1273,8 @@ int trace_vprintk(unsigned long ip, const char *fmt, va_list args)
 
         memcpy(&entry->buf, trace_buf, len);
         entry->buf[len] = 0;
-        if (!filter_check_discard(call, entry, tr->buffer, event))
-                ring_buffer_unlock_commit(tr->buffer, event);
+        if (!filter_check_discard(call, entry, buffer, event))
+                ring_buffer_unlock_commit(buffer, event);
 
  out_unlock:
         __raw_spin_unlock(&trace_buf_lock);
@@ -1380,6 +1286,11 @@ int trace_vprintk(unsigned long ip, const char *fmt, va_list args)
 
         return len;
 }
+
+int trace_vprintk(unsigned long ip, const char *fmt, va_list args)
+{
+        return trace_array_printk(&global_trace, ip, fmt, args);
+}
 EXPORT_SYMBOL_GPL(trace_vprintk);
 
 enum trace_file_type {
@@ -1519,6 +1430,37 @@ static void *s_next(struct seq_file *m, void *v, loff_t *pos)
         return ent;
 }
 
+static void tracing_iter_reset(struct trace_iterator *iter, int cpu)
+{
+        struct trace_array *tr = iter->tr;
+        struct ring_buffer_event *event;
+        struct ring_buffer_iter *buf_iter;
+        unsigned long entries = 0;
+        u64 ts;
+
+        tr->data[cpu]->skipped_entries = 0;
+
+        if (!iter->buffer_iter[cpu])
+                return;
+
+        buf_iter = iter->buffer_iter[cpu];
+        ring_buffer_iter_reset(buf_iter);
+
+        /*
+         * We could have the case with the max latency tracers
+         * that a reset never took place on a cpu. This is evident
+         * by the timestamp being before the start of the buffer.
+         */
+        while ((event = ring_buffer_iter_peek(buf_iter, &ts))) {
+                if (ts >= iter->tr->time_start)
+                        break;
+                entries++;
+                ring_buffer_read(buf_iter, NULL);
+        }
+
+        tr->data[cpu]->skipped_entries = entries;
+}
+
 /*
  * No necessary locking here. The worst thing which can
  * happen is loosing events consumed at the same time
@@ -1557,10 +1499,9 @@ static void *s_start(struct seq_file *m, loff_t *pos)
 
                 if (cpu_file == TRACE_PIPE_ALL_CPU) {
                         for_each_tracing_cpu(cpu)
-                                ring_buffer_iter_reset(iter->buffer_iter[cpu]);
+                                tracing_iter_reset(iter, cpu);
                 } else
-                        ring_buffer_iter_reset(iter->buffer_iter[cpu_file]);
-
+                        tracing_iter_reset(iter, cpu_file);
 
                 ftrace_enable_cpu();
 
@@ -1609,16 +1550,32 @@ print_trace_header(struct seq_file *m, struct trace_iterator *iter)
         struct trace_array *tr = iter->tr;
         struct trace_array_cpu *data = tr->data[tr->cpu];
         struct tracer *type = current_trace;
-        unsigned long total;
-        unsigned long entries;
+        unsigned long entries = 0;
+        unsigned long total = 0;
+        unsigned long count;
         const char *name = "preemption";
+        int cpu;
 
         if (type)
                 name = type->name;
 
-        entries = ring_buffer_entries(iter->tr->buffer);
-        total = entries +
-                ring_buffer_overruns(iter->tr->buffer);
+
+        for_each_tracing_cpu(cpu) {
+                count = ring_buffer_entries_cpu(tr->buffer, cpu);
+                /*
+                 * If this buffer has skipped entries, then we hold all
+                 * entries for the trace and we need to ignore the
+                 * ones before the time stamp.
+                 */
+                if (tr->data[cpu]->skipped_entries) {
+                        count -= tr->data[cpu]->skipped_entries;
+                        /* total is the same as the entries */
+                        total += count;
+                } else
+                        total += count +
+                                ring_buffer_overrun_cpu(tr->buffer, cpu);
+                entries += count;
+        }
 
         seq_printf(m, "# %s latency trace v1.1.5 on %s\n",
                    name, UTS_RELEASE);
@@ -1660,7 +1617,7 @@ print_trace_header(struct seq_file *m, struct trace_iterator *iter)
                 seq_puts(m, "\n#  => ended at:   ");
                 seq_print_ip_sym(&iter->seq, data->critical_end, sym_flags);
                 trace_print_seq(m, &iter->seq);
-                seq_puts(m, "#\n");
+                seq_puts(m, "\n#\n");
         }
 
         seq_puts(m, "#\n");
@@ -1679,6 +1636,9 @@ static void test_cpu_buff_start(struct trace_iterator *iter)
         if (cpumask_test_cpu(iter->cpu, iter->started))
                 return;
 
+        if (iter->tr->data[iter->cpu]->skipped_entries)
+                return;
+
         cpumask_set_cpu(iter->cpu, iter->started);
 
         /* Don't print started cpu buffer for the first entry of the trace */
@@ -1941,19 +1901,23 @@ __tracing_open(struct inode *inode, struct file *file)
         if (ring_buffer_overruns(iter->tr->buffer))
                 iter->iter_flags |= TRACE_FILE_ANNOTATE;
 
+        /* stop the trace while dumping */
+        tracing_stop();
+
         if (iter->cpu_file == TRACE_PIPE_ALL_CPU) {
                 for_each_tracing_cpu(cpu) {
 
                         iter->buffer_iter[cpu] =
                                 ring_buffer_read_start(iter->tr->buffer, cpu);
+                        tracing_iter_reset(iter, cpu);
                 }
         } else {
                 cpu = iter->cpu_file;
                 iter->buffer_iter[cpu] =
                                 ring_buffer_read_start(iter->tr->buffer, cpu);
+                tracing_iter_reset(iter, cpu);
         }
 
-        /* TODO stop tracer */
         ret = seq_open(file, &tracer_seq_ops);
         if (ret < 0) {
                 fail_ret = ERR_PTR(ret);
@@ -1963,9 +1927,6 @@ __tracing_open(struct inode *inode, struct file *file)
         m = file->private_data;
         m->private = iter;
 
-        /* stop the trace while dumping */
-        tracing_stop();
-
         mutex_unlock(&trace_types_lock);
 
         return iter;
@@ -1976,6 +1937,7 @@ __tracing_open(struct inode *inode, struct file *file)
                         ring_buffer_read_finish(iter->buffer_iter[cpu]);
         }
         free_cpumask_var(iter->started);
+        tracing_start();
  fail:
         mutex_unlock(&trace_types_lock);
         kfree(iter->trace);
@@ -2257,8 +2219,8 @@ tracing_trace_options_read(struct file *filp, char __user *ubuf,
                 len += 3; /* "no" and newline */
         }
 
-        /* +2 for \n and \0 */
-        buf = kmalloc(len + 2, GFP_KERNEL);
+        /* +1 for \0 */
+        buf = kmalloc(len + 1, GFP_KERNEL);
         if (!buf) {
                 mutex_unlock(&trace_types_lock);
                 return -ENOMEM;
@@ -2281,7 +2243,7 @@ tracing_trace_options_read(struct file *filp, char __user *ubuf,
         }
         mutex_unlock(&trace_types_lock);
 
-        WARN_ON(r >= len + 2);
+        WARN_ON(r >= len + 1);
 
         r = simple_read_from_buffer(ubuf, cnt, ppos, buf, r);
 
@@ -2292,23 +2254,23 @@ tracing_trace_options_read(struct file *filp, char __user *ubuf,
 /* Try to assign a tracer specific option */
 static int set_tracer_option(struct tracer *trace, char *cmp, int neg)
 {
-        struct tracer_flags *trace_flags = trace->flags;
+        struct tracer_flags *tracer_flags = trace->flags;
         struct tracer_opt *opts = NULL;
         int ret = 0, i = 0;
         int len;
 
-        for (i = 0; trace_flags->opts[i].name; i++) {
-                opts = &trace_flags->opts[i];
+        for (i = 0; tracer_flags->opts[i].name; i++) {
+                opts = &tracer_flags->opts[i];
                 len = strlen(opts->name);
 
                 if (strncmp(cmp, opts->name, len) == 0) {
-                        ret = trace->set_flag(trace_flags->val,
+                        ret = trace->set_flag(tracer_flags->val,
                                 opts->bit, !neg);
                         break;
                 }
         }
         /* Not found */
-        if (!trace_flags->opts[i].name)
+        if (!tracer_flags->opts[i].name)
                 return -EINVAL;
 
         /* Refused to handle */
@@ -2316,9 +2278,9 @@ static int set_tracer_option(struct tracer *trace, char *cmp, int neg)
                 return ret;
 
         if (neg)
-                trace_flags->val &= ~opts->bit;
+                tracer_flags->val &= ~opts->bit;
         else
-                trace_flags->val |= opts->bit;
+                tracer_flags->val |= opts->bit;
 
         return 0;
 }
@@ -2333,22 +2295,6 @@ static void set_tracer_flags(unsigned int mask, int enabled)
                 trace_flags |= mask;
         else
                 trace_flags &= ~mask;
-
-        if (mask == TRACE_ITER_GLOBAL_CLK) {
-                u64 (*func)(void);
-
-                if (enabled)
-                        func = trace_clock_global;
-                else
-                        func = trace_clock_local;
-
-                mutex_lock(&trace_types_lock);
-                ring_buffer_set_clock(global_trace.buffer, func);
-
-                if (max_tr.buffer)
-                        ring_buffer_set_clock(max_tr.buffer, func);
-                mutex_unlock(&trace_types_lock);
-        }
 }
 
 static ssize_t
@@ -3316,6 +3262,62 @@ tracing_mark_write(struct file *filp, const char __user *ubuf,
         return cnt;
 }
 
+static ssize_t tracing_clock_read(struct file *filp, char __user *ubuf,
+                                  size_t cnt, loff_t *ppos)
+{
+        char buf[64];
+        int bufiter = 0;
+        int i;
+
+        for (i = 0; i < ARRAY_SIZE(trace_clocks); i++)
+                bufiter += snprintf(buf + bufiter, sizeof(buf) - bufiter,
+                        "%s%s%s%s", i ? " " : "",
+                        i == trace_clock_id ? "[" : "", trace_clocks[i].name,
+                        i == trace_clock_id ? "]" : "");
+        bufiter += snprintf(buf + bufiter, sizeof(buf) - bufiter, "\n");
+
+        return simple_read_from_buffer(ubuf, cnt, ppos, buf, bufiter);
+}
+
+static ssize_t tracing_clock_write(struct file *filp, const char __user *ubuf,
+                                   size_t cnt, loff_t *fpos)
+{
+        char buf[64];
+        const char *clockstr;
+        int i;
+
+        if (cnt >= sizeof(buf))
+                return -EINVAL;
+
+        if (copy_from_user(&buf, ubuf, cnt))
+                return -EFAULT;
+
+        buf[cnt] = 0;
+
+        clockstr = strstrip(buf);
+
+        for (i = 0; i < ARRAY_SIZE(trace_clocks); i++) {
+                if (strcmp(trace_clocks[i].name, clockstr) == 0)
+                        break;
+        }
+        if (i == ARRAY_SIZE(trace_clocks))
+                return -EINVAL;
+
+        trace_clock_id = i;
+
+        mutex_lock(&trace_types_lock);
+
+        ring_buffer_set_clock(global_trace.buffer, trace_clocks[i].func);
+        if (max_tr.buffer)
+                ring_buffer_set_clock(max_tr.buffer, trace_clocks[i].func);
+
+        mutex_unlock(&trace_types_lock);
+
+        *fpos += cnt;
+
+        return cnt;
+}
+
 static const struct file_operations tracing_max_lat_fops = {
         .open           = tracing_open_generic,
         .read           = tracing_max_lat_read,
@@ -3353,6 +3355,12 @@ static const struct file_operations tracing_mark_fops = {
         .write          = tracing_mark_write,
 };
 
+static const struct file_operations trace_clock_fops = {
+        .open           = tracing_open_generic,
+        .read           = tracing_clock_read,
+        .write          = tracing_clock_write,
+};
+
 struct ftrace_buffer_info {
         struct trace_array      *tr;
         void                    *spare;
@@ -3633,9 +3641,6 @@ tracing_stats_read(struct file *filp, char __user *ubuf,
         cnt = ring_buffer_commit_overrun_cpu(tr->buffer, cpu);
         trace_seq_printf(s, "commit overrun: %ld\n", cnt);
 
-        cnt = ring_buffer_nmi_dropped_cpu(tr->buffer, cpu);
-        trace_seq_printf(s, "nmi dropped: %ld\n", cnt);
-
         count = simple_read_from_buffer(ubuf, count, ppos, s->buffer, s->len);
 
         kfree(s);
@@ -4066,11 +4071,13 @@ static __init int tracer_init_debugfs(void)
         trace_create_file("current_tracer", 0644, d_tracer,
                         &global_trace, &set_tracer_fops);
 
+#ifdef CONFIG_TRACER_MAX_TRACE
         trace_create_file("tracing_max_latency", 0644, d_tracer,
                         &tracing_max_latency, &tracing_max_lat_fops);
 
         trace_create_file("tracing_thresh", 0644, d_tracer,
                         &tracing_thresh, &tracing_max_lat_fops);
+#endif
 
         trace_create_file("README", 0444, d_tracer,
                         NULL, &tracing_readme_fops);
@@ -4087,6 +4094,9 @@ static __init int tracer_init_debugfs(void)
         trace_create_file("saved_cmdlines", 0444, d_tracer,
                         NULL, &tracing_saved_cmdlines_fops);
 
+        trace_create_file("trace_clock", 0644, d_tracer, NULL,
+                          &trace_clock_fops);
+
 #ifdef CONFIG_DYNAMIC_FTRACE
         trace_create_file("dyn_ftrace_total_info", 0444, d_tracer,
                         &ftrace_update_tot_cnt, &tracing_dyn_info_fops);
@@ -4265,7 +4275,6 @@ void ftrace_dump(void)
 
 __init static int tracer_alloc_buffers(void)
 {
-        struct trace_array_cpu *data;
         int ring_buf_size;
         int i;
         int ret = -ENOMEM;
@@ -4315,7 +4324,7 @@ __init static int tracer_alloc_buffers(void)
 
         /* Allocate the first page for all buffers */
         for_each_tracing_cpu(i) {
-                data = global_trace.data[i] = &per_cpu(global_trace_cpu, i);
+                global_trace.data[i] = &per_cpu(global_trace_cpu, i);
                 max_tr.data[i] = &per_cpu(max_data, i);
         }
 
diff --git a/kernel/trace/trace.h b/kernel/trace/trace.h
index 8b9f4f6e9559..fa1dccb579d5 100644
--- a/kernel/trace/trace.h
+++ b/kernel/trace/trace.h
@@ -34,8 +34,6 @@ enum trace_type {
         TRACE_GRAPH_ENT,
         TRACE_USER_STACK,
         TRACE_HW_BRANCHES,
-        TRACE_SYSCALL_ENTER,
-        TRACE_SYSCALL_EXIT,
         TRACE_KMEM_ALLOC,
         TRACE_KMEM_FREE,
         TRACE_POWER,
@@ -236,9 +234,6 @@ struct trace_array_cpu {
         atomic_t                disabled;
         void                    *buffer_page;   /* ring buffer spare */
 
-        /* these fields get copied into max-trace: */
-        unsigned long           trace_idx;
-        unsigned long           overrun;
         unsigned long           saved_latency;
         unsigned long           critical_start;
         unsigned long           critical_end;
@@ -246,6 +241,7 @@ struct trace_array_cpu {
         unsigned long           nice;
         unsigned long           policy;
         unsigned long           rt_priority;
+        unsigned long           skipped_entries;
         cycle_t                 preempt_timestamp;
         pid_t                   pid;
         uid_t                   uid;
@@ -319,10 +315,6 @@ extern void __ftrace_bad_type(void);
                           TRACE_KMEM_ALLOC);    \
                 IF_ASSIGN(var, ent, struct kmemtrace_free_entry,        \
                           TRACE_KMEM_FREE);     \
-                IF_ASSIGN(var, ent, struct syscall_trace_enter,         \
-                          TRACE_SYSCALL_ENTER);                         \
-                IF_ASSIGN(var, ent, struct syscall_trace_exit,          \
-                          TRACE_SYSCALL_EXIT);                          \
                 __ftrace_bad_type();                                    \
         } while (0)
 
@@ -423,12 +415,13 @@ void init_tracer_sysprof_debugfs(struct dentry *d_tracer);
 
 struct ring_buffer_event;
 
-struct ring_buffer_event *trace_buffer_lock_reserve(struct trace_array *tr,
-                                                    int type,
-                                                    unsigned long len,
-                                                    unsigned long flags,
-                                                    int pc);
-void trace_buffer_unlock_commit(struct trace_array *tr,
+struct ring_buffer_event *
+trace_buffer_lock_reserve(struct ring_buffer *buffer,
+                          int type,
+                          unsigned long len,
+                          unsigned long flags,
+                          int pc);
+void trace_buffer_unlock_commit(struct ring_buffer *buffer,
                                 struct ring_buffer_event *event,
                                 unsigned long flags, int pc);
 
@@ -467,6 +460,7 @@ void trace_function(struct trace_array *tr,
 
 void trace_graph_return(struct ftrace_graph_ret *trace);
 int trace_graph_entry(struct ftrace_graph_ent *trace);
+void set_graph_array(struct trace_array *tr);
 
 void tracing_start_cmdline_record(void);
 void tracing_stop_cmdline_record(void);
@@ -478,16 +472,40 @@ void unregister_tracer(struct tracer *type);
 
 extern unsigned long nsecs_to_usecs(unsigned long nsecs);
 
+#ifdef CONFIG_TRACER_MAX_TRACE
 extern unsigned long tracing_max_latency;
 extern unsigned long tracing_thresh;
 
 void update_max_tr(struct trace_array *tr, struct task_struct *tsk, int cpu);
 void update_max_tr_single(struct trace_array *tr,
                           struct task_struct *tsk, int cpu);
+#endif /* CONFIG_TRACER_MAX_TRACE */
 
-void __trace_stack(struct trace_array *tr,
-                   unsigned long flags,
-                   int skip, int pc);
+#ifdef CONFIG_STACKTRACE
+void ftrace_trace_stack(struct ring_buffer *buffer, unsigned long flags,
+                        int skip, int pc);
+
+void ftrace_trace_userstack(struct ring_buffer *buffer, unsigned long flags,
+                            int pc);
+
+void __trace_stack(struct trace_array *tr, unsigned long flags, int skip,
+                   int pc);
+#else
+static inline void ftrace_trace_stack(struct trace_array *tr,
+                                      unsigned long flags, int skip, int pc)
+{
+}
+
+static inline void ftrace_trace_userstack(struct trace_array *tr,
+                                          unsigned long flags, int pc)
+{
+}
+
+static inline void __trace_stack(struct trace_array *tr, unsigned long flags,
+                                 int skip, int pc)
+{
+}
+#endif /* CONFIG_STACKTRACE */
 
 extern cycle_t ftrace_now(int cpu);
 
@@ -513,6 +531,10 @@ extern unsigned long ftrace_update_tot_cnt;
 extern int DYN_FTRACE_TEST_NAME(void);
 #endif
 
+extern int ring_buffer_expanded;
+extern bool tracing_selftest_disabled;
+DECLARE_PER_CPU(local_t, ftrace_cpu_disabled);
+
 #ifdef CONFIG_FTRACE_STARTUP_TEST
 extern int trace_selftest_startup_function(struct tracer *trace,
                                            struct trace_array *tr);
@@ -544,9 +566,16 @@ extern int
 trace_vbprintk(unsigned long ip, const char *fmt, va_list args);
 extern int
 trace_vprintk(unsigned long ip, const char *fmt, va_list args);
+extern int
+trace_array_vprintk(struct trace_array *tr,
+                    unsigned long ip, const char *fmt, va_list args);
+int trace_array_printk(struct trace_array *tr,
+                       unsigned long ip, const char *fmt, ...);
 
 extern unsigned long trace_flags;
 
+extern int trace_clock_id;
+
 /* Standard output formatting function used for function return traces */
 #ifdef CONFIG_FUNCTION_GRAPH_TRACER
 extern enum print_line_t print_graph_function(struct trace_iterator *iter);
@@ -635,9 +664,8 @@ enum trace_iterator_flags {
         TRACE_ITER_PRINTK_MSGONLY       = 0x10000,
         TRACE_ITER_CONTEXT_INFO         = 0x20000, /* Print pid/cpu/time */
         TRACE_ITER_LATENCY_FMT          = 0x40000,
-        TRACE_ITER_GLOBAL_CLK           = 0x80000,
-        TRACE_ITER_SLEEP_TIME           = 0x100000,
-        TRACE_ITER_GRAPH_TIME           = 0x200000,
+        TRACE_ITER_SLEEP_TIME           = 0x80000,
+        TRACE_ITER_GRAPH_TIME           = 0x100000,
 };
 
 /*
@@ -734,6 +762,7 @@ struct ftrace_event_field {
         struct list_head        link;
         char                    *name;
         char                    *type;
+        int                     filter_type;
         int                     offset;
         int                     size;
         int                     is_signed;
@@ -743,13 +772,15 @@ struct event_filter {
         int                     n_preds;
         struct filter_pred      **preds;
         char                    *filter_string;
+        bool                    no_reset;
 };
 
 struct event_subsystem {
         struct list_head        list;
         const char              *name;
         struct dentry           *entry;
-        void                    *filter;
+        struct event_filter     *filter;
+        int                     nr_events;
 };
 
 struct filter_pred;
@@ -777,6 +808,7 @@ extern int apply_subsystem_event_filter(struct event_subsystem *system,
                                         char *filter_string);
 extern void print_subsystem_event_filter(struct event_subsystem *system,
                                          struct trace_seq *s);
+extern int filter_assign_type(const char *type);
 
 static inline int
 filter_check_discard(struct ftrace_event_call *call, void *rec,
diff --git a/kernel/trace/trace_boot.c b/kernel/trace/trace_boot.c
index a29ef23ffb47..19bfc75d467e 100644
--- a/kernel/trace/trace_boot.c
+++ b/kernel/trace/trace_boot.c
@@ -41,14 +41,12 @@ void disable_boot_trace(void)
 
 static int boot_trace_init(struct trace_array *tr)
 {
-        int cpu;
         boot_trace = tr;
 
         if (!tr)
                 return 0;
 
-        for_each_cpu(cpu, cpu_possible_mask)
-                tracing_reset(tr, cpu);
+        tracing_reset_online_cpus(tr);
 
         tracing_sched_switch_assign_trace(tr);
         return 0;
@@ -132,6 +130,7 @@ struct tracer boot_tracer __read_mostly =
 void trace_boot_call(struct boot_trace_call *bt, initcall_t fn)
 {
         struct ring_buffer_event *event;
+        struct ring_buffer *buffer;
         struct trace_boot_call *entry;
         struct trace_array *tr = boot_trace;
 
@@ -144,13 +143,14 @@ void trace_boot_call(struct boot_trace_call *bt, initcall_t fn)
         sprint_symbol(bt->func, (unsigned long)fn);
         preempt_disable();
 
-        event = trace_buffer_lock_reserve(tr, TRACE_BOOT_CALL,
+        buffer = tr->buffer;
+        event = trace_buffer_lock_reserve(buffer, TRACE_BOOT_CALL,
                                           sizeof(*entry), 0, 0);
         if (!event)
                 goto out;
         entry   = ring_buffer_event_data(event);
         entry->boot_call = *bt;
-        trace_buffer_unlock_commit(tr, event, 0, 0);
+        trace_buffer_unlock_commit(buffer, event, 0, 0);
  out:
         preempt_enable();
 }
@@ -158,6 +158,7 @@ void trace_boot_call(struct boot_trace_call *bt, initcall_t fn)
 void trace_boot_ret(struct boot_trace_ret *bt, initcall_t fn)
 {
         struct ring_buffer_event *event;
+        struct ring_buffer *buffer;
         struct trace_boot_ret *entry;
         struct trace_array *tr = boot_trace;
 
@@ -167,13 +168,14 @@ void trace_boot_ret(struct boot_trace_ret *bt, initcall_t fn)
         sprint_symbol(bt->func, (unsigned long)fn);
         preempt_disable();
 
-        event = trace_buffer_lock_reserve(tr, TRACE_BOOT_RET,
+        buffer = tr->buffer;
+        event = trace_buffer_lock_reserve(buffer, TRACE_BOOT_RET,
                                           sizeof(*entry), 0, 0);
         if (!event)
                 goto out;
         entry   = ring_buffer_event_data(event);
         entry->boot_ret = *bt;
-        trace_buffer_unlock_commit(tr, event, 0, 0);
+        trace_buffer_unlock_commit(buffer, event, 0, 0);
  out:
         preempt_enable();
 }
diff --git a/kernel/trace/trace_events.c b/kernel/trace/trace_events.c
index e75276a49cf5..78b1ed230177 100644
--- a/kernel/trace/trace_events.c
+++ b/kernel/trace/trace_events.c
@@ -17,6 +17,8 @@
 #include <linux/ctype.h>
 #include <linux/delay.h>
 
+#include <asm/setup.h>
+
 #include "trace_output.h"
 
 #define TRACE_SYSTEM "TRACE_SYSTEM"
@@ -25,8 +27,9 @@ DEFINE_MUTEX(event_mutex);
 
 LIST_HEAD(ftrace_events);
 
-int trace_define_field(struct ftrace_event_call *call, char *type,
-                       char *name, int offset, int size, int is_signed)
+int trace_define_field(struct ftrace_event_call *call, const char *type,
+                       const char *name, int offset, int size, int is_signed,
+                       int filter_type)
 {
         struct ftrace_event_field *field;
 
@@ -42,9 +45,15 @@ int trace_define_field(struct ftrace_event_call *call, char *type,
         if (!field->type)
                 goto err;
 
+        if (filter_type == FILTER_OTHER)
+                field->filter_type = filter_assign_type(type);
+        else
+                field->filter_type = filter_type;
+
         field->offset = offset;
         field->size = size;
         field->is_signed = is_signed;
+
         list_add(&field->link, &call->fields);
 
         return 0;
@@ -60,6 +69,29 @@ err:
 }
 EXPORT_SYMBOL_GPL(trace_define_field);
 
+#define __common_field(type, item)                                      \
+        ret = trace_define_field(call, #type, "common_" #item,          \
+                                 offsetof(typeof(ent), item),           \
+                                 sizeof(ent.item),                      \
+                                 is_signed_type(type), FILTER_OTHER);   \
+        if (ret)                                                        \
+                return ret;
+
+int trace_define_common_fields(struct ftrace_event_call *call)
+{
+        int ret;
+        struct trace_entry ent;
+
+        __common_field(unsigned short, type);
+        __common_field(unsigned char, flags);
+        __common_field(unsigned char, preempt_count);
+        __common_field(int, pid);
+        __common_field(int, tgid);
+
+        return ret;
+}
+EXPORT_SYMBOL_GPL(trace_define_common_fields);
+
 #ifdef CONFIG_MODULES
 
 static void trace_destroy_fields(struct ftrace_event_call *call)
@@ -84,14 +116,14 @@ static void ftrace_event_enable_disable(struct ftrace_event_call *call,
                 if (call->enabled) {
                         call->enabled = 0;
                         tracing_stop_cmdline_record();
-                        call->unregfunc();
+                        call->unregfunc(call->data);
                 }
                 break;
         case 1:
                 if (!call->enabled) {
                         call->enabled = 1;
                         tracing_start_cmdline_record();
-                        call->regfunc();
+                        call->regfunc(call->data);
                 }
                 break;
         }
@@ -574,7 +606,7 @@ event_format_read(struct file *filp, char __user *ubuf, size_t cnt,
         trace_seq_printf(s, "format:\n");
         trace_write_header(s);
 
-        r = call->show_format(s);
+        r = call->show_format(call, s);
         if (!r) {
                 /*
                  * ug!  The format output is bigger than a PAGE!!
@@ -849,8 +881,10 @@ event_subsystem_dir(const char *name, struct dentry *d_events)
 
         /* First see if we did not already create this dir */
         list_for_each_entry(system, &event_subsystems, list) {
-                if (strcmp(system->name, name) == 0)
+                if (strcmp(system->name, name) == 0) {
+                        system->nr_events++;
                         return system->entry;
+                }
         }
 
         /* need to create new entry */
@@ -869,6 +903,7 @@ event_subsystem_dir(const char *name, struct dentry *d_events)
                 return d_events;
         }
 
+        system->nr_events = 1;
         system->name = kstrdup(name, GFP_KERNEL);
         if (!system->name) {
                 debugfs_remove(system->entry);
@@ -920,15 +955,6 @@ event_create_dir(struct ftrace_event_call *call, struct dentry *d_events,
         if (strcmp(call->system, TRACE_SYSTEM) != 0)
                 d_events = event_subsystem_dir(call->system, d_events);
 
-        if (call->raw_init) {
-                ret = call->raw_init();
-                if (ret < 0) {
-                        pr_warning("Could not initialize trace point"
-                                   " events/%s\n", call->name);
-                        return ret;
-                }
-        }
-
         call->dir = debugfs_create_dir(call->name, d_events);
         if (!call->dir) {
                 pr_warning("Could not create debugfs "
@@ -945,7 +971,7 @@ event_create_dir(struct ftrace_event_call *call, struct dentry *d_events,
                                           id);
 
         if (call->define_fields) {
-                ret = call->define_fields();
+                ret = call->define_fields(call);
                 if (ret < 0) {
                         pr_warning("Could not initialize trace point"
                                    " events/%s\n", call->name);
@@ -987,6 +1013,32 @@ struct ftrace_module_file_ops {
         struct file_operations          filter;
 };
 
+static void remove_subsystem_dir(const char *name)
+{
+        struct event_subsystem *system;
+
+        if (strcmp(name, TRACE_SYSTEM) == 0)
+                return;
+
+        list_for_each_entry(system, &event_subsystems, list) {
+                if (strcmp(system->name, name) == 0) {
+                        if (!--system->nr_events) {
+                                struct event_filter *filter = system->filter;
+
+                                debugfs_remove_recursive(system->entry);
+                                list_del(&system->list);
+                                if (filter) {
+                                        kfree(filter->filter_string);
+                                        kfree(filter);
+                                }
+                                kfree(system->name);
+                                kfree(system);
+                        }
+                        break;
+                }
+        }
+}
+
 static struct ftrace_module_file_ops *
 trace_create_file_ops(struct module *mod)
 {
@@ -1027,6 +1079,7 @@ static void trace_module_add_events(struct module *mod)
         struct ftrace_module_file_ops *file_ops = NULL;
         struct ftrace_event_call *call, *start, *end;
         struct dentry *d_events;
+        int ret;
 
         start = mod->trace_events;
         end = mod->trace_events + mod->num_trace_events;
@@ -1042,7 +1095,15 @@ static void trace_module_add_events(struct module *mod)
                 /* The linker may leave blanks */
                 if (!call->name)
                         continue;
-
+                if (call->raw_init) {
+                        ret = call->raw_init();
+                        if (ret < 0) {
+                                if (ret != -ENOSYS)
+                                        pr_warning("Could not initialize trace "
+                                        "point events/%s\n", call->name);
+                                continue;
+                        }
+                }
                 /*
                  * This module has events, create file ops for this module
                  * if not already done.
@@ -1077,6 +1138,7 @@ static void trace_module_remove_events(struct module *mod)
                         list_del(&call->list);
                         trace_destroy_fields(call);
                         destroy_preds(call);
+                        remove_subsystem_dir(call->system);
                 }
         }
 
@@ -1133,6 +1195,18 @@ struct notifier_block trace_module_nb = {
 extern struct ftrace_event_call __start_ftrace_events[];
 extern struct ftrace_event_call __stop_ftrace_events[];
 
+static char bootup_event_buf[COMMAND_LINE_SIZE] __initdata;
+
+static __init int setup_trace_event(char *str)
+{
+        strlcpy(bootup_event_buf, str, COMMAND_LINE_SIZE);
+        ring_buffer_expanded = 1;
+        tracing_selftest_disabled = 1;
+
+        return 1;
+}
+__setup("trace_event=", setup_trace_event);
+
 static __init int event_trace_init(void)
 {
         struct ftrace_event_call *call;
@@ -1140,6 +1214,8 @@ static __init int event_trace_init(void)
         struct dentry *entry;
         struct dentry *d_events;
         int ret;
+        char *buf = bootup_event_buf;
+        char *token;
 
         d_tracer = tracing_init_dentry();
         if (!d_tracer)
@@ -1179,12 +1255,34 @@ static __init int event_trace_init(void)
                 /* The linker may leave blanks */
                 if (!call->name)
                         continue;
+                if (call->raw_init) {
+                        ret = call->raw_init();
+                        if (ret < 0) {
+                                if (ret != -ENOSYS)
+                                        pr_warning("Could not initialize trace "
+                                        "point events/%s\n", call->name);
+                                continue;
+                        }
+                }
                 list_add(&call->list, &ftrace_events);
                 event_create_dir(call, d_events, &ftrace_event_id_fops,
                                  &ftrace_enable_fops, &ftrace_event_filter_fops,
                                  &ftrace_event_format_fops);
         }
 
+        while (true) {
+                token = strsep(&buf, ",");
+
+                if (!token)
+                        break;
+                if (!*token)
+                        continue;
+
+                ret = ftrace_set_clr_event(token, 1);
+                if (ret)
+                        pr_warning("Failed to enable trace event: %s\n", token);
+        }
+
         ret = register_module_notifier(&trace_module_nb);
         if (ret)
                 pr_warning("Failed to register trace events module notifier\n");
@@ -1340,6 +1438,7 @@ static void
 function_test_events_call(unsigned long ip, unsigned long parent_ip)
 {
         struct ring_buffer_event *event;
+        struct ring_buffer *buffer;
         struct ftrace_entry *entry;
         unsigned long flags;
         long disabled;
@@ -1357,7 +1456,8 @@ function_test_events_call(unsigned long ip, unsigned long parent_ip)
 
         local_save_flags(flags);
 
-        event = trace_current_buffer_lock_reserve(TRACE_FN, sizeof(*entry),
+        event = trace_current_buffer_lock_reserve(&buffer,
+                                                  TRACE_FN, sizeof(*entry),
                                                   flags, pc);
         if (!event)
                 goto out;
@@ -1365,7 +1465,7 @@ function_test_events_call(unsigned long ip, unsigned long parent_ip)
         entry->ip                       = ip;
         entry->parent_ip                = parent_ip;
 
-        trace_nowake_buffer_unlock_commit(event, flags, pc);
+        trace_nowake_buffer_unlock_commit(buffer, event, flags, pc);
 
  out:
         atomic_dec(&per_cpu(test_event_disable, cpu));
@@ -1392,10 +1492,10 @@ static __init void event_trace_self_test_with_function(void)
 
 static __init int event_trace_self_tests_init(void)
 {
-
-        event_trace_self_tests();
-
-        event_trace_self_test_with_function();
+        if (!tracing_selftest_disabled) {
+                event_trace_self_tests();
+                event_trace_self_test_with_function();
+        }
 
         return 0;
 }
diff --git a/kernel/trace/trace_events_filter.c b/kernel/trace/trace_events_filter.c
index f32dc9d1ea7b..93660fbbf629 100644
--- a/kernel/trace/trace_events_filter.c
+++ b/kernel/trace/trace_events_filter.c
@@ -163,6 +163,20 @@ static int filter_pred_string(struct filter_pred *pred, void *event,
         return match;
 }
 
+/* Filter predicate for char * pointers */
+static int filter_pred_pchar(struct filter_pred *pred, void *event,
+                             int val1, int val2)
+{
+        char **addr = (char **)(event + pred->offset);
+        int cmp, match;
+
+        cmp = strncmp(*addr, pred->str_val, pred->str_len);
+
+        match = (!cmp) ^ pred->not;
+
+        return match;
+}
+
 /*
  * Filter predicate for dynamic sized arrays of characters.
  * These are implemented through a list of strings at the end
@@ -176,11 +190,13 @@ static int filter_pred_string(struct filter_pred *pred, void *event,
 static int filter_pred_strloc(struct filter_pred *pred, void *event,
                               int val1, int val2)
 {
-        unsigned short str_loc = *(unsigned short *)(event + pred->offset);
+        u32 str_item = *(u32 *)(event + pred->offset);
+        int str_loc = str_item & 0xffff;
+        int str_len = str_item >> 16;
         char *addr = (char *)(event + str_loc);
         int cmp, match;
 
-        cmp = strncmp(addr, pred->str_val, pred->str_len);
+        cmp = strncmp(addr, pred->str_val, str_len);
 
         match = (!cmp) ^ pred->not;
 
@@ -293,7 +309,7 @@ void print_event_filter(struct ftrace_event_call *call, struct trace_seq *s)
         struct event_filter *filter = call->filter;
 
         mutex_lock(&event_mutex);
-        if (filter->filter_string)
+        if (filter && filter->filter_string)
                 trace_seq_printf(s, "%s\n", filter->filter_string);
         else
                 trace_seq_printf(s, "none\n");
@@ -306,7 +322,7 @@ void print_subsystem_event_filter(struct event_subsystem *system,
         struct event_filter *filter = system->filter;
 
         mutex_lock(&event_mutex);
-        if (filter->filter_string)
+        if (filter && filter->filter_string)
                 trace_seq_printf(s, "%s\n", filter->filter_string);
         else
                 trace_seq_printf(s, "none\n");
@@ -374,6 +390,9 @@ void destroy_preds(struct ftrace_event_call *call)
         struct event_filter *filter = call->filter;
         int i;
 
+        if (!filter)
+                return;
+
         for (i = 0; i < MAX_FILTER_PRED; i++) {
                 if (filter->preds[i])
                         filter_free_pred(filter->preds[i]);
@@ -384,17 +403,19 @@ void destroy_preds(struct ftrace_event_call *call)
         call->filter = NULL;
 }
 
-int init_preds(struct ftrace_event_call *call)
+static int init_preds(struct ftrace_event_call *call)
 {
         struct event_filter *filter;
         struct filter_pred *pred;
         int i;
 
+        if (call->filter)
+                return 0;
+
         filter = call->filter = kzalloc(sizeof(*filter), GFP_KERNEL);
         if (!call->filter)
                 return -ENOMEM;
 
-        call->filter_active = 0;
         filter->n_preds = 0;
 
         filter->preds = kzalloc(MAX_FILTER_PRED * sizeof(pred), GFP_KERNEL);
@@ -416,30 +437,55 @@ oom:
 
         return -ENOMEM;
 }
-EXPORT_SYMBOL_GPL(init_preds);
 
-static void filter_free_subsystem_preds(struct event_subsystem *system)
+static int init_subsystem_preds(struct event_subsystem *system)
 {
-        struct event_filter *filter = system->filter;
         struct ftrace_event_call *call;
-        int i;
+        int err;
 
-        if (filter->n_preds) {
-                for (i = 0; i < filter->n_preds; i++)
-                        filter_free_pred(filter->preds[i]);
-                kfree(filter->preds);
-                filter->preds = NULL;
-                filter->n_preds = 0;
+        list_for_each_entry(call, &ftrace_events, list) {
+                if (!call->define_fields)
+                        continue;
+
+                if (strcmp(call->system, system->name) != 0)
+                        continue;
+
+                err = init_preds(call);
+                if (err)
+                        return err;
         }
 
+        return 0;
+}
+
+enum {
+        FILTER_DISABLE_ALL,
+        FILTER_INIT_NO_RESET,
+        FILTER_SKIP_NO_RESET,
+};
+
+static void filter_free_subsystem_preds(struct event_subsystem *system,
+                                        int flag)
+{
+        struct ftrace_event_call *call;
+
         list_for_each_entry(call, &ftrace_events, list) {
                 if (!call->define_fields)
                         continue;
 
-                if (!strcmp(call->system, system->name)) {
-                        filter_disable_preds(call);
-                        remove_filter_string(call->filter);
+                if (strcmp(call->system, system->name) != 0)
+                        continue;
+
+                if (flag == FILTER_INIT_NO_RESET) {
+                        call->filter->no_reset = false;
+                        continue;
                 }
+
+                if (flag == FILTER_SKIP_NO_RESET && call->filter->no_reset)
+                        continue;
+
+                filter_disable_preds(call);
+                remove_filter_string(call->filter);
         }
 }
 
@@ -468,12 +514,7 @@ static int filter_add_pred_fn(struct filter_parse_state *ps,
         return 0;
 }
 
-enum {
-        FILTER_STATIC_STRING = 1,
-        FILTER_DYN_STRING
-};
-
-static int is_string_field(const char *type)
+int filter_assign_type(const char *type)
 {
         if (strstr(type, "__data_loc") && strstr(type, "char"))
                 return FILTER_DYN_STRING;
@@ -481,12 +522,19 @@ static int is_string_field(const char *type)
         if (strchr(type, '[') && strstr(type, "char"))
                 return FILTER_STATIC_STRING;
 
-        return 0;
+        return FILTER_OTHER;
+}
+
+static bool is_string_field(struct ftrace_event_field *field)
+{
+        return field->filter_type == FILTER_DYN_STRING ||
+               field->filter_type == FILTER_STATIC_STRING ||
+               field->filter_type == FILTER_PTR_STRING;
 }
 
 static int is_legal_op(struct ftrace_event_field *field, int op)
 {
-        if (is_string_field(field->type) && (op != OP_EQ && op != OP_NE))
+        if (is_string_field(field) && (op != OP_EQ && op != OP_NE))
                 return 0;
 
         return 1;
@@ -537,22 +585,24 @@ static filter_pred_fn_t select_comparison_fn(int op, int field_size,
 
 static int filter_add_pred(struct filter_parse_state *ps,
                            struct ftrace_event_call *call,
-                           struct filter_pred *pred)
+                           struct filter_pred *pred,
+                           bool dry_run)
 {
         struct ftrace_event_field *field;
         filter_pred_fn_t fn;
         unsigned long long val;
-        int string_type;
         int ret;
 
         pred->fn = filter_pred_none;
 
         if (pred->op == OP_AND) {
                 pred->pop_n = 2;
-                return filter_add_pred_fn(ps, call, pred, filter_pred_and);
+                fn = filter_pred_and;
+                goto add_pred_fn;
         } else if (pred->op == OP_OR) {
                 pred->pop_n = 2;
-                return filter_add_pred_fn(ps, call, pred, filter_pred_or);
+                fn = filter_pred_or;
+                goto add_pred_fn;
         }
 
         field = find_event_field(call, pred->field_name);
@@ -568,16 +618,17 @@ static int filter_add_pred(struct filter_parse_state *ps,
                 return -EINVAL;
         }
 
-        string_type = is_string_field(field->type);
-        if (string_type) {
-                if (string_type == FILTER_STATIC_STRING)
+        if (is_string_field(field)) {
+                pred->str_len = field->size;
+
+                if (field->filter_type == FILTER_STATIC_STRING)
                         fn = filter_pred_string;
-                else
+                else if (field->filter_type == FILTER_DYN_STRING)
                         fn = filter_pred_strloc;
-                pred->str_len = field->size;
-                if (pred->op == OP_NE)
-                        pred->not = 1;
-                return filter_add_pred_fn(ps, call, pred, fn);
+                else {
+                        fn = filter_pred_pchar;
+                        pred->str_len = strlen(pred->str_val);
+                }
         } else {
                 if (field->is_signed)
                         ret = strict_strtoll(pred->str_val, 0, &val);
@@ -588,41 +639,33 @@ static int filter_add_pred(struct filter_parse_state *ps,
                         return -EINVAL;
                 }
                 pred->val = val;
-        }
 
-        fn = select_comparison_fn(pred->op, field->size, field->is_signed);
-        if (!fn) {
-                parse_error(ps, FILT_ERR_INVALID_OP, 0);
-                return -EINVAL;
+                fn = select_comparison_fn(pred->op, field->size,
+                                          field->is_signed);
+                if (!fn) {
+                        parse_error(ps, FILT_ERR_INVALID_OP, 0);
+                        return -EINVAL;
+                }
         }
 
         if (pred->op == OP_NE)
                 pred->not = 1;
 
-        return filter_add_pred_fn(ps, call, pred, fn);
+add_pred_fn:
+        if (!dry_run)
+                return filter_add_pred_fn(ps, call, pred, fn);
+        return 0;
 }
 
 static int filter_add_subsystem_pred(struct filter_parse_state *ps,
                                      struct event_subsystem *system,
                                      struct filter_pred *pred,
-                                     char *filter_string)
+                                     char *filter_string,
+                                     bool dry_run)
 {
-        struct event_filter *filter = system->filter;
         struct ftrace_event_call *call;
         int err = 0;
-
-        if (!filter->preds) {
-                filter->preds = kzalloc(MAX_FILTER_PRED * sizeof(pred),
-                                        GFP_KERNEL);
-
-                if (!filter->preds)
-                        return -ENOMEM;
-        }
-
-        if (filter->n_preds == MAX_FILTER_PRED) {
-                parse_error(ps, FILT_ERR_TOO_MANY_PREDS, 0);
-                return -ENOSPC;
-        }
+        bool fail = true;
 
         list_for_each_entry(call, &ftrace_events, list) {
 
@@ -632,19 +675,24 @@ static int filter_add_subsystem_pred(struct filter_parse_state *ps,
                 if (strcmp(call->system, system->name))
                         continue;
 
-                err = filter_add_pred(ps, call, pred);
-                if (err) {
-                        filter_free_subsystem_preds(system);
-                        parse_error(ps, FILT_ERR_BAD_SUBSYS_FILTER, 0);
-                        goto out;
-                }
-                replace_filter_string(call->filter, filter_string);
+                if (call->filter->no_reset)
+                        continue;
+
+                err = filter_add_pred(ps, call, pred, dry_run);
+                if (err)
+                        call->filter->no_reset = true;
+                else
+                        fail = false;
+
+                if (!dry_run)
+                        replace_filter_string(call->filter, filter_string);
         }
 
-        filter->preds[filter->n_preds] = pred;
-        filter->n_preds++;
-out:
-        return err;
+        if (fail) {
+                parse_error(ps, FILT_ERR_BAD_SUBSYS_FILTER, 0);
+                return err;
+        }
+        return 0;
 }
 
 static void parse_init(struct filter_parse_state *ps,
@@ -1003,12 +1051,14 @@ static int check_preds(struct filter_parse_state *ps)
 static int replace_preds(struct event_subsystem *system,
                          struct ftrace_event_call *call,
                          struct filter_parse_state *ps,
-                         char *filter_string)
+                         char *filter_string,
+                         bool dry_run)
 {
         char *operand1 = NULL, *operand2 = NULL;
         struct filter_pred *pred;
         struct postfix_elt *elt;
         int err;
+        int n_preds = 0;
 
         err = check_preds(ps);
         if (err)
@@ -1027,24 +1077,14 @@ static int replace_preds(struct event_subsystem *system,
                         continue;
                 }
 
+                if (n_preds++ == MAX_FILTER_PRED) {
+                        parse_error(ps, FILT_ERR_TOO_MANY_PREDS, 0);
+                        return -ENOSPC;
+                }
+
                 if (elt->op == OP_AND || elt->op == OP_OR) {
                         pred = create_logical_pred(elt->op);
-                        if (!pred)
-                                return -ENOMEM;
-                        if (call) {
-                                err = filter_add_pred(ps, call, pred);
-                                filter_free_pred(pred);
-                        } else {
-                                err = filter_add_subsystem_pred(ps, system,
-                                                        pred, filter_string);
-                                if (err)
-                                        filter_free_pred(pred);
-                        }
-                        if (err)
-                                return err;
-
-                        operand1 = operand2 = NULL;
-                        continue;
+                        goto add_pred;
                 }
 
                 if (!operand1 || !operand2) {
@@ -1053,17 +1093,15 @@ static int replace_preds(struct event_subsystem *system,
                 }
 
                 pred = create_pred(elt->op, operand1, operand2);
+add_pred:
                 if (!pred)
                         return -ENOMEM;
-                if (call) {
-                        err = filter_add_pred(ps, call, pred);
-                        filter_free_pred(pred);
-                } else {
+                if (call)
+                        err = filter_add_pred(ps, call, pred, false);
+                else
                         err = filter_add_subsystem_pred(ps, system, pred,
-                                                        filter_string);
-                        if (err)
-                                filter_free_pred(pred);
-                }
+                                                filter_string, dry_run);
+                filter_free_pred(pred);
                 if (err)
                         return err;
 
@@ -1081,6 +1119,10 @@ int apply_event_filter(struct ftrace_event_call *call, char *filter_string)
 
         mutex_lock(&event_mutex);
 
+        err = init_preds(call);
+        if (err)
+                goto out_unlock;
+
         if (!strcmp(strstrip(filter_string), "0")) {
                 filter_disable_preds(call);
                 remove_filter_string(call->filter);
@@ -1103,7 +1145,7 @@ int apply_event_filter(struct ftrace_event_call *call, char *filter_string)
                 goto out;
         }
 
-        err = replace_preds(NULL, call, ps, filter_string);
+        err = replace_preds(NULL, call, ps, filter_string, false);
         if (err)
                 append_filter_err(ps, call->filter);
 
@@ -1126,8 +1168,12 @@ int apply_subsystem_event_filter(struct event_subsystem *system,
 
         mutex_lock(&event_mutex);
 
+        err = init_subsystem_preds(system);
+        if (err)
+                goto out_unlock;
+
         if (!strcmp(strstrip(filter_string), "0")) {
-                filter_free_subsystem_preds(system);
+                filter_free_subsystem_preds(system, FILTER_DISABLE_ALL);
                 remove_filter_string(system->filter);
                 mutex_unlock(&event_mutex);
                 return 0;
@@ -1138,7 +1184,6 @@ int apply_subsystem_event_filter(struct event_subsystem *system,
         if (!ps)
                 goto out_unlock;
 
-        filter_free_subsystem_preds(system);
         replace_filter_string(system->filter, filter_string);
 
         parse_init(ps, filter_ops, filter_string);
@@ -1148,9 +1193,23 @@ int apply_subsystem_event_filter(struct event_subsystem *system,
                 goto out;
         }
 
-        err = replace_preds(system, NULL, ps, filter_string);
-        if (err)
+        filter_free_subsystem_preds(system, FILTER_INIT_NO_RESET);
+
+        /* try to see the filter can be applied to which events */
+        err = replace_preds(system, NULL, ps, filter_string, true);
+        if (err) {
                 append_filter_err(ps, system->filter);
+                goto out;
+        }
+
+        filter_free_subsystem_preds(system, FILTER_SKIP_NO_RESET);
+
+        /* really apply the filter to the events */
+        err = replace_preds(system, NULL, ps, filter_string, false);
+        if (err) {
+                append_filter_err(ps, system->filter);
+                filter_free_subsystem_preds(system, 2);
+        }
 
 out:
         filter_opstack_clear(ps);
diff --git a/kernel/trace/trace_export.c b/kernel/trace/trace_export.c
index d06cf898dc86..df1bf6e48bb9 100644
--- a/kernel/trace/trace_export.c
+++ b/kernel/trace/trace_export.c
@@ -60,7 +60,8 @@ extern void __bad_type_size(void);
 #undef TRACE_EVENT_FORMAT
 #define TRACE_EVENT_FORMAT(call, proto, args, fmt, tstruct, tpfmt)      \
 static int                                                              \
-ftrace_format_##call(struct trace_seq *s)                               \
+ftrace_format_##call(struct ftrace_event_call *unused,                  \
+                      struct trace_seq *s)                              \
 {                                                                       \
         struct args field;                                              \
         int ret;                                                        \
@@ -76,7 +77,8 @@ ftrace_format_##call(struct trace_seq *s)				\
 #define TRACE_EVENT_FORMAT_NOFILTER(call, proto, args, fmt, tstruct,    \
                                     tpfmt)                              \
 static int                                                              \
-ftrace_format_##call(struct trace_seq *s)                               \
+ftrace_format_##call(struct ftrace_event_call *unused,                  \
+                      struct trace_seq *s)                              \
 {                                                                       \
         struct args field;                                              \
         int ret;                                                        \
@@ -117,7 +119,7 @@ ftrace_format_##call(struct trace_seq *s)				\
 
 #undef TRACE_EVENT_FORMAT
 #define TRACE_EVENT_FORMAT(call, proto, args, fmt, tstruct, tpfmt)      \
-int ftrace_define_fields_##call(void);                                  \
+int ftrace_define_fields_##call(struct ftrace_event_call *event_call);  \
 static int ftrace_raw_init_event_##call(void);                          \
                                                                         \
 struct ftrace_event_call __used                                         \
@@ -133,7 +135,6 @@ __attribute__((section("_ftrace_events"))) event_##call = {		\
 static int ftrace_raw_init_event_##call(void)                           \
 {                                                                       \
         INIT_LIST_HEAD(&event_##call.fields);                           \
-        init_preds(&event_##call);                                      \
         return 0;                                                       \
 }                                                                       \
 
@@ -156,7 +157,8 @@ __attribute__((section("_ftrace_events"))) event_##call = {		\
 #define TRACE_FIELD(type, item, assign)                                 \
         ret = trace_define_field(event_call, #type, #item,              \
                                  offsetof(typeof(field), item),         \
-                                 sizeof(field.item), is_signed_type(type));     \
+                                 sizeof(field.item),                    \
+                                 is_signed_type(type), FILTER_OTHER);   \
         if (ret)                                                        \
                 return ret;
 
@@ -164,7 +166,7 @@ __attribute__((section("_ftrace_events"))) event_##call = {		\
 #define TRACE_FIELD_SPECIAL(type, item, len, cmd)                       \
         ret = trace_define_field(event_call, #type "[" #len "]", #item, \
                                  offsetof(typeof(field), item),         \
-                                 sizeof(field.item), 0);                \
+                                 sizeof(field.item), 0, FILTER_OTHER);  \
         if (ret)                                                        \
                 return ret;
 
@@ -172,7 +174,8 @@ __attribute__((section("_ftrace_events"))) event_##call = {		\
 #define TRACE_FIELD_SIGN(type, item, assign, is_signed)                 \
         ret = trace_define_field(event_call, #type, #item,              \
                                  offsetof(typeof(field), item),         \
-                                 sizeof(field.item), is_signed);        \
+                                 sizeof(field.item), is_signed,         \
+                                 FILTER_OTHER);                         \
         if (ret)                                                        \
                 return ret;
 
@@ -182,17 +185,14 @@ __attribute__((section("_ftrace_events"))) event_##call = {		\
 #undef TRACE_EVENT_FORMAT
 #define TRACE_EVENT_FORMAT(call, proto, args, fmt, tstruct, tpfmt)      \
 int                                                                     \
-ftrace_define_fields_##call(void)                                       \
+ftrace_define_fields_##call(struct ftrace_event_call *event_call)       \
 {                                                                       \
-        struct ftrace_event_call *event_call = &event_##call;           \
         struct args field;                                              \
         int ret;                                                        \
                                                                         \
-        __common_field(unsigned char, type, 0);                         \
-        __common_field(unsigned char, flags, 0);                        \
-        __common_field(unsigned char, preempt_count, 0);                \
-        __common_field(int, pid, 1);                                    \
-        __common_field(int, tgid, 1);                                   \
+        ret = trace_define_common_fields(event_call);                   \
+        if (ret)                                                        \
+                return ret;                                             \
                                                                         \
         tstruct;                                                        \
                                                                         \
diff --git a/kernel/trace/trace_functions.c b/kernel/trace/trace_functions.c
index 75ef000613c3..5b01b94518fc 100644
--- a/kernel/trace/trace_functions.c
+++ b/kernel/trace/trace_functions.c
@@ -288,11 +288,9 @@ static int
 ftrace_trace_onoff_print(struct seq_file *m, unsigned long ip,
                          struct ftrace_probe_ops *ops, void *data)
 {
-        char str[KSYM_SYMBOL_LEN];
         long count = (long)data;
 
-        kallsyms_lookup(ip, NULL, NULL, NULL, str);
-        seq_printf(m, "%s:", str);
+        seq_printf(m, "%pf:", (void *)ip);
 
         if (ops == &traceon_probe_ops)
                 seq_printf(m, "traceon");
diff --git a/kernel/trace/trace_functions_graph.c b/kernel/trace/trace_functions_graph.c
index 420ec3487579..b3749a2c3132 100644
--- a/kernel/trace/trace_functions_graph.c
+++ b/kernel/trace/trace_functions_graph.c
@@ -52,7 +52,7 @@ static struct tracer_flags tracer_flags = {
         .opts = trace_opts
 };
 
-/* pid on the last trace processed */
+static struct trace_array *graph_array;
 
 
 /* Add a function return address to the trace stack on thread info.*/
@@ -166,10 +166,123 @@ unsigned long ftrace_return_to_handler(unsigned long frame_pointer)
         return ret;
 }
 
+static int __trace_graph_entry(struct trace_array *tr,
+                                struct ftrace_graph_ent *trace,
+                                unsigned long flags,
+                                int pc)
+{
+        struct ftrace_event_call *call = &event_funcgraph_entry;
+        struct ring_buffer_event *event;
+        struct ring_buffer *buffer = tr->buffer;
+        struct ftrace_graph_ent_entry *entry;
+
+        if (unlikely(local_read(&__get_cpu_var(ftrace_cpu_disabled))))
+                return 0;
+
+        event = trace_buffer_lock_reserve(buffer, TRACE_GRAPH_ENT,
+                                          sizeof(*entry), flags, pc);
+        if (!event)
+                return 0;
+        entry   = ring_buffer_event_data(event);
+        entry->graph_ent                        = *trace;
+        if (!filter_current_check_discard(buffer, call, entry, event))
+                ring_buffer_unlock_commit(buffer, event);
+
+        return 1;
+}
+
+int trace_graph_entry(struct ftrace_graph_ent *trace)
+{
+        struct trace_array *tr = graph_array;
+        struct trace_array_cpu *data;
+        unsigned long flags;
+        long disabled;
+        int ret;
+        int cpu;
+        int pc;
+
+        if (unlikely(!tr))
+                return 0;
+
+        if (!ftrace_trace_task(current))
+                return 0;
+
+        if (!ftrace_graph_addr(trace->func))
+                return 0;
+
+        local_irq_save(flags);
+        cpu = raw_smp_processor_id();
+        data = tr->data[cpu];
+        disabled = atomic_inc_return(&data->disabled);
+        if (likely(disabled == 1)) {
+                pc = preempt_count();
+                ret = __trace_graph_entry(tr, trace, flags, pc);
+        } else {
+                ret = 0;
+        }
+        /* Only do the atomic if it is not already set */
+        if (!test_tsk_trace_graph(current))
+                set_tsk_trace_graph(current);
+
+        atomic_dec(&data->disabled);
+        local_irq_restore(flags);
+
+        return ret;
+}
+
+static void __trace_graph_return(struct trace_array *tr,
+                                struct ftrace_graph_ret *trace,
+                                unsigned long flags,
+                                int pc)
+{
+        struct ftrace_event_call *call = &event_funcgraph_exit;
+        struct ring_buffer_event *event;
+        struct ring_buffer *buffer = tr->buffer;
+        struct ftrace_graph_ret_entry *entry;
+
+        if (unlikely(local_read(&__get_cpu_var(ftrace_cpu_disabled))))
+                return;
+
+        event = trace_buffer_lock_reserve(buffer, TRACE_GRAPH_RET,
+                                          sizeof(*entry), flags, pc);
+        if (!event)
+                return;
+        entry   = ring_buffer_event_data(event);
+        entry->ret                              = *trace;
+        if (!filter_current_check_discard(buffer, call, entry, event))
+                ring_buffer_unlock_commit(buffer, event);
+}
+
+void trace_graph_return(struct ftrace_graph_ret *trace)
+{
+        struct trace_array *tr = graph_array;
+        struct trace_array_cpu *data;
+        unsigned long flags;
+        long disabled;
+        int cpu;
+        int pc;
+
+        local_irq_save(flags);
+        cpu = raw_smp_processor_id();
+        data = tr->data[cpu];
+        disabled = atomic_inc_return(&data->disabled);
+        if (likely(disabled == 1)) {
+                pc = preempt_count();
+                __trace_graph_return(tr, trace, flags, pc);
+        }
+        if (!trace->depth)
+                clear_tsk_trace_graph(current);
+        atomic_dec(&data->disabled);
+        local_irq_restore(flags);
+}
+
 static int graph_trace_init(struct trace_array *tr)
 {
-        int ret = register_ftrace_graph(&trace_graph_return,
-                                        &trace_graph_entry);
+        int ret;
+
+        graph_array = tr;
+        ret = register_ftrace_graph(&trace_graph_return,
+                                    &trace_graph_entry);
         if (ret)
                 return ret;
         tracing_start_cmdline_record();
@@ -177,49 +290,30 @@ static int graph_trace_init(struct trace_array *tr)
         return 0;
 }
 
+void set_graph_array(struct trace_array *tr)
+{
+        graph_array = tr;
+}
+
 static void graph_trace_reset(struct trace_array *tr)
 {
         tracing_stop_cmdline_record();
         unregister_ftrace_graph();
 }
 
-static inline int log10_cpu(int nb)
-{
-        if (nb / 100)
-                return 3;
-        if (nb / 10)
-                return 2;
-        return 1;
-}
+static int max_bytes_for_cpu;
 
 static enum print_line_t
 print_graph_cpu(struct trace_seq *s, int cpu)
 {
-        int i;
         int ret;
-        int log10_this = log10_cpu(cpu);
-        int log10_all = log10_cpu(cpumask_weight(cpu_online_mask));
-
 
         /*
          * Start with a space character - to make it stand out
          * to the right a bit when trace output is pasted into
          * email:
          */
-        ret = trace_seq_printf(s, " ");
-
-        /*
-         * Tricky - we space the CPU field according to the max
-         * number of online CPUs. On a 2-cpu system it would take
-         * a maximum of 1 digit - on a 128 cpu system it would
-         * take up to 3 digits:
-         */
-        for (i = 0; i < log10_all - log10_this; i++) {
-                ret = trace_seq_printf(s, " ");
-                if (!ret)
-                        return TRACE_TYPE_PARTIAL_LINE;
-        }
-        ret = trace_seq_printf(s, "%d) ", cpu);
+        ret = trace_seq_printf(s, " %*d) ", max_bytes_for_cpu, cpu);
         if (!ret)
                 return TRACE_TYPE_PARTIAL_LINE;
 
@@ -565,11 +659,7 @@ print_graph_entry_leaf(struct trace_iterator *iter,
                         return TRACE_TYPE_PARTIAL_LINE;
         }
 
-        ret = seq_print_ip_sym(s, call->func, 0);
-        if (!ret)
-                return TRACE_TYPE_PARTIAL_LINE;
-
-        ret = trace_seq_printf(s, "();\n");
+        ret = trace_seq_printf(s, "%pf();\n", (void *)call->func);
         if (!ret)
                 return TRACE_TYPE_PARTIAL_LINE;
 
@@ -612,11 +702,7 @@ print_graph_entry_nested(struct trace_iterator *iter,
                         return TRACE_TYPE_PARTIAL_LINE;
         }
 
-        ret = seq_print_ip_sym(s, call->func, 0);
-        if (!ret)
-                return TRACE_TYPE_PARTIAL_LINE;
-
-        ret = trace_seq_printf(s, "() {\n");
+        ret = trace_seq_printf(s, "%pf() {\n", (void *)call->func);
         if (!ret)
                 return TRACE_TYPE_PARTIAL_LINE;
 
@@ -934,6 +1020,8 @@ static struct tracer graph_trace __read_mostly = {
 
 static __init int init_graph_trace(void)
 {
+        max_bytes_for_cpu = snprintf(NULL, 0, "%d", nr_cpu_ids - 1);
+
         return register_tracer(&graph_trace);
 }
 
diff --git a/kernel/trace/trace_irqsoff.c b/kernel/trace/trace_irqsoff.c
index b923d13e2fad..5555b75a0d12 100644
--- a/kernel/trace/trace_irqsoff.c
+++ b/kernel/trace/trace_irqsoff.c
@@ -178,7 +178,6 @@ out_unlock:
 out:
         data->critical_sequence = max_sequence;
         data->preempt_timestamp = ftrace_now(cpu);
-        tracing_reset(tr, cpu);
         trace_function(tr, CALLER_ADDR0, parent_ip, flags, pc);
 }
 
@@ -208,7 +207,6 @@ start_critical_timing(unsigned long ip, unsigned long parent_ip)
         data->critical_sequence = max_sequence;
         data->preempt_timestamp = ftrace_now(cpu);
         data->critical_start = parent_ip ? : ip;
-        tracing_reset(tr, cpu);
 
         local_save_flags(flags);
 
@@ -379,6 +377,7 @@ static void __irqsoff_tracer_init(struct trace_array *tr)
         irqsoff_trace = tr;
         /* make sure that the tracer is visible */
         smp_wmb();
+        tracing_reset_online_cpus(tr);
         start_irqsoff_tracer(tr);
 }
 
diff --git a/kernel/trace/trace_mmiotrace.c b/kernel/trace/trace_mmiotrace.c
index d53b45ed0806..c4c9bbda53d3 100644
--- a/kernel/trace/trace_mmiotrace.c
+++ b/kernel/trace/trace_mmiotrace.c
@@ -307,11 +307,12 @@ static void __trace_mmiotrace_rw(struct trace_array *tr,
                                 struct trace_array_cpu *data,
                                 struct mmiotrace_rw *rw)
 {
+        struct ring_buffer *buffer = tr->buffer;
         struct ring_buffer_event *event;
         struct trace_mmiotrace_rw *entry;
         int pc = preempt_count();
 
-        event = trace_buffer_lock_reserve(tr, TRACE_MMIO_RW,
+        event = trace_buffer_lock_reserve(buffer, TRACE_MMIO_RW,
                                           sizeof(*entry), 0, pc);
         if (!event) {
                 atomic_inc(&dropped_count);
@@ -319,7 +320,7 @@ static void __trace_mmiotrace_rw(struct trace_array *tr,
         }
         entry   = ring_buffer_event_data(event);
         entry->rw                       = *rw;
-        trace_buffer_unlock_commit(tr, event, 0, pc);
+        trace_buffer_unlock_commit(buffer, event, 0, pc);
 }
 
 void mmio_trace_rw(struct mmiotrace_rw *rw)
@@ -333,11 +334,12 @@ static void __trace_mmiotrace_map(struct trace_array *tr,
                                 struct trace_array_cpu *data,
                                 struct mmiotrace_map *map)
 {
+        struct ring_buffer *buffer = tr->buffer;
         struct ring_buffer_event *event;
         struct trace_mmiotrace_map *entry;
         int pc = preempt_count();
 
-        event = trace_buffer_lock_reserve(tr, TRACE_MMIO_MAP,
+        event = trace_buffer_lock_reserve(buffer, TRACE_MMIO_MAP,
                                           sizeof(*entry), 0, pc);
         if (!event) {
                 atomic_inc(&dropped_count);
@@ -345,7 +347,7 @@ static void __trace_mmiotrace_map(struct trace_array *tr,
         }
         entry   = ring_buffer_event_data(event);
         entry->map                      = *map;
-        trace_buffer_unlock_commit(tr, event, 0, pc);
+        trace_buffer_unlock_commit(buffer, event, 0, pc);
 }
 
 void mmio_trace_mapping(struct mmiotrace_map *map)
diff --git a/kernel/trace/trace_power.c b/kernel/trace/trace_power.c
index 8a30d9874cd4..fe1a00f1445a 100644
--- a/kernel/trace/trace_power.c
+++ b/kernel/trace/trace_power.c
@@ -38,6 +38,7 @@ static void probe_power_end(struct power_trace *it)
 {
         struct ftrace_event_call *call = &event_power;
         struct ring_buffer_event *event;
+        struct ring_buffer *buffer;
         struct trace_power *entry;
         struct trace_array_cpu *data;
         struct trace_array *tr = power_trace;
@@ -45,18 +46,20 @@ static void probe_power_end(struct power_trace *it)
         if (!trace_power_enabled)
                 return;
 
+        buffer = tr->buffer;
+
         preempt_disable();
         it->end = ktime_get();
         data = tr->data[smp_processor_id()];
 
-        event = trace_buffer_lock_reserve(tr, TRACE_POWER,
+        event = trace_buffer_lock_reserve(buffer, TRACE_POWER,
                                           sizeof(*entry), 0, 0);
         if (!event)
                 goto out;
         entry   = ring_buffer_event_data(event);
         entry->state_data = *it;
-        if (!filter_check_discard(call, entry, tr->buffer, event))
-                trace_buffer_unlock_commit(tr, event, 0, 0);
+        if (!filter_check_discard(call, entry, buffer, event))
+                trace_buffer_unlock_commit(buffer, event, 0, 0);
  out:
         preempt_enable();
 }
@@ -66,6 +69,7 @@ static void probe_power_mark(struct power_trace *it, unsigned int type,
 {
         struct ftrace_event_call *call = &event_power;
         struct ring_buffer_event *event;
+        struct ring_buffer *buffer;
         struct trace_power *entry;
         struct trace_array_cpu *data;
         struct trace_array *tr = power_trace;
@@ -73,6 +77,8 @@ static void probe_power_mark(struct power_trace *it, unsigned int type,
         if (!trace_power_enabled)
                 return;
 
+        buffer = tr->buffer;
+
         memset(it, 0, sizeof(struct power_trace));
         it->state = level;
         it->type = type;
@@ -81,14 +87,14 @@ static void probe_power_mark(struct power_trace *it, unsigned int type,
         it->end = it->stamp;
         data = tr->data[smp_processor_id()];
 
-        event = trace_buffer_lock_reserve(tr, TRACE_POWER,
+        event = trace_buffer_lock_reserve(buffer, TRACE_POWER,
                                           sizeof(*entry), 0, 0);
         if (!event)
                 goto out;
         entry   = ring_buffer_event_data(event);
         entry->state_data = *it;
-        if (!filter_check_discard(call, entry, tr->buffer, event))
-                trace_buffer_unlock_commit(tr, event, 0, 0);
+        if (!filter_check_discard(call, entry, buffer, event))
+                trace_buffer_unlock_commit(buffer, event, 0, 0);
  out:
         preempt_enable();
 }
@@ -144,14 +150,12 @@ static void power_trace_reset(struct trace_array *tr)
 
 static int power_trace_init(struct trace_array *tr)
 {
-        int cpu;
         power_trace = tr;
 
         trace_power_enabled = 1;
         tracing_power_register();
 
-        for_each_cpu(cpu, cpu_possible_mask)
-                tracing_reset(tr, cpu);
+        tracing_reset_online_cpus(tr);
         return 0;
 }
 
diff --git a/kernel/trace/trace_sched_switch.c b/kernel/trace/trace_sched_switch.c
index a98106dd979c..5fca0f51fde4 100644
--- a/kernel/trace/trace_sched_switch.c
+++ b/kernel/trace/trace_sched_switch.c
@@ -20,6 +20,35 @@ static int			sched_ref;
 static DEFINE_MUTEX(sched_register_mutex);
 static int                      sched_stopped;
 
+
+void
+tracing_sched_switch_trace(struct trace_array *tr,
+                           struct task_struct *prev,
+                           struct task_struct *next,
+                           unsigned long flags, int pc)
+{
+        struct ftrace_event_call *call = &event_context_switch;
+        struct ring_buffer *buffer = tr->buffer;
+        struct ring_buffer_event *event;
+        struct ctx_switch_entry *entry;
+
+        event = trace_buffer_lock_reserve(buffer, TRACE_CTX,
+                                          sizeof(*entry), flags, pc);
+        if (!event)
+                return;
+        entry   = ring_buffer_event_data(event);
+        entry->prev_pid                 = prev->pid;
+        entry->prev_prio                = prev->prio;
+        entry->prev_state               = prev->state;
+        entry->next_pid                 = next->pid;
+        entry->next_prio                = next->prio;
+        entry->next_state               = next->state;
+        entry->next_cpu = task_cpu(next);
+
+        if (!filter_check_discard(call, entry, buffer, event))
+                trace_buffer_unlock_commit(buffer, event, flags, pc);
+}
+
 static void
 probe_sched_switch(struct rq *__rq, struct task_struct *prev,
                         struct task_struct *next)
@@ -49,6 +78,36 @@ probe_sched_switch(struct rq *__rq, struct task_struct *prev,
         local_irq_restore(flags);
 }
 
+void
+tracing_sched_wakeup_trace(struct trace_array *tr,
+                           struct task_struct *wakee,
+                           struct task_struct *curr,
+                           unsigned long flags, int pc)
+{
+        struct ftrace_event_call *call = &event_wakeup;
+        struct ring_buffer_event *event;
+        struct ctx_switch_entry *entry;
+        struct ring_buffer *buffer = tr->buffer;
+
+        event = trace_buffer_lock_reserve(buffer, TRACE_WAKE,
+                                          sizeof(*entry), flags, pc);
+        if (!event)
+                return;
+        entry   = ring_buffer_event_data(event);
+        entry->prev_pid                 = curr->pid;
+        entry->prev_prio                = curr->prio;
+        entry->prev_state               = curr->state;
+        entry->next_pid                 = wakee->pid;
+        entry->next_prio                = wakee->prio;
+        entry->next_state               = wakee->state;
+        entry->next_cpu                 = task_cpu(wakee);
+
+        if (!filter_check_discard(call, entry, buffer, event))
+                ring_buffer_unlock_commit(buffer, event);
+        ftrace_trace_stack(tr->buffer, flags, 6, pc);
+        ftrace_trace_userstack(tr->buffer, flags, pc);
+}
+
 static void
 probe_sched_wakeup(struct rq *__rq, struct task_struct *wakee, int success)
 {
diff --git a/kernel/trace/trace_sched_wakeup.c b/kernel/trace/trace_sched_wakeup.c
index eacb27225173..ad69f105a7c6 100644
--- a/kernel/trace/trace_sched_wakeup.c
+++ b/kernel/trace/trace_sched_wakeup.c
@@ -186,11 +186,6 @@ out:
 
 static void __wakeup_reset(struct trace_array *tr)
 {
-        int cpu;
-
-        for_each_possible_cpu(cpu)
-                tracing_reset(tr, cpu);
-
         wakeup_cpu = -1;
         wakeup_prio = -1;
 
@@ -204,6 +199,8 @@ static void wakeup_reset(struct trace_array *tr)
 {
         unsigned long flags;
 
+        tracing_reset_online_cpus(tr);
+
         local_irq_save(flags);
         __raw_spin_lock(&wakeup_lock);
         __wakeup_reset(tr);
diff --git a/kernel/trace/trace_selftest.c b/kernel/trace/trace_selftest.c
index 00dd6485bdd7..d2cdbabb4ead 100644
--- a/kernel/trace/trace_selftest.c
+++ b/kernel/trace/trace_selftest.c
@@ -288,6 +288,7 @@ trace_selftest_startup_function_graph(struct tracer *trace,
          * to detect and recover from possible hangs
          */
         tracing_reset_online_cpus(tr);
+        set_graph_array(tr);
         ret = register_ftrace_graph(&trace_graph_return,
                                     &trace_graph_entry_watchdog);
         if (ret) {
diff --git a/kernel/trace/trace_stack.c b/kernel/trace/trace_stack.c
index 6a2a9d484cd6..0f6facb050a1 100644
--- a/kernel/trace/trace_stack.c
+++ b/kernel/trace/trace_stack.c
@@ -186,43 +186,33 @@ static const struct file_operations stack_max_size_fops = {
 };
 
 static void *
-t_next(struct seq_file *m, void *v, loff_t *pos)
+__next(struct seq_file *m, loff_t *pos)
 {
-        long i;
+        long n = *pos - 1;
 
-        (*pos)++;
-
-        if (v == SEQ_START_TOKEN)
-                i = 0;
-        else {
-                i = *(long *)v;
-                i++;
-        }
-
-        if (i >= max_stack_trace.nr_entries ||
-            stack_dump_trace[i] == ULONG_MAX)
+        if (n >= max_stack_trace.nr_entries || stack_dump_trace[n] == ULONG_MAX)
                 return NULL;
 
-        m->private = (void *)i;
-
+        m->private = (void *)n;
         return &m->private;
 }
 
-static void *t_start(struct seq_file *m, loff_t *pos)
+static void *
+t_next(struct seq_file *m, void *v, loff_t *pos)
 {
-        void *t = SEQ_START_TOKEN;
-        loff_t l = 0;
+        (*pos)++;
+        return __next(m, pos);
+}
 
+static void *t_start(struct seq_file *m, loff_t *pos)
+{
         local_irq_disable();
         __raw_spin_lock(&max_stack_lock);
 
         if (*pos == 0)
                 return SEQ_START_TOKEN;
 
-        for (; t && l < *pos; t = t_next(m, t, &l))
-                ;
-
-        return t;
+        return __next(m, pos);
 }
 
 static void t_stop(struct seq_file *m, void *p)
@@ -234,15 +224,8 @@ static void t_stop(struct seq_file *m, void *p)
 static int trace_lookup_stack(struct seq_file *m, long i)
 {
         unsigned long addr = stack_dump_trace[i];
-#ifdef CONFIG_KALLSYMS
-        char str[KSYM_SYMBOL_LEN];
-
-        sprint_symbol(str, addr);
 
-        return seq_printf(m, "%s\n", str);
-#else
-        return seq_printf(m, "%p\n", (void*)addr);
-#endif
+        return seq_printf(m, "%pF\n", (void *)addr);
 }
 
 static void print_disabled(struct seq_file *m)
diff --git a/kernel/trace/trace_stat.c b/kernel/trace/trace_stat.c
index aea321c82fa0..a4bb239eb987 100644
--- a/kernel/trace/trace_stat.c
+++ b/kernel/trace/trace_stat.c
@@ -49,7 +49,8 @@ static struct dentry		*stat_dir;
  * but it will at least advance closer to the next one
  * to be released.
  */
-static struct rb_node *release_next(struct rb_node *node)
+static struct rb_node *release_next(struct tracer_stat *ts,
+                                    struct rb_node *node)
 {
         struct stat_node *snode;
         struct rb_node *parent = rb_parent(node);
@@ -67,6 +68,8 @@ static struct rb_node *release_next(struct rb_node *node)
                         parent->rb_right = NULL;
 
                 snode = container_of(node, struct stat_node, node);
+                if (ts->stat_release)
+                        ts->stat_release(snode->stat);
                 kfree(snode);
 
                 return parent;
@@ -78,7 +81,7 @@ static void __reset_stat_session(struct stat_session *session)
         struct rb_node *node = session->stat_root.rb_node;
 
         while (node)
-                node = release_next(node);
+                node = release_next(session->ts, node);
 
         session->stat_root = RB_ROOT;
 }
@@ -200,17 +203,21 @@ static void *stat_seq_start(struct seq_file *s, loff_t *pos)
 {
         struct stat_session *session = s->private;
         struct rb_node *node;
+        int n = *pos;
         int i;
 
         /* Prevent from tracer switch or rbtree modification */
         mutex_lock(&session->stat_mutex);
 
         /* If we are in the beginning of the file, print the headers */
-        if (!*pos && session->ts->stat_headers)
-                return SEQ_START_TOKEN;
+        if (session->ts->stat_headers) {
+                if (n == 0)
+                        return SEQ_START_TOKEN;
+                n--;
+        }
 
         node = rb_first(&session->stat_root);
-        for (i = 0; node && i < *pos; i++)
+        for (i = 0; node && i < n; i++)
                 node = rb_next(node);
 
         return node;
diff --git a/kernel/trace/trace_stat.h b/kernel/trace/trace_stat.h
index f3546a2cd826..8f03914b9a6a 100644
--- a/kernel/trace/trace_stat.h
+++ b/kernel/trace/trace_stat.h
@@ -18,6 +18,8 @@ struct tracer_stat {
         int                     (*stat_cmp)(void *p1, void *p2);
         /* Print a stat entry */
         int                     (*stat_show)(struct seq_file *s, void *p);
+        /* Release an entry */
+        void                    (*stat_release)(void *stat);
         /* Print the headers of your stat entries */
         int                     (*stat_headers)(struct seq_file *s);
 };
diff --git a/kernel/trace/trace_syscalls.c b/kernel/trace/trace_syscalls.c
index 5e579645ac86..8712ce3c6a0e 100644
--- a/kernel/trace/trace_syscalls.c
+++ b/kernel/trace/trace_syscalls.c
@@ -1,30 +1,18 @@
 #include <trace/syscall.h>
+#include <trace/events/syscalls.h>
 #include <linux/kernel.h>
+#include <linux/ftrace.h>
+#include <linux/perf_counter.h>
 #include <asm/syscall.h>
 
 #include "trace_output.h"
 #include "trace.h"
 
-/* Keep a counter of the syscall tracing users */
-static int refcount;
-
-/* Prevent from races on thread flags toggling */
 static DEFINE_MUTEX(syscall_trace_lock);
-
-/* Option to display the parameters types */
-enum {
-        TRACE_SYSCALLS_OPT_TYPES = 0x1,
-};
-
-static struct tracer_opt syscalls_opts[] = {
-        { TRACER_OPT(syscall_arg_type, TRACE_SYSCALLS_OPT_TYPES) },
-        { }
-};
-
-static struct tracer_flags syscalls_flags = {
-        .val = 0, /* By default: no parameters types */
-        .opts = syscalls_opts
-};
+static int sys_refcount_enter;
+static int sys_refcount_exit;
+static DECLARE_BITMAP(enabled_enter_syscalls, NR_syscalls);
+static DECLARE_BITMAP(enabled_exit_syscalls, NR_syscalls);
 
 enum print_line_t
 print_syscall_enter(struct trace_iterator *iter, int flags)
@@ -35,35 +23,46 @@ print_syscall_enter(struct trace_iterator *iter, int flags)
         struct syscall_metadata *entry;
         int i, ret, syscall;
 
-        trace_assign_type(trace, ent);
-
+        trace = (typeof(trace))ent;
         syscall = trace->nr;
-
         entry = syscall_nr_to_meta(syscall);
+
         if (!entry)
                 goto end;
 
+        if (entry->enter_id != ent->type) {
+                WARN_ON_ONCE(1);
+                goto end;
+        }
+
         ret = trace_seq_printf(s, "%s(", entry->name);
         if (!ret)
                 return TRACE_TYPE_PARTIAL_LINE;
 
         for (i = 0; i < entry->nb_args; i++) {
                 /* parameter types */
-                if (syscalls_flags.val & TRACE_SYSCALLS_OPT_TYPES) {
+                if (trace_flags & TRACE_ITER_VERBOSE) {
                         ret = trace_seq_printf(s, "%s ", entry->types[i]);
                         if (!ret)
                                 return TRACE_TYPE_PARTIAL_LINE;
                 }
                 /* parameter values */
-                ret = trace_seq_printf(s, "%s: %lx%s ", entry->args[i],
+                ret = trace_seq_printf(s, "%s: %lx%s", entry->args[i],
                                        trace->args[i],
-                                       i == entry->nb_args - 1 ? ")" : ",");
+                                       i == entry->nb_args - 1 ? "" : ", ");
                 if (!ret)
                         return TRACE_TYPE_PARTIAL_LINE;
         }
 
+        ret = trace_seq_putc(s, ')');
+        if (!ret)
+                return TRACE_TYPE_PARTIAL_LINE;
+
 end:
-        trace_seq_printf(s, "\n");
+        ret =  trace_seq_putc(s, '\n');
+        if (!ret)
+                return TRACE_TYPE_PARTIAL_LINE;
+
         return TRACE_TYPE_HANDLED;
 }
 
@@ -77,16 +76,20 @@ print_syscall_exit(struct trace_iterator *iter, int flags)
         struct syscall_metadata *entry;
         int ret;
 
-        trace_assign_type(trace, ent);
-
+        trace = (typeof(trace))ent;
         syscall = trace->nr;
-
         entry = syscall_nr_to_meta(syscall);
+
         if (!entry) {
                 trace_seq_printf(s, "\n");
                 return TRACE_TYPE_HANDLED;
         }
 
+        if (entry->exit_id != ent->type) {
+                WARN_ON_ONCE(1);
+                return TRACE_TYPE_UNHANDLED;
+        }
+
         ret = trace_seq_printf(s, "%s -> 0x%lx\n", entry->name,
                                 trace->ret);
         if (!ret)
@@ -95,62 +98,140 @@ print_syscall_exit(struct trace_iterator *iter, int flags)
         return TRACE_TYPE_HANDLED;
 }
 
-void start_ftrace_syscalls(void)
+extern char *__bad_type_size(void);
+
+#define SYSCALL_FIELD(type, name)                                       \
+        sizeof(type) != sizeof(trace.name) ?                            \
+                __bad_type_size() :                                     \
+                #type, #name, offsetof(typeof(trace), name), sizeof(trace.name)
+
+int syscall_enter_format(struct ftrace_event_call *call, struct trace_seq *s)
 {
-        unsigned long flags;
-        struct task_struct *g, *t;
+        int i;
+        int nr;
+        int ret;
+        struct syscall_metadata *entry;
+        struct syscall_trace_enter trace;
+        int offset = offsetof(struct syscall_trace_enter, args);
 
-        mutex_lock(&syscall_trace_lock);
+        nr = syscall_name_to_nr(call->data);
+        entry = syscall_nr_to_meta(nr);
 
-        /* Don't enable the flag on the tasks twice */
-        if (++refcount != 1)
-                goto unlock;
+        if (!entry)
+                return 0;
 
-        arch_init_ftrace_syscalls();
-        read_lock_irqsave(&tasklist_lock, flags);
+        ret = trace_seq_printf(s, "\tfield:%s %s;\toffset:%zu;\tsize:%zu;\n",
+                               SYSCALL_FIELD(int, nr));
+        if (!ret)
+                return 0;
 
-        do_each_thread(g, t) {
-                set_tsk_thread_flag(t, TIF_SYSCALL_FTRACE);
-        } while_each_thread(g, t);
+        for (i = 0; i < entry->nb_args; i++) {
+                ret = trace_seq_printf(s, "\tfield:%s %s;", entry->types[i],
+                                        entry->args[i]);
+                if (!ret)
+                        return 0;
+                ret = trace_seq_printf(s, "\toffset:%d;\tsize:%zu;\n", offset,
+                                       sizeof(unsigned long));
+                if (!ret)
+                        return 0;
+                offset += sizeof(unsigned long);
+        }
 
-        read_unlock_irqrestore(&tasklist_lock, flags);
+        trace_seq_puts(s, "\nprint fmt: \"");
+        for (i = 0; i < entry->nb_args; i++) {
+                ret = trace_seq_printf(s, "%s: 0x%%0%zulx%s", entry->args[i],
+                                        sizeof(unsigned long),
+                                        i == entry->nb_args - 1 ? "" : ", ");
+                if (!ret)
+                        return 0;
+        }
+        trace_seq_putc(s, '"');
 
-unlock:
-        mutex_unlock(&syscall_trace_lock);
+        for (i = 0; i < entry->nb_args; i++) {
+                ret = trace_seq_printf(s, ", ((unsigned long)(REC->%s))",
+                                       entry->args[i]);
+                if (!ret)
+                        return 0;
+        }
+
+        return trace_seq_putc(s, '\n');
 }
 
-void stop_ftrace_syscalls(void)
+int syscall_exit_format(struct ftrace_event_call *call, struct trace_seq *s)
 {
-        unsigned long flags;
-        struct task_struct *g, *t;
+        int ret;
+        struct syscall_trace_exit trace;
 
-        mutex_lock(&syscall_trace_lock);
+        ret = trace_seq_printf(s,
+                               "\tfield:%s %s;\toffset:%zu;\tsize:%zu;\n"
+                               "\tfield:%s %s;\toffset:%zu;\tsize:%zu;\n",
+                               SYSCALL_FIELD(int, nr),
+                               SYSCALL_FIELD(unsigned long, ret));
+        if (!ret)
+                return 0;
 
-        /* There are perhaps still some users */
-        if (--refcount)
-                goto unlock;
+        return trace_seq_printf(s, "\nprint fmt: \"0x%%lx\", REC->ret\n");
+}
 
-        read_lock_irqsave(&tasklist_lock, flags);
+int syscall_enter_define_fields(struct ftrace_event_call *call)
+{
+        struct syscall_trace_enter trace;
+        struct syscall_metadata *meta;
+        int ret;
+        int nr;
+        int i;
+        int offset = offsetof(typeof(trace), args);
+
+        nr = syscall_name_to_nr(call->data);
+        meta = syscall_nr_to_meta(nr);
+
+        if (!meta)
+                return 0;
+
+        ret = trace_define_common_fields(call);
+        if (ret)
+                return ret;
+
+        for (i = 0; i < meta->nb_args; i++) {
+                ret = trace_define_field(call, meta->types[i],
+                                         meta->args[i], offset,
+                                         sizeof(unsigned long), 0,
+                                         FILTER_OTHER);
+                offset += sizeof(unsigned long);
+        }
 
-        do_each_thread(g, t) {
-                clear_tsk_thread_flag(t, TIF_SYSCALL_FTRACE);
-        } while_each_thread(g, t);
+        return ret;
+}
 
-        read_unlock_irqrestore(&tasklist_lock, flags);
+int syscall_exit_define_fields(struct ftrace_event_call *call)
+{
+        struct syscall_trace_exit trace;
+        int ret;
 
-unlock:
-        mutex_unlock(&syscall_trace_lock);
+        ret = trace_define_common_fields(call);
+        if (ret)
+                return ret;
+
+        ret = trace_define_field(call, SYSCALL_FIELD(unsigned long, ret), 0,
+                                 FILTER_OTHER);
+
+        return ret;
 }
 
-void ftrace_syscall_enter(struct pt_regs *regs)
+void ftrace_syscall_enter(struct pt_regs *regs, long id)
 {
         struct syscall_trace_enter *entry;
         struct syscall_metadata *sys_data;
         struct ring_buffer_event *event;
+        struct ring_buffer *buffer;
         int size;
         int syscall_nr;
 
         syscall_nr = syscall_get_nr(current, regs);
+        if (syscall_nr < 0)
+                return;
+        if (!test_bit(syscall_nr, enabled_enter_syscalls))
+                return;
 
         sys_data = syscall_nr_to_meta(syscall_nr);
         if (!sys_data)
@@ -158,8 +239,8 @@ void ftrace_syscall_enter(struct pt_regs *regs)
 
         size = sizeof(*entry) + sizeof(unsigned long) * sys_data->nb_args;
 
-        event = trace_current_buffer_lock_reserve(TRACE_SYSCALL_ENTER, size,
-                                                        0, 0);
+        event = trace_current_buffer_lock_reserve(&buffer, sys_data->enter_id,
+                                                  size, 0, 0);
         if (!event)
                 return;
 
@@ -167,24 +248,30 @@ void ftrace_syscall_enter(struct pt_regs *regs)
         entry->nr = syscall_nr;
         syscall_get_arguments(current, regs, 0, sys_data->nb_args, entry->args);
 
-        trace_current_buffer_unlock_commit(event, 0, 0);
-        trace_wake_up();
+        if (!filter_current_check_discard(buffer, sys_data->enter_event,
+                                          entry, event))
+                trace_current_buffer_unlock_commit(buffer, event, 0, 0);
 }
 
-void ftrace_syscall_exit(struct pt_regs *regs)
+void ftrace_syscall_exit(struct pt_regs *regs, long ret)
 {
         struct syscall_trace_exit *entry;
         struct syscall_metadata *sys_data;
         struct ring_buffer_event *event;
+        struct ring_buffer *buffer;
         int syscall_nr;
 
         syscall_nr = syscall_get_nr(current, regs);
+        if (syscall_nr < 0)
+                return;
+        if (!test_bit(syscall_nr, enabled_exit_syscalls))
+                return;
 
         sys_data = syscall_nr_to_meta(syscall_nr);
         if (!sys_data)
                 return;
 
-        event = trace_current_buffer_lock_reserve(TRACE_SYSCALL_EXIT,
+        event = trace_current_buffer_lock_reserve(&buffer, sys_data->exit_id,
                                 sizeof(*entry), 0, 0);
         if (!event)
                 return;
@@ -193,58 +280,244 @@ void ftrace_syscall_exit(struct pt_regs *regs)
         entry->nr = syscall_nr;
         entry->ret = syscall_get_return_value(current, regs);
 
-        trace_current_buffer_unlock_commit(event, 0, 0);
-        trace_wake_up();
+        if (!filter_current_check_discard(buffer, sys_data->exit_event,
+                                          entry, event))
+                trace_current_buffer_unlock_commit(buffer, event, 0, 0);
 }
 
-static int init_syscall_tracer(struct trace_array *tr)
+int reg_event_syscall_enter(void *ptr)
 {
-        start_ftrace_syscalls();
+        int ret = 0;
+        int num;
+        char *name;
+
+        name = (char *)ptr;
+        num = syscall_name_to_nr(name);
+        if (num < 0 || num >= NR_syscalls)
+                return -ENOSYS;
+        mutex_lock(&syscall_trace_lock);
+        if (!sys_refcount_enter)
+                ret = register_trace_sys_enter(ftrace_syscall_enter);
+        if (ret) {
+                pr_info("event trace: Could not activate"
+                                "syscall entry trace point");
+        } else {
+                set_bit(num, enabled_enter_syscalls);
+                sys_refcount_enter++;
+        }
+        mutex_unlock(&syscall_trace_lock);
+        return ret;
+}
+
+void unreg_event_syscall_enter(void *ptr)
+{
+        int num;
+        char *name;
 
-        return 0;
+        name = (char *)ptr;
+        num = syscall_name_to_nr(name);
+        if (num < 0 || num >= NR_syscalls)
+                return;
+        mutex_lock(&syscall_trace_lock);
+        sys_refcount_enter--;
+        clear_bit(num, enabled_enter_syscalls);
+        if (!sys_refcount_enter)
+                unregister_trace_sys_enter(ftrace_syscall_enter);
+        mutex_unlock(&syscall_trace_lock);
 }
 
-static void reset_syscall_tracer(struct trace_array *tr)
+int reg_event_syscall_exit(void *ptr)
 {
-        stop_ftrace_syscalls();
-        tracing_reset_online_cpus(tr);
+        int ret = 0;
+        int num;
+        char *name;
+
+        name = (char *)ptr;
+        num = syscall_name_to_nr(name);
+        if (num < 0 || num >= NR_syscalls)
+                return -ENOSYS;
+        mutex_lock(&syscall_trace_lock);
+        if (!sys_refcount_exit)
+                ret = register_trace_sys_exit(ftrace_syscall_exit);
+        if (ret) {
+                pr_info("event trace: Could not activate"
+                                "syscall exit trace point");
+        } else {
+                set_bit(num, enabled_exit_syscalls);
+                sys_refcount_exit++;
+        }
+        mutex_unlock(&syscall_trace_lock);
+        return ret;
 }
 
-static struct trace_event syscall_enter_event = {
-        .type           = TRACE_SYSCALL_ENTER,
-        .trace          = print_syscall_enter,
-};
+void unreg_event_syscall_exit(void *ptr)
+{
+        int num;
+        char *name;
+
+        name = (char *)ptr;
+        num = syscall_name_to_nr(name);
+        if (num < 0 || num >= NR_syscalls)
+                return;
+        mutex_lock(&syscall_trace_lock);
+        sys_refcount_exit--;
+        clear_bit(num, enabled_exit_syscalls);
+        if (!sys_refcount_exit)
+                unregister_trace_sys_exit(ftrace_syscall_exit);
+        mutex_unlock(&syscall_trace_lock);
+}
 
-static struct trace_event syscall_exit_event = {
-        .type           = TRACE_SYSCALL_EXIT,
-        .trace          = print_syscall_exit,
+struct trace_event event_syscall_enter = {
+        .trace                  = print_syscall_enter,
 };
 
-static struct tracer syscall_tracer __read_mostly = {
-        .name           = "syscall",
-        .init           = init_syscall_tracer,
-        .reset          = reset_syscall_tracer,
-        .flags          = &syscalls_flags,
+struct trace_event event_syscall_exit = {
+        .trace                  = print_syscall_exit,
 };
 
-__init int register_ftrace_syscalls(void)
+#ifdef CONFIG_EVENT_PROFILE
+
+static DECLARE_BITMAP(enabled_prof_enter_syscalls, NR_syscalls);
+static DECLARE_BITMAP(enabled_prof_exit_syscalls, NR_syscalls);
+static int sys_prof_refcount_enter;
+static int sys_prof_refcount_exit;
+
+static void prof_syscall_enter(struct pt_regs *regs, long id)
 {
-        int ret;
+        struct syscall_trace_enter *rec;
+        struct syscall_metadata *sys_data;
+        int syscall_nr;
+        int size;
 
-        ret = register_ftrace_event(&syscall_enter_event);
-        if (!ret) {
-                printk(KERN_WARNING "event %d failed to register\n",
-                       syscall_enter_event.type);
-                WARN_ON_ONCE(1);
+        syscall_nr = syscall_get_nr(current, regs);
+        if (!test_bit(syscall_nr, enabled_prof_enter_syscalls))
+                return;
+
+        sys_data = syscall_nr_to_meta(syscall_nr);
+        if (!sys_data)
+                return;
+
+        /* get the size after alignment with the u32 buffer size field */
+        size = sizeof(unsigned long) * sys_data->nb_args + sizeof(*rec);
+        size = ALIGN(size + sizeof(u32), sizeof(u64));
+        size -= sizeof(u32);
+
+        do {
+                char raw_data[size];
+
+                /* zero the dead bytes from align to not leak stack to user */
+                *(u64 *)(&raw_data[size - sizeof(u64)]) = 0ULL;
+
+                rec = (struct syscall_trace_enter *) raw_data;
+                tracing_generic_entry_update(&rec->ent, 0, 0);
+                rec->ent.type = sys_data->enter_id;
+                rec->nr = syscall_nr;
+                syscall_get_arguments(current, regs, 0, sys_data->nb_args,
+                                       (unsigned long *)&rec->args);
+                perf_tpcounter_event(sys_data->enter_id, 0, 1, rec, size);
+        } while(0);
+}
+
+int reg_prof_syscall_enter(char *name)
+{
+        int ret = 0;
+        int num;
+
+        num = syscall_name_to_nr(name);
+        if (num < 0 || num >= NR_syscalls)
+                return -ENOSYS;
+
+        mutex_lock(&syscall_trace_lock);
+        if (!sys_prof_refcount_enter)
+                ret = register_trace_sys_enter(prof_syscall_enter);
+        if (ret) {
+                pr_info("event trace: Could not activate"
+                                "syscall entry trace point");
+        } else {
+                set_bit(num, enabled_prof_enter_syscalls);
+                sys_prof_refcount_enter++;
         }
+        mutex_unlock(&syscall_trace_lock);
+        return ret;
+}
 
-        ret = register_ftrace_event(&syscall_exit_event);
-        if (!ret) {
-                printk(KERN_WARNING "event %d failed to register\n",
-                       syscall_exit_event.type);
-                WARN_ON_ONCE(1);
+void unreg_prof_syscall_enter(char *name)
+{
+        int num;
+
+        num = syscall_name_to_nr(name);
+        if (num < 0 || num >= NR_syscalls)
+                return;
+
+        mutex_lock(&syscall_trace_lock);
+        sys_prof_refcount_enter--;
+        clear_bit(num, enabled_prof_enter_syscalls);
+        if (!sys_prof_refcount_enter)
+                unregister_trace_sys_enter(prof_syscall_enter);
+        mutex_unlock(&syscall_trace_lock);
+}
+
+static void prof_syscall_exit(struct pt_regs *regs, long ret)
+{
+        struct syscall_metadata *sys_data;
+        struct syscall_trace_exit rec;
+        int syscall_nr;
+
+        syscall_nr = syscall_get_nr(current, regs);
+        if (!test_bit(syscall_nr, enabled_prof_exit_syscalls))
+                return;
+
+        sys_data = syscall_nr_to_meta(syscall_nr);
+        if (!sys_data)
+                return;
+
+        tracing_generic_entry_update(&rec.ent, 0, 0);
+        rec.ent.type = sys_data->exit_id;
+        rec.nr = syscall_nr;
+        rec.ret = syscall_get_return_value(current, regs);
+
+        perf_tpcounter_event(sys_data->exit_id, 0, 1, &rec, sizeof(rec));
+}
+
+int reg_prof_syscall_exit(char *name)
+{
+        int ret = 0;
+        int num;
+
+        num = syscall_name_to_nr(name);
+        if (num < 0 || num >= NR_syscalls)
+                return -ENOSYS;
+
+        mutex_lock(&syscall_trace_lock);
+        if (!sys_prof_refcount_exit)
+                ret = register_trace_sys_exit(prof_syscall_exit);
+        if (ret) {
+                pr_info("event trace: Could not activate"
+                                "syscall entry trace point");
+        } else {
+                set_bit(num, enabled_prof_exit_syscalls);
+                sys_prof_refcount_exit++;
         }
+        mutex_unlock(&syscall_trace_lock);
+        return ret;
+}
 
-        return register_tracer(&syscall_tracer);
+void unreg_prof_syscall_exit(char *name)
+{
+        int num;
+
+        num = syscall_name_to_nr(name);
+        if (num < 0 || num >= NR_syscalls)
+                return;
+
+        mutex_lock(&syscall_trace_lock);
+        sys_prof_refcount_exit--;
+        clear_bit(num, enabled_prof_exit_syscalls);
+        if (!sys_prof_refcount_exit)
+                unregister_trace_sys_exit(prof_syscall_exit);
+        mutex_unlock(&syscall_trace_lock);
 }
-device_initcall(register_ftrace_syscalls);
+
+#endif
+
+
diff --git a/kernel/trace/trace_workqueue.c b/kernel/trace/trace_workqueue.c
index 97fcea4acce1..40cafb07dffd 100644
--- a/kernel/trace/trace_workqueue.c
+++ b/kernel/trace/trace_workqueue.c
@@ -9,6 +9,7 @@
 #include <trace/events/workqueue.h>
 #include <linux/list.h>
 #include <linux/percpu.h>
+#include <linux/kref.h>
 #include "trace_stat.h"
 #include "trace.h"
 
@@ -16,6 +17,7 @@
 /* A cpu workqueue thread */
 struct cpu_workqueue_stats {
         struct list_head            list;
+        struct kref                 kref;
         int                         cpu;
         pid_t                       pid;
 /* Can be inserted from interrupt or user context, need to be atomic */
@@ -39,6 +41,11 @@ struct workqueue_global_stats {
 static DEFINE_PER_CPU(struct workqueue_global_stats, all_workqueue_stat);
 #define workqueue_cpu_stat(cpu) (&per_cpu(all_workqueue_stat, cpu))
 
+static void cpu_workqueue_stat_free(struct kref *kref)
+{
+        kfree(container_of(kref, struct cpu_workqueue_stats, kref));
+}
+
 /* Insertion of a work */
 static void
 probe_workqueue_insertion(struct task_struct *wq_thread,
@@ -96,8 +103,8 @@ static void probe_workqueue_creation(struct task_struct *wq_thread, int cpu)
                 return;
         }
         INIT_LIST_HEAD(&cws->list);
+        kref_init(&cws->kref);
         cws->cpu = cpu;
-
         cws->pid = wq_thread->pid;
 
         spin_lock_irqsave(&workqueue_cpu_stat(cpu)->lock, flags);
@@ -118,7 +125,7 @@ static void probe_workqueue_destruction(struct task_struct *wq_thread)
                                                         list) {
                 if (node->pid == wq_thread->pid) {
                         list_del(&node->list);
-                        kfree(node);
+                        kref_put(&node->kref, cpu_workqueue_stat_free);
                         goto found;
                 }
         }
@@ -137,9 +144,11 @@ static struct cpu_workqueue_stats *workqueue_stat_start_cpu(int cpu)
 
         spin_lock_irqsave(&workqueue_cpu_stat(cpu)->lock, flags);
 
-        if (!list_empty(&workqueue_cpu_stat(cpu)->list))
+        if (!list_empty(&workqueue_cpu_stat(cpu)->list)) {
                 ret = list_entry(workqueue_cpu_stat(cpu)->list.next,
                                  struct cpu_workqueue_stats, list);
+                kref_get(&ret->kref);
+        }
 
         spin_unlock_irqrestore(&workqueue_cpu_stat(cpu)->lock, flags);
 
@@ -162,9 +171,9 @@ static void *workqueue_stat_start(struct tracer_stat *trace)
 static void *workqueue_stat_next(void *prev, int idx)
 {
         struct cpu_workqueue_stats *prev_cws = prev;
+        struct cpu_workqueue_stats *ret;
         int cpu = prev_cws->cpu;
         unsigned long flags;
-        void *ret = NULL;
 
         spin_lock_irqsave(&workqueue_cpu_stat(cpu)->lock, flags);
         if (list_is_last(&prev_cws->list, &workqueue_cpu_stat(cpu)->list)) {
@@ -175,11 +184,14 @@ static void *workqueue_stat_next(void *prev, int idx)
                                 return NULL;
                 } while (!(ret = workqueue_stat_start_cpu(cpu)));
                 return ret;
+        } else {
+                ret = list_entry(prev_cws->list.next,
+                                 struct cpu_workqueue_stats, list);
+                kref_get(&ret->kref);
         }
         spin_unlock_irqrestore(&workqueue_cpu_stat(cpu)->lock, flags);
 
-        return list_entry(prev_cws->list.next, struct cpu_workqueue_stats,
-                          list);
+        return ret;
 }
 
 static int workqueue_stat_show(struct seq_file *s, void *p)
@@ -203,6 +215,13 @@ static int workqueue_stat_show(struct seq_file *s, void *p)
         return 0;
 }
 
+static void workqueue_stat_release(void *stat)
+{
+        struct cpu_workqueue_stats *node = stat;
+
+        kref_put(&node->kref, cpu_workqueue_stat_free);
+}
+
 static int workqueue_stat_headers(struct seq_file *s)
 {
         seq_printf(s, "# CPU  INSERTED  EXECUTED   NAME\n");
@@ -215,6 +234,7 @@ struct tracer_stat workqueue_stats __read_mostly = {
         .stat_start = workqueue_stat_start,
         .stat_next = workqueue_stat_next,
         .stat_show = workqueue_stat_show,
+        .stat_release = workqueue_stat_release,
         .stat_headers = workqueue_stat_headers
 };
 
diff --git a/kernel/tracepoint.c b/kernel/tracepoint.c
index 1ef5d3a601c7..9489a0a9b1be 100644
--- a/kernel/tracepoint.c
+++ b/kernel/tracepoint.c
@@ -24,6 +24,7 @@
 #include <linux/tracepoint.h>
 #include <linux/err.h>
 #include <linux/slab.h>
+#include <linux/sched.h>
 
 extern struct tracepoint __start___tracepoints[];
 extern struct tracepoint __stop___tracepoints[];
@@ -242,6 +243,11 @@ static void set_tracepoint(struct tracepoint_entry **entry,
 {
         WARN_ON(strcmp((*entry)->name, elem->name) != 0);
 
+        if (elem->regfunc && !elem->state && active)
+                elem->regfunc();
+        else if (elem->unregfunc && elem->state && !active)
+                elem->unregfunc();
+
         /*
          * rcu_assign_pointer has a smp_wmb() which makes sure that the new
          * probe callbacks array is consistent before setting a pointer to it.
@@ -261,6 +267,9 @@ static void set_tracepoint(struct tracepoint_entry **entry,
  */
 static void disable_tracepoint(struct tracepoint *elem)
 {
+        if (elem->unregfunc && elem->state)
+                elem->unregfunc();
+
         elem->state = 0;
         rcu_assign_pointer(elem->funcs, NULL);
 }
@@ -554,9 +563,6 @@ int tracepoint_module_notify(struct notifier_block *self,
 
         switch (val) {
         case MODULE_STATE_COMING:
-                tracepoint_update_probe_range(mod->tracepoints,
-                        mod->tracepoints + mod->num_tracepoints);
-                break;
         case MODULE_STATE_GOING:
                 tracepoint_update_probe_range(mod->tracepoints,
                         mod->tracepoints + mod->num_tracepoints);
@@ -577,3 +583,41 @@ static int init_tracepoints(void)
 __initcall(init_tracepoints);
 
 #endif /* CONFIG_MODULES */
+
+#ifdef CONFIG_HAVE_SYSCALL_TRACEPOINTS
+
+/* NB: reg/unreg are called while guarded with the tracepoints_mutex */
+static int sys_tracepoint_refcount;
+
+void syscall_regfunc(void)
+{
+        unsigned long flags;
+        struct task_struct *g, *t;
+
+        if (!sys_tracepoint_refcount) {
+                read_lock_irqsave(&tasklist_lock, flags);
+                do_each_thread(g, t) {
+                        /* Skip kernel threads. */
+                        if (t->mm)
+                                set_tsk_thread_flag(t, TIF_SYSCALL_TRACEPOINT);
+                } while_each_thread(g, t);
+                read_unlock_irqrestore(&tasklist_lock, flags);
+        }
+        sys_tracepoint_refcount++;
+}
+
+void syscall_unregfunc(void)
+{
+        unsigned long flags;
+        struct task_struct *g, *t;
+
+        sys_tracepoint_refcount--;
+        if (!sys_tracepoint_refcount) {
+                read_lock_irqsave(&tasklist_lock, flags);
+                do_each_thread(g, t) {
+                        clear_tsk_thread_flag(t, TIF_SYSCALL_TRACEPOINT);
+                } while_each_thread(g, t);
+                read_unlock_irqrestore(&tasklist_lock, flags);
+        }
+}
+#endif
diff --git a/kernel/workqueue.c b/kernel/workqueue.c
index 0668795d8818..addfe2df93b1 100644
--- a/kernel/workqueue.c
+++ b/kernel/workqueue.c
@@ -317,8 +317,6 @@ static int worker_thread(void *__cwq)
         if (cwq->wq->freezeable)
                 set_freezable();
 
-        set_user_nice(current, -5);
-
         for (;;) {
                 prepare_to_wait(&cwq->more_work, &wait, TASK_INTERRUPTIBLE);
                 if (!freezing(current) &&
@@ -600,7 +598,12 @@ static struct workqueue_struct *keventd_wq __read_mostly;
  * schedule_work - put work task in global workqueue
  * @work: job to be done
  *
- * This puts a job in the kernel-global workqueue.
+ * Returns zero if @work was already on the kernel-global workqueue and
+ * non-zero otherwise.
+ *
+ * This puts a job in the kernel-global workqueue if it was not already
+ * queued and leaves it in the same position on the kernel-global
+ * workqueue otherwise.
  */
 int schedule_work(struct work_struct *work)
 {
diff --git a/lib/Kconfig.debug b/lib/Kconfig.debug
index fbb87cf138c5..7dbd5d9c29a4 100644
--- a/lib/Kconfig.debug
+++ b/lib/Kconfig.debug
@@ -740,7 +740,7 @@ config RCU_TORTURE_TEST_RUNNABLE
 
 config RCU_CPU_STALL_DETECTOR
         bool "Check for stalled CPUs delaying RCU grace periods"
-        depends on CLASSIC_RCU || TREE_RCU
+        depends on TREE_RCU || TREE_PREEMPT_RCU
         default n
         help
           This option causes RCU to printk information on which
diff --git a/lib/swiotlb.c b/lib/swiotlb.c
index bffe6d7ef9d9..ac25cd28e807 100644
--- a/lib/swiotlb.c
+++ b/lib/swiotlb.c
@@ -114,46 +114,11 @@ setup_io_tlb_npages(char *str)
 __setup("swiotlb=", setup_io_tlb_npages);
 /* make io_tlb_overflow tunable too? */
 
-void * __weak __init swiotlb_alloc_boot(size_t size, unsigned long nslabs)
-{
-        return alloc_bootmem_low_pages(size);
-}
-
-void * __weak swiotlb_alloc(unsigned order, unsigned long nslabs)
-{
-        return (void *)__get_free_pages(GFP_DMA | __GFP_NOWARN, order);
-}
-
-dma_addr_t __weak swiotlb_phys_to_bus(struct device *hwdev, phys_addr_t paddr)
-{
-        return paddr;
-}
-
-phys_addr_t __weak swiotlb_bus_to_phys(struct device *hwdev, dma_addr_t baddr)
-{
-        return baddr;
-}
-
+/* Note that this doesn't work with highmem page */
 static dma_addr_t swiotlb_virt_to_bus(struct device *hwdev,
                                       volatile void *address)
 {
-        return swiotlb_phys_to_bus(hwdev, virt_to_phys(address));
-}
-
-void * __weak swiotlb_bus_to_virt(struct device *hwdev, dma_addr_t address)
-{
-        return phys_to_virt(swiotlb_bus_to_phys(hwdev, address));
-}
-
-int __weak swiotlb_arch_address_needs_mapping(struct device *hwdev,
-                                               dma_addr_t addr, size_t size)
-{
-        return !is_buffer_dma_capable(dma_get_mask(hwdev), addr, size);
-}
-
-int __weak swiotlb_arch_range_needs_mapping(phys_addr_t paddr, size_t size)
-{
-        return 0;
+        return phys_to_dma(hwdev, virt_to_phys(address));
 }
 
 static void swiotlb_print_info(unsigned long bytes)
@@ -189,7 +154,7 @@ swiotlb_init_with_default_size(size_t default_size)
         /*
          * Get IO TLB memory from the low pages
          */
-        io_tlb_start = swiotlb_alloc_boot(bytes, io_tlb_nslabs);
+        io_tlb_start = alloc_bootmem_low_pages(bytes);
         if (!io_tlb_start)
                 panic("Cannot allocate SWIOTLB buffer");
         io_tlb_end = io_tlb_start + bytes;
@@ -245,7 +210,8 @@ swiotlb_late_init_with_default_size(size_t default_size)
         bytes = io_tlb_nslabs << IO_TLB_SHIFT;
 
         while ((SLABS_PER_PAGE << order) > IO_TLB_MIN_SLABS) {
-                io_tlb_start = swiotlb_alloc(order, io_tlb_nslabs);
+                io_tlb_start = (void *)__get_free_pages(GFP_DMA | __GFP_NOWARN,
+                                                        order);
                 if (io_tlb_start)
                         break;
                 order--;
@@ -315,20 +281,10 @@ cleanup1:
         return -ENOMEM;
 }
 
-static inline int
-address_needs_mapping(struct device *hwdev, dma_addr_t addr, size_t size)
+static int is_swiotlb_buffer(phys_addr_t paddr)
 {
-        return swiotlb_arch_address_needs_mapping(hwdev, addr, size);
-}
-
-static inline int range_needs_mapping(phys_addr_t paddr, size_t size)
-{
-        return swiotlb_force || swiotlb_arch_range_needs_mapping(paddr, size);
-}
-
-static int is_swiotlb_buffer(char *addr)
-{
-        return addr >= io_tlb_start && addr < io_tlb_end;
+        return paddr >= virt_to_phys(io_tlb_start) &&
+                paddr < virt_to_phys(io_tlb_end);
 }
 
 /*
@@ -561,9 +517,7 @@ swiotlb_alloc_coherent(struct device *hwdev, size_t size,
                 dma_mask = hwdev->coherent_dma_mask;
 
         ret = (void *)__get_free_pages(flags, order);
-        if (ret &&
-            !is_buffer_dma_capable(dma_mask, swiotlb_virt_to_bus(hwdev, ret),
-                                   size)) {
+        if (ret && swiotlb_virt_to_bus(hwdev, ret) + size > dma_mask) {
                 /*
                  * The allocated memory isn't reachable by the device.
                  */
@@ -585,7 +539,7 @@ swiotlb_alloc_coherent(struct device *hwdev, size_t size,
         dev_addr = swiotlb_virt_to_bus(hwdev, ret);
 
         /* Confirm address can be DMA'd by device */
-        if (!is_buffer_dma_capable(dma_mask, dev_addr, size)) {
+        if (dev_addr + size > dma_mask) {
                 printk("hwdev DMA mask = 0x%016Lx, dev_addr = 0x%016Lx\n",
                        (unsigned long long)dma_mask,
                        (unsigned long long)dev_addr);
@@ -601,11 +555,13 @@ EXPORT_SYMBOL(swiotlb_alloc_coherent);
 
 void
 swiotlb_free_coherent(struct device *hwdev, size_t size, void *vaddr,
-                      dma_addr_t dma_handle)
+                      dma_addr_t dev_addr)
 {
+        phys_addr_t paddr = dma_to_phys(hwdev, dev_addr);
+
         WARN_ON(irqs_disabled());
-        if (!is_swiotlb_buffer(vaddr))
-                free_pages((unsigned long) vaddr, get_order(size));
+        if (!is_swiotlb_buffer(paddr))
+                free_pages((unsigned long)vaddr, get_order(size));
         else
                 /* DMA_TO_DEVICE to avoid memcpy in unmap_single */
                 do_unmap_single(hwdev, vaddr, size, DMA_TO_DEVICE);
@@ -625,12 +581,15 @@ swiotlb_full(struct device *dev, size_t size, int dir, int do_panic)
         printk(KERN_ERR "DMA: Out of SW-IOMMU space for %zu bytes at "
                "device %s\n", size, dev ? dev_name(dev) : "?");
 
-        if (size > io_tlb_overflow && do_panic) {
-                if (dir == DMA_FROM_DEVICE || dir == DMA_BIDIRECTIONAL)
-                        panic("DMA: Memory would be corrupted\n");
-                if (dir == DMA_TO_DEVICE || dir == DMA_BIDIRECTIONAL)
-                        panic("DMA: Random memory would be DMAed\n");
-        }
+        if (size <= io_tlb_overflow || !do_panic)
+                return;
+
+        if (dir == DMA_BIDIRECTIONAL)
+                panic("DMA: Random memory could be DMA accessed\n");
+        if (dir == DMA_FROM_DEVICE)
+                panic("DMA: Random memory could be DMA written\n");
+        if (dir == DMA_TO_DEVICE)
+                panic("DMA: Random memory could be DMA read\n");
 }
 
 /*
@@ -646,7 +605,7 @@ dma_addr_t swiotlb_map_page(struct device *dev, struct page *page,
                             struct dma_attrs *attrs)
 {
         phys_addr_t phys = page_to_phys(page) + offset;
-        dma_addr_t dev_addr = swiotlb_phys_to_bus(dev, phys);
+        dma_addr_t dev_addr = phys_to_dma(dev, phys);
         void *map;
 
         BUG_ON(dir == DMA_NONE);
@@ -655,8 +614,7 @@ dma_addr_t swiotlb_map_page(struct device *dev, struct page *page,
          * we can safely return the device addr and not worry about bounce
          * buffering it.
          */
-        if (!address_needs_mapping(dev, dev_addr, size) &&
-            !range_needs_mapping(phys, size))
+        if (dma_capable(dev, dev_addr, size) && !swiotlb_force)
                 return dev_addr;
 
         /*
@@ -673,7 +631,7 @@ dma_addr_t swiotlb_map_page(struct device *dev, struct page *page,
         /*
          * Ensure that the address returned is DMA'ble
          */
-        if (address_needs_mapping(dev, dev_addr, size))
+        if (!dma_capable(dev, dev_addr, size))
                 panic("map_single: bounce buffer is not DMA'ble");
 
         return dev_addr;
@@ -691,19 +649,25 @@ EXPORT_SYMBOL_GPL(swiotlb_map_page);
 static void unmap_single(struct device *hwdev, dma_addr_t dev_addr,
                          size_t size, int dir)
 {
-        char *dma_addr = swiotlb_bus_to_virt(hwdev, dev_addr);
+        phys_addr_t paddr = dma_to_phys(hwdev, dev_addr);
 
         BUG_ON(dir == DMA_NONE);
 
-        if (is_swiotlb_buffer(dma_addr)) {
-                do_unmap_single(hwdev, dma_addr, size, dir);
+        if (is_swiotlb_buffer(paddr)) {
+                do_unmap_single(hwdev, phys_to_virt(paddr), size, dir);
                 return;
         }
 
         if (dir != DMA_FROM_DEVICE)
                 return;
 
-        dma_mark_clean(dma_addr, size);
+        /*
+         * phys_to_virt doesn't work with hihgmem page but we could
+         * call dma_mark_clean() with hihgmem page here. However, we
+         * are fine since dma_mark_clean() is null on POWERPC. We can
+         * make dma_mark_clean() take a physical address if necessary.
+         */
+        dma_mark_clean(phys_to_virt(paddr), size);
 }
 
 void swiotlb_unmap_page(struct device *hwdev, dma_addr_t dev_addr,
@@ -728,19 +692,19 @@ static void
 swiotlb_sync_single(struct device *hwdev, dma_addr_t dev_addr,
                     size_t size, int dir, int target)
 {
-        char *dma_addr = swiotlb_bus_to_virt(hwdev, dev_addr);
+        phys_addr_t paddr = dma_to_phys(hwdev, dev_addr);
 
         BUG_ON(dir == DMA_NONE);
 
-        if (is_swiotlb_buffer(dma_addr)) {
-                sync_single(hwdev, dma_addr, size, dir, target);
+        if (is_swiotlb_buffer(paddr)) {
+                sync_single(hwdev, phys_to_virt(paddr), size, dir, target);
                 return;
         }
 
         if (dir != DMA_FROM_DEVICE)
                 return;
 
-        dma_mark_clean(dma_addr, size);
+        dma_mark_clean(phys_to_virt(paddr), size);
 }
 
 void
@@ -817,10 +781,10 @@ swiotlb_map_sg_attrs(struct device *hwdev, struct scatterlist *sgl, int nelems,
 
         for_each_sg(sgl, sg, nelems, i) {
                 phys_addr_t paddr = sg_phys(sg);
-                dma_addr_t dev_addr = swiotlb_phys_to_bus(hwdev, paddr);
+                dma_addr_t dev_addr = phys_to_dma(hwdev, paddr);
 
-                if (range_needs_mapping(paddr, sg->length) ||
-                    address_needs_mapping(hwdev, dev_addr, sg->length)) {
+                if (swiotlb_force ||
+                    !dma_capable(hwdev, dev_addr, sg->length)) {
                         void *map = map_single(hwdev, sg_phys(sg),
                                                sg->length, dir);
                         if (!map) {
diff --git a/scripts/recordmcount.pl b/scripts/recordmcount.pl
index 911ba7ffab84..090d300d7394 100755
--- a/scripts/recordmcount.pl
+++ b/scripts/recordmcount.pl
@@ -57,7 +57,6 @@
 #        call mcount  (offset: 0x5)
 #        [...]
 #        ret
-#  .globl my_func
 #  other_func:
 #        [...]
 #        call mcount (offset: 0x1b)
diff --git a/tools/perf/Documentation/perf-record.txt b/tools/perf/Documentation/perf-record.txt
index 6be696b0a2bb..0ff23de9e453 100644
--- a/tools/perf/Documentation/perf-record.txt
+++ b/tools/perf/Documentation/perf-record.txt
@@ -91,6 +91,10 @@ OPTIONS
 --no-samples::
         Don't sample.
 
+-R::
+--raw-samples::
+Collect raw sample records from all opened counters (typically for tracepoint counters).
+
 SEE ALSO
 --------
 linkperf:perf-stat[1], linkperf:perf-list[1]
diff --git a/tools/perf/Documentation/perf-report.txt b/tools/perf/Documentation/perf-report.txt
index e72e93110782..59f0b846cd71 100644
--- a/tools/perf/Documentation/perf-report.txt
+++ b/tools/perf/Documentation/perf-report.txt
@@ -27,6 +27,9 @@ OPTIONS
 -n
 --show-nr-samples
         Show the number of samples for each symbol
+-T
+--threads
+        Show per-thread event counters
 -C::
 --comms=::
         Only consider symbols in these comms. CSV that understands
@@ -48,6 +51,16 @@ OPTIONS
         all occurances of this separator in symbol names (and other output)
         with a '.' character, that thus it's the only non valid separator.
 
+-g [type,min]::
+--call-graph::
+        Display callchains using type and min percent threshold.
+        type can be either:
+        - flat: single column, linear exposure of callchains.
+        - graph: use a graph tree, displaying absolute overhead rates.
+        - fractal: like graph, but displays relative rates. Each branch of
+                 the tree is considered as a new profiled object. +
+        Default: fractal,0.5.
+
 SEE ALSO
 --------
 linkperf:perf-stat[1]
diff --git a/tools/perf/Makefile b/tools/perf/Makefile
index c045b4271e57..9f8d207a91bf 100644
--- a/tools/perf/Makefile
+++ b/tools/perf/Makefile
@@ -166,7 +166,35 @@ endif
 
 # CFLAGS and LDFLAGS are for the users to override from the command line.
 
-CFLAGS = $(M64) -ggdb3 -Wall -Wextra -Wstrict-prototypes -Wmissing-declarations -Wmissing-prototypes -std=gnu99 -Wdeclaration-after-statement -Werror -O6
+#
+# Include saner warnings here, which can catch bugs:
+#
+
+EXTRA_WARNINGS := -Wcast-align
+EXTRA_WARNINGS := $(EXTRA_WARNINGS) -Wformat
+EXTRA_WARNINGS := $(EXTRA_WARNINGS) -Wformat-security
+EXTRA_WARNINGS := $(EXTRA_WARNINGS) -Wformat-y2k
+EXTRA_WARNINGS := $(EXTRA_WARNINGS) -Wshadow
+EXTRA_WARNINGS := $(EXTRA_WARNINGS) -Winit-self
+EXTRA_WARNINGS := $(EXTRA_WARNINGS) -Wpacked
+EXTRA_WARNINGS := $(EXTRA_WARNINGS) -Wredundant-decls
+EXTRA_WARNINGS := $(EXTRA_WARNINGS) -Wstack-protector
+EXTRA_WARNINGS := $(EXTRA_WARNINGS) -Wstrict-aliasing=3
+EXTRA_WARNINGS := $(EXTRA_WARNINGS) -Wswitch-default
+EXTRA_WARNINGS := $(EXTRA_WARNINGS) -Wswitch-enum
+EXTRA_WARNINGS := $(EXTRA_WARNINGS) -Wno-system-headers
+EXTRA_WARNINGS := $(EXTRA_WARNINGS) -Wundef
+EXTRA_WARNINGS := $(EXTRA_WARNINGS) -Wvolatile-register-var
+EXTRA_WARNINGS := $(EXTRA_WARNINGS) -Wwrite-strings
+EXTRA_WARNINGS := $(EXTRA_WARNINGS) -Wbad-function-cast
+EXTRA_WARNINGS := $(EXTRA_WARNINGS) -Wmissing-declarations
+EXTRA_WARNINGS := $(EXTRA_WARNINGS) -Wmissing-prototypes
+EXTRA_WARNINGS := $(EXTRA_WARNINGS) -Wnested-externs
+EXTRA_WARNINGS := $(EXTRA_WARNINGS) -Wold-style-definition
+EXTRA_WARNINGS := $(EXTRA_WARNINGS) -Wstrict-prototypes
+EXTRA_WARNINGS := $(EXTRA_WARNINGS) -Wdeclaration-after-statement
+
+CFLAGS = $(M64) -ggdb3 -Wall -Wextra -std=gnu99 -Werror -O6 -fstack-protector-all -D_FORTIFY_SOURCE=2 $(EXTRA_WARNINGS)
 LDFLAGS = -lpthread -lrt -lelf -lm
 ALL_CFLAGS = $(CFLAGS)
 ALL_LDFLAGS = $(LDFLAGS)
@@ -310,6 +338,7 @@ LIB_H += util/sigchain.h
 LIB_H += util/symbol.h
 LIB_H += util/module.h
 LIB_H += util/color.h
+LIB_H += util/values.h
 
 LIB_OBJS += util/abspath.o
 LIB_OBJS += util/alias.o
@@ -337,6 +366,13 @@ LIB_OBJS += util/color.o
 LIB_OBJS += util/pager.o
 LIB_OBJS += util/header.o
 LIB_OBJS += util/callchain.o
+LIB_OBJS += util/values.o
+LIB_OBJS += util/debug.o
+LIB_OBJS += util/map.o
+LIB_OBJS += util/thread.o
+LIB_OBJS += util/trace-event-parse.o
+LIB_OBJS += util/trace-event-read.o
+LIB_OBJS += util/trace-event-info.o
 
 BUILTIN_OBJS += builtin-annotate.o
 BUILTIN_OBJS += builtin-help.o
@@ -345,6 +381,7 @@ BUILTIN_OBJS += builtin-record.o
 BUILTIN_OBJS += builtin-report.o
 BUILTIN_OBJS += builtin-stat.o
 BUILTIN_OBJS += builtin-top.o
+BUILTIN_OBJS += builtin-trace.o
 
 PERFLIBS = $(LIB_FILE)
 
diff --git a/tools/perf/builtin-annotate.c b/tools/perf/builtin-annotate.c
index 5e17de984dc8..043d85b7e254 100644
--- a/tools/perf/builtin-annotate.c
+++ b/tools/perf/builtin-annotate.c
@@ -17,16 +17,13 @@
 #include "util/string.h"
 
 #include "perf.h"
+#include "util/debug.h"
 
 #include "util/parse-options.h"
 #include "util/parse-events.h"
-
-#define SHOW_KERNEL     1
-#define SHOW_USER       2
-#define SHOW_HV         4
+#include "util/thread.h"
 
 static char             const *input_name = "perf.data";
-static char             *vmlinux = "vmlinux";
 
 static char             default_sort_order[] = "comm,symbol";
 static char             *sort_order = default_sort_order;
@@ -35,13 +32,6 @@ static int		force;
 static int              input;
 static int              show_mask = SHOW_KERNEL | SHOW_USER | SHOW_HV;
 
-static int              dump_trace = 0;
-#define dprintf(x...)   do { if (dump_trace) printf(x); } while (0)
-
-static int              verbose;
-
-static int              modules;
-
 static int              full_paths;
 
 static int              print_line;
@@ -49,39 +39,8 @@ static int		print_line;
 static unsigned long    page_size;
 static unsigned long    mmap_window = 32;
 
-struct ip_event {
-        struct perf_event_header header;
-        u64 ip;
-        u32 pid, tid;
-};
-
-struct mmap_event {
-        struct perf_event_header header;
-        u32 pid, tid;
-        u64 start;
-        u64 len;
-        u64 pgoff;
-        char filename[PATH_MAX];
-};
-
-struct comm_event {
-        struct perf_event_header header;
-        u32 pid, tid;
-        char comm[16];
-};
-
-struct fork_event {
-        struct perf_event_header header;
-        u32 pid, ppid;
-};
-
-typedef union event_union {
-        struct perf_event_header        header;
-        struct ip_event                 ip;
-        struct mmap_event               mmap;
-        struct comm_event               comm;
-        struct fork_event               fork;
-} event_t;
+static struct rb_root   threads;
+static struct thread    *last_match;
 
 
 struct sym_ext {
@@ -90,323 +49,6 @@ struct sym_ext {
         char            *path;
 };
 
-static LIST_HEAD(dsos);
-static struct dso *kernel_dso;
-static struct dso *vdso;
-
-
-static void dsos__add(struct dso *dso)
-{
-        list_add_tail(&dso->node, &dsos);
-}
-
-static struct dso *dsos__find(const char *name)
-{
-        struct dso *pos;
-
-        list_for_each_entry(pos, &dsos, node)
-                if (strcmp(pos->name, name) == 0)
-                        return pos;
-        return NULL;
-}
-
-static struct dso *dsos__findnew(const char *name)
-{
-        struct dso *dso = dsos__find(name);
-        int nr;
-
-        if (dso)
-                return dso;
-
-        dso = dso__new(name, 0);
-        if (!dso)
-                goto out_delete_dso;
-
-        nr = dso__load(dso, NULL, verbose);
-        if (nr < 0) {
-                if (verbose)
-                        fprintf(stderr, "Failed to open: %s\n", name);
-                goto out_delete_dso;
-        }
-        if (!nr && verbose) {
-                fprintf(stderr,
-                "No symbols found in: %s, maybe install a debug package?\n",
-                                name);
-        }
-
-        dsos__add(dso);
-
-        return dso;
-
-out_delete_dso:
-        dso__delete(dso);
-        return NULL;
-}
-
-static void dsos__fprintf(FILE *fp)
-{
-        struct dso *pos;
-
-        list_for_each_entry(pos, &dsos, node)
-                dso__fprintf(pos, fp);
-}
-
-static struct symbol *vdso__find_symbol(struct dso *dso, u64 ip)
-{
-        return dso__find_symbol(dso, ip);
-}
-
-static int load_kernel(void)
-{
-        int err;
-
-        kernel_dso = dso__new("[kernel]", 0);
-        if (!kernel_dso)
-                return -1;
-
-        err = dso__load_kernel(kernel_dso, vmlinux, NULL, verbose, modules);
-        if (err <= 0) {
-                dso__delete(kernel_dso);
-                kernel_dso = NULL;
-        } else
-                dsos__add(kernel_dso);
-
-        vdso = dso__new("[vdso]", 0);
-        if (!vdso)
-                return -1;
-
-        vdso->find_symbol = vdso__find_symbol;
-
-        dsos__add(vdso);
-
-        return err;
-}
-
-struct map {
-        struct list_head node;
-        u64      start;
-        u64      end;
-        u64      pgoff;
-        u64      (*map_ip)(struct map *, u64);
-        struct dso       *dso;
-};
-
-static u64 map__map_ip(struct map *map, u64 ip)
-{
-        return ip - map->start + map->pgoff;
-}
-
-static u64 vdso__map_ip(struct map *map __used, u64 ip)
-{
-        return ip;
-}
-
-static struct map *map__new(struct mmap_event *event)
-{
-        struct map *self = malloc(sizeof(*self));
-
-        if (self != NULL) {
-                const char *filename = event->filename;
-
-                self->start = event->start;
-                self->end   = event->start + event->len;
-                self->pgoff = event->pgoff;
-
-                self->dso = dsos__findnew(filename);
-                if (self->dso == NULL)
-                        goto out_delete;
-
-                if (self->dso == vdso)
-                        self->map_ip = vdso__map_ip;
-                else
-                        self->map_ip = map__map_ip;
-        }
-        return self;
-out_delete:
-        free(self);
-        return NULL;
-}
-
-static struct map *map__clone(struct map *self)
-{
-        struct map *map = malloc(sizeof(*self));
-
-        if (!map)
-                return NULL;
-
-        memcpy(map, self, sizeof(*self));
-
-        return map;
-}
-
-static int map__overlap(struct map *l, struct map *r)
-{
-        if (l->start > r->start) {
-                struct map *t = l;
-                l = r;
-                r = t;
-        }
-
-        if (l->end > r->start)
-                return 1;
-
-        return 0;
-}
-
-static size_t map__fprintf(struct map *self, FILE *fp)
-{
-        return fprintf(fp, " %Lx-%Lx %Lx %s\n",
-                       self->start, self->end, self->pgoff, self->dso->name);
-}
-
-
-struct thread {
-        struct rb_node   rb_node;
-        struct list_head maps;
-        pid_t            pid;
-        char             *comm;
-};
-
-static struct thread *thread__new(pid_t pid)
-{
-        struct thread *self = malloc(sizeof(*self));
-
-        if (self != NULL) {
-                self->pid = pid;
-                self->comm = malloc(32);
-                if (self->comm)
-                        snprintf(self->comm, 32, ":%d", self->pid);
-                INIT_LIST_HEAD(&self->maps);
-        }
-
-        return self;
-}
-
-static int thread__set_comm(struct thread *self, const char *comm)
-{
-        if (self->comm)
-                free(self->comm);
-        self->comm = strdup(comm);
-        return self->comm ? 0 : -ENOMEM;
-}
-
-static size_t thread__fprintf(struct thread *self, FILE *fp)
-{
-        struct map *pos;
-        size_t ret = fprintf(fp, "Thread %d %s\n", self->pid, self->comm);
-
-        list_for_each_entry(pos, &self->maps, node)
-                ret += map__fprintf(pos, fp);
-
-        return ret;
-}
-
-
-static struct rb_root threads;
-static struct thread *last_match;
-
-static struct thread *threads__findnew(pid_t pid)
-{
-        struct rb_node **p = &threads.rb_node;
-        struct rb_node *parent = NULL;
-        struct thread *th;
-
-        /*
-         * Font-end cache - PID lookups come in blocks,
-         * so most of the time we dont have to look up
-         * the full rbtree:
-         */
-        if (last_match && last_match->pid == pid)
-                return last_match;
-
-        while (*p != NULL) {
-                parent = *p;
-                th = rb_entry(parent, struct thread, rb_node);
-
-                if (th->pid == pid) {
-                        last_match = th;
-                        return th;
-                }
-
-                if (pid < th->pid)
-                        p = &(*p)->rb_left;
-                else
-                        p = &(*p)->rb_right;
-        }
-
-        th = thread__new(pid);
-        if (th != NULL) {
-                rb_link_node(&th->rb_node, parent, p);
-                rb_insert_color(&th->rb_node, &threads);
-                last_match = th;
-        }
-
-        return th;
-}
-
-static void thread__insert_map(struct thread *self, struct map *map)
-{
-        struct map *pos, *tmp;
-
-        list_for_each_entry_safe(pos, tmp, &self->maps, node) {
-                if (map__overlap(pos, map)) {
-                        list_del_init(&pos->node);
-                        /* XXX leaks dsos */
-                        free(pos);
-                }
-        }
-
-        list_add_tail(&map->node, &self->maps);
-}
-
-static int thread__fork(struct thread *self, struct thread *parent)
-{
-        struct map *map;
-
-        if (self->comm)
-                free(self->comm);
-        self->comm = strdup(parent->comm);
-        if (!self->comm)
-                return -ENOMEM;
-
-        list_for_each_entry(map, &parent->maps, node) {
-                struct map *new = map__clone(map);
-                if (!new)
-                        return -ENOMEM;
-                thread__insert_map(self, new);
-        }
-
-        return 0;
-}
-
-static struct map *thread__find_map(struct thread *self, u64 ip)
-{
-        struct map *pos;
-
-        if (self == NULL)
-                return NULL;
-
-        list_for_each_entry(pos, &self->maps, node)
-                if (ip >= pos->start && ip <= pos->end)
-                        return pos;
-
-        return NULL;
-}
-
-static size_t threads__fprintf(FILE *fp)
-{
-        size_t ret = 0;
-        struct rb_node *nd;
-
-        for (nd = rb_first(&threads); nd; nd = rb_next(nd)) {
-                struct thread *pos = rb_entry(nd, struct thread, rb_node);
-
-                ret += thread__fprintf(pos, fp);
-        }
-
-        return ret;
-}
-
 /*
  * histogram, sorted on item, collects counts
  */
@@ -433,7 +75,7 @@ struct hist_entry {
 struct sort_entry {
         struct list_head list;
 
-        char *header;
+        const char *header;
 
         int64_t (*cmp)(struct hist_entry *, struct hist_entry *);
         int64_t (*collapse)(struct hist_entry *, struct hist_entry *);
@@ -577,7 +219,7 @@ static struct sort_entry sort_sym = {
 static int sort__need_collapse = 0;
 
 struct sort_dimension {
-        char                    *name;
+        const char              *name;
         struct sort_entry       *entry;
         int                     taken;
 };
@@ -830,17 +472,6 @@ static void output__resort(void)
         }
 }
 
-static void register_idle_thread(void)
-{
-        struct thread *thread = threads__findnew(0);
-
-        if (thread == NULL ||
-                        thread__set_comm(thread, "[idle]")) {
-                fprintf(stderr, "problem inserting idle task.\n");
-                exit(-1);
-        }
-}
-
 static unsigned long total = 0,
                      total_mmap = 0,
                      total_comm = 0,
@@ -853,18 +484,20 @@ process_sample_event(event_t *event, unsigned long offset, unsigned long head)
         char level;
         int show = 0;
         struct dso *dso = NULL;
-        struct thread *thread = threads__findnew(event->ip.pid);
+        struct thread *thread;
         u64 ip = event->ip.ip;
         struct map *map = NULL;
 
-        dprintf("%p [%p]: PERF_EVENT (IP, %d): %d: %p\n",
+        thread = threads__findnew(event->ip.pid, &threads, &last_match);
+
+        dump_printf("%p [%p]: PERF_EVENT (IP, %d): %d: %p\n",
                 (void *)(offset + head),
                 (void *)(long)(event->header.size),
                 event->header.misc,
                 event->ip.pid,
                 (void *)(long)ip);
 
-        dprintf(" ... thread: %s:%d\n", thread->comm, thread->pid);
+        dump_printf(" ... thread: %s:%d\n", thread->comm, thread->pid);
 
         if (thread == NULL) {
                 fprintf(stderr, "problem processing %d event, skipping it.\n",
@@ -878,7 +511,7 @@ process_sample_event(event_t *event, unsigned long offset, unsigned long head)
 
                 dso = kernel_dso;
 
-                dprintf(" ...... dso: %s\n", dso->name);
+                dump_printf(" ...... dso: %s\n", dso->name);
 
         } else if (event->header.misc & PERF_EVENT_MISC_USER) {
 
@@ -899,12 +532,12 @@ process_sample_event(event_t *event, unsigned long offset, unsigned long head)
                         if ((long long)ip < 0)
                                 dso = kernel_dso;
                 }
-                dprintf(" ...... dso: %s\n", dso ? dso->name : "<not found>");
+                dump_printf(" ...... dso: %s\n", dso ? dso->name : "<not found>");
 
         } else {
                 show = SHOW_HV;
                 level = 'H';
-                dprintf(" ...... dso: [hypervisor]\n");
+                dump_printf(" ...... dso: [hypervisor]\n");
         }
 
         if (show & show_mask) {
@@ -927,10 +560,12 @@ process_sample_event(event_t *event, unsigned long offset, unsigned long head)
 static int
 process_mmap_event(event_t *event, unsigned long offset, unsigned long head)
 {
-        struct thread *thread = threads__findnew(event->mmap.pid);
-        struct map *map = map__new(&event->mmap);
+        struct thread *thread;
+        struct map *map = map__new(&event->mmap, NULL, 0);
+
+        thread = threads__findnew(event->mmap.pid, &threads, &last_match);
 
-        dprintf("%p [%p]: PERF_EVENT_MMAP %d: [%p(%p) @ %p]: %s\n",
+        dump_printf("%p [%p]: PERF_EVENT_MMAP %d: [%p(%p) @ %p]: %s\n",
                 (void *)(offset + head),
                 (void *)(long)(event->header.size),
                 event->mmap.pid,
@@ -940,7 +575,7 @@ process_mmap_event(event_t *event, unsigned long offset, unsigned long head)
                 event->mmap.filename);
 
         if (thread == NULL || map == NULL) {
-                dprintf("problem processing PERF_EVENT_MMAP, skipping event.\n");
+                dump_printf("problem processing PERF_EVENT_MMAP, skipping event.\n");
                 return 0;
         }
 
@@ -953,16 +588,17 @@ process_mmap_event(event_t *event, unsigned long offset, unsigned long head)
 static int
 process_comm_event(event_t *event, unsigned long offset, unsigned long head)
 {
-        struct thread *thread = threads__findnew(event->comm.pid);
+        struct thread *thread;
 
-        dprintf("%p [%p]: PERF_EVENT_COMM: %s:%d\n",
+        thread = threads__findnew(event->comm.pid, &threads, &last_match);
+        dump_printf("%p [%p]: PERF_EVENT_COMM: %s:%d\n",
                 (void *)(offset + head),
                 (void *)(long)(event->header.size),
                 event->comm.comm, event->comm.pid);
 
         if (thread == NULL ||
             thread__set_comm(thread, event->comm.comm)) {
-                dprintf("problem processing PERF_EVENT_COMM, skipping event.\n");
+                dump_printf("problem processing PERF_EVENT_COMM, skipping event.\n");
                 return -1;
         }
         total_comm++;
@@ -973,10 +609,12 @@ process_comm_event(event_t *event, unsigned long offset, unsigned long head)
 static int
 process_fork_event(event_t *event, unsigned long offset, unsigned long head)
 {
-        struct thread *thread = threads__findnew(event->fork.pid);
-        struct thread *parent = threads__findnew(event->fork.ppid);
+        struct thread *thread;
+        struct thread *parent;
 
-        dprintf("%p [%p]: PERF_EVENT_FORK: %d:%d\n",
+        thread = threads__findnew(event->fork.pid, &threads, &last_match);
+        parent = threads__findnew(event->fork.ppid, &threads, &last_match);
+        dump_printf("%p [%p]: PERF_EVENT_FORK: %d:%d\n",
                 (void *)(offset + head),
                 (void *)(long)(event->header.size),
                 event->fork.pid, event->fork.ppid);
@@ -989,7 +627,7 @@ process_fork_event(event_t *event, unsigned long offset, unsigned long head)
                 return 0;
 
         if (!thread || !parent || thread__fork(thread, parent)) {
-                dprintf("problem processing PERF_EVENT_FORK, skipping event.\n");
+                dump_printf("problem processing PERF_EVENT_FORK, skipping event.\n");
                 return -1;
         }
         total_fork++;
@@ -1075,7 +713,7 @@ parse_line(FILE *file, struct symbol *sym, u64 start, u64 len)
                 const char *path = NULL;
                 unsigned int hits = 0;
                 double percent = 0.0;
-                char *color;
+                const char *color;
                 struct sym_ext *sym_ext = sym->priv;
 
                 offset = line_ip - start;
@@ -1157,7 +795,7 @@ static void free_source_line(struct symbol *sym, int len)
 
 /* Get the filename:line for the colored entries */
 static void
-get_source_line(struct symbol *sym, u64 start, int len, char *filename)
+get_source_line(struct symbol *sym, u64 start, int len, const char *filename)
 {
         int i;
         char cmd[PATH_MAX * 2];
@@ -1203,7 +841,7 @@ get_source_line(struct symbol *sym, u64 start, int len, char *filename)
         }
 }
 
-static void print_summary(char *filename)
+static void print_summary(const char *filename)
 {
         struct sym_ext *sym_ext;
         struct rb_node *node;
@@ -1219,7 +857,7 @@ static void print_summary(char *filename)
         node = rb_first(&root_sym_ext);
         while (node) {
                 double percent;
-                char *color;
+                const char *color;
                 char *path;
 
                 sym_ext = rb_entry(node, struct sym_ext, node);
@@ -1234,7 +872,7 @@ static void print_summary(char *filename)
 
 static void annotate_sym(struct dso *dso, struct symbol *sym)
 {
-        char *filename = dso->name, *d_filename;
+        const char *filename = dso->name, *d_filename;
         u64 start, end, len;
         char command[PATH_MAX*2];
         FILE *file;
@@ -1244,7 +882,7 @@ static void annotate_sym(struct dso *dso, struct symbol *sym)
         if (sym->module)
                 filename = sym->module->path;
         else if (dso == kernel_dso)
-                filename = vmlinux;
+                filename = vmlinux_name;
 
         start = sym->obj_start;
         if (!start)
@@ -1316,12 +954,12 @@ static int __cmd_annotate(void)
         int ret, rc = EXIT_FAILURE;
         unsigned long offset = 0;
         unsigned long head = 0;
-        struct stat stat;
+        struct stat input_stat;
         event_t *event;
         uint32_t size;
         char *buf;
 
-        register_idle_thread();
+        register_idle_thread(&threads, &last_match);
 
         input = open(input_name, O_RDONLY);
         if (input < 0) {
@@ -1329,18 +967,18 @@ static int __cmd_annotate(void)
                 exit(-1);
         }
 
-        ret = fstat(input, &stat);
+        ret = fstat(input, &input_stat);
         if (ret < 0) {
                 perror("failed to stat file");
                 exit(-1);
         }
 
-        if (!force && (stat.st_uid != geteuid())) {
-                fprintf(stderr, "file: %s not owned by current user\n", input_name);
+        if (!force && input_stat.st_uid && (input_stat.st_uid != geteuid())) {
+                fprintf(stderr, "file: %s not owned by current user or root\n", input_name);
                 exit(-1);
         }
 
-        if (!stat.st_size) {
+        if (!input_stat.st_size) {
                 fprintf(stderr, "zero-sized file, nothing to do!\n");
                 exit(0);
         }
@@ -1367,10 +1005,10 @@ more:
 
         if (head + event->header.size >= page_size * mmap_window) {
                 unsigned long shift = page_size * (head / page_size);
-                int ret;
+                int munmap_ret;
 
-                ret = munmap(buf, page_size * mmap_window);
-                assert(ret == 0);
+                munmap_ret = munmap(buf, page_size * mmap_window);
+                assert(munmap_ret == 0);
 
                 offset += shift;
                 head -= shift;
@@ -1379,14 +1017,14 @@ more:
 
         size = event->header.size;
 
-        dprintf("%p [%p]: event: %d\n",
+        dump_printf("%p [%p]: event: %d\n",
                         (void *)(offset + head),
                         (void *)(long)event->header.size,
                         event->header.type);
 
         if (!size || process_event(event, offset, head) < 0) {
 
-                dprintf("%p [%p]: skipping unknown header type: %d\n",
+                dump_printf("%p [%p]: skipping unknown header type: %d\n",
                         (void *)(offset + head),
                         (void *)(long)(event->header.size),
                         event->header.type);
@@ -1406,23 +1044,23 @@ more:
 
         head += size;
 
-        if (offset + head < (unsigned long)stat.st_size)
+        if (offset + head < (unsigned long)input_stat.st_size)
                 goto more;
 
         rc = EXIT_SUCCESS;
         close(input);
 
-        dprintf("      IP events: %10ld\n", total);
-        dprintf("    mmap events: %10ld\n", total_mmap);
-        dprintf("    comm events: %10ld\n", total_comm);
-        dprintf("    fork events: %10ld\n", total_fork);
-        dprintf(" unknown events: %10ld\n", total_unknown);
+        dump_printf("      IP events: %10ld\n", total);
+        dump_printf("    mmap events: %10ld\n", total_mmap);
+        dump_printf("    comm events: %10ld\n", total_comm);
+        dump_printf("    fork events: %10ld\n", total_fork);
+        dump_printf(" unknown events: %10ld\n", total_unknown);
 
         if (dump_trace)
                 return 0;
 
         if (verbose >= 3)
-                threads__fprintf(stdout);
+                threads__fprintf(stdout, &threads);
 
         if (verbose >= 2)
                 dsos__fprintf(stdout);
@@ -1450,7 +1088,7 @@ static const struct option options[] = {
                     "be more verbose (show symbol address, etc)"),
         OPT_BOOLEAN('D', "dump-raw-trace", &dump_trace,
                     "dump raw trace in ASCII"),
-        OPT_STRING('k', "vmlinux", &vmlinux, "file", "vmlinux pathname"),
+        OPT_STRING('k', "vmlinux", &vmlinux_name, "file", "vmlinux pathname"),
         OPT_BOOLEAN('m', "modules", &modules,
                     "load module symbols - WARNING: use only with -k and LIVE kernel"),
         OPT_BOOLEAN('l', "print-line", &print_line,
diff --git a/tools/perf/builtin-help.c b/tools/perf/builtin-help.c
index 2599d86a733b..4fb8734a796e 100644
--- a/tools/perf/builtin-help.c
+++ b/tools/perf/builtin-help.c
@@ -456,6 +456,7 @@ int cmd_help(int argc, const char **argv, const char *prefix __used)
                 break;
         case HELP_FORMAT_WEB:
                 show_html_page(argv[0]);
+        default:
                 break;
         }
 
diff --git a/tools/perf/builtin-record.c b/tools/perf/builtin-record.c
index 89a5ddcd1ded..99a12fe86e9f 100644
--- a/tools/perf/builtin-record.c
+++ b/tools/perf/builtin-record.c
@@ -15,6 +15,9 @@
 #include "util/string.h"
 
 #include "util/header.h"
+#include "util/event.h"
+#include "util/debug.h"
+#include "util/trace-event.h"
 
 #include <unistd.h>
 #include <sched.h>
@@ -42,7 +45,6 @@ static int			inherit				= 1;
 static int                      force                           = 0;
 static int                      append_file                     = 0;
 static int                      call_graph                      = 0;
-static int                      verbose                         = 0;
 static int                      inherit_stat                    = 0;
 static int                      no_samples                      = 0;
 static int                      sample_address                  = 0;
@@ -62,24 +64,6 @@ static int			file_new = 1;
 
 struct perf_header              *header;
 
-struct mmap_event {
-        struct perf_event_header        header;
-        u32                             pid;
-        u32                             tid;
-        u64                             start;
-        u64                             len;
-        u64                             pgoff;
-        char                            filename[PATH_MAX];
-};
-
-struct comm_event {
-        struct perf_event_header        header;
-        u32                             pid;
-        u32                             tid;
-        char                            comm[16];
-};
-
-
 struct mmap_data {
         int                     counter;
         void                    *base;
@@ -419,8 +403,11 @@ static void create_counter(int counter, int cpu, pid_t pid)
         if (call_graph)
                 attr->sample_type       |= PERF_SAMPLE_CALLCHAIN;
 
-        if (raw_samples)
+        if (raw_samples) {
+                attr->sample_type       |= PERF_SAMPLE_TIME;
                 attr->sample_type       |= PERF_SAMPLE_RAW;
+                attr->sample_type       |= PERF_SAMPLE_CPU;
+        }
 
         attr->mmap              = track;
         attr->comm              = track;
@@ -563,6 +550,17 @@ static int __cmd_record(int argc, const char **argv)
         else
                 header = perf_header__new();
 
+
+        if (raw_samples) {
+                read_tracing_data(attrs, nr_counters);
+        } else {
+                for (i = 0; i < nr_counters; i++) {
+                        if (attrs[i].sample_type & PERF_SAMPLE_RAW) {
+                                read_tracing_data(attrs, nr_counters);
+                                break;
+                        }
+                }
+        }
         atexit(atexit_header);
 
         if (!system_wide) {
diff --git a/tools/perf/builtin-report.c b/tools/perf/builtin-report.c
index 8b2ec882e6e0..cdf9a8d27bb9 100644
--- a/tools/perf/builtin-report.c
+++ b/tools/perf/builtin-report.c
@@ -17,19 +17,18 @@
 #include "util/string.h"
 #include "util/callchain.h"
 #include "util/strlist.h"
+#include "util/values.h"
 
 #include "perf.h"
+#include "util/debug.h"
 #include "util/header.h"
 
 #include "util/parse-options.h"
 #include "util/parse-events.h"
 
-#define SHOW_KERNEL     1
-#define SHOW_USER       2
-#define SHOW_HV         4
+#include "util/thread.h"
 
 static char             const *input_name = "perf.data";
-static char             *vmlinux = NULL;
 
 static char             default_sort_order[] = "comm,dso,symbol";
 static char             *sort_order = default_sort_order;
@@ -42,18 +41,15 @@ static int		force;
 static int              input;
 static int              show_mask = SHOW_KERNEL | SHOW_USER | SHOW_HV;
 
-static int              dump_trace = 0;
-#define dprintf(x...)   do { if (dump_trace) printf(x); } while (0)
-#define cdprintf(x...)  do { if (dump_trace) color_fprintf(stdout, color, x); } while (0)
-
-static int              verbose;
-#define eprintf(x...)   do { if (verbose) fprintf(stderr, x); } while (0)
-
-static int              modules;
-
 static int              full_paths;
 static int              show_nr_samples;
 
+static int              show_threads;
+static struct perf_read_values  show_threads_values;
+
+static char             default_pretty_printing_style[] = "normal";
+static char             *pretty_printing_style = default_pretty_printing_style;
+
 static unsigned long    page_size;
 static unsigned long    mmap_window = 32;
 
@@ -67,6 +63,15 @@ static char		callchain_default_opt[] = "fractal,0.5";
 
 static int              callchain;
 
+static char             __cwd[PATH_MAX];
+static char             *cwd = __cwd;
+static int              cwdlen;
+
+static struct rb_root   threads;
+static struct thread    *last_match;
+
+static struct perf_header *header;
+
 static
 struct callchain_param  callchain_param = {
         .mode   = CHAIN_GRAPH_REL,
@@ -75,59 +80,6 @@ struct callchain_param	callchain_param = {
 
 static u64              sample_type;
 
-struct ip_event {
-        struct perf_event_header header;
-        u64 ip;
-        u32 pid, tid;
-        unsigned char __more_data[];
-};
-
-struct mmap_event {
-        struct perf_event_header header;
-        u32 pid, tid;
-        u64 start;
-        u64 len;
-        u64 pgoff;
-        char filename[PATH_MAX];
-};
-
-struct comm_event {
-        struct perf_event_header header;
-        u32 pid, tid;
-        char comm[16];
-};
-
-struct fork_event {
-        struct perf_event_header header;
-        u32 pid, ppid;
-        u32 tid, ptid;
-};
-
-struct lost_event {
-        struct perf_event_header header;
-        u64 id;
-        u64 lost;
-};
-
-struct read_event {
-        struct perf_event_header header;
-        u32 pid,tid;
-        u64 value;
-        u64 time_enabled;
-        u64 time_running;
-        u64 id;
-};
-
-typedef union event_union {
-        struct perf_event_header        header;
-        struct ip_event                 ip;
-        struct mmap_event               mmap;
-        struct comm_event               comm;
-        struct fork_event               fork;
-        struct lost_event               lost;
-        struct read_event               read;
-} event_t;
-
 static int repsep_fprintf(FILE *fp, const char *fmt, ...)
 {
         int n;
@@ -141,6 +93,7 @@ static int repsep_fprintf(FILE *fp, const char *fmt, ...)
                 n = vasprintf(&bf, fmt, ap);
                 if (n > 0) {
                         char *sep = bf;
+
                         while (1) {
                                 sep = strchr(sep, *field_sep);
                                 if (sep == NULL)
@@ -155,396 +108,10 @@ static int repsep_fprintf(FILE *fp, const char *fmt, ...)
         return n;
 }
 
-static LIST_HEAD(dsos);
-static struct dso *kernel_dso;
-static struct dso *vdso;
-static struct dso *hypervisor_dso;
-
-static void dsos__add(struct dso *dso)
-{
-        list_add_tail(&dso->node, &dsos);
-}
-
-static struct dso *dsos__find(const char *name)
-{
-        struct dso *pos;
-
-        list_for_each_entry(pos, &dsos, node)
-                if (strcmp(pos->name, name) == 0)
-                        return pos;
-        return NULL;
-}
-
-static struct dso *dsos__findnew(const char *name)
-{
-        struct dso *dso = dsos__find(name);
-        int nr;
-
-        if (dso)
-                return dso;
-
-        dso = dso__new(name, 0);
-        if (!dso)
-                goto out_delete_dso;
-
-        nr = dso__load(dso, NULL, verbose);
-        if (nr < 0) {
-                eprintf("Failed to open: %s\n", name);
-                goto out_delete_dso;
-        }
-        if (!nr)
-                eprintf("No symbols found in: %s, maybe install a debug package?\n", name);
-
-        dsos__add(dso);
-
-        return dso;
-
-out_delete_dso:
-        dso__delete(dso);
-        return NULL;
-}
-
-static void dsos__fprintf(FILE *fp)
-{
-        struct dso *pos;
-
-        list_for_each_entry(pos, &dsos, node)
-                dso__fprintf(pos, fp);
-}
-
-static struct symbol *vdso__find_symbol(struct dso *dso, u64 ip)
-{
-        return dso__find_symbol(dso, ip);
-}
-
-static int load_kernel(void)
-{
-        int err;
-
-        kernel_dso = dso__new("[kernel]", 0);
-        if (!kernel_dso)
-                return -1;
-
-        err = dso__load_kernel(kernel_dso, vmlinux, NULL, verbose, modules);
-        if (err <= 0) {
-                dso__delete(kernel_dso);
-                kernel_dso = NULL;
-        } else
-                dsos__add(kernel_dso);
-
-        vdso = dso__new("[vdso]", 0);
-        if (!vdso)
-                return -1;
-
-        vdso->find_symbol = vdso__find_symbol;
-
-        dsos__add(vdso);
-
-        hypervisor_dso = dso__new("[hypervisor]", 0);
-        if (!hypervisor_dso)
-                return -1;
-        dsos__add(hypervisor_dso);
-
-        return err;
-}
-
-static char __cwd[PATH_MAX];
-static char *cwd = __cwd;
-static int cwdlen;
-
-static int strcommon(const char *pathname)
-{
-        int n = 0;
-
-        while (n < cwdlen && pathname[n] == cwd[n])
-                ++n;
-
-        return n;
-}
-
-struct map {
-        struct list_head node;
-        u64      start;
-        u64      end;
-        u64      pgoff;
-        u64      (*map_ip)(struct map *, u64);
-        struct dso       *dso;
-};
-
-static u64 map__map_ip(struct map *map, u64 ip)
-{
-        return ip - map->start + map->pgoff;
-}
-
-static u64 vdso__map_ip(struct map *map __used, u64 ip)
-{
-        return ip;
-}
-
-static inline int is_anon_memory(const char *filename)
-{
-        return strcmp(filename, "//anon") == 0;
-}
-
-static struct map *map__new(struct mmap_event *event)
-{
-        struct map *self = malloc(sizeof(*self));
-
-        if (self != NULL) {
-                const char *filename = event->filename;
-                char newfilename[PATH_MAX];
-                int anon;
-
-                if (cwd) {
-                        int n = strcommon(filename);
-
-                        if (n == cwdlen) {
-                                snprintf(newfilename, sizeof(newfilename),
-                                         ".%s", filename + n);
-                                filename = newfilename;
-                        }
-                }
-
-                anon = is_anon_memory(filename);
-
-                if (anon) {
-                        snprintf(newfilename, sizeof(newfilename), "/tmp/perf-%d.map", event->pid);
-                        filename = newfilename;
-                }
-
-                self->start = event->start;
-                self->end   = event->start + event->len;
-                self->pgoff = event->pgoff;
-
-                self->dso = dsos__findnew(filename);
-                if (self->dso == NULL)
-                        goto out_delete;
-
-                if (self->dso == vdso || anon)
-                        self->map_ip = vdso__map_ip;
-                else
-                        self->map_ip = map__map_ip;
-        }
-        return self;
-out_delete:
-        free(self);
-        return NULL;
-}
-
-static struct map *map__clone(struct map *self)
-{
-        struct map *map = malloc(sizeof(*self));
-
-        if (!map)
-                return NULL;
-
-        memcpy(map, self, sizeof(*self));
-
-        return map;
-}
-
-static int map__overlap(struct map *l, struct map *r)
-{
-        if (l->start > r->start) {
-                struct map *t = l;
-                l = r;
-                r = t;
-        }
-
-        if (l->end > r->start)
-                return 1;
-
-        return 0;
-}
-
-static size_t map__fprintf(struct map *self, FILE *fp)
-{
-        return fprintf(fp, " %Lx-%Lx %Lx %s\n",
-                       self->start, self->end, self->pgoff, self->dso->name);
-}
-
-
-struct thread {
-        struct rb_node   rb_node;
-        struct list_head maps;
-        pid_t            pid;
-        char             *comm;
-};
-
-static struct thread *thread__new(pid_t pid)
-{
-        struct thread *self = malloc(sizeof(*self));
-
-        if (self != NULL) {
-                self->pid = pid;
-                self->comm = malloc(32);
-                if (self->comm)
-                        snprintf(self->comm, 32, ":%d", self->pid);
-                INIT_LIST_HEAD(&self->maps);
-        }
-
-        return self;
-}
-
 static unsigned int dsos__col_width,
                     comms__col_width,
                     threads__col_width;
 
-static int thread__set_comm(struct thread *self, const char *comm)
-{
-        if (self->comm)
-                free(self->comm);
-        self->comm = strdup(comm);
-        if (!self->comm)
-                return -ENOMEM;
-
-        if (!col_width_list_str && !field_sep &&
-            (!comm_list || strlist__has_entry(comm_list, comm))) {
-                unsigned int slen = strlen(comm);
-                if (slen > comms__col_width) {
-                        comms__col_width = slen;
-                        threads__col_width = slen + 6;
-                }
-        }
-
-        return 0;
-}
-
-static size_t thread__fprintf(struct thread *self, FILE *fp)
-{
-        struct map *pos;
-        size_t ret = fprintf(fp, "Thread %d %s\n", self->pid, self->comm);
-
-        list_for_each_entry(pos, &self->maps, node)
-                ret += map__fprintf(pos, fp);
-
-        return ret;
-}
-
-
-static struct rb_root threads;
-static struct thread *last_match;
-
-static struct thread *threads__findnew(pid_t pid)
-{
-        struct rb_node **p = &threads.rb_node;
-        struct rb_node *parent = NULL;
-        struct thread *th;
-
-        /*
-         * Font-end cache - PID lookups come in blocks,
-         * so most of the time we dont have to look up
-         * the full rbtree:
-         */
-        if (last_match && last_match->pid == pid)
-                return last_match;
-
-        while (*p != NULL) {
-                parent = *p;
-                th = rb_entry(parent, struct thread, rb_node);
-
-                if (th->pid == pid) {
-                        last_match = th;
-                        return th;
-                }
-
-                if (pid < th->pid)
-                        p = &(*p)->rb_left;
-                else
-                        p = &(*p)->rb_right;
-        }
-
-        th = thread__new(pid);
-        if (th != NULL) {
-                rb_link_node(&th->rb_node, parent, p);
-                rb_insert_color(&th->rb_node, &threads);
-                last_match = th;
-        }
-
-        return th;
-}
-
-static void thread__insert_map(struct thread *self, struct map *map)
-{
-        struct map *pos, *tmp;
-
-        list_for_each_entry_safe(pos, tmp, &self->maps, node) {
-                if (map__overlap(pos, map)) {
-                        if (verbose >= 2) {
-                                printf("overlapping maps:\n");
-                                map__fprintf(map, stdout);
-                                map__fprintf(pos, stdout);
-                        }
-
-                        if (map->start <= pos->start && map->end > pos->start)
-                                pos->start = map->end;
-
-                        if (map->end >= pos->end && map->start < pos->end)
-                                pos->end = map->start;
-
-                        if (verbose >= 2) {
-                                printf("after collision:\n");
-                                map__fprintf(pos, stdout);
-                        }
-
-                        if (pos->start >= pos->end) {
-                                list_del_init(&pos->node);
-                                free(pos);
-                        }
-                }
-        }
-
-        list_add_tail(&map->node, &self->maps);
-}
-
-static int thread__fork(struct thread *self, struct thread *parent)
-{
-        struct map *map;
-
-        if (self->comm)
-                free(self->comm);
-        self->comm = strdup(parent->comm);
-        if (!self->comm)
-                return -ENOMEM;
-
-        list_for_each_entry(map, &parent->maps, node) {
-                struct map *new = map__clone(map);
-                if (!new)
-                        return -ENOMEM;
-                thread__insert_map(self, new);
-        }
-
-        return 0;
-}
-
-static struct map *thread__find_map(struct thread *self, u64 ip)
-{
-        struct map *pos;
-
-        if (self == NULL)
-                return NULL;
-
-        list_for_each_entry(pos, &self->maps, node)
-                if (ip >= pos->start && ip <= pos->end)
-                        return pos;
-
-        return NULL;
-}
-
-static size_t threads__fprintf(FILE *fp)
-{
-        size_t ret = 0;
-        struct rb_node *nd;
-
-        for (nd = rb_first(&threads); nd; nd = rb_next(nd)) {
-                struct thread *pos = rb_entry(nd, struct thread, rb_node);
-
-                ret += thread__fprintf(pos, fp);
-        }
-
-        return ret;
-}
-
 /*
  * histogram, sorted on item, collects counts
  */
@@ -574,7 +141,7 @@ struct hist_entry {
 struct sort_entry {
         struct list_head list;
 
-        char *header;
+        const char *header;
 
         int64_t (*cmp)(struct hist_entry *, struct hist_entry *);
         int64_t (*collapse)(struct hist_entry *, struct hist_entry *);
@@ -758,7 +325,7 @@ static int sort__need_collapse = 0;
 static int sort__has_parent = 0;
 
 struct sort_dimension {
-        char                    *name;
+        const char              *name;
         struct sort_entry       *entry;
         int                     taken;
 };
@@ -773,7 +340,7 @@ static struct sort_dimension sort_dimensions[] = {
 
 static LIST_HEAD(hist_entry__sort_list);
 
-static int sort_dimension__add(char *tok)
+static int sort_dimension__add(const char *tok)
 {
         unsigned int i;
 
@@ -1032,6 +599,7 @@ hist_entry_callchain__fprintf(FILE *fp, struct hist_entry *self,
                 case CHAIN_GRAPH_REL:
                         ret += callchain__fprintf_graph(fp, chain,
                                                         total_samples, 1, 1);
+                case CHAIN_NONE:
                 default:
                         break;
                 }
@@ -1098,6 +666,34 @@ static void dso__calc_col_width(struct dso *self)
         self->slen_calculated = 1;
 }
 
+static void thread__comm_adjust(struct thread *self)
+{
+        char *comm = self->comm;
+
+        if (!col_width_list_str && !field_sep &&
+            (!comm_list || strlist__has_entry(comm_list, comm))) {
+                unsigned int slen = strlen(comm);
+
+                if (slen > comms__col_width) {
+                        comms__col_width = slen;
+                        threads__col_width = slen + 6;
+                }
+        }
+}
+
+static int thread__set_comm_adjust(struct thread *self, const char *comm)
+{
+        int ret = thread__set_comm(self, comm);
+
+        if (ret)
+                return ret;
+
+        thread__comm_adjust(self);
+
+        return 0;
+}
+
+
 static struct symbol *
 resolve_symbol(struct thread *thread, struct map **mapp,
                struct dso **dsop, u64 *ipp)
@@ -1141,8 +737,8 @@ got_map:
                 if ((long long)ip < 0)
                 dso = kernel_dso;
         }
-        dprintf(" ...... dso: %s\n", dso ? dso->name : "<not found>");
-        dprintf(" ...... map: %Lx -> %Lx\n", *ipp, ip);
+        dump_printf(" ...... dso: %s\n", dso ? dso->name : "<not found>");
+        dump_printf(" ...... map: %Lx -> %Lx\n", *ipp, ip);
         *ipp  = ip;
 
         if (dsop)
@@ -1398,6 +994,9 @@ static size_t output__fprintf(FILE *fp, u64 total_samples)
         size_t ret = 0;
         unsigned int width;
         char *col_width = col_width_list_str;
+        int raw_printing_style;
+
+        raw_printing_style = !strcmp(pretty_printing_style, "raw");
 
         init_rem_hits();
 
@@ -1474,18 +1073,11 @@ print_entries:
 
         free(rem_sq_bracket);
 
-        return ret;
-}
+        if (show_threads)
+                perf_read_values_display(fp, &show_threads_values,
+                                         raw_printing_style);
 
-static void register_idle_thread(void)
-{
-        struct thread *thread = threads__findnew(0);
-
-        if (thread == NULL ||
-                        thread__set_comm(thread, "[idle]")) {
-                fprintf(stderr, "problem inserting idle task.\n");
-                exit(-1);
-        }
+        return ret;
 }
 
 static unsigned long total = 0,
@@ -1514,7 +1106,7 @@ process_sample_event(event_t *event, unsigned long offset, unsigned long head)
         char level;
         int show = 0;
         struct dso *dso = NULL;
-        struct thread *thread = threads__findnew(event->ip.pid);
+        struct thread *thread;
         u64 ip = event->ip.ip;
         u64 period = 1;
         struct map *map = NULL;
@@ -1522,12 +1114,14 @@ process_sample_event(event_t *event, unsigned long offset, unsigned long head)
         struct ip_callchain *chain = NULL;
         int cpumode;
 
+        thread = threads__findnew(event->ip.pid, &threads, &last_match);
+
         if (sample_type & PERF_SAMPLE_PERIOD) {
                 period = *(u64 *)more_data;
                 more_data += sizeof(u64);
         }
 
-        dprintf("%p [%p]: PERF_EVENT_SAMPLE (IP, %d): %d/%d: %p period: %Ld\n",
+        dump_printf("%p [%p]: PERF_EVENT_SAMPLE (IP, %d): %d/%d: %p period: %Ld\n",
                 (void *)(offset + head),
                 (void *)(long)(event->header.size),
                 event->header.misc,
@@ -1540,7 +1134,7 @@ process_sample_event(event_t *event, unsigned long offset, unsigned long head)
 
                 chain = (void *)more_data;
 
-                dprintf("... chain: nr:%Lu\n", chain->nr);
+                dump_printf("... chain: nr:%Lu\n", chain->nr);
 
                 if (validate_chain(chain, event) < 0) {
                         eprintf("call-chain problem with event, skipping it.\n");
@@ -1549,11 +1143,11 @@ process_sample_event(event_t *event, unsigned long offset, unsigned long head)
 
                 if (dump_trace) {
                         for (i = 0; i < chain->nr; i++)
-                                dprintf("..... %2d: %016Lx\n", i, chain->ips[i]);
+                                dump_printf("..... %2d: %016Lx\n", i, chain->ips[i]);
                 }
         }
 
-        dprintf(" ... thread: %s:%d\n", thread->comm, thread->pid);
+        dump_printf(" ... thread: %s:%d\n", thread->comm, thread->pid);
 
         if (thread == NULL) {
                 eprintf("problem processing %d event, skipping it.\n",
@@ -1572,7 +1166,7 @@ process_sample_event(event_t *event, unsigned long offset, unsigned long head)
 
                 dso = kernel_dso;
 
-                dprintf(" ...... dso: %s\n", dso->name);
+                dump_printf(" ...... dso: %s\n", dso->name);
 
         } else if (cpumode == PERF_EVENT_MISC_USER) {
 
@@ -1585,7 +1179,7 @@ process_sample_event(event_t *event, unsigned long offset, unsigned long head)
 
                 dso = hypervisor_dso;
 
-                dprintf(" ...... dso: [hypervisor]\n");
+                dump_printf(" ...... dso: [hypervisor]\n");
         }
 
         if (show & show_mask) {
@@ -1611,10 +1205,12 @@ process_sample_event(event_t *event, unsigned long offset, unsigned long head)
 static int
 process_mmap_event(event_t *event, unsigned long offset, unsigned long head)
 {
-        struct thread *thread = threads__findnew(event->mmap.pid);
-        struct map *map = map__new(&event->mmap);
+        struct thread *thread;
+        struct map *map = map__new(&event->mmap, cwd, cwdlen);
 
-        dprintf("%p [%p]: PERF_EVENT_MMAP %d/%d: [%p(%p) @ %p]: %s\n",
+        thread = threads__findnew(event->mmap.pid, &threads, &last_match);
+
+        dump_printf("%p [%p]: PERF_EVENT_MMAP %d/%d: [%p(%p) @ %p]: %s\n",
                 (void *)(offset + head),
                 (void *)(long)(event->header.size),
                 event->mmap.pid,
@@ -1625,7 +1221,7 @@ process_mmap_event(event_t *event, unsigned long offset, unsigned long head)
                 event->mmap.filename);
 
         if (thread == NULL || map == NULL) {
-                dprintf("problem processing PERF_EVENT_MMAP, skipping event.\n");
+                dump_printf("problem processing PERF_EVENT_MMAP, skipping event.\n");
                 return 0;
         }
 
@@ -1638,16 +1234,18 @@ process_mmap_event(event_t *event, unsigned long offset, unsigned long head)
 static int
 process_comm_event(event_t *event, unsigned long offset, unsigned long head)
 {
-        struct thread *thread = threads__findnew(event->comm.pid);
+        struct thread *thread;
+
+        thread = threads__findnew(event->comm.pid, &threads, &last_match);
 
-        dprintf("%p [%p]: PERF_EVENT_COMM: %s:%d\n",
+        dump_printf("%p [%p]: PERF_EVENT_COMM: %s:%d\n",
                 (void *)(offset + head),
                 (void *)(long)(event->header.size),
                 event->comm.comm, event->comm.pid);
 
         if (thread == NULL ||
-            thread__set_comm(thread, event->comm.comm)) {
-                dprintf("problem processing PERF_EVENT_COMM, skipping event.\n");
+            thread__set_comm_adjust(thread, event->comm.comm)) {
+                dump_printf("problem processing PERF_EVENT_COMM, skipping event.\n");
                 return -1;
         }
         total_comm++;
@@ -1658,10 +1256,13 @@ process_comm_event(event_t *event, unsigned long offset, unsigned long head)
 static int
 process_task_event(event_t *event, unsigned long offset, unsigned long head)
 {
-        struct thread *thread = threads__findnew(event->fork.pid);
-        struct thread *parent = threads__findnew(event->fork.ppid);
+        struct thread *thread;
+        struct thread *parent;
 
-        dprintf("%p [%p]: PERF_EVENT_%s: (%d:%d):(%d:%d)\n",
+        thread = threads__findnew(event->fork.pid, &threads, &last_match);
+        parent = threads__findnew(event->fork.ppid, &threads, &last_match);
+
+        dump_printf("%p [%p]: PERF_EVENT_%s: (%d:%d):(%d:%d)\n",
                 (void *)(offset + head),
                 (void *)(long)(event->header.size),
                 event->header.type == PERF_EVENT_FORK ? "FORK" : "EXIT",
@@ -1679,7 +1280,7 @@ process_task_event(event_t *event, unsigned long offset, unsigned long head)
                 return 0;
 
         if (!thread || !parent || thread__fork(thread, parent)) {
-                dprintf("problem processing PERF_EVENT_FORK, skipping event.\n");
+                dump_printf("problem processing PERF_EVENT_FORK, skipping event.\n");
                 return -1;
         }
         total_fork++;
@@ -1690,7 +1291,7 @@ process_task_event(event_t *event, unsigned long offset, unsigned long head)
 static int
 process_lost_event(event_t *event, unsigned long offset, unsigned long head)
 {
-        dprintf("%p [%p]: PERF_EVENT_LOST: id:%Ld: lost:%Ld\n",
+        dump_printf("%p [%p]: PERF_EVENT_LOST: id:%Ld: lost:%Ld\n",
                 (void *)(offset + head),
                 (void *)(long)(event->header.size),
                 event->lost.id,
@@ -1701,67 +1302,24 @@ process_lost_event(event_t *event, unsigned long offset, unsigned long head)
         return 0;
 }
 
-static void trace_event(event_t *event)
-{
-        unsigned char *raw_event = (void *)event;
-        char *color = PERF_COLOR_BLUE;
-        int i, j;
-
-        if (!dump_trace)
-                return;
-
-        dprintf(".");
-        cdprintf("\n. ... raw event: size %d bytes\n", event->header.size);
-
-        for (i = 0; i < event->header.size; i++) {
-                if ((i & 15) == 0) {
-                        dprintf(".");
-                        cdprintf("  %04x: ", i);
-                }
-
-                cdprintf(" %02x", raw_event[i]);
-
-                if (((i & 15) == 15) || i == event->header.size-1) {
-                        cdprintf("  ");
-                        for (j = 0; j < 15-(i & 15); j++)
-                                cdprintf("   ");
-                        for (j = 0; j < (i & 15); j++) {
-                                if (isprint(raw_event[i-15+j]))
-                                        cdprintf("%c", raw_event[i-15+j]);
-                                else
-                                        cdprintf(".");
-                        }
-                        cdprintf("\n");
-                }
-        }
-        dprintf(".\n");
-}
-
-static struct perf_header       *header;
-
-static struct perf_counter_attr *perf_header__find_attr(u64 id)
+static int
+process_read_event(event_t *event, unsigned long offset, unsigned long head)
 {
-        int i;
+        struct perf_counter_attr *attr;
 
-        for (i = 0; i < header->attrs; i++) {
-                struct perf_header_attr *attr = header->attr[i];
-                int j;
+        attr = perf_header__find_attr(event->read.id, header);
 
-                for (j = 0; j < attr->ids; j++) {
-                        if (attr->id[j] == id)
-                                return &attr->attr;
-                }
+        if (show_threads) {
+                const char *name = attr ? __event_name(attr->type, attr->config)
+                                   : "unknown";
+                perf_read_values_add_value(&show_threads_values,
+                                           event->read.pid, event->read.tid,
+                                           event->read.id,
+                                           name,
+                                           event->read.value);
         }
 
-        return NULL;
-}
-
-static int
-process_read_event(event_t *event, unsigned long offset, unsigned long head)
-{
-        struct perf_counter_attr *attr = perf_header__find_attr(event->read.id);
-
-        dprintf("%p [%p]: PERF_EVENT_READ: %d %d %s %Lu\n",
+        dump_printf("%p [%p]: PERF_EVENT_READ: %d %d %s %Lu\n",
                         (void *)(offset + head),
                         (void *)(long)(event->header.size),
                         event->read.pid,
@@ -1813,34 +1371,22 @@ process_event(event_t *event, unsigned long offset, unsigned long head)
         return 0;
 }
 
-static u64 perf_header__sample_type(void)
-{
-        u64 sample_type = 0;
-        int i;
-
-        for (i = 0; i < header->attrs; i++) {
-                struct perf_header_attr *attr = header->attr[i];
-
-                if (!sample_type)
-                        sample_type = attr->attr.sample_type;
-                else if (sample_type != attr->attr.sample_type)
-                        die("non matching sample_type");
-        }
-
-        return sample_type;
-}
-
 static int __cmd_report(void)
 {
         int ret, rc = EXIT_FAILURE;
         unsigned long offset = 0;
         unsigned long head, shift;
-        struct stat stat;
+        struct stat input_stat;
+        struct thread *idle;
         event_t *event;
         uint32_t size;
         char *buf;
 
-        register_idle_thread();
+        idle = register_idle_thread(&threads, &last_match);
+        thread__comm_adjust(idle);
+
+        if (show_threads)
+                perf_read_values_init(&show_threads_values);
 
         input = open(input_name, O_RDONLY);
         if (input < 0) {
@@ -1851,18 +1397,18 @@ static int __cmd_report(void)
                 exit(-1);
         }
 
-        ret = fstat(input, &stat);
+        ret = fstat(input, &input_stat);
         if (ret < 0) {
                 perror("failed to stat file");
                 exit(-1);
         }
 
-        if (!force && (stat.st_uid != geteuid())) {
-                fprintf(stderr, "file: %s not owned by current user\n", input_name);
+        if (!force && input_stat.st_uid && (input_stat.st_uid != geteuid())) {
+                fprintf(stderr, "file: %s not owned by current user or root\n", input_name);
                 exit(-1);
         }
 
-        if (!stat.st_size) {
+        if (!input_stat.st_size) {
                 fprintf(stderr, "zero-sized file, nothing to do!\n");
                 exit(0);
         }
@@ -1870,7 +1416,7 @@ static int __cmd_report(void)
         header = perf_header__read(input);
         head = header->data_offset;
 
-        sample_type = perf_header__sample_type();
+        sample_type = perf_header__sample_type(header);
 
         if (!(sample_type & PERF_SAMPLE_CALLCHAIN)) {
                 if (sort__has_parent) {
@@ -1880,7 +1426,7 @@ static int __cmd_report(void)
                         exit(-1);
                 }
                 if (callchain) {
-                        fprintf(stderr, "selected -c but no callchain data."
+                        fprintf(stderr, "selected -g but no callchain data."
                                         " Did you call perf record without"
                                         " -g?\n");
                         exit(-1);
@@ -1930,12 +1476,12 @@ more:
                 size = 8;
 
         if (head + event->header.size >= page_size * mmap_window) {
-                int ret;
+                int munmap_ret;
 
                 shift = page_size * (head / page_size);
 
-                ret = munmap(buf, page_size * mmap_window);
-                assert(ret == 0);
+                munmap_ret = munmap(buf, page_size * mmap_window);
+                assert(munmap_ret == 0);
 
                 offset += shift;
                 head -= shift;
@@ -1944,14 +1490,14 @@ more:
 
         size = event->header.size;
 
-        dprintf("\n%p [%p]: event: %d\n",
+        dump_printf("\n%p [%p]: event: %d\n",
                         (void *)(offset + head),
                         (void *)(long)event->header.size,
                         event->header.type);
 
         if (!size || process_event(event, offset, head) < 0) {
 
-                dprintf("%p [%p]: skipping unknown header type: %d\n",
+                dump_printf("%p [%p]: skipping unknown header type: %d\n",
                         (void *)(offset + head),
                         (void *)(long)(event->header.size),
                         event->header.type);
@@ -1974,25 +1520,25 @@ more:
         if (offset + head >= header->data_offset + header->data_size)
                 goto done;
 
-        if (offset + head < (unsigned long)stat.st_size)
+        if (offset + head < (unsigned long)input_stat.st_size)
                 goto more;
 
 done:
         rc = EXIT_SUCCESS;
         close(input);
 
-        dprintf("      IP events: %10ld\n", total);
-        dprintf("    mmap events: %10ld\n", total_mmap);
-        dprintf("    comm events: %10ld\n", total_comm);
-        dprintf("    fork events: %10ld\n", total_fork);
-        dprintf("    lost events: %10ld\n", total_lost);
-        dprintf(" unknown events: %10ld\n", total_unknown);
+        dump_printf("      IP events: %10ld\n", total);
+        dump_printf("    mmap events: %10ld\n", total_mmap);
+        dump_printf("    comm events: %10ld\n", total_comm);
+        dump_printf("    fork events: %10ld\n", total_fork);
+        dump_printf("    lost events: %10ld\n", total_lost);
+        dump_printf(" unknown events: %10ld\n", total_unknown);
 
         if (dump_trace)
                 return 0;
 
         if (verbose >= 3)
-                threads__fprintf(stdout);
+                threads__fprintf(stdout, &threads);
 
         if (verbose >= 2)
                 dsos__fprintf(stdout);
@@ -2001,6 +1547,9 @@ done:
         output__resort(total);
         output__fprintf(stdout, total);
 
+        if (show_threads)
+                perf_read_values_destroy(&show_threads_values);
+
         return rc;
 }
 
@@ -2069,12 +1618,16 @@ static const struct option options[] = {
                     "be more verbose (show symbol address, etc)"),
         OPT_BOOLEAN('D', "dump-raw-trace", &dump_trace,
                     "dump raw trace in ASCII"),
-        OPT_STRING('k', "vmlinux", &vmlinux, "file", "vmlinux pathname"),
+        OPT_STRING('k', "vmlinux", &vmlinux_name, "file", "vmlinux pathname"),
         OPT_BOOLEAN('f', "force", &force, "don't complain, do it"),
         OPT_BOOLEAN('m', "modules", &modules,
                     "load module symbols - WARNING: use only with -k and LIVE kernel"),
         OPT_BOOLEAN('n', "show-nr-samples", &show_nr_samples,
                     "Show a column with the number of samples"),
+        OPT_BOOLEAN('T', "threads", &show_threads,
+                    "Show per-thread event counters"),
+        OPT_STRING(0, "pretty", &pretty_printing_style, "key",
+                   "pretty printing style key: normal raw"),
         OPT_STRING('s', "sort", &sort_order, "key[,key2...]",
                    "sort by key(s): pid, comm, dso, symbol, parent"),
         OPT_BOOLEAN('P', "full-paths", &full_paths,
diff --git a/tools/perf/builtin-stat.c b/tools/perf/builtin-stat.c
index b4b06c7903e1..61b828236c11 100644
--- a/tools/perf/builtin-stat.c
+++ b/tools/perf/builtin-stat.c
@@ -42,6 +42,8 @@
 #include "util/util.h"
 #include "util/parse-options.h"
 #include "util/parse-events.h"
+#include "util/event.h"
+#include "util/debug.h"
 
 #include <sys/prctl.h>
 #include <math.h>
@@ -60,10 +62,7 @@ static struct perf_counter_attr default_attrs[] = {
 
 };
 
-#define MAX_RUN                 100
-
 static int                      system_wide                     =  0;
-static int                      verbose                         =  0;
 static unsigned int             nr_cpus                         =  0;
 static int                      run_idx                         =  0;
 
@@ -75,26 +74,56 @@ static int			null_run			=  0;
 
 static int                      fd[MAX_NR_CPUS][MAX_COUNTERS];
 
-static u64                      runtime_nsecs[MAX_RUN];
-static u64                      walltime_nsecs[MAX_RUN];
-static u64                      runtime_cycles[MAX_RUN];
+static int                      event_scaled[MAX_COUNTERS];
 
-static u64                      event_res[MAX_RUN][MAX_COUNTERS][3];
-static u64                      event_scaled[MAX_RUN][MAX_COUNTERS];
+struct stats
+{
+        double n, mean, M2;
+};
 
-static u64                      event_res_avg[MAX_COUNTERS][3];
-static u64                      event_res_noise[MAX_COUNTERS][3];
+static void update_stats(struct stats *stats, u64 val)
+{
+        double delta;
 
-static u64                      event_scaled_avg[MAX_COUNTERS];
+        stats->n++;
+        delta = val - stats->mean;
+        stats->mean += delta / stats->n;
+        stats->M2 += delta*(val - stats->mean);
+}
 
-static u64                      runtime_nsecs_avg;
-static u64                      runtime_nsecs_noise;
+static double avg_stats(struct stats *stats)
+{
+        return stats->mean;
+}
 
-static u64                      walltime_nsecs_avg;
-static u64                      walltime_nsecs_noise;
+/*
+ * http://en.wikipedia.org/wiki/Algorithms_for_calculating_variance
+ *
+ *       (\Sum n_i^2) - ((\Sum n_i)^2)/n
+ * s^2 = -------------------------------
+ *                  n - 1
+ *
+ * http://en.wikipedia.org/wiki/Stddev
+ *
+ * The std dev of the mean is related to the std dev by:
+ *
+ *             s
+ * s_mean = -------
+ *          sqrt(n)
+ *
+ */
+static double stddev_stats(struct stats *stats)
+{
+        double variance = stats->M2 / (stats->n - 1);
+        double variance_mean = variance / stats->n;
+
+        return sqrt(variance_mean);
+}
 
-static u64                      runtime_cycles_avg;
-static u64                      runtime_cycles_noise;
+struct stats                    event_res_stats[MAX_COUNTERS][3];
+struct stats                    runtime_nsecs_stats;
+struct stats                    walltime_nsecs_stats;
+struct stats                    runtime_cycles_stats;
 
 #define MATCH_EVENT(t, c, counter)                      \
         (attrs[counter].type == PERF_TYPE_##t &&        \
@@ -149,12 +178,11 @@ static inline int nsec_counter(int counter)
  */
 static void read_counter(int counter)
 {
-        u64 *count, single_count[3];
+        u64 count[3], single_count[3];
         unsigned int cpu;
         size_t res, nv;
         int scaled;
-
-        count = event_res[run_idx][counter];
+        int i;
 
         count[0] = count[1] = count[2] = 0;
 
@@ -179,24 +207,33 @@ static void read_counter(int counter)
         scaled = 0;
         if (scale) {
                 if (count[2] == 0) {
-                        event_scaled[run_idx][counter] = -1;
+                        event_scaled[counter] = -1;
                         count[0] = 0;
                         return;
                 }
 
                 if (count[2] < count[1]) {
-                        event_scaled[run_idx][counter] = 1;
+                        event_scaled[counter] = 1;
                         count[0] = (unsigned long long)
                                 ((double)count[0] * count[1] / count[2] + 0.5);
                 }
         }
+
+        for (i = 0; i < 3; i++)
+                update_stats(&event_res_stats[counter][i], count[i]);
+
+        if (verbose) {
+                fprintf(stderr, "%s: %Ld %Ld %Ld\n", event_name(counter),
+                                count[0], count[1], count[2]);
+        }
+
         /*
          * Save the full runtime - to allow normalization during printout:
          */
         if (MATCH_EVENT(SOFTWARE, SW_TASK_CLOCK, counter))
-                runtime_nsecs[run_idx] = count[0];
+                update_stats(&runtime_nsecs_stats, count[0]);
         if (MATCH_EVENT(HARDWARE, HW_CPU_CYCLES, counter))
-                runtime_cycles[run_idx] = count[0];
+                update_stats(&runtime_cycles_stats, count[0]);
 }
 
 static int run_perf_stat(int argc __used, const char **argv)
@@ -270,7 +307,7 @@ static int run_perf_stat(int argc __used, const char **argv)
 
         t1 = rdclock();
 
-        walltime_nsecs[run_idx] = t1 - t0;
+        update_stats(&walltime_nsecs_stats, t1 - t0);
 
         for (counter = 0; counter < nr_counters; counter++)
                 read_counter(counter);
@@ -278,42 +315,38 @@ static int run_perf_stat(int argc __used, const char **argv)
         return WEXITSTATUS(status);
 }
 
-static void print_noise(u64 *count, u64 *noise)
+static void print_noise(int counter, double avg)
 {
-        if (run_count > 1)
-                fprintf(stderr, "   ( +- %7.3f%% )",
-                        (double)noise[0]/(count[0]+1)*100.0);
+        if (run_count == 1)
+                return;
+
+        fprintf(stderr, "   ( +- %7.3f%% )",
+                        100 * stddev_stats(&event_res_stats[counter][0]) / avg);
 }
 
-static void nsec_printout(int counter, u64 *count, u64 *noise)
+static void nsec_printout(int counter, double avg)
 {
-        double msecs = (double)count[0] / 1000000;
+        double msecs = avg / 1e6;
 
         fprintf(stderr, " %14.6f  %-24s", msecs, event_name(counter));
 
         if (MATCH_EVENT(SOFTWARE, SW_TASK_CLOCK, counter)) {
-                if (walltime_nsecs_avg)
-                        fprintf(stderr, " # %10.3f CPUs ",
-                                (double)count[0] / (double)walltime_nsecs_avg);
+                fprintf(stderr, " # %10.3f CPUs ",
+                                avg / avg_stats(&walltime_nsecs_stats));
         }
-        print_noise(count, noise);
 }
 
-static void abs_printout(int counter, u64 *count, u64 *noise)
+static void abs_printout(int counter, double avg)
 {
-        fprintf(stderr, " %14Ld  %-24s", count[0], event_name(counter));
+        fprintf(stderr, " %14.0f  %-24s", avg, event_name(counter));
 
-        if (runtime_cycles_avg &&
-            MATCH_EVENT(HARDWARE, HW_INSTRUCTIONS, counter)) {
+        if (MATCH_EVENT(HARDWARE, HW_INSTRUCTIONS, counter)) {
                 fprintf(stderr, " # %10.3f IPC  ",
-                        (double)count[0] / (double)runtime_cycles_avg);
+                                avg / avg_stats(&runtime_cycles_stats));
         } else {
-                if (runtime_nsecs_avg) {
-                        fprintf(stderr, " # %10.3f M/sec",
-                                (double)count[0]/runtime_nsecs_avg*1000.0);
-                }
+                fprintf(stderr, " # %10.3f M/sec",
+                                1000.0 * avg / avg_stats(&runtime_nsecs_stats));
         }
-        print_noise(count, noise);
 }
 
 /*
@@ -321,12 +354,8 @@ static void abs_printout(int counter, u64 *count, u64 *noise)
  */
 static void print_counter(int counter)
 {
-        u64 *count, *noise;
-        int scaled;
-
-        count = event_res_avg[counter];
-        noise = event_res_noise[counter];
-        scaled = event_scaled_avg[counter];
+        double avg = avg_stats(&event_res_stats[counter][0]);
+        int scaled = event_scaled[counter];
 
         if (scaled == -1) {
                 fprintf(stderr, " %14s  %-24s\n",
@@ -335,110 +364,29 @@ static void print_counter(int counter)
         }
 
         if (nsec_counter(counter))
-                nsec_printout(counter, count, noise);
+                nsec_printout(counter, avg);
         else
-                abs_printout(counter, count, noise);
-
-        if (scaled)
-                fprintf(stderr, "  (scaled from %.2f%%)",
-                        (double) count[2] / count[1] * 100);
-
-        fprintf(stderr, "\n");
-}
+                abs_printout(counter, avg);
 
-/*
- * normalize_noise noise values down to stddev:
- */
-static void normalize_noise(u64 *val)
-{
-        double res;
+        print_noise(counter, avg);
 
-        res = (double)*val / (run_count * sqrt((double)run_count));
+        if (scaled) {
+                double avg_enabled, avg_running;
 
-        *val = (u64)res;
-}
+                avg_enabled = avg_stats(&event_res_stats[counter][1]);
+                avg_running = avg_stats(&event_res_stats[counter][2]);
 
-static void update_avg(const char *name, int idx, u64 *avg, u64 *val)
-{
-        *avg += *val;
-
-        if (verbose > 1)
-                fprintf(stderr, "debug: %20s[%d]: %Ld\n", name, idx, *val);
-}
-/*
- * Calculate the averages and noises:
- */
-static void calc_avg(void)
-{
-        int i, j;
-
-        if (verbose > 1)
-                fprintf(stderr, "\n");
-
-        for (i = 0; i < run_count; i++) {
-                update_avg("runtime", 0, &runtime_nsecs_avg, runtime_nsecs + i);
-                update_avg("walltime", 0, &walltime_nsecs_avg, walltime_nsecs + i);
-                update_avg("runtime_cycles", 0, &runtime_cycles_avg, runtime_cycles + i);
-
-                for (j = 0; j < nr_counters; j++) {
-                        update_avg("counter/0", j,
-                                event_res_avg[j]+0, event_res[i][j]+0);
-                        update_avg("counter/1", j,
-                                event_res_avg[j]+1, event_res[i][j]+1);
-                        update_avg("counter/2", j,
-                                event_res_avg[j]+2, event_res[i][j]+2);
-                        if (event_scaled[i][j] != (u64)-1)
-                                update_avg("scaled", j,
-                                        event_scaled_avg + j, event_scaled[i]+j);
-                        else
-                                event_scaled_avg[j] = -1;
-                }
-        }
-        runtime_nsecs_avg /= run_count;
-        walltime_nsecs_avg /= run_count;
-        runtime_cycles_avg /= run_count;
-
-        for (j = 0; j < nr_counters; j++) {
-                event_res_avg[j][0] /= run_count;
-                event_res_avg[j][1] /= run_count;
-                event_res_avg[j][2] /= run_count;
-        }
-
-        for (i = 0; i < run_count; i++) {
-                runtime_nsecs_noise +=
-                        abs((s64)(runtime_nsecs[i] - runtime_nsecs_avg));
-                walltime_nsecs_noise +=
-                        abs((s64)(walltime_nsecs[i] - walltime_nsecs_avg));
-                runtime_cycles_noise +=
-                        abs((s64)(runtime_cycles[i] - runtime_cycles_avg));
-
-                for (j = 0; j < nr_counters; j++) {
-                        event_res_noise[j][0] +=
-                                abs((s64)(event_res[i][j][0] - event_res_avg[j][0]));
-                        event_res_noise[j][1] +=
-                                abs((s64)(event_res[i][j][1] - event_res_avg[j][1]));
-                        event_res_noise[j][2] +=
-                                abs((s64)(event_res[i][j][2] - event_res_avg[j][2]));
-                }
+                fprintf(stderr, "  (scaled from %.2f%%)",
+                                100 * avg_running / avg_enabled);
         }
 
-        normalize_noise(&runtime_nsecs_noise);
-        normalize_noise(&walltime_nsecs_noise);
-        normalize_noise(&runtime_cycles_noise);
-
-        for (j = 0; j < nr_counters; j++) {
-                normalize_noise(&event_res_noise[j][0]);
-                normalize_noise(&event_res_noise[j][1]);
-                normalize_noise(&event_res_noise[j][2]);
-        }
+        fprintf(stderr, "\n");
 }
 
 static void print_stat(int argc, const char **argv)
 {
         int i, counter;
 
-        calc_avg();
-
         fflush(stdout);
 
         fprintf(stderr, "\n");
@@ -457,10 +405,11 @@ static void print_stat(int argc, const char **argv)
 
         fprintf(stderr, "\n");
         fprintf(stderr, " %14.9f  seconds time elapsed",
-                        (double)walltime_nsecs_avg/1e9);
+                        avg_stats(&walltime_nsecs_stats)/1e9);
         if (run_count > 1) {
                 fprintf(stderr, "   ( +- %7.3f%% )",
-                        100.0*(double)walltime_nsecs_noise/(double)walltime_nsecs_avg);
+                                100*stddev_stats(&walltime_nsecs_stats) /
+                                avg_stats(&walltime_nsecs_stats));
         }
         fprintf(stderr, "\n\n");
 }
@@ -515,7 +464,7 @@ int cmd_stat(int argc, const char **argv, const char *prefix __used)
                 PARSE_OPT_STOP_AT_NON_OPTION);
         if (!argc)
                 usage_with_options(stat_usage, options);
-        if (run_count <= 0 || run_count > MAX_RUN)
+        if (run_count <= 0)
                 usage_with_options(stat_usage, options);
 
         /* Set attrs and nr_counters if no event is selected and !null_run */
diff --git a/tools/perf/builtin-top.c b/tools/perf/builtin-top.c
index 7de28ce9ca26..4002ccb36750 100644
--- a/tools/perf/builtin-top.c
+++ b/tools/perf/builtin-top.c
@@ -27,6 +27,8 @@
 #include "util/parse-options.h"
 #include "util/parse-events.h"
 
+#include "util/debug.h"
+
 #include <assert.h>
 #include <fcntl.h>
 
@@ -68,8 +70,6 @@ static int			group				=  0;
 static unsigned int             page_size;
 static unsigned int             mmap_pages                      = 16;
 static int                      freq                            =  0;
-static int                      verbose                         =  0;
-static char                     *vmlinux                        =  NULL;
 
 static int                      delay_secs                      =  2;
 static int                      zero;
@@ -122,7 +122,8 @@ static void parse_source(struct sym_entry *syme)
         struct module *module;
         struct section *section = NULL;
         FILE *file;
-        char command[PATH_MAX*2], *path = vmlinux;
+        char command[PATH_MAX*2];
+        const char *path = vmlinux_name;
         u64 start, end, len;
 
         if (!syme)
@@ -338,8 +339,6 @@ static void show_details(struct sym_entry *syme)
                 printf("%d lines not displayed, maybe increase display entries [e]\n", more);
 }
 
-struct dso                      *kernel_dso;
-
 /*
  * Symbols will be added here in record_ip and will get out
  * after decayed.
@@ -484,17 +483,24 @@ static void print_sym_table(void)
         if (nr_counters == 1)
                 printf("             samples    pcnt");
         else
-                printf("  weight     samples    pcnt");
+                printf("   weight    samples    pcnt");
 
-        printf("         RIP          kernel function\n"
-                       "  ______     _______   _____   ________________   _______________\n\n"
-        );
+        if (verbose)
+                printf("         RIP       ");
+        printf("   kernel function\n");
+        printf("   %s    _______   _____",
+               nr_counters == 1 ? "      " : "______");
+        if (verbose)
+                printf("   ________________");
+        printf("   _______________\n\n");
 
         for (nd = rb_first(&tmp); nd; nd = rb_next(nd)) {
-                struct sym_entry *syme = rb_entry(nd, struct sym_entry, rb_node);
-                struct symbol *sym = (struct symbol *)(syme + 1);
+                struct symbol *sym;
                 double pcnt;
 
+                syme = rb_entry(nd, struct sym_entry, rb_node);
+                sym = (struct symbol *)(syme + 1);
+
                 if (++printed > print_entries || (int)syme->snap_count < count_filter)
                         continue;
 
@@ -507,7 +513,9 @@ static void print_sym_table(void)
                         printf("%9.1f %10ld - ", syme->weight, syme->snap_count);
 
                 percent_color_fprintf(stdout, "%4.1f%%", pcnt);
-                printf(" - %016llx : %s", sym->start, sym->name);
+                if (verbose)
+                        printf(" - %016llx", sym->start);
+                printf(" : %s", sym->name);
                 if (sym->module)
                         printf("\t[%s]", sym->module->name);
                 printf("\n");
@@ -613,7 +621,7 @@ static void print_mapped_keys(void)
 
         fprintf(stdout, "\t[f]     profile display filter (count).    \t(%d)\n", count_filter);
 
-        if (vmlinux) {
+        if (vmlinux_name) {
                 fprintf(stdout, "\t[F]     annotate display filter (percent). \t(%d%%)\n", sym_pcnt_filter);
                 fprintf(stdout, "\t[s]     annotate symbol.                   \t(%s)\n", name?: "NULL");
                 fprintf(stdout, "\t[S]     stop annotation.\n");
@@ -642,7 +650,9 @@ static int key_mapped(int c)
                 case 'F':
                 case 's':
                 case 'S':
-                        return vmlinux ? 1 : 0;
+                        return vmlinux_name ? 1 : 0;
+                default:
+                        break;
         }
 
         return 0;
@@ -728,6 +738,8 @@ static void handle_keypress(int c)
                 case 'z':
                         zero = ~zero;
                         break;
+                default:
+                        break;
         }
 }
 
@@ -816,13 +828,13 @@ static int parse_symbols(void)
 {
         struct rb_node *node;
         struct symbol  *sym;
-        int modules = vmlinux ? 1 : 0;
+        int use_modules = vmlinux_name ? 1 : 0;
 
         kernel_dso = dso__new("[kernel]", sizeof(struct sym_entry));
         if (kernel_dso == NULL)
                 return -1;
 
-        if (dso__load_kernel(kernel_dso, vmlinux, symbol_filter, verbose, modules) <= 0)
+        if (dso__load_kernel(kernel_dso, vmlinux_name, symbol_filter, verbose, use_modules) <= 0)
                 goto out_delete_dso;
 
         node = rb_first(&kernel_dso->syms);
@@ -937,26 +949,6 @@ static void mmap_read_counter(struct mmap_data *md)
         last_read = this_read;
 
         for (; old != head;) {
-                struct ip_event {
-                        struct perf_event_header header;
-                        u64 ip;
-                        u32 pid, target_pid;
-                };
-                struct mmap_event {
-                        struct perf_event_header header;
-                        u32 pid, target_pid;
-                        u64 start;
-                        u64 len;
-                        u64 pgoff;
-                        char filename[PATH_MAX];
-                };
-
-                typedef union event_union {
-                        struct perf_event_header header;
-                        struct ip_event ip;
-                        struct mmap_event mmap;
-                } event_t;
-
                 event_t *event = (event_t *)&data[old & md->mask];
 
                 event_t event_copy;
@@ -1138,7 +1130,7 @@ static const struct option options[] = {
                             "system-wide collection from all CPUs"),
         OPT_INTEGER('C', "CPU", &profile_cpu,
                     "CPU to profile on"),
-        OPT_STRING('k', "vmlinux", &vmlinux, "file", "vmlinux pathname"),
+        OPT_STRING('k', "vmlinux", &vmlinux_name, "file", "vmlinux pathname"),
         OPT_INTEGER('m', "mmap-pages", &mmap_pages,
                     "number of mmap data pages"),
         OPT_INTEGER('r', "realtime", &realtime_prio,
diff --git a/tools/perf/builtin-trace.c b/tools/perf/builtin-trace.c
new file mode 100644
index 000000000000..914ab366e369
--- /dev/null
+++ b/tools/perf/builtin-trace.c
@@ -0,0 +1,297 @@
+#include "builtin.h"
+
+#include "util/util.h"
+#include "util/cache.h"
+#include "util/symbol.h"
+#include "util/thread.h"
+#include "util/header.h"
+
+#include "util/parse-options.h"
+
+#include "perf.h"
+#include "util/debug.h"
+
+#include "util/trace-event.h"
+
+static char             const *input_name = "perf.data";
+static int              input;
+static unsigned long    page_size;
+static unsigned long    mmap_window = 32;
+
+static unsigned long    total = 0;
+static unsigned long    total_comm = 0;
+
+static struct rb_root   threads;
+static struct thread    *last_match;
+
+static struct perf_header *header;
+static u64              sample_type;
+
+
+static int
+process_comm_event(event_t *event, unsigned long offset, unsigned long head)
+{
+        struct thread *thread;
+
+        thread = threads__findnew(event->comm.pid, &threads, &last_match);
+
+        dump_printf("%p [%p]: PERF_EVENT_COMM: %s:%d\n",
+                (void *)(offset + head),
+                (void *)(long)(event->header.size),
+                event->comm.comm, event->comm.pid);
+
+        if (thread == NULL ||
+            thread__set_comm(thread, event->comm.comm)) {
+                dump_printf("problem processing PERF_EVENT_COMM, skipping event.\n");
+                return -1;
+        }
+        total_comm++;
+
+        return 0;
+}
+
+static int
+process_sample_event(event_t *event, unsigned long offset, unsigned long head)
+{
+        char level;
+        int show = 0;
+        struct dso *dso = NULL;
+        struct thread *thread;
+        u64 ip = event->ip.ip;
+        u64 timestamp = -1;
+        u32 cpu = -1;
+        u64 period = 1;
+        void *more_data = event->ip.__more_data;
+        int cpumode;
+
+        thread = threads__findnew(event->ip.pid, &threads, &last_match);
+
+        if (sample_type & PERF_SAMPLE_TIME) {
+                timestamp = *(u64 *)more_data;
+                more_data += sizeof(u64);
+        }
+
+        if (sample_type & PERF_SAMPLE_CPU) {
+                cpu = *(u32 *)more_data;
+                more_data += sizeof(u32);
+                more_data += sizeof(u32); /* reserved */
+        }
+
+        if (sample_type & PERF_SAMPLE_PERIOD) {
+                period = *(u64 *)more_data;
+                more_data += sizeof(u64);
+        }
+
+        dump_printf("%p [%p]: PERF_EVENT_SAMPLE (IP, %d): %d/%d: %p period: %Ld\n",
+                (void *)(offset + head),
+                (void *)(long)(event->header.size),
+                event->header.misc,
+                event->ip.pid, event->ip.tid,
+                (void *)(long)ip,
+                (long long)period);
+
+        dump_printf(" ... thread: %s:%d\n", thread->comm, thread->pid);
+
+        if (thread == NULL) {
+                eprintf("problem processing %d event, skipping it.\n",
+                        event->header.type);
+                return -1;
+        }
+
+        cpumode = event->header.misc & PERF_EVENT_MISC_CPUMODE_MASK;
+
+        if (cpumode == PERF_EVENT_MISC_KERNEL) {
+                show = SHOW_KERNEL;
+                level = 'k';
+
+                dso = kernel_dso;
+
+                dump_printf(" ...... dso: %s\n", dso->name);
+
+        } else if (cpumode == PERF_EVENT_MISC_USER) {
+
+                show = SHOW_USER;
+                level = '.';
+
+        } else {
+                show = SHOW_HV;
+                level = 'H';
+
+                dso = hypervisor_dso;
+
+                dump_printf(" ...... dso: [hypervisor]\n");
+        }
+
+        if (sample_type & PERF_SAMPLE_RAW) {
+                struct {
+                        u32 size;
+                        char data[0];
+                } *raw = more_data;
+
+                /*
+                 * FIXME: better resolve from pid from the struct trace_entry
+                 * field, although it should be the same than this perf
+                 * event pid
+                 */
+                print_event(cpu, raw->data, raw->size, timestamp, thread->comm);
+        }
+        total += period;
+
+        return 0;
+}
+
+static int
+process_event(event_t *event, unsigned long offset, unsigned long head)
+{
+        trace_event(event);
+
+        switch (event->header.type) {
+        case PERF_EVENT_MMAP ... PERF_EVENT_LOST:
+                return 0;
+
+        case PERF_EVENT_COMM:
+                return process_comm_event(event, offset, head);
+
+        case PERF_EVENT_EXIT ... PERF_EVENT_READ:
+                return 0;
+
+        case PERF_EVENT_SAMPLE:
+                return process_sample_event(event, offset, head);
+
+        case PERF_EVENT_MAX:
+        default:
+                return -1;
+        }
+
+        return 0;
+}
+
+static int __cmd_trace(void)
+{
+        int ret, rc = EXIT_FAILURE;
+        unsigned long offset = 0;
+        unsigned long head = 0;
+        struct stat perf_stat;
+        event_t *event;
+        uint32_t size;
+        char *buf;
+
+        trace_report();
+        register_idle_thread(&threads, &last_match);
+
+        input = open(input_name, O_RDONLY);
+        if (input < 0) {
+                perror("failed to open file");
+                exit(-1);
+        }
+
+        ret = fstat(input, &perf_stat);
+        if (ret < 0) {
+                perror("failed to stat file");
+                exit(-1);
+        }
+
+        if (!perf_stat.st_size) {
+                fprintf(stderr, "zero-sized file, nothing to do!\n");
+                exit(0);
+        }
+        header = perf_header__read(input);
+        head = header->data_offset;
+        sample_type = perf_header__sample_type(header);
+
+        if (!(sample_type & PERF_SAMPLE_RAW))
+                die("No trace sample to read. Did you call perf record "
+                    "without -R?");
+
+        if (load_kernel() < 0) {
+                perror("failed to load kernel symbols");
+                return EXIT_FAILURE;
+        }
+
+remap:
+        buf = (char *)mmap(NULL, page_size * mmap_window, PROT_READ,
+                           MAP_SHARED, input, offset);
+        if (buf == MAP_FAILED) {
+                perror("failed to mmap file");
+                exit(-1);
+        }
+
+more:
+        event = (event_t *)(buf + head);
+
+        size = event->header.size;
+        if (!size)
+                size = 8;
+
+        if (head + event->header.size >= page_size * mmap_window) {
+                unsigned long shift = page_size * (head / page_size);
+                int res;
+
+                res = munmap(buf, page_size * mmap_window);
+                assert(res == 0);
+
+                offset += shift;
+                head -= shift;
+                goto remap;
+        }
+
+        size = event->header.size;
+
+
+        if (!size || process_event(event, offset, head) < 0) {
+
+                /*
+                 * assume we lost track of the stream, check alignment, and
+                 * increment a single u64 in the hope to catch on again 'soon'.
+                 */
+
+                if (unlikely(head & 7))
+                        head &= ~7ULL;
+
+                size = 8;
+        }
+
+        head += size;
+
+        if (offset + head < (unsigned long)perf_stat.st_size)
+                goto more;
+
+        rc = EXIT_SUCCESS;
+        close(input);
+
+        return rc;
+}
+
+static const char * const annotate_usage[] = {
+        "perf trace [<options>] <command>",
+        NULL
+};
+
+static const struct option options[] = {
+        OPT_BOOLEAN('D', "dump-raw-trace", &dump_trace,
+                    "dump raw trace in ASCII"),
+        OPT_BOOLEAN('v', "verbose", &verbose,
+                    "be more verbose (show symbol address, etc)"),
+        OPT_END()
+};
+
+int cmd_trace(int argc, const char **argv, const char *prefix __used)
+{
+        symbol__init();
+        page_size = getpagesize();
+
+        argc = parse_options(argc, argv, options, annotate_usage, 0);
+        if (argc) {
+                /*
+                 * Special case: if there's an argument left then assume tha
+                 * it's a symbol filter:
+                 */
+                if (argc > 1)
+                        usage_with_options(annotate_usage, options);
+        }
+
+
+        setup_pager();
+
+        return __cmd_trace();
+}
diff --git a/tools/perf/builtin.h b/tools/perf/builtin.h
index 51d168230ee7..3a63e41fb44e 100644
--- a/tools/perf/builtin.h
+++ b/tools/perf/builtin.h
@@ -22,5 +22,6 @@ extern int cmd_stat(int argc, const char **argv, const char *prefix);
 extern int cmd_top(int argc, const char **argv, const char *prefix);
 extern int cmd_version(int argc, const char **argv, const char *prefix);
 extern int cmd_list(int argc, const char **argv, const char *prefix);
+extern int cmd_trace(int argc, const char **argv, const char *prefix);
 
 #endif
diff --git a/tools/perf/perf.c b/tools/perf/perf.c
index 31982ad064b4..fe4589dde950 100644
--- a/tools/perf/perf.c
+++ b/tools/perf/perf.c
@@ -292,6 +292,7 @@ static void handle_internal_command(int argc, const char **argv)
                 { "top", cmd_top, 0 },
                 { "annotate", cmd_annotate, 0 },
                 { "version", cmd_version, 0 },
+                { "trace", cmd_trace, 0 },
         };
         unsigned int i;
         static const char ext[] = STRIP_EXTENSION;
diff --git a/tools/perf/util/abspath.c b/tools/perf/util/abspath.c
index 61d33b81fc97..a791dd467261 100644
--- a/tools/perf/util/abspath.c
+++ b/tools/perf/util/abspath.c
@@ -50,7 +50,8 @@ const char *make_absolute_path(const char *path)
                         die ("Could not get current working directory");
 
                 if (last_elem) {
-                        int len = strlen(buf);
+                        len = strlen(buf);
+
                         if (len + strlen(last_elem) + 2 > PATH_MAX)
                                 die ("Too long path name: '%s/%s'",
                                                 buf, last_elem);
diff --git a/tools/perf/util/cache.h b/tools/perf/util/cache.h
index 4b50c412b9c5..6f8ea9d210b6 100644
--- a/tools/perf/util/cache.h
+++ b/tools/perf/util/cache.h
@@ -52,7 +52,6 @@ extern const char *perf_mailmap_file;
 extern void maybe_flush_or_die(FILE *, const char *);
 extern int copy_fd(int ifd, int ofd);
 extern int copy_file(const char *dst, const char *src, int mode);
-extern ssize_t read_in_full(int fd, void *buf, size_t count);
 extern ssize_t write_in_full(int fd, const void *buf, size_t count);
 extern void write_or_die(int fd, const void *buf, size_t count);
 extern int write_or_whine(int fd, const void *buf, size_t count, const char *msg);
diff --git a/tools/perf/util/callchain.c b/tools/perf/util/callchain.c
index 011473411642..3b8380f1b478 100644
--- a/tools/perf/util/callchain.c
+++ b/tools/perf/util/callchain.c
@@ -50,6 +50,7 @@ rb_insert_callchain(struct rb_root *root, struct callchain_node *chain,
                         else
                                 p = &(*p)->rb_right;
                         break;
+                case CHAIN_NONE:
                 default:
                         break;
                 }
@@ -143,6 +144,7 @@ int register_callchain_param(struct callchain_param *param)
         case CHAIN_FLAT:
                 param->sort = sort_chain_flat;
                 break;
+        case CHAIN_NONE:
         default:
                 return -1;
         }
diff --git a/tools/perf/util/callchain.h b/tools/perf/util/callchain.h
index a926ae4f5a16..43cf3ea9e088 100644
--- a/tools/perf/util/callchain.h
+++ b/tools/perf/util/callchain.h
@@ -4,6 +4,7 @@
 #include "../perf.h"
 #include <linux/list.h>
 #include <linux/rbtree.h>
+#include "util.h"
 #include "symbol.h"
 
 enum chain_mode {
diff --git a/tools/perf/util/color.c b/tools/perf/util/color.c
index 90a044d1fe7d..e88bca55a599 100644
--- a/tools/perf/util/color.c
+++ b/tools/perf/util/color.c
@@ -166,7 +166,7 @@ int perf_color_default_config(const char *var, const char *value, void *cb)
         return perf_default_config(var, value, cb);
 }
 
-static int color_vfprintf(FILE *fp, const char *color, const char *fmt,
+static int __color_vfprintf(FILE *fp, const char *color, const char *fmt,
                 va_list args, const char *trail)
 {
         int r = 0;
@@ -191,6 +191,10 @@ static int color_vfprintf(FILE *fp, const char *color, const char *fmt,
         return r;
 }
 
+int color_vfprintf(FILE *fp, const char *color, const char *fmt, va_list args)
+{
+        return __color_vfprintf(fp, color, fmt, args, NULL);
+}
 
 
 int color_fprintf(FILE *fp, const char *color, const char *fmt, ...)
@@ -199,7 +203,7 @@ int color_fprintf(FILE *fp, const char *color, const char *fmt, ...)
         int r;
 
         va_start(args, fmt);
-        r = color_vfprintf(fp, color, fmt, args, NULL);
+        r = color_vfprintf(fp, color, fmt, args);
         va_end(args);
         return r;
 }
@@ -209,7 +213,7 @@ int color_fprintf_ln(FILE *fp, const char *color, const char *fmt, ...)
         va_list args;
         int r;
         va_start(args, fmt);
-        r = color_vfprintf(fp, color, fmt, args, "\n");
+        r = __color_vfprintf(fp, color, fmt, args, "\n");
         va_end(args);
         return r;
 }
@@ -242,9 +246,9 @@ int color_fwrite_lines(FILE *fp, const char *color,
         return 0;
 }
 
-char *get_percent_color(double percent)
+const char *get_percent_color(double percent)
 {
-        char *color = PERF_COLOR_NORMAL;
+        const char *color = PERF_COLOR_NORMAL;
 
         /*
          * We color high-overhead entries in red, mid-overhead
@@ -263,7 +267,7 @@ char *get_percent_color(double percent)
 int percent_color_fprintf(FILE *fp, const char *fmt, double percent)
 {
         int r;
-        char *color;
+        const char *color;
 
         color = get_percent_color(percent);
         r = color_fprintf(fp, color, fmt, percent);
diff --git a/tools/perf/util/color.h b/tools/perf/util/color.h
index 706cec50bd25..58d597564b99 100644
--- a/tools/perf/util/color.h
+++ b/tools/perf/util/color.h
@@ -32,10 +32,11 @@ int perf_color_default_config(const char *var, const char *value, void *cb);
 int perf_config_colorbool(const char *var, const char *value, int stdout_is_tty);
 void color_parse(const char *value, const char *var, char *dst);
 void color_parse_mem(const char *value, int len, const char *var, char *dst);
+int color_vfprintf(FILE *fp, const char *color, const char *fmt, va_list args);
 int color_fprintf(FILE *fp, const char *color, const char *fmt, ...);
 int color_fprintf_ln(FILE *fp, const char *color, const char *fmt, ...);
 int color_fwrite_lines(FILE *fp, const char *color, size_t count, const char *buf);
 int percent_color_fprintf(FILE *fp, const char *fmt, double percent);
-char *get_percent_color(double percent);
+const char *get_percent_color(double percent);
 
 #endif /* COLOR_H */
diff --git a/tools/perf/util/config.c b/tools/perf/util/config.c
index 780df541006d..8784649109ce 100644
--- a/tools/perf/util/config.c
+++ b/tools/perf/util/config.c
@@ -160,17 +160,18 @@ static int get_extended_base_var(char *name, int baselen, int c)
         name[baselen++] = '.';
 
         for (;;) {
-                int c = get_next_char();
-                if (c == '\n')
+                int ch = get_next_char();
+
+                if (ch == '\n')
                         return -1;
-                if (c == '"')
+                if (ch == '"')
                         break;
-                if (c == '\\') {
-                        c = get_next_char();
-                        if (c == '\n')
+                if (ch == '\\') {
+                        ch = get_next_char();
+                        if (ch == '\n')
                                 return -1;
                 }
-                name[baselen++] = c;
+                name[baselen++] = ch;
                 if (baselen > MAXNAME / 2)
                         return -1;
         }
@@ -530,6 +531,8 @@ static int store_aux(const char* key, const char* value, void *cb __used)
                                         store.offset[store.seen] = ftell(config_file);
                         }
                 }
+        default:
+                break;
         }
         return 0;
 }
@@ -619,6 +622,7 @@ contline:
                 switch (contents[offset]) {
                         case '=': equal_offset = offset; break;
                         case ']': bracket_offset = offset; break;
+                        default: break;
                 }
         if (offset > 0 && contents[offset-1] == '\\') {
                 offset_ = offset;
@@ -742,9 +746,9 @@ int perf_config_set_multivar(const char* key, const char* value,
                         goto write_err_out;
         } else {
                 struct stat st;
-                char* contents;
+                char *contents;
                 ssize_t contents_sz, copy_begin, copy_end;
-                int i, new_line = 0;
+                int new_line = 0;
 
                 if (value_regex == NULL)
                         store.value_regex = NULL;
diff --git a/tools/perf/util/debug.c b/tools/perf/util/debug.c
new file mode 100644
index 000000000000..e8ca98fe0bd4
--- /dev/null
+++ b/tools/perf/util/debug.c
@@ -0,0 +1,95 @@
+/* For general debugging purposes */
+
+#include "../perf.h"
+
+#include <string.h>
+#include <stdarg.h>
+#include <stdio.h>
+
+#include "color.h"
+#include "event.h"
+#include "debug.h"
+
+int verbose = 0;
+int dump_trace = 0;
+
+int eprintf(const char *fmt, ...)
+{
+        va_list args;
+        int ret = 0;
+
+        if (verbose) {
+                va_start(args, fmt);
+                ret = vfprintf(stderr, fmt, args);
+                va_end(args);
+        }
+
+        return ret;
+}
+
+int dump_printf(const char *fmt, ...)
+{
+        va_list args;
+        int ret = 0;
+
+        if (dump_trace) {
+                va_start(args, fmt);
+                ret = vprintf(fmt, args);
+                va_end(args);
+        }
+
+        return ret;
+}
+
+static int dump_printf_color(const char *fmt, const char *color, ...)
+{
+        va_list args;
+        int ret = 0;
+
+        if (dump_trace) {
+                va_start(args, color);
+                ret = color_vfprintf(stdout, color, fmt, args);
+                va_end(args);
+        }
+
+        return ret;
+}
+
+
+void trace_event(event_t *event)
+{
+        unsigned char *raw_event = (void *)event;
+        const char *color = PERF_COLOR_BLUE;
+        int i, j;
+
+        if (!dump_trace)
+                return;
+
+        dump_printf(".");
+        dump_printf_color("\n. ... raw event: size %d bytes\n", color,
+                          event->header.size);
+
+        for (i = 0; i < event->header.size; i++) {
+                if ((i & 15) == 0) {
+                        dump_printf(".");
+                        dump_printf_color("  %04x: ", color, i);
+                }
+
+                dump_printf_color(" %02x", color, raw_event[i]);
+
+                if (((i & 15) == 15) || i == event->header.size-1) {
+                        dump_printf_color("  ", color);
+                        for (j = 0; j < 15-(i & 15); j++)
+                                dump_printf_color("   ", color);
+                        for (j = 0; j < (i & 15); j++) {
+                                if (isprint(raw_event[i-15+j]))
+                                        dump_printf_color("%c", color,
+                                                          raw_event[i-15+j]);
+                                else
+                                        dump_printf_color(".", color);
+                        }
+                        dump_printf_color("\n", color);
+                }
+        }
+        dump_printf(".\n");
+}
diff --git a/tools/perf/util/debug.h b/tools/perf/util/debug.h
new file mode 100644
index 000000000000..437eea58ce40
--- /dev/null
+++ b/tools/perf/util/debug.h
@@ -0,0 +1,8 @@
+/* For debugging general purposes */
+
+extern int verbose;
+extern int dump_trace;
+
+int eprintf(const char *fmt, ...) __attribute__((format(printf, 1, 2)));
+int dump_printf(const char *fmt, ...) __attribute__((format(printf, 1, 2)));
+void trace_event(event_t *event);
diff --git a/tools/perf/util/event.h b/tools/perf/util/event.h
new file mode 100644
index 000000000000..fa2d4e91d329
--- /dev/null
+++ b/tools/perf/util/event.h
@@ -0,0 +1,96 @@
+#ifndef __PERF_EVENT_H
+#define __PERF_EVENT_H
+#include "../perf.h"
+#include "util.h"
+#include <linux/list.h>
+
+enum {
+        SHOW_KERNEL     = 1,
+        SHOW_USER       = 2,
+        SHOW_HV         = 4,
+};
+
+/*
+ * PERF_SAMPLE_IP | PERF_SAMPLE_TID | *
+ */
+struct ip_event {
+        struct perf_event_header header;
+        u64 ip;
+        u32 pid, tid;
+        unsigned char __more_data[];
+};
+
+struct mmap_event {
+        struct perf_event_header header;
+        u32 pid, tid;
+        u64 start;
+        u64 len;
+        u64 pgoff;
+        char filename[PATH_MAX];
+};
+
+struct comm_event {
+        struct perf_event_header header;
+        u32 pid, tid;
+        char comm[16];
+};
+
+struct fork_event {
+        struct perf_event_header header;
+        u32 pid, ppid;
+        u32 tid, ptid;
+};
+
+struct lost_event {
+        struct perf_event_header header;
+        u64 id;
+        u64 lost;
+};
+
+/*
+ * PERF_FORMAT_ENABLED | PERF_FORMAT_RUNNING | PERF_FORMAT_ID
+ */
+struct read_event {
+        struct perf_event_header header;
+        u32 pid,tid;
+        u64 value;
+        u64 time_enabled;
+        u64 time_running;
+        u64 id;
+};
+
+typedef union event_union {
+        struct perf_event_header        header;
+        struct ip_event                 ip;
+        struct mmap_event               mmap;
+        struct comm_event               comm;
+        struct fork_event               fork;
+        struct lost_event               lost;
+        struct read_event               read;
+} event_t;
+
+struct map {
+        struct list_head        node;
+        u64                     start;
+        u64                     end;
+        u64                     pgoff;
+        u64                     (*map_ip)(struct map *, u64);
+        struct dso              *dso;
+};
+
+static inline u64 map__map_ip(struct map *map, u64 ip)
+{
+        return ip - map->start + map->pgoff;
+}
+
+static inline u64 vdso__map_ip(struct map *map __used, u64 ip)
+{
+        return ip;
+}
+
+struct map *map__new(struct mmap_event *event, char *cwd, int cwdlen);
+struct map *map__clone(struct map *self);
+int map__overlap(struct map *l, struct map *r);
+size_t map__fprintf(struct map *self, FILE *fp);
+
+#endif
diff --git a/tools/perf/util/exec_cmd.c b/tools/perf/util/exec_cmd.c
index 34a352867382..2745605dba11 100644
--- a/tools/perf/util/exec_cmd.c
+++ b/tools/perf/util/exec_cmd.c
@@ -6,7 +6,6 @@
 
 #define MAX_ARGS        32
 
-extern char **environ;
 static const char *argv_exec_path;
 static const char *argv0_path;
 
diff --git a/tools/perf/util/header.c b/tools/perf/util/header.c
index b92a457ca32e..ec4d4c2f9522 100644
--- a/tools/perf/util/header.c
+++ b/tools/perf/util/header.c
@@ -237,9 +237,44 @@ struct perf_header *perf_header__read(int fd)
         self->data_offset = f_header.data.offset;
         self->data_size   = f_header.data.size;
 
-        lseek(fd, self->data_offset + self->data_size, SEEK_SET);
+        lseek(fd, self->data_offset, SEEK_SET);
 
         self->frozen = 1;
 
         return self;
 }
+
+u64 perf_header__sample_type(struct perf_header *header)
+{
+        u64 type = 0;
+        int i;
+
+        for (i = 0; i < header->attrs; i++) {
+                struct perf_header_attr *attr = header->attr[i];
+
+                if (!type)
+                        type = attr->attr.sample_type;
+                else if (type != attr->attr.sample_type)
+                        die("non matching sample_type");
+        }
+
+        return type;
+}
+
+struct perf_counter_attr *
+perf_header__find_attr(u64 id, struct perf_header *header)
+{
+        int i;
+
+        for (i = 0; i < header->attrs; i++) {
+                struct perf_header_attr *attr = header->attr[i];
+                int j;
+
+                for (j = 0; j < attr->ids; j++) {
+                        if (attr->id[j] == id)
+                                return &attr->attr;
+                }
+        }
+
+        return NULL;
+}
diff --git a/tools/perf/util/header.h b/tools/perf/util/header.h
index bf280449fcfd..5d0a72ecc919 100644
--- a/tools/perf/util/header.h
+++ b/tools/perf/util/header.h
@@ -31,6 +31,10 @@ struct perf_header_attr *
 perf_header_attr__new(struct perf_counter_attr *attr);
 void perf_header_attr__add_id(struct perf_header_attr *self, u64 id);
 
+u64 perf_header__sample_type(struct perf_header *header);
+struct perf_counter_attr *
+perf_header__find_attr(u64 id, struct perf_header *header);
+
 
 struct perf_header *perf_header__new(void);
 
diff --git a/tools/perf/util/map.c b/tools/perf/util/map.c
new file mode 100644
index 000000000000..804e02382739
--- /dev/null
+++ b/tools/perf/util/map.c
@@ -0,0 +1,97 @@
+#include "event.h"
+#include "symbol.h"
+#include <stdlib.h>
+#include <string.h>
+#include <stdio.h>
+
+static inline int is_anon_memory(const char *filename)
+{
+        return strcmp(filename, "//anon") == 0;
+}
+
+static int strcommon(const char *pathname, char *cwd, int cwdlen)
+{
+        int n = 0;
+
+        while (n < cwdlen && pathname[n] == cwd[n])
+                ++n;
+
+        return n;
+}
+
+ struct map *map__new(struct mmap_event *event, char *cwd, int cwdlen)
+{
+        struct map *self = malloc(sizeof(*self));
+
+        if (self != NULL) {
+                const char *filename = event->filename;
+                char newfilename[PATH_MAX];
+                int anon;
+
+                if (cwd) {
+                        int n = strcommon(filename, cwd, cwdlen);
+
+                        if (n == cwdlen) {
+                                snprintf(newfilename, sizeof(newfilename),
+                                         ".%s", filename + n);
+                                filename = newfilename;
+                        }
+                }
+
+                anon = is_anon_memory(filename);
+
+                if (anon) {
+                        snprintf(newfilename, sizeof(newfilename), "/tmp/perf-%d.map", event->pid);
+                        filename = newfilename;
+                }
+
+                self->start = event->start;
+                self->end   = event->start + event->len;
+                self->pgoff = event->pgoff;
+
+                self->dso = dsos__findnew(filename);
+                if (self->dso == NULL)
+                        goto out_delete;
+
+                if (self->dso == vdso || anon)
+                        self->map_ip = vdso__map_ip;
+                else
+                        self->map_ip = map__map_ip;
+        }
+        return self;
+out_delete:
+        free(self);
+        return NULL;
+}
+
+struct map *map__clone(struct map *self)
+{
+        struct map *map = malloc(sizeof(*self));
+
+        if (!map)
+                return NULL;
+
+        memcpy(map, self, sizeof(*self));
+
+        return map;
+}
+
+int map__overlap(struct map *l, struct map *r)
+{
+        if (l->start > r->start) {
+                struct map *t = l;
+                l = r;
+                r = t;
+        }
+
+        if (l->end > r->start)
+                return 1;
+
+        return 0;
+}
+
+size_t map__fprintf(struct map *self, FILE *fp)
+{
+        return fprintf(fp, " %Lx-%Lx %Lx %s\n",
+                       self->start, self->end, self->pgoff, self->dso->name);
+}
diff --git a/tools/perf/util/module.c b/tools/perf/util/module.c
index ddabe925d65d..3d567fe59c79 100644
--- a/tools/perf/util/module.c
+++ b/tools/perf/util/module.c
@@ -436,9 +436,9 @@ static int mod_dso__load_module_paths(struct mod_dso *self)
                 goto out_failure;
 
         while (!feof(file)) {
-                char *path, *name, *tmp;
+                char *name, *tmp;
                 struct module *module;
-                int line_len, len;
+                int line_len;
 
                 line_len = getline(&line, &n, file);
                 if (line_len < 0)
diff --git a/tools/perf/util/parse-events.c b/tools/perf/util/parse-events.c
index 044178408783..a587d41ae3c9 100644
--- a/tools/perf/util/parse-events.c
+++ b/tools/perf/util/parse-events.c
@@ -1,23 +1,21 @@
 
-#include "../perf.h"
 #include "util.h"
+#include "../perf.h"
 #include "parse-options.h"
 #include "parse-events.h"
 #include "exec_cmd.h"
 #include "string.h"
 #include "cache.h"
 
-extern char *strcasestr(const char *haystack, const char *needle);
-
 int                                     nr_counters;
 
 struct perf_counter_attr                attrs[MAX_COUNTERS];
 
 struct event_symbol {
-        u8      type;
-        u64     config;
-        char    *symbol;
-        char    *alias;
+        u8              type;
+        u64             config;
+        const char      *symbol;
+        const char      *alias;
 };
 
 char debugfs_path[MAXPATHLEN];
@@ -51,7 +49,7 @@ static struct event_symbol event_symbols[] = {
 #define PERF_COUNTER_TYPE(config)       __PERF_COUNTER_FIELD(config, TYPE)
 #define PERF_COUNTER_ID(config)         __PERF_COUNTER_FIELD(config, EVENT)
 
-static char *hw_event_names[] = {
+static const char *hw_event_names[] = {
         "cycles",
         "instructions",
         "cache-references",
@@ -61,7 +59,7 @@ static char *hw_event_names[] = {
         "bus-cycles",
 };
 
-static char *sw_event_names[] = {
+static const char *sw_event_names[] = {
         "cpu-clock-msecs",
         "task-clock-msecs",
         "page-faults",
@@ -73,7 +71,7 @@ static char *sw_event_names[] = {
 
 #define MAX_ALIASES 8
 
-static char *hw_cache[][MAX_ALIASES] = {
+static const char *hw_cache[][MAX_ALIASES] = {
  { "L1-dcache", "l1-d",         "l1d",          "L1-data",              },
  { "L1-icache", "l1-i",         "l1i",          "L1-instruction",       },
  { "LLC",       "L2"                                                    },
@@ -82,13 +80,13 @@ static char *hw_cache[][MAX_ALIASES] = {
  { "branch",    "branches",     "bpu",          "btb",          "bpc",  },
 };
 
-static char *hw_cache_op[][MAX_ALIASES] = {
+static const char *hw_cache_op[][MAX_ALIASES] = {
  { "load",      "loads",        "read",                                 },
  { "store",     "stores",       "write",                                },
  { "prefetch",  "prefetches",   "speculative-read", "speculative-load", },
 };
 
-static char *hw_cache_result[][MAX_ALIASES] = {
+static const char *hw_cache_result[][MAX_ALIASES] = {
  { "refs",      "Reference",    "ops",          "access",               },
  { "misses",    "miss",                                                 },
 };
@@ -113,11 +111,9 @@ static unsigned long hw_cache_stat[C(MAX)] = {
  [C(BPU)]       = (CACHE_READ),
 };
 
-#define for_each_subsystem(sys_dir, sys_dirent, sys_next, file, st)            \
+#define for_each_subsystem(sys_dir, sys_dirent, sys_next)              \
         while (!readdir_r(sys_dir, &sys_dirent, &sys_next) && sys_next)        \
-        if (snprintf(file, MAXPATHLEN, "%s/%s", debugfs_path,                  \
-                        sys_dirent.d_name) &&                                  \
-           (!stat(file, &st)) && (S_ISDIR(st.st_mode)) &&                      \
+        if (sys_dirent.d_type == DT_DIR &&                                     \
            (strcmp(sys_dirent.d_name, ".")) &&                                 \
            (strcmp(sys_dirent.d_name, "..")))
 
@@ -136,11 +132,9 @@ static int tp_event_has_id(struct dirent *sys_dir, struct dirent *evt_dir)
         return 0;
 }
 
-#define for_each_event(sys_dirent, evt_dir, evt_dirent, evt_next, file, st)    \
+#define for_each_event(sys_dirent, evt_dir, evt_dirent, evt_next)              \
         while (!readdir_r(evt_dir, &evt_dirent, &evt_next) && evt_next)        \
-        if (snprintf(file, MAXPATHLEN, "%s/%s/%s", debugfs_path,               \
-                     sys_dirent.d_name, evt_dirent.d_name) &&                  \
-           (!stat(file, &st)) && (S_ISDIR(st.st_mode)) &&                      \
+        if (evt_dirent.d_type == DT_DIR &&                                     \
            (strcmp(evt_dirent.d_name, ".")) &&                                 \
            (strcmp(evt_dirent.d_name, "..")) &&                                \
            (!tp_event_has_id(&sys_dirent, &evt_dirent)))
@@ -158,34 +152,39 @@ int valid_debugfs_mount(const char *debugfs)
         return 0;
 }
 
-static char *tracepoint_id_to_name(u64 config)
+struct tracepoint_path *tracepoint_id_to_path(u64 config)
 {
-        static char tracepoint_name[2 * MAX_EVENT_LENGTH];
+        struct tracepoint_path *path = NULL;
         DIR *sys_dir, *evt_dir;
         struct dirent *sys_next, *evt_next, sys_dirent, evt_dirent;
-        struct stat st;
         char id_buf[4];
-        int fd;
+        int sys_dir_fd, fd;
         u64 id;
         char evt_path[MAXPATHLEN];
 
         if (valid_debugfs_mount(debugfs_path))
-                return "unkown";
+                return NULL;
 
         sys_dir = opendir(debugfs_path);
         if (!sys_dir)
                 goto cleanup;
-
-        for_each_subsystem(sys_dir, sys_dirent, sys_next, evt_path, st) {
-                evt_dir = opendir(evt_path);
-                if (!evt_dir)
-                        goto cleanup;
-                for_each_event(sys_dirent, evt_dir, evt_dirent, evt_next,
-                                                                evt_path, st) {
-                        snprintf(evt_path, MAXPATHLEN, "%s/%s/%s/id",
-                                 debugfs_path, sys_dirent.d_name,
+        sys_dir_fd = dirfd(sys_dir);
+
+        for_each_subsystem(sys_dir, sys_dirent, sys_next) {
+                int dfd = openat(sys_dir_fd, sys_dirent.d_name,
+                                 O_RDONLY|O_DIRECTORY), evt_dir_fd;
+                if (dfd == -1)
+                        continue;
+                evt_dir = fdopendir(dfd);
+                if (!evt_dir) {
+                        close(dfd);
+                        continue;
+                }
+                evt_dir_fd = dirfd(evt_dir);
+                for_each_event(sys_dirent, evt_dir, evt_dirent, evt_next) {
+                        snprintf(evt_path, MAXPATHLEN, "%s/id",
                                  evt_dirent.d_name);
-                        fd = open(evt_path, O_RDONLY);
+                        fd = openat(evt_dir_fd, evt_path, O_RDONLY);
                         if (fd < 0)
                                 continue;
                         if (read(fd, id_buf, sizeof(id_buf)) < 0) {
@@ -197,10 +196,23 @@ static char *tracepoint_id_to_name(u64 config)
                         if (id == config) {
                                 closedir(evt_dir);
                                 closedir(sys_dir);
-                                snprintf(tracepoint_name, 2 * MAX_EVENT_LENGTH,
-                                        "%s:%s", sys_dirent.d_name,
-                                        evt_dirent.d_name);
-                                return tracepoint_name;
+                                path = calloc(1, sizeof(path));
+                                path->system = malloc(MAX_EVENT_LENGTH);
+                                if (!path->system) {
+                                        free(path);
+                                        return NULL;
+                                }
+                                path->name = malloc(MAX_EVENT_LENGTH);
+                                if (!path->name) {
+                                        free(path->system);
+                                        free(path);
+                                        return NULL;
+                                }
+                                strncpy(path->system, sys_dirent.d_name,
+                                        MAX_EVENT_LENGTH);
+                                strncpy(path->name, evt_dirent.d_name,
+                                        MAX_EVENT_LENGTH);
+                                return path;
                         }
                 }
                 closedir(evt_dir);
@@ -208,7 +220,25 @@ static char *tracepoint_id_to_name(u64 config)
 
 cleanup:
         closedir(sys_dir);
-        return "unkown";
+        return NULL;
+}
+
+#define TP_PATH_LEN (MAX_EVENT_LENGTH * 2 + 1)
+static const char *tracepoint_id_to_name(u64 config)
+{
+        static char buf[TP_PATH_LEN];
+        struct tracepoint_path *path;
+
+        path = tracepoint_id_to_path(config);
+        if (path) {
+                snprintf(buf, TP_PATH_LEN, "%s:%s", path->system, path->name);
+                free(path->name);
+                free(path->system);
+                free(path);
+        } else
+                snprintf(buf, TP_PATH_LEN, "%s:%s", "unknown", "unknown");
+
+        return buf;
 }
 
 static int is_cache_op_valid(u8 cache_type, u8 cache_op)
@@ -235,7 +265,7 @@ static char *event_cache_name(u8 cache_type, u8 cache_op, u8 cache_result)
         return name;
 }
 
-char *event_name(int counter)
+const char *event_name(int counter)
 {
         u64 config = attrs[counter].config;
         int type = attrs[counter].type;
@@ -243,7 +273,7 @@ char *event_name(int counter)
         return __event_name(type, config);
 }
 
-char *__event_name(int type, u64 config)
+const char *__event_name(int type, u64 config)
 {
         static char buf[32];
 
@@ -294,7 +324,7 @@ char *__event_name(int type, u64 config)
         return "unknown";
 }
 
-static int parse_aliases(const char **str, char *names[][MAX_ALIASES], int size)
+static int parse_aliases(const char **str, const char *names[][MAX_ALIASES], int size)
 {
         int i, j;
         int n, longest = -1;
@@ -598,7 +628,7 @@ static void print_tracepoint_events(void)
 {
         DIR *sys_dir, *evt_dir;
         struct dirent *sys_next, *evt_next, sys_dirent, evt_dirent;
-        struct stat st;
+        int sys_dir_fd;
         char evt_path[MAXPATHLEN];
 
         if (valid_debugfs_mount(debugfs_path))
@@ -607,16 +637,23 @@ static void print_tracepoint_events(void)
         sys_dir = opendir(debugfs_path);
         if (!sys_dir)
                 goto cleanup;
-
-        for_each_subsystem(sys_dir, sys_dirent, sys_next, evt_path, st) {
-                evt_dir = opendir(evt_path);
-                if (!evt_dir)
-                        goto cleanup;
-                for_each_event(sys_dirent, evt_dir, evt_dirent, evt_next,
-                                                                evt_path, st) {
+        sys_dir_fd = dirfd(sys_dir);
+
+        for_each_subsystem(sys_dir, sys_dirent, sys_next) {
+                int dfd = openat(sys_dir_fd, sys_dirent.d_name,
+                                 O_RDONLY|O_DIRECTORY), evt_dir_fd;
+                if (dfd == -1)
+                        continue;
+                evt_dir = fdopendir(dfd);
+                if (!evt_dir) {
+                        close(dfd);
+                        continue;
+                }
+                evt_dir_fd = dirfd(evt_dir);
+                for_each_event(sys_dirent, evt_dir, evt_dirent, evt_next) {
                         snprintf(evt_path, MAXPATHLEN, "%s:%s",
                                  sys_dirent.d_name, evt_dirent.d_name);
-                        fprintf(stderr, "  %-40s [%s]\n", evt_path,
+                        fprintf(stderr, "  %-42s [%s]\n", evt_path,
                                 event_type_descriptors[PERF_TYPE_TRACEPOINT+1]);
                 }
                 closedir(evt_dir);
@@ -650,7 +687,7 @@ void print_events(void)
                         sprintf(name, "%s OR %s", syms->symbol, syms->alias);
                 else
                         strcpy(name, syms->symbol);
-                fprintf(stderr, "  %-40s [%s]\n", name,
+                fprintf(stderr, "  %-42s [%s]\n", name,
                         event_type_descriptors[type]);
 
                 prev_type = type;
@@ -664,7 +701,7 @@ void print_events(void)
                                 continue;
 
                         for (i = 0; i < PERF_COUNT_HW_CACHE_RESULT_MAX; i++) {
-                                fprintf(stderr, "  %-40s [%s]\n",
+                                fprintf(stderr, "  %-42s [%s]\n",
                                         event_cache_name(type, op, i),
                                         event_type_descriptors[4]);
                         }
@@ -672,7 +709,7 @@ void print_events(void)
         }
 
         fprintf(stderr, "\n");
-        fprintf(stderr, "  %-40s [raw hardware event descriptor]\n",
+        fprintf(stderr, "  %-42s [raw hardware event descriptor]\n",
                 "rNNN");
         fprintf(stderr, "\n");
 
diff --git a/tools/perf/util/parse-events.h b/tools/perf/util/parse-events.h
index 192a962e3a0f..60704c15961f 100644
--- a/tools/perf/util/parse-events.h
+++ b/tools/perf/util/parse-events.h
@@ -1,16 +1,25 @@
-
+#ifndef _PARSE_EVENTS_H
+#define _PARSE_EVENTS_H
 /*
  * Parse symbolic events/counts passed in as options:
  */
 
 struct option;
 
+struct tracepoint_path {
+        char *system;
+        char *name;
+        struct tracepoint_path *next;
+};
+
+extern struct tracepoint_path *tracepoint_id_to_path(u64 config);
+
 extern int                      nr_counters;
 
 extern struct perf_counter_attr attrs[MAX_COUNTERS];
 
-extern char *event_name(int ctr);
-extern char *__event_name(int type, u64 config);
+extern const char *event_name(int ctr);
+extern const char *__event_name(int type, u64 config);
 
 extern int parse_events(const struct option *opt, const char *str, int unset);
 
@@ -21,3 +30,5 @@ extern void print_events(void);
 extern char debugfs_path[];
 extern int valid_debugfs_mount(const char *debugfs);
 
+
+#endif /* _PARSE_EVENTS_H */
diff --git a/tools/perf/util/parse-options.c b/tools/perf/util/parse-options.c
index 1bf67190c820..6d8af48c925e 100644
--- a/tools/perf/util/parse-options.c
+++ b/tools/perf/util/parse-options.c
@@ -53,6 +53,12 @@ static int get_value(struct parse_opt_ctx_t *p,
                 case OPTION_SET_INT:
                 case OPTION_SET_PTR:
                         return opterror(opt, "takes no value", flags);
+                case OPTION_END:
+                case OPTION_ARGUMENT:
+                case OPTION_GROUP:
+                case OPTION_STRING:
+                case OPTION_INTEGER:
+                case OPTION_LONG:
                 default:
                         break;
                 }
@@ -130,6 +136,9 @@ static int get_value(struct parse_opt_ctx_t *p,
                         return opterror(opt, "expects a numerical value", flags);
                 return 0;
 
+        case OPTION_END:
+        case OPTION_ARGUMENT:
+        case OPTION_GROUP:
         default:
                 die("should not happen, someone must be hit on the forehead");
         }
@@ -296,6 +305,8 @@ int parse_options_step(struct parse_opt_ctx_t *ctx,
                                 return parse_options_usage(usagestr, options);
                         case -2:
                                 goto unknown;
+                        default:
+                                break;
                         }
                         if (ctx->opt)
                                 check_typos(arg + 1, options);
@@ -314,6 +325,8 @@ int parse_options_step(struct parse_opt_ctx_t *ctx,
                                         ctx->argv[0] = strdup(ctx->opt - 1);
                                         *(char *)ctx->argv[0] = '-';
                                         goto unknown;
+                                default:
+                                        break;
                                 }
                         }
                         continue;
@@ -336,6 +349,8 @@ int parse_options_step(struct parse_opt_ctx_t *ctx,
                         return parse_options_usage(usagestr, options);
                 case -2:
                         goto unknown;
+                default:
+                        break;
                 }
                 continue;
 unknown:
@@ -456,6 +471,13 @@ int usage_with_options_internal(const char * const *usagestr,
                         }
                         break;
                 default: /* OPTION_{BIT,BOOLEAN,SET_INT,SET_PTR} */
+                case OPTION_END:
+                case OPTION_GROUP:
+                case OPTION_BIT:
+                case OPTION_BOOLEAN:
+                case OPTION_SET_INT:
+                case OPTION_SET_PTR:
+                case OPTION_LONG:
                         break;
                 }
 
diff --git a/tools/perf/util/path.c b/tools/perf/util/path.c
index a501a40dd2cb..fd1f2faaade4 100644
--- a/tools/perf/util/path.c
+++ b/tools/perf/util/path.c
@@ -17,7 +17,7 @@ static char bad_path[] = "/bad-path/";
  * Two hacks:
  */
 
-static char *get_perf_dir(void)
+static const char *get_perf_dir(void)
 {
         return ".";
 }
@@ -38,8 +38,9 @@ size_t strlcpy(char *dest, const char *src, size_t size)
 static char *get_pathname(void)
 {
         static char pathname_array[4][PATH_MAX];
-        static int index;
-        return pathname_array[3 & ++index];
+        static int idx;
+
+        return pathname_array[3 & ++idx];
 }
 
 static char *cleanup_path(char *path)
@@ -161,20 +162,24 @@ int perf_mkstemp(char *path, size_t len, const char *template)
 }
 
 
-const char *make_relative_path(const char *abs, const char *base)
+const char *make_relative_path(const char *abs_path, const char *base)
 {
         static char buf[PATH_MAX + 1];
         int baselen;
+
         if (!base)
-                return abs;
+                return abs_path;
+
         baselen = strlen(base);
-        if (prefixcmp(abs, base))
-                return abs;
-        if (abs[baselen] == '/')
+        if (prefixcmp(abs_path, base))
+                return abs_path;
+        if (abs_path[baselen] == '/')
                 baselen++;
         else if (base[baselen - 1] != '/')
-                return abs;
-        strcpy(buf, abs + baselen);
+                return abs_path;
+
+        strcpy(buf, abs_path + baselen);
+
         return buf;
 }
 
diff --git a/tools/perf/util/run-command.c b/tools/perf/util/run-command.c
index a3935343091a..2b615acf94d7 100644
--- a/tools/perf/util/run-command.c
+++ b/tools/perf/util/run-command.c
@@ -262,7 +262,7 @@ int run_hook(const char *index_file, const char *name, ...)
 {
         struct child_process hook;
         const char **argv = NULL, *env[2];
-        char index[PATH_MAX];
+        char idx[PATH_MAX];
         va_list args;
         int ret;
         size_t i = 0, alloc = 0;
@@ -284,8 +284,8 @@ int run_hook(const char *index_file, const char *name, ...)
         hook.no_stdin = 1;
         hook.stdout_to_stderr = 1;
         if (index_file) {
-                snprintf(index, sizeof(index), "PERF_INDEX_FILE=%s", index_file);
-                env[0] = index;
+                snprintf(idx, sizeof(idx), "PERF_INDEX_FILE=%s", index_file);
+                env[0] = idx;
                 env[1] = NULL;
                 hook.env = env;
         }
diff --git a/tools/perf/util/symbol.c b/tools/perf/util/symbol.c
index 5c0f42e6b33b..fd3d9c8e90fc 100644
--- a/tools/perf/util/symbol.c
+++ b/tools/perf/util/symbol.c
@@ -3,6 +3,8 @@
 #include "string.h"
 #include "symbol.h"
 
+#include "debug.h"
+
 #include <libelf.h>
 #include <gelf.h>
 #include <elf.h>
@@ -21,7 +23,7 @@ enum dso_origin {
 
 static struct symbol *symbol__new(u64 start, u64 len,
                                   const char *name, unsigned int priv_size,
-                                  u64 obj_start, int verbose)
+                                  u64 obj_start, int v)
 {
         size_t namelen = strlen(name) + 1;
         struct symbol *self = calloc(1, priv_size + sizeof(*self) + namelen);
@@ -29,7 +31,7 @@ static struct symbol *symbol__new(u64 start, u64 len,
         if (!self)
                 return NULL;
 
-        if (verbose >= 2)
+        if (v >= 2)
                 printf("new symbol: %016Lx [%08lx]: %s, hist: %p, obj_start: %p\n",
                         (u64)start, (unsigned long)len, name, self->hist, (void *)(unsigned long)obj_start);
 
@@ -156,7 +158,7 @@ size_t dso__fprintf(struct dso *self, FILE *fp)
         return ret;
 }
 
-static int dso__load_kallsyms(struct dso *self, symbol_filter_t filter, int verbose)
+static int dso__load_kallsyms(struct dso *self, symbol_filter_t filter, int v)
 {
         struct rb_node *nd, *prevnd;
         char *line = NULL;
@@ -198,7 +200,7 @@ static int dso__load_kallsyms(struct dso *self, symbol_filter_t filter, int verb
                  * Well fix up the end later, when we have all sorted.
                  */
                 sym = symbol__new(start, 0xdead, line + len + 2,
-                                  self->sym_priv_size, 0, verbose);
+                                  self->sym_priv_size, 0, v);
 
                 if (sym == NULL)
                         goto out_delete_line;
@@ -239,7 +241,7 @@ out_failure:
         return -1;
 }
 
-static int dso__load_perf_map(struct dso *self, symbol_filter_t filter, int verbose)
+static int dso__load_perf_map(struct dso *self, symbol_filter_t filter, int v)
 {
         char *line = NULL;
         size_t n;
@@ -277,7 +279,7 @@ static int dso__load_perf_map(struct dso *self, symbol_filter_t filter, int verb
                         continue;
 
                 sym = symbol__new(start, size, line + len,
-                                  self->sym_priv_size, start, verbose);
+                                  self->sym_priv_size, start, v);
 
                 if (sym == NULL)
                         goto out_delete_line;
@@ -305,13 +307,13 @@ out_failure:
  * elf_symtab__for_each_symbol - iterate thru all the symbols
  *
  * @self: struct elf_symtab instance to iterate
- * @index: uint32_t index
+ * @idx: uint32_t idx
  * @sym: GElf_Sym iterator
  */
-#define elf_symtab__for_each_symbol(syms, nr_syms, index, sym) \
-        for (index = 0, gelf_getsym(syms, index, &sym);\
-             index < nr_syms; \
-             index++, gelf_getsym(syms, index, &sym))
+#define elf_symtab__for_each_symbol(syms, nr_syms, idx, sym) \
+        for (idx = 0, gelf_getsym(syms, idx, &sym);\
+             idx < nr_syms; \
+             idx++, gelf_getsym(syms, idx, &sym))
 
 static inline uint8_t elf_sym__type(const GElf_Sym *sym)
 {
@@ -354,7 +356,7 @@ static inline const char *elf_sym__name(const GElf_Sym *sym,
 
 static Elf_Scn *elf_section_by_name(Elf *elf, GElf_Ehdr *ep,
                                     GElf_Shdr *shp, const char *name,
-                                    size_t *index)
+                                    size_t *idx)
 {
         Elf_Scn *sec = NULL;
         size_t cnt = 1;
@@ -365,8 +367,8 @@ static Elf_Scn *elf_section_by_name(Elf *elf, GElf_Ehdr *ep,
                 gelf_getshdr(sec, shp);
                 str = elf_strptr(elf, ep->e_shstrndx, shp->sh_name);
                 if (!strcmp(name, str)) {
-                        if (index)
-                                *index = cnt;
+                        if (idx)
+                                *idx = cnt;
                         break;
                 }
                 ++cnt;
@@ -392,7 +394,7 @@ static Elf_Scn *elf_section_by_name(Elf *elf, GElf_Ehdr *ep,
  * And always look at the original dso, not at debuginfo packages, that
  * have the PLT data stripped out (shdr_rel_plt.sh_type == SHT_NOBITS).
  */
-static int dso__synthesize_plt_symbols(struct  dso *self, int verbose)
+static int dso__synthesize_plt_symbols(struct  dso *self, int v)
 {
         uint32_t nr_rel_entries, idx;
         GElf_Sym sym;
@@ -442,7 +444,7 @@ static int dso__synthesize_plt_symbols(struct  dso *self, int verbose)
                 goto out_elf_end;
 
         /*
-         * Fetch the relocation section to find the indexes to the GOT
+         * Fetch the relocation section to find the idxes to the GOT
          * and the symbols in the .dynsym they refer to.
          */
         reldata = elf_getdata(scn_plt_rel, NULL);
@@ -476,7 +478,7 @@ static int dso__synthesize_plt_symbols(struct  dso *self, int verbose)
                                  "%s@plt", elf_sym__name(&sym, symstrs));
 
                         f = symbol__new(plt_offset, shdr_plt.sh_entsize,
-                                        sympltname, self->sym_priv_size, 0, verbose);
+                                        sympltname, self->sym_priv_size, 0, v);
                         if (!f)
                                 goto out_elf_end;
 
@@ -494,7 +496,7 @@ static int dso__synthesize_plt_symbols(struct  dso *self, int verbose)
                                  "%s@plt", elf_sym__name(&sym, symstrs));
 
                         f = symbol__new(plt_offset, shdr_plt.sh_entsize,
-                                        sympltname, self->sym_priv_size, 0, verbose);
+                                        sympltname, self->sym_priv_size, 0, v);
                         if (!f)
                                 goto out_elf_end;
 
@@ -518,12 +520,12 @@ out:
 }
 
 static int dso__load_sym(struct dso *self, int fd, const char *name,
-                         symbol_filter_t filter, int verbose, struct module *mod)
+                         symbol_filter_t filter, int v, struct module *mod)
 {
         Elf_Data *symstrs, *secstrs;
         uint32_t nr_syms;
         int err = -1;
-        uint32_t index;
+        uint32_t idx;
         GElf_Ehdr ehdr;
         GElf_Shdr shdr;
         Elf_Data *syms;
@@ -534,14 +536,14 @@ static int dso__load_sym(struct dso *self, int fd, const char *name,
 
         elf = elf_begin(fd, ELF_C_READ_MMAP, NULL);
         if (elf == NULL) {
-                if (verbose)
+                if (v)
                         fprintf(stderr, "%s: cannot read %s ELF file.\n",
                                 __func__, name);
                 goto out_close;
         }
 
         if (gelf_getehdr(elf, &ehdr) == NULL) {
-                if (verbose)
+                if (v)
                         fprintf(stderr, "%s: cannot get elf header.\n", __func__);
                 goto out_elf_end;
         }
@@ -583,9 +585,9 @@ static int dso__load_sym(struct dso *self, int fd, const char *name,
                                                      NULL) != NULL);
         } else self->adjust_symbols = 0;
 
-        elf_symtab__for_each_symbol(syms, nr_syms, index, sym) {
+        elf_symtab__for_each_symbol(syms, nr_syms, idx, sym) {
                 struct symbol *f;
-                const char *name;
+                const char *elf_name;
                 char *demangled;
                 u64 obj_start;
                 struct section *section = NULL;
@@ -608,7 +610,7 @@ static int dso__load_sym(struct dso *self, int fd, const char *name,
                 obj_start = sym.st_value;
 
                 if (self->adjust_symbols) {
-                        if (verbose >= 2)
+                        if (v >= 2)
                                 printf("adjusting symbol: st_value: %Lx sh_addr: %Lx sh_offset: %Lx\n",
                                         (u64)sym.st_value, (u64)shdr.sh_addr, (u64)shdr.sh_offset);
 
@@ -630,13 +632,13 @@ static int dso__load_sym(struct dso *self, int fd, const char *name,
                  * DWARF DW_compile_unit has this, but we don't always have access
                  * to it...
                  */
-                name = elf_sym__name(&sym, symstrs);
-                demangled = bfd_demangle(NULL, name, DMGL_PARAMS | DMGL_ANSI);
+                elf_name = elf_sym__name(&sym, symstrs);
+                demangled = bfd_demangle(NULL, elf_name, DMGL_PARAMS | DMGL_ANSI);
                 if (demangled != NULL)
-                        name = demangled;
+                        elf_name = demangled;
 
-                f = symbol__new(sym.st_value, sym.st_size, name,
-                                self->sym_priv_size, obj_start, verbose);
+                f = symbol__new(sym.st_value, sym.st_size, elf_name,
+                                self->sym_priv_size, obj_start, v);
                 free(demangled);
                 if (!f)
                         goto out_elf_end;
@@ -659,7 +661,7 @@ out_close:
 
 #define BUILD_ID_SIZE 128
 
-static char *dso__read_build_id(struct dso *self, int verbose)
+static char *dso__read_build_id(struct dso *self, int v)
 {
         int i;
         GElf_Ehdr ehdr;
@@ -676,14 +678,14 @@ static char *dso__read_build_id(struct dso *self, int verbose)
 
         elf = elf_begin(fd, ELF_C_READ_MMAP, NULL);
         if (elf == NULL) {
-                if (verbose)
+                if (v)
                         fprintf(stderr, "%s: cannot read %s ELF file.\n",
                                 __func__, self->name);
                 goto out_close;
         }
 
         if (gelf_getehdr(elf, &ehdr) == NULL) {
-                if (verbose)
+                if (v)
                         fprintf(stderr, "%s: cannot get elf header.\n", __func__);
                 goto out_elf_end;
         }
@@ -706,7 +708,7 @@ static char *dso__read_build_id(struct dso *self, int verbose)
                 ++raw;
                 bid += 2;
         }
-        if (verbose >= 2)
+        if (v >= 2)
                 printf("%s(%s): %s\n", __func__, self->name, build_id);
 out_elf_end:
         elf_end(elf);
@@ -732,7 +734,7 @@ char dso__symtab_origin(const struct dso *self)
         return origin[self->origin];
 }
 
-int dso__load(struct dso *self, symbol_filter_t filter, int verbose)
+int dso__load(struct dso *self, symbol_filter_t filter, int v)
 {
         int size = PATH_MAX;
         char *name = malloc(size), *build_id = NULL;
@@ -745,7 +747,7 @@ int dso__load(struct dso *self, symbol_filter_t filter, int verbose)
         self->adjust_symbols = 0;
 
         if (strncmp(self->name, "/tmp/perf-", 10) == 0) {
-                ret = dso__load_perf_map(self, filter, verbose);
+                ret = dso__load_perf_map(self, filter, v);
                 self->origin = ret > 0 ? DSO__ORIG_JAVA_JIT :
                                          DSO__ORIG_NOT_FOUND;
                 return ret;
@@ -764,7 +766,7 @@ more:
                         snprintf(name, size, "/usr/lib/debug%s", self->name);
                         break;
                 case DSO__ORIG_BUILDID:
-                        build_id = dso__read_build_id(self, verbose);
+                        build_id = dso__read_build_id(self, v);
                         if (build_id != NULL) {
                                 snprintf(name, size,
                                          "/usr/lib/debug/.build-id/%.2s/%s.debug",
@@ -785,7 +787,7 @@ more:
                 fd = open(name, O_RDONLY);
         } while (fd < 0);
 
-        ret = dso__load_sym(self, fd, name, filter, verbose, NULL);
+        ret = dso__load_sym(self, fd, name, filter, v, NULL);
         close(fd);
 
         /*
@@ -795,7 +797,7 @@ more:
                 goto more;
 
         if (ret > 0) {
-                int nr_plt = dso__synthesize_plt_symbols(self, verbose);
+                int nr_plt = dso__synthesize_plt_symbols(self, v);
                 if (nr_plt > 0)
                         ret += nr_plt;
         }
@@ -807,7 +809,7 @@ out:
 }
 
 static int dso__load_module(struct dso *self, struct mod_dso *mods, const char *name,
-                             symbol_filter_t filter, int verbose)
+                             symbol_filter_t filter, int v)
 {
         struct module *mod = mod_dso__find_module(mods, name);
         int err = 0, fd;
@@ -820,13 +822,13 @@ static int dso__load_module(struct dso *self, struct mod_dso *mods, const char *
         if (fd < 0)
                 return err;
 
-        err = dso__load_sym(self, fd, name, filter, verbose, mod);
+        err = dso__load_sym(self, fd, name, filter, v, mod);
         close(fd);
 
         return err;
 }
 
-int dso__load_modules(struct dso *self, symbol_filter_t filter, int verbose)
+int dso__load_modules(struct dso *self, symbol_filter_t filter, int v)
 {
         struct mod_dso *mods = mod_dso__new_dso("modules");
         struct module *pos;
@@ -844,7 +846,7 @@ int dso__load_modules(struct dso *self, symbol_filter_t filter, int verbose)
         next = rb_first(&mods->mods);
         while (next) {
                 pos = rb_entry(next, struct module, rb_node);
-                err = dso__load_module(self, mods, pos->name, filter, verbose);
+                err = dso__load_module(self, mods, pos->name, filter, v);
 
                 if (err < 0)
                         break;
@@ -887,14 +889,14 @@ static inline void dso__fill_symbol_holes(struct dso *self)
 }
 
 static int dso__load_vmlinux(struct dso *self, const char *vmlinux,
-                             symbol_filter_t filter, int verbose)
+                             symbol_filter_t filter, int v)
 {
         int err, fd = open(vmlinux, O_RDONLY);
 
         if (fd < 0)
                 return -1;
 
-        err = dso__load_sym(self, fd, vmlinux, filter, verbose, NULL);
+        err = dso__load_sym(self, fd, vmlinux, filter, v, NULL);
 
         if (err > 0)
                 dso__fill_symbol_holes(self);
@@ -905,18 +907,18 @@ static int dso__load_vmlinux(struct dso *self, const char *vmlinux,
 }
 
 int dso__load_kernel(struct dso *self, const char *vmlinux,
-                     symbol_filter_t filter, int verbose, int modules)
+                     symbol_filter_t filter, int v, int use_modules)
 {
         int err = -1;
 
         if (vmlinux) {
-                err = dso__load_vmlinux(self, vmlinux, filter, verbose);
-                if (err > 0 && modules)
-                        err = dso__load_modules(self, filter, verbose);
+                err = dso__load_vmlinux(self, vmlinux, filter, v);
+                if (err > 0 && use_modules)
+                        err = dso__load_modules(self, filter, v);
         }
 
         if (err <= 0)
-                err = dso__load_kallsyms(self, filter, verbose);
+                err = dso__load_kallsyms(self, filter, v);
 
         if (err > 0)
                 self->origin = DSO__ORIG_KERNEL;
@@ -924,6 +926,103 @@ int dso__load_kernel(struct dso *self, const char *vmlinux,
         return err;
 }
 
+LIST_HEAD(dsos);
+struct dso      *kernel_dso;
+struct dso      *vdso;
+struct dso      *hypervisor_dso;
+
+const char      *vmlinux_name = "vmlinux";
+int             modules;
+
+static void dsos__add(struct dso *dso)
+{
+        list_add_tail(&dso->node, &dsos);
+}
+
+static struct dso *dsos__find(const char *name)
+{
+        struct dso *pos;
+
+        list_for_each_entry(pos, &dsos, node)
+                if (strcmp(pos->name, name) == 0)
+                        return pos;
+        return NULL;
+}
+
+struct dso *dsos__findnew(const char *name)
+{
+        struct dso *dso = dsos__find(name);
+        int nr;
+
+        if (dso)
+                return dso;
+
+        dso = dso__new(name, 0);
+        if (!dso)
+                goto out_delete_dso;
+
+        nr = dso__load(dso, NULL, verbose);
+        if (nr < 0) {
+                eprintf("Failed to open: %s\n", name);
+                goto out_delete_dso;
+        }
+        if (!nr)
+                eprintf("No symbols found in: %s, maybe install a debug package?\n", name);
+
+        dsos__add(dso);
+
+        return dso;
+
+out_delete_dso:
+        dso__delete(dso);
+        return NULL;
+}
+
+void dsos__fprintf(FILE *fp)
+{
+        struct dso *pos;
+
+        list_for_each_entry(pos, &dsos, node)
+                dso__fprintf(pos, fp);
+}
+
+static struct symbol *vdso__find_symbol(struct dso *dso, u64 ip)
+{
+        return dso__find_symbol(dso, ip);
+}
+
+int load_kernel(void)
+{
+        int err;
+
+        kernel_dso = dso__new("[kernel]", 0);
+        if (!kernel_dso)
+                return -1;
+
+        err = dso__load_kernel(kernel_dso, vmlinux_name, NULL, verbose, modules);
+        if (err <= 0) {
+                dso__delete(kernel_dso);
+                kernel_dso = NULL;
+        } else
+                dsos__add(kernel_dso);
+
+        vdso = dso__new("[vdso]", 0);
+        if (!vdso)
+                return -1;
+
+        vdso->find_symbol = vdso__find_symbol;
+
+        dsos__add(vdso);
+
+        hypervisor_dso = dso__new("[hypervisor]", 0);
+        if (!hypervisor_dso)
+                return -1;
+        dsos__add(hypervisor_dso);
+
+        return err;
+}
+
+
 void symbol__init(void)
 {
         elf_version(EV_CURRENT);
diff --git a/tools/perf/util/symbol.h b/tools/perf/util/symbol.h
index b53bf0125c1b..6e8490716408 100644
--- a/tools/perf/util/symbol.h
+++ b/tools/perf/util/symbol.h
@@ -6,6 +6,7 @@
 #include <linux/list.h>
 #include <linux/rbtree.h>
 #include "module.h"
+#include "event.h"
 
 #ifdef HAVE_CPLUS_DEMANGLE
 extern char *cplus_demangle(const char *, int);
@@ -54,7 +55,7 @@ struct dso {
         char             name[0];
 };
 
-const char *sym_hist_filter;
+extern const char *sym_hist_filter;
 
 typedef int (*symbol_filter_t)(struct dso *self, struct symbol *sym);
 
@@ -72,9 +73,20 @@ int dso__load_kernel(struct dso *self, const char *vmlinux,
                      symbol_filter_t filter, int verbose, int modules);
 int dso__load_modules(struct dso *self, symbol_filter_t filter, int verbose);
 int dso__load(struct dso *self, symbol_filter_t filter, int verbose);
+struct dso *dsos__findnew(const char *name);
+void dsos__fprintf(FILE *fp);
 
 size_t dso__fprintf(struct dso *self, FILE *fp);
 char dso__symtab_origin(const struct dso *self);
 
+int load_kernel(void);
+
 void symbol__init(void);
+
+extern struct list_head dsos;
+extern struct dso *kernel_dso;
+extern struct dso *vdso;
+extern struct dso *hypervisor_dso;
+extern const char *vmlinux_name;
+extern int   modules;
 #endif /* _PERF_SYMBOL_ */
diff --git a/tools/perf/util/thread.c b/tools/perf/util/thread.c
new file mode 100644
index 000000000000..7635928ca278
--- /dev/null
+++ b/tools/perf/util/thread.c
@@ -0,0 +1,175 @@
+#include "../perf.h"
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include "thread.h"
+#include "util.h"
+#include "debug.h"
+
+static struct thread *thread__new(pid_t pid)
+{
+        struct thread *self = malloc(sizeof(*self));
+
+        if (self != NULL) {
+                self->pid = pid;
+                self->comm = malloc(32);
+                if (self->comm)
+                        snprintf(self->comm, 32, ":%d", self->pid);
+                INIT_LIST_HEAD(&self->maps);
+        }
+
+        return self;
+}
+
+int thread__set_comm(struct thread *self, const char *comm)
+{
+        if (self->comm)
+                free(self->comm);
+        self->comm = strdup(comm);
+        return self->comm ? 0 : -ENOMEM;
+}
+
+static size_t thread__fprintf(struct thread *self, FILE *fp)
+{
+        struct map *pos;
+        size_t ret = fprintf(fp, "Thread %d %s\n", self->pid, self->comm);
+
+        list_for_each_entry(pos, &self->maps, node)
+                ret += map__fprintf(pos, fp);
+
+        return ret;
+}
+
+struct thread *
+threads__findnew(pid_t pid, struct rb_root *threads, struct thread **last_match)
+{
+        struct rb_node **p = &threads->rb_node;
+        struct rb_node *parent = NULL;
+        struct thread *th;
+
+        /*
+         * Font-end cache - PID lookups come in blocks,
+         * so most of the time we dont have to look up
+         * the full rbtree:
+         */
+        if (*last_match && (*last_match)->pid == pid)
+                return *last_match;
+
+        while (*p != NULL) {
+                parent = *p;
+                th = rb_entry(parent, struct thread, rb_node);
+
+                if (th->pid == pid) {
+                        *last_match = th;
+                        return th;
+                }
+
+                if (pid < th->pid)
+                        p = &(*p)->rb_left;
+                else
+                        p = &(*p)->rb_right;
+        }
+
+        th = thread__new(pid);
+        if (th != NULL) {
+                rb_link_node(&th->rb_node, parent, p);
+                rb_insert_color(&th->rb_node, threads);
+                *last_match = th;
+        }
+
+        return th;
+}
+
+struct thread *
+register_idle_thread(struct rb_root *threads, struct thread **last_match)
+{
+        struct thread *thread = threads__findnew(0, threads, last_match);
+
+        if (!thread || thread__set_comm(thread, "[init]")) {
+                fprintf(stderr, "problem inserting idle task.\n");
+                exit(-1);
+        }
+
+        return thread;
+}
+
+void thread__insert_map(struct thread *self, struct map *map)
+{
+        struct map *pos, *tmp;
+
+        list_for_each_entry_safe(pos, tmp, &self->maps, node) {
+                if (map__overlap(pos, map)) {
+                        if (verbose >= 2) {
+                                printf("overlapping maps:\n");
+                                map__fprintf(map, stdout);
+                                map__fprintf(pos, stdout);
+                        }
+
+                        if (map->start <= pos->start && map->end > pos->start)
+                                pos->start = map->end;
+
+                        if (map->end >= pos->end && map->start < pos->end)
+                                pos->end = map->start;
+
+                        if (verbose >= 2) {
+                                printf("after collision:\n");
+                                map__fprintf(pos, stdout);
+                        }
+
+                        if (pos->start >= pos->end) {
+                                list_del_init(&pos->node);
+                                free(pos);
+                        }
+                }
+        }
+
+        list_add_tail(&map->node, &self->maps);
+}
+
+int thread__fork(struct thread *self, struct thread *parent)
+{
+        struct map *map;
+
+        if (self->comm)
+                free(self->comm);
+        self->comm = strdup(parent->comm);
+        if (!self->comm)
+                return -ENOMEM;
+
+        list_for_each_entry(map, &parent->maps, node) {
+                struct map *new = map__clone(map);
+                if (!new)
+                        return -ENOMEM;
+                thread__insert_map(self, new);
+        }
+
+        return 0;
+}
+
+struct map *thread__find_map(struct thread *self, u64 ip)
+{
+        struct map *pos;
+
+        if (self == NULL)
+                return NULL;
+
+        list_for_each_entry(pos, &self->maps, node)
+                if (ip >= pos->start && ip <= pos->end)
+                        return pos;
+
+        return NULL;
+}
+
+size_t threads__fprintf(FILE *fp, struct rb_root *threads)
+{
+        size_t ret = 0;
+        struct rb_node *nd;
+
+        for (nd = rb_first(threads); nd; nd = rb_next(nd)) {
+                struct thread *pos = rb_entry(nd, struct thread, rb_node);
+
+                ret += thread__fprintf(pos, fp);
+        }
+
+        return ret;
+}
diff --git a/tools/perf/util/thread.h b/tools/perf/util/thread.h
new file mode 100644
index 000000000000..634f2809a342
--- /dev/null
+++ b/tools/perf/util/thread.h
@@ -0,0 +1,21 @@
+#include <linux/rbtree.h>
+#include <linux/list.h>
+#include <unistd.h>
+#include "symbol.h"
+
+struct thread {
+        struct rb_node   rb_node;
+        struct list_head maps;
+        pid_t            pid;
+        char             *comm;
+};
+
+int thread__set_comm(struct thread *self, const char *comm);
+struct thread *
+threads__findnew(pid_t pid, struct rb_root *threads, struct thread **last_match);
+struct thread *
+register_idle_thread(struct rb_root *threads, struct thread **last_match);
+void thread__insert_map(struct thread *self, struct map *map);
+int thread__fork(struct thread *self, struct thread *parent);
+struct map *thread__find_map(struct thread *self, u64 ip);
+size_t threads__fprintf(FILE *fp, struct rb_root *threads);
diff --git a/tools/perf/util/trace-event-info.c b/tools/perf/util/trace-event-info.c
new file mode 100644
index 000000000000..6c9302a7274c
--- /dev/null
+++ b/tools/perf/util/trace-event-info.c
@@ -0,0 +1,539 @@
+/*
+ * Copyright (C) 2008,2009, Steven Rostedt <srostedt@redhat.com>
+ *
+ * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; version 2 of the License (not later!)
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ *
+ * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+ */
+#define _GNU_SOURCE
+#include <dirent.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <stdarg.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <sys/wait.h>
+#include <pthread.h>
+#include <fcntl.h>
+#include <unistd.h>
+#include <ctype.h>
+#include <errno.h>
+#include <stdbool.h>
+
+#include "../perf.h"
+#include "trace-event.h"
+
+
+#define VERSION "0.5"
+
+#define _STR(x) #x
+#define STR(x) _STR(x)
+#define MAX_PATH 256
+
+#define TRACE_CTRL      "tracing_on"
+#define TRACE           "trace"
+#define AVAILABLE       "available_tracers"
+#define CURRENT         "current_tracer"
+#define ITER_CTRL       "trace_options"
+#define MAX_LATENCY     "tracing_max_latency"
+
+unsigned int page_size;
+
+static const char *output_file = "trace.info";
+static int output_fd;
+
+struct event_list {
+        struct event_list *next;
+        const char *event;
+};
+
+struct events {
+        struct events *sibling;
+        struct events *children;
+        struct events *next;
+        char *name;
+};
+
+
+
+static void die(const char *fmt, ...)
+{
+        va_list ap;
+        int ret = errno;
+
+        if (errno)
+                perror("trace-cmd");
+        else
+                ret = -1;
+
+        va_start(ap, fmt);
+        fprintf(stderr, "  ");
+        vfprintf(stderr, fmt, ap);
+        va_end(ap);
+
+        fprintf(stderr, "\n");
+        exit(ret);
+}
+
+void *malloc_or_die(unsigned int size)
+{
+        void *data;
+
+        data = malloc(size);
+        if (!data)
+                die("malloc");
+        return data;
+}
+
+static const char *find_debugfs(void)
+{
+        static char debugfs[MAX_PATH+1];
+        static int debugfs_found;
+        char type[100];
+        FILE *fp;
+
+        if (debugfs_found)
+                return debugfs;
+
+        if ((fp = fopen("/proc/mounts","r")) == NULL)
+                die("Can't open /proc/mounts for read");
+
+        while (fscanf(fp, "%*s %"
+                      STR(MAX_PATH)
+                      "s %99s %*s %*d %*d\n",
+                      debugfs, type) == 2) {
+                if (strcmp(type, "debugfs") == 0)
+                        break;
+        }
+        fclose(fp);
+
+        if (strcmp(type, "debugfs") != 0)
+                die("debugfs not mounted, please mount");
+
+        debugfs_found = 1;
+
+        return debugfs;
+}
+
+/*
+ * Finds the path to the debugfs/tracing
+ * Allocates the string and stores it.
+ */
+static const char *find_tracing_dir(void)
+{
+        static char *tracing;
+        static int tracing_found;
+        const char *debugfs;
+
+        if (tracing_found)
+                return tracing;
+
+        debugfs = find_debugfs();
+
+        tracing = malloc_or_die(strlen(debugfs) + 9);
+
+        sprintf(tracing, "%s/tracing", debugfs);
+
+        tracing_found = 1;
+        return tracing;
+}
+
+static char *get_tracing_file(const char *name)
+{
+        const char *tracing;
+        char *file;
+
+        tracing = find_tracing_dir();
+        if (!tracing)
+                return NULL;
+
+        file = malloc_or_die(strlen(tracing) + strlen(name) + 2);
+
+        sprintf(file, "%s/%s", tracing, name);
+        return file;
+}
+
+static void put_tracing_file(char *file)
+{
+        free(file);
+}
+
+static ssize_t write_or_die(const void *buf, size_t len)
+{
+        int ret;
+
+        ret = write(output_fd, buf, len);
+        if (ret < 0)
+                die("writing to '%s'", output_file);
+
+        return ret;
+}
+
+int bigendian(void)
+{
+        unsigned char str[] = { 0x1, 0x2, 0x3, 0x4, 0x0, 0x0, 0x0, 0x0};
+        unsigned int *ptr;
+
+        ptr = (unsigned int *)(void *)str;
+        return *ptr == 0x01020304;
+}
+
+static unsigned long long copy_file_fd(int fd)
+{
+        unsigned long long size = 0;
+        char buf[BUFSIZ];
+        int r;
+
+        do {
+                r = read(fd, buf, BUFSIZ);
+                if (r > 0) {
+                        size += r;
+                        write_or_die(buf, r);
+                }
+        } while (r > 0);
+
+        return size;
+}
+
+static unsigned long long copy_file(const char *file)
+{
+        unsigned long long size = 0;
+        int fd;
+
+        fd = open(file, O_RDONLY);
+        if (fd < 0)
+                die("Can't read '%s'", file);
+        size = copy_file_fd(fd);
+        close(fd);
+
+        return size;
+}
+
+static unsigned long get_size_fd(int fd)
+{
+        unsigned long long size = 0;
+        char buf[BUFSIZ];
+        int r;
+
+        do {
+                r = read(fd, buf, BUFSIZ);
+                if (r > 0)
+                        size += r;
+        } while (r > 0);
+
+        lseek(fd, 0, SEEK_SET);
+
+        return size;
+}
+
+static unsigned long get_size(const char *file)
+{
+        unsigned long long size = 0;
+        int fd;
+
+        fd = open(file, O_RDONLY);
+        if (fd < 0)
+                die("Can't read '%s'", file);
+        size = get_size_fd(fd);
+        close(fd);
+
+        return size;
+}
+
+static void read_header_files(void)
+{
+        unsigned long long size, check_size;
+        char *path;
+        int fd;
+
+        path = get_tracing_file("events/header_page");
+        fd = open(path, O_RDONLY);
+        if (fd < 0)
+                die("can't read '%s'", path);
+
+        /* unfortunately, you can not stat debugfs files for size */
+        size = get_size_fd(fd);
+
+        write_or_die("header_page", 12);
+        write_or_die(&size, 8);
+        check_size = copy_file_fd(fd);
+        if (size != check_size)
+                die("wrong size for '%s' size=%lld read=%lld",
+                    path, size, check_size);
+        put_tracing_file(path);
+
+        path = get_tracing_file("events/header_event");
+        fd = open(path, O_RDONLY);
+        if (fd < 0)
+                die("can't read '%s'", path);
+
+        size = get_size_fd(fd);
+
+        write_or_die("header_event", 13);
+        write_or_die(&size, 8);
+        check_size = copy_file_fd(fd);
+        if (size != check_size)
+                die("wrong size for '%s'", path);
+        put_tracing_file(path);
+}
+
+static bool name_in_tp_list(char *sys, struct tracepoint_path *tps)
+{
+        while (tps) {
+                if (!strcmp(sys, tps->name))
+                        return true;
+                tps = tps->next;
+        }
+
+        return false;
+}
+
+static void copy_event_system(const char *sys, struct tracepoint_path *tps)
+{
+        unsigned long long size, check_size;
+        struct dirent *dent;
+        struct stat st;
+        char *format;
+        DIR *dir;
+        int count = 0;
+        int ret;
+
+        dir = opendir(sys);
+        if (!dir)
+                die("can't read directory '%s'", sys);
+
+        while ((dent = readdir(dir))) {
+                if (strcmp(dent->d_name, ".") == 0 ||
+                    strcmp(dent->d_name, "..") == 0 ||
+                    !name_in_tp_list(dent->d_name, tps))
+                        continue;
+                format = malloc_or_die(strlen(sys) + strlen(dent->d_name) + 10);
+                sprintf(format, "%s/%s/format", sys, dent->d_name);
+                ret = stat(format, &st);
+                free(format);
+                if (ret < 0)
+                        continue;
+                count++;
+        }
+
+        write_or_die(&count, 4);
+
+        rewinddir(dir);
+        while ((dent = readdir(dir))) {
+                if (strcmp(dent->d_name, ".") == 0 ||
+                    strcmp(dent->d_name, "..") == 0 ||
+                    !name_in_tp_list(dent->d_name, tps))
+                        continue;
+                format = malloc_or_die(strlen(sys) + strlen(dent->d_name) + 10);
+                sprintf(format, "%s/%s/format", sys, dent->d_name);
+                ret = stat(format, &st);
+
+                if (ret >= 0) {
+                        /* unfortunately, you can not stat debugfs files for size */
+                        size = get_size(format);
+                        write_or_die(&size, 8);
+                        check_size = copy_file(format);
+                        if (size != check_size)
+                                die("error in size of file '%s'", format);
+                }
+
+                free(format);
+        }
+}
+
+static void read_ftrace_files(struct tracepoint_path *tps)
+{
+        char *path;
+
+        path = get_tracing_file("events/ftrace");
+
+        copy_event_system(path, tps);
+
+        put_tracing_file(path);
+}
+
+static bool system_in_tp_list(char *sys, struct tracepoint_path *tps)
+{
+        while (tps) {
+                if (!strcmp(sys, tps->system))
+                        return true;
+                tps = tps->next;
+        }
+
+        return false;
+}
+
+static void read_event_files(struct tracepoint_path *tps)
+{
+        struct dirent *dent;
+        struct stat st;
+        char *path;
+        char *sys;
+        DIR *dir;
+        int count = 0;
+        int ret;
+
+        path = get_tracing_file("events");
+
+        dir = opendir(path);
+        if (!dir)
+                die("can't read directory '%s'", path);
+
+        while ((dent = readdir(dir))) {
+                if (strcmp(dent->d_name, ".") == 0 ||
+                    strcmp(dent->d_name, "..") == 0 ||
+                    strcmp(dent->d_name, "ftrace") == 0 ||
+                    !system_in_tp_list(dent->d_name, tps))
+                        continue;
+                sys = malloc_or_die(strlen(path) + strlen(dent->d_name) + 2);
+                sprintf(sys, "%s/%s", path, dent->d_name);
+                ret = stat(sys, &st);
+                free(sys);
+                if (ret < 0)
+                        continue;
+                if (S_ISDIR(st.st_mode))
+                        count++;
+        }
+
+        write_or_die(&count, 4);
+
+        rewinddir(dir);
+        while ((dent = readdir(dir))) {
+                if (strcmp(dent->d_name, ".") == 0 ||
+                    strcmp(dent->d_name, "..") == 0 ||
+                    strcmp(dent->d_name, "ftrace") == 0 ||
+                    !system_in_tp_list(dent->d_name, tps))
+                        continue;
+                sys = malloc_or_die(strlen(path) + strlen(dent->d_name) + 2);
+                sprintf(sys, "%s/%s", path, dent->d_name);
+                ret = stat(sys, &st);
+                if (ret >= 0) {
+                        if (S_ISDIR(st.st_mode)) {
+                                write_or_die(dent->d_name, strlen(dent->d_name) + 1);
+                                copy_event_system(sys, tps);
+                        }
+                }
+                free(sys);
+        }
+
+        put_tracing_file(path);
+}
+
+static void read_proc_kallsyms(void)
+{
+        unsigned int size, check_size;
+        const char *path = "/proc/kallsyms";
+        struct stat st;
+        int ret;
+
+        ret = stat(path, &st);
+        if (ret < 0) {
+                /* not found */
+                size = 0;
+                write_or_die(&size, 4);
+                return;
+        }
+        size = get_size(path);
+        write_or_die(&size, 4);
+        check_size = copy_file(path);
+        if (size != check_size)
+                die("error in size of file '%s'", path);
+
+}
+
+static void read_ftrace_printk(void)
+{
+        unsigned int size, check_size;
+        const char *path;
+        struct stat st;
+        int ret;
+
+        path = get_tracing_file("printk_formats");
+        ret = stat(path, &st);
+        if (ret < 0) {
+                /* not found */
+                size = 0;
+                write_or_die(&size, 4);
+                return;
+        }
+        size = get_size(path);
+        write_or_die(&size, 4);
+        check_size = copy_file(path);
+        if (size != check_size)
+                die("error in size of file '%s'", path);
+
+}
+
+static struct tracepoint_path *
+get_tracepoints_path(struct perf_counter_attr *pattrs, int nb_counters)
+{
+        struct tracepoint_path path, *ppath = &path;
+        int i;
+
+        for (i = 0; i < nb_counters; i++) {
+                if (pattrs[i].type != PERF_TYPE_TRACEPOINT)
+                        continue;
+                ppath->next = tracepoint_id_to_path(pattrs[i].config);
+                if (!ppath->next)
+                        die("%s\n", "No memory to alloc tracepoints list");
+                ppath = ppath->next;
+        }
+
+        return path.next;
+}
+void read_tracing_data(struct perf_counter_attr *pattrs, int nb_counters)
+{
+        char buf[BUFSIZ];
+        struct tracepoint_path *tps;
+
+        output_fd = open(output_file, O_WRONLY | O_CREAT | O_TRUNC | O_LARGEFILE, 0644);
+        if (output_fd < 0)
+                die("creating file '%s'", output_file);
+
+        buf[0] = 23;
+        buf[1] = 8;
+        buf[2] = 68;
+        memcpy(buf + 3, "tracing", 7);
+
+        write_or_die(buf, 10);
+
+        write_or_die(VERSION, strlen(VERSION) + 1);
+
+        /* save endian */
+        if (bigendian())
+                buf[0] = 1;
+        else
+                buf[0] = 0;
+
+        write_or_die(buf, 1);
+
+        /* save size of long */
+        buf[0] = sizeof(long);
+        write_or_die(buf, 1);
+
+        /* save page_size */
+        page_size = getpagesize();
+        write_or_die(&page_size, 4);
+
+        tps = get_tracepoints_path(pattrs, nb_counters);
+
+        read_header_files();
+        read_ftrace_files(tps);
+        read_event_files(tps);
+        read_proc_kallsyms();
+        read_ftrace_printk();
+}
diff --git a/tools/perf/util/trace-event-parse.c b/tools/perf/util/trace-event-parse.c
new file mode 100644
index 000000000000..629e602d9405
--- /dev/null
+++ b/tools/perf/util/trace-event-parse.c
@@ -0,0 +1,2942 @@
+/*
+ * Copyright (C) 2009, Steven Rostedt <srostedt@redhat.com>
+ *
+ * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; version 2 of the License (not later!)
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ *
+ * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+ *
+ *  The parts for function graph printing was taken and modified from the
+ *  Linux Kernel that were written by Frederic Weisbecker.
+ */
+#define _GNU_SOURCE
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <ctype.h>
+#include <errno.h>
+
+#undef _GNU_SOURCE
+#include "../perf.h"
+#include "util.h"
+#include "trace-event.h"
+
+int header_page_ts_offset;
+int header_page_ts_size;
+int header_page_size_offset;
+int header_page_size_size;
+int header_page_data_offset;
+int header_page_data_size;
+
+static char *input_buf;
+static unsigned long long input_buf_ptr;
+static unsigned long long input_buf_siz;
+
+static int cpus;
+static int long_size;
+
+static void init_input_buf(char *buf, unsigned long long size)
+{
+        input_buf = buf;
+        input_buf_siz = size;
+        input_buf_ptr = 0;
+}
+
+struct cmdline {
+        char *comm;
+        int pid;
+};
+
+static struct cmdline *cmdlines;
+static int cmdline_count;
+
+static int cmdline_cmp(const void *a, const void *b)
+{
+        const struct cmdline *ca = a;
+        const struct cmdline *cb = b;
+
+        if (ca->pid < cb->pid)
+                return -1;
+        if (ca->pid > cb->pid)
+                return 1;
+
+        return 0;
+}
+
+void parse_cmdlines(char *file, int size __unused)
+{
+        struct cmdline_list {
+                struct cmdline_list     *next;
+                char                    *comm;
+                int                     pid;
+        } *list = NULL, *item;
+        char *line;
+        char *next = NULL;
+        int i;
+
+        line = strtok_r(file, "\n", &next);
+        while (line) {
+                item = malloc_or_die(sizeof(*item));
+                sscanf(line, "%d %as", &item->pid,
+                       (float *)(void *)&item->comm); /* workaround gcc warning */
+                item->next = list;
+                list = item;
+                line = strtok_r(NULL, "\n", &next);
+                cmdline_count++;
+        }
+
+        cmdlines = malloc_or_die(sizeof(*cmdlines) * cmdline_count);
+
+        i = 0;
+        while (list) {
+                cmdlines[i].pid = list->pid;
+                cmdlines[i].comm = list->comm;
+                i++;
+                item = list;
+                list = list->next;
+                free(item);
+        }
+
+        qsort(cmdlines, cmdline_count, sizeof(*cmdlines), cmdline_cmp);
+}
+
+static struct func_map {
+        unsigned long long              addr;
+        char                            *func;
+        char                            *mod;
+} *func_list;
+static unsigned int func_count;
+
+static int func_cmp(const void *a, const void *b)
+{
+        const struct func_map *fa = a;
+        const struct func_map *fb = b;
+
+        if (fa->addr < fb->addr)
+                return -1;
+        if (fa->addr > fb->addr)
+                return 1;
+
+        return 0;
+}
+
+void parse_proc_kallsyms(char *file, unsigned int size __unused)
+{
+        struct func_list {
+                struct func_list        *next;
+                unsigned long long      addr;
+                char                    *func;
+                char                    *mod;
+        } *list = NULL, *item;
+        char *line;
+        char *next = NULL;
+        char *addr_str;
+        char ch;
+        int ret;
+        int i;
+
+        line = strtok_r(file, "\n", &next);
+        while (line) {
+                item = malloc_or_die(sizeof(*item));
+                item->mod = NULL;
+                ret = sscanf(line, "%as %c %as\t[%as",
+                             (float *)(void *)&addr_str, /* workaround gcc warning */
+                             &ch,
+                             (float *)(void *)&item->func,
+                             (float *)(void *)&item->mod);
+                item->addr = strtoull(addr_str, NULL, 16);
+                free(addr_str);
+
+                /* truncate the extra ']' */
+                if (item->mod)
+                        item->mod[strlen(item->mod) - 1] = 0;
+
+
+                item->next = list;
+                list = item;
+                line = strtok_r(NULL, "\n", &next);
+                func_count++;
+        }
+
+        func_list = malloc_or_die(sizeof(*func_list) * func_count + 1);
+
+        i = 0;
+        while (list) {
+                func_list[i].func = list->func;
+                func_list[i].addr = list->addr;
+                func_list[i].mod = list->mod;
+                i++;
+                item = list;
+                list = list->next;
+                free(item);
+        }
+
+        qsort(func_list, func_count, sizeof(*func_list), func_cmp);
+
+        /*
+         * Add a special record at the end.
+         */
+        func_list[func_count].func = NULL;
+        func_list[func_count].addr = 0;
+        func_list[func_count].mod = NULL;
+}
+
+/*
+ * We are searching for a record in between, not an exact
+ * match.
+ */
+static int func_bcmp(const void *a, const void *b)
+{
+        const struct func_map *fa = a;
+        const struct func_map *fb = b;
+
+        if ((fa->addr == fb->addr) ||
+
+            (fa->addr > fb->addr &&
+             fa->addr < (fb+1)->addr))
+                return 0;
+
+        if (fa->addr < fb->addr)
+                return -1;
+
+        return 1;
+}
+
+static struct func_map *find_func(unsigned long long addr)
+{
+        struct func_map *func;
+        struct func_map key;
+
+        key.addr = addr;
+
+        func = bsearch(&key, func_list, func_count, sizeof(*func_list),
+                       func_bcmp);
+
+        return func;
+}
+
+void print_funcs(void)
+{
+        int i;
+
+        for (i = 0; i < (int)func_count; i++) {
+                printf("%016llx %s",
+                       func_list[i].addr,
+                       func_list[i].func);
+                if (func_list[i].mod)
+                        printf(" [%s]\n", func_list[i].mod);
+                else
+                        printf("\n");
+        }
+}
+
+static struct printk_map {
+        unsigned long long              addr;
+        char                            *printk;
+} *printk_list;
+static unsigned int printk_count;
+
+static int printk_cmp(const void *a, const void *b)
+{
+        const struct func_map *fa = a;
+        const struct func_map *fb = b;
+
+        if (fa->addr < fb->addr)
+                return -1;
+        if (fa->addr > fb->addr)
+                return 1;
+
+        return 0;
+}
+
+static struct printk_map *find_printk(unsigned long long addr)
+{
+        struct printk_map *printk;
+        struct printk_map key;
+
+        key.addr = addr;
+
+        printk = bsearch(&key, printk_list, printk_count, sizeof(*printk_list),
+                         printk_cmp);
+
+        return printk;
+}
+
+void parse_ftrace_printk(char *file, unsigned int size __unused)
+{
+        struct printk_list {
+                struct printk_list      *next;
+                unsigned long long      addr;
+                char                    *printk;
+        } *list = NULL, *item;
+        char *line;
+        char *next = NULL;
+        char *addr_str;
+        int ret;
+        int i;
+
+        line = strtok_r(file, "\n", &next);
+        while (line) {
+                item = malloc_or_die(sizeof(*item));
+                ret = sscanf(line, "%as : %as",
+                             (float *)(void *)&addr_str, /* workaround gcc warning */
+                             (float *)(void *)&item->printk);
+                item->addr = strtoull(addr_str, NULL, 16);
+                free(addr_str);
+
+                item->next = list;
+                list = item;
+                line = strtok_r(NULL, "\n", &next);
+                printk_count++;
+        }
+
+        printk_list = malloc_or_die(sizeof(*printk_list) * printk_count + 1);
+
+        i = 0;
+        while (list) {
+                printk_list[i].printk = list->printk;
+                printk_list[i].addr = list->addr;
+                i++;
+                item = list;
+                list = list->next;
+                free(item);
+        }
+
+        qsort(printk_list, printk_count, sizeof(*printk_list), printk_cmp);
+}
+
+void print_printk(void)
+{
+        int i;
+
+        for (i = 0; i < (int)printk_count; i++) {
+                printf("%016llx %s\n",
+                       printk_list[i].addr,
+                       printk_list[i].printk);
+        }
+}
+
+static struct event *alloc_event(void)
+{
+        struct event *event;
+
+        event = malloc_or_die(sizeof(*event));
+        memset(event, 0, sizeof(*event));
+
+        return event;
+}
+
+enum event_type {
+        EVENT_ERROR,
+        EVENT_NONE,
+        EVENT_SPACE,
+        EVENT_NEWLINE,
+        EVENT_OP,
+        EVENT_DELIM,
+        EVENT_ITEM,
+        EVENT_DQUOTE,
+        EVENT_SQUOTE,
+};
+
+static struct event *event_list;
+
+static void add_event(struct event *event)
+{
+        event->next = event_list;
+        event_list = event;
+}
+
+static int event_item_type(enum event_type type)
+{
+        switch (type) {
+        case EVENT_ITEM ... EVENT_SQUOTE:
+                return 1;
+        case EVENT_ERROR ... EVENT_DELIM:
+        default:
+                return 0;
+        }
+}
+
+static void free_arg(struct print_arg *arg)
+{
+        if (!arg)
+                return;
+
+        switch (arg->type) {
+        case PRINT_ATOM:
+                if (arg->atom.atom)
+                        free(arg->atom.atom);
+                break;
+        case PRINT_NULL:
+        case PRINT_FIELD ... PRINT_OP:
+        default:
+                /* todo */
+                break;
+        }
+
+        free(arg);
+}
+
+static enum event_type get_type(int ch)
+{
+        if (ch == '\n')
+                return EVENT_NEWLINE;
+        if (isspace(ch))
+                return EVENT_SPACE;
+        if (isalnum(ch) || ch == '_')
+                return EVENT_ITEM;
+        if (ch == '\'')
+                return EVENT_SQUOTE;
+        if (ch == '"')
+                return EVENT_DQUOTE;
+        if (!isprint(ch))
+                return EVENT_NONE;
+        if (ch == '(' || ch == ')' || ch == ',')
+                return EVENT_DELIM;
+
+        return EVENT_OP;
+}
+
+static int __read_char(void)
+{
+        if (input_buf_ptr >= input_buf_siz)
+                return -1;
+
+        return input_buf[input_buf_ptr++];
+}
+
+static int __peek_char(void)
+{
+        if (input_buf_ptr >= input_buf_siz)
+                return -1;
+
+        return input_buf[input_buf_ptr];
+}
+
+static enum event_type __read_token(char **tok)
+{
+        char buf[BUFSIZ];
+        int ch, last_ch, quote_ch, next_ch;
+        int i = 0;
+        int tok_size = 0;
+        enum event_type type;
+
+        *tok = NULL;
+
+
+        ch = __read_char();
+        if (ch < 0)
+                return EVENT_NONE;
+
+        type = get_type(ch);
+        if (type == EVENT_NONE)
+                return type;
+
+        buf[i++] = ch;
+
+        switch (type) {
+        case EVENT_NEWLINE:
+        case EVENT_DELIM:
+                *tok = malloc_or_die(2);
+                (*tok)[0] = ch;
+                (*tok)[1] = 0;
+                return type;
+
+        case EVENT_OP:
+                switch (ch) {
+                case '-':
+                        next_ch = __peek_char();
+                        if (next_ch == '>') {
+                                buf[i++] = __read_char();
+                                break;
+                        }
+                        /* fall through */
+                case '+':
+                case '|':
+                case '&':
+                case '>':
+                case '<':
+                        last_ch = ch;
+                        ch = __peek_char();
+                        if (ch != last_ch)
+                                goto test_equal;
+                        buf[i++] = __read_char();
+                        switch (last_ch) {
+                        case '>':
+                        case '<':
+                                goto test_equal;
+                        default:
+                                break;
+                        }
+                        break;
+                case '!':
+                case '=':
+                        goto test_equal;
+                default: /* what should we do instead? */
+                        break;
+                }
+                buf[i] = 0;
+                *tok = strdup(buf);
+                return type;
+
+ test_equal:
+                ch = __peek_char();
+                if (ch == '=')
+                        buf[i++] = __read_char();
+                break;
+
+        case EVENT_DQUOTE:
+        case EVENT_SQUOTE:
+                /* don't keep quotes */
+                i--;
+                quote_ch = ch;
+                last_ch = 0;
+                do {
+                        if (i == (BUFSIZ - 1)) {
+                                buf[i] = 0;
+                                if (*tok) {
+                                        *tok = realloc(*tok, tok_size + BUFSIZ);
+                                        if (!*tok)
+                                                return EVENT_NONE;
+                                        strcat(*tok, buf);
+                                } else
+                                        *tok = strdup(buf);
+
+                                if (!*tok)
+                                        return EVENT_NONE;
+                                tok_size += BUFSIZ;
+                                i = 0;
+                        }
+                        last_ch = ch;
+                        ch = __read_char();
+                        buf[i++] = ch;
+                } while (ch != quote_ch && last_ch != '\\');
+                /* remove the last quote */
+                i--;
+                goto out;
+
+        case EVENT_ERROR ... EVENT_SPACE:
+        case EVENT_ITEM:
+        default:
+                break;
+        }
+
+        while (get_type(__peek_char()) == type) {
+                if (i == (BUFSIZ - 1)) {
+                        buf[i] = 0;
+                        if (*tok) {
+                                *tok = realloc(*tok, tok_size + BUFSIZ);
+                                if (!*tok)
+                                        return EVENT_NONE;
+                                strcat(*tok, buf);
+                        } else
+                                *tok = strdup(buf);
+
+                        if (!*tok)
+                                return EVENT_NONE;
+                        tok_size += BUFSIZ;
+                        i = 0;
+                }
+                ch = __read_char();
+                buf[i++] = ch;
+        }
+
+ out:
+        buf[i] = 0;
+        if (*tok) {
+                *tok = realloc(*tok, tok_size + i);
+                if (!*tok)
+                        return EVENT_NONE;
+                strcat(*tok, buf);
+        } else
+                *tok = strdup(buf);
+        if (!*tok)
+                return EVENT_NONE;
+
+        return type;
+}
+
+static void free_token(char *tok)
+{
+        if (tok)
+                free(tok);
+}
+
+static enum event_type read_token(char **tok)
+{
+        enum event_type type;
+
+        for (;;) {
+                type = __read_token(tok);
+                if (type != EVENT_SPACE)
+                        return type;
+
+                free_token(*tok);
+        }
+
+        /* not reached */
+        return EVENT_NONE;
+}
+
+/* no newline */
+static enum event_type read_token_item(char **tok)
+{
+        enum event_type type;
+
+        for (;;) {
+                type = __read_token(tok);
+                if (type != EVENT_SPACE && type != EVENT_NEWLINE)
+                        return type;
+
+                free_token(*tok);
+        }
+
+        /* not reached */
+        return EVENT_NONE;
+}
+
+static int test_type(enum event_type type, enum event_type expect)
+{
+        if (type != expect) {
+                die("Error: expected type %d but read %d",
+                    expect, type);
+                return -1;
+        }
+        return 0;
+}
+
+static int test_type_token(enum event_type type, char *token,
+                    enum event_type expect, char *expect_tok)
+{
+        if (type != expect) {
+                die("Error: expected type %d but read %d",
+                    expect, type);
+                return -1;
+        }
+
+        if (strcmp(token, expect_tok) != 0) {
+                die("Error: expected '%s' but read '%s'",
+                    expect_tok, token);
+                return -1;
+        }
+        return 0;
+}
+
+static int __read_expect_type(enum event_type expect, char **tok, int newline_ok)
+{
+        enum event_type type;
+
+        if (newline_ok)
+                type = read_token(tok);
+        else
+                type = read_token_item(tok);
+        return test_type(type, expect);
+}
+
+static int read_expect_type(enum event_type expect, char **tok)
+{
+        return __read_expect_type(expect, tok, 1);
+}
+
+static int __read_expected(enum event_type expect, char *str, int newline_ok)
+{
+        enum event_type type;
+        char *token;
+        int ret;
+
+        if (newline_ok)
+                type = read_token(&token);
+        else
+                type = read_token_item(&token);
+
+        ret = test_type_token(type, token, expect, str);
+
+        free_token(token);
+
+        return 0;
+}
+
+static int read_expected(enum event_type expect, char *str)
+{
+        return __read_expected(expect, str, 1);
+}
+
+static int read_expected_item(enum event_type expect, char *str)
+{
+        return __read_expected(expect, str, 0);
+}
+
+static char *event_read_name(void)
+{
+        char *token;
+
+        if (read_expected(EVENT_ITEM, (char *)"name") < 0)
+                return NULL;
+
+        if (read_expected(EVENT_OP, (char *)":") < 0)
+                return NULL;
+
+        if (read_expect_type(EVENT_ITEM, &token) < 0)
+                goto fail;
+
+        return token;
+
+ fail:
+        free_token(token);
+        return NULL;
+}
+
+static int event_read_id(void)
+{
+        char *token;
+        int id;
+
+        if (read_expected_item(EVENT_ITEM, (char *)"ID") < 0)
+                return -1;
+
+        if (read_expected(EVENT_OP, (char *)":") < 0)
+                return -1;
+
+        if (read_expect_type(EVENT_ITEM, &token) < 0)
+                goto fail;
+
+        id = strtoul(token, NULL, 0);
+        free_token(token);
+        return id;
+
+ fail:
+        free_token(token);
+        return -1;
+}
+
+static int event_read_fields(struct event *event, struct format_field **fields)
+{
+        struct format_field *field = NULL;
+        enum event_type type;
+        char *token;
+        char *last_token;
+        int count = 0;
+
+        do {
+                type = read_token(&token);
+                if (type == EVENT_NEWLINE) {
+                        free_token(token);
+                        return count;
+                }
+
+                count++;
+
+                if (test_type_token(type, token, EVENT_ITEM, (char *)"field"))
+                        goto fail;
+                free_token(token);
+
+                type = read_token(&token);
+                /*
+                 * The ftrace fields may still use the "special" name.
+                 * Just ignore it.
+                 */
+                if (event->flags & EVENT_FL_ISFTRACE &&
+                    type == EVENT_ITEM && strcmp(token, "special") == 0) {
+                        free_token(token);
+                        type = read_token(&token);
+                }
+
+                if (test_type_token(type, token, EVENT_OP, (char *)":") < 0)
+                        return -1;
+
+                if (read_expect_type(EVENT_ITEM, &token) < 0)
+                        goto fail;
+
+                last_token = token;
+
+                field = malloc_or_die(sizeof(*field));
+                memset(field, 0, sizeof(*field));
+
+                /* read the rest of the type */
+                for (;;) {
+                        type = read_token(&token);
+                        if (type == EVENT_ITEM ||
+                            (type == EVENT_OP && strcmp(token, "*") == 0) ||
+                            /*
+                             * Some of the ftrace fields are broken and have
+                             * an illegal "." in them.
+                             */
+                            (event->flags & EVENT_FL_ISFTRACE &&
+                             type == EVENT_OP && strcmp(token, ".") == 0)) {
+
+                                if (strcmp(token, "*") == 0)
+                                        field->flags |= FIELD_IS_POINTER;
+
+                                if (field->type) {
+                                        field->type = realloc(field->type,
+                                                              strlen(field->type) +
+                                                              strlen(last_token) + 2);
+                                        strcat(field->type, " ");
+                                        strcat(field->type, last_token);
+                                } else
+                                        field->type = last_token;
+                                last_token = token;
+                                continue;
+                        }
+
+                        break;
+                }
+
+                if (!field->type) {
+                        die("no type found");
+                        goto fail;
+                }
+                field->name = last_token;
+
+                if (test_type(type, EVENT_OP))
+                        goto fail;
+
+                if (strcmp(token, "[") == 0) {
+                        enum event_type last_type = type;
+                        char *brackets = token;
+                        int len;
+
+                        field->flags |= FIELD_IS_ARRAY;
+
+                        type = read_token(&token);
+                        while (strcmp(token, "]") != 0) {
+                                if (last_type == EVENT_ITEM &&
+                                    type == EVENT_ITEM)
+                                        len = 2;
+                                else
+                                        len = 1;
+                                last_type = type;
+
+                                brackets = realloc(brackets,
+                                                   strlen(brackets) +
+                                                   strlen(token) + len);
+                                if (len == 2)
+                                        strcat(brackets, " ");
+                                strcat(brackets, token);
+                                free_token(token);
+                                type = read_token(&token);
+                                if (type == EVENT_NONE) {
+                                        die("failed to find token");
+                                        goto fail;
+                                }
+                        }
+
+                        free_token(token);
+
+                        brackets = realloc(brackets, strlen(brackets) + 2);
+                        strcat(brackets, "]");
+
+                        /* add brackets to type */
+
+                        type = read_token(&token);
+                        /*
+                         * If the next token is not an OP, then it is of
+                         * the format: type [] item;
+                         */
+                        if (type == EVENT_ITEM) {
+                                field->type = realloc(field->type,
+                                                      strlen(field->type) +
+                                                      strlen(field->name) +
+                                                      strlen(brackets) + 2);
+                                strcat(field->type, " ");
+                                strcat(field->type, field->name);
+                                free_token(field->name);
+                                strcat(field->type, brackets);
+                                field->name = token;
+                                type = read_token(&token);
+                        } else {
+                                field->type = realloc(field->type,
+                                                      strlen(field->type) +
+                                                      strlen(brackets) + 1);
+                                strcat(field->type, brackets);
+                        }
+                        free(brackets);
+                }
+
+                if (test_type_token(type, token,  EVENT_OP, (char *)";"))
+                        goto fail;
+                free_token(token);
+
+                if (read_expected(EVENT_ITEM, (char *)"offset") < 0)
+                        goto fail_expect;
+
+                if (read_expected(EVENT_OP, (char *)":") < 0)
+                        goto fail_expect;
+
+                if (read_expect_type(EVENT_ITEM, &token))
+                        goto fail;
+                field->offset = strtoul(token, NULL, 0);
+                free_token(token);
+
+                if (read_expected(EVENT_OP, (char *)";") < 0)
+                        goto fail_expect;
+
+                if (read_expected(EVENT_ITEM, (char *)"size") < 0)
+                        goto fail_expect;
+
+                if (read_expected(EVENT_OP, (char *)":") < 0)
+                        goto fail_expect;
+
+                if (read_expect_type(EVENT_ITEM, &token))
+                        goto fail;
+                field->size = strtoul(token, NULL, 0);
+                free_token(token);
+
+                if (read_expected(EVENT_OP, (char *)";") < 0)
+                        goto fail_expect;
+
+                if (read_expect_type(EVENT_NEWLINE, &token) < 0)
+                        goto fail;
+                free_token(token);
+
+                *fields = field;
+                fields = &field->next;
+
+        } while (1);
+
+        return 0;
+
+fail:
+        free_token(token);
+fail_expect:
+        if (field)
+                free(field);
+        return -1;
+}
+
+static int event_read_format(struct event *event)
+{
+        char *token;
+        int ret;
+
+        if (read_expected_item(EVENT_ITEM, (char *)"format") < 0)
+                return -1;
+
+        if (read_expected(EVENT_OP, (char *)":") < 0)
+                return -1;
+
+        if (read_expect_type(EVENT_NEWLINE, &token))
+                goto fail;
+        free_token(token);
+
+        ret = event_read_fields(event, &event->format.common_fields);
+        if (ret < 0)
+                return ret;
+        event->format.nr_common = ret;
+
+        ret = event_read_fields(event, &event->format.fields);
+        if (ret < 0)
+                return ret;
+        event->format.nr_fields = ret;
+
+        return 0;
+
+ fail:
+        free_token(token);
+        return -1;
+}
+
+enum event_type
+process_arg_token(struct event *event, struct print_arg *arg,
+                  char **tok, enum event_type type);
+
+static enum event_type
+process_arg(struct event *event, struct print_arg *arg, char **tok)
+{
+        enum event_type type;
+        char *token;
+
+        type = read_token(&token);
+        *tok = token;
+
+        return process_arg_token(event, arg, tok, type);
+}
+
+static enum event_type
+process_cond(struct event *event, struct print_arg *top, char **tok)
+{
+        struct print_arg *arg, *left, *right;
+        enum event_type type;
+        char *token = NULL;
+
+        arg = malloc_or_die(sizeof(*arg));
+        memset(arg, 0, sizeof(*arg));
+
+        left = malloc_or_die(sizeof(*left));
+
+        right = malloc_or_die(sizeof(*right));
+
+        arg->type = PRINT_OP;
+        arg->op.left = left;
+        arg->op.right = right;
+
+        *tok = NULL;
+        type = process_arg(event, left, &token);
+        if (test_type_token(type, token, EVENT_OP, (char *)":"))
+                goto out_free;
+
+        arg->op.op = token;
+
+        type = process_arg(event, right, &token);
+
+        top->op.right = arg;
+
+        *tok = token;
+        return type;
+
+out_free:
+        free_token(*tok);
+        free(right);
+        free(left);
+        free_arg(arg);
+        return EVENT_ERROR;
+}
+
+static int get_op_prio(char *op)
+{
+        if (!op[1]) {
+                switch (op[0]) {
+                case '*':
+                case '/':
+                case '%':
+                        return 6;
+                case '+':
+                case '-':
+                        return 7;
+                        /* '>>' and '<<' are 8 */
+                case '<':
+                case '>':
+                        return 9;
+                        /* '==' and '!=' are 10 */
+                case '&':
+                        return 11;
+                case '^':
+                        return 12;
+                case '|':
+                        return 13;
+                case '?':
+                        return 16;
+                default:
+                        die("unknown op '%c'", op[0]);
+                        return -1;
+                }
+        } else {
+                if (strcmp(op, "++") == 0 ||
+                    strcmp(op, "--") == 0) {
+                        return 3;
+                } else if (strcmp(op, ">>") == 0 ||
+                           strcmp(op, "<<") == 0) {
+                        return 8;
+                } else if (strcmp(op, ">=") == 0 ||
+                           strcmp(op, "<=") == 0) {
+                        return 9;
+                } else if (strcmp(op, "==") == 0 ||
+                           strcmp(op, "!=") == 0) {
+                        return 10;
+                } else if (strcmp(op, "&&") == 0) {
+                        return 14;
+                } else if (strcmp(op, "||") == 0) {
+                        return 15;
+                } else {
+                        die("unknown op '%s'", op);
+                        return -1;
+                }
+        }
+}
+
+static void set_op_prio(struct print_arg *arg)
+{
+
+        /* single ops are the greatest */
+        if (!arg->op.left || arg->op.left->type == PRINT_NULL) {
+                arg->op.prio = 0;
+                return;
+        }
+
+        arg->op.prio = get_op_prio(arg->op.op);
+}
+
+static enum event_type
+process_op(struct event *event, struct print_arg *arg, char **tok)
+{
+        struct print_arg *left, *right = NULL;
+        enum event_type type;
+        char *token;
+
+        /* the op is passed in via tok */
+        token = *tok;
+
+        if (arg->type == PRINT_OP && !arg->op.left) {
+                /* handle single op */
+                if (token[1]) {
+                        die("bad op token %s", token);
+                        return EVENT_ERROR;
+                }
+                switch (token[0]) {
+                case '!':
+                case '+':
+                case '-':
+                        break;
+                default:
+                        die("bad op token %s", token);
+                        return EVENT_ERROR;
+                }
+
+                /* make an empty left */
+                left = malloc_or_die(sizeof(*left));
+                left->type = PRINT_NULL;
+                arg->op.left = left;
+
+                right = malloc_or_die(sizeof(*right));
+                arg->op.right = right;
+
+                type = process_arg(event, right, tok);
+
+        } else if (strcmp(token, "?") == 0) {
+
+                left = malloc_or_die(sizeof(*left));
+                /* copy the top arg to the left */
+                *left = *arg;
+
+                arg->type = PRINT_OP;
+                arg->op.op = token;
+                arg->op.left = left;
+                arg->op.prio = 0;
+
+                type = process_cond(event, arg, tok);
+
+        } else if (strcmp(token, ">>") == 0 ||
+                   strcmp(token, "<<") == 0 ||
+                   strcmp(token, "&") == 0 ||
+                   strcmp(token, "|") == 0 ||
+                   strcmp(token, "&&") == 0 ||
+                   strcmp(token, "||") == 0 ||
+                   strcmp(token, "-") == 0 ||
+                   strcmp(token, "+") == 0 ||
+                   strcmp(token, "*") == 0 ||
+                   strcmp(token, "^") == 0 ||
+                   strcmp(token, "/") == 0 ||
+                   strcmp(token, "==") == 0 ||
+                   strcmp(token, "!=") == 0) {
+
+                left = malloc_or_die(sizeof(*left));
+
+                /* copy the top arg to the left */
+                *left = *arg;
+
+                arg->type = PRINT_OP;
+                arg->op.op = token;
+                arg->op.left = left;
+
+                set_op_prio(arg);
+
+                right = malloc_or_die(sizeof(*right));
+
+                type = process_arg(event, right, tok);
+
+                arg->op.right = right;
+
+        } else {
+                die("unknown op '%s'", token);
+                /* the arg is now the left side */
+                return EVENT_NONE;
+        }
+
+
+        if (type == EVENT_OP) {
+                int prio;
+
+                /* higher prios need to be closer to the root */
+                prio = get_op_prio(*tok);
+
+                if (prio > arg->op.prio)
+                        return process_op(event, arg, tok);
+
+                return process_op(event, right, tok);
+        }
+
+        return type;
+}
+
+static enum event_type
+process_entry(struct event *event __unused, struct print_arg *arg,
+              char **tok)
+{
+        enum event_type type;
+        char *field;
+        char *token;
+
+        if (read_expected(EVENT_OP, (char *)"->") < 0)
+                return EVENT_ERROR;
+
+        if (read_expect_type(EVENT_ITEM, &token) < 0)
+                goto fail;
+        field = token;
+
+        arg->type = PRINT_FIELD;
+        arg->field.name = field;
+
+        type = read_token(&token);
+        *tok = token;
+
+        return type;
+
+fail:
+        free_token(token);
+        return EVENT_ERROR;
+}
+
+static char *arg_eval (struct print_arg *arg);
+
+static long long arg_num_eval(struct print_arg *arg)
+{
+        long long left, right;
+        long long val = 0;
+
+        switch (arg->type) {
+        case PRINT_ATOM:
+                val = strtoll(arg->atom.atom, NULL, 0);
+                break;
+        case PRINT_TYPE:
+                val = arg_num_eval(arg->typecast.item);
+                break;
+        case PRINT_OP:
+                switch (arg->op.op[0]) {
+                case '|':
+                        left = arg_num_eval(arg->op.left);
+                        right = arg_num_eval(arg->op.right);
+                        if (arg->op.op[1])
+                                val = left || right;
+                        else
+                                val = left | right;
+                        break;
+                case '&':
+                        left = arg_num_eval(arg->op.left);
+                        right = arg_num_eval(arg->op.right);
+                        if (arg->op.op[1])
+                                val = left && right;
+                        else
+                                val = left & right;
+                        break;
+                case '<':
+                        left = arg_num_eval(arg->op.left);
+                        right = arg_num_eval(arg->op.right);
+                        switch (arg->op.op[1]) {
+                        case 0:
+                                val = left < right;
+                                break;
+                        case '<':
+                                val = left << right;
+                                break;
+                        case '=':
+                                val = left <= right;
+                                break;
+                        default:
+                                die("unknown op '%s'", arg->op.op);
+                        }
+                        break;
+                case '>':
+                        left = arg_num_eval(arg->op.left);
+                        right = arg_num_eval(arg->op.right);
+                        switch (arg->op.op[1]) {
+                        case 0:
+                                val = left > right;
+                                break;
+                        case '>':
+                                val = left >> right;
+                                break;
+                        case '=':
+                                val = left >= right;
+                                break;
+                        default:
+                                die("unknown op '%s'", arg->op.op);
+                        }
+                        break;
+                case '=':
+                        left = arg_num_eval(arg->op.left);
+                        right = arg_num_eval(arg->op.right);
+
+                        if (arg->op.op[1] != '=')
+                                die("unknown op '%s'", arg->op.op);
+
+                        val = left == right;
+                        break;
+                case '!':
+                        left = arg_num_eval(arg->op.left);
+                        right = arg_num_eval(arg->op.right);
+
+                        switch (arg->op.op[1]) {
+                        case '=':
+                                val = left != right;
+                                break;
+                        default:
+                                die("unknown op '%s'", arg->op.op);
+                        }
+                        break;
+                default:
+                        die("unknown op '%s'", arg->op.op);
+                }
+                break;
+
+        case PRINT_NULL:
+        case PRINT_FIELD ... PRINT_SYMBOL:
+        case PRINT_STRING:
+        default:
+                die("invalid eval type %d", arg->type);
+
+        }
+        return val;
+}
+
+static char *arg_eval (struct print_arg *arg)
+{
+        long long val;
+        static char buf[20];
+
+        switch (arg->type) {
+        case PRINT_ATOM:
+                return arg->atom.atom;
+        case PRINT_TYPE:
+                return arg_eval(arg->typecast.item);
+        case PRINT_OP:
+                val = arg_num_eval(arg);
+                sprintf(buf, "%lld", val);
+                return buf;
+
+        case PRINT_NULL:
+        case PRINT_FIELD ... PRINT_SYMBOL:
+        case PRINT_STRING:
+        default:
+                die("invalid eval type %d", arg->type);
+                break;
+        }
+
+        return NULL;
+}
+
+static enum event_type
+process_fields(struct event *event, struct print_flag_sym **list, char **tok)
+{
+        enum event_type type;
+        struct print_arg *arg = NULL;
+        struct print_flag_sym *field;
+        char *token = NULL;
+        char *value;
+
+        do {
+                free_token(token);
+                type = read_token_item(&token);
+                if (test_type_token(type, token, EVENT_OP, (char *)"{"))
+                        break;
+
+                arg = malloc_or_die(sizeof(*arg));
+
+                free_token(token);
+                type = process_arg(event, arg, &token);
+                if (test_type_token(type, token, EVENT_DELIM, (char *)","))
+                        goto out_free;
+
+                field = malloc_or_die(sizeof(*field));
+                memset(field, 0, sizeof(field));
+
+                value = arg_eval(arg);
+                field->value = strdup(value);
+
+                free_token(token);
+                type = process_arg(event, arg, &token);
+                if (test_type_token(type, token, EVENT_OP, (char *)"}"))
+                        goto out_free;
+
+                value = arg_eval(arg);
+                field->str = strdup(value);
+                free_arg(arg);
+                arg = NULL;
+
+                *list = field;
+                list = &field->next;
+
+                free_token(token);
+                type = read_token_item(&token);
+        } while (type == EVENT_DELIM && strcmp(token, ",") == 0);
+
+        *tok = token;
+        return type;
+
+out_free:
+        free_arg(arg);
+        free_token(token);
+
+        return EVENT_ERROR;
+}
+
+static enum event_type
+process_flags(struct event *event, struct print_arg *arg, char **tok)
+{
+        struct print_arg *field;
+        enum event_type type;
+        char *token;
+
+        memset(arg, 0, sizeof(*arg));
+        arg->type = PRINT_FLAGS;
+
+        if (read_expected_item(EVENT_DELIM, (char *)"(") < 0)
+                return EVENT_ERROR;
+
+        field = malloc_or_die(sizeof(*field));
+
+        type = process_arg(event, field, &token);
+        if (test_type_token(type, token, EVENT_DELIM, (char *)","))
+                goto out_free;
+
+        arg->flags.field = field;
+
+        type = read_token_item(&token);
+        if (event_item_type(type)) {
+                arg->flags.delim = token;
+                type = read_token_item(&token);
+        }
+
+        if (test_type_token(type, token, EVENT_DELIM, (char *)","))
+                goto out_free;
+
+        type = process_fields(event, &arg->flags.flags, &token);
+        if (test_type_token(type, token, EVENT_DELIM, (char *)")"))
+                goto out_free;
+
+        free_token(token);
+        type = read_token_item(tok);
+        return type;
+
+out_free:
+        free_token(token);
+        return EVENT_ERROR;
+}
+
+static enum event_type
+process_symbols(struct event *event, struct print_arg *arg, char **tok)
+{
+        struct print_arg *field;
+        enum event_type type;
+        char *token;
+
+        memset(arg, 0, sizeof(*arg));
+        arg->type = PRINT_SYMBOL;
+
+        if (read_expected_item(EVENT_DELIM, (char *)"(") < 0)
+                return EVENT_ERROR;
+
+        field = malloc_or_die(sizeof(*field));
+
+        type = process_arg(event, field, &token);
+        if (test_type_token(type, token, EVENT_DELIM, (char *)","))
+                goto out_free;
+
+        arg->symbol.field = field;
+
+        type = process_fields(event, &arg->symbol.symbols, &token);
+        if (test_type_token(type, token, EVENT_DELIM, (char *)")"))
+                goto out_free;
+
+        free_token(token);
+        type = read_token_item(tok);
+        return type;
+
+out_free:
+        free_token(token);
+        return EVENT_ERROR;
+}
+
+static enum event_type
+process_paren(struct event *event, struct print_arg *arg, char **tok)
+{
+        struct print_arg *item_arg;
+        enum event_type type;
+        int ptr_cast = 0;
+        char *token;
+
+        type = process_arg(event, arg, &token);
+
+        if (type == EVENT_ERROR)
+                return EVENT_ERROR;
+
+        if (type == EVENT_OP) {
+                /* handle the ptr casts */
+                if (!strcmp(token, "*")) {
+                        /*
+                         * FIXME: should we zapp whitespaces before ')' ?
+                         * (may require a peek_token_item())
+                         */
+                        if (__peek_char() == ')') {
+                                ptr_cast = 1;
+                                free_token(token);
+                                type = read_token_item(&token);
+                        }
+                }
+                if (!ptr_cast) {
+                        type = process_op(event, arg, &token);
+
+                        if (type == EVENT_ERROR)
+                                return EVENT_ERROR;
+                }
+        }
+
+        if (test_type_token(type, token, EVENT_DELIM, (char *)")")) {
+                free_token(token);
+                return EVENT_ERROR;
+        }
+
+        free_token(token);
+        type = read_token_item(&token);
+
+        /*
+         * If the next token is an item or another open paren, then
+         * this was a typecast.
+         */
+        if (event_item_type(type) ||
+            (type == EVENT_DELIM && strcmp(token, "(") == 0)) {
+
+                /* make this a typecast and contine */
+
+                /* prevous must be an atom */
+                if (arg->type != PRINT_ATOM)
+                        die("previous needed to be PRINT_ATOM");
+
+                item_arg = malloc_or_die(sizeof(*item_arg));
+
+                arg->type = PRINT_TYPE;
+                if (ptr_cast) {
+                        char *old = arg->atom.atom;
+
+                        arg->atom.atom = malloc_or_die(strlen(old + 3));
+                        sprintf(arg->atom.atom, "%s *", old);
+                        free(old);
+                }
+                arg->typecast.type = arg->atom.atom;
+                arg->typecast.item = item_arg;
+                type = process_arg_token(event, item_arg, &token, type);
+
+        }
+
+        *tok = token;
+        return type;
+}
+
+
+static enum event_type
+process_str(struct event *event __unused, struct print_arg *arg, char **tok)
+{
+        enum event_type type;
+        char *token;
+
+        if (read_expected(EVENT_DELIM, (char *)"(") < 0)
+                return EVENT_ERROR;
+
+        if (read_expect_type(EVENT_ITEM, &token) < 0)
+                goto fail;
+
+        arg->type = PRINT_STRING;
+        arg->string.string = token;
+        arg->string.offset = -1;
+
+        if (read_expected(EVENT_DELIM, (char *)")") < 0)
+                return EVENT_ERROR;
+
+        type = read_token(&token);
+        *tok = token;
+
+        return type;
+fail:
+        free_token(token);
+        return EVENT_ERROR;
+}
+
+enum event_type
+process_arg_token(struct event *event, struct print_arg *arg,
+                  char **tok, enum event_type type)
+{
+        char *token;
+        char *atom;
+
+        token = *tok;
+
+        switch (type) {
+        case EVENT_ITEM:
+                if (strcmp(token, "REC") == 0) {
+                        free_token(token);
+                        type = process_entry(event, arg, &token);
+                } else if (strcmp(token, "__print_flags") == 0) {
+                        free_token(token);
+                        type = process_flags(event, arg, &token);
+                } else if (strcmp(token, "__print_symbolic") == 0) {
+                        free_token(token);
+                        type = process_symbols(event, arg, &token);
+                } else if (strcmp(token, "__get_str") == 0) {
+                        free_token(token);
+                        type = process_str(event, arg, &token);
+                } else {
+                        atom = token;
+                        /* test the next token */
+                        type = read_token_item(&token);
+
+                        /* atoms can be more than one token long */
+                        while (type == EVENT_ITEM) {
+                                atom = realloc(atom, strlen(atom) + strlen(token) + 2);
+                                strcat(atom, " ");
+                                strcat(atom, token);
+                                free_token(token);
+                                type = read_token_item(&token);
+                        }
+
+                        /* todo, test for function */
+
+                        arg->type = PRINT_ATOM;
+                        arg->atom.atom = atom;
+                }
+                break;
+        case EVENT_DQUOTE:
+        case EVENT_SQUOTE:
+                arg->type = PRINT_ATOM;
+                arg->atom.atom = token;
+                type = read_token_item(&token);
+                break;
+        case EVENT_DELIM:
+                if (strcmp(token, "(") == 0) {
+                        free_token(token);
+                        type = process_paren(event, arg, &token);
+                        break;
+                }
+        case EVENT_OP:
+                /* handle single ops */
+                arg->type = PRINT_OP;
+                arg->op.op = token;
+                arg->op.left = NULL;
+                type = process_op(event, arg, &token);
+
+                break;
+
+        case EVENT_ERROR ... EVENT_NEWLINE:
+        default:
+                die("unexpected type %d", type);
+        }
+        *tok = token;
+
+        return type;
+}
+
+static int event_read_print_args(struct event *event, struct print_arg **list)
+{
+        enum event_type type;
+        struct print_arg *arg;
+        char *token;
+        int args = 0;
+
+        do {
+                arg = malloc_or_die(sizeof(*arg));
+                memset(arg, 0, sizeof(*arg));
+
+                type = process_arg(event, arg, &token);
+
+                if (type == EVENT_ERROR) {
+                        free_arg(arg);
+                        return -1;
+                }
+
+                *list = arg;
+                args++;
+
+                if (type == EVENT_OP) {
+                        type = process_op(event, arg, &token);
+                        list = &arg->next;
+                        continue;
+                }
+
+                if (type == EVENT_DELIM && strcmp(token, ",") == 0) {
+                        free_token(token);
+                        *list = arg;
+                        list = &arg->next;
+                        continue;
+                }
+                break;
+        } while (type != EVENT_NONE);
+
+        if (type != EVENT_NONE)
+                free_token(token);
+
+        return args;
+}
+
+static int event_read_print(struct event *event)
+{
+        enum event_type type;
+        char *token;
+        int ret;
+
+        if (read_expected_item(EVENT_ITEM, (char *)"print") < 0)
+                return -1;
+
+        if (read_expected(EVENT_ITEM, (char *)"fmt") < 0)
+                return -1;
+
+        if (read_expected(EVENT_OP, (char *)":") < 0)
+                return -1;
+
+        if (read_expect_type(EVENT_DQUOTE, &token) < 0)
+                goto fail;
+
+        event->print_fmt.format = token;
+        event->print_fmt.args = NULL;
+
+        /* ok to have no arg */
+        type = read_token_item(&token);
+
+        if (type == EVENT_NONE)
+                return 0;
+
+        if (test_type_token(type, token, EVENT_DELIM, (char *)","))
+                goto fail;
+
+        free_token(token);
+
+        ret = event_read_print_args(event, &event->print_fmt.args);
+        if (ret < 0)
+                return -1;
+
+        return 0;
+
+ fail:
+        free_token(token);
+        return -1;
+}
+
+static struct format_field *
+find_common_field(struct event *event, const char *name)
+{
+        struct format_field *format;
+
+        for (format = event->format.common_fields;
+             format; format = format->next) {
+                if (strcmp(format->name, name) == 0)
+                        break;
+        }
+
+        return format;
+}
+
+static struct format_field *
+find_field(struct event *event, const char *name)
+{
+        struct format_field *format;
+
+        for (format = event->format.fields;
+             format; format = format->next) {
+                if (strcmp(format->name, name) == 0)
+                        break;
+        }
+
+        return format;
+}
+
+static struct format_field *
+find_any_field(struct event *event, const char *name)
+{
+        struct format_field *format;
+
+        format = find_common_field(event, name);
+        if (format)
+                return format;
+        return find_field(event, name);
+}
+
+static unsigned long long read_size(void *ptr, int size)
+{
+        switch (size) {
+        case 1:
+                return *(unsigned char *)ptr;
+        case 2:
+                return data2host2(ptr);
+        case 4:
+                return data2host4(ptr);
+        case 8:
+                return data2host8(ptr);
+        default:
+                /* BUG! */
+                return 0;
+        }
+}
+
+static int get_common_info(const char *type, int *offset, int *size)
+{
+        struct event *event;
+        struct format_field *field;
+
+        /*
+         * All events should have the same common elements.
+         * Pick any event to find where the type is;
+         */
+        if (!event_list)
+                die("no event_list!");
+
+        event = event_list;
+        field = find_common_field(event, type);
+        if (!field)
+                die("field '%s' not found", type);
+
+        *offset = field->offset;
+        *size = field->size;
+
+        return 0;
+}
+
+static int parse_common_type(void *data)
+{
+        static int type_offset;
+        static int type_size;
+        int ret;
+
+        if (!type_size) {
+                ret = get_common_info("common_type",
+                                      &type_offset,
+                                      &type_size);
+                if (ret < 0)
+                        return ret;
+        }
+        return read_size(data + type_offset, type_size);
+}
+
+static int parse_common_pid(void *data)
+{
+        static int pid_offset;
+        static int pid_size;
+        int ret;
+
+        if (!pid_size) {
+                ret = get_common_info("common_pid",
+                                      &pid_offset,
+                                      &pid_size);
+                if (ret < 0)
+                        return ret;
+        }
+
+        return read_size(data + pid_offset, pid_size);
+}
+
+static struct event *find_event(int id)
+{
+        struct event *event;
+
+        for (event = event_list; event; event = event->next) {
+                if (event->id == id)
+                        break;
+        }
+        return event;
+}
+
+static unsigned long long eval_num_arg(void *data, int size,
+                                   struct event *event, struct print_arg *arg)
+{
+        unsigned long long val = 0;
+        unsigned long long left, right;
+
+        switch (arg->type) {
+        case PRINT_NULL:
+                /* ?? */
+                return 0;
+        case PRINT_ATOM:
+                return strtoull(arg->atom.atom, NULL, 0);
+        case PRINT_FIELD:
+                if (!arg->field.field) {
+                        arg->field.field = find_any_field(event, arg->field.name);
+                        if (!arg->field.field)
+                                die("field %s not found", arg->field.name);
+                }
+                /* must be a number */
+                val = read_size(data + arg->field.field->offset,
+                                arg->field.field->size);
+                break;
+        case PRINT_FLAGS:
+        case PRINT_SYMBOL:
+                break;
+        case PRINT_TYPE:
+                return eval_num_arg(data, size, event, arg->typecast.item);
+        case PRINT_STRING:
+                return 0;
+                break;
+        case PRINT_OP:
+                left = eval_num_arg(data, size, event, arg->op.left);
+                right = eval_num_arg(data, size, event, arg->op.right);
+                switch (arg->op.op[0]) {
+                case '|':
+                        if (arg->op.op[1])
+                                val = left || right;
+                        else
+                                val = left | right;
+                        break;
+                case '&':
+                        if (arg->op.op[1])
+                                val = left && right;
+                        else
+                                val = left & right;
+                        break;
+                case '<':
+                        switch (arg->op.op[1]) {
+                        case 0:
+                                val = left < right;
+                                break;
+                        case '<':
+                                val = left << right;
+                                break;
+                        case '=':
+                                val = left <= right;
+                                break;
+                        default:
+                                die("unknown op '%s'", arg->op.op);
+                        }
+                        break;
+                case '>':
+                        switch (arg->op.op[1]) {
+                        case 0:
+                                val = left > right;
+                                break;
+                        case '>':
+                                val = left >> right;
+                                break;
+                        case '=':
+                                val = left >= right;
+                                break;
+                        default:
+                                die("unknown op '%s'", arg->op.op);
+                        }
+                        break;
+                case '=':
+                        if (arg->op.op[1] != '=')
+                                die("unknown op '%s'", arg->op.op);
+                        val = left == right;
+                        break;
+                default:
+                        die("unknown op '%s'", arg->op.op);
+                }
+                break;
+        default: /* not sure what to do there */
+                return 0;
+        }
+        return val;
+}
+
+struct flag {
+        const char *name;
+        unsigned long long value;
+};
+
+static const struct flag flags[] = {
+        { "HI_SOFTIRQ", 0 },
+        { "TIMER_SOFTIRQ", 1 },
+        { "NET_TX_SOFTIRQ", 2 },
+        { "NET_RX_SOFTIRQ", 3 },
+        { "BLOCK_SOFTIRQ", 4 },
+        { "TASKLET_SOFTIRQ", 5 },
+        { "SCHED_SOFTIRQ", 6 },
+        { "HRTIMER_SOFTIRQ", 7 },
+        { "RCU_SOFTIRQ", 8 },
+
+        { "HRTIMER_NORESTART", 0 },
+        { "HRTIMER_RESTART", 1 },
+};
+
+static unsigned long long eval_flag(const char *flag)
+{
+        int i;
+
+        /*
+         * Some flags in the format files do not get converted.
+         * If the flag is not numeric, see if it is something that
+         * we already know about.
+         */
+        if (isdigit(flag[0]))
+                return strtoull(flag, NULL, 0);
+
+        for (i = 0; i < (int)(sizeof(flags)/sizeof(flags[0])); i++)
+                if (strcmp(flags[i].name, flag) == 0)
+                        return flags[i].value;
+
+        return 0;
+}
+
+static void print_str_arg(void *data, int size,
+                          struct event *event, struct print_arg *arg)
+{
+        struct print_flag_sym *flag;
+        unsigned long long val, fval;
+        char *str;
+        int print;
+
+        switch (arg->type) {
+        case PRINT_NULL:
+                /* ?? */
+                return;
+        case PRINT_ATOM:
+                printf("%s", arg->atom.atom);
+                return;
+        case PRINT_FIELD:
+                if (!arg->field.field) {
+                        arg->field.field = find_any_field(event, arg->field.name);
+                        if (!arg->field.field)
+                                die("field %s not found", arg->field.name);
+                }
+                str = malloc_or_die(arg->field.field->size + 1);
+                memcpy(str, data + arg->field.field->offset,
+                       arg->field.field->size);
+                str[arg->field.field->size] = 0;
+                printf("%s", str);
+                free(str);
+                break;
+        case PRINT_FLAGS:
+                val = eval_num_arg(data, size, event, arg->flags.field);
+                print = 0;
+                for (flag = arg->flags.flags; flag; flag = flag->next) {
+                        fval = eval_flag(flag->value);
+                        if (!val && !fval) {
+                                printf("%s", flag->str);
+                                break;
+                        }
+                        if (fval && (val & fval) == fval) {
+                                if (print && arg->flags.delim)
+                                        printf("%s", arg->flags.delim);
+                                printf("%s", flag->str);
+                                print = 1;
+                                val &= ~fval;
+                        }
+                }
+                break;
+        case PRINT_SYMBOL:
+                val = eval_num_arg(data, size, event, arg->symbol.field);
+                for (flag = arg->symbol.symbols; flag; flag = flag->next) {
+                        fval = eval_flag(flag->value);
+                        if (val == fval) {
+                                printf("%s", flag->str);
+                                break;
+                        }
+                }
+                break;
+
+        case PRINT_TYPE:
+                break;
+        case PRINT_STRING: {
+                int str_offset;
+
+                if (arg->string.offset == -1) {
+                        struct format_field *f;
+
+                        f = find_any_field(event, arg->string.string);
+                        arg->string.offset = f->offset;
+                }
+                str_offset = *(int *)(data + arg->string.offset);
+                str_offset &= 0xffff;
+                printf("%s", ((char *)data) + str_offset);
+                break;
+        }
+        case PRINT_OP:
+                /*
+                 * The only op for string should be ? :
+                 */
+                if (arg->op.op[0] != '?')
+                        return;
+                val = eval_num_arg(data, size, event, arg->op.left);
+                if (val)
+                        print_str_arg(data, size, event, arg->op.right->op.left);
+                else
+                        print_str_arg(data, size, event, arg->op.right->op.right);
+                break;
+        default:
+                /* well... */
+                break;
+        }
+}
+
+static struct print_arg *make_bprint_args(char *fmt, void *data, int size, struct event *event)
+{
+        static struct format_field *field, *ip_field;
+        struct print_arg *args, *arg, **next;
+        unsigned long long ip, val;
+        char *ptr;
+        void *bptr;
+
+        if (!field) {
+                field = find_field(event, "buf");
+                if (!field)
+                        die("can't find buffer field for binary printk");
+                ip_field = find_field(event, "ip");
+                if (!ip_field)
+                        die("can't find ip field for binary printk");
+        }
+
+        ip = read_size(data + ip_field->offset, ip_field->size);
+
+        /*
+         * The first arg is the IP pointer.
+         */
+        args = malloc_or_die(sizeof(*args));
+        arg = args;
+        arg->next = NULL;
+        next = &arg->next;
+
+        arg->type = PRINT_ATOM;
+        arg->atom.atom = malloc_or_die(32);
+        sprintf(arg->atom.atom, "%lld", ip);
+
+        /* skip the first "%pf : " */
+        for (ptr = fmt + 6, bptr = data + field->offset;
+             bptr < data + size && *ptr; ptr++) {
+                int ls = 0;
+
+                if (*ptr == '%') {
+ process_again:
+                        ptr++;
+                        switch (*ptr) {
+                        case '%':
+                                break;
+                        case 'l':
+                                ls++;
+                                goto process_again;
+                        case 'L':
+                                ls = 2;
+                                goto process_again;
+                        case '0' ... '9':
+                                goto process_again;
+                        case 'p':
+                                ls = 1;
+                                /* fall through */
+                        case 'd':
+                        case 'u':
+                        case 'x':
+                        case 'i':
+                                bptr = (void *)(((unsigned long)bptr + (long_size - 1)) &
+                                                ~(long_size - 1));
+                                switch (ls) {
+                                case 0:
+                                case 1:
+                                        ls = long_size;
+                                        break;
+                                case 2:
+                                        ls = 8;
+                                default:
+                                        break;
+                                }
+                                val = read_size(bptr, ls);
+                                bptr += ls;
+                                arg = malloc_or_die(sizeof(*arg));
+                                arg->next = NULL;
+                                arg->type = PRINT_ATOM;
+                                arg->atom.atom = malloc_or_die(32);
+                                sprintf(arg->atom.atom, "%lld", val);
+                                *next = arg;
+                                next = &arg->next;
+                                break;
+                        case 's':
+                                arg = malloc_or_die(sizeof(*arg));
+                                arg->next = NULL;
+                                arg->type = PRINT_STRING;
+                                arg->string.string = strdup(bptr);
+                                bptr += strlen(bptr) + 1;
+                                *next = arg;
+                                next = &arg->next;
+                        default:
+                                break;
+                        }
+                }
+        }
+
+        return args;
+}
+
+static void free_args(struct print_arg *args)
+{
+        struct print_arg *next;
+
+        while (args) {
+                next = args->next;
+
+                if (args->type == PRINT_ATOM)
+                        free(args->atom.atom);
+                else
+                        free(args->string.string);
+                free(args);
+                args = next;
+        }
+}
+
+static char *get_bprint_format(void *data, int size __unused, struct event *event)
+{
+        unsigned long long addr;
+        static struct format_field *field;
+        struct printk_map *printk;
+        char *format;
+        char *p;
+
+        if (!field) {
+                field = find_field(event, "fmt");
+                if (!field)
+                        die("can't find format field for binary printk");
+                printf("field->offset = %d size=%d\n", field->offset, field->size);
+        }
+
+        addr = read_size(data + field->offset, field->size);
+
+        printk = find_printk(addr);
+        if (!printk) {
+                format = malloc_or_die(45);
+                sprintf(format, "%%pf : (NO FORMAT FOUND at %llx)\n",
+                        addr);
+                return format;
+        }
+
+        p = printk->printk;
+        /* Remove any quotes. */
+        if (*p == '"')
+                p++;
+        format = malloc_or_die(strlen(p) + 10);
+        sprintf(format, "%s : %s", "%pf", p);
+        /* remove ending quotes and new line since we will add one too */
+        p = format + strlen(format) - 1;
+        if (*p == '"')
+                *p = 0;
+
+        p -= 2;
+        if (strcmp(p, "\\n") == 0)
+                *p = 0;
+
+        return format;
+}
+
+static void pretty_print(void *data, int size, struct event *event)
+{
+        struct print_fmt *print_fmt = &event->print_fmt;
+        struct print_arg *arg = print_fmt->args;
+        struct print_arg *args = NULL;
+        const char *ptr = print_fmt->format;
+        unsigned long long val;
+        struct func_map *func;
+        const char *saveptr;
+        char *bprint_fmt = NULL;
+        char format[32];
+        int show_func;
+        int len;
+        int ls;
+
+        if (event->flags & EVENT_FL_ISFUNC)
+                ptr = " %pF <-- %pF";
+
+        if (event->flags & EVENT_FL_ISBPRINT) {
+                bprint_fmt = get_bprint_format(data, size, event);
+                args = make_bprint_args(bprint_fmt, data, size, event);
+                arg = args;
+                ptr = bprint_fmt;
+        }
+
+        for (; *ptr; ptr++) {
+                ls = 0;
+                if (*ptr == '%') {
+                        saveptr = ptr;
+                        show_func = 0;
+ cont_process:
+                        ptr++;
+                        switch (*ptr) {
+                        case '%':
+                                printf("%%");
+                                break;
+                        case 'l':
+                                ls++;
+                                goto cont_process;
+                        case 'L':
+                                ls = 2;
+                                goto cont_process;
+                        case 'z':
+                        case 'Z':
+                        case '0' ... '9':
+                                goto cont_process;
+                        case 'p':
+                                if (long_size == 4)
+                                        ls = 1;
+                                else
+                                        ls = 2;
+
+                                if (*(ptr+1) == 'F' ||
+                                    *(ptr+1) == 'f') {
+                                        ptr++;
+                                        show_func = *ptr;
+                                }
+
+                                /* fall through */
+                        case 'd':
+                        case 'i':
+                        case 'x':
+                        case 'X':
+                        case 'u':
+                                if (!arg)
+                                        die("no argument match");
+
+                                len = ((unsigned long)ptr + 1) -
+                                        (unsigned long)saveptr;
+
+                                /* should never happen */
+                                if (len > 32)
+                                        die("bad format!");
+
+                                memcpy(format, saveptr, len);
+                                format[len] = 0;
+
+                                val = eval_num_arg(data, size, event, arg);
+                                arg = arg->next;
+
+                                if (show_func) {
+                                        func = find_func(val);
+                                        if (func) {
+                                                printf("%s", func->func);
+                                                if (show_func == 'F')
+                                                        printf("+0x%llx",
+                                                               val - func->addr);
+                                                break;
+                                        }
+                                }
+                                switch (ls) {
+                                case 0:
+                                        printf(format, (int)val);
+                                        break;
+                                case 1:
+                                        printf(format, (long)val);
+                                        break;
+                                case 2:
+                                        printf(format, (long long)val);
+                                        break;
+                                default:
+                                        die("bad count (%d)", ls);
+                                }
+                                break;
+                        case 's':
+                                if (!arg)
+                                        die("no matching argument");
+
+                                print_str_arg(data, size, event, arg);
+                                arg = arg->next;
+                                break;
+                        default:
+                                printf(">%c<", *ptr);
+
+                        }
+                } else
+                        printf("%c", *ptr);
+        }
+
+        if (args) {
+                free_args(args);
+                free(bprint_fmt);
+        }
+}
+
+static inline int log10_cpu(int nb)
+{
+        if (nb / 100)
+                return 3;
+        if (nb / 10)
+                return 2;
+        return 1;
+}
+
+/* taken from Linux, written by Frederic Weisbecker */
+static void print_graph_cpu(int cpu)
+{
+        int i;
+        int log10_this = log10_cpu(cpu);
+        int log10_all = log10_cpu(cpus);
+
+
+        /*
+         * Start with a space character - to make it stand out
+         * to the right a bit when trace output is pasted into
+         * email:
+         */
+        printf(" ");
+
+        /*
+         * Tricky - we space the CPU field according to the max
+         * number of online CPUs. On a 2-cpu system it would take
+         * a maximum of 1 digit - on a 128 cpu system it would
+         * take up to 3 digits:
+         */
+        for (i = 0; i < log10_all - log10_this; i++)
+                printf(" ");
+
+        printf("%d) ", cpu);
+}
+
+#define TRACE_GRAPH_PROCINFO_LENGTH     14
+#define TRACE_GRAPH_INDENT      2
+
+static void print_graph_proc(int pid, const char *comm)
+{
+        /* sign + log10(MAX_INT) + '\0' */
+        char pid_str[11];
+        int spaces = 0;
+        int len;
+        int i;
+
+        sprintf(pid_str, "%d", pid);
+
+        /* 1 stands for the "-" character */
+        len = strlen(comm) + strlen(pid_str) + 1;
+
+        if (len < TRACE_GRAPH_PROCINFO_LENGTH)
+                spaces = TRACE_GRAPH_PROCINFO_LENGTH - len;
+
+        /* First spaces to align center */
+        for (i = 0; i < spaces / 2; i++)
+                printf(" ");
+
+        printf("%s-%s", comm, pid_str);
+
+        /* Last spaces to align center */
+        for (i = 0; i < spaces - (spaces / 2); i++)
+                printf(" ");
+}
+
+static struct record *
+get_return_for_leaf(int cpu, int cur_pid, unsigned long long cur_func,
+                    struct record *next)
+{
+        struct format_field *field;
+        struct event *event;
+        unsigned long val;
+        int type;
+        int pid;
+
+        type = parse_common_type(next->data);
+        event = find_event(type);
+        if (!event)
+                return NULL;
+
+        if (!(event->flags & EVENT_FL_ISFUNCRET))
+                return NULL;
+
+        pid = parse_common_pid(next->data);
+        field = find_field(event, "func");
+        if (!field)
+                die("function return does not have field func");
+
+        val = read_size(next->data + field->offset, field->size);
+
+        if (cur_pid != pid || cur_func != val)
+                return NULL;
+
+        /* this is a leaf, now advance the iterator */
+        return trace_read_data(cpu);
+}
+
+/* Signal a overhead of time execution to the output */
+static void print_graph_overhead(unsigned long long duration)
+{
+        /* Non nested entry or return */
+        if (duration == ~0ULL)
+                return (void)printf("  ");
+
+        /* Duration exceeded 100 msecs */
+        if (duration > 100000ULL)
+                return (void)printf("! ");
+
+        /* Duration exceeded 10 msecs */
+        if (duration > 10000ULL)
+                return (void)printf("+ ");
+
+        printf("  ");
+}
+
+static void print_graph_duration(unsigned long long duration)
+{
+        unsigned long usecs = duration / 1000;
+        unsigned long nsecs_rem = duration % 1000;
+        /* log10(ULONG_MAX) + '\0' */
+        char msecs_str[21];
+        char nsecs_str[5];
+        int len;
+        int i;
+
+        sprintf(msecs_str, "%lu", usecs);
+
+        /* Print msecs */
+        len = printf("%lu", usecs);
+
+        /* Print nsecs (we don't want to exceed 7 numbers) */
+        if (len < 7) {
+                snprintf(nsecs_str, 8 - len, "%03lu", nsecs_rem);
+                len += printf(".%s", nsecs_str);
+        }
+
+        printf(" us ");
+
+        /* Print remaining spaces to fit the row's width */
+        for (i = len; i < 7; i++)
+                printf(" ");
+
+        printf("|  ");
+}
+
+static void
+print_graph_entry_leaf(struct event *event, void *data, struct record *ret_rec)
+{
+        unsigned long long rettime, calltime;
+        unsigned long long duration, depth;
+        unsigned long long val;
+        struct format_field *field;
+        struct func_map *func;
+        struct event *ret_event;
+        int type;
+        int i;
+
+        type = parse_common_type(ret_rec->data);
+        ret_event = find_event(type);
+
+        field = find_field(ret_event, "rettime");
+        if (!field)
+                die("can't find rettime in return graph");
+        rettime = read_size(ret_rec->data + field->offset, field->size);
+
+        field = find_field(ret_event, "calltime");
+        if (!field)
+                die("can't find rettime in return graph");
+        calltime = read_size(ret_rec->data + field->offset, field->size);
+
+        duration = rettime - calltime;
+
+        /* Overhead */
+        print_graph_overhead(duration);
+
+        /* Duration */
+        print_graph_duration(duration);
+
+        field = find_field(event, "depth");
+        if (!field)
+                die("can't find depth in entry graph");
+        depth = read_size(data + field->offset, field->size);
+
+        /* Function */
+        for (i = 0; i < (int)(depth * TRACE_GRAPH_INDENT); i++)
+                printf(" ");
+
+        field = find_field(event, "func");
+        if (!field)
+                die("can't find func in entry graph");
+        val = read_size(data + field->offset, field->size);
+        func = find_func(val);
+
+        if (func)
+                printf("%s();", func->func);
+        else
+                printf("%llx();", val);
+}
+
+static void print_graph_nested(struct event *event, void *data)
+{
+        struct format_field *field;
+        unsigned long long depth;
+        unsigned long long val;
+        struct func_map *func;
+        int i;
+
+        /* No overhead */
+        print_graph_overhead(-1);
+
+        /* No time */
+        printf("           |  ");
+
+        field = find_field(event, "depth");
+        if (!field)
+                die("can't find depth in entry graph");
+        depth = read_size(data + field->offset, field->size);
+
+        /* Function */
+        for (i = 0; i < (int)(depth * TRACE_GRAPH_INDENT); i++)
+                printf(" ");
+
+        field = find_field(event, "func");
+        if (!field)
+                die("can't find func in entry graph");
+        val = read_size(data + field->offset, field->size);
+        func = find_func(val);
+
+        if (func)
+                printf("%s() {", func->func);
+        else
+                printf("%llx() {", val);
+}
+
+static void
+pretty_print_func_ent(void *data, int size, struct event *event,
+                      int cpu, int pid, const char *comm,
+                      unsigned long secs, unsigned long usecs)
+{
+        struct format_field *field;
+        struct record *rec;
+        void *copy_data;
+        unsigned long val;
+
+        printf("%5lu.%06lu |  ", secs, usecs);
+
+        print_graph_cpu(cpu);
+        print_graph_proc(pid, comm);
+
+        printf(" | ");
+
+        field = find_field(event, "func");
+        if (!field)
+                die("function entry does not have func field");
+
+        val = read_size(data + field->offset, field->size);
+
+        /*
+         * peek_data may unmap the data pointer. Copy it first.
+         */
+        copy_data = malloc_or_die(size);
+        memcpy(copy_data, data, size);
+        data = copy_data;
+
+        rec = trace_peek_data(cpu);
+        if (rec) {
+                rec = get_return_for_leaf(cpu, pid, val, rec);
+                if (rec) {
+                        print_graph_entry_leaf(event, data, rec);
+                        goto out_free;
+                }
+        }
+        print_graph_nested(event, data);
+out_free:
+        free(data);
+}
+
+static void
+pretty_print_func_ret(void *data, int size __unused, struct event *event,
+                      int cpu, int pid, const char *comm,
+                      unsigned long secs, unsigned long usecs)
+{
+        unsigned long long rettime, calltime;
+        unsigned long long duration, depth;
+        struct format_field *field;
+        int i;
+
+        printf("%5lu.%06lu |  ", secs, usecs);
+
+        print_graph_cpu(cpu);
+        print_graph_proc(pid, comm);
+
+        printf(" | ");
+
+        field = find_field(event, "rettime");
+        if (!field)
+                die("can't find rettime in return graph");
+        rettime = read_size(data + field->offset, field->size);
+
+        field = find_field(event, "calltime");
+        if (!field)
+                die("can't find calltime in return graph");
+        calltime = read_size(data + field->offset, field->size);
+
+        duration = rettime - calltime;
+
+        /* Overhead */
+        print_graph_overhead(duration);
+
+        /* Duration */
+        print_graph_duration(duration);
+
+        field = find_field(event, "depth");
+        if (!field)
+                die("can't find depth in entry graph");
+        depth = read_size(data + field->offset, field->size);
+
+        /* Function */
+        for (i = 0; i < (int)(depth * TRACE_GRAPH_INDENT); i++)
+                printf(" ");
+
+        printf("}");
+}
+
+static void
+pretty_print_func_graph(void *data, int size, struct event *event,
+                        int cpu, int pid, const char *comm,
+                        unsigned long secs, unsigned long usecs)
+{
+        if (event->flags & EVENT_FL_ISFUNCENT)
+                pretty_print_func_ent(data, size, event,
+                                      cpu, pid, comm, secs, usecs);
+        else if (event->flags & EVENT_FL_ISFUNCRET)
+                pretty_print_func_ret(data, size, event,
+                                      cpu, pid, comm, secs, usecs);
+        printf("\n");
+}
+
+void print_event(int cpu, void *data, int size, unsigned long long nsecs,
+                  char *comm)
+{
+        struct event *event;
+        unsigned long secs;
+        unsigned long usecs;
+        int type;
+        int pid;
+
+        secs = nsecs / NSECS_PER_SEC;
+        nsecs -= secs * NSECS_PER_SEC;
+        usecs = nsecs / NSECS_PER_USEC;
+
+        type = parse_common_type(data);
+
+        event = find_event(type);
+        if (!event)
+                die("ug! no event found for type %d", type);
+
+        pid = parse_common_pid(data);
+
+        if (event->flags & (EVENT_FL_ISFUNCENT | EVENT_FL_ISFUNCRET))
+                return pretty_print_func_graph(data, size, event, cpu,
+                                               pid, comm, secs, usecs);
+
+        printf("%16s-%-5d [%03d] %5lu.%09Lu: %s: ",
+               comm, pid,  cpu,
+               secs, nsecs, event->name);
+
+        pretty_print(data, size, event);
+        printf("\n");
+}
+
+static void print_fields(struct print_flag_sym *field)
+{
+        printf("{ %s, %s }", field->value, field->str);
+        if (field->next) {
+                printf(", ");
+                print_fields(field->next);
+        }
+}
+
+static void print_args(struct print_arg *args)
+{
+        int print_paren = 1;
+
+        switch (args->type) {
+        case PRINT_NULL:
+                printf("null");
+                break;
+        case PRINT_ATOM:
+                printf("%s", args->atom.atom);
+                break;
+        case PRINT_FIELD:
+                printf("REC->%s", args->field.name);
+                break;
+        case PRINT_FLAGS:
+                printf("__print_flags(");
+                print_args(args->flags.field);
+                printf(", %s, ", args->flags.delim);
+                print_fields(args->flags.flags);
+                printf(")");
+                break;
+        case PRINT_SYMBOL:
+                printf("__print_symbolic(");
+                print_args(args->symbol.field);
+                printf(", ");
+                print_fields(args->symbol.symbols);
+                printf(")");
+                break;
+        case PRINT_STRING:
+                printf("__get_str(%s)", args->string.string);
+                break;
+        case PRINT_TYPE:
+                printf("(%s)", args->typecast.type);
+                print_args(args->typecast.item);
+                break;
+        case PRINT_OP:
+                if (strcmp(args->op.op, ":") == 0)
+                        print_paren = 0;
+                if (print_paren)
+                        printf("(");
+                print_args(args->op.left);
+                printf(" %s ", args->op.op);
+                print_args(args->op.right);
+                if (print_paren)
+                        printf(")");
+                break;
+        default:
+                /* we should warn... */
+                return;
+        }
+        if (args->next) {
+                printf("\n");
+                print_args(args->next);
+        }
+}
+
+static void parse_header_field(char *type,
+                               int *offset, int *size)
+{
+        char *token;
+
+        if (read_expected(EVENT_ITEM, (char *)"field") < 0)
+                return;
+        if (read_expected(EVENT_OP, (char *)":") < 0)
+                return;
+        /* type */
+        if (read_expect_type(EVENT_ITEM, &token) < 0)
+                return;
+        free_token(token);
+
+        if (read_expected(EVENT_ITEM, type) < 0)
+                return;
+        if (read_expected(EVENT_OP, (char *)";") < 0)
+                return;
+        if (read_expected(EVENT_ITEM, (char *)"offset") < 0)
+                return;
+        if (read_expected(EVENT_OP, (char *)":") < 0)
+                return;
+        if (read_expect_type(EVENT_ITEM, &token) < 0)
+                return;
+        *offset = atoi(token);
+        free_token(token);
+        if (read_expected(EVENT_OP, (char *)";") < 0)
+                return;
+        if (read_expected(EVENT_ITEM, (char *)"size") < 0)
+                return;
+        if (read_expected(EVENT_OP, (char *)":") < 0)
+                return;
+        if (read_expect_type(EVENT_ITEM, &token) < 0)
+                return;
+        *size = atoi(token);
+        free_token(token);
+        if (read_expected(EVENT_OP, (char *)";") < 0)
+                return;
+        if (read_expect_type(EVENT_NEWLINE, &token) < 0)
+                return;
+        free_token(token);
+}
+
+int parse_header_page(char *buf, unsigned long size)
+{
+        init_input_buf(buf, size);
+
+        parse_header_field((char *)"timestamp", &header_page_ts_offset,
+                           &header_page_ts_size);
+        parse_header_field((char *)"commit", &header_page_size_offset,
+                           &header_page_size_size);
+        parse_header_field((char *)"data", &header_page_data_offset,
+                           &header_page_data_size);
+
+        return 0;
+}
+
+int parse_ftrace_file(char *buf, unsigned long size)
+{
+        struct format_field *field;
+        struct print_arg *arg, **list;
+        struct event *event;
+        int ret;
+
+        init_input_buf(buf, size);
+
+        event = alloc_event();
+        if (!event)
+                return -ENOMEM;
+
+        event->flags |= EVENT_FL_ISFTRACE;
+
+        event->name = event_read_name();
+        if (!event->name)
+                die("failed to read ftrace event name");
+
+        if (strcmp(event->name, "function") == 0)
+                event->flags |= EVENT_FL_ISFUNC;
+
+        else if (strcmp(event->name, "funcgraph_entry") == 0)
+                event->flags |= EVENT_FL_ISFUNCENT;
+
+        else if (strcmp(event->name, "funcgraph_exit") == 0)
+                event->flags |= EVENT_FL_ISFUNCRET;
+
+        else if (strcmp(event->name, "bprint") == 0)
+                event->flags |= EVENT_FL_ISBPRINT;
+
+        event->id = event_read_id();
+        if (event->id < 0)
+                die("failed to read ftrace event id");
+
+        add_event(event);
+
+        ret = event_read_format(event);
+        if (ret < 0)
+                die("failed to read ftrace event format");
+
+        ret = event_read_print(event);
+        if (ret < 0)
+                die("failed to read ftrace event print fmt");
+
+        /*
+         * The arguments for ftrace files are parsed by the fields.
+         * Set up the fields as their arguments.
+         */
+        list = &event->print_fmt.args;
+        for (field = event->format.fields; field; field = field->next) {
+                arg = malloc_or_die(sizeof(*arg));
+                memset(arg, 0, sizeof(*arg));
+                *list = arg;
+                list = &arg->next;
+                arg->type = PRINT_FIELD;
+                arg->field.name = field->name;
+                arg->field.field = field;
+        }
+        return 0;
+}
+
+int parse_event_file(char *buf, unsigned long size, char *system__unused __unused)
+{
+        struct event *event;
+        int ret;
+
+        init_input_buf(buf, size);
+
+        event = alloc_event();
+        if (!event)
+                return -ENOMEM;
+
+        event->name = event_read_name();
+        if (!event->name)
+                die("failed to read event name");
+
+        event->id = event_read_id();
+        if (event->id < 0)
+                die("failed to read event id");
+
+        ret = event_read_format(event);
+        if (ret < 0)
+                die("failed to read event format");
+
+        ret = event_read_print(event);
+        if (ret < 0)
+                die("failed to read event print fmt");
+
+#define PRINT_ARGS 0
+        if (PRINT_ARGS && event->print_fmt.args)
+                print_args(event->print_fmt.args);
+
+        add_event(event);
+        return 0;
+}
+
+void parse_set_info(int nr_cpus, int long_sz)
+{
+        cpus = nr_cpus;
+        long_size = long_sz;
+}
diff --git a/tools/perf/util/trace-event-read.c b/tools/perf/util/trace-event-read.c
new file mode 100644
index 000000000000..a1217a10632f
--- /dev/null
+++ b/tools/perf/util/trace-event-read.c
@@ -0,0 +1,512 @@
+/*
+ * Copyright (C) 2009, Steven Rostedt <srostedt@redhat.com>
+ *
+ * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; version 2 of the License (not later!)
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ *
+ * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+ */
+#define _LARGEFILE64_SOURCE
+
+#include <dirent.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <getopt.h>
+#include <stdarg.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <sys/wait.h>
+#include <sys/mman.h>
+#include <pthread.h>
+#include <fcntl.h>
+#include <unistd.h>
+#include <ctype.h>
+#include <errno.h>
+
+#include "../perf.h"
+#include "util.h"
+#include "trace-event.h"
+
+static int input_fd;
+
+static int read_page;
+
+int file_bigendian;
+int host_bigendian;
+static int long_size;
+
+static unsigned long    page_size;
+
+static int read_or_die(void *data, int size)
+{
+        int r;
+
+        r = read(input_fd, data, size);
+        if (r != size)
+                die("reading input file (size expected=%d received=%d)",
+                    size, r);
+        return r;
+}
+
+static unsigned int read4(void)
+{
+        unsigned int data;
+
+        read_or_die(&data, 4);
+        return __data2host4(data);
+}
+
+static unsigned long long read8(void)
+{
+        unsigned long long data;
+
+        read_or_die(&data, 8);
+        return __data2host8(data);
+}
+
+static char *read_string(void)
+{
+        char buf[BUFSIZ];
+        char *str = NULL;
+        int size = 0;
+        int i;
+        int r;
+
+        for (;;) {
+                r = read(input_fd, buf, BUFSIZ);
+                if (r < 0)
+                        die("reading input file");
+
+                if (!r)
+                        die("no data");
+
+                for (i = 0; i < r; i++) {
+                        if (!buf[i])
+                                break;
+                }
+                if (i < r)
+                        break;
+
+                if (str) {
+                        size += BUFSIZ;
+                        str = realloc(str, size);
+                        if (!str)
+                                die("malloc of size %d", size);
+                        memcpy(str + (size - BUFSIZ), buf, BUFSIZ);
+                } else {
+                        size = BUFSIZ;
+                        str = malloc_or_die(size);
+                        memcpy(str, buf, size);
+                }
+        }
+
+        /* trailing \0: */
+        i++;
+
+        /* move the file descriptor to the end of the string */
+        r = lseek(input_fd, -(r - i), SEEK_CUR);
+        if (r < 0)
+                die("lseek");
+
+        if (str) {
+                size += i;
+                str = realloc(str, size);
+                if (!str)
+                        die("malloc of size %d", size);
+                memcpy(str + (size - i), buf, i);
+        } else {
+                size = i;
+                str = malloc_or_die(i);
+                memcpy(str, buf, i);
+        }
+
+        return str;
+}
+
+static void read_proc_kallsyms(void)
+{
+        unsigned int size;
+        char *buf;
+
+        size = read4();
+        if (!size)
+                return;
+
+        buf = malloc_or_die(size);
+        read_or_die(buf, size);
+
+        parse_proc_kallsyms(buf, size);
+
+        free(buf);
+}
+
+static void read_ftrace_printk(void)
+{
+        unsigned int size;
+        char *buf;
+
+        size = read4();
+        if (!size)
+                return;
+
+        buf = malloc_or_die(size);
+        read_or_die(buf, size);
+
+        parse_ftrace_printk(buf, size);
+
+        free(buf);
+}
+
+static void read_header_files(void)
+{
+        unsigned long long size;
+        char *header_page;
+        char *header_event;
+        char buf[BUFSIZ];
+
+        read_or_die(buf, 12);
+
+        if (memcmp(buf, "header_page", 12) != 0)
+                die("did not read header page");
+
+        size = read8();
+        header_page = malloc_or_die(size);
+        read_or_die(header_page, size);
+        parse_header_page(header_page, size);
+        free(header_page);
+
+        /*
+         * The size field in the page is of type long,
+         * use that instead, since it represents the kernel.
+         */
+        long_size = header_page_size_size;
+
+        read_or_die(buf, 13);
+        if (memcmp(buf, "header_event", 13) != 0)
+                die("did not read header event");
+
+        size = read8();
+        header_event = malloc_or_die(size);
+        read_or_die(header_event, size);
+        free(header_event);
+}
+
+static void read_ftrace_file(unsigned long long size)
+{
+        char *buf;
+
+        buf = malloc_or_die(size);
+        read_or_die(buf, size);
+        parse_ftrace_file(buf, size);
+        free(buf);
+}
+
+static void read_event_file(char *sys, unsigned long long size)
+{
+        char *buf;
+
+        buf = malloc_or_die(size);
+        read_or_die(buf, size);
+        parse_event_file(buf, size, sys);
+        free(buf);
+}
+
+static void read_ftrace_files(void)
+{
+        unsigned long long size;
+        int count;
+        int i;
+
+        count = read4();
+
+        for (i = 0; i < count; i++) {
+                size = read8();
+                read_ftrace_file(size);
+        }
+}
+
+static void read_event_files(void)
+{
+        unsigned long long size;
+        char *sys;
+        int systems;
+        int count;
+        int i,x;
+
+        systems = read4();
+
+        for (i = 0; i < systems; i++) {
+                sys = read_string();
+
+                count = read4();
+                for (x=0; x < count; x++) {
+                        size = read8();
+                        read_event_file(sys, size);
+                }
+        }
+}
+
+struct cpu_data {
+        unsigned long long      offset;
+        unsigned long long      size;
+        unsigned long long      timestamp;
+        struct record           *next;
+        char                    *page;
+        int                     cpu;
+        int                     index;
+        int                     page_size;
+};
+
+static struct cpu_data *cpu_data;
+
+static void update_cpu_data_index(int cpu)
+{
+        cpu_data[cpu].offset += page_size;
+        cpu_data[cpu].size -= page_size;
+        cpu_data[cpu].index = 0;
+}
+
+static void get_next_page(int cpu)
+{
+        off64_t save_seek;
+        off64_t ret;
+
+        if (!cpu_data[cpu].page)
+                return;
+
+        if (read_page) {
+                if (cpu_data[cpu].size <= page_size) {
+                        free(cpu_data[cpu].page);
+                        cpu_data[cpu].page = NULL;
+                        return;
+                }
+
+                update_cpu_data_index(cpu);
+
+                /* other parts of the code may expect the pointer to not move */
+                save_seek = lseek64(input_fd, 0, SEEK_CUR);
+
+                ret = lseek64(input_fd, cpu_data[cpu].offset, SEEK_SET);
+                if (ret < 0)
+                        die("failed to lseek");
+                ret = read(input_fd, cpu_data[cpu].page, page_size);
+                if (ret < 0)
+                        die("failed to read page");
+
+                /* reset the file pointer back */
+                lseek64(input_fd, save_seek, SEEK_SET);
+
+                return;
+        }
+
+        munmap(cpu_data[cpu].page, page_size);
+        cpu_data[cpu].page = NULL;
+
+        if (cpu_data[cpu].size <= page_size)
+                return;
+
+        update_cpu_data_index(cpu);
+
+        cpu_data[cpu].page = mmap(NULL, page_size, PROT_READ, MAP_PRIVATE,
+                                  input_fd, cpu_data[cpu].offset);
+        if (cpu_data[cpu].page == MAP_FAILED)
+                die("failed to mmap cpu %d at offset 0x%llx",
+                    cpu, cpu_data[cpu].offset);
+}
+
+static unsigned int type_len4host(unsigned int type_len_ts)
+{
+        if (file_bigendian)
+                return (type_len_ts >> 27) & ((1 << 5) - 1);
+        else
+                return type_len_ts & ((1 << 5) - 1);
+}
+
+static unsigned int ts4host(unsigned int type_len_ts)
+{
+        if (file_bigendian)
+                return type_len_ts & ((1 << 27) - 1);
+        else
+                return type_len_ts >> 5;
+}
+
+static int calc_index(void *ptr, int cpu)
+{
+        return (unsigned long)ptr - (unsigned long)cpu_data[cpu].page;
+}
+
+struct record *trace_peek_data(int cpu)
+{
+        struct record *data;
+        void *page = cpu_data[cpu].page;
+        int idx = cpu_data[cpu].index;
+        void *ptr = page + idx;
+        unsigned long long extend;
+        unsigned int type_len_ts;
+        unsigned int type_len;
+        unsigned int delta;
+        unsigned int length = 0;
+
+        if (cpu_data[cpu].next)
+                return cpu_data[cpu].next;
+
+        if (!page)
+                return NULL;
+
+        if (!idx) {
+                /* FIXME: handle header page */
+                if (header_page_ts_size != 8)
+                        die("expected a long long type for timestamp");
+                cpu_data[cpu].timestamp = data2host8(ptr);
+                ptr += 8;
+                switch (header_page_size_size) {
+                case 4:
+                        cpu_data[cpu].page_size = data2host4(ptr);
+                        ptr += 4;
+                        break;
+                case 8:
+                        cpu_data[cpu].page_size = data2host8(ptr);
+                        ptr += 8;
+                        break;
+                default:
+                        die("bad long size");
+                }
+                ptr = cpu_data[cpu].page + header_page_data_offset;
+        }
+
+read_again:
+        idx = calc_index(ptr, cpu);
+
+        if (idx >= cpu_data[cpu].page_size) {
+                get_next_page(cpu);
+                return trace_peek_data(cpu);
+        }
+
+        type_len_ts = data2host4(ptr);
+        ptr += 4;
+
+        type_len = type_len4host(type_len_ts);
+        delta = ts4host(type_len_ts);
+
+        switch (type_len) {
+        case RINGBUF_TYPE_PADDING:
+                if (!delta)
+                        die("error, hit unexpected end of page");
+                length = data2host4(ptr);
+                ptr += 4;
+                length *= 4;
+                ptr += length;
+                goto read_again;
+
+        case RINGBUF_TYPE_TIME_EXTEND:
+                extend = data2host4(ptr);
+                ptr += 4;
+                extend <<= TS_SHIFT;
+                extend += delta;
+                cpu_data[cpu].timestamp += extend;
+                goto read_again;
+
+        case RINGBUF_TYPE_TIME_STAMP:
+                ptr += 12;
+                break;
+        case 0:
+                length = data2host4(ptr);
+                ptr += 4;
+                die("here! length=%d", length);
+                break;
+        default:
+                length = type_len * 4;
+                break;
+        }
+
+        cpu_data[cpu].timestamp += delta;
+
+        data = malloc_or_die(sizeof(*data));
+        memset(data, 0, sizeof(*data));
+
+        data->ts = cpu_data[cpu].timestamp;
+        data->size = length;
+        data->data = ptr;
+        ptr += length;
+
+        cpu_data[cpu].index = calc_index(ptr, cpu);
+        cpu_data[cpu].next = data;
+
+        return data;
+}
+
+struct record *trace_read_data(int cpu)
+{
+        struct record *data;
+
+        data = trace_peek_data(cpu);
+        cpu_data[cpu].next = NULL;
+
+        return data;
+}
+
+void trace_report (void)
+{
+        const char *input_file = "trace.info";
+        char buf[BUFSIZ];
+        char test[] = { 23, 8, 68 };
+        char *version;
+        int show_funcs = 0;
+        int show_printk = 0;
+
+        input_fd = open(input_file, O_RDONLY);
+        if (input_fd < 0)
+                die("opening '%s'\n", input_file);
+
+        read_or_die(buf, 3);
+        if (memcmp(buf, test, 3) != 0)
+                die("not an trace data file");
+
+        read_or_die(buf, 7);
+        if (memcmp(buf, "tracing", 7) != 0)
+                die("not a trace file (missing tracing)");
+
+        version = read_string();
+        printf("version = %s\n", version);
+        free(version);
+
+        read_or_die(buf, 1);
+        file_bigendian = buf[0];
+        host_bigendian = bigendian();
+
+        read_or_die(buf, 1);
+        long_size = buf[0];
+
+        page_size = read4();
+
+        read_header_files();
+
+        read_ftrace_files();
+        read_event_files();
+        read_proc_kallsyms();
+        read_ftrace_printk();
+
+        if (show_funcs) {
+                print_funcs();
+                return;
+        }
+        if (show_printk) {
+                print_printk();
+                return;
+        }
+
+        return;
+}
diff --git a/tools/perf/util/trace-event.h b/tools/perf/util/trace-event.h
new file mode 100644
index 000000000000..420294a5773e
--- /dev/null
+++ b/tools/perf/util/trace-event.h
@@ -0,0 +1,240 @@
+#ifndef _TRACE_EVENTS_H
+#define _TRACE_EVENTS_H
+
+#include "parse-events.h"
+
+#define __unused __attribute__((unused))
+
+
+#ifndef PAGE_MASK
+#define PAGE_MASK (page_size - 1)
+#endif
+
+enum {
+        RINGBUF_TYPE_PADDING            = 29,
+        RINGBUF_TYPE_TIME_EXTEND        = 30,
+        RINGBUF_TYPE_TIME_STAMP         = 31,
+};
+
+#ifndef TS_SHIFT
+#define TS_SHIFT                27
+#endif
+
+#define NSECS_PER_SEC           1000000000ULL
+#define NSECS_PER_USEC          1000ULL
+
+enum format_flags {
+        FIELD_IS_ARRAY          = 1,
+        FIELD_IS_POINTER        = 2,
+};
+
+struct format_field {
+        struct format_field     *next;
+        char                    *type;
+        char                    *name;
+        int                     offset;
+        int                     size;
+        unsigned long           flags;
+};
+
+struct format {
+        int                     nr_common;
+        int                     nr_fields;
+        struct format_field     *common_fields;
+        struct format_field     *fields;
+};
+
+struct print_arg_atom {
+        char                    *atom;
+};
+
+struct print_arg_string {
+        char                    *string;
+        int                     offset;
+};
+
+struct print_arg_field {
+        char                    *name;
+        struct format_field     *field;
+};
+
+struct print_flag_sym {
+        struct print_flag_sym   *next;
+        char                    *value;
+        char                    *str;
+};
+
+struct print_arg_typecast {
+        char                    *type;
+        struct print_arg        *item;
+};
+
+struct print_arg_flags {
+        struct print_arg        *field;
+        char                    *delim;
+        struct print_flag_sym   *flags;
+};
+
+struct print_arg_symbol {
+        struct print_arg        *field;
+        struct print_flag_sym   *symbols;
+};
+
+struct print_arg;
+
+struct print_arg_op {
+        char                    *op;
+        int                     prio;
+        struct print_arg        *left;
+        struct print_arg        *right;
+};
+
+struct print_arg_func {
+        char                    *name;
+        struct print_arg        *args;
+};
+
+enum print_arg_type {
+        PRINT_NULL,
+        PRINT_ATOM,
+        PRINT_FIELD,
+        PRINT_FLAGS,
+        PRINT_SYMBOL,
+        PRINT_TYPE,
+        PRINT_STRING,
+        PRINT_OP,
+};
+
+struct print_arg {
+        struct print_arg                *next;
+        enum print_arg_type             type;
+        union {
+                struct print_arg_atom           atom;
+                struct print_arg_field          field;
+                struct print_arg_typecast       typecast;
+                struct print_arg_flags          flags;
+                struct print_arg_symbol         symbol;
+                struct print_arg_func           func;
+                struct print_arg_string         string;
+                struct print_arg_op             op;
+        };
+};
+
+struct print_fmt {
+        char                    *format;
+        struct print_arg        *args;
+};
+
+struct event {
+        struct event            *next;
+        char                    *name;
+        int                     id;
+        int                     flags;
+        struct format           format;
+        struct print_fmt        print_fmt;
+};
+
+enum {
+        EVENT_FL_ISFTRACE       = 1,
+        EVENT_FL_ISPRINT        = 2,
+        EVENT_FL_ISBPRINT       = 4,
+        EVENT_FL_ISFUNC         = 8,
+        EVENT_FL_ISFUNCENT      = 16,
+        EVENT_FL_ISFUNCRET      = 32,
+};
+
+struct record {
+        unsigned long long ts;
+        int size;
+        void *data;
+};
+
+struct record *trace_peek_data(int cpu);
+struct record *trace_read_data(int cpu);
+
+void parse_set_info(int nr_cpus, int long_sz);
+
+void trace_report(void);
+
+void *malloc_or_die(unsigned int size);
+
+void parse_cmdlines(char *file, int size);
+void parse_proc_kallsyms(char *file, unsigned int size);
+void parse_ftrace_printk(char *file, unsigned int size);
+
+void print_funcs(void);
+void print_printk(void);
+
+int parse_ftrace_file(char *buf, unsigned long size);
+int parse_event_file(char *buf, unsigned long size, char *system);
+void print_event(int cpu, void *data, int size, unsigned long long nsecs,
+                  char *comm);
+
+extern int file_bigendian;
+extern int host_bigendian;
+
+int bigendian(void);
+
+static inline unsigned short __data2host2(unsigned short data)
+{
+        unsigned short swap;
+
+        if (host_bigendian == file_bigendian)
+                return data;
+
+        swap = ((data & 0xffULL) << 8) |
+                ((data & (0xffULL << 8)) >> 8);
+
+        return swap;
+}
+
+static inline unsigned int __data2host4(unsigned int data)
+{
+        unsigned int swap;
+
+        if (host_bigendian == file_bigendian)
+                return data;
+
+        swap = ((data & 0xffULL) << 24) |
+                ((data & (0xffULL << 8)) << 8) |
+                ((data & (0xffULL << 16)) >> 8) |
+                ((data & (0xffULL << 24)) >> 24);
+
+        return swap;
+}
+
+static inline unsigned long long __data2host8(unsigned long long data)
+{
+        unsigned long long swap;
+
+        if (host_bigendian == file_bigendian)
+                return data;
+
+        swap = ((data & 0xffULL) << 56) |
+                ((data & (0xffULL << 8)) << 40) |
+                ((data & (0xffULL << 16)) << 24) |
+                ((data & (0xffULL << 24)) << 8) |
+                ((data & (0xffULL << 32)) >> 8) |
+                ((data & (0xffULL << 40)) >> 24) |
+                ((data & (0xffULL << 48)) >> 40) |
+                ((data & (0xffULL << 56)) >> 56);
+
+        return swap;
+}
+
+#define data2host2(ptr)         __data2host2(*(unsigned short *)ptr)
+#define data2host4(ptr)         __data2host4(*(unsigned int *)ptr)
+#define data2host8(ptr)         __data2host8(*(unsigned long long *)ptr)
+
+extern int header_page_ts_offset;
+extern int header_page_ts_size;
+extern int header_page_size_offset;
+extern int header_page_size_size;
+extern int header_page_data_offset;
+extern int header_page_data_size;
+
+int parse_header_page(char *buf, unsigned long size);
+
+void read_tracing_data(struct perf_counter_attr *pattrs, int nb_counters);
+
+#endif /* _TRACE_EVENTS_H */
diff --git a/tools/perf/util/util.h b/tools/perf/util/util.h
index 68fe157d72fb..9de2329dd44d 100644
--- a/tools/perf/util/util.h
+++ b/tools/perf/util/util.h
@@ -39,10 +39,6 @@
 /* Approximation of the length of the decimal representation of this type. */
 #define decimal_length(x)       ((int)(sizeof(x) * 2.56 + 0.5) + 1)
 
-#if !defined(__APPLE__) && !defined(__FreeBSD__)  && !defined(__USLC__) && !defined(_M_UNIX)
-#define _XOPEN_SOURCE 600 /* glibc2 and AIX 5.3L need 500, OpenBSD needs 600 for S_ISLNK() */
-#define _XOPEN_SOURCE_EXTENDED 1 /* AIX 5.3L needs this */
-#endif
 #define _ALL_SOURCE 1
 #define _GNU_SOURCE 1
 #define _BSD_SOURCE 1
@@ -83,6 +79,7 @@
 #include <inttypes.h>
 #include "../../../include/linux/magic.h"
 
+
 #ifndef NO_ICONV
 #include <iconv.h>
 #endif
@@ -310,6 +307,7 @@ static inline int has_extension(const char *filename, const char *ext)
 #undef isspace
 #undef isdigit
 #undef isalpha
+#undef isprint
 #undef isalnum
 #undef tolower
 #undef toupper
diff --git a/tools/perf/util/values.c b/tools/perf/util/values.c
new file mode 100644
index 000000000000..1c15e39f99e3
--- /dev/null
+++ b/tools/perf/util/values.c
@@ -0,0 +1,230 @@
+#include <stdlib.h>
+
+#include "util.h"
+#include "values.h"
+
+void perf_read_values_init(struct perf_read_values *values)
+{
+        values->threads_max = 16;
+        values->pid = malloc(values->threads_max * sizeof(*values->pid));
+        values->tid = malloc(values->threads_max * sizeof(*values->tid));
+        values->value = malloc(values->threads_max * sizeof(*values->value));
+        if (!values->pid || !values->tid || !values->value)
+                die("failed to allocate read_values threads arrays");
+        values->threads = 0;
+
+        values->counters_max = 16;
+        values->counterrawid = malloc(values->counters_max
+                                      * sizeof(*values->counterrawid));
+        values->countername = malloc(values->counters_max
+                                     * sizeof(*values->countername));
+        if (!values->counterrawid || !values->countername)
+                die("failed to allocate read_values counters arrays");
+        values->counters = 0;
+}
+
+void perf_read_values_destroy(struct perf_read_values *values)
+{
+        int i;
+
+        if (!values->threads_max || !values->counters_max)
+                return;
+
+        for (i = 0; i < values->threads; i++)
+                free(values->value[i]);
+        free(values->pid);
+        free(values->tid);
+        free(values->counterrawid);
+        for (i = 0; i < values->counters; i++)
+                free(values->countername[i]);
+        free(values->countername);
+}
+
+static void perf_read_values__enlarge_threads(struct perf_read_values *values)
+{
+        values->threads_max *= 2;
+        values->pid = realloc(values->pid,
+                              values->threads_max * sizeof(*values->pid));
+        values->tid = realloc(values->tid,
+                              values->threads_max * sizeof(*values->tid));
+        values->value = realloc(values->value,
+                                values->threads_max * sizeof(*values->value));
+        if (!values->pid || !values->tid || !values->value)
+                die("failed to enlarge read_values threads arrays");
+}
+
+static int perf_read_values__findnew_thread(struct perf_read_values *values,
+                                            u32 pid, u32 tid)
+{
+        int i;
+
+        for (i = 0; i < values->threads; i++)
+                if (values->pid[i] == pid && values->tid[i] == tid)
+                        return i;
+
+        if (values->threads == values->threads_max)
+                perf_read_values__enlarge_threads(values);
+
+        i = values->threads++;
+        values->pid[i] = pid;
+        values->tid[i] = tid;
+        values->value[i] = malloc(values->counters_max * sizeof(**values->value));
+        if (!values->value[i])
+                die("failed to allocate read_values counters array");
+
+        return i;
+}
+
+static void perf_read_values__enlarge_counters(struct perf_read_values *values)
+{
+        int i;
+
+        values->counters_max *= 2;
+        values->counterrawid = realloc(values->counterrawid,
+                                       values->counters_max * sizeof(*values->counterrawid));
+        values->countername = realloc(values->countername,
+                                      values->counters_max * sizeof(*values->countername));
+        if (!values->counterrawid || !values->countername)
+                die("failed to enlarge read_values counters arrays");
+
+        for (i = 0; i < values->threads; i++) {
+                values->value[i] = realloc(values->value[i],
+                                           values->counters_max * sizeof(**values->value));
+                if (!values->value[i])
+                        die("failed to enlarge read_values counters arrays");
+        }
+}
+
+static int perf_read_values__findnew_counter(struct perf_read_values *values,
+                                             u64 rawid, const char *name)
+{
+        int i;
+
+        for (i = 0; i < values->counters; i++)
+                if (values->counterrawid[i] == rawid)
+                        return i;
+
+        if (values->counters == values->counters_max)
+                perf_read_values__enlarge_counters(values);
+
+        i = values->counters++;
+        values->counterrawid[i] = rawid;
+        values->countername[i] = strdup(name);
+
+        return i;
+}
+
+void perf_read_values_add_value(struct perf_read_values *values,
+                                u32 pid, u32 tid,
+                                u64 rawid, const char *name, u64 value)
+{
+        int tindex, cindex;
+
+        tindex = perf_read_values__findnew_thread(values, pid, tid);
+        cindex = perf_read_values__findnew_counter(values, rawid, name);
+
+        values->value[tindex][cindex] = value;
+}
+
+static void perf_read_values__display_pretty(FILE *fp,
+                                             struct perf_read_values *values)
+{
+        int i, j;
+        int pidwidth, tidwidth;
+        int *counterwidth;
+
+        counterwidth = malloc(values->counters * sizeof(*counterwidth));
+        if (!counterwidth)
+                die("failed to allocate counterwidth array");
+        tidwidth = 3;
+        pidwidth = 3;
+        for (j = 0; j < values->counters; j++)
+                counterwidth[j] = strlen(values->countername[j]);
+        for (i = 0; i < values->threads; i++) {
+                int width;
+
+                width = snprintf(NULL, 0, "%d", values->pid[i]);
+                if (width > pidwidth)
+                        pidwidth = width;
+                width = snprintf(NULL, 0, "%d", values->tid[i]);
+                if (width > tidwidth)
+                        tidwidth = width;
+                for (j = 0; j < values->counters; j++) {
+                        width = snprintf(NULL, 0, "%Lu", values->value[i][j]);
+                        if (width > counterwidth[j])
+                                counterwidth[j] = width;
+                }
+        }
+
+        fprintf(fp, "# %*s  %*s", pidwidth, "PID", tidwidth, "TID");
+        for (j = 0; j < values->counters; j++)
+                fprintf(fp, "  %*s", counterwidth[j], values->countername[j]);
+        fprintf(fp, "\n");
+
+        for (i = 0; i < values->threads; i++) {
+                fprintf(fp, "  %*d  %*d", pidwidth, values->pid[i],
+                        tidwidth, values->tid[i]);
+                for (j = 0; j < values->counters; j++)
+                        fprintf(fp, "  %*Lu",
+                                counterwidth[j], values->value[i][j]);
+                fprintf(fp, "\n");
+        }
+}
+
+static void perf_read_values__display_raw(FILE *fp,
+                                          struct perf_read_values *values)
+{
+        int width, pidwidth, tidwidth, namewidth, rawwidth, countwidth;
+        int i, j;
+
+        tidwidth = 3; /* TID */
+        pidwidth = 3; /* PID */
+        namewidth = 4; /* "Name" */
+        rawwidth = 3; /* "Raw" */
+        countwidth = 5; /* "Count" */
+
+        for (i = 0; i < values->threads; i++) {
+                width = snprintf(NULL, 0, "%d", values->pid[i]);
+                if (width > pidwidth)
+                        pidwidth = width;
+                width = snprintf(NULL, 0, "%d", values->tid[i]);
+                if (width > tidwidth)
+                        tidwidth = width;
+        }
+        for (j = 0; j < values->counters; j++) {
+                width = strlen(values->countername[j]);
+                if (width > namewidth)
+                        namewidth = width;
+                width = snprintf(NULL, 0, "%llx", values->counterrawid[j]);
+                if (width > rawwidth)
+                        rawwidth = width;
+        }
+        for (i = 0; i < values->threads; i++) {
+                for (j = 0; j < values->counters; j++) {
+                        width = snprintf(NULL, 0, "%Lu", values->value[i][j]);
+                        if (width > countwidth)
+                                countwidth = width;
+                }
+        }
+
+        fprintf(fp, "# %*s  %*s  %*s  %*s  %*s\n",
+                pidwidth, "PID", tidwidth, "TID",
+                namewidth, "Name", rawwidth, "Raw",
+                countwidth, "Count");
+        for (i = 0; i < values->threads; i++)
+                for (j = 0; j < values->counters; j++)
+                        fprintf(fp, "  %*d  %*d  %*s  %*llx  %*Lu\n",
+                                pidwidth, values->pid[i],
+                                tidwidth, values->tid[i],
+                                namewidth, values->countername[j],
+                                rawwidth, values->counterrawid[j],
+                                countwidth, values->value[i][j]);
+}
+
+void perf_read_values_display(FILE *fp, struct perf_read_values *values, int raw)
+{
+        if (raw)
+                perf_read_values__display_raw(fp, values);
+        else
+                perf_read_values__display_pretty(fp, values);
+}
diff --git a/tools/perf/util/values.h b/tools/perf/util/values.h
new file mode 100644
index 000000000000..cadf8cf2a590
--- /dev/null
+++ b/tools/perf/util/values.h
@@ -0,0 +1,27 @@
+#ifndef _PERF_VALUES_H
+#define _PERF_VALUES_H
+
+#include "types.h"
+
+struct perf_read_values {
+        int threads;
+        int threads_max;
+        u32 *pid, *tid;
+        int counters;
+        int counters_max;
+        u64 *counterrawid;
+        char **countername;
+        u64 **value;
+};
+
+void perf_read_values_init(struct perf_read_values *values);
+void perf_read_values_destroy(struct perf_read_values *values);
+
+void perf_read_values_add_value(struct perf_read_values *values,
+                                u32 pid, u32 tid,
+                                u64 rawid, const char *name, u64 value);
+
+void perf_read_values_display(FILE *fp, struct perf_read_values *values,
+                              int raw);
+
+#endif /* _PERF_VALUES_H */