From mboxrd@z Thu Jan 1 00:00:00 1970 From: Thomas Zimmermann Date: Mon, 14 Oct 2019 14:04:09 +0000 Subject: [PATCH v2 08/15] drm/fbconv: Add plane-state check and update Message-Id: <20191014140416.28517-9-tzimmermann@suse.de> List-Id: References: <20191014140416.28517-1-tzimmermann@suse.de> In-Reply-To: <20191014140416.28517-1-tzimmermann@suse.de> MIME-Version: 1.0 Content-Type: text/plain; charset="us-ascii" Content-Transfer-Encoding: 7bit To: airlied@linux.ie, daniel@ffwll.ch, maarten.lankhorst@linux.intel.com, mripard@kernel.org, sean@poorly.run, b.zolnierkie@samsung.com, ajax@redhat.com, ville.syrjala@linux.intel.com, malat@debian.org, michel@daenzer.net Cc: gregkh@linuxfoundation.org, linux-fbdev@vger.kernel.org, Thomas Zimmermann , dri-devel@lists.freedesktop.org, corbet@lwn.net For the update of the primary plane, we copy the content of a SHMEM buffer object to the hardware's on-screen buffer; doing a format conversion if necessary. This is able to support all combinations of framebuffers and hardware, and should work with any fbdev driver. Occasionally, fbdev drivers require an update of the hardware's gamma tables to not show distorted colors. We also do this during the plane update. There's no support for horizontal panning, as fbdev drivers vary widely in their capability to do this. Vertical panning is supported to the extend allowed by available video ram. However, this whole functionality is more interesting for porting drivers and not directly required by fbconv itself. Signed-off-by: Thomas Zimmermann --- drivers/gpu/drm/Kconfig | 1 + drivers/gpu/drm/drm_fbconv_helper.c | 500 +++++++++++++++++++++++++++- include/drm/drm_fbconv_helper.h | 9 + 3 files changed, 507 insertions(+), 3 deletions(-) diff --git a/drivers/gpu/drm/Kconfig b/drivers/gpu/drm/Kconfig index ed689201ec81..2ce7749c3157 100644 --- a/drivers/gpu/drm/Kconfig +++ b/drivers/gpu/drm/Kconfig @@ -160,6 +160,7 @@ config DRM_DP_CEC config DRM_FBCONV_HELPER tristate "Enable fbdev conversion helpers" depends on DRM + select DRM_GEM_SHMEM_HELPER help Provides helpers for running DRM on top of fbdev drivers. Choose this option if you're converting an fbdev driver to DRM. The diff --git a/drivers/gpu/drm/drm_fbconv_helper.c b/drivers/gpu/drm/drm_fbconv_helper.c index 4cda1f15e072..cf218016ac05 100644 --- a/drivers/gpu/drm/drm_fbconv_helper.c +++ b/drivers/gpu/drm/drm_fbconv_helper.c @@ -5,12 +5,17 @@ #include #include +#include #include #include +#include #include +#include #include #include +#include #include +#include /* * Format conversion helpers @@ -728,10 +733,192 @@ static const struct drm_connector_funcs connector_funcs = { .atomic_print_state = NULL }; +/* + * Colormap updates + */ + +/* provides a default colormap for palette modes */ +static int create_palette_cmap(struct fb_cmap *cmap, + const struct fb_var_screeninfo *fb_var) +{ + __u32 len; + const struct fb_cmap *default_cmap; + int ret; + + len = max3(fb_var->red.length, + fb_var->green.length, + fb_var->blue.length); + if (!len || (len > 31)) { + DRM_ERROR("fbconv: Gamma LUT has invalid bit count of %u\n", + (unsigned int)len); + return -EINVAL; + } + + default_cmap = fb_default_cmap(1ul << len); + if (!default_cmap) { + DRM_ERROR("fbconv: fb_default_cmap() failed\n"); + return -EINVAL; + } + + ret = fb_alloc_cmap(cmap, default_cmap->len, 0); + if (ret) { + DRM_ERROR("fbconv: fb_alloc_cmap() failed: %d\n", ret); + return ret; + } + ret = fb_copy_cmap(default_cmap, cmap); + if (ret) { + DRM_ERROR("fbconv: fb_copy_cmap() failed: %d\n", ret); + goto err_fb_dealloc_cmap; + } + + return 0; + +err_fb_dealloc_cmap: + fb_dealloc_cmap(cmap); + return ret; +} + +/* provides a linear color ramp for RGB modes */ +static int create_linear_cmap(struct fb_cmap *cmap, + const struct fb_var_screeninfo *fb_var) +{ + int ret; + size_t i; + unsigned int j; + u16 *lut; + u16 incr; + u16 *gamma_lut[3]; + __u32 len; + const __u32 gamma_len[3] = { + fb_var->red.length, + fb_var->green.length, + fb_var->blue.length + }; + + len = max3(gamma_len[0], gamma_len[1], gamma_len[2]); + if (!len || (len > 8)) { + DRM_ERROR("fbconv: gamma LUT has invalid bit count of %u\n", + (unsigned int)len); + return -EINVAL; + } + + ret = fb_alloc_cmap(cmap, 1ul << len, 0); + if (ret) { + DRM_ERROR("fbconv: fb_alloc_cmap() failed: %d\n", ret); + return ret; + } + + gamma_lut[0] = cmap->red; + gamma_lut[1] = cmap->green; + gamma_lut[2] = cmap->blue; + + for (i = 0; i < ARRAY_SIZE(gamma_lut); ++i) { + lut = gamma_lut[i]; + len = 1ul << gamma_len[i]; + incr = 0x10000u >> gamma_len[i]; + for (j = 0; j < len; ++j, ++lut) + *lut = incr * j; + + /* In order to have no intensity at index 0 and full + * intensity at the final index of the LUT, we fix-up the + * table's final entries. The fix-up makes intensity grow + * faster near the final entries of the gamma LUT. The human + * eye is more sensitive to changes to the lower intensities, + * so this is probably not directly perceivable. + */ + for (lut -= gamma_len[i], j = gamma_len[i]; j > 0; ++lut) { + --j; + /* subtract 1 to not overflow the LUT's final entry */ + *lut += (incr >> j) - 1; + } + } + + return 0; +} + +static int set_cmap(struct fb_info *fb_info) +{ + struct fb_cmap cmap; + int ret; + + memset(&cmap, 0, sizeof(cmap)); + + switch (fb_info->fix.visual) { + case FB_VISUAL_PSEUDOCOLOR: + ret = create_palette_cmap(&cmap, &fb_info->var); + break; + case FB_VISUAL_DIRECTCOLOR: + ret = create_linear_cmap(&cmap, &fb_info->var); + break; + default: + return 0; + } + if (ret) + return ret; + + ret = fb_set_cmap(&cmap, fb_info); + if (ret) { + DRM_ERROR("fbconv: fb_set_cmap() failed: %d\n", ret); + goto err_fb_dealloc_cmap; + } + fb_dealloc_cmap(&cmap); + + return 0; + +err_fb_dealloc_cmap: + fb_dealloc_cmap(&cmap); + return ret; +} + /* * Simple display pipe */ +static void drm_fbconv_update_fb_var_screeninfo_from_crtc_state( + struct fb_var_screeninfo *fb_var, struct drm_crtc_state *crtc_state) +{ + drm_fbconv_update_fb_var_screeninfo_from_mode( + fb_var, &crtc_state->adjusted_mode); +} + +static int drm_fbconv_update_fb_var_screeninfo_from_framebuffer( + struct fb_var_screeninfo *fb_var, struct drm_framebuffer *fb, + size_t vram_size) +{ + unsigned int width, pitch; + uint64_t cpp, lines; + int ret; + + /* Our virtual screen covers all the graphics memory (sans some + * trailing bytes). This allows for setting the scanout buffer's + * address with fb_pan_display(). + */ + + width = fb->pitches[0]; + cpp = fb->format[0].cpp[0]; + do_div(width, cpp); + + if (width > (__u32)-1) + return -EINVAL; /* would overflow fb_var->xres_virtual */ + + pitch = fb->pitches[0]; + lines = vram_size; + do_div(lines, pitch); + + if (lines > (__u32)-1) + return -EINVAL; /* would overflow fb_var->yres_virtual */ + + fb_var->xres_virtual = width; + fb_var->yres_virtual = lines; + + ret = drm_fbconv_update_fb_var_screeninfo_from_format( + fb_var, fb->format[0].format); + if (ret) + return ret; + + return 0; +} + /** * drm_fbconv_simple_display_pipe_mode_valid - default implementation for * struct drm_simple_display_pipe_funcs.mode_valid @@ -767,6 +954,52 @@ bool drm_fbconv_simple_display_pipe_mode_fixup( } EXPORT_SYMBOL(drm_fbconv_simple_display_pipe_mode_fixup); +/** + * drm_fbconv_blit_rect - copy an area of pixel data from a framebuffer + * to the hardware buffer + * @dst: the on-screen hardware buffer + * @vaddr: the source buffer in kernel address space + * @fb: the framebuffer of the source buffer + * @rect: the area to copy + * Returns: + * 0 on success, or + * a negative error code otherwise. + * + * This function copies the pixel data from a DRM framebuffer to a hardware + * buffer; doing necessary format conversion in the process. Not all + * combinations of source and destination formats are currently supported. + */ +int drm_fbconv_blit_rect(void *dst, void *vaddr, struct drm_framebuffer *fb, + struct drm_rect *rect) +{ + struct drm_device *dev = fb->dev; + + if (!vaddr) + return 0; /* no framebuffer set for plane; no error */ + + if (dev->mode_config.preferred_depth = (fb->format->cpp[0] * 8)) + drm_fb_memcpy_dstclip(dst, vaddr, fb, rect); + + else if (fb->format->cpp[0] = 4 && + dev->mode_config.preferred_depth = 16) + drm_fb_xrgb8888_to_rgb565_dstclip(dst, fb->pitches[0], + vaddr, fb, rect, false); + + else if (fb->format->cpp[0] = 4 && + dev->mode_config.preferred_depth = 24) + drm_fb_xrgb8888_to_rgb888_dstclip(dst, fb->pitches[0], + vaddr, fb, rect); + + else { + /* TODO: add the missing conversion */ + DRM_ERROR("fbconv: mismatching pixel formats\n"); + return -EINVAL; + } + + return 0; +} +EXPORT_SYMBOL(drm_fbconv_blit_rect); + /** * drm_fbconv_simple_display_pipe_enable - default implementation for * struct drm_simple_display_pipe_funcs.enable @@ -803,6 +1036,100 @@ drm_fbconv_simple_display_pipe_check(struct drm_simple_display_pipe *pipe, struct drm_plane_state *plane_state, struct drm_crtc_state *crtc_state) { + struct drm_fbconv_modeset *modeset; + struct fb_videomode fb_mode, fb_var_mode; + int ret; + struct fb_var_screeninfo fb_var; + + /* + * CRTC check + */ + + modeset = drm_fbconv_modeset_of_pipe(pipe); + + /* DRM porting notes: when fbcon takes over the console, it regularly + * changes the display mode. Where's apparently no way to detect this + * directly from fbcon itself. DRM's mode information might therefore + * be out of data, after it takes over the display at a later time. + * Here, we test the CRTC's current mode with the fbdev state. If they + * do not match, we request a mode change from DRM. If you port an + * fbdev driver to DRM, you can remove this code section, DRM will + * be in full control of the display device and doesn't have to react + * to changes from external sources. + */ + + if (!crtc_state->mode_changed && crtc_state->adjusted_mode.clock) { + drm_fbconv_init_fb_videomode_from_mode( + &fb_mode, &crtc_state->adjusted_mode); + fb_var_to_videomode(&fb_var_mode, &modeset->fb_info->var); + if (!fb_mode_is_equal(&fb_mode, &fb_var_mode)) + crtc_state->mode_changed = true; + } + + /* TODO: The vblank interrupt is currently not supported. We set + * the corresponding flag as a workaround. Some fbdev drivers + * support FBIO_WAITFORVSYNC, which we might use for querying + * vblanks. + * + * DRM porting notes: if you're porting an fbdev driver to DRM, + * remove this line and instead signal a vblank event from the + * interrupt handler. + */ + crtc_state->no_vblank = true; + + /* + * Plane check + */ + + if (!plane_state->crtc) + return 0; + + ret = drm_atomic_helper_check_plane_state(plane_state, crtc_state, + 1 << 16, 1 << 16, + false, true); + if (ret < 0) + return ret; + + if (!plane_state->visible || !plane_state->fb) + return 0; + + /* Virtual screen sizes are not supported. + */ + + if (drm_rect_width(&plane_state->dst) != plane_state->fb->width || + drm_rect_height(&plane_state->dst) != plane_state->fb->height) { + DRM_ERROR("fbconv: virtual screen sizes not supported\n"); + return -EINVAL; + } + if (plane_state->dst.x1 || plane_state->dst.y1) { + DRM_ERROR("fbconv: virtual screen offset not supported\n"); + return -EINVAL; + } + + /* Pixel formats have to be compatible with fbdev. This is + * usually some variation of XRGB. + */ + + if (!pipe->plane.state || + !pipe->plane.state->fb || + pipe->plane.state->fb->format[0].format !+ plane_state->fb->format[0].format) { + + if (modeset->fb_info->fbops->fb_check_var) { + memcpy(&fb_var, &modeset->fb_info->var, + sizeof(fb_var)); + drm_fbconv_update_fb_var_screeninfo_from_crtc_state( + &fb_var, crtc_state); + drm_fbconv_update_fb_var_screeninfo_from_framebuffer( + &fb_var, plane_state->fb, + modeset->fb_info->fix.smem_len); + ret = modeset->fb_info->fbops->fb_check_var( + &fb_var, modeset->fb_info); + if (ret < 0) + return ret; + } + } + return 0; } EXPORT_SYMBOL(drm_fbconv_simple_display_pipe_check); @@ -816,7 +1143,119 @@ EXPORT_SYMBOL(drm_fbconv_simple_display_pipe_check); void drm_fbconv_simple_display_pipe_update(struct drm_simple_display_pipe *pipe, struct drm_plane_state *old_plane_state) -{ } +{ + struct drm_fbconv_modeset *modeset; + uint32_t format; + struct fb_var_screeninfo fb_var; + int ret; + bool do_blit; + struct drm_rect rect; + struct drm_crtc *crtc = &pipe->crtc; + + /* + * Plane update + */ + + modeset = drm_fbconv_modeset_of_pipe(pipe); + + format = drm_fbconv_format_of_fb_info(modeset->fb_info); + + /* DRM porting notes: Some fbdev drivers report alpha channels for + * their framebuffer, even though they don't support transparent + * primary planes. For the format test below, we ignore the alpha + * channel and use the non-transparent equivalent of the pixel format. + * If you're porting an fbdev driver to DRM, remove this switch + * statement and report the correct format instead. + */ + switch (format) { + case DRM_FORMAT_ARGB8888: + format = DRM_FORMAT_XRGB8888; + break; + case DRM_FORMAT_ABGR8888: + format = DRM_FORMAT_XBGR8888; + break; + case DRM_FORMAT_RGBA8888: + format = DRM_FORMAT_RGBX8888; + break; + case DRM_FORMAT_BGRA8888: + format = DRM_FORMAT_BGRX8888; + break; + default: + break; + } + + if (!pipe->plane.state->fb) { + /* No framebuffer installed; blank display. */ + fb_blank(modeset->fb_info, FB_BLANK_NORMAL); + return; + } + + if ((format != pipe->plane.state->fb->format[0].format) || + (modeset->fb_info->var.xres_virtual !+ pipe->plane.state->fb->width)) { + + /* Pixel format changed, update fb_info accordingly + */ + + memcpy(&fb_var, &modeset->fb_info->var, sizeof(fb_var)); + ret = drm_fbconv_update_fb_var_screeninfo_from_framebuffer( + &fb_var, pipe->plane.state->fb, + modeset->fb_info->fix.smem_len); + if (ret) + return; + + fb_var.activate = FB_ACTIVATE_NOW; + + ret = fb_set_var(modeset->fb_info, &fb_var); + if (ret) { + DRM_ERROR("fbconv: fb_set_var() failed: %d\n", ret); + return; + } + } + + if (!old_plane_state->fb || /* first-time update */ + (format != pipe->plane.state->fb->format[0].format)) { + + /* DRM porting notes: Below we set the LUTs for palette and + * gamma correction. This is required by some fbdev drivers, + * such as nvidiafb and atyfb, which don't initialize the + * table to pass-through the framebuffer values unchanged. This + * is actually CRTC state, but the respective function + * crtc_helper_mode_set_nofb() is only called when a CRTC + * property changes, changes in color formats are not handled + * there. When you're porting a fbdev driver to DRM, remove + * the call. Gamma LUTs are CRTC properties and should be + * handled there. Either remove gamma correction or set up + * the respective CRTC properties for userspace. + */ + set_cmap(modeset->fb_info); + } + + memcpy(&fb_var, &modeset->fb_info->var, sizeof(fb_var)); + fb_var.xoffset = 0; + fb_var.yoffset = 0; + + ret = fb_pan_display(modeset->fb_info, &fb_var); + if (ret) { + DRM_ERROR("fbconv: fb_pan_display() failed: %d\n", ret); + return; + } + + do_blit = drm_atomic_helper_damage_merged(old_plane_state, + pipe->plane.state, + &rect); + if (do_blit) + drm_fbconv_blit_rect(modeset->blit.screen_base, + modeset->blit.vmap, pipe->plane.state->fb, + &rect); + + if (crtc->state->event) { + spin_lock_irq(&crtc->dev->event_lock); + drm_crtc_send_vblank_event(crtc, crtc->state->event); + crtc->state->event = NULL; + spin_unlock_irq(&crtc->dev->event_lock); + } +} EXPORT_SYMBOL(drm_fbconv_simple_display_pipe_update); /** @@ -837,7 +1276,48 @@ EXPORT_SYMBOL(drm_fbconv_simple_display_pipe_update); int drm_fbconv_simple_display_pipe_prepare_fb(struct drm_simple_display_pipe *pipe, struct drm_plane_state *plane_state) -{ } +{ + struct drm_fbconv_modeset *modeset = drm_fbconv_modeset_of_pipe(pipe); + struct fb_info *fb_info = modeset->fb_info; + struct drm_framebuffer *fb = plane_state->fb; + bool unmap_screen_base = false; + void *screen_base; + void *vmap; + int ret; + + if (!fb) + return 0; + + screen_base = fb_info->screen_base; + + if (!screen_base) { + screen_base = ioremap(fb_info->fix.smem_start, + fb_info->fix.smem_len); + if (!screen_base) { + DRM_ERROR("fbconv: ioremap() failed\n"); + return -ENOMEM; + } + unmap_screen_base = true; + } + + vmap = drm_gem_shmem_vmap(fb->obj[0]); + if (!vmap) { + DRM_ERROR("fbconv: drm_gem_shmem_vmap() failed\n"); + ret = -ENOMEM; + goto err_iounmap; + } + + modeset->blit.vmap = vmap; + modeset->blit.screen_base = screen_base; + modeset->blit.unmap_screen_base = unmap_screen_base; + + return 0; + +err_iounmap: + if (unmap_screen_base) + iounmap(screen_base); + return ret; +} EXPORT_SYMBOL(drm_fbconv_simple_display_pipe_prepare_fb); /** @@ -853,7 +1333,21 @@ EXPORT_SYMBOL(drm_fbconv_simple_display_pipe_prepare_fb); void drm_fbconv_simple_display_pipe_cleanup_fb(struct drm_simple_display_pipe *pipe, struct drm_plane_state *plane_state) -{ } +{ + struct drm_fbconv_modeset *modeset = drm_fbconv_modeset_of_pipe(pipe); + struct drm_framebuffer *fb = plane_state->fb; + + if (!fb) + return; + + drm_gem_shmem_vunmap(fb->obj[0], modeset->blit.vmap); + + if (modeset->blit.unmap_screen_base) + iounmap(modeset->blit.screen_base); + + memset(&modeset->blit, 0, sizeof(modeset->blit)); +} +EXPORT_SYMBOL(drm_fbconv_simple_display_pipe_cleanup_fb); static const struct drm_simple_display_pipe_funcs simple_display_pipe_funcs = { .mode_valid = drm_fbconv_simple_display_pipe_mode_valid, diff --git a/include/drm/drm_fbconv_helper.h b/include/drm/drm_fbconv_helper.h index 79716af687c1..3e62b5e80af6 100644 --- a/include/drm/drm_fbconv_helper.h +++ b/include/drm/drm_fbconv_helper.h @@ -92,6 +92,9 @@ void drm_fbconv_simple_display_pipe_cleanup_fb(struct drm_simple_display_pipe *pipe, struct drm_plane_state *plane_state); +int drm_fbconv_blit_rect(void *dst, void *vaddr, struct drm_framebuffer *fb, + struct drm_rect *rect); + /* * Modeset helpers */ @@ -107,6 +110,12 @@ struct drm_fbconv_modeset { struct drm_connector connector; struct drm_simple_display_pipe pipe; + struct { + void *vmap; + void *screen_base; + bool unmap_screen_base; + } blit; + struct drm_device *dev; struct fb_info *fb_info; }; -- 2.23.0 From mboxrd@z Thu Jan 1 00:00:00 1970 From: Thomas Zimmermann Subject: [PATCH v2 08/15] drm/fbconv: Add plane-state check and update Date: Mon, 14 Oct 2019 16:04:09 +0200 Message-ID: <20191014140416.28517-9-tzimmermann@suse.de> References: <20191014140416.28517-1-tzimmermann@suse.de> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Return-path: Received: from mx1.suse.de (mx2.suse.de [195.135.220.15]) by gabe.freedesktop.org (Postfix) with ESMTPS id 59C486E503 for ; Mon, 14 Oct 2019 14:04:24 +0000 (UTC) In-Reply-To: <20191014140416.28517-1-tzimmermann@suse.de> List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: dri-devel-bounces@lists.freedesktop.org Sender: "dri-devel" To: airlied@linux.ie, daniel@ffwll.ch, maarten.lankhorst@linux.intel.com, mripard@kernel.org, sean@poorly.run, b.zolnierkie@samsung.com, ajax@redhat.com, ville.syrjala@linux.intel.com, malat@debian.org, michel@daenzer.net Cc: gregkh@linuxfoundation.org, linux-fbdev@vger.kernel.org, Thomas Zimmermann , dri-devel@lists.freedesktop.org, corbet@lwn.net List-Id: dri-devel@lists.freedesktop.org Rm9yIHRoZSB1cGRhdGUgb2YgdGhlIHByaW1hcnkgcGxhbmUsIHdlIGNvcHkgdGhlIGNvbnRlbnQg b2YgYSBTSE1FTSBidWZmZXIKb2JqZWN0IHRvIHRoZSBoYXJkd2FyZSdzIG9uLXNjcmVlbiBidWZm ZXI7IGRvaW5nIGEgZm9ybWF0IGNvbnZlcnNpb24gaWYKbmVjZXNzYXJ5LiBUaGlzIGlzIGFibGUg dG8gc3VwcG9ydCBhbGwgY29tYmluYXRpb25zIG9mIGZyYW1lYnVmZmVycyBhbmQKaGFyZHdhcmUs IGFuZCBzaG91bGQgd29yayB3aXRoIGFueSBmYmRldiBkcml2ZXIuCgpPY2Nhc2lvbmFsbHksIGZi ZGV2IGRyaXZlcnMgcmVxdWlyZSBhbiB1cGRhdGUgb2YgdGhlIGhhcmR3YXJlJ3MgZ2FtbWEKdGFi bGVzIHRvIG5vdCBzaG93IGRpc3RvcnRlZCBjb2xvcnMuIFdlIGFsc28gZG8gdGhpcyBkdXJpbmcg dGhlIHBsYW5lCnVwZGF0ZS4KClRoZXJlJ3Mgbm8gc3VwcG9ydCBmb3IgaG9yaXpvbnRhbCBwYW5u aW5nLCBhcyBmYmRldiBkcml2ZXJzIHZhcnkgd2lkZWx5CmluIHRoZWlyIGNhcGFiaWxpdHkgdG8g ZG8gdGhpcy4gVmVydGljYWwgcGFubmluZyBpcyBzdXBwb3J0ZWQgdG8gdGhlCmV4dGVuZCBhbGxv d2VkIGJ5IGF2YWlsYWJsZSB2aWRlbyByYW0uIEhvd2V2ZXIsIHRoaXMgd2hvbGUgZnVuY3Rpb25h bGl0eQppcyBtb3JlIGludGVyZXN0aW5nIGZvciBwb3J0aW5nIGRyaXZlcnMgYW5kIG5vdCBkaXJl Y3RseSByZXF1aXJlZCBieQpmYmNvbnYgaXRzZWxmLgoKU2lnbmVkLW9mZi1ieTogVGhvbWFzIFpp bW1lcm1hbm4gPHR6aW1tZXJtYW5uQHN1c2UuZGU+Ci0tLQogZHJpdmVycy9ncHUvZHJtL0tjb25m aWcgICAgICAgICAgICAgfCAgIDEgKwogZHJpdmVycy9ncHUvZHJtL2RybV9mYmNvbnZfaGVscGVy LmMgfCA1MDAgKysrKysrKysrKysrKysrKysrKysrKysrKysrLQogaW5jbHVkZS9kcm0vZHJtX2Zi Y29udl9oZWxwZXIuaCAgICAgfCAgIDkgKwogMyBmaWxlcyBjaGFuZ2VkLCA1MDcgaW5zZXJ0aW9u cygrKSwgMyBkZWxldGlvbnMoLSkKCmRpZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9kcm0vS2NvbmZp ZyBiL2RyaXZlcnMvZ3B1L2RybS9LY29uZmlnCmluZGV4IGVkNjg5MjAxZWM4MS4uMmNlNzc0OWMz MTU3IDEwMDY0NAotLS0gYS9kcml2ZXJzL2dwdS9kcm0vS2NvbmZpZworKysgYi9kcml2ZXJzL2dw dS9kcm0vS2NvbmZpZwpAQCAtMTYwLDYgKzE2MCw3IEBAIGNvbmZpZyBEUk1fRFBfQ0VDCiBjb25m aWcgRFJNX0ZCQ09OVl9IRUxQRVIKIAl0cmlzdGF0ZSAiRW5hYmxlIGZiZGV2IGNvbnZlcnNpb24g aGVscGVycyIKIAlkZXBlbmRzIG9uIERSTQorCXNlbGVjdCBEUk1fR0VNX1NITUVNX0hFTFBFUgog CWhlbHAKIAkgIFByb3ZpZGVzIGhlbHBlcnMgZm9yIHJ1bm5pbmcgRFJNIG9uIHRvcCBvZiBmYmRl diBkcml2ZXJzLiBDaG9vc2UKIAkgIHRoaXMgb3B0aW9uIGlmIHlvdSdyZSBjb252ZXJ0aW5nIGFu IGZiZGV2IGRyaXZlciB0byBEUk0uIFRoZQpkaWZmIC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJtL2Ry bV9mYmNvbnZfaGVscGVyLmMgYi9kcml2ZXJzL2dwdS9kcm0vZHJtX2ZiY29udl9oZWxwZXIuYwpp bmRleCA0Y2RhMWYxNWUwNzIuLmNmMjE4MDE2YWMwNSAxMDA2NDQKLS0tIGEvZHJpdmVycy9ncHUv ZHJtL2RybV9mYmNvbnZfaGVscGVyLmMKKysrIGIvZHJpdmVycy9ncHUvZHJtL2RybV9mYmNvbnZf aGVscGVyLmMKQEAgLTUsMTIgKzUsMTcgQEAKICNpbmNsdWRlIDxsaW51eC9mYi5oPgogCiAjaW5j bHVkZSA8ZHJtL2RybV9hdG9taWNfaGVscGVyLmg+CisjaW5jbHVkZSA8ZHJtL2RybV9kYW1hZ2Vf aGVscGVyLmg+CiAjaW5jbHVkZSA8ZHJtL2RybV9mYmNvbnZfaGVscGVyLmg+CiAjaW5jbHVkZSA8 ZHJtL2RybV9mYl9oZWxwZXIuaD4KKyNpbmNsdWRlIDxkcm0vZHJtX2Zvcm1hdF9oZWxwZXIuaD4K ICNpbmNsdWRlIDxkcm0vZHJtX2dlbV9mcmFtZWJ1ZmZlcl9oZWxwZXIuaD4KKyNpbmNsdWRlIDxk cm0vZHJtX2dlbV9zaG1lbV9oZWxwZXIuaD4KICNpbmNsdWRlIDxkcm0vZHJtX21vZGVzLmg+CiAj aW5jbHVkZSA8ZHJtL2RybV9tb2Rlc2V0X2hlbHBlcl92dGFibGVzLmg+CisjaW5jbHVkZSA8ZHJt L2RybV9wcmludC5oPgogI2luY2x1ZGUgPGRybS9kcm1fcHJvYmVfaGVscGVyLmg+CisjaW5jbHVk ZSA8ZHJtL2RybV92YmxhbmsuaD4KIAogLyoKICAqIEZvcm1hdCBjb252ZXJzaW9uIGhlbHBlcnMK QEAgLTcyOCwxMCArNzMzLDE5MiBAQCBzdGF0aWMgY29uc3Qgc3RydWN0IGRybV9jb25uZWN0b3Jf ZnVuY3MgY29ubmVjdG9yX2Z1bmNzID0gewogCS5hdG9taWNfcHJpbnRfc3RhdGUgPSBOVUxMCiB9 OwogCisvKgorICogQ29sb3JtYXAgdXBkYXRlcworICovCisKKy8qIHByb3ZpZGVzIGEgZGVmYXVs dCBjb2xvcm1hcCBmb3IgcGFsZXR0ZSBtb2RlcyAqLworc3RhdGljIGludCBjcmVhdGVfcGFsZXR0 ZV9jbWFwKHN0cnVjdCBmYl9jbWFwICpjbWFwLAorCQkJICAgICAgIGNvbnN0IHN0cnVjdCBmYl92 YXJfc2NyZWVuaW5mbyAqZmJfdmFyKQoreworCV9fdTMyIGxlbjsKKwljb25zdCBzdHJ1Y3QgZmJf Y21hcCAqZGVmYXVsdF9jbWFwOworCWludCByZXQ7CisKKwlsZW4gPSBtYXgzKGZiX3Zhci0+cmVk Lmxlbmd0aCwKKwkJICAgZmJfdmFyLT5ncmVlbi5sZW5ndGgsCisJCSAgIGZiX3Zhci0+Ymx1ZS5s ZW5ndGgpOworCWlmICghbGVuIHx8IChsZW4gPiAzMSkpIHsKKwkJRFJNX0VSUk9SKCJmYmNvbnY6 IEdhbW1hIExVVCBoYXMgaW52YWxpZCBiaXQgY291bnQgb2YgJXVcbiIsCisJCQkgICh1bnNpZ25l ZCBpbnQpbGVuKTsKKwkJcmV0dXJuIC1FSU5WQUw7CisJfQorCisJZGVmYXVsdF9jbWFwID0gZmJf ZGVmYXVsdF9jbWFwKDF1bCA8PCBsZW4pOworCWlmICghZGVmYXVsdF9jbWFwKSB7CisJCURSTV9F UlJPUigiZmJjb252OiBmYl9kZWZhdWx0X2NtYXAoKSBmYWlsZWRcbiIpOworCQlyZXR1cm4gLUVJ TlZBTDsKKwl9CisKKwlyZXQgPSBmYl9hbGxvY19jbWFwKGNtYXAsIGRlZmF1bHRfY21hcC0+bGVu LCAwKTsKKwlpZiAocmV0KSB7CisJCURSTV9FUlJPUigiZmJjb252OiBmYl9hbGxvY19jbWFwKCkg ZmFpbGVkOiAlZFxuIiwgcmV0KTsKKwkJcmV0dXJuIHJldDsKKwl9CisJcmV0ID0gZmJfY29weV9j bWFwKGRlZmF1bHRfY21hcCwgY21hcCk7CisJaWYgKHJldCkgeworCQlEUk1fRVJST1IoImZiY29u djogZmJfY29weV9jbWFwKCkgZmFpbGVkOiAlZFxuIiwgcmV0KTsKKwkJZ290byBlcnJfZmJfZGVh bGxvY19jbWFwOworCX0KKworCXJldHVybiAwOworCitlcnJfZmJfZGVhbGxvY19jbWFwOgorCWZi X2RlYWxsb2NfY21hcChjbWFwKTsKKwlyZXR1cm4gcmV0OworfQorCisvKiBwcm92aWRlcyBhIGxp bmVhciBjb2xvciByYW1wIGZvciBSR0IgbW9kZXMgKi8KK3N0YXRpYyBpbnQgY3JlYXRlX2xpbmVh cl9jbWFwKHN0cnVjdCBmYl9jbWFwICpjbWFwLAorCQkJICAgICAgY29uc3Qgc3RydWN0IGZiX3Zh cl9zY3JlZW5pbmZvICpmYl92YXIpCit7CisJaW50IHJldDsKKwlzaXplX3QgaTsKKwl1bnNpZ25l ZCBpbnQgajsKKwl1MTYgKmx1dDsKKwl1MTYgaW5jcjsKKwl1MTYgKmdhbW1hX2x1dFszXTsKKwlf X3UzMiBsZW47CisJY29uc3QgX191MzIgZ2FtbWFfbGVuWzNdID0geworCQlmYl92YXItPnJlZC5s ZW5ndGgsCisJCWZiX3Zhci0+Z3JlZW4ubGVuZ3RoLAorCQlmYl92YXItPmJsdWUubGVuZ3RoCisJ fTsKKworCWxlbiA9IG1heDMoZ2FtbWFfbGVuWzBdLCBnYW1tYV9sZW5bMV0sIGdhbW1hX2xlblsy XSk7CisJaWYgKCFsZW4gfHwgKGxlbiA+IDgpKSB7CisJCURSTV9FUlJPUigiZmJjb252OiBnYW1t YSBMVVQgaGFzIGludmFsaWQgYml0IGNvdW50IG9mICV1XG4iLAorCQkJICAodW5zaWduZWQgaW50 KWxlbik7CisJCXJldHVybiAtRUlOVkFMOworCX0KKworCXJldCA9IGZiX2FsbG9jX2NtYXAoY21h cCwgMXVsIDw8IGxlbiwgMCk7CisJaWYgKHJldCkgeworCQlEUk1fRVJST1IoImZiY29udjogZmJf YWxsb2NfY21hcCgpIGZhaWxlZDogJWRcbiIsIHJldCk7CisJCXJldHVybiByZXQ7CisJfQorCisJ Z2FtbWFfbHV0WzBdID0gY21hcC0+cmVkOworCWdhbW1hX2x1dFsxXSA9IGNtYXAtPmdyZWVuOwor CWdhbW1hX2x1dFsyXSA9IGNtYXAtPmJsdWU7CisKKwlmb3IgKGkgPSAwOyBpIDwgQVJSQVlfU0la RShnYW1tYV9sdXQpOyArK2kpIHsKKwkJbHV0ID0gZ2FtbWFfbHV0W2ldOworCQlsZW4gPSAxdWwg PDwgZ2FtbWFfbGVuW2ldOworCQlpbmNyID0gMHgxMDAwMHUgPj4gZ2FtbWFfbGVuW2ldOworCQlm b3IgKGogPSAwOyBqIDwgbGVuOyArK2osICsrbHV0KQorCQkJKmx1dCA9IGluY3IgKiBqOworCisJ CS8qIEluIG9yZGVyIHRvIGhhdmUgbm8gaW50ZW5zaXR5IGF0IGluZGV4IDAgYW5kIGZ1bGwKKwkJ ICogaW50ZW5zaXR5IGF0IHRoZSBmaW5hbCBpbmRleCBvZiB0aGUgTFVULCB3ZSBmaXgtdXAgdGhl CisJCSAqIHRhYmxlJ3MgZmluYWwgZW50cmllcy4gVGhlIGZpeC11cCBtYWtlcyBpbnRlbnNpdHkg Z3JvdworCQkgKiBmYXN0ZXIgbmVhciB0aGUgZmluYWwgZW50cmllcyBvZiB0aGUgZ2FtbWEgTFVU LiBUaGUgaHVtYW4KKwkJICogZXllIGlzIG1vcmUgc2Vuc2l0aXZlIHRvIGNoYW5nZXMgdG8gdGhl IGxvd2VyIGludGVuc2l0aWVzLAorCQkgKiBzbyB0aGlzIGlzIHByb2JhYmx5IG5vdCBkaXJlY3Rs eSBwZXJjZWl2YWJsZS4KKwkJICovCisJCWZvciAobHV0IC09IGdhbW1hX2xlbltpXSwgaiA9IGdh bW1hX2xlbltpXTsgaiA+IDA7ICsrbHV0KSB7CisJCQktLWo7CisJCQkvKiBzdWJ0cmFjdCAxIHRv IG5vdCBvdmVyZmxvdyB0aGUgTFVUJ3MgZmluYWwgZW50cnkgKi8KKwkJCSpsdXQgKz0gKGluY3Ig Pj4gaikgLSAxOworCQl9CisJfQorCisJcmV0dXJuIDA7Cit9CisKK3N0YXRpYyBpbnQgc2V0X2Nt YXAoc3RydWN0IGZiX2luZm8gKmZiX2luZm8pCit7CisJc3RydWN0IGZiX2NtYXAgY21hcDsKKwlp bnQgcmV0OworCisJbWVtc2V0KCZjbWFwLCAwLCBzaXplb2YoY21hcCkpOworCisJc3dpdGNoIChm Yl9pbmZvLT5maXgudmlzdWFsKSB7CisJY2FzZSBGQl9WSVNVQUxfUFNFVURPQ09MT1I6CisJCXJl dCA9IGNyZWF0ZV9wYWxldHRlX2NtYXAoJmNtYXAsICZmYl9pbmZvLT52YXIpOworCQlicmVhazsK KwljYXNlIEZCX1ZJU1VBTF9ESVJFQ1RDT0xPUjoKKwkJcmV0ID0gY3JlYXRlX2xpbmVhcl9jbWFw KCZjbWFwLCAmZmJfaW5mby0+dmFyKTsKKwkJYnJlYWs7CisJZGVmYXVsdDoKKwkJcmV0dXJuIDA7 CisJfQorCWlmIChyZXQpCisJCXJldHVybiByZXQ7CisKKwlyZXQgPSBmYl9zZXRfY21hcCgmY21h cCwgZmJfaW5mbyk7CisJaWYgKHJldCkgeworCQlEUk1fRVJST1IoImZiY29udjogZmJfc2V0X2Nt YXAoKSBmYWlsZWQ6ICVkXG4iLCByZXQpOworCQlnb3RvIGVycl9mYl9kZWFsbG9jX2NtYXA7CisJ fQorCWZiX2RlYWxsb2NfY21hcCgmY21hcCk7CisKKwlyZXR1cm4gMDsKKworZXJyX2ZiX2RlYWxs b2NfY21hcDoKKwlmYl9kZWFsbG9jX2NtYXAoJmNtYXApOworCXJldHVybiByZXQ7Cit9CisKIC8q CiAgKiBTaW1wbGUgZGlzcGxheSBwaXBlCiAgKi8KIAorc3RhdGljIHZvaWQgZHJtX2ZiY29udl91 cGRhdGVfZmJfdmFyX3NjcmVlbmluZm9fZnJvbV9jcnRjX3N0YXRlKAorCXN0cnVjdCBmYl92YXJf c2NyZWVuaW5mbyAqZmJfdmFyLCBzdHJ1Y3QgZHJtX2NydGNfc3RhdGUgKmNydGNfc3RhdGUpCit7 CisJZHJtX2ZiY29udl91cGRhdGVfZmJfdmFyX3NjcmVlbmluZm9fZnJvbV9tb2RlKAorCQlmYl92 YXIsICZjcnRjX3N0YXRlLT5hZGp1c3RlZF9tb2RlKTsKK30KKworc3RhdGljIGludCBkcm1fZmJj b252X3VwZGF0ZV9mYl92YXJfc2NyZWVuaW5mb19mcm9tX2ZyYW1lYnVmZmVyKAorCXN0cnVjdCBm Yl92YXJfc2NyZWVuaW5mbyAqZmJfdmFyLCBzdHJ1Y3QgZHJtX2ZyYW1lYnVmZmVyICpmYiwKKwlz aXplX3QgdnJhbV9zaXplKQoreworCXVuc2lnbmVkIGludCB3aWR0aCwgcGl0Y2g7CisJdWludDY0 X3QgY3BwLCBsaW5lczsKKwlpbnQgcmV0OworCisJLyogT3VyIHZpcnR1YWwgc2NyZWVuIGNvdmVy cyBhbGwgdGhlIGdyYXBoaWNzIG1lbW9yeSAoc2FucyBzb21lCisJICogdHJhaWxpbmcgYnl0ZXMp LiBUaGlzIGFsbG93cyBmb3Igc2V0dGluZyB0aGUgc2Nhbm91dCBidWZmZXIncworCSAqIGFkZHJl c3Mgd2l0aCBmYl9wYW5fZGlzcGxheSgpLgorCSAqLworCisJd2lkdGggPSBmYi0+cGl0Y2hlc1sw XTsKKwljcHAgPSBmYi0+Zm9ybWF0WzBdLmNwcFswXTsKKwlkb19kaXYod2lkdGgsIGNwcCk7CisK KwlpZiAod2lkdGggPiAoX191MzIpLTEpCisJCXJldHVybiAtRUlOVkFMOyAvKiB3b3VsZCBvdmVy ZmxvdyBmYl92YXItPnhyZXNfdmlydHVhbCAqLworCisJcGl0Y2ggPSBmYi0+cGl0Y2hlc1swXTsK KwlsaW5lcyA9IHZyYW1fc2l6ZTsKKwlkb19kaXYobGluZXMsIHBpdGNoKTsKKworCWlmIChsaW5l cyA+IChfX3UzMiktMSkKKwkJcmV0dXJuIC1FSU5WQUw7IC8qIHdvdWxkIG92ZXJmbG93IGZiX3Zh ci0+eXJlc192aXJ0dWFsICovCisKKwlmYl92YXItPnhyZXNfdmlydHVhbCA9IHdpZHRoOworCWZi X3Zhci0+eXJlc192aXJ0dWFsID0gbGluZXM7CisKKwlyZXQgPSBkcm1fZmJjb252X3VwZGF0ZV9m Yl92YXJfc2NyZWVuaW5mb19mcm9tX2Zvcm1hdCgKKwkJZmJfdmFyLCBmYi0+Zm9ybWF0WzBdLmZv cm1hdCk7CisJaWYgKHJldCkKKwkJcmV0dXJuIHJldDsKKworCXJldHVybiAwOworfQorCiAvKioK ICAqIGRybV9mYmNvbnZfc2ltcGxlX2Rpc3BsYXlfcGlwZV9tb2RlX3ZhbGlkIC0gZGVmYXVsdCBp bXBsZW1lbnRhdGlvbiBmb3IKICAqCXN0cnVjdCBkcm1fc2ltcGxlX2Rpc3BsYXlfcGlwZV9mdW5j cy5tb2RlX3ZhbGlkCkBAIC03NjcsNiArOTU0LDUyIEBAIGJvb2wgZHJtX2ZiY29udl9zaW1wbGVf ZGlzcGxheV9waXBlX21vZGVfZml4dXAoCiB9CiBFWFBPUlRfU1lNQk9MKGRybV9mYmNvbnZfc2lt cGxlX2Rpc3BsYXlfcGlwZV9tb2RlX2ZpeHVwKTsKIAorLyoqCisgKiBkcm1fZmJjb252X2JsaXRf cmVjdCAtIGNvcHkgYW4gYXJlYSBvZiBwaXhlbCBkYXRhIGZyb20gYSBmcmFtZWJ1ZmZlcgorICoJ dG8gdGhlIGhhcmR3YXJlIGJ1ZmZlcgorICogQGRzdDoJdGhlIG9uLXNjcmVlbiBoYXJkd2FyZSBi dWZmZXIKKyAqIEB2YWRkcjoJdGhlIHNvdXJjZSBidWZmZXIgaW4ga2VybmVsIGFkZHJlc3Mgc3Bh Y2UKKyAqIEBmYjoJCXRoZSBmcmFtZWJ1ZmZlciBvZiB0aGUgc291cmNlIGJ1ZmZlcgorICogQHJl Y3Q6CXRoZSBhcmVhIHRvIGNvcHkKKyAqIFJldHVybnM6CisgKgkwIG9uIHN1Y2Nlc3MsIG9yCisg KglhIG5lZ2F0aXZlIGVycm9yIGNvZGUgb3RoZXJ3aXNlLgorICoKKyAqIFRoaXMgZnVuY3Rpb24g Y29waWVzIHRoZSBwaXhlbCBkYXRhIGZyb20gYSBEUk0gZnJhbWVidWZmZXIgdG8gYSBoYXJkd2Fy ZQorICogYnVmZmVyOyBkb2luZyBuZWNlc3NhcnkgZm9ybWF0IGNvbnZlcnNpb24gaW4gdGhlIHBy b2Nlc3MuIE5vdCBhbGwKKyAqIGNvbWJpbmF0aW9ucyBvZiBzb3VyY2UgYW5kIGRlc3RpbmF0aW9u IGZvcm1hdHMgYXJlIGN1cnJlbnRseSBzdXBwb3J0ZWQuCisgKi8KK2ludCBkcm1fZmJjb252X2Js aXRfcmVjdCh2b2lkICpkc3QsIHZvaWQgKnZhZGRyLCBzdHJ1Y3QgZHJtX2ZyYW1lYnVmZmVyICpm YiwKKwkJCSBzdHJ1Y3QgZHJtX3JlY3QgKnJlY3QpCit7CisJc3RydWN0IGRybV9kZXZpY2UgKmRl diA9IGZiLT5kZXY7CisKKwlpZiAoIXZhZGRyKQorCQlyZXR1cm4gMDsgLyogbm8gZnJhbWVidWZm ZXIgc2V0IGZvciBwbGFuZTsgbm8gZXJyb3IgKi8KKworCWlmIChkZXYtPm1vZGVfY29uZmlnLnBy ZWZlcnJlZF9kZXB0aCA9PSAoZmItPmZvcm1hdC0+Y3BwWzBdICogOCkpCisJCWRybV9mYl9tZW1j cHlfZHN0Y2xpcChkc3QsIHZhZGRyLCBmYiwgcmVjdCk7CisKKwllbHNlIGlmIChmYi0+Zm9ybWF0 LT5jcHBbMF0gPT0gNCAmJgorCQkgZGV2LT5tb2RlX2NvbmZpZy5wcmVmZXJyZWRfZGVwdGggPT0g MTYpCisJCWRybV9mYl94cmdiODg4OF90b19yZ2I1NjVfZHN0Y2xpcChkc3QsIGZiLT5waXRjaGVz WzBdLAorCQkJCQkJICB2YWRkciwgZmIsIHJlY3QsIGZhbHNlKTsKKworCWVsc2UgaWYgKGZiLT5m b3JtYXQtPmNwcFswXSA9PSA0ICYmCisJCSBkZXYtPm1vZGVfY29uZmlnLnByZWZlcnJlZF9kZXB0 aCA9PSAyNCkKKwkJZHJtX2ZiX3hyZ2I4ODg4X3RvX3JnYjg4OF9kc3RjbGlwKGRzdCwgZmItPnBp dGNoZXNbMF0sCisJCQkJCQkgIHZhZGRyLCBmYiwgcmVjdCk7CisKKwllbHNlIHsKKwkJLyogVE9E TzogYWRkIHRoZSBtaXNzaW5nIGNvbnZlcnNpb24gKi8KKwkJRFJNX0VSUk9SKCJmYmNvbnY6IG1p c21hdGNoaW5nIHBpeGVsIGZvcm1hdHNcbiIpOworCQlyZXR1cm4gLUVJTlZBTDsKKwl9CisKKwly ZXR1cm4gMDsKK30KK0VYUE9SVF9TWU1CT0woZHJtX2ZiY29udl9ibGl0X3JlY3QpOworCiAvKioK ICAqIGRybV9mYmNvbnZfc2ltcGxlX2Rpc3BsYXlfcGlwZV9lbmFibGUgLSBkZWZhdWx0IGltcGxl bWVudGF0aW9uIGZvcgogICoJc3RydWN0IGRybV9zaW1wbGVfZGlzcGxheV9waXBlX2Z1bmNzLmVu YWJsZQpAQCAtODAzLDYgKzEwMzYsMTAwIEBAIGRybV9mYmNvbnZfc2ltcGxlX2Rpc3BsYXlfcGlw ZV9jaGVjayhzdHJ1Y3QgZHJtX3NpbXBsZV9kaXNwbGF5X3BpcGUgKnBpcGUsCiAJCQkJICAgICBz dHJ1Y3QgZHJtX3BsYW5lX3N0YXRlICpwbGFuZV9zdGF0ZSwKIAkJCQkgICAgIHN0cnVjdCBkcm1f Y3J0Y19zdGF0ZSAqY3J0Y19zdGF0ZSkKIHsKKwlzdHJ1Y3QgZHJtX2ZiY29udl9tb2Rlc2V0ICpt b2Rlc2V0OworCXN0cnVjdCBmYl92aWRlb21vZGUgZmJfbW9kZSwgZmJfdmFyX21vZGU7CisJaW50 IHJldDsKKwlzdHJ1Y3QgZmJfdmFyX3NjcmVlbmluZm8gZmJfdmFyOworCisJLyoKKwkgKiBDUlRD IGNoZWNrCisJICovCisKKwltb2Rlc2V0ID0gZHJtX2ZiY29udl9tb2Rlc2V0X29mX3BpcGUocGlw ZSk7CisKKwkvKiBEUk0gcG9ydGluZyBub3Rlczogd2hlbiBmYmNvbiB0YWtlcyBvdmVyIHRoZSBj b25zb2xlLCBpdCByZWd1bGFybHkKKwkgKiBjaGFuZ2VzIHRoZSBkaXNwbGF5IG1vZGUuIFdoZXJl J3MgYXBwYXJlbnRseSBubyB3YXkgdG8gZGV0ZWN0IHRoaXMKKwkgKiBkaXJlY3RseSBmcm9tIGZi Y29uIGl0c2VsZi4gRFJNJ3MgbW9kZSBpbmZvcm1hdGlvbiBtaWdodCB0aGVyZWZvcmUKKwkgKiBi ZSBvdXQgb2YgZGF0YSwgYWZ0ZXIgaXQgdGFrZXMgb3ZlciB0aGUgZGlzcGxheSBhdCBhIGxhdGVy IHRpbWUuCisJICogSGVyZSwgd2UgdGVzdCB0aGUgQ1JUQydzIGN1cnJlbnQgbW9kZSB3aXRoIHRo ZSBmYmRldiBzdGF0ZS4gSWYgdGhleQorCSAqIGRvIG5vdCBtYXRjaCwgd2UgcmVxdWVzdCBhIG1v ZGUgY2hhbmdlIGZyb20gRFJNLiBJZiB5b3UgcG9ydCBhbgorCSAqIGZiZGV2IGRyaXZlciB0byBE Uk0sIHlvdSBjYW4gcmVtb3ZlIHRoaXMgY29kZSBzZWN0aW9uLCBEUk0gd2lsbAorCSAqIGJlIGlu IGZ1bGwgY29udHJvbCBvZiB0aGUgZGlzcGxheSBkZXZpY2UgYW5kIGRvZXNuJ3QgaGF2ZSB0byBy ZWFjdAorCSAqIHRvIGNoYW5nZXMgZnJvbSBleHRlcm5hbCBzb3VyY2VzLgorCSAqLworCisJaWYg KCFjcnRjX3N0YXRlLT5tb2RlX2NoYW5nZWQgJiYgY3J0Y19zdGF0ZS0+YWRqdXN0ZWRfbW9kZS5j bG9jaykgeworCQlkcm1fZmJjb252X2luaXRfZmJfdmlkZW9tb2RlX2Zyb21fbW9kZSgKKwkJCSZm Yl9tb2RlLCAmY3J0Y19zdGF0ZS0+YWRqdXN0ZWRfbW9kZSk7CisJCWZiX3Zhcl90b192aWRlb21v ZGUoJmZiX3Zhcl9tb2RlLCAmbW9kZXNldC0+ZmJfaW5mby0+dmFyKTsKKwkJaWYgKCFmYl9tb2Rl X2lzX2VxdWFsKCZmYl9tb2RlLCAmZmJfdmFyX21vZGUpKQorCQkJY3J0Y19zdGF0ZS0+bW9kZV9j aGFuZ2VkID0gdHJ1ZTsKKwl9CisKKwkvKiBUT0RPOiBUaGUgdmJsYW5rIGludGVycnVwdCBpcyBj dXJyZW50bHkgbm90IHN1cHBvcnRlZC4gV2Ugc2V0CisJICogdGhlIGNvcnJlc3BvbmRpbmcgZmxh ZyBhcyBhIHdvcmthcm91bmQuIFNvbWUgZmJkZXYgZHJpdmVycworCSAqIHN1cHBvcnQgRkJJT19X QUlURk9SVlNZTkMsIHdoaWNoIHdlIG1pZ2h0IHVzZSBmb3IgcXVlcnlpbmcKKwkgKiB2Ymxhbmtz LgorCSAqCisJICogRFJNIHBvcnRpbmcgbm90ZXM6IGlmIHlvdSdyZSBwb3J0aW5nIGFuIGZiZGV2 IGRyaXZlciB0byBEUk0sCisJICogcmVtb3ZlIHRoaXMgbGluZSBhbmQgaW5zdGVhZCBzaWduYWwg YSB2YmxhbmsgZXZlbnQgZnJvbSB0aGUKKwkgKiBpbnRlcnJ1cHQgaGFuZGxlci4KKwkgKi8KKwlj cnRjX3N0YXRlLT5ub192YmxhbmsgPSB0cnVlOworCisJLyoKKwkgKiBQbGFuZSBjaGVjaworCSAq LworCisJaWYgKCFwbGFuZV9zdGF0ZS0+Y3J0YykKKwkJcmV0dXJuIDA7CisKKwlyZXQgPSBkcm1f YXRvbWljX2hlbHBlcl9jaGVja19wbGFuZV9zdGF0ZShwbGFuZV9zdGF0ZSwgY3J0Y19zdGF0ZSwK KwkJCQkJCSAgMSA8PCAxNiwgMSA8PCAxNiwKKwkJCQkJCSAgZmFsc2UsIHRydWUpOworCWlmIChy ZXQgPCAwKQorCQlyZXR1cm4gcmV0OworCisJaWYgKCFwbGFuZV9zdGF0ZS0+dmlzaWJsZSB8fCAh cGxhbmVfc3RhdGUtPmZiKQorCQlyZXR1cm4gMDsKKworCS8qIFZpcnR1YWwgc2NyZWVuIHNpemVz IGFyZSBub3Qgc3VwcG9ydGVkLgorCSAqLworCisJaWYgKGRybV9yZWN0X3dpZHRoKCZwbGFuZV9z dGF0ZS0+ZHN0KSAhPSBwbGFuZV9zdGF0ZS0+ZmItPndpZHRoIHx8CisJICAgIGRybV9yZWN0X2hl aWdodCgmcGxhbmVfc3RhdGUtPmRzdCkgIT0gcGxhbmVfc3RhdGUtPmZiLT5oZWlnaHQpIHsKKwkJ RFJNX0VSUk9SKCJmYmNvbnY6IHZpcnR1YWwgc2NyZWVuIHNpemVzIG5vdCBzdXBwb3J0ZWRcbiIp OworCQlyZXR1cm4gLUVJTlZBTDsKKwl9CisJaWYgKHBsYW5lX3N0YXRlLT5kc3QueDEgfHwgcGxh bmVfc3RhdGUtPmRzdC55MSkgeworCQlEUk1fRVJST1IoImZiY29udjogdmlydHVhbCBzY3JlZW4g b2Zmc2V0IG5vdCBzdXBwb3J0ZWRcbiIpOworCQlyZXR1cm4gLUVJTlZBTDsKKwl9CisKKwkvKiBQ aXhlbCBmb3JtYXRzIGhhdmUgdG8gYmUgY29tcGF0aWJsZSB3aXRoIGZiZGV2LiBUaGlzIGlzCisJ ICogdXN1YWxseSBzb21lIHZhcmlhdGlvbiBvZiBYUkdCLgorCSAqLworCisJaWYgKCFwaXBlLT5w bGFuZS5zdGF0ZSB8fAorCSAgICAhcGlwZS0+cGxhbmUuc3RhdGUtPmZiIHx8CisJICAgIHBpcGUt PnBsYW5lLnN0YXRlLT5mYi0+Zm9ybWF0WzBdLmZvcm1hdCAhPQorCQlwbGFuZV9zdGF0ZS0+ZmIt PmZvcm1hdFswXS5mb3JtYXQpIHsKKworCQlpZiAobW9kZXNldC0+ZmJfaW5mby0+ZmJvcHMtPmZi X2NoZWNrX3ZhcikgeworCQkJbWVtY3B5KCZmYl92YXIsICZtb2Rlc2V0LT5mYl9pbmZvLT52YXIs CisJCQkgICAgICAgc2l6ZW9mKGZiX3ZhcikpOworCQkJZHJtX2ZiY29udl91cGRhdGVfZmJfdmFy X3NjcmVlbmluZm9fZnJvbV9jcnRjX3N0YXRlKAorCQkJCSZmYl92YXIsIGNydGNfc3RhdGUpOwor CQkJZHJtX2ZiY29udl91cGRhdGVfZmJfdmFyX3NjcmVlbmluZm9fZnJvbV9mcmFtZWJ1ZmZlcigK KwkJCQkmZmJfdmFyLCBwbGFuZV9zdGF0ZS0+ZmIsCisJCQkJbW9kZXNldC0+ZmJfaW5mby0+Zml4 LnNtZW1fbGVuKTsKKwkJCXJldCA9IG1vZGVzZXQtPmZiX2luZm8tPmZib3BzLT5mYl9jaGVja192 YXIoCisJCQkJJmZiX3ZhciwgbW9kZXNldC0+ZmJfaW5mbyk7CisJCQlpZiAocmV0IDwgMCkKKwkJ CQlyZXR1cm4gcmV0OworCQl9CisJfQorCiAJcmV0dXJuIDA7CiB9CiBFWFBPUlRfU1lNQk9MKGRy bV9mYmNvbnZfc2ltcGxlX2Rpc3BsYXlfcGlwZV9jaGVjayk7CkBAIC04MTYsNyArMTE0MywxMTkg QEAgRVhQT1JUX1NZTUJPTChkcm1fZmJjb252X3NpbXBsZV9kaXNwbGF5X3BpcGVfY2hlY2spOwog dm9pZAogZHJtX2ZiY29udl9zaW1wbGVfZGlzcGxheV9waXBlX3VwZGF0ZShzdHJ1Y3QgZHJtX3Np bXBsZV9kaXNwbGF5X3BpcGUgKnBpcGUsCiAJCQkJICAgICAgc3RydWN0IGRybV9wbGFuZV9zdGF0 ZSAqb2xkX3BsYW5lX3N0YXRlKQoteyB9Cit7CisJc3RydWN0IGRybV9mYmNvbnZfbW9kZXNldCAq bW9kZXNldDsKKwl1aW50MzJfdCBmb3JtYXQ7CisJc3RydWN0IGZiX3Zhcl9zY3JlZW5pbmZvIGZi X3ZhcjsKKwlpbnQgcmV0OworCWJvb2wgZG9fYmxpdDsKKwlzdHJ1Y3QgZHJtX3JlY3QgcmVjdDsK KwlzdHJ1Y3QgZHJtX2NydGMgKmNydGMgPSAmcGlwZS0+Y3J0YzsKKworCS8qCisJICogUGxhbmUg dXBkYXRlCisJICovCisKKwltb2Rlc2V0ID0gZHJtX2ZiY29udl9tb2Rlc2V0X29mX3BpcGUocGlw ZSk7CisKKwlmb3JtYXQgPSBkcm1fZmJjb252X2Zvcm1hdF9vZl9mYl9pbmZvKG1vZGVzZXQtPmZi X2luZm8pOworCisJLyogRFJNIHBvcnRpbmcgbm90ZXM6IFNvbWUgZmJkZXYgZHJpdmVycyByZXBv cnQgYWxwaGEgY2hhbm5lbHMgZm9yCisJICogdGhlaXIgZnJhbWVidWZmZXIsIGV2ZW4gdGhvdWdo IHRoZXkgZG9uJ3Qgc3VwcG9ydCB0cmFuc3BhcmVudAorCSAqIHByaW1hcnkgcGxhbmVzLiBGb3Ig dGhlIGZvcm1hdCB0ZXN0IGJlbG93LCB3ZSBpZ25vcmUgdGhlIGFscGhhCisJICogY2hhbm5lbCBh bmQgdXNlIHRoZSBub24tdHJhbnNwYXJlbnQgZXF1aXZhbGVudCBvZiB0aGUgcGl4ZWwgZm9ybWF0 LgorCSAqIElmIHlvdSdyZSBwb3J0aW5nIGFuIGZiZGV2IGRyaXZlciB0byBEUk0sIHJlbW92ZSB0 aGlzIHN3aXRjaAorCSAqIHN0YXRlbWVudCBhbmQgcmVwb3J0IHRoZSBjb3JyZWN0IGZvcm1hdCBp bnN0ZWFkLgorCSAqLworCXN3aXRjaCAoZm9ybWF0KSB7CisJY2FzZSBEUk1fRk9STUFUX0FSR0I4 ODg4OgorCQlmb3JtYXQgPSBEUk1fRk9STUFUX1hSR0I4ODg4OworCQlicmVhazsKKwljYXNlIERS TV9GT1JNQVRfQUJHUjg4ODg6CisJCWZvcm1hdCA9IERSTV9GT1JNQVRfWEJHUjg4ODg7CisJCWJy ZWFrOworCWNhc2UgRFJNX0ZPUk1BVF9SR0JBODg4ODoKKwkJZm9ybWF0ID0gRFJNX0ZPUk1BVF9S R0JYODg4ODsKKwkJYnJlYWs7CisJY2FzZSBEUk1fRk9STUFUX0JHUkE4ODg4OgorCQlmb3JtYXQg PSBEUk1fRk9STUFUX0JHUlg4ODg4OworCQlicmVhazsKKwlkZWZhdWx0OgorCQlicmVhazsKKwl9 CisKKwlpZiAoIXBpcGUtPnBsYW5lLnN0YXRlLT5mYikgeworCQkvKiBObyBmcmFtZWJ1ZmZlciBp bnN0YWxsZWQ7IGJsYW5rIGRpc3BsYXkuICovCisJCWZiX2JsYW5rKG1vZGVzZXQtPmZiX2luZm8s IEZCX0JMQU5LX05PUk1BTCk7CisJCXJldHVybjsKKwl9CisKKwlpZiAoKGZvcm1hdCAhPSBwaXBl LT5wbGFuZS5zdGF0ZS0+ZmItPmZvcm1hdFswXS5mb3JtYXQpIHx8CisJICAgIChtb2Rlc2V0LT5m Yl9pbmZvLT52YXIueHJlc192aXJ0dWFsICE9CisJICAgIHBpcGUtPnBsYW5lLnN0YXRlLT5mYi0+ d2lkdGgpKSB7CisKKwkJLyogUGl4ZWwgZm9ybWF0IGNoYW5nZWQsIHVwZGF0ZSBmYl9pbmZvIGFj Y29yZGluZ2x5CisJCSAqLworCisJCW1lbWNweSgmZmJfdmFyLCAmbW9kZXNldC0+ZmJfaW5mby0+ dmFyLCBzaXplb2YoZmJfdmFyKSk7CisJCXJldCA9IGRybV9mYmNvbnZfdXBkYXRlX2ZiX3Zhcl9z Y3JlZW5pbmZvX2Zyb21fZnJhbWVidWZmZXIoCisJCQkmZmJfdmFyLCBwaXBlLT5wbGFuZS5zdGF0 ZS0+ZmIsCisJCQltb2Rlc2V0LT5mYl9pbmZvLT5maXguc21lbV9sZW4pOworCQlpZiAocmV0KQor CQkJcmV0dXJuOworCisJCWZiX3Zhci5hY3RpdmF0ZSA9IEZCX0FDVElWQVRFX05PVzsKKworCQly ZXQgPSBmYl9zZXRfdmFyKG1vZGVzZXQtPmZiX2luZm8sICZmYl92YXIpOworCQlpZiAocmV0KSB7 CisJCQlEUk1fRVJST1IoImZiY29udjogZmJfc2V0X3ZhcigpIGZhaWxlZDogJWRcbiIsIHJldCk7 CisJCQlyZXR1cm47CisJCX0KKwl9CisKKwlpZiAoIW9sZF9wbGFuZV9zdGF0ZS0+ZmIgfHwgLyog Zmlyc3QtdGltZSB1cGRhdGUgKi8KKwkgICAgKGZvcm1hdCAhPSBwaXBlLT5wbGFuZS5zdGF0ZS0+ ZmItPmZvcm1hdFswXS5mb3JtYXQpKSB7CisKKwkJLyogRFJNIHBvcnRpbmcgbm90ZXM6IEJlbG93 IHdlIHNldCB0aGUgTFVUcyBmb3IgcGFsZXR0ZSBhbmQKKwkJICogZ2FtbWEgY29ycmVjdGlvbi4g VGhpcyBpcyByZXF1aXJlZCBieSBzb21lIGZiZGV2IGRyaXZlcnMsCisJCSAqIHN1Y2ggYXMgbnZp ZGlhZmIgYW5kIGF0eWZiLCB3aGljaCBkb24ndCBpbml0aWFsaXplIHRoZQorCQkgKiB0YWJsZSB0 byBwYXNzLXRocm91Z2ggdGhlIGZyYW1lYnVmZmVyIHZhbHVlcyB1bmNoYW5nZWQuIFRoaXMKKwkJ ICogaXMgYWN0dWFsbHkgQ1JUQyBzdGF0ZSwgYnV0IHRoZSByZXNwZWN0aXZlIGZ1bmN0aW9uCisJ CSAqIGNydGNfaGVscGVyX21vZGVfc2V0X25vZmIoKSBpcyBvbmx5IGNhbGxlZCB3aGVuIGEgQ1JU QworCQkgKiBwcm9wZXJ0eSBjaGFuZ2VzLCBjaGFuZ2VzIGluIGNvbG9yIGZvcm1hdHMgYXJlIG5v dCBoYW5kbGVkCisJCSAqIHRoZXJlLiBXaGVuIHlvdSdyZSBwb3J0aW5nIGEgZmJkZXYgZHJpdmVy IHRvIERSTSwgcmVtb3ZlCisJCSAqIHRoZSBjYWxsLiBHYW1tYSBMVVRzIGFyZSBDUlRDIHByb3Bl cnRpZXMgYW5kIHNob3VsZCBiZQorCQkgKiBoYW5kbGVkIHRoZXJlLiBFaXRoZXIgcmVtb3ZlIGdh bW1hIGNvcnJlY3Rpb24gb3Igc2V0IHVwCisJCSAqIHRoZSByZXNwZWN0aXZlIENSVEMgcHJvcGVy dGllcyBmb3IgdXNlcnNwYWNlLgorCQkgKi8KKwkJc2V0X2NtYXAobW9kZXNldC0+ZmJfaW5mbyk7 CisJfQorCisJbWVtY3B5KCZmYl92YXIsICZtb2Rlc2V0LT5mYl9pbmZvLT52YXIsIHNpemVvZihm Yl92YXIpKTsKKwlmYl92YXIueG9mZnNldCA9IDA7CisJZmJfdmFyLnlvZmZzZXQgPSAwOworCisJ cmV0ID0gZmJfcGFuX2Rpc3BsYXkobW9kZXNldC0+ZmJfaW5mbywgJmZiX3Zhcik7CisJaWYgKHJl dCkgeworCQlEUk1fRVJST1IoImZiY29udjogZmJfcGFuX2Rpc3BsYXkoKSBmYWlsZWQ6ICVkXG4i LCByZXQpOworCQlyZXR1cm47CisJfQorCisJZG9fYmxpdCA9IGRybV9hdG9taWNfaGVscGVyX2Rh bWFnZV9tZXJnZWQob2xkX3BsYW5lX3N0YXRlLAorCQkJCQkJICBwaXBlLT5wbGFuZS5zdGF0ZSwK KwkJCQkJCSAgJnJlY3QpOworCWlmIChkb19ibGl0KQorCQlkcm1fZmJjb252X2JsaXRfcmVjdCht b2Rlc2V0LT5ibGl0LnNjcmVlbl9iYXNlLAorCQkJCSAgICAgbW9kZXNldC0+YmxpdC52bWFwLCBw aXBlLT5wbGFuZS5zdGF0ZS0+ZmIsCisJCQkJICAgICAmcmVjdCk7CisKKwlpZiAoY3J0Yy0+c3Rh dGUtPmV2ZW50KSB7CisJCXNwaW5fbG9ja19pcnEoJmNydGMtPmRldi0+ZXZlbnRfbG9jayk7CisJ CWRybV9jcnRjX3NlbmRfdmJsYW5rX2V2ZW50KGNydGMsIGNydGMtPnN0YXRlLT5ldmVudCk7CisJ CWNydGMtPnN0YXRlLT5ldmVudCA9IE5VTEw7CisJCXNwaW5fdW5sb2NrX2lycSgmY3J0Yy0+ZGV2 LT5ldmVudF9sb2NrKTsKKwl9Cit9CiBFWFBPUlRfU1lNQk9MKGRybV9mYmNvbnZfc2ltcGxlX2Rp c3BsYXlfcGlwZV91cGRhdGUpOwogCiAvKioKQEAgLTgzNyw3ICsxMjc2LDQ4IEBAIEVYUE9SVF9T WU1CT0woZHJtX2ZiY29udl9zaW1wbGVfZGlzcGxheV9waXBlX3VwZGF0ZSk7CiBpbnQKIGRybV9m YmNvbnZfc2ltcGxlX2Rpc3BsYXlfcGlwZV9wcmVwYXJlX2ZiKHN0cnVjdCBkcm1fc2ltcGxlX2Rp c3BsYXlfcGlwZSAqcGlwZSwKIAkJCQkJICBzdHJ1Y3QgZHJtX3BsYW5lX3N0YXRlICpwbGFuZV9z dGF0ZSkKLXsgfQoreworCXN0cnVjdCBkcm1fZmJjb252X21vZGVzZXQgKm1vZGVzZXQgPSBkcm1f ZmJjb252X21vZGVzZXRfb2ZfcGlwZShwaXBlKTsKKwlzdHJ1Y3QgZmJfaW5mbyAqZmJfaW5mbyA9 IG1vZGVzZXQtPmZiX2luZm87CisJc3RydWN0IGRybV9mcmFtZWJ1ZmZlciAqZmIgPSBwbGFuZV9z dGF0ZS0+ZmI7CisJYm9vbCB1bm1hcF9zY3JlZW5fYmFzZSA9IGZhbHNlOworCXZvaWQgKnNjcmVl bl9iYXNlOworCXZvaWQgKnZtYXA7CisJaW50IHJldDsKKworCWlmICghZmIpCisJCXJldHVybiAw OworCisJc2NyZWVuX2Jhc2UgPSBmYl9pbmZvLT5zY3JlZW5fYmFzZTsKKworCWlmICghc2NyZWVu X2Jhc2UpIHsKKwkJc2NyZWVuX2Jhc2UgPSBpb3JlbWFwKGZiX2luZm8tPmZpeC5zbWVtX3N0YXJ0 LAorCQkJCSAgICAgIGZiX2luZm8tPmZpeC5zbWVtX2xlbik7CisJCWlmICghc2NyZWVuX2Jhc2Up IHsKKwkJCURSTV9FUlJPUigiZmJjb252OiBpb3JlbWFwKCkgZmFpbGVkXG4iKTsKKwkJCXJldHVy biAtRU5PTUVNOworCQl9CisJCXVubWFwX3NjcmVlbl9iYXNlID0gdHJ1ZTsKKwl9CisKKwl2bWFw ID0gZHJtX2dlbV9zaG1lbV92bWFwKGZiLT5vYmpbMF0pOworCWlmICghdm1hcCkgeworCQlEUk1f RVJST1IoImZiY29udjogZHJtX2dlbV9zaG1lbV92bWFwKCkgZmFpbGVkXG4iKTsKKwkJcmV0ID0g LUVOT01FTTsKKwkJZ290byBlcnJfaW91bm1hcDsKKwl9CisKKwltb2Rlc2V0LT5ibGl0LnZtYXAg PSB2bWFwOworCW1vZGVzZXQtPmJsaXQuc2NyZWVuX2Jhc2UgPSBzY3JlZW5fYmFzZTsKKwltb2Rl c2V0LT5ibGl0LnVubWFwX3NjcmVlbl9iYXNlID0gdW5tYXBfc2NyZWVuX2Jhc2U7CisKKwlyZXR1 cm4gMDsKKworZXJyX2lvdW5tYXA6CisJaWYgKHVubWFwX3NjcmVlbl9iYXNlKQorCQlpb3VubWFw KHNjcmVlbl9iYXNlKTsKKwlyZXR1cm4gcmV0OworfQogRVhQT1JUX1NZTUJPTChkcm1fZmJjb252 X3NpbXBsZV9kaXNwbGF5X3BpcGVfcHJlcGFyZV9mYik7CiAKIC8qKgpAQCAtODUzLDcgKzEzMzMs MjEgQEAgRVhQT1JUX1NZTUJPTChkcm1fZmJjb252X3NpbXBsZV9kaXNwbGF5X3BpcGVfcHJlcGFy ZV9mYik7CiB2b2lkCiBkcm1fZmJjb252X3NpbXBsZV9kaXNwbGF5X3BpcGVfY2xlYW51cF9mYihz dHJ1Y3QgZHJtX3NpbXBsZV9kaXNwbGF5X3BpcGUgKnBpcGUsCiAJCQkJCSAgc3RydWN0IGRybV9w bGFuZV9zdGF0ZSAqcGxhbmVfc3RhdGUpCi17IH0KK3sKKwlzdHJ1Y3QgZHJtX2ZiY29udl9tb2Rl c2V0ICptb2Rlc2V0ID0gZHJtX2ZiY29udl9tb2Rlc2V0X29mX3BpcGUocGlwZSk7CisJc3RydWN0 IGRybV9mcmFtZWJ1ZmZlciAqZmIgPSBwbGFuZV9zdGF0ZS0+ZmI7CisKKwlpZiAoIWZiKQorCQly ZXR1cm47CisKKwlkcm1fZ2VtX3NobWVtX3Z1bm1hcChmYi0+b2JqWzBdLCBtb2Rlc2V0LT5ibGl0 LnZtYXApOworCisJaWYgKG1vZGVzZXQtPmJsaXQudW5tYXBfc2NyZWVuX2Jhc2UpCisJCWlvdW5t YXAobW9kZXNldC0+YmxpdC5zY3JlZW5fYmFzZSk7CisKKwltZW1zZXQoJm1vZGVzZXQtPmJsaXQs IDAsIHNpemVvZihtb2Rlc2V0LT5ibGl0KSk7Cit9CitFWFBPUlRfU1lNQk9MKGRybV9mYmNvbnZf c2ltcGxlX2Rpc3BsYXlfcGlwZV9jbGVhbnVwX2ZiKTsKIAogc3RhdGljIGNvbnN0IHN0cnVjdCBk cm1fc2ltcGxlX2Rpc3BsYXlfcGlwZV9mdW5jcyBzaW1wbGVfZGlzcGxheV9waXBlX2Z1bmNzID0g ewogCS5tb2RlX3ZhbGlkID0gZHJtX2ZiY29udl9zaW1wbGVfZGlzcGxheV9waXBlX21vZGVfdmFs aWQsCmRpZmYgLS1naXQgYS9pbmNsdWRlL2RybS9kcm1fZmJjb252X2hlbHBlci5oIGIvaW5jbHVk ZS9kcm0vZHJtX2ZiY29udl9oZWxwZXIuaAppbmRleCA3OTcxNmFmNjg3YzEuLjNlNjJiNWU4MGFm NiAxMDA2NDQKLS0tIGEvaW5jbHVkZS9kcm0vZHJtX2ZiY29udl9oZWxwZXIuaAorKysgYi9pbmNs dWRlL2RybS9kcm1fZmJjb252X2hlbHBlci5oCkBAIC05Miw2ICs5Miw5IEBAIHZvaWQKIGRybV9m YmNvbnZfc2ltcGxlX2Rpc3BsYXlfcGlwZV9jbGVhbnVwX2ZiKHN0cnVjdCBkcm1fc2ltcGxlX2Rp c3BsYXlfcGlwZSAqcGlwZSwKIAkJCQkJICBzdHJ1Y3QgZHJtX3BsYW5lX3N0YXRlICpwbGFuZV9z dGF0ZSk7CiAKK2ludCBkcm1fZmJjb252X2JsaXRfcmVjdCh2b2lkICpkc3QsIHZvaWQgKnZhZGRy LCBzdHJ1Y3QgZHJtX2ZyYW1lYnVmZmVyICpmYiwKKwkJCSBzdHJ1Y3QgZHJtX3JlY3QgKnJlY3Qp OworCiAvKgogICogTW9kZXNldCBoZWxwZXJzCiAgKi8KQEAgLTEwNyw2ICsxMTAsMTIgQEAgc3Ry dWN0IGRybV9mYmNvbnZfbW9kZXNldCB7CiAJc3RydWN0IGRybV9jb25uZWN0b3IgY29ubmVjdG9y OwogCXN0cnVjdCBkcm1fc2ltcGxlX2Rpc3BsYXlfcGlwZSBwaXBlOwogCisJc3RydWN0IHsKKwkJ dm9pZCAqdm1hcDsKKwkJdm9pZCAqc2NyZWVuX2Jhc2U7CisJCWJvb2wgdW5tYXBfc2NyZWVuX2Jh c2U7CisJfSBibGl0OworCiAJc3RydWN0IGRybV9kZXZpY2UgKmRldjsKIAlzdHJ1Y3QgZmJfaW5m byAqZmJfaW5mbzsKIH07Ci0tIAoyLjIzLjAKCl9fX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fCmRyaS1kZXZlbCBtYWlsaW5nIGxpc3QKZHJpLWRldmVsQGxpc3Rz LmZyZWVkZXNrdG9wLm9yZwpodHRwczovL2xpc3RzLmZyZWVkZXNrdG9wLm9yZy9tYWlsbWFuL2xp c3RpbmZvL2RyaS1kZXZlbA==