From mboxrd@z Thu Jan 1 00:00:00 1970 From: Felix Kuehling Subject: Re: [PATCH] drm: Print unadorned pointers Date: Wed, 18 Apr 2018 11:53:31 -0400 Message-ID: <85049bd0-2220-e718-090a-fa199184668a@amd.com> References: <20180418092450.13798-1-abrodkin@synopsys.com> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Return-path: In-Reply-To: <20180418092450.13798-1-abrodkin@synopsys.com> Content-Language: en-CA List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: intel-gfx-bounces@lists.freedesktop.org Sender: "Intel-gfx" To: Alexey Brodkin , dri-devel@lists.freedesktop.org Cc: =?UTF-8?Q?Michel_D=c3=a4nzer?= , =?UTF-8?Q?Heiko_St=c3=bcbner?= , Andrey Grodzovsky , David Airlie , Sandy Huang , Cihangir Akturk , amd-gfx@lists.freedesktop.org, Benjamin Gaignard , Ingo Molnar , "David (ChunMing) Zhou" , Thomas Hellstrom , Sinclair Yeh , linux-rockchip@lists.infradead.org, Russell King , Krzysztof Kozlowski , Maxime Ripard , "Jerry (Fangzhi) Zuo" , Roger He , Daniel Vetter , CK Hu , Dave Airlie , Borislav Petkov , Harry Wentland List-Id: amd-gfx.lists.freedesktop.org T24gMjAxOC0wNC0xOCAwNToyNCBBTSwgQWxleGV5IEJyb2RraW4gd3JvdGU6Cj4gQWZ0ZXIgY29t bWl0IGFkNjdiNzQgKCJwcmludGs6IGhhc2ggYWRkcmVzc2VzIHByaW50ZWQgd2l0aCAlcCIpCj4g cG9pbnRlcnMgYXJlIGJlaW5nIGhhc2hlZCB3aGVuIHByaW50ZWQuIEhvd2V2ZXIsIHRoaXMgbWFr ZXMKPiBkZWJ1ZyBvdXRwdXQgY29tcGxldGVseSB1c2VsZXNzLiBTd2l0Y2ggdG8gJXB4IGluIG9y ZGVyIHRvIHNlZSB0aGUKPiB1bmFkb3JuZWQga2VybmVsIHBvaW50ZXJzLgpNeSB1bmRlcnN0YW5k aW5nIG9mIHRoZSBwcmludGsgcG9pbnRlciBoYXNoaW5nIGNoYW5nZSB3YXMgdG8gZm9yY2UKcGVv cGxlIHRvIHRoaW5rIG1vcmUgY2FyZWZ1bGx5IHdoZW4gdGhleSByZWFsbHkgbmVlZCB0byBwcmlu dCBhIGtlcm5lbApwb2ludGVyLiBXaGVuIGl0IGlzIG9ubHkgdXNlZCB0byBpZGVudGlmeSBhbiBv YmplY3QsIHRoZW4gYSBoYXNoIHdvcmtzCmp1c3QgZmluZS4gTW9zdCBvZiB0aGUgY2hhbmdlcyBJ IHNlZSBpbiBhbWRncHUvYW1ka2ZkIGZhbGwgaW50byB0aGlzCmNhdGVnb3J5LgoKQXMgSSBzZWUg aXQsIGNoYW5naW5nIGFsbCAlcCB0byAlcHggYnkgYSBzY3JpcHQgdGFrZXMgdGhlIHRob3VnaHQK cHJvY2VzcyBvdXQgb2YgaXQgYW5kIHN1YnZlcnRzIHRoZSBpbnRlbnRpb24gb2YgdGhlIG9yaWdp bmFsIHBvaW50ZXIKaGFzaGluZyBjaGFuZ2UuCgpSZWdhcmRzLArCoCBGZWxpeAoKCj4KPiBUaGlz IHdhcyBkb25lIHdpdGggdGhlIGZvbGxvd2luZyBvbmUtbGluZXI6Cj4gIGZpbmQgZHJpdmVycy9n cHUvZHJtIC10eXBlIGYgLW5hbWUgIiouYyIgLWV4ZWMgc2VkIC1yIC1pICcvRFJNX0RFQlVHfEtF Uk5fREVCVUd8cHJfZGVidWcvIHMvJXBcYi8lcHgvZycge30gKwo+Cj4gU2lnbmVkLW9mZi1ieTog QWxleGV5IEJyb2RraW4gPGFicm9ka2luQHN5bm9wc3lzLmNvbT4KPiBDYzogQm9yaXNsYXYgUGV0 a292IDxicEBzdXNlLmRlPgo+IENjOiBUb2JpbiBDLiBIYXJkaW5nIDxtZUB0b2Jpbi5jYz4KPiBD YzogQWxleCBEZXVjaGVyIDxhbGV4YW5kZXIuZGV1Y2hlckBhbWQuY29tPgo+IENjOiBBbmRyZXkg R3JvZHpvdnNreSA8YW5kcmV5Lmdyb2R6b3Zza3lAYW1kLmNvbT4KPiBDYzogQXJuZCBCZXJnbWFu biA8YXJuZEBhcm5kYi5kZT4KPiBDYzogQmVuamFtaW4gR2FpZ25hcmQgPGJlbmphbWluLmdhaWdu YXJkQGxpbmFyby5vcmc+Cj4gQ2M6IENoZW4tWXUgVHNhaSA8d2Vuc0Bjc2llLm9yZz4KPiBDYzog Q2hyaXN0aWFuIEdtZWluZXIgPGNocmlzdGlhbi5nbWVpbmVyQGdtYWlsLmNvbT4KPiBDYzogIkNo cmlzdGlhbiBLw7ZuaWciIDxjaHJpc3RpYW4ua29lbmlnQGFtZC5jb20+Cj4gQ2M6IENpaGFuZ2ly IEFrdHVyayA8Y2FrdHVya0BnbWFpbC5jb20+Cj4gQ2M6IENLIEh1IDxjay5odUBtZWRpYXRlay5j b20+Cj4gQ2M6IERhbmllbCBWZXR0ZXIgPGRhbmllbC52ZXR0ZXJAZmZ3bGwuY2g+Cj4gQ2M6IERh dmUgQWlybGllIDxhaXJsaWVkQHJlZGhhdC5jb20+Cj4gQ2M6IERhdmlkIEFpcmxpZSA8YWlybGll ZEBsaW51eC5pZT4KPiBDYzogIkRhdmlkIChDaHVuTWluZykgWmhvdSIgPERhdmlkMS5aaG91QGFt ZC5jb20+Cj4gQ2M6IEdlcmQgSG9mZm1hbm4gPGtyYXhlbEByZWRoYXQuY29tPgo+IENjOiBHcmVn IEtyb2FoLUhhcnRtYW4gPGdyZWdraEBsaW51eGZvdW5kYXRpb24ub3JnPgo+IENjOiBHdXN0YXZv IFBhZG92YW4gPGd1c3Rhdm9AcGFkb3Zhbi5vcmc+Cj4gQ2M6IEhhcnJ5IFdlbnRsYW5kIDxoYXJy eS53ZW50bGFuZEBhbWQuY29tPgo+IENjOiAiSGVpa28gU3TDvGJuZXIiIDxoZWlrb0BzbnRlY2gu ZGU+Cj4gQ2M6IEluZ28gTW9sbmFyIDxtaW5nb0BrZXJuZWwub3JnPgo+IENjOiBKYW5pIE5pa3Vs YSA8amFuaS5uaWt1bGFAbGludXguaW50ZWwuY29tPgo+IENjOiAiSmVycnkgKEZhbmd6aGkpIFp1 byIgPEplcnJ5Llp1b0BhbWQuY29tPgo+IENjOiBKb29uYXMgTGFodGluZW4gPGpvb25hcy5sYWh0 aW5lbkBsaW51eC5pbnRlbC5jb20+Cj4gQ2M6IEtyenlzenRvZiBLb3psb3dza2kgPGtyemtAa2Vy bmVsLm9yZz4KPiBDYzogIkxlbyAoU3VucGVuZykgTGkiIDxzdW5wZW5nLmxpQGFtZC5jb20+Cj4g Q2M6IEx1Y2FzIFN0YWNoIDxsLnN0YWNoQHBlbmd1dHJvbml4LmRlPgo+IENjOiBNYWFydGVuIExh bmtob3JzdCA8bWFhcnRlbi5sYW5raG9yc3RAbGludXguaW50ZWwuY29tPgo+IENjOiBNYXR0aGlh cyBCcnVnZ2VyIDxtYXR0aGlhcy5iZ2dAZ21haWwuY29tPgo+IENjOiBNYXhpbWUgUmlwYXJkIDxt YXhpbWUucmlwYXJkQGJvb3RsaW4uY29tPgo+IENjOiAiTWljaGVsIETDpG56ZXIiIDxtaWNoZWwu ZGFlbnplckBhbWQuY29tPgo+IENjOiBPZGVkIEdhYmJheSA8b2RlZC5nYWJiYXlAZ21haWwuY29t Pgo+IENjOiBQaGlsaXBwIFphYmVsIDxwLnphYmVsQHBlbmd1dHJvbml4LmRlPgo+IENjOiBSb2Ig Q2xhcmsgPHJvYmRjbGFya0BnbWFpbC5jb20+Cj4gQ2M6IFJvZHJpZ28gVml2aSA8cm9kcmlnby52 aXZpQGludGVsLmNvbT4KPiBDYzogUm9nZXIgSGUgPEhvbmdiby5IZUBhbWQuY29tPgo+IENjOiBS b21hbiBMaSA8Um9tYW4uTGlAYW1kLmNvbT4KPiBDYzogUnVzc2VsbCBLaW5nIDxsaW51eEBhcm1s aW51eC5vcmcudWs+Cj4gQ2M6IFNhbXVlbCBMaSA8U2FtdWVsLkxpQGFtZC5jb20+Cj4gQ2M6IFNh bmR5IEh1YW5nIDxoamNAcm9jay1jaGlwcy5jb20+Cj4gQ2M6IFNlYW4gUGF1bCA8c2VhbnBhdWxA Y2hyb21pdW0ub3JnPgo+IENjOiBTaGlyaXNoIFMgPHNoaXJpc2guc0BhbWQuY29tPgo+IENjOiBT aW5jbGFpciBZZWggPHN5ZWhAdm13YXJlLmNvbT4KPiBDYzogVGhvbWFzIEhlbGxzdHJvbSA8dGhl bGxzdHJvbUB2bXdhcmUuY29tPgo+IENjOiBUb20gTGVuZGFja3kgPHRob21hcy5sZW5kYWNreUBh bWQuY29tPgo+IENjOiBUb255IENoZW5nIDxUb255LkNoZW5nQGFtZC5jb20+Cj4gQ2M6IFZpbmNl bnQgQWJyaW91IDx2aW5jZW50LmFicmlvdUBzdC5jb20+Cj4gQ2M6IFZNd2FyZSBHcmFwaGljcyA8 bGludXgtZ3JhcGhpY3MtbWFpbnRhaW5lckB2bXdhcmUuY29tPgo+IENjOiBsaW51eC1hcm0ta2Vy bmVsQGxpc3RzLmluZnJhZGVhZC5vcmcKPiBDYzogbGludXgtYXJtLW1zbUB2Z2VyLmtlcm5lbC5v cmcKPiBDYzogbGludXgta2VybmVsQHZnZXIua2VybmVsLm9yZwo+IENjOiBsaW51eC1tZWRpYXRl a0BsaXN0cy5pbmZyYWRlYWQub3JnCj4gQ2M6IGxpbnV4LXJvY2tjaGlwQGxpc3RzLmluZnJhZGVh ZC5vcmcKPiBDYzogZXRuYXZpdkBsaXN0cy5mcmVlZGVza3RvcC5vcmcKPiBDYzogZnJlZWRyZW5v QGxpc3RzLmZyZWVkZXNrdG9wLm9yZwo+IENjOiBhbWQtZ2Z4QGxpc3RzLmZyZWVkZXNrdG9wLm9y Zwo+IENjOiBpbnRlbC1nZnhAbGlzdHMuZnJlZWRlc2t0b3Aub3JnCj4gQ2M6IHZpcnR1YWxpemF0 aW9uQGxpc3RzLmxpbnV4LWZvdW5kYXRpb24ub3JnCj4gLS0tCj4gIGRyaXZlcnMvZ3B1L2RybS9h bWQvYW1kZ3B1L2FtZGdwdV9hbWRrZmRfZ3B1dm0uYyAgIHwgMTQgKysrLS0tLQo+ICBkcml2ZXJz L2dwdS9kcm0vYW1kL2FtZGdwdS9hbWRncHVfZGlzcGxheS5jICAgICAgICB8ICA0ICstCj4gIGRy aXZlcnMvZ3B1L2RybS9hbWQvYW1ka2ZkL2tmZF9jaGFyZGV2LmMgICAgICAgICAgIHwgIDQgKy0K PiAgZHJpdmVycy9ncHUvZHJtL2FtZC9hbWRrZmQva2ZkX2RiZ2Rldi5jICAgICAgICAgICAgfCAg MiArLQo+ICBkcml2ZXJzL2dwdS9kcm0vYW1kL2FtZGtmZC9rZmRfZGV2aWNlLmMgICAgICAgICAg ICB8IDEwICsrLS0tCj4gIGRyaXZlcnMvZ3B1L2RybS9hbWQvYW1ka2ZkL2tmZF9kb29yYmVsbC5j ICAgICAgICAgIHwgIDQgKy0KPiAgZHJpdmVycy9ncHUvZHJtL2FtZC9hbWRrZmQva2ZkX2V2ZW50 cy5jICAgICAgICAgICAgfCAgNCArLQo+ICBkcml2ZXJzL2dwdS9kcm0vYW1kL2FtZGtmZC9rZmRf a2VybmVsX3F1ZXVlLmMgICAgICB8ICAyICstCj4gIGRyaXZlcnMvZ3B1L2RybS9hbWQvYW1ka2Zk L2tmZF9wcm9jZXNzLmMgICAgICAgICAgIHwgIDQgKy0KPiAgZHJpdmVycy9ncHUvZHJtL2FtZC9h bWRrZmQva2ZkX3F1ZXVlLmMgICAgICAgICAgICAgfCAxOCArKysrLS0tLS0KPiAgZHJpdmVycy9n cHUvZHJtL2FtZC9kaXNwbGF5L2FtZGdwdV9kbS9hbWRncHVfZG0uYyAgfCAxNCArKystLS0tCj4g IC4uLi9hbWQvZGlzcGxheS9hbWRncHVfZG0vYW1kZ3B1X2RtX21zdF90eXBlcy5jICAgIHwgIDIg Ky0KPiAgZHJpdmVycy9ncHUvZHJtL2FybWFkYS9hcm1hZGFfZ2VtLmMgICAgICAgICAgICAgICAg fCAxMiArKystLS0KPiAgZHJpdmVycy9ncHUvZHJtL2RybV9hdG9taWMuYyAgICAgICAgICAgICAg ICAgICAgICAgfCA0NCArKysrKysrKysrKy0tLS0tLS0tLS0tCj4gIGRyaXZlcnMvZ3B1L2RybS9k cm1fYnVmcy5jICAgICAgICAgICAgICAgICAgICAgICAgIHwgIDggKystLQo+ICBkcml2ZXJzL2dw dS9kcm0vZHJtX2RwX21zdF90b3BvbG9neS5jICAgICAgICAgICAgICB8ICA0ICstCj4gIGRyaXZl cnMvZ3B1L2RybS9kcm1fbGVhc2UuYyAgICAgICAgICAgICAgICAgICAgICAgIHwgIDYgKy0tCj4g IGRyaXZlcnMvZ3B1L2RybS9kcm1fbG9jay5jICAgICAgICAgICAgICAgICAgICAgICAgIHwgIDIg Ky0KPiAgZHJpdmVycy9ncHUvZHJtL2RybV9zY2F0dGVyLmMgICAgICAgICAgICAgICAgICAgICAg fCAgNCArLQo+ICBkcml2ZXJzL2dwdS9kcm0vZXRuYXZpdi9ldG5hdml2X2Rydi5jICAgICAgICAg ICAgICB8ICA2ICstLQo+ICBkcml2ZXJzL2dwdS9kcm0vaTgxMC9pODEwX2RtYS5jICAgICAgICAg ICAgICAgICAgICB8ICAyICstCj4gIGRyaXZlcnMvZ3B1L2RybS9pOTE1L2k5MTVfcGVyZi5jICAg ICAgICAgICAgICAgICAgIHwgIDIgKy0KPiAgZHJpdmVycy9ncHUvZHJtL2k5MTUvaW50ZWxfZGlz cGxheS5jICAgICAgICAgICAgICAgfCAgMiArLQo+ICBkcml2ZXJzL2dwdS9kcm0vaTkxNS9pbnRl bF9ndWNfY3QuYyAgICAgICAgICAgICAgICB8ICA0ICstCj4gIGRyaXZlcnMvZ3B1L2RybS9pOTE1 L2ludGVsX2d1Y19zdWJtaXNzaW9uLmMgICAgICAgIHwgIDIgKy0KPiAgZHJpdmVycy9ncHUvZHJt L2k5MTUvaW50ZWxfdWNfZncuYyAgICAgICAgICAgICAgICAgfCAgMiArLQo+ICBkcml2ZXJzL2dw dS9kcm0vbWVkaWF0ZWsvbXRrX2RybV9nZW0uYyAgICAgICAgICAgICB8ICAyICstCj4gIGRyaXZl cnMvZ3B1L2RybS9tZ2EvbWdhX3dhcnAuYyAgICAgICAgICAgICAgICAgICAgIHwgIDIgKy0KPiAg ZHJpdmVycy9ncHUvZHJtL21zbS9tc21fZHJ2LmMgICAgICAgICAgICAgICAgICAgICAgfCAgNCAr LQo+ICBkcml2ZXJzL2dwdS9kcm0vcXhsL3F4bF9jbWQuYyAgICAgICAgICAgICAgICAgICAgICB8 ICA0ICstCj4gIGRyaXZlcnMvZ3B1L2RybS9xeGwvcXhsX2ZiLmMgICAgICAgICAgICAgICAgICAg ICAgIHwgIDIgKy0KPiAgZHJpdmVycy9ncHUvZHJtL3F4bC9xeGxfdHRtLmMgICAgICAgICAgICAg ICAgICAgICAgfCAgMiArLQo+ICBkcml2ZXJzL2dwdS9kcm0vcmFkZW9uL3JhZGVvbl9kaXNwbGF5 LmMgICAgICAgICAgICB8ICAyICstCj4gIGRyaXZlcnMvZ3B1L2RybS9yYWRlb24vcmFkZW9uX2Rw X21zdC5jICAgICAgICAgICAgIHwgMTIgKysrLS0tCj4gIGRyaXZlcnMvZ3B1L2RybS9yYWRlb24v cmFkZW9uX29iamVjdC5jICAgICAgICAgICAgIHwgIDIgKy0KPiAgZHJpdmVycy9ncHUvZHJtL3Jv Y2tjaGlwL3JvY2tjaGlwX2RybV9mYmRldi5jICAgICAgfCAgMiArLQo+ICBkcml2ZXJzL2dwdS9k cm0vc2F2YWdlL3NhdmFnZV9iY2kuYyAgICAgICAgICAgICAgICB8ICAyICstCj4gIGRyaXZlcnMv Z3B1L2RybS9zdGkvc3RpX2dkcC5jICAgICAgICAgICAgICAgICAgICAgIHwgIDQgKy0KPiAgZHJp dmVycy9ncHUvZHJtL3N0aS9zdGlfbWl4ZXIuYyAgICAgICAgICAgICAgICAgICAgfCAgMiArLQo+ ICBkcml2ZXJzL2dwdS9kcm0vc3VuNGkvc3VuNGlfY3J0Yy5jICAgICAgICAgICAgICAgICB8ICA0 ICstCj4gIGRyaXZlcnMvZ3B1L2RybS90dG0vdHRtX3BhZ2VfYWxsb2MuYyAgICAgICAgICAgICAg IHwgIDIgKy0KPiAgZHJpdmVycy9ncHUvZHJtL3VkbC91ZGxfZmIuYyAgICAgICAgICAgICAgICAg ICAgICAgfCAgMiArLQo+ICBkcml2ZXJzL2dwdS9kcm0vdmlhL3ZpYV9kbWEuYyAgICAgICAgICAg ICAgICAgICAgICB8ICA0ICstCj4gIGRyaXZlcnMvZ3B1L2RybS92aWEvdmlhX2lycS5jICAgICAg ICAgICAgICAgICAgICAgIHwgIDIgKy0KPiAgZHJpdmVycy9ncHUvZHJtL3Ztd2dmeC92bXdnZnhf b3ZlcmxheS5jICAgICAgICAgICAgfCAgMiArLQo+ICA0NSBmaWxlcyBjaGFuZ2VkLCAxMjAgaW5z ZXJ0aW9ucygrKSwgMTIwIGRlbGV0aW9ucygtKQo+Cj4gZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1 L2RybS9hbWQvYW1kZ3B1L2FtZGdwdV9hbWRrZmRfZ3B1dm0uYyBiL2RyaXZlcnMvZ3B1L2RybS9h bWQvYW1kZ3B1L2FtZGdwdV9hbWRrZmRfZ3B1dm0uYwo+IGluZGV4IDFkNmUxNDc5ZGEzOC4uMzJl ODVmZTgzMTUyIDEwMDY0NAo+IC0tLSBhL2RyaXZlcnMvZ3B1L2RybS9hbWQvYW1kZ3B1L2FtZGdw dV9hbWRrZmRfZ3B1dm0uYwo+ICsrKyBiL2RyaXZlcnMvZ3B1L2RybS9hbWQvYW1kZ3B1L2FtZGdw dV9hbWRrZmRfZ3B1dm0uYwo+IEBAIC00MzgsNyArNDM4LDcgQEAgc3RhdGljIGludCBhZGRfYm9f dG9fdm0oc3RydWN0IGFtZGdwdV9kZXZpY2UgKmFkZXYsIHN0cnVjdCBrZ2RfbWVtICptZW0sCj4g IAlpZiAoIWJvX3ZhX2VudHJ5KQo+ICAJCXJldHVybiAtRU5PTUVNOwo+ICAKPiAtCXByX2RlYnVn KCJcdCBhZGQgVkEgMHglbGx4IC0gMHglbGx4IHRvIHZtICVwXG4iLCB2YSwKPiArCXByX2RlYnVn KCJcdCBhZGQgVkEgMHglbGx4IC0gMHglbGx4IHRvIHZtICVweFxuIiwgdmEsCj4gIAkJCXZhICsg Ym9fc2l6ZSwgdm0pOwo+ICAKPiAgCS8qIEFkZCBCTyB0byBWTSBpbnRlcm5hbCBkYXRhIHN0cnVj dHVyZXMqLwo+IEBAIC00OTcsNyArNDk3LDcgQEAgc3RhdGljIGludCBhZGRfYm9fdG9fdm0oc3Ry dWN0IGFtZGdwdV9kZXZpY2UgKmFkZXYsIHN0cnVjdCBrZ2RfbWVtICptZW0sCj4gIHN0YXRpYyB2 b2lkIHJlbW92ZV9ib19mcm9tX3ZtKHN0cnVjdCBhbWRncHVfZGV2aWNlICphZGV2LAo+ICAJCXN0 cnVjdCBrZmRfYm9fdmFfbGlzdCAqZW50cnksIHVuc2lnbmVkIGxvbmcgc2l6ZSkKPiAgewo+IC0J cHJfZGVidWcoIlx0IHJlbW92ZSBWQSAweCVsbHggLSAweCVsbHggaW4gZW50cnkgJXBcbiIsCj4g Kwlwcl9kZWJ1ZygiXHQgcmVtb3ZlIFZBIDB4JWxseCAtIDB4JWxseCBpbiBlbnRyeSAlcHhcbiIs Cj4gIAkJCWVudHJ5LT52YSwKPiAgCQkJZW50cnktPnZhICsgc2l6ZSwgZW50cnkpOwo+ICAJYW1k Z3B1X3ZtX2JvX3JtdihhZGV2LCBlbnRyeS0+Ym9fdmEpOwo+IEBAIC05ODIsNyArOTgyLDcgQEAg dm9pZCBhbWRncHVfYW1ka2ZkX2dwdXZtX2Rlc3Ryb3lfcHJvY2Vzc192bShzdHJ1Y3Qga2dkX2Rl diAqa2dkLCB2b2lkICp2bSkKPiAgCWlmIChXQVJOX09OKCFrZ2QgfHwgIXZtKSkKPiAgCQlyZXR1 cm47Cj4gIAo+IC0JcHJfZGVidWcoIkRlc3Ryb3lpbmcgcHJvY2VzcyB2bSAlcFxuIiwgdm0pOwo+ ICsJcHJfZGVidWcoIkRlc3Ryb3lpbmcgcHJvY2VzcyB2bSAlcHhcbiIsIHZtKTsKPiAgCj4gIAkv KiBSZWxlYXNlIHRoZSBWTSBjb250ZXh0ICovCj4gIAlhbWRncHVfdm1fZmluaShhZGV2LCBhdm0p Owo+IEBAIC0xMTkxLDcgKzExOTEsNyBAQCBpbnQgYW1kZ3B1X2FtZGtmZF9ncHV2bV9tYXBfbWVt b3J5X3RvX2dwdSgKPiAgCWRvbWFpbiA9IG1lbS0+ZG9tYWluOwo+ICAJYm9fc2l6ZSA9IGJvLT50 Ym8ubWVtLnNpemU7Cj4gIAo+IC0JcHJfZGVidWcoIk1hcCBWQSAweCVsbHggLSAweCVsbHggdG8g dm0gJXAgZG9tYWluICVzXG4iLAo+ICsJcHJfZGVidWcoIk1hcCBWQSAweCVsbHggLSAweCVsbHgg dG8gdm0gJXB4IGRvbWFpbiAlc1xuIiwKPiAgCQkJbWVtLT52YSwKPiAgCQkJbWVtLT52YSArIGJv X3NpemUgKiAoMSArIG1lbS0+YXFsX3F1ZXVlKSwKPiAgCQkJdm0sIGRvbWFpbl9zdHJpbmcoZG9t YWluKSk7Cj4gQEAgLTEyMzEsNyArMTIzMSw3IEBAIGludCBhbWRncHVfYW1ka2ZkX2dwdXZtX21h cF9tZW1vcnlfdG9fZ3B1KAo+ICAKPiAgCWxpc3RfZm9yX2VhY2hfZW50cnkoZW50cnksICZtZW0t PmJvX3ZhX2xpc3QsIGJvX2xpc3QpIHsKPiAgCQlpZiAoZW50cnktPmJvX3ZhLT5iYXNlLnZtID09 IHZtICYmICFlbnRyeS0+aXNfbWFwcGVkKSB7Cj4gLQkJCXByX2RlYnVnKCJcdCBtYXAgVkEgMHgl bGx4IC0gMHglbGx4IGluIGVudHJ5ICVwXG4iLAo+ICsJCQlwcl9kZWJ1ZygiXHQgbWFwIFZBIDB4 JWxseCAtIDB4JWxseCBpbiBlbnRyeSAlcHhcbiIsCj4gIAkJCQkJZW50cnktPnZhLCBlbnRyeS0+ dmEgKyBib19zaXplLAo+ICAJCQkJCWVudHJ5KTsKPiAgCj4gQEAgLTEzMDIsMTQgKzEzMDIsMTQg QEAgaW50IGFtZGdwdV9hbWRrZmRfZ3B1dm1fdW5tYXBfbWVtb3J5X2Zyb21fZ3B1KAo+ICAJaWYg KHVubGlrZWx5KHJldCkpCj4gIAkJZ290byB1bnJlc2VydmVfb3V0Owo+ICAKPiAtCXByX2RlYnVn KCJVbm1hcCBWQSAweCVsbHggLSAweCVsbHggZnJvbSB2bSAlcFxuIiwKPiArCXByX2RlYnVnKCJV bm1hcCBWQSAweCVsbHggLSAweCVsbHggZnJvbSB2bSAlcHhcbiIsCj4gIAkJbWVtLT52YSwKPiAg CQltZW0tPnZhICsgYm9fc2l6ZSAqICgxICsgbWVtLT5hcWxfcXVldWUpLAo+ICAJCXZtKTsKPiAg Cj4gIAlsaXN0X2Zvcl9lYWNoX2VudHJ5KGVudHJ5LCAmbWVtLT5ib192YV9saXN0LCBib19saXN0 KSB7Cj4gIAkJaWYgKGVudHJ5LT5ib192YS0+YmFzZS52bSA9PSB2bSAmJiBlbnRyeS0+aXNfbWFw cGVkKSB7Cj4gLQkJCXByX2RlYnVnKCJcdCB1bm1hcCBWQSAweCVsbHggLSAweCVsbHggZnJvbSBl bnRyeSAlcFxuIiwKPiArCQkJcHJfZGVidWcoIlx0IHVubWFwIFZBIDB4JWxseCAtIDB4JWxseCBm cm9tIGVudHJ5ICVweFxuIiwKPiAgCQkJCQllbnRyeS0+dmEsCj4gIAkJCQkJZW50cnktPnZhICsg Ym9fc2l6ZSwKPiAgCQkJCQllbnRyeSk7Cj4gZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2RybS9h bWQvYW1kZ3B1L2FtZGdwdV9kaXNwbGF5LmMgYi9kcml2ZXJzL2dwdS9kcm0vYW1kL2FtZGdwdS9h bWRncHVfZGlzcGxheS5jCj4gaW5kZXggOTNmNzAwYWIxYmZiLi40NGExOWQ3Y2M5NDEgMTAwNjQ0 Cj4gLS0tIGEvZHJpdmVycy9ncHUvZHJtL2FtZC9hbWRncHUvYW1kZ3B1X2Rpc3BsYXkuYwo+ICsr KyBiL2RyaXZlcnMvZ3B1L2RybS9hbWQvYW1kZ3B1L2FtZGdwdV9kaXNwbGF5LmMKPiBAQCAtMTEy LDcgKzExMiw3IEBAIHN0YXRpYyB2b2lkIGFtZGdwdV9kaXNwbGF5X2ZsaXBfd29ya19mdW5jKHN0 cnVjdCB3b3JrX3N0cnVjdCAqX193b3JrKQo+ICAJc3Bpbl91bmxvY2tfaXJxcmVzdG9yZSgmY3J0 Yy0+ZGV2LT5ldmVudF9sb2NrLCBmbGFncyk7Cj4gIAo+ICAKPiAtCURSTV9ERUJVR19EUklWRVIo ImNydGM6JWRbJXBdLCBwZmxpcF9zdGF0OkFNREdQVV9GTElQX1NVQk1JVFRFRCwgd29yazogJXAs XG4iLAo+ICsJRFJNX0RFQlVHX0RSSVZFUigiY3J0YzolZFslcHhdLCBwZmxpcF9zdGF0OkFNREdQ VV9GTElQX1NVQk1JVFRFRCwgd29yazogJXB4LFxuIiwKPiAgCQkJCQkgYW1kZ3B1X2NydGMtPmNy dGNfaWQsIGFtZGdwdV9jcnRjLCB3b3JrKTsKPiAgCj4gIH0KPiBAQCAtMjI2LDcgKzIyNiw3IEBA IGludCBhbWRncHVfZGlzcGxheV9jcnRjX3BhZ2VfZmxpcF90YXJnZXQoc3RydWN0IGRybV9jcnRj ICpjcnRjLAo+ICAJYW1kZ3B1X2NydGMtPnBmbGlwX3dvcmtzID0gd29yazsKPiAgCj4gIAo+IC0J RFJNX0RFQlVHX0RSSVZFUigiY3J0YzolZFslcF0sIHBmbGlwX3N0YXQ6QU1ER1BVX0ZMSVBfUEVO RElORywgd29yazogJXAsXG4iLAo+ICsJRFJNX0RFQlVHX0RSSVZFUigiY3J0YzolZFslcHhdLCBw ZmxpcF9zdGF0OkFNREdQVV9GTElQX1BFTkRJTkcsIHdvcms6ICVweCxcbiIsCj4gIAkJCQkJIGFt ZGdwdV9jcnRjLT5jcnRjX2lkLCBhbWRncHVfY3J0Yywgd29yayk7Cj4gIAkvKiB1cGRhdGUgY3J0 YyBmYiAqLwo+ICAJY3J0Yy0+cHJpbWFyeS0+ZmIgPSBmYjsKPiBkaWZmIC0tZ2l0IGEvZHJpdmVy cy9ncHUvZHJtL2FtZC9hbWRrZmQva2ZkX2NoYXJkZXYuYyBiL2RyaXZlcnMvZ3B1L2RybS9hbWQv YW1ka2ZkL2tmZF9jaGFyZGV2LmMKPiBpbmRleCBjZDY3OWNmMWZkMzAuLmZjOTFkZTZhN2YwMiAx MDA2NDQKPiAtLS0gYS9kcml2ZXJzL2dwdS9kcm0vYW1kL2FtZGtmZC9rZmRfY2hhcmRldi5jCj4g KysrIGIvZHJpdmVycy9ncHUvZHJtL2FtZC9hbWRrZmQva2ZkX2NoYXJkZXYuYwo+IEBAIC0yMzMs NyArMjMzLDcgQEAgc3RhdGljIGludCBzZXRfcXVldWVfcHJvcGVydGllc19mcm9tX3VzZXIoc3Ry dWN0IHF1ZXVlX3Byb3BlcnRpZXMgKnFfcHJvcGVydGllcywKPiAgCXByX2RlYnVnKCJRdWV1ZSBT aXplOiAweCVsbFgsICV1XG4iLAo+ICAJCQlxX3Byb3BlcnRpZXMtPnF1ZXVlX3NpemUsIGFyZ3Mt PnJpbmdfc2l6ZSk7Cj4gIAo+IC0JcHJfZGVidWcoIlF1ZXVlIHIvdyBQb2ludGVyczogJXAsICVw XG4iLAo+ICsJcHJfZGVidWcoIlF1ZXVlIHIvdyBQb2ludGVyczogJXB4LCAlcHhcbiIsCj4gIAkJ CXFfcHJvcGVydGllcy0+cmVhZF9wdHIsCj4gIAkJCXFfcHJvcGVydGllcy0+d3JpdGVfcHRyKTsK PiAgCj4gQEAgLTcyNSw3ICs3MjUsNyBAQCBzdGF0aWMgaW50IGtmZF9pb2N0bF9kYmdfd2F2ZV9j b250cm9sKHN0cnVjdCBmaWxlICpmaWxlcCwKPiAgCj4gIAltdXRleF9sb2NrKGtmZF9nZXRfZGJn bWdyX211dGV4KCkpOwo+ICAKPiAtCXByX2RlYnVnKCJDYWxsaW5nIGRiZyBtYW5hZ2VyIHByb2Nl c3MgJXAsIG9wZXJhbmQgJXUsIG1vZGUgJXUsIHRyYXBJZCAldSwgbWVzc2FnZSAldVxuIiwKPiAr CXByX2RlYnVnKCJDYWxsaW5nIGRiZyBtYW5hZ2VyIHByb2Nlc3MgJXB4LCBvcGVyYW5kICV1LCBt b2RlICV1LCB0cmFwSWQgJXUsIG1lc3NhZ2UgJXVcbiIsCj4gIAkJCXdhY19pbmZvLnByb2Nlc3Ms IHdhY19pbmZvLm9wZXJhbmQsCj4gIAkJCXdhY19pbmZvLm1vZGUsIHdhY19pbmZvLnRyYXBJZCwK PiAgCQkJd2FjX2luZm8uZGJnV2F2ZV9tc2cuRGJnV2F2ZU1zZy5XYXZlTXNnSW5mb0dlbjIuVmFs dWUpOwo+IGRpZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9kcm0vYW1kL2FtZGtmZC9rZmRfZGJnZGV2 LmMgYi9kcml2ZXJzL2dwdS9kcm0vYW1kL2FtZGtmZC9rZmRfZGJnZGV2LmMKPiBpbmRleCBhZmIy NmYyMDVkMjkuLmMzMzUwZDAyNzBiMiAxMDA2NDQKPiAtLS0gYS9kcml2ZXJzL2dwdS9kcm0vYW1k L2FtZGtmZC9rZmRfZGJnZGV2LmMKPiArKysgYi9kcml2ZXJzL2dwdS9kcm0vYW1kL2FtZGtmZC9r ZmRfZGJnZGV2LmMKPiBAQCAtNDAxLDcgKzQwMSw3IEBAIHN0YXRpYyBpbnQgZGJnZGV2X2FkZHJl c3Nfd2F0Y2hfZGlxKHN0cnVjdCBrZmRfZGJnZGV2ICpkYmdkZXYsCj4gIAkJcHJfZGVidWcoIlx0 XHQlMzBzXG4iLCAiKiAqICogKiAqICogKiAqICogKiAqICogKiAqICogKiAqICoiKTsKPiAgCQlw cl9kZWJ1ZygiXHRcdCUyMHMgJTA4eFxuIiwgInJlZ2lzdGVyIGluZGV4IDoiLCBpKTsKPiAgCQlw cl9kZWJ1ZygiXHRcdCUyMHMgJTA4eFxuIiwgInZtaWQgaXMgOiIsIHZtaWQpOwo+IC0JCXByX2Rl YnVnKCJcdFx0JTIwcyAlcFxuIiwgIkFkZCBwdHIgaXMgOiIsCj4gKwkJcHJfZGVidWcoIlx0XHQl MjBzICVweFxuIiwgIkFkZCBwdHIgaXMgOiIsCj4gIAkJCQlhZHdfaW5mby0+d2F0Y2hfYWRkcmVz cyk7Cj4gIAkJcHJfZGVidWcoIlx0XHQlMjBzICUwOGxseFxuIiwgIkFkZCAgICAgaXMgOiIsCj4g IAkJCQlhZHdfaW5mby0+d2F0Y2hfYWRkcmVzc1tpXSk7Cj4gZGlmZiAtLWdpdCBhL2RyaXZlcnMv Z3B1L2RybS9hbWQvYW1ka2ZkL2tmZF9kZXZpY2UuYyBiL2RyaXZlcnMvZ3B1L2RybS9hbWQvYW1k a2ZkL2tmZF9kZXZpY2UuYwo+IGluZGV4IDMzNDY2OTk5NjBkZC4uNTdjMjYxNTVlNDJlIDEwMDY0 NAo+IC0tLSBhL2RyaXZlcnMvZ3B1L2RybS9hbWQvYW1ka2ZkL2tmZF9kZXZpY2UuYwo+ICsrKyBi L2RyaXZlcnMvZ3B1L2RybS9hbWQvYW1ka2ZkL2tmZF9kZXZpY2UuYwo+IEBAIC02MTIsNyArNjEy LDcgQEAgc3RhdGljIGludCBrZmRfZ3R0X3NhX2luaXQoc3RydWN0IGtmZF9kZXYgKmtmZCwgdW5z aWduZWQgaW50IGJ1Zl9zaXplLAo+ICAJaWYgKCFrZmQtPmd0dF9zYV9iaXRtYXApCj4gIAkJcmV0 dXJuIC1FTk9NRU07Cj4gIAo+IC0JcHJfZGVidWcoImd0dF9zYV9udW1fb2ZfY2h1bmtzID0gJWQs IGd0dF9zYV9iaXRtYXAgPSAlcFxuIiwKPiArCXByX2RlYnVnKCJndHRfc2FfbnVtX29mX2NodW5r cyA9ICVkLCBndHRfc2FfYml0bWFwID0gJXB4XG4iLAo+ICAJCQlrZmQtPmd0dF9zYV9udW1fb2Zf Y2h1bmtzLCBrZmQtPmd0dF9zYV9iaXRtYXApOwo+ICAKPiAgCW11dGV4X2luaXQoJmtmZC0+Z3R0 X3NhX2xvY2spOwo+IEBAIC02NTYsNyArNjU2LDcgQEAgaW50IGtmZF9ndHRfc2FfYWxsb2NhdGUo c3RydWN0IGtmZF9kZXYgKmtmZCwgdW5zaWduZWQgaW50IHNpemUsCj4gIAlpZiAoKCptZW1fb2Jq KSA9PSBOVUxMKQo+ICAJCXJldHVybiAtRU5PTUVNOwo+ICAKPiAtCXByX2RlYnVnKCJBbGxvY2F0 ZWQgbWVtX29iaiA9ICVwIGZvciBzaXplID0gJWRcbiIsICptZW1fb2JqLCBzaXplKTsKPiArCXBy X2RlYnVnKCJBbGxvY2F0ZWQgbWVtX29iaiA9ICVweCBmb3Igc2l6ZSA9ICVkXG4iLCAqbWVtX29i aiwgc2l6ZSk7Cj4gIAo+ICAJc3RhcnRfc2VhcmNoID0gMDsKPiAgCj4gQEAgLTY4Niw3ICs2ODYs NyBAQCBpbnQga2ZkX2d0dF9zYV9hbGxvY2F0ZShzdHJ1Y3Qga2ZkX2RldiAqa2ZkLCB1bnNpZ25l ZCBpbnQgc2l6ZSwKPiAgCQkJCQlmb3VuZCwKPiAgCQkJCQlrZmQtPmd0dF9zYV9jaHVua19zaXpl KTsKPiAgCj4gLQlwcl9kZWJ1ZygiZ3B1X2FkZHIgPSAlcCwgY3B1X2FkZHIgPSAlcFxuIiwKPiAr CXByX2RlYnVnKCJncHVfYWRkciA9ICVweCwgY3B1X2FkZHIgPSAlcHhcbiIsCj4gIAkJCSh1aW50 NjRfdCAqKSAoKm1lbV9vYmopLT5ncHVfYWRkciwgKCptZW1fb2JqKS0+Y3B1X3B0cik7Cj4gIAo+ ICAJLyogSWYgd2UgbmVlZCBvbmx5IG9uZSBjaHVuaywgbWFyayBpdCBhcyBhbGxvY2F0ZWQgYW5k IGdldCBvdXQgKi8KPiBAQCAtNzQwLDcgKzc0MCw3IEBAIGludCBrZmRfZ3R0X3NhX2FsbG9jYXRl KHN0cnVjdCBrZmRfZGV2ICprZmQsIHVuc2lnbmVkIGludCBzaXplLAo+ICAJcmV0dXJuIDA7Cj4g IAo+ICBrZmRfZ3R0X25vX2ZyZWVfY2h1bms6Cj4gLQlwcl9kZWJ1ZygiQWxsb2NhdGlvbiBmYWls ZWQgd2l0aCBtZW1fb2JqID0gJXBcbiIsIG1lbV9vYmopOwo+ICsJcHJfZGVidWcoIkFsbG9jYXRp b24gZmFpbGVkIHdpdGggbWVtX29iaiA9ICVweFxuIiwgbWVtX29iaik7Cj4gIAltdXRleF91bmxv Y2soJmtmZC0+Z3R0X3NhX2xvY2spOwo+ICAJa2ZyZWUobWVtX29iaik7Cj4gIAlyZXR1cm4gLUVO T01FTTsKPiBAQCAtNzU0LDcgKzc1NCw3IEBAIGludCBrZmRfZ3R0X3NhX2ZyZWUoc3RydWN0IGtm ZF9kZXYgKmtmZCwgc3RydWN0IGtmZF9tZW1fb2JqICptZW1fb2JqKQo+ICAJaWYgKCFtZW1fb2Jq KQo+ICAJCXJldHVybiAwOwo+ICAKPiAtCXByX2RlYnVnKCJGcmVlIG1lbV9vYmogPSAlcCwgcmFu Z2Vfc3RhcnQgPSAlZCwgcmFuZ2VfZW5kID0gJWRcbiIsCj4gKwlwcl9kZWJ1ZygiRnJlZSBtZW1f b2JqID0gJXB4LCByYW5nZV9zdGFydCA9ICVkLCByYW5nZV9lbmQgPSAlZFxuIiwKPiAgCQkJbWVt X29iaiwgbWVtX29iai0+cmFuZ2Vfc3RhcnQsIG1lbV9vYmotPnJhbmdlX2VuZCk7Cj4gIAo+ICAJ bXV0ZXhfbG9jaygma2ZkLT5ndHRfc2FfbG9jayk7Cj4gZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1 L2RybS9hbWQvYW1ka2ZkL2tmZF9kb29yYmVsbC5jIGIvZHJpdmVycy9ncHUvZHJtL2FtZC9hbWRr ZmQva2ZkX2Rvb3JiZWxsLmMKPiBpbmRleCBlYmI0ZGExNGUzZGYuLjdiNWFkMGM1NzdjOCAxMDA2 NDQKPiAtLS0gYS9kcml2ZXJzL2dwdS9kcm0vYW1kL2FtZGtmZC9rZmRfZG9vcmJlbGwuYwo+ICsr KyBiL2RyaXZlcnMvZ3B1L2RybS9hbWQvYW1ka2ZkL2tmZF9kb29yYmVsbC5jCj4gQEAgLTExNiw3 ICsxMTYsNyBAQCBpbnQga2ZkX2Rvb3JiZWxsX2luaXQoc3RydWN0IGtmZF9kZXYgKmtmZCkKPiAg CXByX2RlYnVnKCJkb29yYmVsbCBhcGVydHVyZSBzaXplICA9PSAweCUwOGxYXG4iLAo+ICAJCQlr ZmQtPnNoYXJlZF9yZXNvdXJjZXMuZG9vcmJlbGxfYXBlcnR1cmVfc2l6ZSk7Cj4gIAo+IC0JcHJf ZGVidWcoImRvb3JiZWxsIGtlcm5lbCBhZGRyZXNzID09ICVwXG4iLCBrZmQtPmRvb3JiZWxsX2tl cm5lbF9wdHIpOwo+ICsJcHJfZGVidWcoImRvb3JiZWxsIGtlcm5lbCBhZGRyZXNzID09ICVweFxu Iiwga2ZkLT5kb29yYmVsbF9rZXJuZWxfcHRyKTsKPiAgCj4gIAlyZXR1cm4gMDsKPiAgfQo+IEBA IC0yMTQsNyArMjE0LDcgQEAgaW5saW5lIHZvaWQgd3JpdGVfa2VybmVsX2Rvb3JiZWxsKHUzMiBf X2lvbWVtICpkYiwgdTMyIHZhbHVlKQo+ICB7Cj4gIAlpZiAoZGIpIHsKPiAgCQl3cml0ZWwodmFs dWUsIGRiKTsKPiAtCQlwcl9kZWJ1ZygiV3JpdGluZyAlZCB0byBkb29yYmVsbCBhZGRyZXNzICVw XG4iLCB2YWx1ZSwgZGIpOwo+ICsJCXByX2RlYnVnKCJXcml0aW5nICVkIHRvIGRvb3JiZWxsIGFk ZHJlc3MgJXB4XG4iLCB2YWx1ZSwgZGIpOwo+ICAJfQo+ICB9Cj4gIAo+IGRpZmYgLS1naXQgYS9k cml2ZXJzL2dwdS9kcm0vYW1kL2FtZGtmZC9rZmRfZXZlbnRzLmMgYi9kcml2ZXJzL2dwdS9kcm0v YW1kL2FtZGtmZC9rZmRfZXZlbnRzLmMKPiBpbmRleCA0ODkwYTkwZjFlNDQuLjFiMDMzMDhmYWEw ZSAxMDA2NDQKPiAtLS0gYS9kcml2ZXJzL2dwdS9kcm0vYW1kL2FtZGtmZC9rZmRfZXZlbnRzLmMK PiArKysgYi9kcml2ZXJzL2dwdS9kcm0vYW1kL2FtZGtmZC9rZmRfZXZlbnRzLmMKPiBAQCAtODEs NyArODEsNyBAQCBzdGF0aWMgc3RydWN0IGtmZF9zaWduYWxfcGFnZSAqYWxsb2NhdGVfc2lnbmFs X3BhZ2Uoc3RydWN0IGtmZF9wcm9jZXNzICpwKQo+ICAKPiAgCXBhZ2UtPmtlcm5lbF9hZGRyZXNz ID0gYmFja2luZ19zdG9yZTsKPiAgCXBhZ2UtPm5lZWRfdG9fZnJlZV9wYWdlcyA9IHRydWU7Cj4g LQlwcl9kZWJ1ZygiQWxsb2NhdGVkIG5ldyBldmVudCBzaWduYWwgcGFnZSBhdCAlcCwgZm9yIHBy b2Nlc3MgJXBcbiIsCj4gKwlwcl9kZWJ1ZygiQWxsb2NhdGVkIG5ldyBldmVudCBzaWduYWwgcGFn ZSBhdCAlcHgsIGZvciBwcm9jZXNzICVweFxuIiwKPiAgCQkJcGFnZSwgcCk7Cj4gIAo+ICAJcmV0 dXJuIHBhZ2U7Cj4gQEAgLTIwMiw3ICsyMDIsNyBAQCBzdGF0aWMgaW50IGNyZWF0ZV9zaWduYWxf ZXZlbnQoc3RydWN0IGZpbGUgKmRldmtmZCwKPiAgCXAtPnNpZ25hbF9ldmVudF9jb3VudCsrOwo+ ICAKPiAgCWV2LT51c2VyX3NpZ25hbF9hZGRyZXNzID0gJnAtPnNpZ25hbF9wYWdlLT51c2VyX2Fk ZHJlc3NbZXYtPmV2ZW50X2lkXTsKPiAtCXByX2RlYnVnKCJTaWduYWwgZXZlbnQgbnVtYmVyICV6 dSBjcmVhdGVkIHdpdGggaWQgJWQsIGFkZHJlc3MgJXBcbiIsCj4gKwlwcl9kZWJ1ZygiU2lnbmFs IGV2ZW50IG51bWJlciAlenUgY3JlYXRlZCB3aXRoIGlkICVkLCBhZGRyZXNzICVweFxuIiwKPiAg CQkJcC0+c2lnbmFsX2V2ZW50X2NvdW50LCBldi0+ZXZlbnRfaWQsCj4gIAkJCWV2LT51c2VyX3Np Z25hbF9hZGRyZXNzKTsKPiAgCj4gZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2RybS9hbWQvYW1k a2ZkL2tmZF9rZXJuZWxfcXVldWUuYyBiL2RyaXZlcnMvZ3B1L2RybS9hbWQvYW1ka2ZkL2tmZF9r ZXJuZWxfcXVldWUuYwo+IGluZGV4IDY5ZjQ5NjQ4NTMzMS4uYjM5YjViODEzZGFiIDEwMDY0NAo+ IC0tLSBhL2RyaXZlcnMvZ3B1L2RybS9hbWQvYW1ka2ZkL2tmZF9rZXJuZWxfcXVldWUuYwo+ICsr KyBiL2RyaXZlcnMvZ3B1L2RybS9hbWQvYW1ka2ZkL2tmZF9rZXJuZWxfcXVldWUuYwo+IEBAIC0y MjIsNyArMjIyLDcgQEAgc3RhdGljIGludCBhY3F1aXJlX3BhY2tldF9idWZmZXIoc3RydWN0IGtl cm5lbF9xdWV1ZSAqa3EsCj4gIAo+ICAJcHJfZGVidWcoInJwdHI6ICVkXG4iLCBycHRyKTsKPiAg CXByX2RlYnVnKCJ3cHRyOiAlZFxuIiwgd3B0cik7Cj4gLQlwcl9kZWJ1ZygicXVldWVfYWRkcmVz cyAweCVwXG4iLCBxdWV1ZV9hZGRyZXNzKTsKPiArCXByX2RlYnVnKCJxdWV1ZV9hZGRyZXNzIDB4 JXB4XG4iLCBxdWV1ZV9hZGRyZXNzKTsKPiAgCj4gIAlhdmFpbGFibGVfc2l6ZSA9IChycHRyICsg cXVldWVfc2l6ZV9kd29yZHMgLSAxIC0gd3B0cikgJQo+ICAJCQkJCQkJcXVldWVfc2l6ZV9kd29y ZHM7Cj4gZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2RybS9hbWQvYW1ka2ZkL2tmZF9wcm9jZXNz LmMgYi9kcml2ZXJzL2dwdS9kcm0vYW1kL2FtZGtmZC9rZmRfcHJvY2Vzcy5jCj4gaW5kZXggMTcx MWFkMDY0MmY3Li5jNWMxYjIxNTg5MTAgMTAwNjQ0Cj4gLS0tIGEvZHJpdmVycy9ncHUvZHJtL2Ft ZC9hbWRrZmQva2ZkX3Byb2Nlc3MuYwo+ICsrKyBiL2RyaXZlcnMvZ3B1L2RybS9hbWQvYW1ka2Zk L2tmZF9wcm9jZXNzLmMKPiBAQCAtNDY4LDcgKzQ2OCw3IEBAIHN0YXRpYyBpbnQga2ZkX3Byb2Nl c3NfaW5pdF9jd3NyX2FwdShzdHJ1Y3Qga2ZkX3Byb2Nlc3MgKnAsIHN0cnVjdCBmaWxlICpmaWxl cCkKPiAgCQltZW1jcHkocXBkLT5jd3NyX2thZGRyLCBkZXYtPmN3c3JfaXNhLCBkZXYtPmN3c3Jf aXNhX3NpemUpOwo+ICAKPiAgCQlxcGQtPnRtYV9hZGRyID0gcXBkLT50YmFfYWRkciArIEtGRF9D V1NSX1RNQV9PRkZTRVQ7Cj4gLQkJcHJfZGVidWcoInNldCB0YmEgOjB4JWxseCwgdG1hOjB4JWxs eCwgY3dzcl9rYWRkcjolcCBmb3IgcHFtLlxuIiwKPiArCQlwcl9kZWJ1Zygic2V0IHRiYSA6MHgl bGx4LCB0bWE6MHglbGx4LCBjd3NyX2thZGRyOiVweCBmb3IgcHFtLlxuIiwKPiAgCQkJcXBkLT50 YmFfYWRkciwgcXBkLT50bWFfYWRkciwgcXBkLT5jd3NyX2thZGRyKTsKPiAgCX0KPiAgCj4gQEAg LTQ5OSw3ICs0OTksNyBAQCBzdGF0aWMgaW50IGtmZF9wcm9jZXNzX2RldmljZV9pbml0X2N3c3Jf ZGdwdShzdHJ1Y3Qga2ZkX3Byb2Nlc3NfZGV2aWNlICpwZGQpCj4gIAltZW1jcHkocXBkLT5jd3Ny X2thZGRyLCBkZXYtPmN3c3JfaXNhLCBkZXYtPmN3c3JfaXNhX3NpemUpOwo+ICAKPiAgCXFwZC0+ dG1hX2FkZHIgPSBxcGQtPnRiYV9hZGRyICsgS0ZEX0NXU1JfVE1BX09GRlNFVDsKPiAtCXByX2Rl YnVnKCJzZXQgdGJhIDoweCVsbHgsIHRtYToweCVsbHgsIGN3c3Jfa2FkZHI6JXAgZm9yIHBxbS5c biIsCj4gKwlwcl9kZWJ1Zygic2V0IHRiYSA6MHglbGx4LCB0bWE6MHglbGx4LCBjd3NyX2thZGRy OiVweCBmb3IgcHFtLlxuIiwKPiAgCQkgcXBkLT50YmFfYWRkciwgcXBkLT50bWFfYWRkciwgcXBk LT5jd3NyX2thZGRyKTsKPiAgCj4gIAlyZXR1cm4gMDsKPiBkaWZmIC0tZ2l0IGEvZHJpdmVycy9n cHUvZHJtL2FtZC9hbWRrZmQva2ZkX3F1ZXVlLmMgYi9kcml2ZXJzL2dwdS9kcm0vYW1kL2FtZGtm ZC9rZmRfcXVldWUuYwo+IGluZGV4IGE1MzE1ZDRmMWM5NS4uNTZkM2UwNWI1M2JhIDEwMDY0NAo+ IC0tLSBhL2RyaXZlcnMvZ3B1L2RybS9hbWQvYW1ka2ZkL2tmZF9xdWV1ZS5jCj4gKysrIGIvZHJp dmVycy9ncHUvZHJtL2FtZC9hbWRrZmQva2ZkX3F1ZXVlLmMKPiBAQCAtMzYsOSArMzYsOSBAQCB2 b2lkIHByaW50X3F1ZXVlX3Byb3BlcnRpZXMoc3RydWN0IHF1ZXVlX3Byb3BlcnRpZXMgKnEpCj4g IAlwcl9kZWJ1ZygiUXVldWUgQWRkcmVzczogMHglbGxYXG4iLCBxLT5xdWV1ZV9hZGRyZXNzKTsK PiAgCXByX2RlYnVnKCJRdWV1ZSBJZDogJXVcbiIsIHEtPnF1ZXVlX2lkKTsKPiAgCXByX2RlYnVn KCJRdWV1ZSBQcm9jZXNzIFZtaWQ6ICV1XG4iLCBxLT52bWlkKTsKPiAtCXByX2RlYnVnKCJRdWV1 ZSBSZWFkIFBvaW50ZXI6IDB4JXBcbiIsIHEtPnJlYWRfcHRyKTsKPiAtCXByX2RlYnVnKCJRdWV1 ZSBXcml0ZSBQb2ludGVyOiAweCVwXG4iLCBxLT53cml0ZV9wdHIpOwo+IC0JcHJfZGVidWcoIlF1 ZXVlIERvb3JiZWxsIFBvaW50ZXI6IDB4JXBcbiIsIHEtPmRvb3JiZWxsX3B0cik7Cj4gKwlwcl9k ZWJ1ZygiUXVldWUgUmVhZCBQb2ludGVyOiAweCVweFxuIiwgcS0+cmVhZF9wdHIpOwo+ICsJcHJf ZGVidWcoIlF1ZXVlIFdyaXRlIFBvaW50ZXI6IDB4JXB4XG4iLCBxLT53cml0ZV9wdHIpOwo+ICsJ cHJfZGVidWcoIlF1ZXVlIERvb3JiZWxsIFBvaW50ZXI6IDB4JXB4XG4iLCBxLT5kb29yYmVsbF9w dHIpOwo+ICAJcHJfZGVidWcoIlF1ZXVlIERvb3JiZWxsIE9mZnNldDogJXVcbiIsIHEtPmRvb3Ji ZWxsX29mZik7Cj4gIH0KPiAgCj4gQEAgLTUzLDE0ICs1MywxNCBAQCB2b2lkIHByaW50X3F1ZXVl KHN0cnVjdCBxdWV1ZSAqcSkKPiAgCXByX2RlYnVnKCJRdWV1ZSBBZGRyZXNzOiAweCVsbFhcbiIs IHEtPnByb3BlcnRpZXMucXVldWVfYWRkcmVzcyk7Cj4gIAlwcl9kZWJ1ZygiUXVldWUgSWQ6ICV1 XG4iLCBxLT5wcm9wZXJ0aWVzLnF1ZXVlX2lkKTsKPiAgCXByX2RlYnVnKCJRdWV1ZSBQcm9jZXNz IFZtaWQ6ICV1XG4iLCBxLT5wcm9wZXJ0aWVzLnZtaWQpOwo+IC0JcHJfZGVidWcoIlF1ZXVlIFJl YWQgUG9pbnRlcjogMHglcFxuIiwgcS0+cHJvcGVydGllcy5yZWFkX3B0cik7Cj4gLQlwcl9kZWJ1 ZygiUXVldWUgV3JpdGUgUG9pbnRlcjogMHglcFxuIiwgcS0+cHJvcGVydGllcy53cml0ZV9wdHIp Owo+IC0JcHJfZGVidWcoIlF1ZXVlIERvb3JiZWxsIFBvaW50ZXI6IDB4JXBcbiIsIHEtPnByb3Bl cnRpZXMuZG9vcmJlbGxfcHRyKTsKPiArCXByX2RlYnVnKCJRdWV1ZSBSZWFkIFBvaW50ZXI6IDB4 JXB4XG4iLCBxLT5wcm9wZXJ0aWVzLnJlYWRfcHRyKTsKPiArCXByX2RlYnVnKCJRdWV1ZSBXcml0 ZSBQb2ludGVyOiAweCVweFxuIiwgcS0+cHJvcGVydGllcy53cml0ZV9wdHIpOwo+ICsJcHJfZGVi dWcoIlF1ZXVlIERvb3JiZWxsIFBvaW50ZXI6IDB4JXB4XG4iLCBxLT5wcm9wZXJ0aWVzLmRvb3Ji ZWxsX3B0cik7Cj4gIAlwcl9kZWJ1ZygiUXVldWUgRG9vcmJlbGwgT2Zmc2V0OiAldVxuIiwgcS0+ cHJvcGVydGllcy5kb29yYmVsbF9vZmYpOwo+IC0JcHJfZGVidWcoIlF1ZXVlIE1RRCBBZGRyZXNz OiAweCVwXG4iLCBxLT5tcWQpOwo+ICsJcHJfZGVidWcoIlF1ZXVlIE1RRCBBZGRyZXNzOiAweCVw eFxuIiwgcS0+bXFkKTsKPiAgCXByX2RlYnVnKCJRdWV1ZSBNUUQgR2FydDogMHglbGxYXG4iLCBx LT5nYXJ0X21xZF9hZGRyKTsKPiAtCXByX2RlYnVnKCJRdWV1ZSBQcm9jZXNzIEFkZHJlc3M6IDB4 JXBcbiIsIHEtPnByb2Nlc3MpOwo+IC0JcHJfZGVidWcoIlF1ZXVlIERldmljZSBBZGRyZXNzOiAw eCVwXG4iLCBxLT5kZXZpY2UpOwo+ICsJcHJfZGVidWcoIlF1ZXVlIFByb2Nlc3MgQWRkcmVzczog MHglcHhcbiIsIHEtPnByb2Nlc3MpOwo+ICsJcHJfZGVidWcoIlF1ZXVlIERldmljZSBBZGRyZXNz OiAweCVweFxuIiwgcS0+ZGV2aWNlKTsKPiAgfQo+ICAKPiAgaW50IGluaXRfcXVldWUoc3RydWN0 IHF1ZXVlICoqcSwgY29uc3Qgc3RydWN0IHF1ZXVlX3Byb3BlcnRpZXMgKnByb3BlcnRpZXMpCj4g ZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2RybS9hbWQvZGlzcGxheS9hbWRncHVfZG0vYW1kZ3B1 X2RtLmMgYi9kcml2ZXJzL2dwdS9kcm0vYW1kL2Rpc3BsYXkvYW1kZ3B1X2RtL2FtZGdwdV9kbS5j Cj4gaW5kZXggNGUyZjM3OWNlMjE3Li5jNTA3NzlhYTVkYWEgMTAwNjQ0Cj4gLS0tIGEvZHJpdmVy cy9ncHUvZHJtL2FtZC9kaXNwbGF5L2FtZGdwdV9kbS9hbWRncHVfZG0uYwo+ICsrKyBiL2RyaXZl cnMvZ3B1L2RybS9hbWQvZGlzcGxheS9hbWRncHVfZG0vYW1kZ3B1X2RtLmMKPiBAQCAtMjc1LDcg KzI3NSw3IEBAIHN0YXRpYyB2b2lkIGRtX3BmbGlwX2hpZ2hfaXJxKHZvaWQgKmludGVycnVwdF9w YXJhbXMpCj4gIAlzcGluX2xvY2tfaXJxc2F2ZSgmYWRldi0+ZGRldi0+ZXZlbnRfbG9jaywgZmxh Z3MpOwo+ICAKPiAgCWlmIChhbWRncHVfY3J0Yy0+cGZsaXBfc3RhdHVzICE9IEFNREdQVV9GTElQ X1NVQk1JVFRFRCl7Cj4gLQkJRFJNX0RFQlVHX0RSSVZFUigiYW1kZ3B1X2NydGMtPnBmbGlwX3N0 YXR1cyA9ICVkICE9QU1ER1BVX0ZMSVBfU1VCTUlUVEVEKCVkKSBvbiBjcnRjOiVkWyVwXSBcbiIs Cj4gKwkJRFJNX0RFQlVHX0RSSVZFUigiYW1kZ3B1X2NydGMtPnBmbGlwX3N0YXR1cyA9ICVkICE9 QU1ER1BVX0ZMSVBfU1VCTUlUVEVEKCVkKSBvbiBjcnRjOiVkWyVweF0gXG4iLAo+ICAJCQkJCQkg YW1kZ3B1X2NydGMtPnBmbGlwX3N0YXR1cywKPiAgCQkJCQkJIEFNREdQVV9GTElQX1NVQk1JVFRF RCwKPiAgCQkJCQkJIGFtZGdwdV9jcnRjLT5jcnRjX2lkLAo+IEBAIC0zMDEsNyArMzAxLDcgQEAg c3RhdGljIHZvaWQgZG1fcGZsaXBfaGlnaF9pcnEodm9pZCAqaW50ZXJydXB0X3BhcmFtcykKPiAg CWFtZGdwdV9jcnRjLT5wZmxpcF9zdGF0dXMgPSBBTURHUFVfRkxJUF9OT05FOwo+ICAJc3Bpbl91 bmxvY2tfaXJxcmVzdG9yZSgmYWRldi0+ZGRldi0+ZXZlbnRfbG9jaywgZmxhZ3MpOwo+ICAKPiAt CURSTV9ERUJVR19EUklWRVIoIiVzIC0gY3J0YyA6JWRbJXBdLCBwZmxpcF9zdGF0OkFNREdQVV9G TElQX05PTkVcbiIsCj4gKwlEUk1fREVCVUdfRFJJVkVSKCIlcyAtIGNydGMgOiVkWyVweF0sIHBm bGlwX3N0YXQ6QU1ER1BVX0ZMSVBfTk9ORVxuIiwKPiAgCQkJCQlfX2Z1bmNfXywgYW1kZ3B1X2Ny dGMtPmNydGNfaWQsIGFtZGdwdV9jcnRjKTsKPiAgCj4gIAlkcm1fY3J0Y192YmxhbmtfcHV0KCZh bWRncHVfY3J0Yy0+YmFzZSk7Cj4gQEAgLTQ2Myw3ICs0NjMsNyBAQCBzdGF0aWMgaW50IGFtZGdw dV9kbV9pbml0KHN0cnVjdCBhbWRncHVfZGV2aWNlICphZGV2KQo+ICAJCURSTV9FUlJPUigKPiAg CQkiYW1kZ3B1OiBmYWlsZWQgdG8gaW5pdGlhbGl6ZSBmcmVlc3luY19tb2R1bGUuXG4iKTsKPiAg CX0gZWxzZQo+IC0JCURSTV9ERUJVR19EUklWRVIoImFtZGdwdTogZnJlZXN5bmNfbW9kdWxlIGlu aXQgZG9uZSAlcC5cbiIsCj4gKwkJRFJNX0RFQlVHX0RSSVZFUigiYW1kZ3B1OiBmcmVlc3luY19t b2R1bGUgaW5pdCBkb25lICVweC5cbiIsCj4gIAkJCQlhZGV2LT5kbS5mcmVlc3luY19tb2R1bGUp Owo+ICAKPiAgCWFtZGdwdV9kbV9pbml0X2NvbG9yX21vZCgpOwo+IEBAIC01NDMsNyArNTQzLDcg QEAgc3RhdGljIGludCBkZXRlY3RfbXN0X2xpbmtfZm9yX2FsbF9jb25uZWN0b3JzKHN0cnVjdCBk cm1fZGV2aWNlICpkZXYpCj4gIAkJYWNvbm5lY3RvciA9IHRvX2FtZGdwdV9kbV9jb25uZWN0b3Io Y29ubmVjdG9yKTsKPiAgCQlpZiAoYWNvbm5lY3Rvci0+ZGNfbGluay0+dHlwZSA9PSBkY19jb25u ZWN0aW9uX21zdF9icmFuY2ggJiYKPiAgCQkgICAgYWNvbm5lY3Rvci0+bXN0X21nci5hdXgpIHsK PiAtCQkJRFJNX0RFQlVHX0RSSVZFUigiRE1fTVNUOiBzdGFydGluZyBUTSBvbiBhY29ubmVjdG9y OiAlcCBbaWQ6ICVkXVxuIiwKPiArCQkJRFJNX0RFQlVHX0RSSVZFUigiRE1fTVNUOiBzdGFydGlu ZyBUTSBvbiBhY29ubmVjdG9yOiAlcHggW2lkOiAlZF1cbiIsCj4gIAkJCQkJYWNvbm5lY3Rvciwg YWNvbm5lY3Rvci0+YmFzZS5iYXNlLmlkKTsKPiAgCj4gIAkJCXJldCA9IGRybV9kcF9tc3RfdG9w b2xvZ3lfbWdyX3NldF9tc3QoJmFjb25uZWN0b3ItPm1zdF9tZ3IsIHRydWUpOwo+IEBAIC04OTUs NyArODk1LDcgQEAgYW1kZ3B1X2RtX3VwZGF0ZV9jb25uZWN0b3JfYWZ0ZXJfZGV0ZWN0KHN0cnVj dCBhbWRncHVfZG1fY29ubmVjdG9yICphY29ubmVjdG9yKQo+ICAJCXJldHVybjsKPiAgCX0KPiAg Cj4gLQlEUk1fREVCVUdfRFJJVkVSKCJEQ0hQRDogY29ubmVjdG9yX2lkPSVkOiBPbGQgc2luaz0l cCBOZXcgc2luaz0lcFxuIiwKPiArCURSTV9ERUJVR19EUklWRVIoIkRDSFBEOiBjb25uZWN0b3Jf aWQ9JWQ6IE9sZCBzaW5rPSVweCBOZXcgc2luaz0lcHhcbiIsCj4gIAkJYWNvbm5lY3Rvci0+Y29u bmVjdG9yX2lkLCBhY29ubmVjdG9yLT5kY19zaW5rLCBzaW5rKTsKPiAgCj4gIAltdXRleF9sb2Nr KCZkZXYtPm1vZGVfY29uZmlnLm11dGV4KTsKPiBAQCAtNDE4NSw3ICs0MTg1LDcgQEAgc3RhdGlj IHZvaWQgYW1kZ3B1X2RtX2F0b21pY19jb21taXRfdGFpbChzdHJ1Y3QgZHJtX2F0b21pY19zdGF0 ZSAqc3RhdGUpCj4gIAo+ICAJCWlmIChtb2Rlc2V0X3JlcXVpcmVkKG5ld19jcnRjX3N0YXRlLCBk bV9uZXdfY3J0Y19zdGF0ZS0+c3RyZWFtLCBkbV9vbGRfY3J0Y19zdGF0ZS0+c3RyZWFtKSkgewo+ ICAKPiAtCQkJRFJNX0RFQlVHX0RSSVZFUigiQXRvbWljIGNvbW1pdDogU0VUIGNydGMgaWQgJWQ6 IFslcF1cbiIsIGFjcnRjLT5jcnRjX2lkLCBhY3J0Yyk7Cj4gKwkJCURSTV9ERUJVR19EUklWRVIo IkF0b21pYyBjb21taXQ6IFNFVCBjcnRjIGlkICVkOiBbJXB4XVxuIiwgYWNydGMtPmNydGNfaWQs IGFjcnRjKTsKPiAgCj4gIAkJCWlmICghZG1fbmV3X2NydGNfc3RhdGUtPnN0cmVhbSkgewo+ICAJ CQkJLyoKPiBAQCAtNDIxNSw3ICs0MjE1LDcgQEAgc3RhdGljIHZvaWQgYW1kZ3B1X2RtX2F0b21p Y19jb21taXRfdGFpbChzdHJ1Y3QgZHJtX2F0b21pY19zdGF0ZSAqc3RhdGUpCj4gIAkJCWFjcnRj LT5od19tb2RlID0gbmV3X2NydGNfc3RhdGUtPm1vZGU7Cj4gIAkJCWNydGMtPmh3bW9kZSA9IG5l d19jcnRjX3N0YXRlLT5tb2RlOwo+ICAJCX0gZWxzZSBpZiAobW9kZXJlc2V0X3JlcXVpcmVkKG5l d19jcnRjX3N0YXRlKSkgewo+IC0JCQlEUk1fREVCVUdfRFJJVkVSKCJBdG9taWMgY29tbWl0OiBS RVNFVC4gY3J0YyBpZCAlZDpbJXBdXG4iLCBhY3J0Yy0+Y3J0Y19pZCwgYWNydGMpOwo+ICsJCQlE Uk1fREVCVUdfRFJJVkVSKCJBdG9taWMgY29tbWl0OiBSRVNFVC4gY3J0YyBpZCAlZDpbJXB4XVxu IiwgYWNydGMtPmNydGNfaWQsIGFjcnRjKTsKPiAgCj4gIAkJCS8qIGkuZS4gcmVzZXQgbW9kZSAq Lwo+ICAJCQlpZiAoZG1fb2xkX2NydGNfc3RhdGUtPnN0cmVhbSkKPiBkaWZmIC0tZ2l0IGEvZHJp dmVycy9ncHUvZHJtL2FtZC9kaXNwbGF5L2FtZGdwdV9kbS9hbWRncHVfZG1fbXN0X3R5cGVzLmMg Yi9kcml2ZXJzL2dwdS9kcm0vYW1kL2Rpc3BsYXkvYW1kZ3B1X2RtL2FtZGdwdV9kbV9tc3RfdHlw ZXMuYwo+IGluZGV4IDgyOTFkNzRmMjZiYy4uNGZjMjQ2Y2Q2ZWM0IDEwMDY0NAo+IC0tLSBhL2Ry aXZlcnMvZ3B1L2RybS9hbWQvZGlzcGxheS9hbWRncHVfZG0vYW1kZ3B1X2RtX21zdF90eXBlcy5j Cj4gKysrIGIvZHJpdmVycy9ncHUvZHJtL2FtZC9kaXNwbGF5L2FtZGdwdV9kbS9hbWRncHVfZG1f bXN0X3R5cGVzLmMKPiBAQCAtMzAyLDcgKzMwMiw3IEBAIGRtX2RwX2NyZWF0ZV9mYWtlX21zdF9l bmNvZGVyKHN0cnVjdCBhbWRncHVfZG1fY29ubmVjdG9yICpjb25uZWN0b3IpCj4gIAlzdHJ1Y3Qg ZHJtX2VuY29kZXIgKmVuY19tYXN0ZXIgPQo+ICAJCWNvbm5lY3Rvcl9mdW5jcy0+YmVzdF9lbmNv ZGVyKCZjb25uZWN0b3ItPmJhc2UpOwo+ICAKPiAtCURSTV9ERUJVR19LTVMoImVuYyBtYXN0ZXIg aXMgJXBcbiIsIGVuY19tYXN0ZXIpOwo+ICsJRFJNX0RFQlVHX0tNUygiZW5jIG1hc3RlciBpcyAl cHhcbiIsIGVuY19tYXN0ZXIpOwo+ICAJYW1kZ3B1X2VuY29kZXIgPSBremFsbG9jKHNpemVvZigq YW1kZ3B1X2VuY29kZXIpLCBHRlBfS0VSTkVMKTsKPiAgCWlmICghYW1kZ3B1X2VuY29kZXIpCj4g IAkJcmV0dXJuIE5VTEw7Cj4gZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2RybS9hcm1hZGEvYXJt YWRhX2dlbS5jIGIvZHJpdmVycy9ncHUvZHJtL2FybWFkYS9hcm1hZGFfZ2VtLmMKPiBpbmRleCBh OTdmNTA5NzQzYTUuLjA3NTg0MGEzNzM1ZiAxMDA2NDQKPiAtLS0gYS9kcml2ZXJzL2dwdS9kcm0v YXJtYWRhL2FybWFkYV9nZW0uYwo+ICsrKyBiL2RyaXZlcnMvZ3B1L2RybS9hcm1hZGEvYXJtYWRh X2dlbS5jCj4gQEAgLTUwLDcgKzUwLDcgQEAgdm9pZCBhcm1hZGFfZ2VtX2ZyZWVfb2JqZWN0KHN0 cnVjdCBkcm1fZ2VtX29iamVjdCAqb2JqKQo+ICAJc3RydWN0IGFybWFkYV9nZW1fb2JqZWN0ICpk b2JqID0gZHJtX3RvX2FybWFkYV9nZW0ob2JqKTsKPiAgCXN0cnVjdCBhcm1hZGFfcHJpdmF0ZSAq cHJpdiA9IG9iai0+ZGV2LT5kZXZfcHJpdmF0ZTsKPiAgCj4gLQlEUk1fREVCVUdfRFJJVkVSKCJy ZWxlYXNlIG9iaiAlcFxuIiwgZG9iaik7Cj4gKwlEUk1fREVCVUdfRFJJVkVSKCJyZWxlYXNlIG9i aiAlcHhcbiIsIGRvYmopOwo+ICAKPiAgCWRybV9nZW1fZnJlZV9tbWFwX29mZnNldCgmZG9iai0+ b2JqKTsKPiAgCj4gQEAgLTE3Nyw3ICsxNzcsNyBAQCBhcm1hZGFfZ2VtX2xpbmVhcl9iYWNrKHN0 cnVjdCBkcm1fZGV2aWNlICpkZXYsIHN0cnVjdCBhcm1hZGFfZ2VtX29iamVjdCAqb2JqKQo+ICAJ CW9iai0+bWFwcGVkID0gdHJ1ZTsKPiAgCX0KPiAgCj4gLQlEUk1fREVCVUdfRFJJVkVSKCJvYmog JXAgcGh5cyAlI2xseCBkZXYgJSNsbHhcbiIsIG9iaiwKPiArCURSTV9ERUJVR19EUklWRVIoIm9i aiAlcHggcGh5cyAlI2xseCBkZXYgJSNsbHhcbiIsIG9iaiwKPiAgCQkJICh1bnNpZ25lZCBsb25n IGxvbmcpb2JqLT5waHlzX2FkZHIsCj4gIAkJCSAodW5zaWduZWQgbG9uZyBsb25nKW9iai0+ZGV2 X2FkZHIpOwo+ICAKPiBAQCAtMjA2LDcgKzIwNiw3IEBAIGFybWFkYV9nZW1fYWxsb2NfcHJpdmF0 ZV9vYmplY3Qoc3RydWN0IGRybV9kZXZpY2UgKmRldiwgc2l6ZV90IHNpemUpCj4gIAo+ICAJZHJt X2dlbV9wcml2YXRlX29iamVjdF9pbml0KGRldiwgJm9iai0+b2JqLCBzaXplKTsKPiAgCj4gLQlE Uk1fREVCVUdfRFJJVkVSKCJhbGxvYyBwcml2YXRlIG9iaiAlcCBzaXplICV6dVxuIiwgb2JqLCBz aXplKTsKPiArCURSTV9ERUJVR19EUklWRVIoImFsbG9jIHByaXZhdGUgb2JqICVweCBzaXplICV6 dVxuIiwgb2JqLCBzaXplKTsKPiAgCj4gIAlyZXR1cm4gb2JqOwo+ICB9Cj4gQEAgLTIzMSw3ICsy MzEsNyBAQCBzdGF0aWMgc3RydWN0IGFybWFkYV9nZW1fb2JqZWN0ICphcm1hZGFfZ2VtX2FsbG9j X29iamVjdChzdHJ1Y3QgZHJtX2RldmljZSAqZGV2LAo+ICAJbWFwcGluZyA9IG9iai0+b2JqLmZp bHAtPmZfbWFwcGluZzsKPiAgCW1hcHBpbmdfc2V0X2dmcF9tYXNrKG1hcHBpbmcsIEdGUF9ISUdI VVNFUiB8IF9fR0ZQX1JFQ0xBSU1BQkxFKTsKPiAgCj4gLQlEUk1fREVCVUdfRFJJVkVSKCJhbGxv YyBvYmogJXAgc2l6ZSAlenVcbiIsIG9iaiwgc2l6ZSk7Cj4gKwlEUk1fREVCVUdfRFJJVkVSKCJh bGxvYyBvYmogJXB4IHNpemUgJXp1XG4iLCBvYmosIHNpemUpOwo+ICAKPiAgCXJldHVybiBvYmo7 Cj4gIH0KPiBAQCAtMjYzLDcgKzI2Myw3IEBAIGludCBhcm1hZGFfZ2VtX2R1bWJfY3JlYXRlKHN0 cnVjdCBkcm1fZmlsZSAqZmlsZSwgc3RydWN0IGRybV9kZXZpY2UgKmRldiwKPiAgCWFyZ3MtPmhh bmRsZSA9IGhhbmRsZTsKPiAgCj4gIAkvKiBkcm9wIHJlZmVyZW5jZSBmcm9tIGFsbG9jYXRlIC0g aGFuZGxlIGhvbGRzIGl0IG5vdyAqLwo+IC0JRFJNX0RFQlVHX0RSSVZFUigib2JqICVwIHNpemUg JXp1IGhhbmRsZSAlI3hcbiIsIGRvYmosIHNpemUsIGhhbmRsZSk7Cj4gKwlEUk1fREVCVUdfRFJJ VkVSKCJvYmogJXB4IHNpemUgJXp1IGhhbmRsZSAlI3hcbiIsIGRvYmosIHNpemUsIGhhbmRsZSk7 Cj4gICBlcnI6Cj4gIAlkcm1fZ2VtX29iamVjdF9wdXRfdW5sb2NrZWQoJmRvYmotPm9iaik7Cj4g IAlyZXR1cm4gcmV0Owo+IEBAIC0yOTUsNyArMjk1LDcgQEAgaW50IGFybWFkYV9nZW1fY3JlYXRl X2lvY3RsKHN0cnVjdCBkcm1fZGV2aWNlICpkZXYsIHZvaWQgKmRhdGEsCj4gIAlhcmdzLT5oYW5k bGUgPSBoYW5kbGU7Cj4gIAo+ICAJLyogZHJvcCByZWZlcmVuY2UgZnJvbSBhbGxvY2F0ZSAtIGhh bmRsZSBob2xkcyBpdCBub3cgKi8KPiAtCURSTV9ERUJVR19EUklWRVIoIm9iaiAlcCBzaXplICV6 dSBoYW5kbGUgJSN4XG4iLCBkb2JqLCBzaXplLCBoYW5kbGUpOwo+ICsJRFJNX0RFQlVHX0RSSVZF Uigib2JqICVweCBzaXplICV6dSBoYW5kbGUgJSN4XG4iLCBkb2JqLCBzaXplLCBoYW5kbGUpOwo+ ICAgZXJyOgo+ICAJZHJtX2dlbV9vYmplY3RfcHV0X3VubG9ja2VkKCZkb2JqLT5vYmopOwo+ICAJ cmV0dXJuIHJldDsKPiBkaWZmIC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJtL2RybV9hdG9taWMuYyBi L2RyaXZlcnMvZ3B1L2RybS9kcm1fYXRvbWljLmMKPiBpbmRleCA3ZDI1YzQyZjIyZGIuLjIzOWIw MTBmYzAxMCAxMDA2NDQKPiAtLS0gYS9kcml2ZXJzL2dwdS9kcm0vZHJtX2F0b21pYy5jCj4gKysr IGIvZHJpdmVycy9ncHUvZHJtL2RybV9hdG9taWMuYwo+IEBAIC05Miw3ICs5Miw3IEBAIGRybV9h dG9taWNfc3RhdGVfaW5pdChzdHJ1Y3QgZHJtX2RldmljZSAqZGV2LCBzdHJ1Y3QgZHJtX2F0b21p Y19zdGF0ZSAqc3RhdGUpCj4gIAo+ICAJc3RhdGUtPmRldiA9IGRldjsKPiAgCj4gLQlEUk1fREVC VUdfQVRPTUlDKCJBbGxvY2F0ZWQgYXRvbWljIHN0YXRlICVwXG4iLCBzdGF0ZSk7Cj4gKwlEUk1f REVCVUdfQVRPTUlDKCJBbGxvY2F0ZWQgYXRvbWljIHN0YXRlICVweFxuIiwgc3RhdGUpOwo+ICAK PiAgCXJldHVybiAwOwo+ICBmYWlsOgo+IEBAIC0xNDMsNyArMTQzLDcgQEAgdm9pZCBkcm1fYXRv bWljX3N0YXRlX2RlZmF1bHRfY2xlYXIoc3RydWN0IGRybV9hdG9taWNfc3RhdGUgKnN0YXRlKQo+ ICAJc3RydWN0IGRybV9tb2RlX2NvbmZpZyAqY29uZmlnID0gJmRldi0+bW9kZV9jb25maWc7Cj4g IAlpbnQgaTsKPiAgCj4gLQlEUk1fREVCVUdfQVRPTUlDKCJDbGVhcmluZyBhdG9taWMgc3RhdGUg JXBcbiIsIHN0YXRlKTsKPiArCURSTV9ERUJVR19BVE9NSUMoIkNsZWFyaW5nIGF0b21pYyBzdGF0 ZSAlcHhcbiIsIHN0YXRlKTsKPiAgCj4gIAlmb3IgKGkgPSAwOyBpIDwgc3RhdGUtPm51bV9jb25u ZWN0b3I7IGkrKykgewo+ICAJCXN0cnVjdCBkcm1fY29ubmVjdG9yICpjb25uZWN0b3IgPSBzdGF0 ZS0+Y29ubmVjdG9yc1tpXS5wdHI7Cj4gQEAgLTI0MCw3ICsyNDAsNyBAQCB2b2lkIF9fZHJtX2F0 b21pY19zdGF0ZV9mcmVlKHN0cnVjdCBrcmVmICpyZWYpCj4gIAo+ICAJZHJtX2F0b21pY19zdGF0 ZV9jbGVhcihzdGF0ZSk7Cj4gIAo+IC0JRFJNX0RFQlVHX0FUT01JQygiRnJlZWluZyBhdG9taWMg c3RhdGUgJXBcbiIsIHN0YXRlKTsKPiArCURSTV9ERUJVR19BVE9NSUMoIkZyZWVpbmcgYXRvbWlj IHN0YXRlICVweFxuIiwgc3RhdGUpOwo+ICAKPiAgCWlmIChjb25maWctPmZ1bmNzLT5hdG9taWNf c3RhdGVfZnJlZSkgewo+ICAJCWNvbmZpZy0+ZnVuY3MtPmF0b21pY19zdGF0ZV9mcmVlKHN0YXRl KTsKPiBAQCAtMjkzLDcgKzI5Myw3IEBAIGRybV9hdG9taWNfZ2V0X2NydGNfc3RhdGUoc3RydWN0 IGRybV9hdG9taWNfc3RhdGUgKnN0YXRlLAo+ICAJc3RhdGUtPmNydGNzW2luZGV4XS5wdHIgPSBj cnRjOwo+ICAJY3J0Y19zdGF0ZS0+c3RhdGUgPSBzdGF0ZTsKPiAgCj4gLQlEUk1fREVCVUdfQVRP TUlDKCJBZGRlZCBbQ1JUQzolZDolc10gJXAgc3RhdGUgdG8gJXBcbiIsCj4gKwlEUk1fREVCVUdf QVRPTUlDKCJBZGRlZCBbQ1JUQzolZDolc10gJXB4IHN0YXRlIHRvICVweFxuIiwKPiAgCQkJIGNy dGMtPmJhc2UuaWQsIGNydGMtPm5hbWUsIGNydGNfc3RhdGUsIHN0YXRlKTsKPiAgCj4gIAlyZXR1 cm4gY3J0Y19zdGF0ZTsKPiBAQCAtMzUxLDEyICszNTEsMTIgQEAgaW50IGRybV9hdG9taWNfc2V0 X21vZGVfZm9yX2NydGMoc3RydWN0IGRybV9jcnRjX3N0YXRlICpzdGF0ZSwKPiAgCj4gIAkJZHJt X21vZGVfY29weSgmc3RhdGUtPm1vZGUsIG1vZGUpOwo+ICAJCXN0YXRlLT5lbmFibGUgPSB0cnVl Owo+IC0JCURSTV9ERUJVR19BVE9NSUMoIlNldCBbTU9ERTolc10gZm9yIENSVEMgc3RhdGUgJXBc biIsCj4gKwkJRFJNX0RFQlVHX0FUT01JQygiU2V0IFtNT0RFOiVzXSBmb3IgQ1JUQyBzdGF0ZSAl cHhcbiIsCj4gIAkJCQkgbW9kZS0+bmFtZSwgc3RhdGUpOwo+ICAJfSBlbHNlIHsKPiAgCQltZW1z ZXQoJnN0YXRlLT5tb2RlLCAwLCBzaXplb2Yoc3RhdGUtPm1vZGUpKTsKPiAgCQlzdGF0ZS0+ZW5h YmxlID0gZmFsc2U7Cj4gLQkJRFJNX0RFQlVHX0FUT01JQygiU2V0IFtOT01PREVdIGZvciBDUlRD IHN0YXRlICVwXG4iLAo+ICsJCURSTV9ERUJVR19BVE9NSUMoIlNldCBbTk9NT0RFXSBmb3IgQ1JU QyBzdGF0ZSAlcHhcbiIsCj4gIAkJCQkgc3RhdGUpOwo+ICAJfQo+ICAKPiBAQCAtMzk2LDExICsz OTYsMTEgQEAgaW50IGRybV9hdG9taWNfc2V0X21vZGVfcHJvcF9mb3JfY3J0YyhzdHJ1Y3QgZHJt X2NydGNfc3RhdGUgKnN0YXRlLAo+ICAKPiAgCQlzdGF0ZS0+bW9kZV9ibG9iID0gZHJtX3Byb3Bl cnR5X2Jsb2JfZ2V0KGJsb2IpOwo+ICAJCXN0YXRlLT5lbmFibGUgPSB0cnVlOwo+IC0JCURSTV9E RUJVR19BVE9NSUMoIlNldCBbTU9ERTolc10gZm9yIENSVEMgc3RhdGUgJXBcbiIsCj4gKwkJRFJN X0RFQlVHX0FUT01JQygiU2V0IFtNT0RFOiVzXSBmb3IgQ1JUQyBzdGF0ZSAlcHhcbiIsCj4gIAkJ CQkgc3RhdGUtPm1vZGUubmFtZSwgc3RhdGUpOwo+ICAJfSBlbHNlIHsKPiAgCQlzdGF0ZS0+ZW5h YmxlID0gZmFsc2U7Cj4gLQkJRFJNX0RFQlVHX0FUT01JQygiU2V0IFtOT01PREVdIGZvciBDUlRD IHN0YXRlICVwXG4iLAo+ICsJCURSTV9ERUJVR19BVE9NSUMoIlNldCBbTk9NT0RFXSBmb3IgQ1JU QyBzdGF0ZSAlcHhcbiIsCj4gIAkJCQkgc3RhdGUpOwo+ICAJfQo+ICAKPiBAQCAtNzEwLDcgKzcx MCw3IEBAIGRybV9hdG9taWNfZ2V0X3BsYW5lX3N0YXRlKHN0cnVjdCBkcm1fYXRvbWljX3N0YXRl ICpzdGF0ZSwKPiAgCXN0YXRlLT5wbGFuZXNbaW5kZXhdLm5ld19zdGF0ZSA9IHBsYW5lX3N0YXRl Owo+ICAJcGxhbmVfc3RhdGUtPnN0YXRlID0gc3RhdGU7Cj4gIAo+IC0JRFJNX0RFQlVHX0FUT01J QygiQWRkZWQgW1BMQU5FOiVkOiVzXSAlcCBzdGF0ZSB0byAlcFxuIiwKPiArCURSTV9ERUJVR19B VE9NSUMoIkFkZGVkIFtQTEFORTolZDolc10gJXB4IHN0YXRlIHRvICVweFxuIiwKPiAgCQkJIHBs YW5lLT5iYXNlLmlkLCBwbGFuZS0+bmFtZSwgcGxhbmVfc3RhdGUsIHN0YXRlKTsKPiAgCj4gIAlp ZiAocGxhbmVfc3RhdGUtPmNydGMpIHsKPiBAQCAtMTExMSw3ICsxMTExLDcgQEAgZHJtX2F0b21p Y19nZXRfcHJpdmF0ZV9vYmpfc3RhdGUoc3RydWN0IGRybV9hdG9taWNfc3RhdGUgKnN0YXRlLAo+ ICAKPiAgCXN0YXRlLT5udW1fcHJpdmF0ZV9vYmpzID0gbnVtX29ianM7Cj4gIAo+IC0JRFJNX0RF QlVHX0FUT01JQygiQWRkZWQgbmV3IHByaXZhdGUgb2JqZWN0ICVwIHN0YXRlICVwIHRvICVwXG4i LAo+ICsJRFJNX0RFQlVHX0FUT01JQygiQWRkZWQgbmV3IHByaXZhdGUgb2JqZWN0ICVweCBzdGF0 ZSAlcHggdG8gJXB4XG4iLAo+ICAJCQkgb2JqLCBvYmpfc3RhdGUsIHN0YXRlKTsKPiAgCj4gIAly ZXR1cm4gb2JqX3N0YXRlOwo+IEBAIC0xMTc4LDcgKzExNzgsNyBAQCBkcm1fYXRvbWljX2dldF9j b25uZWN0b3Jfc3RhdGUoc3RydWN0IGRybV9hdG9taWNfc3RhdGUgKnN0YXRlLAo+ICAJc3RhdGUt PmNvbm5lY3RvcnNbaW5kZXhdLnB0ciA9IGNvbm5lY3RvcjsKPiAgCWNvbm5lY3Rvcl9zdGF0ZS0+ c3RhdGUgPSBzdGF0ZTsKPiAgCj4gLQlEUk1fREVCVUdfQVRPTUlDKCJBZGRlZCBbQ09OTkVDVE9S OiVkOiVzXSAlcCBzdGF0ZSB0byAlcFxuIiwKPiArCURSTV9ERUJVR19BVE9NSUMoIkFkZGVkIFtD T05ORUNUT1I6JWQ6JXNdICVweCBzdGF0ZSB0byAlcHhcbiIsCj4gIAkJCSBjb25uZWN0b3ItPmJh c2UuaWQsIGNvbm5lY3Rvci0+bmFtZSwKPiAgCQkJIGNvbm5lY3Rvcl9zdGF0ZSwgc3RhdGUpOwo+ ICAKPiBAQCAtMTQ0MiwxMCArMTQ0MiwxMCBAQCBkcm1fYXRvbWljX3NldF9jcnRjX2Zvcl9wbGFu ZShzdHJ1Y3QgZHJtX3BsYW5lX3N0YXRlICpwbGFuZV9zdGF0ZSwKPiAgCX0KPiAgCj4gIAlpZiAo Y3J0YykKPiAtCQlEUk1fREVCVUdfQVRPTUlDKCJMaW5rIHBsYW5lIHN0YXRlICVwIHRvIFtDUlRD OiVkOiVzXVxuIiwKPiArCQlEUk1fREVCVUdfQVRPTUlDKCJMaW5rIHBsYW5lIHN0YXRlICVweCB0 byBbQ1JUQzolZDolc11cbiIsCj4gIAkJCQkgcGxhbmVfc3RhdGUsIGNydGMtPmJhc2UuaWQsIGNy dGMtPm5hbWUpOwo+ICAJZWxzZQo+IC0JCURSTV9ERUJVR19BVE9NSUMoIkxpbmsgcGxhbmUgc3Rh dGUgJXAgdG8gW05PQ1JUQ11cbiIsCj4gKwkJRFJNX0RFQlVHX0FUT01JQygiTGluayBwbGFuZSBz dGF0ZSAlcHggdG8gW05PQ1JUQ11cbiIsCj4gIAkJCQkgcGxhbmVfc3RhdGUpOwo+ICAKPiAgCXJl dHVybiAwOwo+IEBAIC0xNDY3LDEwICsxNDY3LDEwIEBAIGRybV9hdG9taWNfc2V0X2ZiX2Zvcl9w bGFuZShzdHJ1Y3QgZHJtX3BsYW5lX3N0YXRlICpwbGFuZV9zdGF0ZSwKPiAgCQkJICAgIHN0cnVj dCBkcm1fZnJhbWVidWZmZXIgKmZiKQo+ICB7Cj4gIAlpZiAoZmIpCj4gLQkJRFJNX0RFQlVHX0FU T01JQygiU2V0IFtGQjolZF0gZm9yIHBsYW5lIHN0YXRlICVwXG4iLAo+ICsJCURSTV9ERUJVR19B VE9NSUMoIlNldCBbRkI6JWRdIGZvciBwbGFuZSBzdGF0ZSAlcHhcbiIsCj4gIAkJCQkgZmItPmJh c2UuaWQsIHBsYW5lX3N0YXRlKTsKPiAgCWVsc2UKPiAtCQlEUk1fREVCVUdfQVRPTUlDKCJTZXQg W05PRkJdIGZvciBwbGFuZSBzdGF0ZSAlcFxuIiwKPiArCQlEUk1fREVCVUdfQVRPTUlDKCJTZXQg W05PRkJdIGZvciBwbGFuZSBzdGF0ZSAlcHhcbiIsCj4gIAkJCQkgcGxhbmVfc3RhdGUpOwo+ICAK PiAgCWRybV9mcmFtZWJ1ZmZlcl9hc3NpZ24oJnBsYW5lX3N0YXRlLT5mYiwgZmIpOwo+IEBAIC0x NTUxLDEwICsxNTUxLDEwIEBAIGRybV9hdG9taWNfc2V0X2NydGNfZm9yX2Nvbm5lY3RvcihzdHJ1 Y3QgZHJtX2Nvbm5lY3Rvcl9zdGF0ZSAqY29ubl9zdGF0ZSwKPiAgCQlkcm1fY29ubmVjdG9yX2dl dChjb25uX3N0YXRlLT5jb25uZWN0b3IpOwo+ICAJCWNvbm5fc3RhdGUtPmNydGMgPSBjcnRjOwo+ ICAKPiAtCQlEUk1fREVCVUdfQVRPTUlDKCJMaW5rIGNvbm5lY3RvciBzdGF0ZSAlcCB0byBbQ1JU QzolZDolc11cbiIsCj4gKwkJRFJNX0RFQlVHX0FUT01JQygiTGluayBjb25uZWN0b3Igc3RhdGUg JXB4IHRvIFtDUlRDOiVkOiVzXVxuIiwKPiAgCQkJCSBjb25uX3N0YXRlLCBjcnRjLT5iYXNlLmlk LCBjcnRjLT5uYW1lKTsKPiAgCX0gZWxzZSB7Cj4gLQkJRFJNX0RFQlVHX0FUT01JQygiTGluayBj b25uZWN0b3Igc3RhdGUgJXAgdG8gW05PQ1JUQ11cbiIsCj4gKwkJRFJNX0RFQlVHX0FUT01JQygi TGluayBjb25uZWN0b3Igc3RhdGUgJXB4IHRvIFtOT0NSVENdXG4iLAo+ICAJCQkJIGNvbm5fc3Rh dGUpOwo+ICAJfQo+ICAKPiBAQCAtMTU5OCw3ICsxNTk4LDcgQEAgZHJtX2F0b21pY19hZGRfYWZm ZWN0ZWRfY29ubmVjdG9ycyhzdHJ1Y3QgZHJtX2F0b21pY19zdGF0ZSAqc3RhdGUsCj4gIAlpZiAo cmV0KQo+ICAJCXJldHVybiByZXQ7Cj4gIAo+IC0JRFJNX0RFQlVHX0FUT01JQygiQWRkaW5nIGFs bCBjdXJyZW50IGNvbm5lY3RvcnMgZm9yIFtDUlRDOiVkOiVzXSB0byAlcFxuIiwKPiArCURSTV9E RUJVR19BVE9NSUMoIkFkZGluZyBhbGwgY3VycmVudCBjb25uZWN0b3JzIGZvciBbQ1JUQzolZDol c10gdG8gJXB4XG4iLAo+ICAJCQkgY3J0Yy0+YmFzZS5pZCwgY3J0Yy0+bmFtZSwgc3RhdGUpOwo+ ICAKPiAgCS8qCj4gQEAgLTE2ODIsNyArMTY4Miw3IEBAIGludCBkcm1fYXRvbWljX2NoZWNrX29u bHkoc3RydWN0IGRybV9hdG9taWNfc3RhdGUgKnN0YXRlKQo+ICAJc3RydWN0IGRybV9jcnRjX3N0 YXRlICpjcnRjX3N0YXRlOwo+ICAJaW50IGksIHJldCA9IDA7Cj4gIAo+IC0JRFJNX0RFQlVHX0FU T01JQygiY2hlY2tpbmcgJXBcbiIsIHN0YXRlKTsKPiArCURSTV9ERUJVR19BVE9NSUMoImNoZWNr aW5nICVweFxuIiwgc3RhdGUpOwo+ICAKPiAgCWZvcl9lYWNoX25ld19wbGFuZV9pbl9zdGF0ZShz dGF0ZSwgcGxhbmUsIHBsYW5lX3N0YXRlLCBpKSB7Cj4gIAkJcmV0ID0gZHJtX2F0b21pY19wbGFu ZV9jaGVjayhwbGFuZSwgcGxhbmVfc3RhdGUpOwo+IEBAIC0xNzQ1LDcgKzE3NDUsNyBAQCBpbnQg ZHJtX2F0b21pY19jb21taXQoc3RydWN0IGRybV9hdG9taWNfc3RhdGUgKnN0YXRlKQo+ICAJaWYg KHJldCkKPiAgCQlyZXR1cm4gcmV0Owo+ICAKPiAtCURSTV9ERUJVR19BVE9NSUMoImNvbW1pdHRp bmcgJXBcbiIsIHN0YXRlKTsKPiArCURSTV9ERUJVR19BVE9NSUMoImNvbW1pdHRpbmcgJXB4XG4i LCBzdGF0ZSk7Cj4gIAo+ICAJcmV0dXJuIGNvbmZpZy0+ZnVuY3MtPmF0b21pY19jb21taXQoc3Rh dGUtPmRldiwgc3RhdGUsIGZhbHNlKTsKPiAgfQo+IEBAIC0xNzc0LDcgKzE3NzQsNyBAQCBpbnQg ZHJtX2F0b21pY19ub25ibG9ja2luZ19jb21taXQoc3RydWN0IGRybV9hdG9taWNfc3RhdGUgKnN0 YXRlKQo+ICAJaWYgKHJldCkKPiAgCQlyZXR1cm4gcmV0Owo+ICAKPiAtCURSTV9ERUJVR19BVE9N SUMoImNvbW1pdHRpbmcgJXAgbm9uYmxvY2tpbmdcbiIsIHN0YXRlKTsKPiArCURSTV9ERUJVR19B VE9NSUMoImNvbW1pdHRpbmcgJXB4IG5vbmJsb2NraW5nXG4iLCBzdGF0ZSk7Cj4gIAo+ICAJcmV0 dXJuIGNvbmZpZy0+ZnVuY3MtPmF0b21pY19jb21taXQoc3RhdGUtPmRldiwgc3RhdGUsIHRydWUp Owo+ICB9Cj4gQEAgLTE3OTEsNyArMTc5MSw3IEBAIHN0YXRpYyB2b2lkIGRybV9hdG9taWNfcHJp bnRfc3RhdGUoY29uc3Qgc3RydWN0IGRybV9hdG9taWNfc3RhdGUgKnN0YXRlKQo+ICAJc3RydWN0 IGRybV9jb25uZWN0b3Jfc3RhdGUgKmNvbm5lY3Rvcl9zdGF0ZTsKPiAgCWludCBpOwo+ICAKPiAt CURSTV9ERUJVR19BVE9NSUMoImNoZWNraW5nICVwXG4iLCBzdGF0ZSk7Cj4gKwlEUk1fREVCVUdf QVRPTUlDKCJjaGVja2luZyAlcHhcbiIsIHN0YXRlKTsKPiAgCj4gIAlmb3JfZWFjaF9uZXdfcGxh bmVfaW5fc3RhdGUoc3RhdGUsIHBsYW5lLCBwbGFuZV9zdGF0ZSwgaSkKPiAgCQlkcm1fYXRvbWlj X3BsYW5lX3ByaW50X3N0YXRlKCZwLCBwbGFuZV9zdGF0ZSk7Cj4gZGlmZiAtLWdpdCBhL2RyaXZl cnMvZ3B1L2RybS9kcm1fYnVmcy5jIGIvZHJpdmVycy9ncHUvZHJtL2RybV9idWZzLmMKPiBpbmRl eCBiYThjZmU2NWM2NWIuLmY1NmEwODkzZWYxYiAxMDA2NDQKPiAtLS0gYS9kcml2ZXJzL2dwdS9k cm0vZHJtX2J1ZnMuYwo+ICsrKyBiL2RyaXZlcnMvZ3B1L2RybS9kcm1fYnVmcy5jCj4gQEAgLTIz Niw3ICsyMzYsNyBAQCBzdGF0aWMgaW50IGRybV9hZGRtYXBfY29yZShzdHJ1Y3QgZHJtX2Rldmlj ZSAqZGV2LCByZXNvdXJjZV9zaXplX3Qgb2Zmc2V0LAo+ICAJCQlyZXR1cm4gMDsKPiAgCQl9Cj4g IAkJbWFwLT5oYW5kbGUgPSB2bWFsbG9jX3VzZXIobWFwLT5zaXplKTsKPiAtCQlEUk1fREVCVUco IiVsdSAlZCAlcFxuIiwKPiArCQlEUk1fREVCVUcoIiVsdSAlZCAlcHhcbiIsCj4gIAkJCSAgbWFw LT5zaXplLCBvcmRlcl9iYXNlXzIobWFwLT5zaXplKSwgbWFwLT5oYW5kbGUpOwo+ICAJCWlmICgh bWFwLT5oYW5kbGUpIHsKPiAgCQkJa2ZyZWUobWFwKTsKPiBAQCAtNzkzLDcgKzc5Myw3IEBAIGlu dCBkcm1fbGVnYWN5X2FkZGJ1ZnNfYWdwKHN0cnVjdCBkcm1fZGV2aWNlICpkZXYsCj4gIAkJCXJl dHVybiAtRU5PTUVNOwo+ICAJCX0KPiAgCj4gLQkJRFJNX0RFQlVHKCJidWZmZXIgJWQgQCAlcFxu IiwgZW50cnktPmJ1Zl9jb3VudCwgYnVmLT5hZGRyZXNzKTsKPiArCQlEUk1fREVCVUcoImJ1ZmZl ciAlZCBAICVweFxuIiwgZW50cnktPmJ1Zl9jb3VudCwgYnVmLT5hZGRyZXNzKTsKPiAgCj4gIAkJ b2Zmc2V0ICs9IGFsaWdubWVudDsKPiAgCQllbnRyeS0+YnVmX2NvdW50Kys7Cj4gQEAgLTk5NSw3 ICs5OTUsNyBAQCBpbnQgZHJtX2xlZ2FjeV9hZGRidWZzX3BjaShzdHJ1Y3QgZHJtX2RldmljZSAq ZGV2LAo+ICAJCQkJcmV0dXJuIC1FTk9NRU07Cj4gIAkJCX0KPiAgCj4gLQkJCURSTV9ERUJVRygi YnVmZmVyICVkIEAgJXBcbiIsCj4gKwkJCURSTV9ERUJVRygiYnVmZmVyICVkIEAgJXB4XG4iLAo+ ICAJCQkJICBlbnRyeS0+YnVmX2NvdW50LCBidWYtPmFkZHJlc3MpOwo+ICAJCX0KPiAgCQlieXRl X2NvdW50ICs9IFBBR0VfU0laRSA8PCBwYWdlX29yZGVyOwo+IEBAIC0xMTU2LDcgKzExNTYsNyBA QCBzdGF0aWMgaW50IGRybV9sZWdhY3lfYWRkYnVmc19zZyhzdHJ1Y3QgZHJtX2RldmljZSAqZGV2 LAo+ICAJCQlyZXR1cm4gLUVOT01FTTsKPiAgCQl9Cj4gIAo+IC0JCURSTV9ERUJVRygiYnVmZmVy ICVkIEAgJXBcbiIsIGVudHJ5LT5idWZfY291bnQsIGJ1Zi0+YWRkcmVzcyk7Cj4gKwkJRFJNX0RF QlVHKCJidWZmZXIgJWQgQCAlcHhcbiIsIGVudHJ5LT5idWZfY291bnQsIGJ1Zi0+YWRkcmVzcyk7 Cj4gIAo+ICAJCW9mZnNldCArPSBhbGlnbm1lbnQ7Cj4gIAkJZW50cnktPmJ1Zl9jb3VudCsrOwo+ IGRpZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9kcm0vZHJtX2RwX21zdF90b3BvbG9neS5jIGIvZHJp dmVycy9ncHUvZHJtL2RybV9kcF9tc3RfdG9wb2xvZ3kuYwo+IGluZGV4IDZmYWM0MTI5ZTZhMi4u OGNhOGQ0MThjYTM3IDEwMDY0NAo+IC0tLSBhL2RyaXZlcnMvZ3B1L2RybS9kcm1fZHBfbXN0X3Rv cG9sb2d5LmMKPiArKysgYi9kcml2ZXJzL2dwdS9kcm0vZHJtX2RwX21zdF90b3BvbG9neS5jCj4g QEAgLTgxNCw3ICs4MTQsNyBAQCBzdGF0aWMgaW50IGRybV9kcF9tc3Rfd2FpdF90eF9yZXBseShz dHJ1Y3QgZHJtX2RwX21zdF9icmFuY2ggKm1zdGIsCj4gIAkJCWdvdG8gb3V0Owo+ICAJCX0KPiAg CX0gZWxzZSB7Cj4gLQkJRFJNX0RFQlVHX0tNUygidGltZWRvdXQgbXNnIHNlbmQgJXAgJWQgJWRc biIsIHR4bXNnLCB0eG1zZy0+c3RhdGUsIHR4bXNnLT5zZXFubyk7Cj4gKwkJRFJNX0RFQlVHX0tN UygidGltZWRvdXQgbXNnIHNlbmQgJXB4ICVkICVkXG4iLCB0eG1zZywgdHhtc2ctPnN0YXRlLCB0 eG1zZy0+c2Vxbm8pOwo+ICAKPiAgCQkvKiBkdW1wIHNvbWUgc3RhdGUgKi8KPiAgCQlyZXQgPSAt RUlPOwo+IEBAIC0yMzM1LDcgKzIzMzUsNyBAQCBzdGF0aWMgaW50IGRybV9kcF9tc3RfaGFuZGxl X2Rvd25fcmVwKHN0cnVjdCBkcm1fZHBfbXN0X3RvcG9sb2d5X21nciAqbWdyKQo+ICAJCW11dGV4 X3VubG9jaygmbWdyLT5xbG9jayk7Cj4gIAo+ICAJCWlmICghdHhtc2cpIHsKPiAtCQkJRFJNX0RF QlVHX0tNUygiR290IE1TVCByZXBseSB3aXRoIG5vIG1zZyAlcCAlZCAlZCAlMDJ4ICUwMnhcbiIs Cj4gKwkJCURSTV9ERUJVR19LTVMoIkdvdCBNU1QgcmVwbHkgd2l0aCBubyBtc2cgJXB4ICVkICVk ICUwMnggJTAyeFxuIiwKPiAgCQkJICAgICAgIG1zdGIsCj4gIAkJCSAgICAgICBtZ3ItPmRvd25f cmVwX3JlY3YuaW5pdGlhbF9oZHIuc2Vxbm8sCj4gIAkJCSAgICAgICBtZ3ItPmRvd25fcmVwX3Jl Y3YuaW5pdGlhbF9oZHIubGN0LAo+IGRpZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9kcm0vZHJtX2xl YXNlLmMgYi9kcml2ZXJzL2dwdS9kcm0vZHJtX2xlYXNlLmMKPiBpbmRleCBkMzQ1NTYzZmRmZjMu LjQ3YmFlYzgxYTgxNyAxMDA2NDQKPiAtLS0gYS9kcml2ZXJzL2dwdS9kcm0vZHJtX2xlYXNlLmMK PiArKysgYi9kcml2ZXJzL2dwdS9kcm0vZHJtX2xlYXNlLmMKPiBAQCAtMjQ4LDcgKzI0OCw3IEBA IHN0YXRpYyBzdHJ1Y3QgZHJtX21hc3RlciAqZHJtX2xlYXNlX2NyZWF0ZShzdHJ1Y3QgZHJtX21h c3RlciAqbGVzc29yLCBzdHJ1Y3QgaWRyCj4gIAo+ICAJLyogTW92ZSB0aGUgbGVhc2VzIG92ZXIg Ki8KPiAgCWxlc3NlZS0+bGVhc2VzID0gKmxlYXNlczsKPiAtCURSTV9ERUJVR19MRUFTRSgibmV3 IGxlc3NlZSAlZCAlcCwgbGVzc29yICVkICVwXG4iLCBsZXNzZWUtPmxlc3NlZV9pZCwgbGVzc2Vl LCBsZXNzb3ItPmxlc3NlZV9pZCwgbGVzc29yKTsKPiArCURSTV9ERUJVR19MRUFTRSgibmV3IGxl c3NlZSAlZCAlcHgsIGxlc3NvciAlZCAlcHhcbiIsIGxlc3NlZS0+bGVzc2VlX2lkLCBsZXNzZWUs IGxlc3Nvci0+bGVzc2VlX2lkLCBsZXNzb3IpOwo+ICAKPiAgCW11dGV4X3VubG9jaygmZGV2LT5t b2RlX2NvbmZpZy5pZHJfbXV0ZXgpOwo+ICAJcmV0dXJuIGxlc3NlZTsKPiBAQCAtMzIwLDcgKzMy MCw3IEBAIHN0YXRpYyB2b2lkIF9kcm1fbGVhc2VfcmV2b2tlKHN0cnVjdCBkcm1fbWFzdGVyICp0 b3ApCj4gIAkgKiB0aGUgdHJlZSBpcyBmdWxseSBjb25uZWN0ZWQsIHdlIGNhbiBkbyB0aGlzIHdp dGhvdXQgcmVjdXJzaW5nCj4gIAkgKi8KPiAgCWZvciAoOzspIHsKPiAtCQlEUk1fREVCVUdfTEVB U0UoInJldm9rZSBsZWFzZXMgZm9yICVwICVkXG4iLCBtYXN0ZXIsIG1hc3Rlci0+bGVzc2VlX2lk KTsKPiArCQlEUk1fREVCVUdfTEVBU0UoInJldm9rZSBsZWFzZXMgZm9yICVweCAlZFxuIiwgbWFz dGVyLCBtYXN0ZXItPmxlc3NlZV9pZCk7Cj4gIAo+ICAJCS8qIEV2YWN1YXRlIHRoZSBsZWFzZSAq Lwo+ICAJCWlkcl9mb3JfZWFjaF9lbnRyeSgmbWFzdGVyLT5sZWFzZXMsIGVudHJ5LCBvYmplY3Qp Cj4gQEAgLTU2NCw3ICs1NjQsNyBAQCBpbnQgZHJtX21vZGVfY3JlYXRlX2xlYXNlX2lvY3RsKHN0 cnVjdCBkcm1fZGV2aWNlICpkZXYsCj4gIAl9Cj4gIAo+ICAJLyogSW5pdGlhbGl6ZSB0aGUgbmV3 IGZpbGUgZm9yIERSTSAqLwo+IC0JRFJNX0RFQlVHX0xFQVNFKCJJbml0aWFsaXppbmcgdGhlIGZp bGUgd2l0aCAlcFxuIiwgbGVzc2VlX2ZpbGUtPmZfb3AtPm9wZW4pOwo+ICsJRFJNX0RFQlVHX0xF QVNFKCJJbml0aWFsaXppbmcgdGhlIGZpbGUgd2l0aCAlcHhcbiIsIGxlc3NlZV9maWxlLT5mX29w LT5vcGVuKTsKPiAgCXJldCA9IGxlc3NlZV9maWxlLT5mX29wLT5vcGVuKGxlc3NlZV9maWxlLT5m X2lub2RlLCBsZXNzZWVfZmlsZSk7Cj4gIAlpZiAocmV0KQo+ICAJCWdvdG8gb3V0X2xlc3NlZV9m aWxlOwo+IGRpZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9kcm0vZHJtX2xvY2suYyBiL2RyaXZlcnMv Z3B1L2RybS9kcm1fbG9jay5jCj4gaW5kZXggOTZiYjZiYWRiODE4Li41NTBiNDYyYzk1MjYgMTAw NjQ0Cj4gLS0tIGEvZHJpdmVycy9ncHUvZHJtL2RybV9sb2NrLmMKPiArKysgYi9kcml2ZXJzL2dw dS9kcm0vZHJtX2xvY2suYwo+IEBAIC0zNDEsNyArMzQxLDcgQEAgdm9pZCBkcm1fbGVnYWN5X2xv Y2tfcmVsZWFzZShzdHJ1Y3QgZHJtX2RldmljZSAqZGV2LCBzdHJ1Y3QgZmlsZSAqZmlscCkKPiAg CQlyZXR1cm47Cj4gIAo+ICAJaWYgKGRybV9sZWdhY3lfaV9oYXZlX2h3X2xvY2soZGV2LCBmaWxl X3ByaXYpKSB7Cj4gLQkJRFJNX0RFQlVHKCJGaWxlICVwIHJlbGVhc2VkLCBmcmVlaW5nIGxvY2sg Zm9yIGNvbnRleHQgJWRcbiIsCj4gKwkJRFJNX0RFQlVHKCJGaWxlICVweCByZWxlYXNlZCwgZnJl ZWluZyBsb2NrIGZvciBjb250ZXh0ICVkXG4iLAo+ICAJCQkgIGZpbHAsIF9EUk1fTE9DS0lOR19D T05URVhUKGZpbGVfcHJpdi0+bWFzdGVyLT5sb2NrLmh3X2xvY2stPmxvY2spKTsKPiAgCQlkcm1f bGVnYWN5X2xvY2tfZnJlZSgmZmlsZV9wcml2LT5tYXN0ZXItPmxvY2ssCj4gIAkJCQkgICAgIF9E Uk1fTE9DS0lOR19DT05URVhUKGZpbGVfcHJpdi0+bWFzdGVyLT5sb2NrLmh3X2xvY2stPmxvY2sp KTsKPiBkaWZmIC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJtL2RybV9zY2F0dGVyLmMgYi9kcml2ZXJz L2dwdS9kcm0vZHJtX3NjYXR0ZXIuYwo+IGluZGV4IDI3NWJjYTQ0ZjM4Yy4uMDYzNDBjMDdlYzEy IDEwMDY0NAo+IC0tLSBhL2RyaXZlcnMvZ3B1L2RybS9kcm1fc2NhdHRlci5jCj4gKysrIGIvZHJp dmVycy9ncHUvZHJtL2RybV9zY2F0dGVyLmMKPiBAQCAtMTM0LDcgKzEzNCw3IEBAIGludCBkcm1f bGVnYWN5X3NnX2FsbG9jKHN0cnVjdCBkcm1fZGV2aWNlICpkZXYsIHZvaWQgKmRhdGEsCj4gIAll bnRyeS0+aGFuZGxlID0gU2NhdHRlckhhbmRsZSgodW5zaWduZWQgbG9uZyllbnRyeS0+dmlydHVh bCk7Cj4gIAo+ICAJRFJNX0RFQlVHKCJoYW5kbGUgID0gJTA4bHhcbiIsIGVudHJ5LT5oYW5kbGUp Owo+IC0JRFJNX0RFQlVHKCJ2aXJ0dWFsID0gJXBcbiIsIGVudHJ5LT52aXJ0dWFsKTsKPiArCURS TV9ERUJVRygidmlydHVhbCA9ICVweFxuIiwgZW50cnktPnZpcnR1YWwpOwo+ICAKPiAgCWZvciAo aSA9ICh1bnNpZ25lZCBsb25nKWVudHJ5LT52aXJ0dWFsLCBqID0gMDsgaiA8IHBhZ2VzOwo+ICAJ ICAgICBpICs9IFBBR0VfU0laRSwgaisrKSB7Cj4gQEAgLTIxMyw3ICsyMTMsNyBAQCBpbnQgZHJt X2xlZ2FjeV9zZ19mcmVlKHN0cnVjdCBkcm1fZGV2aWNlICpkZXYsIHZvaWQgKmRhdGEsCj4gIAlp ZiAoIWVudHJ5IHx8IGVudHJ5LT5oYW5kbGUgIT0gcmVxdWVzdC0+aGFuZGxlKQo+ICAJCXJldHVy biAtRUlOVkFMOwo+ICAKPiAtCURSTV9ERUJVRygidmlydHVhbCAgPSAlcFxuIiwgZW50cnktPnZp cnR1YWwpOwo+ICsJRFJNX0RFQlVHKCJ2aXJ0dWFsICA9ICVweFxuIiwgZW50cnktPnZpcnR1YWwp Owo+ICAKPiAgCWRybV9zZ19jbGVhbnVwKGVudHJ5KTsKPiAgCj4gZGlmZiAtLWdpdCBhL2RyaXZl cnMvZ3B1L2RybS9ldG5hdml2L2V0bmF2aXZfZHJ2LmMgYi9kcml2ZXJzL2dwdS9kcm0vZXRuYXZp di9ldG5hdml2X2Rydi5jCj4gaW5kZXggYWI1MDA5MGQwNjZjLi4wOTA2NTU5NjQ2M2IgMTAwNjQ0 Cj4gLS0tIGEvZHJpdmVycy9ncHUvZHJtL2V0bmF2aXYvZXRuYXZpdl9kcnYuYwo+ICsrKyBiL2Ry aXZlcnMvZ3B1L2RybS9ldG5hdml2L2V0bmF2aXZfZHJ2LmMKPiBAQCAtNTIsNyArNTIsNyBAQCB2 b2lkIF9faW9tZW0gKmV0bmF2aXZfaW9yZW1hcChzdHJ1Y3QgcGxhdGZvcm1fZGV2aWNlICpwZGV2 LCBjb25zdCBjaGFyICpuYW1lLAo+ICAJfQo+ICAKPiAgCWlmIChyZWdsb2cpCj4gLQkJZGV2X3By aW50ayhLRVJOX0RFQlVHLCAmcGRldi0+ZGV2LCAiSU86cmVnaW9uICVzIDB4JXAgJTA4enhcbiIs Cj4gKwkJZGV2X3ByaW50ayhLRVJOX0RFQlVHLCAmcGRldi0+ZGV2LCAiSU86cmVnaW9uICVzIDB4 JXB4ICUwOHp4XG4iLAo+ICAJCQkgICBkYmduYW1lLCBwdHIsIChzaXplX3QpcmVzb3VyY2Vfc2l6 ZShyZXMpKTsKPiAgCj4gIAlyZXR1cm4gcHRyOwo+IEBAIC02MSw3ICs2MSw3IEBAIHZvaWQgX19p b21lbSAqZXRuYXZpdl9pb3JlbWFwKHN0cnVjdCBwbGF0Zm9ybV9kZXZpY2UgKnBkZXYsIGNvbnN0 IGNoYXIgKm5hbWUsCj4gIHZvaWQgZXRuYXZpdl93cml0ZWwodTMyIGRhdGEsIHZvaWQgX19pb21l bSAqYWRkcikKPiAgewo+ICAJaWYgKHJlZ2xvZykKPiAtCQlwcmludGsoS0VSTl9ERUJVRyAiSU86 VyAlcCAlMDh4XG4iLCBhZGRyLCBkYXRhKTsKPiArCQlwcmludGsoS0VSTl9ERUJVRyAiSU86VyAl cHggJTA4eFxuIiwgYWRkciwgZGF0YSk7Cj4gIAo+ICAJd3JpdGVsKGRhdGEsIGFkZHIpOwo+ICB9 Cj4gQEAgLTcxLDcgKzcxLDcgQEAgdTMyIGV0bmF2aXZfcmVhZGwoY29uc3Qgdm9pZCBfX2lvbWVt ICphZGRyKQo+ICAJdTMyIHZhbCA9IHJlYWRsKGFkZHIpOwo+ICAKPiAgCWlmIChyZWdsb2cpCj4g LQkJcHJpbnRrKEtFUk5fREVCVUcgIklPOlIgJXAgJTA4eFxuIiwgYWRkciwgdmFsKTsKPiArCQlw cmludGsoS0VSTl9ERUJVRyAiSU86UiAlcHggJTA4eFxuIiwgYWRkciwgdmFsKTsKPiAgCj4gIAly ZXR1cm4gdmFsOwo+ICB9Cj4gZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2RybS9pODEwL2k4MTBf ZG1hLmMgYi9kcml2ZXJzL2dwdS9kcm0vaTgxMC9pODEwX2RtYS5jCj4gaW5kZXggNTc2YTQxNzY5 MGQ0Li4wMGI4NzJmZDI3YjAgMTAwNjQ0Cj4gLS0tIGEvZHJpdmVycy9ncHUvZHJtL2k4MTAvaTgx MF9kbWEuYwo+ICsrKyBiL2RyaXZlcnMvZ3B1L2RybS9pODEwL2k4MTBfZG1hLmMKPiBAQCAtMzk5 LDcgKzM5OSw3IEBAIHN0YXRpYyBpbnQgaTgxMF9kbWFfaW5pdGlhbGl6ZShzdHJ1Y3QgZHJtX2Rl dmljZSAqZGV2LAo+ICAJCURSTV9FUlJPUigiQ2FuIG5vdCBhbGxvY2F0ZSBoYXJkd2FyZSBzdGF0 dXMgcGFnZVxuIik7Cj4gIAkJcmV0dXJuIC1FTk9NRU07Cj4gIAl9Cj4gLQlEUk1fREVCVUcoImh3 IHN0YXR1cyBwYWdlIEAgJXBcbiIsIGRldl9wcml2LT5od19zdGF0dXNfcGFnZSk7Cj4gKwlEUk1f REVCVUcoImh3IHN0YXR1cyBwYWdlIEAgJXB4XG4iLCBkZXZfcHJpdi0+aHdfc3RhdHVzX3BhZ2Up Owo+ICAKPiAgCUk4MTBfV1JJVEUoMHgwMjA4MCwgZGV2X3ByaXYtPmRtYV9zdGF0dXNfcGFnZSk7 Cj4gIAlEUk1fREVCVUcoIkVuYWJsZWQgaGFyZHdhcmUgc3RhdHVzIHBhZ2VcbiIpOwo+IGRpZmYg LS1naXQgYS9kcml2ZXJzL2dwdS9kcm0vaTkxNS9pOTE1X3BlcmYuYyBiL2RyaXZlcnMvZ3B1L2Ry bS9pOTE1L2k5MTVfcGVyZi5jCj4gaW5kZXggYWJhY2E2ZWRlYjcxLi5hOTBjYTI0YjAzZWEgMTAw NjQ0Cj4gLS0tIGEvZHJpdmVycy9ncHUvZHJtL2k5MTUvaTkxNV9wZXJmLmMKPiArKysgYi9kcml2 ZXJzL2dwdS9kcm0vaTkxNS9pOTE1X3BlcmYuYwo+IEBAIC0xNDczLDcgKzE0NzMsNyBAQCBzdGF0 aWMgaW50IGFsbG9jX29hX2J1ZmZlcihzdHJ1Y3QgZHJtX2k5MTVfcHJpdmF0ZSAqZGV2X3ByaXYp Cj4gIAo+ICAJZGV2X3ByaXYtPnBlcmYub2Eub3BzLmluaXRfb2FfYnVmZmVyKGRldl9wcml2KTsK PiAgCj4gLQlEUk1fREVCVUdfRFJJVkVSKCJPQSBCdWZmZXIgaW5pdGlhbGl6ZWQsIGd0dCBvZmZz ZXQgPSAweCV4LCB2YWRkciA9ICVwXG4iLAo+ICsJRFJNX0RFQlVHX0RSSVZFUigiT0EgQnVmZmVy IGluaXRpYWxpemVkLCBndHQgb2Zmc2V0ID0gMHgleCwgdmFkZHIgPSAlcHhcbiIsCj4gIAkJCSBp OTE1X2dndHRfb2Zmc2V0KGRldl9wcml2LT5wZXJmLm9hLm9hX2J1ZmZlci52bWEpLAo+ICAJCQkg ZGV2X3ByaXYtPnBlcmYub2Eub2FfYnVmZmVyLnZhZGRyKTsKPiAgCj4gZGlmZiAtLWdpdCBhL2Ry aXZlcnMvZ3B1L2RybS9pOTE1L2ludGVsX2Rpc3BsYXkuYyBiL2RyaXZlcnMvZ3B1L2RybS9pOTE1 L2ludGVsX2Rpc3BsYXkuYwo+IGluZGV4IDNiNDhmZDI1NjFmZS4uOTc1OTI1N2FjNjE0IDEwMDY0 NAo+IC0tLSBhL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2ludGVsX2Rpc3BsYXkuYwo+ICsrKyBiL2Ry aXZlcnMvZ3B1L2RybS9pOTE1L2ludGVsX2Rpc3BsYXkuYwo+IEBAIC0yNzMyLDcgKzI3MzIsNyBA QCBpbnRlbF9hbGxvY19pbml0aWFsX3BsYW5lX29iaihzdHJ1Y3QgaW50ZWxfY3J0YyAqY3J0YywK PiAgCX0KPiAgCj4gIAo+IC0JRFJNX0RFQlVHX0tNUygiaW5pdGlhbCBwbGFuZSBmYiBvYmogJXBc biIsIG9iaik7Cj4gKwlEUk1fREVCVUdfS01TKCJpbml0aWFsIHBsYW5lIGZiIG9iaiAlcHhcbiIs IG9iaik7Cj4gIAlyZXR1cm4gdHJ1ZTsKPiAgCj4gIG91dF91bnJlZl9vYmo6Cj4gZGlmZiAtLWdp dCBhL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2ludGVsX2d1Y19jdC5jIGIvZHJpdmVycy9ncHUvZHJt L2k5MTUvaW50ZWxfZ3VjX2N0LmMKPiBpbmRleCAyNGFkNTU3NTIzOTYuLjNjNDRjMTk0NmU2NiAx MDA2NDQKPiAtLS0gYS9kcml2ZXJzL2dwdS9kcm0vaTkxNS9pbnRlbF9ndWNfY3QuYwo+ICsrKyBi L2RyaXZlcnMvZ3B1L2RybS9pOTE1L2ludGVsX2d1Y19jdC5jCj4gQEAgLTQ5LDcgKzQ5LDcgQEAg c3RhdGljIGlubGluZSBjb25zdCBjaGFyICpndWNfY3RfYnVmZmVyX3R5cGVfdG9fc3RyKHUzMiB0 eXBlKQo+ICBzdGF0aWMgdm9pZCBndWNfY3RfYnVmZmVyX2Rlc2NfaW5pdChzdHJ1Y3QgZ3VjX2N0 X2J1ZmZlcl9kZXNjICpkZXNjLAo+ICAJCQkJICAgIHUzMiBjbWRzX2FkZHIsIHUzMiBzaXplLCB1 MzIgb3duZXIpCj4gIHsKPiAtCURSTV9ERUJVR19EUklWRVIoIkNUOiBkZXNjICVwIGluaXQgYWRk cj0lI3ggc2l6ZT0ldSBvd25lcj0ldVxuIiwKPiArCURSTV9ERUJVR19EUklWRVIoIkNUOiBkZXNj ICVweCBpbml0IGFkZHI9JSN4IHNpemU9JXUgb3duZXI9JXVcbiIsCj4gIAkJCSBkZXNjLCBjbWRz X2FkZHIsIHNpemUsIG93bmVyKTsKPiAgCW1lbXNldChkZXNjLCAwLCBzaXplb2YoKmRlc2MpKTsK PiAgCWRlc2MtPmFkZHIgPSBjbWRzX2FkZHI7Cj4gQEAgLTU5LDcgKzU5LDcgQEAgc3RhdGljIHZv aWQgZ3VjX2N0X2J1ZmZlcl9kZXNjX2luaXQoc3RydWN0IGd1Y19jdF9idWZmZXJfZGVzYyAqZGVz YywKPiAgCj4gIHN0YXRpYyB2b2lkIGd1Y19jdF9idWZmZXJfZGVzY19yZXNldChzdHJ1Y3QgZ3Vj X2N0X2J1ZmZlcl9kZXNjICpkZXNjKQo+ICB7Cj4gLQlEUk1fREVCVUdfRFJJVkVSKCJDVDogZGVz YyAlcCByZXNldCBoZWFkPSV1IHRhaWw9JXVcbiIsCj4gKwlEUk1fREVCVUdfRFJJVkVSKCJDVDog ZGVzYyAlcHggcmVzZXQgaGVhZD0ldSB0YWlsPSV1XG4iLAo+ICAJCQkgZGVzYywgZGVzYy0+aGVh ZCwgZGVzYy0+dGFpbCk7Cj4gIAlkZXNjLT5oZWFkID0gMDsKPiAgCWRlc2MtPnRhaWwgPSAwOwo+ IGRpZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9kcm0vaTkxNS9pbnRlbF9ndWNfc3VibWlzc2lvbi5j IGIvZHJpdmVycy9ncHUvZHJtL2k5MTUvaW50ZWxfZ3VjX3N1Ym1pc3Npb24uYwo+IGluZGV4IDhh OGFkMmZlMTU4ZC4uMTBhZjk1ZTkxY2ExIDEwMDY0NAo+IC0tLSBhL2RyaXZlcnMvZ3B1L2RybS9p OTE1L2ludGVsX2d1Y19zdWJtaXNzaW9uLmMKPiArKysgYi9kcml2ZXJzL2dwdS9kcm0vaTkxNS9p bnRlbF9ndWNfc3VibWlzc2lvbi5jCj4gQEAgLTkyOCw3ICs5MjgsNyBAQCBndWNfY2xpZW50X2Fs bG9jKHN0cnVjdCBkcm1faTkxNV9wcml2YXRlICpkZXZfcHJpdiwKPiAgCWlmIChyZXQpCj4gIAkJ Z290byBlcnJfdmFkZHI7Cj4gIAo+IC0JRFJNX0RFQlVHX0RSSVZFUigibmV3IHByaW9yaXR5ICV1 IGNsaWVudCAlcCBmb3IgZW5naW5lKHMpIDB4JXg6IHN0YWdlX2lkICV1XG4iLAo+ICsJRFJNX0RF QlVHX0RSSVZFUigibmV3IHByaW9yaXR5ICV1IGNsaWVudCAlcHggZm9yIGVuZ2luZShzKSAweCV4 OiBzdGFnZV9pZCAldVxuIiwKPiAgCQkJIHByaW9yaXR5LCBjbGllbnQsIGNsaWVudC0+ZW5naW5l cywgY2xpZW50LT5zdGFnZV9pZCk7Cj4gIAlEUk1fREVCVUdfRFJJVkVSKCJkb29yYmVsbCBpZCAl dSwgY2FjaGVsaW5lIG9mZnNldCAweCVseFxuIiwKPiAgCQkJIGNsaWVudC0+ZG9vcmJlbGxfaWQs IGNsaWVudC0+ZG9vcmJlbGxfb2Zmc2V0KTsKPiBkaWZmIC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJt L2k5MTUvaW50ZWxfdWNfZncuYyBiL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2ludGVsX3VjX2Z3LmMK PiBpbmRleCAzZWMwY2U1MDViNzYuLjRjOTY4MDc4YzYxYyAxMDA2NDQKPiAtLS0gYS9kcml2ZXJz L2dwdS9kcm0vaTkxNS9pbnRlbF91Y19mdy5jCj4gKysrIGIvZHJpdmVycy9ncHUvZHJtL2k5MTUv aW50ZWxfdWNfZncuYwo+IEBAIC02NCw3ICs2NCw3IEBAIHZvaWQgaW50ZWxfdWNfZndfZmV0Y2go c3RydWN0IGRybV9pOTE1X3ByaXZhdGUgKmRldl9wcml2LAo+ICAJCWdvdG8gZmFpbDsKPiAgCX0K PiAgCj4gLQlEUk1fREVCVUdfRFJJVkVSKCIlcyBmdyBzaXplICV6dSBwdHIgJXBcbiIsCj4gKwlE Uk1fREVCVUdfRFJJVkVSKCIlcyBmdyBzaXplICV6dSBwdHIgJXB4XG4iLAo+ICAJCQkgaW50ZWxf dWNfZndfdHlwZV9yZXByKHVjX2Z3LT50eXBlKSwgZnctPnNpemUsIGZ3KTsKPiAgCj4gIAkvKiBD aGVjayB0aGUgc2l6ZSBvZiB0aGUgYmxvYiBiZWZvcmUgZXhhbWluaW5nIGJ1ZmZlciBjb250ZW50 cyAqLwo+IGRpZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9kcm0vbWVkaWF0ZWsvbXRrX2RybV9nZW0u YyBiL2RyaXZlcnMvZ3B1L2RybS9tZWRpYXRlay9tdGtfZHJtX2dlbS5jCj4gaW5kZXggZjU5NWFj ODE2YjU1Li5jY2RlYzgxZGU5ZTMgMTAwNjQ0Cj4gLS0tIGEvZHJpdmVycy9ncHUvZHJtL21lZGlh dGVrL210a19kcm1fZ2VtLmMKPiArKysgYi9kcml2ZXJzL2dwdS9kcm0vbWVkaWF0ZWsvbXRrX2Ry bV9nZW0uYwo+IEBAIC03MSw3ICs3MSw3IEBAIHN0cnVjdCBtdGtfZHJtX2dlbV9vYmogKm10a19k cm1fZ2VtX2NyZWF0ZShzdHJ1Y3QgZHJtX2RldmljZSAqZGV2LAo+ICAJaWYgKGFsbG9jX2ttYXAp Cj4gIAkJbXRrX2dlbS0+a3ZhZGRyID0gbXRrX2dlbS0+Y29va2llOwo+ICAKPiAtCURSTV9ERUJV R19EUklWRVIoImNvb2tpZSA9ICVwIGRtYV9hZGRyID0gJXBhZCBzaXplID0gJXp1XG4iLAo+ICsJ RFJNX0RFQlVHX0RSSVZFUigiY29va2llID0gJXB4IGRtYV9hZGRyID0gJXBhZCBzaXplID0gJXp1 XG4iLAo+ICAJCQkgbXRrX2dlbS0+Y29va2llLCAmbXRrX2dlbS0+ZG1hX2FkZHIsCj4gIAkJCSBz aXplKTsKPiAgCj4gZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2RybS9tZ2EvbWdhX3dhcnAuYyBi L2RyaXZlcnMvZ3B1L2RybS9tZ2EvbWdhX3dhcnAuYwo+IGluZGV4IDBiNzYzNTIyNjBhOS4uNWIy ODZmMDRmODA1IDEwMDY0NAo+IC0tLSBhL2RyaXZlcnMvZ3B1L2RybS9tZ2EvbWdhX3dhcnAuYwo+ ICsrKyBiL2RyaXZlcnMvZ3B1L2RybS9tZ2EvbWdhX3dhcnAuYwo+IEBAIC0xMTYsNyArMTE2LDcg QEAgaW50IG1nYV93YXJwX2luc3RhbGxfbWljcm9jb2RlKGRybV9tZ2FfcHJpdmF0ZV90ICpkZXZf cHJpdikKPiAgCSAgICAgcmVjID0gaWhleF9uZXh0X2JpbnJlYyhyZWMpKSB7Cj4gIAkJdW5zaWdu ZWQgaW50IHNyY19zaXplLCBkc3Rfc2l6ZTsKPiAgCj4gLQkJRFJNX0RFQlVHKCIgcGNiYXNlID0g MHglMDhseCAgdmNiYXNlID0gJXBcbiIsIHBjYmFzZSwgdmNiYXNlKTsKPiArCQlEUk1fREVCVUco IiBwY2Jhc2UgPSAweCUwOGx4ICB2Y2Jhc2UgPSAlcHhcbiIsIHBjYmFzZSwgdmNiYXNlKTsKPiAg CQlkZXZfcHJpdi0+d2FycF9waXBlX3BoeXNbd2hlcmVdID0gcGNiYXNlOwo+ICAJCXNyY19zaXpl ID0gYmUxNl90b19jcHUocmVjLT5sZW4pOwo+ICAJCWRzdF9zaXplID0gV0FSUF9VQ09ERV9TSVpF KHNyY19zaXplKTsKPiBkaWZmIC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJtL21zbS9tc21fZHJ2LmMg Yi9kcml2ZXJzL2dwdS9kcm0vbXNtL21zbV9kcnYuYwo+IGluZGV4IDMwY2Q1MTRkOGY3Yy4uMDc4 ZTljMzE4M2U4IDEwMDY0NAo+IC0tLSBhL2RyaXZlcnMvZ3B1L2RybS9tc20vbXNtX2Rydi5jCj4g KysrIGIvZHJpdmVycy9ncHUvZHJtL21zbS9tc21fZHJ2LmMKPiBAQCAtMTIyLDcgKzEyMiw3IEBA IHZvaWQgX19pb21lbSAqbXNtX2lvcmVtYXAoc3RydWN0IHBsYXRmb3JtX2RldmljZSAqcGRldiwg Y29uc3QgY2hhciAqbmFtZSwKPiAgCX0KPiAgCj4gIAlpZiAocmVnbG9nKQo+IC0JCXByaW50ayhL RVJOX0RFQlVHICJJTzpyZWdpb24gJXMgJXAgJTA4bHhcbiIsIGRiZ25hbWUsIHB0ciwgc2l6ZSk7 Cj4gKwkJcHJpbnRrKEtFUk5fREVCVUcgIklPOnJlZ2lvbiAlcyAlcHggJTA4bHhcbiIsIGRiZ25h bWUsIHB0ciwgc2l6ZSk7Cj4gIAo+ICAJcmV0dXJuIHB0cjsKPiAgfQo+IEBAIC0xMzAsNyArMTMw LDcgQEAgdm9pZCBfX2lvbWVtICptc21faW9yZW1hcChzdHJ1Y3QgcGxhdGZvcm1fZGV2aWNlICpw ZGV2LCBjb25zdCBjaGFyICpuYW1lLAo+ICB2b2lkIG1zbV93cml0ZWwodTMyIGRhdGEsIHZvaWQg X19pb21lbSAqYWRkcikKPiAgewo+ICAJaWYgKHJlZ2xvZykKPiAtCQlwcmludGsoS0VSTl9ERUJV RyAiSU86VyAlcCAlMDh4XG4iLCBhZGRyLCBkYXRhKTsKPiArCQlwcmludGsoS0VSTl9ERUJVRyAi SU86VyAlcHggJTA4eFxuIiwgYWRkciwgZGF0YSk7Cj4gIAl3cml0ZWwoZGF0YSwgYWRkcik7Cj4g IH0KPiAgCj4gZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2RybS9xeGwvcXhsX2NtZC5jIGIvZHJp dmVycy9ncHUvZHJtL3F4bC9xeGxfY21kLmMKPiBpbmRleCBjMGZiNTJjNmQ0Y2EuLmY2YzY0YzVj Yjk5ZiAxMDA2NDQKPiAtLS0gYS9kcml2ZXJzL2dwdS9kcm0vcXhsL3F4bF9jbWQuYwo+ICsrKyBi L2RyaXZlcnMvZ3B1L2RybS9xeGwvcXhsX2NtZC5jCj4gQEAgLTM4MSw3ICszODEsNyBAQCB2b2lk IHF4bF9pb19jcmVhdGVfcHJpbWFyeShzdHJ1Y3QgcXhsX2RldmljZSAqcWRldiwKPiAgewo+ICAJ c3RydWN0IHF4bF9zdXJmYWNlX2NyZWF0ZSAqY3JlYXRlOwo+ICAKPiAtCURSTV9ERUJVR19EUklW RVIoInFkZXYgJXAsIHJhbV9oZWFkZXIgJXBcbiIsIHFkZXYsIHFkZXYtPnJhbV9oZWFkZXIpOwo+ ICsJRFJNX0RFQlVHX0RSSVZFUigicWRldiAlcHgsIHJhbV9oZWFkZXIgJXB4XG4iLCBxZGV2LCBx ZGV2LT5yYW1faGVhZGVyKTsKPiAgCWNyZWF0ZSA9ICZxZGV2LT5yYW1faGVhZGVyLT5jcmVhdGVf c3VyZmFjZTsKPiAgCWNyZWF0ZS0+Zm9ybWF0ID0gYm8tPnN1cmYuZm9ybWF0Owo+ICAJY3JlYXRl LT53aWR0aCA9IGJvLT5zdXJmLndpZHRoOwo+IEBAIC0zOTMsNyArMzkzLDcgQEAgdm9pZCBxeGxf aW9fY3JlYXRlX3ByaW1hcnkoc3RydWN0IHF4bF9kZXZpY2UgKnFkZXYsCj4gIAkJY3JlYXRlLT5t ZW0gPSBxeGxfYm9fcGh5c2ljYWxfYWRkcmVzcyhxZGV2LCBibywgb2Zmc2V0KTsKPiAgCX0KPiAg Cj4gLQlEUk1fREVCVUdfRFJJVkVSKCJtZW0gPSAlbGx4LCBmcm9tICVwXG4iLCBjcmVhdGUtPm1l bSwgYm8tPmtwdHIpOwo+ICsJRFJNX0RFQlVHX0RSSVZFUigibWVtID0gJWxseCwgZnJvbSAlcHhc biIsIGNyZWF0ZS0+bWVtLCBiby0+a3B0cik7Cj4gIAo+ICAJY3JlYXRlLT5mbGFncyA9IFFYTF9T VVJGX0ZMQUdfS0VFUF9EQVRBOwo+ICAJY3JlYXRlLT50eXBlID0gUVhMX1NVUkZfVFlQRV9QUklN QVJZOwo+IGRpZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9kcm0vcXhsL3F4bF9mYi5jIGIvZHJpdmVy cy9ncHUvZHJtL3F4bC9xeGxfZmIuYwo+IGluZGV4IDMzODg5MTQwMWYzNS4uY2U1MDZlNzAyYWVk IDEwMDY0NAo+IC0tLSBhL2RyaXZlcnMvZ3B1L2RybS9xeGwvcXhsX2ZiLmMKPiArKysgYi9kcml2 ZXJzL2dwdS9kcm0vcXhsL3F4bF9mYi5jCj4gQEAgLTI0Niw3ICsyNDYsNyBAQCBzdGF0aWMgaW50 IHF4bGZiX2NyZWF0ZShzdHJ1Y3QgcXhsX2ZiZGV2ICpxZmJkZXYsCj4gIAlzaGFkb3cgPSB2bWFs bG9jKG1vZGVfY21kLnBpdGNoZXNbMF0gKiBtb2RlX2NtZC5oZWlnaHQpOwo+ICAJLyogVE9ETzog d2hhdCdzIHRoZSB1c3VhbCByZXNwb25zZSB0byBtZW1vcnkgYWxsb2NhdGlvbiBlcnJvcnM/ICov Cj4gIAlCVUdfT04oIXNoYWRvdyk7Cj4gLQlEUk1fREVCVUdfRFJJVkVSKCJzdXJmYWNlMCBhdCBn cHUgb2Zmc2V0ICVsbGQsIG1tYXBfb2Zmc2V0ICVsbGQgKHZpcnQgJXAsIHNoYWRvdyAlcClcbiIs Cj4gKwlEUk1fREVCVUdfRFJJVkVSKCJzdXJmYWNlMCBhdCBncHUgb2Zmc2V0ICVsbGQsIG1tYXBf b2Zmc2V0ICVsbGQgKHZpcnQgJXB4LCBzaGFkb3cgJXB4KVxuIiwKPiAgCQkJIHF4bF9ib19ncHVf b2Zmc2V0KHFibyksIHF4bF9ib19tbWFwX29mZnNldChxYm8pLAo+ICAJCQkgcWJvLT5rcHRyLCBz aGFkb3cpOwo+ICAJc2l6ZSA9IG1vZGVfY21kLnBpdGNoZXNbMF0gKiBtb2RlX2NtZC5oZWlnaHQ7 Cj4gZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2RybS9xeGwvcXhsX3R0bS5jIGIvZHJpdmVycy9n cHUvZHJtL3F4bC9xeGxfdHRtLmMKPiBpbmRleCBlZTIzNDBlMzFmMDYuLmJiYmY5NDMzZDMyYSAx MDA2NDQKPiAtLS0gYS9kcml2ZXJzL2dwdS9kcm0vcXhsL3F4bF90dG0uYwo+ICsrKyBiL2RyaXZl cnMvZ3B1L2RybS9xeGwvcXhsX3R0bS5jCj4gQEAgLTEzMyw3ICsxMzMsNyBAQCBpbnQgcXhsX21t YXAoc3RydWN0IGZpbGUgKmZpbHAsIHN0cnVjdCB2bV9hcmVhX3N0cnVjdCAqdm1hKQo+ICAJCSAi ZmlscC0+cHJpdmF0ZV9kYXRhLT5taW5vci0+ZGV2LT5kZXZfcHJpdmF0ZSA9PSBOVUxMXG4iKTsK PiAgCQlyZXR1cm4gLUVJTlZBTDsKPiAgCX0KPiAtCURSTV9ERUJVR19EUklWRVIoImZpbHAtPnBy aXZhdGVfZGF0YSA9IDB4JXAsIHZtYS0+dm1fcGdvZmYgPSAlbHhcbiIsCj4gKwlEUk1fREVCVUdf RFJJVkVSKCJmaWxwLT5wcml2YXRlX2RhdGEgPSAweCVweCwgdm1hLT52bV9wZ29mZiA9ICVseFxu IiwKPiAgCQkgIGZpbHAtPnByaXZhdGVfZGF0YSwgdm1hLT52bV9wZ29mZik7Cj4gIAo+ICAJciA9 IHR0bV9ib19tbWFwKGZpbHAsIHZtYSwgJnFkZXYtPm1tYW4uYmRldik7Cj4gZGlmZiAtLWdpdCBh L2RyaXZlcnMvZ3B1L2RybS9yYWRlb24vcmFkZW9uX2Rpc3BsYXkuYyBiL2RyaXZlcnMvZ3B1L2Ry bS9yYWRlb24vcmFkZW9uX2Rpc3BsYXkuYwo+IGluZGV4IDI2MTI5YjJiMDgyZC4uOWYzODA5MGU4 OWVmIDEwMDY0NAo+IC0tLSBhL2RyaXZlcnMvZ3B1L2RybS9yYWRlb24vcmFkZW9uX2Rpc3BsYXku Ywo+ICsrKyBiL2RyaXZlcnMvZ3B1L2RybS9yYWRlb24vcmFkZW9uX2Rpc3BsYXkuYwo+IEBAIC01 MTMsNyArNTEzLDcgQEAgc3RhdGljIGludCByYWRlb25fY3J0Y19wYWdlX2ZsaXBfdGFyZ2V0KHN0 cnVjdCBkcm1fY3J0YyAqY3J0YywKPiAgCW5ld19yYm8gPSBnZW1fdG9fcmFkZW9uX2JvKG9iaik7 Cj4gIAo+ICAJLyogcGluIHRoZSBuZXcgYnVmZmVyICovCj4gLQlEUk1fREVCVUdfRFJJVkVSKCJm bGlwLWlvY3RsKCkgY3VyX3JibyA9ICVwLCBuZXdfcmJvID0gJXBcbiIsCj4gKwlEUk1fREVCVUdf RFJJVkVSKCJmbGlwLWlvY3RsKCkgY3VyX3JibyA9ICVweCwgbmV3X3JibyA9ICVweFxuIiwKPiAg CQkJIHdvcmstPm9sZF9yYm8sIG5ld19yYm8pOwo+ICAKPiAgCXIgPSByYWRlb25fYm9fcmVzZXJ2 ZShuZXdfcmJvLCBmYWxzZSk7Cj4gZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2RybS9yYWRlb24v cmFkZW9uX2RwX21zdC5jIGIvZHJpdmVycy9ncHUvZHJtL3JhZGVvbi9yYWRlb25fZHBfbXN0LmMK PiBpbmRleCBjZDhhM2VlMTY2NDkuLjQ0MDE2MzkyMTE1ZSAxMDA2NDQKPiAtLS0gYS9kcml2ZXJz L2dwdS9kcm0vcmFkZW9uL3JhZGVvbl9kcF9tc3QuYwo+ICsrKyBiL2RyaXZlcnMvZ3B1L2RybS9y YWRlb24vcmFkZW9uX2RwX21zdC5jCj4gQEAgLTE5Myw3ICsxOTMsNyBAQCBzdGF0aWMgaW50IHJh ZGVvbl9kcF9tc3RfZ2V0X2RkY19tb2RlcyhzdHJ1Y3QgZHJtX2Nvbm5lY3RvciAqY29ubmVjdG9y KQo+ICAKPiAgCWVkaWQgPSBkcm1fZHBfbXN0X2dldF9lZGlkKGNvbm5lY3RvciwgJm1hc3Rlci0+ bXN0X21nciwgcmFkZW9uX2Nvbm5lY3Rvci0+cG9ydCk7Cj4gIAlyYWRlb25fY29ubmVjdG9yLT5l ZGlkID0gZWRpZDsKPiAtCURSTV9ERUJVR19LTVMoImVkaWQgcmV0cmlldmVkICVwXG4iLCBlZGlk KTsKPiArCURSTV9ERUJVR19LTVMoImVkaWQgcmV0cmlldmVkICVweFxuIiwgZWRpZCk7Cj4gIAlp ZiAocmFkZW9uX2Nvbm5lY3Rvci0+ZWRpZCkgewo+ICAJCWRybV9tb2RlX2Nvbm5lY3Rvcl91cGRh dGVfZWRpZF9wcm9wZXJ0eSgmcmFkZW9uX2Nvbm5lY3Rvci0+YmFzZSwgcmFkZW9uX2Nvbm5lY3Rv ci0+ZWRpZCk7Cj4gIAkJcmV0ID0gZHJtX2FkZF9lZGlkX21vZGVzKCZyYWRlb25fY29ubmVjdG9y LT5iYXNlLCByYWRlb25fY29ubmVjdG9yLT5lZGlkKTsKPiBAQCAtMzQ4LDcgKzM0OCw3IEBAIHJh ZGVvbl9jb25uZWN0b3IgKnJhZGVvbl9tc3RfZmluZF9jb25uZWN0b3Ioc3RydWN0IGRybV9lbmNv ZGVyICplbmNvZGVyKQo+ICAJCWlmICghcmFkZW9uX2Nvbm5lY3Rvci0+aXNfbXN0X2Nvbm5lY3Rv cikKPiAgCQkJY29udGludWU7Cj4gIAo+IC0JCURSTV9ERUJVR19LTVMoImNoZWNraW5nICVwIHZz ICVwXG4iLCBjb25uZWN0b3ItPmVuY29kZXIsIGVuY29kZXIpOwo+ICsJCURSTV9ERUJVR19LTVMo ImNoZWNraW5nICVweCB2cyAlcHhcbiIsIGNvbm5lY3Rvci0+ZW5jb2RlciwgZW5jb2Rlcik7Cj4g IAkJaWYgKGNvbm5lY3Rvci0+ZW5jb2RlciA9PSBlbmNvZGVyKQo+ICAJCQlyZXR1cm4gcmFkZW9u X2Nvbm5lY3RvcjsKPiAgCX0KPiBAQCAtMzc0LDcgKzM3NCw3IEBAIHZvaWQgcmFkZW9uX2RwX21z dF9wcmVwYXJlX3BsbChzdHJ1Y3QgZHJtX2NydGMgKmNydGMsIHN0cnVjdCBkcm1fZGlzcGxheV9t b2RlICptCj4gIAkJCXJhZGVvbl9jcnRjLT5icGMgPSA4Owo+ICAJfQo+ICAKPiAtCURSTV9ERUJV R19LTVMoImRwX2Nsb2NrICVwICVkXG4iLCBkaWdfY29ubmVjdG9yLCBkaWdfY29ubmVjdG9yLT5k cF9jbG9jayk7Cj4gKwlEUk1fREVCVUdfS01TKCJkcF9jbG9jayAlcHggJWRcbiIsIGRpZ19jb25u ZWN0b3IsIGRpZ19jb25uZWN0b3ItPmRwX2Nsb2NrKTsKPiAgCWRwX2Nsb2NrID0gZGlnX2Nvbm5l Y3Rvci0+ZHBfY2xvY2s7Cj4gIAlyYWRlb25fY3J0Yy0+c3NfZW5hYmxlZCA9Cj4gIAkJcmFkZW9u X2F0b21iaW9zX2dldF9hc2ljX3NzX2luZm8ocmRldiwgJnJhZGVvbl9jcnRjLT5zcywKPiBAQCAt NTMzLDcgKzUzMyw3IEBAIHN0YXRpYyBib29sIHJhZGVvbl9tc3RfbW9kZV9maXh1cChzdHJ1Y3Qg ZHJtX2VuY29kZXIgKmVuY29kZXIsCj4gIAlkaWdfY29ubmVjdG9yID0gbXN0X2VuYy0+Y29ubmVj dG9yLT5jb25fcHJpdjsKPiAgCWRpZ19jb25uZWN0b3ItPmRwX2xhbmVfY291bnQgPSBkcm1fZHBf bWF4X2xhbmVfY291bnQoZGlnX2Nvbm5lY3Rvci0+ZHBjZCk7Cj4gIAlkaWdfY29ubmVjdG9yLT5k cF9jbG9jayA9IGRybV9kcF9tYXhfbGlua19yYXRlKGRpZ19jb25uZWN0b3ItPmRwY2QpOwo+IC0J RFJNX0RFQlVHX0tNUygiZGlnIGNsb2NrICVwICVkICVkXG4iLCBkaWdfY29ubmVjdG9yLAo+ICsJ RFJNX0RFQlVHX0tNUygiZGlnIGNsb2NrICVweCAlZCAlZFxuIiwgZGlnX2Nvbm5lY3RvciwKPiAg CQkgICAgICBkaWdfY29ubmVjdG9yLT5kcF9sYW5lX2NvdW50LCBkaWdfY29ubmVjdG9yLT5kcF9j bG9jayk7Cj4gIAlyZXR1cm4gdHJ1ZTsKPiAgfQo+IEBAIC01NDcsNyArNTQ3LDcgQEAgc3RhdGlj IHZvaWQgcmFkZW9uX21zdF9lbmNvZGVyX3ByZXBhcmUoc3RydWN0IGRybV9lbmNvZGVyICplbmNv ZGVyKQo+ICAKPiAgCXJhZGVvbl9jb25uZWN0b3IgPSByYWRlb25fbXN0X2ZpbmRfY29ubmVjdG9y KGVuY29kZXIpOwo+ICAJaWYgKCFyYWRlb25fY29ubmVjdG9yKSB7Cj4gLQkJRFJNX0RFQlVHX0tN UygiZmFpbGVkIHRvIGZpbmQgY29ubmVjdG9yICVwXG4iLCBlbmNvZGVyKTsKPiArCQlEUk1fREVC VUdfS01TKCJmYWlsZWQgdG8gZmluZCBjb25uZWN0b3IgJXB4XG4iLCBlbmNvZGVyKTsKPiAgCQly ZXR1cm47Cj4gIAl9Cj4gIAlyYWRlb25fZW5jb2RlciA9IHRvX3JhZGVvbl9lbmNvZGVyKGVuY29k ZXIpOwo+IEBAIC02MTUsNyArNjE1LDcgQEAgcmFkZW9uX2RwX2NyZWF0ZV9mYWtlX21zdF9lbmNv ZGVyKHN0cnVjdCByYWRlb25fY29ubmVjdG9yICpjb25uZWN0b3IpCj4gIAljb25zdCBzdHJ1Y3Qg ZHJtX2Nvbm5lY3Rvcl9oZWxwZXJfZnVuY3MgKmNvbm5lY3Rvcl9mdW5jcyA9IGNvbm5lY3Rvci0+ YmFzZS5oZWxwZXJfcHJpdmF0ZTsKPiAgCXN0cnVjdCBkcm1fZW5jb2RlciAqZW5jX21hc3RlciA9 IGNvbm5lY3Rvcl9mdW5jcy0+YmVzdF9lbmNvZGVyKCZjb25uZWN0b3ItPmJhc2UpOwo+ICAKPiAt CURSTV9ERUJVR19LTVMoImVuYyBtYXN0ZXIgaXMgJXBcbiIsIGVuY19tYXN0ZXIpOwo+ICsJRFJN X0RFQlVHX0tNUygiZW5jIG1hc3RlciBpcyAlcHhcbiIsIGVuY19tYXN0ZXIpOwo+ICAJcmFkZW9u X2VuY29kZXIgPSBremFsbG9jKHNpemVvZigqcmFkZW9uX2VuY29kZXIpLCBHRlBfS0VSTkVMKTsK PiAgCWlmICghcmFkZW9uX2VuY29kZXIpCj4gIAkJcmV0dXJuIE5VTEw7Cj4gZGlmZiAtLWdpdCBh L2RyaXZlcnMvZ3B1L2RybS9yYWRlb24vcmFkZW9uX29iamVjdC5jIGIvZHJpdmVycy9ncHUvZHJt L3JhZGVvbi9yYWRlb25fb2JqZWN0LmMKPiBpbmRleCBlZGJiNGNkNTE5ZmQuLjI0ZGViYjI3NjBj MyAxMDA2NDQKPiAtLS0gYS9kcml2ZXJzL2dwdS9kcm0vcmFkZW9uL3JhZGVvbl9vYmplY3QuYwo+ ICsrKyBiL2RyaXZlcnMvZ3B1L2RybS9yYWRlb24vcmFkZW9uX29iamVjdC5jCj4gQEAgLTYzOSw3 ICs2MzksNyBAQCBpbnQgcmFkZW9uX2JvX2dldF9zdXJmYWNlX3JlZyhzdHJ1Y3QgcmFkZW9uX2Jv ICpibykKPiAgCQlyZWcgPSAmcmRldi0+c3VyZmFjZV9yZWdzW3N0ZWFsXTsKPiAgCQlvbGRfb2Jq ZWN0ID0gcmVnLT5ibzsKPiAgCQkvKiBibG93IGF3YXkgdGhlIG1hcHBpbmcgKi8KPiAtCQlEUk1f REVCVUcoInN0ZWFsaW5nIHN1cmZhY2UgcmVnICVkIGZyb20gJXBcbiIsIHN0ZWFsLCBvbGRfb2Jq ZWN0KTsKPiArCQlEUk1fREVCVUcoInN0ZWFsaW5nIHN1cmZhY2UgcmVnICVkIGZyb20gJXB4XG4i LCBzdGVhbCwgb2xkX29iamVjdCk7Cj4gIAkJdHRtX2JvX3VubWFwX3ZpcnR1YWwoJm9sZF9vYmpl Y3QtPnRibyk7Cj4gIAkJb2xkX29iamVjdC0+c3VyZmFjZV9yZWcgPSAtMTsKPiAgCQlpID0gc3Rl YWw7Cj4gZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2RybS9yb2NrY2hpcC9yb2NrY2hpcF9kcm1f ZmJkZXYuYyBiL2RyaXZlcnMvZ3B1L2RybS9yb2NrY2hpcC9yb2NrY2hpcF9kcm1fZmJkZXYuYwo+ IGluZGV4IGU2NjUwNTUzZjVkNi4uZDkwYTM3MmE2NDEzIDEwMDY0NAo+IC0tLSBhL2RyaXZlcnMv Z3B1L2RybS9yb2NrY2hpcC9yb2NrY2hpcF9kcm1fZmJkZXYuYwo+ICsrKyBiL2RyaXZlcnMvZ3B1 L2RybS9yb2NrY2hpcC9yb2NrY2hpcF9kcm1fZmJkZXYuYwo+IEBAIC0xMDYsNyArMTA2LDcgQEAg c3RhdGljIGludCByb2NrY2hpcF9kcm1fZmJkZXZfY3JlYXRlKHN0cnVjdCBkcm1fZmJfaGVscGVy ICpoZWxwZXIsCj4gIAlmYmktPnNjcmVlbl9zaXplID0gcmtfb2JqLT5iYXNlLnNpemU7Cj4gIAlm YmktPmZpeC5zbWVtX2xlbiA9IHJrX29iai0+YmFzZS5zaXplOwo+ICAKPiAtCURSTV9ERUJVR19L TVMoIkZCIFslZHglZF0tJWQga3ZhZGRyPSVwIG9mZnNldD0lbGQgc2l6ZT0lenVcbiIsCj4gKwlE Uk1fREVCVUdfS01TKCJGQiBbJWR4JWRdLSVkIGt2YWRkcj0lcHggb2Zmc2V0PSVsZCBzaXplPSV6 dVxuIiwKPiAgCQkgICAgICBmYi0+d2lkdGgsIGZiLT5oZWlnaHQsIGZiLT5mb3JtYXQtPmRlcHRo LAo+ICAJCSAgICAgIHJrX29iai0+a3ZhZGRyLAo+ICAJCSAgICAgIG9mZnNldCwgc2l6ZSk7Cj4g ZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2RybS9zYXZhZ2Uvc2F2YWdlX2JjaS5jIGIvZHJpdmVy cy9ncHUvZHJtL3NhdmFnZS9zYXZhZ2VfYmNpLmMKPiBpbmRleCAyYTViODQ2NmQ4MDYuLjY4YWM4 NmI4M2QxZCAxMDA2NDQKPiAtLS0gYS9kcml2ZXJzL2dwdS9kcm0vc2F2YWdlL3NhdmFnZV9iY2ku Ywo+ICsrKyBiL2RyaXZlcnMvZ3B1L2RybS9zYXZhZ2Uvc2F2YWdlX2JjaS5jCj4gQEAgLTI2NSw3 ICsyNjUsNyBAQCBzdGF0aWMgc3RydWN0IGRybV9idWYgKnNhdmFnZV9mcmVlbGlzdF9nZXQoc3Ry dWN0IGRybV9kZXZpY2UgKiBkZXYpCj4gIAkJcmV0dXJuIHRhaWwtPmJ1ZjsKPiAgCX0KPiAgCj4g LQlEUk1fREVCVUcoInJldHVybmluZyBOVUxMLCB0YWlsLT5idWY9JXAhXG4iLCB0YWlsLT5idWYp Owo+ICsJRFJNX0RFQlVHKCJyZXR1cm5pbmcgTlVMTCwgdGFpbC0+YnVmPSVweCFcbiIsIHRhaWwt PmJ1Zik7Cj4gIAlyZXR1cm4gTlVMTDsKPiAgfQo+ICAKPiBkaWZmIC0tZ2l0IGEvZHJpdmVycy9n cHUvZHJtL3N0aS9zdGlfZ2RwLmMgYi9kcml2ZXJzL2dwdS9kcm0vc3RpL3N0aV9nZHAuYwo+IGlu ZGV4IDliMmM0NzA1MWI1MS4uMzg1ODQxYzQ2ODM4IDEwMDY0NAo+IC0tLSBhL2RyaXZlcnMvZ3B1 L2RybS9zdGkvc3RpX2dkcC5jCj4gKysrIGIvZHJpdmVycy9ncHUvZHJtL3N0aS9zdGlfZ2RwLmMK PiBAQCAtNTI5LDcgKzUyOSw3IEBAIHN0YXRpYyB2b2lkIHN0aV9nZHBfaW5pdChzdHJ1Y3Qgc3Rp X2dkcCAqZ2RwKQo+ICAJCWdkcC0+bm9kZV9saXN0W2ldLnRvcF9maWVsZCA9IGJhc2U7Cj4gIAkJ Z2RwLT5ub2RlX2xpc3RbaV0udG9wX2ZpZWxkX3BhZGRyID0gZG1hX2FkZHI7Cj4gIAo+IC0JCURS TV9ERUJVR19EUklWRVIoIm5vZGVbJWRdLnRvcF9maWVsZD0lcFxuIiwgaSwgYmFzZSk7Cj4gKwkJ RFJNX0RFQlVHX0RSSVZFUigibm9kZVslZF0udG9wX2ZpZWxkPSVweFxuIiwgaSwgYmFzZSk7Cj4g IAkJYmFzZSArPSBzaXplb2Yoc3RydWN0IHN0aV9nZHBfbm9kZSk7Cj4gIAkJZG1hX2FkZHIgKz0g c2l6ZW9mKHN0cnVjdCBzdGlfZ2RwX25vZGUpOwo+ICAKPiBAQCAtNTM5LDcgKzUzOSw3IEBAIHN0 YXRpYyB2b2lkIHN0aV9nZHBfaW5pdChzdHJ1Y3Qgc3RpX2dkcCAqZ2RwKQo+ICAJCX0KPiAgCQln ZHAtPm5vZGVfbGlzdFtpXS5idG1fZmllbGQgPSBiYXNlOwo+ICAJCWdkcC0+bm9kZV9saXN0W2ld LmJ0bV9maWVsZF9wYWRkciA9IGRtYV9hZGRyOwo+IC0JCURSTV9ERUJVR19EUklWRVIoIm5vZGVb JWRdLmJ0bV9maWVsZD0lcFxuIiwgaSwgYmFzZSk7Cj4gKwkJRFJNX0RFQlVHX0RSSVZFUigibm9k ZVslZF0uYnRtX2ZpZWxkPSVweFxuIiwgaSwgYmFzZSk7Cj4gIAkJYmFzZSArPSBzaXplb2Yoc3Ry dWN0IHN0aV9nZHBfbm9kZSk7Cj4gIAkJZG1hX2FkZHIgKz0gc2l6ZW9mKHN0cnVjdCBzdGlfZ2Rw X25vZGUpOwo+ICAJfQo+IGRpZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9kcm0vc3RpL3N0aV9taXhl ci5jIGIvZHJpdmVycy9ncHUvZHJtL3N0aS9zdGlfbWl4ZXIuYwo+IGluZGV4IGE0ZjQ1Yzc0ZDY3 OC4uNmVhNWY4MWRkOWRiIDEwMDY0NAo+IC0tLSBhL2RyaXZlcnMvZ3B1L2RybS9zdGkvc3RpX21p eGVyLmMKPiArKysgYi9kcml2ZXJzL2dwdS9kcm0vc3RpL3N0aV9taXhlci5jCj4gQEAgLTM2Nyw3 ICszNjcsNyBAQCBzdHJ1Y3Qgc3RpX21peGVyICpzdGlfbWl4ZXJfY3JlYXRlKHN0cnVjdCBkZXZp Y2UgKmRldiwKPiAgCW1peGVyLT5kZXYgPSBkZXY7Cj4gIAltaXhlci0+aWQgPSBpZDsKPiAgCj4g LQlEUk1fREVCVUdfRFJJVkVSKCIlcyBjcmVhdGVkLiBSZWdzPSVwXG4iLAo+ICsJRFJNX0RFQlVH X0RSSVZFUigiJXMgY3JlYXRlZC4gUmVncz0lcHhcbiIsCj4gIAkJCSBzdGlfbWl4ZXJfdG9fc3Ry KG1peGVyKSwgbWl4ZXItPnJlZ3MpOwo+ICAKPiAgCXJldHVybiBtaXhlcjsKPiBkaWZmIC0tZ2l0 IGEvZHJpdmVycy9ncHUvZHJtL3N1bjRpL3N1bjRpX2NydGMuYyBiL2RyaXZlcnMvZ3B1L2RybS9z dW40aS9zdW40aV9jcnRjLmMKPiBpbmRleCAyZDdjNTc0MDY3MTUuLjFkMTk5NDQwOTgwOSAxMDA2 NDQKPiAtLS0gYS9kcml2ZXJzL2dwdS9kcm0vc3VuNGkvc3VuNGlfY3J0Yy5jCj4gKysrIGIvZHJp dmVycy9ncHUvZHJtL3N1bjRpL3N1bjRpX2NydGMuYwo+IEBAIC0xNTksNyArMTU5LDcgQEAgc3Rh dGljIGludCBzdW40aV9jcnRjX2VuYWJsZV92Ymxhbmsoc3RydWN0IGRybV9jcnRjICpjcnRjKQo+ ICB7Cj4gIAlzdHJ1Y3Qgc3VuNGlfY3J0YyAqc2NydGMgPSBkcm1fY3J0Y190b19zdW40aV9jcnRj KGNydGMpOwo+ICAKPiAtCURSTV9ERUJVR19EUklWRVIoIkVuYWJsaW5nIFZCTEFOSyBvbiBjcnRj ICVwXG4iLCBjcnRjKTsKPiArCURSTV9ERUJVR19EUklWRVIoIkVuYWJsaW5nIFZCTEFOSyBvbiBj cnRjICVweFxuIiwgY3J0Yyk7Cj4gIAo+ICAJc3VuNGlfdGNvbl9lbmFibGVfdmJsYW5rKHNjcnRj LT50Y29uLCB0cnVlKTsKPiAgCj4gQEAgLTE3MCw3ICsxNzAsNyBAQCBzdGF0aWMgdm9pZCBzdW40 aV9jcnRjX2Rpc2FibGVfdmJsYW5rKHN0cnVjdCBkcm1fY3J0YyAqY3J0YykKPiAgewo+ICAJc3Ry dWN0IHN1bjRpX2NydGMgKnNjcnRjID0gZHJtX2NydGNfdG9fc3VuNGlfY3J0YyhjcnRjKTsKPiAg Cj4gLQlEUk1fREVCVUdfRFJJVkVSKCJEaXNhYmxpbmcgVkJMQU5LIG9uIGNydGMgJXBcbiIsIGNy dGMpOwo+ICsJRFJNX0RFQlVHX0RSSVZFUigiRGlzYWJsaW5nIFZCTEFOSyBvbiBjcnRjICVweFxu IiwgY3J0Yyk7Cj4gIAo+ICAJc3VuNGlfdGNvbl9lbmFibGVfdmJsYW5rKHNjcnRjLT50Y29uLCBm YWxzZSk7Cj4gIH0KPiBkaWZmIC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJtL3R0bS90dG1fcGFnZV9h bGxvYy5jIGIvZHJpdmVycy9ncHUvZHJtL3R0bS90dG1fcGFnZV9hbGxvYy5jCj4gaW5kZXggZjA0 ODFiN2I2MGM1Li4zMmIzYzFiNDIxMTUgMTAwNjQ0Cj4gLS0tIGEvZHJpdmVycy9ncHUvZHJtL3R0 bS90dG1fcGFnZV9hbGxvYy5jCj4gKysrIGIvZHJpdmVycy9ncHUvZHJtL3R0bS90dG1fcGFnZV9h bGxvYy5jCj4gQEAgLTY1OCw3ICs2NTgsNyBAQCBzdGF0aWMgdm9pZCB0dG1fcGFnZV9wb29sX2Zp bGxfbG9ja2VkKHN0cnVjdCB0dG1fcGFnZV9wb29sICpwb29sLCBpbnQgdHRtX2ZsYWdzLAo+ICAJ CQkrK3Bvb2wtPm5yZWZpbGxzOwo+ICAJCQlwb29sLT5ucGFnZXMgKz0gYWxsb2Nfc2l6ZTsKPiAg CQl9IGVsc2Ugewo+IC0JCQlwcl9kZWJ1ZygiRmFpbGVkIHRvIGZpbGwgcG9vbCAoJXApXG4iLCBw b29sKTsKPiArCQkJcHJfZGVidWcoIkZhaWxlZCB0byBmaWxsIHBvb2wgKCVweClcbiIsIHBvb2wp Owo+ICAJCQkvKiBJZiB3ZSBoYXZlIGFueSBwYWdlcyBsZWZ0IHB1dCB0aGVtIHRvIHRoZSBwb29s LiAqLwo+ICAJCQlsaXN0X2Zvcl9lYWNoX2VudHJ5KHAsICZuZXdfcGFnZXMsIGxydSkgewo+ICAJ CQkJKytjcGFnZXM7Cj4gZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2RybS91ZGwvdWRsX2ZiLmMg Yi9kcml2ZXJzL2dwdS9kcm0vdWRsL3VkbF9mYi5jCj4gaW5kZXggMmViZGM2ZDVhNzZlLi43MDMy MjA2YzEwM2YgMTAwNjQ0Cj4gLS0tIGEvZHJpdmVycy9ncHUvZHJtL3VkbC91ZGxfZmIuYwo+ICsr KyBiL2RyaXZlcnMvZ3B1L2RybS91ZGwvdWRsX2ZiLmMKPiBAQCAtNDA2LDcgKzQwNiw3IEBAIHN0 YXRpYyBpbnQgdWRsZmJfY3JlYXRlKHN0cnVjdCBkcm1fZmJfaGVscGVyICpoZWxwZXIsCj4gIAlk cm1fZmJfaGVscGVyX2ZpbGxfZml4KGluZm8sIGZiLT5waXRjaGVzWzBdLCBmYi0+Zm9ybWF0LT5k ZXB0aCk7Cj4gIAlkcm1fZmJfaGVscGVyX2ZpbGxfdmFyKGluZm8sICZ1ZmJkZXYtPmhlbHBlciwg c2l6ZXMtPmZiX3dpZHRoLCBzaXplcy0+ZmJfaGVpZ2h0KTsKPiAgCj4gLQlEUk1fREVCVUdfS01T KCJhbGxvY2F0ZWQgJWR4JWQgdm1hbCAlcFxuIiwKPiArCURSTV9ERUJVR19LTVMoImFsbG9jYXRl ZCAlZHglZCB2bWFsICVweFxuIiwKPiAgCQkgICAgICBmYi0+d2lkdGgsIGZiLT5oZWlnaHQsCj4g IAkJICAgICAgdWZiZGV2LT51ZmIub2JqLT52bWFwcGluZyk7Cj4gIAo+IGRpZmYgLS1naXQgYS9k cml2ZXJzL2dwdS9kcm0vdmlhL3ZpYV9kbWEuYyBiL2RyaXZlcnMvZ3B1L2RybS92aWEvdmlhX2Rt YS5jCj4gaW5kZXggZDE3ZDhmMjQ1YzFhLi41ZDVlMzIyYjdjNDggMTAwNjQ0Cj4gLS0tIGEvZHJp dmVycy9ncHUvZHJtL3ZpYS92aWFfZG1hLmMKPiArKysgYi9kcml2ZXJzL2dwdS9kcm0vdmlhL3Zp YV9kbWEuYwo+IEBAIC0zMzIsNyArMzMyLDcgQEAgc3RhdGljIGludCB2aWFfY21kYnVmZmVyKHN0 cnVjdCBkcm1fZGV2aWNlICpkZXYsIHZvaWQgKmRhdGEsIHN0cnVjdCBkcm1fZmlsZSAqZmkKPiAg Cj4gIAlMT0NLX1RFU1RfV0lUSF9SRVRVUk4oZGV2LCBmaWxlX3ByaXYpOwo+ICAKPiAtCURSTV9E RUJVRygiYnVmICVwIHNpemUgJWx1XG4iLCBjbWRidWYtPmJ1ZiwgY21kYnVmLT5zaXplKTsKPiAr CURSTV9ERUJVRygiYnVmICVweCBzaXplICVsdVxuIiwgY21kYnVmLT5idWYsIGNtZGJ1Zi0+c2l6 ZSk7Cj4gIAo+ICAJcmV0ID0gdmlhX2Rpc3BhdGNoX2NtZGJ1ZmZlcihkZXYsIGNtZGJ1Zik7Cj4g IAlyZXR1cm4gcmV0Owo+IEBAIC0zNjgsNyArMzY4LDcgQEAgc3RhdGljIGludCB2aWFfcGNpX2Nt ZGJ1ZmZlcihzdHJ1Y3QgZHJtX2RldmljZSAqZGV2LCB2b2lkICpkYXRhLCBzdHJ1Y3QgZHJtX2Zp bGUKPiAgCj4gIAlMT0NLX1RFU1RfV0lUSF9SRVRVUk4oZGV2LCBmaWxlX3ByaXYpOwo+ICAKPiAt CURSTV9ERUJVRygiYnVmICVwIHNpemUgJWx1XG4iLCBjbWRidWYtPmJ1ZiwgY21kYnVmLT5zaXpl KTsKPiArCURSTV9ERUJVRygiYnVmICVweCBzaXplICVsdVxuIiwgY21kYnVmLT5idWYsIGNtZGJ1 Zi0+c2l6ZSk7Cj4gIAo+ICAJcmV0ID0gdmlhX2Rpc3BhdGNoX3BjaV9jbWRidWZmZXIoZGV2LCBj bWRidWYpOwo+ICAJcmV0dXJuIHJldDsKPiBkaWZmIC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJtL3Zp YS92aWFfaXJxLmMgYi9kcml2ZXJzL2dwdS9kcm0vdmlhL3ZpYV9pcnEuYwo+IGluZGV4IGM5Njgz MGNjYzBlYy4uMWMzNmViZmUyYzQ1IDEwMDY0NAo+IC0tLSBhL2RyaXZlcnMvZ3B1L2RybS92aWEv dmlhX2lycS5jCj4gKysrIGIvZHJpdmVycy9ncHUvZHJtL3ZpYS92aWFfaXJxLmMKPiBAQCAtMjU5 LDcgKzI1OSw3IEBAIHZvaWQgdmlhX2RyaXZlcl9pcnFfcHJlaW5zdGFsbChzdHJ1Y3QgZHJtX2Rl dmljZSAqZGV2KQo+ICAJZHJtX3ZpYV9pcnFfdCAqY3VyX2lycTsKPiAgCWludCBpOwo+ICAKPiAt CURSTV9ERUJVRygiZGV2X3ByaXY6ICVwXG4iLCBkZXZfcHJpdik7Cj4gKwlEUk1fREVCVUcoImRl dl9wcml2OiAlcHhcbiIsIGRldl9wcml2KTsKPiAgCWlmIChkZXZfcHJpdikgewo+ICAJCWN1cl9p cnEgPSBkZXZfcHJpdi0+dmlhX2lycXM7Cj4gIAo+IGRpZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9k cm0vdm13Z2Z4L3Ztd2dmeF9vdmVybGF5LmMgYi9kcml2ZXJzL2dwdS9kcm0vdm13Z2Z4L3Ztd2dm eF9vdmVybGF5LmMKPiBpbmRleCAyMjJjOWMyMTIzYTEuLmVkZmU3NTBiMzAwYiAxMDA2NDQKPiAt LS0gYS9kcml2ZXJzL2dwdS9kcm0vdm13Z2Z4L3Ztd2dmeF9vdmVybGF5LmMKPiArKysgYi9kcml2 ZXJzL2dwdS9kcm0vdm13Z2Z4L3Ztd2dmeF9vdmVybGF5LmMKPiBAQCAtMzA4LDcgKzMwOCw3IEBA IHN0YXRpYyBpbnQgdm13X292ZXJsYXlfdXBkYXRlX3N0cmVhbShzdHJ1Y3Qgdm13X3ByaXZhdGUg KmRldl9wcml2LAo+ICAJaWYgKCFidWYpCj4gIAkJcmV0dXJuIC1FSU5WQUw7Cj4gIAo+IC0JRFJN X0RFQlVHKCIgICAlczogb2xkICVwLCBuZXcgJXAsICVzcGF1c2VkXG4iLCBfX2Z1bmNfXywKPiAr CURSTV9ERUJVRygiICAgJXM6IG9sZCAlcHgsIG5ldyAlcHgsICVzcGF1c2VkXG4iLCBfX2Z1bmNf XywKPiAgCQkgIHN0cmVhbS0+YnVmLCBidWYsIHN0cmVhbS0+cGF1c2VkID8gIiIgOiAibm90ICIp Owo+ICAKPiAgCWlmIChzdHJlYW0tPmJ1ZiAhPSBidWYpIHsKCl9fX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fCkludGVsLWdmeCBtYWlsaW5nIGxpc3QKSW50ZWwt Z2Z4QGxpc3RzLmZyZWVkZXNrdG9wLm9yZwpodHRwczovL2xpc3RzLmZyZWVkZXNrdG9wLm9yZy9t YWlsbWFuL2xpc3RpbmZvL2ludGVsLWdmeAo= From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: X-Google-Smtp-Source: AIpwx4/aauyQNwMCo1OVE6DKTGBPrVKaV7eMo0L6NkQ7UGS6rDJC38uyPoiwJ2MpL6UZ94Dl/oYn ARC-Seal: i=1; a=rsa-sha256; t=1524066835; cv=none; d=google.com; s=arc-20160816; b=aNv5fciXJjF9R6ZKLUbGR5SapH3irO4XSNhLQ0lyXLgAlf1CIlBGc8zsZ6sLvoNI06 dMCM/iIsZW7tc66bwT6Ag6vMttBMRSOph9Fa/1AHZiOsTzOzqUVtfcWQHbb5GfICXxY4 ugoHvS69yhrgp/S72tVPIIQOf24vpvn7m+cI1zE0tqJey23Jb1sww7mh6zwi9DJljk4e c3yQ0l4D3LRBVNU/2LBTU3YGhWxkVEsb5kry/emHI7qmiymTA6hmzwm/1fePF69SC/lj Njh4pmzwLdUnZq6YpmHKaMAQkrKcZZLHJbjVC3qM+i5ccJ1/neqOsA30JP1EckZD8sDJ IzZQ== ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=arc-20160816; h=spamdiagnosticmetadata:spamdiagnosticoutput:content-language :content-transfer-encoding:in-reply-to:mime-version:user-agent:date :message-id:organization:from:references:cc:to:subject :dkim-signature:arc-authentication-results; bh=o5J3pHEcKUA5RoxQAX/vrc9A8vr2ubtc0CrDTA/g1yQ=; b=fZ4bWqdrjZ4EztsQsGwQm2pNIShbDvXJtbZED4RFbKGVxwI6c5uBy6z1b61ojA435y ntdskL36xFajsARr0hhTyZ4OVzFoJVGaP/0Nao+9kTMUz0EvoXx+mE/sTLFqOw63ua4H gDOkG18cz/Pd3viLp0B+OIM9ylNZJQkd2yXoERXtckuvbjsuzYnGqW0QYo4Ls0sU/Tyi azwUwX9soSoEJXoCxeEvWBA5aDIMLd0zQmJfoEsau5QLaIvZHxvV8MvIkNOoT4Mr8scc 85ofG3lfrtvfJUDHADT0/hdSC8f5c6MfSyGNiEcpKOrukmPtOU3Ecn4Aab8pfPR1bneA JxYg== ARC-Authentication-Results: i=1; mx.google.com; dkim=pass header.i=@amdcloud.onmicrosoft.com header.s=selector1-amd-com header.b=o8DmdYFY; spf=neutral (google.com: 104.47.34.89 is neither permitted nor denied by best guess record for domain of felix.kuehling@amd.com) smtp.mailfrom=Felix.Kuehling@amd.com Authentication-Results: mx.google.com; dkim=pass header.i=@amdcloud.onmicrosoft.com header.s=selector1-amd-com header.b=o8DmdYFY; spf=neutral (google.com: 104.47.34.89 is neither permitted nor denied by best guess record for domain of felix.kuehling@amd.com) smtp.mailfrom=Felix.Kuehling@amd.com Authentication-Results: tobin.cc; dkim=none (message not signed) header.d=none;tobin.cc; dmarc=none action=none header.from=amd.com; Subject: Re: [PATCH] drm: Print unadorned pointers To: Alexey Brodkin , dri-devel@lists.freedesktop.org Cc: amd-gfx@lists.freedesktop.org, =?UTF-8?Q?Heiko_St=c3=bcbner?= , Tom Lendacky , David Airlie , Gustavo Padovan , Russell King , Cihangir Akturk , Gerd Hoffmann , Benjamin Gaignard , Ingo Molnar , linux-kernel@vger.kernel.org, "David (ChunMing) Zhou" , Thomas Hellstrom , Sinclair Yeh , Vincent Abriou , "Jerry (Fangzhi) Zuo" , Krzysztof Kozlowski , Maxime Ripard , Chen-Yu Tsai , Sandy Huang , Roger He , Daniel Vetter , CK Hu , Dave Airlie , Borislav Petkov , Harry Wentland , Andrey Grodzovsky , Joonas Lahtinen , Arnd Bergmann , "Leo (Sunpeng) Li" , linux-arm-msm@vger.kernel.org, intel-gfx@lists.freedesktop.org, Maarten Lankhorst , etnaviv@lists.freedesktop.org, Jani Nikula , linux-rockchip@lists.infradead.org, Christian Gmeiner , Sean Paul , Rodrigo Vivi , Matthias Brugger , virtualization@lists.linux-foundation.org, Tony Cheng , linux-arm-kernel@lists.infradead.org, Oded Gabbay , VMware Graphics , Greg Kroah-Hartman , =?UTF-8?Q?Michel_D=c3=a4nzer?= , Roman Li , Samuel Li , Shirish S , Rob Clark , Philipp Zabel , Alex Deucher , linux-mediatek@lists.infradead.org, Lucas Stach , freedreno@lists.freedesktop.org, =?UTF-8?Q?Christian_K=c3=b6nig?= , "Tobin C . Harding" References: <20180418092450.13798-1-abrodkin@synopsys.com> From: Felix Kuehling Organization: AMD Inc. Message-ID: <85049bd0-2220-e718-090a-fa199184668a@amd.com> Date: Wed, 18 Apr 2018 11:53:31 -0400 User-Agent: Mozilla/5.0 (X11; Linux x86_64; rv:52.0) Gecko/20100101 Thunderbird/52.7.0 MIME-Version: 1.0 In-Reply-To: <20180418092450.13798-1-abrodkin@synopsys.com> Content-Type: text/plain; charset=utf-8 Content-Transfer-Encoding: 8bit Content-Language: en-CA X-Originating-IP: [165.204.55.251] X-ClientProxiedBy: YQXPR0101CA0015.CANPRD01.PROD.OUTLOOK.COM (2603:10b6:c00:15::28) To MWHPR12MB1711.namprd12.prod.outlook.com (2603:10b6:300:111::22) X-MS-PublicTrafficType: Email X-MS-Office365-Filtering-HT: Tenant X-Microsoft-Antispam: UriScan:;BCL:0;PCL:0;RULEID:(7020095)(4652020)(5600026)(4534165)(4627221)(201703031133081)(201702281549075)(48565401081)(2017052603328)(7153060)(7193020);SRVR:MWHPR12MB1711; X-Microsoft-Exchange-Diagnostics: 1;MWHPR12MB1711;3:W9m+7l/kgG4UfSyfGAsn0EE9QTpxb7t9BgUE0h4672MaApMcLrVOxp69SfdiFAsRm8nyEL+tO5kWwMbRhT9hn8KXP54w97uOpA/wL4eK5Y6jD8cayb2KdZ6yxDhzEu19bPlH1FiQPJFb5L3JTNP5yjyYzCn2qzV+pjXcPAkaWh5l71oypg/sc6ZLTyX25Ck0Y4yPejCophxwHU5Y7n0ECg4iC9Wd0K/Q1h9vMjXOvCgpSow8JXdz6etDX7VVsT63;25:4xTLhY18O879rn7vWU2YuAuZnK3qBJgbEK1Attl1cVJZeQg8Pt4/aUktLXm3ugZrJYthyj6NRUzjXErh+fMi040f9c2fmBFjjhXZExeDPxApJZULQsYyXDqfZv+Pd5EeOFsKvxyWwkkCbd3ONiSlCRw5jMsyboxg8kEFkAUE4tzvi5VroPQqTWPHxQP+XtB8Zvy+Ev+xTnAdPTUxPLuF3BDDszgfJHTny+rNgUH/0qXXhzBlYKyDgh2NOoLw7rNhT+/7FiAyFdPcy81X8S/YWRNJfhw4RvBKmSYay7euXrLHQxkhf2a+06Wq05yWqjfH3GOQVz2BP1etgAXz0hpM1A==;31:7nRHupnYwyEHpmPU9Tkn7LwadnWz61teBZf4lgTJo7LkdyrDKtUIg952qc8r3yIxn1RINLXctUXj4oabzEm6Dzj+xaS5FQ0FIPFNVMiIDieeSt0zKSsSkqnNceZkamAEt0R/vhX9Wr0cdhjyw9TpLl+TtVljIxyMJ3Q97h7KpV2kQFA3EPFRczyGzUwPX2TdoZEXQ/6QQ8YuaGOIYDfCMInVT2JISObS2q600lCn0Js= X-MS-TrafficTypeDiagnostic: MWHPR12MB1711: X-LD-Processed: 3dd8961f-e488-4e60-8e11-a82d994e183d,ExtAddr X-Microsoft-Exchange-Diagnostics: 1;MWHPR12MB1711;20:bwkBYoOeIV54jShwQm4TLS4XIHv6XRJGTUQoNr9y/Fa2Ib1VgSOHdtCWQl0o+dsIqFOJdkeXl30DsAS5vOtZ7eVbzEY6sP1t/oszblDnjbaGdIe7E1Xm5UMu8PdQsSeLxZl9XtS+SJ1N6AGRUvaBF9ds0jcVXHqdJ/vpGknZwhYtzuVgCBWILoeRyUS1HVSzC/oVuufChIZdyBQWUcCP7zyyKWWcBn6n0r3JJ03YCm4PlPCmzOR0AGDVULrN61ZqmQVizKIcG0L1oO0mmHZNttnxbxeCuktsLzeeETYyItUH3E6CZ3M2KUYUwFRD+6rYqZEVNAmN5iKZl1d0XBoI/LyPUBYSRt1K/JDHewyY4L1j9WN5UtvWutfE09Mq3OLrv/RdKvxq68OrR/x0ggZxf1WgcxxQeGKVWg0U6W/osQsWp9K0RMMYWadBiImX6LAyYjolyRziKz/N0toWlzyrOTlAyOBkfwr5qAzPnDagHfDwlbqH5arsnQu2Wpp2+Lvp X-Microsoft-Antispam-PRVS: X-Exchange-Antispam-Report-Test: UriScan:(61668805478150)(9452136761055)(85827821059158)(767451399110)(258649278758335)(217544274631240)(228905959029699); X-Exchange-Antispam-Report-CFA-Test: BCL:0;PCL:0;RULEID:(8211001083)(6040522)(2401047)(8121501046)(5005006)(93006095)(93001095)(3002001)(3231232)(944501327)(52105095)(10201501046)(6055026)(6041310)(201703131423095)(201702281528075)(20161123555045)(201703061421075)(201703061406153)(20161123564045)(20161123560045)(20161123558120)(20161123562045)(6072148)(201708071742011);SRVR:MWHPR12MB1711;BCL:0;PCL:0;RULEID:;SRVR:MWHPR12MB1711; X-Microsoft-Exchange-Diagnostics: 1;MWHPR12MB1711;4:5DjbU4oA3oHzAREt0E+Uw8YVmiRpSSSs2JCZeePxEojf4u7HVtEfAbfHSl7nygSwOAYohUB8/5J1eVABX7N/Jkh54fhRmTROQcRk1akLdEbM3lLRsVGYMZRbqzxRrt+65kbGeeJ8j8tmili+gV8nxuJd/32zNo3Yc1qMxO0UaSspTNZRvRItBW8jAMoAP8temlyCHPN24MLTthYZVobYwbJQbJul/JUqyLfmR/VgqlLRoIrlEsMmXJVikVdt6fg8X9JeM/VN+dDYezN1iF6YOa7P8Nj4xafugDoxPnYbTqX94J4+sdzqWBUsXUWcclnNmFbe/2azEci9UPE98CLGW3JMKSexM4kTb5zF9zU34lztDny8MIbtLUHq8l2J18Uw/4rMSedNc5QsMbEx1wvkla3if5katEn7KzMmMDCQJ7vcV/VScvYe9joJ8AIEbcFnXxAWVMhImY9fB0iHb/fNPjdVcC2NnUly5uyWYzzSlRUwDryniWBM/z0IdgBF+Gdzhnm8JUpVkjxNpRXVdX1cNQ== X-Forefront-PRVS: 06469BCC91 X-Forefront-Antispam-Report: SFV:NSPM;SFS:(10009020)(979002)(6049001)(376002)(346002)(39860400002)(396003)(366004)(39380400002)(377424004)(54906003)(36756003)(25786009)(478600001)(4326008)(44832011)(72206003)(106356001)(58126008)(446003)(53546011)(2616005)(956004)(11346002)(476003)(59450400001)(386003)(68736007)(2906002)(186003)(575784001)(16526019)(86362001)(76176011)(2486003)(16576012)(316002)(23676004)(52116002)(36916002)(31696002)(52146003)(2870700001)(39060400002)(53936002)(65826007)(8676002)(50466002)(6486002)(31686004)(305945005)(229853002)(53946003)(66066001)(65806001)(47776003)(7736002)(6246003)(65956001)(8936002)(77096007)(7416002)(7406005)(3846002)(6116002)(5660300001)(81166006)(26005)(6666003)(64126003)(559001)(579004)(969003)(989001)(999001)(1009001)(1019001);DIR:OUT;SFP:1101;SCL:1;SRVR:MWHPR12MB1711;H:[172.27.225.16];FPR:;SPF:None;LANG:en;MLV:ovr;PTR:InfoNoRecords; X-Microsoft-Exchange-Diagnostics: =?utf-8?B?MTtNV0hQUjEyTUIxNzExOzIzOjJMU1c4WS9TTjMyUWtZQlFvdnd1YnhXVW5L?= =?utf-8?B?RmpwQ3RSblhhdlh5KzJCUks3aUxiWGdCOFN4Wmk4UVptbXBKTW9JeWpTQmJm?= =?utf-8?B?dDZLSmxBNDFONU91eHN5WnRHMWlodkdIeEZkUEQrelk3TkFOTGt5MnVtRmwr?= =?utf-8?B?cE11OVZKOE5ESzhmeTV0UlJSUVlubzZjS3cvQWk3aTJxMXlNVFV1UkU2dFQx?= =?utf-8?B?ZHVTN3FJMllMcTI0M1QwTVBKVUg5aVE0UE1pZkdhQXVHQmxOY3ppcit6RXBP?= =?utf-8?B?RDlSa2VyemZIYnFvYVlwNlQzcTlvK3BXNGZCQW1YWTlkbVp2Tk5lMXNUTDF3?= =?utf-8?B?alRmVWZ2ZlovRGJ4aW84Z1VhK0wzMDQyYzliZHI0TythbzViUGZYN0EyYmFS?= =?utf-8?B?OHp1ckt4Zmt4MUNLRXpxdUJRYWRvcC9rKytObVYrc2dsQTFFcDd0eGVGalFw?= =?utf-8?B?ajBGTWJJTDk3dXJVUXZzV2NqK2x2TjZRVDJ3ZFhKRDB4bkQzS2E5cWd6VWhD?= =?utf-8?B?Y1BvZWloaVFuelExa29JTFg1UTlDUk5raHAzZHZBRTFDcmdhdHQyOFFDZjdt?= =?utf-8?B?REJEZUR3Nm4yT2xqNUw1NmllYUVLeXN4VEJMUHVYbHIrMzZUYi9xSGcrV096?= =?utf-8?B?U1BGRXkwak9rMEp4cTkzeFRzQTl5ZWZzQktnbHZTV0EzdFJNckFQWEJVa3Zm?= =?utf-8?B?YzZCNnVOd05NVUYrV0t5RlNSbXR2SDkzRHppSmlWOFA4c2E4aDl3Rkdpcm9O?= =?utf-8?B?Sk9maTIxQTlsTjFmVWw3YUVYZ0ppbUE5NEhpNTVLcTlCdFVEa2dQZ1RVVWVx?= =?utf-8?B?L3FYYmVmM2MyNEt1ekorZlUyL0FyY283d3AyWDZycTZ0cDNLMUdPTEQyZUE0?= =?utf-8?B?MllDaHBKU0FTZFBGL0pwbXkyYmZRSnYyVUpoTE9lU01EZGNteWlUSURTWWdj?= =?utf-8?B?SHFMbDFjRnptcDEvdlU5N1UzWldGY2pWMlV1VWZ3YXdZZWNkK1N3WkNIenJl?= =?utf-8?B?cEdhWkZkbFkwYUx1eTlkVGxQajRiVG56bWlTKzU0eW9KSDE0UmRvMXdrWmho?= =?utf-8?B?RFRYd0pZMUpOZmdUU3JoTnRQaWoyMXhsaiszRlpPYVgyOStOQjB5SFJWWC9I?= =?utf-8?B?WjNaUjNubVhMVVZwTEZQb3NYanNQeC9aYVpNZlowMGllQ2tycXExMjl2bmpQ?= =?utf-8?B?NzVyM00zOFM0VjE0Q29jdmJiYXErVWw0WTkxdWgrN2RvdmRLQk9RV3Ivb2lt?= =?utf-8?B?cW41TmNFL0hDNjI0Y0kyV3Y0TUU1MEZYa0VaM3o0TDlzWlVGQktvbk8ya29I?= =?utf-8?B?aUppaGVIUU10UHcrQ3NVYmxrUGFQSjdqbEh1bE41eWhWbTlaYkYrcjladHZa?= =?utf-8?B?WGROZTZEUWlwMTdBWGlYcm5KUWxsTDRBQUpmR0tSdjczOWxNVjN3UkZ4RHdu?= =?utf-8?B?ZU5IK1ZHSUxnYkNCZmZyNkYzVTlTNFBtZExTMXRUSjBYY1dROU82NWxCaDFt?= =?utf-8?B?cmU4QzV6M2JMUmh3WjU1bFQwUHJibFR3cDFMUkplSnhDeTVjT1lPOUxtcjN6?= =?utf-8?B?R0VtNUZ1a1M1RGQ0ZEw0RllhUWN6YmZCYWp3QjMwR3ZNSlQ4MEVSVGNtZ1JQ?= =?utf-8?B?MFkzeWpqdGFzbXE0SGM4djBtUERFcGgvTGF1YVlWN0w4Tzd2MnN1L1ZZUDk4?= =?utf-8?B?SjZ2U04xVEpLT041bmFvT2RkM3RCeXpJbVZVNXh6UjJ3QnIrVjlTT2JpMnhE?= =?utf-8?B?eGNGRkh6L3BUei90MGJ6bWE3WHVwelZteVdObjJLUFZGNkdLZVZlRWNtVUl1?= =?utf-8?B?bnhVK1dqYWtoKy9uTzRkZWxyNkwzRWZ1SDRhVklQa1hRaHIyQVhkcDJ0WFVx?= =?utf-8?B?S2g5ZUxVQVFSblNYS2hIOVlWZVRaS2Vod2lzbkNzU3ZGZU5PNm83UndWSVNU?= =?utf-8?B?WTdReXdHTjgyZU5RU041dVpvV0NGdEhVQ3lqbi9FZGZ1akZFOU1ZZzlYWHhZ?= =?utf-8?B?dE13QVloc0YrNGx5dHNrbjhPOUFWTHgrTmdBWWJZVnR0NW9CWXdlUVVPTzdv?= =?utf-8?B?SWgvVGxmNy9OSUdjaU40b1dSYkt1RlZhT1ptMjAvZDNYVlZ2eTBNYld5Ullw?= =?utf-8?B?ek5Wc0hJbDNWNzlIRWlCRFJSRVN2NXlYcDk1Lzh3VmpIZU51SlRnNXlMWTcr?= =?utf-8?B?VUtGNEpOTjViVW5QekpvcWlZMko5aWRVbUhRNUFLcVBET0NSVUVHNHlxQWxq?= =?utf-8?Q?XWJKYzjkQK4boc1+Zf?= X-Microsoft-Antispam-Message-Info: 2QOYMpfINZEhJQwWME1ZzIKnAsW09J88iCXxblpfECKeEsiMbr9mVU477XcQlYTkVvPOphAMlM9z2aOYH/7SSB1tH7j4LLPKWOlCkmqU9zx68XV9yGxxTHLcaMe6KHTznkF/3/JsbV9wx5I+MKm8h10ePmUjB7UqdLQUDMd7xR0aTtwIrkl84VQy3FIOs0XP X-Microsoft-Exchange-Diagnostics: 1;MWHPR12MB1711;6:EFWZRjZRU7UMEbFJS2zc49mDmU1Hf/uoFqpEA7iXCaUGyVl8f9vu67hBp+3HzdIEqZ8u3lFRH6JVUmO8P3ftzHZcwu3pxd+fIpekzaRiiQm4+Ir8n4xXatqEYJxORBjQNg2Bh6TbJ6i4a+6jivPGzIn8P+jdqRgLq9rTHuFE+ZjVok3CstRM9zWh9CBOh+srVeFDRjKVd56rGFR/tPpp/3eYUWDVG/rQeR+VQH7JjjLcOyasPnsL3KwrclMIOYNOYSMSwS6dxeEfm340PsGuKDiLDkZkVZOFZmSSiMYb12hvfratM/1SidN7qIvf5LXhc2zDw1Jj+VqRj7khSUmrng3BY55gF8XPXCmAIM6V96CjDYlDcbQh1mjlyP+hOUvFTvlkoN85+ruRkBw62vTmfOXs76RNsOsza4lxlJtMCYX3LZcmjqn88UokYDaUlrWftUQAjIqGs96AMWXbI6xdug==;5:mKBj40FMU6imTfV8/neDyhctpgS7ba8A/BLf1nAfXpRn2w+9n85W68MvNu7OfBInmJZhn/v8Nwd8cRlQsV0c0ds1+5RDvcTv0j8IZZip01tLoFlO1djts6Xkz06siMVlJMOzAZoVs4dBQSusEGM3m2CWCNLjwBXpci5DpvXLWsU=;24:aAGmq4izAICrrGNsz+NYsEKu9m5HpqnqmECrr8kszriv6vUr6q5sPVV1ZLMfqsK2JFlFvTiAiF0YUE0VtljwzwKxEXhJHrFFreU0XpQdEUs= SpamDiagnosticOutput: 1:99 SpamDiagnosticMetadata: NSPM X-Microsoft-Exchange-Diagnostics: 1;MWHPR12MB1711;7:gPK/WxQ8pC5F3hs57E2yT4MUujLkAMRH65CjiISoGeuv/b+mev7jK7o+J4OCAjIoURIQNvBZfg6rIy47LLPUXLBhlxJMMDLh+rrQWrcUaXSW18nWNSWnXJjXbpP+OFNv/P8FtQD2qi4Cobu4K5JxNzahLL034PC3J1HT+YIOV3cABMPHugw5X4r+BQ3FV2J14ZrgACth47yewHb45S0qCTB8tQiinE8+3voVMX5xvqi12btVelkEDWRBNGlbvMTP;20:qpLGGhyislBk4nv1VWtvZt9yuKU1Qw65subE1ouYij5Wm/upeGVocw6Ehi66ghfTwWco4IEXubd/2CzxbuHiuuKSmWdkml3WYiBsaY22vkGd6hpwEpugkqNCUC6RwatEdXAD5LvPcPU2Gwtdm3NUkn2MLalV8F9/1dSthpNkwcegeKrolhJ+8o6DrxPUGUmzinsPeqafsFNaGR08Vfr+NY0CsqWnmM2GTKAIFBMVYIaHcyIik3SlcwIhniDWqz9D X-MS-Office365-Filtering-Correlation-Id: b5fdd266-1702-4667-9b9b-08d5a54491db X-OriginatorOrg: amd.com X-MS-Exchange-CrossTenant-OriginalArrivalTime: 18 Apr 2018 15:53:37.9209 (UTC) X-MS-Exchange-CrossTenant-Network-Message-Id: b5fdd266-1702-4667-9b9b-08d5a54491db X-MS-Exchange-CrossTenant-FromEntityHeader: Hosted X-MS-Exchange-CrossTenant-Id: 3dd8961f-e488-4e60-8e11-a82d994e183d X-MS-Exchange-Transport-CrossTenantHeadersStamped: MWHPR12MB1711 X-getmail-retrieved-from-mailbox: INBOX X-GMAIL-THRID: =?utf-8?q?1598075464656416084?= X-GMAIL-MSGID: =?utf-8?q?1598099906513624205?= X-Mailing-List: linux-kernel@vger.kernel.org List-ID: On 2018-04-18 05:24 AM, Alexey Brodkin wrote: > After commit ad67b74 ("printk: hash addresses printed with %p") > pointers are being hashed when printed. However, this makes > debug output completely useless. Switch to %px in order to see the > unadorned kernel pointers. My understanding of the printk pointer hashing change was to force people to think more carefully when they really need to print a kernel pointer. When it is only used to identify an object, then a hash works just fine. Most of the changes I see in amdgpu/amdkfd fall into this category. As I see it, changing all %p to %px by a script takes the thought process out of it and subverts the intention of the original pointer hashing change. Regards,   Felix > > This was done with the following one-liner: > find drivers/gpu/drm -type f -name "*.c" -exec sed -r -i '/DRM_DEBUG|KERN_DEBUG|pr_debug/ s/%p\b/%px/g' {} + > > Signed-off-by: Alexey Brodkin > Cc: Borislav Petkov > Cc: Tobin C. Harding > Cc: Alex Deucher > Cc: Andrey Grodzovsky > Cc: Arnd Bergmann > Cc: Benjamin Gaignard > Cc: Chen-Yu Tsai > Cc: Christian Gmeiner > Cc: "Christian König" > Cc: Cihangir Akturk > Cc: CK Hu > Cc: Daniel Vetter > Cc: Dave Airlie > Cc: David Airlie > Cc: "David (ChunMing) Zhou" > Cc: Gerd Hoffmann > Cc: Greg Kroah-Hartman > Cc: Gustavo Padovan > Cc: Harry Wentland > Cc: "Heiko Stübner" > Cc: Ingo Molnar > Cc: Jani Nikula > Cc: "Jerry (Fangzhi) Zuo" > Cc: Joonas Lahtinen > Cc: Krzysztof Kozlowski > Cc: "Leo (Sunpeng) Li" > Cc: Lucas Stach > Cc: Maarten Lankhorst > Cc: Matthias Brugger > Cc: Maxime Ripard > Cc: "Michel Dänzer" > Cc: Oded Gabbay > Cc: Philipp Zabel > Cc: Rob Clark > Cc: Rodrigo Vivi > Cc: Roger He > Cc: Roman Li > Cc: Russell King > Cc: Samuel Li > Cc: Sandy Huang > Cc: Sean Paul > Cc: Shirish S > Cc: Sinclair Yeh > Cc: Thomas Hellstrom > Cc: Tom Lendacky > Cc: Tony Cheng > Cc: Vincent Abriou > Cc: VMware Graphics > Cc: linux-arm-kernel@lists.infradead.org > Cc: linux-arm-msm@vger.kernel.org > Cc: linux-kernel@vger.kernel.org > Cc: linux-mediatek@lists.infradead.org > Cc: linux-rockchip@lists.infradead.org > Cc: etnaviv@lists.freedesktop.org > Cc: freedreno@lists.freedesktop.org > Cc: amd-gfx@lists.freedesktop.org > Cc: intel-gfx@lists.freedesktop.org > Cc: virtualization@lists.linux-foundation.org > --- > drivers/gpu/drm/amd/amdgpu/amdgpu_amdkfd_gpuvm.c | 14 +++---- > drivers/gpu/drm/amd/amdgpu/amdgpu_display.c | 4 +- > drivers/gpu/drm/amd/amdkfd/kfd_chardev.c | 4 +- > drivers/gpu/drm/amd/amdkfd/kfd_dbgdev.c | 2 +- > drivers/gpu/drm/amd/amdkfd/kfd_device.c | 10 ++--- > drivers/gpu/drm/amd/amdkfd/kfd_doorbell.c | 4 +- > drivers/gpu/drm/amd/amdkfd/kfd_events.c | 4 +- > drivers/gpu/drm/amd/amdkfd/kfd_kernel_queue.c | 2 +- > drivers/gpu/drm/amd/amdkfd/kfd_process.c | 4 +- > drivers/gpu/drm/amd/amdkfd/kfd_queue.c | 18 ++++----- > drivers/gpu/drm/amd/display/amdgpu_dm/amdgpu_dm.c | 14 +++---- > .../amd/display/amdgpu_dm/amdgpu_dm_mst_types.c | 2 +- > drivers/gpu/drm/armada/armada_gem.c | 12 +++--- > drivers/gpu/drm/drm_atomic.c | 44 +++++++++++----------- > drivers/gpu/drm/drm_bufs.c | 8 ++-- > drivers/gpu/drm/drm_dp_mst_topology.c | 4 +- > drivers/gpu/drm/drm_lease.c | 6 +-- > drivers/gpu/drm/drm_lock.c | 2 +- > drivers/gpu/drm/drm_scatter.c | 4 +- > drivers/gpu/drm/etnaviv/etnaviv_drv.c | 6 +-- > drivers/gpu/drm/i810/i810_dma.c | 2 +- > drivers/gpu/drm/i915/i915_perf.c | 2 +- > drivers/gpu/drm/i915/intel_display.c | 2 +- > drivers/gpu/drm/i915/intel_guc_ct.c | 4 +- > drivers/gpu/drm/i915/intel_guc_submission.c | 2 +- > drivers/gpu/drm/i915/intel_uc_fw.c | 2 +- > drivers/gpu/drm/mediatek/mtk_drm_gem.c | 2 +- > drivers/gpu/drm/mga/mga_warp.c | 2 +- > drivers/gpu/drm/msm/msm_drv.c | 4 +- > drivers/gpu/drm/qxl/qxl_cmd.c | 4 +- > drivers/gpu/drm/qxl/qxl_fb.c | 2 +- > drivers/gpu/drm/qxl/qxl_ttm.c | 2 +- > drivers/gpu/drm/radeon/radeon_display.c | 2 +- > drivers/gpu/drm/radeon/radeon_dp_mst.c | 12 +++--- > drivers/gpu/drm/radeon/radeon_object.c | 2 +- > drivers/gpu/drm/rockchip/rockchip_drm_fbdev.c | 2 +- > drivers/gpu/drm/savage/savage_bci.c | 2 +- > drivers/gpu/drm/sti/sti_gdp.c | 4 +- > drivers/gpu/drm/sti/sti_mixer.c | 2 +- > drivers/gpu/drm/sun4i/sun4i_crtc.c | 4 +- > drivers/gpu/drm/ttm/ttm_page_alloc.c | 2 +- > drivers/gpu/drm/udl/udl_fb.c | 2 +- > drivers/gpu/drm/via/via_dma.c | 4 +- > drivers/gpu/drm/via/via_irq.c | 2 +- > drivers/gpu/drm/vmwgfx/vmwgfx_overlay.c | 2 +- > 45 files changed, 120 insertions(+), 120 deletions(-) > > diff --git a/drivers/gpu/drm/amd/amdgpu/amdgpu_amdkfd_gpuvm.c b/drivers/gpu/drm/amd/amdgpu/amdgpu_amdkfd_gpuvm.c > index 1d6e1479da38..32e85fe83152 100644 > --- a/drivers/gpu/drm/amd/amdgpu/amdgpu_amdkfd_gpuvm.c > +++ b/drivers/gpu/drm/amd/amdgpu/amdgpu_amdkfd_gpuvm.c > @@ -438,7 +438,7 @@ static int add_bo_to_vm(struct amdgpu_device *adev, struct kgd_mem *mem, > if (!bo_va_entry) > return -ENOMEM; > > - pr_debug("\t add VA 0x%llx - 0x%llx to vm %p\n", va, > + pr_debug("\t add VA 0x%llx - 0x%llx to vm %px\n", va, > va + bo_size, vm); > > /* Add BO to VM internal data structures*/ > @@ -497,7 +497,7 @@ static int add_bo_to_vm(struct amdgpu_device *adev, struct kgd_mem *mem, > static void remove_bo_from_vm(struct amdgpu_device *adev, > struct kfd_bo_va_list *entry, unsigned long size) > { > - pr_debug("\t remove VA 0x%llx - 0x%llx in entry %p\n", > + pr_debug("\t remove VA 0x%llx - 0x%llx in entry %px\n", > entry->va, > entry->va + size, entry); > amdgpu_vm_bo_rmv(adev, entry->bo_va); > @@ -982,7 +982,7 @@ void amdgpu_amdkfd_gpuvm_destroy_process_vm(struct kgd_dev *kgd, void *vm) > if (WARN_ON(!kgd || !vm)) > return; > > - pr_debug("Destroying process vm %p\n", vm); > + pr_debug("Destroying process vm %px\n", vm); > > /* Release the VM context */ > amdgpu_vm_fini(adev, avm); > @@ -1191,7 +1191,7 @@ int amdgpu_amdkfd_gpuvm_map_memory_to_gpu( > domain = mem->domain; > bo_size = bo->tbo.mem.size; > > - pr_debug("Map VA 0x%llx - 0x%llx to vm %p domain %s\n", > + pr_debug("Map VA 0x%llx - 0x%llx to vm %px domain %s\n", > mem->va, > mem->va + bo_size * (1 + mem->aql_queue), > vm, domain_string(domain)); > @@ -1231,7 +1231,7 @@ int amdgpu_amdkfd_gpuvm_map_memory_to_gpu( > > list_for_each_entry(entry, &mem->bo_va_list, bo_list) { > if (entry->bo_va->base.vm == vm && !entry->is_mapped) { > - pr_debug("\t map VA 0x%llx - 0x%llx in entry %p\n", > + pr_debug("\t map VA 0x%llx - 0x%llx in entry %px\n", > entry->va, entry->va + bo_size, > entry); > > @@ -1302,14 +1302,14 @@ int amdgpu_amdkfd_gpuvm_unmap_memory_from_gpu( > if (unlikely(ret)) > goto unreserve_out; > > - pr_debug("Unmap VA 0x%llx - 0x%llx from vm %p\n", > + pr_debug("Unmap VA 0x%llx - 0x%llx from vm %px\n", > mem->va, > mem->va + bo_size * (1 + mem->aql_queue), > vm); > > list_for_each_entry(entry, &mem->bo_va_list, bo_list) { > if (entry->bo_va->base.vm == vm && entry->is_mapped) { > - pr_debug("\t unmap VA 0x%llx - 0x%llx from entry %p\n", > + pr_debug("\t unmap VA 0x%llx - 0x%llx from entry %px\n", > entry->va, > entry->va + bo_size, > entry); > diff --git a/drivers/gpu/drm/amd/amdgpu/amdgpu_display.c b/drivers/gpu/drm/amd/amdgpu/amdgpu_display.c > index 93f700ab1bfb..44a19d7cc941 100644 > --- a/drivers/gpu/drm/amd/amdgpu/amdgpu_display.c > +++ b/drivers/gpu/drm/amd/amdgpu/amdgpu_display.c > @@ -112,7 +112,7 @@ static void amdgpu_display_flip_work_func(struct work_struct *__work) > spin_unlock_irqrestore(&crtc->dev->event_lock, flags); > > > - DRM_DEBUG_DRIVER("crtc:%d[%p], pflip_stat:AMDGPU_FLIP_SUBMITTED, work: %p,\n", > + DRM_DEBUG_DRIVER("crtc:%d[%px], pflip_stat:AMDGPU_FLIP_SUBMITTED, work: %px,\n", > amdgpu_crtc->crtc_id, amdgpu_crtc, work); > > } > @@ -226,7 +226,7 @@ int amdgpu_display_crtc_page_flip_target(struct drm_crtc *crtc, > amdgpu_crtc->pflip_works = work; > > > - DRM_DEBUG_DRIVER("crtc:%d[%p], pflip_stat:AMDGPU_FLIP_PENDING, work: %p,\n", > + DRM_DEBUG_DRIVER("crtc:%d[%px], pflip_stat:AMDGPU_FLIP_PENDING, work: %px,\n", > amdgpu_crtc->crtc_id, amdgpu_crtc, work); > /* update crtc fb */ > crtc->primary->fb = fb; > diff --git a/drivers/gpu/drm/amd/amdkfd/kfd_chardev.c b/drivers/gpu/drm/amd/amdkfd/kfd_chardev.c > index cd679cf1fd30..fc91de6a7f02 100644 > --- a/drivers/gpu/drm/amd/amdkfd/kfd_chardev.c > +++ b/drivers/gpu/drm/amd/amdkfd/kfd_chardev.c > @@ -233,7 +233,7 @@ static int set_queue_properties_from_user(struct queue_properties *q_properties, > pr_debug("Queue Size: 0x%llX, %u\n", > q_properties->queue_size, args->ring_size); > > - pr_debug("Queue r/w Pointers: %p, %p\n", > + pr_debug("Queue r/w Pointers: %px, %px\n", > q_properties->read_ptr, > q_properties->write_ptr); > > @@ -725,7 +725,7 @@ static int kfd_ioctl_dbg_wave_control(struct file *filep, > > mutex_lock(kfd_get_dbgmgr_mutex()); > > - pr_debug("Calling dbg manager process %p, operand %u, mode %u, trapId %u, message %u\n", > + pr_debug("Calling dbg manager process %px, operand %u, mode %u, trapId %u, message %u\n", > wac_info.process, wac_info.operand, > wac_info.mode, wac_info.trapId, > wac_info.dbgWave_msg.DbgWaveMsg.WaveMsgInfoGen2.Value); > diff --git a/drivers/gpu/drm/amd/amdkfd/kfd_dbgdev.c b/drivers/gpu/drm/amd/amdkfd/kfd_dbgdev.c > index afb26f205d29..c3350d0270b2 100644 > --- a/drivers/gpu/drm/amd/amdkfd/kfd_dbgdev.c > +++ b/drivers/gpu/drm/amd/amdkfd/kfd_dbgdev.c > @@ -401,7 +401,7 @@ static int dbgdev_address_watch_diq(struct kfd_dbgdev *dbgdev, > pr_debug("\t\t%30s\n", "* * * * * * * * * * * * * * * * * *"); > pr_debug("\t\t%20s %08x\n", "register index :", i); > pr_debug("\t\t%20s %08x\n", "vmid is :", vmid); > - pr_debug("\t\t%20s %p\n", "Add ptr is :", > + pr_debug("\t\t%20s %px\n", "Add ptr is :", > adw_info->watch_address); > pr_debug("\t\t%20s %08llx\n", "Add is :", > adw_info->watch_address[i]); > diff --git a/drivers/gpu/drm/amd/amdkfd/kfd_device.c b/drivers/gpu/drm/amd/amdkfd/kfd_device.c > index 3346699960dd..57c26155e42e 100644 > --- a/drivers/gpu/drm/amd/amdkfd/kfd_device.c > +++ b/drivers/gpu/drm/amd/amdkfd/kfd_device.c > @@ -612,7 +612,7 @@ static int kfd_gtt_sa_init(struct kfd_dev *kfd, unsigned int buf_size, > if (!kfd->gtt_sa_bitmap) > return -ENOMEM; > > - pr_debug("gtt_sa_num_of_chunks = %d, gtt_sa_bitmap = %p\n", > + pr_debug("gtt_sa_num_of_chunks = %d, gtt_sa_bitmap = %px\n", > kfd->gtt_sa_num_of_chunks, kfd->gtt_sa_bitmap); > > mutex_init(&kfd->gtt_sa_lock); > @@ -656,7 +656,7 @@ int kfd_gtt_sa_allocate(struct kfd_dev *kfd, unsigned int size, > if ((*mem_obj) == NULL) > return -ENOMEM; > > - pr_debug("Allocated mem_obj = %p for size = %d\n", *mem_obj, size); > + pr_debug("Allocated mem_obj = %px for size = %d\n", *mem_obj, size); > > start_search = 0; > > @@ -686,7 +686,7 @@ int kfd_gtt_sa_allocate(struct kfd_dev *kfd, unsigned int size, > found, > kfd->gtt_sa_chunk_size); > > - pr_debug("gpu_addr = %p, cpu_addr = %p\n", > + pr_debug("gpu_addr = %px, cpu_addr = %px\n", > (uint64_t *) (*mem_obj)->gpu_addr, (*mem_obj)->cpu_ptr); > > /* If we need only one chunk, mark it as allocated and get out */ > @@ -740,7 +740,7 @@ int kfd_gtt_sa_allocate(struct kfd_dev *kfd, unsigned int size, > return 0; > > kfd_gtt_no_free_chunk: > - pr_debug("Allocation failed with mem_obj = %p\n", mem_obj); > + pr_debug("Allocation failed with mem_obj = %px\n", mem_obj); > mutex_unlock(&kfd->gtt_sa_lock); > kfree(mem_obj); > return -ENOMEM; > @@ -754,7 +754,7 @@ int kfd_gtt_sa_free(struct kfd_dev *kfd, struct kfd_mem_obj *mem_obj) > if (!mem_obj) > return 0; > > - pr_debug("Free mem_obj = %p, range_start = %d, range_end = %d\n", > + pr_debug("Free mem_obj = %px, range_start = %d, range_end = %d\n", > mem_obj, mem_obj->range_start, mem_obj->range_end); > > mutex_lock(&kfd->gtt_sa_lock); > diff --git a/drivers/gpu/drm/amd/amdkfd/kfd_doorbell.c b/drivers/gpu/drm/amd/amdkfd/kfd_doorbell.c > index ebb4da14e3df..7b5ad0c577c8 100644 > --- a/drivers/gpu/drm/amd/amdkfd/kfd_doorbell.c > +++ b/drivers/gpu/drm/amd/amdkfd/kfd_doorbell.c > @@ -116,7 +116,7 @@ int kfd_doorbell_init(struct kfd_dev *kfd) > pr_debug("doorbell aperture size == 0x%08lX\n", > kfd->shared_resources.doorbell_aperture_size); > > - pr_debug("doorbell kernel address == %p\n", kfd->doorbell_kernel_ptr); > + pr_debug("doorbell kernel address == %px\n", kfd->doorbell_kernel_ptr); > > return 0; > } > @@ -214,7 +214,7 @@ inline void write_kernel_doorbell(u32 __iomem *db, u32 value) > { > if (db) { > writel(value, db); > - pr_debug("Writing %d to doorbell address %p\n", value, db); > + pr_debug("Writing %d to doorbell address %px\n", value, db); > } > } > > diff --git a/drivers/gpu/drm/amd/amdkfd/kfd_events.c b/drivers/gpu/drm/amd/amdkfd/kfd_events.c > index 4890a90f1e44..1b03308faa0e 100644 > --- a/drivers/gpu/drm/amd/amdkfd/kfd_events.c > +++ b/drivers/gpu/drm/amd/amdkfd/kfd_events.c > @@ -81,7 +81,7 @@ static struct kfd_signal_page *allocate_signal_page(struct kfd_process *p) > > page->kernel_address = backing_store; > page->need_to_free_pages = true; > - pr_debug("Allocated new event signal page at %p, for process %p\n", > + pr_debug("Allocated new event signal page at %px, for process %px\n", > page, p); > > return page; > @@ -202,7 +202,7 @@ static int create_signal_event(struct file *devkfd, > p->signal_event_count++; > > ev->user_signal_address = &p->signal_page->user_address[ev->event_id]; > - pr_debug("Signal event number %zu created with id %d, address %p\n", > + pr_debug("Signal event number %zu created with id %d, address %px\n", > p->signal_event_count, ev->event_id, > ev->user_signal_address); > > diff --git a/drivers/gpu/drm/amd/amdkfd/kfd_kernel_queue.c b/drivers/gpu/drm/amd/amdkfd/kfd_kernel_queue.c > index 69f496485331..b39b5b813dab 100644 > --- a/drivers/gpu/drm/amd/amdkfd/kfd_kernel_queue.c > +++ b/drivers/gpu/drm/amd/amdkfd/kfd_kernel_queue.c > @@ -222,7 +222,7 @@ static int acquire_packet_buffer(struct kernel_queue *kq, > > pr_debug("rptr: %d\n", rptr); > pr_debug("wptr: %d\n", wptr); > - pr_debug("queue_address 0x%p\n", queue_address); > + pr_debug("queue_address 0x%px\n", queue_address); > > available_size = (rptr + queue_size_dwords - 1 - wptr) % > queue_size_dwords; > diff --git a/drivers/gpu/drm/amd/amdkfd/kfd_process.c b/drivers/gpu/drm/amd/amdkfd/kfd_process.c > index 1711ad0642f7..c5c1b2158910 100644 > --- a/drivers/gpu/drm/amd/amdkfd/kfd_process.c > +++ b/drivers/gpu/drm/amd/amdkfd/kfd_process.c > @@ -468,7 +468,7 @@ static int kfd_process_init_cwsr_apu(struct kfd_process *p, struct file *filep) > memcpy(qpd->cwsr_kaddr, dev->cwsr_isa, dev->cwsr_isa_size); > > qpd->tma_addr = qpd->tba_addr + KFD_CWSR_TMA_OFFSET; > - pr_debug("set tba :0x%llx, tma:0x%llx, cwsr_kaddr:%p for pqm.\n", > + pr_debug("set tba :0x%llx, tma:0x%llx, cwsr_kaddr:%px for pqm.\n", > qpd->tba_addr, qpd->tma_addr, qpd->cwsr_kaddr); > } > > @@ -499,7 +499,7 @@ static int kfd_process_device_init_cwsr_dgpu(struct kfd_process_device *pdd) > memcpy(qpd->cwsr_kaddr, dev->cwsr_isa, dev->cwsr_isa_size); > > qpd->tma_addr = qpd->tba_addr + KFD_CWSR_TMA_OFFSET; > - pr_debug("set tba :0x%llx, tma:0x%llx, cwsr_kaddr:%p for pqm.\n", > + pr_debug("set tba :0x%llx, tma:0x%llx, cwsr_kaddr:%px for pqm.\n", > qpd->tba_addr, qpd->tma_addr, qpd->cwsr_kaddr); > > return 0; > diff --git a/drivers/gpu/drm/amd/amdkfd/kfd_queue.c b/drivers/gpu/drm/amd/amdkfd/kfd_queue.c > index a5315d4f1c95..56d3e05b53ba 100644 > --- a/drivers/gpu/drm/amd/amdkfd/kfd_queue.c > +++ b/drivers/gpu/drm/amd/amdkfd/kfd_queue.c > @@ -36,9 +36,9 @@ void print_queue_properties(struct queue_properties *q) > pr_debug("Queue Address: 0x%llX\n", q->queue_address); > pr_debug("Queue Id: %u\n", q->queue_id); > pr_debug("Queue Process Vmid: %u\n", q->vmid); > - pr_debug("Queue Read Pointer: 0x%p\n", q->read_ptr); > - pr_debug("Queue Write Pointer: 0x%p\n", q->write_ptr); > - pr_debug("Queue Doorbell Pointer: 0x%p\n", q->doorbell_ptr); > + pr_debug("Queue Read Pointer: 0x%px\n", q->read_ptr); > + pr_debug("Queue Write Pointer: 0x%px\n", q->write_ptr); > + pr_debug("Queue Doorbell Pointer: 0x%px\n", q->doorbell_ptr); > pr_debug("Queue Doorbell Offset: %u\n", q->doorbell_off); > } > > @@ -53,14 +53,14 @@ void print_queue(struct queue *q) > pr_debug("Queue Address: 0x%llX\n", q->properties.queue_address); > pr_debug("Queue Id: %u\n", q->properties.queue_id); > pr_debug("Queue Process Vmid: %u\n", q->properties.vmid); > - pr_debug("Queue Read Pointer: 0x%p\n", q->properties.read_ptr); > - pr_debug("Queue Write Pointer: 0x%p\n", q->properties.write_ptr); > - pr_debug("Queue Doorbell Pointer: 0x%p\n", q->properties.doorbell_ptr); > + pr_debug("Queue Read Pointer: 0x%px\n", q->properties.read_ptr); > + pr_debug("Queue Write Pointer: 0x%px\n", q->properties.write_ptr); > + pr_debug("Queue Doorbell Pointer: 0x%px\n", q->properties.doorbell_ptr); > pr_debug("Queue Doorbell Offset: %u\n", q->properties.doorbell_off); > - pr_debug("Queue MQD Address: 0x%p\n", q->mqd); > + pr_debug("Queue MQD Address: 0x%px\n", q->mqd); > pr_debug("Queue MQD Gart: 0x%llX\n", q->gart_mqd_addr); > - pr_debug("Queue Process Address: 0x%p\n", q->process); > - pr_debug("Queue Device Address: 0x%p\n", q->device); > + pr_debug("Queue Process Address: 0x%px\n", q->process); > + pr_debug("Queue Device Address: 0x%px\n", q->device); > } > > int init_queue(struct queue **q, const struct queue_properties *properties) > diff --git a/drivers/gpu/drm/amd/display/amdgpu_dm/amdgpu_dm.c b/drivers/gpu/drm/amd/display/amdgpu_dm/amdgpu_dm.c > index 4e2f379ce217..c50779aa5daa 100644 > --- a/drivers/gpu/drm/amd/display/amdgpu_dm/amdgpu_dm.c > +++ b/drivers/gpu/drm/amd/display/amdgpu_dm/amdgpu_dm.c > @@ -275,7 +275,7 @@ static void dm_pflip_high_irq(void *interrupt_params) > spin_lock_irqsave(&adev->ddev->event_lock, flags); > > if (amdgpu_crtc->pflip_status != AMDGPU_FLIP_SUBMITTED){ > - DRM_DEBUG_DRIVER("amdgpu_crtc->pflip_status = %d !=AMDGPU_FLIP_SUBMITTED(%d) on crtc:%d[%p] \n", > + DRM_DEBUG_DRIVER("amdgpu_crtc->pflip_status = %d !=AMDGPU_FLIP_SUBMITTED(%d) on crtc:%d[%px] \n", > amdgpu_crtc->pflip_status, > AMDGPU_FLIP_SUBMITTED, > amdgpu_crtc->crtc_id, > @@ -301,7 +301,7 @@ static void dm_pflip_high_irq(void *interrupt_params) > amdgpu_crtc->pflip_status = AMDGPU_FLIP_NONE; > spin_unlock_irqrestore(&adev->ddev->event_lock, flags); > > - DRM_DEBUG_DRIVER("%s - crtc :%d[%p], pflip_stat:AMDGPU_FLIP_NONE\n", > + DRM_DEBUG_DRIVER("%s - crtc :%d[%px], pflip_stat:AMDGPU_FLIP_NONE\n", > __func__, amdgpu_crtc->crtc_id, amdgpu_crtc); > > drm_crtc_vblank_put(&amdgpu_crtc->base); > @@ -463,7 +463,7 @@ static int amdgpu_dm_init(struct amdgpu_device *adev) > DRM_ERROR( > "amdgpu: failed to initialize freesync_module.\n"); > } else > - DRM_DEBUG_DRIVER("amdgpu: freesync_module init done %p.\n", > + DRM_DEBUG_DRIVER("amdgpu: freesync_module init done %px.\n", > adev->dm.freesync_module); > > amdgpu_dm_init_color_mod(); > @@ -543,7 +543,7 @@ static int detect_mst_link_for_all_connectors(struct drm_device *dev) > aconnector = to_amdgpu_dm_connector(connector); > if (aconnector->dc_link->type == dc_connection_mst_branch && > aconnector->mst_mgr.aux) { > - DRM_DEBUG_DRIVER("DM_MST: starting TM on aconnector: %p [id: %d]\n", > + DRM_DEBUG_DRIVER("DM_MST: starting TM on aconnector: %px [id: %d]\n", > aconnector, aconnector->base.base.id); > > ret = drm_dp_mst_topology_mgr_set_mst(&aconnector->mst_mgr, true); > @@ -895,7 +895,7 @@ amdgpu_dm_update_connector_after_detect(struct amdgpu_dm_connector *aconnector) > return; > } > > - DRM_DEBUG_DRIVER("DCHPD: connector_id=%d: Old sink=%p New sink=%p\n", > + DRM_DEBUG_DRIVER("DCHPD: connector_id=%d: Old sink=%px New sink=%px\n", > aconnector->connector_id, aconnector->dc_sink, sink); > > mutex_lock(&dev->mode_config.mutex); > @@ -4185,7 +4185,7 @@ static void amdgpu_dm_atomic_commit_tail(struct drm_atomic_state *state) > > if (modeset_required(new_crtc_state, dm_new_crtc_state->stream, dm_old_crtc_state->stream)) { > > - DRM_DEBUG_DRIVER("Atomic commit: SET crtc id %d: [%p]\n", acrtc->crtc_id, acrtc); > + DRM_DEBUG_DRIVER("Atomic commit: SET crtc id %d: [%px]\n", acrtc->crtc_id, acrtc); > > if (!dm_new_crtc_state->stream) { > /* > @@ -4215,7 +4215,7 @@ static void amdgpu_dm_atomic_commit_tail(struct drm_atomic_state *state) > acrtc->hw_mode = new_crtc_state->mode; > crtc->hwmode = new_crtc_state->mode; > } else if (modereset_required(new_crtc_state)) { > - DRM_DEBUG_DRIVER("Atomic commit: RESET. crtc id %d:[%p]\n", acrtc->crtc_id, acrtc); > + DRM_DEBUG_DRIVER("Atomic commit: RESET. crtc id %d:[%px]\n", acrtc->crtc_id, acrtc); > > /* i.e. reset mode */ > if (dm_old_crtc_state->stream) > diff --git a/drivers/gpu/drm/amd/display/amdgpu_dm/amdgpu_dm_mst_types.c b/drivers/gpu/drm/amd/display/amdgpu_dm/amdgpu_dm_mst_types.c > index 8291d74f26bc..4fc246cd6ec4 100644 > --- a/drivers/gpu/drm/amd/display/amdgpu_dm/amdgpu_dm_mst_types.c > +++ b/drivers/gpu/drm/amd/display/amdgpu_dm/amdgpu_dm_mst_types.c > @@ -302,7 +302,7 @@ dm_dp_create_fake_mst_encoder(struct amdgpu_dm_connector *connector) > struct drm_encoder *enc_master = > connector_funcs->best_encoder(&connector->base); > > - DRM_DEBUG_KMS("enc master is %p\n", enc_master); > + DRM_DEBUG_KMS("enc master is %px\n", enc_master); > amdgpu_encoder = kzalloc(sizeof(*amdgpu_encoder), GFP_KERNEL); > if (!amdgpu_encoder) > return NULL; > diff --git a/drivers/gpu/drm/armada/armada_gem.c b/drivers/gpu/drm/armada/armada_gem.c > index a97f509743a5..075840a3735f 100644 > --- a/drivers/gpu/drm/armada/armada_gem.c > +++ b/drivers/gpu/drm/armada/armada_gem.c > @@ -50,7 +50,7 @@ void armada_gem_free_object(struct drm_gem_object *obj) > struct armada_gem_object *dobj = drm_to_armada_gem(obj); > struct armada_private *priv = obj->dev->dev_private; > > - DRM_DEBUG_DRIVER("release obj %p\n", dobj); > + DRM_DEBUG_DRIVER("release obj %px\n", dobj); > > drm_gem_free_mmap_offset(&dobj->obj); > > @@ -177,7 +177,7 @@ armada_gem_linear_back(struct drm_device *dev, struct armada_gem_object *obj) > obj->mapped = true; > } > > - DRM_DEBUG_DRIVER("obj %p phys %#llx dev %#llx\n", obj, > + DRM_DEBUG_DRIVER("obj %px phys %#llx dev %#llx\n", obj, > (unsigned long long)obj->phys_addr, > (unsigned long long)obj->dev_addr); > > @@ -206,7 +206,7 @@ armada_gem_alloc_private_object(struct drm_device *dev, size_t size) > > drm_gem_private_object_init(dev, &obj->obj, size); > > - DRM_DEBUG_DRIVER("alloc private obj %p size %zu\n", obj, size); > + DRM_DEBUG_DRIVER("alloc private obj %px size %zu\n", obj, size); > > return obj; > } > @@ -231,7 +231,7 @@ static struct armada_gem_object *armada_gem_alloc_object(struct drm_device *dev, > mapping = obj->obj.filp->f_mapping; > mapping_set_gfp_mask(mapping, GFP_HIGHUSER | __GFP_RECLAIMABLE); > > - DRM_DEBUG_DRIVER("alloc obj %p size %zu\n", obj, size); > + DRM_DEBUG_DRIVER("alloc obj %px size %zu\n", obj, size); > > return obj; > } > @@ -263,7 +263,7 @@ int armada_gem_dumb_create(struct drm_file *file, struct drm_device *dev, > args->handle = handle; > > /* drop reference from allocate - handle holds it now */ > - DRM_DEBUG_DRIVER("obj %p size %zu handle %#x\n", dobj, size, handle); > + DRM_DEBUG_DRIVER("obj %px size %zu handle %#x\n", dobj, size, handle); > err: > drm_gem_object_put_unlocked(&dobj->obj); > return ret; > @@ -295,7 +295,7 @@ int armada_gem_create_ioctl(struct drm_device *dev, void *data, > args->handle = handle; > > /* drop reference from allocate - handle holds it now */ > - DRM_DEBUG_DRIVER("obj %p size %zu handle %#x\n", dobj, size, handle); > + DRM_DEBUG_DRIVER("obj %px size %zu handle %#x\n", dobj, size, handle); > err: > drm_gem_object_put_unlocked(&dobj->obj); > return ret; > diff --git a/drivers/gpu/drm/drm_atomic.c b/drivers/gpu/drm/drm_atomic.c > index 7d25c42f22db..239b010fc010 100644 > --- a/drivers/gpu/drm/drm_atomic.c > +++ b/drivers/gpu/drm/drm_atomic.c > @@ -92,7 +92,7 @@ drm_atomic_state_init(struct drm_device *dev, struct drm_atomic_state *state) > > state->dev = dev; > > - DRM_DEBUG_ATOMIC("Allocated atomic state %p\n", state); > + DRM_DEBUG_ATOMIC("Allocated atomic state %px\n", state); > > return 0; > fail: > @@ -143,7 +143,7 @@ void drm_atomic_state_default_clear(struct drm_atomic_state *state) > struct drm_mode_config *config = &dev->mode_config; > int i; > > - DRM_DEBUG_ATOMIC("Clearing atomic state %p\n", state); > + DRM_DEBUG_ATOMIC("Clearing atomic state %px\n", state); > > for (i = 0; i < state->num_connector; i++) { > struct drm_connector *connector = state->connectors[i].ptr; > @@ -240,7 +240,7 @@ void __drm_atomic_state_free(struct kref *ref) > > drm_atomic_state_clear(state); > > - DRM_DEBUG_ATOMIC("Freeing atomic state %p\n", state); > + DRM_DEBUG_ATOMIC("Freeing atomic state %px\n", state); > > if (config->funcs->atomic_state_free) { > config->funcs->atomic_state_free(state); > @@ -293,7 +293,7 @@ drm_atomic_get_crtc_state(struct drm_atomic_state *state, > state->crtcs[index].ptr = crtc; > crtc_state->state = state; > > - DRM_DEBUG_ATOMIC("Added [CRTC:%d:%s] %p state to %p\n", > + DRM_DEBUG_ATOMIC("Added [CRTC:%d:%s] %px state to %px\n", > crtc->base.id, crtc->name, crtc_state, state); > > return crtc_state; > @@ -351,12 +351,12 @@ int drm_atomic_set_mode_for_crtc(struct drm_crtc_state *state, > > drm_mode_copy(&state->mode, mode); > state->enable = true; > - DRM_DEBUG_ATOMIC("Set [MODE:%s] for CRTC state %p\n", > + DRM_DEBUG_ATOMIC("Set [MODE:%s] for CRTC state %px\n", > mode->name, state); > } else { > memset(&state->mode, 0, sizeof(state->mode)); > state->enable = false; > - DRM_DEBUG_ATOMIC("Set [NOMODE] for CRTC state %p\n", > + DRM_DEBUG_ATOMIC("Set [NOMODE] for CRTC state %px\n", > state); > } > > @@ -396,11 +396,11 @@ int drm_atomic_set_mode_prop_for_crtc(struct drm_crtc_state *state, > > state->mode_blob = drm_property_blob_get(blob); > state->enable = true; > - DRM_DEBUG_ATOMIC("Set [MODE:%s] for CRTC state %p\n", > + DRM_DEBUG_ATOMIC("Set [MODE:%s] for CRTC state %px\n", > state->mode.name, state); > } else { > state->enable = false; > - DRM_DEBUG_ATOMIC("Set [NOMODE] for CRTC state %p\n", > + DRM_DEBUG_ATOMIC("Set [NOMODE] for CRTC state %px\n", > state); > } > > @@ -710,7 +710,7 @@ drm_atomic_get_plane_state(struct drm_atomic_state *state, > state->planes[index].new_state = plane_state; > plane_state->state = state; > > - DRM_DEBUG_ATOMIC("Added [PLANE:%d:%s] %p state to %p\n", > + DRM_DEBUG_ATOMIC("Added [PLANE:%d:%s] %px state to %px\n", > plane->base.id, plane->name, plane_state, state); > > if (plane_state->crtc) { > @@ -1111,7 +1111,7 @@ drm_atomic_get_private_obj_state(struct drm_atomic_state *state, > > state->num_private_objs = num_objs; > > - DRM_DEBUG_ATOMIC("Added new private object %p state %p to %p\n", > + DRM_DEBUG_ATOMIC("Added new private object %px state %px to %px\n", > obj, obj_state, state); > > return obj_state; > @@ -1178,7 +1178,7 @@ drm_atomic_get_connector_state(struct drm_atomic_state *state, > state->connectors[index].ptr = connector; > connector_state->state = state; > > - DRM_DEBUG_ATOMIC("Added [CONNECTOR:%d:%s] %p state to %p\n", > + DRM_DEBUG_ATOMIC("Added [CONNECTOR:%d:%s] %px state to %px\n", > connector->base.id, connector->name, > connector_state, state); > > @@ -1442,10 +1442,10 @@ drm_atomic_set_crtc_for_plane(struct drm_plane_state *plane_state, > } > > if (crtc) > - DRM_DEBUG_ATOMIC("Link plane state %p to [CRTC:%d:%s]\n", > + DRM_DEBUG_ATOMIC("Link plane state %px to [CRTC:%d:%s]\n", > plane_state, crtc->base.id, crtc->name); > else > - DRM_DEBUG_ATOMIC("Link plane state %p to [NOCRTC]\n", > + DRM_DEBUG_ATOMIC("Link plane state %px to [NOCRTC]\n", > plane_state); > > return 0; > @@ -1467,10 +1467,10 @@ drm_atomic_set_fb_for_plane(struct drm_plane_state *plane_state, > struct drm_framebuffer *fb) > { > if (fb) > - DRM_DEBUG_ATOMIC("Set [FB:%d] for plane state %p\n", > + DRM_DEBUG_ATOMIC("Set [FB:%d] for plane state %px\n", > fb->base.id, plane_state); > else > - DRM_DEBUG_ATOMIC("Set [NOFB] for plane state %p\n", > + DRM_DEBUG_ATOMIC("Set [NOFB] for plane state %px\n", > plane_state); > > drm_framebuffer_assign(&plane_state->fb, fb); > @@ -1551,10 +1551,10 @@ drm_atomic_set_crtc_for_connector(struct drm_connector_state *conn_state, > drm_connector_get(conn_state->connector); > conn_state->crtc = crtc; > > - DRM_DEBUG_ATOMIC("Link connector state %p to [CRTC:%d:%s]\n", > + DRM_DEBUG_ATOMIC("Link connector state %px to [CRTC:%d:%s]\n", > conn_state, crtc->base.id, crtc->name); > } else { > - DRM_DEBUG_ATOMIC("Link connector state %p to [NOCRTC]\n", > + DRM_DEBUG_ATOMIC("Link connector state %px to [NOCRTC]\n", > conn_state); > } > > @@ -1598,7 +1598,7 @@ drm_atomic_add_affected_connectors(struct drm_atomic_state *state, > if (ret) > return ret; > > - DRM_DEBUG_ATOMIC("Adding all current connectors for [CRTC:%d:%s] to %p\n", > + DRM_DEBUG_ATOMIC("Adding all current connectors for [CRTC:%d:%s] to %px\n", > crtc->base.id, crtc->name, state); > > /* > @@ -1682,7 +1682,7 @@ int drm_atomic_check_only(struct drm_atomic_state *state) > struct drm_crtc_state *crtc_state; > int i, ret = 0; > > - DRM_DEBUG_ATOMIC("checking %p\n", state); > + DRM_DEBUG_ATOMIC("checking %px\n", state); > > for_each_new_plane_in_state(state, plane, plane_state, i) { > ret = drm_atomic_plane_check(plane, plane_state); > @@ -1745,7 +1745,7 @@ int drm_atomic_commit(struct drm_atomic_state *state) > if (ret) > return ret; > > - DRM_DEBUG_ATOMIC("committing %p\n", state); > + DRM_DEBUG_ATOMIC("committing %px\n", state); > > return config->funcs->atomic_commit(state->dev, state, false); > } > @@ -1774,7 +1774,7 @@ int drm_atomic_nonblocking_commit(struct drm_atomic_state *state) > if (ret) > return ret; > > - DRM_DEBUG_ATOMIC("committing %p nonblocking\n", state); > + DRM_DEBUG_ATOMIC("committing %px nonblocking\n", state); > > return config->funcs->atomic_commit(state->dev, state, true); > } > @@ -1791,7 +1791,7 @@ static void drm_atomic_print_state(const struct drm_atomic_state *state) > struct drm_connector_state *connector_state; > int i; > > - DRM_DEBUG_ATOMIC("checking %p\n", state); > + DRM_DEBUG_ATOMIC("checking %px\n", state); > > for_each_new_plane_in_state(state, plane, plane_state, i) > drm_atomic_plane_print_state(&p, plane_state); > diff --git a/drivers/gpu/drm/drm_bufs.c b/drivers/gpu/drm/drm_bufs.c > index ba8cfe65c65b..f56a0893ef1b 100644 > --- a/drivers/gpu/drm/drm_bufs.c > +++ b/drivers/gpu/drm/drm_bufs.c > @@ -236,7 +236,7 @@ static int drm_addmap_core(struct drm_device *dev, resource_size_t offset, > return 0; > } > map->handle = vmalloc_user(map->size); > - DRM_DEBUG("%lu %d %p\n", > + DRM_DEBUG("%lu %d %px\n", > map->size, order_base_2(map->size), map->handle); > if (!map->handle) { > kfree(map); > @@ -793,7 +793,7 @@ int drm_legacy_addbufs_agp(struct drm_device *dev, > return -ENOMEM; > } > > - DRM_DEBUG("buffer %d @ %p\n", entry->buf_count, buf->address); > + DRM_DEBUG("buffer %d @ %px\n", entry->buf_count, buf->address); > > offset += alignment; > entry->buf_count++; > @@ -995,7 +995,7 @@ int drm_legacy_addbufs_pci(struct drm_device *dev, > return -ENOMEM; > } > > - DRM_DEBUG("buffer %d @ %p\n", > + DRM_DEBUG("buffer %d @ %px\n", > entry->buf_count, buf->address); > } > byte_count += PAGE_SIZE << page_order; > @@ -1156,7 +1156,7 @@ static int drm_legacy_addbufs_sg(struct drm_device *dev, > return -ENOMEM; > } > > - DRM_DEBUG("buffer %d @ %p\n", entry->buf_count, buf->address); > + DRM_DEBUG("buffer %d @ %px\n", entry->buf_count, buf->address); > > offset += alignment; > entry->buf_count++; > diff --git a/drivers/gpu/drm/drm_dp_mst_topology.c b/drivers/gpu/drm/drm_dp_mst_topology.c > index 6fac4129e6a2..8ca8d418ca37 100644 > --- a/drivers/gpu/drm/drm_dp_mst_topology.c > +++ b/drivers/gpu/drm/drm_dp_mst_topology.c > @@ -814,7 +814,7 @@ static int drm_dp_mst_wait_tx_reply(struct drm_dp_mst_branch *mstb, > goto out; > } > } else { > - DRM_DEBUG_KMS("timedout msg send %p %d %d\n", txmsg, txmsg->state, txmsg->seqno); > + DRM_DEBUG_KMS("timedout msg send %px %d %d\n", txmsg, txmsg->state, txmsg->seqno); > > /* dump some state */ > ret = -EIO; > @@ -2335,7 +2335,7 @@ static int drm_dp_mst_handle_down_rep(struct drm_dp_mst_topology_mgr *mgr) > mutex_unlock(&mgr->qlock); > > if (!txmsg) { > - DRM_DEBUG_KMS("Got MST reply with no msg %p %d %d %02x %02x\n", > + DRM_DEBUG_KMS("Got MST reply with no msg %px %d %d %02x %02x\n", > mstb, > mgr->down_rep_recv.initial_hdr.seqno, > mgr->down_rep_recv.initial_hdr.lct, > diff --git a/drivers/gpu/drm/drm_lease.c b/drivers/gpu/drm/drm_lease.c > index d345563fdff3..47baec81a817 100644 > --- a/drivers/gpu/drm/drm_lease.c > +++ b/drivers/gpu/drm/drm_lease.c > @@ -248,7 +248,7 @@ static struct drm_master *drm_lease_create(struct drm_master *lessor, struct idr > > /* Move the leases over */ > lessee->leases = *leases; > - DRM_DEBUG_LEASE("new lessee %d %p, lessor %d %p\n", lessee->lessee_id, lessee, lessor->lessee_id, lessor); > + DRM_DEBUG_LEASE("new lessee %d %px, lessor %d %px\n", lessee->lessee_id, lessee, lessor->lessee_id, lessor); > > mutex_unlock(&dev->mode_config.idr_mutex); > return lessee; > @@ -320,7 +320,7 @@ static void _drm_lease_revoke(struct drm_master *top) > * the tree is fully connected, we can do this without recursing > */ > for (;;) { > - DRM_DEBUG_LEASE("revoke leases for %p %d\n", master, master->lessee_id); > + DRM_DEBUG_LEASE("revoke leases for %px %d\n", master, master->lessee_id); > > /* Evacuate the lease */ > idr_for_each_entry(&master->leases, entry, object) > @@ -564,7 +564,7 @@ int drm_mode_create_lease_ioctl(struct drm_device *dev, > } > > /* Initialize the new file for DRM */ > - DRM_DEBUG_LEASE("Initializing the file with %p\n", lessee_file->f_op->open); > + DRM_DEBUG_LEASE("Initializing the file with %px\n", lessee_file->f_op->open); > ret = lessee_file->f_op->open(lessee_file->f_inode, lessee_file); > if (ret) > goto out_lessee_file; > diff --git a/drivers/gpu/drm/drm_lock.c b/drivers/gpu/drm/drm_lock.c > index 96bb6badb818..550b462c9526 100644 > --- a/drivers/gpu/drm/drm_lock.c > +++ b/drivers/gpu/drm/drm_lock.c > @@ -341,7 +341,7 @@ void drm_legacy_lock_release(struct drm_device *dev, struct file *filp) > return; > > if (drm_legacy_i_have_hw_lock(dev, file_priv)) { > - DRM_DEBUG("File %p released, freeing lock for context %d\n", > + DRM_DEBUG("File %px released, freeing lock for context %d\n", > filp, _DRM_LOCKING_CONTEXT(file_priv->master->lock.hw_lock->lock)); > drm_legacy_lock_free(&file_priv->master->lock, > _DRM_LOCKING_CONTEXT(file_priv->master->lock.hw_lock->lock)); > diff --git a/drivers/gpu/drm/drm_scatter.c b/drivers/gpu/drm/drm_scatter.c > index 275bca44f38c..06340c07ec12 100644 > --- a/drivers/gpu/drm/drm_scatter.c > +++ b/drivers/gpu/drm/drm_scatter.c > @@ -134,7 +134,7 @@ int drm_legacy_sg_alloc(struct drm_device *dev, void *data, > entry->handle = ScatterHandle((unsigned long)entry->virtual); > > DRM_DEBUG("handle = %08lx\n", entry->handle); > - DRM_DEBUG("virtual = %p\n", entry->virtual); > + DRM_DEBUG("virtual = %px\n", entry->virtual); > > for (i = (unsigned long)entry->virtual, j = 0; j < pages; > i += PAGE_SIZE, j++) { > @@ -213,7 +213,7 @@ int drm_legacy_sg_free(struct drm_device *dev, void *data, > if (!entry || entry->handle != request->handle) > return -EINVAL; > > - DRM_DEBUG("virtual = %p\n", entry->virtual); > + DRM_DEBUG("virtual = %px\n", entry->virtual); > > drm_sg_cleanup(entry); > > diff --git a/drivers/gpu/drm/etnaviv/etnaviv_drv.c b/drivers/gpu/drm/etnaviv/etnaviv_drv.c > index ab50090d066c..09065596463b 100644 > --- a/drivers/gpu/drm/etnaviv/etnaviv_drv.c > +++ b/drivers/gpu/drm/etnaviv/etnaviv_drv.c > @@ -52,7 +52,7 @@ void __iomem *etnaviv_ioremap(struct platform_device *pdev, const char *name, > } > > if (reglog) > - dev_printk(KERN_DEBUG, &pdev->dev, "IO:region %s 0x%p %08zx\n", > + dev_printk(KERN_DEBUG, &pdev->dev, "IO:region %s 0x%px %08zx\n", > dbgname, ptr, (size_t)resource_size(res)); > > return ptr; > @@ -61,7 +61,7 @@ void __iomem *etnaviv_ioremap(struct platform_device *pdev, const char *name, > void etnaviv_writel(u32 data, void __iomem *addr) > { > if (reglog) > - printk(KERN_DEBUG "IO:W %p %08x\n", addr, data); > + printk(KERN_DEBUG "IO:W %px %08x\n", addr, data); > > writel(data, addr); > } > @@ -71,7 +71,7 @@ u32 etnaviv_readl(const void __iomem *addr) > u32 val = readl(addr); > > if (reglog) > - printk(KERN_DEBUG "IO:R %p %08x\n", addr, val); > + printk(KERN_DEBUG "IO:R %px %08x\n", addr, val); > > return val; > } > diff --git a/drivers/gpu/drm/i810/i810_dma.c b/drivers/gpu/drm/i810/i810_dma.c > index 576a417690d4..00b872fd27b0 100644 > --- a/drivers/gpu/drm/i810/i810_dma.c > +++ b/drivers/gpu/drm/i810/i810_dma.c > @@ -399,7 +399,7 @@ static int i810_dma_initialize(struct drm_device *dev, > DRM_ERROR("Can not allocate hardware status page\n"); > return -ENOMEM; > } > - DRM_DEBUG("hw status page @ %p\n", dev_priv->hw_status_page); > + DRM_DEBUG("hw status page @ %px\n", dev_priv->hw_status_page); > > I810_WRITE(0x02080, dev_priv->dma_status_page); > DRM_DEBUG("Enabled hardware status page\n"); > diff --git a/drivers/gpu/drm/i915/i915_perf.c b/drivers/gpu/drm/i915/i915_perf.c > index abaca6edeb71..a90ca24b03ea 100644 > --- a/drivers/gpu/drm/i915/i915_perf.c > +++ b/drivers/gpu/drm/i915/i915_perf.c > @@ -1473,7 +1473,7 @@ static int alloc_oa_buffer(struct drm_i915_private *dev_priv) > > dev_priv->perf.oa.ops.init_oa_buffer(dev_priv); > > - DRM_DEBUG_DRIVER("OA Buffer initialized, gtt offset = 0x%x, vaddr = %p\n", > + DRM_DEBUG_DRIVER("OA Buffer initialized, gtt offset = 0x%x, vaddr = %px\n", > i915_ggtt_offset(dev_priv->perf.oa.oa_buffer.vma), > dev_priv->perf.oa.oa_buffer.vaddr); > > diff --git a/drivers/gpu/drm/i915/intel_display.c b/drivers/gpu/drm/i915/intel_display.c > index 3b48fd2561fe..9759257ac614 100644 > --- a/drivers/gpu/drm/i915/intel_display.c > +++ b/drivers/gpu/drm/i915/intel_display.c > @@ -2732,7 +2732,7 @@ intel_alloc_initial_plane_obj(struct intel_crtc *crtc, > } > > > - DRM_DEBUG_KMS("initial plane fb obj %p\n", obj); > + DRM_DEBUG_KMS("initial plane fb obj %px\n", obj); > return true; > > out_unref_obj: > diff --git a/drivers/gpu/drm/i915/intel_guc_ct.c b/drivers/gpu/drm/i915/intel_guc_ct.c > index 24ad55752396..3c44c1946e66 100644 > --- a/drivers/gpu/drm/i915/intel_guc_ct.c > +++ b/drivers/gpu/drm/i915/intel_guc_ct.c > @@ -49,7 +49,7 @@ static inline const char *guc_ct_buffer_type_to_str(u32 type) > static void guc_ct_buffer_desc_init(struct guc_ct_buffer_desc *desc, > u32 cmds_addr, u32 size, u32 owner) > { > - DRM_DEBUG_DRIVER("CT: desc %p init addr=%#x size=%u owner=%u\n", > + DRM_DEBUG_DRIVER("CT: desc %px init addr=%#x size=%u owner=%u\n", > desc, cmds_addr, size, owner); > memset(desc, 0, sizeof(*desc)); > desc->addr = cmds_addr; > @@ -59,7 +59,7 @@ static void guc_ct_buffer_desc_init(struct guc_ct_buffer_desc *desc, > > static void guc_ct_buffer_desc_reset(struct guc_ct_buffer_desc *desc) > { > - DRM_DEBUG_DRIVER("CT: desc %p reset head=%u tail=%u\n", > + DRM_DEBUG_DRIVER("CT: desc %px reset head=%u tail=%u\n", > desc, desc->head, desc->tail); > desc->head = 0; > desc->tail = 0; > diff --git a/drivers/gpu/drm/i915/intel_guc_submission.c b/drivers/gpu/drm/i915/intel_guc_submission.c > index 8a8ad2fe158d..10af95e91ca1 100644 > --- a/drivers/gpu/drm/i915/intel_guc_submission.c > +++ b/drivers/gpu/drm/i915/intel_guc_submission.c > @@ -928,7 +928,7 @@ guc_client_alloc(struct drm_i915_private *dev_priv, > if (ret) > goto err_vaddr; > > - DRM_DEBUG_DRIVER("new priority %u client %p for engine(s) 0x%x: stage_id %u\n", > + DRM_DEBUG_DRIVER("new priority %u client %px for engine(s) 0x%x: stage_id %u\n", > priority, client, client->engines, client->stage_id); > DRM_DEBUG_DRIVER("doorbell id %u, cacheline offset 0x%lx\n", > client->doorbell_id, client->doorbell_offset); > diff --git a/drivers/gpu/drm/i915/intel_uc_fw.c b/drivers/gpu/drm/i915/intel_uc_fw.c > index 3ec0ce505b76..4c968078c61c 100644 > --- a/drivers/gpu/drm/i915/intel_uc_fw.c > +++ b/drivers/gpu/drm/i915/intel_uc_fw.c > @@ -64,7 +64,7 @@ void intel_uc_fw_fetch(struct drm_i915_private *dev_priv, > goto fail; > } > > - DRM_DEBUG_DRIVER("%s fw size %zu ptr %p\n", > + DRM_DEBUG_DRIVER("%s fw size %zu ptr %px\n", > intel_uc_fw_type_repr(uc_fw->type), fw->size, fw); > > /* Check the size of the blob before examining buffer contents */ > diff --git a/drivers/gpu/drm/mediatek/mtk_drm_gem.c b/drivers/gpu/drm/mediatek/mtk_drm_gem.c > index f595ac816b55..ccdec81de9e3 100644 > --- a/drivers/gpu/drm/mediatek/mtk_drm_gem.c > +++ b/drivers/gpu/drm/mediatek/mtk_drm_gem.c > @@ -71,7 +71,7 @@ struct mtk_drm_gem_obj *mtk_drm_gem_create(struct drm_device *dev, > if (alloc_kmap) > mtk_gem->kvaddr = mtk_gem->cookie; > > - DRM_DEBUG_DRIVER("cookie = %p dma_addr = %pad size = %zu\n", > + DRM_DEBUG_DRIVER("cookie = %px dma_addr = %pad size = %zu\n", > mtk_gem->cookie, &mtk_gem->dma_addr, > size); > > diff --git a/drivers/gpu/drm/mga/mga_warp.c b/drivers/gpu/drm/mga/mga_warp.c > index 0b76352260a9..5b286f04f805 100644 > --- a/drivers/gpu/drm/mga/mga_warp.c > +++ b/drivers/gpu/drm/mga/mga_warp.c > @@ -116,7 +116,7 @@ int mga_warp_install_microcode(drm_mga_private_t *dev_priv) > rec = ihex_next_binrec(rec)) { > unsigned int src_size, dst_size; > > - DRM_DEBUG(" pcbase = 0x%08lx vcbase = %p\n", pcbase, vcbase); > + DRM_DEBUG(" pcbase = 0x%08lx vcbase = %px\n", pcbase, vcbase); > dev_priv->warp_pipe_phys[where] = pcbase; > src_size = be16_to_cpu(rec->len); > dst_size = WARP_UCODE_SIZE(src_size); > diff --git a/drivers/gpu/drm/msm/msm_drv.c b/drivers/gpu/drm/msm/msm_drv.c > index 30cd514d8f7c..078e9c3183e8 100644 > --- a/drivers/gpu/drm/msm/msm_drv.c > +++ b/drivers/gpu/drm/msm/msm_drv.c > @@ -122,7 +122,7 @@ void __iomem *msm_ioremap(struct platform_device *pdev, const char *name, > } > > if (reglog) > - printk(KERN_DEBUG "IO:region %s %p %08lx\n", dbgname, ptr, size); > + printk(KERN_DEBUG "IO:region %s %px %08lx\n", dbgname, ptr, size); > > return ptr; > } > @@ -130,7 +130,7 @@ void __iomem *msm_ioremap(struct platform_device *pdev, const char *name, > void msm_writel(u32 data, void __iomem *addr) > { > if (reglog) > - printk(KERN_DEBUG "IO:W %p %08x\n", addr, data); > + printk(KERN_DEBUG "IO:W %px %08x\n", addr, data); > writel(data, addr); > } > > diff --git a/drivers/gpu/drm/qxl/qxl_cmd.c b/drivers/gpu/drm/qxl/qxl_cmd.c > index c0fb52c6d4ca..f6c64c5cb99f 100644 > --- a/drivers/gpu/drm/qxl/qxl_cmd.c > +++ b/drivers/gpu/drm/qxl/qxl_cmd.c > @@ -381,7 +381,7 @@ void qxl_io_create_primary(struct qxl_device *qdev, > { > struct qxl_surface_create *create; > > - DRM_DEBUG_DRIVER("qdev %p, ram_header %p\n", qdev, qdev->ram_header); > + DRM_DEBUG_DRIVER("qdev %px, ram_header %px\n", qdev, qdev->ram_header); > create = &qdev->ram_header->create_surface; > create->format = bo->surf.format; > create->width = bo->surf.width; > @@ -393,7 +393,7 @@ void qxl_io_create_primary(struct qxl_device *qdev, > create->mem = qxl_bo_physical_address(qdev, bo, offset); > } > > - DRM_DEBUG_DRIVER("mem = %llx, from %p\n", create->mem, bo->kptr); > + DRM_DEBUG_DRIVER("mem = %llx, from %px\n", create->mem, bo->kptr); > > create->flags = QXL_SURF_FLAG_KEEP_DATA; > create->type = QXL_SURF_TYPE_PRIMARY; > diff --git a/drivers/gpu/drm/qxl/qxl_fb.c b/drivers/gpu/drm/qxl/qxl_fb.c > index 338891401f35..ce506e702aed 100644 > --- a/drivers/gpu/drm/qxl/qxl_fb.c > +++ b/drivers/gpu/drm/qxl/qxl_fb.c > @@ -246,7 +246,7 @@ static int qxlfb_create(struct qxl_fbdev *qfbdev, > shadow = vmalloc(mode_cmd.pitches[0] * mode_cmd.height); > /* TODO: what's the usual response to memory allocation errors? */ > BUG_ON(!shadow); > - DRM_DEBUG_DRIVER("surface0 at gpu offset %lld, mmap_offset %lld (virt %p, shadow %p)\n", > + DRM_DEBUG_DRIVER("surface0 at gpu offset %lld, mmap_offset %lld (virt %px, shadow %px)\n", > qxl_bo_gpu_offset(qbo), qxl_bo_mmap_offset(qbo), > qbo->kptr, shadow); > size = mode_cmd.pitches[0] * mode_cmd.height; > diff --git a/drivers/gpu/drm/qxl/qxl_ttm.c b/drivers/gpu/drm/qxl/qxl_ttm.c > index ee2340e31f06..bbbf9433d32a 100644 > --- a/drivers/gpu/drm/qxl/qxl_ttm.c > +++ b/drivers/gpu/drm/qxl/qxl_ttm.c > @@ -133,7 +133,7 @@ int qxl_mmap(struct file *filp, struct vm_area_struct *vma) > "filp->private_data->minor->dev->dev_private == NULL\n"); > return -EINVAL; > } > - DRM_DEBUG_DRIVER("filp->private_data = 0x%p, vma->vm_pgoff = %lx\n", > + DRM_DEBUG_DRIVER("filp->private_data = 0x%px, vma->vm_pgoff = %lx\n", > filp->private_data, vma->vm_pgoff); > > r = ttm_bo_mmap(filp, vma, &qdev->mman.bdev); > diff --git a/drivers/gpu/drm/radeon/radeon_display.c b/drivers/gpu/drm/radeon/radeon_display.c > index 26129b2b082d..9f38090e89ef 100644 > --- a/drivers/gpu/drm/radeon/radeon_display.c > +++ b/drivers/gpu/drm/radeon/radeon_display.c > @@ -513,7 +513,7 @@ static int radeon_crtc_page_flip_target(struct drm_crtc *crtc, > new_rbo = gem_to_radeon_bo(obj); > > /* pin the new buffer */ > - DRM_DEBUG_DRIVER("flip-ioctl() cur_rbo = %p, new_rbo = %p\n", > + DRM_DEBUG_DRIVER("flip-ioctl() cur_rbo = %px, new_rbo = %px\n", > work->old_rbo, new_rbo); > > r = radeon_bo_reserve(new_rbo, false); > diff --git a/drivers/gpu/drm/radeon/radeon_dp_mst.c b/drivers/gpu/drm/radeon/radeon_dp_mst.c > index cd8a3ee16649..44016392115e 100644 > --- a/drivers/gpu/drm/radeon/radeon_dp_mst.c > +++ b/drivers/gpu/drm/radeon/radeon_dp_mst.c > @@ -193,7 +193,7 @@ static int radeon_dp_mst_get_ddc_modes(struct drm_connector *connector) > > edid = drm_dp_mst_get_edid(connector, &master->mst_mgr, radeon_connector->port); > radeon_connector->edid = edid; > - DRM_DEBUG_KMS("edid retrieved %p\n", edid); > + DRM_DEBUG_KMS("edid retrieved %px\n", edid); > if (radeon_connector->edid) { > drm_mode_connector_update_edid_property(&radeon_connector->base, radeon_connector->edid); > ret = drm_add_edid_modes(&radeon_connector->base, radeon_connector->edid); > @@ -348,7 +348,7 @@ radeon_connector *radeon_mst_find_connector(struct drm_encoder *encoder) > if (!radeon_connector->is_mst_connector) > continue; > > - DRM_DEBUG_KMS("checking %p vs %p\n", connector->encoder, encoder); > + DRM_DEBUG_KMS("checking %px vs %px\n", connector->encoder, encoder); > if (connector->encoder == encoder) > return radeon_connector; > } > @@ -374,7 +374,7 @@ void radeon_dp_mst_prepare_pll(struct drm_crtc *crtc, struct drm_display_mode *m > radeon_crtc->bpc = 8; > } > > - DRM_DEBUG_KMS("dp_clock %p %d\n", dig_connector, dig_connector->dp_clock); > + DRM_DEBUG_KMS("dp_clock %px %d\n", dig_connector, dig_connector->dp_clock); > dp_clock = dig_connector->dp_clock; > radeon_crtc->ss_enabled = > radeon_atombios_get_asic_ss_info(rdev, &radeon_crtc->ss, > @@ -533,7 +533,7 @@ static bool radeon_mst_mode_fixup(struct drm_encoder *encoder, > dig_connector = mst_enc->connector->con_priv; > dig_connector->dp_lane_count = drm_dp_max_lane_count(dig_connector->dpcd); > dig_connector->dp_clock = drm_dp_max_link_rate(dig_connector->dpcd); > - DRM_DEBUG_KMS("dig clock %p %d %d\n", dig_connector, > + DRM_DEBUG_KMS("dig clock %px %d %d\n", dig_connector, > dig_connector->dp_lane_count, dig_connector->dp_clock); > return true; > } > @@ -547,7 +547,7 @@ static void radeon_mst_encoder_prepare(struct drm_encoder *encoder) > > radeon_connector = radeon_mst_find_connector(encoder); > if (!radeon_connector) { > - DRM_DEBUG_KMS("failed to find connector %p\n", encoder); > + DRM_DEBUG_KMS("failed to find connector %px\n", encoder); > return; > } > radeon_encoder = to_radeon_encoder(encoder); > @@ -615,7 +615,7 @@ radeon_dp_create_fake_mst_encoder(struct radeon_connector *connector) > const struct drm_connector_helper_funcs *connector_funcs = connector->base.helper_private; > struct drm_encoder *enc_master = connector_funcs->best_encoder(&connector->base); > > - DRM_DEBUG_KMS("enc master is %p\n", enc_master); > + DRM_DEBUG_KMS("enc master is %px\n", enc_master); > radeon_encoder = kzalloc(sizeof(*radeon_encoder), GFP_KERNEL); > if (!radeon_encoder) > return NULL; > diff --git a/drivers/gpu/drm/radeon/radeon_object.c b/drivers/gpu/drm/radeon/radeon_object.c > index edbb4cd519fd..24debb2760c3 100644 > --- a/drivers/gpu/drm/radeon/radeon_object.c > +++ b/drivers/gpu/drm/radeon/radeon_object.c > @@ -639,7 +639,7 @@ int radeon_bo_get_surface_reg(struct radeon_bo *bo) > reg = &rdev->surface_regs[steal]; > old_object = reg->bo; > /* blow away the mapping */ > - DRM_DEBUG("stealing surface reg %d from %p\n", steal, old_object); > + DRM_DEBUG("stealing surface reg %d from %px\n", steal, old_object); > ttm_bo_unmap_virtual(&old_object->tbo); > old_object->surface_reg = -1; > i = steal; > diff --git a/drivers/gpu/drm/rockchip/rockchip_drm_fbdev.c b/drivers/gpu/drm/rockchip/rockchip_drm_fbdev.c > index e6650553f5d6..d90a372a6413 100644 > --- a/drivers/gpu/drm/rockchip/rockchip_drm_fbdev.c > +++ b/drivers/gpu/drm/rockchip/rockchip_drm_fbdev.c > @@ -106,7 +106,7 @@ static int rockchip_drm_fbdev_create(struct drm_fb_helper *helper, > fbi->screen_size = rk_obj->base.size; > fbi->fix.smem_len = rk_obj->base.size; > > - DRM_DEBUG_KMS("FB [%dx%d]-%d kvaddr=%p offset=%ld size=%zu\n", > + DRM_DEBUG_KMS("FB [%dx%d]-%d kvaddr=%px offset=%ld size=%zu\n", > fb->width, fb->height, fb->format->depth, > rk_obj->kvaddr, > offset, size); > diff --git a/drivers/gpu/drm/savage/savage_bci.c b/drivers/gpu/drm/savage/savage_bci.c > index 2a5b8466d806..68ac86b83d1d 100644 > --- a/drivers/gpu/drm/savage/savage_bci.c > +++ b/drivers/gpu/drm/savage/savage_bci.c > @@ -265,7 +265,7 @@ static struct drm_buf *savage_freelist_get(struct drm_device * dev) > return tail->buf; > } > > - DRM_DEBUG("returning NULL, tail->buf=%p!\n", tail->buf); > + DRM_DEBUG("returning NULL, tail->buf=%px!\n", tail->buf); > return NULL; > } > > diff --git a/drivers/gpu/drm/sti/sti_gdp.c b/drivers/gpu/drm/sti/sti_gdp.c > index 9b2c47051b51..385841c46838 100644 > --- a/drivers/gpu/drm/sti/sti_gdp.c > +++ b/drivers/gpu/drm/sti/sti_gdp.c > @@ -529,7 +529,7 @@ static void sti_gdp_init(struct sti_gdp *gdp) > gdp->node_list[i].top_field = base; > gdp->node_list[i].top_field_paddr = dma_addr; > > - DRM_DEBUG_DRIVER("node[%d].top_field=%p\n", i, base); > + DRM_DEBUG_DRIVER("node[%d].top_field=%px\n", i, base); > base += sizeof(struct sti_gdp_node); > dma_addr += sizeof(struct sti_gdp_node); > > @@ -539,7 +539,7 @@ static void sti_gdp_init(struct sti_gdp *gdp) > } > gdp->node_list[i].btm_field = base; > gdp->node_list[i].btm_field_paddr = dma_addr; > - DRM_DEBUG_DRIVER("node[%d].btm_field=%p\n", i, base); > + DRM_DEBUG_DRIVER("node[%d].btm_field=%px\n", i, base); > base += sizeof(struct sti_gdp_node); > dma_addr += sizeof(struct sti_gdp_node); > } > diff --git a/drivers/gpu/drm/sti/sti_mixer.c b/drivers/gpu/drm/sti/sti_mixer.c > index a4f45c74d678..6ea5f81dd9db 100644 > --- a/drivers/gpu/drm/sti/sti_mixer.c > +++ b/drivers/gpu/drm/sti/sti_mixer.c > @@ -367,7 +367,7 @@ struct sti_mixer *sti_mixer_create(struct device *dev, > mixer->dev = dev; > mixer->id = id; > > - DRM_DEBUG_DRIVER("%s created. Regs=%p\n", > + DRM_DEBUG_DRIVER("%s created. Regs=%px\n", > sti_mixer_to_str(mixer), mixer->regs); > > return mixer; > diff --git a/drivers/gpu/drm/sun4i/sun4i_crtc.c b/drivers/gpu/drm/sun4i/sun4i_crtc.c > index 2d7c57406715..1d1994409809 100644 > --- a/drivers/gpu/drm/sun4i/sun4i_crtc.c > +++ b/drivers/gpu/drm/sun4i/sun4i_crtc.c > @@ -159,7 +159,7 @@ static int sun4i_crtc_enable_vblank(struct drm_crtc *crtc) > { > struct sun4i_crtc *scrtc = drm_crtc_to_sun4i_crtc(crtc); > > - DRM_DEBUG_DRIVER("Enabling VBLANK on crtc %p\n", crtc); > + DRM_DEBUG_DRIVER("Enabling VBLANK on crtc %px\n", crtc); > > sun4i_tcon_enable_vblank(scrtc->tcon, true); > > @@ -170,7 +170,7 @@ static void sun4i_crtc_disable_vblank(struct drm_crtc *crtc) > { > struct sun4i_crtc *scrtc = drm_crtc_to_sun4i_crtc(crtc); > > - DRM_DEBUG_DRIVER("Disabling VBLANK on crtc %p\n", crtc); > + DRM_DEBUG_DRIVER("Disabling VBLANK on crtc %px\n", crtc); > > sun4i_tcon_enable_vblank(scrtc->tcon, false); > } > diff --git a/drivers/gpu/drm/ttm/ttm_page_alloc.c b/drivers/gpu/drm/ttm/ttm_page_alloc.c > index f0481b7b60c5..32b3c1b42115 100644 > --- a/drivers/gpu/drm/ttm/ttm_page_alloc.c > +++ b/drivers/gpu/drm/ttm/ttm_page_alloc.c > @@ -658,7 +658,7 @@ static void ttm_page_pool_fill_locked(struct ttm_page_pool *pool, int ttm_flags, > ++pool->nrefills; > pool->npages += alloc_size; > } else { > - pr_debug("Failed to fill pool (%p)\n", pool); > + pr_debug("Failed to fill pool (%px)\n", pool); > /* If we have any pages left put them to the pool. */ > list_for_each_entry(p, &new_pages, lru) { > ++cpages; > diff --git a/drivers/gpu/drm/udl/udl_fb.c b/drivers/gpu/drm/udl/udl_fb.c > index 2ebdc6d5a76e..7032206c103f 100644 > --- a/drivers/gpu/drm/udl/udl_fb.c > +++ b/drivers/gpu/drm/udl/udl_fb.c > @@ -406,7 +406,7 @@ static int udlfb_create(struct drm_fb_helper *helper, > drm_fb_helper_fill_fix(info, fb->pitches[0], fb->format->depth); > drm_fb_helper_fill_var(info, &ufbdev->helper, sizes->fb_width, sizes->fb_height); > > - DRM_DEBUG_KMS("allocated %dx%d vmal %p\n", > + DRM_DEBUG_KMS("allocated %dx%d vmal %px\n", > fb->width, fb->height, > ufbdev->ufb.obj->vmapping); > > diff --git a/drivers/gpu/drm/via/via_dma.c b/drivers/gpu/drm/via/via_dma.c > index d17d8f245c1a..5d5e322b7c48 100644 > --- a/drivers/gpu/drm/via/via_dma.c > +++ b/drivers/gpu/drm/via/via_dma.c > @@ -332,7 +332,7 @@ static int via_cmdbuffer(struct drm_device *dev, void *data, struct drm_file *fi > > LOCK_TEST_WITH_RETURN(dev, file_priv); > > - DRM_DEBUG("buf %p size %lu\n", cmdbuf->buf, cmdbuf->size); > + DRM_DEBUG("buf %px size %lu\n", cmdbuf->buf, cmdbuf->size); > > ret = via_dispatch_cmdbuffer(dev, cmdbuf); > return ret; > @@ -368,7 +368,7 @@ static int via_pci_cmdbuffer(struct drm_device *dev, void *data, struct drm_file > > LOCK_TEST_WITH_RETURN(dev, file_priv); > > - DRM_DEBUG("buf %p size %lu\n", cmdbuf->buf, cmdbuf->size); > + DRM_DEBUG("buf %px size %lu\n", cmdbuf->buf, cmdbuf->size); > > ret = via_dispatch_pci_cmdbuffer(dev, cmdbuf); > return ret; > diff --git a/drivers/gpu/drm/via/via_irq.c b/drivers/gpu/drm/via/via_irq.c > index c96830ccc0ec..1c36ebfe2c45 100644 > --- a/drivers/gpu/drm/via/via_irq.c > +++ b/drivers/gpu/drm/via/via_irq.c > @@ -259,7 +259,7 @@ void via_driver_irq_preinstall(struct drm_device *dev) > drm_via_irq_t *cur_irq; > int i; > > - DRM_DEBUG("dev_priv: %p\n", dev_priv); > + DRM_DEBUG("dev_priv: %px\n", dev_priv); > if (dev_priv) { > cur_irq = dev_priv->via_irqs; > > diff --git a/drivers/gpu/drm/vmwgfx/vmwgfx_overlay.c b/drivers/gpu/drm/vmwgfx/vmwgfx_overlay.c > index 222c9c2123a1..edfe750b300b 100644 > --- a/drivers/gpu/drm/vmwgfx/vmwgfx_overlay.c > +++ b/drivers/gpu/drm/vmwgfx/vmwgfx_overlay.c > @@ -308,7 +308,7 @@ static int vmw_overlay_update_stream(struct vmw_private *dev_priv, > if (!buf) > return -EINVAL; > > - DRM_DEBUG(" %s: old %p, new %p, %spaused\n", __func__, > + DRM_DEBUG(" %s: old %px, new %px, %spaused\n", __func__, > stream->buf, buf, stream->paused ? "" : "not "); > > if (stream->buf != buf) {