From mboxrd@z Thu Jan 1 00:00:00 1970 From: Dave Martin Subject: [PATCH v5 15/30] arm64/sve: Signal handling support Date: Tue, 31 Oct 2017 15:51:07 +0000 Message-ID: <1509465082-30427-16-git-send-email-Dave.Martin@arm.com> References: <1509465082-30427-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: <1509465082-30427-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 VGhpcyBwYXRjaCBpbXBsZW1lbnRzIHN1cHBvcnQgZm9yIHNhdmluZyBhbmQgcmVzdG9yaW5nIHRo ZSBTVkUKcmVnaXN0ZXJzIGFyb3VuZCBzaWduYWxzLgoKQSBmaXhlZC1zaXplIGhlYWRlciBzdHJ1 Y3Qgc3ZlX2NvbnRleHQgaXMgYWx3YXlzIGluY2x1ZGVkIGluIHRoZQpzaWduYWwgZnJhbWUgZW5j b2RpbmcgdGhlIHRocmVhZCdzIHZlY3RvciBsZW5ndGggYXQgdGhlIHRpbWUgb2YKc2lnbmFsIGRl bGl2ZXJ5LCBvcHRpb25hbGx5IGZvbGxvd2VkIGJ5IGEgdmFyaWFibGUtbGF5b3V0IHN0cnVjdHVy ZQplbmNvZGluZyB0aGUgU1ZFIHJlZ2lzdGVycy4KCkJlY2F1c2Ugb2YgdGhlIG5lZWQgdG8gcHJl c2VydmUgYmFja3dhcmRzIGNvbXBhdGliaWxpdHksIHRoZSBGUFNJTUQKdmlldyBvZiB0aGUgU1ZF IHJlZ2lzdGVycyBpcyBhbHdheXMgZHVtcGVkIGFzIGEgc3RydWN0CmZwc2ltZF9jb250ZXh0IGlu IHRoZSB1c3VhbCB3YXksIGluIGFkZGl0aW9uIHRvIGFueSBzdmVfY29udGV4dC4KClRoZSBTVkUg dmVjdG9yIHJlZ2lzdGVycyBhcmUgZHVtcGVkIGluIGZ1bGwsIGluY2x1ZGluZyBiaXRzIDEyNzow Cm9mIGVhY2ggcmVnaXN0ZXIgd2hpY2ggYWxpYXMgdGhlIGNvcnJlc3BvbmRpbmcgRlBTSU1EIHZl Y3RvcgpyZWdpc3RlcnMgaW4gdGhlIGhhcmR3YXJlLiAgVG8gYXZvaWQgYW55IGFtYmlndWl0eSBh Ym91dCB3aGljaAphbGlhcyB0byByZXN0b3JlIGR1cmluZyBzaWdyZXR1cm4sIHRoZSBrZXJuZWwg YWx3YXlzIHJlc3RvcmVzIGJpdHMKMTI3OjAgb2YgZWFjaCBTVkUgdmVjdG9yIHJlZ2lzdGVyIGZy b20gdGhlIGZwc2ltZF9jb250ZXh0IGluIHRoZQpzaWduYWwgZnJhbWUgKHdoaWNoIG11c3QgYmUg cHJlc2VudCk6IHVzZXJzcGFjZSBuZWVkcyB0byB0YWtlIHRoaXMKaW50byBhY2NvdW50IGlmIGl0 IHdhbnRzIHRvIG1vZGlmeSB0aGUgU1ZFIHZlY3RvciByZWdpc3RlciBjb250ZW50cwpvbiByZXR1 cm4gZnJvbSBhIHNpZ25hbC4KCkZQU1IgYW5kIEZQQ1IsIHdoaWNoIGFyZSB1c2VkIGJ5IGJvdGgg RlBTSU1EIGFuZCBTVkUsIGFyZSBub3QKaW5jbHVkZWQgaW4gc3ZlX2NvbnRleHQgYmVjYXVzZSB0 aGV5IGFyZSBhbHdheXMgcHJlc2VudCBpbgpmcHNpbWRfY29udGV4dCBhbnl3YXkuCgpGb3Igc2ln bmFsIGRlbGl2ZXJ5LCBhIG5ldyBoZWxwZXIKZnBzaW1kX3NpZ25hbF9wcmVzZXJ2ZV9jdXJyZW50 X3N0YXRlKCkgaXMgYWRkZWQgdG8gdXBkYXRlIF9ib3RoXwp0aGUgRlBTSU1EIGFuZCBTVkUgdmll d3MgaW4gdGhlIHRhc2sgc3RydWN0LCB0byBtYWtlIGl0IGVhc2llciB0bwpwb3B1bGF0ZSB0aGlz IGluZm9ybWF0aW9uIGludG8gdGhlIHNpZ25hbCBmcmFtZS4gIEJlY2F1c2Ugb2YgdGhlCnJlZHVu ZGFuY3kgYmV0d2VlbiB0aGUgdHdvIHZpZXdzIG9mIHRoZSBzdGF0ZSwgb25seSBvbmUgaXMgdXBk YXRlZApvdGhlcndpc2UuCgpTaWduZWQtb2ZmLWJ5OiBEYXZlIE1hcnRpbiA8RGF2ZS5NYXJ0aW5A YXJtLmNvbT4KQ2M6IEFsZXggQmVubsOpZSA8YWxleC5iZW5uZWVAbGluYXJvLm9yZz4KQ2M6IEFy ZCBCaWVzaGV1dmVsIDxhcmQuYmllc2hldXZlbEBsaW5hcm8ub3JnPgpDYzogV2lsbCBEZWFjb24g PHdpbGwuZGVhY29uQGFybS5jb20+CgotLS0KCioqRHJvcHBlZCoqIFJldmlld2VkLWJ5OiBDYXRh bGluIE1hcmluYXMgPGNhdGFsaW4ubWFyaW5hc0Bhcm0uY29tPgooTm9uLXRyaXZpYWwgY2hhbmdl cy4pCgpDaGFuZ2VzIHNpbmNlIHY0Ci0tLS0tLS0tLS0tLS0tLS0KClJlcXVlc3RlZCBieSBXaWxs IERlYWNvbjoKCiAqIEZpeCBpbmNvbnNpc3RlbnQgcmV0dXJuIHNlbWFudGljcyBpbiByZXN0b3Jl X3N2ZV9mcHNpbWRfY29udGV4dCgpLgoKICAgQ3VycmVudGx5IGEgbm9uemVybyByZXR1cm4gdmFs dWUgZnJvbSBfX2NvcHlfZnJvbV91c2VyKCkgaXMgcGFzc2VkCiAgIGJhY2sgYXMtaXMgdG8gdGhl IGNhbGxlciBvciByZXN0b3JlX3N2ZV9mcHNpbWRfY29udGV4dCgpLCByYXRoZXIgdGhhbgogICB0 cmFuc2xhdGluZyBpdCBkbyBhbiBlcnJvciBjb2RlIGFzIGlzIGRvbmUgZWxzZXdoZXJlLgoKICAg Q2FsbGVycyBvZiByZXN0b3JlX3N2ZV9mcHNpbWRfY29udGV4dCgpIG9ubHkgY2FyZSB3aGV0aGVy IHRoZSByZXR1cm4KICAgdmFsdWUgaXMgMCBvciBub3QsIHNvIHRoaXMgaXNuJ3QgYSBiaWcgZGVh bCwgYnV0IGl0IGlzIG1vcmUKICAgY29uc2lzdGVudCB0byByZXR1cm4gcHJvcGVyIGVycm9yIGNv ZGVzIG9uIGZhaWx1cmUgaW4gY2FzZSB3ZSBncm93IGEKICAgdXNlIGZvciB0aGVtIGxhdGVyLgoK ICAgVGhpcyBwYXRjaCByZXR1cm5zIC1FRkFVTFQgaW4gdGhlIF9fY29weV9mcm9tX3VzZXIoKSBl cnJvciBjYXNlcwogICB0aGF0IHdlcmVuJ3QgZXhwbGljaXRseSBoYW5kbGVkLgoKTWlzY2VsbGFu ZW91czoKCiAqIENoYW5nZSBpbmNvbnNpc3RlbnQgY29weV90b191c2VyKCkgY2FsbHMgdG8gX19j b3B5X3RvX3VzZXIoKSBpbgogICBwcmVzZXJ2ZV9zdmVfY29udGV4dCgpLgoKICAgVGhlcmUgYXJl IGFscmVhZHkgX19wdXRfdXNlcl9lcnJvcigpIGNhbGxzIGhlcmUuCgogICBUaGUgd2hvbGUgZXh0 ZW5kZWQgc2lnbmFsIGZyYW1lIGlzIGFscmVhZHkgY2hlY2tlZCBmb3IKICAgYWNjZXNzX29rKFZF UklGWV9XUklURSkgaW4gZ2V0X3NpZ2ZyYW1lKCkuCi0tLQogYXJjaC9hcm02NC9pbmNsdWRlL2Fz bS9mcHNpbWQuaCB8ICAgMSArCiBhcmNoL2FybTY0L2tlcm5lbC9mcHNpbWQuYyAgICAgIHwgIDU1 ICsrKysrKysrKystLS0KIGFyY2gvYXJtNjQva2VybmVsL3NpZ25hbC5jICAgICAgfCAxNjcgKysr KysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKystLQogYXJjaC9hcm02NC9rZXJuZWwv c2lnbmFsMzIuYyAgICB8ICAgMiArLQogNCBmaWxlcyBjaGFuZ2VkLCAyMDYgaW5zZXJ0aW9ucygr KSwgMTkgZGVsZXRpb25zKC0pCgpkaWZmIC0tZ2l0IGEvYXJjaC9hcm02NC9pbmNsdWRlL2FzbS9m cHNpbWQuaCBiL2FyY2gvYXJtNjQvaW5jbHVkZS9hc20vZnBzaW1kLmgKaW5kZXggNTY1NWZlMS4u OWJiZDc0YyAxMDA2NDQKLS0tIGEvYXJjaC9hcm02NC9pbmNsdWRlL2FzbS9mcHNpbWQuaAorKysg Yi9hcmNoL2FybTY0L2luY2x1ZGUvYXNtL2Zwc2ltZC5oCkBAIC02Myw2ICs2Myw3IEBAIGV4dGVy biB2b2lkIGZwc2ltZF9sb2FkX3N0YXRlKHN0cnVjdCBmcHNpbWRfc3RhdGUgKnN0YXRlKTsKIGV4 dGVybiB2b2lkIGZwc2ltZF90aHJlYWRfc3dpdGNoKHN0cnVjdCB0YXNrX3N0cnVjdCAqbmV4dCk7 CiBleHRlcm4gdm9pZCBmcHNpbWRfZmx1c2hfdGhyZWFkKHZvaWQpOwogCitleHRlcm4gdm9pZCBm cHNpbWRfc2lnbmFsX3ByZXNlcnZlX2N1cnJlbnRfc3RhdGUodm9pZCk7CiBleHRlcm4gdm9pZCBm cHNpbWRfcHJlc2VydmVfY3VycmVudF9zdGF0ZSh2b2lkKTsKIGV4dGVybiB2b2lkIGZwc2ltZF9y ZXN0b3JlX2N1cnJlbnRfc3RhdGUodm9pZCk7CiBleHRlcm4gdm9pZCBmcHNpbWRfdXBkYXRlX2N1 cnJlbnRfc3RhdGUoc3RydWN0IGZwc2ltZF9zdGF0ZSAqc3RhdGUpOwpkaWZmIC0tZ2l0IGEvYXJj aC9hcm02NC9rZXJuZWwvZnBzaW1kLmMgYi9hcmNoL2FybTY0L2tlcm5lbC9mcHNpbWQuYwppbmRl eCBjOTFiZThlLi5lMGI1ZWY1IDEwMDY0NAotLS0gYS9hcmNoL2FybTY0L2tlcm5lbC9mcHNpbWQu YworKysgYi9hcmNoL2FybTY0L2tlcm5lbC9mcHNpbWQuYwpAQCAtMjk5LDYgKzI5OSwzMiBAQCBz dGF0aWMgdm9pZCBmcHNpbWRfdG9fc3ZlKHN0cnVjdCB0YXNrX3N0cnVjdCAqdGFzaykKIAkJICAg ICAgIHNpemVvZihmc3QtPnZyZWdzW2ldKSk7CiB9CiAKKy8qCisgKiBUcmFuc2ZlciB0aGUgU1ZF IHN0YXRlIGluIHRhc2stPnRocmVhZC5zdmVfc3RhdGUgdG8KKyAqIHRhc2stPnRocmVhZC5mcHNp bWRfc3RhdGUuCisgKgorICogVGFzayBjYW4gYmUgYSBub24tcnVubmFibGUgdGFzaywgb3IgY3Vy cmVudC4gIEluIHRoZSBsYXR0ZXIgY2FzZSwKKyAqIHNvZnRpcnFzIChhbmQgcHJlZW1wdGlvbikg bXVzdCBiZSBkaXNhYmxlZC4KKyAqIHRhc2stPnRocmVhZC5zdmVfc3RhdGUgbXVzdCBwb2ludCB0 byBhdCBsZWFzdCBzdmVfc3RhdGVfc2l6ZSh0YXNrKQorICogYnl0ZXMgb2YgYWxsb2NhdGVkIGtl cm5lbCBtZW1vcnkuCisgKiB0YXNrLT50aHJlYWQuc3ZlX3N0YXRlIG11c3QgYmUgdXAgdG8gZGF0 ZSBiZWZvcmUgY2FsbGluZyB0aGlzIGZ1bmN0aW9uLgorICovCitzdGF0aWMgdm9pZCBzdmVfdG9f ZnBzaW1kKHN0cnVjdCB0YXNrX3N0cnVjdCAqdGFzaykKK3sKKwl1bnNpZ25lZCBpbnQgdnE7CisJ dm9pZCBjb25zdCAqc3N0ID0gdGFzay0+dGhyZWFkLnN2ZV9zdGF0ZTsKKwlzdHJ1Y3QgZnBzaW1k X3N0YXRlICpmc3QgPSAmdGFzay0+dGhyZWFkLmZwc2ltZF9zdGF0ZTsKKwl1bnNpZ25lZCBpbnQg aTsKKworCWlmICghc3lzdGVtX3N1cHBvcnRzX3N2ZSgpKQorCQlyZXR1cm47CisKKwl2cSA9IHN2 ZV92cV9mcm9tX3ZsKHRhc2stPnRocmVhZC5zdmVfdmwpOworCWZvciAoaSA9IDA7IGkgPCAzMjsg KytpKQorCQltZW1jcHkoJmZzdC0+dnJlZ3NbaV0sIFpSRUcoc3N0LCB2cSwgaSksCisJCSAgICAg ICBzaXplb2YoZnN0LT52cmVnc1tpXSkpOworfQorCiAjaWZkZWYgQ09ORklHX0FSTTY0X1NWRQog CiAvKgpAQCAtNTAwLDkgKzUyNiw2IEBAIHZvaWQgZnBzaW1kX2ZsdXNoX3RocmVhZCh2b2lkKQog LyoKICAqIFNhdmUgdGhlIHVzZXJsYW5kIEZQU0lNRCBzdGF0ZSBvZiAnY3VycmVudCcgdG8gbWVt b3J5LCBidXQgb25seSBpZiB0aGUgc3RhdGUKICAqIGN1cnJlbnRseSBoZWxkIGluIHRoZSByZWdp c3RlcnMgZG9lcyBpbiBmYWN0IGJlbG9uZyB0byAnY3VycmVudCcKLSAqCi0gKiBDdXJyZW50bHks IFNWRSB0YXNrcyBjYW4ndCBleGlzdCwgc28ganVzdCBXQVJOIGluIHRoYXQgY2FzZS4KLSAqIFN1 YnNlcXVlbnQgcGF0Y2hlcyB3aWxsIGFkZCBmdWxsIFNWRSBzdXBwb3J0IGhlcmUuCiAgKi8KIHZv aWQgZnBzaW1kX3ByZXNlcnZlX2N1cnJlbnRfc3RhdGUodm9pZCkKIHsKQEAgLTUxMCwxNiArNTMz LDIzIEBAIHZvaWQgZnBzaW1kX3ByZXNlcnZlX2N1cnJlbnRfc3RhdGUodm9pZCkKIAkJcmV0dXJu OwogCiAJbG9jYWxfYmhfZGlzYWJsZSgpOwotCi0JaWYgKCF0ZXN0X3RocmVhZF9mbGFnKFRJRl9G T1JFSUdOX0ZQU1RBVEUpKQotCQlmcHNpbWRfc2F2ZV9zdGF0ZSgmY3VycmVudC0+dGhyZWFkLmZw c2ltZF9zdGF0ZSk7Ci0KLQlXQVJOX09OX09OQ0UodGVzdF9hbmRfY2xlYXJfdGhyZWFkX2ZsYWco VElGX1NWRSkpOwotCisJdGFza19mcHNpbWRfc2F2ZSgpOwogCWxvY2FsX2JoX2VuYWJsZSgpOwog fQogCiAvKgorICogTGlrZSBmcHNpbWRfcHJlc2VydmVfY3VycmVudF9zdGF0ZSgpLCBidXQgZW5z dXJlIHRoYXQKKyAqIGN1cnJlbnQtPnRocmVhZC5mcHNpbWRfc3RhdGUgaXMgdXBkYXRlZCBzbyB0 aGF0IGl0IGNhbiBiZSBjb3BpZWQgdG8KKyAqIHRoZSBzaWduYWwgZnJhbWUuCisgKi8KK3ZvaWQg ZnBzaW1kX3NpZ25hbF9wcmVzZXJ2ZV9jdXJyZW50X3N0YXRlKHZvaWQpCit7CisJZnBzaW1kX3By ZXNlcnZlX2N1cnJlbnRfc3RhdGUoKTsKKwlpZiAoc3lzdGVtX3N1cHBvcnRzX3N2ZSgpICYmIHRl c3RfdGhyZWFkX2ZsYWcoVElGX1NWRSkpCisJCXN2ZV90b19mcHNpbWQoY3VycmVudCk7Cit9CisK Ky8qCiAgKiBMb2FkIHRoZSB1c2VybGFuZCBGUFNJTUQgc3RhdGUgb2YgJ2N1cnJlbnQnIGZyb20g bWVtb3J5LCBidXQgb25seSBpZiB0aGUKICAqIEZQU0lNRCBzdGF0ZSBhbHJlYWR5IGhlbGQgaW4g dGhlIHJlZ2lzdGVycyBpcyAvbm90LyB0aGUgbW9zdCByZWNlbnQgRlBTSU1ECiAgKiBzdGF0ZSBv ZiAnY3VycmVudCcKQEAgLTU1NCw3ICs1ODQsMTIgQEAgdm9pZCBmcHNpbWRfdXBkYXRlX2N1cnJl bnRfc3RhdGUoc3RydWN0IGZwc2ltZF9zdGF0ZSAqc3RhdGUpCiAKIAlsb2NhbF9iaF9kaXNhYmxl KCk7CiAKLQlmcHNpbWRfbG9hZF9zdGF0ZShzdGF0ZSk7CisJaWYgKHN5c3RlbV9zdXBwb3J0c19z dmUoKSAmJiB0ZXN0X3RocmVhZF9mbGFnKFRJRl9TVkUpKSB7CisJCWN1cnJlbnQtPnRocmVhZC5m cHNpbWRfc3RhdGUgPSAqc3RhdGU7CisJCWZwc2ltZF90b19zdmUoY3VycmVudCk7CisJfQorCXRh c2tfZnBzaW1kX2xvYWQoKTsKKwogCWlmICh0ZXN0X2FuZF9jbGVhcl90aHJlYWRfZmxhZyhUSUZf Rk9SRUlHTl9GUFNUQVRFKSkgewogCQlzdHJ1Y3QgZnBzaW1kX3N0YXRlICpzdCA9ICZjdXJyZW50 LT50aHJlYWQuZnBzaW1kX3N0YXRlOwogCmRpZmYgLS1naXQgYS9hcmNoL2FybTY0L2tlcm5lbC9z aWduYWwuYyBiL2FyY2gvYXJtNjQva2VybmVsL3NpZ25hbC5jCmluZGV4IDQ3MTY3MjkuLjY0YWJm ODggMTAwNjQ0Ci0tLSBhL2FyY2gvYXJtNjQva2VybmVsL3NpZ25hbC5jCisrKyBiL2FyY2gvYXJt NjQva2VybmVsL3NpZ25hbC5jCkBAIC02Myw2ICs2Myw3IEBAIHN0cnVjdCBydF9zaWdmcmFtZV91 c2VyX2xheW91dCB7CiAKIAl1bnNpZ25lZCBsb25nIGZwc2ltZF9vZmZzZXQ7CiAJdW5zaWduZWQg bG9uZyBlc3Jfb2Zmc2V0OworCXVuc2lnbmVkIGxvbmcgc3ZlX29mZnNldDsKIAl1bnNpZ25lZCBs b25nIGV4dHJhX29mZnNldDsKIAl1bnNpZ25lZCBsb25nIGVuZF9vZmZzZXQ7CiB9OwpAQCAtMTc5 LDkgKzE4MCw2IEBAIHN0YXRpYyBpbnQgcHJlc2VydmVfZnBzaW1kX2NvbnRleHQoc3RydWN0IGZw c2ltZF9jb250ZXh0IF9fdXNlciAqY3R4KQogCXN0cnVjdCBmcHNpbWRfc3RhdGUgKmZwc2ltZCA9 ICZjdXJyZW50LT50aHJlYWQuZnBzaW1kX3N0YXRlOwogCWludCBlcnI7CiAKLQkvKiBkdW1wIHRo ZSBoYXJkd2FyZSByZWdpc3RlcnMgdG8gdGhlIGZwc2ltZF9zdGF0ZSBzdHJ1Y3R1cmUgKi8KLQlm cHNpbWRfcHJlc2VydmVfY3VycmVudF9zdGF0ZSgpOwotCiAJLyogY29weSB0aGUgRlAgYW5kIHN0 YXR1cy9jb250cm9sIHJlZ2lzdGVycyAqLwogCWVyciA9IF9fY29weV90b191c2VyKGN0eC0+dnJl Z3MsIGZwc2ltZC0+dnJlZ3MsIHNpemVvZihmcHNpbWQtPnZyZWdzKSk7CiAJX19wdXRfdXNlcl9l cnJvcihmcHNpbWQtPmZwc3IsICZjdHgtPmZwc3IsIGVycik7CkBAIC0yMTQsNiArMjEyLDggQEAg c3RhdGljIGludCByZXN0b3JlX2Zwc2ltZF9jb250ZXh0KHN0cnVjdCBmcHNpbWRfY29udGV4dCBf X3VzZXIgKmN0eCkKIAlfX2dldF91c2VyX2Vycm9yKGZwc2ltZC5mcHNyLCAmY3R4LT5mcHNyLCBl cnIpOwogCV9fZ2V0X3VzZXJfZXJyb3IoZnBzaW1kLmZwY3IsICZjdHgtPmZwY3IsIGVycik7CiAK KwljbGVhcl90aHJlYWRfZmxhZyhUSUZfU1ZFKTsKKwogCS8qIGxvYWQgdGhlIGhhcmR3YXJlIHJl Z2lzdGVycyBmcm9tIHRoZSBmcHNpbWRfc3RhdGUgc3RydWN0dXJlICovCiAJaWYgKCFlcnIpCiAJ CWZwc2ltZF91cGRhdGVfY3VycmVudF9zdGF0ZSgmZnBzaW1kKTsKQEAgLTIyMSwxMCArMjIxLDEx OCBAQCBzdGF0aWMgaW50IHJlc3RvcmVfZnBzaW1kX2NvbnRleHQoc3RydWN0IGZwc2ltZF9jb250 ZXh0IF9fdXNlciAqY3R4KQogCXJldHVybiBlcnIgPyAtRUZBVUxUIDogMDsKIH0KIAorCiBzdHJ1 Y3QgdXNlcl9jdHhzIHsKIAlzdHJ1Y3QgZnBzaW1kX2NvbnRleHQgX191c2VyICpmcHNpbWQ7CisJ c3RydWN0IHN2ZV9jb250ZXh0IF9fdXNlciAqc3ZlOwogfTsKIAorI2lmZGVmIENPTkZJR19BUk02 NF9TVkUKKworc3RhdGljIGludCBwcmVzZXJ2ZV9zdmVfY29udGV4dChzdHJ1Y3Qgc3ZlX2NvbnRl eHQgX191c2VyICpjdHgpCit7CisJaW50IGVyciA9IDA7CisJdTE2IHJlc2VydmVkW0FSUkFZX1NJ WkUoY3R4LT5fX3Jlc2VydmVkKV07CisJdW5zaWduZWQgaW50IHZsID0gY3VycmVudC0+dGhyZWFk LnN2ZV92bDsKKwl1bnNpZ25lZCBpbnQgdnEgPSAwOworCisJaWYgKHRlc3RfdGhyZWFkX2ZsYWco VElGX1NWRSkpCisJCXZxID0gc3ZlX3ZxX2Zyb21fdmwodmwpOworCisJbWVtc2V0KHJlc2VydmVk LCAwLCBzaXplb2YocmVzZXJ2ZWQpKTsKKworCV9fcHV0X3VzZXJfZXJyb3IoU1ZFX01BR0lDLCAm Y3R4LT5oZWFkLm1hZ2ljLCBlcnIpOworCV9fcHV0X3VzZXJfZXJyb3Iocm91bmRfdXAoU1ZFX1NJ R19DT05URVhUX1NJWkUodnEpLCAxNiksCisJCQkgJmN0eC0+aGVhZC5zaXplLCBlcnIpOworCV9f cHV0X3VzZXJfZXJyb3IodmwsICZjdHgtPnZsLCBlcnIpOworCUJVSUxEX0JVR19PTihzaXplb2Yo Y3R4LT5fX3Jlc2VydmVkKSAhPSBzaXplb2YocmVzZXJ2ZWQpKTsKKwllcnIgfD0gX19jb3B5X3Rv X3VzZXIoJmN0eC0+X19yZXNlcnZlZCwgcmVzZXJ2ZWQsIHNpemVvZihyZXNlcnZlZCkpOworCisJ aWYgKHZxKSB7CisJCS8qCisJCSAqIFRoaXMgYXNzdW1lcyB0aGF0IHRoZSBTVkUgc3RhdGUgaGFz IGFscmVhZHkgYmVlbiBzYXZlZCB0bworCQkgKiB0aGUgdGFzayBzdHJ1Y3QgYnkgY2FsbGluZyBw cmVzZXJ2ZV9mcHNpbWRfY29udGV4dCgpLgorCQkgKi8KKwkJZXJyIHw9IF9fY29weV90b191c2Vy KChjaGFyIF9fdXNlciAqKWN0eCArIFNWRV9TSUdfUkVHU19PRkZTRVQsCisJCQkJICAgICAgY3Vy cmVudC0+dGhyZWFkLnN2ZV9zdGF0ZSwKKwkJCQkgICAgICBTVkVfU0lHX1JFR1NfU0laRSh2cSkp OworCX0KKworCXJldHVybiBlcnIgPyAtRUZBVUxUIDogMDsKK30KKworc3RhdGljIGludCByZXN0 b3JlX3N2ZV9mcHNpbWRfY29udGV4dChzdHJ1Y3QgdXNlcl9jdHhzICp1c2VyKQoreworCWludCBl cnI7CisJdW5zaWduZWQgaW50IHZxOworCXN0cnVjdCBmcHNpbWRfc3RhdGUgZnBzaW1kOworCXN0 cnVjdCBzdmVfY29udGV4dCBzdmU7CisKKwlpZiAoX19jb3B5X2Zyb21fdXNlcigmc3ZlLCB1c2Vy LT5zdmUsIHNpemVvZihzdmUpKSkKKwkJcmV0dXJuIC1FRkFVTFQ7CisKKwlpZiAoc3ZlLnZsICE9 IGN1cnJlbnQtPnRocmVhZC5zdmVfdmwpCisJCXJldHVybiAtRUlOVkFMOworCisJaWYgKHN2ZS5o ZWFkLnNpemUgPD0gc2l6ZW9mKCp1c2VyLT5zdmUpKSB7CisJCWNsZWFyX3RocmVhZF9mbGFnKFRJ Rl9TVkUpOworCQlnb3RvIGZwc2ltZF9vbmx5OworCX0KKworCXZxID0gc3ZlX3ZxX2Zyb21fdmwo c3ZlLnZsKTsKKworCWlmIChzdmUuaGVhZC5zaXplIDwgU1ZFX1NJR19DT05URVhUX1NJWkUodnEp KQorCQlyZXR1cm4gLUVJTlZBTDsKKworCS8qCisJICogQ2FyZWZ1bDogd2UgYXJlIGFib3V0IF9f Y29weV9mcm9tX3VzZXIoKSBkaXJlY3RseSBpbnRvCisJICogdGhyZWFkLnN2ZV9zdGF0ZSB3aXRo IHByZWVtcHRpb24gZW5hYmxlZCwgc28gcHJvdGVjdGlvbiBpcworCSAqIG5lZWRlZCB0byBwcmV2 ZW50IGEgcmFjaW5nIGNvbnRleHQgc3dpdGNoIGZyb20gd3JpdGluZyBzdGFsZQorCSAqIHJlZ2lz dGVycyBiYWNrIG92ZXIgdGhlIG5ldyBkYXRhLgorCSAqLworCisJZnBzaW1kX2ZsdXNoX3Rhc2tf c3RhdGUoY3VycmVudCk7CisJYmFycmllcigpOworCS8qIEZyb20gbm93LCBmcHNpbWRfdGhyZWFk X3N3aXRjaCgpIHdvbid0IGNsZWFyIFRJRl9GT1JFSUdOX0ZQU1RBVEUgKi8KKworCXNldF90aHJl YWRfZmxhZyhUSUZfRk9SRUlHTl9GUFNUQVRFKTsKKwliYXJyaWVyKCk7CisJLyogRnJvbSBub3cs IGZwc2ltZF90aHJlYWRfc3dpdGNoKCkgd29uJ3QgdG91Y2ggdGhyZWFkLnN2ZV9zdGF0ZSAqLwor CisJc3ZlX2FsbG9jKGN1cnJlbnQpOworCWVyciA9IF9fY29weV9mcm9tX3VzZXIoY3VycmVudC0+ dGhyZWFkLnN2ZV9zdGF0ZSwKKwkJCSAgICAgICAoY2hhciBfX3VzZXIgY29uc3QgKil1c2VyLT5z dmUgKworCQkJCQlTVkVfU0lHX1JFR1NfT0ZGU0VULAorCQkJICAgICAgIFNWRV9TSUdfUkVHU19T SVpFKHZxKSk7CisJaWYgKGVycikKKwkJcmV0dXJuIC1FRkFVTFQ7CisKKwlzZXRfdGhyZWFkX2Zs YWcoVElGX1NWRSk7CisKK2Zwc2ltZF9vbmx5OgorCS8qIGNvcHkgdGhlIEZQIGFuZCBzdGF0dXMv Y29udHJvbCByZWdpc3RlcnMgKi8KKwkvKiByZXN0b3JlX3NpZ2ZyYW1lKCkgYWxyZWFkeSBjaGVj a2VkIHRoYXQgdXNlci0+ZnBzaW1kICE9IE5VTEwuICovCisJZXJyID0gX19jb3B5X2Zyb21fdXNl cihmcHNpbWQudnJlZ3MsIHVzZXItPmZwc2ltZC0+dnJlZ3MsCisJCQkgICAgICAgc2l6ZW9mKGZw c2ltZC52cmVncykpOworCV9fZ2V0X3VzZXJfZXJyb3IoZnBzaW1kLmZwc3IsICZ1c2VyLT5mcHNp bWQtPmZwc3IsIGVycik7CisJX19nZXRfdXNlcl9lcnJvcihmcHNpbWQuZnBjciwgJnVzZXItPmZw c2ltZC0+ZnBjciwgZXJyKTsKKworCS8qIGxvYWQgdGhlIGhhcmR3YXJlIHJlZ2lzdGVycyBmcm9t IHRoZSBmcHNpbWRfc3RhdGUgc3RydWN0dXJlICovCisJaWYgKCFlcnIpCisJCWZwc2ltZF91cGRh dGVfY3VycmVudF9zdGF0ZSgmZnBzaW1kKTsKKworCXJldHVybiBlcnIgPyAtRUZBVUxUIDogMDsK K30KKworI2Vsc2UgLyogISBDT05GSUdfQVJNNjRfU1ZFICovCisKKy8qIFR1cm4gYW55IG5vbi1v cHRpbWlzZWQgb3V0IGF0dGVtcHRzIHRvIHVzZSB0aGVzZSBpbnRvIGEgbGluayBlcnJvcjogKi8K K2V4dGVybiBpbnQgcHJlc2VydmVfc3ZlX2NvbnRleHQodm9pZCBfX3VzZXIgKmN0eCk7CitleHRl cm4gaW50IHJlc3RvcmVfc3ZlX2Zwc2ltZF9jb250ZXh0KHN0cnVjdCB1c2VyX2N0eHMgKnVzZXIp OworCisjZW5kaWYgLyogISBDT05GSUdfQVJNNjRfU1ZFICovCisKKwogc3RhdGljIGludCBwYXJz ZV91c2VyX3NpZ2ZyYW1lKHN0cnVjdCB1c2VyX2N0eHMgKnVzZXIsCiAJCQkgICAgICAgc3RydWN0 IHJ0X3NpZ2ZyYW1lIF9fdXNlciAqc2YpCiB7CkBAIC0yMzcsNiArMzQ1LDcgQEAgc3RhdGljIGlu dCBwYXJzZV91c2VyX3NpZ2ZyYW1lKHN0cnVjdCB1c2VyX2N0eHMgKnVzZXIsCiAJY2hhciBjb25z dCBfX3VzZXIgKmNvbnN0IHNmcCA9IChjaGFyIGNvbnN0IF9fdXNlciAqKXNmOwogCiAJdXNlci0+ ZnBzaW1kID0gTlVMTDsKKwl1c2VyLT5zdmUgPSBOVUxMOwogCiAJaWYgKCFJU19BTElHTkVEKCh1 bnNpZ25lZCBsb25nKWJhc2UsIDE2KSkKIAkJZ290byBpbnZhbGlkOwpAQCAtMjg3LDYgKzM5Niwx OSBAQCBzdGF0aWMgaW50IHBhcnNlX3VzZXJfc2lnZnJhbWUoc3RydWN0IHVzZXJfY3R4cyAqdXNl ciwKIAkJCS8qIGlnbm9yZSAqLwogCQkJYnJlYWs7CiAKKwkJY2FzZSBTVkVfTUFHSUM6CisJCQlp ZiAoIXN5c3RlbV9zdXBwb3J0c19zdmUoKSkKKwkJCQlnb3RvIGludmFsaWQ7CisKKwkJCWlmICh1 c2VyLT5zdmUpCisJCQkJZ290byBpbnZhbGlkOworCisJCQlpZiAoc2l6ZSA8IHNpemVvZigqdXNl ci0+c3ZlKSkKKwkJCQlnb3RvIGludmFsaWQ7CisKKwkJCXVzZXItPnN2ZSA9IChzdHJ1Y3Qgc3Zl X2NvbnRleHQgX191c2VyICopaGVhZDsKKwkJCWJyZWFrOworCiAJCWNhc2UgRVhUUkFfTUFHSUM6 CiAJCQlpZiAoaGF2ZV9leHRyYV9jb250ZXh0KQogCQkJCWdvdG8gaW52YWxpZDsKQEAgLTM2Myw5 ICs0ODUsNiBAQCBzdGF0aWMgaW50IHBhcnNlX3VzZXJfc2lnZnJhbWUoc3RydWN0IHVzZXJfY3R4 cyAqdXNlciwKIAl9CiAKIGRvbmU6Ci0JaWYgKCF1c2VyLT5mcHNpbWQpCi0JCWdvdG8gaW52YWxp ZDsKLQogCXJldHVybiAwOwogCiBpbnZhbGlkOgpAQCAtMzk5LDggKzUxOCwxOSBAQCBzdGF0aWMg aW50IHJlc3RvcmVfc2lnZnJhbWUoc3RydWN0IHB0X3JlZ3MgKnJlZ3MsCiAJaWYgKGVyciA9PSAw KQogCQllcnIgPSBwYXJzZV91c2VyX3NpZ2ZyYW1lKCZ1c2VyLCBzZik7CiAKLQlpZiAoZXJyID09 IDApCi0JCWVyciA9IHJlc3RvcmVfZnBzaW1kX2NvbnRleHQodXNlci5mcHNpbWQpOworCWlmIChl cnIgPT0gMCkgeworCQlpZiAoIXVzZXIuZnBzaW1kKQorCQkJcmV0dXJuIC1FSU5WQUw7CisKKwkJ aWYgKHVzZXIuc3ZlKSB7CisJCQlpZiAoIXN5c3RlbV9zdXBwb3J0c19zdmUoKSkKKwkJCQlyZXR1 cm4gLUVJTlZBTDsKKworCQkJZXJyID0gcmVzdG9yZV9zdmVfZnBzaW1kX2NvbnRleHQoJnVzZXIp OworCQl9IGVsc2UgeworCQkJZXJyID0gcmVzdG9yZV9mcHNpbWRfY29udGV4dCh1c2VyLmZwc2lt ZCk7CisJCX0KKwl9CiAKIAlyZXR1cm4gZXJyOwogfQpAQCAtNDU5LDYgKzU4OSwxOCBAQCBzdGF0 aWMgaW50IHNldHVwX3NpZ2ZyYW1lX2xheW91dChzdHJ1Y3QgcnRfc2lnZnJhbWVfdXNlcl9sYXlv dXQgKnVzZXIpCiAJCQlyZXR1cm4gZXJyOwogCX0KIAorCWlmIChzeXN0ZW1fc3VwcG9ydHNfc3Zl KCkpIHsKKwkJdW5zaWduZWQgaW50IHZxID0gMDsKKworCQlpZiAodGVzdF90aHJlYWRfZmxhZyhU SUZfU1ZFKSkKKwkJCXZxID0gc3ZlX3ZxX2Zyb21fdmwoY3VycmVudC0+dGhyZWFkLnN2ZV92bCk7 CisKKwkJZXJyID0gc2lnZnJhbWVfYWxsb2ModXNlciwgJnVzZXItPnN2ZV9vZmZzZXQsCisJCQkJ ICAgICBTVkVfU0lHX0NPTlRFWFRfU0laRSh2cSkpOworCQlpZiAoZXJyKQorCQkJcmV0dXJuIGVy cjsKKwl9CisKIAlyZXR1cm4gc2lnZnJhbWVfYWxsb2NfZW5kKHVzZXIpOwogfQogCkBAIC01MDAs NiArNjQyLDEzIEBAIHN0YXRpYyBpbnQgc2V0dXBfc2lnZnJhbWUoc3RydWN0IHJ0X3NpZ2ZyYW1l X3VzZXJfbGF5b3V0ICp1c2VyLAogCQlfX3B1dF91c2VyX2Vycm9yKGN1cnJlbnQtPnRocmVhZC5m YXVsdF9jb2RlLCAmZXNyX2N0eC0+ZXNyLCBlcnIpOwogCX0KIAorCS8qIFNjYWxhYmxlIFZlY3Rv ciBFeHRlbnNpb24gc3RhdGUsIGlmIHByZXNlbnQgKi8KKwlpZiAoc3lzdGVtX3N1cHBvcnRzX3N2 ZSgpICYmIGVyciA9PSAwICYmIHVzZXItPnN2ZV9vZmZzZXQpIHsKKwkJc3RydWN0IHN2ZV9jb250 ZXh0IF9fdXNlciAqc3ZlX2N0eCA9CisJCQlhcHBseV91c2VyX29mZnNldCh1c2VyLCB1c2VyLT5z dmVfb2Zmc2V0KTsKKwkJZXJyIHw9IHByZXNlcnZlX3N2ZV9jb250ZXh0KHN2ZV9jdHgpOworCX0K KwogCWlmIChlcnIgPT0gMCAmJiB1c2VyLT5leHRyYV9vZmZzZXQpIHsKIAkJY2hhciBfX3VzZXIg KnNmcCA9IChjaGFyIF9fdXNlciAqKXVzZXItPnNpZ2ZyYW1lOwogCQljaGFyIF9fdXNlciAqdXNl cnAgPQpAQCAtNTk5LDYgKzc0OCw4IEBAIHN0YXRpYyBpbnQgc2V0dXBfcnRfZnJhbWUoaW50IHVz aWcsIHN0cnVjdCBrc2lnbmFsICprc2lnLCBzaWdzZXRfdCAqc2V0LAogCXN0cnVjdCBydF9zaWdm cmFtZSBfX3VzZXIgKmZyYW1lOwogCWludCBlcnIgPSAwOwogCisJZnBzaW1kX3NpZ25hbF9wcmVz ZXJ2ZV9jdXJyZW50X3N0YXRlKCk7CisKIAlpZiAoZ2V0X3NpZ2ZyYW1lKCZ1c2VyLCBrc2lnLCBy ZWdzKSkKIAkJcmV0dXJuIDE7CiAKZGlmZiAtLWdpdCBhL2FyY2gvYXJtNjQva2VybmVsL3NpZ25h bDMyLmMgYi9hcmNoL2FybTY0L2tlcm5lbC9zaWduYWwzMi5jCmluZGV4IGUwOWJmNWQuLjIyNzEx ZWUgMTAwNjQ0Ci0tLSBhL2FyY2gvYXJtNjQva2VybmVsL3NpZ25hbDMyLmMKKysrIGIvYXJjaC9h cm02NC9rZXJuZWwvc2lnbmFsMzIuYwpAQCAtMjM5LDcgKzIzOSw3IEBAIHN0YXRpYyBpbnQgY29t cGF0X3ByZXNlcnZlX3ZmcF9jb250ZXh0KHN0cnVjdCBjb21wYXRfdmZwX3NpZ2ZyYW1lIF9fdXNl ciAqZnJhbWUpCiAJICogTm90ZSB0aGF0IHRoaXMgYWxzbyBzYXZlcyBWMTYtMzEsIHdoaWNoIGFy ZW4ndCB2aXNpYmxlCiAJICogaW4gQUFyY2gzMi4KIAkgKi8KLQlmcHNpbWRfcHJlc2VydmVfY3Vy cmVudF9zdGF0ZSgpOworCWZwc2ltZF9zaWduYWxfcHJlc2VydmVfY3VycmVudF9zdGF0ZSgpOwog CiAJLyogUGxhY2Ugc3RydWN0dXJlIGhlYWRlciBvbiB0aGUgc3RhY2sgKi8KIAlfX3B1dF91c2Vy X2Vycm9yKG1hZ2ljLCAmZnJhbWUtPm1hZ2ljLCBlcnIpOwotLSAKMi4xLjQKCl9fX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fCmt2bWFybSBtYWlsaW5nIGxpc3QK a3ZtYXJtQGxpc3RzLmNzLmNvbHVtYmlhLmVkdQpodHRwczovL2xpc3RzLmNzLmNvbHVtYmlhLmVk dS9tYWlsbWFuL2xpc3RpbmZvL2t2bWFybQo= 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]:37710 "EHLO foss.arm.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1753486AbdJaPwB (ORCPT ); Tue, 31 Oct 2017 11:52:01 -0400 From: Dave Martin Subject: [PATCH v5 15/30] arm64/sve: Signal handling support Date: Tue, 31 Oct 2017 15:51:07 +0000 Message-ID: <1509465082-30427-16-git-send-email-Dave.Martin@arm.com> In-Reply-To: <1509465082-30427-1-git-send-email-Dave.Martin@arm.com> References: <1509465082-30427-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: <20171031155107.52bAKknBSBpJFUK_DmdNbb1Fwq9CtFeJU8dtbP9wDLg@z> This patch implements support for saving and restoring the SVE registers around signals. A fixed-size header struct sve_context is always included in the signal frame encoding the thread's vector length at the time of signal delivery, optionally followed by a variable-layout structure encoding the SVE registers. Because of the need to preserve backwards compatibility, the FPSIMD view of the SVE registers is always dumped as a struct fpsimd_context in the usual way, in addition to any sve_context. The SVE vector registers are dumped in full, including bits 127:0 of each register which alias the corresponding FPSIMD vector registers in the hardware. To avoid any ambiguity about which alias to restore during sigreturn, the kernel always restores bits 127:0 of each SVE vector register from the fpsimd_context in the signal frame (which must be present): userspace needs to take this into account if it wants to modify the SVE vector register contents on return from a signal. FPSR and FPCR, which are used by both FPSIMD and SVE, are not included in sve_context because they are always present in fpsimd_context anyway. For signal delivery, a new helper fpsimd_signal_preserve_current_state() is added to update _both_ the FPSIMD and SVE views in the task struct, to make it easier to populate this information into the signal frame. Because of the redundancy between the two views of the state, only one is updated otherwise. Signed-off-by: Dave Martin Cc: Alex BennĂ©e Cc: Ard Biesheuvel Cc: Will Deacon --- **Dropped** Reviewed-by: Catalin Marinas (Non-trivial changes.) Changes since v4 ---------------- Requested by Will Deacon: * Fix inconsistent return semantics in restore_sve_fpsimd_context(). Currently a nonzero return value from __copy_from_user() is passed back as-is to the caller or restore_sve_fpsimd_context(), rather than translating it do an error code as is done elsewhere. Callers of restore_sve_fpsimd_context() only care whether the return value is 0 or not, so this isn't a big deal, but it is more consistent to return proper error codes on failure in case we grow a use for them later. This patch returns -EFAULT in the __copy_from_user() error cases that weren't explicitly handled. Miscellaneous: * Change inconsistent copy_to_user() calls to __copy_to_user() in preserve_sve_context(). There are already __put_user_error() calls here. The whole extended signal frame is already checked for access_ok(VERIFY_WRITE) in get_sigframe(). --- arch/arm64/include/asm/fpsimd.h | 1 + arch/arm64/kernel/fpsimd.c | 55 ++++++++++--- arch/arm64/kernel/signal.c | 167 ++++++++++++++++++++++++++++++++++++++-- arch/arm64/kernel/signal32.c | 2 +- 4 files changed, 206 insertions(+), 19 deletions(-) diff --git a/arch/arm64/include/asm/fpsimd.h b/arch/arm64/include/asm/fpsimd.h index 5655fe1..9bbd74c 100644 --- a/arch/arm64/include/asm/fpsimd.h +++ b/arch/arm64/include/asm/fpsimd.h @@ -63,6 +63,7 @@ extern void fpsimd_load_state(struct fpsimd_state *state); extern void fpsimd_thread_switch(struct task_struct *next); extern void fpsimd_flush_thread(void); +extern void fpsimd_signal_preserve_current_state(void); extern void fpsimd_preserve_current_state(void); extern void fpsimd_restore_current_state(void); extern void fpsimd_update_current_state(struct fpsimd_state *state); diff --git a/arch/arm64/kernel/fpsimd.c b/arch/arm64/kernel/fpsimd.c index c91be8e..e0b5ef5 100644 --- a/arch/arm64/kernel/fpsimd.c +++ b/arch/arm64/kernel/fpsimd.c @@ -299,6 +299,32 @@ static void fpsimd_to_sve(struct task_struct *task) sizeof(fst->vregs[i])); } +/* + * Transfer the SVE state in task->thread.sve_state to + * task->thread.fpsimd_state. + * + * Task can be a non-runnable task, or current. In the latter case, + * softirqs (and preemption) must be disabled. + * task->thread.sve_state must point to at least sve_state_size(task) + * bytes of allocated kernel memory. + * task->thread.sve_state must be up to date before calling this function. + */ +static void sve_to_fpsimd(struct task_struct *task) +{ + unsigned int vq; + void const *sst = task->thread.sve_state; + struct fpsimd_state *fst = &task->thread.fpsimd_state; + unsigned int i; + + if (!system_supports_sve()) + return; + + vq = sve_vq_from_vl(task->thread.sve_vl); + for (i = 0; i < 32; ++i) + memcpy(&fst->vregs[i], ZREG(sst, vq, i), + sizeof(fst->vregs[i])); +} + #ifdef CONFIG_ARM64_SVE /* @@ -500,9 +526,6 @@ void fpsimd_flush_thread(void) /* * Save the userland FPSIMD state of 'current' to memory, but only if the state * currently held in the registers does in fact belong to 'current' - * - * Currently, SVE tasks can't exist, so just WARN in that case. - * Subsequent patches will add full SVE support here. */ void fpsimd_preserve_current_state(void) { @@ -510,16 +533,23 @@ void fpsimd_preserve_current_state(void) return; local_bh_disable(); - - if (!test_thread_flag(TIF_FOREIGN_FPSTATE)) - fpsimd_save_state(¤t->thread.fpsimd_state); - - WARN_ON_ONCE(test_and_clear_thread_flag(TIF_SVE)); - + task_fpsimd_save(); local_bh_enable(); } /* + * Like fpsimd_preserve_current_state(), but ensure that + * current->thread.fpsimd_state is updated so that it can be copied to + * the signal frame. + */ +void fpsimd_signal_preserve_current_state(void) +{ + fpsimd_preserve_current_state(); + if (system_supports_sve() && test_thread_flag(TIF_SVE)) + sve_to_fpsimd(current); +} + +/* * Load the userland FPSIMD state of 'current' from memory, but only if the * FPSIMD state already held in the registers is /not/ the most recent FPSIMD * state of 'current' @@ -554,7 +584,12 @@ void fpsimd_update_current_state(struct fpsimd_state *state) local_bh_disable(); - fpsimd_load_state(state); + if (system_supports_sve() && test_thread_flag(TIF_SVE)) { + current->thread.fpsimd_state = *state; + fpsimd_to_sve(current); + } + task_fpsimd_load(); + if (test_and_clear_thread_flag(TIF_FOREIGN_FPSTATE)) { struct fpsimd_state *st = ¤t->thread.fpsimd_state; diff --git a/arch/arm64/kernel/signal.c b/arch/arm64/kernel/signal.c index 4716729..64abf88 100644 --- a/arch/arm64/kernel/signal.c +++ b/arch/arm64/kernel/signal.c @@ -63,6 +63,7 @@ struct rt_sigframe_user_layout { unsigned long fpsimd_offset; unsigned long esr_offset; + unsigned long sve_offset; unsigned long extra_offset; unsigned long end_offset; }; @@ -179,9 +180,6 @@ static int preserve_fpsimd_context(struct fpsimd_context __user *ctx) struct fpsimd_state *fpsimd = ¤t->thread.fpsimd_state; int err; - /* dump the hardware registers to the fpsimd_state structure */ - fpsimd_preserve_current_state(); - /* copy the FP and status/control registers */ err = __copy_to_user(ctx->vregs, fpsimd->vregs, sizeof(fpsimd->vregs)); __put_user_error(fpsimd->fpsr, &ctx->fpsr, err); @@ -214,6 +212,8 @@ static int restore_fpsimd_context(struct fpsimd_context __user *ctx) __get_user_error(fpsimd.fpsr, &ctx->fpsr, err); __get_user_error(fpsimd.fpcr, &ctx->fpcr, err); + clear_thread_flag(TIF_SVE); + /* load the hardware registers from the fpsimd_state structure */ if (!err) fpsimd_update_current_state(&fpsimd); @@ -221,10 +221,118 @@ static int restore_fpsimd_context(struct fpsimd_context __user *ctx) return err ? -EFAULT : 0; } + struct user_ctxs { struct fpsimd_context __user *fpsimd; + struct sve_context __user *sve; }; +#ifdef CONFIG_ARM64_SVE + +static int preserve_sve_context(struct sve_context __user *ctx) +{ + int err = 0; + u16 reserved[ARRAY_SIZE(ctx->__reserved)]; + unsigned int vl = current->thread.sve_vl; + unsigned int vq = 0; + + if (test_thread_flag(TIF_SVE)) + vq = sve_vq_from_vl(vl); + + memset(reserved, 0, sizeof(reserved)); + + __put_user_error(SVE_MAGIC, &ctx->head.magic, err); + __put_user_error(round_up(SVE_SIG_CONTEXT_SIZE(vq), 16), + &ctx->head.size, err); + __put_user_error(vl, &ctx->vl, err); + BUILD_BUG_ON(sizeof(ctx->__reserved) != sizeof(reserved)); + err |= __copy_to_user(&ctx->__reserved, reserved, sizeof(reserved)); + + if (vq) { + /* + * This assumes that the SVE state has already been saved to + * the task struct by calling preserve_fpsimd_context(). + */ + err |= __copy_to_user((char __user *)ctx + SVE_SIG_REGS_OFFSET, + current->thread.sve_state, + SVE_SIG_REGS_SIZE(vq)); + } + + return err ? -EFAULT : 0; +} + +static int restore_sve_fpsimd_context(struct user_ctxs *user) +{ + int err; + unsigned int vq; + struct fpsimd_state fpsimd; + struct sve_context sve; + + if (__copy_from_user(&sve, user->sve, sizeof(sve))) + return -EFAULT; + + if (sve.vl != current->thread.sve_vl) + return -EINVAL; + + if (sve.head.size <= sizeof(*user->sve)) { + clear_thread_flag(TIF_SVE); + goto fpsimd_only; + } + + vq = sve_vq_from_vl(sve.vl); + + if (sve.head.size < SVE_SIG_CONTEXT_SIZE(vq)) + return -EINVAL; + + /* + * Careful: we are about __copy_from_user() directly into + * thread.sve_state with preemption enabled, so protection is + * needed to prevent a racing context switch from writing stale + * registers back over the new data. + */ + + fpsimd_flush_task_state(current); + barrier(); + /* From now, fpsimd_thread_switch() won't clear TIF_FOREIGN_FPSTATE */ + + set_thread_flag(TIF_FOREIGN_FPSTATE); + barrier(); + /* From now, fpsimd_thread_switch() won't touch thread.sve_state */ + + sve_alloc(current); + err = __copy_from_user(current->thread.sve_state, + (char __user const *)user->sve + + SVE_SIG_REGS_OFFSET, + SVE_SIG_REGS_SIZE(vq)); + if (err) + return -EFAULT; + + set_thread_flag(TIF_SVE); + +fpsimd_only: + /* copy the FP and status/control registers */ + /* restore_sigframe() already checked that user->fpsimd != NULL. */ + err = __copy_from_user(fpsimd.vregs, user->fpsimd->vregs, + sizeof(fpsimd.vregs)); + __get_user_error(fpsimd.fpsr, &user->fpsimd->fpsr, err); + __get_user_error(fpsimd.fpcr, &user->fpsimd->fpcr, err); + + /* load the hardware registers from the fpsimd_state structure */ + if (!err) + fpsimd_update_current_state(&fpsimd); + + return err ? -EFAULT : 0; +} + +#else /* ! CONFIG_ARM64_SVE */ + +/* Turn any non-optimised out attempts to use these into a link error: */ +extern int preserve_sve_context(void __user *ctx); +extern int restore_sve_fpsimd_context(struct user_ctxs *user); + +#endif /* ! CONFIG_ARM64_SVE */ + + static int parse_user_sigframe(struct user_ctxs *user, struct rt_sigframe __user *sf) { @@ -237,6 +345,7 @@ static int parse_user_sigframe(struct user_ctxs *user, char const __user *const sfp = (char const __user *)sf; user->fpsimd = NULL; + user->sve = NULL; if (!IS_ALIGNED((unsigned long)base, 16)) goto invalid; @@ -287,6 +396,19 @@ static int parse_user_sigframe(struct user_ctxs *user, /* ignore */ break; + case SVE_MAGIC: + if (!system_supports_sve()) + goto invalid; + + if (user->sve) + goto invalid; + + if (size < sizeof(*user->sve)) + goto invalid; + + user->sve = (struct sve_context __user *)head; + break; + case EXTRA_MAGIC: if (have_extra_context) goto invalid; @@ -363,9 +485,6 @@ static int parse_user_sigframe(struct user_ctxs *user, } done: - if (!user->fpsimd) - goto invalid; - return 0; invalid: @@ -399,8 +518,19 @@ static int restore_sigframe(struct pt_regs *regs, if (err == 0) err = parse_user_sigframe(&user, sf); - if (err == 0) - err = restore_fpsimd_context(user.fpsimd); + if (err == 0) { + if (!user.fpsimd) + return -EINVAL; + + if (user.sve) { + if (!system_supports_sve()) + return -EINVAL; + + err = restore_sve_fpsimd_context(&user); + } else { + err = restore_fpsimd_context(user.fpsimd); + } + } return err; } @@ -459,6 +589,18 @@ static int setup_sigframe_layout(struct rt_sigframe_user_layout *user) return err; } + if (system_supports_sve()) { + unsigned int vq = 0; + + if (test_thread_flag(TIF_SVE)) + vq = sve_vq_from_vl(current->thread.sve_vl); + + err = sigframe_alloc(user, &user->sve_offset, + SVE_SIG_CONTEXT_SIZE(vq)); + if (err) + return err; + } + return sigframe_alloc_end(user); } @@ -500,6 +642,13 @@ static int setup_sigframe(struct rt_sigframe_user_layout *user, __put_user_error(current->thread.fault_code, &esr_ctx->esr, err); } + /* Scalable Vector Extension state, if present */ + if (system_supports_sve() && err == 0 && user->sve_offset) { + struct sve_context __user *sve_ctx = + apply_user_offset(user, user->sve_offset); + err |= preserve_sve_context(sve_ctx); + } + if (err == 0 && user->extra_offset) { char __user *sfp = (char __user *)user->sigframe; char __user *userp = @@ -599,6 +748,8 @@ static int setup_rt_frame(int usig, struct ksignal *ksig, sigset_t *set, struct rt_sigframe __user *frame; int err = 0; + fpsimd_signal_preserve_current_state(); + if (get_sigframe(&user, ksig, regs)) return 1; diff --git a/arch/arm64/kernel/signal32.c b/arch/arm64/kernel/signal32.c index e09bf5d..22711ee 100644 --- a/arch/arm64/kernel/signal32.c +++ b/arch/arm64/kernel/signal32.c @@ -239,7 +239,7 @@ static int compat_preserve_vfp_context(struct compat_vfp_sigframe __user *frame) * Note that this also saves V16-31, which aren't visible * in AArch32. */ - fpsimd_preserve_current_state(); + fpsimd_signal_preserve_current_state(); /* Place structure header on the stack */ __put_user_error(magic, &frame->magic, err); -- 2.1.4