From mboxrd@z Thu Jan 1 00:00:00 1970 From: Borislav Petkov Subject: Re: [PATCH v2 4/7] ghes_edac: avoid multiple calls to dmi_walk() Date: Mon, 21 Aug 2017 11:29:32 +0200 Message-ID: <20170821092932.vlyhg7ckfigpc26n@pd.tnic> References: <20170814203942.6t3mrq3hc324blab@pd.tnic> <1502810766.2042.149.camel@hpe.com> <20170815154815.wy3dqwb4yi3feahg@intel.com> <20170816082931.p6rpvtlxwt5nccxr@pd.tnic> <1502896578.2042.155.camel@hpe.com> <20170816164234.mgwapenb7fpym6nk@pd.tnic> <1502903940.2042.157.camel@hpe.com> <20170816174028.dqfvubjigvwtcbcy@pd.tnic> <1502905904.2042.159.camel@hpe.com> <1503003532.2042.161.camel@hpe.com> Mime-Version: 1.0 Content-Type: text/plain; charset=utf-8 Content-Transfer-Encoding: 8bit Return-path: Content-Disposition: inline In-Reply-To: <1503003532.2042.161.camel@hpe.com> Sender: linux-kernel-owner@vger.kernel.org To: "Kani, Toshimitsu" , "mchehab@kernel.org" Cc: "linux-kernel@vger.kernel.org" , "rostedt@goodmis.org" , "rjw@rjwysocki.net" , "tony.luck@intel.com" , "lenb@kernel.org" , "linux-acpi@vger.kernel.org" , "linux-edac@vger.kernel.org" List-Id: linux-acpi@vger.kernel.org On Thu, Aug 17, 2017 at 09:08:40PM +0000, Kani, Toshimitsu wrote: > 1. It creates mc0 and mc1.   > I think this is because you called edac_mc_alloc() with mc_num 1. Fixed, see below. > > 2. 'ras-mc-ctl --layout' does not show all DIMMs. Yap, that's strange. $ grep . /sys/devices/system/edac/mc/mc0/dimm*/size /sys/devices/system/edac/mc/mc0/dimm10/size:2048 /sys/devices/system/edac/mc/mc0/dimm11/size:2048 /sys/devices/system/edac/mc/mc0/dimm12/size:2048 /sys/devices/system/edac/mc/mc0/dimm13/size:2048 /sys/devices/system/edac/mc/mc0/dimm14/size:2048 /sys/devices/system/edac/mc/mc0/dimm15/size:2048 /sys/devices/system/edac/mc/mc0/dimm8/size:2048 /sys/devices/system/edac/mc/mc0/dimm9/size:2048 $ ras-mc-ctl --layout +-----------+ | mc0 | ---------+-----------+ memory9: | 2048 MB | memory8: | 2048 MB | ---------+-----------+ memory7: | 0 MB | memory6: | 0 MB | ---------+-----------+ memory5: | 0 MB | memory4: | 0 MB | ---------+-----------+ memory3: | 0 MB | memory2: | 0 MB | ---------+-----------+ memory1: | 0 MB | memory0: | 0 MB | ---------+-----------+ the driver detects them correctly though: [ 7.900694] ghes_edac: This system has 16 DIMM sockets. [ 7.911366] EDAC DEBUG: ghes_edac_dmidecode: DIMM8: Unbuffered DDR3 RAM size = 2048 MB(ECC) [ 7.928437] EDAC DEBUG: ghes_edac_dmidecode: type 24, detail 0x80, width 72(total 64) [ 7.944628] EDAC DEBUG: ghes_edac_dmidecode: DIMM9: Unbuffered DDR3 RAM size = 2048 MB(ECC) [ 7.961683] EDAC DEBUG: ghes_edac_dmidecode: type 24, detail 0x80, width 72(total 64) [ 7.977871] EDAC DEBUG: ghes_edac_dmidecode: DIMM10: Unbuffered DDR3 RAM size = 2048 MB(ECC) [ 7.995105] EDAC DEBUG: ghes_edac_dmidecode: type 24, detail 0x80, width 72(total 64) [ 8.011291] EDAC DEBUG: ghes_edac_dmidecode: DIMM11: Unbuffered DDR3 RAM size = 2048 MB(ECC) [ 8.028524] EDAC DEBUG: ghes_edac_dmidecode: type 24, detail 0x80, width 72(total 64) [ 8.044712] EDAC DEBUG: ghes_edac_dmidecode: DIMM12: Unbuffered DDR3 RAM size = 2048 MB(ECC) [ 8.061942] EDAC DEBUG: ghes_edac_dmidecode: type 24, detail 0x80, width 72(total 64) [ 8.078129] EDAC DEBUG: ghes_edac_dmidecode: DIMM13: Unbuffered DDR3 RAM size = 2048 MB(ECC) [ 8.095360] EDAC DEBUG: ghes_edac_dmidecode: type 24, detail 0x80, width 72(total 64) [ 8.111547] EDAC DEBUG: ghes_edac_dmidecode: DIMM14: Unbuffered DDR3 RAM size = 2048 MB(ECC) [ 8.161703] EDAC DEBUG: ghes_edac_dmidecode: type 24, detail 0x80, width 72(total 64) [ 8.177904] EDAC DEBUG: ghes_edac_dmidecode: DIMM15: Unbuffered DDR3 RAM size = 2048 MB(ECC) [ 8.195132] EDAC DEBUG: ghes_edac_dmidecode: type 24, detail 0x80, width 72(total 64) [ 8.211321] EDAC DEBUG: edac_mc_add_mc_with_groups: [ 8.221456] EDAC DEBUG: edac_create_sysfs_mci_device: creating bus mc0 [ 8.234736] EDAC DEBUG: edac_create_sysfs_mci_device: creating device mc0 [ 8.248545] EDAC DEBUG: edac_create_sysfs_mci_device: creating dimm8, located at memory 8 [ 8.265457] EDAC DEBUG: edac_create_dimm_object: creating rank/dimm device dimm8 [ 8.280601] EDAC DEBUG: edac_create_sysfs_mci_device: creating dimm9, located at memory 9 [ 8.297503] EDAC DEBUG: edac_create_dimm_object: creating rank/dimm device dimm9 [ 8.312650] EDAC DEBUG: edac_create_sysfs_mci_device: creating dimm10, located at memory 10 [ 8.329900] EDAC DEBUG: edac_create_dimm_object: creating rank/dimm device dimm10 [ 8.345220] EDAC DEBUG: edac_create_sysfs_mci_device: creating dimm11, located at memory 11 [ 8.362470] EDAC DEBUG: edac_create_dimm_object: creating rank/dimm device dimm11 [ 8.377789] EDAC DEBUG: edac_create_sysfs_mci_device: creating dimm12, located at memory 12 [ 8.395039] EDAC DEBUG: edac_create_dimm_object: creating rank/dimm device dimm12 [ 8.410358] EDAC DEBUG: edac_create_sysfs_mci_device: creating dimm13, located at memory 13 [ 8.427608] EDAC DEBUG: edac_create_dimm_object: creating rank/dimm device dimm13 [ 8.442928] EDAC DEBUG: edac_create_sysfs_mci_device: creating dimm14, located at memory 14 [ 8.460194] EDAC DEBUG: edac_create_dimm_object: creating rank/dimm device dimm14 [ 8.475517] EDAC DEBUG: edac_create_sysfs_mci_device: creating dimm15, located at memory 15 [ 8.492768] EDAC DEBUG: edac_create_dimm_object: creating rank/dimm device dimm15 Mauro? --- From: Borislav Petkov Date: Wed, 16 Aug 2017 10:33:44 +0200 Subject: [PATCH] EDAC, ghes: Model a single, logical memory controller We're enumerating the DIMMs through a DMI walk and since we can't get any more detailed topological information about which DIMMs belong to which memory controller, convert it to a single, logical controller which contains all the DIMMs. The error reporting path from GHES ghes_edac_report_mem_error() doesn't get called in NMI context but add a warning about it to catch any changes in the future as if so, our locking scheme will be insufficient then. Signed-off-by: Borislav Petkov --- drivers/edac/ghes_edac.c | 116 +++++++++++++++++++++-------------------------- 1 file changed, 51 insertions(+), 65 deletions(-) diff --git a/drivers/edac/ghes_edac.c b/drivers/edac/ghes_edac.c index 6f80eb65c26c..e790d64b8edd 100644 --- a/drivers/edac/ghes_edac.c +++ b/drivers/edac/ghes_edac.c @@ -28,10 +28,15 @@ struct ghes_edac_pvt { char msg[80]; }; -static LIST_HEAD(ghes_reglist); -static DEFINE_MUTEX(ghes_edac_lock); -static int ghes_edac_mc_num; +static atomic_t ghes_init = ATOMIC_INIT(0); +static struct ghes_edac_pvt *ghes_pvt; +/* + * Sync with other, potentially concurrent callers of + * ghes_edac_report_mem_error(). We don't know what the + * "inventive" firmware would do. + */ +static DEFINE_SPINLOCK(ghes_lock); /* Memory Device - Type 17 of SMBIOS spec */ struct memdev_dmi_entry { @@ -169,18 +174,26 @@ void ghes_edac_report_mem_error(struct ghes *ghes, int sev, enum hw_event_mc_err_type type; struct edac_raw_error_desc *e; struct mem_ctl_info *mci; - struct ghes_edac_pvt *pvt = NULL; + struct ghes_edac_pvt *pvt = ghes_pvt; + unsigned long flags; char *p; u8 grain_bits; - list_for_each_entry(pvt, &ghes_reglist, list) { - if (ghes == pvt->ghes) - break; - } if (!pvt) { pr_err("Internal error: Can't find EDAC structure\n"); return; } + + /* + * We can do the locking below because GHES defers error processing + * from NMI to IRQ context. Whenever that changes, we'd at least + * know. + */ + if (WARN_ON_ONCE(in_nmi())) + return; + + spin_lock_irqsave(&ghes_lock, flags); + mci = pvt->mci; e = &mci->error_desc; @@ -398,8 +411,8 @@ void ghes_edac_report_mem_error(struct ghes *ghes, int sev, (e->page_frame_number << PAGE_SHIFT) | e->offset_in_page, grain_bits, e->syndrome, pvt->detail_location); - /* Report the error via EDAC API */ edac_raw_mc_handle_error(type, mci, e); + spin_unlock_irqrestore(&ghes_lock, flags); } EXPORT_SYMBOL_GPL(ghes_edac_report_mem_error); @@ -409,9 +422,14 @@ int ghes_edac_register(struct ghes *ghes, struct device *dev) int rc, num_dimm = 0; struct mem_ctl_info *mci; struct edac_mc_layer layers[1]; - struct ghes_edac_pvt *pvt; struct ghes_edac_dimm_fill dimm_fill; + /* + * We have only one logical memory controller to which all DIMMs belong. + */ + if (atomic_inc_return(&ghes_init) > 1) + return 0; + /* Get the number of DIMMs */ dmi_walk(ghes_edac_count_dimms, &num_dimm); @@ -425,26 +443,17 @@ int ghes_edac_register(struct ghes *ghes, struct device *dev) layers[0].size = num_dimm; layers[0].is_virt_csrow = true; - /* - * We need to serialize edac_mc_alloc() and edac_mc_add_mc(), - * to avoid duplicated memory controller numbers - */ - mutex_lock(&ghes_edac_lock); - mci = edac_mc_alloc(ghes_edac_mc_num, ARRAY_SIZE(layers), layers, - sizeof(*pvt)); + mci = edac_mc_alloc(0, ARRAY_SIZE(layers), layers, sizeof(struct ghes_edac_pvt)); if (!mci) { pr_info("Can't allocate memory for EDAC data\n"); - mutex_unlock(&ghes_edac_lock); return -ENOMEM; } - pvt = mci->pvt_info; - memset(pvt, 0, sizeof(*pvt)); - list_add_tail(&pvt->list, &ghes_reglist); - pvt->ghes = ghes; - pvt->mci = mci; - mci->pdev = dev; + ghes_pvt = mci->pvt_info; + ghes_pvt->ghes = ghes; + ghes_pvt->mci = mci; + mci->pdev = dev; mci->mtype_cap = MEM_FLAG_EMPTY; mci->edac_ctl_cap = EDAC_FLAG_NONE; mci->edac_cap = EDAC_FLAG_NONE; @@ -452,36 +461,23 @@ int ghes_edac_register(struct ghes *ghes, struct device *dev) mci->ctl_name = "ghes_edac"; mci->dev_name = "ghes"; - if (!ghes_edac_mc_num) { - if (!fake) { - pr_info("This EDAC driver relies on BIOS to enumerate memory and get error reports.\n"); - pr_info("Unfortunately, not all BIOSes reflect the memory layout correctly.\n"); - pr_info("So, the end result of using this driver varies from vendor to vendor.\n"); - pr_info("If you find incorrect reports, please contact your hardware vendor\n"); - pr_info("to correct its BIOS.\n"); - pr_info("This system has %d DIMM sockets.\n", - num_dimm); - } else { - pr_info("This system has a very crappy BIOS: It doesn't even list the DIMMS.\n"); - pr_info("Its SMBIOS info is wrong. It is doubtful that the error report would\n"); - pr_info("work on such system. Use this driver with caution\n"); - } + if (!fake) { + pr_info("This EDAC driver relies on BIOS to enumerate memory and get error reports.\n"); + pr_info("Unfortunately, not all BIOSes reflect the memory layout correctly.\n"); + pr_info("So, the end result of using this driver varies from vendor to vendor.\n"); + pr_info("If you find incorrect reports, please contact your hardware vendor\n"); + pr_info("to correct its BIOS.\n"); + pr_info("This system has %d DIMM sockets.\n", num_dimm); + } else { + pr_info("This system has a very crappy BIOS: It doesn't even list the DIMMS.\n"); + pr_info("Its SMBIOS info is wrong. It is doubtful that the error report would\n"); + pr_info("work on such system. Use this driver with caution\n"); } if (!fake) { - /* - * Fill DIMM info from DMI for the memory controller #0 - * - * Keep it in blank for the other memory controllers, as - * there's no reliable way to properly credit each DIMM to - * the memory controller, as different BIOSes fill the - * DMI bank location fields on different ways - */ - if (!ghes_edac_mc_num) { - dimm_fill.count = 0; - dimm_fill.mci = mci; - dmi_walk(ghes_edac_dmidecode, &dimm_fill); - } + dimm_fill.count = 0; + dimm_fill.mci = mci; + dmi_walk(ghes_edac_dmidecode, &dimm_fill); } else { struct dimm_info *dimm = EDAC_DIMM_PTR(mci->layers, mci->dimms, mci->n_layers, 0, 0, 0); @@ -497,12 +493,8 @@ int ghes_edac_register(struct ghes *ghes, struct device *dev) if (rc < 0) { pr_info("Can't register at EDAC core\n"); edac_mc_free(mci); - mutex_unlock(&ghes_edac_lock); return -ENODEV; } - - ghes_edac_mc_num++; - mutex_unlock(&ghes_edac_lock); return 0; } EXPORT_SYMBOL_GPL(ghes_edac_register); @@ -510,15 +502,9 @@ EXPORT_SYMBOL_GPL(ghes_edac_register); void ghes_edac_unregister(struct ghes *ghes) { struct mem_ctl_info *mci; - struct ghes_edac_pvt *pvt, *tmp; - - list_for_each_entry_safe(pvt, tmp, &ghes_reglist, list) { - if (ghes == pvt->ghes) { - mci = pvt->mci; - edac_mc_del_mc(mci->pdev); - edac_mc_free(mci); - list_del(&pvt->list); - } - } + + mci = ghes_pvt->mci; + edac_mc_del_mc(mci->pdev); + edac_mc_free(mci); } EXPORT_SYMBOL_GPL(ghes_edac_unregister); -- 2.13.0 -- Regards/Gruss, Boris. Good mailing practices for 400: avoid top-posting and trim the reply. 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: [v2,4/7] ghes_edac: avoid multiple calls to dmi_walk() From: Borislav Petkov Message-Id: <20170821092932.vlyhg7ckfigpc26n@pd.tnic> Date: Mon, 21 Aug 2017 11:29:32 +0200 To: "Kani, Toshimitsu" , "mchehab@kernel.org" Cc: "linux-kernel@vger.kernel.org" , "rostedt@goodmis.org" , "rjw@rjwysocki.net" , "tony.luck@intel.com" , "lenb@kernel.org" , "linux-acpi@vger.kernel.org" , "linux-edac@vger.kernel.org" List-ID: T24gVGh1LCBBdWcgMTcsIDIwMTcgYXQgMDk6MDg6NDBQTSArMDAwMCwgS2FuaSwgVG9zaGltaXRz dSB3cm90ZToKPiAxLiBJdCBjcmVhdGVzIG1jMCBhbmQgbWMxLiDCoAo+IEkgdGhpbmsgdGhpcyBp cyBiZWNhdXNlIHlvdSBjYWxsZWQgZWRhY19tY19hbGxvYygpIHdpdGggbWNfbnVtIDEuCgpGaXhl ZCwgc2VlIGJlbG93LgoKPiAKPiAyLiAncmFzLW1jLWN0bCAtLWxheW91dCcgZG9lcyBub3Qgc2hv dyBhbGwgRElNTXMuCgpZYXAsIHRoYXQncyBzdHJhbmdlLgoKJCBncmVwIC4gL3N5cy9kZXZpY2Vz L3N5c3RlbS9lZGFjL21jL21jMC9kaW1tKi9zaXplCi9zeXMvZGV2aWNlcy9zeXN0ZW0vZWRhYy9t Yy9tYzAvZGltbTEwL3NpemU6MjA0OAovc3lzL2RldmljZXMvc3lzdGVtL2VkYWMvbWMvbWMwL2Rp bW0xMS9zaXplOjIwNDgKL3N5cy9kZXZpY2VzL3N5c3RlbS9lZGFjL21jL21jMC9kaW1tMTIvc2l6 ZToyMDQ4Ci9zeXMvZGV2aWNlcy9zeXN0ZW0vZWRhYy9tYy9tYzAvZGltbTEzL3NpemU6MjA0OAov c3lzL2RldmljZXMvc3lzdGVtL2VkYWMvbWMvbWMwL2RpbW0xNC9zaXplOjIwNDgKL3N5cy9kZXZp Y2VzL3N5c3RlbS9lZGFjL21jL21jMC9kaW1tMTUvc2l6ZToyMDQ4Ci9zeXMvZGV2aWNlcy9zeXN0 ZW0vZWRhYy9tYy9tYzAvZGltbTgvc2l6ZToyMDQ4Ci9zeXMvZGV2aWNlcy9zeXN0ZW0vZWRhYy9t Yy9tYzAvZGltbTkvc2l6ZToyMDQ4CiQgcmFzLW1jLWN0bCAtLWxheW91dAogICAgICAgICArLS0t LS0tLS0tLS0rCiAgICAgICAgIHwgICAgbWMwICAgIHwKLS0tLS0tLS0tKy0tLS0tLS0tLS0tKwpt ZW1vcnk5OiB8ICAyMDQ4IE1CICB8Cm1lbW9yeTg6IHwgIDIwNDggTUIgIHwKLS0tLS0tLS0tKy0t LS0tLS0tLS0tKwptZW1vcnk3OiB8ICAgICAwIE1CICB8Cm1lbW9yeTY6IHwgICAgIDAgTUIgIHwK LS0tLS0tLS0tKy0tLS0tLS0tLS0tKwptZW1vcnk1OiB8ICAgICAwIE1CICB8Cm1lbW9yeTQ6IHwg ICAgIDAgTUIgIHwKLS0tLS0tLS0tKy0tLS0tLS0tLS0tKwptZW1vcnkzOiB8ICAgICAwIE1CICB8 Cm1lbW9yeTI6IHwgICAgIDAgTUIgIHwKLS0tLS0tLS0tKy0tLS0tLS0tLS0tKwptZW1vcnkxOiB8 ICAgICAwIE1CICB8Cm1lbW9yeTA6IHwgICAgIDAgTUIgIHwKLS0tLS0tLS0tKy0tLS0tLS0tLS0t KwoKdGhlIGRyaXZlciBkZXRlY3RzIHRoZW0gY29ycmVjdGx5IHRob3VnaDoKClsgICAgNy45MDA2 OTRdIGdoZXNfZWRhYzogVGhpcyBzeXN0ZW0gaGFzIDE2IERJTU0gc29ja2V0cy4KWyAgICA3Ljkx MTM2Nl0gRURBQyBERUJVRzogZ2hlc19lZGFjX2RtaWRlY29kZTogRElNTTg6IFVuYnVmZmVyZWQg RERSMyBSQU0gc2l6ZSA9IDIwNDggTUIoRUNDKQpbICAgIDcuOTI4NDM3XSBFREFDIERFQlVHOiBn aGVzX2VkYWNfZG1pZGVjb2RlOiAgICAgICAgIHR5cGUgMjQsIGRldGFpbCAweDgwLCB3aWR0aCA3 Mih0b3RhbCA2NCkKWyAgICA3Ljk0NDYyOF0gRURBQyBERUJVRzogZ2hlc19lZGFjX2RtaWRlY29k ZTogRElNTTk6IFVuYnVmZmVyZWQgRERSMyBSQU0gc2l6ZSA9IDIwNDggTUIoRUNDKQpbICAgIDcu OTYxNjgzXSBFREFDIERFQlVHOiBnaGVzX2VkYWNfZG1pZGVjb2RlOiAgICAgICAgIHR5cGUgMjQs IGRldGFpbCAweDgwLCB3aWR0aCA3Mih0b3RhbCA2NCkKWyAgICA3Ljk3Nzg3MV0gRURBQyBERUJV RzogZ2hlc19lZGFjX2RtaWRlY29kZTogRElNTTEwOiBVbmJ1ZmZlcmVkIEREUjMgUkFNIHNpemUg PSAyMDQ4IE1CKEVDQykKWyAgICA3Ljk5NTEwNV0gRURBQyBERUJVRzogZ2hlc19lZGFjX2RtaWRl Y29kZTogICAgICAgICB0eXBlIDI0LCBkZXRhaWwgMHg4MCwgd2lkdGggNzIodG90YWwgNjQpClsg ICAgOC4wMTEyOTFdIEVEQUMgREVCVUc6IGdoZXNfZWRhY19kbWlkZWNvZGU6IERJTU0xMTogVW5i dWZmZXJlZCBERFIzIFJBTSBzaXplID0gMjA0OCBNQihFQ0MpClsgICAgOC4wMjg1MjRdIEVEQUMg REVCVUc6IGdoZXNfZWRhY19kbWlkZWNvZGU6ICAgICAgICAgdHlwZSAyNCwgZGV0YWlsIDB4ODAs IHdpZHRoIDcyKHRvdGFsIDY0KQpbICAgIDguMDQ0NzEyXSBFREFDIERFQlVHOiBnaGVzX2VkYWNf ZG1pZGVjb2RlOiBESU1NMTI6IFVuYnVmZmVyZWQgRERSMyBSQU0gc2l6ZSA9IDIwNDggTUIoRUND KQpbICAgIDguMDYxOTQyXSBFREFDIERFQlVHOiBnaGVzX2VkYWNfZG1pZGVjb2RlOiAgICAgICAg IHR5cGUgMjQsIGRldGFpbCAweDgwLCB3aWR0aCA3Mih0b3RhbCA2NCkKWyAgICA4LjA3ODEyOV0g RURBQyBERUJVRzogZ2hlc19lZGFjX2RtaWRlY29kZTogRElNTTEzOiBVbmJ1ZmZlcmVkIEREUjMg UkFNIHNpemUgPSAyMDQ4IE1CKEVDQykKWyAgICA4LjA5NTM2MF0gRURBQyBERUJVRzogZ2hlc19l ZGFjX2RtaWRlY29kZTogICAgICAgICB0eXBlIDI0LCBkZXRhaWwgMHg4MCwgd2lkdGggNzIodG90 YWwgNjQpClsgICAgOC4xMTE1NDddIEVEQUMgREVCVUc6IGdoZXNfZWRhY19kbWlkZWNvZGU6IERJ TU0xNDogVW5idWZmZXJlZCBERFIzIFJBTSBzaXplID0gMjA0OCBNQihFQ0MpClsgICAgOC4xNjE3 MDNdIEVEQUMgREVCVUc6IGdoZXNfZWRhY19kbWlkZWNvZGU6ICAgICAgICAgdHlwZSAyNCwgZGV0 YWlsIDB4ODAsIHdpZHRoIDcyKHRvdGFsIDY0KQpbICAgIDguMTc3OTA0XSBFREFDIERFQlVHOiBn aGVzX2VkYWNfZG1pZGVjb2RlOiBESU1NMTU6IFVuYnVmZmVyZWQgRERSMyBSQU0gc2l6ZSA9IDIw NDggTUIoRUNDKQpbICAgIDguMTk1MTMyXSBFREFDIERFQlVHOiBnaGVzX2VkYWNfZG1pZGVjb2Rl OiAgICAgICAgIHR5cGUgMjQsIGRldGFpbCAweDgwLCB3aWR0aCA3Mih0b3RhbCA2NCkKWyAgICA4 LjIxMTMyMV0gRURBQyBERUJVRzogZWRhY19tY19hZGRfbWNfd2l0aF9ncm91cHM6IApbICAgIDgu MjIxNDU2XSBFREFDIERFQlVHOiBlZGFjX2NyZWF0ZV9zeXNmc19tY2lfZGV2aWNlOiBjcmVhdGlu ZyBidXMgbWMwClsgICAgOC4yMzQ3MzZdIEVEQUMgREVCVUc6IGVkYWNfY3JlYXRlX3N5c2ZzX21j aV9kZXZpY2U6IGNyZWF0aW5nIGRldmljZSBtYzAKWyAgICA4LjI0ODU0NV0gRURBQyBERUJVRzog ZWRhY19jcmVhdGVfc3lzZnNfbWNpX2RldmljZTogY3JlYXRpbmcgZGltbTgsIGxvY2F0ZWQgYXQg bWVtb3J5IDggClsgICAgOC4yNjU0NTddIEVEQUMgREVCVUc6IGVkYWNfY3JlYXRlX2RpbW1fb2Jq ZWN0OiBjcmVhdGluZyByYW5rL2RpbW0gZGV2aWNlIGRpbW04ClsgICAgOC4yODA2MDFdIEVEQUMg REVCVUc6IGVkYWNfY3JlYXRlX3N5c2ZzX21jaV9kZXZpY2U6IGNyZWF0aW5nIGRpbW05LCBsb2Nh dGVkIGF0IG1lbW9yeSA5IApbICAgIDguMjk3NTAzXSBFREFDIERFQlVHOiBlZGFjX2NyZWF0ZV9k aW1tX29iamVjdDogY3JlYXRpbmcgcmFuay9kaW1tIGRldmljZSBkaW1tOQpbICAgIDguMzEyNjUw XSBFREFDIERFQlVHOiBlZGFjX2NyZWF0ZV9zeXNmc19tY2lfZGV2aWNlOiBjcmVhdGluZyBkaW1t MTAsIGxvY2F0ZWQgYXQgbWVtb3J5IDEwIApbICAgIDguMzI5OTAwXSBFREFDIERFQlVHOiBlZGFj X2NyZWF0ZV9kaW1tX29iamVjdDogY3JlYXRpbmcgcmFuay9kaW1tIGRldmljZSBkaW1tMTAKWyAg ICA4LjM0NTIyMF0gRURBQyBERUJVRzogZWRhY19jcmVhdGVfc3lzZnNfbWNpX2RldmljZTogY3Jl YXRpbmcgZGltbTExLCBsb2NhdGVkIGF0IG1lbW9yeSAxMSAKWyAgICA4LjM2MjQ3MF0gRURBQyBE RUJVRzogZWRhY19jcmVhdGVfZGltbV9vYmplY3Q6IGNyZWF0aW5nIHJhbmsvZGltbSBkZXZpY2Ug ZGltbTExClsgICAgOC4zNzc3ODldIEVEQUMgREVCVUc6IGVkYWNfY3JlYXRlX3N5c2ZzX21jaV9k ZXZpY2U6IGNyZWF0aW5nIGRpbW0xMiwgbG9jYXRlZCBhdCBtZW1vcnkgMTIgClsgICAgOC4zOTUw MzldIEVEQUMgREVCVUc6IGVkYWNfY3JlYXRlX2RpbW1fb2JqZWN0OiBjcmVhdGluZyByYW5rL2Rp bW0gZGV2aWNlIGRpbW0xMgpbICAgIDguNDEwMzU4XSBFREFDIERFQlVHOiBlZGFjX2NyZWF0ZV9z eXNmc19tY2lfZGV2aWNlOiBjcmVhdGluZyBkaW1tMTMsIGxvY2F0ZWQgYXQgbWVtb3J5IDEzIApb ICAgIDguNDI3NjA4XSBFREFDIERFQlVHOiBlZGFjX2NyZWF0ZV9kaW1tX29iamVjdDogY3JlYXRp bmcgcmFuay9kaW1tIGRldmljZSBkaW1tMTMKWyAgICA4LjQ0MjkyOF0gRURBQyBERUJVRzogZWRh Y19jcmVhdGVfc3lzZnNfbWNpX2RldmljZTogY3JlYXRpbmcgZGltbTE0LCBsb2NhdGVkIGF0IG1l bW9yeSAxNCAKWyAgICA4LjQ2MDE5NF0gRURBQyBERUJVRzogZWRhY19jcmVhdGVfZGltbV9vYmpl Y3Q6IGNyZWF0aW5nIHJhbmsvZGltbSBkZXZpY2UgZGltbTE0ClsgICAgOC40NzU1MTddIEVEQUMg REVCVUc6IGVkYWNfY3JlYXRlX3N5c2ZzX21jaV9kZXZpY2U6IGNyZWF0aW5nIGRpbW0xNSwgbG9j YXRlZCBhdCBtZW1vcnkgMTUgClsgICAgOC40OTI3NjhdIEVEQUMgREVCVUc6IGVkYWNfY3JlYXRl X2RpbW1fb2JqZWN0OiBjcmVhdGluZyByYW5rL2RpbW0gZGV2aWNlIGRpbW0xNQoKTWF1cm8/Ci0t LQpGcm9tOiBCb3Jpc2xhdiBQZXRrb3YgPGJwQHN1c2UuZGU+CkRhdGU6IFdlZCwgMTYgQXVnIDIw MTcgMTA6MzM6NDQgKzAyMDAKU3ViamVjdDogW1BBVENIXSBFREFDLCBnaGVzOiBNb2RlbCBhIHNp bmdsZSwgbG9naWNhbCBtZW1vcnkgY29udHJvbGxlcgoKV2UncmUgZW51bWVyYXRpbmcgdGhlIERJ TU1zIHRocm91Z2ggYSBETUkgd2FsayBhbmQgc2luY2Ugd2UgY2FuJ3QgZ2V0CmFueSBtb3JlIGRl dGFpbGVkIHRvcG9sb2dpY2FsIGluZm9ybWF0aW9uIGFib3V0IHdoaWNoIERJTU1zIGJlbG9uZyB0 bwp3aGljaCBtZW1vcnkgY29udHJvbGxlciwgY29udmVydCBpdCB0byBhIHNpbmdsZSwgbG9naWNh bCBjb250cm9sbGVyCndoaWNoIGNvbnRhaW5zIGFsbCB0aGUgRElNTXMuCgpUaGUgZXJyb3IgcmVw b3J0aW5nIHBhdGggZnJvbSBHSEVTIGdoZXNfZWRhY19yZXBvcnRfbWVtX2Vycm9yKCkgZG9lc24n dApnZXQgY2FsbGVkIGluIE5NSSBjb250ZXh0IGJ1dCBhZGQgYSB3YXJuaW5nIGFib3V0IGl0IHRv IGNhdGNoIGFueQpjaGFuZ2VzIGluIHRoZSBmdXR1cmUgYXMgaWYgc28sIG91ciBsb2NraW5nIHNj aGVtZSB3aWxsIGJlIGluc3VmZmljaWVudAp0aGVuLgoKU2lnbmVkLW9mZi1ieTogQm9yaXNsYXYg UGV0a292IDxicEBzdXNlLmRlPgotLS0KIGRyaXZlcnMvZWRhYy9naGVzX2VkYWMuYyB8IDExNiAr KysrKysrKysrKysrKysrKysrKystLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLQogMSBmaWxlIGNo YW5nZWQsIDUxIGluc2VydGlvbnMoKyksIDY1IGRlbGV0aW9ucygtKQoKZGlmZiAtLWdpdCBhL2Ry aXZlcnMvZWRhYy9naGVzX2VkYWMuYyBiL2RyaXZlcnMvZWRhYy9naGVzX2VkYWMuYwppbmRleCA2 ZjgwZWI2NWMyNmMuLmU3OTBkNjRiOGVkZCAxMDA2NDQKLS0tIGEvZHJpdmVycy9lZGFjL2doZXNf ZWRhYy5jCisrKyBiL2RyaXZlcnMvZWRhYy9naGVzX2VkYWMuYwpAQCAtMjgsMTAgKzI4LDE1IEBA IHN0cnVjdCBnaGVzX2VkYWNfcHZ0IHsKIAljaGFyIG1zZ1s4MF07CiB9OwogCi1zdGF0aWMgTElT VF9IRUFEKGdoZXNfcmVnbGlzdCk7Ci1zdGF0aWMgREVGSU5FX01VVEVYKGdoZXNfZWRhY19sb2Nr KTsKLXN0YXRpYyBpbnQgZ2hlc19lZGFjX21jX251bTsKK3N0YXRpYyBhdG9taWNfdCBnaGVzX2lu aXQgPSBBVE9NSUNfSU5JVCgwKTsKK3N0YXRpYyBzdHJ1Y3QgZ2hlc19lZGFjX3B2dCAqZ2hlc19w dnQ7CiAKKy8qCisgKiBTeW5jIHdpdGggb3RoZXIsIHBvdGVudGlhbGx5IGNvbmN1cnJlbnQgY2Fs bGVycyBvZgorICogZ2hlc19lZGFjX3JlcG9ydF9tZW1fZXJyb3IoKS4gV2UgZG9uJ3Qga25vdyB3 aGF0IHRoZQorICogImludmVudGl2ZSIgZmlybXdhcmUgd291bGQgZG8uCisgKi8KK3N0YXRpYyBE RUZJTkVfU1BJTkxPQ0soZ2hlc19sb2NrKTsKIAogLyogTWVtb3J5IERldmljZSAtIFR5cGUgMTcg b2YgU01CSU9TIHNwZWMgKi8KIHN0cnVjdCBtZW1kZXZfZG1pX2VudHJ5IHsKQEAgLTE2OSwxOCAr MTc0LDI2IEBAIHZvaWQgZ2hlc19lZGFjX3JlcG9ydF9tZW1fZXJyb3Ioc3RydWN0IGdoZXMgKmdo ZXMsIGludCBzZXYsCiAJZW51bSBod19ldmVudF9tY19lcnJfdHlwZSB0eXBlOwogCXN0cnVjdCBl ZGFjX3Jhd19lcnJvcl9kZXNjICplOwogCXN0cnVjdCBtZW1fY3RsX2luZm8gKm1jaTsKLQlzdHJ1 Y3QgZ2hlc19lZGFjX3B2dCAqcHZ0ID0gTlVMTDsKKwlzdHJ1Y3QgZ2hlc19lZGFjX3B2dCAqcHZ0 ID0gZ2hlc19wdnQ7CisJdW5zaWduZWQgbG9uZyBmbGFnczsKIAljaGFyICpwOwogCXU4IGdyYWlu X2JpdHM7CiAKLQlsaXN0X2Zvcl9lYWNoX2VudHJ5KHB2dCwgJmdoZXNfcmVnbGlzdCwgbGlzdCkg ewotCQlpZiAoZ2hlcyA9PSBwdnQtPmdoZXMpCi0JCQlicmVhazsKLQl9CiAJaWYgKCFwdnQpIHsK IAkJcHJfZXJyKCJJbnRlcm5hbCBlcnJvcjogQ2FuJ3QgZmluZCBFREFDIHN0cnVjdHVyZVxuIik7 CiAJCXJldHVybjsKIAl9CisKKwkvKgorCSAqIFdlIGNhbiBkbyB0aGUgbG9ja2luZyBiZWxvdyBi ZWNhdXNlIEdIRVMgZGVmZXJzIGVycm9yIHByb2Nlc3NpbmcKKwkgKiBmcm9tIE5NSSB0byBJUlEg Y29udGV4dC4gV2hlbmV2ZXIgdGhhdCBjaGFuZ2VzLCB3ZSdkIGF0IGxlYXN0CisJICoga25vdy4K KwkgKi8KKwlpZiAoV0FSTl9PTl9PTkNFKGluX25taSgpKSkKKwkJcmV0dXJuOworCisJc3Bpbl9s b2NrX2lycXNhdmUoJmdoZXNfbG9jaywgZmxhZ3MpOworCiAJbWNpID0gcHZ0LT5tY2k7CiAJZSA9 ICZtY2ktPmVycm9yX2Rlc2M7CiAKQEAgLTM5OCw4ICs0MTEsOCBAQCB2b2lkIGdoZXNfZWRhY19y ZXBvcnRfbWVtX2Vycm9yKHN0cnVjdCBnaGVzICpnaGVzLCBpbnQgc2V2LAogCQkgICAgICAgKGUt PnBhZ2VfZnJhbWVfbnVtYmVyIDw8IFBBR0VfU0hJRlQpIHwgZS0+b2Zmc2V0X2luX3BhZ2UsCiAJ CSAgICAgICBncmFpbl9iaXRzLCBlLT5zeW5kcm9tZSwgcHZ0LT5kZXRhaWxfbG9jYXRpb24pOwog Ci0JLyogUmVwb3J0IHRoZSBlcnJvciB2aWEgRURBQyBBUEkgKi8KIAllZGFjX3Jhd19tY19oYW5k bGVfZXJyb3IodHlwZSwgbWNpLCBlKTsKKwlzcGluX3VubG9ja19pcnFyZXN0b3JlKCZnaGVzX2xv Y2ssIGZsYWdzKTsKIH0KIEVYUE9SVF9TWU1CT0xfR1BMKGdoZXNfZWRhY19yZXBvcnRfbWVtX2Vy cm9yKTsKIApAQCAtNDA5LDkgKzQyMiwxNCBAQCBpbnQgZ2hlc19lZGFjX3JlZ2lzdGVyKHN0cnVj dCBnaGVzICpnaGVzLCBzdHJ1Y3QgZGV2aWNlICpkZXYpCiAJaW50IHJjLCBudW1fZGltbSA9IDA7 CiAJc3RydWN0IG1lbV9jdGxfaW5mbyAqbWNpOwogCXN0cnVjdCBlZGFjX21jX2xheWVyIGxheWVy c1sxXTsKLQlzdHJ1Y3QgZ2hlc19lZGFjX3B2dCAqcHZ0OwogCXN0cnVjdCBnaGVzX2VkYWNfZGlt bV9maWxsIGRpbW1fZmlsbDsKIAorCS8qCisJICogV2UgaGF2ZSBvbmx5IG9uZSBsb2dpY2FsIG1l bW9yeSBjb250cm9sbGVyIHRvIHdoaWNoIGFsbCBESU1NcyBiZWxvbmcuCisJICovCisJaWYgKGF0 b21pY19pbmNfcmV0dXJuKCZnaGVzX2luaXQpID4gMSkKKwkJcmV0dXJuIDA7CisKIAkvKiBHZXQg dGhlIG51bWJlciBvZiBESU1NcyAqLwogCWRtaV93YWxrKGdoZXNfZWRhY19jb3VudF9kaW1tcywg Jm51bV9kaW1tKTsKIApAQCAtNDI1LDI2ICs0NDMsMTcgQEAgaW50IGdoZXNfZWRhY19yZWdpc3Rl cihzdHJ1Y3QgZ2hlcyAqZ2hlcywgc3RydWN0IGRldmljZSAqZGV2KQogCWxheWVyc1swXS5zaXpl ID0gbnVtX2RpbW07CiAJbGF5ZXJzWzBdLmlzX3ZpcnRfY3Nyb3cgPSB0cnVlOwogCi0JLyoKLQkg KiBXZSBuZWVkIHRvIHNlcmlhbGl6ZSBlZGFjX21jX2FsbG9jKCkgYW5kIGVkYWNfbWNfYWRkX21j KCksCi0JICogdG8gYXZvaWQgZHVwbGljYXRlZCBtZW1vcnkgY29udHJvbGxlciBudW1iZXJzCi0J ICovCi0JbXV0ZXhfbG9jaygmZ2hlc19lZGFjX2xvY2spOwotCW1jaSA9IGVkYWNfbWNfYWxsb2Mo Z2hlc19lZGFjX21jX251bSwgQVJSQVlfU0laRShsYXllcnMpLCBsYXllcnMsCi0JCQkgICAgc2l6 ZW9mKCpwdnQpKTsKKwltY2kgPSBlZGFjX21jX2FsbG9jKDAsIEFSUkFZX1NJWkUobGF5ZXJzKSwg bGF5ZXJzLCBzaXplb2Yoc3RydWN0IGdoZXNfZWRhY19wdnQpKTsKIAlpZiAoIW1jaSkgewogCQlw cl9pbmZvKCJDYW4ndCBhbGxvY2F0ZSBtZW1vcnkgZm9yIEVEQUMgZGF0YVxuIik7Ci0JCW11dGV4 X3VubG9jaygmZ2hlc19lZGFjX2xvY2spOwogCQlyZXR1cm4gLUVOT01FTTsKIAl9CiAKLQlwdnQg PSBtY2ktPnB2dF9pbmZvOwotCW1lbXNldChwdnQsIDAsIHNpemVvZigqcHZ0KSk7Ci0JbGlzdF9h ZGRfdGFpbCgmcHZ0LT5saXN0LCAmZ2hlc19yZWdsaXN0KTsKLQlwdnQtPmdoZXMgPSBnaGVzOwot CXB2dC0+bWNpICA9IG1jaTsKLQltY2ktPnBkZXYgPSBkZXY7CisJZ2hlc19wdnQJPSBtY2ktPnB2 dF9pbmZvOworCWdoZXNfcHZ0LT5naGVzCT0gZ2hlczsKKwlnaGVzX3B2dC0+bWNpCT0gbWNpOwog CisJbWNpLT5wZGV2ID0gZGV2OwogCW1jaS0+bXR5cGVfY2FwID0gTUVNX0ZMQUdfRU1QVFk7CiAJ bWNpLT5lZGFjX2N0bF9jYXAgPSBFREFDX0ZMQUdfTk9ORTsKIAltY2ktPmVkYWNfY2FwID0gRURB Q19GTEFHX05PTkU7CkBAIC00NTIsMzYgKzQ2MSwyMyBAQCBpbnQgZ2hlc19lZGFjX3JlZ2lzdGVy KHN0cnVjdCBnaGVzICpnaGVzLCBzdHJ1Y3QgZGV2aWNlICpkZXYpCiAJbWNpLT5jdGxfbmFtZSA9 ICJnaGVzX2VkYWMiOwogCW1jaS0+ZGV2X25hbWUgPSAiZ2hlcyI7CiAKLQlpZiAoIWdoZXNfZWRh Y19tY19udW0pIHsKLQkJaWYgKCFmYWtlKSB7Ci0JCQlwcl9pbmZvKCJUaGlzIEVEQUMgZHJpdmVy IHJlbGllcyBvbiBCSU9TIHRvIGVudW1lcmF0ZSBtZW1vcnkgYW5kIGdldCBlcnJvciByZXBvcnRz LlxuIik7Ci0JCQlwcl9pbmZvKCJVbmZvcnR1bmF0ZWx5LCBub3QgYWxsIEJJT1NlcyByZWZsZWN0 IHRoZSBtZW1vcnkgbGF5b3V0IGNvcnJlY3RseS5cbiIpOwotCQkJcHJfaW5mbygiU28sIHRoZSBl bmQgcmVzdWx0IG9mIHVzaW5nIHRoaXMgZHJpdmVyIHZhcmllcyBmcm9tIHZlbmRvciB0byB2ZW5k b3IuXG4iKTsKLQkJCXByX2luZm8oIklmIHlvdSBmaW5kIGluY29ycmVjdCByZXBvcnRzLCBwbGVh c2UgY29udGFjdCB5b3VyIGhhcmR3YXJlIHZlbmRvclxuIik7Ci0JCQlwcl9pbmZvKCJ0byBjb3Jy ZWN0IGl0cyBCSU9TLlxuIik7Ci0JCQlwcl9pbmZvKCJUaGlzIHN5c3RlbSBoYXMgJWQgRElNTSBz b2NrZXRzLlxuIiwKLQkJCQludW1fZGltbSk7Ci0JCX0gZWxzZSB7Ci0JCQlwcl9pbmZvKCJUaGlz IHN5c3RlbSBoYXMgYSB2ZXJ5IGNyYXBweSBCSU9TOiBJdCBkb2Vzbid0IGV2ZW4gbGlzdCB0aGUg RElNTVMuXG4iKTsKLQkJCXByX2luZm8oIkl0cyBTTUJJT1MgaW5mbyBpcyB3cm9uZy4gSXQgaXMg ZG91YnRmdWwgdGhhdCB0aGUgZXJyb3IgcmVwb3J0IHdvdWxkXG4iKTsKLQkJCXByX2luZm8oIndv cmsgb24gc3VjaCBzeXN0ZW0uIFVzZSB0aGlzIGRyaXZlciB3aXRoIGNhdXRpb25cbiIpOwotCQl9 CisJaWYgKCFmYWtlKSB7CisJCXByX2luZm8oIlRoaXMgRURBQyBkcml2ZXIgcmVsaWVzIG9uIEJJ T1MgdG8gZW51bWVyYXRlIG1lbW9yeSBhbmQgZ2V0IGVycm9yIHJlcG9ydHMuXG4iKTsKKwkJcHJf aW5mbygiVW5mb3J0dW5hdGVseSwgbm90IGFsbCBCSU9TZXMgcmVmbGVjdCB0aGUgbWVtb3J5IGxh eW91dCBjb3JyZWN0bHkuXG4iKTsKKwkJcHJfaW5mbygiU28sIHRoZSBlbmQgcmVzdWx0IG9mIHVz aW5nIHRoaXMgZHJpdmVyIHZhcmllcyBmcm9tIHZlbmRvciB0byB2ZW5kb3IuXG4iKTsKKwkJcHJf aW5mbygiSWYgeW91IGZpbmQgaW5jb3JyZWN0IHJlcG9ydHMsIHBsZWFzZSBjb250YWN0IHlvdXIg aGFyZHdhcmUgdmVuZG9yXG4iKTsKKwkJcHJfaW5mbygidG8gY29ycmVjdCBpdHMgQklPUy5cbiIp OworCQlwcl9pbmZvKCJUaGlzIHN5c3RlbSBoYXMgJWQgRElNTSBzb2NrZXRzLlxuIiwgbnVtX2Rp bW0pOworCX0gZWxzZSB7CisJCXByX2luZm8oIlRoaXMgc3lzdGVtIGhhcyBhIHZlcnkgY3JhcHB5 IEJJT1M6IEl0IGRvZXNuJ3QgZXZlbiBsaXN0IHRoZSBESU1NUy5cbiIpOworCQlwcl9pbmZvKCJJ dHMgU01CSU9TIGluZm8gaXMgd3JvbmcuIEl0IGlzIGRvdWJ0ZnVsIHRoYXQgdGhlIGVycm9yIHJl cG9ydCB3b3VsZFxuIik7CisJCXByX2luZm8oIndvcmsgb24gc3VjaCBzeXN0ZW0uIFVzZSB0aGlz IGRyaXZlciB3aXRoIGNhdXRpb25cbiIpOwogCX0KIAogCWlmICghZmFrZSkgewotCQkvKgotCQkg KiBGaWxsIERJTU0gaW5mbyBmcm9tIERNSSBmb3IgdGhlIG1lbW9yeSBjb250cm9sbGVyICMwCi0J CSAqCi0JCSAqIEtlZXAgaXQgaW4gYmxhbmsgZm9yIHRoZSBvdGhlciBtZW1vcnkgY29udHJvbGxl cnMsIGFzCi0JCSAqIHRoZXJlJ3Mgbm8gcmVsaWFibGUgd2F5IHRvIHByb3Blcmx5IGNyZWRpdCBl YWNoIERJTU0gdG8KLQkJICogdGhlIG1lbW9yeSBjb250cm9sbGVyLCBhcyBkaWZmZXJlbnQgQklP U2VzIGZpbGwgdGhlCi0JCSAqIERNSSBiYW5rIGxvY2F0aW9uIGZpZWxkcyBvbiBkaWZmZXJlbnQg d2F5cwotCQkgKi8KLQkJaWYgKCFnaGVzX2VkYWNfbWNfbnVtKSB7Ci0JCQlkaW1tX2ZpbGwuY291 bnQgPSAwOwotCQkJZGltbV9maWxsLm1jaSA9IG1jaTsKLQkJCWRtaV93YWxrKGdoZXNfZWRhY19k bWlkZWNvZGUsICZkaW1tX2ZpbGwpOwotCQl9CisJCWRpbW1fZmlsbC5jb3VudCA9IDA7CisJCWRp bW1fZmlsbC5tY2kgPSBtY2k7CisJCWRtaV93YWxrKGdoZXNfZWRhY19kbWlkZWNvZGUsICZkaW1t X2ZpbGwpOwogCX0gZWxzZSB7CiAJCXN0cnVjdCBkaW1tX2luZm8gKmRpbW0gPSBFREFDX0RJTU1f UFRSKG1jaS0+bGF5ZXJzLCBtY2ktPmRpbW1zLAogCQkJCQkJICAgICAgIG1jaS0+bl9sYXllcnMs IDAsIDAsIDApOwpAQCAtNDk3LDEyICs0OTMsOCBAQCBpbnQgZ2hlc19lZGFjX3JlZ2lzdGVyKHN0 cnVjdCBnaGVzICpnaGVzLCBzdHJ1Y3QgZGV2aWNlICpkZXYpCiAJaWYgKHJjIDwgMCkgewogCQlw cl9pbmZvKCJDYW4ndCByZWdpc3RlciBhdCBFREFDIGNvcmVcbiIpOwogCQllZGFjX21jX2ZyZWUo bWNpKTsKLQkJbXV0ZXhfdW5sb2NrKCZnaGVzX2VkYWNfbG9jayk7CiAJCXJldHVybiAtRU5PREVW OwogCX0KLQotCWdoZXNfZWRhY19tY19udW0rKzsKLQltdXRleF91bmxvY2soJmdoZXNfZWRhY19s b2NrKTsKIAlyZXR1cm4gMDsKIH0KIEVYUE9SVF9TWU1CT0xfR1BMKGdoZXNfZWRhY19yZWdpc3Rl cik7CkBAIC01MTAsMTUgKzUwMiw5IEBAIEVYUE9SVF9TWU1CT0xfR1BMKGdoZXNfZWRhY19yZWdp c3Rlcik7CiB2b2lkIGdoZXNfZWRhY191bnJlZ2lzdGVyKHN0cnVjdCBnaGVzICpnaGVzKQogewog CXN0cnVjdCBtZW1fY3RsX2luZm8gKm1jaTsKLQlzdHJ1Y3QgZ2hlc19lZGFjX3B2dCAqcHZ0LCAq dG1wOwotCi0JbGlzdF9mb3JfZWFjaF9lbnRyeV9zYWZlKHB2dCwgdG1wLCAmZ2hlc19yZWdsaXN0 LCBsaXN0KSB7Ci0JCWlmIChnaGVzID09IHB2dC0+Z2hlcykgewotCQkJbWNpID0gcHZ0LT5tY2k7 Ci0JCQllZGFjX21jX2RlbF9tYyhtY2ktPnBkZXYpOwotCQkJZWRhY19tY19mcmVlKG1jaSk7Ci0J CQlsaXN0X2RlbCgmcHZ0LT5saXN0KTsKLQkJfQotCX0KKworCW1jaSA9IGdoZXNfcHZ0LT5tY2k7 CisJZWRhY19tY19kZWxfbWMobWNpLT5wZGV2KTsKKwllZGFjX21jX2ZyZWUobWNpKTsKIH0KIEVY UE9SVF9TWU1CT0xfR1BMKGdoZXNfZWRhY191bnJlZ2lzdGVyKTsK