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=-6.9 required=3.0 tests=DKIMWL_WL_HIGH,DKIM_SIGNED, DKIM_VALID,DKIM_VALID_AU,HEADER_FROM_DIFFERENT_DOMAINS,INCLUDES_PATCH, MAILING_LIST_MULTI,SIGNED_OFF_BY,SPF_HELO_NONE,SPF_PASS autolearn=ham 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 0E0E2C10F27 for ; Fri, 6 Mar 2020 23:46:45 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [209.132.180.67]) by mail.kernel.org (Postfix) with ESMTP id CBC9F206E2 for ; Fri, 6 Mar 2020 23:46:44 +0000 (UTC) Authentication-Results: mail.kernel.org; dkim=pass (1024-bit key) header.d=redhat.com header.i=@redhat.com header.b="Aizl2v+4" Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1726910AbgCFXql (ORCPT ); Fri, 6 Mar 2020 18:46:41 -0500 Received: from us-smtp-1.mimecast.com ([207.211.31.81]:47763 "EHLO us-smtp-delivery-1.mimecast.com" rhost-flags-OK-OK-OK-FAIL) by vger.kernel.org with ESMTP id S1726635AbgCFXqk (ORCPT ); Fri, 6 Mar 2020 18:46:40 -0500 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=redhat.com; s=mimecast20190719; t=1583538399; h=from:from:reply-to:subject:subject:date:date:message-id:message-id: to:to:cc:cc:mime-version:mime-version:content-type:content-type: content-transfer-encoding:content-transfer-encoding: in-reply-to:in-reply-to:references:references; bh=al/yDzOJoDcjWWSn6wQel46tVaw2Vn6muHcLFQgyG6Y=; b=Aizl2v+4m4eqkCyIUuQH90lhrO8gzHOeqcvM1f51UfwG19pMxhCFlZAhQkr4BGyhtUb9CE vbxCWzDtk+VFvY6lCPaopqxohvyDNP+M+fUwVKzM0j3aMWhVHx8RB6+3jy6/4qxPJs5m6e Rni0WTkK24aBDpCVZZmfuJfGOajNQ+k= Received: from mimecast-mx01.redhat.com (mimecast-mx01.redhat.com [209.132.183.4]) (Using TLS) by relay.mimecast.com with ESMTP id us-mta-123-RIS4M87mOW2Jpch1YHMblw-1; Fri, 06 Mar 2020 18:46:37 -0500 X-MC-Unique: RIS4M87mOW2Jpch1YHMblw-1 Received: from smtp.corp.redhat.com (int-mx05.intmail.prod.int.phx2.redhat.com [10.5.11.15]) (using TLSv1.2 with cipher AECDH-AES256-SHA (256/256 bits)) (No client certificate requested) by mimecast-mx01.redhat.com (Postfix) with ESMTPS id 7647813F5; Fri, 6 Mar 2020 23:46:35 +0000 (UTC) Received: from Ruby.bss.redhat.com (dhcp-10-20-1-196.bss.redhat.com [10.20.1.196]) by smtp.corp.redhat.com (Postfix) with ESMTP id 5E85773873; Fri, 6 Mar 2020 23:46:34 +0000 (UTC) From: Lyude Paul To: dri-devel@lists.freedesktop.org Cc: Mikita Lipski , Sean Paul , Hans de Goede , Maarten Lankhorst , Maxime Ripard , Thomas Zimmermann , David Airlie , Daniel Vetter , Alex Deucher , linux-kernel@vger.kernel.org Subject: [PATCH v2 4/4] drm/dp_mst: Rewrite and fix bandwidth limit checks Date: Fri, 6 Mar 2020 18:46:22 -0500 Message-Id: <20200306234623.547525-5-lyude@redhat.com> In-Reply-To: <20200306234623.547525-1-lyude@redhat.com> References: <20200306234623.547525-1-lyude@redhat.com> MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 X-Scanned-By: MIMEDefang 2.79 on 10.5.11.15 Content-Transfer-Encoding: quoted-printable Sender: linux-kernel-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org Sigh, this is mostly my fault for not giving commit cd82d82cbc04 ("drm/dp_mst: Add branch bandwidth validation to MST atomic check") enough scrutiny during review. The way we're checking bandwidth limitations here is mostly wrong: For starters, drm_dp_mst_atomic_check_bw_limit() determines the pbn_limit of a branch by simply scanning each port on the current branch device, then uses the last non-zero full_pbn value that it finds. It then counts the sum of the PBN used on each branch device for that level, and compares against the full_pbn value it found before. This is wrong because ports can and will have different PBN limitations on many hubs, especially since a number of DisplayPort hubs out there will be clever and only use the smallest link rate required for each downstream sink - potentially giving every port a different full_pbn value depending on what link rate it's trained at. This means with our current code, which max PBN value we end up with is not well defined. Additionally, we also need to remember when checking bandwidth limitations that the top-most device in any MST topology is a branch device, not a port. This means that the first level of a topology doesn't technically have a full_pbn value that needs to be checked. Instead, we should assume that so long as our VCPI allocations fit we're within the bandwidth limitations of the primary MSTB. We do however, want to check full_pbn on every port including those of the primary MSTB. However, it's important to keep in mind that this value represents the minimum link rate /between a port's sink or mstb, and the mstb itself/. A quick diagram to explain: MSTB #1 / \ / \ Port #1 Port #2 full_pbn for Port #1 =E2=86=92 | | =E2=86=90 full_pbn for= Port #2 Sink #1 MSTB #2 | etc... Note that in the above diagram, the combined PBN from all VCPI allocations on said hub should not exceed the full_pbn value of port #2, and the display configuration on sink #1 should not exceed the full_pbn value of port #1. However, port #1 and port #2 can otherwise consume as much bandwidth as they want so long as their VCPI allocations still fit. And finally - our current bandwidth checking code also makes the mistake of not checking whether something is an end device or not before trying to traverse down it. So, let's fix it by rewriting our bandwidth checking helpers. We split the function into one part for handling branches which simply adds up the total PBN on each branch and returns it, and one for checking each port to ensure we're not going over its PBN limit. Phew. This should fix regressions seen, where we erroneously reject display configurations due to thinking they're going over our bandwidth limits when they're not. Changes since v1: * Took an even closer look at how PBN limitations are supposed to be handled, and did some experimenting with Sean Paul. Ended up rewriting these helpers again, but this time they should actually be correct! Signed-off-by: Lyude Paul Fixes: cd82d82cbc04 ("drm/dp_mst: Add branch bandwidth validation to MST = atomic check") Cc: Mikita Lipski Cc: Sean Paul Cc: Hans de Goede --- drivers/gpu/drm/drm_dp_mst_topology.c | 120 ++++++++++++++++++++------ 1 file changed, 94 insertions(+), 26 deletions(-) diff --git a/drivers/gpu/drm/drm_dp_mst_topology.c b/drivers/gpu/drm/drm_= dp_mst_topology.c index b81ad444c24f..322f7b2c9c96 100644 --- a/drivers/gpu/drm/drm_dp_mst_topology.c +++ b/drivers/gpu/drm/drm_dp_mst_topology.c @@ -4841,41 +4841,103 @@ static bool drm_dp_mst_port_downstream_of_branch= (struct drm_dp_mst_port *port, return false; } =20 -static inline -int drm_dp_mst_atomic_check_bw_limit(struct drm_dp_mst_branch *branch, - struct drm_dp_mst_topology_state *mst_state) +static int +drm_dp_mst_atomic_check_port_bw_limit(struct drm_dp_mst_port *port, + struct drm_dp_mst_topology_state *state); + +static int +drm_dp_mst_atomic_check_mstb_bw_limit(struct drm_dp_mst_branch *mstb, + struct drm_dp_mst_topology_state *state) { - struct drm_dp_mst_port *port; struct drm_dp_vcpi_allocation *vcpi; - int pbn_limit =3D 0, pbn_used =3D 0; + struct drm_dp_mst_port *port; + int pbn_used =3D 0, ret; + bool found =3D false; =20 - list_for_each_entry(port, &branch->ports, next) { - if (port->mstb) - if (drm_dp_mst_atomic_check_bw_limit(port->mstb, mst_state)) - return -ENOSPC; + /* Check that we have at least one port in our state that's downstream + * of this branch, otherwise we can skip this branch + */ + list_for_each_entry(vcpi, &state->vcpis, next) { + if (!vcpi->pbn || + !drm_dp_mst_port_downstream_of_branch(vcpi->port, + mstb)) + continue; =20 - if (port->full_pbn > 0) - pbn_limit =3D port->full_pbn; + found =3D true; + break; } - DRM_DEBUG_ATOMIC("[MST BRANCH:%p] branch has %d PBN available\n", - branch, pbn_limit); + if (!found) + return 0; =20 - list_for_each_entry(vcpi, &mst_state->vcpis, next) { - if (!vcpi->pbn) - continue; + if (mstb->port_parent) + DRM_DEBUG_ATOMIC("[MSTB:%p] [MST PORT:%p] Checking bandwidth limits on= [MSTB:%p]\n", + mstb->port_parent->parent, mstb->port_parent, + mstb); + else + DRM_DEBUG_ATOMIC("[MSTB:%p] Checking bandwidth limits\n", + mstb); =20 - if (drm_dp_mst_port_downstream_of_branch(vcpi->port, branch)) - pbn_used +=3D vcpi->pbn; + list_for_each_entry(port, &mstb->ports, next) { + ret =3D drm_dp_mst_atomic_check_port_bw_limit(port, state); + if (ret < 0) + return ret; + + pbn_used +=3D ret; } - DRM_DEBUG_ATOMIC("[MST BRANCH:%p] branch used %d PBN\n", - branch, pbn_used); =20 - if (pbn_used > pbn_limit) { - DRM_DEBUG_ATOMIC("[MST BRANCH:%p] No available bandwidth\n", - branch); + return pbn_used; +} + +static int +drm_dp_mst_atomic_check_port_bw_limit(struct drm_dp_mst_port *port, + struct drm_dp_mst_topology_state *state) +{ + struct drm_dp_vcpi_allocation *vcpi; + int pbn_used =3D 0; + + if (port->pdt =3D=3D DP_PEER_DEVICE_NONE) + return 0; + + if (drm_dp_mst_is_end_device(port->pdt, port->mcs)) { + bool found =3D false; + + list_for_each_entry(vcpi, &state->vcpis, next) { + if (vcpi->port !=3D port) + continue; + if (!vcpi->pbn) + return 0; + + found =3D true; + break; + } + if (!found) + return 0; + + /* This should never happen, as it means we tried to + * set a mode before querying the full_pbn + */ + if (WARN_ON(!port->full_pbn)) + return -EINVAL; + + pbn_used =3D vcpi->pbn; + } else { + pbn_used =3D drm_dp_mst_atomic_check_mstb_bw_limit(port->mstb, + state); + if (pbn_used <=3D 0) + return 0; + } + + if (pbn_used > port->full_pbn) { + DRM_DEBUG_ATOMIC("[MSTB:%p] [MST PORT:%p] required PBN of %d exceeds p= ort limit of %d\n", + port->parent, port, pbn_used, + port->full_pbn); return -ENOSPC; } - return 0; + + DRM_DEBUG_ATOMIC("[MSTB:%p] [MST PORT:%p] uses %d out of %d PBN\n", + port->parent, port, pbn_used, port->full_pbn); + + return pbn_used; } =20 static inline int @@ -5073,9 +5135,15 @@ int drm_dp_mst_atomic_check(struct drm_atomic_stat= e *state) ret =3D drm_dp_mst_atomic_check_vcpi_alloc_limit(mgr, mst_state); if (ret) break; - ret =3D drm_dp_mst_atomic_check_bw_limit(mgr->mst_primary, mst_state); - if (ret) + + mutex_lock(&mgr->lock); + ret =3D drm_dp_mst_atomic_check_mstb_bw_limit(mgr->mst_primary, + mst_state); + mutex_unlock(&mgr->lock); + if (ret < 0) break; + else + ret =3D 0; } =20 return ret; --=20 2.24.1 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=-6.6 required=3.0 tests=DKIM_INVALID,DKIM_SIGNED, HEADER_FROM_DIFFERENT_DOMAINS,INCLUDES_PATCH,MAILING_LIST_MULTI,SIGNED_OFF_BY, SPF_HELO_NONE,SPF_PASS autolearn=ham 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 E59F6C10DCE for ; Fri, 6 Mar 2020 23:46:46 +0000 (UTC) Received: from gabe.freedesktop.org (gabe.freedesktop.org [131.252.210.177]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by mail.kernel.org (Postfix) with ESMTPS id AE17F2073B for ; Fri, 6 Mar 2020 23:46:46 +0000 (UTC) Authentication-Results: mail.kernel.org; dkim=fail reason="signature verification failed" (1024-bit key) header.d=redhat.com header.i=@redhat.com header.b="XOJ9vUTE" DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org AE17F2073B Authentication-Results: mail.kernel.org; dmarc=fail (p=none dis=none) header.from=redhat.com Authentication-Results: mail.kernel.org; spf=none smtp.mailfrom=dri-devel-bounces@lists.freedesktop.org Received: from gabe.freedesktop.org (localhost [127.0.0.1]) by gabe.freedesktop.org (Postfix) with ESMTP id 7C6AB6EDA4; Fri, 6 Mar 2020 23:46:43 +0000 (UTC) Received: from us-smtp-delivery-1.mimecast.com (us-smtp-2.mimecast.com [207.211.31.81]) by gabe.freedesktop.org (Postfix) with ESMTPS id D8AA66EDA4 for ; Fri, 6 Mar 2020 23:46:41 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=redhat.com; s=mimecast20190719; t=1583538400; h=from:from:reply-to:subject:subject:date:date:message-id:message-id: to:to:cc:cc:mime-version:mime-version:content-type:content-type: content-transfer-encoding:content-transfer-encoding: in-reply-to:in-reply-to:references:references; bh=al/yDzOJoDcjWWSn6wQel46tVaw2Vn6muHcLFQgyG6Y=; b=XOJ9vUTEOSYwtBfY0F3r5ohqXl8iXYGxhGAgNUH1uLYOil5miCoYAO3iEgFh/nQL3cF/rZ rf/KbyVc7HpQKM7LVEplpt72qISBElD7rYkxAWK0dRIpw30elXWnOza1RLzyDkfUOzbGXp lfhU99GXAInZ+emH0wcRPbMSxVLIq7M= Received: from mimecast-mx01.redhat.com (mimecast-mx01.redhat.com [209.132.183.4]) (Using TLS) by relay.mimecast.com with ESMTP id us-mta-123-RIS4M87mOW2Jpch1YHMblw-1; Fri, 06 Mar 2020 18:46:37 -0500 X-MC-Unique: RIS4M87mOW2Jpch1YHMblw-1 Received: from smtp.corp.redhat.com (int-mx05.intmail.prod.int.phx2.redhat.com [10.5.11.15]) (using TLSv1.2 with cipher AECDH-AES256-SHA (256/256 bits)) (No client certificate requested) by mimecast-mx01.redhat.com (Postfix) with ESMTPS id 7647813F5; Fri, 6 Mar 2020 23:46:35 +0000 (UTC) Received: from Ruby.bss.redhat.com (dhcp-10-20-1-196.bss.redhat.com [10.20.1.196]) by smtp.corp.redhat.com (Postfix) with ESMTP id 5E85773873; Fri, 6 Mar 2020 23:46:34 +0000 (UTC) From: Lyude Paul To: dri-devel@lists.freedesktop.org Subject: [PATCH v2 4/4] drm/dp_mst: Rewrite and fix bandwidth limit checks Date: Fri, 6 Mar 2020 18:46:22 -0500 Message-Id: <20200306234623.547525-5-lyude@redhat.com> In-Reply-To: <20200306234623.547525-1-lyude@redhat.com> References: <20200306234623.547525-1-lyude@redhat.com> MIME-Version: 1.0 X-Scanned-By: MIMEDefang 2.79 on 10.5.11.15 X-BeenThere: dri-devel@lists.freedesktop.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: Direct Rendering Infrastructure - Development List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Cc: Sean Paul , David Airlie , linux-kernel@vger.kernel.org, Hans de Goede , Thomas Zimmermann , Alex Deucher , Mikita Lipski Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Errors-To: dri-devel-bounces@lists.freedesktop.org Sender: "dri-devel" U2lnaCwgdGhpcyBpcyBtb3N0bHkgbXkgZmF1bHQgZm9yIG5vdCBnaXZpbmcgY29tbWl0IGNkODJk ODJjYmMwNAooImRybS9kcF9tc3Q6IEFkZCBicmFuY2ggYmFuZHdpZHRoIHZhbGlkYXRpb24gdG8g TVNUIGF0b21pYyBjaGVjayIpCmVub3VnaCBzY3J1dGlueSBkdXJpbmcgcmV2aWV3LiBUaGUgd2F5 IHdlJ3JlIGNoZWNraW5nIGJhbmR3aWR0aApsaW1pdGF0aW9ucyBoZXJlIGlzIG1vc3RseSB3cm9u ZzoKCkZvciBzdGFydGVycywgZHJtX2RwX21zdF9hdG9taWNfY2hlY2tfYndfbGltaXQoKSBkZXRl cm1pbmVzIHRoZQpwYm5fbGltaXQgb2YgYSBicmFuY2ggYnkgc2ltcGx5IHNjYW5uaW5nIGVhY2gg cG9ydCBvbiB0aGUgY3VycmVudCBicmFuY2gKZGV2aWNlLCB0aGVuIHVzZXMgdGhlIGxhc3Qgbm9u LXplcm8gZnVsbF9wYm4gdmFsdWUgdGhhdCBpdCBmaW5kcy4gSXQKdGhlbiBjb3VudHMgdGhlIHN1 bSBvZiB0aGUgUEJOIHVzZWQgb24gZWFjaCBicmFuY2ggZGV2aWNlIGZvciB0aGF0CmxldmVsLCBh bmQgY29tcGFyZXMgYWdhaW5zdCB0aGUgZnVsbF9wYm4gdmFsdWUgaXQgZm91bmQgYmVmb3JlLgoK VGhpcyBpcyB3cm9uZyBiZWNhdXNlIHBvcnRzIGNhbiBhbmQgd2lsbCBoYXZlIGRpZmZlcmVudCBQ Qk4gbGltaXRhdGlvbnMKb24gbWFueSBodWJzLCBlc3BlY2lhbGx5IHNpbmNlIGEgbnVtYmVyIG9m IERpc3BsYXlQb3J0IGh1YnMgb3V0IHRoZXJlCndpbGwgYmUgY2xldmVyIGFuZCBvbmx5IHVzZSB0 aGUgc21hbGxlc3QgbGluayByYXRlIHJlcXVpcmVkIGZvciBlYWNoCmRvd25zdHJlYW0gc2luayAt IHBvdGVudGlhbGx5IGdpdmluZyBldmVyeSBwb3J0IGEgZGlmZmVyZW50IGZ1bGxfcGJuCnZhbHVl IGRlcGVuZGluZyBvbiB3aGF0IGxpbmsgcmF0ZSBpdCdzIHRyYWluZWQgYXQuIFRoaXMgbWVhbnMg d2l0aCBvdXIKY3VycmVudCBjb2RlLCB3aGljaCBtYXggUEJOIHZhbHVlIHdlIGVuZCB1cCB3aXRo IGlzIG5vdCB3ZWxsIGRlZmluZWQuCgpBZGRpdGlvbmFsbHksIHdlIGFsc28gbmVlZCB0byByZW1l bWJlciB3aGVuIGNoZWNraW5nIGJhbmR3aWR0aApsaW1pdGF0aW9ucyB0aGF0IHRoZSB0b3AtbW9z dCBkZXZpY2UgaW4gYW55IE1TVCB0b3BvbG9neSBpcyBhIGJyYW5jaApkZXZpY2UsIG5vdCBhIHBv cnQuIFRoaXMgbWVhbnMgdGhhdCB0aGUgZmlyc3QgbGV2ZWwgb2YgYSB0b3BvbG9neQpkb2Vzbid0 IHRlY2huaWNhbGx5IGhhdmUgYSBmdWxsX3BibiB2YWx1ZSB0aGF0IG5lZWRzIHRvIGJlIGNoZWNr ZWQuCkluc3RlYWQsIHdlIHNob3VsZCBhc3N1bWUgdGhhdCBzbyBsb25nIGFzIG91ciBWQ1BJIGFs bG9jYXRpb25zIGZpdCB3ZSdyZQp3aXRoaW4gdGhlIGJhbmR3aWR0aCBsaW1pdGF0aW9ucyBvZiB0 aGUgcHJpbWFyeSBNU1RCLgoKV2UgZG8gaG93ZXZlciwgd2FudCB0byBjaGVjayBmdWxsX3BibiBv biBldmVyeSBwb3J0IGluY2x1ZGluZyB0aG9zZSBvZgp0aGUgcHJpbWFyeSBNU1RCLiBIb3dldmVy LCBpdCdzIGltcG9ydGFudCB0byBrZWVwIGluIG1pbmQgdGhhdCB0aGlzCnZhbHVlIHJlcHJlc2Vu dHMgdGhlIG1pbmltdW0gbGluayByYXRlIC9iZXR3ZWVuIGEgcG9ydCdzIHNpbmsgb3IgbXN0YiwK YW5kIHRoZSBtc3RiIGl0c2VsZi8uIEEgcXVpY2sgZGlhZ3JhbSB0byBleHBsYWluOgoKICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICBNU1RCICMxCiAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAvICAgICAgIFwKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgLyAgICAgICAg IFwKICAgICAgICAgICAgICAgICAgICAgICAgICAgUG9ydCAjMSAgICBQb3J0ICMyCiAgICAgICBm dWxsX3BibiBmb3IgUG9ydCAjMSDihpIgfCAgICAgICAgICB8IOKGkCBmdWxsX3BibiBmb3IgUG9y dCAjMgogICAgICAgICAgICAgICAgICAgICAgICAgICBTaW5rICMxICAgIE1TVEIgIzIKICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICB8CiAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgIGV0Yy4uLgoKTm90ZSB0aGF0IGluIHRoZSBhYm92ZSBkaWFncmFt LCB0aGUgY29tYmluZWQgUEJOIGZyb20gYWxsIFZDUEkKYWxsb2NhdGlvbnMgb24gc2FpZCBodWIg c2hvdWxkIG5vdCBleGNlZWQgdGhlIGZ1bGxfcGJuIHZhbHVlIG9mIHBvcnQgIzIsCmFuZCB0aGUg ZGlzcGxheSBjb25maWd1cmF0aW9uIG9uIHNpbmsgIzEgc2hvdWxkIG5vdCBleGNlZWQgdGhlIGZ1 bGxfcGJuCnZhbHVlIG9mIHBvcnQgIzEuIEhvd2V2ZXIsIHBvcnQgIzEgYW5kIHBvcnQgIzIgY2Fu IG90aGVyd2lzZSBjb25zdW1lIGFzCm11Y2ggYmFuZHdpZHRoIGFzIHRoZXkgd2FudCBzbyBsb25n IGFzIHRoZWlyIFZDUEkgYWxsb2NhdGlvbnMgc3RpbGwgZml0LgoKQW5kIGZpbmFsbHkgLSBvdXIg Y3VycmVudCBiYW5kd2lkdGggY2hlY2tpbmcgY29kZSBhbHNvIG1ha2VzIHRoZSBtaXN0YWtlCm9m IG5vdCBjaGVja2luZyB3aGV0aGVyIHNvbWV0aGluZyBpcyBhbiBlbmQgZGV2aWNlIG9yIG5vdCBi ZWZvcmUgdHJ5aW5nCnRvIHRyYXZlcnNlIGRvd24gaXQuCgpTbywgbGV0J3MgZml4IGl0IGJ5IHJl d3JpdGluZyBvdXIgYmFuZHdpZHRoIGNoZWNraW5nIGhlbHBlcnMuIFdlIHNwbGl0CnRoZSBmdW5j dGlvbiBpbnRvIG9uZSBwYXJ0IGZvciBoYW5kbGluZyBicmFuY2hlcyB3aGljaCBzaW1wbHkgYWRk cyB1cAp0aGUgdG90YWwgUEJOIG9uIGVhY2ggYnJhbmNoIGFuZCByZXR1cm5zIGl0LCBhbmQgb25l IGZvciBjaGVja2luZyBlYWNoCnBvcnQgdG8gZW5zdXJlIHdlJ3JlIG5vdCBnb2luZyBvdmVyIGl0 cyBQQk4gbGltaXQuIFBoZXcuCgpUaGlzIHNob3VsZCBmaXggcmVncmVzc2lvbnMgc2Vlbiwgd2hl cmUgd2UgZXJyb25lb3VzbHkgcmVqZWN0IGRpc3BsYXkKY29uZmlndXJhdGlvbnMgZHVlIHRvIHRo aW5raW5nIHRoZXkncmUgZ29pbmcgb3ZlciBvdXIgYmFuZHdpZHRoIGxpbWl0cwp3aGVuIHRoZXkn cmUgbm90LgoKQ2hhbmdlcyBzaW5jZSB2MToKKiBUb29rIGFuIGV2ZW4gY2xvc2VyIGxvb2sgYXQg aG93IFBCTiBsaW1pdGF0aW9ucyBhcmUgc3VwcG9zZWQgdG8gYmUKICBoYW5kbGVkLCBhbmQgZGlk IHNvbWUgZXhwZXJpbWVudGluZyB3aXRoIFNlYW4gUGF1bC4gRW5kZWQgdXAgcmV3cml0aW5nCiAg dGhlc2UgaGVscGVycyBhZ2FpbiwgYnV0IHRoaXMgdGltZSB0aGV5IHNob3VsZCBhY3R1YWxseSBi ZSBjb3JyZWN0IQoKU2lnbmVkLW9mZi1ieTogTHl1ZGUgUGF1bCA8bHl1ZGVAcmVkaGF0LmNvbT4K Rml4ZXM6IGNkODJkODJjYmMwNCAoImRybS9kcF9tc3Q6IEFkZCBicmFuY2ggYmFuZHdpZHRoIHZh bGlkYXRpb24gdG8gTVNUIGF0b21pYyBjaGVjayIpCkNjOiBNaWtpdGEgTGlwc2tpIDxtaWtpdGEu bGlwc2tpQGFtZC5jb20+CkNjOiBTZWFuIFBhdWwgPHNlYW5wYXVsQGdvb2dsZS5jb20+CkNjOiBI YW5zIGRlIEdvZWRlIDxoZGVnb2VkZUByZWRoYXQuY29tPgotLS0KIGRyaXZlcnMvZ3B1L2RybS9k cm1fZHBfbXN0X3RvcG9sb2d5LmMgfCAxMjAgKysrKysrKysrKysrKysrKysrKystLS0tLS0KIDEg ZmlsZSBjaGFuZ2VkLCA5NCBpbnNlcnRpb25zKCspLCAyNiBkZWxldGlvbnMoLSkKCmRpZmYgLS1n aXQgYS9kcml2ZXJzL2dwdS9kcm0vZHJtX2RwX21zdF90b3BvbG9neS5jIGIvZHJpdmVycy9ncHUv ZHJtL2RybV9kcF9tc3RfdG9wb2xvZ3kuYwppbmRleCBiODFhZDQ0NGMyNGYuLjMyMmY3YjJjOWM5 NiAxMDA2NDQKLS0tIGEvZHJpdmVycy9ncHUvZHJtL2RybV9kcF9tc3RfdG9wb2xvZ3kuYworKysg Yi9kcml2ZXJzL2dwdS9kcm0vZHJtX2RwX21zdF90b3BvbG9neS5jCkBAIC00ODQxLDQxICs0ODQx LDEwMyBAQCBzdGF0aWMgYm9vbCBkcm1fZHBfbXN0X3BvcnRfZG93bnN0cmVhbV9vZl9icmFuY2go c3RydWN0IGRybV9kcF9tc3RfcG9ydCAqcG9ydCwKIAlyZXR1cm4gZmFsc2U7CiB9CiAKLXN0YXRp YyBpbmxpbmUKLWludCBkcm1fZHBfbXN0X2F0b21pY19jaGVja19id19saW1pdChzdHJ1Y3QgZHJt X2RwX21zdF9icmFuY2ggKmJyYW5jaCwKLQkJCQkgICAgIHN0cnVjdCBkcm1fZHBfbXN0X3RvcG9s b2d5X3N0YXRlICptc3Rfc3RhdGUpCitzdGF0aWMgaW50Citkcm1fZHBfbXN0X2F0b21pY19jaGVj a19wb3J0X2J3X2xpbWl0KHN0cnVjdCBkcm1fZHBfbXN0X3BvcnQgKnBvcnQsCisJCQkJICAgICAg c3RydWN0IGRybV9kcF9tc3RfdG9wb2xvZ3lfc3RhdGUgKnN0YXRlKTsKKworc3RhdGljIGludAor ZHJtX2RwX21zdF9hdG9taWNfY2hlY2tfbXN0Yl9id19saW1pdChzdHJ1Y3QgZHJtX2RwX21zdF9i cmFuY2ggKm1zdGIsCisJCQkJICAgICAgc3RydWN0IGRybV9kcF9tc3RfdG9wb2xvZ3lfc3RhdGUg KnN0YXRlKQogewotCXN0cnVjdCBkcm1fZHBfbXN0X3BvcnQgKnBvcnQ7CiAJc3RydWN0IGRybV9k cF92Y3BpX2FsbG9jYXRpb24gKnZjcGk7Ci0JaW50IHBibl9saW1pdCA9IDAsIHBibl91c2VkID0g MDsKKwlzdHJ1Y3QgZHJtX2RwX21zdF9wb3J0ICpwb3J0OworCWludCBwYm5fdXNlZCA9IDAsIHJl dDsKKwlib29sIGZvdW5kID0gZmFsc2U7CiAKLQlsaXN0X2Zvcl9lYWNoX2VudHJ5KHBvcnQsICZi cmFuY2gtPnBvcnRzLCBuZXh0KSB7Ci0JCWlmIChwb3J0LT5tc3RiKQotCQkJaWYgKGRybV9kcF9t c3RfYXRvbWljX2NoZWNrX2J3X2xpbWl0KHBvcnQtPm1zdGIsIG1zdF9zdGF0ZSkpCi0JCQkJcmV0 dXJuIC1FTk9TUEM7CisJLyogQ2hlY2sgdGhhdCB3ZSBoYXZlIGF0IGxlYXN0IG9uZSBwb3J0IGlu IG91ciBzdGF0ZSB0aGF0J3MgZG93bnN0cmVhbQorCSAqIG9mIHRoaXMgYnJhbmNoLCBvdGhlcndp c2Ugd2UgY2FuIHNraXAgdGhpcyBicmFuY2gKKwkgKi8KKwlsaXN0X2Zvcl9lYWNoX2VudHJ5KHZj cGksICZzdGF0ZS0+dmNwaXMsIG5leHQpIHsKKwkJaWYgKCF2Y3BpLT5wYm4gfHwKKwkJICAgICFk cm1fZHBfbXN0X3BvcnRfZG93bnN0cmVhbV9vZl9icmFuY2godmNwaS0+cG9ydCwKKwkJCQkJCQkg IG1zdGIpKQorCQkJY29udGludWU7CiAKLQkJaWYgKHBvcnQtPmZ1bGxfcGJuID4gMCkKLQkJCXBi bl9saW1pdCA9IHBvcnQtPmZ1bGxfcGJuOworCQlmb3VuZCA9IHRydWU7CisJCWJyZWFrOwogCX0K LQlEUk1fREVCVUdfQVRPTUlDKCJbTVNUIEJSQU5DSDolcF0gYnJhbmNoIGhhcyAlZCBQQk4gYXZh aWxhYmxlXG4iLAotCQkJIGJyYW5jaCwgcGJuX2xpbWl0KTsKKwlpZiAoIWZvdW5kKQorCQlyZXR1 cm4gMDsKIAotCWxpc3RfZm9yX2VhY2hfZW50cnkodmNwaSwgJm1zdF9zdGF0ZS0+dmNwaXMsIG5l eHQpIHsKLQkJaWYgKCF2Y3BpLT5wYm4pCi0JCQljb250aW51ZTsKKwlpZiAobXN0Yi0+cG9ydF9w YXJlbnQpCisJCURSTV9ERUJVR19BVE9NSUMoIltNU1RCOiVwXSBbTVNUIFBPUlQ6JXBdIENoZWNr aW5nIGJhbmR3aWR0aCBsaW1pdHMgb24gW01TVEI6JXBdXG4iLAorCQkJCSBtc3RiLT5wb3J0X3Bh cmVudC0+cGFyZW50LCBtc3RiLT5wb3J0X3BhcmVudCwKKwkJCQkgbXN0Yik7CisJZWxzZQorCQlE Uk1fREVCVUdfQVRPTUlDKCJbTVNUQjolcF0gQ2hlY2tpbmcgYmFuZHdpZHRoIGxpbWl0c1xuIiwK KwkJCQkgbXN0Yik7CiAKLQkJaWYgKGRybV9kcF9tc3RfcG9ydF9kb3duc3RyZWFtX29mX2JyYW5j aCh2Y3BpLT5wb3J0LCBicmFuY2gpKQotCQkJcGJuX3VzZWQgKz0gdmNwaS0+cGJuOworCWxpc3Rf Zm9yX2VhY2hfZW50cnkocG9ydCwgJm1zdGItPnBvcnRzLCBuZXh0KSB7CisJCXJldCA9IGRybV9k cF9tc3RfYXRvbWljX2NoZWNrX3BvcnRfYndfbGltaXQocG9ydCwgc3RhdGUpOworCQlpZiAocmV0 IDwgMCkKKwkJCXJldHVybiByZXQ7CisKKwkJcGJuX3VzZWQgKz0gcmV0OwogCX0KLQlEUk1fREVC VUdfQVRPTUlDKCJbTVNUIEJSQU5DSDolcF0gYnJhbmNoIHVzZWQgJWQgUEJOXG4iLAotCQkJIGJy YW5jaCwgcGJuX3VzZWQpOwogCi0JaWYgKHBibl91c2VkID4gcGJuX2xpbWl0KSB7Ci0JCURSTV9E RUJVR19BVE9NSUMoIltNU1QgQlJBTkNIOiVwXSBObyBhdmFpbGFibGUgYmFuZHdpZHRoXG4iLAot CQkJCSBicmFuY2gpOworCXJldHVybiBwYm5fdXNlZDsKK30KKworc3RhdGljIGludAorZHJtX2Rw X21zdF9hdG9taWNfY2hlY2tfcG9ydF9id19saW1pdChzdHJ1Y3QgZHJtX2RwX21zdF9wb3J0ICpw b3J0LAorCQkJCSAgICAgIHN0cnVjdCBkcm1fZHBfbXN0X3RvcG9sb2d5X3N0YXRlICpzdGF0ZSkK K3sKKwlzdHJ1Y3QgZHJtX2RwX3ZjcGlfYWxsb2NhdGlvbiAqdmNwaTsKKwlpbnQgcGJuX3VzZWQg PSAwOworCisJaWYgKHBvcnQtPnBkdCA9PSBEUF9QRUVSX0RFVklDRV9OT05FKQorCQlyZXR1cm4g MDsKKworCWlmIChkcm1fZHBfbXN0X2lzX2VuZF9kZXZpY2UocG9ydC0+cGR0LCBwb3J0LT5tY3Mp KSB7CisJCWJvb2wgZm91bmQgPSBmYWxzZTsKKworCQlsaXN0X2Zvcl9lYWNoX2VudHJ5KHZjcGks ICZzdGF0ZS0+dmNwaXMsIG5leHQpIHsKKwkJCWlmICh2Y3BpLT5wb3J0ICE9IHBvcnQpCisJCQkJ Y29udGludWU7CisJCQlpZiAoIXZjcGktPnBibikKKwkJCQlyZXR1cm4gMDsKKworCQkJZm91bmQg PSB0cnVlOworCQkJYnJlYWs7CisJCX0KKwkJaWYgKCFmb3VuZCkKKwkJCXJldHVybiAwOworCisJ CS8qIFRoaXMgc2hvdWxkIG5ldmVyIGhhcHBlbiwgYXMgaXQgbWVhbnMgd2UgdHJpZWQgdG8KKwkJ ICogc2V0IGEgbW9kZSBiZWZvcmUgcXVlcnlpbmcgdGhlIGZ1bGxfcGJuCisJCSAqLworCQlpZiAo V0FSTl9PTighcG9ydC0+ZnVsbF9wYm4pKQorCQkJcmV0dXJuIC1FSU5WQUw7CisKKwkJcGJuX3Vz ZWQgPSB2Y3BpLT5wYm47CisJfSBlbHNlIHsKKwkJcGJuX3VzZWQgPSBkcm1fZHBfbXN0X2F0b21p Y19jaGVja19tc3RiX2J3X2xpbWl0KHBvcnQtPm1zdGIsCisJCQkJCQkJCSBzdGF0ZSk7CisJCWlm IChwYm5fdXNlZCA8PSAwKQorCQkJcmV0dXJuIDA7CisJfQorCisJaWYgKHBibl91c2VkID4gcG9y dC0+ZnVsbF9wYm4pIHsKKwkJRFJNX0RFQlVHX0FUT01JQygiW01TVEI6JXBdIFtNU1QgUE9SVDol cF0gcmVxdWlyZWQgUEJOIG9mICVkIGV4Y2VlZHMgcG9ydCBsaW1pdCBvZiAlZFxuIiwKKwkJCQkg cG9ydC0+cGFyZW50LCBwb3J0LCBwYm5fdXNlZCwKKwkJCQkgcG9ydC0+ZnVsbF9wYm4pOwogCQly ZXR1cm4gLUVOT1NQQzsKIAl9Ci0JcmV0dXJuIDA7CisKKwlEUk1fREVCVUdfQVRPTUlDKCJbTVNU QjolcF0gW01TVCBQT1JUOiVwXSB1c2VzICVkIG91dCBvZiAlZCBQQk5cbiIsCisJCQkgcG9ydC0+ cGFyZW50LCBwb3J0LCBwYm5fdXNlZCwgcG9ydC0+ZnVsbF9wYm4pOworCisJcmV0dXJuIHBibl91 c2VkOwogfQogCiBzdGF0aWMgaW5saW5lIGludApAQCAtNTA3Myw5ICs1MTM1LDE1IEBAIGludCBk cm1fZHBfbXN0X2F0b21pY19jaGVjayhzdHJ1Y3QgZHJtX2F0b21pY19zdGF0ZSAqc3RhdGUpCiAJ CXJldCA9IGRybV9kcF9tc3RfYXRvbWljX2NoZWNrX3ZjcGlfYWxsb2NfbGltaXQobWdyLCBtc3Rf c3RhdGUpOwogCQlpZiAocmV0KQogCQkJYnJlYWs7Ci0JCXJldCA9IGRybV9kcF9tc3RfYXRvbWlj X2NoZWNrX2J3X2xpbWl0KG1nci0+bXN0X3ByaW1hcnksIG1zdF9zdGF0ZSk7Ci0JCWlmIChyZXQp CisKKwkJbXV0ZXhfbG9jaygmbWdyLT5sb2NrKTsKKwkJcmV0ID0gZHJtX2RwX21zdF9hdG9taWNf Y2hlY2tfbXN0Yl9id19saW1pdChtZ3ItPm1zdF9wcmltYXJ5LAorCQkJCQkJCSAgICBtc3Rfc3Rh dGUpOworCQltdXRleF91bmxvY2soJm1nci0+bG9jayk7CisJCWlmIChyZXQgPCAwKQogCQkJYnJl YWs7CisJCWVsc2UKKwkJCXJldCA9IDA7CiAJfQogCiAJcmV0dXJuIHJldDsKLS0gCjIuMjQuMQoK X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX18KZHJpLWRldmVs IG1haWxpbmcgbGlzdApkcmktZGV2ZWxAbGlzdHMuZnJlZWRlc2t0b3Aub3JnCmh0dHBzOi8vbGlz dHMuZnJlZWRlc2t0b3Aub3JnL21haWxtYW4vbGlzdGluZm8vZHJpLWRldmVsCg==