From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1754507Ab3CRQw3 (ORCPT ); Mon, 18 Mar 2013 12:52:29 -0400 Received: from smtp.eu.citrix.com ([46.33.159.39]:57578 "EHLO SMTP.EU.CITRIX.COM" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1754414Ab3CRQvR (ORCPT ); Mon, 18 Mar 2013 12:51:17 -0400 X-IronPort-AV: E=Sophos;i="4.84,865,1355097600"; d="scan'208";a="2617150" From: Roger Pau Monne To: , CC: Roger Pau Monne , Konrad Rzeszutek Wilk Subject: [PATCH 3/5] xen-blkfront: switch from llist to list Date: Mon, 18 Mar 2013 17:49:34 +0100 Message-ID: <1363625376-35612-4-git-send-email-roger.pau@citrix.com> X-Mailer: git-send-email 1.7.7.5 (Apple Git-26) In-Reply-To: <1363625376-35612-1-git-send-email-roger.pau@citrix.com> References: <1363625376-35612-1-git-send-email-roger.pau@citrix.com> MIME-Version: 1.0 Content-Type: text/plain; charset="UTF-8" Content-Transfer-Encoding: 8bit Sender: linux-kernel-owner@vger.kernel.org List-ID: X-Mailing-List: linux-kernel@vger.kernel.org Replace the use of llist with list. llist_for_each_entry_safe can trigger a bug in GCC 4.1, so it's best to remove it and use a doubly linked list, which is used extensively in the kernel already. Specifically this bug can be triggered by hot-unplugging a disk, either by doing xm block-detach or by save/restore cycle. BUG: unable to handle kernel paging request at fffffffffffffff0 IP: [] blkif_free+0x63/0x130 [xen_blkfront] The crash call trace is: ... bad_area_nosemaphore+0x13/0x20 do_page_fault+0x25e/0x4b0 page_fault+0x25/0x30 ? blkif_free+0x63/0x130 [xen_blkfront] blkfront_resume+0x46/0xa0 [xen_blkfront] xenbus_dev_resume+0x6c/0x140 pm_op+0x192/0x1b0 device_resume+0x82/0x1e0 dpm_resume+0xc9/0x1a0 dpm_resume_end+0x15/0x30 do_suspend+0x117/0x1e0 When drilling down to the assembler code, on newer GCC it does .L29: cmpq $-16, %r12 #, persistent_gnt check je .L30 #, out of the loop .L25: ... code in the loop testq %r13, %r13 # n je .L29 #, back to the top of the loop cmpq $-16, %r12 #, persistent_gnt check movq 16(%r12), %r13 # .node.next, n jne .L25 #, back to the top of the loop .L30: While on GCC 4.1, it is: L78: ... code in the loop testq %r13, %r13 # n je .L78 #, back to the top of the loop movq 16(%rbx), %r13 # .node.next, n jmp .L78 #, back to the top of the loop Which basically means that the exit loop condition instead of being: &(pos)->member != NULL; is: ; which makes the loop unbound. Since we always manipulate the list while holding the io_lock, there's no need for additional locking (llist used previously is safe to use concurrently without additional locking). Should be backported to 3.8 stable. Signed-off-by: Roger Pau Monné [Part of the description] Signed-off-by: Konrad Rzeszutek Wilk Cc: xen-devel@lists.xen.org --- drivers/block/xen-blkfront.c | 41 ++++++++++++++++++----------------------- 1 files changed, 18 insertions(+), 23 deletions(-) diff --git a/drivers/block/xen-blkfront.c b/drivers/block/xen-blkfront.c index 9620644..97324cd1 100644 --- a/drivers/block/xen-blkfront.c +++ b/drivers/block/xen-blkfront.c @@ -44,7 +44,7 @@ #include #include #include -#include +#include #include #include @@ -68,7 +68,7 @@ enum blkif_state { struct grant { grant_ref_t gref; unsigned long pfn; - struct llist_node node; + struct list_head node; }; struct blk_shadow { @@ -105,7 +105,7 @@ struct blkfront_info struct work_struct work; struct gnttab_free_callback callback; struct blk_shadow shadow[BLK_RING_SIZE]; - struct llist_head persistent_gnts; + struct list_head persistent_gnts; unsigned int persistent_gnts_c; unsigned long shadow_free; unsigned int feature_flush; @@ -371,10 +371,11 @@ static int blkif_queue_request(struct request *req) lsect = fsect + (sg->length >> 9) - 1; if (info->persistent_gnts_c) { - BUG_ON(llist_empty(&info->persistent_gnts)); - gnt_list_entry = llist_entry( - llist_del_first(&info->persistent_gnts), - struct grant, node); + BUG_ON(list_empty(&info->persistent_gnts)); + gnt_list_entry = list_first_entry( + &info->persistent_gnts, + struct grant, node); + list_del(&gnt_list_entry->node); ref = gnt_list_entry->gref; buffer_mfn = pfn_to_mfn(gnt_list_entry->pfn); @@ -790,9 +791,8 @@ static void blkif_restart_queue(struct work_struct *work) static void blkif_free(struct blkfront_info *info, int suspend) { - struct llist_node *all_gnts; - struct grant *persistent_gnt, *tmp; - struct llist_node *n; + struct grant *persistent_gnt; + struct grant *n; /* Prevent new requests being issued until we fix things up. */ spin_lock_irq(&info->io_lock); @@ -804,20 +804,15 @@ static void blkif_free(struct blkfront_info *info, int suspend) /* Remove all persistent grants */ if (info->persistent_gnts_c) { - all_gnts = llist_del_all(&info->persistent_gnts); - persistent_gnt = llist_entry(all_gnts, typeof(*(persistent_gnt)), node); - while (persistent_gnt) { + list_for_each_entry_safe(persistent_gnt, n, + &info->persistent_gnts, node) { + list_del(&persistent_gnt->node); gnttab_end_foreign_access(persistent_gnt->gref, 0, 0UL); __free_page(pfn_to_page(persistent_gnt->pfn)); - tmp = persistent_gnt; - n = persistent_gnt->node.next; - if (n) - persistent_gnt = llist_entry(n, typeof(*(persistent_gnt)), node); - else - persistent_gnt = NULL; - kfree(tmp); + kfree(persistent_gnt); + info->persistent_gnts_c--; } - info->persistent_gnts_c = 0; + BUG_ON(info->persistent_gnts_c != 0); } /* No more gnttab callback work. */ @@ -875,7 +870,7 @@ static void blkif_completion(struct blk_shadow *s, struct blkfront_info *info, } /* Add the persistent grant into the list of free grants */ for (i = 0; i < s->req.u.rw.nr_segments; i++) { - llist_add(&s->grants_used[i]->node, &info->persistent_gnts); + list_add(&s->grants_used[i]->node, &info->persistent_gnts); info->persistent_gnts_c++; } } @@ -1171,7 +1166,7 @@ static int blkfront_probe(struct xenbus_device *dev, spin_lock_init(&info->io_lock); info->xbdev = dev; info->vdevice = vdevice; - init_llist_head(&info->persistent_gnts); + INIT_LIST_HEAD(&info->persistent_gnts); info->persistent_gnts_c = 0; info->connected = BLKIF_STATE_DISCONNECTED; INIT_WORK(&info->work, blkif_restart_queue); -- 1.7.7.5 (Apple Git-26) From mboxrd@z Thu Jan 1 00:00:00 1970 From: Roger Pau Monne Subject: [PATCH 3/5] xen-blkfront: switch from llist to list Date: Mon, 18 Mar 2013 17:49:34 +0100 Message-ID: <1363625376-35612-4-git-send-email-roger.pau@citrix.com> References: <1363625376-35612-1-git-send-email-roger.pau@citrix.com> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Return-path: In-Reply-To: <1363625376-35612-1-git-send-email-roger.pau@citrix.com> List-Unsubscribe: , List-Post: List-Help: List-Subscribe: , Sender: xen-devel-bounces@lists.xen.org Errors-To: xen-devel-bounces@lists.xen.org To: xen-devel@lists.xen.org, linux-kernel@vger.kernel.org Cc: Konrad Rzeszutek Wilk , Roger Pau Monne List-Id: xen-devel@lists.xenproject.org UmVwbGFjZSB0aGUgdXNlIG9mIGxsaXN0IHdpdGggbGlzdC4KCmxsaXN0X2Zvcl9lYWNoX2VudHJ5 X3NhZmUgY2FuIHRyaWdnZXIgYSBidWcgaW4gR0NDIDQuMSwgc28gaXQncyBiZXN0CnRvIHJlbW92 ZSBpdCBhbmQgdXNlIGEgZG91Ymx5IGxpbmtlZCBsaXN0LCB3aGljaCBpcyB1c2VkIGV4dGVuc2l2 ZWx5CmluIHRoZSBrZXJuZWwgYWxyZWFkeS4KClNwZWNpZmljYWxseSB0aGlzIGJ1ZyBjYW4gYmUg dHJpZ2dlcmVkIGJ5IGhvdC11bnBsdWdnaW5nIGEgZGlzaywKZWl0aGVyIGJ5IGRvaW5nIHhtIGJs b2NrLWRldGFjaCBvciBieSBzYXZlL3Jlc3RvcmUgY3ljbGUuCgpCVUc6IHVuYWJsZSB0byBoYW5k bGUga2VybmVsIHBhZ2luZyByZXF1ZXN0IGF0IGZmZmZmZmZmZmZmZmZmZjAKSVA6IFs8ZmZmZmZm ZmZhMDA0NzIyMz5dIGJsa2lmX2ZyZWUrMHg2My8weDEzMCBbeGVuX2Jsa2Zyb250XQpUaGUgY3Jh c2ggY2FsbCB0cmFjZSBpczoKCS4uLgpiYWRfYXJlYV9ub3NlbWFwaG9yZSsweDEzLzB4MjAKZG9f cGFnZV9mYXVsdCsweDI1ZS8weDRiMApwYWdlX2ZhdWx0KzB4MjUvMHgzMAo/IGJsa2lmX2ZyZWUr MHg2My8weDEzMCBbeGVuX2Jsa2Zyb250XQpibGtmcm9udF9yZXN1bWUrMHg0Ni8weGEwIFt4ZW5f YmxrZnJvbnRdCnhlbmJ1c19kZXZfcmVzdW1lKzB4NmMvMHgxNDAKcG1fb3ArMHgxOTIvMHgxYjAK ZGV2aWNlX3Jlc3VtZSsweDgyLzB4MWUwCmRwbV9yZXN1bWUrMHhjOS8weDFhMApkcG1fcmVzdW1l X2VuZCsweDE1LzB4MzAKZG9fc3VzcGVuZCsweDExNy8weDFlMAoKV2hlbiBkcmlsbGluZyBkb3du IHRvIHRoZSBhc3NlbWJsZXIgY29kZSwgb24gbmV3ZXIgR0NDIGl0IGRvZXMKLkwyOToKICAgICAg ICBjbXBxICAgICQtMTYsICVyMTIgICAgICAjLCBwZXJzaXN0ZW50X2dudCBjaGVjawogICAgICAg IGplICAgICAgLkwzMCAgICAJIywgb3V0IG9mIHRoZSBsb29wCi5MMjU6CgkuLi4gY29kZSBpbiB0 aGUgbG9vcAogICAgICAgIHRlc3RxICAgJXIxMywgJXIxMyAgICAgICMgbgogICAgICAgIGplICAg ICAgLkwyOSAgICAJIywgYmFjayB0byB0aGUgdG9wIG9mIHRoZSBsb29wCiAgICAgICAgY21wcSAg ICAkLTE2LCAlcjEyICAgICAgIywgcGVyc2lzdGVudF9nbnQgY2hlY2sKICAgICAgICBtb3ZxICAg IDE2KCVyMTIpLCAlcjEzICAjIDx2YXJpYWJsZT4ubm9kZS5uZXh0LCBuCiAgICAgICAgam5lICAg ICAuTDI1ICAgIAkjLAliYWNrIHRvIHRoZSB0b3Agb2YgdGhlIGxvb3AKLkwzMDoKCldoaWxlIG9u IEdDQyA0LjEsIGl0IGlzOgpMNzg6CgkuLi4gY29kZSBpbiB0aGUgbG9vcAoJdGVzdHEgICAlcjEz LCAlcjEzICAgICAgIyBuCiAgICAgICAgamUgICAgICAuTDc4ICAgICMsCWJhY2sgdG8gdGhlIHRv cCBvZiB0aGUgbG9vcAogICAgICAgIG1vdnEgICAgMTYoJXJieCksICVyMTMgICMgPHZhcmlhYmxl Pi5ub2RlLm5leHQsIG4KICAgICAgICBqbXAgICAgIC5MNzggICAgIywJYmFjayB0byB0aGUgdG9w IG9mIHRoZSBsb29wCgpXaGljaCBiYXNpY2FsbHkgbWVhbnMgdGhhdCB0aGUgZXhpdCBsb29wIGNv bmRpdGlvbiBpbnN0ZWFkIG9mCmJlaW5nOgoKCSYocG9zKS0+bWVtYmVyICE9IE5VTEw7CgppczoK CTsKCndoaWNoIG1ha2VzIHRoZSBsb29wIHVuYm91bmQuCgpTaW5jZSB3ZSBhbHdheXMgbWFuaXB1 bGF0ZSB0aGUgbGlzdCB3aGlsZSBob2xkaW5nIHRoZSBpb19sb2NrLCB0aGVyZSdzCm5vIG5lZWQg Zm9yIGFkZGl0aW9uYWwgbG9ja2luZyAobGxpc3QgdXNlZCBwcmV2aW91c2x5IGlzIHNhZmUgdG8g dXNlCmNvbmN1cnJlbnRseSB3aXRob3V0IGFkZGl0aW9uYWwgbG9ja2luZykuCgpTaG91bGQgYmUg YmFja3BvcnRlZCB0byAzLjggc3RhYmxlLgoKU2lnbmVkLW9mZi1ieTogUm9nZXIgUGF1IE1vbm7D qSA8cm9nZXIucGF1QGNpdHJpeC5jb20+CltQYXJ0IG9mIHRoZSBkZXNjcmlwdGlvbl0KU2lnbmVk LW9mZi1ieTogS29ucmFkIFJ6ZXN6dXRlayBXaWxrIDxrb25yYWQud2lsa0BvcmFjbGUuY29tPgpD YzogeGVuLWRldmVsQGxpc3RzLnhlbi5vcmcKLS0tCiBkcml2ZXJzL2Jsb2NrL3hlbi1ibGtmcm9u dC5jIHwgICA0MSArKysrKysrKysrKysrKysrKystLS0tLS0tLS0tLS0tLS0tLS0tLS0tLQogMSBm aWxlcyBjaGFuZ2VkLCAxOCBpbnNlcnRpb25zKCspLCAyMyBkZWxldGlvbnMoLSkKCmRpZmYgLS1n aXQgYS9kcml2ZXJzL2Jsb2NrL3hlbi1ibGtmcm9udC5jIGIvZHJpdmVycy9ibG9jay94ZW4tYmxr ZnJvbnQuYwppbmRleCA5NjIwNjQ0Li45NzMyNGNkMSAxMDA2NDQKLS0tIGEvZHJpdmVycy9ibG9j ay94ZW4tYmxrZnJvbnQuYworKysgYi9kcml2ZXJzL2Jsb2NrL3hlbi1ibGtmcm9udC5jCkBAIC00 NCw3ICs0NCw3IEBACiAjaW5jbHVkZSA8bGludXgvbXV0ZXguaD4KICNpbmNsdWRlIDxsaW51eC9z Y2F0dGVybGlzdC5oPgogI2luY2x1ZGUgPGxpbnV4L2JpdG1hcC5oPgotI2luY2x1ZGUgPGxpbnV4 L2xsaXN0Lmg+CisjaW5jbHVkZSA8bGludXgvbGlzdC5oPgogCiAjaW5jbHVkZSA8eGVuL3hlbi5o PgogI2luY2x1ZGUgPHhlbi94ZW5idXMuaD4KQEAgLTY4LDcgKzY4LDcgQEAgZW51bSBibGtpZl9z dGF0ZSB7CiBzdHJ1Y3QgZ3JhbnQgewogCWdyYW50X3JlZl90IGdyZWY7CiAJdW5zaWduZWQgbG9u ZyBwZm47Ci0Jc3RydWN0IGxsaXN0X25vZGUgbm9kZTsKKwlzdHJ1Y3QgbGlzdF9oZWFkIG5vZGU7 CiB9OwogCiBzdHJ1Y3QgYmxrX3NoYWRvdyB7CkBAIC0xMDUsNyArMTA1LDcgQEAgc3RydWN0IGJs a2Zyb250X2luZm8KIAlzdHJ1Y3Qgd29ya19zdHJ1Y3Qgd29yazsKIAlzdHJ1Y3QgZ250dGFiX2Zy ZWVfY2FsbGJhY2sgY2FsbGJhY2s7CiAJc3RydWN0IGJsa19zaGFkb3cgc2hhZG93W0JMS19SSU5H X1NJWkVdOwotCXN0cnVjdCBsbGlzdF9oZWFkIHBlcnNpc3RlbnRfZ250czsKKwlzdHJ1Y3QgbGlz dF9oZWFkIHBlcnNpc3RlbnRfZ250czsKIAl1bnNpZ25lZCBpbnQgcGVyc2lzdGVudF9nbnRzX2M7 CiAJdW5zaWduZWQgbG9uZyBzaGFkb3dfZnJlZTsKIAl1bnNpZ25lZCBpbnQgZmVhdHVyZV9mbHVz aDsKQEAgLTM3MSwxMCArMzcxLDExIEBAIHN0YXRpYyBpbnQgYmxraWZfcXVldWVfcmVxdWVzdChz dHJ1Y3QgcmVxdWVzdCAqcmVxKQogCQkJbHNlY3QgPSBmc2VjdCArIChzZy0+bGVuZ3RoID4+IDkp IC0gMTsKIAogCQkJaWYgKGluZm8tPnBlcnNpc3RlbnRfZ250c19jKSB7Ci0JCQkJQlVHX09OKGxs aXN0X2VtcHR5KCZpbmZvLT5wZXJzaXN0ZW50X2dudHMpKTsKLQkJCQlnbnRfbGlzdF9lbnRyeSA9 IGxsaXN0X2VudHJ5KAotCQkJCQlsbGlzdF9kZWxfZmlyc3QoJmluZm8tPnBlcnNpc3RlbnRfZ250 cyksCi0JCQkJCXN0cnVjdCBncmFudCwgbm9kZSk7CisJCQkJQlVHX09OKGxpc3RfZW1wdHkoJmlu Zm8tPnBlcnNpc3RlbnRfZ250cykpOworCQkJCWdudF9saXN0X2VudHJ5ID0gbGlzdF9maXJzdF9l bnRyeSgKKwkJCQkgICAgICAgICAgICAgICAgICAgICAgJmluZm8tPnBlcnNpc3RlbnRfZ250cywK KwkJCQkgICAgICAgICAgICAgICAgICAgICAgc3RydWN0IGdyYW50LCBub2RlKTsKKwkJCQlsaXN0 X2RlbCgmZ250X2xpc3RfZW50cnktPm5vZGUpOwogCiAJCQkJcmVmID0gZ250X2xpc3RfZW50cnkt PmdyZWY7CiAJCQkJYnVmZmVyX21mbiA9IHBmbl90b19tZm4oZ250X2xpc3RfZW50cnktPnBmbik7 CkBAIC03OTAsOSArNzkxLDggQEAgc3RhdGljIHZvaWQgYmxraWZfcmVzdGFydF9xdWV1ZShzdHJ1 Y3Qgd29ya19zdHJ1Y3QgKndvcmspCiAKIHN0YXRpYyB2b2lkIGJsa2lmX2ZyZWUoc3RydWN0IGJs a2Zyb250X2luZm8gKmluZm8sIGludCBzdXNwZW5kKQogewotCXN0cnVjdCBsbGlzdF9ub2RlICph bGxfZ250czsKLQlzdHJ1Y3QgZ3JhbnQgKnBlcnNpc3RlbnRfZ250LCAqdG1wOwotCXN0cnVjdCBs bGlzdF9ub2RlICpuOworCXN0cnVjdCBncmFudCAqcGVyc2lzdGVudF9nbnQ7CisJc3RydWN0IGdy YW50ICpuOwogCiAJLyogUHJldmVudCBuZXcgcmVxdWVzdHMgYmVpbmcgaXNzdWVkIHVudGlsIHdl IGZpeCB0aGluZ3MgdXAuICovCiAJc3Bpbl9sb2NrX2lycSgmaW5mby0+aW9fbG9jayk7CkBAIC04 MDQsMjAgKzgwNCwxNSBAQCBzdGF0aWMgdm9pZCBibGtpZl9mcmVlKHN0cnVjdCBibGtmcm9udF9p bmZvICppbmZvLCBpbnQgc3VzcGVuZCkKIAogCS8qIFJlbW92ZSBhbGwgcGVyc2lzdGVudCBncmFu dHMgKi8KIAlpZiAoaW5mby0+cGVyc2lzdGVudF9nbnRzX2MpIHsKLQkJYWxsX2dudHMgPSBsbGlz dF9kZWxfYWxsKCZpbmZvLT5wZXJzaXN0ZW50X2dudHMpOwotCQlwZXJzaXN0ZW50X2dudCA9IGxs aXN0X2VudHJ5KGFsbF9nbnRzLCB0eXBlb2YoKihwZXJzaXN0ZW50X2dudCkpLCBub2RlKTsKLQkJ d2hpbGUgKHBlcnNpc3RlbnRfZ250KSB7CisJCWxpc3RfZm9yX2VhY2hfZW50cnlfc2FmZShwZXJz aXN0ZW50X2dudCwgbiwKKwkJICAgICAgICAgICAgICAgICAgICAgICAgICZpbmZvLT5wZXJzaXN0 ZW50X2dudHMsIG5vZGUpIHsKKwkJCWxpc3RfZGVsKCZwZXJzaXN0ZW50X2dudC0+bm9kZSk7CiAJ CQlnbnR0YWJfZW5kX2ZvcmVpZ25fYWNjZXNzKHBlcnNpc3RlbnRfZ250LT5ncmVmLCAwLCAwVUwp OwogCQkJX19mcmVlX3BhZ2UocGZuX3RvX3BhZ2UocGVyc2lzdGVudF9nbnQtPnBmbikpOwotCQkJ dG1wID0gcGVyc2lzdGVudF9nbnQ7Ci0JCQluID0gcGVyc2lzdGVudF9nbnQtPm5vZGUubmV4dDsK LQkJCWlmIChuKQotCQkJCXBlcnNpc3RlbnRfZ250ID0gbGxpc3RfZW50cnkobiwgdHlwZW9mKCoo cGVyc2lzdGVudF9nbnQpKSwgbm9kZSk7Ci0JCQllbHNlCi0JCQkJcGVyc2lzdGVudF9nbnQgPSBO VUxMOwotCQkJa2ZyZWUodG1wKTsKKwkJCWtmcmVlKHBlcnNpc3RlbnRfZ250KTsKKwkJCWluZm8t PnBlcnNpc3RlbnRfZ250c19jLS07CiAJCX0KLQkJaW5mby0+cGVyc2lzdGVudF9nbnRzX2MgPSAw OworCQlCVUdfT04oaW5mby0+cGVyc2lzdGVudF9nbnRzX2MgIT0gMCk7CiAJfQogCiAJLyogTm8g bW9yZSBnbnR0YWIgY2FsbGJhY2sgd29yay4gKi8KQEAgLTg3NSw3ICs4NzAsNyBAQCBzdGF0aWMg dm9pZCBibGtpZl9jb21wbGV0aW9uKHN0cnVjdCBibGtfc2hhZG93ICpzLCBzdHJ1Y3QgYmxrZnJv bnRfaW5mbyAqaW5mbywKIAl9CiAJLyogQWRkIHRoZSBwZXJzaXN0ZW50IGdyYW50IGludG8gdGhl IGxpc3Qgb2YgZnJlZSBncmFudHMgKi8KIAlmb3IgKGkgPSAwOyBpIDwgcy0+cmVxLnUucncubnJf c2VnbWVudHM7IGkrKykgewotCQlsbGlzdF9hZGQoJnMtPmdyYW50c191c2VkW2ldLT5ub2RlLCAm aW5mby0+cGVyc2lzdGVudF9nbnRzKTsKKwkJbGlzdF9hZGQoJnMtPmdyYW50c191c2VkW2ldLT5u b2RlLCAmaW5mby0+cGVyc2lzdGVudF9nbnRzKTsKIAkJaW5mby0+cGVyc2lzdGVudF9nbnRzX2Mr KzsKIAl9CiB9CkBAIC0xMTcxLDcgKzExNjYsNyBAQCBzdGF0aWMgaW50IGJsa2Zyb250X3Byb2Jl KHN0cnVjdCB4ZW5idXNfZGV2aWNlICpkZXYsCiAJc3Bpbl9sb2NrX2luaXQoJmluZm8tPmlvX2xv Y2spOwogCWluZm8tPnhiZGV2ID0gZGV2OwogCWluZm8tPnZkZXZpY2UgPSB2ZGV2aWNlOwotCWlu aXRfbGxpc3RfaGVhZCgmaW5mby0+cGVyc2lzdGVudF9nbnRzKTsKKwlJTklUX0xJU1RfSEVBRCgm aW5mby0+cGVyc2lzdGVudF9nbnRzKTsKIAlpbmZvLT5wZXJzaXN0ZW50X2dudHNfYyA9IDA7CiAJ aW5mby0+Y29ubmVjdGVkID0gQkxLSUZfU1RBVEVfRElTQ09OTkVDVEVEOwogCUlOSVRfV09SSygm aW5mby0+d29yaywgYmxraWZfcmVzdGFydF9xdWV1ZSk7Ci0tIAoxLjcuNy41IChBcHBsZSBHaXQt MjYpCgoKX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX18KWGVu LWRldmVsIG1haWxpbmcgbGlzdApYZW4tZGV2ZWxAbGlzdHMueGVuLm9yZwpodHRwOi8vbGlzdHMu eGVuLm9yZy94ZW4tZGV2ZWwK