From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1752648AbbDAPdj (ORCPT ); Wed, 1 Apr 2015 11:33:39 -0400 Received: from youngberry.canonical.com ([91.189.89.112]:45030 "EHLO youngberry.canonical.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1751053AbbDAPdf (ORCPT ); Wed, 1 Apr 2015 11:33:35 -0400 MIME-Version: 1.0 In-Reply-To: <1427834835-44412-1-git-send-email-jarod@redhat.com> References: <1427834835-44412-1-git-send-email-jarod@redhat.com> Date: Wed, 1 Apr 2015 23:33:17 +0800 Message-ID: Subject: Re: [PATCH] block/loop: improve reliability of partition scanning From: Ming Lei To: Jarod Wilson Cc: Linux Kernel Mailing List , Jens Axboe , Mike Galbraith , Kent Overstreet , Mikulas Patocka Content-Type: multipart/mixed; boundary=047d7b33caf2368aa50512ab6f6a Sender: linux-kernel-owner@vger.kernel.org List-ID: X-Mailing-List: linux-kernel@vger.kernel.org --047d7b33caf2368aa50512ab6f6a Content-Type: text/plain; charset=UTF-8 Hi Jarod, On Wed, Apr 1, 2015 at 4:47 AM, Jarod Wilson wrote: > If losetup is called with the -P option, it sets a flag to have the > resulting loop block device scanned for partitions. Unfortunately, due > to the way flags are passed in from userspace, there's first a > loop_set_fd() call, which does no partition scanning, then a > loop_set_status() call, where the partition scanning should kick in. > However, particularly on a system with slow I/O (such as a file-backed > vm), there's a race between the loop_set_status() call and udev poking the > device, which leads to partition scanning failing with an -EBUSY (passed > up from block/ioctl.c's blkdev_reread_part()) because the block_device's > bd_mutex is already held by udev calling blkdev_open(), which grabs > bd_mutex, and then in turn calls lo_open(), which then in turn tries to > grab lo_ctl_mutex, which we're holding in all loop ioctls. IMO, lo_ctl_mutex can be avoided in lo_open(), and '--lo->lo_refcnt' can be moved out of the lock in lo_release() meantime. > > To combat this, if we discover bd_mutex is locked, we know partition > scanning will fail, and its probably because of udev, so we can > temporarily drop the lo_ctl_mutex ourselves to try to let udev do its > thing, then grab it back, and hopefully then successfully scan partitions. Even with above change, blkdev_reread_part() still might return -EBUSY, and there is no hurt to retry several times. > > Testing shows a definite improvement to partition scanning success when > calling losetup -fP file-image over and over (with matching losetup -D > too, of course), but still not to 100% success, I'm still getting the > occasional failure, which is typically due to an -EBUSY trying to rescan > partitions on loop device removal. This one is because bd_mutex has been held in release path already. Would you mind testing the attached patch which implements the above idea? Thanks, Ming Lei > > CC: Jens Axboe > CC: Ming Lei > CC: Mike Galbraith > CC: Kent Overstreet > CC: Mikulas Patocka > Signed-off-by: Jarod Wilson > --- > drivers/block/loop.c | 48 ++++++++++++++++++++++++++++++++++++++++++++---- > 1 file changed, 44 insertions(+), 4 deletions(-) > > diff --git a/drivers/block/loop.c b/drivers/block/loop.c > index d1f168b..b30e32c 100644 > --- a/drivers/block/loop.c > +++ b/drivers/block/loop.c > @@ -75,6 +75,7 @@ > #include > #include > #include > +#include > #include "loop.h" > > #include > @@ -529,6 +530,45 @@ static int loop_flush(struct loop_device *lo) > } > > /* > + * Re-reading partitions can fail with an -EBUSY return from block/ioctl.c's > + * blkdev_reread_part(), which calls mutex_trylock on the bd_mutex. Now, udev > + * is calling blkdev_open, which first grabs bd_mutex, then lo_ctl_mutex via > + * lo_open, which occasionally happens before partition scanning, and will > + * prevent partition scanning from ever being successful unless we give up > + * the lo_ctl_mutex temporarily. > + */ > +static void loop_reread_partitions(struct loop_device *lo, > + struct block_device *bdev) > +{ > + int rc; > + int retry = 5; > + > + pr_debug("%s: firing for loop%d (%s)\n", > + __func__, lo->lo_number, lo->lo_file_name); > + > + /* > + * If no lo_device, we were (probably) called from loop_clr_fd(), and > + * retries never seem to help, so don't retry. > + */ > + if (!lo->lo_device) > + retry = 1; > + > + while (mutex_is_locked(&bdev->bd_mutex) && retry > 0) { > + mutex_unlock(&lo->lo_ctl_mutex); > + msleep(50); > + mutex_lock(&lo->lo_ctl_mutex); > + retry--; > + pr_debug("%s: unlocked lo_ctl temporarily (retries left: %d)\n", > + __func__, retry); > + } > + > + rc = ioctl_by_bdev(bdev, BLKRRPART, 0); > + if (rc) > + pr_warn("%s: partition scan of loop%d (%s) failed (rc=%d)\n", > + __func__, lo->lo_number, lo->lo_file_name, rc); > +} > + > +/* > * loop_change_fd switched the backing store of a loopback device to > * a new file. This is useful for operating system installers to free up > * the original file and in High Availability environments to switch to > @@ -576,7 +616,7 @@ static int loop_change_fd(struct loop_device *lo, struct block_device *bdev, > > fput(old_file); > if (lo->lo_flags & LO_FLAGS_PARTSCAN) > - ioctl_by_bdev(bdev, BLKRRPART, 0); > + loop_reread_partitions(lo, bdev); > return 0; > > out_putf: > @@ -807,7 +847,7 @@ static int loop_set_fd(struct loop_device *lo, fmode_t mode, > if (part_shift) > lo->lo_flags |= LO_FLAGS_PARTSCAN; > if (lo->lo_flags & LO_FLAGS_PARTSCAN) > - ioctl_by_bdev(bdev, BLKRRPART, 0); > + loop_reread_partitions(lo, bdev); > > /* Grab the block_device to prevent its destruction after we > * put /dev/loopXX inode. Later in loop_clr_fd() we bdput(bdev). > @@ -920,7 +960,7 @@ static int loop_clr_fd(struct loop_device *lo) > /* This is safe: open() is still holding a reference. */ > module_put(THIS_MODULE); > if (lo->lo_flags & LO_FLAGS_PARTSCAN && bdev) > - ioctl_by_bdev(bdev, BLKRRPART, 0); > + loop_reread_partitions(lo, bdev); > lo->lo_flags = 0; > if (!part_shift) > lo->lo_disk->flags |= GENHD_FL_NO_PART_SCAN; > @@ -995,7 +1035,7 @@ loop_set_status(struct loop_device *lo, const struct loop_info64 *info) > !(lo->lo_flags & LO_FLAGS_PARTSCAN)) { > lo->lo_flags |= LO_FLAGS_PARTSCAN; > lo->lo_disk->flags &= ~GENHD_FL_NO_PART_SCAN; > - ioctl_by_bdev(lo->lo_device, BLKRRPART, 0); > + loop_reread_partitions(lo, lo->lo_device); > } > > lo->lo_encrypt_key_size = info->lo_encrypt_key_size; > -- > 1.8.3.1 > --047d7b33caf2368aa50512ab6f6a Content-Type: text/x-patch; charset=US-ASCII; name="0001-block-loop-fix-race-between-open-release-and-reread-.patch" Content-Disposition: attachment; filename="0001-block-loop-fix-race-between-open-release-and-reread-.patch" Content-Transfer-Encoding: base64 X-Attachment-Id: f_i7yw6pa00 RnJvbSA5YWNhMzA5MTllMjBjZTdlMjRhOTdjM2QxNjM5YTY1NGVhY2U1YmEyIE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQpGcm9tOiBNaW5nIExlaSA8bWluZy5sZWlAY2Fub25pY2FsLmNvbT4KRGF0 ZTogVHVlLCAzMSBNYXIgMjAxNSAxNjo0NzoxNSAtMDQwMApTdWJqZWN0OiBbUEFUQ0hdIGJsb2Nr L2xvb3A6IGZpeCByYWNlIGJldHdlZW4gb3Blbi9yZWxlYXNlIGFuZCByZXJlYWQgcGFydAoKV2hl biBhbm90aGVyIHRhc2soc3VjaCBhcyB1ZGV2KSBpcyB0cnlpbmcgdG8gb3Blbi9jbG9zZSBsb29w IGJsb2NrLApibGtkZXZfcmVyZWFkX3BhcnQoKSBtYXkgcmV0dXJuIC1FQlVTWSBiZWNhdXNlIGJk X211dGV4IGlzIHJlcXVpcmVkCmZvciBib3RoIG9wZW4gYW5kIHJlbGVhc2UuIFRoZSB3b3JzZSB0 aGluZyBpcyB0aGF0IGxvX29wZW4oKSBuZWVkCnRvIGhvbGQgbG9fY3RsX211dGV4LCBzbyB0aGUg dGFzayB0cnlpbmcgdG8gb3BlbiBsb29wIGNhbid0IG9wZW4KdGhlIGxvb3AgZGlzayB1bnRpbCBs b19jdGxfbXV0ZXggaXMgcmVsZWFzZWQgd2hlbiByZXJlYWRpbmcgcGFydCBpcwpjb21wbGV0ZWQg d2l0aCBmYWlsdXJlLgoKVGhpcyBwYXRjaCB0cnlzIHRvIGZpeGluZyB0aGUgaXNzdWUgYnkgdGhl IGZvbGxvd2luZyBhcHByb2FjaDoKCjEpIGludHJvZHVjZSBsb19vcGVuX211dGV4IHRvIHByb3Rl Y3QgbG9fcmVmY250IGFuZCBhdm9pZCBhY3F1aXJpbmcKbG9fY3RsX211dGV4IGluIGxvX29wZW4o KToKCS0gZm9yIG9wZW4gdnMuIGFkZC9kZWwgbG9vcCwgbm8gYW55IHByb2JsZW0gYmVjYXVzZSBv ZiBsb29wX2luZGV4X211dGV4CgktIGxvX29wZW5fbXV0ZXggaXMgdXNlZCBmb3Igc3luY2luZyBv cGVuKCkgYW5kIGxvb3BfY2xyX2ZkKCkKCS0gYm90aCBvcGVuKCkgYW5kIHJlbGVhc2UoKSBhcmUg cHJvdGVjdGVkIGJ5IGJkX211dGV4CgoyKSBkb24ndCBob2xkIGxvX2N0bF9tdXRleCBmb3IgZGVj cmVhc2luZy9jaGVja2luZyBsb19yZWZjbnQgaW4gbG9fcmVsZWFzZSgpCgozKSB3aGVuIHJlcmVh ZCBwYXJ0IGlzIHJ1biBpbnNpZGUgcmVsZWFzZSBwYXRoLCByZXNjYW4gcGFydGl0aW9uIGRpcmVj dGx5CnNpbmNlIGJkX211dGV4IGlzIGhlbGQgYWxyZWFkeQoKNCkgcmV0cnkgc2V2ZXJhbCB0aW1l cyBpZiBibGtkZXZfcmVyZWFkX3BhcnQoKSBzdGlsbCByZXR1cm5zIC1FQlVTWS4KCkNDOiBKZW5z IEF4Ym9lIDxheGJvZUBmYi5jb20+CkNDOiBNaW5nIExlaSA8bWluZy5sZWlAY2Fub25pY2FsLmNv bT4KQ0M6IE1pa2UgR2FsYnJhaXRoIDxiaXRidWNrZXRAb25saW5lLmRlPgpDQzogS2VudCBPdmVy c3RyZWV0IDxrbW9AZGF0ZXJhaW5jLmNvbT4KQ0M6IE1pa3VsYXMgUGF0b2NrYSA8bXBhdG9ja2FA cmVkaGF0LmNvbT4KUmVwb3J0ZWQtYnk6IEphcm9kIFdpbHNvbiA8amFyb2RAcmVkaGF0LmNvbT4K U2lnbmVkLW9mZi1ieTogTWluZyBMZWkgPG1pbmcubGVpQGNhbm9uaWNhbC5jb20+Ci0tLQogYmxv Y2svcGFydGl0aW9uLWdlbmVyaWMuYyB8ICAgIDEgKwogZHJpdmVycy9ibG9jay9sb29wLmMgICAg ICB8ICAgODggKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrLS0tLS0tCiBk cml2ZXJzL2Jsb2NrL2xvb3AuaCAgICAgIHwgICAgMSArCiAzIGZpbGVzIGNoYW5nZWQsIDgwIGlu c2VydGlvbnMoKyksIDEwIGRlbGV0aW9ucygtKQoKZGlmZiAtLWdpdCBhL2Jsb2NrL3BhcnRpdGlv bi1nZW5lcmljLmMgYi9ibG9jay9wYXJ0aXRpb24tZ2VuZXJpYy5jCmluZGV4IDBkOWU1ZjkuLjll ZmE2NjcgMTAwNjQ0Ci0tLSBhL2Jsb2NrL3BhcnRpdGlvbi1nZW5lcmljLmMKKysrIGIvYmxvY2sv cGFydGl0aW9uLWdlbmVyaWMuYwpAQCAtNTI4LDYgKzUyOCw3IEBAIHJlc2NhbjoKIAlmcmVlX3Bh cnRpdGlvbnMoc3RhdGUpOwogCXJldHVybiAwOwogfQorRVhQT1JUX1NZTUJPTChyZXNjYW5fcGFy dGl0aW9ucyk7CiAKIGludCBpbnZhbGlkYXRlX3BhcnRpdGlvbnMoc3RydWN0IGdlbmRpc2sgKmRp c2ssIHN0cnVjdCBibG9ja19kZXZpY2UgKmJkZXYpCiB7CmRpZmYgLS1naXQgYS9kcml2ZXJzL2Js b2NrL2xvb3AuYyBiL2RyaXZlcnMvYmxvY2svbG9vcC5jCmluZGV4IGQxZjE2OGIuLjlhOGQ1MmEg MTAwNjQ0Ci0tLSBhL2RyaXZlcnMvYmxvY2svbG9vcC5jCisrKyBiL2RyaXZlcnMvYmxvY2svbG9v cC5jCkBAIC03NSw2ICs3NSw4IEBACiAjaW5jbHVkZSA8bGludXgvc3lzZnMuaD4KICNpbmNsdWRl IDxsaW51eC9taXNjZGV2aWNlLmg+CiAjaW5jbHVkZSA8bGludXgvZmFsbG9jLmg+CisjaW5jbHVk ZSA8bGludXgvZGVsYXkuaD4KKyNpbmNsdWRlIDxsaW51eC9nZW5oZC5oPgogI2luY2x1ZGUgImxv b3AuaCIKIAogI2luY2x1ZGUgPGFzbS91YWNjZXNzLmg+CkBAIC01MjgsNiArNTMwLDUyIEBAIHN0 YXRpYyBpbnQgbG9vcF9mbHVzaChzdHJ1Y3QgbG9vcF9kZXZpY2UgKmxvKQogCXJldHVybiBsb29w X3N3aXRjaChsbywgTlVMTCk7CiB9CiAKK3N0YXRpYyBpbnQgbG9vcF9yZXJlYWRfcGFydF9ub19s b2NrKHN0cnVjdCBibG9ja19kZXZpY2UgKmJkZXYpCit7CisJc3RydWN0IGdlbmRpc2sgKmRpc2sg PSBiZGV2LT5iZF9kaXNrOworCWludCByZXM7CisKKwlpZiAoIWRpc2tfcGFydF9zY2FuX2VuYWJs ZWQoZGlzaykgfHwgYmRldiAhPSBiZGV2LT5iZF9jb250YWlucykKKwkJcmV0dXJuIC1FSU5WQUw7 CisJcmVzID0gcmVzY2FuX3BhcnRpdGlvbnMoZGlzaywgYmRldik7CisJcmV0dXJuIHJlczsKK30K KworLyoKKyAqIFJlLXJlYWRpbmcgcGFydGl0aW9ucyBjYW4gZmFpbCB3aXRoIGFuIC1FQlVTWSBy ZXR1cm4gZnJvbQorICogYmxvY2svaW9jdGwuYydzIGJsa2Rldl9yZXJlYWRfcGFydCgpLCB3aGlj aCBjYWxscyBtdXRleF90cnlsb2NrCisgKiBvbiB0aGUgYmRfbXV0ZXgsIHdoaWNoIGNhbiBiZSBo ZWxkIGluIGJvdGggb3Blbi9yZWxlYXNlIGhhbmRsZXIsCisgKiBzbyByZXRyeSBzZXZlcmFsIHRp bWVzIGZvciB0aGUgc2FrZSBvZiBzYWZldHkuCisgKi8KK3N0YXRpYyB2b2lkIGxvb3BfcmVyZWFk X3BhcnRpdGlvbnMoc3RydWN0IGxvb3BfZGV2aWNlICpsbywKKwkJCQkgICBzdHJ1Y3QgYmxvY2tf ZGV2aWNlICpiZGV2KQoreworCWludCByYywgaW5fcmVsZWFzZTsKKwlpbnQgcmV0cnkgPSA1Owor CisKKwltdXRleF9sb2NrKCZsby0+bG9fb3Blbl9tdXRleCk7CisJaW5fcmVsZWFzZSA9IGxvLT5s b19yZWZjbnQgPT0gMDsKKwltdXRleF91bmxvY2soJmxvLT5sb19vcGVuX211dGV4KTsKKworCS8q IGJkX211dGV4IGhhcyBiZWVuIGhlbGQgYWxyZWFkeSBpbiByZWxlYXNlIHBhdGggKi8KKwlpZiAo aW5fcmVsZWFzZSkgeworCQlyYyA9IGxvb3BfcmVyZWFkX3BhcnRfbm9fbG9jayhiZGV2KTsKKwkJ Z290byBvdXQ7CisJfQorCisJd2hpbGUgKHJldHJ5LS0gPiAwKSB7CisJCXJjID0gaW9jdGxfYnlf YmRldihiZGV2LCBCTEtSUlBBUlQsIDApOworCQlpZiAocmMgIT0gLUVCVVNZKQorCQkJYnJlYWs7 CisJCW1zbGVlcCg1MCk7CisJfQorIG91dDoKKwlpZiAocmMpCisJCXByX3dhcm4oIiVzOiBwYXJ0 aXRpb24gc2NhbiBvZiBsb29wJWQgKCVzKSBmYWlsZWQgKHJjPSVkKVxuIiwKKwkJCV9fZnVuY19f LCBsby0+bG9fbnVtYmVyLCBsby0+bG9fZmlsZV9uYW1lLCByYyk7Cit9CisKIC8qCiAgKiBsb29w X2NoYW5nZV9mZCBzd2l0Y2hlZCB0aGUgYmFja2luZyBzdG9yZSBvZiBhIGxvb3BiYWNrIGRldmlj ZSB0bwogICogYSBuZXcgZmlsZS4gVGhpcyBpcyB1c2VmdWwgZm9yIG9wZXJhdGluZyBzeXN0ZW0g aW5zdGFsbGVycyB0byBmcmVlIHVwCkBAIC01NzYsNyArNjI0LDcgQEAgc3RhdGljIGludCBsb29w X2NoYW5nZV9mZChzdHJ1Y3QgbG9vcF9kZXZpY2UgKmxvLCBzdHJ1Y3QgYmxvY2tfZGV2aWNlICpi ZGV2LAogCiAJZnB1dChvbGRfZmlsZSk7CiAJaWYgKGxvLT5sb19mbGFncyAmIExPX0ZMQUdTX1BB UlRTQ0FOKQotCQlpb2N0bF9ieV9iZGV2KGJkZXYsIEJMS1JSUEFSVCwgMCk7CisJCWxvb3BfcmVy ZWFkX3BhcnRpdGlvbnMobG8sIGJkZXYpOwogCXJldHVybiAwOwogCiAgb3V0X3B1dGY6CkBAIC04 MDcsNyArODU1LDcgQEAgc3RhdGljIGludCBsb29wX3NldF9mZChzdHJ1Y3QgbG9vcF9kZXZpY2Ug KmxvLCBmbW9kZV90IG1vZGUsCiAJaWYgKHBhcnRfc2hpZnQpCiAJCWxvLT5sb19mbGFncyB8PSBM T19GTEFHU19QQVJUU0NBTjsKIAlpZiAobG8tPmxvX2ZsYWdzICYgTE9fRkxBR1NfUEFSVFNDQU4p Ci0JCWlvY3RsX2J5X2JkZXYoYmRldiwgQkxLUlJQQVJULCAwKTsKKwkJbG9vcF9yZXJlYWRfcGFy dGl0aW9ucyhsbywgYmRldik7CiAKIAkvKiBHcmFiIHRoZSBibG9ja19kZXZpY2UgdG8gcHJldmVu dCBpdHMgZGVzdHJ1Y3Rpb24gYWZ0ZXIgd2UKIAkgKiBwdXQgL2Rldi9sb29wWFggaW5vZGUuIExh dGVyIGluIGxvb3BfY2xyX2ZkKCkgd2UgYmRwdXQoYmRldikuCkBAIC04NzksMTQgKzkyNywxOCBA QCBzdGF0aWMgaW50IGxvb3BfY2xyX2ZkKHN0cnVjdCBsb29wX2RldmljZSAqbG8pCiAJICogPGRl dj4vZG8gc29tZXRoaW5nIGxpa2UgbWtmcy9sb3NldHVwIC1kIDxkZXY+IGNhdXNpbmcgdGhlIGxv c2V0dXAgLWQKIAkgKiBjb21tYW5kIHRvIGZhaWwgd2l0aCBFQlVTWS4KIAkgKi8KKwltdXRleF9s b2NrKCZsby0+bG9fb3Blbl9tdXRleCk7CiAJaWYgKGxvLT5sb19yZWZjbnQgPiAxKSB7CisJCW11 dGV4X3VubG9jaygmbG8tPmxvX29wZW5fbXV0ZXgpOwogCQlsby0+bG9fZmxhZ3MgfD0gTE9fRkxB R1NfQVVUT0NMRUFSOwogCQltdXRleF91bmxvY2soJmxvLT5sb19jdGxfbXV0ZXgpOwogCQlyZXR1 cm4gMDsKIAl9CiAKLQlpZiAoZmlscCA9PSBOVUxMKQorCWlmIChmaWxwID09IE5VTEwpIHsKKwkJ bXV0ZXhfdW5sb2NrKCZsby0+bG9fb3Blbl9tdXRleCk7CiAJCXJldHVybiAtRUlOVkFMOworCX0K IAogCXNwaW5fbG9ja19pcnEoJmxvLT5sb19sb2NrKTsKIAlsby0+bG9fc3RhdGUgPSBMb19ydW5k b3duOwpAQCAtOTE5LDggKzk3MSwxNyBAQCBzdGF0aWMgaW50IGxvb3BfY2xyX2ZkKHN0cnVjdCBs b29wX2RldmljZSAqbG8pCiAJbG8tPmxvX3N0YXRlID0gTG9fdW5ib3VuZDsKIAkvKiBUaGlzIGlz IHNhZmU6IG9wZW4oKSBpcyBzdGlsbCBob2xkaW5nIGEgcmVmZXJlbmNlLiAqLwogCW1vZHVsZV9w dXQoVEhJU19NT0RVTEUpOworCisJLyoKKwkgKiBVbmxvY2sgb3Blbl9tdXRleCBmb3IgYXZvaWRp bmcgLUVCVVNZIG9mIHJlcmVhZGluZyBwYXJ0OgorCSAqIC0gdHJ5IHRvIGFjcXVpcmUgYmRfbXV0 ZXggZnJvbSByZXJlYWQgcGFydAorCSAqIC0gYW5vdGhlciB0YXNrIGlzIG9wZW5pbmcgdGhlIGxv b3Agd2l0aCBob2xkaW5nIGJkX211dGV4CisJICogICBhbmQgdHJ5cyB0byBhY3F1aXJlIG9wZW5f bXV0ZXgKKwkgKi8KKwltdXRleF91bmxvY2soJmxvLT5sb19vcGVuX211dGV4KTsKKwogCWlmIChs by0+bG9fZmxhZ3MgJiBMT19GTEFHU19QQVJUU0NBTiAmJiBiZGV2KQotCQlpb2N0bF9ieV9iZGV2 KGJkZXYsIEJMS1JSUEFSVCwgMCk7CisJCWxvb3BfcmVyZWFkX3BhcnRpdGlvbnMobG8sIGJkZXYp OwogCWxvLT5sb19mbGFncyA9IDA7CiAJaWYgKCFwYXJ0X3NoaWZ0KQogCQlsby0+bG9fZGlzay0+ ZmxhZ3MgfD0gR0VOSERfRkxfTk9fUEFSVF9TQ0FOOwpAQCAtOTk1LDcgKzEwNTYsNyBAQCBsb29w X3NldF9zdGF0dXMoc3RydWN0IGxvb3BfZGV2aWNlICpsbywgY29uc3Qgc3RydWN0IGxvb3BfaW5m bzY0ICppbmZvKQogCSAgICAgIShsby0+bG9fZmxhZ3MgJiBMT19GTEFHU19QQVJUU0NBTikpIHsK IAkJbG8tPmxvX2ZsYWdzIHw9IExPX0ZMQUdTX1BBUlRTQ0FOOwogCQlsby0+bG9fZGlzay0+Zmxh Z3MgJj0gfkdFTkhEX0ZMX05PX1BBUlRfU0NBTjsKLQkJaW9jdGxfYnlfYmRldihsby0+bG9fZGV2 aWNlLCBCTEtSUlBBUlQsIDApOworCQlsb29wX3JlcmVhZF9wYXJ0aXRpb25zKGxvLCBsby0+bG9f ZGV2aWNlKTsKIAl9CiAKIAlsby0+bG9fZW5jcnlwdF9rZXlfc2l6ZSA9IGluZm8tPmxvX2VuY3J5 cHRfa2V5X3NpemU7CkBAIC0xMzc2LDkgKzE0MzcsOSBAQCBzdGF0aWMgaW50IGxvX29wZW4oc3Ry dWN0IGJsb2NrX2RldmljZSAqYmRldiwgZm1vZGVfdCBtb2RlKQogCQlnb3RvIG91dDsKIAl9CiAK LQltdXRleF9sb2NrKCZsby0+bG9fY3RsX211dGV4KTsKKwltdXRleF9sb2NrKCZsby0+bG9fb3Bl bl9tdXRleCk7CiAJbG8tPmxvX3JlZmNudCsrOwotCW11dGV4X3VubG9jaygmbG8tPmxvX2N0bF9t dXRleCk7CisJbXV0ZXhfdW5sb2NrKCZsby0+bG9fb3Blbl9tdXRleCk7CiBvdXQ6CiAJbXV0ZXhf dW5sb2NrKCZsb29wX2luZGV4X211dGV4KTsKIAlyZXR1cm4gZXJyOwpAQCAtMTM4NywxMyArMTQ0 OCwxNiBAQCBvdXQ6CiBzdGF0aWMgdm9pZCBsb19yZWxlYXNlKHN0cnVjdCBnZW5kaXNrICpkaXNr LCBmbW9kZV90IG1vZGUpCiB7CiAJc3RydWN0IGxvb3BfZGV2aWNlICpsbyA9IGRpc2stPnByaXZh dGVfZGF0YTsKLQlpbnQgZXJyOworCWludCBlcnIsIHJlZjsKIAotCW11dGV4X2xvY2soJmxvLT5s b19jdGxfbXV0ZXgpOworCW11dGV4X2xvY2soJmxvLT5sb19vcGVuX211dGV4KTsKKwlyZWYgPSAt LWxvLT5sb19yZWZjbnQ7CisJbXV0ZXhfdW5sb2NrKCZsby0+bG9fb3Blbl9tdXRleCk7CiAKLQlp ZiAoLS1sby0+bG9fcmVmY250KQorCWlmIChyZWYpCiAJCWdvdG8gb3V0OwogCisJbXV0ZXhfbG9j aygmbG8tPmxvX2N0bF9tdXRleCk7CiAJaWYgKGxvLT5sb19mbGFncyAmIExPX0ZMQUdTX0FVVE9D TEVBUikgewogCQkvKgogCQkgKiBJbiBhdXRvY2xlYXIgbW9kZSwgc3RvcCB0aGUgbG9vcCB0aHJl YWQKQEAgLTE2NDYsNiArMTcxMCw3IEBAIHN0YXRpYyBpbnQgbG9vcF9hZGQoc3RydWN0IGxvb3Bf ZGV2aWNlICoqbCwgaW50IGkpCiAJCWRpc2stPmZsYWdzIHw9IEdFTkhEX0ZMX05PX1BBUlRfU0NB TjsKIAlkaXNrLT5mbGFncyB8PSBHRU5IRF9GTF9FWFRfREVWVDsKIAltdXRleF9pbml0KCZsby0+ bG9fY3RsX211dGV4KTsKKwltdXRleF9pbml0KCZsby0+bG9fb3Blbl9tdXRleCk7CiAJbG8tPmxv X251bWJlcgkJPSBpOwogCXNwaW5fbG9ja19pbml0KCZsby0+bG9fbG9jayk7CiAJZGlzay0+bWFq b3IJCT0gTE9PUF9NQUpPUjsKQEAgLTE3NjMsMTEgKzE4MjgsMTQgQEAgc3RhdGljIGxvbmcgbG9v cF9jb250cm9sX2lvY3RsKHN0cnVjdCBmaWxlICpmaWxlLCB1bnNpZ25lZCBpbnQgY21kLAogCQkJ bXV0ZXhfdW5sb2NrKCZsby0+bG9fY3RsX211dGV4KTsKIAkJCWJyZWFrOwogCQl9CisJCW11dGV4 X2xvY2soJmxvLT5sb19vcGVuX211dGV4KTsKIAkJaWYgKGxvLT5sb19yZWZjbnQgPiAwKSB7CiAJ CQlyZXQgPSAtRUJVU1k7CisJCQltdXRleF91bmxvY2soJmxvLT5sb19vcGVuX211dGV4KTsKIAkJ CW11dGV4X3VubG9jaygmbG8tPmxvX2N0bF9tdXRleCk7CiAJCQlicmVhazsKIAkJfQorCQltdXRl eF91bmxvY2soJmxvLT5sb19vcGVuX211dGV4KTsKIAkJbG8tPmxvX2Rpc2stPnByaXZhdGVfZGF0 YSA9IE5VTEw7CiAJCW11dGV4X3VubG9jaygmbG8tPmxvX2N0bF9tdXRleCk7CiAJCWlkcl9yZW1v dmUoJmxvb3BfaW5kZXhfaWRyLCBsby0+bG9fbnVtYmVyKTsKZGlmZiAtLWdpdCBhL2RyaXZlcnMv YmxvY2svbG9vcC5oIGIvZHJpdmVycy9ibG9jay9sb29wLmgKaW5kZXggMzAxYzI3Zi4uMWI0YWNm MiAxMDA2NDQKLS0tIGEvZHJpdmVycy9ibG9jay9sb29wLmgKKysrIGIvZHJpdmVycy9ibG9jay9s b29wLmgKQEAgLTU5LDYgKzU5LDcgQEAgc3RydWN0IGxvb3BfZGV2aWNlIHsKIAlib29sCQkJd3Jp dGVfc3RhcnRlZDsKIAlpbnQJCQlsb19zdGF0ZTsKIAlzdHJ1Y3QgbXV0ZXgJCWxvX2N0bF9tdXRl eDsKKwlzdHJ1Y3QgbXV0ZXgJCWxvX29wZW5fbXV0ZXg7CiAKIAlzdHJ1Y3QgcmVxdWVzdF9xdWV1 ZQkqbG9fcXVldWU7CiAJc3RydWN0IGJsa19tcV90YWdfc2V0CXRhZ19zZXQ7Ci0tIAoxLjcuOS41 Cgo= --047d7b33caf2368aa50512ab6f6a--