Merge branch 'smp-hotplug-for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/tip/tip

Pull CPU hotplug updates from Thomas Gleixner:
 "Yet another batch of cpu hotplug core updates and conversions:

   - Provide core infrastructure for multi instance drivers so the
     drivers do not have to keep custom lists.

   - Convert custom lists to the new infrastructure. The block-mq custom
     list conversion comes through the block tree and makes the diffstat
     tip over to more lines removed than added.

   - Handle unbalanced hotplug enable/disable calls more gracefully.

   - Remove the obsolete CPU_STARTING/DYING notifier support.

   - Convert another batch of notifier users.

   The relayfs changes which conflicted with the conversion have been
   shipped to me by Andrew.

   The remaining lot is targeted for 4.10 so that we finally can remove
   the rest of the notifiers"

* 'smp-hotplug-for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/tip/tip: (46 commits)
  cpufreq: Fix up conversion to hotplug state machine
  blk/mq: Reserve hotplug states for block multiqueue
  x86/apic/uv: Convert to hotplug state machine
  s390/mm/pfault: Convert to hotplug state machine
  mips/loongson/smp: Convert to hotplug state machine
  mips/octeon/smp: Convert to hotplug state machine
  fault-injection/cpu: Convert to hotplug state machine
  padata: Convert to hotplug state machine
  cpufreq: Convert to hotplug state machine
  ACPI/processor: Convert to hotplug state machine
  virtio scsi: Convert to hotplug state machine
  oprofile/timer: Convert to hotplug state machine
  block/softirq: Convert to hotplug state machine
  lib/irq_poll: Convert to hotplug state machine
  x86/microcode: Convert to hotplug state machine
  sh/SH-X3 SMP: Convert to hotplug state machine
  ia64/mca: Convert to hotplug state machine
  ARM/OMAP/wakeupgen: Convert to hotplug state machine
  ARM/shmobile: Convert to hotplug state machine
  arm64/FP/SIMD: Convert to hotplug state machine
  ...

6 files changed, 158 insertions, 25 deletions

diff --git a/include/linux/cpu.h b/include/linux/cpu.h
index ad4f1f33a74e..7572d9e9dced 100644
--- a/include/linux/cpu.h
+++ b/include/linux/cpu.h
@@ -61,17 +61,8 @@ struct notifier_block;
 #define CPU_DOWN_PREPARE        0x0005 /* CPU (unsigned)v going down */
 #define CPU_DOWN_FAILED         0x0006 /* CPU (unsigned)v NOT going down */
 #define CPU_DEAD                0x0007 /* CPU (unsigned)v dead */
-#define CPU_DYING               0x0008 /* CPU (unsigned)v not running any task,
-                                        * not handling interrupts, soon dead.
-                                        * Called on the dying cpu, interrupts
-                                        * are already disabled. Must not
-                                        * sleep, must not fail */
 #define CPU_POST_DEAD           0x0009 /* CPU (unsigned)v dead, cpu_hotplug
                                         * lock is dropped */
-#define CPU_STARTING            0x000A /* CPU (unsigned)v soon running.
-                                        * Called on the new cpu, just before
-                                        * enabling interrupts. Must not sleep,
-                                        * must not fail */
 #define CPU_BROKEN              0x000B /* CPU (unsigned)v did not die properly,
                                         * perhaps due to preemption. */
 
@@ -86,9 +77,6 @@ struct notifier_block;
 #define CPU_DOWN_PREPARE_FROZEN (CPU_DOWN_PREPARE | CPU_TASKS_FROZEN)
 #define CPU_DOWN_FAILED_FROZEN  (CPU_DOWN_FAILED | CPU_TASKS_FROZEN)
 #define CPU_DEAD_FROZEN         (CPU_DEAD | CPU_TASKS_FROZEN)
-#define CPU_DYING_FROZEN        (CPU_DYING | CPU_TASKS_FROZEN)
-#define CPU_STARTING_FROZEN     (CPU_STARTING | CPU_TASKS_FROZEN)
-
 
 #ifdef CONFIG_SMP
 extern bool cpuhp_tasks_frozen;
