From mboxrd@z Thu Jan 1 00:00:00 1970 From: Joe Perches Subject: rfc: remove print_vma_addr ? (was Re: [PATCH 00/16] remove eight obsolete architectures) Date: Thu, 15 Mar 2018 09:56:46 -0700 Message-ID: <1521133006.22221.35.camel@perches.com> References: <20180314143529.1456168-1-arnd@arndb.de> <2929.1521106970@warthog.procyon.org.uk> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Return-path: In-Reply-To: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: dri-devel-bounces@lists.freedesktop.org Sender: "dri-devel" To: Geert Uytterhoeven , David Howells Cc: Linux-Arch , Linux PWM List , Linux Fbdev development list , Linux Watchdog Mailing List , Arnd Bergmann , linux-doc@vger.kernel.org, netdev , USB list , linux-wireless , Linux Kernel Mailing List , DRI Development , linux-spi , linux-block@vger.kernel.org, linux-ide@vger.kernel.org, linux-input@vger.kernel.org, Linux FS Devel , Linux MM , linux-rtc@vger.kernel.org List-Id: linux-arch.vger.kernel.org T24gVGh1LCAyMDE4LTAzLTE1IGF0IDEwOjQ4ICswMTAwLCBHZWVydCBVeXR0ZXJob2V2ZW4gd3Jv dGU6Cj4gSGkgRGF2aWQsCj4gCj4gT24gVGh1LCBNYXIgMTUsIDIwMTggYXQgMTA6NDIgQU0sIERh dmlkIEhvd2VsbHMgPGRob3dlbGxzQHJlZGhhdC5jb20+IHdyb3RlOgo+ID4gRG8gd2UgaGF2ZSBh bnl0aGluZyBsZWZ0IHRoYXQgc3RpbGwgaW1wbGVtZW50cyBOT01NVT8KPiAKPiBTdXJlOiBhcm0s IGM2eCwgbTY4aywgbWljcm9ibGF6ZSwgYW5kICBzaC4KCkkgaGF2ZSBhIHBhdGNoc2V0IHRoYXQg Y3JlYXRlcyBhIHZzcHJpbnRmIGV4dGVuc2lvbiBmb3IKcHJpbnRfdm1hX2FkZHIgYW5kIHJlbW92 ZXMgYWxsIHRoZSB1c2VzIHNpbWlsYXIgdG8gdGhlCnByaW50X3N5bWJvbCgpIHJlbW92YWwuCgpU aGlzIG5vdyBhdm9pZHMgYW55IHBvc3NpYmxlIHByaW50ayBpbnRlcmxlYXZpbmcuCgpVbmZvcnR1 bmF0ZWx5LCB3aXRob3V0IHNvbWUgI2lmZGVmIGluIHZzcHJpbnRmLCB3aGljaApJIHdvdWxkIGxp a2UgdG8gYXZvaWQsIGl0IGluY3JlYXNlcyB0aGUgbm9tbXUga2VybmVsCnNpemUgYnkgfjUwMCBi eXRlcy4KCkFueW9uZSB0aGluayB0aGlzIGlzIGFjY2VwdGFibGU/CgpIZXJlJ3MgdGhlIG92ZXJh bGwgcGF0Y2gsIGJ1dCBJIGhhdmUgaXQgYXMgYSBzZXJpZXMKLS0tCiBEb2N1bWVudGF0aW9uL2Nv cmUtYXBpL3ByaW50ay1mb3JtYXRzLnJzdCB8ICA5ICsrKysrCiBhcmNoL2FybTY0L2tlcm5lbC90 cmFwcy5jICAgICAgICAgICAgICAgICB8IDEzICsrKy0tLS0KIGFyY2gvbWlwcy9tbS9mYXVsdC5j ICAgICAgICAgICAgICAgICAgICAgIHwgMTYgKysrKy0tLS0tCiBhcmNoL3BhcmlzYy9tbS9mYXVs dC5jICAgICAgICAgICAgICAgICAgICB8IDE1ICsrKystLS0tCiBhcmNoL3Jpc2N2L2tlcm5lbC90 cmFwcy5jICAgICAgICAgICAgICAgICB8IDExICsrKy0tLQogYXJjaC9zMzkwL21tL2ZhdWx0LmMg ICAgICAgICAgICAgICAgICAgICAgfCAgNyArKy0tCiBhcmNoL3NwYXJjL21tL2ZhdWx0XzMyLmMg ICAgICAgICAgICAgICAgICB8ICA4ICsrLS0tCiBhcmNoL3NwYXJjL21tL2ZhdWx0XzY0LmMgICAg ICAgICAgICAgICAgICB8ICA4ICsrLS0tCiBhcmNoL3RpbGUva2VybmVsL3NpZ25hbC5jICAgICAg ICAgICAgICAgICB8ICA5ICsrLS0tCiBhcmNoL3VtL2tlcm5lbC90cmFwLmMgICAgICAgICAgICAg ICAgICAgICB8IDEzICsrKy0tLS0KIGFyY2gveDg2L2tlcm5lbC9zaWduYWwuYyAgICAgICAgICAg ICAgICAgIHwgMTAgKystLS0tCiBhcmNoL3g4Ni9rZXJuZWwvdHJhcHMuYyAgICAgICAgICAgICAg ICAgICB8IDE4ICsrKystLS0tLS0KIGFyY2gveDg2L21tL2ZhdWx0LmMgICAgICAgICAgICAgICAg ICAgICAgIHwgMTIgKysrLS0tLQogaW5jbHVkZS9saW51eC9tbS5oICAgICAgICAgICAgICAgICAg ICAgICAgfCAgMSAtCiBsaWIvdnNwcmludGYuYyAgICAgICAgICAgICAgICAgICAgICAgICAgICB8 IDU4ICsrKysrKysrKysrKysrKysrKysrKysrKysrLS0tLS0KIG1tL21lbW9yeS5jICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgIHwgMzMgLS0tLS0tLS0tLS0tLS0tLS0tCiAxNiBmaWxlcyBj aGFuZ2VkLCAxMTIgaW5zZXJ0aW9ucygrKSwgMTI5IGRlbGV0aW9ucygtKQoKZGlmZiAtLWdpdCBh L0RvY3VtZW50YXRpb24vY29yZS1hcGkvcHJpbnRrLWZvcm1hdHMucnN0IGIvRG9jdW1lbnRhdGlv bi9jb3JlLWFwaS9wcmludGstZm9ybWF0cy5yc3QKaW5kZXggOTM0NTU5YjNjMTMwLi4xMGE5MWRh MWJjODMgMTAwNjQ0Ci0tLSBhL0RvY3VtZW50YXRpb24vY29yZS1hcGkvcHJpbnRrLWZvcm1hdHMu cnN0CisrKyBiL0RvY3VtZW50YXRpb24vY29yZS1hcGkvcHJpbnRrLWZvcm1hdHMucnN0CkBAIC0x NTcsNiArMTU3LDE1IEBAIERNQSBhZGRyZXNzIHR5cGVzIGRtYV9hZGRyX3QKIEZvciBwcmludGlu ZyBhIGRtYV9hZGRyX3QgdHlwZSB3aGljaCBjYW4gdmFyeSBiYXNlZCBvbiBidWlsZCBvcHRpb25z LAogcmVnYXJkbGVzcyBvZiB0aGUgd2lkdGggb2YgdGhlIENQVSBkYXRhIHBhdGguCiAKK1ZNQSBu YW1lIGFuZCBhZGRyZXNzCistLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tCisKKzo6CisKKwkl cGF2CTxuYW1lPltoZXhzdGFydCtoZXhzaXplXSBvciA/WzArMF0gaWYgdW5hdmFpbGFibGUKKwor Rm9yIGFueSBhZGRyZXNzLCBwcmludCB0aGUgdm1hJ3MgbmFtZSBhbmQgaXRzIHN0YXJ0aW5nIGFk ZHJlc3MgYW5kIHNpemUKKwogUGFzc2VkIGJ5IHJlZmVyZW5jZS4KIAogUmF3IGJ1ZmZlciBhcyBh biBlc2NhcGVkIHN0cmluZwpkaWZmIC0tZ2l0IGEvYXJjaC9hcm02NC9rZXJuZWwvdHJhcHMuYyBi L2FyY2gvYXJtNjQva2VybmVsL3RyYXBzLmMKaW5kZXggMmI0Nzg1NjVkNzc0Li40OGVkZjgxMmNl OGIgMTAwNjQ0Ci0tLSBhL2FyY2gvYXJtNjQva2VybmVsL3RyYXBzLmMKKysrIGIvYXJjaC9hcm02 NC9rZXJuZWwvdHJhcHMuYwpAQCAtMjQyLDEzICsyNDIsMTQgQEAgdm9pZCBhcm02NF9mb3JjZV9z aWdfaW5mbyhzdHJ1Y3Qgc2lnaW5mbyAqaW5mbywgY29uc3QgY2hhciAqc3RyLAogCWlmICghc2hv d191bmhhbmRsZWRfc2lnbmFsc19yYXRlbGltaXRlZCgpKQogCQlnb3RvIHNlbmRfc2lnOwogCi0J cHJfaW5mbygiJXNbJWRdOiB1bmhhbmRsZWQgZXhjZXB0aW9uOiAiLCB0c2stPmNvbW0sIHRhc2tf cGlkX25yKHRzaykpOwogCWlmIChlc3IpCi0JCXByX2NvbnQoIiVzLCBFU1IgMHglMDh4LCAiLCBl c3JfZ2V0X2NsYXNzX3N0cmluZyhlc3IpLCBlc3IpOwotCi0JcHJfY29udCgiJXMiLCBzdHIpOwot CXByaW50X3ZtYV9hZGRyKEtFUk5fQ09OVCAiIGluICIsIHJlZ3MtPnBjKTsKLQlwcl9jb250KCJc biIpOworCQlwcl9pbmZvKCIlc1slZF06IHVuaGFuZGxlZCBleGNlcHRpb246ICVzLCBFU1IgMHgl MDh4LCAlcyBpbiAlcGF2XG4iLAorCQkJdHNrLT5jb21tLCB0YXNrX3BpZF9ucih0c2spLAorCQkJ ZXNyX2dldF9jbGFzc19zdHJpbmcoZXNyKSwgZXNyLAorCQkJc3RyLCAmcmVncy0+cGMpOworCWVs c2UKKwkJcHJfaW5mbygiJXNbJWRdOiB1bmhhbmRsZWQgZXhjZXB0aW9uOiAlcyBpbiAlcGF2XG4i LAorCQkJdHNrLT5jb21tLCB0YXNrX3BpZF9ucih0c2spLCBzdHIsICZyZWdzLT5wYyk7CiAJX19z aG93X3JlZ3MocmVncyk7CiAKIHNlbmRfc2lnOgpkaWZmIC0tZ2l0IGEvYXJjaC9taXBzL21tL2Zh dWx0LmMgYi9hcmNoL21pcHMvbW0vZmF1bHQuYwppbmRleCA0ZjhmNWJmNDY5NzcuLmNlN2JmMDc3 YTBmNSAxMDA2NDQKLS0tIGEvYXJjaC9taXBzL21tL2ZhdWx0LmMKKysrIGIvYXJjaC9taXBzL21t L2ZhdWx0LmMKQEAgLTIxMywxNCArMjEzLDE0IEBAIHN0YXRpYyB2b2lkIF9fa3Byb2JlcyBfX2Rv X3BhZ2VfZmF1bHQoc3RydWN0IHB0X3JlZ3MgKnJlZ3MsIHVuc2lnbmVkIGxvbmcgd3JpdGUsCiAJ CQkJdHNrLT5jb21tLAogCQkJCXdyaXRlID8gIndyaXRlIGFjY2VzcyB0byIgOiAicmVhZCBhY2Nl c3MgZnJvbSIsCiAJCQkJZmllbGQsIGFkZHJlc3MpOwotCQkJcHJfaW5mbygiZXBjID0gJTAqbHgg aW4iLCBmaWVsZCwKLQkJCQkodW5zaWduZWQgbG9uZykgcmVncy0+Y3AwX2VwYyk7Ci0JCQlwcmlu dF92bWFfYWRkcihLRVJOX0NPTlQgIiAiLCByZWdzLT5jcDBfZXBjKTsKLQkJCXByX2NvbnQoIlxu Iik7Ci0JCQlwcl9pbmZvKCJyYSAgPSAlMCpseCBpbiIsIGZpZWxkLAotCQkJCSh1bnNpZ25lZCBs b25nKSByZWdzLT5yZWdzWzMxXSk7Ci0JCQlwcmludF92bWFfYWRkcihLRVJOX0NPTlQgIiAiLCBy ZWdzLT5yZWdzWzMxXSk7Ci0JCQlwcl9jb250KCJcbiIpOworCQkJcHJfaW5mbygiZXBjID0gJTAq bHggaW4gJXBhdlxuIiwKKwkJCQlmaWVsZCwKKwkJCQkodW5zaWduZWQgbG9uZylyZWdzLT5jcDBf ZXBjLAorCQkJCSZyZWdzLT5jcDBfZXBjKTsKKwkJCXByX2luZm8oInJhICA9ICUwKmx4IGluICVw YXZcbiIsCisJCQkJZmllbGQsCisJCQkJKHVuc2lnbmVkIGxvbmcpcmVncy0+cmVnc1szMV0sCisJ CQkJJnJlZ3MtPnJlZ3NbMzFdKTsKIAkJfQogCQljdXJyZW50LT50aHJlYWQudHJhcF9uciA9IChy ZWdzLT5jcDBfY2F1c2UgPj4gMikgJiAweDFmOwogCQlpbmZvLnNpX3NpZ25vID0gU0lHU0VHVjsK ZGlmZiAtLWdpdCBhL2FyY2gvcGFyaXNjL21tL2ZhdWx0LmMgYi9hcmNoL3BhcmlzYy9tbS9mYXVs dC5jCmluZGV4IGUyNDdlZGJjYTY4ZS4uODc3Y2VhNzAyNzE0IDEwMDY0NAotLS0gYS9hcmNoL3Bh cmlzYy9tbS9mYXVsdC5jCisrKyBiL2FyY2gvcGFyaXNjL21tL2ZhdWx0LmMKQEAgLTI0MCwxNyAr MjQwLDE0IEBAIHNob3dfc2lnbmFsX21zZyhzdHJ1Y3QgcHRfcmVncyAqcmVncywgdW5zaWduZWQg bG9uZyBjb2RlLAogCWlmICghcHJpbnRrX3JhdGVsaW1pdCgpKQogCQlyZXR1cm47CiAKLQlwcl93 YXJuKCJcbiIpOwotCXByX3dhcm4oImRvX3BhZ2VfZmF1bHQoKSBjb21tYW5kPSclcycgdHlwZT0l bHUgYWRkcmVzcz0weCUwOGx4IiwKLQkgICAgdHNrLT5jb21tLCBjb2RlLCBhZGRyZXNzKTsKLQlw cmludF92bWFfYWRkcihLRVJOX0NPTlQgIiBpbiAiLCByZWdzLT5pYW9xWzBdKTsKLQotCXByX2Nv bnQoIlxudHJhcCAjJWx1OiAlcyVjIiwgY29kZSwgdHJhcF9uYW1lKGNvZGUpLAotCQl2bWEgPyAn LCc6J1xuJyk7CisJcHJfd2FybigiZG9fcGFnZV9mYXVsdCgpIGNvbW1hbmQ9JyVzJyB0eXBlPSVs dSBhZGRyZXNzPTB4JTA4bHggaW4gJXBhdlxuIiwKKwkJdHNrLT5jb21tLCBjb2RlLCBhZGRyZXNz LCAmcmVncy0+aWFvcVswXSk7CiAKIAlpZiAodm1hKQotCQlwcl9jb250KCIgdm1fc3RhcnQgPSAw eCUwOGx4LCB2bV9lbmQgPSAweCUwOGx4XG4iLAotCQkJdm1hLT52bV9zdGFydCwgdm1hLT52bV9l bmQpOworCQlwcl93YXJuKCJ0cmFwICMlbHU6ICVzJWMsIHZtX3N0YXJ0ID0gMHglMDhseCwgdm1f ZW5kID0gMHglMDhseFxuIiwKKwkJCWNvZGUsIHRyYXBfbmFtZShjb2RlKSwgdm1hLT52bV9zdGFy dCwgdm1hLT52bV9lbmQpOworCWVsc2UKKwkJcHJfd2FybigidHJhcCAjJWx1OiAlcyVjXG4iLCBj b2RlLCB0cmFwX25hbWUoY29kZSkpOwogCiAJc2hvd19yZWdzKHJlZ3MpOwogfQpkaWZmIC0tZ2l0 IGEvYXJjaC9yaXNjdi9rZXJuZWwvdHJhcHMuYyBiL2FyY2gvcmlzY3Yva2VybmVsL3RyYXBzLmMK aW5kZXggOTMxMzJjYjU5MTg0Li4xNjYwOWRjYjI1NDYgMTAwNjQ0Ci0tLSBhL2FyY2gvcmlzY3Yv a2VybmVsL3RyYXBzLmMKKysrIGIvYXJjaC9yaXNjdi9rZXJuZWwvdHJhcHMuYwpAQCAtNzgsMTIg Kzc4LDExIEBAIHN0YXRpYyBpbmxpbmUgdm9pZCBkb190cmFwX3NpZ2luZm8oaW50IHNpZ25vLCBp bnQgY29kZSwKIHZvaWQgZG9fdHJhcChzdHJ1Y3QgcHRfcmVncyAqcmVncywgaW50IHNpZ25vLCBp bnQgY29kZSwKIAl1bnNpZ25lZCBsb25nIGFkZHIsIHN0cnVjdCB0YXNrX3N0cnVjdCAqdHNrKQog ewotCWlmIChzaG93X3VuaGFuZGxlZF9zaWduYWxzICYmIHVuaGFuZGxlZF9zaWduYWwodHNrLCBz aWdubykKLQkgICAgJiYgcHJpbnRrX3JhdGVsaW1pdCgpKSB7Ci0JCXByX2luZm8oIiVzWyVkXTog dW5oYW5kbGVkIHNpZ25hbCAlZCBjb2RlIDB4JXggYXQgMHgiIFJFR19GTVQsCi0JCQl0c2stPmNv bW0sIHRhc2tfcGlkX25yKHRzayksIHNpZ25vLCBjb2RlLCBhZGRyKTsKLQkJcHJpbnRfdm1hX2Fk ZHIoS0VSTl9DT05UICIgaW4gIiwgR0VUX0lQKHJlZ3MpKTsKLQkJcHJfY29udCgiXG4iKTsKKwlp ZiAoc2hvd191bmhhbmRsZWRfc2lnbmFscyAmJiB1bmhhbmRsZWRfc2lnbmFsKHRzaywgc2lnbm8p ICYmCisJICAgIHByaW50a19yYXRlbGltaXQoKSkgeworCQlwcl9pbmZvKCIlc1slZF06IHVuaGFu ZGxlZCBzaWduYWwgJWQgY29kZSAweCV4IGF0IDB4IiBSRUdfRk1UICIgaW4gJXBhdlxuIiwKKwkJ CXRzay0+Y29tbSwgdGFza19waWRfbnIodHNrKSwgc2lnbm8sIGNvZGUsIGFkZHIsCisJCQkmR0VU X0lQKHJlZ3MpKTsKIAkJc2hvd19yZWdzKHJlZ3MpOwogCX0KIApkaWZmIC0tZ2l0IGEvYXJjaC9z MzkwL21tL2ZhdWx0LmMgYi9hcmNoL3MzOTAvbW0vZmF1bHQuYwppbmRleCA5M2ZhZWNhNTIyODQu LjNiMWQ2ZDYxOGFmMiAxMDA2NDQKLS0tIGEvYXJjaC9zMzkwL21tL2ZhdWx0LmMKKysrIGIvYXJj aC9zMzkwL21tL2ZhdWx0LmMKQEAgLTI1MCwxMCArMjUwLDkgQEAgdm9pZCByZXBvcnRfdXNlcl9m YXVsdChzdHJ1Y3QgcHRfcmVncyAqcmVncywgbG9uZyBzaWduciwgaW50IGlzX21tX2ZhdWx0KQog CQlyZXR1cm47CiAJaWYgKCFwcmludGtfcmF0ZWxpbWl0KCkpCiAJCXJldHVybjsKLQlwcmludGso S0VSTl9BTEVSVCAiVXNlciBwcm9jZXNzIGZhdWx0OiBpbnRlcnJ1cHRpb24gY29kZSAlMDR4IGls YzolZCAiLAotCSAgICAgICByZWdzLT5pbnRfY29kZSAmIDB4ZmZmZiwgcmVncy0+aW50X2NvZGUg Pj4gMTcpOwotCXByaW50X3ZtYV9hZGRyKEtFUk5fQ09OVCAiaW4gIiwgcmVncy0+cHN3LmFkZHIp OwotCXByaW50ayhLRVJOX0NPTlQgIlxuIik7CisJcHJpbnRrKEtFUk5fQUxFUlQgIlVzZXIgcHJv Y2VzcyBmYXVsdDogaW50ZXJydXB0aW9uIGNvZGUgJTA0eCBpbGM6JWQgaW4gJXBhdlxuIiwKKwkg ICAgICAgcmVncy0+aW50X2NvZGUgJiAweGZmZmYsIHJlZ3MtPmludF9jb2RlID4+IDE3LAorCSAg ICAgICAmcmVncy0+cHN3LmFkZHIpOwogCWlmIChpc19tbV9mYXVsdCkKIAkJZHVtcF9mYXVsdF9p bmZvKHJlZ3MpOwogCXNob3dfcmVncyhyZWdzKTsKZGlmZiAtLWdpdCBhL2FyY2gvc3BhcmMvbW0v ZmF1bHRfMzIuYyBiL2FyY2gvc3BhcmMvbW0vZmF1bHRfMzIuYwppbmRleCBhODEwM2E4NGI0YWMu LjIwNmVjNWExYzkxNSAxMDA2NDQKLS0tIGEvYXJjaC9zcGFyYy9tbS9mYXVsdF8zMi5jCisrKyBi L2FyY2gvc3BhcmMvbW0vZmF1bHRfMzIuYwpAQCAtMTEzLDE1ICsxMTMsMTEgQEAgc2hvd19zaWdu YWxfbXNnKHN0cnVjdCBwdF9yZWdzICpyZWdzLCBpbnQgc2lnLCBpbnQgY29kZSwKIAlpZiAoIXBy aW50a19yYXRlbGltaXQoKSkKIAkJcmV0dXJuOwogCi0JcHJpbnRrKCIlcyVzWyVkXTogc2VnZmF1 bHQgYXQgJWx4IGlwICVweCAocnBjICVweCkgc3AgJXB4IGVycm9yICV4IiwKKwlwcmludGsoIiVz JXNbJWRdOiBzZWdmYXVsdCBhdCAlbHggaXAgJXB4IChycGMgJXB4KSBzcCAlcHggZXJyb3IgJXgg aW4gJXBhdlxuIiwKIAkgICAgICAgdGFza19waWRfbnIodHNrKSA+IDEgPyBLRVJOX0lORk8gOiBL RVJOX0VNRVJHLAogCSAgICAgICB0c2stPmNvbW0sIHRhc2tfcGlkX25yKHRzayksIGFkZHJlc3Ms CiAJICAgICAgICh2b2lkICopcmVncy0+cGMsICh2b2lkICopcmVncy0+dV9yZWdzW1VSRUdfSTdd LAotCSAgICAgICAodm9pZCAqKXJlZ3MtPnVfcmVnc1tVUkVHX0ZQXSwgY29kZSk7Ci0KLQlwcmlu dF92bWFfYWRkcihLRVJOX0NPTlQgIiBpbiAiLCByZWdzLT5wYyk7Ci0KLQlwcmludGsoS0VSTl9D T05UICJcbiIpOworCSAgICAgICAodm9pZCAqKXJlZ3MtPnVfcmVnc1tVUkVHX0ZQXSwgY29kZSwg JnJlZ3MtPnBjKTsKIH0KIAogc3RhdGljIHZvaWQgX19kb19mYXVsdF9zaWdpbmZvKGludCBjb2Rl LCBpbnQgc2lnLCBzdHJ1Y3QgcHRfcmVncyAqcmVncywKZGlmZiAtLWdpdCBhL2FyY2gvc3BhcmMv bW0vZmF1bHRfNjQuYyBiL2FyY2gvc3BhcmMvbW0vZmF1bHRfNjQuYwppbmRleCA0MTM2M2Y0Njc5 N2IuLmEyMTE5OTMyOWViZSAxMDA2NDQKLS0tIGEvYXJjaC9zcGFyYy9tbS9mYXVsdF82NC5jCisr KyBiL2FyY2gvc3BhcmMvbW0vZmF1bHRfNjQuYwpAQCAtMTU0LDE1ICsxNTQsMTEgQEAgc2hvd19z aWduYWxfbXNnKHN0cnVjdCBwdF9yZWdzICpyZWdzLCBpbnQgc2lnLCBpbnQgY29kZSwKIAlpZiAo IXByaW50a19yYXRlbGltaXQoKSkKIAkJcmV0dXJuOwogCi0JcHJpbnRrKCIlcyVzWyVkXTogc2Vn ZmF1bHQgYXQgJWx4IGlwICVweCAocnBjICVweCkgc3AgJXB4IGVycm9yICV4IiwKKwlwcmludGso IiVzJXNbJWRdOiBzZWdmYXVsdCBhdCAlbHggaXAgJXB4IChycGMgJXB4KSBzcCAlcHggZXJyb3Ig JXggaW4gJXBhdlxiIiwKIAkgICAgICAgdGFza19waWRfbnIodHNrKSA+IDEgPyBLRVJOX0lORk8g OiBLRVJOX0VNRVJHLAogCSAgICAgICB0c2stPmNvbW0sIHRhc2tfcGlkX25yKHRzayksIGFkZHJl c3MsCiAJICAgICAgICh2b2lkICopcmVncy0+dHBjLCAodm9pZCAqKXJlZ3MtPnVfcmVnc1tVUkVH X0k3XSwKLQkgICAgICAgKHZvaWQgKilyZWdzLT51X3JlZ3NbVVJFR19GUF0sIGNvZGUpOwotCi0J cHJpbnRfdm1hX2FkZHIoS0VSTl9DT05UICIgaW4gIiwgcmVncy0+dHBjKTsKLQotCXByaW50ayhL RVJOX0NPTlQgIlxuIik7CisJICAgICAgICh2b2lkICopcmVncy0+dV9yZWdzW1VSRUdfRlBdLCBj b2RlLCAmcmVncy0+dHBjKTsKIH0KIAogc3RhdGljIHZvaWQgZG9fZmF1bHRfc2lnaW5mbyhpbnQg Y29kZSwgaW50IHNpZywgc3RydWN0IHB0X3JlZ3MgKnJlZ3MsCmRpZmYgLS1naXQgYS9hcmNoL3Rp bGUva2VybmVsL3NpZ25hbC5jIGIvYXJjaC90aWxlL2tlcm5lbC9zaWduYWwuYwppbmRleCBmMmJm NTU3YmIwMDUuLjA1NTYxMDZkZmU4YSAxMDA2NDQKLS0tIGEvYXJjaC90aWxlL2tlcm5lbC9zaWdu YWwuYworKysgYi9hcmNoL3RpbGUva2VybmVsL3NpZ25hbC5jCkBAIC0zODMsMTMgKzM4MywxMCBA QCB2b2lkIHRyYWNlX3VuaGFuZGxlZF9zaWduYWwoY29uc3QgY2hhciAqdHlwZSwgc3RydWN0IHB0 X3JlZ3MgKnJlZ3MsCiAJaWYgKHNob3dfdW5oYW5kbGVkX3NpZ25hbHMgPD0gMSAmJiAhcHJpbnRr X3JhdGVsaW1pdCgpKQogCQlyZXR1cm47CiAKLQlwcmludGsoIiVzJXNbJWRdOiAlcyBhdCAlbHgg cGMgIlJFR0ZNVCIgc2lnbmFsICVkIiwKKwlwcmludGsoIiVzJXNbJWRdOiAlcyBhdCAlbHggcGMg IiBSRUdGTVQgIiBzaWduYWwgJWQgaW4gJXBhdlxuIiwKIAkgICAgICAgdGFza19waWRfbnIodHNr KSA+IDEgPyBLRVJOX0lORk8gOiBLRVJOX0VNRVJHLAotCSAgICAgICB0c2stPmNvbW0sIHRhc2tf cGlkX25yKHRzayksIHR5cGUsIGFkZHJlc3MsIHJlZ3MtPnBjLCBzaWcpOwotCi0JcHJpbnRfdm1h X2FkZHIoS0VSTl9DT05UICIgaW4gIiwgcmVncy0+cGMpOwotCi0JcHJpbnRrKEtFUk5fQ09OVCAi XG4iKTsKKwkgICAgICAgdHNrLT5jb21tLCB0YXNrX3BpZF9ucih0c2spLCB0eXBlLCBhZGRyZXNz LCByZWdzLT5wYywgc2lnLAorCSAgICAgICAmcmVncy0+cGMpOwogCiAJaWYgKHNob3dfdW5oYW5k bGVkX3NpZ25hbHMgPiAxKSB7CiAJCXN3aXRjaCAoc2lnKSB7CmRpZmYgLS1naXQgYS9hcmNoL3Vt L2tlcm5lbC90cmFwLmMgYi9hcmNoL3VtL2tlcm5lbC90cmFwLmMKaW5kZXggYjJiMDJkZjk4OTZl Li45MjgxMjQ4OTcyYzAgMTAwNjQ0Ci0tLSBhL2FyY2gvdW0va2VybmVsL3RyYXAuYworKysgYi9h cmNoL3VtL2tlcm5lbC90cmFwLmMKQEAgLTE1MCwxNCArMTUwLDExIEBAIHN0YXRpYyB2b2lkIHNo b3dfc2Vndl9pbmZvKHN0cnVjdCB1bWxfcHRfcmVncyAqcmVncykKIAlpZiAoIXByaW50a19yYXRl bGltaXQoKSkKIAkJcmV0dXJuOwogCi0JcHJpbnRrKCIlcyVzWyVkXTogc2VnZmF1bHQgYXQgJWx4 IGlwICVweCBzcCAlcHggZXJyb3IgJXgiLAotCQl0YXNrX3BpZF9ucih0c2spID4gMSA/IEtFUk5f SU5GTyA6IEtFUk5fRU1FUkcsCi0JCXRzay0+Y29tbSwgdGFza19waWRfbnIodHNrKSwgRkFVTFRf QUREUkVTUygqZmkpLAotCQkodm9pZCAqKVVQVF9JUChyZWdzKSwgKHZvaWQgKilVUFRfU1AocmVn cyksCi0JCWZpLT5lcnJvcl9jb2RlKTsKLQotCXByaW50X3ZtYV9hZGRyKEtFUk5fQ09OVCAiIGlu ICIsIFVQVF9JUChyZWdzKSk7Ci0JcHJpbnRrKEtFUk5fQ09OVCAiXG4iKTsKKwlwcmludGsoIiVz JXNbJWRdOiBzZWdmYXVsdCBhdCAlbHggaXAgJXB4IHNwICVweCBlcnJvciAleCBpbiAlcGF2XG4i LAorCSAgICAgICB0YXNrX3BpZF9ucih0c2spID4gMSA/IEtFUk5fSU5GTyA6IEtFUk5fRU1FUkcs CisJICAgICAgIHRzay0+Y29tbSwgdGFza19waWRfbnIodHNrKSwgRkFVTFRfQUREUkVTUygqZmkp LAorCSAgICAgICAodm9pZCAqKVVQVF9JUChyZWdzKSwgKHZvaWQgKilVUFRfU1AocmVncyksCisJ ICAgICAgIGZpLT5lcnJvcl9jb2RlLCAmVVBUX0lQKHJlZ3MpKTsKIH0KIAogc3RhdGljIHZvaWQg YmFkX3NlZ3Yoc3RydWN0IGZhdWx0aW5mbyBmaSwgdW5zaWduZWQgbG9uZyBpcCkKZGlmZiAtLWdp dCBhL2FyY2gveDg2L2tlcm5lbC9zaWduYWwuYyBiL2FyY2gveDg2L2tlcm5lbC9zaWduYWwuYwpp bmRleCA0Y2RjMGIyN2VjODIuLjlhYjBjNWM1MGIyOSAxMDA2NDQKLS0tIGEvYXJjaC94ODYva2Vy bmVsL3NpZ25hbC5jCisrKyBiL2FyY2gveDg2L2tlcm5lbC9zaWduYWwuYwpAQCAtODQxLDE1ICs4 NDEsMTEgQEAgdm9pZCBzaWduYWxfZmF1bHQoc3RydWN0IHB0X3JlZ3MgKnJlZ3MsIHZvaWQgX191 c2VyICpmcmFtZSwgY2hhciAqd2hlcmUpCiB7CiAJc3RydWN0IHRhc2tfc3RydWN0ICptZSA9IGN1 cnJlbnQ7CiAKLQlpZiAoc2hvd191bmhhbmRsZWRfc2lnbmFscyAmJiBwcmludGtfcmF0ZWxpbWl0 KCkpIHsKLQkJcHJpbnRrKCIlcyIKLQkJICAgICAgICIlc1slZF0gYmFkIGZyYW1lIGluICVzIGZy YW1lOiVwIGlwOiVseCBzcDolbHggb3JheDolbHgiLAorCWlmIChzaG93X3VuaGFuZGxlZF9zaWdu YWxzICYmIHByaW50a19yYXRlbGltaXQoKSkKKwkJcHJpbnRrKCIlcyVzWyVkXSBiYWQgZnJhbWUg aW4gJXMgZnJhbWU6JXAgaXA6JWx4IHNwOiVseCBvcmF4OiVseCBpbiAlcGF2XG4iLAogCQkgICAg ICAgdGFza19waWRfbnIoY3VycmVudCkgPiAxID8gS0VSTl9JTkZPIDogS0VSTl9FTUVSRywKIAkJ ICAgICAgIG1lLT5jb21tLCBtZS0+cGlkLCB3aGVyZSwgZnJhbWUsCi0JCSAgICAgICByZWdzLT5p cCwgcmVncy0+c3AsIHJlZ3MtPm9yaWdfYXgpOwotCQlwcmludF92bWFfYWRkcihLRVJOX0NPTlQg IiBpbiAiLCByZWdzLT5pcCk7Ci0JCXByX2NvbnQoIlxuIik7Ci0JfQorCQkgICAgICAgcmVncy0+ aXAsIHJlZ3MtPnNwLCByZWdzLT5vcmlnX2F4LCAmcmVncy0+aXApOwogCiAJZm9yY2Vfc2lnKFNJ R1NFR1YsIG1lKTsKIH0KZGlmZiAtLWdpdCBhL2FyY2gveDg2L2tlcm5lbC90cmFwcy5jIGIvYXJj aC94ODYva2VybmVsL3RyYXBzLmMKaW5kZXggM2Q5YjIzMDhlN2ZhLi5jNmUzZDAyNzU5ZTUgMTAw NjQ0Ci0tLSBhL2FyY2gveDg2L2tlcm5lbC90cmFwcy5jCisrKyBiL2FyY2gveDg2L2tlcm5lbC90 cmFwcy5jCkBAIC0yNzAsMTMgKzI3MCwxMCBAQCBkb190cmFwKGludCB0cmFwbnIsIGludCBzaWdu ciwgY2hhciAqc3RyLCBzdHJ1Y3QgcHRfcmVncyAqcmVncywKIAl0c2stPnRocmVhZC50cmFwX25y ID0gdHJhcG5yOwogCiAJaWYgKHNob3dfdW5oYW5kbGVkX3NpZ25hbHMgJiYgdW5oYW5kbGVkX3Np Z25hbCh0c2ssIHNpZ25yKSAmJgotCSAgICBwcmludGtfcmF0ZWxpbWl0KCkpIHsKLQkJcHJfaW5m bygiJXNbJWRdIHRyYXAgJXMgaXA6JWx4IHNwOiVseCBlcnJvcjolbHgiLAorCSAgICBwcmludGtf cmF0ZWxpbWl0KCkpCisJCXByX2luZm8oIiVzWyVkXSB0cmFwICVzIGlwOiVseCBzcDolbHggZXJy b3I6JWx4IGluICVwYXZcbiIsCiAJCQl0c2stPmNvbW0sIHRzay0+cGlkLCBzdHIsCi0JCQlyZWdz LT5pcCwgcmVncy0+c3AsIGVycm9yX2NvZGUpOwotCQlwcmludF92bWFfYWRkcihLRVJOX0NPTlQg IiBpbiAiLCByZWdzLT5pcCk7Ci0JCXByX2NvbnQoIlxuIik7Ci0JfQorCQkJcmVncy0+aXAsIHJl Z3MtPnNwLCBlcnJvcl9jb2RlLCAmcmVncy0+aXApOwogCiAJZm9yY2Vfc2lnX2luZm8oc2lnbnIs IGluZm8gPzogU0VORF9TSUdfUFJJViwgdHNrKTsKIH0KQEAgLTU2NSwxMyArNTYyLDEwIEBAIGRv X2dlbmVyYWxfcHJvdGVjdGlvbihzdHJ1Y3QgcHRfcmVncyAqcmVncywgbG9uZyBlcnJvcl9jb2Rl KQogCXRzay0+dGhyZWFkLnRyYXBfbnIgPSBYODZfVFJBUF9HUDsKIAogCWlmIChzaG93X3VuaGFu ZGxlZF9zaWduYWxzICYmIHVuaGFuZGxlZF9zaWduYWwodHNrLCBTSUdTRUdWKSAmJgotCQkJcHJp bnRrX3JhdGVsaW1pdCgpKSB7Ci0JCXByX2luZm8oIiVzWyVkXSBnZW5lcmFsIHByb3RlY3Rpb24g aXA6JWx4IHNwOiVseCBlcnJvcjolbHgiLAorCQkJcHJpbnRrX3JhdGVsaW1pdCgpKQorCQlwcl9p bmZvKCIlc1slZF0gZ2VuZXJhbCBwcm90ZWN0aW9uIGlwOiVseCBzcDolbHggZXJyb3I6JWx4IGlu ICVwYXZcbiIsCiAJCQl0c2stPmNvbW0sIHRhc2tfcGlkX25yKHRzayksCi0JCQlyZWdzLT5pcCwg cmVncy0+c3AsIGVycm9yX2NvZGUpOwotCQlwcmludF92bWFfYWRkcihLRVJOX0NPTlQgIiBpbiAi LCByZWdzLT5pcCk7Ci0JCXByX2NvbnQoIlxuIik7Ci0JfQorCQkJcmVncy0+aXAsIHJlZ3MtPnNw LCBlcnJvcl9jb2RlLCAmcmVncy0+aXApOwogCiAJZm9yY2Vfc2lnX2luZm8oU0lHU0VHViwgU0VO RF9TSUdfUFJJViwgdHNrKTsKIH0KZGlmZiAtLWdpdCBhL2FyY2gveDg2L21tL2ZhdWx0LmMgYi9h cmNoL3g4Ni9tbS9mYXVsdC5jCmluZGV4IGU2YWYyYjQ2NGMzZC4uYjYyOTMxOWU2MjFhIDEwMDY0 NAotLS0gYS9hcmNoL3g4Ni9tbS9mYXVsdC5jCisrKyBiL2FyY2gveDg2L21tL2ZhdWx0LmMKQEAg LTg1NywxNCArODU3LDEwIEBAIHNob3dfc2lnbmFsX21zZyhzdHJ1Y3QgcHRfcmVncyAqcmVncywg dW5zaWduZWQgbG9uZyBlcnJvcl9jb2RlLAogCWlmICghcHJpbnRrX3JhdGVsaW1pdCgpKQogCQly ZXR1cm47CiAKLQlwcmludGsoIiVzJXNbJWRdOiBzZWdmYXVsdCBhdCAlbHggaXAgJXB4IHNwICVw eCBlcnJvciAlbHgiLAotCQl0YXNrX3BpZF9ucih0c2spID4gMSA/IEtFUk5fSU5GTyA6IEtFUk5f RU1FUkcsCi0JCXRzay0+Y29tbSwgdGFza19waWRfbnIodHNrKSwgYWRkcmVzcywKLQkJKHZvaWQg KilyZWdzLT5pcCwgKHZvaWQgKilyZWdzLT5zcCwgZXJyb3JfY29kZSk7Ci0KLQlwcmludF92bWFf YWRkcihLRVJOX0NPTlQgIiBpbiAiLCByZWdzLT5pcCk7Ci0KLQlwcmludGsoS0VSTl9DT05UICJc biIpOworCXByaW50aygiJXMlc1slZF06IHNlZ2ZhdWx0IGF0ICVseCBpcCAlcHggc3AgJXB4IGVy cm9yICVseCBpbiAlcGF2XG4iLAorCSAgICAgICB0YXNrX3BpZF9ucih0c2spID4gMSA/IEtFUk5f SU5GTyA6IEtFUk5fRU1FUkcsCisJICAgICAgIHRzay0+Y29tbSwgdGFza19waWRfbnIodHNrKSwg YWRkcmVzcywKKwkgICAgICAgKHZvaWQgKilyZWdzLT5pcCwgKHZvaWQgKilyZWdzLT5zcCwgZXJy b3JfY29kZSwgJnJlZ3MtPmlwKTsKIH0KIAogc3RhdGljIHZvaWQKZGlmZiAtLWdpdCBhL2luY2x1 ZGUvbGludXgvbW0uaCBiL2luY2x1ZGUvbGludXgvbW0uaAppbmRleCA5ZjEyNzAzNjA5ODMuLjk1 ODRiZDNlOGMyNSAxMDA2NDQKLS0tIGEvaW5jbHVkZS9saW51eC9tbS5oCisrKyBiL2luY2x1ZGUv bGludXgvbW0uaApAQCAtMjUzNyw3ICsyNTM3LDYgQEAgZXh0ZXJuIGludCByYW5kb21pemVfdmFf c3BhY2U7CiAjZW5kaWYKIAogY29uc3QgY2hhciAqIGFyY2hfdm1hX25hbWUoc3RydWN0IHZtX2Fy ZWFfc3RydWN0ICp2bWEpOwotdm9pZCBwcmludF92bWFfYWRkcihjaGFyICpwcmVmaXgsIHVuc2ln bmVkIGxvbmcgcmlwKTsKIAogdm9pZCBzcGFyc2VfbWVtX21hcHNfcG9wdWxhdGVfbm9kZShzdHJ1 Y3QgcGFnZSAqKm1hcF9tYXAsCiAJCQkJICAgdW5zaWduZWQgbG9uZyBwbnVtX2JlZ2luLApkaWZm IC0tZ2l0IGEvbGliL3ZzcHJpbnRmLmMgYi9saWIvdnNwcmludGYuYwppbmRleCA5NDJiNTIzNGE1 OWIuLjkwODE0NzZlYTRlYSAxMDA2NDQKLS0tIGEvbGliL3ZzcHJpbnRmLmMKKysrIGIvbGliL3Zz cHJpbnRmLmMKQEAgLTM1LDYgKzM1LDggQEAKICNpbmNsdWRlIDxuZXQvYWRkcmNvbmYuaD4KICNp bmNsdWRlIDxsaW51eC9zaXBoYXNoLmg+CiAjaW5jbHVkZSA8bGludXgvY29tcGlsZXIuaD4KKyNp bmNsdWRlIDxsaW51eC9tbV90eXBlcy5oPgorCiAjaWZkZWYgQ09ORklHX0JMT0NLCiAjaW5jbHVk ZSA8bGludXgvYmxrZGV2Lmg+CiAjZW5kaWYKQEAgLTQwNyw2ICs0MDksMTEgQEAgc3RydWN0IHBy aW50Zl9zcGVjIHsKICNkZWZpbmUgRklFTERfV0lEVEhfTUFYICgoMSA8PCAyMykgLSAxKQogI2Rl ZmluZSBQUkVDSVNJT05fTUFYICgoMSA8PCAxNSkgLSAxKQogCitzdGF0aWMgY29uc3Qgc3RydWN0 IHByaW50Zl9zcGVjIHN0cnNwZWMgPSB7CisJLmZpZWxkX3dpZHRoID0gLTEsCisJLnByZWNpc2lv biA9IC0xLAorfTsKKwogc3RhdGljIG5vaW5saW5lX2Zvcl9zdGFjawogY2hhciAqbnVtYmVyKGNo YXIgKmJ1ZiwgY2hhciAqZW5kLCB1bnNpZ25lZCBsb25nIGxvbmcgbnVtLAogCSAgICAgc3RydWN0 IHByaW50Zl9zcGVjIHNwZWMpCkBAIC0xNDI3LDYgKzE0MzQsNDUgQEAgY2hhciAqbmV0ZGV2X2Jp dHMoY2hhciAqYnVmLCBjaGFyICplbmQsIGNvbnN0IHZvaWQgKmFkZHIsIGNvbnN0IGNoYXIgKmZt dCkKIAlyZXR1cm4gc3BlY2lhbF9oZXhfbnVtYmVyKGJ1ZiwgZW5kLCBudW0sIHNpemUpOwogfQog CitzdGF0aWMgbm9pbmxpbmVfZm9yX3N0YWNrCitjaGFyICp2bWFfYWRkcihjaGFyICpidWYsIGNo YXIgKmVuZCwgY29uc3Qgdm9pZCAqYWRkcikKK3sKKwlzdHJ1Y3QgbW1fc3RydWN0ICptbSA9IGN1 cnJlbnQtPm1tOworCXN0cnVjdCB2bV9hcmVhX3N0cnVjdCAqdm1hOworCWNoYXIgKnBhZ2U7CisJ Y2hhciB0YnVmWzIgKiBzaXplb2YodW5zaWduZWQgbG9uZykgKiAyICsgNF07CisJY29uc3QgY2hh ciAqb3V0cHV0ID0gIj9bMCswXSI7CisKKwkvKgorCSAqIHdlIG1pZ2h0IGJlIHJ1bm5pbmcgZnJv bSBhbiBhdG9taWMgY29udGV4dCBzbyB3ZSBjYW5ub3Qgc2xlZXAKKwkgKi8KKwlpZiAoIWRvd25f cmVhZF90cnlsb2NrKCZtbS0+bW1hcF9zZW0pKQorCQlnb3RvIG91dHB1dDsKKworCXZtYSA9IGZp bmRfdm1hKG1tLCAqKHVuc2lnbmVkIGxvbmcgKilhZGRyKTsKKwlpZiAoIXZtYSB8fCAhdm1hLT52 bV9maWxlKQorCQlnb3RvIHVwX3JlYWQ7CisKKwlwYWdlID0gKGNoYXIgKilfX2dldF9mcmVlX3Bh Z2UoR0ZQX0FUT01JQyB8IF9fR0ZQX05PV0FSTik7CisJaWYgKHBhZ2UpIHsKKwkJY2hhciAqZnA7 CisKKwkJZnAgPSBmaWxlX3BhdGgodm1hLT52bV9maWxlLCBwYWdlLCBQQUdFX1NJWkUpOworCQlp ZiAoSVNfRVJSKGZwKSkKKwkJCWZwID0gIj8iOworCQlidWYgPSBzdHJpbmcoYnVmLCBlbmQsIGti YXNlbmFtZShmcCksIHN0cnNwZWMpOworCQlzcHJpbnRmKHRidWYsICJbJWx4KyVseF0iLAorCQkJ dm1hLT52bV9zdGFydCwgdm1hLT52bV9lbmQgLSB2bWEtPnZtX3N0YXJ0KTsKKwkJb3V0cHV0ID0g dGJ1ZjsKKwkJZnJlZV9wYWdlKCh1bnNpZ25lZCBsb25nKXBhZ2UpOworCX0KKwordXBfcmVhZDoK Kwl1cF9yZWFkKCZtbS0+bW1hcF9zZW0pOworb3V0cHV0OgorCXJldHVybiBzdHJpbmcoYnVmLCBl bmQsIG91dHB1dCwgc3Ryc3BlYyk7Cit9CisKIHN0YXRpYyBub2lubGluZV9mb3Jfc3RhY2sKIGNo YXIgKmFkZHJlc3NfdmFsKGNoYXIgKmJ1ZiwgY2hhciAqZW5kLCBjb25zdCB2b2lkICphZGRyLCBj b25zdCBjaGFyICpmbXQpCiB7CkBAIC0xNDM0LDYgKzE0ODAsOCBAQCBjaGFyICphZGRyZXNzX3Zh bChjaGFyICpidWYsIGNoYXIgKmVuZCwgY29uc3Qgdm9pZCAqYWRkciwgY29uc3QgY2hhciAqZm10 KQogCWludCBzaXplOwogCiAJc3dpdGNoIChmbXRbMV0pIHsKKwljYXNlICd2JzoKKwkJcmV0dXJu IHZtYV9hZGRyKGJ1ZiwgZW5kLCBhZGRyKTsKIAljYXNlICdkJzoKIAkJbnVtID0gKihjb25zdCBk bWFfYWRkcl90ICopYWRkcjsKIAkJc2l6ZSA9IHNpemVvZihkbWFfYWRkcl90KTsKQEAgLTE0NzQs MTEgKzE1MjIsNyBAQCBjaGFyICpmb3JtYXRfZmxhZ3MoY2hhciAqYnVmLCBjaGFyICplbmQsIHVu c2lnbmVkIGxvbmcgZmxhZ3MsCiAJCQkJCWNvbnN0IHN0cnVjdCB0cmFjZV9wcmludF9mbGFncyAq bmFtZXMpCiB7CiAJdW5zaWduZWQgbG9uZyBtYXNrOwotCWNvbnN0IHN0cnVjdCBwcmludGZfc3Bl YyBzdHJzcGVjID0gewotCQkuZmllbGRfd2lkdGggPSAtMSwKLQkJLnByZWNpc2lvbiA9IC0xLAot CX07Ci0JY29uc3Qgc3RydWN0IHByaW50Zl9zcGVjIG51bXNwZWMgPSB7CisJc3RhdGljIGNvbnN0 IHN0cnVjdCBwcmludGZfc3BlYyBudW1zcGVjID0gewogCQkuZmxhZ3MgPSBTUEVDSUFMfFNNQUxM LAogCQkuZmllbGRfd2lkdGggPSAtMSwKIAkJLnByZWNpc2lvbiA9IC0xLApAQCAtMTU0OCwxMCAr MTU5Miw2IEBAIGNoYXIgKmRldmljZV9ub2RlX2dlbl9mdWxsX25hbWUoY29uc3Qgc3RydWN0IGRl dmljZV9ub2RlICpucCwgY2hhciAqYnVmLCBjaGFyICplCiB7CiAJaW50IGRlcHRoOwogCWNvbnN0 IHN0cnVjdCBkZXZpY2Vfbm9kZSAqcGFyZW50ID0gbnAtPnBhcmVudDsKLQlzdGF0aWMgY29uc3Qg c3RydWN0IHByaW50Zl9zcGVjIHN0cnNwZWMgPSB7Ci0JCS5maWVsZF93aWR0aCA9IC0xLAotCQku cHJlY2lzaW9uID0gLTEsCi0JfTsKIAogCS8qIHNwZWNpYWwgY2FzZSBmb3Igcm9vdCBub2RlICov CiAJaWYgKCFwYXJlbnQpCmRpZmYgLS1naXQgYS9tbS9tZW1vcnkuYyBiL21tL21lbW9yeS5jCmlu ZGV4IGJjNzYwZGY4YTdmNC4uZjFmOTIyNDIxYmRlIDEwMDY0NAotLS0gYS9tbS9tZW1vcnkuYwor KysgYi9tbS9tZW1vcnkuYwpAQCAtNDUwMiwzOSArNDUwMiw2IEBAIGludCBhY2Nlc3NfcHJvY2Vz c192bShzdHJ1Y3QgdGFza19zdHJ1Y3QgKnRzaywgdW5zaWduZWQgbG9uZyBhZGRyLAogfQogRVhQ T1JUX1NZTUJPTF9HUEwoYWNjZXNzX3Byb2Nlc3Nfdm0pOwogCi0vKgotICogUHJpbnQgdGhlIG5h bWUgb2YgYSBWTUEuCi0gKi8KLXZvaWQgcHJpbnRfdm1hX2FkZHIoY2hhciAqcHJlZml4LCB1bnNp Z25lZCBsb25nIGlwKQotewotCXN0cnVjdCBtbV9zdHJ1Y3QgKm1tID0gY3VycmVudC0+bW07Ci0J c3RydWN0IHZtX2FyZWFfc3RydWN0ICp2bWE7Ci0KLQkvKgotCSAqIHdlIG1pZ2h0IGJlIHJ1bm5p bmcgZnJvbSBhbiBhdG9taWMgY29udGV4dCBzbyB3ZSBjYW5ub3Qgc2xlZXAKLQkgKi8KLQlpZiAo IWRvd25fcmVhZF90cnlsb2NrKCZtbS0+bW1hcF9zZW0pKQotCQlyZXR1cm47Ci0KLQl2bWEgPSBm aW5kX3ZtYShtbSwgaXApOwotCWlmICh2bWEgJiYgdm1hLT52bV9maWxlKSB7Ci0JCXN0cnVjdCBm aWxlICpmID0gdm1hLT52bV9maWxlOwotCQljaGFyICpidWYgPSAoY2hhciAqKV9fZ2V0X2ZyZWVf cGFnZShHRlBfTk9XQUlUKTsKLQkJaWYgKGJ1ZikgewotCQkJY2hhciAqcDsKLQotCQkJcCA9IGZp bGVfcGF0aChmLCBidWYsIFBBR0VfU0laRSk7Ci0JCQlpZiAoSVNfRVJSKHApKQotCQkJCXAgPSAi PyI7Ci0JCQlwcmludGsoIiVzJXNbJWx4KyVseF0iLCBwcmVmaXgsIGtiYXNlbmFtZShwKSwKLQkJ CQkJdm1hLT52bV9zdGFydCwKLQkJCQkJdm1hLT52bV9lbmQgLSB2bWEtPnZtX3N0YXJ0KTsKLQkJ CWZyZWVfcGFnZSgodW5zaWduZWQgbG9uZylidWYpOwotCQl9Ci0JfQotCXVwX3JlYWQoJm1tLT5t bWFwX3NlbSk7Ci19Ci0KICNpZiBkZWZpbmVkKENPTkZJR19QUk9WRV9MT0NLSU5HKSB8fCBkZWZp bmVkKENPTkZJR19ERUJVR19BVE9NSUNfU0xFRVApCiB2b2lkIF9fbWlnaHRfZmF1bHQoY29uc3Qg Y2hhciAqZmlsZSwgaW50IGxpbmUpCiB7CgoKX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fX18KZHJpLWRldmVsIG1haWxpbmcgbGlzdApkcmktZGV2ZWxAbGlzdHMu ZnJlZWRlc2t0b3Aub3JnCmh0dHBzOi8vbGlzdHMuZnJlZWRlc2t0b3Aub3JnL21haWxtYW4vbGlz dGluZm8vZHJpLWRldmVsCg== From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from smtprelay0051.hostedemail.com ([216.40.44.51]:52837 "EHLO smtprelay.hostedemail.com" rhost-flags-OK-OK-OK-FAIL) by vger.kernel.org with ESMTP id S1751314AbeCOQ4y (ORCPT ); Thu, 15 Mar 2018 12:56:54 -0400 Message-ID: <1521133006.22221.35.camel@perches.com> Subject: rfc: remove print_vma_addr ? (was Re: [PATCH 00/16] remove eight obsolete architectures) From: Joe Perches Date: Thu, 15 Mar 2018 09:56:46 -0700 In-Reply-To: References: <20180314143529.1456168-1-arnd@arndb.de> <2929.1521106970@warthog.procyon.org.uk> Content-Type: text/plain; charset="ISO-8859-1" Mime-Version: 1.0 Content-Transfer-Encoding: 7bit Sender: linux-arch-owner@vger.kernel.org List-ID: To: Geert Uytterhoeven , David Howells Cc: Arnd Bergmann , Linux-Arch , Linux Kernel Mailing List , linux-doc@vger.kernel.org, linux-block@vger.kernel.org, linux-ide@vger.kernel.org, linux-input@vger.kernel.org, netdev , linux-wireless , Linux PWM List , linux-rtc@vger.kernel.org, linux-spi , USB list , DRI Development , Linux Fbdev development list , Linux Watchdog Mailing List , Linux FS Devel , Linux MM Message-ID: <20180315165646.f0GMr9ZPhprpOl0J0CmGwn0_OjWAjxkRX8JDdg59om8@z> On Thu, 2018-03-15 at 10:48 +0100, Geert Uytterhoeven wrote: > Hi David, > > On Thu, Mar 15, 2018 at 10:42 AM, David Howells wrote: > > Do we have anything left that still implements NOMMU? > > Sure: arm, c6x, m68k, microblaze, and sh. I have a patchset that creates a vsprintf extension for print_vma_addr and removes all the uses similar to the print_symbol() removal. This now avoids any possible printk interleaving. Unfortunately, without some #ifdef in vsprintf, which I would like to avoid, it increases the nommu kernel size by ~500 bytes. Anyone think this is acceptable? Here's the overall patch, but I have it as a series --- Documentation/core-api/printk-formats.rst | 9 +++++ arch/arm64/kernel/traps.c | 13 +++---- arch/mips/mm/fault.c | 16 ++++----- arch/parisc/mm/fault.c | 15 ++++---- arch/riscv/kernel/traps.c | 11 +++--- arch/s390/mm/fault.c | 7 ++-- arch/sparc/mm/fault_32.c | 8 ++--- arch/sparc/mm/fault_64.c | 8 ++--- arch/tile/kernel/signal.c | 9 ++--- arch/um/kernel/trap.c | 13 +++---- arch/x86/kernel/signal.c | 10 ++---- arch/x86/kernel/traps.c | 18 ++++------ arch/x86/mm/fault.c | 12 +++---- include/linux/mm.h | 1 - lib/vsprintf.c | 58 ++++++++++++++++++++++++++----- mm/memory.c | 33 ------------------ 16 files changed, 112 insertions(+), 129 deletions(-) diff --git a/Documentation/core-api/printk-formats.rst b/Documentation/core-api/printk-formats.rst index 934559b3c130..10a91da1bc83 100644 --- a/Documentation/core-api/printk-formats.rst +++ b/Documentation/core-api/printk-formats.rst @@ -157,6 +157,15 @@ DMA address types dma_addr_t For printing a dma_addr_t type which can vary based on build options, regardless of the width of the CPU data path. +VMA name and address +---------------------------- + +:: + + %pav [hexstart+hexsize] or ?[0+0] if unavailable + +For any address, print the vma's name and its starting address and size + Passed by reference. Raw buffer as an escaped string diff --git a/arch/arm64/kernel/traps.c b/arch/arm64/kernel/traps.c index 2b478565d774..48edf812ce8b 100644 --- a/arch/arm64/kernel/traps.c +++ b/arch/arm64/kernel/traps.c @@ -242,13 +242,14 @@ void arm64_force_sig_info(struct siginfo *info, const char *str, if (!show_unhandled_signals_ratelimited()) goto send_sig; - pr_info("%s[%d]: unhandled exception: ", tsk->comm, task_pid_nr(tsk)); if (esr) - pr_cont("%s, ESR 0x%08x, ", esr_get_class_string(esr), esr); - - pr_cont("%s", str); - print_vma_addr(KERN_CONT " in ", regs->pc); - pr_cont("\n"); + pr_info("%s[%d]: unhandled exception: %s, ESR 0x%08x, %s in %pav\n", + tsk->comm, task_pid_nr(tsk), + esr_get_class_string(esr), esr, + str, ®s->pc); + else + pr_info("%s[%d]: unhandled exception: %s in %pav\n", + tsk->comm, task_pid_nr(tsk), str, ®s->pc); __show_regs(regs); send_sig: diff --git a/arch/mips/mm/fault.c b/arch/mips/mm/fault.c index 4f8f5bf46977..ce7bf077a0f5 100644 --- a/arch/mips/mm/fault.c +++ b/arch/mips/mm/fault.c @@ -213,14 +213,14 @@ static void __kprobes __do_page_fault(struct pt_regs *regs, unsigned long write, tsk->comm, write ? "write access to" : "read access from", field, address); - pr_info("epc = %0*lx in", field, - (unsigned long) regs->cp0_epc); - print_vma_addr(KERN_CONT " ", regs->cp0_epc); - pr_cont("\n"); - pr_info("ra = %0*lx in", field, - (unsigned long) regs->regs[31]); - print_vma_addr(KERN_CONT " ", regs->regs[31]); - pr_cont("\n"); + pr_info("epc = %0*lx in %pav\n", + field, + (unsigned long)regs->cp0_epc, + ®s->cp0_epc); + pr_info("ra = %0*lx in %pav\n", + field, + (unsigned long)regs->regs[31], + ®s->regs[31]); } current->thread.trap_nr = (regs->cp0_cause >> 2) & 0x1f; info.si_signo = SIGSEGV; diff --git a/arch/parisc/mm/fault.c b/arch/parisc/mm/fault.c index e247edbca68e..877cea702714 100644 --- a/arch/parisc/mm/fault.c +++ b/arch/parisc/mm/fault.c @@ -240,17 +240,14 @@ show_signal_msg(struct pt_regs *regs, unsigned long code, if (!printk_ratelimit()) return; - pr_warn("\n"); - pr_warn("do_page_fault() command='%s' type=%lu address=0x%08lx", - tsk->comm, code, address); - print_vma_addr(KERN_CONT " in ", regs->iaoq[0]); - - pr_cont("\ntrap #%lu: %s%c", code, trap_name(code), - vma ? ',':'\n'); + pr_warn("do_page_fault() command='%s' type=%lu address=0x%08lx in %pav\n", + tsk->comm, code, address, ®s->iaoq[0]); if (vma) - pr_cont(" vm_start = 0x%08lx, vm_end = 0x%08lx\n", - vma->vm_start, vma->vm_end); + pr_warn("trap #%lu: %s%c, vm_start = 0x%08lx, vm_end = 0x%08lx\n", + code, trap_name(code), vma->vm_start, vma->vm_end); + else + pr_warn("trap #%lu: %s%c\n", code, trap_name(code)); show_regs(regs); } diff --git a/arch/riscv/kernel/traps.c b/arch/riscv/kernel/traps.c index 93132cb59184..16609dcb2546 100644 --- a/arch/riscv/kernel/traps.c +++ b/arch/riscv/kernel/traps.c @@ -78,12 +78,11 @@ static inline void do_trap_siginfo(int signo, int code, void do_trap(struct pt_regs *regs, int signo, int code, unsigned long addr, struct task_struct *tsk) { - if (show_unhandled_signals && unhandled_signal(tsk, signo) - && printk_ratelimit()) { - pr_info("%s[%d]: unhandled signal %d code 0x%x at 0x" REG_FMT, - tsk->comm, task_pid_nr(tsk), signo, code, addr); - print_vma_addr(KERN_CONT " in ", GET_IP(regs)); - pr_cont("\n"); + if (show_unhandled_signals && unhandled_signal(tsk, signo) && + printk_ratelimit()) { + pr_info("%s[%d]: unhandled signal %d code 0x%x at 0x" REG_FMT " in %pav\n", + tsk->comm, task_pid_nr(tsk), signo, code, addr, + &GET_IP(regs)); show_regs(regs); } diff --git a/arch/s390/mm/fault.c b/arch/s390/mm/fault.c index 93faeca52284..3b1d6d618af2 100644 --- a/arch/s390/mm/fault.c +++ b/arch/s390/mm/fault.c @@ -250,10 +250,9 @@ void report_user_fault(struct pt_regs *regs, long signr, int is_mm_fault) return; if (!printk_ratelimit()) return; - printk(KERN_ALERT "User process fault: interruption code %04x ilc:%d ", - regs->int_code & 0xffff, regs->int_code >> 17); - print_vma_addr(KERN_CONT "in ", regs->psw.addr); - printk(KERN_CONT "\n"); + printk(KERN_ALERT "User process fault: interruption code %04x ilc:%d in %pav\n", + regs->int_code & 0xffff, regs->int_code >> 17, + ®s->psw.addr); if (is_mm_fault) dump_fault_info(regs); show_regs(regs); diff --git a/arch/sparc/mm/fault_32.c b/arch/sparc/mm/fault_32.c index a8103a84b4ac..206ec5a1c915 100644 --- a/arch/sparc/mm/fault_32.c +++ b/arch/sparc/mm/fault_32.c @@ -113,15 +113,11 @@ show_signal_msg(struct pt_regs *regs, int sig, int code, if (!printk_ratelimit()) return; - printk("%s%s[%d]: segfault at %lx ip %px (rpc %px) sp %px error %x", + printk("%s%s[%d]: segfault at %lx ip %px (rpc %px) sp %px error %x in %pav\n", task_pid_nr(tsk) > 1 ? KERN_INFO : KERN_EMERG, tsk->comm, task_pid_nr(tsk), address, (void *)regs->pc, (void *)regs->u_regs[UREG_I7], - (void *)regs->u_regs[UREG_FP], code); - - print_vma_addr(KERN_CONT " in ", regs->pc); - - printk(KERN_CONT "\n"); + (void *)regs->u_regs[UREG_FP], code, ®s->pc); } static void __do_fault_siginfo(int code, int sig, struct pt_regs *regs, diff --git a/arch/sparc/mm/fault_64.c b/arch/sparc/mm/fault_64.c index 41363f46797b..a21199329ebe 100644 --- a/arch/sparc/mm/fault_64.c +++ b/arch/sparc/mm/fault_64.c @@ -154,15 +154,11 @@ show_signal_msg(struct pt_regs *regs, int sig, int code, if (!printk_ratelimit()) return; - printk("%s%s[%d]: segfault at %lx ip %px (rpc %px) sp %px error %x", + printk("%s%s[%d]: segfault at %lx ip %px (rpc %px) sp %px error %x in %pav\b", task_pid_nr(tsk) > 1 ? KERN_INFO : KERN_EMERG, tsk->comm, task_pid_nr(tsk), address, (void *)regs->tpc, (void *)regs->u_regs[UREG_I7], - (void *)regs->u_regs[UREG_FP], code); - - print_vma_addr(KERN_CONT " in ", regs->tpc); - - printk(KERN_CONT "\n"); + (void *)regs->u_regs[UREG_FP], code, ®s->tpc); } static void do_fault_siginfo(int code, int sig, struct pt_regs *regs, diff --git a/arch/tile/kernel/signal.c b/arch/tile/kernel/signal.c index f2bf557bb005..0556106dfe8a 100644 --- a/arch/tile/kernel/signal.c +++ b/arch/tile/kernel/signal.c @@ -383,13 +383,10 @@ void trace_unhandled_signal(const char *type, struct pt_regs *regs, if (show_unhandled_signals <= 1 && !printk_ratelimit()) return; - printk("%s%s[%d]: %s at %lx pc "REGFMT" signal %d", + printk("%s%s[%d]: %s at %lx pc " REGFMT " signal %d in %pav\n", task_pid_nr(tsk) > 1 ? KERN_INFO : KERN_EMERG, - tsk->comm, task_pid_nr(tsk), type, address, regs->pc, sig); - - print_vma_addr(KERN_CONT " in ", regs->pc); - - printk(KERN_CONT "\n"); + tsk->comm, task_pid_nr(tsk), type, address, regs->pc, sig, + ®s->pc); if (show_unhandled_signals > 1) { switch (sig) { diff --git a/arch/um/kernel/trap.c b/arch/um/kernel/trap.c index b2b02df9896e..9281248972c0 100644 --- a/arch/um/kernel/trap.c +++ b/arch/um/kernel/trap.c @@ -150,14 +150,11 @@ static void show_segv_info(struct uml_pt_regs *regs) if (!printk_ratelimit()) return; - printk("%s%s[%d]: segfault at %lx ip %px sp %px error %x", - task_pid_nr(tsk) > 1 ? KERN_INFO : KERN_EMERG, - tsk->comm, task_pid_nr(tsk), FAULT_ADDRESS(*fi), - (void *)UPT_IP(regs), (void *)UPT_SP(regs), - fi->error_code); - - print_vma_addr(KERN_CONT " in ", UPT_IP(regs)); - printk(KERN_CONT "\n"); + printk("%s%s[%d]: segfault at %lx ip %px sp %px error %x in %pav\n", + task_pid_nr(tsk) > 1 ? KERN_INFO : KERN_EMERG, + tsk->comm, task_pid_nr(tsk), FAULT_ADDRESS(*fi), + (void *)UPT_IP(regs), (void *)UPT_SP(regs), + fi->error_code, &UPT_IP(regs)); } static void bad_segv(struct faultinfo fi, unsigned long ip) diff --git a/arch/x86/kernel/signal.c b/arch/x86/kernel/signal.c index 4cdc0b27ec82..9ab0c5c50b29 100644 --- a/arch/x86/kernel/signal.c +++ b/arch/x86/kernel/signal.c @@ -841,15 +841,11 @@ void signal_fault(struct pt_regs *regs, void __user *frame, char *where) { struct task_struct *me = current; - if (show_unhandled_signals && printk_ratelimit()) { - printk("%s" - "%s[%d] bad frame in %s frame:%p ip:%lx sp:%lx orax:%lx", + if (show_unhandled_signals && printk_ratelimit()) + printk("%s%s[%d] bad frame in %s frame:%p ip:%lx sp:%lx orax:%lx in %pav\n", task_pid_nr(current) > 1 ? KERN_INFO : KERN_EMERG, me->comm, me->pid, where, frame, - regs->ip, regs->sp, regs->orig_ax); - print_vma_addr(KERN_CONT " in ", regs->ip); - pr_cont("\n"); - } + regs->ip, regs->sp, regs->orig_ax, ®s->ip); force_sig(SIGSEGV, me); } diff --git a/arch/x86/kernel/traps.c b/arch/x86/kernel/traps.c index 3d9b2308e7fa..c6e3d02759e5 100644 --- a/arch/x86/kernel/traps.c +++ b/arch/x86/kernel/traps.c @@ -270,13 +270,10 @@ do_trap(int trapnr, int signr, char *str, struct pt_regs *regs, tsk->thread.trap_nr = trapnr; if (show_unhandled_signals && unhandled_signal(tsk, signr) && - printk_ratelimit()) { - pr_info("%s[%d] trap %s ip:%lx sp:%lx error:%lx", + printk_ratelimit()) + pr_info("%s[%d] trap %s ip:%lx sp:%lx error:%lx in %pav\n", tsk->comm, tsk->pid, str, - regs->ip, regs->sp, error_code); - print_vma_addr(KERN_CONT " in ", regs->ip); - pr_cont("\n"); - } + regs->ip, regs->sp, error_code, ®s->ip); force_sig_info(signr, info ?: SEND_SIG_PRIV, tsk); } @@ -565,13 +562,10 @@ do_general_protection(struct pt_regs *regs, long error_code) tsk->thread.trap_nr = X86_TRAP_GP; if (show_unhandled_signals && unhandled_signal(tsk, SIGSEGV) && - printk_ratelimit()) { - pr_info("%s[%d] general protection ip:%lx sp:%lx error:%lx", + printk_ratelimit()) + pr_info("%s[%d] general protection ip:%lx sp:%lx error:%lx in %pav\n", tsk->comm, task_pid_nr(tsk), - regs->ip, regs->sp, error_code); - print_vma_addr(KERN_CONT " in ", regs->ip); - pr_cont("\n"); - } + regs->ip, regs->sp, error_code, ®s->ip); force_sig_info(SIGSEGV, SEND_SIG_PRIV, tsk); } diff --git a/arch/x86/mm/fault.c b/arch/x86/mm/fault.c index e6af2b464c3d..b629319e621a 100644 --- a/arch/x86/mm/fault.c +++ b/arch/x86/mm/fault.c @@ -857,14 +857,10 @@ show_signal_msg(struct pt_regs *regs, unsigned long error_code, if (!printk_ratelimit()) return; - printk("%s%s[%d]: segfault at %lx ip %px sp %px error %lx", - task_pid_nr(tsk) > 1 ? KERN_INFO : KERN_EMERG, - tsk->comm, task_pid_nr(tsk), address, - (void *)regs->ip, (void *)regs->sp, error_code); - - print_vma_addr(KERN_CONT " in ", regs->ip); - - printk(KERN_CONT "\n"); + printk("%s%s[%d]: segfault at %lx ip %px sp %px error %lx in %pav\n", + task_pid_nr(tsk) > 1 ? KERN_INFO : KERN_EMERG, + tsk->comm, task_pid_nr(tsk), address, + (void *)regs->ip, (void *)regs->sp, error_code, ®s->ip); } static void diff --git a/include/linux/mm.h b/include/linux/mm.h index 9f1270360983..9584bd3e8c25 100644 --- a/include/linux/mm.h +++ b/include/linux/mm.h @@ -2537,7 +2537,6 @@ extern int randomize_va_space; #endif const char * arch_vma_name(struct vm_area_struct *vma); -void print_vma_addr(char *prefix, unsigned long rip); void sparse_mem_maps_populate_node(struct page **map_map, unsigned long pnum_begin, diff --git a/lib/vsprintf.c b/lib/vsprintf.c index 942b5234a59b..9081476ea4ea 100644 --- a/lib/vsprintf.c +++ b/lib/vsprintf.c @@ -35,6 +35,8 @@ #include #include #include +#include + #ifdef CONFIG_BLOCK #include #endif @@ -407,6 +409,11 @@ struct printf_spec { #define FIELD_WIDTH_MAX ((1 << 23) - 1) #define PRECISION_MAX ((1 << 15) - 1) +static const struct printf_spec strspec = { + .field_width = -1, + .precision = -1, +}; + static noinline_for_stack char *number(char *buf, char *end, unsigned long long num, struct printf_spec spec) @@ -1427,6 +1434,45 @@ char *netdev_bits(char *buf, char *end, const void *addr, const char *fmt) return special_hex_number(buf, end, num, size); } +static noinline_for_stack +char *vma_addr(char *buf, char *end, const void *addr) +{ + struct mm_struct *mm = current->mm; + struct vm_area_struct *vma; + char *page; + char tbuf[2 * sizeof(unsigned long) * 2 + 4]; + const char *output = "?[0+0]"; + + /* + * we might be running from an atomic context so we cannot sleep + */ + if (!down_read_trylock(&mm->mmap_sem)) + goto output; + + vma = find_vma(mm, *(unsigned long *)addr); + if (!vma || !vma->vm_file) + goto up_read; + + page = (char *)__get_free_page(GFP_ATOMIC | __GFP_NOWARN); + if (page) { + char *fp; + + fp = file_path(vma->vm_file, page, PAGE_SIZE); + if (IS_ERR(fp)) + fp = "?"; + buf = string(buf, end, kbasename(fp), strspec); + sprintf(tbuf, "[%lx+%lx]", + vma->vm_start, vma->vm_end - vma->vm_start); + output = tbuf; + free_page((unsigned long)page); + } + +up_read: + up_read(&mm->mmap_sem); +output: + return string(buf, end, output, strspec); +} + static noinline_for_stack char *address_val(char *buf, char *end, const void *addr, const char *fmt) { @@ -1434,6 +1480,8 @@ char *address_val(char *buf, char *end, const void *addr, const char *fmt) int size; switch (fmt[1]) { + case 'v': + return vma_addr(buf, end, addr); case 'd': num = *(const dma_addr_t *)addr; size = sizeof(dma_addr_t); @@ -1474,11 +1522,7 @@ char *format_flags(char *buf, char *end, unsigned long flags, const struct trace_print_flags *names) { unsigned long mask; - const struct printf_spec strspec = { - .field_width = -1, - .precision = -1, - }; - const struct printf_spec numspec = { + static const struct printf_spec numspec = { .flags = SPECIAL|SMALL, .field_width = -1, .precision = -1, @@ -1548,10 +1592,6 @@ char *device_node_gen_full_name(const struct device_node *np, char *buf, char *e { int depth; const struct device_node *parent = np->parent; - static const struct printf_spec strspec = { - .field_width = -1, - .precision = -1, - }; /* special case for root node */ if (!parent) diff --git a/mm/memory.c b/mm/memory.c index bc760df8a7f4..f1f922421bde 100644 --- a/mm/memory.c +++ b/mm/memory.c @@ -4502,39 +4502,6 @@ int access_process_vm(struct task_struct *tsk, unsigned long addr, } EXPORT_SYMBOL_GPL(access_process_vm); -/* - * Print the name of a VMA. - */ -void print_vma_addr(char *prefix, unsigned long ip) -{ - struct mm_struct *mm = current->mm; - struct vm_area_struct *vma; - - /* - * we might be running from an atomic context so we cannot sleep - */ - if (!down_read_trylock(&mm->mmap_sem)) - return; - - vma = find_vma(mm, ip); - if (vma && vma->vm_file) { - struct file *f = vma->vm_file; - char *buf = (char *)__get_free_page(GFP_NOWAIT); - if (buf) { - char *p; - - p = file_path(f, buf, PAGE_SIZE); - if (IS_ERR(p)) - p = "?"; - printk("%s%s[%lx+%lx]", prefix, kbasename(p), - vma->vm_start, - vma->vm_end - vma->vm_start); - free_page((unsigned long)buf); - } - } - up_read(&mm->mmap_sem); -} - #if defined(CONFIG_PROVE_LOCKING) || defined(CONFIG_DEBUG_ATOMIC_SLEEP) void __might_fault(const char *file, int line) {