From mboxrd@z Thu Jan 1 00:00:00 1970 From: Alex =?utf-8?Q?Benn=C3=A9e?= Subject: Re: [RFC PATCH v2 23/23] KVM: arm64/sve: Document KVM API extensions for SVE Date: Thu, 22 Nov 2018 15:31:51 +0000 Message-ID: <877eh5i0wo.fsf@linaro.org> References: <1538141967-15375-1-git-send-email-Dave.Martin@arm.com> <1538141967-15375-24-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 327CD4A1E5 for ; Thu, 22 Nov 2018 10:31:55 -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 xLtx5gNfzQEy for ; Thu, 22 Nov 2018 10:31:53 -0500 (EST) Received: from mail-wr1-f68.google.com (mail-wr1-f68.google.com [209.85.221.68]) by mm01.cs.columbia.edu (Postfix) with ESMTPS id B94D34A1DF for ; Thu, 22 Nov 2018 10:31:53 -0500 (EST) Received: by mail-wr1-f68.google.com with SMTP id t27so1702386wra.6 for ; Thu, 22 Nov 2018 07:31:53 -0800 (PST) In-reply-to: <1538141967-15375-24-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 YWRkcyBzZWN0aW9ucyB0byB0aGUgS1ZNIEFQSSBkb2N1bWVudGF0aW9uIGRlc2NyaWJpbmcKPiB0 aGUgZXh0ZW5zaW9ucyBmb3Igc3VwcG9ydGluZyB0aGUgU2NhbGFibGUgVmVjdG9yIEV4dGVuc2lv biAoU1ZFKQo+IGluIGd1ZXN0cy4KPgo+IFNpZ25lZC1vZmYtYnk6IERhdmUgTWFydGluIDxEYXZl Lk1hcnRpbkBhcm0uY29tPgo+IC0tLQo+ICBEb2N1bWVudGF0aW9uL3ZpcnR1YWwva3ZtL2FwaS50 eHQgfCAxNDIgKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKy0KPiAgMSBmaWxl IGNoYW5nZWQsIDEzOSBpbnNlcnRpb25zKCspLCAzIGRlbGV0aW9ucygtKQo+Cj4gZGlmZiAtLWdp dCBhL0RvY3VtZW50YXRpb24vdmlydHVhbC9rdm0vYXBpLnR4dCBiL0RvY3VtZW50YXRpb24vdmly dHVhbC9rdm0vYXBpLnR4dAo+IGluZGV4IGE1ODA2N2IuLmI4MjU3ZDQgMTAwNjQ0Cj4gLS0tIGEv RG9jdW1lbnRhdGlvbi92aXJ0dWFsL2t2bS9hcGkudHh0Cj4gKysrIGIvRG9jdW1lbnRhdGlvbi92 aXJ0dWFsL2t2bS9hcGkudHh0Cj4gQEAgLTIwNTQsMTMgKzIwNTQsMjEgQEAgU3BlY2lmaWNhbGx5 Ogo+ICAgIDB4NjAzMCAwMDAwIDAwMTAgMDA0YyBTUFNSX1VORCAgICA2NCAgc3BzcltLVk1fU1BT Ul9VTkRdCj4gICAgMHg2MDMwIDAwMDAgMDAxMCAwMDRlIFNQU1JfSVJRICAgIDY0ICBzcHNyW0tW TV9TUFNSX0lSUV0KPiAgICAweDYwNjAgMDAwMCAwMDEwIDAwNTAgU1BTUl9GSVEgICAgNjQgIHNw c3JbS1ZNX1NQU1JfRklRXQo+IC0gIDB4NjA0MCAwMDAwIDAwMTAgMDA1NCBWMCAgICAgICAgIDEy OCAgZnBfcmVncy52cmVnc1swXQo+IC0gIDB4NjA0MCAwMDAwIDAwMTAgMDA1OCBWMSAgICAgICAg IDEyOCAgZnBfcmVncy52cmVnc1sxXQo+ICsgIDB4NjA0MCAwMDAwIDAwMTAgMDA1NCBWMCAgICAg ICAgIDEyOCAgZnBfcmVncy52cmVnc1swXSAgICAoKikKPiArICAweDYwNDAgMDAwMCAwMDEwIDAw NTggVjEgICAgICAgICAxMjggIGZwX3JlZ3MudnJlZ3NbMV0gICAgKCopCj4gICAgICAuLi4KPiAt ICAweDYwNDAgMDAwMCAwMDEwIDAwZDAgVjMxICAgICAgICAxMjggIGZwX3JlZ3MudnJlZ3NbMzFd Cj4gKyAgMHg2MDQwIDAwMDAgMDAxMCAwMGQwIFYzMSAgICAgICAgMTI4ICBmcF9yZWdzLnZyZWdz WzMxXSAgICgqKQo+ICAgIDB4NjAyMCAwMDAwIDAwMTAgMDBkNCBGUFNSICAgICAgICAzMiAgZnBf cmVncy5mcHNyCj4gICAgMHg2MDIwIDAwMDAgMDAxMCAwMGQ1IEZQQ1IgICAgICAgIDMyICBmcF9y ZWdzLmZwY3IKPgo+ICsoKikgVGhlc2UgZW5jb2RpbmdzIGFyZSBub3QgYWNjZXB0ZWQgZm9yIFNW RS1lbmFibGVkIHZjcHVzLiAgU2VlCj4gKyAgICBLVk1fQVJNX1NWRV9DT05GSUcgZm9yIGRldGFp bHMgb2YgaG93IFNWRSBzdXBwb3J0IGlzIGNvbmZpZ3VyZWQgZm9yCj4gKyAgICBhIHZjcHUuCj4g Kwo+ICsgICAgVGhlIGVxdWl2YWxlbnQgcmVnaXN0ZXIgY29udGVudCBjYW4gYmUgYWNjZXNzZWQg dmlhIGJpdHMgWzIwNDc6MF0KPiBvZgoKWW91IG1lYW4gWzEyNzowXSBJIHRoaW5rLgoKPiArICAg IHRoZSBjb3JyZXNwb25kaW5nIFNWRSBabiByZWdpc3RlcnMgaW5zdGVhZCBmb3IgdmNwdXMgdGhh dCBoYXZlIFNWRQo+ICsgICAgZW5hYmxlZCAoc2VlIGJlbG93KS4KPiArCj4gIGFybTY0IENDU0lE UiByZWdpc3RlcnMgYXJlIGRlbXVsdGlwbGV4ZWQgYnkgQ1NTRUxSIHZhbHVlOgo+ICAgIDB4NjAy MCAwMDAwIDAwMTEgMDAgPGNzc2Vscjo4Pgo+Cj4gQEAgLTIwNzAsNiArMjA3OCwxNCBAQCBhcm02 NCBzeXN0ZW0gcmVnaXN0ZXJzIGhhdmUgdGhlIGZvbGxvd2luZyBpZCBiaXQgcGF0dGVybnM6Cj4g IGFybTY0IGZpcm13YXJlIHBzZXVkby1yZWdpc3RlcnMgaGF2ZSB0aGUgZm9sbG93aW5nIGJpdCBw YXR0ZXJuOgo+ICAgIDB4NjAzMCAwMDAwIDAwMTQgPHJlZ25vOjE2Pgo+Cj4gK2FybTY0IFNWRSBy ZWdpc3RlcnMgaGF2ZSB0aGUgZm9sbG93aW5nIGJpdCBwYXR0ZXJuczoKPiArICAweDYwODAgMDAw MCAwMDE1IDAwIDxuOjU+IDxzbGljZTo1PiAgIFpuIGJpdHNbMjA0OCpzbGljZSArIDIwNDcgOiAy MDQ4KnNsaWNlXQo+ICsgIDB4NjA1MCAwMDAwIDAwMTUgMDQgPG46ND4gPHNsaWNlOjU+ICAgUG4g Yml0c1syNTYqc2xpY2UgKyAyNTUgOiAyNTYqc2xpY2VdCj4gKyAgMHg2MDUwIDAwMDAgMDAxNSAw NjAgPHNsaWNlOjU+ICAgICAgICBGRlIgYml0c1syNTYqc2xpY2UgKyAyNTUgOiAyNTYqc2xpY2Vd Cj4gKwo+ICsgIFRoZXNlIHJlZ2lzdGVycyBhcmUgb25seSBhY2Nlc3NpYmxlIG9uIFNWRS1lbmFi bGVkIHZjcHVzLiAgU2VlCj4gKyAgS1ZNX0FSTV9TVkVfQ09ORklHIGZvciBkZXRhaWxzLgo+ICsK Pgo+ICBNSVBTIHJlZ2lzdGVycyBhcmUgbWFwcGVkIHVzaW5nIHRoZSBsb3dlciAzMiBiaXRzLiAg VGhlIHVwcGVyIDE2IG9mIHRoYXQgaXMKPiAgdGhlIHJlZ2lzdGVyIGdyb3VwIHR5cGU6Cj4gQEAg LTM3MDAsNiArMzcxNiwxMjYgQEAgUmV0dXJuczogMCBvbiBzdWNjZXNzLCAtMSBvbiBlcnJvcgo+ ICBUaGlzIGNvcGllcyB0aGUgdmNwdSdzIGt2bV9uZXN0ZWRfc3RhdGUgc3RydWN0IGZyb20gdXNl cnNwYWNlIHRvIHRoZSBrZXJuZWwuICBGb3IKPiAgdGhlIGRlZmluaXRpb24gb2Ygc3RydWN0IGt2 bV9uZXN0ZWRfc3RhdGUsIHNlZSBLVk1fR0VUX05FU1RFRF9TVEFURS4KPgo+ICs0LjExNiBLVk1f QVJNX1NWRV9DT05GSUcKPiArCj4gK0NhcGFiaWxpdHk6IEtWTV9DQVBfQVJNX1NWRQo+ICtBcmNo aXRlY3R1cmVzOiBhcm02NAo+ICtUeXBlOiB2bSBhbmQgdmNwdSBpb2N0bAo+ICtQYXJhbWV0ZXJz OiBzdHJ1Y3Qga3ZtX3N2ZV92bHMgKGluL291dCkKPiArUmV0dXJuczogMCBvbiBzdWNjZXNzCj4g K0Vycm9yczoKPiArICBFSU5WQUw6ICAgIFVucmVjb2duaXNlZCBzdWJjb21tYW5kIG9yIGJhZCBh cmd1bWVudHMKPiArICBFQkFERkQ6ICAgIHZjcHUgaW4gd3Jvbmcgc3RhdGUgZm9yIHJlcXVlc3QK PiArICAgICAgICAgICAgIChLVk1fQVJNX1NWRV9DT05GSUdfU0VULCBLVk1fQVJNX1NWRV9DT05G SUdfU0VUKQo+ICsgIEVOT01FTTogICAgT3V0IG9mIG1lbW9yeQo+ICsgIEVGQVVMVDogICAgQmFk IHVzZXIgYWRkcmVzcwo+ICsKPiArc3RydWN0IGt2bV9zdmVfdmxzIHsKPiArCV9fdTE2IGNtZDsK PiArCV9fdTE2IG1heF92cTsKPiArCV9fdTE2IF9yZXNlcnZlZFsyXTsKPiArCV9fdTY0IHJlcXVp cmVkX3Zxc1s4XTsKPiArfTsKPiArCj4gK0dlbmVyYWw6Cj4gKwo+ICtjbWQ6IFRoaXMgaW9jdGwg c3VwcG9ydHMgYSBmZXcgZGlmZmVyZW50IHN1YmNvbW1hbmRzLCBzZWxlY3RlZCBieSB0aGUKPiAr dmFsdWUgb2YgY21kIChkZXNjcmliZWQgaW4gZGV0YWlsIGluIHRoZSBmb2xsb3dpbmcgc2VjdGlv bnMpLgo+ICsKPiArX3Jlc2VydmVkW106IHRoZXNlIGZpZWxkcyBtYXkgYmUgbWVhbmluZ2Z1bCB0 byBsYXRlciBrZXJuZWxzLiAgRm9yCj4gK2ZvcndhcmQgY29tcGF0aWJpbGl0eSwgdGhleSBtdXN0 IGJlIHplcm9lZCBiZWZvcmUgaW52b2tpbmcgdGhpcyBpb2N0bAo+ICtmb3IgdGhlIGZpcnN0IHRp bWUgb24gYSBnaXZlbiBzdHJ1Y3Qga3ZtX3N2ZV92bHMgb2JqZWN0LiAgKFNvLCBtZW1zZXQoKQo+ ICtpdCB0byB6ZXJvIGJlZm9yZSBmaXJzdCB1c2UsIG9yIGFsbG9jYXRlIHdpdGggY2FsbG9jKCkg Zm9yIGV4YW1wbGUuKQo+ICsKPiArbWF4X3ZxLCByZXF1aXJlZF92cXNbXTogZW5jb2RlIGEgc2V0 IG9mIFNWRSB2ZWN0b3IgbGVuZ3Rocy4gIFRoZSBzZXQgaXMKPiArZW5jb2RlZCBhcyBmb2xsb3dz Ogo+ICsKPiArSWYgKGEgKiA2NCArIGIgKyAxKSA8PSBtYXhfdnEsIHRoZW4gdGhlIGJpdCByZXBy ZXNlbnRlZCBieQo+ICsKPiArICAgIHJlcXVpcmVkX3Zxc1thXSAmICgoX191NjQpMSA8PCBiKQo+ ICsKPiArKHdoZXJlIGEgaXMgaW4gdGhlIHJhbmdlIDAuLjcgYW5kIGIgaXMgaW4gdGhlIHJhbmdl IDAuLjYzKQo+ICtpbmRpY2F0ZXMgdGhhdCB0aGUgdmVjdG9yIGxlbmd0aCAoYSAqIDY0ICsgYiAr IDEpICogMTI4IGJpdHMgaXMKPiArc3VwcG9ydGVkIChLVk1fQVJNX1NWRV9DT05GSUdfUVVFUlks IEtWTV9BUk1fU1ZFX0NPTkZJR19HRVQpIG9yIHJlcXVpcmVkCj4gKyhLVk1fQVJNX1NWRV9DT05G SUdfU0VUKS4KPiArCj4gK0lmIChhICogNjQgKyBiICsgMSkgPiBtYXhfdnEsIHRoZW4gdGhlIHZl Y3RvciBsZW5ndGgKPiArKGEgKiA2NCArIGIgKyAxKSAqIDEyOCBiaXRzIGlzIHVuc3VwcG9ydGVk IG9yIHByb2hpYml0ZWQgcmVzcGVjdGl2ZWx5Lgo+ICtJbiBvdGhlciB3b3Jkcywgb25seSB0aGUg Zmlyc3QgbWF4X3ZxIGJpdHMgaW4gcmVxdWlyZWRfdnFzW10gYXJlCj4gK3NpZ25pZmljYW50OyBy ZW1haW5pbmcgYml0cyBhcmUgaW1wbGljaXRseSB0cmVhdGVkIGFzIGlmIHRoZXkgd2VyZSB6ZXJv Lgo+ICsKPiArbWF4X3ZxIG11c3QgYmUgaW4gdGhlIHJhbmdlIFNWRV9WUV9NSU4gKDEpIHRvIFNW RV9WUV9NQVggKDUxMikuCj4gKwo+ICtTZWUgRG9jdW1lbnRhdGlvbi9hcm02NC9zdmUudHh0IGZv ciBhbiBleHBsYW5hdGlvbiBvZiB2ZWN0b3IgbGVuZ3RocyBhbmQKPiArdGhlIG1lYW5pbmcgYXNz b2NpYXRlZCB3aXRoICJWUSIuCj4gKwo+ICtTdWJjb21tYW5kczoKPiArCj4gKy8qIHZhbHVlcyBm b3IgY21kOiAqLwo+ICsjZGVmaW5lIEtWTV9BUk1fU1ZFX0NPTkZJR19RVUVSWQkwIC8qIHF1ZXJ5 IHdoYXQgdGhlIGhvc3QgY2FuIHN1cHBvcnQgKi8KPiArI2RlZmluZSBLVk1fQVJNX1NWRV9DT05G SUdfU0VUCQkxIC8qIGVuYWJsZSBTVkUgZm9yIHZjcHUgYW5kIHNldCBWTHMgKi8KPiArI2RlZmlu ZSBLVk1fQVJNX1NWRV9DT05GSUdfR0VUCQkyIC8qIHJlYWQgdGhlIHNldCBvZiBWTHMgZm9yIGEg dmNwdSAqLwo+ICsKPiArU3ViY29tbWFuZCBkZXRhaWxzOgo+ICsKPiArNC4xMTYuMSBLVk1fQVJN X1NWRV9DT05GSUdfUVVFUlkKPiArVHlwZTogdm0gYW5kIHZjcHUKPiArCj4gK1JldHJpZXZlIHRo ZSBmdWxsIHNldCBvZiBTVkUgdmVjdG9yIGxlbmd0aHMgYXZhaWxhYmxlIGZvciB1c2UgYnkgS1ZN Cj4gK2d1ZXN0cyBvbiB0aGlzIGhvc3QuICBUaGUgcmVzdWx0IGlzIGluZGVwZW5kZW50IG9mIHdo aWNoIHZjcHUgdGhpcwo+ICtjb21tYW5kIGlzIGludm9rZWQgb24uICBBcyBhIGNvbnZlbmllbmNl LCBpdCBtYXkgYWxzbyBiZSBpbnZva2VkIG9uIGEKPiArdm0gZmlsZSBkZXNjcmlwdG9yLCBlbGlt aW5hdGluZyB0aGUgbmVlZCB0byBjcmVhdGUgYSB2Y3B1IGZpcnN0Lgo+ICsKPiArNC4xMTYuMiBL Vk1fQVJNX1NWRV9DT05GSUdfU0VUCj4gK1R5cGU6IHZjcHUgb25seQo+ICsKPiArRW5hYmxlcyBT VkUgZm9yIHRoZSB2Y3B1IGFuZCBzZXRzIHRoZSBzZXQgb2YgU1ZFIHZlY3RvciBsZW5ndGhzIHRo YXQKPiArd2lsbCBiZSB2aXNpYmxlIHRvIHRoZSBndWVzdC4KPiArCj4gK1RoaXMgaXMgdGhlIG9u bHkgd2F5IHRvIGVuYWJsZSBTVkUgZm9yIGEgdmNwdTogaWYgdGhpcyBjb21tYW5kIGlzIG5vdAo+ ICtpbnZva2VkIGZvciBhIHZjcHUgdGhlbiBTVkUgd2lsbCBub3QgYmUgYXZhaWxhYmxlIHRvIHRo ZSBndWVzdCBvbiB0aGlzCj4gK3ZjcHUuCj4gKwo+ICtUaGlzIHN1YmNvbW1hbmQgaXMgb25seSBw ZXJtaXR0ZWQgb25jZSBwZXIgdmNwdSwgYmVmb3JlIEtWTV9SVU4gaGFzIGJlZW4KPiAraW52b2tl ZCBmb3IgdGhlIHZjcHUgZm9yIHRoZSBmaXJzdCB0aW1lLiAgT3RoZXJ3aXNlLCB0aGUgY29tbWFu ZCBmYWlscwo+ICt3aXRoIC1FQkFERkQgYW5kIHRoZSBzdGF0ZSBvZiB0aGUgdmNwdSBpcyBub3Qg bW9kaWZpZWQuCj4gKwo+ICtJbiB0eXBpY2FsIHVzZSwgdGhlIHVzZXIgc2hvdWxkIGNhbGwgS1ZN X0FSTV9TVkVfQ09ORklHX1FVRVJZIGZpcnN0IHRvCj4gK3BvcHVsYXRlIGEgc3RydWN0IGt2bV9z dmVfdmxzIHdpdGggdGhlIGZ1bGwgc2V0IG9mIHZlY3RvciBsZW5ndGhzCj4gK2F2YWlsYWJsZSBv biB0aGUgaG9zdCwgdGhlbiBzZXQgY21kID0gS1ZNX0FSTV9TVkVfQ09ORklHX1NFVCBhbmQKPiAr cmUtaXNzdWUgdGhlIEtWTV9BUk1fU1ZFX0NPTkZJRyBpb2N0bCBvbiB0aGUgZGVzaXJlZCB2Y3B1 LiAgVGhpcyB3aWxsCj4gK2NvbmZpZ3VyZSB0aGUgYmVzdCBzZXQgb2YgdmVjdG9yIGxlbmd0aHMg YXZhaWxhYmxlLiAgV2hlbiBmb2xsb3dpbmcgdGhpcwo+ICthcHByb2FjaCwgdGhlIG1heGltdW0g YXZhaWxhYmxlIHZlY3RvciBsZW5ndGggY2FuIGFsc28gYmUgcmVzdHJpY3RlZCBieQo+ICtyZWR1 Y2luZyB0aGUgdmFsdWUgb2YgbWF4X3ZxIGJlZm9yZSBpbnZva2luZyBLVk1fQVJNX1NWRV9DT05G SUdfU0VULgo+ICsKPiArRXZlcnkgcmVxdWVzdGVkIHZlY3RvciBsZW5ndGggaW4gdGhlIHN0cnVj dCBrdm1fc3ZlX3ZscyBhcmd1bWVudCBtdXN0IGJlCj4gK3N1cHBvcnRlZCBieSB0aGUgaGFyZHdh cmUuICBJbiBhZGRpdGlvbiwgZXhjZXB0IGZvciB2ZWN0b3IgbGVuZ3Rocwo+ICtncmVhdGVyIHRo YW4gdGhlIG1heGltdW0gcmVxdWVzdGVkIHZlY3RvciBsZW5ndGgsIGV2ZXJ5IHZlY3RvciBsZW5n dGgKPiArbm90IHJlcXVlc3RlZCBtdXN0ICpub3QqIGJlIHN1cHBvcnRlZCBieSB0aGUgaGFyZHdh cmUuICAoVGhlIGxhdHRlcgo+ICtyZXN0cmljdGlvbiBtYXkgYmUgcmVsYXhlZCBpbiB0aGUgZnV0 dXJlLikgIElmIHRoZSByZXF1ZXN0ZWQgc2V0IG9mCj4gK3ZlY3RvciBsZW5ndGhzIGlzIG5vdCBz dXBwb3J0YWJsZSwgdGhlIGNvbW1hbmQgZmFpbHMgd2l0aCAtRUlOVkFMIGFuZAo+ICt0aGUgc3Rh dGUgb2YgdGhlIHZjcHUgaXMgbm90IG1vZGlmaWVkLgo+ICsKPiArRGlmZmVyZW50IHZjcHVzIG9m IGEgdm0gbWF5IGJlIGNvbmZpZ3VyZWQgd2l0aCBkaWZmZXJlbnQgc2V0cyBvZiB2ZWN0b3IKPiAr bGVuZ3Rocy4gIEVxdWFsbHksIHNvbWUgdmNwdXMgbWF5IGhhdmUgU1ZFIGVuYWJsZWQgYW5kIHNv bWUgbm90Lgo+ICtIb3dldmVyLCBzdWNoIGNvbmZpZ3VyYXRpb25zIGFyZSBub3QgcmVjb21tZW5k ZWQgZXhjZXB0IGZvciB0ZXN0aW5nIGFuZAo+ICtleHBlcmltZW50YXRpb24gcHVycG9zZXMuICBB cmNoaXRlY3R1cmFsbHkgY29tcGxpYW50IGd1ZXN0IE9TZXMgd2lsbAo+ICt3b3JrLCBidXQgbWF5 IG9yIG1heSBub3QgbWFrZSBlZmZlY3RpdmUgdXNlIG9mIHRoZSByZXN1bHRpbmcKPiArY29uZmln dXJhdGlvbi4KPiArCj4gK0FmdGVyIGEgc3VjY2Vzc2Z1bCBLVk1fQVJNX1NWRV9DT05GSUdfU0VU LCBLVk1fQVJNX1NWRV9DT05GSUdfR0VUIGNhbiBiZQo+ICt1c2VkIHRvIHJldHJpZXZlIHRoZSBj b25maWd1cmVkIHNldCBvZiB2ZWN0b3IgbGVuZ3Rocy4KPiArCj4gKzQuMTE2LjMgS1ZNX0FSTV9T VkVfQ09ORklHX0dFVAo+ICtUeXBlOiB2Y3B1IG9ubHkKPiArCj4gK1RoaXMgc3ViY29tbWFuZCBy ZXR1cm5zIHRoZSBzZXQgb2YgdmVjdG9yIGxlbmd0aHMgZW5hYmxlZCBmb3IgdGhlIHZjcHUuCj4g K1NWRSBtdXN0IGhhdmUgYmVlbiBlbmFibGVkIGFuZCBjb25maWd1cmVkIGZvciB0aGlzIHZjcHUg YnkgYSBzdWNjZXNzZnVsCj4gK3ByaW9yIEtWTV9BUk1fU1ZFX0NPTkZJR19TRVQgY2FsbC4gIE90 aGVyd2lzZSwgLUVCQURGRCBpcyByZXR1cm5lZC4KPiArCj4gK1RoZSBzdGF0ZSBvZiB0aGUgdmNw dSBpcyB1bmNoYW5nZWQuCj4gKwo+ICsKPiAgNS4gVGhlIGt2bV9ydW4gc3RydWN0dXJlCj4gIC0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLQoKCi0tCkFsZXggQmVubsOpZQpfX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fXwprdm1hcm0gbWFpbGluZyBsaXN0Cmt2bWFy bUBsaXN0cy5jcy5jb2x1bWJpYS5lZHUKaHR0cHM6Ly9saXN0cy5jcy5jb2x1bWJpYS5lZHUvbWFp bG1hbi9saXN0aW5mby9rdm1hcm0K 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:31:51 +0000 Subject: [RFC PATCH v2 23/23] KVM: arm64/sve: Document KVM API extensions for SVE In-Reply-To: <1538141967-15375-24-git-send-email-Dave.Martin@arm.com> References: <1538141967-15375-1-git-send-email-Dave.Martin@arm.com> <1538141967-15375-24-git-send-email-Dave.Martin@arm.com> Message-ID: <877eh5i0wo.fsf@linaro.org> To: linux-arm-kernel@lists.infradead.org List-Id: linux-arm-kernel.lists.infradead.org Dave Martin writes: > This patch adds sections to the KVM API documentation describing > the extensions for supporting the Scalable Vector Extension (SVE) > in guests. > > Signed-off-by: Dave Martin > --- > Documentation/virtual/kvm/api.txt | 142 +++++++++++++++++++++++++++++++++++++- > 1 file changed, 139 insertions(+), 3 deletions(-) > > diff --git a/Documentation/virtual/kvm/api.txt b/Documentation/virtual/kvm/api.txt > index a58067b..b8257d4 100644 > --- a/Documentation/virtual/kvm/api.txt > +++ b/Documentation/virtual/kvm/api.txt > @@ -2054,13 +2054,21 @@ Specifically: > 0x6030 0000 0010 004c SPSR_UND 64 spsr[KVM_SPSR_UND] > 0x6030 0000 0010 004e SPSR_IRQ 64 spsr[KVM_SPSR_IRQ] > 0x6060 0000 0010 0050 SPSR_FIQ 64 spsr[KVM_SPSR_FIQ] > - 0x6040 0000 0010 0054 V0 128 fp_regs.vregs[0] > - 0x6040 0000 0010 0058 V1 128 fp_regs.vregs[1] > + 0x6040 0000 0010 0054 V0 128 fp_regs.vregs[0] (*) > + 0x6040 0000 0010 0058 V1 128 fp_regs.vregs[1] (*) > ... > - 0x6040 0000 0010 00d0 V31 128 fp_regs.vregs[31] > + 0x6040 0000 0010 00d0 V31 128 fp_regs.vregs[31] (*) > 0x6020 0000 0010 00d4 FPSR 32 fp_regs.fpsr > 0x6020 0000 0010 00d5 FPCR 32 fp_regs.fpcr > > +(*) These encodings are not accepted for SVE-enabled vcpus. See > + KVM_ARM_SVE_CONFIG for details of how SVE support is configured for > + a vcpu. > + > + The equivalent register content can be accessed via bits [2047:0] > of You mean [127:0] I think. > + the corresponding SVE Zn registers instead for vcpus that have SVE > + enabled (see below). > + > arm64 CCSIDR registers are demultiplexed by CSSELR value: > 0x6020 0000 0011 00 > > @@ -2070,6 +2078,14 @@ arm64 system registers have the following id bit patterns: > arm64 firmware pseudo-registers have the following bit pattern: > 0x6030 0000 0014 > > +arm64 SVE registers have the following bit patterns: > + 0x6080 0000 0015 00 Zn bits[2048*slice + 2047 : 2048*slice] > + 0x6050 0000 0015 04 Pn bits[256*slice + 255 : 256*slice] > + 0x6050 0000 0015 060 FFR bits[256*slice + 255 : 256*slice] > + > + These registers are only accessible on SVE-enabled vcpus. See > + KVM_ARM_SVE_CONFIG for details. > + > > MIPS registers are mapped using the lower 32 bits. The upper 16 of that is > the register group type: > @@ -3700,6 +3716,126 @@ Returns: 0 on success, -1 on error > This copies the vcpu's kvm_nested_state struct from userspace to the kernel. For > the definition of struct kvm_nested_state, see KVM_GET_NESTED_STATE. > > +4.116 KVM_ARM_SVE_CONFIG > + > +Capability: KVM_CAP_ARM_SVE > +Architectures: arm64 > +Type: vm and vcpu ioctl > +Parameters: struct kvm_sve_vls (in/out) > +Returns: 0 on success > +Errors: > + EINVAL: Unrecognised subcommand or bad arguments > + EBADFD: vcpu in wrong state for request > + (KVM_ARM_SVE_CONFIG_SET, KVM_ARM_SVE_CONFIG_SET) > + ENOMEM: Out of memory > + EFAULT: Bad user address > + > +struct kvm_sve_vls { > + __u16 cmd; > + __u16 max_vq; > + __u16 _reserved[2]; > + __u64 required_vqs[8]; > +}; > + > +General: > + > +cmd: This ioctl supports a few different subcommands, selected by the > +value of cmd (described in detail in the following sections). > + > +_reserved[]: these fields may be meaningful to later kernels. For > +forward compatibility, they must be zeroed before invoking this ioctl > +for the first time on a given struct kvm_sve_vls object. (So, memset() > +it to zero before first use, or allocate with calloc() for example.) > + > +max_vq, required_vqs[]: encode a set of SVE vector lengths. The set is > +encoded as follows: > + > +If (a * 64 + b + 1) <= max_vq, then the bit represented by > + > + required_vqs[a] & ((__u64)1 << b) > + > +(where a is in the range 0..7 and b is in the range 0..63) > +indicates that the vector length (a * 64 + b + 1) * 128 bits is > +supported (KVM_ARM_SVE_CONFIG_QUERY, KVM_ARM_SVE_CONFIG_GET) or required > +(KVM_ARM_SVE_CONFIG_SET). > + > +If (a * 64 + b + 1) > max_vq, then the vector length > +(a * 64 + b + 1) * 128 bits is unsupported or prohibited respectively. > +In other words, only the first max_vq bits in required_vqs[] are > +significant; remaining bits are implicitly treated as if they were zero. > + > +max_vq must be in the range SVE_VQ_MIN (1) to SVE_VQ_MAX (512). > + > +See Documentation/arm64/sve.txt for an explanation of vector lengths and > +the meaning associated with "VQ". > + > +Subcommands: > + > +/* 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 */ > + > +Subcommand details: > + > +4.116.1 KVM_ARM_SVE_CONFIG_QUERY > +Type: vm and vcpu > + > +Retrieve the full set of SVE vector lengths available for use by KVM > +guests on this host. The result is independent of which vcpu this > +command is invoked on. As a convenience, it may also be invoked on a > +vm file descriptor, eliminating the need to create a vcpu first. > + > +4.116.2 KVM_ARM_SVE_CONFIG_SET > +Type: vcpu only > + > +Enables SVE for the vcpu and sets the set of SVE vector lengths that > +will be visible to the guest. > + > +This is the only way to enable SVE for a vcpu: if this command is not > +invoked for a vcpu then SVE will not be available to the guest on this > +vcpu. > + > +This subcommand is only permitted once per vcpu, before KVM_RUN has been > +invoked for the vcpu for the first time. Otherwise, the command fails > +with -EBADFD and the state of the vcpu is not modified. > + > +In typical use, the user should call KVM_ARM_SVE_CONFIG_QUERY first to > +populate a struct kvm_sve_vls with the full set of vector lengths > +available on the host, then set cmd = KVM_ARM_SVE_CONFIG_SET and > +re-issue the KVM_ARM_SVE_CONFIG ioctl on the desired vcpu. This will > +configure the best set of vector lengths available. When following this > +approach, the maximum available vector length can also be restricted by > +reducing the value of max_vq before invoking KVM_ARM_SVE_CONFIG_SET. > + > +Every requested vector length in the struct kvm_sve_vls argument must be > +supported by the hardware. In addition, except for vector lengths > +greater than the maximum requested vector length, every vector length > +not requested must *not* be supported by the hardware. (The latter > +restriction may be relaxed in the future.) If the requested set of > +vector lengths is not supportable, the command fails with -EINVAL and > +the state of the vcpu is not modified. > + > +Different vcpus of a vm may be configured with different sets of vector > +lengths. Equally, some vcpus may have SVE enabled and some not. > +However, such configurations are not recommended except for testing and > +experimentation purposes. Architecturally compliant guest OSes will > +work, but may or may not make effective use of the resulting > +configuration. > + > +After a successful KVM_ARM_SVE_CONFIG_SET, KVM_ARM_SVE_CONFIG_GET can be > +used to retrieve the configured set of vector lengths. > + > +4.116.3 KVM_ARM_SVE_CONFIG_GET > +Type: vcpu only > + > +This subcommand returns the set of vector lengths enabled for the vcpu. > +SVE must have been enabled and configured for this vcpu by a successful > +prior KVM_ARM_SVE_CONFIG_SET call. Otherwise, -EBADFD is returned. > + > +The state of the vcpu is unchanged. > + > + > 5. The kvm_run structure > ------------------------ -- Alex Benn?e