00/18] simplify generic cross CPU function call implementation
Subsystems (10)
PATCH RESEND v3 1/1 00/18] simplify generic cross CPU function call implementation
Resend for collecting more Acks targetting v3.14 merge window. Patch for ARC, MIPS and PARISC has been merged into v3.13. Gained Acks for Metag, Hexagon, Tile 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 (18):
Revert "kernel/smp.c: free related resources when failure occurs in
hotplug_cfd()"
Revert "smp: Fix SMP function call empty cpu mask race" 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, blackfin: 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: cleanup unsued generic_smp_call_function_single_interrupt()
smp: rename call_single_queue as call_function_queue SMP, trivial: remove unused code 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/blackfin/mach-common/smp.c | 6 +---- 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/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 | 11 +-------- 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/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 | 7 +++--- include/linux/smpboot.h | 1 - kernel/smp.c | 39 ++++++++++---------------------- 36 files changed, 70 insertions(+), 282 deletions(-)
Signature · 1 line
1.8.1.2
PATCH RESEND v3 1/1 03/18] smp, alpha: kill SMP single function call interrupt
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.
--- arch/alpha/kernel/smp.c | 8 +------- 1 file changed, 1 insertion(+), 7 deletions(-)
arch/alpha/kernel/smp.c +1 -7
@@ -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 ; } -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
Signature · 1 line
1.8.1.2
PATCH RESEND v3 1/1 04/18] smp, ARM: kill SMP single function call interrupt
In reply to Jiang LiuCommit 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.
--- arch/arm/include/asm/hardirq.h | 2 +- arch/arm/kernel/smp.c | 10 +--------- 2 files changed, 2 insertions(+), 10 deletions(-)
arch/arm/include/asm/hardirq.h +1 -1
@@ -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;
arch/arm/kernel/smp.c +1 -9
@@ -65,7 +65,6 @@ enum ipi_msg_type {IPI_TIMER ,IPI_RESCHEDULE ,IPI_CALL_FUNC , -IPI_CALL_FUNC_SINGLE ,IPI_CPU_STOP ,IPI_IRQ_WORK , IPI_COMPLETION,
@@ -448,7 +447,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
@@ -465,7 +464,6 @@ static const char *ipi_types[NR_IPI] = {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"),
@@ -579,12 +577,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);
Signature · 1 line
1.8.1.2
PATCH RESEND v3 1/1 05/18] smp, ARM64: kill SMP single function call interrupt
In reply to Jiang LiuCommit 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.
--- arch/arm64/include/asm/hardirq.h | 2 +- arch/arm64/kernel/smp.c | 10 +--------- 2 files changed, 2 insertions(+), 10 deletions(-)
arch/arm64/include/asm/hardirq.h +1 -1
@@ -20,7 +20,7 @@#include <linux/threads.h> #include <asm/irq.h> -#define NR_IPI 4 +#define NR_IPI 3 typedef struct { unsigned int __softirq_pending;
arch/arm64/kernel/smp.c +1 -9
@@ -59,7 +59,6 @@ struct secondary_data secondary_data;enum ipi_msg_type {IPI_RESCHEDULE ,IPI_CALL_FUNC , -IPI_CALL_FUNC_SINGLE ,IPI_CPU_STOP , };
@@ -438,14 +437,13 @@ 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 ); }static const char *ipi_types[NR_IPI ] = { #define S(x,s) [x - IPI_RESCHEDULE] = sS (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" ), };
@@ -520,12 +518,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);
Signature · 1 line
1.8.1.2
Re: [PATCH v3 [resend] 05/18] smp, ARM64: kill SMP single function call interrupt
Quoted 17 lines · Jiang Liu
Commit
9a46ad6d6df3b54"smp: makesmp_call_function_many()use logic similar tosmp_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 Andrew Morton <[email protected]>Cc Shaohua Li <[email protected]>Cc Peter Zijlstra <[email protected]>Cc Ingo Molnar <[email protected]>Cc Steven Rostedt <[email protected]>Cc Jiri Kosina <[email protected]>Cc Catalin Marinas <[email protected]>Cc Will Deacon <[email protected]>Cc Arnd Bergmann <[email protected]>Cc linux-arm-kernel at lists.infradead.orgSigned-off-by Jiang Liu <[email protected]>
Quoted 4 lines
--- arch/arm64/include/asm/hardirq.h | 2 +- arch/arm64/kernel/smp.c | 10 +--------- 2 files changed, 2 insertions(+), 10 deletions(-)
I assume you're taking this series via some other route (than the arch/ trees) in order to deal with any core dependencies?
Will
PATCH RESEND v3 1/1 07/18] smp, IA64: kill SMP single function call interrupt
In reply to Jiang LiuCommit 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.
--- arch/ia64/kernel/smp.c | 8 ++------ 1 file changed, 2 insertions(+), 6 deletions(-)
arch/ia64/kernel/smp.c +2 -6
@@ -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)
Signature · 1 line
1.8.1.2
PATCH RESEND v3 1/1 11/18] smp, sh: kill SMP single function call interrupt
In reply to Jiang LiuCommit 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.
--- arch/sh/include/asm/smp.h | 1 - arch/sh/kernel/smp.c | 5 +---- 2 files changed, 1 insertion(+), 5 deletions(-)
arch/sh/include/asm/smp.h +0 -1
@@ -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 */
arch/sh/kernel/smp.c +1 -4
@@ -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 ;
Signature · 1 line
1.8.1.2
PATCH RESEND v3 1/1 12/18] smp, sparc64: kill SMP single function call interrupt
In reply to Jiang LiuCommit 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.
--- arch/sparc/include/asm/pil.h | 5 ++--- arch/sparc/kernel/smp_64.c | 11 +---------- arch/sparc/kernel/ttable_64.S | 12 ++++-------- arch/sparc/mm/ultra.S | 5 ----- 4 files changed, 7 insertions(+), 26 deletions(-)
arch/sparc/include/asm/pil.h +2 -3
@@ -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
arch/sparc/kernel/smp_64.c +1 -10
@@ -811,12 +811,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)
@@ -825,12 +822,6 @@ void __irq_entry smp_call_function_client(int irq, struct pt_regs *regs)generic_smp_call_function_interrupt (); } -void __irq_entry smp_call_function_single_client(int irq, struct pt_regs *regs) -{ -clear_softint (1 << irq); -generic_smp_call_function_single_interrupt (); -} -static void tsb_sync (void *info) {struct trap_per_cpu *tp = &trap_block[raw_smp_processor_id ()];
arch/sparc/kernel/ttable_64.S +4 -8
@@ -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)
arch/sparc/mm/ultra.S +0 -5
@@ -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
Signature · 1 line
1.8.1.2
PATCH RESEND v3 1/1 13/18] smp, sparc: kill SMP single function call interrupt
In reply to Jiang LiuCommit 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.
--- 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(-)
arch/sparc/include/asm/smp_32.h +1 -3
@@ -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;
arch/sparc/kernel/entry.S +2 -8
@@ -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
arch/sparc/kernel/leon_smp.c +7 -24
@@ -271,8 +271,7 @@ void leon_irq_rotate(int cpu) }struct leon_ipi_work { -int single; -int msk; +int func_call;int resched; };
@@ -308,7 +307,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 ; } }
@@ -319,23 +318,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);
@@ -356,12 +344,8 @@ void leonsmp_ipi_interrupt(void) {struct leon_ipi_work *work = &__get_cpu_var (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) {
@@ -467,8 +451,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 )
arch/sparc/kernel/smp_32.c +2 -12
@@ -138,17 +138,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 )
@@ -160,14 +158,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 ();
arch/sparc/kernel/sun4d_smp.c +7 -24
@@ -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 = &__get_cpu_var (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 )
arch/sparc/kernel/sun4m_smp.c +2 -9
@@ -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 )
Signature · 1 line
1.8.1.2
PATCH RESEND v3 1/1 14/18] smp, x86, xen: kill SMP single function call interrupt
In reply to Jiang LiuCommit 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.
--- arch/x86/include/asm/xen/events.h | 1 - arch/x86/xen/smp.c | 38 ++------------------------------------ 2 files changed, 2 insertions(+), 37 deletions(-)
arch/x86/include/asm/xen/events.h +0 -1
@@ -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 ,
arch/x86/xen/smp.c +2 -36
@@ -46,12 +46,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);/*
@@ -123,13 +121,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 ;
@@ -178,18 +169,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.
@@ -569,8 +548,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)
@@ -582,10 +560,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 ;
@@ -663,16 +639,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 ();
Signature · 1 line
1.8.1.2
Re: [PATCH v3 [resend] 14/18] smp, x86, xen: kill SMP single function call interrupt
Quoted 6 lines · Jiang Liu
Commit
9a46ad6d6df3b54"smp: makesmp_call_function_many()use logic similar tosmp_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.
Quoted 9 lines
Cc Andrew Morton <[email protected]>Cc Shaohua Li <[email protected]>Cc Peter Zijlstra <[email protected]>Cc Ingo Molnar <[email protected]>Cc Steven Rostedt <[email protected]>Cc Jiri Kosina <[email protected]>Cc Thomas Gleixner <[email protected]>Cc "H. Peter Anvin" <[email protected]>Cc Konrad Rzeszutek Wilk <[email protected]>
I presume this has been tested?
Quoted 115 lines
Cc Jeremy Fitzhardinge <[email protected]>Cc Sebastian Andrzej Siewior <[email protected]>Signed-off-by Jiang Liu <[email protected]>--- arch/x86/include/asm/xen/events.h | 1 - arch/x86/xen/smp.c | 38 ++------------------------------------ 2 files changed, 2 insertions(+), 37 deletions(-)arch/x86/include/asm/xen/events.h +0
-1@@ -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 ,arch/x86/xen/smp.c +2
-36@@ -46,12 +46,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);/* @@ -123,13 +121,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 ;@@ -178,18 +169,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. @@ -569,8 +548,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)@@ -582,10 +560,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 ;@@ -663,16 +639,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 ();Signature · 1 line
1.8.1.2
RE: [PATCH v3 [resend] 14/18] smp, x86, xen: kill SMP single function call interrupt
Quoted 19 lines · Konrad Rzeszutek Wilk
Quoted 8 lines · Jiang Liu
Commit
9a46ad6d6df3b54"smp: makesmp_call_function_many()use logic similar tosmp_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.Quoted 9 lines
Cc Andrew Morton <[email protected]>Cc Shaohua Li <[email protected]>Cc Peter Zijlstra <[email protected]>Cc Ingo Molnar <[email protected]>Cc Steven Rostedt <[email protected]>Cc Jiri Kosina <[email protected]>Cc Thomas Gleixner <[email protected]>Cc "H. Peter Anvin" <[email protected]>Cc Konrad Rzeszutek Wilk <[email protected]>
Quoted 2 lines
I presume this has been tested?
I have just test Jiang's patch, it works fine for dom0 booting.
Thanks,
Jinsong
Re: [PATCH v3 [resend] 14/18] smp, x86, xen: kill SMP single function call interrupt
Quoted 20 lines · Jinsong
Quoted 19 lines · Konrad Rzeszutek Wilk
Quoted 17 lines · Jiang Liu
Commit
9a46ad6d6df3b54"smp: makesmp_call_function_many()use logic similar tosmp_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 Andrew Morton <[email protected]>Cc Shaohua Li <[email protected]>Cc Peter Zijlstra <[email protected]>Cc Ingo Molnar <[email protected]>Cc Steven Rostedt <[email protected]>Cc Jiri Kosina <[email protected]>Cc Thomas Gleixner <[email protected]>Cc "H. Peter Anvin" <[email protected]>Cc Konrad Rzeszutek Wilk <[email protected]>
Quoted 4 lines
Quoted 2 lines
I presume this has been tested?
I have just test Jiang's patch, it works fine for dom0 booting.
Excellent! Please add Acked-by from me.
Thanks!
Quoted 5 lines
Thanks,
Jinsong
RE: [PATCH v3 [resend] 14/18] smp, x86, xen: kill SMP single function call interrupt
In reply to Konrad Rzeszutek WilkQuoted 19 lines · Konrad Rzeszutek Wilk
Quoted 8 lines · Jiang Liu
Commit
9a46ad6d6df3b54"smp: makesmp_call_function_many()use logic similar tosmp_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.Quoted 9 lines
Cc Andrew Morton <[email protected]>Cc Shaohua Li <[email protected]>Cc Peter Zijlstra <[email protected]>Cc Ingo Molnar <[email protected]>Cc Steven Rostedt <[email protected]>Cc Jiri Kosina <[email protected]>Cc Thomas Gleixner <[email protected]>Cc "H. Peter Anvin" <[email protected]>Cc Konrad Rzeszutek Wilk <[email protected]>
Quoted 2 lines
I presume this has been tested?
I have just test Jiang's patch, it works fine for dom0 booting.
Thanks,
Jinsong
PATCH RESEND v3 1/1 15/18] smp, x86: kill SMP single function call interrupt
In reply to Jiang LiuCommit 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.
--- 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(-)
arch/x86/include/asm/entry_arch.h +0 -1
@@ -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)
arch/x86/include/asm/hw_irq.h +0 -3
@@ -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
@@ -182,7 +180,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
arch/x86/include/asm/irq_vectors.h +3 -4
@@ -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
arch/x86/include/asm/trace/irq_vectors.h +0 -6
@@ -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 */
arch/x86/kernel/entry_64.S +0 -2
@@ -1182,8 +1182,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 \
arch/x86/kernel/irqinit.c +0 -4
@@ -141,10 +141,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);
arch/x86/kernel/smp.c +1 -23
@@ -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;
arch/x86/xen/smp.c +0 -1
@@ -560,7 +560,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 :
Signature · 1 line
1.8.1.2
PATCH RESEND v3 1/1 18/18] SMP, trivial: remove unused code from smp_boot.h
In reply to Jiang LiuFrom: Jiang Liu <[email protected]>
Function smpboot_thread_schedule() is never defined or used, so remove it from smp_boot.h.
--- include/linux/smpboot.h | 1 - 1 file changed, 1 deletion(-)
include/linux/smpboot.h +0 -1
@@ -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
Signature · 1 line
1.8.1.2
PATCH RESEND v3 1/1 01/18] Revert "kernel/smp.c: free related resources when failure occurs in hotplug_cfd()"
In reply to Jiang LiuThis reverts commit 60c323699bb308404dcb60e8808531e02651578a.
Commit 60c323699bb30840 fixes a bug introduced by f44310b98ddb7, and we are going to revert f44310b98ddb7, so revert 60c323699bb30840 first.
--- kernel/smp.c | 5 +---- 1 file changed, 1 insertion(+), 4 deletions(-)
kernel/smp.c +1 -4
@@ -48,13 +48,10 @@ hotplug_cfd(struct notifier_block *nfb, unsigned long action, void *hcpu) cpu_to_node(cpu)))return notifier_from_errno (-ENOMEM );if (!zalloc_cpumask_var_node (&cfd->cpumask_ipi,GFP_KERNEL , -cpu_to_node (cpu))) { -free_cpumask_var (cfd->cpumask); +cpu_to_node (cpu)))return notifier_from_errno (-ENOMEM ); - } cfd->csd = alloc_percpu(struct call_single_data);if (!cfd->csd) { -free_cpumask_var (cfd->cpumask_ipi);free_cpumask_var (cfd->cpumask);return notifier_from_errno (-ENOMEM ); }
Signature · 1 line
1.8.1.2
PATCH RESEND v3 1/1 02/18] Revert "smp: Fix SMP function call empty cpu mask race"
In reply to Jiang LiuThis reverts commit f44310b98ddb7f0d06550d73ed67df5865e3eda5.
Commit f44310b98ddb7 "smp: Fix SMP function call empty cpu mask race" introduced field call_function_data->cpumask_ipi to resolve a race condition in smp_call_function_many().
Later commit 9a46ad6d6df3 "smp: make smp_call_function_many() use logic similar to smp_call_function_single()" fixed the same issue in another way when optimizing smp_call_function_many(), which then obsoletes changes introduced by commit f44310b98ddb7. So revert it.
--- kernel/smp.c | 16 ++-------------- 1 file changed, 2 insertions(+), 14 deletions(-)
kernel/smp.c +2 -14
@@ -23,7 +23,6 @@ enum {struct call_function_data {struct call_single_data __percpu *csd;cpumask_var_t cpumask; -cpumask_var_t cpumask_ipi; }; static DEFINE_PER_CPU_SHARED_ALIGNED(struct call_function_data, cfd_data);
@@ -47,9 +46,6 @@ hotplug_cfd(struct notifier_block *nfb, unsigned long action, void *hcpu)if (!zalloc_cpumask_var_node (&cfd->cpumask,GFP_KERNEL ,cpu_to_node (cpu)))return notifier_from_errno (-ENOMEM ); -if (!zalloc_cpumask_var_node (&cfd->cpumask_ipi,GFP_KERNEL , -cpu_to_node (cpu))) -return notifier_from_errno (-ENOMEM ); cfd->csd = alloc_percpu(struct call_single_data);if (!cfd->csd) {free_cpumask_var (cfd->cpumask);
@@ -64,7 +60,6 @@ hotplug_cfd(struct notifier_block *nfb, unsigned long action, void *hcpu)case CPU_DEAD :case CPU_DEAD_FROZEN :free_cpumask_var (cfd->cpumask); -free_cpumask_var (cfd->cpumask_ipi);free_percpu (cfd->csd);break ;#endif
@@ -245,9 +240,9 @@ int smp_call_function_single(int cpu, smp_call_func_t func, void *info, csd = &__get_cpu_var (csd_data);csd_lock (csd); - csd->func = func; csd->info = info; +generic_exec_single (cpu, csd, wait); }else { err = -ENXIO ;/* CPU not online */
@@ -399,13 +394,6 @@ void smp_call_function_many(const struct cpumask *mask,if (unlikely (!cpumask_weight (cfd->cpumask)))return ; -/* -* After we put an entry into the list, cfd->cpumask may be cleared -* again when another CPU sends another IPI for a SMP function call, so -* cfd->cpumask will be zero. -*/ -cpumask_copy (cfd->cpumask_ipi, cfd->cpumask); -for_each_cpu (cpu, cfd->cpumask) {struct call_single_data *csd =per_cpu_ptr (cfd->csd, cpu); struct call_single_queue *dst =
@@ -422,7 +410,7 @@ void smp_call_function_many(const struct cpumask *mask, }/* Send a message to all CPUs in the map */ -arch_send_call_function_ipi_mask (cfd->cpumask_ipi); +arch_send_call_function_ipi_mask (cfd->cpumask);if (wait) {for_each_cpu (cpu, cfd->cpumask) {
Signature · 1 line
1.8.1.2
PATCH RESEND v3 1/1 06/18] smp, blackfin: kill SMP single function call interrupt
In reply to Jiang LiuCommit 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.
--- arch/blackfin/mach-common/smp.c | 6 +----- 1 file changed, 1 insertion(+), 5 deletions(-)
arch/blackfin/mach-common/smp.c +1 -5
@@ -53,7 +53,6 @@ enum ipi_message_type {BFIN_IPI_TIMER ,BFIN_IPI_RESCHEDULE ,BFIN_IPI_CALL_FUNC , -BFIN_IPI_CALL_FUNC_SINGLE , BFIN_IPI_CPU_STOP, };
@@ -162,9 +161,6 @@ static irqreturn_t ipi_handler_int1(int irq, void *dev_instance)case BFIN_IPI_CALL_FUNC :generic_smp_call_function_interrupt ();break ; -case BFIN_IPI_CALL_FUNC_SINGLE : -generic_smp_call_function_single_interrupt (); -break ;case BFIN_IPI_CPU_STOP :ipi_cpu_stop (cpu);break ;
@@ -210,7 +206,7 @@ void send_ipi(const struct cpumask *cpumask, enum ipi_message_type msg)void arch_send_call_function_single_ipi (int cpu) { -send_ipi (cpumask_of (cpu),BFIN_IPI_CALL_FUNC_SINGLE ); +send_ipi (cpumask_of (cpu),BFIN_IPI_CALL_FUNC ); }void arch_send_call_function_ipi_mask (const struct cpumask *mask)
Signature · 1 line
1.8.1.2
PATCH RESEND v3 1/1 08/18] smp, m32r: kill SMP single function call interrupt
In reply to Jiang LiuCommit 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.
--- 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(-)
arch/m32r/include/asm/smp.h +0 -1
@@ -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)
arch/m32r/kernel/smp.c +1 -8
@@ -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 */ /*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*/
arch/m32r/kernel/traps.c +1 -2
@@ -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 ();
Signature · 1 line
1.8.1.2
PATCH RESEND v3 1/1 09/18] smp, mn10300: kill SMP single function call interrupt
In reply to Jiang LiuRename CALL_FUNC_SINGLE_IPI as CALL_FUNC_IPI to prepare for killing generic_smp_call_function_single_interrupt().
--- arch/mn10300/include/asm/smp.h | 2 +- arch/mn10300/kernel/smp.c | 16 ++++++++-------- 2 files changed, 9 insertions(+), 9 deletions(-)
arch/mn10300/include/asm/smp.h +1 -1
@@ -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
arch/mn10300/kernel/smp.c +8 -8
@@ -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 );
Signature · 1 line
1.8.1.2
PATCH RESEND v3 1/1 10/18] smp, mn10300: enable arch_send_call_function_ipi_mask()
In reply to Jiang LiuEnable arch_send_call_function_ipi_mask() on mn10300 to support smp_call_function_many().
--- arch/mn10300/kernel/smp.c | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-)
arch/mn10300/kernel/smp.c +1 -2
@@ -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)
Signature · 1 line
1.8.1.2
PATCH RESEND v3 1/1 16/18] smp: cleanup unsued generic_smp_call_function_single_interrupt()
In reply to Jiang LiuFrom: Jiang Liu <[email protected]>
Now we have killed all usage of generic_smp_call_function_single_interrupt() from arch code, so kill it.
--- include/linux/smp.h | 7 ++++--- kernel/smp.c | 2 +- 2 files changed, 5 insertions(+), 4 deletions(-)
include/linux/smp.h +4 -3
@@ -107,9 +107,10 @@ void kick_all_cpus_sync(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 smp_call_function_interrupt (void ); +#define generic_smp_call_function_interrupt smp_call_function_interrupt +#define generic_smp_call_function_single_interrupt \ + smp_call_function_interrupt/* * Mark the boot cpu "online" so that it can call console drivers in
kernel/smp.c +1 -1
@@ -167,7 +167,7 @@ static void generic_exec_single(int cpu, struct call_single_data *csd, int wait)* Invoked by arch to handle an IPI for call function single. Must be * called from the arch with interrupts disabled. */ -void generic_smp_call_function_single_interrupt (void ) +void smp_call_function_interrupt (void ) {struct call_single_queue *q = &__get_cpu_var (call_single_queue);LIST_HEAD (list);
Signature · 1 line
1.8.1.2
PATCH RESEND v3 1/1 17/18] smp: rename call_single_queue as call_function_queue
In reply to Jiang LiuFrom: Jiang Liu <[email protected]>
Now the same list is used to serve both single and multiple function call requests, so rename call_single_queue as call_function_queue.
--- kernel/smp.c | 18 +++++++++--------- 1 file changed, 9 insertions(+), 9 deletions(-)
kernel/smp.c +9 -9
@@ -27,12 +27,12 @@ struct call_function_data { static DEFINE_PER_CPU_SHARED_ALIGNED(struct call_function_data, cfd_data); -struct call_single_queue { +struct call_function_queue {struct list_head list;raw_spinlock_t lock; }; -static DEFINE_PER_CPU_SHARED_ALIGNED(struct call_single_queue, call_single_queue); +static DEFINE_PER_CPU_SHARED_ALIGNED(struct call_function_queue, call_function_queue);static int hotplug_cfd (struct notifier_block *nfb,unsigned long action,void *hcpu)
@@ -75,11 +75,11 @@ static struct notifier_block hotplug_cfd_notifier = {void __init call_function_init (void ) {void *cpu = (void *)(long )smp_processor_id (); +struct call_function_queue *q;int i;for_each_possible_cpu (i) { -struct call_single_queue *q = &per_cpu (call_single_queue, i); - + q = &per_cpu (call_function_queue, i);raw_spin_lock_init (&q->lock);INIT_LIST_HEAD (&q->list); }
@@ -133,7 +133,7 @@ static void csd_unlock(struct call_single_data *csd)*/ static void generic_exec_single (int cpu,struct call_single_data *csd,int wait) { -struct call_single_queue *dst = &per_cpu (call_single_queue, cpu); +struct call_function_queue *dst = &per_cpu (call_function_queue, cpu);unsigned long flags;int ipi;
@@ -164,12 +164,12 @@ static void generic_exec_single(int cpu, struct call_single_data *csd, int wait) }/* -* Invoked by arch to handle an IPI for call function single. Must be +* Invoked by arch to handle an IPI for call function. Must be * called from the arch with interrupts disabled. */ void smp_call_function_interrupt (void ) { -struct call_single_queue *q = &__get_cpu_var (call_single_queue); +struct call_function_queue *q = &__get_cpu_var (call_function_queue);LIST_HEAD (list);/*
@@ -396,8 +396,8 @@ void smp_call_function_many(const struct cpumask *mask,for_each_cpu (cpu, cfd->cpumask) {struct call_single_data *csd =per_cpu_ptr (cfd->csd, cpu); -struct call_single_queue *dst = - &per_cpu (call_single_queue, cpu); +struct call_function_queue *dst = + &per_cpu (call_function_queue, cpu);unsigned long flags;csd_lock (csd);
Signature · 1 line
1.8.1.2