From mboxrd@z Thu Jan 1 00:00:00 1970 From: Lyude Paul Subject: [PATCH v5 06/14] drm/dp_mst: Protect drm_dp_mst_port members with locking Date: Mon, 21 Oct 2019 22:36:01 -0400 Message-ID: <20191022023641.8026-7-lyude@redhat.com> References: <20191022023641.8026-1-lyude@redhat.com> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Return-path: In-Reply-To: <20191022023641.8026-1-lyude@redhat.com> List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: intel-gfx-bounces@lists.freedesktop.org Sender: "Intel-gfx" To: dri-devel@lists.freedesktop.org, amd-gfx@lists.freedesktop.org, nouveau@lists.freedesktop.org, intel-gfx@lists.freedesktop.org Cc: David Airlie , Daniel Vetter , Laurent Pinchart , Sam Ravnborg , "David (ChunMing) Zhou" , David Francis , "Jerry (Fangzhi) Zuo" , Ben Skeggs , Harry Wentland , Leo Li , Maxime Ripard , Harry Wentland , Thomas Lim , linux-kernel@vger.kernel.org, =?UTF-8?q?Christian=20K=C3=B6nig?= , Alex Deucher , Nicholas Kazlauskas , =?UTF-8?q?Mathias=20Fr=C3=B6hlich?= List-Id: amd-gfx.lists.freedesktop.org VGhpcyBpcyBhIGNvbXBsaWNhdGVkIG9uZS4gRXNzZW50aWFsbHksIHRoZXJlJ3MgY3VycmVudGx5 IGEgcHJvYmxlbSBpbiB0aGUgTVNUCmNvcmUgdGhhdCBoYXNuJ3QgcmVhbGx5IGNhdXNlZCBhbnkg aXNzdWVzIHRoYXQgd2UncmUgYXdhcmUgb2YgKGVtcGhhc2lzIG9uICJ0aGF0CndlJ3JlIGF3YXJl IG9mIik6IGxvY2tpbmcuCgpXaGVuIHdlIGdvIHRocm91Z2ggYW5kIHByb2JlIHRoZSBsaW5rIGFk ZHJlc3NlcyBhbmQgcGF0aCByZXNvdXJjZXMgaW4gYQp0b3BvbG9neSwgd2UgaG9sZCBubyBsb2Nr cyB3aGVuIHVwZGF0aW5nIHBvcnRzIHdpdGggc2FpZCBpbmZvcm1hdGlvbi4gVGhlCm1lbWJlcnMg SSdtIHJlZmVycmluZyB0byBpbiBwYXJ0aWN1bGFyIGFyZToKCi0gbGRwcwotIGRkcHMKLSBtY3MK LSBwZHQKLSBkcGNkX3JldgotIG51bV9zZHBfc3RyZWFtcwotIG51bV9zZHBfc3RyZWFtX3Npbmtz Ci0gYXZhaWxhYmxlX3BibgotIGlucHV0Ci0gY29ubmVjdG9yCgpOb3cgdGhhdCB3ZSdyZSBoYW5k bGluZyBVUCByZXF1ZXN0cyBhc3luY2hyb25vdXNseSBhbmQgd2lsbCBiZSB1c2luZyBzb21lIG9m CnRoZSBzdHJ1Y3QgbWVtYmVycyBtZW50aW9uZWQgYWJvdmUgaW4gYXRvbWljIG1vZGVzZXR0aW5n IGluIHRoZSBmdXR1cmUgZm9yCmZlYXR1cmVzIHN1Y2ggYXMgUEJOIHZhbGlkYXRpb24sIHRoaXMg aXMgZ29pbmcgdG8gYmVjb21lIGEgbG90IG1vcmUgaW1wb3J0YW50LgpBcyB3ZWxsLCB0aGUgbmV4 dCBmZXcgY29tbWl0cyB0aGF0IHByZXBhcmUgdXMgZm9yIGFuZCBpbnRyb2R1Y2Ugc3VzcGVuZC9y ZXN1bWUKcmVwcm9iaW5nIHdpbGwgYWxzbyBuZWVkIGNsZWFyIGxvY2tpbmcgaW4gb3JkZXIgdG8g cHJldmVudCBmcm9tIGFkZGl0aW9uYWwKcmFjaW5nIGhpbGFyaXRpZXMgdGhhdCB3ZSBuZXZlciBj b3VsZCBoYXZlIGhpdCBpbiB0aGUgcGFzdC4KClNvLCBsZXQncyBzb2x2ZSB0aGlzIGlzc3VlIGJ5 IHVzaW5nICZtZ3ItPmJhc2UubG9jaywgdGhlIG1vZGVzZXR0aW5nCmxvY2sgd2hpY2ggY3VycmVu dGx5IG9ubHkgcHJvdGVjdHMgJm1nci0+YmFzZS5zdGF0ZS4gVGhpcyB3b3JrcwpwZXJmZWN0bHkg YmVjYXVzZSBpdCBhbGxvd3MgdXMgdG8gYXZvaWQgYmxvY2tpbmcgY29ubmVjdGlvbl9tdXRleAp1 bm5lY2Vzc2FyaWx5LCBhbmQgd2UgY2FuIGdyYWIgdGhpcyBpbiBjb25uZWN0b3IgZGV0ZWN0aW9u IHBhdGhzIHNpbmNlCml0J3MgYSB3dyBtdXRleC4gV2Ugc3RhcnQgYnkgaGF2aW5nIGRybV9kcF9t c3RfaGFuZGxlX3VwX3JlcSgpIGhvbGQgdGhpcwp3aGVuIHVwZGF0aW5nIHBvcnRzLiBGb3IgZHJt X2RwX21zdF9oYW5kbGVfbGlua19hZGRyZXNzX3BvcnQoKSB0aGluZ3MKYXJlIGEgYml0IG1vcmUg Y29tcGxpY2F0ZWQuIEFzIEkndmUgbGVhcm5lZCB0aGUgaGFyZCB3YXksIHdlIGNhbiBncmFiCiZt Z3ItPmxvY2suYmFzZSBmb3IgZXZlcnl0aGluZyBleGNlcHQgZm9yIHBvcnQtPmNvbm5lY3Rvci4g U2VlLCBvdXIKbm9ybWFsIGRyaXZlciBwcm9iaW5nIHBhdGhzIGVuZCB1cCBnZW5lcmF0aW5nIHRo aXMgcmF0aGVyIG9idmlvdXMKbG9ja2RlcCBjaGFpbjoKCiZkcm0tPm1vZGVfY29uZmlnLm11dGV4 CiAgLT4gY3J0Y193d19jbGFzc19tdXRleC9jcnRjX3d3X2NsYXNzX2FjcXVpcmUKICAgIC0+ICZj b25uZWN0b3ItPm11dGV4CgpIb3dldmVyLCBzeXNmcyBncmFicyAmZHJtLT5tb2RlX2NvbmZpZy5t dXRleCBpbiBvcmRlciB0byBwcm90ZWN0IGl0c2VsZgpmcm9tIGNvbm5lY3RvciBzdGF0ZSBjaGFu Z2luZyB1bmRlciBpdC4gQmVjYXVzZSB0aGlzIGVudGFpbHMgZ3JhYmJpbmcKa24tPmNvdW50LCBl LmcuIHRoZSBsb2NrIHRoYXQgdGhlIGtlcm5lbCBwcm92aWRlcyBmb3IgcHJvdGVjdGluZyBzeXNm cwpjb250ZXh0cywgd2UgZW5kIHVwIGdyYWJiaW5nIGtuLT5jb3VudCBmb2xsb3dlZCBieQomZHJt LT5tb2RlX2NvbmZpZy5tdXRleC4gVGhpcyBlbmRzIHVwIGNyZWF0aW5nIGFuIGV4dHJlbWVseSBy dWRlIGNoYWluOgoKJmtuLT5jb3VudAogIC0+ICZkcm0tPm1vZGVfY29uZmlnLm11dGV4CiAgICAt PiBjcnRjX3d3X2NsYXNzX211dGV4L2NydGNfd3dfY2xhc3NfYWNxdWlyZQogICAgICAtPiAmY29u bmVjdG9yLT5tdXRleAoKSSBtZWFuLCBsb29rIGF0IHRoYXQgdGhpbmchIEl0J3MganVzdCBldmls ISEhIFRoaXMgZ3Jvc3MgdGhpbmcgZW5kcyB1cAptYWtpbmcgYW55IGNhbGxzIHRvIGRybV9jb25u ZWN0b3JfcmVnaXN0ZXIoKS9kcm1fY29ubmVjdG9yX3VucmVnaXN0ZXIoKQppbXBvc3NpYmxlIHdo ZW4gaG9sZGluZyBhbnkga2luZCBvZiBtb2Rlc2V0dGluZyBsb2NrLiBUaGlzIGlzIGFubm95aW5n CmJlY2F1c2UgaWRlYWxseSwgd2UgYWx3YXlzIHdhbnQgdG8gZW5zdXJlIHRoYXQKZHJtX2RwX21z dF9wb3J0LT5jb25uZWN0b3IgbmV2ZXIgY2hhbmdlcyB3aGVuIGRvaW5nIGFuIGF0b21pYyBjb21t aXQgb3IKY2hlY2sgdGhhdCB3b3VsZCBhZmZlY3QgdGhlIGF0b21pYyB0b3BvbG9neSBzdGF0ZSBz byB0aGF0IGl0IGNhbgpyZWxpYWJseSBhbmQgZWFzaWx5IGJlIHVzZWQgZnJvbSBmdXR1cmUgRFJN IERQIE1TVCBoZWxwZXJzIHRvIGFzc2lzdAp3aXRoIHRhc2tzIHN1Y2ggYXMgc2Nhbm5pbmcgdGhy b3VnaCB0aGUgY3VycmVudCBWQ1BJIGFsbG9jYXRpb25zIGFuZAphZGRpbmcgY29ubmVjdG9ycyB3 aGljaCBuZWVkIHRvIGhhdmUgdGhlaXIgYWxsb2NhdGlvbnMgdXBkYXRlZCBpbgpyZXNwb25zZSB0 byBhIGJhbmR3aWR0aCBjaGFuZ2Ugb3IgdGhlIGxpa2UuCgpCZWluZyBhYmxlIHRvIGhvbGQgJm1n ci0+YmFzZS5sb2NrIHRocm91Z2hvdXQgdGhlIGVudGlyZSBsaW5rIHByb2JlCnByb2Nlc3Mgd291 bGQgaGF2ZSBiZWVuIF9ncmVhdF8sIHNpbmNlIHdlIGNvdWxkIHByZXZlbnQgdXNlcnNwYWNlIGZy b20KZXZlciBzZWVpbmcgYW55IHN0YXRlcyBpbi1iZXR3ZWVuIGluZGl2aWR1YWwgcG9ydCBjaGFu Z2VzIGFuZCBhcyBhCnJlc3VsdCBsaWtlbHkgZW5kIHVwIHdpdGggYSBtdWNoIGZhc3RlciBwcm9i ZSBhbmQgbW9yZSBjb25zaXN0ZW50CnJlc3VsdHMgZnJvbSBzYWlkIHByb2Jlcy4gQnV0IHdpdGhv dXQgc29tZSByZXdvcmsgb2YgaG93IHdlIGhhbmRsZQpjb25uZWN0b3IgcHJvYmluZyBpbiBzeXNm cyBpdCdzIG5vdCBhdCBhbGwgY3VycmVudGx5IHBvc3NpYmxlLiBJbiB0aGUKZnV0dXJlLCBtYXli ZSB3ZSBjYW4gdHJ5IHVzaW5nIHRoZSBzeXNmcyBsb2NrcyB0byBwcm90ZWN0IHVwZGF0ZXMgdG8K Y29ubmVjdG9yIHByb2Jpbmcgc3RhdGUgYW5kIGZpeCB0aGlzIG1lc3MuCgpTbyBmb3Igbm93LCB0 byBwcm90ZWN0IGV2ZXJ5dGhpbmcgb3RoZXIgdGhhbiBwb3J0LT5jb25uZWN0b3IgdW5kZXIKJm1n ci0+YmFzZS5sb2NrIGFuZCBlbnN1cmUgdGhhdCB3ZSBzdGlsbCBoYXZlIHRoZSBndWFyYW50ZWUg dGhhdCBhdG9taWMKY2hlY2svY29tbWl0IGNvbnRleHRzIHdpbGwgbmV2ZXIgc2VlIHBvcnQtPmNv bm5lY3RvciBjaGFuZ2Ugd2UgdXNlIGEKc2lsbHkgdHJpY2suIFNlZTogcG9ydC0+Y29ubmVjdG9y IG9ubHkgbmVlZHMgdG8gY2hhbmdlIGluIG9yZGVyIHRvCmVuc3VyZSB0aGF0IGlucHV0IHBvcnRz IChzZWUgdGhlIE1TVCBzcGVjKSBuZXZlciBoYXZlIGEgZ2hvc3QgY29ubmVjdG9yCmFzc29jaWF0 ZWQgd2l0aCB0aGVtLiBCdXQsIHRoZXJlJ3Mgbm90aGluZyBzdG9wcGluZyB1cyBmcm9tIHNpbXBs eQp0aHJvd2luZyB0aGUgZW50aXJlIHBvcnQgb3V0IGFuZCBjcmVhdGluZyBhIG5ldyBvbmUgaW4g b3JkZXIgdG8gbWFpbnRhaW4KdGhhdCByZXF1aXJlbWVudCB3aGlsZSBzdGlsbCBrZWVwaW5nIHBv cnQtPmNvbm5lY3RvciBjb25zaXN0ZW50IGFjcm9zcwp0aGUgbGlmZXRpbWUgb2YgdGhlIHBvcnQg aW4gYXRvbWljIGNoZWNrL2NvbW1pdCBjb250ZXh0cy4gRm9yIGFsbAppbnRlbmRlZCBwdXJwb3Nl cyB0aGlzIHdvcmtzIGZpbmUsIGFzIHdlIHZhbGlkYXRlIHBvcnRzIGluIGFueSBjb250ZXh0cwp3 ZSBjYXJlIGFib3V0IGJlZm9yZSB1c2luZyB0aGVtIGFuZCBhcyBzdWNoIHdpbGwgZW5kIHVwIHJl cG9ydGluZyB0aGUKY29ubmVjdG9yIGFzIGRpc2Nvbm5lY3RlZCB1bnRpbCBpdCdzIHBvcnQncyBk ZXN0cnVjdGlvbiBmaW5hbGl6ZXMuIFNvLAp3ZSBqdXN0IGRvIHRoYXQgaW4gY2FzZXMgd2hlcmUg d2UgZGV0ZWN0IHBvcnQtPmlucHV0IGhhcyB0cmFuc2l0aW9uZWQKZnJvbSB0cnVlLT5mYWxzZS4g V2UgZG9uJ3QgbmVlZCB0byB3b3JyeSBhYm91dCB0aGUgb3RoZXIgZGlyZWN0aW9uLApzaW5jZSBh IHBvcnQgd2l0aG91dCBhIGNvbm5lY3RvciBpc24ndCB2aXNpYmxlIHRvIHVzZXJzcGFjZSBhbmQg YXMgc3VjaApkb2Vzbid0IG5lZWQgdG8gYmUgcHJvdGVjdGVkIGJ5ICZtZ3ItPmJhc2UubG9jayB1 bnRpbCB3ZSBmaW5pc2gKcmVnaXN0ZXJpbmcgYSBjb25uZWN0b3IgZm9yIGl0LgoKRm9yIHVwZGF0 aW5nIG1lbWJlcnMgb2YgZHJtX2RwX21zdF9wb3J0IG90aGVyIHRoYW4gcG9ydC0+Y29ubmVjdG9y LCB3ZQpzaW1wbHkgZ3JhYiAmbWdyLT5iYXNlLmxvY2sgaW4gZHJtX2RwX21zdF9saW5rX3Byb2Jl X3dvcmsoKSBmb3IgYWxyZWFkeQpyZWdpc3RlcmVkIHBvcnRzLCB1cGRhdGUgc2FpZCBtZW1iZXJz IGFuZCBkcm9wIHRoZSBsb2NrIGJlZm9yZQpwb3RlbnRpYWxseSByZWdpc3RlcmluZyBhIGNvbm5l Y3RvciBhbmQgcHJvYmluZyB0aGUgbGluayBhZGRyZXNzIG9mIGl0J3MKY2hpbGRyZW4uCgpGaW5h bGx5LCB3ZSBtb2RpZnkgZHJtX2RwX21zdF9kZXRlY3RfcG9ydCgpIHRvIHRha2UgYSBtb2Rlc2V0 dGluZyBsb2NrCmFjcXVpc2l0aW9uIGNvbnRleHQgaW4gb3JkZXIgdG8gYWNxdWlyZSAmbWdyLT5i YXNlLmxvY2sgdW5kZXIKJmNvbm5lY3Rpb25fbXV0ZXggYW5kIGNvbnZlcnQgYWxsIGl0J3MgdXNl cnMgb3ZlciB0byB1c2luZyB0aGUKLmRldGVjdF9jdHggcHJvYmUgaG9va3MuCgpXaXRoIHRoYXQs IHdlIGZpbmFsbHkgaGF2ZSB3ZWxsIGRlZmluZWQgbG9ja2luZy4KCkNoYW5nZXMgc2luY2UgdjQ6 CiogR2V0IHJpZCBvZiBwb3J0LT5tdXRleCwgc3RvcCB1c2luZyBjb25uZWN0aW9uX211dGV4IGFu ZCBqdXN0IHVzZSBvdXIgb3duCiAgbW9kZXNldHRpbmcgbG9jayAtIG1nci0+YmFzZS5sb2NrLiBB bHNvLCBhZGQgYSBwcm9iZV9sb2NrIHRoYXQgY29tZXMKICBiZWZvcmUgdGhpcyBwYXRjaC4KKiBK dXN0IHRocm93IG91dCBwb3J0cyB0aGF0IGdldCBjaGFuZ2VkIGZyb20gYW4gb3V0cHV0IHRvIGFu IGlucHV0LCBhbmQKICByZXBsYWNlIHRoZW0gd2l0aCBuZXcgcG9ydHMuIFRoaXMgbGV0cyB1cyBl bnN1cmUgdGhhdCBtb2Rlc2V0dGluZwogIGNvbnRleHRzIG5ldmVyIHNlZSBwb3J0LT5jb25uZWN0 b3IgZ28gZnJvbSBoYXZpbmcgYSBjb25uZWN0b3IgdG8gYmVpbmcKICBOVUxMLgoqIFdyaXRlIGFu IGV4dHJlbWVseSBkZXRhaWxlZCBleHBsYW5hdGlvbiBvZiB3aGF0IHByb2JsZW1zIHRoaXMgaXMK ICB0cnlpbmcgdG8gZml4LCBzaW5jZSB0aGVyZSdzIGEgX2xvdF8gb2YgY29udGV4dCBoZXJlIGFu ZCBJIGhvbmVzdGx5CiAgZm9yZ290IHNvbWUgb2YgaXQgbXlzZWxmIGEgY291cGxlIHRpbWVzLgoq IERvbid0IGdyYWIgbWdyLT5sb2NrIHdoZW4gcmVhZGluZyBwb3J0LT5tc3RiIGluCiAgZHJtX2Rw X21zdF9oYW5kbGVfbGlua19hZGRyZXNzX3BvcnQoKS4gSXQncyBub3QgbmVlZGVkLgoKQ2M6IEp1 c3RvbiBMaSA8anVzdG9uLmxpQGludGVsLmNvbT4KQ2M6IEltcmUgRGVhayA8aW1yZS5kZWFrQGlu dGVsLmNvbT4KQ2M6IFZpbGxlIFN5cmrDpGzDpCA8dmlsbGUuc3lyamFsYUBsaW51eC5pbnRlbC5j b20+CkNjOiBIYXJyeSBXZW50bGFuZCA8aHdlbnRsYW5AYW1kLmNvbT4KQ2M6IERhbmllbCBWZXR0 ZXIgPGRhbmllbC52ZXR0ZXJAZmZ3bGwuY2g+CkNjOiBTZWFuIFBhdWwgPHNlYW5AcG9vcmx5LnJ1 bj4KU2lnbmVkLW9mZi1ieTogTHl1ZGUgUGF1bCA8bHl1ZGVAcmVkaGF0LmNvbT4KLS0tCiAuLi4v ZGlzcGxheS9hbWRncHVfZG0vYW1kZ3B1X2RtX21zdF90eXBlcy5jICAgfCAgMjggKy0tCiBkcml2 ZXJzL2dwdS9kcm0vZHJtX2RwX21zdF90b3BvbG9neS5jICAgICAgICAgfCAyMzAgKysrKysrKysr KysrLS0tLS0tCiBkcml2ZXJzL2dwdS9kcm0vaTkxNS9kaXNwbGF5L2ludGVsX2RwX21zdC5jICAg fCAgMjggKystCiBkcml2ZXJzL2dwdS9kcm0vbm91dmVhdS9kaXNwbnY1MC9kaXNwLmMgICAgICAg fCAgMzIgKy0tCiBkcml2ZXJzL2dwdS9kcm0vcmFkZW9uL3JhZGVvbl9kcF9tc3QuYyAgICAgICAg fCAgMjQgKy0KIGluY2x1ZGUvZHJtL2RybV9kcF9tc3RfaGVscGVyLmggICAgICAgICAgICAgICB8 ICAzOCArKy0KIDYgZmlsZXMgY2hhbmdlZCwgMjQwIGluc2VydGlvbnMoKyksIDE0MCBkZWxldGlv bnMoLSkKCmRpZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9kcm0vYW1kL2Rpc3BsYXkvYW1kZ3B1X2Rt L2FtZGdwdV9kbV9tc3RfdHlwZXMuYyBiL2RyaXZlcnMvZ3B1L2RybS9hbWQvZGlzcGxheS9hbWRn cHVfZG0vYW1kZ3B1X2RtX21zdF90eXBlcy5jCmluZGV4IDVlYzE0ZWZkNGQ4Yy4uZjgyMTRhY2Y3 MGIzIDEwMDY0NAotLS0gYS9kcml2ZXJzL2dwdS9kcm0vYW1kL2Rpc3BsYXkvYW1kZ3B1X2RtL2Ft ZGdwdV9kbV9tc3RfdHlwZXMuYworKysgYi9kcml2ZXJzL2dwdS9kcm0vYW1kL2Rpc3BsYXkvYW1k Z3B1X2RtL2FtZGdwdV9kbV9tc3RfdHlwZXMuYwpAQCAtMTIzLDIxICsxMjMsNiBAQCBzdGF0aWMg c3NpemVfdCBkbV9kcF9hdXhfdHJhbnNmZXIoc3RydWN0IGRybV9kcF9hdXggKmF1eCwKIAlyZXR1 cm4gcmVzdWx0OwogfQogCi1zdGF0aWMgZW51bSBkcm1fY29ubmVjdG9yX3N0YXR1cwotZG1fZHBf bXN0X2RldGVjdChzdHJ1Y3QgZHJtX2Nvbm5lY3RvciAqY29ubmVjdG9yLCBib29sIGZvcmNlKQot ewotCXN0cnVjdCBhbWRncHVfZG1fY29ubmVjdG9yICphY29ubmVjdG9yID0gdG9fYW1kZ3B1X2Rt X2Nvbm5lY3Rvcihjb25uZWN0b3IpOwotCXN0cnVjdCBhbWRncHVfZG1fY29ubmVjdG9yICptYXN0 ZXIgPSBhY29ubmVjdG9yLT5tc3RfcG9ydDsKLQotCWVudW0gZHJtX2Nvbm5lY3Rvcl9zdGF0dXMg c3RhdHVzID0KLQkJZHJtX2RwX21zdF9kZXRlY3RfcG9ydCgKLQkJCWNvbm5lY3RvciwKLQkJCSZt YXN0ZXItPm1zdF9tZ3IsCi0JCQlhY29ubmVjdG9yLT5wb3J0KTsKLQotCXJldHVybiBzdGF0dXM7 Ci19Ci0KIHN0YXRpYyB2b2lkCiBkbV9kcF9tc3RfY29ubmVjdG9yX2Rlc3Ryb3koc3RydWN0IGRy bV9jb25uZWN0b3IgKmNvbm5lY3RvcikKIHsKQEAgLTE3Nyw3ICsxNjIsNiBAQCBhbWRncHVfZG1f bXN0X2Nvbm5lY3Rvcl9lYXJseV91bnJlZ2lzdGVyKHN0cnVjdCBkcm1fY29ubmVjdG9yICpjb25u ZWN0b3IpCiB9CiAKIHN0YXRpYyBjb25zdCBzdHJ1Y3QgZHJtX2Nvbm5lY3Rvcl9mdW5jcyBkbV9k cF9tc3RfY29ubmVjdG9yX2Z1bmNzID0gewotCS5kZXRlY3QgPSBkbV9kcF9tc3RfZGV0ZWN0LAog CS5maWxsX21vZGVzID0gZHJtX2hlbHBlcl9wcm9iZV9zaW5nbGVfY29ubmVjdG9yX21vZGVzLAog CS5kZXN0cm95ID0gZG1fZHBfbXN0X2Nvbm5lY3Rvcl9kZXN0cm95LAogCS5yZXNldCA9IGFtZGdw dV9kbV9jb25uZWN0b3JfZnVuY3NfcmVzZXQsCkBAIC0yNTIsMTAgKzIzNiwyMiBAQCBzdGF0aWMg c3RydWN0IGRybV9lbmNvZGVyICpkbV9tc3RfYmVzdF9lbmNvZGVyKHN0cnVjdCBkcm1fY29ubmVj dG9yICpjb25uZWN0b3IpCiAJcmV0dXJuICZhbWRncHVfZG1fY29ubmVjdG9yLT5tc3RfZW5jb2Rl ci0+YmFzZTsKIH0KIAorc3RhdGljIGludAorZG1fZHBfbXN0X2RldGVjdChzdHJ1Y3QgZHJtX2Nv bm5lY3RvciAqY29ubmVjdG9yLAorCQkgc3RydWN0IGRybV9tb2Rlc2V0X2FjcXVpcmVfY3R4ICpj dHgsIGJvb2wgZm9yY2UpCit7CisJc3RydWN0IGFtZGdwdV9kbV9jb25uZWN0b3IgKmFjb25uZWN0 b3IgPSB0b19hbWRncHVfZG1fY29ubmVjdG9yKGNvbm5lY3Rvcik7CisJc3RydWN0IGFtZGdwdV9k bV9jb25uZWN0b3IgKm1hc3RlciA9IGFjb25uZWN0b3ItPm1zdF9wb3J0OworCisJcmV0dXJuIGRy bV9kcF9tc3RfZGV0ZWN0X3BvcnQoY29ubmVjdG9yLCBjdHgsICZtYXN0ZXItPm1zdF9tZ3IsCisJ CQkJICAgICAgYWNvbm5lY3Rvci0+cG9ydCk7Cit9CisKIHN0YXRpYyBjb25zdCBzdHJ1Y3QgZHJt X2Nvbm5lY3Rvcl9oZWxwZXJfZnVuY3MgZG1fZHBfbXN0X2Nvbm5lY3Rvcl9oZWxwZXJfZnVuY3Mg PSB7CiAJLmdldF9tb2RlcyA9IGRtX2RwX21zdF9nZXRfbW9kZXMsCiAJLm1vZGVfdmFsaWQgPSBh bWRncHVfZG1fY29ubmVjdG9yX21vZGVfdmFsaWQsCiAJLmJlc3RfZW5jb2RlciA9IGRtX21zdF9i ZXN0X2VuY29kZXIsCisJLmRldGVjdF9jdHggPSBkbV9kcF9tc3RfZGV0ZWN0LAogfTsKIAogc3Rh dGljIHZvaWQgYW1kZ3B1X2RtX2VuY29kZXJfZGVzdHJveShzdHJ1Y3QgZHJtX2VuY29kZXIgKmVu Y29kZXIpCmRpZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9kcm0vZHJtX2RwX21zdF90b3BvbG9neS5j IGIvZHJpdmVycy9ncHUvZHJtL2RybV9kcF9tc3RfdG9wb2xvZ3kuYwppbmRleCAxMWQ4NDJmMGJm ZjUuLjdiZjRkYjkxZmY5MCAxMDA2NDQKLS0tIGEvZHJpdmVycy9ncHUvZHJtL2RybV9kcF9tc3Rf dG9wb2xvZ3kuYworKysgYi9kcml2ZXJzL2dwdS9kcm0vZHJtX2RwX21zdF90b3BvbG9neS5jCkBA IC0xOTA1LDYgKzE5MDUsNzggQEAgdm9pZCBkcm1fZHBfbXN0X2Nvbm5lY3Rvcl9lYXJseV91bnJl Z2lzdGVyKHN0cnVjdCBkcm1fY29ubmVjdG9yICpjb25uZWN0b3IsCiB9CiBFWFBPUlRfU1lNQk9M KGRybV9kcF9tc3RfY29ubmVjdG9yX2Vhcmx5X3VucmVnaXN0ZXIpOwogCitzdGF0aWMgdm9pZAor ZHJtX2RwX21zdF9wb3J0X2FkZF9jb25uZWN0b3Ioc3RydWN0IGRybV9kcF9tc3RfYnJhbmNoICpt c3RiLAorCQkJICAgICAgc3RydWN0IGRybV9kcF9tc3RfcG9ydCAqcG9ydCkKK3sKKwlzdHJ1Y3Qg ZHJtX2RwX21zdF90b3BvbG9neV9tZ3IgKm1nciA9IHBvcnQtPm1ncjsKKwljaGFyIHByb3BwYXRo WzI1NV07CisJaW50IHJldDsKKworCWJ1aWxkX21zdF9wcm9wX3BhdGgobXN0YiwgcG9ydC0+cG9y dF9udW0sIHByb3BwYXRoLCBzaXplb2YocHJvcHBhdGgpKTsKKwlwb3J0LT5jb25uZWN0b3IgPSBt Z3ItPmNicy0+YWRkX2Nvbm5lY3RvcihtZ3IsIHBvcnQsIHByb3BwYXRoKTsKKwlpZiAoIXBvcnQt PmNvbm5lY3RvcikgeworCQlyZXQgPSAtRU5PTUVNOworCQlnb3RvIGVycm9yOworCX0KKworCWlm ICgocG9ydC0+cGR0ID09IERQX1BFRVJfREVWSUNFX0RQX0xFR0FDWV9DT05WIHx8CisJICAgICBw b3J0LT5wZHQgPT0gRFBfUEVFUl9ERVZJQ0VfU1NUX1NJTkspICYmCisJICAgIHBvcnQtPnBvcnRf bnVtID49IERQX01TVF9MT0dJQ0FMX1BPUlRfMCkgeworCQlwb3J0LT5jYWNoZWRfZWRpZCA9IGRy bV9nZXRfZWRpZChwb3J0LT5jb25uZWN0b3IsCisJCQkJCQkgJnBvcnQtPmF1eC5kZGMpOworCQlk cm1fY29ubmVjdG9yX3NldF90aWxlX3Byb3BlcnR5KHBvcnQtPmNvbm5lY3Rvcik7CisJfQorCisJ bWdyLT5jYnMtPnJlZ2lzdGVyX2Nvbm5lY3Rvcihwb3J0LT5jb25uZWN0b3IpOworCXJldHVybjsK KworZXJyb3I6CisJRFJNX0VSUk9SKCJGYWlsZWQgdG8gY3JlYXRlIGNvbm5lY3RvciBmb3IgcG9y dCAlcDogJWRcbiIsIHBvcnQsIHJldCk7Cit9CisKKy8qCisgKiBEcm9wIGEgdG9wb2xvZ3kgcmVm ZXJlbmNlLCBhbmQgdW5saW5rIHRoZSBwb3J0IGZyb20gdGhlIGluLW1lbW9yeSB0b3BvbG9neQor ICogbGF5b3V0CisgKi8KK3N0YXRpYyB2b2lkCitkcm1fZHBfbXN0X3RvcG9sb2d5X3VubGlua19w b3J0KHN0cnVjdCBkcm1fZHBfbXN0X3RvcG9sb2d5X21nciAqbWdyLAorCQkJCXN0cnVjdCBkcm1f ZHBfbXN0X3BvcnQgKnBvcnQpCit7CisJbXV0ZXhfbG9jaygmbWdyLT5sb2NrKTsKKwlsaXN0X2Rl bCgmcG9ydC0+bmV4dCk7CisJbXV0ZXhfdW5sb2NrKCZtZ3ItPmxvY2spOworCWRybV9kcF9tc3Rf dG9wb2xvZ3lfcHV0X3BvcnQocG9ydCk7Cit9CisKK3N0YXRpYyBzdHJ1Y3QgZHJtX2RwX21zdF9w b3J0ICoKK2RybV9kcF9tc3RfYWRkX3BvcnQoc3RydWN0IGRybV9kZXZpY2UgKmRldiwKKwkJICAg IHN0cnVjdCBkcm1fZHBfbXN0X3RvcG9sb2d5X21nciAqbWdyLAorCQkgICAgc3RydWN0IGRybV9k cF9tc3RfYnJhbmNoICptc3RiLCB1OCBwb3J0X251bWJlcikKK3sKKwlzdHJ1Y3QgZHJtX2RwX21z dF9wb3J0ICpwb3J0ID0ga3phbGxvYyhzaXplb2YoKnBvcnQpLCBHRlBfS0VSTkVMKTsKKworCWlm ICghcG9ydCkKKwkJcmV0dXJuIE5VTEw7CisKKwlrcmVmX2luaXQoJnBvcnQtPnRvcG9sb2d5X2ty ZWYpOworCWtyZWZfaW5pdCgmcG9ydC0+bWFsbG9jX2tyZWYpOworCXBvcnQtPnBhcmVudCA9IG1z dGI7CisJcG9ydC0+cG9ydF9udW0gPSBwb3J0X251bWJlcjsKKwlwb3J0LT5tZ3IgPSBtZ3I7CisJ cG9ydC0+YXV4Lm5hbWUgPSAiRFBNU1QiOworCXBvcnQtPmF1eC5kZXYgPSBkZXYtPmRldjsKKwlw b3J0LT5hdXguaXNfcmVtb3RlID0gdHJ1ZTsKKworCS8qCisJICogTWFrZSBzdXJlIHRoZSBtZW1v cnkgYWxsb2NhdGlvbiBmb3Igb3VyIHBhcmVudCBicmFuY2ggc3RheXMKKwkgKiBhcm91bmQgdW50 aWwgb3VyIG93biBtZW1vcnkgYWxsb2NhdGlvbiBpcyByZWxlYXNlZAorCSAqLworCWRybV9kcF9t c3RfZ2V0X21zdGJfbWFsbG9jKG1zdGIpOworCisJcmV0dXJuIHBvcnQ7Cit9CisKIHN0YXRpYyB2 b2lkCiBkcm1fZHBfbXN0X2hhbmRsZV9saW5rX2FkZHJlc3NfcG9ydChzdHJ1Y3QgZHJtX2RwX21z dF9icmFuY2ggKm1zdGIsCiAJCQkJICAgIHN0cnVjdCBkcm1fZGV2aWNlICpkZXYsCkBAIC0xOTEy LDM1ICsxOTg0LDQwIEBAIGRybV9kcF9tc3RfaGFuZGxlX2xpbmtfYWRkcmVzc19wb3J0KHN0cnVj dCBkcm1fZHBfbXN0X2JyYW5jaCAqbXN0YiwKIHsKIAlzdHJ1Y3QgZHJtX2RwX21zdF90b3BvbG9n eV9tZ3IgKm1nciA9IG1zdGItPm1ncjsKIAlzdHJ1Y3QgZHJtX2RwX21zdF9wb3J0ICpwb3J0Owot CWJvb2wgY3JlYXRlZCA9IGZhbHNlOwotCWludCBvbGRfZGRwcyA9IDA7CisJaW50IG9sZF9kZHBz ID0gMCwgcmV0OworCXU4IG5ld19wZHQgPSBEUF9QRUVSX0RFVklDRV9OT05FOworCWJvb2wgY3Jl YXRlZCA9IGZhbHNlLCBzZW5kX2xpbmtfYWRkciA9IGZhbHNlOwogCiAJcG9ydCA9IGRybV9kcF9n ZXRfcG9ydChtc3RiLCBwb3J0X21zZy0+cG9ydF9udW1iZXIpOwogCWlmICghcG9ydCkgewotCQlw b3J0ID0ga3phbGxvYyhzaXplb2YoKnBvcnQpLCBHRlBfS0VSTkVMKTsKKwkJcG9ydCA9IGRybV9k cF9tc3RfYWRkX3BvcnQoZGV2LCBtZ3IsIG1zdGIsCisJCQkJCSAgIHBvcnRfbXNnLT5wb3J0X251 bWJlcik7CiAJCWlmICghcG9ydCkKIAkJCXJldHVybjsKLQkJa3JlZl9pbml0KCZwb3J0LT50b3Bv bG9neV9rcmVmKTsKLQkJa3JlZl9pbml0KCZwb3J0LT5tYWxsb2Nfa3JlZik7Ci0JCXBvcnQtPnBh cmVudCA9IG1zdGI7Ci0JCXBvcnQtPnBvcnRfbnVtID0gcG9ydF9tc2ctPnBvcnRfbnVtYmVyOwot CQlwb3J0LT5tZ3IgPSBtZ3I7Ci0JCXBvcnQtPmF1eC5uYW1lID0gIkRQTVNUIjsKLQkJcG9ydC0+ YXV4LmRldiA9IGRldi0+ZGV2OwotCQlwb3J0LT5hdXguaXNfcmVtb3RlID0gdHJ1ZTsKLQotCQkv KgotCQkgKiBNYWtlIHN1cmUgdGhlIG1lbW9yeSBhbGxvY2F0aW9uIGZvciBvdXIgcGFyZW50IGJy YW5jaCBzdGF5cwotCQkgKiBhcm91bmQgdW50aWwgb3VyIG93biBtZW1vcnkgYWxsb2NhdGlvbiBp cyByZWxlYXNlZAorCQljcmVhdGVkID0gdHJ1ZTsKKwl9IGVsc2UgaWYgKHBvcnRfbXNnLT5pbnB1 dF9wb3J0ICYmICFwb3J0LT5pbnB1dCAmJiBwb3J0LT5jb25uZWN0b3IpIHsKKwkJLyogRGVzdHJv eWluZyB0aGUgY29ubmVjdG9yIGlzIGltcG9zc2libGUgaW4gdGhpcyBjb250ZXh0LCBzbworCQkg KiByZXBsYWNlIHRoZSBwb3J0IHdpdGggYSBuZXcgb25lCiAJCSAqLwotCQlkcm1fZHBfbXN0X2dl dF9tc3RiX21hbGxvYyhtc3RiKTsKKwkJZHJtX2RwX21zdF90b3BvbG9neV91bmxpbmtfcG9ydCht Z3IsIHBvcnQpOworCQlkcm1fZHBfbXN0X3RvcG9sb2d5X3B1dF9wb3J0KHBvcnQpOwogCisJCXBv cnQgPSBkcm1fZHBfbXN0X2FkZF9wb3J0KGRldiwgbWdyLCBtc3RiLAorCQkJCQkgICBwb3J0X21z Zy0+cG9ydF9udW1iZXIpOworCQlpZiAoIXBvcnQpCisJCQlyZXR1cm47CiAJCWNyZWF0ZWQgPSB0 cnVlOwogCX0gZWxzZSB7CisJCS8qIExvY2tpbmcgaXMgb25seSBuZWVkZWQgd2hlbiB0aGUgcG9y dCBoYXMgYSBjb25uZWN0b3IKKwkJICogZXhwb3NlZCB0byB1c2Vyc3BhY2UKKwkJICovCisJCWRy bV9tb2Rlc2V0X2xvY2soJm1nci0+YmFzZS5sb2NrLCBOVUxMKTsKIAkJb2xkX2RkcHMgPSBwb3J0 LT5kZHBzOwogCX0KIAogCXBvcnQtPmlucHV0ID0gcG9ydF9tc2ctPmlucHV0X3BvcnQ7CisJaWYg KCFwb3J0LT5pbnB1dCkKKwkJbmV3X3BkdCA9IHBvcnRfbXNnLT5wZWVyX2RldmljZV90eXBlOwog CXBvcnQtPm1jcyA9IHBvcnRfbXNnLT5tY3M7CiAJcG9ydC0+ZGRwcyA9IHBvcnRfbXNnLT5kZHBz OwogCXBvcnQtPmxkcHMgPSBwb3J0X21zZy0+bGVnYWN5X2RldmljZV9wbHVnX3N0YXR1czsKQEAg LTE5NjgsNTkgKzIwNDUsMzkgQEAgZHJtX2RwX21zdF9oYW5kbGVfbGlua19hZGRyZXNzX3BvcnQo c3RydWN0IGRybV9kcF9tc3RfYnJhbmNoICptc3RiLAogCQl9CiAJfQogCi0JaWYgKCFwb3J0LT5p bnB1dCkgewotCQlpbnQgcmV0ID0gZHJtX2RwX3BvcnRfc2V0X3BkdChwb3J0LAotCQkJCQkgICAg ICBwb3J0X21zZy0+cGVlcl9kZXZpY2VfdHlwZSk7Ci0JCWlmIChyZXQgPT0gMSkgewotCQkJZHJt X2RwX3NlbmRfbGlua19hZGRyZXNzKG1nciwgcG9ydC0+bXN0Yik7Ci0JCX0gZWxzZSBpZiAocmV0 IDwgMCkgewotCQkJRFJNX0VSUk9SKCJGYWlsZWQgdG8gY2hhbmdlIFBEVCBvbiBwb3J0ICVwOiAl ZFxuIiwKLQkJCQkgIHBvcnQsIHJldCk7Ci0JCQlnb3RvIGZhaWw7Ci0JCX0KKwlyZXQgPSBkcm1f ZHBfcG9ydF9zZXRfcGR0KHBvcnQsIG5ld19wZHQpOworCWlmIChyZXQgPT0gMSkgeworCQlzZW5k X2xpbmtfYWRkciA9IHRydWU7CisJfSBlbHNlIGlmIChyZXQgPCAwKSB7CisJCURSTV9FUlJPUigi RmFpbGVkIHRvIGNoYW5nZSBQRFQgb24gcG9ydCAlcDogJWRcbiIsCisJCQkgIHBvcnQsIHJldCk7 CisJCWdvdG8gZmFpbDsKIAl9CiAKLQlpZiAoY3JlYXRlZCAmJiAhcG9ydC0+aW5wdXQpIHsKLQkJ Y2hhciBwcm9wcGF0aFsyNTVdOwotCi0JCWJ1aWxkX21zdF9wcm9wX3BhdGgobXN0YiwgcG9ydC0+ cG9ydF9udW0sIHByb3BwYXRoLAotCQkJCSAgICBzaXplb2YocHJvcHBhdGgpKTsKLQkJcG9ydC0+ Y29ubmVjdG9yID0gKCptZ3ItPmNicy0+YWRkX2Nvbm5lY3RvcikobWdyLCBwb3J0LAotCQkJCQkJ CSAgICAgcHJvcHBhdGgpOwotCQlpZiAoIXBvcnQtPmNvbm5lY3RvcikKLQkJCWdvdG8gZmFpbDsK LQotCQlpZiAoKHBvcnQtPnBkdCA9PSBEUF9QRUVSX0RFVklDRV9EUF9MRUdBQ1lfQ09OViB8fAot CQkgICAgIHBvcnQtPnBkdCA9PSBEUF9QRUVSX0RFVklDRV9TU1RfU0lOSykgJiYKLQkJICAgIHBv cnQtPnBvcnRfbnVtID49IERQX01TVF9MT0dJQ0FMX1BPUlRfMCkgewotCQkJcG9ydC0+Y2FjaGVk X2VkaWQgPSBkcm1fZ2V0X2VkaWQocG9ydC0+Y29ubmVjdG9yLAotCQkJCQkJCSAmcG9ydC0+YXV4 LmRkYyk7Ci0JCQlkcm1fY29ubmVjdG9yX3NldF90aWxlX3Byb3BlcnR5KHBvcnQtPmNvbm5lY3Rv cik7Ci0JCX0KKwlpZiAoIWNyZWF0ZWQpCisJCWRybV9tb2Rlc2V0X3VubG9jaygmbWdyLT5iYXNl LmxvY2spOworCWVsc2UgaWYgKCFwb3J0LT5jb25uZWN0b3IgJiYgIXBvcnQtPmlucHV0KQorCQlk cm1fZHBfbXN0X3BvcnRfYWRkX2Nvbm5lY3Rvcihtc3RiLCBwb3J0KTsKIAotCQkoKm1nci0+Y2Jz LT5yZWdpc3Rlcl9jb25uZWN0b3IpKHBvcnQtPmNvbm5lY3Rvcik7Ci0JfQorCWlmIChzZW5kX2xp bmtfYWRkciAmJiBwb3J0LT5tc3RiKQorCQlkcm1fZHBfc2VuZF9saW5rX2FkZHJlc3MobWdyLCBw b3J0LT5tc3RiKTsKIAogCS8qIHB1dCByZWZlcmVuY2UgdG8gdGhpcyBwb3J0ICovCiAJZHJtX2Rw X21zdF90b3BvbG9neV9wdXRfcG9ydChwb3J0KTsKIAlyZXR1cm47CiAKIGZhaWw6Ci0JLyogUmVt b3ZlIGl0IGZyb20gdGhlIHBvcnQgbGlzdCAqLwotCW11dGV4X2xvY2soJm1nci0+bG9jayk7Ci0J bGlzdF9kZWwoJnBvcnQtPm5leHQpOwotCW11dGV4X3VubG9jaygmbWdyLT5sb2NrKTsKLQotCS8q IERyb3AgdGhlIHBvcnQgbGlzdCByZWZlcmVuY2UgKi8KLQlkcm1fZHBfbXN0X3RvcG9sb2d5X3B1 dF9wb3J0KHBvcnQpOwotCS8qIEFuZCBub3cgZHJvcCBvdXIgcmVmZXJlbmNlICovCisJZHJtX2Rw X21zdF90b3BvbG9neV91bmxpbmtfcG9ydChtZ3IsIHBvcnQpOwogCWRybV9kcF9tc3RfdG9wb2xv Z3lfcHV0X3BvcnQocG9ydCk7CisJaWYgKCFjcmVhdGVkKQorCQlkcm1fbW9kZXNldF91bmxvY2so Jm1nci0+YmFzZS5sb2NrKTsKIH0KIAogc3RhdGljIHZvaWQKIGRybV9kcF9tc3RfaGFuZGxlX2Nv bm5fc3RhdChzdHJ1Y3QgZHJtX2RwX21zdF9icmFuY2ggKm1zdGIsCiAJCQkgICAgc3RydWN0IGRy bV9kcF9jb25uZWN0aW9uX3N0YXR1c19ub3RpZnkgKmNvbm5fc3RhdCkKIHsKKwlzdHJ1Y3QgZHJt X2RwX21zdF90b3BvbG9neV9tZ3IgKm1nciA9IG1zdGItPm1ncjsKIAlzdHJ1Y3QgZHJtX2RwX21z dF9wb3J0ICpwb3J0OwogCWludCBvbGRfZGRwczsKIAlib29sIGRvd29yayA9IGZhbHNlOwpAQCAt MjAyOSw2ICsyMDg2LDEwIEBAIGRybV9kcF9tc3RfaGFuZGxlX2Nvbm5fc3RhdChzdHJ1Y3QgZHJt X2RwX21zdF9icmFuY2ggKm1zdGIsCiAJaWYgKCFwb3J0KQogCQlyZXR1cm47CiAKKwkvKiBMb2Nr aW5nIGlzIG9ubHkgbmVlZGVkIGlmIHRoZSBwb3J0J3MgZXhwb3NlZCB0byB1c2Vyc3BhY2UgKi8K KwlpZiAocG9ydC0+Y29ubmVjdG9yKQorCQlkcm1fbW9kZXNldF9sb2NrKCZtZ3ItPmJhc2UubG9j aywgTlVMTCk7CisKIAlvbGRfZGRwcyA9IHBvcnQtPmRkcHM7CiAJcG9ydC0+bWNzID0gY29ubl9z dGF0LT5tZXNzYWdlX2NhcGFiaWxpdHlfc3RhdHVzOwogCXBvcnQtPmxkcHMgPSBjb25uX3N0YXQt PmxlZ2FjeV9kZXZpY2VfcGx1Z19zdGF0dXM7CkBAIC0yMDU0LDEwICsyMTE1LDEyIEBAIGRybV9k cF9tc3RfaGFuZGxlX2Nvbm5fc3RhdChzdHJ1Y3QgZHJtX2RwX21zdF9icmFuY2ggKm1zdGIsCiAJ CX0KIAl9CiAKKwlpZiAocG9ydC0+Y29ubmVjdG9yKQorCQlkcm1fbW9kZXNldF91bmxvY2soJm1n ci0+YmFzZS5sb2NrKTsKKwogCWRybV9kcF9tc3RfdG9wb2xvZ3lfcHV0X3BvcnQocG9ydCk7CiAJ aWYgKGRvd29yaykKIAkJcXVldWVfd29yayhzeXN0ZW1fbG9uZ193cSwgJm1zdGItPm1nci0+d29y ayk7Ci0KIH0KIAogc3RhdGljIHN0cnVjdCBkcm1fZHBfbXN0X2JyYW5jaCAqZHJtX2RwX2dldF9t c3RfYnJhbmNoX2RldmljZShzdHJ1Y3QgZHJtX2RwX21zdF90b3BvbG9neV9tZ3IgKm1nciwKQEAg LTIxNTcsOCArMjIyMCwxMSBAQCBzdGF0aWMgdm9pZCBkcm1fZHBfY2hlY2tfYW5kX3NlbmRfbGlu a19hZGRyZXNzKHN0cnVjdCBkcm1fZHBfbXN0X3RvcG9sb2d5X21nciAqbQogCQlpZiAocG9ydC0+ aW5wdXQgfHwgIXBvcnQtPmRkcHMpCiAJCQljb250aW51ZTsKIAotCQlpZiAoIXBvcnQtPmF2YWls YWJsZV9wYm4pCisJCWlmICghcG9ydC0+YXZhaWxhYmxlX3BibikgeworCQkJZHJtX21vZGVzZXRf bG9jaygmbWdyLT5iYXNlLmxvY2ssIE5VTEwpOwogCQkJZHJtX2RwX3NlbmRfZW51bV9wYXRoX3Jl c291cmNlcyhtZ3IsIG1zdGIsIHBvcnQpOworCQkJZHJtX21vZGVzZXRfdW5sb2NrKCZtZ3ItPmJh c2UubG9jayk7CisJCX0KIAogCQlpZiAocG9ydC0+bXN0YikKIAkJCW1zdGJfY2hpbGQgPSBkcm1f ZHBfbXN0X3RvcG9sb2d5X2dldF9tc3RiX3ZhbGlkYXRlZCgKQEAgLTIxODksMTEgKzIyNTUsMTYg QEAgc3RhdGljIHZvaWQgZHJtX2RwX21zdF9saW5rX3Byb2JlX3dvcmsoc3RydWN0IHdvcmtfc3Ry dWN0ICp3b3JrKQogCQkJbXN0YiA9IE5VTEw7CiAJfQogCW11dGV4X3VubG9jaygmbWdyLT5sb2Nr KTsKLQlpZiAobXN0YikgewotCQlkcm1fZHBfY2hlY2tfYW5kX3NlbmRfbGlua19hZGRyZXNzKG1n ciwgbXN0Yik7Ci0JCWRybV9kcF9tc3RfdG9wb2xvZ3lfcHV0X21zdGIobXN0Yik7CisJaWYgKCFt c3RiKSB7CisJCW11dGV4X3VubG9jaygmbWdyLT5wcm9iZV9sb2NrKTsKKwkJcmV0dXJuOwogCX0K KworCWRybV9kcF9jaGVja19hbmRfc2VuZF9saW5rX2FkZHJlc3MobWdyLCBtc3RiKTsKKwlkcm1f ZHBfbXN0X3RvcG9sb2d5X3B1dF9tc3RiKG1zdGIpOworCiAJbXV0ZXhfdW5sb2NrKCZtZ3ItPnBy b2JlX2xvY2spOworCWRybV9rbXNfaGVscGVyX2hvdHBsdWdfZXZlbnQoZGV2KTsKIH0KIAogc3Rh dGljIGJvb2wgZHJtX2RwX3ZhbGlkYXRlX2d1aWQoc3RydWN0IGRybV9kcF9tc3RfdG9wb2xvZ3lf bWdyICptZ3IsCkBAIC0yNDc4LDggKzI1NDksNiBAQCBzdGF0aWMgdm9pZCBkcm1fZHBfc2VuZF9s aW5rX2FkZHJlc3Moc3RydWN0IGRybV9kcF9tc3RfdG9wb2xvZ3lfbWdyICptZ3IsCiAJCWRybV9k cF9tc3RfaGFuZGxlX2xpbmtfYWRkcmVzc19wb3J0KG1zdGIsIG1nci0+ZGV2LAogCQkJCQkJICAg ICZyZXBseS0+cG9ydHNbaV0pOwogCi0JZHJtX2ttc19oZWxwZXJfaG90cGx1Z19ldmVudChtZ3It PmRldik7Ci0KIG91dDoKIAlpZiAocmV0IDw9IDApCiAJCW1zdGItPmxpbmtfYWRkcmVzc19zZW50 ID0gZmFsc2U7CkBAIC0zMjc0LDEzICszMzQzLDE0IEBAIHN0YXRpYyBpbnQgZHJtX2RwX21zdF9o YW5kbGVfZG93bl9yZXAoc3RydWN0IGRybV9kcF9tc3RfdG9wb2xvZ3lfbWdyICptZ3IpCiAJcmV0 dXJuIDA7CiB9CiAKLXN0YXRpYyBpbmxpbmUgdm9pZAorc3RhdGljIGlubGluZSBib29sCiBkcm1f ZHBfbXN0X3Byb2Nlc3NfdXBfcmVxKHN0cnVjdCBkcm1fZHBfbXN0X3RvcG9sb2d5X21nciAqbWdy LAogCQkJICBzdHJ1Y3QgZHJtX2RwX3BlbmRpbmdfdXBfcmVxICp1cF9yZXEpCiB7CiAJc3RydWN0 IGRybV9kcF9tc3RfYnJhbmNoICptc3RiID0gTlVMTDsKIAlzdHJ1Y3QgZHJtX2RwX3NpZGViYW5k X21zZ19yZXFfYm9keSAqbXNnID0gJnVwX3JlcS0+bXNnOwogCXN0cnVjdCBkcm1fZHBfc2lkZWJh bmRfbXNnX2hkciAqaGRyID0gJnVwX3JlcS0+aGRyOworCWJvb2wgaG90cGx1ZyA9IGZhbHNlOwog CiAJaWYgKGhkci0+YnJvYWRjYXN0KSB7CiAJCWNvbnN0IHU4ICpndWlkID0gTlVMTDsKQEAgLTMy OTgsMTYgKzMzNjgsMTcgQEAgZHJtX2RwX21zdF9wcm9jZXNzX3VwX3JlcShzdHJ1Y3QgZHJtX2Rw X21zdF90b3BvbG9neV9tZ3IgKm1nciwKIAlpZiAoIW1zdGIpIHsKIAkJRFJNX0RFQlVHX0tNUygi R290IE1TVCByZXBseSBmcm9tIHVua25vd24gZGV2aWNlICVkXG4iLAogCQkJICAgICAgaGRyLT5s Y3QpOwotCQlyZXR1cm47CisJCXJldHVybiBmYWxzZTsKIAl9CiAKIAkvKiBUT0RPOiBBZGQgbWlz c2luZyBoYW5kbGVyIGZvciBEUF9SRVNPVVJDRV9TVEFUVVNfTk9USUZZIGV2ZW50cyAqLwogCWlm IChtc2ctPnJlcV90eXBlID09IERQX0NPTk5FQ1RJT05fU1RBVFVTX05PVElGWSkgewogCQlkcm1f ZHBfbXN0X2hhbmRsZV9jb25uX3N0YXQobXN0YiwgJm1zZy0+dS5jb25uX3N0YXQpOwotCQlkcm1f a21zX2hlbHBlcl9ob3RwbHVnX2V2ZW50KG1nci0+ZGV2KTsKKwkJaG90cGx1ZyA9IHRydWU7CiAJ fQogCiAJZHJtX2RwX21zdF90b3BvbG9neV9wdXRfbXN0Yihtc3RiKTsKKwlyZXR1cm4gaG90cGx1 ZzsKIH0KIAogc3RhdGljIHZvaWQgZHJtX2RwX21zdF91cF9yZXFfd29yayhzdHJ1Y3Qgd29ya19z dHJ1Y3QgKndvcmspCkBAIC0zMzE2LDYgKzMzODcsNyBAQCBzdGF0aWMgdm9pZCBkcm1fZHBfbXN0 X3VwX3JlcV93b3JrKHN0cnVjdCB3b3JrX3N0cnVjdCAqd29yaykKIAkJY29udGFpbmVyX29mKHdv cmssIHN0cnVjdCBkcm1fZHBfbXN0X3RvcG9sb2d5X21nciwKIAkJCSAgICAgdXBfcmVxX3dvcmsp OwogCXN0cnVjdCBkcm1fZHBfcGVuZGluZ191cF9yZXEgKnVwX3JlcTsKKwlib29sIHNlbmRfaG90 cGx1ZyA9IGZhbHNlOwogCiAJbXV0ZXhfbG9jaygmbWdyLT5wcm9iZV9sb2NrKTsKIAl3aGlsZSAo dHJ1ZSkgewpAQCAtMzMzMCwxMCArMzQwMiwxMyBAQCBzdGF0aWMgdm9pZCBkcm1fZHBfbXN0X3Vw X3JlcV93b3JrKHN0cnVjdCB3b3JrX3N0cnVjdCAqd29yaykKIAkJaWYgKCF1cF9yZXEpCiAJCQli cmVhazsKIAotCQlkcm1fZHBfbXN0X3Byb2Nlc3NfdXBfcmVxKG1nciwgdXBfcmVxKTsKKwkJc2Vu ZF9ob3RwbHVnIHw9IGRybV9kcF9tc3RfcHJvY2Vzc191cF9yZXEobWdyLCB1cF9yZXEpOwogCQlr ZnJlZSh1cF9yZXEpOwogCX0KIAltdXRleF91bmxvY2soJm1nci0+cHJvYmVfbG9jayk7CisKKwlp ZiAoc2VuZF9ob3RwbHVnKQorCQlkcm1fa21zX2hlbHBlcl9ob3RwbHVnX2V2ZW50KG1nci0+ZGV2 KTsKIH0KIAogc3RhdGljIGludCBkcm1fZHBfbXN0X2hhbmRsZV91cF9yZXEoc3RydWN0IGRybV9k cF9tc3RfdG9wb2xvZ3lfbWdyICptZ3IpCkBAIC0zNDQxLDIyICszNTE2LDMxIEBAIEVYUE9SVF9T WU1CT0woZHJtX2RwX21zdF9ocGRfaXJxKTsKIC8qKgogICogZHJtX2RwX21zdF9kZXRlY3RfcG9y dCgpIC0gZ2V0IGNvbm5lY3Rpb24gc3RhdHVzIGZvciBhbiBNU1QgcG9ydAogICogQGNvbm5lY3Rv cjogRFJNIGNvbm5lY3RvciBmb3IgdGhpcyBwb3J0CisgKiBAY3R4OiBUaGUgYWNxdWlzaXRpb24g Y29udGV4dCB0byB1c2UgZm9yIGdyYWJiaW5nIGxvY2tzCiAgKiBAbWdyOiBtYW5hZ2VyIGZvciB0 aGlzIHBvcnQKLSAqIEBwb3J0OiB1bnZlcmlmaWVkIHBvaW50ZXIgdG8gYSBwb3J0CisgKiBAcG9y dDogcG9pbnRlciB0byBhIHBvcnQKICAqCi0gKiBUaGlzIHJldHVybnMgdGhlIGN1cnJlbnQgY29u bmVjdGlvbiBzdGF0ZSBmb3IgYSBwb3J0LiBJdCB2YWxpZGF0ZXMgdGhlCi0gKiBwb3J0IHBvaW50 ZXIgc3RpbGwgZXhpc3RzIHNvIHRoZSBjYWxsZXIgZG9lc24ndCByZXF1aXJlIGEgcmVmZXJlbmNl CisgKiBUaGlzIHJldHVybnMgdGhlIGN1cnJlbnQgY29ubmVjdGlvbiBzdGF0ZSBmb3IgYSBwb3J0 LgogICovCi1lbnVtIGRybV9jb25uZWN0b3Jfc3RhdHVzIGRybV9kcF9tc3RfZGV0ZWN0X3BvcnQo c3RydWN0IGRybV9jb25uZWN0b3IgKmNvbm5lY3RvciwKLQkJCQkJCSBzdHJ1Y3QgZHJtX2RwX21z dF90b3BvbG9neV9tZ3IgKm1nciwgc3RydWN0IGRybV9kcF9tc3RfcG9ydCAqcG9ydCkKK2ludAor ZHJtX2RwX21zdF9kZXRlY3RfcG9ydChzdHJ1Y3QgZHJtX2Nvbm5lY3RvciAqY29ubmVjdG9yLAor CQkgICAgICAgc3RydWN0IGRybV9tb2Rlc2V0X2FjcXVpcmVfY3R4ICpjdHgsCisJCSAgICAgICBz dHJ1Y3QgZHJtX2RwX21zdF90b3BvbG9neV9tZ3IgKm1nciwKKwkJICAgICAgIHN0cnVjdCBkcm1f ZHBfbXN0X3BvcnQgKnBvcnQpCiB7Ci0JZW51bSBkcm1fY29ubmVjdG9yX3N0YXR1cyBzdGF0dXMg PSBjb25uZWN0b3Jfc3RhdHVzX2Rpc2Nvbm5lY3RlZDsKKwlpbnQgcmV0OwogCiAJLyogd2UgbmVl ZCB0byBzZWFyY2ggZm9yIHRoZSBwb3J0IGluIHRoZSBtZ3IgaW4gY2FzZSBpdCdzIGdvbmUgKi8K IAlwb3J0ID0gZHJtX2RwX21zdF90b3BvbG9neV9nZXRfcG9ydF92YWxpZGF0ZWQobWdyLCBwb3J0 KTsKIAlpZiAoIXBvcnQpCiAJCXJldHVybiBjb25uZWN0b3Jfc3RhdHVzX2Rpc2Nvbm5lY3RlZDsK IAorCXJldCA9IGRybV9tb2Rlc2V0X2xvY2soJm1nci0+YmFzZS5sb2NrLCBjdHgpOworCWlmIChy ZXQpCisJCWdvdG8gb3V0OworCisJcmV0ID0gY29ubmVjdG9yX3N0YXR1c19kaXNjb25uZWN0ZWQ7 CisKIAlpZiAoIXBvcnQtPmRkcHMpCiAJCWdvdG8gb3V0OwogCkBAIC0zNDY2LDcgKzM1NTAsNyBA QCBlbnVtIGRybV9jb25uZWN0b3Jfc3RhdHVzIGRybV9kcF9tc3RfZGV0ZWN0X3BvcnQoc3RydWN0 IGRybV9jb25uZWN0b3IgKmNvbm5lY3RvcgogCQlicmVhazsKIAogCWNhc2UgRFBfUEVFUl9ERVZJ Q0VfU1NUX1NJTks6Ci0JCXN0YXR1cyA9IGNvbm5lY3Rvcl9zdGF0dXNfY29ubmVjdGVkOworCQly ZXQgPSBjb25uZWN0b3Jfc3RhdHVzX2Nvbm5lY3RlZDsKIAkJLyogZm9yIGxvZ2ljYWwgcG9ydHMg LSBjYWNoZSB0aGUgRURJRCAqLwogCQlpZiAocG9ydC0+cG9ydF9udW0gPj0gOCAmJiAhcG9ydC0+ Y2FjaGVkX2VkaWQpIHsKIAkJCXBvcnQtPmNhY2hlZF9lZGlkID0gZHJtX2dldF9lZGlkKGNvbm5l Y3RvciwgJnBvcnQtPmF1eC5kZGMpOwpAQCAtMzQ3NCwxMiArMzU1OCwxMiBAQCBlbnVtIGRybV9j b25uZWN0b3Jfc3RhdHVzIGRybV9kcF9tc3RfZGV0ZWN0X3BvcnQoc3RydWN0IGRybV9jb25uZWN0 b3IgKmNvbm5lY3RvcgogCQlicmVhazsKIAljYXNlIERQX1BFRVJfREVWSUNFX0RQX0xFR0FDWV9D T05WOgogCQlpZiAocG9ydC0+bGRwcykKLQkJCXN0YXR1cyA9IGNvbm5lY3Rvcl9zdGF0dXNfY29u bmVjdGVkOworCQkJcmV0ID0gY29ubmVjdG9yX3N0YXR1c19jb25uZWN0ZWQ7CiAJCWJyZWFrOwog CX0KIG91dDoKIAlkcm1fZHBfbXN0X3RvcG9sb2d5X3B1dF9wb3J0KHBvcnQpOwotCXJldHVybiBz dGF0dXM7CisJcmV0dXJuIHJldDsKIH0KIEVYUE9SVF9TWU1CT0woZHJtX2RwX21zdF9kZXRlY3Rf cG9ydCk7CiAKZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2Rpc3BsYXkvaW50ZWxf ZHBfbXN0LmMgYi9kcml2ZXJzL2dwdS9kcm0vaTkxNS9kaXNwbGF5L2ludGVsX2RwX21zdC5jCmlu ZGV4IGJiY2FiMjc2NDRkYy4uYTk5NjI4NDZhNTAzIDEwMDY0NAotLS0gYS9kcml2ZXJzL2dwdS9k cm0vaTkxNS9kaXNwbGF5L2ludGVsX2RwX21zdC5jCisrKyBiL2RyaXZlcnMvZ3B1L2RybS9pOTE1 L2Rpc3BsYXkvaW50ZWxfZHBfbXN0LmMKQEAgLTM5MSwyMCArMzkxLDcgQEAgc3RhdGljIGludCBp bnRlbF9kcF9tc3RfZ2V0X2RkY19tb2RlcyhzdHJ1Y3QgZHJtX2Nvbm5lY3RvciAqY29ubmVjdG9y KQogCXJldHVybiByZXQ7CiB9CiAKLXN0YXRpYyBlbnVtIGRybV9jb25uZWN0b3Jfc3RhdHVzCi1p bnRlbF9kcF9tc3RfZGV0ZWN0KHN0cnVjdCBkcm1fY29ubmVjdG9yICpjb25uZWN0b3IsIGJvb2wg Zm9yY2UpCi17Ci0Jc3RydWN0IGludGVsX2Nvbm5lY3RvciAqaW50ZWxfY29ubmVjdG9yID0gdG9f aW50ZWxfY29ubmVjdG9yKGNvbm5lY3Rvcik7Ci0Jc3RydWN0IGludGVsX2RwICppbnRlbF9kcCA9 IGludGVsX2Nvbm5lY3Rvci0+bXN0X3BvcnQ7Ci0KLQlpZiAoZHJtX2Nvbm5lY3Rvcl9pc191bnJl Z2lzdGVyZWQoY29ubmVjdG9yKSkKLQkJcmV0dXJuIGNvbm5lY3Rvcl9zdGF0dXNfZGlzY29ubmVj dGVkOwotCXJldHVybiBkcm1fZHBfbXN0X2RldGVjdF9wb3J0KGNvbm5lY3RvciwgJmludGVsX2Rw LT5tc3RfbWdyLAotCQkJCSAgICAgIGludGVsX2Nvbm5lY3Rvci0+cG9ydCk7Ci19Ci0KIHN0YXRp YyBjb25zdCBzdHJ1Y3QgZHJtX2Nvbm5lY3Rvcl9mdW5jcyBpbnRlbF9kcF9tc3RfY29ubmVjdG9y X2Z1bmNzID0gewotCS5kZXRlY3QgPSBpbnRlbF9kcF9tc3RfZGV0ZWN0LAogCS5maWxsX21vZGVz ID0gZHJtX2hlbHBlcl9wcm9iZV9zaW5nbGVfY29ubmVjdG9yX21vZGVzLAogCS5hdG9taWNfZ2V0 X3Byb3BlcnR5ID0gaW50ZWxfZGlnaXRhbF9jb25uZWN0b3JfYXRvbWljX2dldF9wcm9wZXJ0eSwK IAkuYXRvbWljX3NldF9wcm9wZXJ0eSA9IGludGVsX2RpZ2l0YWxfY29ubmVjdG9yX2F0b21pY19z ZXRfcHJvcGVydHksCkBAIC00NjUsMTEgKzQ1MiwyNiBAQCBzdGF0aWMgc3RydWN0IGRybV9lbmNv ZGVyICppbnRlbF9tc3RfYXRvbWljX2Jlc3RfZW5jb2RlcihzdHJ1Y3QgZHJtX2Nvbm5lY3RvciAq YwogCXJldHVybiAmaW50ZWxfZHAtPm1zdF9lbmNvZGVyc1tjcnRjLT5waXBlXS0+YmFzZS5iYXNl OwogfQogCitzdGF0aWMgaW50CitpbnRlbF9kcF9tc3RfZGV0ZWN0KHN0cnVjdCBkcm1fY29ubmVj dG9yICpjb25uZWN0b3IsCisJCSAgICBzdHJ1Y3QgZHJtX21vZGVzZXRfYWNxdWlyZV9jdHggKmN0 eCwgYm9vbCBmb3JjZSkKK3sKKwlzdHJ1Y3QgaW50ZWxfY29ubmVjdG9yICppbnRlbF9jb25uZWN0 b3IgPSB0b19pbnRlbF9jb25uZWN0b3IoY29ubmVjdG9yKTsKKwlzdHJ1Y3QgaW50ZWxfZHAgKmlu dGVsX2RwID0gaW50ZWxfY29ubmVjdG9yLT5tc3RfcG9ydDsKKworCWlmIChkcm1fY29ubmVjdG9y X2lzX3VucmVnaXN0ZXJlZChjb25uZWN0b3IpKQorCQlyZXR1cm4gY29ubmVjdG9yX3N0YXR1c19k aXNjb25uZWN0ZWQ7CisKKwlyZXR1cm4gZHJtX2RwX21zdF9kZXRlY3RfcG9ydChjb25uZWN0b3Is IGN0eCwgJmludGVsX2RwLT5tc3RfbWdyLAorCQkJCSAgICAgIGludGVsX2Nvbm5lY3Rvci0+cG9y dCk7Cit9CisKIHN0YXRpYyBjb25zdCBzdHJ1Y3QgZHJtX2Nvbm5lY3Rvcl9oZWxwZXJfZnVuY3Mg aW50ZWxfZHBfbXN0X2Nvbm5lY3Rvcl9oZWxwZXJfZnVuY3MgPSB7CiAJLmdldF9tb2RlcyA9IGlu dGVsX2RwX21zdF9nZXRfbW9kZXMsCiAJLm1vZGVfdmFsaWQgPSBpbnRlbF9kcF9tc3RfbW9kZV92 YWxpZCwKIAkuYXRvbWljX2Jlc3RfZW5jb2RlciA9IGludGVsX21zdF9hdG9taWNfYmVzdF9lbmNv ZGVyLAogCS5hdG9taWNfY2hlY2sgPSBpbnRlbF9kcF9tc3RfYXRvbWljX2NoZWNrLAorCS5kZXRl Y3RfY3R4ID0gaW50ZWxfZHBfbXN0X2RldGVjdCwKIH07CiAKIHN0YXRpYyB2b2lkIGludGVsX2Rw X21zdF9lbmNvZGVyX2Rlc3Ryb3koc3RydWN0IGRybV9lbmNvZGVyICplbmNvZGVyKQpkaWZmIC0t Z2l0IGEvZHJpdmVycy9ncHUvZHJtL25vdXZlYXUvZGlzcG52NTAvZGlzcC5jIGIvZHJpdmVycy9n cHUvZHJtL25vdXZlYXUvZGlzcG52NTAvZGlzcC5jCmluZGV4IGExMzkyNGFlMTk5Mi4uYTlkNmFh MTEwY2ZkIDEwMDY0NAotLS0gYS9kcml2ZXJzL2dwdS9kcm0vbm91dmVhdS9kaXNwbnY1MC9kaXNw LmMKKysrIGIvZHJpdmVycy9ncHUvZHJtL25vdXZlYXUvZGlzcG52NTAvZGlzcC5jCkBAIC05ODYs MjAgKzk4NiwxMSBAQCBudjUwX21zdGNfYXRvbWljX2NoZWNrKHN0cnVjdCBkcm1fY29ubmVjdG9y ICpjb25uZWN0b3IsCiAJcmV0dXJuIGRybV9kcF9hdG9taWNfcmVsZWFzZV92Y3BpX3Nsb3RzKHN0 YXRlLCBtZ3IsIG1zdGMtPnBvcnQpOwogfQogCi1zdGF0aWMgY29uc3Qgc3RydWN0IGRybV9jb25u ZWN0b3JfaGVscGVyX2Z1bmNzCi1udjUwX21zdGNfaGVscCA9IHsKLQkuZ2V0X21vZGVzID0gbnY1 MF9tc3RjX2dldF9tb2RlcywKLQkubW9kZV92YWxpZCA9IG52NTBfbXN0Y19tb2RlX3ZhbGlkLAot CS5iZXN0X2VuY29kZXIgPSBudjUwX21zdGNfYmVzdF9lbmNvZGVyLAotCS5hdG9taWNfYmVzdF9l bmNvZGVyID0gbnY1MF9tc3RjX2F0b21pY19iZXN0X2VuY29kZXIsCi0JLmF0b21pY19jaGVjayA9 IG52NTBfbXN0Y19hdG9taWNfY2hlY2ssCi19OwotCi1zdGF0aWMgZW51bSBkcm1fY29ubmVjdG9y X3N0YXR1cwotbnY1MF9tc3RjX2RldGVjdChzdHJ1Y3QgZHJtX2Nvbm5lY3RvciAqY29ubmVjdG9y LCBib29sIGZvcmNlKQorc3RhdGljIGludAorbnY1MF9tc3RjX2RldGVjdChzdHJ1Y3QgZHJtX2Nv bm5lY3RvciAqY29ubmVjdG9yLAorCQkgc3RydWN0IGRybV9tb2Rlc2V0X2FjcXVpcmVfY3R4ICpj dHgsIGJvb2wgZm9yY2UpCiB7CiAJc3RydWN0IG52NTBfbXN0YyAqbXN0YyA9IG52NTBfbXN0Yyhj b25uZWN0b3IpOwotCWVudW0gZHJtX2Nvbm5lY3Rvcl9zdGF0dXMgY29ubl9zdGF0dXM7CiAJaW50 IHJldDsKIAogCWlmIChkcm1fY29ubmVjdG9yX2lzX3VucmVnaXN0ZXJlZChjb25uZWN0b3IpKQpA QCAtMTAwOSwxNCArMTAwMCwyNCBAQCBudjUwX21zdGNfZGV0ZWN0KHN0cnVjdCBkcm1fY29ubmVj dG9yICpjb25uZWN0b3IsIGJvb2wgZm9yY2UpCiAJaWYgKHJldCA8IDAgJiYgcmV0ICE9IC1FQUND RVMpCiAJCXJldHVybiBjb25uZWN0b3Jfc3RhdHVzX2Rpc2Nvbm5lY3RlZDsKIAotCWNvbm5fc3Rh dHVzID0gZHJtX2RwX21zdF9kZXRlY3RfcG9ydChjb25uZWN0b3IsIG1zdGMtPnBvcnQtPm1nciwK LQkJCQkJICAgICBtc3RjLT5wb3J0KTsKKwlyZXQgPSBkcm1fZHBfbXN0X2RldGVjdF9wb3J0KGNv bm5lY3RvciwgY3R4LCBtc3RjLT5wb3J0LT5tZ3IsCisJCQkJICAgICBtc3RjLT5wb3J0KTsKIAog CXBtX3J1bnRpbWVfbWFya19sYXN0X2J1c3koY29ubmVjdG9yLT5kZXYtPmRldik7CiAJcG1fcnVu dGltZV9wdXRfYXV0b3N1c3BlbmQoY29ubmVjdG9yLT5kZXYtPmRldik7Ci0JcmV0dXJuIGNvbm5f c3RhdHVzOworCXJldHVybiByZXQ7CiB9CiAKK3N0YXRpYyBjb25zdCBzdHJ1Y3QgZHJtX2Nvbm5l Y3Rvcl9oZWxwZXJfZnVuY3MKK252NTBfbXN0Y19oZWxwID0geworCS5nZXRfbW9kZXMgPSBudjUw X21zdGNfZ2V0X21vZGVzLAorCS5tb2RlX3ZhbGlkID0gbnY1MF9tc3RjX21vZGVfdmFsaWQsCisJ LmJlc3RfZW5jb2RlciA9IG52NTBfbXN0Y19iZXN0X2VuY29kZXIsCisJLmF0b21pY19iZXN0X2Vu Y29kZXIgPSBudjUwX21zdGNfYXRvbWljX2Jlc3RfZW5jb2RlciwKKwkuYXRvbWljX2NoZWNrID0g bnY1MF9tc3RjX2F0b21pY19jaGVjaywKKwkuZGV0ZWN0X2N0eCA9IG52NTBfbXN0Y19kZXRlY3Qs Cit9OworCiBzdGF0aWMgdm9pZAogbnY1MF9tc3RjX2Rlc3Ryb3koc3RydWN0IGRybV9jb25uZWN0 b3IgKmNvbm5lY3RvcikKIHsKQEAgLTEwMzEsNyArMTAzMiw2IEBAIG52NTBfbXN0Y19kZXN0cm95 KHN0cnVjdCBkcm1fY29ubmVjdG9yICpjb25uZWN0b3IpCiBzdGF0aWMgY29uc3Qgc3RydWN0IGRy bV9jb25uZWN0b3JfZnVuY3MKIG52NTBfbXN0YyA9IHsKIAkucmVzZXQgPSBub3V2ZWF1X2Nvbm5f cmVzZXQsCi0JLmRldGVjdCA9IG52NTBfbXN0Y19kZXRlY3QsCiAJLmZpbGxfbW9kZXMgPSBkcm1f aGVscGVyX3Byb2JlX3NpbmdsZV9jb25uZWN0b3JfbW9kZXMsCiAJLmRlc3Ryb3kgPSBudjUwX21z dGNfZGVzdHJveSwKIAkuYXRvbWljX2R1cGxpY2F0ZV9zdGF0ZSA9IG5vdXZlYXVfY29ubl9hdG9t aWNfZHVwbGljYXRlX3N0YXRlLApkaWZmIC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJtL3JhZGVvbi9y YWRlb25fZHBfbXN0LmMgYi9kcml2ZXJzL2dwdS9kcm0vcmFkZW9uL3JhZGVvbl9kcF9tc3QuYwpp bmRleCAyOTk0ZjA3ZmJhZDkuLmVlMjhmNWIzNzg1ZSAxMDA2NDQKLS0tIGEvZHJpdmVycy9ncHUv ZHJtL3JhZGVvbi9yYWRlb25fZHBfbXN0LmMKKysrIGIvZHJpdmVycy9ncHUvZHJtL3JhZGVvbi9y YWRlb25fZHBfbXN0LmMKQEAgLTIzMywyMSArMjMzLDI2IEBAIGRybV9lbmNvZGVyICpyYWRlb25f bXN0X2Jlc3RfZW5jb2RlcihzdHJ1Y3QgZHJtX2Nvbm5lY3RvciAqY29ubmVjdG9yKQogCXJldHVy biAmcmFkZW9uX2Nvbm5lY3Rvci0+bXN0X2VuY29kZXItPmJhc2U7CiB9CiAKK3N0YXRpYyBpbnQK K3JhZGVvbl9kcF9tc3RfZGV0ZWN0KHN0cnVjdCBkcm1fY29ubmVjdG9yICpjb25uZWN0b3IsCisJ CSAgICAgc3RydWN0IGRybV9tb2Rlc2V0X2FjcXVpcmVfY3R4ICpjdHgsCisJCSAgICAgYm9vbCBm b3JjZSkKK3sKKwlzdHJ1Y3QgcmFkZW9uX2Nvbm5lY3RvciAqcmFkZW9uX2Nvbm5lY3RvciA9CisJ CXRvX3JhZGVvbl9jb25uZWN0b3IoY29ubmVjdG9yKTsKKwlzdHJ1Y3QgcmFkZW9uX2Nvbm5lY3Rv ciAqbWFzdGVyID0gcmFkZW9uX2Nvbm5lY3Rvci0+bXN0X3BvcnQ7CisKKwlyZXR1cm4gZHJtX2Rw X21zdF9kZXRlY3RfcG9ydChjb25uZWN0b3IsIGN0eCwgJm1hc3Rlci0+bXN0X21nciwKKwkJCQkg ICAgICByYWRlb25fY29ubmVjdG9yLT5wb3J0KTsKK30KKwogc3RhdGljIGNvbnN0IHN0cnVjdCBk cm1fY29ubmVjdG9yX2hlbHBlcl9mdW5jcyByYWRlb25fZHBfbXN0X2Nvbm5lY3Rvcl9oZWxwZXJf ZnVuY3MgPSB7CiAJLmdldF9tb2RlcyA9IHJhZGVvbl9kcF9tc3RfZ2V0X21vZGVzLAogCS5tb2Rl X3ZhbGlkID0gcmFkZW9uX2RwX21zdF9tb2RlX3ZhbGlkLAogCS5iZXN0X2VuY29kZXIgPSByYWRl b25fbXN0X2Jlc3RfZW5jb2RlciwKKwkuZGV0ZWN0X2N0eCA9IHJhZGVvbl9kcF9tc3RfZGV0ZWN0 LAogfTsKIAotc3RhdGljIGVudW0gZHJtX2Nvbm5lY3Rvcl9zdGF0dXMKLXJhZGVvbl9kcF9tc3Rf ZGV0ZWN0KHN0cnVjdCBkcm1fY29ubmVjdG9yICpjb25uZWN0b3IsIGJvb2wgZm9yY2UpCi17Ci0J c3RydWN0IHJhZGVvbl9jb25uZWN0b3IgKnJhZGVvbl9jb25uZWN0b3IgPSB0b19yYWRlb25fY29u bmVjdG9yKGNvbm5lY3Rvcik7Ci0Jc3RydWN0IHJhZGVvbl9jb25uZWN0b3IgKm1hc3RlciA9IHJh ZGVvbl9jb25uZWN0b3ItPm1zdF9wb3J0OwotCi0JcmV0dXJuIGRybV9kcF9tc3RfZGV0ZWN0X3Bv cnQoY29ubmVjdG9yLCAmbWFzdGVyLT5tc3RfbWdyLCByYWRlb25fY29ubmVjdG9yLT5wb3J0KTsK LX0KLQogc3RhdGljIHZvaWQKIHJhZGVvbl9kcF9tc3RfY29ubmVjdG9yX2Rlc3Ryb3koc3RydWN0 IGRybV9jb25uZWN0b3IgKmNvbm5lY3RvcikKIHsKQEAgLTI2Miw3ICsyNjcsNiBAQCByYWRlb25f ZHBfbXN0X2Nvbm5lY3Rvcl9kZXN0cm95KHN0cnVjdCBkcm1fY29ubmVjdG9yICpjb25uZWN0b3Ip CiAKIHN0YXRpYyBjb25zdCBzdHJ1Y3QgZHJtX2Nvbm5lY3Rvcl9mdW5jcyByYWRlb25fZHBfbXN0 X2Nvbm5lY3Rvcl9mdW5jcyA9IHsKIAkuZHBtcyA9IGRybV9oZWxwZXJfY29ubmVjdG9yX2RwbXMs Ci0JLmRldGVjdCA9IHJhZGVvbl9kcF9tc3RfZGV0ZWN0LAogCS5maWxsX21vZGVzID0gZHJtX2hl bHBlcl9wcm9iZV9zaW5nbGVfY29ubmVjdG9yX21vZGVzLAogCS5kZXN0cm95ID0gcmFkZW9uX2Rw X21zdF9jb25uZWN0b3JfZGVzdHJveSwKIH07CmRpZmYgLS1naXQgYS9pbmNsdWRlL2RybS9kcm1f ZHBfbXN0X2hlbHBlci5oIGIvaW5jbHVkZS9kcm0vZHJtX2RwX21zdF9oZWxwZXIuaAppbmRleCBi Y2NiNTUxNGUwZWYuLmZkMTQyZGI0MmNiMCAxMDA2NDQKLS0tIGEvaW5jbHVkZS9kcm0vZHJtX2Rw X21zdF9oZWxwZXIuaAorKysgYi9pbmNsdWRlL2RybS9kcm1fZHBfbXN0X2hlbHBlci5oCkBAIC00 NSwyMSArNDUsMzEgQEAgc3RydWN0IGRybV9kcF92Y3BpIHsKIC8qKgogICogc3RydWN0IGRybV9k cF9tc3RfcG9ydCAtIE1TVCBwb3J0CiAgKiBAcG9ydF9udW06IHBvcnQgbnVtYmVyCi0gKiBAaW5w dXQ6IGlmIHRoaXMgcG9ydCBpcyBhbiBpbnB1dCBwb3J0LgotICogQG1jczogbWVzc2FnZSBjYXBh YmlsaXR5IHN0YXR1cyAtIERQIDEuMiBzcGVjLgotICogQGRkcHM6IERpc3BsYXlQb3J0IERldmlj ZSBQbHVnIFN0YXR1cyAtIERQIDEuMgotICogQHBkdDogUGVlciBEZXZpY2UgVHlwZQotICogQGxk cHM6IExlZ2FjeSBEZXZpY2UgUGx1ZyBTdGF0dXMKLSAqIEBkcGNkX3JldjogRFBDRCByZXZpc2lv biBvZiBkZXZpY2Ugb24gdGhpcyBwb3J0Ci0gKiBAbnVtX3NkcF9zdHJlYW1zOiBOdW1iZXIgb2Yg c2ltdWx0YW5lb3VzIHN0cmVhbXMKLSAqIEBudW1fc2RwX3N0cmVhbV9zaW5rczogTnVtYmVyIG9m IHN0cmVhbSBzaW5rcwotICogQGF2YWlsYWJsZV9wYm46IEF2YWlsYWJsZSBiYW5kd2lkdGggZm9y IHRoaXMgcG9ydC4KKyAqIEBpbnB1dDogaWYgdGhpcyBwb3J0IGlzIGFuIGlucHV0IHBvcnQuIFBy b3RlY3RlZCBieQorICogJmRybV9kcF9tc3RfdG9wb2xvZ3lfbWdyLmJhc2UubG9jay4KKyAqIEBt Y3M6IG1lc3NhZ2UgY2FwYWJpbGl0eSBzdGF0dXMgLSBEUCAxLjIgc3BlYy4gUHJvdGVjdGVkIGJ5 CisgKiAmZHJtX2RwX21zdF90b3BvbG9neV9tZ3IuYmFzZS5sb2NrLgorICogQGRkcHM6IERpc3Bs YXlQb3J0IERldmljZSBQbHVnIFN0YXR1cyAtIERQIDEuMi4gUHJvdGVjdGVkIGJ5CisgKiAmZHJt X2RwX21zdF90b3BvbG9neV9tZ3IuYmFzZS5sb2NrLgorICogQHBkdDogUGVlciBEZXZpY2UgVHlw ZS4gUHJvdGVjdGVkIGJ5CisgKiAmZHJtX2RwX21zdF90b3BvbG9neV9tZ3IuYmFzZS5sb2NrLgor ICogQGxkcHM6IExlZ2FjeSBEZXZpY2UgUGx1ZyBTdGF0dXMuIFByb3RlY3RlZCBieQorICogJmRy bV9kcF9tc3RfdG9wb2xvZ3lfbWdyLmJhc2UubG9jay4KKyAqIEBkcGNkX3JldjogRFBDRCByZXZp c2lvbiBvZiBkZXZpY2Ugb24gdGhpcyBwb3J0LiBQcm90ZWN0ZWQgYnkKKyAqICZkcm1fZHBfbXN0 X3RvcG9sb2d5X21nci5iYXNlLmxvY2suCisgKiBAbnVtX3NkcF9zdHJlYW1zOiBOdW1iZXIgb2Yg c2ltdWx0YW5lb3VzIHN0cmVhbXMuIFByb3RlY3RlZCBieQorICogJmRybV9kcF9tc3RfdG9wb2xv Z3lfbWdyLmJhc2UubG9jay4KKyAqIEBudW1fc2RwX3N0cmVhbV9zaW5rczogTnVtYmVyIG9mIHN0 cmVhbSBzaW5rcy4gUHJvdGVjdGVkIGJ5CisgKiAmZHJtX2RwX21zdF90b3BvbG9neV9tZ3IuYmFz ZS5sb2NrLgorICogQGF2YWlsYWJsZV9wYm46IEF2YWlsYWJsZSBiYW5kd2lkdGggZm9yIHRoaXMg cG9ydC4gUHJvdGVjdGVkIGJ5CisgKiAmZHJtX2RwX21zdF90b3BvbG9neV9tZ3IuYmFzZS5sb2Nr LgogICogQG5leHQ6IGxpbmsgdG8gbmV4dCBwb3J0IG9uIHRoaXMgYnJhbmNoIGRldmljZQogICog QGF1eDogaTJjIGF1eCB0cmFuc3BvcnQgdG8gdGFsayB0byBkZXZpY2UgY29ubmVjdGVkIHRvIHRo aXMgcG9ydCwgcHJvdGVjdGVkCi0gKiBieSAmZHJtX2RwX21zdF90b3BvbG9neV9tZ3IubG9jawor ICogYnkgJmRybV9kcF9tc3RfdG9wb2xvZ3lfbWdyLmJhc2UubG9jay4KICAqIEBwYXJlbnQ6IGJy YW5jaCBkZXZpY2UgcGFyZW50IG9mIHRoaXMgcG9ydAogICogQHZjcGk6IFZpcnR1YWwgQ2hhbm5l bCBQYXlsb2FkIGluZm8gZm9yIHRoaXMgcG9ydC4KLSAqIEBjb25uZWN0b3I6IERSTSBjb25uZWN0 b3IgdGhpcyBwb3J0IGlzIGNvbm5lY3RlZCB0by4KKyAqIEBjb25uZWN0b3I6IERSTSBjb25uZWN0 b3IgdGhpcyBwb3J0IGlzIGNvbm5lY3RlZCB0by4gUHJvdGVjdGVkIGJ5CisgKiAmZHJtX2RwX21z dF90b3BvbG9neV9tZ3IuYmFzZS5sb2NrLgogICogQG1ncjogdG9wb2xvZ3kgbWFuYWdlciB0aGlz IHBvcnQgbGl2ZXMgdW5kZXIuCiAgKgogICogVGhpcyBzdHJ1Y3R1cmUgcmVwcmVzZW50cyBhbiBN U1QgcG9ydCBlbmRwb2ludCBvbiBhIGRldmljZSBzb21ld2hlcmUKQEAgLTY1Myw3ICs2NjMsMTEg QEAgaW50IGRybV9kcF9tc3RfdG9wb2xvZ3lfbWdyX3NldF9tc3Qoc3RydWN0IGRybV9kcF9tc3Rf dG9wb2xvZ3lfbWdyICptZ3IsIGJvb2wgbXMKIGludCBkcm1fZHBfbXN0X2hwZF9pcnEoc3RydWN0 IGRybV9kcF9tc3RfdG9wb2xvZ3lfbWdyICptZ3IsIHU4ICplc2ksIGJvb2wgKmhhbmRsZWQpOwog CiAKLWVudW0gZHJtX2Nvbm5lY3Rvcl9zdGF0dXMgZHJtX2RwX21zdF9kZXRlY3RfcG9ydChzdHJ1 Y3QgZHJtX2Nvbm5lY3RvciAqY29ubmVjdG9yLCBzdHJ1Y3QgZHJtX2RwX21zdF90b3BvbG9neV9t Z3IgKm1nciwgc3RydWN0IGRybV9kcF9tc3RfcG9ydCAqcG9ydCk7CitpbnQKK2RybV9kcF9tc3Rf ZGV0ZWN0X3BvcnQoc3RydWN0IGRybV9jb25uZWN0b3IgKmNvbm5lY3RvciwKKwkJICAgICAgIHN0 cnVjdCBkcm1fbW9kZXNldF9hY3F1aXJlX2N0eCAqY3R4LAorCQkgICAgICAgc3RydWN0IGRybV9k cF9tc3RfdG9wb2xvZ3lfbWdyICptZ3IsCisJCSAgICAgICBzdHJ1Y3QgZHJtX2RwX21zdF9wb3J0 ICpwb3J0KTsKIAogYm9vbCBkcm1fZHBfbXN0X3BvcnRfaGFzX2F1ZGlvKHN0cnVjdCBkcm1fZHBf bXN0X3RvcG9sb2d5X21nciAqbWdyLAogCQkJCQlzdHJ1Y3QgZHJtX2RwX21zdF9wb3J0ICpwb3J0 KTsKLS0gCjIuMjEuMAoKX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fX18KSW50ZWwtZ2Z4IG1haWxpbmcgbGlzdApJbnRlbC1nZnhAbGlzdHMuZnJlZWRlc2t0b3Au b3JnCmh0dHBzOi8vbGlzdHMuZnJlZWRlc2t0b3Aub3JnL21haWxtYW4vbGlzdGluZm8vaW50ZWwt Z2Z4 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.8 required=3.0 tests=DKIM_SIGNED,DKIM_VALID, DKIM_VALID_AU,HEADER_FROM_DIFFERENT_DOMAINS,INCLUDES_PATCH,MAILING_LIST_MULTI, SIGNED_OFF_BY,SPF_HELO_NONE,SPF_PASS,URIBL_BLOCKED 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 3BAF4CA9EAF for ; Tue, 22 Oct 2019 02:40:25 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [209.132.180.67]) by mail.kernel.org (Postfix) with ESMTP id E2BCC20882 for ; Tue, 22 Oct 2019 02:40:24 +0000 (UTC) Authentication-Results: mail.kernel.org; dkim=pass (1024-bit key) header.d=redhat.com header.i=@redhat.com header.b="bsBHCu9h" Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S2387439AbfJVCkX (ORCPT ); Mon, 21 Oct 2019 22:40:23 -0400 Received: from us-smtp-1.mimecast.com ([207.211.31.81]:54547 "EHLO us-smtp-delivery-1.mimecast.com" rhost-flags-OK-OK-OK-FAIL) by vger.kernel.org with ESMTP id S1730084AbfJVCkX (ORCPT ); Mon, 21 Oct 2019 22:40:23 -0400 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=redhat.com; s=mimecast20190719; t=1571712020; 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=qjLVdEfmhVRsO8dIKQ/T0VmakBgrtkjHw3CdbfENGsI=; b=bsBHCu9heVqjVe0MX2sh/iHDh1oy7d5fJf7SHqVqpK/HuMzHhd20IYb7Fh6TG6Xi4nEJNW 1IZfrTAanPgTqkbi8m8QgEhrvban+liv2tcx223YlptnncqxuKBbpUB3WLO8WdIZYJ3mBt 8KplV1Hr/37F7YH4hAIuiMa0u75COLo= 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-41-TfzmRSTcNUew1IxySKIV_Q-1; Mon, 21 Oct 2019 22:40:16 -0400 Received: from smtp.corp.redhat.com (int-mx01.intmail.prod.int.phx2.redhat.com [10.5.11.11]) (using TLSv1.2 with cipher AECDH-AES256-SHA (256/256 bits)) (No client certificate requested) by mimecast-mx01.redhat.com (Postfix) with ESMTPS id 3A3DC1005500; Tue, 22 Oct 2019 02:40:13 +0000 (UTC) Received: from malachite.redhat.com (ovpn-120-98.rdu2.redhat.com [10.10.120.98]) by smtp.corp.redhat.com (Postfix) with ESMTP id 61E766012D; Tue, 22 Oct 2019 02:39:38 +0000 (UTC) From: Lyude Paul To: dri-devel@lists.freedesktop.org, amd-gfx@lists.freedesktop.org, nouveau@lists.freedesktop.org, intel-gfx@lists.freedesktop.org Cc: Juston Li , Imre Deak , =?UTF-8?q?Ville=20Syrj=C3=A4l=C3=A4?= , Harry Wentland , Daniel Vetter , Sean Paul , Harry Wentland , Leo Li , Alex Deucher , =?UTF-8?q?Christian=20K=C3=B6nig?= , "David (ChunMing) Zhou" , David Airlie , Daniel Vetter , Maarten Lankhorst , Maxime Ripard , Jani Nikula , Joonas Lahtinen , Rodrigo Vivi , Ben Skeggs , "Jerry (Fangzhi) Zuo" , Nicholas Kazlauskas , =?UTF-8?q?Mathias=20Fr=C3=B6hlich?= , Thomas Lim , David Francis , Chris Wilson , =?UTF-8?q?Jos=C3=A9=20Roberto=20de=20Souza?= , Sam Ravnborg , Laurent Pinchart , linux-kernel@vger.kernel.org Subject: [PATCH v5 06/14] drm/dp_mst: Protect drm_dp_mst_port members with locking Date: Mon, 21 Oct 2019 22:36:01 -0400 Message-Id: <20191022023641.8026-7-lyude@redhat.com> In-Reply-To: <20191022023641.8026-1-lyude@redhat.com> References: <20191022023641.8026-1-lyude@redhat.com> MIME-Version: 1.0 X-Scanned-By: MIMEDefang 2.79 on 10.5.11.11 X-MC-Unique: TfzmRSTcNUew1IxySKIV_Q-1 X-Mimecast-Spam-Score: 0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: quoted-printable Sender: linux-kernel-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org This is a complicated one. Essentially, there's currently a problem in the = MST core that hasn't really caused any issues that we're aware of (emphasis on = "that we're aware of"): locking. When we go through and probe the link addresses and path resources in a topology, we hold no locks when updating ports with said information. The members I'm referring to in particular are: - ldps - ddps - mcs - pdt - dpcd_rev - num_sdp_streams - num_sdp_stream_sinks - available_pbn - input - connector Now that we're handling UP requests asynchronously and will be using some o= f the struct members mentioned above in atomic modesetting in the future for features such as PBN validation, this is going to become a lot more importa= nt. As well, the next few commits that prepare us for and introduce suspend/res= ume reprobing will also need clear locking in order to prevent from additional racing hilarities that we never could have hit in the past. So, let's solve this issue by using &mgr->base.lock, the modesetting lock which currently only protects &mgr->base.state. This works perfectly because it allows us to avoid blocking connection_mutex unnecessarily, and we can grab this in connector detection paths since it's a ww mutex. We start by having drm_dp_mst_handle_up_req() hold this when updating ports. For drm_dp_mst_handle_link_address_port() things are a bit more complicated. As I've learned the hard way, we can grab &mgr->lock.base for everything except for port->connector. See, our normal driver probing paths end up generating this rather obvious lockdep chain: &drm->mode_config.mutex -> crtc_ww_class_mutex/crtc_ww_class_acquire -> &connector->mutex However, sysfs grabs &drm->mode_config.mutex in order to protect itself from connector state changing under it. Because this entails grabbing kn->count, e.g. the lock that the kernel provides for protecting sysfs contexts, we end up grabbing kn->count followed by &drm->mode_config.mutex. This ends up creating an extremely rude chain: &kn->count -> &drm->mode_config.mutex -> crtc_ww_class_mutex/crtc_ww_class_acquire -> &connector->mutex I mean, look at that thing! It's just evil!!! This gross thing ends up making any calls to drm_connector_register()/drm_connector_unregister() impossible when holding any kind of modesetting lock. This is annoying because ideally, we always want to ensure that drm_dp_mst_port->connector never changes when doing an atomic commit or check that would affect the atomic topology state so that it can reliably and easily be used from future DRM DP MST helpers to assist with tasks such as scanning through the current VCPI allocations and adding connectors which need to have their allocations updated in response to a bandwidth change or the like. Being able to hold &mgr->base.lock throughout the entire link probe process would have been _great_, since we could prevent userspace from ever seeing any states in-between individual port changes and as a result likely end up with a much faster probe and more consistent results from said probes. But without some rework of how we handle connector probing in sysfs it's not at all currently possible. In the future, maybe we can try using the sysfs locks to protect updates to connector probing state and fix this mess. So for now, to protect everything other than port->connector under &mgr->base.lock and ensure that we still have the guarantee that atomic check/commit contexts will never see port->connector change we use a silly trick. See: port->connector only needs to change in order to ensure that input ports (see the MST spec) never have a ghost connector associated with them. But, there's nothing stopping us from simply throwing the entire port out and creating a new one in order to maintain that requirement while still keeping port->connector consistent across the lifetime of the port in atomic check/commit contexts. For all intended purposes this works fine, as we validate ports in any contexts we care about before using them and as such will end up reporting the connector as disconnected until it's port's destruction finalizes. So, we just do that in cases where we detect port->input has transitioned from true->false. We don't need to worry about the other direction, since a port without a connector isn't visible to userspace and as such doesn't need to be protected by &mgr->base.lock until we finish registering a connector for it. For updating members of drm_dp_mst_port other than port->connector, we simply grab &mgr->base.lock in drm_dp_mst_link_probe_work() for already registered ports, update said members and drop the lock before potentially registering a connector and probing the link address of it's children. Finally, we modify drm_dp_mst_detect_port() to take a modesetting lock acquisition context in order to acquire &mgr->base.lock under &connection_mutex and convert all it's users over to using the .detect_ctx probe hooks. With that, we finally have well defined locking. Changes since v4: * Get rid of port->mutex, stop using connection_mutex and just use our own modesetting lock - mgr->base.lock. Also, add a probe_lock that comes before this patch. * Just throw out ports that get changed from an output to an input, and replace them with new ports. This lets us ensure that modesetting contexts never see port->connector go from having a connector to being NULL. * Write an extremely detailed explanation of what problems this is trying to fix, since there's a _lot_ of context here and I honestly forgot some of it myself a couple times. * Don't grab mgr->lock when reading port->mstb in drm_dp_mst_handle_link_address_port(). It's not needed. Cc: Juston Li Cc: Imre Deak Cc: Ville Syrj=C3=A4l=C3=A4 Cc: Harry Wentland Cc: Daniel Vetter Cc: Sean Paul Signed-off-by: Lyude Paul --- .../display/amdgpu_dm/amdgpu_dm_mst_types.c | 28 +-- drivers/gpu/drm/drm_dp_mst_topology.c | 230 ++++++++++++------ drivers/gpu/drm/i915/display/intel_dp_mst.c | 28 ++- drivers/gpu/drm/nouveau/dispnv50/disp.c | 32 +-- drivers/gpu/drm/radeon/radeon_dp_mst.c | 24 +- include/drm/drm_dp_mst_helper.h | 38 ++- 6 files changed, 240 insertions(+), 140 deletions(-) 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 5ec14efd4d8c..f8214acf70b3 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 @@ -123,21 +123,6 @@ static ssize_t dm_dp_aux_transfer(struct drm_dp_aux *a= ux, =09return result; } =20 -static enum drm_connector_status -dm_dp_mst_detect(struct drm_connector *connector, bool force) -{ -=09struct amdgpu_dm_connector *aconnector =3D to_amdgpu_dm_connector(conne= ctor); -=09struct amdgpu_dm_connector *master =3D aconnector->mst_port; - -=09enum drm_connector_status status =3D -=09=09drm_dp_mst_detect_port( -=09=09=09connector, -=09=09=09&master->mst_mgr, -=09=09=09aconnector->port); - -=09return status; -} - static void dm_dp_mst_connector_destroy(struct drm_connector *connector) { @@ -177,7 +162,6 @@ amdgpu_dm_mst_connector_early_unregister(struct drm_con= nector *connector) } =20 static const struct drm_connector_funcs dm_dp_mst_connector_funcs =3D { -=09.detect =3D dm_dp_mst_detect, =09.fill_modes =3D drm_helper_probe_single_connector_modes, =09.destroy =3D dm_dp_mst_connector_destroy, =09.reset =3D amdgpu_dm_connector_funcs_reset, @@ -252,10 +236,22 @@ static struct drm_encoder *dm_mst_best_encoder(struct= drm_connector *connector) =09return &amdgpu_dm_connector->mst_encoder->base; } =20 +static int +dm_dp_mst_detect(struct drm_connector *connector, +=09=09 struct drm_modeset_acquire_ctx *ctx, bool force) +{ +=09struct amdgpu_dm_connector *aconnector =3D to_amdgpu_dm_connector(conne= ctor); +=09struct amdgpu_dm_connector *master =3D aconnector->mst_port; + +=09return drm_dp_mst_detect_port(connector, ctx, &master->mst_mgr, +=09=09=09=09 aconnector->port); +} + static const struct drm_connector_helper_funcs dm_dp_mst_connector_helper_= funcs =3D { =09.get_modes =3D dm_dp_mst_get_modes, =09.mode_valid =3D amdgpu_dm_connector_mode_valid, =09.best_encoder =3D dm_mst_best_encoder, +=09.detect_ctx =3D dm_dp_mst_detect, }; =20 static void amdgpu_dm_encoder_destroy(struct drm_encoder *encoder) diff --git a/drivers/gpu/drm/drm_dp_mst_topology.c b/drivers/gpu/drm/drm_dp= _mst_topology.c index 11d842f0bff5..7bf4db91ff90 100644 --- a/drivers/gpu/drm/drm_dp_mst_topology.c +++ b/drivers/gpu/drm/drm_dp_mst_topology.c @@ -1905,6 +1905,78 @@ void drm_dp_mst_connector_early_unregister(struct dr= m_connector *connector, } EXPORT_SYMBOL(drm_dp_mst_connector_early_unregister); =20 +static void +drm_dp_mst_port_add_connector(struct drm_dp_mst_branch *mstb, +=09=09=09 struct drm_dp_mst_port *port) +{ +=09struct drm_dp_mst_topology_mgr *mgr =3D port->mgr; +=09char proppath[255]; +=09int ret; + +=09build_mst_prop_path(mstb, port->port_num, proppath, sizeof(proppath)); +=09port->connector =3D mgr->cbs->add_connector(mgr, port, proppath); +=09if (!port->connector) { +=09=09ret =3D -ENOMEM; +=09=09goto error; +=09} + +=09if ((port->pdt =3D=3D DP_PEER_DEVICE_DP_LEGACY_CONV || +=09 port->pdt =3D=3D DP_PEER_DEVICE_SST_SINK) && +=09 port->port_num >=3D DP_MST_LOGICAL_PORT_0) { +=09=09port->cached_edid =3D drm_get_edid(port->connector, +=09=09=09=09=09=09 &port->aux.ddc); +=09=09drm_connector_set_tile_property(port->connector); +=09} + +=09mgr->cbs->register_connector(port->connector); +=09return; + +error: +=09DRM_ERROR("Failed to create connector for port %p: %d\n", port, ret); +} + +/* + * Drop a topology reference, and unlink the port from the in-memory topol= ogy + * layout + */ +static void +drm_dp_mst_topology_unlink_port(struct drm_dp_mst_topology_mgr *mgr, +=09=09=09=09struct drm_dp_mst_port *port) +{ +=09mutex_lock(&mgr->lock); +=09list_del(&port->next); +=09mutex_unlock(&mgr->lock); +=09drm_dp_mst_topology_put_port(port); +} + +static struct drm_dp_mst_port * +drm_dp_mst_add_port(struct drm_device *dev, +=09=09 struct drm_dp_mst_topology_mgr *mgr, +=09=09 struct drm_dp_mst_branch *mstb, u8 port_number) +{ +=09struct drm_dp_mst_port *port =3D kzalloc(sizeof(*port), GFP_KERNEL); + +=09if (!port) +=09=09return NULL; + +=09kref_init(&port->topology_kref); +=09kref_init(&port->malloc_kref); +=09port->parent =3D mstb; +=09port->port_num =3D port_number; +=09port->mgr =3D mgr; +=09port->aux.name =3D "DPMST"; +=09port->aux.dev =3D dev->dev; +=09port->aux.is_remote =3D true; + +=09/* +=09 * Make sure the memory allocation for our parent branch stays +=09 * around until our own memory allocation is released +=09 */ +=09drm_dp_mst_get_mstb_malloc(mstb); + +=09return port; +} + static void drm_dp_mst_handle_link_address_port(struct drm_dp_mst_branch *mstb, =09=09=09=09 struct drm_device *dev, @@ -1912,35 +1984,40 @@ drm_dp_mst_handle_link_address_port(struct drm_dp_m= st_branch *mstb, { =09struct drm_dp_mst_topology_mgr *mgr =3D mstb->mgr; =09struct drm_dp_mst_port *port; -=09bool created =3D false; -=09int old_ddps =3D 0; +=09int old_ddps =3D 0, ret; +=09u8 new_pdt =3D DP_PEER_DEVICE_NONE; +=09bool created =3D false, send_link_addr =3D false; =20 =09port =3D drm_dp_get_port(mstb, port_msg->port_number); =09if (!port) { -=09=09port =3D kzalloc(sizeof(*port), GFP_KERNEL); +=09=09port =3D drm_dp_mst_add_port(dev, mgr, mstb, +=09=09=09=09=09 port_msg->port_number); =09=09if (!port) =09=09=09return; -=09=09kref_init(&port->topology_kref); -=09=09kref_init(&port->malloc_kref); -=09=09port->parent =3D mstb; -=09=09port->port_num =3D port_msg->port_number; -=09=09port->mgr =3D mgr; -=09=09port->aux.name =3D "DPMST"; -=09=09port->aux.dev =3D dev->dev; -=09=09port->aux.is_remote =3D true; - -=09=09/* -=09=09 * Make sure the memory allocation for our parent branch stays -=09=09 * around until our own memory allocation is released +=09=09created =3D true; +=09} else if (port_msg->input_port && !port->input && port->connector) { +=09=09/* Destroying the connector is impossible in this context, so +=09=09 * replace the port with a new one =09=09 */ -=09=09drm_dp_mst_get_mstb_malloc(mstb); +=09=09drm_dp_mst_topology_unlink_port(mgr, port); +=09=09drm_dp_mst_topology_put_port(port); =20 +=09=09port =3D drm_dp_mst_add_port(dev, mgr, mstb, +=09=09=09=09=09 port_msg->port_number); +=09=09if (!port) +=09=09=09return; =09=09created =3D true; =09} else { +=09=09/* Locking is only needed when the port has a connector +=09=09 * exposed to userspace +=09=09 */ +=09=09drm_modeset_lock(&mgr->base.lock, NULL); =09=09old_ddps =3D port->ddps; =09} =20 =09port->input =3D port_msg->input_port; +=09if (!port->input) +=09=09new_pdt =3D port_msg->peer_device_type; =09port->mcs =3D port_msg->mcs; =09port->ddps =3D port_msg->ddps; =09port->ldps =3D port_msg->legacy_device_plug_status; @@ -1968,59 +2045,39 @@ drm_dp_mst_handle_link_address_port(struct drm_dp_m= st_branch *mstb, =09=09} =09} =20 -=09if (!port->input) { -=09=09int ret =3D drm_dp_port_set_pdt(port, -=09=09=09=09=09 port_msg->peer_device_type); -=09=09if (ret =3D=3D 1) { -=09=09=09drm_dp_send_link_address(mgr, port->mstb); -=09=09} else if (ret < 0) { -=09=09=09DRM_ERROR("Failed to change PDT on port %p: %d\n", -=09=09=09=09 port, ret); -=09=09=09goto fail; -=09=09} +=09ret =3D drm_dp_port_set_pdt(port, new_pdt); +=09if (ret =3D=3D 1) { +=09=09send_link_addr =3D true; +=09} else if (ret < 0) { +=09=09DRM_ERROR("Failed to change PDT on port %p: %d\n", +=09=09=09 port, ret); +=09=09goto fail; =09} =20 -=09if (created && !port->input) { -=09=09char proppath[255]; - -=09=09build_mst_prop_path(mstb, port->port_num, proppath, -=09=09=09=09 sizeof(proppath)); -=09=09port->connector =3D (*mgr->cbs->add_connector)(mgr, port, -=09=09=09=09=09=09=09 proppath); -=09=09if (!port->connector) -=09=09=09goto fail; - -=09=09if ((port->pdt =3D=3D DP_PEER_DEVICE_DP_LEGACY_CONV || -=09=09 port->pdt =3D=3D DP_PEER_DEVICE_SST_SINK) && -=09=09 port->port_num >=3D DP_MST_LOGICAL_PORT_0) { -=09=09=09port->cached_edid =3D drm_get_edid(port->connector, -=09=09=09=09=09=09=09 &port->aux.ddc); -=09=09=09drm_connector_set_tile_property(port->connector); -=09=09} +=09if (!created) +=09=09drm_modeset_unlock(&mgr->base.lock); +=09else if (!port->connector && !port->input) +=09=09drm_dp_mst_port_add_connector(mstb, port); =20 -=09=09(*mgr->cbs->register_connector)(port->connector); -=09} +=09if (send_link_addr && port->mstb) +=09=09drm_dp_send_link_address(mgr, port->mstb); =20 =09/* put reference to this port */ =09drm_dp_mst_topology_put_port(port); =09return; =20 fail: -=09/* Remove it from the port list */ -=09mutex_lock(&mgr->lock); -=09list_del(&port->next); -=09mutex_unlock(&mgr->lock); - -=09/* Drop the port list reference */ -=09drm_dp_mst_topology_put_port(port); -=09/* And now drop our reference */ +=09drm_dp_mst_topology_unlink_port(mgr, port); =09drm_dp_mst_topology_put_port(port); +=09if (!created) +=09=09drm_modeset_unlock(&mgr->base.lock); } =20 static void drm_dp_mst_handle_conn_stat(struct drm_dp_mst_branch *mstb, =09=09=09 struct drm_dp_connection_status_notify *conn_stat) { +=09struct drm_dp_mst_topology_mgr *mgr =3D mstb->mgr; =09struct drm_dp_mst_port *port; =09int old_ddps; =09bool dowork =3D false; @@ -2029,6 +2086,10 @@ drm_dp_mst_handle_conn_stat(struct drm_dp_mst_branch= *mstb, =09if (!port) =09=09return; =20 +=09/* Locking is only needed if the port's exposed to userspace */ +=09if (port->connector) +=09=09drm_modeset_lock(&mgr->base.lock, NULL); + =09old_ddps =3D port->ddps; =09port->mcs =3D conn_stat->message_capability_status; =09port->ldps =3D conn_stat->legacy_device_plug_status; @@ -2054,10 +2115,12 @@ drm_dp_mst_handle_conn_stat(struct drm_dp_mst_branc= h *mstb, =09=09} =09} =20 +=09if (port->connector) +=09=09drm_modeset_unlock(&mgr->base.lock); + =09drm_dp_mst_topology_put_port(port); =09if (dowork) =09=09queue_work(system_long_wq, &mstb->mgr->work); - } =20 static struct drm_dp_mst_branch *drm_dp_get_mst_branch_device(struct drm_d= p_mst_topology_mgr *mgr, @@ -2157,8 +2220,11 @@ static void drm_dp_check_and_send_link_address(struc= t drm_dp_mst_topology_mgr *m =09=09if (port->input || !port->ddps) =09=09=09continue; =20 -=09=09if (!port->available_pbn) +=09=09if (!port->available_pbn) { +=09=09=09drm_modeset_lock(&mgr->base.lock, NULL); =09=09=09drm_dp_send_enum_path_resources(mgr, mstb, port); +=09=09=09drm_modeset_unlock(&mgr->base.lock); +=09=09} =20 =09=09if (port->mstb) =09=09=09mstb_child =3D drm_dp_mst_topology_get_mstb_validated( @@ -2189,11 +2255,16 @@ static void drm_dp_mst_link_probe_work(struct work_= struct *work) =09=09=09mstb =3D NULL; =09} =09mutex_unlock(&mgr->lock); -=09if (mstb) { -=09=09drm_dp_check_and_send_link_address(mgr, mstb); -=09=09drm_dp_mst_topology_put_mstb(mstb); +=09if (!mstb) { +=09=09mutex_unlock(&mgr->probe_lock); +=09=09return; =09} + +=09drm_dp_check_and_send_link_address(mgr, mstb); +=09drm_dp_mst_topology_put_mstb(mstb); + =09mutex_unlock(&mgr->probe_lock); +=09drm_kms_helper_hotplug_event(dev); } =20 static bool drm_dp_validate_guid(struct drm_dp_mst_topology_mgr *mgr, @@ -2478,8 +2549,6 @@ static void drm_dp_send_link_address(struct drm_dp_ms= t_topology_mgr *mgr, =09=09drm_dp_mst_handle_link_address_port(mstb, mgr->dev, =09=09=09=09=09=09 &reply->ports[i]); =20 -=09drm_kms_helper_hotplug_event(mgr->dev); - out: =09if (ret <=3D 0) =09=09mstb->link_address_sent =3D false; @@ -3274,13 +3343,14 @@ static int drm_dp_mst_handle_down_rep(struct drm_dp= _mst_topology_mgr *mgr) =09return 0; } =20 -static inline void +static inline bool drm_dp_mst_process_up_req(struct drm_dp_mst_topology_mgr *mgr, =09=09=09 struct drm_dp_pending_up_req *up_req) { =09struct drm_dp_mst_branch *mstb =3D NULL; =09struct drm_dp_sideband_msg_req_body *msg =3D &up_req->msg; =09struct drm_dp_sideband_msg_hdr *hdr =3D &up_req->hdr; +=09bool hotplug =3D false; =20 =09if (hdr->broadcast) { =09=09const u8 *guid =3D NULL; @@ -3298,16 +3368,17 @@ drm_dp_mst_process_up_req(struct drm_dp_mst_topolog= y_mgr *mgr, =09if (!mstb) { =09=09DRM_DEBUG_KMS("Got MST reply from unknown device %d\n", =09=09=09 hdr->lct); -=09=09return; +=09=09return false; =09} =20 =09/* TODO: Add missing handler for DP_RESOURCE_STATUS_NOTIFY events */ =09if (msg->req_type =3D=3D DP_CONNECTION_STATUS_NOTIFY) { =09=09drm_dp_mst_handle_conn_stat(mstb, &msg->u.conn_stat); -=09=09drm_kms_helper_hotplug_event(mgr->dev); +=09=09hotplug =3D true; =09} =20 =09drm_dp_mst_topology_put_mstb(mstb); +=09return hotplug; } =20 static void drm_dp_mst_up_req_work(struct work_struct *work) @@ -3316,6 +3387,7 @@ static void drm_dp_mst_up_req_work(struct work_struct= *work) =09=09container_of(work, struct drm_dp_mst_topology_mgr, =09=09=09 up_req_work); =09struct drm_dp_pending_up_req *up_req; +=09bool send_hotplug =3D false; =20 =09mutex_lock(&mgr->probe_lock); =09while (true) { @@ -3330,10 +3402,13 @@ static void drm_dp_mst_up_req_work(struct work_stru= ct *work) =09=09if (!up_req) =09=09=09break; =20 -=09=09drm_dp_mst_process_up_req(mgr, up_req); +=09=09send_hotplug |=3D drm_dp_mst_process_up_req(mgr, up_req); =09=09kfree(up_req); =09} =09mutex_unlock(&mgr->probe_lock); + +=09if (send_hotplug) +=09=09drm_kms_helper_hotplug_event(mgr->dev); } =20 static int drm_dp_mst_handle_up_req(struct drm_dp_mst_topology_mgr *mgr) @@ -3441,22 +3516,31 @@ EXPORT_SYMBOL(drm_dp_mst_hpd_irq); /** * drm_dp_mst_detect_port() - get connection status for an MST port * @connector: DRM connector for this port + * @ctx: The acquisition context to use for grabbing locks * @mgr: manager for this port - * @port: unverified pointer to a port + * @port: pointer to a port * - * This returns the current connection state for a port. It validates the - * port pointer still exists so the caller doesn't require a reference + * This returns the current connection state for a port. */ -enum drm_connector_status drm_dp_mst_detect_port(struct drm_connector *con= nector, -=09=09=09=09=09=09 struct drm_dp_mst_topology_mgr *mgr, struct drm_dp_mst_= port *port) +int +drm_dp_mst_detect_port(struct drm_connector *connector, +=09=09 struct drm_modeset_acquire_ctx *ctx, +=09=09 struct drm_dp_mst_topology_mgr *mgr, +=09=09 struct drm_dp_mst_port *port) { -=09enum drm_connector_status status =3D connector_status_disconnected; +=09int ret; =20 =09/* we need to search for the port in the mgr in case it's gone */ =09port =3D drm_dp_mst_topology_get_port_validated(mgr, port); =09if (!port) =09=09return connector_status_disconnected; =20 +=09ret =3D drm_modeset_lock(&mgr->base.lock, ctx); +=09if (ret) +=09=09goto out; + +=09ret =3D connector_status_disconnected; + =09if (!port->ddps) =09=09goto out; =20 @@ -3466,7 +3550,7 @@ enum drm_connector_status drm_dp_mst_detect_port(stru= ct drm_connector *connector =09=09break; =20 =09case DP_PEER_DEVICE_SST_SINK: -=09=09status =3D connector_status_connected; +=09=09ret =3D connector_status_connected; =09=09/* for logical ports - cache the EDID */ =09=09if (port->port_num >=3D 8 && !port->cached_edid) { =09=09=09port->cached_edid =3D drm_get_edid(connector, &port->aux.ddc); @@ -3474,12 +3558,12 @@ enum drm_connector_status drm_dp_mst_detect_port(st= ruct drm_connector *connector =09=09break; =09case DP_PEER_DEVICE_DP_LEGACY_CONV: =09=09if (port->ldps) -=09=09=09status =3D connector_status_connected; +=09=09=09ret =3D connector_status_connected; =09=09break; =09} out: =09drm_dp_mst_topology_put_port(port); -=09return status; +=09return ret; } EXPORT_SYMBOL(drm_dp_mst_detect_port); =20 diff --git a/drivers/gpu/drm/i915/display/intel_dp_mst.c b/drivers/gpu/drm/= i915/display/intel_dp_mst.c index bbcab27644dc..a9962846a503 100644 --- a/drivers/gpu/drm/i915/display/intel_dp_mst.c +++ b/drivers/gpu/drm/i915/display/intel_dp_mst.c @@ -391,20 +391,7 @@ static int intel_dp_mst_get_ddc_modes(struct drm_conne= ctor *connector) =09return ret; } =20 -static enum drm_connector_status -intel_dp_mst_detect(struct drm_connector *connector, bool force) -{ -=09struct intel_connector *intel_connector =3D to_intel_connector(connecto= r); -=09struct intel_dp *intel_dp =3D intel_connector->mst_port; - -=09if (drm_connector_is_unregistered(connector)) -=09=09return connector_status_disconnected; -=09return drm_dp_mst_detect_port(connector, &intel_dp->mst_mgr, -=09=09=09=09 intel_connector->port); -} - static const struct drm_connector_funcs intel_dp_mst_connector_funcs =3D { -=09.detect =3D intel_dp_mst_detect, =09.fill_modes =3D drm_helper_probe_single_connector_modes, =09.atomic_get_property =3D intel_digital_connector_atomic_get_property, =09.atomic_set_property =3D intel_digital_connector_atomic_set_property, @@ -465,11 +452,26 @@ static struct drm_encoder *intel_mst_atomic_best_enco= der(struct drm_connector *c =09return &intel_dp->mst_encoders[crtc->pipe]->base.base; } =20 +static int +intel_dp_mst_detect(struct drm_connector *connector, +=09=09 struct drm_modeset_acquire_ctx *ctx, bool force) +{ +=09struct intel_connector *intel_connector =3D to_intel_connector(connecto= r); +=09struct intel_dp *intel_dp =3D intel_connector->mst_port; + +=09if (drm_connector_is_unregistered(connector)) +=09=09return connector_status_disconnected; + +=09return drm_dp_mst_detect_port(connector, ctx, &intel_dp->mst_mgr, +=09=09=09=09 intel_connector->port); +} + static const struct drm_connector_helper_funcs intel_dp_mst_connector_help= er_funcs =3D { =09.get_modes =3D intel_dp_mst_get_modes, =09.mode_valid =3D intel_dp_mst_mode_valid, =09.atomic_best_encoder =3D intel_mst_atomic_best_encoder, =09.atomic_check =3D intel_dp_mst_atomic_check, +=09.detect_ctx =3D intel_dp_mst_detect, }; =20 static void intel_dp_mst_encoder_destroy(struct drm_encoder *encoder) diff --git a/drivers/gpu/drm/nouveau/dispnv50/disp.c b/drivers/gpu/drm/nouv= eau/dispnv50/disp.c index a13924ae1992..a9d6aa110cfd 100644 --- a/drivers/gpu/drm/nouveau/dispnv50/disp.c +++ b/drivers/gpu/drm/nouveau/dispnv50/disp.c @@ -986,20 +986,11 @@ nv50_mstc_atomic_check(struct drm_connector *connecto= r, =09return drm_dp_atomic_release_vcpi_slots(state, mgr, mstc->port); } =20 -static const struct drm_connector_helper_funcs -nv50_mstc_help =3D { -=09.get_modes =3D nv50_mstc_get_modes, -=09.mode_valid =3D nv50_mstc_mode_valid, -=09.best_encoder =3D nv50_mstc_best_encoder, -=09.atomic_best_encoder =3D nv50_mstc_atomic_best_encoder, -=09.atomic_check =3D nv50_mstc_atomic_check, -}; - -static enum drm_connector_status -nv50_mstc_detect(struct drm_connector *connector, bool force) +static int +nv50_mstc_detect(struct drm_connector *connector, +=09=09 struct drm_modeset_acquire_ctx *ctx, bool force) { =09struct nv50_mstc *mstc =3D nv50_mstc(connector); -=09enum drm_connector_status conn_status; =09int ret; =20 =09if (drm_connector_is_unregistered(connector)) @@ -1009,14 +1000,24 @@ nv50_mstc_detect(struct drm_connector *connector, b= ool force) =09if (ret < 0 && ret !=3D -EACCES) =09=09return connector_status_disconnected; =20 -=09conn_status =3D drm_dp_mst_detect_port(connector, mstc->port->mgr, -=09=09=09=09=09 mstc->port); +=09ret =3D drm_dp_mst_detect_port(connector, ctx, mstc->port->mgr, +=09=09=09=09 mstc->port); =20 =09pm_runtime_mark_last_busy(connector->dev->dev); =09pm_runtime_put_autosuspend(connector->dev->dev); -=09return conn_status; +=09return ret; } =20 +static const struct drm_connector_helper_funcs +nv50_mstc_help =3D { +=09.get_modes =3D nv50_mstc_get_modes, +=09.mode_valid =3D nv50_mstc_mode_valid, +=09.best_encoder =3D nv50_mstc_best_encoder, +=09.atomic_best_encoder =3D nv50_mstc_atomic_best_encoder, +=09.atomic_check =3D nv50_mstc_atomic_check, +=09.detect_ctx =3D nv50_mstc_detect, +}; + static void nv50_mstc_destroy(struct drm_connector *connector) { @@ -1031,7 +1032,6 @@ nv50_mstc_destroy(struct drm_connector *connector) static const struct drm_connector_funcs nv50_mstc =3D { =09.reset =3D nouveau_conn_reset, -=09.detect =3D nv50_mstc_detect, =09.fill_modes =3D drm_helper_probe_single_connector_modes, =09.destroy =3D nv50_mstc_destroy, =09.atomic_duplicate_state =3D nouveau_conn_atomic_duplicate_state, diff --git a/drivers/gpu/drm/radeon/radeon_dp_mst.c b/drivers/gpu/drm/radeo= n/radeon_dp_mst.c index 2994f07fbad9..ee28f5b3785e 100644 --- a/drivers/gpu/drm/radeon/radeon_dp_mst.c +++ b/drivers/gpu/drm/radeon/radeon_dp_mst.c @@ -233,21 +233,26 @@ drm_encoder *radeon_mst_best_encoder(struct drm_conne= ctor *connector) =09return &radeon_connector->mst_encoder->base; } =20 +static int +radeon_dp_mst_detect(struct drm_connector *connector, +=09=09 struct drm_modeset_acquire_ctx *ctx, +=09=09 bool force) +{ +=09struct radeon_connector *radeon_connector =3D +=09=09to_radeon_connector(connector); +=09struct radeon_connector *master =3D radeon_connector->mst_port; + +=09return drm_dp_mst_detect_port(connector, ctx, &master->mst_mgr, +=09=09=09=09 radeon_connector->port); +} + static const struct drm_connector_helper_funcs radeon_dp_mst_connector_hel= per_funcs =3D { =09.get_modes =3D radeon_dp_mst_get_modes, =09.mode_valid =3D radeon_dp_mst_mode_valid, =09.best_encoder =3D radeon_mst_best_encoder, +=09.detect_ctx =3D radeon_dp_mst_detect, }; =20 -static enum drm_connector_status -radeon_dp_mst_detect(struct drm_connector *connector, bool force) -{ -=09struct radeon_connector *radeon_connector =3D to_radeon_connector(conne= ctor); -=09struct radeon_connector *master =3D radeon_connector->mst_port; - -=09return drm_dp_mst_detect_port(connector, &master->mst_mgr, radeon_conne= ctor->port); -} - static void radeon_dp_mst_connector_destroy(struct drm_connector *connector) { @@ -262,7 +267,6 @@ radeon_dp_mst_connector_destroy(struct drm_connector *c= onnector) =20 static const struct drm_connector_funcs radeon_dp_mst_connector_funcs =3D = { =09.dpms =3D drm_helper_connector_dpms, -=09.detect =3D radeon_dp_mst_detect, =09.fill_modes =3D drm_helper_probe_single_connector_modes, =09.destroy =3D radeon_dp_mst_connector_destroy, }; diff --git a/include/drm/drm_dp_mst_helper.h b/include/drm/drm_dp_mst_helpe= r.h index bccb5514e0ef..fd142db42cb0 100644 --- a/include/drm/drm_dp_mst_helper.h +++ b/include/drm/drm_dp_mst_helper.h @@ -45,21 +45,31 @@ struct drm_dp_vcpi { /** * struct drm_dp_mst_port - MST port * @port_num: port number - * @input: if this port is an input port. - * @mcs: message capability status - DP 1.2 spec. - * @ddps: DisplayPort Device Plug Status - DP 1.2 - * @pdt: Peer Device Type - * @ldps: Legacy Device Plug Status - * @dpcd_rev: DPCD revision of device on this port - * @num_sdp_streams: Number of simultaneous streams - * @num_sdp_stream_sinks: Number of stream sinks - * @available_pbn: Available bandwidth for this port. + * @input: if this port is an input port. Protected by + * &drm_dp_mst_topology_mgr.base.lock. + * @mcs: message capability status - DP 1.2 spec. Protected by + * &drm_dp_mst_topology_mgr.base.lock. + * @ddps: DisplayPort Device Plug Status - DP 1.2. Protected by + * &drm_dp_mst_topology_mgr.base.lock. + * @pdt: Peer Device Type. Protected by + * &drm_dp_mst_topology_mgr.base.lock. + * @ldps: Legacy Device Plug Status. Protected by + * &drm_dp_mst_topology_mgr.base.lock. + * @dpcd_rev: DPCD revision of device on this port. Protected by + * &drm_dp_mst_topology_mgr.base.lock. + * @num_sdp_streams: Number of simultaneous streams. Protected by + * &drm_dp_mst_topology_mgr.base.lock. + * @num_sdp_stream_sinks: Number of stream sinks. Protected by + * &drm_dp_mst_topology_mgr.base.lock. + * @available_pbn: Available bandwidth for this port. Protected by + * &drm_dp_mst_topology_mgr.base.lock. * @next: link to next port on this branch device * @aux: i2c aux transport to talk to device connected to this port, prote= cted - * by &drm_dp_mst_topology_mgr.lock + * by &drm_dp_mst_topology_mgr.base.lock. * @parent: branch device parent of this port * @vcpi: Virtual Channel Payload info for this port. - * @connector: DRM connector this port is connected to. + * @connector: DRM connector this port is connected to. Protected by + * &drm_dp_mst_topology_mgr.base.lock. * @mgr: topology manager this port lives under. * * This structure represents an MST port endpoint on a device somewhere @@ -653,7 +663,11 @@ int drm_dp_mst_topology_mgr_set_mst(struct drm_dp_mst_= topology_mgr *mgr, bool ms int drm_dp_mst_hpd_irq(struct drm_dp_mst_topology_mgr *mgr, u8 *esi, bool = *handled); =20 =20 -enum drm_connector_status drm_dp_mst_detect_port(struct drm_connector *con= nector, struct drm_dp_mst_topology_mgr *mgr, struct drm_dp_mst_port *port); +int +drm_dp_mst_detect_port(struct drm_connector *connector, +=09=09 struct drm_modeset_acquire_ctx *ctx, +=09=09 struct drm_dp_mst_topology_mgr *mgr, +=09=09 struct drm_dp_mst_port *port); =20 bool drm_dp_mst_port_has_audio(struct drm_dp_mst_topology_mgr *mgr, =09=09=09=09=09struct drm_dp_mst_port *port); --=20 2.21.0