From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S933107AbcGEPY1 (ORCPT ); Tue, 5 Jul 2016 11:24:27 -0400 Received: from mail.kernel.org ([198.145.29.136]:53892 "EHLO mail.kernel.org" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1754640AbcGEPYX (ORCPT ); Tue, 5 Jul 2016 11:24:23 -0400 Date: Tue, 5 Jul 2016 16:23:23 +0100 (BST) From: Stefano Stabellini X-X-Sender: sstabellini@sstabellini-ThinkPad-X260 To: Juergen Gross cc: xen-devel@lists.xenproject.org, linux-kernel@vger.kernel.org, sstabellini@kernel.org, boris.ostrovsky@oracle.com, david.vrabel@citrix.com Subject: Re: [PATCH 3/3] xen: support runqueue steal time on xen In-Reply-To: <1466579034-12113-4-git-send-email-jgross@suse.com> Message-ID: References: <1466579034-12113-1-git-send-email-jgross@suse.com> <1466579034-12113-4-git-send-email-jgross@suse.com> User-Agent: Alpine 2.10 (DEB 1266 2009-07-14) MIME-Version: 1.0 Content-Type: TEXT/PLAIN; charset=US-ASCII Sender: linux-kernel-owner@vger.kernel.org List-ID: X-Mailing-List: linux-kernel@vger.kernel.org On Wed, 22 Jun 2016, Juergen Gross wrote: > 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; Honestly I would rather have one global variable less if it means only dropping one BUG_ON. > /* 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); > } From mboxrd@z Thu Jan 1 00:00:00 1970 From: Stefano Stabellini Subject: Re: [PATCH 3/3] xen: support runqueue steal time on xen Date: Tue, 5 Jul 2016 16:23:23 +0100 (BST) Message-ID: References: <1466579034-12113-1-git-send-email-jgross@suse.com> <1466579034-12113-4-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.bemta14.messagelabs.com ([193.109.254.103]) by lists.xenproject.org with esmtp (Exim 4.84_2) (envelope-from ) id 1bKSCD-0003S0-4D for xen-devel@lists.xenproject.org; Tue, 05 Jul 2016 15:23:33 +0000 In-Reply-To: <1466579034-12113-4-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: Juergen Gross Cc: xen-devel@lists.xenproject.org, boris.ostrovsky@oracle.com, sstabellini@kernel.org, linux-kernel@vger.kernel.org, david.vrabel@citrix.com List-Id: xen-devel@lists.xenproject.org T24gV2VkLCAyMiBKdW4gMjAxNiwgSnVlcmdlbiBHcm9zcyB3cm90ZToKPiBVcCB0byBub3cgcmVh ZGluZyB0aGUgc3RvbGVuIHRpbWUgb2YgYSByZW1vdGUgY3B1IHdhcyBub3QgcG9zc2libGUgaW4g YQo+IHBlcmZvcm1hbnQgd2F5IHVuZGVyIFhlbi4gVGhpcyBtYWRlIHN1cHBvcnQgb2YgcnVucXVl dWUgc3RlYWwgdGltZSB2aWEKPiBwYXJhdmlydF9zdGVhbF9ycV9lbmFibGVkIGltcG9zc2libGUu Cj4gCj4gV2l0aCB0aGUgYWRkaXRpb24gb2YgYW4gYXBwcm9wcmlhdGUgaHlwZXJ2aXNvciBpbnRl cmZhY2UgdGhpcyBpcyBub3cKPiBwb3NzaWJsZSwgc28gYWRkIHRoZSBzdXBwb3J0Lgo+IAo+IFNp Z25lZC1vZmYtYnk6IEp1ZXJnZW4gR3Jvc3MgPGpncm9zc0BzdXNlLmNvbT4KPiAtLS0KPiAgZHJp dmVycy94ZW4vdGltZS5jIHwgNDIgKysrKysrKysrKysrKysrKysrKysrKysrKy0tLS0tLS0tLS0t LS0tLS0tCj4gIDEgZmlsZSBjaGFuZ2VkLCAyNSBpbnNlcnRpb25zKCspLCAxNyBkZWxldGlvbnMo LSkKPiAKPiBkaWZmIC0tZ2l0IGEvZHJpdmVycy94ZW4vdGltZS5jIGIvZHJpdmVycy94ZW4vdGlt ZS5jCj4gaW5kZXggMjI1N2I2Ni4uNjVhZmJlOSAxMDA2NDQKPiAtLS0gYS9kcml2ZXJzL3hlbi90 aW1lLmMKPiArKysgYi9kcml2ZXJzL3hlbi90aW1lLmMKPiBAQCAtMTksNiArMTksOSBAQAo+ICAv KiBydW5zdGF0ZSBpbmZvIHVwZGF0ZWQgYnkgWGVuICovCj4gIHN0YXRpYyBERUZJTkVfUEVSX0NQ VShzdHJ1Y3QgdmNwdV9ydW5zdGF0ZV9pbmZvLCB4ZW5fcnVuc3RhdGUpOwo+ICAKPiArLyogcnVu c3RhdGUgaW5mbyBvZiByZW1vdGUgY3B1IGFjY2Vzc2libGUgKi8KPiArc3RhdGljIGJvb2wgeGVu X3J1bnN0YXRlX3JlbW90ZTsKCkhvbmVzdGx5IEkgd291bGQgcmF0aGVyIGhhdmUgb25lIGdsb2Jh bCB2YXJpYWJsZSBsZXNzIGlmIGl0IG1lYW5zIG9ubHkKZHJvcHBpbmcgb25lIEJVR19PTi4KCgo+ ICAvKiByZXR1cm4gYW4gY29uc2lzdGVudCBzbmFwc2hvdCBvZiA2NC1iaXQgdGltZS9jb3VudGVy IHZhbHVlICovCj4gIHN0YXRpYyB1NjQgZ2V0NjQoY29uc3QgdTY0ICpwKQo+ICB7Cj4gQEAgLTQ3 LDI3ICs1MCwzMSBAQCBzdGF0aWMgdTY0IGdldDY0KGNvbnN0IHU2NCAqcCkKPiAgCXJldHVybiBy ZXQ7Cj4gIH0KPiAgCj4gLS8qCj4gLSAqIFJ1bnN0YXRlIGFjY291bnRpbmcKPiAtICovCj4gLXZv aWQgeGVuX2dldF9ydW5zdGF0ZV9zbmFwc2hvdChzdHJ1Y3QgdmNwdV9ydW5zdGF0ZV9pbmZvICpy ZXMpCj4gK3N0YXRpYyB2b2lkIHhlbl9nZXRfcnVuc3RhdGVfc25hcHNob3RfY3B1KHN0cnVjdCB2 Y3B1X3J1bnN0YXRlX2luZm8gKnJlcywKPiArCQkJCQkgIHVuc2lnbmVkIGludCBjcHUpCj4gIHsK PiAgCXU2NCBzdGF0ZV90aW1lOwo+ICAJc3RydWN0IHZjcHVfcnVuc3RhdGVfaW5mbyAqc3RhdGU7 Cj4gIAo+ICAJQlVHX09OKHByZWVtcHRpYmxlKCkpOwo+ICAKPiAtCXN0YXRlID0gdGhpc19jcHVf cHRyKCZ4ZW5fcnVuc3RhdGUpOwo+ICsJc3RhdGUgPSBwZXJfY3B1X3B0cigmeGVuX3J1bnN0YXRl LCBjcHUpOwo+ICAKPiAtCS8qCj4gLQkgKiBUaGUgcnVuc3RhdGUgaW5mbyBpcyBhbHdheXMgdXBk YXRlZCBieSB0aGUgaHlwZXJ2aXNvciBvbgo+IC0JICogdGhlIGN1cnJlbnQgQ1BVLCBzbyB0aGVy ZSdzIG5vIG5lZWQgdG8gdXNlIGFueXRoaW5nCj4gLQkgKiBzdHJvbmdlciB0aGFuIGEgY29tcGls ZXIgYmFycmllciB3aGVuIGZldGNoaW5nIGl0Lgo+IC0JICovCj4gIAlkbyB7Cj4gIAkJc3RhdGVf dGltZSA9IGdldDY0KCZzdGF0ZS0+c3RhdGVfZW50cnlfdGltZSk7Cj4gKwkJcm1iKCk7CS8qIEh5 cGVydmlzb3IgbWlnaHQgdXBkYXRlIGRhdGEuICovCj4gIAkJKnJlcyA9IFJFQURfT05DRSgqc3Rh dGUpOwo+IC0JfSB3aGlsZSAoZ2V0NjQoJnN0YXRlLT5zdGF0ZV9lbnRyeV90aW1lKSAhPSBzdGF0 ZV90aW1lKTsKPiArCQlybWIoKTsJLyogSHlwZXJ2aXNvciBtaWdodCB1cGRhdGUgZGF0YS4gKi8K PiArCX0gd2hpbGUgKGdldDY0KCZzdGF0ZS0+c3RhdGVfZW50cnlfdGltZSkgIT0gc3RhdGVfdGlt ZSB8fAo+ICsJCSAoc3RhdGVfdGltZSAmIFhFTl9SVU5TVEFURV9VUERBVEUpKTsKPiArfQo+ICsK PiArLyoKPiArICogUnVuc3RhdGUgYWNjb3VudGluZwo+ICsgKi8KPiArdm9pZCB4ZW5fZ2V0X3J1 bnN0YXRlX3NuYXBzaG90KHN0cnVjdCB2Y3B1X3J1bnN0YXRlX2luZm8gKnJlcykKPiArewo+ICsJ eGVuX2dldF9ydW5zdGF0ZV9zbmFwc2hvdF9jcHUocmVzLCBzbXBfcHJvY2Vzc29yX2lkKCkpOwo+ ICB9Cj4gIAo+ICAvKiByZXR1cm4gdHJ1ZSB3aGVuIGEgdmNwdSBjb3VsZCBydW4gYnV0IGhhcyBu byByZWFsIGNwdSB0byBydW4gb24gKi8KPiBAQCAtODAsOCArODcsOCBAQCBzdGF0aWMgdTY0IHhl bl9zdGVhbF9jbG9jayhpbnQgY3B1KQo+ICB7Cj4gIAlzdHJ1Y3QgdmNwdV9ydW5zdGF0ZV9pbmZv IHN0YXRlOwo+ICAKPiAtCUJVR19PTihjcHUgIT0gc21wX3Byb2Nlc3Nvcl9pZCgpKTsKPiAtCXhl bl9nZXRfcnVuc3RhdGVfc25hcHNob3QoJnN0YXRlKTsKPiArCUJVR19PTigheGVuX3J1bnN0YXRl X3JlbW90ZSAmJiBjcHUgIT0gc21wX3Byb2Nlc3Nvcl9pZCgpKTsKPiArCXhlbl9nZXRfcnVuc3Rh dGVfc25hcHNob3RfY3B1KCZzdGF0ZSwgY3B1KTsKPiAgCXJldHVybiBzdGF0ZS50aW1lW1JVTlNU QVRFX3J1bm5hYmxlXSArIHN0YXRlLnRpbWVbUlVOU1RBVEVfb2ZmbGluZV07Cj4gIH0KPiAgCj4g QEAgLTk4LDExICsxMDUsMTIgQEAgdm9pZCB4ZW5fc2V0dXBfcnVuc3RhdGVfaW5mbyhpbnQgY3B1 KQo+ICAKPiAgdm9pZCBfX2luaXQgeGVuX3RpbWVfc2V0dXBfZ3Vlc3Qodm9pZCkKPiAgewo+ICsJ eGVuX3J1bnN0YXRlX3JlbW90ZSA9ICFIWVBFUlZJU09SX3ZtX2Fzc2lzdChWTUFTU1RfQ01EX2Vu YWJsZSwKPiArCQkJCQlWTUFTU1RfVFlQRV9ydW5zdGF0ZV91cGRhdGVfZmxhZyk7Cj4gKwo+ICAJ cHZfdGltZV9vcHMuc3RlYWxfY2xvY2sgPSB4ZW5fc3RlYWxfY2xvY2s7Cj4gIAo+ICAJc3RhdGlj X2tleV9zbG93X2luYygmcGFyYXZpcnRfc3RlYWxfZW5hYmxlZCk7Cj4gLQkvKgo+IC0JICogV2Ug Y2FuJ3Qgc2V0IHBhcmF2aXJ0X3N0ZWFsX3JxX2VuYWJsZWQgYXMgdGhpcyB3b3VsZCByZXF1aXJl IHRoZQo+IC0JICogY2FwYWJpbGl0eSB0byByZWFkIGFub3RoZXIgY3B1J3MgcnVuc3RhdGUgaW5m by4KPiAtCSAqLwo+ICsJaWYgKHhlbl9ydW5zdGF0ZV9yZW1vdGUpCj4gKwkJc3RhdGljX2tleV9z bG93X2luYygmcGFyYXZpcnRfc3RlYWxfcnFfZW5hYmxlZCk7Cj4gIH0KCl9fX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fClhlbi1kZXZlbCBtYWlsaW5nIGxpc3QK WGVuLWRldmVsQGxpc3RzLnhlbi5vcmcKaHR0cHM6Ly9saXN0cy54ZW4ub3JnL3hlbi1kZXZlbAo=