From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org X-Spam-Level: X-Spam-Status: No, score=-9.1 required=3.0 tests=DKIM_SIGNED,DKIM_VALID, DKIM_VALID_AU,INCLUDES_PATCH,MAILING_LIST_MULTI,SIGNED_OFF_BY,SPF_PASS, URIBL_BLOCKED,USER_AGENT_GIT autolearn=unavailable autolearn_force=no version=3.4.0 Received: from mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id 7BB26C43381 for ; Wed, 27 Mar 2019 18:04:30 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [209.132.180.67]) by mail.kernel.org (Postfix) with ESMTP id 4173F217F5 for ; Wed, 27 Mar 2019 18:04:30 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=default; t=1553709870; bh=KpgmBbIc4h+H3ttXp4nQcrGjHvD3LHFfn6DErsCoCWg=; h=From:To:Cc:Subject:Date:In-Reply-To:References:List-ID:From; b=fwNJe7Ll1/BXeGbHqtyRg2gT78b66WkCQTwL3D8v9gRxLEbQNTbUmrnJmN5l1j6ue Opa5gxYDTzJId8mt8cNliSGqwZp6Sk3l48hDJqhvqRwp2H1SamhyjZmxfzvID1Fguj cgesziVdWAgIqQzow2pno1dRxxt7ERgnLAxw3scg= Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1733269AbfC0SE2 (ORCPT ); Wed, 27 Mar 2019 14:04:28 -0400 Received: from mail.kernel.org ([198.145.29.99]:45074 "EHLO mail.kernel.org" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1733210AbfC0SE0 (ORCPT ); Wed, 27 Mar 2019 14:04:26 -0400 Received: from sasha-vm.mshome.net (c-73-47-72-35.hsd1.nh.comcast.net [73.47.72.35]) (using TLSv1.2 with cipher ECDHE-RSA-AES128-GCM-SHA256 (128/128 bits)) (No client certificate requested) by mail.kernel.org (Postfix) with ESMTPSA id 2CE6121734; Wed, 27 Mar 2019 18:04:24 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=default; t=1553709865; bh=KpgmBbIc4h+H3ttXp4nQcrGjHvD3LHFfn6DErsCoCWg=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=b+JnvTurwGuGm8nlTcRbC5V4rCk5aFLuJHl6LZCcbGvXf8DrcDb5ItB2JWVbuAerj wEVbsn1D2plPV3U45e26fHOTKHsvyfn0xhzU+luOf3g642GMgoUc2Q1mP4L1k7CvGo HH7+LQc/QPC5XOxf4tM34a5TUha9t/yw+ThxlsL8= From: Sasha Levin To: linux-kernel@vger.kernel.org, stable@vger.kernel.org Cc: =?UTF-8?q?Mathias=20Fr=C3=B6hlich?= , Alex Deucher , Sasha Levin , amd-gfx@lists.freedesktop.org, dri-devel@lists.freedesktop.org Subject: [PATCH AUTOSEL 5.0 078/262] drm/amd/display: Fix reference counting for struct dc_sink. Date: Wed, 27 Mar 2019 13:58:53 -0400 Message-Id: <20190327180158.10245-78-sashal@kernel.org> X-Mailer: git-send-email 2.19.1 In-Reply-To: <20190327180158.10245-1-sashal@kernel.org> References: <20190327180158.10245-1-sashal@kernel.org> MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 X-Patchwork-Hint: Ignore Content-Transfer-Encoding: 8bit Sender: linux-kernel-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org From: Mathias Fröhlich [ Upstream commit dcd5fb82ffb484124203aa339733663ac0b059f3 ] Reference counting in amdgpu_dm_connector for amdgpu_dm_connector::dc_sink and amdgpu_dm_connector::dc_em_sink as well as in dc_link::local_sink seems to be out of shape. Thus make reference counting consistent for these members and just plain increment the reference count when the variable gets assigned and decrement when the pointer is set to zero or replaced. Also simplify reference counting in selected function sopes to be sure the reference is released in any case. In some cases add NULL pointer check before dereferencing. At a hand full of places a comment is placed to stat that the reference increment happened already somewhere else. This actually fixes the following kernel bug on my system when enabling display core in amdgpu. There are some more similar bug reports around, so it probably helps at more places. kernel BUG at mm/slub.c:294! invalid opcode: 0000 [#1] SMP PTI CPU: 9 PID: 1180 Comm: Xorg Not tainted 5.0.0-rc1+ #2 Hardware name: Supermicro X10DAi/X10DAI, BIOS 3.0a 02/05/2018 RIP: 0010:__slab_free+0x1e2/0x3d0 Code: 8b 54 24 30 48 89 4c 24 28 e8 da fb ff ff 4c 8b 54 24 28 85 c0 0f 85 67 fe ff ff 48 8d 65 d8 5b 41 5c 41 5d 41 5e 41 5f 5d c3 <0f> 0b 49 3b 5c 24 28 75 ab 48 8b 44 24 30 49 89 4c 24 28 49 89 44 RSP: 0018:ffffb0978589fa90 EFLAGS: 00010246 RAX: ffff92f12806c400 RBX: 0000000080200019 RCX: ffff92f12806c400 RDX: ffff92f12806c400 RSI: ffffdd6421a01a00 RDI: ffff92ed2f406e80 RBP: ffffb0978589fb40 R08: 0000000000000001 R09: ffffffffc0ee4748 R10: ffff92f12806c400 R11: 0000000000000001 R12: ffffdd6421a01a00 R13: ffff92f12806c400 R14: ffff92ed2f406e80 R15: ffffdd6421a01a20 FS: 00007f4170be0ac0(0000) GS:ffff92ed2fb40000(0000) knlGS:0000000000000000 CS: 0010 DS: 0000 ES: 0000 CR0: 0000000080050033 CR2: 0000562818aaa000 CR3: 000000045745a002 CR4: 00000000003606e0 DR0: 0000000000000000 DR1: 0000000000000000 DR2: 0000000000000000 DR3: 0000000000000000 DR6: 00000000fffe0ff0 DR7: 0000000000000400 Call Trace: ? drm_dbg+0x87/0x90 [drm] dc_stream_release+0x28/0x50 [amdgpu] amdgpu_dm_connector_mode_valid+0xb4/0x1f0 [amdgpu] drm_helper_probe_single_connector_modes+0x492/0x6b0 [drm_kms_helper] drm_mode_getconnector+0x457/0x490 [drm] ? drm_connector_property_set_ioctl+0x60/0x60 [drm] drm_ioctl_kernel+0xa9/0xf0 [drm] drm_ioctl+0x201/0x3a0 [drm] ? drm_connector_property_set_ioctl+0x60/0x60 [drm] amdgpu_drm_ioctl+0x49/0x80 [amdgpu] do_vfs_ioctl+0xa4/0x630 ? __sys_recvmsg+0x83/0xa0 ksys_ioctl+0x60/0x90 __x64_sys_ioctl+0x16/0x20 do_syscall_64+0x5b/0x160 entry_SYSCALL_64_after_hwframe+0x44/0xa9 RIP: 0033:0x7f417110809b Code: 0f 1e fa 48 8b 05 ed bd 0c 00 64 c7 00 26 00 00 00 48 c7 c0 ff ff ff ff c3 66 0f 1f 44 00 00 f3 0f 1e fa b8 10 00 00 00 0f 05 <48> 3d 01 f0 ff ff 73 01 c3 48 8b 0d bd bd 0c 00 f7 d8 64 89 01 48 RSP: 002b:00007ffdd8d1c268 EFLAGS: 00000246 ORIG_RAX: 0000000000000010 RAX: ffffffffffffffda RBX: 0000562818a8ebc0 RCX: 00007f417110809b RDX: 00007ffdd8d1c2a0 RSI: 00000000c05064a7 RDI: 0000000000000012 RBP: 00007ffdd8d1c2a0 R08: 0000562819012280 R09: 0000000000000007 R10: 0000000000000000 R11: 0000000000000246 R12: 00000000c05064a7 R13: 0000000000000012 R14: 0000000000000012 R15: 00007ffdd8d1c2a0 Modules linked in: nfsv4 dns_resolver nfs lockd grace fscache fuse vfat fat amdgpu intel_rapl sb_edac x86_pkg_temp_thermal intel_powerclamp coretemp kvm_intel kvm irqbypass crct10dif_pclmul chash gpu_sched crc32_pclmul snd_hda_codec_realtek ghash_clmulni_intel amd_iommu_v2 iTCO_wdt iTCO_vendor_support ttm snd_hda_codec_generic snd_hda_codec_hdmi ledtrig_audio snd_hda_intel drm_kms_helper snd_hda_codec intel_cstate snd_hda_core drm snd_hwdep snd_seq snd_seq_device intel_uncore snd_pcm intel_rapl_perf snd_timer snd soundcore ioatdma pcspkr intel_wmi_thunderbolt mxm_wmi i2c_i801 lpc_ich pcc_cpufreq auth_rpcgss sunrpc igb crc32c_intel i2c_algo_bit dca wmi hid_cherry analog gameport joydev This patch is based on agd5f/drm-next-5.1-wip. This patch does not require all of that, but agd5f/drm-next-5.1-wip contains at least one more dc_sink counting fix that I could spot. Signed-off-by: Mathias Fröhlich Reviewed-by: Leo Li Signed-off-by: Alex Deucher Signed-off-by: Sasha Levin --- .../gpu/drm/amd/display/amdgpu_dm/amdgpu_dm.c | 43 +++++++++++++++---- .../display/amdgpu_dm/amdgpu_dm_mst_types.c | 1 + drivers/gpu/drm/amd/display/dc/core/dc_link.c | 1 + 3 files changed, 37 insertions(+), 8 deletions(-) diff --git a/drivers/gpu/drm/amd/display/amdgpu_dm/amdgpu_dm.c b/drivers/gpu/drm/amd/display/amdgpu_dm/amdgpu_dm.c index 636d14a60952..6d77fd966dbd 100644 --- a/drivers/gpu/drm/amd/display/amdgpu_dm/amdgpu_dm.c +++ b/drivers/gpu/drm/amd/display/amdgpu_dm/amdgpu_dm.c @@ -886,6 +886,7 @@ static void emulated_link_detect(struct dc_link *link) return; } + /* dc_sink_create returns a new reference */ link->local_sink = sink; edid_status = dm_helpers_read_local_edid( @@ -952,6 +953,8 @@ static int dm_resume(void *handle) if (aconnector->fake_enable && aconnector->dc_link->local_sink) aconnector->fake_enable = false; + if (aconnector->dc_sink) + dc_sink_release(aconnector->dc_sink); aconnector->dc_sink = NULL; amdgpu_dm_update_connector_after_detect(aconnector); mutex_unlock(&aconnector->hpd_lock); @@ -1061,6 +1064,8 @@ amdgpu_dm_update_connector_after_detect(struct amdgpu_dm_connector *aconnector) sink = aconnector->dc_link->local_sink; + if (sink) + dc_sink_retain(sink); /* * Edid mgmt connector gets first update only in mode_valid hook and then @@ -1085,21 +1090,24 @@ amdgpu_dm_update_connector_after_detect(struct amdgpu_dm_connector *aconnector) * to it anymore after disconnect, so on next crtc to connector * reshuffle by UMD we will get into unwanted dc_sink release */ - if (aconnector->dc_sink != aconnector->dc_em_sink) - dc_sink_release(aconnector->dc_sink); + dc_sink_release(aconnector->dc_sink); } aconnector->dc_sink = sink; + dc_sink_retain(aconnector->dc_sink); amdgpu_dm_update_freesync_caps(connector, aconnector->edid); } else { amdgpu_dm_update_freesync_caps(connector, NULL); - if (!aconnector->dc_sink) + if (!aconnector->dc_sink) { aconnector->dc_sink = aconnector->dc_em_sink; - else if (aconnector->dc_sink != aconnector->dc_em_sink) dc_sink_retain(aconnector->dc_sink); + } } mutex_unlock(&dev->mode_config.mutex); + + if (sink) + dc_sink_release(sink); return; } @@ -1107,8 +1115,10 @@ amdgpu_dm_update_connector_after_detect(struct amdgpu_dm_connector *aconnector) * TODO: temporary guard to look for proper fix * if this sink is MST sink, we should not do anything */ - if (sink && sink->sink_signal == SIGNAL_TYPE_DISPLAY_PORT_MST) + if (sink && sink->sink_signal == SIGNAL_TYPE_DISPLAY_PORT_MST) { + dc_sink_release(sink); return; + } if (aconnector->dc_sink == sink) { /* @@ -1117,6 +1127,8 @@ amdgpu_dm_update_connector_after_detect(struct amdgpu_dm_connector *aconnector) */ DRM_DEBUG_DRIVER("DCHPD: connector_id=%d: dc_sink didn't change.\n", aconnector->connector_id); + if (sink) + dc_sink_release(sink); return; } @@ -1138,6 +1150,7 @@ amdgpu_dm_update_connector_after_detect(struct amdgpu_dm_connector *aconnector) amdgpu_dm_update_freesync_caps(connector, NULL); aconnector->dc_sink = sink; + dc_sink_retain(aconnector->dc_sink); if (sink->dc_edid.length == 0) { aconnector->edid = NULL; drm_dp_cec_unset_edid(&aconnector->dm_dp_aux.aux); @@ -1158,11 +1171,15 @@ amdgpu_dm_update_connector_after_detect(struct amdgpu_dm_connector *aconnector) amdgpu_dm_update_freesync_caps(connector, NULL); drm_connector_update_edid_property(connector, NULL); aconnector->num_modes = 0; + dc_sink_release(aconnector->dc_sink); aconnector->dc_sink = NULL; aconnector->edid = NULL; } mutex_unlock(&dev->mode_config.mutex); + + if (sink) + dc_sink_release(sink); } static void handle_hpd_irq(void *param) @@ -2908,6 +2925,7 @@ create_stream_for_sink(struct amdgpu_dm_connector *aconnector, } } else { sink = aconnector->dc_sink; + dc_sink_retain(sink); } stream = dc_create_stream_for_sink(sink); @@ -2974,8 +2992,7 @@ create_stream_for_sink(struct amdgpu_dm_connector *aconnector, stream->ignore_msa_timing_param = true; finish: - if (sink && sink->sink_signal == SIGNAL_TYPE_VIRTUAL && aconnector->base.force != DRM_FORCE_ON) - dc_sink_release(sink); + dc_sink_release(sink); return stream; } @@ -3233,6 +3250,14 @@ static void amdgpu_dm_connector_destroy(struct drm_connector *connector) dm->backlight_dev = NULL; } #endif + + if (aconnector->dc_em_sink) + dc_sink_release(aconnector->dc_em_sink); + aconnector->dc_em_sink = NULL; + if (aconnector->dc_sink) + dc_sink_release(aconnector->dc_sink); + aconnector->dc_sink = NULL; + drm_dp_cec_unregister_connector(&aconnector->dm_dp_aux.aux); drm_connector_unregister(connector); drm_connector_cleanup(connector); @@ -3330,10 +3355,12 @@ static void create_eml_sink(struct amdgpu_dm_connector *aconnector) (edid->extensions + 1) * EDID_LENGTH, &init_params); - if (aconnector->base.force == DRM_FORCE_ON) + if (aconnector->base.force == DRM_FORCE_ON) { aconnector->dc_sink = aconnector->dc_link->local_sink ? aconnector->dc_link->local_sink : aconnector->dc_em_sink; + dc_sink_retain(aconnector->dc_sink); + } } static void handle_edid_mgmt(struct amdgpu_dm_connector *aconnector) diff --git a/drivers/gpu/drm/amd/display/amdgpu_dm/amdgpu_dm_mst_types.c b/drivers/gpu/drm/amd/display/amdgpu_dm/amdgpu_dm_mst_types.c index 1b0d209d8367..3b95a637b508 100644 --- a/drivers/gpu/drm/amd/display/amdgpu_dm/amdgpu_dm_mst_types.c +++ b/drivers/gpu/drm/amd/display/amdgpu_dm/amdgpu_dm_mst_types.c @@ -239,6 +239,7 @@ static int dm_dp_mst_get_modes(struct drm_connector *connector) &init_params); dc_sink->priv = aconnector; + /* dc_link_add_remote_sink returns a new reference */ aconnector->dc_sink = dc_sink; if (aconnector->dc_sink) diff --git a/drivers/gpu/drm/amd/display/dc/core/dc_link.c b/drivers/gpu/drm/amd/display/dc/core/dc_link.c index b0265dbebd4c..583eb367850f 100644 --- a/drivers/gpu/drm/amd/display/dc/core/dc_link.c +++ b/drivers/gpu/drm/amd/display/dc/core/dc_link.c @@ -792,6 +792,7 @@ bool dc_link_detect(struct dc_link *link, enum dc_detect_reason reason) sink->dongle_max_pix_clk = sink_caps.max_hdmi_pixel_clock; sink->converter_disable_audio = converter_disable_audio; + /* dc_sink_create returns a new reference */ link->local_sink = sink; edid_status = dm_helpers_read_local_edid( -- 2.19.1 From mboxrd@z Thu Jan 1 00:00:00 1970 From: Sasha Levin Subject: [PATCH AUTOSEL 5.0 078/262] drm/amd/display: Fix reference counting for struct dc_sink. Date: Wed, 27 Mar 2019 13:58:53 -0400 Message-ID: <20190327180158.10245-78-sashal@kernel.org> References: <20190327180158.10245-1-sashal@kernel.org> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Return-path: In-Reply-To: <20190327180158.10245-1-sashal@kernel.org> List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: dri-devel-bounces@lists.freedesktop.org Sender: "dri-devel" To: linux-kernel@vger.kernel.org, stable@vger.kernel.org Cc: Alex Deucher , Sasha Levin , dri-devel@lists.freedesktop.org, amd-gfx@lists.freedesktop.org, =?UTF-8?q?Mathias=20Fr=C3=B6hlich?= List-Id: dri-devel@lists.freedesktop.org RnJvbTogTWF0aGlhcyBGcsO2aGxpY2ggPE1hdGhpYXMuRnJvZWhsaWNoQHdlYi5kZT4KClsgVXBz dHJlYW0gY29tbWl0IGRjZDVmYjgyZmZiNDg0MTI0MjAzYWEzMzk3MzM2NjNhYzBiMDU5ZjMgXQoK UmVmZXJlbmNlIGNvdW50aW5nIGluIGFtZGdwdV9kbV9jb25uZWN0b3IgZm9yIGFtZGdwdV9kbV9j b25uZWN0b3I6OmRjX3NpbmsKYW5kIGFtZGdwdV9kbV9jb25uZWN0b3I6OmRjX2VtX3NpbmsgYXMg d2VsbCBhcyBpbiBkY19saW5rOjpsb2NhbF9zaW5rIHNlZW1zCnRvIGJlIG91dCBvZiBzaGFwZS4g VGh1cyBtYWtlIHJlZmVyZW5jZSBjb3VudGluZyBjb25zaXN0ZW50IGZvciB0aGVzZQptZW1iZXJz IGFuZCBqdXN0IHBsYWluIGluY3JlbWVudCB0aGUgcmVmZXJlbmNlIGNvdW50IHdoZW4gdGhlIHZh cmlhYmxlCmdldHMgYXNzaWduZWQgYW5kIGRlY3JlbWVudCB3aGVuIHRoZSBwb2ludGVyIGlzIHNl dCB0byB6ZXJvIG9yIHJlcGxhY2VkLgpBbHNvIHNpbXBsaWZ5IHJlZmVyZW5jZSBjb3VudGluZyBp biBzZWxlY3RlZCBmdW5jdGlvbiBzb3BlcyB0byBiZSBzdXJlIHRoZQpyZWZlcmVuY2UgaXMgcmVs ZWFzZWQgaW4gYW55IGNhc2UuIEluIHNvbWUgY2FzZXMgYWRkIE5VTEwgcG9pbnRlciBjaGVjawpi ZWZvcmUgZGVyZWZlcmVuY2luZy4KQXQgYSBoYW5kIGZ1bGwgb2YgcGxhY2VzIGEgY29tbWVudCBp cyBwbGFjZWQgdG8gc3RhdCB0aGF0IHRoZSByZWZlcmVuY2UKaW5jcmVtZW50IGhhcHBlbmVkIGFs cmVhZHkgc29tZXdoZXJlIGVsc2UuCgpUaGlzIGFjdHVhbGx5IGZpeGVzIHRoZSBmb2xsb3dpbmcg a2VybmVsIGJ1ZyBvbiBteSBzeXN0ZW0gd2hlbiBlbmFibGluZwpkaXNwbGF5IGNvcmUgaW4gYW1k Z3B1LiBUaGVyZSBhcmUgc29tZSBtb3JlIHNpbWlsYXIgYnVnIHJlcG9ydHMgYXJvdW5kLApzbyBp dCBwcm9iYWJseSBoZWxwcyBhdCBtb3JlIHBsYWNlcy4KCiAgIGtlcm5lbCBCVUcgYXQgbW0vc2x1 Yi5jOjI5NCEKICAgaW52YWxpZCBvcGNvZGU6IDAwMDAgWyMxXSBTTVAgUFRJCiAgIENQVTogOSBQ SUQ6IDExODAgQ29tbTogWG9yZyBOb3QgdGFpbnRlZCA1LjAuMC1yYzErICMyCiAgIEhhcmR3YXJl IG5hbWU6IFN1cGVybWljcm8gWDEwREFpL1gxMERBSSwgQklPUyAzLjBhIDAyLzA1LzIwMTgKICAg UklQOiAwMDEwOl9fc2xhYl9mcmVlKzB4MWUyLzB4M2QwCiAgIENvZGU6IDhiIDU0IDI0IDMwIDQ4 IDg5IDRjIDI0IDI4IGU4IGRhIGZiIGZmIGZmIDRjIDhiIDU0IDI0IDI4IDg1IGMwIDBmIDg1IDY3 IGZlIGZmIGZmIDQ4IDhkIDY1IGQ4IDViIDQxIDVjIDQxIDVkIDQxIDVlIDQxIDVmIDVkIGMzIDww Zj4gMGIgNDkgM2IgNWMgMjQgMjggNzUgYWIgNDggOGIgNDQgMjQgMzAgNDkgODkgNGMgMjQgMjgg NDkgODkgNDQKICAgUlNQOiAwMDE4OmZmZmZiMDk3ODU4OWZhOTAgRUZMQUdTOiAwMDAxMDI0Ngog ICBSQVg6IGZmZmY5MmYxMjgwNmM0MDAgUkJYOiAwMDAwMDAwMDgwMjAwMDE5IFJDWDogZmZmZjky ZjEyODA2YzQwMAogICBSRFg6IGZmZmY5MmYxMjgwNmM0MDAgUlNJOiBmZmZmZGQ2NDIxYTAxYTAw IFJESTogZmZmZjkyZWQyZjQwNmU4MAogICBSQlA6IGZmZmZiMDk3ODU4OWZiNDAgUjA4OiAwMDAw MDAwMDAwMDAwMDAxIFIwOTogZmZmZmZmZmZjMGVlNDc0OAogICBSMTA6IGZmZmY5MmYxMjgwNmM0 MDAgUjExOiAwMDAwMDAwMDAwMDAwMDAxIFIxMjogZmZmZmRkNjQyMWEwMWEwMAogICBSMTM6IGZm ZmY5MmYxMjgwNmM0MDAgUjE0OiBmZmZmOTJlZDJmNDA2ZTgwIFIxNTogZmZmZmRkNjQyMWEwMWEy MAogICBGUzogIDAwMDA3ZjQxNzBiZTBhYzAoMDAwMCkgR1M6ZmZmZjkyZWQyZmI0MDAwMCgwMDAw KSBrbmxHUzowMDAwMDAwMDAwMDAwMDAwCiAgIENTOiAgMDAxMCBEUzogMDAwMCBFUzogMDAwMCBD UjA6IDAwMDAwMDAwODAwNTAwMzMKICAgQ1IyOiAwMDAwNTYyODE4YWFhMDAwIENSMzogMDAwMDAw MDQ1NzQ1YTAwMiBDUjQ6IDAwMDAwMDAwMDAzNjA2ZTAKICAgRFIwOiAwMDAwMDAwMDAwMDAwMDAw IERSMTogMDAwMDAwMDAwMDAwMDAwMCBEUjI6IDAwMDAwMDAwMDAwMDAwMDAKICAgRFIzOiAwMDAw MDAwMDAwMDAwMDAwIERSNjogMDAwMDAwMDBmZmZlMGZmMCBEUjc6IDAwMDAwMDAwMDAwMDA0MDAK ICAgQ2FsbCBUcmFjZToKICAgID8gZHJtX2RiZysweDg3LzB4OTAgW2RybV0KICAgIGRjX3N0cmVh bV9yZWxlYXNlKzB4MjgvMHg1MCBbYW1kZ3B1XQogICAgYW1kZ3B1X2RtX2Nvbm5lY3Rvcl9tb2Rl X3ZhbGlkKzB4YjQvMHgxZjAgW2FtZGdwdV0KICAgIGRybV9oZWxwZXJfcHJvYmVfc2luZ2xlX2Nv bm5lY3Rvcl9tb2RlcysweDQ5Mi8weDZiMCBbZHJtX2ttc19oZWxwZXJdCiAgICBkcm1fbW9kZV9n ZXRjb25uZWN0b3IrMHg0NTcvMHg0OTAgW2RybV0KICAgID8gZHJtX2Nvbm5lY3Rvcl9wcm9wZXJ0 eV9zZXRfaW9jdGwrMHg2MC8weDYwIFtkcm1dCiAgICBkcm1faW9jdGxfa2VybmVsKzB4YTkvMHhm MCBbZHJtXQogICAgZHJtX2lvY3RsKzB4MjAxLzB4M2EwIFtkcm1dCiAgICA/IGRybV9jb25uZWN0 b3JfcHJvcGVydHlfc2V0X2lvY3RsKzB4NjAvMHg2MCBbZHJtXQogICAgYW1kZ3B1X2RybV9pb2N0 bCsweDQ5LzB4ODAgW2FtZGdwdV0KICAgIGRvX3Zmc19pb2N0bCsweGE0LzB4NjMwCiAgICA/IF9f c3lzX3JlY3Ztc2crMHg4My8weGEwCiAgICBrc3lzX2lvY3RsKzB4NjAvMHg5MAogICAgX194NjRf c3lzX2lvY3RsKzB4MTYvMHgyMAogICAgZG9fc3lzY2FsbF82NCsweDViLzB4MTYwCiAgICBlbnRy eV9TWVNDQUxMXzY0X2FmdGVyX2h3ZnJhbWUrMHg0NC8weGE5CiAgIFJJUDogMDAzMzoweDdmNDE3 MTEwODA5YgogICBDb2RlOiAwZiAxZSBmYSA0OCA4YiAwNSBlZCBiZCAwYyAwMCA2NCBjNyAwMCAy NiAwMCAwMCAwMCA0OCBjNyBjMCBmZiBmZiBmZiBmZiBjMyA2NiAwZiAxZiA0NCAwMCAwMCBmMyAw ZiAxZSBmYSBiOCAxMCAwMCAwMCAwMCAwZiAwNSA8NDg+IDNkIDAxIGYwIGZmIGZmIDczIDAxIGMz IDQ4IDhiIDBkIGJkIGJkIDBjIDAwIGY3IGQ4IDY0IDg5IDAxIDQ4CiAgIFJTUDogMDAyYjowMDAw N2ZmZGQ4ZDFjMjY4IEVGTEFHUzogMDAwMDAyNDYgT1JJR19SQVg6IDAwMDAwMDAwMDAwMDAwMTAK ICAgUkFYOiBmZmZmZmZmZmZmZmZmZmRhIFJCWDogMDAwMDU2MjgxOGE4ZWJjMCBSQ1g6IDAwMDA3 ZjQxNzExMDgwOWIKICAgUkRYOiAwMDAwN2ZmZGQ4ZDFjMmEwIFJTSTogMDAwMDAwMDBjMDUwNjRh NyBSREk6IDAwMDAwMDAwMDAwMDAwMTIKICAgUkJQOiAwMDAwN2ZmZGQ4ZDFjMmEwIFIwODogMDAw MDU2MjgxOTAxMjI4MCBSMDk6IDAwMDAwMDAwMDAwMDAwMDcKICAgUjEwOiAwMDAwMDAwMDAwMDAw MDAwIFIxMTogMDAwMDAwMDAwMDAwMDI0NiBSMTI6IDAwMDAwMDAwYzA1MDY0YTcKICAgUjEzOiAw MDAwMDAwMDAwMDAwMDEyIFIxNDogMDAwMDAwMDAwMDAwMDAxMiBSMTU6IDAwMDA3ZmZkZDhkMWMy YTAKICAgTW9kdWxlcyBsaW5rZWQgaW46IG5mc3Y0IGRuc19yZXNvbHZlciBuZnMgbG9ja2QgZ3Jh Y2UgZnNjYWNoZSBmdXNlIHZmYXQgZmF0IGFtZGdwdSBpbnRlbF9yYXBsIHNiX2VkYWMgeDg2X3Br Z190ZW1wX3RoZXJtYWwgaW50ZWxfcG93ZXJjbGFtcCBjb3JldGVtcCBrdm1faW50ZWwga3ZtIGly cWJ5cGFzcyBjcmN0MTBkaWZfcGNsbXVsIGNoYXNoIGdwdV9zY2hlZCBjcmMzMl9wY2xtdWwgc25k X2hkYV9jb2RlY19yZWFsdGVrIGdoYXNoX2NsbXVsbmlfaW50ZWwgYW1kX2lvbW11X3YyIGlUQ09f d2R0IGlUQ09fdmVuZG9yX3N1cHBvcnQgdHRtIHNuZF9oZGFfY29kZWNfZ2VuZXJpYyBzbmRfaGRh X2NvZGVjX2hkbWkgbGVkdHJpZ19hdWRpbyBzbmRfaGRhX2ludGVsIGRybV9rbXNfaGVscGVyIHNu ZF9oZGFfY29kZWMgaW50ZWxfY3N0YXRlIHNuZF9oZGFfY29yZSBkcm0gc25kX2h3ZGVwIHNuZF9z ZXEgc25kX3NlcV9kZXZpY2UgaW50ZWxfdW5jb3JlIHNuZF9wY20gaW50ZWxfcmFwbF9wZXJmIHNu ZF90aW1lciBzbmQgc291bmRjb3JlIGlvYXRkbWEgcGNzcGtyIGludGVsX3dtaV90aHVuZGVyYm9s dCBteG1fd21pIGkyY19pODAxIGxwY19pY2ggcGNjX2NwdWZyZXEgYXV0aF9ycGNnc3Mgc3VucnBj IGlnYiBjcmMzMmNfaW50ZWwgaTJjX2FsZ29fYml0IGRjYSB3bWkgaGlkX2NoZXJyeSBhbmFsb2cg Z2FtZXBvcnQgam95ZGV2CgpUaGlzIHBhdGNoIGlzIGJhc2VkIG9uIGFnZDVmL2RybS1uZXh0LTUu MS13aXAuIFRoaXMgcGF0Y2ggZG9lcyBub3QgcmVxdWlyZQphbGwgb2YgdGhhdCwgYnV0IGFnZDVm L2RybS1uZXh0LTUuMS13aXAgY29udGFpbnMgYXQgbGVhc3Qgb25lIG1vcmUgZGNfc2luawpjb3Vu dGluZyBmaXggdGhhdCBJIGNvdWxkIHNwb3QuCgpTaWduZWQtb2ZmLWJ5OiBNYXRoaWFzIEZyw7Zo bGljaCA8TWF0aGlhcy5Gcm9laGxpY2hAd2ViLmRlPgpSZXZpZXdlZC1ieTogTGVvIExpIDxzdW5w ZW5nLmxpQGFtZC5jb20+ClNpZ25lZC1vZmYtYnk6IEFsZXggRGV1Y2hlciA8YWxleGFuZGVyLmRl dWNoZXJAYW1kLmNvbT4KU2lnbmVkLW9mZi1ieTogU2FzaGEgTGV2aW4gPHNhc2hhbEBrZXJuZWwu b3JnPgotLS0KIC4uLi9ncHUvZHJtL2FtZC9kaXNwbGF5L2FtZGdwdV9kbS9hbWRncHVfZG0uYyB8 IDQzICsrKysrKysrKysrKysrKy0tLS0KIC4uLi9kaXNwbGF5L2FtZGdwdV9kbS9hbWRncHVfZG1f bXN0X3R5cGVzLmMgICB8ICAxICsKIGRyaXZlcnMvZ3B1L2RybS9hbWQvZGlzcGxheS9kYy9jb3Jl L2RjX2xpbmsuYyB8ICAxICsKIDMgZmlsZXMgY2hhbmdlZCwgMzcgaW5zZXJ0aW9ucygrKSwgOCBk ZWxldGlvbnMoLSkKCmRpZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9kcm0vYW1kL2Rpc3BsYXkvYW1k Z3B1X2RtL2FtZGdwdV9kbS5jIGIvZHJpdmVycy9ncHUvZHJtL2FtZC9kaXNwbGF5L2FtZGdwdV9k bS9hbWRncHVfZG0uYwppbmRleCA2MzZkMTRhNjA5NTIuLjZkNzdmZDk2NmRiZCAxMDA2NDQKLS0t IGEvZHJpdmVycy9ncHUvZHJtL2FtZC9kaXNwbGF5L2FtZGdwdV9kbS9hbWRncHVfZG0uYworKysg Yi9kcml2ZXJzL2dwdS9kcm0vYW1kL2Rpc3BsYXkvYW1kZ3B1X2RtL2FtZGdwdV9kbS5jCkBAIC04 ODYsNiArODg2LDcgQEAgc3RhdGljIHZvaWQgZW11bGF0ZWRfbGlua19kZXRlY3Qoc3RydWN0IGRj X2xpbmsgKmxpbmspCiAJCXJldHVybjsKIAl9CiAKKwkvKiBkY19zaW5rX2NyZWF0ZSByZXR1cm5z IGEgbmV3IHJlZmVyZW5jZSAqLwogCWxpbmstPmxvY2FsX3NpbmsgPSBzaW5rOwogCiAJZWRpZF9z dGF0dXMgPSBkbV9oZWxwZXJzX3JlYWRfbG9jYWxfZWRpZCgKQEAgLTk1Miw2ICs5NTMsOCBAQCBz dGF0aWMgaW50IGRtX3Jlc3VtZSh2b2lkICpoYW5kbGUpCiAJCWlmIChhY29ubmVjdG9yLT5mYWtl X2VuYWJsZSAmJiBhY29ubmVjdG9yLT5kY19saW5rLT5sb2NhbF9zaW5rKQogCQkJYWNvbm5lY3Rv ci0+ZmFrZV9lbmFibGUgPSBmYWxzZTsKIAorCQlpZiAoYWNvbm5lY3Rvci0+ZGNfc2luaykKKwkJ CWRjX3NpbmtfcmVsZWFzZShhY29ubmVjdG9yLT5kY19zaW5rKTsKIAkJYWNvbm5lY3Rvci0+ZGNf c2luayA9IE5VTEw7CiAJCWFtZGdwdV9kbV91cGRhdGVfY29ubmVjdG9yX2FmdGVyX2RldGVjdChh Y29ubmVjdG9yKTsKIAkJbXV0ZXhfdW5sb2NrKCZhY29ubmVjdG9yLT5ocGRfbG9jayk7CkBAIC0x MDYxLDYgKzEwNjQsOCBAQCBhbWRncHVfZG1fdXBkYXRlX2Nvbm5lY3Rvcl9hZnRlcl9kZXRlY3Qo c3RydWN0IGFtZGdwdV9kbV9jb25uZWN0b3IgKmFjb25uZWN0b3IpCiAKIAogCXNpbmsgPSBhY29u bmVjdG9yLT5kY19saW5rLT5sb2NhbF9zaW5rOworCWlmIChzaW5rKQorCQlkY19zaW5rX3JldGFp bihzaW5rKTsKIAogCS8qCiAJICogRWRpZCBtZ210IGNvbm5lY3RvciBnZXRzIGZpcnN0IHVwZGF0 ZSBvbmx5IGluIG1vZGVfdmFsaWQgaG9vayBhbmQgdGhlbgpAQCAtMTA4NSwyMSArMTA5MCwyNCBA QCBhbWRncHVfZG1fdXBkYXRlX2Nvbm5lY3Rvcl9hZnRlcl9kZXRlY3Qoc3RydWN0IGFtZGdwdV9k bV9jb25uZWN0b3IgKmFjb25uZWN0b3IpCiAJCQkJICogdG8gaXQgYW55bW9yZSBhZnRlciBkaXNj b25uZWN0LCBzbyBvbiBuZXh0IGNydGMgdG8gY29ubmVjdG9yCiAJCQkJICogcmVzaHVmZmxlIGJ5 IFVNRCB3ZSB3aWxsIGdldCBpbnRvIHVud2FudGVkIGRjX3NpbmsgcmVsZWFzZQogCQkJCSAqLwot CQkJCWlmIChhY29ubmVjdG9yLT5kY19zaW5rICE9IGFjb25uZWN0b3ItPmRjX2VtX3NpbmspCi0J CQkJCWRjX3NpbmtfcmVsZWFzZShhY29ubmVjdG9yLT5kY19zaW5rKTsKKwkJCQlkY19zaW5rX3Jl bGVhc2UoYWNvbm5lY3Rvci0+ZGNfc2luayk7CiAJCQl9CiAJCQlhY29ubmVjdG9yLT5kY19zaW5r ID0gc2luazsKKwkJCWRjX3NpbmtfcmV0YWluKGFjb25uZWN0b3ItPmRjX3NpbmspOwogCQkJYW1k Z3B1X2RtX3VwZGF0ZV9mcmVlc3luY19jYXBzKGNvbm5lY3RvciwKIAkJCQkJYWNvbm5lY3Rvci0+ ZWRpZCk7CiAJCX0gZWxzZSB7CiAJCQlhbWRncHVfZG1fdXBkYXRlX2ZyZWVzeW5jX2NhcHMoY29u bmVjdG9yLCBOVUxMKTsKLQkJCWlmICghYWNvbm5lY3Rvci0+ZGNfc2luaykKKwkJCWlmICghYWNv bm5lY3Rvci0+ZGNfc2luaykgewogCQkJCWFjb25uZWN0b3ItPmRjX3NpbmsgPSBhY29ubmVjdG9y LT5kY19lbV9zaW5rOwotCQkJZWxzZSBpZiAoYWNvbm5lY3Rvci0+ZGNfc2luayAhPSBhY29ubmVj dG9yLT5kY19lbV9zaW5rKQogCQkJCWRjX3NpbmtfcmV0YWluKGFjb25uZWN0b3ItPmRjX3Npbmsp OworCQkJfQogCQl9CiAKIAkJbXV0ZXhfdW5sb2NrKCZkZXYtPm1vZGVfY29uZmlnLm11dGV4KTsK KworCQlpZiAoc2luaykKKwkJCWRjX3NpbmtfcmVsZWFzZShzaW5rKTsKIAkJcmV0dXJuOwogCX0K IApAQCAtMTEwNyw4ICsxMTE1LDEwIEBAIGFtZGdwdV9kbV91cGRhdGVfY29ubmVjdG9yX2FmdGVy X2RldGVjdChzdHJ1Y3QgYW1kZ3B1X2RtX2Nvbm5lY3RvciAqYWNvbm5lY3RvcikKIAkgKiBUT0RP OiB0ZW1wb3JhcnkgZ3VhcmQgdG8gbG9vayBmb3IgcHJvcGVyIGZpeAogCSAqIGlmIHRoaXMgc2lu ayBpcyBNU1Qgc2luaywgd2Ugc2hvdWxkIG5vdCBkbyBhbnl0aGluZwogCSAqLwotCWlmIChzaW5r ICYmIHNpbmstPnNpbmtfc2lnbmFsID09IFNJR05BTF9UWVBFX0RJU1BMQVlfUE9SVF9NU1QpCisJ aWYgKHNpbmsgJiYgc2luay0+c2lua19zaWduYWwgPT0gU0lHTkFMX1RZUEVfRElTUExBWV9QT1JU X01TVCkgeworCQlkY19zaW5rX3JlbGVhc2Uoc2luayk7CiAJCXJldHVybjsKKwl9CiAKIAlpZiAo YWNvbm5lY3Rvci0+ZGNfc2luayA9PSBzaW5rKSB7CiAJCS8qCkBAIC0xMTE3LDYgKzExMjcsOCBA QCBhbWRncHVfZG1fdXBkYXRlX2Nvbm5lY3Rvcl9hZnRlcl9kZXRlY3Qoc3RydWN0IGFtZGdwdV9k bV9jb25uZWN0b3IgKmFjb25uZWN0b3IpCiAJCSAqLwogCQlEUk1fREVCVUdfRFJJVkVSKCJEQ0hQ RDogY29ubmVjdG9yX2lkPSVkOiBkY19zaW5rIGRpZG4ndCBjaGFuZ2UuXG4iLAogCQkJCWFjb25u ZWN0b3ItPmNvbm5lY3Rvcl9pZCk7CisJCWlmIChzaW5rKQorCQkJZGNfc2lua19yZWxlYXNlKHNp bmspOwogCQlyZXR1cm47CiAJfQogCkBAIC0xMTM4LDYgKzExNTAsNyBAQCBhbWRncHVfZG1fdXBk YXRlX2Nvbm5lY3Rvcl9hZnRlcl9kZXRlY3Qoc3RydWN0IGFtZGdwdV9kbV9jb25uZWN0b3IgKmFj b25uZWN0b3IpCiAJCQlhbWRncHVfZG1fdXBkYXRlX2ZyZWVzeW5jX2NhcHMoY29ubmVjdG9yLCBO VUxMKTsKIAogCQlhY29ubmVjdG9yLT5kY19zaW5rID0gc2luazsKKwkJZGNfc2lua19yZXRhaW4o YWNvbm5lY3Rvci0+ZGNfc2luayk7CiAJCWlmIChzaW5rLT5kY19lZGlkLmxlbmd0aCA9PSAwKSB7 CiAJCQlhY29ubmVjdG9yLT5lZGlkID0gTlVMTDsKIAkJCWRybV9kcF9jZWNfdW5zZXRfZWRpZCgm YWNvbm5lY3Rvci0+ZG1fZHBfYXV4LmF1eCk7CkBAIC0xMTU4LDExICsxMTcxLDE1IEBAIGFtZGdw dV9kbV91cGRhdGVfY29ubmVjdG9yX2FmdGVyX2RldGVjdChzdHJ1Y3QgYW1kZ3B1X2RtX2Nvbm5l Y3RvciAqYWNvbm5lY3RvcikKIAkJYW1kZ3B1X2RtX3VwZGF0ZV9mcmVlc3luY19jYXBzKGNvbm5l Y3RvciwgTlVMTCk7CiAJCWRybV9jb25uZWN0b3JfdXBkYXRlX2VkaWRfcHJvcGVydHkoY29ubmVj dG9yLCBOVUxMKTsKIAkJYWNvbm5lY3Rvci0+bnVtX21vZGVzID0gMDsKKwkJZGNfc2lua19yZWxl YXNlKGFjb25uZWN0b3ItPmRjX3NpbmspOwogCQlhY29ubmVjdG9yLT5kY19zaW5rID0gTlVMTDsK IAkJYWNvbm5lY3Rvci0+ZWRpZCA9IE5VTEw7CiAJfQogCiAJbXV0ZXhfdW5sb2NrKCZkZXYtPm1v ZGVfY29uZmlnLm11dGV4KTsKKworCWlmIChzaW5rKQorCQlkY19zaW5rX3JlbGVhc2Uoc2luayk7 CiB9CiAKIHN0YXRpYyB2b2lkIGhhbmRsZV9ocGRfaXJxKHZvaWQgKnBhcmFtKQpAQCAtMjkwOCw2 ICsyOTI1LDcgQEAgY3JlYXRlX3N0cmVhbV9mb3Jfc2luayhzdHJ1Y3QgYW1kZ3B1X2RtX2Nvbm5l Y3RvciAqYWNvbm5lY3RvciwKIAkJfQogCX0gZWxzZSB7CiAJCXNpbmsgPSBhY29ubmVjdG9yLT5k Y19zaW5rOworCQlkY19zaW5rX3JldGFpbihzaW5rKTsKIAl9CiAKIAlzdHJlYW0gPSBkY19jcmVh dGVfc3RyZWFtX2Zvcl9zaW5rKHNpbmspOwpAQCAtMjk3NCw4ICsyOTkyLDcgQEAgY3JlYXRlX3N0 cmVhbV9mb3Jfc2luayhzdHJ1Y3QgYW1kZ3B1X2RtX2Nvbm5lY3RvciAqYWNvbm5lY3RvciwKIAkJ c3RyZWFtLT5pZ25vcmVfbXNhX3RpbWluZ19wYXJhbSA9IHRydWU7CiAKIGZpbmlzaDoKLQlpZiAo c2luayAmJiBzaW5rLT5zaW5rX3NpZ25hbCA9PSBTSUdOQUxfVFlQRV9WSVJUVUFMICYmIGFjb25u ZWN0b3ItPmJhc2UuZm9yY2UgIT0gRFJNX0ZPUkNFX09OKQotCQlkY19zaW5rX3JlbGVhc2Uoc2lu ayk7CisJZGNfc2lua19yZWxlYXNlKHNpbmspOwogCiAJcmV0dXJuIHN0cmVhbTsKIH0KQEAgLTMy MzMsNiArMzI1MCwxNCBAQCBzdGF0aWMgdm9pZCBhbWRncHVfZG1fY29ubmVjdG9yX2Rlc3Ryb3ko c3RydWN0IGRybV9jb25uZWN0b3IgKmNvbm5lY3RvcikKIAkJZG0tPmJhY2tsaWdodF9kZXYgPSBO VUxMOwogCX0KICNlbmRpZgorCisJaWYgKGFjb25uZWN0b3ItPmRjX2VtX3NpbmspCisJCWRjX3Np bmtfcmVsZWFzZShhY29ubmVjdG9yLT5kY19lbV9zaW5rKTsKKwlhY29ubmVjdG9yLT5kY19lbV9z aW5rID0gTlVMTDsKKwlpZiAoYWNvbm5lY3Rvci0+ZGNfc2luaykKKwkJZGNfc2lua19yZWxlYXNl KGFjb25uZWN0b3ItPmRjX3NpbmspOworCWFjb25uZWN0b3ItPmRjX3NpbmsgPSBOVUxMOworCiAJ ZHJtX2RwX2NlY191bnJlZ2lzdGVyX2Nvbm5lY3RvcigmYWNvbm5lY3Rvci0+ZG1fZHBfYXV4LmF1 eCk7CiAJZHJtX2Nvbm5lY3Rvcl91bnJlZ2lzdGVyKGNvbm5lY3Rvcik7CiAJZHJtX2Nvbm5lY3Rv cl9jbGVhbnVwKGNvbm5lY3Rvcik7CkBAIC0zMzMwLDEwICszMzU1LDEyIEBAIHN0YXRpYyB2b2lk IGNyZWF0ZV9lbWxfc2luayhzdHJ1Y3QgYW1kZ3B1X2RtX2Nvbm5lY3RvciAqYWNvbm5lY3RvcikK IAkJKGVkaWQtPmV4dGVuc2lvbnMgKyAxKSAqIEVESURfTEVOR1RILAogCQkmaW5pdF9wYXJhbXMp OwogCi0JaWYgKGFjb25uZWN0b3ItPmJhc2UuZm9yY2UgPT0gRFJNX0ZPUkNFX09OKQorCWlmIChh Y29ubmVjdG9yLT5iYXNlLmZvcmNlID09IERSTV9GT1JDRV9PTikgewogCQlhY29ubmVjdG9yLT5k Y19zaW5rID0gYWNvbm5lY3Rvci0+ZGNfbGluay0+bG9jYWxfc2luayA/CiAJCWFjb25uZWN0b3It PmRjX2xpbmstPmxvY2FsX3NpbmsgOgogCQlhY29ubmVjdG9yLT5kY19lbV9zaW5rOworCQlkY19z aW5rX3JldGFpbihhY29ubmVjdG9yLT5kY19zaW5rKTsKKwl9CiB9CiAKIHN0YXRpYyB2b2lkIGhh bmRsZV9lZGlkX21nbXQoc3RydWN0IGFtZGdwdV9kbV9jb25uZWN0b3IgKmFjb25uZWN0b3IpCmRp ZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9kcm0vYW1kL2Rpc3BsYXkvYW1kZ3B1X2RtL2FtZGdwdV9k bV9tc3RfdHlwZXMuYyBiL2RyaXZlcnMvZ3B1L2RybS9hbWQvZGlzcGxheS9hbWRncHVfZG0vYW1k Z3B1X2RtX21zdF90eXBlcy5jCmluZGV4IDFiMGQyMDlkODM2Ny4uM2I5NWE2MzdiNTA4IDEwMDY0 NAotLS0gYS9kcml2ZXJzL2dwdS9kcm0vYW1kL2Rpc3BsYXkvYW1kZ3B1X2RtL2FtZGdwdV9kbV9t c3RfdHlwZXMuYworKysgYi9kcml2ZXJzL2dwdS9kcm0vYW1kL2Rpc3BsYXkvYW1kZ3B1X2RtL2Ft ZGdwdV9kbV9tc3RfdHlwZXMuYwpAQCAtMjM5LDYgKzIzOSw3IEBAIHN0YXRpYyBpbnQgZG1fZHBf bXN0X2dldF9tb2RlcyhzdHJ1Y3QgZHJtX2Nvbm5lY3RvciAqY29ubmVjdG9yKQogCQkJJmluaXRf cGFyYW1zKTsKIAogCQlkY19zaW5rLT5wcml2ID0gYWNvbm5lY3RvcjsKKwkJLyogZGNfbGlua19h ZGRfcmVtb3RlX3NpbmsgcmV0dXJucyBhIG5ldyByZWZlcmVuY2UgKi8KIAkJYWNvbm5lY3Rvci0+ ZGNfc2luayA9IGRjX3Npbms7CiAKIAkJaWYgKGFjb25uZWN0b3ItPmRjX3NpbmspCmRpZmYgLS1n aXQgYS9kcml2ZXJzL2dwdS9kcm0vYW1kL2Rpc3BsYXkvZGMvY29yZS9kY19saW5rLmMgYi9kcml2 ZXJzL2dwdS9kcm0vYW1kL2Rpc3BsYXkvZGMvY29yZS9kY19saW5rLmMKaW5kZXggYjAyNjVkYmVi ZDRjLi41ODNlYjM2Nzg1MGYgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvZ3B1L2RybS9hbWQvZGlzcGxh eS9kYy9jb3JlL2RjX2xpbmsuYworKysgYi9kcml2ZXJzL2dwdS9kcm0vYW1kL2Rpc3BsYXkvZGMv Y29yZS9kY19saW5rLmMKQEAgLTc5Miw2ICs3OTIsNyBAQCBib29sIGRjX2xpbmtfZGV0ZWN0KHN0 cnVjdCBkY19saW5rICpsaW5rLCBlbnVtIGRjX2RldGVjdF9yZWFzb24gcmVhc29uKQogCQlzaW5r LT5kb25nbGVfbWF4X3BpeF9jbGsgPSBzaW5rX2NhcHMubWF4X2hkbWlfcGl4ZWxfY2xvY2s7CiAJ CXNpbmstPmNvbnZlcnRlcl9kaXNhYmxlX2F1ZGlvID0gY29udmVydGVyX2Rpc2FibGVfYXVkaW87 CiAKKwkJLyogZGNfc2lua19jcmVhdGUgcmV0dXJucyBhIG5ldyByZWZlcmVuY2UgKi8KIAkJbGlu ay0+bG9jYWxfc2luayA9IHNpbms7CiAKIAkJZWRpZF9zdGF0dXMgPSBkbV9oZWxwZXJzX3JlYWRf bG9jYWxfZWRpZCgKLS0gCjIuMTkuMQoKX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX18KZHJpLWRldmVsIG1haWxpbmcgbGlzdApkcmktZGV2ZWxAbGlzdHMuZnJl ZWRlc2t0b3Aub3JnCmh0dHBzOi8vbGlzdHMuZnJlZWRlc2t0b3Aub3JnL21haWxtYW4vbGlzdGlu Zm8vZHJpLWRldmVs