diff --git a/include/linux/cpuhotplug.h b/include/linux/cpuhotplug.h
index eb445a4e2a83..7b6c446ee17f 100644
--- a/include/linux/cpuhotplug.h
+++ b/include/linux/cpuhotplug.h
@@ -16,15 +16,40 @@ enum cpuhp_state {
         CPUHP_PERF_SUPERH,
         CPUHP_X86_HPET_DEAD,
         CPUHP_X86_APB_DEAD,
+        CPUHP_VIRT_NET_DEAD,
+        CPUHP_SLUB_DEAD,
+        CPUHP_MM_WRITEBACK_DEAD,
+        CPUHP_SOFTIRQ_DEAD,
+        CPUHP_NET_MVNETA_DEAD,
+        CPUHP_CPUIDLE_DEAD,
+        CPUHP_ARM64_FPSIMD_DEAD,
+        CPUHP_ARM_OMAP_WAKE_DEAD,
+        CPUHP_IRQ_POLL_DEAD,
+        CPUHP_BLOCK_SOFTIRQ_DEAD,
+        CPUHP_VIRT_SCSI_DEAD,
+        CPUHP_ACPI_CPUDRV_DEAD,
+        CPUHP_S390_PFAULT_DEAD,
+        CPUHP_BLK_MQ_DEAD,
         CPUHP_WORKQUEUE_PREP,
         CPUHP_POWER_NUMA_PREPARE,
         CPUHP_HRTIMERS_PREPARE,
         CPUHP_PROFILE_PREPARE,
         CPUHP_X2APIC_PREPARE,
         CPUHP_SMPCFD_PREPARE,
+        CPUHP_RELAY_PREPARE,
+        CPUHP_SLAB_PREPARE,
+        CPUHP_MD_RAID5_PREPARE,
         CPUHP_RCUTREE_PREP,
+        CPUHP_CPUIDLE_COUPLED_PREPARE,
+        CPUHP_POWERPC_PMAC_PREPARE,
+        CPUHP_POWERPC_MMU_CTX_PREPARE,
         CPUHP_NOTIFY_PREPARE,
+        CPUHP_ARM_SHMOBILE_SCU_PREPARE,
+        CPUHP_SH_SH3X_PREPARE,
+        CPUHP_BLK_MQ_PREPARE,
         CPUHP_TIMERS_DEAD,
+        CPUHP_NOTF_ERR_INJ_PREPARE,
+        CPUHP_MIPS_SOC_PREPARE,
         CPUHP_BRINGUP_CPU,
         CPUHP_AP_IDLE_DEAD,
         CPUHP_AP_OFFLINE,
@@ -72,7 +97,6 @@ enum cpuhp_state {
         CPUHP_AP_ARM64_ISNDEP_STARTING,
         CPUHP_AP_SMPCFD_DYING,
         CPUHP_AP_X86_TBOOT_DYING,
-        CPUHP_AP_NOTIFY_STARTING,
         CPUHP_AP_ONLINE,
         CPUHP_TEARDOWN_CPU,
         CPUHP_AP_ONLINE_IDLE,
@@ -103,7 +127,7 @@ enum cpuhp_state {
 
 int __cpuhp_setup_state(enum cpuhp_state state, const char *name, bool invoke,
                         int (*startup)(unsigned int cpu),
-                        int (*teardown)(unsigned int cpu));
+                        int (*teardown)(unsigned int cpu), bool multi_instance);
 
 /**
  * cpuhp_setup_state - Setup hotplug state callbacks with calling the callbacks
@@ -120,7 +144,7 @@ static inline int cpuhp_setup_state(enum cpuhp_state state,
                                     int (*startup)(unsigned int cpu),
                                     int (*teardown)(unsigned int cpu))
 {
-        return __cpuhp_setup_state(state, name, true, startup, teardown);
+        return __cpuhp_setup_state(state, name, true, startup, teardown, false);
 }
 
 /**
@@ -139,7 +163,66 @@ static inline int cpuhp_setup_state_nocalls(enum cpuhp_state state,
                                             int (*startup)(unsigned int cpu),
                                             int (*teardown)(unsigned int cpu))
 {
-        return __cpuhp_setup_state(state, name, false, startup, teardown);
+        return __cpuhp_setup_state(state, name, false, startup, teardown,
+                                   false);
+}
+
+/**
+ * cpuhp_setup_state_multi - Add callbacks for multi state
+ * @state:      The state for which the calls are installed
+ * @name:       Name of the callback.
+ * @startup:    startup callback function
+ * @teardown:   teardown callback function
+ *
+ * Sets the internal multi_instance flag and prepares a state to work as a multi
+ * instance callback. No callbacks are invoked at this point. The callbacks are
+ * invoked once an instance for this state are registered via
+ * @cpuhp_state_add_instance or @cpuhp_state_add_instance_nocalls.
+ */
+static inline int cpuhp_setup_state_multi(enum cpuhp_state state,
+                                          const char *name,
+                                          int (*startup)(unsigned int cpu,
+                                                         struct hlist_node *node),
+                                          int (*teardown)(unsigned int cpu,
+                                                          struct hlist_node *node))
+{
+        return __cpuhp_setup_state(state, name, false,
+                                   (void *) startup,
+                                   (void *) teardown, true);
+}
+
+int __cpuhp_state_add_instance(enum cpuhp_state state, struct hlist_node *node,
+                               bool invoke);
+
+/**
+ * cpuhp_state_add_instance - Add an instance for a state and invoke startup
+ *                            callback.
+ * @state:      The state for which the instance is installed
+ * @node:       The node for this individual state.
+ *
+ * Installs the instance for the @state and invokes the startup callback on
+ * the present cpus which have already reached the @state. The @state must have
+ * been earlier marked as multi-instance by @cpuhp_setup_state_multi.
+ */
+static inline int cpuhp_state_add_instance(enum cpuhp_state state,
+                                           struct hlist_node *node)
+{
+        return __cpuhp_state_add_instance(state, node, true);
+}
+
+/**
+ * cpuhp_state_add_instance_nocalls - Add an instance for a state without
+ *                                    invoking the startup callback.
+ * @state:      The state for which the instance is installed
+ * @node:       The node for this individual state.
+ *
+ * Installs the instance for the @state The @state must have been earlier
+ * marked as multi-instance by @cpuhp_setup_state_multi.
+ */
+static inline int cpuhp_state_add_instance_nocalls(enum cpuhp_state state,
+                                                   struct hlist_node *node)
+{
+        return __cpuhp_state_add_instance(state, node, false);
 }
 
 void __cpuhp_remove_state(enum cpuhp_state state, bool invoke);
@@ -166,6 +249,51 @@ static inline void cpuhp_remove_state_nocalls(enum cpuhp_state state)
         __cpuhp_remove_state(state, false);
 }
 
+/**
+ * cpuhp_remove_multi_state - Remove hotplug multi state callback
+ * @state:      The state for which the calls are removed
+ *
+ * Removes the callback functions from a multi state. This is the reverse of
+ * cpuhp_setup_state_multi(). All instances should have been removed before
+ * invoking this function.
+ */
+static inline void cpuhp_remove_multi_state(enum cpuhp_state state)
+{
+        __cpuhp_remove_state(state, false);
+}
+
+int __cpuhp_state_remove_instance(enum cpuhp_state state,
+                                  struct hlist_node *node, bool invoke);
+
+/**
+ * cpuhp_state_remove_instance - Remove hotplug instance from state and invoke
+ *                               the teardown callback
+ * @state:      The state from which the instance is removed
+ * @node:       The node for this individual state.
+ *
+ * Removes the instance and invokes the teardown callback on the present cpus
+ * which have already reached the @state.
+ */
+static inline int cpuhp_state_remove_instance(enum cpuhp_state state,
+                                              struct hlist_node *node)
+{
+        return __cpuhp_state_remove_instance(state, node, true);
+}
+
+/**
+ * cpuhp_state_remove_instance_nocalls - Remove hotplug instance from state
+ *                                       without invoking the reatdown callback
+ * @state:      The state from which the instance is removed
+ * @node:       The node for this individual state.
+ *
+ * Removes the instance without invoking the teardown callback.
+ */
+static inline int cpuhp_state_remove_instance_nocalls(enum cpuhp_state state,
+                                                      struct hlist_node *node)
+{
+        return __cpuhp_state_remove_instance(state, node, false);
+}
+
 #ifdef CONFIG_SMP
 void cpuhp_online_idle(enum cpuhp_state state);
 #else
diff --git a/include/linux/padata.h b/include/linux/padata.h
index 113ee626a4dc..0f9e567d5e15 100644
--- a/include/linux/padata.h
+++ b/include/linux/padata.h
@@ -151,7 +151,7 @@ struct parallel_data {
  * @flags: padata flags.
  */
 struct padata_instance {
-        struct notifier_block            cpu_notifier;
+        struct hlist_node                node;
         struct workqueue_struct         *wq;
         struct parallel_data            *pd;
         struct padata_cpumask           cpumask;
diff --git a/include/linux/perf/arm_pmu.h b/include/linux/perf/arm_pmu.h
index 9ff07d3fc8de..8462da266089 100644
--- a/include/linux/perf/arm_pmu.h
+++ b/include/linux/perf/arm_pmu.h
@@ -116,7 +116,7 @@ struct arm_pmu {
         DECLARE_BITMAP(pmceid_bitmap, ARMV8_PMUV3_MAX_COMMON_EVENTS);
         struct platform_device  *plat_device;
         struct pmu_hw_events    __percpu *hw_events;
-        struct list_head        entry;
+        struct hlist_node       node;
         struct notifier_block   cpu_pm_nb;
         /* the attr_groups array must be NULL-terminated */
         const struct attribute_group *attr_groups[ARMPMU_NR_ATTR_GROUPS + 1];
diff --git a/include/linux/relay.h b/include/linux/relay.h
index d7c8359693c6..ecbb34a382b8 100644
--- a/include/linux/relay.h
+++ b/include/linux/relay.h
@@ -19,6 +19,7 @@
 #include <linux/fs.h>
 #include <linux/poll.h>
 #include <linux/kref.h>
+#include <linux/percpu.h>
 
 /*
  * Tracks changes to rchan/rchan_buf structs
@@ -63,7 +64,7 @@ struct rchan
         struct kref kref;               /* channel refcount */
         void *private_data;             /* for user-defined data */
         size_t last_toobig;             /* tried to log event > subbuf size */
-        struct rchan_buf *buf[NR_CPUS]; /* per-cpu channel buffers */
+        struct rchan_buf ** __percpu buf; /* per-cpu channel buffers */
         int is_global;                  /* One global buffer ? */
         struct list_head list;          /* for channel list */
         struct dentry *parent;          /* parent dentry passed to open */
@@ -204,7 +205,7 @@ static inline void relay_write(struct rchan *chan,
         struct rchan_buf *buf;
 
         local_irq_save(flags);
-        buf = chan->buf[smp_processor_id()];
+        buf = *this_cpu_ptr(chan->buf);
         if (unlikely(buf->offset + length > chan->subbuf_size))
                 length = relay_switch_subbuf(buf, length);
         memcpy(buf->data + buf->offset, data, length);
@@ -230,12 +231,12 @@ static inline void __relay_write(struct rchan *chan,
 {
         struct rchan_buf *buf;
 
-        buf = chan->buf[get_cpu()];
+        buf = *get_cpu_ptr(chan->buf);
         if (unlikely(buf->offset + length > buf->chan->subbuf_size))
                 length = relay_switch_subbuf(buf, length);
         memcpy(buf->data + buf->offset, data, length);
         buf->offset += length;
-        put_cpu();
+        put_cpu_ptr(chan->buf);
 }
 
 /**
@@ -251,17 +252,19 @@ static inline void __relay_write(struct rchan *chan,
  */
 static inline void *relay_reserve(struct rchan *chan, size_t length)
 {
-        void *reserved;
-        struct rchan_buf *buf = chan->buf[smp_processor_id()];
+        void *reserved = NULL;
+        struct rchan_buf *buf = *get_cpu_ptr(chan->buf);
 
         if (unlikely(buf->offset + length > buf->chan->subbuf_size)) {
                 length = relay_switch_subbuf(buf, length);
                 if (!length)
-                        return NULL;
+                        goto end;
         }
         reserved = buf->data + buf->offset;
         buf->offset += length;
 
+end:
+        put_cpu_ptr(chan->buf);
         return reserved;
 }
 
@@ -285,5 +288,11 @@ static inline void subbuf_start_reserve(struct rchan_buf *buf,
  */
 extern const struct file_operations relay_file_operations;
 
+#ifdef CONFIG_RELAY
+int relay_prepare_cpu(unsigned int cpu);
+#else
+#define relay_prepare_cpu     NULL
+#endif
+
 #endif /* _LINUX_RELAY_H */
 
diff --git a/include/linux/slab.h b/include/linux/slab.h
index 4293808d8cfb..084b12bad198 100644
--- a/include/linux/slab.h
+++ b/include/linux/slab.h
@@ -650,4 +650,12 @@ static inline void *kzalloc_node(size_t size, gfp_t flags, int node)
 unsigned int kmem_cache_size(struct kmem_cache *s);
 void __init kmem_cache_init_late(void);
 
+#if defined(CONFIG_SMP) && defined(CONFIG_SLAB)
+int slab_prepare_cpu(unsigned int cpu);
+int slab_dead_cpu(unsigned int cpu);
+#else
+#define slab_prepare_cpu        NULL
+#define slab_dead_cpu           NULL
+#endif
+
 #endif  /* _LINUX_SLAB_H */