From mboxrd@z Thu Jan 1 00:00:00 1970 From: Dave Martin Subject: [PATCH v4 13/28] arm64/sve: Signal handling support Date: Fri, 27 Oct 2017 11:50:55 +0100 Message-ID: <1509101470-7881-14-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 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 ZCBCaWVzaGV1dmVsIDxhcmQuYmllc2hldXZlbEBsaW5hcm8ub3JnPgoKLS0tCgpDaGFuZ2VzIHNp bmNlIHYzCi0tLS0tLS0tLS0tLS0tLS0KCioqRHJvcHBlZCoqIFJldmlld2VkLWJ5OiBDYXRhbGlu IE1hcmluYXMgPGNhdGFsaW4ubWFyaW5hc0Bhcm0uY29tPgpUaGUgY2hhbmdlcyBhcmUgbWlub3Ig aG93ZXZlcjoKCkNoYW5nZXMgcmVxdWVzdGVkIGJ5IENhdGFsaW4gLyBXaWxsOgoKICogQUJJIGNo YW5nZTogWmVybyBTVkUgcmVncyBvbiBzeXNjYWxsIGVudHJ5OgoKICAgUmVmYWN0b3Jpbmcgc2lu Y2UgdjIgdGhhdCBhbGxvd2VkIGRpc2NhcmQgdG8gYmUgZXhwbGljaXRseSByZXF1ZXN0ZWQKICAg aGFzIGJlZW4gZHJvcHBlZCwgc2luY2Ugbm93IGRpc2NhcmQgaGFzIGFscmVhZHkgaGFwcGVuZWQg YXQgc3lzY2FsbAogICBlbnRyeSBpbiB0aGUgcmVsZXZhbnQgc2NlbmFyaW9zLgoKICogRGVsZXRl IGEgY29tbWVudCB0aGF0IHRoYXQgaXMgbm8gbG9uZ2VyIGFwcHJvcHJpYXRlOiB0aGVyZSBjYW4g bm8KICAgbG9uZ2VyIGJlIGEgcGVuZGluZyBkaXNjYXJkLgoKICAgSXQgc3RpbGwgbWFrZXMgcmVh c29uYWJsZSBzZW5zZSB0byB3cml0ZSB0aGUgRlBTSU1EL1NWRSBzdGF0ZSBiYWNrCiAgIHRvIHRo cmVhZF9zdHJ1Y3Qgb24gdGhlIGNvbW1vbiBwYXRoIHRob3VnaC4KLS0tCiBhcmNoL2FybTY0L2lu Y2x1ZGUvYXNtL2Zwc2ltZC5oIHwgICAxICsKIGFyY2gvYXJtNjQva2VybmVsL2Zwc2ltZC5jICAg ICAgfCAgNTUgKysrKysrKysrKy0tLQogYXJjaC9hcm02NC9rZXJuZWwvc2lnbmFsLmMgICAgICB8 IDE2NyArKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKy0tCiBhcmNoL2FybTY0 L2tlcm5lbC9zaWduYWwzMi5jICAgIHwgICAyICstCiA0IGZpbGVzIGNoYW5nZWQsIDIwNiBpbnNl cnRpb25zKCspLCAxOSBkZWxldGlvbnMoLSkKCmRpZmYgLS1naXQgYS9hcmNoL2FybTY0L2luY2x1 ZGUvYXNtL2Zwc2ltZC5oIGIvYXJjaC9hcm02NC9pbmNsdWRlL2FzbS9mcHNpbWQuaAppbmRleCA1 NjU1ZmUxLi45YmJkNzRjIDEwMDY0NAotLS0gYS9hcmNoL2FybTY0L2luY2x1ZGUvYXNtL2Zwc2lt ZC5oCisrKyBiL2FyY2gvYXJtNjQvaW5jbHVkZS9hc20vZnBzaW1kLmgKQEAgLTYzLDYgKzYzLDcg QEAgZXh0ZXJuIHZvaWQgZnBzaW1kX2xvYWRfc3RhdGUoc3RydWN0IGZwc2ltZF9zdGF0ZSAqc3Rh dGUpOwogZXh0ZXJuIHZvaWQgZnBzaW1kX3RocmVhZF9zd2l0Y2goc3RydWN0IHRhc2tfc3RydWN0 ICpuZXh0KTsKIGV4dGVybiB2b2lkIGZwc2ltZF9mbHVzaF90aHJlYWQodm9pZCk7CiAKK2V4dGVy biB2b2lkIGZwc2ltZF9zaWduYWxfcHJlc2VydmVfY3VycmVudF9zdGF0ZSh2b2lkKTsKIGV4dGVy biB2b2lkIGZwc2ltZF9wcmVzZXJ2ZV9jdXJyZW50X3N0YXRlKHZvaWQpOwogZXh0ZXJuIHZvaWQg ZnBzaW1kX3Jlc3RvcmVfY3VycmVudF9zdGF0ZSh2b2lkKTsKIGV4dGVybiB2b2lkIGZwc2ltZF91 cGRhdGVfY3VycmVudF9zdGF0ZShzdHJ1Y3QgZnBzaW1kX3N0YXRlICpzdGF0ZSk7CmRpZmYgLS1n aXQgYS9hcmNoL2FybTY0L2tlcm5lbC9mcHNpbWQuYyBiL2FyY2gvYXJtNjQva2VybmVsL2Zwc2lt ZC5jCmluZGV4IDJiNjkxZDEuLjUwNjM0NzYgMTAwNjQ0Ci0tLSBhL2FyY2gvYXJtNjQva2VybmVs L2Zwc2ltZC5jCisrKyBiL2FyY2gvYXJtNjQva2VybmVsL2Zwc2ltZC5jCkBAIC0yOTgsNiArMjk4 LDMyIEBAIHN0YXRpYyB2b2lkIGZwc2ltZF90b19zdmUoc3RydWN0IHRhc2tfc3RydWN0ICp0YXNr KQogCQkgICAgICAgc2l6ZW9mKGZzdC0+dnJlZ3NbaV0pKTsKIH0KIAorLyoKKyAqIFRyYW5zZmVy IHRoZSBTVkUgc3RhdGUgaW4gdGFzay0+dGhyZWFkLnN2ZV9zdGF0ZSB0bworICogdGFzay0+dGhy ZWFkLmZwc2ltZF9zdGF0ZS4KKyAqCisgKiBUYXNrIGNhbiBiZSBhIG5vbi1ydW5uYWJsZSB0YXNr LCBvciBjdXJyZW50LiAgSW4gdGhlIGxhdHRlciBjYXNlLAorICogc29mdGlycXMgKGFuZCBwcmVl bXB0aW9uKSBtdXN0IGJlIGRpc2FibGVkLgorICogdGFzay0+dGhyZWFkLnN2ZV9zdGF0ZSBtdXN0 IHBvaW50IHRvIGF0IGxlYXN0IHN2ZV9zdGF0ZV9zaXplKHRhc2spCisgKiBieXRlcyBvZiBhbGxv Y2F0ZWQga2VybmVsIG1lbW9yeS4KKyAqIHRhc2stPnRocmVhZC5zdmVfc3RhdGUgbXVzdCBiZSB1 cCB0byBkYXRlIGJlZm9yZSBjYWxsaW5nIHRoaXMgZnVuY3Rpb24uCisgKi8KK3N0YXRpYyB2b2lk IHN2ZV90b19mcHNpbWQoc3RydWN0IHRhc2tfc3RydWN0ICp0YXNrKQoreworCXVuc2lnbmVkIGlu dCB2cTsKKwl2b2lkIGNvbnN0ICpzc3QgPSB0YXNrLT50aHJlYWQuc3ZlX3N0YXRlOworCXN0cnVj dCBmcHNpbWRfc3RhdGUgKmZzdCA9ICZ0YXNrLT50aHJlYWQuZnBzaW1kX3N0YXRlOworCXVuc2ln bmVkIGludCBpOworCisJaWYgKCFzeXN0ZW1fc3VwcG9ydHNfc3ZlKCkpCisJCXJldHVybjsKKwor CXZxID0gc3ZlX3ZxX2Zyb21fdmwodGFzay0+dGhyZWFkLnN2ZV92bCk7CisJZm9yIChpID0gMDsg aSA8IDMyOyArK2kpCisJCW1lbWNweSgmZnN0LT52cmVnc1tpXSwgWlJFRyhzc3QsIHZxLCBpKSwK KwkJICAgICAgIHNpemVvZihmc3QtPnZyZWdzW2ldKSk7Cit9CisKICNpZmRlZiBDT05GSUdfQVJN NjRfU1ZFCiAKIC8qCkBAIC00OTksOSArNTI1LDYgQEAgdm9pZCBmcHNpbWRfZmx1c2hfdGhyZWFk KHZvaWQpCiAvKgogICogU2F2ZSB0aGUgdXNlcmxhbmQgRlBTSU1EIHN0YXRlIG9mICdjdXJyZW50 JyB0byBtZW1vcnksIGJ1dCBvbmx5IGlmIHRoZSBzdGF0ZQogICogY3VycmVudGx5IGhlbGQgaW4g dGhlIHJlZ2lzdGVycyBkb2VzIGluIGZhY3QgYmVsb25nIHRvICdjdXJyZW50JwotICoKLSAqIEN1 cnJlbnRseSwgU1ZFIHRhc2tzIGNhbid0IGV4aXN0LCBzbyBqdXN0IFdBUk4gaW4gdGhhdCBjYXNl LgotICogU3Vic2VxdWVudCBwYXRjaGVzIHdpbGwgYWRkIGZ1bGwgU1ZFIHN1cHBvcnQgaGVyZS4K ICAqLwogdm9pZCBmcHNpbWRfcHJlc2VydmVfY3VycmVudF9zdGF0ZSh2b2lkKQogewpAQCAtNTA5 LDE2ICs1MzIsMjMgQEAgdm9pZCBmcHNpbWRfcHJlc2VydmVfY3VycmVudF9zdGF0ZSh2b2lkKQog CQlyZXR1cm47CiAKIAlsb2NhbF9iaF9kaXNhYmxlKCk7Ci0KLQlpZiAoIXRlc3RfdGhyZWFkX2Zs YWcoVElGX0ZPUkVJR05fRlBTVEFURSkpCi0JCWZwc2ltZF9zYXZlX3N0YXRlKCZjdXJyZW50LT50 aHJlYWQuZnBzaW1kX3N0YXRlKTsKLQotCVdBUk5fT05fT05DRSh0ZXN0X2FuZF9jbGVhcl90aHJl YWRfZmxhZyhUSUZfU1ZFKSk7Ci0KKwl0YXNrX2Zwc2ltZF9zYXZlKCk7CiAJbG9jYWxfYmhfZW5h YmxlKCk7CiB9CiAKIC8qCisgKiBMaWtlIGZwc2ltZF9wcmVzZXJ2ZV9jdXJyZW50X3N0YXRlKCks IGJ1dCBlbnN1cmUgdGhhdAorICogY3VycmVudC0+dGhyZWFkLmZwc2ltZF9zdGF0ZSBpcyB1cGRh dGVkIHNvIHRoYXQgaXQgY2FuIGJlIGNvcGllZCB0bworICogdGhlIHNpZ25hbCBmcmFtZS4KKyAq Lwordm9pZCBmcHNpbWRfc2lnbmFsX3ByZXNlcnZlX2N1cnJlbnRfc3RhdGUodm9pZCkKK3sKKwlm cHNpbWRfcHJlc2VydmVfY3VycmVudF9zdGF0ZSgpOworCWlmIChzeXN0ZW1fc3VwcG9ydHNfc3Zl KCkgJiYgdGVzdF90aHJlYWRfZmxhZyhUSUZfU1ZFKSkKKwkJc3ZlX3RvX2Zwc2ltZChjdXJyZW50 KTsKK30KKworLyoKICAqIExvYWQgdGhlIHVzZXJsYW5kIEZQU0lNRCBzdGF0ZSBvZiAnY3VycmVu dCcgZnJvbSBtZW1vcnksIGJ1dCBvbmx5IGlmIHRoZQogICogRlBTSU1EIHN0YXRlIGFscmVhZHkg aGVsZCBpbiB0aGUgcmVnaXN0ZXJzIGlzIC9ub3QvIHRoZSBtb3N0IHJlY2VudCBGUFNJTUQKICAq IHN0YXRlIG9mICdjdXJyZW50JwpAQCAtNTUzLDcgKzU4MywxMiBAQCB2b2lkIGZwc2ltZF91cGRh dGVfY3VycmVudF9zdGF0ZShzdHJ1Y3QgZnBzaW1kX3N0YXRlICpzdGF0ZSkKIAogCWxvY2FsX2Jo X2Rpc2FibGUoKTsKIAotCWZwc2ltZF9sb2FkX3N0YXRlKHN0YXRlKTsKKwlpZiAoc3lzdGVtX3N1 cHBvcnRzX3N2ZSgpICYmIHRlc3RfdGhyZWFkX2ZsYWcoVElGX1NWRSkpIHsKKwkJY3VycmVudC0+ dGhyZWFkLmZwc2ltZF9zdGF0ZSA9ICpzdGF0ZTsKKwkJZnBzaW1kX3RvX3N2ZShjdXJyZW50KTsK Kwl9CisJdGFza19mcHNpbWRfbG9hZCgpOworCiAJaWYgKHRlc3RfYW5kX2NsZWFyX3RocmVhZF9m bGFnKFRJRl9GT1JFSUdOX0ZQU1RBVEUpKSB7CiAJCXN0cnVjdCBmcHNpbWRfc3RhdGUgKnN0ID0g JmN1cnJlbnQtPnRocmVhZC5mcHNpbWRfc3RhdGU7CiAKZGlmZiAtLWdpdCBhL2FyY2gvYXJtNjQv a2VybmVsL3NpZ25hbC5jIGIvYXJjaC9hcm02NC9rZXJuZWwvc2lnbmFsLmMKaW5kZXggMGJkYzk2 Yy4uNzliYzU1YSAxMDA2NDQKLS0tIGEvYXJjaC9hcm02NC9rZXJuZWwvc2lnbmFsLmMKKysrIGIv YXJjaC9hcm02NC9rZXJuZWwvc2lnbmFsLmMKQEAgLTYzLDYgKzYzLDcgQEAgc3RydWN0IHJ0X3Np Z2ZyYW1lX3VzZXJfbGF5b3V0IHsKIAogCXVuc2lnbmVkIGxvbmcgZnBzaW1kX29mZnNldDsKIAl1 bnNpZ25lZCBsb25nIGVzcl9vZmZzZXQ7CisJdW5zaWduZWQgbG9uZyBzdmVfb2Zmc2V0OwogCXVu c2lnbmVkIGxvbmcgZXh0cmFfb2Zmc2V0OwogCXVuc2lnbmVkIGxvbmcgZW5kX29mZnNldDsKIH07 CkBAIC0xNzksOSArMTgwLDYgQEAgc3RhdGljIGludCBwcmVzZXJ2ZV9mcHNpbWRfY29udGV4dChz dHJ1Y3QgZnBzaW1kX2NvbnRleHQgX191c2VyICpjdHgpCiAJc3RydWN0IGZwc2ltZF9zdGF0ZSAq ZnBzaW1kID0gJmN1cnJlbnQtPnRocmVhZC5mcHNpbWRfc3RhdGU7CiAJaW50IGVycjsKIAotCS8q IGR1bXAgdGhlIGhhcmR3YXJlIHJlZ2lzdGVycyB0byB0aGUgZnBzaW1kX3N0YXRlIHN0cnVjdHVy ZSAqLwotCWZwc2ltZF9wcmVzZXJ2ZV9jdXJyZW50X3N0YXRlKCk7Ci0KIAkvKiBjb3B5IHRoZSBG UCBhbmQgc3RhdHVzL2NvbnRyb2wgcmVnaXN0ZXJzICovCiAJZXJyID0gX19jb3B5X3RvX3VzZXIo Y3R4LT52cmVncywgZnBzaW1kLT52cmVncywgc2l6ZW9mKGZwc2ltZC0+dnJlZ3MpKTsKIAlfX3B1 dF91c2VyX2Vycm9yKGZwc2ltZC0+ZnBzciwgJmN0eC0+ZnBzciwgZXJyKTsKQEAgLTIxNCw2ICsy MTIsOCBAQCBzdGF0aWMgaW50IHJlc3RvcmVfZnBzaW1kX2NvbnRleHQoc3RydWN0IGZwc2ltZF9j b250ZXh0IF9fdXNlciAqY3R4KQogCV9fZ2V0X3VzZXJfZXJyb3IoZnBzaW1kLmZwc3IsICZjdHgt PmZwc3IsIGVycik7CiAJX19nZXRfdXNlcl9lcnJvcihmcHNpbWQuZnBjciwgJmN0eC0+ZnBjciwg ZXJyKTsKIAorCWNsZWFyX3RocmVhZF9mbGFnKFRJRl9TVkUpOworCiAJLyogbG9hZCB0aGUgaGFy ZHdhcmUgcmVnaXN0ZXJzIGZyb20gdGhlIGZwc2ltZF9zdGF0ZSBzdHJ1Y3R1cmUgKi8KIAlpZiAo IWVycikKIAkJZnBzaW1kX3VwZGF0ZV9jdXJyZW50X3N0YXRlKCZmcHNpbWQpOwpAQCAtMjIxLDEw ICsyMjEsMTE4IEBAIHN0YXRpYyBpbnQgcmVzdG9yZV9mcHNpbWRfY29udGV4dChzdHJ1Y3QgZnBz aW1kX2NvbnRleHQgX191c2VyICpjdHgpCiAJcmV0dXJuIGVyciA/IC1FRkFVTFQgOiAwOwogfQog CisKIHN0cnVjdCB1c2VyX2N0eHMgewogCXN0cnVjdCBmcHNpbWRfY29udGV4dCBfX3VzZXIgKmZw c2ltZDsKKwlzdHJ1Y3Qgc3ZlX2NvbnRleHQgX191c2VyICpzdmU7CiB9OwogCisjaWZkZWYgQ09O RklHX0FSTTY0X1NWRQorCitzdGF0aWMgaW50IHByZXNlcnZlX3N2ZV9jb250ZXh0KHN0cnVjdCBz dmVfY29udGV4dCBfX3VzZXIgKmN0eCkKK3sKKwlpbnQgZXJyID0gMDsKKwl1MTYgcmVzZXJ2ZWRb QVJSQVlfU0laRShjdHgtPl9fcmVzZXJ2ZWQpXTsKKwl1bnNpZ25lZCBpbnQgdmwgPSBjdXJyZW50 LT50aHJlYWQuc3ZlX3ZsOworCXVuc2lnbmVkIGludCB2cSA9IDA7CisKKwlpZiAodGVzdF90aHJl YWRfZmxhZyhUSUZfU1ZFKSkKKwkJdnEgPSBzdmVfdnFfZnJvbV92bCh2bCk7CisKKwltZW1zZXQo cmVzZXJ2ZWQsIDAsIHNpemVvZihyZXNlcnZlZCkpOworCisJX19wdXRfdXNlcl9lcnJvcihTVkVf TUFHSUMsICZjdHgtPmhlYWQubWFnaWMsIGVycik7CisJX19wdXRfdXNlcl9lcnJvcihyb3VuZF91 cChTVkVfU0lHX0NPTlRFWFRfU0laRSh2cSksIDE2KSwKKwkJCSAmY3R4LT5oZWFkLnNpemUsIGVy cik7CisJX19wdXRfdXNlcl9lcnJvcih2bCwgJmN0eC0+dmwsIGVycik7CisJQlVJTERfQlVHX09O KHNpemVvZihjdHgtPl9fcmVzZXJ2ZWQpICE9IHNpemVvZihyZXNlcnZlZCkpOworCWVyciB8PSBj b3B5X3RvX3VzZXIoJmN0eC0+X19yZXNlcnZlZCwgcmVzZXJ2ZWQsIHNpemVvZihyZXNlcnZlZCkp OworCisJaWYgKHZxKSB7CisJCS8qCisJCSAqIFRoaXMgYXNzdW1lcyB0aGF0IHRoZSBTVkUgc3Rh dGUgaGFzIGFscmVhZHkgYmVlbiBzYXZlZCB0bworCQkgKiB0aGUgdGFzayBzdHJ1Y3QgYnkgY2Fs bGluZyBwcmVzZXJ2ZV9mcHNpbWRfY29udGV4dCgpLgorCQkgKi8KKwkJZXJyIHw9IGNvcHlfdG9f dXNlcigoY2hhciBfX3VzZXIgKiljdHggKyBTVkVfU0lHX1JFR1NfT0ZGU0VULAorCQkJCSAgICBj dXJyZW50LT50aHJlYWQuc3ZlX3N0YXRlLAorCQkJCSAgICBTVkVfU0lHX1JFR1NfU0laRSh2cSkp OworCX0KKworCXJldHVybiBlcnIgPyAtRUZBVUxUIDogMDsKK30KKworc3RhdGljIGludCByZXN0 b3JlX3N2ZV9mcHNpbWRfY29udGV4dChzdHJ1Y3QgdXNlcl9jdHhzICp1c2VyKQoreworCWludCBl cnI7CisJdW5zaWduZWQgaW50IHZxOworCXN0cnVjdCBmcHNpbWRfc3RhdGUgZnBzaW1kOworCXN0 cnVjdCBzdmVfY29udGV4dCBzdmU7CisKKwlpZiAoX19jb3B5X2Zyb21fdXNlcigmc3ZlLCB1c2Vy LT5zdmUsIHNpemVvZihzdmUpKSkKKwkJcmV0dXJuIC1FRkFVTFQ7CisKKwlpZiAoc3ZlLnZsICE9 IGN1cnJlbnQtPnRocmVhZC5zdmVfdmwpCisJCXJldHVybiAtRUlOVkFMOworCisJaWYgKHN2ZS5o ZWFkLnNpemUgPD0gc2l6ZW9mKCp1c2VyLT5zdmUpKSB7CisJCWNsZWFyX3RocmVhZF9mbGFnKFRJ Rl9TVkUpOworCQlnb3RvIGZwc2ltZF9vbmx5OworCX0KKworCXZxID0gc3ZlX3ZxX2Zyb21fdmwo c3ZlLnZsKTsKKworCWlmIChzdmUuaGVhZC5zaXplIDwgU1ZFX1NJR19DT05URVhUX1NJWkUodnEp KQorCQlyZXR1cm4gLUVJTlZBTDsKKworCS8qCisJICogQ2FyZWZ1bDogd2UgYXJlIGFib3V0IF9f Y29weV9mcm9tX3VzZXIoKSBkaXJlY3RseSBpbnRvCisJICogdGhyZWFkLnN2ZV9zdGF0ZSB3aXRo IHByZWVtcHRpb24gZW5hYmxlZCwgc28gcHJvdGVjdGlvbiBpcworCSAqIG5lZWRlZCB0byBwcmV2 ZW50IGEgcmFjaW5nIGNvbnRleHQgc3dpdGNoIGZyb20gd3JpdGluZyBzdGFsZQorCSAqIHJlZ2lz dGVycyBiYWNrIG92ZXIgdGhlIG5ldyBkYXRhLgorCSAqLworCisJZnBzaW1kX2ZsdXNoX3Rhc2tf c3RhdGUoY3VycmVudCk7CisJYmFycmllcigpOworCS8qIEZyb20gbm93LCBmcHNpbWRfdGhyZWFk X3N3aXRjaCgpIHdvbid0IGNsZWFyIFRJRl9GT1JFSUdOX0ZQU1RBVEUgKi8KKworCXNldF90aHJl YWRfZmxhZyhUSUZfRk9SRUlHTl9GUFNUQVRFKTsKKwliYXJyaWVyKCk7CisJLyogRnJvbSBub3cs IGZwc2ltZF90aHJlYWRfc3dpdGNoKCkgd29uJ3QgdG91Y2ggdGhyZWFkLnN2ZV9zdGF0ZSAqLwor CisJc3ZlX2FsbG9jKGN1cnJlbnQpOworCWVyciA9IF9fY29weV9mcm9tX3VzZXIoY3VycmVudC0+ dGhyZWFkLnN2ZV9zdGF0ZSwKKwkJCSAgICAgICAoY2hhciBfX3VzZXIgY29uc3QgKil1c2VyLT5z dmUgKworCQkJCQlTVkVfU0lHX1JFR1NfT0ZGU0VULAorCQkJICAgICAgIFNWRV9TSUdfUkVHU19T SVpFKHZxKSk7CisJaWYgKGVycikKKwkJcmV0dXJuIGVycjsKKworCXNldF90aHJlYWRfZmxhZyhU SUZfU1ZFKTsKKworZnBzaW1kX29ubHk6CisJLyogY29weSB0aGUgRlAgYW5kIHN0YXR1cy9jb250 cm9sIHJlZ2lzdGVycyAqLworCS8qIHJlc3RvcmVfc2lnZnJhbWUoKSBhbHJlYWR5IGNoZWNrZWQg dGhhdCB1c2VyLT5mcHNpbWQgIT0gTlVMTC4gKi8KKwllcnIgPSBfX2NvcHlfZnJvbV91c2VyKGZw c2ltZC52cmVncywgdXNlci0+ZnBzaW1kLT52cmVncywKKwkJCSAgICAgICBzaXplb2YoZnBzaW1k LnZyZWdzKSk7CisJX19nZXRfdXNlcl9lcnJvcihmcHNpbWQuZnBzciwgJnVzZXItPmZwc2ltZC0+ ZnBzciwgZXJyKTsKKwlfX2dldF91c2VyX2Vycm9yKGZwc2ltZC5mcGNyLCAmdXNlci0+ZnBzaW1k LT5mcGNyLCBlcnIpOworCisJLyogbG9hZCB0aGUgaGFyZHdhcmUgcmVnaXN0ZXJzIGZyb20gdGhl IGZwc2ltZF9zdGF0ZSBzdHJ1Y3R1cmUgKi8KKwlpZiAoIWVycikKKwkJZnBzaW1kX3VwZGF0ZV9j dXJyZW50X3N0YXRlKCZmcHNpbWQpOworCisJcmV0dXJuIGVycjsKK30KKworI2Vsc2UgLyogISBD T05GSUdfQVJNNjRfU1ZFICovCisKKy8qIFR1cm4gYW55IG5vbi1vcHRpbWlzZWQgb3V0IGF0dGVt cHRzIHRvIHVzZSB0aGVzZSBpbnRvIGEgbGluayBlcnJvcjogKi8KK2V4dGVybiBpbnQgcHJlc2Vy dmVfc3ZlX2NvbnRleHQodm9pZCBfX3VzZXIgKmN0eCk7CitleHRlcm4gaW50IHJlc3RvcmVfc3Zl X2Zwc2ltZF9jb250ZXh0KHN0cnVjdCB1c2VyX2N0eHMgKnVzZXIpOworCisjZW5kaWYgLyogISBD T05GSUdfQVJNNjRfU1ZFICovCisKKwogc3RhdGljIGludCBwYXJzZV91c2VyX3NpZ2ZyYW1lKHN0 cnVjdCB1c2VyX2N0eHMgKnVzZXIsCiAJCQkgICAgICAgc3RydWN0IHJ0X3NpZ2ZyYW1lIF9fdXNl ciAqc2YpCiB7CkBAIC0yMzcsNiArMzQ1LDcgQEAgc3RhdGljIGludCBwYXJzZV91c2VyX3NpZ2Zy YW1lKHN0cnVjdCB1c2VyX2N0eHMgKnVzZXIsCiAJY2hhciBjb25zdCBfX3VzZXIgKmNvbnN0IHNm cCA9IChjaGFyIGNvbnN0IF9fdXNlciAqKXNmOwogCiAJdXNlci0+ZnBzaW1kID0gTlVMTDsKKwl1 c2VyLT5zdmUgPSBOVUxMOwogCiAJaWYgKCFJU19BTElHTkVEKCh1bnNpZ25lZCBsb25nKWJhc2Us IDE2KSkKIAkJZ290byBpbnZhbGlkOwpAQCAtMjg3LDYgKzM5NiwxOSBAQCBzdGF0aWMgaW50IHBh cnNlX3VzZXJfc2lnZnJhbWUoc3RydWN0IHVzZXJfY3R4cyAqdXNlciwKIAkJCS8qIGlnbm9yZSAq LwogCQkJYnJlYWs7CiAKKwkJY2FzZSBTVkVfTUFHSUM6CisJCQlpZiAoIXN5c3RlbV9zdXBwb3J0 c19zdmUoKSkKKwkJCQlnb3RvIGludmFsaWQ7CisKKwkJCWlmICh1c2VyLT5zdmUpCisJCQkJZ290 byBpbnZhbGlkOworCisJCQlpZiAoc2l6ZSA8IHNpemVvZigqdXNlci0+c3ZlKSkKKwkJCQlnb3Rv IGludmFsaWQ7CisKKwkJCXVzZXItPnN2ZSA9IChzdHJ1Y3Qgc3ZlX2NvbnRleHQgX191c2VyICop aGVhZDsKKwkJCWJyZWFrOworCiAJCWNhc2UgRVhUUkFfTUFHSUM6CiAJCQlpZiAoaGF2ZV9leHRy YV9jb250ZXh0KQogCQkJCWdvdG8gaW52YWxpZDsKQEAgLTM1OSw5ICs0ODEsNiBAQCBzdGF0aWMg aW50IHBhcnNlX3VzZXJfc2lnZnJhbWUoc3RydWN0IHVzZXJfY3R4cyAqdXNlciwKIAl9CiAKIGRv bmU6Ci0JaWYgKCF1c2VyLT5mcHNpbWQpCi0JCWdvdG8gaW52YWxpZDsKLQogCXJldHVybiAwOwog CiBpbnZhbGlkOgpAQCAtMzk1LDggKzUxNCwxOSBAQCBzdGF0aWMgaW50IHJlc3RvcmVfc2lnZnJh bWUoc3RydWN0IHB0X3JlZ3MgKnJlZ3MsCiAJaWYgKGVyciA9PSAwKQogCQllcnIgPSBwYXJzZV91 c2VyX3NpZ2ZyYW1lKCZ1c2VyLCBzZik7CiAKLQlpZiAoZXJyID09IDApCi0JCWVyciA9IHJlc3Rv cmVfZnBzaW1kX2NvbnRleHQodXNlci5mcHNpbWQpOworCWlmIChlcnIgPT0gMCkgeworCQlpZiAo IXVzZXIuZnBzaW1kKQorCQkJcmV0dXJuIC1FSU5WQUw7CisKKwkJaWYgKHVzZXIuc3ZlKSB7CisJ CQlpZiAoIXN5c3RlbV9zdXBwb3J0c19zdmUoKSkKKwkJCQlyZXR1cm4gLUVJTlZBTDsKKworCQkJ ZXJyID0gcmVzdG9yZV9zdmVfZnBzaW1kX2NvbnRleHQoJnVzZXIpOworCQl9IGVsc2UgeworCQkJ ZXJyID0gcmVzdG9yZV9mcHNpbWRfY29udGV4dCh1c2VyLmZwc2ltZCk7CisJCX0KKwl9CiAKIAly ZXR1cm4gZXJyOwogfQpAQCAtNDU1LDYgKzU4NSwxOCBAQCBzdGF0aWMgaW50IHNldHVwX3NpZ2Zy YW1lX2xheW91dChzdHJ1Y3QgcnRfc2lnZnJhbWVfdXNlcl9sYXlvdXQgKnVzZXIpCiAJCQlyZXR1 cm4gZXJyOwogCX0KIAorCWlmIChzeXN0ZW1fc3VwcG9ydHNfc3ZlKCkpIHsKKwkJdW5zaWduZWQg aW50IHZxID0gMDsKKworCQlpZiAodGVzdF90aHJlYWRfZmxhZyhUSUZfU1ZFKSkKKwkJCXZxID0g c3ZlX3ZxX2Zyb21fdmwoY3VycmVudC0+dGhyZWFkLnN2ZV92bCk7CisKKwkJZXJyID0gc2lnZnJh bWVfYWxsb2ModXNlciwgJnVzZXItPnN2ZV9vZmZzZXQsCisJCQkJICAgICBTVkVfU0lHX0NPTlRF WFRfU0laRSh2cSkpOworCQlpZiAoZXJyKQorCQkJcmV0dXJuIGVycjsKKwl9CisKIAlyZXR1cm4g c2lnZnJhbWVfYWxsb2NfZW5kKHVzZXIpOwogfQogCkBAIC00OTYsNiArNjM4LDEzIEBAIHN0YXRp YyBpbnQgc2V0dXBfc2lnZnJhbWUoc3RydWN0IHJ0X3NpZ2ZyYW1lX3VzZXJfbGF5b3V0ICp1c2Vy LAogCQlfX3B1dF91c2VyX2Vycm9yKGN1cnJlbnQtPnRocmVhZC5mYXVsdF9jb2RlLCAmZXNyX2N0 eC0+ZXNyLCBlcnIpOwogCX0KIAorCS8qIFNjYWxhYmxlIFZlY3RvciBFeHRlbnNpb24gc3RhdGUs IGlmIHByZXNlbnQgKi8KKwlpZiAoc3lzdGVtX3N1cHBvcnRzX3N2ZSgpICYmIGVyciA9PSAwICYm IHVzZXItPnN2ZV9vZmZzZXQpIHsKKwkJc3RydWN0IHN2ZV9jb250ZXh0IF9fdXNlciAqc3ZlX2N0 eCA9CisJCQlhcHBseV91c2VyX29mZnNldCh1c2VyLCB1c2VyLT5zdmVfb2Zmc2V0KTsKKwkJZXJy IHw9IHByZXNlcnZlX3N2ZV9jb250ZXh0KHN2ZV9jdHgpOworCX0KKwogCWlmIChlcnIgPT0gMCAm JiB1c2VyLT5leHRyYV9vZmZzZXQpIHsKIAkJY2hhciBfX3VzZXIgKnNmcCA9IChjaGFyIF9fdXNl ciAqKXVzZXItPnNpZ2ZyYW1lOwogCQljaGFyIF9fdXNlciAqdXNlcnAgPQpAQCAtNTk1LDYgKzc0 NCw4IEBAIHN0YXRpYyBpbnQgc2V0dXBfcnRfZnJhbWUoaW50IHVzaWcsIHN0cnVjdCBrc2lnbmFs ICprc2lnLCBzaWdzZXRfdCAqc2V0LAogCXN0cnVjdCBydF9zaWdmcmFtZSBfX3VzZXIgKmZyYW1l OwogCWludCBlcnIgPSAwOwogCisJZnBzaW1kX3NpZ25hbF9wcmVzZXJ2ZV9jdXJyZW50X3N0YXRl KCk7CisKIAlpZiAoZ2V0X3NpZ2ZyYW1lKCZ1c2VyLCBrc2lnLCByZWdzKSkKIAkJcmV0dXJuIDE7 CiAKZGlmZiAtLWdpdCBhL2FyY2gvYXJtNjQva2VybmVsL3NpZ25hbDMyLmMgYi9hcmNoL2FybTY0 L2tlcm5lbC9zaWduYWwzMi5jCmluZGV4IGUwOWJmNWQuLjIyNzExZWUgMTAwNjQ0Ci0tLSBhL2Fy Y2gvYXJtNjQva2VybmVsL3NpZ25hbDMyLmMKKysrIGIvYXJjaC9hcm02NC9rZXJuZWwvc2lnbmFs MzIuYwpAQCAtMjM5LDcgKzIzOSw3IEBAIHN0YXRpYyBpbnQgY29tcGF0X3ByZXNlcnZlX3ZmcF9j b250ZXh0KHN0cnVjdCBjb21wYXRfdmZwX3NpZ2ZyYW1lIF9fdXNlciAqZnJhbWUpCiAJICogTm90 ZSB0aGF0IHRoaXMgYWxzbyBzYXZlcyBWMTYtMzEsIHdoaWNoIGFyZW4ndCB2aXNpYmxlCiAJICog aW4gQUFyY2gzMi4KIAkgKi8KLQlmcHNpbWRfcHJlc2VydmVfY3VycmVudF9zdGF0ZSgpOworCWZw c2ltZF9zaWduYWxfcHJlc2VydmVfY3VycmVudF9zdGF0ZSgpOwogCiAJLyogUGxhY2Ugc3RydWN0 dXJlIGhlYWRlciBvbiB0aGUgc3RhY2sgKi8KIAlfX3B1dF91c2VyX2Vycm9yKG1hZ2ljLCAmZnJh bWUtPm1hZ2ljLCBlcnIpOwotLSAKMi4xLjQKCl9fX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fCmt2bWFybSBtYWlsaW5nIGxpc3QKa3ZtYXJtQGxpc3RzLmNzLmNv bHVtYmlhLmVkdQpodHRwczovL2xpc3RzLmNzLmNvbHVtYmlhLmVkdS9tYWlsbWFuL2xpc3RpbmZv L2t2bWFybQo= From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from foss.arm.com ([217.140.101.70]:56878 "EHLO foss.arm.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1752456AbdJ0Kvp (ORCPT ); Fri, 27 Oct 2017 06:51:45 -0400 From: Dave Martin Subject: [PATCH v4 13/28] arm64/sve: Signal handling support Date: Fri, 27 Oct 2017 11:50:55 +0100 Message-ID: <1509101470-7881-14-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: <20171027105055.TQClsX8Pas-wsN1ERo8hGW7dF4xEzk5_Dj0pScBcsiQ@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 --- Changes since v3 ---------------- **Dropped** Reviewed-by: Catalin Marinas The changes are minor however: Changes requested by Catalin / Will: * ABI change: Zero SVE regs on syscall entry: Refactoring since v2 that allowed discard to be explicitly requested has been dropped, since now discard has already happened at syscall entry in the relevant scenarios. * Delete a comment that that is no longer appropriate: there can no longer be a pending discard. It still makes reasonable sense to write the FPSIMD/SVE state back to thread_struct on the common path though. --- 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 2b691d1..5063476 100644 --- a/arch/arm64/kernel/fpsimd.c +++ b/arch/arm64/kernel/fpsimd.c @@ -298,6 +298,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 /* @@ -499,9 +525,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) { @@ -509,16 +532,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' @@ -553,7 +583,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 0bdc96c..79bc55a 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 err; + + 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; +} + +#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; @@ -359,9 +481,6 @@ static int parse_user_sigframe(struct user_ctxs *user, } done: - if (!user->fpsimd) - goto invalid; - return 0; invalid: @@ -395,8 +514,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; } @@ -455,6 +585,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); } @@ -496,6 +638,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 = @@ -595,6 +744,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