From mboxrd@z Thu Jan 1 00:00:00 1970 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: base64 Subject: [v1] EDAC, armv8: Add Cache Error Reporting driver for ARMv8 processors From: Kyle Yan Message-Id: <6c3d84bd102d49aa78591caa5adf7bfc@codeaurora.org> Date: Wed, 17 Jan 2018 17:19:47 -0800 To: James Morse Cc: Mark Rutland , linux-edac@vger.kernel.org, mchehab@kernel.org, bp@alien8.de, linux-arm-kernel@lists.infradead.org, suzuki.poulose@arm.com List-ID: T24gMjAxOC0wMS0xNiAwNToxMSwgSmFtZXMgTW9yc2Ugd3JvdGU6Cj4gSGkgS3lsZSwKPiAKPiAo VGhhbmtzIGZvciBsb29waW5nIG1lIGluIE1hcmshKQo+IAo+IE9uIDE2LzAxLzE4IDAxOjAwLCBL eWxlIFlhbiB3cm90ZToKPj4gT24gMjAxOC0wMS0xNSAwNjo0NCwgTWFyayBSdXRsYW5kIHdyb3Rl Ogo+Pj4gT24gRnJpLCBKYW4gMTIsIDIwMTggYXQgMDQ6NTA6MjZQTSAtMDgwMCwgS3lsZSBZYW4g d3JvdGU6Cj4+Pj4gSW50ZXJydXB0IGJhc2VkIEVEQUMgZHJpdmVyIGZvciBBUk12OCBwcm9jZXNz b3JzIHRoYXQgaW1wbGVtZW50Cj4+Pj4gUkFTIGZvciBlcnJvciBkZXRlY3Rpb24gb2YgQ1BVIGNh Y2hlcyBhbmQgbHNvIGFsbG93cyBvcHRpb25hbCAKPj4+PiBwb2xsaW5nCj4+Pj4gb2YgZXJyb3Ig c3luZHJvbWUgcmVnaXN0ZXJzIGlmIGludGVycnVwdHMgYXJlIG5vdCBzdXBwb3J0ZWQuCj4+PiAK Pj4+IElzIHRoaXMgdXNpbmcgdGhlIGFyY2hpdGVjdHVyYWwgUkFTIGV4dGVuc2lvbnMsIG9yIHNv bWV0aGluZyBzcGVjaWZpYyAKPj4+IHRvCj4+PiBRQyBDUFVzPyBJdCB3b3VsZCBiZSBnb29kIHRv IGNhbGwgdGhpcyBvdXQgZXhwbGljaXRseS4KPj4+IAo+Pj4gSWYgaXQncyB0aGUgbGF0dGVyLCB0 aGlzIG5lZWRzIHJld29yZGluZyB0byBiZSBjbGVhciB0aGF0IHRoaXMgaXMKPj4+IHNwZWNpZmlj IHRvIFFDIENQVXMsIGFuZCBpcyBub3QgYSBnZW5lcmljIEFSTXY4IGZlYXR1cmUuCj4gCj4+IFRo aXMgaXMgbm90IHNwZWNpZmljIHRvIFFDIENQVXMgYW5kIGxvb2tzIGF0IHRoZSBzeXN0ZW0gcmVn aXN0ZXJzIAo+PiBkZWZpbmVkIGJ5IHRoZQo+PiBSQVMgZXh0ZW5zaW9ucy4KPiAKPiBFeGNlbGxl bnQsIHNvIGl0IHNob3VsZCB3b3JrIG9uIHRoZSBGVlAgdG9vIQo+IAo+IFsuLi5dCj4gCj4gCj4+ PiBJZiB0aGlzIGlzIGFyY2hpdGVjdHVyYWwsIGhvdyBpcyB0aGlzIGV4cGVjdGVkIHRvIHdvcmsg b24gQUNQSSAKPj4+IHN5c3RlbXM/Cj4+PiAKPj4gVGhlIGN1cnJlbnQgZGVzaWduIG9mIHRoaXMg ZHJpdmVyIGhhcyBvbmx5IGJlZW4gdGVzdGVkL3VzZWQgb24gbW9iaWxlIAo+PiBkZXZpY2VzIHNv Cj4+IEkgZG8gbm90IHlldCBrbm93IGhvdyBpdCB3aWxsIHdvcmsgb24gQUNQSSBzeXN0ZW1zLgo+ IAo+IEZvciBBQ1BJIHN5c3RlbXMgd2FudGluZyB0byBkbyBrZXJuZWwtZmlyc3QgSSBhc3N1bWUg dGhlcmUgd2lsbCBuZWVkIHRvIAo+IGJlIHNvbWUKPiBkZXNjcmlwdGlvbiBvZiB3aGVyZSB0aGUg bW1pbyBSQVMgbm9kZXMgYXJlIGluIHRoZSBhZGRyZXNzIHNwYWNlIGFuZCAKPiB3aGF0Cj4gaW50 ZXJydXB0cyBldGMgdGhleSBnZW5lcmF0ZS4gVGhpcyB3b3VsZCBiZSBlcXVpdmFsZW50IHRvIHRo ZSBkYXRhIGluIAo+IHRoZSBEVC4KPiAKPiBIb3cgY29tZSB5b3UgZG9uJ3QgcmVhZCBFUlJJRFIg dG8gZmluZCBvdXQgaG93IG1hbnkgbm9kZXMgYXJlIGJlaGluZCAKPiB0aGUgQ1BVCj4gaW50ZXJm YWNlIHJlZ2lzdGVycz8gU3VyZWx5IHlvdSBoYXZlIHRvIHBvbGwgYWxsIG9mIHRoZW0/Cj4gCj4g SWYgeW91J3JlIHBvbGxpbmcgdGhpcywgeW91IG11c3QgaGF2ZSB0byBwb2tlIHRoZSBzeXN0ZW0g cmVnaXN0ZXIgCj4gZXZlcnktc2Vjb25kCj4gb24gZXZlcnktQ1BVLiBXb3VsZG4ndCBpdCBiZSBi ZXR0ZXIgdG8gdXNlIHRoZSBtZW1vcnktbWFwcGVkIGludGVyZmFjZSAKPiBvbiBvbmUKPiBDUFUg dG8gZG8gdGhpcz8KPiAKPiBZb3UgYXJlbid0IHRvdWNoaW5nIEVSUjxuPkZSIGF0IGFsbCwgdGhp cyB0ZWxscyB1cyB3aGV0aGVyIHRoZSBub2RlKD8pIAo+IHN1cHBvcnRzCj4gZXJyb3IgcmVjb3Zl cnkgaW50ZXJydXB0cywgY291bnRlciBmb3JtYXRzIGV0Yy4KPiAKPiAKPj4+PiBkaWZmIC0tZ2l0 IGEvZHJpdmVycy9lZGFjL0tjb25maWcgYi9kcml2ZXJzL2VkYWMvS2NvbmZpZwo+Pj4+IGluZGV4 IDk2YWZiMmEuLjQ3YTY4ZTMgMTAwNjQ0Cj4+Pj4gLS0tIGEvZHJpdmVycy9lZGFjL0tjb25maWcK Pj4+PiArKysgYi9kcml2ZXJzL2VkYWMvS2NvbmZpZwo+Pj4+IEBAIC00NTcsNCArNDU3LDI1IEBA IGNvbmZpZyBFREFDX1hHRU5FCj4+Pj4gICAgICAgIFN1cHBvcnQgZm9yIGVycm9yIGRldGVjdGlv biBhbmQgY29ycmVjdGlvbiBvbiB0aGUKPj4+PiAgICAgICAgQVBNIFgtR2VuZSBmYW1pbHkgb2Yg U09Dcy4KPj4+PiAKPj4+PiArY29uZmlnIEVEQUNfQVJNVjgKPj4+PiArICAgIGRlcGVuZHMgb24g KEFSTSB8fCBBUk02NCkKPiAKPiBBcyB5b3UgYXJlIGFjY2Vzc2luZyBzeXN0ZW0gcmVnaXN0ZXJz IHRoaXMgc2hvdWxkIGRlcGVuZCBvbiAKPiAnQVJNNjRfUkFTX0VYVE4nCj4gdG9vLCBhbmQgcmVn aXN0ZXIgYWNjZXNzZXMgbmVlZCB0byBiZSBiZWhpbmQgc29tZXRoaW5nIGxpa2UKPiBjcHVzX2hh dmVfY29uc3RfY2FwKEFSTTY0X1JBU19FWFROKS4KPiAKPiBUaGUgcGF0Y2ggdGhhdCBhZGRzIHRo ZXNlIGJpdHMgaXMgaGVyZToKPiBodHRwczovL3d3dy5zcGluaWNzLm5ldC9saXN0cy9hcm0ta2Vy bmVsL21zZzYyODk5Ny5odG1sCj4gCj4gKEkgZG9uJ3Qga25vdyBob3cgY3B1ZmVhdHVyZSBkZXRl Y3Rpb24gd29ya3Mgb24gMzJiaXQpCj4gCj4gCj4+Pj4gKyAgICB0cmlzdGF0ZSAiQVJNdjggTDEv TDIvTDMvU0NVIENhY2hlcyBFQ0MiCj4+Pj4gKyAgICBoZWxwCj4+Pj4gKyAgICAgICBTdXBwb3J0 IGZvciBlcnJvciBkZXRlY3Rpb24gYW5kIGNvcnJlY3Rpb24gb24gQVJNdjggY29yZXMKPj4+PiAr ICAgICAgIHN1cHBvcnRpbmcgUkFTIGZlYXR1cmVzLiBSZXBvcnRzIGVycm9ycyBjYXVnaHQgYnkg QVJNdjgKPj4+PiArICAgICAgIEVDQyBtZWNoYW5pc20uCj4+Pj4gKyAgICAgICBGb3IgZGVidWdn aW5nIGlzc3VlcyBoYXZpbmcgdG8gZG8gd2l0aCBzdGFiaWxpdHkgYW5kIG92ZXJhbGwgCj4+Pj4g c3lzdGVtCj4+Pj4gKyAgICAgICBoZWFsdGgsIHlvdSBzaG91bGQgcHJvYmFibHkgc2F5ICdZJyBo ZXJlLgo+Pj4+ICsKPj4+PiArY29uZmlnIEVEQUNfQVJNVjhfUE9MTAo+Pj4+ICsgICAgZGVwZW5k cyBvbiBFREFDX0FSTVY4Cj4+Pj4gKyAgICBib29sICJQb2xsIG9uIEFSTXY4IEVDQyByZWdpc3Rl cnMiCj4+Pj4gKyAgICBoZWxwCj4+Pj4gKyAgICAgICBUaGlzIG9wdGlvbiBjaG9vc2VzIHdoZXRo ZXIgb3Igbm90IHlvdSB3YW50IHRvIHBvbGwgb24gdGhlIAo+Pj4+IEtyeW8zeHgKPj4+PiArICAg ICAgIEVDQyByZWdpc3RlcnMuCj4+PiAKPj4+IEFyZSB0aGVzZSByZWdpc3RlcnMgc3BlY2lmaWMg dG8gS3J5bzN4eCAoaS5lLiBJTVBMRU1FTlRBVElPTiAKPj4+IERFRklORUQpLAo+Pj4gb3IgYXJl IHRoZXkgZGVmaW5lZCBieSB0aGUgUkFTIGV4dGVuc2lvbnM/Cj4+PiAKPj4gT29wcyEgVHlwbyBo ZXJlLiBUaGUgcmVnaXN0ZXJzIGFyZSBkZWZpbmVkIGJ5IFJBUyBleHRlbnNpb25zLgo+PiAKPj4+ PiAgICAgICAgICBXaGVuIHRoaXMgaXMgZW5hYmxlZCwgdGhlIHBvbGxpbmcgcmF0ZSBjYW4gYmUg c2V0IGFzCj4+Pj4gKyAgICAgICBhIG1vZHVsZSBwYXJhbWV0ZXIuIEJ5IGRlZmF1bHQsIGl0IHdp bGwgY2FsbCB0aGUgcG9sbGluZyAKPj4+PiBmdW5jdGlvbgo+Pj4+ICsgICAgICAgZXZlcnkgc2Vj b25kLgo+IAo+IEFDUEkncyBmaXJtd2FyZS1maXJzdCBwb2xsaW5nIG1lY2hhbmlzbSBhbGxvd3Mg ZmlybXdhcmUgdG8gc3BlY2lmeSB0aGUgCj4gcG9sbGluZwo+IHJhdGUuIEhvdyB3YXMgJ2V2ZXJ5 IHNlY29uZCcgcGlja2VkPyBEb2VzIGl0IGRlcGVuZCBvbiB0aGUgU29DPwo+IAo+IAo+Pj4+ICsg ICAgICAgVGhpcyBvcHRpb24gc2hvdWxkIG9ubHkgYmUgdXNlZCBpZiB0aGUgYXNzb2NpYXRlZCBp bnRlcnJ1cHQgCj4+Pj4gbGluZXMKPj4+PiArICAgICAgIGFyZSBub3QgZW5hYmxlZC4KPiAKPiBI b3cgZG9lcyB0aGUgdXNlciBrbm93Pwo+IAo+IAo+Pj4+IGRpZmYgLS1naXQgYS9kcml2ZXJzL2Vk YWMvYXJtdjhfZWRhYy5jIGIvZHJpdmVycy9lZGFjL2FybXY4X2VkYWMuYwo+Pj4+IG5ldyBmaWxl IG1vZGUgMTAwNjQ0Cj4+Pj4gaW5kZXggMDAwMDAwMC4uZDk4NmM0Nwo+Pj4+IC0tLSAvZGV2L251 bGwKPj4+PiArKysgYi9kcml2ZXJzL2VkYWMvYXJtdjhfZWRhYy5jCj4+Pj4gQEAgLTAsMCArMSw0 ODkgQEAKPj4+PiArLyogQ29weXJpZ2h0IChjKSAyMDE2LTIwMTgsIFRoZSBMaW51eCBGb3VuZGF0 aW9uLiBBbGwgcmlnaHRzIAo+Pj4+IHJlc2VydmVkLgo+Pj4+ICsgKgo+Pj4+ICsgKiBUaGlzIHBy b2dyYW0gaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yIAo+ Pj4+IG1vZGlmeQo+Pj4+ICsgKiBpdCB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEdOVSBHZW5lcmFs IFB1YmxpYyBMaWNlbnNlIHZlcnNpb24gMiAKPj4+PiBhbmQKPj4+PiArICogb25seSB2ZXJzaW9u IDIgYXMgcHVibGlzaGVkIGJ5IHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb24uCj4+Pj4gKyAq Cj4+Pj4gKyAqIFRoaXMgcHJvZ3JhbSBpcyBkaXN0cmlidXRlZCBpbiB0aGUgaG9wZSB0aGF0IGl0 IHdpbGwgYmUgdXNlZnVsLAo+Pj4+ICsgKiBidXQgV0lUSE9VVCBBTlkgV0FSUkFOVFk7IHdpdGhv dXQgZXZlbiB0aGUgaW1wbGllZCB3YXJyYW50eSBvZgo+Pj4+ICsgKiBNRVJDSEFOVEFCSUxJVFkg b3IgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UuICBTZWUgdGhlCj4+Pj4gKyAqIEdO VSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGZvciBtb3JlIGRldGFpbHMuCj4+Pj4gKyAqLwo+Pj4+ ICsKPj4+PiArI2luY2x1ZGUgPGxpbnV4L2tlcm5lbC5oPgo+Pj4+ICsjaW5jbHVkZSA8bGludXgv ZWRhYy5oPgo+Pj4+ICsjaW5jbHVkZSA8bGludXgvb2ZfZGV2aWNlLmg+Cj4+Pj4gKyNpbmNsdWRl IDxsaW51eC9wbGF0Zm9ybV9kZXZpY2UuaD4KPj4+PiArI2luY2x1ZGUgPGxpbnV4L3NtcC5oPgo+ Pj4+ICsjaW5jbHVkZSA8bGludXgvY3B1Lmg+Cj4+Pj4gKyNpbmNsdWRlIDxsaW51eC9jcHVfcG0u aD4KPj4+PiArI2luY2x1ZGUgPGxpbnV4L2ludGVycnVwdC5oPgo+Pj4+ICsjaW5jbHVkZSA8bGlu dXgvb2ZfaXJxLmg+Cj4gCj4gKE5pdDogYWxwaGFiZXRpY2FsIG9yZGVyIG1ha2VzIGZvciBmZXdl ciBjb25mbGljdHMgaW4gdGhlIGZ1dHVyZSkKPiAKPiAKPj4+PiArI2luY2x1ZGUgImVkYWNfbWMu aCIKPj4+PiArI2luY2x1ZGUgImVkYWNfZGV2aWNlLmgiCj4+Pj4gKwo+Pj4+ICtzdGF0aWMgaW50 IHBvbGxfbXNlYyA9IDEwMDA7Cj4+Pj4gK21vZHVsZV9wYXJhbShwb2xsX21zZWMsIGludCwgMDQ0 NCk7Cj4+Pj4gKwo+Pj4+ICtzdGF0aWMgYm9vbCBwYW5pY19vbl91ZSA9IDA7Cj4+Pj4gK21vZHVs ZV9wYXJhbV9uYW1lZChwYW5pY19vbl91ZSwgcGFuaWNfb25fdWUsIGJvb2wsIDA2NjQpOwo+Pj4+ ICsKPj4+PiArI2RlZmluZSBMMSAweDAKPj4+PiArI2RlZmluZSBMMiAweDEKPj4+PiArI2RlZmlu ZSBMMyAweDIKPiAKPj4+PiArI2RlZmluZSBFREFDX0NQVSAgICAiYXJtdjhfZWRhYyIKPj4+PiAr Cj4+Pj4gKyNkZWZpbmUgRVJSWFNUQVRVU19WQUxJRChhKSAgICAoKGEgPj4gMzApICYgMHgxKQo+ Pj4+ICsjZGVmaW5lIEVSUlhTVEFUVVNfVUUoYSkgICAgKChhID4+IDI5KSAmIDB4MSkKPj4+PiAr I2RlZmluZSBFUlJYU1RBVFVTX1NFUlIoYSkgICAgKGEgJiAweEZGKQo+Pj4+ICsKPj4+PiArI2Rl ZmluZSBFUlJYTUlTQ19MVkwoYSkgICAgICAgICgoYSA+PiAxKSAmIDB4NykKPj4+PiArI2RlZmlu ZSBFUlJYTUlTQ19XQVkoYSkgICAgICAgICgoYSA+PiAyOCkgJiAweEYpCj4gCj4gV2hpY2ggRVJS PG4+TUlTQyBpcyB0aGlzPyBbMF0gaGFzIHR3by4gQXQgZmlyc3QgZ2xhbmNlIHRoZXNlIGFyZSBi b3RoCj4gaW1wbGVtZW50YXRpb24tZGVmaW5lZCwgc28gd2UgY2FuJ3QgcmVseSBvbiB0aGUgdmFs dWVzLgo+IAo+IChNSVNDMCBoYXMgc29tZSBhcmNodGl0ZWN0ZWQtbGF5b3V0LCBpdCBzZWVtcyB3 ZSdyZSBleHBlY3RlZCB0byBrbm93IAo+IHdoaWNoCj4gbGF5b3V0IGl0IHdpbGwgYmUgYmFzZWQg b24gRVJSPG4+RlIgLSBidXQgSSBjYW4ndCBzZWUgJ2x2bCcgb3IgJ3dheScgaW4gCj4gYW55IG9m Cj4gdGhvc2UgbGF5b3V0cykuCj4gCj4gWW91IGRvbid0IGNoZWNrIEVSUjxuPlNUQVRVUy5NViB0 byBrbm93IGlmIHRoZSAnTWlzY2FsbGFuZW91cyBSZWdpc3RlcnMgCj4gVmFsaWQnLgo+IAo+IAo+ Pj4+ICsjZGVmaW5lIEVSUlhDVExSX0VOQUJMRSAgICAgICAgMHgxMGYKPiAKPiBUaGlzIGxvb2tz IGxpa2UgYSBtYWdpYyB2YWx1ZSB0byBzZXQgc29tZSBiaXRzLiBDb3VsZCB5b3UgYWRkIGRlZmlu ZXMgCj4gdG8gbmFtZQo+IGVhY2ggb25lLCB0aGVuIGNvbWJpbmUgc28gd2Uga25vdyB3aGF0IHdh cyBzZXQuCj4gVGhpcyByZWdpc3RlciBoYXMgb25lIG9mIHR3byBsYXlvdXRzLCBpdCBzZWVtcyBl YWNoIGNvbnRyb2wgcGlja3MgYSAKPiBsYXlvdXQuIEhvdwo+IGNhbiB3ZSBrbm93IGlmIHRoZSBy ZWFkL3dyaXRlIGJpdHMgYXJlIGNvbWJpbmVkIG9yIHNlcGFyYXRlPyBJdCBsb29rcyAKPiBsaWtl IHRoaXMKPiBpbiBFUlI8bj5GUiB0b28uCj4gCj4gCj4+Pj4gKyNkZWZpbmUgRVJSWE1JU0NfT1ZF UkZMT1cgICAgMHg3RjdGMDAwMDAwMDBVTEwKPiAKPiBUaGlzIGxvb2tzIGxpa2UgYSBtYWdpYyB2 YWx1ZSB3cml0dGVuIHRvIGEgcmVnaXN0ZXIgd2l0aCBhbiBpbXBkZWYgCj4gbGF5b3V0Lgo+IAo+ IFsuLi5dCj4gCj4+Pj4gK3N0YXRpYyBpbmxpbmUgdm9pZCBzZXRfZXJyeGN0bHJfZWwxKHZvaWQp Cj4+Pj4gK3sKPj4+PiArICAgIGFzbSB2b2xhdGlsZSgibXNyIHMzXzBfYzVfYzRfMSwgJTAiIDog OiAiciIgKEVSUlhDVExSX0VOQUJMRSkpOwo+Pj4+ICt9Cj4gCj4+PiAKPj4+IFBsZWFzZSB1c2Ug e3JlYWQsd3JpdGV9X3N5c3JlZygpLgo+Pj4gCj4+PiBJZiB0aGVzZSByZWdpc3RlcnMgYXJlIGRl ZmluZWQgYnkgQVJNdjgsIHBsZWFzZSBwbGFjZSBkZWZpbml0aW9ucyBpbgo+Pj4gYXJtNjQncyA8 YXNtL3N5c3JlZy5oPi4KPj4+IAo+PiBXaWxsIGRvLgo+IAo+IFllcyBwbGVhc2UhCj4gCj4gKFRo ZSBzM18wX2M1X2M0XzEgc3ludGF4IGlzbid0IHN1cHBvcnRlZCBieSBhbGwgdG9vbGNoYWlucywg c2VlIAo+IDcyYzU4Mzk1MTUyNjBkYwo+ICJhcm02NDogZ2ljdjM6IEFsbG93IEdJQ3YzIGNvbXBp bGF0aW9uIHdpdGggb2xkZXIgYmludXRpbHMiKQo+IAo+IFlvdSBhbHNvIG5lZWQgdG8gZ3VhcmQg dGhlc2Ugd2l0aCBzb21ldGhpbmcgbGlrZQo+IGNwdXNfaGF2ZV9jb25zdF9jYXAoQVJNNjRfUkFT X0VYVE4pIHNvIENQVXMgd2l0aG91dCB0aGUgUkFTIGV4dGVuc2lvbnMgCj4gZG9uJ3QgdHJ5Cj4g dG8gYWNjZXNzIGFuIHVuaW1wbGVtZW50ZWQgc3lzdGVtIHJlZ2lzdGVyLiBUZXN0aW5nIG9uY2Ug ZHVyaW5nIHByb2JlIAo+IGlzCj4gcHJvYmFibHkgdGhlIGJlc3QgcGxhY2UgdG8gZG8gdGhpcy4K PiAKPiAKPj4+PiArCj4+Pj4gK3N0cnVjdCBlcnJvcnNfZWRhYyB7Cj4+Pj4gKyAgICBjb25zdCBj aGFyICogY29uc3QgbXNnOwo+Pj4+ICsgICAgdm9pZCAoKmZ1bmMpKHN0cnVjdCBlZGFjX2Rldmlj ZV9jdGxfaW5mbyAqZWRhY19kZXYsCj4+Pj4gKyAgICAgICAgICAgIGludCBpbnN0X25yLCBpbnQg YmxvY2tfbnIsIGNvbnN0IGNoYXIgKm1zZyk7Cj4+Pj4gK307Cj4+Pj4gKwo+Pj4+ICtzdGF0aWMg Y29uc3Qgc3RydWN0IGVycm9yc19lZGFjIGVycm9yc1tdID0gewo+Pj4+ICsgICAgeyAiTDEgQ29y cmVjdGFibGUgRXJyb3IiLCBlZGFjX2RldmljZV9oYW5kbGVfY2UgfSwKPj4+PiArICAgIHsgIkwx IFVuY29ycmVjdGFibGUgRXJyb3IiLCBlZGFjX2RldmljZV9oYW5kbGVfdWUgfSwKPj4+PiArICAg IHsgIkwyIENvcnJlY3RhYmxlIEVycm9yIiwgZWRhY19kZXZpY2VfaGFuZGxlX2NlIH0sCj4+Pj4g KyAgICB7ICJMMiBVbmNvcnJlY3RhYmxlIEVycm9yIiwgZWRhY19kZXZpY2VfaGFuZGxlX3VlIH0s Cj4+Pj4gKyAgICB7ICJMMyBDb3JyZWN0YWJsZSBFcnJvciIsIGVkYWNfZGV2aWNlX2hhbmRsZV9j ZSB9LAo+Pj4+ICsgICAgeyAiTDMgVW5jb3JyZWN0YWJsZSBFcnJvciIsIGVkYWNfZGV2aWNlX2hh bmRsZV91ZSB9LAo+Pj4+ICt9Owo+Pj4+ICsKPiAKPj4+PiArI2RlZmluZSBMMV9DRSAwCj4+Pj4g KyNkZWZpbmUgTDFfVUUgMQo+Pj4+ICsjZGVmaW5lIEwyX0NFIDIKPj4+PiArI2RlZmluZSBMMl9V RSAzCj4+Pj4gKyNkZWZpbmUgTDNfQ0UgNAo+Pj4+ICsjZGVmaW5lIEwzX1VFIDUKPiAKPiBUaGlz IGFyZSByZWFkIGZyb20gRVJSPG4+TUlTQywgSSBjYW4ndCBmaW5kIHRoaXMgaW4gdGhlIHNwZWNb MF0sIGFyZSAKPiB0aGVzZQo+IHNwZWNpZmljIHRvIHlvdXIgaW1wbGVtZW50YXRpb24/Cj4gCj4g Cj4+Pj4gKyNkZWZpbmUgREFUQV9CVUZfRVJSICAgICAgICAweDIKPj4+PiArI2RlZmluZSBDQUNI RV9EQVRBX0VSUiAgICAgICAgMHg2Cj4+Pj4gKyNkZWZpbmUgQ0FDSEVfVEFHX0RJUlRZX0VSUiAg ICAweDcKPj4+PiArI2RlZmluZSBUTEJfUEFSSVRZX0VSUl9EQVRBICAgIDB4OAo+Pj4+ICsjZGVm aW5lIFRMQl9QQVJJVFlfRVJSX1RBRyAgICAweDkKPiAKPiAoTml0OiAnVEFHJyBpcyB0aGUgZXhh bXBsZSBhZGRyZXNzL2NvbnRyb2wgZGF0YSB0aGF0IGhhcyBiZWNvbWUgCj4gY29ycnVwdC4gV2UK PiBkb24ndCBrbm93IGhvdyB0aGUgY2FjaGUgaXMgZGVzaWduZWQsICdtZXRhZGF0YScgbWF5IGJl IGEgYmV0dGVyIGNob2ljZSAKPiBvZiB3b3JkCj4gaGVyZSkuCj4gCj4+Pj4gKyNkZWZpbmUgQlVT X0VSUk9SICAgICAgICAweDEyCj4gCj4gVGhlcmUgYXJlIDIxIG9mIHRoZXNlIGFuZCBvbmx5IDIg YXJlIGltcGxlbWVudGF0aW9uIGRlZmluZWQuIEhvdyBjb21lIAo+IHlvdSBkb24ndAo+IGRlZmlu ZSBhbGwgb2YgdGhlbT8KPiAKPiBBbGwgdGhlc2UgZ2V0IHVzZWQgZm9yIGlzIHRvIG1hcCB0byBh IG5hbWUsIHdvdWxkIGEgdGFibGUgYmUgYmV0dGVyPwo+IChlLmcuIGFyY2gvYXJtNjQvbW0vZmF1 bHQuYzo6ZmF1bHRfaW5mbykKPiAKPiAKPj4+PiArc3RydWN0IGVycF9kcnZkYXRhIHsKPj4+PiAr ICAgIHN0cnVjdCBlZGFjX2RldmljZV9jdGxfaW5mbyAqZWRldl9jdGw7Cj4+Pj4gKyAgICBzdHJ1 Y3QgZXJwX2RydmRhdGEgX19wZXJjcHUgKiplcnBfY3B1X2RydmRhdGE7Cj4+Pj4gKyAgICBzdHJ1 Y3Qgbm90aWZpZXJfYmxvY2sgbmJfcG07Cj4+Pj4gKyAgICBpbnQgcHBpOwo+Pj4+ICt9Owo+Pj4+ ICsKPj4+PiArc3RhdGljIHN0cnVjdCBlcnBfZHJ2ZGF0YSAqcGFuaWNfaGFuZGxlcl9kcnZkYXRh Owo+Pj4+ICsKPj4+PiArc3RhdGljIERFRklORV9TUElOTE9DSyhhcm12OF9lZGFjX2xvY2spOwo+ Pj4+ICsKPj4+PiArc3RhdGljIHZvaWQgbDFfbDJfaXJxX2VuYWJsZSh2b2lkICppbmZvKQo+Pj4+ ICt7Cj4+Pj4gKyAgICBpbnQgaXJxID0gKihpbnQgKilpbmZvOwo+Pj4+ICsKPj4+PiArICAgIGVu YWJsZV9wZXJjcHVfaXJxKGlycSwgSVJRX1RZUEVfTEVWRUxfSElHSCk7Cj4+Pj4gK30KPiAKPiAo U2hvdWxkbid0IHRoZSAncGVyY3B1JyBhbmQgJ2xldmVsX2hpZ2gnIGJlIGluZm9ybWF0aW9uIGxl YXJudCBmcm9tIHRoZSAKPiBEVD8pCj4gCj4gCj4+Pj4gK3N0YXRpYyBpbnQgcmVxdWVzdF9lcnBf aXJxKHN0cnVjdCBwbGF0Zm9ybV9kZXZpY2UgKnBkZXYsIGNvbnN0IGNoYXIgCj4+Pj4gKnByb3Bu YW1lLAo+Pj4+ICsgICAgICAgICAgICBjb25zdCBjaGFyICpkZXNjLCBpcnFfaGFuZGxlcl90IGhh bmRsZXIsCj4+Pj4gKyAgICAgICAgICAgIHZvaWQgKmVkLCBpbnQgcGVyY3B1KQo+Pj4+ICt7Cj4+ Pj4gKyAgICBpbnQgcmM7Cj4+Pj4gKyAgICBzdHJ1Y3QgcmVzb3VyY2UgKnI7Cj4+Pj4gKyAgICBz dHJ1Y3QgZXJwX2RydmRhdGEgKmRydiA9IGVkOwo+Pj4+ICsKPj4+PiArICAgIHIgPSBwbGF0Zm9y bV9nZXRfcmVzb3VyY2VfYnluYW1lKHBkZXYsIElPUkVTT1VSQ0VfSVJRLCAKPj4+PiBwcm9wbmFt ZSk7Cj4+Pj4gKwo+Pj4+ICsgICAgaWYgKCFyKSB7Cj4+Pj4gKyAgICAgICAgcHJfZXJyKCJBUk12 OCBDUFUgRVJQOiBDb3VsZCBub3QgZmluZCA8JXM+IElSUSBwcm9wZXJ0eS4gCj4+Pj4gUHJvY2Vl ZGluZwo+Pj4+IGFueXdheS5cbiIsCj4+Pj4gKyAgICAgICAgICAgIHByb3BuYW1lKTsKPj4+IAo+ Pj4gV2hhdCBpcyAiRVJQIiA/Cj4gCj4+IEVycm9yIFJlcG9ydGluZy4gSSBtYXkganVzdCByZW5h bWUgaXQgdG8gRURBQyBvciBsaXN0IGl0IG91dCBpbiAKPj4gRG9jdW1lbnRhdGlvbi4KPiAKPj4+ PiArICAgICAgICBnb3RvIG91dDsKPj4+PiArICAgIH0KPj4+PiArCj4+Pj4gKyAgICBpZiAoIXBl cmNwdSkgewo+Pj4+ICsgICAgICAgIHJjID0gZGV2bV9yZXF1ZXN0X3RocmVhZGVkX2lycSgmcGRl di0+ZGV2LCByLT5zdGFydCwgTlVMTCwKPj4+PiArICAgICAgICAgICAgICAgICAgICAgICAgICAg aGFuZGxlciwKPj4+PiArICAgICAgICAgICAgICAgICAgICAgICAgICAgSVJRRl9PTkVTSE9UIHwg SVJRRl9UUklHR0VSX0hJR0gsCj4+Pj4gKyAgICAgICAgICAgICAgICAgICAgICAgICAgIGRlc2Ms Cj4+Pj4gKyAgICAgICAgICAgICAgICAgICAgICAgICAgIGVkKTsKPj4+PiArCj4+Pj4gKyAgICAg ICAgaWYgKHJjKSB7Cj4+Pj4gKyAgICAgICAgICAgIHByX2VycigiQVJNdjggQ1BVIEVSUDogRmFp bGVkIHRvIHJlcXVlc3QgSVJRICVkOiAlZCAoJXMgCj4+Pj4gLyAlcykuCj4+Pj4gUHJvY2VlZGlu ZyBhbnl3YXkuXG4iLAo+Pj4+ICsgICAgICAgICAgICAgICAgICAgKGludCkgci0+c3RhcnQsIHJj LCBwcm9wbmFtZSwgZGVzYyk7Cj4+Pj4gKyAgICAgICAgICAgIGdvdG8gb3V0Owo+Pj4+ICsgICAg ICAgIH0KPj4+PiArCj4+Pj4gKyAgICB9IGVsc2Ugewo+Pj4+ICsgICAgICAgIGRydi0+ZXJwX2Nw dV9kcnZkYXRhID0gYWxsb2NfcGVyY3B1KHN0cnVjdCBlcnBfZHJ2ZGF0YSAqKTsKPj4+PiArICAg ICAgICBpZiAoIWRydi0+ZXJwX2NwdV9kcnZkYXRhKSB7Cj4+Pj4gKyAgICAgICAgICAgIHByX2Vy cigiRmFpbGVkIHRvIGFsbG9jYXRlIHBlcmNwdSBlcnAgZGF0YVxuIik7Cj4+Pj4gKyAgICAgICAg ICAgIGdvdG8gb3V0Owo+Pj4+ICsgICAgICAgIH0KPj4+PiArCj4+Pj4gKyAgICAgICAgKnJhd19j cHVfcHRyKGRydi0+ZXJwX2NwdV9kcnZkYXRhKSA9IGRydjsKPiAKPiByYXdfY3B1X3B0cigpLiBZ b3UgY2FsbCB0aGlzIGZyb20gYXJtdjhfY3B1X2VycF9wcm9iZSgpLCBzbyB5b3UncmUgCj4gcHJv YmFibHkKPiBwcmVlbXRpYmxlLiBDb3VsZCB5b3UgdXNlIHRoaXNfY3B1X3B0cigpIGFuZCBlbmFi bGUgCj4gQ09ORklHX0RFQlVHX1BSRUVNUFQuCj4gCj4gKEhvdyBjb21lIHlvdSBvbmx5IHNldCB0 aGlzIHBlci1jcHUgY29va2llIG9uIG9uZSBjcHU/KQo+IAo+IAo+Pj4+ICsgICAgICAgIHJjID0g cmVxdWVzdF9wZXJjcHVfaXJxKHItPnN0YXJ0LCBoYW5kbGVyLCBkZXNjLAo+Pj4+ICsgICAgICAg ICAgICAgICAgZHJ2LT5lcnBfY3B1X2RydmRhdGEpOwo+Pj4+ICsKPj4+PiArICAgICAgICBpZiAo cmMpIHsKPj4+PiArICAgICAgICAgICAgcHJfZXJyKCJBUk12OCBDUFUgRVJQOiBGYWlsZWQgdG8g cmVxdWVzdCBJUlEgJWQ6ICVkICglcyAKPj4+PiAvICVzKS4KPj4+PiBQcm9jZWVkaW5nIGFueXdh eS5cbiIsCj4+Pj4gKyAgICAgICAgICAgICAgICAgICAoaW50KSByLT5zdGFydCwgcmMsIHByb3Bu YW1lLCBkZXNjKTsKPj4+PiArICAgICAgICAgICAgZ290byBvdXRfZnJlZTsKPj4+PiArICAgICAg ICB9Cj4+Pj4gKwo+Pj4+ICsgICAgICAgIGRydi0+cHBpID0gci0+c3RhcnQ7Cj4+Pj4gKyAgICAg ICAgb25fZWFjaF9jcHUobDFfbDJfaXJxX2VuYWJsZSwgJihyLT5zdGFydCksIDEpOwo+Pj4+ICsg ICAgfQo+Pj4+ICsKPj4+PiArICAgIHJldHVybiAwOwo+Pj4+ICsKPj4+PiArb3V0X2ZyZWU6Cj4+ Pj4gKyAgICBmcmVlX3BlcmNwdShkcnYtPmVycF9jcHVfZHJ2ZGF0YSk7Cj4+Pj4gKyAgICBkcnYt PmVycF9jcHVfZHJ2ZGF0YSA9IE5VTEw7Cj4+Pj4gK291dDoKPj4+PiArICAgIHJldHVybiAxOwo+ Pj4+ICt9Cj4+Pj4gKwo+Pj4+ICtzdGF0aWMgdm9pZCBkdW1wX2Vycl9yZWcoaW50IGVycm9yY29k ZSwgaW50IGxldmVsLCB1NjQgZXJyeHN0YXR1cywgCj4+Pj4gdTY0Cj4+Pj4gZXJyeG1pc2MsCj4+ Pj4gKyAgICBzdHJ1Y3QgZWRhY19kZXZpY2VfY3RsX2luZm8gKmVkZXZfY3RsKQo+Pj4+ICt7Cj4+ Pj4gKyAgICBlZGFjX3ByaW50ayhLRVJOX0NSSVQsIEVEQUNfQ1BVLCAiRVJSWFNUQVRVU19FTDE6 ICVsbHhcbiIsIAo+Pj4+IGVycnhzdGF0dXMpOwo+Pj4+ICsgICAgZWRhY19wcmludGsoS0VSTl9D UklULCBFREFDX0NQVSwgIkVSUlhNSVNDX0VMMTogJWxseFxuIiwgCj4+Pj4gZXJyeG1pc2MpOwo+ Pj4+ICsgICAgZWRhY19wcmludGsoS0VSTl9DUklULCBFREFDX0NQVSwgIkNhY2hlIGxldmVsOiBM JWRcbiIsIAo+Pj4+IGxldmVsKzEpOwo+Pj4+ICsgICAgc3dpdGNoIChFUlJYU1RBVFVTX1NFUlIo ZXJyeHN0YXR1cykpIHsKPj4+PiArICAgIGNhc2UgREFUQV9CVUZfRVJSOgo+Pj4+ICsgICAgICAg IGVkYWNfcHJpbnRrKEtFUk5fQ1JJVCwgRURBQ19DUFUsICJFQ0MgRXJyb3IgZnJvbSBpbnRlcm5h bCAKPj4+PiBkYXRhCj4+Pj4gYnVmZmVyXG4iKTsKPj4+PiArICAgICAgICBicmVhazsKPj4+PiAr Cj4+Pj4gKyAgICBjYXNlIENBQ0hFX0RBVEFfRVJSOgo+Pj4+ICsgICAgICAgIGVkYWNfcHJpbnRr KEtFUk5fQ1JJVCwgRURBQ19DUFUsICJFQ0MgRXJyb3IgZnJvbSBjYWNoZSBkYXRhIAo+Pj4+IFJB TVxuIik7Cj4+Pj4gKyAgICAgICAgYnJlYWs7Cj4+Pj4gKwo+Pj4+ICsgICAgY2FzZSBDQUNIRV9U QUdfRElSVFlfRVJSOgo+Pj4+ICsgICAgICAgIGVkYWNfcHJpbnRrKEtFUk5fQ1JJVCwgRURBQ19D UFUsICJFQ0MgRXJyb3IgZnJvbSBjYWNoZSB0YWcgCj4+Pj4gb3IgZGlydHkKPj4+PiBSQU1cbiIp Owo+Pj4+ICsgICAgICAgIGJyZWFrOwo+Pj4+ICsKPj4+PiArICAgIGNhc2UgVExCX1BBUklUWV9F UlJfREFUQToKPj4+PiArICAgICAgICBlZGFjX3ByaW50ayhLRVJOX0NSSVQsIEVEQUNfQ1BVLCAi UGFyaXR5IGVycm9yIG9uIFRMQiBEQVRBIAo+Pj4+IFJBTVxuIik7Cj4+Pj4gKyAgICAgICAgYnJl YWs7Cj4+Pj4gKwo+Pj4+ICsgICAgY2FzZSBUTEJfUEFSSVRZX0VSUl9UQUc6Cj4+Pj4gKyAgICAg ICAgZWRhY19wcmludGsoS0VSTl9DUklULCBFREFDX0NQVSwgIlBhcml0eSBlcnJvciBvbiBUTEIg VEFHIAo+Pj4+IFJBTVxuIik7Cj4+Pj4gKyAgICAgICAgYnJlYWs7Cj4+Pj4gKwo+Pj4+ICsgICAg Y2FzZSBCVVNfRVJST1I6Cj4+Pj4gKyAgICAgICAgZWRhY19wcmludGsoS0VSTl9DUklULCBFREFD X0NQVSwgIkJ1cyBFcnJvclxuIik7Cj4+Pj4gKyAgICAgICAgYnJlYWs7Cj4+Pj4gKyAgICB9Cj4g Cj4+Pj4gKyAgICBpZiAobGV2ZWwgPT0gTDMpCj4+Pj4gKyAgICAgICAgZWRhY19wcmludGsoS0VS Tl9DUklULCBFREFDX0NQVSwKPj4+PiArICAgICAgICAgICAgIldheTogJWRcbiIsIChpbnQpIEVS UlhNSVNDX1dBWShlcnJ4bWlzYykpOwo+Pj4+ICsgICAgZWxzZQo+Pj4+ICsgICAgICAgIGVkYWNf cHJpbnRrKEtFUk5fQ1JJVCwgRURBQ19DUFUsCj4+Pj4gKyAgICAgICAgICAgICJXYXk6ICVkXG4i LCAoaW50KSBFUlJYTUlTQ19XQVkoZXJyeG1pc2MpID4+IDIpOwo+Pj4+ICsKPj4+PiArICAgIGVk ZXZfY3RsLT5wYW5pY19vbl91ZSA9IHBhbmljX29uX3VlOwo+Pj4+ICsgICAgZXJyb3JzW2Vycm9y Y29kZV0uZnVuYyhlZGV2X2N0bCwgc21wX3Byb2Nlc3Nvcl9pZCgpLAo+Pj4+ICsgICAgICAgICAg ICAgICAgbGV2ZWwsIGVycm9yc1tlcnJvcmNvZGVdLm1zZyk7Cj4+Pj4gK30KPj4+PiArCj4+Pj4g K3N0YXRpYyB2b2lkIGFybXY4X3BhcnNlX2wxX2wyX2NhY2hlX2Vycm9yKHU2NCBlcnJ4c3RhdHVz LCB1NjQgCj4+Pj4gZXJyeG1pc2MsCj4+Pj4gKyAgICBzdHJ1Y3QgZWRhY19kZXZpY2VfY3RsX2lu Zm8gKmVkZXZfY3RsKQo+Pj4+ICt7Cj4+Pj4gKyAgICBzd2l0Y2ggKEVSUlhNSVNDX0xWTChlcnJ4 bWlzYykpIHsKPj4+PiArICAgIGNhc2UgTDE6Cj4+Pj4gKyAgICAgICAgaWYgKEVSUlhTVEFUVVNf VUUoZXJyeHN0YXR1cykpCj4+Pj4gKyAgICAgICAgICAgIGR1bXBfZXJyX3JlZyhMMV9VRSwgTDEs IGVycnhzdGF0dXMsIGVycnhtaXNjLAo+Pj4+ICsgICAgICAgICAgICAgICAgICAgIGVkZXZfY3Rs KTsKPj4+PiArICAgICAgICBlbHNlCj4+Pj4gKyAgICAgICAgICAgIGR1bXBfZXJyX3JlZyhMMV9D RSwgTDEsIGVycnhzdGF0dXMsIGVycnhtaXNjLAo+Pj4+ICsgICAgICAgICAgICAgICAgICAgIGVk ZXZfY3RsKTsKPiAKPiBJZiB0aGUgVUUgYml0IGlzIGNsZWFyIHRoZSBlcnJvciBtYXkgaGF2ZSBi ZWVuICdjb3JyZWN0ZWQgb3IgZGVmZXJyZWQnLiAKPiBJIGd1ZXNzCj4gd2UgYXNzdW1lIGRlZmVy cmVkIGVycm9ycyBkb24ndCBoYXBwZW4sIHNvICFVRSBtZWFucyBDb3JyZWN0ZWQtRXJyb3IuCj4g Cj4gCj4+Pj4gKyAgICAgICAgYnJlYWs7Cj4+Pj4gKyAgICBjYXNlIEwyOgo+Pj4+ICsgICAgICAg IGlmIChFUlJYU1RBVFVTX1VFKGVycnhzdGF0dXMpKQo+Pj4+ICsgICAgICAgICAgICBkdW1wX2Vy cl9yZWcoTDJfVUUsIEwyLCBlcnJ4c3RhdHVzLCBlcnJ4bWlzYywKPj4+PiArICAgICAgICAgICAg ICAgICAgICBlZGV2X2N0bCk7Cj4+Pj4gKyAgICAgICAgZWxzZQo+Pj4+ICsgICAgICAgICAgICBk dW1wX2Vycl9yZWcoTDJfQ0UsIEwyLCBlcnJ4c3RhdHVzLCBlcnJ4bWlzYywKPj4+PiArICAgICAg ICAgICAgICAgICAgICBlZGV2X2N0bCk7Cj4+Pj4gKyAgICAgICAgYnJlYWs7Cj4+Pj4gKyAgICBk ZWZhdWx0Ogo+Pj4+ICsgICAgICAgIGVkYWNfcHJpbnRrKEtFUk5fQ1JJVCwgRURBQ19DUFUsICJV bmtub3duIEVSUlhNSVNDX0xWTCAKPj4+PiB2YWx1ZVxuIik7Cj4+Pj4gKyAgICB9Cj4+Pj4gK30K Pj4+PiArCj4+Pj4gK3N0YXRpYyBib29sIGFybXY4X2NoZWNrX2wxX2wyX2VjYyh2b2lkICppbmZv KQo+Pj4+ICt7Cj4+Pj4gKyAgICBzdHJ1Y3QgZWRhY19kZXZpY2VfY3RsX2luZm8gKmVkZXZfY3Rs ID0gaW5mbzsKPj4+PiArICAgIHU2NCBlcnJ4c3RhdHVzOwo+Pj4+ICsgICAgdTY0IGVycnhtaXNj Owo+Pj4+ICsgICAgdW5zaWduZWQgbG9uZyBmbGFnczsKPj4+PiArCj4+Pj4gKyAgICBzcGluX2xv Y2tfaXJxc2F2ZSgmYXJtdjhfZWRhY19sb2NrLCBmbGFncyk7Cj4gCj4+Pj4gKyAgICB3cml0ZV9l cnJzZWxyX2VsMSgwKTsKPiAKPiBIb3cgZG8gd2Uga25vdyBob3cgbWFueSBub2RlcyBiYWNrZWQg YnkgdGhlIGNwdSBpbnRlcmZhY2UgdGhlcmUgYXJlPwo+IEhvdyBkbyB3ZSBrbm93ICcwJyBpcyB0 aGUgb25lIHdlIHdhbnQ/Cj4gCj4+Pj4gKyAgICBlcnJ4c3RhdHVzID0gcmVhZF9lcnJ4c3RhdHVz X2VsMSgpOwo+Pj4+ICsKPj4+PiArICAgIGlmIChFUlJYU1RBVFVTX1ZBTElEKGVycnhzdGF0dXMp KSB7Cj4+Pj4gKyAgICAgICAgZXJyeG1pc2MgPSByZWFkX2VycnhtaXNjX2VsMSgpOwo+Pj4+ICsg ICAgICAgIGVkYWNfcHJpbnRrKEtFUk5fQ1JJVCwgRURBQ19DUFUsCj4+Pj4gKyAgICAgICAgIkNQ VSVkIGRldGVjdGVkIGEgTDEvTDIgY2FjaGUgZXJyb3JcbiIsCj4+Pj4gKyAgICAgICAgc21wX3By b2Nlc3Nvcl9pZCgpKTsKPj4+PiArCj4+Pj4gKyAgICAgICAgYXJtdjhfcGFyc2VfbDFfbDJfY2Fj aGVfZXJyb3IoZXJyeHN0YXR1cywgZXJyeG1pc2MsIAo+Pj4+IGVkZXZfY3RsKTsKPj4+PiArICAg ICAgICBjbGVhcl9lcnJ4c3RhdHVzX3ZhbGlkKGVycnhzdGF0dXMpOwo+Pj4+ICsgICAgICAgIHNw aW5fdW5sb2NrX2lycXJlc3RvcmUoJmFybXY4X2VkYWNfbG9jaywgZmxhZ3MpOwo+Pj4+ICsgICAg ICAgIHJldHVybiB0cnVlOwo+Pj4+ICsgICAgfQo+Pj4+ICsgICAgc3Bpbl91bmxvY2tfaXJxcmVz dG9yZSgmYXJtdjhfZWRhY19sb2NrLCBmbGFncyk7Cj4+Pj4gKyAgICByZXR1cm4gZmFsc2U7Cj4+ Pj4gK30KPj4+PiArCj4+Pj4gK3N0YXRpYyBib29sIGFybXY4X2NoZWNrX2wzX3NjdV9lcnJvcihz dHJ1Y3QgZWRhY19kZXZpY2VfY3RsX2luZm8gCj4+Pj4gKmVkZXZfY3RsKQo+Pj4+ICt7Cj4+Pj4g KyAgICB1NjQgZXJyeHN0YXR1cyA9IDA7Cj4+Pj4gKyAgICB1NjQgZXJyeG1pc2MgPSAwOwo+Pj4+ ICsgICAgdW5zaWduZWQgbG9uZyBmbGFnczsKPj4+PiArCj4+Pj4gKyAgICBzcGluX2xvY2tfaXJx c2F2ZSgmYXJtdjhfZWRhY19sb2NrLCBmbGFncyk7Cj4gCj4+Pj4gKyAgICB3cml0ZV9lcnJzZWxy X2VsMSgxKTsKPiAKPiBIb3cgZG8gd2Uga25vdyAnMScgaXMgdGhlIG9uZSB3ZSB3YW50Pwo+IAo+ IAo+Pj4+ICsgICAgZXJyeHN0YXR1cyA9IHJlYWRfZXJyeHN0YXR1c19lbDEoKTsKPj4+PiArICAg IGVycnhtaXNjID0gcmVhZF9lcnJ4bWlzY19lbDEoKTsKPj4+PiArCj4+Pj4gKyAgICBpZiAoRVJS WFNUQVRVU19WQUxJRChlcnJ4c3RhdHVzKSAmJgo+Pj4+ICsgICAgICAgIEVSUlhNSVNDX0xWTChl cnJ4bWlzYykgPT0gTDMpIHsKPj4+PiArICAgICAgICBpZiAoRVJSWFNUQVRVU19VRShlcnJ4c3Rh dHVzKSkgewo+Pj4+ICsgICAgICAgICAgICBlZGFjX3ByaW50ayhLRVJOX0NSSVQsIEVEQUNfQ1BV LCAiRGV0ZWN0ZWQgTDMgCj4+Pj4gdW5jb3JyZWN0YWJsZQo+Pj4+IGVycm9yXG4iKTsKPj4+PiAr ICAgICAgICAgICAgZHVtcF9lcnJfcmVnKEwzX1VFLCBMMywgZXJyeHN0YXR1cywgZXJyeG1pc2Ms Cj4+Pj4gKyAgICAgICAgICAgICAgICBlZGV2X2N0bCk7Cj4+Pj4gKyAgICAgICAgfSBlbHNlIHsK Pj4+PiArICAgICAgICAgICAgZWRhY19wcmludGsoS0VSTl9DUklULCBFREFDX0NQVSwgIkRldGVj dGVkIEwzIAo+Pj4+IGNvcnJlY3RhYmxlCj4+Pj4gZXJyb3JcbiIpOwo+Pj4+ICsgICAgICAgICAg ICBkdW1wX2Vycl9yZWcoTDNfQ0UsIEwzLCBlcnJ4c3RhdHVzLCBlcnJ4bWlzYywKPj4+PiArICAg ICAgICAgICAgICAgIGVkZXZfY3RsKTsKPiAKPiBXaGF0IGFib3V0IGRlZmVycmVkIGVycm9ycz8K PiAKPiAKPj4+PiArICAgICAgICB9Cj4+Pj4gKwo+Pj4+ICsgICAgICAgIGNsZWFyX2VycnhzdGF0 dXNfdmFsaWQoZXJyeHN0YXR1cyk7Cj4+Pj4gKyAgICAgICAgc3Bpbl91bmxvY2tfaXJxcmVzdG9y ZSgmYXJtdjhfZWRhY19sb2NrLCBmbGFncyk7Cj4+Pj4gKyAgICAgICAgcmV0dXJuIHRydWU7Cj4+ Pj4gKyAgICB9Cj4+Pj4gKyAgICBzcGluX3VubG9ja19pcnFyZXN0b3JlKCZhcm12OF9lZGFjX2xv Y2ssIGZsYWdzKTsKPj4+PiArICAgIHJldHVybiBmYWxzZTsKPj4+PiArfQo+Pj4+ICsKPj4+PiAr c3RhdGljIHZvaWQgYXJtdjhfY2hlY2tfbDFfbDJfZWNjX2hlbHBlcih2b2lkICppbmZvKQo+Pj4+ ICt7Cj4+Pj4gKyAgICBhcm12OF9jaGVja19sMV9sMl9lY2MoaW5mbyk7Cj4+Pj4gK30KPj4+PiAr Cj4+Pj4gK3ZvaWQgYXJtdjhfcG9sbF9jYWNoZV9lcnJvcnMoc3RydWN0IGVkYWNfZGV2aWNlX2N0 bF9pbmZvICplZGV2X2N0bCkKPj4+PiArewo+Pj4+ICsgICAgaW50IGNwdTsKPj4+PiArCj4+Pj4g KyAgICBpZiAoIWVkZXZfY3RsKQo+Pj4+ICsgICAgICAgIGVkZXZfY3RsID0gcGFuaWNfaGFuZGxl cl9kcnZkYXRhLT5lZGV2X2N0bDsKPj4+PiArCj4+Pj4gKyAgICBhcm12OF9jaGVja19sM19zY3Vf ZXJyb3IoZWRldl9jdGwpOwo+Pj4+ICsgICAgZm9yX2VhY2hfcG9zc2libGVfY3B1KGNwdSkgewo+ Pj4+ICsgICAgICAgIHNtcF9jYWxsX2Z1bmN0aW9uX3NpbmdsZShjcHUsIGFybXY4X2NoZWNrX2wx X2wyX2VjY19oZWxwZXIsCj4+Pj4gKyAgICAgICAgICAgIGVkZXZfY3RsLCAwKTsKPiAKPiBvbl9l YWNoX2NwdSgpPwo+IAo+Pj4+ICsgICAgfQo+Pj4+ICt9Cj4+Pj4gKwo+Pj4+ICtzdGF0aWMgaXJx cmV0dXJuX3QgYXJtdjhfbDFfbDJfaGFuZGxlcihpbnQgaXJxLCB2b2lkICpkcnZkYXRhKQo+Pj4+ ICt7Cj4+Pj4gKyAgICBpZiAoYXJtdjhfY2hlY2tfbDFfbDJfZWNjKHBhbmljX2hhbmRsZXJfZHJ2 ZGF0YS0+ZWRldl9jdGwpKQo+Pj4+ICsgICAgICAgIHJldHVybiBJUlFfSEFORExFRDsKPj4+PiAr ICAgIHJldHVybiBJUlFfTk9ORTsKPj4+PiArfQo+Pj4+ICsKPj4+PiArc3RhdGljIGlycXJldHVy bl90IGFybXY4X2wzX3NjdV9oYW5kbGVyKGludCBpcnEsIHZvaWQgKmRydmRhdGEpCj4+Pj4gK3sK Pj4+PiArICAgIHN0cnVjdCBlcnBfZHJ2ZGF0YSAqZHJ2ID0gZHJ2ZGF0YTsKPj4+PiArICAgIHN0 cnVjdCBlZGFjX2RldmljZV9jdGxfaW5mbyAqZWRldl9jdGwgPSBkcnYtPmVkZXZfY3RsOwo+Pj4+ ICsKPj4+PiArICAgIGlmIChhcm12OF9jaGVja19sM19zY3VfZXJyb3IoZWRldl9jdGwpKQo+Pj4+ ICsgICAgICAgIHJldHVybiBJUlFfSEFORExFRDsKPj4+PiArICAgIHJldHVybiBJUlFfTk9ORTsK Pj4+PiArfQo+Pj4+ICsKPj4+PiArc3RhdGljIHZvaWQgaW5pdGlhbGl6ZV9yZWdpc3RlcnModm9p ZCAqaW5mbykKPj4+PiArewo+Pj4+ICsgICAgc2V0X2VycnhjdGxyX2VsMSgpOwo+Pj4+ICsgICAg c2V0X2VycnhtaXNjX292ZXJmbG93KCk7Cj4+Pj4gK30KPj4+PiArCj4+Pj4gK3N0YXRpYyB2b2lk IGluaXRfcmVnc19vbl9jcHUoYm9vbCBhbGxfY3B1cykKPj4+PiArewo+Pj4+ICsgICAgaW50IGNw dTsKPj4+PiArCj4+Pj4gKyAgICB3cml0ZV9lcnJzZWxyX2VsMSgwKTsKPiAKPiBUaGlzIG9ubHkg aGFwcGVucyBvbiB0aGUgbG9jYWwgQ1BVLCB0aGUgb3RoZXIgZW5kIG9mIHlvdXIKPiBzbXBfY2Fs bF9mdW5jdGlvbl9zaW5nbGUoKSBtYXkgaGF2ZSBqdW5rIGluIHRoaXMgcmVnaXN0ZXIuCj4gCj4g Cj4+Pj4gKyAgICBpZiAoYWxsX2NwdXMpIHsKPj4+PiArICAgICAgICBmb3JfZWFjaF9wb3NzaWJs ZV9jcHUoY3B1KQo+Pj4+ICsgICAgICAgICAgICBzbXBfY2FsbF9mdW5jdGlvbl9zaW5nbGUoY3B1 LCBpbml0aWFsaXplX3JlZ2lzdGVycywKPj4+PiArICAgICAgICAgICAgICAgICAgICAgICAgTlVM TCwgMSk7Cj4gCj4gb25fZWFjaF9jcHUoKT8KPiAKPiAKPj4+PiArICAgIH0gZWxzZSB7Cj4+Pj4g KyAgICAgICAgaW5pdGlhbGl6ZV9yZWdpc3RlcnMoTlVMTCk7Cj4+Pj4gKyAgICB9Cj4+Pj4gKwo+ Pj4+ICsgICAgd3JpdGVfZXJyc2Vscl9lbDEoMSk7Cj4+Pj4gKyAgICBpbml0aWFsaXplX3JlZ2lz dGVycyhOVUxMKTsKPiAKPiBZb3Ugc2VlbSB0byBtYWdpY2FsbHkta25vdyB0aGF0IHRoaXMgJ3Jl Y29yZCAxJyBpcyBzaGFyZWQgYmV0d2VlbiBhbGwgCj4gQ1BVcyBhbmQKPiB2aXNpYmxlIHZpYSB0 aGUgY3B1IGludGVyZmFjZS4KPiAKWWVzIHRoaXMgcG9ydGlvbiAoYW5kIGNvbWluZyB0byB0aGUg cmVhbGl6YXRpb24gdGhhdCBhIGxvdCBvZiBvdGhlciAKcGFydHMpIG9mIHRoZQpjb2RlIGlzIHNw ZWNpZmljIHRvIG91ciB0b3BvbG9neS4gSXMgdGhlcmUgYW55IHdheSB0byBkZXRlY3QgdGhpcz8g CkVSUklEUiByZXBvcnRzCmhvdyBtYW55IHJlY29yZHMgdGhlcmUgYXJlIGJ1dCBub3Qgd2hhdCBl YWNoIHJlY29yZCBpcyBmb3IuIFdpdGhvdXQgdGhpcyAKaW5mb3JtYXRpb24sCm5vdCBzdXJlIGhv dyB0aGVyZSBjb3VsZCBiZSBhIGdlbmVyaWMgaW50ZXJydXB0IGJhc2VkIGRyaXZlci4KCj4gCj4+ Pj4gK30KPj4+PiArCj4+Pj4gK3N0YXRpYyBpbnQgYXJtdjhfcG11X2NwdV9wbV9ub3RpZnkoc3Ry dWN0IG5vdGlmaWVyX2Jsb2NrICpzZWxmLAo+Pj4+ICsgICAgICAgICAgICAgICAgdW5zaWduZWQg bG9uZyBhY3Rpb24sIHZvaWQgKnYpCj4+Pj4gK3sKPj4+PiArICAgIHN3aXRjaCAoYWN0aW9uKSB7 Cj4+Pj4gKyAgICBjYXNlIENQVV9QTV9FWElUOgo+Pj4+ICsgICAgICAgIGluaXRfcmVnc19vbl9j cHUoZmFsc2UpOwo+Pj4+ICsgICAgICAgIGFybXY4X2NoZWNrX2wzX3NjdV9lcnJvcihwYW5pY19o YW5kbGVyX2RydmRhdGEtPmVkZXZfY3RsKTsKPj4+PiArICAgICAgICBhcm12OF9jaGVja19sMV9s Ml9lY2MocGFuaWNfaGFuZGxlcl9kcnZkYXRhLT5lZGV2X2N0bCk7Cj4+Pj4gKyAgICAgICAgYnJl YWs7Cj4+Pj4gKyAgICB9Cj4+Pj4gKwo+Pj4+ICsgICAgcmV0dXJuIE5PVElGWV9PSzsKPj4+PiAr fQo+Pj4gCj4+PiBXaGF0IGFib3V0IENQVSBob3RwbHVnPwo+Pj4gCj4+IEFncmVlZCB0aGF0IENQ VSBob3RwbHVnIHdpbGwgYmUgcmVxdWlyZWQgZm9yIHRoZSBzbWFsbCB3aW5kb3cgYmV0d2Vlbgo+ PiBob3RwbHVnZ2luZyBiYWNrIGluIGFuZCBMUE0gZXhpdC4KPj4gCj4+Pj4gKwo+Pj4+ICtzdGF0 aWMgaW50IGFybXY4X2NwdV9lcnBfcHJvYmUoc3RydWN0IHBsYXRmb3JtX2RldmljZSAqcGRldikK Pj4+PiArewo+Pj4+ICsgICAgc3RydWN0IGRldmljZSAqZGV2ID0gJnBkZXYtPmRldjsKPj4+PiAr ICAgIHN0cnVjdCBlcnBfZHJ2ZGF0YSAqZHJ2Owo+Pj4+ICsgICAgaW50IHJjID0gMDsKPj4+PiAr ICAgIGludCBmYWlsID0gMDsKPj4+PiArCj4+Pj4gKyAgICBpbml0X3JlZ3Nfb25fY3B1KHRydWUp Owo+Pj4+ICsKPj4+PiArICAgIGRydiA9IGRldm1fa3phbGxvYyhkZXYsIHNpemVvZigqZHJ2KSwg R0ZQX0tFUk5FTCk7Cj4+Pj4gKwo+Pj4+ICsgICAgaWYgKCFkcnYpCj4+Pj4gKyAgICAgICAgcmV0 dXJuIC1FTk9NRU07Cj4+Pj4gKwo+Pj4+ICsgICAgZHJ2LT5lZGV2X2N0bCA9IGVkYWNfZGV2aWNl X2FsbG9jX2N0bF9pbmZvKDAsICJjcHUiLAo+Pj4+ICsgICAgICAgICAgICAgICAgICAgIG51bV9w b3NzaWJsZV9jcHVzKCksICJMIiwgMywgMSwgTlVMTCwgMCwKPj4+PiArICAgICAgICAgICAgICAg ICAgICBlZGFjX2RldmljZV9hbGxvY19pbmRleCgpKTsKPj4+PiArCj4+Pj4gKyAgICBpZiAoIWRy di0+ZWRldl9jdGwpCj4+Pj4gKyAgICAgICAgcmV0dXJuIC1FTk9NRU07Cj4+Pj4gKwo+Pj4+ICsg ICAgaWYgKElTX0VOQUJMRUQoQ09ORklHX0VEQUNfQVJNVjhfUE9MTCkpIHsKPj4+PiArICAgICAg ICBkcnYtPmVkZXZfY3RsLT5lZGFjX2NoZWNrID0gYXJtdjhfcG9sbF9jYWNoZV9lcnJvcnM7Cj4+ Pj4gKyAgICAgICAgZHJ2LT5lZGV2X2N0bC0+cG9sbF9tc2VjID0gcG9sbF9tc2VjOwo+Pj4+ICsg ICAgfQo+Pj4+ICsKPj4+PiArICAgIGRydi0+ZWRldl9jdGwtPmRldiA9IGRldjsKPj4+PiArICAg IGRydi0+ZWRldl9jdGwtPm1vZF9uYW1lID0gZGV2X25hbWUoZGV2KTsKPj4+PiArICAgIGRydi0+ ZWRldl9jdGwtPmRldl9uYW1lID0gZGV2X25hbWUoZGV2KTsKPiAKPj4+PiArICAgIGRydi0+ZWRl dl9jdGwtPmN0bF9uYW1lID0gImNhY2hlIjsKPiAKPiBIb3cgZG8gd2Uga25vdyByZWNvcmRzICcw JyBhbmQgJzEnIGFyZSAnY2FjaGUnPwo+IAo+IAo+Pj4+ICsgICAgZHJ2LT5lZGV2X2N0bC0+cGFu aWNfb25fdWUgPSBwYW5pY19vbl91ZTsKPj4+PiArICAgIGRydi0+bmJfcG0ubm90aWZpZXJfY2Fs bCA9IGFybXY4X3BtdV9jcHVfcG1fbm90aWZ5Owo+Pj4+ICsgICAgcGxhdGZvcm1fc2V0X2RydmRh dGEocGRldiwgZHJ2KTsKPj4+PiArCj4+Pj4gKyAgICByYyA9IGVkYWNfZGV2aWNlX2FkZF9kZXZp Y2UoZHJ2LT5lZGV2X2N0bCk7Cj4+Pj4gKyAgICBpZiAocmMpCj4+Pj4gKyAgICAgICAgZ290byBv dXRfbWVtOwo+Pj4+ICsKPj4+PiArICAgIHBhbmljX2hhbmRsZXJfZHJ2ZGF0YSA9IGRydjsKPj4+ PiArCj4+Pj4gKyAgICBpZiAoIUlTX0VOQUJMRUQoQ09ORklHX0VEQUNfQVJNVjhfUE9MTCkpIHsK Pj4+PiArICAgICAgICBmYWlsICs9IHJlcXVlc3RfZXJwX2lycShwZGV2LCAibDEtbDItaXJxIiwK Pj4+PiArICAgICAgICAgICAgICAgICJsMV9sMl9pcnEiLAo+Pj4+ICsgICAgICAgICAgICAgICAg YXJtdjhfbDFfbDJfaGFuZGxlciwgZHJ2LCAxKTsKPj4+PiArCj4+Pj4gKyAgICAgICAgZmFpbCAr PSByZXF1ZXN0X2VycF9pcnEocGRldiwgImwzLXNjdS1pcnEiLAo+Pj4+ICsgICAgICAgICAgICAg ICAgImwzX3NjdV9pcnEiLAo+Pj4+ICsgICAgICAgICAgICAgICAgYXJtdjhfbDNfc2N1X2hhbmRs ZXIsIGRydiwgMCk7Cj4gCj4gSG93IGRvIHdlIGtub3cgJ2wxL2wyJyBpcyBwZXItY3B1IGFuZCBs MiBpc24ndD8gSSdkIGV4cGVjdCB0aGlzIAo+IGluZm9ybWF0aW9uIHRvCj4gY29tZSBmcm9tIHRo ZSBEVC4KPiAKPiAKPj4+IFNDVSBpc24ndCBhbiBhcmNoaXRlY3R1cmFsIGNvbmNlcHQsIGFuZCBh IGNvbWJpbmVkIGwxLWwyIGludGVycnVwdAo+Pj4gc291bmRzIHZlcnkgc3BlY2lmaWMgdG8gYSBw YXJ0aWN1bGFyIGltcGxlbWVudGF0aW9uLgo+IAo+PiBDYW4gZG8gYSByZW5hbWUgdG8gc29tZXRo aW5nIG1vcmUgYWtpbiB0byAicHJpdmF0ZV9jYWNoZV9pcnEiIGFuZAo+PiAic2hhcmVkX2NhY2hl X2lycSIuCj4gCj4+PiBNeSB1bmRlcnN0YW5kaW5nIHdhcyB0aGF0IHdpdGggdGhlIFJBUyBleHRl bnNpb25zLCBTRXJyb3Igd291bGQgYmUgCj4+PiB1c2VkCj4+PiB0byBub3RpZnkgb24gUkFTIGNv bmRpdGlvbnMsIHNvIEknbSBjb25mdXNlZCBhcyB0byB3aHkgd2UnZCBuZWVkCj4+PiByZWd1bGFy IGludGVycnVwdHMgaGVyZS4KPiAKPj4gVGhlcmUgbWF5IGJlIGNhc2VzIHdoZXJlIGludGVycnVw dHMgYXJlIHByZWZlcnJlZC4gVG8gbXkga25vd2xlZGdlIAo+PiAodGhvdWdoIEkgbWF5Cj4+IG1p c3Rha2VuKSwgU0Vycm9ycyB3b3VsZCBub3QgY2F0Y2ggY29ycmVjdGFibGUgZXJyb3JzPwo+IAo+ IFdpdGggdGhlIHY4LjIgUkFTIEV4dGVuc2lvbnMgYm90aCBzeW5jaHJvbm91cyBhbmQgYXN5bmNo cm9ub3VzIAo+IGV4dGVybmFsLWFib3J0cwo+IGhhdmUgYSBzZXZlcml0eSBpbiB0aGUgRVNSIHdo aWNoIHRlbGxzIHVzCj4gY29ycmVjdGVkL3Jlc3RhcnRhYmxlL3JlY292ZXJhYmxlL3VuY29udGFp bmFibGUuCj4gCj4gRXJyb3Igbm9kZXMgbWF5IHNpZ25hbCBhbiAnZXJyb3IgcmVjb3ZlcnkgaW50 ZXJydXB0JyBvciAnZmF0YWwgaGFuZGxpbmcKPiBpbnRlcnJ1cHQnIHdoZW4gdGhlIGluLWJhbmQg ZXh0ZXJuYWwtYWJvcnQgbWVjaGFuaXNtcyBjYW4ndCBiZSB1c2VkLiAKPiAoU2VjdGlvbnMKPiAz LjMgdG8gMy41IG9mIFswXSkuCj4gCj4gCj4+Pj4gKyAgICAgICAgaWYgKGZhaWwgPT0gb2ZfaXJx X2NvdW50KGRldi0+b2Zfbm9kZSkpIHsKPj4+PiArICAgICAgICAgICAgcHJfZXJyKCJFUlA6IENv dWxkIG5vdCByZXF1ZXN0IGFueSBJUlFzLiBHaXZpbmcgCj4+Pj4gdXAuXG4iKTsKPj4+PiArICAg ICAgICAgICAgcmMgPSAtRU5PREVWOwo+Pj4+ICsgICAgICAgICAgICBnb3RvIG91dF9kZXY7Cj4+ Pj4gKyAgICAgICAgfQo+Pj4+ICsgICAgfQo+Pj4+ICsKPj4+PiArICAgIGNwdV9wbV9yZWdpc3Rl cl9ub3RpZmllcigmKGRydi0+bmJfcG0pKTsKPj4+PiArCj4+Pj4gKyAgICByZXR1cm4gMDsKPj4+ PiArCj4+Pj4gK291dF9kZXY6Cj4+Pj4gKyAgICBlZGFjX2RldmljZV9kZWxfZGV2aWNlKGRldik7 Cj4+Pj4gK291dF9tZW06Cj4+Pj4gKyAgICBlZGFjX2RldmljZV9mcmVlX2N0bF9pbmZvKGRydi0+ ZWRldl9jdGwpOwo+Pj4+ICsgICAgcmV0dXJuIHJjOwo+Pj4+ICt9Cj4+Pj4gKwo+Pj4+ICtzdGF0 aWMgaW50IGFybXY4X2NwdV9lcnBfcmVtb3ZlKHN0cnVjdCBwbGF0Zm9ybV9kZXZpY2UgKnBkZXYp Cj4+Pj4gK3sKPj4+PiArICAgIHN0cnVjdCBlcnBfZHJ2ZGF0YSAqZHJ2ID0gZGV2X2dldF9kcnZk YXRhKCZwZGV2LT5kZXYpOwo+Pj4+ICsgICAgc3RydWN0IGVkYWNfZGV2aWNlX2N0bF9pbmZvICpl ZGFjX2N0bCA9IGRydi0+ZWRldl9jdGw7Cj4+Pj4gKwo+Pj4+ICsgICAgaWYgKGRydi0+ZXJwX2Nw dV9kcnZkYXRhKSB7Cj4+Pj4gKyAgICAgICAgZnJlZV9wZXJjcHVfaXJxKGRydi0+cHBpLCBkcnYt PmVycF9jcHVfZHJ2ZGF0YSk7Cj4+Pj4gKyAgICAgICAgZnJlZV9wZXJjcHUoZHJ2LT5lcnBfY3B1 X2RydmRhdGEpOwo+Pj4+ICsgICAgfQo+Pj4+ICsKPj4+PiArICAgIGVkYWNfZGV2aWNlX2RlbF9k ZXZpY2UoZWRhY19jdGwtPmRldik7Cj4+Pj4gKyAgICBlZGFjX2RldmljZV9mcmVlX2N0bF9pbmZv KGVkYWNfY3RsKTsKPj4+PiArCj4+Pj4gKyAgICByZXR1cm4gMDsKPj4+PiArfQo+Pj4+ICsKPj4+ PiArc3RhdGljIGNvbnN0IHN0cnVjdCBvZl9kZXZpY2VfaWQgYXJtdjhfY3B1X2VycF9tYXRjaF90 YWJsZVtdID0gewo+Pj4+ICsgICAgeyAuY29tcGF0aWJsZSA9ICJhcm0sYXJtdjgtY3B1LWVycCIg fSwKPj4+PiArICAgIHsgfQo+Pj4+ICt9Owo+Pj4gCj4+PiBUaGlzIG5lZWRzIGEgYmluZGluZyBk b2N1bWVudCwgbGF5aW5nIG91dCBwcmVjaXNlbHkgd2hhdCB0aGlzIGlzCj4+PiBpbnRlbmRlZCB0 byBkZXNjcmliZS4KPiAKPiAKPiBUaGFua3MsCj4gCj4gSmFtZXMKPiAKSSBzaG91bGQgcHJvYmFi bHkgYW1lbmQgYSBwcmV2aW91cyBzdGF0ZW1lbnQgYWJvdXQgdGhpcyBhbGwgYmVpbmcgCmRlZmlu ZWQgaW4gUkFTLiBEaWRuJ3QgcmVhbGl6ZSB0aGlzIGluaXRpYWxseQpidXQgYXMgeW91IGhhdmUg bWVudGlvbmVkLCBldmVuIHRob3VnaCB0aGUgcmVnaXN0ZXJzIGFyZSBhcmNoaXRlY3RlZCwgCnRo ZSBkZWNvZGluZy9iaXRzIHdpdGhpbiB0aGUgcmVnaXN0ZXJzIGFyZQppbXBsZW1lbnRhdGlvbiBk ZWZpbmVkLiBTbyB3aXRoaW4gdGhlIGRyaXZlciwgc29tZSBvZiB0aGUgIm1hZ2ljYWxseSAKa25v d24iIHZhbHVlcyBhcmUgYmVjYXVzZSBhcyBpdCBpcyByaWdodCBub3csCnRoZSBkZWNvZGluZ3Mg YW5kIHNvbWUgYmVoYXZpb3IgaXMgc3BlY2lmaWMgdG8gb3VyIGltcGxlbWVudGF0aW9uLgoKVG8g bW9yZSBnZW5lcmFsaXplIHRoaXMsIHdvdWxkIGl0IGJlIGJldHRlciB0byAoYWZ0ZXIgY2hlY2tp bmcgdGhlIApJRFIvRlIgcmVnaXN0ZXJzKSB0byBpbnN0ZWFkIGp1c3QgZHVtcCBvdXQgdGhlCkVS UlhTVEFUVVMvRVJSWE1JU0MgZGlyZWN0bHksIGFuZCB0aGVuIGhhdmUgcmVnaXN0ZXJlZCBjYWxs YmFja3MgdG8gCmFjdHVhbGx5IHByb3Blcmx5IGRlY29kZSB0aGUgdmFsdWVzIGludG8Kc29tZXRo aW5nIG1vcmUgcmVhZGFibGU/CgpUaGFua3MsCkt5bGUKLS0tClRvIHVuc3Vic2NyaWJlIGZyb20g dGhpcyBsaXN0OiBzZW5kIHRoZSBsaW5lICJ1bnN1YnNjcmliZSBsaW51eC1lZGFjIiBpbgp0aGUg Ym9keSBvZiBhIG1lc3NhZ2UgdG8gbWFqb3Jkb21vQHZnZXIua2VybmVsLm9yZwpNb3JlIG1ham9y ZG9tbyBpbmZvIGF0ICBodHRwOi8vdmdlci5rZXJuZWwub3JnL21ham9yZG9tby1pbmZvLmh0bWwK From mboxrd@z Thu Jan 1 00:00:00 1970 From: kyan@codeaurora.org (Kyle Yan) Date: Wed, 17 Jan 2018 17:19:47 -0800 Subject: [PATCH v1] EDAC, armv8: Add Cache Error Reporting driver for ARMv8 processors In-Reply-To: <5A5DF9F4.90101@arm.com> References: <1515804626-21254-1-git-send-email-kyan@codeaurora.org> <20180115144441.d6dlwl7herq24byv@lakrids.cambridge.arm.com> <3d3da849d32b1a674d1bcd560eeba261@codeaurora.org> <5A5DF9F4.90101@arm.com> Message-ID: <6c3d84bd102d49aa78591caa5adf7bfc@codeaurora.org> To: linux-arm-kernel@lists.infradead.org List-Id: linux-arm-kernel.lists.infradead.org On 2018-01-16 05:11, James Morse wrote: > Hi Kyle, > > (Thanks for looping me in Mark!) > > On 16/01/18 01:00, Kyle Yan wrote: >> On 2018-01-15 06:44, Mark Rutland wrote: >>> On Fri, Jan 12, 2018 at 04:50:26PM -0800, Kyle Yan wrote: >>>> Interrupt based EDAC driver for ARMv8 processors that implement >>>> RAS for error detection of CPU caches and lso allows optional >>>> polling >>>> of error syndrome registers if interrupts are not supported. >>> >>> Is this using the architectural RAS extensions, or something specific >>> to >>> QC CPUs? It would be good to call this out explicitly. >>> >>> If it's the latter, this needs rewording to be clear that this is >>> specific to QC CPUs, and is not a generic ARMv8 feature. > >> This is not specific to QC CPUs and looks at the system registers >> defined by the >> RAS extensions. > > Excellent, so it should work on the FVP too! > > [...] > > >>> If this is architectural, how is this expected to work on ACPI >>> systems? >>> >> The current design of this driver has only been tested/used on mobile >> devices so >> I do not yet know how it will work on ACPI systems. > > For ACPI systems wanting to do kernel-first I assume there will need to > be some > description of where the mmio RAS nodes are in the address space and > what > interrupts etc they generate. This would be equivalent to the data in > the DT. > > How come you don't read ERRIDR to find out how many nodes are behind > the CPU > interface registers? Surely you have to poll all of them? > > If you're polling this, you must have to poke the system register > every-second > on every-CPU. Wouldn't it be better to use the memory-mapped interface > on one > CPU to do this? > > You aren't touching ERRFR at all, this tells us whether the node(?) > supports > error recovery interrupts, counter formats etc. > > >>>> diff --git a/drivers/edac/Kconfig b/drivers/edac/Kconfig >>>> index 96afb2a..47a68e3 100644 >>>> --- a/drivers/edac/Kconfig >>>> +++ b/drivers/edac/Kconfig >>>> @@ -457,4 +457,25 @@ config EDAC_XGENE >>>> Support for error detection and correction on the >>>> APM X-Gene family of SOCs. >>>> >>>> +config EDAC_ARMV8 >>>> + depends on (ARM || ARM64) > > As you are accessing system registers this should depend on > 'ARM64_RAS_EXTN' > too, and register accesses need to be behind something like > cpus_have_const_cap(ARM64_RAS_EXTN). > > The patch that adds these bits is here: > https://www.spinics.net/lists/arm-kernel/msg628997.html > > (I don't know how cpufeature detection works on 32bit) > > >>>> + tristate "ARMv8 L1/L2/L3/SCU Caches ECC" >>>> + help >>>> + Support for error detection and correction on ARMv8 cores >>>> + supporting RAS features. Reports errors caught by ARMv8 >>>> + ECC mechanism. >>>> + For debugging issues having to do with stability and overall >>>> system >>>> + health, you should probably say 'Y' here. >>>> + >>>> +config EDAC_ARMV8_POLL >>>> + depends on EDAC_ARMV8 >>>> + bool "Poll on ARMv8 ECC registers" >>>> + help >>>> + This option chooses whether or not you want to poll on the >>>> Kryo3xx >>>> + ECC registers. >>> >>> Are these registers specific to Kryo3xx (i.e. IMPLEMENTATION >>> DEFINED), >>> or are they defined by the RAS extensions? >>> >> Oops! Typo here. The registers are defined by RAS extensions. >> >>>> When this is enabled, the polling rate can be set as >>>> + a module parameter. By default, it will call the polling >>>> function >>>> + every second. > > ACPI's firmware-first polling mechanism allows firmware to specify the > polling > rate. How was 'every second' picked? Does it depend on the SoC? > > >>>> + This option should only be used if the associated interrupt >>>> lines >>>> + are not enabled. > > How does the user know? > > >>>> diff --git a/drivers/edac/armv8_edac.c b/drivers/edac/armv8_edac.c >>>> new file mode 100644 >>>> index 0000000..d986c47 >>>> --- /dev/null >>>> +++ b/drivers/edac/armv8_edac.c >>>> @@ -0,0 +1,489 @@ >>>> +/* Copyright (c) 2016-2018, The Linux Foundation. All rights >>>> reserved. >>>> + * >>>> + * This program is free software; you can redistribute it and/or >>>> modify >>>> + * it under the terms of the GNU General Public License version 2 >>>> and >>>> + * only version 2 as published by the Free Software Foundation. >>>> + * >>>> + * This program is distributed in the hope that it will be useful, >>>> + * but WITHOUT ANY WARRANTY; without even the implied warranty of >>>> + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the >>>> + * GNU General Public License for more details. >>>> + */ >>>> + >>>> +#include >>>> +#include >>>> +#include >>>> +#include >>>> +#include >>>> +#include >>>> +#include >>>> +#include >>>> +#include > > (Nit: alphabetical order makes for fewer conflicts in the future) > > >>>> +#include "edac_mc.h" >>>> +#include "edac_device.h" >>>> + >>>> +static int poll_msec = 1000; >>>> +module_param(poll_msec, int, 0444); >>>> + >>>> +static bool panic_on_ue = 0; >>>> +module_param_named(panic_on_ue, panic_on_ue, bool, 0664); >>>> + >>>> +#define L1 0x0 >>>> +#define L2 0x1 >>>> +#define L3 0x2 > >>>> +#define EDAC_CPU "armv8_edac" >>>> + >>>> +#define ERRXSTATUS_VALID(a) ((a >> 30) & 0x1) >>>> +#define ERRXSTATUS_UE(a) ((a >> 29) & 0x1) >>>> +#define ERRXSTATUS_SERR(a) (a & 0xFF) >>>> + >>>> +#define ERRXMISC_LVL(a) ((a >> 1) & 0x7) >>>> +#define ERRXMISC_WAY(a) ((a >> 28) & 0xF) > > Which ERRMISC is this? [0] has two. At first glance these are both > implementation-defined, so we can't rely on the values. > > (MISC0 has some archtitected-layout, it seems we're expected to know > which > layout it will be based on ERRFR - but I can't see 'lvl' or 'way' in > any of > those layouts). > > You don't check ERRSTATUS.MV to know if the 'Miscallaneous Registers > Valid'. > > >>>> +#define ERRXCTLR_ENABLE 0x10f > > This looks like a magic value to set some bits. Could you add defines > to name > each one, then combine so we know what was set. > This register has one of two layouts, it seems each control picks a > layout. How > can we know if the read/write bits are combined or separate? It looks > like this > in ERRFR too. > > >>>> +#define ERRXMISC_OVERFLOW 0x7F7F00000000ULL > > This looks like a magic value written to a register with an impdef > layout. > > [...] > >>>> +static inline void set_errxctlr_el1(void) >>>> +{ >>>> + asm volatile("msr s3_0_c5_c4_1, %0" : : "r" (ERRXCTLR_ENABLE)); >>>> +} > >>> >>> Please use {read,write}_sysreg(). >>> >>> If these registers are defined by ARMv8, please place definitions in >>> arm64's . >>> >> Will do. > > Yes please! > > (The s3_0_c5_c4_1 syntax isn't supported by all toolchains, see > 72c5839515260dc > "arm64: gicv3: Allow GICv3 compilation with older binutils") > > You also need to guard these with something like > cpus_have_const_cap(ARM64_RAS_EXTN) so CPUs without the RAS extensions > don't try > to access an unimplemented system register. Testing once during probe > is > probably the best place to do this. > > >>>> + >>>> +struct errors_edac { >>>> + const char * const msg; >>>> + void (*func)(struct edac_device_ctl_info *edac_dev, >>>> + int inst_nr, int block_nr, const char *msg); >>>> +}; >>>> + >>>> +static const struct errors_edac errors[] = { >>>> + { "L1 Correctable Error", edac_device_handle_ce }, >>>> + { "L1 Uncorrectable Error", edac_device_handle_ue }, >>>> + { "L2 Correctable Error", edac_device_handle_ce }, >>>> + { "L2 Uncorrectable Error", edac_device_handle_ue }, >>>> + { "L3 Correctable Error", edac_device_handle_ce }, >>>> + { "L3 Uncorrectable Error", edac_device_handle_ue }, >>>> +}; >>>> + > >>>> +#define L1_CE 0 >>>> +#define L1_UE 1 >>>> +#define L2_CE 2 >>>> +#define L2_UE 3 >>>> +#define L3_CE 4 >>>> +#define L3_UE 5 > > This are read from ERRMISC, I can't find this in the spec[0], are > these > specific to your implementation? > > >>>> +#define DATA_BUF_ERR 0x2 >>>> +#define CACHE_DATA_ERR 0x6 >>>> +#define CACHE_TAG_DIRTY_ERR 0x7 >>>> +#define TLB_PARITY_ERR_DATA 0x8 >>>> +#define TLB_PARITY_ERR_TAG 0x9 > > (Nit: 'TAG' is the example address/control data that has become > corrupt. We > don't know how the cache is designed, 'metadata' may be a better choice > of word > here). > >>>> +#define BUS_ERROR 0x12 > > There are 21 of these and only 2 are implementation defined. How come > you don't > define all of them? > > All these get used for is to map to a name, would a table be better? > (e.g. arch/arm64/mm/fault.c::fault_info) > > >>>> +struct erp_drvdata { >>>> + struct edac_device_ctl_info *edev_ctl; >>>> + struct erp_drvdata __percpu **erp_cpu_drvdata; >>>> + struct notifier_block nb_pm; >>>> + int ppi; >>>> +}; >>>> + >>>> +static struct erp_drvdata *panic_handler_drvdata; >>>> + >>>> +static DEFINE_SPINLOCK(armv8_edac_lock); >>>> + >>>> +static void l1_l2_irq_enable(void *info) >>>> +{ >>>> + int irq = *(int *)info; >>>> + >>>> + enable_percpu_irq(irq, IRQ_TYPE_LEVEL_HIGH); >>>> +} > > (Shouldn't the 'percpu' and 'level_high' be information learnt from the > DT?) > > >>>> +static int request_erp_irq(struct platform_device *pdev, const char >>>> *propname, >>>> + const char *desc, irq_handler_t handler, >>>> + void *ed, int percpu) >>>> +{ >>>> + int rc; >>>> + struct resource *r; >>>> + struct erp_drvdata *drv = ed; >>>> + >>>> + r = platform_get_resource_byname(pdev, IORESOURCE_IRQ, >>>> propname); >>>> + >>>> + if (!r) { >>>> + pr_err("ARMv8 CPU ERP: Could not find <%s> IRQ property. >>>> Proceeding >>>> anyway.\n", >>>> + propname); >>> >>> What is "ERP" ? > >> Error Reporting. I may just rename it to EDAC or list it out in >> Documentation. > >>>> + goto out; >>>> + } >>>> + >>>> + if (!percpu) { >>>> + rc = devm_request_threaded_irq(&pdev->dev, r->start, NULL, >>>> + handler, >>>> + IRQF_ONESHOT | IRQF_TRIGGER_HIGH, >>>> + desc, >>>> + ed); >>>> + >>>> + if (rc) { >>>> + pr_err("ARMv8 CPU ERP: Failed to request IRQ %d: %d (%s >>>> / %s). >>>> Proceeding anyway.\n", >>>> + (int) r->start, rc, propname, desc); >>>> + goto out; >>>> + } >>>> + >>>> + } else { >>>> + drv->erp_cpu_drvdata = alloc_percpu(struct erp_drvdata *); >>>> + if (!drv->erp_cpu_drvdata) { >>>> + pr_err("Failed to allocate percpu erp data\n"); >>>> + goto out; >>>> + } >>>> + >>>> + *raw_cpu_ptr(drv->erp_cpu_drvdata) = drv; > > raw_cpu_ptr(). You call this from armv8_cpu_erp_probe(), so you're > probably > preemtible. Could you use this_cpu_ptr() and enable > CONFIG_DEBUG_PREEMPT. > > (How come you only set this per-cpu cookie on one cpu?) > > >>>> + rc = request_percpu_irq(r->start, handler, desc, >>>> + drv->erp_cpu_drvdata); >>>> + >>>> + if (rc) { >>>> + pr_err("ARMv8 CPU ERP: Failed to request IRQ %d: %d (%s >>>> / %s). >>>> Proceeding anyway.\n", >>>> + (int) r->start, rc, propname, desc); >>>> + goto out_free; >>>> + } >>>> + >>>> + drv->ppi = r->start; >>>> + on_each_cpu(l1_l2_irq_enable, &(r->start), 1); >>>> + } >>>> + >>>> + return 0; >>>> + >>>> +out_free: >>>> + free_percpu(drv->erp_cpu_drvdata); >>>> + drv->erp_cpu_drvdata = NULL; >>>> +out: >>>> + return 1; >>>> +} >>>> + >>>> +static void dump_err_reg(int errorcode, int level, u64 errxstatus, >>>> u64 >>>> errxmisc, >>>> + struct edac_device_ctl_info *edev_ctl) >>>> +{ >>>> + edac_printk(KERN_CRIT, EDAC_CPU, "ERRXSTATUS_EL1: %llx\n", >>>> errxstatus); >>>> + edac_printk(KERN_CRIT, EDAC_CPU, "ERRXMISC_EL1: %llx\n", >>>> errxmisc); >>>> + edac_printk(KERN_CRIT, EDAC_CPU, "Cache level: L%d\n", >>>> level+1); >>>> + switch (ERRXSTATUS_SERR(errxstatus)) { >>>> + case DATA_BUF_ERR: >>>> + edac_printk(KERN_CRIT, EDAC_CPU, "ECC Error from internal >>>> data >>>> buffer\n"); >>>> + break; >>>> + >>>> + case CACHE_DATA_ERR: >>>> + edac_printk(KERN_CRIT, EDAC_CPU, "ECC Error from cache data >>>> RAM\n"); >>>> + break; >>>> + >>>> + case CACHE_TAG_DIRTY_ERR: >>>> + edac_printk(KERN_CRIT, EDAC_CPU, "ECC Error from cache tag >>>> or dirty >>>> RAM\n"); >>>> + break; >>>> + >>>> + case TLB_PARITY_ERR_DATA: >>>> + edac_printk(KERN_CRIT, EDAC_CPU, "Parity error on TLB DATA >>>> RAM\n"); >>>> + break; >>>> + >>>> + case TLB_PARITY_ERR_TAG: >>>> + edac_printk(KERN_CRIT, EDAC_CPU, "Parity error on TLB TAG >>>> RAM\n"); >>>> + break; >>>> + >>>> + case BUS_ERROR: >>>> + edac_printk(KERN_CRIT, EDAC_CPU, "Bus Error\n"); >>>> + break; >>>> + } > >>>> + if (level == L3) >>>> + edac_printk(KERN_CRIT, EDAC_CPU, >>>> + "Way: %d\n", (int) ERRXMISC_WAY(errxmisc)); >>>> + else >>>> + edac_printk(KERN_CRIT, EDAC_CPU, >>>> + "Way: %d\n", (int) ERRXMISC_WAY(errxmisc) >> 2); >>>> + >>>> + edev_ctl->panic_on_ue = panic_on_ue; >>>> + errors[errorcode].func(edev_ctl, smp_processor_id(), >>>> + level, errors[errorcode].msg); >>>> +} >>>> + >>>> +static void armv8_parse_l1_l2_cache_error(u64 errxstatus, u64 >>>> errxmisc, >>>> + struct edac_device_ctl_info *edev_ctl) >>>> +{ >>>> + switch (ERRXMISC_LVL(errxmisc)) { >>>> + case L1: >>>> + if (ERRXSTATUS_UE(errxstatus)) >>>> + dump_err_reg(L1_UE, L1, errxstatus, errxmisc, >>>> + edev_ctl); >>>> + else >>>> + dump_err_reg(L1_CE, L1, errxstatus, errxmisc, >>>> + edev_ctl); > > If the UE bit is clear the error may have been 'corrected or deferred'. > I guess > we assume deferred errors don't happen, so !UE means Corrected-Error. > > >>>> + break; >>>> + case L2: >>>> + if (ERRXSTATUS_UE(errxstatus)) >>>> + dump_err_reg(L2_UE, L2, errxstatus, errxmisc, >>>> + edev_ctl); >>>> + else >>>> + dump_err_reg(L2_CE, L2, errxstatus, errxmisc, >>>> + edev_ctl); >>>> + break; >>>> + default: >>>> + edac_printk(KERN_CRIT, EDAC_CPU, "Unknown ERRXMISC_LVL >>>> value\n"); >>>> + } >>>> +} >>>> + >>>> +static bool armv8_check_l1_l2_ecc(void *info) >>>> +{ >>>> + struct edac_device_ctl_info *edev_ctl = info; >>>> + u64 errxstatus; >>>> + u64 errxmisc; >>>> + unsigned long flags; >>>> + >>>> + spin_lock_irqsave(&armv8_edac_lock, flags); > >>>> + write_errselr_el1(0); > > How do we know how many nodes backed by the cpu interface there are? > How do we know '0' is the one we want? > >>>> + errxstatus = read_errxstatus_el1(); >>>> + >>>> + if (ERRXSTATUS_VALID(errxstatus)) { >>>> + errxmisc = read_errxmisc_el1(); >>>> + edac_printk(KERN_CRIT, EDAC_CPU, >>>> + "CPU%d detected a L1/L2 cache error\n", >>>> + smp_processor_id()); >>>> + >>>> + armv8_parse_l1_l2_cache_error(errxstatus, errxmisc, >>>> edev_ctl); >>>> + clear_errxstatus_valid(errxstatus); >>>> + spin_unlock_irqrestore(&armv8_edac_lock, flags); >>>> + return true; >>>> + } >>>> + spin_unlock_irqrestore(&armv8_edac_lock, flags); >>>> + return false; >>>> +} >>>> + >>>> +static bool armv8_check_l3_scu_error(struct edac_device_ctl_info >>>> *edev_ctl) >>>> +{ >>>> + u64 errxstatus = 0; >>>> + u64 errxmisc = 0; >>>> + unsigned long flags; >>>> + >>>> + spin_lock_irqsave(&armv8_edac_lock, flags); > >>>> + write_errselr_el1(1); > > How do we know '1' is the one we want? > > >>>> + errxstatus = read_errxstatus_el1(); >>>> + errxmisc = read_errxmisc_el1(); >>>> + >>>> + if (ERRXSTATUS_VALID(errxstatus) && >>>> + ERRXMISC_LVL(errxmisc) == L3) { >>>> + if (ERRXSTATUS_UE(errxstatus)) { >>>> + edac_printk(KERN_CRIT, EDAC_CPU, "Detected L3 >>>> uncorrectable >>>> error\n"); >>>> + dump_err_reg(L3_UE, L3, errxstatus, errxmisc, >>>> + edev_ctl); >>>> + } else { >>>> + edac_printk(KERN_CRIT, EDAC_CPU, "Detected L3 >>>> correctable >>>> error\n"); >>>> + dump_err_reg(L3_CE, L3, errxstatus, errxmisc, >>>> + edev_ctl); > > What about deferred errors? > > >>>> + } >>>> + >>>> + clear_errxstatus_valid(errxstatus); >>>> + spin_unlock_irqrestore(&armv8_edac_lock, flags); >>>> + return true; >>>> + } >>>> + spin_unlock_irqrestore(&armv8_edac_lock, flags); >>>> + return false; >>>> +} >>>> + >>>> +static void armv8_check_l1_l2_ecc_helper(void *info) >>>> +{ >>>> + armv8_check_l1_l2_ecc(info); >>>> +} >>>> + >>>> +void armv8_poll_cache_errors(struct edac_device_ctl_info *edev_ctl) >>>> +{ >>>> + int cpu; >>>> + >>>> + if (!edev_ctl) >>>> + edev_ctl = panic_handler_drvdata->edev_ctl; >>>> + >>>> + armv8_check_l3_scu_error(edev_ctl); >>>> + for_each_possible_cpu(cpu) { >>>> + smp_call_function_single(cpu, armv8_check_l1_l2_ecc_helper, >>>> + edev_ctl, 0); > > on_each_cpu()? > >>>> + } >>>> +} >>>> + >>>> +static irqreturn_t armv8_l1_l2_handler(int irq, void *drvdata) >>>> +{ >>>> + if (armv8_check_l1_l2_ecc(panic_handler_drvdata->edev_ctl)) >>>> + return IRQ_HANDLED; >>>> + return IRQ_NONE; >>>> +} >>>> + >>>> +static irqreturn_t armv8_l3_scu_handler(int irq, void *drvdata) >>>> +{ >>>> + struct erp_drvdata *drv = drvdata; >>>> + struct edac_device_ctl_info *edev_ctl = drv->edev_ctl; >>>> + >>>> + if (armv8_check_l3_scu_error(edev_ctl)) >>>> + return IRQ_HANDLED; >>>> + return IRQ_NONE; >>>> +} >>>> + >>>> +static void initialize_registers(void *info) >>>> +{ >>>> + set_errxctlr_el1(); >>>> + set_errxmisc_overflow(); >>>> +} >>>> + >>>> +static void init_regs_on_cpu(bool all_cpus) >>>> +{ >>>> + int cpu; >>>> + >>>> + write_errselr_el1(0); > > This only happens on the local CPU, the other end of your > smp_call_function_single() may have junk in this register. > > >>>> + if (all_cpus) { >>>> + for_each_possible_cpu(cpu) >>>> + smp_call_function_single(cpu, initialize_registers, >>>> + NULL, 1); > > on_each_cpu()? > > >>>> + } else { >>>> + initialize_registers(NULL); >>>> + } >>>> + >>>> + write_errselr_el1(1); >>>> + initialize_registers(NULL); > > You seem to magically-know that this 'record 1' is shared between all > CPUs and > visible via the cpu interface. > Yes this portion (and coming to the realization that a lot of other parts) of the code is specific to our topology. Is there any way to detect this? ERRIDR reports how many records there are but not what each record is for. Without this information, not sure how there could be a generic interrupt based driver. > >>>> +} >>>> + >>>> +static int armv8_pmu_cpu_pm_notify(struct notifier_block *self, >>>> + unsigned long action, void *v) >>>> +{ >>>> + switch (action) { >>>> + case CPU_PM_EXIT: >>>> + init_regs_on_cpu(false); >>>> + armv8_check_l3_scu_error(panic_handler_drvdata->edev_ctl); >>>> + armv8_check_l1_l2_ecc(panic_handler_drvdata->edev_ctl); >>>> + break; >>>> + } >>>> + >>>> + return NOTIFY_OK; >>>> +} >>> >>> What about CPU hotplug? >>> >> Agreed that CPU hotplug will be required for the small window between >> hotplugging back in and LPM exit. >> >>>> + >>>> +static int armv8_cpu_erp_probe(struct platform_device *pdev) >>>> +{ >>>> + struct device *dev = &pdev->dev; >>>> + struct erp_drvdata *drv; >>>> + int rc = 0; >>>> + int fail = 0; >>>> + >>>> + init_regs_on_cpu(true); >>>> + >>>> + drv = devm_kzalloc(dev, sizeof(*drv), GFP_KERNEL); >>>> + >>>> + if (!drv) >>>> + return -ENOMEM; >>>> + >>>> + drv->edev_ctl = edac_device_alloc_ctl_info(0, "cpu", >>>> + num_possible_cpus(), "L", 3, 1, NULL, 0, >>>> + edac_device_alloc_index()); >>>> + >>>> + if (!drv->edev_ctl) >>>> + return -ENOMEM; >>>> + >>>> + if (IS_ENABLED(CONFIG_EDAC_ARMV8_POLL)) { >>>> + drv->edev_ctl->edac_check = armv8_poll_cache_errors; >>>> + drv->edev_ctl->poll_msec = poll_msec; >>>> + } >>>> + >>>> + drv->edev_ctl->dev = dev; >>>> + drv->edev_ctl->mod_name = dev_name(dev); >>>> + drv->edev_ctl->dev_name = dev_name(dev); > >>>> + drv->edev_ctl->ctl_name = "cache"; > > How do we know records '0' and '1' are 'cache'? > > >>>> + drv->edev_ctl->panic_on_ue = panic_on_ue; >>>> + drv->nb_pm.notifier_call = armv8_pmu_cpu_pm_notify; >>>> + platform_set_drvdata(pdev, drv); >>>> + >>>> + rc = edac_device_add_device(drv->edev_ctl); >>>> + if (rc) >>>> + goto out_mem; >>>> + >>>> + panic_handler_drvdata = drv; >>>> + >>>> + if (!IS_ENABLED(CONFIG_EDAC_ARMV8_POLL)) { >>>> + fail += request_erp_irq(pdev, "l1-l2-irq", >>>> + "l1_l2_irq", >>>> + armv8_l1_l2_handler, drv, 1); >>>> + >>>> + fail += request_erp_irq(pdev, "l3-scu-irq", >>>> + "l3_scu_irq", >>>> + armv8_l3_scu_handler, drv, 0); > > How do we know 'l1/l2' is per-cpu and l2 isn't? I'd expect this > information to > come from the DT. > > >>> SCU isn't an architectural concept, and a combined l1-l2 interrupt >>> sounds very specific to a particular implementation. > >> Can do a rename to something more akin to "private_cache_irq" and >> "shared_cache_irq". > >>> My understanding was that with the RAS extensions, SError would be >>> used >>> to notify on RAS conditions, so I'm confused as to why we'd need >>> regular interrupts here. > >> There may be cases where interrupts are preferred. To my knowledge >> (though I may >> mistaken), SErrors would not catch correctable errors? > > With the v8.2 RAS Extensions both synchronous and asynchronous > external-aborts > have a severity in the ESR which tells us > corrected/restartable/recoverable/uncontainable. > > Error nodes may signal an 'error recovery interrupt' or 'fatal handling > interrupt' when the in-band external-abort mechanisms can't be used. > (Sections > 3.3 to 3.5 of [0]). > > >>>> + if (fail == of_irq_count(dev->of_node)) { >>>> + pr_err("ERP: Could not request any IRQs. Giving >>>> up.\n"); >>>> + rc = -ENODEV; >>>> + goto out_dev; >>>> + } >>>> + } >>>> + >>>> + cpu_pm_register_notifier(&(drv->nb_pm)); >>>> + >>>> + return 0; >>>> + >>>> +out_dev: >>>> + edac_device_del_device(dev); >>>> +out_mem: >>>> + edac_device_free_ctl_info(drv->edev_ctl); >>>> + return rc; >>>> +} >>>> + >>>> +static int armv8_cpu_erp_remove(struct platform_device *pdev) >>>> +{ >>>> + struct erp_drvdata *drv = dev_get_drvdata(&pdev->dev); >>>> + struct edac_device_ctl_info *edac_ctl = drv->edev_ctl; >>>> + >>>> + if (drv->erp_cpu_drvdata) { >>>> + free_percpu_irq(drv->ppi, drv->erp_cpu_drvdata); >>>> + free_percpu(drv->erp_cpu_drvdata); >>>> + } >>>> + >>>> + edac_device_del_device(edac_ctl->dev); >>>> + edac_device_free_ctl_info(edac_ctl); >>>> + >>>> + return 0; >>>> +} >>>> + >>>> +static const struct of_device_id armv8_cpu_erp_match_table[] = { >>>> + { .compatible = "arm,armv8-cpu-erp" }, >>>> + { } >>>> +}; >>> >>> This needs a binding document, laying out precisely what this is >>> intended to describe. > > > Thanks, > > James > I should probably amend a previous statement about this all being defined in RAS. Didn't realize this initially but as you have mentioned, even though the registers are architected, the decoding/bits within the registers are implementation defined. So within the driver, some of the "magically known" values are because as it is right now, the decodings and some behavior is specific to our implementation. To more generalize this, would it be better to (after checking the IDR/FR registers) to instead just dump out the ERRXSTATUS/ERRXMISC directly, and then have registered callbacks to actually properly decode the values into something more readable? Thanks, Kyle