From mboxrd@z Thu Jan 1 00:00:00 1970 From: Alex =?utf-8?Q?Benn=C3=A9e?= Subject: Re: [RFC PATCH v2 19/23] KVM: arm64/sve: Report and enable SVE API extensions for userspace Date: Thu, 22 Nov 2018 15:23:13 +0000 Message-ID: <87a7m1i1b2.fsf@linaro.org> References: <1538141967-15375-1-git-send-email-Dave.Martin@arm.com> <1538141967-15375-20-git-send-email-Dave.Martin@arm.com> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Return-path: Received: from localhost (localhost [127.0.0.1]) by mm01.cs.columbia.edu (Postfix) with ESMTP id 541954A2E6 for ; Thu, 22 Nov 2018 10:23:34 -0500 (EST) Received: from mm01.cs.columbia.edu ([127.0.0.1]) by localhost (mm01.cs.columbia.edu [127.0.0.1]) (amavisd-new, port 10024) with ESMTP id k3hIUUKk0z2n for ; Thu, 22 Nov 2018 10:23:17 -0500 (EST) Received: from mail-wr1-f67.google.com (mail-wr1-f67.google.com [209.85.221.67]) by mm01.cs.columbia.edu (Postfix) with ESMTPS id 1EE394A1D8 for ; Thu, 22 Nov 2018 10:23:17 -0500 (EST) Received: by mail-wr1-f67.google.com with SMTP id v6so9620050wrr.12 for ; Thu, 22 Nov 2018 07:23:17 -0800 (PST) In-reply-to: <1538141967-15375-20-git-send-email-Dave.Martin@arm.com> List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: kvmarm-bounces@lists.cs.columbia.edu Sender: kvmarm-bounces@lists.cs.columbia.edu To: Dave Martin Cc: Okamoto Takayuki , Christoffer Dall , Ard Biesheuvel , Marc Zyngier , Catalin Marinas , Will Deacon , kvmarm@lists.cs.columbia.edu, linux-arm-kernel@lists.infradead.org List-Id: kvmarm@lists.cs.columbia.edu CkRhdmUgTWFydGluIDxEYXZlLk1hcnRpbkBhcm0uY29tPiB3cml0ZXM6Cgo+IFRoaXMgcGF0Y2gg YWRkcyB0aGUgbmVjZXNzYXJ5IEFQSSBleHRlbnNpb25zIHRvIGFsbG93IHVzZXJzcGFjZSB0bwo+ IGRldGVjdCBTVkUgc3VwcG9ydCBmb3IgZ3Vlc3RzIGFuZCBlbmFibGUgaXQuCj4KPiBBIG5ldyBj YXBhYmlsaXR5IEtWTV9DQVBfQVJNX1NWRSBpcyBkZWZpbmVkIHRvIGFsbG93IHVzZXJzcGFjZSB0 bwo+IGRldGVjdCB0aGUgYXZhaWxhYmlsaXR5IG9mIHRoZSBLVk0gU1ZFIEFQSSBleHRlbnNpb25z IGluIHRoZSB1c3VhbAo+IHdheS4KPgo+IFVzZXJzcGFjZSBuZWVkcyB0byBlbmFibGUgU1ZFIGV4 cGxpY2l0bHkgcGVyIHZjcHUgYW5kIGNvbmZpZ3VyZSB0aGUKPiBzZXQgb2YgU1ZFIHZlY3RvciBs ZW5ndGhzIGF2YWlsYWJsZSB0byB0aGUgZ3Vlc3QgYmVmb3JlIHRoZSB2Y3B1IGlzCj4gYWxsb3dl ZCB0byBydW4uICBGb3IgdGhlc2UgcHVycG9zZXMsIGEgbmV3IGFybTY0LXNwZWNpZmljIHZjcHUK PiBpb2N0bCBLVk1fQVJNX1NWRV9DT05GSUcgaXMgYWRkZWQsIHdpdGggdGhlIGZvbGxvd2luZyBz dWJjb21tYW5kcwo+IChpbiByb3VnaCBvcmRlciBvZiBleHBlY3RlZCB1c2UpOgo+Cj4gS1ZNX0FS TV9TVkVfQ09ORklHX1FVRVJZOiByZXBvcnQgdGhlIHNldCBvZiB2ZWN0b3IgbGVuZ3Rocwo+ICAg ICBzdXBwb3J0ZWQgYnkgdGhpcyBob3N0Lgo+Cj4gICAgIFRoZSByZXN1bHRpbmcgc2V0IGNhbiBi ZSBzdXBwbGllZCBkaXJlY3RseSB0bwo+ICAgICBLVk1fQVJNX1NWRV9DT05GSUdfU0VUIGluIG9y ZGVyIHRvIG9idGFpbiB0aGUgbWF4aW1hbCBwb3NzaWJsZQo+ICAgICBzZXQsIG9yIHVzZWQgdG8g aW5mb3JtIHVzZXJzcGFjZSdzIGRlY2lzaW9uIG9uIHRoZSBhcHByb3ByaWF0ZQo+ICAgICBzZXQg b2YgdmVjdG9yIGxlbmd0aHMgKHBvc3NpYmx5IHRha2luZyBpbnRvIGFjY291bnQgdGhlCj4gICAg IGNvbmZpZ3VyYXRpb24gb2Ygb3RoZXIgbm9kZXMgaW4gdGhlIGNsdXN0ZXIgc28gdGhhdCB0aGUg Vk0gY2FuCj4gICAgIG1pZ3JhdGUgZnJlZWx5KS4KPgo+IEtWTV9BUk1fU1ZFX0NPTkZJR19TRVQ6 IGVuYWJsZSBTVkUgZm9yIHRoaXMgdmNwdSBhbmQgY29uZmlndXJlIHRoZQo+ICAgICBzZXQgb2Yg dmVjdG9yIGxlbmd0aHMgaXQgb2ZmZXJzIHRvIHRoZSBndWVzdC4KPgo+ICAgICBUaGlzIGNhbiBv bmx5IGJlIGRvbmUgb25jZSwgYmVmb3JlIHRoZSB2Y3B1IGlzIHJ1bi4KPgo+IEtWTV9BUk1fU1ZF X0NPTkZJR19HRVQ6IHJlcG9ydCB0aGUgc2V0IG9mIHZlY3RvciBsZW5ndGhzIGF2YWlsYWJsZQo+ ICAgICB0byB0aGUgZ3Vlc3Qgb24gdGhpcyB2Y3B1IChmb3IgdXNlIHdoZW4gc25hcHNob3R0aW5n IG9yCj4gICAgIG1pZ3JhdGluZyBhIFZNKS4KPgo+IFNpZ25lZC1vZmYtYnk6IERhdmUgTWFydGlu IDxEYXZlLk1hcnRpbkBhcm0uY29tPgo+IC0tLQo+Cj4gQ2hhbmdlcyBzaW5jZSBSRkN2MToKPgo+ ICAqIFRoZSBuZXcgZmVhdHVyZSBiaXQgZm9yIFBSRUZFUlJFRF9UQVJHRVQgLyBWQ1BVX0lOSVQg aXMgZ29uZSBpbgo+ICAgIGZhdm91ciBvZiBhIGNhcGFiaWxpdHkgYW5kIGEgbmV3IGlvY3RsIHRv IGVuYWJsZS9jb25maWd1cmUgU1ZFLgo+Cj4gICAgUGVyaGFwcyB0aGUgU1ZFIGNvbmZpZ3VyYXRp b24gY291bGQgYmUgZG9uZSB2aWEgZGV2aWNlIGF0dHJpYnV0ZXMsCj4gICAgYnV0IGl0IHN0aWxs IGhhcyB0byBiZSBkb25lIGVhcmx5LCBzbyBjcm93YmFycmluZyBzdXBwb3J0IGZvciB0aGlzCj4g ICAgYmVoaW5kIGEgZ2VuZXJpYyBBUEkgbWF5IGNhdXNlIG1vcmUgdHJvdWJsZSB0aGFuIGl0IHNv bHZlcy4KPgo+ICAgIFRoaXMgaXMgc3RpbGwgdXAgZm9yIGRpc2N1c3Npb24gaWYgYW55Ym9keSBm ZWVscyBzdHJvbmdseSBhYm91dCBpdC4KPgo+ICAqIEFuIGlvY3RsIEtWTV9BUk1fU1ZFX0NPTkZJ RyBoYXMgYmVlbiBhZGRlZCB0byByZXBvcnQgdGhlIHNldCBvZgo+ICAgIHZlY3RvciBsZW5ndGhz IGF2YWlsYWJsZSBhbmQgY29uZmlndXJlIFNWRSBmb3IgYSB2Y3B1Lgo+Cj4gICAgVG8gcmVkdWNl IGlvY3RsIG5hbWVzcGFjZSBwb2xsdXRpb24gdGhlIG5ldyBvcGVyYXRpb25zIGFyZSBncm91cGVk Cj4gICAgYXMgc3ViY29tbWFuZHMgdW5kZXIgYSBzaW5nbGUgaW9jdGwsIHNpbmNlIHRoZXkgdXNl IHRoZSBzYW1lCj4gICAgYXJndW1lbnQgZm9ybWF0IGFueXdheS4KPiAtLS0KPiAgYXJjaC9hcm02 NC9pbmNsdWRlL2FzbS9rdm1faG9zdC5oIHwgICA4ICstCj4gIGFyY2gvYXJtNjQvaW5jbHVkZS91 YXBpL2FzbS9rdm0uaCB8ICAxNCArKysrCj4gIGFyY2gvYXJtNjQva3ZtL2d1ZXN0LmMgICAgICAg ICAgICB8IDE2NCArKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrLQo+ICBhcmNo L2FybTY0L2t2bS9yZXNldC5jICAgICAgICAgICAgfCAgNTAgKysrKysrKysrKysrCj4gIGluY2x1 ZGUvdWFwaS9saW51eC9rdm0uaCAgICAgICAgICB8ICAgNCArCj4gIDUgZmlsZXMgY2hhbmdlZCwg MjM4IGluc2VydGlvbnMoKyksIDIgZGVsZXRpb25zKC0pCj4KPiBkaWZmIC0tZ2l0IGEvYXJjaC9h cm02NC9pbmNsdWRlL2FzbS9rdm1faG9zdC5oIGIvYXJjaC9hcm02NC9pbmNsdWRlL2FzbS9rdm1f aG9zdC5oCj4gaW5kZXggYmJkZTU5Ny4uNTIyNTQ4NSAxMDA2NDQKPiAtLS0gYS9hcmNoL2FybTY0 L2luY2x1ZGUvYXNtL2t2bV9ob3N0LmgKPiArKysgYi9hcmNoL2FybTY0L2luY2x1ZGUvYXNtL2t2 bV9ob3N0LmgKPiBAQCAtNTIsNiArNTIsMTIgQEAKPgo+ICBERUNMQVJFX1NUQVRJQ19LRVlfRkFM U0UodXNlcnNwYWNlX2lycWNoaXBfaW5fdXNlKTsKPgo+ICsjaWZkZWYgQ09ORklHX0FSTTY0X1NW RQo+ICtib29sIGt2bV9zdmVfc3VwcG9ydGVkKHZvaWQpOwo+ICsjZWxzZQo+ICtzdGF0aWMgaW5s aW5lIGJvb2wga3ZtX3N2ZV9zdXBwb3J0ZWQodm9pZCkgeyByZXR1cm4gZmFsc2U7IH0KPiArI2Vu ZGlmCj4gKwo+ICBpbnQgX19hdHRyaWJ1dGVfY29uc3RfXyBrdm1fdGFyZ2V0X2NwdSh2b2lkKTsK PiAgaW50IGt2bV9yZXNldF92Y3B1KHN0cnVjdCBrdm1fdmNwdSAqdmNwdSk7Cj4gIGludCBrdm1f YXJjaF9kZXZfaW9jdGxfY2hlY2tfZXh0ZW5zaW9uKHN0cnVjdCBrdm0gKmt2bSwgbG9uZyBleHQp Owo+IEBAIC00NDEsNyArNDQ3LDcgQEAgc3RhdGljIGlubGluZSB2b2lkIGt2bV9hcmNoX3N5bmNf ZXZlbnRzKHN0cnVjdCBrdm0gKmt2bSkge30KPiAgc3RhdGljIGlubGluZSB2b2lkIGt2bV9hcmNo X3NjaGVkX2luKHN0cnVjdCBrdm1fdmNwdSAqdmNwdSwgaW50IGNwdSkge30KPiAgc3RhdGljIGlu bGluZSB2b2lkIGt2bV9hcmNoX3ZjcHVfYmxvY2tfZmluaXNoKHN0cnVjdCBrdm1fdmNwdSAqdmNw dSkge30KPgo+IC1zdGF0aWMgaW5saW5lIHZvaWQga3ZtX2FybV9hcmNoX3ZjcHVfdW5pbml0KHN0 cnVjdCBrdm1fdmNwdSAqdmNwdSkge30KPiArdm9pZCBrdm1fYXJtX2FyY2hfdmNwdV91bmluaXQo c3RydWN0IGt2bV92Y3B1ICp2Y3B1KTsKPgo+ICB2b2lkIGt2bV9hcm1faW5pdF9kZWJ1Zyh2b2lk KTsKPiAgdm9pZCBrdm1fYXJtX3NldHVwX2RlYnVnKHN0cnVjdCBrdm1fdmNwdSAqdmNwdSk7Cj4g ZGlmZiAtLWdpdCBhL2FyY2gvYXJtNjQvaW5jbHVkZS91YXBpL2FzbS9rdm0uaCBiL2FyY2gvYXJt NjQvaW5jbHVkZS91YXBpL2FzbS9rdm0uaAo+IGluZGV4IDFmZjY4ZmEuLjk0ZjY5MzIgMTAwNjQ0 Cj4gLS0tIGEvYXJjaC9hcm02NC9pbmNsdWRlL3VhcGkvYXNtL2t2bS5oCj4gKysrIGIvYXJjaC9h cm02NC9pbmNsdWRlL3VhcGkvYXNtL2t2bS5oCj4gQEAgLTMyLDYgKzMyLDcgQEAKPiAgI2RlZmlu ZSBLVk1fTlJfU1BTUgk1Cj4KPiAgI2lmbmRlZiBfX0FTU0VNQkxZX18KPiArI2luY2x1ZGUgPGxp bnV4L2tlcm5lbC5oPgo+ICAjaW5jbHVkZSA8bGludXgvcHNjaS5oPgo+ICAjaW5jbHVkZSA8bGlu dXgvdHlwZXMuaD4KPiAgI2luY2x1ZGUgPGFzbS9wdHJhY2UuaD4KPiBAQCAtMTA4LDYgKzEwOSwx OSBAQCBzdHJ1Y3Qga3ZtX3ZjcHVfaW5pdCB7Cj4gIAlfX3UzMiBmZWF0dXJlc1s3XTsKPiAgfTsK Pgo+ICsvKiBWZWN0b3IgbGVuZ3RoIHNldCBmb3IgS1ZNX0FSTV9TVkVfQ09ORklHICovCj4gK3N0 cnVjdCBrdm1fc3ZlX3ZscyB7Cj4gKwlfX3UxNiBjbWQ7Cj4gKwlfX3UxNiBtYXhfdnE7Cj4gKwlf X3UxNiBfcmVzZXJ2ZWRbMl07Cj4gKwlfX3U2NCByZXF1aXJlZF92cXNbX19LRVJORUxfRElWX1JP VU5EX1VQKFNWRV9WUV9NQVggLSBTVkVfVlFfTUlOICsgMSwgNjQpXTsKPiArfTsKPiArCj4gKy8q IHZhbHVlcyBmb3IgY21kOiAqLwo+ICsjZGVmaW5lIEtWTV9BUk1fU1ZFX0NPTkZJR19RVUVSWQkw IC8qIHF1ZXJ5IHdoYXQgdGhlIGhvc3QgY2FuIHN1cHBvcnQgKi8KPiArI2RlZmluZSBLVk1fQVJN X1NWRV9DT05GSUdfU0VUCQkxIC8qIGVuYWJsZSBTVkUgZm9yIHZjcHUgYW5kIHNldCBWTHMgKi8K PiArI2RlZmluZSBLVk1fQVJNX1NWRV9DT05GSUdfR0VUCQkyIC8qIHJlYWQgdGhlIHNldCBvZiBW THMgZm9yIGEgdmNwdSAqLwo+ICsKPiAgc3RydWN0IGt2bV9zcmVncyB7Cj4gIH07Cj4KPiBkaWZm IC0tZ2l0IGEvYXJjaC9hcm02NC9rdm0vZ3Vlc3QuYyBiL2FyY2gvYXJtNjQva3ZtL2d1ZXN0LmMK PiBpbmRleCAzMzFiODVlLi5kOTYxNDVhIDEwMDY0NAo+IC0tLSBhL2FyY2gvYXJtNjQva3ZtL2d1 ZXN0LmMKPiArKysgYi9hcmNoL2FybTY0L2t2bS9ndWVzdC5jCj4gQEAgLTI2LDYgKzI2LDkgQEAK PiAgI2luY2x1ZGUgPGxpbnV4L21vZHVsZS5oPgo+ICAjaW5jbHVkZSA8bGludXgvdm1hbGxvYy5o Pgo+ICAjaW5jbHVkZSA8bGludXgvZnMuaD4KPiArI2luY2x1ZGUgPGxpbnV4L3NsYWIuaD4KPiAr I2luY2x1ZGUgPGxpbnV4L3N0cmluZy5oPgo+ICsjaW5jbHVkZSA8bGludXgvdHlwZXMuaD4KPiAg I2luY2x1ZGUgPGt2bS9hcm1fcHNjaS5oPgo+ICAjaW5jbHVkZSA8YXNtL2NwdXR5cGUuaD4KPiAg I2luY2x1ZGUgPGxpbnV4L3VhY2Nlc3MuaD4KPiBAQCAtNTYsNiArNTksMTEgQEAgaW50IGt2bV9h cmNoX3ZjcHVfc2V0dXAoc3RydWN0IGt2bV92Y3B1ICp2Y3B1KQo+ICAJcmV0dXJuIDA7Cj4gIH0K Pgo+ICt2b2lkIGt2bV9hcm1fYXJjaF92Y3B1X3VuaW5pdChzdHJ1Y3Qga3ZtX3ZjcHUgKnZjcHUp Cj4gK3sKPiArCWtmcmVlKHZjcHUtPmFyY2guc3ZlX3N0YXRlKTsKPiArfQo+ICsKPiAgc3RhdGlj IHU2NCBjb3JlX3JlZ19vZmZzZXRfZnJvbV9pZCh1NjQgaWQpCj4gIHsKPiAgCXJldHVybiBpZCAm IH4oS1ZNX1JFR19BUkNIX01BU0sgfCBLVk1fUkVHX1NJWkVfTUFTSyB8IEtWTV9SRUdfQVJNX0NP UkUpOwo+IEBAIC01NDYsMTAgKzU1NCwxNjQgQEAgaW50IGt2bV92Y3B1X3ByZWZlcnJlZF90YXJn ZXQoc3RydWN0IGt2bV92Y3B1X2luaXQgKmluaXQpCj4gIAlyZXR1cm4gMDsKPiAgfQo+Cj4gKyNk ZWZpbmUgVlFTX1BFUl9VNjQgNjQKPiArI2RlZmluZSB2cV93b3JkKHZxcywgdnEpICgmKHZxcylb KCh2cSkgLSBTVkVfVlFfTUlOKSAvIFZRU19QRVJfVTY0XSkKPiArI2RlZmluZSB2cV9tYXNrKHZx KSAoKHU2NCkxIDw8ICgoKHZxKSAtIFNWRV9WUV9NSU4pICUgVlFTX1BFUl9VNjQpKQo+ICsKPiAr c3RhdGljIHZvaWQgc2V0X3ZxKHU2NCAqdnFzLCB1bnNpZ25lZCBpbnQgdnEpCj4gK3sKPiArCSp2 cV93b3JkKHZxcywgdnEpIHw9IHZxX21hc2sodnEpOwo+ICt9Cj4gKwo+ICtzdGF0aWMgYm9vbCB2 cV9zZXQoY29uc3QgdTY0ICp2cXMsIHVuc2lnbmVkIGludCB2cSkKPiArewo+ICsJcmV0dXJuICp2 cV93b3JkKHZxcywgdnEpICYgdnFfbWFzayh2cSk7Cj4gK30KPiArCj4gK3N0YXRpYyBpbnQga3Zt X3ZjcHVfc2V0X3N2ZV92bHMoc3RydWN0IGt2bV92Y3B1ICp2Y3B1LCBzdHJ1Y3Qga3ZtX3N2ZV92 bHMgKnZscywKPiArCQlzdHJ1Y3Qga3ZtX3N2ZV92bHMgX191c2VyICp1c2VycCkKPiArewo+ICsJ dW5zaWduZWQgaW50IHZxLCBtYXhfdnE7Cj4gKwlpbnQgcmV0Owo+ICsKPiArCWlmICh2Y3B1LT5h cmNoLmhhc19ydW5fb25jZSB8fCB2Y3B1X2hhc19zdmUodmNwdSkpCj4gKwkJcmV0dXJuIC1FQkFE RkQ7IC8qIHRvbyBsYXRlLCBvciBhbHJlYWR5IGNvbmZpZ3VyZWQgKi8KPiArCj4gKwlCVUdfT04o dmNwdS0+YXJjaC5zdmVfbWF4X3ZsIHx8IHZjcHUtPmFyY2guc3ZlX3N0YXRlKTsKPiArCj4gKwlp ZiAodmxzLT5tYXhfdnEgPCBTVkVfVlFfTUlOIHx8IHZscy0+bWF4X3ZxID4gU1ZFX1ZRX01BWCkK PiArCQlyZXR1cm4gLUVJTlZBTDsKPiArCj4gKwltYXhfdnEgPSAwOwo+ICsJZm9yICh2cSA9IFNW RV9WUV9NSU47IHZxIDw9IHZscy0+bWF4X3ZxOyArK3ZxKSB7Cj4gKwkJYm9vbCBhdmFpbGFibGUg PSBzdmVfdnFfYXZhaWxhYmxlKHZxKTsKPiArCQlib29sIHJlcXVpcmVkID0gdnFfc2V0KHZscy0+ cmVxdWlyZWRfdnFzLCB2cSk7Cj4gKwo+ICsJCWlmIChyZXF1aXJlZCAhPSBhdmFpbGFibGUpCj4g KwkJCWJyZWFrOwo+ICsKPiArCQlpZiAocmVxdWlyZWQpCj4gKwkJCW1heF92cSA9IHZxOwo+ICsJ fQo+ICsKPiArCWlmIChtYXhfdnEgPCBTVkVfVlFfTUlOKQo+ICsJCXJldHVybiAtRUlOVkFMOwo+ ICsKPiArCXZscy0+bWF4X3ZxID0gbWF4X3ZxOwo+ICsJcmV0ID0gcHV0X3VzZXIodmxzLT5tYXhf dnEsICZ1c2VycC0+bWF4X3ZxKTsKPiArCWlmIChyZXQpCj4gKwkJcmV0dXJuIHJldDsKPiArCj4g KwkvKgo+ICsJICoga3ZtX3Jlc2V0X3ZjcHUoKSBtYXkgYWxyZWFkeSBoYXZlIHJ1biBpbiBLVk1f VkNQVV9JTklULCBzbyB3ZQo+ICsJICogcmVseSBvbiBremFsbG9jKCkgYmVpbmcgc3VmZmljaWVu dCB0byByZXNldCB0aGUgZ3Vlc3QgU1ZFCj4gKwkgKiBzdGF0ZSBoZXJlIGZvciBhIG5ldyB2Y3B1 Lgo+ICsJICoKPiArCSAqIFN1YnNlcXVlbnQgcmVzZXRzIGFmdGVyIHZjcHUgaW5pdGlhbGlzYXRp b24gYXJlIGhhbmRsZWQgYnkKPiArCSAqIGt2bV9yZXNldF9zdmUoKS4KPiArCSAqLwo+ICsJdmNw dS0+YXJjaC5zdmVfc3RhdGUgPSBremFsbG9jKFNWRV9TSUdfUkVHU19TSVpFKHZscy0+bWF4X3Zx KSwKPiArCQkJCSAgICAgICBHRlBfS0VSTkVMKTsKPiArCWlmICghdmNwdS0+YXJjaC5zdmVfc3Rh dGUpCj4gKwkJcmV0dXJuIC1FTk9NRU07Cj4gKwo+ICsJdmNwdS0+YXJjaC5mbGFncyB8PSBLVk1f QVJNNjRfR1VFU1RfSEFTX1NWRTsKPiArCXZjcHUtPmFyY2guc3ZlX21heF92bCA9IHN2ZV92bF9m cm9tX3ZxKHZscy0+bWF4X3ZxKTsKPiArCj4gKwlyZXR1cm4gMDsKPiArfQo+ICsKPiArc3RhdGlj IGludCBfX2t2bV92Y3B1X3F1ZXJ5X3N2ZV92bHMoc3RydWN0IGt2bV9zdmVfdmxzICp2bHMsCj4g KwkJdW5zaWduZWQgaW50IG1heF92cSwgc3RydWN0IGt2bV9zdmVfdmxzIF9fdXNlciAqdXNlcnAp Cj4gK3sKPiArCXVuc2lnbmVkIGludCB2cSwgbWF4X2F2YWlsYWJsZV92cTsKPiArCj4gKwltZW1z ZXQoJnZscy0+cmVxdWlyZWRfdnFzLCAwLCBzaXplb2YodmxzLT5yZXF1aXJlZF92cXMpKTsKPiAr Cj4gKwlCVUdfT04obWF4X3ZxIDwgU1ZFX1ZRX01JTiB8fCBtYXhfdnEgPiBTVkVfVlFfTUFYKTsK PiArCj4gKwltYXhfYXZhaWxhYmxlX3ZxID0gMDsKPiArCWZvciAodnEgPSBTVkVfVlFfTUlOOyB2 cSA8PSBtYXhfdnE7ICsrdnEpCj4gKwkJaWYgKHN2ZV92cV9hdmFpbGFibGUodnEpKSB7Cj4gKwkJ CXNldF92cSh2bHMtPnJlcXVpcmVkX3ZxcywgdnEpOwo+ICsJCQltYXhfYXZhaWxhYmxlX3ZxID0g dnE7Cj4gKwkJfQo+ICsKPiArCWlmIChXQVJOX09OKG1heF9hdmFpbGFibGVfdnEgPCBTVkVfVlFf TUlOKSkKPiArCQlyZXR1cm4gLUVJTzsKPiArCj4gKwl2bHMtPm1heF92cSA9IG1heF9hdmFpbGFi bGVfdnE7Cj4gKwlpZiAoY29weV90b191c2VyKHVzZXJwLCB2bHMsIHNpemVvZigqdmxzKSkpCj4g KwkJcmV0dXJuIC1FRkFVTFQ7Cj4gKwo+ICsJcmV0dXJuIDA7Cj4gK30KPiArCj4gK3N0YXRpYyBp bnQga3ZtX3ZjcHVfcXVlcnlfc3ZlX3ZscyhzdHJ1Y3Qga3ZtX3ZjcHUgKnZjcHUsIHN0cnVjdCBr dm1fc3ZlX3ZscyAqdmxzLAo+ICsJCXN0cnVjdCBrdm1fc3ZlX3ZscyBfX3VzZXIgKnVzZXJwKQo+ ICt7Cj4gKwlCVUdfT04oIXN2ZV92bF92YWxpZChzdmVfbWF4X3ZsKSk7Cj4gKwo+ICsJcmV0dXJu IF9fa3ZtX3ZjcHVfcXVlcnlfc3ZlX3Zscyh2bHMsCj4gKwkJCXN2ZV92cV9mcm9tX3ZsKHN2ZV9t YXhfdmwpLCB1c2VycCk7Cj4gK30KPiArCj4gK3N0YXRpYyBpbnQga3ZtX3ZjcHVfZ2V0X3N2ZV92 bHMoc3RydWN0IGt2bV92Y3B1ICp2Y3B1LCBzdHJ1Y3Qga3ZtX3N2ZV92bHMgKnZscywKPiArCQlz dHJ1Y3Qga3ZtX3N2ZV92bHMgX191c2VyICp1c2VycCkKPiArewo+ICsJaWYgKCF2Y3B1X2hhc19z dmUodmNwdSkpCj4gKwkJcmV0dXJuIC1FQkFERkQ7IC8qIG5vdCBjb25maWd1cmVkIHlldCAqLwo+ ICsKPiArCUJVR19PTighc3ZlX3ZsX3ZhbGlkKHZjcHUtPmFyY2guc3ZlX21heF92bCkpOwo+ICsK PiArCXJldHVybiBfX2t2bV92Y3B1X3F1ZXJ5X3N2ZV92bHModmxzLAo+ICsJCQlzdmVfdnFfZnJv bV92bCh2Y3B1LT5hcmNoLnN2ZV9tYXhfdmwpLCB1c2VycCk7Cj4gK30KPiArCj4gK3N0YXRpYyBp bnQga3ZtX3ZjcHVfc3ZlX2NvbmZpZyhzdHJ1Y3Qga3ZtX3ZjcHUgKnZjcHUsCj4gKwkJCSAgICAg ICBzdHJ1Y3Qga3ZtX3N2ZV92bHMgX191c2VyICp1c2VycCkKPiArewo+ICsJc3RydWN0IGt2bV9z dmVfdmxzIHZsczsKPiArCj4gKwlpZiAoIWt2bV9zdmVfc3VwcG9ydGVkKCkpCj4gKwkJcmV0dXJu IC1FSU5WQUw7Cj4gKwo+ICsJaWYgKGNvcHlfZnJvbV91c2VyKCZ2bHMsIHVzZXJwLCBzaXplb2Yo dmxzKSkpCj4gKwkJcmV0dXJuIC1FRkFVTFQ7Cj4gKwo+ICsJLyoKPiArCSAqIEZvciBmb3J3YXJk cyBjb21wYXRpYmlsaXR5LCBmbHVzaCBhbnkgc2V0IGJpdHMgaW4gX3Jlc2VydmVkW10KPiArCSAq IHRvIHRlbGwgdXNlcnNwYWNlIHRoYXQgd2UgZGlkbid0IGxvb2sgYXQgdGhlbToKPiArCSAqLwo+ ICsJbWVtc2V0KCZ2bHMuX3Jlc2VydmVkLCAwLCBzaXplb2YgdmxzLl9yZXNlcnZlZCk7Cj4gKwo+ ICsJc3dpdGNoICh2bHMuY21kKSB7Cj4gKwljYXNlIEtWTV9BUk1fU1ZFX0NPTkZJR19RVUVSWToK PiArCQlyZXR1cm4ga3ZtX3ZjcHVfcXVlcnlfc3ZlX3Zscyh2Y3B1LCAmdmxzLCB1c2VycCk7Cj4g Kwo+ICsJY2FzZSBLVk1fQVJNX1NWRV9DT05GSUdfU0VUOgo+ICsJCXJldHVybiBrdm1fdmNwdV9z ZXRfc3ZlX3Zscyh2Y3B1LCAmdmxzLCB1c2VycCk7Cj4gKwo+ICsJY2FzZSBLVk1fQVJNX1NWRV9D T05GSUdfR0VUOgo+ICsJCXJldHVybiBrdm1fdmNwdV9nZXRfc3ZlX3Zscyh2Y3B1LCAmdmxzLCB1 c2VycCk7Cj4gKwo+ICsJZGVmYXVsdDoKPiArCQlyZXR1cm4gLUVJTlZBTDsKPiArCX0KPiArfQo+ ICsKPiAgaW50IGt2bV9hcm1fYXJjaF92Y3B1X2lvY3RsKHN0cnVjdCBrdm1fdmNwdSAqdmNwdSwK PiAgCQkJICAgIHVuc2lnbmVkIGludCBpb2N0bCwgdW5zaWduZWQgbG9uZyBhcmcpCj4gIHsKPiAt CXJldHVybiAtRUlOVkFMOwo+ICsJdm9pZCBfX3VzZXIgKnVzZXJwID0gKHZvaWQgX191c2VyICop YXJnOwo+ICsKPiArCXN3aXRjaCAoaW9jdGwpIHsKPiArCWNhc2UgS1ZNX0FSTV9TVkVfQ09ORklH Ogo+ICsJCXJldHVybiBrdm1fdmNwdV9zdmVfY29uZmlnKHZjcHUsIHVzZXJwKTsKPiArCj4gKwlk ZWZhdWx0Ogo+ICsJCXJldHVybiAtRUlOVkFMOwo+ICsJfQo+ICB9Cj4KPiAgaW50IGt2bV9hcmNo X3ZjcHVfaW9jdGxfZ2V0X2ZwdShzdHJ1Y3Qga3ZtX3ZjcHUgKnZjcHUsIHN0cnVjdCBrdm1fZnB1 ICpmcHUpCj4gZGlmZiAtLWdpdCBhL2FyY2gvYXJtNjQva3ZtL3Jlc2V0LmMgYi9hcmNoL2FybTY0 L2t2bS9yZXNldC5jCj4gaW5kZXggZTM3Yzc4Yi4uYzJlZGNkZSAxMDA2NDQKPiAtLS0gYS9hcmNo L2FybTY0L2t2bS9yZXNldC5jCj4gKysrIGIvYXJjaC9hcm02NC9rdm0vcmVzZXQuYwo+IEBAIC0x OSwxMCArMTksMTIgQEAKPiAgICogYWxvbmcgd2l0aCB0aGlzIHByb2dyYW0uICBJZiBub3QsIHNl ZSA8aHR0cDovL3d3dy5nbnUub3JnL2xpY2Vuc2VzLz4uCj4gICAqLwo+Cj4gKyNpbmNsdWRlIDxs aW51eC9hdG9taWMuaD4KPiAgI2luY2x1ZGUgPGxpbnV4L2Vycm5vLmg+Cj4gICNpbmNsdWRlIDxs aW51eC9rdm1faG9zdC5oPgo+ICAjaW5jbHVkZSA8bGludXgva3ZtLmg+Cj4gICNpbmNsdWRlIDxs aW51eC9od19icmVha3BvaW50Lmg+Cj4gKyNpbmNsdWRlIDxsaW51eC9zdHJpbmcuaD4KPgo+ICAj aW5jbHVkZSA8a3ZtL2FybV9hcmNoX3RpbWVyLmg+Cj4KPiBAQCAtNTQsNiArNTYsMzEgQEAgc3Rh dGljIGJvb2wgY3B1X2hhc18zMmJpdF9lbDEodm9pZCkKPiAgCXJldHVybiAhIShwZnIwICYgMHgy MCk7Cj4gIH0KPgo+ICsjaWZkZWYgQ09ORklHX0FSTTY0X1NWRQo+ICtib29sIGt2bV9zdmVfc3Vw cG9ydGVkKHZvaWQpCj4gK3sKPiArCXN0YXRpYyBib29sIHdhcm5fcHJpbnRlZCA9IGZhbHNlOwo+ ICsKPiArCWlmICghc3lzdGVtX3N1cHBvcnRzX3N2ZSgpKQo+ICsJCXJldHVybiBmYWxzZTsKPiAr Cj4gKwkvKgo+ICsJICogRm9yIG5vdywgY29uc2lkZXIgdGhlIGhhcmR3YXJlIGJyb2tlbiBpZiBp bXBsZW1lbnRhdGlvbgo+ICsJICogZGlmZmVyZW5jZXMgYmV0d2VlbiBDUFVzIGluIHRoZSBzeXN0 ZW0gcmVzdWx0IGluIHRoZSBzZXQgb2YKPiArCSAqIHZlY3RvciBsZW5ndGhzIHNhZmVseSB2aXJ0 dWFsaXNhYmxlIGZvciBndWVzdHMgYmVpbmcgbGVzcwo+ICsJICogdGhhbiB0aGUgc2V0IHByb3Zp ZGVkIHRvIHVzZXJzcGFjZToKPiArCSAqLwo+ICsJaWYgKHN2ZV9tYXhfdmlydHVhbGlzYWJsZV92 bCAhPSBzdmVfbWF4X3ZsKSB7Cj4gKwkJaWYgKCF4Y2hnKCZ3YXJuX3ByaW50ZWQsIHRydWUpKQo+ ICsJCQlrdm1fZXJyKCJIYXJkd2FyZSBTVkUgaW1wbGVtZW50YXRpb25zCj4gbWlzbWF0Y2hlZDog c3VwcHJlc3NpbmcgU1ZFIGZvciBndWVzdHMuIik7CgpUaGlzIHNlZW1zIGxpa2UgeW91IGFyZSBy ZS1pbnZlbnRpbmcgV0FSTl9PTkNFIGZvciB0aGUgc2FrZSBvZiBoYXZpbmcKImt2bSBbJWldOiAi IGluIHlvdXIgcHJpbnRrIHN0cmluZy4KCj4gKwo+ICsJCXJldHVybiBmYWxzZTsKPiArCX0KPiAr Cj4gKwlyZXR1cm4gdHJ1ZTsKPiArfQo+ICsjZW5kaWYKPiArCj4gIC8qKgo+ICAgKiBrdm1fYXJj aF9kZXZfaW9jdGxfY2hlY2tfZXh0ZW5zaW9uCj4gICAqCj4gQEAgLTg1LDYgKzExMiw5IEBAIGlu dCBrdm1fYXJjaF9kZXZfaW9jdGxfY2hlY2tfZXh0ZW5zaW9uKHN0cnVjdCBrdm0gKmt2bSwgbG9u ZyBleHQpCj4gIAljYXNlIEtWTV9DQVBfVkNQVV9FVkVOVFM6Cj4gIAkJciA9IDE7Cj4gIAkJYnJl YWs7Cj4gKwljYXNlIEtWTV9DQVBfQVJNX1NWRToKPiArCQlyID0ga3ZtX3N2ZV9zdXBwb3J0ZWQo KTsKPiArCQlicmVhazsKCkZvciBkZWJ1Z2dpbmcgd2UgYWN0dWFsbHkgdXNlIHRoZSByZXR1cm4g dmFsdWUgdG8gaW5kaWNhdGUgaG93IG1hbnkKV1AvQlBzIHdlIGhhdmUuIFdlIGNvdWxkIGRvIHRo ZSBzYW1lIGhlcmUgZm9yIG1heCBudW1iZXIgb2YgVlFzIGJ1dCBJCmd1ZXNzIEtWTV9BUk1fU1ZF X0NPTkZJR19RVUVSWSByZXBvcnRzIGEgbXVjaCByaWNoZXIgc2V0IG9mIGluZm9ybWF0aW9uLgpI b3dldmVyIHRoaXMgZG9lcyBiZWcgdGhlIHF1ZXN0aW9uIG9mIGhvdyB1c2VmdWwgYWxsIHRoaXMg ZXh0cmEKaW5mb3JtYXRpb24gaXMgdG8gdGhlIGd1ZXN0IHByb2dyYW0/CgpBIGR1bWJlciBpbXBs ZW1lbnRhdGlvbiB3b3VsZCBiZToKClFFTVUgICAgICAgICAgICAgICAgIHwgICAgICAgIEtlcm5l bAoKS1ZNX0NBUF9BUk1fU1ZFICAtLS0tLS0tLS0+CiAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgIE1heCBWUT1uCiAgICAgICAgICAgVlEvMCAgPC0tLS0tLS0tLQoKV2Ugd2FudCBuIDwgbWF4 IFZRCgpLVk1fQVJNX1NWRV9DT05GSUcobikgLS0tLT4KICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgVW5zdXBwb3J0ZWQgVlEKICAgICAgICAgICBFSU5WQUwgPC0tLS0tLS0tCgpXZWlyZCBI VyBjYW4ndCBzdXBwb3J0IG91ciBjaG9pY2Ugb2Ygbi4KR2l2ZSB1cCBvciB0cnkgYW5vdGhlciB2 YWx1ZS4KCktWTV9BUk1fU1ZFX0NPTkZJRyhuLTEpIC0tLT4KICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgVGhhdCdzIE9LCiAgICAgICAgICAgMCAoT0spIDwtLS0tLS0tLS0KCkl0IGltcG9z ZXMgbW9yZSBoZWF2eSBsaWZ0aW5nIG9uIHRoZSB1c2Vyc3BhY2Ugc2lkZSBvZiB0aGluZ3MgYnV0 IEkKd291bGQgZXhwZWN0IHRoZSAibm9ybWFsIiBjYXNlIHdvdWxkIGJlIHNhbmUgaGFyZHdhcmUg c3VwcG9ydHMgYWxsIFZMcwpmcm9tIE1heCBWUSB0byAxLiBBbmQgZm9yIGNhc2VzIHdoZXJlIGl0 IGRvZXNuJ3QgaXRlcmF0aW5nIHRocm91Z2gKc2V2ZXJhbCBLVk1fQVJNX1NWRV9DT05GSUcgc3Rl cHMgaXMgYSBzdGFydC11cCBjb3N0IG5vdCBhIHJ1bnRpbWUgb25lLgoKVGhpcyB3b3VsZCBtZWFu IG9uZSBjYXBhYmlsaXR5IGFuZCBvbmUgU1ZFX0NPTkZJRyBzdWItY29tbWFuZCB3aXRoIGEgc2lu Z2xlCnBhcmFtZXRlci4gV291bGQgY291bGQgYWx3YXlzIGFkZCB0aGUgZXh0ZW5kIHRoZSBpbnRl cmZhY2UgbGF0ZXIgYnV0IEkKd29uZGVyIGlmIHdlIGFyZSBnb2xkIHBsYXRpbmcgdGhlIEFQSSB0 b28gZWFybHkgaGVyZT8KCldoYXQgZG8gdGhlIG1haW50YWluZXJzIHRoaW5nPwoKCj4gIAlkZWZh dWx0Ogo+ICAJCXIgPSAwOwo+ICAJfQo+IEBAIC05Miw2ICsxMjIsMjEgQEAgaW50IGt2bV9hcmNo X2Rldl9pb2N0bF9jaGVja19leHRlbnNpb24oc3RydWN0IGt2bSAqa3ZtLCBsb25nIGV4dCkKPiAg CXJldHVybiByOwo+ICB9Cj4KPiAraW50IGt2bV9yZXNldF9zdmUoc3RydWN0IGt2bV92Y3B1ICp2 Y3B1KQo+ICt7Cj4gKwlpZiAoIXZjcHVfaGFzX3N2ZSh2Y3B1KSkKPiArCQlyZXR1cm4gMDsKPiAr Cj4gKwlpZiAoV0FSTl9PTighdmNwdS0+YXJjaC5zdmVfc3RhdGUgfHwKPiArCQkgICAgIXN2ZV92 bF92YWxpZCh2Y3B1LT5hcmNoLnN2ZV9tYXhfdmwpKSkKPiArCQlyZXR1cm4gLUVJTzsKCkZvciBz b21lIHJlYXNvbiB1c2luZyBXQVJOX09OIGZvciBzaWRlIGVmZmVjdHMgc2VlbXMgc2tldGNoeSBi dXQgd2hpbGUKQlVHX09OIGNhbiBjb21waWxlIGF3YXkgdG8gbm90aGluZyBpdCBzZWVtcyBXQVJO X09OIGhhcyBiZWVuIGRlc2lnbmVkIHRvCmFsd2F5cyBnaXZlIHlvdSBhIHJlc3VsdCBvZiB0aGUg Y29uZGl0aW9uIHNvIG5ldmVyIG1pbmQuLi4KCj4gKwo+ICsJbWVtc2V0KHZjcHUtPmFyY2guc3Zl X3N0YXRlLCAwLAo+ICsJICAgICAgIFNWRV9TSUdfUkVHU19TSVpFKHN2ZV92cV9mcm9tX3ZsKHZj cHUtPmFyY2guc3ZlX21heF92bCkpKTsKPiArCj4gKwlyZXR1cm4gMDsKPiArfQo+ICsKPiAgLyoq Cj4gICAqIGt2bV9yZXNldF92Y3B1IC0gc2V0cyBjb3JlIHJlZ2lzdGVycyBhbmQgc3lzX3JlZ3Mg dG8gcmVzZXQgdmFsdWUKPiAgICogQHZjcHU6IFRoZSBWQ1BVIHBvaW50ZXIKPiBAQCAtMTAzLDYg KzE0OCw3IEBAIGludCBrdm1fYXJjaF9kZXZfaW9jdGxfY2hlY2tfZXh0ZW5zaW9uKHN0cnVjdCBr dm0gKmt2bSwgbG9uZyBleHQpCj4gIGludCBrdm1fcmVzZXRfdmNwdShzdHJ1Y3Qga3ZtX3ZjcHUg KnZjcHUpCj4gIHsKPiAgCWNvbnN0IHN0cnVjdCBrdm1fcmVncyAqY3B1X3Jlc2V0Owo+ICsJaW50 IHJldDsKPgo+ICAJc3dpdGNoICh2Y3B1LT5hcmNoLnRhcmdldCkgewo+ICAJZGVmYXVsdDoKPiBA QCAtMTIwLDYgKzE2NiwxMCBAQCBpbnQga3ZtX3Jlc2V0X3ZjcHUoc3RydWN0IGt2bV92Y3B1ICp2 Y3B1KQo+ICAJLyogUmVzZXQgY29yZSByZWdpc3RlcnMgKi8KPiAgCW1lbWNweSh2Y3B1X2dwX3Jl Z3ModmNwdSksIGNwdV9yZXNldCwgc2l6ZW9mKCpjcHVfcmVzZXQpKTsKPgo+ICsJcmV0ID0ga3Zt X3Jlc2V0X3N2ZSh2Y3B1KTsKPiArCWlmIChyZXQpCj4gKwkJcmV0dXJuIHJldDsKPiArCj4gIAkv KiBSZXNldCBzeXN0ZW0gcmVnaXN0ZXJzICovCj4gIAlrdm1fcmVzZXRfc3lzX3JlZ3ModmNwdSk7 Cj4KPiBkaWZmIC0tZ2l0IGEvaW5jbHVkZS91YXBpL2xpbnV4L2t2bS5oIGIvaW5jbHVkZS91YXBp L2xpbnV4L2t2bS5oCj4gaW5kZXggN2MzYzVjYy4uNDg4Y2E1NiAxMDA2NDQKPiAtLS0gYS9pbmNs dWRlL3VhcGkvbGludXgva3ZtLmgKPiArKysgYi9pbmNsdWRlL3VhcGkvbGludXgva3ZtLmgKPiBA QCAtOTUzLDYgKzk1Myw3IEBAIHN0cnVjdCBrdm1fcHBjX3Jlc2l6ZV9ocHQgewo+ICAjZGVmaW5l IEtWTV9DQVBfTkVTVEVEX1NUQVRFIDE1Nwo+ICAjZGVmaW5lIEtWTV9DQVBfQVJNX0lOSkVDVF9T RVJST1JfRVNSIDE1OAo+ICAjZGVmaW5lIEtWTV9DQVBfTVNSX1BMQVRGT1JNX0lORk8gMTU5Cj4g KyNkZWZpbmUgS1ZNX0NBUF9BUk1fU1ZFIDE2MAo+Cj4gICNpZmRlZiBLVk1fQ0FQX0lSUV9ST1VU SU5HCj4KPiBAQCAtMTQwMCw2ICsxNDAxLDkgQEAgc3RydWN0IGt2bV9lbmNfcmVnaW9uIHsKPiAg I2RlZmluZSBLVk1fR0VUX05FU1RFRF9TVEFURSAgICAgICAgIF9JT1dSKEtWTUlPLCAweGJlLCBz dHJ1Y3Qga3ZtX25lc3RlZF9zdGF0ZSkKPiAgI2RlZmluZSBLVk1fU0VUX05FU1RFRF9TVEFURSAg ICAgICAgIF9JT1coS1ZNSU8sICAweGJmLCBzdHJ1Y3Qga3ZtX25lc3RlZF9zdGF0ZSkKPgo+ICsv KiBBdmFpbGFibGUgd2l0aCBLVk1fQ0FQX0FSTV9TVkUgKi8KPiArI2RlZmluZSBLVk1fQVJNX1NW RV9DT05GSUcJICBfSU9XUihLVk1JTywgIDB4YzAsIHN0cnVjdCBrdm1fc3ZlX3ZscykKPiArCj4g IC8qIFNlY3VyZSBFbmNyeXB0ZWQgVmlydHVhbGl6YXRpb24gY29tbWFuZCAqLwo+ICBlbnVtIHNl dl9jbWRfaWQgewo+ICAJLyogR3Vlc3QgaW5pdGlhbGl6YXRpb24gY29tbWFuZHMgKi8KCgotLQpB bGV4IEJlbm7DqWUKX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f X18Ka3ZtYXJtIG1haWxpbmcgbGlzdAprdm1hcm1AbGlzdHMuY3MuY29sdW1iaWEuZWR1Cmh0dHBz Oi8vbGlzdHMuY3MuY29sdW1iaWEuZWR1L21haWxtYW4vbGlzdGluZm8va3ZtYXJtCg== From mboxrd@z Thu Jan 1 00:00:00 1970 From: alex.bennee@linaro.org (Alex =?utf-8?Q?Benn=C3=A9e?=) Date: Thu, 22 Nov 2018 15:23:13 +0000 Subject: [RFC PATCH v2 19/23] KVM: arm64/sve: Report and enable SVE API extensions for userspace In-Reply-To: <1538141967-15375-20-git-send-email-Dave.Martin@arm.com> References: <1538141967-15375-1-git-send-email-Dave.Martin@arm.com> <1538141967-15375-20-git-send-email-Dave.Martin@arm.com> Message-ID: <87a7m1i1b2.fsf@linaro.org> To: linux-arm-kernel@lists.infradead.org List-Id: linux-arm-kernel.lists.infradead.org Dave Martin writes: > This patch adds the necessary API extensions to allow userspace to > detect SVE support for guests and enable it. > > A new capability KVM_CAP_ARM_SVE is defined to allow userspace to > detect the availability of the KVM SVE API extensions in the usual > way. > > Userspace needs to enable SVE explicitly per vcpu and configure the > set of SVE vector lengths available to the guest before the vcpu is > allowed to run. For these purposes, a new arm64-specific vcpu > ioctl KVM_ARM_SVE_CONFIG is added, with the following subcommands > (in rough order of expected use): > > KVM_ARM_SVE_CONFIG_QUERY: report the set of vector lengths > supported by this host. > > The resulting set can be supplied directly to > KVM_ARM_SVE_CONFIG_SET in order to obtain the maximal possible > set, or used to inform userspace's decision on the appropriate > set of vector lengths (possibly taking into account the > configuration of other nodes in the cluster so that the VM can > migrate freely). > > KVM_ARM_SVE_CONFIG_SET: enable SVE for this vcpu and configure the > set of vector lengths it offers to the guest. > > This can only be done once, before the vcpu is run. > > KVM_ARM_SVE_CONFIG_GET: report the set of vector lengths available > to the guest on this vcpu (for use when snapshotting or > migrating a VM). > > Signed-off-by: Dave Martin > --- > > Changes since RFCv1: > > * The new feature bit for PREFERRED_TARGET / VCPU_INIT is gone in > favour of a capability and a new ioctl to enable/configure SVE. > > Perhaps the SVE configuration could be done via device attributes, > but it still has to be done early, so crowbarring support for this > behind a generic API may cause more trouble than it solves. > > This is still up for discussion if anybody feels strongly about it. > > * An ioctl KVM_ARM_SVE_CONFIG has been added to report the set of > vector lengths available and configure SVE for a vcpu. > > To reduce ioctl namespace pollution the new operations are grouped > as subcommands under a single ioctl, since they use the same > argument format anyway. > --- > arch/arm64/include/asm/kvm_host.h | 8 +- > arch/arm64/include/uapi/asm/kvm.h | 14 ++++ > arch/arm64/kvm/guest.c | 164 +++++++++++++++++++++++++++++++++++++- > arch/arm64/kvm/reset.c | 50 ++++++++++++ > include/uapi/linux/kvm.h | 4 + > 5 files changed, 238 insertions(+), 2 deletions(-) > > diff --git a/arch/arm64/include/asm/kvm_host.h b/arch/arm64/include/asm/kvm_host.h > index bbde597..5225485 100644 > --- a/arch/arm64/include/asm/kvm_host.h > +++ b/arch/arm64/include/asm/kvm_host.h > @@ -52,6 +52,12 @@ > > DECLARE_STATIC_KEY_FALSE(userspace_irqchip_in_use); > > +#ifdef CONFIG_ARM64_SVE > +bool kvm_sve_supported(void); > +#else > +static inline bool kvm_sve_supported(void) { return false; } > +#endif > + > int __attribute_const__ kvm_target_cpu(void); > int kvm_reset_vcpu(struct kvm_vcpu *vcpu); > int kvm_arch_dev_ioctl_check_extension(struct kvm *kvm, long ext); > @@ -441,7 +447,7 @@ static inline void kvm_arch_sync_events(struct kvm *kvm) {} > static inline void kvm_arch_sched_in(struct kvm_vcpu *vcpu, int cpu) {} > static inline void kvm_arch_vcpu_block_finish(struct kvm_vcpu *vcpu) {} > > -static inline void kvm_arm_arch_vcpu_uninit(struct kvm_vcpu *vcpu) {} > +void kvm_arm_arch_vcpu_uninit(struct kvm_vcpu *vcpu); > > void kvm_arm_init_debug(void); > void kvm_arm_setup_debug(struct kvm_vcpu *vcpu); > diff --git a/arch/arm64/include/uapi/asm/kvm.h b/arch/arm64/include/uapi/asm/kvm.h > index 1ff68fa..94f6932 100644 > --- a/arch/arm64/include/uapi/asm/kvm.h > +++ b/arch/arm64/include/uapi/asm/kvm.h > @@ -32,6 +32,7 @@ > #define KVM_NR_SPSR 5 > > #ifndef __ASSEMBLY__ > +#include > #include > #include > #include > @@ -108,6 +109,19 @@ struct kvm_vcpu_init { > __u32 features[7]; > }; > > +/* Vector length set for KVM_ARM_SVE_CONFIG */ > +struct kvm_sve_vls { > + __u16 cmd; > + __u16 max_vq; > + __u16 _reserved[2]; > + __u64 required_vqs[__KERNEL_DIV_ROUND_UP(SVE_VQ_MAX - SVE_VQ_MIN + 1, 64)]; > +}; > + > +/* values for cmd: */ > +#define KVM_ARM_SVE_CONFIG_QUERY 0 /* query what the host can support */ > +#define KVM_ARM_SVE_CONFIG_SET 1 /* enable SVE for vcpu and set VLs */ > +#define KVM_ARM_SVE_CONFIG_GET 2 /* read the set of VLs for a vcpu */ > + > struct kvm_sregs { > }; > > diff --git a/arch/arm64/kvm/guest.c b/arch/arm64/kvm/guest.c > index 331b85e..d96145a 100644 > --- a/arch/arm64/kvm/guest.c > +++ b/arch/arm64/kvm/guest.c > @@ -26,6 +26,9 @@ > #include > #include > #include > +#include > +#include > +#include > #include > #include > #include > @@ -56,6 +59,11 @@ int kvm_arch_vcpu_setup(struct kvm_vcpu *vcpu) > return 0; > } > > +void kvm_arm_arch_vcpu_uninit(struct kvm_vcpu *vcpu) > +{ > + kfree(vcpu->arch.sve_state); > +} > + > static u64 core_reg_offset_from_id(u64 id) > { > return id & ~(KVM_REG_ARCH_MASK | KVM_REG_SIZE_MASK | KVM_REG_ARM_CORE); > @@ -546,10 +554,164 @@ int kvm_vcpu_preferred_target(struct kvm_vcpu_init *init) > return 0; > } > > +#define VQS_PER_U64 64 > +#define vq_word(vqs, vq) (&(vqs)[((vq) - SVE_VQ_MIN) / VQS_PER_U64]) > +#define vq_mask(vq) ((u64)1 << (((vq) - SVE_VQ_MIN) % VQS_PER_U64)) > + > +static void set_vq(u64 *vqs, unsigned int vq) > +{ > + *vq_word(vqs, vq) |= vq_mask(vq); > +} > + > +static bool vq_set(const u64 *vqs, unsigned int vq) > +{ > + return *vq_word(vqs, vq) & vq_mask(vq); > +} > + > +static int kvm_vcpu_set_sve_vls(struct kvm_vcpu *vcpu, struct kvm_sve_vls *vls, > + struct kvm_sve_vls __user *userp) > +{ > + unsigned int vq, max_vq; > + int ret; > + > + if (vcpu->arch.has_run_once || vcpu_has_sve(vcpu)) > + return -EBADFD; /* too late, or already configured */ > + > + BUG_ON(vcpu->arch.sve_max_vl || vcpu->arch.sve_state); > + > + if (vls->max_vq < SVE_VQ_MIN || vls->max_vq > SVE_VQ_MAX) > + return -EINVAL; > + > + max_vq = 0; > + for (vq = SVE_VQ_MIN; vq <= vls->max_vq; ++vq) { > + bool available = sve_vq_available(vq); > + bool required = vq_set(vls->required_vqs, vq); > + > + if (required != available) > + break; > + > + if (required) > + max_vq = vq; > + } > + > + if (max_vq < SVE_VQ_MIN) > + return -EINVAL; > + > + vls->max_vq = max_vq; > + ret = put_user(vls->max_vq, &userp->max_vq); > + if (ret) > + return ret; > + > + /* > + * kvm_reset_vcpu() may already have run in KVM_VCPU_INIT, so we > + * rely on kzalloc() being sufficient to reset the guest SVE > + * state here for a new vcpu. > + * > + * Subsequent resets after vcpu initialisation are handled by > + * kvm_reset_sve(). > + */ > + vcpu->arch.sve_state = kzalloc(SVE_SIG_REGS_SIZE(vls->max_vq), > + GFP_KERNEL); > + if (!vcpu->arch.sve_state) > + return -ENOMEM; > + > + vcpu->arch.flags |= KVM_ARM64_GUEST_HAS_SVE; > + vcpu->arch.sve_max_vl = sve_vl_from_vq(vls->max_vq); > + > + return 0; > +} > + > +static int __kvm_vcpu_query_sve_vls(struct kvm_sve_vls *vls, > + unsigned int max_vq, struct kvm_sve_vls __user *userp) > +{ > + unsigned int vq, max_available_vq; > + > + memset(&vls->required_vqs, 0, sizeof(vls->required_vqs)); > + > + BUG_ON(max_vq < SVE_VQ_MIN || max_vq > SVE_VQ_MAX); > + > + max_available_vq = 0; > + for (vq = SVE_VQ_MIN; vq <= max_vq; ++vq) > + if (sve_vq_available(vq)) { > + set_vq(vls->required_vqs, vq); > + max_available_vq = vq; > + } > + > + if (WARN_ON(max_available_vq < SVE_VQ_MIN)) > + return -EIO; > + > + vls->max_vq = max_available_vq; > + if (copy_to_user(userp, vls, sizeof(*vls))) > + return -EFAULT; > + > + return 0; > +} > + > +static int kvm_vcpu_query_sve_vls(struct kvm_vcpu *vcpu, struct kvm_sve_vls *vls, > + struct kvm_sve_vls __user *userp) > +{ > + BUG_ON(!sve_vl_valid(sve_max_vl)); > + > + return __kvm_vcpu_query_sve_vls(vls, > + sve_vq_from_vl(sve_max_vl), userp); > +} > + > +static int kvm_vcpu_get_sve_vls(struct kvm_vcpu *vcpu, struct kvm_sve_vls *vls, > + struct kvm_sve_vls __user *userp) > +{ > + if (!vcpu_has_sve(vcpu)) > + return -EBADFD; /* not configured yet */ > + > + BUG_ON(!sve_vl_valid(vcpu->arch.sve_max_vl)); > + > + return __kvm_vcpu_query_sve_vls(vls, > + sve_vq_from_vl(vcpu->arch.sve_max_vl), userp); > +} > + > +static int kvm_vcpu_sve_config(struct kvm_vcpu *vcpu, > + struct kvm_sve_vls __user *userp) > +{ > + struct kvm_sve_vls vls; > + > + if (!kvm_sve_supported()) > + return -EINVAL; > + > + if (copy_from_user(&vls, userp, sizeof(vls))) > + return -EFAULT; > + > + /* > + * For forwards compatibility, flush any set bits in _reserved[] > + * to tell userspace that we didn't look at them: > + */ > + memset(&vls._reserved, 0, sizeof vls._reserved); > + > + switch (vls.cmd) { > + case KVM_ARM_SVE_CONFIG_QUERY: > + return kvm_vcpu_query_sve_vls(vcpu, &vls, userp); > + > + case KVM_ARM_SVE_CONFIG_SET: > + return kvm_vcpu_set_sve_vls(vcpu, &vls, userp); > + > + case KVM_ARM_SVE_CONFIG_GET: > + return kvm_vcpu_get_sve_vls(vcpu, &vls, userp); > + > + default: > + return -EINVAL; > + } > +} > + > int kvm_arm_arch_vcpu_ioctl(struct kvm_vcpu *vcpu, > unsigned int ioctl, unsigned long arg) > { > - return -EINVAL; > + void __user *userp = (void __user *)arg; > + > + switch (ioctl) { > + case KVM_ARM_SVE_CONFIG: > + return kvm_vcpu_sve_config(vcpu, userp); > + > + default: > + return -EINVAL; > + } > } > > int kvm_arch_vcpu_ioctl_get_fpu(struct kvm_vcpu *vcpu, struct kvm_fpu *fpu) > diff --git a/arch/arm64/kvm/reset.c b/arch/arm64/kvm/reset.c > index e37c78b..c2edcde 100644 > --- a/arch/arm64/kvm/reset.c > +++ b/arch/arm64/kvm/reset.c > @@ -19,10 +19,12 @@ > * along with this program. If not, see . > */ > > +#include > #include > #include > #include > #include > +#include > > #include > > @@ -54,6 +56,31 @@ static bool cpu_has_32bit_el1(void) > return !!(pfr0 & 0x20); > } > > +#ifdef CONFIG_ARM64_SVE > +bool kvm_sve_supported(void) > +{ > + static bool warn_printed = false; > + > + if (!system_supports_sve()) > + return false; > + > + /* > + * For now, consider the hardware broken if implementation > + * differences between CPUs in the system result in the set of > + * vector lengths safely virtualisable for guests being less > + * than the set provided to userspace: > + */ > + if (sve_max_virtualisable_vl != sve_max_vl) { > + if (!xchg(&warn_printed, true)) > + kvm_err("Hardware SVE implementations > mismatched: suppressing SVE for guests."); This seems like you are re-inventing WARN_ONCE for the sake of having "kvm [%i]: " in your printk string. > + > + return false; > + } > + > + return true; > +} > +#endif > + > /** > * kvm_arch_dev_ioctl_check_extension > * > @@ -85,6 +112,9 @@ int kvm_arch_dev_ioctl_check_extension(struct kvm *kvm, long ext) > case KVM_CAP_VCPU_EVENTS: > r = 1; > break; > + case KVM_CAP_ARM_SVE: > + r = kvm_sve_supported(); > + break; For debugging we actually use the return value to indicate how many WP/BPs we have. We could do the same here for max number of VQs but I guess KVM_ARM_SVE_CONFIG_QUERY reports a much richer set of information. However this does beg the question of how useful all this extra information is to the guest program? A dumber implementation would be: QEMU | Kernel KVM_CAP_ARM_SVE ---------> Max VQ=n VQ/0 <--------- We want n < max VQ KVM_ARM_SVE_CONFIG(n) ----> Unsupported VQ EINVAL <-------- Weird HW can't support our choice of n. Give up or try another value. KVM_ARM_SVE_CONFIG(n-1) ---> That's OK 0 (OK) <--------- It imposes more heavy lifting on the userspace side of things but I would expect the "normal" case would be sane hardware supports all VLs from Max VQ to 1. And for cases where it doesn't iterating through several KVM_ARM_SVE_CONFIG steps is a start-up cost not a runtime one. This would mean one capability and one SVE_CONFIG sub-command with a single parameter. Would could always add the extend the interface later but I wonder if we are gold plating the API too early here? What do the maintainers thing? > default: > r = 0; > } > @@ -92,6 +122,21 @@ int kvm_arch_dev_ioctl_check_extension(struct kvm *kvm, long ext) > return r; > } > > +int kvm_reset_sve(struct kvm_vcpu *vcpu) > +{ > + if (!vcpu_has_sve(vcpu)) > + return 0; > + > + if (WARN_ON(!vcpu->arch.sve_state || > + !sve_vl_valid(vcpu->arch.sve_max_vl))) > + return -EIO; For some reason using WARN_ON for side effects seems sketchy but while BUG_ON can compile away to nothing it seems WARN_ON has been designed to always give you a result of the condition so never mind... > + > + memset(vcpu->arch.sve_state, 0, > + SVE_SIG_REGS_SIZE(sve_vq_from_vl(vcpu->arch.sve_max_vl))); > + > + return 0; > +} > + > /** > * kvm_reset_vcpu - sets core registers and sys_regs to reset value > * @vcpu: The VCPU pointer > @@ -103,6 +148,7 @@ int kvm_arch_dev_ioctl_check_extension(struct kvm *kvm, long ext) > int kvm_reset_vcpu(struct kvm_vcpu *vcpu) > { > const struct kvm_regs *cpu_reset; > + int ret; > > switch (vcpu->arch.target) { > default: > @@ -120,6 +166,10 @@ int kvm_reset_vcpu(struct kvm_vcpu *vcpu) > /* Reset core registers */ > memcpy(vcpu_gp_regs(vcpu), cpu_reset, sizeof(*cpu_reset)); > > + ret = kvm_reset_sve(vcpu); > + if (ret) > + return ret; > + > /* Reset system registers */ > kvm_reset_sys_regs(vcpu); > > diff --git a/include/uapi/linux/kvm.h b/include/uapi/linux/kvm.h > index 7c3c5cc..488ca56 100644 > --- a/include/uapi/linux/kvm.h > +++ b/include/uapi/linux/kvm.h > @@ -953,6 +953,7 @@ struct kvm_ppc_resize_hpt { > #define KVM_CAP_NESTED_STATE 157 > #define KVM_CAP_ARM_INJECT_SERROR_ESR 158 > #define KVM_CAP_MSR_PLATFORM_INFO 159 > +#define KVM_CAP_ARM_SVE 160 > > #ifdef KVM_CAP_IRQ_ROUTING > > @@ -1400,6 +1401,9 @@ struct kvm_enc_region { > #define KVM_GET_NESTED_STATE _IOWR(KVMIO, 0xbe, struct kvm_nested_state) > #define KVM_SET_NESTED_STATE _IOW(KVMIO, 0xbf, struct kvm_nested_state) > > +/* Available with KVM_CAP_ARM_SVE */ > +#define KVM_ARM_SVE_CONFIG _IOWR(KVMIO, 0xc0, struct kvm_sve_vls) > + > /* Secure Encrypted Virtualization command */ > enum sev_cmd_id { > /* Guest initialization commands */ -- Alex Benn?e