LKML Archive on lore.kernel.org
help / color / mirror / Atom feed
* [Resend Patch v4 00/16] Kill SMP single function call interrupt
@ 2015-01-23  5:36 Jiang Liu
  2015-01-23  5:36 ` [Resend Patch v4 01/16] smp, alpha: " Jiang Liu
                   ` (16 more replies)
  0 siblings, 17 replies; 25+ messages in thread
From: Jiang Liu @ 2015-01-23  5:36 UTC (permalink / raw)
  To: Thomas Gleixner; +Cc: Jiang Liu, Borislav Petkov, Tony Luck, linux-kernel

This patch set has been hanging around for more than one year since v3.
Resend for collecting more Acks targetting v3.20 merging window.
Patches for ARC, Hexagon, Metag, MIPS and PARISC has been merged.
Gained Acks for Tile, Xen, ARM64 and S390.

Since commit 9a46ad6d6df3b54 "smp: make smp_call_function_many() use
logic similar to smp_call_function_single()", single and multiple
(mask version) cross CPU function calls are handled in the same way,
and generic_smp_call_function_interrupt() becomes an aliases of
generic_smp_call_function_single_interrupt(), so only one interrupt
is needed for arch code to support generic SMP function call interfaces.
This patch series simplifies arch code by killing the redundant
interrupt for cross CPU function calls.

We choose to keep generic_smp_call_function_interrupt() instead of
generic_smp_call_function_single_interrupt() because the former is
more generic.

Jiang Liu (16):
  smp, alpha: Kill SMP single function call interrupt
  smp, ARM: Kill SMP single function call interrupt
  smp, ARM64: Kill SMP single function call interrupt
  smp, IA64: Kill SMP single function call interrupt
  smp, m32r: Kill SMP single function call interrupt
  smp, mn10300: Kill SMP single function call interrupt
  smp, mn10300: Enable arch_send_call_function_ipi_mask()
  smp, sh: Kill SMP single function call interrupt
  smp, sparc64: Kill SMP single function call interrupt
  smp, sparc: Kill SMP single function call interrupt
  smp, x86, xen: Kill SMP single function call interrupt
  smp, x86: Kill SMP single function call interrupt
  smp, tile: Kill SMP single function call interrupt
  smp, s390: Kill SMP single function call interrupt
  smp: Cleanup unsued generic_smp_call_function_single_interrupt()
  smp, trivial: Remove unused function prototype from smp_boot.h

 arch/alpha/kernel/smp.c                  |    8 +------
 arch/arm/include/asm/hardirq.h           |    2 +-
 arch/arm/kernel/smp.c                    |   10 +-------
 arch/arm64/include/asm/hardirq.h         |    2 +-
 arch/arm64/kernel/smp.c                  |   10 +-------
 arch/ia64/kernel/smp.c                   |    8 ++-----
 arch/m32r/include/asm/smp.h              |    1 -
 arch/m32r/kernel/smp.c                   |    9 +-------
 arch/m32r/kernel/traps.c                 |    3 +--
 arch/mn10300/include/asm/smp.h           |    2 +-
 arch/mn10300/kernel/smp.c                |   19 ++++++++-------
 arch/s390/kernel/smp.c                   |   10 ++++----
 arch/sh/include/asm/smp.h                |    1 -
 arch/sh/kernel/smp.c                     |    5 +---
 arch/sparc/include/asm/pil.h             |    5 ++--
 arch/sparc/include/asm/smp_32.h          |    4 +---
 arch/sparc/kernel/entry.S                |   10 ++------
 arch/sparc/kernel/leon_smp.c             |   31 ++++++-------------------
 arch/sparc/kernel/smp_32.c               |   14 ++---------
 arch/sparc/kernel/smp_64.c               |   13 +----------
 arch/sparc/kernel/sun4d_smp.c            |   31 ++++++-------------------
 arch/sparc/kernel/sun4m_smp.c            |   11 ++-------
 arch/sparc/kernel/ttable_64.S            |   12 ++++------
 arch/sparc/mm/ultra.S                    |    5 ----
 arch/tile/include/asm/smp.h              |    7 +++---
 arch/tile/kernel/smp.c                   |    6 +----
 arch/x86/include/asm/entry_arch.h        |    1 -
 arch/x86/include/asm/hw_irq.h            |    3 ---
 arch/x86/include/asm/irq_vectors.h       |    7 +++---
 arch/x86/include/asm/trace/irq_vectors.h |    6 -----
 arch/x86/include/asm/xen/events.h        |    1 -
 arch/x86/kernel/entry_64.S               |    2 --
 arch/x86/kernel/irqinit.c                |    4 ----
 arch/x86/kernel/smp.c                    |   24 +------------------
 arch/x86/xen/smp.c                       |   37 +-----------------------------
 include/linux/smp.h                      |    4 +---
 include/linux/smpboot.h                  |    1 -
 kernel/smp.c                             |    4 ++--
 38 files changed, 65 insertions(+), 268 deletions(-)

-- 
1.7.10.4


^ permalink raw reply	[flat|nested] 25+ messages in thread

* [Resend Patch v4 01/16] smp, alpha: Kill SMP single function call interrupt
  2015-01-23  5:36 [Resend Patch v4 00/16] Kill SMP single function call interrupt Jiang Liu
@ 2015-01-23  5:36 ` Jiang Liu
  2015-01-23  5:36 ` [Resend Patch v4 02/16] smp, ARM: " Jiang Liu
                   ` (15 subsequent siblings)
  16 siblings, 0 replies; 25+ messages in thread
From: Jiang Liu @ 2015-01-23  5:36 UTC (permalink / raw)
  To: Thomas Gleixner, Richard Henderson, Ivan Kokshaysky, Matt Turner,
	Jiang Liu
  Cc: Borislav Petkov, Tony Luck, linux-kernel, linux-alpha

Commit 9a46ad6d6df3b54 "smp: make smp_call_function_many() use logic
similar to smp_call_function_single()" has unified the way to handle
single and multiple cross-CPU function calls. Now only one interrupt
is needed for architecture specific code to support generic SMP function
call interfaces, so kill the redundant single function call interrupt.

Cc: Richard Henderson <rth@twiddle.net>
Cc: Ivan Kokshaysky <ink@jurassic.park.msu.ru>
Cc: Matt Turner <mattst88@gmail.com>
Cc: linux-alpha@vger.kernel.org
Signed-off-by: Jiang Liu <jiang.liu@linux.intel.com>
---
 arch/alpha/kernel/smp.c |    8 +-------
 1 file changed, 1 insertion(+), 7 deletions(-)

diff --git a/arch/alpha/kernel/smp.c b/arch/alpha/kernel/smp.c
index 99ac36d5de4e..2f24447fef92 100644
--- a/arch/alpha/kernel/smp.c
+++ b/arch/alpha/kernel/smp.c
@@ -63,7 +63,6 @@ static struct {
 enum ipi_message_type {
 	IPI_RESCHEDULE,
 	IPI_CALL_FUNC,
-	IPI_CALL_FUNC_SINGLE,
 	IPI_CPU_STOP,
 };
 
@@ -506,7 +505,6 @@ setup_profiling_timer(unsigned int multiplier)
 	return -EINVAL;
 }
 
-\f
 static void
 send_ipi_message(const struct cpumask *to_whom, enum ipi_message_type operation)
 {
@@ -552,10 +550,6 @@ handle_ipi(struct pt_regs *regs)
 			generic_smp_call_function_interrupt();
 			break;
 
-		case IPI_CALL_FUNC_SINGLE:
-			generic_smp_call_function_single_interrupt();
-			break;
-
 		case IPI_CPU_STOP:
 			halt();
 
@@ -606,7 +600,7 @@ void arch_send_call_function_ipi_mask(const struct cpumask *mask)
 
 void arch_send_call_function_single_ipi(int cpu)
 {
-	send_ipi_message(cpumask_of(cpu), IPI_CALL_FUNC_SINGLE);
+	send_ipi_message(cpumask_of(cpu), IPI_CALL_FUNC);
 }
 
 static void
-- 
1.7.10.4


^ permalink raw reply	[flat|nested] 25+ messages in thread

* [Resend Patch v4 02/16] smp, ARM: Kill SMP single function call interrupt
  2015-01-23  5:36 [Resend Patch v4 00/16] Kill SMP single function call interrupt Jiang Liu
  2015-01-23  5:36 ` [Resend Patch v4 01/16] smp, alpha: " Jiang Liu
@ 2015-01-23  5:36 ` Jiang Liu
  2015-01-23  5:36 ` [Resend Patch v4 03/16] smp, ARM64: " Jiang Liu
                   ` (14 subsequent siblings)
  16 siblings, 0 replies; 25+ messages in thread
From: Jiang Liu @ 2015-01-23  5:36 UTC (permalink / raw)
  To: Thomas Gleixner, Russell King, Nicolas Pitre, Pavel Machek,
	Geert Uytterhoeven, Jiang Liu
  Cc: Borislav Petkov, Tony Luck, linux-kernel, Catalin Marinas,
	Will Deacon, Arnd Bergmann, linux-arm-kernel, Russell King

Commit 9a46ad6d6df3b54 "smp: make smp_call_function_many() use logic
similar to smp_call_function_single()" has unified the way to handle
single and multiple cross-CPU function calls. Now only one interrupt
is needed for architecture specific code to support generic SMP function
call interfaces, so kill the redundant single function call interrupt.

Cc: Catalin Marinas <catalin.marinas@arm.com>
Cc: Will Deacon <will.deacon@arm.com>
Cc: Arnd Bergmann <arnd@arndb.de>
Cc: linux-arm-kernel@lists.infradead.org
Cc: Russell King <linux@arm.linux.org.uk>
Signed-off-by: Jiang Liu <jiang.liu@linux.intel.com>
---
 arch/arm/include/asm/hardirq.h |    2 +-
 arch/arm/kernel/smp.c          |   10 +---------
 2 files changed, 2 insertions(+), 10 deletions(-)

diff --git a/arch/arm/include/asm/hardirq.h b/arch/arm/include/asm/hardirq.h
index fe3ea776dc34..3d7351c844aa 100644
--- a/arch/arm/include/asm/hardirq.h
+++ b/arch/arm/include/asm/hardirq.h
@@ -5,7 +5,7 @@
 #include <linux/threads.h>
 #include <asm/irq.h>
 
-#define NR_IPI	8
+#define NR_IPI	7
 
 typedef struct {
 	unsigned int __softirq_pending;
diff --git a/arch/arm/kernel/smp.c b/arch/arm/kernel/smp.c
index 86ef244c5a24..2bab642eb0b1 100644
--- a/arch/arm/kernel/smp.c
+++ b/arch/arm/kernel/smp.c
@@ -68,7 +68,6 @@ enum ipi_msg_type {
 	IPI_TIMER,
 	IPI_RESCHEDULE,
 	IPI_CALL_FUNC,
-	IPI_CALL_FUNC_SINGLE,
 	IPI_CPU_STOP,
 	IPI_IRQ_WORK,
 	IPI_COMPLETION,
@@ -452,7 +451,6 @@ static const char *ipi_types[NR_IPI] __tracepoint_string = {
 	S(IPI_TIMER, "Timer broadcast interrupts"),
 	S(IPI_RESCHEDULE, "Rescheduling interrupts"),
 	S(IPI_CALL_FUNC, "Function call interrupts"),
-	S(IPI_CALL_FUNC_SINGLE, "Single function call interrupts"),
 	S(IPI_CPU_STOP, "CPU stop interrupts"),
 	S(IPI_IRQ_WORK, "IRQ work interrupts"),
 	S(IPI_COMPLETION, "completion interrupts"),
@@ -502,7 +500,7 @@ void arch_send_wakeup_ipi_mask(const struct cpumask *mask)
 
 void arch_send_call_function_single_ipi(int cpu)
 {
-	smp_cross_call(cpumask_of(cpu), IPI_CALL_FUNC_SINGLE);
+	smp_cross_call(cpumask_of(cpu), IPI_CALL_FUNC);
 }
 
 #ifdef CONFIG_IRQ_WORK
@@ -597,12 +595,6 @@ void handle_IPI(int ipinr, struct pt_regs *regs)
 		irq_exit();
 		break;
 
-	case IPI_CALL_FUNC_SINGLE:
-		irq_enter();
-		generic_smp_call_function_single_interrupt();
-		irq_exit();
-		break;
-
 	case IPI_CPU_STOP:
 		irq_enter();
 		ipi_cpu_stop(cpu);
-- 
1.7.10.4


^ permalink raw reply	[flat|nested] 25+ messages in thread

* [Resend Patch v4 03/16] smp, ARM64: Kill SMP single function call interrupt
  2015-01-23  5:36 [Resend Patch v4 00/16] Kill SMP single function call interrupt Jiang Liu
  2015-01-23  5:36 ` [Resend Patch v4 01/16] smp, alpha: " Jiang Liu
  2015-01-23  5:36 ` [Resend Patch v4 02/16] smp, ARM: " Jiang Liu
@ 2015-01-23  5:36 ` Jiang Liu
  2015-01-23 18:10   ` Catalin Marinas
  2015-01-23  5:36 ` [Resend Patch v4 04/16] smp, IA64: " Jiang Liu
                   ` (13 subsequent siblings)
  16 siblings, 1 reply; 25+ messages in thread
From: Jiang Liu @ 2015-01-23  5:36 UTC (permalink / raw)
  To: Thomas Gleixner, Catalin Marinas, Will Deacon, Mark Rutland,
	Nicolas Pitre, Ashwin Chaugule, Larry Bassel, Mark Brown,
	Jiang Liu
  Cc: Borislav Petkov, Tony Luck, linux-kernel, linux-arm-kernel,
	Arnd Bergmann

Commit 9a46ad6d6df3b54 "smp: make smp_call_function_many() use logic
similar to smp_call_function_single()" has unified the way to handle
single and multiple cross-CPU function calls. Now only one interrupt
is needed for architecture specific code to support generic SMP function
call interfaces, so kill the redundant single function call interrupt.

Signed-off-by: Jiang Liu <jiang.liu@linux.intel.com>
Acked-by: Will Deacon <will.deacon@arm.com>
Cc: linux-arm-kernel@lists.infradead.org
Cc: Catalin Marinas <catalin.marinas@arm.com>
Cc: Arnd Bergmann <arnd@arndb.de>
---
 arch/arm64/include/asm/hardirq.h |    2 +-
 arch/arm64/kernel/smp.c          |   10 +---------
 2 files changed, 2 insertions(+), 10 deletions(-)

diff --git a/arch/arm64/include/asm/hardirq.h b/arch/arm64/include/asm/hardirq.h
index e8a3268a891c..6aae421f4d73 100644
--- a/arch/arm64/include/asm/hardirq.h
+++ b/arch/arm64/include/asm/hardirq.h
@@ -20,7 +20,7 @@
 #include <linux/threads.h>
 #include <asm/irq.h>
 
-#define NR_IPI	6
+#define NR_IPI	5
 
 typedef struct {
 	unsigned int __softirq_pending;
diff --git a/arch/arm64/kernel/smp.c b/arch/arm64/kernel/smp.c
index 7ae6ee085261..328b8ce4b007 100644
--- a/arch/arm64/kernel/smp.c
+++ b/arch/arm64/kernel/smp.c
@@ -65,7 +65,6 @@ struct secondary_data secondary_data;
 enum ipi_msg_type {
 	IPI_RESCHEDULE,
 	IPI_CALL_FUNC,
-	IPI_CALL_FUNC_SINGLE,
 	IPI_CPU_STOP,
 	IPI_TIMER,
 	IPI_IRQ_WORK,
@@ -483,7 +482,6 @@ static const char *ipi_types[NR_IPI] __tracepoint_string = {
 #define S(x,s)	[x] = s
 	S(IPI_RESCHEDULE, "Rescheduling interrupts"),
 	S(IPI_CALL_FUNC, "Function call interrupts"),
-	S(IPI_CALL_FUNC_SINGLE, "Single function call interrupts"),
 	S(IPI_CPU_STOP, "CPU stop interrupts"),
 	S(IPI_TIMER, "Timer broadcast interrupts"),
 	S(IPI_IRQ_WORK, "IRQ work interrupts"),
@@ -527,7 +525,7 @@ void arch_send_call_function_ipi_mask(const struct cpumask *mask)
 
 void arch_send_call_function_single_ipi(int cpu)
 {
-	smp_cross_call(cpumask_of(cpu), IPI_CALL_FUNC_SINGLE);
+	smp_cross_call(cpumask_of(cpu), IPI_CALL_FUNC);
 }
 
 #ifdef CONFIG_IRQ_WORK
@@ -585,12 +583,6 @@ void handle_IPI(int ipinr, struct pt_regs *regs)
 		irq_exit();
 		break;
 
-	case IPI_CALL_FUNC_SINGLE:
-		irq_enter();
-		generic_smp_call_function_single_interrupt();
-		irq_exit();
-		break;
-
 	case IPI_CPU_STOP:
 		irq_enter();
 		ipi_cpu_stop(cpu);
-- 
1.7.10.4


^ permalink raw reply	[flat|nested] 25+ messages in thread

* [Resend Patch v4 04/16] smp, IA64: Kill SMP single function call interrupt
  2015-01-23  5:36 [Resend Patch v4 00/16] Kill SMP single function call interrupt Jiang Liu
                   ` (2 preceding siblings ...)
  2015-01-23  5:36 ` [Resend Patch v4 03/16] smp, ARM64: " Jiang Liu
@ 2015-01-23  5:36 ` Jiang Liu
  2015-01-23  5:36 ` [Resend Patch v4 05/16] smp, m32r: " Jiang Liu
                   ` (12 subsequent siblings)
  16 siblings, 0 replies; 25+ messages in thread
