From mboxrd@z Thu Jan 1 00:00:00 1970 From: Lyude Paul Subject: [PATCH v5 14/14] drm/dp_mst: Add topology ref history tracking for debugging Date: Mon, 21 Oct 2019 22:36:09 -0400 Message-ID: <20191022023641.8026-15-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: dri-devel-bounces@lists.freedesktop.org Sender: "dri-devel" 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 , linux-kernel@vger.kernel.org, Harry Wentland , Juston Li , Sean Paul List-Id: amd-gfx.lists.freedesktop.org Rm9yIHZlcnkgc3VidGxlIG1pc3Rha2VzIHdpdGggdG9wb2xvZ3kgcmVmcywgaXQgY2FuIGJlIHJh dGhlciBkaWZmaWN1bHQKdG8gdHJhY2UgdGhlbSBkb3duIHdpdGggdGhlIGRlYnVnZ2luZyBpbmZv IHRoYXQgd2UgYWxyZWFkeSBoYXZlLiBJIGhhZApvbmUgc3VjaCBpc3N1ZSByZWNlbnRseSB3aGls ZSB0cnlpbmcgdG8gaW1wbGVtZW50IHN1c3BlbmQvcmVzdW1lCnJlcHJvYmluZyBmb3IgTVNULCBh bmQgZW5kZWQgdXAgY29taW5nIHVwIHdpdGggdGhpcy4KCkluc3BpcmVkIGJ5IENocmlzIFdpbHNv bidzIHdha2VyZWYgdHJhY2tpbmcgZm9yIGk5MTUsIHRoaXMgYWRkcyBhIHZlcnkKc2ltaWxhciBm ZWF0dXJlIHRvIHRoZSBEUCBNU1QgaGVscGVycywgd2hpY2ggYWxsb3dzIGZvciBwYXJ0aWFsIHRy YWNraW5nCm9mIHRvcG9sb2d5IHJlZnMgZm9yIGJvdGggcG9ydHMgYW5kIGJyYW5jaCBkZXZpY2Vz LiBUaGlzIGlzIGEgbG90IGxlc3MKYWR2YW5jZWQgdGhlbiB3YWtlcmVmIHRyYWNraW5nOiB3ZSBt ZXJlbHkga2VlcCBhIGNvdW50IG9mIGFsbCBvZiB0aGUKc3BvdHMgd2hlcmUgYSB0b3BvbG9neSBy ZWYgaGFzIGJlZW4gZ3JhYmJlZCBvciBkcm9wcGVkLCB0aGVuIGR1bXAgb3V0CnRoYXQgaGlzdG9y eSBpbiBjaHJvbm9sb2dpY2FsIG9yZGVyIHdoZW4gYSBwb3J0IG9yIGJyYW5jaCBkZXZpY2Uncwp0 b3BvbG9neSByZWZjb3VudCByZWFjaGVzIDAuIFNvIGZhciwgSSd2ZSBmb3VuZCB0aGlzIGluY3Jl ZGlibHkgdXNlZnVsCmZvciBkZWJ1Z2dpbmcgdG9wb2xvZ3kgcmVmY291bnQgZXJyb3JzLgoKU2lu Y2UgdGhpcyBoYXMgdGhlIHBvdGVudGlhbCB0byBiZSBzb21ld2hhdCBzbG93IGFuZCBsb3VkLCB3 ZSBhZGQgYW4KZXhwZXJ0IGtlcm5lbCBjb25maWcgb3B0aW9uIHRvIGVuYWJsZSBvciBkaXNhYmxl IHRoaXMgZmVhdHVyZSwKQ09ORklHX0RSTV9ERUJVR19EUF9NU1RfVE9QT0xPR1lfUkVGUy4KCkNo YW5nZXMgc2luY2UgdjE6CiogRG9uJ3QgZm9yZ2V0IHRvIGRlc3Ryb3kgdG9wb2xvZ3lfcmVmX2hp c3RvcnlfbG9jawpDaGFuZ2VzIHNpbmNlIHY0OgoqIENvcnJlY3Qgb3JkZXIgb2Yga3JlZl9wdXQo KS90b3BvbG9neV9yZWZfaGlzdG9yeV91bmxvY2sgLSB3ZSBjYW4ndAogIHVubG9jayB0aGUgaGlz dG9yeSBhZnRlciBrcmVmX3B1dCgpIHNpbmNlIHRoZSBtZW1vcnkgbWlnaHQgaGF2ZSBiZWVuCiAg ZnJlZWQgYnkgdGhhdCBwb2ludAoqIERvbid0IHByaW50IG1lc3NhZ2Ugb24gYWxsb2NhdGlvbiBl cnJvciBmYWlsdXJlcywgdGhlIGtlcm5lbCBhbHJlYWR5CiAgZG9lcyB0aGlzIGZvciB1cwoKQ2M6 IEp1c3RvbiBMaSA8anVzdG9uLmxpQGludGVsLmNvbT4KQ2M6IEltcmUgRGVhayA8aW1yZS5kZWFr QGludGVsLmNvbT4KQ2M6IFZpbGxlIFN5cmrDpGzDpCA8dmlsbGUuc3lyamFsYUBsaW51eC5pbnRl bC5jb20+CkNjOiBIYXJyeSBXZW50bGFuZCA8aHdlbnRsYW5AYW1kLmNvbT4KQ2M6IERhbmllbCBW ZXR0ZXIgPGRhbmllbC52ZXR0ZXJAZmZ3bGwuY2g+ClJldmlld2VkLWJ5OiBTZWFuIFBhdWwgPHNl YW5AcG9vcmx5LnJ1bj4KU2lnbmVkLW9mZi1ieTogTHl1ZGUgUGF1bCA8bHl1ZGVAcmVkaGF0LmNv bT4KLS0tCiBkcml2ZXJzL2dwdS9kcm0vS2NvbmZpZyAgICAgICAgICAgICAgIHwgIDE0ICsrCiBk cml2ZXJzL2dwdS9kcm0vZHJtX2RwX21zdF90b3BvbG9neS5jIHwgMjQxICsrKysrKysrKysrKysr KysrKysrKysrKy0tCiBpbmNsdWRlL2RybS9kcm1fZHBfbXN0X2hlbHBlci5oICAgICAgIHwgIDQ1 ICsrKysrCiAzIGZpbGVzIGNoYW5nZWQsIDI5MCBpbnNlcnRpb25zKCspLCAxMCBkZWxldGlvbnMo LSkKCmRpZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9kcm0vS2NvbmZpZyBiL2RyaXZlcnMvZ3B1L2Ry bS9LY29uZmlnCmluZGV4IDM2MzU3YTM2YTI4MS4uZjNmNTkxMDc0M2Q0IDEwMDY0NAotLS0gYS9k cml2ZXJzL2dwdS9kcm0vS2NvbmZpZworKysgYi9kcml2ZXJzL2dwdS9kcm0vS2NvbmZpZwpAQCAt OTMsNiArOTMsMjAgQEAgY29uZmlnIERSTV9LTVNfRkJfSEVMUEVSCiAJaGVscAogCSAgRkJERVYg aGVscGVycyBmb3IgS01TIGRyaXZlcnMuCiAKK2NvbmZpZyBEUk1fREVCVUdfRFBfTVNUX1RPUE9M T0dZX1JFRlMKKyAgICAgICAgYm9vbCAiRW5hYmxlIHJlZmNvdW50IGJhY2t0cmFjZSBoaXN0b3J5 IGluIHRoZSBEUCBNU1QgaGVscGVycyIKKyAgICAgICAgc2VsZWN0IFNUQUNLREVQT1QKKyAgICAg ICAgZGVwZW5kcyBvbiBEUk1fS01TX0hFTFBFUgorICAgICAgICBkZXBlbmRzIG9uIERFQlVHX0tF Uk5FTAorICAgICAgICBkZXBlbmRzIG9uIEVYUEVSVAorICAgICAgICBoZWxwCisgICAgICAgICAg RW5hYmxlcyBkZWJ1ZyB0cmFjaW5nIGZvciB0b3BvbG9neSByZWZzIGluIERSTSdzIERQIE1TVCBo ZWxwZXJzLiBBCisgICAgICAgICAgaGlzdG9yeSBvZiBlYWNoIHRvcG9sb2d5IHJlZmVyZW5jZS9k ZXJlZmVyZW5jZSB3aWxsIGJlIHByaW50ZWQgdG8gdGhlCisgICAgICAgICAga2VybmVsIGxvZyBv bmNlIGEgcG9ydCBvciBicmFuY2ggZGV2aWNlJ3MgdG9wb2xvZ3kgcmVmY291bnQgcmVhY2hlcyAw LgorCisgICAgICAgICAgVGhpcyBoYXMgdGhlIHBvdGVudGlhbCB0byB1c2UgYSBsb3Qgb2YgbWVt b3J5IGFuZCBwcmludCBzb21lIHZlcnkKKyAgICAgICAgICBsYXJnZSBrZXJuZWwgbWVzc2FnZXMu IElmIGluIGRvdWJ0LCBzYXkgIk4iLgorCiBjb25maWcgRFJNX0ZCREVWX0VNVUxBVElPTgogCWJv b2wgIkVuYWJsZSBsZWdhY3kgZmJkZXYgc3VwcG9ydCBmb3IgeW91ciBtb2Rlc2V0dGluZyBkcml2 ZXIiCiAJZGVwZW5kcyBvbiBEUk0KZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2RybS9kcm1fZHBf bXN0X3RvcG9sb2d5LmMgYi9kcml2ZXJzL2dwdS9kcm0vZHJtX2RwX21zdF90b3BvbG9neS5jCmlu ZGV4IDQyODE2MDI3MDQ4Mi4uY2VkZmEyODFhMjJlIDEwMDY0NAotLS0gYS9kcml2ZXJzL2dwdS9k cm0vZHJtX2RwX21zdF90b3BvbG9neS5jCisrKyBiL2RyaXZlcnMvZ3B1L2RybS9kcm1fZHBfbXN0 X3RvcG9sb2d5LmMKQEAgLTI4LDYgKzI4LDEzIEBACiAjaW5jbHVkZSA8bGludXgvc2NoZWQuaD4K ICNpbmNsdWRlIDxsaW51eC9zZXFfZmlsZS5oPgogCisjaWYgSVNfRU5BQkxFRChDT05GSUdfRFJN X0RFQlVHX0RQX01TVF9UT1BPTE9HWV9SRUZTKQorI2luY2x1ZGUgPGxpbnV4L3N0YWNrZGVwb3Qu aD4KKyNpbmNsdWRlIDxsaW51eC9zb3J0Lmg+CisjaW5jbHVkZSA8bGludXgvdGltZWtlZXBpbmcu aD4KKyNpbmNsdWRlIDxsaW51eC9tYXRoNjQuaD4KKyNlbmRpZgorCiAjaW5jbHVkZSA8ZHJtL2Ry bV9hdG9taWMuaD4KICNpbmNsdWRlIDxkcm0vZHJtX2F0b21pY19oZWxwZXIuaD4KICNpbmNsdWRl IDxkcm0vZHJtX2RwX21zdF9oZWxwZXIuaD4KQEAgLTEzOTksMTIgKzE0MDYsMTg3IEBAIGRybV9k cF9tc3RfcHV0X3BvcnRfbWFsbG9jKHN0cnVjdCBkcm1fZHBfbXN0X3BvcnQgKnBvcnQpCiB9CiBF WFBPUlRfU1lNQk9MKGRybV9kcF9tc3RfcHV0X3BvcnRfbWFsbG9jKTsKIAorI2lmIElTX0VOQUJM RUQoQ09ORklHX0RSTV9ERUJVR19EUF9NU1RfVE9QT0xPR1lfUkVGUykKKworI2RlZmluZSBTVEFD S19ERVBUSCA4CisKK3N0YXRpYyBub2lubGluZSB2b2lkCitfX3RvcG9sb2d5X3JlZl9zYXZlKHN0 cnVjdCBkcm1fZHBfbXN0X3RvcG9sb2d5X21nciAqbWdyLAorCQkgICAgc3RydWN0IGRybV9kcF9t c3RfdG9wb2xvZ3lfcmVmX2hpc3RvcnkgKmhpc3RvcnksCisJCSAgICBlbnVtIGRybV9kcF9tc3Rf dG9wb2xvZ3lfcmVmX3R5cGUgdHlwZSkKK3sKKwlzdHJ1Y3QgZHJtX2RwX21zdF90b3BvbG9neV9y ZWZfZW50cnkgKmVudHJ5ID0gTlVMTDsKKwlkZXBvdF9zdGFja19oYW5kbGVfdCBiYWNrdHJhY2U7 CisJdWxvbmcgc3RhY2tfZW50cmllc1tTVEFDS19ERVBUSF07CisJdWludCBuOworCWludCBpOwor CisJbiA9IHN0YWNrX3RyYWNlX3NhdmUoc3RhY2tfZW50cmllcywgQVJSQVlfU0laRShzdGFja19l bnRyaWVzKSwgMSk7CisJYmFja3RyYWNlID0gc3RhY2tfZGVwb3Rfc2F2ZShzdGFja19lbnRyaWVz LCBuLCBHRlBfS0VSTkVMKTsKKwlpZiAoIWJhY2t0cmFjZSkKKwkJcmV0dXJuOworCisJLyogVHJ5 IHRvIGZpbmQgYW4gZXhpc3RpbmcgZW50cnkgZm9yIHRoaXMgYmFja3RyYWNlICovCisJZm9yIChp ID0gMDsgaSA8IGhpc3RvcnktPmxlbjsgaSsrKSB7CisJCWlmIChoaXN0b3J5LT5lbnRyaWVzW2ld LmJhY2t0cmFjZSA9PSBiYWNrdHJhY2UpIHsKKwkJCWVudHJ5ID0gJmhpc3RvcnktPmVudHJpZXNb aV07CisJCQlicmVhazsKKwkJfQorCX0KKworCS8qIE90aGVyd2lzZSBhZGQgb25lICovCisJaWYg KCFlbnRyeSkgeworCQlzdHJ1Y3QgZHJtX2RwX21zdF90b3BvbG9neV9yZWZfZW50cnkgKm5ldzsK KwkJaW50IG5ld19sZW4gPSBoaXN0b3J5LT5sZW4gKyAxOworCisJCW5ldyA9IGtyZWFsbG9jKGhp c3RvcnktPmVudHJpZXMsIHNpemVvZigqbmV3KSAqIG5ld19sZW4sCisJCQkgICAgICAgR0ZQX0tF Uk5FTCk7CisJCWlmICghbmV3KQorCQkJcmV0dXJuOworCisJCWVudHJ5ID0gJm5ld1toaXN0b3J5 LT5sZW5dOworCQloaXN0b3J5LT5sZW4gPSBuZXdfbGVuOworCQloaXN0b3J5LT5lbnRyaWVzID0g bmV3OworCisJCWVudHJ5LT5iYWNrdHJhY2UgPSBiYWNrdHJhY2U7CisJCWVudHJ5LT50eXBlID0g dHlwZTsKKwkJZW50cnktPmNvdW50ID0gMDsKKwl9CisJZW50cnktPmNvdW50Kys7CisJZW50cnkt PnRzX25zZWMgPSBrdGltZV9nZXRfbnMoKTsKKworCXJldHVybjsKK30KKworc3RhdGljIGludAor dG9wb2xvZ3lfcmVmX2hpc3RvcnlfY21wKGNvbnN0IHZvaWQgKmEsIGNvbnN0IHZvaWQgKmIpCit7 CisJY29uc3Qgc3RydWN0IGRybV9kcF9tc3RfdG9wb2xvZ3lfcmVmX2VudHJ5ICplbnRyeV9hID0g YSwgKmVudHJ5X2IgPSBiOworCisJaWYgKGVudHJ5X2EtPnRzX25zZWMgPiBlbnRyeV9iLT50c19u c2VjKQorCQlyZXR1cm4gMTsKKwllbHNlIGlmIChlbnRyeV9hLT50c19uc2VjIDwgZW50cnlfYi0+ dHNfbnNlYykKKwkJcmV0dXJuIC0xOworCWVsc2UKKwkJcmV0dXJuIDA7Cit9CisKK3N0YXRpYyBp bmxpbmUgY29uc3QgY2hhciAqCit0b3BvbG9neV9yZWZfdHlwZV90b19zdHIoZW51bSBkcm1fZHBf bXN0X3RvcG9sb2d5X3JlZl90eXBlIHR5cGUpCit7CisJaWYgKHR5cGUgPT0gRFJNX0RQX01TVF9U T1BPTE9HWV9SRUZfR0VUKQorCQlyZXR1cm4gImdldCI7CisJZWxzZQorCQlyZXR1cm4gInB1dCI7 Cit9CisKK3N0YXRpYyB2b2lkCitfX2R1bXBfdG9wb2xvZ3lfcmVmX2hpc3Rvcnkoc3RydWN0IGRy bV9kcF9tc3RfdG9wb2xvZ3lfcmVmX2hpc3RvcnkgKmhpc3RvcnksCisJCQkgICAgdm9pZCAqcHRy LCBjb25zdCBjaGFyICp0eXBlX3N0cikKK3sKKwlzdHJ1Y3QgZHJtX3ByaW50ZXIgcCA9IGRybV9k ZWJ1Z19wcmludGVyKERCR19QUkVGSVgpOworCWNoYXIgKmJ1ZiA9IGt6YWxsb2MoUEFHRV9TSVpF LCBHRlBfS0VSTkVMKTsKKwlpbnQgaTsKKworCWlmICghYnVmKQorCQlyZXR1cm47CisKKwlpZiAo IWhpc3RvcnktPmxlbikKKwkJZ290byBvdXQ7CisKKwkvKiBGaXJzdCwgc29ydCB0aGUgbGlzdCBz byB0aGF0IGl0IGdvZXMgZnJvbSBvbGRlc3QgdG8gbmV3ZXN0CisJICogcmVmZXJlbmNlIGVudHJ5 CisJICovCisJc29ydChoaXN0b3J5LT5lbnRyaWVzLCBoaXN0b3J5LT5sZW4sIHNpemVvZigqaGlz dG9yeS0+ZW50cmllcyksCisJICAgICB0b3BvbG9neV9yZWZfaGlzdG9yeV9jbXAsIE5VTEwpOwor CisJZHJtX3ByaW50ZigmcCwKKwkJICAgIiVzICglcC8lcHgpIHRvcG9sb2d5IGNvdW50IHJlYWNo ZWQgMCwgZHVtcGluZyBoaXN0b3J5OlxuIiwKKwkJICAgdHlwZV9zdHIsIHB0ciwgcHRyKTsKKwor CWZvciAoaSA9IDA7IGkgPCBoaXN0b3J5LT5sZW47IGkrKykgeworCQljb25zdCBzdHJ1Y3QgZHJt X2RwX21zdF90b3BvbG9neV9yZWZfZW50cnkgKmVudHJ5ID0KKwkJCSZoaXN0b3J5LT5lbnRyaWVz W2ldOworCQl1bG9uZyAqZW50cmllczsKKwkJdWludCBucl9lbnRyaWVzOworCQl1NjQgdHNfbnNl YyA9IGVudHJ5LT50c19uc2VjOworCQl1NjQgcmVtX25zZWMgPSBkb19kaXYodHNfbnNlYywgMTAw MDAwMDAwMCk7CisKKwkJbnJfZW50cmllcyA9IHN0YWNrX2RlcG90X2ZldGNoKGVudHJ5LT5iYWNr dHJhY2UsICZlbnRyaWVzKTsKKwkJc3RhY2tfdHJhY2Vfc25wcmludChidWYsIFBBR0VfU0laRSwg ZW50cmllcywgbnJfZW50cmllcywgNCk7CisKKwkJZHJtX3ByaW50ZigmcCwgIiAgJWQgJXNzIChs YXN0IGF0ICU1bGx1LiUwNmxsdSk6XG4lcyIsCisJCQkgICBlbnRyeS0+Y291bnQsCisJCQkgICB0 b3BvbG9neV9yZWZfdHlwZV90b19zdHIoZW50cnktPnR5cGUpLAorCQkJICAgdHNfbnNlYywgcmVt X25zZWMgLyAxMDAwLCBidWYpOworCX0KKworCS8qIE5vdyBmcmVlIHRoZSBoaXN0b3J5LCBzaW5j ZSB0aGlzIGlzIHRoZSBvbmx5IHRpbWUgd2UgZXhwb3NlIGl0ICovCisJa2ZyZWUoaGlzdG9yeS0+ ZW50cmllcyk7CitvdXQ6CisJa2ZyZWUoYnVmKTsKK30KKworc3RhdGljIF9fYWx3YXlzX2lubGlu ZSB2b2lkCitkcm1fZHBfbXN0X2R1bXBfbXN0Yl90b3BvbG9neV9oaXN0b3J5KHN0cnVjdCBkcm1f ZHBfbXN0X2JyYW5jaCAqbXN0YikKK3sKKwlfX2R1bXBfdG9wb2xvZ3lfcmVmX2hpc3RvcnkoJm1z dGItPnRvcG9sb2d5X3JlZl9oaXN0b3J5LCBtc3RiLAorCQkJCSAgICAiTVNUQiIpOworfQorCitz dGF0aWMgX19hbHdheXNfaW5saW5lIHZvaWQKK2RybV9kcF9tc3RfZHVtcF9wb3J0X3RvcG9sb2d5 X2hpc3Rvcnkoc3RydWN0IGRybV9kcF9tc3RfcG9ydCAqcG9ydCkKK3sKKwlfX2R1bXBfdG9wb2xv Z3lfcmVmX2hpc3RvcnkoJnBvcnQtPnRvcG9sb2d5X3JlZl9oaXN0b3J5LCBwb3J0LAorCQkJCSAg ICAiUG9ydCIpOworfQorCitzdGF0aWMgX19hbHdheXNfaW5saW5lIHZvaWQKK3NhdmVfbXN0Yl90 b3BvbG9neV9yZWYoc3RydWN0IGRybV9kcF9tc3RfYnJhbmNoICptc3RiLAorCQkgICAgICAgZW51 bSBkcm1fZHBfbXN0X3RvcG9sb2d5X3JlZl90eXBlIHR5cGUpCit7CisJX190b3BvbG9neV9yZWZf c2F2ZShtc3RiLT5tZ3IsICZtc3RiLT50b3BvbG9neV9yZWZfaGlzdG9yeSwgdHlwZSk7Cit9CisK K3N0YXRpYyBfX2Fsd2F5c19pbmxpbmUgdm9pZAorc2F2ZV9wb3J0X3RvcG9sb2d5X3JlZihzdHJ1 Y3QgZHJtX2RwX21zdF9wb3J0ICpwb3J0LAorCQkgICAgICAgZW51bSBkcm1fZHBfbXN0X3RvcG9s b2d5X3JlZl90eXBlIHR5cGUpCit7CisJX190b3BvbG9neV9yZWZfc2F2ZShwb3J0LT5tZ3IsICZw b3J0LT50b3BvbG9neV9yZWZfaGlzdG9yeSwgdHlwZSk7Cit9CisKK3N0YXRpYyBpbmxpbmUgdm9p ZAordG9wb2xvZ3lfcmVmX2hpc3RvcnlfbG9jayhzdHJ1Y3QgZHJtX2RwX21zdF90b3BvbG9neV9t Z3IgKm1ncikKK3sKKwltdXRleF9sb2NrKCZtZ3ItPnRvcG9sb2d5X3JlZl9oaXN0b3J5X2xvY2sp OworfQorCitzdGF0aWMgaW5saW5lIHZvaWQKK3RvcG9sb2d5X3JlZl9oaXN0b3J5X3VubG9jayhz dHJ1Y3QgZHJtX2RwX21zdF90b3BvbG9neV9tZ3IgKm1ncikKK3sKKwltdXRleF91bmxvY2soJm1n ci0+dG9wb2xvZ3lfcmVmX2hpc3RvcnlfbG9jayk7Cit9CisjZWxzZQorc3RhdGljIGlubGluZSB2 b2lkCit0b3BvbG9neV9yZWZfaGlzdG9yeV9sb2NrKHN0cnVjdCBkcm1fZHBfbXN0X3RvcG9sb2d5 X21nciAqbWdyKSB7fQorc3RhdGljIGlubGluZSB2b2lkCit0b3BvbG9neV9yZWZfaGlzdG9yeV91 bmxvY2soc3RydWN0IGRybV9kcF9tc3RfdG9wb2xvZ3lfbWdyICptZ3IpIHt9CitzdGF0aWMgaW5s aW5lIHZvaWQKK2RybV9kcF9tc3RfZHVtcF9tc3RiX3RvcG9sb2d5X2hpc3Rvcnkoc3RydWN0IGRy bV9kcF9tc3RfYnJhbmNoICptc3RiKSB7fQorc3RhdGljIGlubGluZSB2b2lkCitkcm1fZHBfbXN0 X2R1bXBfcG9ydF90b3BvbG9neV9oaXN0b3J5KHN0cnVjdCBkcm1fZHBfbXN0X3BvcnQgKnBvcnQp IHt9CisjZGVmaW5lIHNhdmVfbXN0Yl90b3BvbG9neV9yZWYobXN0YiwgdHlwZSkKKyNkZWZpbmUg c2F2ZV9wb3J0X3RvcG9sb2d5X3JlZihwb3J0LCB0eXBlKQorI2VuZGlmCisKIHN0YXRpYyB2b2lk IGRybV9kcF9kZXN0cm95X21zdF9icmFuY2hfZGV2aWNlKHN0cnVjdCBrcmVmICprcmVmKQogewog CXN0cnVjdCBkcm1fZHBfbXN0X2JyYW5jaCAqbXN0YiA9CiAJCWNvbnRhaW5lcl9vZihrcmVmLCBz dHJ1Y3QgZHJtX2RwX21zdF9icmFuY2gsIHRvcG9sb2d5X2tyZWYpOwogCXN0cnVjdCBkcm1fZHBf bXN0X3RvcG9sb2d5X21nciAqbWdyID0gbXN0Yi0+bWdyOwogCisJZHJtX2RwX21zdF9kdW1wX21z dGJfdG9wb2xvZ3lfaGlzdG9yeShtc3RiKTsKKwogCUlOSVRfTElTVF9IRUFEKCZtc3RiLT5kZXN0 cm95X25leHQpOwogCiAJLyoKQEAgLTE0NDIsMTEgKzE2MjQsMTcgQEAgc3RhdGljIHZvaWQgZHJt X2RwX2Rlc3Ryb3lfbXN0X2JyYW5jaF9kZXZpY2Uoc3RydWN0IGtyZWYgKmtyZWYpCiBzdGF0aWMg aW50IF9fbXVzdF9jaGVjawogZHJtX2RwX21zdF90b3BvbG9neV90cnlfZ2V0X21zdGIoc3RydWN0 IGRybV9kcF9tc3RfYnJhbmNoICptc3RiKQogewotCWludCByZXQgPSBrcmVmX2dldF91bmxlc3Nf emVybygmbXN0Yi0+dG9wb2xvZ3lfa3JlZik7CisJaW50IHJldDsKIAotCWlmIChyZXQpCi0JCURS TV9ERUJVRygibXN0YiAlcCAoJWQpXG4iLCBtc3RiLAotCQkJICBrcmVmX3JlYWQoJm1zdGItPnRv cG9sb2d5X2tyZWYpKTsKKwl0b3BvbG9neV9yZWZfaGlzdG9yeV9sb2NrKG1zdGItPm1ncik7CisJ cmV0ID0ga3JlZl9nZXRfdW5sZXNzX3plcm8oJm1zdGItPnRvcG9sb2d5X2tyZWYpOworCWlmIChy ZXQpIHsKKwkJRFJNX0RFQlVHKCJtc3RiICVwICglZClcbiIsCisJCQkgIG1zdGIsIGtyZWZfcmVh ZCgmbXN0Yi0+dG9wb2xvZ3lfa3JlZikpOworCQlzYXZlX21zdGJfdG9wb2xvZ3lfcmVmKG1zdGIs IERSTV9EUF9NU1RfVE9QT0xPR1lfUkVGX0dFVCk7CisJfQorCisJdG9wb2xvZ3lfcmVmX2hpc3Rv cnlfdW5sb2NrKG1zdGItPm1ncik7CiAKIAlyZXR1cm4gcmV0OwogfQpAQCAtMTQ2Nyw5ICsxNjU1 LDE0IEBAIGRybV9kcF9tc3RfdG9wb2xvZ3lfdHJ5X2dldF9tc3RiKHN0cnVjdCBkcm1fZHBfbXN0 X2JyYW5jaCAqbXN0YikKICAqLwogc3RhdGljIHZvaWQgZHJtX2RwX21zdF90b3BvbG9neV9nZXRf bXN0YihzdHJ1Y3QgZHJtX2RwX21zdF9icmFuY2ggKm1zdGIpCiB7CisJdG9wb2xvZ3lfcmVmX2hp c3RvcnlfbG9jayhtc3RiLT5tZ3IpOworCisJc2F2ZV9tc3RiX3RvcG9sb2d5X3JlZihtc3RiLCBE Uk1fRFBfTVNUX1RPUE9MT0dZX1JFRl9HRVQpOwogCVdBUk5fT04oa3JlZl9yZWFkKCZtc3RiLT50 b3BvbG9neV9rcmVmKSA9PSAwKTsKIAlrcmVmX2dldCgmbXN0Yi0+dG9wb2xvZ3lfa3JlZik7CiAJ RFJNX0RFQlVHKCJtc3RiICVwICglZClcbiIsIG1zdGIsIGtyZWZfcmVhZCgmbXN0Yi0+dG9wb2xv Z3lfa3JlZikpOworCisJdG9wb2xvZ3lfcmVmX2hpc3RvcnlfdW5sb2NrKG1zdGItPm1ncik7CiB9 CiAKIC8qKgpAQCAtMTQ4Nyw4ICsxNjgwLDEzIEBAIHN0YXRpYyB2b2lkIGRybV9kcF9tc3RfdG9w b2xvZ3lfZ2V0X21zdGIoc3RydWN0IGRybV9kcF9tc3RfYnJhbmNoICptc3RiKQogc3RhdGljIHZv aWQKIGRybV9kcF9tc3RfdG9wb2xvZ3lfcHV0X21zdGIoc3RydWN0IGRybV9kcF9tc3RfYnJhbmNo ICptc3RiKQogeworCXRvcG9sb2d5X3JlZl9oaXN0b3J5X2xvY2sobXN0Yi0+bWdyKTsKKwogCURS TV9ERUJVRygibXN0YiAlcCAoJWQpXG4iLAogCQkgIG1zdGIsIGtyZWZfcmVhZCgmbXN0Yi0+dG9w b2xvZ3lfa3JlZikgLSAxKTsKKwlzYXZlX21zdGJfdG9wb2xvZ3lfcmVmKG1zdGIsIERSTV9EUF9N U1RfVE9QT0xPR1lfUkVGX1BVVCk7CisKKwl0b3BvbG9neV9yZWZfaGlzdG9yeV91bmxvY2sobXN0 Yi0+bWdyKTsKIAlrcmVmX3B1dCgmbXN0Yi0+dG9wb2xvZ3lfa3JlZiwgZHJtX2RwX2Rlc3Ryb3lf bXN0X2JyYW5jaF9kZXZpY2UpOwogfQogCkBAIC0xNDk4LDYgKzE2OTYsOCBAQCBzdGF0aWMgdm9p ZCBkcm1fZHBfZGVzdHJveV9wb3J0KHN0cnVjdCBrcmVmICprcmVmKQogCQljb250YWluZXJfb2Yo a3JlZiwgc3RydWN0IGRybV9kcF9tc3RfcG9ydCwgdG9wb2xvZ3lfa3JlZik7CiAJc3RydWN0IGRy bV9kcF9tc3RfdG9wb2xvZ3lfbWdyICptZ3IgPSBwb3J0LT5tZ3I7CiAKKwlkcm1fZHBfbXN0X2R1 bXBfcG9ydF90b3BvbG9neV9oaXN0b3J5KHBvcnQpOworCiAJLyogVGhlcmUncyBub3RoaW5nIHRo YXQgbmVlZHMgbG9ja2luZyB0byBkZXN0cm95IGFuIGlucHV0IHBvcnQgeWV0ICovCiAJaWYgKHBv cnQtPmlucHV0KSB7CiAJCWRybV9kcF9tc3RfcHV0X3BvcnRfbWFsbG9jKHBvcnQpOwpAQCAtMTU0 MSwxMiArMTc0MSwxNyBAQCBzdGF0aWMgdm9pZCBkcm1fZHBfZGVzdHJveV9wb3J0KHN0cnVjdCBr cmVmICprcmVmKQogc3RhdGljIGludCBfX211c3RfY2hlY2sKIGRybV9kcF9tc3RfdG9wb2xvZ3lf dHJ5X2dldF9wb3J0KHN0cnVjdCBkcm1fZHBfbXN0X3BvcnQgKnBvcnQpCiB7Ci0JaW50IHJldCA9 IGtyZWZfZ2V0X3VubGVzc196ZXJvKCZwb3J0LT50b3BvbG9neV9rcmVmKTsKKwlpbnQgcmV0Owog Ci0JaWYgKHJldCkKLQkJRFJNX0RFQlVHKCJwb3J0ICVwICglZClcbiIsIHBvcnQsCi0JCQkgIGty ZWZfcmVhZCgmcG9ydC0+dG9wb2xvZ3lfa3JlZikpOworCXRvcG9sb2d5X3JlZl9oaXN0b3J5X2xv Y2socG9ydC0+bWdyKTsKKwlyZXQgPSBrcmVmX2dldF91bmxlc3NfemVybygmcG9ydC0+dG9wb2xv Z3lfa3JlZik7CisJaWYgKHJldCkgeworCQlEUk1fREVCVUcoInBvcnQgJXAgKCVkKVxuIiwKKwkJ CSAgcG9ydCwga3JlZl9yZWFkKCZwb3J0LT50b3BvbG9neV9rcmVmKSk7CisJCXNhdmVfcG9ydF90 b3BvbG9neV9yZWYocG9ydCwgRFJNX0RQX01TVF9UT1BPTE9HWV9SRUZfR0VUKTsKKwl9CiAKKwl0 b3BvbG9neV9yZWZfaGlzdG9yeV91bmxvY2socG9ydC0+bWdyKTsKIAlyZXR1cm4gcmV0OwogfQog CkBAIC0xNTY1LDkgKzE3NzAsMTQgQEAgZHJtX2RwX21zdF90b3BvbG9neV90cnlfZ2V0X3BvcnQo c3RydWN0IGRybV9kcF9tc3RfcG9ydCAqcG9ydCkKICAqLwogc3RhdGljIHZvaWQgZHJtX2RwX21z dF90b3BvbG9neV9nZXRfcG9ydChzdHJ1Y3QgZHJtX2RwX21zdF9wb3J0ICpwb3J0KQogeworCXRv cG9sb2d5X3JlZl9oaXN0b3J5X2xvY2socG9ydC0+bWdyKTsKKwogCVdBUk5fT04oa3JlZl9yZWFk KCZwb3J0LT50b3BvbG9neV9rcmVmKSA9PSAwKTsKIAlrcmVmX2dldCgmcG9ydC0+dG9wb2xvZ3lf a3JlZik7CiAJRFJNX0RFQlVHKCJwb3J0ICVwICglZClcbiIsIHBvcnQsIGtyZWZfcmVhZCgmcG9y dC0+dG9wb2xvZ3lfa3JlZikpOworCXNhdmVfcG9ydF90b3BvbG9neV9yZWYocG9ydCwgRFJNX0RQ X01TVF9UT1BPTE9HWV9SRUZfR0VUKTsKKworCXRvcG9sb2d5X3JlZl9oaXN0b3J5X3VubG9jayhw b3J0LT5tZ3IpOwogfQogCiAvKioKQEAgLTE1ODMsOCArMTc5MywxMyBAQCBzdGF0aWMgdm9pZCBk cm1fZHBfbXN0X3RvcG9sb2d5X2dldF9wb3J0KHN0cnVjdCBkcm1fZHBfbXN0X3BvcnQgKnBvcnQp CiAgKi8KIHN0YXRpYyB2b2lkIGRybV9kcF9tc3RfdG9wb2xvZ3lfcHV0X3BvcnQoc3RydWN0IGRy bV9kcF9tc3RfcG9ydCAqcG9ydCkKIHsKLQlEUk1fREVCVUcoInBvcnQgJXAgKCVkKVxuIiwKLQkJ ICBwb3J0LCBrcmVmX3JlYWQoJnBvcnQtPnRvcG9sb2d5X2tyZWYpIC0gMSk7CisJdG9wb2xvZ3lf cmVmX2hpc3RvcnlfbG9jayhwb3J0LT5tZ3IpOworCisJRFJNX0RFQlVHKCJwb3J0ICVwLyVweCAo JWQpXG4iLAorCQkgIHBvcnQsIHBvcnQsIGtyZWZfcmVhZCgmcG9ydC0+dG9wb2xvZ3lfa3JlZikg LSAxKTsKKwlzYXZlX3BvcnRfdG9wb2xvZ3lfcmVmKHBvcnQsIERSTV9EUF9NU1RfVE9QT0xPR1lf UkVGX1BVVCk7CisKKwl0b3BvbG9neV9yZWZfaGlzdG9yeV91bmxvY2socG9ydC0+bWdyKTsKIAlr cmVmX3B1dCgmcG9ydC0+dG9wb2xvZ3lfa3JlZiwgZHJtX2RwX2Rlc3Ryb3lfcG9ydCk7CiB9CiAK QEAgLTQ1NzcsNiArNDc5Miw5IEBAIGludCBkcm1fZHBfbXN0X3RvcG9sb2d5X21ncl9pbml0KHN0 cnVjdCBkcm1fZHBfbXN0X3RvcG9sb2d5X21nciAqbWdyLAogCW11dGV4X2luaXQoJm1nci0+ZGVs YXllZF9kZXN0cm95X2xvY2spOwogCW11dGV4X2luaXQoJm1nci0+dXBfcmVxX2xvY2spOwogCW11 dGV4X2luaXQoJm1nci0+cHJvYmVfbG9jayk7CisjaWYgSVNfRU5BQkxFRChDT05GSUdfRFJNX0RF QlVHX0RQX01TVF9UT1BPTE9HWV9SRUZTKQorCW11dGV4X2luaXQoJm1nci0+dG9wb2xvZ3lfcmVm X2hpc3RvcnlfbG9jayk7CisjZW5kaWYKIAlJTklUX0xJU1RfSEVBRCgmbWdyLT50eF9tc2dfZG93 bnEpOwogCUlOSVRfTElTVF9IRUFEKCZtZ3ItPmRlc3Ryb3lfcG9ydF9saXN0KTsKIAlJTklUX0xJ U1RfSEVBRCgmbWdyLT5kZXN0cm95X2JyYW5jaF9kZXZpY2VfbGlzdCk7CkBAIC00NjQzLDYgKzQ4 NjEsOSBAQCB2b2lkIGRybV9kcF9tc3RfdG9wb2xvZ3lfbWdyX2Rlc3Ryb3koc3RydWN0IGRybV9k cF9tc3RfdG9wb2xvZ3lfbWdyICptZ3IpCiAJbXV0ZXhfZGVzdHJveSgmbWdyLT5sb2NrKTsKIAlt dXRleF9kZXN0cm95KCZtZ3ItPnVwX3JlcV9sb2NrKTsKIAltdXRleF9kZXN0cm95KCZtZ3ItPnBy b2JlX2xvY2spOworI2lmIElTX0VOQUJMRUQoQ09ORklHX0RSTV9ERUJVR19EUF9NU1RfVE9QT0xP R1lfUkVGUykKKwltdXRleF9kZXN0cm95KCZtZ3ItPnRvcG9sb2d5X3JlZl9oaXN0b3J5X2xvY2sp OworI2VuZGlmCiB9CiBFWFBPUlRfU1lNQk9MKGRybV9kcF9tc3RfdG9wb2xvZ3lfbWdyX2Rlc3Ry b3kpOwogCmRpZmYgLS1naXQgYS9pbmNsdWRlL2RybS9kcm1fZHBfbXN0X2hlbHBlci5oIGIvaW5j bHVkZS9kcm0vZHJtX2RwX21zdF9oZWxwZXIuaAppbmRleCAxNDQwMjdlMjc0NjQuLmQ1ZmM5MGIz MDQ4NyAxMDA2NDQKLS0tIGEvaW5jbHVkZS9kcm0vZHJtX2RwX21zdF9oZWxwZXIuaAorKysgYi9p bmNsdWRlL2RybS9kcm1fZHBfbXN0X2hlbHBlci5oCkBAIC0yNiw2ICsyNiwyNiBAQAogI2luY2x1 ZGUgPGRybS9kcm1fZHBfaGVscGVyLmg+CiAjaW5jbHVkZSA8ZHJtL2RybV9hdG9taWMuaD4KIAor I2lmIElTX0VOQUJMRUQoQ09ORklHX0RSTV9ERUJVR19EUF9NU1RfVE9QT0xPR1lfUkVGUykKKyNp bmNsdWRlIDxsaW51eC9zdGFja2RlcG90Lmg+CisjaW5jbHVkZSA8bGludXgvdGltZWtlZXBpbmcu aD4KKworZW51bSBkcm1fZHBfbXN0X3RvcG9sb2d5X3JlZl90eXBlIHsKKwlEUk1fRFBfTVNUX1RP UE9MT0dZX1JFRl9HRVQsCisJRFJNX0RQX01TVF9UT1BPTE9HWV9SRUZfUFVULAorfTsKKworc3Ry dWN0IGRybV9kcF9tc3RfdG9wb2xvZ3lfcmVmX2hpc3RvcnkgeworCXN0cnVjdCBkcm1fZHBfbXN0 X3RvcG9sb2d5X3JlZl9lbnRyeSB7CisJCWVudW0gZHJtX2RwX21zdF90b3BvbG9neV9yZWZfdHlw ZSB0eXBlOworCQlpbnQgY291bnQ7CisJCWt0aW1lX3QgdHNfbnNlYzsKKwkJZGVwb3Rfc3RhY2tf aGFuZGxlX3QgYmFja3RyYWNlOworCX0gKmVudHJpZXM7CisJaW50IGxlbjsKK307CisjZW5kaWYg LyogSVNfRU5BQkxFRChDT05GSUdfRFJNX0RFQlVHX0RQX01TVF9UT1BPTE9HWV9SRUZTKSAqLwor CiBzdHJ1Y3QgZHJtX2RwX21zdF9icmFuY2g7CiAKIC8qKgpAQCAtODksNiArMTA5LDE0IEBAIHN0 cnVjdCBkcm1fZHBfbXN0X3BvcnQgewogCSAqLwogCXN0cnVjdCBrcmVmIG1hbGxvY19rcmVmOwog CisjaWYgSVNfRU5BQkxFRChDT05GSUdfRFJNX0RFQlVHX0RQX01TVF9UT1BPTE9HWV9SRUZTKQor CS8qKgorCSAqIEB0b3BvbG9neV9yZWZfaGlzdG9yeTogQSBoaXN0b3J5IG9mIGVhY2ggdG9wb2xv Z3kKKwkgKiByZWZlcmVuY2UvZGVyZWZlcmVuY2UuIFNlZSBDT05GSUdfRFJNX0RFQlVHX0RQX01T VF9UT1BPTE9HWV9SRUZTLgorCSAqLworCXN0cnVjdCBkcm1fZHBfbXN0X3RvcG9sb2d5X3JlZl9o aXN0b3J5IHRvcG9sb2d5X3JlZl9oaXN0b3J5OworI2VuZGlmCisKIAl1OCBwb3J0X251bTsKIAli b29sIGlucHV0OwogCWJvb2wgbWNzOwpAQCAtMTYyLDYgKzE5MCwxNCBAQCBzdHJ1Y3QgZHJtX2Rw X21zdF9icmFuY2ggewogCSAqLwogCXN0cnVjdCBrcmVmIG1hbGxvY19rcmVmOwogCisjaWYgSVNf RU5BQkxFRChDT05GSUdfRFJNX0RFQlVHX0RQX01TVF9UT1BPTE9HWV9SRUZTKQorCS8qKgorCSAq IEB0b3BvbG9neV9yZWZfaGlzdG9yeTogQSBoaXN0b3J5IG9mIGVhY2ggdG9wb2xvZ3kKKwkgKiBy ZWZlcmVuY2UvZGVyZWZlcmVuY2UuIFNlZSBDT05GSUdfRFJNX0RFQlVHX0RQX01TVF9UT1BPTE9H WV9SRUZTLgorCSAqLworCXN0cnVjdCBkcm1fZHBfbXN0X3RvcG9sb2d5X3JlZl9oaXN0b3J5IHRv cG9sb2d5X3JlZl9oaXN0b3J5OworI2VuZGlmCisKIAkvKioKIAkgKiBAZGVzdHJveV9uZXh0OiBs aW5rZWQtbGlzdCBlbnRyeSB1c2VkIGJ5CiAJICogZHJtX2RwX2RlbGF5ZWRfZGVzdHJveV93b3Jr KCkKQEAgLTY0Nyw2ICs2ODMsMTUgQEAgc3RydWN0IGRybV9kcF9tc3RfdG9wb2xvZ3lfbWdyIHsK IAkgKiB0cmFuc21pc3Npb25zLgogCSAqLwogCXN0cnVjdCB3b3JrX3N0cnVjdCB1cF9yZXFfd29y azsKKworI2lmIElTX0VOQUJMRUQoQ09ORklHX0RSTV9ERUJVR19EUF9NU1RfVE9QT0xPR1lfUkVG UykKKwkvKioKKwkgKiBAdG9wb2xvZ3lfcmVmX2hpc3RvcnlfbG9jazogcHJvdGVjdHMKKwkgKiAm ZHJtX2RwX21zdF9wb3J0LnRvcG9sb2d5X3JlZl9oaXN0b3J5IGFuZAorCSAqICZkcm1fZHBfbXN0 X2JyYW5jaC50b3BvbG9neV9yZWZfaGlzdG9yeS4KKwkgKi8KKwlzdHJ1Y3QgbXV0ZXggdG9wb2xv Z3lfcmVmX2hpc3RvcnlfbG9jazsKKyNlbmRpZgogfTsKIAogaW50IGRybV9kcF9tc3RfdG9wb2xv Z3lfbWdyX2luaXQoc3RydWN0IGRybV9kcF9tc3RfdG9wb2xvZ3lfbWdyICptZ3IsCi0tIAoyLjIx LjAKCl9fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fCmRyaS1k ZXZlbCBtYWlsaW5nIGxpc3QKZHJpLWRldmVsQGxpc3RzLmZyZWVkZXNrdG9wLm9yZwpodHRwczov L2xpc3RzLmZyZWVkZXNrdG9wLm9yZy9tYWlsbWFuL2xpc3RpbmZvL2RyaS1kZXZlbA== 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 CF9AECA9EB0 for ; Tue, 22 Oct 2019 02:42:11 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [209.132.180.67]) by mail.kernel.org (Postfix) with ESMTP id 928F420882 for ; Tue, 22 Oct 2019 02:42:11 +0000 (UTC) Authentication-Results: mail.kernel.org; dkim=pass (1024-bit key) header.d=redhat.com header.i=@redhat.com header.b="H259MJcB" Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1730919AbfJVCmK (ORCPT ); Mon, 21 Oct 2019 22:42:10 -0400 Received: from us-smtp-delivery-1.mimecast.com ([207.211.31.120]:22279 "EHLO us-smtp-1.mimecast.com" rhost-flags-OK-OK-OK-FAIL) by vger.kernel.org with ESMTP id S1729573AbfJVCmJ (ORCPT ); Mon, 21 Oct 2019 22:42:09 -0400 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=redhat.com; s=mimecast20190719; t=1571712127; 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=lrcURt96aE5EHVhNmaVNmOBVnWTfjuiDFNgRlZ76m00=; b=H259MJcBlvzfVtvDtqPVr0mD6ufGeMLCnYuACF2mgcXIU3QvdKeagKTUaNj6VQyC/IGgya 7XgKAJE+OJOuHFz/7+Jeu9dQPGieDFC1ae2u9AszpexqQ8/SuUzrj7F1ibSplxJmsQuO3Z uriXOxhcqHfLXLEhKnMAog8bmmDjGag= 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-339-nK0cvsgiNnaIyuCaZEGfBQ-1; Mon, 21 Oct 2019 22:42:03 -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 617EB800D41; Tue, 22 Oct 2019 02:42:01 +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 66B8660126; Tue, 22 Oct 2019 02:41:58 +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 , Maarten Lankhorst , Maxime Ripard , David Airlie , Daniel Vetter , linux-kernel@vger.kernel.org Subject: [PATCH v5 14/14] drm/dp_mst: Add topology ref history tracking for debugging Date: Mon, 21 Oct 2019 22:36:09 -0400 Message-Id: <20191022023641.8026-15-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: nK0cvsgiNnaIyuCaZEGfBQ-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 For very subtle mistakes with topology refs, it can be rather difficult to trace them down with the debugging info that we already have. I had one such issue recently while trying to implement suspend/resume reprobing for MST, and ended up coming up with this. Inspired by Chris Wilson's wakeref tracking for i915, this adds a very similar feature to the DP MST helpers, which allows for partial tracking of topology refs for both ports and branch devices. This is a lot less advanced then wakeref tracking: we merely keep a count of all of the spots where a topology ref has been grabbed or dropped, then dump out that history in chronological order when a port or branch device's topology refcount reaches 0. So far, I've found this incredibly useful for debugging topology refcount errors. Since this has the potential to be somewhat slow and loud, we add an expert kernel config option to enable or disable this feature, CONFIG_DRM_DEBUG_DP_MST_TOPOLOGY_REFS. Changes since v1: * Don't forget to destroy topology_ref_history_lock Changes since v4: * Correct order of kref_put()/topology_ref_history_unlock - we can't unlock the history after kref_put() since the memory might have been freed by that point * Don't print message on allocation error failures, the kernel already does this for us Cc: Juston Li Cc: Imre Deak Cc: Ville Syrj=C3=A4l=C3=A4 Cc: Harry Wentland Cc: Daniel Vetter Reviewed-by: Sean Paul Signed-off-by: Lyude Paul --- drivers/gpu/drm/Kconfig | 14 ++ drivers/gpu/drm/drm_dp_mst_topology.c | 241 ++++++++++++++++++++++++-- include/drm/drm_dp_mst_helper.h | 45 +++++ 3 files changed, 290 insertions(+), 10 deletions(-) diff --git a/drivers/gpu/drm/Kconfig b/drivers/gpu/drm/Kconfig index 36357a36a281..f3f5910743d4 100644 --- a/drivers/gpu/drm/Kconfig +++ b/drivers/gpu/drm/Kconfig @@ -93,6 +93,20 @@ config DRM_KMS_FB_HELPER =09help =09 FBDEV helpers for KMS drivers. =20 +config DRM_DEBUG_DP_MST_TOPOLOGY_REFS + bool "Enable refcount backtrace history in the DP MST helpers" + select STACKDEPOT + depends on DRM_KMS_HELPER + depends on DEBUG_KERNEL + depends on EXPERT + help + Enables debug tracing for topology refs in DRM's DP MST helpers.= A + history of each topology reference/dereference will be printed t= o the + kernel log once a port or branch device's topology refcount reac= hes 0. + + This has the potential to use a lot of memory and print some ver= y + large kernel messages. If in doubt, say "N". + config DRM_FBDEV_EMULATION =09bool "Enable legacy fbdev support for your modesetting driver" =09depends on DRM diff --git a/drivers/gpu/drm/drm_dp_mst_topology.c b/drivers/gpu/drm/drm_dp= _mst_topology.c index 428160270482..cedfa281a22e 100644 --- a/drivers/gpu/drm/drm_dp_mst_topology.c +++ b/drivers/gpu/drm/drm_dp_mst_topology.c @@ -28,6 +28,13 @@ #include #include =20 +#if IS_ENABLED(CONFIG_DRM_DEBUG_DP_MST_TOPOLOGY_REFS) +#include +#include +#include +#include +#endif + #include #include #include @@ -1399,12 +1406,187 @@ drm_dp_mst_put_port_malloc(struct drm_dp_mst_port = *port) } EXPORT_SYMBOL(drm_dp_mst_put_port_malloc); =20 +#if IS_ENABLED(CONFIG_DRM_DEBUG_DP_MST_TOPOLOGY_REFS) + +#define STACK_DEPTH 8 + +static noinline void +__topology_ref_save(struct drm_dp_mst_topology_mgr *mgr, +=09=09 struct drm_dp_mst_topology_ref_history *history, +=09=09 enum drm_dp_mst_topology_ref_type type) +{ +=09struct drm_dp_mst_topology_ref_entry *entry =3D NULL; +=09depot_stack_handle_t backtrace; +=09ulong stack_entries[STACK_DEPTH]; +=09uint n; +=09int i; + +=09n =3D stack_trace_save(stack_entries, ARRAY_SIZE(stack_entries), 1); +=09backtrace =3D stack_depot_save(stack_entries, n, GFP_KERNEL); +=09if (!backtrace) +=09=09return; + +=09/* Try to find an existing entry for this backtrace */ +=09for (i =3D 0; i < history->len; i++) { +=09=09if (history->entries[i].backtrace =3D=3D backtrace) { +=09=09=09entry =3D &history->entries[i]; +=09=09=09break; +=09=09} +=09} + +=09/* Otherwise add one */ +=09if (!entry) { +=09=09struct drm_dp_mst_topology_ref_entry *new; +=09=09int new_len =3D history->len + 1; + +=09=09new =3D krealloc(history->entries, sizeof(*new) * new_len, +=09=09=09 GFP_KERNEL); +=09=09if (!new) +=09=09=09return; + +=09=09entry =3D &new[history->len]; +=09=09history->len =3D new_len; +=09=09history->entries =3D new; + +=09=09entry->backtrace =3D backtrace; +=09=09entry->type =3D type; +=09=09entry->count =3D 0; +=09} +=09entry->count++; +=09entry->ts_nsec =3D ktime_get_ns(); + +=09return; +} + +static int +topology_ref_history_cmp(const void *a, const void *b) +{ +=09const struct drm_dp_mst_topology_ref_entry *entry_a =3D a, *entry_b =3D= b; + +=09if (entry_a->ts_nsec > entry_b->ts_nsec) +=09=09return 1; +=09else if (entry_a->ts_nsec < entry_b->ts_nsec) +=09=09return -1; +=09else +=09=09return 0; +} + +static inline const char * +topology_ref_type_to_str(enum drm_dp_mst_topology_ref_type type) +{ +=09if (type =3D=3D DRM_DP_MST_TOPOLOGY_REF_GET) +=09=09return "get"; +=09else +=09=09return "put"; +} + +static void +__dump_topology_ref_history(struct drm_dp_mst_topology_ref_history *histor= y, +=09=09=09 void *ptr, const char *type_str) +{ +=09struct drm_printer p =3D drm_debug_printer(DBG_PREFIX); +=09char *buf =3D kzalloc(PAGE_SIZE, GFP_KERNEL); +=09int i; + +=09if (!buf) +=09=09return; + +=09if (!history->len) +=09=09goto out; + +=09/* First, sort the list so that it goes from oldest to newest +=09 * reference entry +=09 */ +=09sort(history->entries, history->len, sizeof(*history->entries), +=09 topology_ref_history_cmp, NULL); + +=09drm_printf(&p, +=09=09 "%s (%p/%px) topology count reached 0, dumping history:\n", +=09=09 type_str, ptr, ptr); + +=09for (i =3D 0; i < history->len; i++) { +=09=09const struct drm_dp_mst_topology_ref_entry *entry =3D +=09=09=09&history->entries[i]; +=09=09ulong *entries; +=09=09uint nr_entries; +=09=09u64 ts_nsec =3D entry->ts_nsec; +=09=09u64 rem_nsec =3D do_div(ts_nsec, 1000000000); + +=09=09nr_entries =3D stack_depot_fetch(entry->backtrace, &entries); +=09=09stack_trace_snprint(buf, PAGE_SIZE, entries, nr_entries, 4); + +=09=09drm_printf(&p, " %d %ss (last at %5llu.%06llu):\n%s", +=09=09=09 entry->count, +=09=09=09 topology_ref_type_to_str(entry->type), +=09=09=09 ts_nsec, rem_nsec / 1000, buf); +=09} + +=09/* Now free the history, since this is the only time we expose it */ +=09kfree(history->entries); +out: +=09kfree(buf); +} + +static __always_inline void +drm_dp_mst_dump_mstb_topology_history(struct drm_dp_mst_branch *mstb) +{ +=09__dump_topology_ref_history(&mstb->topology_ref_history, mstb, +=09=09=09=09 "MSTB"); +} + +static __always_inline void +drm_dp_mst_dump_port_topology_history(struct drm_dp_mst_port *port) +{ +=09__dump_topology_ref_history(&port->topology_ref_history, port, +=09=09=09=09 "Port"); +} + +static __always_inline void +save_mstb_topology_ref(struct drm_dp_mst_branch *mstb, +=09=09 enum drm_dp_mst_topology_ref_type type) +{ +=09__topology_ref_save(mstb->mgr, &mstb->topology_ref_history, type); +} + +static __always_inline void +save_port_topology_ref(struct drm_dp_mst_port *port, +=09=09 enum drm_dp_mst_topology_ref_type type) +{ +=09__topology_ref_save(port->mgr, &port->topology_ref_history, type); +} + +static inline void +topology_ref_history_lock(struct drm_dp_mst_topology_mgr *mgr) +{ +=09mutex_lock(&mgr->topology_ref_history_lock); +} + +static inline void +topology_ref_history_unlock(struct drm_dp_mst_topology_mgr *mgr) +{ +=09mutex_unlock(&mgr->topology_ref_history_lock); +} +#else +static inline void +topology_ref_history_lock(struct drm_dp_mst_topology_mgr *mgr) {} +static inline void +topology_ref_history_unlock(struct drm_dp_mst_topology_mgr *mgr) {} +static inline void +drm_dp_mst_dump_mstb_topology_history(struct drm_dp_mst_branch *mstb) {} +static inline void +drm_dp_mst_dump_port_topology_history(struct drm_dp_mst_port *port) {} +#define save_mstb_topology_ref(mstb, type) +#define save_port_topology_ref(port, type) +#endif + static void drm_dp_destroy_mst_branch_device(struct kref *kref) { =09struct drm_dp_mst_branch *mstb =3D =09=09container_of(kref, struct drm_dp_mst_branch, topology_kref); =09struct drm_dp_mst_topology_mgr *mgr =3D mstb->mgr; =20 +=09drm_dp_mst_dump_mstb_topology_history(mstb); + =09INIT_LIST_HEAD(&mstb->destroy_next); =20 =09/* @@ -1442,11 +1624,17 @@ static void drm_dp_destroy_mst_branch_device(struct= kref *kref) static int __must_check drm_dp_mst_topology_try_get_mstb(struct drm_dp_mst_branch *mstb) { -=09int ret =3D kref_get_unless_zero(&mstb->topology_kref); +=09int ret; =20 -=09if (ret) -=09=09DRM_DEBUG("mstb %p (%d)\n", mstb, -=09=09=09 kref_read(&mstb->topology_kref)); +=09topology_ref_history_lock(mstb->mgr); +=09ret =3D kref_get_unless_zero(&mstb->topology_kref); +=09if (ret) { +=09=09DRM_DEBUG("mstb %p (%d)\n", +=09=09=09 mstb, kref_read(&mstb->topology_kref)); +=09=09save_mstb_topology_ref(mstb, DRM_DP_MST_TOPOLOGY_REF_GET); +=09} + +=09topology_ref_history_unlock(mstb->mgr); =20 =09return ret; } @@ -1467,9 +1655,14 @@ drm_dp_mst_topology_try_get_mstb(struct drm_dp_mst_b= ranch *mstb) */ static void drm_dp_mst_topology_get_mstb(struct drm_dp_mst_branch *mstb) { +=09topology_ref_history_lock(mstb->mgr); + +=09save_mstb_topology_ref(mstb, DRM_DP_MST_TOPOLOGY_REF_GET); =09WARN_ON(kref_read(&mstb->topology_kref) =3D=3D 0); =09kref_get(&mstb->topology_kref); =09DRM_DEBUG("mstb %p (%d)\n", mstb, kref_read(&mstb->topology_kref)); + +=09topology_ref_history_unlock(mstb->mgr); } =20 /** @@ -1487,8 +1680,13 @@ static void drm_dp_mst_topology_get_mstb(struct drm_= dp_mst_branch *mstb) static void drm_dp_mst_topology_put_mstb(struct drm_dp_mst_branch *mstb) { +=09topology_ref_history_lock(mstb->mgr); + =09DRM_DEBUG("mstb %p (%d)\n", =09=09 mstb, kref_read(&mstb->topology_kref) - 1); +=09save_mstb_topology_ref(mstb, DRM_DP_MST_TOPOLOGY_REF_PUT); + +=09topology_ref_history_unlock(mstb->mgr); =09kref_put(&mstb->topology_kref, drm_dp_destroy_mst_branch_device); } =20 @@ -1498,6 +1696,8 @@ static void drm_dp_destroy_port(struct kref *kref) =09=09container_of(kref, struct drm_dp_mst_port, topology_kref); =09struct drm_dp_mst_topology_mgr *mgr =3D port->mgr; =20 +=09drm_dp_mst_dump_port_topology_history(port); + =09/* There's nothing that needs locking to destroy an input port yet */ =09if (port->input) { =09=09drm_dp_mst_put_port_malloc(port); @@ -1541,12 +1741,17 @@ static void drm_dp_destroy_port(struct kref *kref) static int __must_check drm_dp_mst_topology_try_get_port(struct drm_dp_mst_port *port) { -=09int ret =3D kref_get_unless_zero(&port->topology_kref); +=09int ret; =20 -=09if (ret) -=09=09DRM_DEBUG("port %p (%d)\n", port, -=09=09=09 kref_read(&port->topology_kref)); +=09topology_ref_history_lock(port->mgr); +=09ret =3D kref_get_unless_zero(&port->topology_kref); +=09if (ret) { +=09=09DRM_DEBUG("port %p (%d)\n", +=09=09=09 port, kref_read(&port->topology_kref)); +=09=09save_port_topology_ref(port, DRM_DP_MST_TOPOLOGY_REF_GET); +=09} =20 +=09topology_ref_history_unlock(port->mgr); =09return ret; } =20 @@ -1565,9 +1770,14 @@ drm_dp_mst_topology_try_get_port(struct drm_dp_mst_p= ort *port) */ static void drm_dp_mst_topology_get_port(struct drm_dp_mst_port *port) { +=09topology_ref_history_lock(port->mgr); + =09WARN_ON(kref_read(&port->topology_kref) =3D=3D 0); =09kref_get(&port->topology_kref); =09DRM_DEBUG("port %p (%d)\n", port, kref_read(&port->topology_kref)); +=09save_port_topology_ref(port, DRM_DP_MST_TOPOLOGY_REF_GET); + +=09topology_ref_history_unlock(port->mgr); } =20 /** @@ -1583,8 +1793,13 @@ static void drm_dp_mst_topology_get_port(struct drm_= dp_mst_port *port) */ static void drm_dp_mst_topology_put_port(struct drm_dp_mst_port *port) { -=09DRM_DEBUG("port %p (%d)\n", -=09=09 port, kref_read(&port->topology_kref) - 1); +=09topology_ref_history_lock(port->mgr); + +=09DRM_DEBUG("port %p/%px (%d)\n", +=09=09 port, port, kref_read(&port->topology_kref) - 1); +=09save_port_topology_ref(port, DRM_DP_MST_TOPOLOGY_REF_PUT); + +=09topology_ref_history_unlock(port->mgr); =09kref_put(&port->topology_kref, drm_dp_destroy_port); } =20 @@ -4577,6 +4792,9 @@ int drm_dp_mst_topology_mgr_init(struct drm_dp_mst_to= pology_mgr *mgr, =09mutex_init(&mgr->delayed_destroy_lock); =09mutex_init(&mgr->up_req_lock); =09mutex_init(&mgr->probe_lock); +#if IS_ENABLED(CONFIG_DRM_DEBUG_DP_MST_TOPOLOGY_REFS) +=09mutex_init(&mgr->topology_ref_history_lock); +#endif =09INIT_LIST_HEAD(&mgr->tx_msg_downq); =09INIT_LIST_HEAD(&mgr->destroy_port_list); =09INIT_LIST_HEAD(&mgr->destroy_branch_device_list); @@ -4643,6 +4861,9 @@ void drm_dp_mst_topology_mgr_destroy(struct drm_dp_ms= t_topology_mgr *mgr) =09mutex_destroy(&mgr->lock); =09mutex_destroy(&mgr->up_req_lock); =09mutex_destroy(&mgr->probe_lock); +#if IS_ENABLED(CONFIG_DRM_DEBUG_DP_MST_TOPOLOGY_REFS) +=09mutex_destroy(&mgr->topology_ref_history_lock); +#endif } EXPORT_SYMBOL(drm_dp_mst_topology_mgr_destroy); =20 diff --git a/include/drm/drm_dp_mst_helper.h b/include/drm/drm_dp_mst_helpe= r.h index 144027e27464..d5fc90b30487 100644 --- a/include/drm/drm_dp_mst_helper.h +++ b/include/drm/drm_dp_mst_helper.h @@ -26,6 +26,26 @@ #include #include =20 +#if IS_ENABLED(CONFIG_DRM_DEBUG_DP_MST_TOPOLOGY_REFS) +#include +#include + +enum drm_dp_mst_topology_ref_type { +=09DRM_DP_MST_TOPOLOGY_REF_GET, +=09DRM_DP_MST_TOPOLOGY_REF_PUT, +}; + +struct drm_dp_mst_topology_ref_history { +=09struct drm_dp_mst_topology_ref_entry { +=09=09enum drm_dp_mst_topology_ref_type type; +=09=09int count; +=09=09ktime_t ts_nsec; +=09=09depot_stack_handle_t backtrace; +=09} *entries; +=09int len; +}; +#endif /* IS_ENABLED(CONFIG_DRM_DEBUG_DP_MST_TOPOLOGY_REFS) */ + struct drm_dp_mst_branch; =20 /** @@ -89,6 +109,14 @@ struct drm_dp_mst_port { =09 */ =09struct kref malloc_kref; =20 +#if IS_ENABLED(CONFIG_DRM_DEBUG_DP_MST_TOPOLOGY_REFS) +=09/** +=09 * @topology_ref_history: A history of each topology +=09 * reference/dereference. See CONFIG_DRM_DEBUG_DP_MST_TOPOLOGY_REFS. +=09 */ +=09struct drm_dp_mst_topology_ref_history topology_ref_history; +#endif + =09u8 port_num; =09bool input; =09bool mcs; @@ -162,6 +190,14 @@ struct drm_dp_mst_branch { =09 */ =09struct kref malloc_kref; =20 +#if IS_ENABLED(CONFIG_DRM_DEBUG_DP_MST_TOPOLOGY_REFS) +=09/** +=09 * @topology_ref_history: A history of each topology +=09 * reference/dereference. See CONFIG_DRM_DEBUG_DP_MST_TOPOLOGY_REFS. +=09 */ +=09struct drm_dp_mst_topology_ref_history topology_ref_history; +#endif + =09/** =09 * @destroy_next: linked-list entry used by =09 * drm_dp_delayed_destroy_work() @@ -647,6 +683,15 @@ struct drm_dp_mst_topology_mgr { =09 * transmissions. =09 */ =09struct work_struct up_req_work; + +#if IS_ENABLED(CONFIG_DRM_DEBUG_DP_MST_TOPOLOGY_REFS) +=09/** +=09 * @topology_ref_history_lock: protects +=09 * &drm_dp_mst_port.topology_ref_history and +=09 * &drm_dp_mst_branch.topology_ref_history. +=09 */ +=09struct mutex topology_ref_history_lock; +#endif }; =20 int drm_dp_mst_topology_mgr_init(struct drm_dp_mst_topology_mgr *mgr, --=20 2.21.0