3.8.13-rt16-rc1 stable review
Steven Rostedt
maintainercover 3.8.13-rt16-rc1 stable review
Dear RT Folks,
This is the RT stable review cycle of patch 3.8.13-rt16-rc1.
Please scream at me if I messed something up. Please test the patches too.
The -rc release will be uploaded to kernel.org and will be deleted when the final release is out. This is just a review release (or release candidate).
The pre-releases will not be pushed to the git repository, only the final release is.
If all goes well, this patch will be converted to the next main release on 9/11/2013.
Enjoy,
-- Steve
To build 3.8.13-rt16-rc1 directly, the following patches should be applied:
http://www.kernel.org/pub/linux/kernel/v3.x/linux-3.8.tar.xz
http://www.kernel.org/pub/linux/kernel/v3.x/patch-3.8.13.xz
http://www.kernel.org/pub/linux/kernel/projects/rt/3.8/patch-3.8.13-rt16-rc1.patch.xz
You can also build from 3.8.13-rt15 by applying the incremental patch:
http://www.kernel.org/pub/linux/kernel/projects/rt/3.8/incr/patch-3.8.13-rt15-rt16-rc1.patch.xz
Changes from 3.8.13-rt15:
---
John Kacur (1):
hpsa: fix warning with smp_processor_id() in preemptible section
Sebastian Andrzej Siewior (2):
powerpc: 52xx: provide a default in mpc52xx_irqhost_map()
genirq: do not invoke the affinity callback via a workqueue
Steven Rostedt (4):
rt,ntp: Move call to schedule_delayed_work() to helper thread
hwlat-detector: Update hwlat_detector to add outer loop detection
hwlat-detector: Use trace_clock_local if available
hwlat-detector: Use thread instead of stop machine
Steven Rostedt (Red Hat) (2):
hwlat-detect/trace: Export trace_clock_local for hwlat-detector Linux 3.8.13-rt16-rc1
Thomas Gleixner (1):
sched: Distangle worker accounting from rqlock
----
arch/powerpc/platforms/52xx/mpc52xx_pic.c | 3 +- drivers/misc/hwlat_detector.c | 117 ++++++++++++++++++----------- drivers/scsi/hpsa.c | 2 +- include/linux/interrupt.h | 1 + kernel/irq/manage.c | 79 ++++++++++++++++++- kernel/sched/core.c | 70 ++++------------- kernel/time/ntp.c | 40 ++++++++++ kernel/trace/trace_clock.c | 1 + kernel/workqueue.c | 63 +++++++--------- kernel/workqueue_sched.h | 5 +- localversion-rt | 2 +- 11 files changed, 240 insertions(+), 143 deletions(-)
Steven Rostedt
maintainerPATCH 1/10 sched: Distangle worker accounting from rqlock
From: Thomas Gleixner <[email protected]>
The worker accounting for cpu bound workers is plugged into the core scheduler code and the wakeup code. This is not a hard requirement and can be avoided by keeping track of the state in the workqueue code itself.
Keep track of the sleeping state in the worker itself and call the notifier before entering the core scheduler. There might be false positives when the task is woken between that call and actually scheduling, but that's not really different from scheduling and being woken immediately after switching away. There is also no harm from updating nr_running when the task returns from scheduling instead of accounting it in the wakeup code.
--- kernel/sched/core.c | 70 ++++++++++------------------------------------ kernel/workqueue.c | 63 +++++++++++++++++++---------------------- kernel/workqueue_sched.h | 5 ++-- 3 files changed, 46 insertions(+), 92 deletions(-)
kernel/sched/core.c +15 -55
@@ -1321,10 +1321,6 @@ static void ttwu_activate(struct rq *rq, struct task_struct *p, int en_flags) {activate_task (rq, p, en_flags); p->on_rq =1 ; - -/* if a worker is waking up, notify workqueue */ -if (p->flags &PF_WQ_WORKER ) -wq_worker_waking_up (p,cpu_of (rq)); }/*
@@ -1551,42 +1547,6 @@ out: }/** -* try_to_wake_up_local - try to wake up a local task with rq lock held -* @p: the thread to be awakened -* -* Put @p on the run-queue if it's not already there. The caller must -* ensure that this_rq() is locked, @p is bound to this_rq() and not -* the current task. -*/ -static void try_to_wake_up_local (struct task_struct *p) -{ -struct rq *rq =task_rq (p); - -if (WARN_ON_ONCE (rq !=this_rq ()) || -WARN_ON_ONCE (p == current)) -return ; - -lockdep_assert_held (&rq->lock); - -if (!raw_spin_trylock (&p->pi_lock)) { -raw_spin_unlock (&rq->lock); -raw_spin_lock (&p->pi_lock); -raw_spin_lock (&rq->lock); - } - -if (!(p->state &TASK_NORMAL )) - goto out; - -if (!p->on_rq) -ttwu_activate (rq, p,ENQUEUE_WAKEUP ); - -ttwu_do_wakeup (rq, p,0 ); -ttwu_stat (p,smp_processor_id (),0 ); -out: -raw_spin_unlock (&p->pi_lock); -} - -/** * wake_up_process - Wake up a specific process * @p: The process to be woken up. *
@@ -3139,21 +3099,6 @@ need_resched: }else {deactivate_task (rq, prev,DEQUEUE_SLEEP ); prev->on_rq =0 ; - -/* -* If a worker went to sleep, notify and ask workqueue -* whether it wants to wake up a task to maintain -* concurrency. -* Only call wake up if prev isn't blocked on a sleeping -* spin lock. -*/ -if (prev->flags &PF_WQ_WORKER && !prev->saved_state) { -struct task_struct *to_wakeup; - - to_wakeup =wq_worker_sleeping (prev, cpu); -if (to_wakeup) -try_to_wake_up_local (to_wakeup); - } } switch_count = &prev->nvcsw; }
@@ -3197,6 +3142,14 @@ static inline void sched_submit_work(struct task_struct *tsk) {if (!tsk->state ||tsk_is_pi_blocked (tsk))return ; + +/* +* If a worker went to sleep, notify and ask workqueue whether +* it wants to wake up a task to maintain concurrency. +*/ +if (tsk->flags &PF_WQ_WORKER ) +wq_worker_sleeping (tsk); +/* * If we are going to sleep and we have plugged IO queued, * make sure to submit it to avoid deadlocks.
@@ -3205,12 +3158,19 @@ static inline void sched_submit_work(struct task_struct *tsk)blk_schedule_flush_plug (tsk); } +static inline void sched_update_worker (struct task_struct *tsk) +{ +if (tsk->flags &PF_WQ_WORKER ) +wq_worker_running (tsk); +} + asmlinkage void __sched schedule(void) {struct task_struct *tsk = current;sched_submit_work (tsk);__schedule (); +sched_update_worker (tsk); }EXPORT_SYMBOL (schedule);
kernel/workqueue.c +29 -34
98 lines not on this page · raw message
kernel/workqueue_sched.h +2 -3
@@ -4,6 +4,5 @@* Scheduler hooks for concurrency managed workqueue. Only to be * included from sched.c and workqueue.c. */ -void wq_worker_waking_up (struct task_struct *task,unsigned int cpu); -struct task_struct *wq_worker_sleeping (struct task_struct *task, -unsigned int cpu); +void wq_worker_running (struct task_struct *task); +void wq_worker_sleeping (struct task_struct *task);
Signature · 1 line
1.7.10.4
Steven Rostedt
maintainerPATCH 2/10 rt,ntp: Move call to schedule_delayed_work() to helper thread
In reply to Steven RostedtFrom: Steven Rostedt <[email protected]>
The ntp code for notify_cmos_timer() is called from a hard interrupt context. schedule_delayed_work() under PREEMPT_RT_FULL calls spinlocks that have been converted to mutexes, thus calling schedule_delayed_work() from interrupt is not safe.
Add a helper thread that does the call to schedule_delayed_work and wake up that thread instead of calling schedule_delayed_work() directly. This is only for CONFIG_PREEMPT_RT_FULL, otherwise the code still calls schedule_delayed_work() directly in irq context.
Note: There's a few places in the kernel that do this. Perhaps the RT code should have a dedicated thread that does the checks. Just register a notifier on boot up for your check and wake up the thread when needed. This will be a todo.
--- kernel/time/ntp.c | 40 ++++++++++++++++++++++++++++++++++++++++ 1 file changed, 40 insertions(+)
kernel/time/ntp.c +40 -0
@@ -10,6 +10,7 @@#include <linux/workqueue.h> #include <linux/hrtimer.h> #include <linux/jiffies.h> +#include <linux/kthread.h> #include <linux/math64.h> #include <linux/timex.h> #include <linux/time.h>
@@ -529,10 +530,49 @@ static void sync_cmos_clock(struct work_struct *work)schedule_delayed_work (&sync_cmos_work,timespec_to_jiffies (&next)); } +#ifdef CONFIG_PREEMPT_RT_FULL +/* +* RT can not call schedule_delayed_work from real interrupt context. +* Need to make a thread to do the real work. +*/ +static struct task_struct *cmos_delay_thread; +static bool do_cmos_delay; + +static int run_cmos_delay (void *ignore) +{ +while (!kthread_should_stop ()) { +set_current_state (TASK_INTERRUPTIBLE ); +if (do_cmos_delay) { + do_cmos_delay = false; +schedule_delayed_work (&sync_cmos_work,0 ); + } +schedule (); + } +__set_current_state (TASK_RUNNING ); +return 0 ; +} + +static void notify_cmos_timer (void ) +{ + do_cmos_delay = true; +/* Make visible before waking up process */ +smp_wmb (); +wake_up_process (cmos_delay_thread); +} + +static __init int create_cmos_delay_thread (void ) +{ + cmos_delay_thread =kthread_run (run_cmos_delay,NULL ,"kcmosdelayd" ); +BUG_ON (!cmos_delay_thread); +return 0 ; +} +early_initcall (create_cmos_delay_thread); +#else static void notify_cmos_timer (void ) {schedule_delayed_work (&sync_cmos_work,0 ); } +#endif /* CONFIG_PREEMPT_RT_FULL */ #else static inline void notify_cmos_timer (void ) { }
Signature · 1 line
1.7.10.4
Steven Rostedt
maintainerPATCH 3/10 hpsa: fix warning with smp_processor_id() in preemptible section
In reply to Steven RostedtFrom: John Kacur <[email protected]>
On a 3.6-rt (real-time patch) kernel we are seeing the following BUG However, it appears to be relevant for non-realtime (mainline) as well.
|hpsa 0000:03:00.0: hpsa0: <0x323a> at IRQ 67 using DAC |scsi0 : hpsa |BUG: using smp_processor_id() in preemptible [0000000000000000] code: kworker/u:0/6 |caller is enqueue_cmd_and_start_io+0x5a/0x100 [hpsa] |Pid: 6, comm: kworker/u:0 Not tainted 3.6.11.5-rt37.52.el6rt.x86_64.debug #1 |Call Trace: | [<ffffffff812abe83>] debug_smp_processor_id+0x123/0x150 | [<ffffffffa009043a>] enqueue_cmd_and_start_io+0x5a/0x100 [hpsa] | [<ffffffffa00905cb>] hpsa_scsi_do_simple_cmd_core+0xeb/0x110 [hpsa] | [<ffffffff812b09c8>] ? swiotlb_dma_mapping_error+0x18/0x30 | [<ffffffff812b09c8>] ? swiotlb_dma_mapping_error+0x18/0x30 | [<ffffffffa0090701>] hpsa_scsi_do_simple_cmd_with_retry+0x91/0x280 [hpsa] | [<ffffffffa0093558>] hpsa_scsi_do_report_luns.clone.2+0xd8/0x130 [hpsa] | [<ffffffffa00935ea>] hpsa_gather_lun_info.clone.3+0x3a/0x1a0 [hpsa] | [<ffffffffa00963df>] hpsa_update_scsi_devices+0x11f/0x4f0 [hpsa] | [<ffffffff81592019>] ? sub_preempt_count+0xa9/0xe0 | [<ffffffffa00968ad>] hpsa_scan_start+0xfd/0x150 [hpsa] | [<ffffffff8158cba8>] ? rt_spin_lock_slowunlock+0x78/0x90 | [<ffffffff813b04d7>] do_scsi_scan_host+0x37/0xa0 | [<ffffffff813b05da>] do_scan_async+0x1a/0x30 | [<ffffffff8107c4ab>] async_run_entry_fn+0x9b/0x1d0 | [<ffffffff8106ae92>] process_one_work+0x1f2/0x620 | [<ffffffff8106ae20>] ? process_one_work+0x180/0x620 | [<ffffffff8106d4fe>] ? worker_thread+0x5e/0x3a0 | [<ffffffff8107c410>] ? async_schedule+0x20/0x20 | [<ffffffff8106d5d3>] worker_thread+0x133/0x3a0 | [<ffffffff8106d4a0>] ? manage_workers+0x190/0x190 | [<ffffffff81073236>] kthread+0xa6/0xb0 | [<ffffffff815970a4>] kernel_thread_helper+0x4/0x10 | [<ffffffff81082a7c>] ? finish_task_switch+0x8c/0x110 | [<ffffffff8158e44b>] ? _raw_spin_unlock_irq+0x3b/0x70 | [<ffffffff8158e85d>] ? retint_restore_args+0xe/0xe | [<ffffffff81073190>] ? kthreadd+0x1e0/0x1e0 | [<ffffffff815970a0>] ? gs_change+0xb/0xb
-------------------
This is caused by
enqueue_cmd_and_start_io()->
set_performant_mode()->
smp_processor_id()Which if you have debugging enabled calls debug_processor_id() and triggers the warning.
The code here is
c->Header.ReplyQueue = smp_processor_id() % h->nreply_queues;
Since it is not critical that the code complete on the same processor, but the cpu is a hint used in generating the ReplyQueue and will still work if the cpu migrates or is preempted, it is safe to use the raw_smp_processor_id() to surpress the false positve warning.
--- drivers/scsi/hpsa.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)
drivers/scsi/hpsa.c +1 -1
@@ -583,7 +583,7 @@ static void set_performant_mode(struct ctlr_info *h, struct CommandList *c) c->busaddr |=1 | (h->blockFetchTable[c->Header.SGList] <<1 );if (likely (h->msix_vector)) c->Header.ReplyQueue = -smp_processor_id () % h->nreply_queues; +raw_smp_processor_id () % h->nreply_queues; } }
Signature · 1 line
1.7.10.4
Steven Rostedt
maintainerPATCH 4/10 powerpc: 52xx: provide a default in mpc52xx_irqhost_map()
In reply to Steven RostedtFrom: Sebastian Andrzej Siewior <[email protected]>
My gcc-4.3.5 fails to compile due to:
|cc1: warnings being treated as errors |arch/powerpc/platforms/52xx/mpc52xx_pic.c: In function ‘mpc52xx_irqhost_map’: |arch/powerpc/platforms/52xx/mpc52xx_pic.c:343: error: ‘irqchip’ may be used uninitialized in this function
since commit e34298c ("powerpc: 52xx: nop out unsupported critical IRQs"). This warning is complete crap since only values 0…3 are possible which are checked but gcc fails to understand that. I wouldn't care much but since this is compiled with -Werror I made this patch. While add it, I replaced the warning from l2irq to l1irq since this is the number that is evaluated.
--- arch/powerpc/platforms/52xx/mpc52xx_pic.c | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-)
arch/powerpc/platforms/52xx/mpc52xx_pic.c +2 -1
@@ -373,8 +373,9 @@ static int mpc52xx_irqhost_map(struct irq_domain *h, unsigned int virq,case MPC52xx_IRQ_L1_PERP: irqchip = &mpc52xx_periph_irqchip;break ;case MPC52xx_IRQ_L1_SDMA: irqchip = &mpc52xx_sdma_irqchip;break ;case MPC52xx_IRQ_L1_CRIT: +default :pr_warn ("%s: Critical IRQ #%d is unsupported! Nopping it.\n" , - __func__, l2irq); + __func__, l1irq);irq_set_chip (virq, &no_irq_chip);return 0 ; }
Signature · 1 line
1.7.10.4
Steven Rostedt
maintainerPATCH 5/10 hwlat-detector: Update hwlat_detector to add outer loop detection
In reply to Steven RostedtFrom: Steven Rostedt <[email protected]>
The hwlat_detector reads two timestamps in a row, then reports any gap between those calls. The problem is, it misses everything between the second reading of the time stamp to the first reading of the time stamp in the next loop. That's were most of the time is spent, which means, chances are likely that it will miss all hardware latencies. This defeats the purpose.
By also testing the first time stamp from the previous loop second time stamp (the outer loop), we are more likely to find a latency.
Setting the threshold to 1, here's what the report now looks like:
1347415723.0232202770 0 2
1347415725.0234202822 0 2
1347415727.0236202875 0 2
1347415729.0238202928 0 2
1347415731.0240202980 0 2
1347415734.0243203061 0 2
1347415736.0245203113 0 2
1347415738.0247203166 2 0
1347415740.0249203219 0 3
1347415742.0251203272 0 3
1347415743.0252203299 0 3
1347415745.0254203351 0 2
1347415747.0256203404 0 2
1347415749.0258203457 0 2
1347415751.0260203510 0 2
1347415754.0263203589 0 2
1347415756.0265203642 0 2
1347415758.0267203695 0 2
1347415760.0269203748 0 2
1347415762.0271203801 0 2
1347415764.0273203853 2 0
There's some hardware latency that takes 2 microseconds to run.
--- drivers/misc/hwlat_detector.c | 32 ++++++++++++++++++++++++++------ 1 file changed, 26 insertions(+), 6 deletions(-)
drivers/misc/hwlat_detector.c +26 -6
@@ -143,6 +143,7 @@ static void detector_exit(void);struct sample {u64 seqnum;/* unique sequence */ u64 duration;/* ktime delta */ +u64 outer_duration;/* ktime delta (outer loop) */ struct timespec timestamp;/* wall time */ unsigned long lost; };
@@ -219,11 +220,13 @@ static struct sample *buffer_get_sample(struct sample *sample)*/ static int get_sample (void *unused) { -ktime_t start, t1, t2; +ktime_t start, t1, t2, last_t2;s64 diff, total =0 ;u64 sample =0 ; +u64 outer_sample =0 ;int ret =1 ; + last_t2.tv64 =0 ; start =ktime_get ();/* start timestamp */ do {
@@ -231,7 +234,22 @@ static int get_sample(void *unused) t1 =ktime_get ();/* we'll look for a discontinuity */ t2 =ktime_get (); +if (last_t2.tv64) { +/* Check the delta from the outer loop (t2 to next t1) */ + diff =ktime_to_us (ktime_sub (t1, last_t2)); +/* This shouldn't happen */ +if (diff <0 ) { + printk(KERN_ERR BANNER "time running backwards\n"); + goto out; + } +if (diff > outer_sample) + outer_sample = diff; + } + last_t2 = t2; + total =ktime_to_us (ktime_sub (t2, start));/* sample width */ + +/* This checks the inner loop (t1 to t2) */ diff =ktime_to_us (ktime_sub (t2, t1));/* current diff */ /* This shouldn't happen */
@@ -246,12 +264,13 @@ static int get_sample(void *unused) }while (total <= data.sample_width);/* If we exceed the threshold value, we have found a hardware latency */ -if (sample > data.threshold) { +if (sample > data.threshold || outer_sample > data.threshold) {struct sample s; data.count++; s.seqnum = data.count; s.duration = sample; + s.outer_duration = outer_sample; s.timestamp =CURRENT_TIME ;__buffer_add_sample (&s);
@@ -738,10 +757,11 @@ static ssize_t debug_sample_fread(struct file *filp, char __user *ubuf, } } - len =snprintf (buf,sizeof (buf),"%010lu.%010lu\t%llu\n" , - sample->timestamp.tv_sec, - sample->timestamp.tv_nsec, - sample->duration); + len =snprintf (buf,sizeof (buf),"%010lu.%010lu\t%llu\t%llu\n" , + sample->timestamp.tv_sec, + sample->timestamp.tv_nsec, + sample->duration, + sample->outer_duration);/* handling partial reads is more trouble than it's worth */
Signature · 1 line
1.7.10.4
Steven Rostedt
maintainerPATCH 6/10 hwlat-detect/trace: Export trace_clock_local for hwlat-detector
In reply to Steven RostedtFrom: "Steven Rostedt (Red Hat)" <[email protected]>
The hwlat-detector needs a better clock than just ktime_get() as that can induce its own latencies. The trace clock is perfect for it, but it needs to be exported for use by modules.
--- kernel/trace/trace_clock.c | 1 + 1 file changed, 1 insertion(+)
kernel/trace/trace_clock.c +1 -0
@@ -44,6 +44,7 @@ u64 notrace trace_clock_local(void)return clock; } +EXPORT_SYMBOL_GPL (trace_clock_local);/* * trace_clock(): 'between' trace clock. Not completely serialized,
Signature · 1 line
1.7.10.4
Steven Rostedt
maintainerPATCH 7/10 hwlat-detector: Use trace_clock_local if available
In reply to Steven RostedtFrom: Steven Rostedt <[email protected]>
As ktime_get() calls into the timing code which does a read_seq(), it may be affected by other CPUS that touch that lock. To remove this dependency, use the trace_clock_local() which is already exported for module use. If CONFIG_TRACING is enabled, use that as the clock, otherwise use ktime_get().
--- drivers/misc/hwlat_detector.c | 34 +++++++++++++++++++++++++--------- 1 file changed, 25 insertions(+), 9 deletions(-)
drivers/misc/hwlat_detector.c +25 -9
@@ -51,6 +51,7 @@#include <linux/version.h> #include <linux/delay.h> #include <linux/slab.h> +#include <linux/trace_clock.h> #define BUF_SIZE_DEFAULT 262144UL/* 8K*(sizeof(entry)) */ #define BUF_FLAGS (RB_FL_OVERWRITE)/* no block on full */
@@ -211,6 +212,21 @@ static struct sample *buffer_get_sample(struct sample *sample)return sample; } +#ifndef CONFIG_TRACING +#define time_type ktime_t +#define time_get () ktime_get() +#define time_to_us (x) ktime_to_us(x) +#define time_sub (a, b) ktime_sub(a, b) +#define init_time (a, b) (a).tv64 = b +#define time_u64 (a) (a).tv64 +#else +#define time_type u64 +#define time_get () trace_clock_local() +#define time_to_us (x) div_u64(x, 1000) +#define time_sub (a, b) ((a) - (b)) +#define init_time (a, b) a = b +#define time_u64 (a) a +#endif /** * get_sample - sample the CPU TSC and look for likely hardware latencies * @unused: This is not used but is a part of the stop_machine API
@@ -220,23 +236,23 @@ static struct sample *buffer_get_sample(struct sample *sample)*/ static int get_sample (void *unused) { -ktime_t start, t1, t2, last_t2; +time_type start, t1, t2, last_t2;s64 diff, total =0 ;u64 sample =0 ;u64 outer_sample =0 ;int ret =1 ; - last_t2.tv64 =0 ; - start =ktime_get ();/* start timestamp */ +init_time (last_t2,0 ); + start =time_get ();/* start timestamp */ do { - t1 = ktime_get(); /* we'll look for a discontinuity */ - t2 = ktime_get(); + t1 = time_get(); /* we'll look for a discontinuity */ + t2 = time_get(); - if (last_t2.tv64) { + if (time_u64(last_t2)) { /* Check the delta from the outer loop (t2 to next t1) */ - diff = ktime_to_us(ktime_sub(t1, last_t2)); + diff = time_to_us(time_sub(t1, last_t2)); /* This shouldn't happen */ if (diff < 0) { printk(KERN_ERR BANNER "time running backwards\n");
@@ -247,10 +263,10 @@ static int get_sample(void *unused) } last_t2 = t2; - total =ktime_to_us (ktime_sub (t2, start));/* sample width */ + total =time_to_us (time_sub (t2, start));/* sample width */ /* This checks the inner loop (t1 to t2) */ - diff =ktime_to_us (ktime_sub (t2, t1));/* current diff */ + diff =time_to_us (time_sub (t2, t1));/* current diff */ /* This shouldn't happen */ if (diff <0 ) {
Signature · 1 line
1.7.10.4
Steven Rostedt
maintainerPATCH 8/10 hwlat-detector: Use thread instead of stop machine
In reply to Steven RostedtFrom: Steven Rostedt <[email protected]>
There's no reason to use stop machine to search for hardware latency. Simply disabling interrupts while running the loop will do enough to check if something comes in that wasn't disabled by interrupts being off, which is exactly what stop machine does.
Instead of using stop machine, just have the thread disable interrupts while it checks for hardware latency.
--- drivers/misc/hwlat_detector.c | 59 +++++++++++++++++------------------------ 1 file changed, 25 insertions(+), 34 deletions(-)
drivers/misc/hwlat_detector.c +25 -34
@@ -41,7 +41,6 @@#include <linux/module.h> #include <linux/init.h> #include <linux/ring_buffer.h> -#include <linux/stop_machine.h> #include <linux/time.h> #include <linux/hrtimer.h> #include <linux/kthread.h>
@@ -107,7 +106,6 @@ struct data; /* Global state *//* Sampling functions */ static int __buffer_add_sample (struct sample *sample);static struct sample *buffer_get_sample (struct sample *sample); -static int get_sample (void *unused);/* Threading and state */ static int kthread_fn (void *unused);
@@ -149,7 +147,7 @@ struct sample {unsigned long lost; }; -/* keep the global state somewhere. Mostly used under stop_machine. */ +/* keep the global state somewhere. */ static struct data { struct mutex lock; /* protect changes */
@@ -172,7 +170,7 @@ static struct data {* @sample: The new latency sample value * * This receives a new latency sample and records it in a global ring buffer. -* No additional locking is used in this case - suited for stop_machine use. +* No additional locking is used in this case. */ static int __buffer_add_sample (struct sample *sample) {
@@ -229,18 +227,17 @@ static struct sample *buffer_get_sample(struct sample *sample)#endif /** * get_sample - sample the CPU TSC and look for likely hardware latencies -* @unused: This is not used but is a part of the stop_machine API * * Used to repeatedly capture the CPU TSC (or similar), looking for potential -* hardware-induced latency. Called under stop_machine, with data.lock held. +* hardware-induced latency. Called with interrupts disabled and with data.lock held. */ -static int get_sample (void *unused) +static int get_sample (void ) {time_type start, t1, t2, last_t2;s64 diff, total =0 ;u64 sample =0 ;u64 outer_sample =0 ; -int ret =1 ; +int ret =-1 ;init_time (last_t2,0 ); start =time_get ();/* start timestamp */
@@ -279,10 +276,14 @@ static int get_sample(void *unused) }while (total <= data.sample_width); + ret =0 ; +/* If we exceed the threshold value, we have found a hardware latency */ if (sample > data.threshold || outer_sample > data.threshold) {struct sample s; + ret =1 ; + data.count++; s.seqnum = data.count; s.duration = sample;
@@ -295,7 +296,6 @@ static int get_sample(void *unused) data.max_sample = sample; } - ret =0 ; out:return ret; }
@@ -305,32 +305,30 @@ out:* @unused: A required part of the kthread API. * * Used to periodically sample the CPU TSC via a call to get_sample. We -* use stop_machine, whith does (intentionally) introduce latency since we +* disable interrupts, which does (intentionally) introduce latency since we * need to ensure nothing else might be running (and thus pre-empting). * Obviously this should never be used in production environments. * -* stop_machine will schedule us typically only on CPU0 which is fine for -* almost every real-world hardware latency situation - but we might later -* generalize this if we find there are any actualy systems with alternate -* SMI delivery or other non CPU0 hardware latencies. +* Currently this runs on which ever CPU it was scheduled on, but most +* real-worald hardware latency situations occur across several CPUs, +* but we might later generalize this if we find there are any actualy +* systems with alternate SMI delivery or other hardware latencies. */ static int kthread_fn (void *unused) { -int err =0 ; -u64 interval =0 ; +int ret; +u64 interval;while (!kthread_should_stop ()) {mutex_lock (&data.lock); - err =stop_machine (get_sample, unused,0 ); -if (err) { -/* Houston, we have a problem */ -mutex_unlock (&data.lock); - goto err_out; - } +local_irq_disable (); + ret =get_sample (); +local_irq_enable (); -wake_up (&data.wq);/* wake up reader(s) */ +if (ret >0 ) +wake_up (&data.wq);/* wake up reader(s) */ interval = data.sample_window - data.sample_width;do_div (interval,USEC_PER_MSEC );/* modifies interval value */
@@ -338,15 +336,10 @@ static int kthread_fn(void *unused)mutex_unlock (&data.lock);if (msleep_interruptible (interval)) - goto out; +break ; } - goto out; -err_out: - printk(KERN_ERR BANNER "could not call stop_machine, disabling\n"); - enabled =0 ; -out: -return err; +return 0 ; }/**
@@ -442,8 +435,7 @@ out:* This function provides a generic read implementation for the global state * "data" structure debugfs filesystem entries. It would be nice to use * simple_attr_read directly, but we need to make sure that the data.lock -* spinlock is held during the actual read (even though we likely won't ever -* actually race here as the updater runs under a stop_machine context). +* is held during the actual read. */ static ssize_t simple_data_read (struct file *filp,char __user *ubuf,size_t cnt,loff_t *ppos,const u64 *entry)
@@ -478,8 +470,7 @@ static ssize_t simple_data_read(struct file *filp, char __user *ubuf,* This function provides a generic write implementation for the global state * "data" structure debugfs filesystem entries. It would be nice to use * simple_attr_write directly, but we need to make sure that the data.lock -* spinlock is held during the actual write (even though we likely won't ever -* actually race here as the updater runs under a stop_machine context). +* is held during the actual write. */ static ssize_t simple_data_write (struct file *filp,const char __user *ubuf,size_t cnt,loff_t *ppos,u64 *entry)
Signature · 1 line
1.7.10.4
Steven Rostedt
maintainerPATCH 9/10 genirq: do not invoke the affinity callback via a workqueue
In reply to Steven RostedtFrom: Sebastian Andrzej Siewior <[email protected]>
Joe Korty reported, that __irq_set_affinity_locked() schedules a workqueue while holding a rawlock which results in a might_sleep() warning.
This patch moves the invokation into a process context so that we only wakeup() a process while holding the lock.
--- include/linux/interrupt.h | 1 + kernel/irq/manage.c | 79 +++++++++++++++++++++++++++++++++++++++++++-- 2 files changed, 77 insertions(+), 3 deletions(-)
include/linux/interrupt.h +1 -0
@@ -263,6 +263,7 @@ struct irq_affinity_notify {unsigned int irq;struct kref kref;struct work_struct work; +struct list_head list;void (*notify)(struct irq_affinity_notify *,const cpumask_t *mask);void (*release)(struct kref *ref); };
kernel/irq/manage.c +76 -3
111 lines not on this page · raw message
Signature · 1 line
1.7.10.4
Steven Rostedt
maintainerPATCH 10/10 Linux 3.8.13-rt16-rc1
In reply to Steven RostedtFrom: "Steven Rostedt (Red Hat)" <[email protected]>
--- localversion-rt | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)
localversion-rt +1 -1
@@ -1 +1 @@ --rt15 +-rt16-rc1
Signature · 1 line
1.7.10.4