From: Jiang Liu @ 2015-01-23  5:36 UTC (permalink / raw)
  To: Thomas Gleixner, Tony Luck, Fenghua Yu, Jiang Liu
  Cc: Borislav Petkov, linux-kernel, linux-ia64

Commit 9a46ad6d6df3b54 "smp: make smp_call_function_many() use logic
similar to smp_call_function_single()" has unified the way to handle
single and multiple cross-CPU function calls. Now only one interrupt
is needed for architecture specific code to support generic SMP function
call interfaces, so kill the redundant single function call interrupt.

Cc: Tony Luck <tony.luck@intel.com>
Cc: Fenghua Yu <fenghua.yu@intel.com>
Cc: linux-ia64@vger.kernel.org
Signed-off-by: Jiang Liu <jiang.liu@linux.intel.com>
---
 arch/ia64/kernel/smp.c |    8 ++------
 1 file changed, 2 insertions(+), 6 deletions(-)

diff --git a/arch/ia64/kernel/smp.c b/arch/ia64/kernel/smp.c
index 9fcd4e63048f..0532909b6e8e 100644
--- a/arch/ia64/kernel/smp.c
+++ b/arch/ia64/kernel/smp.c
@@ -62,8 +62,7 @@ static DEFINE_PER_CPU_SHARED_ALIGNED(unsigned short [NR_CPUS],
 
 #define IPI_CALL_FUNC		0
 #define IPI_CPU_STOP		1
-#define IPI_CALL_FUNC_SINGLE	2
-#define IPI_KDUMP_CPU_STOP	3
+#define IPI_KDUMP_CPU_STOP	2
 
 /* This needs to be cacheline aligned because it is written to by *other* CPUs.  */
 static DEFINE_PER_CPU_SHARED_ALIGNED(unsigned long, ipi_operation);
@@ -116,9 +115,6 @@ handle_IPI (int irq, void *dev_id)
 			case IPI_CALL_FUNC:
 				generic_smp_call_function_interrupt();
 				break;
-			case IPI_CALL_FUNC_SINGLE:
-				generic_smp_call_function_single_interrupt();
-				break;
 #ifdef CONFIG_KEXEC
 			case IPI_KDUMP_CPU_STOP:
 				unw_init_running(kdump_cpu_freeze, NULL);
@@ -318,7 +314,7 @@ smp_flush_tlb_mm (struct mm_struct *mm)
 
 void arch_send_call_function_single_ipi(int cpu)
 {
-	send_IPI_single(cpu, IPI_CALL_FUNC_SINGLE);
+	send_IPI_single(cpu, IPI_CALL_FUNC);
 }
 
 void arch_send_call_function_ipi_mask(const struct cpumask *mask)
-- 
1.7.10.4


^ permalink raw reply	[flat|nested] 25+ messages in thread

* [Resend Patch v4 05/16] smp, m32r: Kill SMP single function call interrupt
  2015-01-23  5:36 [Resend Patch v4 00/16] Kill SMP single function call interrupt Jiang Liu
                   ` (3 preceding siblings ...)
  2015-01-23  5:36 ` [Resend Patch v4 04/16] smp, IA64: " Jiang Liu
@ 2015-01-23  5:36 ` Jiang Liu
  2015-01-23  5:36 ` [Resend Patch v4 06/16] smp, mn10300: " Jiang Liu
                   ` (11 subsequent siblings)
  16 siblings, 0 replies; 25+ messages in thread
From: Jiang Liu @ 2015-01-23  5:36 UTC (permalink / raw)
  To: Thomas Gleixner, Jiang Liu; +Cc: Borislav Petkov, Tony Luck, linux-kernel

Commit 9a46ad6d6df3b54 "smp: make smp_call_function_many() use logic
similar to smp_call_function_single()" has unified the way to handle
single and multiple cross-CPU function calls. Now only one interrupt
is needed for architecture specific code to support generic SMP function
call interfaces, so kill the redundant single function call interrupt.

Signed-off-by: Jiang Liu <jiang.liu@linux.intel.com>
---
 arch/m32r/include/asm/smp.h |    1 -
 arch/m32r/kernel/smp.c      |    9 +--------
 arch/m32r/kernel/traps.c    |    3 +--
 3 files changed, 2 insertions(+), 11 deletions(-)

diff --git a/arch/m32r/include/asm/smp.h b/arch/m32r/include/asm/smp.h
index c689b828dfe2..3a502d4592e9 100644
--- a/arch/m32r/include/asm/smp.h
+++ b/arch/m32r/include/asm/smp.h
@@ -98,7 +98,6 @@ extern void arch_send_call_function_ipi_mask(const struct cpumask *mask);
 #define LOCAL_TIMER_IPI		(M32R_IRQ_IPI3-M32R_IRQ_IPI0)
 #define INVALIDATE_CACHE_IPI	(M32R_IRQ_IPI4-M32R_IRQ_IPI0)
 #define CPU_BOOT_IPI		(M32R_IRQ_IPI5-M32R_IRQ_IPI0)
-#define CALL_FUNC_SINGLE_IPI	(M32R_IRQ_IPI6-M32R_IRQ_IPI0)
 
 #define IPI_SHIFT	(0)
 #define NR_IPIS		(8)
diff --git a/arch/m32r/kernel/smp.c b/arch/m32r/kernel/smp.c
index ce7aea34fdf4..c6d0bb93ad2d 100644
--- a/arch/m32r/kernel/smp.c
+++ b/arch/m32r/kernel/smp.c
@@ -542,7 +542,7 @@ void arch_send_call_function_ipi_mask(const struct cpumask *mask)
 
 void arch_send_call_function_single_ipi(int cpu)
 {
-	send_IPI_mask(cpumask_of(cpu), CALL_FUNC_SINGLE_IPI, 0);
+	send_IPI_mask(cpumask_of(cpu), CALL_FUNCTION_IPI, 0);
 }
 
 /*==========================================================================*
@@ -569,13 +569,6 @@ void smp_call_function_interrupt(void)
 	irq_exit();
 }
 
-void smp_call_function_single_interrupt(void)
-{
-	irq_enter();
-	generic_smp_call_function_single_interrupt();
-	irq_exit();
-}
-
 /*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*/
 /* Timer Routines                                                            */
 /*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*/
diff --git a/arch/m32r/kernel/traps.c b/arch/m32r/kernel/traps.c
index a7a424f852e4..f5d911dcd763 100644
--- a/arch/m32r/kernel/traps.c
+++ b/arch/m32r/kernel/traps.c
@@ -39,7 +39,6 @@ extern void smp_invalidate_interrupt(void);
 extern void smp_call_function_interrupt(void);
 extern void smp_ipi_timer_interrupt(void);
 extern void smp_flush_cache_all_interrupt(void);
-extern void smp_call_function_single_interrupt(void);
 
 /*
  * for Boot AP function
@@ -104,7 +103,7 @@ static void set_eit_vector_entries(void)
 	eit_vector[187] = (unsigned long)smp_ipi_timer_interrupt;
 	eit_vector[188] = (unsigned long)smp_flush_cache_all_interrupt;
 	eit_vector[189] = 0;	/* CPU_BOOT_IPI */
-	eit_vector[190] = (unsigned long)smp_call_function_single_interrupt;
+	eit_vector[190] = 0;
 	eit_vector[191] = 0;
 #endif
 	_flush_cache_copyback_all();
-- 
1.7.10.4


^ permalink raw reply	[flat|nested] 25+ messages in thread

* [Resend Patch v4 06/16] smp, mn10300: Kill SMP single function call interrupt
  2015-01-23  5:36 [Resend Patch v4 00/16] Kill SMP single function call interrupt Jiang Liu
                   ` (4 preceding siblings ...)
  2015-01-23  5:36 ` [Resend Patch v4 05/16] smp, m32r: " Jiang Liu
@ 2015-01-23  5:36 ` Jiang Liu
  2015-01-23  5:36 ` [Resend Patch v4 07/16] smp, mn10300: Enable arch_send_call_function_ipi_mask() Jiang Liu
                   ` (10 subsequent siblings)
  16 siblings, 0 replies; 25+ messages in thread
From: Jiang Liu @ 2015-01-23  5:36 UTC (permalink / raw)
  To: Thomas Gleixner, David Howells, Koichi Yasutake, Jiang Liu
  Cc: Borislav Petkov, Tony Luck, linux-kernel, linux-am33-list

Rename CALL_FUNC_SINGLE_IPI as CALL_FUNC_IPI to prepare for
killing generic_smp_call_function_single_interrupt().

Cc: Koichi Yasutake <yasutake.koichi@jp.panasonic.com>
Cc: linux-am33-list@redhat.com
Signed-off-by: Jiang Liu <jiang.liu@linux.intel.com>
---
 arch/mn10300/include/asm/smp.h |    2 +-
 arch/mn10300/kernel/smp.c      |   16 ++++++++--------
 2 files changed, 9 insertions(+), 9 deletions(-)

diff --git a/arch/mn10300/include/asm/smp.h b/arch/mn10300/include/asm/smp.h
index 56c42417d428..8e689d1724bf 100644
--- a/arch/mn10300/include/asm/smp.h
+++ b/arch/mn10300/include/asm/smp.h
@@ -31,7 +31,7 @@
 #include <proc/smp-regs.h>
 
 #define RESCHEDULE_IPI		63
-#define CALL_FUNC_SINGLE_IPI	192
+#define CALL_FUNC_IPI		192
 #define LOCAL_TIMER_IPI		193
 #define FLUSH_CACHE_IPI		194
 #define CALL_FUNCTION_NMI_IPI	195
diff --git a/arch/mn10300/kernel/smp.c b/arch/mn10300/kernel/smp.c
index f984193718b1..13aa7ac5a82b 100644
--- a/arch/mn10300/kernel/smp.c
+++ b/arch/mn10300/kernel/smp.c
@@ -164,11 +164,11 @@ static void init_ipi(void)
 	mn10300_ipi_enable(RESCHEDULE_IPI);
 
 	/* set up the call function IPI */
-	irq_set_chip_and_handler(CALL_FUNC_SINGLE_IPI, &mn10300_ipi_type,
+	irq_set_chip_and_handler(CALL_FUNC_IPI, &mn10300_ipi_type,
 				 handle_percpu_irq);
-	setup_irq(CALL_FUNC_SINGLE_IPI, &call_function_ipi);
-	set_intr_level(CALL_FUNC_SINGLE_IPI, CALL_FUNCTION_GxICR_LV);
-	mn10300_ipi_enable(CALL_FUNC_SINGLE_IPI);
+	setup_irq(CALL_FUNC_IPI, &call_function_ipi);
+	set_intr_level(CALL_FUNC_IPI, CALL_FUNCTION_GxICR_LV);
+	mn10300_ipi_enable(CALL_FUNC_IPI);
 
 	/* set up the local timer IPI */
 #if !defined(CONFIG_GENERIC_CLOCKEVENTS) || \
@@ -362,7 +362,7 @@ void arch_send_call_function_ipi_mask(const struct cpumask *mask)
 
 void arch_send_call_function_single_ipi(int cpu)
 {
-	send_IPI_mask(cpumask_of(cpu), CALL_FUNC_SINGLE_IPI);
+	send_IPI_mask(cpumask_of(cpu), CALL_FUNC_IPI);
 }
 
 /**
@@ -519,7 +519,7 @@ static irqreturn_t smp_reschedule_interrupt(int irq, void *dev_id)
 static irqreturn_t smp_call_function_interrupt(int irq, void *dev_id)
 {
 	/* generic_smp_call_function_interrupt(); */
-	generic_smp_call_function_single_interrupt();
+	generic_smp_call_function_interrupt();
 	return IRQ_HANDLED;
 }
 
@@ -598,8 +598,8 @@ static void __init smp_cpu_init(void)
 	/* Force FPU initialization */
 	clear_using_fpu(current);
 
-	GxICR(CALL_FUNC_SINGLE_IPI) = CALL_FUNCTION_GxICR_LV | GxICR_DETECT;
-	mn10300_ipi_enable(CALL_FUNC_SINGLE_IPI);
+	GxICR(CALL_FUNC_IPI) = CALL_FUNCTION_GxICR_LV | GxICR_DETECT;
+	mn10300_ipi_enable(CALL_FUNC_IPI);
 
 	GxICR(LOCAL_TIMER_IPI) = LOCAL_TIMER_GxICR_LV | GxICR_DETECT;
 	mn10300_ipi_enable(LOCAL_TIMER_IPI);
-- 
1.7.10.4


^ permalink raw reply	[flat|nested] 25+ messages in thread

* [Resend Patch v4 07/16] smp, mn10300: Enable arch_send_call_function_ipi_mask()
  2015-01-23  5:36 [Resend Patch v4 00/16] Kill SMP single function call interrupt Jiang Liu
                   ` (5 preceding siblings ...)
  2015-01-23  5:36 ` [Resend Patch v4 06/16] smp, mn10300: " Jiang Liu
@ 2015-01-23  5:36 ` Jiang Liu
  2015-01-23  5:36 ` [Resend Patch v4 08/16] smp, sh: Kill SMP single function call interrupt Jiang Liu
                   ` (9 subsequent siblings)
  16 siblings, 0 replies; 25+ messages in thread
From: Jiang Liu @ 2015-01-23  5:36 UTC (permalink / raw)
  To: Thomas Gleixner, David Howells, Koichi Yasutake, Jiang Liu
  Cc: Borislav Petkov, Tony Luck, linux-kernel, linux-am33-list

Enable arch_send_call_function_ipi_mask() on mn10300 to support
smp_call_function_many().

Cc: Koichi Yasutake <yasutake.koichi@jp.panasonic.com>
Cc: linux-am33-list@redhat.com
Signed-off-by: Jiang Liu <jiang.liu@linux.intel.com>
---
 arch/mn10300/kernel/smp.c |    3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/arch/mn10300/kernel/smp.c b/arch/mn10300/kernel/smp.c
index 13aa7ac5a82b..9d21c3391374 100644
--- a/arch/mn10300/kernel/smp.c
+++ b/arch/mn10300/kernel/smp.c
@@ -356,8 +356,7 @@ void send_IPI_allbutself(int irq)
 
 void arch_send_call_function_ipi_mask(const struct cpumask *mask)
 {
-	BUG();
-	/*send_IPI_mask(mask, CALL_FUNCTION_IPI);*/
+	send_IPI_mask(mask, CALL_FUNC_IPI);
 }
 
 void arch_send_call_function_single_ipi(int cpu)
-- 
1.7.10.4


^ permalink raw reply	[flat|nested] 25+ messages in thread

* [Resend Patch v4 08/16] smp, sh: Kill SMP single function call interrupt
  2015-01-23  5:36 [Resend Patch v4 00/16] Kill SMP single function call interrupt Jiang Liu
                   ` (6 preceding siblings ...)
  2015-01-23  5:36 ` [Resend Patch v4 07/16] smp, mn10300: Enable arch_send_call_function_ipi_mask() Jiang Liu
@ 2015-01-23  5:36 ` Jiang Liu
  2015-01-23  5:36 ` [Resend Patch v4 09/16] smp, sparc64: " Jiang Liu
                   ` (8 subsequent siblings)
  16 siblings, 0 replies; 25+ messages in thread
From: Jiang Liu @ 2015-01-23  5:36 UTC (permalink / raw)
  To: Thomas Gleixner, Jiang Liu
  Cc: Borislav Petkov, Tony Luck, linux-kernel, Paul Mundt, linux-sh

Commit 9a46ad6d6df3b54 "smp: make smp_call_function_many() use logic
similar to smp_call_function_single()" has unified the way to handle
single and multiple cross-CPU function calls. Now only one interrupt
is needed for architecture specific code to support generic SMP function
call interfaces, so kill the redundant single function call interrupt.

Cc: Paul Mundt <lethal@linux-sh.org>
Signed-off-by: Jiang Liu <jiang.liu@linux.intel.com>
---
 arch/sh/include/asm/smp.h |    1 -
 arch/sh/kernel/smp.c      |    5 +----
 2 files changed, 1 insertion(+), 5 deletions(-)

diff --git a/arch/sh/include/asm/smp.h b/arch/sh/include/asm/smp.h
index 78b0d0f4b24b..93ce87b3a18d 100644
--- a/arch/sh/include/asm/smp.h
+++ b/arch/sh/include/asm/smp.h
@@ -25,7 +25,6 @@ extern int __cpu_logical_map[NR_CPUS];
 enum {
 	SMP_MSG_FUNCTION,
 	SMP_MSG_RESCHEDULE,
-	SMP_MSG_FUNCTION_SINGLE,
 	SMP_MSG_TIMER,
 
 	SMP_MSG_NR,	/* must be last */
diff --git a/arch/sh/kernel/smp.c b/arch/sh/kernel/smp.c
index fc5acfc93c92..fc03baf8b661 100644
--- a/arch/sh/kernel/smp.c
+++ b/arch/sh/kernel/smp.c
@@ -282,7 +282,7 @@ void arch_send_call_function_ipi_mask(const struct cpumask *mask)
 
 void arch_send_call_function_single_ipi(int cpu)
 {
-	mp_ops->send_ipi(cpu, SMP_MSG_FUNCTION_SINGLE);
+	mp_ops->send_ipi(cpu, SMP_MSG_FUNCTION);
 }
 
 void smp_timer_broadcast(const struct cpumask *mask)
@@ -309,9 +309,6 @@ void smp_message_recv(unsigned int msg)
 	case SMP_MSG_RESCHEDULE:
 		scheduler_ipi();
 		break;
-	case SMP_MSG_FUNCTION_SINGLE:
-		generic_smp_call_function_single_interrupt();
-		break;
 	case SMP_MSG_TIMER:
 		ipi_timer();
 		break;
-- 
1.7.10.4


^ permalink raw reply	[flat|nested] 25+ messages in thread

* [Resend Patch v4 09/16] smp, sparc64: Kill SMP single function call interrupt
  2015-01-23  5:36 [Resend Patch v4 00/16] Kill SMP single function call interrupt Jiang Liu
                   ` (7 preceding siblings ...)
  2015-01-23  5:36 ` [Resend Patch v4 08/16] smp, sh: Kill SMP single function call interrupt Jiang Liu
@ 2015-01-23  5:36 ` Jiang Liu
  2015-01-23  5:36 ` [Resend Patch v4 10/16] smp, sparc: " Jiang Liu
                   ` (7 subsequent siblings)
  16 siblings, 0 replies; 25+ messages in thread
From: Jiang Liu @ 2015-01-23  5:36 UTC (permalink / raw)
  To: Thomas Gleixner, David S. Miller, Jiang Liu, Sam Ravnborg, Kirill Tkhai
  Cc: Borislav Petkov, Tony Luck, linux-kernel, sparclinux

Commit 9a46ad6d6df3b54 "smp: make smp_call_function_many() use logic
similar to smp_call_function_single()" has unified the way to handle
single and multiple cross-CPU function calls. Now only one interrupt
is needed for architecture specific code to support generic SMP function
call interfaces, so kill the redundant single function call interrupt.

Cc: "David S. Miller" <davem@davemloft.net>
Cc: Sam Ravnborg <sam@ravnborg.org>
Cc: sparclinux@vger.kernel.org
Signed-off-by: Jiang Liu <jiang.liu@linux.intel.com>
---
 arch/sparc/include/asm/pil.h  |    5 ++---
 arch/sparc/kernel/smp_64.c    |   13 +------------
 arch/sparc/kernel/ttable_64.S |   12 ++++--------
 arch/sparc/mm/ultra.S         |    5 -----
 4 files changed, 7 insertions(+), 28 deletions(-)

diff --git a/arch/sparc/include/asm/pil.h b/arch/sparc/include/asm/pil.h
index 266937030546..5ffb15df5062 100644
--- a/arch/sparc/include/asm/pil.h
+++ b/arch/sparc/include/asm/pil.h
@@ -22,9 +22,8 @@
 #define PIL_SMP_CAPTURE		3
 #define PIL_SMP_CTX_NEW_VERSION	4
 #define PIL_DEVICE_IRQ		5
-#define PIL_SMP_CALL_FUNC_SNGL	6
-#define PIL_DEFERRED_PCR_WORK	7
-#define PIL_KGDB_CAPTURE	8
+#define PIL_DEFERRED_PCR_WORK	6
+#define PIL_KGDB_CAPTURE	7
 #define PIL_NORMAL_MAX		14
 #define PIL_NMI			15
 
diff --git a/arch/sparc/kernel/smp_64.c b/arch/sparc/kernel/smp_64.c
index da6f1a7fc4db..a91b4f9ca822 100644
--- a/arch/sparc/kernel/smp_64.c
+++ b/arch/sparc/kernel/smp_64.c
@@ -805,12 +805,9 @@ void arch_send_call_function_ipi_mask(const struct cpumask *mask)
 	xcall_deliver((u64) &xcall_call_function, 0, 0, mask);
 }
 
-extern unsigned long xcall_call_function_single;
-
 void arch_send_call_function_single_ipi(int cpu)
 {
-	xcall_deliver((u64) &xcall_call_function_single, 0, 0,
-		      cpumask_of(cpu));
+	xcall_deliver((u64) &xcall_call_function, 0, 0, cpumask_of(cpu));
 }
 
 void __irq_entry smp_call_function_client(int irq, struct pt_regs *regs)
@@ -821,14 +818,6 @@ void __irq_entry smp_call_function_client(int irq, struct pt_regs *regs)
 	irq_exit();
 }
 
-void __irq_entry smp_call_function_single_client(int irq, struct pt_regs *regs)
-{
-	clear_softint(1 << irq);
-	irq_enter();
-	generic_smp_call_function_single_interrupt();
-	irq_exit();
-}
-
 static void tsb_sync(void *info)
 {
 	struct trap_per_cpu *tp = &trap_block[raw_smp_processor_id()];
diff --git a/arch/sparc/kernel/ttable_64.S b/arch/sparc/kernel/ttable_64.S
index c6dfdaa29e20..defa2db9f914 100644
--- a/arch/sparc/kernel/ttable_64.S
+++ b/arch/sparc/kernel/ttable_64.S
@@ -58,17 +58,13 @@ tl0_irq3:	BTRAP(0x43)
 tl0_irq4:	BTRAP(0x44)
 #endif
 tl0_irq5:	TRAP_IRQ(handler_irq, 5)
-#ifdef CONFIG_SMP
-tl0_irq6:	TRAP_IRQ(smp_call_function_single_client, 6)
-#else
-tl0_irq6:	BTRAP(0x46)
-#endif
-tl0_irq7:	TRAP_IRQ(deferred_pcr_work_irq, 7)
+tl0_irq6:	TRAP_IRQ(deferred_pcr_work_irq, 6)
 #if defined(CONFIG_KGDB) && defined(CONFIG_SMP)
-tl0_irq8:	TRAP_IRQ(smp_kgdb_capture_client, 8)
+tl0_irq7:	TRAP_IRQ(smp_kgdb_capture_client, 7)
 #else
-tl0_irq8:	BTRAP(0x48)
+tl0_irq7:	BTRAP(0x47)
 #endif
+tl0_irq8:	BTRAP(0x48)
 tl0_irq9:	BTRAP(0x49)
 tl0_irq10:	BTRAP(0x4a) BTRAP(0x4b) BTRAP(0x4c) BTRAP(0x4d)
 tl0_irq14:	TRAP_IRQ(timer_interrupt, 14)
diff --git a/arch/sparc/mm/ultra.S b/arch/sparc/mm/ultra.S
index b4f4733abc6e..1da47398df65 100644
--- a/arch/sparc/mm/ultra.S
+++ b/arch/sparc/mm/ultra.S
@@ -780,11 +780,6 @@ xcall_call_function:
 	wr		%g0, (1 << PIL_SMP_CALL_FUNC), %set_softint
 	retry
 
-	.globl		xcall_call_function_single
-xcall_call_function_single:
-	wr		%g0, (1 << PIL_SMP_CALL_FUNC_SNGL), %set_softint
-	retry
-
 	.globl		xcall_receive_signal
 xcall_receive_signal:
 	wr		%g0, (1 << PIL_SMP_RECEIVE_SIGNAL), %set_softint
-- 
1.7.10.4


^ permalink raw reply	[flat|nested] 25+ messages in thread

* [Resend Patch v4 10/16] smp, sparc: Kill SMP single function call interrupt
  2015-01-23  5:36 [Resend Patch v4 00/16] Kill SMP single function call interrupt Jiang Liu
                   ` (8 preceding siblings ...)
  2015-01-23  5:36 ` [Resend Patch v4 09/16] smp, sparc64: " Jiang Liu
@ 2015-01-23  5:36 ` Jiang Liu
  2015-01-23  5:36 ` [Resend Patch v4 11/16] smp, x86, xen: " Jiang Liu
                   ` (6 subsequent siblings)
  16 siblings, 0 replies; 25+ messages in thread
From: Jiang Liu @ 2015-01-23  5:36 UTC (permalink / raw)
  To: Thomas Gleixner, David S. Miller, Sam Ravnborg, Jiang Liu
  Cc: Borislav Petkov, Tony Luck, linux-kernel, sparclinux

Commit 9a46ad6d6df3b54 "smp: make smp_call_function_many() use logic
similar to smp_call_function_single()" has unified the way to handle
single and multiple cross-CPU function calls. Now only one interrupt
is needed for architecture specific code to support generic SMP function
call interfaces, so kill the redundant single function call interrupt.

Cc: "David S. Miller" <davem@davemloft.net>
Cc: Sam Ravnborg <sam@ravnborg.org>
Cc: sparclinux@vger.kernel.org
Signed-off-by: Jiang Liu <jiang.liu@linux.intel.com>
---
 arch/sparc/include/asm/smp_32.h |    4 +---
 arch/sparc/kernel/entry.S       |   10 ++--------
 arch/sparc/kernel/leon_smp.c    |   31 +++++++------------------------
 arch/sparc/kernel/smp_32.c      |   14 ++------------
 arch/sparc/kernel/sun4d_smp.c   |   31 +++++++------------------------
 arch/sparc/kernel/sun4m_smp.c   |   11 ++---------
 6 files changed, 21 insertions(+), 80 deletions(-)

diff --git a/arch/sparc/include/asm/smp_32.h b/arch/sparc/include/asm/smp_32.h
index 7c24e08a88d2..51e53c606cc9 100644
--- a/arch/sparc/include/asm/smp_32.h
+++ b/arch/sparc/include/asm/smp_32.h
@@ -48,7 +48,6 @@ void smp_callin(void);
 void smp_store_cpu_info(int);
 
 void smp_resched_interrupt(void);
-void smp_call_function_single_interrupt(void);
 void smp_call_function_interrupt(void);
 
 struct seq_file;
@@ -60,8 +59,7 @@ struct sparc32_ipi_ops {
 			   unsigned long arg2, unsigned long arg3,
 			   unsigned long arg4);
 	void (*resched)(int cpu);
-	void (*single)(int cpu);
-	void (*mask_one)(int cpu);
+	void (*func_call)(int cpu);
 };
 extern const struct sparc32_ipi_ops *sparc32_ipi_ops;
 
diff --git a/arch/sparc/kernel/entry.S b/arch/sparc/kernel/entry.S
index 33c02b15f478..98bacfb16fa8 100644
--- a/arch/sparc/kernel/entry.S
+++ b/arch/sparc/kernel/entry.S
@@ -263,7 +263,7 @@ smp4m_ticker:
 	 * on some level other than 15 which is the NMI and only used
 	 * for cross calls.  That has a separate entry point below.
 	 *
-	 * IPIs are sent on Level 12, 13 and 14. See IRQ_IPI_*.
+	 * IPIs are sent on Level 13 and 14. See IRQ_IPI_*.
 	 */
 maybe_smp4m_msg:
 	GET_PROCESSOR4M_ID(o3)
@@ -287,14 +287,8 @@ maybe_smp4m_msg:
 	wr	%l4, PSR_ET, %psr
 	WRITE_PAUSE
 	srl	%o3, 28, %o2		! shift for simpler checks below
-maybe_smp4m_msg_check_single:
-	andcc	%o2, 0x1, %g0
-	beq,a	maybe_smp4m_msg_check_mask
-	 andcc	%o2, 0x2, %g0
-	call	smp_call_function_single_interrupt
-	 nop
-	andcc	%o2, 0x2, %g0
 maybe_smp4m_msg_check_mask:
+	andcc	%o2, 0x2, %g0
 	beq,a	maybe_smp4m_msg_check_resched
 	 andcc	%o2, 0x4, %g0
 	call	smp_call_function_interrupt
diff --git a/arch/sparc/kernel/leon_smp.c b/arch/sparc/kernel/leon_smp.c
index 71e16f2241c2..ee3c6599c271 100644
--- a/arch/sparc/kernel/leon_smp.c
+++ b/arch/sparc/kernel/leon_smp.c
@@ -260,8 +260,7 @@ void __init leon_smp_done(void)
 }
 
 struct leon_ipi_work {
-	int single;
-	int msk;
+	int func_call;
 	int resched;
 };
 
