Instead of having a full blown scheduler running for the free cpus add a very minimalistic scheduler for that purpose only ever scheduling the related idle vcpu. This has the big advantage of not needing any per-cpu, per-domain or per-scheduling unit data for free cpus and in turn simplifying moving cpus to and from cpupools a lot.
As this new scheduler is not user selectable don't register it as an official scheduler, but just include it in schedule.c. Signed-off-by: Juergen Gross <jgr...@suse.com> --- V1: new patch --- xen/arch/arm/smpboot.c | 2 - xen/arch/x86/smpboot.c | 2 - xen/common/schedule.c | 143 +++++++++++++++++++++++------------------------- xen/include/xen/sched.h | 1 - 4 files changed, 67 insertions(+), 81 deletions(-) diff --git a/xen/arch/arm/smpboot.c b/xen/arch/arm/smpboot.c index 9a6582f2a6..f756444362 100644 --- a/xen/arch/arm/smpboot.c +++ b/xen/arch/arm/smpboot.c @@ -350,8 +350,6 @@ void start_secondary(unsigned long boot_phys_offset, setup_cpu_sibling_map(cpuid); - scheduler_percpu_init(cpuid); - /* Run local notifiers */ notify_cpu_starting(cpuid); /* diff --git a/xen/arch/x86/smpboot.c b/xen/arch/x86/smpboot.c index 7e95b2cdac..153bfbb4b7 100644 --- a/xen/arch/x86/smpboot.c +++ b/xen/arch/x86/smpboot.c @@ -382,8 +382,6 @@ void start_secondary(void *unused) set_cpu_sibling_map(cpu); - scheduler_percpu_init(cpu); - init_percpu_time(); setup_secondary_APIC_clock(); diff --git a/xen/common/schedule.c b/xen/common/schedule.c index 7a5ab4b1b6..d3e4ae226c 100644 --- a/xen/common/schedule.c +++ b/xen/common/schedule.c @@ -83,6 +83,57 @@ extern const struct scheduler *__start_schedulers_array[], *__end_schedulers_arr static struct scheduler __read_mostly ops; +static spinlock_t * +sched_idle_switch_sched(struct scheduler *new_ops, unsigned int cpu, + void *pdata, void *vdata) +{ + sched_idle_unit(cpu)->priv = NULL; + + return &sched_free_cpu_lock; +} + +static struct sched_resource * +sched_idle_res_pick(const struct scheduler *ops, struct sched_unit *unit) +{ + return unit->res; +} + +static void * +sched_idle_alloc_vdata(const struct scheduler *ops, struct sched_unit *unit, + void *dd) +{ + /* Any non-NULL pointer is fine here. */ + return (void *)1UL; +} + +static void +sched_idle_free_vdata(const struct scheduler *ops, void *priv) +{ +} + +static void sched_idle_schedule( + const struct scheduler *ops, struct sched_unit *unit, s_time_t now, + bool tasklet_work_scheduled) +{ + const unsigned int cpu = smp_processor_id(); + + unit->next_time = -1; + unit->next_task = sched_idle_unit(sched_get_resource_cpu(cpu)); +} + +static struct scheduler sched_idle_ops = { + .name = "Idle Scheduler", + .opt_name = "idle", + .sched_data = NULL, + + .pick_resource = sched_idle_res_pick, + .do_schedule = sched_idle_schedule, + + .alloc_vdata = sched_idle_alloc_vdata, + .free_vdata = sched_idle_free_vdata, + .switch_sched = sched_idle_switch_sched, +}; + static inline struct vcpu *unit2vcpu_cpu(struct sched_unit *unit, unsigned int cpu) { @@ -2141,7 +2192,6 @@ static void poll_timer_fn(void *data) static int cpu_schedule_up(unsigned int cpu) { struct sched_resource *sd; - void *sched_priv; sd = xzalloc(struct sched_resource); if ( sd == NULL ) @@ -2150,7 +2200,7 @@ static int cpu_schedule_up(unsigned int cpu) sd->cpus = cpumask_of(cpu); set_sched_res(cpu, sd); - sd->scheduler = &ops; + sd->scheduler = &sched_idle_ops; spin_lock_init(&sd->_lock); sd->schedule_lock = &sched_free_cpu_lock; init_timer(&sd->s_timer, s_timer_fn, NULL, cpu); @@ -2171,20 +2221,10 @@ static int cpu_schedule_up(unsigned int cpu) struct sched_unit *unit = idle->sched_unit; /* - * During (ACPI?) suspend the idle vCPU for this pCPU is not freed, - * while its scheduler specific data (what is pointed by sched_priv) - * is. Also, at this stage of the resume path, we attach the pCPU - * to the default scheduler, no matter in what cpupool it was before - * suspend. To avoid inconsistency, let's allocate default scheduler - * data for the idle vCPU here. If the pCPU was in a different pool - * with a different scheduler, it is schedule_cpu_switch(), invoked - * later, that will set things up as appropriate. + * No need to allocate any scheduler data, as cpus coming online are + * free initially and the idle scheduler doesn't need any data areas + * allocated. */ - ASSERT(unit->priv == NULL); - - unit->priv = sched_alloc_vdata(&ops, unit, idle->domain->sched_priv); - if ( unit->priv == NULL ) - return -ENOMEM; /* Update the resource pointer in the idle unit. */ unit->res = sd; @@ -2195,16 +2235,7 @@ static int cpu_schedule_up(unsigned int cpu) sd->curr = idle_vcpu[cpu]->sched_unit; sd->sched_unit_idle = idle_vcpu[cpu]->sched_unit; - /* - * We don't want to risk calling xfree() on an sd->sched_priv - * (e.g., inside free_pdata, from cpu_schedule_down() called - * during CPU_UP_CANCELLED) that contains an IS_ERR value. - */ - sched_priv = sched_alloc_pdata(&ops, cpu); - if ( IS_ERR(sched_priv) ) - return PTR_ERR(sched_priv); - - sd->sched_priv = sched_priv; + sd->sched_priv = NULL; return 0; } @@ -2212,13 +2243,6 @@ static int cpu_schedule_up(unsigned int cpu) static void cpu_schedule_down(unsigned int cpu) { struct sched_resource *sd = get_sched_res(cpu); - struct scheduler *sched = sd->scheduler; - - sched_free_pdata(sched, sd->sched_priv, cpu); - sched_free_vdata(sched, idle_vcpu[cpu]->sched_unit->priv); - - idle_vcpu[cpu]->sched_unit->priv = NULL; - sd->sched_priv = NULL; kill_timer(&sd->s_timer); @@ -2226,26 +2250,14 @@ static void cpu_schedule_down(unsigned int cpu) xfree(sd); } -void scheduler_percpu_init(unsigned int cpu) -{ - struct sched_resource *sd = get_sched_res(cpu); - struct scheduler *sched = sd->scheduler; - - if ( system_state != SYS_STATE_resume ) - sched_init_pdata(sched, sd->sched_priv, cpu); -} - void sched_rm_cpu(unsigned int cpu) { int rc; - struct sched_resource *sd = get_sched_res(cpu); - struct scheduler *sched = sd->scheduler; rcu_read_lock(&domlist_read_lock); rc = cpu_disable_scheduler(cpu); BUG_ON(rc); rcu_read_unlock(&domlist_read_lock); - sched_deinit_pdata(sched, sd->sched_priv, cpu); cpu_schedule_down(cpu); } @@ -2260,32 +2272,22 @@ static int cpu_schedule_callback( * allocating and initializing the per-pCPU scheduler specific data, * as well as "registering" this pCPU to the scheduler (which may * involve modifying some scheduler wide data structures). - * This happens by calling the alloc_pdata and init_pdata hooks, in - * this order. A scheduler that does not need to allocate any per-pCPU - * data can avoid implementing alloc_pdata. init_pdata may, however, be - * necessary/useful in this case too (e.g., it can contain the "register - * the pCPU to the scheduler" part). alloc_pdata (if present) is called - * during CPU_UP_PREPARE. init_pdata (if present) is called before - * CPU_STARTING in scheduler_percpu_init(). + * As new pCPUs always start as "free" cpus with the minimal idle + * scheduler being in charge, we don't need any of that. * * On the other hand, at teardown, we need to reverse what has been done - * during initialization, and then free the per-pCPU specific data. This - * happens by calling the deinit_pdata and free_pdata hooks, in this + * during initialization, and then free the per-pCPU specific data. A + * pCPU brought down is not forced through "free" cpus, so here we need to + * use the appropriate hooks. + * + * This happens by calling the deinit_pdata and free_pdata hooks, in this * order. If no per-pCPU memory was allocated, there is no need to * provide an implementation of free_pdata. deinit_pdata may, however, * be necessary/useful in this case too (e.g., it can undo something done * on scheduler wide data structure during init_pdata). Both deinit_pdata * and free_pdata are called during CPU_DEAD. * - * If someting goes wrong during bringup, we go to CPU_UP_CANCELLED - * *before* having called init_pdata. In this case, as there is no - * initialization needing undoing, only free_pdata should be called. - * This means it is possible to call free_pdata just after alloc_pdata, - * without a init_pdata/deinit_pdata "cycle" in between the two. - * - * So, in summary, the usage pattern should look either - * - alloc_pdata-->init_pdata-->deinit_pdata-->free_pdata, or - * - alloc_pdata-->free_pdata. + * If someting goes wrong during bringup, we go to CPU_UP_CANCELLED. */ switch ( action ) { @@ -2402,9 +2404,6 @@ void __init scheduler_init(void) BUG(); get_sched_res(0)->curr = idle_vcpu[0]->sched_unit; get_sched_res(0)->sched_unit_idle = idle_vcpu[0]->sched_unit; - get_sched_res(0)->sched_priv = sched_alloc_pdata(&ops, 0); - BUG_ON(IS_ERR(get_sched_res(0)->sched_priv)); - scheduler_percpu_init(0); } /* @@ -2412,18 +2411,14 @@ void __init scheduler_init(void) * cpupool, or subject it to the scheduler of a new cpupool. * * For the pCPUs that are removed from their cpupool, their scheduler becomes - * &ops (the default scheduler, selected at boot, which also services the - * default cpupool). However, as these pCPUs are not really part of any pool, - * there won't be any scheduling event on them, not even from the default - * scheduler. Basically, they will just sit idle until they are explicitly - * added back to a cpupool. + * &sched_idle_ops (the idle scheduler). */ int schedule_cpu_switch(unsigned int cpu, struct cpupool *c) { struct vcpu *idle; void *ppriv, *ppriv_old, *vpriv, *vpriv_old; struct scheduler *old_ops = get_sched_res(cpu)->scheduler; - struct scheduler *new_ops = (c == NULL) ? &ops : c->sched; + struct scheduler *new_ops = (c == NULL) ? &sched_idle_ops : c->sched; struct sched_resource *sd = get_sched_res(cpu); struct cpupool *old_pool = sd->cpupool; spinlock_t *old_lock, *new_lock; @@ -2443,9 +2438,6 @@ int schedule_cpu_switch(unsigned int cpu, struct cpupool *c) ASSERT((c == NULL && !cpumask_test_cpu(cpu, old_pool->cpu_valid)) || (c != NULL && !cpumask_test_cpu(cpu, c->cpu_valid))); - if ( old_ops == new_ops ) - goto out; - /* * To setup the cpu for the new scheduler we need: * - a valid instance of per-CPU scheduler specific data, as it is @@ -2498,7 +2490,7 @@ int schedule_cpu_switch(unsigned int cpu, struct cpupool *c) * taking it, finds all the initializations we've done above in place. */ smp_mb(); - sd->schedule_lock = c ? new_lock : &sched_free_cpu_lock; + sd->schedule_lock = new_lock; /* _Not_ pcpu_schedule_unlock(): schedule_lock may have changed! */ spin_unlock_irqrestore(old_lock, flags); @@ -2510,7 +2502,6 @@ int schedule_cpu_switch(unsigned int cpu, struct cpupool *c) sched_free_vdata(old_ops, vpriv_old); sched_free_pdata(old_ops, ppriv_old, cpu); - out: get_sched_res(cpu)->granularity = c ? c->granularity : 1; get_sched_res(cpu)->cpupool = c; /* When a cpu is added to a pool, trigger it to go pick up some work */ diff --git a/xen/include/xen/sched.h b/xen/include/xen/sched.h index 7dc63c449b..e689bba361 100644 --- a/xen/include/xen/sched.h +++ b/xen/include/xen/sched.h @@ -677,7 +677,6 @@ void __domain_crash(struct domain *d); void noreturn asm_domain_crash_synchronous(unsigned long addr); void scheduler_init(void); -void scheduler_percpu_init(unsigned int cpu); int sched_init_vcpu(struct vcpu *v); void sched_destroy_vcpu(struct vcpu *v); int sched_init_domain(struct domain *d, int poolid); -- 2.16.4 _______________________________________________ Xen-devel mailing list Xen-devel@lists.xenproject.org https://lists.xenproject.org/mailman/listinfo/xen-devel