186 files changed, 4209 insertions, 1630 deletions
diff --git a/Documentation/ftrace.txt b/Documentation/ftrace.txt
index 9cc4d685dde5..753f4de4b175 100644
--- a/Documentation/ftrace.txt
+++ b/Documentation/ftrace.txt
@@ -82,7 +82,7 @@ of ftrace. Here is a list of some of the key files:
                tracer is not adding more data, they will display
                the same information every time they are read.
-  iter_ctrl: This file lets the user control the amount of data
+  trace_options: This file lets the user control the amount of data
                that is displayed in one of the above output
                files.
@@ -94,10 +94,10 @@ of ftrace. Here is a list of some of the key files:
                only be recorded if the latency is greater than
                the value in this file. (in microseconds)
-  trace_entries: This sets or displays the number of bytes each CPU
+  buffer_size_kb: This sets or displays the number of kilobytes each CPU
                buffer can hold. The tracer buffers are the same size
                for each CPU. The displayed number is the size of the
-                 CPU buffer and not total size of all buffers. The
+                CPU buffer and not total size of all buffers. The
                trace buffers are allocated in pages (blocks of memory
                that the kernel uses for allocation, usually 4 KB in size).
                If the last page allocated has room for more bytes
@@ -316,23 +316,23 @@ The above is mostly meaningful for kernel developers.
  The rest is the same as the 'trace' file.
-iter_ctrl
+trace_options
---------
+-------------
-The iter_ctrl file is used to control what gets printed in the trace
+The trace_options file is used to control what gets printed in the trace
 output. To see what is available, simply cat the file:
-  cat /debug/tracing/iter_ctrl
+  cat /debug/tracing/trace_options
  print-parent nosym-offset nosym-addr noverbose noraw nohex nobin \
 noblock nostacktrace nosched-tree
 To disable one of the options, echo in the option prepended with "no".
-  echo noprint-parent > /debug/tracing/iter_ctrl
+  echo noprint-parent > /debug/tracing/trace_options
 To enable an option, leave off the "no".
-  echo sym-offset > /debug/tracing/iter_ctrl
+  echo sym-offset > /debug/tracing/trace_options
 Here are the available options:
@@ -1299,41 +1299,29 @@ trace entries
 -------------
 Having too much or not enough data can be troublesome in diagnosing
-an issue in the kernel. The file trace_entries is used to modify
+an issue in the kernel. The file buffer_size_kb is used to modify
 the size of the internal trace buffers. The number listed
 is the number of entries that can be recorded per CPU. To know
 the full size, multiply the number of possible CPUS with the
 number of entries.
- # cat /debug/tracing/trace_entries
+ # cat /debug/tracing/buffer_size_kb
-65620
+1408 (units kilobytes)
 Note, to modify this, you must have tracing completely disabled. To do that,
 echo "nop" into the current_tracer. If the current_tracer is not set
 to "nop", an EINVAL error will be returned.
 # echo nop > /debug/tracing/current_tracer
- # echo 100000 > /debug/tracing/trace_entries
+ # echo 10000 > /debug/tracing/buffer_size_kb
- # cat /debug/tracing/trace_entries
+ # cat /debug/tracing/buffer_size_kb
-100045
+10000 (units kilobytes)
-Notice that we echoed in 100,000 but the size is 100,045. The entries
-are held in individual pages. It allocates the number of pages it takes
-to fulfill the request. If more entries may fit on the last page
-then they will be added.
- # echo 1 > /debug/tracing/trace_entries
- # cat /debug/tracing/trace_entries
-85
-This shows us that 85 entries can fit in a single page.
 The number of pages which will be allocated is limited to a percentage
 of available memory. Allocating too much will produce an error.
- # echo 1000000000000 > /debug/tracing/trace_entries
+ # echo 1000000000000 > /debug/tracing/buffer_size_kb
 -bash: echo: write error: Cannot allocate memory
- # cat /debug/tracing/trace_entries
+ # cat /debug/tracing/buffer_size_kb
 85
diff --git a/Documentation/kernel-parameters.txt b/Documentation/kernel-parameters.txt
index 9fa6508892c2..2919a2e91938 100644
--- a/Documentation/kernel-parameters.txt
+++ b/Documentation/kernel-parameters.txt
@@ -294,7 +294,9 @@ and is between 256 and 4096 characters. It is defined in the file
                        Possible values are:
                        isolate - enable device isolation (each device, as far
                                  as possible, will get its own protection
-                                  domain)
+                                  domain) [default]
+                        share - put every device behind one IOMMU into the
+                                same protection domain
                        fullflush - enable flushing of IO/TLB entries when
                                    they are unmapped. Otherwise they are
                                    flushed before they will be reused, which
@@ -748,6 +750,14 @@ and is between 256 and 4096 characters. It is defined in the file
                        parameter will force ia64_sal_cache_flush to call
                        ia64_pal_cache_flush instead of SAL_CACHE_FLUSH.
+        ftrace=[tracer]
+                        [ftrace] will set and start the specified tracer
+                        as early as possible in order to facilitate early
+                        boot debugging.
+        ftrace_dump_on_oops
+                        [ftrace] will dump the trace buffers on oops.
        gamecon.map[2|3]=
                        [HW,JOY] Multisystem joystick and NES/SNES/PSX pad
                        support via parallel port (up to 5 devices per port)
@@ -1193,8 +1203,8 @@ and is between 256 and 4096 characters. It is defined in the file
                        it is equivalent to "nosmp", which also disables
                        the IO APIC.
-        max_addr=[KMG]  [KNL,BOOT,ia64] All physical memory greater than or
+        max_addr=nn[KMG]        [KNL,BOOT,ia64] All physical memory greater than
-                        equal to this physical address is ignored.
+                        or equal to this physical address is ignored.
        max_luns=       [SCSI] Maximum number of LUNs to probe.
                        Should be between 1 and 2^32-1.
@@ -1294,6 +1304,9 @@ and is between 256 and 4096 characters. It is defined in the file
        mga=            [HW,DRM]
+        min_addr=nn[KMG]        [KNL,BOOT,ia64] All physical memory below this
+                        physical address is ignored.
        mminit_loglevel=
                        [KNL] When CONFIG_DEBUG_MEMORY_INIT is set, this
                        parameter allows control of the logging verbosity for
diff --git a/Documentation/markers.txt b/Documentation/markers.txt
index 089f6138fcd9..6d275e4ef385 100644
--- a/Documentation/markers.txt
+++ b/Documentation/markers.txt
@@ -70,6 +70,20 @@ a printk warning which identifies the inconsistency:
 "Format mismatch for probe probe_name (format), marker (format)"
+Another way to use markers is to simply define the marker without generating any
+function call to actually call into the marker. This is useful in combination
+with tracepoint probes in a scheme like this :
+void probe_tracepoint_name(unsigned int arg1, struct task_struct *tsk);
+DEFINE_MARKER_TP(marker_eventname, tracepoint_name, probe_tracepoint_name,
+        "arg1 %u pid %d");
+notrace void probe_tracepoint_name(unsigned int arg1, struct task_struct *tsk)
+{
+        struct marker *marker = &GET_MARKER(kernel_irq_entry);
+        /* write data to trace buffers ... */
+}
 * Probe / marker example
diff --git a/Documentation/networking/phy.txt b/Documentation/networking/phy.txt
index 8df6a7b0e66c..88bb71b46da4 100644
--- a/Documentation/networking/phy.txt
+++ b/Documentation/networking/phy.txt
@@ -96,7 +96,7 @@ Letting the PHY Abstraction Layer do Everything
   static void adjust_link(struct net_device *dev);
 
 Next, you need to know the device name of the PHY connected to this device. 
- The name will look something like, "phy0:0", where the first number is the
+ The name will look something like, "0:00", where the first number is the
 bus id, and the second is the PHY's address on that bus.  Typically,
 the bus is responsible for making its ID unique.
 
diff --git a/Documentation/tracepoints.txt b/Documentation/tracepoints.txt
index 5d354e167494..2d42241a25c3 100644
--- a/Documentation/tracepoints.txt
+++ b/Documentation/tracepoints.txt
@@ -3,28 +3,30 @@
                            Mathieu Desnoyers
-This document introduces Linux Kernel Tracepoints and their use. It provides
+This document introduces Linux Kernel Tracepoints and their use. It
-examples of how to insert tracepoints in the kernel and connect probe functions
+provides examples of how to insert tracepoints in the kernel and
-to them and provides some examples of probe functions.
+connect probe functions to them and provides some examples of probe
+functions.
 * Purpose of tracepoints
-A tracepoint placed in code provides a hook to call a function (probe) that you
+A tracepoint placed in code provides a hook to call a function (probe)
-can provide at runtime. A tracepoint can be "on" (a probe is connected to it) or
+that you can provide at runtime. A tracepoint can be "on" (a probe is
-"off" (no probe is attached). When a tracepoint is "off" it has no effect,
+connected to it) or "off" (no probe is attached). When a tracepoint is
-except for adding a tiny time penalty (checking a condition for a branch) and
+"off" it has no effect, except for adding a tiny time penalty
-space penalty (adding a few bytes for the function call at the end of the
+(checking a condition for a branch) and space penalty (adding a few
-instrumented function and adds a data structure in a separate section).  When a
+bytes for the function call at the end of the instrumented function
-tracepoint is "on", the function you provide is called each time the tracepoint
+and adds a data structure in a separate section).  When a tracepoint
-is executed, in the execution context of the caller. When the function provided
+is "on", the function you provide is called each time the tracepoint
-ends its execution, it returns to the caller (continuing from the tracepoint
+is executed, in the execution context of the caller. When the function
-site).
+provided ends its execution, it returns to the caller (continuing from
+the tracepoint site).
 You can put tracepoints at important locations in the code. They are
 lightweight hooks that can pass an arbitrary number of parameters,
-which prototypes are described in a tracepoint declaration placed in a header
+which prototypes are described in a tracepoint declaration placed in a
-file.
+header file.
 They can be used for tracing and performance accounting.
@@ -42,7 +44,7 @@ In include/trace/subsys.h :
 #include <linux/tracepoint.h>
-DEFINE_TRACE(subsys_eventname,
+DECLARE_TRACE(subsys_eventname,
        TPPTOTO(int firstarg, struct task_struct *p),
        TPARGS(firstarg, p));
@@ -50,6 +52,8 @@ In subsys/file.c (where the tracing statement must be added) :
 #include <trace/subsys.h>
+DEFINE_TRACE(subsys_eventname);
 void somefct(void)
 {
        ...
@@ -61,31 +65,41 @@ Where :
 - subsys_eventname is an identifier unique to your event
    - subsys is the name of your subsystem.
    - eventname is the name of the event to trace.
- TPPTOTO(int firstarg, struct task_struct *p) is the prototype of the function
-  called by this tracepoint.
- TPARGS(firstarg, p) are the parameters names, same as found in the prototype.
-Connecting a function (probe) to a tracepoint is done by providing a probe
+- TPPTOTO(int firstarg, struct task_struct *p) is the prototype of the
-(function to call) for the specific tracepoint through
+  function called by this tracepoint.
-register_trace_subsys_eventname().  Removing a probe is done through
-unregister_trace_subsys_eventname(); it will remove the probe sure there is no
-caller left using the probe when it returns. Probe removal is preempt-safe
-because preemption is disabled around the probe call. See the "Probe example"
-section below for a sample probe module.
-The tracepoint mechanism supports inserting multiple instances of the same
-tracepoint, but a single definition must be made of a given tracepoint name over
-all the kernel to make sure no type conflict will occur. Name mangling of the
-tracepoints is done using the prototypes to make sure typing is correct.
-Verification of probe type correctness is done at the registration site by the
-compiler. Tracepoints can be put in inline functions, inlined static functions,
-and unrolled loops as well as regular functions.
-The naming scheme "subsys_event" is suggested here as a convention intended
-to limit collisions. Tracepoint names are global to the kernel: they are
-considered as being the same whether they are in the core kernel image or in
-modules.
+- TPARGS(firstarg, p) are the parameters names, same as found in the
+  prototype.
+Connecting a function (probe) to a tracepoint is done by providing a
+probe (function to call) for the specific tracepoint through
+register_trace_subsys_eventname().  Removing a probe is done through
+unregister_trace_subsys_eventname(); it will remove the probe.
+tracepoint_synchronize_unregister() must be called before the end of
+the module exit function to make sure there is no caller left using
+the probe. This, and the fact that preemption is disabled around the
+probe call, make sure that probe removal and module unload are safe.
+See the "Probe example" section below for a sample probe module.
+The tracepoint mechanism supports inserting multiple instances of the
+same tracepoint, but a single definition must be made of a given
+tracepoint name over all the kernel to make sure no type conflict will
+occur. Name mangling of the tracepoints is done using the prototypes
+to make sure typing is correct. Verification of probe type correctness
+is done at the registration site by the compiler. Tracepoints can be
+put in inline functions, inlined static functions, and unrolled loops
+as well as regular functions.
+The naming scheme "subsys_event" is suggested here as a convention
+intended to limit collisions. Tracepoint names are global to the
+kernel: they are considered as being the same whether they are in the
+core kernel image or in modules.
+If the tracepoint has to be used in kernel modules, an
+EXPORT_TRACEPOINT_SYMBOL_GPL() or EXPORT_TRACEPOINT_SYMBOL() can be
+used to export the defined tracepoints.
 * Probe / tracepoint example
diff --git a/MAINTAINERS b/MAINTAINERS
index 627e4c89328e..618c1ef4a397 100644
--- a/MAINTAINERS
+++ b/MAINTAINERS
@@ -1809,7 +1809,7 @@ S:	Maintained
 FTRACE
 P:      Steven Rostedt
-M:      srostedt@redhat.com
+M:      rostedt@goodmis.org
 S:      Maintained
 FUJITSU FR-V (FRV) PORT
diff --git a/Makefile b/Makefile
index a9ae5dc0aa16..7b1f2384094f 100644
--- a/Makefile
+++ b/Makefile
@@ -1,7 +1,7 @@
 VERSION = 2
 PATCHLEVEL = 6
 SUBLEVEL = 28
-EXTRAVERSION = -rc5
+EXTRAVERSION = -rc6
 NAME = Killer Bat of Doom
 # *DOCUMENTATION*
diff --git a/arch/arm/mach-pxa/include/mach/pxafb.h b/arch/arm/mach-pxa/include/mach/pxafb.h
index 8e591118371e..cbda4d35c421 100644
--- a/arch/arm/mach-pxa/include/mach/pxafb.h
+++ b/arch/arm/mach-pxa/include/mach/pxafb.h
@@ -33,6 +33,7 @@
 #define LCD_CONN_TYPE(_x)       ((_x) & 0x0f)
 #define LCD_CONN_WIDTH(_x)      (((_x) >> 4) & 0x1f)
+#define LCD_TYPE_MASK           0xf
 #define LCD_TYPE_UNKNOWN        0
 #define LCD_TYPE_MONO_STN       1
 #define LCD_TYPE_MONO_DSTN      2
diff --git a/arch/arm/mach-pxa/reset.c b/arch/arm/mach-pxa/reset.c
index 1b2af575c40f..00b2dc2a1074 100644
--- a/arch/arm/mach-pxa/reset.c
+++ b/arch/arm/mach-pxa/reset.c
@@ -90,12 +90,13 @@ void arch_reset(char mode)
                /* Jump into ROM at address 0 */
                cpu_reset(0);
                break;
-        case 'h':
-                do_hw_reset();
-                break;
        case 'g':
                do_gpio_reset();
                break;
+        case 'h':
+        default:
+                do_hw_reset();
+                break;
        }
 }
diff --git a/arch/arm/mach-pxa/spitz.c b/arch/arm/mach-pxa/spitz.c
index f0a5bbae0b45..3be76ee2bdbf 100644
--- a/arch/arm/mach-pxa/spitz.c
+++ b/arch/arm/mach-pxa/spitz.c
@@ -67,6 +67,7 @@
 static unsigned long spitz_pin_config[] __initdata = {
        /* Chip Selects */
        GPIO78_nCS_2,   /* SCOOP #2 */
+        GPIO79_nCS_3,   /* NAND */
        GPIO80_nCS_4,   /* SCOOP #1 */
        /* LCD - 16bpp Active TFT */
@@ -97,10 +98,10 @@ static unsigned long spitz_pin_config[] __initdata = {
        GPIO51_nPIOW,
        GPIO85_nPCE_1,
        GPIO54_nPCE_2,
-        GPIO79_PSKTSEL,
        GPIO55_nPREG,
        GPIO56_nPWAIT,
        GPIO57_nIOIS16,
+        GPIO104_PSKTSEL,
        /* MMC */
        GPIO32_MMC_CLK,
@@ -686,7 +687,6 @@ static void __init akita_init(void)
        spitz_pcmcia_config.num_devs = 1;
        platform_scoop_config = &spitz_pcmcia_config;
-        pxa_set_i2c_info(NULL);
        i2c_register_board_info(0, ARRAY_AND_SIZE(akita_i2c_board_info));
        common_init();
diff --git a/arch/ia64/include/asm/intrinsics.h b/arch/ia64/include/asm/intrinsics.h
index 47d686dba1eb..a3e44a5ed497 100644
--- a/arch/ia64/include/asm/intrinsics.h
+++ b/arch/ia64/include/asm/intrinsics.h
@@ -226,7 +226,7 @@ extern long ia64_cmpxchg_called_with_bad_pointer (void);
 /************************************************/
 #define ia64_ssm                        IA64_INTRINSIC_MACRO(ssm)
 #define ia64_rsm                        IA64_INTRINSIC_MACRO(rsm)
-#define ia64_getreg                     IA64_INTRINSIC_API(getreg)
+#define ia64_getreg                     IA64_INTRINSIC_MACRO(getreg)
 #define ia64_setreg                     IA64_INTRINSIC_API(setreg)
 #define ia64_set_rr                     IA64_INTRINSIC_API(set_rr)
 #define ia64_get_rr                     IA64_INTRINSIC_API(get_rr)
diff --git a/arch/ia64/include/asm/paravirt_privop.h b/arch/ia64/include/asm/paravirt_privop.h
index d577aac11835..0b597424fcfc 100644
--- a/arch/ia64/include/asm/paravirt_privop.h
+++ b/arch/ia64/include/asm/paravirt_privop.h
@@ -78,6 +78,19 @@ extern unsigned long ia64_native_getreg_func(int regnum);
                        ia64_native_rsm(mask);  \
        } while (0)
+/* returned ip value should be the one in the caller,
+ * not in __paravirt_getreg() */
+#define paravirt_getreg(reg)                                    \
+        ({                                                      \
+                unsigned long res;                              \
+                BUILD_BUG_ON(!__builtin_constant_p(reg));       \
+                if ((reg) == _IA64_REG_IP)                      \
+                        res = ia64_native_getreg(_IA64_REG_IP); \
+                else                                            \
+                        res = pv_cpu_ops.getreg(reg);           \
+                res;                                            \
+        })
 /******************************************************************************
 * replacement of hand written assembly codes.
 */
diff --git a/arch/ia64/kernel/entry.S b/arch/ia64/kernel/entry.S
index 7ef0c594f5ed..d435f4a7a96c 100644
--- a/arch/ia64/kernel/entry.S
+++ b/arch/ia64/kernel/entry.S
@@ -499,6 +499,7 @@ GLOBAL_ENTRY(prefetch_stack)
 END(prefetch_stack)
 GLOBAL_ENTRY(kernel_execve)
+        rum psr.ac
        mov r15=__NR_execve                     // put syscall number in place
        break __BREAK_SYSCALL
        br.ret.sptk.many rp
diff --git a/arch/ia64/kernel/head.S b/arch/ia64/kernel/head.S
index 66e491d8baac..59301c472800 100644
--- a/arch/ia64/kernel/head.S
+++ b/arch/ia64/kernel/head.S
@@ -260,7 +260,7 @@ start_ap:
         * Switch into virtual mode:
         */
        movl r16=(IA64_PSR_IT|IA64_PSR_IC|IA64_PSR_DT|IA64_PSR_RT|IA64_PSR_DFH|IA64_PSR_BN \
-                  |IA64_PSR_DI)
+                  |IA64_PSR_DI|IA64_PSR_AC)
        ;;
        mov cr.ipsr=r16
        movl r17=1f
diff --git a/arch/ia64/kernel/mca.c b/arch/ia64/kernel/mca.c
index 7dd96c127177..bab1de2d2f6a 100644
--- a/arch/ia64/kernel/mca.c
+++ b/arch/ia64/kernel/mca.c
@@ -1139,7 +1139,7 @@ ia64_mca_modify_original_stack(struct pt_regs *regs,
        return previous_current;
 no_mod:
-        printk(KERN_INFO "cpu %d, %s %s, original stack not modified\n",
+        mprintk(KERN_INFO "cpu %d, %s %s, original stack not modified\n",
                        smp_processor_id(), type, msg);
        return previous_current;
 }
diff --git a/arch/ia64/kernel/paravirt.c b/arch/ia64/kernel/paravirt.c
index de35d8e8b7d2..9f14c16f6369 100644
--- a/arch/ia64/kernel/paravirt.c
+++ b/arch/ia64/kernel/paravirt.c
@@ -130,7 +130,7 @@ ia64_native_getreg_func(int regnum)
        unsigned long res = -1;
        switch (regnum) {
        CASE_GET_REG(GP);
-        CASE_GET_REG(IP);
+        /*CASE_GET_REG(IP);*/ /* returned ip value shouldn't be constant */
        CASE_GET_REG(PSR);
        CASE_GET_REG(TP);
        CASE_GET_REG(SP);
diff --git a/arch/ia64/kernel/pci-dma.c b/arch/ia64/kernel/pci-dma.c
index dbdb778efa05..2a92f637431d 100644
--- a/arch/ia64/kernel/pci-dma.c
+++ b/arch/ia64/kernel/pci-dma.c
@@ -19,7 +19,6 @@
 #include <linux/kernel.h>
 #include <asm/page.h>
-#include <asm/iommu.h>
 dma_addr_t bad_dma_address __read_mostly;
 EXPORT_SYMBOL(bad_dma_address);
diff --git a/arch/ia64/xen/hypercall.S b/arch/ia64/xen/hypercall.S
index d4ff0b9e79f1..45e02bb64a92 100644
--- a/arch/ia64/xen/hypercall.S
+++ b/arch/ia64/xen/hypercall.S
@@ -58,7 +58,7 @@ __HCALL2(xen_set_rr, HYPERPRIVOP_SET_RR)
 __HCALL2(xen_set_kr, HYPERPRIVOP_SET_KR)
 #ifdef CONFIG_IA32_SUPPORT
-__HCALL1(xen_get_eflag, HYPERPRIVOP_GET_EFLAG)
+__HCALL0(xen_get_eflag, HYPERPRIVOP_GET_EFLAG)
 __HCALL1(xen_set_eflag, HYPERPRIVOP_SET_EFLAG)  // refer SDM vol1 3.1.8
 #endif /* CONFIG_IA32_SUPPORT */
diff --git a/arch/mips/include/asm/mach-rc32434/gpio.h b/arch/mips/include/asm/mach-rc32434/gpio.h
index c8e554eafce3..b5cf6457305a 100644
--- a/arch/mips/include/asm/mach-rc32434/gpio.h
+++ b/arch/mips/include/asm/mach-rc32434/gpio.h
@@ -84,5 +84,7 @@ extern void set_434_reg(unsigned reg_offs, unsigned bit, unsigned len, unsigned
 extern unsigned get_434_reg(unsigned reg_offs);
 extern void set_latch_u5(unsigned char or_mask, unsigned char nand_mask);
 extern unsigned char get_latch_u5(void);
+extern void rb532_gpio_set_ilevel(int bit, unsigned gpio);
+extern void rb532_gpio_set_istat(int bit, unsigned gpio);
 #endif /* _RC32434_GPIO_H_ */
diff --git a/arch/mips/include/asm/mach-rc32434/rb.h b/arch/mips/include/asm/mach-rc32434/rb.h
index 79e8ef67d0d3..f25a84916703 100644
--- a/arch/mips/include/asm/mach-rc32434/rb.h
+++ b/arch/mips/include/asm/mach-rc32434/rb.h
@@ -40,12 +40,14 @@
 #define BTCS            0x010040
 #define BTCOMPARE       0x010044
 #define GPIOBASE        0x050000
-#define GPIOCFG         0x050004
+/* Offsets relative to GPIOBASE */
-#define GPIOD           0x050008
+#define GPIOFUNC        0x00
-#define GPIOILEVEL      0x05000C
+#define GPIOCFG         0x04
-#define GPIOISTAT       0x050010
+#define GPIOD           0x08
-#define GPIONMIEN       0x050014
+#define GPIOILEVEL      0x0C
-#define IMASK6          0x038038
+#define GPIOISTAT       0x10
+#define GPIONMIEN       0x14
+#define IMASK6          0x38
 #define LO_WPX          (1 << 0)
 #define LO_ALE          (1 << 1)
 #define LO_CLE          (1 << 2)
diff --git a/arch/mips/include/asm/time.h b/arch/mips/include/asm/time.h
index d3bd5c5aa2ec..9601ea950542 100644
--- a/arch/mips/include/asm/time.h
+++ b/arch/mips/include/asm/time.h
@@ -63,7 +63,7 @@ static inline int mips_clockevent_init(void)
 /*
 * Initialize the count register as a clocksource
 */
-#ifdef CONFIG_CEVT_R4K
+#ifdef CONFIG_CSRC_R4K
 extern int init_mips_clocksource(void);
 #else
 static inline int init_mips_clocksource(void)
diff --git a/arch/mips/kernel/csrc-r4k.c b/arch/mips/kernel/csrc-r4k.c
index 86e026f067bc..74fb74583b4e 100644
--- a/arch/mips/kernel/csrc-r4k.c
+++ b/arch/mips/kernel/csrc-r4k.c
@@ -27,7 +27,7 @@ int __init init_mips_clocksource(void)
        if (!cpu_has_counter || !mips_hpt_frequency)
                return -ENXIO;
-        /* Calclate a somewhat reasonable rating value */
+        /* Calculate a somewhat reasonable rating value */
        clocksource_mips.rating = 200 + mips_hpt_frequency / 10000000;
        clocksource_set_clock(&clocksource_mips, mips_hpt_frequency);
diff --git a/arch/mips/mm/sc-ip22.c b/arch/mips/mm/sc-ip22.c
index 1f602a110e10..13adb5782110 100644
--- a/arch/mips/mm/sc-ip22.c
+++ b/arch/mips/mm/sc-ip22.c
@@ -161,7 +161,7 @@ static inline int __init indy_sc_probe(void)
 /* XXX Check with wje if the Indy caches can differenciate between
   writeback + invalidate and just invalidate.  */
-struct bcache_ops indy_sc_ops = {
+static struct bcache_ops indy_sc_ops = {
        .bc_enable = indy_sc_enable,
        .bc_disable = indy_sc_disable,
        .bc_wback_inv = indy_sc_wback_invalidate,
diff --git a/arch/mips/mti-malta/malta-amon.c b/arch/mips/mti-malta/malta-amon.c
index 96236bf33838..df9e526312a2 100644
--- a/arch/mips/mti-malta/malta-amon.c
+++ b/arch/mips/mti-malta/malta-amon.c
@@ -22,9 +22,9 @@
 #include <linux/init.h>
 #include <linux/smp.h>
-#include <asm-mips/addrspace.h>
+#include <asm/addrspace.h>
-#include <asm-mips/mips-boards/launch.h>
+#include <asm/mips-boards/launch.h>
-#include <asm-mips/mipsmtregs.h>
+#include <asm/mipsmtregs.h>
 int amon_cpu_avail(int cpu)
 {
diff --git a/arch/mips/rb532/devices.c b/arch/mips/rb532/devices.c
index 2f22d714d5b0..c1c29181bd46 100644
--- a/arch/mips/rb532/devices.c
+++ b/arch/mips/rb532/devices.c
@@ -118,7 +118,7 @@ static struct platform_device cf_slot0 = {
 /* Resources and device for NAND */
 static int rb532_dev_ready(struct mtd_info *mtd)
 {
-        return readl(IDT434_REG_BASE + GPIOD) & GPIO_RDY;
+        return gpio_get_value(GPIO_RDY);
 }
 static void rb532_cmd_ctrl(struct mtd_info *mtd, int cmd, unsigned int ctrl)
diff --git a/arch/mips/rb532/gpio.c b/arch/mips/rb532/gpio.c
index 70c4a6726377..0e84c8ab6a39 100644
--- a/arch/mips/rb532/gpio.c
+++ b/arch/mips/rb532/gpio.c
@@ -39,10 +39,6 @@
 struct rb532_gpio_chip {
        struct gpio_chip chip;
        void __iomem     *regbase;
-        void            (*set_int_level)(struct gpio_chip *chip, unsigned offset, int value);
-        int             (*get_int_level)(struct gpio_chip *chip, unsigned offset);
-        void            (*set_int_status)(struct gpio_chip *chip, unsigned offset, int value);
-        int             (*get_int_status)(struct gpio_chip *chip, unsigned offset);
 };
 struct mpmc_device dev3;
@@ -111,15 +107,47 @@ unsigned char get_latch_u5(void)
 }
 EXPORT_SYMBOL(get_latch_u5);
+/* rb532_set_bit - sanely set a bit
+ *
+ * bitval: new value for the bit
+ * offset: bit index in the 4 byte address range
+ * ioaddr: 4 byte aligned address being altered
+ */
+static inline void rb532_set_bit(unsigned bitval,
+                unsigned offset, void __iomem *ioaddr)
+{
+        unsigned long flags;
+        u32 val;
+        bitval = !!bitval;              /* map parameter to {0,1} */
+        local_irq_save(flags);
+        val = readl(ioaddr);
+        val &= ~( ~bitval << offset );   /* unset bit if bitval == 0 */
+        val |=  (  bitval << offset );   /* set bit if bitval == 1 */
+        writel(val, ioaddr);
+        local_irq_restore(flags);
+}
+/* rb532_get_bit - read a bit
+ *
+ * returns the boolean state of the bit, which may be > 1
+ */
+static inline int rb532_get_bit(unsigned offset, void __iomem *ioaddr)
+{
+        return (readl(ioaddr) & (1 << offset));
+}
 /*
 * Return GPIO level */
 static int rb532_gpio_get(struct gpio_chip *chip, unsigned offset)
 {
-        u32                     mask = 1 << offset;
        struct rb532_gpio_chip  *gpch;
        gpch = container_of(chip, struct rb532_gpio_chip, chip);
-        return readl(gpch->regbase + GPIOD) & mask;
+        return rb532_get_bit(offset, gpch->regbase + GPIOD);
 }
 /*
@@ -128,23 +156,10 @@ static int rb532_gpio_get(struct gpio_chip *chip, unsigned offset)
 static void rb532_gpio_set(struct gpio_chip *chip,
                                unsigned offset, int value)
 {
-        unsigned long           flags;
-        u32                     mask = 1 << offset;
-        u32                     tmp;
        struct rb532_gpio_chip  *gpch;
-        void __iomem            *gpvr;
        gpch = container_of(chip, struct rb532_gpio_chip, chip);
-        gpvr = gpch->regbase + GPIOD;
+        rb532_set_bit(value, offset, gpch->regbase + GPIOD);
-        local_irq_save(flags);
-        tmp = readl(gpvr);
-        if (value)
-                tmp |= mask;
-        else
-                tmp &= ~mask;
-        writel(tmp, gpvr);
-        local_irq_restore(flags);
 }
 /*
@@ -152,21 +167,14 @@ static void rb532_gpio_set(struct gpio_chip *chip,
 */
 static int rb532_gpio_direction_input(struct gpio_chip *chip, unsigned offset)
 {
-        unsigned long           flags;
-        u32                     mask = 1 << offset;
-        u32                     value;
        struct rb532_gpio_chip  *gpch;
-        void __iomem            *gpdr;
        gpch = container_of(chip, struct rb532_gpio_chip, chip);
-        gpdr = gpch->regbase + GPIOCFG;
-        local_irq_save(flags);
+        if (rb532_get_bit(offset, gpch->regbase + GPIOFUNC))
-        value = readl(gpdr);
+                return 1;       /* alternate function, GPIOCFG is ignored */
-        value &= ~mask;
-        writel(value, gpdr);
-        local_irq_restore(flags);
+        rb532_set_bit(0, offset, gpch->regbase + GPIOCFG);
        return 0;
 }
@@ -176,117 +184,60 @@ static int rb532_gpio_direction_input(struct gpio_chip *chip, unsigned offset)
 static int rb532_gpio_direction_output(struct gpio_chip *chip,
                                        unsigned offset, int value)
 {
-        unsigned long           flags;
-        u32                     mask = 1 << offset;
-        u32                     tmp;
        struct rb532_gpio_chip  *gpch;
-        void __iomem            *gpdr;
        gpch = container_of(chip, struct rb532_gpio_chip, chip);
-        writel(mask, gpch->regbase + GPIOD);
-        gpdr = gpch->regbase + GPIOCFG;
-        local_irq_save(flags);
+        if (rb532_get_bit(offset, gpch->regbase + GPIOFUNC))
-        tmp = readl(gpdr);
+                return 1;       /* alternate function, GPIOCFG is ignored */
-        tmp |= mask;
-        writel(tmp, gpdr);
-        local_irq_restore(flags);
+        /* set the initial output value */
+        rb532_set_bit(value, offset, gpch->regbase + GPIOD);
+        rb532_set_bit(1, offset, gpch->regbase + GPIOCFG);
        return 0;
 }
-/*
+static struct rb532_gpio_chip rb532_gpio_chip[] = {
- * Set the GPIO interrupt level
+        [0] = {
- */
+                .chip = {
-static void rb532_gpio_set_int_level(struct gpio_chip *chip,
+                        .label                  = "gpio0",
-                                        unsigned offset, int value)
+                        .direction_input        = rb532_gpio_direction_input,
-{
+                        .direction_output       = rb532_gpio_direction_output,
-        unsigned long           flags;
+                        .get                    = rb532_gpio_get,
-        u32                     mask = 1 << offset;
+                        .set                    = rb532_gpio_set,
-        u32                     tmp;
+                        .base                   = 0,
-        struct rb532_gpio_chip  *gpch;
+                        .ngpio                  = 32,
-        void __iomem            *gpil;
+                },
+        },
-        gpch = container_of(chip, struct rb532_gpio_chip, chip);
+};
-        gpil = gpch->regbase + GPIOILEVEL;
-        local_irq_save(flags);
-        tmp = readl(gpil);
-        if (value)
-                tmp |= mask;
-        else
-                tmp &= ~mask;
-        writel(tmp, gpil);
-        local_irq_restore(flags);
-}
 /*
- * Get the GPIO interrupt level
+ * Set GPIO interrupt level
 */
-static int rb532_gpio_get_int_level(struct gpio_chip *chip, unsigned offset)
+void rb532_gpio_set_ilevel(int bit, unsigned gpio)
 {
-        u32                     mask = 1 << offset;
+        rb532_set_bit(bit, gpio, rb532_gpio_chip->regbase + GPIOILEVEL);
-        struct rb532_gpio_chip  *gpch;
-        gpch = container_of(chip, struct rb532_gpio_chip, chip);
-        return readl(gpch->regbase + GPIOILEVEL) & mask;
 }
+EXPORT_SYMBOL(rb532_gpio_set_ilevel);
 /*
- * Set the GPIO interrupt status
+ * Set GPIO interrupt status
 */
-static void rb532_gpio_set_int_status(struct gpio_chip *chip,
+void rb532_gpio_set_istat(int bit, unsigned gpio)
-                                unsigned offset, int value)
 {
-        unsigned long           flags;
+        rb532_set_bit(bit, gpio, rb532_gpio_chip->regbase + GPIOISTAT);
-        u32                     mask = 1 << offset;
-        u32                     tmp;
-        struct rb532_gpio_chip  *gpch;
-        void __iomem            *gpis;
-        gpch = container_of(chip, struct rb532_gpio_chip, chip);
-        gpis = gpch->regbase + GPIOISTAT;
-        local_irq_save(flags);
-        tmp = readl(gpis);
-        if (value)
-                tmp |= mask;
-        else
-                tmp &= ~mask;
-        writel(tmp, gpis);
-        local_irq_restore(flags);
 }
+EXPORT_SYMBOL(rb532_gpio_set_istat);
 /*
- * Get the GPIO interrupt status
+ * Configure GPIO alternate function
 */
-static int rb532_gpio_get_int_status(struct gpio_chip *chip, unsigned offset)
+static void rb532_gpio_set_func(int bit, unsigned gpio)
 {
-        u32                     mask = 1 << offset;
+       rb532_set_bit(bit, gpio, rb532_gpio_chip->regbase + GPIOFUNC);
-        struct rb532_gpio_chip  *gpch;
-        gpch = container_of(chip, struct rb532_gpio_chip, chip);
-        return readl(gpch->regbase + GPIOISTAT) & mask;
 }
-static struct rb532_gpio_chip rb532_gpio_chip[] = {
-        [0] = {
-                .chip = {
-                        .label                  = "gpio0",
-                        .direction_input        = rb532_gpio_direction_input,
-                        .direction_output       = rb532_gpio_direction_output,
-                        .get                    = rb532_gpio_get,
-                        .set                    = rb532_gpio_set,
-                        .base                   = 0,
-                        .ngpio                  = 32,
-                },
-                .get_int_level          = rb532_gpio_get_int_level,
-                .set_int_level          = rb532_gpio_set_int_level,
-                .get_int_status         = rb532_gpio_get_int_status,
-                .set_int_status         = rb532_gpio_set_int_status,
-        },
-};
 int __init rb532_gpio_init(void)
 {
        struct resource *r;
@@ -310,9 +261,11 @@ int __init rb532_gpio_init(void)
                return -ENXIO;
        }
-        /* Set the interrupt status and level for the CF pin */
+        /* configure CF_GPIO_NUM as CFRDY IRQ source */
-        rb532_gpio_set_int_level(&rb532_gpio_chip->chip, CF_GPIO_NUM, 1);
+        rb532_gpio_set_func(0, CF_GPIO_NUM);
-        rb532_gpio_set_int_status(&rb532_gpio_chip->chip, CF_GPIO_NUM, 0);
+        rb532_gpio_direction_input(&rb532_gpio_chip->chip, CF_GPIO_NUM);
+        rb532_gpio_set_ilevel(1, CF_GPIO_NUM);
+        rb532_gpio_set_istat(0, CF_GPIO_NUM);
        return 0;
 }
diff --git a/arch/parisc/kernel/ptrace.c b/arch/parisc/kernel/ptrace.c
index 90904f9dfc50..927db3668b6f 100644
--- a/arch/parisc/kernel/ptrace.c
+++ b/arch/parisc/kernel/ptrace.c
@@ -183,10 +183,10 @@ long arch_ptrace(struct task_struct *child, long request, long addr, long data)
 * being 64 bit in both cases.
 */
-static long translate_usr_offset(long offset)
+static compat_ulong_t translate_usr_offset(compat_ulong_t offset)
 {
        if (offset < 0)
-                return -1;
+                return sizeof(struct pt_regs);
        else if (offset <= 32*4)        /* gr[0..31] */
                return offset * 2 + 4;
        else if (offset <= 32*4+32*8)   /* gr[0..31] + fr[0..31] */
@@ -194,7 +194,7 @@ static long translate_usr_offset(long offset)
        else if (offset < sizeof(struct pt_regs)/2 + 32*4)
                return offset * 2 + 4 - 32*8;
        else
-                return -1;
+                return sizeof(struct pt_regs);
 }
 long compat_arch_ptrace(struct task_struct *child, compat_long_t request,
@@ -209,7 +209,7 @@ long compat_arch_ptrace(struct task_struct *child, compat_long_t request,
                if (addr & (sizeof(compat_uint_t)-1))
                        break;
                addr = translate_usr_offset(addr);
-                if (addr < 0)
+                if (addr >= sizeof(struct pt_regs))
                        break;
                tmp = *(compat_uint_t *) ((char *) task_regs(child) + addr);
@@ -236,7 +236,7 @@ long compat_arch_ptrace(struct task_struct *child, compat_long_t request,
                        if (addr & (sizeof(compat_uint_t)-1))
                                break;
                        addr = translate_usr_offset(addr);
-                        if (addr < 0)
+                        if (addr >= sizeof(struct pt_regs))
                                break;
                        if (addr >= PT_FR0 && addr <= PT_FR31 + 4) {
                                /* Special case, fp regs are 64 bits anyway */
diff --git a/arch/sparc/include/asm/unistd_32.h b/arch/sparc/include/asm/unistd_32.h
index 648643a9f139..0d13d2a4c76f 100644
--- a/arch/sparc/include/asm/unistd_32.h
+++ b/arch/sparc/include/asm/unistd_32.h
@@ -338,8 +338,9 @@
 #define __NR_dup3               320
 #define __NR_pipe2              321
 #define __NR_inotify_init1      322
+#define __NR_accept4            323
-#define NR_SYSCALLS             323
+#define NR_SYSCALLS             324
 /* Sparc 32-bit only has the "setresuid32", "getresuid32" variants,
 * it never had the plain ones and there is no value to adding those
diff --git a/arch/sparc/include/asm/unistd_64.h b/arch/sparc/include/asm/unistd_64.h
index c5cc0e052321..fa5d3c0343c7 100644
--- a/arch/sparc/include/asm/unistd_64.h
+++ b/arch/sparc/include/asm/unistd_64.h
@@ -340,8 +340,9 @@
 #define __NR_dup3               320
 #define __NR_pipe2              321
 #define __NR_inotify_init1      322
+#define __NR_accept4            323
-#define NR_SYSCALLS             323
+#define NR_SYSCALLS             324
 #ifdef __KERNEL__
 #define __ARCH_WANT_IPC_PARSE_VERSION
diff --git a/arch/sparc/kernel/systbls.S b/arch/sparc/kernel/systbls.S
index e1b9233b90ab..7d0807586442 100644
--- a/arch/sparc/kernel/systbls.S
+++ b/arch/sparc/kernel/systbls.S
@@ -81,4 +81,4 @@ sys_call_table:
 /*305*/ .long sys_set_mempolicy, sys_kexec_load, sys_move_pages, sys_getcpu, sys_epoll_pwait
 /*310*/ .long sys_utimensat, sys_signalfd, sys_timerfd_create, sys_eventfd, sys_fallocate
 /*315*/ .long sys_timerfd_settime, sys_timerfd_gettime, sys_signalfd4, sys_eventfd2, sys_epoll_create1
-/*320*/ .long sys_dup3, sys_pipe2, sys_inotify_init1
+/*320*/ .long sys_dup3, sys_pipe2, sys_inotify_init1, sys_accept4
diff --git a/arch/sparc64/kernel/sys32.S b/arch/sparc64/kernel/sys32.S
index ade18ba0c686..f061c4dda9ef 100644
--- a/arch/sparc64/kernel/sys32.S
+++ b/arch/sparc64/kernel/sys32.S
@@ -150,7 +150,7 @@ sys32_mmap2:
 sys32_socketcall:       /* %o0=call, %o1=args */
        cmp             %o0, 1
        bl,pn           %xcc, do_einval
-         cmp            %o0, 17
+         cmp            %o0, 18
        bg,pn           %xcc, do_einval
         sub            %o0, 1, %o0
        sllx            %o0, 5, %o0
@@ -319,6 +319,15 @@ do_sys_recvmsg: /* compat_sys_recvmsg(int, struct compat_msghdr *, unsigned int)
        nop
        nop
        nop
+do_sys_accept4: /* sys_accept4(int, struct sockaddr *, int *, int) */
+63:     ldswa           [%o1 + 0x0] %asi, %o0
+        sethi           %hi(sys_accept4), %g1
+64:     lduwa           [%o1 + 0x8] %asi, %o2
+65:     ldswa           [%o1 + 0xc] %asi, %o3
+        jmpl            %g1 + %lo(sys_accept4), %g0
+66:      lduwa          [%o1 + 0x4] %asi, %o1
+        nop
+        nop
        .section        __ex_table,"a"
        .align          4
@@ -353,4 +362,6 @@ do_sys_recvmsg: /* compat_sys_recvmsg(int, struct compat_msghdr *, unsigned int)
        .word           57b, __retl_efault, 58b, __retl_efault
        .word           59b, __retl_efault, 60b, __retl_efault
        .word           61b, __retl_efault, 62b, __retl_efault
+        .word           63b, __retl_efault, 64b, __retl_efault
+        .word           65b, __retl_efault, 66b, __retl_efault
        .previous
diff --git a/arch/sparc64/kernel/systbls.S b/arch/sparc64/kernel/systbls.S
index b2fa4c163638..9fc78cf354bd 100644
--- a/arch/sparc64/kernel/systbls.S
+++ b/arch/sparc64/kernel/systbls.S
@@ -82,7 +82,7 @@ sys_call_table32:
        .word compat_sys_set_mempolicy, compat_sys_kexec_load, compat_sys_move_pages, sys_getcpu, compat_sys_epoll_pwait
 /*310*/ .word compat_sys_utimensat, compat_sys_signalfd, sys_timerfd_create, sys_eventfd, compat_sys_fallocate
        .word compat_sys_timerfd_settime, compat_sys_timerfd_gettime, compat_sys_signalfd4, sys_eventfd2, sys_epoll_create1
-/*320*/ .word sys_dup3, sys_pipe2, sys_inotify_init1
+/*320*/ .word sys_dup3, sys_pipe2, sys_inotify_init1, sys_accept4
 #endif /* CONFIG_COMPAT */
@@ -156,4 +156,4 @@ sys_call_table:
        .word sys_set_mempolicy, sys_kexec_load, sys_move_pages, sys_getcpu, sys_epoll_pwait
 /*310*/ .word sys_utimensat, sys_signalfd, sys_timerfd_create, sys_eventfd, sys_fallocate
        .word sys_timerfd_settime, sys_timerfd_gettime, sys_signalfd4, sys_eventfd2, sys_epoll_create1
-/*320*/ .word sys_dup3, sys_pipe2, sys_inotify_init1
+/*320*/ .word sys_dup3, sys_pipe2, sys_inotify_init1, sys_accept4
diff --git a/arch/x86/Kconfig b/arch/x86/Kconfig
index 93224b569187..7a146baaa990 100644
--- a/arch/x86/Kconfig
+++ b/arch/x86/Kconfig
@@ -29,6 +29,8 @@ config X86
        select HAVE_FTRACE_MCOUNT_RECORD
        select HAVE_DYNAMIC_FTRACE
        select HAVE_FUNCTION_TRACER
+        select HAVE_FUNCTION_RET_TRACER if X86_32
+        select HAVE_FUNCTION_TRACE_MCOUNT_TEST
        select HAVE_KVM if ((X86_32 && !X86_VOYAGER && !X86_VISWS && !X86_NUMAQ) || X86_64)
        select HAVE_ARCH_KGDB if !X86_VOYAGER
        select HAVE_ARCH_TRACEHOOK
@@ -167,9 +169,12 @@ config GENERIC_PENDING_IRQ
 config X86_SMP
        bool
        depends on SMP && ((X86_32 && !X86_VOYAGER) || X86_64)
-        select USE_GENERIC_SMP_HELPERS
        default y
+config USE_GENERIC_SMP_HELPERS
+        def_bool y
+        depends on SMP
 config X86_32_SMP
        def_bool y
        depends on X86_32 && SMP
@@ -957,7 +962,7 @@ config ARCH_PHYS_ADDR_T_64BIT
 config NUMA
        bool "Numa Memory Allocation and Scheduler Support (EXPERIMENTAL)"
        depends on SMP
-        depends on X86_64 || (X86_32 && HIGHMEM64G && (X86_NUMAQ || X86_BIGSMP || X86_SUMMIT && ACPI) && BROKEN)
+        depends on X86_64 || (X86_32 && HIGHMEM64G && (X86_NUMAQ || X86_BIGSMP || X86_SUMMIT && ACPI) && EXPERIMENTAL)
        default n if X86_PC
        default y if (X86_NUMAQ || X86_SUMMIT || X86_BIGSMP)
        help
diff --git a/arch/x86/Kconfig.debug b/arch/x86/Kconfig.debug
index 2a3dfbd5e677..fa013f529b74 100644
--- a/arch/x86/Kconfig.debug
+++ b/arch/x86/Kconfig.debug
@@ -186,14 +186,10 @@ config IOMMU_LEAK
          Add a simple leak tracer to the IOMMU code. This is useful when you
          are debugging a buggy device driver that leaks IOMMU mappings.
-config MMIOTRACE_HOOKS
-        bool
 config MMIOTRACE
        bool "Memory mapped IO tracing"
        depends on DEBUG_KERNEL && PCI
        select TRACING
-        select MMIOTRACE_HOOKS
        help
          Mmiotrace traces Memory Mapped I/O access and is meant for
          debugging and reverse engineering. It is called from the ioremap
diff --git a/arch/x86/include/asm/ftrace.h b/arch/x86/include/asm/ftrace.h
index 9e8bc29b8b17..2bb43b433e07 100644
--- a/arch/x86/include/asm/ftrace.h
+++ b/arch/x86/include/asm/ftrace.h
@@ -17,8 +17,41 @@ static inline unsigned long ftrace_call_adjust(unsigned long addr)
         */
        return addr - 1;
 }
-#endif
+#ifdef CONFIG_DYNAMIC_FTRACE
+struct dyn_arch_ftrace {
+        /* No extra data needed for x86 */
+};
+#endif /*  CONFIG_DYNAMIC_FTRACE */
+#endif /* __ASSEMBLY__ */
 #endif /* CONFIG_FUNCTION_TRACER */
+#ifdef CONFIG_FUNCTION_RET_TRACER
+#define FTRACE_RET_STACK_SIZE 20
+#ifndef __ASSEMBLY__
+/*
+ * Stack of return addresses for functions
+ * of a thread.
+ * Used in struct thread_info
+ */
+struct ftrace_ret_stack {
+        unsigned long ret;
+        unsigned long func;
+        unsigned long long calltime;
+};
+/*
+ * Primary handler of a function return.
+ * It relays on ftrace_return_to_handler.
+ * Defined in entry32.S
+ */
+extern void return_to_handler(void);
+#endif /* __ASSEMBLY__ */
+#endif /* CONFIG_FUNCTION_RET_TRACER */
 #endif /* _ASM_X86_FTRACE_H */
diff --git a/include/asm-x86/iomap.h b/arch/x86/include/asm/iomap.h
index c1f06289b14b..c1f06289b14b 100644
--- a/include/asm-x86/iomap.h
+++ b/arch/x86/include/asm/iomap.h
diff --git a/arch/x86/include/asm/mmzone_32.h b/arch/x86/include/asm/mmzone_32.h
index 485bdf059ffb..07f1af494ca5 100644
--- a/arch/x86/include/asm/mmzone_32.h
+++ b/arch/x86/include/asm/mmzone_32.h
@@ -34,10 +34,14 @@ static inline void get_memcfg_numa(void)
 extern int early_pfn_to_nid(unsigned long pfn);
+extern void resume_map_numa_kva(pgd_t *pgd);
 #else /* !CONFIG_NUMA */
 #define get_memcfg_numa get_memcfg_numa_flat
+static inline void resume_map_numa_kva(pgd_t *pgd) {}
 #endif /* CONFIG_NUMA */
 #ifdef CONFIG_DISCONTIGMEM
diff --git a/arch/x86/include/asm/thread_info.h b/arch/x86/include/asm/thread_info.h
index e44d379faad2..e90e81ef6ab9 100644
--- a/arch/x86/include/asm/thread_info.h
+++ b/arch/x86/include/asm/thread_info.h
@@ -20,6 +20,8 @@
 struct task_struct;
 struct exec_domain;
 #include <asm/processor.h>
+#include <asm/ftrace.h>
+#include <asm/atomic.h>
 struct thread_info {
        struct task_struct      *task;          /* main task structure */
@@ -38,8 +40,36 @@ struct thread_info {
                                                */
        __u8                    supervisor_stack[0];
 #endif
+#ifdef CONFIG_FUNCTION_RET_TRACER
+        /* Index of current stored adress in ret_stack */
+        int             curr_ret_stack;
+        /* Stack of return addresses for return function tracing */
+        struct ftrace_ret_stack ret_stack[FTRACE_RET_STACK_SIZE];
+        /*
+         * Number of functions that haven't been traced
+         * because of depth overrun.
+         */
+        atomic_t        trace_overrun;
+#endif
 };
+#ifdef CONFIG_FUNCTION_RET_TRACER
+#define INIT_THREAD_INFO(tsk)                   \
+{                                               \
+        .task           = &tsk,                 \
+        .exec_domain    = &default_exec_domain, \
+        .flags          = 0,                    \
+        .cpu            = 0,                    \
+        .preempt_count  = 1,                    \
+        .addr_limit     = KERNEL_DS,            \
+        .restart_block = {                      \
+                .fn = do_no_restart_syscall,    \
+        },                                      \
+        .curr_ret_stack = -1,\
+        .trace_overrun  = ATOMIC_INIT(0)        \
+}
+#else
 #define INIT_THREAD_INFO(tsk)                   \
 {                                               \
        .task           = &tsk,                 \
@@ -52,6 +82,7 @@ struct thread_info {
                .fn = do_no_restart_syscall,    \
        },                                      \
 }
+#endif
 #define init_thread_info        (init_thread_union.thread_info)
 #define init_stack              (init_thread_union.stack)
diff --git a/arch/x86/include/asm/uaccess_64.h b/arch/x86/include/asm/uaccess_64.h
index 664f15280f14..f8cfd00db450 100644
--- a/arch/x86/include/asm/uaccess_64.h
+++ b/arch/x86/include/asm/uaccess_64.h
@@ -46,7 +46,7 @@ int __copy_from_user(void *dst, const void __user *src, unsigned size)
                return ret;
        case 10:
                __get_user_asm(*(u64 *)dst, (u64 __user *)src,
-                               ret, "q", "", "=r", 16);
+                               ret, "q", "", "=r", 10);
                if (unlikely(ret))
                        return ret;
                __get_user_asm(*(u16 *)(8 + (char *)dst),
diff --git a/arch/x86/include/asm/unistd_64.h b/arch/x86/include/asm/unistd_64.h
index 834b2c1d89fb..d2e415e6666f 100644
--- a/arch/x86/include/asm/unistd_64.h
+++ b/arch/x86/include/asm/unistd_64.h
@@ -639,8 +639,8 @@ __SYSCALL(__NR_fallocate, sys_fallocate)
 __SYSCALL(__NR_timerfd_settime, sys_timerfd_settime)
 #define __NR_timerfd_gettime                    287
 __SYSCALL(__NR_timerfd_gettime, sys_timerfd_gettime)
-#define __NR_paccept                            288
+#define __NR_accept4                            288
-__SYSCALL(__NR_paccept, sys_paccept)
+__SYSCALL(__NR_accept4, sys_accept4)
 #define __NR_signalfd4                          289
 __SYSCALL(__NR_signalfd4, sys_signalfd4)
 #define __NR_eventfd2                           290
diff --git a/arch/x86/kernel/Makefile b/arch/x86/kernel/Makefile
index e489ff9cb3e2..1d8ed95da846 100644
--- a/arch/x86/kernel/Makefile
+++ b/arch/x86/kernel/Makefile
@@ -14,6 +14,11 @@ CFLAGS_REMOVE_paravirt-spinlocks.o = -pg
 CFLAGS_REMOVE_ftrace.o = -pg
 endif
+ifdef CONFIG_FUNCTION_RET_TRACER
+# Don't trace __switch_to() but let it for function tracer
+CFLAGS_REMOVE_process_32.o = -pg
+endif
 #
 # vsyscalls (which work on the user stack) should have
 # no stack-protector checks:
@@ -65,6 +70,7 @@ obj-$(CONFIG_X86_LOCAL_APIC)	+= apic.o nmi.o
 obj-$(CONFIG_X86_IO_APIC)       += io_apic.o
 obj-$(CONFIG_X86_REBOOTFIXUPS)  += reboot_fixups_32.o
 obj-$(CONFIG_DYNAMIC_FTRACE)    += ftrace.o
+obj-$(CONFIG_FUNCTION_RET_TRACER)       += ftrace.o
 obj-$(CONFIG_KEXEC)             += machine_kexec_$(BITS).o
 obj-$(CONFIG_KEXEC)             += relocate_kernel_$(BITS).o crash.o
 obj-$(CONFIG_CRASH_DUMP)        += crash_dump_$(BITS).o
diff --git a/arch/x86/kernel/amd_iommu.c b/arch/x86/kernel/amd_iommu.c
index 331b318304eb..e4899e0e8787 100644
--- a/arch/x86/kernel/amd_iommu.c
+++ b/arch/x86/kernel/amd_iommu.c
@@ -537,7 +537,7 @@ static void dma_ops_free_addresses(struct dma_ops_domain *dom,
        address >>= PAGE_SHIFT;
        iommu_area_free(dom->bitmap, address, pages);
-        if (address + pages >= dom->next_bit)
+        if (address >= dom->next_bit)
                dom->need_flush = true;
 }
diff --git a/arch/x86/kernel/amd_iommu_init.c b/arch/x86/kernel/amd_iommu_init.c
index 0cdcda35a05f..30ae2701b3df 100644
--- a/arch/x86/kernel/amd_iommu_init.c
+++ b/arch/x86/kernel/amd_iommu_init.c
@@ -121,7 +121,7 @@ u16 amd_iommu_last_bdf;			/* largest PCI device id we have
 LIST_HEAD(amd_iommu_unity_map);         /* a list of required unity mappings
                                           we find in ACPI */
 unsigned amd_iommu_aperture_order = 26; /* size of aperture in power of 2 */
-int amd_iommu_isolate;                  /* if 1, device isolation is enabled */
+int amd_iommu_isolate = 1;              /* if 1, device isolation is enabled */
 bool amd_iommu_unmap_flush;             /* if true, flush on every unmap */
 LIST_HEAD(amd_iommu_list);              /* list of all AMD IOMMUs in the
@@ -1213,7 +1213,9 @@ static int __init parse_amd_iommu_options(char *str)
        for (; *str; ++str) {
                if (strncmp(str, "isolate", 7) == 0)
                        amd_iommu_isolate = 1;
-                if (strncmp(str, "fullflush", 11) == 0)
+                if (strncmp(str, "share", 5) == 0)
+                        amd_iommu_isolate = 0;
+                if (strncmp(str, "fullflush", 9) == 0)
                        amd_iommu_unmap_flush = true;
        }
diff --git a/arch/x86/kernel/ds.c b/arch/x86/kernel/ds.c
index 2b69994fd3a8..d1a121443bde 100644
--- a/arch/x86/kernel/ds.c
+++ b/arch/x86/kernel/ds.c
@@ -236,17 +236,33 @@ static inline struct ds_context *ds_alloc_context(struct task_struct *task)
        struct ds_context *context = *p_context;
        if (!context) {
+                spin_unlock(&ds_lock);
                context = kzalloc(sizeof(*context), GFP_KERNEL);
-                if (!context)
+                if (!context) {
+                        spin_lock(&ds_lock);
                        return NULL;
+                }
                context->ds = kzalloc(ds_cfg.sizeof_ds, GFP_KERNEL);
                if (!context->ds) {
                        kfree(context);
+                        spin_lock(&ds_lock);
                        return NULL;
                }
+                spin_lock(&ds_lock);
+                /*
+                 * Check for race - another CPU could have allocated
+                 * it meanwhile:
+                 */
+                if (*p_context) {
+                        kfree(context->ds);
+                        kfree(context);
+                        return *p_context;
+                }
                *p_context = context;
                context->this = p_context;
@@ -384,14 +400,15 @@ static int ds_request(struct task_struct *task, void *base, size_t size,
        spin_lock(&ds_lock);
-        if (!check_tracer(task))
-                return -EPERM;
        error = -ENOMEM;
        context = ds_alloc_context(task);
        if (!context)
                goto out_unlock;
+        error = -EPERM;
+        if (!check_tracer(task))
+                goto out_unlock;
        error = -EALREADY;
        if (context->owner[qual] == current)
                goto out_unlock;
diff --git a/arch/x86/kernel/entry_32.S b/arch/x86/kernel/entry_32.S
index 28b597ef9ca1..74defe21ba42 100644
--- a/arch/x86/kernel/entry_32.S
+++ b/arch/x86/kernel/entry_32.S
@@ -1157,6 +1157,9 @@ ENTRY(mcount)
 END(mcount)
 ENTRY(ftrace_caller)
+        cmpl $0, function_trace_stop
+        jne  ftrace_stub
        pushl %eax
        pushl %ecx
        pushl %edx
@@ -1180,8 +1183,15 @@ END(ftrace_caller)
 #else /* ! CONFIG_DYNAMIC_FTRACE */
 ENTRY(mcount)
+        cmpl $0, function_trace_stop
+        jne  ftrace_stub
        cmpl $ftrace_stub, ftrace_trace_function
        jnz trace
+#ifdef CONFIG_FUNCTION_RET_TRACER
+        cmpl $ftrace_stub, ftrace_function_return
+        jnz ftrace_return_caller
+#endif
 .globl ftrace_stub
 ftrace_stub:
        ret
@@ -1200,12 +1210,42 @@ trace:
        popl %edx
        popl %ecx
        popl %eax
        jmp ftrace_stub
 END(mcount)
 #endif /* CONFIG_DYNAMIC_FTRACE */
 #endif /* CONFIG_FUNCTION_TRACER */
+#ifdef CONFIG_FUNCTION_RET_TRACER
+ENTRY(ftrace_return_caller)
+        cmpl $0, function_trace_stop
+        jne ftrace_stub
+        pushl %eax
+        pushl %ecx
+        pushl %edx
+        movl 0xc(%esp), %edx
+        lea 0x4(%ebp), %eax
+        call prepare_ftrace_return
+        popl %edx
+        popl %ecx
+        popl %eax
+        ret
+END(ftrace_return_caller)
+.globl return_to_handler
+return_to_handler:
+        pushl $0
+        pushl %eax
+        pushl %ecx
+        pushl %edx
+        call ftrace_return_to_handler
+        movl %eax, 0xc(%esp)
+        popl %edx
+        popl %ecx
+        popl %eax
+        ret
+#endif
 .section .rodata,"a"
 #include "syscall_table_32.S"
diff --git a/arch/x86/kernel/entry_64.S b/arch/x86/kernel/entry_64.S
index b86f332c96a6..08aa6b10933c 100644
--- a/arch/x86/kernel/entry_64.S
+++ b/arch/x86/kernel/entry_64.S
@@ -68,6 +68,8 @@ ENTRY(mcount)
 END(mcount)
 ENTRY(ftrace_caller)
+        cmpl $0, function_trace_stop
+        jne  ftrace_stub
        /* taken from glibc */
        subq $0x38, %rsp
@@ -103,6 +105,9 @@ END(ftrace_caller)
 #else /* ! CONFIG_DYNAMIC_FTRACE */
 ENTRY(mcount)
+        cmpl $0, function_trace_stop
+        jne  ftrace_stub
        cmpq $ftrace_stub, ftrace_trace_function
        jnz trace
 .globl ftrace_stub
diff --git a/arch/x86/kernel/es7000_32.c b/arch/x86/kernel/es7000_32.c
index f454c78fcef6..0aa2c443d600 100644
--- a/arch/x86/kernel/es7000_32.c
+++ b/arch/x86/kernel/es7000_32.c
@@ -250,31 +250,24 @@ int __init find_unisys_acpi_oem_table(unsigned long *oem_addr)
 {
        struct acpi_table_header *header = NULL;
        int i = 0;
-        acpi_size tbl_size;
-        while (ACPI_SUCCESS(acpi_get_table_with_size("OEM1", i++, &header, &tbl_size))) {
+        while (ACPI_SUCCESS(acpi_get_table("OEM1", i++, &header))) {
                if (!memcmp((char *) &header->oem_id, "UNISYS", 6)) {
                        struct oem_table *t = (struct oem_table *)header;
                        oem_addrX = t->OEMTableAddr;
                        oem_size = t->OEMTableSize;
-                        early_acpi_os_unmap_memory(header, tbl_size);
                        *oem_addr = (unsigned long)__acpi_map_table(oem_addrX,
                                                                    oem_size);
                        return 0;
                }
-                early_acpi_os_unmap_memory(header, tbl_size);
        }
        return -1;
 }
 void __init unmap_unisys_acpi_oem_table(unsigned long oem_addr)
 {
-        if (!oem_addr)
-                return;
-        __acpi_unmap_table((char *)oem_addr, oem_size);
 }
 #endif
diff --git a/arch/x86/kernel/ftrace.c b/arch/x86/kernel/ftrace.c
index 50ea0ac8c9bf..356bb1eb6e9a 100644
--- a/arch/x86/kernel/ftrace.c
+++ b/arch/x86/kernel/ftrace.c
@@ -14,14 +14,17 @@
 #include <linux/uaccess.h>
 #include <linux/ftrace.h>
 #include <linux/percpu.h>
+#include <linux/sched.h>
 #include <linux/init.h>
 #include <linux/list.h>
 #include <asm/ftrace.h>
+#include <linux/ftrace.h>
 #include <asm/nops.h>
+#include <asm/nmi.h>
-static unsigned char ftrace_nop[MCOUNT_INSN_SIZE];
+#ifdef CONFIG_DYNAMIC_FTRACE
 union ftrace_code_union {
        char code[MCOUNT_INSN_SIZE];
@@ -31,18 +34,12 @@ union ftrace_code_union {
        } __attribute__((packed));
 };
 static int ftrace_calc_offset(long ip, long addr)
 {
        return (int)(addr - ip);
 }
-unsigned char *ftrace_nop_replace(void)
+static unsigned char *ftrace_call_replace(unsigned long ip, unsigned long addr)
-{
-        return ftrace_nop;
-}
-unsigned char *ftrace_call_replace(unsigned long ip, unsigned long addr)
 {
        static union ftrace_code_union calc;
@@ -56,7 +53,143 @@ unsigned char *ftrace_call_replace(unsigned long ip, unsigned long addr)
        return calc.code;
 }
-int
+/*
+ * Modifying code must take extra care. On an SMP machine, if
+ * the code being modified is also being executed on another CPU
+ * that CPU will have undefined results and possibly take a GPF.
+ * We use kstop_machine to stop other CPUS from exectuing code.
+ * But this does not stop NMIs from happening. We still need
+ * to protect against that. We separate out the modification of
+ * the code to take care of this.
+ *
+ * Two buffers are added: An IP buffer and a "code" buffer.
+ *
+ * 1) Put the instruction pointer into the IP buffer
+ *    and the new code into the "code" buffer.
+ * 2) Set a flag that says we are modifying code
+ * 3) Wait for any running NMIs to finish.
+ * 4) Write the code
+ * 5) clear the flag.
+ * 6) Wait for any running NMIs to finish.
+ *
+ * If an NMI is executed, the first thing it does is to call
+ * "ftrace_nmi_enter". This will check if the flag is set to write
+ * and if it is, it will write what is in the IP and "code" buffers.
+ *
+ * The trick is, it does not matter if everyone is writing the same
+ * content to the code location. Also, if a CPU is executing code
+ * it is OK to write to that code location if the contents being written
+ * are the same as what exists.
+ */
+static atomic_t in_nmi = ATOMIC_INIT(0);
+static int mod_code_status;             /* holds return value of text write */
+static int mod_code_write;              /* set when NMI should do the write */
+static void *mod_code_ip;               /* holds the IP to write to */
+static void *mod_code_newcode;          /* holds the text to write to the IP */
+static unsigned nmi_wait_count;
+static atomic_t nmi_update_count = ATOMIC_INIT(0);
+int ftrace_arch_read_dyn_info(char *buf, int size)
+{
+        int r;
+        r = snprintf(buf, size, "%u %u",
+                     nmi_wait_count,
+                     atomic_read(&nmi_update_count));
+        return r;
+}
+static void ftrace_mod_code(void)
+{
+        /*
+         * Yes, more than one CPU process can be writing to mod_code_status.
+         *    (and the code itself)
+         * But if one were to fail, then they all should, and if one were
+         * to succeed, then they all should.
+         */
+        mod_code_status = probe_kernel_write(mod_code_ip, mod_code_newcode,
+                                             MCOUNT_INSN_SIZE);
+}
+void ftrace_nmi_enter(void)
+{
+        atomic_inc(&in_nmi);
+        /* Must have in_nmi seen before reading write flag */
+        smp_mb();
+        if (mod_code_write) {
+                ftrace_mod_code();
+                atomic_inc(&nmi_update_count);
+        }
+}
+void ftrace_nmi_exit(void)
+{
+        /* Finish all executions before clearing in_nmi */
+        smp_wmb();
+        atomic_dec(&in_nmi);
+}
+static void wait_for_nmi(void)
+{
+        int waited = 0;
+        while (atomic_read(&in_nmi)) {
+                waited = 1;
+                cpu_relax();
+        }
+        if (waited)
+                nmi_wait_count++;
+}
+static int
+do_ftrace_mod_code(unsigned long ip, void *new_code)
+{
+        mod_code_ip = (void *)ip;
+        mod_code_newcode = new_code;
+        /* The buffers need to be visible before we let NMIs write them */
+        smp_wmb();
+        mod_code_write = 1;
+        /* Make sure write bit is visible before we wait on NMIs */
+        smp_mb();
+        wait_for_nmi();
+        /* Make sure all running NMIs have finished before we write the code */
+        smp_mb();
+        ftrace_mod_code();
+        /* Make sure the write happens before clearing the bit */
+        smp_wmb();
+        mod_code_write = 0;
+        /* make sure NMIs see the cleared bit */
+        smp_mb();
+        wait_for_nmi();
+        return mod_code_status;
+}
+static unsigned char ftrace_nop[MCOUNT_INSN_SIZE];
+static unsigned char *ftrace_nop_replace(void)
+{
+        return ftrace_nop;
+}
+static int
 ftrace_modify_code(unsigned long ip, unsigned char *old_code,
                   unsigned char *new_code)
 {
@@ -81,7 +214,7 @@ ftrace_modify_code(unsigned long ip, unsigned char *old_code,
                return -EINVAL;
        /* replace the text with the new text */
-        if (probe_kernel_write((void *)ip, new_code, MCOUNT_INSN_SIZE))
+        if (do_ftrace_mod_code(ip, new_code))
                return -EPERM;
        sync_core();
@@ -89,6 +222,29 @@ ftrace_modify_code(unsigned long ip, unsigned char *old_code,
        return 0;
 }
+int ftrace_make_nop(struct module *mod,
+                    struct dyn_ftrace *rec, unsigned long addr)
+{
+        unsigned char *new, *old;
+        unsigned long ip = rec->ip;
+        old = ftrace_call_replace(ip, addr);
+        new = ftrace_nop_replace();
+        return ftrace_modify_code(rec->ip, old, new);
+}
+int ftrace_make_call(struct dyn_ftrace *rec, unsigned long addr)
+{
+        unsigned char *new, *old;
+        unsigned long ip = rec->ip;
+        old = ftrace_nop_replace();
+        new = ftrace_call_replace(ip, addr);
+        return ftrace_modify_code(rec->ip, old, new);
+}
 int ftrace_update_ftrace_func(ftrace_func_t func)
 {
        unsigned long ip = (unsigned long)(&ftrace_call);
@@ -165,3 +321,138 @@ int __init ftrace_dyn_arch_init(void *data)
        return 0;
 }
+#endif
+#ifdef CONFIG_FUNCTION_RET_TRACER
+#ifndef CONFIG_DYNAMIC_FTRACE
+/*
+ * These functions are picked from those used on
+ * this page for dynamic ftrace. They have been
+ * simplified to ignore all traces in NMI context.
+ */
+static atomic_t in_nmi;
+void ftrace_nmi_enter(void)
+{
+        atomic_inc(&in_nmi);
+}
+void ftrace_nmi_exit(void)
+{
+        atomic_dec(&in_nmi);
+}
+#endif /* !CONFIG_DYNAMIC_FTRACE */
+/* Add a function return address to the trace stack on thread info.*/
+static int push_return_trace(unsigned long ret, unsigned long long time,
+                                unsigned long func)
+{
+        int index;
+        struct thread_info *ti = current_thread_info();
+        /* The return trace stack is full */
+        if (ti->curr_ret_stack == FTRACE_RET_STACK_SIZE - 1) {
+                atomic_inc(&ti->trace_overrun);
+                return -EBUSY;
+        }
+        index = ++ti->curr_ret_stack;
+        barrier();
+        ti->ret_stack[index].ret = ret;
+        ti->ret_stack[index].func = func;
+        ti->ret_stack[index].calltime = time;
+        return 0;
+}
+/* Retrieve a function return address to the trace stack on thread info.*/
+static void pop_return_trace(unsigned long *ret, unsigned long long *time,
+                                unsigned long *func, unsigned long *overrun)
+{
+        int index;
+        struct thread_info *ti = current_thread_info();
+        index = ti->curr_ret_stack;
+        *ret = ti->ret_stack[index].ret;
+        *func = ti->ret_stack[index].func;
+        *time = ti->ret_stack[index].calltime;
+        *overrun = atomic_read(&ti->trace_overrun);
+        ti->curr_ret_stack--;
+}
+/*
+ * Send the trace to the ring-buffer.
+ * @return the original return address.
+ */
+unsigned long ftrace_return_to_handler(void)
+{
+        struct ftrace_retfunc trace;
+        pop_return_trace(&trace.ret, &trace.calltime, &trace.func,
+                        &trace.overrun);
+        trace.rettime = cpu_clock(raw_smp_processor_id());
+        ftrace_function_return(&trace);
+        return trace.ret;
+}
+/*
+ * Hook the return address and push it in the stack of return addrs
+ * in current thread info.
+ */
+void prepare_ftrace_return(unsigned long *parent, unsigned long self_addr)
+{
+        unsigned long old;
+        unsigned long long calltime;
+        int faulted;
+        unsigned long return_hooker = (unsigned long)
+                                &return_to_handler;
+        /* Nmi's are currently unsupported */
+        if (atomic_read(&in_nmi))
+                return;
+        /*
+         * Protect against fault, even if it shouldn't
+         * happen. This tool is too much intrusive to
+         * ignore such a protection.
+         */
+        asm volatile(
+                "1: movl (%[parent_old]), %[old]\n"
+                "2: movl %[return_hooker], (%[parent_replaced])\n"
+                "   movl $0, %[faulted]\n"
+                ".section .fixup, \"ax\"\n"
+                "3: movl $1, %[faulted]\n"
+                ".previous\n"
+                ".section __ex_table, \"a\"\n"
+                "   .long 1b, 3b\n"
+                "   .long 2b, 3b\n"
+                ".previous\n"
+                : [parent_replaced] "=r" (parent), [old] "=r" (old),
+                  [faulted] "=r" (faulted)
+                : [parent_old] "0" (parent), [return_hooker] "r" (return_hooker)
+                : "memory"
+        );
+        if (WARN_ON(faulted)) {
+                unregister_ftrace_return();
+                return;
+        }
+        if (WARN_ON(!__kernel_text_address(old))) {
+                unregister_ftrace_return();
+                *parent = old;
+                return;
+        }
+        calltime = cpu_clock(raw_smp_processor_id());
+        if (push_return_trace(old, calltime, self_addr) == -EBUSY)
+                *parent = old;
+}
+#endif /* CONFIG_FUNCTION_RET_TRACER */
diff --git a/arch/x86/kernel/io_apic.c b/arch/x86/kernel/io_apic.c
index 7a3f2028e2eb..c9513e1ff28d 100644
--- a/arch/x86/kernel/io_apic.c
+++ b/arch/x86/kernel/io_apic.c
@@ -1140,6 +1140,20 @@ static void __clear_irq_vector(int irq)
        cfg->vector = 0;
        cpus_clear(cfg->domain);
+        if (likely(!cfg->move_in_progress))
+                return;
+        cpus_and(mask, cfg->old_domain, cpu_online_map);
+        for_each_cpu_mask_nr(cpu, mask) {
+                for (vector = FIRST_EXTERNAL_VECTOR; vector < NR_VECTORS;
+                                                                vector++) {
+                        if (per_cpu(vector_irq, cpu)[vector] != irq)
+                                continue;
+                        per_cpu(vector_irq, cpu)[vector] = -1;
+                        break;
+                }
+        }
+        cfg->move_in_progress = 0;
 }
 void __setup_vector_irq(int cpu)
diff --git a/arch/x86/kernel/reboot.c b/arch/x86/kernel/reboot.c
index 724adfc63cb9..cc5a2545dd41 100644
--- a/arch/x86/kernel/reboot.c
+++ b/arch/x86/kernel/reboot.c
@@ -169,6 +169,15 @@ static struct dmi_system_id __initdata reboot_dmi_table[] = {
                        DMI_MATCH(DMI_BOARD_NAME, "0KW626"),
                },
        },
+        {   /* Handle problems with rebooting on Dell Optiplex 330 with 0KP561 */
+                .callback = set_bios_reboot,
+                .ident = "Dell OptiPlex 330",
+                .matches = {
+                        DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."),
+                        DMI_MATCH(DMI_PRODUCT_NAME, "OptiPlex 330"),
+                        DMI_MATCH(DMI_BOARD_NAME, "0KP561"),
+                },
+        },
        {       /* Handle problems with rebooting on Dell 2400's */
                .callback = set_bios_reboot,
                .ident = "Dell PowerEdge 2400",
diff --git a/arch/x86/kernel/setup.c b/arch/x86/kernel/setup.c
index 0fa6790c1dd3..9d5674f7b6cc 100644
--- a/arch/x86/kernel/setup.c
+++ b/arch/x86/kernel/setup.c
@@ -764,7 +764,7 @@ static struct dmi_system_id __initdata bad_bios_dmi_table[] = {
                .callback = dmi_low_memory_corruption,
                .ident = "Phoenix BIOS",
                .matches = {
-                        DMI_MATCH(DMI_BIOS_VENDOR, "Phoenix Technologies, LTD"),
+                        DMI_MATCH(DMI_BIOS_VENDOR, "Phoenix Technologies"),
                },
        },
 #endif
diff --git a/arch/x86/kernel/tsc_sync.c b/arch/x86/kernel/tsc_sync.c
index 9ffb01c31c40..1c0dfbca87c1 100644
--- a/arch/x86/kernel/tsc_sync.c
+++ b/arch/x86/kernel/tsc_sync.c
@@ -46,7 +46,9 @@ static __cpuinit void check_tsc_warp(void)
        cycles_t start, now, prev, end;
        int i;
+        rdtsc_barrier();
        start = get_cycles();
+        rdtsc_barrier();
        /*
         * The measurement runs for 20 msecs:
         */
@@ -61,7 +63,9 @@ static __cpuinit void check_tsc_warp(void)
                 */
                __raw_spin_lock(&sync_lock);
                prev = last_tsc;
+                rdtsc_barrier();
                now = get_cycles();
+                rdtsc_barrier();
                last_tsc = now;
                __raw_spin_unlock(&sync_lock);
diff --git a/arch/x86/kernel/vsyscall_64.c b/arch/x86/kernel/vsyscall_64.c
index 0b8b6690a86d..6f3d3d4cd973 100644
--- a/arch/x86/kernel/vsyscall_64.c
+++ b/arch/x86/kernel/vsyscall_64.c
@@ -17,6 +17,9 @@
 *  want per guest time just set the kernel.vsyscall64 sysctl to 0.
 */
+/* Disable profiling for userspace code: */
+#define DISABLE_BRANCH_PROFILING
 #include <linux/time.h>
 #include <linux/init.h>
 #include <linux/kernel.h>
diff --git a/arch/x86/mach-voyager/voyager_smp.c b/arch/x86/mach-voyager/voyager_smp.c
index 0e331652681e..52145007bd7e 100644
--- a/arch/x86/mach-voyager/voyager_smp.c
+++ b/arch/x86/mach-voyager/voyager_smp.c
@@ -7,6 +7,7 @@
 * This file provides all the same external entries as smp.c but uses
 * the voyager hal to provide the functionality
 */
+#include <linux/cpu.h>
 #include <linux/module.h>
 #include <linux/mm.h>
 #include <linux/kernel_stat.h>
@@ -1790,6 +1791,17 @@ void __init smp_setup_processor_id(void)
        x86_write_percpu(cpu_number, hard_smp_processor_id());
 }
+static void voyager_send_call_func(cpumask_t callmask)
+{
+        __u32 mask = cpus_addr(callmask)[0] & ~(1 << smp_processor_id());
+        send_CPI(mask, VIC_CALL_FUNCTION_CPI);
+}
+static void voyager_send_call_func_single(int cpu)
+{
+        send_CPI(1 << cpu, VIC_CALL_FUNCTION_SINGLE_CPI);
+}
 struct smp_ops smp_ops = {
        .smp_prepare_boot_cpu = voyager_smp_prepare_boot_cpu,
        .smp_prepare_cpus = voyager_smp_prepare_cpus,
@@ -1799,6 +1811,6 @@ struct smp_ops smp_ops = {
        .smp_send_stop = voyager_smp_send_stop,
        .smp_send_reschedule = voyager_smp_send_reschedule,
-        .send_call_func_ipi = native_send_call_func_ipi,
+        .send_call_func_ipi = voyager_send_call_func,
-        .send_call_func_single_ipi = native_send_call_func_single_ipi,
+        .send_call_func_single_ipi = voyager_send_call_func_single,
 };
diff --git a/arch/x86/mm/Makefile b/arch/x86/mm/Makefile
index fea4565ff576..d8cc96a2738f 100644
--- a/arch/x86/mm/Makefile
+++ b/arch/x86/mm/Makefile
@@ -8,9 +8,8 @@ obj-$(CONFIG_X86_PTDUMP)	+= dump_pagetables.o
 obj-$(CONFIG_HIGHMEM)           += highmem_32.o
-obj-$(CONFIG_MMIOTRACE_HOOKS)   += kmmio.o
 obj-$(CONFIG_MMIOTRACE)         += mmiotrace.o
-mmiotrace-y                     := pf_in.o mmio-mod.o
+mmiotrace-y                     := kmmio.o pf_in.o mmio-mod.o
 obj-$(CONFIG_MMIOTRACE_TEST)    += testmmiotrace.o
 obj-$(CONFIG_NUMA)              += numa_$(BITS).o
diff --git a/arch/x86/mm/fault.c b/arch/x86/mm/fault.c
index 31e8730fa246..4152d3c3b138 100644
--- a/arch/x86/mm/fault.c
+++ b/arch/x86/mm/fault.c
@@ -53,7 +53,7 @@
 static inline int kmmio_fault(struct pt_regs *regs, unsigned long addr)
 {
-#ifdef CONFIG_MMIOTRACE_HOOKS
+#ifdef CONFIG_MMIOTRACE
        if (unlikely(is_kmmio_active()))
                if (kmmio_handler(regs, addr) == 1)
                        return -1;
diff --git a/arch/x86/mm/numa_32.c b/arch/x86/mm/numa_32.c
index 847c164725f4..8518c678d83f 100644
--- a/arch/x86/mm/numa_32.c
+++ b/arch/x86/mm/numa_32.c
@@ -222,6 +222,41 @@ static void __init remap_numa_kva(void)
        }
 }
+#ifdef CONFIG_HIBERNATION
+/**
+ * resume_map_numa_kva - add KVA mapping to the temporary page tables created
+ *                       during resume from hibernation
+ * @pgd_base - temporary resume page directory
+ */
+void resume_map_numa_kva(pgd_t *pgd_base)
+{
+        int node;
+        for_each_online_node(node) {
+                unsigned long start_va, start_pfn, size, pfn;
+                start_va = (unsigned long)node_remap_start_vaddr[node];
+                start_pfn = node_remap_start_pfn[node];
+                size = node_remap_size[node];
+                printk(KERN_DEBUG "%s: node %d\n", __FUNCTION__, node);
+                for (pfn = 0; pfn < size; pfn += PTRS_PER_PTE) {
+                        unsigned long vaddr = start_va + (pfn << PAGE_SHIFT);
+                        pgd_t *pgd = pgd_base + pgd_index(vaddr);
+                        pud_t *pud = pud_offset(pgd, vaddr);
+                        pmd_t *pmd = pmd_offset(pud, vaddr);
+                        set_pmd(pmd, pfn_pmd(start_pfn + pfn,
+                                                PAGE_KERNEL_LARGE_EXEC));
+                        printk(KERN_DEBUG "%s: %08lx -> pfn %08lx\n",
+                                __FUNCTION__, vaddr, start_pfn + pfn);
+                }
+        }
+}
+#endif
 static unsigned long calculate_numa_remap_pages(void)
 {
        int nid;
diff --git a/arch/x86/power/hibernate_32.c b/arch/x86/power/hibernate_32.c
index f2b6e3f11bfc..81197c62d5b3 100644
--- a/arch/x86/power/hibernate_32.c
+++ b/arch/x86/power/hibernate_32.c
@@ -12,6 +12,7 @@
 #include <asm/system.h>
 #include <asm/page.h>
 #include <asm/pgtable.h>
+#include <asm/mmzone.h>
 /* Defined in hibernate_asm_32.S */
 extern int restore_image(void);
@@ -127,6 +128,9 @@ static int resume_physical_mapping_init(pgd_t *pgd_base)
                        }
                }
        }
+        resume_map_numa_kva(pgd_base);
        return 0;
 }
diff --git a/arch/x86/vdso/vclock_gettime.c b/arch/x86/vdso/vclock_gettime.c
index 1ef0f90813d6..d9d35824c56f 100644
--- a/arch/x86/vdso/vclock_gettime.c
+++ b/arch/x86/vdso/vclock_gettime.c
@@ -9,6 +9,9 @@
 * Also alternative() doesn't work.
 */
+/* Disable profiling for userspace code: */
+#define DISABLE_BRANCH_PROFILING
 #include <linux/kernel.h>
 #include <linux/posix-timers.h>
 #include <linux/time.h>
diff --git a/drivers/block/cciss.c b/drivers/block/cciss.c
index 12de1fdaa6c6..9364dc554257 100644
--- a/drivers/block/cciss.c
+++ b/drivers/block/cciss.c
@@ -2847,7 +2847,7 @@ static void do_cciss_request(struct request_queue *q)
                h->maxSG = seg;
 #ifdef CCISS_DEBUG
-        printk(KERN_DEBUG "cciss: Submitting %d sectors in %d segments\n",
+        printk(KERN_DEBUG "cciss: Submitting %lu sectors in %d segments\n",
               creq->nr_sectors, seg);
 #endif                          /* CCISS_DEBUG */
@@ -3197,7 +3197,7 @@ static int __devinit cciss_pci_init(ctlr_info_t *c, struct pci_dev *pdev)
        c->paddr = pci_resource_start(pdev, 0); /* addressing mode bits already removed */
 #ifdef CCISS_DEBUG
-        printk("address 0 = %x\n", c->paddr);
+        printk("address 0 = %lx\n", c->paddr);
 #endif                          /* CCISS_DEBUG */
        c->vaddr = remap_pci_mem(c->paddr, 0x250);
@@ -3224,7 +3224,8 @@ static int __devinit cciss_pci_init(ctlr_info_t *c, struct pci_dev *pdev)
 #endif                          /* CCISS_DEBUG */
        cfg_base_addr_index = find_PCI_BAR_index(pdev, cfg_base_addr);
 #ifdef CCISS_DEBUG
-        printk("cfg base address index = %x\n", cfg_base_addr_index);
+        printk("cfg base address index = %llx\n",
+                (unsigned long long)cfg_base_addr_index);
 #endif                          /* CCISS_DEBUG */
        if (cfg_base_addr_index == -1) {
                printk(KERN_WARNING "cciss: Cannot find cfg_base_addr_index\n");
@@ -3234,7 +3235,7 @@ static int __devinit cciss_pci_init(ctlr_info_t *c, struct pci_dev *pdev)
        cfg_offset = readl(c->vaddr + SA5_CTMEM_OFFSET);
 #ifdef CCISS_DEBUG
-        printk("cfg offset = %x\n", cfg_offset);
+        printk("cfg offset = %llx\n", (unsigned long long)cfg_offset);
 #endif                          /* CCISS_DEBUG */
        c->cfgtable = remap_pci_mem(pci_resource_start(pdev,
                                                       cfg_base_addr_index) +
diff --git a/drivers/char/sysrq.c b/drivers/char/sysrq.c
index ce0d9da52a8a..94966edfb44d 100644
--- a/drivers/char/sysrq.c
+++ b/drivers/char/sysrq.c
@@ -274,6 +274,22 @@ static struct sysrq_key_op sysrq_showstate_blocked_op = {
        .enable_mask    = SYSRQ_ENABLE_DUMP,
 };
+#ifdef CONFIG_TRACING
+#include <linux/ftrace.h>
+static void sysrq_ftrace_dump(int key, struct tty_struct *tty)
+{
+        ftrace_dump();
+}
+static struct sysrq_key_op sysrq_ftrace_dump_op = {
+        .handler        = sysrq_ftrace_dump,
+        .help_msg       = "dumpZ-ftrace-buffer",
+        .action_msg     = "Dump ftrace buffer",
+        .enable_mask    = SYSRQ_ENABLE_DUMP,
+};
+#else
+#define sysrq_ftrace_dump_op (*(struct sysrq_key_op *)0)
+#endif
 static void sysrq_handle_showmem(int key, struct tty_struct *tty)
 {
@@ -406,7 +422,7 @@ static struct sysrq_key_op *sysrq_key_table[36] = {
        NULL,                           /* x */
        /* y: May be registered on sparc64 for global register dump */
        NULL,                           /* y */
-        NULL                            /* z */
+        &sysrq_ftrace_dump_op,          /* z */
 };
 /* key2index calculation, -1 on invalid index */
diff --git a/drivers/gpio/gpiolib.c b/drivers/gpio/gpiolib.c
index faa1cc66e9cf..82020abc329e 100644
--- a/drivers/gpio/gpiolib.c
+++ b/drivers/gpio/gpiolib.c
@@ -1134,7 +1134,7 @@ static void gpiolib_dbg_show(struct seq_file *s, struct gpio_chip *chip)
                        continue;
                is_out = test_bit(FLAG_IS_OUT, &gdesc->flags);
-                seq_printf(s, " gpio-%-3d (%-12s) %s %s",
+                seq_printf(s, " gpio-%-3d (%-20.20s) %s %s",
                        gpio, gdesc->label,
                        is_out ? "out" : "in ",
                        chip->get
diff --git a/drivers/hwmon/applesmc.c b/drivers/hwmon/applesmc.c
index 488e45cd43d7..f7dce8b9f64b 100644
--- a/drivers/hwmon/applesmc.c
+++ b/drivers/hwmon/applesmc.c
@@ -128,6 +128,9 @@ static const char* temperature_sensors_sets[][36] = {
 /* Set 13: iMac 8,1 */
        { "TA0P", "TC0D", "TC0H", "TC0P", "TG0D", "TG0H", "TG0P", "TH0P",
          "TL0P", "TO0P", "TW0P", "Tm0P", "Tp0P", NULL },
+/* Set 14: iMac 6,1 */
+        { "TA0P", "TC0D", "TC0H", "TC0P", "TG0D", "TG0H", "TG0P", "TH0P",
+          "TO0P", "Tp0P", NULL },
 };
 /* List of keys used to read/write fan speeds */
@@ -1296,6 +1299,8 @@ static __initdata struct dmi_match_data applesmc_dmi_data[] = {
        { .accelerometer = 1, .light = 1, .temperature_set = 12 },
 /* iMac 8: light sensor only, temperature set 13 */
        { .accelerometer = 0, .light = 0, .temperature_set = 13 },
+/* iMac 6: light sensor only, temperature set 14 */
+        { .accelerometer = 0, .light = 0, .temperature_set = 14 },
 };
 /* Note that DMI_MATCH(...,"MacBook") will match "MacBookPro1,1".
@@ -1349,10 +1354,18 @@ static __initdata struct dmi_system_id applesmc_whitelist[] = {
          DMI_MATCH(DMI_BOARD_VENDOR,"Apple"),
          DMI_MATCH(DMI_PRODUCT_NAME,"MacPro2") },
                &applesmc_dmi_data[4]},
+        { applesmc_dmi_match, "Apple MacPro", {
+          DMI_MATCH(DMI_BOARD_VENDOR, "Apple"),
+          DMI_MATCH(DMI_PRODUCT_NAME, "MacPro") },
+                &applesmc_dmi_data[4]},
        { applesmc_dmi_match, "Apple iMac 8", {
          DMI_MATCH(DMI_BOARD_VENDOR, "Apple"),
          DMI_MATCH(DMI_PRODUCT_NAME, "iMac8") },
                &applesmc_dmi_data[13]},
+        { applesmc_dmi_match, "Apple iMac 6", {
+          DMI_MATCH(DMI_BOARD_VENDOR, "Apple"),
+          DMI_MATCH(DMI_PRODUCT_NAME, "iMac6") },
+                &applesmc_dmi_data[14]},
        { applesmc_dmi_match, "Apple iMac 5", {
          DMI_MATCH(DMI_BOARD_VENDOR, "Apple"),
          DMI_MATCH(DMI_PRODUCT_NAME, "iMac5") },
diff --git a/drivers/misc/sgi-gru/Makefile b/drivers/misc/sgi-gru/Makefile
index d03597a521b0..9e9170b3599a 100644
--- a/drivers/misc/sgi-gru/Makefile
+++ b/drivers/misc/sgi-gru/Makefile
@@ -1,3 +1,7 @@
+ifdef CONFIG_SGI_GRU_DEBUG
+  EXTRA_CFLAGS  += -DDEBUG
+endif
 obj-$(CONFIG_SGI_GRU) := gru.o
 gru-y := grufile.o grumain.o grufault.o grutlbpurge.o gruprocfs.o grukservices.o
diff --git a/drivers/net/atlx/atl2.c b/drivers/net/atlx/atl2.c
index f5bdc92c1a65..8571e8c0bc67 100644
--- a/drivers/net/atlx/atl2.c
+++ b/drivers/net/atlx/atl2.c
@@ -1690,9 +1690,11 @@ static int atl2_resume(struct pci_dev *pdev)
        ATL2_WRITE_REG(&adapter->hw, REG_WOL_CTRL, 0);
-        err = atl2_request_irq(adapter);
+        if (netif_running(netdev)) {
-        if (netif_running(netdev) && err)
+                err = atl2_request_irq(adapter);
-                return err;
+                if (err)
+                        return err;
+        }
        atl2_reset_hw(&adapter->hw);
diff --git a/drivers/net/ipg.c b/drivers/net/ipg.c
index 7373dafbb3f7..059369885be1 100644
--- a/drivers/net/ipg.c
+++ b/drivers/net/ipg.c
@@ -1112,7 +1112,7 @@ static void ipg_nic_rx_free_skb(struct net_device *dev)
                struct ipg_rx *rxfd = sp->rxd + entry;
                pci_unmap_single(sp->pdev,
-                        le64_to_cpu(rxfd->frag_info & ~IPG_RFI_FRAGLEN),
+                        le64_to_cpu(rxfd->frag_info) & ~IPG_RFI_FRAGLEN,
                        sp->rx_buf_sz, PCI_DMA_FROMDEVICE);
                dev_kfree_skb_irq(sp->rx_buff[entry]);
                sp->rx_buff[entry] = NULL;
@@ -1179,7 +1179,7 @@ static int ipg_nic_rx_check_error(struct net_device *dev)
                 */
                if (sp->rx_buff[entry]) {
                        pci_unmap_single(sp->pdev,
-                                le64_to_cpu(rxfd->frag_info & ~IPG_RFI_FRAGLEN),
+                                le64_to_cpu(rxfd->frag_info) & ~IPG_RFI_FRAGLEN,
                                sp->rx_buf_sz, PCI_DMA_FROMDEVICE);
                        dev_kfree_skb_irq(sp->rx_buff[entry]);
@@ -1246,7 +1246,7 @@ static void ipg_nic_rx_with_start(struct net_device *dev,
        if (jumbo->found_start)
                dev_kfree_skb_irq(jumbo->skb);
-        pci_unmap_single(pdev, le64_to_cpu(rxfd->frag_info & ~IPG_RFI_FRAGLEN),
+        pci_unmap_single(pdev, le64_to_cpu(rxfd->frag_info) & ~IPG_RFI_FRAGLEN,
                         sp->rx_buf_sz, PCI_DMA_FROMDEVICE);
        skb_put(skb, sp->rxfrag_size);
@@ -1349,7 +1349,7 @@ static int ipg_nic_rx_jumbo(struct net_device *dev)
                unsigned int entry = curr % IPG_RFDLIST_LENGTH;
                struct ipg_rx *rxfd = sp->rxd + entry;
-                if (!(rxfd->rfs & le64_to_cpu(IPG_RFS_RFDDONE)))
+                if (!(rxfd->rfs & cpu_to_le64(IPG_RFS_RFDDONE)))
                        break;
                switch (ipg_nic_rx_check_frame_type(dev)) {
diff --git a/drivers/net/ixgbe/ixgbe_main.c b/drivers/net/ixgbe/ixgbe_main.c
index 7548fb7360d9..36f2bb666bf7 100644
--- a/drivers/net/ixgbe/ixgbe_main.c
+++ b/drivers/net/ixgbe/ixgbe_main.c
@@ -1287,7 +1287,34 @@ static void ixgbe_set_itr(struct ixgbe_adapter *adapter)
        return;
 }
-static inline void ixgbe_irq_enable(struct ixgbe_adapter *adapter);
+/**
+ * ixgbe_irq_disable - Mask off interrupt generation on the NIC
+ * @adapter: board private structure
+ **/
+static inline void ixgbe_irq_disable(struct ixgbe_adapter *adapter)
+{
+        IXGBE_WRITE_REG(&adapter->hw, IXGBE_EIMC, ~0);
+        IXGBE_WRITE_FLUSH(&adapter->hw);
+        if (adapter->flags & IXGBE_FLAG_MSIX_ENABLED) {
+                int i;
+                for (i = 0; i < adapter->num_msix_vectors; i++)
+                        synchronize_irq(adapter->msix_entries[i].vector);
+        } else {
+                synchronize_irq(adapter->pdev->irq);
+        }
+}
+/**
+ * ixgbe_irq_enable - Enable default interrupt generation settings
+ * @adapter: board private structure
+ **/
+static inline void ixgbe_irq_enable(struct ixgbe_adapter *adapter)
+{
+        u32 mask;
+        mask = IXGBE_EIMS_ENABLE_MASK;
+        IXGBE_WRITE_REG(&adapter->hw, IXGBE_EIMS, mask);
+        IXGBE_WRITE_FLUSH(&adapter->hw);
+}
 /**
 * ixgbe_intr - legacy mode Interrupt Handler
@@ -1394,35 +1421,6 @@ static void ixgbe_free_irq(struct ixgbe_adapter *adapter)
 }
 /**
- * ixgbe_irq_disable - Mask off interrupt generation on the NIC
- * @adapter: board private structure
- **/
-static inline void ixgbe_irq_disable(struct ixgbe_adapter *adapter)
-{
-        IXGBE_WRITE_REG(&adapter->hw, IXGBE_EIMC, ~0);
-        IXGBE_WRITE_FLUSH(&adapter->hw);
-        if (adapter->flags & IXGBE_FLAG_MSIX_ENABLED) {
-                int i;
-                for (i = 0; i < adapter->num_msix_vectors; i++)
-                        synchronize_irq(adapter->msix_entries[i].vector);
-        } else {
-                synchronize_irq(adapter->pdev->irq);
-        }
-}
-/**
- * ixgbe_irq_enable - Enable default interrupt generation settings
- * @adapter: board private structure
- **/
-static inline void ixgbe_irq_enable(struct ixgbe_adapter *adapter)
-{
-        u32 mask;
-        mask = IXGBE_EIMS_ENABLE_MASK;
-        IXGBE_WRITE_REG(&adapter->hw, IXGBE_EIMS, mask);
-        IXGBE_WRITE_FLUSH(&adapter->hw);
-}
-/**
 * ixgbe_configure_msi_and_legacy - Initialize PIN (INTA...) and MSI interrupts
 *
 **/
diff --git a/drivers/net/jme.c b/drivers/net/jme.c
index 81c6cdc3851f..665e70d620fc 100644
--- a/drivers/net/jme.c
+++ b/drivers/net/jme.c
@@ -912,23 +912,23 @@ jme_alloc_and_feed_skb(struct jme_adapter *jme, int idx)
                skb_put(skb, framesize);
                skb->protocol = eth_type_trans(skb, jme->dev);
-                if (jme_rxsum_ok(jme, rxdesc->descwb.flags))
+                if (jme_rxsum_ok(jme, le16_to_cpu(rxdesc->descwb.flags)))
                        skb->ip_summed = CHECKSUM_UNNECESSARY;
                else
                        skb->ip_summed = CHECKSUM_NONE;
-                if (rxdesc->descwb.flags & RXWBFLAG_TAGON) {
+                if (rxdesc->descwb.flags & cpu_to_le16(RXWBFLAG_TAGON)) {
                        if (jme->vlgrp) {
                                jme->jme_vlan_rx(skb, jme->vlgrp,
-                                        le32_to_cpu(rxdesc->descwb.vlan));
+                                        le16_to_cpu(rxdesc->descwb.vlan));
                                NET_STAT(jme).rx_bytes += 4;
                        }
                } else {
                        jme->jme_rx(skb);
                }
-                if ((le16_to_cpu(rxdesc->descwb.flags) & RXWBFLAG_DEST) ==
+                if ((rxdesc->descwb.flags & cpu_to_le16(RXWBFLAG_DEST)) ==
-                                RXWBFLAG_DEST_MUL)
+                    cpu_to_le16(RXWBFLAG_DEST_MUL))
                        ++(NET_STAT(jme).multicast);
                jme->dev->last_rx = jiffies;
@@ -961,7 +961,7 @@ jme_process_receive(struct jme_adapter *jme, int limit)
                rxdesc = rxring->desc;
                rxdesc += i;
-                if ((rxdesc->descwb.flags & RXWBFLAG_OWN) ||
+                if ((rxdesc->descwb.flags & cpu_to_le16(RXWBFLAG_OWN)) ||
                !(rxdesc->descwb.desccnt & RXWBDCNT_WBCPL))
                        goto out;
@@ -1763,10 +1763,9 @@ jme_expand_header(struct jme_adapter *jme, struct sk_buff *skb)
 }
 static int
-jme_tx_tso(struct sk_buff *skb,
+jme_tx_tso(struct sk_buff *skb, __le16 *mss, u8 *flags)
-                u16 *mss, u8 *flags)
 {
-        *mss = skb_shinfo(skb)->gso_size << TXDESC_MSS_SHIFT;
+        *mss = cpu_to_le16(skb_shinfo(skb)->gso_size << TXDESC_MSS_SHIFT);
        if (*mss) {
                *flags |= TXFLAG_LSEN;
@@ -1826,11 +1825,11 @@ jme_tx_csum(struct jme_adapter *jme, struct sk_buff *skb, u8 *flags)
 }
 static inline void
-jme_tx_vlan(struct sk_buff *skb, u16 *vlan, u8 *flags)
+jme_tx_vlan(struct sk_buff *skb, __le16 *vlan, u8 *flags)
 {
        if (vlan_tx_tag_present(skb)) {
                *flags |= TXFLAG_TAGON;
-                *vlan = vlan_tx_tag_get(skb);
+                *vlan = cpu_to_le16(vlan_tx_tag_get(skb));
        }
 }
diff --git a/drivers/net/mv643xx_eth.c b/drivers/net/mv643xx_eth.c
index b9dcdbd369f8..e513f76f2a9f 100644
--- a/drivers/net/mv643xx_eth.c
+++ b/drivers/net/mv643xx_eth.c
@@ -899,7 +899,8 @@ static int txq_reclaim(struct tx_queue *txq, int budget, int force)
                if (skb != NULL) {
                        if (skb_queue_len(&mp->rx_recycle) <
                                        mp->default_rx_ring_size &&
-                            skb_recycle_check(skb, mp->skb_size))
+                            skb_recycle_check(skb, mp->skb_size +
+                                        dma_get_cache_alignment() - 1))
                                __skb_queue_head(&mp->rx_recycle, skb);
                        else
                                dev_kfree_skb(skb);
@@ -2435,8 +2436,8 @@ static int mv643xx_eth_shared_remove(struct platform_device *pdev)
        struct mv643xx_eth_shared_platform_data *pd = pdev->dev.platform_data;
        if (pd == NULL || pd->shared_smi == NULL) {
-                mdiobus_free(msp->smi_bus);
                mdiobus_unregister(msp->smi_bus);
+                mdiobus_free(msp->smi_bus);
        }
        if (msp->err_interrupt != NO_IRQ)
                free_irq(msp->err_interrupt, msp);
diff --git a/drivers/net/phy/phy_device.c b/drivers/net/phy/phy_device.c
index 8fb1faca883a..55bc24b234e3 100644
--- a/drivers/net/phy/phy_device.c
+++ b/drivers/net/phy/phy_device.c
@@ -564,20 +564,32 @@ EXPORT_SYMBOL(genphy_restart_aneg);
 */
 int genphy_config_aneg(struct phy_device *phydev)
 {
-        int result = 0;
+        int result;
-        if (AUTONEG_ENABLE == phydev->autoneg) {
+        if (AUTONEG_ENABLE != phydev->autoneg)
-                int result = genphy_config_advert(phydev);
+                return genphy_setup_forced(phydev);
+        result = genphy_config_advert(phydev);
+        if (result < 0) /* error */
+                return result;
-                if (result < 0) /* error */
+        if (result == 0) {
-                        return result;
+                /* Advertisment hasn't changed, but maybe aneg was never on to
+                 * begin with?  Or maybe phy was isolated? */
+                int ctl = phy_read(phydev, MII_BMCR);
+                if (ctl < 0)
+                        return ctl;
+                if (!(ctl & BMCR_ANENABLE) || (ctl & BMCR_ISOLATE))
+                        result = 1; /* do restart aneg */
+        }
-                /* Only restart aneg if we are advertising something different
+        /* Only restart aneg if we are advertising something different
-                 * than we were before.  */
+         * than we were before.  */
-                if (result > 0)
+        if (result > 0)
-                        result = genphy_restart_aneg(phydev);
+                result = genphy_restart_aneg(phydev);
-        } else
-                result = genphy_setup_forced(phydev);
        return result;
 }
diff --git a/drivers/net/sh_eth.c b/drivers/net/sh_eth.c
index a24bb68887ab..59f242a67714 100644
--- a/drivers/net/sh_eth.c
+++ b/drivers/net/sh_eth.c
@@ -927,7 +927,7 @@ static int sh_eth_start_xmit(struct sk_buff *skb, struct net_device *ndev)
        struct sh_eth_private *mdp = netdev_priv(ndev);
        struct sh_eth_txdesc *txdesc;
        u32 entry;
-        int flags;
+        unsigned long flags;
        spin_lock_irqsave(&mdp->lock, flags);
        if ((mdp->cur_tx - mdp->dirty_tx) >= (TX_RING_SIZE - 4)) {
@@ -1141,7 +1141,7 @@ static int sh_mdio_init(struct net_device *ndev, int id)
        /* Hook up MII support for ethtool */
        mdp->mii_bus->name = "sh_mii";
        mdp->mii_bus->parent = &ndev->dev;
-        mdp->mii_bus->id[0] = id;
+        snprintf(mdp->mii_bus->id, MII_BUS_ID_SIZE, "%x", id);
        /* PHY IRQ */
        mdp->mii_bus->irq = kmalloc(sizeof(int)*PHY_MAX_ADDR, GFP_KERNEL);
diff --git a/drivers/net/smc911x.c b/drivers/net/smc911x.c
index 1f26ab0e7986..b185cd12269c 100644
--- a/drivers/net/smc911x.c
+++ b/drivers/net/smc911x.c
@@ -1813,7 +1813,7 @@ static int __init smc911x_probe(struct net_device *dev)
        val = SMC_GET_BYTE_TEST(lp);
        DBG(SMC_DEBUG_MISC, "%s: endian probe returned 0x%04x\n", CARDNAME, val);
        if (val != 0x87654321) {
-                printk(KERN_ERR "Invalid chip endian 0x08%x\n",val);
+                printk(KERN_ERR "Invalid chip endian 0x%08x\n",val);
                retval = -ENODEV;
                goto err_out;
        }
diff --git a/drivers/net/usb/asix.c b/drivers/net/usb/asix.c
index e12cdb4543b4..de57490103fc 100644
--- a/drivers/net/usb/asix.c
+++ b/drivers/net/usb/asix.c
@@ -1102,12 +1102,14 @@ static int ax88178_link_reset(struct usbnet *dev)
        mode = AX88178_MEDIUM_DEFAULT;
        if (ecmd.speed == SPEED_1000)
-                mode |= AX_MEDIUM_GM | AX_MEDIUM_ENCK;
+                mode |= AX_MEDIUM_GM;
        else if (ecmd.speed == SPEED_100)
                mode |= AX_MEDIUM_PS;
        else
                mode &= ~(AX_MEDIUM_PS | AX_MEDIUM_GM);
+        mode |= AX_MEDIUM_ENCK;
        if (ecmd.duplex == DUPLEX_FULL)
                mode |= AX_MEDIUM_FD;
        else
diff --git a/drivers/net/wireless/iwlwifi/iwl-agn.c b/drivers/net/wireless/iwlwifi/iwl-agn.c
index 8d690a0eb1a9..444c5cc05f03 100644
--- a/drivers/net/wireless/iwlwifi/iwl-agn.c
+++ b/drivers/net/wireless/iwlwifi/iwl-agn.c
@@ -1384,7 +1384,7 @@ void iwl_rx_handle(struct iwl_priv *priv)
                rxq->queue[i] = NULL;
-                pci_dma_sync_single_for_cpu(priv->pci_dev, rxb->dma_addr,
+                pci_dma_sync_single_for_cpu(priv->pci_dev, rxb->aligned_dma_addr,
                                            priv->hw_params.rx_buf_size,
                                            PCI_DMA_FROMDEVICE);
                pkt = (struct iwl_rx_packet *)rxb->skb->data;
@@ -1436,8 +1436,8 @@ void iwl_rx_handle(struct iwl_priv *priv)
                        rxb->skb = NULL;
                }
-                pci_unmap_single(priv->pci_dev, rxb->dma_addr,
+                pci_unmap_single(priv->pci_dev, rxb->real_dma_addr,
-                                 priv->hw_params.rx_buf_size,
+                                 priv->hw_params.rx_buf_size + 256,
                                 PCI_DMA_FROMDEVICE);
                spin_lock_irqsave(&rxq->lock, flags);
                list_add_tail(&rxb->list, &priv->rxq.rx_used);
@@ -2341,7 +2341,6 @@ static void iwl_bg_alive_start(struct work_struct *data)
        mutex_lock(&priv->mutex);
        iwl_alive_start(priv);
        mutex_unlock(&priv->mutex);
-        ieee80211_notify_mac(priv->hw, IEEE80211_NOTIFY_RE_ASSOC);
 }
 static void iwl4965_bg_rf_kill(struct work_struct *work)
diff --git a/drivers/net/wireless/iwlwifi/iwl-dev.h b/drivers/net/wireless/iwlwifi/iwl-dev.h
index c018121085e9..9966d4e384ce 100644
--- a/drivers/net/wireless/iwlwifi/iwl-dev.h
+++ b/drivers/net/wireless/iwlwifi/iwl-dev.h
@@ -89,7 +89,8 @@ extern struct iwl_cfg iwl5100_abg_cfg;
 #define DEFAULT_LONG_RETRY_LIMIT  4U
 struct iwl_rx_mem_buffer {
-        dma_addr_t dma_addr;
+        dma_addr_t real_dma_addr;
+        dma_addr_t aligned_dma_addr;
        struct sk_buff *skb;
        struct list_head list;
 };
diff --git a/drivers/net/wireless/iwlwifi/iwl-rx.c b/drivers/net/wireless/iwlwifi/iwl-rx.c
index 7cde9d76ff5d..0509c16dbe75 100644
--- a/drivers/net/wireless/iwlwifi/iwl-rx.c
+++ b/drivers/net/wireless/iwlwifi/iwl-rx.c
@@ -204,7 +204,7 @@ int iwl_rx_queue_restock(struct iwl_priv *priv)
                list_del(element);
                /* Point to Rx buffer via next RBD in circular buffer */
-                rxq->bd[rxq->write] = iwl_dma_addr2rbd_ptr(priv, rxb->dma_addr);
+                rxq->bd[rxq->write] = iwl_dma_addr2rbd_ptr(priv, rxb->aligned_dma_addr);
                rxq->queue[rxq->write] = rxb;
                rxq->write = (rxq->write + 1) & RX_QUEUE_MASK;
                rxq->free_count--;
@@ -251,7 +251,7 @@ void iwl_rx_allocate(struct iwl_priv *priv)
                rxb = list_entry(element, struct iwl_rx_mem_buffer, list);
                /* Alloc a new receive buffer */
-                rxb->skb = alloc_skb(priv->hw_params.rx_buf_size,
+                rxb->skb = alloc_skb(priv->hw_params.rx_buf_size + 256,
                                __GFP_NOWARN | GFP_ATOMIC);
                if (!rxb->skb) {
                        if (net_ratelimit())
@@ -266,9 +266,17 @@ void iwl_rx_allocate(struct iwl_priv *priv)
                list_del(element);
                /* Get physical address of RB/SKB */
-                rxb->dma_addr =
+                rxb->real_dma_addr = pci_map_single(
-                    pci_map_single(priv->pci_dev, rxb->skb->data,
+                                        priv->pci_dev,
-                           priv->hw_params.rx_buf_size, PCI_DMA_FROMDEVICE);
+                                        rxb->skb->data,
+                                        priv->hw_params.rx_buf_size + 256,
+                                        PCI_DMA_FROMDEVICE);
+                /* dma address must be no more than 36 bits */
+                BUG_ON(rxb->real_dma_addr & ~DMA_BIT_MASK(36));
+                /* and also 256 byte aligned! */
+                rxb->aligned_dma_addr = ALIGN(rxb->real_dma_addr, 256);
+                skb_reserve(rxb->skb, rxb->aligned_dma_addr - rxb->real_dma_addr);
                list_add_tail(&rxb->list, &rxq->rx_free);
                rxq->free_count++;
        }
@@ -300,8 +308,8 @@ void iwl_rx_queue_free(struct iwl_priv *priv, struct iwl_rx_queue *rxq)
        for (i = 0; i < RX_QUEUE_SIZE + RX_FREE_BUFFERS; i++) {
                if (rxq->pool[i].skb != NULL) {
                        pci_unmap_single(priv->pci_dev,
-                                         rxq->pool[i].dma_addr,
+                                         rxq->pool[i].real_dma_addr,
-                                         priv->hw_params.rx_buf_size,
+                                         priv->hw_params.rx_buf_size + 256,
                                         PCI_DMA_FROMDEVICE);
                        dev_kfree_skb(rxq->pool[i].skb);
                }
@@ -354,8 +362,8 @@ void iwl_rx_queue_reset(struct iwl_priv *priv, struct iwl_rx_queue *rxq)
                 * to an SKB, so we need to unmap and free potential storage */
                if (rxq->pool[i].skb != NULL) {
                        pci_unmap_single(priv->pci_dev,
-                                         rxq->pool[i].dma_addr,
+                                         rxq->pool[i].real_dma_addr,
-                                         priv->hw_params.rx_buf_size,
+                                         priv->hw_params.rx_buf_size + 256,
                                         PCI_DMA_FROMDEVICE);
                        priv->alloc_rxb_skb--;
                        dev_kfree_skb(rxq->pool[i].skb);
diff --git a/drivers/net/wireless/iwlwifi/iwl3945-base.c b/drivers/net/wireless/iwlwifi/iwl3945-base.c
index 285b53e7e261..45a6b0c35695 100644
--- a/drivers/net/wireless/iwlwifi/iwl3945-base.c
+++ b/drivers/net/wireless/iwlwifi/iwl3945-base.c
@@ -6012,7 +6012,6 @@ static void iwl3945_bg_alive_start(struct work_struct *data)
        mutex_lock(&priv->mutex);
        iwl3945_alive_start(priv);
        mutex_unlock(&priv->mutex);
-        ieee80211_notify_mac(priv->hw, IEEE80211_NOTIFY_RE_ASSOC);
 }
 static void iwl3945_bg_rf_kill(struct work_struct *work)
diff --git a/drivers/net/wireless/libertas_tf/if_usb.c b/drivers/net/wireless/libertas_tf/if_usb.c
index 1cc03a8dd67a..59634c33b1f9 100644
--- a/drivers/net/wireless/libertas_tf/if_usb.c
+++ b/drivers/net/wireless/libertas_tf/if_usb.c
@@ -331,7 +331,7 @@ static int __if_usb_submit_rx_urb(struct if_usb_card *cardp,
        /* Fill the receive configuration URB and initialise the Rx call back */
        usb_fill_bulk_urb(cardp->rx_urb, cardp->udev,
                          usb_rcvbulkpipe(cardp->udev, cardp->ep_in),
-                          (void *) (skb->tail),
+                          skb_tail_pointer(skb),
                          MRVDRV_ETH_RX_PACKET_BUFFER_SIZE, callbackfn, cardp);
        cardp->rx_urb->transfer_flags |= URB_ZERO_PACKET;
diff --git a/drivers/parport/Kconfig b/drivers/parport/Kconfig
index 209b4a464bcf..855f389eea40 100644
--- a/drivers/parport/Kconfig
+++ b/drivers/parport/Kconfig
@@ -36,7 +36,7 @@ if PARPORT
 config PARPORT_PC
        tristate "PC-style hardware"
        depends on (!SPARC64 || PCI) && !SPARC32 && !M32R && !FRV && \
-                (!M68K || ISA) && !MN10300 && !AVR32
+                (!M68K || ISA) && !MN10300 && !AVR32 && !BLACKFIN
        ---help---
          You should say Y here if you have a PC-style parallel port. All
          IBM PC compatible computers and some Alphas have PC-style
diff --git a/drivers/pci/intel-iommu.c b/drivers/pci/intel-iommu.c
index a2692724b68f..5c8baa43ac9c 100644
--- a/drivers/pci/intel-iommu.c
+++ b/drivers/pci/intel-iommu.c
@@ -1655,12 +1655,14 @@ int __init init_dmars(void)
                        iommu->flush.flush_context = __iommu_flush_context;
                        iommu->flush.flush_iotlb = __iommu_flush_iotlb;
                        printk(KERN_INFO "IOMMU 0x%Lx: using Register based "
-                               "invalidation\n", drhd->reg_base_addr);
+                               "invalidation\n",
+                               (unsigned long long)drhd->reg_base_addr);
                } else {
                        iommu->flush.flush_context = qi_flush_context;
                        iommu->flush.flush_iotlb = qi_flush_iotlb;
                        printk(KERN_INFO "IOMMU 0x%Lx: using Queued "
-                               "invalidation\n", drhd->reg_base_addr);
+                               "invalidation\n",
+                               (unsigned long long)drhd->reg_base_addr);
                }
        }
diff --git a/drivers/pci/pci.c b/drivers/pci/pci.c
index 21f2ac639cab..28af496b441e 100644
--- a/drivers/pci/pci.c
+++ b/drivers/pci/pci.c
@@ -1832,7 +1832,7 @@ int pci_reset_function(struct pci_dev *dev)
        if (!(cap & PCI_EXP_DEVCAP_FLR))
                return -ENOTTY;
-        if (!dev->msi_enabled && !dev->msix_enabled)
+        if (!dev->msi_enabled && !dev->msix_enabled && dev->irq != 0)
                disable_irq(dev->irq);
        pci_save_state(dev);
@@ -1841,7 +1841,7 @@ int pci_reset_function(struct pci_dev *dev)
        r = pci_execute_reset_function(dev);
        pci_restore_state(dev);
-        if (!dev->msi_enabled && !dev->msix_enabled)
+        if (!dev->msi_enabled && !dev->msix_enabled && dev->irq != 0)
                enable_irq(dev->irq);
        return r;
diff --git a/drivers/spi/pxa2xx_spi.c b/drivers/spi/pxa2xx_spi.c
index dae87b1a4c6e..cf12f2d84be2 100644
--- a/drivers/spi/pxa2xx_spi.c
+++ b/drivers/spi/pxa2xx_spi.c
@@ -352,21 +352,21 @@ static int map_dma_buffers(struct driver_data *drv_data)
        } else
                drv_data->tx_map_len = drv_data->len;
-        /* Stream map the rx buffer */
+        /* Stream map the tx buffer. Always do DMA_TO_DEVICE first
-        drv_data->rx_dma = dma_map_single(dev, drv_data->rx,
+         * so we flush the cache *before* invalidating it, in case
-                                                drv_data->rx_map_len,
+         * the tx and rx buffers overlap.
-                                                DMA_FROM_DEVICE);
+         */
-        if (dma_mapping_error(dev, drv_data->rx_dma))
-                return 0;
-        /* Stream map the tx buffer */
        drv_data->tx_dma = dma_map_single(dev, drv_data->tx,
-                                                drv_data->tx_map_len,
+                                        drv_data->tx_map_len, DMA_TO_DEVICE);
-                                                DMA_TO_DEVICE);
+        if (dma_mapping_error(dev, drv_data->tx_dma))
+                return 0;
-        if (dma_mapping_error(dev, drv_data->tx_dma)) {
+        /* Stream map the rx buffer */
-                dma_unmap_single(dev, drv_data->rx_dma,
+        drv_data->rx_dma = dma_map_single(dev, drv_data->rx,
                                        drv_data->rx_map_len, DMA_FROM_DEVICE);
+        if (dma_mapping_error(dev, drv_data->rx_dma)) {
+                dma_unmap_single(dev, drv_data->tx_dma,
+                                        drv_data->tx_map_len, DMA_TO_DEVICE);
                return 0;
        }
diff --git a/drivers/spi/spi_imx.c b/drivers/spi/spi_imx.c
index 61ba147e384d..0b4db0ce78d6 100644
--- a/drivers/spi/spi_imx.c
+++ b/drivers/spi/spi_imx.c
@@ -506,20 +506,6 @@ static int map_dma_buffers(struct driver_data *drv_data)
        if (!IS_DMA_ALIGNED(drv_data->rx) || !IS_DMA_ALIGNED(drv_data->tx))
                return -1;
-        /* NULL rx means write-only transfer and no map needed
-           since rx DMA will not be used */
-        if (drv_data->rx) {
-                buf = drv_data->rx;
-                drv_data->rx_dma = dma_map_single(
-                                        dev,
-                                        buf,
-                                        drv_data->len,
-                                        DMA_FROM_DEVICE);
-                if (dma_mapping_error(dev, drv_data->rx_dma))
-                        return -1;
-                drv_data->rx_dma_needs_unmap = 1;
-        }
        if (drv_data->tx == NULL) {
                /* Read only message --> use drv_data->dummy_dma_buf for dummy
                   writes to achive reads */
@@ -533,18 +519,31 @@ static int map_dma_buffers(struct driver_data *drv_data)
                                        buf,
                                        drv_data->tx_map_len,
                                        DMA_TO_DEVICE);
-        if (dma_mapping_error(dev, drv_data->tx_dma)) {
+        if (dma_mapping_error(dev, drv_data->tx_dma))
-                if (drv_data->rx_dma) {
-                        dma_unmap_single(dev,
-                                        drv_data->rx_dma,
-                                        drv_data->len,
-                                        DMA_FROM_DEVICE);
-                        drv_data->rx_dma_needs_unmap = 0;
-                }
                return -1;
-        }
        drv_data->tx_dma_needs_unmap = 1;
+        /* NULL rx means write-only transfer and no map needed
+         * since rx DMA will not be used */
+        if (drv_data->rx) {
+                buf = drv_data->rx;
+                drv_data->rx_dma = dma_map_single(dev,
+                                                buf,
+                                                drv_data->len,
+                                                DMA_FROM_DEVICE);
+                if (dma_mapping_error(dev, drv_data->rx_dma)) {
+                        if (drv_data->tx_dma) {
+                                dma_unmap_single(dev,
+                                                drv_data->tx_dma,
+                                                drv_data->tx_map_len,
+                                                DMA_TO_DEVICE);
+                                drv_data->tx_dma_needs_unmap = 0;
+                        }
+                        return -1;
+                }
+                drv_data->rx_dma_needs_unmap = 1;
+        }
        return 0;
 }
diff --git a/drivers/usb/gadget/f_rndis.c b/drivers/usb/gadget/f_rndis.c
index 659b3d9671c4..428b5993575a 100644
--- a/drivers/usb/gadget/f_rndis.c
+++ b/drivers/usb/gadget/f_rndis.c
@@ -172,7 +172,6 @@ static struct usb_interface_descriptor rndis_data_intf __initdata = {
        .bDescriptorType =      USB_DT_INTERFACE,
        /* .bInterfaceNumber = DYNAMIC */
-        .bAlternateSetting =    1,
        .bNumEndpoints =        2,
        .bInterfaceClass =      USB_CLASS_CDC_DATA,
        .bInterfaceSubClass =   0,
@@ -303,7 +302,7 @@ static void rndis_response_available(void *_rndis)
        __le32                          *data = req->buf;
        int                             status;
-        if (atomic_inc_return(&rndis->notify_count))
+        if (atomic_inc_return(&rndis->notify_count) != 1)
                return;
        /* Send RNDIS RESPONSE_AVAILABLE notification; a
diff --git a/drivers/usb/host/ehci-pci.c b/drivers/usb/host/ehci-pci.c
index c46a58f9181d..9d0ea573aef6 100644
--- a/drivers/usb/host/ehci-pci.c
+++ b/drivers/usb/host/ehci-pci.c
@@ -66,6 +66,8 @@ static int ehci_pci_setup(struct usb_hcd *hcd)
 {
        struct ehci_hcd         *ehci = hcd_to_ehci(hcd);
        struct pci_dev          *pdev = to_pci_dev(hcd->self.controller);
+        struct pci_dev          *p_smbus;
+        u8                      rev;
        u32                     temp;
        int                     retval;
@@ -166,6 +168,25 @@ static int ehci_pci_setup(struct usb_hcd *hcd)
                        pci_write_config_byte(pdev, 0x4b, tmp | 0x20);
                }
                break;
+        case PCI_VENDOR_ID_ATI:
+                /* SB700 old version has a bug in EHCI controller,
+                 * which causes usb devices lose response in some cases.
+                 */
+                if (pdev->device == 0x4396) {
+                        p_smbus = pci_get_device(PCI_VENDOR_ID_ATI,
+                                                 PCI_DEVICE_ID_ATI_SBX00_SMBUS,
+                                                 NULL);
+                        if (!p_smbus)
+                                break;
+                        rev = p_smbus->revision;
+                        if ((rev == 0x3a) || (rev == 0x3b)) {
+                                u8 tmp;
+                                pci_read_config_byte(pdev, 0x53, &tmp);
+                                pci_write_config_byte(pdev, 0x53, tmp | (1<<3));
+                        }
+                        pci_dev_put(p_smbus);
+                }
+                break;
        }
        ehci_reset(ehci);
diff --git a/drivers/usb/mon/mon_bin.c b/drivers/usb/mon/mon_bin.c
index c9de3f027aab..e06810aef2df 100644
--- a/drivers/usb/mon/mon_bin.c
+++ b/drivers/usb/mon/mon_bin.c
@@ -687,7 +687,10 @@ static ssize_t mon_bin_read(struct file *file, char __user *buf,
        }
        if (rp->b_read >= sizeof(struct mon_bin_hdr)) {
-                step_len = min(nbytes, (size_t)ep->len_cap);
+                step_len = ep->len_cap;
+                step_len -= rp->b_read - sizeof(struct mon_bin_hdr);
+                if (step_len > nbytes)
+                        step_len = nbytes;
                offset = rp->b_out + PKT_SIZE;
                offset += rp->b_read - sizeof(struct mon_bin_hdr);
                if (offset >= rp->b_size)
diff --git a/drivers/usb/musb/musb_host.c b/drivers/usb/musb/musb_host.c
index e45e70bcc5e2..cc64462d4c4e 100644
--- a/drivers/usb/musb/musb_host.c
+++ b/drivers/usb/musb/musb_host.c
@@ -1757,7 +1757,7 @@ static int musb_schedule(
                }
        }
        /* use bulk reserved ep1 if no other ep is free */
-        if (best_end > 0 && qh->type == USB_ENDPOINT_XFER_BULK) {
+        if (best_end < 0 && qh->type == USB_ENDPOINT_XFER_BULK) {
                hw_ep = musb->bulk_ep;
                if (is_in)
                        head = &musb->in_bulk;
diff --git a/drivers/usb/serial/cp2101.c b/drivers/usb/serial/cp2101.c
index 9035d7256b03..cfaf1f085535 100644
--- a/drivers/usb/serial/cp2101.c
+++ b/drivers/usb/serial/cp2101.c
@@ -56,6 +56,7 @@ static void cp2101_shutdown(struct usb_serial *);
 static int debug;
 static struct usb_device_id id_table [] = {
+        { USB_DEVICE(0x0471, 0x066A) }, /* AKTAKOM ACE-1001 cable */
        { USB_DEVICE(0x0489, 0xE000) }, /* Pirelli Broadband S.p.A, DP-L10 SIP/GSM Mobile */
        { USB_DEVICE(0x08e6, 0x5501) }, /* Gemalto Prox-PU/CU contactless smartcard reader */
        { USB_DEVICE(0x0FCF, 0x1003) }, /* Dynastream ANT development board */
diff --git a/drivers/usb/storage/unusual_devs.h b/drivers/usb/storage/unusual_devs.h
index d4e5fc86e43c..6da9a7a962a8 100644
--- a/drivers/usb/storage/unusual_devs.h
+++ b/drivers/usb/storage/unusual_devs.h
@@ -167,6 +167,13 @@ UNUSUAL_DEV(  0x0421, 0x005d, 0x0001, 0x0600,
                US_SC_DEVICE, US_PR_DEVICE, NULL,
                US_FL_FIX_CAPACITY ),
+/* Patch for Nokia 5310 capacity */
+UNUSUAL_DEV(  0x0421, 0x006a, 0x0000, 0x0591,
+                "Nokia",
+                "5310",
+                US_SC_DEVICE, US_PR_DEVICE, NULL,
+                US_FL_FIX_CAPACITY ),
 /* Reported by Mario Rettig <mariorettig@web.de> */
 UNUSUAL_DEV(  0x0421, 0x042e, 0x0100, 0x0100,
                "Nokia",
@@ -233,14 +240,14 @@ UNUSUAL_DEV(  0x0421, 0x0495, 0x0370, 0x0370,
                US_FL_MAX_SECTORS_64 ),
 /* Reported by Cedric Godin <cedric@belbone.be> */
-UNUSUAL_DEV(  0x0421, 0x04b9, 0x0551, 0x0551,
+UNUSUAL_DEV(  0x0421, 0x04b9, 0x0500, 0x0551,
                "Nokia",
                "5300",
                US_SC_DEVICE, US_PR_DEVICE, NULL,
                US_FL_FIX_CAPACITY ),
 /* Reported by Richard Nauber <RichardNauber@web.de> */
-UNUSUAL_DEV(  0x0421, 0x04fa, 0x0601, 0x0601,
+UNUSUAL_DEV(  0x0421, 0x04fa, 0x0550, 0x0660,
                "Nokia",
                "6300",
                US_SC_DEVICE, US_PR_DEVICE, NULL,
diff --git a/drivers/video/atmel_lcdfb.c b/drivers/video/atmel_lcdfb.c
index f8d0a57a07cb..9a577a800db5 100644
--- a/drivers/video/atmel_lcdfb.c
+++ b/drivers/video/atmel_lcdfb.c
@@ -132,7 +132,7 @@ static void init_backlight(struct atmel_lcdfb_info *sinfo)
        bl = backlight_device_register("backlight", &sinfo->pdev->dev,
                        sinfo, &atmel_lcdc_bl_ops);
-        if (IS_ERR(sinfo->backlight)) {
+        if (IS_ERR(bl)) {
                dev_err(&sinfo->pdev->dev, "error %ld on backlight register\n",
                                PTR_ERR(bl));
                return;
diff --git a/drivers/video/backlight/da903x.c b/drivers/video/backlight/da903x.c
index 242c38250166..93bb4340cc64 100644
--- a/drivers/video/backlight/da903x.c
+++ b/drivers/video/backlight/da903x.c
@@ -119,6 +119,7 @@ static int da903x_backlight_probe(struct platform_device *pdev)
        default:
                dev_err(&pdev->dev, "invalid backlight device ID(%d)\n",
                                pdev->id);
+                kfree(data);
                return -EINVAL;
        }
@@ -130,6 +131,7 @@ static int da903x_backlight_probe(struct platform_device *pdev)
                        data, &da903x_backlight_ops);
        if (IS_ERR(bl)) {
                dev_err(&pdev->dev, "failed to register backlight\n");
+                kfree(data);
                return PTR_ERR(bl);
        }
diff --git a/drivers/video/backlight/lcd.c b/drivers/video/backlight/lcd.c
index 8e1731d3b228..680e57b616cd 100644
--- a/drivers/video/backlight/lcd.c
+++ b/drivers/video/backlight/lcd.c
@@ -42,10 +42,13 @@ static int fb_notifier_callback(struct notifier_block *self,
        mutex_lock(&ld->ops_lock);
        if (!ld->ops->check_fb || ld->ops->check_fb(ld, evdata->info)) {
-                if (event == FB_EVENT_BLANK)
+                if (event == FB_EVENT_BLANK) {
-                        ld->ops->set_power(ld, *(int *)evdata->data);
+                        if (ld->ops->set_power)
-                else
+                                ld->ops->set_power(ld, *(int *)evdata->data);
-                        ld->ops->set_mode(ld, evdata->data);
+                } else {
+                        if (ld->ops->set_mode)
+                                ld->ops->set_mode(ld, evdata->data);
+                }
        }
        mutex_unlock(&ld->ops_lock);
        return 0;
diff --git a/drivers/video/cirrusfb.c b/drivers/video/cirrusfb.c
index 8a8760230bc7..a2aa6ddffbe2 100644
--- a/drivers/video/cirrusfb.c
+++ b/drivers/video/cirrusfb.c
@@ -2462,8 +2462,7 @@ static int __init cirrusfb_init(void)
 #ifndef MODULE
 static int __init cirrusfb_setup(char *options) {
-        char *this_opt, s[32];
+        char *this_opt;
-        int i;
        DPRINTK("ENTER\n");
diff --git a/drivers/video/fbmem.c b/drivers/video/fbmem.c
index 1d5ae39cb271..3c65b0d67617 100644
--- a/drivers/video/fbmem.c
+++ b/drivers/video/fbmem.c
@@ -230,7 +230,7 @@ static void fb_set_logo_directpalette(struct fb_info *info,
        greenshift = info->var.green.offset;
        blueshift = info->var.blue.offset;
-        for (i = 32; i < logo->clutsize; i++)
+        for (i = 32; i < 32 + logo->clutsize; i++)
                palette[i] = i << redshift | i << greenshift | i << blueshift;
 }
diff --git a/drivers/video/pxafb.c b/drivers/video/pxafb.c
index 97204497d9f7..cc59c52e1103 100644
--- a/drivers/video/pxafb.c
+++ b/drivers/video/pxafb.c
@@ -804,6 +804,9 @@ static int pxafb_smart_thread(void *arg)
 static int pxafb_smart_init(struct pxafb_info *fbi)
 {
+        if (!(fbi->lccr0 | LCCR0_LCDT))
+                return 0;
        fbi->smart_thread = kthread_run(pxafb_smart_thread, fbi,
                                        "lcd_refresh");
        if (IS_ERR(fbi->smart_thread)) {
@@ -1372,7 +1375,7 @@ static void pxafb_decode_mach_info(struct pxafb_info *fbi,
        fbi->cmap_inverse       = inf->cmap_inverse;
        fbi->cmap_static        = inf->cmap_static;
-        switch (lcd_conn & 0xf) {
+        switch (lcd_conn & LCD_TYPE_MASK) {
        case LCD_TYPE_MONO_STN:
                fbi->lccr0 = LCCR0_CMS;
                break;
diff --git a/drivers/video/tmiofb.c b/drivers/video/tmiofb.c
index 2a380011e9ba..7baf2dd12d50 100644
--- a/drivers/video/tmiofb.c
+++ b/drivers/video/tmiofb.c
@@ -222,6 +222,9 @@ static irqreturn_t tmiofb_irq(int irq, void *__info)
        unsigned int bbisc = tmio_ioread16(par->lcr + LCR_BBISC);
+        tmio_iowrite16(bbisc, par->lcr + LCR_BBISC);
+#ifdef CONFIG_FB_TMIO_ACCELL
        /*
         * We were in polling mode and now we got correct irq.
         * Switch back to IRQ-based sync of command FIFO
@@ -231,9 +234,6 @@ static irqreturn_t tmiofb_irq(int irq, void *__info)
                par->use_polling = false;
        }
-        tmio_iowrite16(bbisc, par->lcr + LCR_BBISC);
-#ifdef CONFIG_FB_TMIO_ACCELL
        if (bbisc & 1)
                wake_up(&par->wait_acc);
 #endif
@@ -938,7 +938,9 @@ static void tmiofb_dump_regs(struct platform_device *dev)
 static int tmiofb_suspend(struct platform_device *dev, pm_message_t state)
 {
        struct fb_info *info = platform_get_drvdata(dev);
+#ifdef CONFIG_FB_TMIO_ACCELL
        struct tmiofb_par *par = info->par;
+#endif
        struct mfd_cell *cell = dev->dev.platform_data;
        int retval = 0;
@@ -950,12 +952,14 @@ static int tmiofb_suspend(struct platform_device *dev, pm_message_t state)
                info->fbops->fb_sync(info);
+#ifdef CONFIG_FB_TMIO_ACCELL
        /*
         * The fb should be usable even if interrupts are disabled (and they are
         * during suspend/resume). Switch temporary to forced polling.
         */
        printk(KERN_INFO "tmiofb: switching to polling\n");
        par->use_polling = true;
+#endif
        tmiofb_hw_stop(dev);
        if (cell->suspend)
diff --git a/drivers/video/via/viafbdev.c b/drivers/video/via/viafbdev.c
index 0132eae06f55..73ac754ad801 100644
--- a/drivers/video/via/viafbdev.c
+++ b/drivers/video/via/viafbdev.c
@@ -2036,30 +2036,30 @@ static int viafb_vt1636_proc_write(struct file *file,
        return count;
 }
-static void viafb_init_proc(struct proc_dir_entry *viafb_entry)
+static void viafb_init_proc(struct proc_dir_entry **viafb_entry)
 {
        struct proc_dir_entry *entry;
-        viafb_entry = proc_mkdir("viafb", NULL);
+        *viafb_entry = proc_mkdir("viafb", NULL);
        if (viafb_entry) {
-                entry = create_proc_entry("dvp0", 0, viafb_entry);
+                entry = create_proc_entry("dvp0", 0, *viafb_entry);
                if (entry) {
                        entry->owner = THIS_MODULE;
                        entry->read_proc = viafb_dvp0_proc_read;
                        entry->write_proc = viafb_dvp0_proc_write;
                }
-                entry = create_proc_entry("dvp1", 0, viafb_entry);
+                entry = create_proc_entry("dvp1", 0, *viafb_entry);
                if (entry) {
                        entry->owner = THIS_MODULE;
                        entry->read_proc = viafb_dvp1_proc_read;
                        entry->write_proc = viafb_dvp1_proc_write;
                }
-                entry = create_proc_entry("dfph", 0, viafb_entry);
+                entry = create_proc_entry("dfph", 0, *viafb_entry);
                if (entry) {
                        entry->owner = THIS_MODULE;
                        entry->read_proc = viafb_dfph_proc_read;
                        entry->write_proc = viafb_dfph_proc_write;
                }
-                entry = create_proc_entry("dfpl", 0, viafb_entry);
+                entry = create_proc_entry("dfpl", 0, *viafb_entry);
                if (entry) {
                        entry->owner = THIS_MODULE;
                        entry->read_proc = viafb_dfpl_proc_read;
@@ -2068,7 +2068,7 @@ static void viafb_init_proc(struct proc_dir_entry *viafb_entry)
                if (VT1636_LVDS == viaparinfo->chip_info->lvds_chip_info.
                        lvds_chip_name || VT1636_LVDS ==
                    viaparinfo->chip_info->lvds_chip_info2.lvds_chip_name) {
-                        entry = create_proc_entry("vt1636", 0, viafb_entry);
+                        entry = create_proc_entry("vt1636", 0, *viafb_entry);
                        if (entry) {
                                entry->owner = THIS_MODULE;
                                entry->read_proc = viafb_vt1636_proc_read;
@@ -2087,6 +2087,7 @@ static void viafb_remove_proc(struct proc_dir_entry *viafb_entry)
        remove_proc_entry("dfpl", viafb_entry);
        remove_proc_entry("vt1636", viafb_entry);
        remove_proc_entry("vt1625", viafb_entry);
+        remove_proc_entry("viafb", NULL);
 }
 static int __devinit via_pci_probe(void)
@@ -2348,7 +2349,7 @@ static int __devinit via_pci_probe(void)
                  viafbinfo->node, viafbinfo->fix.id, default_var.xres,
                  default_var.yres, default_var.bits_per_pixel);
-        viafb_init_proc(viaparinfo->proc_entry);
+        viafb_init_proc(&viaparinfo->proc_entry);
        viafb_init_dac(IGA2);
        return 0;
 }
diff --git a/drivers/w1/masters/omap_hdq.c b/drivers/w1/masters/omap_hdq.c
index 1295625c4825..c973889110c8 100644
--- a/drivers/w1/masters/omap_hdq.c
+++ b/drivers/w1/masters/omap_hdq.c
@@ -86,8 +86,8 @@ static struct platform_driver omap_hdq_driver = {
 static u8 omap_w1_read_byte(void *_hdq);
 static void omap_w1_write_byte(void *_hdq, u8 byte);
 static u8 omap_w1_reset_bus(void *_hdq);
-static void omap_w1_search_bus(void *_hdq, u8 search_type,
+static void omap_w1_search_bus(void *_hdq, struct w1_master *master_dev,
-        w1_slave_found_callback slave_found);
+                u8 search_type, w1_slave_found_callback slave_found);
 static struct w1_bus_master omap_w1_master = {
@@ -231,8 +231,8 @@ static u8 omap_w1_reset_bus(void *_hdq)
 }
 /* W1 search callback function */
-static void omap_w1_search_bus(void *_hdq, u8 search_type,
+static void omap_w1_search_bus(void *_hdq, struct w1_master *master_dev,
-        w1_slave_found_callback slave_found)
+                u8 search_type, w1_slave_found_callback slave_found)
 {
        u64 module_id, rn_le, cs, id;
@@ -249,7 +249,7 @@ static void omap_w1_search_bus(void *_hdq, u8 search_type,
        cs = w1_calc_crc8((u8 *)&rn_le, 7);
        id = (cs << 56) | module_id;
-        slave_found(_hdq, id);
+        slave_found(master_dev, id);
 }
 static int _omap_hdq_reset(struct hdq_data *hdq_data)
diff --git a/drivers/xen/balloon.c b/drivers/xen/balloon.c
index a0fb5eac407c..526c191e84ea 100644
--- a/drivers/xen/balloon.c
+++ b/drivers/xen/balloon.c
@@ -122,14 +122,7 @@ static struct timer_list balloon_timer;
 static void scrub_page(struct page *page)
 {
 #ifdef CONFIG_XEN_SCRUB_PAGES
-        if (PageHighMem(page)) {
+        clear_highpage(page);
-                void *v = kmap(page);
-                clear_page(v);
-                kunmap(v);
-        } else {
-                void *v = page_address(page);
-                clear_page(v);
-        }
 #endif
 }
diff --git a/fs/cifs/CHANGES b/fs/cifs/CHANGES
index 8855331b2fba..e078b7aea143 100644
--- a/fs/cifs/CHANGES
+++ b/fs/cifs/CHANGES
@@ -8,7 +8,11 @@ handling fcntl(F_SETLEASE).  Convert cifs to using blocking tcp
 sends, and also let tcp autotune the socket send and receive buffers.
 This reduces the number of EAGAIN errors returned by TCP/IP in
 high stress workloads (and the number of retries on socket writes
-when sending large SMBWriteX requests).
+when sending large SMBWriteX requests).  Fix case in which a portion of
+data can in some cases not get written to the file on the server before the
+file is closed.  Fix DFS parsing to properly handle path consumed field,
+and to handle certain codepage conversions better.  Fix mount and
+umount race that can cause oops in mount or umount or reconnect.
 Version 1.54
 ------------
diff --git a/fs/cifs/cifsglob.h b/fs/cifs/cifsglob.h
index f1ae1f57c30d..c57c0565547f 100644
--- a/fs/cifs/cifsglob.h
+++ b/fs/cifs/cifsglob.h
@@ -606,7 +606,15 @@ GLOBAL_EXTERN struct list_head		cifs_tcp_ses_list;
 * changes to the tcon->tidStatus should be done while holding this lock.
 */
 GLOBAL_EXTERN rwlock_t          cifs_tcp_ses_lock;
-GLOBAL_EXTERN rwlock_t GlobalSMBSeslock;  /* protects list inserts on 3 above */
+/*
+ * This lock protects the cifs_file->llist and cifs_file->flist
+ * list operations, and updates to some flags (cifs_file->invalidHandle)
+ * It will be moved to either use the tcon->stat_lock or equivalent later.
+ * If cifs_tcp_ses_lock and the lock below are both needed to be held, then
+ * the cifs_tcp_ses_lock must be grabbed first and released last.
+ */
+GLOBAL_EXTERN rwlock_t GlobalSMBSeslock;
 GLOBAL_EXTERN struct list_head GlobalOplock_Q;
diff --git a/fs/cifs/cifssmb.c b/fs/cifs/cifssmb.c
index bdda46dd435a..2af8626ced43 100644
--- a/fs/cifs/cifssmb.c
+++ b/fs/cifs/cifssmb.c
@@ -295,7 +295,7 @@ smb_init(int smb_command, int wct, struct cifsTconInfo *tcon,
           check for tcp and smb session status done differently
           for those three - in the calling routine */
        if (tcon) {
-                if (tcon->need_reconnect) {
+                if (tcon->tidStatus == CifsExiting) {
                        /* only tree disconnect, open, and write,
                          (and ulogoff which does not have tcon)
                          are allowed as we start force umount */
diff --git a/fs/cifs/file.c b/fs/cifs/file.c
index 6449e1aae621..b691b893a848 100644
--- a/fs/cifs/file.c
+++ b/fs/cifs/file.c
@@ -488,12 +488,13 @@ int cifs_close(struct inode *inode, struct file *file)
        pTcon = cifs_sb->tcon;
        if (pSMBFile) {
                struct cifsLockInfo *li, *tmp;
+                write_lock(&GlobalSMBSeslock);
                pSMBFile->closePend = true;
                if (pTcon) {
                        /* no sense reconnecting to close a file that is
                           already closed */
                        if (!pTcon->need_reconnect) {
+                                write_unlock(&GlobalSMBSeslock);
                                timeout = 2;
                                while ((atomic_read(&pSMBFile->wrtPending) != 0)
                                        && (timeout <= 2048)) {
@@ -510,12 +511,15 @@ int cifs_close(struct inode *inode, struct file *file)
                                        timeout *= 4;
                                }
                                if (atomic_read(&pSMBFile->wrtPending))
-                                        cERROR(1,
+                                        cERROR(1, ("close with pending write"));
-                                                ("close with pending writes"));
+                                if (!pTcon->need_reconnect &&
-                                rc = CIFSSMBClose(xid, pTcon,
+                                    !pSMBFile->invalidHandle)
+                                        rc = CIFSSMBClose(xid, pTcon,
                                                  pSMBFile->netfid);
-                        }
+                        } else
-                }
+                                write_unlock(&GlobalSMBSeslock);
+                } else
+                        write_unlock(&GlobalSMBSeslock);
                /* Delete any outstanding lock records.
                   We'll lose them when the file is closed anyway. */
@@ -587,15 +591,18 @@ int cifs_closedir(struct inode *inode, struct file *file)
                pTcon = cifs_sb->tcon;
                cFYI(1, ("Freeing private data in close dir"));
+                write_lock(&GlobalSMBSeslock);
                if (!pCFileStruct->srch_inf.endOfSearch &&
                    !pCFileStruct->invalidHandle) {
                        pCFileStruct->invalidHandle = true;
+                        write_unlock(&GlobalSMBSeslock);
                        rc = CIFSFindClose(xid, pTcon, pCFileStruct->netfid);
                        cFYI(1, ("Closing uncompleted readdir with rc %d",
                                 rc));
                        /* not much we can do if it fails anyway, ignore rc */
                        rc = 0;
-                }
+                } else
+                        write_unlock(&GlobalSMBSeslock);
                ptmp = pCFileStruct->srch_inf.ntwrk_buf_start;
                if (ptmp) {
                        cFYI(1, ("closedir free smb buf in srch struct"));
diff --git a/fs/cifs/misc.c b/fs/cifs/misc.c
index addd1dcc2d79..9ee3f689c2b0 100644
--- a/fs/cifs/misc.c
+++ b/fs/cifs/misc.c
@@ -555,12 +555,14 @@ is_valid_oplock_break(struct smb_hdr *buf, struct TCP_Server_Info *srv)
                                continue;
                        cifs_stats_inc(&tcon->num_oplock_brks);
+                        write_lock(&GlobalSMBSeslock);
                        list_for_each(tmp2, &tcon->openFileList) {
                                netfile = list_entry(tmp2, struct cifsFileInfo,
                                                     tlist);
                                if (pSMB->Fid != netfile->netfid)
                                        continue;
+                                write_unlock(&GlobalSMBSeslock);
                                read_unlock(&cifs_tcp_ses_lock);
                                cFYI(1, ("file id match, oplock break"));
                                pCifsInode = CIFS_I(netfile->pInode);
@@ -576,6 +578,7 @@ is_valid_oplock_break(struct smb_hdr *buf, struct TCP_Server_Info *srv)
                                return true;
                        }
+                        write_unlock(&GlobalSMBSeslock);
                        read_unlock(&cifs_tcp_ses_lock);
                        cFYI(1, ("No matching file for oplock break"));
                        return true;
diff --git a/fs/cifs/readdir.c b/fs/cifs/readdir.c
index 58d57299f2a0..9f51f9bf0292 100644
--- a/fs/cifs/readdir.c
+++ b/fs/cifs/readdir.c
@@ -741,11 +741,14 @@ static int find_cifs_entry(const int xid, struct cifsTconInfo *pTcon,
           (index_to_find < first_entry_in_buffer)) {
                /* close and restart search */
                cFYI(1, ("search backing up - close and restart search"));
+                write_lock(&GlobalSMBSeslock);
                if (!cifsFile->srch_inf.endOfSearch &&
                    !cifsFile->invalidHandle) {
                        cifsFile->invalidHandle = true;
+                        write_unlock(&GlobalSMBSeslock);
                        CIFSFindClose(xid, pTcon, cifsFile->netfid);
-                }
+                } else
+                        write_unlock(&GlobalSMBSeslock);
                if (cifsFile->srch_inf.ntwrk_buf_start) {
                        cFYI(1, ("freeing SMB ff cache buf on search rewind"));
                        if (cifsFile->srch_inf.smallBuf)
diff --git a/fs/ecryptfs/keystore.c b/fs/ecryptfs/keystore.c
index e22bc3961345..0d713b691941 100644
--- a/fs/ecryptfs/keystore.c
+++ b/fs/ecryptfs/keystore.c
@@ -1037,17 +1037,14 @@ static int
 decrypt_passphrase_encrypted_session_key(struct ecryptfs_auth_tok *auth_tok,
                                         struct ecryptfs_crypt_stat *crypt_stat)
 {
-        struct scatterlist dst_sg;
+        struct scatterlist dst_sg[2];
-        struct scatterlist src_sg;
+        struct scatterlist src_sg[2];
        struct mutex *tfm_mutex;
        struct blkcipher_desc desc = {
                .flags = CRYPTO_TFM_REQ_MAY_SLEEP
        };
        int rc = 0;
-        sg_init_table(&dst_sg, 1);
-        sg_init_table(&src_sg, 1);
        if (unlikely(ecryptfs_verbosity > 0)) {
                ecryptfs_printk(
                        KERN_DEBUG, "Session key encryption key (size [%d]):\n",
@@ -1066,8 +1063,8 @@ decrypt_passphrase_encrypted_session_key(struct ecryptfs_auth_tok *auth_tok,
        }
        rc = virt_to_scatterlist(auth_tok->session_key.encrypted_key,
                                 auth_tok->session_key.encrypted_key_size,
-                                 &src_sg, 1);
+                                 src_sg, 2);
-        if (rc != 1) {
+        if (rc < 1 || rc > 2) {
                printk(KERN_ERR "Internal error whilst attempting to convert "
                        "auth_tok->session_key.encrypted_key to scatterlist; "
                        "expected rc = 1; got rc = [%d]. "
@@ -1079,8 +1076,8 @@ decrypt_passphrase_encrypted_session_key(struct ecryptfs_auth_tok *auth_tok,
                auth_tok->session_key.encrypted_key_size;
        rc = virt_to_scatterlist(auth_tok->session_key.decrypted_key,
                                 auth_tok->session_key.decrypted_key_size,
-                                 &dst_sg, 1);
+                                 dst_sg, 2);
-        if (rc != 1) {
+        if (rc < 1 || rc > 2) {
                printk(KERN_ERR "Internal error whilst attempting to convert "
                        "auth_tok->session_key.decrypted_key to scatterlist; "
                        "expected rc = 1; got rc = [%d]\n", rc);
@@ -1096,7 +1093,7 @@ decrypt_passphrase_encrypted_session_key(struct ecryptfs_auth_tok *auth_tok,
                rc = -EINVAL;
                goto out;
        }
-        rc = crypto_blkcipher_decrypt(&desc, &dst_sg, &src_sg,
+        rc = crypto_blkcipher_decrypt(&desc, dst_sg, src_sg,
                                      auth_tok->session_key.encrypted_key_size);
        mutex_unlock(tfm_mutex);
        if (unlikely(rc)) {
@@ -1539,8 +1536,8 @@ write_tag_3_packet(char *dest, size_t *remaining_bytes,
        size_t i;
        size_t encrypted_session_key_valid = 0;
        char session_key_encryption_key[ECRYPTFS_MAX_KEY_BYTES];
-        struct scatterlist dst_sg;
+        struct scatterlist dst_sg[2];
-        struct scatterlist src_sg;
+        struct scatterlist src_sg[2];
        struct mutex *tfm_mutex = NULL;
        u8 cipher_code;
        size_t packet_size_length;
@@ -1619,8 +1616,8 @@ write_tag_3_packet(char *dest, size_t *remaining_bytes,
                ecryptfs_dump_hex(session_key_encryption_key, 16);
        }
        rc = virt_to_scatterlist(crypt_stat->key, key_rec->enc_key_size,
-                                 &src_sg, 1);
+                                 src_sg, 2);
-        if (rc != 1) {
+        if (rc < 1 || rc > 2) {
                ecryptfs_printk(KERN_ERR, "Error generating scatterlist "
                                "for crypt_stat session key; expected rc = 1; "
                                "got rc = [%d]. key_rec->enc_key_size = [%d]\n",
@@ -1629,8 +1626,8 @@ write_tag_3_packet(char *dest, size_t *remaining_bytes,
                goto out;
        }
        rc = virt_to_scatterlist(key_rec->enc_key, key_rec->enc_key_size,
-                                 &dst_sg, 1);
+                                 dst_sg, 2);
-        if (rc != 1) {
+        if (rc < 1 || rc > 2) {
                ecryptfs_printk(KERN_ERR, "Error generating scatterlist "
                                "for crypt_stat encrypted session key; "
                                "expected rc = 1; got rc = [%d]. "
@@ -1651,7 +1648,7 @@ write_tag_3_packet(char *dest, size_t *remaining_bytes,
        rc = 0;
        ecryptfs_printk(KERN_DEBUG, "Encrypting [%d] bytes of the key\n",
                        crypt_stat->key_size);
-        rc = crypto_blkcipher_encrypt(&desc, &dst_sg, &src_sg,
+        rc = crypto_blkcipher_encrypt(&desc, dst_sg, src_sg,
                                      (*key_rec).enc_key_size);
        mutex_unlock(tfm_mutex);
        if (rc) {
diff --git a/fs/hostfs/hostfs.h b/fs/hostfs/hostfs.h
index 6ae9011b95eb..2f34f8f2134b 100644
--- a/fs/hostfs/hostfs.h
+++ b/fs/hostfs/hostfs.h
@@ -81,7 +81,7 @@ extern int do_rmdir(const char *file);
 extern int do_mknod(const char *file, int mode, unsigned int major,
                    unsigned int minor);
 extern int link_file(const char *from, const char *to);
-extern int do_readlink(char *file, char *buf, int size);
+extern int hostfs_do_readlink(char *file, char *buf, int size);
 extern int rename_file(char *from, char *to);
 extern int do_statfs(char *root, long *bsize_out, long long *blocks_out,
                     long long *bfree_out, long long *bavail_out,
diff --git a/fs/hostfs/hostfs_kern.c b/fs/hostfs/hostfs_kern.c
index 7f34f4385de0..3a31451ac170 100644
--- a/fs/hostfs/hostfs_kern.c
+++ b/fs/hostfs/hostfs_kern.c
@@ -168,7 +168,7 @@ static char *follow_link(char *link)
                if (name == NULL)
                        goto out;
-                n = do_readlink(link, name, len);
+                n = hostfs_do_readlink(link, name, len);
                if (n < len)
                        break;
                len *= 2;
@@ -943,7 +943,7 @@ int hostfs_link_readpage(struct file *file, struct page *page)
        name = inode_name(page->mapping->host, 0);
        if (name == NULL)
                return -ENOMEM;
-        err = do_readlink(name, buffer, PAGE_CACHE_SIZE);
+        err = hostfs_do_readlink(name, buffer, PAGE_CACHE_SIZE);
        kfree(name);
        if (err == PAGE_CACHE_SIZE)
                err = -E2BIG;
diff --git a/fs/hostfs/hostfs_user.c b/fs/hostfs/hostfs_user.c
index 53fd0a67c11a..b79424f93282 100644
--- a/fs/hostfs/hostfs_user.c
+++ b/fs/hostfs/hostfs_user.c
@@ -377,7 +377,7 @@ int link_file(const char *to, const char *from)
        return 0;
 }
-int do_readlink(char *file, char *buf, int size)
+int hostfs_do_readlink(char *file, char *buf, int size)
 {
        int n;
diff --git a/fs/namei.c b/fs/namei.c
index 09ce58e49e72..d34e0f9681c6 100644
--- a/fs/namei.c
+++ b/fs/namei.c
@@ -1378,7 +1378,7 @@ static int may_delete(struct inode *dir,struct dentry *victim,int isdir)
        if (IS_APPEND(dir))
                return -EPERM;
        if (check_sticky(dir, victim->d_inode)||IS_APPEND(victim->d_inode)||
-            IS_IMMUTABLE(victim->d_inode))
+            IS_IMMUTABLE(victim->d_inode) || IS_SWAPFILE(victim->d_inode))
                return -EPERM;
        if (isdir) {
                if (!S_ISDIR(victim->d_inode->i_mode))
diff --git a/include/asm-generic/vmlinux.lds.h b/include/asm-generic/vmlinux.lds.h
index 80744606bad1..3b46ae464933 100644
--- a/include/asm-generic/vmlinux.lds.h
+++ b/include/asm-generic/vmlinux.lds.h
@@ -45,6 +45,17 @@
 #define MCOUNT_REC()
 #endif
+#ifdef CONFIG_TRACE_BRANCH_PROFILING
+#define LIKELY_PROFILE()        VMLINUX_SYMBOL(__start_likely_profile) = .;   \
+                                *(_ftrace_likely)                             \
+                                VMLINUX_SYMBOL(__stop_likely_profile) = .;    \
+                                VMLINUX_SYMBOL(__start_unlikely_profile) = .; \
+                                *(_ftrace_unlikely)                           \
+                                VMLINUX_SYMBOL(__stop_unlikely_profile) = .;
+#else
+#define LIKELY_PROFILE()
+#endif
 /* .data section */
 #define DATA_DATA                                                       \
        *(.data)                                                        \
@@ -60,9 +71,11 @@
        VMLINUX_SYMBOL(__start___markers) = .;                          \
        *(__markers)                                                    \
        VMLINUX_SYMBOL(__stop___markers) = .;                           \
+        . = ALIGN(32);                                                  \
        VMLINUX_SYMBOL(__start___tracepoints) = .;                      \
        *(__tracepoints)                                                \
-        VMLINUX_SYMBOL(__stop___tracepoints) = .;
+        VMLINUX_SYMBOL(__stop___tracepoints) = .;                       \
+        LIKELY_PROFILE()
 #define RO_DATA(align)                                                  \
        . = ALIGN((align));                                             \
diff --git a/include/linux/compiler.h b/include/linux/compiler.h
index 98115d9d04da..c7d804a7a4d6 100644
--- a/include/linux/compiler.h
+++ b/include/linux/compiler.h
@@ -59,8 +59,70 @@ extern void __chk_io_ptr(const volatile void __iomem *);
 * specific implementations come from the above header files
 */
-#define likely(x)       __builtin_expect(!!(x), 1)
+struct ftrace_branch_data {
-#define unlikely(x)     __builtin_expect(!!(x), 0)
+        const char *func;
+        const char *file;
+        unsigned line;
+        unsigned long correct;
+        unsigned long incorrect;
+};
+/*
+ * Note: DISABLE_BRANCH_PROFILING can be used by special lowlevel code
+ * to disable branch tracing on a per file basis.
+ */
+#if defined(CONFIG_TRACE_BRANCH_PROFILING) && !defined(DISABLE_BRANCH_PROFILING)
+void ftrace_likely_update(struct ftrace_branch_data *f, int val, int expect);
+#define likely_notrace(x)       __builtin_expect(!!(x), 1)
+#define unlikely_notrace(x)     __builtin_expect(!!(x), 0)
+#define likely_check(x) ({                                              \
+                        int ______r;                                    \
+                        static struct ftrace_branch_data                \
+                                __attribute__((__aligned__(4)))         \
+                                __attribute__((section("_ftrace_likely"))) \
+                                ______f = {                             \
+                                .func = __func__,                       \
+                                .file = __FILE__,                       \
+                                .line = __LINE__,                       \
+                        };                                              \
+                        ______f.line = __LINE__;                        \
+                        ______r = likely_notrace(x);                    \
+                        ftrace_likely_update(&______f, ______r, 1);     \
+                        ______r;                                        \
+                })
+#define unlikely_check(x) ({                                            \
+                        int ______r;                                    \
+                        static struct ftrace_branch_data                \
+                                __attribute__((__aligned__(4)))         \
+                                __attribute__((section("_ftrace_unlikely"))) \
+                                ______f = {                             \
+                                .func = __func__,                       \
+                                .file = __FILE__,                       \
+                                .line = __LINE__,                       \
+                        };                                              \
+                        ______f.line = __LINE__;                        \
+                        ______r = unlikely_notrace(x);                  \
+                        ftrace_likely_update(&______f, ______r, 0);     \
+                        ______r;                                        \
+                })
+/*
+ * Using __builtin_constant_p(x) to ignore cases where the return
+ * value is always the same.  This idea is taken from a similar patch
+ * written by Daniel Walker.
+ */
+# ifndef likely
+#  define likely(x)     (__builtin_constant_p(x) ? !!(x) : likely_check(x))
+# endif
+# ifndef unlikely
+#  define unlikely(x)   (__builtin_constant_p(x) ? !!(x) : unlikely_check(x))
+# endif
+#else
+# define likely(x)      __builtin_expect(!!(x), 1)
+# define unlikely(x)    __builtin_expect(!!(x), 0)
+#endif
 /* Optimization barrier */
 #ifndef barrier
diff --git a/include/linux/cpuset.h b/include/linux/cpuset.h
index 2691926fb506..8e540d32c9fe 100644
--- a/include/linux/cpuset.h
+++ b/include/linux/cpuset.h
@@ -74,8 +74,6 @@ static inline int cpuset_do_slab_mem_spread(void)
        return current->flags & PF_SPREAD_SLAB;
 }
-extern void cpuset_track_online_nodes(void);
 extern int current_cpuset_is_being_rebound(void);
 extern void rebuild_sched_domains(void);
@@ -151,8 +149,6 @@ static inline int cpuset_do_slab_mem_spread(void)
        return 0;
 }
-static inline void cpuset_track_online_nodes(void) {}
 static inline int current_cpuset_is_being_rebound(void)
 {
        return 0;
diff --git a/include/linux/ftrace.h b/include/linux/ftrace.h
index 703eb53cfa2b..f7ba4ea5e128 100644
--- a/include/linux/ftrace.h
+++ b/include/linux/ftrace.h
@@ -23,6 +23,45 @@ struct ftrace_ops {
        struct ftrace_ops *next;
 };
+extern int function_trace_stop;
+/*
+ * Type of the current tracing.
+ */
+enum ftrace_tracing_type_t {
+        FTRACE_TYPE_ENTER = 0, /* Hook the call of the function */
+        FTRACE_TYPE_RETURN,     /* Hook the return of the function */
+};
+/* Current tracing type, default is FTRACE_TYPE_ENTER */
+extern enum ftrace_tracing_type_t ftrace_tracing_type;
+/**
+ * ftrace_stop - stop function tracer.
+ *
+ * A quick way to stop the function tracer. Note this an on off switch,
+ * it is not something that is recursive like preempt_disable.
+ * This does not disable the calling of mcount, it only stops the
+ * calling of functions from mcount.
+ */
+static inline void ftrace_stop(void)
+{
+        function_trace_stop = 1;
+}
+/**
+ * ftrace_start - start the function tracer.
+ *
+ * This function is the inverse of ftrace_stop. This does not enable
+ * the function tracing if the function tracer is disabled. This only
+ * sets the function tracer flag to continue calling the functions
+ * from mcount.
+ */
+static inline void ftrace_start(void)
+{
+        function_trace_stop = 0;
+}
 /*
 * The ftrace_ops must be a static and should also
 * be read_mostly.  These functions do modify read_mostly variables
@@ -41,9 +80,13 @@ extern void ftrace_stub(unsigned long a0, unsigned long a1);
 # define unregister_ftrace_function(ops) do { } while (0)
 # define clear_ftrace_function(ops) do { } while (0)
 static inline void ftrace_kill(void) { }
+static inline void ftrace_stop(void) { }
+static inline void ftrace_start(void) { }
 #endif /* CONFIG_FUNCTION_TRACER */
 #ifdef CONFIG_DYNAMIC_FTRACE
+/* asm/ftrace.h must be defined for archs supporting dynamic ftrace */
+#include <asm/ftrace.h>
 enum {
        FTRACE_FL_FREE          = (1 << 0),
@@ -59,6 +102,7 @@ struct dyn_ftrace {
        struct list_head        list;
        unsigned long           ip; /* address of mcount call-site */
        unsigned long           flags;
+        struct dyn_arch_ftrace  arch;
 };
 int ftrace_force_update(void);
@@ -66,19 +110,43 @@ void ftrace_set_filter(unsigned char *buf, int len, int reset);
 /* defined in arch */
 extern int ftrace_ip_converted(unsigned long ip);
-extern unsigned char *ftrace_nop_replace(void);
-extern unsigned char *ftrace_call_replace(unsigned long ip, unsigned long addr);
 extern int ftrace_dyn_arch_init(void *data);
 extern int ftrace_update_ftrace_func(ftrace_func_t func);
 extern void ftrace_caller(void);
 extern void ftrace_call(void);
 extern void mcount_call(void);
+#ifdef CONFIG_FUNCTION_RET_TRACER
+extern void ftrace_return_caller(void);
+#endif
+/**
+ * ftrace_make_nop - convert code into top
+ * @mod: module structure if called by module load initialization
+ * @rec: the mcount call site record
+ * @addr: the address that the call site should be calling
+ *
+ * This is a very sensitive operation and great care needs
+ * to be taken by the arch.  The operation should carefully
+ * read the location, check to see if what is read is indeed
+ * what we expect it to be, and then on success of the compare,
+ * it should write to the location.
+ *
+ * The code segment at @rec->ip should be a caller to @addr
+ *
+ * Return must be:
+ *  0 on success
+ *  -EFAULT on error reading the location
+ *  -EINVAL on a failed compare of the contents
+ *  -EPERM  on error writing to the location
+ * Any other value will be considered a failure.
+ */
+extern int ftrace_make_nop(struct module *mod,
+                           struct dyn_ftrace *rec, unsigned long addr);
 /**
- * ftrace_modify_code - modify code segment
+ * ftrace_make_call - convert a nop call site into a call to addr
- * @ip: the address of the code segment
+ * @rec: the mcount call site record
- * @old_code: the contents of what is expected to be there
+ * @addr: the address that the call site should call
- * @new_code: the code to patch in
 *
 * This is a very sensitive operation and great care needs
 * to be taken by the arch.  The operation should carefully
@@ -86,6 +154,8 @@ extern void mcount_call(void);
 * what we expect it to be, and then on success of the compare,
 * it should write to the location.
 *
+ * The code segment at @rec->ip should be a nop
+ *
 * Return must be:
 *  0 on success
 *  -EFAULT on error reading the location
@@ -93,8 +163,11 @@ extern void mcount_call(void);
 *  -EPERM  on error writing to the location
 * Any other value will be considered a failure.
 */
-extern int ftrace_modify_code(unsigned long ip, unsigned char *old_code,
+extern int ftrace_make_call(struct dyn_ftrace *rec, unsigned long addr);
-                              unsigned char *new_code);
+/* May be defined in arch */
+extern int ftrace_arch_read_dyn_info(char *buf, int size);
 extern int skip_trace(unsigned long ip);
@@ -102,7 +175,6 @@ extern void ftrace_release(void *start, unsigned long size);
 extern void ftrace_disable_daemon(void);
 extern void ftrace_enable_daemon(void);
 #else
 # define skip_trace(ip)                         ({ 0; })
 # define ftrace_force_update()                  ({ 0; })
@@ -181,6 +253,11 @@ static inline void __ftrace_enabled_restore(int enabled)
 #endif
 #ifdef CONFIG_TRACING
+extern int ftrace_dump_on_oops;
+extern void tracing_start(void);
+extern void tracing_stop(void);
 extern void
 ftrace_special(unsigned long arg1, unsigned long arg2, unsigned long arg3);
@@ -211,6 +288,8 @@ ftrace_special(unsigned long arg1, unsigned long arg2, unsigned long arg3) { }
 static inline int
 ftrace_printk(const char *fmt, ...) __attribute__ ((format (printf, 1, 0)));
+static inline void tracing_start(void) { }
+static inline void tracing_stop(void) { }
 static inline int
 ftrace_printk(const char *fmt, ...)
 {
@@ -221,33 +300,36 @@ static inline void ftrace_dump(void) { }
 #ifdef CONFIG_FTRACE_MCOUNT_RECORD
 extern void ftrace_init(void);
-extern void ftrace_init_module(unsigned long *start, unsigned long *end);
+extern void ftrace_init_module(struct module *mod,
+                               unsigned long *start, unsigned long *end);
 #else
 static inline void ftrace_init(void) { }
 static inline void
-ftrace_init_module(unsigned long *start, unsigned long *end) { }
+ftrace_init_module(struct module *mod,
+                   unsigned long *start, unsigned long *end) { }
 #endif
-struct boot_trace {
+/*
-        pid_t                   caller;
+ * Structure that defines a return function trace.
-        char                    func[KSYM_NAME_LEN];
+ */
-        int                     result;
+struct ftrace_retfunc {
-        unsigned long long      duration;               /* usecs */
+        unsigned long ret; /* Return address */
-        ktime_t                 calltime;
+        unsigned long func; /* Current function */
-        ktime_t                 rettime;
+        unsigned long long calltime;
+        unsigned long long rettime;
+        /* Number of functions that overran the depth limit for current task */
+        unsigned long overrun;
 };
-#ifdef CONFIG_BOOT_TRACER
+#ifdef CONFIG_FUNCTION_RET_TRACER
-extern void trace_boot(struct boot_trace *it, initcall_t fn);
+/* Type of a callback handler of tracing return function */
-extern void start_boot_trace(void);
+typedef void (*trace_function_return_t)(struct ftrace_retfunc *);
-extern void stop_boot_trace(void);
-#else
-static inline void trace_boot(struct boot_trace *it, initcall_t fn) { }
-static inline void start_boot_trace(void) { }
-static inline void stop_boot_trace(void) { }
-#endif
+extern int register_ftrace_return(trace_function_return_t func);
+/* The current handler in use */
+extern trace_function_return_t ftrace_function_return;
+extern void unregister_ftrace_return(void);
+#endif
 #endif /* _LINUX_FTRACE_H */
diff --git a/include/linux/ftrace_irq.h b/include/linux/ftrace_irq.h
new file mode 100644
index 000000000000..0b4df55d7a74
--- /dev/null
+++ b/include/linux/ftrace_irq.h
@@ -0,0 +1,13 @@
+#ifndef _LINUX_FTRACE_IRQ_H
+#define _LINUX_FTRACE_IRQ_H
+#if defined(CONFIG_DYNAMIC_FTRACE) || defined(CONFIG_FUNCTION_RET_TRACER)
+extern void ftrace_nmi_enter(void);
+extern void ftrace_nmi_exit(void);
+#else
+static inline void ftrace_nmi_enter(void) { }
+static inline void ftrace_nmi_exit(void) { }
+#endif
+#endif /* _LINUX_FTRACE_IRQ_H */
diff --git a/include/linux/hardirq.h b/include/linux/hardirq.h
index 181006cc94a0..89a56d79e4c6 100644
--- a/include/linux/hardirq.h
+++ b/include/linux/hardirq.h
@@ -4,6 +4,7 @@
 #include <linux/preempt.h>
 #include <linux/smp_lock.h>
 #include <linux/lockdep.h>
+#include <linux/ftrace_irq.h>
 #include <asm/hardirq.h>
 #include <asm/system.h>
@@ -161,7 +162,17 @@ extern void irq_enter(void);
 */
 extern void irq_exit(void);
-#define nmi_enter()             do { lockdep_off(); __irq_enter(); } while (0)
+#define nmi_enter()                             \
-#define nmi_exit()              do { __irq_exit(); lockdep_on(); } while (0)
+        do {                                    \
+                ftrace_nmi_enter();             \
+                lockdep_off();                  \
+                __irq_enter();                  \
+        } while (0)
+#define nmi_exit()                              \
+        do {                                    \
+                __irq_exit();                   \
+                lockdep_on();                   \
+                ftrace_nmi_exit();              \
+        } while (0)
 #endif /* LINUX_HARDIRQ_H */
diff --git a/include/linux/marker.h b/include/linux/marker.h
index 889196c7fbb1..34c14bc957f5 100644
--- a/include/linux/marker.h
+++ b/include/linux/marker.h
@@ -12,6 +12,7 @@
 * See the file COPYING for more details.
 */
+#include <stdarg.h>
 #include <linux/types.h>
 struct module;
@@ -48,10 +49,28 @@ struct marker {
        void (*call)(const struct marker *mdata, void *call_private, ...);
        struct marker_probe_closure single;
        struct marker_probe_closure *multi;
+        const char *tp_name;    /* Optional tracepoint name */
+        void *tp_cb;            /* Optional tracepoint callback */
 } __attribute__((aligned(8)));
 #ifdef CONFIG_MARKERS
+#define _DEFINE_MARKER(name, tp_name_str, tp_cb, format)                \
+                static const char __mstrtab_##name[]                    \
+                __attribute__((section("__markers_strings")))           \
+                = #name "\0" format;                                    \
+                static struct marker __mark_##name                      \
+                __attribute__((section("__markers"), aligned(8))) =     \
+                { __mstrtab_##name, &__mstrtab_##name[sizeof(#name)],   \
+                  0, 0, marker_probe_cb, { __mark_empty_function, NULL},\
+                  NULL, tp_name_str, tp_cb }
+#define DEFINE_MARKER(name, format)                                     \
+                _DEFINE_MARKER(name, NULL, NULL, format)
+#define DEFINE_MARKER_TP(name, tp_name, tp_cb, format)                  \
+                _DEFINE_MARKER(name, #tp_name, tp_cb, format)
 /*
 * Note : the empty asm volatile with read constraint is used here instead of a
 * "used" attribute to fix a gcc 4.1.x bug.
@@ -65,14 +84,7 @@ struct marker {
 */
 #define __trace_mark(generic, name, call_private, format, args...)      \
        do {                                                            \
-                static const char __mstrtab_##name[]                    \
+                DEFINE_MARKER(name, format);                            \
-                __attribute__((section("__markers_strings")))           \
-                = #name "\0" format;                                    \
-                static struct marker __mark_##name                      \
-                __attribute__((section("__markers"), aligned(8))) =     \
-                { __mstrtab_##name, &__mstrtab_##name[sizeof(#name)],   \
-                0, 0, marker_probe_cb,                                  \
-                { __mark_empty_function, NULL}, NULL };                 \
                __mark_check_format(format, ## args);                   \
                if (unlikely(__mark_##name.state)) {                    \
                        (*__mark_##name.call)                           \
@@ -80,14 +92,39 @@ struct marker {
                }                                                       \
        } while (0)
+#define __trace_mark_tp(name, call_private, tp_name, tp_cb, format, args...) \
+        do {                                                            \
+                void __check_tp_type(void)                              \
+                {                                                       \
+                        register_trace_##tp_name(tp_cb);                \
+                }                                                       \
+                DEFINE_MARKER_TP(name, tp_name, tp_cb, format);         \
+                __mark_check_format(format, ## args);                   \
+                (*__mark_##name.call)(&__mark_##name, call_private,     \
+                                        ## args);                       \
+        } while (0)
 extern void marker_update_probe_range(struct marker *begin,
        struct marker *end);
+#define GET_MARKER(name)        (__mark_##name)
 #else /* !CONFIG_MARKERS */
+#define DEFINE_MARKER(name, tp_name, tp_cb, format)
 #define __trace_mark(generic, name, call_private, format, args...) \
                __mark_check_format(format, ## args)
+#define __trace_mark_tp(name, call_private, tp_name, tp_cb, format, args...) \
+        do {                                                            \
+                void __check_tp_type(void)                              \
+                {                                                       \
+                        register_trace_##tp_name(tp_cb);                \
+                }                                                       \
+                __mark_check_format(format, ## args);                   \
+        } while (0)
 static inline void marker_update_probe_range(struct marker *begin,
        struct marker *end)
 { }
+#define GET_MARKER(name)
 #endif /* CONFIG_MARKERS */
 /**
@@ -117,6 +154,20 @@ static inline void marker_update_probe_range(struct marker *begin,
        __trace_mark(1, name, NULL, format, ## args)
 /**
+ * trace_mark_tp - Marker in a tracepoint callback
+ * @name: marker name, not quoted.
+ * @tp_name: tracepoint name, not quoted.
+ * @tp_cb: tracepoint callback. Should have an associated global symbol so it
+ *         is not optimized away by the compiler (should not be static).
+ * @format: format string
+ * @args...: variable argument list
+ *
+ * Places a marker in a tracepoint callback.
+ */
+#define trace_mark_tp(name, tp_name, tp_cb, format, args...)    \
+        __trace_mark_tp(name, NULL, tp_name, tp_cb, format, ## args)
+/**
 * MARK_NOARGS - Format string for a marker with no argument.
 */
 #define MARK_NOARGS " "
@@ -136,8 +187,6 @@ extern marker_probe_func __mark_empty_function;
 extern void marker_probe_cb(const struct marker *mdata,
        void *call_private, ...);
-extern void marker_probe_cb_noarg(const struct marker *mdata,
-        void *call_private, ...);
 /*
 * Connect a probe to a marker.
diff --git a/include/linux/net.h b/include/linux/net.h
index 6dc14a240042..4515efae4c39 100644
--- a/include/linux/net.h
+++ b/include/linux/net.h
@@ -40,7 +40,7 @@
 #define SYS_GETSOCKOPT  15              /* sys_getsockopt(2)            */
 #define SYS_SENDMSG     16              /* sys_sendmsg(2)               */
 #define SYS_RECVMSG     17              /* sys_recvmsg(2)               */
-#define SYS_PACCEPT     18              /* sys_paccept(2)               */
+#define SYS_ACCEPT4     18              /* sys_accept4(2)               */
 typedef enum {
        SS_FREE = 0,                    /* not allocated                */
@@ -100,7 +100,7 @@ enum sock_type {
 * remaining bits are used as flags. */
 #define SOCK_TYPE_MASK 0xf
-/* Flags for socket, socketpair, paccept */
+/* Flags for socket, socketpair, accept4 */
 #define SOCK_CLOEXEC    O_CLOEXEC
 #ifndef SOCK_NONBLOCK
 #define SOCK_NONBLOCK   O_NONBLOCK
@@ -223,8 +223,6 @@ extern int 	     sock_map_fd(struct socket *sock, int flags);
 extern struct socket *sockfd_lookup(int fd, int *err);
 #define              sockfd_put(sock) fput(sock->file)
 extern int           net_ratelimit(void);
-extern long          do_accept(int fd, struct sockaddr __user *upeer_sockaddr,
-                               int __user *upeer_addrlen, int flags);
 #define net_random()            random32()
 #define net_srandom(seed)       srandom32((__force u32)seed)
diff --git a/include/linux/rcupdate.h b/include/linux/rcupdate.h
index 86f1f5e43e33..895dc9c1088c 100644
--- a/include/linux/rcupdate.h
+++ b/include/linux/rcupdate.h
@@ -142,6 +142,7 @@ struct rcu_head {
 * on the write-side to insure proper synchronization.
 */
 #define rcu_read_lock_sched() preempt_disable()
+#define rcu_read_lock_sched_notrace() preempt_disable_notrace()
 /*
 * rcu_read_unlock_sched - marks the end of a RCU-classic critical section
@@ -149,6 +150,7 @@ struct rcu_head {
 * See rcu_read_lock_sched for more information.
 */
 #define rcu_read_unlock_sched() preempt_enable()
+#define rcu_read_unlock_sched_notrace() preempt_enable_notrace()
diff --git a/include/linux/sched.h b/include/linux/sched.h
index 644ffbda17ca..c8e0db464206 100644
--- a/include/linux/sched.h
+++ b/include/linux/sched.h
@@ -2006,6 +2006,18 @@ static inline void setup_thread_stack(struct task_struct *p, struct task_struct
 {
        *task_thread_info(p) = *task_thread_info(org);
        task_thread_info(p)->task = p;
+#ifdef CONFIG_FUNCTION_RET_TRACER
+        /*
+         * When fork() creates a child process, this function is called.
+         * But the child task may not inherit the return adresses traced
+         * by the return function tracer because it will directly execute
+         * in userspace and will not return to kernel functions its parent
+         * used.
+         */
+        task_thread_info(p)->curr_ret_stack = -1;
+        atomic_set(&task_thread_info(p)->trace_overrun, 0);
+#endif
 }
 static inline unsigned long *end_of_stack(struct task_struct *p)
diff --git a/include/linux/syscalls.h b/include/linux/syscalls.h
index d6ff145919ca..04fb47bfb920 100644
--- a/include/linux/syscalls.h
+++ b/include/linux/syscalls.h
@@ -410,8 +410,7 @@ asmlinkage long sys_getsockopt(int fd, int level, int optname,
 asmlinkage long sys_bind(int, struct sockaddr __user *, int);
 asmlinkage long sys_connect(int, struct sockaddr __user *, int);
 asmlinkage long sys_accept(int, struct sockaddr __user *, int __user *);
-asmlinkage long sys_paccept(int, struct sockaddr __user *, int __user *,
+asmlinkage long sys_accept4(int, struct sockaddr __user *, int __user *, int);
-                            const __user sigset_t *, size_t, int);
 asmlinkage long sys_getsockname(int, struct sockaddr __user *, int __user *);
 asmlinkage long sys_getpeername(int, struct sockaddr __user *, int __user *);
 asmlinkage long sys_send(int, void __user *, size_t, unsigned);
diff --git a/include/linux/tracepoint.h b/include/linux/tracepoint.h
index c5bb39c7a770..757005458366 100644
--- a/include/linux/tracepoint.h
+++ b/include/linux/tracepoint.h
@@ -24,8 +24,12 @@ struct tracepoint {
        const char *name;               /* Tracepoint name */
        int state;                      /* State. */
        void **funcs;
-} __attribute__((aligned(8)));
+} __attribute__((aligned(32)));         /*
+                                         * Aligned on 32 bytes because it is
+                                         * globally visible and gcc happily
+                                         * align these on the structure size.
+                                         * Keep in sync with vmlinux.lds.h.
+                                         */
 #define TPPROTO(args...)        args
 #define TPARGS(args...)         args
@@ -40,14 +44,14 @@ struct tracepoint {
        do {                                                            \
                void **it_func;                                         \
                                                                        \
-                rcu_read_lock_sched();                                  \
+                rcu_read_lock_sched_notrace();                          \
                it_func = rcu_dereference((tp)->funcs);                 \
                if (it_func) {                                          \
                        do {                                            \
                                ((void(*)(proto))(*it_func))(args);     \
                        } while (*(++it_func));                         \
                }                                                       \
-                rcu_read_unlock_sched();                                \
+                rcu_read_unlock_sched_notrace();                        \
        } while (0)
 /*
@@ -55,35 +59,40 @@ struct tracepoint {
 * not add unwanted padding between the beginning of the section and the
 * structure. Force alignment to the same alignment as the section start.
 */
-#define DEFINE_TRACE(name, proto, args)                                 \
+#define DECLARE_TRACE(name, proto, args)                                \
+        extern struct tracepoint __tracepoint_##name;                   \
        static inline void trace_##name(proto)                          \
        {                                                               \
-                static const char __tpstrtab_##name[]                   \
-                __attribute__((section("__tracepoints_strings")))       \
-                = #name ":" #proto;                                     \
-                static struct tracepoint __tracepoint_##name            \
-                __attribute__((section("__tracepoints"), aligned(8))) = \
-                { __tpstrtab_##name, 0, NULL };                         \
                if (unlikely(__tracepoint_##name.state))                \
                        __DO_TRACE(&__tracepoint_##name,                \
                                TPPROTO(proto), TPARGS(args));          \
        }                                                               \
        static inline int register_trace_##name(void (*probe)(proto))   \
        {                                                               \
-                return tracepoint_probe_register(#name ":" #proto,      \
+                return tracepoint_probe_register(#name, (void *)probe); \
-                        (void *)probe);                                 \
        }                                                               \
-        static inline void unregister_trace_##name(void (*probe)(proto))\
+        static inline int unregister_trace_##name(void (*probe)(proto)) \
        {                                                               \
-                tracepoint_probe_unregister(#name ":" #proto,           \
+                return tracepoint_probe_unregister(#name, (void *)probe);\
-                        (void *)probe);                                 \
        }
+#define DEFINE_TRACE(name)                                              \
+        static const char __tpstrtab_##name[]                           \
+        __attribute__((section("__tracepoints_strings"))) = #name;      \
+        struct tracepoint __tracepoint_##name                           \
+        __attribute__((section("__tracepoints"), aligned(32))) =        \
+                { __tpstrtab_##name, 0, NULL }
+#define EXPORT_TRACEPOINT_SYMBOL_GPL(name)                              \
+        EXPORT_SYMBOL_GPL(__tracepoint_##name)
+#define EXPORT_TRACEPOINT_SYMBOL(name)                                  \
+        EXPORT_SYMBOL(__tracepoint_##name)
 extern void tracepoint_update_probe_range(struct tracepoint *begin,
        struct tracepoint *end);
 #else /* !CONFIG_TRACEPOINTS */
-#define DEFINE_TRACE(name, proto, args)                 \
+#define DECLARE_TRACE(name, proto, args)                                \
        static inline void _do_trace_##name(struct tracepoint *tp, proto) \
        { }                                                             \
        static inline void trace_##name(proto)                          \
@@ -92,8 +101,14 @@ extern void tracepoint_update_probe_range(struct tracepoint *begin,
        {                                                               \
                return -ENOSYS;                                         \
        }                                                               \
-        static inline void unregister_trace_##name(void (*probe)(proto))\
+        static inline int unregister_trace_##name(void (*probe)(proto)) \
-        { }
+        {                                                               \
+                return -ENOSYS;                                         \
+        }
+#define DEFINE_TRACE(name)
+#define EXPORT_TRACEPOINT_SYMBOL_GPL(name)
+#define EXPORT_TRACEPOINT_SYMBOL(name)
 static inline void tracepoint_update_probe_range(struct tracepoint *begin,
        struct tracepoint *end)
@@ -112,6 +127,10 @@ extern int tracepoint_probe_register(const char *name, void *probe);
 */
 extern int tracepoint_probe_unregister(const char *name, void *probe);
+extern int tracepoint_probe_register_noupdate(const char *name, void *probe);
+extern int tracepoint_probe_unregister_noupdate(const char *name, void *probe);
+extern void tracepoint_probe_update_all(void);
 struct tracepoint_iter {
        struct module *module;
        struct tracepoint *tracepoint;
diff --git a/include/net/mac80211.h b/include/net/mac80211.h
index 8856e2d60e9f..73d81bc6aa75 100644
--- a/include/net/mac80211.h
+++ b/include/net/mac80211.h
@@ -74,14 +74,6 @@
 */
 /**
- * enum ieee80211_notification_type - Low level driver notification
- * @IEEE80211_NOTIFY_RE_ASSOC: start the re-association sequence
- */
-enum ieee80211_notification_types {
-        IEEE80211_NOTIFY_RE_ASSOC,
-};
-/**
 * struct ieee80211_ht_bss_info - describing BSS's HT characteristics
 *
 * This structure describes most essential parameters needed
@@ -1798,18 +1790,6 @@ void ieee80211_stop_tx_ba_cb_irqsafe(struct ieee80211_hw *hw, const u8 *ra,
                                     u16 tid);
 /**
- * ieee80211_notify_mac - low level driver notification
- * @hw: pointer as obtained from ieee80211_alloc_hw().
- * @notif_type: enum ieee80211_notification_types
- *
- * This function must be called by low level driver to inform mac80211 of
- * low level driver status change or force mac80211 to re-assoc for low
- * level driver internal error that require re-assoc.
- */
-void ieee80211_notify_mac(struct ieee80211_hw *hw,
-                          enum ieee80211_notification_types  notif_type);
-/**
 * ieee80211_find_sta - find a station
 *
 * @hw: pointer as obtained from ieee80211_alloc_hw()
diff --git a/include/trace/boot.h b/include/trace/boot.h
new file mode 100644
index 000000000000..6b54537eab02
--- /dev/null
+++ b/include/trace/boot.h
@@ -0,0 +1,56 @@
+#ifndef _LINUX_TRACE_BOOT_H
+#define _LINUX_TRACE_BOOT_H
+/*
+ * Structure which defines the trace of an initcall
+ * while it is called.
+ * You don't have to fill the func field since it is
+ * only used internally by the tracer.
+ */
+struct boot_trace_call {
+        pid_t                   caller;
+        char                    func[KSYM_NAME_LEN];
+};
+/*
+ * Structure which defines the trace of an initcall
+ * while it returns.
+ */
+struct boot_trace_ret {
+        char                    func[KSYM_NAME_LEN];
+        int                             result;
+        unsigned long long      duration;               /* nsecs */
+};
+#ifdef CONFIG_BOOT_TRACER
+/* Append the traces on the ring-buffer */
+extern void trace_boot_call(struct boot_trace_call *bt, initcall_t fn);
+extern void trace_boot_ret(struct boot_trace_ret *bt, initcall_t fn);
+/* Tells the tracer that smp_pre_initcall is finished.
+ * So we can start the tracing
+ */
+extern void start_boot_trace(void);
+/* Resume the tracing of other necessary events
+ * such as sched switches
+ */
+extern void enable_boot_trace(void);
+/* Suspend this tracing. Actually, only sched_switches tracing have
+ * to be suspended. Initcalls doesn't need it.)
+ */
+extern void disable_boot_trace(void);
+#else
+static inline
+void trace_boot_call(struct boot_trace_call *bt, initcall_t fn) { }
+static inline
+void trace_boot_ret(struct boot_trace_ret *bt, initcall_t fn) { }
+static inline void start_boot_trace(void) { }
+static inline void enable_boot_trace(void) { }
+static inline void disable_boot_trace(void) { }
+#endif /* CONFIG_BOOT_TRACER */
+#endif /* __LINUX_TRACE_BOOT_H */
diff --git a/include/trace/sched.h b/include/trace/sched.h
index ad47369d01b5..9b2854abf7e2 100644
--- a/include/trace/sched.h
+++ b/include/trace/sched.h
@@ -4,52 +4,52 @@
 #include <linux/sched.h>
 #include <linux/tracepoint.h>
-DEFINE_TRACE(sched_kthread_stop,
+DECLARE_TRACE(sched_kthread_stop,
        TPPROTO(struct task_struct *t),
                TPARGS(t));
-DEFINE_TRACE(sched_kthread_stop_ret,
+DECLARE_TRACE(sched_kthread_stop_ret,
        TPPROTO(int ret),
                TPARGS(ret));
-DEFINE_TRACE(sched_wait_task,
+DECLARE_TRACE(sched_wait_task,
        TPPROTO(struct rq *rq, struct task_struct *p),
                TPARGS(rq, p));
-DEFINE_TRACE(sched_wakeup,
+DECLARE_TRACE(sched_wakeup,
        TPPROTO(struct rq *rq, struct task_struct *p),
                TPARGS(rq, p));
-DEFINE_TRACE(sched_wakeup_new,
+DECLARE_TRACE(sched_wakeup_new,
        TPPROTO(struct rq *rq, struct task_struct *p),
                TPARGS(rq, p));
-DEFINE_TRACE(sched_switch,
+DECLARE_TRACE(sched_switch,
        TPPROTO(struct rq *rq, struct task_struct *prev,
                struct task_struct *next),
                TPARGS(rq, prev, next));
-DEFINE_TRACE(sched_migrate_task,
+DECLARE_TRACE(sched_migrate_task,
        TPPROTO(struct rq *rq, struct task_struct *p, int dest_cpu),
                TPARGS(rq, p, dest_cpu));
-DEFINE_TRACE(sched_process_free,
+DECLARE_TRACE(sched_process_free,
        TPPROTO(struct task_struct *p),
                TPARGS(p));
-DEFINE_TRACE(sched_process_exit,
+DECLARE_TRACE(sched_process_exit,
        TPPROTO(struct task_struct *p),
                TPARGS(p));
-DEFINE_TRACE(sched_process_wait,
+DECLARE_TRACE(sched_process_wait,
        TPPROTO(struct pid *pid),
                TPARGS(pid));
-DEFINE_TRACE(sched_process_fork,
+DECLARE_TRACE(sched_process_fork,
        TPPROTO(struct task_struct *parent, struct task_struct *child),
                TPARGS(parent, child));
-DEFINE_TRACE(sched_signal_send,
+DECLARE_TRACE(sched_signal_send,
        TPPROTO(int sig, struct task_struct *p),
                TPARGS(sig, p));
diff --git a/init/Kconfig b/init/Kconfig
index f763762d544a..f291f086caa1 100644
--- a/init/Kconfig
+++ b/init/Kconfig
@@ -808,6 +808,7 @@ config TRACEPOINTS
 config MARKERS
        bool "Activate markers"
+        depends on TRACEPOINTS
        help
          Place an empty function call at each marker site. Can be
          dynamically changed for a probe function.
diff --git a/init/main.c b/init/main.c
index 7e117a231af1..e810196bf2f2 100644
--- a/init/main.c
+++ b/init/main.c
@@ -63,6 +63,7 @@
 #include <linux/signal.h>
 #include <linux/idr.h>
 #include <linux/ftrace.h>
+#include <trace/boot.h>
 #include <asm/io.h>
 #include <asm/bugs.h>
@@ -703,31 +704,35 @@ core_param(initcall_debug, initcall_debug, bool, 0644);
 int do_one_initcall(initcall_t fn)
 {
        int count = preempt_count();
-        ktime_t delta;
+        ktime_t calltime, delta, rettime;
        char msgbuf[64];
-        struct boot_trace it;
+        struct boot_trace_call call;
+        struct boot_trace_ret ret;
        if (initcall_debug) {
-                it.caller = task_pid_nr(current);
+                call.caller = task_pid_nr(current);
-                printk("calling  %pF @ %i\n", fn, it.caller);
+                printk("calling  %pF @ %i\n", fn, call.caller);
-                it.calltime = ktime_get();
+                calltime = ktime_get();
+                trace_boot_call(&call, fn);
+                enable_boot_trace();
        }
-        it.result = fn();
+        ret.result = fn();
        if (initcall_debug) {
-                it.rettime = ktime_get();
+                disable_boot_trace();
-                delta = ktime_sub(it.rettime, it.calltime);
+                rettime = ktime_get();
-                it.duration = (unsigned long long) delta.tv64 >> 10;
+                delta = ktime_sub(rettime, calltime);
+                ret.duration = (unsigned long long) delta.tv64 >> 10;
+                trace_boot_ret(&ret, fn);
                printk("initcall %pF returned %d after %Ld usecs\n", fn,
-                        it.result, it.duration);
+                        ret.result, ret.duration);
-                trace_boot(&it, fn);
        }
        msgbuf[0] = 0;
-        if (it.result && it.result != -ENODEV && initcall_debug)
+        if (ret.result && ret.result != -ENODEV && initcall_debug)
-                sprintf(msgbuf, "error code %d ", it.result);
+                sprintf(msgbuf, "error code %d ", ret.result);
        if (preempt_count() != count) {
                strlcat(msgbuf, "preemption imbalance ", sizeof(msgbuf));
@@ -741,7 +746,7 @@ int do_one_initcall(initcall_t fn)
                printk("initcall %pF returned with %s\n", fn, msgbuf);
        }
-        return it.result;
+        return ret.result;
 }
@@ -882,7 +887,7 @@ static int __init kernel_init(void * unused)
         * we're essentially up and running. Get rid of the
         * initmem segments and start the user-mode stuff..
         */
-        stop_boot_trace();
        init_post();
        return 0;
 }
diff --git a/ipc/util.c b/ipc/util.c
index 49b3ea615dc5..361fd1c96fcf 100644
--- a/ipc/util.c
+++ b/ipc/util.c
@@ -266,9 +266,17 @@ int ipc_addid(struct ipc_ids* ids, struct kern_ipc_perm* new, int size)
        if (ids->in_use >= size)
                return -ENOSPC;
+        spin_lock_init(&new->lock);
+        new->deleted = 0;
+        rcu_read_lock();
+        spin_lock(&new->lock);
        err = idr_get_new(&ids->ipcs_idr, new, &id);
-        if (err)
+        if (err) {
+                spin_unlock(&new->lock);
+                rcu_read_unlock();
                return err;
+        }
        ids->in_use++;
@@ -280,10 +288,6 @@ int ipc_addid(struct ipc_ids* ids, struct kern_ipc_perm* new, int size)
                ids->seq = 0;
        new->id = ipc_buildid(id, new->seq);
-        spin_lock_init(&new->lock);
-        new->deleted = 0;
-        rcu_read_lock();
-        spin_lock(&new->lock);
        return id;
 }
diff --git a/kernel/Makefile b/kernel/Makefile
index 19fad003b19d..03a45e7e87b7 100644
--- a/kernel/Makefile
+++ b/kernel/Makefile
@@ -21,6 +21,10 @@ CFLAGS_REMOVE_cgroup-debug.o = -pg
 CFLAGS_REMOVE_sched_clock.o = -pg
 CFLAGS_REMOVE_sched.o = -pg
 endif
+ifdef CONFIG_FUNCTION_RET_TRACER
+CFLAGS_REMOVE_extable.o = -pg # For __kernel_text_address()
+CFLAGS_REMOVE_module.o = -pg # For __module_text_address()
+endif
 obj-$(CONFIG_FREEZER) += freezer.o
 obj-$(CONFIG_PROFILING) += profile.o
diff --git a/kernel/cgroup.c b/kernel/cgroup.c
index 358e77564e6f..fe00b3b983a8 100644
--- a/kernel/cgroup.c
+++ b/kernel/cgroup.c
@@ -2039,10 +2039,13 @@ int cgroupstats_build(struct cgroupstats *stats, struct dentry *dentry)
        struct cgroup *cgrp;
        struct cgroup_iter it;
        struct task_struct *tsk;
        /*
-         * Validate dentry by checking the superblock operations
+         * Validate dentry by checking the superblock operations,
+         * and make sure it's a directory.
         */
-        if (dentry->d_sb->s_op != &cgroup_ops)
+        if (dentry->d_sb->s_op != &cgroup_ops ||
+            !S_ISDIR(dentry->d_inode->i_mode))
                 goto err;
        ret = 0;
@@ -2472,10 +2475,7 @@ static int cgroup_rmdir(struct inode *unused_dir, struct dentry *dentry)
                mutex_unlock(&cgroup_mutex);
                return -EBUSY;
        }
+        mutex_unlock(&cgroup_mutex);
-        parent = cgrp->parent;
-        root = cgrp->root;
-        sb = root->sb;
        /*
         * Call pre_destroy handlers of subsys. Notify subsystems
@@ -2483,7 +2483,14 @@ static int cgroup_rmdir(struct inode *unused_dir, struct dentry *dentry)
         */
        cgroup_call_pre_destroy(cgrp);
-        if (cgroup_has_css_refs(cgrp)) {
+        mutex_lock(&cgroup_mutex);
+        parent = cgrp->parent;
+        root = cgrp->root;
+        sb = root->sb;
+        if (atomic_read(&cgrp->count)
+            || !list_empty(&cgrp->children)
+            || cgroup_has_css_refs(cgrp)) {
                mutex_unlock(&cgroup_mutex);
                return -EBUSY;
        }
diff --git a/kernel/cpuset.c b/kernel/cpuset.c
index 81fc6791a296..da7ff6137f37 100644
--- a/kernel/cpuset.c
+++ b/kernel/cpuset.c
@@ -36,6 +36,7 @@
 #include <linux/list.h>
 #include <linux/mempolicy.h>
 #include <linux/mm.h>
+#include <linux/memory.h>
 #include <linux/module.h>
 #include <linux/mount.h>
 #include <linux/namei.h>
@@ -2015,12 +2016,23 @@ static int cpuset_track_online_cpus(struct notifier_block *unused_nb,
 * Call this routine anytime after node_states[N_HIGH_MEMORY] changes.
 * See also the previous routine cpuset_track_online_cpus().
 */
-void cpuset_track_online_nodes(void)
+static int cpuset_track_online_nodes(struct notifier_block *self,
+                                unsigned long action, void *arg)
 {
        cgroup_lock();
-        top_cpuset.mems_allowed = node_states[N_HIGH_MEMORY];
+        switch (action) {
-        scan_for_empty_cpusets(&top_cpuset);
+        case MEM_ONLINE:
+                top_cpuset.mems_allowed = node_states[N_HIGH_MEMORY];
+                break;
+        case MEM_OFFLINE:
+                top_cpuset.mems_allowed = node_states[N_HIGH_MEMORY];
+                scan_for_empty_cpusets(&top_cpuset);
+                break;
+        default:
+                break;
+        }
        cgroup_unlock();
+        return NOTIFY_OK;
 }
 #endif
@@ -2036,6 +2048,7 @@ void __init cpuset_init_smp(void)
        top_cpuset.mems_allowed = node_states[N_HIGH_MEMORY];
        hotcpu_notifier(cpuset_track_online_cpus, 0);
+        hotplug_memory_notifier(cpuset_track_online_nodes, 10);
 }
 /**
diff --git a/kernel/exit.c b/kernel/exit.c
index 2d8be7ebb0f7..35c8ec2ba03a 100644
--- a/kernel/exit.c
+++ b/kernel/exit.c
@@ -53,6 +53,10 @@
 #include <asm/pgtable.h>
 #include <asm/mmu_context.h>
+DEFINE_TRACE(sched_process_free);
+DEFINE_TRACE(sched_process_exit);
+DEFINE_TRACE(sched_process_wait);
 static void exit_mm(struct task_struct * tsk);
 static inline int task_detached(struct task_struct *p)
diff --git a/kernel/fork.c b/kernel/fork.c
index 2a372a0e206f..ac62f43ee430 100644
--- a/kernel/fork.c
+++ b/kernel/fork.c
@@ -80,6 +80,8 @@ DEFINE_PER_CPU(unsigned long, process_counts) = 0;
 __cacheline_aligned DEFINE_RWLOCK(tasklist_lock);  /* outer */
+DEFINE_TRACE(sched_process_fork);
 int nr_processes(void)
 {
        int cpu;
diff --git a/kernel/kallsyms.c b/kernel/kallsyms.c
index 5072cf1685a2..7b8b0f21a5b1 100644
--- a/kernel/kallsyms.c
+++ b/kernel/kallsyms.c
@@ -304,17 +304,24 @@ int sprint_symbol(char *buffer, unsigned long address)
        char *modname;
        const char *name;
        unsigned long offset, size;
-        char namebuf[KSYM_NAME_LEN];
+        int len;
-        name = kallsyms_lookup(address, &size, &offset, &modname, namebuf);
+        name = kallsyms_lookup(address, &size, &offset, &modname, buffer);
        if (!name)
                return sprintf(buffer, "0x%lx", address);
+        if (name != buffer)
+                strcpy(buffer, name);
+        len = strlen(buffer);
+        buffer += len;
        if (modname)
-                return sprintf(buffer, "%s+%#lx/%#lx [%s]", name, offset,
+                len += sprintf(buffer, "+%#lx/%#lx [%s]",
-                                size, modname);
+                                                offset, size, modname);
        else
-                return sprintf(buffer, "%s+%#lx/%#lx", name, offset, size);
+                len += sprintf(buffer, "+%#lx/%#lx", offset, size);
+        return len;
 }
 /* Look up a kernel symbol and print it to the kernel messages. */
diff --git a/kernel/kthread.c b/kernel/kthread.c
index 8e7a7ce3ed0a..4fbc456f393d 100644
--- a/kernel/kthread.c
+++ b/kernel/kthread.c
@@ -21,6 +21,9 @@ static DEFINE_SPINLOCK(kthread_create_lock);
 static LIST_HEAD(kthread_create_list);
 struct task_struct *kthreadd_task;
+DEFINE_TRACE(sched_kthread_stop);
+DEFINE_TRACE(sched_kthread_stop_ret);
 struct kthread_create_info
 {
        /* Information passed to kthread() from kthreadd. */
diff --git a/kernel/marker.c b/kernel/marker.c
index e9c6b2bc9400..ea54f2647868 100644
--- a/kernel/marker.c
+++ b/kernel/marker.c
@@ -43,6 +43,7 @@ static DEFINE_MUTEX(markers_mutex);
 */
 #define MARKER_HASH_BITS 6
 #define MARKER_TABLE_SIZE (1 << MARKER_HASH_BITS)
+static struct hlist_head marker_table[MARKER_TABLE_SIZE];
 /*
 * Note about RCU :
@@ -64,11 +65,10 @@ struct marker_entry {
        void *oldptr;
        int rcu_pending;
        unsigned char ptype:1;
+        unsigned char format_allocated:1;
        char name[0];   /* Contains name'\0'format'\0' */
 };
-static struct hlist_head marker_table[MARKER_TABLE_SIZE];
 /**
 * __mark_empty_function - Empty probe callback
 * @probe_private: probe private data
@@ -81,7 +81,7 @@ static struct hlist_head marker_table[MARKER_TABLE_SIZE];
 * though the function pointer change and the marker enabling are two distinct
 * operations that modifies the execution flow of preemptible code.
 */
-void __mark_empty_function(void *probe_private, void *call_private,
+notrace void __mark_empty_function(void *probe_private, void *call_private,
        const char *fmt, va_list *args)
 {
 }
@@ -97,7 +97,8 @@ EXPORT_SYMBOL_GPL(__mark_empty_function);
 * need to put a full smp_rmb() in this branch. This is why we do not use
 * rcu_dereference() for the pointer read.
 */
-void marker_probe_cb(const struct marker *mdata, void *call_private, ...)
+notrace void marker_probe_cb(const struct marker *mdata,
+                void *call_private, ...)
 {
        va_list args;
        char ptype;
@@ -107,7 +108,7 @@ void marker_probe_cb(const struct marker *mdata, void *call_private, ...)
         * sure the teardown of the callbacks can be done correctly when they
         * are in modules and they insure RCU read coherency.
         */
-        rcu_read_lock_sched();
+        rcu_read_lock_sched_notrace();
        ptype = mdata->ptype;
        if (likely(!ptype)) {
                marker_probe_func *func;
@@ -145,7 +146,7 @@ void marker_probe_cb(const struct marker *mdata, void *call_private, ...)
                        va_end(args);
                }
        }
-        rcu_read_unlock_sched();
+        rcu_read_unlock_sched_notrace();
 }
 EXPORT_SYMBOL_GPL(marker_probe_cb);
@@ -157,12 +158,13 @@ EXPORT_SYMBOL_GPL(marker_probe_cb);
 *
 * Should be connected to markers "MARK_NOARGS".
 */
-void marker_probe_cb_noarg(const struct marker *mdata, void *call_private, ...)
+static notrace void marker_probe_cb_noarg(const struct marker *mdata,
+                void *call_private, ...)
 {
        va_list args;   /* not initialized */
        char ptype;
-        rcu_read_lock_sched();
+        rcu_read_lock_sched_notrace();
        ptype = mdata->ptype;
        if (likely(!ptype)) {
                marker_probe_func *func;
@@ -195,9 +197,8 @@ void marker_probe_cb_noarg(const struct marker *mdata, void *call_private, ...)
                        multi[i].func(multi[i].probe_private, call_private,
                                mdata->format, &args);
        }
-        rcu_read_unlock_sched();
+        rcu_read_unlock_sched_notrace();
 }
-EXPORT_SYMBOL_GPL(marker_probe_cb_noarg);
 static void free_old_closure(struct rcu_head *head)
 {
@@ -416,6 +417,7 @@ static struct marker_entry *add_marker(const char *name, const char *format)
        e->single.probe_private = NULL;
        e->multi = NULL;
        e->ptype = 0;
+        e->format_allocated = 0;
        e->refcount = 0;
        e->rcu_pending = 0;
        hlist_add_head(&e->hlist, head);
@@ -447,6 +449,8 @@ static int remove_marker(const char *name)
        if (e->single.func != __mark_empty_function)
                return -EBUSY;
        hlist_del(&e->hlist);
+        if (e->format_allocated)
+                kfree(e->format);
        /* Make sure the call_rcu has been executed */
        if (e->rcu_pending)
                rcu_barrier_sched();
@@ -457,57 +461,34 @@ static int remove_marker(const char *name)
 /*
 * Set the mark_entry format to the format found in the element.
 */
-static int marker_set_format(struct marker_entry **entry, const char *format)
+static int marker_set_format(struct marker_entry *entry, const char *format)
 {
-        struct marker_entry *e;
+        entry->format = kstrdup(format, GFP_KERNEL);
-        size_t name_len = strlen((*entry)->name) + 1;
+        if (!entry->format)
-        size_t format_len = strlen(format) + 1;
-        e = kmalloc(sizeof(struct marker_entry) + name_len + format_len,
-                        GFP_KERNEL);
-        if (!e)
                return -ENOMEM;
-        memcpy(&e->name[0], (*entry)->name, name_len);
+        entry->format_allocated = 1;
-        e->format = &e->name[name_len];
-        memcpy(e->format, format, format_len);
-        if (strcmp(e->format, MARK_NOARGS) == 0)
-                e->call = marker_probe_cb_noarg;
-        else
-                e->call = marker_probe_cb;
-        e->single = (*entry)->single;
-        e->multi = (*entry)->multi;
-        e->ptype = (*entry)->ptype;
-        e->refcount = (*entry)->refcount;
-        e->rcu_pending = 0;
-        hlist_add_before(&e->hlist, &(*entry)->hlist);
-        hlist_del(&(*entry)->hlist);
-        /* Make sure the call_rcu has been executed */
-        if ((*entry)->rcu_pending)
-                rcu_barrier_sched();
-        kfree(*entry);
-        *entry = e;
        trace_mark(core_marker_format, "name %s format %s",
-                        e->name, e->format);
+                        entry->name, entry->format);
        return 0;
 }
 /*
 * Sets the probe callback corresponding to one marker.
 */
-static int set_marker(struct marker_entry **entry, struct marker *elem,
+static int set_marker(struct marker_entry *entry, struct marker *elem,
                int active)
 {
-        int ret;
+        int ret = 0;
-        WARN_ON(strcmp((*entry)->name, elem->name) != 0);
+        WARN_ON(strcmp(entry->name, elem->name) != 0);
-        if ((*entry)->format) {
+        if (entry->format) {
-                if (strcmp((*entry)->format, elem->format) != 0) {
+                if (strcmp(entry->format, elem->format) != 0) {
                        printk(KERN_NOTICE
                                "Format mismatch for probe %s "
                                "(%s), marker (%s)\n",
-                                (*entry)->name,
+                                entry->name,
-                                (*entry)->format,
+                                entry->format,
                                elem->format);
                        return -EPERM;
                }
@@ -523,37 +504,67 @@ static int set_marker(struct marker_entry **entry, struct marker *elem,
         * pass from a "safe" callback (with argument) to an "unsafe"
         * callback (does not set arguments).
         */
-        elem->call = (*entry)->call;
+        elem->call = entry->call;
        /*
         * Sanity check :
         * We only update the single probe private data when the ptr is
         * set to a _non_ single probe! (0 -> 1 and N -> 1, N != 1)
         */
        WARN_ON(elem->single.func != __mark_empty_function
-                && elem->single.probe_private
+                && elem->single.probe_private != entry->single.probe_private
-                != (*entry)->single.probe_private &&
+                && !elem->ptype);
-                !elem->ptype);
+        elem->single.probe_private = entry->single.probe_private;
-        elem->single.probe_private = (*entry)->single.probe_private;
        /*
         * Make sure the private data is valid when we update the
         * single probe ptr.
         */
        smp_wmb();
-        elem->single.func = (*entry)->single.func;
+        elem->single.func = entry->single.func;
        /*
         * We also make sure that the new probe callbacks array is consistent
         * before setting a pointer to it.
         */
-        rcu_assign_pointer(elem->multi, (*entry)->multi);
+        rcu_assign_pointer(elem->multi, entry->multi);
        /*
         * Update the function or multi probe array pointer before setting the
         * ptype.
         */
        smp_wmb();
-        elem->ptype = (*entry)->ptype;
+        elem->ptype = entry->ptype;
+        if (elem->tp_name && (active ^ elem->state)) {
+                WARN_ON(!elem->tp_cb);
+                /*
+                 * It is ok to directly call the probe registration because type
+                 * checking has been done in the __trace_mark_tp() macro.
+                 */
+                if (active) {
+                        /*
+                         * try_module_get should always succeed because we hold
+                         * lock_module() to get the tp_cb address.
+                         */
+                        ret = try_module_get(__module_text_address(
+                                (unsigned long)elem->tp_cb));
+                        BUG_ON(!ret);
+                        ret = tracepoint_probe_register_noupdate(
+                                elem->tp_name,
+                                elem->tp_cb);
+                } else {
+                        ret = tracepoint_probe_unregister_noupdate(
+                                elem->tp_name,
+                                elem->tp_cb);
+                        /*
+                         * tracepoint_probe_update_all() must be called
+                         * before the module containing tp_cb is unloaded.
+                         */
+                        module_put(__module_text_address(
+                                (unsigned long)elem->tp_cb));
+                }
+        }
        elem->state = active;
-        return 0;
+        return ret;
 }
 /*
@@ -564,7 +575,24 @@ static int set_marker(struct marker_entry **entry, struct marker *elem,
 */
 static void disable_marker(struct marker *elem)
 {
+        int ret;
        /* leave "call" as is. It is known statically. */
+        if (elem->tp_name && elem->state) {
+                WARN_ON(!elem->tp_cb);
+                /*
+                 * It is ok to directly call the probe registration because type
+                 * checking has been done in the __trace_mark_tp() macro.
+                 */
+                ret = tracepoint_probe_unregister_noupdate(elem->tp_name,
+                        elem->tp_cb);
+                WARN_ON(ret);
+                /*
+                 * tracepoint_probe_update_all() must be called
+                 * before the module containing tp_cb is unloaded.
+                 */
+                module_put(__module_text_address((unsigned long)elem->tp_cb));
+        }
        elem->state = 0;
        elem->single.func = __mark_empty_function;
        /* Update the function before setting the ptype */
@@ -594,8 +622,7 @@ void marker_update_probe_range(struct marker *begin,
        for (iter = begin; iter < end; iter++) {
                mark_entry = get_marker(iter->name);
                if (mark_entry) {
-                        set_marker(&mark_entry, iter,
+                        set_marker(mark_entry, iter, !!mark_entry->refcount);
-                                        !!mark_entry->refcount);
                        /*
                         * ignore error, continue
                         */
@@ -629,6 +656,7 @@ static void marker_update_probes(void)
        marker_update_probe_range(__start___markers, __stop___markers);
        /* Markers in modules. */
        module_update_markers();
+        tracepoint_probe_update_all();
 }
 /**
@@ -657,7 +685,7 @@ int marker_probe_register(const char *name, const char *format,
                        ret = PTR_ERR(entry);
        } else if (format) {
                if (!entry->format)
-                        ret = marker_set_format(&entry, format);
+                        ret = marker_set_format(entry, format);
                else if (strcmp(entry->format, format))
                        ret = -EPERM;
        }
@@ -676,10 +704,11 @@ int marker_probe_register(const char *name, const char *format,
                goto end;
        }
        mutex_unlock(&markers_mutex);
-        marker_update_probes();         /* may update entry */
+        marker_update_probes();
        mutex_lock(&markers_mutex);
        entry = get_marker(name);
-        WARN_ON(!entry);
+        if (!entry)
+                goto end;
        if (entry->rcu_pending)
                rcu_barrier_sched();
        entry->oldptr = old;
@@ -720,7 +749,7 @@ int marker_probe_unregister(const char *name,
                rcu_barrier_sched();
        old = marker_entry_remove_probe(entry, probe, probe_private);
        mutex_unlock(&markers_mutex);
-        marker_update_probes();         /* may update entry */
+        marker_update_probes();
        mutex_lock(&markers_mutex);
        entry = get_marker(name);
        if (!entry)
@@ -801,10 +830,11 @@ int marker_probe_unregister_private_data(marker_probe_func *probe,
                rcu_barrier_sched();
        old = marker_entry_remove_probe(entry, NULL, probe_private);
        mutex_unlock(&markers_mutex);
-        marker_update_probes();         /* may update entry */
+        marker_update_probes();
        mutex_lock(&markers_mutex);
        entry = get_marker_from_private_data(probe, probe_private);
-        WARN_ON(!entry);
+        if (!entry)
+                goto end;
        if (entry->rcu_pending)
                rcu_barrier_sched();
        entry->oldptr = old;
@@ -848,8 +878,6 @@ void *marker_get_private_data(const char *name, marker_probe_func *probe,
                        if (!e->ptype) {
                                if (num == 0 && e->single.func == probe)
                                        return e->single.probe_private;
-                                else
-                                        break;
                        } else {
                                struct marker_probe_closure *closure;
                                int match = 0;
@@ -861,8 +889,42 @@ void *marker_get_private_data(const char *name, marker_probe_func *probe,
                                                return closure[i].probe_private;
                                }
                        }
+                        break;
                }
        }
        return ERR_PTR(-ENOENT);
 }
 EXPORT_SYMBOL_GPL(marker_get_private_data);
+#ifdef CONFIG_MODULES
+int marker_module_notify(struct notifier_block *self,
+                         unsigned long val, void *data)
+{
+        struct module *mod = data;
+        switch (val) {
+        case MODULE_STATE_COMING:
+                marker_update_probe_range(mod->markers,
+                        mod->markers + mod->num_markers);
+                break;
+        case MODULE_STATE_GOING:
+                marker_update_probe_range(mod->markers,
+                        mod->markers + mod->num_markers);
+                break;
+        }
+        return 0;
+}
+struct notifier_block marker_module_nb = {
+        .notifier_call = marker_module_notify,
+        .priority = 0,
+};
+static int init_markers(void)
+{
+        return register_module_notifier(&marker_module_nb);
+}
+__initcall(init_markers);
+#endif /* CONFIG_MODULES */
diff --git a/kernel/module.c b/kernel/module.c
index 1f4cc00e0c20..89bcf7c1327d 100644
--- a/kernel/module.c
+++ b/kernel/module.c
@@ -2184,24 +2184,15 @@ static noinline struct module *load_module(void __user *umod,
                struct mod_debug *debug;
                unsigned int num_debug;
-#ifdef CONFIG_MARKERS
-                marker_update_probe_range(mod->markers,
-                        mod->markers + mod->num_markers);
-#endif
                debug = section_objs(hdr, sechdrs, secstrings, "__verbose",
                                     sizeof(*debug), &num_debug);
                dynamic_printk_setup(debug, num_debug);
-#ifdef CONFIG_TRACEPOINTS
-                tracepoint_update_probe_range(mod->tracepoints,
-                        mod->tracepoints + mod->num_tracepoints);
-#endif
        }
        /* sechdrs[0].sh_size is always zero */
        mseg = section_objs(hdr, sechdrs, secstrings, "__mcount_loc",
                            sizeof(*mseg), &num_mcount);
-        ftrace_init_module(mseg, mseg + num_mcount);
+        ftrace_init_module(mod, mseg, mseg + num_mcount);
        err = module_finalize(hdr, sechdrs, mod);
        if (err < 0)
diff --git a/kernel/sched.c b/kernel/sched.c
index 9b1e79371c20..4de56108c86f 100644
--- a/kernel/sched.c
+++ b/kernel/sched.c
@@ -118,6 +118,12 @@
 */
 #define RUNTIME_INF     ((u64)~0ULL)
+DEFINE_TRACE(sched_wait_task);
+DEFINE_TRACE(sched_wakeup);
+DEFINE_TRACE(sched_wakeup_new);
+DEFINE_TRACE(sched_switch);
+DEFINE_TRACE(sched_migrate_task);
 #ifdef CONFIG_SMP
 /*
 * Divide a load by a sched group cpu_power : (load / sg->__cpu_power)
diff --git a/kernel/signal.c b/kernel/signal.c
index 4530fc654455..e9afe63da24b 100644
--- a/kernel/signal.c
+++ b/kernel/signal.c
@@ -41,6 +41,8 @@
 static struct kmem_cache *sigqueue_cachep;
+DEFINE_TRACE(sched_signal_send);
 static void __user *sig_handler(struct task_struct *t, int sig)
 {
        return t->sighand->action[sig - 1].sa.sa_handler;
diff --git a/kernel/sys_ni.c b/kernel/sys_ni.c
index a77b27b11b04..e14a23281707 100644
--- a/kernel/sys_ni.c
+++ b/kernel/sys_ni.c
@@ -31,7 +31,7 @@ cond_syscall(sys_socketpair);
 cond_syscall(sys_bind);
 cond_syscall(sys_listen);
 cond_syscall(sys_accept);
-cond_syscall(sys_paccept);
+cond_syscall(sys_accept4);
 cond_syscall(sys_connect);
 cond_syscall(sys_getsockname);
 cond_syscall(sys_getpeername);
diff --git a/kernel/sysctl.c b/kernel/sysctl.c
index 9d048fa2d902..65d4a9ba79e4 100644
--- a/kernel/sysctl.c
+++ b/kernel/sysctl.c
@@ -484,6 +484,16 @@ static struct ctl_table kern_table[] = {
                .proc_handler   = &ftrace_enable_sysctl,
        },
 #endif
+#ifdef CONFIG_TRACING
+        {
+                .ctl_name       = CTL_UNNUMBERED,
+                .procname       = "ftrace_dump_on_oops",
+                .data           = &ftrace_dump_on_oops,
+                .maxlen         = sizeof(int),
+                .mode           = 0644,
+                .proc_handler   = &proc_dointvec,
+        },
+#endif
 #ifdef CONFIG_MODULES
        {
                .ctl_name       = KERN_MODPROBE,
diff --git a/kernel/trace/Kconfig b/kernel/trace/Kconfig
index 33dbefd471e8..b8378fad29a3 100644
--- a/kernel/trace/Kconfig
+++ b/kernel/trace/Kconfig
@@ -9,6 +9,16 @@ config NOP_TRACER
 config HAVE_FUNCTION_TRACER
        bool
+config HAVE_FUNCTION_RET_TRACER
+        bool
+config HAVE_FUNCTION_TRACE_MCOUNT_TEST
+        bool
+        help
+         This gets selected when the arch tests the function_trace_stop
+         variable at the mcount call site. Otherwise, this variable
+         is tested by the called function.
 config HAVE_DYNAMIC_FTRACE
        bool
@@ -47,6 +57,16 @@ config FUNCTION_TRACER
          (the bootup default), then the overhead of the instructions is very
          small and not measurable even in micro-benchmarks.
+config FUNCTION_RET_TRACER
+        bool "Kernel Function return Tracer"
+        depends on HAVE_FUNCTION_RET_TRACER
+        depends on FUNCTION_TRACER
+        help
+          Enable the kernel to trace a function at its return.
+          It's first purpose is to trace the duration of functions.
+          This is done by setting the current return address on the thread
+          info structure of the current task.
 config IRQSOFF_TRACER
        bool "Interrupts-off Latency Tracer"
        default n
@@ -138,6 +158,44 @@ config BOOT_TRACER
            selected, because the self-tests are an initcall as well and that
            would invalidate the boot trace. )
+config TRACE_BRANCH_PROFILING
+        bool "Trace likely/unlikely profiler"
+        depends on DEBUG_KERNEL
+        select TRACING
+        help
+          This tracer profiles all the the likely and unlikely macros
+          in the kernel. It will display the results in:
+          /debugfs/tracing/profile_likely
+          /debugfs/tracing/profile_unlikely
+          Note: this will add a significant overhead, only turn this
+          on if you need to profile the system's use of these macros.
+          Say N if unsure.
+config TRACING_BRANCHES
+        bool
+        help
+          Selected by tracers that will trace the likely and unlikely
+          conditions. This prevents the tracers themselves from being
+          profiled. Profiling the tracing infrastructure can only happen
+          when the likelys and unlikelys are not being traced.
+config BRANCH_TRACER
+        bool "Trace likely/unlikely instances"
+        depends on TRACE_BRANCH_PROFILING
+        select TRACING_BRANCHES
+        help
+          This traces the events of likely and unlikely condition
+          calls in the kernel.  The difference between this and the
+          "Trace likely/unlikely profiler" is that this is not a
+          histogram of the callers, but actually places the calling
+          events into a running trace buffer to see when and where the
+          events happened, as well as their results.
+          Say N if unsure.
 config STACK_TRACER
        bool "Trace max stack"
        depends on HAVE_FUNCTION_TRACER
diff --git a/kernel/trace/Makefile b/kernel/trace/Makefile
index c8228b1a49e9..1a8c9259dc69 100644
--- a/kernel/trace/Makefile
+++ b/kernel/trace/Makefile
@@ -10,6 +10,11 @@ CFLAGS_trace_selftest_dynamic.o = -pg
 obj-y += trace_selftest_dynamic.o
 endif
+# If unlikely tracing is enabled, do not trace these files
+ifdef CONFIG_TRACING_BRANCHES
+KBUILD_CFLAGS += -DDISABLE_BRANCH_PROFILING
+endif
 obj-$(CONFIG_FUNCTION_TRACER) += libftrace.o
 obj-$(CONFIG_RING_BUFFER) += ring_buffer.o
@@ -24,5 +29,7 @@ obj-$(CONFIG_NOP_TRACER) += trace_nop.o
 obj-$(CONFIG_STACK_TRACER) += trace_stack.o
 obj-$(CONFIG_MMIOTRACE) += trace_mmiotrace.o
 obj-$(CONFIG_BOOT_TRACER) += trace_boot.o
+obj-$(CONFIG_FUNCTION_RET_TRACER) += trace_functions_return.o
+obj-$(CONFIG_TRACE_BRANCH_PROFILING) += trace_branch.o
 libftrace-y := ftrace.o
diff --git a/kernel/trace/ftrace.c b/kernel/trace/ftrace.c
index e60205722d0c..f212da486689 100644
--- a/kernel/trace/ftrace.c
+++ b/kernel/trace/ftrace.c
@@ -47,6 +47,12 @@
 int ftrace_enabled __read_mostly;
 static int last_ftrace_enabled;
+/* Quick disabling of function tracer. */
+int function_trace_stop;
+/* By default, current tracing type is normal tracing. */
+enum ftrace_tracing_type_t ftrace_tracing_type = FTRACE_TYPE_ENTER;
 /*
 * ftrace_disabled is set when an anomaly is discovered.
 * ftrace_disabled is much stronger than ftrace_enabled.
@@ -63,6 +69,7 @@ static struct ftrace_ops ftrace_list_end __read_mostly =
 static struct ftrace_ops *ftrace_list __read_mostly = &ftrace_list_end;
 ftrace_func_t ftrace_trace_function __read_mostly = ftrace_stub;
+ftrace_func_t __ftrace_trace_function __read_mostly = ftrace_stub;
 static void ftrace_list_func(unsigned long ip, unsigned long parent_ip)
 {
@@ -88,7 +95,22 @@ static void ftrace_list_func(unsigned long ip, unsigned long parent_ip)
 void clear_ftrace_function(void)
 {
        ftrace_trace_function = ftrace_stub;
+        __ftrace_trace_function = ftrace_stub;
+}
+#ifndef CONFIG_HAVE_FUNCTION_TRACE_MCOUNT_TEST
+/*
+ * For those archs that do not test ftrace_trace_stop in their
+ * mcount call site, we need to do it from C.
+ */
+static void ftrace_test_stop_func(unsigned long ip, unsigned long parent_ip)
+{
+        if (function_trace_stop)
+                return;
+        __ftrace_trace_function(ip, parent_ip);
 }
+#endif
 static int __register_ftrace_function(struct ftrace_ops *ops)
 {
@@ -110,10 +132,18 @@ static int __register_ftrace_function(struct ftrace_ops *ops)
                 * For one func, simply call it directly.
                 * For more than one func, call the chain.
                 */
+#ifdef CONFIG_HAVE_FUNCTION_TRACE_MCOUNT_TEST
                if (ops->next == &ftrace_list_end)
                        ftrace_trace_function = ops->func;
                else
                        ftrace_trace_function = ftrace_list_func;
+#else
+                if (ops->next == &ftrace_list_end)
+                        __ftrace_trace_function = ops->func;
+                else
+                        __ftrace_trace_function = ftrace_list_func;
+                ftrace_trace_function = ftrace_test_stop_func;
+#endif
        }
        spin_unlock(&ftrace_lock);
@@ -152,8 +182,7 @@ static int __unregister_ftrace_function(struct ftrace_ops *ops)
        if (ftrace_enabled) {
                /* If we only have one func left, then call that directly */
-                if (ftrace_list == &ftrace_list_end ||
+                if (ftrace_list->next == &ftrace_list_end)
-                    ftrace_list->next == &ftrace_list_end)
                        ftrace_trace_function = ftrace_list->func;
        }
@@ -308,7 +337,7 @@ ftrace_record_ip(unsigned long ip)
 {
        struct dyn_ftrace *rec;
-        if (!ftrace_enabled || ftrace_disabled)
+        if (ftrace_disabled)
                return NULL;
        rec = ftrace_alloc_dyn_node(ip);
@@ -322,107 +351,138 @@ ftrace_record_ip(unsigned long ip)
        return rec;
 }
-#define FTRACE_ADDR ((long)(ftrace_caller))
+static void print_ip_ins(const char *fmt, unsigned char *p)
+{
+        int i;
+        printk(KERN_CONT "%s", fmt);
+        for (i = 0; i < MCOUNT_INSN_SIZE; i++)
+                printk(KERN_CONT "%s%02x", i ? ":" : "", p[i]);
+}
+static void ftrace_bug(int failed, unsigned long ip)
+{
+        switch (failed) {
+        case -EFAULT:
+                FTRACE_WARN_ON_ONCE(1);
+                pr_info("ftrace faulted on modifying ");
+                print_ip_sym(ip);
+                break;
+        case -EINVAL:
+                FTRACE_WARN_ON_ONCE(1);
+                pr_info("ftrace failed to modify ");
+                print_ip_sym(ip);
+                print_ip_ins(" actual: ", (unsigned char *)ip);
+                printk(KERN_CONT "\n");
+                break;
+        case -EPERM:
+                FTRACE_WARN_ON_ONCE(1);
+                pr_info("ftrace faulted on writing ");
+                print_ip_sym(ip);
+                break;
+        default:
+                FTRACE_WARN_ON_ONCE(1);
+                pr_info("ftrace faulted on unknown error ");
+                print_ip_sym(ip);
+        }
+}
 static int
-__ftrace_replace_code(struct dyn_ftrace *rec,
+__ftrace_replace_code(struct dyn_ftrace *rec, int enable)
-                      unsigned char *old, unsigned char *new, int enable)
 {
        unsigned long ip, fl;
+        unsigned long ftrace_addr;
+#ifdef CONFIG_FUNCTION_RET_TRACER
+        if (ftrace_tracing_type == FTRACE_TYPE_ENTER)
+                ftrace_addr = (unsigned long)ftrace_caller;
+        else
+                ftrace_addr = (unsigned long)ftrace_return_caller;
+#else
+        ftrace_addr = (unsigned long)ftrace_caller;
+#endif
        ip = rec->ip;
-        if (ftrace_filtered && enable) {
+        /*
+         * If this record is not to be traced and
+         * it is not enabled then do nothing.
+         *
+         * If this record is not to be traced and
+         * it is enabled then disabled it.
+         *
+         */
+        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) {
                /*
-                 * If filtering is on:
+                 * Filtering is on:
-                 *
-                 * If this record is set to be filtered and
-                 * is enabled then do nothing.
-                 *
-                 * If this record is set to be filtered and
-                 * it is not enabled, enable it.
-                 *
-                 * If this record is not set to be filtered
-                 * and it is not enabled do nothing.
-                 *
-                 * If this record is set not to trace then
-                 * do nothing.
-                 *
-                 * If this record is set not to trace and
-                 * it is enabled then disable it.
-                 *
-                 * If this record is not set to be filtered and
-                 * it is enabled, disable it.
                 */
-                fl = rec->flags & (FTRACE_FL_FILTER | FTRACE_FL_NOTRACE |
+                fl = rec->flags & (FTRACE_FL_FILTER | FTRACE_FL_ENABLED);
-                                   FTRACE_FL_ENABLED);
-                if ((fl ==  (FTRACE_FL_FILTER | FTRACE_FL_ENABLED)) ||
+                /* Record is filtered and enabled, do nothing */
-                    (fl ==  (FTRACE_FL_FILTER | FTRACE_FL_NOTRACE)) ||
+                if (fl == (FTRACE_FL_FILTER | FTRACE_FL_ENABLED))
-                    !fl || (fl == FTRACE_FL_NOTRACE))
                        return 0;
-                /*
+                /* Record is not filtered and is not enabled do nothing */
-                 * If it is enabled disable it,
+                if (!fl)
-                 * otherwise enable it!
+                        return 0;
-                 */
-                if (fl & FTRACE_FL_ENABLED) {
+                /* Record is not filtered but enabled, disable it */
-                        /* swap new and old */
+                if (fl == FTRACE_FL_ENABLED)
-                        new = old;
-                        old = ftrace_call_replace(ip, FTRACE_ADDR);
                        rec->flags &= ~FTRACE_FL_ENABLED;
-                } else {
+                else
-                        new = ftrace_call_replace(ip, FTRACE_ADDR);
+                /* 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 this record is set not to trace and is
-                         * not enabled, do nothing.
-                         */
-                        fl = rec->flags & (FTRACE_FL_NOTRACE | FTRACE_FL_ENABLED);
-                        if (fl == FTRACE_FL_NOTRACE)
-                                return 0;
-                        new = ftrace_call_replace(ip, FTRACE_ADDR);
-                } else
-                        old = ftrace_call_replace(ip, FTRACE_ADDR);
-                if (enable) {
                        if (rec->flags & FTRACE_FL_ENABLED)
                                return 0;
                        rec->flags |= FTRACE_FL_ENABLED;
                } else {
+                        /* if record is not enabled do nothing */
                        if (!(rec->flags & FTRACE_FL_ENABLED))
                                return 0;
                        rec->flags &= ~FTRACE_FL_ENABLED;
                }
        }
-        return ftrace_modify_code(ip, old, new);
+        if (rec->flags & FTRACE_FL_ENABLED)
+                return ftrace_make_call(rec, ftrace_addr);
+        else
+                return ftrace_make_nop(NULL, rec, ftrace_addr);
 }
 static void ftrace_replace_code(int enable)
 {
        int i, failed;
-        unsigned char *new = NULL, *old = NULL;
        struct dyn_ftrace *rec;
        struct ftrace_page *pg;
-        if (enable)
-                old = ftrace_nop_replace();
-        else
-                new = ftrace_nop_replace();
        for (pg = ftrace_pages_start; pg; pg = pg->next) {
                for (i = 0; i < pg->index; i++) {
                        rec = &pg->records[i];
-                        /* don't modify code that has already faulted */
+                        /*
-                        if (rec->flags & FTRACE_FL_FAILED)
+                         * Skip over free records and records that have
+                         * failed.
+                         */
+                        if (rec->flags & FTRACE_FL_FREE ||
+                            rec->flags & FTRACE_FL_FAILED)
                                continue;
                        /* ignore updates to this record's mcount site */
@@ -433,68 +493,30 @@ static void ftrace_replace_code(int enable)
                                unfreeze_record(rec);
                        }
-                        failed = __ftrace_replace_code(rec, old, new, enable);
+                        failed = __ftrace_replace_code(rec, enable);
                        if (failed && (rec->flags & FTRACE_FL_CONVERTED)) {
                                rec->flags |= FTRACE_FL_FAILED;
                                if ((system_state == SYSTEM_BOOTING) ||
                                    !core_kernel_text(rec->ip)) {
                                        ftrace_free_rec(rec);
-                                }
+                                } else
+                                        ftrace_bug(failed, rec->ip);
                        }
                }
        }
 }
-static void print_ip_ins(const char *fmt, unsigned char *p)
-{
-        int i;
-        printk(KERN_CONT "%s", fmt);
-        for (i = 0; i < MCOUNT_INSN_SIZE; i++)
-                printk(KERN_CONT "%s%02x", i ? ":" : "", p[i]);
-}
 static int
-ftrace_code_disable(struct dyn_ftrace *rec)
+ftrace_code_disable(struct module *mod, struct dyn_ftrace *rec)
 {
        unsigned long ip;
-        unsigned char *nop, *call;
        int ret;
        ip = rec->ip;
-        nop = ftrace_nop_replace();
+        ret = ftrace_make_nop(mod, rec, mcount_addr);
-        call = ftrace_call_replace(ip, mcount_addr);
-        ret = ftrace_modify_code(ip, call, nop);
        if (ret) {
-                switch (ret) {
+                ftrace_bug(ret, ip);
-                case -EFAULT:
-                        FTRACE_WARN_ON_ONCE(1);
-                        pr_info("ftrace faulted on modifying ");
-                        print_ip_sym(ip);
-                        break;
-                case -EINVAL:
-                        FTRACE_WARN_ON_ONCE(1);
-                        pr_info("ftrace failed to modify ");
-                        print_ip_sym(ip);
-                        print_ip_ins(" expected: ", call);
-                        print_ip_ins(" actual: ", (unsigned char *)ip);
-                        print_ip_ins(" replace: ", nop);
-                        printk(KERN_CONT "\n");
-                        break;
-                case -EPERM:
-                        FTRACE_WARN_ON_ONCE(1);
-                        pr_info("ftrace faulted on writing ");
-                        print_ip_sym(ip);
-                        break;
-                default:
-                        FTRACE_WARN_ON_ONCE(1);
-                        pr_info("ftrace faulted on unknown error ");
-                        print_ip_sym(ip);
-                }
                rec->flags |= FTRACE_FL_FAILED;
                return 0;
        }
@@ -522,7 +544,7 @@ static void ftrace_run_update_code(int command)
 }
 static ftrace_func_t saved_ftrace_func;
-static int ftrace_start;
+static int ftrace_start_up;
 static DEFINE_MUTEX(ftrace_start_lock);
 static void ftrace_startup(void)
@@ -533,9 +555,8 @@ static void ftrace_startup(void)
                return;
        mutex_lock(&ftrace_start_lock);
-        ftrace_start++;
+        ftrace_start_up++;
-        if (ftrace_start == 1)
+        command |= FTRACE_ENABLE_CALLS;
-                command |= FTRACE_ENABLE_CALLS;
        if (saved_ftrace_func != ftrace_trace_function) {
                saved_ftrace_func = ftrace_trace_function;
@@ -558,8 +579,8 @@ static void ftrace_shutdown(void)
                return;
        mutex_lock(&ftrace_start_lock);
-        ftrace_start--;
+        ftrace_start_up--;
-        if (!ftrace_start)
+        if (!ftrace_start_up)
                command |= FTRACE_DISABLE_CALLS;
        if (saved_ftrace_func != ftrace_trace_function) {
@@ -585,8 +606,8 @@ static void ftrace_startup_sysctl(void)
        mutex_lock(&ftrace_start_lock);
        /* Force update next time */
        saved_ftrace_func = NULL;
-        /* ftrace_start is true if we want ftrace running */
+        /* ftrace_start_up is true if we want ftrace running */
-        if (ftrace_start)
+        if (ftrace_start_up)
                command |= FTRACE_ENABLE_CALLS;
        ftrace_run_update_code(command);
@@ -601,8 +622,8 @@ static void ftrace_shutdown_sysctl(void)
                return;
        mutex_lock(&ftrace_start_lock);
-        /* ftrace_start is true if ftrace is running */
+        /* ftrace_start_up is true if ftrace is running */
-        if (ftrace_start)
+        if (ftrace_start_up)
                command |= FTRACE_DISABLE_CALLS;
        ftrace_run_update_code(command);
@@ -613,7 +634,7 @@ static cycle_t		ftrace_update_time;
 static unsigned long    ftrace_update_cnt;
 unsigned long           ftrace_update_tot_cnt;
-static int ftrace_update_code(void)
+static int ftrace_update_code(struct module *mod)
 {
        struct dyn_ftrace *p, *t;
        cycle_t start, stop;
@@ -630,7 +651,7 @@ static int ftrace_update_code(void)
                list_del_init(&p->list);
                /* convert record (i.e, patch mcount-call with NOP) */
-                if (ftrace_code_disable(p)) {
+                if (ftrace_code_disable(mod, p)) {
                        p->flags |= FTRACE_FL_CONVERTED;
                        ftrace_update_cnt++;
                } else
@@ -734,6 +755,9 @@ t_next(struct seq_file *m, void *v, loff_t *pos)
                    ((iter->flags & FTRACE_ITER_FAILURES) &&
                     !(rec->flags & FTRACE_FL_FAILED)) ||
+                    ((iter->flags & FTRACE_ITER_FILTER) &&
+                     !(rec->flags & FTRACE_FL_FILTER)) ||
                    ((iter->flags & FTRACE_ITER_NOTRACE) &&
                     !(rec->flags & FTRACE_FL_NOTRACE))) {
                        rec = NULL;
@@ -1186,7 +1210,7 @@ ftrace_regex_release(struct inode *inode, struct file *file, int enable)
        mutex_lock(&ftrace_sysctl_lock);
        mutex_lock(&ftrace_start_lock);
-        if (iter->filtered && ftrace_start && ftrace_enabled)
+        if (ftrace_start_up && ftrace_enabled)
                ftrace_run_update_code(FTRACE_ENABLE_CALLS);
        mutex_unlock(&ftrace_start_lock);
        mutex_unlock(&ftrace_sysctl_lock);
@@ -1273,7 +1297,8 @@ static __init int ftrace_init_debugfs(void)
 fs_initcall(ftrace_init_debugfs);
-static int ftrace_convert_nops(unsigned long *start,
+static int ftrace_convert_nops(struct module *mod,
+                               unsigned long *start,
                               unsigned long *end)
 {
        unsigned long *p;
@@ -1284,23 +1309,32 @@ static int ftrace_convert_nops(unsigned long *start,
        p = start;
        while (p < end) {
                addr = ftrace_call_adjust(*p++);
+                /*
+                 * Some architecture linkers will pad between
+                 * the different mcount_loc sections of different
+                 * object files to satisfy alignments.
+                 * Skip any NULL pointers.
+                 */
+                if (!addr)
+                        continue;
                ftrace_record_ip(addr);
        }
        /* disable interrupts to prevent kstop machine */
        local_irq_save(flags);
-        ftrace_update_code();
+        ftrace_update_code(mod);
        local_irq_restore(flags);
        mutex_unlock(&ftrace_start_lock);
        return 0;
 }
-void ftrace_init_module(unsigned long *start, unsigned long *end)
+void ftrace_init_module(struct module *mod,
+                        unsigned long *start, unsigned long *end)
 {
        if (ftrace_disabled || start == end)
                return;
-        ftrace_convert_nops(start, end);
+        ftrace_convert_nops(mod, start, end);
 }
 extern unsigned long __start_mcount_loc[];
@@ -1330,7 +1364,8 @@ void __init ftrace_init(void)
        last_ftrace_enabled = ftrace_enabled = 1;
-        ret = ftrace_convert_nops(__start_mcount_loc,
+        ret = ftrace_convert_nops(NULL,
+                                  __start_mcount_loc,
                                  __stop_mcount_loc);
        return;
@@ -1386,10 +1421,17 @@ int register_ftrace_function(struct ftrace_ops *ops)
                return -1;
        mutex_lock(&ftrace_sysctl_lock);
+        if (ftrace_tracing_type == FTRACE_TYPE_RETURN) {
+                ret = -EBUSY;
+                goto out;
+        }
        ret = __register_ftrace_function(ops);
        ftrace_startup();
-        mutex_unlock(&ftrace_sysctl_lock);
+out:
+        mutex_unlock(&ftrace_sysctl_lock);
        return ret;
 }
@@ -1454,3 +1496,48 @@ ftrace_enable_sysctl(struct ctl_table *table, int write,
        return ret;
 }
+#ifdef CONFIG_FUNCTION_RET_TRACER
+/* The callback that hooks the return of a function */
+trace_function_return_t ftrace_function_return =
+                        (trace_function_return_t)ftrace_stub;
+int register_ftrace_return(trace_function_return_t func)
+{
+        int ret = 0;
+        mutex_lock(&ftrace_sysctl_lock);
+        /*
+         * Don't launch return tracing if normal function
+         * tracing is already running.
+         */
+        if (ftrace_trace_function != ftrace_stub) {
+                ret = -EBUSY;
+                goto out;
+        }
+        ftrace_tracing_type = FTRACE_TYPE_RETURN;
+        ftrace_function_return = func;
+        ftrace_startup();
+out:
+        mutex_unlock(&ftrace_sysctl_lock);
+        return ret;
+}
+void unregister_ftrace_return(void)
+{
+        mutex_lock(&ftrace_sysctl_lock);
+        ftrace_function_return = (trace_function_return_t)ftrace_stub;
+        ftrace_shutdown();
+        /* Restore normal tracing type */
+        ftrace_tracing_type = FTRACE_TYPE_ENTER;
+        mutex_unlock(&ftrace_sysctl_lock);
+}
+#endif
diff --git a/kernel/trace/ring_buffer.c b/kernel/trace/ring_buffer.c
index 036456cbb4f7..85ced143c2c4 100644
--- a/kernel/trace/ring_buffer.c
+++ b/kernel/trace/ring_buffer.c
@@ -45,6 +45,8 @@ void tracing_off(void)
        ring_buffers_off = 1;
 }
+#include "trace.h"
 /* Up this if you want to test the TIME_EXTENTS and normalization */
 #define DEBUG_SHIFT 0
@@ -187,7 +189,8 @@ static inline int test_time_stamp(u64 delta)
 struct ring_buffer_per_cpu {
        int                             cpu;
        struct ring_buffer              *buffer;
-        spinlock_t                      lock;
+        spinlock_t                      reader_lock; /* serialize readers */
+        raw_spinlock_t                  lock;
        struct lock_class_key           lock_key;
        struct list_head                pages;
        struct buffer_page              *head_page;     /* read from head */
@@ -221,32 +224,16 @@ struct ring_buffer_iter {
        u64                             read_stamp;
 };
+/* buffer may be either ring_buffer or ring_buffer_per_cpu */
 #define RB_WARN_ON(buffer, cond)                                \
-        do {                                                    \
+        ({                                                      \
-                if (unlikely(cond)) {                           \
+                int _____ret = unlikely(cond);                  \
-                        atomic_inc(&buffer->record_disabled);   \
+                if (_____ret) {                                 \
-                        WARN_ON(1);                             \
-                }                                               \
-        } while (0)
-#define RB_WARN_ON_RET(buffer, cond)                            \
-        do {                                                    \
-                if (unlikely(cond)) {                           \
-                        atomic_inc(&buffer->record_disabled);   \
-                        WARN_ON(1);                             \
-                        return -1;                              \
-                }                                               \
-        } while (0)
-#define RB_WARN_ON_ONCE(buffer, cond)                           \
-        do {                                                    \
-                static int once;                                \
-                if (unlikely(cond) && !once) {                  \
-                        once++;                                 \
                        atomic_inc(&buffer->record_disabled);   \
                        WARN_ON(1);                             \
                }                                               \
-        } while (0)
+                _____ret;                                       \
+        })
 /**
 * check_pages - integrity check of buffer pages
@@ -260,14 +247,18 @@ static int rb_check_pages(struct ring_buffer_per_cpu *cpu_buffer)
        struct list_head *head = &cpu_buffer->pages;
        struct buffer_page *page, *tmp;
-        RB_WARN_ON_RET(cpu_buffer, head->next->prev != head);
+        if (RB_WARN_ON(cpu_buffer, head->next->prev != head))
-        RB_WARN_ON_RET(cpu_buffer, head->prev->next != head);
+                return -1;
+        if (RB_WARN_ON(cpu_buffer, head->prev->next != head))
+                return -1;
        list_for_each_entry_safe(page, tmp, head, list) {
-                RB_WARN_ON_RET(cpu_buffer,
+                if (RB_WARN_ON(cpu_buffer,
-                               page->list.next->prev != &page->list);
+                               page->list.next->prev != &page->list))
-                RB_WARN_ON_RET(cpu_buffer,
+                        return -1;
-                               page->list.prev->next != &page->list);
+                if (RB_WARN_ON(cpu_buffer,
+                               page->list.prev->next != &page->list))
+                        return -1;
        }
        return 0;
@@ -324,7 +315,8 @@ rb_allocate_cpu_buffer(struct ring_buffer *buffer, int cpu)
        cpu_buffer->cpu = cpu;
        cpu_buffer->buffer = buffer;
-        spin_lock_init(&cpu_buffer->lock);
+        spin_lock_init(&cpu_buffer->reader_lock);
+        cpu_buffer->lock = (raw_spinlock_t)__RAW_SPIN_LOCK_UNLOCKED;
        INIT_LIST_HEAD(&cpu_buffer->pages);
        page = kzalloc_node(ALIGN(sizeof(*page), cache_line_size()),
@@ -473,13 +465,15 @@ rb_remove_pages(struct ring_buffer_per_cpu *cpu_buffer, unsigned nr_pages)
        synchronize_sched();
        for (i = 0; i < nr_pages; i++) {
-                BUG_ON(list_empty(&cpu_buffer->pages));
+                if (RB_WARN_ON(cpu_buffer, list_empty(&cpu_buffer->pages)))
+                        return;
                p = cpu_buffer->pages.next;
                page = list_entry(p, struct buffer_page, list);
                list_del_init(&page->list);
                free_buffer_page(page);
        }
-        BUG_ON(list_empty(&cpu_buffer->pages));
+        if (RB_WARN_ON(cpu_buffer, list_empty(&cpu_buffer->pages)))
+                return;
        rb_reset_cpu(cpu_buffer);
@@ -501,7 +495,8 @@ rb_insert_pages(struct ring_buffer_per_cpu *cpu_buffer,
        synchronize_sched();
        for (i = 0; i < nr_pages; i++) {
-                BUG_ON(list_empty(pages));
+                if (RB_WARN_ON(cpu_buffer, list_empty(pages)))
+                        return;
                p = pages->next;
                page = list_entry(p, struct buffer_page, list);
                list_del_init(&page->list);
@@ -562,7 +557,10 @@ int ring_buffer_resize(struct ring_buffer *buffer, unsigned long size)
        if (size < buffer_size) {
                /* easy case, just free pages */
-                BUG_ON(nr_pages >= buffer->pages);
+                if (RB_WARN_ON(buffer, nr_pages >= buffer->pages)) {
+                        mutex_unlock(&buffer->mutex);
+                        return -1;
+                }
                rm_pages = buffer->pages - nr_pages;
@@ -581,7 +579,11 @@ int ring_buffer_resize(struct ring_buffer *buffer, unsigned long size)
         * add these pages to the cpu_buffers. Otherwise we just free
         * them all and return -ENOMEM;
         */
-        BUG_ON(nr_pages <= buffer->pages);
+        if (RB_WARN_ON(buffer, nr_pages <= buffer->pages)) {
+                mutex_unlock(&buffer->mutex);
+                return -1;
+        }
        new_pages = nr_pages - buffer->pages;
        for_each_buffer_cpu(buffer, cpu) {
@@ -604,7 +606,10 @@ int ring_buffer_resize(struct ring_buffer *buffer, unsigned long size)
                rb_insert_pages(cpu_buffer, &pages, new_pages);
        }
-        BUG_ON(!list_empty(&pages));
+        if (RB_WARN_ON(buffer, !list_empty(&pages))) {
+                mutex_unlock(&buffer->mutex);
+                return -1;
+        }
 out:
        buffer->pages = nr_pages;
@@ -617,6 +622,7 @@ int ring_buffer_resize(struct ring_buffer *buffer, unsigned long size)
                list_del_init(&page->list);
                free_buffer_page(page);
        }
+        mutex_unlock(&buffer->mutex);
        return -ENOMEM;
 }
@@ -692,7 +698,8 @@ static void rb_update_overflow(struct ring_buffer_per_cpu *cpu_buffer)
             head += rb_event_length(event)) {
                event = __rb_page_index(cpu_buffer->head_page, head);
-                BUG_ON(rb_null_event(event));
+                if (RB_WARN_ON(cpu_buffer, rb_null_event(event)))
+                        return;
                /* Only count data entries */
                if (event->type != RINGBUF_TYPE_DATA)
                        continue;
@@ -745,8 +752,9 @@ rb_set_commit_event(struct ring_buffer_per_cpu *cpu_buffer,
        addr &= PAGE_MASK;
        while (cpu_buffer->commit_page->page != (void *)addr) {
-                RB_WARN_ON(cpu_buffer,
+                if (RB_WARN_ON(cpu_buffer,
-                           cpu_buffer->commit_page == cpu_buffer->tail_page);
+                          cpu_buffer->commit_page == cpu_buffer->tail_page))
+                        return;
                cpu_buffer->commit_page->commit =
                        cpu_buffer->commit_page->write;
                rb_inc_page(cpu_buffer, &cpu_buffer->commit_page);
@@ -893,7 +901,8 @@ __rb_reserve_next(struct ring_buffer_per_cpu *cpu_buffer,
        if (write > BUF_PAGE_SIZE) {
                struct buffer_page *next_page = tail_page;
-                spin_lock_irqsave(&cpu_buffer->lock, flags);
+                local_irq_save(flags);
+                __raw_spin_lock(&cpu_buffer->lock);
                rb_inc_page(cpu_buffer, &next_page);
@@ -901,7 +910,8 @@ __rb_reserve_next(struct ring_buffer_per_cpu *cpu_buffer,
                reader_page = cpu_buffer->reader_page;
                /* we grabbed the lock before incrementing */
-                RB_WARN_ON(cpu_buffer, next_page == reader_page);
+                if (RB_WARN_ON(cpu_buffer, next_page == reader_page))
+                        goto out_unlock;
                /*
                 * If for some reason, we had an interrupt storm that made
@@ -969,7 +979,8 @@ __rb_reserve_next(struct ring_buffer_per_cpu *cpu_buffer,
                        rb_set_commit_to_write(cpu_buffer);
                }
-                spin_unlock_irqrestore(&cpu_buffer->lock, flags);
+                __raw_spin_unlock(&cpu_buffer->lock);
+                local_irq_restore(flags);
                /* fail and let the caller try again */
                return ERR_PTR(-EAGAIN);
@@ -977,7 +988,8 @@ __rb_reserve_next(struct ring_buffer_per_cpu *cpu_buffer,
        /* We reserved something on the buffer */
-        BUG_ON(write > BUF_PAGE_SIZE);
+        if (RB_WARN_ON(cpu_buffer, write > BUF_PAGE_SIZE))
+                return NULL;
        event = __rb_page_index(tail_page, tail);
        rb_update_event(event, type, length);
@@ -992,7 +1004,8 @@ __rb_reserve_next(struct ring_buffer_per_cpu *cpu_buffer,
        return event;
 out_unlock:
-        spin_unlock_irqrestore(&cpu_buffer->lock, flags);
+        __raw_spin_unlock(&cpu_buffer->lock);
+        local_irq_restore(flags);
        return NULL;
 }
@@ -1075,10 +1088,8 @@ rb_reserve_next_event(struct ring_buffer_per_cpu *cpu_buffer,
         * storm or we have something buggy.
         * Bail!
         */
-        if (unlikely(++nr_loops > 1000)) {
+        if (RB_WARN_ON(cpu_buffer, ++nr_loops > 1000))
-                RB_WARN_ON(cpu_buffer, 1);
                return NULL;
-        }
        ts = ring_buffer_time_stamp(cpu_buffer->cpu);
@@ -1181,8 +1192,7 @@ ring_buffer_lock_reserve(struct ring_buffer *buffer,
                return NULL;
        /* If we are tracing schedule, we don't want to recurse */
-        resched = need_resched();
+        resched = ftrace_preempt_disable();
-        preempt_disable_notrace();
        cpu = raw_smp_processor_id();
@@ -1213,10 +1223,7 @@ ring_buffer_lock_reserve(struct ring_buffer *buffer,
        return event;
 out:
-        if (resched)
+        ftrace_preempt_enable(resched);
-                preempt_enable_notrace();
-        else
-                preempt_enable_notrace();
        return NULL;
 }
@@ -1258,12 +1265,9 @@ int ring_buffer_unlock_commit(struct ring_buffer *buffer,
        /*
         * Only the last preempt count needs to restore preemption.
         */
-        if (preempt_count() == 1) {
+        if (preempt_count() == 1)
-                if (per_cpu(rb_need_resched, cpu))
+                ftrace_preempt_enable(per_cpu(rb_need_resched, cpu));
-                        preempt_enable_no_resched_notrace();
+        else
-                else
-                        preempt_enable_notrace();
-        } else
                preempt_enable_no_resched_notrace();
        return 0;
@@ -1299,8 +1303,7 @@ int ring_buffer_write(struct ring_buffer *buffer,
        if (atomic_read(&buffer->record_disabled))
                return -EBUSY;
-        resched = need_resched();
+        resched = ftrace_preempt_disable();
-        preempt_disable_notrace();
        cpu = raw_smp_processor_id();
@@ -1326,10 +1329,7 @@ int ring_buffer_write(struct ring_buffer *buffer,
        ret = 0;
 out:
-        if (resched)
+        ftrace_preempt_enable(resched);
-                preempt_enable_no_resched_notrace();
-        else
-                preempt_enable_notrace();
        return ret;
 }
@@ -1488,14 +1488,7 @@ unsigned long ring_buffer_overruns(struct ring_buffer *buffer)
        return overruns;
 }
-/**
+static void rb_iter_reset(struct ring_buffer_iter *iter)
- * ring_buffer_iter_reset - reset an iterator
- * @iter: The iterator to reset
- *
- * Resets the iterator, so that it will start from the beginning
- * again.
- */
-void ring_buffer_iter_reset(struct ring_buffer_iter *iter)
 {
        struct ring_buffer_per_cpu *cpu_buffer = iter->cpu_buffer;
@@ -1514,6 +1507,23 @@ void ring_buffer_iter_reset(struct ring_buffer_iter *iter)
 }
 /**
+ * ring_buffer_iter_reset - reset an iterator
+ * @iter: The iterator to reset
+ *
+ * Resets the iterator, so that it will start from the beginning
+ * again.
+ */
+void ring_buffer_iter_reset(struct ring_buffer_iter *iter)
+{
+        struct ring_buffer_per_cpu *cpu_buffer = iter->cpu_buffer;
+        unsigned long flags;
+        spin_lock_irqsave(&cpu_buffer->reader_lock, flags);
+        rb_iter_reset(iter);
+        spin_unlock_irqrestore(&cpu_buffer->reader_lock, flags);
+}
+/**
 * ring_buffer_iter_empty - check if an iterator has no more to read
 * @iter: The iterator to check
 */
@@ -1596,7 +1606,8 @@ rb_get_reader_page(struct ring_buffer_per_cpu *cpu_buffer)
        unsigned long flags;
        int nr_loops = 0;
-        spin_lock_irqsave(&cpu_buffer->lock, flags);
+        local_irq_save(flags);
+        __raw_spin_lock(&cpu_buffer->lock);
 again:
        /*
@@ -1605,8 +1616,7 @@ rb_get_reader_page(struct ring_buffer_per_cpu *cpu_buffer)
         * a case where we will loop three times. There should be no
         * reason to loop four times (that I know of).
         */
-        if (unlikely(++nr_loops > 3)) {
+        if (RB_WARN_ON(cpu_buffer, ++nr_loops > 3)) {
-                RB_WARN_ON(cpu_buffer, 1);
                reader = NULL;
                goto out;
        }
@@ -1618,8 +1628,9 @@ rb_get_reader_page(struct ring_buffer_per_cpu *cpu_buffer)
                goto out;
        /* Never should we have an index greater than the size */
-        RB_WARN_ON(cpu_buffer,
+        if (RB_WARN_ON(cpu_buffer,
-                   cpu_buffer->reader_page->read > rb_page_size(reader));
+                       cpu_buffer->reader_page->read > rb_page_size(reader)))
+                goto out;
        /* check if we caught up to the tail */
        reader = NULL;
@@ -1658,7 +1669,8 @@ rb_get_reader_page(struct ring_buffer_per_cpu *cpu_buffer)
        goto again;
 out:
-        spin_unlock_irqrestore(&cpu_buffer->lock, flags);
+        __raw_spin_unlock(&cpu_buffer->lock);
+        local_irq_restore(flags);
        return reader;
 }
@@ -1672,7 +1684,8 @@ static void rb_advance_reader(struct ring_buffer_per_cpu *cpu_buffer)
        reader = rb_get_reader_page(cpu_buffer);
        /* This function should not be called when buffer is empty */
-        BUG_ON(!reader);
+        if (RB_WARN_ON(cpu_buffer, !reader))
+                return;
        event = rb_reader_event(cpu_buffer);
@@ -1699,7 +1712,9 @@ static void rb_advance_iter(struct ring_buffer_iter *iter)
         * Check if we are at the end of the buffer.
         */
        if (iter->head >= rb_page_size(iter->head_page)) {
-                BUG_ON(iter->head_page == cpu_buffer->commit_page);
+                if (RB_WARN_ON(buffer,
+                               iter->head_page == cpu_buffer->commit_page))
+                        return;
                rb_inc_iter(iter);
                return;
        }
@@ -1712,8 +1727,10 @@ static void rb_advance_iter(struct ring_buffer_iter *iter)
         * This should not be called to advance the header if we are
         * at the tail of the buffer.
         */
-        BUG_ON((iter->head_page == cpu_buffer->commit_page) &&
+        if (RB_WARN_ON(cpu_buffer,
-               (iter->head + length > rb_commit_index(cpu_buffer)));
+                       (iter->head_page == cpu_buffer->commit_page) &&
+                       (iter->head + length > rb_commit_index(cpu_buffer))))
+                return;
        rb_update_iter_read_stamp(iter, event);
@@ -1725,17 +1742,8 @@ static void rb_advance_iter(struct ring_buffer_iter *iter)
                rb_advance_iter(iter);
 }
-/**
+static struct ring_buffer_event *
- * ring_buffer_peek - peek at the next event to be read
+rb_buffer_peek(struct ring_buffer *buffer, int cpu, u64 *ts)
- * @buffer: The ring buffer to read
- * @cpu: The cpu to peak at
- * @ts: The timestamp counter of this event.
- *
- * This will return the event that will be read next, but does
- * not consume the data.
- */
-struct ring_buffer_event *
-ring_buffer_peek(struct ring_buffer *buffer, int cpu, u64 *ts)
 {
        struct ring_buffer_per_cpu *cpu_buffer;
        struct ring_buffer_event *event;
@@ -1756,10 +1764,8 @@ ring_buffer_peek(struct ring_buffer *buffer, int cpu, u64 *ts)
         * can have.  Nesting 10 deep of interrupts is clearly
         * an anomaly.
         */
-        if (unlikely(++nr_loops > 10)) {
+        if (RB_WARN_ON(cpu_buffer, ++nr_loops > 10))
-                RB_WARN_ON(cpu_buffer, 1);
                return NULL;
-        }
        reader = rb_get_reader_page(cpu_buffer);
        if (!reader)
@@ -1797,16 +1803,8 @@ ring_buffer_peek(struct ring_buffer *buffer, int cpu, u64 *ts)
        return NULL;
 }
-/**
+static struct ring_buffer_event *
- * ring_buffer_iter_peek - peek at the next event to be read
+rb_iter_peek(struct ring_buffer_iter *iter, u64 *ts)
- * @iter: The ring buffer iterator
- * @ts: The timestamp counter of this event.
- *
- * This will return the event that will be read next, but does
- * not increment the iterator.
- */
-struct ring_buffer_event *
-ring_buffer_iter_peek(struct ring_buffer_iter *iter, u64 *ts)
 {
        struct ring_buffer *buffer;
        struct ring_buffer_per_cpu *cpu_buffer;
@@ -1828,10 +1826,8 @@ ring_buffer_iter_peek(struct ring_buffer_iter *iter, u64 *ts)
         * can have. Nesting 10 deep of interrupts is clearly
         * an anomaly.
         */
-        if (unlikely(++nr_loops > 10)) {
+        if (RB_WARN_ON(cpu_buffer, ++nr_loops > 10))
-                RB_WARN_ON(cpu_buffer, 1);
                return NULL;
-        }
        if (rb_per_cpu_empty(cpu_buffer))
                return NULL;
@@ -1868,6 +1864,51 @@ ring_buffer_iter_peek(struct ring_buffer_iter *iter, u64 *ts)
 }
 /**
+ * ring_buffer_peek - peek at the next event to be read
+ * @buffer: The ring buffer to read
+ * @cpu: The cpu to peak at
+ * @ts: The timestamp counter of this event.
+ *
+ * This will return the event that will be read next, but does
+ * not consume the data.
+ */
+struct ring_buffer_event *
+ring_buffer_peek(struct ring_buffer *buffer, int cpu, u64 *ts)
+{
+        struct ring_buffer_per_cpu *cpu_buffer = buffer->buffers[cpu];
+        struct ring_buffer_event *event;
+        unsigned long flags;
+        spin_lock_irqsave(&cpu_buffer->reader_lock, flags);
+        event = rb_buffer_peek(buffer, cpu, ts);
+        spin_unlock_irqrestore(&cpu_buffer->reader_lock, flags);
+        return event;
+}
+/**
+ * ring_buffer_iter_peek - peek at the next event to be read
+ * @iter: The ring buffer iterator
+ * @ts: The timestamp counter of this event.
+ *
+ * This will return the event that will be read next, but does
+ * not increment the iterator.
+ */
+struct ring_buffer_event *
+ring_buffer_iter_peek(struct ring_buffer_iter *iter, u64 *ts)
+{
+        struct ring_buffer_per_cpu *cpu_buffer = iter->cpu_buffer;
+        struct ring_buffer_event *event;
+        unsigned long flags;
+        spin_lock_irqsave(&cpu_buffer->reader_lock, flags);
+        event = rb_iter_peek(iter, ts);
+        spin_unlock_irqrestore(&cpu_buffer->reader_lock, flags);
+        return event;
+}
+/**
 * ring_buffer_consume - return an event and consume it
 * @buffer: The ring buffer to get the next event from
 *
@@ -1878,19 +1919,24 @@ ring_buffer_iter_peek(struct ring_buffer_iter *iter, u64 *ts)
 struct ring_buffer_event *
 ring_buffer_consume(struct ring_buffer *buffer, int cpu, u64 *ts)
 {
-        struct ring_buffer_per_cpu *cpu_buffer;
+        struct ring_buffer_per_cpu *cpu_buffer = buffer->buffers[cpu];
        struct ring_buffer_event *event;
+        unsigned long flags;
        if (!cpu_isset(cpu, buffer->cpumask))
                return NULL;
-        event = ring_buffer_peek(buffer, cpu, ts);
+        spin_lock_irqsave(&cpu_buffer->reader_lock, flags);
+        event = rb_buffer_peek(buffer, cpu, ts);
        if (!event)
-                return NULL;
+                goto out;
-        cpu_buffer = buffer->buffers[cpu];
        rb_advance_reader(cpu_buffer);
+ out:
+        spin_unlock_irqrestore(&cpu_buffer->reader_lock, flags);
        return event;
 }
@@ -1927,9 +1973,11 @@ ring_buffer_read_start(struct ring_buffer *buffer, int cpu)
        atomic_inc(&cpu_buffer->record_disabled);
        synchronize_sched();
-        spin_lock_irqsave(&cpu_buffer->lock, flags);
+        spin_lock_irqsave(&cpu_buffer->reader_lock, flags);
-        ring_buffer_iter_reset(iter);
+        __raw_spin_lock(&cpu_buffer->lock);
-        spin_unlock_irqrestore(&cpu_buffer->lock, flags);
+        rb_iter_reset(iter);
+        __raw_spin_unlock(&cpu_buffer->lock);
+        spin_unlock_irqrestore(&cpu_buffer->reader_lock, flags);
        return iter;
 }
@@ -1961,12 +2009,17 @@ struct ring_buffer_event *
 ring_buffer_read(struct ring_buffer_iter *iter, u64 *ts)
 {
        struct ring_buffer_event *event;
+        struct ring_buffer_per_cpu *cpu_buffer = iter->cpu_buffer;
+        unsigned long flags;
-        event = ring_buffer_iter_peek(iter, ts);
+        spin_lock_irqsave(&cpu_buffer->reader_lock, flags);
+        event = rb_iter_peek(iter, ts);
        if (!event)
-                return NULL;
+                goto out;
        rb_advance_iter(iter);
+ out:
+        spin_unlock_irqrestore(&cpu_buffer->reader_lock, flags);
        return event;
 }
@@ -2015,11 +2068,15 @@ void ring_buffer_reset_cpu(struct ring_buffer *buffer, int cpu)
        if (!cpu_isset(cpu, buffer->cpumask))
                return;
-        spin_lock_irqsave(&cpu_buffer->lock, flags);
+        spin_lock_irqsave(&cpu_buffer->reader_lock, flags);
+        __raw_spin_lock(&cpu_buffer->lock);
        rb_reset_cpu(cpu_buffer);
-        spin_unlock_irqrestore(&cpu_buffer->lock, flags);
+        __raw_spin_unlock(&cpu_buffer->lock);
+        spin_unlock_irqrestore(&cpu_buffer->reader_lock, flags);
 }
 /**
diff --git a/kernel/trace/trace.c b/kernel/trace/trace.c
index 697eda36b86a..4ee6f0375222 100644
--- a/kernel/trace/trace.c
+++ b/kernel/trace/trace.c
@@ -43,6 +43,29 @@
 unsigned long __read_mostly     tracing_max_latency = (cycle_t)ULONG_MAX;
 unsigned long __read_mostly     tracing_thresh;
+/* For tracers that don't implement custom flags */
+static struct tracer_opt dummy_tracer_opt[] = {
+        { }
+};
+static struct tracer_flags dummy_tracer_flags = {
+        .val = 0,
+        .opts = dummy_tracer_opt
+};
+static int dummy_set_flag(u32 old_flags, u32 bit, int set)
+{
+        return 0;
+}
+/*
+ * Kill all tracing for good (never come back).
+ * It is initialized to 1 but will turn to zero if the initialization
+ * of the tracer is successful. But that is the only place that sets
+ * this back to zero.
+ */
+int tracing_disabled = 1;
 static DEFINE_PER_CPU(local_t, ftrace_cpu_disabled);
 static inline void ftrace_disable_cpu(void)
@@ -62,7 +85,36 @@ static cpumask_t __read_mostly		tracing_buffer_mask;
 #define for_each_tracing_cpu(cpu)       \
        for_each_cpu_mask(cpu, tracing_buffer_mask)
-static int tracing_disabled = 1;
+/*
+ * ftrace_dump_on_oops - variable to dump ftrace buffer on oops
+ *
+ * If there is an oops (or kernel panic) and the ftrace_dump_on_oops
+ * is set, then ftrace_dump is called. This will output the contents
+ * of the ftrace buffers to the console.  This is very useful for
+ * capturing traces that lead to crashes and outputing it to a
+ * serial console.
+ *
+ * It is default off, but you can enable it with either specifying
+ * "ftrace_dump_on_oops" in the kernel command line, or setting
+ * /proc/sys/kernel/ftrace_dump_on_oops to true.
+ */
+int ftrace_dump_on_oops;
+static int tracing_set_tracer(char *buf);
+static int __init set_ftrace(char *str)
+{
+        tracing_set_tracer(str);
+        return 1;
+}
+__setup("ftrace", set_ftrace);
+static int __init set_ftrace_dump_on_oops(char *str)
+{
+        ftrace_dump_on_oops = 1;
+        return 1;
+}
+__setup("ftrace_dump_on_oops", set_ftrace_dump_on_oops);
 long
 ns2usecs(cycle_t nsec)
@@ -112,6 +164,19 @@ static DEFINE_PER_CPU(struct trace_array_cpu, max_data);
 /* tracer_enabled is used to toggle activation of a tracer */
 static int                      tracer_enabled = 1;
+/**
+ * tracing_is_enabled - return tracer_enabled status
+ *
+ * This function is used by other tracers to know the status
+ * of the tracer_enabled flag.  Tracers may use this function
+ * to know if it should enable their features when starting
+ * up. See irqsoff tracer for an example (start_irqsoff_tracer).
+ */
+int tracing_is_enabled(void)
+{
+        return tracer_enabled;
+}
 /* function tracing enabled */
 int                             ftrace_function_enabled;
@@ -153,8 +218,9 @@ static DEFINE_MUTEX(trace_types_lock);
 /* trace_wait is a waitqueue for tasks blocked on trace_poll */
 static DECLARE_WAIT_QUEUE_HEAD(trace_wait);
-/* trace_flags holds iter_ctrl options */
+/* trace_flags holds trace_options default values */
-unsigned long trace_flags = TRACE_ITER_PRINT_PARENT;
+unsigned long trace_flags = TRACE_ITER_PRINT_PARENT | TRACE_ITER_PRINTK |
+        TRACE_ITER_ANNOTATE;
 /**
 * trace_wake_up - wake up tasks waiting for trace input
@@ -193,13 +259,6 @@ unsigned long nsecs_to_usecs(unsigned long nsecs)
        return nsecs / 1000;
 }
-/*
- * TRACE_ITER_SYM_MASK masks the options in trace_flags that
- * control the output of kernel symbols.
- */
-#define TRACE_ITER_SYM_MASK \
-        (TRACE_ITER_PRINT_PARENT|TRACE_ITER_SYM_OFFSET|TRACE_ITER_SYM_ADDR)
 /* These must match the bit postions in trace_iterator_flags */
 static const char *trace_options[] = {
        "print-parent",
@@ -213,6 +272,9 @@ static const char *trace_options[] = {
        "stacktrace",
        "sched-tree",
        "ftrace_printk",
+        "ftrace_preempt",
+        "branch",
+        "annotate",
        NULL
 };
@@ -470,7 +532,15 @@ int register_tracer(struct tracer *type)
                return -1;
        }
+        /*
+         * When this gets called we hold the BKL which means that
+         * preemption is disabled. Various trace selftests however
+         * need to disable and enable preemption for successful tests.
+         * So we drop the BKL here and grab it after the tests again.
+         */
+        unlock_kernel();
        mutex_lock(&trace_types_lock);
        for (t = trace_types; t; t = t->next) {
                if (strcmp(type->name, t->name) == 0) {
                        /* already found */
@@ -481,11 +551,18 @@ int register_tracer(struct tracer *type)
                }
        }
+        if (!type->set_flag)
+                type->set_flag = &dummy_set_flag;
+        if (!type->flags)
+                type->flags = &dummy_tracer_flags;
+        else
+                if (!type->flags->opts)
+                        type->flags->opts = dummy_tracer_opt;
 #ifdef CONFIG_FTRACE_STARTUP_TEST
        if (type->selftest) {
                struct tracer *saved_tracer = current_trace;
                struct trace_array *tr = &global_trace;
-                int saved_ctrl = tr->ctrl;
                int i;
                /*
                 * Run a selftest on this tracer.
@@ -494,25 +571,23 @@ int register_tracer(struct tracer *type)
                 * internal tracing to verify that everything is in order.
                 * If we fail, we do not register this tracer.
                 */
-                for_each_tracing_cpu(i) {
+                for_each_tracing_cpu(i)
                        tracing_reset(tr, i);
-                }
                current_trace = type;
-                tr->ctrl = 0;
                /* the test is responsible for initializing and enabling */
                pr_info("Testing tracer %s: ", type->name);
                ret = type->selftest(type, tr);
                /* the test is responsible for resetting too */
                current_trace = saved_tracer;
-                tr->ctrl = saved_ctrl;
                if (ret) {
                        printk(KERN_CONT "FAILED!\n");
                        goto out;
                }
                /* Only reset on passing, to avoid touching corrupted buffers */
-                for_each_tracing_cpu(i) {
+                for_each_tracing_cpu(i)
                        tracing_reset(tr, i);
-                }
                printk(KERN_CONT "PASSED\n");
        }
 #endif
@@ -525,6 +600,7 @@ int register_tracer(struct tracer *type)
 out:
        mutex_unlock(&trace_types_lock);
+        lock_kernel();
        return ret;
 }
@@ -581,6 +657,76 @@ static void trace_init_cmdlines(void)
        cmdline_idx = 0;
 }
+static int trace_stop_count;
+static DEFINE_SPINLOCK(tracing_start_lock);
+/**
+ * tracing_start - quick start of the tracer
+ *
+ * If tracing is enabled but was stopped by tracing_stop,
+ * this will start the tracer back up.
+ */
+void tracing_start(void)
+{
+        struct ring_buffer *buffer;
+        unsigned long flags;
+        if (tracing_disabled)
+                return;
+        spin_lock_irqsave(&tracing_start_lock, flags);
+        if (--trace_stop_count)
+                goto out;
+        if (trace_stop_count < 0) {
+                /* Someone screwed up their debugging */
+                WARN_ON_ONCE(1);
+                trace_stop_count = 0;
+                goto out;
+        }
+        buffer = global_trace.buffer;
+        if (buffer)
+                ring_buffer_record_enable(buffer);
+        buffer = max_tr.buffer;
+        if (buffer)
+                ring_buffer_record_enable(buffer);
+        ftrace_start();
+ out:
+        spin_unlock_irqrestore(&tracing_start_lock, flags);
+}
+/**
+ * tracing_stop - quick stop of the tracer
+ *
+ * Light weight way to stop tracing. Use in conjunction with
+ * tracing_start.
+ */
+void tracing_stop(void)
+{
+        struct ring_buffer *buffer;
+        unsigned long flags;
+        ftrace_stop();
+        spin_lock_irqsave(&tracing_start_lock, flags);
+        if (trace_stop_count++)
+                goto out;
+        buffer = global_trace.buffer;
+        if (buffer)
+                ring_buffer_record_disable(buffer);
+        buffer = max_tr.buffer;
+        if (buffer)
+                ring_buffer_record_disable(buffer);
+ out:
+        spin_unlock_irqrestore(&tracing_start_lock, flags);
+}
 void trace_stop_cmdline_recording(void);
 static void trace_save_cmdline(struct task_struct *tsk)
@@ -691,6 +837,36 @@ trace_function(struct trace_array *tr, struct trace_array_cpu *data,
        ring_buffer_unlock_commit(tr->buffer, event, irq_flags);
 }
+#ifdef CONFIG_FUNCTION_RET_TRACER
+static void __trace_function_return(struct trace_array *tr,
+                                struct trace_array_cpu *data,
+                                struct ftrace_retfunc *trace,
+                                unsigned long flags,
+                                int pc)
+{
+        struct ring_buffer_event *event;
+        struct ftrace_ret_entry *entry;
+        unsigned long irq_flags;
+        if (unlikely(local_read(&__get_cpu_var(ftrace_cpu_disabled))))
+                return;
+        event = ring_buffer_lock_reserve(global_trace.buffer, sizeof(*entry),
+                                         &irq_flags);
+        if (!event)
+                return;
+        entry   = ring_buffer_event_data(event);
+        tracing_generic_entry_update(&entry->ent, flags, pc);
+        entry->ent.type                 = TRACE_FN_RET;
+        entry->ip                       = trace->func;
+        entry->parent_ip        = trace->ret;
+        entry->rettime          = trace->rettime;
+        entry->calltime         = trace->calltime;
+        entry->overrun          = trace->overrun;
+        ring_buffer_unlock_commit(global_trace.buffer, event, irq_flags);
+}
+#endif
 void
 ftrace(struct trace_array *tr, struct trace_array_cpu *data,
       unsigned long ip, unsigned long parent_ip, unsigned long flags,
@@ -841,26 +1017,28 @@ ftrace_special(unsigned long arg1, unsigned long arg2, unsigned long arg3)
 {
        struct trace_array *tr = &global_trace;
        struct trace_array_cpu *data;
+        unsigned long flags;
        int cpu;
        int pc;
-        if (tracing_disabled || !tr->ctrl)
+        if (tracing_disabled)
                return;
        pc = preempt_count();
-        preempt_disable_notrace();
+        local_irq_save(flags);
        cpu = raw_smp_processor_id();
        data = tr->data[cpu];
-        if (likely(!atomic_read(&data->disabled)))
+        if (likely(atomic_inc_return(&data->disabled) == 1))
                ftrace_trace_special(tr, data, arg1, arg2, arg3, pc);
-        preempt_enable_notrace();
+        atomic_dec(&data->disabled);
+        local_irq_restore(flags);
 }
 #ifdef CONFIG_FUNCTION_TRACER
 static void
-function_trace_call(unsigned long ip, unsigned long parent_ip)
+function_trace_call_preempt_only(unsigned long ip, unsigned long parent_ip)
 {
        struct trace_array *tr = &global_trace;
        struct trace_array_cpu *data;
@@ -873,8 +1051,7 @@ function_trace_call(unsigned long ip, unsigned long parent_ip)
                return;
        pc = preempt_count();
-        resched = need_resched();
+        resched = ftrace_preempt_disable();
-        preempt_disable_notrace();
        local_save_flags(flags);
        cpu = raw_smp_processor_id();
        data = tr->data[cpu];
@@ -884,12 +1061,63 @@ function_trace_call(unsigned long ip, unsigned long parent_ip)
                trace_function(tr, data, ip, parent_ip, flags, pc);
        atomic_dec(&data->disabled);
-        if (resched)
+        ftrace_preempt_enable(resched);
-                preempt_enable_no_resched_notrace();
+}
-        else
-                preempt_enable_notrace();
+static void
+function_trace_call(unsigned long ip, unsigned long parent_ip)
+{
+        struct trace_array *tr = &global_trace;
+        struct trace_array_cpu *data;
+        unsigned long flags;
+        long disabled;
+        int cpu;
+        int pc;
+        if (unlikely(!ftrace_function_enabled))
+                return;
+        /*
+         * Need to use raw, since this must be called before the
+         * recursive protection is performed.
+         */
+        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_function(tr, data, ip, parent_ip, flags, pc);
+        }
+        atomic_dec(&data->disabled);
+        local_irq_restore(flags);
 }
+#ifdef CONFIG_FUNCTION_RET_TRACER
+void trace_function_return(struct ftrace_retfunc *trace)
+{
+        struct trace_array *tr = &global_trace;
+        struct trace_array_cpu *data;
+        unsigned long flags;
+        long disabled;
+        int cpu;
+        int pc;
+        raw_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_function_return(tr, data, trace, flags, pc);
+        }
+        atomic_dec(&data->disabled);
+        raw_local_irq_restore(flags);
+}
+#endif /* CONFIG_FUNCTION_RET_TRACER */
 static struct ftrace_ops trace_ops __read_mostly =
 {
        .func = function_trace_call,
@@ -898,9 +1126,14 @@ static struct ftrace_ops trace_ops __read_mostly =
 void tracing_start_function_trace(void)
 {
        ftrace_function_enabled = 0;
+        if (trace_flags & TRACE_ITER_PREEMPTONLY)
+                trace_ops.func = function_trace_call_preempt_only;
+        else
+                trace_ops.func = function_trace_call;
        register_ftrace_function(&trace_ops);
-        if (tracer_enabled)
+        ftrace_function_enabled = 1;
-                ftrace_function_enabled = 1;
 }
 void tracing_stop_function_trace(void)
@@ -912,6 +1145,7 @@ void tracing_stop_function_trace(void)
 enum trace_file_type {
        TRACE_FILE_LAT_FMT      = 1,
+        TRACE_FILE_ANNOTATE     = 2,
 };
 static void trace_iterator_increment(struct trace_iterator *iter, int cpu)
@@ -1047,10 +1281,6 @@ static void *s_start(struct seq_file *m, loff_t *pos)
        atomic_inc(&trace_record_cmdline_disabled);
-        /* let the tracer grab locks here if needed */
-        if (current_trace->start)
-                current_trace->start(iter);
        if (*pos != iter->pos) {
                iter->ent = NULL;
                iter->cpu = 0;
@@ -1077,14 +1307,7 @@ static void *s_start(struct seq_file *m, loff_t *pos)
 static void s_stop(struct seq_file *m, void *p)
 {
-        struct trace_iterator *iter = m->private;
        atomic_dec(&trace_record_cmdline_disabled);
-        /* let the tracer release locks here if needed */
-        if (current_trace && current_trace == iter->trace && iter->trace->stop)
-                iter->trace->stop(iter);
        mutex_unlock(&trace_types_lock);
 }
@@ -1143,7 +1366,7 @@ seq_print_sym_offset(struct trace_seq *s, const char *fmt,
 # define IP_FMT "%016lx"
 #endif
-static int
+int
 seq_print_ip_sym(struct trace_seq *s, unsigned long ip, unsigned long sym_flags)
 {
        int ret;
@@ -1338,6 +1561,23 @@ void trace_seq_print_cont(struct trace_seq *s, struct trace_iterator *iter)
                trace_seq_putc(s, '\n');
 }
+static void test_cpu_buff_start(struct trace_iterator *iter)
+{
+        struct trace_seq *s = &iter->seq;
+        if (!(trace_flags & TRACE_ITER_ANNOTATE))
+                return;
+        if (!(iter->iter_flags & TRACE_FILE_ANNOTATE))
+                return;
+        if (cpu_isset(iter->cpu, iter->started))
+                return;
+        cpu_set(iter->cpu, iter->started);
+        trace_seq_printf(s, "##### CPU %u buffer started ####\n", iter->cpu);
+}
 static enum print_line_t
 print_lat_fmt(struct trace_iterator *iter, unsigned int trace_idx, int cpu)
 {
@@ -1357,6 +1597,8 @@ print_lat_fmt(struct trace_iterator *iter, unsigned int trace_idx, int cpu)
        if (entry->type == TRACE_CONT)
                return TRACE_TYPE_HANDLED;
+        test_cpu_buff_start(iter);
        next_entry = find_next_entry(iter, NULL, &next_ts);
        if (!next_entry)
                next_ts = iter->ts;
@@ -1448,6 +1690,18 @@ print_lat_fmt(struct trace_iterator *iter, unsigned int trace_idx, int cpu)
                        trace_seq_print_cont(s, iter);
                break;
        }
+        case TRACE_BRANCH: {
+                struct trace_branch *field;
+                trace_assign_type(field, entry);
+                trace_seq_printf(s, "[%s] %s:%s:%d\n",
+                                 field->correct ? "  ok  " : " MISS ",
+                                 field->func,
+                                 field->file,
+                                 field->line);
+                break;
+        }
        default:
                trace_seq_printf(s, "Unknown type %d\n", entry->type);
        }
@@ -1472,6 +1726,8 @@ static enum print_line_t print_trace_fmt(struct trace_iterator *iter)
        if (entry->type == TRACE_CONT)
                return TRACE_TYPE_HANDLED;
+        test_cpu_buff_start(iter);
        comm = trace_find_cmdline(iter->ent->pid);
        t = ns2usecs(iter->ts);
@@ -1581,6 +1837,22 @@ static enum print_line_t print_trace_fmt(struct trace_iterator *iter)
                        trace_seq_print_cont(s, iter);
                break;
        }
+        case TRACE_FN_RET: {
+                return print_return_function(iter);
+                break;
+        }
+        case TRACE_BRANCH: {
+                struct trace_branch *field;
+                trace_assign_type(field, entry);
+                trace_seq_printf(s, "[%s] %s:%s:%d\n",
+                                 field->correct ? "  ok  " : " MISS ",
+                                 field->func,
+                                 field->file,
+                                 field->line);
+                break;
+        }
        }
        return TRACE_TYPE_HANDLED;
 }
@@ -1899,6 +2171,11 @@ __tracing_open(struct inode *inode, struct file *file, int *ret)
        iter->trace = current_trace;
        iter->pos = -1;
+        /* Annotate start of buffers if we had overruns */
+        if (ring_buffer_overruns(iter->tr->buffer))
+                iter->iter_flags |= TRACE_FILE_ANNOTATE;
        for_each_tracing_cpu(cpu) {
                iter->buffer_iter[cpu] =
@@ -1917,10 +2194,7 @@ __tracing_open(struct inode *inode, struct file *file, int *ret)
        m->private = iter;
        /* stop the trace while dumping */
-        if (iter->tr->ctrl) {
+        tracing_stop();
-                tracer_enabled = 0;
-                ftrace_function_enabled = 0;
-        }
        if (iter->trace && iter->trace->open)
                        iter->trace->open(iter);
@@ -1936,6 +2210,7 @@ __tracing_open(struct inode *inode, struct file *file, int *ret)
                        ring_buffer_read_finish(iter->buffer_iter[cpu]);
        }
        mutex_unlock(&trace_types_lock);
+        kfree(iter);
        return ERR_PTR(-ENOMEM);
 }
@@ -1965,14 +2240,7 @@ int tracing_release(struct inode *inode, struct file *file)
                iter->trace->close(iter);
        /* reenable tracing if it was previously enabled */
-        if (iter->tr->ctrl) {
+        tracing_start();
-                tracer_enabled = 1;
-                /*
-                 * It is safe to enable function tracing even if it
-                 * isn't used
-                 */
-                ftrace_function_enabled = 1;
-        }
        mutex_unlock(&trace_types_lock);
        seq_release(inode, file);
@@ -2188,13 +2456,16 @@ static struct file_operations tracing_cpumask_fops = {
 };
 static ssize_t
-tracing_iter_ctrl_read(struct file *filp, char __user *ubuf,
+tracing_trace_options_read(struct file *filp, char __user *ubuf,
                       size_t cnt, loff_t *ppos)
 {
+        int i;
        char *buf;
        int r = 0;
        int len = 0;
-        int i;
+        u32 tracer_flags = current_trace->flags->val;
+        struct tracer_opt *trace_opts = current_trace->flags->opts;
        /* calulate max size */
        for (i = 0; trace_options[i]; i++) {
@@ -2202,6 +2473,15 @@ tracing_iter_ctrl_read(struct file *filp, char __user *ubuf,
                len += 3; /* "no" and space */
        }
+        /*
+         * Increase the size with names of options specific
+         * of the current tracer.
+         */
+        for (i = 0; trace_opts[i].name; i++) {
+                len += strlen(trace_opts[i].name);
+                len += 3; /* "no" and space */
+        }
        /* +2 for \n and \0 */
        buf = kmalloc(len + 2, GFP_KERNEL);
        if (!buf)
@@ -2214,6 +2494,15 @@ tracing_iter_ctrl_read(struct file *filp, char __user *ubuf,
                        r += sprintf(buf + r, "no%s ", trace_options[i]);
        }
+        for (i = 0; trace_opts[i].name; i++) {
+                if (tracer_flags & trace_opts[i].bit)
+                        r += sprintf(buf + r, "%s ",
+                                trace_opts[i].name);
+                else
+                        r += sprintf(buf + r, "no%s ",
+                                trace_opts[i].name);
+        }
        r += sprintf(buf + r, "\n");
        WARN_ON(r >= len + 2);
@@ -2224,13 +2513,48 @@ tracing_iter_ctrl_read(struct file *filp, char __user *ubuf,
        return r;
 }
+/* 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_opt *opts = NULL;
+        int ret = 0, i = 0;
+        int len;
+        for (i = 0; trace_flags->opts[i].name; i++) {
+                opts = &trace_flags->opts[i];
+                len = strlen(opts->name);
+                if (strncmp(cmp, opts->name, len) == 0) {
+                        ret = trace->set_flag(trace_flags->val,
+                                opts->bit, !neg);
+                        break;
+                }
+        }
+        /* Not found */
+        if (!trace_flags->opts[i].name)
+                return -EINVAL;
+        /* Refused to handle */
+        if (ret)
+                return ret;
+        if (neg)
+                trace_flags->val &= ~opts->bit;
+        else
+                trace_flags->val |= opts->bit;
+        return 0;
+}
 static ssize_t
-tracing_iter_ctrl_write(struct file *filp, const char __user *ubuf,
+tracing_trace_options_write(struct file *filp, const char __user *ubuf,
                        size_t cnt, loff_t *ppos)
 {
        char buf[64];
        char *cmp = buf;
        int neg = 0;
+        int ret;
        int i;
        if (cnt >= sizeof(buf))
@@ -2257,11 +2581,13 @@ tracing_iter_ctrl_write(struct file *filp, const char __user *ubuf,
                        break;
                }
        }
-        /*
-         * If no option could be set, return an error:
+        /* If no option could be set, test the specific tracer options */
-         */
+        if (!trace_options[i]) {
-        if (!trace_options[i])
+                ret = set_tracer_option(current_trace, cmp, neg);
-                return -EINVAL;
+                if (ret)
+                        return ret;
+        }
        filp->f_pos += cnt;
@@ -2270,8 +2596,8 @@ tracing_iter_ctrl_write(struct file *filp, const char __user *ubuf,
 static struct file_operations tracing_iter_fops = {
        .open           = tracing_open_generic,
-        .read           = tracing_iter_ctrl_read,
+        .read           = tracing_trace_options_read,
-        .write          = tracing_iter_ctrl_write,
+        .write          = tracing_trace_options_write,
 };
 static const char readme_msg[] =
@@ -2285,9 +2611,9 @@ static const char readme_msg[] =
        "# echo sched_switch > /debug/tracing/current_tracer\n"
        "# cat /debug/tracing/current_tracer\n"
        "sched_switch\n"
-        "# cat /debug/tracing/iter_ctrl\n"
+        "# cat /debug/tracing/trace_options\n"
        "noprint-parent nosym-offset nosym-addr noverbose\n"
-        "# echo print-parent > /debug/tracing/iter_ctrl\n"
+        "# echo print-parent > /debug/tracing/trace_options\n"
        "# echo 1 > /debug/tracing/tracing_enabled\n"
        "# cat /debug/tracing/trace > /tmp/trace.txt\n"
        "echo 0 > /debug/tracing/tracing_enabled\n"
@@ -2310,11 +2636,10 @@ static ssize_t
 tracing_ctrl_read(struct file *filp, char __user *ubuf,
                  size_t cnt, loff_t *ppos)
 {
-        struct trace_array *tr = filp->private_data;
        char buf[64];
        int r;
-        r = sprintf(buf, "%ld\n", tr->ctrl);
+        r = sprintf(buf, "%u\n", tracer_enabled);
        return simple_read_from_buffer(ubuf, cnt, ppos, buf, r);
 }
@@ -2342,16 +2667,18 @@ tracing_ctrl_write(struct file *filp, const char __user *ubuf,
        val = !!val;
        mutex_lock(&trace_types_lock);
-        if (tr->ctrl ^ val) {
+        if (tracer_enabled ^ val) {
-                if (val)
+                if (val) {
                        tracer_enabled = 1;
-                else
+                        if (current_trace->start)
+                                current_trace->start(tr);
+                        tracing_start();
+                } else {
                        tracer_enabled = 0;
+                        tracing_stop();
-                tr->ctrl = val;
+                        if (current_trace->stop)
+                                current_trace->stop(tr);
-                if (current_trace && current_trace->ctrl_update)
+                }
-                        current_trace->ctrl_update(tr);
        }
        mutex_unlock(&trace_types_lock);
@@ -2377,29 +2704,11 @@ tracing_set_trace_read(struct file *filp, char __user *ubuf,
        return simple_read_from_buffer(ubuf, cnt, ppos, buf, r);
 }
-static ssize_t
+static int tracing_set_tracer(char *buf)
-tracing_set_trace_write(struct file *filp, const char __user *ubuf,
-                        size_t cnt, loff_t *ppos)
 {
        struct trace_array *tr = &global_trace;
        struct tracer *t;
-        char buf[max_tracer_type_len+1];
+        int ret = 0;
-        int i;
-        size_t ret;
-        ret = cnt;
-        if (cnt > max_tracer_type_len)
-                cnt = max_tracer_type_len;
-        if (copy_from_user(&buf, ubuf, cnt))
-                return -EFAULT;
-        buf[cnt] = 0;
-        /* strip ending whitespace. */
-        for (i = cnt - 1; i > 0 && isspace(buf[i]); i--)
-                buf[i] = 0;
        mutex_lock(&trace_types_lock);
        for (t = trace_types; t; t = t->next) {
@@ -2413,18 +2722,52 @@ tracing_set_trace_write(struct file *filp, const char __user *ubuf,
        if (t == current_trace)
                goto out;
+        trace_branch_disable();
        if (current_trace && current_trace->reset)
                current_trace->reset(tr);
        current_trace = t;
-        if (t->init)
+        if (t->init) {
-                t->init(tr);
+                ret = t->init(tr);
+                if (ret)
+                        goto out;
+        }
+        trace_branch_enable(tr);
 out:
        mutex_unlock(&trace_types_lock);
-        if (ret > 0)
+        return ret;
-                filp->f_pos += ret;
+}
+static ssize_t
+tracing_set_trace_write(struct file *filp, const char __user *ubuf,
+                        size_t cnt, loff_t *ppos)
+{
+        char buf[max_tracer_type_len+1];
+        int i;
+        size_t ret;
+        int err;
+        ret = cnt;
+        if (cnt > max_tracer_type_len)
+                cnt = max_tracer_type_len;
+        if (copy_from_user(&buf, ubuf, cnt))
+                return -EFAULT;
+        buf[cnt] = 0;
+        /* strip ending whitespace. */
+        for (i = cnt - 1; i > 0 && isspace(buf[i]); i--)
+                buf[i] = 0;
+        err = tracing_set_tracer(buf);
+        if (err)
+                return err;
+        filp->f_pos += ret;
        return ret;
 }
@@ -2491,6 +2834,10 @@ static int tracing_open_pipe(struct inode *inode, struct file *filp)
                return -ENOMEM;
        mutex_lock(&trace_types_lock);
+        /* trace pipe does not show start of buffer */
+        cpus_setall(iter->started);
        iter->tr = &global_trace;
        iter->trace = current_trace;
        filp->private_data = iter;
@@ -2666,7 +3013,7 @@ tracing_entries_read(struct file *filp, char __user *ubuf,
        char buf[64];
        int r;
-        r = sprintf(buf, "%lu\n", tr->entries);
+        r = sprintf(buf, "%lu\n", tr->entries >> 10);
        return simple_read_from_buffer(ubuf, cnt, ppos, buf, r);
 }
@@ -2677,7 +3024,6 @@ tracing_entries_write(struct file *filp, const char __user *ubuf,
        unsigned long val;
        char buf[64];
        int ret, cpu;
-        struct trace_array *tr = filp->private_data;
        if (cnt >= sizeof(buf))
                return -EINVAL;
@@ -2697,12 +3043,7 @@ tracing_entries_write(struct file *filp, const char __user *ubuf,
        mutex_lock(&trace_types_lock);
-        if (tr->ctrl) {
+        tracing_stop();
-                cnt = -EBUSY;
-                pr_info("ftrace: please disable tracing"
-                        " before modifying buffer size\n");
-                goto out;
-        }
        /* disable all cpu buffers */
        for_each_tracing_cpu(cpu) {
@@ -2712,6 +3053,9 @@ tracing_entries_write(struct file *filp, const char __user *ubuf,
                        atomic_inc(&max_tr.data[cpu]->disabled);
        }
+        /* value is in KB */
+        val <<= 10;
        if (val != global_trace.entries) {
                ret = ring_buffer_resize(global_trace.buffer, val);
                if (ret < 0) {
@@ -2750,6 +3094,7 @@ tracing_entries_write(struct file *filp, const char __user *ubuf,
                        atomic_dec(&max_tr.data[cpu]->disabled);
        }
+        tracing_start();
        max_tr.entries = global_trace.entries;
        mutex_unlock(&trace_types_lock);
@@ -2772,9 +3117,8 @@ tracing_mark_write(struct file *filp, const char __user *ubuf,
 {
        char *buf;
        char *end;
-        struct trace_array *tr = &global_trace;
-        if (!tr->ctrl || tracing_disabled)
+        if (tracing_disabled)
                return -EINVAL;
        if (cnt > TRACE_BUF_SIZE)
@@ -2840,22 +3184,38 @@ static struct file_operations tracing_mark_fops = {
 #ifdef CONFIG_DYNAMIC_FTRACE
+int __weak ftrace_arch_read_dyn_info(char *buf, int size)
+{
+        return 0;
+}
 static ssize_t
-tracing_read_long(struct file *filp, char __user *ubuf,
+tracing_read_dyn_info(struct file *filp, char __user *ubuf,
                  size_t cnt, loff_t *ppos)
 {
+        static char ftrace_dyn_info_buffer[1024];
+        static DEFINE_MUTEX(dyn_info_mutex);
        unsigned long *p = filp->private_data;
-        char buf[64];
+        char *buf = ftrace_dyn_info_buffer;
+        int size = ARRAY_SIZE(ftrace_dyn_info_buffer);
        int r;
-        r = sprintf(buf, "%ld\n", *p);
+        mutex_lock(&dyn_info_mutex);
+        r = sprintf(buf, "%ld ", *p);
-        return simple_read_from_buffer(ubuf, cnt, ppos, buf, r);
+        r += ftrace_arch_read_dyn_info(buf+r, (size-1)-r);
+        buf[r++] = '\n';
+        r = simple_read_from_buffer(ubuf, cnt, ppos, buf, r);
+        mutex_unlock(&dyn_info_mutex);
+        return r;
 }
-static struct file_operations tracing_read_long_fops = {
+static struct file_operations tracing_dyn_info_fops = {
        .open           = tracing_open_generic,
-        .read           = tracing_read_long,
+        .read           = tracing_read_dyn_info,
 };
 #endif
@@ -2896,10 +3256,10 @@ static __init int tracer_init_debugfs(void)
        if (!entry)
                pr_warning("Could not create debugfs 'tracing_enabled' entry\n");
-        entry = debugfs_create_file("iter_ctrl", 0644, d_tracer,
+        entry = debugfs_create_file("trace_options", 0644, d_tracer,
                                    NULL, &tracing_iter_fops);
        if (!entry)
-                pr_warning("Could not create debugfs 'iter_ctrl' entry\n");
+                pr_warning("Could not create debugfs 'trace_options' entry\n");
        entry = debugfs_create_file("tracing_cpumask", 0644, d_tracer,
                                    NULL, &tracing_cpumask_fops);
@@ -2949,11 +3309,11 @@ static __init int tracer_init_debugfs(void)
                pr_warning("Could not create debugfs "
                           "'trace_pipe' entry\n");
-        entry = debugfs_create_file("trace_entries", 0644, d_tracer,
+        entry = debugfs_create_file("buffer_size_kb", 0644, d_tracer,
                                    &global_trace, &tracing_entries_fops);
        if (!entry)
                pr_warning("Could not create debugfs "
-                           "'trace_entries' entry\n");
+                           "'buffer_size_kb' entry\n");
        entry = debugfs_create_file("trace_marker", 0220, d_tracer,
                                    NULL, &tracing_mark_fops);
@@ -2964,7 +3324,7 @@ static __init int tracer_init_debugfs(void)
 #ifdef CONFIG_DYNAMIC_FTRACE
        entry = debugfs_create_file("dyn_ftrace_total_info", 0444, d_tracer,
                                    &ftrace_update_tot_cnt,
-                                    &tracing_read_long_fops);
+                                    &tracing_dyn_info_fops);
        if (!entry)
                pr_warning("Could not create debugfs "
                           "'dyn_ftrace_total_info' entry\n");
@@ -2987,7 +3347,7 @@ int trace_vprintk(unsigned long ip, const char *fmt, va_list args)
        unsigned long flags, irq_flags;
        int cpu, len = 0, size, pc;
-        if (!tr->ctrl || tracing_disabled)
+        if (tracing_disabled)
                return 0;
        pc = preempt_count();
@@ -3045,7 +3405,8 @@ EXPORT_SYMBOL_GPL(__ftrace_printk);
 static int trace_panic_handler(struct notifier_block *this,
                               unsigned long event, void *unused)
 {
-        ftrace_dump();
+        if (ftrace_dump_on_oops)
+                ftrace_dump();
        return NOTIFY_OK;
 }
@@ -3061,7 +3422,8 @@ static int trace_die_handler(struct notifier_block *self,
 {
        switch (val) {
        case DIE_OOPS:
-                ftrace_dump();
+                if (ftrace_dump_on_oops)
+                        ftrace_dump();
                break;
        default:
                break;
@@ -3102,7 +3464,6 @@ trace_printk_seq(struct trace_seq *s)
        trace_seq_reset(s);
 }
 void ftrace_dump(void)
 {
        static DEFINE_SPINLOCK(ftrace_dump_lock);
@@ -3220,7 +3581,6 @@ __init static int tracer_alloc_buffers(void)
 #endif
        /* All seems OK, enable tracing */
-        global_trace.ctrl = tracer_enabled;
        tracing_disabled = 0;
        atomic_notifier_chain_register(&panic_notifier_list,
diff --git a/kernel/trace/trace.h b/kernel/trace/trace.h
index 8465ad052707..2cb12fd98f6b 100644
--- a/kernel/trace/trace.h
+++ b/kernel/trace/trace.h
@@ -8,6 +8,7 @@
 #include <linux/ring_buffer.h>
 #include <linux/mmiotrace.h>
 #include <linux/ftrace.h>
+#include <trace/boot.h>
 enum trace_type {
        __TRACE_FIRST_TYPE = 0,
@@ -21,7 +22,10 @@ enum trace_type {
        TRACE_SPECIAL,
        TRACE_MMIO_RW,
        TRACE_MMIO_MAP,
-        TRACE_BOOT,
+        TRACE_BRANCH,
+        TRACE_BOOT_CALL,
+        TRACE_BOOT_RET,
+        TRACE_FN_RET,
        __TRACE_LAST_TYPE
 };
@@ -48,6 +52,16 @@ struct ftrace_entry {
        unsigned long           ip;
        unsigned long           parent_ip;
 };
+/* Function return entry */
+struct ftrace_ret_entry {
+        struct trace_entry      ent;
+        unsigned long           ip;
+        unsigned long           parent_ip;
+        unsigned long long      calltime;
+        unsigned long long      rettime;
+        unsigned long           overrun;
+};
 extern struct tracer boot_tracer;
 /*
@@ -112,9 +126,24 @@ struct trace_mmiotrace_map {
        struct mmiotrace_map    map;
 };
-struct trace_boot {
+struct trace_boot_call {
        struct trace_entry      ent;
-        struct boot_trace       initcall;
+        struct boot_trace_call boot_call;
+};
+struct trace_boot_ret {
+        struct trace_entry      ent;
+        struct boot_trace_ret boot_ret;
+};
+#define TRACE_FUNC_SIZE 30
+#define TRACE_FILE_SIZE 20
+struct trace_branch {
+        struct trace_entry      ent;
+        unsigned                line;
+        char                    func[TRACE_FUNC_SIZE+1];
+        char                    file[TRACE_FILE_SIZE+1];
+        char                    correct;
 };
 /*
@@ -172,7 +201,6 @@ struct trace_iterator;
 struct trace_array {
        struct ring_buffer      *buffer;
        unsigned long           entries;
-        long                    ctrl;
        int                     cpu;
        cycle_t                 time_start;
        struct task_struct      *waiter;
@@ -218,7 +246,10 @@ extern void __ftrace_bad_type(void);
                          TRACE_MMIO_RW);                               \
                IF_ASSIGN(var, ent, struct trace_mmiotrace_map,         \
                          TRACE_MMIO_MAP);                              \
-                IF_ASSIGN(var, ent, struct trace_boot, TRACE_BOOT);     \
+                IF_ASSIGN(var, ent, struct trace_boot_call, TRACE_BOOT_CALL);\
+                IF_ASSIGN(var, ent, struct trace_boot_ret, TRACE_BOOT_RET);\
+                IF_ASSIGN(var, ent, struct trace_branch, TRACE_BRANCH); \
+                IF_ASSIGN(var, ent, struct ftrace_ret_entry, TRACE_FN_RET);\
                __ftrace_bad_type();                                    \
        } while (0)
@@ -229,29 +260,55 @@ enum print_line_t {
        TRACE_TYPE_UNHANDLED    = 2     /* Relay to other output functions */
 };
+/*
+ * An option specific to a tracer. This is a boolean value.
+ * The bit is the bit index that sets its value on the
+ * flags value in struct tracer_flags.
+ */
+struct tracer_opt {
+        const char      *name; /* Will appear on the trace_options file */
+        u32             bit; /* Mask assigned in val field in tracer_flags */
+};
+/*
+ * The set of specific options for a tracer. Your tracer
+ * have to set the initial value of the flags val.
+ */
+struct tracer_flags {
+        u32                     val;
+        struct tracer_opt       *opts;
+};
+/* Makes more easy to define a tracer opt */
+#define TRACER_OPT(s, b)        .name = #s, .bit = b
 /*
 * A specific tracer, represented by methods that operate on a trace array:
 */
 struct tracer {
        const char              *name;
-        void                    (*init)(struct trace_array *tr);
+        /* Your tracer should raise a warning if init fails */
+        int                     (*init)(struct trace_array *tr);
        void                    (*reset)(struct trace_array *tr);
+        void                    (*start)(struct trace_array *tr);
+        void                    (*stop)(struct trace_array *tr);
        void                    (*open)(struct trace_iterator *iter);
        void                    (*pipe_open)(struct trace_iterator *iter);
        void                    (*close)(struct trace_iterator *iter);
-        void                    (*start)(struct trace_iterator *iter);
-        void                    (*stop)(struct trace_iterator *iter);
        ssize_t                 (*read)(struct trace_iterator *iter,
                                        struct file *filp, char __user *ubuf,
                                        size_t cnt, loff_t *ppos);
-        void                    (*ctrl_update)(struct trace_array *tr);
 #ifdef CONFIG_FTRACE_STARTUP_TEST
        int                     (*selftest)(struct tracer *trace,
                                            struct trace_array *tr);
 #endif
        enum print_line_t       (*print_line)(struct trace_iterator *iter);
+        /* If you handled the flag setting, return 0 */
+        int                     (*set_flag)(u32 old_flags, u32 bit, int set);
        struct tracer           *next;
        int                     print_max;
+        struct tracer_flags     *flags;
 };
 struct trace_seq {
@@ -279,8 +336,11 @@ struct trace_iterator {
        unsigned long           iter_flags;
        loff_t                  pos;
        long                    idx;
+        cpumask_t               started;
 };
+int tracing_is_enabled(void);
 void trace_wake_up(void);
 void tracing_reset(struct trace_array *tr, int cpu);
 int tracing_open_generic(struct inode *inode, struct file *filp);
@@ -320,9 +380,14 @@ void trace_function(struct trace_array *tr,
                    unsigned long ip,
                    unsigned long parent_ip,
                    unsigned long flags, int pc);
+void
+trace_function_return(struct ftrace_retfunc *trace);
 void tracing_start_cmdline_record(void);
 void tracing_stop_cmdline_record(void);
+void tracing_sched_switch_assign_trace(struct trace_array *tr);
+void tracing_stop_sched_switch_record(void);
+void tracing_start_sched_switch_record(void);
 int register_tracer(struct tracer *type);
 void unregister_tracer(struct tracer *type);
@@ -383,12 +448,18 @@ extern int trace_selftest_startup_sched_switch(struct tracer *trace,
                                               struct trace_array *tr);
 extern int trace_selftest_startup_sysprof(struct tracer *trace,
                                               struct trace_array *tr);
+extern int trace_selftest_startup_branch(struct tracer *trace,
+                                         struct trace_array *tr);
 #endif /* CONFIG_FTRACE_STARTUP_TEST */
 extern void *head_page(struct trace_array_cpu *data);
 extern int trace_seq_printf(struct trace_seq *s, const char *fmt, ...);
 extern void trace_seq_print_cont(struct trace_seq *s,
                                 struct trace_iterator *iter);
+extern int
+seq_print_ip_sym(struct trace_seq *s, unsigned long ip,
+                unsigned long sym_flags);
 extern ssize_t trace_seq_to_user(struct trace_seq *s, char __user *ubuf,
                                 size_t cnt);
 extern long ns2usecs(cycle_t nsec);
@@ -396,6 +467,17 @@ extern int trace_vprintk(unsigned long ip, const char *fmt, va_list args);
 extern unsigned long trace_flags;
+/* Standard output formatting function used for function return traces */
+#ifdef CONFIG_FUNCTION_RET_TRACER
+extern enum print_line_t print_return_function(struct trace_iterator *iter);
+#else
+static inline enum print_line_t
+print_return_function(struct trace_iterator *iter)
+{
+        return TRACE_TYPE_UNHANDLED;
+}
+#endif
 /*
 * trace_iterator_flags is an enumeration that defines bit
 * positions into trace_flags that controls the output.
@@ -415,8 +497,90 @@ enum trace_iterator_flags {
        TRACE_ITER_STACKTRACE           = 0x100,
        TRACE_ITER_SCHED_TREE           = 0x200,
        TRACE_ITER_PRINTK               = 0x400,
+        TRACE_ITER_PREEMPTONLY          = 0x800,
+        TRACE_ITER_BRANCH               = 0x1000,
+        TRACE_ITER_ANNOTATE             = 0x2000,
 };
+/*
+ * TRACE_ITER_SYM_MASK masks the options in trace_flags that
+ * control the output of kernel symbols.
+ */
+#define TRACE_ITER_SYM_MASK \
+        (TRACE_ITER_PRINT_PARENT|TRACE_ITER_SYM_OFFSET|TRACE_ITER_SYM_ADDR)
 extern struct tracer nop_trace;
+/**
+ * ftrace_preempt_disable - disable preemption scheduler safe
+ *
+ * When tracing can happen inside the scheduler, there exists
+ * cases that the tracing might happen before the need_resched
+ * flag is checked. If this happens and the tracer calls
+ * preempt_enable (after a disable), a schedule might take place
+ * causing an infinite recursion.
+ *
+ * To prevent this, we read the need_recshed flag before
+ * disabling preemption. When we want to enable preemption we
+ * check the flag, if it is set, then we call preempt_enable_no_resched.
+ * Otherwise, we call preempt_enable.
+ *
+ * The rational for doing the above is that if need resched is set
+ * and we have yet to reschedule, we are either in an atomic location
+ * (where we do not need to check for scheduling) or we are inside
+ * the scheduler and do not want to resched.
+ */
+static inline int ftrace_preempt_disable(void)
+{
+        int resched;
+        resched = need_resched();
+        preempt_disable_notrace();
+        return resched;
+}
+/**
+ * ftrace_preempt_enable - enable preemption scheduler safe
+ * @resched: the return value from ftrace_preempt_disable
+ *
+ * This is a scheduler safe way to enable preemption and not miss
+ * any preemption checks. The disabled saved the state of preemption.
+ * If resched is set, then we were either inside an atomic or
+ * are inside the scheduler (we would have already scheduled
+ * otherwise). In this case, we do not want to call normal
+ * preempt_enable, but preempt_enable_no_resched instead.
+ */
+static inline void ftrace_preempt_enable(int resched)
+{
+        if (resched)
+                preempt_enable_no_resched_notrace();
+        else
+                preempt_enable_notrace();
+}
+#ifdef CONFIG_BRANCH_TRACER
+extern int enable_branch_tracing(struct trace_array *tr);
+extern void disable_branch_tracing(void);
+static inline int trace_branch_enable(struct trace_array *tr)
+{
+        if (trace_flags & TRACE_ITER_BRANCH)
+                return enable_branch_tracing(tr);
+        return 0;
+}
+static inline void trace_branch_disable(void)
+{
+        /* due to races, always disable */
+        disable_branch_tracing();
+}
+#else
+static inline int trace_branch_enable(struct trace_array *tr)
+{
+        return 0;
+}
+static inline void trace_branch_disable(void)
+{
+}
+#endif /* CONFIG_BRANCH_TRACER */
 #endif /* _LINUX_KERNEL_TRACE_H */
diff --git a/kernel/trace/trace_boot.c b/kernel/trace/trace_boot.c
index d0a5e50eeff2..a4fa2c57e34e 100644
--- a/kernel/trace/trace_boot.c
+++ b/kernel/trace/trace_boot.c
@@ -13,73 +13,117 @@
 #include "trace.h"
 static struct trace_array *boot_trace;
-static int trace_boot_enabled;
+static bool pre_initcalls_finished;
+/* Tells the boot tracer that the pre_smp_initcalls are finished.
-/* Should be started after do_pre_smp_initcalls() in init/main.c */
+ * So we are ready .
+ * It doesn't enable sched events tracing however.
+ * You have to call enable_boot_trace to do so.
+ */
 void start_boot_trace(void)
 {
-        trace_boot_enabled = 1;
+        pre_initcalls_finished = true;
 }
-void stop_boot_trace(void)
+void enable_boot_trace(void)
 {
-        trace_boot_enabled = 0;
+        if (pre_initcalls_finished)
+                tracing_start_sched_switch_record();
 }
-void reset_boot_trace(struct trace_array *tr)
+void disable_boot_trace(void)
 {
-        stop_boot_trace();
+        if (pre_initcalls_finished)
+                tracing_stop_sched_switch_record();
 }
-static void boot_trace_init(struct trace_array *tr)
+static void reset_boot_trace(struct trace_array *tr)
 {
        int cpu;
-        boot_trace = tr;
-        trace_boot_enabled = 0;
+        tr->time_start = ftrace_now(tr->cpu);
+        for_each_online_cpu(cpu)
+                tracing_reset(tr, cpu);
+}
+static int boot_trace_init(struct trace_array *tr)
+{
+        int cpu;
+        boot_trace = tr;
        for_each_cpu_mask(cpu, cpu_possible_map)
                tracing_reset(tr, cpu);
+        tracing_sched_switch_assign_trace(tr);
+        return 0;
 }
-static void boot_trace_ctrl_update(struct trace_array *tr)
+static enum print_line_t
+initcall_call_print_line(struct trace_iterator *iter)
 {
-        if (tr->ctrl)
+        struct trace_entry *entry = iter->ent;
-                start_boot_trace();
+        struct trace_seq *s = &iter->seq;
+        struct trace_boot_call *field;
+        struct boot_trace_call *call;
+        u64 ts;
+        unsigned long nsec_rem;
+        int ret;
+        trace_assign_type(field, entry);
+        call = &field->boot_call;
+        ts = iter->ts;
+        nsec_rem = do_div(ts, 1000000000);
+        ret = trace_seq_printf(s, "[%5ld.%09ld] calling  %s @ %i\n",
+                        (unsigned long)ts, nsec_rem, call->func, call->caller);
+        if (!ret)
+                return TRACE_TYPE_PARTIAL_LINE;
        else
-                stop_boot_trace();
+                return TRACE_TYPE_HANDLED;
 }
-static enum print_line_t initcall_print_line(struct trace_iterator *iter)
+static enum print_line_t
+initcall_ret_print_line(struct trace_iterator *iter)
 {
-        int ret;
        struct trace_entry *entry = iter->ent;
-        struct trace_boot *field = (struct trace_boot *)entry;
-        struct boot_trace *it = &field->initcall;
        struct trace_seq *s = &iter->seq;
-        struct timespec calltime = ktime_to_timespec(it->calltime);
+        struct trace_boot_ret *field;
-        struct timespec rettime = ktime_to_timespec(it->rettime);
+        struct boot_trace_ret *init_ret;
+        u64 ts;
-        if (entry->type == TRACE_BOOT) {
+        unsigned long nsec_rem;
-                ret = trace_seq_printf(s, "[%5ld.%09ld] calling  %s @ %i\n",
+        int ret;
-                                          calltime.tv_sec,
-                                          calltime.tv_nsec,
+        trace_assign_type(field, entry);
-                                          it->func, it->caller);
+        init_ret = &field->boot_ret;
-                if (!ret)
+        ts = iter->ts;
-                        return TRACE_TYPE_PARTIAL_LINE;
+        nsec_rem = do_div(ts, 1000000000);
-                ret = trace_seq_printf(s, "[%5ld.%09ld] initcall %s "
+        ret = trace_seq_printf(s, "[%5ld.%09ld] initcall %s "
-                                          "returned %d after %lld msecs\n",
+                        "returned %d after %llu msecs\n",
-                                          rettime.tv_sec,
+                        (unsigned long) ts,
-                                          rettime.tv_nsec,
+                        nsec_rem,
-                                          it->func, it->result, it->duration);
+                        init_ret->func, init_ret->result, init_ret->duration);
-                if (!ret)
+        if (!ret)
-                        return TRACE_TYPE_PARTIAL_LINE;
+                return TRACE_TYPE_PARTIAL_LINE;
+        else
                return TRACE_TYPE_HANDLED;
+}
+static enum print_line_t initcall_print_line(struct trace_iterator *iter)
+{
+        struct trace_entry *entry = iter->ent;
+        switch (entry->type) {
+        case TRACE_BOOT_CALL:
+                return initcall_call_print_line(iter);
+        case TRACE_BOOT_RET:
+                return initcall_ret_print_line(iter);
+        default:
+                return TRACE_TYPE_UNHANDLED;
        }
-        return TRACE_TYPE_UNHANDLED;
 }
 struct tracer boot_tracer __read_mostly =
@@ -87,27 +131,53 @@ struct tracer boot_tracer __read_mostly =
        .name           = "initcall",
        .init           = boot_trace_init,
        .reset          = reset_boot_trace,
-        .ctrl_update    = boot_trace_ctrl_update,
        .print_line     = initcall_print_line,
 };
-void trace_boot(struct boot_trace *it, initcall_t fn)
+void trace_boot_call(struct boot_trace_call *bt, initcall_t fn)
 {
        struct ring_buffer_event *event;
-        struct trace_boot *entry;
+        struct trace_boot_call *entry;
-        struct trace_array_cpu *data;
        unsigned long irq_flags;
        struct trace_array *tr = boot_trace;
-        if (!trace_boot_enabled)
+        if (!pre_initcalls_finished)
                return;
        /* Get its name now since this function could
         * disappear because it is in the .init section.
         */
-        sprint_symbol(it->func, (unsigned long)fn);
+        sprint_symbol(bt->func, (unsigned long)fn);
+        preempt_disable();
+        event = ring_buffer_lock_reserve(tr->buffer, sizeof(*entry),
+                                         &irq_flags);
+        if (!event)
+                goto out;
+        entry   = ring_buffer_event_data(event);
+        tracing_generic_entry_update(&entry->ent, 0, 0);
+        entry->ent.type = TRACE_BOOT_CALL;
+        entry->boot_call = *bt;
+        ring_buffer_unlock_commit(tr->buffer, event, irq_flags);
+        trace_wake_up();
+ out:
+        preempt_enable();
+}
+void trace_boot_ret(struct boot_trace_ret *bt, initcall_t fn)
+{
+        struct ring_buffer_event *event;
+        struct trace_boot_ret *entry;
+        unsigned long irq_flags;
+        struct trace_array *tr = boot_trace;
+        if (!pre_initcalls_finished)
+                return;
+        sprint_symbol(bt->func, (unsigned long)fn);
        preempt_disable();
-        data = tr->data[smp_processor_id()];
        event = ring_buffer_lock_reserve(tr->buffer, sizeof(*entry),
                                         &irq_flags);
@@ -115,8 +185,8 @@ void trace_boot(struct boot_trace *it, initcall_t fn)
                goto out;
        entry   = ring_buffer_event_data(event);
        tracing_generic_entry_update(&entry->ent, 0, 0);
-        entry->ent.type = TRACE_BOOT;
+        entry->ent.type = TRACE_BOOT_RET;
-        entry->initcall = *it;
+        entry->boot_ret = *bt;
        ring_buffer_unlock_commit(tr->buffer, event, irq_flags);
        trace_wake_up();
diff --git a/kernel/trace/trace_branch.c b/kernel/trace/trace_branch.c
new file mode 100644
index 000000000000..23f9b02ce967
--- /dev/null
+++ b/kernel/trace/trace_branch.c
@@ -0,0 +1,321 @@
+/*
+ * unlikely profiler
+ *
+ * Copyright (C) 2008 Steven Rostedt <srostedt@redhat.com>
+ */
+#include <linux/kallsyms.h>
+#include <linux/seq_file.h>
+#include <linux/spinlock.h>
+#include <linux/debugfs.h>
+#include <linux/uaccess.h>
+#include <linux/module.h>
+#include <linux/ftrace.h>
+#include <linux/hash.h>
+#include <linux/fs.h>
+#include <asm/local.h>
+#include "trace.h"
+#ifdef CONFIG_BRANCH_TRACER
+static int branch_tracing_enabled __read_mostly;
+static DEFINE_MUTEX(branch_tracing_mutex);
+static struct trace_array *branch_tracer;
+static void
+probe_likely_condition(struct ftrace_branch_data *f, int val, int expect)
+{
+        struct trace_array *tr = branch_tracer;
+        struct ring_buffer_event *event;
+        struct trace_branch *entry;
+        unsigned long flags, irq_flags;
+        int cpu, pc;
+        const char *p;
+        /*
+         * I would love to save just the ftrace_likely_data pointer, but
+         * this code can also be used by modules. Ugly things can happen
+         * if the module is unloaded, and then we go and read the
+         * pointer.  This is slower, but much safer.
+         */
+        if (unlikely(!tr))
+                return;
+        raw_local_irq_save(flags);
+        cpu = raw_smp_processor_id();
+        if (atomic_inc_return(&tr->data[cpu]->disabled) != 1)
+                goto out;
+        event = ring_buffer_lock_reserve(tr->buffer, sizeof(*entry),
+                                         &irq_flags);
+        if (!event)
+                goto out;
+        pc = preempt_count();
+        entry   = ring_buffer_event_data(event);
+        tracing_generic_entry_update(&entry->ent, flags, pc);
+        entry->ent.type         = TRACE_BRANCH;
+        /* Strip off the path, only save the file */
+        p = f->file + strlen(f->file);
+        while (p >= f->file && *p != '/')
+                p--;
+        p++;
+        strncpy(entry->func, f->func, TRACE_FUNC_SIZE);
+        strncpy(entry->file, p, TRACE_FILE_SIZE);
+        entry->func[TRACE_FUNC_SIZE] = 0;
+        entry->file[TRACE_FILE_SIZE] = 0;
+        entry->line = f->line;
+        entry->correct = val == expect;
+        ring_buffer_unlock_commit(tr->buffer, event, irq_flags);
+ out:
+        atomic_dec(&tr->data[cpu]->disabled);
+        raw_local_irq_restore(flags);
+}
+static inline
+void trace_likely_condition(struct ftrace_branch_data *f, int val, int expect)
+{
+        if (!branch_tracing_enabled)
+                return;
+        probe_likely_condition(f, val, expect);
+}
+int enable_branch_tracing(struct trace_array *tr)
+{
+        int ret = 0;
+        mutex_lock(&branch_tracing_mutex);
+        branch_tracer = tr;
+        /*
+         * Must be seen before enabling. The reader is a condition
+         * where we do not need a matching rmb()
+         */
+        smp_wmb();
+        branch_tracing_enabled++;
+        mutex_unlock(&branch_tracing_mutex);
+        return ret;
+}
+void disable_branch_tracing(void)
+{
+        mutex_lock(&branch_tracing_mutex);
+        if (!branch_tracing_enabled)
+                goto out_unlock;
+        branch_tracing_enabled--;
+ out_unlock:
+        mutex_unlock(&branch_tracing_mutex);
+}
+static void start_branch_trace(struct trace_array *tr)
+{
+        enable_branch_tracing(tr);
+}
+static void stop_branch_trace(struct trace_array *tr)
+{
+        disable_branch_tracing();
+}
+static int branch_trace_init(struct trace_array *tr)
+{
+        int cpu;
+        for_each_online_cpu(cpu)
+                tracing_reset(tr, cpu);
+        start_branch_trace(tr);
+        return 0;
+}
+static void branch_trace_reset(struct trace_array *tr)
+{
+        stop_branch_trace(tr);
+}
+struct tracer branch_trace __read_mostly =
+{
+        .name           = "branch",
+        .init           = branch_trace_init,
+        .reset          = branch_trace_reset,
+#ifdef CONFIG_FTRACE_SELFTEST
+        .selftest       = trace_selftest_startup_branch,
+#endif
+};
+__init static int init_branch_trace(void)
+{
+        return register_tracer(&branch_trace);
+}
+device_initcall(init_branch_trace);
+#else
+static inline
+void trace_likely_condition(struct ftrace_branch_data *f, int val, int expect)
+{
+}
+#endif /* CONFIG_BRANCH_TRACER */
+void ftrace_likely_update(struct ftrace_branch_data *f, int val, int expect)
+{
+        /*
+         * I would love to have a trace point here instead, but the
+         * trace point code is so inundated with unlikely and likely
+         * conditions that the recursive nightmare that exists is too
+         * much to try to get working. At least for now.
+         */
+        trace_likely_condition(f, val, expect);
+        /* FIXME: Make this atomic! */
+        if (val == expect)
+                f->correct++;
+        else
+                f->incorrect++;
+}
+EXPORT_SYMBOL(ftrace_likely_update);
+struct ftrace_pointer {
+        void            *start;
+        void            *stop;
+};
+static void *
+t_next(struct seq_file *m, void *v, loff_t *pos)
+{
+        struct ftrace_pointer *f = m->private;
+        struct ftrace_branch_data *p = v;
+        (*pos)++;
+        if (v == (void *)1)
+                return f->start;
+        ++p;
+        if ((void *)p >= (void *)f->stop)
+                return NULL;
+        return p;
+}
+static void *t_start(struct seq_file *m, loff_t *pos)
+{
+        void *t = (void *)1;
+        loff_t l = 0;
+        for (; t && l < *pos; t = t_next(m, t, &l))
+                ;
+        return t;
+}
+static void t_stop(struct seq_file *m, void *p)
+{
+}
+static int t_show(struct seq_file *m, void *v)
+{
+        struct ftrace_branch_data *p = v;
+        const char *f;
+        unsigned long percent;
+        if (v == (void *)1) {
+                seq_printf(m, " correct incorrect  %% "
+                              "       Function                "
+                              "  File              Line\n"
+                              " ------- ---------  - "
+                              "       --------                "
+                              "  ----              ----\n");
+                return 0;
+        }
+        /* Only print the file, not the path */
+        f = p->file + strlen(p->file);
+        while (f >= p->file && *f != '/')
+                f--;
+        f++;
+        if (p->correct) {
+                percent = p->incorrect * 100;
+                percent /= p->correct + p->incorrect;
+        } else
+                percent = p->incorrect ? 100 : 0;
+        seq_printf(m, "%8lu %8lu %3lu ", p->correct, p->incorrect, percent);
+        seq_printf(m, "%-30.30s %-20.20s %d\n", p->func, f, p->line);
+        return 0;
+}
+static struct seq_operations tracing_likely_seq_ops = {
+        .start          = t_start,
+        .next           = t_next,
+        .stop           = t_stop,
+        .show           = t_show,
+};
+static int tracing_likely_open(struct inode *inode, struct file *file)
+{
+        int ret;
+        ret = seq_open(file, &tracing_likely_seq_ops);
+        if (!ret) {
+                struct seq_file *m = file->private_data;
+                m->private = (void *)inode->i_private;
+        }
+        return ret;
+}
+static struct file_operations tracing_likely_fops = {
+        .open           = tracing_likely_open,
+        .read           = seq_read,
+        .llseek         = seq_lseek,
+};
+extern unsigned long __start_likely_profile[];
+extern unsigned long __stop_likely_profile[];
+extern unsigned long __start_unlikely_profile[];
+extern unsigned long __stop_unlikely_profile[];
+static struct ftrace_pointer ftrace_likely_pos = {
+        .start                  = __start_likely_profile,
+        .stop                   = __stop_likely_profile,
+};
+static struct ftrace_pointer ftrace_unlikely_pos = {
+        .start                  = __start_unlikely_profile,
+        .stop                   = __stop_unlikely_profile,
+};
+static __init int ftrace_branch_init(void)
+{
+        struct dentry *d_tracer;
+        struct dentry *entry;
+        d_tracer = tracing_init_dentry();
+        entry = debugfs_create_file("profile_likely", 0444, d_tracer,
+                                    &ftrace_likely_pos,
+                                    &tracing_likely_fops);
+        if (!entry)
+                pr_warning("Could not create debugfs 'profile_likely' entry\n");
+        entry = debugfs_create_file("profile_unlikely", 0444, d_tracer,
+                                    &ftrace_unlikely_pos,
+                                    &tracing_likely_fops);
+        if (!entry)
+                pr_warning("Could not create debugfs"
+                           " 'profile_unlikely' entry\n");
+        return 0;
+}
+device_initcall(ftrace_branch_init);
diff --git a/kernel/trace/trace_functions.c b/kernel/trace/trace_functions.c
index 0f85a64003d3..e74f6d0a3216 100644
--- a/kernel/trace/trace_functions.c
+++ b/kernel/trace/trace_functions.c
@@ -42,24 +42,20 @@ static void stop_function_trace(struct trace_array *tr)
        tracing_stop_cmdline_record();
 }
-static void function_trace_init(struct trace_array *tr)
+static int function_trace_init(struct trace_array *tr)
 {
-        if (tr->ctrl)
+        start_function_trace(tr);
-                start_function_trace(tr);
+        return 0;
 }
 static void function_trace_reset(struct trace_array *tr)
 {
-        if (tr->ctrl)
+        stop_function_trace(tr);
-                stop_function_trace(tr);
 }
-static void function_trace_ctrl_update(struct trace_array *tr)
+static void function_trace_start(struct trace_array *tr)
 {
-        if (tr->ctrl)
+        function_reset(tr);
-                start_function_trace(tr);
-        else
-                stop_function_trace(tr);
 }
 static struct tracer function_trace __read_mostly =
@@ -67,7 +63,7 @@ static struct tracer function_trace __read_mostly =
        .name        = "function",
        .init        = function_trace_init,
        .reset       = function_trace_reset,
-        .ctrl_update = function_trace_ctrl_update,
+        .start       = function_trace_start,
 #ifdef CONFIG_FTRACE_SELFTEST
        .selftest    = trace_selftest_startup_function,
 #endif
diff --git a/kernel/trace/trace_functions_return.c b/kernel/trace/trace_functions_return.c
new file mode 100644
index 000000000000..e00d64509c9c
--- /dev/null
+++ b/kernel/trace/trace_functions_return.c
@@ -0,0 +1,98 @@
+/*
+ *
+ * Function return tracer.
+ * Copyright (c) 2008 Frederic Weisbecker <fweisbec@gmail.com>
+ * Mostly borrowed from function tracer which
+ * is Copyright (c) Steven Rostedt <srostedt@redhat.com>
+ *
+ */
+#include <linux/debugfs.h>
+#include <linux/uaccess.h>
+#include <linux/ftrace.h>
+#include <linux/fs.h>
+#include "trace.h"
+#define TRACE_RETURN_PRINT_OVERRUN      0x1
+static struct tracer_opt trace_opts[] = {
+        /* Display overruns or not */
+        { TRACER_OPT(overrun, TRACE_RETURN_PRINT_OVERRUN) },
+        { } /* Empty entry */
+};
+static struct tracer_flags tracer_flags = {
+        .val = 0, /* Don't display overruns by default */
+        .opts = trace_opts
+};
+static int return_trace_init(struct trace_array *tr)
+{
+        int cpu;
+        for_each_online_cpu(cpu)
+                tracing_reset(tr, cpu);
+        return register_ftrace_return(&trace_function_return);
+}
+static void return_trace_reset(struct trace_array *tr)
+{
+                unregister_ftrace_return();
+}
+enum print_line_t
+print_return_function(struct trace_iterator *iter)
+{
+        struct trace_seq *s = &iter->seq;
+        struct trace_entry *entry = iter->ent;
+        struct ftrace_ret_entry *field;
+        int ret;
+        if (entry->type == TRACE_FN_RET) {
+                trace_assign_type(field, entry);
+                ret = trace_seq_printf(s, "%pF -> ", (void *)field->parent_ip);
+                if (!ret)
+                        return TRACE_TYPE_PARTIAL_LINE;
+                ret = seq_print_ip_sym(s, field->ip,
+                                        trace_flags & TRACE_ITER_SYM_MASK);
+                if (!ret)
+                        return TRACE_TYPE_PARTIAL_LINE;
+                ret = trace_seq_printf(s, " (%llu ns)",
+                                        field->rettime - field->calltime);
+                if (!ret)
+                        return TRACE_TYPE_PARTIAL_LINE;
+                if (tracer_flags.val & TRACE_RETURN_PRINT_OVERRUN) {
+                        ret = trace_seq_printf(s, " (Overruns: %lu)",
+                                                field->overrun);
+                        if (!ret)
+                                return TRACE_TYPE_PARTIAL_LINE;
+                }
+                ret = trace_seq_printf(s, "\n");
+                if (!ret)
+                        return TRACE_TYPE_PARTIAL_LINE;
+                return TRACE_TYPE_HANDLED;
+        }
+        return TRACE_TYPE_UNHANDLED;
+}
+static struct tracer return_trace __read_mostly = {
+        .name        = "return",
+        .init        = return_trace_init,
+        .reset       = return_trace_reset,
+        .print_line = print_return_function,
+        .flags          = &tracer_flags,
+};
+static __init int init_return_trace(void)
+{
+        return register_tracer(&return_trace);
+}
+device_initcall(init_return_trace);
diff --git a/kernel/trace/trace_irqsoff.c b/kernel/trace/trace_irqsoff.c
index 9c74071c10e0..7c2e326bbc8b 100644
--- a/kernel/trace/trace_irqsoff.c
+++ b/kernel/trace/trace_irqsoff.c
@@ -353,15 +353,28 @@ void trace_preempt_off(unsigned long a0, unsigned long a1)
 }
 #endif /* CONFIG_PREEMPT_TRACER */
+/*
+ * save_tracer_enabled is used to save the state of the tracer_enabled
+ * variable when we disable it when we open a trace output file.
+ */
+static int save_tracer_enabled;
 static void start_irqsoff_tracer(struct trace_array *tr)
 {
        register_ftrace_function(&trace_ops);
-        tracer_enabled = 1;
+        if (tracing_is_enabled()) {
+                tracer_enabled = 1;
+                save_tracer_enabled = 1;
+        } else {
+                tracer_enabled = 0;
+                save_tracer_enabled = 0;
+        }
 }
 static void stop_irqsoff_tracer(struct trace_array *tr)
 {
        tracer_enabled = 0;
+        save_tracer_enabled = 0;
        unregister_ftrace_function(&trace_ops);
 }
@@ -370,53 +383,55 @@ static void __irqsoff_tracer_init(struct trace_array *tr)
        irqsoff_trace = tr;
        /* make sure that the tracer is visible */
        smp_wmb();
+        start_irqsoff_tracer(tr);
-        if (tr->ctrl)
-                start_irqsoff_tracer(tr);
 }
 static void irqsoff_tracer_reset(struct trace_array *tr)
 {
-        if (tr->ctrl)
+        stop_irqsoff_tracer(tr);
-                stop_irqsoff_tracer(tr);
 }
-static void irqsoff_tracer_ctrl_update(struct trace_array *tr)
+static void irqsoff_tracer_start(struct trace_array *tr)
 {
-        if (tr->ctrl)
+        tracer_enabled = 1;
-                start_irqsoff_tracer(tr);
+        save_tracer_enabled = 1;
-        else
+}
-                stop_irqsoff_tracer(tr);
+static void irqsoff_tracer_stop(struct trace_array *tr)
+{
+        tracer_enabled = 0;
+        save_tracer_enabled = 0;
 }
 static void irqsoff_tracer_open(struct trace_iterator *iter)
 {
        /* stop the trace while dumping */
-        if (iter->tr->ctrl)
+        tracer_enabled = 0;
-                stop_irqsoff_tracer(iter->tr);
 }
 static void irqsoff_tracer_close(struct trace_iterator *iter)
 {
-        if (iter->tr->ctrl)
+        /* restart tracing */
-                start_irqsoff_tracer(iter->tr);
+        tracer_enabled = save_tracer_enabled;
 }
 #ifdef CONFIG_IRQSOFF_TRACER
-static void irqsoff_tracer_init(struct trace_array *tr)
+static int irqsoff_tracer_init(struct trace_array *tr)
 {
        trace_type = TRACER_IRQS_OFF;
        __irqsoff_tracer_init(tr);
+        return 0;
 }
 static struct tracer irqsoff_tracer __read_mostly =
 {
        .name           = "irqsoff",
        .init           = irqsoff_tracer_init,
        .reset          = irqsoff_tracer_reset,
+        .start          = irqsoff_tracer_start,
+        .stop           = irqsoff_tracer_stop,
        .open           = irqsoff_tracer_open,
        .close          = irqsoff_tracer_close,
-        .ctrl_update    = irqsoff_tracer_ctrl_update,
        .print_max      = 1,
 #ifdef CONFIG_FTRACE_SELFTEST
        .selftest    = trace_selftest_startup_irqsoff,
@@ -428,11 +443,12 @@ static struct tracer irqsoff_tracer __read_mostly =
 #endif
 #ifdef CONFIG_PREEMPT_TRACER
-static void preemptoff_tracer_init(struct trace_array *tr)
+static int preemptoff_tracer_init(struct trace_array *tr)
 {
        trace_type = TRACER_PREEMPT_OFF;
        __irqsoff_tracer_init(tr);
+        return 0;
 }
 static struct tracer preemptoff_tracer __read_mostly =
@@ -440,9 +456,10 @@ static struct tracer preemptoff_tracer __read_mostly =
        .name           = "preemptoff",
        .init           = preemptoff_tracer_init,
        .reset          = irqsoff_tracer_reset,
+        .start          = irqsoff_tracer_start,
+        .stop           = irqsoff_tracer_stop,
        .open           = irqsoff_tracer_open,
        .close          = irqsoff_tracer_close,
-        .ctrl_update    = irqsoff_tracer_ctrl_update,
        .print_max      = 1,
 #ifdef CONFIG_FTRACE_SELFTEST
        .selftest    = trace_selftest_startup_preemptoff,
@@ -456,11 +473,12 @@ static struct tracer preemptoff_tracer __read_mostly =
 #if defined(CONFIG_IRQSOFF_TRACER) && \
        defined(CONFIG_PREEMPT_TRACER)
-static void preemptirqsoff_tracer_init(struct trace_array *tr)
+static int preemptirqsoff_tracer_init(struct trace_array *tr)
 {
        trace_type = TRACER_IRQS_OFF | TRACER_PREEMPT_OFF;
        __irqsoff_tracer_init(tr);
+        return 0;
 }
 static struct tracer preemptirqsoff_tracer __read_mostly =
@@ -468,9 +486,10 @@ static struct tracer preemptirqsoff_tracer __read_mostly =
        .name           = "preemptirqsoff",
        .init           = preemptirqsoff_tracer_init,
        .reset          = irqsoff_tracer_reset,
+        .start          = irqsoff_tracer_start,
+        .stop           = irqsoff_tracer_stop,
        .open           = irqsoff_tracer_open,
        .close          = irqsoff_tracer_close,
-        .ctrl_update    = irqsoff_tracer_ctrl_update,
        .print_max      = 1,
 #ifdef CONFIG_FTRACE_SELFTEST
        .selftest    = trace_selftest_startup_preemptirqsoff,
diff --git a/kernel/trace/trace_mmiotrace.c b/kernel/trace/trace_mmiotrace.c
index f28484618ff0..433d650eda9f 100644
--- a/kernel/trace/trace_mmiotrace.c
+++ b/kernel/trace/trace_mmiotrace.c
@@ -30,34 +30,29 @@ static void mmio_reset_data(struct trace_array *tr)
                tracing_reset(tr, cpu);
 }
-static void mmio_trace_init(struct trace_array *tr)
+static int mmio_trace_init(struct trace_array *tr)
 {
        pr_debug("in %s\n", __func__);
        mmio_trace_array = tr;
-        if (tr->ctrl) {
-                mmio_reset_data(tr);
+        mmio_reset_data(tr);
-                enable_mmiotrace();
+        enable_mmiotrace();
-        }
+        return 0;
 }
 static void mmio_trace_reset(struct trace_array *tr)
 {
        pr_debug("in %s\n", __func__);
-        if (tr->ctrl)
-                disable_mmiotrace();
+        disable_mmiotrace();
        mmio_reset_data(tr);
        mmio_trace_array = NULL;
 }
-static void mmio_trace_ctrl_update(struct trace_array *tr)
+static void mmio_trace_start(struct trace_array *tr)
 {
        pr_debug("in %s\n", __func__);
-        if (tr->ctrl) {
+        mmio_reset_data(tr);
-                mmio_reset_data(tr);
-                enable_mmiotrace();
-        } else {
-                disable_mmiotrace();
-        }
 }
 static int mmio_print_pcidev(struct trace_seq *s, const struct pci_dev *dev)
@@ -298,10 +293,10 @@ static struct tracer mmio_tracer __read_mostly =
        .name           = "mmiotrace",
        .init           = mmio_trace_init,
        .reset          = mmio_trace_reset,
+        .start          = mmio_trace_start,
        .pipe_open      = mmio_pipe_open,
        .close          = mmio_close,
        .read           = mmio_read,
-        .ctrl_update    = mmio_trace_ctrl_update,
        .print_line     = mmio_print_line,
 };
diff --git a/kernel/trace/trace_nop.c b/kernel/trace/trace_nop.c
index 4592b4862515..b9767acd30ac 100644
--- a/kernel/trace/trace_nop.c
+++ b/kernel/trace/trace_nop.c
@@ -12,6 +12,27 @@
 #include "trace.h"
+/* Our two options */
+enum {
+        TRACE_NOP_OPT_ACCEPT = 0x1,
+        TRACE_NOP_OPT_REFUSE = 0x2
+};
+/* Options for the tracer (see trace_options file) */
+static struct tracer_opt nop_opts[] = {
+        /* Option that will be accepted by set_flag callback */
+        { TRACER_OPT(test_nop_accept, TRACE_NOP_OPT_ACCEPT) },
+        /* Option that will be refused by set_flag callback */
+        { TRACER_OPT(test_nop_refuse, TRACE_NOP_OPT_REFUSE) },
+        { } /* Always set a last empty entry */
+};
+static struct tracer_flags nop_flags = {
+        /* You can check your flags value here when you want. */
+        .val = 0, /* By default: all flags disabled */
+        .opts = nop_opts
+};
 static struct trace_array       *ctx_trace;
 static void start_nop_trace(struct trace_array *tr)
@@ -24,7 +45,7 @@ static void stop_nop_trace(struct trace_array *tr)
        /* Nothing to do! */
 }
-static void nop_trace_init(struct trace_array *tr)
+static int nop_trace_init(struct trace_array *tr)
 {
        int cpu;
        ctx_trace = tr;
@@ -32,33 +53,53 @@ static void nop_trace_init(struct trace_array *tr)
        for_each_online_cpu(cpu)
                tracing_reset(tr, cpu);
-        if (tr->ctrl)
+        start_nop_trace(tr);
-                start_nop_trace(tr);
+        return 0;
 }
 static void nop_trace_reset(struct trace_array *tr)
 {
-        if (tr->ctrl)
+        stop_nop_trace(tr);
-                stop_nop_trace(tr);
 }
-static void nop_trace_ctrl_update(struct trace_array *tr)
+/* It only serves as a signal handler and a callback to
+ * accept or refuse tthe setting of a flag.
+ * If you don't implement it, then the flag setting will be
+ * automatically accepted.
+ */
+static int nop_set_flag(u32 old_flags, u32 bit, int set)
 {
-        /* When starting a new trace, reset the buffers */
+        /*
-        if (tr->ctrl)
+         * Note that you don't need to update nop_flags.val yourself.
-                start_nop_trace(tr);
+         * The tracing Api will do it automatically if you return 0
-        else
+         */
-                stop_nop_trace(tr);
+        if (bit == TRACE_NOP_OPT_ACCEPT) {
+                printk(KERN_DEBUG "nop_test_accept flag set to %d: we accept."
+                        " Now cat trace_options to see the result\n",
+                        set);
+                return 0;
+        }
+        if (bit == TRACE_NOP_OPT_REFUSE) {
+                printk(KERN_DEBUG "nop_test_refuse flag set to %d: we refuse."
+                        "Now cat trace_options to see the result\n",
+                        set);
+                return -EINVAL;
+        }
+        return 0;
 }
 struct tracer nop_trace __read_mostly =
 {
        .name           = "nop",
        .init           = nop_trace_init,
        .reset          = nop_trace_reset,
-        .ctrl_update    = nop_trace_ctrl_update,
 #ifdef CONFIG_FTRACE_SELFTEST
        .selftest       = trace_selftest_startup_nop,
 #endif
+        .flags          = &nop_flags,
+        .set_flag       = nop_set_flag
 };
diff --git a/kernel/trace/trace_sched_switch.c b/kernel/trace/trace_sched_switch.c
index b8f56beb1a62..863390557b44 100644
--- a/kernel/trace/trace_sched_switch.c
+++ b/kernel/trace/trace_sched_switch.c
@@ -16,7 +16,8 @@
 static struct trace_array       *ctx_trace;
 static int __read_mostly        tracer_enabled;
-static atomic_t                 sched_ref;
+static int                      sched_ref;
+static DEFINE_MUTEX(sched_register_mutex);
 static void
 probe_sched_switch(struct rq *__rq, struct task_struct *prev,
@@ -27,7 +28,7 @@ probe_sched_switch(struct rq *__rq, struct task_struct *prev,
        int cpu;
        int pc;
-        if (!atomic_read(&sched_ref))
+        if (!sched_ref)
                return;
        tracing_record_cmdline(prev);
@@ -123,20 +124,18 @@ static void tracing_sched_unregister(void)
 static void tracing_start_sched_switch(void)
 {
-        long ref;
+        mutex_lock(&sched_register_mutex);
+        if (!(sched_ref++))
-        ref = atomic_inc_return(&sched_ref);
-        if (ref == 1)
                tracing_sched_register();
+        mutex_unlock(&sched_register_mutex);
 }
 static void tracing_stop_sched_switch(void)
 {
-        long ref;
+        mutex_lock(&sched_register_mutex);
+        if (!(--sched_ref))
-        ref = atomic_dec_and_test(&sched_ref);
-        if (ref)
                tracing_sched_unregister();
+        mutex_unlock(&sched_register_mutex);
 }
 void tracing_start_cmdline_record(void)
@@ -149,40 +148,86 @@ void tracing_stop_cmdline_record(void)
        tracing_stop_sched_switch();
 }
+/**
+ * tracing_start_sched_switch_record - start tracing context switches
+ *
+ * Turns on context switch tracing for a tracer.
+ */
+void tracing_start_sched_switch_record(void)
+{
+        if (unlikely(!ctx_trace)) {
+                WARN_ON(1);
+                return;
+        }
+        tracing_start_sched_switch();
+        mutex_lock(&sched_register_mutex);
+        tracer_enabled++;
+        mutex_unlock(&sched_register_mutex);
+}
+/**
+ * tracing_stop_sched_switch_record - start tracing context switches
+ *
+ * Turns off context switch tracing for a tracer.
+ */
+void tracing_stop_sched_switch_record(void)
+{
+        mutex_lock(&sched_register_mutex);
+        tracer_enabled--;
+        WARN_ON(tracer_enabled < 0);
+        mutex_unlock(&sched_register_mutex);
+        tracing_stop_sched_switch();
+}
+/**
+ * tracing_sched_switch_assign_trace - assign a trace array for ctx switch
+ * @tr: trace array pointer to assign
+ *
+ * Some tracers might want to record the context switches in their
+ * trace. This function lets those tracers assign the trace array
+ * to use.
+ */
+void tracing_sched_switch_assign_trace(struct trace_array *tr)
+{
+        ctx_trace = tr;
+}
 static void start_sched_trace(struct trace_array *tr)
 {
        sched_switch_reset(tr);
-        tracing_start_cmdline_record();
+        tracing_start_sched_switch_record();
-        tracer_enabled = 1;
 }
 static void stop_sched_trace(struct trace_array *tr)
 {
-        tracer_enabled = 0;
+        tracing_stop_sched_switch_record();
-        tracing_stop_cmdline_record();
 }
-static void sched_switch_trace_init(struct trace_array *tr)
+static int sched_switch_trace_init(struct trace_array *tr)
 {
        ctx_trace = tr;
+        start_sched_trace(tr);
-        if (tr->ctrl)
+        return 0;
-                start_sched_trace(tr);
 }
 static void sched_switch_trace_reset(struct trace_array *tr)
 {
-        if (tr->ctrl)
+        if (sched_ref)
                stop_sched_trace(tr);
 }
-static void sched_switch_trace_ctrl_update(struct trace_array *tr)
+static void sched_switch_trace_start(struct trace_array *tr)
 {
-        /* When starting a new trace, reset the buffers */
+        sched_switch_reset(tr);
-        if (tr->ctrl)
+        tracing_start_sched_switch();
-                start_sched_trace(tr);
+}
-        else
-                stop_sched_trace(tr);
+static void sched_switch_trace_stop(struct trace_array *tr)
+{
+        tracing_stop_sched_switch();
 }
 static struct tracer sched_switch_trace __read_mostly =
@@ -190,7 +235,8 @@ static struct tracer sched_switch_trace __read_mostly =
        .name           = "sched_switch",
        .init           = sched_switch_trace_init,
        .reset          = sched_switch_trace_reset,
-        .ctrl_update    = sched_switch_trace_ctrl_update,
+        .start          = sched_switch_trace_start,
+        .stop           = sched_switch_trace_stop,
 #ifdef CONFIG_FTRACE_SELFTEST
        .selftest    = trace_selftest_startup_sched_switch,
 #endif
@@ -198,14 +244,6 @@ static struct tracer sched_switch_trace __read_mostly =
 __init static int init_sched_switch_trace(void)
 {
-        int ret = 0;
-        if (atomic_read(&sched_ref))
-                ret = tracing_sched_register();
-        if (ret) {
-                pr_info("error registering scheduler trace\n");
-                return ret;
-        }
        return register_tracer(&sched_switch_trace);
 }
 device_initcall(init_sched_switch_trace);
diff --git a/kernel/trace/trace_sched_wakeup.c b/kernel/trace/trace_sched_wakeup.c
index 3ae93f16b565..0067b49746c1 100644
--- a/kernel/trace/trace_sched_wakeup.c
+++ b/kernel/trace/trace_sched_wakeup.c
@@ -50,8 +50,7 @@ wakeup_tracer_call(unsigned long ip, unsigned long parent_ip)
                return;
        pc = preempt_count();
-        resched = need_resched();
+        resched = ftrace_preempt_disable();
-        preempt_disable_notrace();
        cpu = raw_smp_processor_id();
        data = tr->data[cpu];
@@ -81,15 +80,7 @@ wakeup_tracer_call(unsigned long ip, unsigned long parent_ip)
 out:
        atomic_dec(&data->disabled);
-        /*
+        ftrace_preempt_enable(resched);
-         * To prevent recursion from the scheduler, if the
-         * resched flag was set before we entered, then
-         * don't reschedule.
-         */
-        if (resched)
-                preempt_enable_no_resched_notrace();
-        else
-                preempt_enable_notrace();
 }
 static struct ftrace_ops trace_ops __read_mostly =
@@ -271,6 +262,12 @@ out:
        atomic_dec(&wakeup_trace->data[cpu]->disabled);
 }
+/*
+ * save_tracer_enabled is used to save the state of the tracer_enabled
+ * variable when we disable it when we open a trace output file.
+ */
+static int save_tracer_enabled;
 static void start_wakeup_tracer(struct trace_array *tr)
 {
        int ret;
@@ -309,7 +306,13 @@ static void start_wakeup_tracer(struct trace_array *tr)
        register_ftrace_function(&trace_ops);
-        tracer_enabled = 1;
+        if (tracing_is_enabled()) {
+                tracer_enabled = 1;
+                save_tracer_enabled = 1;
+        } else {
+                tracer_enabled = 0;
+                save_tracer_enabled = 0;
+        }
        return;
 fail_deprobe_wake_new:
@@ -321,49 +324,53 @@ fail_deprobe:
 static void stop_wakeup_tracer(struct trace_array *tr)
 {
        tracer_enabled = 0;
+        save_tracer_enabled = 0;
        unregister_ftrace_function(&trace_ops);
        unregister_trace_sched_switch(probe_wakeup_sched_switch);
        unregister_trace_sched_wakeup_new(probe_wakeup);
        unregister_trace_sched_wakeup(probe_wakeup);
 }
-static void wakeup_tracer_init(struct trace_array *tr)
+static int wakeup_tracer_init(struct trace_array *tr)
 {
        wakeup_trace = tr;
+        start_wakeup_tracer(tr);
-        if (tr->ctrl)
+        return 0;
-                start_wakeup_tracer(tr);
 }
 static void wakeup_tracer_reset(struct trace_array *tr)
 {
-        if (tr->ctrl) {
+        stop_wakeup_tracer(tr);
-                stop_wakeup_tracer(tr);
+        /* make sure we put back any tasks we are tracing */
-                /* make sure we put back any tasks we are tracing */
+        wakeup_reset(tr);
-                wakeup_reset(tr);
+}
-        }
+static void wakeup_tracer_start(struct trace_array *tr)
+{
+        wakeup_reset(tr);
+        tracer_enabled = 1;
+        save_tracer_enabled = 1;
 }
-static void wakeup_tracer_ctrl_update(struct trace_array *tr)
+static void wakeup_tracer_stop(struct trace_array *tr)
 {
-        if (tr->ctrl)
+        tracer_enabled = 0;
-                start_wakeup_tracer(tr);
+        save_tracer_enabled = 0;
-        else
-                stop_wakeup_tracer(tr);
 }
 static void wakeup_tracer_open(struct trace_iterator *iter)
 {
        /* stop the trace while dumping */
-        if (iter->tr->ctrl)
+        tracer_enabled = 0;
-                stop_wakeup_tracer(iter->tr);
 }
 static void wakeup_tracer_close(struct trace_iterator *iter)
 {
        /* forget about any processes we were recording */
-        if (iter->tr->ctrl)
+        if (save_tracer_enabled) {
-                start_wakeup_tracer(iter->tr);
+                wakeup_reset(iter->tr);
+                tracer_enabled = 1;
+        }
 }
 static struct tracer wakeup_tracer __read_mostly =
@@ -371,9 +378,10 @@ static struct tracer wakeup_tracer __read_mostly =
        .name           = "wakeup",
        .init           = wakeup_tracer_init,
        .reset          = wakeup_tracer_reset,
+        .start          = wakeup_tracer_start,
+        .stop           = wakeup_tracer_stop,
        .open           = wakeup_tracer_open,
        .close          = wakeup_tracer_close,
-        .ctrl_update    = wakeup_tracer_ctrl_update,
        .print_max      = 1,
 #ifdef CONFIG_FTRACE_SELFTEST
        .selftest    = trace_selftest_startup_wakeup,
diff --git a/kernel/trace/trace_selftest.c b/kernel/trace/trace_selftest.c
index 90bc752a7580..88c8eb70f54a 100644
--- a/kernel/trace/trace_selftest.c
+++ b/kernel/trace/trace_selftest.c
@@ -13,6 +13,7 @@ static inline int trace_valid_entry(struct trace_entry *entry)
        case TRACE_STACK:
        case TRACE_PRINT:
        case TRACE_SPECIAL:
+        case TRACE_BRANCH:
                return 1;
        }
        return 0;
@@ -51,7 +52,7 @@ static int trace_test_buffer(struct trace_array *tr, unsigned long *count)
        int cpu, ret = 0;
        /* Don't allow flipping of max traces now */
-        raw_local_irq_save(flags);
+        local_irq_save(flags);
        __raw_spin_lock(&ftrace_max_lock);
        cnt = ring_buffer_entries(tr->buffer);
@@ -62,7 +63,7 @@ static int trace_test_buffer(struct trace_array *tr, unsigned long *count)
                        break;
        }
        __raw_spin_unlock(&ftrace_max_lock);
-        raw_local_irq_restore(flags);
+        local_irq_restore(flags);
        if (count)
                *count = cnt;
@@ -70,6 +71,11 @@ static int trace_test_buffer(struct trace_array *tr, unsigned long *count)
        return ret;
 }
+static inline void warn_failed_init_tracer(struct tracer *trace, int init_ret)
+{
+        printk(KERN_WARNING "Failed to init %s tracer, init returned %d\n",
+                trace->name, init_ret);
+}
 #ifdef CONFIG_FUNCTION_TRACER
 #ifdef CONFIG_DYNAMIC_FTRACE
@@ -110,8 +116,11 @@ int trace_selftest_startup_dynamic_tracing(struct tracer *trace,
        ftrace_set_filter(func_name, strlen(func_name), 1);
        /* enable tracing */
-        tr->ctrl = 1;
+        ret = trace->init(tr);
-        trace->init(tr);
+        if (ret) {
+                warn_failed_init_tracer(trace, ret);
+                goto out;
+        }
        /* Sleep for a 1/10 of a second */
        msleep(100);
@@ -134,13 +143,13 @@ int trace_selftest_startup_dynamic_tracing(struct tracer *trace,
        msleep(100);
        /* stop the tracing. */
-        tr->ctrl = 0;
+        tracing_stop();
-        trace->ctrl_update(tr);
        ftrace_enabled = 0;
        /* check the trace buffer */
        ret = trace_test_buffer(tr, &count);
        trace->reset(tr);
+        tracing_start();
        /* we should only have one item */
        if (!ret && count != 1) {
@@ -148,6 +157,7 @@ int trace_selftest_startup_dynamic_tracing(struct tracer *trace,
                ret = -1;
                goto out;
        }
 out:
        ftrace_enabled = save_ftrace_enabled;
        tracer_enabled = save_tracer_enabled;
@@ -180,18 +190,22 @@ trace_selftest_startup_function(struct tracer *trace, struct trace_array *tr)
        ftrace_enabled = 1;
        tracer_enabled = 1;
-        tr->ctrl = 1;
+        ret = trace->init(tr);
-        trace->init(tr);
+        if (ret) {
+                warn_failed_init_tracer(trace, ret);
+                goto out;
+        }
        /* Sleep for a 1/10 of a second */
        msleep(100);
        /* stop the tracing. */
-        tr->ctrl = 0;
+        tracing_stop();
-        trace->ctrl_update(tr);
        ftrace_enabled = 0;
        /* check the trace buffer */
        ret = trace_test_buffer(tr, &count);
        trace->reset(tr);
+        tracing_start();
        if (!ret && !count) {
                printk(KERN_CONT ".. no entries found ..");
@@ -223,8 +237,12 @@ trace_selftest_startup_irqsoff(struct tracer *trace, struct trace_array *tr)
        int ret;
        /* start the tracing */
-        tr->ctrl = 1;
+        ret = trace->init(tr);
-        trace->init(tr);
+        if (ret) {
+                warn_failed_init_tracer(trace, ret);
+                return ret;
+        }
        /* reset the max latency */
        tracing_max_latency = 0;
        /* disable interrupts for a bit */
@@ -232,13 +250,13 @@ trace_selftest_startup_irqsoff(struct tracer *trace, struct trace_array *tr)
        udelay(100);
        local_irq_enable();
        /* stop the tracing. */
-        tr->ctrl = 0;
+        tracing_stop();
-        trace->ctrl_update(tr);
        /* check both trace buffers */
        ret = trace_test_buffer(tr, NULL);
        if (!ret)
                ret = trace_test_buffer(&max_tr, &count);
        trace->reset(tr);
+        tracing_start();
        if (!ret && !count) {
                printk(KERN_CONT ".. no entries found ..");
@@ -259,9 +277,26 @@ trace_selftest_startup_preemptoff(struct tracer *trace, struct trace_array *tr)
        unsigned long count;
        int ret;
+        /*
+         * Now that the big kernel lock is no longer preemptable,
+         * and this is called with the BKL held, it will always
+         * fail. If preemption is already disabled, simply
+         * pass the test. When the BKL is removed, or becomes
+         * preemptible again, we will once again test this,
+         * so keep it in.
+         */
+        if (preempt_count()) {
+                printk(KERN_CONT "can not test ... force ");
+                return 0;
+        }
        /* start the tracing */
-        tr->ctrl = 1;
+        ret = trace->init(tr);
-        trace->init(tr);
+        if (ret) {
+                warn_failed_init_tracer(trace, ret);
+                return ret;
+        }
        /* reset the max latency */
        tracing_max_latency = 0;
        /* disable preemption for a bit */
@@ -269,13 +304,13 @@ trace_selftest_startup_preemptoff(struct tracer *trace, struct trace_array *tr)
        udelay(100);
        preempt_enable();
        /* stop the tracing. */
-        tr->ctrl = 0;
+        tracing_stop();
-        trace->ctrl_update(tr);
        /* check both trace buffers */
        ret = trace_test_buffer(tr, NULL);
        if (!ret)
                ret = trace_test_buffer(&max_tr, &count);
        trace->reset(tr);
+        tracing_start();
        if (!ret && !count) {
                printk(KERN_CONT ".. no entries found ..");
@@ -296,9 +331,25 @@ trace_selftest_startup_preemptirqsoff(struct tracer *trace, struct trace_array *
        unsigned long count;
        int ret;
+        /*
+         * Now that the big kernel lock is no longer preemptable,
+         * and this is called with the BKL held, it will always
+         * fail. If preemption is already disabled, simply
+         * pass the test. When the BKL is removed, or becomes
+         * preemptible again, we will once again test this,
+         * so keep it in.
+         */
+        if (preempt_count()) {
+                printk(KERN_CONT "can not test ... force ");
+                return 0;
+        }
        /* start the tracing */
-        tr->ctrl = 1;
+        ret = trace->init(tr);
-        trace->init(tr);
+        if (ret) {
+                warn_failed_init_tracer(trace, ret);
+                goto out;
+        }
        /* reset the max latency */
        tracing_max_latency = 0;
@@ -312,27 +363,30 @@ trace_selftest_startup_preemptirqsoff(struct tracer *trace, struct trace_array *
        local_irq_enable();
        /* stop the tracing. */
-        tr->ctrl = 0;
+        tracing_stop();
-        trace->ctrl_update(tr);
        /* check both trace buffers */
        ret = trace_test_buffer(tr, NULL);
-        if (ret)
+        if (ret) {
+                tracing_start();
                goto out;
+        }
        ret = trace_test_buffer(&max_tr, &count);
-        if (ret)
+        if (ret) {
+                tracing_start();
                goto out;
+        }
        if (!ret && !count) {
                printk(KERN_CONT ".. no entries found ..");
                ret = -1;
+                tracing_start();
                goto out;
        }
        /* do the test by disabling interrupts first this time */
        tracing_max_latency = 0;
-        tr->ctrl = 1;
+        tracing_start();
-        trace->ctrl_update(tr);
        preempt_disable();
        local_irq_disable();
        udelay(100);
@@ -341,8 +395,7 @@ trace_selftest_startup_preemptirqsoff(struct tracer *trace, struct trace_array *
        local_irq_enable();
        /* stop the tracing. */
-        tr->ctrl = 0;
+        tracing_stop();
-        trace->ctrl_update(tr);
        /* check both trace buffers */
        ret = trace_test_buffer(tr, NULL);
        if (ret)
@@ -358,6 +411,7 @@ trace_selftest_startup_preemptirqsoff(struct tracer *trace, struct trace_array *
 out:
        trace->reset(tr);
+        tracing_start();
        tracing_max_latency = save_max;
        return ret;
@@ -423,8 +477,12 @@ trace_selftest_startup_wakeup(struct tracer *trace, struct trace_array *tr)
        wait_for_completion(&isrt);
        /* start the tracing */
-        tr->ctrl = 1;
+        ret = trace->init(tr);
-        trace->init(tr);
+        if (ret) {
+                warn_failed_init_tracer(trace, ret);
+                return ret;
+        }
        /* reset the max latency */
        tracing_max_latency = 0;
@@ -448,8 +506,7 @@ trace_selftest_startup_wakeup(struct tracer *trace, struct trace_array *tr)
        msleep(100);
        /* stop the tracing. */
-        tr->ctrl = 0;
+        tracing_stop();
-        trace->ctrl_update(tr);
        /* check both trace buffers */
        ret = trace_test_buffer(tr, NULL);
        if (!ret)
@@ -457,6 +514,7 @@ trace_selftest_startup_wakeup(struct tracer *trace, struct trace_array *tr)
        trace->reset(tr);
+        tracing_start();
        tracing_max_latency = save_max;
@@ -480,16 +538,20 @@ trace_selftest_startup_sched_switch(struct tracer *trace, struct trace_array *tr
        int ret;
        /* start the tracing */
-        tr->ctrl = 1;
+        ret = trace->init(tr);
-        trace->init(tr);
+        if (ret) {
+                warn_failed_init_tracer(trace, ret);
+                return ret;
+        }
        /* Sleep for a 1/10 of a second */
        msleep(100);
        /* stop the tracing. */
-        tr->ctrl = 0;
+        tracing_stop();
-        trace->ctrl_update(tr);
        /* check the trace buffer */
        ret = trace_test_buffer(tr, &count);
        trace->reset(tr);
+        tracing_start();
        if (!ret && !count) {
                printk(KERN_CONT ".. no entries found ..");
@@ -508,17 +570,48 @@ trace_selftest_startup_sysprof(struct tracer *trace, struct trace_array *tr)
        int ret;
        /* start the tracing */
-        tr->ctrl = 1;
+        ret = trace->init(tr);
-        trace->init(tr);
+        if (ret) {
+                warn_failed_init_tracer(trace, ret);
+                return 0;
+        }
        /* Sleep for a 1/10 of a second */
        msleep(100);
        /* stop the tracing. */
-        tr->ctrl = 0;
+        tracing_stop();
-        trace->ctrl_update(tr);
        /* check the trace buffer */
        ret = trace_test_buffer(tr, &count);
        trace->reset(tr);
+        tracing_start();
        return ret;
 }
 #endif /* CONFIG_SYSPROF_TRACER */
+#ifdef CONFIG_BRANCH_TRACER
+int
+trace_selftest_startup_branch(struct tracer *trace, struct trace_array *tr)
+{
+        unsigned long count;
+        int ret;
+        /* start the tracing */
+        ret = trace->init(tr);
+        if (ret) {
+                warn_failed_init_tracer(trace, ret);
+                return ret;
+        }
+        /* Sleep for a 1/10 of a second */
+        msleep(100);
+        /* stop the tracing. */
+        tracing_stop();
+        /* check the trace buffer */
+        ret = trace_test_buffer(tr, &count);
+        trace->reset(tr);
+        tracing_start();
+        return ret;
+}
+#endif /* CONFIG_BRANCH_TRACER */
diff --git a/kernel/trace/trace_stack.c b/kernel/trace/trace_stack.c
index be682b62fe58..fde3be15c642 100644
--- a/kernel/trace/trace_stack.c
+++ b/kernel/trace/trace_stack.c
@@ -107,8 +107,7 @@ stack_trace_call(unsigned long ip, unsigned long parent_ip)
        if (unlikely(!ftrace_enabled || stack_trace_disabled))
                return;
-        resched = need_resched();
+        resched = ftrace_preempt_disable();
-        preempt_disable_notrace();
        cpu = raw_smp_processor_id();
        /* no atomic needed, we only modify this variable by this cpu */
@@ -120,10 +119,7 @@ stack_trace_call(unsigned long ip, unsigned long parent_ip)
 out:
        per_cpu(trace_active, cpu)--;
        /* prevent recursion in schedule */
-        if (resched)
+        ftrace_preempt_enable(resched);
-                preempt_enable_no_resched_notrace();
-        else
-                preempt_enable_notrace();
 }
 static struct ftrace_ops trace_ops __read_mostly =
@@ -184,11 +180,16 @@ static struct file_operations stack_max_size_fops = {
 static void *
 t_next(struct seq_file *m, void *v, loff_t *pos)
 {
-        long i = (long)m->private;
+        long i;
        (*pos)++;
-        i++;
+        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)
@@ -201,12 +202,15 @@ t_next(struct seq_file *m, void *v, loff_t *pos)
 static void *t_start(struct seq_file *m, loff_t *pos)
 {
-        void *t = &m->private;
+        void *t = SEQ_START_TOKEN;
        loff_t l = 0;
        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))
                ;
@@ -235,10 +239,10 @@ static int trace_lookup_stack(struct seq_file *m, long i)
 static int t_show(struct seq_file *m, void *v)
 {
-        long i = *(long *)v;
+        long i;
        int size;
-        if (i < 0) {
+        if (v == SEQ_START_TOKEN) {
                seq_printf(m, "        Depth   Size      Location"
                           "    (%d entries)\n"
                           "        -----   ----      --------\n",
@@ -246,6 +250,8 @@ static int t_show(struct seq_file *m, void *v)
                return 0;
        }
+        i = *(long *)v;
        if (i >= max_stack_trace.nr_entries ||
            stack_dump_trace[i] == ULONG_MAX)
                return 0;
@@ -275,10 +281,6 @@ static int stack_trace_open(struct inode *inode, struct file *file)
        int ret;
        ret = seq_open(file, &stack_trace_seq_ops);
-        if (!ret) {
-                struct seq_file *m = file->private_data;
-                m->private = (void *)-1;
-        }
        return ret;
 }
diff --git a/kernel/trace/trace_sysprof.c b/kernel/trace/trace_sysprof.c
index 9587d3bcba55..54960edb96d0 100644
--- a/kernel/trace/trace_sysprof.c
+++ b/kernel/trace/trace_sysprof.c
@@ -261,27 +261,17 @@ static void stop_stack_trace(struct trace_array *tr)
        mutex_unlock(&sample_timer_lock);
 }
-static void stack_trace_init(struct trace_array *tr)
+static int stack_trace_init(struct trace_array *tr)
 {
        sysprof_trace = tr;
-        if (tr->ctrl)
+        start_stack_trace(tr);
-                start_stack_trace(tr);
+        return 0;
 }
 static void stack_trace_reset(struct trace_array *tr)
 {
-        if (tr->ctrl)
+        stop_stack_trace(tr);
-                stop_stack_trace(tr);
-}
-static void stack_trace_ctrl_update(struct trace_array *tr)
-{
-        /* When starting a new trace, reset the buffers */
-        if (tr->ctrl)
-                start_stack_trace(tr);
-        else
-                stop_stack_trace(tr);
 }
 static struct tracer stack_trace __read_mostly =
@@ -289,7 +279,6 @@ static struct tracer stack_trace __read_mostly =
        .name           = "sysprof",
        .init           = stack_trace_init,
        .reset          = stack_trace_reset,
-        .ctrl_update    = stack_trace_ctrl_update,
 #ifdef CONFIG_FTRACE_SELFTEST
        .selftest    = trace_selftest_startup_sysprof,
 #endif
diff --git a/kernel/tracepoint.c b/kernel/tracepoint.c
index af8c85664882..79602740bbb5 100644
--- a/kernel/tracepoint.c
+++ b/kernel/tracepoint.c
@@ -43,6 +43,7 @@ static DEFINE_MUTEX(tracepoints_mutex);
 */
 #define TRACEPOINT_HASH_BITS 6
 #define TRACEPOINT_TABLE_SIZE (1 << TRACEPOINT_HASH_BITS)
+static struct hlist_head tracepoint_table[TRACEPOINT_TABLE_SIZE];
 /*
 * Note about RCU :
@@ -54,40 +55,43 @@ struct tracepoint_entry {
        struct hlist_node hlist;
        void **funcs;
        int refcount;   /* Number of times armed. 0 if disarmed. */
-        struct rcu_head rcu;
-        void *oldptr;
-        unsigned char rcu_pending:1;
        char name[0];
 };
-static struct hlist_head tracepoint_table[TRACEPOINT_TABLE_SIZE];
+struct tp_probes {
+        union {
+                struct rcu_head rcu;
+                struct list_head list;
+        } u;
+        void *probes[0];
+};
-static void free_old_closure(struct rcu_head *head)
+static inline void *allocate_probes(int count)
 {
-        struct tracepoint_entry *entry = container_of(head,
+        struct tp_probes *p  = kmalloc(count * sizeof(void *)
-                struct tracepoint_entry, rcu);
+                        + sizeof(struct tp_probes), GFP_KERNEL);
-        kfree(entry->oldptr);
+        return p == NULL ? NULL : p->probes;
-        /* Make sure we free the data before setting the pending flag to 0 */
-        smp_wmb();
-        entry->rcu_pending = 0;
 }
-static void tracepoint_entry_free_old(struct tracepoint_entry *entry, void *old)
+static void rcu_free_old_probes(struct rcu_head *head)
 {
-        if (!old)
+        kfree(container_of(head, struct tp_probes, u.rcu));
-                return;
+}
-        entry->oldptr = old;
-        entry->rcu_pending = 1;
+static inline void release_probes(void *old)
-        /* write rcu_pending before calling the RCU callback */
+{
-        smp_wmb();
+        if (old) {
-        call_rcu_sched(&entry->rcu, free_old_closure);
+                struct tp_probes *tp_probes = container_of(old,
+                        struct tp_probes, probes[0]);
+                call_rcu_sched(&tp_probes->u.rcu, rcu_free_old_probes);
+        }
 }
 static void debug_print_probes(struct tracepoint_entry *entry)
 {
        int i;
-        if (!tracepoint_debug)
+        if (!tracepoint_debug || !entry->funcs)
                return;
        for (i = 0; entry->funcs[i]; i++)
@@ -111,12 +115,13 @@ tracepoint_entry_add_probe(struct tracepoint_entry *entry, void *probe)
                                return ERR_PTR(-EEXIST);
        }
        /* + 2 : one for new probe, one for NULL func */
-        new = kzalloc((nr_probes + 2) * sizeof(void *), GFP_KERNEL);
+        new = allocate_probes(nr_probes + 2);
        if (new == NULL)
                return ERR_PTR(-ENOMEM);
        if (old)
                memcpy(new, old, nr_probes * sizeof(void *));
        new[nr_probes] = probe;
+        new[nr_probes + 1] = NULL;
        entry->refcount = nr_probes + 1;
        entry->funcs = new;
        debug_print_probes(entry);
@@ -132,7 +137,7 @@ tracepoint_entry_remove_probe(struct tracepoint_entry *entry, void *probe)
        old = entry->funcs;
        if (!old)
-                return NULL;
+                return ERR_PTR(-ENOENT);
        debug_print_probes(entry);
        /* (N -> M), (N > 1, M >= 0) probes */
@@ -151,13 +156,13 @@ tracepoint_entry_remove_probe(struct tracepoint_entry *entry, void *probe)
                int j = 0;
                /* N -> M, (N > 1, M > 0) */
                /* + 1 for NULL */
-                new = kzalloc((nr_probes - nr_del + 1)
+                new = allocate_probes(nr_probes - nr_del + 1);
-                        * sizeof(void *), GFP_KERNEL);
                if (new == NULL)
                        return ERR_PTR(-ENOMEM);
                for (i = 0; old[i]; i++)
                        if ((probe && old[i] != probe))
                                new[j++] = old[i];
+                new[nr_probes - nr_del] = NULL;
                entry->refcount = nr_probes - nr_del;
                entry->funcs = new;
        }
@@ -215,7 +220,6 @@ static struct tracepoint_entry *add_tracepoint(const char *name)
        memcpy(&e->name[0], name, name_len);
        e->funcs = NULL;
        e->refcount = 0;
-        e->rcu_pending = 0;
        hlist_add_head(&e->hlist, head);
        return e;
 }
@@ -224,32 +228,10 @@ static struct tracepoint_entry *add_tracepoint(const char *name)
 * Remove the tracepoint from the tracepoint hash table. Must be called with
 * mutex_lock held.
 */
-static int remove_tracepoint(const char *name)
+static inline void remove_tracepoint(struct tracepoint_entry *e)
 {
-        struct hlist_head *head;
-        struct hlist_node *node;
-        struct tracepoint_entry *e;
-        int found = 0;
-        size_t len = strlen(name) + 1;
-        u32 hash = jhash(name, len-1, 0);
-        head = &tracepoint_table[hash & (TRACEPOINT_TABLE_SIZE - 1)];
-        hlist_for_each_entry(e, node, head, hlist) {
-                if (!strcmp(name, e->name)) {
-                        found = 1;
-                        break;
-                }
-        }
-        if (!found)
-                return -ENOENT;
-        if (e->refcount)
-                return -EBUSY;
        hlist_del(&e->hlist);
-        /* Make sure the call_rcu_sched has been executed */
-        if (e->rcu_pending)
-                rcu_barrier_sched();
        kfree(e);
-        return 0;
 }
 /*
@@ -280,6 +262,7 @@ static void set_tracepoint(struct tracepoint_entry **entry,
 static void disable_tracepoint(struct tracepoint *elem)
 {
        elem->state = 0;
+        rcu_assign_pointer(elem->funcs, NULL);
 }
 /**
@@ -320,6 +303,23 @@ static void tracepoint_update_probes(void)
        module_update_tracepoints();
 }
+static void *tracepoint_add_probe(const char *name, void *probe)
+{
+        struct tracepoint_entry *entry;
+        void *old;
+        entry = get_tracepoint(name);
+        if (!entry) {
+                entry = add_tracepoint(name);
+                if (IS_ERR(entry))
+                        return entry;
+        }
+        old = tracepoint_entry_add_probe(entry, probe);
+        if (IS_ERR(old) && !entry->refcount)
+                remove_tracepoint(entry);
+        return old;
+}
 /**
 * tracepoint_probe_register -  Connect a probe to a tracepoint
 * @name: tracepoint name
@@ -330,44 +330,36 @@ static void tracepoint_update_probes(void)
 */
 int tracepoint_probe_register(const char *name, void *probe)
 {
-        struct tracepoint_entry *entry;
-        int ret = 0;
        void *old;
        mutex_lock(&tracepoints_mutex);
-        entry = get_tracepoint(name);
+        old = tracepoint_add_probe(name, probe);
-        if (!entry) {
-                entry = add_tracepoint(name);
-                if (IS_ERR(entry)) {
-                        ret = PTR_ERR(entry);
-                        goto end;
-                }
-        }
-        /*
-         * If we detect that a call_rcu_sched is pending for this tracepoint,
-         * make sure it's executed now.
-         */
-        if (entry->rcu_pending)
-                rcu_barrier_sched();
-        old = tracepoint_entry_add_probe(entry, probe);
-        if (IS_ERR(old)) {
-                ret = PTR_ERR(old);
-                goto end;
-        }
        mutex_unlock(&tracepoints_mutex);
+        if (IS_ERR(old))
+                return PTR_ERR(old);
        tracepoint_update_probes();             /* may update entry */
-        mutex_lock(&tracepoints_mutex);
+        release_probes(old);
-        entry = get_tracepoint(name);
+        return 0;
-        WARN_ON(!entry);
-        if (entry->rcu_pending)
-                rcu_barrier_sched();
-        tracepoint_entry_free_old(entry, old);
-end:
-        mutex_unlock(&tracepoints_mutex);
-        return ret;
 }
 EXPORT_SYMBOL_GPL(tracepoint_probe_register);
+static void *tracepoint_remove_probe(const char *name, void *probe)
+{
+        struct tracepoint_entry *entry;
+        void *old;
+        entry = get_tracepoint(name);
+        if (!entry)
+                return ERR_PTR(-ENOENT);
+        old = tracepoint_entry_remove_probe(entry, probe);
+        if (IS_ERR(old))
+                return old;
+        if (!entry->refcount)
+                remove_tracepoint(entry);
+        return old;
+}
 /**
 * tracepoint_probe_unregister -  Disconnect a probe from a tracepoint
 * @name: tracepoint name
@@ -380,38 +372,104 @@ EXPORT_SYMBOL_GPL(tracepoint_probe_register);
 */
 int tracepoint_probe_unregister(const char *name, void *probe)
 {
-        struct tracepoint_entry *entry;
        void *old;
-        int ret = -ENOENT;
        mutex_lock(&tracepoints_mutex);
-        entry = get_tracepoint(name);
+        old = tracepoint_remove_probe(name, probe);
-        if (!entry)
-                goto end;
-        if (entry->rcu_pending)
-                rcu_barrier_sched();
-        old = tracepoint_entry_remove_probe(entry, probe);
-        if (!old) {
-                printk(KERN_WARNING "Warning: Trying to unregister a probe"
-                                    "that doesn't exist\n");
-                goto end;
-        }
        mutex_unlock(&tracepoints_mutex);
+        if (IS_ERR(old))
+                return PTR_ERR(old);
        tracepoint_update_probes();             /* may update entry */
+        release_probes(old);
+        return 0;
+}
+EXPORT_SYMBOL_GPL(tracepoint_probe_unregister);
+static LIST_HEAD(old_probes);
+static int need_update;
+static void tracepoint_add_old_probes(void *old)
+{
+        need_update = 1;
+        if (old) {
+                struct tp_probes *tp_probes = container_of(old,
+                        struct tp_probes, probes[0]);
+                list_add(&tp_probes->u.list, &old_probes);
+        }
+}
+/**
+ * tracepoint_probe_register_noupdate -  register a probe but not connect
+ * @name: tracepoint name
+ * @probe: probe handler
+ *
+ * caller must call tracepoint_probe_update_all()
+ */
+int tracepoint_probe_register_noupdate(const char *name, void *probe)
+{
+        void *old;
        mutex_lock(&tracepoints_mutex);
-        entry = get_tracepoint(name);
+        old = tracepoint_add_probe(name, probe);
-        if (!entry)
+        if (IS_ERR(old)) {
-                goto end;
+                mutex_unlock(&tracepoints_mutex);
-        if (entry->rcu_pending)
+                return PTR_ERR(old);
-                rcu_barrier_sched();
+        }
-        tracepoint_entry_free_old(entry, old);
+        tracepoint_add_old_probes(old);
-        remove_tracepoint(name);        /* Ignore busy error message */
-        ret = 0;
-end:
        mutex_unlock(&tracepoints_mutex);
-        return ret;
+        return 0;
 }
-EXPORT_SYMBOL_GPL(tracepoint_probe_unregister);
+EXPORT_SYMBOL_GPL(tracepoint_probe_register_noupdate);
+/**
+ * tracepoint_probe_unregister_noupdate -  remove a probe but not disconnect
+ * @name: tracepoint name
+ * @probe: probe function pointer
+ *
+ * caller must call tracepoint_probe_update_all()
+ */
+int tracepoint_probe_unregister_noupdate(const char *name, void *probe)
+{
+        void *old;
+        mutex_lock(&tracepoints_mutex);
+        old = tracepoint_remove_probe(name, probe);
+        if (IS_ERR(old)) {
+                mutex_unlock(&tracepoints_mutex);
+                return PTR_ERR(old);
+        }
+        tracepoint_add_old_probes(old);
+        mutex_unlock(&tracepoints_mutex);
+        return 0;
+}
+EXPORT_SYMBOL_GPL(tracepoint_probe_unregister_noupdate);
+/**
+ * tracepoint_probe_update_all -  update tracepoints
+ */
+void tracepoint_probe_update_all(void)
+{
+        LIST_HEAD(release_probes);
+        struct tp_probes *pos, *next;
+        mutex_lock(&tracepoints_mutex);
+        if (!need_update) {
+                mutex_unlock(&tracepoints_mutex);
+                return;
+        }
+        if (!list_empty(&old_probes))
+                list_replace_init(&old_probes, &release_probes);
+        need_update = 0;
+        mutex_unlock(&tracepoints_mutex);
+        tracepoint_update_probes();
+        list_for_each_entry_safe(pos, next, &release_probes, u.list) {
+                list_del(&pos->u.list);
+                call_rcu_sched(&pos->u.rcu, rcu_free_old_probes);
+        }
+}
+EXPORT_SYMBOL_GPL(tracepoint_probe_update_all);
 /**
 * tracepoint_get_iter_range - Get a next tracepoint iterator given a range.
@@ -483,3 +541,36 @@ void tracepoint_iter_reset(struct tracepoint_iter *iter)
        iter->tracepoint = NULL;
 }
 EXPORT_SYMBOL_GPL(tracepoint_iter_reset);
+#ifdef CONFIG_MODULES
+int tracepoint_module_notify(struct notifier_block *self,
+                             unsigned long val, void *data)
+{
+        struct module *mod = data;
+        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);
+                break;
+        }
+        return 0;
+}
+struct notifier_block tracepoint_module_nb = {
+        .notifier_call = tracepoint_module_notify,
+        .priority = 0,
+};
+static int init_tracepoints(void)
+{
+        return register_module_notifier(&tracepoint_module_nb);
+}
+__initcall(init_tracepoints);
+#endif /* CONFIG_MODULES */
diff --git a/lib/scatterlist.c b/lib/scatterlist.c
index 8d2688ff1352..b7b449dafbe5 100644
--- a/lib/scatterlist.c
+++ b/lib/scatterlist.c
@@ -395,7 +395,7 @@ void sg_miter_stop(struct sg_mapping_iter *miter)
                        WARN_ON(!irqs_disabled());
                        kunmap_atomic(miter->addr, KM_BIO_SRC_IRQ);
                } else
-                        kunmap(miter->addr);
+                        kunmap(miter->page);
                miter->page = NULL;
                miter->addr = NULL;
diff --git a/mm/memory_hotplug.c b/mm/memory_hotplug.c
index 6837a1014372..b5b2b15085a8 100644
--- a/mm/memory_hotplug.c
+++ b/mm/memory_hotplug.c
@@ -22,7 +22,6 @@
 #include <linux/highmem.h>
 #include <linux/vmalloc.h>
 #include <linux/ioport.h>
-#include <linux/cpuset.h>
 #include <linux/delay.h>
 #include <linux/migrate.h>
 #include <linux/page-isolation.h>
@@ -498,8 +497,6 @@ int add_memory(int nid, u64 start, u64 size)
        /* we online node here. we can't roll back from here. */
        node_set_online(nid);
-        cpuset_track_online_nodes();
        if (new_pgdat) {
                ret = register_one_node(nid);
                /*
diff --git a/mm/migrate.c b/mm/migrate.c
index 385db89f0c33..1e0d6b237f44 100644
--- a/mm/migrate.c
+++ b/mm/migrate.c
@@ -522,15 +522,12 @@ static int writeout(struct address_space *mapping, struct page *page)
        remove_migration_ptes(page, page);
        rc = mapping->a_ops->writepage(page, &wbc);
-        if (rc < 0)
-                /* I/O Error writing */
-                return -EIO;
        if (rc != AOP_WRITEPAGE_ACTIVATE)
                /* unlocked. Relock */
                lock_page(page);
-        return -EAGAIN;
+        return (rc < 0) ? -EIO : -EAGAIN;
 }
 /*
diff --git a/mm/vmalloc.c b/mm/vmalloc.c
index ba6b0f5f7fac..30f826d484f0 100644
--- a/mm/vmalloc.c
+++ b/mm/vmalloc.c
@@ -324,14 +324,14 @@ static struct vmap_area *alloc_vmap_area(unsigned long size,
        BUG_ON(size & ~PAGE_MASK);
-        addr = ALIGN(vstart, align);
        va = kmalloc_node(sizeof(struct vmap_area),
                        gfp_mask & GFP_RECLAIM_MASK, node);
        if (unlikely(!va))
                return ERR_PTR(-ENOMEM);
 retry:
+        addr = ALIGN(vstart, align);
        spin_lock(&vmap_area_lock);
        /* XXX: could have a last_hole cache */
        n = vmap_area_root.rb_node;
@@ -362,7 +362,7 @@ retry:
                                goto found;
                }
-                while (addr + size >= first->va_start && addr + size <= vend) {
+                while (addr + size > first->va_start && addr + size <= vend) {
                        addr = ALIGN(first->va_end + PAGE_SIZE, align);
                        n = rb_next(&first->rb_node);
@@ -522,13 +522,24 @@ static void __purge_vmap_area_lazy(unsigned long *start, unsigned long *end,
 }
 /*
+ * Kick off a purge of the outstanding lazy areas. Don't bother if somebody
+ * is already purging.
+ */
+static void try_purge_vmap_area_lazy(void)
+{
+        unsigned long start = ULONG_MAX, end = 0;
+        __purge_vmap_area_lazy(&start, &end, 0, 0);
+}
+/*
 * Kick off a purge of the outstanding lazy areas.
 */
 static void purge_vmap_area_lazy(void)
 {
        unsigned long start = ULONG_MAX, end = 0;
-        __purge_vmap_area_lazy(&start, &end, 0, 0);
+        __purge_vmap_area_lazy(&start, &end, 1, 0);
 }
 /*
@@ -539,7 +550,7 @@ static void free_unmap_vmap_area(struct vmap_area *va)
        va->flags |= VM_LAZY_FREE;
        atomic_add((va->va_end - va->va_start) >> PAGE_SHIFT, &vmap_lazy_nr);
        if (unlikely(atomic_read(&vmap_lazy_nr) > lazy_max_pages()))
-                purge_vmap_area_lazy();
+                try_purge_vmap_area_lazy();
 }
 static struct vmap_area *find_vmap_area(unsigned long addr)
diff --git a/mm/vmscan.c b/mm/vmscan.c
index c141b3e78071..7ea1440b53db 100644
--- a/mm/vmscan.c
+++ b/mm/vmscan.c
@@ -623,6 +623,8 @@ static unsigned long shrink_page_list(struct list_head *page_list,
                 * Try to allocate it some swap space here.
                 */
                if (PageAnon(page) && !PageSwapCache(page)) {
+                        if (!(sc->gfp_mask & __GFP_IO))
+                                goto keep_locked;
                        switch (try_to_munlock(page)) {
                        case SWAP_FAIL:         /* shouldn't happen */
                        case SWAP_AGAIN:
@@ -634,6 +636,7 @@ static unsigned long shrink_page_list(struct list_head *page_list,
                        }
                        if (!add_to_swap(page, GFP_ATOMIC))
                                goto activate_locked;
+                        may_enter_fs = 1;
                }
 #endif /* CONFIG_SWAP */
@@ -1386,9 +1389,9 @@ static void get_scan_ratio(struct zone *zone, struct scan_control *sc,
        file_prio = 200 - sc->swappiness;
        /*
-         *                  anon       recent_rotated[0]
+         * The amount of pressure on anon vs file pages is inversely
-         * %anon = 100 * ----------- / ----------------- * IO cost
+         * proportional to the fraction of recently scanned pages on
-         *               anon + file      rotate_sum
+         * each list that were recently referenced and in active use.
         */
        ap = (anon_prio + 1) * (zone->recent_scanned[0] + 1);
        ap /= zone->recent_rotated[0] + 1;
diff --git a/net/compat.c b/net/compat.c
index 6ce1a1cadcc0..a3a2ba0fac08 100644
--- a/net/compat.c
+++ b/net/compat.c
@@ -725,7 +725,7 @@ EXPORT_SYMBOL(compat_mc_getsockopt);
 static unsigned char nas[19]={AL(0),AL(3),AL(3),AL(3),AL(2),AL(3),
                                AL(3),AL(3),AL(4),AL(4),AL(4),AL(6),
                                AL(6),AL(2),AL(5),AL(5),AL(3),AL(3),
-                                AL(6)};
+                                AL(4)};
 #undef AL
 asmlinkage long compat_sys_sendmsg(int fd, struct compat_msghdr __user *msg, unsigned flags)
@@ -738,52 +738,13 @@ asmlinkage long compat_sys_recvmsg(int fd, struct compat_msghdr __user *msg, uns
        return sys_recvmsg(fd, (struct msghdr __user *)msg, flags | MSG_CMSG_COMPAT);
 }
-asmlinkage long compat_sys_paccept(int fd, struct sockaddr __user *upeer_sockaddr,
-                                   int __user *upeer_addrlen,
-                                   const compat_sigset_t __user *sigmask,
-                                   compat_size_t sigsetsize, int flags)
-{
-        compat_sigset_t ss32;
-        sigset_t ksigmask, sigsaved;
-        int ret;
-        if (sigmask) {
-                if (sigsetsize != sizeof(compat_sigset_t))
-                        return -EINVAL;
-                if (copy_from_user(&ss32, sigmask, sizeof(ss32)))
-                        return -EFAULT;
-                sigset_from_compat(&ksigmask, &ss32);
-                sigdelsetmask(&ksigmask, sigmask(SIGKILL)|sigmask(SIGSTOP));
-                sigprocmask(SIG_SETMASK, &ksigmask, &sigsaved);
-        }
-        ret = do_accept(fd, upeer_sockaddr, upeer_addrlen, flags);
-        if (ret == -ERESTARTNOHAND) {
-                /*
-                 * Don't restore the signal mask yet. Let do_signal() deliver
-                 * the signal on the way back to userspace, before the signal
-                 * mask is restored.
-                 */
-                if (sigmask) {
-                        memcpy(&current->saved_sigmask, &sigsaved,
-                               sizeof(sigsaved));
-                        set_restore_sigmask();
-                }
-        } else if (sigmask)
-                sigprocmask(SIG_SETMASK, &sigsaved, NULL);
-        return ret;
-}
 asmlinkage long compat_sys_socketcall(int call, u32 __user *args)
 {
        int ret;
        u32 a[6];
        u32 a0, a1;
-        if (call < SYS_SOCKET || call > SYS_PACCEPT)
+        if (call < SYS_SOCKET || call > SYS_ACCEPT4)
                return -EINVAL;
        if (copy_from_user(a, args, nas[call]))
                return -EFAULT;
@@ -804,7 +765,7 @@ asmlinkage long compat_sys_socketcall(int call, u32 __user *args)
                ret = sys_listen(a0, a1);
                break;
        case SYS_ACCEPT:
-                ret = do_accept(a0, compat_ptr(a1), compat_ptr(a[2]), 0);
+                ret = sys_accept4(a0, compat_ptr(a1), compat_ptr(a[2]), 0);
                break;
        case SYS_GETSOCKNAME:
                ret = sys_getsockname(a0, compat_ptr(a1), compat_ptr(a[2]));
@@ -844,9 +805,8 @@ asmlinkage long compat_sys_socketcall(int call, u32 __user *args)
        case SYS_RECVMSG:
                ret = compat_sys_recvmsg(a0, compat_ptr(a1), a[2]);
                break;
-        case SYS_PACCEPT:
+        case SYS_ACCEPT4:
-                ret = compat_sys_paccept(a0, compat_ptr(a1), compat_ptr(a[2]),
+                ret = sys_accept4(a0, compat_ptr(a1), compat_ptr(a[2]), a[3]);
-                                         compat_ptr(a[3]), a[4], a[5]);
                break;
        default:
                ret = -EINVAL;
diff --git a/net/core/pktgen.c b/net/core/pktgen.c
index a47f5bad110d..8997e912aaaf 100644
--- a/net/core/pktgen.c
+++ b/net/core/pktgen.c
@@ -1973,13 +1973,7 @@ static void pktgen_setup_inject(struct pktgen_dev *pkt_dev)
        /* make sure that we don't pick a non-existing transmit queue */
        ntxq = pkt_dev->odev->real_num_tx_queues;
-        if (ntxq > num_online_cpus() && (pkt_dev->flags & F_QUEUE_MAP_CPU)) {
-                printk(KERN_WARNING "pktgen: WARNING: QUEUE_MAP_CPU "
-                       "disabled because CPU count (%d) exceeds number "
-                       "of tx queues (%d) on %s\n", num_online_cpus(), ntxq,
-                       pkt_dev->odev->name);
-                pkt_dev->flags &= ~F_QUEUE_MAP_CPU;
-        }
        if (ntxq <= pkt_dev->queue_map_min) {
                printk(KERN_WARNING "pktgen: WARNING: Requested "
                       "queue_map_min (zero-based) (%d) exceeds valid range "
@@ -2202,6 +2196,7 @@ static void set_cur_queue_map(struct pktgen_dev *pkt_dev)
                }
                pkt_dev->cur_queue_map = t;
        }
+        pkt_dev->cur_queue_map  = pkt_dev->cur_queue_map % pkt_dev->odev->real_num_tx_queues;
 }
 /* Increment/randomize headers according to flags and current values
diff --git a/net/ipv4/af_inet.c b/net/ipv4/af_inet.c
index 1fbff5fa4241..1aa2dc9e380e 100644
--- a/net/ipv4/af_inet.c
+++ b/net/ipv4/af_inet.c
@@ -1117,6 +1117,7 @@ int inet_sk_rebuild_header(struct sock *sk)
                        },
                },
                .proto = sk->sk_protocol,
+                .flags = inet_sk_flowi_flags(sk),
                .uli_u = {
                        .ports = {
                                .sport = inet->sport,
diff --git a/net/ipv4/ipmr.c b/net/ipv4/ipmr.c
index b42e082cc170..25924b1eb2ef 100644
--- a/net/ipv4/ipmr.c
+++ b/net/ipv4/ipmr.c
@@ -1945,13 +1945,14 @@ int __init ip_mr_init(void)
                goto proc_cache_fail;
 #endif
        return 0;
-reg_notif_fail:
-        kmem_cache_destroy(mrt_cachep);
 #ifdef CONFIG_PROC_FS
-proc_vif_fail:
-        unregister_netdevice_notifier(&ip_mr_notifier);
 proc_cache_fail:
        proc_net_remove(&init_net, "ip_mr_vif");
+proc_vif_fail:
+        unregister_netdevice_notifier(&ip_mr_notifier);
 #endif
+reg_notif_fail:
+        del_timer(&ipmr_expire_timer);
+        kmem_cache_destroy(mrt_cachep);
        return err;
 }
diff --git a/net/ipv4/udp.c b/net/ipv4/udp.c
index cf02701ced48..98c1fd09be88 100644
--- a/net/ipv4/udp.c
+++ b/net/ipv4/udp.c
@@ -633,6 +633,7 @@ int udp_sendmsg(struct kiocb *iocb, struct sock *sk, struct msghdr *msg,
                                                .saddr = saddr,
                                                .tos = tos } },
                                    .proto = sk->sk_protocol,
+                                    .flags = inet_sk_flowi_flags(sk),
                                    .uli_u = { .ports =
                                               { .sport = inet->sport,
                                                 .dport = dport } } };
diff --git a/net/ipv6/ip6mr.c b/net/ipv6/ip6mr.c
index 52a7eb0e2c2c..0524769632e7 100644
--- a/net/ipv6/ip6mr.c
+++ b/net/ipv6/ip6mr.c
@@ -224,7 +224,7 @@ static struct file_operations ip6mr_vif_fops = {
        .open    = ip6mr_vif_open,
        .read    = seq_read,
        .llseek  = seq_lseek,
-        .release = seq_release,
+        .release = seq_release_private,
 };
 static void *ipmr_mfc_seq_start(struct seq_file *seq, loff_t *pos)
@@ -338,7 +338,7 @@ static struct file_operations ip6mr_mfc_fops = {
        .open    = ipmr_mfc_open,
        .read    = seq_read,
        .llseek  = seq_lseek,
-        .release = seq_release,
+        .release = seq_release_private,
 };
 #endif
diff --git a/net/ipv6/proc.c b/net/ipv6/proc.c
index 07f0b76e7427..97c17fdd6f75 100644
--- a/net/ipv6/proc.c
+++ b/net/ipv6/proc.c
@@ -132,7 +132,7 @@ static struct snmp_mib snmp6_udplite6_list[] = {
 static void snmp6_seq_show_icmpv6msg(struct seq_file *seq, void **mib)
 {
-        static char name[32];
+        char name[32];
        int i;
        /* print by name -- deprecated items */
@@ -144,7 +144,7 @@ static void snmp6_seq_show_icmpv6msg(struct seq_file *seq, void **mib)
                p = icmp6type2name[icmptype];
                if (!p) /* don't print un-named types here */
                        continue;
-                (void) snprintf(name, sizeof(name)-1, "Icmp6%s%s",
+                snprintf(name, sizeof(name), "Icmp6%s%s",
                        i & 0x100 ? "Out" : "In", p);
                seq_printf(seq, "%-32s\t%lu\n", name,
                        snmp_fold_field(mib, i));
@@ -157,7 +157,7 @@ static void snmp6_seq_show_icmpv6msg(struct seq_file *seq, void **mib)
                val = snmp_fold_field(mib, i);
                if (!val)
                        continue;
-                (void) snprintf(name, sizeof(name)-1, "Icmp6%sType%u",
+                snprintf(name, sizeof(name), "Icmp6%sType%u",
                        i & 0x100 ?  "Out" : "In", i & 0xff);
                seq_printf(seq, "%-32s\t%lu\n", name, val);
        }
diff --git a/net/mac80211/mlme.c b/net/mac80211/mlme.c
index 14d165f0df75..409bb7716236 100644
--- a/net/mac80211/mlme.c
+++ b/net/mac80211/mlme.c
@@ -2560,25 +2560,3 @@ void ieee80211_mlme_notify_scan_completed(struct ieee80211_local *local)
                ieee80211_restart_sta_timer(sdata);
        rcu_read_unlock();
 }
-/* driver notification call */
-void ieee80211_notify_mac(struct ieee80211_hw *hw,
-                          enum ieee80211_notification_types  notif_type)
-{
-        struct ieee80211_local *local = hw_to_local(hw);
-        struct ieee80211_sub_if_data *sdata;
-        switch (notif_type) {
-        case IEEE80211_NOTIFY_RE_ASSOC:
-                rtnl_lock();
-                list_for_each_entry(sdata, &local->interfaces, list) {
-                        if (sdata->vif.type != NL80211_IFTYPE_STATION)
-                                continue;
-                        ieee80211_sta_req_auth(sdata, &sdata->u.sta);
-                }
-                rtnl_unlock();
-                break;
-        }
-}
-EXPORT_SYMBOL(ieee80211_notify_mac);
diff --git a/net/phonet/af_phonet.c b/net/phonet/af_phonet.c
index 7ab30f668b5a..9d211f12582b 100644
--- a/net/phonet/af_phonet.c
+++ b/net/phonet/af_phonet.c
@@ -33,9 +33,30 @@
 #include <net/phonet/phonet.h>
 #include <net/phonet/pn_dev.h>
-static struct net_proto_family phonet_proto_family;
+/* Transport protocol registration */
-static struct phonet_protocol *phonet_proto_get(int protocol);
+static struct phonet_protocol *proto_tab[PHONET_NPROTO] __read_mostly;
-static inline void phonet_proto_put(struct phonet_protocol *pp);
+static DEFINE_SPINLOCK(proto_tab_lock);
+static struct phonet_protocol *phonet_proto_get(int protocol)
+{
+        struct phonet_protocol *pp;
+        if (protocol >= PHONET_NPROTO)
+                return NULL;
+        spin_lock(&proto_tab_lock);
+        pp = proto_tab[protocol];
+        if (pp && !try_module_get(pp->prot->owner))
+                pp = NULL;
+        spin_unlock(&proto_tab_lock);
+        return pp;
+}
+static inline void phonet_proto_put(struct phonet_protocol *pp)
+{
+        module_put(pp->prot->owner);
+}
 /* protocol family functions */
@@ -375,10 +396,6 @@ static struct packet_type phonet_packet_type = {
        .func = phonet_rcv,
 };
-/* Transport protocol registration */
-static struct phonet_protocol *proto_tab[PHONET_NPROTO] __read_mostly;
-static DEFINE_SPINLOCK(proto_tab_lock);
 int __init_or_module phonet_proto_register(int protocol,
                                                struct phonet_protocol *pp)
 {
@@ -412,27 +429,6 @@ void phonet_proto_unregister(int protocol, struct phonet_protocol *pp)
 }
 EXPORT_SYMBOL(phonet_proto_unregister);
-static struct phonet_protocol *phonet_proto_get(int protocol)
-{
-        struct phonet_protocol *pp;
-        if (protocol >= PHONET_NPROTO)
-                return NULL;
-        spin_lock(&proto_tab_lock);
-        pp = proto_tab[protocol];
-        if (pp && !try_module_get(pp->prot->owner))
-                pp = NULL;
-        spin_unlock(&proto_tab_lock);
-        return pp;
-}
-static inline void phonet_proto_put(struct phonet_protocol *pp)
-{
-        module_put(pp->prot->owner);
-}
 /* Module registration */
 static int __init phonet_init(void)
 {
diff --git a/net/sched/sch_api.c b/net/sched/sch_api.c
index b16ad2972c6b..6ab4a2f92ca0 100644
--- a/net/sched/sch_api.c
+++ b/net/sched/sch_api.c
@@ -417,6 +417,8 @@ static int qdisc_dump_stab(struct sk_buff *skb, struct qdisc_size_table *stab)
        struct nlattr *nest;
        nest = nla_nest_start(skb, TCA_STAB);
+        if (nest == NULL)
+                goto nla_put_failure;
        NLA_PUT(skb, TCA_STAB_BASE, sizeof(stab->szopts), &stab->szopts);
        nla_nest_end(skb, nest);
diff --git a/net/sched/sch_generic.c b/net/sched/sch_generic.c
index 93cd30ce6501..cdcd16fcfeda 100644
--- a/net/sched/sch_generic.c
+++ b/net/sched/sch_generic.c
@@ -270,6 +270,8 @@ static void dev_watchdog_down(struct net_device *dev)
 void netif_carrier_on(struct net_device *dev)
 {
        if (test_and_clear_bit(__LINK_STATE_NOCARRIER, &dev->state)) {
+                if (dev->reg_state == NETREG_UNINITIALIZED)
+                        return;
                linkwatch_fire_event(dev);
                if (netif_running(dev))
                        __netdev_watchdog_up(dev);
@@ -285,8 +287,11 @@ EXPORT_SYMBOL(netif_carrier_on);
 */
 void netif_carrier_off(struct net_device *dev)
 {
-        if (!test_and_set_bit(__LINK_STATE_NOCARRIER, &dev->state))
+        if (!test_and_set_bit(__LINK_STATE_NOCARRIER, &dev->state)) {
+                if (dev->reg_state == NETREG_UNINITIALIZED)
+                        return;
                linkwatch_fire_event(dev);
+        }
 }
 EXPORT_SYMBOL(netif_carrier_off);
diff --git a/net/socket.c b/net/socket.c
index 57550c3bcabe..92764d836891 100644
--- a/net/socket.c
+++ b/net/socket.c
@@ -1426,8 +1426,8 @@ asmlinkage long sys_listen(int fd, int backlog)
 *      clean when we restucture accept also.
 */
-long do_accept(int fd, struct sockaddr __user *upeer_sockaddr,
+asmlinkage long sys_accept4(int fd, struct sockaddr __user *upeer_sockaddr,
-               int __user *upeer_addrlen, int flags)
+                            int __user *upeer_addrlen, int flags)
 {
        struct socket *sock, *newsock;
        struct file *newfile;
@@ -1510,66 +1510,10 @@ out_fd:
        goto out_put;
 }
-#if 0
-#ifdef HAVE_SET_RESTORE_SIGMASK
-asmlinkage long sys_paccept(int fd, struct sockaddr __user *upeer_sockaddr,
-                            int __user *upeer_addrlen,
-                            const sigset_t __user *sigmask,
-                            size_t sigsetsize, int flags)
-{
-        sigset_t ksigmask, sigsaved;
-        int ret;
-        if (sigmask) {
-                /* XXX: Don't preclude handling different sized sigset_t's.  */
-                if (sigsetsize != sizeof(sigset_t))
-                        return -EINVAL;
-                if (copy_from_user(&ksigmask, sigmask, sizeof(ksigmask)))
-                        return -EFAULT;
-                sigdelsetmask(&ksigmask, sigmask(SIGKILL)|sigmask(SIGSTOP));
-                sigprocmask(SIG_SETMASK, &ksigmask, &sigsaved);
-        }
-        ret = do_accept(fd, upeer_sockaddr, upeer_addrlen, flags);
-        if (ret < 0 && signal_pending(current)) {
-                /*
-                 * Don't restore the signal mask yet. Let do_signal() deliver
-                 * the signal on the way back to userspace, before the signal
-                 * mask is restored.
-                 */
-                if (sigmask) {
-                        memcpy(&current->saved_sigmask, &sigsaved,
-                               sizeof(sigsaved));
-                        set_restore_sigmask();
-                }
-        } else if (sigmask)
-                sigprocmask(SIG_SETMASK, &sigsaved, NULL);
-        return ret;
-}
-#else
-asmlinkage long sys_paccept(int fd, struct sockaddr __user *upeer_sockaddr,
-                            int __user *upeer_addrlen,
-                            const sigset_t __user *sigmask,
-                            size_t sigsetsize, int flags)
-{
-        /* The platform does not support restoring the signal mask in the
-         * return path.  So we do not allow using paccept() with a signal
-         * mask.  */
-        if (sigmask)
-                return -EINVAL;
-        return do_accept(fd, upeer_sockaddr, upeer_addrlen, flags);
-}
-#endif
-#endif
 asmlinkage long sys_accept(int fd, struct sockaddr __user *upeer_sockaddr,
                           int __user *upeer_addrlen)
 {
-        return do_accept(fd, upeer_sockaddr, upeer_addrlen, 0);
+        return sys_accept4(fd, upeer_sockaddr, upeer_addrlen, 0);
 }
 /*
@@ -2096,7 +2040,7 @@ static const unsigned char nargs[19]={
        AL(0),AL(3),AL(3),AL(3),AL(2),AL(3),
        AL(3),AL(3),AL(4),AL(4),AL(4),AL(6),
        AL(6),AL(2),AL(5),AL(5),AL(3),AL(3),
-        AL(6)
+        AL(4)
 };
 #undef AL
@@ -2115,7 +2059,7 @@ asmlinkage long sys_socketcall(int call, unsigned long __user *args)
        unsigned long a0, a1;
        int err;
-        if (call < 1 || call > SYS_PACCEPT)
+        if (call < 1 || call > SYS_ACCEPT4)
                return -EINVAL;
        /* copy_from_user should be SMP safe. */
@@ -2143,9 +2087,8 @@ asmlinkage long sys_socketcall(int call, unsigned long __user *args)
                err = sys_listen(a0, a1);
                break;
        case SYS_ACCEPT:
-                err =
+                err = sys_accept4(a0, (struct sockaddr __user *)a1,
-                    do_accept(a0, (struct sockaddr __user *)a1,
+                                  (int __user *)a[2], 0);
-                              (int __user *)a[2], 0);
                break;
        case SYS_GETSOCKNAME:
                err =
@@ -2192,12 +2135,9 @@ asmlinkage long sys_socketcall(int call, unsigned long __user *args)
        case SYS_RECVMSG:
                err = sys_recvmsg(a0, (struct msghdr __user *)a1, a[2]);
                break;
-        case SYS_PACCEPT:
+        case SYS_ACCEPT4:
-                err =
+                err = sys_accept4(a0, (struct sockaddr __user *)a1,
-                    sys_paccept(a0, (struct sockaddr __user *)a1,
+                                  (int __user *)a[2], a[3]);
-                                (int __user *)a[2],
-                                (const sigset_t __user *) a[3],
-                                a[4], a[5]);
                break;
        default:
                err = -EINVAL;
diff --git a/net/sunrpc/auth_generic.c b/net/sunrpc/auth_generic.c
index 744b79fdcb19..4028502f0528 100644
--- a/net/sunrpc/auth_generic.c
+++ b/net/sunrpc/auth_generic.c
@@ -133,13 +133,29 @@ static int
 generic_match(struct auth_cred *acred, struct rpc_cred *cred, int flags)
 {
        struct generic_cred *gcred = container_of(cred, struct generic_cred, gc_base);
+        int i;
        if (gcred->acred.uid != acred->uid ||
            gcred->acred.gid != acred->gid ||
-            gcred->acred.group_info != acred->group_info ||
            gcred->acred.machine_cred != acred->machine_cred)
-                return 0;
+                goto out_nomatch;
+        /* Optimisation in the case where pointers are identical... */
+        if (gcred->acred.group_info == acred->group_info)
+                goto out_match;
+        /* Slow path... */
+        if (gcred->acred.group_info->ngroups != acred->group_info->ngroups)
+                goto out_nomatch;
+        for (i = 0; i < gcred->acred.group_info->ngroups; i++) {
+                if (GROUP_AT(gcred->acred.group_info, i) !=
+                                GROUP_AT(acred->group_info, i))
+                        goto out_nomatch;
+        }
+out_match:
        return 1;
+out_nomatch:
+        return 0;
 }
 void __init rpc_init_generic_auth(void)
diff --git a/samples/tracepoints/tp-samples-trace.h b/samples/tracepoints/tp-samples-trace.h
index 0216b55bd640..01724e04c556 100644
--- a/samples/tracepoints/tp-samples-trace.h
+++ b/samples/tracepoints/tp-samples-trace.h
@@ -4,10 +4,10 @@
 #include <linux/proc_fs.h>      /* for struct inode and struct file */
 #include <linux/tracepoint.h>
-DEFINE_TRACE(subsys_event,
+DECLARE_TRACE(subsys_event,
        TPPROTO(struct inode *inode, struct file *file),
        TPARGS(inode, file));
-DEFINE_TRACE(subsys_eventb,
+DECLARE_TRACE(subsys_eventb,
        TPPROTO(void),
        TPARGS());
 #endif
diff --git a/samples/tracepoints/tracepoint-probe-sample.c b/samples/tracepoints/tracepoint-probe-sample.c
index 55abfdda4bd4..e3a964889dc7 100644
--- a/samples/tracepoints/tracepoint-probe-sample.c
+++ b/samples/tracepoints/tracepoint-probe-sample.c
@@ -46,6 +46,7 @@ void __exit tp_sample_trace_exit(void)
 {
        unregister_trace_subsys_eventb(probe_subsys_eventb);
        unregister_trace_subsys_event(probe_subsys_event);
+        tracepoint_synchronize_unregister();
 }
 module_exit(tp_sample_trace_exit);
diff --git a/samples/tracepoints/tracepoint-probe-sample2.c b/samples/tracepoints/tracepoint-probe-sample2.c
index 5e9fcf4afffe..685a5acb4562 100644
--- a/samples/tracepoints/tracepoint-probe-sample2.c
+++ b/samples/tracepoints/tracepoint-probe-sample2.c
@@ -33,6 +33,7 @@ module_init(tp_sample_trace_init);
 void __exit tp_sample_trace_exit(void)
 {
        unregister_trace_subsys_event(probe_subsys_event);
+        tracepoint_synchronize_unregister();
 }
 module_exit(tp_sample_trace_exit);
diff --git a/samples/tracepoints/tracepoint-sample.c b/samples/tracepoints/tracepoint-sample.c
index 4ae4b7fcc043..00d169792a3e 100644
--- a/samples/tracepoints/tracepoint-sample.c
+++ b/samples/tracepoints/tracepoint-sample.c
@@ -13,6 +13,9 @@
 #include <linux/proc_fs.h>
 #include "tp-samples-trace.h"
+DEFINE_TRACE(subsys_event);
+DEFINE_TRACE(subsys_eventb);
 struct proc_dir_entry *pentry_example;
 static int my_open(struct inode *inode, struct file *file)
diff --git a/scripts/Makefile.build b/scripts/Makefile.build
index 468fbc9016c7..7a176773af85 100644
--- a/scripts/Makefile.build
+++ b/scripts/Makefile.build
@@ -198,16 +198,10 @@ cmd_modversions =							\
        fi;
 endif
-ifdef CONFIG_64BIT
-arch_bits = 64
-else
-arch_bits = 32
-endif
 ifdef CONFIG_FTRACE_MCOUNT_RECORD
-cmd_record_mcount = perl $(srctree)/scripts/recordmcount.pl \
+cmd_record_mcount = perl $(srctree)/scripts/recordmcount.pl "$(ARCH)" \
-        "$(ARCH)" "$(arch_bits)" "$(OBJDUMP)" "$(OBJCOPY)" "$(CC)" "$(LD)" \
+        "$(if $(CONFIG_64BIT),64,32)" \
-        "$(NM)" "$(RM)" "$(MV)" "$(@)";
+        "$(OBJDUMP)" "$(OBJCOPY)" "$(CC)" "$(LD)" "$(NM)" "$(RM)" "$(MV)" "$(@)";
 endif
 define rule_cc_o_c
diff --git a/scripts/bootgraph.pl b/scripts/bootgraph.pl
index d2c61efc216f..f0af9aa9b243 100644
--- a/scripts/bootgraph.pl
+++ b/scripts/bootgraph.pl
@@ -78,11 +78,13 @@ while (<>) {
 }
 if ($count == 0) {
-        print "No data found in the dmesg. Make sure that 'printk.time=1' and\n";
+    print STDERR <<END;
-        print "'initcall_debug' are passed on the kernel command line.\n\n";
+No data found in the dmesg. Make sure that 'printk.time=1' and
-        print "Usage: \n";
+'initcall_debug' are passed on the kernel command line.
-        print "      dmesg | perl scripts/bootgraph.pl > output.svg\n\n";
+Usage:
-        exit;
+      dmesg | perl scripts/bootgraph.pl > output.svg
+END
+    exit 1;
 }
 print "<?xml version=\"1.0\" standalone=\"no\"?> \n";
@@ -109,8 +111,8 @@ my $stylecounter = 0;
 my %rows;
 my $rowscount = 1;
 my @initcalls = sort { $start{$a} <=> $start{$b} } keys(%start);
-my $key;
-foreach $key (@initcalls) {
+foreach my $key (@initcalls) {
        my $duration = $end{$key} - $start{$key};
        if ($duration >= $threshold) {
diff --git a/scripts/recordmcount.pl b/scripts/recordmcount.pl
index 6b9fe3eb8360..eeac71c87c66 100755
--- a/scripts/recordmcount.pl
+++ b/scripts/recordmcount.pl
@@ -134,6 +134,7 @@ my $section_regex;	# Find the start of a section
 my $function_regex;     # Find the name of a function
                        #    (return offset and func name)
 my $mcount_regex;       # Find the call site to mcount (return offset)
+my $alignment;         # The .align value to use for $mcount_section
 if ($arch eq "x86") {
    if ($bits == 64) {
@@ -148,6 +149,7 @@ if ($arch eq "x86_64") {
    $function_regex = "^([0-9a-fA-F]+)\\s+<(.*?)>:";
    $mcount_regex = "^\\s*([0-9a-fA-F]+):.*\\smcount([+-]0x[0-9a-zA-Z]+)?\$";
    $type = ".quad";
+    $alignment = 8;
    # force flags for this arch
    $ld .= " -m elf_x86_64";
@@ -160,6 +162,7 @@ if ($arch eq "x86_64") {
    $function_regex = "^([0-9a-fA-F]+)\\s+<(.*?)>:";
    $mcount_regex = "^\\s*([0-9a-fA-F]+):.*\\smcount\$";
    $type = ".long";
+    $alignment = 4;
    # force flags for this arch
    $ld .= " -m elf_i386";
@@ -288,6 +291,7 @@ sub update_funcs
            open(FILE, ">$mcount_s") || die "can't create $mcount_s\n";
            $opened = 1;
            print FILE "\t.section $mcount_section,\"a\",\@progbits\n";
+            print FILE "\t.align $alignment\n";
        }
        printf FILE "\t%s %s + %d\n", $type, $ref_func, $offsets[$i] - $offset;
    }
diff --git a/scripts/tracing/draw_functrace.py b/scripts/tracing/draw_functrace.py
new file mode 100644
index 000000000000..902f9a992620
--- /dev/null
+++ b/scripts/tracing/draw_functrace.py
@@ -0,0 +1,130 @@
+#!/usr/bin/python
+"""
+Copyright 2008 (c) Frederic Weisbecker <fweisbec@gmail.com>
+Licensed under the terms of the GNU GPL License version 2
+This script parses a trace provided by the function tracer in
+kernel/trace/trace_functions.c
+The resulted trace is processed into a tree to produce a more human
+view of the call stack by drawing textual but hierarchical tree of
+calls. Only the functions's names and the the call time are provided.
+Usage:
+        Be sure that you have CONFIG_FUNCTION_TRACER
+        # mkdir /debugfs
+        # mount -t debug debug /debug
+        # echo function > /debug/tracing/current_tracer
+        $ cat /debug/tracing/trace_pipe > ~/raw_trace_func
+        Wait some times but not too much, the script is a bit slow.
+        Break the pipe (Ctrl + Z)
+        $ scripts/draw_functrace.py < raw_trace_func > draw_functrace
+        Then you have your drawn trace in draw_functrace
+"""
+import sys, re
+class CallTree:
+        """ This class provides a tree representation of the functions
+                call stack. If a function has no parent in the kernel (interrupt,
+                syscall, kernel thread...) then it is attached to a virtual parent
+                called ROOT.
+        """
+        ROOT = None
+        def __init__(self, func, time = None, parent = None):
+                self._func = func
+                self._time = time
+                if parent is None:
+                        self._parent = CallTree.ROOT
+                else:
+                        self._parent = parent
+                self._children = []
+        def calls(self, func, calltime):
+                """ If a function calls another one, call this method to insert it
+                        into the tree at the appropriate place.
+                        @return: A reference to the newly created child node.
+                """
+                child = CallTree(func, calltime, self)
+                self._children.append(child)
+                return child
+        def getParent(self, func):
+                """ Retrieve the last parent of the current node that
+                        has the name given by func. If this function is not
+                        on a parent, then create it as new child of root
+                        @return: A reference to the parent.
+                """
+                tree = self
+                while tree != CallTree.ROOT and tree._func != func:
+                        tree = tree._parent
+                if tree == CallTree.ROOT:
+                        child = CallTree.ROOT.calls(func, None)
+                        return child
+                return tree
+        def __repr__(self):
+                return self.__toString("", True)
+        def __toString(self, branch, lastChild):
+                if self._time is not None:
+                        s = "%s----%s (%s)\n" % (branch, self._func, self._time)
+                else:
+                        s = "%s----%s\n" % (branch, self._func)
+                i = 0
+                if lastChild:
+                        branch = branch[:-1] + " "
+                while i < len(self._children):
+                        if i != len(self._children) - 1:
+                                s += "%s" % self._children[i].__toString(branch +\
+                                                                "    |", False)
+                        else:
+                                s += "%s" % self._children[i].__toString(branch +\
+                                                                "    |", True)
+                        i += 1
+                return s
+class BrokenLineException(Exception):
+        """If the last line is not complete because of the pipe breakage,
+           we want to stop the processing and ignore this line.
+        """
+        pass
+class CommentLineException(Exception):
+        """ If the line is a comment (as in the beginning of the trace file),
+            just ignore it.
+        """
+        pass
+def parseLine(line):
+        line = line.strip()
+        if line.startswith("#"):
+                raise CommentLineException
+        m = re.match("[^]]+?\\] +([0-9.]+): (\\w+) <-(\\w+)", line)
+        if m is None:
+                raise BrokenLineException
+        return (m.group(1), m.group(2), m.group(3))
+def main():
+        CallTree.ROOT = CallTree("Root (Nowhere)", None, None)
+        tree = CallTree.ROOT
+        for line in sys.stdin:
+                try:
+                        calltime, callee, caller = parseLine(line)
+                except BrokenLineException:
+                        break
+                except CommentLineException:
+                        continue
+                tree = tree.getParent(caller)
+                tree = tree.calls(callee, calltime)
+        print CallTree.ROOT
+if __name__ == "__main__":
+        main()