From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1753938AbeC1PJb (ORCPT ); Wed, 28 Mar 2018 11:09:31 -0400 Received: from mail-wm0-f67.google.com ([74.125.82.67]:51956 "EHLO mail-wm0-f67.google.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1753897AbeC1PJa (ORCPT ); Wed, 28 Mar 2018 11:09:30 -0400 X-Google-Smtp-Source: AIpwx48571j+e4ONtIquNHkksHtHoL8cXV9InhVmEcPJjheEsztwh9/vYG7wv8LumjFphTgLxGf0sw== Date: Wed, 28 Mar 2018 17:09:26 +0200 From: Daniel Vetter To: Oleksandr Andrushchenko Cc: linux-kernel@vger.kernel.org, dri-devel@lists.freedesktop.org, airlied@linux.ie, daniel.vetter@intel.com, seanpaul@chromium.org, gustavo@padovan.org, intel-gfx@lists.freedesktop.org, Oleksandr Andrushchenko Subject: Re: [PATCH] drm: Use srcu to protect drm_device.unplugged Message-ID: <20180328150926.GC3881@phenom.ffwll.local> Mail-Followup-To: Oleksandr Andrushchenko , linux-kernel@vger.kernel.org, dri-devel@lists.freedesktop.org, airlied@linux.ie, daniel.vetter@intel.com, seanpaul@chromium.org, gustavo@padovan.org, intel-gfx@lists.freedesktop.org, Oleksandr Andrushchenko References: <1522222715-11814-1-git-send-email-andr2000@gmail.com> MIME-Version: 1.0 Content-Type: text/plain; charset=iso-8859-1 Content-Disposition: inline Content-Transfer-Encoding: 8bit In-Reply-To: <1522222715-11814-1-git-send-email-andr2000@gmail.com> X-Operating-System: Linux phenom 4.15.0-1-amd64 User-Agent: Mutt/1.9.4 (2018-02-28) Sender: linux-kernel-owner@vger.kernel.org List-ID: X-Mailing-List: linux-kernel@vger.kernel.org On Wed, Mar 28, 2018 at 10:38:35AM +0300, Oleksandr Andrushchenko wrote: > From: Noralf Trønnes > > Use srcu to protect drm_device.unplugged in a race free manner. > Drivers can use drm_dev_enter()/drm_dev_exit() to protect and mark > sections preventing access to device resources that are not available > after the device is gone. > > Suggested-by: Daniel Vetter > Signed-off-by: Noralf Trønnes > Signed-off-by: Oleksandr Andrushchenko > Reviewed-by: Oleksandr Andrushchenko > Tested-by: Oleksandr Andrushchenko > Cc: intel-gfx@lists.freedesktop.org Reviewed-by: Daniel Vetter Oleksandr, please push to drm-misc-next once you have dim tools setup up and everything. Thanks, Daniel > --- > drivers/gpu/drm/drm_drv.c | 54 ++++++++++++++++++++++++++++++++++++++++++----- > include/drm/drm_device.h | 9 +++++++- > include/drm/drm_drv.h | 15 +++++++++---- > 3 files changed, 68 insertions(+), 10 deletions(-) > > diff --git a/drivers/gpu/drm/drm_drv.c b/drivers/gpu/drm/drm_drv.c > index a1b9338736e3..32a83b41ab61 100644 > --- a/drivers/gpu/drm/drm_drv.c > +++ b/drivers/gpu/drm/drm_drv.c > @@ -32,6 +32,7 @@ > #include > #include > #include > +#include > > #include > #include > @@ -75,6 +76,8 @@ static bool drm_core_init_complete = false; > > static struct dentry *drm_debugfs_root; > > +DEFINE_STATIC_SRCU(drm_unplug_srcu); > + > /* > * DRM Minors > * A DRM device can provide several char-dev interfaces on the DRM-Major. Each > @@ -318,18 +321,51 @@ void drm_put_dev(struct drm_device *dev) > } > EXPORT_SYMBOL(drm_put_dev); > > -static void drm_device_set_unplugged(struct drm_device *dev) > +/** > + * drm_dev_enter - Enter device critical section > + * @dev: DRM device > + * @idx: Pointer to index that will be passed to the matching drm_dev_exit() > + * > + * This function marks and protects the beginning of a section that should not > + * be entered after the device has been unplugged. The section end is marked > + * with drm_dev_exit(). Calls to this function can be nested. > + * > + * Returns: > + * True if it is OK to enter the section, false otherwise. > + */ > +bool drm_dev_enter(struct drm_device *dev, int *idx) > +{ > + *idx = srcu_read_lock(&drm_unplug_srcu); > + > + if (dev->unplugged) { > + srcu_read_unlock(&drm_unplug_srcu, *idx); > + return false; > + } > + > + return true; > +} > +EXPORT_SYMBOL(drm_dev_enter); > + > +/** > + * drm_dev_exit - Exit device critical section > + * @idx: index returned from drm_dev_enter() > + * > + * This function marks the end of a section that should not be entered after > + * the device has been unplugged. > + */ > +void drm_dev_exit(int idx) > { > - smp_wmb(); > - atomic_set(&dev->unplugged, 1); > + srcu_read_unlock(&drm_unplug_srcu, idx); > } > +EXPORT_SYMBOL(drm_dev_exit); > > /** > * drm_dev_unplug - unplug a DRM device > * @dev: DRM device > * > * This unplugs a hotpluggable DRM device, which makes it inaccessible to > - * userspace operations. Entry-points can use drm_dev_is_unplugged(). This > + * userspace operations. Entry-points can use drm_dev_enter() and > + * drm_dev_exit() to protect device resources in a race free manner. This > * essentially unregisters the device like drm_dev_unregister(), but can be > * called while there are still open users of @dev. > */ > @@ -338,10 +374,18 @@ void drm_dev_unplug(struct drm_device *dev) > drm_dev_unregister(dev); > > mutex_lock(&drm_global_mutex); > - drm_device_set_unplugged(dev); > if (dev->open_count == 0) > drm_dev_put(dev); > mutex_unlock(&drm_global_mutex); > + > + /* > + * After synchronizing any critical read section is guaranteed to see > + * the new value of ->unplugged, and any critical section which might > + * still have seen the old value of ->unplugged is guaranteed to have > + * finished. > + */ > + dev->unplugged = true; > + synchronize_srcu(&drm_unplug_srcu); > } > EXPORT_SYMBOL(drm_dev_unplug); > > diff --git a/include/drm/drm_device.h b/include/drm/drm_device.h > index 7c4fa32f3fc6..3a0eac2885b7 100644 > --- a/include/drm/drm_device.h > +++ b/include/drm/drm_device.h > @@ -46,7 +46,14 @@ struct drm_device { > /* currently active master for this device. Protected by master_mutex */ > struct drm_master *master; > > - atomic_t unplugged; /**< Flag whether dev is dead */ > + /** > + * @unplugged: > + * > + * Flag to tell if the device has been unplugged. > + * See drm_dev_enter() and drm_dev_is_unplugged(). > + */ > + bool unplugged; > + > struct inode *anon_inode; /**< inode for private address-space */ > char *unique; /**< unique name of the device */ > /*@} */ > diff --git a/include/drm/drm_drv.h b/include/drm/drm_drv.h > index d23dcdd1bd95..7e545f5f94d3 100644 > --- a/include/drm/drm_drv.h > +++ b/include/drm/drm_drv.h > @@ -624,6 +624,8 @@ void drm_dev_get(struct drm_device *dev); > void drm_dev_put(struct drm_device *dev); > void drm_dev_unref(struct drm_device *dev); > void drm_put_dev(struct drm_device *dev); > +bool drm_dev_enter(struct drm_device *dev, int *idx); > +void drm_dev_exit(int idx); > void drm_dev_unplug(struct drm_device *dev); > > /** > @@ -635,11 +637,16 @@ void drm_dev_unplug(struct drm_device *dev); > * unplugged, these two functions guarantee that any store before calling > * drm_dev_unplug() is visible to callers of this function after it completes > */ > -static inline int drm_dev_is_unplugged(struct drm_device *dev) > +static inline bool drm_dev_is_unplugged(struct drm_device *dev) > { > - int ret = atomic_read(&dev->unplugged); > - smp_rmb(); > - return ret; > + int idx; > + > + if (drm_dev_enter(dev, &idx)) { > + drm_dev_exit(idx); > + return false; > + } > + > + return true; > } > > > -- > 2.7.4 > > _______________________________________________ > dri-devel mailing list > dri-devel@lists.freedesktop.org > https://lists.freedesktop.org/mailman/listinfo/dri-devel -- Daniel Vetter Software Engineer, Intel Corporation http://blog.ffwll.ch From mboxrd@z Thu Jan 1 00:00:00 1970 From: Daniel Vetter Subject: Re: [PATCH] drm: Use srcu to protect drm_device.unplugged Date: Wed, 28 Mar 2018 17:09:26 +0200 Message-ID: <20180328150926.GC3881@phenom.ffwll.local> References: <1522222715-11814-1-git-send-email-andr2000@gmail.com> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Return-path: Content-Disposition: inline In-Reply-To: <1522222715-11814-1-git-send-email-andr2000@gmail.com> List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: intel-gfx-bounces@lists.freedesktop.org Sender: "Intel-gfx" To: Oleksandr Andrushchenko Cc: Oleksandr Andrushchenko , airlied@linux.ie, intel-gfx@lists.freedesktop.org, linux-kernel@vger.kernel.org, dri-devel@lists.freedesktop.org, daniel.vetter@intel.com List-Id: dri-devel@lists.freedesktop.org T24gV2VkLCBNYXIgMjgsIDIwMTggYXQgMTA6Mzg6MzVBTSArMDMwMCwgT2xla3NhbmRyIEFuZHJ1 c2hjaGVua28gd3JvdGU6Cj4gRnJvbTogTm9yYWxmIFRyw7hubmVzIDxub3JhbGZAdHJvbm5lcy5v cmc+Cj4gCj4gVXNlIHNyY3UgdG8gcHJvdGVjdCBkcm1fZGV2aWNlLnVucGx1Z2dlZCBpbiBhIHJh Y2UgZnJlZSBtYW5uZXIuCj4gRHJpdmVycyBjYW4gdXNlIGRybV9kZXZfZW50ZXIoKS9kcm1fZGV2 X2V4aXQoKSB0byBwcm90ZWN0IGFuZCBtYXJrCj4gc2VjdGlvbnMgcHJldmVudGluZyBhY2Nlc3Mg dG8gZGV2aWNlIHJlc291cmNlcyB0aGF0IGFyZSBub3QgYXZhaWxhYmxlCj4gYWZ0ZXIgdGhlIGRl dmljZSBpcyBnb25lLgo+IAo+IFN1Z2dlc3RlZC1ieTogRGFuaWVsIFZldHRlciA8ZGFuaWVsLnZl dHRlckBmZndsbC5jaD4KPiBTaWduZWQtb2ZmLWJ5OiBOb3JhbGYgVHLDuG5uZXMgPG5vcmFsZkB0 cm9ubmVzLm9yZz4KPiBTaWduZWQtb2ZmLWJ5OiBPbGVrc2FuZHIgQW5kcnVzaGNoZW5rbyA8b2xl a3NhbmRyX2FuZHJ1c2hjaGVua29AZXBhbS5jb20+Cj4gUmV2aWV3ZWQtYnk6IE9sZWtzYW5kciBB bmRydXNoY2hlbmtvIDxvbGVrc2FuZHJfYW5kcnVzaGNoZW5rb0BlcGFtLmNvbT4KPiBUZXN0ZWQt Ynk6IE9sZWtzYW5kciBBbmRydXNoY2hlbmtvIDxvbGVrc2FuZHJfYW5kcnVzaGNoZW5rb0BlcGFt LmNvbT4KPiBDYzogaW50ZWwtZ2Z4QGxpc3RzLmZyZWVkZXNrdG9wLm9yZwoKUmV2aWV3ZWQtYnk6 IERhbmllbCBWZXR0ZXIgPGRhbmllbC52ZXR0ZXJAZmZ3bGwuY2g+CgpPbGVrc2FuZHIsIHBsZWFz ZSBwdXNoIHRvIGRybS1taXNjLW5leHQgb25jZSB5b3UgaGF2ZSBkaW0gdG9vbHMgc2V0dXAgdXAK YW5kIGV2ZXJ5dGhpbmcuCgpUaGFua3MsIERhbmllbAoKPiAtLS0KPiAgZHJpdmVycy9ncHUvZHJt L2RybV9kcnYuYyB8IDU0ICsrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysr Ky0tLS0tCj4gIGluY2x1ZGUvZHJtL2RybV9kZXZpY2UuaCAgfCAgOSArKysrKysrLQo+ICBpbmNs dWRlL2RybS9kcm1fZHJ2LmggICAgIHwgMTUgKysrKysrKysrLS0tLQo+ICAzIGZpbGVzIGNoYW5n ZWQsIDY4IGluc2VydGlvbnMoKyksIDEwIGRlbGV0aW9ucygtKQo+IAo+IGRpZmYgLS1naXQgYS9k cml2ZXJzL2dwdS9kcm0vZHJtX2Rydi5jIGIvZHJpdmVycy9ncHUvZHJtL2RybV9kcnYuYwo+IGlu ZGV4IGExYjkzMzg3MzZlMy4uMzJhODNiNDFhYjYxIDEwMDY0NAo+IC0tLSBhL2RyaXZlcnMvZ3B1 L2RybS9kcm1fZHJ2LmMKPiArKysgYi9kcml2ZXJzL2dwdS9kcm0vZHJtX2Rydi5jCj4gQEAgLTMy LDYgKzMyLDcgQEAKPiAgI2luY2x1ZGUgPGxpbnV4L21vZHVsZXBhcmFtLmg+Cj4gICNpbmNsdWRl IDxsaW51eC9tb3VudC5oPgo+ICAjaW5jbHVkZSA8bGludXgvc2xhYi5oPgo+ICsjaW5jbHVkZSA8 bGludXgvc3JjdS5oPgo+ICAKPiAgI2luY2x1ZGUgPGRybS9kcm1fZHJ2Lmg+Cj4gICNpbmNsdWRl IDxkcm0vZHJtUC5oPgo+IEBAIC03NSw2ICs3Niw4IEBAIHN0YXRpYyBib29sIGRybV9jb3JlX2lu aXRfY29tcGxldGUgPSBmYWxzZTsKPiAgCj4gIHN0YXRpYyBzdHJ1Y3QgZGVudHJ5ICpkcm1fZGVi dWdmc19yb290Owo+ICAKPiArREVGSU5FX1NUQVRJQ19TUkNVKGRybV91bnBsdWdfc3JjdSk7Cj4g Kwo+ICAvKgo+ICAgKiBEUk0gTWlub3JzCj4gICAqIEEgRFJNIGRldmljZSBjYW4gcHJvdmlkZSBz ZXZlcmFsIGNoYXItZGV2IGludGVyZmFjZXMgb24gdGhlIERSTS1NYWpvci4gRWFjaAo+IEBAIC0z MTgsMTggKzMyMSw1MSBAQCB2b2lkIGRybV9wdXRfZGV2KHN0cnVjdCBkcm1fZGV2aWNlICpkZXYp Cj4gIH0KPiAgRVhQT1JUX1NZTUJPTChkcm1fcHV0X2Rldik7Cj4gIAo+IC1zdGF0aWMgdm9pZCBk cm1fZGV2aWNlX3NldF91bnBsdWdnZWQoc3RydWN0IGRybV9kZXZpY2UgKmRldikKPiArLyoqCj4g KyAqIGRybV9kZXZfZW50ZXIgLSBFbnRlciBkZXZpY2UgY3JpdGljYWwgc2VjdGlvbgo+ICsgKiBA ZGV2OiBEUk0gZGV2aWNlCj4gKyAqIEBpZHg6IFBvaW50ZXIgdG8gaW5kZXggdGhhdCB3aWxsIGJl IHBhc3NlZCB0byB0aGUgbWF0Y2hpbmcgZHJtX2Rldl9leGl0KCkKPiArICoKPiArICogVGhpcyBm dW5jdGlvbiBtYXJrcyBhbmQgcHJvdGVjdHMgdGhlIGJlZ2lubmluZyBvZiBhIHNlY3Rpb24gdGhh dCBzaG91bGQgbm90Cj4gKyAqIGJlIGVudGVyZWQgYWZ0ZXIgdGhlIGRldmljZSBoYXMgYmVlbiB1 bnBsdWdnZWQuIFRoZSBzZWN0aW9uIGVuZCBpcyBtYXJrZWQKPiArICogd2l0aCBkcm1fZGV2X2V4 aXQoKS4gQ2FsbHMgdG8gdGhpcyBmdW5jdGlvbiBjYW4gYmUgbmVzdGVkLgo+ICsgKgo+ICsgKiBS ZXR1cm5zOgo+ICsgKiBUcnVlIGlmIGl0IGlzIE9LIHRvIGVudGVyIHRoZSBzZWN0aW9uLCBmYWxz ZSBvdGhlcndpc2UuCj4gKyAqLwo+ICtib29sIGRybV9kZXZfZW50ZXIoc3RydWN0IGRybV9kZXZp Y2UgKmRldiwgaW50ICppZHgpCj4gK3sKPiArCSppZHggPSBzcmN1X3JlYWRfbG9jaygmZHJtX3Vu cGx1Z19zcmN1KTsKPiArCj4gKwlpZiAoZGV2LT51bnBsdWdnZWQpIHsKPiArCQlzcmN1X3JlYWRf dW5sb2NrKCZkcm1fdW5wbHVnX3NyY3UsICppZHgpOwo+ICsJCXJldHVybiBmYWxzZTsKPiArCX0K PiArCj4gKwlyZXR1cm4gdHJ1ZTsKPiArfQo+ICtFWFBPUlRfU1lNQk9MKGRybV9kZXZfZW50ZXIp Owo+ICsKPiArLyoqCj4gKyAqIGRybV9kZXZfZXhpdCAtIEV4aXQgZGV2aWNlIGNyaXRpY2FsIHNl Y3Rpb24KPiArICogQGlkeDogaW5kZXggcmV0dXJuZWQgZnJvbSBkcm1fZGV2X2VudGVyKCkKPiAr ICoKPiArICogVGhpcyBmdW5jdGlvbiBtYXJrcyB0aGUgZW5kIG9mIGEgc2VjdGlvbiB0aGF0IHNo b3VsZCBub3QgYmUgZW50ZXJlZCBhZnRlcgo+ICsgKiB0aGUgZGV2aWNlIGhhcyBiZWVuIHVucGx1 Z2dlZC4KPiArICovCj4gK3ZvaWQgZHJtX2Rldl9leGl0KGludCBpZHgpCj4gIHsKPiAtCXNtcF93 bWIoKTsKPiAtCWF0b21pY19zZXQoJmRldi0+dW5wbHVnZ2VkLCAxKTsKPiArCXNyY3VfcmVhZF91 bmxvY2soJmRybV91bnBsdWdfc3JjdSwgaWR4KTsKPiAgfQo+ICtFWFBPUlRfU1lNQk9MKGRybV9k ZXZfZXhpdCk7Cj4gIAo+ICAvKioKPiAgICogZHJtX2Rldl91bnBsdWcgLSB1bnBsdWcgYSBEUk0g ZGV2aWNlCj4gICAqIEBkZXY6IERSTSBkZXZpY2UKPiAgICoKPiAgICogVGhpcyB1bnBsdWdzIGEg aG90cGx1Z2dhYmxlIERSTSBkZXZpY2UsIHdoaWNoIG1ha2VzIGl0IGluYWNjZXNzaWJsZSB0bwo+ IC0gKiB1c2Vyc3BhY2Ugb3BlcmF0aW9ucy4gRW50cnktcG9pbnRzIGNhbiB1c2UgZHJtX2Rldl9p c191bnBsdWdnZWQoKS4gVGhpcwo+ICsgKiB1c2Vyc3BhY2Ugb3BlcmF0aW9ucy4gRW50cnktcG9p bnRzIGNhbiB1c2UgZHJtX2Rldl9lbnRlcigpIGFuZAo+ICsgKiBkcm1fZGV2X2V4aXQoKSB0byBw cm90ZWN0IGRldmljZSByZXNvdXJjZXMgaW4gYSByYWNlIGZyZWUgbWFubmVyLiBUaGlzCj4gICAq IGVzc2VudGlhbGx5IHVucmVnaXN0ZXJzIHRoZSBkZXZpY2UgbGlrZSBkcm1fZGV2X3VucmVnaXN0 ZXIoKSwgYnV0IGNhbiBiZQo+ICAgKiBjYWxsZWQgd2hpbGUgdGhlcmUgYXJlIHN0aWxsIG9wZW4g dXNlcnMgb2YgQGRldi4KPiAgICovCj4gQEAgLTMzOCwxMCArMzc0LDE4IEBAIHZvaWQgZHJtX2Rl dl91bnBsdWcoc3RydWN0IGRybV9kZXZpY2UgKmRldikKPiAgCWRybV9kZXZfdW5yZWdpc3Rlcihk ZXYpOwo+ICAKPiAgCW11dGV4X2xvY2soJmRybV9nbG9iYWxfbXV0ZXgpOwo+IC0JZHJtX2Rldmlj ZV9zZXRfdW5wbHVnZ2VkKGRldik7Cj4gIAlpZiAoZGV2LT5vcGVuX2NvdW50ID09IDApCj4gIAkJ ZHJtX2Rldl9wdXQoZGV2KTsKPiAgCW11dGV4X3VubG9jaygmZHJtX2dsb2JhbF9tdXRleCk7Cj4g Kwo+ICsJLyoKPiArCSAqIEFmdGVyIHN5bmNocm9uaXppbmcgYW55IGNyaXRpY2FsIHJlYWQgc2Vj dGlvbiBpcyBndWFyYW50ZWVkIHRvIHNlZQo+ICsJICogdGhlIG5ldyB2YWx1ZSBvZiAtPnVucGx1 Z2dlZCwgYW5kIGFueSBjcml0aWNhbCBzZWN0aW9uIHdoaWNoIG1pZ2h0Cj4gKwkgKiBzdGlsbCBo YXZlIHNlZW4gdGhlIG9sZCB2YWx1ZSBvZiAtPnVucGx1Z2dlZCBpcyBndWFyYW50ZWVkIHRvIGhh dmUKPiArCSAqIGZpbmlzaGVkLgo+ICsJICovCj4gKwlkZXYtPnVucGx1Z2dlZCA9IHRydWU7Cj4g KwlzeW5jaHJvbml6ZV9zcmN1KCZkcm1fdW5wbHVnX3NyY3UpOwo+ICB9Cj4gIEVYUE9SVF9TWU1C T0woZHJtX2Rldl91bnBsdWcpOwo+ICAKPiBkaWZmIC0tZ2l0IGEvaW5jbHVkZS9kcm0vZHJtX2Rl dmljZS5oIGIvaW5jbHVkZS9kcm0vZHJtX2RldmljZS5oCj4gaW5kZXggN2M0ZmEzMmYzZmM2Li4z YTBlYWMyODg1YjcgMTAwNjQ0Cj4gLS0tIGEvaW5jbHVkZS9kcm0vZHJtX2RldmljZS5oCj4gKysr IGIvaW5jbHVkZS9kcm0vZHJtX2RldmljZS5oCj4gQEAgLTQ2LDcgKzQ2LDE0IEBAIHN0cnVjdCBk cm1fZGV2aWNlIHsKPiAgCS8qIGN1cnJlbnRseSBhY3RpdmUgbWFzdGVyIGZvciB0aGlzIGRldmlj ZS4gUHJvdGVjdGVkIGJ5IG1hc3Rlcl9tdXRleCAqLwo+ICAJc3RydWN0IGRybV9tYXN0ZXIgKm1h c3RlcjsKPiAgCj4gLQlhdG9taWNfdCB1bnBsdWdnZWQ7CQkJLyoqPCBGbGFnIHdoZXRoZXIgZGV2 IGlzIGRlYWQgKi8KPiArCS8qKgo+ICsJICogQHVucGx1Z2dlZDoKPiArCSAqCj4gKwkgKiBGbGFn IHRvIHRlbGwgaWYgdGhlIGRldmljZSBoYXMgYmVlbiB1bnBsdWdnZWQuCj4gKwkgKiBTZWUgZHJt X2Rldl9lbnRlcigpIGFuZCBkcm1fZGV2X2lzX3VucGx1Z2dlZCgpLgo+ICsJICovCj4gKwlib29s IHVucGx1Z2dlZDsKPiArCj4gIAlzdHJ1Y3QgaW5vZGUgKmFub25faW5vZGU7CQkvKio8IGlub2Rl IGZvciBwcml2YXRlIGFkZHJlc3Mtc3BhY2UgKi8KPiAgCWNoYXIgKnVuaXF1ZTsJCQkJLyoqPCB1 bmlxdWUgbmFtZSBvZiB0aGUgZGV2aWNlICovCj4gIAkvKkB9ICovCj4gZGlmZiAtLWdpdCBhL2lu Y2x1ZGUvZHJtL2RybV9kcnYuaCBiL2luY2x1ZGUvZHJtL2RybV9kcnYuaAo+IGluZGV4IGQyM2Rj ZGQxYmQ5NS4uN2U1NDVmNWY5NGQzIDEwMDY0NAo+IC0tLSBhL2luY2x1ZGUvZHJtL2RybV9kcnYu aAo+ICsrKyBiL2luY2x1ZGUvZHJtL2RybV9kcnYuaAo+IEBAIC02MjQsNiArNjI0LDggQEAgdm9p ZCBkcm1fZGV2X2dldChzdHJ1Y3QgZHJtX2RldmljZSAqZGV2KTsKPiAgdm9pZCBkcm1fZGV2X3B1 dChzdHJ1Y3QgZHJtX2RldmljZSAqZGV2KTsKPiAgdm9pZCBkcm1fZGV2X3VucmVmKHN0cnVjdCBk cm1fZGV2aWNlICpkZXYpOwo+ICB2b2lkIGRybV9wdXRfZGV2KHN0cnVjdCBkcm1fZGV2aWNlICpk ZXYpOwo+ICtib29sIGRybV9kZXZfZW50ZXIoc3RydWN0IGRybV9kZXZpY2UgKmRldiwgaW50ICpp ZHgpOwo+ICt2b2lkIGRybV9kZXZfZXhpdChpbnQgaWR4KTsKPiAgdm9pZCBkcm1fZGV2X3VucGx1 ZyhzdHJ1Y3QgZHJtX2RldmljZSAqZGV2KTsKPiAgCj4gIC8qKgo+IEBAIC02MzUsMTEgKzYzNywx NiBAQCB2b2lkIGRybV9kZXZfdW5wbHVnKHN0cnVjdCBkcm1fZGV2aWNlICpkZXYpOwo+ICAgKiB1 bnBsdWdnZWQsIHRoZXNlIHR3byBmdW5jdGlvbnMgZ3VhcmFudGVlIHRoYXQgYW55IHN0b3JlIGJl Zm9yZSBjYWxsaW5nCj4gICAqIGRybV9kZXZfdW5wbHVnKCkgaXMgdmlzaWJsZSB0byBjYWxsZXJz IG9mIHRoaXMgZnVuY3Rpb24gYWZ0ZXIgaXQgY29tcGxldGVzCj4gICAqLwo+IC1zdGF0aWMgaW5s aW5lIGludCBkcm1fZGV2X2lzX3VucGx1Z2dlZChzdHJ1Y3QgZHJtX2RldmljZSAqZGV2KQo+ICtz dGF0aWMgaW5saW5lIGJvb2wgZHJtX2Rldl9pc191bnBsdWdnZWQoc3RydWN0IGRybV9kZXZpY2Ug KmRldikKPiAgewo+IC0JaW50IHJldCA9IGF0b21pY19yZWFkKCZkZXYtPnVucGx1Z2dlZCk7Cj4g LQlzbXBfcm1iKCk7Cj4gLQlyZXR1cm4gcmV0Owo+ICsJaW50IGlkeDsKPiArCj4gKwlpZiAoZHJt X2Rldl9lbnRlcihkZXYsICZpZHgpKSB7Cj4gKwkJZHJtX2Rldl9leGl0KGlkeCk7Cj4gKwkJcmV0 dXJuIGZhbHNlOwo+ICsJfQo+ICsKPiArCXJldHVybiB0cnVlOwo+ICB9Cj4gIAo+ICAKPiAtLSAK PiAyLjcuNAo+IAo+IF9fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fCj4gZHJpLWRldmVsIG1haWxpbmcgbGlzdAo+IGRyaS1kZXZlbEBsaXN0cy5mcmVlZGVza3Rv cC5vcmcKPiBodHRwczovL2xpc3RzLmZyZWVkZXNrdG9wLm9yZy9tYWlsbWFuL2xpc3RpbmZvL2Ry aS1kZXZlbAoKLS0gCkRhbmllbCBWZXR0ZXIKU29mdHdhcmUgRW5naW5lZXIsIEludGVsIENvcnBv cmF0aW9uCmh0dHA6Ly9ibG9nLmZmd2xsLmNoCl9fX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fCkludGVsLWdmeCBtYWlsaW5nIGxpc3QKSW50ZWwtZ2Z4QGxpc3Rz LmZyZWVkZXNrdG9wLm9yZwpodHRwczovL2xpc3RzLmZyZWVkZXNrdG9wLm9yZy9tYWlsbWFuL2xp c3RpbmZvL2ludGVsLWdmeAo=