From mboxrd@z Thu Jan 1 00:00:00 1970 From: Dave Martin Subject: [PATCH v4 09/28] arm64/sve: Signal frame and context structure definition Date: Fri, 27 Oct 2017 11:50:51 +0100 Message-ID: <1509101470-7881-10-git-send-email-Dave.Martin@arm.com> References: <1509101470-7881-1-git-send-email-Dave.Martin@arm.com> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Return-path: In-Reply-To: <1509101470-7881-1-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: linux-arm-kernel@lists.infradead.org Cc: linux-arch@vger.kernel.org, Okamoto Takayuki , libc-alpha@sourceware.org, Ard Biesheuvel , Szabolcs Nagy , Catalin Marinas , Will Deacon , kvmarm@lists.cs.columbia.edu List-Id: linux-arch.vger.kernel.org VGhpcyBwYXRjaCBkZWZpbmVzIHRoZSByZXByZXNlbnRhdGlvbiB0aGF0IHdpbGwgYmUgdXNlZCBm b3IgdGhlIFNWRQpyZWdpc3RlciBzdGF0ZSBpbiB0aGUgc2lnbmFsIGZyYW1lLCBhbmQgaW1wbGVt ZW50cyBzdXBwb3J0IGZvcgpzYXZpbmcgYW5kIHJlc3RvcmluZyB0aGUgU1ZFIHJlZ2lzdGVycyBh cm91bmQgc2lnbmFscy4KClRoZSBzYW1lIGxheW91dCB3aWxsIGFsc28gYmUgdXNlZCBmb3IgdGhl IGluLWtlcm5lbCB0YXNrIHN0YXRlLgoKRHVlIHRvIHRoZSB2YXJpYWJpbGl0eSBvZiB0aGUgU1ZF IHZlY3RvciBsZW5ndGgsIGl0IGlzIG5vdCBwb3NzaWJsZQp0byBkZWZpbmUgYSBmaXhlZCBDIHN0 cnVjdCB0byBkZXNjcmliZSBhbGwgdGhlIHJlZ2lzdGVycy4gIEluc3RlYWQsCk1hY3JvcyBhcmUg ZGVmaW5lZCBpbiBzaWdjb250ZXh0LmggdG8gZmFjaWxpdGF0ZSBhY2Nlc3MgdG8gdGhlCnBhcnRz IG9mIHRoZSBzdHJ1Y3R1cmUuCgpTaWduZWQtb2ZmLWJ5OiBEYXZlIE1hcnRpbiA8RGF2ZS5NYXJ0 aW5AYXJtLmNvbT4KUmV2aWV3ZWQtYnk6IENhdGFsaW4gTWFyaW5hcyA8Y2F0YWxpbi5tYXJpbmFz QGFybS5jb20+CkNjOiBBbGV4IEJlbm7DqWUgPGFsZXguYmVubmVlQGxpbmFyby5vcmc+Ci0tLQog YXJjaC9hcm02NC9pbmNsdWRlL3VhcGkvYXNtL3NpZ2NvbnRleHQuaCB8IDExNyArKysrKysrKysr KysrKysrKysrKysrKysrKysrKystCiAxIGZpbGUgY2hhbmdlZCwgMTE2IGluc2VydGlvbnMoKyks IDEgZGVsZXRpb24oLSkKCmRpZmYgLS1naXQgYS9hcmNoL2FybTY0L2luY2x1ZGUvdWFwaS9hc20v c2lnY29udGV4dC5oIGIvYXJjaC9hcm02NC9pbmNsdWRlL3VhcGkvYXNtL3NpZ2NvbnRleHQuaApp bmRleCBmMGE3NmI5Li43NjU0YTgxIDEwMDY0NAotLS0gYS9hcmNoL2FybTY0L2luY2x1ZGUvdWFw aS9hc20vc2lnY29udGV4dC5oCisrKyBiL2FyY2gvYXJtNjQvaW5jbHVkZS91YXBpL2FzbS9zaWdj b250ZXh0LmgKQEAgLTE2LDYgKzE2LDggQEAKICNpZm5kZWYgX1VBUElfX0FTTV9TSUdDT05URVhU X0gKICNkZWZpbmUgX1VBUElfX0FTTV9TSUdDT05URVhUX0gKIAorI2lmbmRlZiBfX0FTU0VNQkxZ X18KKwogI2luY2x1ZGUgPGxpbnV4L3R5cGVzLmg+CiAKIC8qCkBAIC00MSwxMCArNDMsMTEgQEAg c3RydWN0IHNpZ2NvbnRleHQgewogICoKICAqCTB4MjEwCQlmcHNpbWRfY29udGV4dAogICoJIDB4 MTAJCWVzcl9jb250ZXh0CisgKgkweDhhMAkJc3ZlX2NvbnRleHQgKHZsIDw9IDY0KSAob3B0aW9u YWwpCiAgKgkgMHgyMAkJZXh0cmFfY29udGV4dCAob3B0aW9uYWwpCiAgKgkgMHgxMAkJdGVybWlu YXRvciAobnVsbCBfYWFyY2g2NF9jdHgpCiAgKgotICoJMHhkYjAJCShyZXNlcnZlZCBmb3IgZnV0 dXJlIGFsbG9jYXRpb24pCisgKgkweDUxMAkJKHJlc2VydmVkIGZvciBmdXR1cmUgYWxsb2NhdGlv bikKICAqCiAgKiBOZXcgcmVjb3JkcyB0aGF0IGNhbiBleGNlZWQgdGhpcyBzcGFjZSBuZWVkIHRv IGJlIG9wdC1pbiBmb3IgdXNlcnNwYWNlLCBzbwogICogdGhhdCBhbiBleHBhbmRlZCBzaWduYWwg ZnJhbWUgaXMgbm90IGdlbmVyYXRlZCB1bmV4cGVjdGVkbHkuICBUaGUgbWVjaGFuaXNtCkBAIC0x MTYsNCArMTE5LDExNiBAQCBzdHJ1Y3QgZXh0cmFfY29udGV4dCB7CiAJX191MzIgX19yZXNlcnZl ZFszXTsKIH07CiAKKyNkZWZpbmUgU1ZFX01BR0lDCTB4NTM1NjQ1MDEKKworc3RydWN0IHN2ZV9j b250ZXh0IHsKKwlzdHJ1Y3QgX2FhcmNoNjRfY3R4IGhlYWQ7CisJX191MTYgdmw7CisJX191MTYg X19yZXNlcnZlZFszXTsKK307CisKKyNlbmRpZiAvKiAhX19BU1NFTUJMWV9fICovCisKKy8qCisg KiBUaGUgU1ZFIGFyY2hpdGVjdHVyZSBsZWF2ZXMgc3BhY2UgZm9yIGZ1dHVyZSBleHBhbnNpb24g b2YgdGhlCisgKiB2ZWN0b3IgbGVuZ3RoIGJleW9uZCBpdHMgaW5pdGlhbCBhcmNoaXRlY3R1cmFs IGxpbWl0IG9mIDIwNDggYml0cworICogKDE2IHF1YWR3b3JkcykuCisgKi8KKyNkZWZpbmUgU1ZF X1ZRX0JZVEVTCQkxNgkvKiBudW1iZXIgb2YgYnl0ZXMgcGVyIHF1YWR3b3JkICovCisKKyNkZWZp bmUgU1ZFX1ZRX01JTgkJMQorI2RlZmluZSBTVkVfVlFfTUFYCQk1MTIKKworI2RlZmluZSBTVkVf VkxfTUlOCQkoU1ZFX1ZRX01JTiAqIFNWRV9WUV9CWVRFUykKKyNkZWZpbmUgU1ZFX1ZMX01BWAkJ KFNWRV9WUV9NQVggKiBTVkVfVlFfQllURVMpCisKKyNkZWZpbmUgU1ZFX05VTV9aUkVHUwkJMzIK KyNkZWZpbmUgU1ZFX05VTV9QUkVHUwkJMTYKKworI2RlZmluZSBzdmVfdmxfdmFsaWQodmwpIFwK KwkoKHZsKSAlIFNWRV9WUV9CWVRFUyA9PSAwICYmICh2bCkgPj0gU1ZFX1ZMX01JTiAmJiAodmwp IDw9IFNWRV9WTF9NQVgpCisjZGVmaW5lIHN2ZV92cV9mcm9tX3ZsKHZsKQkoKHZsKSAvIFNWRV9W UV9CWVRFUykKKyNkZWZpbmUgc3ZlX3ZsX2Zyb21fdnEodnEpCSgodnEpICogU1ZFX1ZRX0JZVEVT KQorCisvKgorICogSWYgdGhlIFNWRSByZWdpc3RlcnMgYXJlIGN1cnJlbnRseSBsaXZlIGZvciB0 aGUgdGhyZWFkIGF0IHNpZ25hbCBkZWxpdmVyeSwKKyAqIHN2ZV9jb250ZXh0LmhlYWQuc2l6ZSA+ PQorICoJU1ZFX1NJR19DT05URVhUX1NJWkUoc3ZlX3ZxX2Zyb21fdmwoc3ZlX2NvbnRleHQudmwp KQorICogYW5kIHRoZSByZWdpc3RlciBkYXRhIG1heSBiZSBhY2Nlc3NlZCB1c2luZyB0aGUgU1ZF X1NJR18qKCkgbWFjcm9zLgorICoKKyAqIElmIHN2ZV9jb250ZXh0LmhlYWQuc2l6ZSA8CisgKglT VkVfU0lHX0NPTlRFWFRfU0laRShzdmVfdnFfZnJvbV92bChzdmVfY29udGV4dC52bCkpLAorICog dGhlIFNWRSByZWdpc3RlcnMgd2VyZSBub3QgbGl2ZSBmb3IgdGhlIHRocmVhZCBhbmQgbm8gcmVn aXN0ZXIgZGF0YQorICogaXMgaW5jbHVkZWQ6IGluIHRoaXMgY2FzZSwgdGhlIFNWRV9TSUdfKigp IG1hY3JvcyBzaG91bGQgbm90IGJlCisgKiB1c2VkIGV4Y2VwdCBmb3IgdGhpcyBjaGVjay4KKyAq CisgKiBUaGUgc2FtZSBjb252ZW50aW9uIGFwcGxpZXMgd2hlbiByZXR1cm5pbmcgZnJvbSBhIHNp Z25hbDogYSBjYWxsZXIKKyAqIHdpbGwgbmVlZCB0byByZW1vdmUgb3IgcmVzaXplIHRoZSBzdmVf Y29udGV4dCBibG9jayBpZiBpdCB3YW50cyB0bworICogbWFrZSB0aGUgU1ZFIHJlZ2lzdGVycyBs aXZlIHdoZW4gdGhleSB3ZXJlIHByZXZpb3VzbHkgbm9uLWxpdmUgb3IKKyAqIHZpY2UtdmVyc2Eu ICBUaGlzIG1heSByZXF1aXJlIHRoZSB0aGUgY2FsbGVyIHRvIGFsbG9jYXRlIGZyZXNoCisgKiBt ZW1vcnkgYW5kL29yIG1vdmUgb3RoZXIgY29udGV4dCBibG9ja3MgaW4gdGhlIHNpZ25hbCBmcmFt ZS4KKyAqCisgKiBDaGFuZ2luZyB0aGUgdmVjdG9yIGxlbmd0aCBkdXJpbmcgc2lnbmFsIHJldHVy biBpcyBub3QgcGVybWl0dGVkOgorICogc3ZlX2NvbnRleHQudmwgbXVzdCBlcXVhbCB0aGUgdGhy ZWFkJ3MgY3VycmVudCB2ZWN0b3IgbGVuZ3RoIHdoZW4KKyAqIGRvaW5nIGEgc2lncmV0dXJuLgor ICoKKyAqCisgKiBOb3RlOiBmb3IgYWxsIHRoZXNlIG1hY3JvcywgdGhlICJ2cSIgYXJndW1lbnQg ZGVub3RlcyB0aGUgU1ZFCisgKiB2ZWN0b3IgbGVuZ3RoIGluIHF1YWR3b3JkcyAoaS5lLiwgdW5p dHMgb2YgMTI4IGJpdHMpLgorICoKKyAqIFRoZSBjb3JyZWN0IHdheSB0byBvYnRhaW4gdnEgaXMg dG8gdXNlIHN2ZV92cV9mcm9tX3ZsKHZsKS4gIFRoZQorICogcmVzdWx0IGlzIHZhbGlkIGlmIGFu ZCBvbmx5IGlmIHN2ZV92bF92YWxpZCh2bCkgaXMgdHJ1ZS4gIFRoaXMgaXMKKyAqIGd1YXJhbnRl ZWQgZm9yIGEgc3RydWN0IHN2ZV9jb250ZXh0IHdyaXR0ZW4gYnkgdGhlIGtlcm5lbC4KKyAqCisg KgorICogQWRkaXRpb25hbCBtYWNyb3MgZGVzY3JpYmUgdGhlIGNvbnRlbnRzIGFuZCBsYXlvdXQg b2YgdGhlIHBheWxvYWQuCisgKiBGb3IgZWFjaCwgU1ZFX1NJR194X09GRlNFVChhcmdzKSBpcyB0 aGUgc3RhcnQgb2Zmc2V0IHJlbGF0aXZlIHRvCisgKiB0aGUgc3RhcnQgb2Ygc3RydWN0IHN2ZV9j b250ZXh0LCBhbmQgU1ZFX1NJR194X1NJWkUoYXJncykgaXMgdGhlCisgKiBzaXplIGluIGJ5dGVz OgorICoKKyAqCXgJdHlwZQkJCQlkZXNjcmlwdGlvbgorICoJLQktLS0tCQkJCS0tLS0tLS0tLS0t CisgKglSRUdTCQkJCQl0aGUgZW50aXJlIFNWRSBjb250ZXh0CisgKgorICoJWlJFR1MJX191aW50 MTI4X3RbU1ZFX05VTV9aUkVHU11bdnFdCWFsbCBaLXJlZ2lzdGVycworICoJWlJFRwlfX3VpbnQx MjhfdFt2cV0JCQlpbmRpdmlkdWFsIFotcmVnaXN0ZXIgWm4KKyAqCisgKglQUkVHUwl1aW50MTZf dFtTVkVfTlVNX1BSRUdTXVt2cV0JYWxsIFAtcmVnaXN0ZXJzCisgKglQUkVHCXVpbnQxNl90W3Zx XQkJCWluZGl2aWR1YWwgUC1yZWdpc3RlciBQbgorICoKKyAqCUZGUgl1aW50MTZfdFt2cV0JCQlm aXJzdC1mYXVsdCBzdGF0dXMgcmVnaXN0ZXIKKyAqCisgKiBBZGRpdGlvbmFsIGRhdGEgbWlnaHQg YmUgYXBwZW5kZWQgaW4gdGhlIGZ1dHVyZS4KKyAqLworCisjZGVmaW5lIFNWRV9TSUdfWlJFR19T SVpFKHZxKQkoKF9fdTMyKSh2cSkgKiBTVkVfVlFfQllURVMpCisjZGVmaW5lIFNWRV9TSUdfUFJF R19TSVpFKHZxKQkoKF9fdTMyKSh2cSkgKiAoU1ZFX1ZRX0JZVEVTIC8gOCkpCisjZGVmaW5lIFNW RV9TSUdfRkZSX1NJWkUodnEpCVNWRV9TSUdfUFJFR19TSVpFKHZxKQorCisjZGVmaW5lIFNWRV9T SUdfUkVHU19PRkZTRVQJCQkJCVwKKwkoKHNpemVvZihzdHJ1Y3Qgc3ZlX2NvbnRleHQpICsgKFNW RV9WUV9CWVRFUyAtIDEpKQlcCisJCS8gU1ZFX1ZRX0JZVEVTICogU1ZFX1ZRX0JZVEVTKQorCisj ZGVmaW5lIFNWRV9TSUdfWlJFR1NfT0ZGU0VUCVNWRV9TSUdfUkVHU19PRkZTRVQKKyNkZWZpbmUg U1ZFX1NJR19aUkVHX09GRlNFVCh2cSwgbikgXAorCShTVkVfU0lHX1pSRUdTX09GRlNFVCArIFNW RV9TSUdfWlJFR19TSVpFKHZxKSAqIChuKSkKKyNkZWZpbmUgU1ZFX1NJR19aUkVHU19TSVpFKHZx KSBcCisJKFNWRV9TSUdfWlJFR19PRkZTRVQodnEsIFNWRV9OVU1fWlJFR1MpIC0gU1ZFX1NJR19a UkVHU19PRkZTRVQpCisKKyNkZWZpbmUgU1ZFX1NJR19QUkVHU19PRkZTRVQodnEpIFwKKwkoU1ZF X1NJR19aUkVHU19PRkZTRVQgKyBTVkVfU0lHX1pSRUdTX1NJWkUodnEpKQorI2RlZmluZSBTVkVf U0lHX1BSRUdfT0ZGU0VUKHZxLCBuKSBcCisJKFNWRV9TSUdfUFJFR1NfT0ZGU0VUKHZxKSArIFNW RV9TSUdfUFJFR19TSVpFKHZxKSAqIChuKSkKKyNkZWZpbmUgU1ZFX1NJR19QUkVHU19TSVpFKHZx KSBcCisJKFNWRV9TSUdfUFJFR19PRkZTRVQodnEsIFNWRV9OVU1fUFJFR1MpIC0gU1ZFX1NJR19Q UkVHU19PRkZTRVQodnEpKQorCisjZGVmaW5lIFNWRV9TSUdfRkZSX09GRlNFVCh2cSkgXAorCShT VkVfU0lHX1BSRUdTX09GRlNFVCh2cSkgKyBTVkVfU0lHX1BSRUdTX1NJWkUodnEpKQorCisjZGVm aW5lIFNWRV9TSUdfUkVHU19TSVpFKHZxKSBcCisJKFNWRV9TSUdfRkZSX09GRlNFVCh2cSkgKyBT VkVfU0lHX0ZGUl9TSVpFKHZxKSAtIFNWRV9TSUdfUkVHU19PRkZTRVQpCisKKyNkZWZpbmUgU1ZF X1NJR19DT05URVhUX1NJWkUodnEpIChTVkVfU0lHX1JFR1NfT0ZGU0VUICsgU1ZFX1NJR19SRUdT X1NJWkUodnEpKQorCisKICNlbmRpZiAvKiBfVUFQSV9fQVNNX1NJR0NPTlRFWFRfSCAqLwotLSAK Mi4xLjQKCl9fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fCmt2 bWFybSBtYWlsaW5nIGxpc3QKa3ZtYXJtQGxpc3RzLmNzLmNvbHVtYmlhLmVkdQpodHRwczovL2xp c3RzLmNzLmNvbHVtYmlhLmVkdS9tYWlsbWFuL2xpc3RpbmZvL2t2bWFybQo= From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from usa-sjc-mx-foss1.foss.arm.com ([217.140.101.70]:56804 "EHLO foss.arm.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1752427AbdJ0Kvh (ORCPT ); Fri, 27 Oct 2017 06:51:37 -0400 From: Dave Martin Subject: [PATCH v4 09/28] arm64/sve: Signal frame and context structure definition Date: Fri, 27 Oct 2017 11:50:51 +0100 Message-ID: <1509101470-7881-10-git-send-email-Dave.Martin@arm.com> In-Reply-To: <1509101470-7881-1-git-send-email-Dave.Martin@arm.com> References: <1509101470-7881-1-git-send-email-Dave.Martin@arm.com> MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Sender: linux-arch-owner@vger.kernel.org List-ID: To: linux-arm-kernel@lists.infradead.org Cc: Catalin Marinas , Will Deacon , Ard Biesheuvel , =?UTF-8?q?Alex=20Benn=C3=A9e?= , Szabolcs Nagy , Okamoto Takayuki , kvmarm@lists.cs.columbia.edu, libc-alpha@sourceware.org, linux-arch@vger.kernel.org Message-ID: <20171027105051.ehvM4d6XE_17Y92iEfw6-KGVqo3vxKFio2c3VirGEx4@z> This patch defines the representation that will be used for the SVE register state in the signal frame, and implements support for saving and restoring the SVE registers around signals. The same layout will also be used for the in-kernel task state. Due to the variability of the SVE vector length, it is not possible to define a fixed C struct to describe all the registers. Instead, Macros are defined in sigcontext.h to facilitate access to the parts of the structure. Signed-off-by: Dave Martin Reviewed-by: Catalin Marinas Cc: Alex Bennée --- arch/arm64/include/uapi/asm/sigcontext.h | 117 ++++++++++++++++++++++++++++++- 1 file changed, 116 insertions(+), 1 deletion(-) diff --git a/arch/arm64/include/uapi/asm/sigcontext.h b/arch/arm64/include/uapi/asm/sigcontext.h index f0a76b9..7654a81 100644 --- a/arch/arm64/include/uapi/asm/sigcontext.h +++ b/arch/arm64/include/uapi/asm/sigcontext.h @@ -16,6 +16,8 @@ #ifndef _UAPI__ASM_SIGCONTEXT_H #define _UAPI__ASM_SIGCONTEXT_H +#ifndef __ASSEMBLY__ + #include /* @@ -41,10 +43,11 @@ struct sigcontext { * * 0x210 fpsimd_context * 0x10 esr_context + * 0x8a0 sve_context (vl <= 64) (optional) * 0x20 extra_context (optional) * 0x10 terminator (null _aarch64_ctx) * - * 0xdb0 (reserved for future allocation) + * 0x510 (reserved for future allocation) * * New records that can exceed this space need to be opt-in for userspace, so * that an expanded signal frame is not generated unexpectedly. The mechanism @@ -116,4 +119,116 @@ struct extra_context { __u32 __reserved[3]; }; +#define SVE_MAGIC 0x53564501 + +struct sve_context { + struct _aarch64_ctx head; + __u16 vl; + __u16 __reserved[3]; +}; + +#endif /* !__ASSEMBLY__ */ + +/* + * The SVE architecture leaves space for future expansion of the + * vector length beyond its initial architectural limit of 2048 bits + * (16 quadwords). + */ +#define SVE_VQ_BYTES 16 /* number of bytes per quadword */ + +#define SVE_VQ_MIN 1 +#define SVE_VQ_MAX 512 + +#define SVE_VL_MIN (SVE_VQ_MIN * SVE_VQ_BYTES) +#define SVE_VL_MAX (SVE_VQ_MAX * SVE_VQ_BYTES) + +#define SVE_NUM_ZREGS 32 +#define SVE_NUM_PREGS 16 + +#define sve_vl_valid(vl) \ + ((vl) % SVE_VQ_BYTES == 0 && (vl) >= SVE_VL_MIN && (vl) <= SVE_VL_MAX) +#define sve_vq_from_vl(vl) ((vl) / SVE_VQ_BYTES) +#define sve_vl_from_vq(vq) ((vq) * SVE_VQ_BYTES) + +/* + * If the SVE registers are currently live for the thread at signal delivery, + * sve_context.head.size >= + * SVE_SIG_CONTEXT_SIZE(sve_vq_from_vl(sve_context.vl)) + * and the register data may be accessed using the SVE_SIG_*() macros. + * + * If sve_context.head.size < + * SVE_SIG_CONTEXT_SIZE(sve_vq_from_vl(sve_context.vl)), + * the SVE registers were not live for the thread and no register data + * is included: in this case, the SVE_SIG_*() macros should not be + * used except for this check. + * + * The same convention applies when returning from a signal: a caller + * will need to remove or resize the sve_context block if it wants to + * make the SVE registers live when they were previously non-live or + * vice-versa. This may require the the caller to allocate fresh + * memory and/or move other context blocks in the signal frame. + * + * Changing the vector length during signal return is not permitted: + * sve_context.vl must equal the thread's current vector length when + * doing a sigreturn. + * + * + * Note: for all these macros, the "vq" argument denotes the SVE + * vector length in quadwords (i.e., units of 128 bits). + * + * The correct way to obtain vq is to use sve_vq_from_vl(vl). The + * result is valid if and only if sve_vl_valid(vl) is true. This is + * guaranteed for a struct sve_context written by the kernel. + * + * + * Additional macros describe the contents and layout of the payload. + * For each, SVE_SIG_x_OFFSET(args) is the start offset relative to + * the start of struct sve_context, and SVE_SIG_x_SIZE(args) is the + * size in bytes: + * + * x type description + * - ---- ----------- + * REGS the entire SVE context + * + * ZREGS __uint128_t[SVE_NUM_ZREGS][vq] all Z-registers + * ZREG __uint128_t[vq] individual Z-register Zn + * + * PREGS uint16_t[SVE_NUM_PREGS][vq] all P-registers + * PREG uint16_t[vq] individual P-register Pn + * + * FFR uint16_t[vq] first-fault status register + * + * Additional data might be appended in the future. + */ + +#define SVE_SIG_ZREG_SIZE(vq) ((__u32)(vq) * SVE_VQ_BYTES) +#define SVE_SIG_PREG_SIZE(vq) ((__u32)(vq) * (SVE_VQ_BYTES / 8)) +#define SVE_SIG_FFR_SIZE(vq) SVE_SIG_PREG_SIZE(vq) + +#define SVE_SIG_REGS_OFFSET \ + ((sizeof(struct sve_context) + (SVE_VQ_BYTES - 1)) \ + / SVE_VQ_BYTES * SVE_VQ_BYTES) + +#define SVE_SIG_ZREGS_OFFSET SVE_SIG_REGS_OFFSET +#define SVE_SIG_ZREG_OFFSET(vq, n) \ + (SVE_SIG_ZREGS_OFFSET + SVE_SIG_ZREG_SIZE(vq) * (n)) +#define SVE_SIG_ZREGS_SIZE(vq) \ + (SVE_SIG_ZREG_OFFSET(vq, SVE_NUM_ZREGS) - SVE_SIG_ZREGS_OFFSET) + +#define SVE_SIG_PREGS_OFFSET(vq) \ + (SVE_SIG_ZREGS_OFFSET + SVE_SIG_ZREGS_SIZE(vq)) +#define SVE_SIG_PREG_OFFSET(vq, n) \ + (SVE_SIG_PREGS_OFFSET(vq) + SVE_SIG_PREG_SIZE(vq) * (n)) +#define SVE_SIG_PREGS_SIZE(vq) \ + (SVE_SIG_PREG_OFFSET(vq, SVE_NUM_PREGS) - SVE_SIG_PREGS_OFFSET(vq)) + +#define SVE_SIG_FFR_OFFSET(vq) \ + (SVE_SIG_PREGS_OFFSET(vq) + SVE_SIG_PREGS_SIZE(vq)) + +#define SVE_SIG_REGS_SIZE(vq) \ + (SVE_SIG_FFR_OFFSET(vq) + SVE_SIG_FFR_SIZE(vq) - SVE_SIG_REGS_OFFSET) + +#define SVE_SIG_CONTEXT_SIZE(vq) (SVE_SIG_REGS_OFFSET + SVE_SIG_REGS_SIZE(vq)) + + #endif /* _UAPI__ASM_SIGCONTEXT_H */ -- 2.1.4