From mboxrd@z Thu Jan 1 00:00:00 1970 From: Dave Martin Subject: [PATCH v4 01/28] regset: Add support for dynamically sized regsets Date: Fri, 27 Oct 2017 11:50:43 +0100 Message-ID: <1509101470-7881-2-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 , Oleg Nesterov , Alexander Viro , kvmarm@lists.cs.columbia.edu List-Id: linux-arch.vger.kernel.org Q3VycmVudGx5IHRoZSByZWdzZXQgQVBJIGRvZXNuJ3QgYWxsb3cgZm9yIHRoZSBwb3NzaWJpbGl0 eSB0aGF0CnJlZ3NldHMgKG9yIGF0IGxlYXN0LCB0aGUgYW1vdW50IG9mIG1lYW5pbmdmdWwgZGF0 YSBpbiBhIHJlZ3NldCkKbWF5IGNoYW5nZSBpbiBzaXplLgoKSW4gcGFydGljdWxhciwgdGhpcyBy ZXN1bHRzIGluIHVzZWxlc3MgcGFkZGluZyBiZWluZyBhZGRlZCB0bwpjb3JlZHVtcHMgaWYgYSBy ZWdzZXQncyBjdXJyZW50IHNpemUgaXMgc21hbGxlciB0aGFuIGl0cwp0aGVvcmV0aWNhbCBtYXhp bXVtIHNpemUuCgpUaGlzIHBhdGNoIGFkZHMgYSBnZXRfc2l6ZSgpIGZ1bmN0aW9uIHRvIHN0cnVj dCB1c2VyX3JlZ3NldC4KSW5kaXZpZHVhbCByZWdzZXQgaW1wbGVtZW50YXRpb25zIGNhbiBpbXBs ZW1lbnQgdGhpcyBmdW5jdGlvbiB0bwpyZXR1cm4gdGhlIGN1cnJlbnQgc2l6ZSBvZiB0aGUgcmVn c2V0IGRhdGEuICBBIHJlZ3NldF9zaXplKCkKZnVuY3Rpb24gaXMgYWRkZWQgdG8gcHJvdmlkZSBj YWxsZXJzIHdpdGggYW4gYWJzdHJhY3QgaW50ZXJmYWNlIGZvcgpkZXRlcm1pbmluZyB0aGUgc2l6 ZSBvZiBhIHJlZ3NldCB3aXRob3V0IG5lZWRpbmcgdG8ga25vdyB3aGV0aGVyCnRoZSByZWdzZXQg aXMgZHluYW1pY2FsbHkgc2l6ZWQgb3Igbm90LgoKVGhlIG9ubHkgYWZmZWN0ZWQgdXNlciBvZiB0 aGlzIGludGVyZmFjZSBpcyB0aGUgRUxGIGNvcmVkdW1wIGNvZGU6ClRoaXMgcGF0Y2ggcG9ydHMg RUxGIGNvcmVkdW1wIHRvIGR1bXAgcmVnc2V0cyB3aXRoIHRoZWlyIGFjdHVhbApzaXplIGluIHRo ZSBjb3JlZHVtcC4gIFRoaXMgaGFzIG5vIGVmZmVjdCBleGNlcHQgZm9yIG5ldyByZWdzZXRzCnRo YXQgYXJlIGR5bmFtaWNhbGx5IHNpemVkIGFuZCBwcm92aWRlIGEgZ2V0X3NpemUoKSBpbXBsZW1l bnRhdGlvbi4KClNpZ25lZC1vZmYtYnk6IERhdmUgTWFydGluIDxEYXZlLk1hcnRpbkBhcm0uY29t PgpSZXZpZXdlZC1ieTogQWxleCBCZW5uw6llIDxhbGV4LmJlbm5lZUBsaW5hcm8ub3JnPgpSZXZp ZXdlZC1ieTogQ2F0YWxpbiBNYXJpbmFzIDxjYXRhbGluLm1hcmluYXNAYXJtLmNvbT4KQ2M6IE9s ZWcgTmVzdGVyb3YgPG9sZWdAcmVkaGF0LmNvbT4KQ2M6IEFsZXhhbmRlciBWaXJvIDx2aXJvQHpl bml2LmxpbnV4Lm9yZy51az4KLS0tCiBmcy9iaW5mbXRfZWxmLmMgICAgICAgIHwgIDYgKystLS0K IGluY2x1ZGUvbGludXgvcmVnc2V0LmggfCA2NyArKysrKysrKysrKysrKysrKysrKysrKysrKysr KysrKysrKysrKysrKysrKy0tLS0tLQogMiBmaWxlcyBjaGFuZ2VkLCA2MyBpbnNlcnRpb25zKCsp LCAxMCBkZWxldGlvbnMoLSkKCmRpZmYgLS1naXQgYS9mcy9iaW5mbXRfZWxmLmMgYi9mcy9iaW5m bXRfZWxmLmMKaW5kZXggNzNiMDFlNC4uMzVhYTAzZiAxMDA2NDQKLS0tIGEvZnMvYmluZm10X2Vs Zi5jCisrKyBiL2ZzL2JpbmZtdF9lbGYuYwpAQCAtMTY5OSw3ICsxNjk5LDcgQEAgc3RhdGljIGlu dCBmaWxsX3RocmVhZF9jb3JlX2luZm8oc3RydWN0IGVsZl90aHJlYWRfY29yZV9pbmZvICp0LAog CQkJCSBsb25nIHNpZ25yLCBzaXplX3QgKnRvdGFsKQogewogCXVuc2lnbmVkIGludCBpOwotCXVu c2lnbmVkIGludCByZWdzZXRfc2l6ZSA9IHZpZXctPnJlZ3NldHNbMF0ubiAqIHZpZXctPnJlZ3Nl dHNbMF0uc2l6ZTsKKwl1bnNpZ25lZCBpbnQgc2l6ZSA9IHJlZ3NldF9zaXplKHQtPnRhc2ssICZ2 aWV3LT5yZWdzZXRzWzBdKTsKIAogCS8qCiAJICogTlRfUFJTVEFUVVMgaXMgdGhlIG9uZSBzcGVj aWFsIGNhc2UsIGJlY2F1c2UgdGhlIHJlZ3NldCBkYXRhCkBAIC0xNzA4LDcgKzE3MDgsNyBAQCBz dGF0aWMgaW50IGZpbGxfdGhyZWFkX2NvcmVfaW5mbyhzdHJ1Y3QgZWxmX3RocmVhZF9jb3JlX2lu Zm8gKnQsCiAJICogV2UgYXNzdW1lIHRoYXQgcmVnc2V0IDAgaXMgTlRfUFJTVEFUVVMuCiAJICov CiAJZmlsbF9wcnN0YXR1cygmdC0+cHJzdGF0dXMsIHQtPnRhc2ssIHNpZ25yKTsKLQkodm9pZCkg dmlldy0+cmVnc2V0c1swXS5nZXQodC0+dGFzaywgJnZpZXctPnJlZ3NldHNbMF0sIDAsIHJlZ3Nl dF9zaXplLAorCSh2b2lkKSB2aWV3LT5yZWdzZXRzWzBdLmdldCh0LT50YXNrLCAmdmlldy0+cmVn c2V0c1swXSwgMCwgc2l6ZSwKIAkJCQkgICAgJnQtPnByc3RhdHVzLnByX3JlZywgTlVMTCk7CiAK IAlmaWxsX25vdGUoJnQtPm5vdGVzWzBdLCAiQ09SRSIsIE5UX1BSU1RBVFVTLApAQCAtMTcyOCw3 ICsxNzI4LDcgQEAgc3RhdGljIGludCBmaWxsX3RocmVhZF9jb3JlX2luZm8oc3RydWN0IGVsZl90 aHJlYWRfY29yZV9pbmZvICp0LAogCQlpZiAocmVnc2V0LT5jb3JlX25vdGVfdHlwZSAmJiByZWdz ZXQtPmdldCAmJgogCQkgICAgKCFyZWdzZXQtPmFjdGl2ZSB8fCByZWdzZXQtPmFjdGl2ZSh0LT50 YXNrLCByZWdzZXQpKSkgewogCQkJaW50IHJldDsKLQkJCXNpemVfdCBzaXplID0gcmVnc2V0LT5u ICogcmVnc2V0LT5zaXplOworCQkJc2l6ZV90IHNpemUgPSByZWdzZXRfc2l6ZSh0LT50YXNrLCBy ZWdzZXQpOwogCQkJdm9pZCAqZGF0YSA9IGttYWxsb2Moc2l6ZSwgR0ZQX0tFUk5FTCk7CiAJCQlp ZiAodW5saWtlbHkoIWRhdGEpKQogCQkJCXJldHVybiAwOwpkaWZmIC0tZ2l0IGEvaW5jbHVkZS9s aW51eC9yZWdzZXQuaCBiL2luY2x1ZGUvbGludXgvcmVnc2V0LmgKaW5kZXggOGUwYzlmZS4uNDk0 Y2VkYSAxMDA2NDQKLS0tIGEvaW5jbHVkZS9saW51eC9yZWdzZXQuaAorKysgYi9pbmNsdWRlL2xp bnV4L3JlZ3NldC5oCkBAIC0xMDcsNiArMTA3LDI4IEBAIHR5cGVkZWYgaW50IHVzZXJfcmVnc2V0 X3dyaXRlYmFja19mbihzdHJ1Y3QgdGFza19zdHJ1Y3QgKnRhcmdldCwKIAkJCQkgICAgIGludCBp bW1lZGlhdGUpOwogCiAvKioKKyAqIHVzZXJfcmVnc2V0X2dldF9zaXplX2ZuIC0gdHlwZSBvZiBA Z2V0X3NpemUgZnVuY3Rpb24gaW4gJnN0cnVjdCB1c2VyX3JlZ3NldAorICogQHRhcmdldDoJdGhy ZWFkIGJlaW5nIGV4YW1pbmVkCisgKiBAcmVnc2V0OglyZWdzZXQgYmVpbmcgZXhhbWluZWQKKyAq CisgKiBUaGlzIGNhbGwgaXMgb3B0aW9uYWw7IHVzdWFsbHkgdGhlIHBvaW50ZXIgaXMgJU5VTEwu CisgKgorICogV2hlbiBwcm92aWRlZCwgdGhpcyBmdW5jdGlvbiBtdXN0IHJldHVybiB0aGUgY3Vy cmVudCBzaXplIG9mIHJlZ3NldAorICogZGF0YSwgYXMgb2JzZXJ2ZWQgYnkgdGhlIEBnZXQgZnVu Y3Rpb24gaW4gJnN0cnVjdCB1c2VyX3JlZ3NldC4gIFRoZQorICogdmFsdWUgcmV0dXJuZWQgbXVz dCBiZSBhIG11bHRpcGxlIG9mIEBzaXplLiAgVGhlIHJldHVybmVkIHNpemUgaXMKKyAqIHJlcXVp cmVkIHRvIGJlIHZhbGlkIG9ubHkgdW50aWwgdGhlIG5leHQgdGltZSAoaWYgYW55KSBAcmVnc2V0 IGlzCisgKiBtb2RpZmllZCBmb3IgQHRhcmdldC4KKyAqCisgKiBUaGlzIGZ1bmN0aW9uIGlzIGlu dGVuZGVkIGZvciBkeW5hbWljYWxseSBzaXplZCByZWdzZXRzLiAgQSByZWdzZXQKKyAqIHRoYXQg aXMgc3RhdGljYWxseSBzaXplZCBkb2VzIG5vdCBuZWVkIHRvIGltcGxlbWVudCBpdC4KKyAqCisg KiBUaGlzIGZ1bmN0aW9uIHNob3VsZCBub3QgYmUgY2FsbGVkIGRpcmVjdGx5OiBpbnN0ZWFkLCBj YWxsZXJzIHNob3VsZAorICogY2FsbCByZWdzZXRfc2l6ZSgpIHRvIGRldGVybWluZSB0aGUgY3Vy cmVudCBzaXplIG9mIGEgcmVnc2V0LgorICovCit0eXBlZGVmIHVuc2lnbmVkIGludCB1c2VyX3Jl Z3NldF9nZXRfc2l6ZV9mbihzdHJ1Y3QgdGFza19zdHJ1Y3QgKnRhcmdldCwKKwkJCQkJICAgICBj b25zdCBzdHJ1Y3QgdXNlcl9yZWdzZXQgKnJlZ3NldCk7CisKKy8qKgogICogc3RydWN0IHVzZXJf cmVnc2V0IC0gYWNjZXNzaWJsZSB0aHJlYWQgQ1BVIHN0YXRlCiAgKiBAbjoJCQlOdW1iZXIgb2Yg c2xvdHMgKHJlZ2lzdGVycykuCiAgKiBAc2l6ZToJCVNpemUgaW4gYnl0ZXMgb2YgYSBzbG90IChy ZWdpc3RlcikuCkBAIC0xMTcsMTkgKzEzOSwzMyBAQCB0eXBlZGVmIGludCB1c2VyX3JlZ3NldF93 cml0ZWJhY2tfZm4oc3RydWN0IHRhc2tfc3RydWN0ICp0YXJnZXQsCiAgKiBAc2V0OgkJRnVuY3Rp b24gdG8gc3RvcmUgdmFsdWVzLgogICogQGFjdGl2ZToJCUZ1bmN0aW9uIHRvIHJlcG9ydCBpZiBy ZWdzZXQgaXMgYWN0aXZlLCBvciAlTlVMTC4KICAqIEB3cml0ZWJhY2s6CQlGdW5jdGlvbiB0byB3 cml0ZSBkYXRhIGJhY2sgdG8gdXNlciBtZW1vcnksIG9yICVOVUxMLgorICogQGdldF9zaXplOgkJ RnVuY3Rpb24gdG8gcmV0dXJuIHRoZSByZWdzZXQncyBzaXplLCBvciAlTlVMTC4KICAqCiAgKiBU aGlzIGRhdGEgc3RydWN0dXJlIGRlc2NyaWJlcyBhIG1hY2hpbmUgcmVzb3VyY2Ugd2UgY2FsbCBh IHJlZ2lzdGVyIHNldC4KICAqIFRoaXMgaXMgcGFydCBvZiB0aGUgc3RhdGUgb2YgYW4gaW5kaXZp ZHVhbCB0aHJlYWQsIG5vdCBuZWNlc3NhcmlseQogICogYWN0dWFsIENQVSByZWdpc3RlcnMgcGVy IHNlLiAgQSByZWdpc3RlciBzZXQgY29uc2lzdHMgb2YgYSBudW1iZXIgb2YKICAqIHNpbWlsYXIg c2xvdHMsIGdpdmVuIGJ5IEBuLiAgRWFjaCBzbG90IGlzIEBzaXplIGJ5dGVzLCBhbmQgYWxpZ25l ZCB0bwotICogQGFsaWduIGJ5dGVzICh3aGljaCBpcyBhdCBsZWFzdCBAc2l6ZSkuCisgKiBAYWxp Z24gYnl0ZXMgKHdoaWNoIGlzIGF0IGxlYXN0IEBzaXplKS4gIEZvciBkeW5hbWljYWxseS1zaXpl ZAorICogcmVnc2V0cywgQG4gbXVzdCBjb250YWluIHRoZSBtYXhpbXVtIHBvc3NpYmxlIG51bWJl ciBvZiBzbG90cyBmb3IgdGhlCisgKiByZWdzZXQsIGFuZCBAZ2V0X3NpemUgbXVzdCBwb2ludCB0 byBhIGZ1bmN0aW9uIHRoYXQgcmV0dXJucyB0aGUKKyAqIGN1cnJlbnQgcmVnc2V0IHNpemUuCiAg KgotICogVGhlc2UgZnVuY3Rpb25zIG11c3QgYmUgY2FsbGVkIG9ubHkgb24gdGhlIGN1cnJlbnQg dGhyZWFkIG9yIG9uIGEKLSAqIHRocmVhZCB0aGF0IGlzIGluICVUQVNLX1NUT1BQRUQgb3IgJVRB U0tfVFJBQ0VEIHN0YXRlLCB0aGF0IHdlIGFyZQotICogZ3VhcmFudGVlZCB3aWxsIG5vdCBiZSB3 b2tlbiB1cCBhbmQgcmV0dXJuIHRvIHVzZXIgbW9kZSwgYW5kIHRoYXQgd2UKLSAqIGhhdmUgY2Fs bGVkIHdhaXRfdGFza19pbmFjdGl2ZSgpIG9uLiAgKFRoZSB0YXJnZXQgdGhyZWFkIGFsd2F5cyBt aWdodAotICogd2FrZSB1cCBmb3IgU0lHS0lMTCB3aGlsZSB0aGVzZSBmdW5jdGlvbnMgYXJlIHdv cmtpbmcsIGluIHdoaWNoIGNhc2UKLSAqIHRoYXQgdGhyZWFkJ3MgdXNlcl9yZWdzZXQgc3RhdGUg bWlnaHQgYmUgc2NyYW1ibGVkLikKKyAqIENhbGxlcnMgdGhhdCBuZWVkIHRvIGtub3cgb25seSB0 aGUgY3VycmVudCBzaXplIG9mIHRoZSByZWdzZXQgYW5kIGRvCisgKiBub3QgY2FyZSBhYm91dCBp dHMgaW50ZXJuYWwgc3RydWN0dXJlIHNob3VsZCBjYWxsIHJlZ3NldF9zaXplKCkKKyAqIGluc3Rl YWQgb2YgaW5zcGVjdGluZyBAbiBvciBjYWxsaW5nIEBnZXRfc2l6ZS4KKyAqCisgKiBGb3IgYmFj a3dhcmQgY29tcGF0aWJpbGl0eSwgdGhlIEBnZXQgYW5kIEBzZXQgbWV0aG9kcyBtdXN0IHBhZCB0 bywgb3IKKyAqIGFjY2VwdCwgQG4gKiBAc2l6ZSBieXRlcywgZXZlbiBpZiB0aGUgY3VycmVudCBy ZWdzZXQgc2l6ZSBpcyBzbWFsbGVyLgorICogVGhlIHByZWNpc2Ugc2VtYW50aWNzIG9mIHRoZXNl IG9wZXJhdGlvbnMgZGVwZW5kIG9uIHRoZSByZWdzZXQgYmVpbmcKKyAqIGFjY2Vzc2VkLgorICoK KyAqIFRoZSBmdW5jdGlvbnMgdG8gd2hpY2ggJnN0cnVjdCB1c2VyX3JlZ3NldCBtZW1iZXJzIHBv aW50IG11c3QgYmUKKyAqIGNhbGxlZCBvbmx5IG9uIHRoZSBjdXJyZW50IHRocmVhZCBvciBvbiBh IHRocmVhZCB0aGF0IGlzIGluCisgKiAlVEFTS19TVE9QUEVEIG9yICVUQVNLX1RSQUNFRCBzdGF0 ZSwgdGhhdCB3ZSBhcmUgZ3VhcmFudGVlZCB3aWxsIG5vdAorICogYmUgd29rZW4gdXAgYW5kIHJl dHVybiB0byB1c2VyIG1vZGUsIGFuZCB0aGF0IHdlIGhhdmUgY2FsbGVkCisgKiB3YWl0X3Rhc2tf aW5hY3RpdmUoKSBvbi4gIChUaGUgdGFyZ2V0IHRocmVhZCBhbHdheXMgbWlnaHQgd2FrZSB1cCBm b3IKKyAqIFNJR0tJTEwgd2hpbGUgdGhlc2UgZnVuY3Rpb25zIGFyZSB3b3JraW5nLCBpbiB3aGlj aCBjYXNlIHRoYXQKKyAqIHRocmVhZCdzIHVzZXJfcmVnc2V0IHN0YXRlIG1pZ2h0IGJlIHNjcmFt YmxlZC4pCiAgKgogICogVGhlIEBwb3MgYXJndW1lbnQgbXVzdCBiZSBhbGlnbmVkIGFjY29yZGlu ZyB0byBAYWxpZ247IHRoZSBAY291bnQKICAqIGFyZ3VtZW50IG11c3QgYmUgYSBtdWx0aXBsZSBv ZiBAc2l6ZS4gIFRoZXNlIGZ1bmN0aW9ucyBhcmUgbm90CkBAIC0xNTYsNiArMTkyLDcgQEAgc3Ry dWN0IHVzZXJfcmVnc2V0IHsKIAl1c2VyX3JlZ3NldF9zZXRfZm4JCSpzZXQ7CiAJdXNlcl9yZWdz ZXRfYWN0aXZlX2ZuCQkqYWN0aXZlOwogCXVzZXJfcmVnc2V0X3dyaXRlYmFja19mbgkqd3JpdGVi YWNrOworCXVzZXJfcmVnc2V0X2dldF9zaXplX2ZuCQkqZ2V0X3NpemU7CiAJdW5zaWduZWQgaW50 CQkJbjsKIAl1bnNpZ25lZCBpbnQgCQkJc2l6ZTsKIAl1bnNpZ25lZCBpbnQgCQkJYWxpZ247CkBA IC0zNzEsNSArNDA4LDIxIEBAIHN0YXRpYyBpbmxpbmUgaW50IGNvcHlfcmVnc2V0X2Zyb21fdXNl cihzdHJ1Y3QgdGFza19zdHJ1Y3QgKnRhcmdldCwKIAlyZXR1cm4gcmVnc2V0LT5zZXQodGFyZ2V0 LCByZWdzZXQsIG9mZnNldCwgc2l6ZSwgTlVMTCwgZGF0YSk7CiB9CiAKKy8qKgorICogcmVnc2V0 X3NpemUgLSBkZXRlcm1pbmUgdGhlIGN1cnJlbnQgc2l6ZSBvZiBhIHJlZ3NldAorICogQHRhcmdl dDoJdGhyZWFkIHRvIGJlIGV4YW1pbmVkCisgKiBAcmVnc2V0OglyZWdzZXQgdG8gYmUgZXhhbWlu ZWQKKyAqCisgKiBOb3RlIHRoYXQgdGhlIHJldHVybmVkIHNpemUgaXMgdmFsaWQgb25seSB1bnRp bCB0aGUgbmV4dCB0aW1lCisgKiAoaWYgYW55KSBAcmVnc2V0IGlzIG1vZGlmaWVkIGZvciBAdGFy Z2V0LgorICovCitzdGF0aWMgaW5saW5lIHVuc2lnbmVkIGludCByZWdzZXRfc2l6ZShzdHJ1Y3Qg dGFza19zdHJ1Y3QgKnRhcmdldCwKKwkJCQkgICAgICAgY29uc3Qgc3RydWN0IHVzZXJfcmVnc2V0 ICpyZWdzZXQpCit7CisJaWYgKCFyZWdzZXQtPmdldF9zaXplKQorCQlyZXR1cm4gcmVnc2V0LT5u ICogcmVnc2V0LT5zaXplOworCWVsc2UKKwkJcmV0dXJuIHJlZ3NldC0+Z2V0X3NpemUodGFyZ2V0 LCByZWdzZXQpOworfQogCiAjZW5kaWYJLyogPGxpbnV4L3JlZ3NldC5oPiAqLwotLSAKMi4xLjQK Cl9fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fCmt2bWFybSBt YWlsaW5nIGxpc3QKa3ZtYXJtQGxpc3RzLmNzLmNvbHVtYmlhLmVkdQpodHRwczovL2xpc3RzLmNz LmNvbHVtYmlhLmVkdS9tYWlsbWFuL2xpc3RpbmZvL2t2bWFybQo= From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from foss.arm.com ([217.140.101.70]:56690 "EHLO foss.arm.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1751176AbdJ0KvW (ORCPT ); Fri, 27 Oct 2017 06:51:22 -0400 From: Dave Martin Subject: [PATCH v4 01/28] regset: Add support for dynamically sized regsets Date: Fri, 27 Oct 2017 11:50:43 +0100 Message-ID: <1509101470-7881-2-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, Oleg Nesterov , Alexander Viro Message-ID: <20171027105043.GXDOck4gQDQ3qC6wx3OMYYls7Was6O-makiCUjeDmN8@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 if 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 Reviewed-by: Catalin Marinas Cc: Oleg Nesterov Cc: Alexander Viro --- 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