mirror of
https://github.com/BobTheBlinker/android_kernel_motorola_sm6375.git
synced 2026-10-24 13:44:26 -04:00
Merge branch 'perf/urgent' into perf/core
Pick up the latest fixes, refresh the development tree. Signed-off-by: Ingo Molnar <mingo@kernel.org>
This commit is contained in:
Ingo Molnar
commit
860fc2f264
565 changed files with 5338 additions and 2771 deletions
|
|
@ -137,9 +137,10 @@ $(obj)/timeconst.h: $(obj)/hz.bc $(src)/timeconst.bc FORCE
|
|||
###############################################################################
|
||||
ifeq ($(CONFIG_SYSTEM_TRUSTED_KEYRING),y)
|
||||
X509_CERTIFICATES-y := $(wildcard *.x509) $(wildcard $(srctree)/*.x509)
|
||||
X509_CERTIFICATES-$(CONFIG_MODULE_SIG) += signing_key.x509
|
||||
X509_CERTIFICATES := $(sort $(foreach CERT,$(X509_CERTIFICATES-y), \
|
||||
X509_CERTIFICATES-$(CONFIG_MODULE_SIG) += $(objtree)/signing_key.x509
|
||||
X509_CERTIFICATES-raw := $(sort $(foreach CERT,$(X509_CERTIFICATES-y), \
|
||||
$(or $(realpath $(CERT)),$(CERT))))
|
||||
X509_CERTIFICATES := $(subst $(realpath $(objtree))/,,$(X509_CERTIFICATES-raw))
|
||||
|
||||
ifeq ($(X509_CERTIFICATES),)
|
||||
$(warning *** No X.509 certificates found ***)
|
||||
|
|
@ -164,9 +165,9 @@ $(obj)/x509_certificate_list: $(X509_CERTIFICATES) $(obj)/.x509.list
|
|||
targets += $(obj)/.x509.list
|
||||
$(obj)/.x509.list:
|
||||
@echo $(X509_CERTIFICATES) >$@
|
||||
endif
|
||||
|
||||
clean-files := x509_certificate_list .x509.list
|
||||
endif
|
||||
|
||||
ifeq ($(CONFIG_MODULE_SIG),y)
|
||||
###############################################################################
|
||||
|
|
|
|||
|
|
@ -22,6 +22,6 @@ void foo(void)
|
|||
#ifdef CONFIG_SMP
|
||||
DEFINE(NR_CPUS_BITS, ilog2(CONFIG_NR_CPUS));
|
||||
#endif
|
||||
DEFINE(BLOATED_SPINLOCKS, sizeof(spinlock_t) > sizeof(int));
|
||||
DEFINE(SPINLOCK_SIZE, sizeof(spinlock_t));
|
||||
/* End of constants */
|
||||
}
|
||||
|
|
|
|||
|
|
@ -890,6 +890,16 @@ static void cgroup_diput(struct dentry *dentry, struct inode *inode)
|
|||
struct cgroup *cgrp = dentry->d_fsdata;
|
||||
|
||||
BUG_ON(!(cgroup_is_dead(cgrp)));
|
||||
|
||||
/*
|
||||
* XXX: cgrp->id is only used to look up css's. As cgroup
|
||||
* and css's lifetimes will be decoupled, it should be made
|
||||
* per-subsystem and moved to css->id so that lookups are
|
||||
* successful until the target css is released.
|
||||
*/
|
||||
idr_remove(&cgrp->root->cgroup_idr, cgrp->id);
|
||||
cgrp->id = -1;
|
||||
|
||||
call_rcu(&cgrp->rcu_head, cgroup_free_rcu);
|
||||
} else {
|
||||
struct cfent *cfe = __d_cfe(dentry);
|
||||
|
|
@ -4268,6 +4278,7 @@ static void css_release(struct percpu_ref *ref)
|
|||
struct cgroup_subsys_state *css =
|
||||
container_of(ref, struct cgroup_subsys_state, refcnt);
|
||||
|
||||
rcu_assign_pointer(css->cgroup->subsys[css->ss->subsys_id], NULL);
|
||||
call_rcu(&css->rcu_head, css_free_rcu_fn);
|
||||
}
|
||||
|
||||
|
|
@ -4426,14 +4437,6 @@ static long cgroup_create(struct cgroup *parent, struct dentry *dentry,
|
|||
list_add_tail_rcu(&cgrp->sibling, &cgrp->parent->children);
|
||||
root->number_of_cgroups++;
|
||||
|
||||
/* each css holds a ref to the cgroup's dentry and the parent css */
|
||||
for_each_root_subsys(root, ss) {
|
||||
struct cgroup_subsys_state *css = css_ar[ss->subsys_id];
|
||||
|
||||
dget(dentry);
|
||||
css_get(css->parent);
|
||||
}
|
||||
|
||||
/* hold a ref to the parent's dentry */
|
||||
dget(parent->dentry);
|
||||
|
||||
|
|
@ -4445,6 +4448,13 @@ static long cgroup_create(struct cgroup *parent, struct dentry *dentry,
|
|||
if (err)
|
||||
goto err_destroy;
|
||||
|
||||
/* each css holds a ref to the cgroup's dentry and parent css */
|
||||
dget(dentry);
|
||||
css_get(css->parent);
|
||||
|
||||
/* mark it consumed for error path */
|
||||
css_ar[ss->subsys_id] = NULL;
|
||||
|
||||
if (ss->broken_hierarchy && !ss->warned_broken_hierarchy &&
|
||||
parent->parent) {
|
||||
pr_warning("cgroup: %s (%d) created nested cgroup for controller \"%s\" which has incomplete hierarchy support. Nested cgroups may change behavior in the future.\n",
|
||||
|
|
@ -4491,6 +4501,14 @@ err_free_cgrp:
|
|||
return err;
|
||||
|
||||
err_destroy:
|
||||
for_each_root_subsys(root, ss) {
|
||||
struct cgroup_subsys_state *css = css_ar[ss->subsys_id];
|
||||
|
||||
if (css) {
|
||||
percpu_ref_cancel_init(&css->refcnt);
|
||||
ss->css_free(css);
|
||||
}
|
||||
}
|
||||
cgroup_destroy_locked(cgrp);
|
||||
mutex_unlock(&cgroup_mutex);
|
||||
mutex_unlock(&dentry->d_inode->i_mutex);
|
||||
|
|
@ -4652,8 +4670,12 @@ static int cgroup_destroy_locked(struct cgroup *cgrp)
|
|||
* will be invoked to perform the rest of destruction once the
|
||||
* percpu refs of all css's are confirmed to be killed.
|
||||
*/
|
||||
for_each_root_subsys(cgrp->root, ss)
|
||||
kill_css(cgroup_css(cgrp, ss));
|
||||
for_each_root_subsys(cgrp->root, ss) {
|
||||
struct cgroup_subsys_state *css = cgroup_css(cgrp, ss);
|
||||
|
||||
if (css)
|
||||
kill_css(css);
|
||||
}
|
||||
|
||||
/*
|
||||
* Mark @cgrp dead. This prevents further task migration and child
|
||||
|
|
@ -4722,14 +4744,6 @@ static void cgroup_destroy_css_killed(struct cgroup *cgrp)
|
|||
/* delete this cgroup from parent->children */
|
||||
list_del_rcu(&cgrp->sibling);
|
||||
|
||||
/*
|
||||
* We should remove the cgroup object from idr before its grace
|
||||
* period starts, so we won't be looking up a cgroup while the
|
||||
* cgroup is being freed.
|
||||
*/
|
||||
idr_remove(&cgrp->root->cgroup_idr, cgrp->id);
|
||||
cgrp->id = -1;
|
||||
|
||||
dput(d);
|
||||
|
||||
set_bit(CGRP_RELEASABLE, &parent->flags);
|
||||
|
|
|
|||
|
|
@ -1397,6 +1397,8 @@ event_sched_out(struct perf_event *event,
|
|||
if (event->state != PERF_EVENT_STATE_ACTIVE)
|
||||
return;
|
||||
|
||||
perf_pmu_disable(event->pmu);
|
||||
|
||||
event->state = PERF_EVENT_STATE_INACTIVE;
|
||||
if (event->pending_disable) {
|
||||
event->pending_disable = 0;
|
||||
|
|
@ -1413,6 +1415,8 @@ event_sched_out(struct perf_event *event,
|
|||
ctx->nr_freq--;
|
||||
if (event->attr.exclusive || !cpuctx->active_oncpu)
|
||||
cpuctx->exclusive = 0;
|
||||
|
||||
perf_pmu_enable(event->pmu);
|
||||
}
|
||||
|
||||
static void
|
||||
|
|
@ -1653,6 +1657,7 @@ event_sched_in(struct perf_event *event,
|
|||
struct perf_event_context *ctx)
|
||||
{
|
||||
u64 tstamp = perf_event_time(event);
|
||||
int ret = 0;
|
||||
|
||||
if (event->state <= PERF_EVENT_STATE_OFF)
|
||||
return 0;
|
||||
|
|
@ -1675,10 +1680,13 @@ event_sched_in(struct perf_event *event,
|
|||
*/
|
||||
smp_wmb();
|
||||
|
||||
perf_pmu_disable(event->pmu);
|
||||
|
||||
if (event->pmu->add(event, PERF_EF_START)) {
|
||||
event->state = PERF_EVENT_STATE_INACTIVE;
|
||||
event->oncpu = -1;
|
||||
return -EAGAIN;
|
||||
ret = -EAGAIN;
|
||||
goto out;
|
||||
}
|
||||
|
||||
event->tstamp_running += tstamp - event->tstamp_stopped;
|
||||
|
|
@ -1694,7 +1702,10 @@ event_sched_in(struct perf_event *event,
|
|||
if (event->attr.exclusive)
|
||||
cpuctx->exclusive = 1;
|
||||
|
||||
return 0;
|
||||
out:
|
||||
perf_pmu_enable(event->pmu);
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
static int
|
||||
|
|
@ -2744,6 +2755,8 @@ static void perf_adjust_freq_unthr_context(struct perf_event_context *ctx,
|
|||
if (!event_filter_match(event))
|
||||
continue;
|
||||
|
||||
perf_pmu_disable(event->pmu);
|
||||
|
||||
hwc = &event->hw;
|
||||
|
||||
if (hwc->interrupts == MAX_INTERRUPTS) {
|
||||
|
|
@ -2753,7 +2766,7 @@ static void perf_adjust_freq_unthr_context(struct perf_event_context *ctx,
|
|||
}
|
||||
|
||||
if (!event->attr.freq || !event->attr.sample_freq)
|
||||
continue;
|
||||
goto next;
|
||||
|
||||
/*
|
||||
* stop the event and update event->count
|
||||
|
|
@ -2775,6 +2788,8 @@ static void perf_adjust_freq_unthr_context(struct perf_event_context *ctx,
|
|||
perf_adjust_period(event, period, delta, false);
|
||||
|
||||
event->pmu->start(event, delta > 0 ? PERF_EF_RELOAD : 0);
|
||||
next:
|
||||
perf_pmu_enable(event->pmu);
|
||||
}
|
||||
|
||||
perf_pmu_enable(ctx->pmu);
|
||||
|
|
|
|||
|
|
@ -537,6 +537,7 @@ static struct mm_struct *mm_init(struct mm_struct *mm, struct task_struct *p)
|
|||
spin_lock_init(&mm->page_table_lock);
|
||||
mm_init_aio(mm);
|
||||
mm_init_owner(mm, p);
|
||||
clear_tlb_flush_pending(mm);
|
||||
|
||||
if (likely(!mm_alloc_pgd(mm))) {
|
||||
mm->def_flags = 0;
|
||||
|
|
|
|||
|
|
@ -19,6 +19,12 @@ EXPORT_SYMBOL(system_freezing_cnt);
|
|||
bool pm_freezing;
|
||||
bool pm_nosig_freezing;
|
||||
|
||||
/*
|
||||
* Temporary export for the deadlock workaround in ata_scsi_hotplug().
|
||||
* Remove once the hack becomes unnecessary.
|
||||
*/
|
||||
EXPORT_SYMBOL_GPL(pm_freezing);
|
||||
|
||||
/* protects freezing and frozen transitions */
|
||||
static DEFINE_SPINLOCK(freezer_lock);
|
||||
|
||||
|
|
|
|||
|
|
@ -1680,6 +1680,7 @@ int kernel_kexec(void)
|
|||
{
|
||||
kexec_in_progress = true;
|
||||
kernel_restart_prepare(NULL);
|
||||
migrate_to_reboot_cpu();
|
||||
printk(KERN_EMERG "Starting new kernel\n");
|
||||
machine_shutdown();
|
||||
}
|
||||
|
|
|
|||
|
|
@ -81,6 +81,7 @@ void pm_vt_switch_unregister(struct device *dev)
|
|||
list_for_each_entry(tmp, &pm_vt_switch_list, head) {
|
||||
if (tmp->dev == dev) {
|
||||
list_del(&tmp->head);
|
||||
kfree(tmp);
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -104,7 +104,7 @@ int unregister_reboot_notifier(struct notifier_block *nb)
|
|||
}
|
||||
EXPORT_SYMBOL(unregister_reboot_notifier);
|
||||
|
||||
static void migrate_to_reboot_cpu(void)
|
||||
void migrate_to_reboot_cpu(void)
|
||||
{
|
||||
/* The boot cpu is always logical cpu 0 */
|
||||
int cpu = reboot_cpu;
|
||||
|
|
|
|||
|
|
@ -4902,6 +4902,7 @@ DEFINE_PER_CPU(struct sched_domain *, sd_asym);
|
|||
static void update_top_cache_domain(int cpu)
|
||||
{
|
||||
struct sched_domain *sd;
|
||||
struct sched_domain *busy_sd = NULL;
|
||||
int id = cpu;
|
||||
int size = 1;
|
||||
|
||||
|
|
@ -4909,9 +4910,9 @@ static void update_top_cache_domain(int cpu)
|
|||
if (sd) {
|
||||
id = cpumask_first(sched_domain_span(sd));
|
||||
size = cpumask_weight(sched_domain_span(sd));
|
||||
sd = sd->parent; /* sd_busy */
|
||||
busy_sd = sd->parent; /* sd_busy */
|
||||
}
|
||||
rcu_assign_pointer(per_cpu(sd_busy, cpu), sd);
|
||||
rcu_assign_pointer(per_cpu(sd_busy, cpu), busy_sd);
|
||||
|
||||
rcu_assign_pointer(per_cpu(sd_llc, cpu), sd);
|
||||
per_cpu(sd_llc_size, cpu) = size;
|
||||
|
|
@ -5112,6 +5113,7 @@ build_overlap_sched_groups(struct sched_domain *sd, int cpu)
|
|||
* die on a /0 trap.
|
||||
*/
|
||||
sg->sgp->power = SCHED_POWER_SCALE * cpumask_weight(sg_span);
|
||||
sg->sgp->power_orig = sg->sgp->power;
|
||||
|
||||
/*
|
||||
* Make sure the first group of this domain contains the
|
||||
|
|
|
|||
|
|
@ -178,59 +178,61 @@ void sched_init_granularity(void)
|
|||
update_sysctl();
|
||||
}
|
||||
|
||||
#if BITS_PER_LONG == 32
|
||||
# define WMULT_CONST (~0UL)
|
||||
#else
|
||||
# define WMULT_CONST (1UL << 32)
|
||||
#endif
|
||||
|
||||
#define WMULT_CONST (~0U)
|
||||
#define WMULT_SHIFT 32
|
||||
|
||||
/*
|
||||
* Shift right and round:
|
||||
*/
|
||||
#define SRR(x, y) (((x) + (1UL << ((y) - 1))) >> (y))
|
||||
|
||||
/*
|
||||
* delta *= weight / lw
|
||||
*/
|
||||
static unsigned long
|
||||
calc_delta_mine(unsigned long delta_exec, unsigned long weight,
|
||||
struct load_weight *lw)
|
||||
static void __update_inv_weight(struct load_weight *lw)
|
||||
{
|
||||
u64 tmp;
|
||||
unsigned long w;
|
||||
|
||||
/*
|
||||
* weight can be less than 2^SCHED_LOAD_RESOLUTION for task group sched
|
||||
* entities since MIN_SHARES = 2. Treat weight as 1 if less than
|
||||
* 2^SCHED_LOAD_RESOLUTION.
|
||||
*/
|
||||
if (likely(weight > (1UL << SCHED_LOAD_RESOLUTION)))
|
||||
tmp = (u64)delta_exec * scale_load_down(weight);
|
||||
if (likely(lw->inv_weight))
|
||||
return;
|
||||
|
||||
w = scale_load_down(lw->weight);
|
||||
|
||||
if (BITS_PER_LONG > 32 && unlikely(w >= WMULT_CONST))
|
||||
lw->inv_weight = 1;
|
||||
else if (unlikely(!w))
|
||||
lw->inv_weight = WMULT_CONST;
|
||||
else
|
||||
tmp = (u64)delta_exec;
|
||||
lw->inv_weight = WMULT_CONST / w;
|
||||
}
|
||||
|
||||
if (!lw->inv_weight) {
|
||||
unsigned long w = scale_load_down(lw->weight);
|
||||
/*
|
||||
* delta_exec * weight / lw.weight
|
||||
* OR
|
||||
* (delta_exec * (weight * lw->inv_weight)) >> WMULT_SHIFT
|
||||
*
|
||||
* Either weight := NICE_0_LOAD and lw \e prio_to_wmult[], in which case
|
||||
* we're guaranteed shift stays positive because inv_weight is guaranteed to
|
||||
* fit 32 bits, and NICE_0_LOAD gives another 10 bits; therefore shift >= 22.
|
||||
*
|
||||
* Or, weight =< lw.weight (because lw.weight is the runqueue weight), thus
|
||||
* weight/lw.weight <= 1, and therefore our shift will also be positive.
|
||||
*/
|
||||
static u64 __calc_delta(u64 delta_exec, unsigned long weight, struct load_weight *lw)
|
||||
{
|
||||
u64 fact = scale_load_down(weight);
|
||||
int shift = WMULT_SHIFT;
|
||||
|
||||
if (BITS_PER_LONG > 32 && unlikely(w >= WMULT_CONST))
|
||||
lw->inv_weight = 1;
|
||||
else if (unlikely(!w))
|
||||
lw->inv_weight = WMULT_CONST;
|
||||
else
|
||||
lw->inv_weight = WMULT_CONST / w;
|
||||
__update_inv_weight(lw);
|
||||
|
||||
if (unlikely(fact >> 32)) {
|
||||
while (fact >> 32) {
|
||||
fact >>= 1;
|
||||
shift--;
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
* Check whether we'd overflow the 64-bit multiplication:
|
||||
*/
|
||||
if (unlikely(tmp > WMULT_CONST))
|
||||
tmp = SRR(SRR(tmp, WMULT_SHIFT/2) * lw->inv_weight,
|
||||
WMULT_SHIFT/2);
|
||||
else
|
||||
tmp = SRR(tmp * lw->inv_weight, WMULT_SHIFT);
|
||||
/* hint to use a 32x32->64 mul */
|
||||
fact = (u64)(u32)fact * lw->inv_weight;
|
||||
|
||||
return (unsigned long)min(tmp, (u64)(unsigned long)LONG_MAX);
|
||||
while (fact >> 32) {
|
||||
fact >>= 1;
|
||||
shift--;
|
||||
}
|
||||
|
||||
return mul_u64_u32_shr(delta_exec, fact, shift);
|
||||
}
|
||||
|
||||
|
||||
|
|
@ -443,7 +445,7 @@ find_matching_se(struct sched_entity **se, struct sched_entity **pse)
|
|||
#endif /* CONFIG_FAIR_GROUP_SCHED */
|
||||
|
||||
static __always_inline
|
||||
void account_cfs_rq_runtime(struct cfs_rq *cfs_rq, unsigned long delta_exec);
|
||||
void account_cfs_rq_runtime(struct cfs_rq *cfs_rq, u64 delta_exec);
|
||||
|
||||
/**************************************************************
|
||||
* Scheduling class tree data structure manipulation methods:
|
||||
|
|
@ -612,11 +614,10 @@ int sched_proc_update_handler(struct ctl_table *table, int write,
|
|||
/*
|
||||
* delta /= w
|
||||
*/
|
||||
static inline unsigned long
|
||||
calc_delta_fair(unsigned long delta, struct sched_entity *se)
|
||||
static inline u64 calc_delta_fair(u64 delta, struct sched_entity *se)
|
||||
{
|
||||
if (unlikely(se->load.weight != NICE_0_LOAD))
|
||||
delta = calc_delta_mine(delta, NICE_0_LOAD, &se->load);
|
||||
delta = __calc_delta(delta, NICE_0_LOAD, &se->load);
|
||||
|
||||
return delta;
|
||||
}
|
||||
|
|
@ -665,7 +666,7 @@ static u64 sched_slice(struct cfs_rq *cfs_rq, struct sched_entity *se)
|
|||
update_load_add(&lw, se->load.weight);
|
||||
load = &lw;
|
||||
}
|
||||
slice = calc_delta_mine(slice, se->load.weight, load);
|
||||
slice = __calc_delta(slice, se->load.weight, load);
|
||||
}
|
||||
return slice;
|
||||
}
|
||||
|
|
@ -703,47 +704,32 @@ void init_task_runnable_average(struct task_struct *p)
|
|||
#endif
|
||||
|
||||
/*
|
||||
* Update the current task's runtime statistics. Skip current tasks that
|
||||
* are not in our scheduling class.
|
||||
* Update the current task's runtime statistics.
|
||||
*/
|
||||
static inline void
|
||||
__update_curr(struct cfs_rq *cfs_rq, struct sched_entity *curr,
|
||||
unsigned long delta_exec)
|
||||
{
|
||||
unsigned long delta_exec_weighted;
|
||||
|
||||
schedstat_set(curr->statistics.exec_max,
|
||||
max((u64)delta_exec, curr->statistics.exec_max));
|
||||
|
||||
curr->sum_exec_runtime += delta_exec;
|
||||
schedstat_add(cfs_rq, exec_clock, delta_exec);
|
||||
delta_exec_weighted = calc_delta_fair(delta_exec, curr);
|
||||
|
||||
curr->vruntime += delta_exec_weighted;
|
||||
update_min_vruntime(cfs_rq);
|
||||
}
|
||||
|
||||
static void update_curr(struct cfs_rq *cfs_rq)
|
||||
{
|
||||
struct sched_entity *curr = cfs_rq->curr;
|
||||
u64 now = rq_clock_task(rq_of(cfs_rq));
|
||||
unsigned long delta_exec;
|
||||
u64 delta_exec;
|
||||
|
||||
if (unlikely(!curr))
|
||||
return;
|
||||
|
||||
/*
|
||||
* Get the amount of time the current task was running
|
||||
* since the last time we changed load (this cannot
|
||||
* overflow on 32 bits):
|
||||
*/
|
||||
delta_exec = (unsigned long)(now - curr->exec_start);
|
||||
if (!delta_exec)
|
||||
delta_exec = now - curr->exec_start;
|
||||
if (unlikely((s64)delta_exec <= 0))
|
||||
return;
|
||||
|
||||
__update_curr(cfs_rq, curr, delta_exec);
|
||||
curr->exec_start = now;
|
||||
|
||||
schedstat_set(curr->statistics.exec_max,
|
||||
max(delta_exec, curr->statistics.exec_max));
|
||||
|
||||
curr->sum_exec_runtime += delta_exec;
|
||||
schedstat_add(cfs_rq, exec_clock, delta_exec);
|
||||
|
||||
curr->vruntime += calc_delta_fair(delta_exec, curr);
|
||||
update_min_vruntime(cfs_rq);
|
||||
|
||||
if (entity_is_task(curr)) {
|
||||
struct task_struct *curtask = task_of(curr);
|
||||
|
||||
|
|
@ -1752,6 +1738,13 @@ void task_numa_work(struct callback_head *work)
|
|||
(vma->vm_file && (vma->vm_flags & (VM_READ|VM_WRITE)) == (VM_READ)))
|
||||
continue;
|
||||
|
||||
/*
|
||||
* Skip inaccessible VMAs to avoid any confusion between
|
||||
* PROT_NONE and NUMA hinting ptes
|
||||
*/
|
||||
if (!(vma->vm_flags & (VM_READ | VM_EXEC | VM_WRITE)))
|
||||
continue;
|
||||
|
||||
do {
|
||||
start = max(start, vma->vm_start);
|
||||
end = ALIGN(start + (pages << PAGE_SHIFT), HPAGE_SIZE);
|
||||
|
|
@ -3015,8 +3008,7 @@ static void expire_cfs_rq_runtime(struct cfs_rq *cfs_rq)
|
|||
}
|
||||
}
|
||||
|
||||
static void __account_cfs_rq_runtime(struct cfs_rq *cfs_rq,
|
||||
unsigned long delta_exec)
|
||||
static void __account_cfs_rq_runtime(struct cfs_rq *cfs_rq, u64 delta_exec)
|
||||
{
|
||||
/* dock delta_exec before expiring quota (as it could span periods) */
|
||||
cfs_rq->runtime_remaining -= delta_exec;
|
||||
|
|
@ -3034,7 +3026,7 @@ static void __account_cfs_rq_runtime(struct cfs_rq *cfs_rq,
|
|||
}
|
||||
|
||||
static __always_inline
|
||||
void account_cfs_rq_runtime(struct cfs_rq *cfs_rq, unsigned long delta_exec)
|
||||
void account_cfs_rq_runtime(struct cfs_rq *cfs_rq, u64 delta_exec)
|
||||
{
|
||||
if (!cfs_bandwidth_used() || !cfs_rq->runtime_enabled)
|
||||
return;
|
||||
|
|
@ -3574,8 +3566,7 @@ static inline u64 cfs_rq_clock_task(struct cfs_rq *cfs_rq)
|
|||
return rq_clock_task(rq_of(cfs_rq));
|
||||
}
|
||||
|
||||
static void account_cfs_rq_runtime(struct cfs_rq *cfs_rq,
|
||||
unsigned long delta_exec) {}
|
||||
static void account_cfs_rq_runtime(struct cfs_rq *cfs_rq, u64 delta_exec) {}
|
||||
static void check_cfs_rq_runtime(struct cfs_rq *cfs_rq) {}
|
||||
static void check_enqueue_throttle(struct cfs_rq *cfs_rq) {}
|
||||
static __always_inline void return_cfs_rq_runtime(struct cfs_rq *cfs_rq) {}
|
||||
|
|
@ -3932,7 +3923,7 @@ static long effective_load(struct task_group *tg, int cpu, long wl, long wg)
|
|||
{
|
||||
struct sched_entity *se = tg->se[cpu];
|
||||
|
||||
if (!tg->parent || !wl) /* the trivial, non-cgroup case */
|
||||
if (!tg->parent) /* the trivial, non-cgroup case */
|
||||
return wl;
|
||||
|
||||
for_each_sched_entity(se) {
|
||||
|
|
|
|||
|
|
@ -901,6 +901,13 @@ inc_rt_prio_smp(struct rt_rq *rt_rq, int prio, int prev_prio)
|
|||
{
|
||||
struct rq *rq = rq_of_rt_rq(rt_rq);
|
||||
|
||||
#ifdef CONFIG_RT_GROUP_SCHED
|
||||
/*
|
||||
* Change rq's cpupri only if rt_rq is the top queue.
|
||||
*/
|
||||
if (&rq->rt != rt_rq)
|
||||
return;
|
||||
#endif
|
||||
if (rq->online && prio < prev_prio)
|
||||
cpupri_set(&rq->rd->cpupri, rq->cpu, prio);
|
||||
}
|
||||
|
|
@ -910,6 +917,13 @@ dec_rt_prio_smp(struct rt_rq *rt_rq, int prio, int prev_prio)
|
|||
{
|
||||
struct rq *rq = rq_of_rt_rq(rt_rq);
|
||||
|
||||
#ifdef CONFIG_RT_GROUP_SCHED
|
||||
/*
|
||||
* Change rq's cpupri only if rt_rq is the top queue.
|
||||
*/
|
||||
if (&rq->rt != rt_rq)
|
||||
return;
|
||||
#endif
|
||||
if (rq->online && rt_rq->highest_prio.curr != prev_prio)
|
||||
cpupri_set(&rq->rd->cpupri, rq->cpu, rt_rq->highest_prio.curr);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -74,7 +74,7 @@ unsigned long long notrace sched_clock(void)
|
|||
return cd.epoch_ns;
|
||||
|
||||
do {
|
||||
seq = read_seqcount_begin(&cd.seq);
|
||||
seq = raw_read_seqcount_begin(&cd.seq);
|
||||
epoch_cyc = cd.epoch_cyc;
|
||||
epoch_ns = cd.epoch_ns;
|
||||
} while (read_seqcount_retry(&cd.seq, seq));
|
||||
|
|
@ -99,10 +99,10 @@ static void notrace update_sched_clock(void)
|
|||
cd.mult, cd.shift);
|
||||
|
||||
raw_local_irq_save(flags);
|
||||
write_seqcount_begin(&cd.seq);
|
||||
raw_write_seqcount_begin(&cd.seq);
|
||||
cd.epoch_ns = ns;
|
||||
cd.epoch_cyc = cyc;
|
||||
write_seqcount_end(&cd.seq);
|
||||
raw_write_seqcount_end(&cd.seq);
|
||||
raw_local_irq_restore(flags);
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -775,7 +775,7 @@ static int ftrace_profile_init(void)
|
|||
int cpu;
|
||||
int ret = 0;
|
||||
|
||||
for_each_online_cpu(cpu) {
|
||||
for_each_possible_cpu(cpu) {
|
||||
ret = ftrace_profile_init_cpu(cpu);
|
||||
if (ret)
|
||||
break;
|
||||
|
|
|
|||
|
|
@ -51,9 +51,9 @@ struct user_namespace init_user_ns = {
|
|||
.owner = GLOBAL_ROOT_UID,
|
||||
.group = GLOBAL_ROOT_GID,
|
||||
.proc_inum = PROC_USER_INIT_INO,
|
||||
#ifdef CONFIG_KEYS_KERBEROS_CACHE
|
||||
.krb_cache_register_sem =
|
||||
__RWSEM_INITIALIZER(init_user_ns.krb_cache_register_sem),
|
||||
#ifdef CONFIG_PERSISTENT_KEYRINGS
|
||||
.persistent_keyring_register_sem =
|
||||
__RWSEM_INITIALIZER(init_user_ns.persistent_keyring_register_sem),
|
||||
#endif
|
||||
};
|
||||
EXPORT_SYMBOL_GPL(init_user_ns);
|
||||
|
|
|
|||
Loading…
Reference in a new issue