Merge 4.4.80 into android-4.4

author Greg Kroah-Hartman <gregkh@google.com>

Mon, 7 Aug 2017 21:29:16 +0000 (14:29 -0700)

committer Greg Kroah-Hartman <gregkh@google.com>

Mon, 7 Aug 2017 21:29:16 +0000 (14:29 -0700)
author Greg Kroah-Hartman <gregkh@google.com>
Mon, 7 Aug 2017 21:29:16 +0000 (14:29 -0700)
committer Greg Kroah-Hartman <gregkh@google.com>
Mon, 7 Aug 2017 21:29:16 +0000 (14:29 -0700)
diff --cc Makefile
Simple merge
diff --cc arch/arm64/mm/fault.c
Simple merge
diff --cc fs/dcache.c
Simple merge
diff --cc fs/namei.c
Simple merge
diff --cc fs/pstore/ram.c
Simple merge
diff --cc fs/pstore/ram_core.c
Simple merge
diff --cc include/linux/dcache.h
Simple merge
diff --cc include/linux/pstore_ram.h

index 45ac5a0d29eefa85b4928c4c9dbe654dcfd047ca,6f4520a82197fcf25d11f7d58b52b846cd695445..7097a45dbc25c8c053745fc1bc164c4c2bfbe7f3
--- 1/include/linux/pstore_ram.h
--- 2/include/linux/pstore_ram.h
+++ b/include/linux/pstore_ram.h
@@@ -23,7 -21,15 +23,14 @@@
   #include <linux/kernel.h>
   #include <linux/list.h>
   #include <linux/types.h>
- -#include <linux/init.h>
   
+ /*
+  * Choose whether access to the RAM zone requires locking or not.  If a zone
+  * can be written to from different CPUs like with ftrace for example, then
+  * PRZ_FLAG_NO_LOCK is used. For all other cases, locking is required.
+  */
+ #define PRZ_FLAG_NO_LOCK      BIT(0)
+ 
   struct persistent_ram_buffer;
   struct rs_control;
   
diff --cc kernel/sched/core.c

index a4e23e7e6eded0f6231190d1d5c9380a83143347,dece705b7f8c197c48d6bb4761dd3e57f9a2045b..9307827cc7b14ef00e4e96c58fcbdfa85949fe92
--- 1/kernel/sched/core.c
--- 2/kernel/sched/core.c
+++ b/kernel/sched/core.c
@@@ -5784,11 -5552,7 +5784,10 @@@ migration_call(struct notifier_block *n
         switch (action & ~CPU_TASKS_FROZEN) {
   
         case CPU_UP_PREPARE:
+ +              raw_spin_lock_irqsave(&rq->lock, flags);
+ +              walt_set_window_start(rq);
+ +              raw_spin_unlock_irqrestore(&rq->lock, flags);
                 rq->calc_load_update = calc_load_update;
-               account_reset_rq(rq);
                 break;
   
         case CPU_ONLINE:
diff --cc kernel/sched/sched.h

index ce364ddbb72c739bab12f572da3703f2fc33f579,55d92a1ca070270be3f2697db84dc6bcd599d59f..430fff0d005d4305d2f953bb0ad366afd660e2fd
--- 1/kernel/sched/sched.h
--- 2/kernel/sched/sched.h
+++ b/kernel/sched/sched.h
@@@ -2035,68 -1770,3 +2035,55 @@@ static inline u64 irq_time_read(int cpu
   }
   #endif /* CONFIG_64BIT */
   #endif /* CONFIG_IRQ_TIME_ACCOUNTING */
- static inline void account_reset_rq(struct rq *rq)
- {
- #ifdef CONFIG_IRQ_TIME_ACCOUNTING
-       rq->prev_irq_time = 0;
- #endif
- #ifdef CONFIG_PARAVIRT
-       rq->prev_steal_time = 0;
- #endif
- #ifdef CONFIG_PARAVIRT_TIME_ACCOUNTING
-       rq->prev_steal_time_rq = 0;
- #endif
- }
- 
+ +
+ +#ifdef CONFIG_CPU_FREQ
+ +DECLARE_PER_CPU(struct update_util_data *, cpufreq_update_util_data);
+ +
+ +/**
+ + * cpufreq_update_util - Take a note about CPU utilization changes.
+ + * @rq: Runqueue to carry out the update for.
+ + * @flags: Update reason flags.
+ + *
+ + * This function is called by the scheduler on the CPU whose utilization is
+ + * being updated.
+ + *
+ + * It can only be called from RCU-sched read-side critical sections.
+ + *
+ + * The way cpufreq is currently arranged requires it to evaluate the CPU
+ + * performance state (frequency/voltage) on a regular basis to prevent it from
+ + * being stuck in a completely inadequate performance level for too long.
+ + * That is not guaranteed to happen if the updates are only triggered from CFS,
+ + * though, because they may not be coming in if RT or deadline tasks are active
+ + * all the time (or there are RT and DL tasks only).
+ + *
+ + * As a workaround for that issue, this function is called by the RT and DL
+ + * sched classes to trigger extra cpufreq updates to prevent it from stalling,
+ + * but that really is a band-aid.  Going forward it should be replaced with
+ + * solutions targeted more specifically at RT and DL tasks.
+ + */
+ +static inline void cpufreq_update_util(struct rq *rq, unsigned int flags)
+ +{
+ +        struct update_util_data *data;
+ +
+ +        data = rcu_dereference_sched(*this_cpu_ptr(&cpufreq_update_util_data));
+ +        if (data)
+ +                data->func(data, rq_clock(rq), flags);
+ +}
+ +
+ +static inline void cpufreq_update_this_cpu(struct rq *rq, unsigned int flags)
+ +{
+ +        if (cpu_of(rq) == smp_processor_id())
+ +                cpufreq_update_util(rq, flags);
+ +}
+ +#else
+ +static inline void cpufreq_update_util(struct rq *rq, unsigned int flags) {}
+ +static inline void cpufreq_update_this_cpu(struct rq *rq, unsigned int flags) {}
+ +#endif /* CONFIG_CPU_FREQ */
+ +
+ +#ifdef arch_scale_freq_capacity
+ +#ifndef arch_scale_freq_invariant
+ +#define arch_scale_freq_invariant()     (true)
+ +#endif
+ +#else /* arch_scale_freq_capacity */
+ +#define arch_scale_freq_invariant()     (false)
+ +#endif
author	Greg Kroah-Hartman <gregkh@google.com>
	Mon, 7 Aug 2017 21:29:16 +0000 (14:29 -0700)
committer	Greg Kroah-Hartman <gregkh@google.com>
	Mon, 7 Aug 2017 21:29:16 +0000 (14:29 -0700)
		1	2
Makefile	patch \|	diff1 \|	diff2 \|	blob \| history
arch/arm64/mm/fault.c	patch \|	diff1 \|	diff2 \|	blob \| history
fs/dcache.c	patch \|	diff1 \|	diff2 \|	blob \| history
fs/namei.c	patch \|	diff1 \|	diff2 \|	blob \| history
fs/pstore/ram.c	patch \|	diff1 \|	diff2 \|	blob \| history
fs/pstore/ram_core.c	patch \|	diff1 \|	diff2 \|	blob \| history
include/linux/dcache.h	patch \|	diff1 \|	diff2 \|	blob \| history
include/linux/pstore_ram.h	patch \|	diff1 \|	diff2 \|	blob \| history
kernel/sched/core.c	patch \|	diff1 \|	diff2 \|	blob \| history
kernel/sched/sched.h	patch \|	diff1 \|	diff2 \|	blob \| history