From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1752062AbcFVHFj (ORCPT ); Wed, 22 Jun 2016 03:05:39 -0400 Received: from mx2.suse.de ([195.135.220.15]:52368 "EHLO mx2.suse.de" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1751002AbcFVHEo (ORCPT ); Wed, 22 Jun 2016 03:04:44 -0400 From: Juergen Gross To: xen-devel@lists.xenproject.org, linux-kernel@vger.kernel.org Cc: sstabellini@kernel.org, boris.ostrovsky@oracle.com, david.vrabel@citrix.com, Juergen Gross Subject: [PATCH 3/3] xen: support runqueue steal time on xen Date: Wed, 22 Jun 2016 09:03:54 +0200 Message-Id: <1466579034-12113-4-git-send-email-jgross@suse.com> X-Mailer: git-send-email 2.6.6 In-Reply-To: <1466579034-12113-1-git-send-email-jgross@suse.com> References: <1466579034-12113-1-git-send-email-jgross@suse.com> Sender: linux-kernel-owner@vger.kernel.org List-ID: X-Mailing-List: linux-kernel@vger.kernel.org Up to now reading the stolen time of a remote cpu was not possible in a performant way under Xen. This made support of runqueue steal time via paravirt_steal_rq_enabled impossible. With the addition of an appropriate hypervisor interface this is now possible, so add the support. Signed-off-by: Juergen Gross --- drivers/xen/time.c | 42 +++++++++++++++++++++++++----------------- 1 file changed, 25 insertions(+), 17 deletions(-) diff --git a/drivers/xen/time.c b/drivers/xen/time.c index 2257b66..65afbe9 100644 --- a/drivers/xen/time.c +++ b/drivers/xen/time.c @@ -19,6 +19,9 @@ /* runstate info updated by Xen */ static DEFINE_PER_CPU(struct vcpu_runstate_info, xen_runstate); +/* runstate info of remote cpu accessible */ +static bool xen_runstate_remote; + /* return an consistent snapshot of 64-bit time/counter value */ static u64 get64(const u64 *p) { @@ -47,27 +50,31 @@ static u64 get64(const u64 *p) return ret; } -/* - * Runstate accounting - */ -void xen_get_runstate_snapshot(struct vcpu_runstate_info *res) +static void xen_get_runstate_snapshot_cpu(struct vcpu_runstate_info *res, + unsigned int cpu) { u64 state_time; struct vcpu_runstate_info *state; BUG_ON(preemptible()); - state = this_cpu_ptr(&xen_runstate); + state = per_cpu_ptr(&xen_runstate, cpu); - /* - * The runstate info is always updated by the hypervisor on - * the current CPU, so there's no need to use anything - * stronger than a compiler barrier when fetching it. - */ do { state_time = get64(&state->state_entry_time); + rmb(); /* Hypervisor might update data. */ *res = READ_ONCE(*state); - } while (get64(&state->state_entry_time) != state_time); + rmb(); /* Hypervisor might update data. */ + } while (get64(&state->state_entry_time) != state_time || + (state_time & XEN_RUNSTATE_UPDATE)); +} + +/* + * Runstate accounting + */ +void xen_get_runstate_snapshot(struct vcpu_runstate_info *res) +{ + xen_get_runstate_snapshot_cpu(res, smp_processor_id()); } /* return true when a vcpu could run but has no real cpu to run on */ @@ -80,8 +87,8 @@ static u64 xen_steal_clock(int cpu) { struct vcpu_runstate_info state; - BUG_ON(cpu != smp_processor_id()); - xen_get_runstate_snapshot(&state); + BUG_ON(!xen_runstate_remote && cpu != smp_processor_id()); + xen_get_runstate_snapshot_cpu(&state, cpu); return state.time[RUNSTATE_runnable] + state.time[RUNSTATE_offline]; } @@ -98,11 +105,12 @@ void xen_setup_runstate_info(int cpu) void __init xen_time_setup_guest(void) { + xen_runstate_remote = !HYPERVISOR_vm_assist(VMASST_CMD_enable, + VMASST_TYPE_runstate_update_flag); + pv_time_ops.steal_clock = xen_steal_clock; static_key_slow_inc(¶virt_steal_enabled); - /* - * We can't set paravirt_steal_rq_enabled as this would require the - * capability to read another cpu's runstate info. - */ + if (xen_runstate_remote) + static_key_slow_inc(¶virt_steal_rq_enabled); } -- 2.6.6 From mboxrd@z Thu Jan 1 00:00:00 1970 From: Juergen Gross Subject: [PATCH 3/3] xen: support runqueue steal time on xen Date: Wed, 22 Jun 2016 09:03:54 +0200 Message-ID: <1466579034-12113-4-git-send-email-jgross@suse.com> References: <1466579034-12113-1-git-send-email-jgross@suse.com> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Return-path: Received: from mail6.bemta5.messagelabs.com ([195.245.231.135]) by lists.xenproject.org with esmtp (Exim 4.84_2) (envelope-from ) id 1bFcCj-0004d8-AG for xen-devel@lists.xenproject.org; Wed, 22 Jun 2016 07:04:05 +0000 In-Reply-To: <1466579034-12113-1-git-send-email-jgross@suse.com> List-Unsubscribe: , List-Post: List-Help: List-Subscribe: , Errors-To: xen-devel-bounces@lists.xen.org Sender: "Xen-devel" To: xen-devel@lists.xenproject.org, linux-kernel@vger.kernel.org Cc: Juergen Gross , boris.ostrovsky@oracle.com, sstabellini@kernel.org, david.vrabel@citrix.com List-Id: xen-devel@lists.xenproject.org VXAgdG8gbm93IHJlYWRpbmcgdGhlIHN0b2xlbiB0aW1lIG9mIGEgcmVtb3RlIGNwdSB3YXMgbm90 IHBvc3NpYmxlIGluIGEKcGVyZm9ybWFudCB3YXkgdW5kZXIgWGVuLiBUaGlzIG1hZGUgc3VwcG9y dCBvZiBydW5xdWV1ZSBzdGVhbCB0aW1lIHZpYQpwYXJhdmlydF9zdGVhbF9ycV9lbmFibGVkIGlt cG9zc2libGUuCgpXaXRoIHRoZSBhZGRpdGlvbiBvZiBhbiBhcHByb3ByaWF0ZSBoeXBlcnZpc29y IGludGVyZmFjZSB0aGlzIGlzIG5vdwpwb3NzaWJsZSwgc28gYWRkIHRoZSBzdXBwb3J0LgoKU2ln bmVkLW9mZi1ieTogSnVlcmdlbiBHcm9zcyA8amdyb3NzQHN1c2UuY29tPgotLS0KIGRyaXZlcnMv eGVuL3RpbWUuYyB8IDQyICsrKysrKysrKysrKysrKysrKysrKysrKystLS0tLS0tLS0tLS0tLS0t LQogMSBmaWxlIGNoYW5nZWQsIDI1IGluc2VydGlvbnMoKyksIDE3IGRlbGV0aW9ucygtKQoKZGlm ZiAtLWdpdCBhL2RyaXZlcnMveGVuL3RpbWUuYyBiL2RyaXZlcnMveGVuL3RpbWUuYwppbmRleCAy MjU3YjY2Li42NWFmYmU5IDEwMDY0NAotLS0gYS9kcml2ZXJzL3hlbi90aW1lLmMKKysrIGIvZHJp dmVycy94ZW4vdGltZS5jCkBAIC0xOSw2ICsxOSw5IEBACiAvKiBydW5zdGF0ZSBpbmZvIHVwZGF0 ZWQgYnkgWGVuICovCiBzdGF0aWMgREVGSU5FX1BFUl9DUFUoc3RydWN0IHZjcHVfcnVuc3RhdGVf aW5mbywgeGVuX3J1bnN0YXRlKTsKIAorLyogcnVuc3RhdGUgaW5mbyBvZiByZW1vdGUgY3B1IGFj Y2Vzc2libGUgKi8KK3N0YXRpYyBib29sIHhlbl9ydW5zdGF0ZV9yZW1vdGU7CisKIC8qIHJldHVy biBhbiBjb25zaXN0ZW50IHNuYXBzaG90IG9mIDY0LWJpdCB0aW1lL2NvdW50ZXIgdmFsdWUgKi8K IHN0YXRpYyB1NjQgZ2V0NjQoY29uc3QgdTY0ICpwKQogewpAQCAtNDcsMjcgKzUwLDMxIEBAIHN0 YXRpYyB1NjQgZ2V0NjQoY29uc3QgdTY0ICpwKQogCXJldHVybiByZXQ7CiB9CiAKLS8qCi0gKiBS dW5zdGF0ZSBhY2NvdW50aW5nCi0gKi8KLXZvaWQgeGVuX2dldF9ydW5zdGF0ZV9zbmFwc2hvdChz dHJ1Y3QgdmNwdV9ydW5zdGF0ZV9pbmZvICpyZXMpCitzdGF0aWMgdm9pZCB4ZW5fZ2V0X3J1bnN0 YXRlX3NuYXBzaG90X2NwdShzdHJ1Y3QgdmNwdV9ydW5zdGF0ZV9pbmZvICpyZXMsCisJCQkJCSAg dW5zaWduZWQgaW50IGNwdSkKIHsKIAl1NjQgc3RhdGVfdGltZTsKIAlzdHJ1Y3QgdmNwdV9ydW5z dGF0ZV9pbmZvICpzdGF0ZTsKIAogCUJVR19PTihwcmVlbXB0aWJsZSgpKTsKIAotCXN0YXRlID0g dGhpc19jcHVfcHRyKCZ4ZW5fcnVuc3RhdGUpOworCXN0YXRlID0gcGVyX2NwdV9wdHIoJnhlbl9y dW5zdGF0ZSwgY3B1KTsKIAotCS8qCi0JICogVGhlIHJ1bnN0YXRlIGluZm8gaXMgYWx3YXlzIHVw ZGF0ZWQgYnkgdGhlIGh5cGVydmlzb3Igb24KLQkgKiB0aGUgY3VycmVudCBDUFUsIHNvIHRoZXJl J3Mgbm8gbmVlZCB0byB1c2UgYW55dGhpbmcKLQkgKiBzdHJvbmdlciB0aGFuIGEgY29tcGlsZXIg YmFycmllciB3aGVuIGZldGNoaW5nIGl0LgotCSAqLwogCWRvIHsKIAkJc3RhdGVfdGltZSA9IGdl dDY0KCZzdGF0ZS0+c3RhdGVfZW50cnlfdGltZSk7CisJCXJtYigpOwkvKiBIeXBlcnZpc29yIG1p Z2h0IHVwZGF0ZSBkYXRhLiAqLwogCQkqcmVzID0gUkVBRF9PTkNFKCpzdGF0ZSk7Ci0JfSB3aGls ZSAoZ2V0NjQoJnN0YXRlLT5zdGF0ZV9lbnRyeV90aW1lKSAhPSBzdGF0ZV90aW1lKTsKKwkJcm1i KCk7CS8qIEh5cGVydmlzb3IgbWlnaHQgdXBkYXRlIGRhdGEuICovCisJfSB3aGlsZSAoZ2V0NjQo JnN0YXRlLT5zdGF0ZV9lbnRyeV90aW1lKSAhPSBzdGF0ZV90aW1lIHx8CisJCSAoc3RhdGVfdGlt ZSAmIFhFTl9SVU5TVEFURV9VUERBVEUpKTsKK30KKworLyoKKyAqIFJ1bnN0YXRlIGFjY291bnRp bmcKKyAqLwordm9pZCB4ZW5fZ2V0X3J1bnN0YXRlX3NuYXBzaG90KHN0cnVjdCB2Y3B1X3J1bnN0 YXRlX2luZm8gKnJlcykKK3sKKwl4ZW5fZ2V0X3J1bnN0YXRlX3NuYXBzaG90X2NwdShyZXMsIHNt cF9wcm9jZXNzb3JfaWQoKSk7CiB9CiAKIC8qIHJldHVybiB0cnVlIHdoZW4gYSB2Y3B1IGNvdWxk IHJ1biBidXQgaGFzIG5vIHJlYWwgY3B1IHRvIHJ1biBvbiAqLwpAQCAtODAsOCArODcsOCBAQCBz dGF0aWMgdTY0IHhlbl9zdGVhbF9jbG9jayhpbnQgY3B1KQogewogCXN0cnVjdCB2Y3B1X3J1bnN0 YXRlX2luZm8gc3RhdGU7CiAKLQlCVUdfT04oY3B1ICE9IHNtcF9wcm9jZXNzb3JfaWQoKSk7Ci0J eGVuX2dldF9ydW5zdGF0ZV9zbmFwc2hvdCgmc3RhdGUpOworCUJVR19PTigheGVuX3J1bnN0YXRl X3JlbW90ZSAmJiBjcHUgIT0gc21wX3Byb2Nlc3Nvcl9pZCgpKTsKKwl4ZW5fZ2V0X3J1bnN0YXRl X3NuYXBzaG90X2NwdSgmc3RhdGUsIGNwdSk7CiAJcmV0dXJuIHN0YXRlLnRpbWVbUlVOU1RBVEVf cnVubmFibGVdICsgc3RhdGUudGltZVtSVU5TVEFURV9vZmZsaW5lXTsKIH0KIApAQCAtOTgsMTEg KzEwNSwxMiBAQCB2b2lkIHhlbl9zZXR1cF9ydW5zdGF0ZV9pbmZvKGludCBjcHUpCiAKIHZvaWQg X19pbml0IHhlbl90aW1lX3NldHVwX2d1ZXN0KHZvaWQpCiB7CisJeGVuX3J1bnN0YXRlX3JlbW90 ZSA9ICFIWVBFUlZJU09SX3ZtX2Fzc2lzdChWTUFTU1RfQ01EX2VuYWJsZSwKKwkJCQkJVk1BU1NU X1RZUEVfcnVuc3RhdGVfdXBkYXRlX2ZsYWcpOworCiAJcHZfdGltZV9vcHMuc3RlYWxfY2xvY2sg PSB4ZW5fc3RlYWxfY2xvY2s7CiAKIAlzdGF0aWNfa2V5X3Nsb3dfaW5jKCZwYXJhdmlydF9zdGVh bF9lbmFibGVkKTsKLQkvKgotCSAqIFdlIGNhbid0IHNldCBwYXJhdmlydF9zdGVhbF9ycV9lbmFi bGVkIGFzIHRoaXMgd291bGQgcmVxdWlyZSB0aGUKLQkgKiBjYXBhYmlsaXR5IHRvIHJlYWQgYW5v dGhlciBjcHUncyBydW5zdGF0ZSBpbmZvLgotCSAqLworCWlmICh4ZW5fcnVuc3RhdGVfcmVtb3Rl KQorCQlzdGF0aWNfa2V5X3Nsb3dfaW5jKCZwYXJhdmlydF9zdGVhbF9ycV9lbmFibGVkKTsKIH0K LS0gCjIuNi42CgoKX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f X18KWGVuLWRldmVsIG1haWxpbmcgbGlzdApYZW4tZGV2ZWxAbGlzdHMueGVuLm9yZwpodHRwOi8v bGlzdHMueGVuLm9yZy94ZW4tZGV2ZWwK