Merge branch 'master' of git://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux-2.6

author: Paul Mundt <lethal@linux-sh.org> 2010-05-19 22:57:38 -0400
committer: Paul Mundt <lethal@linux-sh.org> 2010-05-19 22:57:38 -0400
commit: ffee72d4681c8777918268a96aef42bdeb6c367b (patch)
tree: 4baf91483886d561c198ed0524ab54b783273e86 /include
parent: fb54d268329846aa13b2bc44a64d90e9b7131192 (diff)
parent: f72caf7e496465182eeda842ac66a5e75404ddf1 (diff)
115 files changed, 1677 insertions, 667 deletions
diff --git a/include/asm-generic/atomic.h b/include/asm-generic/atomic.h
index c99c64dc5f3d..c33749f95b32 100644
--- a/include/asm-generic/atomic.h
+++ b/include/asm-generic/atomic.h
@@ -33,7 +33,7 @@
 * Atomically reads the value of @v.  Note that the guaranteed
 * useful range of an atomic_t is only 24 bits.
 */
-#define atomic_read(v)  ((v)->counter)
+#define atomic_read(v)  (*(volatile int *)&(v)->counter)
 /**
 * atomic_set - set atomic variable
diff --git a/include/asm-generic/bitops/arch_hweight.h b/include/asm-generic/bitops/arch_hweight.h
new file mode 100644
index 000000000000..6a211f40665c
--- /dev/null
+++ b/include/asm-generic/bitops/arch_hweight.h
@@ -0,0 +1,25 @@
+#ifndef _ASM_GENERIC_BITOPS_ARCH_HWEIGHT_H_
+#define _ASM_GENERIC_BITOPS_ARCH_HWEIGHT_H_
+#include <asm/types.h>
+static inline unsigned int __arch_hweight32(unsigned int w)
+{
+        return __sw_hweight32(w);
+}
+static inline unsigned int __arch_hweight16(unsigned int w)
+{
+        return __sw_hweight16(w);
+}
+static inline unsigned int __arch_hweight8(unsigned int w)
+{
+        return __sw_hweight8(w);
+}
+static inline unsigned long __arch_hweight64(__u64 w)
+{
+        return __sw_hweight64(w);
+}
+#endif /* _ASM_GENERIC_BITOPS_HWEIGHT_H_ */
diff --git a/include/asm-generic/bitops/const_hweight.h b/include/asm-generic/bitops/const_hweight.h
new file mode 100644
index 000000000000..fa2a50b7ee66
--- /dev/null
+++ b/include/asm-generic/bitops/const_hweight.h
@@ -0,0 +1,42 @@
+#ifndef _ASM_GENERIC_BITOPS_CONST_HWEIGHT_H_
+#define _ASM_GENERIC_BITOPS_CONST_HWEIGHT_H_
+/*
+ * Compile time versions of __arch_hweightN()
+ */
+#define __const_hweight8(w)             \
+      ( (!!((w) & (1ULL << 0))) +       \
+        (!!((w) & (1ULL << 1))) +       \
+        (!!((w) & (1ULL << 2))) +       \
+        (!!((w) & (1ULL << 3))) +       \
+        (!!((w) & (1ULL << 4))) +       \
+        (!!((w) & (1ULL << 5))) +       \
+        (!!((w) & (1ULL << 6))) +       \
+        (!!((w) & (1ULL << 7))) )
+#define __const_hweight16(w) (__const_hweight8(w)  + __const_hweight8((w)  >> 8 ))
+#define __const_hweight32(w) (__const_hweight16(w) + __const_hweight16((w) >> 16))
+#define __const_hweight64(w) (__const_hweight32(w) + __const_hweight32((w) >> 32))
+/*
+ * Generic interface.
+ */
+#define hweight8(w)  (__builtin_constant_p(w) ? __const_hweight8(w)  : __arch_hweight8(w))
+#define hweight16(w) (__builtin_constant_p(w) ? __const_hweight16(w) : __arch_hweight16(w))
+#define hweight32(w) (__builtin_constant_p(w) ? __const_hweight32(w) : __arch_hweight32(w))
+#define hweight64(w) (__builtin_constant_p(w) ? __const_hweight64(w) : __arch_hweight64(w))
+/*
+ * Interface for known constant arguments
+ */
+#define HWEIGHT8(w)  (BUILD_BUG_ON_ZERO(!__builtin_constant_p(w)) + __const_hweight8(w))
+#define HWEIGHT16(w) (BUILD_BUG_ON_ZERO(!__builtin_constant_p(w)) + __const_hweight16(w))
+#define HWEIGHT32(w) (BUILD_BUG_ON_ZERO(!__builtin_constant_p(w)) + __const_hweight32(w))
+#define HWEIGHT64(w) (BUILD_BUG_ON_ZERO(!__builtin_constant_p(w)) + __const_hweight64(w))
+/*
+ * Type invariant interface to the compile time constant hweight functions.
+ */
+#define HWEIGHT(w)   HWEIGHT64((u64)w)
+#endif /* _ASM_GENERIC_BITOPS_CONST_HWEIGHT_H_ */
diff --git a/include/asm-generic/bitops/hweight.h b/include/asm-generic/bitops/hweight.h
index fbbc383771da..a94d6519c7ed 100644
--- a/include/asm-generic/bitops/hweight.h
+++ b/include/asm-generic/bitops/hweight.h
@@ -1,11 +1,7 @@
 #ifndef _ASM_GENERIC_BITOPS_HWEIGHT_H_
 #define _ASM_GENERIC_BITOPS_HWEIGHT_H_
-#include <asm/types.h>
+#include <asm-generic/bitops/arch_hweight.h>
+#include <asm-generic/bitops/const_hweight.h>
-extern unsigned int hweight32(unsigned int w);
-extern unsigned int hweight16(unsigned int w);
-extern unsigned int hweight8(unsigned int w);
-extern unsigned long hweight64(__u64 w);
 #endif /* _ASM_GENERIC_BITOPS_HWEIGHT_H_ */
diff --git a/include/asm-generic/dma-mapping-common.h b/include/asm-generic/dma-mapping-common.h
index e694263445f7..69206957b72c 100644
--- a/include/asm-generic/dma-mapping-common.h
+++ b/include/asm-generic/dma-mapping-common.h
@@ -131,7 +131,7 @@ static inline void dma_sync_single_range_for_cpu(struct device *dev,
                debug_dma_sync_single_range_for_cpu(dev, addr, offset, size, dir);
        } else
-                dma_sync_single_for_cpu(dev, addr, size, dir);
+                dma_sync_single_for_cpu(dev, addr + offset, size, dir);
 }
 static inline void dma_sync_single_range_for_device(struct device *dev,
@@ -148,7 +148,7 @@ static inline void dma_sync_single_range_for_device(struct device *dev,
                debug_dma_sync_single_range_for_device(dev, addr, offset, size, dir);
        } else
-                dma_sync_single_for_device(dev, addr, size, dir);
+                dma_sync_single_for_device(dev, addr + offset, size, dir);
 }
 static inline void
diff --git a/include/drm/drm_pciids.h b/include/drm/drm_pciids.h
index 04a6ebc27b96..2d428b088cc8 100644
--- a/include/drm/drm_pciids.h
+++ b/include/drm/drm_pciids.h
@@ -6,6 +6,7 @@
        {0x1002, 0x3150, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV380|RADEON_IS_MOBILITY}, \
        {0x1002, 0x3152, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV380|RADEON_IS_MOBILITY|RADEON_NEW_MEMMAP}, \
        {0x1002, 0x3154, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV380|RADEON_IS_MOBILITY|RADEON_NEW_MEMMAP}, \
+        {0x1002, 0x3155, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV380|RADEON_IS_MOBILITY|RADEON_NEW_MEMMAP}, \
        {0x1002, 0x3E50, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV380|RADEON_NEW_MEMMAP}, \
        {0x1002, 0x3E54, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV380|RADEON_NEW_MEMMAP}, \
        {0x1002, 0x4136, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RS100|RADEON_IS_IGP}, \
diff --git a/include/drm/ttm/ttm_bo_driver.h b/include/drm/ttm/ttm_bo_driver.h
index e929c27ede22..6b9db917e717 100644
--- a/include/drm/ttm/ttm_bo_driver.h
+++ b/include/drm/ttm/ttm_bo_driver.h
@@ -789,34 +789,6 @@ extern void ttm_bo_unreserve(struct ttm_buffer_object *bo);
 extern int ttm_bo_wait_unreserved(struct ttm_buffer_object *bo,
                                  bool interruptible);
-/**
- * ttm_bo_block_reservation
- *
- * @bo: A pointer to a struct ttm_buffer_object.
- * @interruptible: Use interruptible sleep when waiting.
- * @no_wait: Don't sleep, but rather return -EBUSY.
- *
- * Block reservation for validation by simply reserving the buffer.
- * This is intended for single buffer use only without eviction,
- * and thus needs no deadlock protection.
- *
- * Returns:
- * -EBUSY: If no_wait == 1 and the buffer is already reserved.
- * -ERESTARTSYS: If interruptible == 1 and the process received a signal
- * while sleeping.
- */
-extern int ttm_bo_block_reservation(struct ttm_buffer_object *bo,
-                                    bool interruptible, bool no_wait);
-/**
- * ttm_bo_unblock_reservation
- *
- * @bo: A pointer to a struct ttm_buffer_object.
- *
- * Unblocks reservation leaving lru lists untouched.
- */
-extern void ttm_bo_unblock_reservation(struct ttm_buffer_object *bo);
 /*
 * ttm_bo_util.c
 */
diff --git a/include/linux/acpi.h b/include/linux/acpi.h
index b926afe8c03e..3da73f5f0ae9 100644
--- a/include/linux/acpi.h
+++ b/include/linux/acpi.h
@@ -116,11 +116,12 @@ extern unsigned long acpi_realmode_flags;
 int acpi_register_gsi (struct device *dev, u32 gsi, int triggering, int polarity);
 int acpi_gsi_to_irq (u32 gsi, unsigned int *irq);
+int acpi_isa_irq_to_gsi (unsigned isa_irq, u32 *gsi);
 #ifdef CONFIG_X86_IO_APIC
-extern int acpi_get_override_irq(int bus_irq, int *trigger, int *polarity);
+extern int acpi_get_override_irq(u32 gsi, int *trigger, int *polarity);
 #else
