From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1753972AbeEaGbo (ORCPT ); Thu, 31 May 2018 02:31:44 -0400 Received: from mail.kernel.org ([198.145.29.99]:55884 "EHLO mail.kernel.org" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1753740AbeEaGbl (ORCPT ); Thu, 31 May 2018 02:31:41 -0400 Date: Thu, 31 May 2018 08:31:18 +0200 From: Greg KH To: Alan Stern Cc: Martin Liu , heikki.krogerus@linux.intel.com, johan@kernel.org, andy.shevchenko@gmail.com, linux-kernel@vger.kernel.org, linux-usb@vger.kernel.org, jenhaochen@google.com Subject: Re: [PATCH v4] driver core: hold dev's parent lock when needed Message-ID: <20180531063118.GA7554@kroah.com> References: <20180530163135.50081-1-liumartin@google.com> MIME-Version: 1.0 Content-Type: text/plain; charset=us-ascii Content-Disposition: inline In-Reply-To: User-Agent: Mutt/1.10.0 (2018-05-17) Sender: linux-kernel-owner@vger.kernel.org List-ID: X-Mailing-List: linux-kernel@vger.kernel.org On Wed, May 30, 2018 at 01:21:02PM -0400, Alan Stern wrote: > On Thu, 31 May 2018, Martin Liu wrote: > > > SoC have internal I/O buses that can't be proved for devices. The > > devices on the buses can be accessed directly without additinal > > configuration required. This type of bus is represented as > > "simple-bus". In some platforms, we name "soc" with "simple-bus" > > attribute and many devices are hooked under it described in DT > > (device tree). > > > > In commit bf74ad5bc417 ("Hold the device's parent's lock during > > probe and remove") to solve USB subsystem lock sequence since > > USB device's characteristic. Thus "soc" needs to be locked > > whenever a device and driver's probing happen under "soc" bus. > > During this period, an async driver tries to probe a device which > > is under the "soc" bus would be blocked until previous driver > > finish the probing and release "soc" lock. And the next probing > > under the "soc" bus need to wait for async finish. Because of > > that, driver's async probe for init time improvement will be > > shadowed. > > > > Since many devices don't have USB devices' characteristic, they > > actually don't need parent's lock. Thus, we introduce a lock flag > > in bus_type struct and driver core would lock the parent lock base > > on the flag. For USB, we set this flag in usb_bus_type to keep > > original lock behavior in driver core. > > > > Async probe could have more benefit after this patch. > > > > Signed-off-by: Martin Liu > > --- > > Changes in v4: > > -fix comment and wording. > > -follow the suggestion. > > > > [v3]: https://lkml.org/lkml/2018/5/29/876 > > [v2]: https://lkml.org/lkml/2018/5/29/108 > > [v1]: https://lkml.org/lkml/2018/5/22/545 > > > > drivers/base/bus.c | 16 ++++++++-------- > > drivers/base/dd.c | 8 ++++---- > > drivers/usb/core/driver.c | 1 + > > include/linux/device.h | 3 +++ > > 4 files changed, 16 insertions(+), 12 deletions(-) > > > > diff --git a/drivers/base/bus.c b/drivers/base/bus.c > > index ef6183306b40..8bfd27ec73d6 100644 > > --- a/drivers/base/bus.c > > +++ b/drivers/base/bus.c > > @@ -184,10 +184,10 @@ static ssize_t unbind_store(struct device_driver *drv, const char *buf, > > > > dev = bus_find_device_by_name(bus, NULL, buf); > > if (dev && dev->driver == drv) { > > - if (dev->parent) /* Needed for USB */ > > + if (dev->parent && dev->bus->need_parent_lock) > > device_lock(dev->parent); > > device_release_driver(dev); > > - if (dev->parent) > > + if (dev->parent && dev->bus->need_parent_lock) > > device_unlock(dev->parent); > > err = count; > > } > > @@ -211,12 +211,12 @@ static ssize_t bind_store(struct device_driver *drv, const char *buf, > > > > dev = bus_find_device_by_name(bus, NULL, buf); > > if (dev && dev->driver == NULL && driver_match_device(drv, dev)) { > > - if (dev->parent) /* Needed for USB */ > > + if (dev->parent && bus->need_parent_lock) > > device_lock(dev->parent); > > device_lock(dev); > > err = driver_probe_device(drv, dev); > > device_unlock(dev); > > - if (dev->parent) > > + if (dev->parent && bus->need_parent_lock) > > device_unlock(dev->parent); > > > > if (err > 0) { > > @@ -735,10 +735,10 @@ static int __must_check bus_rescan_devices_helper(struct device *dev, > > int ret = 0; > > > > if (!dev->driver) { > > - if (dev->parent) /* Needed for USB */ > > + if (dev->parent && dev->bus->need_parent_lock) > > device_lock(dev->parent); > > ret = device_attach(dev); > > - if (dev->parent) > > + if (dev->parent && dev->bus->need_parent_lock) > > device_unlock(dev->parent); > > } > > return ret < 0 ? ret : 0; > > @@ -770,10 +770,10 @@ EXPORT_SYMBOL_GPL(bus_rescan_devices); > > int device_reprobe(struct device *dev) > > { > > if (dev->driver) { > > - if (dev->parent) /* Needed for USB */ > > + if (dev->parent && dev->bus->need_parent_lock) > > device_lock(dev->parent); > > device_release_driver(dev); > > - if (dev->parent) > > + if (dev->parent && dev->bus->need_parent_lock) > > device_unlock(dev->parent); > > } > > return bus_rescan_devices_helper(dev, NULL); > > diff --git a/drivers/base/dd.c b/drivers/base/dd.c > > index c9f54089429b..7c09f73b96f3 100644 > > --- a/drivers/base/dd.c > > +++ b/drivers/base/dd.c > > @@ -817,13 +817,13 @@ static int __driver_attach(struct device *dev, void *data) > > return ret; > > } /* ret > 0 means positive match */ > > > > - if (dev->parent) /* Needed for USB */ > > + if (dev->parent && dev->bus->need_parent_lock) > > device_lock(dev->parent); > > device_lock(dev); > > if (!dev->driver) > > driver_probe_device(drv, dev); > > device_unlock(dev); > > - if (dev->parent) > > + if (dev->parent && dev->bus->need_parent_lock) > > device_unlock(dev->parent); > > > > return 0; > > @@ -919,7 +919,7 @@ void device_release_driver_internal(struct device *dev, > > struct device_driver *drv, > > struct device *parent) > > { > > - if (parent) > > + if (parent && dev->bus->need_parent_lock) > > device_lock(parent); > > > > device_lock(dev); > > @@ -927,7 +927,7 @@ void device_release_driver_internal(struct device *dev, > > __device_release_driver(dev, parent); > > > > device_unlock(dev); > > - if (parent) > > + if (parent && dev->bus->need_parent_lock) > > device_unlock(parent); > > } > > > > diff --git a/drivers/usb/core/driver.c b/drivers/usb/core/driver.c > > index 9792cedfc351..e76e95f62f76 100644 > > --- a/drivers/usb/core/driver.c > > +++ b/drivers/usb/core/driver.c > > @@ -1922,4 +1922,5 @@ struct bus_type usb_bus_type = { > > .name = "usb", > > .match = usb_device_match, > > .uevent = usb_uevent, > > + .need_parent_lock = true, > > }; > > diff --git a/include/linux/device.h b/include/linux/device.h > > index 477956990f5e..beca424395dd 100644 > > --- a/include/linux/device.h > > +++ b/include/linux/device.h > > @@ -98,6 +98,8 @@ extern void bus_remove_file(struct bus_type *, struct bus_attribute *); > > * @lock_key: Lock class key for use by the lock validator > > * @force_dma: Assume devices on this bus should be set up by dma_configure() > > * even if DMA capability is not explicitly described by firmware. > > + * @need_parent_lock: When probing or removing a device on this bus, the > > + * device core should lock the device's parent. > > * > > * A bus is a channel between the processor and one or more devices. For the > > * purposes of the device model, all devices are connected via a bus, even if > > @@ -138,6 +140,7 @@ struct bus_type { > > struct lock_class_key lock_key; > > > > bool force_dma; > > + bool need_parent_lock; > > }; > > > > extern int __must_check bus_register(struct bus_type *bus); > > This looks okay to me. > > Acked-by: Alan Stern > > Greg, any more comments? Looks sane to me. Martin, thanks for all of the changes. greg k-h 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: [v4] driver core: hold dev's parent lock when needed From: Greg Kroah-Hartman Message-Id: <20180531063118.GA7554@kroah.com> Date: Thu, 31 May 2018 08:31:18 +0200 To: Alan Stern Cc: Martin Liu , heikki.krogerus@linux.intel.com, johan@kernel.org, andy.shevchenko@gmail.com, linux-kernel@vger.kernel.org, linux-usb@vger.kernel.org, jenhaochen@google.com List-ID: T24gV2VkLCBNYXkgMzAsIDIwMTggYXQgMDE6MjE6MDJQTSAtMDQwMCwgQWxhbiBTdGVybiB3cm90 ZToKPiBPbiBUaHUsIDMxIE1heSAyMDE4LCBNYXJ0aW4gTGl1IHdyb3RlOgo+IAo+ID4gU29DIGhh dmUgaW50ZXJuYWwgSS9PIGJ1c2VzIHRoYXQgY2FuJ3QgYmUgcHJvdmVkIGZvciBkZXZpY2VzLiBU aGUKPiA+IGRldmljZXMgb24gdGhlIGJ1c2VzIGNhbiBiZSBhY2Nlc3NlZCBkaXJlY3RseSB3aXRo b3V0IGFkZGl0aW5hbAo+ID4gY29uZmlndXJhdGlvbiByZXF1aXJlZC4gVGhpcyB0eXBlIG9mIGJ1 cyBpcyByZXByZXNlbnRlZCBhcwo+ID4gInNpbXBsZS1idXMiLiBJbiBzb21lIHBsYXRmb3Jtcywg d2UgbmFtZSAic29jIiB3aXRoICJzaW1wbGUtYnVzIgo+ID4gYXR0cmlidXRlIGFuZCBtYW55IGRl dmljZXMgYXJlIGhvb2tlZCB1bmRlciBpdCBkZXNjcmliZWQgaW4gRFQKPiA+IChkZXZpY2UgdHJl ZSkuCj4gPiAKPiA+IEluIGNvbW1pdCBiZjc0YWQ1YmM0MTcgKCJIb2xkIHRoZSBkZXZpY2UncyBw YXJlbnQncyBsb2NrIGR1cmluZwo+ID4gcHJvYmUgYW5kIHJlbW92ZSIpIHRvIHNvbHZlIFVTQiBz dWJzeXN0ZW0gbG9jayBzZXF1ZW5jZSBzaW5jZQo+ID4gVVNCIGRldmljZSdzIGNoYXJhY3Rlcmlz dGljLiBUaHVzICJzb2MiIG5lZWRzIHRvIGJlIGxvY2tlZAo+ID4gd2hlbmV2ZXIgYSBkZXZpY2Ug YW5kIGRyaXZlcidzIHByb2JpbmcgaGFwcGVuIHVuZGVyICJzb2MiIGJ1cy4KPiA+IER1cmluZyB0 aGlzIHBlcmlvZCwgYW4gYXN5bmMgZHJpdmVyIHRyaWVzIHRvIHByb2JlIGEgZGV2aWNlIHdoaWNo Cj4gPiBpcyB1bmRlciB0aGUgInNvYyIgYnVzIHdvdWxkIGJlIGJsb2NrZWQgdW50aWwgcHJldmlv dXMgZHJpdmVyCj4gPiBmaW5pc2ggdGhlIHByb2JpbmcgYW5kIHJlbGVhc2UgInNvYyIgbG9jay4g QW5kIHRoZSBuZXh0IHByb2JpbmcKPiA+IHVuZGVyIHRoZSAic29jIiBidXMgbmVlZCB0byB3YWl0 IGZvciBhc3luYyBmaW5pc2guIEJlY2F1c2Ugb2YKPiA+IHRoYXQsIGRyaXZlcidzIGFzeW5jIHBy b2JlIGZvciBpbml0IHRpbWUgaW1wcm92ZW1lbnQgd2lsbCBiZQo+ID4gc2hhZG93ZWQuCj4gPiAK PiA+IFNpbmNlIG1hbnkgZGV2aWNlcyBkb24ndCBoYXZlIFVTQiBkZXZpY2VzJyBjaGFyYWN0ZXJp c3RpYywgdGhleQo+ID4gYWN0dWFsbHkgZG9uJ3QgbmVlZCBwYXJlbnQncyBsb2NrLiBUaHVzLCB3 ZSBpbnRyb2R1Y2UgYSBsb2NrIGZsYWcKPiA+IGluIGJ1c190eXBlIHN0cnVjdCBhbmQgZHJpdmVy IGNvcmUgd291bGQgbG9jayB0aGUgcGFyZW50IGxvY2sgYmFzZQo+ID4gb24gdGhlIGZsYWcuIEZv ciBVU0IsIHdlIHNldCB0aGlzIGZsYWcgaW4gdXNiX2J1c190eXBlIHRvIGtlZXAKPiA+IG9yaWdp bmFsIGxvY2sgYmVoYXZpb3IgaW4gZHJpdmVyIGNvcmUuCj4gPiAKPiA+IEFzeW5jIHByb2JlIGNv dWxkIGhhdmUgbW9yZSBiZW5lZml0IGFmdGVyIHRoaXMgcGF0Y2guCj4gPiAKPiA+IFNpZ25lZC1v ZmYtYnk6IE1hcnRpbiBMaXUgPGxpdW1hcnRpbkBnb29nbGUuY29tPgo+ID4gLS0tCj4gPiBDaGFu Z2VzIGluIHY0Ogo+ID4gIC1maXggY29tbWVudCBhbmQgd29yZGluZy4KPiA+ICAtZm9sbG93IHRo ZSBzdWdnZXN0aW9uLgo+ID4gCj4gPiBbdjNdOiBodHRwczovL2xrbWwub3JnL2xrbWwvMjAxOC81 LzI5Lzg3Ngo+ID4gW3YyXTogaHR0cHM6Ly9sa21sLm9yZy9sa21sLzIwMTgvNS8yOS8xMDgKPiA+ IFt2MV06IGh0dHBzOi8vbGttbC5vcmcvbGttbC8yMDE4LzUvMjIvNTQ1Cj4gPiAKPiA+ICBkcml2 ZXJzL2Jhc2UvYnVzLmMgICAgICAgIHwgMTYgKysrKysrKystLS0tLS0tLQo+ID4gIGRyaXZlcnMv YmFzZS9kZC5jICAgICAgICAgfCAgOCArKysrLS0tLQo+ID4gIGRyaXZlcnMvdXNiL2NvcmUvZHJp dmVyLmMgfCAgMSArCj4gPiAgaW5jbHVkZS9saW51eC9kZXZpY2UuaCAgICB8ICAzICsrKwo+ID4g IDQgZmlsZXMgY2hhbmdlZCwgMTYgaW5zZXJ0aW9ucygrKSwgMTIgZGVsZXRpb25zKC0pCj4gPiAK PiA+IGRpZmYgLS1naXQgYS9kcml2ZXJzL2Jhc2UvYnVzLmMgYi9kcml2ZXJzL2Jhc2UvYnVzLmMK PiA+IGluZGV4IGVmNjE4MzMwNmI0MC4uOGJmZDI3ZWM3M2Q2IDEwMDY0NAo+ID4gLS0tIGEvZHJp dmVycy9iYXNlL2J1cy5jCj4gPiArKysgYi9kcml2ZXJzL2Jhc2UvYnVzLmMKPiA+IEBAIC0xODQs MTAgKzE4NCwxMCBAQCBzdGF0aWMgc3NpemVfdCB1bmJpbmRfc3RvcmUoc3RydWN0IGRldmljZV9k cml2ZXIgKmRydiwgY29uc3QgY2hhciAqYnVmLAo+ID4gIAo+ID4gIAlkZXYgPSBidXNfZmluZF9k ZXZpY2VfYnlfbmFtZShidXMsIE5VTEwsIGJ1Zik7Cj4gPiAgCWlmIChkZXYgJiYgZGV2LT5kcml2 ZXIgPT0gZHJ2KSB7Cj4gPiAtCQlpZiAoZGV2LT5wYXJlbnQpCS8qIE5lZWRlZCBmb3IgVVNCICov Cj4gPiArCQlpZiAoZGV2LT5wYXJlbnQgJiYgZGV2LT5idXMtPm5lZWRfcGFyZW50X2xvY2spCj4g PiAgCQkJZGV2aWNlX2xvY2soZGV2LT5wYXJlbnQpOwo+ID4gIAkJZGV2aWNlX3JlbGVhc2VfZHJp dmVyKGRldik7Cj4gPiAtCQlpZiAoZGV2LT5wYXJlbnQpCj4gPiArCQlpZiAoZGV2LT5wYXJlbnQg JiYgZGV2LT5idXMtPm5lZWRfcGFyZW50X2xvY2spCj4gPiAgCQkJZGV2aWNlX3VubG9jayhkZXYt PnBhcmVudCk7Cj4gPiAgCQllcnIgPSBjb3VudDsKPiA+ICAJfQo+ID4gQEAgLTIxMSwxMiArMjEx LDEyIEBAIHN0YXRpYyBzc2l6ZV90IGJpbmRfc3RvcmUoc3RydWN0IGRldmljZV9kcml2ZXIgKmRy diwgY29uc3QgY2hhciAqYnVmLAo+ID4gIAo+ID4gIAlkZXYgPSBidXNfZmluZF9kZXZpY2VfYnlf bmFtZShidXMsIE5VTEwsIGJ1Zik7Cj4gPiAgCWlmIChkZXYgJiYgZGV2LT5kcml2ZXIgPT0gTlVM TCAmJiBkcml2ZXJfbWF0Y2hfZGV2aWNlKGRydiwgZGV2KSkgewo+ID4gLQkJaWYgKGRldi0+cGFy ZW50KQkvKiBOZWVkZWQgZm9yIFVTQiAqLwo+ID4gKwkJaWYgKGRldi0+cGFyZW50ICYmIGJ1cy0+ bmVlZF9wYXJlbnRfbG9jaykKPiA+ICAJCQlkZXZpY2VfbG9jayhkZXYtPnBhcmVudCk7Cj4gPiAg CQlkZXZpY2VfbG9jayhkZXYpOwo+ID4gIAkJZXJyID0gZHJpdmVyX3Byb2JlX2RldmljZShkcnYs IGRldik7Cj4gPiAgCQlkZXZpY2VfdW5sb2NrKGRldik7Cj4gPiAtCQlpZiAoZGV2LT5wYXJlbnQp Cj4gPiArCQlpZiAoZGV2LT5wYXJlbnQgJiYgYnVzLT5uZWVkX3BhcmVudF9sb2NrKQo+ID4gIAkJ CWRldmljZV91bmxvY2soZGV2LT5wYXJlbnQpOwo+ID4gIAo+ID4gIAkJaWYgKGVyciA+IDApIHsK PiA+IEBAIC03MzUsMTAgKzczNSwxMCBAQCBzdGF0aWMgaW50IF9fbXVzdF9jaGVjayBidXNfcmVz Y2FuX2RldmljZXNfaGVscGVyKHN0cnVjdCBkZXZpY2UgKmRldiwKPiA+ICAJaW50IHJldCA9IDA7 Cj4gPiAgCj4gPiAgCWlmICghZGV2LT5kcml2ZXIpIHsKPiA+IC0JCWlmIChkZXYtPnBhcmVudCkJ LyogTmVlZGVkIGZvciBVU0IgKi8KPiA+ICsJCWlmIChkZXYtPnBhcmVudCAmJiBkZXYtPmJ1cy0+ bmVlZF9wYXJlbnRfbG9jaykKPiA+ICAJCQlkZXZpY2VfbG9jayhkZXYtPnBhcmVudCk7Cj4gPiAg CQlyZXQgPSBkZXZpY2VfYXR0YWNoKGRldik7Cj4gPiAtCQlpZiAoZGV2LT5wYXJlbnQpCj4gPiAr CQlpZiAoZGV2LT5wYXJlbnQgJiYgZGV2LT5idXMtPm5lZWRfcGFyZW50X2xvY2spCj4gPiAgCQkJ ZGV2aWNlX3VubG9jayhkZXYtPnBhcmVudCk7Cj4gPiAgCX0KPiA+ICAJcmV0dXJuIHJldCA8IDAg PyByZXQgOiAwOwo+ID4gQEAgLTc3MCwxMCArNzcwLDEwIEBAIEVYUE9SVF9TWU1CT0xfR1BMKGJ1 c19yZXNjYW5fZGV2aWNlcyk7Cj4gPiAgaW50IGRldmljZV9yZXByb2JlKHN0cnVjdCBkZXZpY2Ug KmRldikKPiA+ICB7Cj4gPiAgCWlmIChkZXYtPmRyaXZlcikgewo+ID4gLQkJaWYgKGRldi0+cGFy ZW50KSAgICAgICAgLyogTmVlZGVkIGZvciBVU0IgKi8KPiA+ICsJCWlmIChkZXYtPnBhcmVudCAm JiBkZXYtPmJ1cy0+bmVlZF9wYXJlbnRfbG9jaykKPiA+ICAJCQlkZXZpY2VfbG9jayhkZXYtPnBh cmVudCk7Cj4gPiAgCQlkZXZpY2VfcmVsZWFzZV9kcml2ZXIoZGV2KTsKPiA+IC0JCWlmIChkZXYt PnBhcmVudCkKPiA+ICsJCWlmIChkZXYtPnBhcmVudCAmJiBkZXYtPmJ1cy0+bmVlZF9wYXJlbnRf bG9jaykKPiA+ICAJCQlkZXZpY2VfdW5sb2NrKGRldi0+cGFyZW50KTsKPiA+ICAJfQo+ID4gIAly ZXR1cm4gYnVzX3Jlc2Nhbl9kZXZpY2VzX2hlbHBlcihkZXYsIE5VTEwpOwo+ID4gZGlmZiAtLWdp dCBhL2RyaXZlcnMvYmFzZS9kZC5jIGIvZHJpdmVycy9iYXNlL2RkLmMKPiA+IGluZGV4IGM5ZjU0 MDg5NDI5Yi4uN2MwOWY3M2I5NmYzIDEwMDY0NAo+ID4gLS0tIGEvZHJpdmVycy9iYXNlL2RkLmMK PiA+ICsrKyBiL2RyaXZlcnMvYmFzZS9kZC5jCj4gPiBAQCAtODE3LDEzICs4MTcsMTMgQEAgc3Rh dGljIGludCBfX2RyaXZlcl9hdHRhY2goc3RydWN0IGRldmljZSAqZGV2LCB2b2lkICpkYXRhKQo+ ID4gIAkJcmV0dXJuIHJldDsKPiA+ICAJfSAvKiByZXQgPiAwIG1lYW5zIHBvc2l0aXZlIG1hdGNo ICovCj4gPiAgCj4gPiAtCWlmIChkZXYtPnBhcmVudCkJLyogTmVlZGVkIGZvciBVU0IgKi8KPiA+ ICsJaWYgKGRldi0+cGFyZW50ICYmIGRldi0+YnVzLT5uZWVkX3BhcmVudF9sb2NrKQo+ID4gIAkJ ZGV2aWNlX2xvY2soZGV2LT5wYXJlbnQpOwo+ID4gIAlkZXZpY2VfbG9jayhkZXYpOwo+ID4gIAlp ZiAoIWRldi0+ZHJpdmVyKQo+ID4gIAkJZHJpdmVyX3Byb2JlX2RldmljZShkcnYsIGRldik7Cj4g PiAgCWRldmljZV91bmxvY2soZGV2KTsKPiA+IC0JaWYgKGRldi0+cGFyZW50KQo+ID4gKwlpZiAo ZGV2LT5wYXJlbnQgJiYgZGV2LT5idXMtPm5lZWRfcGFyZW50X2xvY2spCj4gPiAgCQlkZXZpY2Vf dW5sb2NrKGRldi0+cGFyZW50KTsKPiA+ICAKPiA+ICAJcmV0dXJuIDA7Cj4gPiBAQCAtOTE5LDcg KzkxOSw3IEBAIHZvaWQgZGV2aWNlX3JlbGVhc2VfZHJpdmVyX2ludGVybmFsKHN0cnVjdCBkZXZp Y2UgKmRldiwKPiA+ICAJCQkJICAgIHN0cnVjdCBkZXZpY2VfZHJpdmVyICpkcnYsCj4gPiAgCQkJ CSAgICBzdHJ1Y3QgZGV2aWNlICpwYXJlbnQpCj4gPiAgewo+ID4gLQlpZiAocGFyZW50KQo+ID4g KwlpZiAocGFyZW50ICYmIGRldi0+YnVzLT5uZWVkX3BhcmVudF9sb2NrKQo+ID4gIAkJZGV2aWNl X2xvY2socGFyZW50KTsKPiA+ICAKPiA+ICAJZGV2aWNlX2xvY2soZGV2KTsKPiA+IEBAIC05Mjcs NyArOTI3LDcgQEAgdm9pZCBkZXZpY2VfcmVsZWFzZV9kcml2ZXJfaW50ZXJuYWwoc3RydWN0IGRl dmljZSAqZGV2LAo+ID4gIAkJX19kZXZpY2VfcmVsZWFzZV9kcml2ZXIoZGV2LCBwYXJlbnQpOwo+ ID4gIAo+ID4gIAlkZXZpY2VfdW5sb2NrKGRldik7Cj4gPiAtCWlmIChwYXJlbnQpCj4gPiArCWlm IChwYXJlbnQgJiYgZGV2LT5idXMtPm5lZWRfcGFyZW50X2xvY2spCj4gPiAgCQlkZXZpY2VfdW5s b2NrKHBhcmVudCk7Cj4gPiAgfQo+ID4gIAo+ID4gZGlmZiAtLWdpdCBhL2RyaXZlcnMvdXNiL2Nv cmUvZHJpdmVyLmMgYi9kcml2ZXJzL3VzYi9jb3JlL2RyaXZlci5jCj4gPiBpbmRleCA5NzkyY2Vk ZmMzNTEuLmU3NmU5NWY2MmY3NiAxMDA2NDQKPiA+IC0tLSBhL2RyaXZlcnMvdXNiL2NvcmUvZHJp dmVyLmMKPiA+ICsrKyBiL2RyaXZlcnMvdXNiL2NvcmUvZHJpdmVyLmMKPiA+IEBAIC0xOTIyLDQg KzE5MjIsNSBAQCBzdHJ1Y3QgYnVzX3R5cGUgdXNiX2J1c190eXBlID0gewo+ID4gIAkubmFtZSA9 CQkidXNiIiwKPiA+ICAJLm1hdGNoID0JdXNiX2RldmljZV9tYXRjaCwKPiA+ICAJLnVldmVudCA9 CXVzYl91ZXZlbnQsCj4gPiArCS5uZWVkX3BhcmVudF9sb2NrID0JdHJ1ZSwKPiA+ICB9Owo+ID4g ZGlmZiAtLWdpdCBhL2luY2x1ZGUvbGludXgvZGV2aWNlLmggYi9pbmNsdWRlL2xpbnV4L2Rldmlj ZS5oCj4gPiBpbmRleCA0Nzc5NTY5OTBmNWUuLmJlY2E0MjQzOTVkZCAxMDA2NDQKPiA+IC0tLSBh L2luY2x1ZGUvbGludXgvZGV2aWNlLmgKPiA+ICsrKyBiL2luY2x1ZGUvbGludXgvZGV2aWNlLmgK PiA+IEBAIC05OCw2ICs5OCw4IEBAIGV4dGVybiB2b2lkIGJ1c19yZW1vdmVfZmlsZShzdHJ1Y3Qg YnVzX3R5cGUgKiwgc3RydWN0IGJ1c19hdHRyaWJ1dGUgKik7Cj4gPiAgICogQGxvY2tfa2V5OglM b2NrIGNsYXNzIGtleSBmb3IgdXNlIGJ5IHRoZSBsb2NrIHZhbGlkYXRvcgo+ID4gICAqIEBmb3Jj ZV9kbWE6CUFzc3VtZSBkZXZpY2VzIG9uIHRoaXMgYnVzIHNob3VsZCBiZSBzZXQgdXAgYnkgZG1h X2NvbmZpZ3VyZSgpCj4gPiAgICogCQlldmVuIGlmIERNQSBjYXBhYmlsaXR5IGlzIG5vdCBleHBs aWNpdGx5IGRlc2NyaWJlZCBieSBmaXJtd2FyZS4KPiA+ICsgKiBAbmVlZF9wYXJlbnRfbG9jazoJ V2hlbiBwcm9iaW5nIG9yIHJlbW92aW5nIGEgZGV2aWNlIG9uIHRoaXMgYnVzLCB0aGUKPiA+ICsg KgkJCWRldmljZSBjb3JlIHNob3VsZCBsb2NrIHRoZSBkZXZpY2UncyBwYXJlbnQuCj4gPiAgICoK PiA+ICAgKiBBIGJ1cyBpcyBhIGNoYW5uZWwgYmV0d2VlbiB0aGUgcHJvY2Vzc29yIGFuZCBvbmUg b3IgbW9yZSBkZXZpY2VzLiBGb3IgdGhlCj4gPiAgICogcHVycG9zZXMgb2YgdGhlIGRldmljZSBt b2RlbCwgYWxsIGRldmljZXMgYXJlIGNvbm5lY3RlZCB2aWEgYSBidXMsIGV2ZW4gaWYKPiA+IEBA IC0xMzgsNiArMTQwLDcgQEAgc3RydWN0IGJ1c190eXBlIHsKPiA+ICAJc3RydWN0IGxvY2tfY2xh c3Nfa2V5IGxvY2tfa2V5Owo+ID4gIAo+ID4gIAlib29sIGZvcmNlX2RtYTsKPiA+ICsJYm9vbCBu ZWVkX3BhcmVudF9sb2NrOwo+ID4gIH07Cj4gPiAgCj4gPiAgZXh0ZXJuIGludCBfX211c3RfY2hl Y2sgYnVzX3JlZ2lzdGVyKHN0cnVjdCBidXNfdHlwZSAqYnVzKTsKPiAKPiBUaGlzIGxvb2tzIG9r YXkgdG8gbWUuCj4gCj4gQWNrZWQtYnk6IEFsYW4gU3Rlcm4gPHN0ZXJuQHJvd2xhbmQuaGFydmFy ZC5lZHU+Cj4gCj4gR3JlZywgYW55IG1vcmUgY29tbWVudHM/CgpMb29rcyBzYW5lIHRvIG1lLiAg TWFydGluLCB0aGFua3MgZm9yIGFsbCBvZiB0aGUgY2hhbmdlcy4KCmdyZWcgay1oCi0tLQpUbyB1 bnN1YnNjcmliZSBmcm9tIHRoaXMgbGlzdDogc2VuZCB0aGUgbGluZSAidW5zdWJzY3JpYmUgbGlu dXgtdXNiIiBpbgp0aGUgYm9keSBvZiBhIG1lc3NhZ2UgdG8gbWFqb3Jkb21vQHZnZXIua2VybmVs Lm9yZwpNb3JlIG1ham9yZG9tbyBpbmZvIGF0ICBodHRwOi8vdmdlci5rZXJuZWwub3JnL21ham9y ZG9tby1pbmZvLmh0bWwK