Module: xenomai-3 Branch: stable-3.0.x Commit: be6f3c41769cacbcfa9efc9add46543be0d09bde URL: http://git.xenomai.org/?p=xenomai-3.git;a=commit;h=be6f3c41769cacbcfa9efc9add46543be0d09bde
Author: Philippe Gerum <r...@xenomai.org> Date: Fri Sep 9 19:00:22 2016 +0200 cobalt/x86: upgrade I-pipe support --- ...-x86-6.patch => ipipe-core-3.18.20-x86-8.patch} | 79 +++-- ...8-x86-3.patch => ipipe-core-4.1.18-x86-7.patch} | 313 +++++++++++++++----- 2 files changed, 302 insertions(+), 90 deletions(-) diff --git a/kernel/cobalt/arch/x86/patches/ipipe-core-3.18.20-x86-6.patch b/kernel/cobalt/arch/x86/patches/ipipe-core-3.18.20-x86-8.patch similarity index 99% rename from kernel/cobalt/arch/x86/patches/ipipe-core-3.18.20-x86-6.patch rename to kernel/cobalt/arch/x86/patches/ipipe-core-3.18.20-x86-8.patch index 128c382..51ebf67 100644 --- a/kernel/cobalt/arch/x86/patches/ipipe-core-3.18.20-x86-6.patch +++ b/kernel/cobalt/arch/x86/patches/ipipe-core-3.18.20-x86-8.patch @@ -449,7 +449,7 @@ index 615fa90..e0a62ab 100644 extern void default_send_IPI_mask_sequence_phys(const struct cpumask *mask, diff --git a/arch/x86/include/asm/ipipe.h b/arch/x86/include/asm/ipipe.h new file mode 100644 -index 0000000..ccc8945 +index 0000000..12305ff --- /dev/null +++ b/arch/x86/include/asm/ipipe.h @@ -0,0 +1,118 @@ @@ -479,7 +479,7 @@ index 0000000..ccc8945 + +#ifdef CONFIG_IPIPE + -+#define IPIPE_CORE_RELEASE 6 ++#define IPIPE_CORE_RELEASE 8 + +struct ipipe_domain; +struct pt_regs; @@ -3426,10 +3426,10 @@ index e7cc537..bc5e8f8 100644 handle_real_irq: diff --git a/arch/x86/kernel/ipipe.c b/arch/x86/kernel/ipipe.c new file mode 100644 -index 0000000..a06e6bb +index 0000000..d756d17 --- /dev/null +++ b/arch/x86/kernel/ipipe.c -@@ -0,0 +1,499 @@ +@@ -0,0 +1,504 @@ +/* -*- linux-c -*- + * linux/arch/x86/kernel/ipipe.c + * @@ -3465,6 +3465,7 @@ index 0000000..a06e6bb +#include <linux/mm.h> +#include <linux/kgdb.h> +#include <linux/ipipe_tickdev.h> ++#include <trace/events/tlb.h> +#include <asm/asm-offsets.h> +#include <asm/unistd.h> +#include <asm/processor.h> @@ -3929,6 +3930,10 @@ index 0000000..a06e6bb +#if defined(CONFIG_CC_STACKPROTECTOR) && defined(CONFIG_X86_64) +EXPORT_PER_CPU_SYMBOL_GPL(irq_stack_union); +#endif ++ ++#if defined(CONFIG_TRACEPOINTS) && defined(CONFIG_IPIPE_LEGACY) ++EXPORT_TRACEPOINT_SYMBOL_GPL(tlb_flush); ++#endif diff --git a/arch/x86/kernel/irq.c b/arch/x86/kernel/irq.c index 3790775..218eb83 100644 --- a/arch/x86/kernel/irq.c @@ -5831,6 +5836,18 @@ index abcafaa..a8440e4 100644 } ____cacheline_aligned; /* +diff --git a/include/linux/ftrace.h b/include/linux/ftrace.h +index 662697b..6a9b6ad 100644 +--- a/include/linux/ftrace.h ++++ b/include/linux/ftrace.h +@@ -108,6 +108,7 @@ enum { + FTRACE_OPS_FL_ADDING = 1 << 9, + FTRACE_OPS_FL_REMOVING = 1 << 10, + FTRACE_OPS_FL_MODIFYING = 1 << 11, ++ FTRACE_OPS_FL_IPIPE_EXCLUSIVE = 1 << 12, + }; + + #ifdef CONFIG_DYNAMIC_FTRACE diff --git a/include/linux/hardirq.h b/include/linux/hardirq.h index cba442e..b513a46 100644 --- a/include/linux/hardirq.h @@ -11776,7 +11793,7 @@ index 0000000..143f9e6 +#endif /* CONFIG_IPIPE_HAVE_HOSTRT */ diff --git a/kernel/ipipe/tracer.c b/kernel/ipipe/tracer.c new file mode 100644 -index 0000000..da272c50 +index 0000000..8388671 --- /dev/null +++ b/kernel/ipipe/tracer.c @@ -0,0 +1,1468 @@ @@ -13114,7 +13131,7 @@ index 0000000..da272c50 + +static struct ftrace_ops ipipe_trace_ops = { + .func = ipipe_trace_function, -+ .flags = FTRACE_OPS_FL_RECURSION_SAFE, ++ .flags = FTRACE_OPS_FL_IPIPE_EXCLUSIVE, +}; + +static ssize_t __ipipe_wr_enable(struct file *file, const char __user *buffer, @@ -14675,7 +14692,7 @@ index a5da09c..6650799 100644 help This option will modify all the calls to function tracing diff --git a/kernel/trace/ftrace.c b/kernel/trace/ftrace.c -index d1eff3d..2a324bc 100644 +index d1eff3d..f8b9472 100644 --- a/kernel/trace/ftrace.c +++ b/kernel/trace/ftrace.c @@ -32,6 +32,7 @@ @@ -14686,7 +14703,33 @@ index d1eff3d..2a324bc 100644 #include <trace/events/sched.h> -@@ -2298,6 +2299,9 @@ void __weak arch_ftrace_update_code(int command) +@@ -251,8 +252,17 @@ static inline void update_function_graph_func(void) { } + + static void update_ftrace_function(void) + { ++ struct ftrace_ops *ops; + ftrace_func_t func; + ++ for (ops = ftrace_ops_list; ++ ops != &ftrace_list_end; ops = ops->next) ++ if (ops->flags & FTRACE_OPS_FL_IPIPE_EXCLUSIVE) { ++ set_function_trace_op = ops; ++ func = ops->func; ++ goto set_pointers; ++ } ++ + /* + * Prepare the ftrace_ops that the arch callback will use. + * If there's only one ftrace_ops registered, the ftrace_ops_list +@@ -280,6 +290,7 @@ static void update_ftrace_function(void) + + update_function_graph_func(); + ++ set_pointers: + /* If there's no change, then do nothing more here */ + if (ftrace_trace_function == func) + return; +@@ -2298,6 +2309,9 @@ void __weak arch_ftrace_update_code(int command) static void ftrace_run_update_code(int command) { @@ -14696,7 +14739,7 @@ index d1eff3d..2a324bc 100644 int ret; ret = ftrace_arch_code_modify_prepare(); -@@ -2311,7 +2315,13 @@ static void ftrace_run_update_code(int command) +@@ -2311,7 +2325,13 @@ static void ftrace_run_update_code(int command) * is safe. The stop_machine() is the safest, but also * produces the most overhead. */ @@ -14710,7 +14753,7 @@ index d1eff3d..2a324bc 100644 ret = ftrace_arch_code_modify_post_process(); FTRACE_WARN_ON(ret); -@@ -4621,10 +4631,10 @@ static int ftrace_process_locs(struct module *mod, +@@ -4621,10 +4641,10 @@ static int ftrace_process_locs(struct module *mod, * reason to cause large interrupt latencies while we do it. */ if (!mod) @@ -14723,7 +14766,7 @@ index d1eff3d..2a324bc 100644 ret = 0; out: mutex_unlock(&ftrace_lock); -@@ -4723,9 +4733,11 @@ void __init ftrace_init(void) +@@ -4723,9 +4743,11 @@ void __init ftrace_init(void) unsigned long count, flags; int ret; @@ -14737,7 +14780,7 @@ index d1eff3d..2a324bc 100644 if (ret) goto failed; -@@ -4891,7 +4903,16 @@ __ftrace_ops_list_func(unsigned long ip, unsigned long parent_ip, +@@ -4891,7 +4913,16 @@ __ftrace_ops_list_func(unsigned long ip, unsigned long parent_ip, } } while_for_each_ftrace_op(op); out: @@ -15103,24 +15146,22 @@ index 0c9216c..00a9a30 100644 return err; } diff --git a/lib/smp_processor_id.c b/lib/smp_processor_id.c -index 1afec32..5803111 100644 +index 1afec32..f7c1a2a 100644 --- a/lib/smp_processor_id.c +++ b/lib/smp_processor_id.c -@@ -12,10 +12,13 @@ notrace static unsigned int check_preemption_disabled(const char *what1, +@@ -12,6 +12,12 @@ notrace static unsigned int check_preemption_disabled(const char *what1, { int this_cpu = raw_smp_processor_id(); ++ if (hard_irqs_disabled()) ++ goto out; ++ + if (!ipipe_root_p) + goto out; + if (likely(preempt_count())) goto out; -- if (irqs_disabled()) -+ if (irqs_disabled() || hard_irqs_disabled()) - goto out; - - /* diff --git a/mm/memory.c b/mm/memory.c index 90fb265..8a1fd79 100644 --- a/mm/memory.c diff --git a/kernel/cobalt/arch/x86/patches/ipipe-core-4.1.18-x86-3.patch b/kernel/cobalt/arch/x86/patches/ipipe-core-4.1.18-x86-7.patch similarity index 98% rename from kernel/cobalt/arch/x86/patches/ipipe-core-4.1.18-x86-3.patch rename to kernel/cobalt/arch/x86/patches/ipipe-core-4.1.18-x86-7.patch index 5a8cf1e..48a87d8 100644 --- a/kernel/cobalt/arch/x86/patches/ipipe-core-4.1.18-x86-3.patch +++ b/kernel/cobalt/arch/x86/patches/ipipe-core-4.1.18-x86-7.patch @@ -434,7 +434,7 @@ index 615fa90..e0a62ab 100644 extern void default_send_IPI_mask_sequence_phys(const struct cpumask *mask, diff --git a/arch/x86/include/asm/ipipe.h b/arch/x86/include/asm/ipipe.h new file mode 100644 -index 0000000..b5966a6 +index 0000000..ed68a7e --- /dev/null +++ b/arch/x86/include/asm/ipipe.h @@ -0,0 +1,112 @@ @@ -464,7 +464,7 @@ index 0000000..b5966a6 + +#ifdef CONFIG_IPIPE + -+#define IPIPE_CORE_RELEASE 3 ++#define IPIPE_CORE_RELEASE 7 + +struct ipipe_domain; +struct pt_regs; @@ -3423,10 +3423,10 @@ index e7cc537..bc5e8f8 100644 handle_real_irq: diff --git a/arch/x86/kernel/ipipe.c b/arch/x86/kernel/ipipe.c new file mode 100644 -index 0000000..d63126c +index 0000000..fb9d80f --- /dev/null +++ b/arch/x86/kernel/ipipe.c -@@ -0,0 +1,499 @@ +@@ -0,0 +1,510 @@ +/* -*- linux-c -*- + * linux/arch/x86/kernel/ipipe.c + * @@ -3485,6 +3485,7 @@ index 0000000..d63126c +#include <asm/i387.h> +#include <asm/fpu-internal.h> +#include <asm/mce.h> ++#include <asm/mmu_context.h> + +DEFINE_PER_CPU(unsigned long, __ipipe_cr2); +EXPORT_PER_CPU_SYMBOL_GPL(__ipipe_cr2); @@ -3926,6 +3927,16 @@ index 0000000..d63126c +#if defined(CONFIG_CC_STACKPROTECTOR) && defined(CONFIG_X86_64) +EXPORT_PER_CPU_SYMBOL_GPL(irq_stack_union); +#endif ++ ++#ifdef CONFIG_IPIPE_LEGACY ++#ifdef CONFIG_TRACEPOINTS ++EXPORT_TRACEPOINT_SYMBOL_GPL(tlb_flush); ++#endif ++#ifdef CONFIG_PERF_EVENTS ++EXPORT_SYMBOL_GPL(rdpmc_always_available); ++#endif ++#endif ++ diff --git a/arch/x86/kernel/irq.c b/arch/x86/kernel/irq.c index e5952c2..9376ee0 100644 --- a/arch/x86/kernel/irq.c @@ -5746,6 +5757,19 @@ index 0000000..1f6e9c3 +static inline void __ipipe_init_threadinfo(struct ipipe_threadinfo *p) { } + +#endif /* !_IPIPE_THREAD_INFO_H */ +diff --git a/include/linux/basic_mmio_gpio.h b/include/linux/basic_mmio_gpio.h +index 0e97856..b5d7e60 100644 +--- a/include/linux/basic_mmio_gpio.h ++++ b/include/linux/basic_mmio_gpio.h +@@ -50,7 +50,7 @@ struct bgpio_chip { + * Used to lock bgpio_chip->data. Also, this is needed to keep + * shadowed and real data registers writes together. + */ +- spinlock_t lock; ++ ipipe_spinlock_t lock; + + /* Shadowed data register to clear/set bits safely. */ + unsigned long data; diff --git a/include/linux/clockchips.h b/include/linux/clockchips.h index 96c280b..0baa8f1 100644 --- a/include/linux/clockchips.h @@ -5798,6 +5822,18 @@ index 901555a..1ba117c 100644 int (*read)(struct console *, char *, unsigned); struct tty_driver *(*device)(struct console *, int *); void (*unblank)(void); +diff --git a/include/linux/ftrace.h b/include/linux/ftrace.h +index 6cd8c0e..0951ab4 100644 +--- a/include/linux/ftrace.h ++++ b/include/linux/ftrace.h +@@ -134,6 +134,7 @@ enum { + FTRACE_OPS_FL_ALLOC_TRAMP = 1 << 12, + FTRACE_OPS_FL_IPMODIFY = 1 << 13, + FTRACE_OPS_FL_PID = 1 << 14, ++ FTRACE_OPS_FL_IPIPE_EXCLUSIVE = 1 << 15, + }; + + #ifdef CONFIG_DYNAMIC_FTRACE diff --git a/include/linux/hardirq.h b/include/linux/hardirq.h index f4af034..fa16b8c 100644 --- a/include/linux/hardirq.h @@ -6308,10 +6344,10 @@ index 0000000..0a9b5b6 +#endif /* !__LINUX_IPIPE_H */ diff --git a/include/linux/ipipe_base.h b/include/linux/ipipe_base.h new file mode 100644 -index 0000000..8c06eed +index 0000000..42b368a --- /dev/null +++ b/include/linux/ipipe_base.h -@@ -0,0 +1,360 @@ +@@ -0,0 +1,365 @@ +/* -*- linux-c -*- + * include/linux/ipipe_base.h + * @@ -6422,6 +6458,7 @@ index 0000000..8c06eed +#define IPIPE_KEVT_EXIT 4 +#define IPIPE_KEVT_CLEANUP 5 +#define IPIPE_KEVT_HOSTRT 6 ++#define IPIPE_KEVT_CLOCKFREQ 7 + +struct ipipe_vm_notifier { + void (*handler)(struct ipipe_vm_notifier *nfy); @@ -6550,6 +6587,9 @@ index 0000000..8c06eed +#define __ipipe_report_cleanup(mm) \ + __ipipe_notify_kevent(IPIPE_KEVT_CLEANUP, mm) + ++#define __ipipe_report_clockfreq_update(freq) \ ++ __ipipe_notify_kevent(IPIPE_KEVT_CLOCKFREQ, &(freq)) ++ +void __ipipe_notify_vm_preemption(void); + +void __ipipe_call_mayday(struct pt_regs *regs); @@ -6569,7 +6609,8 @@ index 0000000..8c06eed +#define IPIPE_EVENT_EXIT (IPIPE_FIRST_EVENT + 4) +#define IPIPE_EVENT_CLEANUP (IPIPE_FIRST_EVENT + 5) +#define IPIPE_EVENT_HOSTRT (IPIPE_FIRST_EVENT + 6) -+#define IPIPE_EVENT_SYSCALL (IPIPE_FIRST_EVENT + 7) ++#define IPIPE_EVENT_CLOCKFREQ (IPIPE_FIRST_EVENT + 7) ++#define IPIPE_EVENT_SYSCALL (IPIPE_FIRST_EVENT + 8) +#define IPIPE_LAST_EVENT IPIPE_EVENT_SYSCALL +#define IPIPE_NR_EVENTS (IPIPE_LAST_EVENT + 1) + @@ -7420,10 +7461,10 @@ index 0000000..d00c56b +#endif /* !__LINUX_IPIPE_DOMAIN_H */ diff --git a/include/linux/ipipe_lock.h b/include/linux/ipipe_lock.h new file mode 100644 -index 0000000..f71d2f1 +index 0000000..a108278 --- /dev/null +++ b/include/linux/ipipe_lock.h -@@ -0,0 +1,260 @@ +@@ -0,0 +1,327 @@ +/* -*- linux-c -*- + * include/linux/ipipe_lock.h + * @@ -7452,22 +7493,87 @@ index 0000000..f71d2f1 + arch_spinlock_t arch_lock; +} __ipipe_spinlock_t; + ++#define ipipe_spinlock(lock) ((__ipipe_spinlock_t *)(lock)) +#define ipipe_spinlock_p(lock) \ + __builtin_types_compatible_p(typeof(lock), __ipipe_spinlock_t *) || \ + __builtin_types_compatible_p(typeof(lock), __ipipe_spinlock_t []) + ++#define std_spinlock_raw(lock) ((raw_spinlock_t *)(lock)) +#define std_spinlock_raw_p(lock) \ + __builtin_types_compatible_p(typeof(lock), raw_spinlock_t *) || \ + __builtin_types_compatible_p(typeof(lock), raw_spinlock_t []) + ++#ifdef CONFIG_PREEMPT_RT_FULL ++ ++#define PICK_SPINLOCK_IRQSAVE(lock, flags) \ ++ do { \ ++ if (ipipe_spinlock_p(lock)) \ ++ (flags) = __ipipe_spin_lock_irqsave(ipipe_spinlock(lock)); \ ++ else if (std_spinlock_raw_p(lock)) \ ++ __real_raw_spin_lock_irqsave(std_spinlock_raw(lock), flags); \ ++ else __bad_lock_type(); \ ++ } while (0) ++ ++#define PICK_SPINTRYLOCK_IRQSAVE(lock, flags) \ ++ ({ \ ++ int __ret__; \ ++ if (ipipe_spinlock_p(lock)) \ ++ __ret__ = __ipipe_spin_trylock_irqsave(ipipe_spinlock(lock), &(flags)); \ ++ else if (std_spinlock_raw_p(lock)) \ ++ __ret__ = __real_raw_spin_trylock_irqsave(std_spinlock_raw(lock), flags); \ ++ else __bad_lock_type(); \ ++ __ret__; \ ++ }) ++ ++#define PICK_SPINTRYLOCK_IRQ(lock) \ ++ ({ \ ++ int __ret__; \ ++ if (ipipe_spinlock_p(lock)) \ ++ __ret__ = __ipipe_spin_trylock_irq(ipipe_spinlock(lock)); \ ++ else if (std_spinlock_raw_p(lock)) \ ++ __ret__ = __real_raw_spin_trylock_irq(std_spinlock_raw(lock)); \ ++ else __bad_lock_type(); \ ++ __ret__; \ ++ }) ++ ++#define PICK_SPINUNLOCK_IRQRESTORE(lock, flags) \ ++ do { \ ++ if (ipipe_spinlock_p(lock)) \ ++ __ipipe_spin_unlock_irqrestore(ipipe_spinlock(lock), flags); \ ++ else if (std_spinlock_raw_p(lock)) { \ ++ __ipipe_spin_unlock_debug(flags); \ ++ __real_raw_spin_unlock_irqrestore(std_spinlock_raw(lock), flags); \ ++ } else __bad_lock_type(); \ ++ } while (0) ++ ++#define PICK_SPINOP(op, lock) \ ++ ({ \ ++ if (ipipe_spinlock_p(lock)) \ ++ arch_spin##op(&ipipe_spinlock(lock)->arch_lock); \ ++ else if (std_spinlock_raw_p(lock)) \ ++ __real_raw_spin##op(std_spinlock_raw(lock)); \ ++ else __bad_lock_type(); \ ++ (void)0; \ ++ }) ++ ++#define PICK_SPINOP_RET(op, lock, type) \ ++ ({ \ ++ type __ret__; \ ++ if (ipipe_spinlock_p(lock)) \ ++ __ret__ = arch_spin##op(&ipipe_spinlock(lock)->arch_lock); \ ++ else if (std_spinlock_raw_p(lock)) \ ++ __ret__ = __real_raw_spin##op(std_spinlock_raw(lock)); \ ++ else { __ret__ = -1; __bad_lock_type(); } \ ++ __ret__; \ ++ }) ++ ++#else /* !CONFIG_PREEMPT_RT_FULL */ ++ ++#define std_spinlock(lock) ((spinlock_t *)(lock)) +#define std_spinlock_p(lock) \ + __builtin_types_compatible_p(typeof(lock), spinlock_t *) || \ + __builtin_types_compatible_p(typeof(lock), spinlock_t []) + -+#define ipipe_spinlock(lock) ((__ipipe_spinlock_t *)(lock)) -+#define std_spinlock_raw(lock) ((raw_spinlock_t *)(lock)) -+#define std_spinlock(lock) ((spinlock_t *)(lock)) -+ +#define PICK_SPINLOCK_IRQSAVE(lock, flags) \ + do { \ + if (ipipe_spinlock_p(lock)) \ @@ -7543,6 +7649,8 @@ index 0000000..f71d2f1 + __ret__; \ + }) + ++#endif /* !CONFIG_PREEMPT_RT_FULL */ ++ +#define arch_spin_lock_init(lock) \ + do { \ + IPIPE_DEFINE_SPINLOCK(__lock__); \ @@ -7672,7 +7780,7 @@ index 0000000..f71d2f1 +#define __ipipe_spin_trylock_irq(lock) 1 +#define __ipipe_spin_trylock_irqsave(lock, x) ({ (void)(x); 1; }) +#define __ipipe_spin_unlock_irqrestore(lock, x) do { (void)(x); } while (0) -+#define __ipipe_spin_unlock_irqbegin(lock) do { } while (0) ++#define __ipipe_spin_unlock_irqbegin(lock) spin_unlock(lock) +#define __ipipe_spin_unlock_irqcomplete(x) do { (void)(x); } while (0) +#define __ipipe_spin_unlock_debug(flags) do { } while (0) + @@ -7686,10 +7794,10 @@ index 0000000..f71d2f1 +#endif /* !__LINUX_IPIPE_LOCK_H */ diff --git a/include/linux/ipipe_tickdev.h b/include/linux/ipipe_tickdev.h new file mode 100644 -index 0000000..58a4142 +index 0000000..2f065ad --- /dev/null +++ b/include/linux/ipipe_tickdev.h -@@ -0,0 +1,145 @@ +@@ -0,0 +1,148 @@ +/* -*- linux-c -*- + * include/linux/ipipe_tickdev.h + * @@ -7769,6 +7877,7 @@ index 0000000..58a4142 + struct clock_event_device *cdev); + int (*real_set_next_event)(unsigned long evt, + struct clock_event_device *cdev); ++ unsigned int (*refresh_freq)(void); +}; + +#define __ipipe_hrtimer_irq __ipipe_raw_cpu_read(ipipe_percpu.hrtimer_irq) @@ -7821,6 +7930,8 @@ index 0000000..58a4142 + +unsigned ipipe_timer_ns2ticks(struct ipipe_timer *timer, unsigned ns); + ++void __ipipe_timer_refresh_freq(unsigned int hrclock_freq); ++ +#else /* !CONFIG_IPIPE */ + +#define ipipe_host_timer_register(clkevt) do { } while (0) @@ -9375,7 +9486,7 @@ index 0000000..797a849 +} diff --git a/kernel/ipipe/core.c b/kernel/ipipe/core.c new file mode 100644 -index 0000000..3b07d65 +index 0000000..339fb95 --- /dev/null +++ b/kernel/ipipe/core.c @@ -0,0 +1,1916 @@ @@ -10203,7 +10314,7 @@ index 0000000..3b07d65 + unsigned long flags, irq = 0; + int ipos; + -+ spin_lock_irqsave(&__ipipe_lock, flags); ++ raw_spin_lock_irqsave(&__ipipe_lock, flags); + + if (__ipipe_virtual_irq_map != ~0) { + ipos = ffz(__ipipe_virtual_irq_map); @@ -10211,7 +10322,7 @@ index 0000000..3b07d65 + irq = ipos + IPIPE_VIRQ_BASE; + } + -+ spin_unlock_irqrestore(&__ipipe_lock, flags); ++ raw_spin_unlock_irqrestore(&__ipipe_lock, flags); + + return irq; +} @@ -10241,7 +10352,7 @@ index 0000000..3b07d65 + (irq >= IPIPE_NR_XIRQS && !ipipe_virtual_irq_p(irq))) + return -EINVAL; + -+ spin_lock_irqsave(&__ipipe_lock, flags); ++ raw_spin_lock_irqsave(&__ipipe_lock, flags); + + if (ipd->irqs[irq].handler) { + ret = -EBUSY; @@ -10259,7 +10370,7 @@ index 0000000..3b07d65 + if (irq < IPIPE_NR_ROOT_IRQS) + __ipipe_enable_irqdesc(ipd, irq); +out: -+ spin_unlock_irqrestore(&__ipipe_lock, flags); ++ raw_spin_unlock_irqrestore(&__ipipe_lock, flags); + + return ret; +} @@ -10274,7 +10385,7 @@ index 0000000..3b07d65 + ipipe_root_only(); +#endif /* CONFIG_IPIPE_LEGACY */ + -+ spin_lock_irqsave(&__ipipe_lock, flags); ++ raw_spin_lock_irqsave(&__ipipe_lock, flags); + + if (ipd->irqs[irq].handler == NULL) + goto out; @@ -10287,7 +10398,7 @@ index 0000000..3b07d65 + if (irq < IPIPE_NR_ROOT_IRQS) + __ipipe_disable_irqdesc(ipd, irq); +out: -+ spin_unlock_irqrestore(&__ipipe_lock, flags); ++ raw_spin_unlock_irqrestore(&__ipipe_lock, flags); +} +EXPORT_SYMBOL_GPL(ipipe_free_irq); + @@ -10930,7 +11041,7 @@ index 0000000..3b07d65 + * another CPU. Enter a spinning wait until he releases the + * global lock. + */ -+ spin_lock(&__ipipe_cpu_barrier); ++ raw_spin_lock(&__ipipe_cpu_barrier); + + /* Got it. Now get out. */ + @@ -10940,7 +11051,7 @@ index 0000000..3b07d65 + + cpumask_set_cpu(cpu, &__ipipe_cpu_pass_map); + -+ spin_unlock(&__ipipe_cpu_barrier); ++ raw_spin_unlock(&__ipipe_cpu_barrier); + + cpumask_clear_cpu(cpu, &__ipipe_cpu_sync_map); +} @@ -10973,7 +11084,7 @@ index 0000000..3b07d65 + } +restart: + online = *cpu_online_mask; -+ spin_lock(&__ipipe_cpu_barrier); ++ raw_spin_lock(&__ipipe_cpu_barrier); + + __ipipe_cpu_sync = syncfn; + @@ -10999,7 +11110,7 @@ index 0000000..3b07d65 + */ + __ipipe_cpu_sync = NULL; + -+ spin_unlock(&__ipipe_cpu_barrier); ++ raw_spin_unlock(&__ipipe_cpu_barrier); + /* + * Ensure all CPUs consumed the IPI to avoid + * running __ipipe_cpu_sync prematurely. This @@ -11029,7 +11140,7 @@ index 0000000..3b07d65 + +#ifdef CONFIG_SMP + if (atomic_dec_and_test(&__ipipe_critical_count)) { -+ spin_unlock(&__ipipe_cpu_barrier); ++ raw_spin_unlock(&__ipipe_cpu_barrier); + while (!cpumask_empty(&__ipipe_cpu_sync_map)) + cpu_relax(); + cpumask_clear_cpu(ipipe_processor_id(), &__ipipe_cpu_lock_map); @@ -11297,10 +11408,10 @@ index 0000000..3b07d65 +#endif diff --git a/kernel/ipipe/timer.c b/kernel/ipipe/timer.c new file mode 100644 -index 0000000..73f748e +index 0000000..a9917f4 --- /dev/null +++ b/kernel/ipipe/timer.c -@@ -0,0 +1,497 @@ +@@ -0,0 +1,520 @@ +/* -*- linux-c -*- + * linux/kernel/ipipe/timer.c + * @@ -11427,7 +11538,7 @@ index 0000000..73f748e + if (timer->cpumask == NULL) + timer->cpumask = cpumask_of(smp_processor_id()); + -+ spin_lock_irqsave(&lock, flags); ++ raw_spin_lock_irqsave(&lock, flags); + + list_for_each_entry(t, &timers, link) { + if (t->rating <= timer->rating) { @@ -11437,7 +11548,7 @@ index 0000000..73f748e + } + list_add_tail(&timer->link, &timers); + done: -+ spin_unlock_irqrestore(&lock, flags); ++ raw_spin_unlock_irqrestore(&lock, flags); +} + +static void ipipe_timer_request_sync(void) @@ -11460,18 +11571,14 @@ index 0000000..73f748e + timer->request(timer, steal); +} + -+/* Set up a timer as per-cpu timer for ipipe */ -+static void install_pcpu_timer(unsigned cpu, unsigned hrclock_freq, -+ struct ipipe_timer *t) { -+ unsigned hrtimer_freq; ++static void config_pcpu_timer(struct ipipe_timer *t, unsigned hrclock_freq) ++{ + unsigned long long tmp; ++ unsigned hrtimer_freq; + -+ if (__ipipe_hrtimer_freq == 0) ++ if (__ipipe_hrtimer_freq != t->freq) + __ipipe_hrtimer_freq = t->freq; + -+ per_cpu(ipipe_percpu.hrtimer_irq, cpu) = t->irq; -+ per_cpu(percpu_timer, cpu) = t; -+ + hrtimer_freq = t->freq; + if (__ipipe_hrclock_freq > UINT_MAX) + hrtimer_freq /= 1000; @@ -11484,6 +11591,15 @@ index 0000000..73f748e + t->c2t_frac = tmp; +} + ++/* Set up a timer as per-cpu timer for ipipe */ ++static void install_pcpu_timer(unsigned cpu, unsigned hrclock_freq, ++ struct ipipe_timer *t) ++{ ++ per_cpu(ipipe_percpu.hrtimer_irq, cpu) = t->irq; ++ per_cpu(percpu_timer, cpu) = t; ++ config_pcpu_timer(t, hrclock_freq); ++} ++ +static void select_root_only_timer(unsigned cpu, unsigned hrclock_khz, + const struct cpumask *mask, + struct ipipe_timer *t) { @@ -11537,7 +11653,7 @@ index 0000000..73f748e + } else + hrclock_freq = __ipipe_hrclock_freq; + -+ spin_lock_irqsave(&lock, flags); ++ raw_spin_lock_irqsave(&lock, flags); + + /* First, choose timers for the CPUs handled by ipipe */ + for_each_cpu(cpu, mask) { @@ -11577,7 +11693,7 @@ index 0000000..73f748e + } + } + -+ spin_unlock_irqrestore(&lock, flags); ++ raw_spin_unlock_irqrestore(&lock, flags); + + flags = ipipe_critical_enter(ipipe_timer_request_sync); + ipipe_timer_request_sync(); @@ -11586,7 +11702,7 @@ index 0000000..73f748e + return 0; + +err_remove_all: -+ spin_unlock_irqrestore(&lock, flags); ++ raw_spin_unlock_irqrestore(&lock, flags); + + for_each_cpu(cpu, mask) { + per_cpu(ipipe_percpu.hrtimer_irq, cpu) = -1; @@ -11798,9 +11914,27 @@ index 0000000..73f748e +} + +#endif /* CONFIG_IPIPE_HAVE_HOSTRT */ ++ ++int clockevents_program_event(struct clock_event_device *dev, ktime_t expires, ++ bool force); ++ ++void __ipipe_timer_refresh_freq(unsigned int hrclock_freq) ++{ ++ struct ipipe_timer *t = __ipipe_raw_cpu_read(percpu_timer); ++ unsigned long flags; ++ ++ if (t && t->refresh_freq) { ++ t->freq = t->refresh_freq(); ++ flags = hard_local_irq_save(); ++ config_pcpu_timer(t, hrclock_freq); ++ hard_local_irq_restore(flags); ++ clockevents_program_event(t->host_timer, ++ t->host_timer->next_event, false); ++ } ++} diff --git a/kernel/ipipe/tracer.c b/kernel/ipipe/tracer.c new file mode 100644 -index 0000000..da272c50 +index 0000000..1ae7bc2 --- /dev/null +++ b/kernel/ipipe/tracer.c @@ -0,0 +1,1468 @@ @@ -11865,7 +11999,7 @@ index 0000000..da272c50 +#define IPIPE_TFLG_CURRDOM_SHIFT 10 /* bits 10..11: current domain */ +#define IPIPE_TFLG_CURRDOM_MASK 0x0C00 +#define IPIPE_TFLG_DOMSTATE_SHIFT 12 /* bits 12..15: domain stalled? */ -+#define IPIPE_TFLG_DOMSTATE_BITS 3 ++#define IPIPE_TFLG_DOMSTATE_BITS 1 + +#define IPIPE_TFLG_DOMAIN_STALLED(point, n) \ + (point->flags & (1 << (n + IPIPE_TFLG_DOMSTATE_SHIFT))) @@ -12008,7 +12142,7 @@ index 0000000..da272c50 + if (length > per_cpu(trace_path, cpu)[per_cpu(max_path, cpu)].length) { + /* we need protection here against other cpus trying + to start a proc dump */ -+ spin_lock(&global_path_lock); ++ raw_spin_lock(&global_path_lock); + + /* active path holds new worst case */ + tp->length = length; @@ -12017,7 +12151,7 @@ index 0000000..da272c50 + /* find next unused trace path */ + active = __ipipe_get_free_trace_path(active, cpu); + -+ spin_unlock(&global_path_lock); ++ raw_spin_unlock(&global_path_lock); + + tp = &per_cpu(trace_path, cpu)[active]; + @@ -12040,7 +12174,7 @@ index 0000000..da272c50 + + /* we need protection here against other cpus trying + * to set their frozen path or to start a proc dump */ -+ spin_lock(&global_path_lock); ++ raw_spin_lock(&global_path_lock); + + per_cpu(frozen_path, cpu) = active; + @@ -12054,7 +12188,7 @@ index 0000000..da272c50 + tp->end = -1; + } + -+ spin_unlock(&global_path_lock); ++ raw_spin_unlock(&global_path_lock); + + tp = &per_cpu(trace_path, cpu)[active]; + @@ -12209,7 +12343,7 @@ index 0000000..da272c50 + int cpu; + struct ipipe_trace_path *tp; + -+ spin_lock_irqsave(&global_path_lock, flags); ++ raw_spin_lock_irqsave(&global_path_lock, flags); + + cpu = ipipe_processor_id(); + restart: @@ -13138,7 +13272,7 @@ index 0000000..da272c50 + +static struct ftrace_ops ipipe_trace_ops = { + .func = ipipe_trace_function, -+ .flags = FTRACE_OPS_FL_RECURSION_SAFE, ++ .flags = FTRACE_OPS_FL_IPIPE_EXCLUSIVE, +}; + +static ssize_t __ipipe_wr_enable(struct file *file, const char __user *buffer, @@ -14025,7 +14159,7 @@ index 2329daa..79cfe9b 100644 if (pm_wakeup_pending()) { error = -EAGAIN; diff --git a/kernel/printk/printk.c b/kernel/printk/printk.c -index 3c1aca0..90b1189 100644 +index 3c1aca0..ae6b3d5 100644 --- a/kernel/printk/printk.c +++ b/kernel/printk/printk.c @@ -62,6 +62,9 @@ int console_printk[4] = { @@ -14141,7 +14275,7 @@ index 3c1aca0..90b1189 100644 + goto start; + + do { -+ spin_unlock_irqrestore(&__ipipe_printk_lock, flags); ++ raw_spin_unlock_irqrestore(&__ipipe_printk_lock, flags); + start: + lmax = __ipipe_printk_fill; + while (out < lmax) { @@ -14150,13 +14284,13 @@ index 3c1aca0..90b1189 100644 + p += len; + out += len; + } -+ spin_lock_irqsave(&__ipipe_printk_lock, flags); ++ raw_spin_lock_irqsave(&__ipipe_printk_lock, flags); + } + while (__ipipe_printk_fill != lmax); + + __ipipe_printk_fill = 0; + -+ spin_unlock_irqrestore(&__ipipe_printk_lock, flags); ++ raw_spin_unlock_irqrestore(&__ipipe_printk_lock, flags); +} + /** @@ -14194,7 +14328,7 @@ index 3c1aca0..90b1189 100644 + goto out; + } + -+ spin_lock_irqsave(&__ipipe_printk_lock, flags); ++ raw_spin_lock_irqsave(&__ipipe_printk_lock, flags); + + oldcount = __ipipe_printk_fill; + fbytes = __LOG_BUF_LEN - oldcount; @@ -14205,7 +14339,7 @@ index 3c1aca0..90b1189 100644 + } else + r = 0; + -+ spin_unlock_irqrestore(&__ipipe_printk_lock, flags); ++ raw_spin_unlock_irqrestore(&__ipipe_printk_lock, flags); + + if (oldcount == 0) + ipipe_raise_irq(__ipipe_printk_virq); @@ -14854,7 +14988,7 @@ index 3b9a48a..edd9470 100644 help This option will modify all the calls to function tracing diff --git a/kernel/trace/ftrace.c b/kernel/trace/ftrace.c -index eb11011..5fa6c0a 100644 +index eb11011..d0957bd 100644 --- a/kernel/trace/ftrace.c +++ b/kernel/trace/ftrace.c @@ -32,6 +32,7 @@ @@ -14865,7 +14999,33 @@ index eb11011..5fa6c0a 100644 #include <trace/events/sched.h> -@@ -2518,6 +2519,9 @@ void __weak arch_ftrace_update_code(int command) +@@ -262,8 +263,17 @@ static ftrace_func_t ftrace_ops_get_list_func(struct ftrace_ops *ops) + + static void update_ftrace_function(void) + { ++ struct ftrace_ops *ops; + ftrace_func_t func; + ++ for (ops = ftrace_ops_list; ++ ops != &ftrace_list_end; ops = ops->next) ++ if (ops->flags & FTRACE_OPS_FL_IPIPE_EXCLUSIVE) { ++ set_function_trace_op = ops; ++ func = ops->func; ++ goto set_pointers; ++ } ++ + /* + * Prepare the ftrace_ops that the arch callback will use. + * If there's only one ftrace_ops registered, the ftrace_ops_list +@@ -291,6 +301,7 @@ static void update_ftrace_function(void) + + update_function_graph_func(); + ++ set_pointers: + /* If there's no change, then do nothing more here */ + if (ftrace_trace_function == func) + return; +@@ -2518,6 +2529,9 @@ void __weak arch_ftrace_update_code(int command) static void ftrace_run_update_code(int command) { @@ -14875,7 +15035,7 @@ index eb11011..5fa6c0a 100644 int ret; ret = ftrace_arch_code_modify_prepare(); -@@ -2531,7 +2535,13 @@ static void ftrace_run_update_code(int command) +@@ -2531,7 +2545,13 @@ static void ftrace_run_update_code(int command) * is safe. The stop_machine() is the safest, but also * produces the most overhead. */ @@ -14889,7 +15049,7 @@ index eb11011..5fa6c0a 100644 ret = ftrace_arch_code_modify_post_process(); FTRACE_WARN_ON(ret); -@@ -4877,10 +4887,10 @@ static int ftrace_process_locs(struct module *mod, +@@ -4877,10 +4897,10 @@ static int ftrace_process_locs(struct module *mod, * reason to cause large interrupt latencies while we do it. */ if (!mod) @@ -14902,7 +15062,7 @@ index eb11011..5fa6c0a 100644 ret = 0; out: mutex_unlock(&ftrace_lock); -@@ -4979,9 +4989,11 @@ void __init ftrace_init(void) +@@ -4979,9 +4999,11 @@ void __init ftrace_init(void) unsigned long count, flags; int ret; @@ -14916,7 +15076,7 @@ index eb11011..5fa6c0a 100644 if (ret) goto failed; -@@ -5174,7 +5186,16 @@ __ftrace_ops_list_func(unsigned long ip, unsigned long parent_ip, +@@ -5174,7 +5196,16 @@ __ftrace_ops_list_func(unsigned long ip, unsigned long parent_ip, } } while_for_each_ftrace_op(op); out: @@ -15276,24 +15436,22 @@ index 86c8911..373a30b 100644 return err; } diff --git a/lib/smp_processor_id.c b/lib/smp_processor_id.c -index 1afec32..5803111 100644 +index 1afec32..f7c1a2a 100644 --- a/lib/smp_processor_id.c +++ b/lib/smp_processor_id.c -@@ -12,10 +12,13 @@ notrace static unsigned int check_preemption_disabled(const char *what1, +@@ -12,6 +12,12 @@ notrace static unsigned int check_preemption_disabled(const char *what1, { int this_cpu = raw_smp_processor_id(); ++ if (hard_irqs_disabled()) ++ goto out; ++ + if (!ipipe_root_p) + goto out; + if (likely(preempt_count())) goto out; -- if (irqs_disabled()) -+ if (irqs_disabled() || hard_irqs_disabled()) - goto out; - - /* diff --git a/mm/memory.c b/mm/memory.c index 2a9e098..46ec4cd 100644 --- a/mm/memory.c @@ -15501,7 +15659,7 @@ index 2a9e098..46ec4cd 100644 static struct kmem_cache *page_ptl_cachep; diff --git a/mm/mlock.c b/mm/mlock.c -index 3d3ee6c..ed47c08 100644 +index 3d3ee6ca..ed47c08 100644 --- a/mm/mlock.c +++ b/mm/mlock.c @@ -756,3 +756,28 @@ void user_shm_unlock(size_t size, struct user_struct *user) @@ -15636,3 +15794,16 @@ index 2faaa29..ef00f26 100644 return nr; } +diff --git a/sound/soc/intel/atom/sst/sst.c b/sound/soc/intel/atom/sst/sst.c +index 96c2e42..2e6e3cf 100644 +--- a/sound/soc/intel/atom/sst/sst.c ++++ b/sound/soc/intel/atom/sst/sst.c +@@ -369,7 +369,7 @@ static inline void sst_restore_shim64(struct intel_sst_drv *ctx, + */ + spin_lock_irqsave(&ctx->ipc_spin_lock, irq_flags); + sst_shim_write64(shim, SST_IMRX, shim_regs->imrx), +- sst_shim_write64(shim, SST_CSR, shim_regs->csr), ++ sst_shim_write64(shim, SST_CSR, shim_regs->csr); + spin_unlock_irqrestore(&ctx->ipc_spin_lock, irq_flags); + } + _______________________________________________ Xenomai-git mailing list Xenomai-git@xenomai.org https://xenomai.org/mailman/listinfo/xenomai-git