@@ -297,7 +296,7 @@ static void __init leon_ipi_init(void)
 
 	for_each_possible_cpu(cpu) {
 		work = &per_cpu(leon_ipi_work, cpu);
-		work->single = work->msk = work->resched = 0;
+		work->func_call = work->resched = 0;
 	}
 }
 
@@ -308,23 +307,12 @@ static void leon_send_ipi(int cpu, int level)
 	LEON3_BYPASS_STORE_PA(&leon3_irqctrl_regs->force[cpu], mask);
 }
 
-static void leon_ipi_single(int cpu)
+static void leon_ipi_func_call(int cpu)
 {
 	struct leon_ipi_work *work = &per_cpu(leon_ipi_work, cpu);
 
 	/* Mark work */
-	work->single = 1;
-
-	/* Generate IRQ on the CPU */
-	leon_send_ipi(cpu, leon_ipi_irq);
-}
-
-static void leon_ipi_mask_one(int cpu)
-{
-	struct leon_ipi_work *work = &per_cpu(leon_ipi_work, cpu);
-
-	/* Mark work */
-	work->msk = 1;
+	work->func_call = 1;
 
 	/* Generate IRQ on the CPU */
 	leon_send_ipi(cpu, leon_ipi_irq);
@@ -345,12 +333,8 @@ void leonsmp_ipi_interrupt(void)
 {
 	struct leon_ipi_work *work = this_cpu_ptr(&leon_ipi_work);
 
-	if (work->single) {
-		work->single = 0;
-		smp_call_function_single_interrupt();
-	}
-	if (work->msk) {
-		work->msk = 0;
+	if (work->func_call) {
+		work->func_call = 0;
 		smp_call_function_interrupt();
 	}
 	if (work->resched) {
@@ -456,8 +440,7 @@ void leon_cross_call_irq(void)
 static const struct sparc32_ipi_ops leon_ipi_ops = {
 	.cross_call = leon_cross_call,
 	.resched    = leon_ipi_resched,
-	.single     = leon_ipi_single,
-	.mask_one   = leon_ipi_mask_one,
+	.func_call   = leon_ipi_func_call,
 };
 
 void __init leon_init_smp(void)
diff --git a/arch/sparc/kernel/smp_32.c b/arch/sparc/kernel/smp_32.c
index b3a5d81b20f0..0d5287bad74c 100644
--- a/arch/sparc/kernel/smp_32.c
+++ b/arch/sparc/kernel/smp_32.c
@@ -137,17 +137,15 @@ void smp_send_stop(void)
 
 void arch_send_call_function_single_ipi(int cpu)
 {
-	/* trigger one IPI single call on one CPU */
-	sparc32_ipi_ops->single(cpu);
+	sparc32_ipi_ops->func_call(cpu);
 }
 
 void arch_send_call_function_ipi_mask(const struct cpumask *mask)
 {
 	int cpu;
 
-	/* trigger IPI mask call on each CPU */
 	for_each_cpu(cpu, mask)
-		sparc32_ipi_ops->mask_one(cpu);
+		sparc32_ipi_ops->func_call(cpu);
 }
 
 void smp_resched_interrupt(void)
@@ -159,14 +157,6 @@ void smp_resched_interrupt(void)
 	/* re-schedule routine called by interrupt return code. */
 }
 
-void smp_call_function_single_interrupt(void)
-{
-	irq_enter();
-	generic_smp_call_function_single_interrupt();
-	local_cpu_data().irq_call_count++;
-	irq_exit();
-}
-
 void smp_call_function_interrupt(void)
 {
 	irq_enter();
diff --git a/arch/sparc/kernel/sun4d_smp.c b/arch/sparc/kernel/sun4d_smp.c
index 9d98e5002a09..61d9f87334a1 100644
--- a/arch/sparc/kernel/sun4d_smp.c
+++ b/arch/sparc/kernel/sun4d_smp.c
@@ -181,8 +181,7 @@ void __init smp4d_smp_done(void)
 
 /* Memory structure giving interrupt handler information about IPI generated */
 struct sun4d_ipi_work {
-	int single;
-	int msk;
+	int func_call;
 	int resched;
 };
 
@@ -198,7 +197,7 @@ static void __init smp4d_ipi_init(void)
 
 	for_each_possible_cpu(cpu) {
 		work = &per_cpu(sun4d_ipi_work, cpu);
-		work->single = work->msk = work->resched = 0;
+		work->func_call = work->resched = 0;
 	}
 }
 
@@ -206,12 +205,8 @@ void sun4d_ipi_interrupt(void)
 {
 	struct sun4d_ipi_work *work = this_cpu_ptr(&sun4d_ipi_work);
 
-	if (work->single) {
-		work->single = 0;
-		smp_call_function_single_interrupt();
-	}
-	if (work->msk) {
-		work->msk = 0;
+	if (work->func_call) {
+		work->func_call = 0;
 		smp_call_function_interrupt();
 	}
 	if (work->resched) {
@@ -233,23 +228,12 @@ static void sun4d_send_ipi(int cpu, int level)
 	cc_set_igen(IGEN_MESSAGE(0, cpu << 3, 6 + ((level >> 1) & 7), 1 << (level - 1)));
 }
 
-static void sun4d_ipi_single(int cpu)
-{
-	struct sun4d_ipi_work *work = &per_cpu(sun4d_ipi_work, cpu);
-
-	/* Mark work */
-	work->single = 1;
-
-	/* Generate IRQ on the CPU */
-	sun4d_send_ipi(cpu, SUN4D_IPI_IRQ);
-}
-
-static void sun4d_ipi_mask_one(int cpu)
+static void sun4d_ipi_func_call(int cpu)
 {
 	struct sun4d_ipi_work *work = &per_cpu(sun4d_ipi_work, cpu);
 
 	/* Mark work */
-	work->msk = 1;
+	work->func_call = 1;
 
 	/* Generate IRQ on the CPU */
 	sun4d_send_ipi(cpu, SUN4D_IPI_IRQ);
@@ -392,8 +376,7 @@ void smp4d_percpu_timer_interrupt(struct pt_regs *regs)
 static const struct sparc32_ipi_ops sun4d_ipi_ops = {
 	.cross_call = sun4d_cross_call,
 	.resched    = sun4d_ipi_resched,
-	.single     = sun4d_ipi_single,
-	.mask_one   = sun4d_ipi_mask_one,
+	.func_call   = sun4d_ipi_func_call,
 };
 
 void __init sun4d_init_smp(void)
diff --git a/arch/sparc/kernel/sun4m_smp.c b/arch/sparc/kernel/sun4m_smp.c
index d3408e72d20c..d4b7d0149128 100644
--- a/arch/sparc/kernel/sun4m_smp.c
+++ b/arch/sparc/kernel/sun4m_smp.c
@@ -20,7 +20,6 @@
 #include "irq.h"
 #include "kernel.h"
 
-#define IRQ_IPI_SINGLE		12
 #define IRQ_IPI_MASK		13
 #define IRQ_IPI_RESCHED		14
 #define IRQ_CROSS_CALL		15
@@ -145,12 +144,7 @@ static void sun4m_ipi_resched(int cpu)
 	sun4m_send_ipi(cpu, IRQ_IPI_RESCHED);
 }
 
-static void sun4m_ipi_single(int cpu)
-{
-	sun4m_send_ipi(cpu, IRQ_IPI_SINGLE);
-}
-
-static void sun4m_ipi_mask_one(int cpu)
+static void sun4m_ipi_func_call(int cpu)
 {
 	sun4m_send_ipi(cpu, IRQ_IPI_MASK);
 }
@@ -262,8 +256,7 @@ void smp4m_percpu_timer_interrupt(struct pt_regs *regs)
 static const struct sparc32_ipi_ops sun4m_ipi_ops = {
 	.cross_call = sun4m_cross_call,
 	.resched    = sun4m_ipi_resched,
-	.single     = sun4m_ipi_single,
-	.mask_one   = sun4m_ipi_mask_one,
+	.func_call   = sun4m_ipi_func_call,
 };
 
 void __init sun4m_init_smp(void)
-- 
1.7.10.4


^ permalink raw reply	[flat|nested] 25+ messages in thread

* [Resend Patch v4 11/16] smp, x86, xen: Kill SMP single function call interrupt
  2015-01-23  5:36 [Resend Patch v4 00/16] Kill SMP single function call interrupt Jiang Liu
                   ` (9 preceding siblings ...)
  2015-01-23  5:36 ` [Resend Patch v4 10/16] smp, sparc: " Jiang Liu
@ 2015-01-23  5:36 ` Jiang Liu
  2015-01-23  5:36 ` [Resend Patch v4 12/16] smp, x86: " Jiang Liu
                   ` (5 subsequent siblings)
  16 siblings, 0 replies; 25+ messages in thread
From: Jiang Liu @ 2015-01-23  5:36 UTC (permalink / raw)
  To: Thomas Gleixner, Konrad Rzeszutek Wilk, Boris Ostrovsky,
	David Vrabel, Ingo Molnar, H. Peter Anvin, x86
  Cc: Jiang Liu, Borislav Petkov, Tony Luck, linux-kernel, Jiang Liu,
	xen-devel, virtualization, xen-devel

Commit 9a46ad6d6df3b54 "smp: make smp_call_function_many() use logic
similar to smp_call_function_single()" has unified the way to handle
single and multiple cross-CPU function calls. Now only one interrupt
is needed for architecture specific code to support generic SMP function
call interfaces, so kill the redundant single function call interrupt.

Signed-off-by: Jiang Liu <liuj97@gmail.com>
Acked-by: Konrad Rzeszutek Wilk <konrad.wilk@oracle.com>
Cc: x86@kernel.org
Cc: xen-devel@lists.xensource.com
Cc: virtualization@lists.linux-foundation.org
Signed-off-by: Jiang Liu <jiang.liu@linux.intel.com>
---
 arch/x86/include/asm/xen/events.h |    1 -
 arch/x86/xen/smp.c                |   38 ++-----------------------------------
 2 files changed, 2 insertions(+), 37 deletions(-)

diff --git a/arch/x86/include/asm/xen/events.h b/arch/x86/include/asm/xen/events.h
index 608a79d5a466..a9e54dc05c50 100644
--- a/arch/x86/include/asm/xen/events.h
+++ b/arch/x86/include/asm/xen/events.h
@@ -4,7 +4,6 @@
 enum ipi_vector {
 	XEN_RESCHEDULE_VECTOR,
 	XEN_CALL_FUNCTION_VECTOR,
-	XEN_CALL_FUNCTION_SINGLE_VECTOR,
 	XEN_SPIN_UNLOCK_VECTOR,
 	XEN_IRQ_WORK_VECTOR,
 	XEN_NMI_VECTOR,
diff --git a/arch/x86/xen/smp.c b/arch/x86/xen/smp.c
index 4c071aeb8417..d54c122a0486 100644
--- a/arch/x86/xen/smp.c
+++ b/arch/x86/xen/smp.c
@@ -47,12 +47,10 @@ struct xen_common_irq {
 };
 static DEFINE_PER_CPU(struct xen_common_irq, xen_resched_irq) = { .irq = -1 };
 static DEFINE_PER_CPU(struct xen_common_irq, xen_callfunc_irq) = { .irq = -1 };
-static DEFINE_PER_CPU(struct xen_common_irq, xen_callfuncsingle_irq) = { .irq = -1 };
 static DEFINE_PER_CPU(struct xen_common_irq, xen_irq_work) = { .irq = -1 };
 static DEFINE_PER_CPU(struct xen_common_irq, xen_debug_irq) = { .irq = -1 };
 
 static irqreturn_t xen_call_function_interrupt(int irq, void *dev_id);
-static irqreturn_t xen_call_function_single_interrupt(int irq, void *dev_id);
 static irqreturn_t xen_irq_work_interrupt(int irq, void *dev_id);
 
 /*
@@ -136,13 +134,6 @@ static void xen_smp_intr_free(unsigned int cpu)
 		kfree(per_cpu(xen_debug_irq, cpu).name);
 		per_cpu(xen_debug_irq, cpu).name = NULL;
 	}
-	if (per_cpu(xen_callfuncsingle_irq, cpu).irq >= 0) {
-		unbind_from_irqhandler(per_cpu(xen_callfuncsingle_irq, cpu).irq,
-				       NULL);
-		per_cpu(xen_callfuncsingle_irq, cpu).irq = -1;
-		kfree(per_cpu(xen_callfuncsingle_irq, cpu).name);
-		per_cpu(xen_callfuncsingle_irq, cpu).name = NULL;
-	}
 	if (xen_hvm_domain())
 		return;
 
@@ -191,18 +182,6 @@ static int xen_smp_intr_init(unsigned int cpu)
 	per_cpu(xen_debug_irq, cpu).irq = rc;
 	per_cpu(xen_debug_irq, cpu).name = debug_name;
 
-	callfunc_name = kasprintf(GFP_KERNEL, "callfuncsingle%d", cpu);
-	rc = bind_ipi_to_irqhandler(XEN_CALL_FUNCTION_SINGLE_VECTOR,
-				    cpu,
-				    xen_call_function_single_interrupt,
-				    IRQF_PERCPU|IRQF_NOBALANCING,
-				    callfunc_name,
-				    NULL);
-	if (rc < 0)
-		goto fail;
-	per_cpu(xen_callfuncsingle_irq, cpu).irq = rc;
-	per_cpu(xen_callfuncsingle_irq, cpu).name = callfunc_name;
-
 	/*
 	 * The IRQ worker on PVHVM goes through the native path and uses the
 	 * IPI mechanism.
@@ -599,8 +578,7 @@ static void xen_smp_send_call_function_ipi(const struct cpumask *mask)
 
 static void xen_smp_send_call_function_single_ipi(int cpu)
 {
-	__xen_send_IPI_mask(cpumask_of(cpu),
-			  XEN_CALL_FUNCTION_SINGLE_VECTOR);
+	__xen_send_IPI_mask(cpumask_of(cpu), XEN_CALL_FUNCTION_VECTOR);
 }
 
 static inline int xen_map_vector(int vector)
@@ -612,10 +590,8 @@ static inline int xen_map_vector(int vector)
 		xen_vector = XEN_RESCHEDULE_VECTOR;
 		break;
 	case CALL_FUNCTION_VECTOR:
-		xen_vector = XEN_CALL_FUNCTION_VECTOR;
-		break;
 	case CALL_FUNCTION_SINGLE_VECTOR:
-		xen_vector = XEN_CALL_FUNCTION_SINGLE_VECTOR;
+		xen_vector = XEN_CALL_FUNCTION_VECTOR;
 		break;
 	case IRQ_WORK_VECTOR:
 		xen_vector = XEN_IRQ_WORK_VECTOR;
@@ -693,16 +669,6 @@ static irqreturn_t xen_call_function_interrupt(int irq, void *dev_id)
 	return IRQ_HANDLED;
 }
 
-static irqreturn_t xen_call_function_single_interrupt(int irq, void *dev_id)
-{
-	irq_enter();
-	generic_smp_call_function_single_interrupt();
-	inc_irq_stat(irq_call_count);
-	irq_exit();
-
-	return IRQ_HANDLED;
-}
-
 static irqreturn_t xen_irq_work_interrupt(int irq, void *dev_id)
 {
 	irq_enter();
-- 
1.7.10.4


^ permalink raw reply	[flat|nested] 25+ messages in thread

* [Resend Patch v4 12/16] smp, x86: Kill SMP single function call interrupt
  2015-01-23  5:36 [Resend Patch v4 00/16] Kill SMP single function call interrupt Jiang Liu
                   ` (10 preceding siblings ...)
  2015-01-23  5:36 ` [Resend Patch v4 11/16] smp, x86, xen: " Jiang Liu
@ 2015-01-23  5:36 ` Jiang Liu
  2015-01-23  8:53   ` Peter Zijlstra
  2015-01-23 11:20   ` Borislav Petkov
  2015-01-23  5:36 ` [Resend Patch v4 13/16] smp, tile: " Jiang Liu
                   ` (4 subsequent siblings)
  16 siblings, 2 replies; 25+ messages in thread
From: Jiang Liu @ 2015-01-23  5:36 UTC (permalink / raw)
  To: Thomas Gleixner, Ingo Molnar, H. Peter Anvin, x86,
	Konrad Rzeszutek Wilk, Boris Ostrovsky, David Vrabel, Jiang Liu,
	Jan Beulich, Andy Lutomirski, David Drysdale, Steven Rostedt
  Cc: Borislav Petkov, Tony Luck, linux-kernel, Peter Zijlstra,
	Ingo Molnar, H. Peter Anvin, xen-devel

Commit 9a46ad6d6df3b54 "smp: make smp_call_function_many() use logic
similar to smp_call_function_single()" has unified the way to handle
single and multiple cross-CPU function calls. Now only one interrupt
is needed for architecture specific code to support generic SMP function
call interfaces, so kill the redundant single function call interrupt.

Cc: Peter Zijlstra <a.p.zijlstra@chello.nl>
Cc: Ingo Molnar <mingo@elte.hu>
Cc: Steven Rostedt <rostedt@goodmis.org>
Signed-off-by: Jiang Liu <jiang.liu@linux.intel.com>
---
 arch/x86/include/asm/entry_arch.h        |    1 -
 arch/x86/include/asm/hw_irq.h            |    3 ---
 arch/x86/include/asm/irq_vectors.h       |    7 +++----
 arch/x86/include/asm/trace/irq_vectors.h |    6 ------
 arch/x86/kernel/entry_64.S               |    2 --
 arch/x86/kernel/irqinit.c                |    4 ----
 arch/x86/kernel/smp.c                    |   24 +-----------------------
 arch/x86/xen/smp.c                       |    1 -
 8 files changed, 4 insertions(+), 44 deletions(-)

diff --git a/arch/x86/include/asm/entry_arch.h b/arch/x86/include/asm/entry_arch.h
index dc5fa661465f..9670cff64e93 100644
--- a/arch/x86/include/asm/entry_arch.h
+++ b/arch/x86/include/asm/entry_arch.h
@@ -12,7 +12,6 @@
 #ifdef CONFIG_SMP
 BUILD_INTERRUPT(reschedule_interrupt,RESCHEDULE_VECTOR)
 BUILD_INTERRUPT(call_function_interrupt,CALL_FUNCTION_VECTOR)
-BUILD_INTERRUPT(call_function_single_interrupt,CALL_FUNCTION_SINGLE_VECTOR)
 BUILD_INTERRUPT3(irq_move_cleanup_interrupt, IRQ_MOVE_CLEANUP_VECTOR,
 		 smp_irq_move_cleanup_interrupt)
 BUILD_INTERRUPT3(reboot_interrupt, REBOOT_VECTOR, smp_reboot_interrupt)
diff --git a/arch/x86/include/asm/hw_irq.h b/arch/x86/include/asm/hw_irq.h
index 9662290e0b20..4a7f5d4cfcdb 100644
--- a/arch/x86/include/asm/hw_irq.h
+++ b/arch/x86/include/asm/hw_irq.h
@@ -75,7 +75,6 @@ extern asmlinkage void reboot_interrupt(void);
 extern asmlinkage void threshold_interrupt(void);
 
 extern asmlinkage void call_function_interrupt(void);
-extern asmlinkage void call_function_single_interrupt(void);
 
 #ifdef CONFIG_TRACING
 /* Interrupt handlers registered during init_IRQ */
@@ -88,7 +87,6 @@ extern void trace_thermal_interrupt(void);
 extern void trace_reschedule_interrupt(void);
 extern void trace_threshold_interrupt(void);
 extern void trace_call_function_interrupt(void);
-extern void trace_call_function_single_interrupt(void);
 #define trace_irq_move_cleanup_interrupt  irq_move_cleanup_interrupt
 #define trace_reboot_interrupt  reboot_interrupt
 #define trace_kvm_posted_intr_ipi kvm_posted_intr_ipi
@@ -177,7 +175,6 @@ extern asmlinkage void smp_irq_move_cleanup_interrupt(void);
 #ifdef CONFIG_SMP
 extern __visible void smp_reschedule_interrupt(struct pt_regs *);
 extern __visible void smp_call_function_interrupt(struct pt_regs *);
-extern __visible void smp_call_function_single_interrupt(struct pt_regs *);
 extern __visible void smp_invalidate_interrupt(struct pt_regs *);
 #endif
 
diff --git a/arch/x86/include/asm/irq_vectors.h b/arch/x86/include/asm/irq_vectors.h
index 666c89ec4bd7..bab7f0a1edde 100644
--- a/arch/x86/include/asm/irq_vectors.h
+++ b/arch/x86/include/asm/irq_vectors.h
@@ -92,10 +92,9 @@
 #define ERROR_APIC_VECTOR		0xfe
 #define RESCHEDULE_VECTOR		0xfd
 #define CALL_FUNCTION_VECTOR		0xfc
-#define CALL_FUNCTION_SINGLE_VECTOR	0xfb
-#define THERMAL_APIC_VECTOR		0xfa
-#define THRESHOLD_APIC_VECTOR		0xf9
-#define REBOOT_VECTOR			0xf8
+#define THERMAL_APIC_VECTOR		0xfb
+#define THRESHOLD_APIC_VECTOR		0xfa
+#define REBOOT_VECTOR			0xf9
 
 /*
  * Generic system vector for platform specific use
diff --git a/arch/x86/include/asm/trace/irq_vectors.h b/arch/x86/include/asm/trace/irq_vectors.h
index 4cab890007a7..e672e203edc1 100644
--- a/arch/x86/include/asm/trace/irq_vectors.h
+++ b/arch/x86/include/asm/trace/irq_vectors.h
@@ -89,12 +89,6 @@ TRACE_EVENT_PERF_PERM(irq_work_exit, is_sampling_event(p_event) ? -EPERM : 0);
 DEFINE_IRQ_VECTOR_EVENT(call_function);
 
 /*
- * call_function_single - called when entering/exiting a call function
- * single interrupt vector handler
- */
-DEFINE_IRQ_VECTOR_EVENT(call_function_single);
-
-/*
  * threshold_apic - called when entering/exiting a threshold apic interrupt
  * vector handler
  */
diff --git a/arch/x86/kernel/entry_64.S b/arch/x86/kernel/entry_64.S
index 9ebaf63ba182..284e5741a9ba 100644
--- a/arch/x86/kernel/entry_64.S
+++ b/arch/x86/kernel/entry_64.S
@@ -1001,8 +1001,6 @@ apicinterrupt THERMAL_APIC_VECTOR \
 #endif
 
 #ifdef CONFIG_SMP
-apicinterrupt CALL_FUNCTION_SINGLE_VECTOR \
-	call_function_single_interrupt smp_call_function_single_interrupt
 apicinterrupt CALL_FUNCTION_VECTOR \
 	call_function_interrupt smp_call_function_interrupt
 apicinterrupt RESCHEDULE_VECTOR \
diff --git a/arch/x86/kernel/irqinit.c b/arch/x86/kernel/irqinit.c
index 70e181ea1eac..d72a8c4da145 100644
--- a/arch/x86/kernel/irqinit.c
+++ b/arch/x86/kernel/irqinit.c
@@ -111,10 +111,6 @@ static void __init smp_intr_init(void)
 	/* IPI for generic function call */
 	alloc_intr_gate(CALL_FUNCTION_VECTOR, call_function_interrupt);
 
-	/* IPI for generic single function call */
-	alloc_intr_gate(CALL_FUNCTION_SINGLE_VECTOR,
-			call_function_single_interrupt);
-
 	/* Low priority IPI to cleanup after moving an irq */
 	set_intr_gate(IRQ_MOVE_CLEANUP_VECTOR, irq_move_cleanup_interrupt);
 	set_bit(IRQ_MOVE_CLEANUP_VECTOR, used_vectors);
diff --git a/arch/x86/kernel/smp.c b/arch/x86/kernel/smp.c
index be8e1bde07aa..0dd3bf0578a6 100644
--- a/arch/x86/kernel/smp.c
+++ b/arch/x86/kernel/smp.c
@@ -129,7 +129,7 @@ static void native_smp_send_reschedule(int cpu)
 
 void native_send_call_func_single_ipi(int cpu)
 {
-	apic->send_IPI_mask(cpumask_of(cpu), CALL_FUNCTION_SINGLE_VECTOR);
+	apic->send_IPI_mask(cpumask_of(cpu), CALL_FUNCTION_VECTOR);
 }
 
 void native_send_call_func_ipi(const struct cpumask *mask)
@@ -311,28 +311,6 @@ __visible void smp_trace_call_function_interrupt(struct pt_regs *regs)
 	exiting_irq();
 }
 
-static inline void __smp_call_function_single_interrupt(void)
-{
-	generic_smp_call_function_single_interrupt();
-	inc_irq_stat(irq_call_count);
-}
-
-__visible void smp_call_function_single_interrupt(struct pt_regs *regs)
-{
-	smp_entering_irq();
-	__smp_call_function_single_interrupt();
-	exiting_irq();
-}
-
-__visible void smp_trace_call_function_single_interrupt(struct pt_regs *regs)
-{
-	smp_entering_irq();
-	trace_call_function_single_entry(CALL_FUNCTION_SINGLE_VECTOR);
-	__smp_call_function_single_interrupt();
-	trace_call_function_single_exit(CALL_FUNCTION_SINGLE_VECTOR);
-	exiting_irq();
-}
-
 static int __init nonmi_ipi_setup(char *str)
 {
 	smp_no_nmi_ipi = true;
diff --git a/arch/x86/xen/smp.c b/arch/x86/xen/smp.c
index d54c122a0486..91a6c0df46ac 100644
--- a/arch/x86/xen/smp.c
+++ b/arch/x86/xen/smp.c
@@ -590,7 +590,6 @@ static inline int xen_map_vector(int vector)
 		xen_vector = XEN_RESCHEDULE_VECTOR;
 		break;
 	case CALL_FUNCTION_VECTOR:
-	case CALL_FUNCTION_SINGLE_VECTOR:
 		xen_vector = XEN_CALL_FUNCTION_VECTOR;
 		break;
 	case IRQ_WORK_VECTOR:
-- 
1.7.10.4


^ permalink raw reply	[flat|nested] 25+ messages in thread

* [Resend Patch v4 13/16] smp, tile: Kill SMP single function call interrupt
  2015-01-23  5:36 [Resend Patch v4 00/16] Kill SMP single function call interrupt Jiang Liu
                   ` (11 preceding siblings ...)
  2015-01-23  5:36 ` [Resend Patch v4 12/16] smp, x86: " Jiang Liu
@ 2015-01-23  5:36 ` Jiang Liu
  2015-01-23  5:36 ` [Resend Patch v4 14/16] smp, s390: " Jiang Liu
                   ` (3 subsequent siblings)
  16 siblings, 0 replies; 25+ messages in thread
From: Jiang Liu @ 2015-01-23  5:36 UTC (permalink / raw)
  To: Thomas Gleixner, Chris Metcalf, Jiang Liu
  Cc: Borislav Petkov, Tony Luck, linux-kernel

Commit 9a46ad6d6df3b54 "smp: make smp_call_function_many() use logic
similar to smp_call_function_single()" has unified the way to handle
single and multiple cross-CPU function calls. Now only one interrupt
is needed for architecture specific code to support generic SMP function
call interfaces, so kill the redundant single function call interrupt.

Signed-off-by: Jiang Liu <jiang.liu@linux.intel.com>
Acked-by: Chris Metcalf <cmetc...@tilera.com>
---
 arch/tile/include/asm/smp.h |    7 +++----
 arch/tile/kernel/smp.c      |    6 +-----
 2 files changed, 4 insertions(+), 9 deletions(-)

diff --git a/arch/tile/include/asm/smp.h b/arch/tile/include/asm/smp.h
index 9a326b64f7ae..67e58e781549 100644
--- a/arch/tile/include/asm/smp.h
+++ b/arch/tile/include/asm/smp.h
@@ -67,19 +67,18 @@ static inline int xy_to_cpu(int x, int y)
 /* Hypervisor message tags sent via the tile send_IPI*() routines. */
 #define MSG_TAG_START_CPU		1
 #define MSG_TAG_STOP_CPU		2
-#define MSG_TAG_CALL_FUNCTION_MANY	3
-#define MSG_TAG_CALL_FUNCTION_SINGLE	4
+#define MSG_TAG_CALL_FUNCTION		3
 
 /* Hook for the generic smp_call_function_many() routine. */
 static inline void arch_send_call_function_ipi_mask(struct cpumask *mask)
 {
-	send_IPI_many(mask, MSG_TAG_CALL_FUNCTION_MANY);
+	send_IPI_many(mask, MSG_TAG_CALL_FUNCTION);
 }
 
 /* Hook for the generic smp_call_function_single() routine. */
 static inline void arch_send_call_function_single_ipi(int cpu)
 {
-	send_IPI_single(cpu, MSG_TAG_CALL_FUNCTION_SINGLE);
+	send_IPI_single(cpu, MSG_TAG_CALL_FUNCTION);
 }
 
 /* Print out the boot string describing which cpus were disabled. */
diff --git a/arch/tile/kernel/smp.c b/arch/tile/kernel/smp.c
index d3c4ed780ce2..780410176341 100644
--- a/arch/tile/kernel/smp.c
+++ b/arch/tile/kernel/smp.c
@@ -139,14 +139,10 @@ void evaluate_message(int tag)
 		smp_stop_cpu_interrupt();
 		break;
 
-	case MSG_TAG_CALL_FUNCTION_MANY: /* Call function on cpumask */
+	case MSG_TAG_CALL_FUNCTION: /* Call function on cpumask */
 		generic_smp_call_function_interrupt();
 		break;
 
-	case MSG_TAG_CALL_FUNCTION_SINGLE: /* Call function on one other CPU */
-		generic_smp_call_function_single_interrupt();
-		break;
-
 	default:
 		panic("Unknown IPI message tag %d", tag);
 		break;
-- 
1.7.10.4


^ permalink raw reply	[flat|nested] 25+ messages in thread

* [Resend Patch v4 14/16] smp, s390: Kill SMP single function call interrupt
  2015-01-23  5:36 [Resend Patch v4 00/16] Kill SMP single function call interrupt Jiang Liu
                   ` (12 preceding siblings ...)
  2015-01-23  5:36 ` [Resend Patch v4 13/16] smp, tile: " Jiang Liu
@ 2015-01-23  5:36 ` Jiang Liu
  2015-01-23  6:54   ` Heiko Carstens
  2015-01-23  5:36 ` [Resend Patch v4 15/16] smp: Cleanup unsued generic_smp_call_function_single_interrupt() Jiang Liu
                   ` (2 subsequent siblings)
  16 siblings, 1 reply; 25+ messages in thread
From: Jiang Liu @ 2015-01-23  5:36 UTC (permalink / raw)
  To: Thomas Gleixner, Martin Schwidefsky, Heiko Carstens, linux390,
	Michael Holzheu, Srivatsa S. Bhat, Jiang Liu
  Cc: Borislav Petkov, Tony Luck, linux-kernel, linux-s390

Commit 9a46ad6d6df3b54 "smp: make smp_call_function_many() use logic
similar to smp_call_function_single()" has unified the way to handle
single and multiple cross-CPU function calls. Now only one interrupt
is needed for architecture specific code to support generic SMP function
call interfaces, so kill the redundant single function call interrupt.

Signed-off-by: Jiang Liu <jiang.liu@linux.intel.com>
Acked-by: Heiko Carstens <heiko.carst...@de.ibm.com>
---
 arch/s390/kernel/smp.c |   10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/arch/s390/kernel/smp.c b/arch/s390/kernel/smp.c
index 0b499f5cbe19..5b89eabc3a01 100644
--- a/arch/s390/kernel/smp.c
+++ b/arch/s390/kernel/smp.c
@@ -50,7 +50,7 @@
 
 enum {
 	ec_schedule = 0,
-	ec_call_function_single,
+	ec_call_function,
 	ec_stop_cpu,
 };
 
@@ -416,8 +416,8 @@ static void smp_handle_ext_call(void)
 		smp_stop_cpu();
 	if (test_bit(ec_schedule, &bits))
 		scheduler_ipi();
-	if (test_bit(ec_call_function_single, &bits))
-		generic_smp_call_function_single_interrupt();
+	if (test_bit(ec_call_function, &bits))
+		generic_smp_call_function_interrupt();
 }
 
 static void do_ext_call_interrupt(struct ext_code ext_code,
@@ -432,12 +432,12 @@ void arch_send_call_function_ipi_mask(const struct cpumask *mask)
 	int cpu;
 
 	for_each_cpu(cpu, mask)
-		pcpu_ec_call(pcpu_devices + cpu, ec_call_function_single);
+		pcpu_ec_call(pcpu_devices + cpu, ec_call_function);
 }
 
 void arch_send_call_function_single_ipi(int cpu)
 {
-	pcpu_ec_call(pcpu_devices + cpu, ec_call_function_single);
+	pcpu_ec_call(pcpu_devices + cpu, ec_call_function);
 }
 
 #ifndef CONFIG_64BIT
-- 
1.7.10.4


^ permalink raw reply	[flat|nested] 25+ messages in thread

* [Resend Patch v4 15/16] smp: Cleanup unsued generic_smp_call_function_single_interrupt()
  2015-01-23  5:36 [Resend Patch v4 00/16] Kill SMP single function call interrupt Jiang Liu
                   ` (13 preceding siblings ...)
  2015-01-23  5:36 ` [Resend Patch v4 14/16] smp, s390: " Jiang Liu
@ 2015-01-23  5:36 ` Jiang Liu
  2015-01-23  5:36 ` [Resend Patch v4 16/16] smp, trivial: Remove unused function prototype from smp_boot.h Jiang Liu
  2015-01-24 19:28 ` [Resend Patch v4 00/16] Kill SMP single function call interrupt Thomas Gleixner
  16 siblings, 0 replies; 25+ messages in thread
From: Jiang Liu @ 2015-01-23  5:36 UTC (permalink / raw)
  To: Thomas Gleixner, Jens Axboe, Frederic Weisbecker, Andrew Morton,
	Jan Kara, Christoph Hellwig, Paul Gortmaker, Jiang Liu,
	Srivatsa S. Bhat, Chuansheng Liu, Roman Gushchin
  Cc: Borislav Petkov, Tony Luck, linux-kernel

Now we have killed all usage of generic_smp_call_function_single_interrupt()
from arch code, so kill it.

Signed-off-by: Jiang Liu <jiang.liu@linux.intel.com>
---
 include/linux/smp.h |    4 +---
 kernel/smp.c        |    4 ++--
 2 files changed, 3 insertions(+), 5 deletions(-)

diff --git a/include/linux/smp.h b/include/linux/smp.h
index 93dff5fff524..cd78b3aa2cf8 100644
--- a/include/linux/smp.h
+++ b/include/linux/smp.h
@@ -106,9 +106,7 @@ void wake_up_all_idle_cpus(void);
  * Generic and arch helpers
  */
 void __init call_function_init(void);
-void generic_smp_call_function_single_interrupt(void);
-#define generic_smp_call_function_interrupt \
-	generic_smp_call_function_single_interrupt
+void generic_smp_call_function_interrupt(void);
 
 /*
  * Mark the boot cpu "online" so that it can call console drivers in
diff --git a/kernel/smp.c b/kernel/smp.c
index f38a1e692259..e39712cbe92d 100644
--- a/kernel/smp.c
+++ b/kernel/smp.c
@@ -197,12 +197,12 @@ static int generic_exec_single(int cpu, struct call_single_data *csd,
 }
 
 /**
- * generic_smp_call_function_single_interrupt - Execute SMP IPI callbacks
+ * generic_smp_call_function_interrupt - Execute SMP IPI callbacks
  *
  * Invoked by arch to handle an IPI for call function single.
  * Must be called with interrupts disabled.
  */
-void generic_smp_call_function_single_interrupt(void)
+void generic_smp_call_function_interrupt(void)
 {
 	flush_smp_call_function_queue(true);
 }
-- 
1.7.10.4


^ permalink raw reply	[flat|nested] 25+ messages in thread

* [Resend Patch v4 16/16] smp, trivial: Remove unused function prototype from smp_boot.h
  2015-01-23  5:36 [Resend Patch v4 00/16] Kill SMP single function call interrupt Jiang Liu
                   ` (14 preceding siblings ...)
  2015-01-23  5:36 ` [Resend Patch v4 15/16] smp: Cleanup unsued generic_smp_call_function_single_interrupt() Jiang Liu
@ 2015-01-23  5:36 ` Jiang Liu
  2015-01-24 19:28 ` [Resend Patch v4 00/16] Kill SMP single function call interrupt Thomas Gleixner
  16 siblings, 0 replies; 25+ messages in thread
From: Jiang Liu @ 2015-01-23  5:36 UTC (permalink / raw)
  To: Thomas Gleixner, Jiri Kosina
  Cc: Jiang Liu, Borislav Petkov, Tony Luck, linux-kernel

Function smpboot_thread_schedule() is neither used nor defined,
so kill it.

Signed-off-by: Jiang Liu <jiang.liu@linux.intel.com>
---
 include/linux/smpboot.h |    1 -
 1 file changed, 1 deletion(-)

diff --git a/include/linux/smpboot.h b/include/linux/smpboot.h
index 13e929679550..d600afb21926 100644
--- a/include/linux/smpboot.h
+++ b/include/linux/smpboot.h
@@ -47,6 +47,5 @@ struct smp_hotplug_thread {
 
 int smpboot_register_percpu_thread(struct smp_hotplug_thread *plug_thread);
 void smpboot_unregister_percpu_thread(struct smp_hotplug_thread *plug_thread);
-int smpboot_thread_schedule(void);
 
 #endif
-- 
1.7.10.4


^ permalink raw reply	[flat|nested] 25+ messages in thread

* Re: [Resend Patch v4 14/16] smp, s390: Kill SMP single function call interrupt
  2015-01-23  5:36 ` [Resend Patch v4 14/16] smp, s390: " Jiang Liu
@ 2015-01-23  6:54   ` Heiko Carstens
  2015-01-23  9:21     ` Jiang Liu
  0 siblings, 1 reply; 25+ messages in thread
From: Heiko Carstens @ 2015-01-23  6:54 UTC (permalink / raw)
  To: Jiang Liu
  Cc: Thomas Gleixner, Martin Schwidefsky, linux390, Michael Holzheu,
	Srivatsa S. Bhat, Borislav Petkov, Tony Luck, linux-kernel,
	linux-s390

On Fri, Jan 23, 2015 at 01:36:53PM +0800, Jiang Liu wrote:
> Commit 9a46ad6d6df3b54 "smp: make smp_call_function_many() use logic
> similar to smp_call_function_single()" has unified the way to handle
> single and multiple cross-CPU function calls. Now only one interrupt
> is needed for architecture specific code to support generic SMP function
> call interfaces, so kill the redundant single function call interrupt.
> 
> Signed-off-by: Jiang Liu <jiang.liu@linux.intel.com>
> Acked-by: Heiko Carstens <heiko.carst...@de.ibm.com>

Is this really the patch I acked, whenever that was? Because the patch
description doesn't match what your patch does.
All it does is renaming ec_call_function_single to ec_call_function,
nothing else.

Could you please resend with a proper patch description?
Thanks!

> ---
>  arch/s390/kernel/smp.c |   10 +++++-----
>  1 file changed, 5 insertions(+), 5 deletions(-)
> 
> diff --git a/arch/s390/kernel/smp.c b/arch/s390/kernel/smp.c
> index 0b499f5cbe19..5b89eabc3a01 100644
> --- a/arch/s390/kernel/smp.c
> +++ b/arch/s390/kernel/smp.c
> @@ -50,7 +50,7 @@
> 
>  enum {
>  	ec_schedule = 0,
> -	ec_call_function_single,
> +	ec_call_function,
>  	ec_stop_cpu,
>  };
> 
> @@ -416,8 +416,8 @@ static void smp_handle_ext_call(void)
>  		smp_stop_cpu();
>  	if (test_bit(ec_schedule, &bits))
>  		scheduler_ipi();
> -	if (test_bit(ec_call_function_single, &bits))
> -		generic_smp_call_function_single_interrupt();
> +	if (test_bit(ec_call_function, &bits))
> +		generic_smp_call_function_interrupt();
>  }
> 
>  static void do_ext_call_interrupt(struct ext_code ext_code,
> @@ -432,12 +432,12 @@ void arch_send_call_function_ipi_mask(const struct cpumask *mask)
>  	int cpu;
> 
>  	for_each_cpu(cpu, mask)
> -		pcpu_ec_call(pcpu_devices + cpu, ec_call_function_single);
> +		pcpu_ec_call(pcpu_devices + cpu, ec_call_function);
>  }
> 
>  void arch_send_call_function_single_ipi(int cpu)
>  {
> -	pcpu_ec_call(pcpu_devices + cpu, ec_call_function_single);
> +	pcpu_ec_call(pcpu_devices + cpu, ec_call_function);
>  }
> 
>  #ifndef CONFIG_64BIT
> -- 
> 1.7.10.4
> 


^ permalink raw reply	[flat|nested] 25+ messages in thread

* Re: [Resend Patch v4 12/16] smp, x86: Kill SMP single function call interrupt
  2015-01-23  5:36 ` [Resend Patch v4 12/16] smp, x86: " Jiang Liu
@ 2015-01-23  8:53   ` Peter Zijlstra
  2015-01-23 11:20   ` Borislav Petkov
  1 sibling, 0 replies; 25+ messages in thread
From: Peter Zijlstra @ 2015-01-23  8:53 UTC (permalink / raw)
  To: Jiang Liu
  Cc: Thomas Gleixner, Ingo Molnar, H. Peter Anvin, x86,
	Konrad Rzeszutek Wilk, Boris Ostrovsky, David Vrabel,
	Jan Beulich, Andy Lutomirski, David Drysdale, Steven Rostedt,
	Borislav Petkov, Tony Luck, linux-kernel, Ingo Molnar,
	H. Peter Anvin, xen-devel

On Fri, Jan 23, 2015 at 01:36:51PM +0800, Jiang Liu wrote:
> Commit 9a46ad6d6df3b54 "smp: make smp_call_function_many() use logic
> similar to smp_call_function_single()" has unified the way to handle
> single and multiple cross-CPU function calls. Now only one interrupt
> is needed for architecture specific code to support generic SMP function
> call interfaces, so kill the redundant single function call interrupt.
> 
> Cc: Peter Zijlstra <a.p.zijlstra@chello.nl>
> Cc: Ingo Molnar <mingo@elte.hu>
> Cc: Steven Rostedt <rostedt@goodmis.org>
> Signed-off-by: Jiang Liu <jiang.liu@linux.intel.com>

Acked-by: Peter Zijlstra (Intel) <peterz@infradead.org>

^ permalink raw reply	[flat|nested] 25+ messages in thread

* Re: [Resend Patch v4 14/16] smp, s390: Kill SMP single function call interrupt
  2015-01-23  6:54   ` Heiko Carstens
@ 2015-01-23  9:21     ` Jiang Liu
  2015-01-23  9:32       ` Heiko Carstens
  0 siblings, 1 reply; 25+ messages in thread
From: Jiang Liu @ 2015-01-23  9:21 UTC (permalink / raw)
  To: Heiko Carstens
  Cc: Thomas Gleixner, Martin Schwidefsky, linux390, Michael Holzheu,
	Srivatsa S. Bhat, Borislav Petkov, Tony Luck, linux-kernel,
	linux-s390

On 2015/1/23 14:54, Heiko Carstens wrote:
> On Fri, Jan 23, 2015 at 01:36:53PM +0800, Jiang Liu wrote:
>> Commit 9a46ad6d6df3b54 "smp: make smp_call_function_many() use logic
>> similar to smp_call_function_single()" has unified the way to handle
>> single and multiple cross-CPU function calls. Now only one interrupt
>> is needed for architecture specific code to support generic SMP function
>> call interfaces, so kill the redundant single function call interrupt.
>>
>> Signed-off-by: Jiang Liu <jiang.liu@linux.intel.com>
>> Acked-by: Heiko Carstens <heiko.carst...@de.ibm.com>
> 
> Is this really the patch I acked, whenever that was? Because the patch
> description doesn't match what your patch does.
> All it does is renaming ec_call_function_single to ec_call_function,
> nothing else.
> 
> Could you please resend with a proper patch description?
> Thanks!
> 
>> ---
>>  arch/s390/kernel/smp.c |   10 +++++-----
>>  1 file changed, 5 insertions(+), 5 deletions(-)
>>
>> diff --git a/arch/s390/kernel/smp.c b/arch/s390/kernel/smp.c
>> index 0b499f5cbe19..5b89eabc3a01 100644
>> --- a/arch/s390/kernel/smp.c
>> +++ b/arch/s390/kernel/smp.c
>> @@ -50,7 +50,7 @@
>>
>>  enum {
>>  	ec_schedule = 0,
>> -	ec_call_function_single,
>> +	ec_call_function,
>>  	ec_stop_cpu,
>>  };
>>
>> @@ -416,8 +416,8 @@ static void smp_handle_ext_call(void)
>>  		smp_stop_cpu();
>>  	if (test_bit(ec_schedule, &bits))
>>  		scheduler_ipi();
>> -	if (test_bit(ec_call_function_single, &bits))
>> -		generic_smp_call_function_single_interrupt();
HI Heiko,
	The background is that the generic smp_call_xxx() interfaces
only use on interrupt now, previously it used two (FUNC_CALL and
FUNC_CALL_SINGLE). So the whole patch set is to kill
FUNC_CALL_SINGLE from all architectures.
	Above code kills generic_smp_call_function_single_interrupt().
We also replaces ec_call_function_single with ec_call_function so
only one interrupt will be used to support smp_call_xxx().
Regards!
Gerry

>> +	if (test_bit(ec_call_function, &bits))
>> +		generic_smp_call_function_interrupt();
>>  }
>>
>>  static void do_ext_call_interrupt(struct ext_code ext_code,
>> @@ -432,12 +432,12 @@ void arch_send_call_function_ipi_mask(const struct cpumask *mask)
>>  	int cpu;
>>
>>  	for_each_cpu(cpu, mask)
>> -		pcpu_ec_call(pcpu_devices + cpu, ec_call_function_single);
>> +		pcpu_ec_call(pcpu_devices + cpu, ec_call_function);
>>  }
>>
>>  void arch_send_call_function_single_ipi(int cpu)
>>  {
>> -	pcpu_ec_call(pcpu_devices + cpu, ec_call_function_single);
>> +	pcpu_ec_call(pcpu_devices + cpu, ec_call_function);
>>  }
>>
>>  #ifndef CONFIG_64BIT
>> -- 
>> 1.7.10.4
>>
> 
> --
> To unsubscribe from this list: send the line "unsubscribe linux-kernel" in
> the body of a message to majordomo@vger.kernel.org
> More majordomo info at  http://vger.kernel.org/majordomo-info.html
> Please read the FAQ at  http://www.tux.org/lkml/
> 

^ permalink raw reply	[flat|nested] 25+ messages in thread

* Re: [Resend Patch v4 14/16] smp, s390: Kill SMP single function call interrupt
  2015-01-23  9:21     ` Jiang Liu
@ 2015-01-23  9:32       ` Heiko Carstens
  0 siblings, 0 replies; 25+ messages in thread
From: Heiko Carstens @ 2015-01-23  9:32 UTC (permalink / raw)
  To: Jiang Liu
  Cc: Thomas Gleixner, Martin Schwidefsky, linux390, Michael Holzheu,
	Srivatsa S. Bhat, Borislav Petkov, Tony Luck, linux-kernel,
	linux-s390

On Fri, Jan 23, 2015 at 05:21:42PM +0800, Jiang Liu wrote:
> On 2015/1/23 14:54, Heiko Carstens wrote:
> > On Fri, Jan 23, 2015 at 01:36:53PM +0800, Jiang Liu wrote:
> >> Commit 9a46ad6d6df3b54 "smp: make smp_call_function_many() use logic
> >> similar to smp_call_function_single()" has unified the way to handle
> >> single and multiple cross-CPU function calls. Now only one interrupt
> >> is needed for architecture specific code to support generic SMP function
> >> call interfaces, so kill the redundant single function call interrupt.
> >>
> >> Signed-off-by: Jiang Liu <jiang.liu@linux.intel.com>
> >> Acked-by: Heiko Carstens <heiko.carst...@de.ibm.com>
> > 
> > Is this really the patch I acked, whenever that was? Because the patch
> > description doesn't match what your patch does.
> > All it does is renaming ec_call_function_single to ec_call_function,
> > nothing else.
> > 
> > Could you please resend with a proper patch description?
> > Thanks!
> > 
> >> ---
> >>  arch/s390/kernel/smp.c |   10 +++++-----
> >>  1 file changed, 5 insertions(+), 5 deletions(-)
> >>
> >> diff --git a/arch/s390/kernel/smp.c b/arch/s390/kernel/smp.c
> >> index 0b499f5cbe19..5b89eabc3a01 100644
> >> --- a/arch/s390/kernel/smp.c
> >> +++ b/arch/s390/kernel/smp.c
> >> @@ -50,7 +50,7 @@
> >>
> >>  enum {
> >>  	ec_schedule = 0,
> >> -	ec_call_function_single,
> >> +	ec_call_function,
> >>  	ec_stop_cpu,
> >>  };
> >>
> >> @@ -416,8 +416,8 @@ static void smp_handle_ext_call(void)
> >>  		smp_stop_cpu();
> >>  	if (test_bit(ec_schedule, &bits))
> >>  		scheduler_ipi();
> >> -	if (test_bit(ec_call_function_single, &bits))
> >> -		generic_smp_call_function_single_interrupt();
> HI Heiko,
> 	The background is that the generic smp_call_xxx() interfaces
> only use on interrupt now, previously it used two (FUNC_CALL and
> FUNC_CALL_SINGLE). So the whole patch set is to kill
> FUNC_CALL_SINGLE from all architectures.
> 	Above code kills generic_smp_call_function_single_interrupt().
> We also replaces ec_call_function_single with ec_call_function so
> only one interrupt will be used to support smp_call_xxx().

Ah right, I missed that while looking at your patch. Apologies!


^ permalink raw reply	[flat|nested] 25+ messages in thread

* Re: [Resend Patch v4 12/16] smp, x86: Kill SMP single function call interrupt
  2015-01-23  5:36 ` [Resend Patch v4 12/16] smp, x86: " Jiang Liu
  2015-01-23  8:53   ` Peter Zijlstra
@ 2015-01-23 11:20   ` Borislav Petkov
  1 sibling, 0 replies; 25+ messages in thread
From: Borislav Petkov @ 2015-01-23 11:20 UTC (permalink / raw)
  To: Jiang Liu
  Cc: Thomas Gleixner, Ingo Molnar, H. Peter Anvin, x86,
	Konrad Rzeszutek Wilk, Boris Ostrovsky, David Vrabel,
	Jan Beulich, Andy Lutomirski, David Drysdale, Steven Rostedt,
	Tony Luck, linux-kernel, Peter Zijlstra, Ingo Molnar,
	H. Peter Anvin, xen-devel

On Fri, Jan 23, 2015 at 01:36:51PM +0800, Jiang Liu wrote:
> Commit 9a46ad6d6df3b54 "smp: make smp_call_function_many() use logic
> similar to smp_call_function_single()" has unified the way to handle
> single and multiple cross-CPU function calls. Now only one interrupt
> is needed for architecture specific code to support generic SMP function
> call interfaces, so kill the redundant single function call interrupt.
> 
> Cc: Peter Zijlstra <a.p.zijlstra@chello.nl>
> Cc: Ingo Molnar <mingo@elte.hu>
> Cc: Steven Rostedt <rostedt@goodmis.org>
> Signed-off-by: Jiang Liu <jiang.liu@linux.intel.com>

Acked-by: Borislav Petkov <bp@suse.de>

-- 
Regards/Gruss,
    Boris.

ECO tip #101: Trim your mails when you reply.
--

^ permalink raw reply	[flat|nested] 25+ messages in thread

* Re: [Resend Patch v4 03/16] smp, ARM64: Kill SMP single function call interrupt
  2015-01-23  5:36 ` [Resend Patch v4 03/16] smp, ARM64: " Jiang Liu
@ 2015-01-23 18:10   ` Catalin Marinas
  0 siblings, 0 replies; 25+ messages in thread
From: Catalin Marinas @ 2015-01-23 18:10 UTC (permalink / raw)
  To: Jiang Liu
  Cc: Thomas Gleixner, Will Deacon, Mark Rutland, nicolas.pitre,
	Ashwin Chaugule, Larry Bassel, Mark Brown, Borislav Petkov,
	Tony Luck, linux-kernel, linux-arm-kernel, Arnd Bergmann

On Fri, Jan 23, 2015 at 05:36:42AM +0000, Jiang Liu wrote:
> Commit 9a46ad6d6df3b54 "smp: make smp_call_function_many() use logic
> similar to smp_call_function_single()" has unified the way to handle
> single and multiple cross-CPU function calls. Now only one interrupt
> is needed for architecture specific code to support generic SMP function
> call interfaces, so kill the redundant single function call interrupt.
> 
> Signed-off-by: Jiang Liu <jiang.liu@linux.intel.com>
> Acked-by: Will Deacon <will.deacon@arm.com>
> Cc: linux-arm-kernel@lists.infradead.org
> Cc: Catalin Marinas <catalin.marinas@arm.com>
> Cc: Arnd Bergmann <arnd@arndb.de>

I queued the arm64 patch for 3.20. Thanks.

-- 
Catalin

^ permalink raw reply	[flat|nested] 25+ messages in thread

* Re: [Resend Patch v4 00/16] Kill SMP single function call interrupt
  2015-01-23  5:36 [Resend Patch v4 00/16] Kill SMP single function call interrupt Jiang Liu
                   ` (15 preceding siblings ...)
  2015-01-23  5:36 ` [Resend Patch v4 16/16] smp, trivial: Remove unused function prototype from smp_boot.h Jiang Liu
@ 2015-01-24 19:28 ` Thomas Gleixner
  2015-01-26  2:13   ` Jiang Liu
  16 siblings, 1 reply; 25+ messages in thread
From: Thomas Gleixner @ 2015-01-24 19:28 UTC (permalink / raw)
  To: Jiang Liu; +Cc: Borislav Petkov, Tony Luck, linux-kernel

On Fri, 23 Jan 2015, Jiang Liu wrote:

>  38 files changed, 65 insertions(+), 268 deletions(-)

Nice cleanup. If nobody yells, I'm going to route it through tip.

Thanks,

	tglx

^ permalink raw reply	[flat|nested] 25+ messages in thread

* Re: [Resend Patch v4 00/16] Kill SMP single function call interrupt
  2015-01-24 19:28 ` [Resend Patch v4 00/16] Kill SMP single function call interrupt Thomas Gleixner
@ 2015-01-26  2:13   ` Jiang Liu
  0 siblings, 0 replies; 25+ messages in thread
From: Jiang Liu @ 2015-01-26  2:13 UTC (permalink / raw)
  To: Thomas Gleixner, David S. Miller, Sam Ravnborg, Kirill Tkhai
  Cc: Borislav Petkov, Tony Luck, linux-kernel



On 2015/1/25 3:28, Thomas Gleixner wrote:
> On Fri, 23 Jan 2015, Jiang Liu wrote:
> 
>>  38 files changed, 65 insertions(+), 268 deletions(-)
> 
> Nice cleanup. If nobody yells, I'm going to route it through tip.
Hi Thomas,
	We need explicitly ACKs from SPARC/SPARC64 maintainers
for patch 9 and 10. SPARC assembler has some advanced concept
"defer slot", I'm not sure I have done it in the right way.
Thanks!
Gerry
> 
> Thanks,
> 
> 	tglx
> 

^ permalink raw reply	[flat|nested] 25+ messages in thread

end of thread, other threads:[~2015-01-26  2:13 UTC | newest]

Thread overview: 25+ messages (download: mbox.gz / follow: Atom feed)
-- links below jump to the message on this page --
2015-01-23  5:36 [Resend Patch v4 00/16] Kill SMP single function call interrupt Jiang Liu
2015-01-23  5:36 ` [Resend Patch v4 01/16] smp, alpha: " Jiang Liu
2015-01-23  5:36 ` [Resend Patch v4 02/16] smp, ARM: " Jiang Liu
2015-01-23  5:36 ` [Resend Patch v4 03/16] smp, ARM64: " Jiang Liu
2015-01-23 18:10   ` Catalin Marinas
2015-01-23  5:36 ` [Resend Patch v4 04/16] smp, IA64: " Jiang Liu
2015-01-23  5:36 ` [Resend Patch v4 05/16] smp, m32r: " Jiang Liu
2015-01-23  5:36 ` [Resend Patch v4 06/16] smp, mn10300: " Jiang Liu
2015-01-23  5:36 ` [Resend Patch v4 07/16] smp, mn10300: Enable arch_send_call_function_ipi_mask() Jiang Liu
2015-01-23  5:36 ` [Resend Patch v4 08/16] smp, sh: Kill SMP single function call interrupt Jiang Liu
2015-01-23  5:36 ` [Resend Patch v4 09/16] smp, sparc64: " Jiang Liu
2015-01-23  5:36 ` [Resend Patch v4 10/16] smp, sparc: " Jiang Liu
2015-01-23  5:36 ` [Resend Patch v4 11/16] smp, x86, xen: " Jiang Liu
2015-01-23  5:36 ` [Resend Patch v4 12/16] smp, x86: " Jiang Liu
2015-01-23  8:53   ` Peter Zijlstra
2015-01-23 11:20   ` Borislav Petkov
2015-01-23  5:36 ` [Resend Patch v4 13/16] smp, tile: " Jiang Liu
2015-01-23  5:36 ` [Resend Patch v4 14/16] smp, s390: " Jiang Liu
2015-01-23  6:54   ` Heiko Carstens
2015-01-23  9:21     ` Jiang Liu
2015-01-23  9:32       ` Heiko Carstens
2015-01-23  5:36 ` [Resend Patch v4 15/16] smp: Cleanup unsued generic_smp_call_function_single_interrupt() Jiang Liu
2015-01-23  5:36 ` [Resend Patch v4 16/16] smp, trivial: Remove unused function prototype from smp_boot.h Jiang Liu
2015-01-24 19:28 ` [Resend Patch v4 00/16] Kill SMP single function call interrupt Thomas Gleixner
2015-01-26  2:13   ` Jiang Liu

This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox;
as well as URLs for NNTP newsgroup(s).