From mboxrd@z Thu Jan 1 00:00:00 1970 From: =?UTF-8?Q?Christian_K=c3=b6nig?= Subject: Re: [PATCH] gpu: Consistently use octal not symbolic permissions Date: Fri, 25 May 2018 08:46:39 +0200 Message-ID: References: <9b0f5f5cf6bccc003beef82f0972be655613075d.1527193246.git.joe@perches.com> Reply-To: christian.koenig@amd.com Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8"; Format="flowed" Content-Transfer-Encoding: base64 Return-path: In-Reply-To: <9b0f5f5cf6bccc003beef82f0972be655613075d.1527193246.git.joe@perches.com> Content-Language: en-US List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: intel-gfx-bounces@lists.freedesktop.org Sender: "Intel-gfx" To: Joe Perches , Russell King , Gustavo Padovan , Maarten Lankhorst , Sean Paul , David Airlie , Zhenyu Wang , Zhi Wang , Jani Nikula , Joonas Lahtinen , Rodrigo Vivi , Rob Clark , Ben Skeggs , Alex Deucher , =?UTF-8?Q?Christian_K=c3=b6nig?= , "David (ChunMing) Zhou" , Benjamin Gaignard , Vincent Abriou , =?UTF-8?Q?Noralf_Tr=c3=b8nnes?= , Roger He , Dave Airlie , Thierry Reding Cc: intel-gvt-dev@lists.freedesktop.org, linux-arm-msm@vger.kernel.org, intel-gfx@lists.freedesktop.org, linux-kernel@vger.kernel.org, dri-devel@lists.freedesktop.org, Tomi Valkeinen , amd-gfx@lists.freedesktop.org, nouveau@lists.freedesktop.org, linux-tegra@vger.kernel.org, freedreno@lists.freedesktop.org List-Id: amd-gfx.lists.freedesktop.org V2VsbCBJIHRoaW5rIHdlIHJlamVjdGVkIHRoYXQgbXVsdGlwbGUgdGltZXMgbm93LgoKQXQgbGVh c3QgSSBmaW5kIHRoZSBzeW1ib2xpYyBwZXJtaXNzaW9ucyBlYXNpZXIgdG8gcmVhZCBhbmQgSSBh YnNvbHV0ZWx5IApkb24ndCBzZWUgYW55IHJlYXNvbiB3aHkgd2Ugc2hvdWxkIG9ubHkgdXNlIG9u ZSBmb3JtLgoKQ2hyaXN0aWFuLgoKQW0gMjQuMDUuMjAxOCB1bSAyMjoyMiBzY2hyaWViIEpvZSBQ ZXJjaGVzOgo+IFRoZXJlIGlzIGN1cnJlbnRseSBhIG1peHR1cmUgb2Ygb2N0YWwgYW5kIHN5bWJv bGljIHBlcm1pc3Npb25zIHVzZXMKPiBpbiBmaWxlcyBpbiBkcml2ZXJzL2dwdS9kcm0gYW5kIG9u ZSBmaWxlIGluIGRyaXZlcnMvZ3B1Lgo+Cj4gVGhlcmUgYXJlIH4yNzAgZXhpc3Rpbmcgb2N0YWwg dXNlcyBhbmQgfjExNSBTXzxGT08+IHVzZXMuCj4KPiBDb252ZXJ0IGFsbCB0aGUgU188Rk9PPiBz eW1ib2xpYyBwZXJtaXNzaW9ucyB0byB0aGVpciBvY3RhbCBlcXVpdmFsZW50cwo+IGFzIHVzaW5n IG9jdGFsIGFuZCBub3Qgc3ltYm9saWMgcGVybWlzc2lvbnMgaXMgcHJlZmVycmVkIGJ5IG1hbnkg YXMgbW9yZQo+IHJlYWRhYmxlLgo+Cj4gc2VlOiBodHRwczovL2xrbWwub3JnL2xrbWwvMjAxNi84 LzIvMTk0NQo+Cj4gRG9uZSB3aXRoIGF1dG9tYXRlZCBjb252ZXJzaW9uIHZpYToKPiAkIC4vc2Ny aXB0cy9jaGVja3BhdGNoLnBsIC1mIC0tdHlwZXM9U1lNQk9MSUNfUEVSTVMgLS1maXgtaW5wbGFj ZSA8ZmlsZXMuLi4+Cj4KPiBNaXNjZWxsYW5lYToKPgo+IG8gV3JhcHBlZCBtb2RpZmllZCBtdWx0 aS1saW5lIGNhbGxzIHRvIGEgc2luZ2xlIGxpbmUgd2hlcmUgYXBwcm9wcmlhdGUKPiBvIFJlYWxp Z24gbW9kaWZpZWQgbXVsdGktbGluZSBjYWxscyB0byBvcGVuIHBhcmVudGhlc2lzCj4gbyBkcml2 ZXJzL2dwdS9kcm0vbXNtL2FkcmVuby9hNXh4X2RlYnVnZnMuYyBoYXMgYSB3b3JsZC13cml0ZWFi bGUKPiAgICBkZWJ1ZyBwZXJtaXNzaW9uIGZvciAicmVzZXQiIC0gcGVyaGFwcyB0aGF0IHNob3Vs ZCBiZSBtb2RpZmllZAo+Cj4gU2lnbmVkLW9mZi1ieTogSm9lIFBlcmNoZXMgPGpvZUBwZXJjaGVz LmNvbT4KPiAtLS0KPiAgIGRyaXZlcnMvZ3B1L2RybS9hbWQvYW1kZ3B1L2FtZGdwdV9kZWJ1Z2Zz LmMgICAgICAgIHwgIDIgKy0KPiAgIGRyaXZlcnMvZ3B1L2RybS9hbWQvYW1kZ3B1L2FtZGdwdV9w bS5jICAgICAgICAgICAgIHwgOTggKysrKysrKysrKystLS0tLS0tLS0tLQo+ICAgZHJpdmVycy9n cHUvZHJtL2FtZC9hbWRncHUvYW1kZ3B1X3JpbmcuYyAgICAgICAgICAgfCAgMyArLQo+ICAgZHJp dmVycy9ncHUvZHJtL2FtZC9hbWRncHUvYW1kZ3B1X3R0bS5jICAgICAgICAgICAgfCAgOSArLQo+ ICAgZHJpdmVycy9ncHUvZHJtL2FybWFkYS9hcm1hZGFfZGVidWdmcy5jICAgICAgICAgICAgfCAg NCArLQo+ICAgZHJpdmVycy9ncHUvZHJtL2RybV9kZWJ1Z2ZzLmMgICAgICAgICAgICAgICAgICAg ICAgfCAgNiArLQo+ICAgZHJpdmVycy9ncHUvZHJtL2RybV9kZWJ1Z2ZzX2NyYy5jICAgICAgICAg ICAgICAgICAgfCAgNCArLQo+ICAgZHJpdmVycy9ncHUvZHJtL2RybV9zeXNmcy5jICAgICAgICAg ICAgICAgICAgICAgICAgfCAgMiArLQo+ICAgZHJpdmVycy9ncHUvZHJtL2k5MTUvZ3Z0L2Zpcm13 YXJlLmMgICAgICAgICAgICAgICAgfCAgMiArLQo+ICAgZHJpdmVycy9ncHUvZHJtL2k5MTUvaTkx NV9kZWJ1Z2ZzLmMgICAgICAgICAgICAgICAgfCAgOCArLQo+ICAgZHJpdmVycy9ncHUvZHJtL2k5 MTUvaTkxNV9wZXJmLmMgICAgICAgICAgICAgICAgICAgfCAgMiArLQo+ICAgZHJpdmVycy9ncHUv ZHJtL2k5MTUvaTkxNV9zeXNmcy5jICAgICAgICAgICAgICAgICAgfCAyMiArKy0tLQo+ICAgZHJp dmVycy9ncHUvZHJtL2k5MTUvaW50ZWxfcGlwZV9jcmMuYyAgICAgICAgICAgICAgfCAgMiArLQo+ ICAgZHJpdmVycy9ncHUvZHJtL21zbS9hZHJlbm8vYTV4eF9kZWJ1Z2ZzLmMgICAgICAgICAgfCAg NSArLQo+ICAgZHJpdmVycy9ncHUvZHJtL21zbS9tc21fcGVyZi5jICAgICAgICAgICAgICAgICAg ICAgfCAgNCArLQo+ICAgZHJpdmVycy9ncHUvZHJtL21zbS9tc21fcmQuYyAgICAgICAgICAgICAg ICAgICAgICAgfCAgNCArLQo+ICAgZHJpdmVycy9ncHUvZHJtL25vdXZlYXUvbm91dmVhdV9kZWJ1 Z2ZzLmMgICAgICAgICAgfCAgMiArLQo+ICAgZHJpdmVycy9ncHUvZHJtL29tYXBkcm0vZGlzcGxh eXMvcGFuZWwtZHNpLWNtLmMgICAgfCAxMSArKy0KPiAgIC4uLi9kcm0vb21hcGRybS9kaXNwbGF5 cy9wYW5lbC1zb255LWFjeDU2NWFrbS5jICAgIHwgIDYgKy0KPiAgIC4uLi9kcm0vb21hcGRybS9k aXNwbGF5cy9wYW5lbC10cG8tdGQwNDNtdGVhMS5jICAgIHwgMTAgKy0tCj4gICBkcml2ZXJzL2dw dS9kcm0vcmFkZW9uL3JhZGVvbl9wbS5jICAgICAgICAgICAgICAgICB8IDI2ICsrKy0tLQo+ICAg ZHJpdmVycy9ncHUvZHJtL3JhZGVvbi9yYWRlb25fdHRtLmMgICAgICAgICAgICAgICAgfCAgNCAr LQo+ICAgZHJpdmVycy9ncHUvZHJtL3N0aS9zdGlfZHJ2LmMgICAgICAgICAgICAgICAgICAgICAg fCAgMiArLQo+ICAgZHJpdmVycy9ncHUvZHJtL3Rpbnlkcm0vbWlwaS1kYmkuYyAgICAgICAgICAg ICAgICAgfCAgNCArLQo+ICAgZHJpdmVycy9ncHUvZHJtL3R0bS90dG1fYm8uYyAgICAgICAgICAg ICAgICAgICAgICAgfCAgMiArLQo+ICAgZHJpdmVycy9ncHUvZHJtL3R0bS90dG1fbWVtb3J5LmMg ICAgICAgICAgICAgICAgICAgfCAxMiArLS0KPiAgIGRyaXZlcnMvZ3B1L2RybS90dG0vdHRtX3Bh Z2VfYWxsb2MuYyAgICAgICAgICAgICAgIHwgIDYgKy0KPiAgIGRyaXZlcnMvZ3B1L2RybS90dG0v dHRtX3BhZ2VfYWxsb2NfZG1hLmMgICAgICAgICAgIHwgIDYgKy0KPiAgIGRyaXZlcnMvZ3B1L2Ry bS91ZGwvdWRsX2ZiLmMgICAgICAgICAgICAgICAgICAgICAgIHwgIDQgKy0KPiAgIGRyaXZlcnMv Z3B1L2hvc3QxeC9kZWJ1Zy5jICAgICAgICAgICAgICAgICAgICAgICAgIHwgMTIgKy0tCj4gICAz MCBmaWxlcyBjaGFuZ2VkLCAxMzggaW5zZXJ0aW9ucygrKSwgMTQ2IGRlbGV0aW9ucygtKQo+Cj4g ZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2RybS9hbWQvYW1kZ3B1L2FtZGdwdV9kZWJ1Z2ZzLmMg Yi9kcml2ZXJzL2dwdS9kcm0vYW1kL2FtZGdwdS9hbWRncHVfZGVidWdmcy5jCj4gaW5kZXggZjVm YjkzNzk1YTY5Li43YjI5ZmViZmY1MTEgMTAwNjQ0Cj4gLS0tIGEvZHJpdmVycy9ncHUvZHJtL2Ft ZC9hbWRncHUvYW1kZ3B1X2RlYnVnZnMuYwo+ICsrKyBiL2RyaXZlcnMvZ3B1L2RybS9hbWQvYW1k Z3B1L2FtZGdwdV9kZWJ1Z2ZzLmMKPiBAQCAtODMwLDcgKzgzMCw3IEBAIGludCBhbWRncHVfZGVi dWdmc19yZWdzX2luaXQoc3RydWN0IGFtZGdwdV9kZXZpY2UgKmFkZXYpCj4gICAKPiAgIAlmb3Ig KGkgPSAwOyBpIDwgQVJSQVlfU0laRShkZWJ1Z2ZzX3JlZ3MpOyBpKyspIHsKPiAgIAkJZW50ID0g ZGVidWdmc19jcmVhdGVfZmlsZShkZWJ1Z2ZzX3JlZ3NfbmFtZXNbaV0sCj4gLQkJCQkJICBTX0lG UkVHIHwgU19JUlVHTywgcm9vdCwKPiArCQkJCQkgIFNfSUZSRUcgfCAwNDQ0LCByb290LAo+ICAg CQkJCQkgIGFkZXYsIGRlYnVnZnNfcmVnc1tpXSk7Cj4gICAJCWlmIChJU19FUlIoZW50KSkgewo+ ICAgCQkJZm9yIChqID0gMDsgaiA8IGk7IGorKykgewo+IGRpZmYgLS1naXQgYS9kcml2ZXJzL2dw dS9kcm0vYW1kL2FtZGdwdS9hbWRncHVfcG0uYyBiL2RyaXZlcnMvZ3B1L2RybS9hbWQvYW1kZ3B1 L2FtZGdwdV9wbS5jCj4gaW5kZXggYjQ1NWRhNDg3NzgyLi5mYTU1ZDdlOWU3ODQgMTAwNjQ0Cj4g LS0tIGEvZHJpdmVycy9ncHUvZHJtL2FtZC9hbWRncHUvYW1kZ3B1X3BtLmMKPiArKysgYi9kcml2 ZXJzL2dwdS9kcm0vYW1kL2FtZGdwdS9hbWRncHVfcG0uYwo+IEBAIC05MDUsMzkgKzkwNSwzOSBA QCBzdGF0aWMgc3NpemVfdCBhbWRncHVfc2V0X3BwX3Bvd2VyX3Byb2ZpbGVfbW9kZShzdHJ1Y3Qg ZGV2aWNlICpkZXYsCj4gICAJcmV0dXJuIC1FSU5WQUw7Cj4gICB9Cj4gICAKPiAtc3RhdGljIERF VklDRV9BVFRSKHBvd2VyX2RwbV9zdGF0ZSwgU19JUlVHTyB8IFNfSVdVU1IsIGFtZGdwdV9nZXRf ZHBtX3N0YXRlLCBhbWRncHVfc2V0X2RwbV9zdGF0ZSk7Cj4gLXN0YXRpYyBERVZJQ0VfQVRUUihw b3dlcl9kcG1fZm9yY2VfcGVyZm9ybWFuY2VfbGV2ZWwsIFNfSVJVR08gfCBTX0lXVVNSLAo+ICtz dGF0aWMgREVWSUNFX0FUVFIocG93ZXJfZHBtX3N0YXRlLCAwNjQ0LCBhbWRncHVfZ2V0X2RwbV9z dGF0ZSwgYW1kZ3B1X3NldF9kcG1fc3RhdGUpOwo+ICtzdGF0aWMgREVWSUNFX0FUVFIocG93ZXJf ZHBtX2ZvcmNlX3BlcmZvcm1hbmNlX2xldmVsLCAwNjQ0LAo+ICAgCQkgICBhbWRncHVfZ2V0X2Rw bV9mb3JjZWRfcGVyZm9ybWFuY2VfbGV2ZWwsCj4gICAJCSAgIGFtZGdwdV9zZXRfZHBtX2ZvcmNl ZF9wZXJmb3JtYW5jZV9sZXZlbCk7Cj4gLXN0YXRpYyBERVZJQ0VfQVRUUihwcF9udW1fc3RhdGVz LCBTX0lSVUdPLCBhbWRncHVfZ2V0X3BwX251bV9zdGF0ZXMsIE5VTEwpOwo+IC1zdGF0aWMgREVW SUNFX0FUVFIocHBfY3VyX3N0YXRlLCBTX0lSVUdPLCBhbWRncHVfZ2V0X3BwX2N1cl9zdGF0ZSwg TlVMTCk7Cj4gLXN0YXRpYyBERVZJQ0VfQVRUUihwcF9mb3JjZV9zdGF0ZSwgU19JUlVHTyB8IFNf SVdVU1IsCj4gLQkJYW1kZ3B1X2dldF9wcF9mb3JjZV9zdGF0ZSwKPiAtCQlhbWRncHVfc2V0X3Bw X2ZvcmNlX3N0YXRlKTsKPiAtc3RhdGljIERFVklDRV9BVFRSKHBwX3RhYmxlLCBTX0lSVUdPIHwg U19JV1VTUiwKPiAtCQlhbWRncHVfZ2V0X3BwX3RhYmxlLAo+IC0JCWFtZGdwdV9zZXRfcHBfdGFi bGUpOwo+IC1zdGF0aWMgREVWSUNFX0FUVFIocHBfZHBtX3NjbGssIFNfSVJVR08gfCBTX0lXVVNS LAo+IC0JCWFtZGdwdV9nZXRfcHBfZHBtX3NjbGssCj4gLQkJYW1kZ3B1X3NldF9wcF9kcG1fc2Ns ayk7Cj4gLXN0YXRpYyBERVZJQ0VfQVRUUihwcF9kcG1fbWNsaywgU19JUlVHTyB8IFNfSVdVU1Is Cj4gLQkJYW1kZ3B1X2dldF9wcF9kcG1fbWNsaywKPiAtCQlhbWRncHVfc2V0X3BwX2RwbV9tY2xr KTsKPiAtc3RhdGljIERFVklDRV9BVFRSKHBwX2RwbV9wY2llLCBTX0lSVUdPIHwgU19JV1VTUiwK PiAtCQlhbWRncHVfZ2V0X3BwX2RwbV9wY2llLAo+IC0JCWFtZGdwdV9zZXRfcHBfZHBtX3BjaWUp Owo+IC1zdGF0aWMgREVWSUNFX0FUVFIocHBfc2Nsa19vZCwgU19JUlVHTyB8IFNfSVdVU1IsCj4g LQkJYW1kZ3B1X2dldF9wcF9zY2xrX29kLAo+IC0JCWFtZGdwdV9zZXRfcHBfc2Nsa19vZCk7Cj4g LXN0YXRpYyBERVZJQ0VfQVRUUihwcF9tY2xrX29kLCBTX0lSVUdPIHwgU19JV1VTUiwKPiAtCQlh bWRncHVfZ2V0X3BwX21jbGtfb2QsCj4gLQkJYW1kZ3B1X3NldF9wcF9tY2xrX29kKTsKPiAtc3Rh dGljIERFVklDRV9BVFRSKHBwX3Bvd2VyX3Byb2ZpbGVfbW9kZSwgU19JUlVHTyB8IFNfSVdVU1Is Cj4gLQkJYW1kZ3B1X2dldF9wcF9wb3dlcl9wcm9maWxlX21vZGUsCj4gLQkJYW1kZ3B1X3NldF9w cF9wb3dlcl9wcm9maWxlX21vZGUpOwo+IC1zdGF0aWMgREVWSUNFX0FUVFIocHBfb2RfY2xrX3Zv bHRhZ2UsIFNfSVJVR08gfCBTX0lXVVNSLAo+IC0JCWFtZGdwdV9nZXRfcHBfb2RfY2xrX3ZvbHRh Z2UsCj4gLQkJYW1kZ3B1X3NldF9wcF9vZF9jbGtfdm9sdGFnZSk7Cj4gK3N0YXRpYyBERVZJQ0Vf QVRUUihwcF9udW1fc3RhdGVzLCAwNDQ0LCBhbWRncHVfZ2V0X3BwX251bV9zdGF0ZXMsIE5VTEwp Owo+ICtzdGF0aWMgREVWSUNFX0FUVFIocHBfY3VyX3N0YXRlLCAwNDQ0LCBhbWRncHVfZ2V0X3Bw X2N1cl9zdGF0ZSwgTlVMTCk7Cj4gK3N0YXRpYyBERVZJQ0VfQVRUUihwcF9mb3JjZV9zdGF0ZSwg MDY0NCwKPiArCQkgICBhbWRncHVfZ2V0X3BwX2ZvcmNlX3N0YXRlLAo+ICsJCSAgIGFtZGdwdV9z ZXRfcHBfZm9yY2Vfc3RhdGUpOwo+ICtzdGF0aWMgREVWSUNFX0FUVFIocHBfdGFibGUsIDA2NDQs Cj4gKwkJICAgYW1kZ3B1X2dldF9wcF90YWJsZSwKPiArCQkgICBhbWRncHVfc2V0X3BwX3RhYmxl KTsKPiArc3RhdGljIERFVklDRV9BVFRSKHBwX2RwbV9zY2xrLCAwNjQ0LAo+ICsJCSAgIGFtZGdw dV9nZXRfcHBfZHBtX3NjbGssCj4gKwkJICAgYW1kZ3B1X3NldF9wcF9kcG1fc2Nsayk7Cj4gK3N0 YXRpYyBERVZJQ0VfQVRUUihwcF9kcG1fbWNsaywgMDY0NCwKPiArCQkgICBhbWRncHVfZ2V0X3Bw X2RwbV9tY2xrLAo+ICsJCSAgIGFtZGdwdV9zZXRfcHBfZHBtX21jbGspOwo+ICtzdGF0aWMgREVW SUNFX0FUVFIocHBfZHBtX3BjaWUsIDA2NDQsCj4gKwkJICAgYW1kZ3B1X2dldF9wcF9kcG1fcGNp ZSwKPiArCQkgICBhbWRncHVfc2V0X3BwX2RwbV9wY2llKTsKPiArc3RhdGljIERFVklDRV9BVFRS KHBwX3NjbGtfb2QsIDA2NDQsCj4gKwkJICAgYW1kZ3B1X2dldF9wcF9zY2xrX29kLAo+ICsJCSAg IGFtZGdwdV9zZXRfcHBfc2Nsa19vZCk7Cj4gK3N0YXRpYyBERVZJQ0VfQVRUUihwcF9tY2xrX29k LCAwNjQ0LAo+ICsJCSAgIGFtZGdwdV9nZXRfcHBfbWNsa19vZCwKPiArCQkgICBhbWRncHVfc2V0 X3BwX21jbGtfb2QpOwo+ICtzdGF0aWMgREVWSUNFX0FUVFIocHBfcG93ZXJfcHJvZmlsZV9tb2Rl LCAwNjQ0LAo+ICsJCSAgIGFtZGdwdV9nZXRfcHBfcG93ZXJfcHJvZmlsZV9tb2RlLAo+ICsJCSAg IGFtZGdwdV9zZXRfcHBfcG93ZXJfcHJvZmlsZV9tb2RlKTsKPiArc3RhdGljIERFVklDRV9BVFRS KHBwX29kX2Nsa192b2x0YWdlLCAwNjQ0LAo+ICsJCSAgIGFtZGdwdV9nZXRfcHBfb2RfY2xrX3Zv bHRhZ2UsCj4gKwkJICAgYW1kZ3B1X3NldF9wcF9vZF9jbGtfdm9sdGFnZSk7Cj4gICAKPiAgIHN0 YXRpYyBzc2l6ZV90IGFtZGdwdV9od21vbl9zaG93X3RlbXAoc3RydWN0IGRldmljZSAqZGV2LAo+ ICAgCQkJCSAgICAgIHN0cnVjdCBkZXZpY2VfYXR0cmlidXRlICphdHRyLAo+IEBAIC0xMzIwLDIy ICsxMzIwLDIyIEBAIHN0YXRpYyBzc2l6ZV90IGFtZGdwdV9od21vbl9zZXRfcG93ZXJfY2FwKHN0 cnVjdCBkZXZpY2UgKmRldiwKPiAgICAqCj4gICAgKi8KPiAgIAo+IC1zdGF0aWMgU0VOU09SX0RF VklDRV9BVFRSKHRlbXAxX2lucHV0LCBTX0lSVUdPLCBhbWRncHVfaHdtb25fc2hvd190ZW1wLCBO VUxMLCAwKTsKPiAtc3RhdGljIFNFTlNPUl9ERVZJQ0VfQVRUUih0ZW1wMV9jcml0LCBTX0lSVUdP LCBhbWRncHVfaHdtb25fc2hvd190ZW1wX3RocmVzaCwgTlVMTCwgMCk7Cj4gLXN0YXRpYyBTRU5T T1JfREVWSUNFX0FUVFIodGVtcDFfY3JpdF9oeXN0LCBTX0lSVUdPLCBhbWRncHVfaHdtb25fc2hv d190ZW1wX3RocmVzaCwgTlVMTCwgMSk7Cj4gLXN0YXRpYyBTRU5TT1JfREVWSUNFX0FUVFIocHdt MSwgU19JUlVHTyB8IFNfSVdVU1IsIGFtZGdwdV9od21vbl9nZXRfcHdtMSwgYW1kZ3B1X2h3bW9u X3NldF9wd20xLCAwKTsKPiAtc3RhdGljIFNFTlNPUl9ERVZJQ0VfQVRUUihwd20xX2VuYWJsZSwg U19JUlVHTyB8IFNfSVdVU1IsIGFtZGdwdV9od21vbl9nZXRfcHdtMV9lbmFibGUsIGFtZGdwdV9o d21vbl9zZXRfcHdtMV9lbmFibGUsIDApOwo+IC1zdGF0aWMgU0VOU09SX0RFVklDRV9BVFRSKHB3 bTFfbWluLCBTX0lSVUdPLCBhbWRncHVfaHdtb25fZ2V0X3B3bTFfbWluLCBOVUxMLCAwKTsKPiAt c3RhdGljIFNFTlNPUl9ERVZJQ0VfQVRUUihwd20xX21heCwgU19JUlVHTywgYW1kZ3B1X2h3bW9u X2dldF9wd20xX21heCwgTlVMTCwgMCk7Cj4gLXN0YXRpYyBTRU5TT1JfREVWSUNFX0FUVFIoZmFu MV9pbnB1dCwgU19JUlVHTywgYW1kZ3B1X2h3bW9uX2dldF9mYW4xX2lucHV0LCBOVUxMLCAwKTsK PiAtc3RhdGljIFNFTlNPUl9ERVZJQ0VfQVRUUihpbjBfaW5wdXQsIFNfSVJVR08sIGFtZGdwdV9o d21vbl9zaG93X3ZkZGdmeCwgTlVMTCwgMCk7Cj4gLXN0YXRpYyBTRU5TT1JfREVWSUNFX0FUVFIo aW4wX2xhYmVsLCBTX0lSVUdPLCBhbWRncHVfaHdtb25fc2hvd192ZGRnZnhfbGFiZWwsIE5VTEws IDApOwo+IC1zdGF0aWMgU0VOU09SX0RFVklDRV9BVFRSKGluMV9pbnB1dCwgU19JUlVHTywgYW1k Z3B1X2h3bW9uX3Nob3dfdmRkbmIsIE5VTEwsIDApOwo+IC1zdGF0aWMgU0VOU09SX0RFVklDRV9B VFRSKGluMV9sYWJlbCwgU19JUlVHTywgYW1kZ3B1X2h3bW9uX3Nob3dfdmRkbmJfbGFiZWwsIE5V TEwsIDApOwo+IC1zdGF0aWMgU0VOU09SX0RFVklDRV9BVFRSKHBvd2VyMV9hdmVyYWdlLCBTX0lS VUdPLCBhbWRncHVfaHdtb25fc2hvd19wb3dlcl9hdmcsIE5VTEwsIDApOwo+IC1zdGF0aWMgU0VO U09SX0RFVklDRV9BVFRSKHBvd2VyMV9jYXBfbWF4LCBTX0lSVUdPLCBhbWRncHVfaHdtb25fc2hv d19wb3dlcl9jYXBfbWF4LCBOVUxMLCAwKTsKPiAtc3RhdGljIFNFTlNPUl9ERVZJQ0VfQVRUUihw b3dlcjFfY2FwX21pbiwgU19JUlVHTywgYW1kZ3B1X2h3bW9uX3Nob3dfcG93ZXJfY2FwX21pbiwg TlVMTCwgMCk7Cj4gLXN0YXRpYyBTRU5TT1JfREVWSUNFX0FUVFIocG93ZXIxX2NhcCwgU19JUlVH TyB8IFNfSVdVU1IsIGFtZGdwdV9od21vbl9zaG93X3Bvd2VyX2NhcCwgYW1kZ3B1X2h3bW9uX3Nl dF9wb3dlcl9jYXAsIDApOwo+ICtzdGF0aWMgU0VOU09SX0RFVklDRV9BVFRSKHRlbXAxX2lucHV0 LCAwNDQ0LCBhbWRncHVfaHdtb25fc2hvd190ZW1wLCBOVUxMLCAwKTsKPiArc3RhdGljIFNFTlNP Ul9ERVZJQ0VfQVRUUih0ZW1wMV9jcml0LCAwNDQ0LCBhbWRncHVfaHdtb25fc2hvd190ZW1wX3Ro cmVzaCwgTlVMTCwgMCk7Cj4gK3N0YXRpYyBTRU5TT1JfREVWSUNFX0FUVFIodGVtcDFfY3JpdF9o eXN0LCAwNDQ0LCBhbWRncHVfaHdtb25fc2hvd190ZW1wX3RocmVzaCwgTlVMTCwgMSk7Cj4gK3N0 YXRpYyBTRU5TT1JfREVWSUNFX0FUVFIocHdtMSwgMDY0NCwgYW1kZ3B1X2h3bW9uX2dldF9wd20x LCBhbWRncHVfaHdtb25fc2V0X3B3bTEsIDApOwo+ICtzdGF0aWMgU0VOU09SX0RFVklDRV9BVFRS KHB3bTFfZW5hYmxlLCAwNjQ0LCBhbWRncHVfaHdtb25fZ2V0X3B3bTFfZW5hYmxlLCBhbWRncHVf aHdtb25fc2V0X3B3bTFfZW5hYmxlLCAwKTsKPiArc3RhdGljIFNFTlNPUl9ERVZJQ0VfQVRUUihw d20xX21pbiwgMDQ0NCwgYW1kZ3B1X2h3bW9uX2dldF9wd20xX21pbiwgTlVMTCwgMCk7Cj4gK3N0 YXRpYyBTRU5TT1JfREVWSUNFX0FUVFIocHdtMV9tYXgsIDA0NDQsIGFtZGdwdV9od21vbl9nZXRf cHdtMV9tYXgsIE5VTEwsIDApOwo+ICtzdGF0aWMgU0VOU09SX0RFVklDRV9BVFRSKGZhbjFfaW5w dXQsIDA0NDQsIGFtZGdwdV9od21vbl9nZXRfZmFuMV9pbnB1dCwgTlVMTCwgMCk7Cj4gK3N0YXRp YyBTRU5TT1JfREVWSUNFX0FUVFIoaW4wX2lucHV0LCAwNDQ0LCBhbWRncHVfaHdtb25fc2hvd192 ZGRnZngsIE5VTEwsIDApOwo+ICtzdGF0aWMgU0VOU09SX0RFVklDRV9BVFRSKGluMF9sYWJlbCwg MDQ0NCwgYW1kZ3B1X2h3bW9uX3Nob3dfdmRkZ2Z4X2xhYmVsLCBOVUxMLCAwKTsKPiArc3RhdGlj IFNFTlNPUl9ERVZJQ0VfQVRUUihpbjFfaW5wdXQsIDA0NDQsIGFtZGdwdV9od21vbl9zaG93X3Zk ZG5iLCBOVUxMLCAwKTsKPiArc3RhdGljIFNFTlNPUl9ERVZJQ0VfQVRUUihpbjFfbGFiZWwsIDA0 NDQsIGFtZGdwdV9od21vbl9zaG93X3ZkZG5iX2xhYmVsLCBOVUxMLCAwKTsKPiArc3RhdGljIFNF TlNPUl9ERVZJQ0VfQVRUUihwb3dlcjFfYXZlcmFnZSwgMDQ0NCwgYW1kZ3B1X2h3bW9uX3Nob3df cG93ZXJfYXZnLCBOVUxMLCAwKTsKPiArc3RhdGljIFNFTlNPUl9ERVZJQ0VfQVRUUihwb3dlcjFf Y2FwX21heCwgMDQ0NCwgYW1kZ3B1X2h3bW9uX3Nob3dfcG93ZXJfY2FwX21heCwgTlVMTCwgMCk7 Cj4gK3N0YXRpYyBTRU5TT1JfREVWSUNFX0FUVFIocG93ZXIxX2NhcF9taW4sIDA0NDQsIGFtZGdw dV9od21vbl9zaG93X3Bvd2VyX2NhcF9taW4sIE5VTEwsIDApOwo+ICtzdGF0aWMgU0VOU09SX0RF VklDRV9BVFRSKHBvd2VyMV9jYXAsIDA2NDQsIGFtZGdwdV9od21vbl9zaG93X3Bvd2VyX2NhcCwg YW1kZ3B1X2h3bW9uX3NldF9wb3dlcl9jYXAsIDApOwo+ICAgCj4gICBzdGF0aWMgc3RydWN0IGF0 dHJpYnV0ZSAqaHdtb25fYXR0cmlidXRlc1tdID0gewo+ICAgCSZzZW5zb3JfZGV2X2F0dHJfdGVt cDFfaW5wdXQuZGV2X2F0dHIuYXR0ciwKPiBAQCAtMTM4OCwxMyArMTM4OCwxMyBAQCBzdGF0aWMg dW1vZGVfdCBod21vbl9hdHRyaWJ1dGVzX3Zpc2libGUoc3RydWN0IGtvYmplY3QgKmtvYmosCj4g ICAJICAgICBhdHRyID09ICZzZW5zb3JfZGV2X2F0dHJfcHdtMS5kZXZfYXR0ci5hdHRyKSB8fCAv KiBjYW4ndCBxdWVyeSBmYW4gKi8KPiAgIAkgICAgKCFhZGV2LT5wb3dlcnBsYXkucHBfZnVuY3Mt PmdldF9mYW5fY29udHJvbF9tb2RlICYmCj4gICAJICAgICBhdHRyID09ICZzZW5zb3JfZGV2X2F0 dHJfcHdtMV9lbmFibGUuZGV2X2F0dHIuYXR0cikpIC8qIGNhbid0IHF1ZXJ5IHN0YXRlICovCj4g LQkJZWZmZWN0aXZlX21vZGUgJj0gflNfSVJVR087Cj4gKwkJZWZmZWN0aXZlX21vZGUgJj0gfjA0 NDQ7Cj4gICAKPiAgIAlpZiAoKCFhZGV2LT5wb3dlcnBsYXkucHBfZnVuY3MtPnNldF9mYW5fc3Bl ZWRfcGVyY2VudCAmJgo+ICAgCSAgICAgYXR0ciA9PSAmc2Vuc29yX2Rldl9hdHRyX3B3bTEuZGV2 X2F0dHIuYXR0cikgfHwgLyogY2FuJ3QgbWFuYWdlIGZhbiAqLwo+ICAgCSAgICAoIWFkZXYtPnBv d2VycGxheS5wcF9mdW5jcy0+c2V0X2Zhbl9jb250cm9sX21vZGUgJiYKPiAgIAkgICAgIGF0dHIg PT0gJnNlbnNvcl9kZXZfYXR0cl9wd20xX2VuYWJsZS5kZXZfYXR0ci5hdHRyKSkgLyogY2FuJ3Qg bWFuYWdlIHN0YXRlICovCj4gLQkJZWZmZWN0aXZlX21vZGUgJj0gflNfSVdVU1I7Cj4gKwkJZWZm ZWN0aXZlX21vZGUgJj0gfjAyMDA7Cj4gICAKPiAgIAlpZiAoKGFkZXYtPmZsYWdzICYgQU1EX0lT X0FQVSkgJiYKPiAgIAkgICAgKGF0dHIgPT0gJnNlbnNvcl9kZXZfYXR0cl9wb3dlcjFfY2FwX21h eC5kZXZfYXR0ci5hdHRyIHx8Cj4gZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2RybS9hbWQvYW1k Z3B1L2FtZGdwdV9yaW5nLmMgYi9kcml2ZXJzL2dwdS9kcm0vYW1kL2FtZGdwdS9hbWRncHVfcmlu Zy5jCj4gaW5kZXggNDljYWQwOGI1YzE2Li4yMmM1NjM2N2VlOGUgMTAwNjQ0Cj4gLS0tIGEvZHJp dmVycy9ncHUvZHJtL2FtZC9hbWRncHUvYW1kZ3B1X3JpbmcuYwo+ICsrKyBiL2RyaXZlcnMvZ3B1 L2RybS9hbWQvYW1kZ3B1L2FtZGdwdV9yaW5nLmMKPiBAQCAtNTUzLDggKzU1Myw3IEBAIHN0YXRp YyBpbnQgYW1kZ3B1X2RlYnVnZnNfcmluZ19pbml0KHN0cnVjdCBhbWRncHVfZGV2aWNlICphZGV2 LAo+ICAgCj4gICAJc3ByaW50ZihuYW1lLCAiYW1kZ3B1X3JpbmdfJXMiLCByaW5nLT5uYW1lKTsK PiAgIAo+IC0JZW50ID0gZGVidWdmc19jcmVhdGVfZmlsZShuYW1lLAo+IC0JCQkJICBTX0lGUkVH IHwgU19JUlVHTywgcm9vdCwKPiArCWVudCA9IGRlYnVnZnNfY3JlYXRlX2ZpbGUobmFtZSwgU19J RlJFRyB8IDA0NDQsIHJvb3QsCj4gICAJCQkJICByaW5nLCAmYW1kZ3B1X2RlYnVnZnNfcmluZ19m b3BzKTsKPiAgIAlpZiAoIWVudCkKPiAgIAkJcmV0dXJuIC1FTk9NRU07Cj4gZGlmZiAtLWdpdCBh L2RyaXZlcnMvZ3B1L2RybS9hbWQvYW1kZ3B1L2FtZGdwdV90dG0uYyBiL2RyaXZlcnMvZ3B1L2Ry bS9hbWQvYW1kZ3B1L2FtZGdwdV90dG0uYwo+IGluZGV4IDY5YTJiMjViMzY5Ni4uNjk2YTI2MTc5 MzBmIDEwMDY0NAo+IC0tLSBhL2RyaXZlcnMvZ3B1L2RybS9hbWQvYW1kZ3B1L2FtZGdwdV90dG0u Ywo+ICsrKyBiL2RyaXZlcnMvZ3B1L2RybS9hbWQvYW1kZ3B1L2FtZGdwdV90dG0uYwo+IEBAIC0y MTYwLDExICsyMTYwLDEwIEBAIHN0YXRpYyBpbnQgYW1kZ3B1X3R0bV9kZWJ1Z2ZzX2luaXQoc3Ry dWN0IGFtZGdwdV9kZXZpY2UgKmFkZXYpCj4gICAJc3RydWN0IGRlbnRyeSAqZW50LCAqcm9vdCA9 IG1pbm9yLT5kZWJ1Z2ZzX3Jvb3Q7Cj4gICAKPiAgIAlmb3IgKGNvdW50ID0gMDsgY291bnQgPCBB UlJBWV9TSVpFKHR0bV9kZWJ1Z2ZzX2VudHJpZXMpOyBjb3VudCsrKSB7Cj4gLQkJZW50ID0gZGVi dWdmc19jcmVhdGVfZmlsZSgKPiAtCQkJCXR0bV9kZWJ1Z2ZzX2VudHJpZXNbY291bnRdLm5hbWUs Cj4gLQkJCQlTX0lGUkVHIHwgU19JUlVHTywgcm9vdCwKPiAtCQkJCWFkZXYsCj4gLQkJCQl0dG1f ZGVidWdmc19lbnRyaWVzW2NvdW50XS5mb3BzKTsKPiArCQllbnQgPSBkZWJ1Z2ZzX2NyZWF0ZV9m aWxlKHR0bV9kZWJ1Z2ZzX2VudHJpZXNbY291bnRdLm5hbWUsCj4gKwkJCQkJICBTX0lGUkVHIHwg MDQ0NCwgcm9vdCwKPiArCQkJCQkgIGFkZXYsCj4gKwkJCQkJICB0dG1fZGVidWdmc19lbnRyaWVz W2NvdW50XS5mb3BzKTsKPiAgIAkJaWYgKElTX0VSUihlbnQpKQo+ICAgCQkJcmV0dXJuIFBUUl9F UlIoZW50KTsKPiAgIAkJaWYgKHR0bV9kZWJ1Z2ZzX2VudHJpZXNbY291bnRdLmRvbWFpbiA9PSBU VE1fUExfVlJBTSkKPiBkaWZmIC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJtL2FybWFkYS9hcm1hZGFf ZGVidWdmcy5jIGIvZHJpdmVycy9ncHUvZHJtL2FybWFkYS9hcm1hZGFfZGVidWdmcy5jCj4gaW5k ZXggNjc1OGMzYTgzZGUyLi45YmUzOTZlNGI2ZGQgMTAwNjQ0Cj4gLS0tIGEvZHJpdmVycy9ncHUv ZHJtL2FybWFkYS9hcm1hZGFfZGVidWdmcy5jCj4gKysrIGIvZHJpdmVycy9ncHUvZHJtL2FybWFk YS9hcm1hZGFfZGVidWdmcy5jCj4gQEAgLTExOCwxMiArMTE4LDEyIEBAIGludCBhcm1hZGFfZHJt X2RlYnVnZnNfaW5pdChzdHJ1Y3QgZHJtX21pbm9yICptaW5vcikKPiAgIAlpZiAocmV0KQo+ICAg CQlyZXR1cm4gcmV0Owo+ICAgCj4gLQlkZSA9IGRlYnVnZnNfY3JlYXRlX2ZpbGUoInJlZyIsIFNf SUZSRUcgfCBTX0lSVVNSLAo+ICsJZGUgPSBkZWJ1Z2ZzX2NyZWF0ZV9maWxlKCJyZWciLCBTX0lG UkVHIHwgMDQwMCwKPiAgIAkJCQkgbWlub3ItPmRlYnVnZnNfcm9vdCwgbWlub3ItPmRldiwgJmZv cHNfcmVnX3IpOwo+ICAgCWlmICghZGUpCj4gICAJCXJldHVybiAtRU5PTUVNOwo+ICAgCj4gLQlk ZSA9IGRlYnVnZnNfY3JlYXRlX2ZpbGUoInJlZ193ciIsIFNfSUZSRUcgfCBTX0lXVVNSLAo+ICsJ ZGUgPSBkZWJ1Z2ZzX2NyZWF0ZV9maWxlKCJyZWdfd3IiLCBTX0lGUkVHIHwgMDIwMCwKPiAgIAkJ CQkgbWlub3ItPmRlYnVnZnNfcm9vdCwgbWlub3ItPmRldiwgJmZvcHNfcmVnX3cpOwo+ICAgCWlm ICghZGUpCj4gICAJCXJldHVybiAtRU5PTUVNOwo+IGRpZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9k cm0vZHJtX2RlYnVnZnMuYyBiL2RyaXZlcnMvZ3B1L2RybS9kcm1fZGVidWdmcy5jCj4gaW5kZXgg YjI0ODI4MThmZWU4Li44NGM5MTAxOGEzOTggMTAwNjQ0Cj4gLS0tIGEvZHJpdmVycy9ncHUvZHJt L2RybV9kZWJ1Z2ZzLmMKPiArKysgYi9kcml2ZXJzL2dwdS9kcm0vZHJtX2RlYnVnZnMuYwo+IEBA IC05OSw3ICs5OSw3IEBAIGludCBkcm1fZGVidWdmc19jcmVhdGVfZmlsZXMoY29uc3Qgc3RydWN0 IGRybV9pbmZvX2xpc3QgKmZpbGVzLCBpbnQgY291bnQsCj4gICAJCQlyZXQgPSAtMTsKPiAgIAkJ CWdvdG8gZmFpbDsKPiAgIAkJfQo+IC0JCWVudCA9IGRlYnVnZnNfY3JlYXRlX2ZpbGUoZmlsZXNb aV0ubmFtZSwgU19JRlJFRyB8IFNfSVJVR08sCj4gKwkJZW50ID0gZGVidWdmc19jcmVhdGVfZmls ZShmaWxlc1tpXS5uYW1lLCBTX0lGUkVHIHwgMDQ0NCwKPiAgIAkJCQkJICByb290LCB0bXAsICZk cm1fZGVidWdmc19mb3BzKTsKPiAgIAkJaWYgKCFlbnQpIHsKPiAgIAkJCURSTV9FUlJPUigiQ2Fu bm90IGNyZWF0ZSAvc3lzL2tlcm5lbC9kZWJ1Zy9kcmkvJXBkLyVzXG4iLAo+IEBAIC0zNTcsMTMg KzM1NywxMyBAQCBpbnQgZHJtX2RlYnVnZnNfY29ubmVjdG9yX2FkZChzdHJ1Y3QgZHJtX2Nvbm5l Y3RvciAqY29ubmVjdG9yKQo+ICAgCWNvbm5lY3Rvci0+ZGVidWdmc19lbnRyeSA9IHJvb3Q7Cj4g ICAKPiAgIAkvKiBmb3JjZSAqLwo+IC0JZW50ID0gZGVidWdmc19jcmVhdGVfZmlsZSgiZm9yY2Ui LCBTX0lSVUdPIHwgU19JV1VTUiwgcm9vdCwgY29ubmVjdG9yLAo+ICsJZW50ID0gZGVidWdmc19j cmVhdGVfZmlsZSgiZm9yY2UiLCAwNjQ0LCByb290LCBjb25uZWN0b3IsCj4gICAJCQkJICAmZHJt X2Nvbm5lY3Rvcl9mb3BzKTsKPiAgIAlpZiAoIWVudCkKPiAgIAkJZ290byBlcnJvcjsKPiAgIAo+ ICAgCS8qIGVkaWQgKi8KPiAtCWVudCA9IGRlYnVnZnNfY3JlYXRlX2ZpbGUoImVkaWRfb3ZlcnJp ZGUiLCBTX0lSVUdPIHwgU19JV1VTUiwgcm9vdCwKPiArCWVudCA9IGRlYnVnZnNfY3JlYXRlX2Zp bGUoImVkaWRfb3ZlcnJpZGUiLCAwNjQ0LCByb290LAo+ICAgCQkJCSAgY29ubmVjdG9yLCAmZHJt X2VkaWRfZm9wcyk7Cj4gICAJaWYgKCFlbnQpCj4gICAJCWdvdG8gZXJyb3I7Cj4gZGlmZiAtLWdp dCBhL2RyaXZlcnMvZ3B1L2RybS9kcm1fZGVidWdmc19jcmMuYyBiL2RyaXZlcnMvZ3B1L2RybS9k cm1fZGVidWdmc19jcmMuYwo+IGluZGV4IDlmODMxMjEzN2NhZC4uNjNkZDI5MDk2M2E3IDEwMDY0 NAo+IC0tLSBhL2RyaXZlcnMvZ3B1L2RybS9kcm1fZGVidWdmc19jcmMuYwo+ICsrKyBiL2RyaXZl cnMvZ3B1L2RybS9kcm1fZGVidWdmc19jcmMuYwo+IEBAIC0zNDQsMTIgKzM0NCwxMiBAQCBpbnQg ZHJtX2RlYnVnZnNfY3J0Y19jcmNfYWRkKHN0cnVjdCBkcm1fY3J0YyAqY3J0YykKPiAgIAlpZiAo IWNyY19lbnQpCj4gICAJCXJldHVybiAtRU5PTUVNOwo+ICAgCj4gLQllbnQgPSBkZWJ1Z2ZzX2Ny ZWF0ZV9maWxlKCJjb250cm9sIiwgU19JUlVHTywgY3JjX2VudCwgY3J0YywKPiArCWVudCA9IGRl YnVnZnNfY3JlYXRlX2ZpbGUoImNvbnRyb2wiLCAwNDQ0LCBjcmNfZW50LCBjcnRjLAo+ICAgCQkJ CSAgJmRybV9jcnRjX2NyY19jb250cm9sX2ZvcHMpOwo+ICAgCWlmICghZW50KQo+ICAgCQlnb3Rv IGVycm9yOwo+ICAgCj4gLQllbnQgPSBkZWJ1Z2ZzX2NyZWF0ZV9maWxlKCJkYXRhIiwgU19JUlVH TywgY3JjX2VudCwgY3J0YywKPiArCWVudCA9IGRlYnVnZnNfY3JlYXRlX2ZpbGUoImRhdGEiLCAw NDQ0LCBjcmNfZW50LCBjcnRjLAo+ICAgCQkJCSAgJmRybV9jcnRjX2NyY19kYXRhX2ZvcHMpOwo+ ICAgCWlmICghZW50KQo+ICAgCQlnb3RvIGVycm9yOwo+IGRpZmYgLS1naXQgYS9kcml2ZXJzL2dw dS9kcm0vZHJtX3N5c2ZzLmMgYi9kcml2ZXJzL2dwdS9kcm0vZHJtX3N5c2ZzLmMKPiBpbmRleCBi M2MxZGFhZDExNjkuLmM2NDAxOWYxNGM3OSAxMDA2NDQKPiAtLS0gYS9kcml2ZXJzL2dwdS9kcm0v ZHJtX3N5c2ZzLmMKPiArKysgYi9kcml2ZXJzL2dwdS9kcm0vZHJtX3N5c2ZzLmMKPiBAQCAtNTAs NyArNTAsNyBAQCBzdGF0aWMgY2hhciAqZHJtX2Rldm5vZGUoc3RydWN0IGRldmljZSAqZGV2LCB1 bW9kZV90ICptb2RlKQo+ICAgCXJldHVybiBrYXNwcmludGYoR0ZQX0tFUk5FTCwgImRyaS8lcyIs IGRldl9uYW1lKGRldikpOwo+ICAgfQo+ICAgCj4gLXN0YXRpYyBDTEFTU19BVFRSX1NUUklORyh2 ZXJzaW9uLCBTX0lSVUdPLCAiZHJtIDEuMS4wIDIwMDYwODEwIik7Cj4gK3N0YXRpYyBDTEFTU19B VFRSX1NUUklORyh2ZXJzaW9uLCAwNDQ0LCAiZHJtIDEuMS4wIDIwMDYwODEwIik7Cj4gICAKPiAg IC8qKgo+ICAgICogZHJtX3N5c2ZzX2luaXQgLSBpbml0aWFsaXplIHN5c2ZzIGhlbHBlcnMKPiBk aWZmIC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJtL2k5MTUvZ3Z0L2Zpcm13YXJlLmMgYi9kcml2ZXJz L2dwdS9kcm0vaTkxNS9ndnQvZmlybXdhcmUuYwo+IGluZGV4IGE3M2UxZDQxOGMyMi4uMzNiOGM0 ZjM4ZmQ4IDEwMDY0NAo+IC0tLSBhL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2d2dC9maXJtd2FyZS5j Cj4gKysrIGIvZHJpdmVycy9ncHUvZHJtL2k5MTUvZ3Z0L2Zpcm13YXJlLmMKPiBAQCAtNjAsNyAr NjAsNyBAQCBndnRfZmlybXdhcmVfcmVhZChzdHJ1Y3QgZmlsZSAqZmlscCwgc3RydWN0IGtvYmpl Y3QgKmtvYmosCj4gICB9Cj4gICAKPiAgIHN0YXRpYyBzdHJ1Y3QgYmluX2F0dHJpYnV0ZSBmaXJt d2FyZV9hdHRyID0gewo+IC0JLmF0dHIgPSB7Lm5hbWUgPSAiZ3Z0X2Zpcm13YXJlIiwgLm1vZGUg PSAoU19JUlVTUil9LAo+ICsJLmF0dHIgPSB7Lm5hbWUgPSAiZ3Z0X2Zpcm13YXJlIiwgLm1vZGUg PSAwNDAwfSwKPiAgIAkucmVhZCA9IGd2dF9maXJtd2FyZV9yZWFkLAo+ICAgCS53cml0ZSA9IE5V TEwsCj4gICAJLm1tYXAgPSBOVUxMLAo+IGRpZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9kcm0vaTkx NS9pOTE1X2RlYnVnZnMuYyBiL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2k5MTVfZGVidWdmcy5jCj4g aW5kZXggMTNlN2I5ZTRhNmU2Li4xNzk2NjI2YTg1OGYgMTAwNjQ0Cj4gLS0tIGEvZHJpdmVycy9n cHUvZHJtL2k5MTUvaTkxNV9kZWJ1Z2ZzLmMKPiArKysgYi9kcml2ZXJzL2dwdS9kcm0vaTkxNS9p OTE1X2RlYnVnZnMuYwo+IEBAIC00ODUxLDcgKzQ4NTEsNyBAQCBpbnQgaTkxNV9kZWJ1Z2ZzX3Jl Z2lzdGVyKHN0cnVjdCBkcm1faTkxNV9wcml2YXRlICpkZXZfcHJpdikKPiAgIAlzdHJ1Y3QgZGVu dHJ5ICplbnQ7Cj4gICAJaW50IHJldCwgaTsKPiAgIAo+IC0JZW50ID0gZGVidWdmc19jcmVhdGVf ZmlsZSgiaTkxNV9mb3JjZXdha2VfdXNlciIsIFNfSVJVU1IsCj4gKwllbnQgPSBkZWJ1Z2ZzX2Ny ZWF0ZV9maWxlKCJpOTE1X2ZvcmNld2FrZV91c2VyIiwgMDQwMCwKPiAgIAkJCQkgIG1pbm9yLT5k ZWJ1Z2ZzX3Jvb3QsIHRvX2k5MTUobWlub3ItPmRldiksCj4gICAJCQkJICAmaTkxNV9mb3JjZXdh a2VfZm9wcyk7Cj4gICAJaWYgKCFlbnQpCj4gQEAgLTQ4NjMsNyArNDg2Myw3IEBAIGludCBpOTE1 X2RlYnVnZnNfcmVnaXN0ZXIoc3RydWN0IGRybV9pOTE1X3ByaXZhdGUgKmRldl9wcml2KQo+ICAg Cj4gICAJZm9yIChpID0gMDsgaSA8IEFSUkFZX1NJWkUoaTkxNV9kZWJ1Z2ZzX2ZpbGVzKTsgaSsr KSB7Cj4gICAJCWVudCA9IGRlYnVnZnNfY3JlYXRlX2ZpbGUoaTkxNV9kZWJ1Z2ZzX2ZpbGVzW2ld Lm5hbWUsCj4gLQkJCQkJICBTX0lSVUdPIHwgU19JV1VTUiwKPiArCQkJCQkgIDA2NDQsCj4gICAJ CQkJCSAgbWlub3ItPmRlYnVnZnNfcm9vdCwKPiAgIAkJCQkJICB0b19pOTE1KG1pbm9yLT5kZXYp LAo+ICAgCQkJCQkgIGk5MTVfZGVidWdmc19maWxlc1tpXS5mb3BzKTsKPiBAQCAtNDk3OSwxMSAr NDk3OSwxMSBAQCBpbnQgaTkxNV9kZWJ1Z2ZzX2Nvbm5lY3Rvcl9hZGQoc3RydWN0IGRybV9jb25u ZWN0b3IgKmNvbm5lY3RvcikKPiAgIAo+ICAgCWlmIChjb25uZWN0b3ItPmNvbm5lY3Rvcl90eXBl ID09IERSTV9NT0RFX0NPTk5FQ1RPUl9EaXNwbGF5UG9ydCB8fAo+ICAgCSAgICBjb25uZWN0b3It PmNvbm5lY3Rvcl90eXBlID09IERSTV9NT0RFX0NPTk5FQ1RPUl9lRFApCj4gLQkJZGVidWdmc19j cmVhdGVfZmlsZSgiaTkxNV9kcGNkIiwgU19JUlVHTywgcm9vdCwKPiArCQlkZWJ1Z2ZzX2NyZWF0 ZV9maWxlKCJpOTE1X2RwY2QiLCAwNDQ0LCByb290LAo+ICAgCQkJCSAgICBjb25uZWN0b3IsICZp OTE1X2RwY2RfZm9wcyk7Cj4gICAKPiAgIAlpZiAoY29ubmVjdG9yLT5jb25uZWN0b3JfdHlwZSA9 PSBEUk1fTU9ERV9DT05ORUNUT1JfZURQKQo+IC0JCWRlYnVnZnNfY3JlYXRlX2ZpbGUoImk5MTVf cGFuZWxfdGltaW5ncyIsIFNfSVJVR08sIHJvb3QsCj4gKwkJZGVidWdmc19jcmVhdGVfZmlsZSgi aTkxNV9wYW5lbF90aW1pbmdzIiwgMDQ0NCwgcm9vdCwKPiAgIAkJCQkgICAgY29ubmVjdG9yLCAm aTkxNV9wYW5lbF9mb3BzKTsKPiAgIAo+ICAgCXJldHVybiAwOwo+IGRpZmYgLS1naXQgYS9kcml2 ZXJzL2dwdS9kcm0vaTkxNS9pOTE1X3BlcmYuYyBiL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2k5MTVf cGVyZi5jCj4gaW5kZXggMDE5YmQyZDA3M2FkLi44ZTUwMDk0NDU5NjMgMTAwNjQ0Cj4gLS0tIGEv ZHJpdmVycy9ncHUvZHJtL2k5MTUvaTkxNV9wZXJmLmMKPiArKysgYi9kcml2ZXJzL2dwdS9kcm0v aTkxNS9pOTE1X3BlcmYuYwo+IEBAIC0zMTQ4LDcgKzMxNDgsNyBAQCBzdGF0aWMgaW50IGNyZWF0 ZV9keW5hbWljX29hX3N5c2ZzX2VudHJ5KHN0cnVjdCBkcm1faTkxNV9wcml2YXRlICpkZXZfcHJp diwKPiAgIHsKPiAgIAlzeXNmc19hdHRyX2luaXQoJm9hX2NvbmZpZy0+c3lzZnNfbWV0cmljX2lk LmF0dHIpOwo+ICAgCW9hX2NvbmZpZy0+c3lzZnNfbWV0cmljX2lkLmF0dHIubmFtZSA9ICJpZCI7 Cj4gLQlvYV9jb25maWctPnN5c2ZzX21ldHJpY19pZC5hdHRyLm1vZGUgPSBTX0lSVUdPOwo+ICsJ b2FfY29uZmlnLT5zeXNmc19tZXRyaWNfaWQuYXR0ci5tb2RlID0gMDQ0NDsKPiAgIAlvYV9jb25m aWctPnN5c2ZzX21ldHJpY19pZC5zaG93ID0gc2hvd19keW5hbWljX2lkOwo+ICAgCW9hX2NvbmZp Zy0+c3lzZnNfbWV0cmljX2lkLnN0b3JlID0gTlVMTDsKPiAgIAo+IGRpZmYgLS1naXQgYS9kcml2 ZXJzL2dwdS9kcm0vaTkxNS9pOTE1X3N5c2ZzLmMgYi9kcml2ZXJzL2dwdS9kcm0vaTkxNS9pOTE1 X3N5c2ZzLmMKPiBpbmRleCBlNWU2ZjZiYjJiMDUuLmE4ZTI1NDY1YmYxYSAxMDA2NDQKPiAtLS0g YS9kcml2ZXJzL2dwdS9kcm0vaTkxNS9pOTE1X3N5c2ZzLmMKPiArKysgYi9kcml2ZXJzL2dwdS9k cm0vaTkxNS9pOTE1X3N5c2ZzLmMKPiBAQCAtMTAwLDExICsxMDAsMTEgQEAgc2hvd19tZWRpYV9y YzZfbXMoc3RydWN0IGRldmljZSAqa2Rldiwgc3RydWN0IGRldmljZV9hdHRyaWJ1dGUgKmF0dHIs IGNoYXIgKmJ1ZikKPiAgIAlyZXR1cm4gc25wcmludGYoYnVmLCBQQUdFX1NJWkUsICIldVxuIiwg cmM2X3Jlc2lkZW5jeSk7Cj4gICB9Cj4gICAKPiAtc3RhdGljIERFVklDRV9BVFRSKHJjNl9lbmFi bGUsIFNfSVJVR08sIHNob3dfcmM2X21hc2ssIE5VTEwpOwo+IC1zdGF0aWMgREVWSUNFX0FUVFIo cmM2X3Jlc2lkZW5jeV9tcywgU19JUlVHTywgc2hvd19yYzZfbXMsIE5VTEwpOwo+IC1zdGF0aWMg REVWSUNFX0FUVFIocmM2cF9yZXNpZGVuY3lfbXMsIFNfSVJVR08sIHNob3dfcmM2cF9tcywgTlVM TCk7Cj4gLXN0YXRpYyBERVZJQ0VfQVRUUihyYzZwcF9yZXNpZGVuY3lfbXMsIFNfSVJVR08sIHNo b3dfcmM2cHBfbXMsIE5VTEwpOwo+IC1zdGF0aWMgREVWSUNFX0FUVFIobWVkaWFfcmM2X3Jlc2lk ZW5jeV9tcywgU19JUlVHTywgc2hvd19tZWRpYV9yYzZfbXMsIE5VTEwpOwo+ICtzdGF0aWMgREVW SUNFX0FUVFIocmM2X2VuYWJsZSwgMDQ0NCwgc2hvd19yYzZfbWFzaywgTlVMTCk7Cj4gK3N0YXRp YyBERVZJQ0VfQVRUUihyYzZfcmVzaWRlbmN5X21zLCAwNDQ0LCBzaG93X3JjNl9tcywgTlVMTCk7 Cj4gK3N0YXRpYyBERVZJQ0VfQVRUUihyYzZwX3Jlc2lkZW5jeV9tcywgMDQ0NCwgc2hvd19yYzZw X21zLCBOVUxMKTsKPiArc3RhdGljIERFVklDRV9BVFRSKHJjNnBwX3Jlc2lkZW5jeV9tcywgMDQ0 NCwgc2hvd19yYzZwcF9tcywgTlVMTCk7Cj4gK3N0YXRpYyBERVZJQ0VfQVRUUihtZWRpYV9yYzZf cmVzaWRlbmN5X21zLCAwNDQ0LCBzaG93X21lZGlhX3JjNl9tcywgTlVMTCk7Cj4gICAKPiAgIHN0 YXRpYyBzdHJ1Y3QgYXR0cmlidXRlICpyYzZfYXR0cnNbXSA9IHsKPiAgIAkmZGV2X2F0dHJfcmM2 X2VuYWJsZS5hdHRyLAo+IEBAIC0yMzcsNyArMjM3LDcgQEAgaTkxNV9sM193cml0ZShzdHJ1Y3Qg ZmlsZSAqZmlscCwgc3RydWN0IGtvYmplY3QgKmtvYmosCj4gICB9Cj4gICAKPiAgIHN0YXRpYyBj b25zdCBzdHJ1Y3QgYmluX2F0dHJpYnV0ZSBkcGZfYXR0cnMgPSB7Cj4gLQkuYXR0ciA9IHsubmFt ZSA9ICJsM19wYXJpdHkiLCAubW9kZSA9IChTX0lSVVNSIHwgU19JV1VTUil9LAo+ICsJLmF0dHIg PSB7Lm5hbWUgPSAibDNfcGFyaXR5IiwgLm1vZGUgPSAwNjAwfSwKPiAgIAkuc2l6ZSA9IEdFTjdf TDNMT0dfU0laRSwKPiAgIAkucmVhZCA9IGk5MTVfbDNfcmVhZCwKPiAgIAkud3JpdGUgPSBpOTE1 X2wzX3dyaXRlLAo+IEBAIC0yNDYsNyArMjQ2LDcgQEAgc3RhdGljIGNvbnN0IHN0cnVjdCBiaW5f YXR0cmlidXRlIGRwZl9hdHRycyA9IHsKPiAgIH07Cj4gICAKPiAgIHN0YXRpYyBjb25zdCBzdHJ1 Y3QgYmluX2F0dHJpYnV0ZSBkcGZfYXR0cnNfMSA9IHsKPiAtCS5hdHRyID0gey5uYW1lID0gImwz X3Bhcml0eV9zbGljZV8xIiwgLm1vZGUgPSAoU19JUlVTUiB8IFNfSVdVU1IpfSwKPiArCS5hdHRy ID0gey5uYW1lID0gImwzX3Bhcml0eV9zbGljZV8xIiwgLm1vZGUgPSAwNjAwfSwKPiAgIAkuc2l6 ZSA9IEdFTjdfTDNMT0dfU0laRSwKPiAgIAkucmVhZCA9IGk5MTVfbDNfcmVhZCwKPiAgIAkud3Jp dGUgPSBpOTE1X2wzX3dyaXRlLAo+IEBAIC00NjAsOSArNDYwLDkgQEAgc3RhdGljIERFVklDRV9B VFRSX1JXKGd0X21pbl9mcmVxX21oeik7Cj4gICBzdGF0aWMgREVWSUNFX0FUVFJfUk8odmx2X3Jw ZV9mcmVxX21oeik7Cj4gICAKPiAgIHN0YXRpYyBzc2l6ZV90IGd0X3JwX21oel9zaG93KHN0cnVj dCBkZXZpY2UgKmtkZXYsIHN0cnVjdCBkZXZpY2VfYXR0cmlidXRlICphdHRyLCBjaGFyICpidWYp Owo+IC1zdGF0aWMgREVWSUNFX0FUVFIoZ3RfUlAwX2ZyZXFfbWh6LCBTX0lSVUdPLCBndF9ycF9t aHpfc2hvdywgTlVMTCk7Cj4gLXN0YXRpYyBERVZJQ0VfQVRUUihndF9SUDFfZnJlcV9taHosIFNf SVJVR08sIGd0X3JwX21oel9zaG93LCBOVUxMKTsKPiAtc3RhdGljIERFVklDRV9BVFRSKGd0X1JQ bl9mcmVxX21oeiwgU19JUlVHTywgZ3RfcnBfbWh6X3Nob3csIE5VTEwpOwo+ICtzdGF0aWMgREVW SUNFX0FUVFIoZ3RfUlAwX2ZyZXFfbWh6LCAwNDQ0LCBndF9ycF9taHpfc2hvdywgTlVMTCk7Cj4g K3N0YXRpYyBERVZJQ0VfQVRUUihndF9SUDFfZnJlcV9taHosIDA0NDQsIGd0X3JwX21oel9zaG93 LCBOVUxMKTsKPiArc3RhdGljIERFVklDRV9BVFRSKGd0X1JQbl9mcmVxX21oeiwgMDQ0NCwgZ3Rf cnBfbWh6X3Nob3csIE5VTEwpOwo+ICAgCj4gICAvKiBGb3Igbm93IHdlIGhhdmUgYSBzdGF0aWMg bnVtYmVyIG9mIFJQIHN0YXRlcyAqLwo+ICAgc3RhdGljIHNzaXplX3QgZ3RfcnBfbWh6X3Nob3co c3RydWN0IGRldmljZSAqa2Rldiwgc3RydWN0IGRldmljZV9hdHRyaWJ1dGUgKmF0dHIsIGNoYXIg KmJ1ZikKPiBAQCAtNTU1LDcgKzU1NSw3IEBAIHN0YXRpYyBzc2l6ZV90IGVycm9yX3N0YXRlX3dy aXRlKHN0cnVjdCBmaWxlICpmaWxlLCBzdHJ1Y3Qga29iamVjdCAqa29iaiwKPiAgIAo+ICAgc3Rh dGljIGNvbnN0IHN0cnVjdCBiaW5fYXR0cmlidXRlIGVycm9yX3N0YXRlX2F0dHIgPSB7Cj4gICAJ LmF0dHIubmFtZSA9ICJlcnJvciIsCj4gLQkuYXR0ci5tb2RlID0gU19JUlVTUiB8IFNfSVdVU1Is Cj4gKwkuYXR0ci5tb2RlID0gMDYwMCwKPiAgIAkuc2l6ZSA9IDAsCj4gICAJLnJlYWQgPSBlcnJv cl9zdGF0ZV9yZWFkLAo+ICAgCS53cml0ZSA9IGVycm9yX3N0YXRlX3dyaXRlLAo+IGRpZmYgLS1n aXQgYS9kcml2ZXJzL2dwdS9kcm0vaTkxNS9pbnRlbF9waXBlX2NyYy5jIGIvZHJpdmVycy9ncHUv ZHJtL2k5MTUvaW50ZWxfcGlwZV9jcmMuYwo+IGluZGV4IDM5YTRlNGVkZGEwNy4uMmEzNGFjOGUz MTliIDEwMDY0NAo+IC0tLSBhL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2ludGVsX3BpcGVfY3JjLmMK PiArKysgYi9kcml2ZXJzL2dwdS9kcm0vaTkxNS9pbnRlbF9waXBlX2NyYy5jCj4gQEAgLTkwMyw3 ICs5MDMsNyBAQCBpbnQgaW50ZWxfcGlwZV9jcmNfY3JlYXRlKHN0cnVjdCBkcm1fbWlub3IgKm1p bm9yKQo+ICAgCQlzdHJ1Y3QgcGlwZV9jcmNfaW5mbyAqaW5mbyA9ICZpOTE1X3BpcGVfY3JjX2Rh dGFbaV07Cj4gICAKPiAgIAkJaW5mby0+ZGV2X3ByaXYgPSBkZXZfcHJpdjsKPiAtCQllbnQgPSBk ZWJ1Z2ZzX2NyZWF0ZV9maWxlKGluZm8tPm5hbWUsIFNfSVJVR08sCj4gKwkJZW50ID0gZGVidWdm c19jcmVhdGVfZmlsZShpbmZvLT5uYW1lLCAwNDQ0LAo+ICAgCQkJCQkgIG1pbm9yLT5kZWJ1Z2Zz X3Jvb3QsIGluZm8sCj4gICAJCQkJCSAgJmk5MTVfcGlwZV9jcmNfZm9wcyk7Cj4gICAJCWlmICgh ZW50KQo+IGRpZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9kcm0vbXNtL2FkcmVuby9hNXh4X2RlYnVn ZnMuYyBiL2RyaXZlcnMvZ3B1L2RybS9tc20vYWRyZW5vL2E1eHhfZGVidWdmcy5jCj4gaW5kZXgg MDU5ZWM3ZDM5NGQwLi5jNDM3M2E1YTE4YmUgMTAwNjQ0Cj4gLS0tIGEvZHJpdmVycy9ncHUvZHJt L21zbS9hZHJlbm8vYTV4eF9kZWJ1Z2ZzLmMKPiArKysgYi9kcml2ZXJzL2dwdS9kcm0vbXNtL2Fk cmVuby9hNXh4X2RlYnVnZnMuYwo+IEBAIC0xNzcsOSArMTc3LDggQEAgaW50IGE1eHhfZGVidWdm c19pbml0KHN0cnVjdCBtc21fZ3B1ICpncHUsIHN0cnVjdCBkcm1fbWlub3IgKm1pbm9yKQo+ICAg CQlyZXR1cm4gcmV0Owo+ICAgCX0KPiAgIAo+IC0JZW50ID0gZGVidWdmc19jcmVhdGVfZmlsZSgi cmVzZXQiLCBTX0lXVUdPLAo+IC0JCW1pbm9yLT5kZWJ1Z2ZzX3Jvb3QsCj4gLQkJZGV2LCAmcmVz ZXRfZm9wcyk7Cj4gKwllbnQgPSBkZWJ1Z2ZzX2NyZWF0ZV9maWxlKCJyZXNldCIsIDAyMjIsIG1p bm9yLT5kZWJ1Z2ZzX3Jvb3QsCj4gKwkJCQkgIGRldiwgJnJlc2V0X2ZvcHMpOwo+ICAgCWlmICgh ZW50KQo+ICAgCQlyZXR1cm4gLUVOT01FTTsKPiAgIAo+IGRpZmYgLS1naXQgYS9kcml2ZXJzL2dw dS9kcm0vbXNtL21zbV9wZXJmLmMgYi9kcml2ZXJzL2dwdS9kcm0vbXNtL21zbV9wZXJmLmMKPiBp bmRleCA1YWIyMWJkMmRlY2IuLmFkMWNmZmU3MmJmNCAxMDA2NDQKPiAtLS0gYS9kcml2ZXJzL2dw dS9kcm0vbXNtL21zbV9wZXJmLmMKPiArKysgYi9kcml2ZXJzL2dwdS9kcm0vbXNtL21zbV9wZXJm LmMKPiBAQCAtMjIwLDggKzIyMCw4IEBAIGludCBtc21fcGVyZl9kZWJ1Z2ZzX2luaXQoc3RydWN0 IGRybV9taW5vciAqbWlub3IpCj4gICAJbXV0ZXhfaW5pdCgmcGVyZi0+cmVhZF9sb2NrKTsKPiAg IAlwcml2LT5wZXJmID0gcGVyZjsKPiAgIAo+IC0JZW50ID0gZGVidWdmc19jcmVhdGVfZmlsZSgi cGVyZiIsIFNfSUZSRUcgfCBTX0lSVUdPLAo+IC0JCQltaW5vci0+ZGVidWdmc19yb290LCBwZXJm LCAmcGVyZl9kZWJ1Z2ZzX2ZvcHMpOwo+ICsJZW50ID0gZGVidWdmc19jcmVhdGVfZmlsZSgicGVy ZiIsIFNfSUZSRUcgfCAwNDQ0LCBtaW5vci0+ZGVidWdmc19yb290LAo+ICsJCQkJICBwZXJmLCAm cGVyZl9kZWJ1Z2ZzX2ZvcHMpOwo+ICAgCWlmICghZW50KSB7Cj4gICAJCURSTV9FUlJPUigiQ2Fu bm90IGNyZWF0ZSAvc3lzL2tlcm5lbC9kZWJ1Zy9kcmkvJXBkL3BlcmZcbiIsCj4gICAJCQkJbWlu b3ItPmRlYnVnZnNfcm9vdCk7Cj4gZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2RybS9tc20vbXNt X3JkLmMgYi9kcml2ZXJzL2dwdS9kcm0vbXNtL21zbV9yZC5jCj4gaW5kZXggM2FhOGE4NTc2YWJl Li5jNjE3Mjk4MDk1MWQgMTAwNjQ0Cj4gLS0tIGEvZHJpdmVycy9ncHUvZHJtL21zbS9tc21fcmQu Ywo+ICsrKyBiL2RyaXZlcnMvZ3B1L2RybS9tc20vbXNtX3JkLmMKPiBAQCAtMjUzLDggKzI1Myw4 IEBAIHN0YXRpYyBzdHJ1Y3QgbXNtX3JkX3N0YXRlICpyZF9pbml0KHN0cnVjdCBkcm1fbWlub3Ig Km1pbm9yLCBjb25zdCBjaGFyICpuYW1lKQo+ICAgCj4gICAJaW5pdF93YWl0cXVldWVfaGVhZCgm cmQtPmZpZm9fZXZlbnQpOwo+ICAgCj4gLQllbnQgPSBkZWJ1Z2ZzX2NyZWF0ZV9maWxlKG5hbWUs IFNfSUZSRUcgfCBTX0lSVUdPLAo+IC0JCQltaW5vci0+ZGVidWdmc19yb290LCByZCwgJnJkX2Rl YnVnZnNfZm9wcyk7Cj4gKwllbnQgPSBkZWJ1Z2ZzX2NyZWF0ZV9maWxlKG5hbWUsIFNfSUZSRUcg fCAwNDQ0LCBtaW5vci0+ZGVidWdmc19yb290LAo+ICsJCQkJICByZCwgJnJkX2RlYnVnZnNfZm9w cyk7Cj4gICAJaWYgKCFlbnQpIHsKPiAgIAkJRFJNX0VSUk9SKCJDYW5ub3QgY3JlYXRlIC9zeXMv a2VybmVsL2RlYnVnL2RyaS8lcGQvJXNcbiIsCj4gICAJCQkJbWlub3ItPmRlYnVnZnNfcm9vdCwg bmFtZSk7Cj4gZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2RybS9ub3V2ZWF1L25vdXZlYXVfZGVi dWdmcy5jIGIvZHJpdmVycy9ncHUvZHJtL25vdXZlYXUvbm91dmVhdV9kZWJ1Z2ZzLmMKPiBpbmRl eCA5NjNhNGRiYTgyMTMuLjdlNmIyY2NhMjQxZSAxMDA2NDQKPiAtLS0gYS9kcml2ZXJzL2dwdS9k cm0vbm91dmVhdS9ub3V2ZWF1X2RlYnVnZnMuYwo+ICsrKyBiL2RyaXZlcnMvZ3B1L2RybS9ub3V2 ZWF1L25vdXZlYXVfZGVidWdmcy5jCj4gQEAgLTIwMCw3ICsyMDAsNyBAQCBub3V2ZWF1X2RybV9k ZWJ1Z2ZzX2luaXQoc3RydWN0IGRybV9taW5vciAqbWlub3IpCj4gICAKPiAgIAlmb3IgKGkgPSAw OyBpIDwgQVJSQVlfU0laRShub3V2ZWF1X2RlYnVnZnNfZmlsZXMpOyBpKyspIHsKPiAgIAkJZGVu dHJ5ID0gZGVidWdmc19jcmVhdGVfZmlsZShub3V2ZWF1X2RlYnVnZnNfZmlsZXNbaV0ubmFtZSwK PiAtCQkJCQkgICAgIFNfSVJVR08gfCBTX0lXVVNSLAo+ICsJCQkJCSAgICAgMDY0NCwKPiAgIAkJ CQkJICAgICBtaW5vci0+ZGVidWdmc19yb290LCBtaW5vci0+ZGV2LAo+ICAgCQkJCQkgICAgIG5v dXZlYXVfZGVidWdmc19maWxlc1tpXS5mb3BzKTsKPiAgIAkJaWYgKCFkZW50cnkpCj4gZGlmZiAt LWdpdCBhL2RyaXZlcnMvZ3B1L2RybS9vbWFwZHJtL2Rpc3BsYXlzL3BhbmVsLWRzaS1jbS5jIGIv ZHJpdmVycy9ncHUvZHJtL29tYXBkcm0vZGlzcGxheXMvcGFuZWwtZHNpLWNtLmMKPiBpbmRleCA0 MjhkZTkwZmNlZDEuLjJlZDVkOTBiNjJhZSAxMDA2NDQKPiAtLS0gYS9kcml2ZXJzL2dwdS9kcm0v b21hcGRybS9kaXNwbGF5cy9wYW5lbC1kc2ktY20uYwo+ICsrKyBiL2RyaXZlcnMvZ3B1L2RybS9v bWFwZHJtL2Rpc3BsYXlzL3BhbmVsLWRzaS1jbS5jCj4gQEAgLTU2OSwxMiArNTY5LDExIEBAIHN0 YXRpYyBzc2l6ZV90IGRzaWNtX3Nob3dfdWxwc190aW1lb3V0KHN0cnVjdCBkZXZpY2UgKmRldiwK PiAgIAlyZXR1cm4gc25wcmludGYoYnVmLCBQQUdFX1NJWkUsICIldVxuIiwgdCk7Cj4gICB9Cj4g ICAKPiAtc3RhdGljIERFVklDRV9BVFRSKG51bV9kc2lfZXJyb3JzLCBTX0lSVUdPLCBkc2ljbV9u dW1fZXJyb3JzX3Nob3csIE5VTEwpOwo+IC1zdGF0aWMgREVWSUNFX0FUVFIoaHdfcmV2aXNpb24s IFNfSVJVR08sIGRzaWNtX2h3X3JldmlzaW9uX3Nob3csIE5VTEwpOwo+IC1zdGF0aWMgREVWSUNF X0FUVFIodWxwcywgU19JUlVHTyB8IFNfSVdVU1IsCj4gLQkJZHNpY21fc2hvd191bHBzLCBkc2lj bV9zdG9yZV91bHBzKTsKPiAtc3RhdGljIERFVklDRV9BVFRSKHVscHNfdGltZW91dCwgU19JUlVH TyB8IFNfSVdVU1IsCj4gLQkJZHNpY21fc2hvd191bHBzX3RpbWVvdXQsIGRzaWNtX3N0b3JlX3Vs cHNfdGltZW91dCk7Cj4gK3N0YXRpYyBERVZJQ0VfQVRUUihudW1fZHNpX2Vycm9ycywgMDQ0NCwg ZHNpY21fbnVtX2Vycm9yc19zaG93LCBOVUxMKTsKPiArc3RhdGljIERFVklDRV9BVFRSKGh3X3Jl dmlzaW9uLCAwNDQ0LCBkc2ljbV9od19yZXZpc2lvbl9zaG93LCBOVUxMKTsKPiArc3RhdGljIERF VklDRV9BVFRSKHVscHMsIDA2NDQsIGRzaWNtX3Nob3dfdWxwcywgZHNpY21fc3RvcmVfdWxwcyk7 Cj4gK3N0YXRpYyBERVZJQ0VfQVRUUih1bHBzX3RpbWVvdXQsIDA2NDQsCj4gKwkJICAgZHNpY21f c2hvd191bHBzX3RpbWVvdXQsIGRzaWNtX3N0b3JlX3VscHNfdGltZW91dCk7Cj4gICAKPiAgIHN0 YXRpYyBzdHJ1Y3QgYXR0cmlidXRlICpkc2ljbV9hdHRyc1tdID0gewo+ICAgCSZkZXZfYXR0cl9u dW1fZHNpX2Vycm9ycy5hdHRyLAo+IGRpZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9kcm0vb21hcGRy bS9kaXNwbGF5cy9wYW5lbC1zb255LWFjeDU2NWFrbS5jIGIvZHJpdmVycy9ncHUvZHJtL29tYXBk cm0vZGlzcGxheXMvcGFuZWwtc29ueS1hY3g1NjVha20uYwo+IGluZGV4IDkyZmUxMjVjZTIyZS4u MzdhMzRkNTVlYjk5IDEwMDY0NAo+IC0tLSBhL2RyaXZlcnMvZ3B1L2RybS9vbWFwZHJtL2Rpc3Bs YXlzL3BhbmVsLXNvbnktYWN4NTY1YWttLmMKPiArKysgYi9kcml2ZXJzL2dwdS9kcm0vb21hcGRy bS9kaXNwbGF5cy9wYW5lbC1zb255LWFjeDU2NWFrbS5jCj4gQEAgLTQ5MiwxMCArNDkyLDggQEAg c3RhdGljIHNzaXplX3Qgc2hvd19jYWJjX2F2YWlsYWJsZV9tb2RlcyhzdHJ1Y3QgZGV2aWNlICpk ZXYsCj4gICAJcmV0dXJuIGxlbiA8IFBBR0VfU0laRSA/IGxlbiA6IFBBR0VfU0laRSAtIDE7Cj4g ICB9Cj4gICAKPiAtc3RhdGljIERFVklDRV9BVFRSKGNhYmNfbW9kZSwgU19JUlVHTyB8IFNfSVdV U1IsCj4gLQkJc2hvd19jYWJjX21vZGUsIHN0b3JlX2NhYmNfbW9kZSk7Cj4gLXN0YXRpYyBERVZJ Q0VfQVRUUihjYWJjX2F2YWlsYWJsZV9tb2RlcywgU19JUlVHTywKPiAtCQlzaG93X2NhYmNfYXZh aWxhYmxlX21vZGVzLCBOVUxMKTsKPiArc3RhdGljIERFVklDRV9BVFRSKGNhYmNfbW9kZSwgMDY0 NCwgc2hvd19jYWJjX21vZGUsIHN0b3JlX2NhYmNfbW9kZSk7Cj4gK3N0YXRpYyBERVZJQ0VfQVRU UihjYWJjX2F2YWlsYWJsZV9tb2RlcywgMDQ0NCwgc2hvd19jYWJjX2F2YWlsYWJsZV9tb2Rlcywg TlVMTCk7Cj4gICAKPiAgIHN0YXRpYyBzdHJ1Y3QgYXR0cmlidXRlICpibGRldl9hdHRyc1tdID0g ewo+ICAgCSZkZXZfYXR0cl9jYWJjX21vZGUuYXR0ciwKPiBkaWZmIC0tZ2l0IGEvZHJpdmVycy9n cHUvZHJtL29tYXBkcm0vZGlzcGxheXMvcGFuZWwtdHBvLXRkMDQzbXRlYTEuYyBiL2RyaXZlcnMv Z3B1L2RybS9vbWFwZHJtL2Rpc3BsYXlzL3BhbmVsLXRwby10ZDA0M210ZWExLmMKPiBpbmRleCBj MDhlMjJiNDM0NDcuLmUwNmZlNjFmOGM3ZSAxMDA2NDQKPiAtLS0gYS9kcml2ZXJzL2dwdS9kcm0v b21hcGRybS9kaXNwbGF5cy9wYW5lbC10cG8tdGQwNDNtdGVhMS5jCj4gKysrIGIvZHJpdmVycy9n cHUvZHJtL29tYXBkcm0vZGlzcGxheXMvcGFuZWwtdHBvLXRkMDQzbXRlYTEuYwo+IEBAIC0yNjgs MTIgKzI2OCwxMCBAQCBzdGF0aWMgc3NpemVfdCB0cG9fdGQwNDNfZ2FtbWFfc3RvcmUoc3RydWN0 IGRldmljZSAqZGV2LAo+ICAgCXJldHVybiBjb3VudDsKPiAgIH0KPiAgIAo+IC1zdGF0aWMgREVW SUNFX0FUVFIodm1pcnJvciwgU19JUlVHTyB8IFNfSVdVU1IsCj4gLQkJdHBvX3RkMDQzX3ZtaXJy b3Jfc2hvdywgdHBvX3RkMDQzX3ZtaXJyb3Jfc3RvcmUpOwo+IC1zdGF0aWMgREVWSUNFX0FUVFIo bW9kZSwgU19JUlVHTyB8IFNfSVdVU1IsCj4gLQkJdHBvX3RkMDQzX21vZGVfc2hvdywgdHBvX3Rk MDQzX21vZGVfc3RvcmUpOwo+IC1zdGF0aWMgREVWSUNFX0FUVFIoZ2FtbWEsIFNfSVJVR08gfCBT X0lXVVNSLAo+IC0JCXRwb190ZDA0M19nYW1tYV9zaG93LCB0cG9fdGQwNDNfZ2FtbWFfc3RvcmUp Owo+ICtzdGF0aWMgREVWSUNFX0FUVFIodm1pcnJvciwgMDY0NCwKPiArCQkgICB0cG9fdGQwNDNf dm1pcnJvcl9zaG93LCB0cG9fdGQwNDNfdm1pcnJvcl9zdG9yZSk7Cj4gK3N0YXRpYyBERVZJQ0Vf QVRUUihtb2RlLCAwNjQ0LCB0cG9fdGQwNDNfbW9kZV9zaG93LCB0cG9fdGQwNDNfbW9kZV9zdG9y ZSk7Cj4gK3N0YXRpYyBERVZJQ0VfQVRUUihnYW1tYSwgMDY0NCwgdHBvX3RkMDQzX2dhbW1hX3No b3csIHRwb190ZDA0M19nYW1tYV9zdG9yZSk7Cj4gICAKPiAgIHN0YXRpYyBzdHJ1Y3QgYXR0cmli dXRlICp0cG9fdGQwNDNfYXR0cnNbXSA9IHsKPiAgIAkmZGV2X2F0dHJfdm1pcnJvci5hdHRyLAo+ IGRpZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9kcm0vcmFkZW9uL3JhZGVvbl9wbS5jIGIvZHJpdmVy cy9ncHUvZHJtL3JhZGVvbi9yYWRlb25fcG0uYwo+IGluZGV4IDRiNjU0MjUzOGZmOS4uNDU4MDFj MjdkMjNiIDEwMDY0NAo+IC0tLSBhL2RyaXZlcnMvZ3B1L2RybS9yYWRlb24vcmFkZW9uX3BtLmMK PiArKysgYi9kcml2ZXJzL2dwdS9kcm0vcmFkZW9uL3JhZGVvbl9wbS5jCj4gQEAgLTY1NSwxMCAr NjU1LDEwIEBAIHN0YXRpYyBzc2l6ZV90IHJhZGVvbl9od21vbl9nZXRfcHdtMShzdHJ1Y3QgZGV2 aWNlICpkZXYsCj4gICAJcmV0dXJuIHNwcmludGYoYnVmLCAiJWlcbiIsIHNwZWVkKTsKPiAgIH0K PiAgIAo+IC1zdGF0aWMgREVWSUNFX0FUVFIocG93ZXJfcHJvZmlsZSwgU19JUlVHTyB8IFNfSVdV U1IsIHJhZGVvbl9nZXRfcG1fcHJvZmlsZSwgcmFkZW9uX3NldF9wbV9wcm9maWxlKTsKPiAtc3Rh dGljIERFVklDRV9BVFRSKHBvd2VyX21ldGhvZCwgU19JUlVHTyB8IFNfSVdVU1IsIHJhZGVvbl9n ZXRfcG1fbWV0aG9kLCByYWRlb25fc2V0X3BtX21ldGhvZCk7Cj4gLXN0YXRpYyBERVZJQ0VfQVRU Uihwb3dlcl9kcG1fc3RhdGUsIFNfSVJVR08gfCBTX0lXVVNSLCByYWRlb25fZ2V0X2RwbV9zdGF0 ZSwgcmFkZW9uX3NldF9kcG1fc3RhdGUpOwo+IC1zdGF0aWMgREVWSUNFX0FUVFIocG93ZXJfZHBt X2ZvcmNlX3BlcmZvcm1hbmNlX2xldmVsLCBTX0lSVUdPIHwgU19JV1VTUiwKPiArc3RhdGljIERF VklDRV9BVFRSKHBvd2VyX3Byb2ZpbGUsIDA2NDQsIHJhZGVvbl9nZXRfcG1fcHJvZmlsZSwgcmFk ZW9uX3NldF9wbV9wcm9maWxlKTsKPiArc3RhdGljIERFVklDRV9BVFRSKHBvd2VyX21ldGhvZCwg MDY0NCwgcmFkZW9uX2dldF9wbV9tZXRob2QsIHJhZGVvbl9zZXRfcG1fbWV0aG9kKTsKPiArc3Rh dGljIERFVklDRV9BVFRSKHBvd2VyX2RwbV9zdGF0ZSwgMDY0NCwgcmFkZW9uX2dldF9kcG1fc3Rh dGUsIHJhZGVvbl9zZXRfZHBtX3N0YXRlKTsKPiArc3RhdGljIERFVklDRV9BVFRSKHBvd2VyX2Rw bV9mb3JjZV9wZXJmb3JtYW5jZV9sZXZlbCwgMDY0NCwKPiAgIAkJICAgcmFkZW9uX2dldF9kcG1f Zm9yY2VkX3BlcmZvcm1hbmNlX2xldmVsLAo+ICAgCQkgICByYWRlb25fc2V0X2RwbV9mb3JjZWRf cGVyZm9ybWFuY2VfbGV2ZWwpOwo+ICAgCj4gQEAgLTY5OSwxMyArNjk5LDEzIEBAIHN0YXRpYyBz c2l6ZV90IHJhZGVvbl9od21vbl9zaG93X3RlbXBfdGhyZXNoKHN0cnVjdCBkZXZpY2UgKmRldiwK PiAgIAlyZXR1cm4gc25wcmludGYoYnVmLCBQQUdFX1NJWkUsICIlZFxuIiwgdGVtcCk7Cj4gICB9 Cj4gICAKPiAtc3RhdGljIFNFTlNPUl9ERVZJQ0VfQVRUUih0ZW1wMV9pbnB1dCwgU19JUlVHTywg cmFkZW9uX2h3bW9uX3Nob3dfdGVtcCwgTlVMTCwgMCk7Cj4gLXN0YXRpYyBTRU5TT1JfREVWSUNF X0FUVFIodGVtcDFfY3JpdCwgU19JUlVHTywgcmFkZW9uX2h3bW9uX3Nob3dfdGVtcF90aHJlc2gs IE5VTEwsIDApOwo+IC1zdGF0aWMgU0VOU09SX0RFVklDRV9BVFRSKHRlbXAxX2NyaXRfaHlzdCwg U19JUlVHTywgcmFkZW9uX2h3bW9uX3Nob3dfdGVtcF90aHJlc2gsIE5VTEwsIDEpOwo+IC1zdGF0 aWMgU0VOU09SX0RFVklDRV9BVFRSKHB3bTEsIFNfSVJVR08gfCBTX0lXVVNSLCByYWRlb25faHdt b25fZ2V0X3B3bTEsIHJhZGVvbl9od21vbl9zZXRfcHdtMSwgMCk7Cj4gLXN0YXRpYyBTRU5TT1Jf REVWSUNFX0FUVFIocHdtMV9lbmFibGUsIFNfSVJVR08gfCBTX0lXVVNSLCByYWRlb25faHdtb25f Z2V0X3B3bTFfZW5hYmxlLCByYWRlb25faHdtb25fc2V0X3B3bTFfZW5hYmxlLCAwKTsKPiAtc3Rh dGljIFNFTlNPUl9ERVZJQ0VfQVRUUihwd20xX21pbiwgU19JUlVHTywgcmFkZW9uX2h3bW9uX2dl dF9wd20xX21pbiwgTlVMTCwgMCk7Cj4gLXN0YXRpYyBTRU5TT1JfREVWSUNFX0FUVFIocHdtMV9t YXgsIFNfSVJVR08sIHJhZGVvbl9od21vbl9nZXRfcHdtMV9tYXgsIE5VTEwsIDApOwo+ICtzdGF0 aWMgU0VOU09SX0RFVklDRV9BVFRSKHRlbXAxX2lucHV0LCAwNDQ0LCByYWRlb25faHdtb25fc2hv d190ZW1wLCBOVUxMLCAwKTsKPiArc3RhdGljIFNFTlNPUl9ERVZJQ0VfQVRUUih0ZW1wMV9jcml0 LCAwNDQ0LCByYWRlb25faHdtb25fc2hvd190ZW1wX3RocmVzaCwgTlVMTCwgMCk7Cj4gK3N0YXRp YyBTRU5TT1JfREVWSUNFX0FUVFIodGVtcDFfY3JpdF9oeXN0LCAwNDQ0LCByYWRlb25faHdtb25f c2hvd190ZW1wX3RocmVzaCwgTlVMTCwgMSk7Cj4gK3N0YXRpYyBTRU5TT1JfREVWSUNFX0FUVFIo cHdtMSwgMDY0NCwgcmFkZW9uX2h3bW9uX2dldF9wd20xLCByYWRlb25faHdtb25fc2V0X3B3bTEs IDApOwo+ICtzdGF0aWMgU0VOU09SX0RFVklDRV9BVFRSKHB3bTFfZW5hYmxlLCAwNjQ0LCByYWRl b25faHdtb25fZ2V0X3B3bTFfZW5hYmxlLCByYWRlb25faHdtb25fc2V0X3B3bTFfZW5hYmxlLCAw KTsKPiArc3RhdGljIFNFTlNPUl9ERVZJQ0VfQVRUUihwd20xX21pbiwgMDQ0NCwgcmFkZW9uX2h3 bW9uX2dldF9wd20xX21pbiwgTlVMTCwgMCk7Cj4gK3N0YXRpYyBTRU5TT1JfREVWSUNFX0FUVFIo cHdtMV9tYXgsIDA0NDQsIHJhZGVvbl9od21vbl9nZXRfcHdtMV9tYXgsIE5VTEwsIDApOwo+ICAg Cj4gICAKPiAgIHN0YXRpYyBzdHJ1Y3QgYXR0cmlidXRlICpod21vbl9hdHRyaWJ1dGVzW10gPSB7 Cj4gQEAgLTc0OSwxMyArNzQ5LDEzIEBAIHN0YXRpYyB1bW9kZV90IGh3bW9uX2F0dHJpYnV0ZXNf dmlzaWJsZShzdHJ1Y3Qga29iamVjdCAqa29iaiwKPiAgIAkgICAgIGF0dHIgPT0gJnNlbnNvcl9k ZXZfYXR0cl9wd20xLmRldl9hdHRyLmF0dHIpIHx8IC8qIGNhbid0IHF1ZXJ5IGZhbiAqLwo+ICAg CSAgICAoIXJkZXYtPmFzaWMtPmRwbS5mYW5fY3RybF9nZXRfbW9kZSAmJgo+ICAgCSAgICAgYXR0 ciA9PSAmc2Vuc29yX2Rldl9hdHRyX3B3bTFfZW5hYmxlLmRldl9hdHRyLmF0dHIpKSAvKiBjYW4n dCBxdWVyeSBzdGF0ZSAqLwo+IC0JCWVmZmVjdGl2ZV9tb2RlICY9IH5TX0lSVUdPOwo+ICsJCWVm ZmVjdGl2ZV9tb2RlICY9IH4wNDQ0Owo+ICAgCj4gICAJaWYgKCghcmRldi0+YXNpYy0+ZHBtLnNl dF9mYW5fc3BlZWRfcGVyY2VudCAmJgo+ICAgCSAgICAgYXR0ciA9PSAmc2Vuc29yX2Rldl9hdHRy X3B3bTEuZGV2X2F0dHIuYXR0cikgfHwgLyogY2FuJ3QgbWFuYWdlIGZhbiAqLwo+ICAgCSAgICAo IXJkZXYtPmFzaWMtPmRwbS5mYW5fY3RybF9zZXRfbW9kZSAmJgo+ICAgCSAgICAgYXR0ciA9PSAm c2Vuc29yX2Rldl9hdHRyX3B3bTFfZW5hYmxlLmRldl9hdHRyLmF0dHIpKSAvKiBjYW4ndCBtYW5h Z2Ugc3RhdGUgKi8KPiAtCQllZmZlY3RpdmVfbW9kZSAmPSB+U19JV1VTUjsKPiArCQllZmZlY3Rp dmVfbW9kZSAmPSB+MDIwMDsKPiAgIAo+ICAgCS8qIGhpZGUgbWF4L21pbiB2YWx1ZXMgaWYgd2Ug Y2FuJ3QgYm90aCBxdWVyeSBhbmQgbWFuYWdlIHRoZSBmYW4gKi8KPiAgIAlpZiAoKCFyZGV2LT5h c2ljLT5kcG0uc2V0X2Zhbl9zcGVlZF9wZXJjZW50ICYmCj4gZGlmZiAtLWdpdCBhL2RyaXZlcnMv Z3B1L2RybS9yYWRlb24vcmFkZW9uX3R0bS5jIGIvZHJpdmVycy9ncHUvZHJtL3JhZGVvbi9yYWRl b25fdHRtLmMKPiBpbmRleCA4Njg5ZmNjYTA1MWMuLjcxYjJiZWQwYjk4MyAxMDA2NDQKPiAtLS0g YS9kcml2ZXJzL2dwdS9kcm0vcmFkZW9uL3JhZGVvbl90dG0uYwo+ICsrKyBiL2RyaXZlcnMvZ3B1 L2RybS9yYWRlb24vcmFkZW9uX3R0bS5jCj4gQEAgLTExMzYsMTMgKzExMzYsMTMgQEAgc3RhdGlj IGludCByYWRlb25fdHRtX2RlYnVnZnNfaW5pdChzdHJ1Y3QgcmFkZW9uX2RldmljZSAqcmRldikK PiAgIAlzdHJ1Y3QgZHJtX21pbm9yICptaW5vciA9IHJkZXYtPmRkZXYtPnByaW1hcnk7Cj4gICAJ c3RydWN0IGRlbnRyeSAqZW50LCAqcm9vdCA9IG1pbm9yLT5kZWJ1Z2ZzX3Jvb3Q7Cj4gICAKPiAt CWVudCA9IGRlYnVnZnNfY3JlYXRlX2ZpbGUoInJhZGVvbl92cmFtIiwgU19JRlJFRyB8IFNfSVJV R08sIHJvb3QsCj4gKwllbnQgPSBkZWJ1Z2ZzX2NyZWF0ZV9maWxlKCJyYWRlb25fdnJhbSIsIFNf SUZSRUcgfCAwNDQ0LCByb290LAo+ICAgCQkJCSAgcmRldiwgJnJhZGVvbl90dG1fdnJhbV9mb3Bz KTsKPiAgIAlpZiAoSVNfRVJSKGVudCkpCj4gICAJCXJldHVybiBQVFJfRVJSKGVudCk7Cj4gICAJ cmRldi0+bW1hbi52cmFtID0gZW50Owo+ICAgCj4gLQllbnQgPSBkZWJ1Z2ZzX2NyZWF0ZV9maWxl KCJyYWRlb25fZ3R0IiwgU19JRlJFRyB8IFNfSVJVR08sIHJvb3QsCj4gKwllbnQgPSBkZWJ1Z2Zz X2NyZWF0ZV9maWxlKCJyYWRlb25fZ3R0IiwgU19JRlJFRyB8IDA0NDQsIHJvb3QsCj4gICAJCQkJ ICByZGV2LCAmcmFkZW9uX3R0bV9ndHRfZm9wcyk7Cj4gICAJaWYgKElTX0VSUihlbnQpKQo+ICAg CQlyZXR1cm4gUFRSX0VSUihlbnQpOwo+IGRpZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9kcm0vc3Rp L3N0aV9kcnYuYyBiL2RyaXZlcnMvZ3B1L2RybS9zdGkvc3RpX2Rydi5jCj4gaW5kZXggOTBjNDZi NDljOTMxLi5mYWZhOWE3ODE0OTMgMTAwNjQ0Cj4gLS0tIGEvZHJpdmVycy9ncHUvZHJtL3N0aS9z dGlfZHJ2LmMKPiArKysgYi9kcml2ZXJzL2dwdS9kcm0vc3RpL3N0aV9kcnYuYwo+IEBAIC0xMDQs NyArMTA0LDcgQEAgc3RhdGljIGludCBzdGlfZHJtX2RiZ19pbml0KHN0cnVjdCBkcm1fbWlub3Ig Km1pbm9yKQo+ICAgCWlmIChyZXQpCj4gICAJCWdvdG8gZXJyOwo+ICAgCj4gLQlkZW50cnkgPSBk ZWJ1Z2ZzX2NyZWF0ZV9maWxlKCJmcHNfc2hvdyIsIFNfSVJVR08gfCBTX0lXVVNSLAo+ICsJZGVu dHJ5ID0gZGVidWdmc19jcmVhdGVfZmlsZSgiZnBzX3Nob3ciLCAwNjQ0LAo+ICAgCQkJCSAgICAg bWlub3ItPmRlYnVnZnNfcm9vdCwgbWlub3ItPmRldiwKPiAgIAkJCQkgICAgICZzdGlfZHJtX2Zw c19mb3BzKTsKPiAgIAlpZiAoIWRlbnRyeSkgewo+IGRpZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9k cm0vdGlueWRybS9taXBpLWRiaS5jIGIvZHJpdmVycy9ncHUvZHJtL3Rpbnlkcm0vbWlwaS1kYmku Ywo+IGluZGV4IDRkMWZiMzFhNzgxZi4uNTViZDM4ZjE1MDdiIDEwMDY0NAo+IC0tLSBhL2RyaXZl cnMvZ3B1L2RybS90aW55ZHJtL21pcGktZGJpLmMKPiArKysgYi9kcml2ZXJzL2dwdS9kcm0vdGlu eWRybS9taXBpLWRiaS5jCj4gQEAgLTEwNTUsMTAgKzEwNTUsMTAgQEAgaW50IG1pcGlfZGJpX2Rl YnVnZnNfaW5pdChzdHJ1Y3QgZHJtX21pbm9yICptaW5vcikKPiAgIHsKPiAgIAlzdHJ1Y3QgdGlu eWRybV9kZXZpY2UgKnRkZXYgPSBtaW5vci0+ZGV2LT5kZXZfcHJpdmF0ZTsKPiAgIAlzdHJ1Y3Qg bWlwaV9kYmkgKm1pcGkgPSBtaXBpX2RiaV9mcm9tX3Rpbnlkcm0odGRldik7Cj4gLQl1bW9kZV90 IG1vZGUgPSBTX0lGUkVHIHwgU19JV1VTUjsKPiArCXVtb2RlX3QgbW9kZSA9IFNfSUZSRUcgfCAw MjAwOwo+ICAgCj4gICAJaWYgKG1pcGktPnJlYWRfY29tbWFuZHMpCj4gLQkJbW9kZSB8PSBTX0lS VUdPOwo+ICsJCW1vZGUgfD0gMDQ0NDsKPiAgIAlkZWJ1Z2ZzX2NyZWF0ZV9maWxlKCJjb21tYW5k IiwgbW9kZSwgbWlub3ItPmRlYnVnZnNfcm9vdCwgbWlwaSwKPiAgIAkJCSAgICAmbWlwaV9kYmlf ZGVidWdmc19jb21tYW5kX2ZvcHMpOwo+ICAgCj4gZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2Ry bS90dG0vdHRtX2JvLmMgYi9kcml2ZXJzL2dwdS9kcm0vdHRtL3R0bV9iby5jCj4gaW5kZXggNWQ4 Njg4ZTUyMmQxLi45MDg0M2Q3ZDEwYTggMTAwNjQ0Cj4gLS0tIGEvZHJpdmVycy9ncHUvZHJtL3R0 bS90dG1fYm8uYwo+ICsrKyBiL2RyaXZlcnMvZ3B1L2RybS90dG0vdHRtX2JvLmMKPiBAQCAtNDcs NyArNDcsNyBAQCBzdGF0aWMgdm9pZCB0dG1fYm9fZ2xvYmFsX2tvYmpfcmVsZWFzZShzdHJ1Y3Qg a29iamVjdCAqa29iaik7Cj4gICAKPiAgIHN0YXRpYyBzdHJ1Y3QgYXR0cmlidXRlIHR0bV9ib19j b3VudCA9IHsKPiAgIAkubmFtZSA9ICJib19jb3VudCIsCj4gLQkubW9kZSA9IFNfSVJVR08KPiAr CS5tb2RlID0gMDQ0NAo+ICAgfTsKPiAgIAo+ICAgLyogZGVmYXVsdCBkZXN0cnVjdG9yICovCj4g ZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2RybS90dG0vdHRtX21lbW9yeS5jIGIvZHJpdmVycy9n cHUvZHJtL3R0bS90dG1fbWVtb3J5LmMKPiBpbmRleCA0NTAzODdjOTJiNjMuLmUxN2E1OGRjOTBm NSAxMDA2NDQKPiAtLS0gYS9kcml2ZXJzL2dwdS9kcm0vdHRtL3R0bV9tZW1vcnkuYwo+ICsrKyBi L2RyaXZlcnMvZ3B1L2RybS90dG0vdHRtX21lbW9yeS5jCj4gQEAgLTU0LDIzICs1NCwyMyBAQCBz dHJ1Y3QgdHRtX21lbV96b25lIHsKPiAgIAo+ICAgc3RhdGljIHN0cnVjdCBhdHRyaWJ1dGUgdHRt X21lbV9zeXMgPSB7Cj4gICAJLm5hbWUgPSAiem9uZV9tZW1vcnkiLAo+IC0JLm1vZGUgPSBTX0lS VUdPCj4gKwkubW9kZSA9IDA0NDQKPiAgIH07Cj4gICBzdGF0aWMgc3RydWN0IGF0dHJpYnV0ZSB0 dG1fbWVtX2VtZXIgPSB7Cj4gICAJLm5hbWUgPSAiZW1lcmdlbmN5X21lbW9yeSIsCj4gLQkubW9k ZSA9IFNfSVJVR08gfCBTX0lXVVNSCj4gKwkubW9kZSA9IDA2NDQKPiAgIH07Cj4gICBzdGF0aWMg c3RydWN0IGF0dHJpYnV0ZSB0dG1fbWVtX21heCA9IHsKPiAgIAkubmFtZSA9ICJhdmFpbGFibGVf bWVtb3J5IiwKPiAtCS5tb2RlID0gU19JUlVHTyB8IFNfSVdVU1IKPiArCS5tb2RlID0gMDY0NAo+ ICAgfTsKPiAgIHN0YXRpYyBzdHJ1Y3QgYXR0cmlidXRlIHR0bV9tZW1fc3dhcCA9IHsKPiAgIAku bmFtZSA9ICJzd2FwX2xpbWl0IiwKPiAtCS5tb2RlID0gU19JUlVHTyB8IFNfSVdVU1IKPiArCS5t b2RlID0gMDY0NAo+ICAgfTsKPiAgIHN0YXRpYyBzdHJ1Y3QgYXR0cmlidXRlIHR0bV9tZW1fdXNl ZCA9IHsKPiAgIAkubmFtZSA9ICJ1c2VkX21lbW9yeSIsCj4gLQkubW9kZSA9IFNfSVJVR08KPiAr CS5tb2RlID0gMDQ0NAo+ICAgfTsKPiAgIAo+ICAgc3RhdGljIHZvaWQgdHRtX21lbV96b25lX2tv YmpfcmVsZWFzZShzdHJ1Y3Qga29iamVjdCAqa29iaikKPiBAQCAtMTcwLDcgKzE3MCw3IEBAIHN0 YXRpYyBzdHJ1Y3Qga29ial90eXBlIHR0bV9tZW1fem9uZV9rb2JqX3R5cGUgPSB7Cj4gICAKPiAg IHN0YXRpYyBzdHJ1Y3QgYXR0cmlidXRlIHR0bV9tZW1fZ2xvYmFsX2xvd2VyX21lbV9saW1pdCA9 IHsKPiAgIAkubmFtZSA9ICJsb3dlcl9tZW1fbGltaXQiLAo+IC0JLm1vZGUgPSBTX0lSVUdPIHwg U19JV1VTUgo+ICsJLm1vZGUgPSAwNjQ0Cj4gICB9Owo+ICAgCj4gICBzdGF0aWMgc3NpemVfdCB0 dG1fbWVtX2dsb2JhbF9zaG93KHN0cnVjdCBrb2JqZWN0ICprb2JqLAo+IGRpZmYgLS1naXQgYS9k cml2ZXJzL2dwdS9kcm0vdHRtL3R0bV9wYWdlX2FsbG9jLmMgYi9kcml2ZXJzL2dwdS9kcm0vdHRt L3R0bV9wYWdlX2FsbG9jLmMKPiBpbmRleCAwNmM5NGUzYTVmMTUuLjk0MmQwNTFlNjgzMyAxMDA2 NDQKPiAtLS0gYS9kcml2ZXJzL2dwdS9kcm0vdHRtL3R0bV9wYWdlX2FsbG9jLmMKPiArKysgYi9k cml2ZXJzL2dwdS9kcm0vdHRtL3R0bV9wYWdlX2FsbG9jLmMKPiBAQCAtMTMxLDE1ICsxMzEsMTUg QEAgc3RydWN0IHR0bV9wb29sX21hbmFnZXIgewo+ICAgCj4gICBzdGF0aWMgc3RydWN0IGF0dHJp YnV0ZSB0dG1fcGFnZV9wb29sX21heCA9IHsKPiAgIAkubmFtZSA9ICJwb29sX21heF9zaXplIiwK PiAtCS5tb2RlID0gU19JUlVHTyB8IFNfSVdVU1IKPiArCS5tb2RlID0gMDY0NAo+ICAgfTsKPiAg IHN0YXRpYyBzdHJ1Y3QgYXR0cmlidXRlIHR0bV9wYWdlX3Bvb2xfc21hbGwgPSB7Cj4gICAJLm5h bWUgPSAicG9vbF9zbWFsbF9hbGxvY2F0aW9uIiwKPiAtCS5tb2RlID0gU19JUlVHTyB8IFNfSVdV U1IKPiArCS5tb2RlID0gMDY0NAo+ICAgfTsKPiAgIHN0YXRpYyBzdHJ1Y3QgYXR0cmlidXRlIHR0 bV9wYWdlX3Bvb2xfYWxsb2Nfc2l6ZSA9IHsKPiAgIAkubmFtZSA9ICJwb29sX2FsbG9jYXRpb25f c2l6ZSIsCj4gLQkubW9kZSA9IFNfSVJVR08gfCBTX0lXVVNSCj4gKwkubW9kZSA9IDA2NDQKPiAg IH07Cj4gICAKPiAgIHN0YXRpYyBzdHJ1Y3QgYXR0cmlidXRlICp0dG1fcG9vbF9hdHRyc1tdID0g ewo+IGRpZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9kcm0vdHRtL3R0bV9wYWdlX2FsbG9jX2RtYS5j IGIvZHJpdmVycy9ncHUvZHJtL3R0bS90dG1fcGFnZV9hbGxvY19kbWEuYwo+IGluZGV4IGY2M2Q5 OWMzMDJlNC4uMjUxMzQzZjgxNmUxIDEwMDY0NAo+IC0tLSBhL2RyaXZlcnMvZ3B1L2RybS90dG0v dHRtX3BhZ2VfYWxsb2NfZG1hLmMKPiArKysgYi9kcml2ZXJzL2dwdS9kcm0vdHRtL3R0bV9wYWdl X2FsbG9jX2RtYS5jCj4gQEAgLTE3OCwxNSArMTc4LDE1IEBAIHN0YXRpYyBzdHJ1Y3QgdHRtX3Bv b2xfbWFuYWdlciAqX21hbmFnZXI7Cj4gICAKPiAgIHN0YXRpYyBzdHJ1Y3QgYXR0cmlidXRlIHR0 bV9wYWdlX3Bvb2xfbWF4ID0gewo+ICAgCS5uYW1lID0gInBvb2xfbWF4X3NpemUiLAo+IC0JLm1v ZGUgPSBTX0lSVUdPIHwgU19JV1VTUgo+ICsJLm1vZGUgPSAwNjQ0Cj4gICB9Owo+ICAgc3RhdGlj IHN0cnVjdCBhdHRyaWJ1dGUgdHRtX3BhZ2VfcG9vbF9zbWFsbCA9IHsKPiAgIAkubmFtZSA9ICJw b29sX3NtYWxsX2FsbG9jYXRpb24iLAo+IC0JLm1vZGUgPSBTX0lSVUdPIHwgU19JV1VTUgo+ICsJ Lm1vZGUgPSAwNjQ0Cj4gICB9Owo+ICAgc3RhdGljIHN0cnVjdCBhdHRyaWJ1dGUgdHRtX3BhZ2Vf cG9vbF9hbGxvY19zaXplID0gewo+ICAgCS5uYW1lID0gInBvb2xfYWxsb2NhdGlvbl9zaXplIiwK PiAtCS5tb2RlID0gU19JUlVHTyB8IFNfSVdVU1IKPiArCS5tb2RlID0gMDY0NAo+ICAgfTsKPiAg IAo+ICAgc3RhdGljIHN0cnVjdCBhdHRyaWJ1dGUgKnR0bV9wb29sX2F0dHJzW10gPSB7Cj4gZGlm ZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2RybS91ZGwvdWRsX2ZiLmMgYi9kcml2ZXJzL2dwdS9kcm0v dWRsL3VkbF9mYi5jCj4gaW5kZXggMmViZGM2ZDVhNzZlLi40NjNmYjE2NjU5ZDggMTAwNjQ0Cj4g LS0tIGEvZHJpdmVycy9ncHUvZHJtL3VkbC91ZGxfZmIuYwo+ICsrKyBiL2RyaXZlcnMvZ3B1L2Ry bS91ZGwvdWRsX2ZiLmMKPiBAQCAtMjgsOCArMjgsOCBAQAo+ICAgc3RhdGljIGludCBmYl9kZWZp byA9IDA7ICAvKiBPcHRpb25hbGx5IGVuYWJsZSBleHBlcmltZW50YWwgZmJfZGVmaW8gbW1hcCBz dXBwb3J0ICovCj4gICBzdGF0aWMgaW50IGZiX2JwcCA9IDE2Owo+ICAgCj4gLW1vZHVsZV9wYXJh bShmYl9icHAsIGludCwgU19JV1VTUiB8IFNfSVJVU1IgfCBTX0lXR1JQIHwgU19JUkdSUCk7Cj4g LW1vZHVsZV9wYXJhbShmYl9kZWZpbywgaW50LCBTX0lXVVNSIHwgU19JUlVTUiB8IFNfSVdHUlAg fCBTX0lSR1JQKTsKPiArbW9kdWxlX3BhcmFtKGZiX2JwcCwgaW50LCAwNjYwKTsKPiArbW9kdWxl X3BhcmFtKGZiX2RlZmlvLCBpbnQsIDA2NjApOwo+ICAgCj4gICBzdHJ1Y3QgdWRsX2ZiZGV2IHsK PiAgIAlzdHJ1Y3QgZHJtX2ZiX2hlbHBlciBoZWxwZXI7Cj4gZGlmZiAtLWdpdCBhL2RyaXZlcnMv Z3B1L2hvc3QxeC9kZWJ1Zy5jIGIvZHJpdmVycy9ncHUvaG9zdDF4L2RlYnVnLmMKPiBpbmRleCAz MjllNGEzZDhhZTcuLmQ4MGUyNThmOTcyZiAxMDA2NDQKPiAtLS0gYS9kcml2ZXJzL2dwdS9ob3N0 MXgvZGVidWcuYwo+ICsrKyBiL2RyaXZlcnMvZ3B1L2hvc3QxeC9kZWJ1Zy5jCj4gQEAgLTE3Nywy MCArMTc3LDIwIEBAIHN0YXRpYyB2b2lkIGhvc3QxeF9kZWJ1Z2ZzX2luaXQoc3RydWN0IGhvc3Qx eCAqaG9zdDF4KQo+ICAgCS8qIFN0b3JlIHRoZSBjcmVhdGVkIGVudHJ5ICovCj4gICAJaG9zdDF4 LT5kZWJ1Z2ZzID0gZGU7Cj4gICAKPiAtCWRlYnVnZnNfY3JlYXRlX2ZpbGUoInN0YXR1cyIsIFNf SVJVR08sIGRlLCBob3N0MXgsICZob3N0MXhfZGVidWdfZm9wcyk7Cj4gLQlkZWJ1Z2ZzX2NyZWF0 ZV9maWxlKCJzdGF0dXNfYWxsIiwgU19JUlVHTywgZGUsIGhvc3QxeCwKPiArCWRlYnVnZnNfY3Jl YXRlX2ZpbGUoInN0YXR1cyIsIDA0NDQsIGRlLCBob3N0MXgsICZob3N0MXhfZGVidWdfZm9wcyk7 Cj4gKwlkZWJ1Z2ZzX2NyZWF0ZV9maWxlKCJzdGF0dXNfYWxsIiwgMDQ0NCwgZGUsIGhvc3QxeCwK PiAgIAkJCSAgICAmaG9zdDF4X2RlYnVnX2FsbF9mb3BzKTsKPiAgIAo+IC0JZGVidWdmc19jcmVh dGVfdTMyKCJ0cmFjZV9jbWRidWYiLCBTX0lSVUdPfFNfSVdVU1IsIGRlLAo+ICsJZGVidWdmc19j cmVhdGVfdTMyKCJ0cmFjZV9jbWRidWYiLCAwNjQ0LCBkZSwKPiAgIAkJCSAgICZob3N0MXhfZGVi dWdfdHJhY2VfY21kYnVmKTsKPiAgIAo+ICAgCWhvc3QxeF9od19kZWJ1Z19pbml0KGhvc3QxeCwg ZGUpOwo+ICAgCj4gLQlkZWJ1Z2ZzX2NyZWF0ZV91MzIoImZvcmNlX3RpbWVvdXRfcGlkIiwgU19J UlVHT3xTX0lXVVNSLCBkZSwKPiArCWRlYnVnZnNfY3JlYXRlX3UzMigiZm9yY2VfdGltZW91dF9w aWQiLCAwNjQ0LCBkZSwKPiAgIAkJCSAgICZob3N0MXhfZGVidWdfZm9yY2VfdGltZW91dF9waWQp Owo+IC0JZGVidWdmc19jcmVhdGVfdTMyKCJmb3JjZV90aW1lb3V0X3ZhbCIsIFNfSVJVR098U19J V1VTUiwgZGUsCj4gKwlkZWJ1Z2ZzX2NyZWF0ZV91MzIoImZvcmNlX3RpbWVvdXRfdmFsIiwgMDY0 NCwgZGUsCj4gICAJCQkgICAmaG9zdDF4X2RlYnVnX2ZvcmNlX3RpbWVvdXRfdmFsKTsKPiAtCWRl YnVnZnNfY3JlYXRlX3UzMigiZm9yY2VfdGltZW91dF9jaGFubmVsIiwgU19JUlVHT3xTX0lXVVNS LCBkZSwKPiArCWRlYnVnZnNfY3JlYXRlX3UzMigiZm9yY2VfdGltZW91dF9jaGFubmVsIiwgMDY0 NCwgZGUsCj4gICAJCQkgICAmaG9zdDF4X2RlYnVnX2ZvcmNlX3RpbWVvdXRfY2hhbm5lbCk7Cj4g ICB9Cj4gICAKCl9fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f CkludGVsLWdmeCBtYWlsaW5nIGxpc3QKSW50ZWwtZ2Z4QGxpc3RzLmZyZWVkZXNrdG9wLm9yZwpo dHRwczovL2xpc3RzLmZyZWVkZXNrdG9wLm9yZy9tYWlsbWFuL2xpc3RpbmZvL2ludGVsLWdmeAo= From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S935438AbeEYGqs (ORCPT ); Fri, 25 May 2018 02:46:48 -0400 Received: from mail-wm0-f65.google.com ([74.125.82.65]:38658 "EHLO mail-wm0-f65.google.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1751791AbeEYGqo (ORCPT ); Fri, 25 May 2018 02:46:44 -0400 X-Google-Smtp-Source: ADUXVKKvEsW3fehb9z2EEVoXmHO+Md+CJ+lDOLBX8+1wsfYHRVeKlaJDN6cKezgsdFJcROpx63fJ1g== Reply-To: christian.koenig@amd.com Subject: Re: [PATCH] gpu: Consistently use octal not symbolic permissions To: Joe Perches , Russell King , Gustavo Padovan , Maarten Lankhorst , Sean Paul , David Airlie , Zhenyu Wang , Zhi Wang , Jani Nikula , Joonas Lahtinen , Rodrigo Vivi , Rob Clark , Ben Skeggs , Alex Deucher , =?UTF-8?Q?Christian_K=c3=b6nig?= , "David (ChunMing) Zhou" , Benjamin Gaignard , Vincent Abriou , =?UTF-8?Q?Noralf_Tr=c3=b8nnes?= , Roger He , Dave Airlie , Thierry Reding Cc: freedreno@lists.freedesktop.org, linux-arm-msm@vger.kernel.org, intel-gfx@lists.freedesktop.org, linux-kernel@vger.kernel.org, dri-devel@lists.freedesktop.org, Tomi Valkeinen , amd-gfx@lists.freedesktop.org, nouveau@lists.freedesktop.org, linux-tegra@vger.kernel.org, intel-gvt-dev@lists.freedesktop.org References: <9b0f5f5cf6bccc003beef82f0972be655613075d.1527193246.git.joe@perches.com> From: =?UTF-8?Q?Christian_K=c3=b6nig?= Message-ID: Date: Fri, 25 May 2018 08:46:39 +0200 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: <9b0f5f5cf6bccc003beef82f0972be655613075d.1527193246.git.joe@perches.com> Content-Type: text/plain; charset=utf-8; format=flowed Content-Transfer-Encoding: 7bit Content-Language: en-US Sender: linux-kernel-owner@vger.kernel.org List-ID: X-Mailing-List: linux-kernel@vger.kernel.org Well I think we rejected that multiple times now. At least I find the symbolic permissions easier to read and I absolutely don't see any reason why we should only use one form. Christian. Am 24.05.2018 um 22:22 schrieb Joe Perches: > There is currently a mixture of octal and symbolic permissions uses > in files in drivers/gpu/drm and one file in drivers/gpu. > > There are ~270 existing octal uses and ~115 S_ uses. > > Convert all the S_ symbolic permissions to their octal equivalents > as using octal and not symbolic permissions is preferred by many as more > readable. > > see: https://lkml.org/lkml/2016/8/2/1945 > > Done with automated conversion via: > $ ./scripts/checkpatch.pl -f --types=SYMBOLIC_PERMS --fix-inplace > > Miscellanea: > > o Wrapped modified multi-line calls to a single line where appropriate > o Realign modified multi-line calls to open parenthesis > o drivers/gpu/drm/msm/adreno/a5xx_debugfs.c has a world-writeable > debug permission for "reset" - perhaps that should be modified > > Signed-off-by: Joe Perches > --- > drivers/gpu/drm/amd/amdgpu/amdgpu_debugfs.c | 2 +- > drivers/gpu/drm/amd/amdgpu/amdgpu_pm.c | 98 +++++++++++----------- > drivers/gpu/drm/amd/amdgpu/amdgpu_ring.c | 3 +- > drivers/gpu/drm/amd/amdgpu/amdgpu_ttm.c | 9 +- > drivers/gpu/drm/armada/armada_debugfs.c | 4 +- > drivers/gpu/drm/drm_debugfs.c | 6 +- > drivers/gpu/drm/drm_debugfs_crc.c | 4 +- > drivers/gpu/drm/drm_sysfs.c | 2 +- > drivers/gpu/drm/i915/gvt/firmware.c | 2 +- > drivers/gpu/drm/i915/i915_debugfs.c | 8 +- > drivers/gpu/drm/i915/i915_perf.c | 2 +- > drivers/gpu/drm/i915/i915_sysfs.c | 22 ++--- > drivers/gpu/drm/i915/intel_pipe_crc.c | 2 +- > drivers/gpu/drm/msm/adreno/a5xx_debugfs.c | 5 +- > drivers/gpu/drm/msm/msm_perf.c | 4 +- > drivers/gpu/drm/msm/msm_rd.c | 4 +- > drivers/gpu/drm/nouveau/nouveau_debugfs.c | 2 +- > drivers/gpu/drm/omapdrm/displays/panel-dsi-cm.c | 11 ++- > .../drm/omapdrm/displays/panel-sony-acx565akm.c | 6 +- > .../drm/omapdrm/displays/panel-tpo-td043mtea1.c | 10 +-- > drivers/gpu/drm/radeon/radeon_pm.c | 26 +++--- > drivers/gpu/drm/radeon/radeon_ttm.c | 4 +- > drivers/gpu/drm/sti/sti_drv.c | 2 +- > drivers/gpu/drm/tinydrm/mipi-dbi.c | 4 +- > drivers/gpu/drm/ttm/ttm_bo.c | 2 +- > drivers/gpu/drm/ttm/ttm_memory.c | 12 +-- > drivers/gpu/drm/ttm/ttm_page_alloc.c | 6 +- > drivers/gpu/drm/ttm/ttm_page_alloc_dma.c | 6 +- > drivers/gpu/drm/udl/udl_fb.c | 4 +- > drivers/gpu/host1x/debug.c | 12 +-- > 30 files changed, 138 insertions(+), 146 deletions(-) > > diff --git a/drivers/gpu/drm/amd/amdgpu/amdgpu_debugfs.c b/drivers/gpu/drm/amd/amdgpu/amdgpu_debugfs.c > index f5fb93795a69..7b29febff511 100644 > --- a/drivers/gpu/drm/amd/amdgpu/amdgpu_debugfs.c > +++ b/drivers/gpu/drm/amd/amdgpu/amdgpu_debugfs.c > @@ -830,7 +830,7 @@ int amdgpu_debugfs_regs_init(struct amdgpu_device *adev) > > for (i = 0; i < ARRAY_SIZE(debugfs_regs); i++) { > ent = debugfs_create_file(debugfs_regs_names[i], > - S_IFREG | S_IRUGO, root, > + S_IFREG | 0444, root, > adev, debugfs_regs[i]); > if (IS_ERR(ent)) { > for (j = 0; j < i; j++) { > diff --git a/drivers/gpu/drm/amd/amdgpu/amdgpu_pm.c b/drivers/gpu/drm/amd/amdgpu/amdgpu_pm.c > index b455da487782..fa55d7e9e784 100644 > --- a/drivers/gpu/drm/amd/amdgpu/amdgpu_pm.c > +++ b/drivers/gpu/drm/amd/amdgpu/amdgpu_pm.c > @@ -905,39 +905,39 @@ static ssize_t amdgpu_set_pp_power_profile_mode(struct device *dev, > return -EINVAL; > } > > -static DEVICE_ATTR(power_dpm_state, S_IRUGO | S_IWUSR, amdgpu_get_dpm_state, amdgpu_set_dpm_state); > -static DEVICE_ATTR(power_dpm_force_performance_level, S_IRUGO | S_IWUSR, > +static DEVICE_ATTR(power_dpm_state, 0644, amdgpu_get_dpm_state, amdgpu_set_dpm_state); > +static DEVICE_ATTR(power_dpm_force_performance_level, 0644, > amdgpu_get_dpm_forced_performance_level, > amdgpu_set_dpm_forced_performance_level); > -static DEVICE_ATTR(pp_num_states, S_IRUGO, amdgpu_get_pp_num_states, NULL); > -static DEVICE_ATTR(pp_cur_state, S_IRUGO, amdgpu_get_pp_cur_state, NULL); > -static DEVICE_ATTR(pp_force_state, S_IRUGO | S_IWUSR, > - amdgpu_get_pp_force_state, > - amdgpu_set_pp_force_state); > -static DEVICE_ATTR(pp_table, S_IRUGO | S_IWUSR, > - amdgpu_get_pp_table, > - amdgpu_set_pp_table); > -static DEVICE_ATTR(pp_dpm_sclk, S_IRUGO | S_IWUSR, > - amdgpu_get_pp_dpm_sclk, > - amdgpu_set_pp_dpm_sclk); > -static DEVICE_ATTR(pp_dpm_mclk, S_IRUGO | S_IWUSR, > - amdgpu_get_pp_dpm_mclk, > - amdgpu_set_pp_dpm_mclk); > -static DEVICE_ATTR(pp_dpm_pcie, S_IRUGO | S_IWUSR, > - amdgpu_get_pp_dpm_pcie, > - amdgpu_set_pp_dpm_pcie); > -static DEVICE_ATTR(pp_sclk_od, S_IRUGO | S_IWUSR, > - amdgpu_get_pp_sclk_od, > - amdgpu_set_pp_sclk_od); > -static DEVICE_ATTR(pp_mclk_od, S_IRUGO | S_IWUSR, > - amdgpu_get_pp_mclk_od, > - amdgpu_set_pp_mclk_od); > -static DEVICE_ATTR(pp_power_profile_mode, S_IRUGO | S_IWUSR, > - amdgpu_get_pp_power_profile_mode, > - amdgpu_set_pp_power_profile_mode); > -static DEVICE_ATTR(pp_od_clk_voltage, S_IRUGO | S_IWUSR, > - amdgpu_get_pp_od_clk_voltage, > - amdgpu_set_pp_od_clk_voltage); > +static DEVICE_ATTR(pp_num_states, 0444, amdgpu_get_pp_num_states, NULL); > +static DEVICE_ATTR(pp_cur_state, 0444, amdgpu_get_pp_cur_state, NULL); > +static DEVICE_ATTR(pp_force_state, 0644, > + amdgpu_get_pp_force_state, > + amdgpu_set_pp_force_state); > +static DEVICE_ATTR(pp_table, 0644, > + amdgpu_get_pp_table, > + amdgpu_set_pp_table); > +static DEVICE_ATTR(pp_dpm_sclk, 0644, > + amdgpu_get_pp_dpm_sclk, > + amdgpu_set_pp_dpm_sclk); > +static DEVICE_ATTR(pp_dpm_mclk, 0644, > + amdgpu_get_pp_dpm_mclk, > + amdgpu_set_pp_dpm_mclk); > +static DEVICE_ATTR(pp_dpm_pcie, 0644, > + amdgpu_get_pp_dpm_pcie, > + amdgpu_set_pp_dpm_pcie); > +static DEVICE_ATTR(pp_sclk_od, 0644, > + amdgpu_get_pp_sclk_od, > + amdgpu_set_pp_sclk_od); > +static DEVICE_ATTR(pp_mclk_od, 0644, > + amdgpu_get_pp_mclk_od, > + amdgpu_set_pp_mclk_od); > +static DEVICE_ATTR(pp_power_profile_mode, 0644, > + amdgpu_get_pp_power_profile_mode, > + amdgpu_set_pp_power_profile_mode); > +static DEVICE_ATTR(pp_od_clk_voltage, 0644, > + amdgpu_get_pp_od_clk_voltage, > + amdgpu_set_pp_od_clk_voltage); > > static ssize_t amdgpu_hwmon_show_temp(struct device *dev, > struct device_attribute *attr, > @@ -1320,22 +1320,22 @@ static ssize_t amdgpu_hwmon_set_power_cap(struct device *dev, > * > */ > > -static SENSOR_DEVICE_ATTR(temp1_input, S_IRUGO, amdgpu_hwmon_show_temp, NULL, 0); > -static SENSOR_DEVICE_ATTR(temp1_crit, S_IRUGO, amdgpu_hwmon_show_temp_thresh, NULL, 0); > -static SENSOR_DEVICE_ATTR(temp1_crit_hyst, S_IRUGO, amdgpu_hwmon_show_temp_thresh, NULL, 1); > -static SENSOR_DEVICE_ATTR(pwm1, S_IRUGO | S_IWUSR, amdgpu_hwmon_get_pwm1, amdgpu_hwmon_set_pwm1, 0); > -static SENSOR_DEVICE_ATTR(pwm1_enable, S_IRUGO | S_IWUSR, amdgpu_hwmon_get_pwm1_enable, amdgpu_hwmon_set_pwm1_enable, 0); > -static SENSOR_DEVICE_ATTR(pwm1_min, S_IRUGO, amdgpu_hwmon_get_pwm1_min, NULL, 0); > -static SENSOR_DEVICE_ATTR(pwm1_max, S_IRUGO, amdgpu_hwmon_get_pwm1_max, NULL, 0); > -static SENSOR_DEVICE_ATTR(fan1_input, S_IRUGO, amdgpu_hwmon_get_fan1_input, NULL, 0); > -static SENSOR_DEVICE_ATTR(in0_input, S_IRUGO, amdgpu_hwmon_show_vddgfx, NULL, 0); > -static SENSOR_DEVICE_ATTR(in0_label, S_IRUGO, amdgpu_hwmon_show_vddgfx_label, NULL, 0); > -static SENSOR_DEVICE_ATTR(in1_input, S_IRUGO, amdgpu_hwmon_show_vddnb, NULL, 0); > -static SENSOR_DEVICE_ATTR(in1_label, S_IRUGO, amdgpu_hwmon_show_vddnb_label, NULL, 0); > -static SENSOR_DEVICE_ATTR(power1_average, S_IRUGO, amdgpu_hwmon_show_power_avg, NULL, 0); > -static SENSOR_DEVICE_ATTR(power1_cap_max, S_IRUGO, amdgpu_hwmon_show_power_cap_max, NULL, 0); > -static SENSOR_DEVICE_ATTR(power1_cap_min, S_IRUGO, amdgpu_hwmon_show_power_cap_min, NULL, 0); > -static SENSOR_DEVICE_ATTR(power1_cap, S_IRUGO | S_IWUSR, amdgpu_hwmon_show_power_cap, amdgpu_hwmon_set_power_cap, 0); > +static SENSOR_DEVICE_ATTR(temp1_input, 0444, amdgpu_hwmon_show_temp, NULL, 0); > +static SENSOR_DEVICE_ATTR(temp1_crit, 0444, amdgpu_hwmon_show_temp_thresh, NULL, 0); > +static SENSOR_DEVICE_ATTR(temp1_crit_hyst, 0444, amdgpu_hwmon_show_temp_thresh, NULL, 1); > +static SENSOR_DEVICE_ATTR(pwm1, 0644, amdgpu_hwmon_get_pwm1, amdgpu_hwmon_set_pwm1, 0); > +static SENSOR_DEVICE_ATTR(pwm1_enable, 0644, amdgpu_hwmon_get_pwm1_enable, amdgpu_hwmon_set_pwm1_enable, 0); > +static SENSOR_DEVICE_ATTR(pwm1_min, 0444, amdgpu_hwmon_get_pwm1_min, NULL, 0); > +static SENSOR_DEVICE_ATTR(pwm1_max, 0444, amdgpu_hwmon_get_pwm1_max, NULL, 0); > +static SENSOR_DEVICE_ATTR(fan1_input, 0444, amdgpu_hwmon_get_fan1_input, NULL, 0); > +static SENSOR_DEVICE_ATTR(in0_input, 0444, amdgpu_hwmon_show_vddgfx, NULL, 0); > +static SENSOR_DEVICE_ATTR(in0_label, 0444, amdgpu_hwmon_show_vddgfx_label, NULL, 0); > +static SENSOR_DEVICE_ATTR(in1_input, 0444, amdgpu_hwmon_show_vddnb, NULL, 0); > +static SENSOR_DEVICE_ATTR(in1_label, 0444, amdgpu_hwmon_show_vddnb_label, NULL, 0); > +static SENSOR_DEVICE_ATTR(power1_average, 0444, amdgpu_hwmon_show_power_avg, NULL, 0); > +static SENSOR_DEVICE_ATTR(power1_cap_max, 0444, amdgpu_hwmon_show_power_cap_max, NULL, 0); > +static SENSOR_DEVICE_ATTR(power1_cap_min, 0444, amdgpu_hwmon_show_power_cap_min, NULL, 0); > +static SENSOR_DEVICE_ATTR(power1_cap, 0644, amdgpu_hwmon_show_power_cap, amdgpu_hwmon_set_power_cap, 0); > > static struct attribute *hwmon_attributes[] = { > &sensor_dev_attr_temp1_input.dev_attr.attr, > @@ -1388,13 +1388,13 @@ static umode_t hwmon_attributes_visible(struct kobject *kobj, > attr == &sensor_dev_attr_pwm1.dev_attr.attr) || /* can't query fan */ > (!adev->powerplay.pp_funcs->get_fan_control_mode && > attr == &sensor_dev_attr_pwm1_enable.dev_attr.attr)) /* can't query state */ > - effective_mode &= ~S_IRUGO; > + effective_mode &= ~0444; > > if ((!adev->powerplay.pp_funcs->set_fan_speed_percent && > attr == &sensor_dev_attr_pwm1.dev_attr.attr) || /* can't manage fan */ > (!adev->powerplay.pp_funcs->set_fan_control_mode && > attr == &sensor_dev_attr_pwm1_enable.dev_attr.attr)) /* can't manage state */ > - effective_mode &= ~S_IWUSR; > + effective_mode &= ~0200; > > if ((adev->flags & AMD_IS_APU) && > (attr == &sensor_dev_attr_power1_cap_max.dev_attr.attr || > diff --git a/drivers/gpu/drm/amd/amdgpu/amdgpu_ring.c b/drivers/gpu/drm/amd/amdgpu/amdgpu_ring.c > index 49cad08b5c16..22c56367ee8e 100644 > --- a/drivers/gpu/drm/amd/amdgpu/amdgpu_ring.c > +++ b/drivers/gpu/drm/amd/amdgpu/amdgpu_ring.c > @@ -553,8 +553,7 @@ static int amdgpu_debugfs_ring_init(struct amdgpu_device *adev, > > sprintf(name, "amdgpu_ring_%s", ring->name); > > - ent = debugfs_create_file(name, > - S_IFREG | S_IRUGO, root, > + ent = debugfs_create_file(name, S_IFREG | 0444, root, > ring, &amdgpu_debugfs_ring_fops); > if (!ent) > return -ENOMEM; > diff --git a/drivers/gpu/drm/amd/amdgpu/amdgpu_ttm.c b/drivers/gpu/drm/amd/amdgpu/amdgpu_ttm.c > index 69a2b25b3696..696a2617930f 100644 > --- a/drivers/gpu/drm/amd/amdgpu/amdgpu_ttm.c > +++ b/drivers/gpu/drm/amd/amdgpu/amdgpu_ttm.c > @@ -2160,11 +2160,10 @@ static int amdgpu_ttm_debugfs_init(struct amdgpu_device *adev) > struct dentry *ent, *root = minor->debugfs_root; > > for (count = 0; count < ARRAY_SIZE(ttm_debugfs_entries); count++) { > - ent = debugfs_create_file( > - ttm_debugfs_entries[count].name, > - S_IFREG | S_IRUGO, root, > - adev, > - ttm_debugfs_entries[count].fops); > + ent = debugfs_create_file(ttm_debugfs_entries[count].name, > + S_IFREG | 0444, root, > + adev, > + ttm_debugfs_entries[count].fops); > if (IS_ERR(ent)) > return PTR_ERR(ent); > if (ttm_debugfs_entries[count].domain == TTM_PL_VRAM) > diff --git a/drivers/gpu/drm/armada/armada_debugfs.c b/drivers/gpu/drm/armada/armada_debugfs.c > index 6758c3a83de2..9be396e4b6dd 100644 > --- a/drivers/gpu/drm/armada/armada_debugfs.c > +++ b/drivers/gpu/drm/armada/armada_debugfs.c > @@ -118,12 +118,12 @@ int armada_drm_debugfs_init(struct drm_minor *minor) > if (ret) > return ret; > > - de = debugfs_create_file("reg", S_IFREG | S_IRUSR, > + de = debugfs_create_file("reg", S_IFREG | 0400, > minor->debugfs_root, minor->dev, &fops_reg_r); > if (!de) > return -ENOMEM; > > - de = debugfs_create_file("reg_wr", S_IFREG | S_IWUSR, > + de = debugfs_create_file("reg_wr", S_IFREG | 0200, > minor->debugfs_root, minor->dev, &fops_reg_w); > if (!de) > return -ENOMEM; > diff --git a/drivers/gpu/drm/drm_debugfs.c b/drivers/gpu/drm/drm_debugfs.c > index b2482818fee8..84c91018a398 100644 > --- a/drivers/gpu/drm/drm_debugfs.c > +++ b/drivers/gpu/drm/drm_debugfs.c > @@ -99,7 +99,7 @@ int drm_debugfs_create_files(const struct drm_info_list *files, int count, > ret = -1; > goto fail; > } > - ent = debugfs_create_file(files[i].name, S_IFREG | S_IRUGO, > + ent = debugfs_create_file(files[i].name, S_IFREG | 0444, > root, tmp, &drm_debugfs_fops); > if (!ent) { > DRM_ERROR("Cannot create /sys/kernel/debug/dri/%pd/%s\n", > @@ -357,13 +357,13 @@ int drm_debugfs_connector_add(struct drm_connector *connector) > connector->debugfs_entry = root; > > /* force */ > - ent = debugfs_create_file("force", S_IRUGO | S_IWUSR, root, connector, > + ent = debugfs_create_file("force", 0644, root, connector, > &drm_connector_fops); > if (!ent) > goto error; > > /* edid */ > - ent = debugfs_create_file("edid_override", S_IRUGO | S_IWUSR, root, > + ent = debugfs_create_file("edid_override", 0644, root, > connector, &drm_edid_fops); > if (!ent) > goto error; > diff --git a/drivers/gpu/drm/drm_debugfs_crc.c b/drivers/gpu/drm/drm_debugfs_crc.c > index 9f8312137cad..63dd290963a7 100644 > --- a/drivers/gpu/drm/drm_debugfs_crc.c > +++ b/drivers/gpu/drm/drm_debugfs_crc.c > @@ -344,12 +344,12 @@ int drm_debugfs_crtc_crc_add(struct drm_crtc *crtc) > if (!crc_ent) > return -ENOMEM; > > - ent = debugfs_create_file("control", S_IRUGO, crc_ent, crtc, > + ent = debugfs_create_file("control", 0444, crc_ent, crtc, > &drm_crtc_crc_control_fops); > if (!ent) > goto error; > > - ent = debugfs_create_file("data", S_IRUGO, crc_ent, crtc, > + ent = debugfs_create_file("data", 0444, crc_ent, crtc, > &drm_crtc_crc_data_fops); > if (!ent) > goto error; > diff --git a/drivers/gpu/drm/drm_sysfs.c b/drivers/gpu/drm/drm_sysfs.c > index b3c1daad1169..c64019f14c79 100644 > --- a/drivers/gpu/drm/drm_sysfs.c > +++ b/drivers/gpu/drm/drm_sysfs.c > @@ -50,7 +50,7 @@ static char *drm_devnode(struct device *dev, umode_t *mode) > return kasprintf(GFP_KERNEL, "dri/%s", dev_name(dev)); > } > > -static CLASS_ATTR_STRING(version, S_IRUGO, "drm 1.1.0 20060810"); > +static CLASS_ATTR_STRING(version, 0444, "drm 1.1.0 20060810"); > > /** > * drm_sysfs_init - initialize sysfs helpers > diff --git a/drivers/gpu/drm/i915/gvt/firmware.c b/drivers/gpu/drm/i915/gvt/firmware.c > index a73e1d418c22..33b8c4f38fd8 100644 > --- a/drivers/gpu/drm/i915/gvt/firmware.c > +++ b/drivers/gpu/drm/i915/gvt/firmware.c > @@ -60,7 +60,7 @@ gvt_firmware_read(struct file *filp, struct kobject *kobj, > } > > static struct bin_attribute firmware_attr = { > - .attr = {.name = "gvt_firmware", .mode = (S_IRUSR)}, > + .attr = {.name = "gvt_firmware", .mode = 0400}, > .read = gvt_firmware_read, > .write = NULL, > .mmap = NULL, > diff --git a/drivers/gpu/drm/i915/i915_debugfs.c b/drivers/gpu/drm/i915/i915_debugfs.c > index 13e7b9e4a6e6..1796626a858f 100644 > --- a/drivers/gpu/drm/i915/i915_debugfs.c > +++ b/drivers/gpu/drm/i915/i915_debugfs.c > @@ -4851,7 +4851,7 @@ int i915_debugfs_register(struct drm_i915_private *dev_priv) > struct dentry *ent; > int ret, i; > > - ent = debugfs_create_file("i915_forcewake_user", S_IRUSR, > + ent = debugfs_create_file("i915_forcewake_user", 0400, > minor->debugfs_root, to_i915(minor->dev), > &i915_forcewake_fops); > if (!ent) > @@ -4863,7 +4863,7 @@ int i915_debugfs_register(struct drm_i915_private *dev_priv) > > for (i = 0; i < ARRAY_SIZE(i915_debugfs_files); i++) { > ent = debugfs_create_file(i915_debugfs_files[i].name, > - S_IRUGO | S_IWUSR, > + 0644, > minor->debugfs_root, > to_i915(minor->dev), > i915_debugfs_files[i].fops); > @@ -4979,11 +4979,11 @@ int i915_debugfs_connector_add(struct drm_connector *connector) > > if (connector->connector_type == DRM_MODE_CONNECTOR_DisplayPort || > connector->connector_type == DRM_MODE_CONNECTOR_eDP) > - debugfs_create_file("i915_dpcd", S_IRUGO, root, > + debugfs_create_file("i915_dpcd", 0444, root, > connector, &i915_dpcd_fops); > > if (connector->connector_type == DRM_MODE_CONNECTOR_eDP) > - debugfs_create_file("i915_panel_timings", S_IRUGO, root, > + debugfs_create_file("i915_panel_timings", 0444, root, > connector, &i915_panel_fops); > > return 0; > diff --git a/drivers/gpu/drm/i915/i915_perf.c b/drivers/gpu/drm/i915/i915_perf.c > index 019bd2d073ad..8e5009445963 100644 > --- a/drivers/gpu/drm/i915/i915_perf.c > +++ b/drivers/gpu/drm/i915/i915_perf.c > @@ -3148,7 +3148,7 @@ static int create_dynamic_oa_sysfs_entry(struct drm_i915_private *dev_priv, > { > sysfs_attr_init(&oa_config->sysfs_metric_id.attr); > oa_config->sysfs_metric_id.attr.name = "id"; > - oa_config->sysfs_metric_id.attr.mode = S_IRUGO; > + oa_config->sysfs_metric_id.attr.mode = 0444; > oa_config->sysfs_metric_id.show = show_dynamic_id; > oa_config->sysfs_metric_id.store = NULL; > > diff --git a/drivers/gpu/drm/i915/i915_sysfs.c b/drivers/gpu/drm/i915/i915_sysfs.c > index e5e6f6bb2b05..a8e25465bf1a 100644 > --- a/drivers/gpu/drm/i915/i915_sysfs.c > +++ b/drivers/gpu/drm/i915/i915_sysfs.c > @@ -100,11 +100,11 @@ show_media_rc6_ms(struct device *kdev, struct device_attribute *attr, char *buf) > return snprintf(buf, PAGE_SIZE, "%u\n", rc6_residency); > } > > -static DEVICE_ATTR(rc6_enable, S_IRUGO, show_rc6_mask, NULL); > -static DEVICE_ATTR(rc6_residency_ms, S_IRUGO, show_rc6_ms, NULL); > -static DEVICE_ATTR(rc6p_residency_ms, S_IRUGO, show_rc6p_ms, NULL); > -static DEVICE_ATTR(rc6pp_residency_ms, S_IRUGO, show_rc6pp_ms, NULL); > -static DEVICE_ATTR(media_rc6_residency_ms, S_IRUGO, show_media_rc6_ms, NULL); > +static DEVICE_ATTR(rc6_enable, 0444, show_rc6_mask, NULL); > +static DEVICE_ATTR(rc6_residency_ms, 0444, show_rc6_ms, NULL); > +static DEVICE_ATTR(rc6p_residency_ms, 0444, show_rc6p_ms, NULL); > +static DEVICE_ATTR(rc6pp_residency_ms, 0444, show_rc6pp_ms, NULL); > +static DEVICE_ATTR(media_rc6_residency_ms, 0444, show_media_rc6_ms, NULL); > > static struct attribute *rc6_attrs[] = { > &dev_attr_rc6_enable.attr, > @@ -237,7 +237,7 @@ i915_l3_write(struct file *filp, struct kobject *kobj, > } > > static const struct bin_attribute dpf_attrs = { > - .attr = {.name = "l3_parity", .mode = (S_IRUSR | S_IWUSR)}, > + .attr = {.name = "l3_parity", .mode = 0600}, > .size = GEN7_L3LOG_SIZE, > .read = i915_l3_read, > .write = i915_l3_write, > @@ -246,7 +246,7 @@ static const struct bin_attribute dpf_attrs = { > }; > > static const struct bin_attribute dpf_attrs_1 = { > - .attr = {.name = "l3_parity_slice_1", .mode = (S_IRUSR | S_IWUSR)}, > + .attr = {.name = "l3_parity_slice_1", .mode = 0600}, > .size = GEN7_L3LOG_SIZE, > .read = i915_l3_read, > .write = i915_l3_write, > @@ -460,9 +460,9 @@ static DEVICE_ATTR_RW(gt_min_freq_mhz); > static DEVICE_ATTR_RO(vlv_rpe_freq_mhz); > > static ssize_t gt_rp_mhz_show(struct device *kdev, struct device_attribute *attr, char *buf); > -static DEVICE_ATTR(gt_RP0_freq_mhz, S_IRUGO, gt_rp_mhz_show, NULL); > -static DEVICE_ATTR(gt_RP1_freq_mhz, S_IRUGO, gt_rp_mhz_show, NULL); > -static DEVICE_ATTR(gt_RPn_freq_mhz, S_IRUGO, gt_rp_mhz_show, NULL); > +static DEVICE_ATTR(gt_RP0_freq_mhz, 0444, gt_rp_mhz_show, NULL); > +static DEVICE_ATTR(gt_RP1_freq_mhz, 0444, gt_rp_mhz_show, NULL); > +static DEVICE_ATTR(gt_RPn_freq_mhz, 0444, gt_rp_mhz_show, NULL); > > /* For now we have a static number of RP states */ > static ssize_t gt_rp_mhz_show(struct device *kdev, struct device_attribute *attr, char *buf) > @@ -555,7 +555,7 @@ static ssize_t error_state_write(struct file *file, struct kobject *kobj, > > static const struct bin_attribute error_state_attr = { > .attr.name = "error", > - .attr.mode = S_IRUSR | S_IWUSR, > + .attr.mode = 0600, > .size = 0, > .read = error_state_read, > .write = error_state_write, > diff --git a/drivers/gpu/drm/i915/intel_pipe_crc.c b/drivers/gpu/drm/i915/intel_pipe_crc.c > index 39a4e4edda07..2a34ac8e319b 100644 > --- a/drivers/gpu/drm/i915/intel_pipe_crc.c > +++ b/drivers/gpu/drm/i915/intel_pipe_crc.c > @@ -903,7 +903,7 @@ int intel_pipe_crc_create(struct drm_minor *minor) > struct pipe_crc_info *info = &i915_pipe_crc_data[i]; > > info->dev_priv = dev_priv; > - ent = debugfs_create_file(info->name, S_IRUGO, > + ent = debugfs_create_file(info->name, 0444, > minor->debugfs_root, info, > &i915_pipe_crc_fops); > if (!ent) > diff --git a/drivers/gpu/drm/msm/adreno/a5xx_debugfs.c b/drivers/gpu/drm/msm/adreno/a5xx_debugfs.c > index 059ec7d394d0..c4373a5a18be 100644 > --- a/drivers/gpu/drm/msm/adreno/a5xx_debugfs.c > +++ b/drivers/gpu/drm/msm/adreno/a5xx_debugfs.c > @@ -177,9 +177,8 @@ int a5xx_debugfs_init(struct msm_gpu *gpu, struct drm_minor *minor) > return ret; > } > > - ent = debugfs_create_file("reset", S_IWUGO, > - minor->debugfs_root, > - dev, &reset_fops); > + ent = debugfs_create_file("reset", 0222, minor->debugfs_root, > + dev, &reset_fops); > if (!ent) > return -ENOMEM; > > diff --git a/drivers/gpu/drm/msm/msm_perf.c b/drivers/gpu/drm/msm/msm_perf.c > index 5ab21bd2decb..ad1cffe72bf4 100644 > --- a/drivers/gpu/drm/msm/msm_perf.c > +++ b/drivers/gpu/drm/msm/msm_perf.c > @@ -220,8 +220,8 @@ int msm_perf_debugfs_init(struct drm_minor *minor) > mutex_init(&perf->read_lock); > priv->perf = perf; > > - ent = debugfs_create_file("perf", S_IFREG | S_IRUGO, > - minor->debugfs_root, perf, &perf_debugfs_fops); > + ent = debugfs_create_file("perf", S_IFREG | 0444, minor->debugfs_root, > + perf, &perf_debugfs_fops); > if (!ent) { > DRM_ERROR("Cannot create /sys/kernel/debug/dri/%pd/perf\n", > minor->debugfs_root); > diff --git a/drivers/gpu/drm/msm/msm_rd.c b/drivers/gpu/drm/msm/msm_rd.c > index 3aa8a8576abe..c6172980951d 100644 > --- a/drivers/gpu/drm/msm/msm_rd.c > +++ b/drivers/gpu/drm/msm/msm_rd.c > @@ -253,8 +253,8 @@ static struct msm_rd_state *rd_init(struct drm_minor *minor, const char *name) > > init_waitqueue_head(&rd->fifo_event); > > - ent = debugfs_create_file(name, S_IFREG | S_IRUGO, > - minor->debugfs_root, rd, &rd_debugfs_fops); > + ent = debugfs_create_file(name, S_IFREG | 0444, minor->debugfs_root, > + rd, &rd_debugfs_fops); > if (!ent) { > DRM_ERROR("Cannot create /sys/kernel/debug/dri/%pd/%s\n", > minor->debugfs_root, name); > diff --git a/drivers/gpu/drm/nouveau/nouveau_debugfs.c b/drivers/gpu/drm/nouveau/nouveau_debugfs.c > index 963a4dba8213..7e6b2cca241e 100644 > --- a/drivers/gpu/drm/nouveau/nouveau_debugfs.c > +++ b/drivers/gpu/drm/nouveau/nouveau_debugfs.c > @@ -200,7 +200,7 @@ nouveau_drm_debugfs_init(struct drm_minor *minor) > > for (i = 0; i < ARRAY_SIZE(nouveau_debugfs_files); i++) { > dentry = debugfs_create_file(nouveau_debugfs_files[i].name, > - S_IRUGO | S_IWUSR, > + 0644, > minor->debugfs_root, minor->dev, > nouveau_debugfs_files[i].fops); > if (!dentry) > diff --git a/drivers/gpu/drm/omapdrm/displays/panel-dsi-cm.c b/drivers/gpu/drm/omapdrm/displays/panel-dsi-cm.c > index 428de90fced1..2ed5d90b62ae 100644 > --- a/drivers/gpu/drm/omapdrm/displays/panel-dsi-cm.c > +++ b/drivers/gpu/drm/omapdrm/displays/panel-dsi-cm.c > @@ -569,12 +569,11 @@ static ssize_t dsicm_show_ulps_timeout(struct device *dev, > return snprintf(buf, PAGE_SIZE, "%u\n", t); > } > > -static DEVICE_ATTR(num_dsi_errors, S_IRUGO, dsicm_num_errors_show, NULL); > -static DEVICE_ATTR(hw_revision, S_IRUGO, dsicm_hw_revision_show, NULL); > -static DEVICE_ATTR(ulps, S_IRUGO | S_IWUSR, > - dsicm_show_ulps, dsicm_store_ulps); > -static DEVICE_ATTR(ulps_timeout, S_IRUGO | S_IWUSR, > - dsicm_show_ulps_timeout, dsicm_store_ulps_timeout); > +static DEVICE_ATTR(num_dsi_errors, 0444, dsicm_num_errors_show, NULL); > +static DEVICE_ATTR(hw_revision, 0444, dsicm_hw_revision_show, NULL); > +static DEVICE_ATTR(ulps, 0644, dsicm_show_ulps, dsicm_store_ulps); > +static DEVICE_ATTR(ulps_timeout, 0644, > + dsicm_show_ulps_timeout, dsicm_store_ulps_timeout); > > static struct attribute *dsicm_attrs[] = { > &dev_attr_num_dsi_errors.attr, > diff --git a/drivers/gpu/drm/omapdrm/displays/panel-sony-acx565akm.c b/drivers/gpu/drm/omapdrm/displays/panel-sony-acx565akm.c > index 92fe125ce22e..37a34d55eb99 100644 > --- a/drivers/gpu/drm/omapdrm/displays/panel-sony-acx565akm.c > +++ b/drivers/gpu/drm/omapdrm/displays/panel-sony-acx565akm.c > @@ -492,10 +492,8 @@ static ssize_t show_cabc_available_modes(struct device *dev, > return len < PAGE_SIZE ? len : PAGE_SIZE - 1; > } > > -static DEVICE_ATTR(cabc_mode, S_IRUGO | S_IWUSR, > - show_cabc_mode, store_cabc_mode); > -static DEVICE_ATTR(cabc_available_modes, S_IRUGO, > - show_cabc_available_modes, NULL); > +static DEVICE_ATTR(cabc_mode, 0644, show_cabc_mode, store_cabc_mode); > +static DEVICE_ATTR(cabc_available_modes, 0444, show_cabc_available_modes, NULL); > > static struct attribute *bldev_attrs[] = { > &dev_attr_cabc_mode.attr, > diff --git a/drivers/gpu/drm/omapdrm/displays/panel-tpo-td043mtea1.c b/drivers/gpu/drm/omapdrm/displays/panel-tpo-td043mtea1.c > index c08e22b43447..e06fe61f8c7e 100644 > --- a/drivers/gpu/drm/omapdrm/displays/panel-tpo-td043mtea1.c > +++ b/drivers/gpu/drm/omapdrm/displays/panel-tpo-td043mtea1.c > @@ -268,12 +268,10 @@ static ssize_t tpo_td043_gamma_store(struct device *dev, > return count; > } > > -static DEVICE_ATTR(vmirror, S_IRUGO | S_IWUSR, > - tpo_td043_vmirror_show, tpo_td043_vmirror_store); > -static DEVICE_ATTR(mode, S_IRUGO | S_IWUSR, > - tpo_td043_mode_show, tpo_td043_mode_store); > -static DEVICE_ATTR(gamma, S_IRUGO | S_IWUSR, > - tpo_td043_gamma_show, tpo_td043_gamma_store); > +static DEVICE_ATTR(vmirror, 0644, > + tpo_td043_vmirror_show, tpo_td043_vmirror_store); > +static DEVICE_ATTR(mode, 0644, tpo_td043_mode_show, tpo_td043_mode_store); > +static DEVICE_ATTR(gamma, 0644, tpo_td043_gamma_show, tpo_td043_gamma_store); > > static struct attribute *tpo_td043_attrs[] = { > &dev_attr_vmirror.attr, > diff --git a/drivers/gpu/drm/radeon/radeon_pm.c b/drivers/gpu/drm/radeon/radeon_pm.c > index 4b6542538ff9..45801c27d23b 100644 > --- a/drivers/gpu/drm/radeon/radeon_pm.c > +++ b/drivers/gpu/drm/radeon/radeon_pm.c > @@ -655,10 +655,10 @@ static ssize_t radeon_hwmon_get_pwm1(struct device *dev, > return sprintf(buf, "%i\n", speed); > } > > -static DEVICE_ATTR(power_profile, S_IRUGO | S_IWUSR, radeon_get_pm_profile, radeon_set_pm_profile); > -static DEVICE_ATTR(power_method, S_IRUGO | S_IWUSR, radeon_get_pm_method, radeon_set_pm_method); > -static DEVICE_ATTR(power_dpm_state, S_IRUGO | S_IWUSR, radeon_get_dpm_state, radeon_set_dpm_state); > -static DEVICE_ATTR(power_dpm_force_performance_level, S_IRUGO | S_IWUSR, > +static DEVICE_ATTR(power_profile, 0644, radeon_get_pm_profile, radeon_set_pm_profile); > +static DEVICE_ATTR(power_method, 0644, radeon_get_pm_method, radeon_set_pm_method); > +static DEVICE_ATTR(power_dpm_state, 0644, radeon_get_dpm_state, radeon_set_dpm_state); > +static DEVICE_ATTR(power_dpm_force_performance_level, 0644, > radeon_get_dpm_forced_performance_level, > radeon_set_dpm_forced_performance_level); > > @@ -699,13 +699,13 @@ static ssize_t radeon_hwmon_show_temp_thresh(struct device *dev, > return snprintf(buf, PAGE_SIZE, "%d\n", temp); > } > > -static SENSOR_DEVICE_ATTR(temp1_input, S_IRUGO, radeon_hwmon_show_temp, NULL, 0); > -static SENSOR_DEVICE_ATTR(temp1_crit, S_IRUGO, radeon_hwmon_show_temp_thresh, NULL, 0); > -static SENSOR_DEVICE_ATTR(temp1_crit_hyst, S_IRUGO, radeon_hwmon_show_temp_thresh, NULL, 1); > -static SENSOR_DEVICE_ATTR(pwm1, S_IRUGO | S_IWUSR, radeon_hwmon_get_pwm1, radeon_hwmon_set_pwm1, 0); > -static SENSOR_DEVICE_ATTR(pwm1_enable, S_IRUGO | S_IWUSR, radeon_hwmon_get_pwm1_enable, radeon_hwmon_set_pwm1_enable, 0); > -static SENSOR_DEVICE_ATTR(pwm1_min, S_IRUGO, radeon_hwmon_get_pwm1_min, NULL, 0); > -static SENSOR_DEVICE_ATTR(pwm1_max, S_IRUGO, radeon_hwmon_get_pwm1_max, NULL, 0); > +static SENSOR_DEVICE_ATTR(temp1_input, 0444, radeon_hwmon_show_temp, NULL, 0); > +static SENSOR_DEVICE_ATTR(temp1_crit, 0444, radeon_hwmon_show_temp_thresh, NULL, 0); > +static SENSOR_DEVICE_ATTR(temp1_crit_hyst, 0444, radeon_hwmon_show_temp_thresh, NULL, 1); > +static SENSOR_DEVICE_ATTR(pwm1, 0644, radeon_hwmon_get_pwm1, radeon_hwmon_set_pwm1, 0); > +static SENSOR_DEVICE_ATTR(pwm1_enable, 0644, radeon_hwmon_get_pwm1_enable, radeon_hwmon_set_pwm1_enable, 0); > +static SENSOR_DEVICE_ATTR(pwm1_min, 0444, radeon_hwmon_get_pwm1_min, NULL, 0); > +static SENSOR_DEVICE_ATTR(pwm1_max, 0444, radeon_hwmon_get_pwm1_max, NULL, 0); > > > static struct attribute *hwmon_attributes[] = { > @@ -749,13 +749,13 @@ static umode_t hwmon_attributes_visible(struct kobject *kobj, > attr == &sensor_dev_attr_pwm1.dev_attr.attr) || /* can't query fan */ > (!rdev->asic->dpm.fan_ctrl_get_mode && > attr == &sensor_dev_attr_pwm1_enable.dev_attr.attr)) /* can't query state */ > - effective_mode &= ~S_IRUGO; > + effective_mode &= ~0444; > > if ((!rdev->asic->dpm.set_fan_speed_percent && > attr == &sensor_dev_attr_pwm1.dev_attr.attr) || /* can't manage fan */ > (!rdev->asic->dpm.fan_ctrl_set_mode && > attr == &sensor_dev_attr_pwm1_enable.dev_attr.attr)) /* can't manage state */ > - effective_mode &= ~S_IWUSR; > + effective_mode &= ~0200; > > /* hide max/min values if we can't both query and manage the fan */ > if ((!rdev->asic->dpm.set_fan_speed_percent && > diff --git a/drivers/gpu/drm/radeon/radeon_ttm.c b/drivers/gpu/drm/radeon/radeon_ttm.c > index 8689fcca051c..71b2bed0b983 100644 > --- a/drivers/gpu/drm/radeon/radeon_ttm.c > +++ b/drivers/gpu/drm/radeon/radeon_ttm.c > @@ -1136,13 +1136,13 @@ static int radeon_ttm_debugfs_init(struct radeon_device *rdev) > struct drm_minor *minor = rdev->ddev->primary; > struct dentry *ent, *root = minor->debugfs_root; > > - ent = debugfs_create_file("radeon_vram", S_IFREG | S_IRUGO, root, > + ent = debugfs_create_file("radeon_vram", S_IFREG | 0444, root, > rdev, &radeon_ttm_vram_fops); > if (IS_ERR(ent)) > return PTR_ERR(ent); > rdev->mman.vram = ent; > > - ent = debugfs_create_file("radeon_gtt", S_IFREG | S_IRUGO, root, > + ent = debugfs_create_file("radeon_gtt", S_IFREG | 0444, root, > rdev, &radeon_ttm_gtt_fops); > if (IS_ERR(ent)) > return PTR_ERR(ent); > diff --git a/drivers/gpu/drm/sti/sti_drv.c b/drivers/gpu/drm/sti/sti_drv.c > index 90c46b49c931..fafa9a781493 100644 > --- a/drivers/gpu/drm/sti/sti_drv.c > +++ b/drivers/gpu/drm/sti/sti_drv.c > @@ -104,7 +104,7 @@ static int sti_drm_dbg_init(struct drm_minor *minor) > if (ret) > goto err; > > - dentry = debugfs_create_file("fps_show", S_IRUGO | S_IWUSR, > + dentry = debugfs_create_file("fps_show", 0644, > minor->debugfs_root, minor->dev, > &sti_drm_fps_fops); > if (!dentry) { > diff --git a/drivers/gpu/drm/tinydrm/mipi-dbi.c b/drivers/gpu/drm/tinydrm/mipi-dbi.c > index 4d1fb31a781f..55bd38f1507b 100644 > --- a/drivers/gpu/drm/tinydrm/mipi-dbi.c > +++ b/drivers/gpu/drm/tinydrm/mipi-dbi.c > @@ -1055,10 +1055,10 @@ int mipi_dbi_debugfs_init(struct drm_minor *minor) > { > struct tinydrm_device *tdev = minor->dev->dev_private; > struct mipi_dbi *mipi = mipi_dbi_from_tinydrm(tdev); > - umode_t mode = S_IFREG | S_IWUSR; > + umode_t mode = S_IFREG | 0200; > > if (mipi->read_commands) > - mode |= S_IRUGO; > + mode |= 0444; > debugfs_create_file("command", mode, minor->debugfs_root, mipi, > &mipi_dbi_debugfs_command_fops); > > diff --git a/drivers/gpu/drm/ttm/ttm_bo.c b/drivers/gpu/drm/ttm/ttm_bo.c > index 5d8688e522d1..90843d7d10a8 100644 > --- a/drivers/gpu/drm/ttm/ttm_bo.c > +++ b/drivers/gpu/drm/ttm/ttm_bo.c > @@ -47,7 +47,7 @@ static void ttm_bo_global_kobj_release(struct kobject *kobj); > > static struct attribute ttm_bo_count = { > .name = "bo_count", > - .mode = S_IRUGO > + .mode = 0444 > }; > > /* default destructor */ > diff --git a/drivers/gpu/drm/ttm/ttm_memory.c b/drivers/gpu/drm/ttm/ttm_memory.c > index 450387c92b63..e17a58dc90f5 100644 > --- a/drivers/gpu/drm/ttm/ttm_memory.c > +++ b/drivers/gpu/drm/ttm/ttm_memory.c > @@ -54,23 +54,23 @@ struct ttm_mem_zone { > > static struct attribute ttm_mem_sys = { > .name = "zone_memory", > - .mode = S_IRUGO > + .mode = 0444 > }; > static struct attribute ttm_mem_emer = { > .name = "emergency_memory", > - .mode = S_IRUGO | S_IWUSR > + .mode = 0644 > }; > static struct attribute ttm_mem_max = { > .name = "available_memory", > - .mode = S_IRUGO | S_IWUSR > + .mode = 0644 > }; > static struct attribute ttm_mem_swap = { > .name = "swap_limit", > - .mode = S_IRUGO | S_IWUSR > + .mode = 0644 > }; > static struct attribute ttm_mem_used = { > .name = "used_memory", > - .mode = S_IRUGO > + .mode = 0444 > }; > > static void ttm_mem_zone_kobj_release(struct kobject *kobj) > @@ -170,7 +170,7 @@ static struct kobj_type ttm_mem_zone_kobj_type = { > > static struct attribute ttm_mem_global_lower_mem_limit = { > .name = "lower_mem_limit", > - .mode = S_IRUGO | S_IWUSR > + .mode = 0644 > }; > > static ssize_t ttm_mem_global_show(struct kobject *kobj, > diff --git a/drivers/gpu/drm/ttm/ttm_page_alloc.c b/drivers/gpu/drm/ttm/ttm_page_alloc.c > index 06c94e3a5f15..942d051e6833 100644 > --- a/drivers/gpu/drm/ttm/ttm_page_alloc.c > +++ b/drivers/gpu/drm/ttm/ttm_page_alloc.c > @@ -131,15 +131,15 @@ struct ttm_pool_manager { > > static struct attribute ttm_page_pool_max = { > .name = "pool_max_size", > - .mode = S_IRUGO | S_IWUSR > + .mode = 0644 > }; > static struct attribute ttm_page_pool_small = { > .name = "pool_small_allocation", > - .mode = S_IRUGO | S_IWUSR > + .mode = 0644 > }; > static struct attribute ttm_page_pool_alloc_size = { > .name = "pool_allocation_size", > - .mode = S_IRUGO | S_IWUSR > + .mode = 0644 > }; > > static struct attribute *ttm_pool_attrs[] = { > diff --git a/drivers/gpu/drm/ttm/ttm_page_alloc_dma.c b/drivers/gpu/drm/ttm/ttm_page_alloc_dma.c > index f63d99c302e4..251343f816e1 100644 > --- a/drivers/gpu/drm/ttm/ttm_page_alloc_dma.c > +++ b/drivers/gpu/drm/ttm/ttm_page_alloc_dma.c > @@ -178,15 +178,15 @@ static struct ttm_pool_manager *_manager; > > static struct attribute ttm_page_pool_max = { > .name = "pool_max_size", > - .mode = S_IRUGO | S_IWUSR > + .mode = 0644 > }; > static struct attribute ttm_page_pool_small = { > .name = "pool_small_allocation", > - .mode = S_IRUGO | S_IWUSR > + .mode = 0644 > }; > static struct attribute ttm_page_pool_alloc_size = { > .name = "pool_allocation_size", > - .mode = S_IRUGO | S_IWUSR > + .mode = 0644 > }; > > static struct attribute *ttm_pool_attrs[] = { > diff --git a/drivers/gpu/drm/udl/udl_fb.c b/drivers/gpu/drm/udl/udl_fb.c > index 2ebdc6d5a76e..463fb16659d8 100644 > --- a/drivers/gpu/drm/udl/udl_fb.c > +++ b/drivers/gpu/drm/udl/udl_fb.c > @@ -28,8 +28,8 @@ > static int fb_defio = 0; /* Optionally enable experimental fb_defio mmap support */ > static int fb_bpp = 16; > > -module_param(fb_bpp, int, S_IWUSR | S_IRUSR | S_IWGRP | S_IRGRP); > -module_param(fb_defio, int, S_IWUSR | S_IRUSR | S_IWGRP | S_IRGRP); > +module_param(fb_bpp, int, 0660); > +module_param(fb_defio, int, 0660); > > struct udl_fbdev { > struct drm_fb_helper helper; > diff --git a/drivers/gpu/host1x/debug.c b/drivers/gpu/host1x/debug.c > index 329e4a3d8ae7..d80e258f972f 100644 > --- a/drivers/gpu/host1x/debug.c > +++ b/drivers/gpu/host1x/debug.c > @@ -177,20 +177,20 @@ static void host1x_debugfs_init(struct host1x *host1x) > /* Store the created entry */ > host1x->debugfs = de; > > - debugfs_create_file("status", S_IRUGO, de, host1x, &host1x_debug_fops); > - debugfs_create_file("status_all", S_IRUGO, de, host1x, > + debugfs_create_file("status", 0444, de, host1x, &host1x_debug_fops); > + debugfs_create_file("status_all", 0444, de, host1x, > &host1x_debug_all_fops); > > - debugfs_create_u32("trace_cmdbuf", S_IRUGO|S_IWUSR, de, > + debugfs_create_u32("trace_cmdbuf", 0644, de, > &host1x_debug_trace_cmdbuf); > > host1x_hw_debug_init(host1x, de); > > - debugfs_create_u32("force_timeout_pid", S_IRUGO|S_IWUSR, de, > + debugfs_create_u32("force_timeout_pid", 0644, de, > &host1x_debug_force_timeout_pid); > - debugfs_create_u32("force_timeout_val", S_IRUGO|S_IWUSR, de, > + debugfs_create_u32("force_timeout_val", 0644, de, > &host1x_debug_force_timeout_val); > - debugfs_create_u32("force_timeout_channel", S_IRUGO|S_IWUSR, de, > + debugfs_create_u32("force_timeout_channel", 0644, de, > &host1x_debug_force_timeout_channel); > } >