From patchwork Tue Feb 28 11:52:02 2017 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Dario Faggioli X-Patchwork-Id: 9595303 Return-Path: Received: from mail.wl.linuxfoundation.org (pdx-wl-mail.web.codeaurora.org [172.30.200.125]) by pdx-korg-patchwork.web.codeaurora.org (Postfix) with ESMTP id C53D5601D7 for ; Tue, 28 Feb 2017 11:54:37 +0000 (UTC) Received: from mail.wl.linuxfoundation.org (localhost [127.0.0.1]) by mail.wl.linuxfoundation.org (Postfix) with ESMTP id B1E5427816 for ; Tue, 28 Feb 2017 11:54:37 +0000 (UTC) Received: by mail.wl.linuxfoundation.org (Postfix, from userid 486) id A55FC27F07; Tue, 28 Feb 2017 11:54:37 +0000 (UTC) X-Spam-Checker-Version: SpamAssassin 3.3.1 (2010-03-16) on pdx-wl-mail.web.codeaurora.org X-Spam-Level: X-Spam-Status: No, score=-3.6 required=2.0 tests=BAYES_00,DKIM_SIGNED, RCVD_IN_DNSWL_MED,RCVD_IN_SORBS_SPAM,T_DKIM_INVALID autolearn=ham version=3.3.1 Received: from lists.xenproject.org (lists.xenproject.org [192.237.175.120]) (using TLSv1.2 with cipher AES128-GCM-SHA256 (128/128 bits)) (No client certificate requested) by mail.wl.linuxfoundation.org (Postfix) with ESMTPS id 5FC4A27816 for ; Tue, 28 Feb 2017 11:54:36 +0000 (UTC) Received: from localhost ([127.0.0.1] helo=lists.xenproject.org) by lists.xenproject.org with esmtp (Exim 4.84_2) (envelope-from ) id 1cigK8-00012J-Dn; Tue, 28 Feb 2017 11:52:08 +0000 Received: from mail6.bemta5.messagelabs.com ([195.245.231.135]) by lists.xenproject.org with esmtp (Exim 4.84_2) (envelope-from ) id 1cigK6-000129-Ns for xen-devel@lists.xenproject.org; Tue, 28 Feb 2017 11:52:06 +0000 Received: from [85.158.139.211] by server-4.bemta-5.messagelabs.com id FF/AF-20656-66465B85; Tue, 28 Feb 2017 11:52:06 +0000 X-Brightmail-Tracker: H4sIAAAAAAAAA+NgFmplleJIrShJLcpLzFFi42K5GNpwRDc1ZWu Ewep1bBbft0xmcmD0OPzhCksAYxRrZl5SfkUCa8buPdtZCo5MZ6xo7LjD1sB4v6KLkYtDSGAG o8T7WbuYQBwWgTWsEitnPwdzJAQusUrMb5jI1sXICeTESGzY/BvKrpLYvu42M4gtJKAicXP7K iaIUT8ZJW7eeQ9WJCygJ3Hk6A92CDte4sHEWywgNpuAgcSbHXtZQWwRASWJe6smgzUzCyxnlJ g36QgjSIJFQFVi56PzYDavgLfE6h+HgIZycHAK+Egsv2EBYgoBhbc9jgWpEBWQk1h5uYUVolp Q4uTMJywgJcwCmhLrd+mDhJkF5CW2v53DPIFRZBaSqlkIVbOQVC1gZF7FqFGcWlSWWqRrZKiX VJSZnlGSm5iZo2toYKqXm1pcnJiempOYVKyXnJ+7iREYAfUMDIw7GO9O9jvEKMnBpCTKe/TRl gghvqT8lMqMxOKM+KLSnNTiQ4waHBwCE87Onc4kxZKXn5eqJMErn7w1QkiwKDU9tSItMwcYoz ClEhw8SiK8P5KA0rzFBYm5xZnpEKlTjMYcD07tesPE8an/8BsmIbBJUuK8L0FKBUBKM0rz4Ab BUsclRlkpYV5GBgYGIZ6C1KLczBJU+VeM4hyMSsK8vSD38GTmlcDtewV0ChPQKS9UwE4pSURI STUw6vPdW+quxtCjmT05vfoH3+mJ4etnrNKfW8AWWNl6tLx/deokoedROydP///i9NR33Fr+d yamL/13Olh4xeMo0RRjxRXln6Wnp0+I53zAXGdn9//f/M2J5dEM7D5i0wKttriKTXWb0pFZs5 5F5XrBbYYuts7sl3tvJAr2fplpvFVkAU/3q/t1SizFGYmGWsxFxYkACtqzPRgDAAA= X-Env-Sender: raistlin.df@gmail.com X-Msg-Ref: server-2.tower-206.messagelabs.com!1488282724!66468342!1 X-Originating-IP: [209.85.128.196] X-SpamReason: No, hits=0.5 required=7.0 tests=BODY_RANDOM_LONG X-StarScan-Received: X-StarScan-Version: 9.2.3; banners=-,-,- X-VirusChecked: Checked Received: (qmail 65183 invoked from network); 28 Feb 2017 11:52:05 -0000 Received: from mail-wr0-f196.google.com (HELO mail-wr0-f196.google.com) (209.85.128.196) by server-2.tower-206.messagelabs.com with AES128-GCM-SHA256 encrypted SMTP; 28 Feb 2017 11:52:05 -0000 Received: by mail-wr0-f196.google.com with SMTP id l37so1311141wrc.3 for ; Tue, 28 Feb 2017 03:52:05 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20161025; h=sender:subject:from:to:cc:date:message-id:in-reply-to:references :user-agent:mime-version:content-transfer-encoding; bh=mnXR/ouoA6ABPiMfvfj17L3gvl65+adzcaxtTGdf5gE=; b=u5Jype4X24JQiXayMyWUMEg2I0JsHd2sUFHUtrnWxwaBRun0TvSIV7hkH7753bhIk/ aHUDCG3b0my5d39n2/cqaFmUYf52Dzn0Wb0Cho9xRw7i7Fu6gkkIXvWN2uoidPSxnVZv Czou/1qZwa6zq1MJTCQsINWrbLIai/nE65GC4do3BA8F0Q69EGKGsogDoc4Jbc/Trz36 UUuSbrFQV+txwp3vQ3yt1KC0fO9Hox9ZFwlNbk1+LP/6sSrRU3xNBHbjZyBotoOzBSYE 4gCPbW3v9nOffIoian14lsx2bMMiAsDJIciGO2jqeKWS0eV6j6Nw8fun/PsSGm97cMRi i2XQ== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:sender:subject:from:to:cc:date:message-id :in-reply-to:references:user-agent:mime-version :content-transfer-encoding; bh=mnXR/ouoA6ABPiMfvfj17L3gvl65+adzcaxtTGdf5gE=; b=jpOD3Qu51SFkJfsTFK7Z5PMUlpuO05jhOA0M/odQuR3lZpow4zKZSgsQvjCLny/AOk 4KVVktmVFBlSY4DlcfExJYfg4cWgVjqBN98aOTguFmiitmGwbckCy4MM9pDcNEHjSgiP 8MiIZ+TC2p2d4BBKy02odYp8d6MODghQT18AP6K7cH3WNmuRpO2iE25VIeEhTG5SMry2 DcM1G3HzepzTFtwuyv0EqSvdLDXQJLTN4eOi4qiOBLSI4F35m6AkS4cebPdti3099kf5 bUpI6lLSCPjEEsPQlaotHmTBckT8vtFOEAKErwiy9zyNiq8adChYGhlARPzo5BbJPLT7 x/kg== X-Gm-Message-State: AMke39nUGmZOq5eqM2EPmJhdEyotQwNtktl/r33rS17mDdrhNPeFiNXr8T1LPSNOQyawPA== X-Received: by 10.223.174.165 with SMTP id y34mr2012055wrc.40.1488282724632; Tue, 28 Feb 2017 03:52:04 -0800 (PST) Received: from Solace.fritz.box ([80.66.223.93]) by smtp.gmail.com with ESMTPSA id j80sm2360898wmd.14.2017.02.28.03.52.03 (version=TLS1_2 cipher=ECDHE-RSA-AES128-GCM-SHA256 bits=128/128); Tue, 28 Feb 2017 03:52:03 -0800 (PST) From: Dario Faggioli To: xen-devel@lists.xenproject.org Date: Tue, 28 Feb 2017 12:52:02 +0100 Message-ID: <148828272157.26730.2501581028817640720.stgit@Solace.fritz.box> In-Reply-To: <148828109243.26730.2771577013485070217.stgit@Solace.fritz.box> References: <148828109243.26730.2771577013485070217.stgit@Solace.fritz.box> User-Agent: StGit/0.17.1-dirty MIME-Version: 1.0 Cc: George Dunlap , Andrew Cooper , Anshul Makkar , Jan Beulich Subject: [Xen-devel] [PATCH v3 1/7] xen: credit2: make accessor helpers inline functions instead of macros X-BeenThere: xen-devel@lists.xen.org X-Mailman-Version: 2.1.18 Precedence: list List-Id: Xen developer discussion List-Unsubscribe: , List-Post: List-Help: List-Subscribe: , Errors-To: xen-devel-bounces@lists.xen.org Sender: "Xen-devel" X-Virus-Scanned: ClamAV using ClamSMTP There isn't any particular reason for the accessor helpers to be macro, so turn them into 'static inline'-s, which are better. Note that it is necessary to move the function definitions below the structure declarations. No functional change intended. Signed-off-by: Dario Faggioli --- Cc: George Dunlap Cc: Anshul Makkar Cc: Andrew Cooper Cc: Jan Beulich --- Changes from v2: * plain 'inline' instead of 'always_inline', as requested during review; * 'unsigned int' instead of just 'unisgned', as requested during review; * constified more, as suggested during review; * killed pointless parantheses, as suggested during review. --- xen/common/sched_credit2.c | 153 +++++++++++++++++++++++++------------------- 1 file changed, 86 insertions(+), 67 deletions(-) diff --git a/xen/common/sched_credit2.c b/xen/common/sched_credit2.c index b12d038..939c37b 100644 --- a/xen/common/sched_credit2.c +++ b/xen/common/sched_credit2.c @@ -208,18 +208,6 @@ static unsigned int __read_mostly opt_migrate_resist = 500; integer_param("sched_credit2_migrate_resist", opt_migrate_resist); /* - * Useful macros - */ -#define CSCHED2_PRIV(_ops) \ - ((struct csched2_private *)((_ops)->sched_data)) -#define CSCHED2_VCPU(_vcpu) ((struct csched2_vcpu *) (_vcpu)->sched_priv) -#define CSCHED2_DOM(_dom) ((struct csched2_dom *) (_dom)->sched_priv) -/* CPU to runq_id macro */ -#define c2r(_ops, _cpu) (CSCHED2_PRIV(_ops)->runq_map[(_cpu)]) -/* CPU to runqueue struct macro */ -#define RQD(_ops, _cpu) (&CSCHED2_PRIV(_ops)->rqd[c2r(_ops, _cpu)]) - -/* * Load tracking and load balancing * * Load history of runqueues and vcpus is accounted for by using an @@ -440,6 +428,37 @@ struct csched2_dom { }; /* + * Accessor helpers functions. + */ +static inline struct csched2_private *csched2_priv(const struct scheduler *ops) +{ + return ops->sched_data; +} + +static inline struct csched2_vcpu *csched2_vcpu(const struct vcpu *v) +{ + return v->sched_priv; +} + +static inline struct csched2_dom *csched2_dom(const struct domain *d) +{ + return d->sched_priv; +} + +/* CPU to runq_id macro */ +static inline int c2r(const struct scheduler *ops, unsigned int cpu) +{ + return csched2_priv(ops)->runq_map[(cpu)]; +} + +/* CPU to runqueue struct macro */ +static inline struct csched2_runqueue_data *c2rqd(const struct scheduler *ops, + unsigned int cpu) +{ + return &csched2_priv(ops)->rqd[c2r(ops, cpu)]; +} + +/* * Hyperthreading (SMT) support. * * We use a special per-runq mask (smt_idle) and update it according to the @@ -693,7 +712,7 @@ static void __update_runq_load(const struct scheduler *ops, struct csched2_runqueue_data *rqd, int change, s_time_t now) { - struct csched2_private *prv = CSCHED2_PRIV(ops); + struct csched2_private *prv = csched2_priv(ops); s_time_t delta, load = rqd->load; unsigned int P, W; @@ -780,7 +799,7 @@ static void __update_svc_load(const struct scheduler *ops, struct csched2_vcpu *svc, int change, s_time_t now) { - struct csched2_private *prv = CSCHED2_PRIV(ops); + struct csched2_private *prv = csched2_priv(ops); s_time_t delta, vcpu_load; unsigned int P, W; @@ -877,7 +896,7 @@ static void runq_insert(const struct scheduler *ops, struct csched2_vcpu *svc) { unsigned int cpu = svc->vcpu->processor; - struct list_head * runq = &RQD(ops, cpu)->runq; + struct list_head * runq = &c2rqd(ops, cpu)->runq; int pos = 0; ASSERT(spin_is_locked(per_cpu(schedule_data, cpu).schedule_lock)); @@ -935,7 +954,7 @@ runq_tickle(const struct scheduler *ops, struct csched2_vcpu *new, s_time_t now) int i, ipid = -1; s_time_t lowest = (1<<30); unsigned int cpu = new->vcpu->processor; - struct csched2_runqueue_data *rqd = RQD(ops, cpu); + struct csched2_runqueue_data *rqd = c2rqd(ops, cpu); cpumask_t mask; struct csched2_vcpu * cur; @@ -1006,7 +1025,7 @@ runq_tickle(const struct scheduler *ops, struct csched2_vcpu *new, s_time_t now) cpumask_and(&mask, &mask, cpumask_scratch_cpu(cpu)); if ( __cpumask_test_and_clear_cpu(cpu, &mask) ) { - cur = CSCHED2_VCPU(curr_on_cpu(cpu)); + cur = csched2_vcpu(curr_on_cpu(cpu)); burn_credits(rqd, cur, now); if ( cur->credit < new->credit ) @@ -1022,7 +1041,7 @@ runq_tickle(const struct scheduler *ops, struct csched2_vcpu *new, s_time_t now) /* Already looked at this one above */ ASSERT(i != cpu); - cur = CSCHED2_VCPU(curr_on_cpu(i)); + cur = csched2_vcpu(curr_on_cpu(i)); /* * Even if the cpu is not in rqd->idle, it may be running the @@ -1095,7 +1114,7 @@ runq_tickle(const struct scheduler *ops, struct csched2_vcpu *new, s_time_t now) static void reset_credit(const struct scheduler *ops, int cpu, s_time_t now, struct csched2_vcpu *snext) { - struct csched2_runqueue_data *rqd = RQD(ops, cpu); + struct csched2_runqueue_data *rqd = c2rqd(ops, cpu); struct list_head *iter; int m; @@ -1173,7 +1192,7 @@ void burn_credits(struct csched2_runqueue_data *rqd, { s_time_t delta; - ASSERT(svc == CSCHED2_VCPU(curr_on_cpu(svc->vcpu->processor))); + ASSERT(svc == csched2_vcpu(curr_on_cpu(svc->vcpu->processor))); if ( unlikely(is_idle_vcpu(svc->vcpu)) ) { @@ -1260,11 +1279,11 @@ static void update_max_weight(struct csched2_runqueue_data *rqd, int new_weight, static /*inline*/ void __csched2_vcpu_check(struct vcpu *vc) { - struct csched2_vcpu * const svc = CSCHED2_VCPU(vc); + struct csched2_vcpu * const svc = csched2_vcpu(vc); struct csched2_dom * const sdom = svc->sdom; BUG_ON( svc->vcpu != vc ); - BUG_ON( sdom != CSCHED2_DOM(vc->domain) ); + BUG_ON( sdom != csched2_dom(vc->domain) ); if ( sdom ) { BUG_ON( is_idle_vcpu(vc) ); @@ -1304,7 +1323,7 @@ csched2_alloc_vdata(const struct scheduler *ops, struct vcpu *vc, void *dd) svc->credit = CSCHED2_CREDIT_INIT; svc->weight = svc->sdom->weight; /* Starting load of 50% */ - svc->avgload = 1ULL << (CSCHED2_PRIV(ops)->load_precision_shift - 1); + svc->avgload = 1ULL << (csched2_priv(ops)->load_precision_shift - 1); svc->load_last_update = NOW() >> LOADAVG_GRANULARITY_SHIFT; } else @@ -1356,7 +1375,7 @@ runq_assign(const struct scheduler *ops, struct vcpu *vc) ASSERT(svc->rqd == NULL); - __runq_assign(svc, RQD(ops, vc->processor)); + __runq_assign(svc, c2rqd(ops, vc->processor)); } static void @@ -1381,7 +1400,7 @@ runq_deassign(const struct scheduler *ops, struct vcpu *vc) { struct csched2_vcpu *svc = vc->sched_priv; - ASSERT(svc->rqd == RQD(ops, vc->processor)); + ASSERT(svc->rqd == c2rqd(ops, vc->processor)); __runq_deassign(svc); } @@ -1389,7 +1408,7 @@ runq_deassign(const struct scheduler *ops, struct vcpu *vc) static void csched2_vcpu_sleep(const struct scheduler *ops, struct vcpu *vc) { - struct csched2_vcpu * const svc = CSCHED2_VCPU(vc); + struct csched2_vcpu * const svc = csched2_vcpu(vc); ASSERT(!is_idle_vcpu(vc)); SCHED_STAT_CRANK(vcpu_sleep); @@ -1398,7 +1417,7 @@ csched2_vcpu_sleep(const struct scheduler *ops, struct vcpu *vc) cpu_raise_softirq(vc->processor, SCHEDULE_SOFTIRQ); else if ( __vcpu_on_runq(svc) ) { - ASSERT(svc->rqd == RQD(ops, vc->processor)); + ASSERT(svc->rqd == c2rqd(ops, vc->processor)); update_load(ops, svc->rqd, svc, -1, NOW()); __runq_remove(svc); } @@ -1409,7 +1428,7 @@ csched2_vcpu_sleep(const struct scheduler *ops, struct vcpu *vc) static void csched2_vcpu_wake(const struct scheduler *ops, struct vcpu *vc) { - struct csched2_vcpu * const svc = CSCHED2_VCPU(vc); + struct csched2_vcpu * const svc = csched2_vcpu(vc); unsigned int cpu = vc->processor; s_time_t now; @@ -1447,7 +1466,7 @@ csched2_vcpu_wake(const struct scheduler *ops, struct vcpu *vc) if ( svc->rqd == NULL ) runq_assign(ops, vc); else - ASSERT(RQD(ops, vc->processor) == svc->rqd ); + ASSERT(c2rqd(ops, vc->processor) == svc->rqd ); now = NOW(); @@ -1464,7 +1483,7 @@ out: static void csched2_vcpu_yield(const struct scheduler *ops, struct vcpu *v) { - struct csched2_vcpu * const svc = CSCHED2_VCPU(v); + struct csched2_vcpu * const svc = csched2_vcpu(v); __set_bit(__CSFLAG_vcpu_yield, &svc->flags); } @@ -1472,12 +1491,12 @@ csched2_vcpu_yield(const struct scheduler *ops, struct vcpu *v) static void csched2_context_saved(const struct scheduler *ops, struct vcpu *vc) { - struct csched2_vcpu * const svc = CSCHED2_VCPU(vc); + struct csched2_vcpu * const svc = csched2_vcpu(vc); spinlock_t *lock = vcpu_schedule_lock_irq(vc); s_time_t now = NOW(); - BUG_ON( !is_idle_vcpu(vc) && svc->rqd != RQD(ops, vc->processor)); - ASSERT(is_idle_vcpu(vc) || svc->rqd == RQD(ops, vc->processor)); + BUG_ON( !is_idle_vcpu(vc) && svc->rqd != c2rqd(ops, vc->processor)); + ASSERT(is_idle_vcpu(vc) || svc->rqd == c2rqd(ops, vc->processor)); /* This vcpu is now eligible to be put on the runqueue again */ __clear_bit(__CSFLAG_scheduled, &svc->flags); @@ -1508,9 +1527,9 @@ csched2_context_saved(const struct scheduler *ops, struct vcpu *vc) static int csched2_cpu_pick(const struct scheduler *ops, struct vcpu *vc) { - struct csched2_private *prv = CSCHED2_PRIV(ops); + struct csched2_private *prv = csched2_priv(ops); int i, min_rqi = -1, new_cpu, cpu = vc->processor; - struct csched2_vcpu *svc = CSCHED2_VCPU(vc); + struct csched2_vcpu *svc = csched2_vcpu(vc); s_time_t min_avgload = MAX_LOAD; ASSERT(!cpumask_empty(&prv->active_queues)); @@ -1773,7 +1792,7 @@ static bool_t vcpu_is_migrateable(struct csched2_vcpu *svc, static void balance_load(const struct scheduler *ops, int cpu, s_time_t now) { - struct csched2_private *prv = CSCHED2_PRIV(ops); + struct csched2_private *prv = csched2_priv(ops); int i, max_delta_rqi = -1; struct list_head *push_iter, *pull_iter; bool_t inner_load_updated = 0; @@ -1788,7 +1807,7 @@ static void balance_load(const struct scheduler *ops, int cpu, s_time_t now) */ ASSERT(spin_is_locked(per_cpu(schedule_data, cpu).schedule_lock)); - st.lrqd = RQD(ops, cpu); + st.lrqd = c2rqd(ops, cpu); __update_runq_load(ops, st.lrqd, 0, now); @@ -1961,7 +1980,7 @@ csched2_vcpu_migrate( const struct scheduler *ops, struct vcpu *vc, unsigned int new_cpu) { struct domain *d = vc->domain; - struct csched2_vcpu * const svc = CSCHED2_VCPU(vc); + struct csched2_vcpu * const svc = csched2_vcpu(vc); struct csched2_runqueue_data *trqd; s_time_t now = NOW(); @@ -1994,10 +2013,10 @@ csched2_vcpu_migrate( } /* If here, new_cpu must be a valid Credit2 pCPU, and in our affinity. */ - ASSERT(cpumask_test_cpu(new_cpu, &CSCHED2_PRIV(ops)->initialized)); + ASSERT(cpumask_test_cpu(new_cpu, &csched2_priv(ops)->initialized)); ASSERT(cpumask_test_cpu(new_cpu, vc->cpu_hard_affinity)); - trqd = RQD(ops, new_cpu); + trqd = c2rqd(ops, new_cpu); /* * Do the actual movement toward new_cpu, and update vc->processor. @@ -2019,8 +2038,8 @@ csched2_dom_cntl( struct domain *d, struct xen_domctl_scheduler_op *op) { - struct csched2_dom * const sdom = CSCHED2_DOM(d); - struct csched2_private *prv = CSCHED2_PRIV(ops); + struct csched2_dom * const sdom = csched2_dom(d); + struct csched2_private *prv = csched2_priv(ops); unsigned long flags; int rc = 0; @@ -2053,10 +2072,10 @@ csched2_dom_cntl( /* Update weights for vcpus, and max_weight for runqueues on which they reside */ for_each_vcpu ( d, v ) { - struct csched2_vcpu *svc = CSCHED2_VCPU(v); + struct csched2_vcpu *svc = csched2_vcpu(v); spinlock_t *lock = vcpu_schedule_lock(svc->vcpu); - ASSERT(svc->rqd == RQD(ops, svc->vcpu->processor)); + ASSERT(svc->rqd == c2rqd(ops, svc->vcpu->processor)); svc->weight = sdom->weight; update_max_weight(svc->rqd, svc->weight, old_weight); @@ -2080,7 +2099,7 @@ static int csched2_sys_cntl(const struct scheduler *ops, struct xen_sysctl_scheduler_op *sc) { xen_sysctl_credit2_schedule_t *params = &sc->u.sched_credit2; - struct csched2_private *prv = CSCHED2_PRIV(ops); + struct csched2_private *prv = csched2_priv(ops); unsigned long flags; switch (sc->cmd ) @@ -2111,7 +2130,7 @@ static int csched2_sys_cntl(const struct scheduler *ops, static void * csched2_alloc_domdata(const struct scheduler *ops, struct domain *dom) { - struct csched2_private *prv = CSCHED2_PRIV(ops); + struct csched2_private *prv = csched2_priv(ops); struct csched2_dom *sdom; unsigned long flags; @@ -2127,7 +2146,7 @@ csched2_alloc_domdata(const struct scheduler *ops, struct domain *dom) write_lock_irqsave(&prv->lock, flags); - list_add_tail(&sdom->sdom_elem, &CSCHED2_PRIV(ops)->sdom); + list_add_tail(&sdom->sdom_elem, &csched2_priv(ops)->sdom); write_unlock_irqrestore(&prv->lock, flags); @@ -2156,7 +2175,7 @@ csched2_free_domdata(const struct scheduler *ops, void *data) { unsigned long flags; struct csched2_dom *sdom = data; - struct csched2_private *prv = CSCHED2_PRIV(ops); + struct csched2_private *prv = csched2_priv(ops); write_lock_irqsave(&prv->lock, flags); @@ -2170,9 +2189,9 @@ csched2_free_domdata(const struct scheduler *ops, void *data) static void csched2_dom_destroy(const struct scheduler *ops, struct domain *dom) { - ASSERT(CSCHED2_DOM(dom)->nr_vcpus == 0); + ASSERT(csched2_dom(dom)->nr_vcpus == 0); - csched2_free_domdata(ops, CSCHED2_DOM(dom)); + csched2_free_domdata(ops, csched2_dom(dom)); } static void @@ -2217,7 +2236,7 @@ csched2_free_vdata(const struct scheduler *ops, void *priv) static void csched2_vcpu_remove(const struct scheduler *ops, struct vcpu *vc) { - struct csched2_vcpu * const svc = CSCHED2_VCPU(vc); + struct csched2_vcpu * const svc = csched2_vcpu(vc); spinlock_t *lock; ASSERT(!is_idle_vcpu(vc)); @@ -2242,9 +2261,9 @@ csched2_runtime(const struct scheduler *ops, int cpu, { s_time_t time, min_time; int rt_credit; /* Proposed runtime measured in credits */ - struct csched2_runqueue_data *rqd = RQD(ops, cpu); + struct csched2_runqueue_data *rqd = c2rqd(ops, cpu); struct list_head *runq = &rqd->runq; - struct csched2_private *prv = CSCHED2_PRIV(ops); + struct csched2_private *prv = csched2_priv(ops); /* * If we're idle, just stay so. Others (or external events) @@ -2333,7 +2352,7 @@ runq_candidate(struct csched2_runqueue_data *rqd, { struct list_head *iter; struct csched2_vcpu *snext = NULL; - struct csched2_private *prv = CSCHED2_PRIV(per_cpu(scheduler, cpu)); + struct csched2_private *prv = csched2_priv(per_cpu(scheduler, cpu)); bool yield = __test_and_clear_bit(__CSFLAG_vcpu_yield, &scurr->flags); *skipped = 0; @@ -2372,7 +2391,7 @@ runq_candidate(struct csched2_runqueue_data *rqd, if ( vcpu_runnable(scurr->vcpu) ) snext = scurr; else - snext = CSCHED2_VCPU(idle_vcpu[cpu]); + snext = csched2_vcpu(idle_vcpu[cpu]); list_for_each( iter, &rqd->runq ) { @@ -2452,7 +2471,7 @@ csched2_schedule( { const int cpu = smp_processor_id(); struct csched2_runqueue_data *rqd; - struct csched2_vcpu * const scurr = CSCHED2_VCPU(current); + struct csched2_vcpu * const scurr = csched2_vcpu(current); struct csched2_vcpu *snext = NULL; unsigned int skipped_vcpus = 0; struct task_slice ret; @@ -2461,9 +2480,9 @@ csched2_schedule( SCHED_STAT_CRANK(schedule); CSCHED2_VCPU_CHECK(current); - BUG_ON(!cpumask_test_cpu(cpu, &CSCHED2_PRIV(ops)->initialized)); + BUG_ON(!cpumask_test_cpu(cpu, &csched2_priv(ops)->initialized)); - rqd = RQD(ops, cpu); + rqd = c2rqd(ops, cpu); BUG_ON(!cpumask_test_cpu(cpu, &rqd->active)); ASSERT(spin_is_locked(per_cpu(schedule_data, cpu).schedule_lock)); @@ -2521,7 +2540,7 @@ csched2_schedule( { __clear_bit(__CSFLAG_vcpu_yield, &scurr->flags); trace_var(TRC_CSCHED2_SCHED_TASKLET, 1, 0, NULL); - snext = CSCHED2_VCPU(idle_vcpu[cpu]); + snext = csched2_vcpu(idle_vcpu[cpu]); } else snext = runq_candidate(rqd, scurr, cpu, now, &skipped_vcpus); @@ -2642,7 +2661,7 @@ csched2_dump_vcpu(struct csched2_private *prv, struct csched2_vcpu *svc) static inline void dump_pcpu(const struct scheduler *ops, int cpu) { - struct csched2_private *prv = CSCHED2_PRIV(ops); + struct csched2_private *prv = csched2_priv(ops); struct csched2_vcpu *svc; #define cpustr keyhandler_scratch @@ -2652,7 +2671,7 @@ dump_pcpu(const struct scheduler *ops, int cpu) printk("core=%s\n", cpustr); /* current VCPU (nothing to say if that's the idle vcpu) */ - svc = CSCHED2_VCPU(curr_on_cpu(cpu)); + svc = csched2_vcpu(curr_on_cpu(cpu)); if ( svc && !is_idle_vcpu(svc->vcpu) ) { printk("\trun: "); @@ -2665,7 +2684,7 @@ static void csched2_dump(const struct scheduler *ops) { struct list_head *iter_sdom; - struct csched2_private *prv = CSCHED2_PRIV(ops); + struct csched2_private *prv = csched2_priv(ops); unsigned long flags; unsigned int i, j, loop; #define cpustr keyhandler_scratch @@ -2725,7 +2744,7 @@ csched2_dump(const struct scheduler *ops) for_each_vcpu( sdom->dom, v ) { - struct csched2_vcpu * const svc = CSCHED2_VCPU(v); + struct csched2_vcpu * const svc = csched2_vcpu(v); spinlock_t *lock; lock = vcpu_schedule_lock(svc->vcpu); @@ -2896,7 +2915,7 @@ init_pdata(struct csched2_private *prv, unsigned int cpu) static void csched2_init_pdata(const struct scheduler *ops, void *pdata, int cpu) { - struct csched2_private *prv = CSCHED2_PRIV(ops); + struct csched2_private *prv = csched2_priv(ops); spinlock_t *old_lock; unsigned long flags; unsigned rqi; @@ -2924,7 +2943,7 @@ static void csched2_switch_sched(struct scheduler *new_ops, unsigned int cpu, void *pdata, void *vdata) { - struct csched2_private *prv = CSCHED2_PRIV(new_ops); + struct csched2_private *prv = csched2_priv(new_ops); struct csched2_vcpu *svc = vdata; unsigned rqi; @@ -2971,7 +2990,7 @@ static void csched2_deinit_pdata(const struct scheduler *ops, void *pcpu, int cpu) { unsigned long flags; - struct csched2_private *prv = CSCHED2_PRIV(ops); + struct csched2_private *prv = csched2_priv(ops); struct csched2_runqueue_data *rqd; int rqi; @@ -3080,7 +3099,7 @@ csched2_deinit(struct scheduler *ops) { struct csched2_private *prv; - prv = CSCHED2_PRIV(ops); + prv = csched2_priv(ops); ops->sched_data = NULL; xfree(prv); }