22 files changed, 177 insertions, 50 deletions

diff --git a/include/linux/ata.h b/include/linux/ata.h
index d2992bfa1706..c1a2f345cbe6 100644
--- a/include/linux/ata.h
+++ b/include/linux/ata.h
@@ -487,8 +487,8 @@ enum ata_tf_protocols {
 };
 
 enum ata_ioctls {
-        ATA_IOC_GET_IO32        = 0x309,
-        ATA_IOC_SET_IO32        = 0x324,
+        ATA_IOC_GET_IO32        = 0x309, /* HDIO_GET_32BIT */
+        ATA_IOC_SET_IO32        = 0x324, /* HDIO_SET_32BIT */
 };
 
 /* core structures */
diff --git a/include/linux/bio.h b/include/linux/bio.h
index 5349e6816cbb..88bc64f00bb5 100644
--- a/include/linux/bio.h
+++ b/include/linux/bio.h
@@ -310,6 +310,38 @@ static inline void bio_clear_flag(struct bio *bio, unsigned int bit)
         bio->bi_flags &= ~(1U << bit);
 }
 
+static inline void bio_get_first_bvec(struct bio *bio, struct bio_vec *bv)
+{
+        *bv = bio_iovec(bio);
+}
+
+static inline void bio_get_last_bvec(struct bio *bio, struct bio_vec *bv)
+{
+        struct bvec_iter iter = bio->bi_iter;
+        int idx;
+
+        if (unlikely(!bio_multiple_segments(bio))) {
+                *bv = bio_iovec(bio);
+                return;
+        }
+
+        bio_advance_iter(bio, &iter, iter.bi_size);
+
+        if (!iter.bi_bvec_done)
+                idx = iter.bi_idx - 1;
+        else    /* in the middle of bvec */
+                idx = iter.bi_idx;
+
+        *bv = bio->bi_io_vec[idx];
+
+        /*
+         * iter.bi_bvec_done records actual length of the last bvec
+         * if this bio ends in the middle of one io vector
+         */
+        if (iter.bi_bvec_done)
+                bv->bv_len = iter.bi_bvec_done;
+}
+
 enum bip_flags {
         BIP_BLOCK_INTEGRITY     = 1 << 0, /* block layer owns integrity data */
         BIP_MAPPED_INTEGRITY    = 1 << 1, /* ref tag has been remapped */
diff --git a/include/linux/blkdev.h b/include/linux/blkdev.h
index 4571ef1a12a9..413c84fbc4ed 100644
--- a/include/linux/blkdev.h
+++ b/include/linux/blkdev.h
@@ -895,7 +895,7 @@ static inline unsigned int blk_rq_get_max_sectors(struct request *rq)
 {
         struct request_queue *q = rq->q;
 
-        if (unlikely(rq->cmd_type == REQ_TYPE_BLOCK_PC))
+        if (unlikely(rq->cmd_type != REQ_TYPE_FS))
                 return q->limits.max_hw_sectors;
 
         if (!q->limits.chunk_sectors || (rq->cmd_flags & REQ_DISCARD))
@@ -1372,6 +1372,13 @@ static inline void put_dev_sector(Sector p)
         page_cache_release(p.v);
 }
 
+static inline bool __bvec_gap_to_prev(struct request_queue *q,
+                                struct bio_vec *bprv, unsigned int offset)
+{
+        return offset ||
+                ((bprv->bv_offset + bprv->bv_len) & queue_virt_boundary(q));
+}
+
 /*
  * Check if adding a bio_vec after bprv with offset would create a gap in
  * the SG list. Most drivers don't care about this, but some do.
@@ -1381,18 +1388,22 @@ static inline bool bvec_gap_to_prev(struct request_queue *q,
 {
         if (!queue_virt_boundary(q))
                 return false;
-        return offset ||
-                ((bprv->bv_offset + bprv->bv_len) & queue_virt_boundary(q));
+        return __bvec_gap_to_prev(q, bprv, offset);
 }
 
 static inline bool bio_will_gap(struct request_queue *q, struct bio *prev,
                          struct bio *next)
 {
-        if (!bio_has_data(prev))
-                return false;
+        if (bio_has_data(prev) && queue_virt_boundary(q)) {
+                struct bio_vec pb, nb;
+
+                bio_get_last_bvec(prev, &pb);
+                bio_get_first_bvec(next, &nb);
 
-        return bvec_gap_to_prev(q, &prev->bi_io_vec[prev->bi_vcnt - 1],
-                                next->bi_io_vec[0].bv_offset);
+                return __bvec_gap_to_prev(q, &pb, nb.bv_offset);
+        }
+
+        return false;
 }
 
 static inline bool req_gap_back_merge(struct request *req, struct bio *bio)
diff --git a/include/linux/cache.h b/include/linux/cache.h
index 17e7e82d2aa7..1be04f8c563a 100644
--- a/include/linux/cache.h
+++ b/include/linux/cache.h
@@ -12,10 +12,24 @@
 #define SMP_CACHE_BYTES L1_CACHE_BYTES
 #endif
 
+/*
+ * __read_mostly is used to keep rarely changing variables out of frequently
+ * updated cachelines. If an architecture doesn't support it, ignore the
+ * hint.
+ */
 #ifndef __read_mostly
 #define __read_mostly
 #endif
 
+/*
+ * __ro_after_init is used to mark things that are read-only after init (i.e.
+ * after mark_rodata_ro() has been called). These are effectively read-only,
+ * but may get written to during init, so can't live in .rodata (via "const").
+ */
+#ifndef __ro_after_init
+#define __ro_after_init __attribute__((__section__(".data..ro_after_init")))
+#endif
+
 #ifndef ____cacheline_aligned
 #define ____cacheline_aligned __attribute__((__aligned__(SMP_CACHE_BYTES)))
 #endif
diff --git a/include/linux/ceph/ceph_features.h b/include/linux/ceph/ceph_features.h
index c1ef6f14e7be..15151f3c4120 100644
--- a/include/linux/ceph/ceph_features.h
+++ b/include/linux/ceph/ceph_features.h
@@ -75,6 +75,7 @@
 #define CEPH_FEATURE_CRUSH_TUNABLES5    (1ULL<<58) /* chooseleaf stable mode */
 // duplicated since it was introduced at the same time as CEPH_FEATURE_CRUSH_TUNABLES5
 #define CEPH_FEATURE_NEW_OSDOPREPLY_ENCODING   (1ULL<<58) /* New, v7 encoding */
+#define CEPH_FEATURE_FS_FILE_LAYOUT_V2       (1ULL<<58) /* file_layout_t */
 
 /*
  * The introduction of CEPH_FEATURE_OSD_SNAPMAPPER caused the feature
diff --git a/include/linux/compiler.h b/include/linux/compiler.h
index 48f5aab117ae..a27f4f17c382 100644
--- a/include/linux/compiler.h
+++ b/include/linux/compiler.h
@@ -263,8 +263,9 @@ static __always_inline void __write_once_size(volatile void *p, void *res, int s
  * In contrast to ACCESS_ONCE these two macros will also work on aggregate
  * data types like structs or unions. If the size of the accessed data
  * type exceeds the word size of the machine (e.g., 32 bits or 64 bits)
- * READ_ONCE() and WRITE_ONCE()  will fall back to memcpy and print a
- * compile-time warning.
+ * READ_ONCE() and WRITE_ONCE() will fall back to memcpy(). There's at
+ * least two memcpy()s: one for the __builtin_memcpy() and then one for
+ * the macro doing the copy of variable - '__u' allocated on the stack.
  *
  * Their two major use cases are: (1) Mediating communication between
  * process-level code and irq/NMI handlers, all running on the same CPU,
diff --git a/include/linux/dcache.h b/include/linux/dcache.h
index 7781ce110503..c4b5f4b3f8f8 100644
--- a/include/linux/dcache.h
+++ b/include/linux/dcache.h
@@ -409,9 +409,7 @@ static inline bool d_mountpoint(const struct dentry *dentry)
  */
 static inline unsigned __d_entry_type(const struct dentry *dentry)
 {
-        unsigned type = READ_ONCE(dentry->d_flags);
-        smp_rmb();
-        return type & DCACHE_ENTRY_TYPE;
+        return dentry->d_flags & DCACHE_ENTRY_TYPE;
 }
 
 static inline bool d_is_miss(const struct dentry *dentry)
diff --git a/include/linux/dma-mapping.h b/include/linux/dma-mapping.h
index 75857cda38e9..5e45cf930a3f 100644
--- a/include/linux/dma-mapping.h
+++ b/include/linux/dma-mapping.h
@@ -386,7 +386,7 @@ static inline void dma_free_attrs(struct device *dev, size_t size,
         if (dma_release_from_coherent(dev, get_order(size), cpu_addr))
                 return;
 
-        if (!ops->free)
+        if (!ops->free || !cpu_addr)
                 return;
 
         debug_dma_free_coherent(dev, size, cpu_addr, dma_handle);
@@ -641,31 +641,40 @@ static inline void dmam_release_declared_memory(struct device *dev)
 }
 #endif /* CONFIG_HAVE_GENERIC_DMA_COHERENT */
 
-static inline void *dma_alloc_writecombine(struct device *dev, size_t size,
-                                           dma_addr_t *dma_addr, gfp_t gfp)
+static inline void *dma_alloc_wc(struct device *dev, size_t size,
+                                 dma_addr_t *dma_addr, gfp_t gfp)
 {
         DEFINE_DMA_ATTRS(attrs);
         dma_set_attr(DMA_ATTR_WRITE_COMBINE, &attrs);
         return dma_alloc_attrs(dev, size, dma_addr, gfp, &attrs);
 }
+#ifndef dma_alloc_writecombine
+#define dma_alloc_writecombine dma_alloc_wc
+#endif
 
-static inline void dma_free_writecombine(struct device *dev, size_t size,
-                                         void *cpu_addr, dma_addr_t dma_addr)
+static inline void dma_free_wc(struct device *dev, size_t size,
+                               void *cpu_addr, dma_addr_t dma_addr)
 {
         DEFINE_DMA_ATTRS(attrs);
         dma_set_attr(DMA_ATTR_WRITE_COMBINE, &attrs);
         return dma_free_attrs(dev, size, cpu_addr, dma_addr, &attrs);
 }
+#ifndef dma_free_writecombine
+#define dma_free_writecombine dma_free_wc
+#endif
 
-static inline int dma_mmap_writecombine(struct device *dev,
-                                        struct vm_area_struct *vma,
-                                        void *cpu_addr, dma_addr_t dma_addr,
-                                        size_t size)
+static inline int dma_mmap_wc(struct device *dev,
+                              struct vm_area_struct *vma,
+                              void *cpu_addr, dma_addr_t dma_addr,
+                              size_t size)
 {
         DEFINE_DMA_ATTRS(attrs);
         dma_set_attr(DMA_ATTR_WRITE_COMBINE, &attrs);
         return dma_mmap_attrs(dev, vma, cpu_addr, dma_addr, size, &attrs);
 }
+#ifndef dma_mmap_writecombine
+#define dma_mmap_writecombine dma_mmap_wc
+#endif
 
 #ifdef CONFIG_NEED_DMA_MAP_STATE
 #define DEFINE_DMA_UNMAP_ADDR(ADDR_NAME)        dma_addr_t ADDR_NAME
diff --git a/include/linux/init.h b/include/linux/init.h
index b449f378f995..aedb254abc37 100644
--- a/include/linux/init.h
+++ b/include/linux/init.h
@@ -142,6 +142,10 @@ void prepare_namespace(void);
 void __init load_default_modules(void);
 int __init init_rootfs(void);
 
+#ifdef CONFIG_DEBUG_RODATA
+void mark_rodata_ro(void);
+#endif
+
 extern void (*late_time_init)(void);
 
 extern bool initcall_debug;
diff --git a/include/linux/ioport.h b/include/linux/ioport.h
index 24bea087e7af..afb45597fb5f 100644
--- a/include/linux/ioport.h
+++ b/include/linux/ioport.h
@@ -20,6 +20,7 @@ struct resource {
         resource_size_t end;
         const char *name;
         unsigned long flags;
+        unsigned long desc;
         struct resource *parent, *sibling, *child;
 };
 
@@ -49,12 +50,19 @@ struct resource {
 #define IORESOURCE_WINDOW       0x00200000      /* forwarded by bridge */
 #define IORESOURCE_MUXED        0x00400000      /* Resource is software muxed */
 
+#define IORESOURCE_EXT_TYPE_BITS 0x01000000     /* Resource extended types */
+#define IORESOURCE_SYSRAM       0x01000000      /* System RAM (modifier) */
+
 #define IORESOURCE_EXCLUSIVE    0x08000000      /* Userland may not map this resource */
+
 #define IORESOURCE_DISABLED     0x10000000
 #define IORESOURCE_UNSET        0x20000000      /* No address assigned yet */
 #define IORESOURCE_AUTO         0x40000000
 #define IORESOURCE_BUSY         0x80000000      /* Driver has marked this resource busy */
 
+/* I/O resource extended types */
+#define IORESOURCE_SYSTEM_RAM           (IORESOURCE_MEM|IORESOURCE_SYSRAM)
+
 /* PnP IRQ specific bits (IORESOURCE_BITS) */
 #define IORESOURCE_IRQ_HIGHEDGE         (1<<0)
 #define IORESOURCE_IRQ_LOWEDGE          (1<<1)
@@ -105,6 +113,22 @@ struct resource {
 /* PCI control bits.  Shares IORESOURCE_BITS with above PCI ROM.  */
 #define IORESOURCE_PCI_FIXED            (1<<4)  /* Do not move resource */
 
+/*
+ * I/O Resource Descriptors
+ *
+ * Descriptors are used by walk_iomem_res_desc() and region_intersects()
+ * for searching a specific resource range in the iomem table.  Assign
+ * a new descriptor when a resource range supports the search interfaces.
+ * Otherwise, resource.desc must be set to IORES_DESC_NONE (0).
+ */
+enum {
+        IORES_DESC_NONE                         = 0,
+        IORES_DESC_CRASH_KERNEL                 = 1,
+        IORES_DESC_ACPI_TABLES                  = 2,
+        IORES_DESC_ACPI_NV_STORAGE              = 3,
+        IORES_DESC_PERSISTENT_MEMORY            = 4,
+        IORES_DESC_PERSISTENT_MEMORY_LEGACY     = 5,
+};
 
 /* helpers to define resources */
 #define DEFINE_RES_NAMED(_start, _size, _name, _flags)                  \
@@ -113,6 +137,7 @@ struct resource {
                 .end = (_start) + (_size) - 1,                          \
                 .name = (_name),                                        \
                 .flags = (_flags),                                      \
+                .desc = IORES_DESC_NONE,                                \
         }
 
 #define DEFINE_RES_IO_NAMED(_start, _size, _name)                       \
@@ -170,6 +195,10 @@ static inline unsigned long resource_type(const struct resource *res)
 {
         return res->flags & IORESOURCE_TYPE_BITS;
 }
+static inline unsigned long resource_ext_type(const struct resource *res)
+{
+        return res->flags & IORESOURCE_EXT_TYPE_BITS;
+}
 /* True iff r1 completely contains r2 */
 static inline bool resource_contains(struct resource *r1, struct resource *r2)
 {
@@ -239,8 +268,8 @@ extern int
 walk_system_ram_res(u64 start, u64 end, void *arg,
                     int (*func)(u64, u64, void *));
 extern int
-walk_iomem_res(char *name, unsigned long flags, u64 start, u64 end, void *arg,
-               int (*func)(u64, u64, void *));
+walk_iomem_res_desc(unsigned long desc, unsigned long flags, u64 start, u64 end,
+                    void *arg, int (*func)(u64, u64, void *));
 
 /* True if any part of r1 overlaps r2 */
 static inline bool resource_overlaps(struct resource *r1, struct resource *r2)
diff --git a/include/linux/kasan.h b/include/linux/kasan.h
index 4b9f85c963d0..0fdc798e3ff7 100644
--- a/include/linux/kasan.h
+++ b/include/linux/kasan.h
@@ -1,6 +1,7 @@
 #ifndef _LINUX_KASAN_H
 #define _LINUX_KASAN_H
 
+#include <linux/sched.h>
 #include <linux/types.h>
 
 struct kmem_cache;
@@ -13,7 +14,6 @@ struct vm_struct;
 
 #include <asm/kasan.h>
 #include <asm/pgtable.h>
-#include <linux/sched.h>
 
 extern unsigned char kasan_zero_page[PAGE_SIZE];
 extern pte_t kasan_zero_pte[PTRS_PER_PTE];
@@ -43,6 +43,8 @@ static inline void kasan_disable_current(void)
 
 void kasan_unpoison_shadow(const void *address, size_t size);
 
+void kasan_unpoison_task_stack(struct task_struct *task);
+
 void kasan_alloc_pages(struct page *page, unsigned int order);
 void kasan_free_pages(struct page *page, unsigned int order);
 
@@ -66,6 +68,8 @@ void kasan_free_shadow(const struct vm_struct *vm);
 
 static inline void kasan_unpoison_shadow(const void *address, size_t size) {}
 
+static inline void kasan_unpoison_task_stack(struct task_struct *task) {}
+
 static inline void kasan_enable_current(void) {}
 static inline void kasan_disable_current(void) {}
 
diff --git a/include/linux/libata.h b/include/linux/libata.h
index bec2abbd7ab2..2c4ebef79d0c 100644
--- a/include/linux/libata.h
+++ b/include/linux/libata.h
@@ -720,7 +720,7 @@ struct ata_device {
         union {
                 u16             id[ATA_ID_WORDS]; /* IDENTIFY xxx DEVICE data */
                 u32             gscr[SATA_PMP_GSCR_DWORDS]; /* PMP GSCR block */
-        };
+        } ____cacheline_aligned;
 
         /* DEVSLP Timing Variables from Identify Device Data Log */
         u8                      devslp_timing[ATA_LOG_DEVSLP_SIZE];
diff --git a/include/linux/list.h b/include/linux/list.h
index 30cf4200ab40..5356f4d661a7 100644
--- a/include/linux/list.h
+++ b/include/linux/list.h
@@ -113,17 +113,6 @@ extern void __list_del_entry(struct list_head *entry);
 extern void list_del(struct list_head *entry);
 #endif
 
-#ifdef CONFIG_DEBUG_LIST
-/*
- * See devm_memremap_pages() which wants DEBUG_LIST=y to assert if one
- * of the pages it allocates is ever passed to list_add()
- */
-extern void list_force_poison(struct list_head *entry);
-#else
-/* fallback to the less strict LIST_POISON* definitions */
-#define list_force_poison list_del
-#endif
-
 /**
  * list_replace - replace old entry by new one
  * @old : the element to be replaced
diff --git a/include/linux/lockdep.h b/include/linux/lockdep.h
index 4dca42fd32f5..d026b190c530 100644
--- a/include/linux/lockdep.h
+++ b/include/linux/lockdep.h
@@ -261,7 +261,6 @@ struct held_lock {
 /*
  * Initialization, self-test and debugging-output methods:
  */
-extern void lockdep_init(void);
 extern void lockdep_info(void);
 extern void lockdep_reset(void);
 extern void lockdep_reset_lock(struct lockdep_map *lock);
@@ -392,7 +391,6 @@ static inline void lockdep_on(void)
 # define lockdep_set_current_reclaim_state(g)   do { } while (0)
 # define lockdep_clear_current_reclaim_state()  do { } while (0)
 # define lockdep_trace_alloc(g)                 do { } while (0)
-# define lockdep_init()                         do { } while (0)
 # define lockdep_info()                         do { } while (0)
 # define lockdep_init_map(lock, name, key, sub) \
                 do { (void)(name); (void)(key); } while (0)
diff --git a/include/linux/mlx5/mlx5_ifc.h b/include/linux/mlx5/mlx5_ifc.h
index 51f1e540fc2b..58eef02edc7e 100644
--- a/include/linux/mlx5/mlx5_ifc.h
+++ b/include/linux/mlx5/mlx5_ifc.h
@@ -4245,7 +4245,9 @@ struct mlx5_ifc_modify_tir_bitmask_bits {
 
         u8         reserved_at_20[0x1b];
         u8         self_lb_en[0x1];
-        u8         reserved_at_3c[0x3];
+        u8         reserved_at_3c[0x1];
+        u8         hash[0x1];
+        u8         reserved_at_3e[0x1];
         u8         lro[0x1];
 };
 
diff --git a/include/linux/mm.h b/include/linux/mm.h
index 516e14944339..2b6e22782699 100644
--- a/include/linux/mm.h
+++ b/include/linux/mm.h
@@ -387,7 +387,8 @@ enum {
         REGION_MIXED,
 };
 
-int region_intersects(resource_size_t offset, size_t size, const char *type);
+int region_intersects(resource_size_t offset, size_t size, unsigned long flags,
+                      unsigned long desc);
 
 /* Support for virtually mapped pages */
 struct page *vmalloc_to_page(const void *addr);
diff --git a/include/linux/perf_event.h b/include/linux/perf_event.h
index f5c5a3fa2c81..a9d8cab18b00 100644
--- a/include/linux/perf_event.h
+++ b/include/linux/perf_event.h
@@ -468,6 +468,7 @@ struct perf_event {
         int                             group_flags;
         struct perf_event               *group_leader;
         struct pmu                      *pmu;
+        void                            *pmu_private;
 
         enum perf_event_active_state    state;
         unsigned int                    attach_state;
diff --git a/include/linux/skbuff.h b/include/linux/skbuff.h
index 4ce9ff7086f4..d3fcd4591ce4 100644
--- a/include/linux/skbuff.h
+++ b/include/linux/skbuff.h
@@ -1985,6 +1985,30 @@ static inline void skb_reserve(struct sk_buff *skb, int len)
         skb->tail += len;
 }
 
+/**
+ *      skb_tailroom_reserve - adjust reserved_tailroom
+ *      @skb: buffer to alter
+ *      @mtu: maximum amount of headlen permitted
+ *      @needed_tailroom: minimum amount of reserved_tailroom
+ *
+ *      Set reserved_tailroom so that headlen can be as large as possible but
+ *      not larger than mtu and tailroom cannot be smaller than
+ *      needed_tailroom.
+ *      The required headroom should already have been reserved before using
+ *      this function.
+ */
+static inline void skb_tailroom_reserve(struct sk_buff *skb, unsigned int mtu,
+                                        unsigned int needed_tailroom)
+{
+        SKB_LINEAR_ASSERT(skb);
+        if (mtu < skb_tailroom(skb) - needed_tailroom)
+                /* use at most mtu */
+                skb->reserved_tailroom = skb_tailroom(skb) - mtu;
+        else
+                /* use up to all available space */
+                skb->reserved_tailroom = needed_tailroom;
+}
+
 #define ENCAP_TYPE_ETHER        0
 #define ENCAP_TYPE_IPPROTO      1
 
diff --git a/include/linux/stmmac.h b/include/linux/stmmac.h
index eead8ab93c0a..881a79d52467 100644
--- a/include/linux/stmmac.h
+++ b/include/linux/stmmac.h
@@ -100,6 +100,7 @@ struct plat_stmmacenet_data {
         int interface;
         struct stmmac_mdio_bus_data *mdio_bus_data;
         struct device_node *phy_node;
+        struct device_node *mdio_node;
         struct stmmac_dma_cfg *dma_cfg;
         int clk_csr;
         int has_gmac;
diff --git a/include/linux/trace_events.h b/include/linux/trace_events.h
index 429fdfc3baf5..925730bc9fc1 100644
--- a/include/linux/trace_events.h
+++ b/include/linux/trace_events.h
@@ -568,6 +568,8 @@ enum {
         FILTER_DYN_STRING,
         FILTER_PTR_STRING,
         FILTER_TRACE_FN,
+        FILTER_COMM,
+        FILTER_CPU,
 };
 
 extern int trace_event_raw_init(struct trace_event_call *call);
diff --git a/include/linux/tracepoint.h b/include/linux/tracepoint.h
index acfdbf353a0b..be586c632a0c 100644
--- a/include/linux/tracepoint.h
+++ b/include/linux/tracepoint.h
@@ -134,9 +134,6 @@ extern void syscall_unregfunc(void);
                 void *it_func;                                          \
                 void *__data;                                           \
                                                                         \
-                if (!cpu_online(raw_smp_processor_id()))                \
-                        return;                                         \
-                                                                        \
                 if (!(cond))                                            \
                         return;                                         \
                 prercu;                                                 \
@@ -343,15 +340,19 @@ extern void syscall_unregfunc(void);
  * "void *__data, proto" as the callback prototype.
  */
 #define DECLARE_TRACE_NOARGS(name)                                      \
-                __DECLARE_TRACE(name, void, , 1, void *__data, __data)
+        __DECLARE_TRACE(name, void, ,                                   \
+                        cpu_online(raw_smp_processor_id()),             \
+                        void *__data, __data)
 
 #define DECLARE_TRACE(name, proto, args)                                \
-                __DECLARE_TRACE(name, PARAMS(proto), PARAMS(args), 1,   \
-                                PARAMS(void *__data, proto),            \
-                                PARAMS(__data, args))
+        __DECLARE_TRACE(name, PARAMS(proto), PARAMS(args),              \
+                        cpu_online(raw_smp_processor_id()),             \
+                        PARAMS(void *__data, proto),                    \
+                        PARAMS(__data, args))
 
 #define DECLARE_TRACE_CONDITION(name, proto, args, cond)                \
-        __DECLARE_TRACE(name, PARAMS(proto), PARAMS(args), PARAMS(cond), \
+        __DECLARE_TRACE(name, PARAMS(proto), PARAMS(args),              \
+                        cpu_online(raw_smp_processor_id()) && (PARAMS(cond)), \
                         PARAMS(void *__data, proto),                    \
                         PARAMS(__data, args))
 
diff --git a/include/linux/writeback.h b/include/linux/writeback.h
index b333c945e571..d0b5ca5d4e08 100644
--- a/include/linux/writeback.h
+++ b/include/linux/writeback.h
@@ -198,6 +198,7 @@ void wbc_attach_and_unlock_inode(struct writeback_control *wbc,
 void wbc_detach_inode(struct writeback_control *wbc);
 void wbc_account_io(struct writeback_control *wbc, struct page *page,
                     size_t bytes);
+void cgroup_writeback_umount(void);
 
 /**
  * inode_attach_wb - associate an inode with its wb
@@ -301,6 +302,10 @@ static inline void wbc_account_io(struct writeback_control *wbc,
 {
 }
 
+static inline void cgroup_writeback_umount(void)
+{
+}
+
 #endif  /* CONFIG_CGROUP_WRITEBACK */
 
 /*