From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S966940AbbDXQIs (ORCPT ); Fri, 24 Apr 2015 12:08:48 -0400 Received: from mail-bl2on0118.outbound.protection.outlook.com ([65.55.169.118]:43264 "EHLO na01-bl2-obe.outbound.protection.outlook.com" rhost-flags-OK-OK-OK-FAIL) by vger.kernel.org with ESMTP id S966397AbbDXQIo (ORCPT ); Fri, 24 Apr 2015 12:08:44 -0400 X-Greylist: delayed 919 seconds by postgrey-1.27 at vger.kernel.org; Fri, 24 Apr 2015 12:08:43 EDT Authentication-Results: spf=fail (sender IP is 192.88.158.2) smtp.mailfrom=freescale.com; freescale.mail.onmicrosoft.com; dkim=none (message not signed) header.d=none; From: Bogdan Purcareata To: , , , , , , , , , Subject: [PATCH v2 1/2] powerpc/kvm: Convert openpic lock to raw_spinlock Date: Fri, 24 Apr 2015 15:53:12 +0000 Message-ID: <1429890793-19487-2-git-send-email-bogdan.purcareata@freescale.com> X-Mailer: git-send-email 2.1.4 In-Reply-To: <1429890793-19487-1-git-send-email-bogdan.purcareata@freescale.com> References: <1429890793-19487-1-git-send-email-bogdan.purcareata@freescale.com> X-EOPAttributedMessage: 0 X-Forefront-Antispam-Report: CIP:192.88.158.2;CTRY:US;IPV:NLI;EFV:NLI;BMV:1;SFV:NSPM;SFS:(10019020)(6009001)(339900001)(199003)(189002)(104016003)(229853001)(107886001)(48376002)(105606002)(36756003)(33646002)(85426001)(106466001)(47776003)(50466002)(50986999)(76176999)(19580395003)(19580405001)(2950100001)(6806004)(77156002)(92566002)(62966003)(15975445007)(77096005)(2201001)(46102003)(87936001)(49486002)(50226001)(5001770100001)(921003)(21314002)(1121003)(4001450100001)(2101003);DIR:OUT;SFP:1102;SCL:1;SRVR:BY2PR03MB315;H:az84smr01.freescale.net;FPR:;SPF:Fail;MLV:sfv;A:1;MX:1;LANG:en; MIME-Version: 1.0 Content-Type: text/plain X-Microsoft-Antispam: UriScan:;BCL:0;PCL:0;RULEID:;SRVR:BY2PR03MB315; X-Microsoft-Antispam-PRVS: X-Exchange-Antispam-Report-Test: UriScan:; X-Exchange-Antispam-Report-CFA-Test: BCL:0;PCL:0;RULEID:(601004)(5005006)(5002010)(3002001);SRVR:BY2PR03MB315;BCL:0;PCL:0;RULEID:;SRVR:BY2PR03MB315; X-Forefront-PRVS: 05568D1FF7 X-OriginatorOrg: freescale.com X-MS-Exchange-CrossTenant-OriginalArrivalTime: 24 Apr 2015 15:53:22.0175 (UTC) X-MS-Exchange-CrossTenant-Id: 710a03f5-10f6-4d38-9ff4-a80b81da590d X-MS-Exchange-CrossTenant-OriginalAttributedTenantConnectingIp: TenantId=710a03f5-10f6-4d38-9ff4-a80b81da590d;Ip=[192.88.158.2];Helo=[az84smr01.freescale.net] X-MS-Exchange-CrossTenant-FromEntityHeader: HybridOnPrem X-MS-Exchange-Transport-CrossTenantHeadersStamped: BY2PR03MB315 Sender: linux-kernel-owner@vger.kernel.org List-ID: X-Mailing-List: linux-kernel@vger.kernel.org The lock in the KVM openpic emulation on PPC is a spinlock_t, meaning it becomes a sleeping mutex under PREEMPT_RT_FULL. This yields to a situation where this non-raw lock is grabbed with interrupts already disabled by hard_irq_disable(): kvmppc_prepare_to_enter() hard_irq_disable() kvmppc_core_prepare_to_enter() kvmppc_core_check_exceptions() kvmppc_booke_irqprio_deliver() kvmppc_mpic_set_epr() spin_lock_irqsave() ... This happens for guest interrupts that go through this openpic emulation code. The result is a kernel crash on guest enter (include/linux/kvm_host.h:784). Converting the lock to a raw_spinlock fixes the issue and enables the guest to run I/O intensive workloads in a SMP configuration. A similar fix can be found for the i8254 PIT emulation on x86 [1]. [1] https://lkml.org/lkml/2010/1/11/289 v2: - updated commit message Signed-off-by: Bogdan Purcareata --- arch/powerpc/kvm/mpic.c | 44 ++++++++++++++++++++++---------------------- 1 file changed, 22 insertions(+), 22 deletions(-) diff --git a/arch/powerpc/kvm/mpic.c b/arch/powerpc/kvm/mpic.c index 6249cdc..2f70660 100644 --- a/arch/powerpc/kvm/mpic.c +++ b/arch/powerpc/kvm/mpic.c @@ -196,7 +196,7 @@ struct openpic { int num_mmio_regions; gpa_t reg_base; - spinlock_t lock; + raw_spinlock_t lock; /* Behavior control */ struct fsl_mpic_info *fsl; @@ -1103,9 +1103,9 @@ static int openpic_cpu_write_internal(void *opaque, gpa_t addr, mpic_irq_raise(opp, dst, ILR_INTTGT_INT); } - spin_unlock(&opp->lock); + raw_spin_unlock(&opp->lock); kvm_notify_acked_irq(opp->kvm, 0, notify_eoi); - spin_lock(&opp->lock); + raw_spin_lock(&opp->lock); break; } @@ -1180,12 +1180,12 @@ void kvmppc_mpic_set_epr(struct kvm_vcpu *vcpu) int cpu = vcpu->arch.irq_cpu_id; unsigned long flags; - spin_lock_irqsave(&opp->lock, flags); + raw_spin_lock_irqsave(&opp->lock, flags); if ((opp->gcr & opp->mpic_mode_mask) == GCR_MODE_PROXY) kvmppc_set_epr(vcpu, openpic_iack(opp, &opp->dst[cpu], cpu)); - spin_unlock_irqrestore(&opp->lock, flags); + raw_spin_unlock_irqrestore(&opp->lock, flags); } static int openpic_cpu_read_internal(void *opaque, gpa_t addr, @@ -1386,9 +1386,9 @@ static int kvm_mpic_read(struct kvm_vcpu *vcpu, return -EINVAL; } - spin_lock_irq(&opp->lock); + raw_spin_lock_irq(&opp->lock); ret = kvm_mpic_read_internal(opp, addr - opp->reg_base, &u.val); - spin_unlock_irq(&opp->lock); + raw_spin_unlock_irq(&opp->lock); /* * Technically only 32-bit accesses are allowed, but be nice to @@ -1427,10 +1427,10 @@ static int kvm_mpic_write(struct kvm_vcpu *vcpu, return -EOPNOTSUPP; } - spin_lock_irq(&opp->lock); + raw_spin_lock_irq(&opp->lock); ret = kvm_mpic_write_internal(opp, addr - opp->reg_base, *(const u32 *)ptr); - spin_unlock_irq(&opp->lock); + raw_spin_unlock_irq(&opp->lock); pr_debug("%s: addr %llx ret %d val %x\n", __func__, addr, ret, *(const u32 *)ptr); @@ -1501,14 +1501,14 @@ static int access_reg(struct openpic *opp, gpa_t addr, u32 *val, int type) if (addr & 3) return -ENXIO; - spin_lock_irq(&opp->lock); + raw_spin_lock_irq(&opp->lock); if (type == ATTR_SET) ret = kvm_mpic_write_internal(opp, addr, *val); else ret = kvm_mpic_read_internal(opp, addr, val); - spin_unlock_irq(&opp->lock); + raw_spin_unlock_irq(&opp->lock); pr_debug("%s: type %d addr %llx val %x\n", __func__, type, addr, *val); @@ -1545,9 +1545,9 @@ static int mpic_set_attr(struct kvm_device *dev, struct kvm_device_attr *attr) if (attr32 != 0 && attr32 != 1) return -EINVAL; - spin_lock_irq(&opp->lock); + raw_spin_lock_irq(&opp->lock); openpic_set_irq(opp, attr->attr, attr32); - spin_unlock_irq(&opp->lock); + raw_spin_unlock_irq(&opp->lock); return 0; } @@ -1592,9 +1592,9 @@ static int mpic_get_attr(struct kvm_device *dev, struct kvm_device_attr *attr) if (attr->attr > MAX_SRC) return -EINVAL; - spin_lock_irq(&opp->lock); + raw_spin_lock_irq(&opp->lock); attr32 = opp->src[attr->attr].pending; - spin_unlock_irq(&opp->lock); + raw_spin_unlock_irq(&opp->lock); if (put_user(attr32, (u32 __user *)(long)attr->addr)) return -EFAULT; @@ -1670,7 +1670,7 @@ static int mpic_create(struct kvm_device *dev, u32 type) opp->kvm = dev->kvm; opp->dev = dev; opp->model = type; - spin_lock_init(&opp->lock); + raw_spin_lock_init(&opp->lock); add_mmio_region(opp, &openpic_gbl_mmio); add_mmio_region(opp, &openpic_tmr_mmio); @@ -1743,7 +1743,7 @@ int kvmppc_mpic_connect_vcpu(struct kvm_device *dev, struct kvm_vcpu *vcpu, if (cpu < 0 || cpu >= MAX_CPU) return -EPERM; - spin_lock_irq(&opp->lock); + raw_spin_lock_irq(&opp->lock); if (opp->dst[cpu].vcpu) { ret = -EEXIST; @@ -1766,7 +1766,7 @@ int kvmppc_mpic_connect_vcpu(struct kvm_device *dev, struct kvm_vcpu *vcpu, vcpu->arch.epr_flags |= KVMPPC_EPR_KERNEL; out: - spin_unlock_irq(&opp->lock); + raw_spin_unlock_irq(&opp->lock); return ret; } @@ -1796,9 +1796,9 @@ static int mpic_set_irq(struct kvm_kernel_irq_routing_entry *e, struct openpic *opp = kvm->arch.mpic; unsigned long flags; - spin_lock_irqsave(&opp->lock, flags); + raw_spin_lock_irqsave(&opp->lock, flags); openpic_set_irq(opp, irq, level); - spin_unlock_irqrestore(&opp->lock, flags); + raw_spin_unlock_irqrestore(&opp->lock, flags); /* All code paths we care about don't check for the return value */ return 0; @@ -1810,14 +1810,14 @@ int kvm_set_msi(struct kvm_kernel_irq_routing_entry *e, struct openpic *opp = kvm->arch.mpic; unsigned long flags; - spin_lock_irqsave(&opp->lock, flags); + raw_spin_lock_irqsave(&opp->lock, flags); /* * XXX We ignore the target address for now, as we only support * a single MSI bank. */ openpic_msi_write(kvm->arch.mpic, MSIIR_OFFSET, e->msi.data); - spin_unlock_irqrestore(&opp->lock, flags); + raw_spin_unlock_irqrestore(&opp->lock, flags); /* All code paths we care about don't check for the return value */ return 0; -- 2.1.4 From mboxrd@z Thu Jan 1 00:00:00 1970 From: Bogdan Purcareata Subject: [PATCH v2 1/2] powerpc/kvm: Convert openpic lock to raw_spinlock Date: Fri, 24 Apr 2015 15:53:12 +0000 Message-ID: <1429890793-19487-2-git-send-email-bogdan.purcareata@freescale.com> References: <1429890793-19487-1-git-send-email-bogdan.purcareata@freescale.com> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 To: , , , , , , , , , Return-path: In-Reply-To: <1429890793-19487-1-git-send-email-bogdan.purcareata@freescale.com> List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: linuxppc-dev-bounces+glppe-linuxppc-embedded-2=m.gmane.org@lists.ozlabs.org Sender: "Linuxppc-dev" List-Id: linux-rt-users.vger.kernel.org VGhlIGxvY2sgaW4gdGhlIEtWTSBvcGVucGljIGVtdWxhdGlvbiBvbiBQUEMgaXMgYSBzcGlubG9j a190LCBtZWFuaW5nIGl0IGJlY29tZXMKYSBzbGVlcGluZyBtdXRleCB1bmRlciBQUkVFTVBUX1JU X0ZVTEwuIFRoaXMgeWllbGRzIHRvIGEgc2l0dWF0aW9uIHdoZXJlIHRoaXMKbm9uLXJhdyBsb2Nr IGlzIGdyYWJiZWQgd2l0aCBpbnRlcnJ1cHRzIGFscmVhZHkgZGlzYWJsZWQgYnkgaGFyZF9pcnFf ZGlzYWJsZSgpOgoKa3ZtcHBjX3ByZXBhcmVfdG9fZW50ZXIoKQogIGhhcmRfaXJxX2Rpc2FibGUo KQogIGt2bXBwY19jb3JlX3ByZXBhcmVfdG9fZW50ZXIoKQogICAga3ZtcHBjX2NvcmVfY2hlY2tf ZXhjZXB0aW9ucygpCiAgICAgIGt2bXBwY19ib29rZV9pcnFwcmlvX2RlbGl2ZXIoKQogICAgICAg IGt2bXBwY19tcGljX3NldF9lcHIoKQogICAgICAgICAgc3Bpbl9sb2NrX2lycXNhdmUoKQogICAg ICAgICAgICAuLi4KClRoaXMgaGFwcGVucyBmb3IgZ3Vlc3QgaW50ZXJydXB0cyB0aGF0IGdvIHRo cm91Z2ggdGhpcyBvcGVucGljIGVtdWxhdGlvbiBjb2RlLgpUaGUgcmVzdWx0IGlzIGEga2VybmVs IGNyYXNoIG9uIGd1ZXN0IGVudGVyIChpbmNsdWRlL2xpbnV4L2t2bV9ob3N0Lmg6Nzg0KS4KCkNv bnZlcnRpbmcgdGhlIGxvY2sgdG8gYSByYXdfc3BpbmxvY2sgZml4ZXMgdGhlIGlzc3VlIGFuZCBl bmFibGVzIHRoZSBndWVzdCB0bwpydW4gSS9PIGludGVuc2l2ZSB3b3JrbG9hZHMgaW4gYSBTTVAg Y29uZmlndXJhdGlvbi4gQSBzaW1pbGFyIGZpeCBjYW4gYmUgZm91bmQKZm9yIHRoZSBpODI1NCBQ SVQgZW11bGF0aW9uIG9uIHg4NiBbMV0uCgpbMV0gaHR0cHM6Ly9sa21sLm9yZy9sa21sLzIwMTAv MS8xMS8yODkKCnYyOgotIHVwZGF0ZWQgY29tbWl0IG1lc3NhZ2UKClNpZ25lZC1vZmYtYnk6IEJv Z2RhbiBQdXJjYXJlYXRhIDxib2dkYW4ucHVyY2FyZWF0YUBmcmVlc2NhbGUuY29tPgotLS0KIGFy Y2gvcG93ZXJwYy9rdm0vbXBpYy5jIHwgNDQgKysrKysrKysrKysrKysrKysrKysrKy0tLS0tLS0t LS0tLS0tLS0tLS0tLS0KIDEgZmlsZSBjaGFuZ2VkLCAyMiBpbnNlcnRpb25zKCspLCAyMiBkZWxl dGlvbnMoLSkKCmRpZmYgLS1naXQgYS9hcmNoL3Bvd2VycGMva3ZtL21waWMuYyBiL2FyY2gvcG93 ZXJwYy9rdm0vbXBpYy5jCmluZGV4IDYyNDljZGMuLjJmNzA2NjAgMTAwNjQ0Ci0tLSBhL2FyY2gv cG93ZXJwYy9rdm0vbXBpYy5jCisrKyBiL2FyY2gvcG93ZXJwYy9rdm0vbXBpYy5jCkBAIC0xOTYs NyArMTk2LDcgQEAgc3RydWN0IG9wZW5waWMgewogCWludCBudW1fbW1pb19yZWdpb25zOwogCiAJ Z3BhX3QgcmVnX2Jhc2U7Ci0Jc3BpbmxvY2tfdCBsb2NrOworCXJhd19zcGlubG9ja190IGxvY2s7 CiAKIAkvKiBCZWhhdmlvciBjb250cm9sICovCiAJc3RydWN0IGZzbF9tcGljX2luZm8gKmZzbDsK QEAgLTExMDMsOSArMTEwMyw5IEBAIHN0YXRpYyBpbnQgb3BlbnBpY19jcHVfd3JpdGVfaW50ZXJu YWwodm9pZCAqb3BhcXVlLCBncGFfdCBhZGRyLAogCQkJbXBpY19pcnFfcmFpc2Uob3BwLCBkc3Qs IElMUl9JTlRUR1RfSU5UKTsKIAkJfQogCi0JCXNwaW5fdW5sb2NrKCZvcHAtPmxvY2spOworCQly YXdfc3Bpbl91bmxvY2soJm9wcC0+bG9jayk7CiAJCWt2bV9ub3RpZnlfYWNrZWRfaXJxKG9wcC0+ a3ZtLCAwLCBub3RpZnlfZW9pKTsKLQkJc3Bpbl9sb2NrKCZvcHAtPmxvY2spOworCQlyYXdfc3Bp bl9sb2NrKCZvcHAtPmxvY2spOwogCiAJCWJyZWFrOwogCX0KQEAgLTExODAsMTIgKzExODAsMTIg QEAgdm9pZCBrdm1wcGNfbXBpY19zZXRfZXByKHN0cnVjdCBrdm1fdmNwdSAqdmNwdSkKIAlpbnQg Y3B1ID0gdmNwdS0+YXJjaC5pcnFfY3B1X2lkOwogCXVuc2lnbmVkIGxvbmcgZmxhZ3M7CiAKLQlz cGluX2xvY2tfaXJxc2F2ZSgmb3BwLT5sb2NrLCBmbGFncyk7CisJcmF3X3NwaW5fbG9ja19pcnFz YXZlKCZvcHAtPmxvY2ssIGZsYWdzKTsKIAogCWlmICgob3BwLT5nY3IgJiBvcHAtPm1waWNfbW9k ZV9tYXNrKSA9PSBHQ1JfTU9ERV9QUk9YWSkKIAkJa3ZtcHBjX3NldF9lcHIodmNwdSwgb3BlbnBp Y19pYWNrKG9wcCwgJm9wcC0+ZHN0W2NwdV0sIGNwdSkpOwogCi0Jc3Bpbl91bmxvY2tfaXJxcmVz dG9yZSgmb3BwLT5sb2NrLCBmbGFncyk7CisJcmF3X3NwaW5fdW5sb2NrX2lycXJlc3RvcmUoJm9w cC0+bG9jaywgZmxhZ3MpOwogfQogCiBzdGF0aWMgaW50IG9wZW5waWNfY3B1X3JlYWRfaW50ZXJu YWwodm9pZCAqb3BhcXVlLCBncGFfdCBhZGRyLApAQCAtMTM4Niw5ICsxMzg2LDkgQEAgc3RhdGlj IGludCBrdm1fbXBpY19yZWFkKHN0cnVjdCBrdm1fdmNwdSAqdmNwdSwKIAkJcmV0dXJuIC1FSU5W QUw7CiAJfQogCi0Jc3Bpbl9sb2NrX2lycSgmb3BwLT5sb2NrKTsKKwlyYXdfc3Bpbl9sb2NrX2ly cSgmb3BwLT5sb2NrKTsKIAlyZXQgPSBrdm1fbXBpY19yZWFkX2ludGVybmFsKG9wcCwgYWRkciAt IG9wcC0+cmVnX2Jhc2UsICZ1LnZhbCk7Ci0Jc3Bpbl91bmxvY2tfaXJxKCZvcHAtPmxvY2spOwor CXJhd19zcGluX3VubG9ja19pcnEoJm9wcC0+bG9jayk7CiAKIAkvKgogCSAqIFRlY2huaWNhbGx5 IG9ubHkgMzItYml0IGFjY2Vzc2VzIGFyZSBhbGxvd2VkLCBidXQgYmUgbmljZSB0bwpAQCAtMTQy NywxMCArMTQyNywxMCBAQCBzdGF0aWMgaW50IGt2bV9tcGljX3dyaXRlKHN0cnVjdCBrdm1fdmNw dSAqdmNwdSwKIAkJcmV0dXJuIC1FT1BOT1RTVVBQOwogCX0KIAotCXNwaW5fbG9ja19pcnEoJm9w cC0+bG9jayk7CisJcmF3X3NwaW5fbG9ja19pcnEoJm9wcC0+bG9jayk7CiAJcmV0ID0ga3ZtX21w aWNfd3JpdGVfaW50ZXJuYWwob3BwLCBhZGRyIC0gb3BwLT5yZWdfYmFzZSwKIAkJCQkgICAgICAq KGNvbnN0IHUzMiAqKXB0cik7Ci0Jc3Bpbl91bmxvY2tfaXJxKCZvcHAtPmxvY2spOworCXJhd19z cGluX3VubG9ja19pcnEoJm9wcC0+bG9jayk7CiAKIAlwcl9kZWJ1ZygiJXM6IGFkZHIgJWxseCBy ZXQgJWQgdmFsICV4XG4iLAogCQkgX19mdW5jX18sIGFkZHIsIHJldCwgKihjb25zdCB1MzIgKilw dHIpOwpAQCAtMTUwMSwxNCArMTUwMSwxNCBAQCBzdGF0aWMgaW50IGFjY2Vzc19yZWcoc3RydWN0 IG9wZW5waWMgKm9wcCwgZ3BhX3QgYWRkciwgdTMyICp2YWwsIGludCB0eXBlKQogCWlmIChhZGRy ICYgMykKIAkJcmV0dXJuIC1FTlhJTzsKIAotCXNwaW5fbG9ja19pcnEoJm9wcC0+bG9jayk7CisJ cmF3X3NwaW5fbG9ja19pcnEoJm9wcC0+bG9jayk7CiAKIAlpZiAodHlwZSA9PSBBVFRSX1NFVCkK IAkJcmV0ID0ga3ZtX21waWNfd3JpdGVfaW50ZXJuYWwob3BwLCBhZGRyLCAqdmFsKTsKIAllbHNl CiAJCXJldCA9IGt2bV9tcGljX3JlYWRfaW50ZXJuYWwob3BwLCBhZGRyLCB2YWwpOwogCi0Jc3Bp bl91bmxvY2tfaXJxKCZvcHAtPmxvY2spOworCXJhd19zcGluX3VubG9ja19pcnEoJm9wcC0+bG9j ayk7CiAKIAlwcl9kZWJ1ZygiJXM6IHR5cGUgJWQgYWRkciAlbGx4IHZhbCAleFxuIiwgX19mdW5j X18sIHR5cGUsIGFkZHIsICp2YWwpOwogCkBAIC0xNTQ1LDkgKzE1NDUsOSBAQCBzdGF0aWMgaW50 IG1waWNfc2V0X2F0dHIoc3RydWN0IGt2bV9kZXZpY2UgKmRldiwgc3RydWN0IGt2bV9kZXZpY2Vf YXR0ciAqYXR0cikKIAkJaWYgKGF0dHIzMiAhPSAwICYmIGF0dHIzMiAhPSAxKQogCQkJcmV0dXJu IC1FSU5WQUw7CiAKLQkJc3Bpbl9sb2NrX2lycSgmb3BwLT5sb2NrKTsKKwkJcmF3X3NwaW5fbG9j a19pcnEoJm9wcC0+bG9jayk7CiAJCW9wZW5waWNfc2V0X2lycShvcHAsIGF0dHItPmF0dHIsIGF0 dHIzMik7Ci0JCXNwaW5fdW5sb2NrX2lycSgmb3BwLT5sb2NrKTsKKwkJcmF3X3NwaW5fdW5sb2Nr X2lycSgmb3BwLT5sb2NrKTsKIAkJcmV0dXJuIDA7CiAJfQogCkBAIC0xNTkyLDkgKzE1OTIsOSBA QCBzdGF0aWMgaW50IG1waWNfZ2V0X2F0dHIoc3RydWN0IGt2bV9kZXZpY2UgKmRldiwgc3RydWN0 IGt2bV9kZXZpY2VfYXR0ciAqYXR0cikKIAkJaWYgKGF0dHItPmF0dHIgPiBNQVhfU1JDKQogCQkJ cmV0dXJuIC1FSU5WQUw7CiAKLQkJc3Bpbl9sb2NrX2lycSgmb3BwLT5sb2NrKTsKKwkJcmF3X3Nw aW5fbG9ja19pcnEoJm9wcC0+bG9jayk7CiAJCWF0dHIzMiA9IG9wcC0+c3JjW2F0dHItPmF0dHJd LnBlbmRpbmc7Ci0JCXNwaW5fdW5sb2NrX2lycSgmb3BwLT5sb2NrKTsKKwkJcmF3X3NwaW5fdW5s b2NrX2lycSgmb3BwLT5sb2NrKTsKIAogCQlpZiAocHV0X3VzZXIoYXR0cjMyLCAodTMyIF9fdXNl ciAqKShsb25nKWF0dHItPmFkZHIpKQogCQkJcmV0dXJuIC1FRkFVTFQ7CkBAIC0xNjcwLDcgKzE2 NzAsNyBAQCBzdGF0aWMgaW50IG1waWNfY3JlYXRlKHN0cnVjdCBrdm1fZGV2aWNlICpkZXYsIHUz MiB0eXBlKQogCW9wcC0+a3ZtID0gZGV2LT5rdm07CiAJb3BwLT5kZXYgPSBkZXY7CiAJb3BwLT5t b2RlbCA9IHR5cGU7Ci0Jc3Bpbl9sb2NrX2luaXQoJm9wcC0+bG9jayk7CisJcmF3X3NwaW5fbG9j a19pbml0KCZvcHAtPmxvY2spOwogCiAJYWRkX21taW9fcmVnaW9uKG9wcCwgJm9wZW5waWNfZ2Js X21taW8pOwogCWFkZF9tbWlvX3JlZ2lvbihvcHAsICZvcGVucGljX3Rtcl9tbWlvKTsKQEAgLTE3 NDMsNyArMTc0Myw3IEBAIGludCBrdm1wcGNfbXBpY19jb25uZWN0X3ZjcHUoc3RydWN0IGt2bV9k ZXZpY2UgKmRldiwgc3RydWN0IGt2bV92Y3B1ICp2Y3B1LAogCWlmIChjcHUgPCAwIHx8IGNwdSA+ PSBNQVhfQ1BVKQogCQlyZXR1cm4gLUVQRVJNOwogCi0Jc3Bpbl9sb2NrX2lycSgmb3BwLT5sb2Nr KTsKKwlyYXdfc3Bpbl9sb2NrX2lycSgmb3BwLT5sb2NrKTsKIAogCWlmIChvcHAtPmRzdFtjcHVd LnZjcHUpIHsKIAkJcmV0ID0gLUVFWElTVDsKQEAgLTE3NjYsNyArMTc2Niw3IEBAIGludCBrdm1w cGNfbXBpY19jb25uZWN0X3ZjcHUoc3RydWN0IGt2bV9kZXZpY2UgKmRldiwgc3RydWN0IGt2bV92 Y3B1ICp2Y3B1LAogCQl2Y3B1LT5hcmNoLmVwcl9mbGFncyB8PSBLVk1QUENfRVBSX0tFUk5FTDsK IAogb3V0OgotCXNwaW5fdW5sb2NrX2lycSgmb3BwLT5sb2NrKTsKKwlyYXdfc3Bpbl91bmxvY2tf aXJxKCZvcHAtPmxvY2spOwogCXJldHVybiByZXQ7CiB9CiAKQEAgLTE3OTYsOSArMTc5Niw5IEBA IHN0YXRpYyBpbnQgbXBpY19zZXRfaXJxKHN0cnVjdCBrdm1fa2VybmVsX2lycV9yb3V0aW5nX2Vu dHJ5ICplLAogCXN0cnVjdCBvcGVucGljICpvcHAgPSBrdm0tPmFyY2gubXBpYzsKIAl1bnNpZ25l ZCBsb25nIGZsYWdzOwogCi0Jc3Bpbl9sb2NrX2lycXNhdmUoJm9wcC0+bG9jaywgZmxhZ3MpOwor CXJhd19zcGluX2xvY2tfaXJxc2F2ZSgmb3BwLT5sb2NrLCBmbGFncyk7CiAJb3BlbnBpY19zZXRf aXJxKG9wcCwgaXJxLCBsZXZlbCk7Ci0Jc3Bpbl91bmxvY2tfaXJxcmVzdG9yZSgmb3BwLT5sb2Nr LCBmbGFncyk7CisJcmF3X3NwaW5fdW5sb2NrX2lycXJlc3RvcmUoJm9wcC0+bG9jaywgZmxhZ3Mp OwogCiAJLyogQWxsIGNvZGUgcGF0aHMgd2UgY2FyZSBhYm91dCBkb24ndCBjaGVjayBmb3IgdGhl IHJldHVybiB2YWx1ZSAqLwogCXJldHVybiAwOwpAQCAtMTgxMCwxNCArMTgxMCwxNCBAQCBpbnQg a3ZtX3NldF9tc2koc3RydWN0IGt2bV9rZXJuZWxfaXJxX3JvdXRpbmdfZW50cnkgKmUsCiAJc3Ry dWN0IG9wZW5waWMgKm9wcCA9IGt2bS0+YXJjaC5tcGljOwogCXVuc2lnbmVkIGxvbmcgZmxhZ3M7 CiAKLQlzcGluX2xvY2tfaXJxc2F2ZSgmb3BwLT5sb2NrLCBmbGFncyk7CisJcmF3X3NwaW5fbG9j a19pcnFzYXZlKCZvcHAtPmxvY2ssIGZsYWdzKTsKIAogCS8qCiAJICogWFhYIFdlIGlnbm9yZSB0 aGUgdGFyZ2V0IGFkZHJlc3MgZm9yIG5vdywgYXMgd2Ugb25seSBzdXBwb3J0CiAJICogICAgIGEg c2luZ2xlIE1TSSBiYW5rLgogCSAqLwogCW9wZW5waWNfbXNpX3dyaXRlKGt2bS0+YXJjaC5tcGlj LCBNU0lJUl9PRkZTRVQsIGUtPm1zaS5kYXRhKTsKLQlzcGluX3VubG9ja19pcnFyZXN0b3JlKCZv cHAtPmxvY2ssIGZsYWdzKTsKKwlyYXdfc3Bpbl91bmxvY2tfaXJxcmVzdG9yZSgmb3BwLT5sb2Nr LCBmbGFncyk7CiAKIAkvKiBBbGwgY29kZSBwYXRocyB3ZSBjYXJlIGFib3V0IGRvbid0IGNoZWNr IGZvciB0aGUgcmV0dXJuIHZhbHVlICovCiAJcmV0dXJuIDA7Ci0tIAoyLjEuNAoKX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX18KTGludXhwcGMtZGV2IG1haWxp bmcgbGlzdApMaW51eHBwYy1kZXZAbGlzdHMub3psYWJzLm9yZwpodHRwczovL2xpc3RzLm96bGFi cy5vcmcvbGlzdGluZm8vbGludXhwcGMtZGV2