From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1753778AbeE3RVF (ORCPT ); Wed, 30 May 2018 13:21:05 -0400 Received: from iolanthe.rowland.org ([192.131.102.54]:37078 "HELO iolanthe.rowland.org" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with SMTP id S1752850AbeE3RVC (ORCPT ); Wed, 30 May 2018 13:21:02 -0400 Date: Wed, 30 May 2018 13:21:02 -0400 (EDT) From: Alan Stern X-X-Sender: stern@iolanthe.rowland.org To: Martin Liu cc: gregkh@linuxfoundation.org, , , , , , Subject: Re: [PATCH v4] driver core: hold dev's parent lock when needed In-Reply-To: <20180530163135.50081-1-liumartin@google.com> Message-ID: MIME-Version: 1.0 Content-Type: TEXT/PLAIN; charset=US-ASCII Sender: linux-kernel-owner@vger.kernel.org List-ID: X-Mailing-List: linux-kernel@vger.kernel.org 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? Alan Stern 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: Alan Stern Message-Id: Date: Wed, 30 May 2018 13:21:02 -0400 (EDT) To: Martin Liu Cc: gregkh@linuxfoundation.org, 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: T24gVGh1LCAzMSBNYXkgMjAxOCwgTWFydGluIExpdSB3cm90ZToKCj4gU29DIGhhdmUgaW50ZXJu YWwgSS9PIGJ1c2VzIHRoYXQgY2FuJ3QgYmUgcHJvdmVkIGZvciBkZXZpY2VzLiBUaGUKPiBkZXZp Y2VzIG9uIHRoZSBidXNlcyBjYW4gYmUgYWNjZXNzZWQgZGlyZWN0bHkgd2l0aG91dCBhZGRpdGlu YWwKPiBjb25maWd1cmF0aW9uIHJlcXVpcmVkLiBUaGlzIHR5cGUgb2YgYnVzIGlzIHJlcHJlc2Vu dGVkIGFzCj4gInNpbXBsZS1idXMiLiBJbiBzb21lIHBsYXRmb3Jtcywgd2UgbmFtZSAic29jIiB3 aXRoICJzaW1wbGUtYnVzIgo+IGF0dHJpYnV0ZSBhbmQgbWFueSBkZXZpY2VzIGFyZSBob29rZWQg dW5kZXIgaXQgZGVzY3JpYmVkIGluIERUCj4gKGRldmljZSB0cmVlKS4KPiAKPiBJbiBjb21taXQg YmY3NGFkNWJjNDE3ICgiSG9sZCB0aGUgZGV2aWNlJ3MgcGFyZW50J3MgbG9jayBkdXJpbmcKPiBw cm9iZSBhbmQgcmVtb3ZlIikgdG8gc29sdmUgVVNCIHN1YnN5c3RlbSBsb2NrIHNlcXVlbmNlIHNp bmNlCj4gVVNCIGRldmljZSdzIGNoYXJhY3RlcmlzdGljLiBUaHVzICJzb2MiIG5lZWRzIHRvIGJl IGxvY2tlZAo+IHdoZW5ldmVyIGEgZGV2aWNlIGFuZCBkcml2ZXIncyBwcm9iaW5nIGhhcHBlbiB1 bmRlciAic29jIiBidXMuCj4gRHVyaW5nIHRoaXMgcGVyaW9kLCBhbiBhc3luYyBkcml2ZXIgdHJp ZXMgdG8gcHJvYmUgYSBkZXZpY2Ugd2hpY2gKPiBpcyB1bmRlciB0aGUgInNvYyIgYnVzIHdvdWxk IGJlIGJsb2NrZWQgdW50aWwgcHJldmlvdXMgZHJpdmVyCj4gZmluaXNoIHRoZSBwcm9iaW5nIGFu ZCByZWxlYXNlICJzb2MiIGxvY2suIEFuZCB0aGUgbmV4dCBwcm9iaW5nCj4gdW5kZXIgdGhlICJz b2MiIGJ1cyBuZWVkIHRvIHdhaXQgZm9yIGFzeW5jIGZpbmlzaC4gQmVjYXVzZSBvZgo+IHRoYXQs IGRyaXZlcidzIGFzeW5jIHByb2JlIGZvciBpbml0IHRpbWUgaW1wcm92ZW1lbnQgd2lsbCBiZQo+ IHNoYWRvd2VkLgo+IAo+IFNpbmNlIG1hbnkgZGV2aWNlcyBkb24ndCBoYXZlIFVTQiBkZXZpY2Vz JyBjaGFyYWN0ZXJpc3RpYywgdGhleQo+IGFjdHVhbGx5IGRvbid0IG5lZWQgcGFyZW50J3MgbG9j ay4gVGh1cywgd2UgaW50cm9kdWNlIGEgbG9jayBmbGFnCj4gaW4gYnVzX3R5cGUgc3RydWN0IGFu ZCBkcml2ZXIgY29yZSB3b3VsZCBsb2NrIHRoZSBwYXJlbnQgbG9jayBiYXNlCj4gb24gdGhlIGZs YWcuIEZvciBVU0IsIHdlIHNldCB0aGlzIGZsYWcgaW4gdXNiX2J1c190eXBlIHRvIGtlZXAKPiBv cmlnaW5hbCBsb2NrIGJlaGF2aW9yIGluIGRyaXZlciBjb3JlLgo+IAo+IEFzeW5jIHByb2JlIGNv dWxkIGhhdmUgbW9yZSBiZW5lZml0IGFmdGVyIHRoaXMgcGF0Y2guCj4gCj4gU2lnbmVkLW9mZi1i eTogTWFydGluIExpdSA8bGl1bWFydGluQGdvb2dsZS5jb20+Cj4gLS0tCj4gQ2hhbmdlcyBpbiB2 NDoKPiAgLWZpeCBjb21tZW50IGFuZCB3b3JkaW5nLgo+ICAtZm9sbG93IHRoZSBzdWdnZXN0aW9u Lgo+IAo+IFt2M106IGh0dHBzOi8vbGttbC5vcmcvbGttbC8yMDE4LzUvMjkvODc2Cj4gW3YyXTog aHR0cHM6Ly9sa21sLm9yZy9sa21sLzIwMTgvNS8yOS8xMDgKPiBbdjFdOiBodHRwczovL2xrbWwu b3JnL2xrbWwvMjAxOC81LzIyLzU0NQo+IAo+ICBkcml2ZXJzL2Jhc2UvYnVzLmMgICAgICAgIHwg MTYgKysrKysrKystLS0tLS0tLQo+ICBkcml2ZXJzL2Jhc2UvZGQuYyAgICAgICAgIHwgIDggKysr Ky0tLS0KPiAgZHJpdmVycy91c2IvY29yZS9kcml2ZXIuYyB8ICAxICsKPiAgaW5jbHVkZS9saW51 eC9kZXZpY2UuaCAgICB8ICAzICsrKwo+ICA0IGZpbGVzIGNoYW5nZWQsIDE2IGluc2VydGlvbnMo KyksIDEyIGRlbGV0aW9ucygtKQo+IAo+IGRpZmYgLS1naXQgYS9kcml2ZXJzL2Jhc2UvYnVzLmMg Yi9kcml2ZXJzL2Jhc2UvYnVzLmMKPiBpbmRleCBlZjYxODMzMDZiNDAuLjhiZmQyN2VjNzNkNiAx MDA2NDQKPiAtLS0gYS9kcml2ZXJzL2Jhc2UvYnVzLmMKPiArKysgYi9kcml2ZXJzL2Jhc2UvYnVz LmMKPiBAQCAtMTg0LDEwICsxODQsMTAgQEAgc3RhdGljIHNzaXplX3QgdW5iaW5kX3N0b3JlKHN0 cnVjdCBkZXZpY2VfZHJpdmVyICpkcnYsIGNvbnN0IGNoYXIgKmJ1ZiwKPiAgCj4gIAlkZXYgPSBi dXNfZmluZF9kZXZpY2VfYnlfbmFtZShidXMsIE5VTEwsIGJ1Zik7Cj4gIAlpZiAoZGV2ICYmIGRl di0+ZHJpdmVyID09IGRydikgewo+IC0JCWlmIChkZXYtPnBhcmVudCkJLyogTmVlZGVkIGZvciBV U0IgKi8KPiArCQlpZiAoZGV2LT5wYXJlbnQgJiYgZGV2LT5idXMtPm5lZWRfcGFyZW50X2xvY2sp Cj4gIAkJCWRldmljZV9sb2NrKGRldi0+cGFyZW50KTsKPiAgCQlkZXZpY2VfcmVsZWFzZV9kcml2 ZXIoZGV2KTsKPiAtCQlpZiAoZGV2LT5wYXJlbnQpCj4gKwkJaWYgKGRldi0+cGFyZW50ICYmIGRl di0+YnVzLT5uZWVkX3BhcmVudF9sb2NrKQo+ICAJCQlkZXZpY2VfdW5sb2NrKGRldi0+cGFyZW50 KTsKPiAgCQllcnIgPSBjb3VudDsKPiAgCX0KPiBAQCAtMjExLDEyICsyMTEsMTIgQEAgc3RhdGlj IHNzaXplX3QgYmluZF9zdG9yZShzdHJ1Y3QgZGV2aWNlX2RyaXZlciAqZHJ2LCBjb25zdCBjaGFy ICpidWYsCj4gIAo+ICAJZGV2ID0gYnVzX2ZpbmRfZGV2aWNlX2J5X25hbWUoYnVzLCBOVUxMLCBi dWYpOwo+ICAJaWYgKGRldiAmJiBkZXYtPmRyaXZlciA9PSBOVUxMICYmIGRyaXZlcl9tYXRjaF9k ZXZpY2UoZHJ2LCBkZXYpKSB7Cj4gLQkJaWYgKGRldi0+cGFyZW50KQkvKiBOZWVkZWQgZm9yIFVT QiAqLwo+ICsJCWlmIChkZXYtPnBhcmVudCAmJiBidXMtPm5lZWRfcGFyZW50X2xvY2spCj4gIAkJ CWRldmljZV9sb2NrKGRldi0+cGFyZW50KTsKPiAgCQlkZXZpY2VfbG9jayhkZXYpOwo+ICAJCWVy ciA9IGRyaXZlcl9wcm9iZV9kZXZpY2UoZHJ2LCBkZXYpOwo+ICAJCWRldmljZV91bmxvY2soZGV2 KTsKPiAtCQlpZiAoZGV2LT5wYXJlbnQpCj4gKwkJaWYgKGRldi0+cGFyZW50ICYmIGJ1cy0+bmVl ZF9wYXJlbnRfbG9jaykKPiAgCQkJZGV2aWNlX3VubG9jayhkZXYtPnBhcmVudCk7Cj4gIAo+ICAJ CWlmIChlcnIgPiAwKSB7Cj4gQEAgLTczNSwxMCArNzM1LDEwIEBAIHN0YXRpYyBpbnQgX19tdXN0 X2NoZWNrIGJ1c19yZXNjYW5fZGV2aWNlc19oZWxwZXIoc3RydWN0IGRldmljZSAqZGV2LAo+ICAJ aW50IHJldCA9IDA7Cj4gIAo+ICAJaWYgKCFkZXYtPmRyaXZlcikgewo+IC0JCWlmIChkZXYtPnBh cmVudCkJLyogTmVlZGVkIGZvciBVU0IgKi8KPiArCQlpZiAoZGV2LT5wYXJlbnQgJiYgZGV2LT5i dXMtPm5lZWRfcGFyZW50X2xvY2spCj4gIAkJCWRldmljZV9sb2NrKGRldi0+cGFyZW50KTsKPiAg CQlyZXQgPSBkZXZpY2VfYXR0YWNoKGRldik7Cj4gLQkJaWYgKGRldi0+cGFyZW50KQo+ICsJCWlm IChkZXYtPnBhcmVudCAmJiBkZXYtPmJ1cy0+bmVlZF9wYXJlbnRfbG9jaykKPiAgCQkJZGV2aWNl X3VubG9jayhkZXYtPnBhcmVudCk7Cj4gIAl9Cj4gIAlyZXR1cm4gcmV0IDwgMCA/IHJldCA6IDA7 Cj4gQEAgLTc3MCwxMCArNzcwLDEwIEBAIEVYUE9SVF9TWU1CT0xfR1BMKGJ1c19yZXNjYW5fZGV2 aWNlcyk7Cj4gIGludCBkZXZpY2VfcmVwcm9iZShzdHJ1Y3QgZGV2aWNlICpkZXYpCj4gIHsKPiAg CWlmIChkZXYtPmRyaXZlcikgewo+IC0JCWlmIChkZXYtPnBhcmVudCkgICAgICAgIC8qIE5lZWRl ZCBmb3IgVVNCICovCj4gKwkJaWYgKGRldi0+cGFyZW50ICYmIGRldi0+YnVzLT5uZWVkX3BhcmVu dF9sb2NrKQo+ICAJCQlkZXZpY2VfbG9jayhkZXYtPnBhcmVudCk7Cj4gIAkJZGV2aWNlX3JlbGVh c2VfZHJpdmVyKGRldik7Cj4gLQkJaWYgKGRldi0+cGFyZW50KQo+ICsJCWlmIChkZXYtPnBhcmVu dCAmJiBkZXYtPmJ1cy0+bmVlZF9wYXJlbnRfbG9jaykKPiAgCQkJZGV2aWNlX3VubG9jayhkZXYt PnBhcmVudCk7Cj4gIAl9Cj4gIAlyZXR1cm4gYnVzX3Jlc2Nhbl9kZXZpY2VzX2hlbHBlcihkZXYs IE5VTEwpOwo+IGRpZmYgLS1naXQgYS9kcml2ZXJzL2Jhc2UvZGQuYyBiL2RyaXZlcnMvYmFzZS9k ZC5jCj4gaW5kZXggYzlmNTQwODk0MjliLi43YzA5ZjczYjk2ZjMgMTAwNjQ0Cj4gLS0tIGEvZHJp dmVycy9iYXNlL2RkLmMKPiArKysgYi9kcml2ZXJzL2Jhc2UvZGQuYwo+IEBAIC04MTcsMTMgKzgx NywxMyBAQCBzdGF0aWMgaW50IF9fZHJpdmVyX2F0dGFjaChzdHJ1Y3QgZGV2aWNlICpkZXYsIHZv aWQgKmRhdGEpCj4gIAkJcmV0dXJuIHJldDsKPiAgCX0gLyogcmV0ID4gMCBtZWFucyBwb3NpdGl2 ZSBtYXRjaCAqLwo+ICAKPiAtCWlmIChkZXYtPnBhcmVudCkJLyogTmVlZGVkIGZvciBVU0IgKi8K PiArCWlmIChkZXYtPnBhcmVudCAmJiBkZXYtPmJ1cy0+bmVlZF9wYXJlbnRfbG9jaykKPiAgCQlk ZXZpY2VfbG9jayhkZXYtPnBhcmVudCk7Cj4gIAlkZXZpY2VfbG9jayhkZXYpOwo+ICAJaWYgKCFk ZXYtPmRyaXZlcikKPiAgCQlkcml2ZXJfcHJvYmVfZGV2aWNlKGRydiwgZGV2KTsKPiAgCWRldmlj ZV91bmxvY2soZGV2KTsKPiAtCWlmIChkZXYtPnBhcmVudCkKPiArCWlmIChkZXYtPnBhcmVudCAm JiBkZXYtPmJ1cy0+bmVlZF9wYXJlbnRfbG9jaykKPiAgCQlkZXZpY2VfdW5sb2NrKGRldi0+cGFy ZW50KTsKPiAgCj4gIAlyZXR1cm4gMDsKPiBAQCAtOTE5LDcgKzkxOSw3IEBAIHZvaWQgZGV2aWNl X3JlbGVhc2VfZHJpdmVyX2ludGVybmFsKHN0cnVjdCBkZXZpY2UgKmRldiwKPiAgCQkJCSAgICBz dHJ1Y3QgZGV2aWNlX2RyaXZlciAqZHJ2LAo+ICAJCQkJICAgIHN0cnVjdCBkZXZpY2UgKnBhcmVu dCkKPiAgewo+IC0JaWYgKHBhcmVudCkKPiArCWlmIChwYXJlbnQgJiYgZGV2LT5idXMtPm5lZWRf cGFyZW50X2xvY2spCj4gIAkJZGV2aWNlX2xvY2socGFyZW50KTsKPiAgCj4gIAlkZXZpY2VfbG9j ayhkZXYpOwo+IEBAIC05MjcsNyArOTI3LDcgQEAgdm9pZCBkZXZpY2VfcmVsZWFzZV9kcml2ZXJf aW50ZXJuYWwoc3RydWN0IGRldmljZSAqZGV2LAo+ICAJCV9fZGV2aWNlX3JlbGVhc2VfZHJpdmVy KGRldiwgcGFyZW50KTsKPiAgCj4gIAlkZXZpY2VfdW5sb2NrKGRldik7Cj4gLQlpZiAocGFyZW50 KQo+ICsJaWYgKHBhcmVudCAmJiBkZXYtPmJ1cy0+bmVlZF9wYXJlbnRfbG9jaykKPiAgCQlkZXZp Y2VfdW5sb2NrKHBhcmVudCk7Cj4gIH0KPiAgCj4gZGlmZiAtLWdpdCBhL2RyaXZlcnMvdXNiL2Nv cmUvZHJpdmVyLmMgYi9kcml2ZXJzL3VzYi9jb3JlL2RyaXZlci5jCj4gaW5kZXggOTc5MmNlZGZj MzUxLi5lNzZlOTVmNjJmNzYgMTAwNjQ0Cj4gLS0tIGEvZHJpdmVycy91c2IvY29yZS9kcml2ZXIu Ywo+ICsrKyBiL2RyaXZlcnMvdXNiL2NvcmUvZHJpdmVyLmMKPiBAQCAtMTkyMiw0ICsxOTIyLDUg QEAgc3RydWN0IGJ1c190eXBlIHVzYl9idXNfdHlwZSA9IHsKPiAgCS5uYW1lID0JCSJ1c2IiLAo+ ICAJLm1hdGNoID0JdXNiX2RldmljZV9tYXRjaCwKPiAgCS51ZXZlbnQgPQl1c2JfdWV2ZW50LAo+ ICsJLm5lZWRfcGFyZW50X2xvY2sgPQl0cnVlLAo+ICB9Owo+IGRpZmYgLS1naXQgYS9pbmNsdWRl L2xpbnV4L2RldmljZS5oIGIvaW5jbHVkZS9saW51eC9kZXZpY2UuaAo+IGluZGV4IDQ3Nzk1Njk5 MGY1ZS4uYmVjYTQyNDM5NWRkIDEwMDY0NAo+IC0tLSBhL2luY2x1ZGUvbGludXgvZGV2aWNlLmgK PiArKysgYi9pbmNsdWRlL2xpbnV4L2RldmljZS5oCj4gQEAgLTk4LDYgKzk4LDggQEAgZXh0ZXJu IHZvaWQgYnVzX3JlbW92ZV9maWxlKHN0cnVjdCBidXNfdHlwZSAqLCBzdHJ1Y3QgYnVzX2F0dHJp YnV0ZSAqKTsKPiAgICogQGxvY2tfa2V5OglMb2NrIGNsYXNzIGtleSBmb3IgdXNlIGJ5IHRoZSBs b2NrIHZhbGlkYXRvcgo+ICAgKiBAZm9yY2VfZG1hOglBc3N1bWUgZGV2aWNlcyBvbiB0aGlzIGJ1 cyBzaG91bGQgYmUgc2V0IHVwIGJ5IGRtYV9jb25maWd1cmUoKQo+ICAgKiAJCWV2ZW4gaWYgRE1B IGNhcGFiaWxpdHkgaXMgbm90IGV4cGxpY2l0bHkgZGVzY3JpYmVkIGJ5IGZpcm13YXJlLgo+ICsg KiBAbmVlZF9wYXJlbnRfbG9jazoJV2hlbiBwcm9iaW5nIG9yIHJlbW92aW5nIGEgZGV2aWNlIG9u IHRoaXMgYnVzLCB0aGUKPiArICoJCQlkZXZpY2UgY29yZSBzaG91bGQgbG9jayB0aGUgZGV2aWNl J3MgcGFyZW50Lgo+ICAgKgo+ICAgKiBBIGJ1cyBpcyBhIGNoYW5uZWwgYmV0d2VlbiB0aGUgcHJv Y2Vzc29yIGFuZCBvbmUgb3IgbW9yZSBkZXZpY2VzLiBGb3IgdGhlCj4gICAqIHB1cnBvc2VzIG9m IHRoZSBkZXZpY2UgbW9kZWwsIGFsbCBkZXZpY2VzIGFyZSBjb25uZWN0ZWQgdmlhIGEgYnVzLCBl dmVuIGlmCj4gQEAgLTEzOCw2ICsxNDAsNyBAQCBzdHJ1Y3QgYnVzX3R5cGUgewo+ICAJc3RydWN0 IGxvY2tfY2xhc3Nfa2V5IGxvY2tfa2V5Owo+ICAKPiAgCWJvb2wgZm9yY2VfZG1hOwo+ICsJYm9v bCBuZWVkX3BhcmVudF9sb2NrOwo+ICB9Owo+ICAKPiAgZXh0ZXJuIGludCBfX211c3RfY2hlY2sg YnVzX3JlZ2lzdGVyKHN0cnVjdCBidXNfdHlwZSAqYnVzKTsKClRoaXMgbG9va3Mgb2theSB0byBt ZS4KCkFja2VkLWJ5OiBBbGFuIFN0ZXJuIDxzdGVybkByb3dsYW5kLmhhcnZhcmQuZWR1PgoKR3Jl ZywgYW55IG1vcmUgY29tbWVudHM/CgpBbGFuIFN0ZXJuCi0tLQpUbyB1bnN1YnNjcmliZSBmcm9t IHRoaXMgbGlzdDogc2VuZCB0aGUgbGluZSAidW5zdWJzY3JpYmUgbGludXgtdXNiIiBpbgp0aGUg Ym9keSBvZiBhIG1lc3NhZ2UgdG8gbWFqb3Jkb21vQHZnZXIua2VybmVsLm9yZwpNb3JlIG1ham9y ZG9tbyBpbmZvIGF0ICBodHRwOi8vdmdlci5rZXJuZWwub3JnL21ham9yZG9tby1pbmZvLmh0bWwK