psi: pressure stall monitors v5
Subsystems (5)
Suren Baghdasaryan
maintainerv5 cover psi: pressure stall monitors v5
This is respin of:
https://lwn.net/ml/linux-kernel/20190206023446.177362-1-surenb%40google.com/
Android is adopting psi to detect and remedy memory pressure that results in stuttering and decreased responsiveness on mobile devices.
Psi gives us the stall information, but because we're dealing with latencies in the millisecond range, periodically reading the pressure files to detect stalls in a timely fashion is not feasible. Psi also doesn't aggregate its averages at a high-enough frequency right now.
This patch series extends the psi interface such that users can configure sensitive latency thresholds and use poll() and friends to be notified when these are breached.
As high-frequency aggregation is costly, it implements an aggregation method that is optimized for fast, short-interval averaging, and makes the aggregation frequency adaptive, such that high-frequency updates only happen while monitored stall events are actively occurring.
With these patches applied, Android can monitor for, and ward off, mounting memory shortages before they cause problems for the user. For example, using memory stall monitors in userspace low memory killer daemon (lmkd) we can detect mounting pressure and kill less important processes before device becomes visibly sluggish. In our memory stress testing psi memory monitors produce roughly 10x less false positives compared to vmpressure signals. Having ability to specify multiple triggers for the same psi metric allows other parts of Android framework to monitor memory state of the device and act accordingly.
The new interface is straight-forward. The user opens one of the pressure files for writing and writes a trigger description into the file descriptor that defines the stall state - some or full, and the maximum stall time over a given window of time. E.g.:
/* Signal when stall time exceeds 100ms of a 1s window */
char trigger[] = "full 100000 1000000"
fd = open("/proc/pressure/memory")
write(fd, trigger, sizeof(trigger))
while (poll() >= 0) {
...
};
close(fd);When the monitored stall state is entered, psi adapts its aggregation frequency according to what the configured time window requires in order to emit event signals in a timely fashion. Once the stalling subsides, aggregation reverts back to normal.
The trigger is associated with the open file descriptor. To stop monitoring, the user only needs to close the file descriptor and the trigger is discarded.
Patches 1-6 prepare the psi code for polling support. Patch 7 implements the adaptive polling logic, the pressure growth detection optimized for short intervals, and hooks up write() and poll() on the pressure files.
The patches were developed in collaboration with Johannes Weiner.
The patches are based on 5.0-rc8 (Merge tag 'drm-next-2019-03-06').
Suren Baghdasaryan (7):
psi: introduce state_mask to represent stalled psi states
psi: make psi_enable static
psi: rename psi fields in preparation for psi trigger addition
psi: split update_stats into parts
psi: track changed states
refactor header includes to allow kthread.h inclusion in psi_types.h
psi: introduce psi monitor
Documentation/accounting/psi.txt | 107 ++++++ include/linux/kthread.h | 3 +- include/linux/psi.h | 8 + include/linux/psi_types.h | 105 +++++- include/linux/sched.h | 1 - kernel/cgroup/cgroup.c | 71 +++- kernel/kthread.c | 1 + kernel/sched/psi.c | 613 ++++++++++++++++++++++++++++--- 8 files changed, 833 insertions(+), 76 deletions(-)
Changes in v5:
- Fixed sparse: error: incompatible types in comparison expression, as per Andrew
- Changed psi_enable to static, as per Andrew
- Refactored headers to be able to include kthread.h into psi_types.h without creating a circular inclusion, as per Johannes
- Split psi monitor from aggregator, used RT worker for psi monitoring to prevent it being starved by other RT threads and memory pressure events being delayed or lost, as per Minchan and Android Performance Team
- Fixed blockable memory allocation under rcu_read_lock inside psi_trigger_poll by using refcounting, as per Eva Huang and Minchan
- Misc cleanup and improvements, as per Johannes
Notes:
0001-psi-introduce-state_mask-to-represent-stalled-psi-st.patch is unchanged from the previous version and provided for completeness.
Signature · 1 line
2.21.0.360.g471c308f928-goog
Suren Baghdasaryan
maintainerPATCH v5 1/7 psi: introduce state_mask to represent stalled psi states
The psi monitoring patches will need to determine the same states as record_times(). To avoid calculating them twice, maintain a state mask that can be consulted cheaply. Do this in a separate patch to keep the churn in the main feature patch at a minimum.
This adds 4-byte state_mask member into psi_group_cpu struct which results in its first cacheline-aligned part becoming 52 bytes long. Add explicit values to enumeration element counters that affect psi_group_cpu struct size.
--- include/linux/psi_types.h | 9 ++++++--- kernel/sched/psi.c | 29 +++++++++++++++++++---------- 2 files changed, 25 insertions(+), 13 deletions(-)
include/linux/psi_types.h +6 -3
@@ -11,7 +11,7 @@ enum psi_task_count {NR_IOWAIT ,NR_MEMSTALL ,NR_RUNNING , - NR_PSI_TASK_COUNTS, + NR_PSI_TASK_COUNTS = 3, };/* Task state bitmasks */
@@ -24,7 +24,7 @@ enum psi_res {PSI_IO ,PSI_MEM ,PSI_CPU , - NR_PSI_RESOURCES, + NR_PSI_RESOURCES = 3, };/*
@@ -41,7 +41,7 @@ enum psi_states {PSI_CPU_SOME ,/* Only per-CPU, to weigh the CPU in the global average: */ PSI_NONIDLE , - NR_PSI_STATES, + NR_PSI_STATES = 6, }; struct psi_group_cpu {
@@ -53,6 +53,9 @@ struct psi_group_cpu {/* States of the tasks belonging to this group */ unsigned int tasks[NR_PSI_TASK_COUNTS ]; +/* Aggregate pressure state derived from the tasks */ +u32 state_mask; +/* Period time sampling buckets for each state of interest (ns) */ u32 times[NR_PSI_STATES ];
kernel/sched/psi.c +19 -10
@@ -213,17 +213,17 @@ static bool test_state(unsigned int *tasks, enum psi_states state)static void get_recent_times (struct psi_group *group,int cpu,u32 *times) {struct psi_group_cpu *groupc =per_cpu_ptr (group->pcpu, cpu); -unsigned int tasks[NR_PSI_TASK_COUNTS ];u64 now, state_start; +enum psi_states s;unsigned int seq; -int s; +u32 state_mask;/* Snapshot a coherent view of the CPU state */ do { seq =read_seqcount_begin (&groupc->seq); now =cpu_clock (cpu);memcpy (times, groupc->times,sizeof (groupc->times)); -memcpy (tasks, groupc->tasks,sizeof (groupc->tasks)); + state_mask = groupc->state_mask; state_start = groupc->state_start; }while (read_seqcount_retry (&groupc->seq, seq));
@@ -239,7 +239,7 @@ static void get_recent_times(struct psi_group *group, int cpu, u32 *times)* (u32) and our reported pressure close to what's * actually happening. */ -if (test_state (tasks, s)) +if (state_mask & (1 << s)) times[s] += now - state_start; delta = times[s] - groupc->times_prev[s];
@@ -407,15 +407,15 @@ static void record_times(struct psi_group_cpu *groupc, int cpu, delta = now - groupc->state_start; groupc->state_start = now; -if (test_state (groupc->tasks,PSI_IO_SOME )) { +if (groupc->state_mask & (1 <<PSI_IO_SOME )) { groupc->times[PSI_IO_SOME ] += delta; -if (test_state (groupc->tasks,PSI_IO_FULL )) +if (groupc->state_mask & (1 <<PSI_IO_FULL )) groupc->times[PSI_IO_FULL ] += delta; } -if (test_state (groupc->tasks,PSI_MEM_SOME )) { +if (groupc->state_mask & (1 <<PSI_MEM_SOME )) { groupc->times[PSI_MEM_SOME ] += delta; -if (test_state (groupc->tasks,PSI_MEM_FULL )) +if (groupc->state_mask & (1 <<PSI_MEM_FULL )) groupc->times[PSI_MEM_FULL ] += delta;else if (memstall_tick) {u32 sample;
@@ -436,10 +436,10 @@ static void record_times(struct psi_group_cpu *groupc, int cpu, } } -if (test_state (groupc->tasks,PSI_CPU_SOME )) +if (groupc->state_mask & (1 <<PSI_CPU_SOME )) groupc->times[PSI_CPU_SOME ] += delta; -if (test_state (groupc->tasks,PSI_NONIDLE )) +if (groupc->state_mask & (1 <<PSI_NONIDLE )) groupc->times[PSI_NONIDLE ] += delta; }
@@ -448,6 +448,8 @@ static void psi_group_change(struct psi_group *group, int cpu, {struct psi_group_cpu *groupc;unsigned int t, m; +enum psi_states s; +u32 state_mask =0 ; groupc =per_cpu_ptr (group->pcpu, cpu);
@@ -480,6 +482,13 @@ static void psi_group_change(struct psi_group *group, int cpu,if (set & (1 << t)) groupc->tasks[t]++; +/* Calculate state mask representing active states */ +for (s =0 ; s <NR_PSI_STATES ; s++) { +if (test_state (groupc->tasks, s)) + state_mask |= (1 << s); + } + groupc->state_mask = state_mask; +write_seqcount_end (&groupc->seq); }
Signature · 1 line
2.21.0.360.g471c308f928-goog
Suren Baghdasaryan
maintainerPATCH v5 2/7 psi: make psi_enable static
In reply to Suren Baghdasaryanpsi_enable is not used outside of psi.c, make it static.
--- kernel/sched/psi.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-)
kernel/sched/psi.c +2 -2
@@ -140,9 +140,9 @@ static int psi_bug __read_mostly;DEFINE_STATIC_KEY_FALSE (psi_disabled);#ifdef CONFIG_PSI_DEFAULT_DISABLED -bool psi_enable; +static bool psi_enable;#else -bool psi_enable = true; +static bool psi_enable = true;#endif static int __init setup_psi (char *str) {
Signature · 1 line
2.21.0.360.g471c308f928-goog
Suren Baghdasaryan
maintainerPATCH v5 3/7 psi: rename psi fields in preparation for psi trigger addition
In reply to Suren BaghdasaryanRenaming psi_group structure member fields used for calculating psi totals and averages for clear distinction between them and trigger-related fields that will be added next.
--- include/linux/psi_types.h | 14 ++++++------- kernel/sched/psi.c | 41 ++++++++++++++++++++------------------- 2 files changed, 28 insertions(+), 27 deletions(-)
include/linux/psi_types.h +7 -7
@@ -69,17 +69,17 @@ struct psi_group_cpu { };struct psi_group { -/* Protects data updated during an aggregation */ -struct mutex stat_lock; +/* Protects data used by the aggregator */ +struct mutex avgs_lock;/* Per-cpu task state & time tracking */ struct psi_group_cpu __percpu *pcpu; -/* Periodic aggregation state */ -u64 total_prev[NR_PSI_STATES -1 ]; -u64 last_update; -u64 next_update; -struct delayed_work clock_work; +/* Running pressure averages */ +u64 avg_total[NR_PSI_STATES -1 ]; +u64 avg_last_update; +u64 avg_next_update; +struct delayed_work avgs_work;/* Total stall times and sampled pressure averages */ u64 total[NR_PSI_STATES -1 ];
kernel/sched/psi.c +21 -20
115 lines not on this page · raw message
Signature · 1 line
2.21.0.360.g471c308f928-goog
Suren Baghdasaryan
maintainerPATCH v5 4/7 psi: split update_stats into parts
In reply to Suren BaghdasaryanSplit update_stats into collect_percpu_times and update_averages for collect_percpu_times to be reused later inside psi monitor.
--- kernel/sched/psi.c | 55 +++++++++++++++++++++++++++------------------- 1 file changed, 32 insertions(+), 23 deletions(-)
kernel/sched/psi.c +32 -23
@@ -269,17 +269,13 @@ static void calc_avgs(unsigned long avg[3], int missed_periods, avg[2 ] =calc_load (avg[2 ], EXP_300s, pct); } -static bool update_stats (struct psi_group *group) +static bool collect_percpu_times (struct psi_group *group) {u64 deltas[NR_PSI_STATES -1 ] = {0 , }; -unsigned long missed_periods =0 ;unsigned long nonidle_total =0 ; -u64 now, expires, period;int cpu;int s; -mutex_lock (&group->avgs_lock); -/* * Collect the per-cpu time buckets and average them into a * single time sample that is normalized to wallclock time.
@@ -317,11 +313,18 @@ static bool update_stats(struct psi_group *group)for (s =0 ; s <NR_PSI_STATES -1 ; s++) group->total[s] +=div_u64 (deltas[s],max (nonidle_total,1UL )); +return nonidle_total; +} + +static u64 update_averages (struct psi_group *group,u64 now) +{ +unsigned long missed_periods =0 ; +u64 expires, period; +u64 avg_next_update; +int s; +/* avgX= */ - now =sched_clock (); expires = group->avg_next_update; -if (now < expires) - goto out;if (now - expires >= psi_period) missed_periods =div_u64 (now - expires, psi_period);
@@ -332,7 +335,7 @@ static bool update_stats(struct psi_group *group)* But the deltas we sample out of the per-cpu buckets above * are based on the actual time elapsing between clock ticks. */ - group->avg_next_update = expires + ((1 + missed_periods) * psi_period); + avg_next_update = expires + ((1 + missed_periods) * psi_period); period = now - (group->avg_last_update + (missed_periods * psi_period)); group->avg_last_update = now;
@@ -362,9 +365,8 @@ static bool update_stats(struct psi_group *group) group->avg_total[s] += sample;calc_avgs (group->avg[s], missed_periods, sample, period); } -out: -mutex_unlock (&group->avgs_lock); -return nonidle_total; + +return avg_next_update; }static void psi_avgs_work (struct work_struct *work)
@@ -372,10 +374,16 @@ static void psi_avgs_work(struct work_struct *work)struct delayed_work *dwork;struct psi_group *group;bool nonidle; +u64 now; dwork =to_delayed_work (work); group = container_of(dwork, struct psi_group, avgs_work); +mutex_lock (&group->avgs_lock); + + now =sched_clock (); + + nonidle =collect_percpu_times (group);/* * If there is task activity, periodically fold the per-cpu * times and feed samples into the running averages. If things
@@ -384,18 +392,15 @@ static void psi_avgs_work(struct work_struct *work)* go - see calc_avgs() and missed_periods. */ - nonidle =update_stats (group); -if (nonidle) { -unsigned long delay =0 ; -u64 now; - - now =sched_clock (); -if (group->avg_next_update > now) - delay =nsecs_to_jiffies ( - group->avg_next_update - now) +1 ; -schedule_delayed_work (dwork, delay); +if (now >= group->avg_next_update) + group->avg_next_update =update_averages (group, now); + +schedule_delayed_work (dwork,nsecs_to_jiffies ( + group->avg_next_update - now) +1 ); } + +mutex_unlock (&group->avgs_lock); } static void record_times(struct psi_group_cpu *groupc, int cpu,
@@ -711,7 +716,11 @@ int psi_show(struct seq_file *m, struct psi_group *group, enum psi_res res)if (static_branch_likely (&psi_disabled))return -EOPNOTSUPP ; -update_stats (group); +/* Update averages before reporting them */ +mutex_lock (&group->avgs_lock); +collect_percpu_times (group); +update_averages (group,sched_clock ()); +mutex_unlock (&group->avgs_lock);for (full =0 ; full <2 - (res ==PSI_CPU ); full++) {unsigned long avg[3 ];
Signature · 1 line
2.21.0.360.g471c308f928-goog
Suren Baghdasaryan
maintainerPATCH v5 5/7 psi: track changed states
In reply to Suren BaghdasaryanIntroduce changed_states parameter into collect_percpu_times to track the states changed since the last update.
--- kernel/sched/psi.c | 24 ++++++++++++++++++------ 1 file changed, 18 insertions(+), 6 deletions(-)
kernel/sched/psi.c +18 -6
@@ -210,7 +210,8 @@ static bool test_state(unsigned int *tasks, enum psi_states state) } } -static void get_recent_times (struct psi_group *group,int cpu,u32 *times) +static void get_recent_times (struct psi_group *group,int cpu,u32 *times, +u32 *pchanged_states) {struct psi_group_cpu *groupc =per_cpu_ptr (group->pcpu, cpu);u64 now, state_start;
@@ -218,6 +219,8 @@ static void get_recent_times(struct psi_group *group, int cpu, u32 *times)unsigned int seq;u32 state_mask; + *pchanged_states =0 ; +/* Snapshot a coherent view of the CPU state */ do { seq = read_seqcount_begin(&groupc->seq);
@@ -246,6 +249,8 @@ static void get_recent_times(struct psi_group *group, int cpu, u32 *times) groupc->times_prev[s] = times[s]; times[s] = delta; +if (delta) + *pchanged_states |= (1 << s); } }
@@ -269,10 +274,11 @@ static void calc_avgs(unsigned long avg[3], int missed_periods, avg[2 ] =calc_load (avg[2 ], EXP_300s, pct); } -static bool collect_percpu_times (struct psi_group *group) +static void collect_percpu_times (struct psi_group *group,u32 *pchanged_states) {u64 deltas[NR_PSI_STATES -1 ] = {0 , };unsigned long nonidle_total =0 ; +u32 changed_states =0 ;int cpu;int s;
@@ -287,8 +293,11 @@ static bool collect_percpu_times(struct psi_group *group)for_each_possible_cpu (cpu) {u32 times[NR_PSI_STATES ];u32 nonidle; +u32 cpu_changed_states; -get_recent_times (group, cpu, times); +get_recent_times (group, cpu, times, + &cpu_changed_states); + changed_states |= cpu_changed_states; nonidle =nsecs_to_jiffies (times[PSI_NONIDLE ]); nonidle_total += nonidle;
@@ -313,7 +322,8 @@ static bool collect_percpu_times(struct psi_group *group)for (s =0 ; s <NR_PSI_STATES -1 ; s++) group->total[s] +=div_u64 (deltas[s],max (nonidle_total,1UL )); -return nonidle_total; +if (pchanged_states) + *pchanged_states = changed_states; }static u64 update_averages (struct psi_group *group,u64 now)
@@ -373,6 +383,7 @@ static void psi_avgs_work(struct work_struct *work) {struct delayed_work *dwork;struct psi_group *group; +u32 changed_states;bool nonidle;u64 now;
@@ -383,7 +394,8 @@ static void psi_avgs_work(struct work_struct *work) now =sched_clock (); - nonidle =collect_percpu_times (group); +collect_percpu_times (group, &changed_states); + nonidle = changed_states & (1 <<PSI_NONIDLE );/* * If there is task activity, periodically fold the per-cpu * times and feed samples into the running averages. If things
@@ -718,7 +730,7 @@ int psi_show(struct seq_file *m, struct psi_group *group, enum psi_res res)/* Update averages before reporting them */ mutex_lock (&group->avgs_lock); -collect_percpu_times (group); +collect_percpu_times (group,NULL );update_averages (group,sched_clock ());mutex_unlock (&group->avgs_lock);
Signature · 1 line
2.21.0.360.g471c308f928-goog
Suren Baghdasaryan
maintainerPATCH v5 6/7 refactor header includes to allow kthread.h inclusion in psi_types.h
In reply to Suren Baghdasaryankthread.h can't be included in psi_types.h because it creates a circular inclusion with kthread.h eventually including psi_types.h and complaining on kthread structures not being defined because they are defined further in the kthread.h. Resolve this by removing psi_types.h inclusion from the headers included from kthread.h.
--- include/linux/kthread.h | 3 ++- include/linux/sched.h | 1 - kernel/kthread.c | 1 + 3 files changed, 3 insertions(+), 2 deletions(-)
include/linux/kthread.h +2 -1
@@ -4,7 +4,6 @@/* Simple interface for creating and stopping kernel threads without mess. */ #include <linux/err.h> #include <linux/sched.h> -#include <linux/cgroup.h> __printf(4, 5) struct task_struct *kthread_create_on_node(int (*threadfn)(void *data),
@@ -198,6 +197,8 @@ bool kthread_cancel_delayed_work_sync(struct kthread_delayed_work *work);void kthread_destroy_worker (struct kthread_worker *worker); +struct cgroup_subsys_state ; +#ifdef CONFIG_BLK_CGROUP void kthread_associate_blkcg (struct cgroup_subsys_state *css);struct cgroup_subsys_state *kthread_blkcg (void );
include/linux/sched.h +0 -1
@@ -26,7 +26,6 @@#include <linux/latencytop.h> #include <linux/sched/prio.h> #include <linux/signal_types.h> -#include <linux/psi_types.h> #include <linux/mm_types_task.h> #include <linux/task_io_accounting.h> #include <linux/rseq.h>
kernel/kthread.c +1 -0
@@ -11,6 +11,7 @@#include <linux/kthread.h> #include <linux/completion.h> #include <linux/err.h> +#include <linux/cgroup.h> #include <linux/cpuset.h> #include <linux/unistd.h> #include <linux/file.h>
Signature · 1 line
2.21.0.360.g471c308f928-goog
kbuild test robot
build botRe: [PATCH v5 6/7] refactor header includes to allow kthread.h inclusion in psi_types.h
Thank you for the patch! Yet something to improve:
Hi Suren,
Thank you for the patch! Yet something to improve:
[auto build test ERROR on linus/master]
[also build test ERROR on v5.0]
[cannot apply to next-20190306]
[if your patch is applied to the wrong git tree, please drop us a note to help improve the system]
url: https://github.com/0day-ci/linux/commits/Suren-Baghdasaryan/psi-pressure-stall-monitors-v5/20190310-024018
config: ia64-allmodconfig (attached as .config)
compiler: ia64-linux-gcc (GCC) 8.2.0
reproduce:
wget https://raw.githubusercontent.com/intel/lkp-tests/master/sbin/make.cross -O ~/bin/make.cross chmod +x ~/bin/make.cross
# save the attached .config to linux build tree
GCC_VERSION=8.2.0 make.cross ARCH=ia64
All errors (new ones prefixed by >>):
drivers/spi/spi-rockchip.c: In function 'rockchip_spi_probe':
>> drivers/spi/spi-rockchip.c:649:8: error: implicit declaration of function 'devm_request_threaded_irq'; did you mean 'devm_request_region'? [-Werror=implicit-function-declaration]
ret = devm_request_threaded_irq(&pdev->dev, ret, rockchip_spi_isr, NULL,
^~~~~~~~~~~~~~~~~~~~~~~~~
devm_request_region
>> drivers/spi/spi-rockchip.c:650:4: error: 'IRQF_ONESHOT' undeclared (first use in this function); did you mean 'SA_ONESHOT'?
IRQF_ONESHOT, dev_name(&pdev->dev), master);
^~~~~~~~~~~~
SA_ONESHOT drivers/spi/spi-rockchip.c:650:4: note: each undeclared identifier is reported only once for each function it appears in
cc1: some warnings being treated as errors
vim +649 drivers/spi/spi-rockchip.c
64e36824b addy ke 2014-07-01 592
64e36824b addy ke 2014-07-01 593 static int rockchip_spi_probe(struct platform_device *pdev)
64e36824b addy ke 2014-07-01 594 {
43de979dd Jeffy Chen 2017-08-07 595 int ret;
64e36824b addy ke 2014-07-01 596 struct rockchip_spi *rs;
64e36824b addy ke 2014-07-01 597 struct spi_master *master;
64e36824b addy ke 2014-07-01 598 struct resource *mem;
76b17e6e4 Julius Werner 2015-03-26 599 u32 rsd_nsecs;
64e36824b addy ke 2014-07-01 600
64e36824b addy ke 2014-07-01 601 master = spi_alloc_master(&pdev->dev, sizeof(struct rockchip_spi));
5dcc44ed9 Addy Ke 2014-07-11 602 if (!master)
64e36824b addy ke 2014-07-01 603 return -ENOMEM;
5dcc44ed9 Addy Ke 2014-07-11 604
64e36824b addy ke 2014-07-01 605 platform_set_drvdata(pdev, master);
64e36824b addy ke 2014-07-01 606
64e36824b addy ke 2014-07-01 607 rs = spi_master_get_devdata(master);
64e36824b addy ke 2014-07-01 608
64e36824b addy ke 2014-07-01 609 /* Get basic io resource and map it */
64e36824b addy ke 2014-07-01 610 mem = platform_get_resource(pdev, IORESOURCE_MEM, 0);
64e36824b addy ke 2014-07-01 611 rs->regs = devm_ioremap_resource(&pdev->dev, mem);
64e36824b addy ke 2014-07-01 612 if (IS_ERR(rs->regs)) {
64e36824b addy ke 2014-07-01 613 ret = PTR_ERR(rs->regs);
c351587e2 Jeffy Chen 2017-06-13 614 goto err_put_master;
64e36824b addy ke 2014-07-01 615 }
64e36824b addy ke 2014-07-01 616
64e36824b addy ke 2014-07-01 617 rs->apb_pclk = devm_clk_get(&pdev->dev, "apb_pclk");
64e36824b addy ke 2014-07-01 618 if (IS_ERR(rs->apb_pclk)) {
64e36824b addy ke 2014-07-01 619 dev_err(&pdev->dev, "Failed to get apb_pclk\n");
64e36824b addy ke 2014-07-01 620 ret = PTR_ERR(rs->apb_pclk);
c351587e2 Jeffy Chen 2017-06-13 621 goto err_put_master;
64e36824b addy ke 2014-07-01 622 }
64e36824b addy ke 2014-07-01 623
64e36824b addy ke 2014-07-01 624 rs->spiclk = devm_clk_get(&pdev->dev, "spiclk");
64e36824b addy ke 2014-07-01 625 if (IS_ERR(rs->spiclk)) {
64e36824b addy ke 2014-07-01 626 dev_err(&pdev->dev, "Failed to get spi_pclk\n");
64e36824b addy ke 2014-07-01 627 ret = PTR_ERR(rs->spiclk);
c351587e2 Jeffy Chen 2017-06-13 628 goto err_put_master;
64e36824b addy ke 2014-07-01 629 }
64e36824b addy ke 2014-07-01 630
64e36824b addy ke 2014-07-01 631 ret = clk_prepare_enable(rs->apb_pclk);
43de979dd Jeffy Chen 2017-08-07 632 if (ret < 0) {
64e36824b addy ke 2014-07-01 633 dev_err(&pdev->dev, "Failed to enable apb_pclk\n");
c351587e2 Jeffy Chen 2017-06-13 634 goto err_put_master;
64e36824b addy ke 2014-07-01 635 }
64e36824b addy ke 2014-07-01 636
64e36824b addy ke 2014-07-01 637 ret = clk_prepare_enable(rs->spiclk);
43de979dd Jeffy Chen 2017-08-07 638 if (ret < 0) {
64e36824b addy ke 2014-07-01 639 dev_err(&pdev->dev, "Failed to enable spi_clk\n");
c351587e2 Jeffy Chen 2017-06-13 640 goto err_disable_apbclk;
64e36824b addy ke 2014-07-01 641 }
64e36824b addy ke 2014-07-01 642
30688e4e6 Emil Renner Berthing 2018-10-31 643 spi_enable_chip(rs, false);
64e36824b addy ke 2014-07-01 644
01b59ce5d Emil Renner Berthing 2018-10-31 645 ret = platform_get_irq(pdev, 0);
01b59ce5d Emil Renner Berthing 2018-10-31 646 if (ret < 0)
01b59ce5d Emil Renner Berthing 2018-10-31 647 goto err_disable_spiclk;
01b59ce5d Emil Renner Berthing 2018-10-31 648
01b59ce5d Emil Renner Berthing 2018-10-31 @649 ret = devm_request_threaded_irq(&pdev->dev, ret, rockchip_spi_isr, NULL,
01b59ce5d Emil Renner Berthing 2018-10-31 @650 IRQF_ONESHOT, dev_name(&pdev->dev), master);
01b59ce5d Emil Renner Berthing 2018-10-31 651 if (ret)
01b59ce5d Emil Renner Berthing 2018-10-31 652 goto err_disable_spiclk;
01b59ce5d Emil Renner Berthing 2018-10-31 653
64e36824b addy ke 2014-07-01 654 rs->dev = &pdev->dev;
420b82f84 Emil Renner Berthing 2018-10-31 655 rs->freq = clk_get_rate(rs->spiclk);
64e36824b addy ke 2014-07-01 656
76b17e6e4 Julius Werner 2015-03-26 657 if (!of_property_read_u32(pdev->dev.of_node, "rx-sample-delay-ns",
74b7efa82 Emil Renner Berthing 2018-10-31 658 &rsd_nsecs)) {
74b7efa82 Emil Renner Berthing 2018-10-31 659 /* rx sample delay is expressed in parent clock cycles (max 3) */
74b7efa82 Emil Renner Berthing 2018-10-31 660 u32 rsd = DIV_ROUND_CLOSEST(rsd_nsecs * (rs->freq >> 8),
74b7efa82 Emil Renner Berthing 2018-10-31 661 1000000000 >> 8);
74b7efa82 Emil Renner Berthing 2018-10-31 662 if (!rsd) {
74b7efa82 Emil Renner Berthing 2018-10-31 663 dev_warn(rs->dev, "%u Hz are too slow to express %u ns delay\n",
74b7efa82 Emil Renner Berthing 2018-10-31 664 rs->freq, rsd_nsecs);
74b7efa82 Emil Renner Berthing 2018-10-31 665 } else if (rsd > CR0_RSD_MAX) {
74b7efa82 Emil Renner Berthing 2018-10-31 666 rsd = CR0_RSD_MAX;
74b7efa82 Emil Renner Berthing 2018-10-31 667 dev_warn(rs->dev, "%u Hz are too fast to express %u ns delay, clamping at %u ns\n",
74b7efa82 Emil Renner Berthing 2018-10-31 668 rs->freq, rsd_nsecs,
74b7efa82 Emil Renner Berthing 2018-10-31 669 CR0_RSD_MAX * 1000000000U / rs->freq);
74b7efa82 Emil Renner Berthing 2018-10-31 670 }
74b7efa82 Emil Renner Berthing 2018-10-31 671 rs->rsd = rsd;
74b7efa82 Emil Renner Berthing 2018-10-31 672 }
76b17e6e4 Julius Werner 2015-03-26 673
64e36824b addy ke 2014-07-01 674 rs->fifo_len = get_fifo_len(rs);
64e36824b addy ke 2014-07-01 675 if (!rs->fifo_len) {
64e36824b addy ke 2014-07-01 676 dev_err(&pdev->dev, "Failed to get fifo length\n");
db7e8d90c Wei Yongjun 2014-07-20 677 ret = -EINVAL;
c351587e2 Jeffy Chen 2017-06-13 678 goto err_disable_spiclk;
64e36824b addy ke 2014-07-01 679 }
64e36824b addy ke 2014-07-01 680
64e36824b addy ke 2014-07-01 681 pm_runtime_set_active(&pdev->dev);
64e36824b addy ke 2014-07-01 682 pm_runtime_enable(&pdev->dev);
64e36824b addy ke 2014-07-01 683
64e36824b addy ke 2014-07-01 684 master->auto_runtime_pm = true;
64e36824b addy ke 2014-07-01 685 master->bus_num = pdev->id;
04290192f Emil Renner Berthing 2018-10-31 686 master->mode_bits = SPI_CPOL | SPI_CPHA | SPI_LOOP | SPI_LSB_FIRST;
aa099382a Jeffy Chen 2017-06-28 687 master->num_chipselect = ROCKCHIP_SPI_MAX_CS_NUM;
64e36824b addy ke 2014-07-01 688 master->dev.of_node = pdev->dev.of_node;
65498c6ae Emil Renner Berthing 2018-10-31 689 master->bits_per_word_mask = SPI_BPW_MASK(16) | SPI_BPW_MASK(8) | SPI_BPW_MASK(4);
420b82f84 Emil Renner Berthing 2018-10-31 690 master->min_speed_hz = rs->freq / BAUDR_SCKDV_MAX;
420b82f84 Emil Renner Berthing 2018-10-31 691 master->max_speed_hz = min(rs->freq / BAUDR_SCKDV_MIN, MAX_SCLK_OUT);
64e36824b addy ke 2014-07-01 692
64e36824b addy ke 2014-07-01 693 master->set_cs = rockchip_spi_set_cs;
64e36824b addy ke 2014-07-01 694 master->transfer_one = rockchip_spi_transfer_one;
5185a81c0 Brian Norris 2016-07-14 695 master->max_transfer_size = rockchip_spi_max_transfer_size;
2291793cc Andy Shevchenko 2015-02-27 696 master->handle_err = rockchip_spi_handle_err;
c863795c4 Jeffy Chen 2017-06-28 697 master->flags = SPI_MASTER_GPIO_SS;
64e36824b addy ke 2014-07-01 698
eee06a9ee Emil Renner Berthing 2018-10-31 699 master->dma_tx = dma_request_chan(rs->dev, "tx");
eee06a9ee Emil Renner Berthing 2018-10-31 700 if (IS_ERR(master->dma_tx)) {
61cadcf46 Shawn Lin 2016-03-09 701 /* Check tx to see if we need defer probing driver */
eee06a9ee Emil Renner Berthing 2018-10-31 702 if (PTR_ERR(master->dma_tx) == -EPROBE_DEFER) {
61cadcf46 Shawn Lin 2016-03-09 703 ret = -EPROBE_DEFER;
c351587e2 Jeffy Chen 2017-06-13 704 goto err_disable_pm_runtime;
61cadcf46 Shawn Lin 2016-03-09 705 }
64e36824b addy ke 2014-07-01 706 dev_warn(rs->dev, "Failed to request TX DMA channel\n");
eee06a9ee Emil Renner Berthing 2018-10-31 707 master->dma_tx = NULL;
61cadcf46 Shawn Lin 2016-03-09 708 }
64e36824b addy ke 2014-07-01 709
eee06a9ee Emil Renner Berthing 2018-10-31 710 master->dma_rx = dma_request_chan(rs->dev, "rx");
eee06a9ee Emil Renner Berthing 2018-10-31 711 if (IS_ERR(master->dma_rx)) {
eee06a9ee Emil Renner Berthing 2018-10-31 712 if (PTR_ERR(master->dma_rx) == -EPROBE_DEFER) {
e4c0e06f9 Shawn Lin 2016-03-31 713 ret = -EPROBE_DEFER;
5de7ed0c9 Dan Carpenter 2016-05-04 714 goto err_free_dma_tx;
64e36824b addy ke 2014-07-01 715 }
64e36824b addy ke 2014-07-01 716 dev_warn(rs->dev, "Failed to request RX DMA channel\n");
eee06a9ee Emil Renner Berthing 2018-10-31 717 master->dma_rx = NULL;
64e36824b addy ke 2014-07-01 718 }
64e36824b addy ke 2014-07-01 719
eee06a9ee Emil Renner Berthing 2018-10-31 720 if (master->dma_tx && master->dma_rx) {
eee06a9ee Emil Renner Berthing 2018-10-31 721 rs->dma_addr_tx = mem->start + ROCKCHIP_SPI_TXDR;
eee06a9ee Emil Renner Berthing 2018-10-31 722 rs->dma_addr_rx = mem->start + ROCKCHIP_SPI_RXDR;
64e36824b addy ke 2014-07-01 723 master->can_dma = rockchip_spi_can_dma;
64e36824b addy ke 2014-07-01 724 }
64e36824b addy ke 2014-07-01 725
64e36824b addy ke 2014-07-01 726 ret = devm_spi_register_master(&pdev->dev, master);
43de979dd Jeffy Chen 2017-08-07 727 if (ret < 0) {
64e36824b addy ke 2014-07-01 728 dev_err(&pdev->dev, "Failed to register master\n");
c351587e2 Jeffy Chen 2017-06-13 729 goto err_free_dma_rx;
64e36824b addy ke 2014-07-01 730 }
64e36824b addy ke 2014-07-01 731
64e36824b addy ke 2014-07-01 732 return 0;
64e36824b addy ke 2014-07-01 733
c351587e2 Jeffy Chen 2017-06-13 734 err_free_dma_rx:
eee06a9ee Emil Renner Berthing 2018-10-31 735 if (master->dma_rx)
eee06a9ee Emil Renner Berthing 2018-10-31 736 dma_release_channel(master->dma_rx);
5de7ed0c9 Dan Carpenter 2016-05-04 737 err_free_dma_tx:
eee06a9ee Emil Renner Berthing 2018-10-31 738 if (master->dma_tx)
eee06a9ee Emil Renner Berthing 2018-10-31 739 dma_release_channel(master->dma_tx);
c351587e2 Jeffy Chen 2017-06-13 740 err_disable_pm_runtime:
c351587e2 Jeffy Chen 2017-06-13 741 pm_runtime_disable(&pdev->dev);
c351587e2 Jeffy Chen 2017-06-13 742 err_disable_spiclk:
64e36824b addy ke 2014-07-01 743 clk_disable_unprepare(rs->spiclk);
c351587e2 Jeffy Chen 2017-06-13 744 err_disable_apbclk:
64e36824b addy ke 2014-07-01 745 clk_disable_unprepare(rs->apb_pclk);
c351587e2 Jeffy Chen 2017-06-13 746 err_put_master:
64e36824b addy ke 2014-07-01 747 spi_master_put(master);
64e36824b addy ke 2014-07-01 748
64e36824b addy ke 2014-07-01 749 return ret;
64e36824b addy ke 2014-07-01 750 }
64e36824b addy ke 2014-07-01 751 :::::: The code at line 649 was first introduced by commit
:::::: 01b59ce5dac856323a0c13c1d51d99a819f32efe spi: rockchip: use irq rather than polling
:::::: TO: Emil Renner Berthing <[email protected]>
:::::: CC: Mark Brown <[email protected]>
---
0-DAY kernel test infrastructure Open Source Technology Center
https://lists.01.org/pipermail/kbuild-all Intel Corporation
kbuild test robot
build botRe: [PATCH v5 6/7] refactor header includes to allow kthread.h inclusion in psi_types.h
In reply to Suren BaghdasaryanThank you for the patch! Yet something to improve:
Hi Suren,
Thank you for the patch! Yet something to improve:
[auto build test ERROR on linus/master]
[also build test ERROR on v5.0]
[cannot apply to next-20190306]
[if your patch is applied to the wrong git tree, please drop us a note to help improve the system]
url: https://github.com/0day-ci/linux/commits/Suren-Baghdasaryan/psi-pressure-stall-monitors-v5/20190310-024018
config: i386-randconfig-a0-201910 (attached as .config)
compiler: gcc-4.9 (Debian 4.9.4-2) 4.9.4 reproduce:
# save the attached .config to linux build tree
make ARCH=i386 All errors (new ones prefixed by >>):
drivers/spi/spi-rockchip.c:328:8: error: unknown type name 'irqreturn_t'
static irqreturn_t rockchip_spi_isr(int irq, void *dev_id)
^
drivers/spi/spi-rockchip.c: In function 'rockchip_spi_isr':
drivers/spi/spi-rockchip.c:343:9: error: 'IRQ_HANDLED' undeclared (first use in this function)
return IRQ_HANDLED;
^
drivers/spi/spi-rockchip.c:343:9: note: each undeclared identifier is reported only once for each function it appears in
drivers/spi/spi-rockchip.c: In function 'rockchip_spi_probe':
>> drivers/spi/spi-rockchip.c:649:2: error: implicit declaration of function 'devm_request_threaded_irq' [-Werror=implicit-function-declaration]
ret = devm_request_threaded_irq(&pdev->dev, ret, rockchip_spi_isr, NULL,
^
drivers/spi/spi-rockchip.c:650:4: error: 'IRQF_ONESHOT' undeclared (first use in this function)
IRQF_ONESHOT, dev_name(&pdev->dev), master);
^cc1: some warnings being treated as errors
vim +/devm_request_threaded_irq +649 drivers/spi/spi-rockchip.c
64e36824b addy ke 2014-07-01 592
64e36824b addy ke 2014-07-01 593 static int rockchip_spi_probe(struct platform_device *pdev)
64e36824b addy ke 2014-07-01 594 {
43de979dd Jeffy Chen 2017-08-07 595 int ret;
64e36824b addy ke 2014-07-01 596 struct rockchip_spi *rs;
64e36824b addy ke 2014-07-01 597 struct spi_master *master;
64e36824b addy ke 2014-07-01 598 struct resource *mem;
76b17e6e4 Julius Werner 2015-03-26 599 u32 rsd_nsecs;
64e36824b addy ke 2014-07-01 600
64e36824b addy ke 2014-07-01 601 master = spi_alloc_master(&pdev->dev, sizeof(struct rockchip_spi));
5dcc44ed9 Addy Ke 2014-07-11 602 if (!master)
64e36824b addy ke 2014-07-01 603 return -ENOMEM;
5dcc44ed9 Addy Ke 2014-07-11 604
64e36824b addy ke 2014-07-01 605 platform_set_drvdata(pdev, master);
64e36824b addy ke 2014-07-01 606
64e36824b addy ke 2014-07-01 607 rs = spi_master_get_devdata(master);
64e36824b addy ke 2014-07-01 608
64e36824b addy ke 2014-07-01 609 /* Get basic io resource and map it */
64e36824b addy ke 2014-07-01 610 mem = platform_get_resource(pdev, IORESOURCE_MEM, 0);
64e36824b addy ke 2014-07-01 611 rs->regs = devm_ioremap_resource(&pdev->dev, mem);
64e36824b addy ke 2014-07-01 612 if (IS_ERR(rs->regs)) {
64e36824b addy ke 2014-07-01 613 ret = PTR_ERR(rs->regs);
c351587e2 Jeffy Chen 2017-06-13 614 goto err_put_master;
64e36824b addy ke 2014-07-01 615 }
64e36824b addy ke 2014-07-01 616
64e36824b addy ke 2014-07-01 617 rs->apb_pclk = devm_clk_get(&pdev->dev, "apb_pclk");
64e36824b addy ke 2014-07-01 618 if (IS_ERR(rs->apb_pclk)) {
64e36824b addy ke 2014-07-01 619 dev_err(&pdev->dev, "Failed to get apb_pclk\n");
64e36824b addy ke 2014-07-01 620 ret = PTR_ERR(rs->apb_pclk);
c351587e2 Jeffy Chen 2017-06-13 621 goto err_put_master;
64e36824b addy ke 2014-07-01 622 }
64e36824b addy ke 2014-07-01 623
64e36824b addy ke 2014-07-01 624 rs->spiclk = devm_clk_get(&pdev->dev, "spiclk");
64e36824b addy ke 2014-07-01 625 if (IS_ERR(rs->spiclk)) {
64e36824b addy ke 2014-07-01 626 dev_err(&pdev->dev, "Failed to get spi_pclk\n");
64e36824b addy ke 2014-07-01 627 ret = PTR_ERR(rs->spiclk);
c351587e2 Jeffy Chen 2017-06-13 628 goto err_put_master;
64e36824b addy ke 2014-07-01 629 }
64e36824b addy ke 2014-07-01 630
64e36824b addy ke 2014-07-01 631 ret = clk_prepare_enable(rs->apb_pclk);
43de979dd Jeffy Chen 2017-08-07 632 if (ret < 0) {
64e36824b addy ke 2014-07-01 633 dev_err(&pdev->dev, "Failed to enable apb_pclk\n");
c351587e2 Jeffy Chen 2017-06-13 634 goto err_put_master;
64e36824b addy ke 2014-07-01 635 }
64e36824b addy ke 2014-07-01 636
64e36824b addy ke 2014-07-01 637 ret = clk_prepare_enable(rs->spiclk);
43de979dd Jeffy Chen 2017-08-07 638 if (ret < 0) {
64e36824b addy ke 2014-07-01 639 dev_err(&pdev->dev, "Failed to enable spi_clk\n");
c351587e2 Jeffy Chen 2017-06-13 640 goto err_disable_apbclk;
64e36824b addy ke 2014-07-01 641 }
64e36824b addy ke 2014-07-01 642
30688e4e6 Emil Renner Berthing 2018-10-31 643 spi_enable_chip(rs, false);
64e36824b addy ke 2014-07-01 644
01b59ce5d Emil Renner Berthing 2018-10-31 645 ret = platform_get_irq(pdev, 0);
01b59ce5d Emil Renner Berthing 2018-10-31 646 if (ret < 0)
01b59ce5d Emil Renner Berthing 2018-10-31 647 goto err_disable_spiclk;
01b59ce5d Emil Renner Berthing 2018-10-31 648
01b59ce5d Emil Renner Berthing 2018-10-31 @649 ret = devm_request_threaded_irq(&pdev->dev, ret, rockchip_spi_isr, NULL,
01b59ce5d Emil Renner Berthing 2018-10-31 650 IRQF_ONESHOT, dev_name(&pdev->dev), master);
01b59ce5d Emil Renner Berthing 2018-10-31 651 if (ret)
01b59ce5d Emil Renner Berthing 2018-10-31 652 goto err_disable_spiclk;
01b59ce5d Emil Renner Berthing 2018-10-31 653
64e36824b addy ke 2014-07-01 654 rs->dev = &pdev->dev;
420b82f84 Emil Renner Berthing 2018-10-31 655 rs->freq = clk_get_rate(rs->spiclk);
64e36824b addy ke 2014-07-01 656
76b17e6e4 Julius Werner 2015-03-26 657 if (!of_property_read_u32(pdev->dev.of_node, "rx-sample-delay-ns",
74b7efa82 Emil Renner Berthing 2018-10-31 658 &rsd_nsecs)) {
74b7efa82 Emil Renner Berthing 2018-10-31 659 /* rx sample delay is expressed in parent clock cycles (max 3) */
74b7efa82 Emil Renner Berthing 2018-10-31 660 u32 rsd = DIV_ROUND_CLOSEST(rsd_nsecs * (rs->freq >> 8),
74b7efa82 Emil Renner Berthing 2018-10-31 661 1000000000 >> 8);
74b7efa82 Emil Renner Berthing 2018-10-31 662 if (!rsd) {
74b7efa82 Emil Renner Berthing 2018-10-31 663 dev_warn(rs->dev, "%u Hz are too slow to express %u ns delay\n",
74b7efa82 Emil Renner Berthing 2018-10-31 664 rs->freq, rsd_nsecs);
74b7efa82 Emil Renner Berthing 2018-10-31 665 } else if (rsd > CR0_RSD_MAX) {
74b7efa82 Emil Renner Berthing 2018-10-31 666 rsd = CR0_RSD_MAX;
74b7efa82 Emil Renner Berthing 2018-10-31 667 dev_warn(rs->dev, "%u Hz are too fast to express %u ns delay, clamping at %u ns\n",
74b7efa82 Emil Renner Berthing 2018-10-31 668 rs->freq, rsd_nsecs,
74b7efa82 Emil Renner Berthing 2018-10-31 669 CR0_RSD_MAX * 1000000000U / rs->freq);
74b7efa82 Emil Renner Berthing 2018-10-31 670 }
74b7efa82 Emil Renner Berthing 2018-10-31 671 rs->rsd = rsd;
74b7efa82 Emil Renner Berthing 2018-10-31 672 }
76b17e6e4 Julius Werner 2015-03-26 673
64e36824b addy ke 2014-07-01 674 rs->fifo_len = get_fifo_len(rs);
64e36824b addy ke 2014-07-01 675 if (!rs->fifo_len) {
64e36824b addy ke 2014-07-01 676 dev_err(&pdev->dev, "Failed to get fifo length\n");
db7e8d90c Wei Yongjun 2014-07-20 677 ret = -EINVAL;
c351587e2 Jeffy Chen 2017-06-13 678 goto err_disable_spiclk;
64e36824b addy ke 2014-07-01 679 }
64e36824b addy ke 2014-07-01 680
64e36824b addy ke 2014-07-01 681 pm_runtime_set_active(&pdev->dev);
64e36824b addy ke 2014-07-01 682 pm_runtime_enable(&pdev->dev);
64e36824b addy ke 2014-07-01 683
64e36824b addy ke 2014-07-01 684 master->auto_runtime_pm = true;
64e36824b addy ke 2014-07-01 685 master->bus_num = pdev->id;
04290192f Emil Renner Berthing 2018-10-31 686 master->mode_bits = SPI_CPOL | SPI_CPHA | SPI_LOOP | SPI_LSB_FIRST;
aa099382a Jeffy Chen 2017-06-28 687 master->num_chipselect = ROCKCHIP_SPI_MAX_CS_NUM;
64e36824b addy ke 2014-07-01 688 master->dev.of_node = pdev->dev.of_node;
65498c6ae Emil Renner Berthing 2018-10-31 689 master->bits_per_word_mask = SPI_BPW_MASK(16) | SPI_BPW_MASK(8) | SPI_BPW_MASK(4);
420b82f84 Emil Renner Berthing 2018-10-31 690 master->min_speed_hz = rs->freq / BAUDR_SCKDV_MAX;
420b82f84 Emil Renner Berthing 2018-10-31 691 master->max_speed_hz = min(rs->freq / BAUDR_SCKDV_MIN, MAX_SCLK_OUT);
64e36824b addy ke 2014-07-01 692
64e36824b addy ke 2014-07-01 693 master->set_cs = rockchip_spi_set_cs;
64e36824b addy ke 2014-07-01 694 master->transfer_one = rockchip_spi_transfer_one;
5185a81c0 Brian Norris 2016-07-14 695 master->max_transfer_size = rockchip_spi_max_transfer_size;
2291793cc Andy Shevchenko 2015-02-27 696 master->handle_err = rockchip_spi_handle_err;
c863795c4 Jeffy Chen 2017-06-28 697 master->flags = SPI_MASTER_GPIO_SS;
64e36824b addy ke 2014-07-01 698
eee06a9ee Emil Renner Berthing 2018-10-31 699 master->dma_tx = dma_request_chan(rs->dev, "tx");
eee06a9ee Emil Renner Berthing 2018-10-31 700 if (IS_ERR(master->dma_tx)) {
61cadcf46 Shawn Lin 2016-03-09 701 /* Check tx to see if we need defer probing driver */
eee06a9ee Emil Renner Berthing 2018-10-31 702 if (PTR_ERR(master->dma_tx) == -EPROBE_DEFER) {
61cadcf46 Shawn Lin 2016-03-09 703 ret = -EPROBE_DEFER;
c351587e2 Jeffy Chen 2017-06-13 704 goto err_disable_pm_runtime;
61cadcf46 Shawn Lin 2016-03-09 705 }
64e36824b addy ke 2014-07-01 706 dev_warn(rs->dev, "Failed to request TX DMA channel\n");
eee06a9ee Emil Renner Berthing 2018-10-31 707 master->dma_tx = NULL;
61cadcf46 Shawn Lin 2016-03-09 708 }
64e36824b addy ke 2014-07-01 709
eee06a9ee Emil Renner Berthing 2018-10-31 710 master->dma_rx = dma_request_chan(rs->dev, "rx");
eee06a9ee Emil Renner Berthing 2018-10-31 711 if (IS_ERR(master->dma_rx)) {
eee06a9ee Emil Renner Berthing 2018-10-31 712 if (PTR_ERR(master->dma_rx) == -EPROBE_DEFER) {
e4c0e06f9 Shawn Lin 2016-03-31 713 ret = -EPROBE_DEFER;
5de7ed0c9 Dan Carpenter 2016-05-04 714 goto err_free_dma_tx;
64e36824b addy ke 2014-07-01 715 }
64e36824b addy ke 2014-07-01 716 dev_warn(rs->dev, "Failed to request RX DMA channel\n");
eee06a9ee Emil Renner Berthing 2018-10-31 717 master->dma_rx = NULL;
64e36824b addy ke 2014-07-01 718 }
64e36824b addy ke 2014-07-01 719
eee06a9ee Emil Renner Berthing 2018-10-31 720 if (master->dma_tx && master->dma_rx) {
eee06a9ee Emil Renner Berthing 2018-10-31 721 rs->dma_addr_tx = mem->start + ROCKCHIP_SPI_TXDR;
eee06a9ee Emil Renner Berthing 2018-10-31 722 rs->dma_addr_rx = mem->start + ROCKCHIP_SPI_RXDR;
64e36824b addy ke 2014-07-01 723 master->can_dma = rockchip_spi_can_dma;
64e36824b addy ke 2014-07-01 724 }
64e36824b addy ke 2014-07-01 725
64e36824b addy ke 2014-07-01 726 ret = devm_spi_register_master(&pdev->dev, master);
43de979dd Jeffy Chen 2017-08-07 727 if (ret < 0) {
64e36824b addy ke 2014-07-01 728 dev_err(&pdev->dev, "Failed to register master\n");
c351587e2 Jeffy Chen 2017-06-13 729 goto err_free_dma_rx;
64e36824b addy ke 2014-07-01 730 }
64e36824b addy ke 2014-07-01 731
64e36824b addy ke 2014-07-01 732 return 0;
64e36824b addy ke 2014-07-01 733
c351587e2 Jeffy Chen 2017-06-13 734 err_free_dma_rx:
eee06a9ee Emil Renner Berthing 2018-10-31 735 if (master->dma_rx)
eee06a9ee Emil Renner Berthing 2018-10-31 736 dma_release_channel(master->dma_rx);
5de7ed0c9 Dan Carpenter 2016-05-04 737 err_free_dma_tx:
eee06a9ee Emil Renner Berthing 2018-10-31 738 if (master->dma_tx)
eee06a9ee Emil Renner Berthing 2018-10-31 739 dma_release_channel(master->dma_tx);
c351587e2 Jeffy Chen 2017-06-13 740 err_disable_pm_runtime:
c351587e2 Jeffy Chen 2017-06-13 741 pm_runtime_disable(&pdev->dev);
c351587e2 Jeffy Chen 2017-06-13 742 err_disable_spiclk:
64e36824b addy ke 2014-07-01 743 clk_disable_unprepare(rs->spiclk);
c351587e2 Jeffy Chen 2017-06-13 744 err_disable_apbclk:
64e36824b addy ke 2014-07-01 745 clk_disable_unprepare(rs->apb_pclk);
c351587e2 Jeffy Chen 2017-06-13 746 err_put_master:
64e36824b addy ke 2014-07-01 747 spi_master_put(master);
64e36824b addy ke 2014-07-01 748
64e36824b addy ke 2014-07-01 749 return ret;
64e36824b addy ke 2014-07-01 750 }
64e36824b addy ke 2014-07-01 751 :::::: The code at line 649 was first introduced by commit
:::::: 01b59ce5dac856323a0c13c1d51d99a819f32efe spi: rockchip: use irq rather than polling
:::::: TO: Emil Renner Berthing <[email protected]>
:::::: CC: Mark Brown <[email protected]>
---
0-DAY kernel test infrastructure Open Source Technology Center
https://lists.01.org/pipermail/kbuild-all Intel Corporation
Suren Baghdasaryan
maintainerPATCH v5 7/7 psi: introduce psi monitor
In reply to Suren BaghdasaryanPsi monitor aims to provide a low-latency short-term pressure detection mechanism configurable by users. It allows users to monitor psi metrics growth and trigger events whenever a metric raises above user-defined threshold within user-defined time window.
Time window and threshold are both expressed in usecs. Multiple psi resources with different thresholds and window sizes can be monitored concurrently.
Psi monitors activate when system enters stall state for the monitored psi metric and deactivate upon exit from the stall state. While system is in the stall state psi signal growth is monitored at a rate of 10 times per tracking window. Min window size is 500ms, therefore the min monitoring interval is 50ms. Max window size is 10s with monitoring interval of 1s.
When activated psi monitor stays active for at least the duration of one tracking window to avoid repeated activations/deactivations when psi signal is bouncing.
Notifications to the users are rate-limited to one per tracking window.
--- Documentation/accounting/psi.txt | 107 +++++++ include/linux/psi.h | 8 + include/linux/psi_types.h | 82 ++++- kernel/cgroup/cgroup.c | 71 ++++- kernel/sched/psi.c | 494 ++++++++++++++++++++++++++++++- 5 files changed, 742 insertions(+), 20 deletions(-)
Documentation/accounting/psi.txt +107 -0
@@ -63,6 +63,110 @@ tracked and exported as well, to allow detection of latency spikes which wouldn't necessarily make a dent in the time averages, or to average trends over custom time frames. +Monitoring for pressure thresholds +================================== + +Users can register triggers and use poll() to be woken up when resource +pressure exceeds certain thresholds. + +A trigger describes the maximum cumulative stall time over a specific +time window, e.g. 100ms of total stall time within any 500ms window to +generate a wakeup event. + +To register a trigger user has to open psi interface file under +/proc/pressure/ representing the resource to be monitored and write the +desired threshold and time window. The open file descriptor should be +used to wait for trigger events using select(), poll() or epoll(). +The following format is used: + +<some|full> <stall amount in us> <time window in us> + +For example writing "some 150000 1000000" into /proc/pressure/memory +would add 150ms threshold for partial memory stall measured within +1sec time window. Writing "full 50000 1000000" into /proc/pressure/io +would add 50ms threshold for full io stall measured within 1sec time window. + +Triggers can be set on more than one psi metric and more than one trigger +for the same psi metric can be specified. However for each trigger a separate +file descriptor is required to be able to poll it separately from others, +therefore for each trigger a separate open() syscall should be made even +when opening the same psi interface file. + +Monitors activate only when system enters stall state for the monitored +psi metric and deactivates upon exit from the stall state. While system is +in the stall state psi signal growth is monitored at a rate of 10 times per +tracking window. + +The kernel accepts window sizes ranging from 500ms to 10s, therefore min +monitoring update interval is 50ms and max is 1s. Min limit is set to +prevent overly frequent polling. Max limit is chosen as a high enough number +after which monitors are most likely not needed and psi averages can be used +instead. + +When activated, psi monitor stays active for at least the duration of one +tracking window to avoid repeated activations/deactivations when system is +bouncing in and out of the stall state. + +Notifications to the userspace are rate-limited to one per tracking window. + +The trigger will de-register when the file descriptor used to define the +trigger is closed. + +Userspace monitor usage example +=============================== + +#include <errno.h> +#include <fcntl.h> +#include <stdio.h> +#include <poll.h> +#include <string.h> +#include <unistd.h> + +/* + * Monitor memory partial stall with 1s tracking window size + * and 150ms threshold. + */ +int main() { + const char trig[] = "some 150000 1000000"; + struct pollfd fds; + int n; + + fds.fd = open("/proc/pressure/memory", O_RDWR | O_NONBLOCK); + if (fds.fd < 0) { + printf("/proc/pressure/memory open error: %s\n", + strerror(errno)); + return 1; + } + fds.events = POLLPRI; + + if (write(fds.fd, trig, strlen(trig) + 1) < 0) { + printf("/proc/pressure/memory write error: %s\n", + strerror(errno)); + return 1; + } + + printf("waiting for events...\n"); + while (1) { + n = poll(&fds, 1, -1); + if (n < 0) { + printf("poll error: %s\n", strerror(errno)); + return 1; + } + if (fds.revents & POLLERR) { + printf("got POLLERR, event source is gone\n"); + return 0; + } + if (fds.revents & POLLPRI) { + printf("event triggered!\n"); + } else { + printf("unknown event received: 0x%x\n", fds.revents); + return 1; + } + } + + return 0; +} + Cgroup2 interface =================
@@ -71,3 +175,6 @@ mounted, pressure stall information is also tracked for tasks grouped into cgroups. Each subdirectory in the cgroupfs mountpoint contains cpu.pressure, memory.pressure, and io.pressure files; the format is the same as the /proc/pressure/ files. + +Per-cgroup psi monitors can be specified and used the same way as +system-wide ones.
include/linux/psi.h +8 -0
@@ -4,6 +4,7 @@#include <linux/jump_label.h> #include <linux/psi_types.h> #include <linux/sched.h> +#include <linux/poll.h> struct seq_file ;struct css_set ;
@@ -26,6 +27,13 @@ int psi_show(struct seq_file *s, struct psi_group *group, enum psi_res res);int psi_cgroup_alloc (struct cgroup *cgrp);void psi_cgroup_free (struct cgroup *cgrp);void cgroup_move_task (struct task_struct *p,struct css_set *to); + +struct psi_trigger *psi_trigger_create (struct psi_group *group, +char *buf,size_t nbytes,enum psi_res res); +void psi_trigger_replace (void **trigger_ptr,struct psi_trigger *t); + +__poll_t psi_trigger_poll (void **trigger_ptr,struct file *file, +poll_table *wait);#endif #else /* CONFIG_PSI */
include/linux/psi_types.h +80 -2
112 lines not on this page · raw message
kernel/cgroup/cgroup.c +69 -2
94 lines not on this page · raw message
kernel/sched/psi.c +478 -16
627 lines not on this page · raw message
Signature · 1 line
2.21.0.360.g471c308f928-goog
Quoted 94 lines · Suren Baghdasaryan
This is respin of:
https://lwn.net/ml/linux-kernel/20190206023446.177362-1-surenb%40google.com/Android is adopting psi to detect and remedy memory pressure that results in stuttering and decreased responsiveness on mobile devices.
Psi gives us the stall information, but because we're dealing with latencies in the millisecond range, periodically reading the pressure files to detect stalls in a timely fashion is not feasible. Psi also doesn't aggregate its averages at a high-enough frequency right now.
This patch series extends the psi interface such that users can configure sensitive latency thresholds and use
poll()and friends to be notified when these are breached.As high-frequency aggregation is costly, it implements an aggregation method that is optimized for fast, short-interval averaging, and makes the aggregation frequency adaptive, such that high-frequency updates only happen while monitored stall events are actively occurring.
With these patches applied, Android can monitor for, and ward off, mounting memory shortages before they cause problems for the user. For example, using memory stall monitors in userspace low memory killer daemon (lmkd) we can detect mounting pressure and kill less important processes before device becomes visibly sluggish. In our memory stress testing psi memory monitors produce roughly 10x less false positives compared to vmpressure signals. Having ability to specify multiple triggers for the same psi metric allows other parts of Android framework to monitor memory state of the device and act accordingly.
The new interface is straight-forward. The user opens one of the pressure files for writing and writes a trigger description into the file descriptor that defines the stall state - some or full, and the maximum stall time over a given window of time. E.g.:
/* Signal when stall time exceeds 100ms of a 1s window */ char trigger[] = "full 100000 1000000" fd = open("/proc/pressure/memory") write(fd, trigger, sizeof(trigger)) while (poll() >= 0) { ... }; close(fd);When the monitored stall state is entered, psi adapts its aggregation frequency according to what the configured time window requires in order to emit event signals in a timely fashion. Once the stalling subsides, aggregation reverts back to normal.
The trigger is associated with the open file descriptor. To stop monitoring, the user only needs to close the file descriptor and the trigger is discarded.
Patches 1-6 prepare the psi code for polling support. Patch 7 implements the adaptive polling logic, the pressure growth detection optimized for short intervals, and hooks up
write()andpoll()on the pressure files.The patches were developed in collaboration with Johannes Weiner.
The patches are based on 5.0-rc8 (Merge tag 'drm-next-2019-03-06').
Suren Baghdasaryan (7):
psi: introducestate_maskto represent stalled psi states
psi: makepsi_enablestatic
psi: rename psi fields in preparation for psi trigger addition
psi: splitupdate_statsinto parts
psi: track changed states
refactor header includes to allowkthread.hinclusion inpsi_types.h
psi: introduce psi monitorDocumentation/accounting/psi.txt | 107 ++++++ include/linux/kthread.h | 3 +- include/linux/psi.h | 8 + include/linux/psi_types.h | 105 +++++- include/linux/sched.h | 1 - kernel/cgroup/cgroup.c | 71 +++- kernel/kthread.c | 1 + kernel/sched/psi.c | 613 ++++++++++++++++++++++++++++--- 8 files changed, 833 insertions(+), 76 deletions(-)Changes in v5:
- Fixed sparse: error: incompatible types in comparison expression, as per Andrew
- Changedpsi_enableto static, as per Andrew
- Refactored headers to be able to includekthread.hintopsi_types.hwithout creating a circular inclusion, as per Johannes
- Split psi monitor from aggregator, used RT worker for psi monitoring to prevent it being starved by other RT threads and memory pressure events being delayed or lost, as per Minchan and Android Performance Team
- Fixed blockable memory allocation underrcu_read_lockinsidepsi_trigger_pollby using refcounting, as per Eva Huang and Minchan
- Misc cleanup and improvements, as per Johannes
Quoted 3 lines
Notes:
0001-psi-introduce-state_mask-to-represent-stalled-psi-st.patch is unchanged from the previous version and provided for completeness.
Please fix kbuild test bot's warning in 6/7
Other than that, for all patches,
Suren Baghdasaryan
maintainerQuoted 96 lines · Minchan Kim
Quoted 94 lines · Suren Baghdasaryan
This is respin of:
https://lwn.net/ml/linux-kernel/20190206023446.177362-1-surenb%40google.com/Android is adopting psi to detect and remedy memory pressure that results in stuttering and decreased responsiveness on mobile devices.
Psi gives us the stall information, but because we're dealing with latencies in the millisecond range, periodically reading the pressure files to detect stalls in a timely fashion is not feasible. Psi also doesn't aggregate its averages at a high-enough frequency right now.
This patch series extends the psi interface such that users can configure sensitive latency thresholds and use
poll()and friends to be notified when these are breached.As high-frequency aggregation is costly, it implements an aggregation method that is optimized for fast, short-interval averaging, and makes the aggregation frequency adaptive, such that high-frequency updates only happen while monitored stall events are actively occurring.
With these patches applied, Android can monitor for, and ward off, mounting memory shortages before they cause problems for the user. For example, using memory stall monitors in userspace low memory killer daemon (lmkd) we can detect mounting pressure and kill less important processes before device becomes visibly sluggish. In our memory stress testing psi memory monitors produce roughly 10x less false positives compared to vmpressure signals. Having ability to specify multiple triggers for the same psi metric allows other parts of Android framework to monitor memory state of the device and act accordingly.
The new interface is straight-forward. The user opens one of the pressure files for writing and writes a trigger description into the file descriptor that defines the stall state - some or full, and the maximum stall time over a given window of time. E.g.:
/* Signal when stall time exceeds 100ms of a 1s window */ char trigger[] = "full 100000 1000000" fd = open("/proc/pressure/memory") write(fd, trigger, sizeof(trigger)) while (poll() >= 0) { ... }; close(fd);When the monitored stall state is entered, psi adapts its aggregation frequency according to what the configured time window requires in order to emit event signals in a timely fashion. Once the stalling subsides, aggregation reverts back to normal.
The trigger is associated with the open file descriptor. To stop monitoring, the user only needs to close the file descriptor and the trigger is discarded.
Patches 1-6 prepare the psi code for polling support. Patch 7 implements the adaptive polling logic, the pressure growth detection optimized for short intervals, and hooks up
write()andpoll()on the pressure files.The patches were developed in collaboration with Johannes Weiner.
The patches are based on 5.0-rc8 (Merge tag 'drm-next-2019-03-06').
Suren Baghdasaryan (7):
psi: introducestate_maskto represent stalled psi states
psi: makepsi_enablestatic
psi: rename psi fields in preparation for psi trigger addition
psi: splitupdate_statsinto parts
psi: track changed states
refactor header includes to allowkthread.hinclusion inpsi_types.h
psi: introduce psi monitorDocumentation/accounting/psi.txt | 107 ++++++ include/linux/kthread.h | 3 +- include/linux/psi.h | 8 + include/linux/psi_types.h | 105 +++++- include/linux/sched.h | 1 - kernel/cgroup/cgroup.c | 71 +++- kernel/kthread.c | 1 + kernel/sched/psi.c | 613 ++++++++++++++++++++++++++++--- 8 files changed, 833 insertions(+), 76 deletions(-)Changes in v5:
- Fixed sparse: error: incompatible types in comparison expression, as per Andrew
- Changedpsi_enableto static, as per Andrew
- Refactored headers to be able to includekthread.hintopsi_types.hwithout creating a circular inclusion, as per Johannes
- Split psi monitor from aggregator, used RT worker for psi monitoring to prevent it being starved by other RT threads and memory pressure events being delayed or lost, as per Minchan and Android Performance Team
- Fixed blockable memory allocation underrcu_read_lockinsidepsi_trigger_pollby using refcounting, as per Eva Huang and Minchan
- Misc cleanup and improvements, as per Johannes
Quoted 6 lines
Quoted 3 lines
Notes:
0001-psi-introduce-state_mask-to-represent-stalled-psi-st.patch is unchanged from the previous version and provided for completeness.Please fix kbuild test bot's warning in 6/7
Other than that, for all patches,
Thanks for the review!
Pushed v6 with the fix for the warning: https://lkml.org/lkml/2019/3/19/987
Also fixed a bug introduced in https://lkml.org/lkml/2019/3/8/686
which I discovered while testing (description in the changelog of the new patchset).
Quoted 2 lines
Acked-by Minchan Kim <[email protected]>