From mboxrd@z Thu Jan 1 00:00:00 1970 From: Dave Martin Subject: [PATCH v3 01/28] regset: Add support for dynamically sized regsets Date: Tue, 10 Oct 2017 19:38:18 +0100 Message-ID: <1507660725-7986-2-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 , Will Deacon , Richard Sandiford , kvmarm@lists.cs.columbia.edu List-Id: linux-arch.vger.kernel.org Q3VycmVudGx5IHRoZSByZWdzZXQgQVBJIGRvZXNuJ3QgYWxsb3cgZm9yIHRoZSBwb3NzaWJpbGl0 eSB0aGF0CnJlZ3NldHMgKG9yIGF0IGxlYXN0LCB0aGUgYW1vdW50IG9mIG1lYW5pbmdmdWwgZGF0 YSBpbiBhIHJlZ3NldCkKbWF5IGNoYW5nZSBpbiBzaXplLgoKSW4gcGFydGljdWxhciwgdGhpcyBy ZXN1bHRzIGluIHVzZWxlc3MgcGFkZGluZyBiZWluZyBhZGRlZCB0bwpjb3JlZHVtcHMgaW4gYSBy ZWdzZXQncyBjdXJyZW50IHNpemUgaXMgc21hbGxlciB0aGFuIGl0cwp0aGVvcmV0aWNhbCBtYXhp bXVtIHNpemUuCgpUaGlzIHBhdGNoIGFkZHMgYSBnZXRfc2l6ZSgpIGZ1bmN0aW9uIHRvIHN0cnVj dCB1c2VyX3JlZ3NldC4KSW5kaXZpZHVhbCByZWdzZXQgaW1wbGVtZW50YXRpb25zIGNhbiBpbXBs ZW1lbnQgdGhpcyBmdW5jdGlvbiB0bwpyZXR1cm4gdGhlIGN1cnJlbnQgc2l6ZSBvZiB0aGUgcmVn c2V0IGRhdGEuICBBIHJlZ3NldF9zaXplKCkKZnVuY3Rpb24gaXMgYWRkZWQgdG8gcHJvdmlkZSBj YWxsZXJzIHdpdGggYW4gYWJzdHJhY3QgaW50ZXJmYWNlIGZvcgpkZXRlcm1pbmluZyB0aGUgc2l6 ZSBvZiBhIHJlZ3NldCB3aXRob3V0IG5lZWRpbmcgdG8ga25vdyB3aGV0aGVyCnRoZSByZWdzZXQg aXMgZHluYW1pY2FsbHkgc2l6ZWQgb3Igbm90LgoKVGhlIG9ubHkgYWZmZWN0ZWQgdXNlciBvZiB0 aGlzIGludGVyZmFjZSBpcyB0aGUgRUxGIGNvcmVkdW1wIGNvZGU6ClRoaXMgcGF0Y2ggcG9ydHMg RUxGIGNvcmVkdW1wIHRvIGR1bXAgcmVnc2V0cyB3aXRoIHRoZWlyIGFjdHVhbApzaXplIGluIHRo ZSBjb3JlZHVtcC4gIFRoaXMgaGFzIG5vIGVmZmVjdCBleGNlcHQgZm9yIG5ldyByZWdzZXRzCnRo YXQgYXJlIGR5bmFtaWNhbGx5IHNpemVkIGFuZCBwcm92aWRlIGEgZ2V0X3NpemUoKSBpbXBsZW1l bnRhdGlvbi4KClNpZ25lZC1vZmYtYnk6IERhdmUgTWFydGluIDxEYXZlLk1hcnRpbkBhcm0uY29t PgpSZXZpZXdlZC1ieTogQWxleCBCZW5uw6llIDxhbGV4LmJlbm5lZUBsaW5hcm8ub3JnPgotLS0K IGZzL2JpbmZtdF9lbGYuYyAgICAgICAgfCAgNiArKy0tLQogaW5jbHVkZS9saW51eC9yZWdzZXQu aCB8IDY3ICsrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrLS0tLS0t CiAyIGZpbGVzIGNoYW5nZWQsIDYzIGluc2VydGlvbnMoKyksIDEwIGRlbGV0aW9ucygtKQoKZGlm ZiAtLWdpdCBhL2ZzL2JpbmZtdF9lbGYuYyBiL2ZzL2JpbmZtdF9lbGYuYwppbmRleCA3M2IwMWU0 Li4zNWFhMDNmIDEwMDY0NAotLS0gYS9mcy9iaW5mbXRfZWxmLmMKKysrIGIvZnMvYmluZm10X2Vs Zi5jCkBAIC0xNjk5LDcgKzE2OTksNyBAQCBzdGF0aWMgaW50IGZpbGxfdGhyZWFkX2NvcmVfaW5m byhzdHJ1Y3QgZWxmX3RocmVhZF9jb3JlX2luZm8gKnQsCiAJCQkJIGxvbmcgc2lnbnIsIHNpemVf dCAqdG90YWwpCiB7CiAJdW5zaWduZWQgaW50IGk7Ci0JdW5zaWduZWQgaW50IHJlZ3NldF9zaXpl ID0gdmlldy0+cmVnc2V0c1swXS5uICogdmlldy0+cmVnc2V0c1swXS5zaXplOworCXVuc2lnbmVk IGludCBzaXplID0gcmVnc2V0X3NpemUodC0+dGFzaywgJnZpZXctPnJlZ3NldHNbMF0pOwogCiAJ LyoKIAkgKiBOVF9QUlNUQVRVUyBpcyB0aGUgb25lIHNwZWNpYWwgY2FzZSwgYmVjYXVzZSB0aGUg cmVnc2V0IGRhdGEKQEAgLTE3MDgsNyArMTcwOCw3IEBAIHN0YXRpYyBpbnQgZmlsbF90aHJlYWRf Y29yZV9pbmZvKHN0cnVjdCBlbGZfdGhyZWFkX2NvcmVfaW5mbyAqdCwKIAkgKiBXZSBhc3N1bWUg dGhhdCByZWdzZXQgMCBpcyBOVF9QUlNUQVRVUy4KIAkgKi8KIAlmaWxsX3Byc3RhdHVzKCZ0LT5w cnN0YXR1cywgdC0+dGFzaywgc2lnbnIpOwotCSh2b2lkKSB2aWV3LT5yZWdzZXRzWzBdLmdldCh0 LT50YXNrLCAmdmlldy0+cmVnc2V0c1swXSwgMCwgcmVnc2V0X3NpemUsCisJKHZvaWQpIHZpZXct PnJlZ3NldHNbMF0uZ2V0KHQtPnRhc2ssICZ2aWV3LT5yZWdzZXRzWzBdLCAwLCBzaXplLAogCQkJ CSAgICAmdC0+cHJzdGF0dXMucHJfcmVnLCBOVUxMKTsKIAogCWZpbGxfbm90ZSgmdC0+bm90ZXNb MF0sICJDT1JFIiwgTlRfUFJTVEFUVVMsCkBAIC0xNzI4LDcgKzE3MjgsNyBAQCBzdGF0aWMgaW50 IGZpbGxfdGhyZWFkX2NvcmVfaW5mbyhzdHJ1Y3QgZWxmX3RocmVhZF9jb3JlX2luZm8gKnQsCiAJ CWlmIChyZWdzZXQtPmNvcmVfbm90ZV90eXBlICYmIHJlZ3NldC0+Z2V0ICYmCiAJCSAgICAoIXJl Z3NldC0+YWN0aXZlIHx8IHJlZ3NldC0+YWN0aXZlKHQtPnRhc2ssIHJlZ3NldCkpKSB7CiAJCQlp bnQgcmV0OwotCQkJc2l6ZV90IHNpemUgPSByZWdzZXQtPm4gKiByZWdzZXQtPnNpemU7CisJCQlz aXplX3Qgc2l6ZSA9IHJlZ3NldF9zaXplKHQtPnRhc2ssIHJlZ3NldCk7CiAJCQl2b2lkICpkYXRh ID0ga21hbGxvYyhzaXplLCBHRlBfS0VSTkVMKTsKIAkJCWlmICh1bmxpa2VseSghZGF0YSkpCiAJ CQkJcmV0dXJuIDA7CmRpZmYgLS1naXQgYS9pbmNsdWRlL2xpbnV4L3JlZ3NldC5oIGIvaW5jbHVk ZS9saW51eC9yZWdzZXQuaAppbmRleCA4ZTBjOWZlLi40OTRjZWRhIDEwMDY0NAotLS0gYS9pbmNs dWRlL2xpbnV4L3JlZ3NldC5oCisrKyBiL2luY2x1ZGUvbGludXgvcmVnc2V0LmgKQEAgLTEwNyw2 ICsxMDcsMjggQEAgdHlwZWRlZiBpbnQgdXNlcl9yZWdzZXRfd3JpdGViYWNrX2ZuKHN0cnVjdCB0 YXNrX3N0cnVjdCAqdGFyZ2V0LAogCQkJCSAgICAgaW50IGltbWVkaWF0ZSk7CiAKIC8qKgorICog dXNlcl9yZWdzZXRfZ2V0X3NpemVfZm4gLSB0eXBlIG9mIEBnZXRfc2l6ZSBmdW5jdGlvbiBpbiAm c3RydWN0IHVzZXJfcmVnc2V0CisgKiBAdGFyZ2V0Ogl0aHJlYWQgYmVpbmcgZXhhbWluZWQKKyAq IEByZWdzZXQ6CXJlZ3NldCBiZWluZyBleGFtaW5lZAorICoKKyAqIFRoaXMgY2FsbCBpcyBvcHRp b25hbDsgdXN1YWxseSB0aGUgcG9pbnRlciBpcyAlTlVMTC4KKyAqCisgKiBXaGVuIHByb3ZpZGVk LCB0aGlzIGZ1bmN0aW9uIG11c3QgcmV0dXJuIHRoZSBjdXJyZW50IHNpemUgb2YgcmVnc2V0Cisg KiBkYXRhLCBhcyBvYnNlcnZlZCBieSB0aGUgQGdldCBmdW5jdGlvbiBpbiAmc3RydWN0IHVzZXJf cmVnc2V0LiAgVGhlCisgKiB2YWx1ZSByZXR1cm5lZCBtdXN0IGJlIGEgbXVsdGlwbGUgb2YgQHNp emUuICBUaGUgcmV0dXJuZWQgc2l6ZSBpcworICogcmVxdWlyZWQgdG8gYmUgdmFsaWQgb25seSB1 bnRpbCB0aGUgbmV4dCB0aW1lIChpZiBhbnkpIEByZWdzZXQgaXMKKyAqIG1vZGlmaWVkIGZvciBA dGFyZ2V0LgorICoKKyAqIFRoaXMgZnVuY3Rpb24gaXMgaW50ZW5kZWQgZm9yIGR5bmFtaWNhbGx5 IHNpemVkIHJlZ3NldHMuICBBIHJlZ3NldAorICogdGhhdCBpcyBzdGF0aWNhbGx5IHNpemVkIGRv ZXMgbm90IG5lZWQgdG8gaW1wbGVtZW50IGl0LgorICoKKyAqIFRoaXMgZnVuY3Rpb24gc2hvdWxk IG5vdCBiZSBjYWxsZWQgZGlyZWN0bHk6IGluc3RlYWQsIGNhbGxlcnMgc2hvdWxkCisgKiBjYWxs IHJlZ3NldF9zaXplKCkgdG8gZGV0ZXJtaW5lIHRoZSBjdXJyZW50IHNpemUgb2YgYSByZWdzZXQu CisgKi8KK3R5cGVkZWYgdW5zaWduZWQgaW50IHVzZXJfcmVnc2V0X2dldF9zaXplX2ZuKHN0cnVj dCB0YXNrX3N0cnVjdCAqdGFyZ2V0LAorCQkJCQkgICAgIGNvbnN0IHN0cnVjdCB1c2VyX3JlZ3Nl dCAqcmVnc2V0KTsKKworLyoqCiAgKiBzdHJ1Y3QgdXNlcl9yZWdzZXQgLSBhY2Nlc3NpYmxlIHRo cmVhZCBDUFUgc3RhdGUKICAqIEBuOgkJCU51bWJlciBvZiBzbG90cyAocmVnaXN0ZXJzKS4KICAq IEBzaXplOgkJU2l6ZSBpbiBieXRlcyBvZiBhIHNsb3QgKHJlZ2lzdGVyKS4KQEAgLTExNywxOSAr MTM5LDMzIEBAIHR5cGVkZWYgaW50IHVzZXJfcmVnc2V0X3dyaXRlYmFja19mbihzdHJ1Y3QgdGFz a19zdHJ1Y3QgKnRhcmdldCwKICAqIEBzZXQ6CQlGdW5jdGlvbiB0byBzdG9yZSB2YWx1ZXMuCiAg KiBAYWN0aXZlOgkJRnVuY3Rpb24gdG8gcmVwb3J0IGlmIHJlZ3NldCBpcyBhY3RpdmUsIG9yICVO VUxMLgogICogQHdyaXRlYmFjazoJCUZ1bmN0aW9uIHRvIHdyaXRlIGRhdGEgYmFjayB0byB1c2Vy IG1lbW9yeSwgb3IgJU5VTEwuCisgKiBAZ2V0X3NpemU6CQlGdW5jdGlvbiB0byByZXR1cm4gdGhl IHJlZ3NldCdzIHNpemUsIG9yICVOVUxMLgogICoKICAqIFRoaXMgZGF0YSBzdHJ1Y3R1cmUgZGVz Y3JpYmVzIGEgbWFjaGluZSByZXNvdXJjZSB3ZSBjYWxsIGEgcmVnaXN0ZXIgc2V0LgogICogVGhp cyBpcyBwYXJ0IG9mIHRoZSBzdGF0ZSBvZiBhbiBpbmRpdmlkdWFsIHRocmVhZCwgbm90IG5lY2Vz c2FyaWx5CiAgKiBhY3R1YWwgQ1BVIHJlZ2lzdGVycyBwZXIgc2UuICBBIHJlZ2lzdGVyIHNldCBj b25zaXN0cyBvZiBhIG51bWJlciBvZgogICogc2ltaWxhciBzbG90cywgZ2l2ZW4gYnkgQG4uICBF YWNoIHNsb3QgaXMgQHNpemUgYnl0ZXMsIGFuZCBhbGlnbmVkIHRvCi0gKiBAYWxpZ24gYnl0ZXMg KHdoaWNoIGlzIGF0IGxlYXN0IEBzaXplKS4KKyAqIEBhbGlnbiBieXRlcyAod2hpY2ggaXMgYXQg bGVhc3QgQHNpemUpLiAgRm9yIGR5bmFtaWNhbGx5LXNpemVkCisgKiByZWdzZXRzLCBAbiBtdXN0 IGNvbnRhaW4gdGhlIG1heGltdW0gcG9zc2libGUgbnVtYmVyIG9mIHNsb3RzIGZvciB0aGUKKyAq IHJlZ3NldCwgYW5kIEBnZXRfc2l6ZSBtdXN0IHBvaW50IHRvIGEgZnVuY3Rpb24gdGhhdCByZXR1 cm5zIHRoZQorICogY3VycmVudCByZWdzZXQgc2l6ZS4KICAqCi0gKiBUaGVzZSBmdW5jdGlvbnMg bXVzdCBiZSBjYWxsZWQgb25seSBvbiB0aGUgY3VycmVudCB0aHJlYWQgb3Igb24gYQotICogdGhy ZWFkIHRoYXQgaXMgaW4gJVRBU0tfU1RPUFBFRCBvciAlVEFTS19UUkFDRUQgc3RhdGUsIHRoYXQg d2UgYXJlCi0gKiBndWFyYW50ZWVkIHdpbGwgbm90IGJlIHdva2VuIHVwIGFuZCByZXR1cm4gdG8g dXNlciBtb2RlLCBhbmQgdGhhdCB3ZQotICogaGF2ZSBjYWxsZWQgd2FpdF90YXNrX2luYWN0aXZl KCkgb24uICAoVGhlIHRhcmdldCB0aHJlYWQgYWx3YXlzIG1pZ2h0Ci0gKiB3YWtlIHVwIGZvciBT SUdLSUxMIHdoaWxlIHRoZXNlIGZ1bmN0aW9ucyBhcmUgd29ya2luZywgaW4gd2hpY2ggY2FzZQot ICogdGhhdCB0aHJlYWQncyB1c2VyX3JlZ3NldCBzdGF0ZSBtaWdodCBiZSBzY3JhbWJsZWQuKQor ICogQ2FsbGVycyB0aGF0IG5lZWQgdG8ga25vdyBvbmx5IHRoZSBjdXJyZW50IHNpemUgb2YgdGhl IHJlZ3NldCBhbmQgZG8KKyAqIG5vdCBjYXJlIGFib3V0IGl0cyBpbnRlcm5hbCBzdHJ1Y3R1cmUg c2hvdWxkIGNhbGwgcmVnc2V0X3NpemUoKQorICogaW5zdGVhZCBvZiBpbnNwZWN0aW5nIEBuIG9y IGNhbGxpbmcgQGdldF9zaXplLgorICoKKyAqIEZvciBiYWNrd2FyZCBjb21wYXRpYmlsaXR5LCB0 aGUgQGdldCBhbmQgQHNldCBtZXRob2RzIG11c3QgcGFkIHRvLCBvcgorICogYWNjZXB0LCBAbiAq IEBzaXplIGJ5dGVzLCBldmVuIGlmIHRoZSBjdXJyZW50IHJlZ3NldCBzaXplIGlzIHNtYWxsZXIu CisgKiBUaGUgcHJlY2lzZSBzZW1hbnRpY3Mgb2YgdGhlc2Ugb3BlcmF0aW9ucyBkZXBlbmQgb24g dGhlIHJlZ3NldCBiZWluZworICogYWNjZXNzZWQuCisgKgorICogVGhlIGZ1bmN0aW9ucyB0byB3 aGljaCAmc3RydWN0IHVzZXJfcmVnc2V0IG1lbWJlcnMgcG9pbnQgbXVzdCBiZQorICogY2FsbGVk IG9ubHkgb24gdGhlIGN1cnJlbnQgdGhyZWFkIG9yIG9uIGEgdGhyZWFkIHRoYXQgaXMgaW4KKyAq ICVUQVNLX1NUT1BQRUQgb3IgJVRBU0tfVFJBQ0VEIHN0YXRlLCB0aGF0IHdlIGFyZSBndWFyYW50 ZWVkIHdpbGwgbm90CisgKiBiZSB3b2tlbiB1cCBhbmQgcmV0dXJuIHRvIHVzZXIgbW9kZSwgYW5k IHRoYXQgd2UgaGF2ZSBjYWxsZWQKKyAqIHdhaXRfdGFza19pbmFjdGl2ZSgpIG9uLiAgKFRoZSB0 YXJnZXQgdGhyZWFkIGFsd2F5cyBtaWdodCB3YWtlIHVwIGZvcgorICogU0lHS0lMTCB3aGlsZSB0 aGVzZSBmdW5jdGlvbnMgYXJlIHdvcmtpbmcsIGluIHdoaWNoIGNhc2UgdGhhdAorICogdGhyZWFk J3MgdXNlcl9yZWdzZXQgc3RhdGUgbWlnaHQgYmUgc2NyYW1ibGVkLikKICAqCiAgKiBUaGUgQHBv cyBhcmd1bWVudCBtdXN0IGJlIGFsaWduZWQgYWNjb3JkaW5nIHRvIEBhbGlnbjsgdGhlIEBjb3Vu dAogICogYXJndW1lbnQgbXVzdCBiZSBhIG11bHRpcGxlIG9mIEBzaXplLiAgVGhlc2UgZnVuY3Rp b25zIGFyZSBub3QKQEAgLTE1Niw2ICsxOTIsNyBAQCBzdHJ1Y3QgdXNlcl9yZWdzZXQgewogCXVz ZXJfcmVnc2V0X3NldF9mbgkJKnNldDsKIAl1c2VyX3JlZ3NldF9hY3RpdmVfZm4JCSphY3RpdmU7 CiAJdXNlcl9yZWdzZXRfd3JpdGViYWNrX2ZuCSp3cml0ZWJhY2s7CisJdXNlcl9yZWdzZXRfZ2V0 X3NpemVfZm4JCSpnZXRfc2l6ZTsKIAl1bnNpZ25lZCBpbnQJCQluOwogCXVuc2lnbmVkIGludCAJ CQlzaXplOwogCXVuc2lnbmVkIGludCAJCQlhbGlnbjsKQEAgLTM3MSw1ICs0MDgsMjEgQEAgc3Rh dGljIGlubGluZSBpbnQgY29weV9yZWdzZXRfZnJvbV91c2VyKHN0cnVjdCB0YXNrX3N0cnVjdCAq dGFyZ2V0LAogCXJldHVybiByZWdzZXQtPnNldCh0YXJnZXQsIHJlZ3NldCwgb2Zmc2V0LCBzaXpl LCBOVUxMLCBkYXRhKTsKIH0KIAorLyoqCisgKiByZWdzZXRfc2l6ZSAtIGRldGVybWluZSB0aGUg Y3VycmVudCBzaXplIG9mIGEgcmVnc2V0CisgKiBAdGFyZ2V0Ogl0aHJlYWQgdG8gYmUgZXhhbWlu ZWQKKyAqIEByZWdzZXQ6CXJlZ3NldCB0byBiZSBleGFtaW5lZAorICoKKyAqIE5vdGUgdGhhdCB0 aGUgcmV0dXJuZWQgc2l6ZSBpcyB2YWxpZCBvbmx5IHVudGlsIHRoZSBuZXh0IHRpbWUKKyAqIChp ZiBhbnkpIEByZWdzZXQgaXMgbW9kaWZpZWQgZm9yIEB0YXJnZXQuCisgKi8KK3N0YXRpYyBpbmxp bmUgdW5zaWduZWQgaW50IHJlZ3NldF9zaXplKHN0cnVjdCB0YXNrX3N0cnVjdCAqdGFyZ2V0LAor CQkJCSAgICAgICBjb25zdCBzdHJ1Y3QgdXNlcl9yZWdzZXQgKnJlZ3NldCkKK3sKKwlpZiAoIXJl Z3NldC0+Z2V0X3NpemUpCisJCXJldHVybiByZWdzZXQtPm4gKiByZWdzZXQtPnNpemU7CisJZWxz ZQorCQlyZXR1cm4gcmVnc2V0LT5nZXRfc2l6ZSh0YXJnZXQsIHJlZ3NldCk7Cit9CiAKICNlbmRp ZgkvKiA8bGludXgvcmVnc2V0Lmg+ICovCi0tIAoyLjEuNAoKX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fX18Ka3ZtYXJtIG1haWxpbmcgbGlzdAprdm1hcm1AbGlz dHMuY3MuY29sdW1iaWEuZWR1Cmh0dHBzOi8vbGlzdHMuY3MuY29sdW1iaWEuZWR1L21haWxtYW4v bGlzdGluZm8va3ZtYXJtCg== 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]:48794 "EHLO foss.arm.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1756578AbdJJSi5 (ORCPT ); Tue, 10 Oct 2017 14:38:57 -0400 From: Dave Martin Subject: [PATCH v3 01/28] regset: Add support for dynamically sized regsets Date: Tue, 10 Oct 2017 19:38:18 +0100 Message-ID: <1507660725-7986-2-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 Message-ID: <20171010183818.PQx6nfj6StdlRl8st3e0mqanE4qUyVcp8xY3kHre2fc@z> Currently the regset API doesn't allow for the possibility that regsets (or at least, the amount of meaningful data in a regset) may change in size. In particular, this results in useless padding being added to coredumps in a regset's current size is smaller than its theoretical maximum size. This patch adds a get_size() function to struct user_regset. Individual regset implementations can implement this function to return the current size of the regset data. A regset_size() function is added to provide callers with an abstract interface for determining the size of a regset without needing to know whether the regset is dynamically sized or not. The only affected user of this interface is the ELF coredump code: This patch ports ELF coredump to dump regsets with their actual size in the coredump. This has no effect except for new regsets that are dynamically sized and provide a get_size() implementation. Signed-off-by: Dave Martin Reviewed-by: Alex Bennée --- fs/binfmt_elf.c | 6 ++--- include/linux/regset.h | 67 ++++++++++++++++++++++++++++++++++++++++++++------ 2 files changed, 63 insertions(+), 10 deletions(-) diff --git a/fs/binfmt_elf.c b/fs/binfmt_elf.c index 73b01e4..35aa03f 100644 --- a/fs/binfmt_elf.c +++ b/fs/binfmt_elf.c @@ -1699,7 +1699,7 @@ static int fill_thread_core_info(struct elf_thread_core_info *t, long signr, size_t *total) { unsigned int i; - unsigned int regset_size = view->regsets[0].n * view->regsets[0].size; + unsigned int size = regset_size(t->task, &view->regsets[0]); /* * NT_PRSTATUS is the one special case, because the regset data @@ -1708,7 +1708,7 @@ static int fill_thread_core_info(struct elf_thread_core_info *t, * We assume that regset 0 is NT_PRSTATUS. */ fill_prstatus(&t->prstatus, t->task, signr); - (void) view->regsets[0].get(t->task, &view->regsets[0], 0, regset_size, + (void) view->regsets[0].get(t->task, &view->regsets[0], 0, size, &t->prstatus.pr_reg, NULL); fill_note(&t->notes[0], "CORE", NT_PRSTATUS, @@ -1728,7 +1728,7 @@ static int fill_thread_core_info(struct elf_thread_core_info *t, if (regset->core_note_type && regset->get && (!regset->active || regset->active(t->task, regset))) { int ret; - size_t size = regset->n * regset->size; + size_t size = regset_size(t->task, regset); void *data = kmalloc(size, GFP_KERNEL); if (unlikely(!data)) return 0; diff --git a/include/linux/regset.h b/include/linux/regset.h index 8e0c9fe..494ceda 100644 --- a/include/linux/regset.h +++ b/include/linux/regset.h @@ -107,6 +107,28 @@ typedef int user_regset_writeback_fn(struct task_struct *target, int immediate); /** + * user_regset_get_size_fn - type of @get_size function in &struct user_regset + * @target: thread being examined + * @regset: regset being examined + * + * This call is optional; usually the pointer is %NULL. + * + * When provided, this function must return the current size of regset + * data, as observed by the @get function in &struct user_regset. The + * value returned must be a multiple of @size. The returned size is + * required to be valid only until the next time (if any) @regset is + * modified for @target. + * + * This function is intended for dynamically sized regsets. A regset + * that is statically sized does not need to implement it. + * + * This function should not be called directly: instead, callers should + * call regset_size() to determine the current size of a regset. + */ +typedef unsigned int user_regset_get_size_fn(struct task_struct *target, + const struct user_regset *regset); + +/** * struct user_regset - accessible thread CPU state * @n: Number of slots (registers). * @size: Size in bytes of a slot (register). @@ -117,19 +139,33 @@ typedef int user_regset_writeback_fn(struct task_struct *target, * @set: Function to store values. * @active: Function to report if regset is active, or %NULL. * @writeback: Function to write data back to user memory, or %NULL. + * @get_size: Function to return the regset's size, or %NULL. * * This data structure describes a machine resource we call a register set. * This is part of the state of an individual thread, not necessarily * actual CPU registers per se. A register set consists of a number of * similar slots, given by @n. Each slot is @size bytes, and aligned to - * @align bytes (which is at least @size). + * @align bytes (which is at least @size). For dynamically-sized + * regsets, @n must contain the maximum possible number of slots for the + * regset, and @get_size must point to a function that returns the + * current regset size. * - * These functions must be called only on the current thread or on a - * thread that is in %TASK_STOPPED or %TASK_TRACED state, that we are - * guaranteed will not be woken up and return to user mode, and that we - * have called wait_task_inactive() on. (The target thread always might - * wake up for SIGKILL while these functions are working, in which case - * that thread's user_regset state might be scrambled.) + * Callers that need to know only the current size of the regset and do + * not care about its internal structure should call regset_size() + * instead of inspecting @n or calling @get_size. + * + * For backward compatibility, the @get and @set methods must pad to, or + * accept, @n * @size bytes, even if the current regset size is smaller. + * The precise semantics of these operations depend on the regset being + * accessed. + * + * The functions to which &struct user_regset members point must be + * called only on the current thread or on a thread that is in + * %TASK_STOPPED or %TASK_TRACED state, that we are guaranteed will not + * be woken up and return to user mode, and that we have called + * wait_task_inactive() on. (The target thread always might wake up for + * SIGKILL while these functions are working, in which case that + * thread's user_regset state might be scrambled.) * * The @pos argument must be aligned according to @align; the @count * argument must be a multiple of @size. These functions are not @@ -156,6 +192,7 @@ struct user_regset { user_regset_set_fn *set; user_regset_active_fn *active; user_regset_writeback_fn *writeback; + user_regset_get_size_fn *get_size; unsigned int n; unsigned int size; unsigned int align; @@ -371,5 +408,21 @@ static inline int copy_regset_from_user(struct task_struct *target, return regset->set(target, regset, offset, size, NULL, data); } +/** + * regset_size - determine the current size of a regset + * @target: thread to be examined + * @regset: regset to be examined + * + * Note that the returned size is valid only until the next time + * (if any) @regset is modified for @target. + */ +static inline unsigned int regset_size(struct task_struct *target, + const struct user_regset *regset) +{ + if (!regset->get_size) + return regset->n * regset->size; + else + return regset->get_size(target, regset); +} #endif /* */ -- 2.1.4