From mboxrd@z Thu Jan 1 00:00:00 1970 From: Bartlomiej Zolnierkiewicz Date: Wed, 25 Jul 2018 11:51:42 +0000 Subject: Re: [PATCH] fb: fix lost console when the user unplugs a USB adapter Message-Id: <1975707.vO8kdHz3oS@amdc3058> List-Id: References: <6008699.T6Yd1fn3Dk@amdc3058> In-Reply-To: MIME-Version: 1.0 Content-Type: text/plain; charset="us-ascii" Content-Transfer-Encoding: 7bit To: Mikulas Patocka Cc: Dave Airlie , linux-fbdev@vger.kernel.org, Ladislav Michl , Bernie Thompson , dri-devel@lists.freedesktop.org On Monday, July 09, 2018 10:29:40 PM Mikulas Patocka wrote: > > On Wed, 4 Jul 2018, Bartlomiej Zolnierkiewicz wrote: > > > On Tuesday, July 03, 2018 01:18:57 PM Mikulas Patocka wrote: > > > > > > On Tue, 3 Jul 2018, Bartlomiej Zolnierkiewicz wrote: > > > > > > > Hi, > > > > > > > > On Sunday, June 03, 2018 11:46:29 AM Mikulas Patocka wrote: > > > > > I have a USB display adapter using the udlfb driver and I use it on an ARM > > > > > board that doesn't have any graphics card. When I plug the adapter in, the > > > > > console is properly displayed, however when I unplug and re-plug the > > > > > adapter, the console is not displayed and I can't access it until I reboot > > > > > the board. > > > > > > > > > > The reason is this: > > > > > When the adapter is unplugged, dlfb_usb_disconnect calls > > > > > unlink_framebuffer, then it waits until the reference count drops to zero > > > > > and then it deallocates the framebuffer. However, the console that is > > > > > attached to the framebuffer device keeps the reference count non-zero, so > > > > > the framebuffer device is never destroyed. When the USB adapter is plugged > > > > > again, it creates a new device /dev/fb1 and the console is not attached to > > > > > it. > > > > > > > > > > This patch fixes the bug by unbinding the console from unlink_framebuffer. > > > > > The code to unbind the console is moved from do_unregister_framebuffer to > > > > > a function unbind_console. When the console is unbound, the reference > > > > > count drops to zero and the udlfb driver frees the framebuffer. When the > > > > > adapter is plugged back, a new framebuffer is created and the console is > > > > > attached to it. > > > > > > > > > > Signed-off-by: Mikulas Patocka > > > > > Cc: stable@vger.kernel.org > > > > > > > > After this change unbind_console() will be called twice in the standard > > > > framebuffer unregister path: > > > > > > > > - first time, directly by do_unregister_framebuffer() > > > > > > > > - second time, indirectly by do_unregister_framebuffer()->unlink_framebuffer() > > > > > > > > This doesn't look correctly. > > > > > > unbind_console calls the FB_EVENT_FB_UNBIND notifier, FB_EVENT_FB_UNBIND > > > goes to the function fbcon_fb_unbind and fbcon_fb_unbind checks if the > > > console is bound to the framebuffer for which unbind is requested. So a > > > double call won't cause any trouble. > > > > Even if it works okay currently it is not a best design to send duplicate > > events - especially since this can be easily avoided (for non-udlfb users) > > by: > > > > - renaming "vanilla" unlink_framebuffer() to __unlink_framebuffer() > > > > - converting do_unregister_framebuffer() to use __unlink_framebuffer() > > > > - adding "new" unlink_framebuffer() that will also call unbind_console() > > > > > > Also why can't udlfb just use unregister_framebuffer() like all other > > > > drivers (it uses unlink_framebuffer() and it is the only user of this > > > > helper)? > > > > > > It uses unregister_framebuffer() - but - unregister_framebuffer() may only > > > be called when the open count of the framebuffer is zero. So, the udlfb > > > driver waits until the open count drops to zero and then calls > > > unregister_framebuffer(). > > > > > > But the console subsystem keeps the framebuffer open - which means that if > > > user use unplugs the USB adapter, the open count won't drop to zero > > > (because the console is bound to it) - which means that > > > unregister_framebuffer() will not be called. > > > > Is it a really the console subsystem and not the user-space keeping > > /dev/fb0 (with console binded to fb0) opened after the USB device > > vanishes? > > Yes - I unplugged the adapter without Xserver running and without any > other framebuffer application running - the console keeps it open. > > > After re-plugging the USB device /dev/fb0 stays and /dev/fb1 > > appears, right? > > The file /dev/fb0 is deleted (because dlfb_usb_disconnect calls > unlink_framebuffer), but it is kept in the kernel. When I re-plug the > adapter, /dev/fb1 is created but the console is still bound to /dev/fb0. > When the adapter is re-plugged, it shows just a green screen. > > > I also mean that unregister_framebuffer() should be called instead > > unlink_framebuffer(), not additionally some time later as it is done > > currently. > > Can unregister_framebuffer() be called when /dev/fb0 is open as a file > handle and/or mapped to some process? It should be OK. > > Moreover the dlfb <-> fb_info locking scheme seems to be reversed > > (+racy) as it is dlfb that should control lifetime of fb_info, then > > in dlfb_free() we should just call framebuffer_release() etc. > > How should in your opinion framebuffer destruction work? > > Should the driver count the number of users and call > unregister_framebuffer() when it drops to zero? > > Or should the driver call unregister_framebuffer() unconditionally when > the device is unplugged and destroy the device in the "fb_destroy" > callback? (fb_destroy seems to be called by the framebuffer subsystem when > the open count reaches zero) The driver should call unregister_framebuffer() unconditionally in dlfb_usb_disconnect() (instead of calling unlink_framebuffer()). Anyway it seems that this would require major reworking of the driver and I think that it would be better to put efforts into fixing udl-kms driver instead. For now I have queued your patch (with __unregister_framebuffer() change to keep the old behavior for non-udlfb drivers) for v4.19 (patch attached at the end of this mail). > If I grep the kernel for fb_destroy, very few framebuffer drivers use it. > > > BTW comment in dlfb_ops_release(): > > > > /* We can't free fb_info here - fbmem will touch it when we return */ > > > > seems to be wrong as fbmem keeps an extra reference on fb_info > > during ->fb_release(). > > > > > You must unbind the console before calling unregister_framebuffer(). The > > > > Hmm? The first thing that [do_]unregister_framebuffer) does seems to be > > unbinding the console. > > > > > PCI framebuffer drivers don't have this problem because the user is not > > > expected to just unplug the PCI card while it is being used by the > > > console. > > > > PCI framebuffer drivers currently don't use .suppress_bind_attrs driver > > flag so the PCI devices can be unbinded at any time by using sysfs "unbind" > > functionality (I guess we should be using .suppress_bind_attrs flag if it > > doesn't work currently). > > I tested matrox PCI framebuffer driver on an old computer - and it suffers > from the same problem as udlfb. The matrox driver keeps the open count and > destroys itself when the open count reaches zero - but the console that is > bound to the driver prevents the open count from reaching zero - so if I > unbind the PCI device in sysfs, it does nothing and the console is still > active and works. matroxfb is a not a good reference driver as it also defers the call to unregister_framebuffer() when the device is unplugged: static void matroxfb_remove(struct matrox_fb_info *minfo, int dummy) { ... minfo->dead = 1; if (minfo->usecount) { /* destroy it later */ --> return; } matroxfb_unregister_device(minfo); unregister_framebuffer(&minfo->fbcon); ... } Best regards, -- Bartlomiej Zolnierkiewicz Samsung R&D Institute Poland Samsung Electronics From: Mikulas Patocka Subject: [PATCH] fb: fix lost console when the user unplugs a USB adapter I have a USB display adapter using the udlfb driver and I use it on an ARM board that doesn't have any graphics card. When I plug the adapter in, the console is properly displayed, however when I unplug and re-plug the adapter, the console is not displayed and I can't access it until I reboot the board. The reason is this: When the adapter is unplugged, dlfb_usb_disconnect calls unlink_framebuffer, then it waits until the reference count drops to zero and then it deallocates the framebuffer. However, the console that is attached to the framebuffer device keeps the reference count non-zero, so the framebuffer device is never destroyed. When the USB adapter is plugged again, it creates a new device /dev/fb1 and the console is not attached to it. This patch fixes the bug by unbinding the console from unlink_framebuffer. The code to unbind the console is moved from do_unregister_framebuffer to a function unbind_console. When the console is unbound, the reference count drops to zero and the udlfb driver frees the framebuffer. When the adapter is plugged back, a new framebuffer is created and the console is attached to it. Signed-off-by: Mikulas Patocka Cc: Dave Airlie Cc: Bernie Thompson Cc: Ladislav Michl Cc: stable@vger.kernel.org [b.zolnierkie: preserve old behavior for do_unregister_framebuffer()] Signed-off-by: Bartlomiej Zolnierkiewicz --- drivers/video/fbdev/core/fbmem.c | 38 ++++++++++++++++++++++++++++++++------ 1 file changed, 32 insertions(+), 6 deletions(-) Index: b/drivers/video/fbdev/core/fbmem.c =================================--- a/drivers/video/fbdev/core/fbmem.c 2018-07-25 12:49:21.668763429 +0200 +++ b/drivers/video/fbdev/core/fbmem.c 2018-07-25 12:51:42.824766984 +0200 @@ -1703,12 +1703,12 @@ static int do_register_framebuffer(struc return 0; } -static int do_unregister_framebuffer(struct fb_info *fb_info) +static int unbind_console(struct fb_info *fb_info) { struct fb_event event; - int i, ret = 0; + int ret; + int i = fb_info->node; - i = fb_info->node; if (i < 0 || i >= FB_MAX || registered_fb[i] != fb_info) return -EINVAL; @@ -1723,17 +1723,29 @@ static int do_unregister_framebuffer(str unlock_fb_info(fb_info); console_unlock(); + return ret; +} + +static int __unlink_framebuffer(struct fb_info *fb_info); + +static int do_unregister_framebuffer(struct fb_info *fb_info) +{ + struct fb_event event; + int ret; + + ret = unbind_console(fb_info); + if (ret) return -EINVAL; pm_vt_switch_unregister(fb_info->dev); - unlink_framebuffer(fb_info); + __unlink_framebuffer(fb_info); if (fb_info->pixmap.addr && (fb_info->pixmap.flags & FB_PIXMAP_DEFAULT)) kfree(fb_info->pixmap.addr); fb_destroy_modelist(&fb_info->modelist); - registered_fb[i] = NULL; + registered_fb[fb_info->node] = NULL; num_registered_fb--; fb_cleanup_device(fb_info); event.info = fb_info; @@ -1746,7 +1758,7 @@ static int do_unregister_framebuffer(str return 0; } -int unlink_framebuffer(struct fb_info *fb_info) +static int __unlink_framebuffer(struct fb_info *fb_info) { int i; @@ -1758,6 +1770,20 @@ int unlink_framebuffer(struct fb_info *f device_destroy(fb_class, MKDEV(FB_MAJOR, i)); fb_info->dev = NULL; } + + return 0; +} + +int unlink_framebuffer(struct fb_info *fb_info) +{ + int ret; + + ret = __unlink_framebuffer(fb_info); + if (ret) + return ret; + + unbind_console(fb_info); + return 0; } EXPORT_SYMBOL(unlink_framebuffer); From mboxrd@z Thu Jan 1 00:00:00 1970 From: Bartlomiej Zolnierkiewicz Subject: Re: [PATCH] fb: fix lost console when the user unplugs a USB adapter Date: Wed, 25 Jul 2018 13:51:42 +0200 Message-ID: <1975707.vO8kdHz3oS@amdc3058> References: <6008699.T6Yd1fn3Dk@amdc3058> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Return-path: Received: from mailout1.w1.samsung.com (mailout1.w1.samsung.com [210.118.77.11]) by gabe.freedesktop.org (Postfix) with ESMTPS id 2E11189D6C for ; Wed, 25 Jul 2018 11:51:46 +0000 (UTC) In-reply-to: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: dri-devel-bounces@lists.freedesktop.org Sender: "dri-devel" To: Mikulas Patocka Cc: Dave Airlie , linux-fbdev@vger.kernel.org, Ladislav Michl , Bernie Thompson , dri-devel@lists.freedesktop.org List-Id: dri-devel@lists.freedesktop.org T24gTW9uZGF5LCBKdWx5IDA5LCAyMDE4IDEwOjI5OjQwIFBNIE1pa3VsYXMgUGF0b2NrYSB3cm90 ZToKPiAKPiBPbiBXZWQsIDQgSnVsIDIwMTgsIEJhcnRsb21pZWogWm9sbmllcmtpZXdpY3ogd3Jv dGU6Cj4gCj4gPiBPbiBUdWVzZGF5LCBKdWx5IDAzLCAyMDE4IDAxOjE4OjU3IFBNIE1pa3VsYXMg UGF0b2NrYSB3cm90ZToKPiA+ID4gCj4gPiA+IE9uIFR1ZSwgMyBKdWwgMjAxOCwgQmFydGxvbWll aiBab2xuaWVya2lld2ljeiB3cm90ZToKPiA+ID4gCj4gPiA+ID4gSGksCj4gPiA+ID4gCj4gPiA+ ID4gT24gU3VuZGF5LCBKdW5lIDAzLCAyMDE4IDExOjQ2OjI5IEFNIE1pa3VsYXMgUGF0b2NrYSB3 cm90ZToKPiA+ID4gPiA+IEkgaGF2ZSBhIFVTQiBkaXNwbGF5IGFkYXB0ZXIgdXNpbmcgdGhlIHVk bGZiIGRyaXZlciBhbmQgSSB1c2UgaXQgb24gYW4gQVJNCj4gPiA+ID4gPiBib2FyZCB0aGF0IGRv ZXNuJ3QgaGF2ZSBhbnkgZ3JhcGhpY3MgY2FyZC4gV2hlbiBJIHBsdWcgdGhlIGFkYXB0ZXIgaW4s IHRoZQo+ID4gPiA+ID4gY29uc29sZSBpcyBwcm9wZXJseSBkaXNwbGF5ZWQsIGhvd2V2ZXIgd2hl biBJIHVucGx1ZyBhbmQgcmUtcGx1ZyB0aGUKPiA+ID4gPiA+IGFkYXB0ZXIsIHRoZSBjb25zb2xl IGlzIG5vdCBkaXNwbGF5ZWQgYW5kIEkgY2FuJ3QgYWNjZXNzIGl0IHVudGlsIEkgcmVib290Cj4g PiA+ID4gPiB0aGUgYm9hcmQuCj4gPiA+ID4gPiAKPiA+ID4gPiA+IFRoZSByZWFzb24gaXMgdGhp czoKPiA+ID4gPiA+IFdoZW4gdGhlIGFkYXB0ZXIgaXMgdW5wbHVnZ2VkLCBkbGZiX3VzYl9kaXNj b25uZWN0IGNhbGxzCj4gPiA+ID4gPiB1bmxpbmtfZnJhbWVidWZmZXIsIHRoZW4gaXQgd2FpdHMg dW50aWwgdGhlIHJlZmVyZW5jZSBjb3VudCBkcm9wcyB0byB6ZXJvCj4gPiA+ID4gPiBhbmQgdGhl biBpdCBkZWFsbG9jYXRlcyB0aGUgZnJhbWVidWZmZXIuIEhvd2V2ZXIsIHRoZSBjb25zb2xlIHRo YXQgaXMKPiA+ID4gPiA+IGF0dGFjaGVkIHRvIHRoZSBmcmFtZWJ1ZmZlciBkZXZpY2Uga2VlcHMg dGhlIHJlZmVyZW5jZSBjb3VudCBub24temVybywgc28KPiA+ID4gPiA+IHRoZSBmcmFtZWJ1ZmZl ciBkZXZpY2UgaXMgbmV2ZXIgZGVzdHJveWVkLiBXaGVuIHRoZSBVU0IgYWRhcHRlciBpcyBwbHVn Z2VkCj4gPiA+ID4gPiBhZ2FpbiwgaXQgY3JlYXRlcyBhIG5ldyBkZXZpY2UgL2Rldi9mYjEgYW5k IHRoZSBjb25zb2xlIGlzIG5vdCBhdHRhY2hlZCB0bwo+ID4gPiA+ID4gaXQuCj4gPiA+ID4gPiAK PiA+ID4gPiA+IFRoaXMgcGF0Y2ggZml4ZXMgdGhlIGJ1ZyBieSB1bmJpbmRpbmcgdGhlIGNvbnNv bGUgZnJvbSB1bmxpbmtfZnJhbWVidWZmZXIuCj4gPiA+ID4gPiBUaGUgY29kZSB0byB1bmJpbmQg dGhlIGNvbnNvbGUgaXMgbW92ZWQgZnJvbSBkb191bnJlZ2lzdGVyX2ZyYW1lYnVmZmVyIHRvCj4g PiA+ID4gPiBhIGZ1bmN0aW9uIHVuYmluZF9jb25zb2xlLiBXaGVuIHRoZSBjb25zb2xlIGlzIHVu Ym91bmQsIHRoZSByZWZlcmVuY2UKPiA+ID4gPiA+IGNvdW50IGRyb3BzIHRvIHplcm8gYW5kIHRo ZSB1ZGxmYiBkcml2ZXIgZnJlZXMgdGhlIGZyYW1lYnVmZmVyLiBXaGVuIHRoZQo+ID4gPiA+ID4g YWRhcHRlciBpcyBwbHVnZ2VkIGJhY2ssIGEgbmV3IGZyYW1lYnVmZmVyIGlzIGNyZWF0ZWQgYW5k IHRoZSBjb25zb2xlIGlzCj4gPiA+ID4gPiBhdHRhY2hlZCB0byBpdC4KPiA+ID4gPiA+IAo+ID4g PiA+ID4gU2lnbmVkLW9mZi1ieTogTWlrdWxhcyBQYXRvY2thIDxtcGF0b2NrYUByZWRoYXQuY29t Pgo+ID4gPiA+ID4gQ2M6IHN0YWJsZUB2Z2VyLmtlcm5lbC5vcmcKPiA+ID4gPiAKPiA+ID4gPiBB ZnRlciB0aGlzIGNoYW5nZSB1bmJpbmRfY29uc29sZSgpIHdpbGwgYmUgY2FsbGVkIHR3aWNlIGlu IHRoZSBzdGFuZGFyZAo+ID4gPiA+IGZyYW1lYnVmZmVyIHVucmVnaXN0ZXIgcGF0aDoKPiA+ID4g PiAKPiA+ID4gPiAtIGZpcnN0IHRpbWUsIGRpcmVjdGx5IGJ5IGRvX3VucmVnaXN0ZXJfZnJhbWVi dWZmZXIoKQo+ID4gPiA+IAo+ID4gPiA+IC0gc2Vjb25kIHRpbWUsIGluZGlyZWN0bHkgYnkgZG9f dW5yZWdpc3Rlcl9mcmFtZWJ1ZmZlcigpLT51bmxpbmtfZnJhbWVidWZmZXIoKQo+ID4gPiA+IAo+ ID4gPiA+IFRoaXMgZG9lc24ndCBsb29rIGNvcnJlY3RseS4KPiA+ID4gCj4gPiA+IHVuYmluZF9j b25zb2xlIGNhbGxzIHRoZSBGQl9FVkVOVF9GQl9VTkJJTkQgbm90aWZpZXIsIEZCX0VWRU5UX0ZC X1VOQklORCAKPiA+ID4gZ29lcyB0byB0aGUgZnVuY3Rpb24gZmJjb25fZmJfdW5iaW5kIGFuZCBm YmNvbl9mYl91bmJpbmQgY2hlY2tzIGlmIHRoZSAKPiA+ID4gY29uc29sZSBpcyBib3VuZCB0byB0 aGUgZnJhbWVidWZmZXIgZm9yIHdoaWNoIHVuYmluZCBpcyByZXF1ZXN0ZWQuIFNvIGEgCj4gPiA+ IGRvdWJsZSBjYWxsIHdvbid0IGNhdXNlIGFueSB0cm91YmxlLgo+ID4gCj4gPiBFdmVuIGlmIGl0 IHdvcmtzIG9rYXkgY3VycmVudGx5IGl0IGlzIG5vdCBhIGJlc3QgZGVzaWduIHRvIHNlbmQgZHVw bGljYXRlCj4gPiBldmVudHMgLSBlc3BlY2lhbGx5IHNpbmNlIHRoaXMgY2FuIGJlIGVhc2lseSBh dm9pZGVkIChmb3Igbm9uLXVkbGZiIHVzZXJzKQo+ID4gYnk6Cj4gPiAKPiA+IC0gcmVuYW1pbmcg InZhbmlsbGEiIHVubGlua19mcmFtZWJ1ZmZlcigpIHRvIF9fdW5saW5rX2ZyYW1lYnVmZmVyKCkK PiA+IAo+ID4gLSBjb252ZXJ0aW5nIGRvX3VucmVnaXN0ZXJfZnJhbWVidWZmZXIoKSB0byB1c2Ug X191bmxpbmtfZnJhbWVidWZmZXIoKQo+ID4gCj4gPiAtIGFkZGluZyAibmV3IiB1bmxpbmtfZnJh bWVidWZmZXIoKSB0aGF0IHdpbGwgYWxzbyBjYWxsIHVuYmluZF9jb25zb2xlKCkKPiA+IAo+ID4g PiA+IEFsc28gd2h5IGNhbid0IHVkbGZiIGp1c3QgdXNlIHVucmVnaXN0ZXJfZnJhbWVidWZmZXIo KSBsaWtlIGFsbCBvdGhlcgo+ID4gPiA+IGRyaXZlcnMgKGl0IHVzZXMgdW5saW5rX2ZyYW1lYnVm ZmVyKCkgYW5kIGl0IGlzIHRoZSBvbmx5IHVzZXIgb2YgdGhpcwo+ID4gPiA+IGhlbHBlcik/Cj4g PiA+IAo+ID4gPiBJdCB1c2VzIHVucmVnaXN0ZXJfZnJhbWVidWZmZXIoKSAtIGJ1dCAtIHVucmVn aXN0ZXJfZnJhbWVidWZmZXIoKSBtYXkgb25seSAKPiA+ID4gYmUgY2FsbGVkIHdoZW4gdGhlIG9w ZW4gY291bnQgb2YgdGhlIGZyYW1lYnVmZmVyIGlzIHplcm8uIFNvLCB0aGUgdWRsZmIgCj4gPiA+ IGRyaXZlciB3YWl0cyB1bnRpbCB0aGUgb3BlbiBjb3VudCBkcm9wcyB0byB6ZXJvIGFuZCB0aGVu IGNhbGxzIAo+ID4gPiB1bnJlZ2lzdGVyX2ZyYW1lYnVmZmVyKCkuCj4gPiA+IAo+ID4gPiBCdXQg dGhlIGNvbnNvbGUgc3Vic3lzdGVtIGtlZXBzIHRoZSBmcmFtZWJ1ZmZlciBvcGVuIC0gd2hpY2gg bWVhbnMgdGhhdCBpZiAKPiA+ID4gdXNlciB1c2UgdW5wbHVncyB0aGUgVVNCIGFkYXB0ZXIsIHRo ZSBvcGVuIGNvdW50IHdvbid0IGRyb3AgdG8gemVybyAKPiA+ID4gKGJlY2F1c2UgdGhlIGNvbnNv bGUgaXMgYm91bmQgdG8gaXQpIC0gd2hpY2ggbWVhbnMgdGhhdCAKPiA+ID4gdW5yZWdpc3Rlcl9m cmFtZWJ1ZmZlcigpIHdpbGwgbm90IGJlIGNhbGxlZC4KPiA+IAo+ID4gSXMgaXQgYSByZWFsbHkg dGhlIGNvbnNvbGUgc3Vic3lzdGVtIGFuZCBub3QgdGhlIHVzZXItc3BhY2Uga2VlcGluZwo+ID4g L2Rldi9mYjAgKHdpdGggY29uc29sZSBiaW5kZWQgdG8gZmIwKSBvcGVuZWQgYWZ0ZXIgdGhlIFVT QiBkZXZpY2UKPiA+IHZhbmlzaGVzPwo+IAo+IFllcyAtIEkgdW5wbHVnZ2VkIHRoZSBhZGFwdGVy IHdpdGhvdXQgWHNlcnZlciBydW5uaW5nIGFuZCB3aXRob3V0IGFueSAKPiBvdGhlciBmcmFtZWJ1 ZmZlciBhcHBsaWNhdGlvbiBydW5uaW5nIC0gdGhlIGNvbnNvbGUga2VlcHMgaXQgb3Blbi4KPiAK PiA+IEFmdGVyIHJlLXBsdWdnaW5nIHRoZSBVU0IgZGV2aWNlIC9kZXYvZmIwIHN0YXlzIGFuZCAv ZGV2L2ZiMQo+ID4gYXBwZWFycywgcmlnaHQ/Cj4gCj4gVGhlIGZpbGUgL2Rldi9mYjAgaXMgZGVs ZXRlZCAoYmVjYXVzZSBkbGZiX3VzYl9kaXNjb25uZWN0IGNhbGxzIAo+IHVubGlua19mcmFtZWJ1 ZmZlciksIGJ1dCBpdCBpcyBrZXB0IGluIHRoZSBrZXJuZWwuIFdoZW4gSSByZS1wbHVnIHRoZSAK PiBhZGFwdGVyLCAvZGV2L2ZiMSBpcyBjcmVhdGVkIGJ1dCB0aGUgY29uc29sZSBpcyBzdGlsbCBi b3VuZCB0byAvZGV2L2ZiMC4gCj4gV2hlbiB0aGUgYWRhcHRlciBpcyByZS1wbHVnZ2VkLCBpdCBz aG93cyBqdXN0IGEgZ3JlZW4gc2NyZWVuLgo+IAo+ID4gSSBhbHNvIG1lYW4gdGhhdCB1bnJlZ2lz dGVyX2ZyYW1lYnVmZmVyKCkgc2hvdWxkIGJlIGNhbGxlZCBpbnN0ZWFkCj4gPiB1bmxpbmtfZnJh bWVidWZmZXIoKSwgbm90IGFkZGl0aW9uYWxseSBzb21lIHRpbWUgbGF0ZXIgYXMgaXQgaXMgZG9u ZQo+ID4gY3VycmVudGx5Lgo+IAo+IENhbiB1bnJlZ2lzdGVyX2ZyYW1lYnVmZmVyKCkgYmUgY2Fs bGVkIHdoZW4gL2Rldi9mYjAgaXMgb3BlbiBhcyBhIGZpbGUgCj4gaGFuZGxlIGFuZC9vciBtYXBw ZWQgdG8gc29tZSBwcm9jZXNzPwoKSXQgc2hvdWxkIGJlIE9LLgoKPiA+IE1vcmVvdmVyIHRoZSBk bGZiIDwtPiBmYl9pbmZvIGxvY2tpbmcgc2NoZW1lIHNlZW1zIHRvIGJlIHJldmVyc2VkCj4gPiAo K3JhY3kpIGFzIGl0IGlzIGRsZmIgdGhhdCBzaG91bGQgY29udHJvbCBsaWZldGltZSBvZiBmYl9p bmZvLCB0aGVuCj4gPiBpbiBkbGZiX2ZyZWUoKSB3ZSBzaG91bGQganVzdCBjYWxsIGZyYW1lYnVm ZmVyX3JlbGVhc2UoKSBldGMuCj4gCj4gSG93IHNob3VsZCBpbiB5b3VyIG9waW5pb24gZnJhbWVi dWZmZXIgZGVzdHJ1Y3Rpb24gd29yaz8KPiAKPiBTaG91bGQgdGhlIGRyaXZlciBjb3VudCB0aGUg bnVtYmVyIG9mIHVzZXJzIGFuZCBjYWxsIAo+IHVucmVnaXN0ZXJfZnJhbWVidWZmZXIoKSB3aGVu IGl0IGRyb3BzIHRvIHplcm8/Cj4gCj4gT3Igc2hvdWxkIHRoZSBkcml2ZXIgY2FsbCB1bnJlZ2lz dGVyX2ZyYW1lYnVmZmVyKCkgdW5jb25kaXRpb25hbGx5IHdoZW4gCj4gdGhlIGRldmljZSBpcyB1 bnBsdWdnZWQgYW5kIGRlc3Ryb3kgdGhlIGRldmljZSBpbiB0aGUgImZiX2Rlc3Ryb3kiIAo+IGNh bGxiYWNrPyAoZmJfZGVzdHJveSBzZWVtcyB0byBiZSBjYWxsZWQgYnkgdGhlIGZyYW1lYnVmZmVy IHN1YnN5c3RlbSB3aGVuIAo+IHRoZSBvcGVuIGNvdW50IHJlYWNoZXMgemVybykKClRoZSBkcml2 ZXIgc2hvdWxkIGNhbGwgdW5yZWdpc3Rlcl9mcmFtZWJ1ZmZlcigpIHVuY29uZGl0aW9uYWxseSBp bgpkbGZiX3VzYl9kaXNjb25uZWN0KCkgKGluc3RlYWQgb2YgY2FsbGluZyB1bmxpbmtfZnJhbWVi dWZmZXIoKSkuCgpBbnl3YXkgaXQgc2VlbXMgdGhhdCB0aGlzIHdvdWxkIHJlcXVpcmUgbWFqb3Ig cmV3b3JraW5nIG9mIHRoZSBkcml2ZXIgYW5kCkkgdGhpbmsgdGhhdCBpdCB3b3VsZCBiZSBiZXR0 ZXIgdG8gcHV0IGVmZm9ydHMgaW50byBmaXhpbmcgdWRsLWttcyBkcml2ZXIKaW5zdGVhZC4gRm9y IG5vdyBJIGhhdmUgcXVldWVkIHlvdXIgcGF0Y2ggKHdpdGggX191bnJlZ2lzdGVyX2ZyYW1lYnVm ZmVyKCkKY2hhbmdlIHRvIGtlZXAgdGhlIG9sZCBiZWhhdmlvciBmb3Igbm9uLXVkbGZiIGRyaXZl cnMpIGZvciB2NC4xOSAocGF0Y2gKYXR0YWNoZWQgYXQgdGhlIGVuZCBvZiB0aGlzIG1haWwpLgoK PiBJZiBJIGdyZXAgdGhlIGtlcm5lbCBmb3IgZmJfZGVzdHJveSwgdmVyeSBmZXcgZnJhbWVidWZm ZXIgZHJpdmVycyB1c2UgaXQuCj4gCj4gPiBCVFcgY29tbWVudCBpbiBkbGZiX29wc19yZWxlYXNl KCk6Cj4gPiAKPiA+IC8qIFdlIGNhbid0IGZyZWUgZmJfaW5mbyBoZXJlIC0gZmJtZW0gd2lsbCB0 b3VjaCBpdCB3aGVuIHdlIHJldHVybiAqLwo+ID4gCj4gPiBzZWVtcyB0byBiZSB3cm9uZyBhcyBm Ym1lbSBrZWVwcyBhbiBleHRyYSByZWZlcmVuY2Ugb24gZmJfaW5mbwo+ID4gZHVyaW5nIC0+ZmJf cmVsZWFzZSgpLgo+ID4gCj4gPiA+IFlvdSBtdXN0IHVuYmluZCB0aGUgY29uc29sZSBiZWZvcmUg Y2FsbGluZyB1bnJlZ2lzdGVyX2ZyYW1lYnVmZmVyKCkuIFRoZSAKPiA+IAo+ID4gSG1tPyBUaGUg Zmlyc3QgdGhpbmcgdGhhdCBbZG9fXXVucmVnaXN0ZXJfZnJhbWVidWZmZXIpIGRvZXMgc2VlbXMg dG8gYmUKPiA+IHVuYmluZGluZyB0aGUgY29uc29sZS4KPiA+IAo+ID4gPiBQQ0kgZnJhbWVidWZm ZXIgZHJpdmVycyBkb24ndCBoYXZlIHRoaXMgcHJvYmxlbSBiZWNhdXNlIHRoZSB1c2VyIGlzIG5v dCAKPiA+ID4gZXhwZWN0ZWQgdG8ganVzdCB1bnBsdWcgdGhlIFBDSSBjYXJkIHdoaWxlIGl0IGlz IGJlaW5nIHVzZWQgYnkgdGhlIAo+ID4gPiBjb25zb2xlLgo+ID4gCj4gPiBQQ0kgZnJhbWVidWZm ZXIgZHJpdmVycyBjdXJyZW50bHkgZG9uJ3QgdXNlIC5zdXBwcmVzc19iaW5kX2F0dHJzIGRyaXZl cgo+ID4gZmxhZyBzbyB0aGUgUENJIGRldmljZXMgY2FuIGJlIHVuYmluZGVkIGF0IGFueSB0aW1l IGJ5IHVzaW5nIHN5c2ZzICJ1bmJpbmQiCj4gPiBmdW5jdGlvbmFsaXR5IChJIGd1ZXNzIHdlIHNo b3VsZCBiZSB1c2luZyAuc3VwcHJlc3NfYmluZF9hdHRycyBmbGFnIGlmIGl0Cj4gPiBkb2Vzbid0 IHdvcmsgY3VycmVudGx5KS4KPiAKPiBJIHRlc3RlZCBtYXRyb3ggUENJIGZyYW1lYnVmZmVyIGRy aXZlciBvbiBhbiBvbGQgY29tcHV0ZXIgLSBhbmQgaXQgc3VmZmVycyAKPiBmcm9tIHRoZSBzYW1l IHByb2JsZW0gYXMgdWRsZmIuIFRoZSBtYXRyb3ggZHJpdmVyIGtlZXBzIHRoZSBvcGVuIGNvdW50 IGFuZCAKPiBkZXN0cm95cyBpdHNlbGYgd2hlbiB0aGUgb3BlbiBjb3VudCByZWFjaGVzIHplcm8g LSBidXQgdGhlIGNvbnNvbGUgdGhhdCBpcyAKPiBib3VuZCB0byB0aGUgZHJpdmVyIHByZXZlbnRz IHRoZSBvcGVuIGNvdW50IGZyb20gcmVhY2hpbmcgemVybyAtIHNvIGlmIEkgCj4gdW5iaW5kIHRo ZSBQQ0kgZGV2aWNlIGluIHN5c2ZzLCBpdCBkb2VzIG5vdGhpbmcgYW5kIHRoZSBjb25zb2xlIGlz IHN0aWxsIAo+IGFjdGl2ZSBhbmQgd29ya3MuCgptYXRyb3hmYiBpcyBhIG5vdCBhIGdvb2QgcmVm ZXJlbmNlIGRyaXZlciBhcyBpdCBhbHNvIGRlZmVycyB0aGUgY2FsbCB0bwp1bnJlZ2lzdGVyX2Zy YW1lYnVmZmVyKCkgd2hlbiB0aGUgZGV2aWNlIGlzIHVucGx1Z2dlZDoKCnN0YXRpYyB2b2lkIG1h dHJveGZiX3JlbW92ZShzdHJ1Y3QgbWF0cm94X2ZiX2luZm8gKm1pbmZvLCBpbnQgZHVtbXkpCnsK Li4uCgltaW5mby0+ZGVhZCA9IDE7CglpZiAobWluZm8tPnVzZWNvdW50KSB7CgkJLyogZGVzdHJv eSBpdCBsYXRlciAqLwotLT4JCXJldHVybjsKCX0KCW1hdHJveGZiX3VucmVnaXN0ZXJfZGV2aWNl KG1pbmZvKTsKCXVucmVnaXN0ZXJfZnJhbWVidWZmZXIoJm1pbmZvLT5mYmNvbik7Ci4uLgp9CiAK QmVzdCByZWdhcmRzLAotLQpCYXJ0bG9taWVqIFpvbG5pZXJraWV3aWN6ClNhbXN1bmcgUiZEIElu c3RpdHV0ZSBQb2xhbmQKU2Ftc3VuZyBFbGVjdHJvbmljcwoKCkZyb206IE1pa3VsYXMgUGF0b2Nr YSA8bXBhdG9ja2FAcmVkaGF0LmNvbT4KU3ViamVjdDogW1BBVENIXSBmYjogZml4IGxvc3QgY29u c29sZSB3aGVuIHRoZSB1c2VyIHVucGx1Z3MgYSBVU0IgYWRhcHRlcgoKSSBoYXZlIGEgVVNCIGRp c3BsYXkgYWRhcHRlciB1c2luZyB0aGUgdWRsZmIgZHJpdmVyIGFuZCBJIHVzZSBpdCBvbiBhbiBB Uk0KYm9hcmQgdGhhdCBkb2Vzbid0IGhhdmUgYW55IGdyYXBoaWNzIGNhcmQuIFdoZW4gSSBwbHVn IHRoZSBhZGFwdGVyIGluLCB0aGUKY29uc29sZSBpcyBwcm9wZXJseSBkaXNwbGF5ZWQsIGhvd2V2 ZXIgd2hlbiBJIHVucGx1ZyBhbmQgcmUtcGx1ZyB0aGUKYWRhcHRlciwgdGhlIGNvbnNvbGUgaXMg bm90IGRpc3BsYXllZCBhbmQgSSBjYW4ndCBhY2Nlc3MgaXQgdW50aWwgSSByZWJvb3QKdGhlIGJv YXJkLgoKVGhlIHJlYXNvbiBpcyB0aGlzOgpXaGVuIHRoZSBhZGFwdGVyIGlzIHVucGx1Z2dlZCwg ZGxmYl91c2JfZGlzY29ubmVjdCBjYWxscwp1bmxpbmtfZnJhbWVidWZmZXIsIHRoZW4gaXQgd2Fp dHMgdW50aWwgdGhlIHJlZmVyZW5jZSBjb3VudCBkcm9wcyB0byB6ZXJvCmFuZCB0aGVuIGl0IGRl YWxsb2NhdGVzIHRoZSBmcmFtZWJ1ZmZlci4gSG93ZXZlciwgdGhlIGNvbnNvbGUgdGhhdCBpcwph dHRhY2hlZCB0byB0aGUgZnJhbWVidWZmZXIgZGV2aWNlIGtlZXBzIHRoZSByZWZlcmVuY2UgY291 bnQgbm9uLXplcm8sIHNvCnRoZSBmcmFtZWJ1ZmZlciBkZXZpY2UgaXMgbmV2ZXIgZGVzdHJveWVk LiBXaGVuIHRoZSBVU0IgYWRhcHRlciBpcyBwbHVnZ2VkCmFnYWluLCBpdCBjcmVhdGVzIGEgbmV3 IGRldmljZSAvZGV2L2ZiMSBhbmQgdGhlIGNvbnNvbGUgaXMgbm90IGF0dGFjaGVkIHRvCml0LgoK VGhpcyBwYXRjaCBmaXhlcyB0aGUgYnVnIGJ5IHVuYmluZGluZyB0aGUgY29uc29sZSBmcm9tIHVu bGlua19mcmFtZWJ1ZmZlci4KVGhlIGNvZGUgdG8gdW5iaW5kIHRoZSBjb25zb2xlIGlzIG1vdmVk IGZyb20gZG9fdW5yZWdpc3Rlcl9mcmFtZWJ1ZmZlciB0bwphIGZ1bmN0aW9uIHVuYmluZF9jb25z b2xlLiBXaGVuIHRoZSBjb25zb2xlIGlzIHVuYm91bmQsIHRoZSByZWZlcmVuY2UKY291bnQgZHJv cHMgdG8gemVybyBhbmQgdGhlIHVkbGZiIGRyaXZlciBmcmVlcyB0aGUgZnJhbWVidWZmZXIuIFdo ZW4gdGhlCmFkYXB0ZXIgaXMgcGx1Z2dlZCBiYWNrLCBhIG5ldyBmcmFtZWJ1ZmZlciBpcyBjcmVh dGVkIGFuZCB0aGUgY29uc29sZSBpcwphdHRhY2hlZCB0byBpdC4KClNpZ25lZC1vZmYtYnk6IE1p a3VsYXMgUGF0b2NrYSA8bXBhdG9ja2FAcmVkaGF0LmNvbT4KQ2M6IERhdmUgQWlybGllIDxhaXJs aWVkQHJlZGhhdC5jb20+CkNjOiBCZXJuaWUgVGhvbXBzb24gPGJlcm5pZUBwbHVnYWJsZS5jb20+ CkNjOiBMYWRpc2xhdiBNaWNobCA8bGFkaXNAbGludXgtbWlwcy5vcmc+CkNjOiBzdGFibGVAdmdl ci5rZXJuZWwub3JnCltiLnpvbG5pZXJraWU6IHByZXNlcnZlIG9sZCBiZWhhdmlvciBmb3IgZG9f dW5yZWdpc3Rlcl9mcmFtZWJ1ZmZlcigpXQpTaWduZWQtb2ZmLWJ5OiBCYXJ0bG9taWVqIFpvbG5p ZXJraWV3aWN6IDxiLnpvbG5pZXJraWVAc2Ftc3VuZy5jb20+Ci0tLQogZHJpdmVycy92aWRlby9m YmRldi9jb3JlL2ZibWVtLmMgfCAgIDM4ICsrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysr LS0tLS0tCiAxIGZpbGUgY2hhbmdlZCwgMzIgaW5zZXJ0aW9ucygrKSwgNiBkZWxldGlvbnMoLSkK CkluZGV4OiBiL2RyaXZlcnMvdmlkZW8vZmJkZXYvY29yZS9mYm1lbS5jCj09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0t IGEvZHJpdmVycy92aWRlby9mYmRldi9jb3JlL2ZibWVtLmMJMjAxOC0wNy0yNSAxMjo0OToyMS42 Njg3NjM0MjkgKzAyMDAKKysrIGIvZHJpdmVycy92aWRlby9mYmRldi9jb3JlL2ZibWVtLmMJMjAx OC0wNy0yNSAxMjo1MTo0Mi44MjQ3NjY5ODQgKzAyMDAKQEAgLTE3MDMsMTIgKzE3MDMsMTIgQEAg c3RhdGljIGludCBkb19yZWdpc3Rlcl9mcmFtZWJ1ZmZlcihzdHJ1YwogCXJldHVybiAwOwogfQog Ci1zdGF0aWMgaW50IGRvX3VucmVnaXN0ZXJfZnJhbWVidWZmZXIoc3RydWN0IGZiX2luZm8gKmZi X2luZm8pCitzdGF0aWMgaW50IHVuYmluZF9jb25zb2xlKHN0cnVjdCBmYl9pbmZvICpmYl9pbmZv KQogewogCXN0cnVjdCBmYl9ldmVudCBldmVudDsKLQlpbnQgaSwgcmV0ID0gMDsKKwlpbnQgcmV0 OworCWludCBpID0gZmJfaW5mby0+bm9kZTsKIAotCWkgPSBmYl9pbmZvLT5ub2RlOwogCWlmIChp IDwgMCB8fCBpID49IEZCX01BWCB8fCByZWdpc3RlcmVkX2ZiW2ldICE9IGZiX2luZm8pCiAJCXJl dHVybiAtRUlOVkFMOwogCkBAIC0xNzIzLDE3ICsxNzIzLDI5IEBAIHN0YXRpYyBpbnQgZG9fdW5y ZWdpc3Rlcl9mcmFtZWJ1ZmZlcihzdHIKIAl1bmxvY2tfZmJfaW5mbyhmYl9pbmZvKTsKIAljb25z b2xlX3VubG9jaygpOwogCisJcmV0dXJuIHJldDsKK30KKworc3RhdGljIGludCBfX3VubGlua19m cmFtZWJ1ZmZlcihzdHJ1Y3QgZmJfaW5mbyAqZmJfaW5mbyk7CisKK3N0YXRpYyBpbnQgZG9fdW5y ZWdpc3Rlcl9mcmFtZWJ1ZmZlcihzdHJ1Y3QgZmJfaW5mbyAqZmJfaW5mbykKK3sKKwlzdHJ1Y3Qg ZmJfZXZlbnQgZXZlbnQ7CisJaW50IHJldDsKKworCXJldCA9IHVuYmluZF9jb25zb2xlKGZiX2lu Zm8pOworCiAJaWYgKHJldCkKIAkJcmV0dXJuIC1FSU5WQUw7CiAKIAlwbV92dF9zd2l0Y2hfdW5y ZWdpc3RlcihmYl9pbmZvLT5kZXYpOwogCi0JdW5saW5rX2ZyYW1lYnVmZmVyKGZiX2luZm8pOwor CV9fdW5saW5rX2ZyYW1lYnVmZmVyKGZiX2luZm8pOwogCWlmIChmYl9pbmZvLT5waXhtYXAuYWRk ciAmJgogCSAgICAoZmJfaW5mby0+cGl4bWFwLmZsYWdzICYgRkJfUElYTUFQX0RFRkFVTFQpKQog CQlrZnJlZShmYl9pbmZvLT5waXhtYXAuYWRkcik7CiAJZmJfZGVzdHJveV9tb2RlbGlzdCgmZmJf aW5mby0+bW9kZWxpc3QpOwotCXJlZ2lzdGVyZWRfZmJbaV0gPSBOVUxMOworCXJlZ2lzdGVyZWRf ZmJbZmJfaW5mby0+bm9kZV0gPSBOVUxMOwogCW51bV9yZWdpc3RlcmVkX2ZiLS07CiAJZmJfY2xl YW51cF9kZXZpY2UoZmJfaW5mbyk7CiAJZXZlbnQuaW5mbyA9IGZiX2luZm87CkBAIC0xNzQ2LDcg KzE3NTgsNyBAQCBzdGF0aWMgaW50IGRvX3VucmVnaXN0ZXJfZnJhbWVidWZmZXIoc3RyCiAJcmV0 dXJuIDA7CiB9CiAKLWludCB1bmxpbmtfZnJhbWVidWZmZXIoc3RydWN0IGZiX2luZm8gKmZiX2lu Zm8pCitzdGF0aWMgaW50IF9fdW5saW5rX2ZyYW1lYnVmZmVyKHN0cnVjdCBmYl9pbmZvICpmYl9p bmZvKQogewogCWludCBpOwogCkBAIC0xNzU4LDYgKzE3NzAsMjAgQEAgaW50IHVubGlua19mcmFt ZWJ1ZmZlcihzdHJ1Y3QgZmJfaW5mbyAqZgogCQlkZXZpY2VfZGVzdHJveShmYl9jbGFzcywgTUtE RVYoRkJfTUFKT1IsIGkpKTsKIAkJZmJfaW5mby0+ZGV2ID0gTlVMTDsKIAl9CisKKwlyZXR1cm4g MDsKK30KKworaW50IHVubGlua19mcmFtZWJ1ZmZlcihzdHJ1Y3QgZmJfaW5mbyAqZmJfaW5mbykK K3sKKwlpbnQgcmV0OworCisJcmV0ID0gX191bmxpbmtfZnJhbWVidWZmZXIoZmJfaW5mbyk7CisJ aWYgKHJldCkKKwkJcmV0dXJuIHJldDsKKworCXVuYmluZF9jb25zb2xlKGZiX2luZm8pOworCiAJ cmV0dXJuIDA7CiB9CiBFWFBPUlRfU1lNQk9MKHVubGlua19mcmFtZWJ1ZmZlcik7CgpfX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fXwpkcmktZGV2ZWwgbWFpbGlu ZyBsaXN0CmRyaS1kZXZlbEBsaXN0cy5mcmVlZGVza3RvcC5vcmcKaHR0cHM6Ly9saXN0cy5mcmVl ZGVza3RvcC5vcmcvbWFpbG1hbi9saXN0aW5mby9kcmktZGV2ZWwK