From mboxrd@z Thu Jan 1 00:00:00 1970 From: Dave Martin Subject: [PATCH v3 19/28] arm64/sve: ptrace and ELF coredump support Date: Tue, 10 Oct 2017 19:38:36 +0100 Message-ID: <1507660725-7986-20-git-send-email-Dave.Martin@arm.com> References: <1507660725-7986-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: <1507660725-7986-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 , Alan Hayward , Will Deacon , Richard Sandiford , kvmarm@lists.cs.columbia.edu List-Id: linux-arch.vger.kernel.org VGhpcyBwYXRjaCBkZWZpbmVzIGFuZCBpbXBsZW1lbnRzIGEgbmV3IHJlZ3NldCBOVF9BUk1fU1ZF LCB3aGljaApkZXNjcmliZXMgYSB0aHJlYWQncyBTVkUgcmVnaXN0ZXIgc3RhdGUuICBUaGlzIGFs bG93cyBhIGRlYnVnZ2VyIHRvCm1hbmlwdWxhdGUgdGhlIFNWRSBzdGF0ZSwgYXMgd2VsbCBhcyBi ZWluZyBpbmNsdWRlZCBpbiBFTEYKY29yZWR1bXBzIGZvciBwb3N0LW1vcnRlbSBkZWJ1Z2dpbmcu CgpCZWNhdXNlIHRoZSByZWdzZXQgc2l6ZSBhbmQgbGF5b3V0IGFyZSBkZXBlbmRlbnQgb24gdGhl IHRocmVhZCdzCmN1cnJlbnQgdmVjdG9yIGxlbmd0aCwgaXQgaXMgbm90IHBvc3NpYmxlIHRvIGRl ZmluZSBhIEMgc3RydWN0IHRvCmRlc2NyaWJlIHRoZSByZWdzZXQgY29udGVudHMgYXMgaXMgZG9u ZSBmb3IgZXhpc3RpbmcgcmVnc2V0cy4KSW5zdGVhZCwgYW5kIGZvciB0aGUgc2FtZSByZWFzb25z LCBOVF9BUk1fU1ZFIGlzIGJhc2VkIG9uIHRoZQpmcmVlZm9ybSB2YXJpYWJsZS1sYXlvdXQgYXBw cm9hY2ggdXNlZCBmb3IgdGhlIFNWRSBzaWduYWwgZnJhbWUuCgpBZGRpdGlvbmFsbHksIHRvIHJl ZHVjZSBkZWJ1ZyBvdmVyaGVhZCB3aGVuIGRlYnVnZ2luZyB0aHJlYWRzIHRoYXQKbWlnaHQgb3Ig bWlnaHQgbm90IGhhdmUgbGl2ZSBTVkUgcmVnaXN0ZXIgc3RhdGUsIE5UX0FSTV9TVkUgbWF5IGJl CnByZXNlbnRlZCBpbiBvbmUgb2YgdHdvIGRpZmZlcmVudCBmb3JtYXRzOiB0aGUgb2xkIHN0cnVj dAp1c2VyX2Zwc2ltZF9zdGF0ZSBmb3JtYXQgaXMgZW1iZWRkZWQgZm9yIGRlc2NyaWJpbmcgdGhl IHN0YXRlIG9mIGEKdGhyZWFkIHdpdGggbm8gbGl2ZSBTVkUgc3RhdGUsIHdoZXJlYXMgYSBuZXcg dmFyaWFibGUtbGF5b3V0CnN0cnVjdHVyZSBpcyBlbWJlZGRlZCBmb3IgZGVzY3JpYmluZyBsaXZl IFNWRSBzdGF0ZS4gIFRoaXMgYXZvaWRzIGEKZGVidWdnZXIgbmVlZGluZyB0byBwb2xsIE5UX1BS RlBSRUcgaW4gYWRkaXRpb24gdG8gTlRfQVJNX1NWRSwgYW5kCmFsbG93cyBleGlzdGluZyB1c2Vy c3BhY2UgY29kZSB0byBoYW5kbGUgdGhlIG5vbi1TVkUgY2FzZSB3aXRob3V0CnRvbyBtdWNoIG1v ZGlmaWNhdGlvbi4KCkZvciB0aGlzIHRvIHdvcmssIE5UX0FSTV9TVkUgaXMgZGVmaW5lZCB3aXRo IGEgZml4ZWQtZm9ybWF0IGhlYWRlcgpvZiB0eXBlIHN0cnVjdCB1c2VyX3N2ZV9oZWFkZXIsIHdo aWNoIHRoZSByZWNpcGllbnQgY2FuIHVzZSB0bwpmaWd1cmUgb3V0IHRoZSBjb250ZW50LCBzaXpl IGFuZCBsYXlvdXQgb2YgdGhlIHJlc2V0IG9mIHRoZSByZWdzZXQuCkFjY2Vzc29yIG1hY3JvcyBh cmUgZGVmaW5lZCB0byBhbGxvdyB0aGUgdmVjdG9yLWxlbmd0aC1kZXBlbmRlbnQKcGFydHMgb2Yg dGhlIHJlZ3NldCB0byBiZSBtYW5pcHVsYXRlZC4KClNpZ25lZC1vZmYtYnk6IEFsYW4gSGF5d2Fy ZCA8YWxhbi5oYXl3YXJkQGFybS5jb20+ClNpZ25lZC1vZmYtYnk6IERhdmUgTWFydGluIDxEYXZl Lk1hcnRpbkBhcm0uY29tPgpDYzogQWxleCBCZW5uw6llIDxhbGV4LmJlbm5lZUBsaW5hcm8ub3Jn PgpDYzogT2thbW90byBUYWtheXVraSA8dG9rYW1vdG9AanAuZnVqaXRzdS5jb20+CgotLS0KCkRy b3BwZWQgQWxleCBCZW5uw6llJ3MgcmV2aWV3ZWQtYnksIHNpbmNlIGJ1ZyBmaXhlcyBoYXZlIGJl ZW4gYXBwbGllZC4KCkNoYW5nZXMgc2luY2UgdjIKLS0tLS0tLS0tLS0tLS0tLQoKQnVnIGZpeGVz OgoKICogSW5pdGlhbGlzZWQgdXNlcl9zdmVfaGVhZGVyLnN2ZV9tYXhfdmwgcHJvcGVybHkgaW4K ICAgc3ZlX2luaXRfaGVhZGVyX2Zyb21fdGFzaygpLiAgKFJlcG9ydGVkIGJ5IE9rYW1vdG8gVGFr YXl1a2kuKQoKICAgVGhpcyBidWcgd2FzIGludHJvZHVjZWQgYnkgdGhlIHJlZmFjdG9yaW5nIHNp bmNlIHYxIHRvIHJlbW92ZQogICBCVUdfT04oKXMuICBBIFdBUk5fT04oKSB3YXMgaW50cm9kdWNl ZCB0byBmaXggdXAgdGhlIGVycm9yIGNhc2UKICAgaGVyZSwgYnV0IHRoZSBjb2RlIGZvciB0aGUg bm9uLWVycm9yIGNhc2Ugd2FzIGxvc3QuCgogICBUaGlzIHJlc3VsdGVkIGluIHVzZXJzcGFjZSBz ZWVpbmcgbWF4X3NpemUgPT0gMCB3aGVuIHJlYWRpbmcKICAgTlRfQVJNX1NWRSB3aXRoIFBUUkFD RV9HRVRSRUdTRVQuICBOVF9BUk1fU1ZFIHdvdWxkIGFsc28gZ2V0CiAgIHRydW5jYXRlZCBpbiBj b3JlZG11cHMgKHRob3VnaCBJJ3ZlIG5vdCB0ZXN0ZWQgdGhhdCkuCgogICBUaGlzIGZpeCBlbnN1 cmVzIHRoYXQgbWF4X3NpemUgaXMgaW5pdGlhbGlzZWQsIGFuZCBvbmx5IG92ZXJyaWRlcwogICB0 aGUgdmFsdWUgd3JpdHRlbiBpZiBpdCB3b3VsZCBiZSBnYXJiYWdlLgoKICogSW4gc3ZlX3NldCgp LCB0aGUgZmxhZ3MgZm9yIHN2ZV9zZXRfdmVjdG9yX2xlbmd0aCgpIGFyZSBzaGlmdGVkCiAgIGlu dG8gdGhlIGNvcnJlY3QgcG9zaXRpb24uICBXaXRob3V0IHRoaXMsIGEgUFRSQUNFX1NFVFJFR1NF VCBmb3IKICAgTlRfQVJNX1NWRSBtYXkgcmVqZWN0IHZhbGlkIGZsYWdzIChpbmNsdWRpbmcgZmxh Z3MgcmVhZCB2aWEKICAgUFRSQUNFX0dFVFJFR1NFVCkgd2l0aCAtRUlOVkFMOiB0aHVzLCBsZWdp dGltYXRlIHVzZXMgaW5jbHVkaW5nCiAgIHNhdmUvcmVzdG9yZSBtYXkgbm90IHdvcmsuCgpNaXNj ZWxsYW5lb3VzOgoKICogQ2xhcmlmaWVkIGNvbW1lbnQgaW4gcHRyYWNlLmggYWJvdXQga2VlcGlu ZyBmbGFncyBpbiBzeW5jIHdpdGgKICAgcHJjdGwuaCBzbyB0aGF0IGl0IHdvbid0IGJlIG1pc2lu dGVycHJldGVkIGFzIGFwcGx5aW5nIHRvCiAgIFNWRV9QVF9SRUdTX3tNQVNLLCBGUFNJTUQsU1ZF fSAod2hpY2ggZGVsaWJlcmF0ZWx5IGhhdmUgbm8gcHJjdGwKICAgZXF1aXZhbGVudCkuCgogKiBB ZGRlZCBjb21tZW50cyBleHBsYWluaW5nIHRoZSBpbnRlbnQsIHB1cnBvc2UgYW5kIGJhc2ljIGNv bnN0cmFpbnRzCiAgIGZvciBmcHNpbWQuYyBoZWxwZXJzLgotLS0KIGFyY2gvYXJtNjQvaW5jbHVk ZS9hc20vZnBzaW1kLmggICAgICB8ICAxMyArLQogYXJjaC9hcm02NC9pbmNsdWRlL3VhcGkvYXNt L3B0cmFjZS5oIHwgMTM4ICsrKysrKysrKysrKysrKysrKwogYXJjaC9hcm02NC9rZXJuZWwvZnBz aW1kLmMgICAgICAgICAgIHwgIDYwICsrKysrKysrCiBhcmNoL2FybTY0L2tlcm5lbC9wdHJhY2Uu YyAgICAgICAgICAgfCAyNzEgKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrLS0KIGlu Y2x1ZGUvdWFwaS9saW51eC9lbGYuaCAgICAgICAgICAgICB8ICAgMSArCiA1IGZpbGVzIGNoYW5n ZWQsIDQ3NCBpbnNlcnRpb25zKCspLCA5IGRlbGV0aW9ucygtKQoKZGlmZiAtLWdpdCBhL2FyY2gv YXJtNjQvaW5jbHVkZS9hc20vZnBzaW1kLmggYi9hcmNoL2FybTY0L2luY2x1ZGUvYXNtL2Zwc2lt ZC5oCmluZGV4IGJhZDcyZmQuLmVlNmRiMzggMTAwNjQ0Ci0tLSBhL2FyY2gvYXJtNjQvaW5jbHVk ZS9hc20vZnBzaW1kLmgKKysrIGIvYXJjaC9hcm02NC9pbmNsdWRlL2FzbS9mcHNpbWQuaApAQCAt MzgsMTMgKzM4LDE2IEBAIHN0cnVjdCBmcHNpbWRfc3RhdGUgewogCQkJX191aW50MTI4X3QgdnJl Z3NbMzJdOwogCQkJdTMyIGZwc3I7CiAJCQl1MzIgZnBjcjsKKwkJCS8qCisJCQkgKiBGb3IgcHRy YWNlIGNvbXBhdGliaWxpdHksIHBhZCB0byBuZXh0IDEyOC1iaXQKKwkJCSAqIGJvdW5kYXJ5IGhl cmUgaWYgZXh0ZW5kaW5nIHRoaXMgc3RydWN0LgorCQkJICovCiAJCX07CiAJfTsKIAkvKiB0aGUg aWQgb2YgdGhlIGxhc3QgY3B1IHRvIGhhdmUgcmVzdG9yZWQgdGhpcyBzdGF0ZSAqLwogCXVuc2ln bmVkIGludCBjcHU7CiB9OwogCi0KICNpZiBkZWZpbmVkKF9fS0VSTkVMX18pICYmIGRlZmluZWQo Q09ORklHX0NPTVBBVCkKIC8qIE1hc2tzIGZvciBleHRyYWN0aW5nIHRoZSBGUFNSIGFuZCBGUENS IGZyb20gdGhlIEZQU0NSICovCiAjZGVmaW5lIFZGUF9GUFNDUl9TVEFUX01BU0sJMHhmODAwMDA5 ZgpAQCAtODksNiArOTIsMTAgQEAgZXh0ZXJuIHNpemVfdCBzdmVfc3RhdGVfc2l6ZShzdHJ1Y3Qg dGFza19zdHJ1Y3QgY29uc3QgKnRhc2spOwogCiBleHRlcm4gdm9pZCBzdmVfYWxsb2Moc3RydWN0 IHRhc2tfc3RydWN0ICp0YXNrKTsKIGV4dGVybiB2b2lkIGZwc2ltZF9yZWxlYXNlX3RocmVhZChz dHJ1Y3QgdGFza19zdHJ1Y3QgKnRhc2spOworZXh0ZXJuIHZvaWQgZnBzaW1kX3N5bmNfdG9fc3Zl KHN0cnVjdCB0YXNrX3N0cnVjdCAqdGFzayk7CitleHRlcm4gdm9pZCBzdmVfc3luY190b19mcHNp bWQoc3RydWN0IHRhc2tfc3RydWN0ICp0YXNrKTsKK2V4dGVybiB2b2lkIHN2ZV9zeW5jX2Zyb21f ZnBzaW1kX3plcm9wYWQoc3RydWN0IHRhc2tfc3RydWN0ICp0YXNrKTsKKwogZXh0ZXJuIGludCBz dmVfc2V0X3ZlY3Rvcl9sZW5ndGgoc3RydWN0IHRhc2tfc3RydWN0ICp0YXNrLAogCQkJCSB1bnNp Z25lZCBsb25nIHZsLCB1bnNpZ25lZCBsb25nIGZsYWdzKTsKIApAQCAtMTA1LDYgKzExMiwxMCBA QCBleHRlcm4gdm9pZCBfX2luaXQgc3ZlX3NldHVwKHZvaWQpOwogCiBzdGF0aWMgdm9pZCBfX21h eWJlX3VudXNlZCBzdmVfYWxsb2Moc3RydWN0IHRhc2tfc3RydWN0ICp0YXNrKSB7IH0KIHN0YXRp YyB2b2lkIF9fbWF5YmVfdW51c2VkIGZwc2ltZF9yZWxlYXNlX3RocmVhZChzdHJ1Y3QgdGFza19z dHJ1Y3QgKnRhc2spIHsgfQorc3RhdGljIHZvaWQgX19tYXliZV91bnVzZWQgc3ZlX3N5bmNfdG9f ZnBzaW1kKHN0cnVjdCB0YXNrX3N0cnVjdCAqdGFzaykgeyB9CitzdGF0aWMgdm9pZCBfX21heWJl X3VudXNlZCBzdmVfc3luY19mcm9tX2Zwc2ltZF96ZXJvcGFkKAorCXN0cnVjdCB0YXNrX3N0cnVj dCAqdGFzaykgeyB9CisKIHN0YXRpYyB2b2lkIF9fbWF5YmVfdW51c2VkIHN2ZV9pbml0X3ZxX21h cCh2b2lkKSB7IH0KIHN0YXRpYyB2b2lkIF9fbWF5YmVfdW51c2VkIHN2ZV91cGRhdGVfdnFfbWFw KHZvaWQpIHsgfQogc3RhdGljIGludCBfX21heWJlX3VudXNlZCBzdmVfdmVyaWZ5X3ZxX21hcCh2 b2lkKSB7IHJldHVybiAwOyB9CmRpZmYgLS1naXQgYS9hcmNoL2FybTY0L2luY2x1ZGUvdWFwaS9h c20vcHRyYWNlLmggYi9hcmNoL2FybTY0L2luY2x1ZGUvdWFwaS9hc20vcHRyYWNlLmgKaW5kZXgg ZDFmZjgzZC4uYTBmYzZhOCAxMDA2NDQKLS0tIGEvYXJjaC9hcm02NC9pbmNsdWRlL3VhcGkvYXNt L3B0cmFjZS5oCisrKyBiL2FyY2gvYXJtNjQvaW5jbHVkZS91YXBpL2FzbS9wdHJhY2UuaApAQCAt MjIsNiArMjIsNyBAQAogI2luY2x1ZGUgPGxpbnV4L3R5cGVzLmg+CiAKICNpbmNsdWRlIDxhc20v aHdjYXAuaD4KKyNpbmNsdWRlIDxhc20vc2lnY29udGV4dC5oPgogCiAKIC8qCkBAIC02Myw2ICs2 NCw4IEBACiAKICNpZm5kZWYgX19BU1NFTUJMWV9fCiAKKyNpbmNsdWRlIDxsaW51eC9wcmN0bC5o PgorCiAvKgogICogVXNlciBzdHJ1Y3R1cmVzIGZvciBnZW5lcmFsIHB1cnBvc2UsIGZsb2F0aW5n IHBvaW50IGFuZCBkZWJ1ZyByZWdpc3RlcnMuCiAgKi8KQEAgLTkwLDYgKzkzLDE0MSBAQCBzdHJ1 Y3QgdXNlcl9od2RlYnVnX3N0YXRlIHsKIAl9CQlkYmdfcmVnc1sxNl07CiB9OwogCisvKiBTVkUv RlAvU0lNRCBzdGF0ZSAoTlRfQVJNX1NWRSkgKi8KKworc3RydWN0IHVzZXJfc3ZlX2hlYWRlciB7 CisJX191MzIgc2l6ZTsgLyogdG90YWwgbWVhbmluZ2Z1bCByZWdzZXQgY29udGVudCBpbiBieXRl cyAqLworCV9fdTMyIG1heF9zaXplOyAvKiBtYXhtaXVtIHBvc3NpYmxlIHNpemUgZm9yIHRoaXMg dGhyZWFkICovCisJX191MTYgdmw7IC8qIGN1cnJlbnQgdmVjdG9yIGxlbmd0aCAqLworCV9fdTE2 IG1heF92bDsgLyogbWF4aW11bSBwb3NzaWJsZSB2ZWN0b3IgbGVuZ3RoICovCisJX191MTYgZmxh Z3M7CisJX191MTYgX19yZXNlcnZlZDsKK307CisKKy8qIERlZmluaXRpb25zIGZvciB1c2VyX3N2 ZV9oZWFkZXIuZmxhZ3M6ICovCisjZGVmaW5lIFNWRV9QVF9SRUdTX01BU0sJCSgxIDw8IDApCisK KyNkZWZpbmUgU1ZFX1BUX1JFR1NfRlBTSU1ECQkwCisjZGVmaW5lIFNWRV9QVF9SRUdTX1NWRQkJ CVNWRV9QVF9SRUdTX01BU0sKKworLyoKKyAqIENvbW1vbiBTVkVfUFRfKiBmbGFnczoKKyAqIFRo ZXNlIG11c3QgYmUga2VwdCBpbiBzeW5jIHdpdGggcHJjdGwgaW50ZXJmYWNlIGluIDxsaW51eC9w dHJhY2UuaD4KKyAqLworI2RlZmluZSBTVkVfUFRfVkxfSU5IRVJJVAkJKFBSX1NWRV9WTF9JTkhF UklUID4+IDE2KQorI2RlZmluZSBTVkVfUFRfVkxfT05FWEVDCQkoUFJfU1ZFX1NFVF9WTF9PTkVY RUMgPj4gMTYpCisKKworLyoKKyAqIFRoZSByZW1haW5kZXIgb2YgdGhlIFNWRSBzdGF0ZSBmb2xs b3dzIHN0cnVjdCB1c2VyX3N2ZV9oZWFkZXIuICBUaGUKKyAqIHRvdGFsIHNpemUgb2YgdGhlIFNW RSBzdGF0ZSAoaW5jbHVkaW5nIGhlYWRlcikgZGVwZW5kcyBvbiB0aGUKKyAqIG1ldGFkYXRhIGlu IHRoZSBoZWFkZXI6ICBTVkVfUFRfU0laRSh2cSwgZmxhZ3MpIGdpdmVzIHRoZSB0b3RhbCBzaXpl CisgKiBvZiB0aGUgc3RhdGUgaW4gYnl0ZXMsIGluY2x1ZGluZyB0aGUgaGVhZGVyLgorICoKKyAq IFJlZmVyIHRvIDxhc20vc2lnY29udGV4dC5oPiBmb3IgZGV0YWlscyBvZiBob3cgdG8gcGFzcyB0 aGUgY29ycmVjdAorICogInZxIiBhcmd1bWVudCB0byB0aGVzZSBtYWNyb3MuCisgKi8KKworLyog T2Zmc2V0IGZyb20gdGhlIHN0YXJ0IG9mIHN0cnVjdCB1c2VyX3N2ZV9oZWFkZXIgdG8gdGhlIHJl Z2lzdGVyIGRhdGEgKi8KKyNkZWZpbmUgU1ZFX1BUX1JFR1NfT0ZGU0VUCQkJCQlcCisJKChzaXpl b2Yoc3RydWN0IHN2ZV9jb250ZXh0KSArIChTVkVfVlFfQllURVMgLSAxKSkJXAorCQkvIFNWRV9W UV9CWVRFUyAqIFNWRV9WUV9CWVRFUykKKworLyoKKyAqIFRoZSByZWdpc3RlciBkYXRhIGNvbnRl bnQgYW5kIGxheW91dCBkZXBlbmRzIG9uIHRoZSB2YWx1ZSBvZiB0aGUKKyAqIGZsYWdzIGZpZWxk LgorICovCisKKy8qCisgKiAoZmxhZ3MgJiBTVkVfUFRfUkVHU19NQVNLKSA9PSBTVkVfUFRfUkVH U19GUFNJTUQgY2FzZToKKyAqCisgKiBUaGUgcGF5bG9hZCBzdGFydHMgYXQgb2Zmc2V0IFNWRV9Q VF9GUFNJTURfT0ZGU0VULCBhbmQgaXMgb2YgdHlwZQorICogc3RydWN0IHVzZXJfZnBzaW1kX3N0 YXRlLiAgQWRkaXRpb25hbCBkYXRhIG1pZ2h0IGJlIGFwcGVuZGVkIGluIHRoZQorICogZnV0dXJl OiB1c2UgU1ZFX1BUX0ZQU0lNRF9TSVpFKHZxLCBmbGFncykgdG8gY29tcHV0ZSB0aGUgdG90YWwg c2l6ZS4KKyAqIFNWRV9QVF9GUFNJTURfU0laRSh2cSwgZmxhZ3MpIHdpbGwgbmV2ZXIgYmUgbGVz cyB0aGFuCisgKiBzaXplb2Yoc3RydWN0IHVzZXJfZnBzaW1kX3N0YXRlKS4KKyAqLworCisjZGVm aW5lIFNWRV9QVF9GUFNJTURfT0ZGU0VUCQlTVkVfUFRfUkVHU19PRkZTRVQKKworI2RlZmluZSBT VkVfUFRfRlBTSU1EX1NJWkUodnEsIGZsYWdzKQkoc2l6ZW9mKHN0cnVjdCB1c2VyX2Zwc2ltZF9z dGF0ZSkpCisKKy8qCisgKiAoZmxhZ3MgJiBTVkVfUFRfUkVHU19NQVNLKSA9PSBTVkVfUFRfUkVH U19TVkUgY2FzZToKKyAqCisgKiBUaGUgcGF5bG9hZCBzdGFydHMgYXQgb2Zmc2V0IFNWRV9QVF9T VkVfT0ZGU0VULCBhbmQgaXMgb2Ygc2l6ZQorICogU1ZFX1BUX1NWRV9TSVpFKHZxLCBmbGFncyku CisgKgorICogQWRkaXRpb25hbCBtYWNyb3MgZGVzY3JpYmUgdGhlIGNvbnRlbnRzIGFuZCBsYXlv dXQgb2YgdGhlIHBheWxvYWQuCisgKiBGb3IgZWFjaCwgU1ZFX1BUX1NWRV94X09GRlNFVChhcmdz KSBpcyB0aGUgc3RhcnQgb2Zmc2V0IHJlbGF0aXZlIHRvCisgKiB0aGUgc3RhcnQgb2Ygc3RydWN0 IHVzZXJfc3ZlX2hlYWRlciwgYW5kIFNWRV9QVF9TVkVfeF9TSVpFKGFyZ3MpIGlzCisgKiB0aGUg c2l6ZSBpbiBieXRlczoKKyAqCisgKgl4CXR5cGUJCQkJZGVzY3JpcHRpb24KKyAqCS0JLS0tLQkJ CQktLS0tLS0tLS0tLQorICoJWlJFR1MJCVwKKyAqCVpSRUcJCXwKKyAqCVBSRUdTCQl8IHJlZmVy IHRvIDxhc20vc2lnY29udGV4dC5oPgorICoJUFJFRwkJfAorICoJRkZSCQkvCisgKgorICoJRlBT Ugl1aW50MzJfdAkJCUZQU1IKKyAqCUZQQ1IJdWludDMyX3QJCQlGUENSCisgKgorICogQWRkaXRp b25hbCBkYXRhIG1pZ2h0IGJlIGFwcGVuZGVkIGluIHRoZSBmdXR1cmUuCisgKi8KKworI2RlZmlu ZSBTVkVfUFRfU1ZFX1pSRUdfU0laRSh2cSkJU1ZFX1NJR19aUkVHX1NJWkUodnEpCisjZGVmaW5l IFNWRV9QVF9TVkVfUFJFR19TSVpFKHZxKQlTVkVfU0lHX1BSRUdfU0laRSh2cSkKKyNkZWZpbmUg U1ZFX1BUX1NWRV9GRlJfU0laRSh2cSkJCVNWRV9TSUdfRkZSX1NJWkUodnEpCisjZGVmaW5lIFNW RV9QVF9TVkVfRlBTUl9TSVpFCQlzaXplb2YoX191MzIpCisjZGVmaW5lIFNWRV9QVF9TVkVfRlBD Ul9TSVpFCQlzaXplb2YoX191MzIpCisKKyNkZWZpbmUgX19TVkVfU0lHX1RPX1BUKG9mZnNldCkg XAorCSgob2Zmc2V0KSAtIFNWRV9TSUdfUkVHU19PRkZTRVQgKyBTVkVfUFRfUkVHU19PRkZTRVQp CisKKyNkZWZpbmUgU1ZFX1BUX1NWRV9PRkZTRVQJCVNWRV9QVF9SRUdTX09GRlNFVAorCisjZGVm aW5lIFNWRV9QVF9TVkVfWlJFR1NfT0ZGU0VUIFwKKwlfX1NWRV9TSUdfVE9fUFQoU1ZFX1NJR19a UkVHU19PRkZTRVQpCisjZGVmaW5lIFNWRV9QVF9TVkVfWlJFR19PRkZTRVQodnEsIG4pIFwKKwlf X1NWRV9TSUdfVE9fUFQoU1ZFX1NJR19aUkVHX09GRlNFVCh2cSwgbikpCisjZGVmaW5lIFNWRV9Q VF9TVkVfWlJFR1NfU0laRSh2cSkgXAorCShTVkVfUFRfU1ZFX1pSRUdfT0ZGU0VUKHZxLCBTVkVf TlVNX1pSRUdTKSAtIFNWRV9QVF9TVkVfWlJFR1NfT0ZGU0VUKQorCisjZGVmaW5lIFNWRV9QVF9T VkVfUFJFR1NfT0ZGU0VUKHZxKSBcCisJX19TVkVfU0lHX1RPX1BUKFNWRV9TSUdfUFJFR1NfT0ZG U0VUKHZxKSkKKyNkZWZpbmUgU1ZFX1BUX1NWRV9QUkVHX09GRlNFVCh2cSwgbikgXAorCV9fU1ZF X1NJR19UT19QVChTVkVfU0lHX1BSRUdfT0ZGU0VUKHZxLCBuKSkKKyNkZWZpbmUgU1ZFX1BUX1NW RV9QUkVHU19TSVpFKHZxKSBcCisJKFNWRV9QVF9TVkVfUFJFR19PRkZTRVQodnEsIFNWRV9OVU1f UFJFR1MpIC0gXAorCQlTVkVfUFRfU1ZFX1BSRUdTX09GRlNFVCh2cSkpCisKKyNkZWZpbmUgU1ZF X1BUX1NWRV9GRlJfT0ZGU0VUKHZxKSBcCisJX19TVkVfU0lHX1RPX1BUKFNWRV9TSUdfRkZSX09G RlNFVCh2cSkpCisKKyNkZWZpbmUgU1ZFX1BUX1NWRV9GUFNSX09GRlNFVCh2cSkJCQkJXAorCSgo U1ZFX1BUX1NWRV9GRlJfT0ZGU0VUKHZxKSArIFNWRV9QVF9TVkVfRkZSX1NJWkUodnEpICsJXAor CQkJKFNWRV9WUV9CWVRFUyAtIDEpKQkJCVwKKwkJLyBTVkVfVlFfQllURVMgKiBTVkVfVlFfQllU RVMpCisjZGVmaW5lIFNWRV9QVF9TVkVfRlBDUl9PRkZTRVQodnEpIFwKKwkoU1ZFX1BUX1NWRV9G UFNSX09GRlNFVCh2cSkgKyBTVkVfUFRfU1ZFX0ZQU1JfU0laRSkKKworLyoKKyAqIEFueSBmdXR1 cmUgZXh0ZW5zaW9uIGFwcGVuZGVkIGFmdGVyIEZQQ1IgbXVzdCBiZSBhbGlnbmVkIHRvIHRoZSBu ZXh0CisgKiAxMjgtYml0IGJvdW5kYXJ5LgorICovCisKKyNkZWZpbmUgU1ZFX1BUX1NWRV9TSVpF KHZxLCBmbGFncykJCQkJCVwKKwkoKFNWRV9QVF9TVkVfRlBDUl9PRkZTRVQodnEpICsgU1ZFX1BU X1NWRV9GUENSX1NJWkUJCVwKKwkJCS0gU1ZFX1BUX1NWRV9PRkZTRVQgKyAoU1ZFX1ZRX0JZVEVT IC0gMSkpCVwKKwkJLyBTVkVfVlFfQllURVMgKiBTVkVfVlFfQllURVMpCisKKyNkZWZpbmUgU1ZF X1BUX1NJWkUodnEsIGZsYWdzKQkJCQkJCVwKKwkgKCgoZmxhZ3MpICYgU1ZFX1BUX1JFR1NfTUFT SykgPT0gU1ZFX1BUX1JFR1NfU1ZFID8JCVwKKwkJICBTVkVfUFRfU1ZFX09GRlNFVCArIFNWRV9Q VF9TVkVfU0laRSh2cSwgZmxhZ3MpCVwKKwkJOiBTVkVfUFRfRlBTSU1EX09GRlNFVCArIFNWRV9Q VF9GUFNJTURfU0laRSh2cSwgZmxhZ3MpKQorCiAjZW5kaWYgLyogX19BU1NFTUJMWV9fICovCiAK ICNlbmRpZiAvKiBfVUFQSV9fQVNNX1BUUkFDRV9IICovCmRpZmYgLS1naXQgYS9hcmNoL2FybTY0 L2tlcm5lbC9mcHNpbWQuYyBiL2FyY2gvYXJtNjQva2VybmVsL2Zwc2ltZC5jCmluZGV4IGMxOTQ2 MjcuLjZkYjlmMzAgMTAwNjQ0Ci0tLSBhL2FyY2gvYXJtNjQva2VybmVsL2Zwc2ltZC5jCisrKyBi L2FyY2gvYXJtNjQva2VybmVsL2Zwc2ltZC5jCkBAIC00MzgsNiArNDM4LDY2IEBAIHZvaWQgc3Zl X2FsbG9jKHN0cnVjdCB0YXNrX3N0cnVjdCAqdGFzaykKIAlCVUdfT04oIXRhc2stPnRocmVhZC5z dmVfc3RhdGUpOwogfQogCisKKy8qCisgKiBFbnN1cmUgdGhhdCB0YXNrLT50aHJlYWQuc3ZlX3N0 YXRlIGlzIHVwIHRvIGRhdGUgd2l0aCByZXNwZWN0IHRvCisgKiB0aGUgdXNlciB0YXNrLCBpcnJl c3BlY3RpdmUgb2Ygd2hlbiBTVkUgaXMgaW4gdXNlIG9yIG5vdC4KKyAqCisgKiBUaGlzIHNob3Vs ZCBvbmx5IGJlIGNhbGxlZCBieSBwdHJhY2UuICB0YXNrIG11c3QgYmUgbm9uLXJ1bm5hYmxlLgor ICogdGFzay0+dGhyZWFkLnN2ZV9zdGF0ZSBtdXN0IHBvaW50IHRvIGF0IGxlYXN0IHN2ZV9zdGF0 ZV9zaXplKHRhc2spCisgKiBieXRlcyBvZiBhbGxvY2F0ZWQga2VybmVsIG1lbW9yeS4KKyAqLwor dm9pZCBmcHNpbWRfc3luY190b19zdmUoc3RydWN0IHRhc2tfc3RydWN0ICp0YXNrKQoreworCWlm ICghdGVzdF90c2tfdGhyZWFkX2ZsYWcodGFzaywgVElGX1NWRSkpCisJCWZwc2ltZF90b19zdmUo dGFzayk7Cit9CisKKy8qCisgKiBFbnN1cmUgdGhhdCB0YXNrLT50aHJlYWQuZnBzaW1kX3N0YXRl IGlzIHVwIHRvIGRhdGUgd2l0aCByZXNwZWN0IHRvCisgKiB0aGUgdXNlciB0YXNrLCBpcnJlc3Bl Y3RpdmUgb2Ygd2hldGhlciBTVkUgaXMgaW4gdXNlIG9yIG5vdC4KKyAqCisgKiBUaGlzIHNob3Vs ZCBvbmx5IGJlIGNhbGxlZCBieSBwdHJhY2UuICB0YXNrIG11c3QgYmUgbm9uLXJ1bm5hYmxlLgor ICogdGFzay0+dGhyZWFkLnN2ZV9zdGF0ZSBtdXN0IHBvaW50IHRvIGF0IGxlYXN0IHN2ZV9zdGF0 ZV9zaXplKHRhc2spCisgKiBieXRlcyBvZiBhbGxvY2F0ZWQga2VybmVsIG1lbW9yeS4KKyAqLwor dm9pZCBzdmVfc3luY190b19mcHNpbWQoc3RydWN0IHRhc2tfc3RydWN0ICp0YXNrKQoreworCWlm ICh0ZXN0X3Rza190aHJlYWRfZmxhZyh0YXNrLCBUSUZfU1ZFKSkKKwkJc3ZlX3RvX2Zwc2ltZCh0 YXNrKTsKK30KKworLyoKKyAqIEVuc3VyZSB0aGF0IHRhc2stPnRocmVhZC5zdmVfc3RhdGUgaXMg dXAgdG8gZGF0ZSB3aXRoIHJlc3BlY3QgdG8KKyAqIHRoZSB0YXNrLT50aHJlYWQuZnBzaW1kX3N0 YXRlLgorICoKKyAqIFRoaXMgc2hvdWxkIG9ubHkgYmUgY2FsbGVkIGJ5IHB0cmFjZSB0byBtZXJn ZSBuZXcgRlBTSU1EIHJlZ2lzdGVyCisgKiB2YWx1ZXMgaW50byBhIHRhc2sgZm9yIHdoaWNoIFNW RSBpcyBjdXJyZW50bHkgYWN0aXZlLgorICogdGFzayBtdXN0IGJlIG5vbi1ydW5uYWJsZS4KKyAq IHRhc2stPnRocmVhZC5zdmVfc3RhdGUgbXVzdCBwb2ludCB0byBhdCBsZWFzdCBzdmVfc3RhdGVf c2l6ZSh0YXNrKQorICogYnl0ZXMgb2YgYWxsb2NhdGVkIGtlcm5lbCBtZW1vcnkuCisgKiB0YXNr LT50aHJlYWQuZnBzaW1kX3N0YXRlIG11c3QgYWxyZWFkeSBoYXZlIGJlZW4gaW5pdGlhbGlzZWQg d2l0aAorICogdGhlIG5ldyBGUFNJTUQgcmVnaXN0ZXIgdmFsdWVzIHRvIGJlIG1lcmdlZCBpbi4K KyAqLwordm9pZCBzdmVfc3luY19mcm9tX2Zwc2ltZF96ZXJvcGFkKHN0cnVjdCB0YXNrX3N0cnVj dCAqdGFzaykKK3sKKwl1bnNpZ25lZCBpbnQgdnE7CisJdm9pZCAqc3N0ID0gdGFzay0+dGhyZWFk LnN2ZV9zdGF0ZTsKKwlzdHJ1Y3QgZnBzaW1kX3N0YXRlIGNvbnN0ICpmc3QgPSAmdGFzay0+dGhy ZWFkLmZwc2ltZF9zdGF0ZTsKKwl1bnNpZ25lZCBpbnQgaTsKKworCWlmICghdGVzdF90c2tfdGhy ZWFkX2ZsYWcodGFzaywgVElGX1NWRSkpCisJCXJldHVybjsKKworCXZxID0gc3ZlX3ZxX2Zyb21f dmwodGFzay0+dGhyZWFkLnN2ZV92bCk7CisKKwltZW1zZXQoc3N0LCAwLCBTVkVfU0lHX1JFR1Nf U0laRSh2cSkpOworCisJZm9yIChpID0gMDsgaSA8IDMyOyArK2kpCisJCW1lbWNweShaUkVHKHNz dCwgdnEsIGkpLCAmZnN0LT52cmVnc1tpXSwKKwkJICAgICAgIHNpemVvZihmc3QtPnZyZWdzW2ld KSk7Cit9CisKIGludCBzdmVfc2V0X3ZlY3Rvcl9sZW5ndGgoc3RydWN0IHRhc2tfc3RydWN0ICp0 YXNrLAogCQkJICB1bnNpZ25lZCBsb25nIHZsLCB1bnNpZ25lZCBsb25nIGZsYWdzKQogewpkaWZm IC0tZ2l0IGEvYXJjaC9hcm02NC9rZXJuZWwvcHRyYWNlLmMgYi9hcmNoL2FybTY0L2tlcm5lbC9w dHJhY2UuYwppbmRleCA5Y2JiNjEyLi43MjUyMjA5IDEwMDY0NAotLS0gYS9hcmNoL2FybTY0L2tl cm5lbC9wdHJhY2UuYworKysgYi9hcmNoL2FybTY0L2tlcm5lbC9wdHJhY2UuYwpAQCAtMzIsNiAr MzIsNyBAQAogI2luY2x1ZGUgPGxpbnV4L3NlY3VyaXR5Lmg+CiAjaW5jbHVkZSA8bGludXgvaW5p dC5oPgogI2luY2x1ZGUgPGxpbnV4L3NpZ25hbC5oPgorI2luY2x1ZGUgPGxpbnV4L3N0cmluZy5o PgogI2luY2x1ZGUgPGxpbnV4L3VhY2Nlc3MuaD4KICNpbmNsdWRlIDxsaW51eC9wZXJmX2V2ZW50 Lmg+CiAjaW5jbHVkZSA8bGludXgvaHdfYnJlYWtwb2ludC5oPgpAQCAtNDAsNiArNDEsNyBAQAog I2luY2x1ZGUgPGxpbnV4L2VsZi5oPgogCiAjaW5jbHVkZSA8YXNtL2NvbXBhdC5oPgorI2luY2x1 ZGUgPGFzbS9jcHVmZWF0dXJlLmg+CiAjaW5jbHVkZSA8YXNtL2RlYnVnLW1vbml0b3JzLmg+CiAj aW5jbHVkZSA8YXNtL3BndGFibGUuaD4KICNpbmNsdWRlIDxhc20vc3RhY2t0cmFjZS5oPgpAQCAt NjE4LDMzICs2MjAsNjYgQEAgc3RhdGljIGludCBncHJfc2V0KHN0cnVjdCB0YXNrX3N0cnVjdCAq dGFyZ2V0LCBjb25zdCBzdHJ1Y3QgdXNlcl9yZWdzZXQgKnJlZ3NldCwKIC8qCiAgKiBUT0RPOiB1 cGRhdGUgZnAgYWNjZXNzb3JzIGZvciBsYXp5IGNvbnRleHQgc3dpdGNoaW5nIChzeW5jL2ZsdXNo IGh3c3RhdGUpCiAgKi8KLXN0YXRpYyBpbnQgZnByX2dldChzdHJ1Y3QgdGFza19zdHJ1Y3QgKnRh cmdldCwgY29uc3Qgc3RydWN0IHVzZXJfcmVnc2V0ICpyZWdzZXQsCi0JCSAgIHVuc2lnbmVkIGlu dCBwb3MsIHVuc2lnbmVkIGludCBjb3VudCwKLQkJICAgdm9pZCAqa2J1Ziwgdm9pZCBfX3VzZXIg KnVidWYpCitzdGF0aWMgaW50IF9fZnByX2dldChzdHJ1Y3QgdGFza19zdHJ1Y3QgKnRhcmdldCwK KwkJICAgICBjb25zdCBzdHJ1Y3QgdXNlcl9yZWdzZXQgKnJlZ3NldCwKKwkJICAgICB1bnNpZ25l ZCBpbnQgcG9zLCB1bnNpZ25lZCBpbnQgY291bnQsCisJCSAgICAgdm9pZCAqa2J1Ziwgdm9pZCBf X3VzZXIgKnVidWYsIHVuc2lnbmVkIGludCBzdGFydF9wb3MpCiB7CiAJc3RydWN0IHVzZXJfZnBz aW1kX3N0YXRlICp1cmVnczsKKworCXN2ZV9zeW5jX3RvX2Zwc2ltZCh0YXJnZXQpOworCiAJdXJl Z3MgPSAmdGFyZ2V0LT50aHJlYWQuZnBzaW1kX3N0YXRlLnVzZXJfZnBzaW1kOwogCisJcmV0dXJu IHVzZXJfcmVnc2V0X2NvcHlvdXQoJnBvcywgJmNvdW50LCAma2J1ZiwgJnVidWYsIHVyZWdzLAor CQkJCSAgIHN0YXJ0X3Bvcywgc3RhcnRfcG9zICsgc2l6ZW9mKCp1cmVncykpOworfQorCitzdGF0 aWMgaW50IGZwcl9nZXQoc3RydWN0IHRhc2tfc3RydWN0ICp0YXJnZXQsIGNvbnN0IHN0cnVjdCB1 c2VyX3JlZ3NldCAqcmVnc2V0LAorCQkgICB1bnNpZ25lZCBpbnQgcG9zLCB1bnNpZ25lZCBpbnQg Y291bnQsCisJCSAgIHZvaWQgKmtidWYsIHZvaWQgX191c2VyICp1YnVmKQorewogCWlmICh0YXJn ZXQgPT0gY3VycmVudCkKIAkJZnBzaW1kX3ByZXNlcnZlX2N1cnJlbnRfc3RhdGUoKTsKIAotCXJl dHVybiB1c2VyX3JlZ3NldF9jb3B5b3V0KCZwb3MsICZjb3VudCwgJmtidWYsICZ1YnVmLCB1cmVn cywgMCwgLTEpOworCXJldHVybiBfX2Zwcl9nZXQodGFyZ2V0LCByZWdzZXQsIHBvcywgY291bnQs IGtidWYsIHVidWYsIDApOwogfQogCi1zdGF0aWMgaW50IGZwcl9zZXQoc3RydWN0IHRhc2tfc3Ry dWN0ICp0YXJnZXQsIGNvbnN0IHN0cnVjdCB1c2VyX3JlZ3NldCAqcmVnc2V0LAotCQkgICB1bnNp Z25lZCBpbnQgcG9zLCB1bnNpZ25lZCBpbnQgY291bnQsCi0JCSAgIGNvbnN0IHZvaWQgKmtidWYs IGNvbnN0IHZvaWQgX191c2VyICp1YnVmKQorc3RhdGljIGludCBfX2Zwcl9zZXQoc3RydWN0IHRh c2tfc3RydWN0ICp0YXJnZXQsCisJCSAgICAgY29uc3Qgc3RydWN0IHVzZXJfcmVnc2V0ICpyZWdz ZXQsCisJCSAgICAgdW5zaWduZWQgaW50IHBvcywgdW5zaWduZWQgaW50IGNvdW50LAorCQkgICAg IGNvbnN0IHZvaWQgKmtidWYsIGNvbnN0IHZvaWQgX191c2VyICp1YnVmLAorCQkgICAgIHVuc2ln bmVkIGludCBzdGFydF9wb3MpCiB7CiAJaW50IHJldDsKIAlzdHJ1Y3QgdXNlcl9mcHNpbWRfc3Rh dGUgbmV3c3RhdGUgPQogCQl0YXJnZXQtPnRocmVhZC5mcHNpbWRfc3RhdGUudXNlcl9mcHNpbWQ7 CiAKLQlyZXQgPSB1c2VyX3JlZ3NldF9jb3B5aW4oJnBvcywgJmNvdW50LCAma2J1ZiwgJnVidWYs ICZuZXdzdGF0ZSwgMCwgLTEpOworCXN2ZV9zeW5jX3RvX2Zwc2ltZCh0YXJnZXQpOworCisJcmV0 ID0gdXNlcl9yZWdzZXRfY29weWluKCZwb3MsICZjb3VudCwgJmtidWYsICZ1YnVmLCAmbmV3c3Rh dGUsCisJCQkJIHN0YXJ0X3Bvcywgc3RhcnRfcG9zICsgc2l6ZW9mKG5ld3N0YXRlKSk7CiAJaWYg KHJldCkKIAkJcmV0dXJuIHJldDsKIAogCXRhcmdldC0+dGhyZWFkLmZwc2ltZF9zdGF0ZS51c2Vy X2Zwc2ltZCA9IG5ld3N0YXRlOworCisJcmV0dXJuIHJldDsKK30KKworc3RhdGljIGludCBmcHJf c2V0KHN0cnVjdCB0YXNrX3N0cnVjdCAqdGFyZ2V0LCBjb25zdCBzdHJ1Y3QgdXNlcl9yZWdzZXQg KnJlZ3NldCwKKwkJICAgdW5zaWduZWQgaW50IHBvcywgdW5zaWduZWQgaW50IGNvdW50LAorCQkg ICBjb25zdCB2b2lkICprYnVmLCBjb25zdCB2b2lkIF9fdXNlciAqdWJ1ZikKK3sKKwlpbnQgcmV0 OworCisJcmV0ID0gX19mcHJfc2V0KHRhcmdldCwgcmVnc2V0LCBwb3MsIGNvdW50LCBrYnVmLCB1 YnVmLCAwKTsKKwlpZiAocmV0KQorCQlyZXR1cm4gcmV0OworCisJc3ZlX3N5bmNfZnJvbV9mcHNp bWRfemVyb3BhZCh0YXJnZXQpOwogCWZwc2ltZF9mbHVzaF90YXNrX3N0YXRlKHRhcmdldCk7CisK IAlyZXR1cm4gcmV0OwogfQogCkBAIC03MDIsNiArNzM3LDIxMSBAQCBzdGF0aWMgaW50IHN5c3Rl bV9jYWxsX3NldChzdHJ1Y3QgdGFza19zdHJ1Y3QgKnRhcmdldCwKIAlyZXR1cm4gcmV0OwogfQog CisjaWZkZWYgQ09ORklHX0FSTTY0X1NWRQorCitzdGF0aWMgdm9pZCBzdmVfaW5pdF9oZWFkZXJf ZnJvbV90YXNrKHN0cnVjdCB1c2VyX3N2ZV9oZWFkZXIgKmhlYWRlciwKKwkJCQkgICAgICBzdHJ1 Y3QgdGFza19zdHJ1Y3QgKnRhcmdldCkKK3sKKwl1bnNpZ25lZCBpbnQgdnE7CisKKwltZW1zZXQo aGVhZGVyLCAwLCBzaXplb2YoKmhlYWRlcikpOworCisJaGVhZGVyLT5mbGFncyA9IHRlc3RfdHNr X3RocmVhZF9mbGFnKHRhcmdldCwgVElGX1NWRSkgPworCQlTVkVfUFRfUkVHU19TVkUgOiBTVkVf UFRfUkVHU19GUFNJTUQ7CisJaWYgKHRlc3RfdHNrX3RocmVhZF9mbGFnKHRhcmdldCwgVElGX1NW RV9WTF9JTkhFUklUKSkKKwkJaGVhZGVyLT5mbGFncyB8PSBTVkVfUFRfVkxfSU5IRVJJVDsKKwor CWhlYWRlci0+dmwgPSB0YXJnZXQtPnRocmVhZC5zdmVfdmw7CisJdnEgPSBzdmVfdnFfZnJvbV92 bChoZWFkZXItPnZsKTsKKworCWhlYWRlci0+bWF4X3ZsID0gc3ZlX21heF92bDsKKwlpZiAoV0FS Tl9PTighc3ZlX3ZsX3ZhbGlkKHN2ZV9tYXhfdmwpKSkKKwkJaGVhZGVyLT5tYXhfdmwgPSBoZWFk ZXItPnZsOworCisJaGVhZGVyLT5zaXplID0gU1ZFX1BUX1NJWkUodnEsIGhlYWRlci0+ZmxhZ3Mp OworCWhlYWRlci0+bWF4X3NpemUgPSBTVkVfUFRfU0laRShzdmVfdnFfZnJvbV92bChoZWFkZXIt Pm1heF92bCksCisJCQkJICAgICAgU1ZFX1BUX1JFR1NfU1ZFKTsKK30KKworc3RhdGljIHVuc2ln bmVkIGludCBzdmVfc2l6ZV9mcm9tX2hlYWRlcihzdHJ1Y3QgdXNlcl9zdmVfaGVhZGVyIGNvbnN0 ICpoZWFkZXIpCit7CisJcmV0dXJuIEFMSUdOKGhlYWRlci0+c2l6ZSwgU1ZFX1ZRX0JZVEVTKTsK K30KKworc3RhdGljIHVuc2lnbmVkIGludCBzdmVfZ2V0X3NpemUoc3RydWN0IHRhc2tfc3RydWN0 ICp0YXJnZXQsCisJCQkJIGNvbnN0IHN0cnVjdCB1c2VyX3JlZ3NldCAqcmVnc2V0KQoreworCXN0 cnVjdCB1c2VyX3N2ZV9oZWFkZXIgaGVhZGVyOworCisJaWYgKCFzeXN0ZW1fc3VwcG9ydHNfc3Zl KCkpCisJCXJldHVybiAwOworCisJc3ZlX2luaXRfaGVhZGVyX2Zyb21fdGFzaygmaGVhZGVyLCB0 YXJnZXQpOworCXJldHVybiBzdmVfc2l6ZV9mcm9tX2hlYWRlcigmaGVhZGVyKTsKK30KKworc3Rh dGljIGludCBzdmVfZ2V0KHN0cnVjdCB0YXNrX3N0cnVjdCAqdGFyZ2V0LAorCQkgICBjb25zdCBz dHJ1Y3QgdXNlcl9yZWdzZXQgKnJlZ3NldCwKKwkJICAgdW5zaWduZWQgaW50IHBvcywgdW5zaWdu ZWQgaW50IGNvdW50LAorCQkgICB2b2lkICprYnVmLCB2b2lkIF9fdXNlciAqdWJ1ZikKK3sKKwlp bnQgcmV0OworCXN0cnVjdCB1c2VyX3N2ZV9oZWFkZXIgaGVhZGVyOworCXVuc2lnbmVkIGludCB2 cTsKKwl1bnNpZ25lZCBsb25nIHN0YXJ0LCBlbmQ7CisKKwlpZiAoIXN5c3RlbV9zdXBwb3J0c19z dmUoKSkKKwkJcmV0dXJuIC1FSU5WQUw7CisKKwkvKiBIZWFkZXIgKi8KKwlzdmVfaW5pdF9oZWFk ZXJfZnJvbV90YXNrKCZoZWFkZXIsIHRhcmdldCk7CisJdnEgPSBzdmVfdnFfZnJvbV92bChoZWFk ZXIudmwpOworCisJcmV0ID0gdXNlcl9yZWdzZXRfY29weW91dCgmcG9zLCAmY291bnQsICZrYnVm LCAmdWJ1ZiwgJmhlYWRlciwKKwkJCQkgIDAsIHNpemVvZihoZWFkZXIpKTsKKwlpZiAocmV0KQor CQlyZXR1cm4gcmV0OworCisJaWYgKHRhcmdldCA9PSBjdXJyZW50KQorCQlmcHNpbWRfcHJlc2Vy dmVfY3VycmVudF9zdGF0ZSgpOworCisJLyogUmVnaXN0ZXJzOiBGUFNJTUQtb25seSBjYXNlICov CisKKwlCVUlMRF9CVUdfT04oU1ZFX1BUX0ZQU0lNRF9PRkZTRVQgIT0gc2l6ZW9mKGhlYWRlcikp OworCWlmICgoaGVhZGVyLmZsYWdzICYgU1ZFX1BUX1JFR1NfTUFTSykgPT0gU1ZFX1BUX1JFR1Nf RlBTSU1EKQorCQlyZXR1cm4gX19mcHJfZ2V0KHRhcmdldCwgcmVnc2V0LCBwb3MsIGNvdW50LCBr YnVmLCB1YnVmLAorCQkJCSBTVkVfUFRfRlBTSU1EX09GRlNFVCk7CisKKwkvKiBPdGhlcndpc2U6 IGZ1bGwgU1ZFIGNhc2UgKi8KKworCUJVSUxEX0JVR19PTihTVkVfUFRfU1ZFX09GRlNFVCAhPSBz aXplb2YoaGVhZGVyKSk7CisJc3RhcnQgPSBTVkVfUFRfU1ZFX09GRlNFVDsKKwllbmQgPSBTVkVf UFRfU1ZFX0ZGUl9PRkZTRVQodnEpICsgU1ZFX1BUX1NWRV9GRlJfU0laRSh2cSk7CisJcmV0ID0g dXNlcl9yZWdzZXRfY29weW91dCgmcG9zLCAmY291bnQsICZrYnVmLCAmdWJ1ZiwKKwkJCQkgIHRh cmdldC0+dGhyZWFkLnN2ZV9zdGF0ZSwKKwkJCQkgIHN0YXJ0LCBlbmQpOworCWlmIChyZXQpCisJ CXJldHVybiByZXQ7CisKKwlzdGFydCA9IGVuZDsKKwllbmQgPSBTVkVfUFRfU1ZFX0ZQU1JfT0ZG U0VUKHZxKTsKKwlyZXQgPSB1c2VyX3JlZ3NldF9jb3B5b3V0X3plcm8oJnBvcywgJmNvdW50LCAm a2J1ZiwgJnVidWYsCisJCQkJICAgICAgIHN0YXJ0LCBlbmQpOworCWlmIChyZXQpCisJCXJldHVy biByZXQ7CisKKwkvKgorCSAqIENvcHkgZnBzciwgYW5kIGZwY3Igd2hpY2ggbXVzdCBmb2xsb3cg Y29udGlndW91c2x5IGluCisJICogc3RydWN0IGZwc2ltZF9zdGF0ZToKKwkgKi8KKwlzdGFydCA9 IGVuZDsKKwllbmQgPSBTVkVfUFRfU1ZFX0ZQQ1JfT0ZGU0VUKHZxKSArIFNWRV9QVF9TVkVfRlBD Ul9TSVpFOworCXJldCA9IHVzZXJfcmVnc2V0X2NvcHlvdXQoJnBvcywgJmNvdW50LCAma2J1Ziwg JnVidWYsCisJCQkJICAmdGFyZ2V0LT50aHJlYWQuZnBzaW1kX3N0YXRlLmZwc3IsCisJCQkJICBz dGFydCwgZW5kKTsKKwlpZiAocmV0KQorCQlyZXR1cm4gcmV0OworCisJc3RhcnQgPSBlbmQ7CisJ ZW5kID0gc3ZlX3NpemVfZnJvbV9oZWFkZXIoJmhlYWRlcik7CisJcmV0dXJuIHVzZXJfcmVnc2V0 X2NvcHlvdXRfemVybygmcG9zLCAmY291bnQsICZrYnVmLCAmdWJ1ZiwKKwkJCQkJc3RhcnQsIGVu ZCk7Cit9CisKK3N0YXRpYyBpbnQgc3ZlX3NldChzdHJ1Y3QgdGFza19zdHJ1Y3QgKnRhcmdldCwK KwkJICAgY29uc3Qgc3RydWN0IHVzZXJfcmVnc2V0ICpyZWdzZXQsCisJCSAgIHVuc2lnbmVkIGlu dCBwb3MsIHVuc2lnbmVkIGludCBjb3VudCwKKwkJICAgY29uc3Qgdm9pZCAqa2J1ZiwgY29uc3Qg dm9pZCBfX3VzZXIgKnVidWYpCit7CisJaW50IHJldDsKKwlzdHJ1Y3QgdXNlcl9zdmVfaGVhZGVy IGhlYWRlcjsKKwl1bnNpZ25lZCBpbnQgdnE7CisJdW5zaWduZWQgbG9uZyBzdGFydCwgZW5kOwor CisJaWYgKCFzeXN0ZW1fc3VwcG9ydHNfc3ZlKCkpCisJCXJldHVybiAtRUlOVkFMOworCisJLyog SGVhZGVyICovCisJaWYgKGNvdW50IDwgc2l6ZW9mKGhlYWRlcikpCisJCXJldHVybiAtRUlOVkFM OworCXJldCA9IHVzZXJfcmVnc2V0X2NvcHlpbigmcG9zLCAmY291bnQsICZrYnVmLCAmdWJ1Ziwg JmhlYWRlciwKKwkJCQkgMCwgc2l6ZW9mKGhlYWRlcikpOworCWlmIChyZXQpCisJCWdvdG8gb3V0 OworCisJLyoKKwkgKiBBcGFydCBmcm9tIFBUX1NWRV9SRUdTX01BU0ssIGFsbCBQVF9TVkVfKiBm bGFncyBhcmUgY29uc3VtZWQgYnkKKwkgKiBzdmVfc2V0X3ZlY3Rvcl9sZW5ndGgoKSwgd2hpY2gg d2lsbCBhbHNvIHZhbGlkYXRlIHRoZW0gZm9yIHVzOgorCSAqLworCXJldCA9IHN2ZV9zZXRfdmVj dG9yX2xlbmd0aCh0YXJnZXQsIGhlYWRlci52bCwKKwkJKCh1bnNpZ25lZCBsb25nKWhlYWRlci5m bGFncyAmIH5TVkVfUFRfUkVHU19NQVNLKSA8PCAxNik7CisJaWYgKHJldCkKKwkJZ290byBvdXQ7 CisKKwkvKiBBY3R1YWwgVkwgc2V0IG1heSBiZSBsZXNzIHRoYW4gdGhlIHVzZXIgYXNrZWQgZm9y OiAqLworCXZxID0gc3ZlX3ZxX2Zyb21fdmwodGFyZ2V0LT50aHJlYWQuc3ZlX3ZsKTsKKworCS8q IFJlZ2lzdGVyczogRlBTSU1ELW9ubHkgY2FzZSAqLworCisJQlVJTERfQlVHX09OKFNWRV9QVF9G UFNJTURfT0ZGU0VUICE9IHNpemVvZihoZWFkZXIpKTsKKwlpZiAoKGhlYWRlci5mbGFncyAmIFNW RV9QVF9SRUdTX01BU0spID09IFNWRV9QVF9SRUdTX0ZQU0lNRCkgeworCQlzdmVfc3luY190b19m cHNpbWQodGFyZ2V0KTsKKworCQlyZXQgPSBfX2Zwcl9zZXQodGFyZ2V0LCByZWdzZXQsIHBvcywg Y291bnQsIGtidWYsIHVidWYsCisJCQkJU1ZFX1BUX0ZQU0lNRF9PRkZTRVQpOworCQljbGVhcl90 c2tfdGhyZWFkX2ZsYWcodGFyZ2V0LCBUSUZfU1ZFKTsKKwkJZ290byBvdXQ7CisJfQorCisJLyog T3RoZXJ3aXNlOiBmdWxsIFNWRSBjYXNlICovCisKKwkvKgorCSAqIElmIHNldHRpbmcgYSBkaWZm ZXJlbnQgVkwgZnJvbSB0aGUgcmVxdWVzdGVkIFZMIGFuZCB0aGVyZSBpcworCSAqIHJlZ2lzdGVy IGRhdGEsIHRoZSBkYXRhIGxheW91dCB3aWxsIGJlIHdyb25nOiBkb24ndCBldmVuCisJICogdHJ5 IHRvIHNldCB0aGUgcmVnaXN0ZXJzIGluIHRoaXMgY2FzZS4KKwkgKi8KKwlpZiAoY291bnQgJiYg dnEgIT0gc3ZlX3ZxX2Zyb21fdmwoaGVhZGVyLnZsKSkgeworCQlyZXQgPSAtRUlPOworCQlnb3Rv IG91dDsKKwl9CisKKwlzdmVfYWxsb2ModGFyZ2V0KTsKKwlmcHNpbWRfc3luY190b19zdmUodGFy Z2V0KTsKKwlzZXRfdHNrX3RocmVhZF9mbGFnKHRhcmdldCwgVElGX1NWRSk7CisKKwlCVUlMRF9C VUdfT04oU1ZFX1BUX1NWRV9PRkZTRVQgIT0gc2l6ZW9mKGhlYWRlcikpOworCXN0YXJ0ID0gU1ZF X1BUX1NWRV9PRkZTRVQ7CisJZW5kID0gU1ZFX1BUX1NWRV9GRlJfT0ZGU0VUKHZxKSArIFNWRV9Q VF9TVkVfRkZSX1NJWkUodnEpOworCXJldCA9IHVzZXJfcmVnc2V0X2NvcHlpbigmcG9zLCAmY291 bnQsICZrYnVmLCAmdWJ1ZiwKKwkJCQkgdGFyZ2V0LT50aHJlYWQuc3ZlX3N0YXRlLAorCQkJCSBz dGFydCwgZW5kKTsKKwlpZiAocmV0KQorCQlnb3RvIG91dDsKKworCXN0YXJ0ID0gZW5kOworCWVu ZCA9IFNWRV9QVF9TVkVfRlBTUl9PRkZTRVQodnEpOworCXJldCA9IHVzZXJfcmVnc2V0X2NvcHlp bl9pZ25vcmUoJnBvcywgJmNvdW50LCAma2J1ZiwgJnVidWYsCisJCQkJCXN0YXJ0LCBlbmQpOwor CWlmIChyZXQpCisJCWdvdG8gb3V0OworCisJLyoKKwkgKiBDb3B5IGZwc3IsIGFuZCBmcGNyIHdo aWNoIG11c3QgZm9sbG93IGNvbnRpZ3VvdXNseSBpbgorCSAqIHN0cnVjdCBmcHNpbWRfc3RhdGU6 CisJICovCisJc3RhcnQgPSBlbmQ7CisJZW5kID0gU1ZFX1BUX1NWRV9GUENSX09GRlNFVCh2cSkg KyBTVkVfUFRfU1ZFX0ZQQ1JfU0laRTsKKwlyZXQgPSB1c2VyX3JlZ3NldF9jb3B5aW4oJnBvcywg JmNvdW50LCAma2J1ZiwgJnVidWYsCisJCQkJICZ0YXJnZXQtPnRocmVhZC5mcHNpbWRfc3RhdGUu ZnBzciwKKwkJCQkgc3RhcnQsIGVuZCk7CisKK291dDoKKwlmcHNpbWRfZmx1c2hfdGFza19zdGF0 ZSh0YXJnZXQpOworCXJldHVybiByZXQ7Cit9CisKKyNlbmRpZiAvKiBDT05GSUdfQVJNNjRfU1ZF ICovCisKIGVudW0gYWFyY2g2NF9yZWdzZXQgewogCVJFR1NFVF9HUFIsCiAJUkVHU0VUX0ZQUiwK QEAgLTcxMSw2ICs5NTEsOSBAQCBlbnVtIGFhcmNoNjRfcmVnc2V0IHsKIAlSRUdTRVRfSFdfV0FU Q0gsCiAjZW5kaWYKIAlSRUdTRVRfU1lTVEVNX0NBTEwsCisjaWZkZWYgQ09ORklHX0FSTTY0X1NW RQorCVJFR1NFVF9TVkUsCisjZW5kaWYKIH07CiAKIHN0YXRpYyBjb25zdCBzdHJ1Y3QgdXNlcl9y ZWdzZXQgYWFyY2g2NF9yZWdzZXRzW10gPSB7CkBAIC03NjgsNiArMTAxMSwxOCBAQCBzdGF0aWMg Y29uc3Qgc3RydWN0IHVzZXJfcmVnc2V0IGFhcmNoNjRfcmVnc2V0c1tdID0gewogCQkuZ2V0ID0g c3lzdGVtX2NhbGxfZ2V0LAogCQkuc2V0ID0gc3lzdGVtX2NhbGxfc2V0LAogCX0sCisjaWZkZWYg Q09ORklHX0FSTTY0X1NWRQorCVtSRUdTRVRfU1ZFXSA9IHsgLyogU2NhbGFibGUgVmVjdG9yIEV4 dGVuc2lvbiAqLworCQkuY29yZV9ub3RlX3R5cGUgPSBOVF9BUk1fU1ZFLAorCQkubiA9IERJVl9S T1VORF9VUChTVkVfUFRfU0laRShTVkVfVlFfTUFYLCBTVkVfUFRfUkVHU19TVkUpLAorCQkJCSAg U1ZFX1ZRX0JZVEVTKSwKKwkJLnNpemUgPSBTVkVfVlFfQllURVMsCisJCS5hbGlnbiA9IFNWRV9W UV9CWVRFUywKKwkJLmdldCA9IHN2ZV9nZXQsCisJCS5zZXQgPSBzdmVfc2V0LAorCQkuZ2V0X3Np emUgPSBzdmVfZ2V0X3NpemUsCisJfSwKKyNlbmRpZgogfTsKIAogc3RhdGljIGNvbnN0IHN0cnVj dCB1c2VyX3JlZ3NldF92aWV3IHVzZXJfYWFyY2g2NF92aWV3ID0gewpkaWZmIC0tZ2l0IGEvaW5j bHVkZS91YXBpL2xpbnV4L2VsZi5oIGIvaW5jbHVkZS91YXBpL2xpbnV4L2VsZi5oCmluZGV4IGI1 MjgwZGIuLjczNWI4ZjQgMTAwNjQ0Ci0tLSBhL2luY2x1ZGUvdWFwaS9saW51eC9lbGYuaAorKysg Yi9pbmNsdWRlL3VhcGkvbGludXgvZWxmLmgKQEAgLTQxNiw2ICs0MTYsNyBAQCB0eXBlZGVmIHN0 cnVjdCBlbGY2NF9zaGRyIHsKICNkZWZpbmUgTlRfQVJNX0hXX0JSRUFLCTB4NDAyCQkvKiBBUk0g aGFyZHdhcmUgYnJlYWtwb2ludCByZWdpc3RlcnMgKi8KICNkZWZpbmUgTlRfQVJNX0hXX1dBVENI CTB4NDAzCQkvKiBBUk0gaGFyZHdhcmUgd2F0Y2hwb2ludCByZWdpc3RlcnMgKi8KICNkZWZpbmUg TlRfQVJNX1NZU1RFTV9DQUxMCTB4NDA0CS8qIEFSTSBzeXN0ZW0gY2FsbCBudW1iZXIgKi8KKyNk ZWZpbmUgTlRfQVJNX1NWRQkweDQwNQkJLyogQVJNIFNjYWxhYmxlIFZlY3RvciBFeHRlbnNpb24g cmVnaXN0ZXJzICovCiAjZGVmaW5lIE5UX01FVEFHX0NCVUYJMHg1MDAJCS8qIE1ldGFnIGNhdGNo IGJ1ZmZlciByZWdpc3RlcnMgKi8KICNkZWZpbmUgTlRfTUVUQUdfUlBJUEUJMHg1MDEJCS8qIE1l dGFnIHJlYWQgcGlwZWxpbmUgc3RhdGUgKi8KICNkZWZpbmUgTlRfTUVUQUdfVExTCTB4NTAyCQkv KiBNZXRhZyBUTFMgcG9pbnRlciAqLwotLSAKMi4xLjQKCl9fX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fCmt2bWFybSBtYWlsaW5nIGxpc3QKa3ZtYXJtQGxpc3Rz LmNzLmNvbHVtYmlhLmVkdQpodHRwczovL2xpc3RzLmNzLmNvbHVtYmlhLmVkdS9tYWlsbWFuL2xp c3RpbmZvL2t2bWFybQo= From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from foss.arm.com ([217.140.101.70]:49080 "EHLO foss.arm.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S932526AbdJJSjf (ORCPT ); Tue, 10 Oct 2017 14:39:35 -0400 From: Dave Martin Subject: [PATCH v3 19/28] arm64/sve: ptrace and ELF coredump support Date: Tue, 10 Oct 2017 19:38:36 +0100 Message-ID: <1507660725-7986-20-git-send-email-Dave.Martin@arm.com> In-Reply-To: <1507660725-7986-1-git-send-email-Dave.Martin@arm.com> References: <1507660725-7986-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 , Richard Sandiford , Okamoto Takayuki , kvmarm@lists.cs.columbia.edu, libc-alpha@sourceware.org, linux-arch@vger.kernel.org, Alan Hayward Message-ID: <20171010183836.VJx8W27-O3pjLnJtkpp2yY4RCDbMIkl-wfJWG1nHAPo@z> This patch defines and implements a new regset NT_ARM_SVE, which describes a thread's SVE register state. This allows a debugger to manipulate the SVE state, as well as being included in ELF coredumps for post-mortem debugging. Because the regset size and layout are dependent on the thread's current vector length, it is not possible to define a C struct to describe the regset contents as is done for existing regsets. Instead, and for the same reasons, NT_ARM_SVE is based on the freeform variable-layout approach used for the SVE signal frame. Additionally, to reduce debug overhead when debugging threads that might or might not have live SVE register state, NT_ARM_SVE may be presented in one of two different formats: the old struct user_fpsimd_state format is embedded for describing the state of a thread with no live SVE state, whereas a new variable-layout structure is embedded for describing live SVE state. This avoids a debugger needing to poll NT_PRFPREG in addition to NT_ARM_SVE, and allows existing userspace code to handle the non-SVE case without too much modification. For this to work, NT_ARM_SVE is defined with a fixed-format header of type struct user_sve_header, which the recipient can use to figure out the content, size and layout of the reset of the regset. Accessor macros are defined to allow the vector-length-dependent parts of the regset to be manipulated. Signed-off-by: Alan Hayward Signed-off-by: Dave Martin Cc: Alex Bennée Cc: Okamoto Takayuki --- Dropped Alex Bennée's reviewed-by, since bug fixes have been applied. Changes since v2 ---------------- Bug fixes: * Initialised user_sve_header.sve_max_vl properly in sve_init_header_from_task(). (Reported by Okamoto Takayuki.) This bug was introduced by the refactoring since v1 to remove BUG_ON()s. A WARN_ON() was introduced to fix up the error case here, but the code for the non-error case was lost. This resulted in userspace seeing max_size == 0 when reading NT_ARM_SVE with PTRACE_GETREGSET. NT_ARM_SVE would also get truncated in coredmups (though I've not tested that). This fix ensures that max_size is initialised, and only overrides the value written if it would be garbage. * In sve_set(), the flags for sve_set_vector_length() are shifted into the correct position. Without this, a PTRACE_SETREGSET for NT_ARM_SVE may reject valid flags (including flags read via PTRACE_GETREGSET) with -EINVAL: thus, legitimate uses including save/restore may not work. Miscellaneous: * Clarified comment in ptrace.h about keeping flags in sync with prctl.h so that it won't be misinterpreted as applying to SVE_PT_REGS_{MASK, FPSIMD,SVE} (which deliberately have no prctl equivalent). * Added comments explaining the intent, purpose and basic constraints for fpsimd.c helpers. --- arch/arm64/include/asm/fpsimd.h | 13 +- arch/arm64/include/uapi/asm/ptrace.h | 138 ++++++++++++++++++ arch/arm64/kernel/fpsimd.c | 60 ++++++++ arch/arm64/kernel/ptrace.c | 271 +++++++++++++++++++++++++++++++++-- include/uapi/linux/elf.h | 1 + 5 files changed, 474 insertions(+), 9 deletions(-) diff --git a/arch/arm64/include/asm/fpsimd.h b/arch/arm64/include/asm/fpsimd.h index bad72fd..ee6db38 100644 --- a/arch/arm64/include/asm/fpsimd.h +++ b/arch/arm64/include/asm/fpsimd.h @@ -38,13 +38,16 @@ struct fpsimd_state { __uint128_t vregs[32]; u32 fpsr; u32 fpcr; + /* + * For ptrace compatibility, pad to next 128-bit + * boundary here if extending this struct. + */ }; }; /* the id of the last cpu to have restored this state */ unsigned int cpu; }; - #if defined(__KERNEL__) && defined(CONFIG_COMPAT) /* Masks for extracting the FPSR and FPCR from the FPSCR */ #define VFP_FPSCR_STAT_MASK 0xf800009f @@ -89,6 +92,10 @@ extern size_t sve_state_size(struct task_struct const *task); extern void sve_alloc(struct task_struct *task); extern void fpsimd_release_thread(struct task_struct *task); +extern void fpsimd_sync_to_sve(struct task_struct *task); +extern void sve_sync_to_fpsimd(struct task_struct *task); +extern void sve_sync_from_fpsimd_zeropad(struct task_struct *task); + extern int sve_set_vector_length(struct task_struct *task, unsigned long vl, unsigned long flags); @@ -105,6 +112,10 @@ extern void __init sve_setup(void); static void __maybe_unused sve_alloc(struct task_struct *task) { } static void __maybe_unused fpsimd_release_thread(struct task_struct *task) { } +static void __maybe_unused sve_sync_to_fpsimd(struct task_struct *task) { } +static void __maybe_unused sve_sync_from_fpsimd_zeropad( + struct task_struct *task) { } + static void __maybe_unused sve_init_vq_map(void) { } static void __maybe_unused sve_update_vq_map(void) { } static int __maybe_unused sve_verify_vq_map(void) { return 0; } diff --git a/arch/arm64/include/uapi/asm/ptrace.h b/arch/arm64/include/uapi/asm/ptrace.h index d1ff83d..a0fc6a8 100644 --- a/arch/arm64/include/uapi/asm/ptrace.h +++ b/arch/arm64/include/uapi/asm/ptrace.h @@ -22,6 +22,7 @@ #include #include +#include /* @@ -63,6 +64,8 @@ #ifndef __ASSEMBLY__ +#include + /* * User structures for general purpose, floating point and debug registers. */ @@ -90,6 +93,141 @@ struct user_hwdebug_state { } dbg_regs[16]; }; +/* SVE/FP/SIMD state (NT_ARM_SVE) */ + +struct user_sve_header { + __u32 size; /* total meaningful regset content in bytes */ + __u32 max_size; /* maxmium possible size for this thread */ + __u16 vl; /* current vector length */ + __u16 max_vl; /* maximum possible vector length */ + __u16 flags; + __u16 __reserved; +}; + +/* Definitions for user_sve_header.flags: */ +#define SVE_PT_REGS_MASK (1 << 0) + +#define SVE_PT_REGS_FPSIMD 0 +#define SVE_PT_REGS_SVE SVE_PT_REGS_MASK + +/* + * Common SVE_PT_* flags: + * These must be kept in sync with prctl interface in + */ +#define SVE_PT_VL_INHERIT (PR_SVE_VL_INHERIT >> 16) +#define SVE_PT_VL_ONEXEC (PR_SVE_SET_VL_ONEXEC >> 16) + + +/* + * The remainder of the SVE state follows struct user_sve_header. The + * total size of the SVE state (including header) depends on the + * metadata in the header: SVE_PT_SIZE(vq, flags) gives the total size + * of the state in bytes, including the header. + * + * Refer to for details of how to pass the correct + * "vq" argument to these macros. + */ + +/* Offset from the start of struct user_sve_header to the register data */ +#define SVE_PT_REGS_OFFSET \ + ((sizeof(struct sve_context) + (SVE_VQ_BYTES - 1)) \ + / SVE_VQ_BYTES * SVE_VQ_BYTES) + +/* + * The register data content and layout depends on the value of the + * flags field. + */ + +/* + * (flags & SVE_PT_REGS_MASK) == SVE_PT_REGS_FPSIMD case: + * + * The payload starts at offset SVE_PT_FPSIMD_OFFSET, and is of type + * struct user_fpsimd_state. Additional data might be appended in the + * future: use SVE_PT_FPSIMD_SIZE(vq, flags) to compute the total size. + * SVE_PT_FPSIMD_SIZE(vq, flags) will never be less than + * sizeof(struct user_fpsimd_state). + */ + +#define SVE_PT_FPSIMD_OFFSET SVE_PT_REGS_OFFSET + +#define SVE_PT_FPSIMD_SIZE(vq, flags) (sizeof(struct user_fpsimd_state)) + +/* + * (flags & SVE_PT_REGS_MASK) == SVE_PT_REGS_SVE case: + * + * The payload starts at offset SVE_PT_SVE_OFFSET, and is of size + * SVE_PT_SVE_SIZE(vq, flags). + * + * Additional macros describe the contents and layout of the payload. + * For each, SVE_PT_SVE_x_OFFSET(args) is the start offset relative to + * the start of struct user_sve_header, and SVE_PT_SVE_x_SIZE(args) is + * the size in bytes: + * + * x type description + * - ---- ----------- + * ZREGS \ + * ZREG | + * PREGS | refer to + * PREG | + * FFR / + * + * FPSR uint32_t FPSR + * FPCR uint32_t FPCR + * + * Additional data might be appended in the future. + */ + +#define SVE_PT_SVE_ZREG_SIZE(vq) SVE_SIG_ZREG_SIZE(vq) +#define SVE_PT_SVE_PREG_SIZE(vq) SVE_SIG_PREG_SIZE(vq) +#define SVE_PT_SVE_FFR_SIZE(vq) SVE_SIG_FFR_SIZE(vq) +#define SVE_PT_SVE_FPSR_SIZE sizeof(__u32) +#define SVE_PT_SVE_FPCR_SIZE sizeof(__u32) + +#define __SVE_SIG_TO_PT(offset) \ + ((offset) - SVE_SIG_REGS_OFFSET + SVE_PT_REGS_OFFSET) + +#define SVE_PT_SVE_OFFSET SVE_PT_REGS_OFFSET + +#define SVE_PT_SVE_ZREGS_OFFSET \ + __SVE_SIG_TO_PT(SVE_SIG_ZREGS_OFFSET) +#define SVE_PT_SVE_ZREG_OFFSET(vq, n) \ + __SVE_SIG_TO_PT(SVE_SIG_ZREG_OFFSET(vq, n)) +#define SVE_PT_SVE_ZREGS_SIZE(vq) \ + (SVE_PT_SVE_ZREG_OFFSET(vq, SVE_NUM_ZREGS) - SVE_PT_SVE_ZREGS_OFFSET) + +#define SVE_PT_SVE_PREGS_OFFSET(vq) \ + __SVE_SIG_TO_PT(SVE_SIG_PREGS_OFFSET(vq)) +#define SVE_PT_SVE_PREG_OFFSET(vq, n) \ + __SVE_SIG_TO_PT(SVE_SIG_PREG_OFFSET(vq, n)) +#define SVE_PT_SVE_PREGS_SIZE(vq) \ + (SVE_PT_SVE_PREG_OFFSET(vq, SVE_NUM_PREGS) - \ + SVE_PT_SVE_PREGS_OFFSET(vq)) + +#define SVE_PT_SVE_FFR_OFFSET(vq) \ + __SVE_SIG_TO_PT(SVE_SIG_FFR_OFFSET(vq)) + +#define SVE_PT_SVE_FPSR_OFFSET(vq) \ + ((SVE_PT_SVE_FFR_OFFSET(vq) + SVE_PT_SVE_FFR_SIZE(vq) + \ + (SVE_VQ_BYTES - 1)) \ + / SVE_VQ_BYTES * SVE_VQ_BYTES) +#define SVE_PT_SVE_FPCR_OFFSET(vq) \ + (SVE_PT_SVE_FPSR_OFFSET(vq) + SVE_PT_SVE_FPSR_SIZE) + +/* + * Any future extension appended after FPCR must be aligned to the next + * 128-bit boundary. + */ + +#define SVE_PT_SVE_SIZE(vq, flags) \ + ((SVE_PT_SVE_FPCR_OFFSET(vq) + SVE_PT_SVE_FPCR_SIZE \ + - SVE_PT_SVE_OFFSET + (SVE_VQ_BYTES - 1)) \ + / SVE_VQ_BYTES * SVE_VQ_BYTES) + +#define SVE_PT_SIZE(vq, flags) \ + (((flags) & SVE_PT_REGS_MASK) == SVE_PT_REGS_SVE ? \ + SVE_PT_SVE_OFFSET + SVE_PT_SVE_SIZE(vq, flags) \ + : SVE_PT_FPSIMD_OFFSET + SVE_PT_FPSIMD_SIZE(vq, flags)) + #endif /* __ASSEMBLY__ */ #endif /* _UAPI__ASM_PTRACE_H */ diff --git a/arch/arm64/kernel/fpsimd.c b/arch/arm64/kernel/fpsimd.c index c194627..6db9f30 100644 --- a/arch/arm64/kernel/fpsimd.c +++ b/arch/arm64/kernel/fpsimd.c @@ -438,6 +438,66 @@ void sve_alloc(struct task_struct *task) BUG_ON(!task->thread.sve_state); } + +/* + * Ensure that task->thread.sve_state is up to date with respect to + * the user task, irrespective of when SVE is in use or not. + * + * This should only be called by ptrace. task must be non-runnable. + * task->thread.sve_state must point to at least sve_state_size(task) + * bytes of allocated kernel memory. + */ +void fpsimd_sync_to_sve(struct task_struct *task) +{ + if (!test_tsk_thread_flag(task, TIF_SVE)) + fpsimd_to_sve(task); +} + +/* + * Ensure that task->thread.fpsimd_state is up to date with respect to + * the user task, irrespective of whether SVE is in use or not. + * + * This should only be called by ptrace. task must be non-runnable. + * task->thread.sve_state must point to at least sve_state_size(task) + * bytes of allocated kernel memory. + */ +void sve_sync_to_fpsimd(struct task_struct *task) +{ + if (test_tsk_thread_flag(task, TIF_SVE)) + sve_to_fpsimd(task); +} + +/* + * Ensure that task->thread.sve_state is up to date with respect to + * the task->thread.fpsimd_state. + * + * This should only be called by ptrace to merge new FPSIMD register + * values into a task for which SVE is currently active. + * task must be non-runnable. + * task->thread.sve_state must point to at least sve_state_size(task) + * bytes of allocated kernel memory. + * task->thread.fpsimd_state must already have been initialised with + * the new FPSIMD register values to be merged in. + */ +void sve_sync_from_fpsimd_zeropad(struct task_struct *task) +{ + unsigned int vq; + void *sst = task->thread.sve_state; + struct fpsimd_state const *fst = &task->thread.fpsimd_state; + unsigned int i; + + if (!test_tsk_thread_flag(task, TIF_SVE)) + return; + + vq = sve_vq_from_vl(task->thread.sve_vl); + + memset(sst, 0, SVE_SIG_REGS_SIZE(vq)); + + for (i = 0; i < 32; ++i) + memcpy(ZREG(sst, vq, i), &fst->vregs[i], + sizeof(fst->vregs[i])); +} + int sve_set_vector_length(struct task_struct *task, unsigned long vl, unsigned long flags) { diff --git a/arch/arm64/kernel/ptrace.c b/arch/arm64/kernel/ptrace.c index 9cbb612..7252209 100644 --- a/arch/arm64/kernel/ptrace.c +++ b/arch/arm64/kernel/ptrace.c @@ -32,6 +32,7 @@ #include #include #include +#include #include #include #include @@ -40,6 +41,7 @@ #include #include +#include #include #include #include @@ -618,33 +620,66 @@ static int gpr_set(struct task_struct *target, const struct user_regset *regset, /* * TODO: update fp accessors for lazy context switching (sync/flush hwstate) */ -static int fpr_get(struct task_struct *target, const struct user_regset *regset, - unsigned int pos, unsigned int count, - void *kbuf, void __user *ubuf) +static int __fpr_get(struct task_struct *target, + const struct user_regset *regset, + unsigned int pos, unsigned int count, + void *kbuf, void __user *ubuf, unsigned int start_pos) { struct user_fpsimd_state *uregs; + + sve_sync_to_fpsimd(target); + uregs = &target->thread.fpsimd_state.user_fpsimd; + return user_regset_copyout(&pos, &count, &kbuf, &ubuf, uregs, + start_pos, start_pos + sizeof(*uregs)); +} + +static int fpr_get(struct task_struct *target, const struct user_regset *regset, + unsigned int pos, unsigned int count, + void *kbuf, void __user *ubuf) +{ if (target == current) fpsimd_preserve_current_state(); - return user_regset_copyout(&pos, &count, &kbuf, &ubuf, uregs, 0, -1); + return __fpr_get(target, regset, pos, count, kbuf, ubuf, 0); } -static int fpr_set(struct task_struct *target, const struct user_regset *regset, - unsigned int pos, unsigned int count, - const void *kbuf, const void __user *ubuf) +static int __fpr_set(struct task_struct *target, + const struct user_regset *regset, + unsigned int pos, unsigned int count, + const void *kbuf, const void __user *ubuf, + unsigned int start_pos) { int ret; struct user_fpsimd_state newstate = target->thread.fpsimd_state.user_fpsimd; - ret = user_regset_copyin(&pos, &count, &kbuf, &ubuf, &newstate, 0, -1); + sve_sync_to_fpsimd(target); + + ret = user_regset_copyin(&pos, &count, &kbuf, &ubuf, &newstate, + start_pos, start_pos + sizeof(newstate)); if (ret) return ret; target->thread.fpsimd_state.user_fpsimd = newstate; + + return ret; +} + +static int fpr_set(struct task_struct *target, const struct user_regset *regset, + unsigned int pos, unsigned int count, + const void *kbuf, const void __user *ubuf) +{ + int ret; + + ret = __fpr_set(target, regset, pos, count, kbuf, ubuf, 0); + if (ret) + return ret; + + sve_sync_from_fpsimd_zeropad(target); fpsimd_flush_task_state(target); + return ret; } @@ -702,6 +737,211 @@ static int system_call_set(struct task_struct *target, return ret; } +#ifdef CONFIG_ARM64_SVE + +static void sve_init_header_from_task(struct user_sve_header *header, + struct task_struct *target) +{ + unsigned int vq; + + memset(header, 0, sizeof(*header)); + + header->flags = test_tsk_thread_flag(target, TIF_SVE) ? + SVE_PT_REGS_SVE : SVE_PT_REGS_FPSIMD; + if (test_tsk_thread_flag(target, TIF_SVE_VL_INHERIT)) + header->flags |= SVE_PT_VL_INHERIT; + + header->vl = target->thread.sve_vl; + vq = sve_vq_from_vl(header->vl); + + header->max_vl = sve_max_vl; + if (WARN_ON(!sve_vl_valid(sve_max_vl))) + header->max_vl = header->vl; + + header->size = SVE_PT_SIZE(vq, header->flags); + header->max_size = SVE_PT_SIZE(sve_vq_from_vl(header->max_vl), + SVE_PT_REGS_SVE); +} + +static unsigned int sve_size_from_header(struct user_sve_header const *header) +{ + return ALIGN(header->size, SVE_VQ_BYTES); +} + +static unsigned int sve_get_size(struct task_struct *target, + const struct user_regset *regset) +{ + struct user_sve_header header; + + if (!system_supports_sve()) + return 0; + + sve_init_header_from_task(&header, target); + return sve_size_from_header(&header); +} + +static int sve_get(struct task_struct *target, + const struct user_regset *regset, + unsigned int pos, unsigned int count, + void *kbuf, void __user *ubuf) +{ + int ret; + struct user_sve_header header; + unsigned int vq; + unsigned long start, end; + + if (!system_supports_sve()) + return -EINVAL; + + /* Header */ + sve_init_header_from_task(&header, target); + vq = sve_vq_from_vl(header.vl); + + ret = user_regset_copyout(&pos, &count, &kbuf, &ubuf, &header, + 0, sizeof(header)); + if (ret) + return ret; + + if (target == current) + fpsimd_preserve_current_state(); + + /* Registers: FPSIMD-only case */ + + BUILD_BUG_ON(SVE_PT_FPSIMD_OFFSET != sizeof(header)); + if ((header.flags & SVE_PT_REGS_MASK) == SVE_PT_REGS_FPSIMD) + return __fpr_get(target, regset, pos, count, kbuf, ubuf, + SVE_PT_FPSIMD_OFFSET); + + /* Otherwise: full SVE case */ + + BUILD_BUG_ON(SVE_PT_SVE_OFFSET != sizeof(header)); + start = SVE_PT_SVE_OFFSET; + end = SVE_PT_SVE_FFR_OFFSET(vq) + SVE_PT_SVE_FFR_SIZE(vq); + ret = user_regset_copyout(&pos, &count, &kbuf, &ubuf, + target->thread.sve_state, + start, end); + if (ret) + return ret; + + start = end; + end = SVE_PT_SVE_FPSR_OFFSET(vq); + ret = user_regset_copyout_zero(&pos, &count, &kbuf, &ubuf, + start, end); + if (ret) + return ret; + + /* + * Copy fpsr, and fpcr which must follow contiguously in + * struct fpsimd_state: + */ + start = end; + end = SVE_PT_SVE_FPCR_OFFSET(vq) + SVE_PT_SVE_FPCR_SIZE; + ret = user_regset_copyout(&pos, &count, &kbuf, &ubuf, + &target->thread.fpsimd_state.fpsr, + start, end); + if (ret) + return ret; + + start = end; + end = sve_size_from_header(&header); + return user_regset_copyout_zero(&pos, &count, &kbuf, &ubuf, + start, end); +} + +static int sve_set(struct task_struct *target, + const struct user_regset *regset, + unsigned int pos, unsigned int count, + const void *kbuf, const void __user *ubuf) +{ + int ret; + struct user_sve_header header; + unsigned int vq; + unsigned long start, end; + + if (!system_supports_sve()) + return -EINVAL; + + /* Header */ + if (count < sizeof(header)) + return -EINVAL; + ret = user_regset_copyin(&pos, &count, &kbuf, &ubuf, &header, + 0, sizeof(header)); + if (ret) + goto out; + + /* + * Apart from PT_SVE_REGS_MASK, all PT_SVE_* flags are consumed by + * sve_set_vector_length(), which will also validate them for us: + */ + ret = sve_set_vector_length(target, header.vl, + ((unsigned long)header.flags & ~SVE_PT_REGS_MASK) << 16); + if (ret) + goto out; + + /* Actual VL set may be less than the user asked for: */ + vq = sve_vq_from_vl(target->thread.sve_vl); + + /* Registers: FPSIMD-only case */ + + BUILD_BUG_ON(SVE_PT_FPSIMD_OFFSET != sizeof(header)); + if ((header.flags & SVE_PT_REGS_MASK) == SVE_PT_REGS_FPSIMD) { + sve_sync_to_fpsimd(target); + + ret = __fpr_set(target, regset, pos, count, kbuf, ubuf, + SVE_PT_FPSIMD_OFFSET); + clear_tsk_thread_flag(target, TIF_SVE); + goto out; + } + + /* Otherwise: full SVE case */ + + /* + * If setting a different VL from the requested VL and there is + * register data, the data layout will be wrong: don't even + * try to set the registers in this case. + */ + if (count && vq != sve_vq_from_vl(header.vl)) { + ret = -EIO; + goto out; + } + + sve_alloc(target); + fpsimd_sync_to_sve(target); + set_tsk_thread_flag(target, TIF_SVE); + + BUILD_BUG_ON(SVE_PT_SVE_OFFSET != sizeof(header)); + start = SVE_PT_SVE_OFFSET; + end = SVE_PT_SVE_FFR_OFFSET(vq) + SVE_PT_SVE_FFR_SIZE(vq); + ret = user_regset_copyin(&pos, &count, &kbuf, &ubuf, + target->thread.sve_state, + start, end); + if (ret) + goto out; + + start = end; + end = SVE_PT_SVE_FPSR_OFFSET(vq); + ret = user_regset_copyin_ignore(&pos, &count, &kbuf, &ubuf, + start, end); + if (ret) + goto out; + + /* + * Copy fpsr, and fpcr which must follow contiguously in + * struct fpsimd_state: + */ + start = end; + end = SVE_PT_SVE_FPCR_OFFSET(vq) + SVE_PT_SVE_FPCR_SIZE; + ret = user_regset_copyin(&pos, &count, &kbuf, &ubuf, + &target->thread.fpsimd_state.fpsr, + start, end); + +out: + fpsimd_flush_task_state(target); + return ret; +} + +#endif /* CONFIG_ARM64_SVE */ + enum aarch64_regset { REGSET_GPR, REGSET_FPR, @@ -711,6 +951,9 @@ enum aarch64_regset { REGSET_HW_WATCH, #endif REGSET_SYSTEM_CALL, +#ifdef CONFIG_ARM64_SVE + REGSET_SVE, +#endif }; static const struct user_regset aarch64_regsets[] = { @@ -768,6 +1011,18 @@ static const struct user_regset aarch64_regsets[] = { .get = system_call_get, .set = system_call_set, }, +#ifdef CONFIG_ARM64_SVE + [REGSET_SVE] = { /* Scalable Vector Extension */ + .core_note_type = NT_ARM_SVE, + .n = DIV_ROUND_UP(SVE_PT_SIZE(SVE_VQ_MAX, SVE_PT_REGS_SVE), + SVE_VQ_BYTES), + .size = SVE_VQ_BYTES, + .align = SVE_VQ_BYTES, + .get = sve_get, + .set = sve_set, + .get_size = sve_get_size, + }, +#endif }; static const struct user_regset_view user_aarch64_view = { diff --git a/include/uapi/linux/elf.h b/include/uapi/linux/elf.h index b5280db..735b8f4 100644 --- a/include/uapi/linux/elf.h +++ b/include/uapi/linux/elf.h @@ -416,6 +416,7 @@ typedef struct elf64_shdr { #define NT_ARM_HW_BREAK 0x402 /* ARM hardware breakpoint registers */ #define NT_ARM_HW_WATCH 0x403 /* ARM hardware watchpoint registers */ #define NT_ARM_SYSTEM_CALL 0x404 /* ARM system call number */ +#define NT_ARM_SVE 0x405 /* ARM Scalable Vector Extension registers */ #define NT_METAG_CBUF 0x500 /* Metag catch buffer registers */ #define NT_METAG_RPIPE 0x501 /* Metag read pipeline state */ #define NT_METAG_TLS 0x502 /* Metag TLS pointer */ -- 2.1.4