-#define acpi_get_override_irq(bus, trigger, polarity) (-1)
+#define acpi_get_override_irq(gsi, trigger, polarity) (-1)
 #endif
 /*
 * This function undoes the effect of one call to acpi_register_gsi().
diff --git a/include/linux/amba/mmci.h b/include/linux/amba/mmci.h
index 6b4241748dda..7e466fe72025 100644
--- a/include/linux/amba/mmci.h
+++ b/include/linux/amba/mmci.h
@@ -6,8 +6,29 @@
 #include <linux/mmc/host.h>
+/**
+ * struct mmci_platform_data - platform configuration for the MMCI
+ * (also known as PL180) block.
+ * @f_max: the maximum operational frequency for this host in this
+ * platform configuration. When this is specified it takes precedence
+ * over the module parameter for the same frequency.
+ * @ocr_mask: available voltages on the 4 pins from the block, this
+ * is ignored if a regulator is used, see the MMC_VDD_* masks in
+ * mmc/host.h
+ * @translate_vdd: a callback function to translate a MMC_VDD_*
+ * mask into a value to be binary or:ed and written into the
+ * MMCIPWR register of the block
+ * @status: if no GPIO read function was given to the block in
+ * gpio_wp (below) this function will be called to determine
+ * whether a card is present in the MMC slot or not
+ * @gpio_wp: read this GPIO pin to see if the card is write protected
+ * @gpio_cd: read this GPIO pin to detect card insertion
+ * @capabilities: the capabilities of the block as implemented in
+ * this platform, signify anything MMC_CAP_* from mmc/host.h
+ */
 struct mmci_platform_data {
-        unsigned int ocr_mask;                  /* available voltages */
+        unsigned int f_max;
+        unsigned int ocr_mask;
        u32 (*translate_vdd)(struct device *, unsigned int);
        unsigned int (*status)(struct device *);
        int     gpio_wp;
diff --git a/include/linux/ata.h b/include/linux/ata.h
index b4c85e2adef5..700c5b9b3583 100644
--- a/include/linux/ata.h
+++ b/include/linux/ata.h
@@ -1025,8 +1025,8 @@ static inline int ata_ok(u8 status)
 static inline int lba_28_ok(u64 block, u32 n_block)
 {
-        /* check the ending block number */
+        /* check the ending block number: must be LESS THAN 0x0fffffff */
-        return ((block + n_block) < ((u64)1 << 28)) && (n_block <= 256);
+        return ((block + n_block) < ((1 << 28) - 1)) && (n_block <= 256);
 }
 static inline int lba_48_ok(u64 block, u32 n_block)
diff --git a/include/linux/backing-dev.h b/include/linux/backing-dev.h
index fcbc26af00e4..bd0e3c6f323f 100644
--- a/include/linux/backing-dev.h
+++ b/include/linux/backing-dev.h
@@ -101,6 +101,7 @@ int bdi_register(struct backing_dev_info *bdi, struct device *parent,
                const char *fmt, ...);
 int bdi_register_dev(struct backing_dev_info *bdi, dev_t dev);
 void bdi_unregister(struct backing_dev_info *bdi);
+int bdi_setup_and_register(struct backing_dev_info *, char *, unsigned int);
 void bdi_start_writeback(struct backing_dev_info *bdi, struct super_block *sb,
                                long nr_pages);
 int bdi_writeback_task(struct bdi_writeback *wb);
@@ -246,6 +247,7 @@ int bdi_set_max_ratio(struct backing_dev_info *bdi, unsigned int max_ratio);
 #endif
 extern struct backing_dev_info default_backing_dev_info;
+extern struct backing_dev_info noop_backing_dev_info;
 void default_unplug_io_fn(struct backing_dev_info *bdi, struct page *page);
 int writeback_in_progress(struct backing_dev_info *bdi);
diff --git a/include/linux/bitops.h b/include/linux/bitops.h
index b79389879238..fc68053378ce 100644
--- a/include/linux/bitops.h
+++ b/include/linux/bitops.h
@@ -10,6 +10,11 @@
 #define BITS_TO_LONGS(nr)       DIV_ROUND_UP(nr, BITS_PER_BYTE * sizeof(long))
 #endif
+extern unsigned int __sw_hweight8(unsigned int w);
+extern unsigned int __sw_hweight16(unsigned int w);
+extern unsigned int __sw_hweight32(unsigned int w);
+extern unsigned long __sw_hweight64(__u64 w);
 /*
 * Include this here because some architectures need generic_ffs/fls in
 * scope
@@ -21,9 +26,6 @@
             (bit) < (size); \
             (bit) = find_next_bit((addr), (size), (bit) + 1))
-/* Temporary */
-#define for_each_bit(bit, addr, size) for_each_set_bit(bit, addr, size)
 static __inline__ int get_bitmask_order(unsigned int count)
 {
        int order;
@@ -47,31 +49,6 @@ static inline unsigned long hweight_long(unsigned long w)
        return sizeof(w) == 4 ? hweight32(w) : hweight64(w);
 }
-/*
- * Clearly slow versions of the hweightN() functions, their benefit is
- * of course compile time evaluation of constant arguments.
- */
-#define HWEIGHT8(w)                                     \
-      ( BUILD_BUG_ON_ZERO(!__builtin_constant_p(w)) +   \
-        (!!((w) & (1ULL << 0))) +                       \
-        (!!((w) & (1ULL << 1))) +                       \
-        (!!((w) & (1ULL << 2))) +                       \
-        (!!((w) & (1ULL << 3))) +                       \
-        (!!((w) & (1ULL << 4))) +                       \
-        (!!((w) & (1ULL << 5))) +                       \
-        (!!((w) & (1ULL << 6))) +                       \
-        (!!((w) & (1ULL << 7))) )
-#define HWEIGHT16(w) (HWEIGHT8(w)  + HWEIGHT8((w) >> 8))
-#define HWEIGHT32(w) (HWEIGHT16(w) + HWEIGHT16((w) >> 16))
-#define HWEIGHT64(w) (HWEIGHT32(w) + HWEIGHT32((w) >> 32))
-/*
- * Type invariant version that simply casts things to the
- * largest type.
- */
-#define HWEIGHT(w)   HWEIGHT64((u64)(w))
 /**
 * rol32 - rotate a 32-bit value left
 * @word: value to rotate
diff --git a/include/linux/blkdev.h b/include/linux/blkdev.h
index ebd22dbed861..6690e8bae7bb 100644
--- a/include/linux/blkdev.h
+++ b/include/linux/blkdev.h
@@ -158,7 +158,6 @@ enum rq_flag_bits {
 struct request {
        struct list_head queuelist;
        struct call_single_data csd;
-        int cpu;
        struct request_queue *q;
@@ -166,9 +165,11 @@ struct request {
        enum rq_cmd_type_bits cmd_type;
        unsigned long atomic_flags;
+        int cpu;
        /* the following two fields are internal, NEVER access directly */
-        sector_t __sector;              /* sector cursor */
        unsigned int __data_len;        /* total data len */
+        sector_t __sector;              /* sector cursor */
        struct bio *bio;
        struct bio *biotail;
@@ -201,20 +202,20 @@ struct request {
        unsigned short ioprio;
+        int ref_count;
        void *special;          /* opaque pointer available for LLD use */
        char *buffer;           /* kaddr of the current segment if available */
        int tag;
        int errors;
-        int ref_count;
        /*
         * when request is used as a packet command carrier
         */
-        unsigned short cmd_len;
        unsigned char __cmd[BLK_MAX_CDB];
        unsigned char *cmd;
+        unsigned short cmd_len;
        unsigned int extra_len; /* length of alignment and padding */
        unsigned int sense_len;
@@ -921,26 +922,7 @@ extern void blk_cleanup_queue(struct request_queue *);
 extern void blk_queue_make_request(struct request_queue *, make_request_fn *);
 extern void blk_queue_bounce_limit(struct request_queue *, u64);
 extern void blk_queue_max_hw_sectors(struct request_queue *, unsigned int);
-/* Temporary compatibility wrapper */
-static inline void blk_queue_max_sectors(struct request_queue *q, unsigned int max)
-{
-        blk_queue_max_hw_sectors(q, max);
-}
 extern void blk_queue_max_segments(struct request_queue *, unsigned short);
-static inline void blk_queue_max_phys_segments(struct request_queue *q, unsigned short max)
-{
-        blk_queue_max_segments(q, max);
-}
-static inline void blk_queue_max_hw_segments(struct request_queue *q, unsigned short max)
-{
-        blk_queue_max_segments(q, max);
-}
 extern void blk_queue_max_segment_size(struct request_queue *, unsigned int);
 extern void blk_queue_max_discard_sectors(struct request_queue *q,
                unsigned int max_discard_sectors);
@@ -1030,11 +1012,6 @@ static inline int sb_issue_discard(struct super_block *sb,
 extern int blk_verify_command(unsigned char *cmd, fmode_t has_write_perm);
-#define MAX_PHYS_SEGMENTS 128
-#define MAX_HW_SEGMENTS 128
-#define SAFE_MAX_SECTORS 255
-#define MAX_SEGMENT_SIZE        65536
 enum blk_default_limits {
        BLK_MAX_SEGMENTS        = 128,
        BLK_SAFE_MAX_SECTORS    = 255,
diff --git a/include/linux/cgroup.h b/include/linux/cgroup.h
index b8ad1ea99586..8f78073d7caa 100644
--- a/include/linux/cgroup.h
+++ b/include/linux/cgroup.h
@@ -530,6 +530,7 @@ static inline struct cgroup_subsys_state *task_subsys_state(
 {
        return rcu_dereference_check(task->cgroups->subsys[subsys_id],
                                     rcu_read_lock_held() ||
+                                     lockdep_is_held(&task->alloc_lock) ||
                                     cgroup_lock_is_held());
 }
diff --git a/include/linux/clocksource.h b/include/linux/clocksource.h
index 4bca8b60cdf7..5ea3c60c160c 100644
--- a/include/linux/clocksource.h
+++ b/include/linux/clocksource.h
@@ -273,7 +273,6 @@ static inline s64 clocksource_cyc2ns(cycle_t cycles, u32 mult, u32 shift)
 }
-/* used to install a new clocksource */
 extern int clocksource_register(struct clocksource*);
 extern void clocksource_unregister(struct clocksource*);
 extern void clocksource_touch_watchdog(void);
@@ -287,6 +286,24 @@ extern void clocksource_mark_unstable(struct clocksource *cs);
 extern void
 clocks_calc_mult_shift(u32 *mult, u32 *shift, u32 from, u32 to, u32 minsec);
+/*
+ * Don't call __clocksource_register_scale directly, use
+ * clocksource_register_hz/khz
+ */
+extern int
+__clocksource_register_scale(struct clocksource *cs, u32 scale, u32 freq);
+static inline int clocksource_register_hz(struct clocksource *cs, u32 hz)
+{
+        return __clocksource_register_scale(cs, 1, hz);
+}
+static inline int clocksource_register_khz(struct clocksource *cs, u32 khz)
+{
+        return __clocksource_register_scale(cs, 1000, khz);
+}
 static inline void
 clocksource_calc_mult_shift(struct clocksource *cs, u32 freq, u32 minsec)
 {
diff --git a/include/linux/coda_psdev.h b/include/linux/coda_psdev.h
index 5b5d4731f956..8859e2ede9fe 100644
--- a/include/linux/coda_psdev.h
+++ b/include/linux/coda_psdev.h
@@ -7,6 +7,8 @@
 #define MAX_CODADEVS  5    /* how many do we allow */
 #ifdef __KERNEL__
+#include <linux/backing-dev.h>
 struct kstatfs;
 /* communication pending/processing queues */
@@ -17,6 +19,7 @@ struct venus_comm {
        struct list_head    vc_processing;
        int                 vc_inuse;
        struct super_block *vc_sb;
+        struct backing_dev_info bdi;
 };
diff --git a/include/linux/cpufreq.h b/include/linux/cpufreq.h
index 4de02b10007f..9f15150ce8d6 100644
--- a/include/linux/cpufreq.h
+++ b/include/linux/cpufreq.h
@@ -278,6 +278,27 @@ struct freq_attr {
        ssize_t (*store)(struct cpufreq_policy *, const char *, size_t count);
 };
+#define cpufreq_freq_attr_ro(_name)             \
+static struct freq_attr _name =                 \
+__ATTR(_name, 0444, show_##_name, NULL)
+#define cpufreq_freq_attr_ro_perm(_name, _perm) \
+static struct freq_attr _name =                 \
+__ATTR(_name, _perm, show_##_name, NULL)
+#define cpufreq_freq_attr_ro_old(_name)         \
+static struct freq_attr _name##_old =           \
+__ATTR(_name, 0444, show_##_name##_old, NULL)
+#define cpufreq_freq_attr_rw(_name)             \
+static struct freq_attr _name =                 \
+__ATTR(_name, 0644, show_##_name, store_##_name)
+#define cpufreq_freq_attr_rw_old(_name)         \
+static struct freq_attr _name##_old =           \
+__ATTR(_name, 0644, show_##_name##_old, store_##_name##_old)
 struct global_attr {
        struct attribute attr;
        ssize_t (*show)(struct kobject *kobj,
@@ -286,6 +307,15 @@ struct global_attr {
                         const char *c, size_t count);
 };
+#define define_one_global_ro(_name)             \
+static struct global_attr _name =               \
+__ATTR(_name, 0444, show_##_name, NULL)
+#define define_one_global_rw(_name)             \
+static struct global_attr _name =               \
+__ATTR(_name, 0644, show_##_name, store_##_name)
 /*********************************************************************
 *                        CPUFREQ 2.6. INTERFACE                     *
 *********************************************************************/
diff --git a/include/linux/cpuset.h b/include/linux/cpuset.h
index a5740fc4d04b..a73454aec333 100644
--- a/include/linux/cpuset.h
+++ b/include/linux/cpuset.h
@@ -21,8 +21,7 @@ extern int number_of_cpusets;	/* How many cpusets are defined in system? */
 extern int cpuset_init(void);
 extern void cpuset_init_smp(void);
 extern void cpuset_cpus_allowed(struct task_struct *p, struct cpumask *mask);
-extern void cpuset_cpus_allowed_locked(struct task_struct *p,
+extern int cpuset_cpus_allowed_fallback(struct task_struct *p);
-                                       struct cpumask *mask);
 extern nodemask_t cpuset_mems_allowed(struct task_struct *p);
 #define cpuset_current_mems_allowed (current->mems_allowed)
 void cpuset_init_current_mems_allowed(void);
@@ -69,9 +68,6 @@ struct seq_file;
 extern void cpuset_task_status_allowed(struct seq_file *m,
                                        struct task_struct *task);
-extern void cpuset_lock(void);
-extern void cpuset_unlock(void);
 extern int cpuset_mem_spread_node(void);
 static inline int cpuset_do_page_mem_spread(void)
@@ -105,10 +101,11 @@ static inline void cpuset_cpus_allowed(struct task_struct *p,
 {
        cpumask_copy(mask, cpu_possible_mask);
 }
-static inline void cpuset_cpus_allowed_locked(struct task_struct *p,
-                                              struct cpumask *mask)
+static inline int cpuset_cpus_allowed_fallback(struct task_struct *p)
 {
-        cpumask_copy(mask, cpu_possible_mask);
+        cpumask_copy(&p->cpus_allowed, cpu_possible_mask);
+        return cpumask_any(cpu_active_mask);
 }
 static inline nodemask_t cpuset_mems_allowed(struct task_struct *p)
@@ -157,9 +154,6 @@ static inline void cpuset_task_status_allowed(struct seq_file *m,
 {
 }
-static inline void cpuset_lock(void) {}
-static inline void cpuset_unlock(void) {}
 static inline int cpuset_mem_spread_node(void)
 {
        return 0;
diff --git a/include/linux/dcache.h b/include/linux/dcache.h
index 30b93b2a01a4..eebb617c17d8 100644
--- a/include/linux/dcache.h
+++ b/include/linux/dcache.h
@@ -186,6 +186,8 @@ d_iput:		no		no		no       yes
 #define DCACHE_FSNOTIFY_PARENT_WATCHED  0x0080 /* Parent inode is watched by some fsnotify listener */
+#define DCACHE_CANT_MOUNT       0x0100
 extern spinlock_t dcache_lock;
 extern seqlock_t rename_lock;
@@ -358,6 +360,18 @@ static inline int d_unlinked(struct dentry *dentry)
        return d_unhashed(dentry) && !IS_ROOT(dentry);
 }
+static inline int cant_mount(struct dentry *dentry)
+{
+        return (dentry->d_flags & DCACHE_CANT_MOUNT);
+}
+static inline void dont_mount(struct dentry *dentry)
+{
+        spin_lock(&dentry->d_lock);
+        dentry->d_flags |= DCACHE_CANT_MOUNT;
+        spin_unlock(&dentry->d_lock);
+}
 static inline struct dentry *dget_parent(struct dentry *dentry)
 {
        struct dentry *ret;
diff --git a/include/linux/debugobjects.h b/include/linux/debugobjects.h
index 8c243aaa86a7..597692f1fc8d 100644
--- a/include/linux/debugobjects.h
+++ b/include/linux/debugobjects.h
@@ -20,12 +20,14 @@ struct debug_obj_descr;
 * struct debug_obj - representaion of an tracked object
 * @node:       hlist node to link the object into the tracker list
 * @state:      tracked object state
+ * @astate:     current active state
 * @object:     pointer to the real object
 * @descr:      pointer to an object type specific debug description structure
 */
 struct debug_obj {
        struct hlist_node       node;
        enum debug_obj_state    state;
+        unsigned int            astate;
        void                    *object;
        struct debug_obj_descr  *descr;
 };
@@ -60,6 +62,15 @@ extern void debug_object_deactivate(void *addr, struct debug_obj_descr *descr);
 extern void debug_object_destroy   (void *addr, struct debug_obj_descr *descr);
 extern void debug_object_free      (void *addr, struct debug_obj_descr *descr);
+/*
+ * Active state:
+ * - Set at 0 upon initialization.
+ * - Must return to 0 before deactivation.
+ */
+extern void
+debug_object_active_state(void *addr, struct debug_obj_descr *descr,
+                          unsigned int expect, unsigned int next);
 extern void debug_objects_early_init(void);
 extern void debug_objects_mem_init(void);
 #else
diff --git a/include/linux/device.h b/include/linux/device.h
index 182192892d45..241b96bcd7ad 100644
--- a/include/linux/device.h
+++ b/include/linux/device.h
@@ -451,6 +451,10 @@ struct device {
 static inline const char *dev_name(const struct device *dev)
 {
+        /* Use the init name until the kobject becomes available */
+        if (dev->init_name)
+                return dev->init_name;
        return kobject_name(&dev->kobj);
 }
diff --git a/include/linux/drbd.h b/include/linux/drbd.h
index 78962272338a..4341b1a97a34 100644
--- a/include/linux/drbd.h
+++ b/include/linux/drbd.h
@@ -56,7 +56,7 @@ extern const char *drbd_buildtag(void);
 #define REL_VERSION "8.3.7"
 #define API_VERSION 88
 #define PRO_VERSION_MIN 86
-#define PRO_VERSION_MAX 91
+#define PRO_VERSION_MAX 92
 enum drbd_io_error_p {
diff --git a/include/linux/drbd_nl.h b/include/linux/drbd_nl.h
index a4d82f895994..f7431a4ca608 100644
--- a/include/linux/drbd_nl.h
+++ b/include/linux/drbd_nl.h
@@ -12,7 +12,7 @@
 #endif
 NL_PACKET(primary, 1,
-       NL_BIT(          1,      T_MAY_IGNORE,   overwrite_peer)
+       NL_BIT(          1,      T_MAY_IGNORE,   primary_force)
 )
 NL_PACKET(secondary, 2, )
@@ -63,6 +63,7 @@ NL_PACKET(net_conf, 5,
        NL_BIT(         41,     T_MAY_IGNORE,   always_asbp)
        NL_BIT(         61,     T_MAY_IGNORE,   no_cork)
        NL_BIT(         62,     T_MANDATORY,    auto_sndbuf_size)
+        NL_BIT(         70,     T_MANDATORY,    dry_run)
 )
 NL_PACKET(disconnect, 6, )
diff --git a/include/linux/elf.h b/include/linux/elf.h
index 597858418051..4d608014753a 100644
--- a/include/linux/elf.h
+++ b/include/linux/elf.h
@@ -394,6 +394,7 @@ typedef struct elf64_shdr {
 #define NT_S390_TODPREG 0x303           /* s390 TOD programmable register */
 #define NT_S390_CTRS    0x304           /* s390 control registers */
 #define NT_S390_PREFIX  0x305           /* s390 prefix register */
+#define NT_S390_LAST_BREAK      0x306   /* s390 breaking event address */
 /* Note header in a PT_NOTE section */
diff --git a/include/linux/firewire-cdev.h b/include/linux/firewire-cdev.h
index 40b11013408e..68f883b30a53 100644
--- a/include/linux/firewire-cdev.h
+++ b/include/linux/firewire-cdev.h
@@ -1,21 +1,26 @@
 /*
 * Char device interface.
 *
- * Copyright (C) 2005-2006  Kristian Hoegsberg <krh@bitplanet.net>
+ * Copyright (C) 2005-2007  Kristian Hoegsberg <krh@bitplanet.net>
- *
+ *
- * This program is free software; you can redistribute it and/or modify
+ * Permission is hereby granted, free of charge, to any person obtaining a
- * it under the terms of the GNU General Public License as published by
+ * copy of this software and associated documentation files (the "Software"),
- * the Free Software Foundation; either version 2 of the License, or
+ * to deal in the Software without restriction, including without limitation
- * (at your option) any later version.
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- *
+ * and/or sell copies of the Software, and to permit persons to whom the
- * This program is distributed in the hope that it will be useful,
+ * Software is furnished to do so, subject to the following conditions:
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * The above copyright notice and this permission notice (including the next
- * GNU General Public License for more details.
+ * paragraph) shall be included in all copies or substantial portions of the
- *
+ * Software.
- * You should have received a copy of the GNU General Public License
+ *
- * along with this program; if not, write to the Free Software Foundation,
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
+ * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+ * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
 */
 #ifndef _LINUX_FIREWIRE_CDEV_H
@@ -438,7 +443,7 @@ struct fw_cdev_remove_descriptor {
 * @type:       %FW_CDEV_ISO_CONTEXT_TRANSMIT or %FW_CDEV_ISO_CONTEXT_RECEIVE
 * @header_size: Header size to strip for receive contexts
 * @channel:    Channel to bind to
- * @speed:      Speed to transmit at
+ * @speed:      Speed for transmit contexts
 * @closure:    To be returned in &fw_cdev_event_iso_interrupt
 * @handle:     Handle to context, written back by kernel
 *
@@ -451,6 +456,9 @@ struct fw_cdev_remove_descriptor {
 * If a context was successfully created, the kernel writes back a handle to the
 * context, which must be passed in for subsequent operations on that context.
 *
+ * For receive contexts, @header_size must be at least 4 and must be a multiple
+ * of 4.
+ *
 * Note that the effect of a @header_size > 4 depends on
 * &fw_cdev_get_info.version, as documented at &fw_cdev_event_iso_interrupt.
 */
@@ -481,10 +489,34 @@ struct fw_cdev_create_iso_context {
 *
 * &struct fw_cdev_iso_packet is used to describe isochronous packet queues.
 *
- * Use the FW_CDEV_ISO_ macros to fill in @control.  The sy and tag fields are
+ * Use the FW_CDEV_ISO_ macros to fill in @control.
- * specified by IEEE 1394a and IEC 61883.
+ *
- *
+ * For transmit packets, the header length must be a multiple of 4 and specifies
- * FIXME - finish this documentation
+ * the numbers of bytes in @header that will be prepended to the packet's
+ * payload; these bytes are copied into the kernel and will not be accessed
+ * after the ioctl has returned.  The sy and tag fields are copied to the iso
+ * packet header (these fields are specified by IEEE 1394a and IEC 61883-1).
+ * The skip flag specifies that no packet is to be sent in a frame; when using
+ * this, all other fields except the interrupt flag must be zero.
+ *
+ * For receive packets, the header length must be a multiple of the context's
+ * header size; if the header length is larger than the context's header size,
+ * multiple packets are queued for this entry.  The sy and tag fields are
+ * ignored.  If the sync flag is set, the context drops all packets until
+ * a packet with a matching sy field is received (the sync value to wait for is
+ * specified in the &fw_cdev_start_iso structure).  The payload length defines
+ * how many payload bytes can be received for one packet (in addition to payload
+ * quadlets that have been defined as headers and are stripped and returned in
+ * the &fw_cdev_event_iso_interrupt structure).  If more bytes are received, the
+ * additional bytes are dropped.  If less bytes are received, the remaining
+ * bytes in this part of the payload buffer will not be written to, not even by
+ * the next packet, i.e., packets received in consecutive frames will not
+ * necessarily be consecutive in memory.  If an entry has queued multiple
+ * packets, the payload length is divided equally among them.
+ *
+ * When a packet with the interrupt flag set has been completed, the
+ * &fw_cdev_event_iso_interrupt event will be sent.  An entry that has queued
+ * multiple receive packets is completed when its last packet is completed.
 */
 struct fw_cdev_iso_packet {
        __u32 control;
@@ -501,7 +533,7 @@ struct fw_cdev_iso_packet {
 * Queue a number of isochronous packets for reception or transmission.
 * This ioctl takes a pointer to an array of &fw_cdev_iso_packet structs,
 * which describe how to transmit from or receive into a contiguous region
- * of a mmap()'ed payload buffer.  As part of the packet descriptors,
+ * of a mmap()'ed payload buffer.  As part of transmit packet descriptors,
 * a series of headers can be supplied, which will be prepended to the
 * payload during DMA.
 *
@@ -620,8 +652,8 @@ struct fw_cdev_get_cycle_timer2 {
 * instead of allocated.
 * An %FW_CDEV_EVENT_ISO_RESOURCE_DEALLOCATED event concludes this operation.
 *
- * To summarize, %FW_CDEV_IOC_DEALLOCATE_ISO_RESOURCE allocates iso resources
+ * To summarize, %FW_CDEV_IOC_ALLOCATE_ISO_RESOURCE allocates iso resources
- * for the lifetime of the fd or handle.
+ * for the lifetime of the fd or @handle.
 * In contrast, %FW_CDEV_IOC_ALLOCATE_ISO_RESOURCE_ONCE allocates iso resources
 * for the duration of a bus generation.
 *
diff --git a/include/linux/firewire-constants.h b/include/linux/firewire-constants.h
index b316770a43fd..9b4bb5fbba4b 100644
--- a/include/linux/firewire-constants.h
+++ b/include/linux/firewire-constants.h
@@ -1,3 +1,28 @@
+/*
+ * IEEE 1394 constants.
+ *
+ * Copyright (C) 2005-2007  Kristian Hoegsberg <krh@bitplanet.net>
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the next
+ * paragraph) shall be included in all copies or substantial portions of the
+ * Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
+ * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+ * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
+ */
 #ifndef _LINUX_FIREWIRE_CONSTANTS_H
 #define _LINUX_FIREWIRE_CONSTANTS_H
@@ -21,7 +46,7 @@
 #define EXTCODE_WRAP_ADD                0x6
 #define EXTCODE_VENDOR_DEPENDENT        0x7
-/* Juju specific tcodes */
+/* Linux firewire-core (Juju) specific tcodes */
 #define TCODE_LOCK_MASK_SWAP            (0x10 | EXTCODE_MASK_SWAP)
 #define TCODE_LOCK_COMPARE_SWAP         (0x10 | EXTCODE_COMPARE_SWAP)
 #define TCODE_LOCK_FETCH_ADD            (0x10 | EXTCODE_FETCH_ADD)
@@ -36,7 +61,7 @@
 #define RCODE_TYPE_ERROR                0x6
 #define RCODE_ADDRESS_ERROR             0x7
-/* Juju specific rcodes */
+/* Linux firewire-core (Juju) specific rcodes */
 #define RCODE_SEND_ERROR                0x10
 #define RCODE_CANCELLED                 0x11
 #define RCODE_BUSY                      0x12
diff --git a/include/linux/fs.h b/include/linux/fs.h
index 10b8dedcd18b..44f35aea2f1f 100644
--- a/include/linux/fs.h
+++ b/include/linux/fs.h
@@ -2212,6 +2212,7 @@ extern int generic_segment_checks(const struct iovec *iov,
 /* fs/block_dev.c */
 extern ssize_t blkdev_aio_write(struct kiocb *iocb, const struct iovec *iov,
                                unsigned long nr_segs, loff_t pos);
+extern int blkdev_fsync(struct file *filp, struct dentry *dentry, int datasync);
 /* fs/splice.c */
 extern ssize_t generic_file_splice_read(struct file *, loff_t *,
@@ -2314,8 +2315,9 @@ extern int vfs_fstatat(int , char __user *, struct kstat *, int);
 extern int do_vfs_ioctl(struct file *filp, unsigned int fd, unsigned int cmd,
                    unsigned long arg);
 extern int __generic_block_fiemap(struct inode *inode,
-                                  struct fiemap_extent_info *fieinfo, u64 start,
+                                  struct fiemap_extent_info *fieinfo,
-                                  u64 len, get_block_t *get_block);
+                                  loff_t start, loff_t len,
+                                  get_block_t *get_block);
 extern int generic_block_fiemap(struct inode *inode,
                                struct fiemap_extent_info *fieinfo, u64 start,
                                u64 len, get_block_t *get_block);
diff --git a/include/linux/ftrace.h b/include/linux/ftrace.h
index 01e6adea07ec..41e46330d9be 100644
--- a/include/linux/ftrace.h
+++ b/include/linux/ftrace.h
@@ -82,9 +82,13 @@ void clear_ftrace_function(void);
 extern void ftrace_stub(unsigned long a0, unsigned long a1);
 #else /* !CONFIG_FUNCTION_TRACER */
-# define register_ftrace_function(ops) do { } while (0)
+/*
-# define unregister_ftrace_function(ops) do { } while (0)
+ * (un)register_ftrace_function must be a macro since the ops parameter
-# define clear_ftrace_function(ops) do { } while (0)
+ * must not be evaluated.
+ */
+#define register_ftrace_function(ops) ({ 0; })
+#define unregister_ftrace_function(ops) ({ 0; })
+static inline void clear_ftrace_function(void) { }
 static inline void ftrace_kill(void) { }
 static inline void ftrace_stop(void) { }
 static inline void ftrace_start(void) { }
@@ -237,11 +241,13 @@ extern int skip_trace(unsigned long ip);
 extern void ftrace_disable_daemon(void);
 extern void ftrace_enable_daemon(void);
 #else
-# define skip_trace(ip)                         ({ 0; })
+static inline int skip_trace(unsigned long ip) { return 0; }
-# define ftrace_force_update()                  ({ 0; })
+static inline int ftrace_force_update(void) { return 0; }
-# define ftrace_set_filter(buf, len, reset)     do { } while (0)
+static inline void ftrace_set_filter(unsigned char *buf, int len, int reset)
-# define ftrace_disable_daemon()                do { } while (0)
+{
-# define ftrace_enable_daemon()                 do { } while (0)
+}
+static inline void ftrace_disable_daemon(void) { }
+static inline void ftrace_enable_daemon(void) { }
 static inline void ftrace_release_mod(struct module *mod) {}
 static inline int register_ftrace_command(struct ftrace_func_command *cmd)
 {
@@ -314,16 +320,16 @@ static inline void __ftrace_enabled_restore(int enabled)
  extern void time_hardirqs_on(unsigned long a0, unsigned long a1);
  extern void time_hardirqs_off(unsigned long a0, unsigned long a1);
 #else
-# define time_hardirqs_on(a0, a1)               do { } while (0)
+  static inline void time_hardirqs_on(unsigned long a0, unsigned long a1) { }
-# define time_hardirqs_off(a0, a1)              do { } while (0)
+  static inline void time_hardirqs_off(unsigned long a0, unsigned long a1) { }
 #endif
 #ifdef CONFIG_PREEMPT_TRACER
  extern void trace_preempt_on(unsigned long a0, unsigned long a1);
  extern void trace_preempt_off(unsigned long a0, unsigned long a1);
 #else
-# define trace_preempt_on(a0, a1)               do { } while (0)
+  static inline void trace_preempt_on(unsigned long a0, unsigned long a1) { }
-# define trace_preempt_off(a0, a1)              do { } while (0)
+  static inline void trace_preempt_off(unsigned long a0, unsigned long a1) { }
 #endif
 #ifdef CONFIG_FTRACE_MCOUNT_RECORD
@@ -352,6 +358,10 @@ struct ftrace_graph_ret {
        int depth;
 };
+/* Type of the callback handlers for tracing function graph*/
+typedef void (*trace_func_graph_ret_t)(struct ftrace_graph_ret *); /* return */
+typedef int (*trace_func_graph_ent_t)(struct ftrace_graph_ent *); /* entry */
 #ifdef CONFIG_FUNCTION_GRAPH_TRACER
 /* for init task */
@@ -400,10 +410,6 @@ extern char __irqentry_text_end[];
 #define FTRACE_RETFUNC_DEPTH 50
 #define FTRACE_RETSTACK_ALLOC_SIZE 32
-/* Type of the callback handlers for tracing function graph*/
-typedef void (*trace_func_graph_ret_t)(struct ftrace_graph_ret *); /* return */
-typedef int (*trace_func_graph_ent_t)(struct ftrace_graph_ent *); /* entry */
 extern int register_ftrace_graph(trace_func_graph_ret_t retfunc,
                                trace_func_graph_ent_t entryfunc);
@@ -441,6 +447,13 @@ static inline void unpause_graph_tracing(void)
 static inline void ftrace_graph_init_task(struct task_struct *t) { }
 static inline void ftrace_graph_exit_task(struct task_struct *t) { }
+static inline int register_ftrace_graph(trace_func_graph_ret_t retfunc,
+                          trace_func_graph_ent_t entryfunc)
+{
+        return -1;
+}
+static inline void unregister_ftrace_graph(void) { }
 static inline int task_curr_ret_stack(struct task_struct *tsk)
 {
        return -1;
@@ -492,7 +505,9 @@ static inline int test_tsk_trace_graph(struct task_struct *tsk)
        return tsk->trace & TSK_TRACE_FL_GRAPH;
 }
-extern int ftrace_dump_on_oops;
+enum ftrace_dump_mode;
+extern enum ftrace_dump_mode ftrace_dump_on_oops;
 #ifdef CONFIG_PREEMPT
 #define INIT_TRACE_RECURSION            .trace_recursion = 0,
@@ -504,18 +519,6 @@ extern int ftrace_dump_on_oops;
 #define INIT_TRACE_RECURSION
 #endif
-#ifdef CONFIG_HW_BRANCH_TRACER
-void trace_hw_branch(u64 from, u64 to);
-void trace_hw_branch_oops(void);
-#else /* CONFIG_HW_BRANCH_TRACER */
-static inline void trace_hw_branch(u64 from, u64 to) {}
-static inline void trace_hw_branch_oops(void) {}
-#endif /* CONFIG_HW_BRANCH_TRACER */
 #ifdef CONFIG_FTRACE_SYSCALLS
 unsigned long arch_syscall_addr(int nr);
diff --git a/include/linux/ftrace_event.h b/include/linux/ftrace_event.h
index c0f4b364c711..39e71b0a3bfd 100644
--- a/include/linux/ftrace_event.h
+++ b/include/linux/ftrace_event.h
@@ -58,6 +58,7 @@ struct trace_iterator {
        /* The below is zeroed out in pipe_read */
        struct trace_seq        seq;
        struct trace_entry      *ent;
+        unsigned long           lost_events;
        int                     leftover;
        int                     cpu;
        u64                     ts;
diff --git a/include/linux/genhd.h b/include/linux/genhd.h
index 56b50514ab25..5f2f4c4d8fb0 100644
--- a/include/linux/genhd.h
+++ b/include/linux/genhd.h
@@ -109,7 +109,7 @@ struct hd_struct {
 };
 #define GENHD_FL_REMOVABLE                      1
-#define GENHD_FL_DRIVERFS                       2
+/* 2 is unused */
 #define GENHD_FL_MEDIA_CHANGE_NOTIFY            4
 #define GENHD_FL_CD                             8
 #define GENHD_FL_UP                             16
diff --git a/include/linux/hrtimer.h b/include/linux/hrtimer.h
index 5d86fb2309d2..fd0c1b857d3d 100644
--- a/include/linux/hrtimer.h
+++ b/include/linux/hrtimer.h
@@ -422,6 +422,8 @@ extern void hrtimer_init_sleeper(struct hrtimer_sleeper *sl,
 extern int schedule_hrtimeout_range(ktime_t *expires, unsigned long delta,
                                                const enum hrtimer_mode mode);
+extern int schedule_hrtimeout_range_clock(ktime_t *expires,
+                unsigned long delta, const enum hrtimer_mode mode, int clock);
 extern int schedule_hrtimeout(ktime_t *expires, const enum hrtimer_mode mode);
 /* Soft interrupt function to run the hrtimer queues: */
diff --git a/include/linux/hw_breakpoint.h b/include/linux/hw_breakpoint.h
index c70d27af03f9..a2d6ea49ec56 100644
--- a/include/linux/hw_breakpoint.h
+++ b/include/linux/hw_breakpoint.h
@@ -9,9 +9,22 @@ enum {
 };
 enum {
-        HW_BREAKPOINT_R = 1,
+        HW_BREAKPOINT_EMPTY     = 0,
-        HW_BREAKPOINT_W = 2,
+        HW_BREAKPOINT_R         = 1,
-        HW_BREAKPOINT_X = 4,
+        HW_BREAKPOINT_W         = 2,
+        HW_BREAKPOINT_RW        = HW_BREAKPOINT_R | HW_BREAKPOINT_W,
+        HW_BREAKPOINT_X         = 4,
+        HW_BREAKPOINT_INVALID   = HW_BREAKPOINT_RW | HW_BREAKPOINT_X,
+};
+enum bp_type_idx {
+        TYPE_INST       = 0,
+#ifdef CONFIG_HAVE_MIXED_BREAKPOINTS_REGS
+        TYPE_DATA       = 0,
+#else
+        TYPE_DATA       = 1,
+#endif
+        TYPE_MAX
 };
 #ifdef __KERNEL__
@@ -34,6 +47,12 @@ static inline void hw_breakpoint_init(struct perf_event_attr *attr)
        attr->sample_period = 1;
 }
+static inline void ptrace_breakpoint_init(struct perf_event_attr *attr)
+{
+        hw_breakpoint_init(attr);
+        attr->exclude_kernel = 1;
+}
 static inline unsigned long hw_breakpoint_addr(struct perf_event *bp)
 {
        return bp->attr.bp_addr;
diff --git a/include/linux/i2c.h b/include/linux/i2c.h
index 0a5da639b327..6ed1d59bfb1e 100644
--- a/include/linux/i2c.h
+++ b/include/linux/i2c.h
@@ -355,6 +355,8 @@ struct i2c_adapter {
        int nr;
        char name[48];
        struct completion dev_released;
+        struct list_head userspace_clients;
 };
 #define to_i2c_adapter(d) container_of(d, struct i2c_adapter, dev)
diff --git a/include/linux/i2o.h b/include/linux/i2o.h
index 87018dc5527d..9e7a12d6385d 100644
--- a/include/linux/i2o.h
+++ b/include/linux/i2o.h
@@ -782,7 +782,6 @@ extern int i2o_exec_lct_get(struct i2o_controller *);
 #define to_i2o_driver(drv) container_of(drv,struct i2o_driver, driver)
 #define to_i2o_device(dev) container_of(dev, struct i2o_device, device)
 #define to_i2o_controller(dev) container_of(dev, struct i2o_controller, device)
-#define kobj_to_i2o_device(kobj) to_i2o_device(container_of(kobj, struct device, kobj))
 /**
 *      i2o_out_to_virt - Turn an I2O message to a virtual address
diff --git a/include/linux/ide.h b/include/linux/ide.h
index 97e6ab435184..3239d1c10acb 100644
--- a/include/linux/ide.h
+++ b/include/linux/ide.h
@@ -1169,6 +1169,7 @@ extern void ide_stall_queue(ide_drive_t *drive, unsigned long timeout);
 extern void ide_timer_expiry(unsigned long);
 extern irqreturn_t ide_intr(int irq, void *dev_id);
 extern void do_ide_request(struct request_queue *);
+extern void ide_requeue_and_plug(ide_drive_t *drive, struct request *rq);
 void ide_init_disk(struct gendisk *, ide_drive_t *);
diff --git a/include/linux/if_link.h b/include/linux/if_link.h
index c9bf92cd7653..d94963b379d9 100644
--- a/include/linux/if_link.h
+++ b/include/linux/if_link.h
@@ -79,10 +79,7 @@ enum {
        IFLA_NET_NS_PID,
        IFLA_IFALIAS,
        IFLA_NUM_VF,            /* Number of VFs if device is SR-IOV PF */
-        IFLA_VF_MAC,            /* Hardware queue specific attributes */
+        IFLA_VFINFO_LIST,
-        IFLA_VF_VLAN,
-        IFLA_VF_TX_RATE,        /* TX Bandwidth Allocation */
-        IFLA_VFINFO,
        __IFLA_MAX
 };
@@ -203,6 +200,24 @@ enum macvlan_mode {
 /* SR-IOV virtual function managment section */
+enum {
+        IFLA_VF_INFO_UNSPEC,
+        IFLA_VF_INFO,
+        __IFLA_VF_INFO_MAX,
+};
+#define IFLA_VF_INFO_MAX (__IFLA_VF_INFO_MAX - 1)
+enum {
+        IFLA_VF_UNSPEC,
+        IFLA_VF_MAC,            /* Hardware queue specific attributes */
+        IFLA_VF_VLAN,
+        IFLA_VF_TX_RATE,        /* TX Bandwidth Allocation */
+        __IFLA_VF_MAX,
+};
+#define IFLA_VF_MAX (__IFLA_VF_MAX - 1)
 struct ifla_vf_mac {
        __u32 vf;
        __u8 mac[32]; /* MAX_ADDR_LEN */
diff --git a/include/linux/init_task.h b/include/linux/init_task.h
index b1ed1cd8e2a8..7996fc2c9ba9 100644
--- a/include/linux/init_task.h
+++ b/include/linux/init_task.h
@@ -49,7 +49,6 @@ extern struct group_info init_groups;
                { .first = &init_task.pids[PIDTYPE_PGID].node },        \
                { .first = &init_task.pids[PIDTYPE_SID].node },         \
        },                                                              \
-        .rcu            = RCU_HEAD_INIT,                                \
        .level          = 0,                                            \
        .numbers        = { {                                           \
                .nr             = 0,                                    \
diff --git a/include/linux/input/matrix_keypad.h b/include/linux/input/matrix_keypad.h
index 3bd018baae20..c964cd7f436a 100644
--- a/include/linux/input/matrix_keypad.h
+++ b/include/linux/input/matrix_keypad.h
@@ -44,6 +44,7 @@ struct matrix_keymap_data {
 * @active_low: gpio polarity
 * @wakeup: controls whether the device should be set up as wakeup
 *      source
+ * @no_autorepeat: disable key autorepeat
 *
 * This structure represents platform-specific data that use used by
 * matrix_keypad driver to perform proper initialization.
@@ -64,6 +65,7 @@ struct matrix_keypad_platform_data {
        bool            active_low;
        bool            wakeup;
+        bool            no_autorepeat;
 };
 /**
diff --git a/include/linux/interrupt.h b/include/linux/interrupt.h
index 75f3f00ac1e5..5137db3317f9 100644
--- a/include/linux/interrupt.h
+++ b/include/linux/interrupt.h
@@ -39,7 +39,8 @@
 * These flags used only by the kernel as part of the
 * irq handling routines.
 *
- * IRQF_DISABLED - keep irqs disabled when calling the action handler
+ * IRQF_DISABLED - keep irqs disabled when calling the action handler.
+ *                 DEPRECATED. This flag is a NOOP and scheduled to be removed
 * IRQF_SAMPLE_RANDOM - irq is used to feed the random generator
 * IRQF_SHARED - allow sharing the irq among several devices
 * IRQF_PROBE_SHARED - set by callers when they expect sharing mismatches to occur
@@ -77,6 +78,18 @@ enum {
        IRQTF_AFFINITY,
 };
+/**
+ * These values can be returned by request_any_context_irq() and
+ * describe the context the interrupt will be run in.
+ *
+ * IRQC_IS_HARDIRQ - interrupt runs in hardirq context
+ * IRQC_IS_NESTED - interrupt runs in a nested threaded context
+ */
+enum {
+        IRQC_IS_HARDIRQ = 0,
+        IRQC_IS_NESTED,
+};
 typedef irqreturn_t (*irq_handler_t)(int, void *);
 /**
@@ -120,6 +133,10 @@ request_irq(unsigned int irq, irq_handler_t handler, unsigned long flags,
        return request_threaded_irq(irq, handler, NULL, flags, name, dev);
 }
+extern int __must_check
+request_any_context_irq(unsigned int irq, irq_handler_t handler,
+                        unsigned long flags, const char *name, void *dev_id);
 extern void exit_irq_thread(void);
 #else
@@ -141,6 +158,13 @@ request_threaded_irq(unsigned int irq, irq_handler_t handler,
        return request_irq(irq, handler, flags, name, dev);
 }
+static inline int __must_check
+request_any_context_irq(unsigned int irq, irq_handler_t handler,
+                        unsigned long flags, const char *name, void *dev_id)
+{
+        return request_irq(irq, handler, flags, name, dev_id);
+}
 static inline void exit_irq_thread(void) { }
 #endif
@@ -209,6 +233,7 @@ extern int irq_set_affinity(unsigned int irq, const struct cpumask *cpumask);
 extern int irq_can_set_affinity(unsigned int irq);
 extern int irq_select_affinity(unsigned int irq);
+extern int irq_set_affinity_hint(unsigned int irq, const struct cpumask *m);
 #else /* CONFIG_SMP */
 static inline int irq_set_affinity(unsigned int irq, const struct cpumask *m)
@@ -223,6 +248,11 @@ static inline int irq_can_set_affinity(unsigned int irq)
 static inline int irq_select_affinity(unsigned int irq)  { return 0; }
+static inline int irq_set_affinity_hint(unsigned int irq,
+                                        const struct cpumask *m)
+{
+        return -EINVAL;
+}
 #endif /* CONFIG_SMP && CONFIG_GENERIC_HARDIRQS */
 #ifdef CONFIG_GENERIC_HARDIRQS
diff --git a/include/linux/iommu.h b/include/linux/iommu.h
index 3af4ffd591b9..be22ad83689c 100644
--- a/include/linux/iommu.h
+++ b/include/linux/iommu.h
@@ -37,9 +37,9 @@ struct iommu_ops {
        int (*attach_dev)(struct iommu_domain *domain, struct device *dev);
        void (*detach_dev)(struct iommu_domain *domain, struct device *dev);
        int (*map)(struct iommu_domain *domain, unsigned long iova,
-                   phys_addr_t paddr, size_t size, int prot);
+                   phys_addr_t paddr, int gfp_order, int prot);
-        void (*unmap)(struct iommu_domain *domain, unsigned long iova,
+        int (*unmap)(struct iommu_domain *domain, unsigned long iova,
-                      size_t size);
+                     int gfp_order);
        phys_addr_t (*iova_to_phys)(struct iommu_domain *domain,
                                    unsigned long iova);
        int (*domain_has_cap)(struct iommu_domain *domain,
@@ -56,10 +56,10 @@ extern int iommu_attach_device(struct iommu_domain *domain,
                               struct device *dev);
 extern void iommu_detach_device(struct iommu_domain *domain,
                                struct device *dev);
-extern int iommu_map_range(struct iommu_domain *domain, unsigned long iova,
+extern int iommu_map(struct iommu_domain *domain, unsigned long iova,
-                           phys_addr_t paddr, size_t size, int prot);
+                     phys_addr_t paddr, int gfp_order, int prot);
-extern void iommu_unmap_range(struct iommu_domain *domain, unsigned long iova,
+extern int iommu_unmap(struct iommu_domain *domain, unsigned long iova,
-                              size_t size);
+                       int gfp_order);
 extern phys_addr_t iommu_iova_to_phys(struct iommu_domain *domain,
                                      unsigned long iova);
 extern int iommu_domain_has_cap(struct iommu_domain *domain,
@@ -96,16 +96,16 @@ static inline void iommu_detach_device(struct iommu_domain *domain,
 {
 }
-static inline int iommu_map_range(struct iommu_domain *domain,
+static inline int iommu_map(struct iommu_domain *domain, unsigned long iova,
-                                  unsigned long iova, phys_addr_t paddr,
+                            phys_addr_t paddr, int gfp_order, int prot)
-                                  size_t size, int prot)
 {
        return -ENODEV;
 }
-static inline void iommu_unmap_range(struct iommu_domain *domain,
+static inline int iommu_unmap(struct iommu_domain *domain, unsigned long iova,
-                                     unsigned long iova, size_t size)
+                              int gfp_order)
 {
+        return -ENODEV;
 }
 static inline phys_addr_t iommu_iova_to_phys(struct iommu_domain *domain,
diff --git a/include/linux/irq.h b/include/linux/irq.h
index 707ab122e2e6..c03243ad84b4 100644
--- a/include/linux/irq.h
+++ b/include/linux/irq.h
@@ -195,6 +195,7 @@ struct irq_desc {
        raw_spinlock_t          lock;
 #ifdef CONFIG_SMP
        cpumask_var_t           affinity;
+        const struct cpumask    *affinity_hint;
        unsigned int            node;
 #ifdef CONFIG_GENERIC_PENDING_IRQ
        cpumask_var_t           pending_mask;
diff --git a/include/linux/iscsi_ibft.h b/include/linux/iscsi_ibft.h
index 6092487e2950..d2e4042f8f5e 100644
--- a/include/linux/iscsi_ibft.h
+++ b/include/linux/iscsi_ibft.h
@@ -42,9 +42,13 @@ extern struct ibft_table_header *ibft_addr;
 * mapped address is set in the ibft_addr variable.
 */
 #ifdef CONFIG_ISCSI_IBFT_FIND
-extern void __init reserve_ibft_region(void);
+unsigned long find_ibft_region(unsigned long *sizep);
 #else
-static inline void reserve_ibft_region(void) { }
+static inline unsigned long find_ibft_region(unsigned long *sizep)
+{
+        *sizep = 0;
+        return 0;
+}
 #endif
 #endif /* ISCSI_IBFT_H */
diff --git a/include/linux/kernel.h b/include/linux/kernel.h
index 7f0707463360..9fb1c1299032 100644
--- a/include/linux/kernel.h
+++ b/include/linux/kernel.h
@@ -426,7 +426,7 @@ static inline char *pack_hex_byte(char *buf, u8 byte)
                .burst = DEFAULT_RATELIMIT_BURST,       \
        };                                              \
                                                        \
-        if (!__ratelimit(&_rs))                         \
+        if (__ratelimit(&_rs))                          \
                printk(fmt, ##__VA_ARGS__);             \
 })
 #else
@@ -490,6 +490,13 @@ static inline void tracing_off(void) { }
 static inline void tracing_off_permanent(void) { }
 static inline int tracing_is_on(void) { return 0; }
 #endif
+enum ftrace_dump_mode {
+        DUMP_NONE,
+        DUMP_ALL,
+        DUMP_ORIG,
+};
 #ifdef CONFIG_TRACING
 extern void tracing_start(void);
 extern void tracing_stop(void);
@@ -571,7 +578,7 @@ __ftrace_vbprintk(unsigned long ip, const char *fmt, va_list ap);
 extern int
 __ftrace_vprintk(unsigned long ip, const char *fmt, va_list ap);
-extern void ftrace_dump(void);
+extern void ftrace_dump(enum ftrace_dump_mode oops_dump_mode);
 #else
 static inline void
 ftrace_special(unsigned long arg1, unsigned long arg2, unsigned long arg3) { }
@@ -592,7 +599,7 @@ ftrace_vprintk(const char *fmt, va_list ap)
 {
        return 0;
 }
-static inline void ftrace_dump(void) { }
+static inline void ftrace_dump(enum ftrace_dump_mode oops_dump_mode) { }
 #endif /* CONFIG_TRACING */
 /*
diff --git a/include/linux/kfifo.h b/include/linux/kfifo.h
index ece0b1c33816..e117b1aee69c 100644
--- a/include/linux/kfifo.h
+++ b/include/linux/kfifo.h
@@ -86,7 +86,8 @@ union { \
 */
 #define INIT_KFIFO(name) \
        name = __kfifo_initializer(sizeof(name##kfifo_buffer) - \
-                                sizeof(struct kfifo), name##kfifo_buffer)
+                                sizeof(struct kfifo), \
+                                name##kfifo_buffer + sizeof(struct kfifo))
 /**
 * DEFINE_KFIFO - macro to define and initialize a kfifo
diff --git a/include/linux/ktime.h b/include/linux/ktime.h
index ce5983225be4..e1ceaa9b36bb 100644
--- a/include/linux/ktime.h
+++ b/include/linux/ktime.h
@@ -130,7 +130,7 @@ static inline ktime_t timeval_to_ktime(struct timeval tv)
 /* Convert ktime_t to nanoseconds - NOP in the scalar storage format: */
 #define ktime_to_ns(kt)                 ((kt).tv64)
-#else
+#else   /* !((BITS_PER_LONG == 64) || defined(CONFIG_KTIME_SCALAR)) */
 /*
 * Helper macros/inlines to get the ktime_t math right in the timespec
@@ -275,7 +275,7 @@ static inline s64 ktime_to_ns(const ktime_t kt)
        return (s64) kt.tv.sec * NSEC_PER_SEC + kt.tv.nsec;
 }
-#endif
+#endif  /* !((BITS_PER_LONG == 64) || defined(CONFIG_KTIME_SCALAR)) */
 /**
 * ktime_equal - Compares two ktime_t variables to see if they are equal
@@ -295,6 +295,12 @@ static inline s64 ktime_to_us(const ktime_t kt)
        return (s64) tv.tv_sec * USEC_PER_SEC + tv.tv_usec;
 }
+static inline s64 ktime_to_ms(const ktime_t kt)
+{
+        struct timeval tv = ktime_to_timeval(kt);
+        return (s64) tv.tv_sec * MSEC_PER_SEC + tv.tv_usec / USEC_PER_MSEC;
+}
 static inline s64 ktime_us_delta(const ktime_t later, const ktime_t earlier)
 {
       return ktime_to_us(ktime_sub(later, earlier));
diff --git a/include/linux/kvm_host.h b/include/linux/kvm_host.h
index a3fd0f91d943..169d07758ee5 100644
--- a/include/linux/kvm_host.h
+++ b/include/linux/kvm_host.h
@@ -54,7 +54,7 @@ extern struct kmem_cache *kvm_vcpu_cache;
 */
 struct kvm_io_bus {
        int                   dev_count;
-#define NR_IOBUS_DEVS 6
+#define NR_IOBUS_DEVS 200
        struct kvm_io_device *devs[NR_IOBUS_DEVS];
 };
@@ -119,6 +119,11 @@ struct kvm_memory_slot {
        int user_alloc;
 };
+static inline unsigned long kvm_dirty_bitmap_bytes(struct kvm_memory_slot *memslot)
+{
+        return ALIGN(memslot->npages, BITS_PER_LONG) / 8;
+}
 struct kvm_kernel_irq_routing_entry {
        u32 gsi;
        u32 type;
diff --git a/include/linux/lcm.h b/include/linux/lcm.h
new file mode 100644
index 000000000000..7bf01d779b45
--- /dev/null
+++ b/include/linux/lcm.h
@@ -0,0 +1,8 @@
+#ifndef _LCM_H
+#define _LCM_H
+#include <linux/compiler.h>
+unsigned long lcm(unsigned long a, unsigned long b) __attribute_const__;
+#endif /* _LCM_H */
diff --git a/include/linux/mm.h b/include/linux/mm.h
index e70f21beb4b4..fb19bb92b809 100644
--- a/include/linux/mm.h
+++ b/include/linux/mm.h
@@ -19,7 +19,6 @@ struct anon_vma;
 struct file_ra_state;
 struct user_struct;
 struct writeback_control;
-struct rlimit;
 #ifndef CONFIG_DISCONTIGMEM          /* Don't use mapnrs, do it properly */
 extern unsigned long max_mapnr;
@@ -783,8 +782,8 @@ struct mm_walk {
        int (*pmd_entry)(pmd_t *, unsigned long, unsigned long, struct mm_walk *);
        int (*pte_entry)(pte_t *, unsigned long, unsigned long, struct mm_walk *);
        int (*pte_hole)(unsigned long, unsigned long, struct mm_walk *);
-        int (*hugetlb_entry)(pte_t *, unsigned long, unsigned long,
+        int (*hugetlb_entry)(pte_t *, unsigned long,
-                             struct mm_walk *);
+                             unsigned long, unsigned long, struct mm_walk *);
        struct mm_struct *mm;
        void *private;
 };
@@ -1449,9 +1448,6 @@ int vmemmap_populate_basepages(struct page *start_page,
 int vmemmap_populate(struct page *start_page, unsigned long pages, int node);
 void vmemmap_populate_print_last(void);
-extern int account_locked_memory(struct mm_struct *mm, struct rlimit *rlim,
-                                 size_t size);
-extern void refund_locked_memory(struct mm_struct *mm, size_t size);
 enum mf_flags {
        MF_COUNT_INCREASED = 1 << 0,
diff --git a/include/linux/mod_devicetable.h b/include/linux/mod_devicetable.h
index f58e9d836f32..56fde4364e4c 100644
--- a/include/linux/mod_devicetable.h
+++ b/include/linux/mod_devicetable.h
@@ -474,4 +474,13 @@ struct platform_device_id {
                        __attribute__((aligned(sizeof(kernel_ulong_t))));
 };
+struct zorro_device_id {
+        __u32 id;                       /* Device ID or ZORRO_WILDCARD */
+        kernel_ulong_t driver_data;     /* Data private to the driver */
+};
+#define ZORRO_WILDCARD                  (0xffffffff)    /* not official */
+#define ZORRO_DEVICE_MODALIAS_FMT       "zorro:i%08X"
 #endif /* LINUX_MOD_DEVICETABLE_H */
diff --git a/include/linux/module.h b/include/linux/module.h
index 515d53ae6a79..6914fcad4673 100644
--- a/include/linux/module.h
+++ b/include/linux/module.h
@@ -465,8 +465,7 @@ static inline void __module_get(struct module *module)
        if (module) {
                preempt_disable();
                __this_cpu_inc(module->refptr->incs);
-                trace_module_get(module, _THIS_IP_,
+                trace_module_get(module, _THIS_IP_);
-                                 __this_cpu_read(module->refptr->incs));
                preempt_enable();
        }
 }
@@ -480,8 +479,7 @@ static inline int try_module_get(struct module *module)
                if (likely(module_is_live(module))) {
                        __this_cpu_inc(module->refptr->incs);
-                        trace_module_get(module, _THIS_IP_,
+                        trace_module_get(module, _THIS_IP_);
-                                __this_cpu_read(module->refptr->incs));
                } else
                        ret = 0;
diff --git a/include/linux/ncp_fs_sb.h b/include/linux/ncp_fs_sb.h
index 6330fc76b00f..5ec9ca671687 100644
--- a/include/linux/ncp_fs_sb.h
+++ b/include/linux/ncp_fs_sb.h
@@ -12,6 +12,7 @@
 #include <linux/ncp_mount.h>
 #include <linux/net.h>
 #include <linux/mutex.h>
+#include <linux/backing-dev.h>
 #ifdef __KERNEL__
@@ -127,6 +128,7 @@ struct ncp_server {
                size_t len;
                __u8 data[128];
        } unexpected_packet;
+        struct backing_dev_info bdi;
 };
 extern void ncp_tcp_rcv_proc(struct work_struct *work);
diff --git a/include/linux/nfs_fs.h b/include/linux/nfs_fs.h
index 1a0b85aa151e..77c2ae53431c 100644
--- a/include/linux/nfs_fs.h
+++ b/include/linux/nfs_fs.h
@@ -209,6 +209,7 @@ struct nfs_inode {
 #define NFS_INO_FLUSHING        (4)             /* inode is flushing out data */
 #define NFS_INO_FSCACHE         (5)             /* inode can be cached by FS-Cache */
 #define NFS_INO_FSCACHE_LOCK    (6)             /* FS-Cache cookie management lock */
+#define NFS_INO_COMMIT          (7)             /* inode is committing unstable writes */
 static inline struct nfs_inode *NFS_I(const struct inode *inode)
 {
@@ -355,6 +356,20 @@ extern struct nfs_open_context *nfs_find_open_context(struct inode *inode, struc
 extern u64 nfs_compat_user_ino64(u64 fileid);
 extern void nfs_fattr_init(struct nfs_fattr *fattr);
+extern struct nfs_fattr *nfs_alloc_fattr(void);
+static inline void nfs_free_fattr(const struct nfs_fattr *fattr)
+{
+        kfree(fattr);
+}
+extern struct nfs_fh *nfs_alloc_fhandle(void);
+static inline void nfs_free_fhandle(const struct nfs_fh *fh)
+{
+        kfree(fh);
+}
 /* linux/net/ipv4/ipconfig.c: trims ip addr off front of name, too. */
 extern __be32 root_nfs_parse_addr(char *name); /*__init*/
 extern unsigned long nfs_inc_attr_generation_counter(void);
diff --git a/include/linux/nfs_fs_sb.h b/include/linux/nfs_fs_sb.h
index 717a5e54eb1d..d6e10a4c06e5 100644
--- a/include/linux/nfs_fs_sb.h
+++ b/include/linux/nfs_fs_sb.h
@@ -44,7 +44,6 @@ struct nfs_client {
 #ifdef CONFIG_NFS_V4
        u64                     cl_clientid;    /* constant */
-        nfs4_verifier           cl_confirm;
        unsigned long           cl_state;
        struct rb_root          cl_openowner_id;
@@ -176,6 +175,7 @@ struct nfs_server {
 #define NFS_CAP_ATIME           (1U << 11)
 #define NFS_CAP_CTIME           (1U << 12)
 #define NFS_CAP_MTIME           (1U << 13)
+#define NFS_CAP_POSIX_LOCK      (1U << 14)
 /* maximum number of slots to use */
diff --git a/include/linux/nfs_xdr.h b/include/linux/nfs_xdr.h
index 89b28812ec24..51914d7d6cc4 100644
--- a/include/linux/nfs_xdr.h
+++ b/include/linux/nfs_xdr.h
@@ -386,8 +386,8 @@ struct nfs_removeargs {
 struct nfs_removeres {
        const struct nfs_server *server;
+        struct nfs_fattr        *dir_attr;
        struct nfs4_change_info cinfo;
-        struct nfs_fattr        dir_attr;
        struct nfs4_sequence_res        seq_res;
 };
@@ -824,6 +824,11 @@ struct nfs4_setclientid {
        u32                             sc_cb_ident;
 };
+struct nfs4_setclientid_res {
+        u64                             clientid;
+        nfs4_verifier                   confirm;
+};
 struct nfs4_statfs_arg {
        const struct nfs_fh *           fh;
        const u32 *                     bitmask;
diff --git a/include/linux/nfsd/nfsfh.h b/include/linux/nfsd/nfsfh.h
index 65e333afaee4..80d55bbc5365 100644
--- a/include/linux/nfsd/nfsfh.h
+++ b/include/linux/nfsd/nfsfh.h
@@ -40,12 +40,12 @@ struct nfs_fhbase_old {
 * This is the new flexible, extensible style NFSv2/v3 file handle.
 * by Neil Brown <neilb@cse.unsw.edu.au> - March 2000
 *
- * The file handle is seens as a list of 4byte words.
+ * The file handle starts with a sequence of four-byte words.
- * The first word contains a version number (1) and four descriptor bytes
+ * The first word contains a version number (1) and three descriptor bytes
 * that tell how the remaining 3 variable length fields should be handled.
 * These three bytes are auth_type, fsid_type and fileid_type.
 *
- * All 4byte values are in host-byte-order.
+ * All four-byte values are in host-byte-order.
 *
 * The auth_type field specifies how the filehandle can be authenticated
 * This might allow a file to be confirmed to be in a writable part of a
diff --git a/include/linux/page_cgroup.h b/include/linux/page_cgroup.h
index 30b08136fdf3..aef22ae2af47 100644
--- a/include/linux/page_cgroup.h
+++ b/include/linux/page_cgroup.h
@@ -39,6 +39,7 @@ enum {
        PCG_CACHE, /* charged as cache */
        PCG_USED, /* this object is in use. */
        PCG_ACCT_LRU, /* page has been accounted for */
+        PCG_FILE_MAPPED, /* page is accounted as "mapped" */
 };
 #define TESTPCGFLAG(uname, lname)                       \
@@ -73,6 +74,11 @@ CLEARPCGFLAG(AcctLRU, ACCT_LRU)
 TESTPCGFLAG(AcctLRU, ACCT_LRU)
 TESTCLEARPCGFLAG(AcctLRU, ACCT_LRU)
+SETPCGFLAG(FileMapped, FILE_MAPPED)
+CLEARPCGFLAG(FileMapped, FILE_MAPPED)
+TESTPCGFLAG(FileMapped, FILE_MAPPED)
 static inline int page_cgroup_nid(struct page_cgroup *pc)
 {
        return page_to_nid(pc->page);
diff --git a/include/linux/perf_event.h b/include/linux/perf_event.h
index c8e375440403..3fd5c82e0e18 100644
--- a/include/linux/perf_event.h
+++ b/include/linux/perf_event.h
@@ -203,8 +203,19 @@ struct perf_event_attr {
                                enable_on_exec :  1, /* next exec enables     */
                                task           :  1, /* trace fork/exit       */
                                watermark      :  1, /* wakeup_watermark      */
+                                /*
-                                __reserved_1   : 49;
+                                 * precise_ip:
+                                 *
+                                 *  0 - SAMPLE_IP can have arbitrary skid
+                                 *  1 - SAMPLE_IP must have constant skid
+                                 *  2 - SAMPLE_IP requested to have 0 skid
+                                 *  3 - SAMPLE_IP must have 0 skid
+                                 *
+                                 *  See also PERF_RECORD_MISC_EXACT_IP
+                                 */
+                                precise_ip     :  2, /* skid constraint       */
+                                __reserved_1   : 47;
        union {
                __u32           wakeup_events;    /* wakeup every n events */
@@ -287,11 +298,24 @@ struct perf_event_mmap_page {
        __u64   data_tail;              /* user-space written tail */
 };
-#define PERF_RECORD_MISC_CPUMODE_MASK           (3 << 0)
+#define PERF_RECORD_MISC_CPUMODE_MASK           (7 << 0)
 #define PERF_RECORD_MISC_CPUMODE_UNKNOWN        (0 << 0)
 #define PERF_RECORD_MISC_KERNEL                 (1 << 0)
 #define PERF_RECORD_MISC_USER                   (2 << 0)
 #define PERF_RECORD_MISC_HYPERVISOR             (3 << 0)
+#define PERF_RECORD_MISC_GUEST_KERNEL           (4 << 0)
+#define PERF_RECORD_MISC_GUEST_USER             (5 << 0)
+/*
+ * Indicates that the content of PERF_SAMPLE_IP points to
+ * the actual instruction that triggered the event. See also
+ * perf_event_attr::precise_ip.
+ */
+#define PERF_RECORD_MISC_EXACT_IP               (1 << 14)
+/*
+ * Reserve the last bit to indicate some extended misc field
+ */
+#define PERF_RECORD_MISC_EXT_RESERVED           (1 << 15)
 struct perf_event_header {
        __u32   type;
@@ -439,6 +463,12 @@ enum perf_callchain_context {
 # include <asm/perf_event.h>
 #endif
+struct perf_guest_info_callbacks {
+        int (*is_in_guest) (void);
+        int (*is_user_mode) (void);
+        unsigned long (*get_guest_ip) (void);
+};
 #ifdef CONFIG_HAVE_HW_BREAKPOINT
 #include <asm/hw_breakpoint.h>
 #endif
@@ -468,6 +498,17 @@ struct perf_raw_record {
        void                            *data;
 };
+struct perf_branch_entry {
+        __u64                           from;
+        __u64                           to;
+        __u64                           flags;
+};
+struct perf_branch_stack {
+        __u64                           nr;
+        struct perf_branch_entry        entries[0];
+};
 struct task_struct;
 /**
@@ -506,6 +547,8 @@ struct hw_perf_event {
 struct perf_event;
+#define PERF_EVENT_TXN_STARTED 1
 /**
 * struct pmu - generic performance monitoring unit
 */
@@ -516,6 +559,16 @@ struct pmu {
        void (*stop)                    (struct perf_event *event);
        void (*read)                    (struct perf_event *event);
        void (*unthrottle)              (struct perf_event *event);
+        /*
+         * group events scheduling is treated as a transaction,
+         * add group events as a whole and perform one schedulability test.
+         * If test fails, roll back the whole group
+         */
+        void (*start_txn)       (const struct pmu *pmu);
+        void (*cancel_txn)      (const struct pmu *pmu);
+        int  (*commit_txn)      (const struct pmu *pmu);
 };
 /**
@@ -571,6 +624,14 @@ enum perf_group_flag {
        PERF_GROUP_SOFTWARE = 0x1,
 };
+#define SWEVENT_HLIST_BITS      8
+#define SWEVENT_HLIST_SIZE      (1 << SWEVENT_HLIST_BITS)
+struct swevent_hlist {
+        struct hlist_head       heads[SWEVENT_HLIST_SIZE];
+        struct rcu_head         rcu_head;
+};
 /**
 * struct perf_event - performance event kernel representation:
 */
@@ -579,6 +640,7 @@ struct perf_event {
        struct list_head                group_entry;
        struct list_head                event_entry;
        struct list_head                sibling_list;
+        struct hlist_node               hlist_entry;
        int                             nr_siblings;
        int                             group_flags;
        struct perf_event               *group_leader;
@@ -726,6 +788,9 @@ struct perf_cpu_context {
        int                             active_oncpu;
        int                             max_pertask;
        int                             exclusive;
+        struct swevent_hlist            *swevent_hlist;
+        struct mutex                    hlist_mutex;
+        int                             hlist_refcount;
        /*
         * Recursion avoidance:
@@ -769,9 +834,6 @@ extern void perf_disable(void);
 extern void perf_enable(void);
 extern int perf_event_task_disable(void);
 extern int perf_event_task_enable(void);
-extern int hw_perf_group_sched_in(struct perf_event *group_leader,
-               struct perf_cpu_context *cpuctx,
-               struct perf_event_context *ctx);
 extern void perf_event_update_userpage(struct perf_event *event);
 extern int perf_event_release_kernel(struct perf_event *event);
 extern struct perf_event *
@@ -902,6 +964,10 @@ static inline void perf_event_mmap(struct vm_area_struct *vma)
                __perf_event_mmap(vma);
 }
+extern struct perf_guest_info_callbacks *perf_guest_cbs;
+extern int perf_register_guest_info_callbacks(struct perf_guest_info_callbacks *callbacks);
+extern int perf_unregister_guest_info_callbacks(struct perf_guest_info_callbacks *callbacks);
 extern void perf_event_comm(struct task_struct *tsk);
 extern void perf_event_fork(struct task_struct *tsk);
@@ -971,6 +1037,11 @@ perf_sw_event(u32 event_id, u64 nr, int nmi,
 static inline void
 perf_bp_event(struct perf_event *event, void *data)                     { }
+static inline int perf_register_guest_info_callbacks
+(struct perf_guest_info_callbacks *callbacks) { return 0; }
+static inline int perf_unregister_guest_info_callbacks
+(struct perf_guest_info_callbacks *callbacks) { return 0; }
 static inline void perf_event_mmap(struct vm_area_struct *vma)          { }
 static inline void perf_event_comm(struct task_struct *tsk)             { }
 static inline void perf_event_fork(struct task_struct *tsk)             { }
diff --git a/include/linux/platform_device.h b/include/linux/platform_device.h
index 212da17d06af..5417944d3687 100644
--- a/include/linux/platform_device.h
+++ b/include/linux/platform_device.h
@@ -44,12 +44,14 @@ extern int platform_get_irq_byname(struct platform_device *, const char *);
 extern int platform_add_devices(struct platform_device **, int);
 extern struct platform_device *platform_device_register_simple(const char *, int id,
-                                        struct resource *, unsigned int);
+                                        const struct resource *, unsigned int);
 extern struct platform_device *platform_device_register_data(struct device *,
                const char *, int, const void *, size_t);
 extern struct platform_device *platform_device_alloc(const char *name, int id);
-extern int platform_device_add_resources(struct platform_device *pdev, struct resource *res, unsigned int num);
+extern int platform_device_add_resources(struct platform_device *pdev,
+                                         const struct resource *res,
+                                         unsigned int num);
 extern int platform_device_add_data(struct platform_device *pdev, const void *data, size_t size);
 extern int platform_device_add(struct platform_device *pdev);
 extern void platform_device_del(struct platform_device *pdev);
diff --git a/include/linux/poison.h b/include/linux/poison.h
index 2110a81c5e2a..34066ffd893d 100644
--- a/include/linux/poison.h
+++ b/include/linux/poison.h
@@ -48,6 +48,15 @@
 #define POISON_FREE     0x6b    /* for use-after-free poisoning */
 #define POISON_END      0xa5    /* end-byte of poisoning */
+/********** mm/hugetlb.c **********/
+/*
+ * Private mappings of hugetlb pages use this poisoned value for
+ * page->mapping. The core VM should not be doing anything with this mapping
+ * but futex requires the existence of some page->mapping value even though it
+ * is unused if PAGE_MAPPING_ANON is set.
+ */
+#define HUGETLB_POISON  ((void *)(0x00300300 + POISON_POINTER_DELTA + PAGE_MAPPING_ANON))
 /********** arch/$ARCH/mm/init.c **********/
 #define POISON_FREE_INITMEM     0xcc
diff --git a/include/linux/ptrace.h b/include/linux/ptrace.h
index e1fb60729979..4272521e29e9 100644
--- a/include/linux/ptrace.h
+++ b/include/linux/ptrace.h
@@ -345,18 +345,6 @@ static inline void user_single_step_siginfo(struct task_struct *tsk,
 #define arch_ptrace_stop(code, info)            do { } while (0)
 #endif
-#ifndef arch_ptrace_untrace
-/*
- * Do machine-specific work before untracing child.
- *
- * This is called for a normal detach as well as from ptrace_exit()
- * when the tracing task dies.
- *
- * Called with write_lock(&tasklist_lock) held.
- */
-#define arch_ptrace_untrace(task)               do { } while (0)
-#endif
 extern int task_current_syscall(struct task_struct *target, long *callno,
                                unsigned long args[6], unsigned int maxargs,
                                unsigned long *sp, unsigned long *pc);
diff --git a/include/linux/radix-tree.h b/include/linux/radix-tree.h
index c5da74918096..55ca73cf25e5 100644
--- a/include/linux/radix-tree.h
+++ b/include/linux/radix-tree.h
@@ -121,6 +121,13 @@ do {									\
 * (Note, rcu_assign_pointer and rcu_dereference are not needed to control
 * access to data items when inserting into or looking up from the radix tree)
 *
+ * Note that the value returned by radix_tree_tag_get() may not be relied upon
+ * if only the RCU read lock is held.  Functions to set/clear tags and to
+ * delete nodes running concurrently with it may affect its result such that
+ * two consecutive reads in the same locked section may return different
+ * values.  If reliability is required, modification functions must also be
+ * excluded from concurrency.
+ *
 * radix_tree_tagged is able to be called without locking or RCU.
 */
diff --git a/include/linux/rbtree.h b/include/linux/rbtree.h
index 5210a5c60877..fe1872e5b37e 100644
--- a/include/linux/rbtree.h
+++ b/include/linux/rbtree.h
@@ -110,6 +110,7 @@ struct rb_node
 struct rb_root
 {
        struct rb_node *rb_node;
+        void (*augment_cb)(struct rb_node *node);
 };
@@ -129,7 +130,9 @@ static inline void rb_set_color(struct rb_node *rb, int color)
        rb->rb_parent_color = (rb->rb_parent_color & ~1) | color;
 }
-#define RB_ROOT (struct rb_root) { NULL, }
+#define RB_ROOT (struct rb_root) { NULL, NULL, }
+#define RB_AUGMENT_ROOT(x)      (struct rb_root) { NULL, x}
 #define rb_entry(ptr, type, member) container_of(ptr, type, member)
 #define RB_EMPTY_ROOT(root)     ((root)->rb_node == NULL)
diff --git a/include/linux/rcupdate.h b/include/linux/rcupdate.h
index 872a98e13d6a..b653b4aaa8a6 100644
--- a/include/linux/rcupdate.h
+++ b/include/linux/rcupdate.h
@@ -56,8 +56,6 @@ struct rcu_head {
 };
 /* Exported common interfaces */
-extern void synchronize_rcu_bh(void);
-extern void synchronize_sched(void);
 extern void rcu_barrier(void);
 extern void rcu_barrier_bh(void);
 extern void rcu_barrier_sched(void);
@@ -66,8 +64,6 @@ extern int sched_expedited_torture_stats(char *page);
 /* Internal to kernel */
 extern void rcu_init(void);
-extern int rcu_scheduler_active;
-extern void rcu_scheduler_starting(void);
 #if defined(CONFIG_TREE_RCU) || defined(CONFIG_TREE_PREEMPT_RCU)
 #include <linux/rcutree.h>
@@ -83,6 +79,14 @@ extern void rcu_scheduler_starting(void);
       (ptr)->next = NULL; (ptr)->func = NULL; \
 } while (0)
+static inline void init_rcu_head_on_stack(struct rcu_head *head)
+{
+}
+static inline void destroy_rcu_head_on_stack(struct rcu_head *head)
+{
+}
 #ifdef CONFIG_DEBUG_LOCK_ALLOC
 extern struct lockdep_map rcu_lock_map;
@@ -101,20 +105,18 @@ extern struct lockdep_map rcu_sched_lock_map;
 # define rcu_read_release_sched() \
                lock_release(&rcu_sched_lock_map, 1, _THIS_IP_)
-static inline int debug_lockdep_rcu_enabled(void)
+extern int debug_lockdep_rcu_enabled(void);
-{
-        return likely(rcu_scheduler_active && debug_locks);
-}
 /**
 * rcu_read_lock_held - might we be in RCU read-side critical section?
 *
- * If CONFIG_PROVE_LOCKING is selected and enabled, returns nonzero iff in
+ * If CONFIG_DEBUG_LOCK_ALLOC is selected, returns nonzero iff in an RCU
- * an RCU read-side critical section.  In absence of CONFIG_PROVE_LOCKING,
+ * read-side critical section.  In absence of CONFIG_DEBUG_LOCK_ALLOC,
 * this assumes we are in an RCU read-side critical section unless it can
 * prove otherwise.
 *
- * Check rcu_scheduler_active to prevent false positives during boot.
+ * Check debug_lockdep_rcu_enabled() to prevent false positives during boot
+ * and while lockdep is disabled.
 */
 static inline int rcu_read_lock_held(void)
 {
@@ -132,13 +134,15 @@ extern int rcu_read_lock_bh_held(void);
 /**
 * rcu_read_lock_sched_held - might we be in RCU-sched read-side critical section?
 *
- * If CONFIG_PROVE_LOCKING is selected and enabled, returns nonzero iff in an
+ * If CONFIG_DEBUG_LOCK_ALLOC is selected, returns nonzero iff in an
- * RCU-sched read-side critical section.  In absence of CONFIG_PROVE_LOCKING,
+ * RCU-sched read-side critical section.  In absence of
- * this assumes we are in an RCU-sched read-side critical section unless it
+ * CONFIG_DEBUG_LOCK_ALLOC, this assumes we are in an RCU-sched read-side
- * can prove otherwise.  Note that disabling of preemption (including
+ * critical section unless it can prove otherwise.  Note that disabling
- * disabling irqs) counts as an RCU-sched read-side critical section.
+ * of preemption (including disabling irqs) counts as an RCU-sched
+ * read-side critical section.
 *
- * Check rcu_scheduler_active to prevent false positives during boot.
+ * Check debug_lockdep_rcu_enabled() to prevent false positives during boot
+ * and while lockdep is disabled.
 */
 #ifdef CONFIG_PREEMPT
 static inline int rcu_read_lock_sched_held(void)
@@ -180,7 +184,7 @@ static inline int rcu_read_lock_bh_held(void)
 #ifdef CONFIG_PREEMPT
 static inline int rcu_read_lock_sched_held(void)
 {
-        return !rcu_scheduler_active || preempt_count() != 0 || irqs_disabled();
+        return preempt_count() != 0 || irqs_disabled();
 }
 #else /* #ifdef CONFIG_PREEMPT */
 static inline int rcu_read_lock_sched_held(void)
@@ -193,29 +197,88 @@ static inline int rcu_read_lock_sched_held(void)
 #ifdef CONFIG_PROVE_RCU
+extern int rcu_my_thread_group_empty(void);
+#define __do_rcu_dereference_check(c)                                   \
+        do {                                                            \
+                static bool __warned;                                   \
+                if (debug_lockdep_rcu_enabled() && !__warned && !(c)) { \
+                        __warned = true;                                \
+                        lockdep_rcu_dereference(__FILE__, __LINE__);    \
+                }                                                       \
+        } while (0)
 /**
 * rcu_dereference_check - rcu_dereference with debug checking
+ * @p: The pointer to read, prior to dereferencing
+ * @c: The conditions under which the dereference will take place
+ *
+ * Do an rcu_dereference(), but check that the conditions under which the
+ * dereference will take place are correct.  Typically the conditions indicate
+ * the various locking conditions that should be held at that point.  The check
+ * should return true if the conditions are satisfied.
+ *
+ * For example:
+ *
+ *      bar = rcu_dereference_check(foo->bar, rcu_read_lock_held() ||
+ *                                            lockdep_is_held(&foo->lock));
 *
- * Do an rcu_dereference(), but check that the context is correct.
+ * could be used to indicate to lockdep that foo->bar may only be dereferenced
- * For example, rcu_dereference_check(gp, rcu_read_lock_held()) to
+ * if either the RCU read lock is held, or that the lock required to replace
- * ensure that the rcu_dereference_check() executes within an RCU
+ * the bar struct at foo->bar is held.
- * read-side critical section.  It is also possible to check for
+ *
- * locks being held, for example, by using lockdep_is_held().
+ * Note that the list of conditions may also include indications of when a lock
+ * need not be held, for example during initialisation or destruction of the
+ * target struct:
+ *
+ *      bar = rcu_dereference_check(foo->bar, rcu_read_lock_held() ||
+ *                                            lockdep_is_held(&foo->lock) ||
+ *                                            atomic_read(&foo->usage) == 0);
 */
 #define rcu_dereference_check(p, c) \
        ({ \
-                if (debug_lockdep_rcu_enabled() && !(c)) \
+                __do_rcu_dereference_check(c); \
-                        lockdep_rcu_dereference(__FILE__, __LINE__); \
                rcu_dereference_raw(p); \
        })
+/**
+ * rcu_dereference_protected - fetch RCU pointer when updates prevented
+ *
+ * Return the value of the specified RCU-protected pointer, but omit
+ * both the smp_read_barrier_depends() and the ACCESS_ONCE().  This
+ * is useful in cases where update-side locks prevent the value of the
+ * pointer from changing.  Please note that this primitive does -not-
+ * prevent the compiler from repeating this reference or combining it
+ * with other references, so it should not be used without protection
+ * of appropriate locks.
+ */
+#define rcu_dereference_protected(p, c) \
+        ({ \
+                __do_rcu_dereference_check(c); \
+                (p); \
+        })
 #else /* #ifdef CONFIG_PROVE_RCU */
 #define rcu_dereference_check(p, c)     rcu_dereference_raw(p)
+#define rcu_dereference_protected(p, c) (p)
 #endif /* #else #ifdef CONFIG_PROVE_RCU */
 /**
+ * rcu_access_pointer - fetch RCU pointer with no dereferencing
+ *
+ * Return the value of the specified RCU-protected pointer, but omit the
+ * smp_read_barrier_depends() and keep the ACCESS_ONCE().  This is useful
+ * when the value of this pointer is accessed, but the pointer is not
+ * dereferenced, for example, when testing an RCU-protected pointer against
+ * NULL.  This may also be used in cases where update-side locks prevent
+ * the value of the pointer from changing, but rcu_dereference_protected()
+ * is a lighter-weight primitive for this use case.
+ */
+#define rcu_access_pointer(p)   ACCESS_ONCE(p)
+/**
 * rcu_read_lock - mark the beginning of an RCU read-side critical section.
 *
 * When synchronize_rcu() is invoked on one CPU while other CPUs
diff --git a/include/linux/rcutiny.h b/include/linux/rcutiny.h
index a5195875480a..e2e893144a84 100644
--- a/include/linux/rcutiny.h
+++ b/include/linux/rcutiny.h
@@ -29,6 +29,10 @@
 void rcu_sched_qs(int cpu);
 void rcu_bh_qs(int cpu);
+static inline void rcu_note_context_switch(int cpu)
+{
+        rcu_sched_qs(cpu);
+}
 #define __rcu_read_lock()       preempt_disable()
 #define __rcu_read_unlock()     preempt_enable()
@@ -60,8 +64,6 @@ static inline long rcu_batches_completed_bh(void)
        return 0;
 }
-extern int rcu_expedited_torture_stats(char *page);
 static inline void rcu_force_quiescent_state(void)
 {
 }
@@ -74,7 +76,17 @@ static inline void rcu_sched_force_quiescent_state(void)
 {
 }
-#define synchronize_rcu synchronize_sched
+extern void synchronize_sched(void);
+static inline void synchronize_rcu(void)
+{
+        synchronize_sched();
+}
+static inline void synchronize_rcu_bh(void)
+{
+        synchronize_sched();
+}
 static inline void synchronize_rcu_expedited(void)
 {
@@ -114,4 +126,17 @@ static inline int rcu_preempt_depth(void)
        return 0;
 }
+#ifdef CONFIG_DEBUG_LOCK_ALLOC
+extern int rcu_scheduler_active __read_mostly;
+extern void rcu_scheduler_starting(void);
+#else /* #ifdef CONFIG_DEBUG_LOCK_ALLOC */
+static inline void rcu_scheduler_starting(void)
+{
+}
+#endif /* #else #ifdef CONFIG_DEBUG_LOCK_ALLOC */
 #endif /* __LINUX_RCUTINY_H */
diff --git a/include/linux/rcutree.h b/include/linux/rcutree.h
index 42cc3a04779e..c0ed1c056f29 100644
--- a/include/linux/rcutree.h
+++ b/include/linux/rcutree.h
@@ -34,8 +34,8 @@ struct notifier_block;
 extern void rcu_sched_qs(int cpu);
 extern void rcu_bh_qs(int cpu);
+extern void rcu_note_context_switch(int cpu);
 extern int rcu_needs_cpu(int cpu);
-extern int rcu_expedited_torture_stats(char *page);
 #ifdef CONFIG_TREE_PREEMPT_RCU
@@ -86,6 +86,8 @@ static inline void __rcu_read_unlock_bh(void)
 extern void call_rcu_sched(struct rcu_head *head,
                           void (*func)(struct rcu_head *rcu));
+extern void synchronize_rcu_bh(void);
+extern void synchronize_sched(void);
 extern void synchronize_rcu_expedited(void);
 static inline void synchronize_rcu_bh_expedited(void)
@@ -120,4 +122,7 @@ static inline int rcu_blocking_is_gp(void)
        return num_online_cpus() == 1;
 }
+extern void rcu_scheduler_starting(void);
+extern int rcu_scheduler_active __read_mostly;
 #endif /* __LINUX_RCUTREE_H */
diff --git a/include/linux/regulator/consumer.h b/include/linux/regulator/consumer.h
index 28c9fd020d39..ebd747265294 100644
--- a/include/linux/regulator/consumer.h
+++ b/include/linux/regulator/consumer.h
@@ -183,9 +183,13 @@ static inline struct regulator *__must_check regulator_get(struct device *dev,
 {
        /* Nothing except the stubbed out regulator API should be
         * looking at the value except to check if it is an error
-         * value so the actual return value doesn't matter.
+         * value. Drivers are free to handle NULL specifically by
+         * skipping all regulator API calls, but they don't have to.
+         * Drivers which don't, should make sure they properly handle
+         * corner cases of the API, such as regulator_get_voltage()
+         * returning 0.
         */
-        return (struct regulator *)id;
+        return NULL;
 }
 static inline void regulator_put(struct regulator *regulator)
 {
diff --git a/include/linux/ring_buffer.h b/include/linux/ring_buffer.h
index 5fcc31ed5771..25b4f686d918 100644
--- a/include/linux/ring_buffer.h
+++ b/include/linux/ring_buffer.h
@@ -120,12 +120,16 @@ int ring_buffer_write(struct ring_buffer *buffer,
                      unsigned long length, void *data);
 struct ring_buffer_event *
-ring_buffer_peek(struct ring_buffer *buffer, int cpu, u64 *ts);
+ring_buffer_peek(struct ring_buffer *buffer, int cpu, u64 *ts,
+                 unsigned long *lost_events);
 struct ring_buffer_event *
-ring_buffer_consume(struct ring_buffer *buffer, int cpu, u64 *ts);
+ring_buffer_consume(struct ring_buffer *buffer, int cpu, u64 *ts,
+                    unsigned long *lost_events);
 struct ring_buffer_iter *
-ring_buffer_read_start(struct ring_buffer *buffer, int cpu);
+ring_buffer_read_prepare(struct ring_buffer *buffer, int cpu);
+void ring_buffer_read_prepare_sync(void);
+void ring_buffer_read_start(struct ring_buffer_iter *iter);
 void ring_buffer_read_finish(struct ring_buffer_iter *iter);
 struct ring_buffer_event *
diff --git a/include/linux/sched.h b/include/linux/sched.h
index dad7f668ebf7..b55e988988b5 100644
--- a/include/linux/sched.h
+++ b/include/linux/sched.h
@@ -99,7 +99,6 @@ struct futex_pi_state;
 struct robust_list_head;
 struct bio_list;
 struct fs_struct;
-struct bts_context;
 struct perf_event_context;
 /*
@@ -275,11 +274,17 @@ extern cpumask_var_t nohz_cpu_mask;
 #if defined(CONFIG_SMP) && defined(CONFIG_NO_HZ)
 extern int select_nohz_load_balancer(int cpu);
 extern int get_nohz_load_balancer(void);
+extern int nohz_ratelimit(int cpu);
 #else
 static inline int select_nohz_load_balancer(int cpu)
 {
        return 0;
 }
+static inline int nohz_ratelimit(int cpu)
+{
+        return 0;
+}
 #endif
 /*
@@ -954,6 +959,7 @@ struct sched_domain {
        char *name;
 #endif
+        unsigned int span_weight;
        /*
         * Span of all CPUs in this domain.
         *
@@ -1026,12 +1032,17 @@ struct sched_domain;
 #define WF_SYNC         0x01            /* waker goes to sleep after wakup */
 #define WF_FORK         0x02            /* child wakeup after fork */
+#define ENQUEUE_WAKEUP          1
+#define ENQUEUE_WAKING          2
+#define ENQUEUE_HEAD            4
+#define DEQUEUE_SLEEP           1
 struct sched_class {
        const struct sched_class *next;
-        void (*enqueue_task) (struct rq *rq, struct task_struct *p, int wakeup,
+        void (*enqueue_task) (struct rq *rq, struct task_struct *p, int flags);
-                              bool head);
+        void (*dequeue_task) (struct rq *rq, struct task_struct *p, int flags);
-        void (*dequeue_task) (struct rq *rq, struct task_struct *p, int sleep);
        void (*yield_task) (struct rq *rq);
        void (*check_preempt_curr) (struct rq *rq, struct task_struct *p, int flags);
@@ -1040,7 +1051,8 @@ struct sched_class {
        void (*put_prev_task) (struct rq *rq, struct task_struct *p);
 #ifdef CONFIG_SMP
-        int  (*select_task_rq)(struct task_struct *p, int sd_flag, int flags);
+        int  (*select_task_rq)(struct rq *rq, struct task_struct *p,
+                               int sd_flag, int flags);
        void (*pre_schedule) (struct rq *this_rq, struct task_struct *task);
        void (*post_schedule) (struct rq *this_rq);
@@ -1077,36 +1089,8 @@ struct load_weight {
        unsigned long weight, inv_weight;
 };
-/*
- * CFS stats for a schedulable entity (task, task-group etc)
- *
- * Current field usage histogram:
- *
- *     4 se->block_start
- *     4 se->run_node
- *     4 se->sleep_start
- *     6 se->load.weight
- */
-struct sched_entity {
-        struct load_weight      load;           /* for load-balancing */
-        struct rb_node          run_node;
-        struct list_head        group_node;
-        unsigned int            on_rq;
-        u64                     exec_start;
-        u64                     sum_exec_runtime;
-        u64                     vruntime;
-        u64                     prev_sum_exec_runtime;
-        u64                     last_wakeup;
-        u64                     avg_overlap;
-        u64                     nr_migrations;
-        u64                     start_runtime;
-        u64                     avg_wakeup;
 #ifdef CONFIG_SCHEDSTATS
+struct sched_statistics {
        u64                     wait_start;
        u64                     wait_max;
        u64                     wait_count;
@@ -1138,6 +1122,24 @@ struct sched_entity {
        u64                     nr_wakeups_affine_attempts;
        u64                     nr_wakeups_passive;
        u64                     nr_wakeups_idle;
+};
+#endif
+struct sched_entity {
+        struct load_weight      load;           /* for load-balancing */
+        struct rb_node          run_node;
+        struct list_head        group_node;
+        unsigned int            on_rq;
+        u64                     exec_start;
+        u64                     sum_exec_runtime;
+        u64                     vruntime;
+        u64                     prev_sum_exec_runtime;
+        u64                     nr_migrations;
+#ifdef CONFIG_SCHEDSTATS
+        struct sched_statistics statistics;
 #endif
 #ifdef CONFIG_FAIR_GROUP_SCHED
@@ -1272,12 +1274,6 @@ struct task_struct {
        struct list_head ptraced;
        struct list_head ptrace_entry;
-        /*
-         * This is the tracer handle for the ptrace BTS extension.
-         * This field actually belongs to the ptracer task.
-         */
-        struct bts_context *bts;
        /* PID/PID hash table linkage. */
        struct pid_link pids[PIDTYPE_MAX];
        struct list_head thread_group;
@@ -1497,7 +1493,6 @@ struct task_struct {
        /* bitmask of trace recursion */
        unsigned long trace_recursion;
 #endif /* CONFIG_TRACING */
-        unsigned long stack_start;
 #ifdef CONFIG_CGROUP_MEM_RES_CTLR /* memcg uses this to do batch job */
        struct memcg_batch_info {
                int do_batch;   /* incremented when batch uncharge started */
@@ -1847,6 +1842,7 @@ extern void sched_clock_idle_sleep_event(void);
 extern void sched_clock_idle_wakeup_event(u64 delta_ns);
 #ifdef CONFIG_HOTPLUG_CPU
+extern void move_task_off_dead_cpu(int dead_cpu, struct task_struct *p);
 extern void idle_task_exit(void);
 #else
 static inline void idle_task_exit(void) {}
@@ -2123,10 +2119,8 @@ extern void set_task_comm(struct task_struct *tsk, char *from);
 extern char *get_task_comm(char *to, struct task_struct *tsk);
 #ifdef CONFIG_SMP
-extern void wait_task_context_switch(struct task_struct *p);
 extern unsigned long wait_task_inactive(struct task_struct *, long match_state);
 #else
-static inline void wait_task_context_switch(struct task_struct *p) {}
 static inline unsigned long wait_task_inactive(struct task_struct *p,
                                               long match_state)
 {
diff --git a/include/linux/sh_clk.h b/include/linux/sh_clk.h
new file mode 100644
index 000000000000..1636d1e2a5f1
--- /dev/null
+++ b/include/linux/sh_clk.h
@@ -0,0 +1,150 @@
+#ifndef __SH_CLOCK_H
+#define __SH_CLOCK_H
+#include <linux/list.h>
+#include <linux/seq_file.h>
+#include <linux/cpufreq.h>
+#include <linux/clk.h>
+#include <linux/err.h>
+struct clk;
+struct clk_ops {
+        void (*init)(struct clk *clk);
+        int (*enable)(struct clk *clk);
+        void (*disable)(struct clk *clk);
+        unsigned long (*recalc)(struct clk *clk);
+        int (*set_rate)(struct clk *clk, unsigned long rate, int algo_id);
+        int (*set_parent)(struct clk *clk, struct clk *parent);
+        long (*round_rate)(struct clk *clk, unsigned long rate);
+};
+struct clk {
+        struct list_head        node;
+        const char              *name;
+        int                     id;
+        struct clk              *parent;
+        struct clk_ops          *ops;
+        struct list_head        children;
+        struct list_head        sibling;        /* node for children */
+        int                     usecount;
+        unsigned long           rate;
+        unsigned long           flags;
+        void __iomem            *enable_reg;
+        unsigned int            enable_bit;
+        unsigned long           arch_flags;
+        void                    *priv;
+        struct dentry           *dentry;
+        struct cpufreq_frequency_table *freq_table;
+};
+#define CLK_ENABLE_ON_INIT      (1 << 0)
+/* drivers/sh/clk.c */
+unsigned long followparent_recalc(struct clk *);
+void recalculate_root_clocks(void);
+void propagate_rate(struct clk *);
+int clk_reparent(struct clk *child, struct clk *parent);
+int clk_register(struct clk *);
+void clk_unregister(struct clk *);
+void clk_enable_init_clocks(void);
+/**
+ * clk_set_rate_ex - set the clock rate for a clock source, with additional parameter
+ * @clk: clock source
+ * @rate: desired clock rate in Hz
+ * @algo_id: algorithm id to be passed down to ops->set_rate
+ *
+ * Returns success (0) or negative errno.
+ */
+int clk_set_rate_ex(struct clk *clk, unsigned long rate, int algo_id);
+enum clk_sh_algo_id {
+        NO_CHANGE = 0,
+        IUS_N1_N1,
+        IUS_322,
+        IUS_522,
+        IUS_N11,
+        SB_N1,
+        SB3_N1,
+        SB3_32,
+        SB3_43,
+        SB3_54,
+        BP_N1,
+        IP_N1,
+};
+struct clk_div_mult_table {
+        unsigned int *divisors;
+        unsigned int nr_divisors;
+        unsigned int *multipliers;
+        unsigned int nr_multipliers;
+};
+struct cpufreq_frequency_table;
+void clk_rate_table_build(struct clk *clk,
+                          struct cpufreq_frequency_table *freq_table,
+                          int nr_freqs,
+                          struct clk_div_mult_table *src_table,
+                          unsigned long *bitmap);
+long clk_rate_table_round(struct clk *clk,
+                          struct cpufreq_frequency_table *freq_table,
+                          unsigned long rate);
+int clk_rate_table_find(struct clk *clk,
+                        struct cpufreq_frequency_table *freq_table,
+                        unsigned long rate);
+#define SH_CLK_MSTP32(_parent, _enable_reg, _enable_bit, _flags)        \
+{                                                                       \
+        .parent         = _parent,                                      \
+        .enable_reg     = (void __iomem *)_enable_reg,                  \
+        .enable_bit     = _enable_bit,                                  \
+        .flags          = _flags,                                       \
+}
+int sh_clk_mstp32_register(struct clk *clks, int nr);
+#define SH_CLK_DIV4(_parent, _reg, _shift, _div_bitmap, _flags) \
+{                                                               \
+        .parent = _parent,                                      \
+        .enable_reg = (void __iomem *)_reg,                     \
+        .enable_bit = _shift,                                   \
+        .arch_flags = _div_bitmap,                              \
+        .flags = _flags,                                        \
+}
+struct clk_div4_table {
+        struct clk_div_mult_table *div_mult_table;
+        void (*kick)(struct clk *clk);
+};
+int sh_clk_div4_register(struct clk *clks, int nr,
+                         struct clk_div4_table *table);
+int sh_clk_div4_enable_register(struct clk *clks, int nr,
+                         struct clk_div4_table *table);
+int sh_clk_div4_reparent_register(struct clk *clks, int nr,
+                         struct clk_div4_table *table);
+#define SH_CLK_DIV6(_parent, _reg, _flags)      \
+{                                               \
+        .parent = _parent,                      \
+        .enable_reg = (void __iomem *)_reg,     \
+        .flags = _flags,                        \
+}
+int sh_clk_div6_register(struct clk *clks, int nr);
+#endif /* __SH_CLOCK_H */
diff --git a/include/linux/sh_dma.h b/include/linux/sh_dma.h
index cdaaff424211..b08cd4efa15c 100644
--- a/include/linux/sh_dma.h
+++ b/include/linux/sh_dma.h
@@ -17,7 +17,7 @@
 struct sh_dmae_slave {
        unsigned int                    slave_id; /* Set by the platform */
        struct device                   *dma_dev; /* Set by the platform */
-        struct sh_dmae_slave_config     *config;  /* Set by the driver */
+        const struct sh_dmae_slave_config       *config;  /* Set by the driver */
 };
 struct sh_dmae_regs {
@@ -36,6 +36,7 @@ struct sh_desc {
        int chunks;
        int mark;
 };
 struct sh_dmae_slave_config {
        unsigned int                    slave_id;
        dma_addr_t                      addr;
@@ -50,15 +51,15 @@ struct sh_dmae_channel {
 };
 struct sh_dmae_pdata {
-        struct sh_dmae_slave_config *slave;
+        const struct sh_dmae_slave_config *slave;
        int slave_num;
-        struct sh_dmae_channel *channel;
+        const struct sh_dmae_channel *channel;
        int channel_num;
        unsigned int ts_low_shift;
        unsigned int ts_low_mask;
        unsigned int ts_high_shift;
        unsigned int ts_high_mask;
-        unsigned int *ts_shift;
+        const unsigned int *ts_shift;
        int ts_shift_num;
        u16 dmaor_init;
 };
diff --git a/include/linux/sh_intc.h b/include/linux/sh_intc.h
index 01d8168c5a1b..0d6cd38e673d 100644
--- a/include/linux/sh_intc.h
+++ b/include/linux/sh_intc.h
@@ -23,6 +23,9 @@ struct intc_group {
 struct intc_mask_reg {
        unsigned long set_reg, clr_reg, reg_width;
        intc_enum enum_ids[32];
+#ifdef CONFIG_INTC_BALANCING
+        unsigned long dist_reg;
+#endif
 #ifdef CONFIG_SMP
        unsigned long smp;
 #endif
@@ -41,8 +44,14 @@ struct intc_sense_reg {
        intc_enum enum_ids[16];
 };
+#ifdef CONFIG_INTC_BALANCING
+#define INTC_SMP_BALANCING(reg) .dist_reg = (reg)
+#else
+#define INTC_SMP_BALANCING(reg)
+#endif
 #ifdef CONFIG_SMP
-#define INTC_SMP(stride, nr) .smp = (stride) | ((nr) << 8)
+#define INTC_SMP(stride, nr)    .smp = (stride) | ((nr) << 8)
 #else
 #define INTC_SMP(stride, nr)
 #endif
@@ -99,6 +108,15 @@ struct intc_desc symbol __initdata = {					\
 int __init register_intc_controller(struct intc_desc *desc);
 int intc_set_priority(unsigned int irq, unsigned int prio);
+#ifdef CONFIG_INTC_USERIMASK
+int register_intc_userimask(unsigned long addr);
+#else
+static inline int register_intc_userimask(unsigned long addr)
+{
+        return 0;
+}
+#endif
 int reserve_irq_vector(unsigned int irq);
 void reserve_irq_legacy(void);
diff --git a/include/linux/slab.h b/include/linux/slab.h
index 488446289cab..49d1247cd6d9 100644
--- a/include/linux/slab.h
+++ b/include/linux/slab.h
@@ -106,6 +106,7 @@ int kmem_cache_shrink(struct kmem_cache *);
 void kmem_cache_free(struct kmem_cache *, void *);
 unsigned int kmem_cache_size(struct kmem_cache *);
 const char *kmem_cache_name(struct kmem_cache *);
+int kern_ptr_validate(const void *ptr, unsigned long size);
 int kmem_ptr_validate(struct kmem_cache *cachep, const void *ptr);
 /*
diff --git a/include/linux/smb_fs_sb.h b/include/linux/smb_fs_sb.h
index 8a060a7040d8..bb947dd1fba9 100644
--- a/include/linux/smb_fs_sb.h
+++ b/include/linux/smb_fs_sb.h
@@ -10,6 +10,7 @@
 #define _SMB_FS_SB
 #include <linux/types.h>
+#include <linux/backing-dev.h>
 #include <linux/smb.h>
 /*
@@ -74,6 +75,8 @@ struct smb_sb_info {
        struct smb_ops *ops;
        struct super_block *super_block;
+        struct backing_dev_info bdi;
 };
 static inline int
diff --git a/include/linux/srcu.h b/include/linux/srcu.h
index 4d5ecb222af9..4d5d2f546dbf 100644
--- a/include/linux/srcu.h
+++ b/include/linux/srcu.h
@@ -27,6 +27,8 @@
 #ifndef _LINUX_SRCU_H
 #define _LINUX_SRCU_H
+#include <linux/mutex.h>
 struct srcu_struct_array {
        int c[2];
 };
@@ -84,8 +86,8 @@ long srcu_batches_completed(struct srcu_struct *sp);
 /**
 * srcu_read_lock_held - might we be in SRCU read-side critical section?
 *
- * If CONFIG_PROVE_LOCKING is selected and enabled, returns nonzero iff in
+ * If CONFIG_DEBUG_LOCK_ALLOC is selected, returns nonzero iff in an SRCU
- * an SRCU read-side critical section.  In absence of CONFIG_PROVE_LOCKING,
+ * read-side critical section.  In absence of CONFIG_DEBUG_LOCK_ALLOC,
 * this assumes we are in an SRCU read-side critical section unless it can
 * prove otherwise.
 */
diff --git a/include/linux/stop_machine.h b/include/linux/stop_machine.h
index baba3a23a814..6b524a0d02e4 100644
--- a/include/linux/stop_machine.h
+++ b/include/linux/stop_machine.h
@@ -1,13 +1,101 @@
 #ifndef _LINUX_STOP_MACHINE
 #define _LINUX_STOP_MACHINE
-/* "Bogolock": stop the entire machine, disable interrupts.  This is a
-   very heavy lock, which is equivalent to grabbing every spinlock
-   (and more).  So the "read" side to such a lock is anything which
-   disables preeempt. */
 #include <linux/cpu.h>
 #include <linux/cpumask.h>
+#include <linux/list.h>
 #include <asm/system.h>
+/*
+ * stop_cpu[s]() is simplistic per-cpu maximum priority cpu
+ * monopolization mechanism.  The caller can specify a non-sleeping
+ * function to be executed on a single or multiple cpus preempting all
+ * other processes and monopolizing those cpus until it finishes.
+ *
+ * Resources for this mechanism are preallocated when a cpu is brought
+ * up and requests are guaranteed to be served as long as the target
+ * cpus are online.
+ */
+typedef int (*cpu_stop_fn_t)(void *arg);
+#ifdef CONFIG_SMP
+struct cpu_stop_work {
+        struct list_head        list;           /* cpu_stopper->works */
+        cpu_stop_fn_t           fn;
+        void                    *arg;
+        struct cpu_stop_done    *done;
+};
+int stop_one_cpu(unsigned int cpu, cpu_stop_fn_t fn, void *arg);
+void stop_one_cpu_nowait(unsigned int cpu, cpu_stop_fn_t fn, void *arg,
+                         struct cpu_stop_work *work_buf);
+int stop_cpus(const struct cpumask *cpumask, cpu_stop_fn_t fn, void *arg);
+int try_stop_cpus(const struct cpumask *cpumask, cpu_stop_fn_t fn, void *arg);
+#else   /* CONFIG_SMP */
+#include <linux/workqueue.h>
+struct cpu_stop_work {
+        struct work_struct      work;
+        cpu_stop_fn_t           fn;
+        void                    *arg;
+};
+static inline int stop_one_cpu(unsigned int cpu, cpu_stop_fn_t fn, void *arg)
+{
+        int ret = -ENOENT;
+        preempt_disable();
+        if (cpu == smp_processor_id())
+                ret = fn(arg);
+        preempt_enable();
+        return ret;
+}
+static void stop_one_cpu_nowait_workfn(struct work_struct *work)
+{
+        struct cpu_stop_work *stwork =
+                container_of(work, struct cpu_stop_work, work);
+        preempt_disable();
+        stwork->fn(stwork->arg);
+        preempt_enable();
+}
+static inline void stop_one_cpu_nowait(unsigned int cpu,
+                                       cpu_stop_fn_t fn, void *arg,
+                                       struct cpu_stop_work *work_buf)
+{
+        if (cpu == smp_processor_id()) {
+                INIT_WORK(&work_buf->work, stop_one_cpu_nowait_workfn);
+                work_buf->fn = fn;
+                work_buf->arg = arg;
+                schedule_work(&work_buf->work);
+        }
+}
+static inline int stop_cpus(const struct cpumask *cpumask,
+                            cpu_stop_fn_t fn, void *arg)
+{
+        if (cpumask_test_cpu(raw_smp_processor_id(), cpumask))
+                return stop_one_cpu(raw_smp_processor_id(), fn, arg);
+        return -ENOENT;
+}
+static inline int try_stop_cpus(const struct cpumask *cpumask,
+                                cpu_stop_fn_t fn, void *arg)
+{
+        return stop_cpus(cpumask, fn, arg);
+}
+#endif  /* CONFIG_SMP */
+/*
+ * stop_machine "Bogolock": stop the entire machine, disable
+ * interrupts.  This is a very heavy lock, which is equivalent to
+ * grabbing every spinlock (and more).  So the "read" side to such a
+ * lock is anything which disables preeempt.
+ */
 #if defined(CONFIG_STOP_MACHINE) && defined(CONFIG_SMP)
 /**
@@ -36,24 +124,7 @@ int stop_machine(int (*fn)(void *), void *data, const struct cpumask *cpus);
 */
 int __stop_machine(int (*fn)(void *), void *data, const struct cpumask *cpus);
-/**
+#else    /* CONFIG_STOP_MACHINE && CONFIG_SMP */
- * stop_machine_create: create all stop_machine threads
- *
- * Description: This causes all stop_machine threads to be created before
- * stop_machine actually gets called. This can be used by subsystems that
- * need a non failing stop_machine infrastructure.
- */
-int stop_machine_create(void);
-/**
- * stop_machine_destroy: destroy all stop_machine threads
- *
- * Description: This causes all stop_machine threads which were created with
- * stop_machine_create to be destroyed again.
- */
-void stop_machine_destroy(void);
-#else
 static inline int stop_machine(int (*fn)(void *), void *data,
                               const struct cpumask *cpus)
@@ -65,8 +136,5 @@ static inline int stop_machine(int (*fn)(void *), void *data,
        return ret;
 }
-static inline int stop_machine_create(void) { return 0; }
+#endif  /* CONFIG_STOP_MACHINE && CONFIG_SMP */
-static inline void stop_machine_destroy(void) { }
+#endif  /* _LINUX_STOP_MACHINE */
-#endif /* CONFIG_SMP */
-#endif /* _LINUX_STOP_MACHINE */
diff --git a/include/linux/sunrpc/auth.h b/include/linux/sunrpc/auth.h
index 996df4dac7d4..87d7ec0bf779 100644
--- a/include/linux/sunrpc/auth.h
+++ b/include/linux/sunrpc/auth.h
@@ -54,6 +54,7 @@ struct rpc_cred {
 #define RPCAUTH_CRED_NEW        0
 #define RPCAUTH_CRED_UPTODATE   1
 #define RPCAUTH_CRED_HASHED     2
+#define RPCAUTH_CRED_NEGATIVE   3
 #define RPCAUTH_CRED_MAGIC      0x0f4aa4f0
diff --git a/include/linux/sunrpc/auth_gss.h b/include/linux/sunrpc/auth_gss.h
index d48d4e605f74..671538d25bc1 100644
--- a/include/linux/sunrpc/auth_gss.h
+++ b/include/linux/sunrpc/auth_gss.h
@@ -82,6 +82,7 @@ struct gss_cred {
        enum rpc_gss_svc        gc_service;
        struct gss_cl_ctx       *gc_ctx;
        struct gss_upcall_msg   *gc_upcall;
+        unsigned long           gc_upcall_timestamp;
        unsigned char           gc_machine_cred : 1;
 };
diff --git a/include/linux/sunrpc/gss_api.h b/include/linux/sunrpc/gss_api.h
index 03f33330ece2..5d8048beb051 100644
--- a/include/linux/sunrpc/gss_api.h
+++ b/include/linux/sunrpc/gss_api.h
@@ -35,7 +35,8 @@ int gss_import_sec_context(
                const void*             input_token,
                size_t                  bufsize,
                struct gss_api_mech     *mech,
-                struct gss_ctx          **ctx_id);
+                struct gss_ctx          **ctx_id,
+                gfp_t                   gfp_mask);
 u32 gss_get_mic(
                struct gss_ctx          *ctx_id,
                struct xdr_buf          *message,
@@ -80,6 +81,8 @@ struct gss_api_mech {
        /* pseudoflavors supported by this mechanism: */
        int                     gm_pf_num;
        struct pf_desc *        gm_pfs;
+        /* Should the following be a callback operation instead? */
+        const char              *gm_upcall_enctypes;
 };
 /* and must provide the following operations: */
@@ -87,7 +90,8 @@ struct gss_api_ops {
        int (*gss_import_sec_context)(
                        const void              *input_token,
                        size_t                  bufsize,
-                        struct gss_ctx          *ctx_id);
+                        struct gss_ctx          *ctx_id,
+                        gfp_t                   gfp_mask);
        u32 (*gss_get_mic)(
                        struct gss_ctx          *ctx_id,
                        struct xdr_buf          *message,
diff --git a/include/linux/sunrpc/gss_krb5.h b/include/linux/sunrpc/gss_krb5.h
index e7bbdba474d5..5af2931cf58d 100644
--- a/include/linux/sunrpc/gss_krb5.h
+++ b/include/linux/sunrpc/gss_krb5.h
@@ -4,7 +4,7 @@
 *  Adapted from MIT Kerberos 5-1.2.1 lib/include/krb5.h,
 *  lib/gssapi/krb5/gssapiP_krb5.h, and others
 *
- *  Copyright (c) 2000 The Regents of the University of Michigan.
+ *  Copyright (c) 2000-2008 The Regents of the University of Michigan.
 *  All rights reserved.
 *
 *  Andy Adamson   <andros@umich.edu>
@@ -36,17 +36,86 @@
 *
 */
+#include <linux/crypto.h>
 #include <linux/sunrpc/auth_gss.h>
 #include <linux/sunrpc/gss_err.h>
 #include <linux/sunrpc/gss_asn1.h>
+/* Length of constant used in key derivation */
+#define GSS_KRB5_K5CLENGTH (5)
+/* Maximum key length (in bytes) for the supported crypto algorithms*/
+#define GSS_KRB5_MAX_KEYLEN (32)
+/* Maximum checksum function output for the supported crypto algorithms */
+#define GSS_KRB5_MAX_CKSUM_LEN  (20)
+/* Maximum blocksize for the supported crypto algorithms */
+#define GSS_KRB5_MAX_BLOCKSIZE  (16)
+struct krb5_ctx;
+struct gss_krb5_enctype {
+        const u32               etype;          /* encryption (key) type */
+        const u32               ctype;          /* checksum type */
+        const char              *name;          /* "friendly" name */
+        const char              *encrypt_name;  /* crypto encrypt name */
+        const char              *cksum_name;    /* crypto checksum name */
+        const u16               signalg;        /* signing algorithm */
+        const u16               sealalg;        /* sealing algorithm */
+        const u32               blocksize;      /* encryption blocksize */
+        const u32               conflen;        /* confounder length
+                                                   (normally the same as
+                                                   the blocksize) */
+        const u32               cksumlength;    /* checksum length */
+        const u32               keyed_cksum;    /* is it a keyed cksum? */
+        const u32               keybytes;       /* raw key len, in bytes */
+        const u32               keylength;      /* final key len, in bytes */
+        u32 (*encrypt) (struct crypto_blkcipher *tfm,
+                        void *iv, void *in, void *out,
+                        int length);            /* encryption function */
+        u32 (*decrypt) (struct crypto_blkcipher *tfm,
+                        void *iv, void *in, void *out,
+                        int length);            /* decryption function */
+        u32 (*mk_key) (const struct gss_krb5_enctype *gk5e,
+                       struct xdr_netobj *in,
+                       struct xdr_netobj *out); /* complete key generation */
+        u32 (*encrypt_v2) (struct krb5_ctx *kctx, u32 offset,
+                           struct xdr_buf *buf, int ec,
+                           struct page **pages); /* v2 encryption function */
+        u32 (*decrypt_v2) (struct krb5_ctx *kctx, u32 offset,
+                           struct xdr_buf *buf, u32 *headskip,
+                           u32 *tailskip);      /* v2 decryption function */
+};
+/* krb5_ctx flags definitions */
+#define KRB5_CTX_FLAG_INITIATOR         0x00000001
+#define KRB5_CTX_FLAG_CFX               0x00000002
+#define KRB5_CTX_FLAG_ACCEPTOR_SUBKEY   0x00000004
 struct krb5_ctx {
        int                     initiate; /* 1 = initiating, 0 = accepting */
+        u32                     enctype;
+        u32                     flags;
+        const struct gss_krb5_enctype *gk5e; /* enctype-specific info */
        struct crypto_blkcipher *enc;
        struct crypto_blkcipher *seq;
+        struct crypto_blkcipher *acceptor_enc;
+        struct crypto_blkcipher *initiator_enc;
+        struct crypto_blkcipher *acceptor_enc_aux;
+        struct crypto_blkcipher *initiator_enc_aux;
+        u8                      Ksess[GSS_KRB5_MAX_KEYLEN]; /* session key */
+        u8                      cksum[GSS_KRB5_MAX_KEYLEN];
        s32                     endtime;
        u32                     seq_send;
+        u64                     seq_send64;
        struct xdr_netobj       mech_used;
+        u8                      initiator_sign[GSS_KRB5_MAX_KEYLEN];
+        u8                      acceptor_sign[GSS_KRB5_MAX_KEYLEN];
+        u8                      initiator_seal[GSS_KRB5_MAX_KEYLEN];
+        u8                      acceptor_seal[GSS_KRB5_MAX_KEYLEN];
+        u8                      initiator_integ[GSS_KRB5_MAX_KEYLEN];
+        u8                      acceptor_integ[GSS_KRB5_MAX_KEYLEN];
 };
 extern spinlock_t krb5_seq_lock;
@@ -57,6 +126,18 @@ extern spinlock_t krb5_seq_lock;
 #define KG_TOK_MIC_MSG    0x0101
 #define KG_TOK_WRAP_MSG   0x0201
+#define KG2_TOK_INITIAL     0x0101
+#define KG2_TOK_RESPONSE    0x0202
+#define KG2_TOK_MIC         0x0404
+#define KG2_TOK_WRAP        0x0504
+#define KG2_TOKEN_FLAG_SENTBYACCEPTOR   0x01
+#define KG2_TOKEN_FLAG_SEALED           0x02
+#define KG2_TOKEN_FLAG_ACCEPTORSUBKEY   0x04
+#define KG2_RESP_FLAG_ERROR             0x0001
+#define KG2_RESP_FLAG_DELEG_OK          0x0002
 enum sgn_alg {
        SGN_ALG_DES_MAC_MD5 = 0x0000,
        SGN_ALG_MD2_5 = 0x0001,
@@ -81,6 +162,9 @@ enum seal_alg {
 #define CKSUMTYPE_RSA_MD5_DES           0x0008
 #define CKSUMTYPE_NIST_SHA              0x0009
 #define CKSUMTYPE_HMAC_SHA1_DES3        0x000c
+#define CKSUMTYPE_HMAC_SHA1_96_AES128   0x000f
+#define CKSUMTYPE_HMAC_SHA1_96_AES256   0x0010
+#define CKSUMTYPE_HMAC_MD5_ARCFOUR      -138 /* Microsoft md5 hmac cksumtype */
 /* from gssapi_err_krb5.h */
 #define KG_CCACHE_NOMATCH                        (39756032L)
@@ -111,11 +195,56 @@ enum seal_alg {
 #define ENCTYPE_DES3_CBC_RAW    0x0006  /* DES-3 cbc mode raw */
 #define ENCTYPE_DES_HMAC_SHA1   0x0008
 #define ENCTYPE_DES3_CBC_SHA1   0x0010
+#define ENCTYPE_AES128_CTS_HMAC_SHA1_96 0x0011
+#define ENCTYPE_AES256_CTS_HMAC_SHA1_96 0x0012
+#define ENCTYPE_ARCFOUR_HMAC            0x0017
+#define ENCTYPE_ARCFOUR_HMAC_EXP        0x0018
 #define ENCTYPE_UNKNOWN         0x01ff
-s32
+/*
-make_checksum(char *, char *header, int hdrlen, struct xdr_buf *body,
+ * Constants used for key derivation
-                   int body_offset, struct xdr_netobj *cksum);
+ */
+/* for 3DES */
+#define KG_USAGE_SEAL (22)
+#define KG_USAGE_SIGN (23)
+#define KG_USAGE_SEQ  (24)
+/* from rfc3961 */
+#define KEY_USAGE_SEED_CHECKSUM         (0x99)
+#define KEY_USAGE_SEED_ENCRYPTION       (0xAA)
+#define KEY_USAGE_SEED_INTEGRITY        (0x55)
+/* from rfc4121 */
+#define KG_USAGE_ACCEPTOR_SEAL  (22)
+#define KG_USAGE_ACCEPTOR_SIGN  (23)
+#define KG_USAGE_INITIATOR_SEAL (24)
+#define KG_USAGE_INITIATOR_SIGN (25)
+/*
+ * This compile-time check verifies that we will not exceed the
+ * slack space allotted by the client and server auth_gss code
+ * before they call gss_wrap().
+ */
+#define GSS_KRB5_MAX_SLACK_NEEDED \
+        (GSS_KRB5_TOK_HDR_LEN     /* gss token header */         \
+        + GSS_KRB5_MAX_CKSUM_LEN  /* gss token checksum */       \
+        + GSS_KRB5_MAX_BLOCKSIZE  /* confounder */               \
+        + GSS_KRB5_MAX_BLOCKSIZE  /* possible padding */         \
+        + GSS_KRB5_TOK_HDR_LEN    /* encrypted hdr in v2 token */\
+        + GSS_KRB5_MAX_CKSUM_LEN  /* encryption hmac */          \
+        + 4 + 4                   /* RPC verifier */             \
+        + GSS_KRB5_TOK_HDR_LEN                                   \
+        + GSS_KRB5_MAX_CKSUM_LEN)
+u32
+make_checksum(struct krb5_ctx *kctx, char *header, int hdrlen,
+                struct xdr_buf *body, int body_offset, u8 *cksumkey,
+                unsigned int usage, struct xdr_netobj *cksumout);
+u32
+make_checksum_v2(struct krb5_ctx *, char *header, int hdrlen,
+                 struct xdr_buf *body, int body_offset, u8 *key,
+                 unsigned int usage, struct xdr_netobj *cksum);
 u32 gss_get_mic_kerberos(struct gss_ctx *, struct xdr_buf *,
                struct xdr_netobj *);
@@ -149,11 +278,54 @@ gss_decrypt_xdr_buf(struct crypto_blkcipher *tfm, struct xdr_buf *inbuf,
                    int offset);
 s32
-krb5_make_seq_num(struct crypto_blkcipher *key,
+krb5_make_seq_num(struct krb5_ctx *kctx,
+                struct crypto_blkcipher *key,
                int direction,
                u32 seqnum, unsigned char *cksum, unsigned char *buf);
 s32
-krb5_get_seq_num(struct crypto_blkcipher *key,
+krb5_get_seq_num(struct krb5_ctx *kctx,
               unsigned char *cksum,
               unsigned char *buf, int *direction, u32 *seqnum);
+int
+xdr_extend_head(struct xdr_buf *buf, unsigned int base, unsigned int shiftlen);
+u32
+krb5_derive_key(const struct gss_krb5_enctype *gk5e,
+                const struct xdr_netobj *inkey,
+                struct xdr_netobj *outkey,
+                const struct xdr_netobj *in_constant,
+                gfp_t gfp_mask);
+u32
+gss_krb5_des3_make_key(const struct gss_krb5_enctype *gk5e,
+                       struct xdr_netobj *randombits,
+                       struct xdr_netobj *key);
+u32
+gss_krb5_aes_make_key(const struct gss_krb5_enctype *gk5e,
+                      struct xdr_netobj *randombits,
+                      struct xdr_netobj *key);
+u32
+gss_krb5_aes_encrypt(struct krb5_ctx *kctx, u32 offset,
+                     struct xdr_buf *buf, int ec,
+                     struct page **pages);
+u32
+gss_krb5_aes_decrypt(struct krb5_ctx *kctx, u32 offset,
+                     struct xdr_buf *buf, u32 *plainoffset,
+                     u32 *plainlen);
+int
+krb5_rc4_setup_seq_key(struct krb5_ctx *kctx,
+                       struct crypto_blkcipher *cipher,
+                       unsigned char *cksum);
+int
+krb5_rc4_setup_enc_key(struct krb5_ctx *kctx,
+                       struct crypto_blkcipher *cipher,
+                       s32 seqnum);
+void
+gss_krb5_make_confounder(char *p, u32 conflen);
diff --git a/include/linux/sunrpc/metrics.h b/include/linux/sunrpc/metrics.h
index 77f78e56c481..b6edbc0ea83d 100644
--- a/include/linux/sunrpc/metrics.h
+++ b/include/linux/sunrpc/metrics.h
@@ -26,6 +26,7 @@
 #define _LINUX_SUNRPC_METRICS_H
 #include <linux/seq_file.h>
+#include <linux/ktime.h>
 #define RPC_IOSTATS_VERS        "1.0"
@@ -58,9 +59,9 @@ struct rpc_iostats {
         * and the total time the request spent from init to release
         * are measured.
         */
-        unsigned long long      om_queue,       /* jiffies queued for xmit */
+        ktime_t                 om_queue,       /* queued for xmit */
-                                om_rtt,         /* jiffies for RPC RTT */
+                                om_rtt,         /* RPC RTT */
-                                om_execute;     /* jiffies for RPC execution */
+                                om_execute;     /* RPC execution */
 } ____cacheline_aligned;
 struct rpc_task;
diff --git a/include/linux/sunrpc/sched.h b/include/linux/sunrpc/sched.h
index 7bc7fd5291ce..7be4f3a6d246 100644
--- a/include/linux/sunrpc/sched.h
+++ b/include/linux/sunrpc/sched.h
@@ -10,6 +10,7 @@
 #define _LINUX_SUNRPC_SCHED_H_
 #include <linux/timer.h>
+#include <linux/ktime.h>
 #include <linux/sunrpc/types.h>
 #include <linux/spinlock.h>
 #include <linux/wait.h>
@@ -40,21 +41,15 @@ struct rpc_wait {
 * This is the RPC task struct
 */
 struct rpc_task {
-#ifdef RPC_DEBUG
-        unsigned long           tk_magic;       /* 0xf00baa */
-#endif
        atomic_t                tk_count;       /* Reference count */
        struct list_head        tk_task;        /* global list of tasks */
        struct rpc_clnt *       tk_client;      /* RPC client */
        struct rpc_rqst *       tk_rqstp;       /* RPC request */
-        int                     tk_status;      /* result of last operation */
        /*
         * RPC call state
         */
        struct rpc_message      tk_msg;         /* RPC call info */
-        __u8                    tk_garb_retry;
-        __u8                    tk_cred_retry;
        /*
         * callback     to be executed after waking up
@@ -67,7 +62,6 @@ struct rpc_task {
        void *                  tk_calldata;
        unsigned long           tk_timeout;     /* timeout for rpc_sleep() */
-        unsigned short          tk_flags;       /* misc flags */
        unsigned long           tk_runstate;    /* Task run status */
        struct workqueue_struct *tk_workqueue;  /* Normally rpciod, but could
                                                 * be any workqueue
@@ -78,17 +72,19 @@ struct rpc_task {
                struct rpc_wait         tk_wait;        /* RPC wait */
        } u;
-        unsigned short          tk_timeouts;    /* maj timeouts */
+        ktime_t                 tk_start;       /* RPC task init timestamp */
-        size_t                  tk_bytes_sent;  /* total bytes sent */
-        unsigned long           tk_start;       /* RPC task init timestamp */
-        long                    tk_rtt;         /* round-trip time (jiffies) */
        pid_t                   tk_owner;       /* Process id for batching tasks */
-        unsigned char           tk_priority : 2;/* Task priority */
+        int                     tk_status;      /* result of last operation */
+        unsigned short          tk_flags;       /* misc flags */
+        unsigned short          tk_timeouts;    /* maj timeouts */
 #ifdef RPC_DEBUG
        unsigned short          tk_pid;         /* debugging aid */
 #endif
+        unsigned char           tk_priority : 2,/* Task priority */
+                                tk_garb_retry : 2,
+                                tk_cred_retry : 2;
 };
 #define tk_xprt                 tk_client->cl_xprt
diff --git a/include/linux/sunrpc/xdr.h b/include/linux/sunrpc/xdr.h
index f5cc0898bc53..35cf2e8cd7c6 100644
--- a/include/linux/sunrpc/xdr.h
+++ b/include/linux/sunrpc/xdr.h
@@ -1,7 +1,10 @@
 /*
- * include/linux/sunrpc/xdr.h
+ * XDR standard data types and function declarations
 *
 * Copyright (C) 1995-1997 Olaf Kirch <okir@monad.swb.de>
+ *
+ * Based on:
+ *   RFC 4506 "XDR: External Data Representation Standard", May 2006
 */
 #ifndef _SUNRPC_XDR_H_
@@ -62,7 +65,6 @@ struct xdr_buf {
        unsigned int    buflen,         /* Total length of storage buffer */
                        len;            /* Length of XDR encoded message */
 };
 /*
@@ -178,7 +180,7 @@ struct xdr_array2_desc {
 };
 extern int xdr_decode_array2(struct xdr_buf *buf, unsigned int base,
-                             struct xdr_array2_desc *desc);
+                             struct xdr_array2_desc *desc);
 extern int xdr_encode_array2(struct xdr_buf *buf, unsigned int base,
                             struct xdr_array2_desc *desc);
diff --git a/include/linux/sunrpc/xprt.h b/include/linux/sunrpc/xprt.h
index 6f9457a75b8f..b51470302399 100644
--- a/include/linux/sunrpc/xprt.h
+++ b/include/linux/sunrpc/xprt.h
@@ -13,6 +13,7 @@
 #include <linux/socket.h>
 #include <linux/in.h>
 #include <linux/kref.h>
+#include <linux/ktime.h>
 #include <linux/sunrpc/sched.h>
 #include <linux/sunrpc/xdr.h>
 #include <linux/sunrpc/msg_prot.h>
@@ -65,8 +66,6 @@ struct rpc_rqst {
        struct rpc_task *       rq_task;        /* RPC task data */
        __be32                  rq_xid;         /* request XID */
        int                     rq_cong;        /* has incremented xprt->cong */
-        int                     rq_reply_bytes_recvd;   /* number of reply */
-                                                        /* bytes received */
        u32                     rq_seqno;       /* gss seq no. used on req. */
        int                     rq_enc_pages_num;
        struct page             **rq_enc_pages; /* scratch pages for use by
@@ -77,12 +76,16 @@ struct rpc_rqst {
        __u32 *                 rq_buffer;      /* XDR encode buffer */
        size_t                  rq_callsize,
                                rq_rcvsize;
+        size_t                  rq_xmit_bytes_sent;     /* total bytes sent */
+        size_t                  rq_reply_bytes_recvd;   /* total reply bytes */
+                                                        /* received */
        struct xdr_buf          rq_private_buf;         /* The receive buffer
                                                         * used in the softirq.
                                                         */
        unsigned long           rq_majortimeo;  /* major timeout alarm */
        unsigned long           rq_timeout;     /* Current timeout value */
+        ktime_t                 rq_rtt;         /* round-trip time */
        unsigned int            rq_retries;     /* # of retries */
        unsigned int            rq_connect_cookie;
                                                /* A cookie used to track the
@@ -94,7 +97,7 @@ struct rpc_rqst {
         */
        u32                     rq_bytes_sent;  /* Bytes we have sent */
-        unsigned long           rq_xtime;       /* when transmitted */
+        ktime_t                 rq_xtime;       /* transmit time stamp */
        int                     rq_ntrans;
 #if defined(CONFIG_NFS_V4_1)
@@ -174,8 +177,7 @@ struct rpc_xprt {
        /*
         * Connection of transports
         */
-        unsigned long           connect_timeout,
+        unsigned long           bind_timeout,
-                                bind_timeout,
                                reestablish_timeout;
        unsigned int            connect_cookie; /* A cookie that gets bumped
                                                   every time the transport
@@ -294,7 +296,6 @@ void			xprt_set_retrans_timeout_rtt(struct rpc_task *task);
 void                    xprt_wake_pending_tasks(struct rpc_xprt *xprt, int status);
 void                    xprt_wait_for_buffer_space(struct rpc_task *task, rpc_action action);
 void                    xprt_write_space(struct rpc_xprt *xprt);
-void                    xprt_update_rtt(struct rpc_task *task);
 void                    xprt_adjust_cwnd(struct rpc_task *task, int result);
 struct rpc_rqst *       xprt_lookup_rqst(struct rpc_xprt *xprt, __be32 xid);
 void                    xprt_complete_rqst(struct rpc_task *task, int copied);
diff --git a/include/linux/tick.h b/include/linux/tick.h
index d2ae79e21be3..b232ccc0ee29 100644
--- a/include/linux/tick.h
+++ b/include/linux/tick.h
@@ -42,6 +42,7 @@ enum tick_nohz_mode {
 * @idle_waketime:      Time when the idle was interrupted
 * @idle_exittime:      Time when the idle state was left
 * @idle_sleeptime:     Sum of the time slept in idle with sched tick stopped
+ * @iowait_sleeptime:   Sum of the time slept in idle with sched tick stopped, with IO outstanding
 * @sleep_length:       Duration of the current idle sleep
 * @do_timer_lst:       CPU was the last one doing do_timer before going idle
 */
@@ -60,7 +61,7 @@ struct tick_sched {
        ktime_t                         idle_waketime;
        ktime_t                         idle_exittime;
        ktime_t                         idle_sleeptime;
-        ktime_t                         idle_lastupdate;
+        ktime_t                         iowait_sleeptime;
        ktime_t                         sleep_length;
        unsigned long                   last_jiffies;
        unsigned long                   next_jiffies;
@@ -124,6 +125,7 @@ extern void tick_nohz_stop_sched_tick(int inidle);
 extern void tick_nohz_restart_sched_tick(void);
 extern ktime_t tick_nohz_get_sleep_length(void);
 extern u64 get_cpu_idle_time_us(int cpu, u64 *last_update_time);
+extern u64 get_cpu_iowait_time_us(int cpu, u64 *last_update_time);
 # else
 static inline void tick_nohz_stop_sched_tick(int inidle) { }
 static inline void tick_nohz_restart_sched_tick(void) { }
@@ -134,6 +136,7 @@ static inline ktime_t tick_nohz_get_sleep_length(void)
        return len;
 }
 static inline u64 get_cpu_idle_time_us(int cpu, u64 *unused) { return -1; }
+static inline u64 get_cpu_iowait_time_us(int cpu, u64 *unused) { return -1; }
 # endif /* !NO_HZ */
 #endif
diff --git a/include/linux/time.h b/include/linux/time.h
index 6e026e45a179..ea3559f0b3f2 100644
--- a/include/linux/time.h
+++ b/include/linux/time.h
@@ -150,7 +150,6 @@ extern struct timespec timespec_trunc(struct timespec t, unsigned gran);
 extern int timekeeping_valid_for_hres(void);
 extern u64 timekeeping_max_deferment(void);
 extern void update_wall_time(void);
-extern void update_xtime_cache(u64 nsec);
 extern void timekeeping_leap_insert(int leapsecond);
 struct tms;
diff --git a/include/linux/timer.h b/include/linux/timer.h
index a2d1eb6cb3f0..ea965b857a50 100644
--- a/include/linux/timer.h
+++ b/include/linux/timer.h
@@ -10,13 +10,19 @@
 struct tvec_base;
 struct timer_list {
+        /*
+         * All fields that change during normal runtime grouped to the
+         * same cacheline
+         */
        struct list_head entry;
        unsigned long expires;
+        struct tvec_base *base;
        void (*function)(unsigned long);
        unsigned long data;
-        struct tvec_base *base;
+        int slack;
 #ifdef CONFIG_TIMER_STATS
        void *start_site;
        char start_comm[16];
@@ -165,6 +171,8 @@ extern int mod_timer(struct timer_list *timer, unsigned long expires);
 extern int mod_timer_pending(struct timer_list *timer, unsigned long expires);
 extern int mod_timer_pinned(struct timer_list *timer, unsigned long expires);
+extern void set_timer_slack(struct timer_list *time, int slack_hz);
 #define TIMER_NOT_PINNED        0
 #define TIMER_PINNED            1
 /*
diff --git a/include/linux/timex.h b/include/linux/timex.h
index 7a082b32d8e1..32d852f8cbe4 100644
--- a/include/linux/timex.h
+++ b/include/linux/timex.h
@@ -232,13 +232,11 @@ struct timex {
 */
 extern unsigned long tick_usec;         /* USER_HZ period (usec) */
 extern unsigned long tick_nsec;         /* ACTHZ          period (nsec) */
-extern int tickadj;                     /* amount of adjustment per tick */
 /*
 * phase-lock loop variables
 */
 extern int time_status;         /* clock synchronization status bits */
-extern long time_adjust;        /* The amount of adjtime left */
 extern void ntp_init(void);
 extern void ntp_clear(void);
@@ -271,9 +269,6 @@ extern void second_overflow(void);
 extern void update_ntp_one_tick(void);
 extern int do_adjtimex(struct timex *);
-/* Don't use! Compatibility define for existing users. */
-#define tickadj (500/HZ ? : 1)
 int read_current_timer(unsigned long *timer_val);
 /* The clock frequency of the i8253/i8254 PIT */
diff --git a/include/linux/tracepoint.h b/include/linux/tracepoint.h
index 78b4bd3be496..1d85f9a6a199 100644
--- a/include/linux/tracepoint.h
+++ b/include/linux/tracepoint.h
@@ -33,6 +33,65 @@ struct tracepoint {
                                         * Keep in sync with vmlinux.lds.h.
                                         */
+/*
+ * Connect a probe to a tracepoint.
+ * Internal API, should not be used directly.
+ */
+extern int tracepoint_probe_register(const char *name, void *probe);
+/*
+ * Disconnect a probe from a tracepoint.
+ * Internal API, should not be used directly.
+ */
+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;
+};
+extern void tracepoint_iter_start(struct tracepoint_iter *iter);
+extern void tracepoint_iter_next(struct tracepoint_iter *iter);
+extern void tracepoint_iter_stop(struct tracepoint_iter *iter);
+extern void tracepoint_iter_reset(struct tracepoint_iter *iter);
+extern int tracepoint_get_iter_range(struct tracepoint **tracepoint,
+        struct tracepoint *begin, struct tracepoint *end);
+/*
+ * tracepoint_synchronize_unregister must be called between the last tracepoint
+ * probe unregistration and the end of module exit to make sure there is no
+ * caller executing a probe when it is freed.
+ */
+static inline void tracepoint_synchronize_unregister(void)
+{
+        synchronize_sched();
+}
+#define PARAMS(args...) args
+#ifdef CONFIG_TRACEPOINTS
+extern void tracepoint_update_probe_range(struct tracepoint *begin,
+        struct tracepoint *end);
+#else
+static inline void tracepoint_update_probe_range(struct tracepoint *begin,
+        struct tracepoint *end)
+{ }
+#endif /* CONFIG_TRACEPOINTS */
+#endif /* _LINUX_TRACEPOINT_H */
+/*
+ * Note: we keep the TRACE_EVENT and DECLARE_TRACE outside the include
+ *  file ifdef protection.
+ *  This is due to the way trace events work. If a file includes two
+ *  trace event headers under one "CREATE_TRACE_POINTS" the first include
+ *  will override the TRACE_EVENT and break the second include.
+ */
 #ifndef DECLARE_TRACE
 #define TP_PROTO(args...)       args
@@ -96,9 +155,6 @@ struct tracepoint {
 #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 DECLARE_TRACE(name, proto, args)                                \
        static inline void _do_trace_##name(struct tracepoint *tp, proto) \
@@ -119,61 +175,9 @@ extern void tracepoint_update_probe_range(struct tracepoint *begin,
 #define EXPORT_TRACEPOINT_SYMBOL_GPL(name)
 #define EXPORT_TRACEPOINT_SYMBOL(name)
-static inline void tracepoint_update_probe_range(struct tracepoint *begin,
-        struct tracepoint *end)
-{ }
 #endif /* CONFIG_TRACEPOINTS */
 #endif /* DECLARE_TRACE */
-/*
- * Connect a probe to a tracepoint.
- * Internal API, should not be used directly.
- */
-extern int tracepoint_probe_register(const char *name, void *probe);
-/*
- * Disconnect a probe from a tracepoint.
- * Internal API, should not be used directly.
- */
-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;
-};
-extern void tracepoint_iter_start(struct tracepoint_iter *iter);
-extern void tracepoint_iter_next(struct tracepoint_iter *iter);
-extern void tracepoint_iter_stop(struct tracepoint_iter *iter);
-extern void tracepoint_iter_reset(struct tracepoint_iter *iter);
-extern int tracepoint_get_iter_range(struct tracepoint **tracepoint,
-        struct tracepoint *begin, struct tracepoint *end);
-/*
- * tracepoint_synchronize_unregister must be called between the last tracepoint
- * probe unregistration and the end of module exit to make sure there is no
- * caller executing a probe when it is freed.
- */
-static inline void tracepoint_synchronize_unregister(void)
-{
-        synchronize_sched();
-}
-#define PARAMS(args...) args
-#endif /* _LINUX_TRACEPOINT_H */
-/*
- * Note: we keep the TRACE_EVENT outside the include file ifdef protection.
- *  This is due to the way trace events work. If a file includes two
- *  trace event headers under one "CREATE_TRACE_POINTS" the first include
- *  will override the TRACE_EVENT and break the second include.
- */
 #ifndef TRACE_EVENT
 /*
 * For use with the TRACE_EVENT macro:
diff --git a/include/linux/types.h b/include/linux/types.h
index c42724f8c802..23d237a075e2 100644
--- a/include/linux/types.h
+++ b/include/linux/types.h
@@ -188,12 +188,12 @@ typedef u32 phys_addr_t;
 typedef phys_addr_t resource_size_t;
 typedef struct {
-        volatile int counter;
+        int counter;
 } atomic_t;
 #ifdef CONFIG_64BIT
 typedef struct {
-        volatile long counter;
+        long counter;
 } atomic64_t;
 #endif
diff --git a/include/linux/usb.h b/include/linux/usb.h
index ce1323c4e47c..739f1fd1cc15 100644
--- a/include/linux/usb.h
+++ b/include/linux/usb.h
@@ -1085,7 +1085,7 @@ typedef void (*usb_complete_t)(struct urb *);
 * Alternatively, drivers may pass the URB_NO_xxx_DMA_MAP transfer flags,
 * which tell the host controller driver that no such mapping is needed since
 * the device driver is DMA-aware.  For example, a device driver might
- * allocate a DMA buffer with usb_buffer_alloc() or call usb_buffer_map().
+ * allocate a DMA buffer with usb_alloc_coherent() or call usb_buffer_map().
 * When these transfer flags are provided, host controller drivers will
 * attempt to use the dma addresses found in the transfer_dma and/or
 * setup_dma fields rather than determining a dma address themselves.
@@ -1366,11 +1366,23 @@ static inline int usb_urb_dir_out(struct urb *urb)
        return (urb->transfer_flags & URB_DIR_MASK) == URB_DIR_OUT;
 }
-void *usb_buffer_alloc(struct usb_device *dev, size_t size,
+void *usb_alloc_coherent(struct usb_device *dev, size_t size,
        gfp_t mem_flags, dma_addr_t *dma);
-void usb_buffer_free(struct usb_device *dev, size_t size,
+void usb_free_coherent(struct usb_device *dev, size_t size,
        void *addr, dma_addr_t dma);
+/* Compatible macros while we switch over */
+static inline void *usb_buffer_alloc(struct usb_device *dev, size_t size,
+                                     gfp_t mem_flags, dma_addr_t *dma)
+{
+        return usb_alloc_coherent(dev, size, mem_flags, dma);
+}
+static inline void usb_buffer_free(struct usb_device *dev, size_t size,
+                                   void *addr, dma_addr_t dma)
+{
+        return usb_free_coherent(dev, size, addr, dma);
+}
 #if 0
 struct urb *usb_buffer_map(struct urb *urb);
 void usb_buffer_dmasync(struct urb *urb);
diff --git a/include/linux/virtio_console.h b/include/linux/virtio_console.h
index ae4f039515b4..92228a8fbcbc 100644
--- a/include/linux/virtio_console.h
+++ b/include/linux/virtio_console.h
@@ -12,37 +12,14 @@
 /* Feature bits */
 #define VIRTIO_CONSOLE_F_SIZE   0       /* Does host provide console size? */
-#define VIRTIO_CONSOLE_F_MULTIPORT 1    /* Does host provide multiple ports? */
 struct virtio_console_config {
        /* colums of the screens */
        __u16 cols;
        /* rows of the screens */
        __u16 rows;
-        /* max. number of ports this device can hold */
-        __u32 max_nr_ports;
-        /* number of ports added so far */
-        __u32 nr_ports;
 } __attribute__((packed));
-/*
- * A message that's passed between the Host and the Guest for a
- * particular port.
- */
-struct virtio_console_control {
-        __u32 id;               /* Port number */
-        __u16 event;            /* The kind of control event (see below) */
-        __u16 value;            /* Extra information for the key */
-};
-/* Some events for control messages */
-#define VIRTIO_CONSOLE_PORT_READY       0
-#define VIRTIO_CONSOLE_CONSOLE_PORT     1
-#define VIRTIO_CONSOLE_RESIZE           2
-#define VIRTIO_CONSOLE_PORT_OPEN        3
-#define VIRTIO_CONSOLE_PORT_NAME        4
-#define VIRTIO_CONSOLE_PORT_REMOVE      5
 #ifdef __KERNEL__
 int __init virtio_cons_early_init(int (*put_chars)(u32, const char *, int));
 #endif /* __KERNEL__ */
diff --git a/include/linux/wait.h b/include/linux/wait.h
index a48e16b77d5e..76d96d035ea0 100644
--- a/include/linux/wait.h
+++ b/include/linux/wait.h
@@ -127,12 +127,26 @@ static inline void __add_wait_queue(wait_queue_head_t *head, wait_queue_t *new)
 /*
 * Used for wake-one threads:
 */
+static inline void __add_wait_queue_exclusive(wait_queue_head_t *q,
+                                              wait_queue_t *wait)
+{
+        wait->flags |= WQ_FLAG_EXCLUSIVE;
+        __add_wait_queue(q, wait);
+}
 static inline void __add_wait_queue_tail(wait_queue_head_t *head,
-                                                wait_queue_t *new)
+                                         wait_queue_t *new)
 {
        list_add_tail(&new->task_list, &head->task_list);
 }
+static inline void __add_wait_queue_tail_exclusive(wait_queue_head_t *q,
+                                              wait_queue_t *wait)
+{
+        wait->flags |= WQ_FLAG_EXCLUSIVE;
+        __add_wait_queue_tail(q, wait);
+}
 static inline void __remove_wait_queue(wait_queue_head_t *head,
                                                        wait_queue_t *old)
 {
@@ -404,25 +418,6 @@ do {									\
 })
 /*
- * Must be called with the spinlock in the wait_queue_head_t held.
- */
-static inline void add_wait_queue_exclusive_locked(wait_queue_head_t *q,
-                                                   wait_queue_t * wait)
-{
-        wait->flags |= WQ_FLAG_EXCLUSIVE;
-        __add_wait_queue_tail(q,  wait);
-}
-/*
- * Must be called with the spinlock in the wait_queue_head_t held.
- */
-static inline void remove_wait_queue_locked(wait_queue_head_t *q,
-                                            wait_queue_t * wait)
-{
-        __remove_wait_queue(q,  wait);
-}
-/*
 * These are the old interfaces to sleep waiting for an event.
 * They are racy.  DO NOT use them, use the wait_event* interfaces above.
 * We plan to remove these interfaces.
diff --git a/include/linux/writeback.h b/include/linux/writeback.h
index 76e8903cd204..36520ded3e06 100644
--- a/include/linux/writeback.h
+++ b/include/linux/writeback.h
@@ -34,6 +34,9 @@ struct writeback_control {
        enum writeback_sync_modes sync_mode;
        unsigned long *older_than_this; /* If !NULL, only write back inodes
                                           older than this */
+        unsigned long wb_start;         /* Time writeback_inodes_wb was
+                                           called. This is needed to avoid
+                                           extra jobs and livelock */
        long nr_to_write;               /* Write this many pages, and decrement
                                           this for each page written */
        long pages_skipped;             /* Pages which were not written */
diff --git a/include/linux/zorro.h b/include/linux/zorro.h
index 913bfc226dda..7bf9db525e9e 100644
--- a/include/linux/zorro.h
+++ b/include/linux/zorro.h
@@ -38,8 +38,6 @@
 typedef __u32 zorro_id;
-#define ZORRO_WILDCARD          (0xffffffff)    /* not official */
 /* Include the ID list */
 #include <linux/zorro_ids.h>
@@ -116,6 +114,7 @@ struct ConfigDev {
 #include <linux/init.h>
 #include <linux/ioport.h>
+#include <linux/mod_devicetable.h>
 #include <asm/zorro.h>
@@ -142,29 +141,10 @@ struct zorro_dev {
     *  Zorro bus
     */
-struct zorro_bus {
-    struct list_head devices;           /* list of devices on this bus */
-    unsigned int num_resources;         /* number of resources */
-    struct resource resources[4];       /* address space routed to this bus */
-    struct device dev;
-    char name[10];
-};
-extern struct zorro_bus zorro_bus;      /* single Zorro bus */
 extern struct bus_type zorro_bus_type;
    /*
-     *  Zorro device IDs
-     */
-struct zorro_device_id {
-        zorro_id id;                    /* Device ID or ZORRO_WILDCARD */
-        unsigned long driver_data;      /* Data private to the driver */
-};
-    /*
     *  Zorro device drivers
     */
diff --git a/include/media/saa7146_vv.h b/include/media/saa7146_vv.h
index b9da1f5591e7..4aeff96ff7d8 100644
--- a/include/media/saa7146_vv.h
+++ b/include/media/saa7146_vv.h
@@ -188,7 +188,6 @@ void saa7146_buffer_timeout(unsigned long data);
 void saa7146_dma_free(struct saa7146_dev* dev,struct videobuf_queue *q,
                                                struct saa7146_buf *buf);
-int saa7146_vv_devinit(struct saa7146_dev *dev);
 int saa7146_vv_init(struct saa7146_dev* dev, struct saa7146_ext_vv *ext_vv);
 int saa7146_vv_release(struct saa7146_dev* dev);
diff --git a/include/net/sctp/command.h b/include/net/sctp/command.h
index 8be5135ff7aa..2c55a7ea20af 100644
--- a/include/net/sctp/command.h
+++ b/include/net/sctp/command.h
@@ -107,6 +107,7 @@ typedef enum {
        SCTP_CMD_T1_RETRAN,      /* Mark for retransmission after T1 timeout  */
        SCTP_CMD_UPDATE_INITTAG, /* Update peer inittag */
        SCTP_CMD_SEND_MSG,       /* Send the whole use message */
+        SCTP_CMD_SEND_NEXT_ASCONF, /* Send the next ASCONF after ACK */
        SCTP_CMD_LAST
 } sctp_verb_t;
diff --git a/include/net/sctp/sctp.h b/include/net/sctp/sctp.h
index 78740ec57d5d..fa6cde578a1d 100644
--- a/include/net/sctp/sctp.h
+++ b/include/net/sctp/sctp.h
@@ -128,6 +128,7 @@ extern int sctp_register_pf(struct sctp_pf *, sa_family_t);
 int sctp_backlog_rcv(struct sock *sk, struct sk_buff *skb);
 int sctp_inet_listen(struct socket *sock, int backlog);
 void sctp_write_space(struct sock *sk);
+void sctp_data_ready(struct sock *sk, int len);
 unsigned int sctp_poll(struct file *file, struct socket *sock,
                poll_table *wait);
 void sctp_sock_rfree(struct sk_buff *skb);
diff --git a/include/net/sctp/sm.h b/include/net/sctp/sm.h
index 851c813adb3a..61d73e37d543 100644
--- a/include/net/sctp/sm.h
+++ b/include/net/sctp/sm.h
@@ -279,6 +279,7 @@ int sctp_do_sm(sctp_event_t event_type, sctp_subtype_t subtype,
 /* 2nd level prototypes */
 void sctp_generate_t3_rtx_event(unsigned long peer);
 void sctp_generate_heartbeat_event(unsigned long peer);
+void sctp_generate_proto_unreach_event(unsigned long peer);
 void sctp_ootb_pkt_free(struct sctp_packet *);
diff --git a/include/net/sctp/structs.h b/include/net/sctp/structs.h
index ff3017744711..219043a67bf7 100644
--- a/include/net/sctp/structs.h
+++ b/include/net/sctp/structs.h
@@ -778,6 +778,7 @@ int sctp_user_addto_chunk(struct sctp_chunk *chunk, int off, int len,
                          struct iovec *data);
 void sctp_chunk_free(struct sctp_chunk *);
 void  *sctp_addto_chunk(struct sctp_chunk *, int len, const void *data);
+void  *sctp_addto_chunk_fixed(struct sctp_chunk *, int len, const void *data);
 struct sctp_chunk *sctp_chunkify(struct sk_buff *,
                                 const struct sctp_association *,
                                 struct sock *);
@@ -1009,6 +1010,9 @@ struct sctp_transport {
        /* Heartbeat timer is per destination. */
        struct timer_list hb_timer;
+        /* Timer to handle ICMP proto unreachable envets */
+        struct timer_list proto_unreach_timer;
        /* Since we're using per-destination retransmission timers
         * (see above), we're also using per-destination "transmitted"
         * queues.  This probably ought to be a private struct
diff --git a/include/net/sock.h b/include/net/sock.h
index b4603cd54fcd..1ad6435f252e 100644
--- a/include/net/sock.h
+++ b/include/net/sock.h
@@ -74,7 +74,7 @@
                                        printk(KERN_DEBUG msg); } while (0)
 #else
 /* Validate arguments and do nothing */
-static void inline int __attribute__ ((format (printf, 2, 3)))
+static inline void __attribute__ ((format (printf, 2, 3)))
 SOCK_DEBUG(struct sock *sk, const char *msg, ...)
 {
 }
diff --git a/include/net/tcp.h b/include/net/tcp.h
index 75be5a28815d..aa04b9a5093b 100644
--- a/include/net/tcp.h
+++ b/include/net/tcp.h
@@ -1197,30 +1197,15 @@ extern int			tcp_v4_md5_do_del(struct sock *sk,
 extern struct tcp_md5sig_pool * __percpu *tcp_alloc_md5sig_pool(struct sock *);
 extern void                     tcp_free_md5sig_pool(void);
-extern struct tcp_md5sig_pool   *__tcp_get_md5sig_pool(int cpu);
+extern struct tcp_md5sig_pool   *tcp_get_md5sig_pool(void);
-extern void                     __tcp_put_md5sig_pool(void);
+extern void                     tcp_put_md5sig_pool(void);
 extern int tcp_md5_hash_header(struct tcp_md5sig_pool *, struct tcphdr *);
 extern int tcp_md5_hash_skb_data(struct tcp_md5sig_pool *, struct sk_buff *,
                                 unsigned header_len);
 extern int tcp_md5_hash_key(struct tcp_md5sig_pool *hp,
                            struct tcp_md5sig_key *key);
-static inline
-struct tcp_md5sig_pool          *tcp_get_md5sig_pool(void)
-{
-        int cpu = get_cpu();
-        struct tcp_md5sig_pool *ret = __tcp_get_md5sig_pool(cpu);
-        if (!ret)
-                put_cpu();
-        return ret;
-}
-static inline void              tcp_put_md5sig_pool(void)
-{
-        __tcp_put_md5sig_pool();
-        put_cpu();
-}
 /* write queue abstraction */
 static inline void tcp_write_queue_purge(struct sock *sk)
 {
diff --git a/include/net/x25.h b/include/net/x25.h
index 15ef9624ab75..468551ea4f1d 100644
--- a/include/net/x25.h
+++ b/include/net/x25.h
@@ -183,6 +183,10 @@ extern int  sysctl_x25_clear_request_timeout;
 extern int  sysctl_x25_ack_holdback_timeout;
 extern int  sysctl_x25_forward;
+extern int x25_parse_address_block(struct sk_buff *skb,
+                struct x25_address *called_addr,
+                struct x25_address *calling_addr);
 extern int  x25_addr_ntoa(unsigned char *, struct x25_address *,
                          struct x25_address *);
 extern int  x25_addr_aton(unsigned char *, struct x25_address *,
diff --git a/include/pcmcia/ds.h b/include/pcmcia/ds.h
index d57847f2f6c1..aab3c13dc310 100644
--- a/include/pcmcia/ds.h
+++ b/include/pcmcia/ds.h
@@ -26,6 +26,7 @@
 #ifdef __KERNEL__
 #include <linux/device.h>
 #include <pcmcia/ss.h>
+#include <asm/atomic.h>
 /*
 * PCMCIA device drivers (16-bit cards only; 32-bit cards require CardBus
@@ -94,10 +95,8 @@ struct pcmcia_device {
        config_req_t            conf;
        window_handle_t         win;
-        /* Is the device suspended, or in the process of
+        /* Is the device suspended? */
-         * being removed? */
        u16                     suspended:1;
-        u16                     _removed:1;
        /* Flags whether io, irq, win configurations were
         * requested, and whether the configuration is "locked" */
@@ -115,7 +114,7 @@ struct pcmcia_device {
        u16                     has_card_id:1;
        u16                     has_func_id:1;
-        u16                     reserved:3;
+        u16                     reserved:4;
        u8                      func_id;
        u16                     manf_id;
diff --git a/include/pcmcia/ss.h b/include/pcmcia/ss.h
index 2e488b60bc76..344705cb42f4 100644
--- a/include/pcmcia/ss.h
+++ b/include/pcmcia/ss.h
@@ -224,18 +224,16 @@ struct pcmcia_socket {
        /* 16-bit state: */
        struct {
-                /* PCMCIA card is present in socket */
-                u8                      present:1;
                /* "master" ioctl is used */
                u8                      busy:1;
-                /* pcmcia module is being unloaded */
-                u8                      dead:1;
                /* the PCMCIA card consists of two pseudo devices */
                u8                      has_pfc:1;
-                u8                      reserved:4;
+                u8                      reserved:6;
        } pcmcia_state;
+        /* non-zero if PCMCIA card is present */
+        atomic_t                        present;
 #ifdef CONFIG_PCMCIA_IOCTL
        struct user_info_t              *user;
diff --git a/include/sound/ak4113.h b/include/sound/ak4113.h
index 8988edae1609..2609048c1d44 100644
--- a/include/sound/ak4113.h
+++ b/include/sound/ak4113.h
@@ -307,7 +307,7 @@ struct ak4113 {
 int snd_ak4113_create(struct snd_card *card, ak4113_read_t *read,
                ak4113_write_t *write,
-                const unsigned char pgm[AK4113_WRITABLE_REGS],
+                const unsigned char *pgm,
                void *private_data, struct ak4113 **r_ak4113);
 void snd_ak4113_reg_write(struct ak4113 *ak4113, unsigned char reg,
                unsigned char mask, unsigned char val);
diff --git a/include/sound/soc-dai.h b/include/sound/soc-dai.h
index 061f16d4c878..0a0b019d41ad 100644
--- a/include/sound/soc-dai.h
+++ b/include/sound/soc-dai.h
@@ -219,7 +219,6 @@ struct snd_soc_dai {
        struct snd_soc_codec *codec;
        unsigned int active;
        unsigned char pop_wait:1;
-        void *dma_data;
        /* DAI private data */
        void *private_data;
@@ -230,4 +229,21 @@ struct snd_soc_dai {
        struct list_head list;
 };
+static inline void *snd_soc_dai_get_dma_data(const struct snd_soc_dai *dai,
+                                             const struct snd_pcm_substream *ss)
+{
+        return (ss->stream == SNDRV_PCM_STREAM_PLAYBACK) ?
+                dai->playback.dma_data : dai->capture.dma_data;
+}
+static inline void snd_soc_dai_set_dma_data(struct snd_soc_dai *dai,
+                                            const struct snd_pcm_substream *ss,
+                                            void *data)
+{
+        if (ss->stream == SNDRV_PCM_STREAM_PLAYBACK)
+                dai->playback.dma_data = data;
+        else
+                dai->capture.dma_data = data;
+}
 #endif
diff --git a/include/sound/soc.h b/include/sound/soc.h
index 5d234a8c2506..a57fbfcd4c8f 100644
--- a/include/sound/soc.h
+++ b/include/sound/soc.h
@@ -375,6 +375,7 @@ struct snd_soc_pcm_stream {
        unsigned int channels_min;      /* min channels */
        unsigned int channels_max;      /* max channels */
        unsigned int active:1;          /* stream is in use */
+        void *dma_data;                 /* used by platform code */
 };
 /* SoC audio ops */
diff --git a/include/trace/define_trace.h b/include/trace/define_trace.h
index 5acfb1eb4df9..1dfab5401511 100644
--- a/include/trace/define_trace.h
+++ b/include/trace/define_trace.h
@@ -65,6 +65,10 @@
 #include TRACE_INCLUDE(TRACE_INCLUDE_FILE)
+/* Make all open coded DECLARE_TRACE nops */
+#undef DECLARE_TRACE
+#define DECLARE_TRACE(name, proto, args)
 #ifdef CONFIG_EVENT_TRACING
 #include <trace/ftrace.h>
 #endif
@@ -75,6 +79,7 @@
 #undef DEFINE_EVENT
 #undef DEFINE_EVENT_PRINT
 #undef TRACE_HEADER_MULTI_READ
+#undef DECLARE_TRACE
 /* Only undef what we defined in this file */
 #ifdef UNDEF_TRACE_INCLUDE_FILE
diff --git a/include/trace/events/block.h b/include/trace/events/block.h
index 5fb72733331e..d870a918559c 100644
--- a/include/trace/events/block.h
+++ b/include/trace/events/block.h
@@ -40,6 +40,16 @@ DECLARE_EVENT_CLASS(block_rq_with_error,
                  __entry->nr_sector, __entry->errors)
 );
+/**
+ * block_rq_abort - abort block operation request
+ * @q: queue containing the block operation request
+ * @rq: block IO operation request
+ *
+ * Called immediately after pending block IO operation request @rq in
+ * queue @q is aborted. The fields in the operation request @rq
+ * can be examined to determine which device and sectors the pending
+ * operation would access.
+ */
 DEFINE_EVENT(block_rq_with_error, block_rq_abort,
        TP_PROTO(struct request_queue *q, struct request *rq),
@@ -47,6 +57,15 @@ DEFINE_EVENT(block_rq_with_error, block_rq_abort,
        TP_ARGS(q, rq)
 );
+/**
+ * block_rq_requeue - place block IO request back on a queue
+ * @q: queue holding operation
+ * @rq: block IO operation request
+ *
+ * The block operation request @rq is being placed back into queue
+ * @q.  For some reason the request was not completed and needs to be
+ * put back in the queue.
+ */
 DEFINE_EVENT(block_rq_with_error, block_rq_requeue,
        TP_PROTO(struct request_queue *q, struct request *rq),
@@ -54,6 +73,17 @@ DEFINE_EVENT(block_rq_with_error, block_rq_requeue,
        TP_ARGS(q, rq)
 );
+/**
+ * block_rq_complete - block IO operation completed by device driver
+ * @q: queue containing the block operation request
+ * @rq: block operations request
+ *
+ * The block_rq_complete tracepoint event indicates that some portion
+ * of operation request has been completed by the device driver.  If
+ * the @rq->bio is %NULL, then there is absolutely no additional work to
+ * do for the request. If @rq->bio is non-NULL then there is
+ * additional work required to complete the request.
+ */
 DEFINE_EVENT(block_rq_with_error, block_rq_complete,
        TP_PROTO(struct request_queue *q, struct request *rq),
@@ -95,6 +125,16 @@ DECLARE_EVENT_CLASS(block_rq,
                  __entry->nr_sector, __entry->comm)
 );
+/**
+ * block_rq_insert - insert block operation request into queue
+ * @q: target queue
+ * @rq: block IO operation request
+ *
+ * Called immediately before block operation request @rq is inserted
+ * into queue @q.  The fields in the operation request @rq struct can
+ * be examined to determine which device and sectors the pending
+ * operation would access.
+ */
 DEFINE_EVENT(block_rq, block_rq_insert,
        TP_PROTO(struct request_queue *q, struct request *rq),
@@ -102,6 +142,14 @@ DEFINE_EVENT(block_rq, block_rq_insert,
        TP_ARGS(q, rq)
 );
+/**
+ * block_rq_issue - issue pending block IO request operation to device driver
+ * @q: queue holding operation
+ * @rq: block IO operation operation request
+ *
+ * Called when block operation request @rq from queue @q is sent to a
+ * device driver for processing.
+ */
 DEFINE_EVENT(block_rq, block_rq_issue,
        TP_PROTO(struct request_queue *q, struct request *rq),
@@ -109,6 +157,17 @@ DEFINE_EVENT(block_rq, block_rq_issue,
        TP_ARGS(q, rq)
 );
+/**
+ * block_bio_bounce - used bounce buffer when processing block operation
+ * @q: queue holding the block operation
+ * @bio: block operation
+ *
+ * A bounce buffer was used to handle the block operation @bio in @q.
+ * This occurs when hardware limitations prevent a direct transfer of
+ * data between the @bio data memory area and the IO device.  Use of a
+ * bounce buffer requires extra copying of data and decreases
+ * performance.
+ */
 TRACE_EVENT(block_bio_bounce,
        TP_PROTO(struct request_queue *q, struct bio *bio),
@@ -138,6 +197,14 @@ TRACE_EVENT(block_bio_bounce,
                  __entry->nr_sector, __entry->comm)
 );
+/**
+ * block_bio_complete - completed all work on the block operation
+ * @q: queue holding the block operation
+ * @bio: block operation completed
+ *
+ * This tracepoint indicates there is no further work to do on this
+ * block IO operation @bio.
+ */
 TRACE_EVENT(block_bio_complete,
        TP_PROTO(struct request_queue *q, struct bio *bio),
@@ -193,6 +260,14 @@ DECLARE_EVENT_CLASS(block_bio,
                  __entry->nr_sector, __entry->comm)
 );
+/**
+ * block_bio_backmerge - merging block operation to the end of an existing operation
+ * @q: queue holding operation
+ * @bio: new block operation to merge
+ *
+ * Merging block request @bio to the end of an existing block request
+ * in queue @q.
+ */
 DEFINE_EVENT(block_bio, block_bio_backmerge,
        TP_PROTO(struct request_queue *q, struct bio *bio),
@@ -200,6 +275,14 @@ DEFINE_EVENT(block_bio, block_bio_backmerge,
        TP_ARGS(q, bio)
 );
+/**
+ * block_bio_frontmerge - merging block operation to the beginning of an existing operation
+ * @q: queue holding operation
+ * @bio: new block operation to merge
+ *
+ * Merging block IO operation @bio to the beginning of an existing block
+ * operation in queue @q.
+ */
 DEFINE_EVENT(block_bio, block_bio_frontmerge,
        TP_PROTO(struct request_queue *q, struct bio *bio),
@@ -207,6 +290,13 @@ DEFINE_EVENT(block_bio, block_bio_frontmerge,
        TP_ARGS(q, bio)
 );
+/**
+ * block_bio_queue - putting new block IO operation in queue
+ * @q: queue holding operation
+ * @bio: new block operation
+ *
+ * About to place the block IO operation @bio into queue @q.
+ */
 DEFINE_EVENT(block_bio, block_bio_queue,
        TP_PROTO(struct request_queue *q, struct bio *bio),
@@ -243,6 +333,15 @@ DECLARE_EVENT_CLASS(block_get_rq,
                  __entry->nr_sector, __entry->comm)
 );
+/**
+ * block_getrq - get a free request entry in queue for block IO operations
+ * @q: queue for operations
+ * @bio: pending block IO operation
+ * @rw: low bit indicates a read (%0) or a write (%1)
+ *
+ * A request struct for queue @q has been allocated to handle the
+ * block IO operation @bio.
+ */
 DEFINE_EVENT(block_get_rq, block_getrq,
        TP_PROTO(struct request_queue *q, struct bio *bio, int rw),
@@ -250,6 +349,17 @@ DEFINE_EVENT(block_get_rq, block_getrq,
        TP_ARGS(q, bio, rw)
 );
+/**
+ * block_sleeprq - waiting to get a free request entry in queue for block IO operation
+ * @q: queue for operation
+ * @bio: pending block IO operation
+ * @rw: low bit indicates a read (%0) or a write (%1)
+ *
+ * In the case where a request struct cannot be provided for queue @q
+ * the process needs to wait for an request struct to become
+ * available.  This tracepoint event is generated each time the
+ * process goes to sleep waiting for request struct become available.
+ */
 DEFINE_EVENT(block_get_rq, block_sleeprq,
        TP_PROTO(struct request_queue *q, struct bio *bio, int rw),
@@ -257,6 +367,14 @@ DEFINE_EVENT(block_get_rq, block_sleeprq,
        TP_ARGS(q, bio, rw)
 );
+/**
+ * block_plug - keep operations requests in request queue
+ * @q: request queue to plug
+ *
+ * Plug the request queue @q.  Do not allow block operation requests
+ * to be sent to the device driver. Instead, accumulate requests in
+ * the queue to improve throughput performance of the block device.
+ */
 TRACE_EVENT(block_plug,
        TP_PROTO(struct request_queue *q),
@@ -293,6 +411,13 @@ DECLARE_EVENT_CLASS(block_unplug,
        TP_printk("[%s] %d", __entry->comm, __entry->nr_rq)
 );
+/**
+ * block_unplug_timer - timed release of operations requests in queue to device driver
+ * @q: request queue to unplug
+ *
+ * Unplug the request queue @q because a timer expired and allow block
+ * operation requests to be sent to the device driver.
+ */
 DEFINE_EVENT(block_unplug, block_unplug_timer,
        TP_PROTO(struct request_queue *q),
@@ -300,6 +425,13 @@ DEFINE_EVENT(block_unplug, block_unplug_timer,
        TP_ARGS(q)
 );
+/**
+ * block_unplug_io - release of operations requests in request queue
+ * @q: request queue to unplug
+ *
+ * Unplug request queue @q because device driver is scheduled to work
+ * on elements in the request queue.
+ */
 DEFINE_EVENT(block_unplug, block_unplug_io,
        TP_PROTO(struct request_queue *q),
@@ -307,6 +439,17 @@ DEFINE_EVENT(block_unplug, block_unplug_io,
        TP_ARGS(q)
 );
+/**
+ * block_split - split a single bio struct into two bio structs
+ * @q: queue containing the bio
+ * @bio: block operation being split
+ * @new_sector: The starting sector for the new bio
+ *
+ * The bio request @bio in request queue @q needs to be split into two
+ * bio requests. The newly created @bio request starts at
+ * @new_sector. This split may be required due to hardware limitation
+ * such as operation crossing device boundaries in a RAID system.
+ */
 TRACE_EVENT(block_split,
        TP_PROTO(struct request_queue *q, struct bio *bio,
@@ -337,6 +480,16 @@ TRACE_EVENT(block_split,
                  __entry->comm)
 );
+/**
+ * block_remap - map request for a partition to the raw device
+ * @q: queue holding the operation
+ * @bio: revised operation
+ * @dev: device for the operation
+ * @from: original sector for the operation
+ *
+ * An operation for a partition on a block device has been mapped to the
+ * raw block device.
+ */
 TRACE_EVENT(block_remap,
        TP_PROTO(struct request_queue *q, struct bio *bio, dev_t dev,
@@ -370,6 +523,17 @@ TRACE_EVENT(block_remap,
                  (unsigned long long)__entry->old_sector)
 );
+/**
+ * block_rq_remap - map request for a block operation request
+ * @q: queue holding the operation
+ * @rq: block IO operation request
+ * @dev: device for the operation
+ * @from: original sector for the operation
+ *
+ * The block operation request @rq in @q has been remapped.  The block
+ * operation request @rq holds the current information and @from hold
+ * the original sector.
+ */
 TRACE_EVENT(block_rq_remap,
        TP_PROTO(struct request_queue *q, struct request *rq, dev_t dev,
diff --git a/include/trace/events/lock.h b/include/trace/events/lock.h
index 5c1dcfc16c60..2821b86de63b 100644
--- a/include/trace/events/lock.h
+++ b/include/trace/events/lock.h
@@ -35,15 +35,15 @@ TRACE_EVENT(lock_acquire,
                  __get_str(name))
 );
-TRACE_EVENT(lock_release,
+DECLARE_EVENT_CLASS(lock,
-        TP_PROTO(struct lockdep_map *lock, int nested, unsigned long ip),
+        TP_PROTO(struct lockdep_map *lock, unsigned long ip),
-        TP_ARGS(lock, nested, ip),
+        TP_ARGS(lock, ip),
        TP_STRUCT__entry(
-                __string(name, lock->name)
+                __string(       name,   lock->name      )
-                __field(void *, lockdep_addr)
+                __field(        void *, lockdep_addr    )
        ),
        TP_fast_assign(
@@ -51,51 +51,30 @@ TRACE_EVENT(lock_release,
                __entry->lockdep_addr = lock;
        ),
-        TP_printk("%p %s",
+        TP_printk("%p %s",  __entry->lockdep_addr, __get_str(name))
-                  __entry->lockdep_addr, __get_str(name))
 );
-#ifdef CONFIG_LOCK_STAT
+DEFINE_EVENT(lock, lock_release,
-TRACE_EVENT(lock_contended,
        TP_PROTO(struct lockdep_map *lock, unsigned long ip),
-        TP_ARGS(lock, ip),
+        TP_ARGS(lock, ip)
+);
-        TP_STRUCT__entry(
+#ifdef CONFIG_LOCK_STAT
-                __string(name, lock->name)
-                __field(void *, lockdep_addr)
-        ),
-        TP_fast_assign(
+DEFINE_EVENT(lock, lock_contended,
-                __assign_str(name, lock->name);
-                __entry->lockdep_addr = lock;
-        ),
-        TP_printk("%p %s",
+        TP_PROTO(struct lockdep_map *lock, unsigned long ip),
-                  __entry->lockdep_addr, __get_str(name))
-);
-TRACE_EVENT(lock_acquired,
+        TP_ARGS(lock, ip)
-        TP_PROTO(struct lockdep_map *lock, unsigned long ip, s64 waittime),
+);
-        TP_ARGS(lock, ip, waittime),
+DEFINE_EVENT(lock, lock_acquired,
-        TP_STRUCT__entry(
+        TP_PROTO(struct lockdep_map *lock, unsigned long ip),
-                __string(name, lock->name)
-                __field(s64, wait_nsec)
-                __field(void *, lockdep_addr)
-        ),
-        TP_fast_assign(
+        TP_ARGS(lock, ip)
-                __assign_str(name, lock->name);
-                __entry->wait_nsec = waittime;
-                __entry->lockdep_addr = lock;
-        ),
-        TP_printk("%p %s (%llu ns)", __entry->lockdep_addr,
-                  __get_str(name),
-                  __entry->wait_nsec)
 );
 #endif
diff --git a/include/trace/events/module.h b/include/trace/events/module.h
index 4b0f48ba16a6..c7bb2f0482fe 100644
--- a/include/trace/events/module.h
+++ b/include/trace/events/module.h
@@ -51,11 +51,14 @@ TRACE_EVENT(module_free,
        TP_printk("%s", __get_str(name))
 );
+#ifdef CONFIG_MODULE_UNLOAD
+/* trace_module_get/put are only used if CONFIG_MODULE_UNLOAD is defined */
 DECLARE_EVENT_CLASS(module_refcnt,
-        TP_PROTO(struct module *mod, unsigned long ip, int refcnt),
+        TP_PROTO(struct module *mod, unsigned long ip),
-        TP_ARGS(mod, ip, refcnt),
+        TP_ARGS(mod, ip),
        TP_STRUCT__entry(
                __field(        unsigned long,  ip              )
@@ -65,7 +68,7 @@ DECLARE_EVENT_CLASS(module_refcnt,
        TP_fast_assign(
                __entry->ip     = ip;
-                __entry->refcnt = refcnt;
+                __entry->refcnt = __this_cpu_read(mod->refptr->incs) + __this_cpu_read(mod->refptr->decs);
                __assign_str(name, mod->name);
        ),
@@ -75,17 +78,18 @@ DECLARE_EVENT_CLASS(module_refcnt,
 DEFINE_EVENT(module_refcnt, module_get,
-        TP_PROTO(struct module *mod, unsigned long ip, int refcnt),
+        TP_PROTO(struct module *mod, unsigned long ip),
-        TP_ARGS(mod, ip, refcnt)
+        TP_ARGS(mod, ip)
 );
 DEFINE_EVENT(module_refcnt, module_put,
-        TP_PROTO(struct module *mod, unsigned long ip, int refcnt),
+        TP_PROTO(struct module *mod, unsigned long ip),
-        TP_ARGS(mod, ip, refcnt)
+        TP_ARGS(mod, ip)
 );
+#endif /* CONFIG_MODULE_UNLOAD */
 TRACE_EVENT(module_request,
diff --git a/include/trace/events/napi.h b/include/trace/events/napi.h
index a8989c4547e7..188deca2f3c7 100644
--- a/include/trace/events/napi.h
+++ b/include/trace/events/napi.h
@@ -1,4 +1,7 @@
-#ifndef _TRACE_NAPI_H_
+#undef TRACE_SYSTEM
+#define TRACE_SYSTEM napi
+#if !defined(_TRACE_NAPI_H) || defined(TRACE_HEADER_MULTI_READ)
 #define _TRACE_NAPI_H_
 #include <linux/netdevice.h>
@@ -8,4 +11,7 @@ DECLARE_TRACE(napi_poll,
        TP_PROTO(struct napi_struct *napi),
        TP_ARGS(napi));
-#endif
+#endif /* _TRACE_NAPI_H_ */
+/* This part must be outside protection */
+#include <trace/define_trace.h>
diff --git a/include/trace/events/sched.h b/include/trace/events/sched.h
index cfceb0b73e20..4f733ecea46e 100644
--- a/include/trace/events/sched.h
+++ b/include/trace/events/sched.h
@@ -51,15 +51,12 @@ TRACE_EVENT(sched_kthread_stop_ret,
 /*
 * Tracepoint for waiting on task to unschedule:
- *
- * (NOTE: the 'rq' argument is not used by generic trace events,
- *        but used by the latency tracer plugin. )
 */
 TRACE_EVENT(sched_wait_task,
-        TP_PROTO(struct rq *rq, struct task_struct *p),
+        TP_PROTO(struct task_struct *p),
-        TP_ARGS(rq, p),
+        TP_ARGS(p),
        TP_STRUCT__entry(
                __array(        char,   comm,   TASK_COMM_LEN   )
@@ -79,15 +76,12 @@ TRACE_EVENT(sched_wait_task,
 /*
 * Tracepoint for waking up a task:
- *
- * (NOTE: the 'rq' argument is not used by generic trace events,
- *        but used by the latency tracer plugin. )
 */
 DECLARE_EVENT_CLASS(sched_wakeup_template,
-        TP_PROTO(struct rq *rq, struct task_struct *p, int success),
+        TP_PROTO(struct task_struct *p, int success),
-        TP_ARGS(rq, p, success),
+        TP_ARGS(p, success),
        TP_STRUCT__entry(
                __array(        char,   comm,   TASK_COMM_LEN   )
@@ -111,31 +105,25 @@ DECLARE_EVENT_CLASS(sched_wakeup_template,
 );
 DEFINE_EVENT(sched_wakeup_template, sched_wakeup,
-             TP_PROTO(struct rq *rq, struct task_struct *p, int success),
+             TP_PROTO(struct task_struct *p, int success),
-             TP_ARGS(rq, p, success));
+             TP_ARGS(p, success));
 /*
 * Tracepoint for waking up a new task:
- *
- * (NOTE: the 'rq' argument is not used by generic trace events,
- *        but used by the latency tracer plugin. )
 */
 DEFINE_EVENT(sched_wakeup_template, sched_wakeup_new,
-             TP_PROTO(struct rq *rq, struct task_struct *p, int success),
+             TP_PROTO(struct task_struct *p, int success),
-             TP_ARGS(rq, p, success));
+             TP_ARGS(p, success));
 /*
 * Tracepoint for task switches, performed by the scheduler:
- *
- * (NOTE: the 'rq' argument is not used by generic trace events,
- *        but used by the latency tracer plugin. )
 */
 TRACE_EVENT(sched_switch,
-        TP_PROTO(struct rq *rq, struct task_struct *prev,
+        TP_PROTO(struct task_struct *prev,
                 struct task_struct *next),
-        TP_ARGS(rq, prev, next),
+        TP_ARGS(prev, next),
        TP_STRUCT__entry(
                __array(        char,   prev_comm,      TASK_COMM_LEN   )
diff --git a/include/trace/events/signal.h b/include/trace/events/signal.h
index a510b75ac304..814566c99d29 100644
--- a/include/trace/events/signal.h
+++ b/include/trace/events/signal.h
@@ -100,18 +100,7 @@ TRACE_EVENT(signal_deliver,
                  __entry->sa_handler, __entry->sa_flags)
 );
-/**
+DECLARE_EVENT_CLASS(signal_queue_overflow,
- * signal_overflow_fail - called when signal queue is overflow
- * @sig: signal number
- * @group: signal to process group or not (bool)
- * @info: pointer to struct siginfo
- *
- * Kernel fails to generate 'sig' signal with 'info' siginfo, because
- * siginfo queue is overflow, and the signal is dropped.
- * 'group' is not 0 if the signal will be sent to a process group.
- * 'sig' is always one of RT signals.
- */
-TRACE_EVENT(signal_overflow_fail,
        TP_PROTO(int sig, int group, struct siginfo *info),
@@ -135,6 +124,24 @@ TRACE_EVENT(signal_overflow_fail,
 );
 /**
+ * signal_overflow_fail - called when signal queue is overflow
+ * @sig: signal number
+ * @group: signal to process group or not (bool)
+ * @info: pointer to struct siginfo
+ *
+ * Kernel fails to generate 'sig' signal with 'info' siginfo, because
+ * siginfo queue is overflow, and the signal is dropped.
+ * 'group' is not 0 if the signal will be sent to a process group.
+ * 'sig' is always one of RT signals.
+ */
+DEFINE_EVENT(signal_queue_overflow, signal_overflow_fail,
+        TP_PROTO(int sig, int group, struct siginfo *info),
+        TP_ARGS(sig, group, info)
+);
+/**
 * signal_lose_info - called when siginfo is lost
 * @sig: signal number
 * @group: signal to process group or not (bool)
@@ -145,28 +152,13 @@ TRACE_EVENT(signal_overflow_fail,
 * 'group' is not 0 if the signal will be sent to a process group.
 * 'sig' is always one of non-RT signals.
 */
-TRACE_EVENT(signal_lose_info,
+DEFINE_EVENT(signal_queue_overflow, signal_lose_info,
        TP_PROTO(int sig, int group, struct siginfo *info),
-        TP_ARGS(sig, group, info),
+        TP_ARGS(sig, group, info)
-        TP_STRUCT__entry(
-                __field(        int,    sig     )
-                __field(        int,    group   )
-                __field(        int,    errno   )
-                __field(        int,    code    )
-        ),
-        TP_fast_assign(
-                __entry->sig    = sig;
-                __entry->group  = group;
-                TP_STORE_SIGINFO(__entry, info);
-        ),
-        TP_printk("sig=%d group=%d errno=%d code=%d",
-                  __entry->sig, __entry->group, __entry->errno, __entry->code)
 );
 #endif /* _TRACE_SIGNAL_H */
 /* This part must be outside protection */
diff --git a/include/trace/ftrace.h b/include/trace/ftrace.h
index ea6f9d4a20e9..16253db38d73 100644
--- a/include/trace/ftrace.h
+++ b/include/trace/ftrace.h
@@ -154,9 +154,11 @@
 *
 *      field = (typeof(field))entry;
 *
- *      p = get_cpu_var(ftrace_event_seq);
+ *      p = &get_cpu_var(ftrace_event_seq);
 *      trace_seq_init(p);
- *      ret = trace_seq_printf(s, <TP_printk> "\n");
+ *      ret = trace_seq_printf(s, "%s: ", <call>);
+ *      if (ret)
+ *              ret = trace_seq_printf(s, <TP_printk> "\n");
 *      put_cpu();
 *      if (!ret)
 *              return TRACE_TYPE_PARTIAL_LINE;
@@ -450,38 +452,38 @@ perf_trace_disable_##name(struct ftrace_event_call *unused)		\
 *
 * static void ftrace_raw_event_<call>(proto)
 * {
+ *      struct ftrace_data_offsets_<call> __maybe_unused __data_offsets;
 *      struct ring_buffer_event *event;
 *      struct ftrace_raw_<call> *entry; <-- defined in stage 1
 *      struct ring_buffer *buffer;
 *      unsigned long irq_flags;
+ *      int __data_size;
 *      int pc;
 *
 *      local_save_flags(irq_flags);
 *      pc = preempt_count();
 *
+ *      __data_size = ftrace_get_offsets_<call>(&__data_offsets, args);
+ *
 *      event = trace_current_buffer_lock_reserve(&buffer,
 *                                event_<call>.id,
- *                                sizeof(struct ftrace_raw_<call>),
+ *                                sizeof(*entry) + __data_size,
 *                                irq_flags, pc);
 *      if (!event)
 *              return;
 *      entry   = ring_buffer_event_data(event);
 *
- *      <assign>;  <-- Here we assign the entries by the __field and
+ *      { <assign>; }  <-- Here we assign the entries by the __field and
- *                      __array macros.
+ *                         __array macros.
 *
- *      trace_current_buffer_unlock_commit(buffer, event, irq_flags, pc);
+ *      if (!filter_current_check_discard(buffer, event_call, entry, event))
+ *              trace_current_buffer_unlock_commit(buffer,
+ *                                                 event, irq_flags, pc);
 * }
 *
 * static int ftrace_raw_reg_event_<call>(struct ftrace_event_call *unused)
 * {
- *      int ret;
+ *      return register_trace_<call>(ftrace_raw_event_<call>);
- *
- *      ret = register_trace_<call>(ftrace_raw_event_<call>);
- *      if (!ret)
- *              pr_info("event trace: Could not activate trace point "
- *                      "probe to <call>");
- *      return ret;
 * }
 *
 * static void ftrace_unreg_event_<call>(struct ftrace_event_call *unused)
@@ -493,6 +495,8 @@ perf_trace_disable_##name(struct ftrace_event_call *unused)		\
 *      .trace                  = ftrace_raw_output_<call>, <-- stage 2
 * };
 *
+ * static const char print_fmt_<call>[] = <TP_printk>;
+ *
 * static struct ftrace_event_call __used
 * __attribute__((__aligned__(4)))
 * __attribute__((section("_ftrace_events"))) event_<call> = {
@@ -501,6 +505,8 @@ perf_trace_disable_##name(struct ftrace_event_call *unused)		\
 *      .raw_init               = trace_event_raw_init,
 *      .regfunc                = ftrace_reg_event_<call>,
 *      .unregfunc              = ftrace_unreg_event_<call>,
+ *      .print_fmt              = print_fmt_<call>,
+ *      .define_fields          = ftrace_define_fields_<call>,
 * }
 *
 */
@@ -569,7 +575,6 @@ ftrace_raw_event_id_##call(struct ftrace_event_call *event_call,	\
                return;                                                 \
        entry   = ring_buffer_event_data(event);                        \
                                                                        \
-                                                                        \
        tstruct                                                         \
                                                                        \
        { assign; }                                                     \
@@ -758,13 +763,12 @@ __attribute__((section("_ftrace_events"))) event_##call = {		\
 #define DECLARE_EVENT_CLASS(call, proto, args, tstruct, assign, print)  \
 static notrace void                                                     \
 perf_trace_templ_##call(struct ftrace_event_call *event_call,           \
-                            proto)                                      \
+                        struct pt_regs *__regs, proto)                  \
 {                                                                       \
        struct ftrace_data_offsets_##call __maybe_unused __data_offsets;\
        struct ftrace_raw_##call *entry;                                \
        u64 __addr = 0, __count = 1;                                    \
        unsigned long irq_flags;                                        \
-        struct pt_regs *__regs;                                         \
        int __entry_size;                                               \
        int __data_size;                                                \
        int rctx;                                                       \
@@ -785,20 +789,22 @@ perf_trace_templ_##call(struct ftrace_event_call *event_call,		\
                                                                        \
        { assign; }                                                     \
                                                                        \
-        __regs = &__get_cpu_var(perf_trace_regs);                       \
-        perf_fetch_caller_regs(__regs, 2);                              \
-                                                                        \
        perf_trace_buf_submit(entry, __entry_size, rctx, __addr,        \
                               __count, irq_flags, __regs);             \
 }
 #undef DEFINE_EVENT
-#define DEFINE_EVENT(template, call, proto, args)               \
+#define DEFINE_EVENT(template, call, proto, args)                       \
-static notrace void perf_trace_##call(proto)                    \
+static notrace void perf_trace_##call(proto)                            \
-{                                                               \
+{                                                                       \
-        struct ftrace_event_call *event_call = &event_##call;   \
+        struct ftrace_event_call *event_call = &event_##call;           \
-                                                                \
+        struct pt_regs *__regs = &get_cpu_var(perf_trace_regs);         \
-        perf_trace_templ_##template(event_call, args);          \
+                                                                        \
+        perf_fetch_caller_regs(__regs, 1);                              \
+                                                                        \
+        perf_trace_templ_##template(event_call, __regs, args);          \
+                                                                        \
+        put_cpu_var(perf_trace_regs);                                   \
 }
 #undef DEFINE_EVENT_PRINT
author	Paul Mundt <lethal@linux-sh.org>	2010-05-19 22:57:38 -0400
committer	Paul Mundt <lethal@linux-sh.org>	2010-05-19 22:57:38 -0400
commit	ffee72d4681c8777918268a96aef42bdeb6c367b (patch)
tree	4baf91483886d561c198ed0524ab54b783273e86 /include
parent	fb54d268329846aa13b2bc44a64d90e9b7131192 (diff)
parent	f72caf7e496465182eeda842ac66a5e75404ddf1 (diff)