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=-16.8 required=3.0 tests=BAYES_00, HEADER_FROM_DIFFERENT_DOMAINS,INCLUDES_CR_TRAILER,INCLUDES_PATCH, MAILING_LIST_MULTI,SPF_HELO_NONE,SPF_PASS,URIBL_BLOCKED,USER_AGENT_GIT 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 40E58C07E9B for ; Tue, 20 Jul 2021 20:40:22 +0000 (UTC) Received: from gabe.freedesktop.org (gabe.freedesktop.org [131.252.210.177]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by mail.kernel.org (Postfix) with ESMTPS id 0733A60FEA for ; Tue, 20 Jul 2021 20:40:22 +0000 (UTC) DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org 0733A60FEA Authentication-Results: mail.kernel.org; dmarc=fail (p=none dis=none) header.from=intel.com Authentication-Results: mail.kernel.org; spf=none smtp.mailfrom=intel-gfx-bounces@lists.freedesktop.org Received: from gabe.freedesktop.org (localhost [127.0.0.1]) by gabe.freedesktop.org (Postfix) with ESMTP id F05376E49F; Tue, 20 Jul 2021 20:40:17 +0000 (UTC) Received: from mga04.intel.com (mga04.intel.com [192.55.52.120]) by gabe.freedesktop.org (Postfix) with ESMTPS id 5C049899FF; Tue, 20 Jul 2021 20:40:16 +0000 (UTC) X-IronPort-AV: E=McAfee;i="6200,9189,10051"; a="209421874" X-IronPort-AV: E=Sophos;i="5.84,256,1620716400"; d="scan'208";a="209421874" Received: from orsmga006.jf.intel.com ([10.7.209.51]) by fmsmga104.fm.intel.com with ESMTP/TLS/ECDHE-RSA-AES256-GCM-SHA384; 20 Jul 2021 13:40:15 -0700 X-IronPort-AV: E=Sophos;i="5.84,256,1620716400"; d="scan'208";a="414906054" Received: from dhiatt-server.jf.intel.com ([10.54.81.3]) by orsmga006-auth.jf.intel.com with ESMTP/TLS/ECDHE-RSA-AES256-GCM-SHA384; 20 Jul 2021 13:40:14 -0700 From: Matthew Brost To: , Date: Tue, 20 Jul 2021 13:57:21 -0700 Message-Id: <20210720205802.39610-2-matthew.brost@intel.com> X-Mailer: git-send-email 2.28.0 In-Reply-To: <20210720205802.39610-1-matthew.brost@intel.com> References: <20210720205802.39610-1-matthew.brost@intel.com> MIME-Version: 1.0 Subject: [Intel-gfx] [RFC PATCH 01/42] drm/i915/guc: GuC submission squashed into single patch X-BeenThere: intel-gfx@lists.freedesktop.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: Intel graphics driver community testing & development List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Errors-To: intel-gfx-bounces@lists.freedesktop.org Sender: "Intel-gfx" aHR0cHM6Ly9wYXRjaHdvcmsuZnJlZWRlc2t0b3Aub3JnL3Nlcmllcy85MTg0MC8KClNpZ25lZC1v ZmYtYnk6IE1hdHRoZXcgQnJvc3QgPG1hdHRoZXcuYnJvc3RAaW50ZWwuY29tPgotLS0KIGRyaXZl cnMvZ3B1L2RybS9pOTE1L01ha2VmaWxlICAgICAgICAgICAgICAgICB8ICAgIDEgKwogZHJpdmVy cy9ncHUvZHJtL2k5MTUvZ2VtL2k5MTVfZ2VtX2NvbnRleHQuYyAgIHwgICAyMSArLQogZHJpdmVy cy9ncHUvZHJtL2k5MTUvZ2VtL2k5MTVfZ2VtX21tYW4uYyAgICAgIHwgICAgMyArLQogZHJpdmVy cy9ncHUvZHJtL2k5MTUvZ3QvZ2VuOF9lbmdpbmVfY3MuYyAgICAgIHwgICAgNiArLQogZHJpdmVy cy9ncHUvZHJtL2k5MTUvZ3QvaW50ZWxfYnJlYWRjcnVtYnMuYyAgIHwgICA0NCArLQogZHJpdmVy cy9ncHUvZHJtL2k5MTUvZ3QvaW50ZWxfYnJlYWRjcnVtYnMuaCAgIHwgICAxNiArLQogLi4uL2dw dS9kcm0vaTkxNS9ndC9pbnRlbF9icmVhZGNydW1ic190eXBlcy5oIHwgICAgNyArCiBkcml2ZXJz L2dwdS9kcm0vaTkxNS9ndC9pbnRlbF9jb250ZXh0LmMgICAgICAgfCAgIDUwICstCiBkcml2ZXJz L2dwdS9kcm0vaTkxNS9ndC9pbnRlbF9jb250ZXh0LmggICAgICAgfCAgIDUwICstCiBkcml2ZXJz L2dwdS9kcm0vaTkxNS9ndC9pbnRlbF9jb250ZXh0X3R5cGVzLmggfCAgIDYzICstCiBkcml2ZXJz L2dwdS9kcm0vaTkxNS9ndC9pbnRlbF9lbmdpbmUuaCAgICAgICAgfCAgIDU3ICstCiBkcml2ZXJz L2dwdS9kcm0vaTkxNS9ndC9pbnRlbF9lbmdpbmVfY3MuYyAgICAgfCAgMTgyICstCiAuLi4vZ3B1 L2RybS9pOTE1L2d0L2ludGVsX2VuZ2luZV9oZWFydGJlYXQuYyAgfCAgIDcxICstCiAuLi4vZ3B1 L2RybS9pOTE1L2d0L2ludGVsX2VuZ2luZV9oZWFydGJlYXQuaCAgfCAgICA0ICsKIGRyaXZlcnMv Z3B1L2RybS9pOTE1L2d0L2ludGVsX2VuZ2luZV90eXBlcy5oICB8ICAgMTMgKy0KIGRyaXZlcnMv Z3B1L2RybS9pOTE1L2d0L2ludGVsX2VuZ2luZV91c2VyLmMgICB8ICAgIDQgKwogLi4uL2RybS9p OTE1L2d0L2ludGVsX2V4ZWNsaXN0c19zdWJtaXNzaW9uLmMgIHwgICA4OSArLQogLi4uL2RybS9p OTE1L2d0L2ludGVsX2V4ZWNsaXN0c19zdWJtaXNzaW9uLmggIHwgICAgNCAtCiBkcml2ZXJzL2dw dS9kcm0vaTkxNS9ndC9pbnRlbF9ndC5jICAgICAgICAgICAgfCAgIDIxICsKIGRyaXZlcnMvZ3B1 L2RybS9pOTE1L2d0L2ludGVsX2d0LmggICAgICAgICAgICB8ICAgIDIgKwogZHJpdmVycy9ncHUv ZHJtL2k5MTUvZ3QvaW50ZWxfZ3RfcG0uYyAgICAgICAgIHwgICAgNiArLQogZHJpdmVycy9ncHUv ZHJtL2k5MTUvZ3QvaW50ZWxfZ3RfcmVxdWVzdHMuYyAgIHwgICAyMSArLQogZHJpdmVycy9ncHUv ZHJtL2k5MTUvZ3QvaW50ZWxfZ3RfcmVxdWVzdHMuaCAgIHwgICAgOSArLQogZHJpdmVycy9ncHUv ZHJtL2k5MTUvZ3QvaW50ZWxfbHJjX3JlZy5oICAgICAgIHwgICAgMSAtCiBkcml2ZXJzL2dwdS9k cm0vaTkxNS9ndC9pbnRlbF9yZXNldC5jICAgICAgICAgfCAgIDUwICstCiAuLi4vZ3B1L2RybS9p OTE1L2d0L2ludGVsX3Jpbmdfc3VibWlzc2lvbi5jICAgfCAgIDQyICsKIGRyaXZlcnMvZ3B1L2Ry bS9pOTE1L2d0L2ludGVsX3Jwcy5jICAgICAgICAgICB8ICAgIDQgKwogZHJpdmVycy9ncHUvZHJt L2k5MTUvZ3QvaW50ZWxfd29ya2Fyb3VuZHMuYyAgIHwgICA0NiArLQogLi4uL2dwdS9kcm0vaTkx NS9ndC9pbnRlbF93b3JrYXJvdW5kc190eXBlcy5oIHwgICAgMSArCiBkcml2ZXJzL2dwdS9kcm0v aTkxNS9ndC9tb2NrX2VuZ2luZS5jICAgICAgICAgfCAgIDM0ICstCiBkcml2ZXJzL2dwdS9kcm0v aTkxNS9ndC9zZWxmdGVzdF9jb250ZXh0LmMgICAgfCAgIDEwICsKIC4uLi9kcm0vaTkxNS9ndC9z ZWxmdGVzdF9lbmdpbmVfaGVhcnRiZWF0LmMgICB8ICAgMjIgKwogLi4uL2RybS9pOTE1L2d0L3Nl bGZ0ZXN0X2VuZ2luZV9oZWFydGJlYXQuaCAgIHwgICAgMiArCiBkcml2ZXJzL2dwdS9kcm0vaTkx NS9ndC9zZWxmdGVzdF9leGVjbGlzdHMuYyAgfCAgIDEyICstCiBkcml2ZXJzL2dwdS9kcm0vaTkx NS9ndC9zZWxmdGVzdF9oYW5nY2hlY2suYyAgfCAgMzE0ICstCiBkcml2ZXJzL2dwdS9kcm0vaTkx NS9ndC9zZWxmdGVzdF9tb2NzLmMgICAgICAgfCAgIDUwICstCiAuLi4vZ3B1L2RybS9pOTE1L2d0 L3NlbGZ0ZXN0X3dvcmthcm91bmRzLmMgICAgfCAgMTMyICstCiAuLi4vZ3B1L2RybS9pOTE1L2d0 L3VjL2FiaS9ndWNfYWN0aW9uc19hYmkuaCAgfCAgIDE1ICsKIGRyaXZlcnMvZ3B1L2RybS9pOTE1 L2d0L3VjL2ludGVsX2d1Yy5jICAgICAgICB8ICAgODIgKy0KIGRyaXZlcnMvZ3B1L2RybS9pOTE1 L2d0L3VjL2ludGVsX2d1Yy5oICAgICAgICB8ICAxMDEgKy0KIGRyaXZlcnMvZ3B1L2RybS9pOTE1 L2d0L3VjL2ludGVsX2d1Y19hZHMuYyAgICB8ICA0NjMgKystCiBkcml2ZXJzL2dwdS9kcm0vaTkx NS9ndC91Yy9pbnRlbF9ndWNfYWRzLmggICAgfCAgICA0ICsKIGRyaXZlcnMvZ3B1L2RybS9pOTE1 L2d0L3VjL2ludGVsX2d1Y19jdC5jICAgICB8ICAxMzIgKy0KIGRyaXZlcnMvZ3B1L2RybS9pOTE1 L2d0L3VjL2ludGVsX2d1Y19jdC5oICAgICB8ICAgMTYgKy0KIC4uLi9ncHUvZHJtL2k5MTUvZ3Qv dWMvaW50ZWxfZ3VjX2RlYnVnZnMuYyAgICB8ICAgMjUgKy0KIGRyaXZlcnMvZ3B1L2RybS9pOTE1 L2d0L3VjL2ludGVsX2d1Y19md2lmLmggICB8ICAgODggKy0KIC4uLi9ncHUvZHJtL2k5MTUvZ3Qv dWMvaW50ZWxfZ3VjX3N1Ym1pc3Npb24uYyB8IDI4NDggKysrKysrKysrKysrKysrLS0KIC4uLi9n cHUvZHJtL2k5MTUvZ3QvdWMvaW50ZWxfZ3VjX3N1Ym1pc3Npb24uaCB8ICAgMTggKy0KIGRyaXZl cnMvZ3B1L2RybS9pOTE1L2d0L3VjL2ludGVsX3VjLmMgICAgICAgICB8ICAxMDEgKy0KIGRyaXZl cnMvZ3B1L2RybS9pOTE1L2d0L3VjL2ludGVsX3VjLmggICAgICAgICB8ICAgMTEgKwogZHJpdmVy cy9ncHUvZHJtL2k5MTUvaTkxNV9kZWJ1Z2ZzX3BhcmFtcy5jICAgIHwgICAzMSArCiBkcml2ZXJz L2dwdS9kcm0vaTkxNS9pOTE1X2dlbV9ldmljdC5jICAgICAgICAgfCAgICAxICsKIGRyaXZlcnMv Z3B1L2RybS9pOTE1L2k5MTVfZ3B1X2Vycm9yLmMgICAgICAgICB8ICAgMjUgKy0KIGRyaXZlcnMv Z3B1L2RybS9pOTE1L2k5MTVfcmVnLmggICAgICAgICAgICAgICB8ICAgIDIgKwogZHJpdmVycy9n cHUvZHJtL2k5MTUvaTkxNV9yZXF1ZXN0LmMgICAgICAgICAgIHwgIDE3MyArLQogZHJpdmVycy9n cHUvZHJtL2k5MTUvaTkxNV9yZXF1ZXN0LmggICAgICAgICAgIHwgICAyOSArCiBkcml2ZXJzL2dw dS9kcm0vaTkxNS9pOTE1X3NjaGVkdWxlci5jICAgICAgICAgfCAgIDE2ICstCiBkcml2ZXJzL2dw dS9kcm0vaTkxNS9pOTE1X3NjaGVkdWxlci5oICAgICAgICAgfCAgIDEwICstCiBkcml2ZXJzL2dw dS9kcm0vaTkxNS9pOTE1X3NjaGVkdWxlcl90eXBlcy5oICAgfCAgIDIyICsKIGRyaXZlcnMvZ3B1 L2RybS9pOTE1L2k5MTVfdHJhY2UuaCAgICAgICAgICAgICB8ICAxOTkgKy0KIGRyaXZlcnMvZ3B1 L2RybS9pOTE1L3NlbGZ0ZXN0cy9pOTE1X3JlcXVlc3QuYyB8ICAgIDQgKy0KIC4uLi9ncHUvZHJt L2k5MTUvc2VsZnRlc3RzL2lndF9mbHVzaF90ZXN0LmMgICB8ICAgIDIgKy0KIC4uLi9ncHUvZHJt L2k5MTUvc2VsZnRlc3RzL2lndF9saXZlX3Rlc3QuYyAgICB8ICAgIDIgKy0KIC4uLi9pOTE1L3Nl bGZ0ZXN0cy9pbnRlbF9zY2hlZHVsZXJfaGVscGVycy5jICB8ICAgODkgKwogLi4uL2k5MTUvc2Vs ZnRlc3RzL2ludGVsX3NjaGVkdWxlcl9oZWxwZXJzLmggIHwgICAzNSArCiAuLi4vZ3B1L2RybS9p OTE1L3NlbGZ0ZXN0cy9tb2NrX2dlbV9kZXZpY2UuYyAgfCAgICAzICstCiBpbmNsdWRlL3VhcGkv ZHJtL2k5MTVfZHJtLmggICAgICAgICAgICAgICAgICAgfCAgICA5ICsKIDY3IGZpbGVzIGNoYW5n ZWQsIDUxMjIgaW5zZXJ0aW9ucygrKSwgODk4IGRlbGV0aW9ucygtKQogY3JlYXRlIG1vZGUgMTAw NjQ0IGRyaXZlcnMvZ3B1L2RybS9pOTE1L3NlbGZ0ZXN0cy9pbnRlbF9zY2hlZHVsZXJfaGVscGVy cy5jCiBjcmVhdGUgbW9kZSAxMDA2NDQgZHJpdmVycy9ncHUvZHJtL2k5MTUvc2VsZnRlc3RzL2lu dGVsX3NjaGVkdWxlcl9oZWxwZXJzLmgKCmRpZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9kcm0vaTkx NS9NYWtlZmlsZSBiL2RyaXZlcnMvZ3B1L2RybS9pOTE1L01ha2VmaWxlCmluZGV4IDEwYjNiYjYy MDdiYS4uYWI3Njc5OTU3NjIzIDEwMDY0NAotLS0gYS9kcml2ZXJzL2dwdS9kcm0vaTkxNS9NYWtl ZmlsZQorKysgYi9kcml2ZXJzL2dwdS9kcm0vaTkxNS9NYWtlZmlsZQpAQCAtMjgwLDYgKzI4MCw3 IEBAIGk5MTUtJChDT05GSUdfRFJNX0k5MTVfQ0FQVFVSRV9FUlJPUikgKz0gaTkxNV9ncHVfZXJy b3IubwogaTkxNS0kKENPTkZJR19EUk1fSTkxNV9TRUxGVEVTVCkgKz0gXAogCWdlbS9zZWxmdGVz dHMvaTkxNV9nZW1fY2xpZW50X2JsdC5vIFwKIAlnZW0vc2VsZnRlc3RzL2lndF9nZW1fdXRpbHMu byBcCisJc2VsZnRlc3RzL2ludGVsX3NjaGVkdWxlcl9oZWxwZXJzLm8gXAogCXNlbGZ0ZXN0cy9p OTE1X3JhbmRvbS5vIFwKIAlzZWxmdGVzdHMvaTkxNV9zZWxmdGVzdC5vIFwKIAlzZWxmdGVzdHMv aWd0X2F0b21pYy5vIFwKZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2dlbS9pOTE1 X2dlbV9jb250ZXh0LmMgYi9kcml2ZXJzL2dwdS9kcm0vaTkxNS9nZW0vaTkxNV9nZW1fY29udGV4 dC5jCmluZGV4IDdkNmY1MmQ4YTgwMS4uZDg3YTRjNmRhNWJjIDEwMDY0NAotLS0gYS9kcml2ZXJz L2dwdS9kcm0vaTkxNS9nZW0vaTkxNV9nZW1fY29udGV4dC5jCisrKyBiL2RyaXZlcnMvZ3B1L2Ry bS9pOTE1L2dlbS9pOTE1X2dlbV9jb250ZXh0LmMKQEAgLTc0LDcgKzc0LDYgQEAKICNpbmNsdWRl ICJndC9pbnRlbF9jb250ZXh0X3BhcmFtLmgiCiAjaW5jbHVkZSAiZ3QvaW50ZWxfZW5naW5lX2hl YXJ0YmVhdC5oIgogI2luY2x1ZGUgImd0L2ludGVsX2VuZ2luZV91c2VyLmgiCi0jaW5jbHVkZSAi Z3QvaW50ZWxfZXhlY2xpc3RzX3N1Ym1pc3Npb24uaCIgLyogdmlydHVhbF9lbmdpbmUgKi8KICNp bmNsdWRlICJndC9pbnRlbF9ncHVfY29tbWFuZHMuaCIKICNpbmNsdWRlICJndC9pbnRlbF9yaW5n LmgiCiAKQEAgLTM2Myw5ICszNjIsNiBAQCBzZXRfcHJvdG9fY3R4X2VuZ2luZXNfYmFsYW5jZShz dHJ1Y3QgaTkxNV91c2VyX2V4dGVuc2lvbiBfX3VzZXIgKmJhc2UsCiAJaWYgKCFIQVNfRVhFQ0xJ U1RTKGk5MTUpKQogCQlyZXR1cm4gLUVOT0RFVjsKIAotCWlmIChpbnRlbF91Y191c2VzX2d1Y19z dWJtaXNzaW9uKCZpOTE1LT5ndC51YykpCi0JCXJldHVybiAtRU5PREVWOyAvKiBub3QgaW1wbGVt ZW50IHlldCAqLwotCiAJaWYgKGdldF91c2VyKGlkeCwgJmV4dC0+ZW5naW5lX2luZGV4KSkKIAkJ cmV0dXJuIC1FRkFVTFQ7CiAKQEAgLTQ5NSw2ICs0OTEsMTEgQEAgc2V0X3Byb3RvX2N0eF9lbmdp bmVzX2JvbmQoc3RydWN0IGk5MTVfdXNlcl9leHRlbnNpb24gX191c2VyICpiYXNlLCB2b2lkICpk YXRhKQogCQlyZXR1cm4gLUVJTlZBTDsKIAl9CiAKKwlpZiAoaW50ZWxfZW5naW5lX3VzZXNfZ3Vj KG1hc3RlcikpIHsKKwkJRFJNX0RFQlVHKCJib25kaW5nIGV4dGVuc2lvbiBub3Qgc3VwcG9ydGVk IHdpdGggR3VDIHN1Ym1pc3Npb24iKTsKKwkJcmV0dXJuIC1FTk9ERVY7CisJfQorCiAJaWYgKGdl dF91c2VyKG51bV9ib25kcywgJmV4dC0+bnVtX2JvbmRzKSkKIAkJcmV0dXJuIC1FRkFVTFQ7CiAK QEAgLTc5OSw3ICs4MDAsOCBAQCBzdGF0aWMgaW50IGludGVsX2NvbnRleHRfc2V0X2dlbShzdHJ1 Y3QgaW50ZWxfY29udGV4dCAqY2UsCiAJfQogCiAJaWYgKGN0eC0+c2NoZWQucHJpb3JpdHkgPj0g STkxNV9QUklPUklUWV9OT1JNQUwgJiYKLQkgICAgaW50ZWxfZW5naW5lX2hhc190aW1lc2xpY2Vz KGNlLT5lbmdpbmUpKQorCSAgICBpbnRlbF9lbmdpbmVfaGFzX3RpbWVzbGljZXMoY2UtPmVuZ2lu ZSkgJiYKKwkgICAgaW50ZWxfZW5naW5lX2hhc19zZW1hcGhvcmVzKGNlLT5lbmdpbmUpKQogCQlf X3NldF9iaXQoQ09OVEVYVF9VU0VfU0VNQVBIT1JFUywgJmNlLT5mbGFncyk7CiAKIAlpZiAoSVNf QUNUSVZFKENPTkZJR19EUk1fSTkxNV9SRVFVRVNUX1RJTUVPVVQpICYmCkBAIC05NDksOCArOTUx LDggQEAgc3RhdGljIHN0cnVjdCBpOTE1X2dlbV9lbmdpbmVzICp1c2VyX2VuZ2luZXMoc3RydWN0 IGk5MTVfZ2VtX2NvbnRleHQgKmN0eCwKIAkJCWJyZWFrOwogCiAJCWNhc2UgSTkxNV9HRU1fRU5H SU5FX1RZUEVfQkFMQU5DRUQ6Ci0JCQljZSA9IGludGVsX2V4ZWNsaXN0c19jcmVhdGVfdmlydHVh bChwZVtuXS5zaWJsaW5ncywKLQkJCQkJCQkgICAgcGVbbl0ubnVtX3NpYmxpbmdzKTsKKwkJCWNl ID0gaW50ZWxfZW5naW5lX2NyZWF0ZV92aXJ0dWFsKHBlW25dLnNpYmxpbmdzLAorCQkJCQkJCSBw ZVtuXS5udW1fc2libGluZ3MpOwogCQkJYnJlYWs7CiAKIAkJY2FzZSBJOTE1X0dFTV9FTkdJTkVf VFlQRV9JTlZBTElEOgpAQCAtMTA4Miw3ICsxMDg0LDcgQEAgc3RhdGljIHZvaWQga2lsbF9lbmdp bmVzKHN0cnVjdCBpOTE1X2dlbV9lbmdpbmVzICplbmdpbmVzLCBib29sIGJhbikKIAlmb3JfZWFj aF9nZW1fZW5naW5lKGNlLCBlbmdpbmVzLCBpdCkgewogCQlzdHJ1Y3QgaW50ZWxfZW5naW5lX2Nz ICplbmdpbmU7CiAKLQkJaWYgKGJhbiAmJiBpbnRlbF9jb250ZXh0X3NldF9iYW5uZWQoY2UpKQor CQlpZiAoYmFuICYmIGludGVsX2NvbnRleHRfYmFuKGNlLCBOVUxMKSkKIAkJCWNvbnRpbnVlOwog CiAJCS8qCkBAIC0xNzc4LDcgKzE3ODAsOCBAQCBzdGF0aWMgdm9pZCBfX2FwcGx5X3ByaW9yaXR5 KHN0cnVjdCBpbnRlbF9jb250ZXh0ICpjZSwgdm9pZCAqYXJnKQogCWlmICghaW50ZWxfZW5naW5l X2hhc190aW1lc2xpY2VzKGNlLT5lbmdpbmUpKQogCQlyZXR1cm47CiAKLQlpZiAoY3R4LT5zY2hl ZC5wcmlvcml0eSA+PSBJOTE1X1BSSU9SSVRZX05PUk1BTCkKKwlpZiAoY3R4LT5zY2hlZC5wcmlv cml0eSA+PSBJOTE1X1BSSU9SSVRZX05PUk1BTCAmJgorCSAgICBpbnRlbF9lbmdpbmVfaGFzX3Nl bWFwaG9yZXMoY2UtPmVuZ2luZSkpCiAJCWludGVsX2NvbnRleHRfc2V0X3VzZV9zZW1hcGhvcmVz KGNlKTsKIAllbHNlCiAJCWludGVsX2NvbnRleHRfY2xlYXJfdXNlX3NlbWFwaG9yZXMoY2UpOwpk aWZmIC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJtL2k5MTUvZ2VtL2k5MTVfZ2VtX21tYW4uYyBiL2Ry aXZlcnMvZ3B1L2RybS9pOTE1L2dlbS9pOTE1X2dlbV9tbWFuLmMKaW5kZXggYTkwZjc5NmU4NWMw Li42ZmZmZDRkMzc3YzIgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2dlbS9pOTE1 X2dlbV9tbWFuLmMKKysrIGIvZHJpdmVycy9ncHUvZHJtL2k5MTUvZ2VtL2k5MTVfZ2VtX21tYW4u YwpAQCAtNjQ1LDcgKzY0NSw4IEBAIG1tYXBfb2Zmc2V0X2F0dGFjaChzdHJ1Y3QgZHJtX2k5MTVf Z2VtX29iamVjdCAqb2JqLAogCQlnb3RvIGluc2VydDsKIAogCS8qIEF0dGVtcHQgdG8gcmVhcCBz b21lIG1tYXAgc3BhY2UgZnJvbSBkZWFkIG9iamVjdHMgKi8KLQllcnIgPSBpbnRlbF9ndF9yZXRp cmVfcmVxdWVzdHNfdGltZW91dCgmaTkxNS0+Z3QsIE1BWF9TQ0hFRFVMRV9USU1FT1VUKTsKKwll cnIgPSBpbnRlbF9ndF9yZXRpcmVfcmVxdWVzdHNfdGltZW91dCgmaTkxNS0+Z3QsIE1BWF9TQ0hF RFVMRV9USU1FT1VULAorCQkJCQkgICAgICAgTlVMTCk7CiAJaWYgKGVycikKIAkJZ290byBlcnI7 CiAKZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2d0L2dlbjhfZW5naW5lX2NzLmMg Yi9kcml2ZXJzL2dwdS9kcm0vaTkxNS9ndC9nZW44X2VuZ2luZV9jcy5jCmluZGV4IDg3YjA2NTcy ZmQyZS4uZjdhYWU1MDJlYzNkIDEwMDY0NAotLS0gYS9kcml2ZXJzL2dwdS9kcm0vaTkxNS9ndC9n ZW44X2VuZ2luZV9jcy5jCisrKyBiL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2d0L2dlbjhfZW5naW5l X2NzLmMKQEAgLTUwNiw3ICs1MDYsOCBAQCBnZW44X2VtaXRfZmluaV9icmVhZGNydW1iX3RhaWwo c3RydWN0IGk5MTVfcmVxdWVzdCAqcnEsIHUzMiAqY3MpCiAJKmNzKysgPSBNSV9VU0VSX0lOVEVS UlVQVDsKIAogCSpjcysrID0gTUlfQVJCX09OX09GRiB8IE1JX0FSQl9FTkFCTEU7Ci0JaWYgKGlu dGVsX2VuZ2luZV9oYXNfc2VtYXBob3JlcyhycS0+ZW5naW5lKSkKKwlpZiAoaW50ZWxfZW5naW5l X2hhc19zZW1hcGhvcmVzKHJxLT5lbmdpbmUpICYmCisJICAgICFpbnRlbF91Y191c2VzX2d1Y19z dWJtaXNzaW9uKCZycS0+ZW5naW5lLT5ndC0+dWMpKQogCQljcyA9IGVtaXRfcHJlZW1wdF9idXN5 d2FpdChycSwgY3MpOwogCiAJcnEtPnRhaWwgPSBpbnRlbF9yaW5nX29mZnNldChycSwgY3MpOwpA QCAtNTk4LDcgKzU5OSw4IEBAIGdlbjEyX2VtaXRfZmluaV9icmVhZGNydW1iX3RhaWwoc3RydWN0 IGk5MTVfcmVxdWVzdCAqcnEsIHUzMiAqY3MpCiAJKmNzKysgPSBNSV9VU0VSX0lOVEVSUlVQVDsK IAogCSpjcysrID0gTUlfQVJCX09OX09GRiB8IE1JX0FSQl9FTkFCTEU7Ci0JaWYgKGludGVsX2Vu Z2luZV9oYXNfc2VtYXBob3JlcyhycS0+ZW5naW5lKSkKKwlpZiAoaW50ZWxfZW5naW5lX2hhc19z ZW1hcGhvcmVzKHJxLT5lbmdpbmUpICYmCisJICAgICFpbnRlbF91Y191c2VzX2d1Y19zdWJtaXNz aW9uKCZycS0+ZW5naW5lLT5ndC0+dWMpKQogCQljcyA9IGdlbjEyX2VtaXRfcHJlZW1wdF9idXN5 d2FpdChycSwgY3MpOwogCiAJcnEtPnRhaWwgPSBpbnRlbF9yaW5nX29mZnNldChycSwgY3MpOwpk aWZmIC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJtL2k5MTUvZ3QvaW50ZWxfYnJlYWRjcnVtYnMuYyBi L2RyaXZlcnMvZ3B1L2RybS9pOTE1L2d0L2ludGVsX2JyZWFkY3J1bWJzLmMKaW5kZXggMzhjYzQy NzgzZGZiLi4yMDljZjI2NWJmNzQgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2d0 L2ludGVsX2JyZWFkY3J1bWJzLmMKKysrIGIvZHJpdmVycy9ncHUvZHJtL2k5MTUvZ3QvaW50ZWxf YnJlYWRjcnVtYnMuYwpAQCAtMTUsMjggKzE1LDE0IEBACiAjaW5jbHVkZSAiaW50ZWxfZ3RfcG0u aCIKICNpbmNsdWRlICJpbnRlbF9ndF9yZXF1ZXN0cy5oIgogCi1zdGF0aWMgYm9vbCBpcnFfZW5h YmxlKHN0cnVjdCBpbnRlbF9lbmdpbmVfY3MgKmVuZ2luZSkKK3N0YXRpYyBib29sIGlycV9lbmFi bGUoc3RydWN0IGludGVsX2JyZWFkY3J1bWJzICpiKQogewotCWlmICghZW5naW5lLT5pcnFfZW5h YmxlKQotCQlyZXR1cm4gZmFsc2U7Ci0KLQkvKiBDYWxsZXIgZGlzYWJsZXMgaW50ZXJydXB0cyAq LwotCXNwaW5fbG9jaygmZW5naW5lLT5ndC0+aXJxX2xvY2spOwotCWVuZ2luZS0+aXJxX2VuYWJs ZShlbmdpbmUpOwotCXNwaW5fdW5sb2NrKCZlbmdpbmUtPmd0LT5pcnFfbG9jayk7Ci0KLQlyZXR1 cm4gdHJ1ZTsKKwlyZXR1cm4gaW50ZWxfZW5naW5lX2lycV9lbmFibGUoYi0+aXJxX2VuZ2luZSk7 CiB9CiAKLXN0YXRpYyB2b2lkIGlycV9kaXNhYmxlKHN0cnVjdCBpbnRlbF9lbmdpbmVfY3MgKmVu Z2luZSkKK3N0YXRpYyB2b2lkIGlycV9kaXNhYmxlKHN0cnVjdCBpbnRlbF9icmVhZGNydW1icyAq YikKIHsKLQlpZiAoIWVuZ2luZS0+aXJxX2Rpc2FibGUpCi0JCXJldHVybjsKLQotCS8qIENhbGxl ciBkaXNhYmxlcyBpbnRlcnJ1cHRzICovCi0Jc3Bpbl9sb2NrKCZlbmdpbmUtPmd0LT5pcnFfbG9j ayk7Ci0JZW5naW5lLT5pcnFfZGlzYWJsZShlbmdpbmUpOwotCXNwaW5fdW5sb2NrKCZlbmdpbmUt Pmd0LT5pcnFfbG9jayk7CisJaW50ZWxfZW5naW5lX2lycV9kaXNhYmxlKGItPmlycV9lbmdpbmUp OwogfQogCiBzdGF0aWMgdm9pZCBfX2ludGVsX2JyZWFkY3J1bWJzX2FybV9pcnEoc3RydWN0IGlu dGVsX2JyZWFkY3J1bWJzICpiKQpAQCAtNTcsNyArNDMsNyBAQCBzdGF0aWMgdm9pZCBfX2ludGVs X2JyZWFkY3J1bWJzX2FybV9pcnEoc3RydWN0IGludGVsX2JyZWFkY3J1bWJzICpiKQogCVdSSVRF X09OQ0UoYi0+aXJxX2FybWVkLCB0cnVlKTsKIAogCS8qIFJlcXVlc3RzIG1heSBoYXZlIGNvbXBs ZXRlZCBiZWZvcmUgd2UgY291bGQgZW5hYmxlIHRoZSBpbnRlcnJ1cHQuICovCi0JaWYgKCFiLT5p cnFfZW5hYmxlZCsrICYmIGlycV9lbmFibGUoYi0+aXJxX2VuZ2luZSkpCisJaWYgKCFiLT5pcnFf ZW5hYmxlZCsrICYmIGItPmlycV9lbmFibGUoYikpCiAJCWlycV93b3JrX3F1ZXVlKCZiLT5pcnFf d29yayk7CiB9CiAKQEAgLTc2LDcgKzYyLDcgQEAgc3RhdGljIHZvaWQgX19pbnRlbF9icmVhZGNy dW1ic19kaXNhcm1faXJxKHN0cnVjdCBpbnRlbF9icmVhZGNydW1icyAqYikKIHsKIAlHRU1fQlVH X09OKCFiLT5pcnFfZW5hYmxlZCk7CiAJaWYgKCEtLWItPmlycV9lbmFibGVkKQotCQlpcnFfZGlz YWJsZShiLT5pcnFfZW5naW5lKTsKKwkJYi0+aXJxX2Rpc2FibGUoYik7CiAKIAlXUklURV9PTkNF KGItPmlycV9hcm1lZCwgZmFsc2UpOwogCWludGVsX2d0X3BtX3B1dF9hc3luYyhiLT5pcnFfZW5n aW5lLT5ndCk7CkBAIC0yNTksNiArMjQ1LDkgQEAgc3RhdGljIHZvaWQgc2lnbmFsX2lycV93b3Jr KHN0cnVjdCBpcnFfd29yayAqd29yaykKIAkJCWxsaXN0X2VudHJ5KHNpZ25hbCwgdHlwZW9mKCpy cSksIHNpZ25hbF9ub2RlKTsKIAkJc3RydWN0IGxpc3RfaGVhZCBjYl9saXN0OwogCisJCWlmIChy cS0+ZW5naW5lLT5zY2hlZF9lbmdpbmUtPnJldGlyZV9pbmZsaWdodF9yZXF1ZXN0X3ByaW8pCisJ CQlycS0+ZW5naW5lLT5zY2hlZF9lbmdpbmUtPnJldGlyZV9pbmZsaWdodF9yZXF1ZXN0X3ByaW8o cnEpOworCiAJCXNwaW5fbG9jaygmcnEtPmxvY2spOwogCQlsaXN0X3JlcGxhY2UoJnJxLT5mZW5j ZS5jYl9saXN0LCAmY2JfbGlzdCk7CiAJCV9fZG1hX2ZlbmNlX3NpZ25hbF9fdGltZXN0YW1wKCZy cS0+ZmVuY2UsIHRpbWVzdGFtcCk7CkBAIC0yODEsNyArMjcwLDcgQEAgaW50ZWxfYnJlYWRjcnVt YnNfY3JlYXRlKHN0cnVjdCBpbnRlbF9lbmdpbmVfY3MgKmlycV9lbmdpbmUpCiAJaWYgKCFiKQog CQlyZXR1cm4gTlVMTDsKIAotCWItPmlycV9lbmdpbmUgPSBpcnFfZW5naW5lOworCWtyZWZfaW5p dCgmYi0+cmVmKTsKIAogCXNwaW5fbG9ja19pbml0KCZiLT5zaWduYWxlcnNfbG9jayk7CiAJSU5J VF9MSVNUX0hFQUQoJmItPnNpZ25hbGVycyk7CkBAIC0yOTAsNiArMjc5LDEwIEBAIGludGVsX2Jy ZWFkY3J1bWJzX2NyZWF0ZShzdHJ1Y3QgaW50ZWxfZW5naW5lX2NzICppcnFfZW5naW5lKQogCXNw aW5fbG9ja19pbml0KCZiLT5pcnFfbG9jayk7CiAJaW5pdF9pcnFfd29yaygmYi0+aXJxX3dvcmss IHNpZ25hbF9pcnFfd29yayk7CiAKKwliLT5pcnFfZW5naW5lID0gaXJxX2VuZ2luZTsKKwliLT5p cnFfZW5hYmxlID0gaXJxX2VuYWJsZTsKKwliLT5pcnFfZGlzYWJsZSA9IGlycV9kaXNhYmxlOwor CiAJcmV0dXJuIGI7CiB9CiAKQEAgLTMwMyw5ICsyOTYsOSBAQCB2b2lkIGludGVsX2JyZWFkY3J1 bWJzX3Jlc2V0KHN0cnVjdCBpbnRlbF9icmVhZGNydW1icyAqYikKIAlzcGluX2xvY2tfaXJxc2F2 ZSgmYi0+aXJxX2xvY2ssIGZsYWdzKTsKIAogCWlmIChiLT5pcnFfZW5hYmxlZCkKLQkJaXJxX2Vu YWJsZShiLT5pcnFfZW5naW5lKTsKKwkJYi0+aXJxX2VuYWJsZShiKTsKIAllbHNlCi0JCWlycV9k aXNhYmxlKGItPmlycV9lbmdpbmUpOworCQliLT5pcnFfZGlzYWJsZShiKTsKIAogCXNwaW5fdW5s b2NrX2lycXJlc3RvcmUoJmItPmlycV9sb2NrLCBmbGFncyk7CiB9CkBAIC0zMjUsMTEgKzMxOCwx NCBAQCB2b2lkIF9faW50ZWxfYnJlYWRjcnVtYnNfcGFyayhzdHJ1Y3QgaW50ZWxfYnJlYWRjcnVt YnMgKmIpCiAJfQogfQogCi12b2lkIGludGVsX2JyZWFkY3J1bWJzX2ZyZWUoc3RydWN0IGludGVs X2JyZWFkY3J1bWJzICpiKQordm9pZCBpbnRlbF9icmVhZGNydW1ic19mcmVlKHN0cnVjdCBrcmVm ICprcmVmKQogeworCXN0cnVjdCBpbnRlbF9icmVhZGNydW1icyAqYiA9IGNvbnRhaW5lcl9vZihr cmVmLCB0eXBlb2YoKmIpLCByZWYpOworCiAJaXJxX3dvcmtfc3luYygmYi0+aXJxX3dvcmspOwog CUdFTV9CVUdfT04oIWxpc3RfZW1wdHkoJmItPnNpZ25hbGVycykpOwogCUdFTV9CVUdfT04oYi0+ aXJxX2FybWVkKTsKKwogCWtmcmVlKGIpOwogfQogCmRpZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9k cm0vaTkxNS9ndC9pbnRlbF9icmVhZGNydW1icy5oIGIvZHJpdmVycy9ncHUvZHJtL2k5MTUvZ3Qv aW50ZWxfYnJlYWRjcnVtYnMuaAppbmRleCAzY2U1Y2UyNzBiMDQuLmJlMGQ0ZjM3OWE4NSAxMDA2 NDQKLS0tIGEvZHJpdmVycy9ncHUvZHJtL2k5MTUvZ3QvaW50ZWxfYnJlYWRjcnVtYnMuaAorKysg Yi9kcml2ZXJzL2dwdS9kcm0vaTkxNS9ndC9pbnRlbF9icmVhZGNydW1icy5oCkBAIC05LDcgKzks NyBAQAogI2luY2x1ZGUgPGxpbnV4L2F0b21pYy5oPgogI2luY2x1ZGUgPGxpbnV4L2lycV93b3Jr Lmg+CiAKLSNpbmNsdWRlICJpbnRlbF9lbmdpbmVfdHlwZXMuaCIKKyNpbmNsdWRlICJpbnRlbF9i cmVhZGNydW1ic190eXBlcy5oIgogCiBzdHJ1Y3QgZHJtX3ByaW50ZXI7CiBzdHJ1Y3QgaTkxNV9y ZXF1ZXN0OwpAQCAtMTcsNyArMTcsNyBAQCBzdHJ1Y3QgaW50ZWxfYnJlYWRjcnVtYnM7CiAKIHN0 cnVjdCBpbnRlbF9icmVhZGNydW1icyAqCiBpbnRlbF9icmVhZGNydW1ic19jcmVhdGUoc3RydWN0 IGludGVsX2VuZ2luZV9jcyAqaXJxX2VuZ2luZSk7Ci12b2lkIGludGVsX2JyZWFkY3J1bWJzX2Zy ZWUoc3RydWN0IGludGVsX2JyZWFkY3J1bWJzICpiKTsKK3ZvaWQgaW50ZWxfYnJlYWRjcnVtYnNf ZnJlZShzdHJ1Y3Qga3JlZiAqa3JlZik7CiAKIHZvaWQgaW50ZWxfYnJlYWRjcnVtYnNfcmVzZXQo c3RydWN0IGludGVsX2JyZWFkY3J1bWJzICpiKTsKIHZvaWQgX19pbnRlbF9icmVhZGNydW1ic19w YXJrKHN0cnVjdCBpbnRlbF9icmVhZGNydW1icyAqYik7CkBAIC00OCw0ICs0OCwxNiBAQCB2b2lk IGk5MTVfcmVxdWVzdF9jYW5jZWxfYnJlYWRjcnVtYihzdHJ1Y3QgaTkxNV9yZXF1ZXN0ICpyZXF1 ZXN0KTsKIHZvaWQgaW50ZWxfY29udGV4dF9yZW1vdmVfYnJlYWRjcnVtYnMoc3RydWN0IGludGVs X2NvbnRleHQgKmNlLAogCQkJCSAgICAgIHN0cnVjdCBpbnRlbF9icmVhZGNydW1icyAqYik7CiAK K3N0YXRpYyBpbmxpbmUgc3RydWN0IGludGVsX2JyZWFkY3J1bWJzICoKK2ludGVsX2JyZWFkY3J1 bWJzX2dldChzdHJ1Y3QgaW50ZWxfYnJlYWRjcnVtYnMgKmIpCit7CisJa3JlZl9nZXQoJmItPnJl Zik7CisJcmV0dXJuIGI7Cit9CisKK3N0YXRpYyBpbmxpbmUgdm9pZCBpbnRlbF9icmVhZGNydW1i c19wdXQoc3RydWN0IGludGVsX2JyZWFkY3J1bWJzICpiKQoreworCWtyZWZfcHV0KCZiLT5yZWYs IGludGVsX2JyZWFkY3J1bWJzX2ZyZWUpOworfQorCiAjZW5kaWYgLyogX19JTlRFTF9CUkVBRENS VU1CU19fICovCmRpZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9kcm0vaTkxNS9ndC9pbnRlbF9icmVh ZGNydW1ic190eXBlcy5oIGIvZHJpdmVycy9ncHUvZHJtL2k5MTUvZ3QvaW50ZWxfYnJlYWRjcnVt YnNfdHlwZXMuaAppbmRleCAzYTA4NGNlOGZmNWUuLjcyZGZkMzc0OGM0YyAxMDA2NDQKLS0tIGEv ZHJpdmVycy9ncHUvZHJtL2k5MTUvZ3QvaW50ZWxfYnJlYWRjcnVtYnNfdHlwZXMuaAorKysgYi9k cml2ZXJzL2dwdS9kcm0vaTkxNS9ndC9pbnRlbF9icmVhZGNydW1ic190eXBlcy5oCkBAIC03LDEw ICs3LDEzIEBACiAjZGVmaW5lIF9fSU5URUxfQlJFQURDUlVNQlNfVFlQRVNfXwogCiAjaW5jbHVk ZSA8bGludXgvaXJxX3dvcmsuaD4KKyNpbmNsdWRlIDxsaW51eC9rcmVmLmg+CiAjaW5jbHVkZSA8 bGludXgvbGlzdC5oPgogI2luY2x1ZGUgPGxpbnV4L3NwaW5sb2NrLmg+CiAjaW5jbHVkZSA8bGlu dXgvdHlwZXMuaD4KIAorI2luY2x1ZGUgImludGVsX2VuZ2luZV90eXBlcy5oIgorCiAvKgogICog UmF0aGVyIHRoYW4gaGF2ZSBldmVyeSBjbGllbnQgd2FpdCB1cG9uIGFsbCB1c2VyIGludGVycnVw dHMsCiAgKiB3aXRoIHRoZSBoZXJkIHdha2luZyBhZnRlciBldmVyeSBpbnRlcnJ1cHQgYW5kIGVh Y2ggZG9pbmcgdGhlCkBAIC0yOSw2ICszMiw3IEBACiAgKiB0aGUgb3ZlcmhlYWQgb2Ygd2FraW5n IHRoYXQgY2xpZW50IGlzIG11Y2ggcHJlZmVycmVkLgogICovCiBzdHJ1Y3QgaW50ZWxfYnJlYWRj cnVtYnMgeworCXN0cnVjdCBrcmVmIHJlZjsKIAlhdG9taWNfdCBhY3RpdmU7CiAKIAlzcGlubG9j a190IHNpZ25hbGVyc19sb2NrOyAvKiBwcm90ZWN0cyB0aGUgbGlzdCBvZiBzaWduYWxlcnMgKi8K QEAgLTQyLDcgKzQ2LDEwIEBAIHN0cnVjdCBpbnRlbF9icmVhZGNydW1icyB7CiAJYm9vbCBpcnFf YXJtZWQ7CiAKIAkvKiBOb3QgYWxsIGJyZWFkY3J1bWJzIGFyZSBhdHRhY2hlZCB0byBwaHlzaWNh bCBIVyAqLworCWludGVsX2VuZ2luZV9tYXNrX3QJZW5naW5lX21hc2s7CiAJc3RydWN0IGludGVs X2VuZ2luZV9jcyAqaXJxX2VuZ2luZTsKKwlib29sCSgqaXJxX2VuYWJsZSkoc3RydWN0IGludGVs X2JyZWFkY3J1bWJzICpiKTsKKwl2b2lkCSgqaXJxX2Rpc2FibGUpKHN0cnVjdCBpbnRlbF9icmVh ZGNydW1icyAqYik7CiB9OwogCiAjZW5kaWYgLyogX19JTlRFTF9CUkVBRENSVU1CU19UWVBFU19f ICovCmRpZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9kcm0vaTkxNS9ndC9pbnRlbF9jb250ZXh0LmMg Yi9kcml2ZXJzL2dwdS9kcm0vaTkxNS9ndC9pbnRlbF9jb250ZXh0LmMKaW5kZXggYmQ2MzgxM2M4 YTgwLi5iMWUzZDAwZmIxZjIgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2d0L2lu dGVsX2NvbnRleHQuYworKysgYi9kcml2ZXJzL2dwdS9kcm0vaTkxNS9ndC9pbnRlbF9jb250ZXh0 LmMKQEAgLTgsNiArOCw3IEBACiAKICNpbmNsdWRlICJpOTE1X2Rydi5oIgogI2luY2x1ZGUgImk5 MTVfZ2xvYmFscy5oIgorI2luY2x1ZGUgImk5MTVfdHJhY2UuaCIKIAogI2luY2x1ZGUgImludGVs X2NvbnRleHQuaCIKICNpbmNsdWRlICJpbnRlbF9lbmdpbmUuaCIKQEAgLTI4LDYgKzI5LDcgQEAg c3RhdGljIHZvaWQgcmN1X2NvbnRleHRfZnJlZShzdHJ1Y3QgcmN1X2hlYWQgKnJjdSkKIHsKIAlz dHJ1Y3QgaW50ZWxfY29udGV4dCAqY2UgPSBjb250YWluZXJfb2YocmN1LCB0eXBlb2YoKmNlKSwg cmN1KTsKIAorCXRyYWNlX2ludGVsX2NvbnRleHRfZnJlZShjZSk7CiAJa21lbV9jYWNoZV9mcmVl KGdsb2JhbC5zbGFiX2NlLCBjZSk7CiB9CiAKQEAgLTQ2LDYgKzQ4LDcgQEAgaW50ZWxfY29udGV4 dF9jcmVhdGUoc3RydWN0IGludGVsX2VuZ2luZV9jcyAqZW5naW5lKQogCQlyZXR1cm4gRVJSX1BU UigtRU5PTUVNKTsKIAogCWludGVsX2NvbnRleHRfaW5pdChjZSwgZW5naW5lKTsKKwl0cmFjZV9p bnRlbF9jb250ZXh0X2NyZWF0ZShjZSk7CiAJcmV0dXJuIGNlOwogfQogCkBAIC04MCw3ICs4Myw3 IEBAIHN0YXRpYyBpbnQgaW50ZWxfY29udGV4dF9hY3RpdmVfYWNxdWlyZShzdHJ1Y3QgaW50ZWxf Y29udGV4dCAqY2UpCiAKIAlfX2k5MTVfYWN0aXZlX2FjcXVpcmUoJmNlLT5hY3RpdmUpOwogCi0J aWYgKGludGVsX2NvbnRleHRfaXNfYmFycmllcihjZSkpCisJaWYgKGludGVsX2NvbnRleHRfaXNf YmFycmllcihjZSkgfHwgaW50ZWxfZW5naW5lX3VzZXNfZ3VjKGNlLT5lbmdpbmUpKQogCQlyZXR1 cm4gMDsKIAogCS8qIFByZWFsbG9jYXRlIHRyYWNraW5nIG5vZGVzICovCkBAIC0yNjgsNiArMjcx LDggQEAgaW50IF9faW50ZWxfY29udGV4dF9kb19waW5fd3coc3RydWN0IGludGVsX2NvbnRleHQg KmNlLAogCiAJR0VNX0JVR19PTighaW50ZWxfY29udGV4dF9pc19waW5uZWQoY2UpKTsgLyogbm8g b3ZlcmZsb3chICovCiAKKwl0cmFjZV9pbnRlbF9jb250ZXh0X2RvX3BpbihjZSk7CisKIGVycl91 bmxvY2s6CiAJbXV0ZXhfdW5sb2NrKCZjZS0+cGluX211dGV4KTsKIGVycl9wb3N0X3VucGluOgpA QCAtMzA2LDkgKzMxMSw5IEBAIGludCBfX2ludGVsX2NvbnRleHRfZG9fcGluKHN0cnVjdCBpbnRl bF9jb250ZXh0ICpjZSkKIAlyZXR1cm4gZXJyOwogfQogCi12b2lkIGludGVsX2NvbnRleHRfdW5w aW4oc3RydWN0IGludGVsX2NvbnRleHQgKmNlKQordm9pZCBfX2ludGVsX2NvbnRleHRfZG9fdW5w aW4oc3RydWN0IGludGVsX2NvbnRleHQgKmNlLCBpbnQgc3ViKQogewotCWlmICghYXRvbWljX2Rl Y19hbmRfdGVzdCgmY2UtPnBpbl9jb3VudCkpCisJaWYgKCFhdG9taWNfc3ViX2FuZF90ZXN0KHN1 YiwgJmNlLT5waW5fY291bnQpKQogCQlyZXR1cm47CiAKIAlDRV9UUkFDRShjZSwgInVucGluXG4i KTsKQEAgLTMyMyw2ICszMjgsNyBAQCB2b2lkIGludGVsX2NvbnRleHRfdW5waW4oc3RydWN0IGlu dGVsX2NvbnRleHQgKmNlKQogCSAqLwogCWludGVsX2NvbnRleHRfZ2V0KGNlKTsKIAlpbnRlbF9j b250ZXh0X2FjdGl2ZV9yZWxlYXNlKGNlKTsKKwl0cmFjZV9pbnRlbF9jb250ZXh0X2RvX3VucGlu KGNlKTsKIAlpbnRlbF9jb250ZXh0X3B1dChjZSk7CiB9CiAKQEAgLTM2MCw2ICszNjYsMTIgQEAg c3RhdGljIGludCBfX2ludGVsX2NvbnRleHRfYWN0aXZlKHN0cnVjdCBpOTE1X2FjdGl2ZSAqYWN0 aXZlKQogCXJldHVybiAwOwogfQogCitzdGF0aWMgaW50IHN3X2ZlbmNlX2R1bW15X25vdGlmeShz dHJ1Y3QgaTkxNV9zd19mZW5jZSAqc2YsCisJCQkJIGVudW0gaTkxNV9zd19mZW5jZV9ub3RpZnkg c3RhdGUpCit7CisJcmV0dXJuIE5PVElGWV9ET05FOworfQorCiB2b2lkCiBpbnRlbF9jb250ZXh0 X2luaXQoc3RydWN0IGludGVsX2NvbnRleHQgKmNlLCBzdHJ1Y3QgaW50ZWxfZW5naW5lX2NzICpl bmdpbmUpCiB7CkBAIC0zODQsNiArMzk2LDE4IEBAIGludGVsX2NvbnRleHRfaW5pdChzdHJ1Y3Qg aW50ZWxfY29udGV4dCAqY2UsIHN0cnVjdCBpbnRlbF9lbmdpbmVfY3MgKmVuZ2luZSkKIAogCW11 dGV4X2luaXQoJmNlLT5waW5fbXV0ZXgpOwogCisJc3Bpbl9sb2NrX2luaXQoJmNlLT5ndWNfc3Rh dGUubG9jayk7CisJSU5JVF9MSVNUX0hFQUQoJmNlLT5ndWNfc3RhdGUuZmVuY2VzKTsKKworCXNw aW5fbG9ja19pbml0KCZjZS0+Z3VjX2FjdGl2ZS5sb2NrKTsKKwlJTklUX0xJU1RfSEVBRCgmY2Ut Pmd1Y19hY3RpdmUucmVxdWVzdHMpOworCisJY2UtPmd1Y19pZCA9IEdVQ19JTlZBTElEX0xSQ19J RDsKKwlJTklUX0xJU1RfSEVBRCgmY2UtPmd1Y19pZF9saW5rKTsKKworCWk5MTVfc3dfZmVuY2Vf aW5pdCgmY2UtPmd1Y19ibG9ja2VkLCBzd19mZW5jZV9kdW1teV9ub3RpZnkpOworCWk5MTVfc3df ZmVuY2VfY29tbWl0KCZjZS0+Z3VjX2Jsb2NrZWQpOworCiAJaTkxNV9hY3RpdmVfaW5pdCgmY2Ut PmFjdGl2ZSwKIAkJCSBfX2ludGVsX2NvbnRleHRfYWN0aXZlLCBfX2ludGVsX2NvbnRleHRfcmV0 aXJlLCAwKTsKIH0KQEAgLTUwMCw2ICs1MjQsMjYgQEAgc3RydWN0IGk5MTVfcmVxdWVzdCAqaW50 ZWxfY29udGV4dF9jcmVhdGVfcmVxdWVzdChzdHJ1Y3QgaW50ZWxfY29udGV4dCAqY2UpCiAJcmV0 dXJuIHJxOwogfQogCitzdHJ1Y3QgaTkxNV9yZXF1ZXN0ICppbnRlbF9jb250ZXh0X2ZpbmRfYWN0 aXZlX3JlcXVlc3Qoc3RydWN0IGludGVsX2NvbnRleHQgKmNlKQoreworCXN0cnVjdCBpOTE1X3Jl cXVlc3QgKnJxLCAqYWN0aXZlID0gTlVMTDsKKwl1bnNpZ25lZCBsb25nIGZsYWdzOworCisJR0VN X0JVR19PTighaW50ZWxfZW5naW5lX3VzZXNfZ3VjKGNlLT5lbmdpbmUpKTsKKworCXNwaW5fbG9j a19pcnFzYXZlKCZjZS0+Z3VjX2FjdGl2ZS5sb2NrLCBmbGFncyk7CisJbGlzdF9mb3JfZWFjaF9l bnRyeV9yZXZlcnNlKHJxLCAmY2UtPmd1Y19hY3RpdmUucmVxdWVzdHMsCisJCQkJICAgIHNjaGVk LmxpbmspIHsKKwkJaWYgKGk5MTVfcmVxdWVzdF9jb21wbGV0ZWQocnEpKQorCQkJYnJlYWs7CisK KwkJYWN0aXZlID0gcnE7CisJfQorCXNwaW5fdW5sb2NrX2lycXJlc3RvcmUoJmNlLT5ndWNfYWN0 aXZlLmxvY2ssIGZsYWdzKTsKKworCXJldHVybiBhY3RpdmU7Cit9CisKICNpZiBJU19FTkFCTEVE KENPTkZJR19EUk1fSTkxNV9TRUxGVEVTVCkKICNpbmNsdWRlICJzZWxmdGVzdF9jb250ZXh0LmMi CiAjZW5kaWYKZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2d0L2ludGVsX2NvbnRl eHQuaCBiL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2d0L2ludGVsX2NvbnRleHQuaAppbmRleCBiMTBj YmU4ZmVlOTkuLjg3NmJkYjA4MzAzYyAxMDA2NDQKLS0tIGEvZHJpdmVycy9ncHUvZHJtL2k5MTUv Z3QvaW50ZWxfY29udGV4dC5oCisrKyBiL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2d0L2ludGVsX2Nv bnRleHQuaApAQCAtMTYsNiArMTYsNyBAQAogI2luY2x1ZGUgImludGVsX2VuZ2luZV90eXBlcy5o IgogI2luY2x1ZGUgImludGVsX3JpbmdfdHlwZXMuaCIKICNpbmNsdWRlICJpbnRlbF90aW1lbGlu ZV90eXBlcy5oIgorI2luY2x1ZGUgImk5MTVfdHJhY2UuaCIKIAogI2RlZmluZSBDRV9UUkFDRShj ZSwgZm10LCAuLi4pIGRvIHsJCQkJCVwKIAljb25zdCBzdHJ1Y3QgaW50ZWxfY29udGV4dCAqY2Vf XyA9IChjZSk7CQkJXApAQCAtNjksNiArNzAsMTMgQEAgaW50ZWxfY29udGV4dF9pc19waW5uZWQo c3RydWN0IGludGVsX2NvbnRleHQgKmNlKQogCXJldHVybiBhdG9taWNfcmVhZCgmY2UtPnBpbl9j b3VudCk7CiB9CiAKK3N0YXRpYyBpbmxpbmUgdm9pZCBpbnRlbF9jb250ZXh0X2NhbmNlbF9yZXF1 ZXN0KHN0cnVjdCBpbnRlbF9jb250ZXh0ICpjZSwKKwkJCQkJCXN0cnVjdCBpOTE1X3JlcXVlc3Qg KnJxKQoreworCUdFTV9CVUdfT04oIWNlLT5vcHMtPmNhbmNlbF9yZXF1ZXN0KTsKKwlyZXR1cm4g Y2UtPm9wcy0+Y2FuY2VsX3JlcXVlc3QoY2UsIHJxKTsKK30KKwogLyoqCiAgKiBpbnRlbF9jb250 ZXh0X3VubG9ja19waW5uZWQgLSBSZWxlYXNlcyB0aGUgZWFybGllciBsb2NraW5nIG9mICdwaW5u ZWQnIHN0YXR1cwogICogQGNlIC0gdGhlIGNvbnRleHQKQEAgLTExMyw3ICsxMjEsMzIgQEAgc3Rh dGljIGlubGluZSB2b2lkIF9faW50ZWxfY29udGV4dF9waW4oc3RydWN0IGludGVsX2NvbnRleHQg KmNlKQogCWF0b21pY19pbmMoJmNlLT5waW5fY291bnQpOwogfQogCi12b2lkIGludGVsX2NvbnRl eHRfdW5waW4oc3RydWN0IGludGVsX2NvbnRleHQgKmNlKTsKK3ZvaWQgX19pbnRlbF9jb250ZXh0 X2RvX3VucGluKHN0cnVjdCBpbnRlbF9jb250ZXh0ICpjZSwgaW50IHN1Yik7CisKK3N0YXRpYyBp bmxpbmUgdm9pZCBpbnRlbF9jb250ZXh0X3NjaGVkX2Rpc2FibGVfdW5waW4oc3RydWN0IGludGVs X2NvbnRleHQgKmNlKQoreworCV9faW50ZWxfY29udGV4dF9kb191bnBpbihjZSwgMik7Cit9CisK K3N0YXRpYyBpbmxpbmUgdm9pZCBpbnRlbF9jb250ZXh0X3VucGluKHN0cnVjdCBpbnRlbF9jb250 ZXh0ICpjZSkKK3sKKwlpZiAoIWNlLT5vcHMtPnNjaGVkX2Rpc2FibGUpIHsKKwkJX19pbnRlbF9j b250ZXh0X2RvX3VucGluKGNlLCAxKTsKKwl9IGVsc2UgeworCQkvKgorCQkgKiBNb3ZlIG93bmVy c2hpcCBvZiB0aGlzIHBpbiB0byB0aGUgc2NoZWR1bGluZyBkaXNhYmxlIHdoaWNoIGlzCisJCSAq IGFuIGFzeW5jIG9wZXJhdGlvbi4gV2hlbiB0aGF0IG9wZXJhdGlvbiBjb21wbGV0ZXMgdGhlIGFi b3ZlCisJCSAqIGludGVsX2NvbnRleHRfc2NoZWRfZGlzYWJsZV91bnBpbiBpcyBjYWxsZWQgcG90 ZW50aWFsbHkKKwkJICogdW5waW5uaW5nIHRoZSBjb250ZXh0LgorCQkgKi8KKwkJd2hpbGUgKCFh dG9taWNfYWRkX3VubGVzcygmY2UtPnBpbl9jb3VudCwgLTEsIDEpKSB7CisJCQlpZiAoYXRvbWlj X2NtcHhjaGcoJmNlLT5waW5fY291bnQsIDEsIDIpID09IDEpIHsKKwkJCQljZS0+b3BzLT5zY2hl ZF9kaXNhYmxlKGNlKTsKKwkJCQlicmVhazsKKwkJCX0KKwkJfQorCX0KK30KIAogdm9pZCBpbnRl bF9jb250ZXh0X2VudGVyX2VuZ2luZShzdHJ1Y3QgaW50ZWxfY29udGV4dCAqY2UpOwogdm9pZCBp bnRlbF9jb250ZXh0X2V4aXRfZW5naW5lKHN0cnVjdCBpbnRlbF9jb250ZXh0ICpjZSk7CkBAIC0x NzUsNiArMjA4LDkgQEAgaW50IGludGVsX2NvbnRleHRfcHJlcGFyZV9yZW1vdGVfcmVxdWVzdChz dHJ1Y3QgaW50ZWxfY29udGV4dCAqY2UsCiAKIHN0cnVjdCBpOTE1X3JlcXVlc3QgKmludGVsX2Nv bnRleHRfY3JlYXRlX3JlcXVlc3Qoc3RydWN0IGludGVsX2NvbnRleHQgKmNlKTsKIAorc3RydWN0 IGk5MTVfcmVxdWVzdCAqCitpbnRlbF9jb250ZXh0X2ZpbmRfYWN0aXZlX3JlcXVlc3Qoc3RydWN0 IGludGVsX2NvbnRleHQgKmNlKTsKKwogc3RhdGljIGlubGluZSBib29sIGludGVsX2NvbnRleHRf aXNfYmFycmllcihjb25zdCBzdHJ1Y3QgaW50ZWxfY29udGV4dCAqY2UpCiB7CiAJcmV0dXJuIHRl c3RfYml0KENPTlRFWFRfQkFSUklFUl9CSVQsICZjZS0+ZmxhZ3MpOwpAQCAtMjE1LDYgKzI1MSwx OCBAQCBzdGF0aWMgaW5saW5lIGJvb2wgaW50ZWxfY29udGV4dF9zZXRfYmFubmVkKHN0cnVjdCBp bnRlbF9jb250ZXh0ICpjZSkKIAlyZXR1cm4gdGVzdF9hbmRfc2V0X2JpdChDT05URVhUX0JBTk5F RCwgJmNlLT5mbGFncyk7CiB9CiAKK3N0YXRpYyBpbmxpbmUgYm9vbCBpbnRlbF9jb250ZXh0X2Jh bihzdHJ1Y3QgaW50ZWxfY29udGV4dCAqY2UsCisJCQkJICAgICBzdHJ1Y3QgaTkxNV9yZXF1ZXN0 ICpycSkKK3sKKwlib29sIHJldCA9IGludGVsX2NvbnRleHRfc2V0X2Jhbm5lZChjZSk7CisKKwl0 cmFjZV9pbnRlbF9jb250ZXh0X2JhbihjZSk7CisJaWYgKGNlLT5vcHMtPmJhbikKKwkJY2UtPm9w cy0+YmFuKGNlLCBycSk7CisKKwlyZXR1cm4gcmV0OworfQorCiBzdGF0aWMgaW5saW5lIGJvb2wK IGludGVsX2NvbnRleHRfZm9yY2Vfc2luZ2xlX3N1Ym1pc3Npb24oY29uc3Qgc3RydWN0IGludGVs X2NvbnRleHQgKmNlKQogewpkaWZmIC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJtL2k5MTUvZ3QvaW50 ZWxfY29udGV4dF90eXBlcy5oIGIvZHJpdmVycy9ncHUvZHJtL2k5MTUvZ3QvaW50ZWxfY29udGV4 dF90eXBlcy5oCmluZGV4IDkwMDI2YzE3NzEwNS4uZmU1NTU1NTFjMmQyIDEwMDY0NAotLS0gYS9k cml2ZXJzL2dwdS9kcm0vaTkxNS9ndC9pbnRlbF9jb250ZXh0X3R5cGVzLmgKKysrIGIvZHJpdmVy cy9ncHUvZHJtL2k5MTUvZ3QvaW50ZWxfY29udGV4dF90eXBlcy5oCkBAIC0xMywxMiArMTMsMTQg QEAKICNpbmNsdWRlIDxsaW51eC90eXBlcy5oPgogCiAjaW5jbHVkZSAiaTkxNV9hY3RpdmVfdHlw ZXMuaCIKKyNpbmNsdWRlICJpOTE1X3N3X2ZlbmNlLmgiCiAjaW5jbHVkZSAiaTkxNV91dGlscy5o IgogI2luY2x1ZGUgImludGVsX2VuZ2luZV90eXBlcy5oIgogI2luY2x1ZGUgImludGVsX3NzZXUu aCIKIAotI2RlZmluZSBDT05URVhUX1JFRFpPTkUgUE9JU09OX0lOVVNFCisjaW5jbHVkZSAidWMv aW50ZWxfZ3VjX2Z3aWYuaCIKIAorI2RlZmluZSBDT05URVhUX1JFRFpPTkUgUE9JU09OX0lOVVNF CiBERUNMQVJFX0VXTUEocnVudGltZSwgMywgOCk7CiAKIHN0cnVjdCBpOTE1X2dlbV9jb250ZXh0 OwpAQCAtMzUsMTYgKzM3LDI5IEBAIHN0cnVjdCBpbnRlbF9jb250ZXh0X29wcyB7CiAKIAlpbnQg KCphbGxvYykoc3RydWN0IGludGVsX2NvbnRleHQgKmNlKTsKIAorCXZvaWQgKCpiYW4pKHN0cnVj dCBpbnRlbF9jb250ZXh0ICpjZSwgc3RydWN0IGk5MTVfcmVxdWVzdCAqcnEpOworCiAJaW50ICgq cHJlX3Bpbikoc3RydWN0IGludGVsX2NvbnRleHQgKmNlLCBzdHJ1Y3QgaTkxNV9nZW1fd3dfY3R4 ICp3dywgdm9pZCAqKnZhZGRyKTsKIAlpbnQgKCpwaW4pKHN0cnVjdCBpbnRlbF9jb250ZXh0ICpj ZSwgdm9pZCAqdmFkZHIpOwogCXZvaWQgKCp1bnBpbikoc3RydWN0IGludGVsX2NvbnRleHQgKmNl KTsKIAl2b2lkICgqcG9zdF91bnBpbikoc3RydWN0IGludGVsX2NvbnRleHQgKmNlKTsKIAorCXZv aWQgKCpjYW5jZWxfcmVxdWVzdCkoc3RydWN0IGludGVsX2NvbnRleHQgKmNlLAorCQkJICAgICAg IHN0cnVjdCBpOTE1X3JlcXVlc3QgKnJxKTsKKwogCXZvaWQgKCplbnRlcikoc3RydWN0IGludGVs X2NvbnRleHQgKmNlKTsKIAl2b2lkICgqZXhpdCkoc3RydWN0IGludGVsX2NvbnRleHQgKmNlKTsK IAorCXZvaWQgKCpzY2hlZF9kaXNhYmxlKShzdHJ1Y3QgaW50ZWxfY29udGV4dCAqY2UpOworCiAJ dm9pZCAoKnJlc2V0KShzdHJ1Y3QgaW50ZWxfY29udGV4dCAqY2UpOwogCXZvaWQgKCpkZXN0cm95 KShzdHJ1Y3Qga3JlZiAqa3JlZik7CisKKwkvKiB2aXJ0dWFsIGVuZ2luZS9jb250ZXh0IGludGVy ZmFjZSAqLworCXN0cnVjdCBpbnRlbF9jb250ZXh0ICooKmNyZWF0ZV92aXJ0dWFsKShzdHJ1Y3Qg aW50ZWxfZW5naW5lX2NzICoqZW5naW5lLAorCQkJCQkJdW5zaWduZWQgaW50IGNvdW50KTsKKwlz dHJ1Y3QgaW50ZWxfZW5naW5lX2NzICooKmdldF9zaWJsaW5nKShzdHJ1Y3QgaW50ZWxfZW5naW5l X2NzICplbmdpbmUsCisJCQkJCSAgICAgICB1bnNpZ25lZCBpbnQgc2libGluZyk7CiB9OwogCiBz dHJ1Y3QgaW50ZWxfY29udGV4dCB7CkBAIC05Niw2ICsxMTEsNyBAQCBzdHJ1Y3QgaW50ZWxfY29u dGV4dCB7CiAjZGVmaW5lIENPTlRFWFRfQkFOTkVECQkJNgogI2RlZmluZSBDT05URVhUX0ZPUkNF X1NJTkdMRV9TVUJNSVNTSU9OCTcKICNkZWZpbmUgQ09OVEVYVF9OT1BSRUVNUFQJCTgKKyNkZWZp bmUgQ09OVEVYVF9MUkNBX0RJUlRZCQk5CiAKIAlzdHJ1Y3QgewogCQl1NjQgdGltZW91dF91czsK QEAgLTEzNyw2ICsxNTMsNTEgQEAgc3RydWN0IGludGVsX2NvbnRleHQgewogCXN0cnVjdCBpbnRl bF9zc2V1IHNzZXU7CiAKIAl1OCB3YV9iYl9wYWdlOyAvKiBpZiBzZXQsIHBhZ2UgbnVtIHJlc2Vy dmVkIGZvciBjb250ZXh0IHdvcmthcm91bmRzICovCisKKwlzdHJ1Y3QgeworCQkvKiogbG9jazog cHJvdGVjdHMgZXZlcnl0aGluZyBpbiBndWNfc3RhdGUgKi8KKwkJc3BpbmxvY2tfdCBsb2NrOwor CQkvKioKKwkJICogc2NoZWRfc3RhdGU6IHNjaGVkdWxpbmcgc3RhdGUgb2YgdGhpcyBjb250ZXh0 IHVzaW5nIEd1QworCQkgKiBzdWJtaXNzaW9uCisJCSAqLworCQl1OCBzY2hlZF9zdGF0ZTsKKwkJ LyoKKwkJICogZmVuY2VzOiBtYWludGFpbnMgb2YgbGlzdCBvZiByZXF1ZXN0cyB0aGF0IGhhdmUg YSBzdWJtaXQKKwkJICogZmVuY2UgcmVsYXRlZCB0byBHdUMgc3VibWlzc2lvbgorCQkgKi8KKwkJ c3RydWN0IGxpc3RfaGVhZCBmZW5jZXM7CisJfSBndWNfc3RhdGU7CisKKwlzdHJ1Y3QgeworCQkv KiogbG9jazogcHJvdGVjdHMgZXZlcnl0aGluZyBpbiBndWNfYWN0aXZlICovCisJCXNwaW5sb2Nr X3QgbG9jazsKKwkJLyoqIHJlcXVlc3RzOiBhY3RpdmUgcmVxdWVzdHMgb24gdGhpcyBjb250ZXh0 ICovCisJCXN0cnVjdCBsaXN0X2hlYWQgcmVxdWVzdHM7CisJfSBndWNfYWN0aXZlOworCisJLyog R3VDIHNjaGVkdWxpbmcgc3RhdGUgZmxhZ3MgdGhhdCBkbyBub3QgcmVxdWlyZSBhIGxvY2suICov CisJYXRvbWljX3QgZ3VjX3NjaGVkX3N0YXRlX25vX2xvY2s7CisKKwkvKiBHdUMgTFJDIGRlc2Ny aXB0b3IgSUQgKi8KKwl1MTYgZ3VjX2lkOworCisJLyogR3VDIExSQyBkZXNjcmlwdG9yIHJlZmVy ZW5jZSBjb3VudCAqLworCWF0b21pY190IGd1Y19pZF9yZWY7CisKKwkvKgorCSAqIEd1QyBJRCBs aW5rIC0gaW4gbGlzdCB3aGVuIHVucGlubmVkIGJ1dCBndWNfaWQgc3RpbGwgdmFsaWQgaW4gR3VD CisJICovCisJc3RydWN0IGxpc3RfaGVhZCBndWNfaWRfbGluazsKKworCS8qIEd1QyBjb250ZXh0 IGJsb2NrZWQgZmVuY2UgKi8KKwlzdHJ1Y3QgaTkxNV9zd19mZW5jZSBndWNfYmxvY2tlZDsKKwor CS8qCisJICogR3VDIHByaW9yaXR5IG1hbmFnZW1lbnQKKwkgKi8KKwl1OCBndWNfcHJpbzsKKwl1 MzIgZ3VjX3ByaW9fY291bnRbR1VDX0NMSUVOVF9QUklPUklUWV9OVU1dOwogfTsKIAogI2VuZGlm IC8qIF9fSU5URUxfQ09OVEVYVF9UWVBFU19fICovCmRpZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9k cm0vaTkxNS9ndC9pbnRlbF9lbmdpbmUuaCBiL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2d0L2ludGVs X2VuZ2luZS5oCmluZGV4IGY5MTFjMTIyNGFiMi4uMDRjZTdhM2UxZDgyIDEwMDY0NAotLS0gYS9k cml2ZXJzL2dwdS9kcm0vaTkxNS9ndC9pbnRlbF9lbmdpbmUuaAorKysgYi9kcml2ZXJzL2dwdS9k cm0vaTkxNS9ndC9pbnRlbF9lbmdpbmUuaApAQCAtMjEyLDYgKzIxMiw5IEBAIHZvaWQgaW50ZWxf ZW5naW5lX2dldF9pbnN0ZG9uZShjb25zdCBzdHJ1Y3QgaW50ZWxfZW5naW5lX2NzICplbmdpbmUs CiAKIHZvaWQgaW50ZWxfZW5naW5lX2luaXRfZXhlY2xpc3RzKHN0cnVjdCBpbnRlbF9lbmdpbmVf Y3MgKmVuZ2luZSk7CiAKK2Jvb2wgaW50ZWxfZW5naW5lX2lycV9lbmFibGUoc3RydWN0IGludGVs X2VuZ2luZV9jcyAqZW5naW5lKTsKK3ZvaWQgaW50ZWxfZW5naW5lX2lycV9kaXNhYmxlKHN0cnVj dCBpbnRlbF9lbmdpbmVfY3MgKmVuZ2luZSk7CisKIHN0YXRpYyBpbmxpbmUgdm9pZCBfX2ludGVs X2VuZ2luZV9yZXNldChzdHJ1Y3QgaW50ZWxfZW5naW5lX2NzICplbmdpbmUsCiAJCQkJCWJvb2wg c3RhbGxlZCkKIHsKQEAgLTIzNywxMiArMjQwLDE1IEBAIF9fcHJpbnRmKDMsIDQpCiB2b2lkIGlu dGVsX2VuZ2luZV9kdW1wKHN0cnVjdCBpbnRlbF9lbmdpbmVfY3MgKmVuZ2luZSwKIAkJICAgICAg IHN0cnVjdCBkcm1fcHJpbnRlciAqbSwKIAkJICAgICAgIGNvbnN0IGNoYXIgKmhlYWRlciwgLi4u KTsKK3ZvaWQgaW50ZWxfZW5naW5lX2R1bXBfYWN0aXZlX3JlcXVlc3RzKHN0cnVjdCBsaXN0X2hl YWQgKnJlcXVlc3RzLAorCQkJCSAgICAgICBzdHJ1Y3QgaTkxNV9yZXF1ZXN0ICpodW5nX3JxLAor CQkJCSAgICAgICBzdHJ1Y3QgZHJtX3ByaW50ZXIgKm0pOwogCiBrdGltZV90IGludGVsX2VuZ2lu ZV9nZXRfYnVzeV90aW1lKHN0cnVjdCBpbnRlbF9lbmdpbmVfY3MgKmVuZ2luZSwKIAkJCQkgICBr dGltZV90ICpub3cpOwogCiBzdHJ1Y3QgaTkxNV9yZXF1ZXN0ICoKLWludGVsX2VuZ2luZV9maW5k X2FjdGl2ZV9yZXF1ZXN0KHN0cnVjdCBpbnRlbF9lbmdpbmVfY3MgKmVuZ2luZSk7CitpbnRlbF9l bmdpbmVfZXhlY2xpc3RfZmluZF9odW5nX3JlcXVlc3Qoc3RydWN0IGludGVsX2VuZ2luZV9jcyAq ZW5naW5lKTsKIAogdTMyIGludGVsX2VuZ2luZV9jb250ZXh0X3NpemUoc3RydWN0IGludGVsX2d0 ICpndCwgdTggY2xhc3MpOwogc3RydWN0IGludGVsX2NvbnRleHQgKgpAQCAtMjczLDEzICsyNzks NjAgQEAgaW50ZWxfZW5naW5lX2hhc19wcmVlbXB0X3Jlc2V0KGNvbnN0IHN0cnVjdCBpbnRlbF9l bmdpbmVfY3MgKmVuZ2luZSkKIAlyZXR1cm4gaW50ZWxfZW5naW5lX2hhc19wcmVlbXB0aW9uKGVu Z2luZSk7CiB9CiAKK3N0cnVjdCBpbnRlbF9jb250ZXh0ICoKK2ludGVsX2VuZ2luZV9jcmVhdGVf dmlydHVhbChzdHJ1Y3QgaW50ZWxfZW5naW5lX2NzICoqc2libGluZ3MsCisJCQkgICAgdW5zaWdu ZWQgaW50IGNvdW50KTsKKworc3RhdGljIGlubGluZSBib29sCitpbnRlbF92aXJ0dWFsX2VuZ2lu ZV9oYXNfaGVhcnRiZWF0KGNvbnN0IHN0cnVjdCBpbnRlbF9lbmdpbmVfY3MgKmVuZ2luZSkKK3sK KwkvKgorCSAqIEZvciBub24tR3VDIHN1Ym1pc3Npb24gd2UgZXhwZWN0IHRoZSBiYWNrLWVuZCB0 byBsb29rIGF0IHRoZQorCSAqIGhlYXJ0YmVhdCBzdGF0dXMgb2YgdGhlIGFjdHVhbCBwaHlzaWNh bCBlbmdpbmUgdGhhdCB0aGUgd29yaworCSAqIGhhcyBiZWVuIChvciBpcyBiZWluZykgc2NoZWR1 bGVkIG9uLCBzbyB3ZSBzaG91bGQgb25seSByZWFjaAorCSAqIGhlcmUgd2l0aCBHdUMgc3VibWlz c2lvbiBlbmFibGVkLgorICAJICovCisJR0VNX0JVR19PTighaW50ZWxfZW5naW5lX3VzZXNfZ3Vj KGVuZ2luZSkpOworCisJcmV0dXJuIGludGVsX2d1Y192aXJ0dWFsX2VuZ2luZV9oYXNfaGVhcnRi ZWF0KGVuZ2luZSk7Cit9CisKIHN0YXRpYyBpbmxpbmUgYm9vbAogaW50ZWxfZW5naW5lX2hhc19o ZWFydGJlYXQoY29uc3Qgc3RydWN0IGludGVsX2VuZ2luZV9jcyAqZW5naW5lKQogewogCWlmICgh SVNfQUNUSVZFKENPTkZJR19EUk1fSTkxNV9IRUFSVEJFQVRfSU5URVJWQUwpKQogCQlyZXR1cm4g ZmFsc2U7CiAKLQlyZXR1cm4gUkVBRF9PTkNFKGVuZ2luZS0+cHJvcHMuaGVhcnRiZWF0X2ludGVy dmFsX21zKTsKKwlpZiAoaW50ZWxfZW5naW5lX2lzX3ZpcnR1YWwoZW5naW5lKSkKKwkJcmV0dXJu IGludGVsX3ZpcnR1YWxfZW5naW5lX2hhc19oZWFydGJlYXQoZW5naW5lKTsKKwllbHNlCisJCXJl dHVybiBSRUFEX09OQ0UoZW5naW5lLT5wcm9wcy5oZWFydGJlYXRfaW50ZXJ2YWxfbXMpOworfQor CitzdGF0aWMgaW5saW5lIHN0cnVjdCBpbnRlbF9lbmdpbmVfY3MgKgoraW50ZWxfZW5naW5lX2dl dF9zaWJsaW5nKHN0cnVjdCBpbnRlbF9lbmdpbmVfY3MgKmVuZ2luZSwgdW5zaWduZWQgaW50IHNp YmxpbmcpCit7CisJR0VNX0JVR19PTighaW50ZWxfZW5naW5lX2lzX3ZpcnR1YWwoZW5naW5lKSk7 CisJcmV0dXJuIGVuZ2luZS0+Y29wcy0+Z2V0X3NpYmxpbmcoZW5naW5lLCBzaWJsaW5nKTsKK30K Kworc3RhdGljIGlubGluZSB2b2lkCitpbnRlbF9lbmdpbmVfc2V0X2h1bmdfY29udGV4dChzdHJ1 Y3QgaW50ZWxfZW5naW5lX2NzICplbmdpbmUsCisJCQkgICAgICBzdHJ1Y3QgaW50ZWxfY29udGV4 dCAqY2UpCit7CisJZW5naW5lLT5odW5nX2NlID0gY2U7Cit9CisKK3N0YXRpYyBpbmxpbmUgdm9p ZAoraW50ZWxfZW5naW5lX2NsZWFyX2h1bmdfY29udGV4dChzdHJ1Y3QgaW50ZWxfZW5naW5lX2Nz ICplbmdpbmUpCit7CisJaW50ZWxfZW5naW5lX3NldF9odW5nX2NvbnRleHQoZW5naW5lLCBOVUxM KTsKK30KKworc3RhdGljIGlubGluZSBzdHJ1Y3QgaW50ZWxfY29udGV4dCAqCitpbnRlbF9lbmdp bmVfZ2V0X2h1bmdfY29udGV4dChzdHJ1Y3QgaW50ZWxfZW5naW5lX2NzICplbmdpbmUpCit7CisJ cmV0dXJuIGVuZ2luZS0+aHVuZ19jZTsKIH0KIAogI2VuZGlmIC8qIF9JTlRFTF9SSU5HQlVGRkVS X0hfICovCmRpZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9kcm0vaTkxNS9ndC9pbnRlbF9lbmdpbmVf Y3MuYyBiL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2d0L2ludGVsX2VuZ2luZV9jcy5jCmluZGV4IGQ1 NjE1NzNlZDk4Yy4uNTFhMGQ4NjBkNTUxIDEwMDY0NAotLS0gYS9kcml2ZXJzL2dwdS9kcm0vaTkx NS9ndC9pbnRlbF9lbmdpbmVfY3MuYworKysgYi9kcml2ZXJzL2dwdS9kcm0vaTkxNS9ndC9pbnRl bF9lbmdpbmVfY3MuYwpAQCAtNzM5LDcgKzczOSw3IEBAIHN0YXRpYyBpbnQgZW5naW5lX3NldHVw X2NvbW1vbihzdHJ1Y3QgaW50ZWxfZW5naW5lX2NzICplbmdpbmUpCiBlcnJfY21kX3BhcnNlcjoK IAlpOTE1X3NjaGVkX2VuZ2luZV9wdXQoZW5naW5lLT5zY2hlZF9lbmdpbmUpOwogZXJyX3NjaGVk X2VuZ2luZToKLQlpbnRlbF9icmVhZGNydW1ic19mcmVlKGVuZ2luZS0+YnJlYWRjcnVtYnMpOwor CWludGVsX2JyZWFkY3J1bWJzX3B1dChlbmdpbmUtPmJyZWFkY3J1bWJzKTsKIGVycl9zdGF0dXM6 CiAJY2xlYW51cF9zdGF0dXNfcGFnZShlbmdpbmUpOwogCXJldHVybiBlcnI7CkBAIC05NDgsNyAr OTQ4LDcgQEAgdm9pZCBpbnRlbF9lbmdpbmVfY2xlYW51cF9jb21tb24oc3RydWN0IGludGVsX2Vu Z2luZV9jcyAqZW5naW5lKQogCUdFTV9CVUdfT04oIWxpc3RfZW1wdHkoJmVuZ2luZS0+c2NoZWRf ZW5naW5lLT5yZXF1ZXN0cykpOwogCiAJaTkxNV9zY2hlZF9lbmdpbmVfcHV0KGVuZ2luZS0+c2No ZWRfZW5naW5lKTsKLQlpbnRlbF9icmVhZGNydW1ic19mcmVlKGVuZ2luZS0+YnJlYWRjcnVtYnMp OworCWludGVsX2JyZWFkY3J1bWJzX3B1dChlbmdpbmUtPmJyZWFkY3J1bWJzKTsKIAogCWludGVs X2VuZ2luZV9maW5pX3JldGlyZShlbmdpbmUpOwogCWludGVsX2VuZ2luZV9jbGVhbnVwX2NtZF9w YXJzZXIoZW5naW5lKTsKQEAgLTEyNjUsNiArMTI2NSwzMCBAQCBib29sIGludGVsX2VuZ2luZXNf YXJlX2lkbGUoc3RydWN0IGludGVsX2d0ICpndCkKIAlyZXR1cm4gdHJ1ZTsKIH0KIAorYm9vbCBp bnRlbF9lbmdpbmVfaXJxX2VuYWJsZShzdHJ1Y3QgaW50ZWxfZW5naW5lX2NzICplbmdpbmUpCit7 CisJaWYgKCFlbmdpbmUtPmlycV9lbmFibGUpCisJCXJldHVybiBmYWxzZTsKKworCS8qIENhbGxl ciBkaXNhYmxlcyBpbnRlcnJ1cHRzICovCisJc3Bpbl9sb2NrKCZlbmdpbmUtPmd0LT5pcnFfbG9j ayk7CisJZW5naW5lLT5pcnFfZW5hYmxlKGVuZ2luZSk7CisJc3Bpbl91bmxvY2soJmVuZ2luZS0+ Z3QtPmlycV9sb2NrKTsKKworCXJldHVybiB0cnVlOworfQorCit2b2lkIGludGVsX2VuZ2luZV9p cnFfZGlzYWJsZShzdHJ1Y3QgaW50ZWxfZW5naW5lX2NzICplbmdpbmUpCit7CisJaWYgKCFlbmdp bmUtPmlycV9kaXNhYmxlKQorCQlyZXR1cm47CisKKwkvKiBDYWxsZXIgZGlzYWJsZXMgaW50ZXJy dXB0cyAqLworCXNwaW5fbG9jaygmZW5naW5lLT5ndC0+aXJxX2xvY2spOworCWVuZ2luZS0+aXJx X2Rpc2FibGUoZW5naW5lKTsKKwlzcGluX3VubG9jaygmZW5naW5lLT5ndC0+aXJxX2xvY2spOwor fQorCiB2b2lkIGludGVsX2VuZ2luZXNfcmVzZXRfZGVmYXVsdF9zdWJtaXNzaW9uKHN0cnVjdCBp bnRlbF9ndCAqZ3QpCiB7CiAJc3RydWN0IGludGVsX2VuZ2luZV9jcyAqZW5naW5lOwpAQCAtMTYw MSw2ICsxNjI1LDk3IEBAIHN0YXRpYyB2b2lkIHByaW50X3Byb3BlcnRpZXMoc3RydWN0IGludGVs X2VuZ2luZV9jcyAqZW5naW5lLAogCQkJICAgcmVhZF91bCgmZW5naW5lLT5kZWZhdWx0cywgcC0+ b2Zmc2V0KSk7CiB9CiAKK3N0YXRpYyB2b2lkIGVuZ2luZV9kdW1wX3JlcXVlc3Qoc3RydWN0IGk5 MTVfcmVxdWVzdCAqcnEsIHN0cnVjdCBkcm1fcHJpbnRlciAqbSwgY29uc3QgY2hhciAqbXNnKQor eworCXN0cnVjdCBpbnRlbF90aW1lbGluZSAqdGwgPSBnZXRfdGltZWxpbmUocnEpOworCisJaTkx NV9yZXF1ZXN0X3Nob3cobSwgcnEsIG1zZywgMCk7CisKKwlkcm1fcHJpbnRmKG0sICJcdFx0cmlu Zy0+c3RhcnQ6ICAweCUwOHhcbiIsCisJCSAgIGk5MTVfZ2d0dF9vZmZzZXQocnEtPnJpbmctPnZt YSkpOworCWRybV9wcmludGYobSwgIlx0XHRyaW5nLT5oZWFkOiAgIDB4JTA4eFxuIiwKKwkJICAg cnEtPnJpbmctPmhlYWQpOworCWRybV9wcmludGYobSwgIlx0XHRyaW5nLT50YWlsOiAgIDB4JTA4 eFxuIiwKKwkJICAgcnEtPnJpbmctPnRhaWwpOworCWRybV9wcmludGYobSwgIlx0XHRyaW5nLT5l bWl0OiAgIDB4JTA4eFxuIiwKKwkJICAgcnEtPnJpbmctPmVtaXQpOworCWRybV9wcmludGYobSwg Ilx0XHRyaW5nLT5zcGFjZTogIDB4JTA4eFxuIiwKKwkJICAgcnEtPnJpbmctPnNwYWNlKTsKKwor CWlmICh0bCkgeworCQlkcm1fcHJpbnRmKG0sICJcdFx0cmluZy0+aHdzcDogICAweCUwOHhcbiIs CisJCQkgICB0bC0+aHdzcF9vZmZzZXQpOworCQlpbnRlbF90aW1lbGluZV9wdXQodGwpOworCX0K KworCXByaW50X3JlcXVlc3RfcmluZyhtLCBycSk7CisKKwlpZiAocnEtPmNvbnRleHQtPmxyY19y ZWdfc3RhdGUpIHsKKwkJZHJtX3ByaW50ZihtLCAiTG9naWNhbCBSaW5nIENvbnRleHQ6XG4iKTsK KwkJaGV4ZHVtcChtLCBycS0+Y29udGV4dC0+bHJjX3JlZ19zdGF0ZSwgUEFHRV9TSVpFKTsKKwl9 Cit9CisKK3ZvaWQgaW50ZWxfZW5naW5lX2R1bXBfYWN0aXZlX3JlcXVlc3RzKHN0cnVjdCBsaXN0 X2hlYWQgKnJlcXVlc3RzLAorCQkJCSAgICAgICBzdHJ1Y3QgaTkxNV9yZXF1ZXN0ICpodW5nX3Jx LAorCQkJCSAgICAgICBzdHJ1Y3QgZHJtX3ByaW50ZXIgKm0pCit7CisJc3RydWN0IGk5MTVfcmVx dWVzdCAqcnE7CisJY29uc3QgY2hhciAqbXNnOworCWVudW0gaTkxNV9yZXF1ZXN0X3N0YXRlIHN0 YXRlOworCisJbGlzdF9mb3JfZWFjaF9lbnRyeShycSwgcmVxdWVzdHMsIHNjaGVkLmxpbmspIHsK KwkJaWYgKHJxID09IGh1bmdfcnEpCisJCQljb250aW51ZTsKKworCQlzdGF0ZSA9IGk5MTVfdGVz dF9yZXF1ZXN0X3N0YXRlKHJxKTsKKwkJaWYgKHN0YXRlIDwgSTkxNV9SRVFVRVNUX1FVRVVFRCkK KwkJCWNvbnRpbnVlOworCisJCWlmIChzdGF0ZSA9PSBJOTE1X1JFUVVFU1RfQUNUSVZFKQorCQkJ bXNnID0gIlx0XHRhY3RpdmUgb24gZW5naW5lIjsKKwkJZWxzZQorCQkJbXNnID0gIlx0XHRhY3Rp dmUgaW4gcXVldWUiOworCisJCWVuZ2luZV9kdW1wX3JlcXVlc3QocnEsIG0sIG1zZyk7CisJfQor fQorCitzdGF0aWMgdm9pZCBlbmdpbmVfZHVtcF9hY3RpdmVfcmVxdWVzdHMoc3RydWN0IGludGVs X2VuZ2luZV9jcyAqZW5naW5lLCBzdHJ1Y3QgZHJtX3ByaW50ZXIgKm0pCit7CisJc3RydWN0IGk5 MTVfcmVxdWVzdCAqaHVuZ19ycSA9IE5VTEw7CisJc3RydWN0IGludGVsX2NvbnRleHQgKmNlOwor CWJvb2wgZ3VjOworCisJLyoKKwkgKiBObyBuZWVkIGZvciBhbiBlbmdpbmUtPmlycV9zZXFub19i YXJyaWVyKCkgYmVmb3JlIHRoZSBzZXFubyByZWFkcy4KKwkgKiBUaGUgR1BVIGlzIHN0aWxsIHJ1 bm5pbmcgc28gcmVxdWVzdHMgYXJlIHN0aWxsIGV4ZWN1dGluZyBhbmQgYW55CisJICogaGFyZHdh cmUgcmVhZHMgd2lsbCBiZSBvdXQgb2YgZGF0ZSBieSB0aGUgdGltZSB0aGV5IGFyZSByZXBvcnRl ZC4KKwkgKiBCdXQgdGhlIGludGVudGlvbiBoZXJlIGlzIGp1c3QgdG8gcmVwb3J0IGFuIGluc3Rh bnRhbmVvdXMgc25hcHNob3QKKwkgKiBzbyB0aGF0J3MgZmluZS4KKwkgKi8KKwlsb2NrZGVwX2Fz c2VydF9oZWxkKCZlbmdpbmUtPnNjaGVkX2VuZ2luZS0+bG9jayk7CisKKwlkcm1fcHJpbnRmKG0s ICJcdFJlcXVlc3RzOlxuIik7CisKKwlndWMgPSBpbnRlbF91Y191c2VzX2d1Y19zdWJtaXNzaW9u KCZlbmdpbmUtPmd0LT51Yyk7CisJaWYgKGd1YykgeworCQljZSA9IGludGVsX2VuZ2luZV9nZXRf aHVuZ19jb250ZXh0KGVuZ2luZSk7CisJCWlmIChjZSkKKwkJCWh1bmdfcnEgPSBpbnRlbF9jb250 ZXh0X2ZpbmRfYWN0aXZlX3JlcXVlc3QoY2UpOworCX0gZWxzZQorCQlodW5nX3JxID0gaW50ZWxf ZW5naW5lX2V4ZWNsaXN0X2ZpbmRfaHVuZ19yZXF1ZXN0KGVuZ2luZSk7CisKKwlpZiAoaHVuZ19y cSkKKwkJZW5naW5lX2R1bXBfcmVxdWVzdChodW5nX3JxLCBtLCAiXHRcdGh1bmciKTsKKworCWlm IChndWMpCisJCWludGVsX2d1Y19kdW1wX2FjdGl2ZV9yZXF1ZXN0cyhlbmdpbmUsIGh1bmdfcnEs IG0pOworCWVsc2UKKwkJaW50ZWxfZW5naW5lX2R1bXBfYWN0aXZlX3JlcXVlc3RzKCZlbmdpbmUt PnNjaGVkX2VuZ2luZS0+cmVxdWVzdHMsCisJCQkJCQkgIGh1bmdfcnEsIG0pOworfQorCiB2b2lk IGludGVsX2VuZ2luZV9kdW1wKHN0cnVjdCBpbnRlbF9lbmdpbmVfY3MgKmVuZ2luZSwKIAkJICAg ICAgIHN0cnVjdCBkcm1fcHJpbnRlciAqbSwKIAkJICAgICAgIGNvbnN0IGNoYXIgKmhlYWRlciwg Li4uKQpAQCAtMTY0NSwzOSArMTc2MCw5IEBAIHZvaWQgaW50ZWxfZW5naW5lX2R1bXAoc3RydWN0 IGludGVsX2VuZ2luZV9jcyAqZW5naW5lLAogCQkgICBpOTE1X3Jlc2V0X2NvdW50KGVycm9yKSk7 CiAJcHJpbnRfcHJvcGVydGllcyhlbmdpbmUsIG0pOwogCi0JZHJtX3ByaW50ZihtLCAiXHRSZXF1 ZXN0czpcbiIpOwotCiAJc3Bpbl9sb2NrX2lycXNhdmUoJmVuZ2luZS0+c2NoZWRfZW5naW5lLT5s b2NrLCBmbGFncyk7Ci0JcnEgPSBpbnRlbF9lbmdpbmVfZmluZF9hY3RpdmVfcmVxdWVzdChlbmdp bmUpOwotCWlmIChycSkgewotCQlzdHJ1Y3QgaW50ZWxfdGltZWxpbmUgKnRsID0gZ2V0X3RpbWVs aW5lKHJxKTsKKwllbmdpbmVfZHVtcF9hY3RpdmVfcmVxdWVzdHMoZW5naW5lLCBtKTsKIAotCQlp OTE1X3JlcXVlc3Rfc2hvdyhtLCBycSwgIlx0XHRhY3RpdmUgIiwgMCk7Ci0KLQkJZHJtX3ByaW50 ZihtLCAiXHRcdHJpbmctPnN0YXJ0OiAgMHglMDh4XG4iLAotCQkJICAgaTkxNV9nZ3R0X29mZnNl dChycS0+cmluZy0+dm1hKSk7Ci0JCWRybV9wcmludGYobSwgIlx0XHRyaW5nLT5oZWFkOiAgIDB4 JTA4eFxuIiwKLQkJCSAgIHJxLT5yaW5nLT5oZWFkKTsKLQkJZHJtX3ByaW50ZihtLCAiXHRcdHJp bmctPnRhaWw6ICAgMHglMDh4XG4iLAotCQkJICAgcnEtPnJpbmctPnRhaWwpOwotCQlkcm1fcHJp bnRmKG0sICJcdFx0cmluZy0+ZW1pdDogICAweCUwOHhcbiIsCi0JCQkgICBycS0+cmluZy0+ZW1p dCk7Ci0JCWRybV9wcmludGYobSwgIlx0XHRyaW5nLT5zcGFjZTogIDB4JTA4eFxuIiwKLQkJCSAg IHJxLT5yaW5nLT5zcGFjZSk7Ci0KLQkJaWYgKHRsKSB7Ci0JCQlkcm1fcHJpbnRmKG0sICJcdFx0 cmluZy0+aHdzcDogICAweCUwOHhcbiIsCi0JCQkJICAgdGwtPmh3c3Bfb2Zmc2V0KTsKLQkJCWlu dGVsX3RpbWVsaW5lX3B1dCh0bCk7Ci0JCX0KLQotCQlwcmludF9yZXF1ZXN0X3JpbmcobSwgcnEp OwotCi0JCWlmIChycS0+Y29udGV4dC0+bHJjX3JlZ19zdGF0ZSkgewotCQkJZHJtX3ByaW50Ziht LCAiTG9naWNhbCBSaW5nIENvbnRleHQ6XG4iKTsKLQkJCWhleGR1bXAobSwgcnEtPmNvbnRleHQt PmxyY19yZWdfc3RhdGUsIFBBR0VfU0laRSk7Ci0JCX0KLQl9CiAJZHJtX3ByaW50ZihtLCAiXHRP biBob2xkPzogJWx1XG4iLAogCQkgICBsaXN0X2NvdW50KCZlbmdpbmUtPnNjaGVkX2VuZ2luZS0+ aG9sZCkpOwogCXNwaW5fdW5sb2NrX2lycXJlc3RvcmUoJmVuZ2luZS0+c2NoZWRfZW5naW5lLT5s b2NrLCBmbGFncyk7CkBAIC0xNzM3LDE4ICsxODIyLDMyIEBAIGt0aW1lX3QgaW50ZWxfZW5naW5l X2dldF9idXN5X3RpbWUoc3RydWN0IGludGVsX2VuZ2luZV9jcyAqZW5naW5lLCBrdGltZV90ICpu b3cpCiAJcmV0dXJuIHRvdGFsOwogfQogCi1zdGF0aWMgYm9vbCBtYXRjaF9yaW5nKHN0cnVjdCBp OTE1X3JlcXVlc3QgKnJxKQorc3RydWN0IGludGVsX2NvbnRleHQgKgoraW50ZWxfZW5naW5lX2Ny ZWF0ZV92aXJ0dWFsKHN0cnVjdCBpbnRlbF9lbmdpbmVfY3MgKipzaWJsaW5ncywKKwkJCSAgICB1 bnNpZ25lZCBpbnQgY291bnQpCiB7Ci0JdTMyIHJpbmcgPSBFTkdJTkVfUkVBRChycS0+ZW5naW5l LCBSSU5HX1NUQVJUKTsKKwlpZiAoY291bnQgPT0gMCkKKwkJcmV0dXJuIEVSUl9QVFIoLUVJTlZB TCk7CisKKwlpZiAoY291bnQgPT0gMSkKKwkJcmV0dXJuIGludGVsX2NvbnRleHRfY3JlYXRlKHNp YmxpbmdzWzBdKTsKIAotCXJldHVybiByaW5nID09IGk5MTVfZ2d0dF9vZmZzZXQocnEtPnJpbmct PnZtYSk7CisJR0VNX0JVR19PTighc2libGluZ3NbMF0tPmNvcHMtPmNyZWF0ZV92aXJ0dWFsKTsK KwlyZXR1cm4gc2libGluZ3NbMF0tPmNvcHMtPmNyZWF0ZV92aXJ0dWFsKHNpYmxpbmdzLCBjb3Vu dCk7CiB9CiAKIHN0cnVjdCBpOTE1X3JlcXVlc3QgKgotaW50ZWxfZW5naW5lX2ZpbmRfYWN0aXZl X3JlcXVlc3Qoc3RydWN0IGludGVsX2VuZ2luZV9jcyAqZW5naW5lKQoraW50ZWxfZW5naW5lX2V4 ZWNsaXN0X2ZpbmRfaHVuZ19yZXF1ZXN0KHN0cnVjdCBpbnRlbF9lbmdpbmVfY3MgKmVuZ2luZSkK IHsKIAlzdHJ1Y3QgaTkxNV9yZXF1ZXN0ICpyZXF1ZXN0LCAqYWN0aXZlID0gTlVMTDsKIAorCS8q CisJICogVGhpcyBzZWFyY2ggZG9lcyBub3Qgd29yayBpbiBHdUMgc3VibWlzc2lvbiBtb2RlLiBI b3dldmVyLCB0aGUgR3VDCisJICogd2lsbCByZXBvcnQgdGhlIGhhbmdpbmcgY29udGV4dCBkaXJl Y3RseSB0byB0aGUgZHJpdmVyIGl0c2VsZi4gU28KKwkgKiB0aGUgZHJpdmVyIHNob3VsZCBuZXZl ciBnZXQgaGVyZSB3aGVuIGluIEd1QyBtb2RlLgorCSAqLworCUdFTV9CVUdfT04oaW50ZWxfdWNf dXNlc19ndWNfc3VibWlzc2lvbigmZW5naW5lLT5ndC0+dWMpKTsKKwogCS8qCiAJICogV2UgYXJl IGNhbGxlZCBieSB0aGUgZXJyb3IgY2FwdHVyZSwgcmVzZXQgYW5kIHRvIGR1bXAgZW5naW5lCiAJ ICogc3RhdGUgYXQgcmFuZG9tIHBvaW50cyBpbiB0aW1lLiBJbiBwYXJ0aWN1bGFyLCBub3RlIHRo YXQgbmVpdGhlciBpcwpAQCAtMTc4MCwxNCArMTg3OSw3IEBAIGludGVsX2VuZ2luZV9maW5kX2Fj dGl2ZV9yZXF1ZXN0KHN0cnVjdCBpbnRlbF9lbmdpbmVfY3MgKmVuZ2luZSkKIAogCWxpc3RfZm9y X2VhY2hfZW50cnkocmVxdWVzdCwgJmVuZ2luZS0+c2NoZWRfZW5naW5lLT5yZXF1ZXN0cywKIAkJ CSAgICBzY2hlZC5saW5rKSB7Ci0JCWlmIChfX2k5MTVfcmVxdWVzdF9pc19jb21wbGV0ZShyZXF1 ZXN0KSkKLQkJCWNvbnRpbnVlOwotCi0JCWlmICghX19pOTE1X3JlcXVlc3RfaGFzX3N0YXJ0ZWQo cmVxdWVzdCkpCi0JCQljb250aW51ZTsKLQotCQkvKiBNb3JlIHRoYW4gb25lIHByZWVtcHRpYmxl IHJlcXVlc3QgbWF5IG1hdGNoISAqLwotCQlpZiAoIW1hdGNoX3JpbmcocmVxdWVzdCkpCisJCWlm IChpOTE1X3Rlc3RfcmVxdWVzdF9zdGF0ZShyZXF1ZXN0KSAhPSBJOTE1X1JFUVVFU1RfQUNUSVZF KQogCQkJY29udGludWU7CiAKIAkJYWN0aXZlID0gcmVxdWVzdDsKZGlmZiAtLWdpdCBhL2RyaXZl cnMvZ3B1L2RybS9pOTE1L2d0L2ludGVsX2VuZ2luZV9oZWFydGJlYXQuYyBiL2RyaXZlcnMvZ3B1 L2RybS9pOTE1L2d0L2ludGVsX2VuZ2luZV9oZWFydGJlYXQuYwppbmRleCBiNmEzMDVlNmE5NzQu LmYwNzY4ODI0ZGU2ZiAxMDA2NDQKLS0tIGEvZHJpdmVycy9ncHUvZHJtL2k5MTUvZ3QvaW50ZWxf ZW5naW5lX2hlYXJ0YmVhdC5jCisrKyBiL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2d0L2ludGVsX2Vu Z2luZV9oZWFydGJlYXQuYwpAQCAtNzAsMTIgKzcwLDM4IEBAIHN0YXRpYyB2b2lkIHNob3dfaGVh cnRiZWF0KGNvbnN0IHN0cnVjdCBpOTE1X3JlcXVlc3QgKnJxLAogewogCXN0cnVjdCBkcm1fcHJp bnRlciBwID0gZHJtX2RlYnVnX3ByaW50ZXIoImhlYXJ0YmVhdCIpOwogCi0JaW50ZWxfZW5naW5l X2R1bXAoZW5naW5lLCAmcCwKLQkJCSAgIiVzIGhlYXJ0YmVhdCB7c2Vxbm86JWxseDolbGxkLCBw cmlvOiVkfSBub3QgdGlja2luZ1xuIiwKLQkJCSAgZW5naW5lLT5uYW1lLAotCQkJICBycS0+ZmVu Y2UuY29udGV4dCwKLQkJCSAgcnEtPmZlbmNlLnNlcW5vLAotCQkJICBycS0+c2NoZWQuYXR0ci5w cmlvcml0eSk7CisJaWYgKCFycSkgeworCQlpbnRlbF9lbmdpbmVfZHVtcChlbmdpbmUsICZwLAor CQkJCSAgIiVzIGhlYXJ0YmVhdCBub3QgdGlja2luZ1xuIiwKKwkJCQkgIGVuZ2luZS0+bmFtZSk7 CisJfSBlbHNlIHsKKwkJaW50ZWxfZW5naW5lX2R1bXAoZW5naW5lLCAmcCwKKwkJCQkgICIlcyBo ZWFydGJlYXQge3NlcW5vOiVsbHg6JWxsZCwgcHJpbzolZH0gbm90IHRpY2tpbmdcbiIsCisJCQkJ ICBlbmdpbmUtPm5hbWUsCisJCQkJICBycS0+ZmVuY2UuY29udGV4dCwKKwkJCQkgIHJxLT5mZW5j ZS5zZXFubywKKwkJCQkgIHJxLT5zY2hlZC5hdHRyLnByaW9yaXR5KTsKKwl9Cit9CisKK3N0YXRp YyB2b2lkCityZXNldF9lbmdpbmUoc3RydWN0IGludGVsX2VuZ2luZV9jcyAqZW5naW5lLCBzdHJ1 Y3QgaTkxNV9yZXF1ZXN0ICpycSkKK3sKKwlpZiAoSVNfRU5BQkxFRChDT05GSUdfRFJNX0k5MTVf REVCVUdfR0VNKSkKKwkJc2hvd19oZWFydGJlYXQocnEsIGVuZ2luZSk7CisKKwlpZiAoaW50ZWxf ZW5naW5lX3VzZXNfZ3VjKGVuZ2luZSkpCisJCS8qCisJCSAqIEd1QyBpdHNlbGYgaXMgdG9hc3Qg b3IgR3VDJ3MgaGFuZyBkZXRlY3Rpb24KKwkJICogaXMgZGlzYWJsZWQuIEVpdGhlciB3YXksIG5l ZWQgdG8gZmluZCB0aGUKKwkJICogaGFuZyBjdWxwcml0IG1hbnVhbGx5LgorCQkgKi8KKwkJaW50 ZWxfZ3VjX2ZpbmRfaHVuZ19jb250ZXh0KGVuZ2luZSk7CisKKwlpbnRlbF9ndF9oYW5kbGVfZXJy b3IoZW5naW5lLT5ndCwgZW5naW5lLT5tYXNrLAorCQkJICAgICAgSTkxNV9FUlJPUl9DQVBUVVJF LAorCQkJICAgICAgInN0b3BwZWQgaGVhcnRiZWF0IG9uICVzIiwKKwkJCSAgICAgIGVuZ2luZS0+ bmFtZSk7CiB9CiAKIHN0YXRpYyB2b2lkIGhlYXJ0YmVhdChzdHJ1Y3Qgd29ya19zdHJ1Y3QgKndy aykKQEAgLTEwMiw2ICsxMjgsMTEgQEAgc3RhdGljIHZvaWQgaGVhcnRiZWF0KHN0cnVjdCB3b3Jr X3N0cnVjdCAqd3JrKQogCWlmIChpbnRlbF9ndF9pc193ZWRnZWQoZW5naW5lLT5ndCkpCiAJCWdv dG8gb3V0OwogCisJaWYgKGk5MTVfc2NoZWRfZW5naW5lX2Rpc2FibGVkKGVuZ2luZS0+c2NoZWRf ZW5naW5lKSkgeworCQlyZXNldF9lbmdpbmUoZW5naW5lLCBlbmdpbmUtPmhlYXJ0YmVhdC5zeXN0 b2xlKTsKKwkJZ290byBvdXQ7CisJfQorCiAJaWYgKGVuZ2luZS0+aGVhcnRiZWF0LnN5c3RvbGUp IHsKIAkJbG9uZyBkZWxheSA9IFJFQURfT05DRShlbmdpbmUtPnByb3BzLmhlYXJ0YmVhdF9pbnRl cnZhbF9tcyk7CiAKQEAgLTEzOSwxMyArMTcwLDcgQEAgc3RhdGljIHZvaWQgaGVhcnRiZWF0KHN0 cnVjdCB3b3JrX3N0cnVjdCAqd3JrKQogCQkJZW5naW5lLT5zY2hlZF9lbmdpbmUtPnNjaGVkdWxl KHJxLCAmYXR0cik7CiAJCQlsb2NhbF9iaF9lbmFibGUoKTsKIAkJfSBlbHNlIHsKLQkJCWlmIChJ U19FTkFCTEVEKENPTkZJR19EUk1fSTkxNV9ERUJVR19HRU0pKQotCQkJCXNob3dfaGVhcnRiZWF0 KHJxLCBlbmdpbmUpOwotCi0JCQlpbnRlbF9ndF9oYW5kbGVfZXJyb3IoZW5naW5lLT5ndCwgZW5n aW5lLT5tYXNrLAotCQkJCQkgICAgICBJOTE1X0VSUk9SX0NBUFRVUkUsCi0JCQkJCSAgICAgICJz dG9wcGVkIGhlYXJ0YmVhdCBvbiAlcyIsCi0JCQkJCSAgICAgIGVuZ2luZS0+bmFtZSk7CisJCQly ZXNldF9lbmdpbmUoZW5naW5lLCBycSk7CiAJCX0KIAogCQlycS0+ZW1pdHRlZF9qaWZmaWVzID0g amlmZmllczsKQEAgLTE5NCw2ICsyMTksMjYgQEAgdm9pZCBpbnRlbF9lbmdpbmVfcGFya19oZWFy dGJlYXQoc3RydWN0IGludGVsX2VuZ2luZV9jcyAqZW5naW5lKQogCQlpOTE1X3JlcXVlc3RfcHV0 KGZldGNoX2FuZF96ZXJvKCZlbmdpbmUtPmhlYXJ0YmVhdC5zeXN0b2xlKSk7CiB9CiAKK3ZvaWQg aW50ZWxfZ3RfdW5wYXJrX2hlYXJ0YmVhdHMoc3RydWN0IGludGVsX2d0ICpndCkKK3sKKwlzdHJ1 Y3QgaW50ZWxfZW5naW5lX2NzICplbmdpbmU7CisJZW51bSBpbnRlbF9lbmdpbmVfaWQgaWQ7CisK Kwlmb3JfZWFjaF9lbmdpbmUoZW5naW5lLCBndCwgaWQpCisJCWlmIChpbnRlbF9lbmdpbmVfcG1f aXNfYXdha2UoZW5naW5lKSkKKwkJCWludGVsX2VuZ2luZV91bnBhcmtfaGVhcnRiZWF0KGVuZ2lu ZSk7CisKK30KKwordm9pZCBpbnRlbF9ndF9wYXJrX2hlYXJ0YmVhdHMoc3RydWN0IGludGVsX2d0 ICpndCkKK3sKKwlzdHJ1Y3QgaW50ZWxfZW5naW5lX2NzICplbmdpbmU7CisJZW51bSBpbnRlbF9l bmdpbmVfaWQgaWQ7CisKKwlmb3JfZWFjaF9lbmdpbmUoZW5naW5lLCBndCwgaWQpCisJCWludGVs X2VuZ2luZV9wYXJrX2hlYXJ0YmVhdChlbmdpbmUpOworfQorCiB2b2lkIGludGVsX2VuZ2luZV9p bml0X2hlYXJ0YmVhdChzdHJ1Y3QgaW50ZWxfZW5naW5lX2NzICplbmdpbmUpCiB7CiAJSU5JVF9E RUxBWUVEX1dPUksoJmVuZ2luZS0+aGVhcnRiZWF0LndvcmssIGhlYXJ0YmVhdCk7CmRpZmYgLS1n aXQgYS9kcml2ZXJzL2dwdS9kcm0vaTkxNS9ndC9pbnRlbF9lbmdpbmVfaGVhcnRiZWF0LmggYi9k cml2ZXJzL2dwdS9kcm0vaTkxNS9ndC9pbnRlbF9lbmdpbmVfaGVhcnRiZWF0LmgKaW5kZXggYTQ4 OGVhM2U4NGEzLi41ZGE2ZDgwOWE4N2EgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvZ3B1L2RybS9pOTE1 L2d0L2ludGVsX2VuZ2luZV9oZWFydGJlYXQuaAorKysgYi9kcml2ZXJzL2dwdS9kcm0vaTkxNS9n dC9pbnRlbF9lbmdpbmVfaGVhcnRiZWF0LmgKQEAgLTcsNiArNyw3IEBACiAjZGVmaW5lIElOVEVM X0VOR0lORV9IRUFSVEJFQVRfSAogCiBzdHJ1Y3QgaW50ZWxfZW5naW5lX2NzOworc3RydWN0IGlu dGVsX2d0OwogCiB2b2lkIGludGVsX2VuZ2luZV9pbml0X2hlYXJ0YmVhdChzdHJ1Y3QgaW50ZWxf ZW5naW5lX2NzICplbmdpbmUpOwogCkBAIC0xNiw2ICsxNyw5IEBAIGludCBpbnRlbF9lbmdpbmVf c2V0X2hlYXJ0YmVhdChzdHJ1Y3QgaW50ZWxfZW5naW5lX2NzICplbmdpbmUsCiB2b2lkIGludGVs X2VuZ2luZV9wYXJrX2hlYXJ0YmVhdChzdHJ1Y3QgaW50ZWxfZW5naW5lX2NzICplbmdpbmUpOwog dm9pZCBpbnRlbF9lbmdpbmVfdW5wYXJrX2hlYXJ0YmVhdChzdHJ1Y3QgaW50ZWxfZW5naW5lX2Nz ICplbmdpbmUpOwogCit2b2lkIGludGVsX2d0X3BhcmtfaGVhcnRiZWF0cyhzdHJ1Y3QgaW50ZWxf Z3QgKmd0KTsKK3ZvaWQgaW50ZWxfZ3RfdW5wYXJrX2hlYXJ0YmVhdHMoc3RydWN0IGludGVsX2d0 ICpndCk7CisKIGludCBpbnRlbF9lbmdpbmVfcHVsc2Uoc3RydWN0IGludGVsX2VuZ2luZV9jcyAq ZW5naW5lKTsKIGludCBpbnRlbF9lbmdpbmVfZmx1c2hfYmFycmllcnMoc3RydWN0IGludGVsX2Vu Z2luZV9jcyAqZW5naW5lKTsKIApkaWZmIC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJtL2k5MTUvZ3Qv aW50ZWxfZW5naW5lX3R5cGVzLmggYi9kcml2ZXJzL2dwdS9kcm0vaTkxNS9ndC9pbnRlbF9lbmdp bmVfdHlwZXMuaAppbmRleCAxY2I5YzNiNzBiMjkuLmVlYzU3ZTU3NDAzZiAxMDA2NDQKLS0tIGEv ZHJpdmVycy9ncHUvZHJtL2k5MTUvZ3QvaW50ZWxfZW5naW5lX3R5cGVzLmgKKysrIGIvZHJpdmVy cy9ncHUvZHJtL2k5MTUvZ3QvaW50ZWxfZW5naW5lX3R5cGVzLmgKQEAgLTIxLDcgKzIxLDYgQEAK ICNpbmNsdWRlICJpOTE1X3BtdS5oIgogI2luY2x1ZGUgImk5MTVfcHJpb2xpc3RfdHlwZXMuaCIK ICNpbmNsdWRlICJpOTE1X3NlbGZ0ZXN0LmgiCi0jaW5jbHVkZSAiaW50ZWxfYnJlYWRjcnVtYnNf dHlwZXMuaCIKICNpbmNsdWRlICJpbnRlbF9zc2V1LmgiCiAjaW5jbHVkZSAiaW50ZWxfdGltZWxp bmVfdHlwZXMuaCIKICNpbmNsdWRlICJpbnRlbF91bmNvcmUuaCIKQEAgLTYzLDYgKzYyLDcgQEAg c3RydWN0IGk5MTVfc2NoZWRfZW5naW5lOwogc3RydWN0IGludGVsX2d0Owogc3RydWN0IGludGVs X3Jpbmc7CiBzdHJ1Y3QgaW50ZWxfdW5jb3JlOworc3RydWN0IGludGVsX2JyZWFkY3J1bWJzOwog CiB0eXBlZGVmIHU4IGludGVsX2VuZ2luZV9tYXNrX3Q7CiAjZGVmaW5lIEFMTF9FTkdJTkVTICgo aW50ZWxfZW5naW5lX21hc2tfdCl+MHVsKQpAQCAtMzA0LDYgKzMwNCw4IEBAIHN0cnVjdCBpbnRl bF9lbmdpbmVfY3MgewogCS8qIGtlZXAgYSByZXF1ZXN0IGluIHJlc2VydmUgZm9yIGEgW3BtXSBi YXJyaWVyIHVuZGVyIG9vbSAqLwogCXN0cnVjdCBpOTE1X3JlcXVlc3QgKnJlcXVlc3RfcG9vbDsK IAorCXN0cnVjdCBpbnRlbF9jb250ZXh0ICpodW5nX2NlOworCiAJc3RydWN0IGxsaXN0X2hlYWQg YmFycmllcl90YXNrczsKIAogCXN0cnVjdCBpbnRlbF9jb250ZXh0ICprZXJuZWxfY29udGV4dDsg LyogcGlubmVkICovCkBAIC0zODgsNiArMzkwLDggQEAgc3RydWN0IGludGVsX2VuZ2luZV9jcyB7 CiAJdm9pZAkJKCpwYXJrKShzdHJ1Y3QgaW50ZWxfZW5naW5lX2NzICplbmdpbmUpOwogCXZvaWQJ CSgqdW5wYXJrKShzdHJ1Y3QgaW50ZWxfZW5naW5lX2NzICplbmdpbmUpOwogCisJdm9pZAkJKCpi dW1wX3NlcmlhbCkoc3RydWN0IGludGVsX2VuZ2luZV9jcyAqZW5naW5lKTsKKwogCXZvaWQJCSgq c2V0X2RlZmF1bHRfc3VibWlzc2lvbikoc3RydWN0IGludGVsX2VuZ2luZV9jcyAqZW5naW5lKTsK IAogCWNvbnN0IHN0cnVjdCBpbnRlbF9jb250ZXh0X29wcyAqY29wczsKQEAgLTQxOCw2ICs0MjIs MTIgQEAgc3RydWN0IGludGVsX2VuZ2luZV9jcyB7CiAKIAl2b2lkCQkoKnJlbGVhc2UpKHN0cnVj dCBpbnRlbF9lbmdpbmVfY3MgKmVuZ2luZSk7CiAKKwkvKgorCSAqIEFkZCAvIHJlbW92ZSByZXF1 ZXN0IGZyb20gZW5naW5lIGFjdGl2ZSB0cmFja2luZworCSAqLworCXZvaWQJCSgqYWRkX2FjdGl2 ZV9yZXF1ZXN0KShzdHJ1Y3QgaTkxNV9yZXF1ZXN0ICpycSk7CisJdm9pZAkJKCpyZW1vdmVfYWN0 aXZlX3JlcXVlc3QpKHN0cnVjdCBpOTE1X3JlcXVlc3QgKnJxKTsKKwogCXN0cnVjdCBpbnRlbF9l bmdpbmVfZXhlY2xpc3RzIGV4ZWNsaXN0czsKIAogCS8qCkBAIC00MzksNiArNDQ5LDcgQEAgc3Ry dWN0IGludGVsX2VuZ2luZV9jcyB7CiAjZGVmaW5lIEk5MTVfRU5HSU5FX0lTX1ZJUlRVQUwgICAg ICAgQklUKDUpCiAjZGVmaW5lIEk5MTVfRU5HSU5FX0hBU19SRUxBVElWRV9NTUlPIEJJVCg2KQog I2RlZmluZSBJOTE1X0VOR0lORV9SRVFVSVJFU19DTURfUEFSU0VSIEJJVCg3KQorI2RlZmluZSBJ OTE1X0VOR0lORV9XQU5UX0ZPUkNFRF9QUkVFTVBUSU9OIEJJVCg4KQogCXVuc2lnbmVkIGludCBm bGFnczsKIAogCS8qCmRpZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9kcm0vaTkxNS9ndC9pbnRlbF9l bmdpbmVfdXNlci5jIGIvZHJpdmVycy9ncHUvZHJtL2k5MTUvZ3QvaW50ZWxfZW5naW5lX3VzZXIu YwppbmRleCA4NDE0MjEyN2ViZDguLjhmOGJlYTA4ZTczNCAxMDA2NDQKLS0tIGEvZHJpdmVycy9n cHUvZHJtL2k5MTUvZ3QvaW50ZWxfZW5naW5lX3VzZXIuYworKysgYi9kcml2ZXJzL2dwdS9kcm0v aTkxNS9ndC9pbnRlbF9lbmdpbmVfdXNlci5jCkBAIC0xMSw2ICsxMSw3IEBACiAjaW5jbHVkZSAi aW50ZWxfZW5naW5lLmgiCiAjaW5jbHVkZSAiaW50ZWxfZW5naW5lX3VzZXIuaCIKICNpbmNsdWRl ICJpbnRlbF9ndC5oIgorI2luY2x1ZGUgInVjL2ludGVsX2d1Y19zdWJtaXNzaW9uLmgiCiAKIHN0 cnVjdCBpbnRlbF9lbmdpbmVfY3MgKgogaW50ZWxfZW5naW5lX2xvb2t1cF91c2VyKHN0cnVjdCBk cm1faTkxNV9wcml2YXRlICppOTE1LCB1OCBjbGFzcywgdTggaW5zdGFuY2UpCkBAIC0xMTUsNiAr MTE2LDkgQEAgc3RhdGljIHZvaWQgc2V0X3NjaGVkdWxlcl9jYXBzKHN0cnVjdCBkcm1faTkxNV9w cml2YXRlICppOTE1KQogCQkJZGlzYWJsZWQgfD0gKEk5MTVfU0NIRURVTEVSX0NBUF9FTkFCTEVE IHwKIAkJCQkgICAgIEk5MTVfU0NIRURVTEVSX0NBUF9QUklPUklUWSk7CiAKKwkJaWYgKGludGVs X3VjX3VzZXNfZ3VjX3N1Ym1pc3Npb24oJmk5MTUtPmd0LnVjKSkKKwkJCWVuYWJsZWQgfD0gSTkx NV9TQ0hFRFVMRVJfQ0FQX1NUQVRJQ19QUklPUklUWV9NQVA7CisKIAkJZm9yIChpID0gMDsgaSA8 IEFSUkFZX1NJWkUobWFwKTsgaSsrKSB7CiAJCQlpZiAoZW5naW5lLT5mbGFncyAmIEJJVChtYXBb aV0uZW5naW5lKSkKIAkJCQllbmFibGVkIHw9IEJJVChtYXBbaV0uc2NoZWQpOwpkaWZmIC0tZ2l0 IGEvZHJpdmVycy9ncHUvZHJtL2k5MTUvZ3QvaW50ZWxfZXhlY2xpc3RzX3N1Ym1pc3Npb24uYyBi L2RyaXZlcnMvZ3B1L2RybS9pOTE1L2d0L2ludGVsX2V4ZWNsaXN0c19zdWJtaXNzaW9uLmMKaW5k ZXggNTZlMjUwOTBkYTY3Li4yYWE1Y2MxMDA5NTYgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvZ3B1L2Ry bS9pOTE1L2d0L2ludGVsX2V4ZWNsaXN0c19zdWJtaXNzaW9uLmMKKysrIGIvZHJpdmVycy9ncHUv ZHJtL2k5MTUvZ3QvaW50ZWxfZXhlY2xpc3RzX3N1Ym1pc3Npb24uYwpAQCAtMTE0LDYgKzExNCw3 IEBACiAjaW5jbHVkZSAiZ2VuOF9lbmdpbmVfY3MuaCIKICNpbmNsdWRlICJpbnRlbF9icmVhZGNy dW1icy5oIgogI2luY2x1ZGUgImludGVsX2NvbnRleHQuaCIKKyNpbmNsdWRlICJpbnRlbF9lbmdp bmVfaGVhcnRiZWF0LmgiCiAjaW5jbHVkZSAiaW50ZWxfZW5naW5lX3BtLmgiCiAjaW5jbHVkZSAi aW50ZWxfZW5naW5lX3N0YXRzLmgiCiAjaW5jbHVkZSAiaW50ZWxfZXhlY2xpc3RzX3N1Ym1pc3Np b24uaCIKQEAgLTE5Myw2ICsxOTQsOSBAQCBzdGF0aWMgc3RydWN0IHZpcnR1YWxfZW5naW5lICp0 b192aXJ0dWFsX2VuZ2luZShzdHJ1Y3QgaW50ZWxfZW5naW5lX2NzICplbmdpbmUpCiAJcmV0dXJu IGNvbnRhaW5lcl9vZihlbmdpbmUsIHN0cnVjdCB2aXJ0dWFsX2VuZ2luZSwgYmFzZSk7CiB9CiAK K3N0YXRpYyBzdHJ1Y3QgaW50ZWxfY29udGV4dCAqCitleGVjbGlzdHNfY3JlYXRlX3ZpcnR1YWwo c3RydWN0IGludGVsX2VuZ2luZV9jcyAqKnNpYmxpbmdzLCB1bnNpZ25lZCBpbnQgY291bnQpOwor CiBzdGF0aWMgc3RydWN0IGk5MTVfcmVxdWVzdCAqCiBfX2FjdGl2ZV9yZXF1ZXN0KGNvbnN0IHN0 cnVjdCBpbnRlbF90aW1lbGluZSAqIGNvbnN0IHRsLAogCQkgc3RydWN0IGk5MTVfcmVxdWVzdCAq cnEsCkBAIC0yNTMzLDExICsyNTM3LDI2IEBAIHN0YXRpYyBpbnQgZXhlY2xpc3RzX2NvbnRleHRf YWxsb2Moc3RydWN0IGludGVsX2NvbnRleHQgKmNlKQogCXJldHVybiBscmNfYWxsb2MoY2UsIGNl LT5lbmdpbmUpOwogfQogCitzdGF0aWMgdm9pZCBleGVjbGlzdHNfY29udGV4dF9jYW5jZWxfcmVx dWVzdChzdHJ1Y3QgaW50ZWxfY29udGV4dCAqY2UsCisJCQkJCSAgICAgc3RydWN0IGk5MTVfcmVx dWVzdCAqcnEpCit7CisJc3RydWN0IGludGVsX2VuZ2luZV9jcyAqZW5naW5lID0gTlVMTDsKKwor CWk5MTVfcmVxdWVzdF9hY3RpdmVfZW5naW5lKHJxLCAmZW5naW5lKTsKKworCWlmIChlbmdpbmUg JiYgaW50ZWxfZW5naW5lX3B1bHNlKGVuZ2luZSkpCisJCWludGVsX2d0X2hhbmRsZV9lcnJvcihl bmdpbmUtPmd0LCBlbmdpbmUtPm1hc2ssIDAsCisJCQkJICAgICAgInJlcXVlc3QgY2FuY2VsbGF0 aW9uIGJ5ICVzIiwKKwkJCQkgICAgICBjdXJyZW50LT5jb21tKTsKK30KKwogc3RhdGljIGNvbnN0 IHN0cnVjdCBpbnRlbF9jb250ZXh0X29wcyBleGVjbGlzdHNfY29udGV4dF9vcHMgPSB7CiAJLmZs YWdzID0gQ09QU19IQVNfSU5GTElHSFQsCiAKIAkuYWxsb2MgPSBleGVjbGlzdHNfY29udGV4dF9h bGxvYywKIAorCS5jYW5jZWxfcmVxdWVzdCA9IGV4ZWNsaXN0c19jb250ZXh0X2NhbmNlbF9yZXF1 ZXN0LAorCiAJLnByZV9waW4gPSBleGVjbGlzdHNfY29udGV4dF9wcmVfcGluLAogCS5waW4gPSBl eGVjbGlzdHNfY29udGV4dF9waW4sCiAJLnVucGluID0gbHJjX3VucGluLApAQCAtMjU0OCw2ICsy NTY3LDggQEAgc3RhdGljIGNvbnN0IHN0cnVjdCBpbnRlbF9jb250ZXh0X29wcyBleGVjbGlzdHNf Y29udGV4dF9vcHMgPSB7CiAKIAkucmVzZXQgPSBscmNfcmVzZXQsCiAJLmRlc3Ryb3kgPSBscmNf ZGVzdHJveSwKKworCS5jcmVhdGVfdmlydHVhbCA9IGV4ZWNsaXN0c19jcmVhdGVfdmlydHVhbCwK IH07CiAKIHN0YXRpYyBpbnQgZW1pdF9wZHBzKHN0cnVjdCBpOTE1X3JlcXVlc3QgKnJxKQpAQCAt MzEwMSw2ICszMTIyLDQyIEBAIHN0YXRpYyB2b2lkIGV4ZWNsaXN0c19wYXJrKHN0cnVjdCBpbnRl bF9lbmdpbmVfY3MgKmVuZ2luZSkKIAljYW5jZWxfdGltZXIoJmVuZ2luZS0+ZXhlY2xpc3RzLnBy ZWVtcHQpOwogfQogCitzdGF0aWMgdm9pZCBhZGRfdG9fZW5naW5lKHN0cnVjdCBpOTE1X3JlcXVl c3QgKnJxKQoreworCWxvY2tkZXBfYXNzZXJ0X2hlbGQoJnJxLT5lbmdpbmUtPnNjaGVkX2VuZ2lu ZS0+bG9jayk7CisJbGlzdF9tb3ZlX3RhaWwoJnJxLT5zY2hlZC5saW5rLCAmcnEtPmVuZ2luZS0+ c2NoZWRfZW5naW5lLT5yZXF1ZXN0cyk7Cit9CisKK3N0YXRpYyB2b2lkIHJlbW92ZV9mcm9tX2Vu Z2luZShzdHJ1Y3QgaTkxNV9yZXF1ZXN0ICpycSkKK3sKKwlzdHJ1Y3QgaW50ZWxfZW5naW5lX2Nz ICplbmdpbmUsICpsb2NrZWQ7CisKKwkvKgorCSAqIFZpcnR1YWwgZW5naW5lcyBjb21wbGljYXRl IGFjcXVpcmluZyB0aGUgZW5naW5lIHRpbWVsaW5lIGxvY2ssCisJICogYXMgdGhlaXIgcnEtPmVu Z2luZSBwb2ludGVyIGlzIG5vdCBzdGFibGUgdW50aWwgdW5kZXIgdGhhdAorCSAqIGVuZ2luZSBs b2NrLiBUaGUgc2ltcGxlIHBsb3kgd2UgdXNlIGlzIHRvIHRha2UgdGhlIGxvY2sgdGhlbgorCSAq IGNoZWNrIHRoYXQgdGhlIHJxIHN0aWxsIGJlbG9uZ3MgdG8gdGhlIG5ld2x5IGxvY2tlZCBlbmdp bmUuCisJICovCisJbG9ja2VkID0gUkVBRF9PTkNFKHJxLT5lbmdpbmUpOworCXNwaW5fbG9ja19p cnEoJmxvY2tlZC0+c2NoZWRfZW5naW5lLT5sb2NrKTsKKwl3aGlsZSAodW5saWtlbHkobG9ja2Vk ICE9IChlbmdpbmUgPSBSRUFEX09OQ0UocnEtPmVuZ2luZSkpKSkgeworCQlzcGluX3VubG9jaygm bG9ja2VkLT5zY2hlZF9lbmdpbmUtPmxvY2spOworCQlzcGluX2xvY2soJmVuZ2luZS0+c2NoZWRf ZW5naW5lLT5sb2NrKTsKKwkJbG9ja2VkID0gZW5naW5lOworCX0KKwlsaXN0X2RlbF9pbml0KCZy cS0+c2NoZWQubGluayk7CisKKwljbGVhcl9iaXQoSTkxNV9GRU5DRV9GTEFHX1BRVUVVRSwgJnJx LT5mZW5jZS5mbGFncyk7CisJY2xlYXJfYml0KEk5MTVfRkVOQ0VfRkxBR19IT0xELCAmcnEtPmZl bmNlLmZsYWdzKTsKKworCS8qIFByZXZlbnQgZnVydGhlciBfX2F3YWl0X2V4ZWN1dGlvbigpIHJl Z2lzdGVyaW5nIGEgY2IsIHRoZW4gZmx1c2ggKi8KKwlzZXRfYml0KEk5MTVfRkVOQ0VfRkxBR19B Q1RJVkUsICZycS0+ZmVuY2UuZmxhZ3MpOworCisJc3Bpbl91bmxvY2tfaXJxKCZsb2NrZWQtPnNj aGVkX2VuZ2luZS0+bG9jayk7CisKKwlpOTE1X3JlcXVlc3Rfbm90aWZ5X2V4ZWN1dGVfY2JfaW1t KHJxKTsKK30KKwogc3RhdGljIGJvb2wgY2FuX3ByZWVtcHQoc3RydWN0IGludGVsX2VuZ2luZV9j cyAqZW5naW5lKQogewogCWlmIChHUkFQSElDU19WRVIoZW5naW5lLT5pOTE1KSA+IDgpCkBAIC0z MTk1LDYgKzMyNTIsOCBAQCBsb2dpY2FsX3JpbmdfZGVmYXVsdF92ZnVuY3Moc3RydWN0IGludGVs X2VuZ2luZV9jcyAqZW5naW5lKQogCiAJZW5naW5lLT5jb3BzID0gJmV4ZWNsaXN0c19jb250ZXh0 X29wczsKIAllbmdpbmUtPnJlcXVlc3RfYWxsb2MgPSBleGVjbGlzdHNfcmVxdWVzdF9hbGxvYzsK KwllbmdpbmUtPmFkZF9hY3RpdmVfcmVxdWVzdCA9IGFkZF90b19lbmdpbmU7CisJZW5naW5lLT5y ZW1vdmVfYWN0aXZlX3JlcXVlc3QgPSByZW1vdmVfZnJvbV9lbmdpbmU7CiAKIAllbmdpbmUtPnJl c2V0LnByZXBhcmUgPSBleGVjbGlzdHNfcmVzZXRfcHJlcGFyZTsKIAllbmdpbmUtPnJlc2V0LnJl d2luZCA9IGV4ZWNsaXN0c19yZXNldF9yZXdpbmQ7CkBAIC0zMzk2LDcgKzM0NTUsNyBAQCBzdGF0 aWMgdm9pZCByY3VfdmlydHVhbF9jb250ZXh0X2Rlc3Ryb3koc3RydWN0IHdvcmtfc3RydWN0ICp3 cmspCiAJaW50ZWxfY29udGV4dF9maW5pKCZ2ZS0+Y29udGV4dCk7CiAKIAlpZiAodmUtPmJhc2Uu YnJlYWRjcnVtYnMpCi0JCWludGVsX2JyZWFkY3J1bWJzX2ZyZWUodmUtPmJhc2UuYnJlYWRjcnVt YnMpOworCQlpbnRlbF9icmVhZGNydW1ic19wdXQodmUtPmJhc2UuYnJlYWRjcnVtYnMpOwogCWlm ICh2ZS0+YmFzZS5zY2hlZF9lbmdpbmUpCiAJCWk5MTVfc2NoZWRfZW5naW5lX3B1dCh2ZS0+YmFz ZS5zY2hlZF9lbmdpbmUpOwogCWludGVsX2VuZ2luZV9mcmVlX3JlcXVlc3RfcG9vbCgmdmUtPmJh c2UpOwpAQCAtMzQ5MywxMSArMzU1MiwyNCBAQCBzdGF0aWMgdm9pZCB2aXJ0dWFsX2NvbnRleHRf ZXhpdChzdHJ1Y3QgaW50ZWxfY29udGV4dCAqY2UpCiAJCWludGVsX2VuZ2luZV9wbV9wdXQodmUt PnNpYmxpbmdzW25dKTsKIH0KIAorc3RhdGljIHN0cnVjdCBpbnRlbF9lbmdpbmVfY3MgKgordmly dHVhbF9nZXRfc2libGluZyhzdHJ1Y3QgaW50ZWxfZW5naW5lX2NzICplbmdpbmUsIHVuc2lnbmVk IGludCBzaWJsaW5nKQoreworCXN0cnVjdCB2aXJ0dWFsX2VuZ2luZSAqdmUgPSB0b192aXJ0dWFs X2VuZ2luZShlbmdpbmUpOworCisJaWYgKHNpYmxpbmcgPj0gdmUtPm51bV9zaWJsaW5ncykKKwkJ cmV0dXJuIE5VTEw7CisKKwlyZXR1cm4gdmUtPnNpYmxpbmdzW3NpYmxpbmddOworfQorCiBzdGF0 aWMgY29uc3Qgc3RydWN0IGludGVsX2NvbnRleHRfb3BzIHZpcnR1YWxfY29udGV4dF9vcHMgPSB7 CiAJLmZsYWdzID0gQ09QU19IQVNfSU5GTElHSFQsCiAKIAkuYWxsb2MgPSB2aXJ0dWFsX2NvbnRl eHRfYWxsb2MsCiAKKwkuY2FuY2VsX3JlcXVlc3QgPSBleGVjbGlzdHNfY29udGV4dF9jYW5jZWxf cmVxdWVzdCwKKwogCS5wcmVfcGluID0gdmlydHVhbF9jb250ZXh0X3ByZV9waW4sCiAJLnBpbiA9 IHZpcnR1YWxfY29udGV4dF9waW4sCiAJLnVucGluID0gbHJjX3VucGluLApAQCAtMzUwNyw2ICsz NTc5LDggQEAgc3RhdGljIGNvbnN0IHN0cnVjdCBpbnRlbF9jb250ZXh0X29wcyB2aXJ0dWFsX2Nv bnRleHRfb3BzID0gewogCS5leGl0ID0gdmlydHVhbF9jb250ZXh0X2V4aXQsCiAKIAkuZGVzdHJv eSA9IHZpcnR1YWxfY29udGV4dF9kZXN0cm95LAorCisJLmdldF9zaWJsaW5nID0gdmlydHVhbF9n ZXRfc2libGluZywKIH07CiAKIHN0YXRpYyBpbnRlbF9lbmdpbmVfbWFza190IHZpcnR1YWxfc3Vi bWlzc2lvbl9tYXNrKHN0cnVjdCB2aXJ0dWFsX2VuZ2luZSAqdmUpCkBAIC0zNjU1LDIwICszNzI5 LDEzIEBAIHN0YXRpYyB2b2lkIHZpcnR1YWxfc3VibWl0X3JlcXVlc3Qoc3RydWN0IGk5MTVfcmVx dWVzdCAqcnEpCiAJc3Bpbl91bmxvY2tfaXJxcmVzdG9yZSgmdmUtPmJhc2Uuc2NoZWRfZW5naW5l LT5sb2NrLCBmbGFncyk7CiB9CiAKLXN0cnVjdCBpbnRlbF9jb250ZXh0ICoKLWludGVsX2V4ZWNs aXN0c19jcmVhdGVfdmlydHVhbChzdHJ1Y3QgaW50ZWxfZW5naW5lX2NzICoqc2libGluZ3MsCi0J CQkgICAgICAgdW5zaWduZWQgaW50IGNvdW50KQorc3RhdGljIHN0cnVjdCBpbnRlbF9jb250ZXh0 ICoKK2V4ZWNsaXN0c19jcmVhdGVfdmlydHVhbChzdHJ1Y3QgaW50ZWxfZW5naW5lX2NzICoqc2li bGluZ3MsIHVuc2lnbmVkIGludCBjb3VudCkKIHsKIAlzdHJ1Y3QgdmlydHVhbF9lbmdpbmUgKnZl OwogCXVuc2lnbmVkIGludCBuOwogCWludCBlcnI7CiAKLQlpZiAoY291bnQgPT0gMCkKLQkJcmV0 dXJuIEVSUl9QVFIoLUVJTlZBTCk7Ci0KLQlpZiAoY291bnQgPT0gMSkKLQkJcmV0dXJuIGludGVs X2NvbnRleHRfY3JlYXRlKHNpYmxpbmdzWzBdKTsKLQogCXZlID0ga3phbGxvYyhzdHJ1Y3Rfc2l6 ZSh2ZSwgc2libGluZ3MsIGNvdW50KSwgR0ZQX0tFUk5FTCk7CiAJaWYgKCF2ZSkKIAkJcmV0dXJu IEVSUl9QVFIoLUVOT01FTSk7CkBAIC0zNzgwLDYgKzM4NDcsOCBAQCBpbnRlbF9leGVjbGlzdHNf Y3JlYXRlX3ZpcnR1YWwoc3RydWN0IGludGVsX2VuZ2luZV9jcyAqKnNpYmxpbmdzLAogCQkJICJ2 JWR4JWQiLCB2ZS0+YmFzZS5jbGFzcywgY291bnQpOwogCQl2ZS0+YmFzZS5jb250ZXh0X3NpemUg PSBzaWJsaW5nLT5jb250ZXh0X3NpemU7CiAKKwkJdmUtPmJhc2UuYWRkX2FjdGl2ZV9yZXF1ZXN0 ID0gc2libGluZy0+YWRkX2FjdGl2ZV9yZXF1ZXN0OworCQl2ZS0+YmFzZS5yZW1vdmVfYWN0aXZl X3JlcXVlc3QgPSBzaWJsaW5nLT5yZW1vdmVfYWN0aXZlX3JlcXVlc3Q7CiAJCXZlLT5iYXNlLmVt aXRfYmJfc3RhcnQgPSBzaWJsaW5nLT5lbWl0X2JiX3N0YXJ0OwogCQl2ZS0+YmFzZS5lbWl0X2Zs dXNoID0gc2libGluZy0+ZW1pdF9mbHVzaDsKIAkJdmUtPmJhc2UuZW1pdF9pbml0X2JyZWFkY3J1 bWIgPSBzaWJsaW5nLT5lbWl0X2luaXRfYnJlYWRjcnVtYjsKZGlmZiAtLWdpdCBhL2RyaXZlcnMv Z3B1L2RybS9pOTE1L2d0L2ludGVsX2V4ZWNsaXN0c19zdWJtaXNzaW9uLmggYi9kcml2ZXJzL2dw dS9kcm0vaTkxNS9ndC9pbnRlbF9leGVjbGlzdHNfc3VibWlzc2lvbi5oCmluZGV4IGFkNGYzZTFh MGZkZS4uYTFhYTkyYzk4M2E1IDEwMDY0NAotLS0gYS9kcml2ZXJzL2dwdS9kcm0vaTkxNS9ndC9p bnRlbF9leGVjbGlzdHNfc3VibWlzc2lvbi5oCisrKyBiL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2d0 L2ludGVsX2V4ZWNsaXN0c19zdWJtaXNzaW9uLmgKQEAgLTMyLDEwICszMiw2IEBAIHZvaWQgaW50 ZWxfZXhlY2xpc3RzX3Nob3dfcmVxdWVzdHMoc3RydWN0IGludGVsX2VuZ2luZV9jcyAqZW5naW5l LAogCQkJCQkJCWludCBpbmRlbnQpLAogCQkJCSAgIHVuc2lnbmVkIGludCBtYXgpOwogCi1zdHJ1 Y3QgaW50ZWxfY29udGV4dCAqCi1pbnRlbF9leGVjbGlzdHNfY3JlYXRlX3ZpcnR1YWwoc3RydWN0 IGludGVsX2VuZ2luZV9jcyAqKnNpYmxpbmdzLAotCQkJICAgICAgIHVuc2lnbmVkIGludCBjb3Vu dCk7Ci0KIGJvb2wKIGludGVsX2VuZ2luZV9pbl9leGVjbGlzdHNfc3VibWlzc2lvbl9tb2RlKGNv bnN0IHN0cnVjdCBpbnRlbF9lbmdpbmVfY3MgKmVuZ2luZSk7CiAKZGlmZiAtLWdpdCBhL2RyaXZl cnMvZ3B1L2RybS9pOTE1L2d0L2ludGVsX2d0LmMgYi9kcml2ZXJzL2dwdS9kcm0vaTkxNS9ndC9p bnRlbF9ndC5jCmluZGV4IGU3MTRlMjFjMGE0ZC4uY2VlYjUxN2JhMjU5IDEwMDY0NAotLS0gYS9k cml2ZXJzL2dwdS9kcm0vaTkxNS9ndC9pbnRlbF9ndC5jCisrKyBiL2RyaXZlcnMvZ3B1L2RybS9p OTE1L2d0L2ludGVsX2d0LmMKQEAgLTU4NSw2ICs1ODUsMjUgQEAgc3RhdGljIHZvaWQgX19pbnRl bF9ndF9kaXNhYmxlKHN0cnVjdCBpbnRlbF9ndCAqZ3QpCiAJR0VNX0JVR19PTihpbnRlbF9ndF9w bV9pc19hd2FrZShndCkpOwogfQogCitpbnQgaW50ZWxfZ3Rfd2FpdF9mb3JfaWRsZShzdHJ1Y3Qg aW50ZWxfZ3QgKmd0LCBsb25nIHRpbWVvdXQpCit7CisJbG9uZyByZW1haW5pbmdfdGltZW91dDsK KworCS8qIElmIHRoZSBkZXZpY2UgaXMgYXNsZWVwLCB3ZSBoYXZlIG5vIHJlcXVlc3RzIG91dHN0 YW5kaW5nICovCisJaWYgKCFpbnRlbF9ndF9wbV9pc19hd2FrZShndCkpCisJCXJldHVybiAwOwor CisJd2hpbGUgKCh0aW1lb3V0ID0gaW50ZWxfZ3RfcmV0aXJlX3JlcXVlc3RzX3RpbWVvdXQoZ3Qs IHRpbWVvdXQsCisJCQkJCQkJICAgJnJlbWFpbmluZ190aW1lb3V0KSkgPiAwKSB7CisJCWNvbmRf cmVzY2hlZCgpOworCQlpZiAoc2lnbmFsX3BlbmRpbmcoY3VycmVudCkpCisJCQlyZXR1cm4gLUVJ TlRSOworCX0KKworCXJldHVybiB0aW1lb3V0ID8gdGltZW91dCA6IGludGVsX3VjX3dhaXRfZm9y X2lkbGUoJmd0LT51YywKKwkJCQkJCQkgIHJlbWFpbmluZ190aW1lb3V0KTsKK30KKwogaW50IGlu dGVsX2d0X2luaXQoc3RydWN0IGludGVsX2d0ICpndCkKIHsKIAlpbnQgZXJyOwpAQCAtNjM1LDYg KzY1NCw4IEBAIGludCBpbnRlbF9ndF9pbml0KHN0cnVjdCBpbnRlbF9ndCAqZ3QpCiAJaWYgKGVy cikKIAkJZ290byBlcnJfZ3Q7CiAKKwlpbnRlbF91Y19pbml0X2xhdGUoJmd0LT51Yyk7CisKIAll cnIgPSBpOTE1X2luamVjdF9wcm9iZV9lcnJvcihndC0+aTkxNSwgLUVJTyk7CiAJaWYgKGVycikK IAkJZ290byBlcnJfZ3Q7CmRpZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9kcm0vaTkxNS9ndC9pbnRl bF9ndC5oIGIvZHJpdmVycy9ncHUvZHJtL2k5MTUvZ3QvaW50ZWxfZ3QuaAppbmRleCBlN2FhYmUw Y2M1YmYuLjc0ZTc3MTg3MWE5YiAxMDA2NDQKLS0tIGEvZHJpdmVycy9ncHUvZHJtL2k5MTUvZ3Qv aW50ZWxfZ3QuaAorKysgYi9kcml2ZXJzL2dwdS9kcm0vaTkxNS9ndC9pbnRlbF9ndC5oCkBAIC00 OCw2ICs0OCw4IEBAIHZvaWQgaW50ZWxfZ3RfZHJpdmVyX3JlbGVhc2Uoc3RydWN0IGludGVsX2d0 ICpndCk7CiAKIHZvaWQgaW50ZWxfZ3RfZHJpdmVyX2xhdGVfcmVsZWFzZShzdHJ1Y3QgaW50ZWxf Z3QgKmd0KTsKIAoraW50IGludGVsX2d0X3dhaXRfZm9yX2lkbGUoc3RydWN0IGludGVsX2d0ICpn dCwgbG9uZyB0aW1lb3V0KTsKKwogdm9pZCBpbnRlbF9ndF9jaGVja19hbmRfY2xlYXJfZmF1bHRz KHN0cnVjdCBpbnRlbF9ndCAqZ3QpOwogdm9pZCBpbnRlbF9ndF9jbGVhcl9lcnJvcl9yZWdpc3Rl cnMoc3RydWN0IGludGVsX2d0ICpndCwKIAkJCQkgICAgaW50ZWxfZW5naW5lX21hc2tfdCBlbmdp bmVfbWFzayk7CmRpZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9kcm0vaTkxNS9ndC9pbnRlbF9ndF9w bS5jIGIvZHJpdmVycy9ncHUvZHJtL2k5MTUvZ3QvaW50ZWxfZ3RfcG0uYwppbmRleCBhZWYzMDg0 ZThiMTYuLjQ2M2E2YWU2MDVhMCAxMDA2NDQKLS0tIGEvZHJpdmVycy9ncHUvZHJtL2k5MTUvZ3Qv aW50ZWxfZ3RfcG0uYworKysgYi9kcml2ZXJzL2dwdS9kcm0vaTkxNS9ndC9pbnRlbF9ndF9wbS5j CkBAIC0xNzQsOCArMTc0LDYgQEAgc3RhdGljIHZvaWQgZ3Rfc2FuaXRpemUoc3RydWN0IGludGVs X2d0ICpndCwgYm9vbCBmb3JjZSkKIAlpZiAoaW50ZWxfZ3RfaXNfd2VkZ2VkKGd0KSkKIAkJaW50 ZWxfZ3RfdW5zZXRfd2VkZ2VkKGd0KTsKIAotCWludGVsX3VjX3Nhbml0aXplKCZndC0+dWMpOwot CiAJZm9yX2VhY2hfZW5naW5lKGVuZ2luZSwgZ3QsIGlkKQogCQlpZiAoZW5naW5lLT5yZXNldC5w cmVwYXJlKQogCQkJZW5naW5lLT5yZXNldC5wcmVwYXJlKGVuZ2luZSk7CkBAIC0xOTEsNiArMTg5 LDggQEAgc3RhdGljIHZvaWQgZ3Rfc2FuaXRpemUoc3RydWN0IGludGVsX2d0ICpndCwgYm9vbCBm b3JjZSkKIAkJCV9faW50ZWxfZW5naW5lX3Jlc2V0KGVuZ2luZSwgZmFsc2UpOwogCX0KIAorCWlu dGVsX3VjX3Jlc2V0KCZndC0+dWMsIGZhbHNlKTsKKwogCWZvcl9lYWNoX2VuZ2luZShlbmdpbmUs IGd0LCBpZCkKIAkJaWYgKGVuZ2luZS0+cmVzZXQuZmluaXNoKQogCQkJZW5naW5lLT5yZXNldC5m aW5pc2goZW5naW5lKTsKQEAgLTI0Myw2ICsyNDMsOCBAQCBpbnQgaW50ZWxfZ3RfcmVzdW1lKHN0 cnVjdCBpbnRlbF9ndCAqZ3QpCiAJCWdvdG8gZXJyX3dlZGdlZDsKIAl9CiAKKwlpbnRlbF91Y19y ZXNldF9maW5pc2goJmd0LT51Yyk7CisKIAlpbnRlbF9ycHNfZW5hYmxlKCZndC0+cnBzKTsKIAlp bnRlbF9sbGNfZW5hYmxlKCZndC0+bGxjKTsKIApkaWZmIC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJt L2k5MTUvZ3QvaW50ZWxfZ3RfcmVxdWVzdHMuYyBiL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2d0L2lu dGVsX2d0X3JlcXVlc3RzLmMKaW5kZXggNjQ3ZWNhOWQ4NjdhLi5lZGI4ODFkNzU2MzAgMTAwNjQ0 Ci0tLSBhL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2d0L2ludGVsX2d0X3JlcXVlc3RzLmMKKysrIGIv ZHJpdmVycy9ncHUvZHJtL2k5MTUvZ3QvaW50ZWxfZ3RfcmVxdWVzdHMuYwpAQCAtMTMwLDcgKzEz MCw4IEBAIHZvaWQgaW50ZWxfZW5naW5lX2ZpbmlfcmV0aXJlKHN0cnVjdCBpbnRlbF9lbmdpbmVf Y3MgKmVuZ2luZSkKIAlHRU1fQlVHX09OKGVuZ2luZS0+cmV0aXJlKTsKIH0KIAotbG9uZyBpbnRl bF9ndF9yZXRpcmVfcmVxdWVzdHNfdGltZW91dChzdHJ1Y3QgaW50ZWxfZ3QgKmd0LCBsb25nIHRp bWVvdXQpCitsb25nIGludGVsX2d0X3JldGlyZV9yZXF1ZXN0c190aW1lb3V0KHN0cnVjdCBpbnRl bF9ndCAqZ3QsIGxvbmcgdGltZW91dCwKKwkJCQkgICAgICBsb25nICpyZW1haW5pbmdfdGltZW91 dCkKIHsKIAlzdHJ1Y3QgaW50ZWxfZ3RfdGltZWxpbmVzICp0aW1lbGluZXMgPSAmZ3QtPnRpbWVs aW5lczsKIAlzdHJ1Y3QgaW50ZWxfdGltZWxpbmUgKnRsLCAqdG47CkBAIC0xOTUsMjIgKzE5Niwx MCBAQCBvdXRfYWN0aXZlOglzcGluX2xvY2soJnRpbWVsaW5lcy0+bG9jayk7CiAJaWYgKGZsdXNo X3N1Ym1pc3Npb24oZ3QsIHRpbWVvdXQpKSAvKiBXYWl0LCB0aGVyZSdzIG1vcmUhICovCiAJCWFj dGl2ZV9jb3VudCsrOwogCi0JcmV0dXJuIGFjdGl2ZV9jb3VudCA/IHRpbWVvdXQgOiAwOwotfQot Ci1pbnQgaW50ZWxfZ3Rfd2FpdF9mb3JfaWRsZShzdHJ1Y3QgaW50ZWxfZ3QgKmd0LCBsb25nIHRp bWVvdXQpCi17Ci0JLyogSWYgdGhlIGRldmljZSBpcyBhc2xlZXAsIHdlIGhhdmUgbm8gcmVxdWVz dHMgb3V0c3RhbmRpbmcgKi8KLQlpZiAoIWludGVsX2d0X3BtX2lzX2F3YWtlKGd0KSkKLQkJcmV0 dXJuIDA7Ci0KLQl3aGlsZSAoKHRpbWVvdXQgPSBpbnRlbF9ndF9yZXRpcmVfcmVxdWVzdHNfdGlt ZW91dChndCwgdGltZW91dCkpID4gMCkgewotCQljb25kX3Jlc2NoZWQoKTsKLQkJaWYgKHNpZ25h bF9wZW5kaW5nKGN1cnJlbnQpKQotCQkJcmV0dXJuIC1FSU5UUjsKLQl9CisJaWYgKHJlbWFpbmlu Z190aW1lb3V0KQorCQkqcmVtYWluaW5nX3RpbWVvdXQgPSB0aW1lb3V0OwogCi0JcmV0dXJuIHRp bWVvdXQ7CisJcmV0dXJuIGFjdGl2ZV9jb3VudCA/IHRpbWVvdXQgOiAwOwogfQogCiBzdGF0aWMg dm9pZCByZXRpcmVfd29ya19oYW5kbGVyKHN0cnVjdCB3b3JrX3N0cnVjdCAqd29yaykKZGlmZiAt LWdpdCBhL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2d0L2ludGVsX2d0X3JlcXVlc3RzLmggYi9kcml2 ZXJzL2dwdS9kcm0vaTkxNS9ndC9pbnRlbF9ndF9yZXF1ZXN0cy5oCmluZGV4IGZjYzMwYTZlNGZl OS4uNTFkYmUwZTMyOTRlIDEwMDY0NAotLS0gYS9kcml2ZXJzL2dwdS9kcm0vaTkxNS9ndC9pbnRl bF9ndF9yZXF1ZXN0cy5oCisrKyBiL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2d0L2ludGVsX2d0X3Jl cXVlc3RzLmgKQEAgLTYsMTQgKzYsMTcgQEAKICNpZm5kZWYgSU5URUxfR1RfUkVRVUVTVFNfSAog I2RlZmluZSBJTlRFTF9HVF9SRVFVRVNUU19ICiAKKyNpbmNsdWRlIDxzdGRkZWYuaD4KKwogc3Ry dWN0IGludGVsX2VuZ2luZV9jczsKIHN0cnVjdCBpbnRlbF9ndDsKIHN0cnVjdCBpbnRlbF90aW1l bGluZTsKIAotbG9uZyBpbnRlbF9ndF9yZXRpcmVfcmVxdWVzdHNfdGltZW91dChzdHJ1Y3QgaW50 ZWxfZ3QgKmd0LCBsb25nIHRpbWVvdXQpOworbG9uZyBpbnRlbF9ndF9yZXRpcmVfcmVxdWVzdHNf dGltZW91dChzdHJ1Y3QgaW50ZWxfZ3QgKmd0LCBsb25nIHRpbWVvdXQsCisJCQkJICAgICAgbG9u ZyAqcmVtYWluaW5nX3RpbWVvdXQpOwogc3RhdGljIGlubGluZSB2b2lkIGludGVsX2d0X3JldGly ZV9yZXF1ZXN0cyhzdHJ1Y3QgaW50ZWxfZ3QgKmd0KQogewotCWludGVsX2d0X3JldGlyZV9yZXF1 ZXN0c190aW1lb3V0KGd0LCAwKTsKKwlpbnRlbF9ndF9yZXRpcmVfcmVxdWVzdHNfdGltZW91dChn dCwgMCwgTlVMTCk7CiB9CiAKIHZvaWQgaW50ZWxfZW5naW5lX2luaXRfcmV0aXJlKHN0cnVjdCBp bnRlbF9lbmdpbmVfY3MgKmVuZ2luZSk7CkBAIC0yMSw4ICsyNCw2IEBAIHZvaWQgaW50ZWxfZW5n aW5lX2FkZF9yZXRpcmUoc3RydWN0IGludGVsX2VuZ2luZV9jcyAqZW5naW5lLAogCQkJICAgICBz dHJ1Y3QgaW50ZWxfdGltZWxpbmUgKnRsKTsKIHZvaWQgaW50ZWxfZW5naW5lX2ZpbmlfcmV0aXJl KHN0cnVjdCBpbnRlbF9lbmdpbmVfY3MgKmVuZ2luZSk7CiAKLWludCBpbnRlbF9ndF93YWl0X2Zv cl9pZGxlKHN0cnVjdCBpbnRlbF9ndCAqZ3QsIGxvbmcgdGltZW91dCk7Ci0KIHZvaWQgaW50ZWxf Z3RfaW5pdF9yZXF1ZXN0cyhzdHJ1Y3QgaW50ZWxfZ3QgKmd0KTsKIHZvaWQgaW50ZWxfZ3RfcGFy a19yZXF1ZXN0cyhzdHJ1Y3QgaW50ZWxfZ3QgKmd0KTsKIHZvaWQgaW50ZWxfZ3RfdW5wYXJrX3Jl cXVlc3RzKHN0cnVjdCBpbnRlbF9ndCAqZ3QpOwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJt L2k5MTUvZ3QvaW50ZWxfbHJjX3JlZy5oIGIvZHJpdmVycy9ncHUvZHJtL2k5MTUvZ3QvaW50ZWxf bHJjX3JlZy5oCmluZGV4IDQxZTUzNTBhN2EwNS4uNDlkNDg1N2FkOWI3IDEwMDY0NAotLS0gYS9k cml2ZXJzL2dwdS9kcm0vaTkxNS9ndC9pbnRlbF9scmNfcmVnLmgKKysrIGIvZHJpdmVycy9ncHUv ZHJtL2k5MTUvZ3QvaW50ZWxfbHJjX3JlZy5oCkBAIC04Nyw3ICs4Nyw2IEBACiAjZGVmaW5lIEdF TjExX0NTQl9XUklURV9QVFJfTUFTSwkoR0VOMTFfQ1NCX1BUUl9NQVNLIDw8IDApCiAKICNkZWZp bmUgTUFYX0NPTlRFWFRfSFdfSUQJKDEgPDwgMjEpIC8qIGV4Y2x1c2l2ZSAqLwotI2RlZmluZSBN QVhfR1VDX0NPTlRFWFRfSFdfSUQJKDEgPDwgMjApIC8qIGV4Y2x1c2l2ZSAqLwogI2RlZmluZSBH RU4xMV9NQVhfQ09OVEVYVF9IV19JRAkoMSA8PCAxMSkgLyogZXhjbHVzaXZlICovCiAvKiBpbiBH ZW4xMiBJRCAweDdGRiBpcyByZXNlcnZlZCB0byBpbmRpY2F0ZSBpZGxlICovCiAjZGVmaW5lIEdF TjEyX01BWF9DT05URVhUX0hXX0lECShHRU4xMV9NQVhfQ09OVEVYVF9IV19JRCAtIDEpCmRpZmYg LS1naXQgYS9kcml2ZXJzL2dwdS9kcm0vaTkxNS9ndC9pbnRlbF9yZXNldC5jIGIvZHJpdmVycy9n cHUvZHJtL2k5MTUvZ3QvaW50ZWxfcmVzZXQuYwppbmRleCA3MjI1MTYzOGQ0ZWEuLjNlZDY5NGNh YjVhZiAxMDA2NDQKLS0tIGEvZHJpdmVycy9ncHUvZHJtL2k5MTUvZ3QvaW50ZWxfcmVzZXQuYwor KysgYi9kcml2ZXJzL2dwdS9kcm0vaTkxNS9ndC9pbnRlbF9yZXNldC5jCkBAIC0yMiw3ICsyMiw2 IEBACiAjaW5jbHVkZSAiaW50ZWxfcmVzZXQuaCIKIAogI2luY2x1ZGUgInVjL2ludGVsX2d1Yy5o IgotI2luY2x1ZGUgInVjL2ludGVsX2d1Y19zdWJtaXNzaW9uLmgiCiAKICNkZWZpbmUgUkVTRVRf TUFYX1JFVFJJRVMgMwogCkBAIC0zOSwyMSArMzgsNiBAQCBzdGF0aWMgdm9pZCBybXdfY2xlYXJf Zncoc3RydWN0IGludGVsX3VuY29yZSAqdW5jb3JlLCBpOTE1X3JlZ190IHJlZywgdTMyIGNscikK IAlpbnRlbF91bmNvcmVfcm13X2Z3KHVuY29yZSwgcmVnLCBjbHIsIDApOwogfQogCi1zdGF0aWMg dm9pZCBza2lwX2NvbnRleHQoc3RydWN0IGk5MTVfcmVxdWVzdCAqcnEpCi17Ci0Jc3RydWN0IGlu dGVsX2NvbnRleHQgKmh1bmdfY3R4ID0gcnEtPmNvbnRleHQ7Ci0KLQlsaXN0X2Zvcl9lYWNoX2Vu dHJ5X2Zyb21fcmN1KHJxLCAmaHVuZ19jdHgtPnRpbWVsaW5lLT5yZXF1ZXN0cywgbGluaykgewot CQlpZiAoIWk5MTVfcmVxdWVzdF9pc19hY3RpdmUocnEpKQotCQkJcmV0dXJuOwotCi0JCWlmIChy cS0+Y29udGV4dCA9PSBodW5nX2N0eCkgewotCQkJaTkxNV9yZXF1ZXN0X3NldF9lcnJvcl9vbmNl KHJxLCAtRUlPKTsKLQkJCV9faTkxNV9yZXF1ZXN0X3NraXAocnEpOwotCQl9Ci0JfQotfQotCiBz dGF0aWMgdm9pZCBjbGllbnRfbWFya19ndWlsdHkoc3RydWN0IGk5MTVfZ2VtX2NvbnRleHQgKmN0 eCwgYm9vbCBiYW5uZWQpCiB7CiAJc3RydWN0IGRybV9pOTE1X2ZpbGVfcHJpdmF0ZSAqZmlsZV9w cml2ID0gY3R4LT5maWxlX3ByaXY7CkBAIC04OCwxMCArNzIsOCBAQCBzdGF0aWMgYm9vbCBtYXJr X2d1aWx0eShzdHJ1Y3QgaTkxNV9yZXF1ZXN0ICpycSkKIAlib29sIGJhbm5lZDsKIAlpbnQgaTsK IAotCWlmIChpbnRlbF9jb250ZXh0X2lzX2Nsb3NlZChycS0+Y29udGV4dCkpIHsKLQkJaW50ZWxf Y29udGV4dF9zZXRfYmFubmVkKHJxLT5jb250ZXh0KTsKKwlpZiAoaW50ZWxfY29udGV4dF9pc19j bG9zZWQocnEtPmNvbnRleHQpKQogCQlyZXR1cm4gdHJ1ZTsKLQl9CiAKIAlyY3VfcmVhZF9sb2Nr KCk7CiAJY3R4ID0gcmN1X2RlcmVmZXJlbmNlKHJxLT5jb250ZXh0LT5nZW1fY29udGV4dCk7CkBA IC0xMjMsMTEgKzEwNSw5IEBAIHN0YXRpYyBib29sIG1hcmtfZ3VpbHR5KHN0cnVjdCBpOTE1X3Jl cXVlc3QgKnJxKQogCWJhbm5lZCA9ICFpOTE1X2dlbV9jb250ZXh0X2lzX3JlY292ZXJhYmxlKGN0 eCk7CiAJaWYgKHRpbWVfYmVmb3JlKGppZmZpZXMsIHByZXZfaGFuZyArIENPTlRFWFRfRkFTVF9I QU5HX0pJRkZJRVMpKQogCQliYW5uZWQgPSB0cnVlOwotCWlmIChiYW5uZWQpIHsKKwlpZiAoYmFu bmVkKQogCQlkcm1fZGJnKCZjdHgtPmk5MTUtPmRybSwgImNvbnRleHQgJXM6IGd1aWx0eSAlZCwg YmFubmVkXG4iLAogCQkJY3R4LT5uYW1lLCBhdG9taWNfcmVhZCgmY3R4LT5ndWlsdHlfY291bnQp KTsKLQkJaW50ZWxfY29udGV4dF9zZXRfYmFubmVkKHJxLT5jb250ZXh0KTsKLQl9CiAKIAljbGll bnRfbWFya19ndWlsdHkoY3R4LCBiYW5uZWQpOwogCkBAIC0xNDksNiArMTI5LDggQEAgc3RhdGlj IHZvaWQgbWFya19pbm5vY2VudChzdHJ1Y3QgaTkxNV9yZXF1ZXN0ICpycSkKIAogdm9pZCBfX2k5 MTVfcmVxdWVzdF9yZXNldChzdHJ1Y3QgaTkxNV9yZXF1ZXN0ICpycSwgYm9vbCBndWlsdHkpCiB7 CisJYm9vbCBiYW5uZWQgPSBmYWxzZTsKKwogCVJRX1RSQUNFKHJxLCAiZ3VpbHR5PyAlc1xuIiwg eWVzbm8oZ3VpbHR5KSk7CiAJR0VNX0JVR19PTihfX2k5MTVfcmVxdWVzdF9pc19jb21wbGV0ZShy cSkpOwogCkBAIC0xNTYsMTMgKzEzOCwxNSBAQCB2b2lkIF9faTkxNV9yZXF1ZXN0X3Jlc2V0KHN0 cnVjdCBpOTE1X3JlcXVlc3QgKnJxLCBib29sIGd1aWx0eSkKIAlpZiAoZ3VpbHR5KSB7CiAJCWk5 MTVfcmVxdWVzdF9zZXRfZXJyb3Jfb25jZShycSwgLUVJTyk7CiAJCV9faTkxNV9yZXF1ZXN0X3Nr aXAocnEpOwotCQlpZiAobWFya19ndWlsdHkocnEpKQotCQkJc2tpcF9jb250ZXh0KHJxKTsKKwkJ YmFubmVkID0gbWFya19ndWlsdHkocnEpOwogCX0gZWxzZSB7CiAJCWk5MTVfcmVxdWVzdF9zZXRf ZXJyb3Jfb25jZShycSwgLUVBR0FJTik7CiAJCW1hcmtfaW5ub2NlbnQocnEpOwogCX0KIAlyY3Vf cmVhZF91bmxvY2soKTsKKworCWlmIChiYW5uZWQpCisJCWludGVsX2NvbnRleHRfYmFuKHJxLT5j b250ZXh0LCBycSk7CiB9CiAKIHN0YXRpYyBib29sIGk5MTVfaW5fcmVzZXQoc3RydWN0IHBjaV9k ZXYgKnBkZXYpCkBAIC04MjYsNiArODEwLDggQEAgc3RhdGljIGludCBndF9yZXNldChzdHJ1Y3Qg aW50ZWxfZ3QgKmd0LCBpbnRlbF9lbmdpbmVfbWFza190IHN0YWxsZWRfbWFzaykKIAkJX19pbnRl bF9lbmdpbmVfcmVzZXQoZW5naW5lLCBzdGFsbGVkX21hc2sgJiBlbmdpbmUtPm1hc2spOwogCWxv Y2FsX2JoX2VuYWJsZSgpOwogCisJaW50ZWxfdWNfcmVzZXQoJmd0LT51YywgdHJ1ZSk7CisKIAlp bnRlbF9nZ3R0X3Jlc3RvcmVfZmVuY2VzKGd0LT5nZ3R0KTsKIAogCXJldHVybiBlcnI7CkBAIC04 NTAsNiArODM2LDggQEAgc3RhdGljIHZvaWQgcmVzZXRfZmluaXNoKHN0cnVjdCBpbnRlbF9ndCAq Z3QsIGludGVsX2VuZ2luZV9tYXNrX3QgYXdha2UpCiAJCWlmIChhd2FrZSAmIGVuZ2luZS0+bWFz aykKIAkJCWludGVsX2VuZ2luZV9wbV9wdXQoZW5naW5lKTsKIAl9CisKKwlpbnRlbF91Y19yZXNl dF9maW5pc2goJmd0LT51Yyk7CiB9CiAKIHN0YXRpYyB2b2lkIG5vcF9zdWJtaXRfcmVxdWVzdChz dHJ1Y3QgaTkxNV9yZXF1ZXN0ICpyZXF1ZXN0KQpAQCAtOTAzLDYgKzg5MSw3IEBAIHN0YXRpYyB2 b2lkIF9faW50ZWxfZ3Rfc2V0X3dlZGdlZChzdHJ1Y3QgaW50ZWxfZ3QgKmd0KQogCWZvcl9lYWNo X2VuZ2luZShlbmdpbmUsIGd0LCBpZCkKIAkJaWYgKGVuZ2luZS0+cmVzZXQuY2FuY2VsKQogCQkJ ZW5naW5lLT5yZXNldC5jYW5jZWwoZW5naW5lKTsKKwlpbnRlbF91Y19jYW5jZWxfcmVxdWVzdHMo Jmd0LT51Yyk7CiAJbG9jYWxfYmhfZW5hYmxlKCk7CiAKIAlyZXNldF9maW5pc2goZ3QsIGF3YWtl KTsKQEAgLTExOTEsNiArMTE4MCw5IEBAIGludCBfX2ludGVsX2VuZ2luZV9yZXNldF9iaChzdHJ1 Y3QgaW50ZWxfZW5naW5lX2NzICplbmdpbmUsIGNvbnN0IGNoYXIgKm1zZykKIAlFTkdJTkVfVFJB Q0UoZW5naW5lLCAiZmxhZ3M9JWx4XG4iLCBndC0+cmVzZXQuZmxhZ3MpOwogCUdFTV9CVUdfT04o IXRlc3RfYml0KEk5MTVfUkVTRVRfRU5HSU5FICsgZW5naW5lLT5pZCwgJmd0LT5yZXNldC5mbGFn cykpOwogCisJaWYgKGludGVsX2VuZ2luZV91c2VzX2d1YyhlbmdpbmUpKQorCQlyZXR1cm4gLUVO T0RFVjsKKwogCWlmICghaW50ZWxfZW5naW5lX3BtX2dldF9pZl9hd2FrZShlbmdpbmUpKQogCQly ZXR1cm4gMDsKIApAQCAtMTIwMSwxMyArMTE5MywxMCBAQCBpbnQgX19pbnRlbF9lbmdpbmVfcmVz ZXRfYmgoc3RydWN0IGludGVsX2VuZ2luZV9jcyAqZW5naW5lLCBjb25zdCBjaGFyICptc2cpCiAJ CQkgICAiUmVzZXR0aW5nICVzIGZvciAlc1xuIiwgZW5naW5lLT5uYW1lLCBtc2cpOwogCWF0b21p Y19pbmMoJmVuZ2luZS0+aTkxNS0+Z3B1X2Vycm9yLnJlc2V0X2VuZ2luZV9jb3VudFtlbmdpbmUt PnVhYmlfY2xhc3NdKTsKIAotCWlmIChpbnRlbF9lbmdpbmVfdXNlc19ndWMoZW5naW5lKSkKLQkJ cmV0ID0gaW50ZWxfZ3VjX3Jlc2V0X2VuZ2luZSgmZW5naW5lLT5ndC0+dWMuZ3VjLCBlbmdpbmUp OwotCWVsc2UKLQkJcmV0ID0gaW50ZWxfZ3RfcmVzZXRfZW5naW5lKGVuZ2luZSk7CisJcmV0ID0g aW50ZWxfZ3RfcmVzZXRfZW5naW5lKGVuZ2luZSk7CiAJaWYgKHJldCkgewogCQkvKiBJZiB3ZSBm YWlsIGhlcmUsIHdlIGV4cGVjdCB0byBmYWxsYmFjayB0byBhIGdsb2JhbCByZXNldCAqLwotCQlF TkdJTkVfVFJBQ0UoZW5naW5lLCAiRmFpbGVkIHRvIHJlc2V0LCBlcnI6ICVkXG4iLCByZXQpOwor CQlFTkdJTkVfVFJBQ0UoZW5naW5lLCAiRmFpbGVkIHRvIHJlc2V0ICVzLCBlcnI6ICVkXG4iLCBl bmdpbmUtPm5hbWUsIHJldCk7CiAJCWdvdG8gb3V0OwogCX0KIApAQCAtMTM0MSw3ICsxMzMwLDgg QEAgdm9pZCBpbnRlbF9ndF9oYW5kbGVfZXJyb3Ioc3RydWN0IGludGVsX2d0ICpndCwKIAkgKiBU cnkgZW5naW5lIHJlc2V0IHdoZW4gYXZhaWxhYmxlLiBXZSBmYWxsIGJhY2sgdG8gZnVsbCByZXNl dCBpZgogCSAqIHNpbmdsZSByZXNldCBmYWlscy4KIAkgKi8KLQlpZiAoaW50ZWxfaGFzX3Jlc2V0 X2VuZ2luZShndCkgJiYgIWludGVsX2d0X2lzX3dlZGdlZChndCkpIHsKKwlpZiAoIWludGVsX3Vj X3VzZXNfZ3VjX3N1Ym1pc3Npb24oJmd0LT51YykgJiYKKwkgICAgaW50ZWxfaGFzX3Jlc2V0X2Vu Z2luZShndCkgJiYgIWludGVsX2d0X2lzX3dlZGdlZChndCkpIHsKIAkJbG9jYWxfYmhfZGlzYWJs ZSgpOwogCQlmb3JfZWFjaF9lbmdpbmVfbWFza2VkKGVuZ2luZSwgZ3QsIGVuZ2luZV9tYXNrLCB0 bXApIHsKIAkJCUJVSUxEX0JVR19PTihJOTE1X1JFU0VUX01PREVTRVQgPj0gSTkxNV9SRVNFVF9F TkdJTkUpOwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJtL2k5MTUvZ3QvaW50ZWxfcmluZ19z dWJtaXNzaW9uLmMgYi9kcml2ZXJzL2dwdS9kcm0vaTkxNS9ndC9pbnRlbF9yaW5nX3N1Ym1pc3Np b24uYwppbmRleCA1YzRkMjA0ZDA3Y2MuLjA1YmI5ZjQ0OWRmMSAxMDA2NDQKLS0tIGEvZHJpdmVy cy9ncHUvZHJtL2k5MTUvZ3QvaW50ZWxfcmluZ19zdWJtaXNzaW9uLmMKKysrIGIvZHJpdmVycy9n cHUvZHJtL2k5MTUvZ3QvaW50ZWxfcmluZ19zdWJtaXNzaW9uLmMKQEAgLTU4Niw5ICs1ODYsMjkg QEAgc3RhdGljIHZvaWQgcmluZ19jb250ZXh0X3Jlc2V0KHN0cnVjdCBpbnRlbF9jb250ZXh0ICpj ZSkKIAljbGVhcl9iaXQoQ09OVEVYVF9WQUxJRF9CSVQsICZjZS0+ZmxhZ3MpOwogfQogCitzdGF0 aWMgdm9pZCByaW5nX2NvbnRleHRfYmFuKHN0cnVjdCBpbnRlbF9jb250ZXh0ICpjZSwKKwkJCSAg ICAgc3RydWN0IGk5MTVfcmVxdWVzdCAqcnEpCit7CisJc3RydWN0IGludGVsX2VuZ2luZV9jcyAq ZW5naW5lOworCisJaWYgKCFycSB8fCAhaTkxNV9yZXF1ZXN0X2lzX2FjdGl2ZShycSkpCisJCXJl dHVybjsKKworCWVuZ2luZSA9IHJxLT5lbmdpbmU7CisJbG9ja2RlcF9hc3NlcnRfaGVsZCgmZW5n aW5lLT5zY2hlZF9lbmdpbmUtPmxvY2spOworCWxpc3RfZm9yX2VhY2hfZW50cnlfY29udGludWUo cnEsICZlbmdpbmUtPnNjaGVkX2VuZ2luZS0+cmVxdWVzdHMsCisJCQkJICAgICBzY2hlZC5saW5r KQorCQlpZiAocnEtPmNvbnRleHQgPT0gY2UpIHsKKwkJCWk5MTVfcmVxdWVzdF9zZXRfZXJyb3Jf b25jZShycSwgLUVJTyk7CisJCQlfX2k5MTVfcmVxdWVzdF9za2lwKHJxKTsKKwkJfQorfQorCiBz dGF0aWMgY29uc3Qgc3RydWN0IGludGVsX2NvbnRleHRfb3BzIHJpbmdfY29udGV4dF9vcHMgPSB7 CiAJLmFsbG9jID0gcmluZ19jb250ZXh0X2FsbG9jLAogCisJLmJhbiA9IHJpbmdfY29udGV4dF9i YW4sCisKIAkucHJlX3BpbiA9IHJpbmdfY29udGV4dF9wcmVfcGluLAogCS5waW4gPSByaW5nX2Nv bnRleHRfcGluLAogCS51bnBpbiA9IHJpbmdfY29udGV4dF91bnBpbiwKQEAgLTEwNDcsNiArMTA2 NywyNSBAQCBzdGF0aWMgdm9pZCBzZXR1cF9pcnEoc3RydWN0IGludGVsX2VuZ2luZV9jcyAqZW5n aW5lKQogCX0KIH0KIAorc3RhdGljIHZvaWQgYWRkX3RvX2VuZ2luZShzdHJ1Y3QgaTkxNV9yZXF1 ZXN0ICpycSkKK3sKKwlsb2NrZGVwX2Fzc2VydF9oZWxkKCZycS0+ZW5naW5lLT5zY2hlZF9lbmdp bmUtPmxvY2spOworCWxpc3RfbW92ZV90YWlsKCZycS0+c2NoZWQubGluaywgJnJxLT5lbmdpbmUt PnNjaGVkX2VuZ2luZS0+cmVxdWVzdHMpOworfQorCitzdGF0aWMgdm9pZCByZW1vdmVfZnJvbV9l bmdpbmUoc3RydWN0IGk5MTVfcmVxdWVzdCAqcnEpCit7CisJc3Bpbl9sb2NrX2lycSgmcnEtPmVu Z2luZS0+c2NoZWRfZW5naW5lLT5sb2NrKTsKKwlsaXN0X2RlbF9pbml0KCZycS0+c2NoZWQubGlu ayk7CisKKwkvKiBQcmV2ZW50IGZ1cnRoZXIgX19hd2FpdF9leGVjdXRpb24oKSByZWdpc3Rlcmlu ZyBhIGNiLCB0aGVuIGZsdXNoICovCisJc2V0X2JpdChJOTE1X0ZFTkNFX0ZMQUdfQUNUSVZFLCAm cnEtPmZlbmNlLmZsYWdzKTsKKworCXNwaW5fdW5sb2NrX2lycSgmcnEtPmVuZ2luZS0+c2NoZWRf ZW5naW5lLT5sb2NrKTsKKworCWk5MTVfcmVxdWVzdF9ub3RpZnlfZXhlY3V0ZV9jYl9pbW0ocnEp OworfQorCiBzdGF0aWMgdm9pZCBzZXR1cF9jb21tb24oc3RydWN0IGludGVsX2VuZ2luZV9jcyAq ZW5naW5lKQogewogCXN0cnVjdCBkcm1faTkxNV9wcml2YXRlICppOTE1ID0gZW5naW5lLT5pOTE1 OwpAQCAtMTA2NCw2ICsxMTAzLDkgQEAgc3RhdGljIHZvaWQgc2V0dXBfY29tbW9uKHN0cnVjdCBp bnRlbF9lbmdpbmVfY3MgKmVuZ2luZSkKIAllbmdpbmUtPnJlc2V0LmNhbmNlbCA9IHJlc2V0X2Nh bmNlbDsKIAllbmdpbmUtPnJlc2V0LmZpbmlzaCA9IHJlc2V0X2ZpbmlzaDsKIAorCWVuZ2luZS0+ YWRkX2FjdGl2ZV9yZXF1ZXN0ID0gYWRkX3RvX2VuZ2luZTsKKwllbmdpbmUtPnJlbW92ZV9hY3Rp dmVfcmVxdWVzdCA9IHJlbW92ZV9mcm9tX2VuZ2luZTsKKwogCWVuZ2luZS0+Y29wcyA9ICZyaW5n X2NvbnRleHRfb3BzOwogCWVuZ2luZS0+cmVxdWVzdF9hbGxvYyA9IHJpbmdfcmVxdWVzdF9hbGxv YzsKIApkaWZmIC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJtL2k5MTUvZ3QvaW50ZWxfcnBzLmMgYi9k cml2ZXJzL2dwdS9kcm0vaTkxNS9ndC9pbnRlbF9ycHMuYwppbmRleCAwNmU5YThlZDRlMDMuLjBj OGU3ZjJiMDZmMCAxMDA2NDQKLS0tIGEvZHJpdmVycy9ncHUvZHJtL2k5MTUvZ3QvaW50ZWxfcnBz LmMKKysrIGIvZHJpdmVycy9ncHUvZHJtL2k5MTUvZ3QvaW50ZWxfcnBzLmMKQEAgLTE4NzcsNiAr MTg3NywxMCBAQCB2b2lkIGludGVsX3Jwc19pbml0KHN0cnVjdCBpbnRlbF9ycHMgKnJwcykKIAog CWlmIChHUkFQSElDU19WRVIoaTkxNSkgPj0gOCAmJiBHUkFQSElDU19WRVIoaTkxNSkgPCAxMSkK IAkJcnBzLT5wbV9pbnRybXNrX21ieiB8PSBHRU44X1BNSU5UUl9ESVNBQkxFX1JFRElSRUNUX1RP X0dVQzsKKworCS8qIEd1QyBuZWVkcyBBUkFUIGV4cGlyZWQgaW50ZXJydXB0IHVubWFza2VkICov CisJaWYgKGludGVsX3VjX3VzZXNfZ3VjX3N1Ym1pc3Npb24oJnJwc190b19ndChycHMpLT51Yykp CisJCXJwcy0+cG1faW50cm1za19tYnogfD0gQVJBVF9FWFBJUkVEX0lOVFJNU0s7CiB9CiAKIHZv aWQgaW50ZWxfcnBzX3Nhbml0aXplKHN0cnVjdCBpbnRlbF9ycHMgKnJwcykKZGlmZiAtLWdpdCBh L2RyaXZlcnMvZ3B1L2RybS9pOTE1L2d0L2ludGVsX3dvcmthcm91bmRzLmMgYi9kcml2ZXJzL2dw dS9kcm0vaTkxNS9ndC9pbnRlbF93b3JrYXJvdW5kcy5jCmluZGV4IDc3MzFkYjMzYzQ2YS4uMmZk MzJkYzBiNTIxIDEwMDY0NAotLS0gYS9kcml2ZXJzL2dwdS9kcm0vaTkxNS9ndC9pbnRlbF93b3Jr YXJvdW5kcy5jCisrKyBiL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2d0L2ludGVsX3dvcmthcm91bmRz LmMKQEAgLTE1MCwxMyArMTUwLDE0IEBAIHN0YXRpYyB2b2lkIF93YV9hZGQoc3RydWN0IGk5MTVf d2FfbGlzdCAqd2FsLCBjb25zdCBzdHJ1Y3QgaTkxNV93YSAqd2EpCiB9CiAKIHN0YXRpYyB2b2lk IHdhX2FkZChzdHJ1Y3QgaTkxNV93YV9saXN0ICp3YWwsIGk5MTVfcmVnX3QgcmVnLAotCQkgICB1 MzIgY2xlYXIsIHUzMiBzZXQsIHUzMiByZWFkX21hc2spCisJCSAgIHUzMiBjbGVhciwgdTMyIHNl dCwgdTMyIHJlYWRfbWFzaywgYm9vbCBtYXNrZWRfcmVnKQogewogCXN0cnVjdCBpOTE1X3dhIHdh ID0gewogCQkucmVnICA9IHJlZywKIAkJLmNsciAgPSBjbGVhciwKIAkJLnNldCAgPSBzZXQsCiAJ CS5yZWFkID0gcmVhZF9tYXNrLAorCQkubWFza2VkX3JlZyA9IG1hc2tlZF9yZWcsCiAJfTsKIAog CV93YV9hZGQod2FsLCAmd2EpOwpAQCAtMTY1LDcgKzE2Niw3IEBAIHN0YXRpYyB2b2lkIHdhX2Fk ZChzdHJ1Y3QgaTkxNV93YV9saXN0ICp3YWwsIGk5MTVfcmVnX3QgcmVnLAogc3RhdGljIHZvaWQK IHdhX3dyaXRlX2Nscl9zZXQoc3RydWN0IGk5MTVfd2FfbGlzdCAqd2FsLCBpOTE1X3JlZ190IHJl ZywgdTMyIGNsZWFyLCB1MzIgc2V0KQogewotCXdhX2FkZCh3YWwsIHJlZywgY2xlYXIsIHNldCwg Y2xlYXIpOworCXdhX2FkZCh3YWwsIHJlZywgY2xlYXIsIHNldCwgY2xlYXIsIGZhbHNlKTsKIH0K IAogc3RhdGljIHZvaWQKQEAgLTIwMCwyMCArMjAxLDIwIEBAIHdhX3dyaXRlX2NscihzdHJ1Y3Qg aTkxNV93YV9saXN0ICp3YWwsIGk5MTVfcmVnX3QgcmVnLCB1MzIgY2xyKQogc3RhdGljIHZvaWQK IHdhX21hc2tlZF9lbihzdHJ1Y3QgaTkxNV93YV9saXN0ICp3YWwsIGk5MTVfcmVnX3QgcmVnLCB1 MzIgdmFsKQogewotCXdhX2FkZCh3YWwsIHJlZywgMCwgX01BU0tFRF9CSVRfRU5BQkxFKHZhbCks IHZhbCk7CisJd2FfYWRkKHdhbCwgcmVnLCAwLCBfTUFTS0VEX0JJVF9FTkFCTEUodmFsKSwgdmFs LCB0cnVlKTsKIH0KIAogc3RhdGljIHZvaWQKIHdhX21hc2tlZF9kaXMoc3RydWN0IGk5MTVfd2Ff bGlzdCAqd2FsLCBpOTE1X3JlZ190IHJlZywgdTMyIHZhbCkKIHsKLQl3YV9hZGQod2FsLCByZWcs IDAsIF9NQVNLRURfQklUX0RJU0FCTEUodmFsKSwgdmFsKTsKKwl3YV9hZGQod2FsLCByZWcsIDAs IF9NQVNLRURfQklUX0RJU0FCTEUodmFsKSwgdmFsLCB0cnVlKTsKIH0KIAogc3RhdGljIHZvaWQK IHdhX21hc2tlZF9maWVsZF9zZXQoc3RydWN0IGk5MTVfd2FfbGlzdCAqd2FsLCBpOTE1X3JlZ190 IHJlZywKIAkJICAgIHUzMiBtYXNrLCB1MzIgdmFsKQogewotCXdhX2FkZCh3YWwsIHJlZywgMCwg X01BU0tFRF9GSUVMRChtYXNrLCB2YWwpLCBtYXNrKTsKKwl3YV9hZGQod2FsLCByZWcsIDAsIF9N QVNLRURfRklFTEQobWFzaywgdmFsKSwgbWFzaywgdHJ1ZSk7CiB9CiAKIHN0YXRpYyB2b2lkIGdl bjZfY3R4X3dvcmthcm91bmRzX2luaXQoc3RydWN0IGludGVsX2VuZ2luZV9jcyAqZW5naW5lLApA QCAtNTMzLDEwICs1MzQsMTAgQEAgc3RhdGljIHZvaWQgaWNsX2N0eF93b3JrYXJvdW5kc19pbml0 KHN0cnVjdCBpbnRlbF9lbmdpbmVfY3MgKmVuZ2luZSwKIAl3YV9tYXNrZWRfZW4od2FsLCBJQ0xf SERDX01PREUsIEhEQ19GT1JDRV9OT05fQ09IRVJFTlQpOwogCiAJLyogV2FFbmFibGVGbG9hdEJs ZW5kT3B0aW1pemF0aW9uOmljbCAqLwotCXdhX3dyaXRlX2Nscl9zZXQod2FsLAotCQkJIEdFTjEw X0NBQ0hFX01PREVfU1MsCi0JCQkgMCwgLyogd3JpdGUtb25seSwgc28gc2tpcCB2YWxpZGF0aW9u ICovCi0JCQkgX01BU0tFRF9CSVRfRU5BQkxFKEZMT0FUX0JMRU5EX09QVElNSVpBVElPTl9FTkFC TEUpKTsKKwl3YV9hZGQod2FsLCBHRU4xMF9DQUNIRV9NT0RFX1NTLCAwLAorCSAgICAgICBfTUFT S0VEX0JJVF9FTkFCTEUoRkxPQVRfQkxFTkRfT1BUSU1JWkFUSU9OX0VOQUJMRSksCisJICAgICAg IDAgLyogd3JpdGUtb25seSwgc28gc2tpcCB2YWxpZGF0aW9uICovLAorCSAgICAgICB0cnVlKTsK IAogCS8qIFdhRGlzYWJsZUdQR1BVTWlkVGhyZWFkUHJlZW1wdGlvbjppY2wgKi8KIAl3YV9tYXNr ZWRfZmllbGRfc2V0KHdhbCwgR0VOOF9DU19DSElDS0VOMSwKQEAgLTU4MSw3ICs1ODIsNyBAQCBz dGF0aWMgdm9pZCBnZW4xMl9jdHhfZ3RfdHVuaW5nX2luaXQoc3RydWN0IGludGVsX2VuZ2luZV9j cyAqZW5naW5lLAogCSAgICAgICBGRl9NT0RFMiwKIAkgICAgICAgRkZfTU9ERTJfVERTX1RJTUVS X01BU0ssCiAJICAgICAgIEZGX01PREUyX1REU19USU1FUl8xMjgsCi0JICAgICAgIDApOworCSAg ICAgICAwLCBmYWxzZSk7CiB9CiAKIHN0YXRpYyB2b2lkIGdlbjEyX2N0eF93b3JrYXJvdW5kc19p bml0KHN0cnVjdCBpbnRlbF9lbmdpbmVfY3MgKmVuZ2luZSwKQEAgLTYxOSw3ICs2MjAsNyBAQCBz dGF0aWMgdm9pZCBnZW4xMl9jdHhfd29ya2Fyb3VuZHNfaW5pdChzdHJ1Y3QgaW50ZWxfZW5naW5l X2NzICplbmdpbmUsCiAJICAgICAgIEZGX01PREUyLAogCSAgICAgICBGRl9NT0RFMl9HU19USU1F Ul9NQVNLLAogCSAgICAgICBGRl9NT0RFMl9HU19USU1FUl8yMjQsCi0JICAgICAgIDApOworCSAg ICAgICAwLCBmYWxzZSk7CiAKIAkvKgogCSAqIFdhXzE0MDEyMTMxMjI3OmRnMQpAQCAtNzk1LDcg Kzc5Niw3IEBAIGhzd19ndF93b3JrYXJvdW5kc19pbml0KHN0cnVjdCBkcm1faTkxNV9wcml2YXRl ICppOTE1LCBzdHJ1Y3QgaTkxNV93YV9saXN0ICp3YWwpCiAJd2FfYWRkKHdhbCwKIAkgICAgICAg SFNXX1JPV19DSElDS0VOMywgMCwKIAkgICAgICAgX01BU0tFRF9CSVRfRU5BQkxFKEhTV19ST1df Q0hJQ0tFTjNfTDNfR0xPQkFMX0FUT01JQ1NfRElTQUJMRSksCi0JCTAgLyogWFhYIGRvZXMgdGhp cyByZWcgZXhpc3Q/ICovKTsKKwkgICAgICAgMCAvKiBYWFggZG9lcyB0aGlzIHJlZyBleGlzdD8g Ki8sIHRydWUpOwogCiAJLyogV2FWU1JlZkNvdW50RnVsbGZvcmNlTWlzc0Rpc2FibGU6aHN3ICov CiAJd2Ffd3JpdGVfY2xyKHdhbCwgR0VON19GRl9USFJFQURfTU9ERSwgR0VON19GRl9WU19SRUZf Q05UX0ZGTUUpOwpAQCAtMTg0MywxMCArMTg0NCwxMCBAQCByY3NfZW5naW5lX3dhX2luaXQoc3Ry dWN0IGludGVsX2VuZ2luZV9jcyAqZW5naW5lLCBzdHJ1Y3QgaTkxNV93YV9saXN0ICp3YWwpCiAJ CSAqIGRpc2FibGUgYml0LCB3aGljaCB3ZSBkb24ndCB0b3VjaCBoZXJlLCBidXQgaXQncyBnb29k CiAJCSAqIHRvIGtlZXAgaW4gbWluZCAoc2VlIDNEU1RBVEVfUFMgYW5kIDNEU1RBVEVfV00pLgog CQkgKi8KLQkJd2FfYWRkKHdhbCwgR0VON19HVF9NT0RFLCAwLAotCQkgICAgICAgX01BU0tFRF9G SUVMRChHRU42X1dJWl9IQVNISU5HX01BU0ssCi0JCQkJICAgICBHRU42X1dJWl9IQVNISU5HXzE2 eDQpLAotCQkgICAgICAgR0VONl9XSVpfSEFTSElOR18xNng0KTsKKwkJd2FfbWFza2VkX2ZpZWxk X3NldCh3YWwsCisJCQkJICAgIEdFTjdfR1RfTU9ERSwKKwkJCQkgICAgR0VONl9XSVpfSEFTSElO R19NQVNLLAorCQkJCSAgICBHRU42X1dJWl9IQVNISU5HXzE2eDQpOwogCX0KIAogCWlmIChJU19H UkFQSElDU19WRVIoaTkxNSwgNiwgNykpCkBAIC0xODk2LDEwICsxODk3LDEwIEBAIHJjc19lbmdp bmVfd2FfaW5pdChzdHJ1Y3QgaW50ZWxfZW5naW5lX2NzICplbmdpbmUsIHN0cnVjdCBpOTE1X3dh X2xpc3QgKndhbCkKIAkJICogZGlzYWJsZSBiaXQsIHdoaWNoIHdlIGRvbid0IHRvdWNoIGhlcmUs IGJ1dCBpdCdzIGdvb2QKIAkJICogdG8ga2VlcCBpbiBtaW5kIChzZWUgM0RTVEFURV9QUyBhbmQg M0RTVEFURV9XTSkuCiAJCSAqLwotCQl3YV9hZGQod2FsLAotCQkgICAgICAgR0VONl9HVF9NT0RF LCAwLAotCQkgICAgICAgX01BU0tFRF9GSUVMRChHRU42X1dJWl9IQVNISU5HX01BU0ssIEdFTjZf V0laX0hBU0hJTkdfMTZ4NCksCi0JCSAgICAgICBHRU42X1dJWl9IQVNISU5HXzE2eDQpOworCQl3 YV9tYXNrZWRfZmllbGRfc2V0KHdhbCwKKwkJCQkgICAgR0VONl9HVF9NT0RFLAorCQkJCSAgICBH RU42X1dJWl9IQVNISU5HX01BU0ssCisJCQkJICAgIEdFTjZfV0laX0hBU0hJTkdfMTZ4NCk7CiAK IAkJLyogV2FEaXNhYmxlX1JlbmRlckNhY2hlX09wZXJhdGlvbmFsRmx1c2g6c25iICovCiAJCXdh X21hc2tlZF9kaXMod2FsLCBDQUNIRV9NT0RFXzAsIFJDX09QX0ZMVVNIX0VOQUJMRSk7CkBAIC0x OTIwLDcgKzE5MjEsNyBAQCByY3NfZW5naW5lX3dhX2luaXQoc3RydWN0IGludGVsX2VuZ2luZV9j cyAqZW5naW5lLCBzdHJ1Y3QgaTkxNV93YV9saXN0ICp3YWwpCiAJCXdhX2FkZCh3YWwsIE1JX01P REUsCiAJCSAgICAgICAwLCBfTUFTS0VEX0JJVF9FTkFCTEUoVlNfVElNRVJfRElTUEFUQ0gpLAog CQkgICAgICAgLyogWFhYIGJpdCBkb2Vzbid0IHN0aWNrIG9uIEJyb2Fkd2F0ZXIgKi8KLQkJICAg ICAgIElTX0k5NjVHKGk5MTUpID8gMCA6IFZTX1RJTUVSX0RJU1BBVENIKTsKKwkJICAgICAgIElT X0k5NjVHKGk5MTUpID8gMCA6IFZTX1RJTUVSX0RJU1BBVENILCB0cnVlKTsKIAogCWlmIChHUkFQ SElDU19WRVIoaTkxNSkgPT0gNCkKIAkJLyoKQEAgLTE5MzUsNyArMTkzNiw4IEBAIHJjc19lbmdp bmVfd2FfaW5pdChzdHJ1Y3QgaW50ZWxfZW5naW5lX2NzICplbmdpbmUsIHN0cnVjdCBpOTE1X3dh X2xpc3QgKndhbCkKIAkJICovCiAJCXdhX2FkZCh3YWwsIEVDT1NLUEQsCiAJCSAgICAgICAwLCBf TUFTS0VEX0JJVF9FTkFCTEUoRUNPX0NPTlNUQU5UX0JVRkZFUl9TUl9ESVNBQkxFKSwKLQkJICAg ICAgIDAgLyogWFhYIGJpdCBkb2Vzbid0IHN0aWNrIG9uIEJyb2Fkd2F0ZXIgKi8pOworCQkgICAg ICAgMCAvKiBYWFggYml0IGRvZXNuJ3Qgc3RpY2sgb24gQnJvYWR3YXRlciAqLywKKwkJICAgICAg IHRydWUpOwogfQogCiBzdGF0aWMgdm9pZApkaWZmIC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJtL2k5 MTUvZ3QvaW50ZWxfd29ya2Fyb3VuZHNfdHlwZXMuaCBiL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2d0 L2ludGVsX3dvcmthcm91bmRzX3R5cGVzLmgKaW5kZXggYzIxNDExMWVhMzY3Li4xZTg3MzY4MTc5 NWQgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2d0L2ludGVsX3dvcmthcm91bmRz X3R5cGVzLmgKKysrIGIvZHJpdmVycy9ncHUvZHJtL2k5MTUvZ3QvaW50ZWxfd29ya2Fyb3VuZHNf dHlwZXMuaApAQCAtMTUsNiArMTUsNyBAQCBzdHJ1Y3QgaTkxNV93YSB7CiAJdTMyCQljbHI7CiAJ dTMyCQlzZXQ7CiAJdTMyCQlyZWFkOworCWJvb2wJCW1hc2tlZF9yZWc7CiB9OwogCiBzdHJ1Y3Qg aTkxNV93YV9saXN0IHsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2d0L21vY2tf ZW5naW5lLmMgYi9kcml2ZXJzL2dwdS9kcm0vaTkxNS9ndC9tb2NrX2VuZ2luZS5jCmluZGV4IDY4 OTcwMzk4ZTRlZi4uMmMxYWYwMzAzMTBjIDEwMDY0NAotLS0gYS9kcml2ZXJzL2dwdS9kcm0vaTkx NS9ndC9tb2NrX2VuZ2luZS5jCisrKyBiL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2d0L21vY2tfZW5n aW5lLmMKQEAgLTIzNSw2ICsyMzUsMzQgQEAgc3RhdGljIHZvaWQgbW9ja19zdWJtaXRfcmVxdWVz dChzdHJ1Y3QgaTkxNV9yZXF1ZXN0ICpyZXF1ZXN0KQogCXNwaW5fdW5sb2NrX2lycXJlc3RvcmUo JmVuZ2luZS0+aHdfbG9jaywgZmxhZ3MpOwogfQogCitzdGF0aWMgdm9pZCBtb2NrX2FkZF90b19l bmdpbmUoc3RydWN0IGk5MTVfcmVxdWVzdCAqcnEpCit7CisJbG9ja2RlcF9hc3NlcnRfaGVsZCgm cnEtPmVuZ2luZS0+c2NoZWRfZW5naW5lLT5sb2NrKTsKKwlsaXN0X21vdmVfdGFpbCgmcnEtPnNj aGVkLmxpbmssICZycS0+ZW5naW5lLT5zY2hlZF9lbmdpbmUtPnJlcXVlc3RzKTsKK30KKworc3Rh dGljIHZvaWQgbW9ja19yZW1vdmVfZnJvbV9lbmdpbmUoc3RydWN0IGk5MTVfcmVxdWVzdCAqcnEp Cit7CisJc3RydWN0IGludGVsX2VuZ2luZV9jcyAqZW5naW5lLCAqbG9ja2VkOworCisJLyoKKwkg KiBWaXJ0dWFsIGVuZ2luZXMgY29tcGxpY2F0ZSBhY3F1aXJpbmcgdGhlIGVuZ2luZSB0aW1lbGlu ZSBsb2NrLAorCSAqIGFzIHRoZWlyIHJxLT5lbmdpbmUgcG9pbnRlciBpcyBub3Qgc3RhYmxlIHVu dGlsIHVuZGVyIHRoYXQKKwkgKiBlbmdpbmUgbG9jay4gVGhlIHNpbXBsZSBwbG95IHdlIHVzZSBp cyB0byB0YWtlIHRoZSBsb2NrIHRoZW4KKwkgKiBjaGVjayB0aGF0IHRoZSBycSBzdGlsbCBiZWxv bmdzIHRvIHRoZSBuZXdseSBsb2NrZWQgZW5naW5lLgorCSAqLworCisJbG9ja2VkID0gUkVBRF9P TkNFKHJxLT5lbmdpbmUpOworCXNwaW5fbG9ja19pcnEoJmxvY2tlZC0+c2NoZWRfZW5naW5lLT5s b2NrKTsKKwl3aGlsZSAodW5saWtlbHkobG9ja2VkICE9IChlbmdpbmUgPSBSRUFEX09OQ0UocnEt PmVuZ2luZSkpKSkgeworCQlzcGluX3VubG9jaygmbG9ja2VkLT5zY2hlZF9lbmdpbmUtPmxvY2sp OworCQlzcGluX2xvY2soJmVuZ2luZS0+c2NoZWRfZW5naW5lLT5sb2NrKTsKKwkJbG9ja2VkID0g ZW5naW5lOworCX0KKwlsaXN0X2RlbF9pbml0KCZycS0+c2NoZWQubGluayk7CisJc3Bpbl91bmxv Y2tfaXJxKCZsb2NrZWQtPnNjaGVkX2VuZ2luZS0+bG9jayk7Cit9CisKIHN0YXRpYyB2b2lkIG1v Y2tfcmVzZXRfcHJlcGFyZShzdHJ1Y3QgaW50ZWxfZW5naW5lX2NzICplbmdpbmUpCiB7CiB9CkBA IC0yODQsNyArMzEyLDcgQEAgc3RhdGljIHZvaWQgbW9ja19lbmdpbmVfcmVsZWFzZShzdHJ1Y3Qg aW50ZWxfZW5naW5lX2NzICplbmdpbmUpCiAJR0VNX0JVR19PTih0aW1lcl9wZW5kaW5nKCZtb2Nr LT5od19kZWxheSkpOwogCiAJaTkxNV9zY2hlZF9lbmdpbmVfcHV0KGVuZ2luZS0+c2NoZWRfZW5n aW5lKTsKLQlpbnRlbF9icmVhZGNydW1ic19mcmVlKGVuZ2luZS0+YnJlYWRjcnVtYnMpOworCWlu dGVsX2JyZWFkY3J1bWJzX3B1dChlbmdpbmUtPmJyZWFkY3J1bWJzKTsKIAogCWludGVsX2NvbnRl eHRfdW5waW4oZW5naW5lLT5rZXJuZWxfY29udGV4dCk7CiAJaW50ZWxfY29udGV4dF9wdXQoZW5n aW5lLT5rZXJuZWxfY29udGV4dCk7CkBAIC0zMjEsNiArMzQ5LDggQEAgc3RydWN0IGludGVsX2Vu Z2luZV9jcyAqbW9ja19lbmdpbmUoc3RydWN0IGRybV9pOTE1X3ByaXZhdGUgKmk5MTUsCiAJZW5n aW5lLT5iYXNlLmVtaXRfZmx1c2ggPSBtb2NrX2VtaXRfZmx1c2g7CiAJZW5naW5lLT5iYXNlLmVt aXRfZmluaV9icmVhZGNydW1iID0gbW9ja19lbWl0X2JyZWFkY3J1bWI7CiAJZW5naW5lLT5iYXNl LnN1Ym1pdF9yZXF1ZXN0ID0gbW9ja19zdWJtaXRfcmVxdWVzdDsKKwllbmdpbmUtPmJhc2UuYWRk X2FjdGl2ZV9yZXF1ZXN0ID0gbW9ja19hZGRfdG9fZW5naW5lOworCWVuZ2luZS0+YmFzZS5yZW1v dmVfYWN0aXZlX3JlcXVlc3QgPSBtb2NrX3JlbW92ZV9mcm9tX2VuZ2luZTsKIAogCWVuZ2luZS0+ YmFzZS5yZXNldC5wcmVwYXJlID0gbW9ja19yZXNldF9wcmVwYXJlOwogCWVuZ2luZS0+YmFzZS5y ZXNldC5yZXdpbmQgPSBtb2NrX3Jlc2V0X3Jld2luZDsKQEAgLTM3MCw3ICs0MDAsNyBAQCBpbnQg bW9ja19lbmdpbmVfaW5pdChzdHJ1Y3QgaW50ZWxfZW5naW5lX2NzICplbmdpbmUpCiAJcmV0dXJu IDA7CiAKIGVycl9icmVhZGNydW1iczoKLQlpbnRlbF9icmVhZGNydW1ic19mcmVlKGVuZ2luZS0+ YnJlYWRjcnVtYnMpOworCWludGVsX2JyZWFkY3J1bWJzX3B1dChlbmdpbmUtPmJyZWFkY3J1bWJz KTsKIGVycl9zY2hlZHVsZToKIAlpOTE1X3NjaGVkX2VuZ2luZV9wdXQoZW5naW5lLT5zY2hlZF9l bmdpbmUpOwogCXJldHVybiAtRU5PTUVNOwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJtL2k5 MTUvZ3Qvc2VsZnRlc3RfY29udGV4dC5jIGIvZHJpdmVycy9ncHUvZHJtL2k5MTUvZ3Qvc2VsZnRl c3RfY29udGV4dC5jCmluZGV4IDI2Njg1YjkyNzE2OS4uZmE3Yjk5YTY3MWRkIDEwMDY0NAotLS0g YS9kcml2ZXJzL2dwdS9kcm0vaTkxNS9ndC9zZWxmdGVzdF9jb250ZXh0LmMKKysrIGIvZHJpdmVy cy9ncHUvZHJtL2k5MTUvZ3Qvc2VsZnRlc3RfY29udGV4dC5jCkBAIC0yMDksNyArMjA5LDEzIEBA IHN0YXRpYyBpbnQgX19saXZlX2FjdGl2ZV9jb250ZXh0KHN0cnVjdCBpbnRlbF9lbmdpbmVfY3Mg KmVuZ2luZSkKIAkgKiBUaGlzIHRlc3QgbWFrZXMgc3VyZSB0aGF0IHRoZSBjb250ZXh0IGlzIGtl cHQgYWxpdmUgdW50aWwgYQogCSAqIHN1YnNlcXVlbnQgaWRsZS1iYXJyaWVyIChlbWl0dGVkIHdo ZW4gdGhlIGVuZ2luZSB3YWtlcmVmIGhpdHMgMAogCSAqIHdpdGggbm8gbW9yZSBvdXRzdGFuZGlu ZyByZXF1ZXN0cykuCisJICoKKwkgKiBJbiBHdUMgc3VibWlzc2lvbiBtb2RlIHdlIGRvbid0IHVz ZSBpZGxlIGJhcnJpZXJzIGFuZCB3ZSBpbnN0ZWFkCisJICogZ2V0IGEgbWVzc2FnZSBmcm9tIHRo ZSBHdUMgdG8gc2lnbmFsIHRoYXQgaXQgaXMgc2FmZSB0byB1bnBpbiB0aGUKKwkgKiBjb250ZXh0 IGZyb20gbWVtb3J5LgogCSAqLworCWlmIChpbnRlbF9lbmdpbmVfdXNlc19ndWMoZW5naW5lKSkK KwkJcmV0dXJuIDA7CiAKIAlpZiAoaW50ZWxfZW5naW5lX3BtX2lzX2F3YWtlKGVuZ2luZSkpIHsK IAkJcHJfZXJyKCIlcyBpcyBhd2FrZSBiZWZvcmUgc3RhcnRpbmcgJXMhXG4iLApAQCAtMzU3LDcg KzM2MywxMSBAQCBzdGF0aWMgaW50IF9fbGl2ZV9yZW1vdGVfY29udGV4dChzdHJ1Y3QgaW50ZWxf ZW5naW5lX2NzICplbmdpbmUpCiAJICogb24gdGhlIGNvbnRleHQgaW1hZ2UgcmVtb3RlbHkgKGlu dGVsX2NvbnRleHRfcHJlcGFyZV9yZW1vdGVfcmVxdWVzdCksCiAJICogd2hpY2ggaW5zZXJ0cyBm b3JlaWduIGZlbmNlcyBpbnRvIGludGVsX2NvbnRleHQuYWN0aXZlLCBkb2VzIG5vdAogCSAqIGNs b2JiZXIgdGhlIGlkbGUtYmFycmllci4KKwkgKgorCSAqIEluIEd1QyBzdWJtaXNzaW9uIG1vZGUg d2UgZG9uJ3QgdXNlIGlkbGUgYmFycmllcnMuCiAJICovCisJaWYgKGludGVsX2VuZ2luZV91c2Vz X2d1YyhlbmdpbmUpKQorCQlyZXR1cm4gMDsKIAogCWlmIChpbnRlbF9lbmdpbmVfcG1faXNfYXdh a2UoZW5naW5lKSkgewogCQlwcl9lcnIoIiVzIGlzIGF3YWtlIGJlZm9yZSBzdGFydGluZyAlcyFc biIsCmRpZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9kcm0vaTkxNS9ndC9zZWxmdGVzdF9lbmdpbmVf aGVhcnRiZWF0LmMgYi9kcml2ZXJzL2dwdS9kcm0vaTkxNS9ndC9zZWxmdGVzdF9lbmdpbmVfaGVh cnRiZWF0LmMKaW5kZXggNDg5NmU0Y2NhZDUwLi4zMTdlZWJmMDg2YzMgMTAwNjQ0Ci0tLSBhL2Ry aXZlcnMvZ3B1L2RybS9pOTE1L2d0L3NlbGZ0ZXN0X2VuZ2luZV9oZWFydGJlYXQuYworKysgYi9k cml2ZXJzL2dwdS9kcm0vaTkxNS9ndC9zZWxmdGVzdF9lbmdpbmVfaGVhcnRiZWF0LmMKQEAgLTQw NSwzICs0MDUsMjUgQEAgdm9pZCBzdF9lbmdpbmVfaGVhcnRiZWF0X2VuYWJsZShzdHJ1Y3QgaW50 ZWxfZW5naW5lX2NzICplbmdpbmUpCiAJZW5naW5lLT5wcm9wcy5oZWFydGJlYXRfaW50ZXJ2YWxf bXMgPQogCQllbmdpbmUtPmRlZmF1bHRzLmhlYXJ0YmVhdF9pbnRlcnZhbF9tczsKIH0KKwordm9p ZCBzdF9lbmdpbmVfaGVhcnRiZWF0X2Rpc2FibGVfbm9fcG0oc3RydWN0IGludGVsX2VuZ2luZV9j cyAqZW5naW5lKQoreworCWVuZ2luZS0+cHJvcHMuaGVhcnRiZWF0X2ludGVydmFsX21zID0gMDsK KworCS8qCisJICogUGFyayB0aGUgaGVhcnRiZWF0IGJ1dCB3aXRob3V0IGhvbGRpbmcgdGhlIFBN IGxvY2sgYXMgdGhhdAorCSAqIG1ha2VzIHRoZSBlbmdpbmVzIGFwcGVhciBub3QtaWRsZS4gTm90 ZSB0aGF0IGlmL3doZW4gdW5wYXJrCisJICogaXMgY2FsbGVkIGR1ZSB0byB0aGUgUE0gbG9jayBi ZWluZyBhY3F1aXJlZCBsYXRlciB0aGUKKwkgKiBoZWFydGJlYXQgc3RpbGwgd29uJ3QgYmUgZW5h YmxlZCBiZWNhdXNlIG9mIHRoZSBhYm92ZSA9IDAuCisJICovCisJaWYgKGludGVsX2VuZ2luZV9w bV9nZXRfaWZfYXdha2UoZW5naW5lKSkgeworCQlpbnRlbF9lbmdpbmVfcGFya19oZWFydGJlYXQo ZW5naW5lKTsKKwkJaW50ZWxfZW5naW5lX3BtX3B1dChlbmdpbmUpOworCX0KK30KKwordm9pZCBz dF9lbmdpbmVfaGVhcnRiZWF0X2VuYWJsZV9ub19wbShzdHJ1Y3QgaW50ZWxfZW5naW5lX2NzICpl bmdpbmUpCit7CisJZW5naW5lLT5wcm9wcy5oZWFydGJlYXRfaW50ZXJ2YWxfbXMgPQorCQllbmdp bmUtPmRlZmF1bHRzLmhlYXJ0YmVhdF9pbnRlcnZhbF9tczsKK30KZGlmZiAtLWdpdCBhL2RyaXZl cnMvZ3B1L2RybS9pOTE1L2d0L3NlbGZ0ZXN0X2VuZ2luZV9oZWFydGJlYXQuaCBiL2RyaXZlcnMv Z3B1L2RybS9pOTE1L2d0L3NlbGZ0ZXN0X2VuZ2luZV9oZWFydGJlYXQuaAppbmRleCBjZDI3MTEz ZDU0MDAuLjgxZGEyY2Q4ZTQwNiAxMDA2NDQKLS0tIGEvZHJpdmVycy9ncHUvZHJtL2k5MTUvZ3Qv c2VsZnRlc3RfZW5naW5lX2hlYXJ0YmVhdC5oCisrKyBiL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2d0 L3NlbGZ0ZXN0X2VuZ2luZV9oZWFydGJlYXQuaApAQCAtOSw2ICs5LDggQEAKIHN0cnVjdCBpbnRl bF9lbmdpbmVfY3M7CiAKIHZvaWQgc3RfZW5naW5lX2hlYXJ0YmVhdF9kaXNhYmxlKHN0cnVjdCBp bnRlbF9lbmdpbmVfY3MgKmVuZ2luZSk7Cit2b2lkIHN0X2VuZ2luZV9oZWFydGJlYXRfZGlzYWJs ZV9ub19wbShzdHJ1Y3QgaW50ZWxfZW5naW5lX2NzICplbmdpbmUpOwogdm9pZCBzdF9lbmdpbmVf aGVhcnRiZWF0X2VuYWJsZShzdHJ1Y3QgaW50ZWxfZW5naW5lX2NzICplbmdpbmUpOwordm9pZCBz dF9lbmdpbmVfaGVhcnRiZWF0X2VuYWJsZV9ub19wbShzdHJ1Y3QgaW50ZWxfZW5naW5lX2NzICpl bmdpbmUpOwogCiAjZW5kaWYgLyogU0VMRlRFU1RfRU5HSU5FX0hFQVJUQkVBVF9IICovCmRpZmYg LS1naXQgYS9kcml2ZXJzL2dwdS9kcm0vaTkxNS9ndC9zZWxmdGVzdF9leGVjbGlzdHMuYyBiL2Ry aXZlcnMvZ3B1L2RybS9pOTE1L2d0L3NlbGZ0ZXN0X2V4ZWNsaXN0cy5jCmluZGV4IDczZGRjNmUx NDczMC4uNTljZjhhZmM2ZDZmIDEwMDY0NAotLS0gYS9kcml2ZXJzL2dwdS9kcm0vaTkxNS9ndC9z ZWxmdGVzdF9leGVjbGlzdHMuYworKysgYi9kcml2ZXJzL2dwdS9kcm0vaTkxNS9ndC9zZWxmdGVz dF9leGVjbGlzdHMuYwpAQCAtMzcyNyw3ICszNzI3LDcgQEAgc3RhdGljIGludCBub3BfdmlydHVh bF9lbmdpbmUoc3RydWN0IGludGVsX2d0ICpndCwKIAlHRU1fQlVHX09OKCFuY3R4IHx8IG5jdHgg PiBBUlJBWV9TSVpFKHZlKSk7CiAKIAlmb3IgKG4gPSAwOyBuIDwgbmN0eDsgbisrKSB7Ci0JCXZl W25dID0gaW50ZWxfZXhlY2xpc3RzX2NyZWF0ZV92aXJ0dWFsKHNpYmxpbmdzLCBuc2libGluZyk7 CisJCXZlW25dID0gaW50ZWxfZW5naW5lX2NyZWF0ZV92aXJ0dWFsKHNpYmxpbmdzLCBuc2libGlu Zyk7CiAJCWlmIChJU19FUlIodmVbbl0pKSB7CiAJCQllcnIgPSBQVFJfRVJSKHZlW25dKTsKIAkJ CW5jdHggPSBuOwpAQCAtMzkyMyw3ICszOTIzLDcgQEAgc3RhdGljIGludCBtYXNrX3ZpcnR1YWxf ZW5naW5lKHN0cnVjdCBpbnRlbF9ndCAqZ3QsCiAJICogcmVzdHJpY3QgaXQgdG8gb3VyIGRlc2ly ZWQgZW5naW5lIHdpdGhpbiB0aGUgdmlydHVhbCBlbmdpbmUuCiAJICovCiAKLQl2ZSA9IGludGVs X2V4ZWNsaXN0c19jcmVhdGVfdmlydHVhbChzaWJsaW5ncywgbnNpYmxpbmcpOworCXZlID0gaW50 ZWxfZW5naW5lX2NyZWF0ZV92aXJ0dWFsKHNpYmxpbmdzLCBuc2libGluZyk7CiAJaWYgKElTX0VS Uih2ZSkpIHsKIAkJZXJyID0gUFRSX0VSUih2ZSk7CiAJCWdvdG8gb3V0X2Nsb3NlOwpAQCAtNDA1 NCw3ICs0MDU0LDcgQEAgc3RhdGljIGludCBzbGljZWluX3ZpcnR1YWxfZW5naW5lKHN0cnVjdCBp bnRlbF9ndCAqZ3QsCiAJCWk5MTVfcmVxdWVzdF9hZGQocnEpOwogCX0KIAotCWNlID0gaW50ZWxf ZXhlY2xpc3RzX2NyZWF0ZV92aXJ0dWFsKHNpYmxpbmdzLCBuc2libGluZyk7CisJY2UgPSBpbnRl bF9lbmdpbmVfY3JlYXRlX3ZpcnR1YWwoc2libGluZ3MsIG5zaWJsaW5nKTsKIAlpZiAoSVNfRVJS KGNlKSkgewogCQllcnIgPSBQVFJfRVJSKGNlKTsKIAkJZ290byBvdXQ7CkBAIC00MTA2LDcgKzQx MDYsNyBAQCBzdGF0aWMgaW50IHNsaWNlb3V0X3ZpcnR1YWxfZW5naW5lKHN0cnVjdCBpbnRlbF9n dCAqZ3QsCiAKIAkvKiBYWFggV2UgZG8gbm90IGhhbmRsZSBvdmVyc3Vic2NyaXB0aW9uIGFuZCBm YWlybmVzcyB3aXRoIG5vcm1hbCBycSAqLwogCWZvciAobiA9IDA7IG4gPCBuc2libGluZzsgbisr KSB7Ci0JCWNlID0gaW50ZWxfZXhlY2xpc3RzX2NyZWF0ZV92aXJ0dWFsKHNpYmxpbmdzLCBuc2li bGluZyk7CisJCWNlID0gaW50ZWxfZW5naW5lX2NyZWF0ZV92aXJ0dWFsKHNpYmxpbmdzLCBuc2li bGluZyk7CiAJCWlmIChJU19FUlIoY2UpKSB7CiAJCQllcnIgPSBQVFJfRVJSKGNlKTsKIAkJCWdv dG8gb3V0OwpAQCAtNDIwOCw3ICs0MjA4LDcgQEAgc3RhdGljIGludCBwcmVzZXJ2ZWRfdmlydHVh bF9lbmdpbmUoc3RydWN0IGludGVsX2d0ICpndCwKIAlpZiAoZXJyKQogCQlnb3RvIG91dF9zY3Jh dGNoOwogCi0JdmUgPSBpbnRlbF9leGVjbGlzdHNfY3JlYXRlX3ZpcnR1YWwoc2libGluZ3MsIG5z aWJsaW5nKTsKKwl2ZSA9IGludGVsX2VuZ2luZV9jcmVhdGVfdmlydHVhbChzaWJsaW5ncywgbnNp YmxpbmcpOwogCWlmIChJU19FUlIodmUpKSB7CiAJCWVyciA9IFBUUl9FUlIodmUpOwogCQlnb3Rv IG91dF9zY3JhdGNoOwpAQCAtNDM0OCw3ICs0MzQ4LDcgQEAgc3RhdGljIGludCByZXNldF92aXJ0 dWFsX2VuZ2luZShzdHJ1Y3QgaW50ZWxfZ3QgKmd0LAogCWlmIChpZ3Rfc3Bpbm5lcl9pbml0KCZz cGluLCBndCkpCiAJCXJldHVybiAtRU5PTUVNOwogCi0JdmUgPSBpbnRlbF9leGVjbGlzdHNfY3Jl YXRlX3ZpcnR1YWwoc2libGluZ3MsIG5zaWJsaW5nKTsKKwl2ZSA9IGludGVsX2VuZ2luZV9jcmVh dGVfdmlydHVhbChzaWJsaW5ncywgbnNpYmxpbmcpOwogCWlmIChJU19FUlIodmUpKSB7CiAJCWVy ciA9IFBUUl9FUlIodmUpOwogCQlnb3RvIG91dF9zcGluOwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9n cHUvZHJtL2k5MTUvZ3Qvc2VsZnRlc3RfaGFuZ2NoZWNrLmMgYi9kcml2ZXJzL2dwdS9kcm0vaTkx NS9ndC9zZWxmdGVzdF9oYW5nY2hlY2suYwppbmRleCA3YWVhMTBhYTFmYjQuLmE5M2E5YjBkMjU4 ZSAxMDA2NDQKLS0tIGEvZHJpdmVycy9ncHUvZHJtL2k5MTUvZ3Qvc2VsZnRlc3RfaGFuZ2NoZWNr LmMKKysrIGIvZHJpdmVycy9ncHUvZHJtL2k5MTUvZ3Qvc2VsZnRlc3RfaGFuZ2NoZWNrLmMKQEAg LTE3LDYgKzE3LDggQEAKICNpbmNsdWRlICJzZWxmdGVzdHMvaWd0X2ZsdXNoX3Rlc3QuaCIKICNp bmNsdWRlICJzZWxmdGVzdHMvaWd0X3Jlc2V0LmgiCiAjaW5jbHVkZSAic2VsZnRlc3RzL2lndF9h dG9taWMuaCIKKyNpbmNsdWRlICJzZWxmdGVzdHMvaWd0X3NwaW5uZXIuaCIKKyNpbmNsdWRlICJz ZWxmdGVzdHMvaW50ZWxfc2NoZWR1bGVyX2hlbHBlcnMuaCIKIAogI2luY2x1ZGUgInNlbGZ0ZXN0 cy9tb2NrX2RybS5oIgogCkBAIC0zNzgsNiArMzgwLDcgQEAgc3RhdGljIGludCBpZ3RfcmVzZXRf bm9wKHZvaWQgKmFyZykKIAkJCWNlID0gaW50ZWxfY29udGV4dF9jcmVhdGUoZW5naW5lKTsKIAkJ CWlmIChJU19FUlIoY2UpKSB7CiAJCQkJZXJyID0gUFRSX0VSUihjZSk7CisJCQkJcHJfZXJyKCJb JXNdIENyZWF0ZSBjb250ZXh0IGZhaWxlZDogJWQhXG4iLCBlbmdpbmUtPm5hbWUsIGVycik7CiAJ CQkJYnJlYWs7CiAJCQl9CiAKQEAgLTM4Nyw2ICszOTAsNyBAQCBzdGF0aWMgaW50IGlndF9yZXNl dF9ub3Aodm9pZCAqYXJnKQogCQkJCXJxID0gaW50ZWxfY29udGV4dF9jcmVhdGVfcmVxdWVzdChj ZSk7CiAJCQkJaWYgKElTX0VSUihycSkpIHsKIAkJCQkJZXJyID0gUFRSX0VSUihycSk7CisJCQkJ CXByX2VycigiWyVzXSBDcmVhdGUgcmVxdWVzdCBmYWlsZWQ6ICVkIVxuIiwgZW5naW5lLT5uYW1l LCBlcnIpOwogCQkJCQlicmVhazsKIAkJCQl9CiAKQEAgLTQwMSwyNCArNDA1LDMxIEBAIHN0YXRp YyBpbnQgaWd0X3Jlc2V0X25vcCh2b2lkICphcmcpCiAJCWlndF9nbG9iYWxfcmVzZXRfdW5sb2Nr KGd0KTsKIAogCQlpZiAoaW50ZWxfZ3RfaXNfd2VkZ2VkKGd0KSkgeworCQkJcHJfZXJyKCJbJXNd IEdUIGlzIHdlZGdlZCFcbiIsIGVuZ2luZS0+bmFtZSk7CiAJCQllcnIgPSAtRUlPOwogCQkJYnJl YWs7CiAJCX0KIAogCQlpZiAoaTkxNV9yZXNldF9jb3VudChnbG9iYWwpICE9IHJlc2V0X2NvdW50 ICsgKytjb3VudCkgewotCQkJcHJfZXJyKCJGdWxsIEdQVSByZXNldCBub3QgcmVjb3JkZWQhXG4i KTsKKwkJCXByX2VycigiWyVzXSBSZXNldCBub3QgcmVjb3JkZWQ6ICVkIHZzICVkICsgJWQhXG4i LAorCQkJICAgICAgIGVuZ2luZS0+bmFtZSwgaTkxNV9yZXNldF9jb3VudChnbG9iYWwpLCByZXNl dF9jb3VudCwgY291bnQpOwogCQkJZXJyID0gLUVJTlZBTDsKIAkJCWJyZWFrOwogCQl9CiAKIAkJ ZXJyID0gaWd0X2ZsdXNoX3Rlc3QoZ3QtPmk5MTUpOwotCQlpZiAoZXJyKQorCQlpZiAoZXJyKSB7 CisJCQlwcl9lcnIoIlslc10gRmx1c2ggZmFpbGVkOiAlZCFcbiIsIGVuZ2luZS0+bmFtZSwgZXJy KTsKIAkJCWJyZWFrOworCQl9CiAJfSB3aGlsZSAodGltZV9iZWZvcmUoamlmZmllcywgZW5kX3Rp bWUpKTsKIAlwcl9pbmZvKCIlczogJWQgcmVzZXRzXG4iLCBfX2Z1bmNfXywgY291bnQpOwogCi0J aWYgKGlndF9mbHVzaF90ZXN0KGd0LT5pOTE1KSkKKwlpZiAoaWd0X2ZsdXNoX3Rlc3QoZ3QtPmk5 MTUpKSB7CisJCXByX2VycigiUG9zdCBmbHVzaCBmYWlsZWQ6ICVkIVxuIiwgZXJyKTsKIAkJZXJy ID0gLUVJTzsKKwl9CisKIAlyZXR1cm4gZXJyOwogfQogCkBAIC00NDAsOSArNDUxLDE5IEBAIHN0 YXRpYyBpbnQgaWd0X3Jlc2V0X25vcF9lbmdpbmUodm9pZCAqYXJnKQogCQlJR1RfVElNRU9VVChl bmRfdGltZSk7CiAJCWludCBlcnI7CiAKKwkJaWYgKGludGVsX2VuZ2luZV91c2VzX2d1Yyhlbmdp bmUpKSB7CisJCQkvKiBFbmdpbmUgbGV2ZWwgcmVzZXRzIGFyZSB0cmlnZ2VyZWQgYnkgR3VDIHdo ZW4gYSBoYW5nCisJCQkgKiBpcyBkZXRlY3RlZC4gVGhleSBjYW4ndCBiZSB0cmlnZ2VyZWQgYnkg dGhlIEtNRCBhbnkKKwkJCSAqIG1vcmUuIFRodXMgYSBub3AgYmF0Y2ggY2Fubm90IGJlIHVzZWQg YXMgYSByZXNldCB0ZXN0CisJCQkgKi8KKwkJCWNvbnRpbnVlOworCQl9CisKIAkJY2UgPSBpbnRl bF9jb250ZXh0X2NyZWF0ZShlbmdpbmUpOwotCQlpZiAoSVNfRVJSKGNlKSkKKwkJaWYgKElTX0VS UihjZSkpIHsKKwkJCXByX2VycigiWyVzXSBDcmVhdGUgY29udGV4dCBmYWlsZWQ6ICVkIVxuIiwg ZW5naW5lLT5uYW1lLCBlcnIpOwogCQkJcmV0dXJuIFBUUl9FUlIoY2UpOworCQl9CiAKIAkJcmVz ZXRfY291bnQgPSBpOTE1X3Jlc2V0X2NvdW50KGdsb2JhbCk7CiAJCXJlc2V0X2VuZ2luZV9jb3Vu dCA9IGk5MTVfcmVzZXRfZW5naW5lX2NvdW50KGdsb2JhbCwgZW5naW5lKTsKQEAgLTU0OSw5ICs1 NzAsMTUgQEAgc3RhdGljIGludCBpZ3RfcmVzZXRfZmFpbF9lbmdpbmUodm9pZCAqYXJnKQogCQlJ R1RfVElNRU9VVChlbmRfdGltZSk7CiAJCWludCBlcnI7CiAKKwkJLyogQ2FuJ3QgbWFudWFsbHkg YnJlYWsgdGhlIHJlc2V0IGlmIGk5MTUgZG9lc24ndCBwZXJmb3JtIGl0ICovCisJCWlmIChpbnRl bF9lbmdpbmVfdXNlc19ndWMoZW5naW5lKSkKKwkJCWNvbnRpbnVlOworCiAJCWNlID0gaW50ZWxf Y29udGV4dF9jcmVhdGUoZW5naW5lKTsKLQkJaWYgKElTX0VSUihjZSkpCisJCWlmIChJU19FUlIo Y2UpKSB7CisJCQlwcl9lcnIoIlslc10gQ3JlYXRlIGNvbnRleHQgZmFpbGVkOiAlZCFcbiIsIGVu Z2luZS0+bmFtZSwgZXJyKTsKIAkJCXJldHVybiBQVFJfRVJSKGNlKTsKKwkJfQogCiAJCXN0X2Vu Z2luZV9oZWFydGJlYXRfZGlzYWJsZShlbmdpbmUpOwogCQlzZXRfYml0KEk5MTVfUkVTRVRfRU5H SU5FICsgaWQsICZndC0+cmVzZXQuZmxhZ3MpOwpAQCAtNjg2LDggKzcxMywxMiBAQCBzdGF0aWMg aW50IF9faWd0X3Jlc2V0X2VuZ2luZShzdHJ1Y3QgaW50ZWxfZ3QgKmd0LCBib29sIGFjdGl2ZSkK IAlmb3JfZWFjaF9lbmdpbmUoZW5naW5lLCBndCwgaWQpIHsKIAkJdW5zaWduZWQgaW50IHJlc2V0 X2NvdW50LCByZXNldF9lbmdpbmVfY291bnQ7CiAJCXVuc2lnbmVkIGxvbmcgY291bnQ7CisJCWJv b2wgdXNpbmdfZ3VjID0gaW50ZWxfZW5naW5lX3VzZXNfZ3VjKGVuZ2luZSk7CiAJCUlHVF9USU1F T1VUKGVuZF90aW1lKTsKIAorCQlpZiAodXNpbmdfZ3VjICYmICFhY3RpdmUpCisJCQljb250aW51 ZTsKKwogCQlpZiAoYWN0aXZlICYmICFpbnRlbF9lbmdpbmVfY2FuX3N0b3JlX2R3b3JkKGVuZ2lu ZSkpCiAJCQljb250aW51ZTsKIApAQCAtNzA1LDEzICs3MzYsMjMgQEAgc3RhdGljIGludCBfX2ln dF9yZXNldF9lbmdpbmUoc3RydWN0IGludGVsX2d0ICpndCwgYm9vbCBhY3RpdmUpCiAJCXNldF9i aXQoSTkxNV9SRVNFVF9FTkdJTkUgKyBpZCwgJmd0LT5yZXNldC5mbGFncyk7CiAJCWNvdW50ID0g MDsKIAkJZG8gewotCQkJaWYgKGFjdGl2ZSkgewotCQkJCXN0cnVjdCBpOTE1X3JlcXVlc3QgKnJx OworCQkJc3RydWN0IGk5MTVfcmVxdWVzdCAqcnEgPSBOVUxMOworCQkJc3RydWN0IGludGVsX3Nl bGZ0ZXN0X3NhdmVkX3BvbGljeSBzYXZlZDsKKwkJCWludCBlcnIyOworCisJCQllcnIgPSBpbnRl bF9zZWxmdGVzdF9tb2RpZnlfcG9saWN5KGVuZ2luZSwgJnNhdmVkLAorCQkJCQkJCSAgIFNFTEZU RVNUX1NDSEVEVUxFUl9NT0RJRllfRkFTVF9SRVNFVCk7CisJCQlpZiAoZXJyKSB7CisJCQkJcHJf ZXJyKCJbJXNdIE1vZGlmeSBwb2xpY3kgZmFpbGVkOiAlZCFcbiIsIGVuZ2luZS0+bmFtZSwgZXJy KTsKKwkJCQlicmVhazsKKwkJCX0KIAorCQkJaWYgKGFjdGl2ZSkgewogCQkJCXJxID0gaGFuZ19j cmVhdGVfcmVxdWVzdCgmaCwgZW5naW5lKTsKIAkJCQlpZiAoSVNfRVJSKHJxKSkgewogCQkJCQll cnIgPSBQVFJfRVJSKHJxKTsKLQkJCQkJYnJlYWs7CisJCQkJCXByX2VycigiWyVzXSBDcmVhdGUg aGFuZyByZXF1ZXN0IGZhaWxlZDogJWQhXG4iLCBlbmdpbmUtPm5hbWUsIGVycik7CisJCQkJCWdv dG8gcmVzdG9yZTsKIAkJCQl9CiAKIAkJCQlpOTE1X3JlcXVlc3RfZ2V0KHJxKTsKQEAgLTcyNywz NCArNzY4LDU4IEBAIHN0YXRpYyBpbnQgX19pZ3RfcmVzZXRfZW5naW5lKHN0cnVjdCBpbnRlbF9n dCAqZ3QsIGJvb2wgYWN0aXZlKQogCiAJCQkJCWk5MTVfcmVxdWVzdF9wdXQocnEpOwogCQkJCQll cnIgPSAtRUlPOwotCQkJCQlicmVhazsKKwkJCQkJZ290byByZXN0b3JlOwogCQkJCX0KKwkJCX0K IAotCQkJCWk5MTVfcmVxdWVzdF9wdXQocnEpOworCQkJaWYgKCF1c2luZ19ndWMpIHsKKwkJCQll cnIgPSBpbnRlbF9lbmdpbmVfcmVzZXQoZW5naW5lLCBOVUxMKTsKKwkJCQlpZiAoZXJyKSB7CisJ CQkJCXByX2VycigiaW50ZWxfZW5naW5lX3Jlc2V0KCVzKSBmYWlsZWQsIGVycjolZFxuIiwKKwkJ CQkJICAgICAgIGVuZ2luZS0+bmFtZSwgZXJyKTsKKwkJCQkJZ290byBza2lwOworCQkJCX0KIAkJ CX0KIAotCQkJZXJyID0gaW50ZWxfZW5naW5lX3Jlc2V0KGVuZ2luZSwgTlVMTCk7Ci0JCQlpZiAo ZXJyKSB7Ci0JCQkJcHJfZXJyKCJpbnRlbF9lbmdpbmVfcmVzZXQoJXMpIGZhaWxlZCwgZXJyOiVk XG4iLAotCQkJCSAgICAgICBlbmdpbmUtPm5hbWUsIGVycik7Ci0JCQkJYnJlYWs7CisJCQlpZiAo cnEpIHsKKwkJCQkvKiBFbnN1cmUgdGhlIHJlc2V0IGhhcHBlbnMgYW5kIGtpbGxzIHRoZSBlbmdp bmUgKi8KKwkJCQllcnIgPSBpbnRlbF9zZWxmdGVzdF93YWl0X2Zvcl9ycShycSk7CisJCQkJaWYg KGVycikKKwkJCQkJcHJfZXJyKCJbJXNdIFdhaXQgZm9yIHJlcXVlc3QgJWxsZDolbGxkIFsweCUw NFhdIGZhaWxlZDogJWQhXG4iLAorCQkJCQkgICAgICAgZW5naW5lLT5uYW1lLCBycS0+ZmVuY2Uu Y29udGV4dCwgcnEtPmZlbmNlLnNlcW5vLCBycS0+Y29udGV4dC0+Z3VjX2lkLCBlcnIpOwogCQkJ fQogCitza2lwOgorCQkJaWYgKHJxKQorCQkJCWk5MTVfcmVxdWVzdF9wdXQocnEpOworCiAJCQlp ZiAoaTkxNV9yZXNldF9jb3VudChnbG9iYWwpICE9IHJlc2V0X2NvdW50KSB7CiAJCQkJcHJfZXJy KCJGdWxsIEdQVSByZXNldCByZWNvcmRlZCEgKGVuZ2luZSByZXNldCBleHBlY3RlZClcbiIpOwog CQkJCWVyciA9IC1FSU5WQUw7Ci0JCQkJYnJlYWs7CisJCQkJZ290byByZXN0b3JlOwogCQkJfQog Ci0JCQlpZiAoaTkxNV9yZXNldF9lbmdpbmVfY291bnQoZ2xvYmFsLCBlbmdpbmUpICE9Ci0JCQkg ICAgKytyZXNldF9lbmdpbmVfY291bnQpIHsKLQkJCQlwcl9lcnIoIiVzIGVuZ2luZSByZXNldCBu b3QgcmVjb3JkZWQhXG4iLAotCQkJCSAgICAgICBlbmdpbmUtPm5hbWUpOwotCQkJCWVyciA9IC1F SU5WQUw7Ci0JCQkJYnJlYWs7CisJCQkvKiBHdUMgYmFzZWQgcmVzZXRzIGFyZSBub3QgbG9nZ2Vk IHBlciBlbmdpbmUgKi8KKwkJCWlmICghdXNpbmdfZ3VjKSB7CisJCQkJaWYgKGk5MTVfcmVzZXRf ZW5naW5lX2NvdW50KGdsb2JhbCwgZW5naW5lKSAhPQorCQkJCSAgICArK3Jlc2V0X2VuZ2luZV9j b3VudCkgeworCQkJCQlwcl9lcnIoIiVzIGVuZ2luZSByZXNldCBub3QgcmVjb3JkZWQhXG4iLAor CQkJCQkgICAgICAgZW5naW5lLT5uYW1lKTsKKwkJCQkJZXJyID0gLUVJTlZBTDsKKwkJCQkJZ290 byByZXN0b3JlOworCQkJCX0KIAkJCX0KIAogCQkJY291bnQrKzsKKworcmVzdG9yZToKKwkJCWVy cjIgPSBpbnRlbF9zZWxmdGVzdF9yZXN0b3JlX3BvbGljeShlbmdpbmUsICZzYXZlZCk7CisJCQlp ZiAoZXJyMikKKwkJCQlwcl9lcnIoIlslc10gUmVzdG9yZSBwb2xpY3kgZmFpbGVkOiAlZCFcbiIs IGVuZ2luZS0+bmFtZSwgZXJyKTsKKwkJCWlmIChlcnIgPT0gMCkKKwkJCQllcnIgPSBlcnIyOwor CQkJaWYgKGVycikKKwkJCQlicmVhazsKIAkJfSB3aGlsZSAodGltZV9iZWZvcmUoamlmZmllcywg ZW5kX3RpbWUpKTsKIAkJY2xlYXJfYml0KEk5MTVfUkVTRVRfRU5HSU5FICsgaWQsICZndC0+cmVz ZXQuZmxhZ3MpOwogCQlzdF9lbmdpbmVfaGVhcnRiZWF0X2VuYWJsZShlbmdpbmUpOwpAQCAtNzY1 LDEyICs4MzAsMTYgQEAgc3RhdGljIGludCBfX2lndF9yZXNldF9lbmdpbmUoc3RydWN0IGludGVs X2d0ICpndCwgYm9vbCBhY3RpdmUpCiAJCQlicmVhazsKIAogCQllcnIgPSBpZ3RfZmx1c2hfdGVz dChndC0+aTkxNSk7Ci0JCWlmIChlcnIpCisJCWlmIChlcnIpIHsKKwkJCXByX2VycigiWyVzXSBG bHVzaCBmYWlsZWQ6ICVkIVxuIiwgZW5naW5lLT5uYW1lLCBlcnIpOwogCQkJYnJlYWs7CisJCX0K IAl9CiAKLQlpZiAoaW50ZWxfZ3RfaXNfd2VkZ2VkKGd0KSkKKwlpZiAoaW50ZWxfZ3RfaXNfd2Vk Z2VkKGd0KSkgeworCQlwcl9lcnIoIkdUIGlzIHdlZGdlZCFcbiIpOwogCQllcnIgPSAtRUlPOwor CX0KIAogCWlmIChhY3RpdmUpCiAJCWhhbmdfZmluaSgmaCk7CkBAIC04MDcsNyArODc2LDcgQEAg c3RhdGljIGludCBhY3RpdmVfcmVxdWVzdF9wdXQoc3RydWN0IGk5MTVfcmVxdWVzdCAqcnEpCiAJ aWYgKCFycSkKIAkJcmV0dXJuIDA7CiAKLQlpZiAoaTkxNV9yZXF1ZXN0X3dhaXQocnEsIDAsIDUg KiBIWikgPCAwKSB7CisJaWYgKGk5MTVfcmVxdWVzdF93YWl0KHJxLCAwLCAxMCAqIEhaKSA8IDAp IHsKIAkJR0VNX1RSQUNFKCIlcyB0aW1lZCBvdXQgd2FpdGluZyBmb3IgY29tcGxldGlvbiBvZiBm ZW5jZSAlbGx4OiVsbGRcbiIsCiAJCQkgIHJxLT5lbmdpbmUtPm5hbWUsCiAJCQkgIHJxLT5mZW5j ZS5jb250ZXh0LApAQCAtODM3LDYgKzkwNiw3IEBAIHN0YXRpYyBpbnQgYWN0aXZlX2VuZ2luZSh2 b2lkICpkYXRhKQogCQljZVtjb3VudF0gPSBpbnRlbF9jb250ZXh0X2NyZWF0ZShlbmdpbmUpOwog CQlpZiAoSVNfRVJSKGNlW2NvdW50XSkpIHsKIAkJCWVyciA9IFBUUl9FUlIoY2VbY291bnRdKTsK KwkJCXByX2VycigiWyVzXSBDcmVhdGUgY29udGV4dCAjJWxkIGZhaWxlZDogJWQhXG4iLCBlbmdp bmUtPm5hbWUsIGNvdW50LCBlcnIpOwogCQkJd2hpbGUgKC0tY291bnQpCiAJCQkJaW50ZWxfY29u dGV4dF9wdXQoY2VbY291bnRdKTsKIAkJCXJldHVybiBlcnI7CkBAIC04NTIsNiArOTIyLDcgQEAg c3RhdGljIGludCBhY3RpdmVfZW5naW5lKHZvaWQgKmRhdGEpCiAJCW5ldyA9IGludGVsX2NvbnRl eHRfY3JlYXRlX3JlcXVlc3QoY2VbaWR4XSk7CiAJCWlmIChJU19FUlIobmV3KSkgewogCQkJZXJy ID0gUFRSX0VSUihuZXcpOworCQkJcHJfZXJyKCJbJXNdIENyZWF0ZSByZXF1ZXN0ICMlZCBmYWls ZWQ6ICVkIVxuIiwgZW5naW5lLT5uYW1lLCBpZHgsIGVycik7CiAJCQlicmVhazsKIAkJfQogCkBA IC04NjcsOCArOTM4LDEwIEBAIHN0YXRpYyBpbnQgYWN0aXZlX2VuZ2luZSh2b2lkICpkYXRhKQog CQl9CiAKIAkJZXJyID0gYWN0aXZlX3JlcXVlc3RfcHV0KG9sZCk7Ci0JCWlmIChlcnIpCisJCWlm IChlcnIpIHsKKwkJCXByX2VycigiWyVzXSBSZXF1ZXN0IHB1dCBmYWlsZWQ6ICVkIVxuIiwgZW5n aW5lLT5uYW1lLCBlcnIpOwogCQkJYnJlYWs7CisJCX0KIAogCQljb25kX3Jlc2NoZWQoKTsKIAl9 CkBAIC04NzYsNiArOTQ5LDkgQEAgc3RhdGljIGludCBhY3RpdmVfZW5naW5lKHZvaWQgKmRhdGEp CiAJZm9yIChjb3VudCA9IDA7IGNvdW50IDwgQVJSQVlfU0laRShycSk7IGNvdW50KyspIHsKIAkJ aW50IGVycl9fID0gYWN0aXZlX3JlcXVlc3RfcHV0KHJxW2NvdW50XSk7CiAKKwkJaWYgKGVycikK KwkJCXByX2VycigiWyVzXSBSZXF1ZXN0IHB1dCAjJWxkIGZhaWxlZDogJWQhXG4iLCBlbmdpbmUt Pm5hbWUsIGNvdW50LCBlcnIpOworCiAJCS8qIEtlZXAgdGhlIGZpcnN0IGVycm9yICovCiAJCWlm ICghZXJyKQogCQkJZXJyID0gZXJyX187CkBAIC05MTYsMTAgKzk5MiwxMyBAQCBzdGF0aWMgaW50 IF9faWd0X3Jlc2V0X2VuZ2luZXMoc3RydWN0IGludGVsX2d0ICpndCwKIAkJc3RydWN0IGFjdGl2 ZV9lbmdpbmUgdGhyZWFkc1tJOTE1X05VTV9FTkdJTkVTXSA9IHt9OwogCQl1bnNpZ25lZCBsb25n IGRldmljZSA9IGk5MTVfcmVzZXRfY291bnQoZ2xvYmFsKTsKIAkJdW5zaWduZWQgbG9uZyBjb3Vu dCA9IDAsIHJlcG9ydGVkOworCQlib29sIHVzaW5nX2d1YyA9IGludGVsX2VuZ2luZV91c2VzX2d1 YyhlbmdpbmUpOwogCQlJR1RfVElNRU9VVChlbmRfdGltZSk7CiAKLQkJaWYgKGZsYWdzICYgVEVT VF9BQ1RJVkUgJiYKLQkJICAgICFpbnRlbF9lbmdpbmVfY2FuX3N0b3JlX2R3b3JkKGVuZ2luZSkp CisJCWlmIChmbGFncyAmIFRFU1RfQUNUSVZFKSB7CisJCQlpZiAoIWludGVsX2VuZ2luZV9jYW5f c3RvcmVfZHdvcmQoZW5naW5lKSkKKwkJCQljb250aW51ZTsKKwkJfSBlbHNlIGlmICh1c2luZ19n dWMpCiAJCQljb250aW51ZTsKIAogCQlpZiAoIXdhaXRfZm9yX2lkbGUoZW5naW5lKSkgewpAQCAt OTQ5LDYgKzEwMjgsNyBAQCBzdGF0aWMgaW50IF9faWd0X3Jlc2V0X2VuZ2luZXMoc3RydWN0IGlu dGVsX2d0ICpndCwKIAkJCQkJICAiaWd0LyVzIiwgb3RoZXItPm5hbWUpOwogCQkJaWYgKElTX0VS Uih0c2spKSB7CiAJCQkJZXJyID0gUFRSX0VSUih0c2spOworCQkJCXByX2VycigiWyVzXSBUaHJl YWQgc3Bhd24gZmFpbGVkOiAlZCFcbiIsIGVuZ2luZS0+bmFtZSwgZXJyKTsKIAkJCQlnb3RvIHVu d2luZDsKIAkJCX0KIApAQCAtOTU4LDE2ICsxMDM4LDI2IEBAIHN0YXRpYyBpbnQgX19pZ3RfcmVz ZXRfZW5naW5lcyhzdHJ1Y3QgaW50ZWxfZ3QgKmd0LAogCiAJCXlpZWxkKCk7IC8qIHN0YXJ0IGFs bCB0aHJlYWRzIGJlZm9yZSB3ZSBiZWdpbiAqLwogCi0JCXN0X2VuZ2luZV9oZWFydGJlYXRfZGlz YWJsZShlbmdpbmUpOworCQlzdF9lbmdpbmVfaGVhcnRiZWF0X2Rpc2FibGVfbm9fcG0oZW5naW5l KTsKIAkJc2V0X2JpdChJOTE1X1JFU0VUX0VOR0lORSArIGlkLCAmZ3QtPnJlc2V0LmZsYWdzKTsK IAkJZG8gewogCQkJc3RydWN0IGk5MTVfcmVxdWVzdCAqcnEgPSBOVUxMOworCQkJc3RydWN0IGlu dGVsX3NlbGZ0ZXN0X3NhdmVkX3BvbGljeSBzYXZlZDsKKwkJCWludCBlcnIyOworCisJCQllcnIg PSBpbnRlbF9zZWxmdGVzdF9tb2RpZnlfcG9saWN5KGVuZ2luZSwgJnNhdmVkLAorCQkJCQkJCSAg U0VMRlRFU1RfU0NIRURVTEVSX01PRElGWV9GQVNUX1JFU0VUKTsKKwkJCWlmIChlcnIpIHsKKwkJ CQlwcl9lcnIoIlslc10gTW9kaWZ5IHBvbGljeSBmYWlsZWQ6ICVkIVxuIiwgZW5naW5lLT5uYW1l LCBlcnIpOworCQkJCWJyZWFrOworCQkJfQogCiAJCQlpZiAoZmxhZ3MgJiBURVNUX0FDVElWRSkg ewogCQkJCXJxID0gaGFuZ19jcmVhdGVfcmVxdWVzdCgmaCwgZW5naW5lKTsKIAkJCQlpZiAoSVNf RVJSKHJxKSkgewogCQkJCQllcnIgPSBQVFJfRVJSKHJxKTsKLQkJCQkJYnJlYWs7CisJCQkJCXBy X2VycigiWyVzXSBDcmVhdGUgaGFuZyByZXF1ZXN0IGZhaWxlZDogJWQhXG4iLCBlbmdpbmUtPm5h bWUsIGVycik7CisJCQkJCWdvdG8gcmVzdG9yZTsKIAkJCQl9CiAKIAkJCQlpOTE1X3JlcXVlc3Rf Z2V0KHJxKTsKQEAgLTk4MywxNSArMTA3MywyNyBAQCBzdGF0aWMgaW50IF9faWd0X3Jlc2V0X2Vu Z2luZXMoc3RydWN0IGludGVsX2d0ICpndCwKIAogCQkJCQlpOTE1X3JlcXVlc3RfcHV0KHJxKTsK IAkJCQkJZXJyID0gLUVJTzsKLQkJCQkJYnJlYWs7CisJCQkJCWdvdG8gcmVzdG9yZTsKIAkJCQl9 CisJCQl9IGVsc2UgeworCQkJCWludGVsX2VuZ2luZV9wbV9nZXQoZW5naW5lKTsKIAkJCX0KIAot CQkJZXJyID0gaW50ZWxfZW5naW5lX3Jlc2V0KGVuZ2luZSwgTlVMTCk7Ci0JCQlpZiAoZXJyKSB7 Ci0JCQkJcHJfZXJyKCJpOTE1X3Jlc2V0X2VuZ2luZSglczolcyk6IGZhaWxlZCwgZXJyPSVkXG4i LAotCQkJCSAgICAgICBlbmdpbmUtPm5hbWUsIHRlc3RfbmFtZSwgZXJyKTsKLQkJCQlicmVhazsK KwkJCWlmICghdXNpbmdfZ3VjKSB7CisJCQkJZXJyID0gaW50ZWxfZW5naW5lX3Jlc2V0KGVuZ2lu ZSwgTlVMTCk7CisJCQkJaWYgKGVycikgeworCQkJCQlwcl9lcnIoImk5MTVfcmVzZXRfZW5naW5l KCVzOiVzKTogZmFpbGVkLCBlcnI9JWRcbiIsCisJCQkJCSAgICAgICBlbmdpbmUtPm5hbWUsIHRl c3RfbmFtZSwgZXJyKTsKKwkJCQkJZ290byByZXN0b3JlOworCQkJCX0KKwkJCX0KKworCQkJaWYg KHJxKSB7CisJCQkJLyogRW5zdXJlIHRoZSByZXNldCBoYXBwZW5zIGFuZCBraWxscyB0aGUgZW5n aW5lICovCisJCQkJZXJyID0gaW50ZWxfc2VsZnRlc3Rfd2FpdF9mb3JfcnEocnEpOworCQkJCWlm IChlcnIpCisJCQkJCXByX2VycigiWyVzXSBXYWl0IGZvciByZXF1ZXN0ICVsbGQ6JWxsZCBbMHgl MDRYXSBmYWlsZWQ6ICVkIVxuIiwKKwkJCQkJICAgICAgIGVuZ2luZS0+bmFtZSwgcnEtPmZlbmNl LmNvbnRleHQsIHJxLT5mZW5jZS5zZXFubywgcnEtPmNvbnRleHQtPmd1Y19pZCwgZXJyKTsKIAkJ CX0KIAogCQkJY291bnQrKzsKQEAgLTk5OSwxNiArMTEwMSwxNiBAQCBzdGF0aWMgaW50IF9faWd0 X3Jlc2V0X2VuZ2luZXMoc3RydWN0IGludGVsX2d0ICpndCwKIAkJCWlmIChycSkgewogCQkJCWlm IChycS0+ZmVuY2UuZXJyb3IgIT0gLUVJTykgewogCQkJCQlwcl9lcnIoImk5MTVfcmVzZXRfZW5n aW5lKCVzOiVzKToiCi0JCQkJCSAgICAgICAiIGZhaWxlZCB0byByZXNldCByZXF1ZXN0ICVsbHg6 JWxsZFxuIiwKKwkJCQkJICAgICAgICIgZmFpbGVkIHRvIHJlc2V0IHJlcXVlc3QgJWxsZDolbGxk IFsweCUwNFhdXG4iLAogCQkJCQkgICAgICAgZW5naW5lLT5uYW1lLCB0ZXN0X25hbWUsCiAJCQkJ CSAgICAgICBycS0+ZmVuY2UuY29udGV4dCwKLQkJCQkJICAgICAgIHJxLT5mZW5jZS5zZXFubyk7 CisJCQkJCSAgICAgICBycS0+ZmVuY2Uuc2Vxbm8sIHJxLT5jb250ZXh0LT5ndWNfaWQpOwogCQkJ CQlpOTE1X3JlcXVlc3RfcHV0KHJxKTsKIAogCQkJCQlHRU1fVFJBQ0VfRFVNUCgpOwogCQkJCQlp bnRlbF9ndF9zZXRfd2VkZ2VkKGd0KTsKIAkJCQkJZXJyID0gLUVJTzsKLQkJCQkJYnJlYWs7CisJ CQkJCWdvdG8gcmVzdG9yZTsKIAkJCQl9CiAKIAkJCQlpZiAoaTkxNV9yZXF1ZXN0X3dhaXQocnEs IDAsIEhaIC8gNSkgPCAwKSB7CkBAIC0xMDI3LDEyICsxMTI5LDE1IEBAIHN0YXRpYyBpbnQgX19p Z3RfcmVzZXRfZW5naW5lcyhzdHJ1Y3QgaW50ZWxfZ3QgKmd0LAogCQkJCQlHRU1fVFJBQ0VfRFVN UCgpOwogCQkJCQlpbnRlbF9ndF9zZXRfd2VkZ2VkKGd0KTsKIAkJCQkJZXJyID0gLUVJTzsKLQkJ CQkJYnJlYWs7CisJCQkJCWdvdG8gcmVzdG9yZTsKIAkJCQl9CiAKIAkJCQlpOTE1X3JlcXVlc3Rf cHV0KHJxKTsKIAkJCX0KIAorCQkJaWYgKCEoZmxhZ3MgJiBURVNUX0FDVElWRSkpCisJCQkJaW50 ZWxfZW5naW5lX3BtX3B1dChlbmdpbmUpOworCiAJCQlpZiAoIShmbGFncyAmIFRFU1RfU0VMRikg JiYgIXdhaXRfZm9yX2lkbGUoZW5naW5lKSkgewogCQkJCXN0cnVjdCBkcm1fcHJpbnRlciBwID0K IAkJCQkJZHJtX2luZm9fcHJpbnRlcihndC0+aTkxNS0+ZHJtLmRldik7CkBAIC0xMDQ0LDIyICsx MTQ5LDM0IEBAIHN0YXRpYyBpbnQgX19pZ3RfcmVzZXRfZW5naW5lcyhzdHJ1Y3QgaW50ZWxfZ3Qg Kmd0LAogCQkJCQkJICAiJXNcbiIsIGVuZ2luZS0+bmFtZSk7CiAKIAkJCQllcnIgPSAtRUlPOwot CQkJCWJyZWFrOworCQkJCWdvdG8gcmVzdG9yZTsKIAkJCX0KKworcmVzdG9yZToKKwkJCWVycjIg PSBpbnRlbF9zZWxmdGVzdF9yZXN0b3JlX3BvbGljeShlbmdpbmUsICZzYXZlZCk7CisJCQlpZiAo ZXJyMikKKwkJCQlwcl9lcnIoIlslc10gUmVzdG9yZSBwb2xpY3kgZmFpbGVkOiAlZCFcbiIsIGVu Z2luZS0+bmFtZSwgZXJyMik7CisJCQlpZiAoZXJyID09IDApCisJCQkJZXJyID0gZXJyMjsKKwkJ CWlmIChlcnIpCisJCQkJYnJlYWs7CiAJCX0gd2hpbGUgKHRpbWVfYmVmb3JlKGppZmZpZXMsIGVu ZF90aW1lKSk7CiAJCWNsZWFyX2JpdChJOTE1X1JFU0VUX0VOR0lORSArIGlkLCAmZ3QtPnJlc2V0 LmZsYWdzKTsKLQkJc3RfZW5naW5lX2hlYXJ0YmVhdF9lbmFibGUoZW5naW5lKTsKKwkJc3RfZW5n aW5lX2hlYXJ0YmVhdF9lbmFibGVfbm9fcG0oZW5naW5lKTsKIAogCQlwcl9pbmZvKCJpOTE1X3Jl c2V0X2VuZ2luZSglczolcyk6ICVsdSByZXNldHNcbiIsCiAJCQllbmdpbmUtPm5hbWUsIHRlc3Rf bmFtZSwgY291bnQpOwogCi0JCXJlcG9ydGVkID0gaTkxNV9yZXNldF9lbmdpbmVfY291bnQoZ2xv YmFsLCBlbmdpbmUpOwotCQlyZXBvcnRlZCAtPSB0aHJlYWRzW2VuZ2luZS0+aWRdLnJlc2V0czsK LQkJaWYgKHJlcG9ydGVkICE9IGNvdW50KSB7Ci0JCQlwcl9lcnIoImk5MTVfcmVzZXRfZW5naW5l KCVzOiVzKTogcmVzZXQgJWx1IHRpbWVzLCBidXQgcmVwb3J0ZWQgJWx1XG4iLAotCQkJICAgICAg IGVuZ2luZS0+bmFtZSwgdGVzdF9uYW1lLCBjb3VudCwgcmVwb3J0ZWQpOwotCQkJaWYgKCFlcnIp Ci0JCQkJZXJyID0gLUVJTlZBTDsKKwkJLyogR3VDIGJhc2VkIHJlc2V0cyBhcmUgbm90IGxvZ2dl ZCBwZXIgZW5naW5lICovCisJCWlmICghdXNpbmdfZ3VjKSB7CisJCQlyZXBvcnRlZCA9IGk5MTVf cmVzZXRfZW5naW5lX2NvdW50KGdsb2JhbCwgZW5naW5lKTsKKwkJCXJlcG9ydGVkIC09IHRocmVh ZHNbZW5naW5lLT5pZF0ucmVzZXRzOworCQkJaWYgKHJlcG9ydGVkICE9IGNvdW50KSB7CisJCQkJ cHJfZXJyKCJpOTE1X3Jlc2V0X2VuZ2luZSglczolcyk6IHJlc2V0ICVsdSB0aW1lcywgYnV0IHJl cG9ydGVkICVsdVxuIiwKKwkJCQkgICAgICAgZW5naW5lLT5uYW1lLCB0ZXN0X25hbWUsIGNvdW50 LCByZXBvcnRlZCk7CisJCQkJaWYgKCFlcnIpCisJCQkJCWVyciA9IC1FSU5WQUw7CisJCQl9CiAJ CX0KIAogdW53aW5kOgpAQCAtMTA3OCwxNSArMTE5NSwxOCBAQCBzdGF0aWMgaW50IF9faWd0X3Jl c2V0X2VuZ2luZXMoc3RydWN0IGludGVsX2d0ICpndCwKIAkJCX0KIAkJCXB1dF90YXNrX3N0cnVj dCh0aHJlYWRzW3RtcF0udGFzayk7CiAKLQkJCWlmIChvdGhlci0+dWFiaV9jbGFzcyAhPSBlbmdp bmUtPnVhYmlfY2xhc3MgJiYKLQkJCSAgICB0aHJlYWRzW3RtcF0ucmVzZXRzICE9Ci0JCQkgICAg aTkxNV9yZXNldF9lbmdpbmVfY291bnQoZ2xvYmFsLCBvdGhlcikpIHsKLQkJCQlwcl9lcnIoIklu bm9jZW50IGVuZ2luZSAlcyB3YXMgcmVzZXQgKGNvdW50PSVsZClcbiIsCi0JCQkJICAgICAgIG90 aGVyLT5uYW1lLAotCQkJCSAgICAgICBpOTE1X3Jlc2V0X2VuZ2luZV9jb3VudChnbG9iYWwsIG90 aGVyKSAtCi0JCQkJICAgICAgIHRocmVhZHNbdG1wXS5yZXNldHMpOwotCQkJCWlmICghZXJyKQot CQkJCQllcnIgPSAtRUlOVkFMOworCQkJLyogR3VDIGJhc2VkIHJlc2V0cyBhcmUgbm90IGxvZ2dl ZCBwZXIgZW5naW5lICovCisJCQlpZiAoIXVzaW5nX2d1YykgeworCQkJCWlmIChvdGhlci0+dWFi aV9jbGFzcyAhPSBlbmdpbmUtPnVhYmlfY2xhc3MgJiYKKwkJCQkgICAgdGhyZWFkc1t0bXBdLnJl c2V0cyAhPQorCQkJCSAgICBpOTE1X3Jlc2V0X2VuZ2luZV9jb3VudChnbG9iYWwsIG90aGVyKSkg eworCQkJCQlwcl9lcnIoIklubm9jZW50IGVuZ2luZSAlcyB3YXMgcmVzZXQgKGNvdW50PSVsZClc biIsCisJCQkJCSAgICAgICBvdGhlci0+bmFtZSwKKwkJCQkJICAgICAgIGk5MTVfcmVzZXRfZW5n aW5lX2NvdW50KGdsb2JhbCwgb3RoZXIpIC0KKwkJCQkJICAgICAgIHRocmVhZHNbdG1wXS5yZXNl dHMpOworCQkJCQlpZiAoIWVycikKKwkJCQkJCWVyciA9IC1FSU5WQUw7CisJCQkJfQogCQkJfQog CQl9CiAKQEAgLTExMDEsOCArMTIyMSwxMCBAQCBzdGF0aWMgaW50IF9faWd0X3Jlc2V0X2VuZ2lu ZXMoc3RydWN0IGludGVsX2d0ICpndCwKIAkJCWJyZWFrOwogCiAJCWVyciA9IGlndF9mbHVzaF90 ZXN0KGd0LT5pOTE1KTsKLQkJaWYgKGVycikKKwkJaWYgKGVycikgeworCQkJcHJfZXJyKCJbJXNd IEZsdXNoIGZhaWxlZDogJWQhXG4iLCBlbmdpbmUtPm5hbWUsIGVycik7CiAJCQlicmVhazsKKwkJ fQogCX0KIAogCWlmIChpbnRlbF9ndF9pc193ZWRnZWQoZ3QpKQpAQCAtMTE4MCwxMiArMTMwMiwx NSBAQCBzdGF0aWMgaW50IGlndF9yZXNldF93YWl0KHZvaWQgKmFyZykKIAlpZ3RfZ2xvYmFsX3Jl c2V0X2xvY2soZ3QpOwogCiAJZXJyID0gaGFuZ19pbml0KCZoLCBndCk7Ci0JaWYgKGVycikKKwlp ZiAoZXJyKSB7CisJCXByX2VycigiWyVzXSBIYW5nIGluaXQgZmFpbGVkOiAlZCFcbiIsIGVuZ2lu ZS0+bmFtZSwgZXJyKTsKIAkJZ290byB1bmxvY2s7CisJfQogCiAJcnEgPSBoYW5nX2NyZWF0ZV9y ZXF1ZXN0KCZoLCBlbmdpbmUpOwogCWlmIChJU19FUlIocnEpKSB7CiAJCWVyciA9IFBUUl9FUlIo cnEpOworCQlwcl9lcnIoIlslc10gQ3JlYXRlIGhhbmcgcmVxdWVzdCBmYWlsZWQ6ICVkIVxuIiwg ZW5naW5lLT5uYW1lLCBlcnIpOwogCQlnb3RvIGZpbmk7CiAJfQogCkBAIC0xMzEwLDEyICsxNDM1 LDE1IEBAIHN0YXRpYyBpbnQgX19pZ3RfcmVzZXRfZXZpY3Rfdm1hKHN0cnVjdCBpbnRlbF9ndCAq Z3QsCiAJLyogQ2hlY2sgdGhhdCB3ZSBjYW4gcmVjb3ZlciBhbiB1bmJpbmQgc3R1Y2sgb24gYSBo YW5naW5nIHJlcXVlc3QgKi8KIAogCWVyciA9IGhhbmdfaW5pdCgmaCwgZ3QpOwotCWlmIChlcnIp CisJaWYgKGVycikgeworCQlwcl9lcnIoIlslc10gSGFuZyBpbml0IGZhaWxlZDogJWQhXG4iLCBl bmdpbmUtPm5hbWUsIGVycik7CiAJCXJldHVybiBlcnI7CisJfQogCiAJb2JqID0gaTkxNV9nZW1f b2JqZWN0X2NyZWF0ZV9pbnRlcm5hbChndC0+aTkxNSwgU1pfMU0pOwogCWlmIChJU19FUlIob2Jq KSkgewogCQllcnIgPSBQVFJfRVJSKG9iaik7CisJCXByX2VycigiWyVzXSBDcmVhdGUgb2JqZWN0 IGZhaWxlZDogJWQhXG4iLCBlbmdpbmUtPm5hbWUsIGVycik7CiAJCWdvdG8gZmluaTsKIAl9CiAK QEAgLTEzMzAsMTIgKzE0NTgsMTQgQEAgc3RhdGljIGludCBfX2lndF9yZXNldF9ldmljdF92bWEo c3RydWN0IGludGVsX2d0ICpndCwKIAlhcmcudm1hID0gaTkxNV92bWFfaW5zdGFuY2Uob2JqLCB2 bSwgTlVMTCk7CiAJaWYgKElTX0VSUihhcmcudm1hKSkgewogCQllcnIgPSBQVFJfRVJSKGFyZy52 bWEpOworCQlwcl9lcnIoIlslc10gVk1BIGluc3RhbmNlIGZhaWxlZDogJWQhXG4iLCBlbmdpbmUt Pm5hbWUsIGVycik7CiAJCWdvdG8gb3V0X29iajsKIAl9CiAKIAlycSA9IGhhbmdfY3JlYXRlX3Jl cXVlc3QoJmgsIGVuZ2luZSk7CiAJaWYgKElTX0VSUihycSkpIHsKIAkJZXJyID0gUFRSX0VSUihy cSk7CisJCXByX2VycigiWyVzXSBDcmVhdGUgaGFuZyByZXF1ZXN0IGZhaWxlZDogJWQhXG4iLCBl bmdpbmUtPm5hbWUsIGVycik7CiAJCWdvdG8gb3V0X29iajsKIAl9CiAKQEAgLTEzNDcsNiArMTQ3 Nyw3IEBAIHN0YXRpYyBpbnQgX19pZ3RfcmVzZXRfZXZpY3Rfdm1hKHN0cnVjdCBpbnRlbF9ndCAq Z3QsCiAJZXJyID0gaTkxNV92bWFfcGluKGFyZy52bWEsIDAsIDAsIHBpbl9mbGFncyk7CiAJaWYg KGVycikgewogCQlpOTE1X3JlcXVlc3RfYWRkKHJxKTsKKwkJcHJfZXJyKCJbJXNdIFZNQSBwaW4g ZmFpbGVkOiAlZCFcbiIsIGVuZ2luZS0+bmFtZSwgZXJyKTsKIAkJZ290byBvdXRfb2JqOwogCX0K IApAQCAtMTM2Myw4ICsxNDk0LDE0IEBAIHN0YXRpYyBpbnQgX19pZ3RfcmVzZXRfZXZpY3Rfdm1h KHN0cnVjdCBpbnRlbF9ndCAqZ3QsCiAJaTkxNV92bWFfbG9jayhhcmcudm1hKTsKIAllcnIgPSBp OTE1X3JlcXVlc3RfYXdhaXRfb2JqZWN0KHJxLCBhcmcudm1hLT5vYmosCiAJCQkJCWZsYWdzICYg RVhFQ19PQkpFQ1RfV1JJVEUpOwotCWlmIChlcnIgPT0gMCkKKwlpZiAoZXJyID09IDApIHsKIAkJ ZXJyID0gaTkxNV92bWFfbW92ZV90b19hY3RpdmUoYXJnLnZtYSwgcnEsIGZsYWdzKTsKKwkJaWYg KGVycikKKwkJCXByX2VycigiWyVzXSBNb3ZlIHRvIGFjdGl2ZSBmYWlsZWQ6ICVkIVxuIiwgZW5n aW5lLT5uYW1lLCBlcnIpOworCX0gZWxzZSB7CisJCXByX2VycigiWyVzXSBSZXF1ZXN0IGF3YWl0 IGZhaWxlZDogJWQhXG4iLCBlbmdpbmUtPm5hbWUsIGVycik7CisJfQorCiAJaTkxNV92bWFfdW5s b2NrKGFyZy52bWEpOwogCiAJaWYgKGZsYWdzICYgRVhFQ19PQkpFQ1RfTkVFRFNfRkVOQ0UpCkBA IC0xMzkyLDYgKzE1MjksNyBAQCBzdGF0aWMgaW50IF9faWd0X3Jlc2V0X2V2aWN0X3ZtYShzdHJ1 Y3QgaW50ZWxfZ3QgKmd0LAogCXRzayA9IGt0aHJlYWRfcnVuKGZuLCAmYXJnLCAiaWd0L2V2aWN0 X3ZtYSIpOwogCWlmIChJU19FUlIodHNrKSkgewogCQllcnIgPSBQVFJfRVJSKHRzayk7CisJCXBy X2VycigiWyVzXSBUaHJlYWQgc3Bhd24gZmFpbGVkOiAlZCFcbiIsIGVuZ2luZS0+bmFtZSwgZXJy KTsKIAkJdHNrID0gTlVMTDsKIAkJZ290byBvdXRfcmVzZXQ7CiAJfQpAQCAtMTUwOCwxNyArMTY0 NiwyOSBAQCBzdGF0aWMgaW50IGlndF9yZXNldF9xdWV1ZSh2b2lkICphcmcpCiAJCWdvdG8gdW5s b2NrOwogCiAJZm9yX2VhY2hfZW5naW5lKGVuZ2luZSwgZ3QsIGlkKSB7CisJCXN0cnVjdCBpbnRl bF9zZWxmdGVzdF9zYXZlZF9wb2xpY3kgc2F2ZWQ7CiAJCXN0cnVjdCBpOTE1X3JlcXVlc3QgKnBy ZXY7CiAJCUlHVF9USU1FT1VUKGVuZF90aW1lKTsKIAkJdW5zaWduZWQgaW50IGNvdW50OworCQli b29sIHVzaW5nX2d1YyA9IGludGVsX2VuZ2luZV91c2VzX2d1YyhlbmdpbmUpOwogCiAJCWlmICgh aW50ZWxfZW5naW5lX2Nhbl9zdG9yZV9kd29yZChlbmdpbmUpKQogCQkJY29udGludWU7CiAKKwkJ aWYgKHVzaW5nX2d1YykgeworCQkJZXJyID0gaW50ZWxfc2VsZnRlc3RfbW9kaWZ5X3BvbGljeShl bmdpbmUsICZzYXZlZCwKKwkJCQkJCQkgIFNFTEZURVNUX1NDSEVEVUxFUl9NT0RJRllfTk9fSEFO R0NIRUNLKTsKKwkJCWlmIChlcnIpIHsKKwkJCQlwcl9lcnIoIlslc10gTW9kaWZ5IHBvbGljeSBm YWlsZWQ6ICVkIVxuIiwgZW5naW5lLT5uYW1lLCBlcnIpOworCQkJCWdvdG8gZmluaTsKKwkJCX0K KwkJfQorCiAJCXByZXYgPSBoYW5nX2NyZWF0ZV9yZXF1ZXN0KCZoLCBlbmdpbmUpOwogCQlpZiAo SVNfRVJSKHByZXYpKSB7CiAJCQllcnIgPSBQVFJfRVJSKHByZXYpOwotCQkJZ290byBmaW5pOwor CQkJcHJfZXJyKCJbJXNdIENyZWF0ZSAncHJldicgaGFuZyByZXF1ZXN0IGZhaWxlZDogJWQhXG4i LCBlbmdpbmUtPm5hbWUsIGVycik7CisJCQlnb3RvIHJlc3RvcmU7CiAJCX0KIAogCQlpOTE1X3Jl cXVlc3RfZ2V0KHByZXYpOwpAQCAtMTUzMiw3ICsxNjgyLDggQEAgc3RhdGljIGludCBpZ3RfcmVz ZXRfcXVldWUodm9pZCAqYXJnKQogCQkJcnEgPSBoYW5nX2NyZWF0ZV9yZXF1ZXN0KCZoLCBlbmdp bmUpOwogCQkJaWYgKElTX0VSUihycSkpIHsKIAkJCQllcnIgPSBQVFJfRVJSKHJxKTsKLQkJCQln b3RvIGZpbmk7CisJCQkJcHJfZXJyKCJbJXNdIENyZWF0ZSBoYW5nIHJlcXVlc3QgZmFpbGVkOiAl ZCFcbiIsIGVuZ2luZS0+bmFtZSwgZXJyKTsKKwkJCQlnb3RvIHJlc3RvcmU7CiAJCQl9CiAKIAkJ CWk5MTVfcmVxdWVzdF9nZXQocnEpOwpAQCAtMTU1Nyw3ICsxNzA4LDcgQEAgc3RhdGljIGludCBp Z3RfcmVzZXRfcXVldWUodm9pZCAqYXJnKQogCiAJCQkJR0VNX1RSQUNFX0RVTVAoKTsKIAkJCQlp bnRlbF9ndF9zZXRfd2VkZ2VkKGd0KTsKLQkJCQlnb3RvIGZpbmk7CisJCQkJZ290byByZXN0b3Jl OwogCQkJfQogCiAJCQlpZiAoIXdhaXRfdW50aWxfcnVubmluZygmaCwgcHJldikpIHsKQEAgLTE1 NzUsNyArMTcyNiw3IEBAIHN0YXRpYyBpbnQgaWd0X3Jlc2V0X3F1ZXVlKHZvaWQgKmFyZykKIAkJ CQlpbnRlbF9ndF9zZXRfd2VkZ2VkKGd0KTsKIAogCQkJCWVyciA9IC1FSU87Ci0JCQkJZ290byBm aW5pOworCQkJCWdvdG8gcmVzdG9yZTsKIAkJCX0KIAogCQkJcmVzZXRfY291bnQgPSBmYWtlX2hh bmdjaGVjayhndCwgQklUKGlkKSk7CkBAIC0xNTg2LDcgKzE3MzcsNyBAQCBzdGF0aWMgaW50IGln dF9yZXNldF9xdWV1ZSh2b2lkICphcmcpCiAJCQkJaTkxNV9yZXF1ZXN0X3B1dChycSk7CiAJCQkJ aTkxNV9yZXF1ZXN0X3B1dChwcmV2KTsKIAkJCQllcnIgPSAtRUlOVkFMOwotCQkJCWdvdG8gZmlu aTsKKwkJCQlnb3RvIHJlc3RvcmU7CiAJCQl9CiAKIAkJCWlmIChycS0+ZmVuY2UuZXJyb3IpIHsK QEAgLTE1OTUsNyArMTc0Niw3IEBAIHN0YXRpYyBpbnQgaWd0X3Jlc2V0X3F1ZXVlKHZvaWQgKmFy ZykKIAkJCQlpOTE1X3JlcXVlc3RfcHV0KHJxKTsKIAkJCQlpOTE1X3JlcXVlc3RfcHV0KHByZXYp OwogCQkJCWVyciA9IC1FSU5WQUw7Ci0JCQkJZ290byBmaW5pOworCQkJCWdvdG8gcmVzdG9yZTsK IAkJCX0KIAogCQkJaWYgKGk5MTVfcmVzZXRfY291bnQoZ2xvYmFsKSA9PSByZXNldF9jb3VudCkg ewpAQCAtMTYwMyw3ICsxNzU0LDcgQEAgc3RhdGljIGludCBpZ3RfcmVzZXRfcXVldWUodm9pZCAq YXJnKQogCQkJCWk5MTVfcmVxdWVzdF9wdXQocnEpOwogCQkJCWk5MTVfcmVxdWVzdF9wdXQocHJl dik7CiAJCQkJZXJyID0gLUVJTlZBTDsKLQkJCQlnb3RvIGZpbmk7CisJCQkJZ290byByZXN0b3Jl OwogCQkJfQogCiAJCQlpOTE1X3JlcXVlc3RfcHV0KHByZXYpOwpAQCAtMTYxOCw5ICsxNzY5LDIy IEBAIHN0YXRpYyBpbnQgaWd0X3Jlc2V0X3F1ZXVlKHZvaWQgKmFyZykKIAogCQlpOTE1X3JlcXVl c3RfcHV0KHByZXYpOwogCi0JCWVyciA9IGlndF9mbHVzaF90ZXN0KGd0LT5pOTE1KTsKK3Jlc3Rv cmU6CisJCWlmICh1c2luZ19ndWMpIHsKKwkJCWludCBlcnIyID0gaW50ZWxfc2VsZnRlc3RfcmVz dG9yZV9wb2xpY3koZW5naW5lLCAmc2F2ZWQpOworCQkJaWYgKGVycjIpCisJCQkJcHJfZXJyKCIl czolZD4gWyVzXSBSZXN0b3JlIHBvbGljeSBmYWlsZWQ6ICVkIVxuIiwgX19mdW5jX18sIF9fTElO RV9fLCBlbmdpbmUtPm5hbWUsIGVycjIpOworCQkJaWYgKGVyciA9PSAwKQorCQkJCWVyciA9IGVy cjI7CisJCX0KIAkJaWYgKGVycikKKwkJCWdvdG8gZmluaTsKKworCQllcnIgPSBpZ3RfZmx1c2hf dGVzdChndC0+aTkxNSk7CisJCWlmIChlcnIpIHsKKwkJCXByX2VycigiWyVzXSBGbHVzaCBmYWls ZWQ6ICVkIVxuIiwgZW5naW5lLT5uYW1lLCBlcnIpOwogCQkJYnJlYWs7CisJCX0KIAl9CiAKIGZp bmk6CkBAIC0xNjUzLDEyICsxODE3LDE1IEBAIHN0YXRpYyBpbnQgaWd0X2hhbmRsZV9lcnJvcih2 b2lkICphcmcpCiAJCXJldHVybiAwOwogCiAJZXJyID0gaGFuZ19pbml0KCZoLCBndCk7Ci0JaWYg KGVycikKKwlpZiAoZXJyKSB7CisJCXByX2VycigiWyVzXSBIYW5nIGluaXQgZmFpbGVkOiAlZCFc biIsIGVuZ2luZS0+bmFtZSwgZXJyKTsKIAkJcmV0dXJuIGVycjsKKwl9CiAKIAlycSA9IGhhbmdf Y3JlYXRlX3JlcXVlc3QoJmgsIGVuZ2luZSk7CiAJaWYgKElTX0VSUihycSkpIHsKIAkJZXJyID0g UFRSX0VSUihycSk7CisJCXByX2VycigiWyVzXSBDcmVhdGUgaGFuZyByZXF1ZXN0IGZhaWxlZDog JWQhXG4iLCBlbmdpbmUtPm5hbWUsIGVycik7CiAJCWdvdG8gZXJyX2Zpbmk7CiAJfQogCkBAIC0x NzQzLDEyICsxOTEwLDE1IEBAIHN0YXRpYyBpbnQgaWd0X2F0b21pY19yZXNldF9lbmdpbmUoc3Ry dWN0IGludGVsX2VuZ2luZV9jcyAqZW5naW5lLAogCQlyZXR1cm4gZXJyOwogCiAJZXJyID0gaGFu Z19pbml0KCZoLCBlbmdpbmUtPmd0KTsKLQlpZiAoZXJyKQorCWlmIChlcnIpIHsKKwkJcHJfZXJy KCJbJXNdIEhhbmcgaW5pdCBmYWlsZWQ6ICVkIVxuIiwgZW5naW5lLT5uYW1lLCBlcnIpOwogCQly ZXR1cm4gZXJyOworCX0KIAogCXJxID0gaGFuZ19jcmVhdGVfcmVxdWVzdCgmaCwgZW5naW5lKTsK IAlpZiAoSVNfRVJSKHJxKSkgewogCQllcnIgPSBQVFJfRVJSKHJxKTsKKwkJcHJfZXJyKCJbJXNd IENyZWF0ZSBoYW5nIHJlcXVlc3QgZmFpbGVkOiAlZCFcbiIsIGVuZ2luZS0+bmFtZSwgZXJyKTsK IAkJZ290byBvdXQ7CiAJfQogCmRpZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9kcm0vaTkxNS9ndC9z ZWxmdGVzdF9tb2NzLmMgYi9kcml2ZXJzL2dwdS9kcm0vaTkxNS9ndC9zZWxmdGVzdF9tb2NzLmMK aW5kZXggODc2M2JiZWNhMGY3Li4xM2QyNWJmMmE5NGEgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvZ3B1 L2RybS9pOTE1L2d0L3NlbGZ0ZXN0X21vY3MuYworKysgYi9kcml2ZXJzL2dwdS9kcm0vaTkxNS9n dC9zZWxmdGVzdF9tb2NzLmMKQEAgLTEwLDYgKzEwLDcgQEAKICNpbmNsdWRlICJnZW0vc2VsZnRl c3RzL21vY2tfY29udGV4dC5oIgogI2luY2x1ZGUgInNlbGZ0ZXN0cy9pZ3RfcmVzZXQuaCIKICNp bmNsdWRlICJzZWxmdGVzdHMvaWd0X3NwaW5uZXIuaCIKKyNpbmNsdWRlICJzZWxmdGVzdHMvaW50 ZWxfc2NoZWR1bGVyX2hlbHBlcnMuaCIKIAogc3RydWN0IGxpdmVfbW9jcyB7CiAJc3RydWN0IGRy bV9pOTE1X21vY3NfdGFibGUgdGFibGU7CkBAIC0zMTgsNyArMzE5LDggQEAgc3RhdGljIGludCBs aXZlX21vY3NfY2xlYW4odm9pZCAqYXJnKQogfQogCiBzdGF0aWMgaW50IGFjdGl2ZV9lbmdpbmVf cmVzZXQoc3RydWN0IGludGVsX2NvbnRleHQgKmNlLAotCQkJICAgICAgIGNvbnN0IGNoYXIgKnJl YXNvbikKKwkJCSAgICAgICBjb25zdCBjaGFyICpyZWFzb24sCisJCQkgICAgICAgYm9vbCB1c2lu Z19ndWMpCiB7CiAJc3RydWN0IGlndF9zcGlubmVyIHNwaW47CiAJc3RydWN0IGk5MTVfcmVxdWVz dCAqcnE7CkBAIC0zMzUsOSArMzM3LDEzIEBAIHN0YXRpYyBpbnQgYWN0aXZlX2VuZ2luZV9yZXNl dChzdHJ1Y3QgaW50ZWxfY29udGV4dCAqY2UsCiAJfQogCiAJZXJyID0gcmVxdWVzdF9hZGRfc3Bp bihycSwgJnNwaW4pOwotCWlmIChlcnIgPT0gMCkKKwlpZiAoZXJyID09IDAgJiYgIXVzaW5nX2d1 YykKIAkJZXJyID0gaW50ZWxfZW5naW5lX3Jlc2V0KGNlLT5lbmdpbmUsIHJlYXNvbik7CiAKKwkv KiBFbnN1cmUgdGhlIHJlc2V0IGhhcHBlbnMgYW5kIGtpbGxzIHRoZSBlbmdpbmUgKi8KKwlpZiAo ZXJyID09IDApCisJCWVyciA9IGludGVsX3NlbGZ0ZXN0X3dhaXRfZm9yX3JxKHJxKTsKKwogCWln dF9zcGlubmVyX2VuZCgmc3Bpbik7CiAJaWd0X3NwaW5uZXJfZmluaSgmc3Bpbik7CiAKQEAgLTM0 NSwyMSArMzUxLDIzIEBAIHN0YXRpYyBpbnQgYWN0aXZlX2VuZ2luZV9yZXNldChzdHJ1Y3QgaW50 ZWxfY29udGV4dCAqY2UsCiB9CiAKIHN0YXRpYyBpbnQgX19saXZlX21vY3NfcmVzZXQoc3RydWN0 IGxpdmVfbW9jcyAqbW9jcywKLQkJCSAgICAgc3RydWN0IGludGVsX2NvbnRleHQgKmNlKQorCQkJ ICAgICBzdHJ1Y3QgaW50ZWxfY29udGV4dCAqY2UsIGJvb2wgdXNpbmdfZ3VjKQogewogCXN0cnVj dCBpbnRlbF9ndCAqZ3QgPSBjZS0+ZW5naW5lLT5ndDsKIAlpbnQgZXJyOwogCiAJaWYgKGludGVs X2hhc19yZXNldF9lbmdpbmUoZ3QpKSB7Ci0JCWVyciA9IGludGVsX2VuZ2luZV9yZXNldChjZS0+ ZW5naW5lLCAibW9jcyIpOwotCQlpZiAoZXJyKQotCQkJcmV0dXJuIGVycjsKLQotCQllcnIgPSBj aGVja19tb2NzX2VuZ2luZShtb2NzLCBjZSk7Ci0JCWlmIChlcnIpCi0JCQlyZXR1cm4gZXJyOwor CQlpZiAoIXVzaW5nX2d1YykgeworCQkJZXJyID0gaW50ZWxfZW5naW5lX3Jlc2V0KGNlLT5lbmdp bmUsICJtb2NzIik7CisJCQlpZiAoZXJyKQorCQkJCXJldHVybiBlcnI7CisKKwkJCWVyciA9IGNo ZWNrX21vY3NfZW5naW5lKG1vY3MsIGNlKTsKKwkJCWlmIChlcnIpCisJCQkJcmV0dXJuIGVycjsK KwkJfQogCi0JCWVyciA9IGFjdGl2ZV9lbmdpbmVfcmVzZXQoY2UsICJtb2NzIik7CisJCWVyciA9 IGFjdGl2ZV9lbmdpbmVfcmVzZXQoY2UsICJtb2NzIiwgdXNpbmdfZ3VjKTsKIAkJaWYgKGVycikK IAkJCXJldHVybiBlcnI7CiAKQEAgLTM5NSwxOSArNDAzLDMzIEBAIHN0YXRpYyBpbnQgbGl2ZV9t b2NzX3Jlc2V0KHZvaWQgKmFyZykKIAogCWlndF9nbG9iYWxfcmVzZXRfbG9jayhndCk7CiAJZm9y X2VhY2hfZW5naW5lKGVuZ2luZSwgZ3QsIGlkKSB7CisJCWJvb2wgdXNpbmdfZ3VjID0gaW50ZWxf ZW5naW5lX3VzZXNfZ3VjKGVuZ2luZSk7CisJCXN0cnVjdCBpbnRlbF9zZWxmdGVzdF9zYXZlZF9w b2xpY3kgc2F2ZWQ7CiAJCXN0cnVjdCBpbnRlbF9jb250ZXh0ICpjZTsKKwkJaW50IGVycjI7CisK KwkJZXJyID0gaW50ZWxfc2VsZnRlc3RfbW9kaWZ5X3BvbGljeShlbmdpbmUsICZzYXZlZCwKKwkJ CQkJCSAgIFNFTEZURVNUX1NDSEVEVUxFUl9NT0RJRllfRkFTVF9SRVNFVCk7CisJCWlmIChlcnIp CisJCQlicmVhazsKIAogCQljZSA9IG1vY3NfY29udGV4dF9jcmVhdGUoZW5naW5lKTsKIAkJaWYg KElTX0VSUihjZSkpIHsKIAkJCWVyciA9IFBUUl9FUlIoY2UpOwotCQkJYnJlYWs7CisJCQlnb3Rv IHJlc3RvcmU7CiAJCX0KIAogCQlpbnRlbF9lbmdpbmVfcG1fZ2V0KGVuZ2luZSk7Ci0JCWVyciA9 IF9fbGl2ZV9tb2NzX3Jlc2V0KCZtb2NzLCBjZSk7Ci0JCWludGVsX2VuZ2luZV9wbV9wdXQoZW5n aW5lKTsKIAorCQllcnIgPSBfX2xpdmVfbW9jc19yZXNldCgmbW9jcywgY2UsIHVzaW5nX2d1Yyk7 CisKKwkJaW50ZWxfZW5naW5lX3BtX3B1dChlbmdpbmUpOwogCQlpbnRlbF9jb250ZXh0X3B1dChj ZSk7CisKK3Jlc3RvcmU6CisJCWVycjIgPSBpbnRlbF9zZWxmdGVzdF9yZXN0b3JlX3BvbGljeShl bmdpbmUsICZzYXZlZCk7CisJCWlmIChlcnIgPT0gMCkKKwkJCWVyciA9IGVycjI7CiAJCWlmIChl cnIpCiAJCQlicmVhazsKIAl9CmRpZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9kcm0vaTkxNS9ndC9z ZWxmdGVzdF93b3JrYXJvdW5kcy5jIGIvZHJpdmVycy9ncHUvZHJtL2k5MTUvZ3Qvc2VsZnRlc3Rf d29ya2Fyb3VuZHMuYwppbmRleCA3ZWJjNGVkYjhlY2YuLmQ4MjBmMGI0MTYzNCAxMDA2NDQKLS0t IGEvZHJpdmVycy9ncHUvZHJtL2k5MTUvZ3Qvc2VsZnRlc3Rfd29ya2Fyb3VuZHMuYworKysgYi9k cml2ZXJzL2dwdS9kcm0vaTkxNS9ndC9zZWxmdGVzdF93b3JrYXJvdW5kcy5jCkBAIC0xMiw2ICsx Miw3IEBACiAjaW5jbHVkZSAic2VsZnRlc3RzL2lndF9mbHVzaF90ZXN0LmgiCiAjaW5jbHVkZSAi c2VsZnRlc3RzL2lndF9yZXNldC5oIgogI2luY2x1ZGUgInNlbGZ0ZXN0cy9pZ3Rfc3Bpbm5lci5o IgorI2luY2x1ZGUgInNlbGZ0ZXN0cy9pbnRlbF9zY2hlZHVsZXJfaGVscGVycy5oIgogI2luY2x1 ZGUgInNlbGZ0ZXN0cy9tb2NrX2RybS5oIgogCiAjaW5jbHVkZSAiZ2VtL3NlbGZ0ZXN0cy9pZ3Rf Z2VtX3V0aWxzLmgiCkBAIC0yNjEsMjggKzI2MiwzNCBAQCBzdGF0aWMgaW50IGRvX2VuZ2luZV9y ZXNldChzdHJ1Y3QgaW50ZWxfZW5naW5lX2NzICplbmdpbmUpCiAJcmV0dXJuIGludGVsX2VuZ2lu ZV9yZXNldChlbmdpbmUsICJsaXZlX3dvcmthcm91bmRzIik7CiB9CiAKK3N0YXRpYyBpbnQgZG9f Z3VjX3Jlc2V0KHN0cnVjdCBpbnRlbF9lbmdpbmVfY3MgKmVuZ2luZSkKK3sKKwkvKiBDdXJyZW50 bHkgYSBuby1vcCBhcyB0aGUgcmVzZXQgaXMgaGFuZGxlZCBieSBHdUMgKi8KKwlyZXR1cm4gMDsK K30KKwogc3RhdGljIGludAogc3dpdGNoX3RvX3NjcmF0Y2hfY29udGV4dChzdHJ1Y3QgaW50ZWxf ZW5naW5lX2NzICplbmdpbmUsCi0JCQkgIHN0cnVjdCBpZ3Rfc3Bpbm5lciAqc3BpbikKKwkJCSAg c3RydWN0IGlndF9zcGlubmVyICpzcGluLAorCQkJICBzdHJ1Y3QgaTkxNV9yZXF1ZXN0ICoqcnEp CiB7CiAJc3RydWN0IGludGVsX2NvbnRleHQgKmNlOwotCXN0cnVjdCBpOTE1X3JlcXVlc3QgKnJx OwogCWludCBlcnIgPSAwOwogCiAJY2UgPSBpbnRlbF9jb250ZXh0X2NyZWF0ZShlbmdpbmUpOwog CWlmIChJU19FUlIoY2UpKQogCQlyZXR1cm4gUFRSX0VSUihjZSk7CiAKLQlycSA9IGlndF9zcGlu bmVyX2NyZWF0ZV9yZXF1ZXN0KHNwaW4sIGNlLCBNSV9OT09QKTsKKwkqcnEgPSBpZ3Rfc3Bpbm5l cl9jcmVhdGVfcmVxdWVzdChzcGluLCBjZSwgTUlfTk9PUCk7CiAJaW50ZWxfY29udGV4dF9wdXQo Y2UpOwogCi0JaWYgKElTX0VSUihycSkpIHsKKwlpZiAoSVNfRVJSKCpycSkpIHsKIAkJc3BpbiA9 IE5VTEw7Ci0JCWVyciA9IFBUUl9FUlIocnEpOworCQllcnIgPSBQVFJfRVJSKCpycSk7CiAJCWdv dG8gZXJyOwogCX0KIAotCWVyciA9IHJlcXVlc3RfYWRkX3NwaW4ocnEsIHNwaW4pOworCWVyciA9 IHJlcXVlc3RfYWRkX3NwaW4oKnJxLCBzcGluKTsKIGVycjoKIAlpZiAoZXJyICYmIHNwaW4pCiAJ CWlndF9zcGlubmVyX2VuZChzcGluKTsKQEAgLTI5Niw2ICszMDMsNyBAQCBzdGF0aWMgaW50IGNo ZWNrX3doaXRlbGlzdF9hY3Jvc3NfcmVzZXQoc3RydWN0IGludGVsX2VuZ2luZV9jcyAqZW5naW5l LAogewogCXN0cnVjdCBpbnRlbF9jb250ZXh0ICpjZSwgKnRtcDsKIAlzdHJ1Y3QgaWd0X3NwaW5u ZXIgc3BpbjsKKwlzdHJ1Y3QgaTkxNV9yZXF1ZXN0ICpycTsKIAlpbnRlbF93YWtlcmVmX3Qgd2Fr ZXJlZjsKIAlpbnQgZXJyOwogCkBAIC0zMTYsMTMgKzMyNCwyNCBAQCBzdGF0aWMgaW50IGNoZWNr X3doaXRlbGlzdF9hY3Jvc3NfcmVzZXQoc3RydWN0IGludGVsX2VuZ2luZV9jcyAqZW5naW5lLAog CQlnb3RvIG91dF9zcGluOwogCX0KIAotCWVyciA9IHN3aXRjaF90b19zY3JhdGNoX2NvbnRleHQo ZW5naW5lLCAmc3Bpbik7CisJZXJyID0gc3dpdGNoX3RvX3NjcmF0Y2hfY29udGV4dChlbmdpbmUs ICZzcGluLCAmcnEpOwogCWlmIChlcnIpCiAJCWdvdG8gb3V0X3NwaW47CiAKKwkvKiBFbnN1cmUg dGhlIHNwaW5uZXIgaGFzbid0IGFib3J0ZWQgKi8KKwlpZiAoaTkxNV9yZXF1ZXN0X2NvbXBsZXRl ZChycSkpIHsKKwkJcHJfZXJyKCIlcyBzcGlubmVyIGZhaWxlZCB0byBzdGFydFxuIiwgbmFtZSk7 CisJCWVyciA9IC1FVElNRURPVVQ7CisJCWdvdG8gb3V0X3NwaW47CisJfQorCiAJd2l0aF9pbnRl bF9ydW50aW1lX3BtKGVuZ2luZS0+dW5jb3JlLT5ycG0sIHdha2VyZWYpCiAJCWVyciA9IHJlc2V0 KGVuZ2luZSk7CiAKKwkvKiBFbnN1cmUgdGhlIHJlc2V0IGhhcHBlbnMgYW5kIGtpbGxzIHRoZSBl bmdpbmUgKi8KKwlpZiAoZXJyID09IDApCisJCWVyciA9IGludGVsX3NlbGZ0ZXN0X3dhaXRfZm9y X3JxKHJxKTsKKwogCWlndF9zcGlubmVyX2VuZCgmc3Bpbik7CiAKIAlpZiAoZXJyKSB7CkBAIC03 ODcsOSArODA2LDI3IEBAIHN0YXRpYyBpbnQgbGl2ZV9yZXNldF93aGl0ZWxpc3Qodm9pZCAqYXJn KQogCQkJY29udGludWU7CiAKIAkJaWYgKGludGVsX2hhc19yZXNldF9lbmdpbmUoZ3QpKSB7Ci0J CQllcnIgPSBjaGVja193aGl0ZWxpc3RfYWNyb3NzX3Jlc2V0KGVuZ2luZSwKLQkJCQkJCQkgICBk b19lbmdpbmVfcmVzZXQsCi0JCQkJCQkJICAgImVuZ2luZSIpOworCQkJaWYgKGludGVsX2VuZ2lu ZV91c2VzX2d1YyhlbmdpbmUpKSB7CisJCQkJc3RydWN0IGludGVsX3NlbGZ0ZXN0X3NhdmVkX3Bv bGljeSBzYXZlZDsKKwkJCQlpbnQgZXJyMjsKKworCQkJCWVyciA9IGludGVsX3NlbGZ0ZXN0X21v ZGlmeV9wb2xpY3koZW5naW5lLCAmc2F2ZWQsCisJCQkJCQkJCSAgIFNFTEZURVNUX1NDSEVEVUxF Ul9NT0RJRllfRkFTVF9SRVNFVCk7CisJCQkJaWYoZXJyKQorCQkJCQlnb3RvIG91dDsKKworCQkJ CWVyciA9IGNoZWNrX3doaXRlbGlzdF9hY3Jvc3NfcmVzZXQoZW5naW5lLAorCQkJCQkJCQkgICBk b19ndWNfcmVzZXQsCisJCQkJCQkJCSAgICJndWMiKTsKKworCQkJCWVycjIgPSBpbnRlbF9zZWxm dGVzdF9yZXN0b3JlX3BvbGljeShlbmdpbmUsICZzYXZlZCk7CisJCQkJaWYgKGVyciA9PSAwKQor CQkJCQllcnIgPSBlcnIyOworCQkJfSBlbHNlCisJCQkJZXJyID0gY2hlY2tfd2hpdGVsaXN0X2Fj cm9zc19yZXNldChlbmdpbmUsCisJCQkJCQkJCSAgIGRvX2VuZ2luZV9yZXNldCwKKwkJCQkJCQkJ ICAgImVuZ2luZSIpOworCiAJCQlpZiAoZXJyKQogCQkJCWdvdG8gb3V0OwogCQl9CkBAIC0xMjI2 LDMxICsxMjYzLDQyIEBAIGxpdmVfZW5naW5lX3Jlc2V0X3dvcmthcm91bmRzKHZvaWQgKmFyZykK IAlyZWZlcmVuY2VfbGlzdHNfaW5pdChndCwgJmxpc3RzKTsKIAogCWZvcl9lYWNoX2VuZ2luZShl bmdpbmUsIGd0LCBpZCkgeworCQlzdHJ1Y3QgaW50ZWxfc2VsZnRlc3Rfc2F2ZWRfcG9saWN5IHNh dmVkOworCQlib29sIHVzaW5nX2d1YyA9IGludGVsX2VuZ2luZV91c2VzX2d1YyhlbmdpbmUpOwog CQlib29sIG9rOworCQlpbnQgcmV0MjsKIAogCQlwcl9pbmZvKCJWZXJpZnlpbmcgYWZ0ZXIgJXMg cmVzZXQuLi5cbiIsIGVuZ2luZS0+bmFtZSk7CisJCXJldCA9IGludGVsX3NlbGZ0ZXN0X21vZGlm eV9wb2xpY3koZW5naW5lLCAmc2F2ZWQsCisJCQkJCQkgICBTRUxGVEVTVF9TQ0hFRFVMRVJfTU9E SUZZX0ZBU1RfUkVTRVQpOworCQlpZiAocmV0KQorCQkJYnJlYWs7CisKKwogCQljZSA9IGludGVs X2NvbnRleHRfY3JlYXRlKGVuZ2luZSk7CiAJCWlmIChJU19FUlIoY2UpKSB7CiAJCQlyZXQgPSBQ VFJfRVJSKGNlKTsKLQkJCWJyZWFrOworCQkJZ290byByZXN0b3JlOwogCQl9CiAKLQkJb2sgPSB2 ZXJpZnlfd2FfbGlzdHMoZ3QsICZsaXN0cywgImJlZm9yZSByZXNldCIpOwotCQlpZiAoIW9rKSB7 Ci0JCQlyZXQgPSAtRVNSQ0g7Ci0JCQlnb3RvIGVycjsKLQkJfQorCQlpZiAoIXVzaW5nX2d1Yykg eworCQkJb2sgPSB2ZXJpZnlfd2FfbGlzdHMoZ3QsICZsaXN0cywgImJlZm9yZSByZXNldCIpOwor CQkJaWYgKCFvaykgeworCQkJCXJldCA9IC1FU1JDSDsKKwkJCQlnb3RvIGVycjsKKwkJCX0KIAot CQlyZXQgPSBpbnRlbF9lbmdpbmVfcmVzZXQoZW5naW5lLCAibGl2ZV93b3JrYXJvdW5kczppZGxl Iik7Ci0JCWlmIChyZXQpIHsKLQkJCXByX2VycigiJXM6IFJlc2V0IGZhaWxlZCB3aGlsZSBpZGxl XG4iLCBlbmdpbmUtPm5hbWUpOwotCQkJZ290byBlcnI7Ci0JCX0KKwkJCXJldCA9IGludGVsX2Vu Z2luZV9yZXNldChlbmdpbmUsICJsaXZlX3dvcmthcm91bmRzOmlkbGUiKTsKKwkJCWlmIChyZXQp IHsKKwkJCQlwcl9lcnIoIiVzOiBSZXNldCBmYWlsZWQgd2hpbGUgaWRsZVxuIiwgZW5naW5lLT5u YW1lKTsKKwkJCQlnb3RvIGVycjsKKwkJCX0KIAotCQlvayA9IHZlcmlmeV93YV9saXN0cyhndCwg Jmxpc3RzLCAiYWZ0ZXIgaWRsZSByZXNldCIpOwotCQlpZiAoIW9rKSB7Ci0JCQlyZXQgPSAtRVNS Q0g7Ci0JCQlnb3RvIGVycjsKKwkJCW9rID0gdmVyaWZ5X3dhX2xpc3RzKGd0LCAmbGlzdHMsICJh ZnRlciBpZGxlIHJlc2V0Iik7CisJCQlpZiAoIW9rKSB7CisJCQkJcmV0ID0gLUVTUkNIOworCQkJ CWdvdG8gZXJyOworCQkJfQogCQl9CiAKIAkJcmV0ID0gaWd0X3NwaW5uZXJfaW5pdCgmc3Bpbiwg ZW5naW5lLT5ndCk7CkBAIC0xMjcxLDI1ICsxMzE5LDQxIEBAIGxpdmVfZW5naW5lX3Jlc2V0X3dv cmthcm91bmRzKHZvaWQgKmFyZykKIAkJCWdvdG8gZXJyOwogCQl9CiAKLQkJcmV0ID0gaW50ZWxf ZW5naW5lX3Jlc2V0KGVuZ2luZSwgImxpdmVfd29ya2Fyb3VuZHM6YWN0aXZlIik7Ci0JCWlmIChy ZXQpIHsKLQkJCXByX2VycigiJXM6IFJlc2V0IGZhaWxlZCBvbiBhbiBhY3RpdmUgc3Bpbm5lclxu IiwKLQkJCSAgICAgICBlbmdpbmUtPm5hbWUpOwotCQkJaWd0X3NwaW5uZXJfZmluaSgmc3Bpbik7 Ci0JCQlnb3RvIGVycjsKKwkJLyogRW5zdXJlIHRoZSBzcGlubmVyIGhhc24ndCBhYm9ydGVkICov CisJCWlmIChpOTE1X3JlcXVlc3RfY29tcGxldGVkKHJxKSkgeworCQkJcmV0ID0gLUVUSU1FRE9V VDsKKwkJCWdvdG8gc2tpcDsKKwkJfQorCisJCWlmICghdXNpbmdfZ3VjKSB7CisJCQlyZXQgPSBp bnRlbF9lbmdpbmVfcmVzZXQoZW5naW5lLCAibGl2ZV93b3JrYXJvdW5kczphY3RpdmUiKTsKKwkJ CWlmIChyZXQpIHsKKwkJCQlwcl9lcnIoIiVzOiBSZXNldCBmYWlsZWQgb24gYW4gYWN0aXZlIHNw aW5uZXJcbiIsCisJCQkJICAgICAgIGVuZ2luZS0+bmFtZSk7CisJCQkJaWd0X3NwaW5uZXJfZmlu aSgmc3Bpbik7CisJCQkJZ290byBlcnI7CisJCQl9CiAJCX0KIAorCQkvKiBFbnN1cmUgdGhlIHJl c2V0IGhhcHBlbnMgYW5kIGtpbGxzIHRoZSBlbmdpbmUgKi8KKwkJaWYgKHJldCA9PSAwKQorCQkJ cmV0ID0gaW50ZWxfc2VsZnRlc3Rfd2FpdF9mb3JfcnEocnEpOworCitza2lwOgogCQlpZ3Rfc3Bp bm5lcl9lbmQoJnNwaW4pOwogCQlpZ3Rfc3Bpbm5lcl9maW5pKCZzcGluKTsKIAogCQlvayA9IHZl cmlmeV93YV9saXN0cyhndCwgJmxpc3RzLCAiYWZ0ZXIgYnVzeSByZXNldCIpOwotCQlpZiAoIW9r KSB7CisJCWlmICghb2spCiAJCQlyZXQgPSAtRVNSQ0g7Ci0JCQlnb3RvIGVycjsKLQkJfQogCiBl cnI6CiAJCWludGVsX2NvbnRleHRfcHV0KGNlKTsKKworcmVzdG9yZToKKwkJcmV0MiA9IGludGVs X3NlbGZ0ZXN0X3Jlc3RvcmVfcG9saWN5KGVuZ2luZSwgJnNhdmVkKTsKKwkJaWYgKHJldCA9PSAw KQorCQkJcmV0ID0gcmV0MjsKIAkJaWYgKHJldCkKIAkJCWJyZWFrOwogCX0KZGlmZiAtLWdpdCBh L2RyaXZlcnMvZ3B1L2RybS9pOTE1L2d0L3VjL2FiaS9ndWNfYWN0aW9uc19hYmkuaCBiL2RyaXZl cnMvZ3B1L2RybS9pOTE1L2d0L3VjL2FiaS9ndWNfYWN0aW9uc19hYmkuaAppbmRleCAyZDYxOThl NjNlYmUuLjU5NmNmNGI4MThlNSAxMDA2NDQKLS0tIGEvZHJpdmVycy9ncHUvZHJtL2k5MTUvZ3Qv dWMvYWJpL2d1Y19hY3Rpb25zX2FiaS5oCisrKyBiL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2d0L3Vj L2FiaS9ndWNfYWN0aW9uc19hYmkuaApAQCAtMTI0LDEwICsxMjQsMjUgQEAgZW51bSBpbnRlbF9n dWNfYWN0aW9uIHsKIAlJTlRFTF9HVUNfQUNUSU9OX0ZPUkNFX0xPR19CVUZGRVJfRkxVU0ggPSAw eDMwMiwKIAlJTlRFTF9HVUNfQUNUSU9OX0VOVEVSX1NfU1RBVEUgPSAweDUwMSwKIAlJTlRFTF9H VUNfQUNUSU9OX0VYSVRfU19TVEFURSA9IDB4NTAyLAorCUlOVEVMX0dVQ19BQ1RJT05fR0xPQkFM X1NDSEVEX1BPTElDWV9DSEFOR0UgPSAweDUwNiwKKwlJTlRFTF9HVUNfQUNUSU9OX1NDSEVEX0NP TlRFWFQgPSAweDEwMDAsCisJSU5URUxfR1VDX0FDVElPTl9TQ0hFRF9DT05URVhUX01PREVfU0VU ID0gMHgxMDAxLAorCUlOVEVMX0dVQ19BQ1RJT05fU0NIRURfQ09OVEVYVF9NT0RFX0RPTkUgPSAw eDEwMDIsCisJSU5URUxfR1VDX0FDVElPTl9TQ0hFRF9FTkdJTkVfTU9ERV9TRVQgPSAweDEwMDMs CisJSU5URUxfR1VDX0FDVElPTl9TQ0hFRF9FTkdJTkVfTU9ERV9ET05FID0gMHgxMDA0LAorCUlO VEVMX0dVQ19BQ1RJT05fU0VUX0NPTlRFWFRfUFJJT1JJVFkgPSAweDEwMDUsCisJSU5URUxfR1VD X0FDVElPTl9TRVRfQ09OVEVYVF9FWEVDVVRJT05fUVVBTlRVTSA9IDB4MTAwNiwKKwlJTlRFTF9H VUNfQUNUSU9OX1NFVF9DT05URVhUX1BSRUVNUFRJT05fVElNRU9VVCA9IDB4MTAwNywKKwlJTlRF TF9HVUNfQUNUSU9OX0NPTlRFWFRfUkVTRVRfTk9USUZJQ0FUSU9OID0gMHgxMDA4LAorCUlOVEVM X0dVQ19BQ1RJT05fRU5HSU5FX0ZBSUxVUkVfTk9USUZJQ0FUSU9OID0gMHgxMDA5LAogCUlOVEVM X0dVQ19BQ1RJT05fU0xQQ19SRVFVRVNUID0gMHgzMDAzLAogCUlOVEVMX0dVQ19BQ1RJT05fQVVU SEVOVElDQVRFX0hVQyA9IDB4NDAwMCwKKwlJTlRFTF9HVUNfQUNUSU9OX1JFR0lTVEVSX0NPTlRF WFQgPSAweDQ1MDIsCisJSU5URUxfR1VDX0FDVElPTl9ERVJFR0lTVEVSX0NPTlRFWFQgPSAweDQ1 MDMsCiAJSU5URUxfR1VDX0FDVElPTl9SRUdJU1RFUl9DT01NQU5EX1RSQU5TUE9SVF9CVUZGRVIg PSAweDQ1MDUsCiAJSU5URUxfR1VDX0FDVElPTl9ERVJFR0lTVEVSX0NPTU1BTkRfVFJBTlNQT1JU X0JVRkZFUiA9IDB4NDUwNiwKKwlJTlRFTF9HVUNfQUNUSU9OX0RFUkVHSVNURVJfQ09OVEVYVF9E T05FID0gMHg0NjAwLAorCUlOVEVMX0dVQ19BQ1RJT05fUkVTRVRfQ0xJRU5UID0gMHg1QjAxLAog CUlOVEVMX0dVQ19BQ1RJT05fTElNSVQKIH07CiAKZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2Ry bS9pOTE1L2d0L3VjL2ludGVsX2d1Yy5jIGIvZHJpdmVycy9ncHUvZHJtL2k5MTUvZ3QvdWMvaW50 ZWxfZ3VjLmMKaW5kZXggNjY2MWRjYjAyMjM5Li45NzkxMjhlMjgzNzIgMTAwNjQ0Ci0tLSBhL2Ry aXZlcnMvZ3B1L2RybS9pOTE1L2d0L3VjL2ludGVsX2d1Yy5jCisrKyBiL2RyaXZlcnMvZ3B1L2Ry bS9pOTE1L2d0L3VjL2ludGVsX2d1Yy5jCkBAIC0xODAsNiArMTgwLDExIEBAIHZvaWQgaW50ZWxf Z3VjX2luaXRfZWFybHkoc3RydWN0IGludGVsX2d1YyAqZ3VjKQogCX0KIH0KIAordm9pZCBpbnRl bF9ndWNfaW5pdF9sYXRlKHN0cnVjdCBpbnRlbF9ndWMgKmd1YykKK3sKKwlpbnRlbF9ndWNfYWRz X2luaXRfbGF0ZShndWMpOworfQorCiBzdGF0aWMgdTMyIGd1Y19jdGxfZGVidWdfZmxhZ3Moc3Ry dWN0IGludGVsX2d1YyAqZ3VjKQogewogCXUzMiBsZXZlbCA9IGludGVsX2d1Y19sb2dfZ2V0X2xl dmVsKCZndWMtPmxvZyk7CkBAIC01MjQsNjUgKzUyOSwzNSBAQCBpbnQgaW50ZWxfZ3VjX2F1dGhf aHVjKHN0cnVjdCBpbnRlbF9ndWMgKmd1YywgdTMyIHJzYV9vZmZzZXQpCiAgKi8KIGludCBpbnRl bF9ndWNfc3VzcGVuZChzdHJ1Y3QgaW50ZWxfZ3VjICpndWMpCiB7Ci0Jc3RydWN0IGludGVsX3Vu Y29yZSAqdW5jb3JlID0gZ3VjX3RvX2d0KGd1YyktPnVuY29yZTsKIAlpbnQgcmV0OwotCXUzMiBz dGF0dXM7CiAJdTMyIGFjdGlvbltdID0gewotCQlJTlRFTF9HVUNfQUNUSU9OX0VOVEVSX1NfU1RB VEUsCi0JCUdVQ19QT1dFUl9EMSwgLyogYW55IHZhbHVlIGdyZWF0ZXIgdGhhbiBHVUNfUE9XRVJf RDAgKi8KKwkJSU5URUxfR1VDX0FDVElPTl9SRVNFVF9DTElFTlQsCiAJfTsKIAotCS8qCi0JICog SWYgR3VDIGNvbW11bmljYXRpb24gaXMgZW5hYmxlZCBidXQgc3VibWlzc2lvbiBpcyBub3Qgc3Vw cG9ydGVkLAotCSAqIHdlIGRvIG5vdCBuZWVkIHRvIHN1c3BlbmQgdGhlIEd1Qy4KLQkgKi8KLQlp ZiAoIWludGVsX2d1Y19zdWJtaXNzaW9uX2lzX3VzZWQoZ3VjKSB8fCAhaW50ZWxfZ3VjX2lzX3Jl YWR5KGd1YykpCisJaWYgKCFpbnRlbF9ndWNfaXNfcmVhZHkoZ3VjKSkKIAkJcmV0dXJuIDA7CiAK LQkvKgotCSAqIFRoZSBFTlRFUl9TX1NUQVRFIGFjdGlvbiBxdWV1ZXMgdGhlIHNhdmUvcmVzdG9y ZSBvcGVyYXRpb24gaW4gR3VDIEZXCi0JICogYW5kIHRoZW4gcmV0dXJucywgc28gd2FpdGluZyBv biB0aGUgSDJHIGlzIG5vdCBlbm91Z2ggdG8gZ3VhcmFudGVlCi0JICogR3VDIGlzIGRvbmUuIFdo ZW4gYWxsIHRoZSBwcm9jZXNzaW5nIGlzIGRvbmUsIEd1QyB3cml0ZXMKLQkgKiBJTlRFTF9HVUNf U0xFRVBfU1RBVEVfU1VDQ0VTUyB0byBzY3JhdGNoIHJlZ2lzdGVyIDE0LCBzbyB3ZSBjYW4gcG9s bAotCSAqIG9uIHRoYXQuIE5vdGUgdGhhdCBHdUMgZG9lcyBub3QgZW5zdXJlIHRoYXQgdGhlIHZh bHVlIGluIHRoZSByZWdpc3RlcgotCSAqIGlzIGRpZmZlcmVudCBmcm9tIElOVEVMX0dVQ19TTEVF UF9TVEFURV9TVUNDRVNTIHdoaWxlIHRoZSBhY3Rpb24gaXMKLQkgKiBpbiBwcm9ncmVzcyBzbyB3 ZSBuZWVkIHRvIHRha2UgY2FyZSBvZiB0aGF0IG91cnNlbHZlcyBhcyB3ZWxsLgotCSAqLwotCi0J aW50ZWxfdW5jb3JlX3dyaXRlKHVuY29yZSwgU09GVF9TQ1JBVENIKDE0KSwKLQkJCSAgIElOVEVM X0dVQ19TTEVFUF9TVEFURV9JTlZBTElEX01BU0spOwotCi0JcmV0ID0gaW50ZWxfZ3VjX3NlbmQo Z3VjLCBhY3Rpb24sIEFSUkFZX1NJWkUoYWN0aW9uKSk7Ci0JaWYgKHJldCkKLQkJcmV0dXJuIHJl dDsKLQotCXJldCA9IF9faW50ZWxfd2FpdF9mb3JfcmVnaXN0ZXIodW5jb3JlLCBTT0ZUX1NDUkFU Q0goMTQpLAotCQkJCQlJTlRFTF9HVUNfU0xFRVBfU1RBVEVfSU5WQUxJRF9NQVNLLAotCQkJCQkw LCAwLCAxMCwgJnN0YXR1cyk7Ci0JaWYgKHJldCkKLQkJcmV0dXJuIHJldDsKLQotCWlmIChzdGF0 dXMgIT0gSU5URUxfR1VDX1NMRUVQX1NUQVRFX1NVQ0NFU1MpIHsKLQkJRFJNX0VSUk9SKCJHdUMg ZmFpbGVkIHRvIGNoYW5nZSBzbGVlcCBzdGF0ZS4gIgotCQkJICAiYWN0aW9uPTB4JXgsIGVycj0l dVxuIiwKLQkJCSAgYWN0aW9uWzBdLCBzdGF0dXMpOwotCQlyZXR1cm4gLUVJTzsKKwlpZiAoaW50 ZWxfZ3VjX3N1Ym1pc3Npb25faXNfdXNlZChndWMpKSB7CisJCS8qCisJCSAqIFRoaXMgSDJHIE1N SU8gY29tbWFuZCB0ZWFycyBkb3duIHRoZSBHdUMgaW4gdHdvIHN0ZXBzLiBGaXJzdCBpdCB3aWxs CisJCSAqIGdlbmVyYXRlIGEgRzJIIENUQiBmb3IgZXZlcnkgYWN0aXZlIGNvbnRleHQgaW5kaWNh dGluZyBhIHJlc2V0LiBJbgorCQkgKiBwcmFjdGljZSB0aGUgaTkxNSBzaG91bGRuJ3QgZXZlciBn ZXQgYSBHMkggYXMgc3VzcGVuZCBzaG91bGQgb25seSBiZQorCQkgKiBjYWxsZWQgd2hlbiB0aGUg R1BVIGlzIGlkbGUuIE5leHQsIGl0IHRlYXJzIGRvd24gdGhlIENUQnMgYW5kIHRoaXMKKwkJICog SDJHIE1NSU8gY29tbWFuZCBjb21wbGV0ZXMuCisJCSAqCisJCSAqIERvbid0IGFib3J0IG9uIGEg ZmFpbHVyZSBjb2RlIGZyb20gdGhlIEd1Qy4gS2VlcCBnb2luZyBhbmQgZG8gdGhlCisJCSAqIGNs ZWFuIHVwIGluIHNhbnRpemUoKSBhbmQgcmUtaW5pdGlhbGlzYXRpb24gb24gcmVzdW1lIGFuZCBo b3BlZnVsbHkKKwkJICogdGhlIGVycm9yIGhlcmUgd29uJ3QgYmUgcHJvYmxlbWF0aWMuCisJCSAq LworCQlyZXQgPSBpbnRlbF9ndWNfc2VuZF9tbWlvKGd1YywgYWN0aW9uLCBBUlJBWV9TSVpFKGFj dGlvbiksIE5VTEwsIDApOworCQlpZiAocmV0KQorCQkJRFJNX0VSUk9SKCJHdUMgc3VzcGVuZDog UkVTRVRfQ0xJRU5UIGFjdGlvbiBmYWlsZWQgd2l0aCBlcnJvciAlZCFcbiIsIHJldCk7CiAJfQog Ci0JcmV0dXJuIDA7Ci19CisJLyogU2lnbmFsIHRoYXQgdGhlIEd1QyBpc24ndCBydW5uaW5nLiAq LworCWludGVsX2d1Y19zYW5pdGl6ZShndWMpOwogCi0vKioKLSAqIGludGVsX2d1Y19yZXNldF9l bmdpbmUoKSAtIGFzayBHdUMgdG8gcmVzZXQgYW4gZW5naW5lCi0gKiBAZ3VjOglpbnRlbF9ndWMg c3RydWN0dXJlCi0gKiBAZW5naW5lOgllbmdpbmUgdG8gYmUgcmVzZXQKLSAqLwotaW50IGludGVs X2d1Y19yZXNldF9lbmdpbmUoc3RydWN0IGludGVsX2d1YyAqZ3VjLAotCQkJICAgc3RydWN0IGlu dGVsX2VuZ2luZV9jcyAqZW5naW5lKQotewotCS8qIFhYWDogdG8gYmUgaW1wbGVtZW50ZWQgd2l0 aCBzdWJtaXNzaW9uIGludGVyZmFjZSByZXdvcmsgKi8KLQotCXJldHVybiAtRU5PREVWOworCXJl dHVybiAwOwogfQogCiAvKioKQEAgLTU5MSw3ICs1NjYsMTIgQEAgaW50IGludGVsX2d1Y19yZXNl dF9lbmdpbmUoc3RydWN0IGludGVsX2d1YyAqZ3VjLAogICovCiBpbnQgaW50ZWxfZ3VjX3Jlc3Vt ZShzdHJ1Y3QgaW50ZWxfZ3VjICpndWMpCiB7Ci0JLyogWFhYOiB0byBiZSBpbXBsZW1lbnRlZCB3 aXRoIHN1Ym1pc3Npb24gaW50ZXJmYWNlIHJld29yayAqLworCS8qCisJICogTkI6IFRoaXMgZnVu Y3Rpb24gY2FuIHN0aWxsIGJlIGNhbGxlZCBldmVuIGlmIEd1QyBzdWJtaXNzaW9uIGlzCisJICog ZGlzYWJsZWQsIGUuZy4gaWYgR3VDIGlzIGVuYWJsZWQgZm9yIEh1QyBhdXRoZW50aWNhdGlvbiBv bmx5LiBUaHVzLAorCSAqIGlmIGFueSBjb2RlIGlzIGxhdGVyIGFkZGVkIGhlcmUsIGl0IG11c3Qg YmUgc3VwcG9ydCBkb2luZyBub3RoaW5nCisJICogaWYgc3VibWlzc2lvbiBpcyBkaXNhYmxlZCAo YXMgcGVyIGludGVsX2d1Y19zdXNwZW5kKS4KKwkgKi8KIAlyZXR1cm4gMDsKIH0KIApkaWZmIC0t Z2l0IGEvZHJpdmVycy9ncHUvZHJtL2k5MTUvZ3QvdWMvaW50ZWxfZ3VjLmggYi9kcml2ZXJzL2dw dS9kcm0vaTkxNS9ndC91Yy9pbnRlbF9ndWMuaAppbmRleCA3MmU0NjUzMjIyZTIuLjVkOTRjZjQ4 MjUxNiAxMDA2NDQKLS0tIGEvZHJpdmVycy9ncHUvZHJtL2k5MTUvZ3QvdWMvaW50ZWxfZ3VjLmgK KysrIGIvZHJpdmVycy9ncHUvZHJtL2k5MTUvZ3QvdWMvaW50ZWxfZ3VjLmgKQEAgLTYsNiArNiw5 IEBACiAjaWZuZGVmIF9JTlRFTF9HVUNfSF8KICNkZWZpbmUgX0lOVEVMX0dVQ19IXwogCisjaW5j bHVkZSA8bGludXgveGFycmF5Lmg+CisjaW5jbHVkZSA8bGludXgvZGVsYXkuaD4KKwogI2luY2x1 ZGUgImludGVsX3VuY29yZS5oIgogI2luY2x1ZGUgImludGVsX2d1Y19mdy5oIgogI2luY2x1ZGUg ImludGVsX2d1Y19md2lmLmgiCkBAIC0yOCwyMyArMzEsNDMgQEAgc3RydWN0IGludGVsX2d1YyB7 CiAJc3RydWN0IGludGVsX2d1Y19sb2cgbG9nOwogCXN0cnVjdCBpbnRlbF9ndWNfY3QgY3Q7CiAK KwkvKiBHbG9iYWwgZW5naW5lIHVzZWQgdG8gc3VibWl0IHJlcXVlc3RzIHRvIEd1QyAqLworCXN0 cnVjdCBpOTE1X3NjaGVkX2VuZ2luZSAqc2NoZWRfZW5naW5lOworCXN0cnVjdCBpOTE1X3JlcXVl c3QgKnN0YWxsZWRfcmVxdWVzdDsKKwogCS8qIGludGVsX2d1Y19yZWN2IGludGVycnVwdCByZWxh dGVkIHN0YXRlICovCiAJc3BpbmxvY2tfdCBpcnFfbG9jazsKIAl1bnNpZ25lZCBpbnQgbXNnX2Vu YWJsZWRfbWFzazsKIAorCWF0b21pY190IG91dHN0YW5kaW5nX3N1Ym1pc3Npb25fZzJoOworCiAJ c3RydWN0IHsKIAkJdm9pZCAoKnJlc2V0KShzdHJ1Y3QgaW50ZWxfZ3VjICpndWMpOwogCQl2b2lk ICgqZW5hYmxlKShzdHJ1Y3QgaW50ZWxfZ3VjICpndWMpOwogCQl2b2lkICgqZGlzYWJsZSkoc3Ry dWN0IGludGVsX2d1YyAqZ3VjKTsKIAl9IGludGVycnVwdHM7CiAKKwkvKgorCSAqIGNvbnRleHRz X2xvY2sgcHJvdGVjdHMgdGhlIHBvb2wgb2YgZnJlZSBndWMgaWRzIGFuZCBhIGxpbmtlZCBsaXN0 IG9mCisJICogZ3VjIGlkcyBhdmFpbGFibGUgdG8gYmUgc3RvbGVuCisJICovCisJc3BpbmxvY2tf dCBjb250ZXh0c19sb2NrOworCXN0cnVjdCBpZGEgZ3VjX2lkczsKKwlzdHJ1Y3QgbGlzdF9oZWFk IGd1Y19pZF9saXN0OworCisJYm9vbCBzdWJtaXNzaW9uX3N1cHBvcnRlZDsKIAlib29sIHN1Ym1p c3Npb25fc2VsZWN0ZWQ7CiAKIAlzdHJ1Y3QgaTkxNV92bWEgKmFkc192bWE7CiAJc3RydWN0IF9f Z3VjX2Fkc19ibG9iICphZHNfYmxvYjsKKwl1MzIgYWRzX3JlZ3NldF9zaXplOworCXUzMiBhZHNf Z29sZGVuX2N0eHRfc2l6ZTsKKworCXN0cnVjdCBpOTE1X3ZtYSAqbHJjX2Rlc2NfcG9vbDsKKwl2 b2lkICpscmNfZGVzY19wb29sX3ZhZGRyOwogCi0Jc3RydWN0IGk5MTVfdm1hICpzdGFnZV9kZXNj X3Bvb2w7Ci0Jdm9pZCAqc3RhZ2VfZGVzY19wb29sX3ZhZGRyOworCS8qIGd1Y19pZCB0byBpbnRl bF9jb250ZXh0IGxvb2t1cCAqLworCXN0cnVjdCB4YXJyYXkgY29udGV4dF9sb29rdXA7CiAKIAkv KiBDb250cm9sIHBhcmFtcyBmb3IgZncgaW5pdGlhbGl6YXRpb24gKi8KIAl1MzIgcGFyYW1zW0dV Q19DVExfTUFYX0RXT1JEU107CkBAIC03OCwxMCArMTAxLDExIEBAIGlubGluZSBpbnQgaW50ZWxf Z3VjX3NlbmQoc3RydWN0IGludGVsX2d1YyAqZ3VjLCBjb25zdCB1MzIgKmFjdGlvbiwgdTMyIGxl bikKIH0KIAogc3RhdGljCi1pbmxpbmUgaW50IGludGVsX2d1Y19zZW5kX25iKHN0cnVjdCBpbnRl bF9ndWMgKmd1YywgY29uc3QgdTMyICphY3Rpb24sIHUzMiBsZW4pCitpbmxpbmUgaW50IGludGVs X2d1Y19zZW5kX25iKHN0cnVjdCBpbnRlbF9ndWMgKmd1YywgY29uc3QgdTMyICphY3Rpb24sIHUz MiBsZW4sCisJCQkgICAgIHUzMiBnMmhfbGVuX2R3KQogewogCXJldHVybiBpbnRlbF9ndWNfY3Rf c2VuZCgmZ3VjLT5jdCwgYWN0aW9uLCBsZW4sIE5VTEwsIDAsCi0JCQkJIElOVEVMX0dVQ19DVF9T RU5EX05CKTsKKwkJCQkgTUFLRV9TRU5EX0ZMQUdTKGcyaF9sZW5fZHcpKTsKIH0KIAogc3RhdGlj IGlubGluZSBpbnQKQEAgLTkyLDYgKzExNiwzNSBAQCBpbnRlbF9ndWNfc2VuZF9hbmRfcmVjZWl2 ZShzdHJ1Y3QgaW50ZWxfZ3VjICpndWMsIGNvbnN0IHUzMiAqYWN0aW9uLCB1MzIgbGVuLAogCQkJ CSByZXNwb25zZV9idWYsIHJlc3BvbnNlX2J1Zl9zaXplLCAwKTsKIH0KIAorc3RhdGljIGlubGlu ZSBpbnQgaW50ZWxfZ3VjX3NlbmRfYnVzeV9sb29wKHN0cnVjdCBpbnRlbF9ndWMqIGd1YywKKwkJ CQkJICAgY29uc3QgdTMyICphY3Rpb24sCisJCQkJCSAgIHUzMiBsZW4sCisJCQkJCSAgIHUzMiBn MmhfbGVuX2R3LAorCQkJCQkgICBib29sIGxvb3ApCit7CisJaW50IGVycjsKKwl1bnNpZ25lZCBp bnQgc2xlZXBfcGVyaW9kX21zID0gMTsKKwlib29sIG5vdF9hdG9taWMgPSAhaW5fYXRvbWljKCkg JiYgIWlycXNfZGlzYWJsZWQoKTsKKworCS8qIE5vIHNsZWVwaW5nIHdpdGggc3BpbiBsb2Nrcywg anVzdCBidXN5IGxvb3AgKi8KKwltaWdodF9zbGVlcF9pZihsb29wICYmIG5vdF9hdG9taWMpOwor CityZXRyeToKKwllcnIgPSBpbnRlbF9ndWNfc2VuZF9uYihndWMsIGFjdGlvbiwgbGVuLCBnMmhf bGVuX2R3KTsKKwlpZiAodW5saWtlbHkoZXJyID09IC1FQlVTWSAmJiBsb29wKSkgeworCQlpZiAo bGlrZWx5KG5vdF9hdG9taWMpKSB7CisJCQlpZiAobXNsZWVwX2ludGVycnVwdGlibGUoc2xlZXBf cGVyaW9kX21zKSkKKwkJCQlyZXR1cm4gLUVJTlRSOworCQkJc2xlZXBfcGVyaW9kX21zID0gc2xl ZXBfcGVyaW9kX21zIDw8IDE7CisJCX0gZWxzZSB7CisJCQljcHVfcmVsYXgoKTsKKwkJfQorCQln b3RvIHJldHJ5OworCX0KKworCXJldHVybiBlcnI7Cit9CisKIHN0YXRpYyBpbmxpbmUgdm9pZCBp bnRlbF9ndWNfdG9faG9zdF9ldmVudF9oYW5kbGVyKHN0cnVjdCBpbnRlbF9ndWMgKmd1YykKIHsK IAlpbnRlbF9ndWNfY3RfZXZlbnRfaGFuZGxlcigmZ3VjLT5jdCk7CkBAIC0xMjUsNiArMTc4LDcg QEAgc3RhdGljIGlubGluZSB1MzIgaW50ZWxfZ3VjX2dndHRfb2Zmc2V0KHN0cnVjdCBpbnRlbF9n dWMgKmd1YywKIH0KIAogdm9pZCBpbnRlbF9ndWNfaW5pdF9lYXJseShzdHJ1Y3QgaW50ZWxfZ3Vj ICpndWMpOwordm9pZCBpbnRlbF9ndWNfaW5pdF9sYXRlKHN0cnVjdCBpbnRlbF9ndWMgKmd1Yyk7 CiB2b2lkIGludGVsX2d1Y19pbml0X3NlbmRfcmVncyhzdHJ1Y3QgaW50ZWxfZ3VjICpndWMpOwog dm9pZCBpbnRlbF9ndWNfd3JpdGVfcGFyYW1zKHN0cnVjdCBpbnRlbF9ndWMgKmd1Yyk7CiBpbnQg aW50ZWxfZ3VjX2luaXQoc3RydWN0IGludGVsX2d1YyAqZ3VjKTsKQEAgLTE2Nyw5ICsyMjEsMjUg QEAgc3RhdGljIGlubGluZSBib29sIGludGVsX2d1Y19pc19yZWFkeShzdHJ1Y3QgaW50ZWxfZ3Vj ICpndWMpCiAJcmV0dXJuIGludGVsX2d1Y19pc19md19ydW5uaW5nKGd1YykgJiYgaW50ZWxfZ3Vj X2N0X2VuYWJsZWQoJmd1Yy0+Y3QpOwogfQogCitzdGF0aWMgaW5saW5lIHZvaWQgaW50ZWxfZ3Vj X3Jlc2V0X2ludGVycnVwdHMoc3RydWN0IGludGVsX2d1YyAqZ3VjKQoreworCWd1Yy0+aW50ZXJy dXB0cy5yZXNldChndWMpOworfQorCitzdGF0aWMgaW5saW5lIHZvaWQgaW50ZWxfZ3VjX2VuYWJs ZV9pbnRlcnJ1cHRzKHN0cnVjdCBpbnRlbF9ndWMgKmd1YykKK3sKKwlndWMtPmludGVycnVwdHMu ZW5hYmxlKGd1Yyk7Cit9CisKK3N0YXRpYyBpbmxpbmUgdm9pZCBpbnRlbF9ndWNfZGlzYWJsZV9p bnRlcnJ1cHRzKHN0cnVjdCBpbnRlbF9ndWMgKmd1YykKK3sKKwlndWMtPmludGVycnVwdHMuZGlz YWJsZShndWMpOworfQorCiBzdGF0aWMgaW5saW5lIGludCBpbnRlbF9ndWNfc2FuaXRpemUoc3Ry dWN0IGludGVsX2d1YyAqZ3VjKQogewogCWludGVsX3VjX2Z3X3Nhbml0aXplKCZndWMtPmZ3KTsK KwlpbnRlbF9ndWNfZGlzYWJsZV9pbnRlcnJ1cHRzKGd1Yyk7CiAJaW50ZWxfZ3VjX2N0X3Nhbml0 aXplKCZndWMtPmN0KTsKIAlndWMtPm1taW9fbXNnID0gMDsKIApAQCAtMTkwLDggKzI2MCwyNyBA QCBzdGF0aWMgaW5saW5lIHZvaWQgaW50ZWxfZ3VjX2Rpc2FibGVfbXNnKHN0cnVjdCBpbnRlbF9n dWMgKmd1YywgdTMyIG1hc2spCiAJc3Bpbl91bmxvY2tfaXJxKCZndWMtPmlycV9sb2NrKTsKIH0K IAotaW50IGludGVsX2d1Y19yZXNldF9lbmdpbmUoc3RydWN0IGludGVsX2d1YyAqZ3VjLAotCQkJ ICAgc3RydWN0IGludGVsX2VuZ2luZV9jcyAqZW5naW5lKTsKK2ludCBpbnRlbF9ndWNfd2FpdF9m b3JfaWRsZShzdHJ1Y3QgaW50ZWxfZ3VjICpndWMsIGxvbmcgdGltZW91dCk7CisKK2ludCBpbnRl bF9ndWNfZGVyZWdpc3Rlcl9kb25lX3Byb2Nlc3NfbXNnKHN0cnVjdCBpbnRlbF9ndWMgKmd1YywK KwkJCQkJICBjb25zdCB1MzIgKm1zZywgdTMyIGxlbik7CitpbnQgaW50ZWxfZ3VjX3NjaGVkX2Rv bmVfcHJvY2Vzc19tc2coc3RydWN0IGludGVsX2d1YyAqZ3VjLAorCQkJCSAgICAgY29uc3QgdTMy ICptc2csIHUzMiBsZW4pOworaW50IGludGVsX2d1Y19jb250ZXh0X3Jlc2V0X3Byb2Nlc3NfbXNn KHN0cnVjdCBpbnRlbF9ndWMgKmd1YywKKwkJCQkJY29uc3QgdTMyICptc2csIHUzMiBsZW4pOwor aW50IGludGVsX2d1Y19lbmdpbmVfZmFpbHVyZV9wcm9jZXNzX21zZyhzdHJ1Y3QgaW50ZWxfZ3Vj ICpndWMsCisJCQkJCSBjb25zdCB1MzIgKm1zZywgdTMyIGxlbik7CisKK3ZvaWQgaW50ZWxfZ3Vj X2ZpbmRfaHVuZ19jb250ZXh0KHN0cnVjdCBpbnRlbF9lbmdpbmVfY3MgKmVuZ2luZSk7CisKK2lu dCBpbnRlbF9ndWNfZ2xvYmFsX3BvbGljaWVzX3VwZGF0ZShzdHJ1Y3QgaW50ZWxfZ3VjICpndWMp OworCit2b2lkIGludGVsX2d1Y19jb250ZXh0X2JhbihzdHJ1Y3QgaW50ZWxfY29udGV4dCAqY2Us IHN0cnVjdCBpOTE1X3JlcXVlc3QgKnJxKTsKKwordm9pZCBpbnRlbF9ndWNfc3VibWlzc2lvbl9y ZXNldF9wcmVwYXJlKHN0cnVjdCBpbnRlbF9ndWMgKmd1Yyk7Cit2b2lkIGludGVsX2d1Y19zdWJt aXNzaW9uX3Jlc2V0KHN0cnVjdCBpbnRlbF9ndWMgKmd1YywgYm9vbCBzdGFsbGVkKTsKK3ZvaWQg aW50ZWxfZ3VjX3N1Ym1pc3Npb25fcmVzZXRfZmluaXNoKHN0cnVjdCBpbnRlbF9ndWMgKmd1Yyk7 Cit2b2lkIGludGVsX2d1Y19zdWJtaXNzaW9uX2NhbmNlbF9yZXF1ZXN0cyhzdHJ1Y3QgaW50ZWxf Z3VjICpndWMpOwogCiB2b2lkIGludGVsX2d1Y19sb2FkX3N0YXR1cyhzdHJ1Y3QgaW50ZWxfZ3Vj ICpndWMsIHN0cnVjdCBkcm1fcHJpbnRlciAqcCk7CiAKZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1 L2RybS9pOTE1L2d0L3VjL2ludGVsX2d1Y19hZHMuYyBiL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2d0 L3VjL2ludGVsX2d1Y19hZHMuYwppbmRleCBiODIxNDU2NTJkNTcuLmM1NjMwMmRlZGIzMiAxMDA2 NDQKLS0tIGEvZHJpdmVycy9ncHUvZHJtL2k5MTUvZ3QvdWMvaW50ZWxfZ3VjX2Fkcy5jCisrKyBi L2RyaXZlcnMvZ3B1L2RybS9pOTE1L2d0L3VjL2ludGVsX2d1Y19hZHMuYwpAQCAtMyw4ICszLDEx IEBACiAgKiBDb3B5cmlnaHQgwqkgMjAxNC0yMDE5IEludGVsIENvcnBvcmF0aW9uCiAgKi8KIAor I2luY2x1ZGUgPGxpbnV4L2JzZWFyY2guaD4KKwogI2luY2x1ZGUgImd0L2ludGVsX2d0LmgiCiAj aW5jbHVkZSAiZ3QvaW50ZWxfbHJjLmgiCisjaW5jbHVkZSAiZ3Qvc2htZW1fdXRpbHMuaCIKICNp bmNsdWRlICJpbnRlbF9ndWNfYWRzLmgiCiAjaW5jbHVkZSAiaW50ZWxfZ3VjX2Z3aWYuaCIKICNp bmNsdWRlICJpbnRlbF91Yy5oIgpAQCAtMjMsNiArMjYsMTUgQEAKICAqICAgICAgfCBndWNfcG9s aWNpZXMgICAgICAgICAgICAgICAgICAgICAgICAgIHwKICAqICAgICAgKy0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLSsKICAqICAgICAgfCBndWNfZ3Rfc3lzdGVtX2luZm8g ICAgICAgICAgICAgICAgICAgIHwKKyAqICAgICAgKy0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLSsgPD09IHN0YXRpYworICogICAgICB8IGd1Y19tbWlvX3JlZ1tjb3VudEFd IChlbmdpbmUgMC4wKSAgICAgfAorICogICAgICB8IGd1Y19tbWlvX3JlZ1tjb3VudEJdIChlbmdp bmUgMC4xKSAgICAgfAorICogICAgICB8IGd1Y19tbWlvX3JlZ1tjb3VudENdIChlbmdpbmUgMS4w KSAgICAgfAorICogICAgICB8ICAgLi4uICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg fAorICogICAgICArLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tKyA8PT0g ZHluYW1pYworICogICAgICB8IHBhZGRpbmcgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg fAorICogICAgICArLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tKyA8PT0g NEsgYWxpZ25lZAorICogICAgICB8IGdvbGRlbiBjb250ZXh0cyAgICAgICAgICAgICAgICAgICAg ICAgfAogICogICAgICArLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tKwog ICogICAgICB8IHBhZGRpbmcgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgfAogICogICAg ICArLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tKyA8PT0gNEsgYWxpZ25l ZApAQCAtMzUsMTYgKzQ3LDQ5IEBAIHN0cnVjdCBfX2d1Y19hZHNfYmxvYiB7CiAJc3RydWN0IGd1 Y19hZHMgYWRzOwogCXN0cnVjdCBndWNfcG9saWNpZXMgcG9saWNpZXM7CiAJc3RydWN0IGd1Y19n dF9zeXN0ZW1faW5mbyBzeXN0ZW1faW5mbzsKKwkvKiBGcm9tIGhlcmUgb24sIGxvY2F0aW9uIGlz IGR5bmFtaWMhIFJlZmVyIHRvIGFib3ZlIGRpYWdyYW0uICovCisJc3RydWN0IGd1Y19tbWlvX3Jl ZyByZWdzZXRbMF07CiB9IF9fcGFja2VkOwogCitzdGF0aWMgdTMyIGd1Y19hZHNfcmVnc2V0X3Np emUoc3RydWN0IGludGVsX2d1YyAqZ3VjKQoreworCUdFTV9CVUdfT04oIWd1Yy0+YWRzX3JlZ3Nl dF9zaXplKTsKKwlyZXR1cm4gZ3VjLT5hZHNfcmVnc2V0X3NpemU7Cit9CisKK3N0YXRpYyB1MzIg Z3VjX2Fkc19nb2xkZW5fY3R4dF9zaXplKHN0cnVjdCBpbnRlbF9ndWMgKmd1YykKK3sKKwlyZXR1 cm4gUEFHRV9BTElHTihndWMtPmFkc19nb2xkZW5fY3R4dF9zaXplKTsKK30KKwogc3RhdGljIHUz MiBndWNfYWRzX3ByaXZhdGVfZGF0YV9zaXplKHN0cnVjdCBpbnRlbF9ndWMgKmd1YykKIHsKIAly ZXR1cm4gUEFHRV9BTElHTihndWMtPmZ3LnByaXZhdGVfZGF0YV9zaXplKTsKIH0KIAorc3RhdGlj IHUzMiBndWNfYWRzX3JlZ3NldF9vZmZzZXQoc3RydWN0IGludGVsX2d1YyAqZ3VjKQoreworCXJl dHVybiBvZmZzZXRvZihzdHJ1Y3QgX19ndWNfYWRzX2Jsb2IsIHJlZ3NldCk7Cit9CisKK3N0YXRp YyB1MzIgZ3VjX2Fkc19nb2xkZW5fY3R4dF9vZmZzZXQoc3RydWN0IGludGVsX2d1YyAqZ3VjKQor eworCXUzMiBvZmZzZXQ7CisKKwlvZmZzZXQgPSBndWNfYWRzX3JlZ3NldF9vZmZzZXQoZ3VjKSAr CisJCSBndWNfYWRzX3JlZ3NldF9zaXplKGd1Yyk7CisKKwlyZXR1cm4gUEFHRV9BTElHTihvZmZz ZXQpOworfQorCiBzdGF0aWMgdTMyIGd1Y19hZHNfcHJpdmF0ZV9kYXRhX29mZnNldChzdHJ1Y3Qg aW50ZWxfZ3VjICpndWMpCiB7Ci0JcmV0dXJuIFBBR0VfQUxJR04oc2l6ZW9mKHN0cnVjdCBfX2d1 Y19hZHNfYmxvYikpOworCXUzMiBvZmZzZXQ7CisKKwlvZmZzZXQgPSBndWNfYWRzX2dvbGRlbl9j dHh0X29mZnNldChndWMpICsKKwkJIGd1Y19hZHNfZ29sZGVuX2N0eHRfc2l6ZShndWMpOworCisJ cmV0dXJuIFBBR0VfQUxJR04ob2Zmc2V0KTsKIH0KIAogc3RhdGljIHUzMiBndWNfYWRzX2Jsb2Jf c2l6ZShzdHJ1Y3QgaW50ZWxfZ3VjICpndWMpCkBAIC01MywxNSArOTgsNjggQEAgc3RhdGljIHUz MiBndWNfYWRzX2Jsb2Jfc2l6ZShzdHJ1Y3QgaW50ZWxfZ3VjICpndWMpCiAJICAgICAgIGd1Y19h ZHNfcHJpdmF0ZV9kYXRhX3NpemUoZ3VjKTsKIH0KIAotc3RhdGljIHZvaWQgZ3VjX3BvbGljaWVz X2luaXQoc3RydWN0IGd1Y19wb2xpY2llcyAqcG9saWNpZXMpCitzdGF0aWMgdm9pZCBndWNfcG9s aWNpZXNfaW5pdChzdHJ1Y3QgaW50ZWxfZ3VjICpndWMsIHN0cnVjdCBndWNfcG9saWNpZXMgKnBv bGljaWVzKQogeworCXN0cnVjdCBpbnRlbF9ndCAqZ3QgPSBndWNfdG9fZ3QoZ3VjKTsKKwlzdHJ1 Y3QgZHJtX2k5MTVfcHJpdmF0ZSAqaTkxNSA9IGd0LT5pOTE1OworCiAJcG9saWNpZXMtPmRwY19w cm9tb3RlX3RpbWUgPSBHTE9CQUxfUE9MSUNZX0RFRkFVTFRfRFBDX1BST01PVEVfVElNRV9VUzsK IAlwb2xpY2llcy0+bWF4X251bV93b3JrX2l0ZW1zID0gR0xPQkFMX1BPTElDWV9NQVhfTlVNX1dJ OwotCS8qIERpc2FibGUgYXV0b21hdGljIHJlc2V0cyBhcyBub3QgeWV0IHN1cHBvcnRlZC4gKi8K LQlwb2xpY2llcy0+Z2xvYmFsX2ZsYWdzID0gR0xPQkFMX1BPTElDWV9ESVNBQkxFX0VOR0lORV9S RVNFVDsKKworCXBvbGljaWVzLT5nbG9iYWxfZmxhZ3MgPSAwOworCWlmIChpOTE1LT5wYXJhbXMu cmVzZXQgPCAyKQorCQlwb2xpY2llcy0+Z2xvYmFsX2ZsYWdzIHw9IEdMT0JBTF9QT0xJQ1lfRElT QUJMRV9FTkdJTkVfUkVTRVQ7CisKIAlwb2xpY2llcy0+aXNfdmFsaWQgPSAxOwogfQogCit2b2lk IGludGVsX2d1Y19hZHNfcHJpbnRfcG9saWN5X2luZm8oc3RydWN0IGludGVsX2d1YyAqZ3VjLAor CQkJCSAgICAgc3RydWN0IGRybV9wcmludGVyICpkcCkKK3sKKwlzdHJ1Y3QgX19ndWNfYWRzX2Js b2IgKmJsb2IgPSBndWMtPmFkc19ibG9iOworCisJaWYgKHVubGlrZWx5KCFibG9iKSkKKwkJcmV0 dXJuOworCisJZHJtX3ByaW50ZihkcCwgIkdsb2JhbCBzY2hlZHVsaW5nIHBvbGljaWVzOlxuIik7 CisJZHJtX3ByaW50ZihkcCwgIiAgRFBDIHByb21vdGUgdGltZSAgID0gJXVcbiIsIGJsb2ItPnBv bGljaWVzLmRwY19wcm9tb3RlX3RpbWUpOworCWRybV9wcmludGYoZHAsICIgIE1heCBudW0gd29y ayBpdGVtcyA9ICV1XG4iLCBibG9iLT5wb2xpY2llcy5tYXhfbnVtX3dvcmtfaXRlbXMpOworCWRy bV9wcmludGYoZHAsICIgIEZsYWdzICAgICAgICAgICAgICA9ICV1XG4iLCBibG9iLT5wb2xpY2ll cy5nbG9iYWxfZmxhZ3MpOworfQorCitzdGF0aWMgaW50IGd1Y19hY3Rpb25fcG9saWNpZXNfdXBk YXRlKHN0cnVjdCBpbnRlbF9ndWMgKmd1YywgdTMyIHBvbGljeV9vZmZzZXQpCit7CisJdTMyIGFj dGlvbltdID0geworCQlJTlRFTF9HVUNfQUNUSU9OX0dMT0JBTF9TQ0hFRF9QT0xJQ1lfQ0hBTkdF LAorCQlwb2xpY3lfb2Zmc2V0CisJfTsKKworCXJldHVybiBpbnRlbF9ndWNfc2VuZF9idXN5X2xv b3AoZ3VjLCBhY3Rpb24sIEFSUkFZX1NJWkUoYWN0aW9uKSwgMCwgdHJ1ZSk7Cit9CisKK2ludCBp bnRlbF9ndWNfZ2xvYmFsX3BvbGljaWVzX3VwZGF0ZShzdHJ1Y3QgaW50ZWxfZ3VjICpndWMpCit7 CisJc3RydWN0IF9fZ3VjX2Fkc19ibG9iICpibG9iID0gZ3VjLT5hZHNfYmxvYjsKKwlzdHJ1Y3Qg aW50ZWxfZ3QgKmd0ID0gZ3VjX3RvX2d0KGd1Yyk7CisJaW50ZWxfd2FrZXJlZl90IHdha2VyZWY7 CisJaW50IHJldDsKKworCWlmICghYmxvYikKKwkJcmV0dXJuIC1FTk9UU1VQUDsKKworCUdFTV9C VUdfT04oIWJsb2ItPmFkcy5zY2hlZHVsZXJfcG9saWNpZXMpOworCisJZ3VjX3BvbGljaWVzX2lu aXQoZ3VjLCAmYmxvYi0+cG9saWNpZXMpOworCisJaWYgKCFpbnRlbF9ndWNfaXNfcmVhZHkoZ3Vj KSkKKwkJcmV0dXJuIDA7CisKKwl3aXRoX2ludGVsX3J1bnRpbWVfcG0oJmd0LT5pOTE1LT5ydW50 aW1lX3BtLCB3YWtlcmVmKQorCQlyZXQgPSBndWNfYWN0aW9uX3BvbGljaWVzX3VwZGF0ZShndWMs IGJsb2ItPmFkcy5zY2hlZHVsZXJfcG9saWNpZXMpOworCisJcmV0dXJuIHJldDsKK30KKwogc3Rh dGljIHZvaWQgZ3VjX21hcHBpbmdfdGFibGVfaW5pdChzdHJ1Y3QgaW50ZWxfZ3QgKmd0LAogCQkJ CSAgIHN0cnVjdCBndWNfZ3Rfc3lzdGVtX2luZm8gKnN5c3RlbV9pbmZvKQogewpAQCAtODQsNTMg KzE4MiwzMjMgQEAgc3RhdGljIHZvaWQgZ3VjX21hcHBpbmdfdGFibGVfaW5pdChzdHJ1Y3QgaW50 ZWxfZ3QgKmd0LAogfQogCiAvKgotICogVGhlIGZpcnN0IDgwIGR3b3JkcyBvZiB0aGUgcmVnaXN0 ZXIgc3RhdGUgY29udGV4dCwgY29udGFpbmluZyB0aGUKLSAqIGV4ZWNsaXN0cyBhbmQgcHBndHQg cmVnaXN0ZXJzLgorICogVGhlIHNhdmUvcmVzdG9yZSByZWdpc3RlciBsaXN0IG11c3QgYmUgcHJl LWNhbGN1bGF0ZWQgdG8gYSB0ZW1wb3JhcnkKKyAqIGJ1ZmZlciBvZiBkcml2ZXIgZGVmaW5lZCBz aXplIGJlZm9yZSBpdCBjYW4gYmUgZ2VuZXJhdGVkIGluIHBsYWNlCisgKiBpbnNpZGUgdGhlIEFE Uy4KICAqLwotI2RlZmluZSBMUl9IV19DT05URVhUX1NJWkUJKDgwICogc2l6ZW9mKHUzMikpCisj ZGVmaW5lIE1BWF9NTUlPX1JFR1MJMTI4CS8qIEFyYml0cmFyeSBzaXplLCBpbmNyZWFzZSBhcyBu ZWVkZWQgKi8KK3N0cnVjdCB0ZW1wX3JlZ3NldCB7CisJc3RydWN0IGd1Y19tbWlvX3JlZyAqcmVn aXN0ZXJzOworCXUzMiB1c2VkOworCXUzMiBzaXplOworfTsKIAotc3RhdGljIHZvaWQgX19ndWNf YWRzX2luaXQoc3RydWN0IGludGVsX2d1YyAqZ3VjKQorc3RhdGljIGludCBndWNfbW1pb19yZWdf Y21wKGNvbnN0IHZvaWQgKmEsIGNvbnN0IHZvaWQgKmIpCit7CisJY29uc3Qgc3RydWN0IGd1Y19t bWlvX3JlZyAqcmEgPSBhOworCWNvbnN0IHN0cnVjdCBndWNfbW1pb19yZWcgKnJiID0gYjsKKwor CXJldHVybiAoaW50KXJhLT5vZmZzZXQgLSAoaW50KXJiLT5vZmZzZXQ7Cit9CisKK3N0YXRpYyB2 b2lkIGd1Y19tbWlvX3JlZ19hZGQoc3RydWN0IHRlbXBfcmVnc2V0ICpyZWdzZXQsCisJCQkgICAg IHUzMiBvZmZzZXQsIHUzMiBmbGFncykKK3sKKwl1MzIgY291bnQgPSByZWdzZXQtPnVzZWQ7CisJ c3RydWN0IGd1Y19tbWlvX3JlZyByZWcgPSB7CisJCS5vZmZzZXQgPSBvZmZzZXQsCisJCS5mbGFn cyA9IGZsYWdzLAorCX07CisJc3RydWN0IGd1Y19tbWlvX3JlZyAqc2xvdDsKKworCUdFTV9CVUdf T04oY291bnQgPj0gcmVnc2V0LT5zaXplKTsKKworCS8qCisJICogVGhlIG1taW8gbGlzdCBpcyBi dWlsdCB1c2luZyBzZXBhcmF0ZSBsaXN0cyB3aXRoaW4gdGhlIGRyaXZlci4KKwkgKiBJdCdzIHBv c3NpYmxlIHRoYXQgYXQgc29tZSBwb2ludCB3ZSBtYXkgYXR0ZW1wdCB0byBhZGQgdGhlIHNhbWUK KwkgKiByZWdpc3RlciBtb3JlIHRoYW4gb25jZS4gRG8gbm90IGNvbnNpZGVyIHRoaXMgYW4gZXJy b3I7IHNpbGVudGx5CisJICogbW92ZSBvbiBpZiB0aGUgcmVnaXN0ZXIgaXMgYWxyZWFkeSBpbiB0 aGUgbGlzdC4KKwkgKi8KKwlpZiAoYnNlYXJjaCgmcmVnLCByZWdzZXQtPnJlZ2lzdGVycywgY291 bnQsCisJCSAgICBzaXplb2YocmVnKSwgZ3VjX21taW9fcmVnX2NtcCkpCisJCXJldHVybjsKKwor CXNsb3QgPSAmcmVnc2V0LT5yZWdpc3RlcnNbY291bnRdOworCXJlZ3NldC0+dXNlZCsrOworCSpz bG90ID0gcmVnOworCisJd2hpbGUgKHNsb3QtLSA+IHJlZ3NldC0+cmVnaXN0ZXJzKSB7CisJCUdF TV9CVUdfT04oc2xvdFswXS5vZmZzZXQgPT0gc2xvdFsxXS5vZmZzZXQpOworCQlpZiAoc2xvdFsx XS5vZmZzZXQgPiBzbG90WzBdLm9mZnNldCkKKwkJCWJyZWFrOworCisJCXN3YXAoc2xvdFsxXSwg c2xvdFswXSk7CisJfQorfQorCisjZGVmaW5lIEdVQ19NTUlPX1JFR19BREQocmVnc2V0LCByZWcs IG1hc2tlZCkgXAorCWd1Y19tbWlvX3JlZ19hZGQocmVnc2V0LCBcCisJCQkgaTkxNV9tbWlvX3Jl Z19vZmZzZXQoKHJlZykpLCBcCisJCQkgKG1hc2tlZCkgPyBHVUNfUkVHU0VUX01BU0tFRCA6IDAp CisKK3N0YXRpYyB2b2lkIGd1Y19tbWlvX3JlZ3NldF9pbml0KHN0cnVjdCB0ZW1wX3JlZ3NldCAq cmVnc2V0LAorCQkJCSBzdHJ1Y3QgaW50ZWxfZW5naW5lX2NzICplbmdpbmUpCit7CisJY29uc3Qg dTMyIGJhc2UgPSBlbmdpbmUtPm1taW9fYmFzZTsKKwlzdHJ1Y3QgaTkxNV93YV9saXN0ICp3YWwg PSAmZW5naW5lLT53YV9saXN0OworCXN0cnVjdCBpOTE1X3dhICp3YTsKKwl1bnNpZ25lZCBpbnQg aTsKKworCXJlZ3NldC0+dXNlZCA9IDA7CisKKwlHVUNfTU1JT19SRUdfQUREKHJlZ3NldCwgUklO R19NT0RFX0dFTjcoYmFzZSksIHRydWUpOworCUdVQ19NTUlPX1JFR19BREQocmVnc2V0LCBSSU5H X0hXU19QR0EoYmFzZSksIGZhbHNlKTsKKwlHVUNfTU1JT19SRUdfQUREKHJlZ3NldCwgUklOR19J TVIoYmFzZSksIGZhbHNlKTsKKworCWZvciAoaSA9IDAsIHdhID0gd2FsLT5saXN0OyBpIDwgd2Fs LT5jb3VudDsgaSsrLCB3YSsrKQorCQlHVUNfTU1JT19SRUdfQUREKHJlZ3NldCwgd2EtPnJlZywg d2EtPm1hc2tlZF9yZWcpOworCisJLyogQmUgZXh0cmEgcGFyYW5vaWQgYW5kIGluY2x1ZGUgYWxs IHdoaXRlbGlzdCByZWdpc3RlcnMuICovCisJZm9yIChpID0gMDsgaSA8IFJJTkdfTUFYX05PTlBS SVZfU0xPVFM7IGkrKykKKwkJR1VDX01NSU9fUkVHX0FERChyZWdzZXQsCisJCQkJIFJJTkdfRk9S Q0VfVE9fTk9OUFJJVihiYXNlLCBpKSwKKwkJCQkgZmFsc2UpOworCisJLyogYWRkIGluIGxvY2Fs IE1PQ1MgcmVnaXN0ZXJzICovCisJZm9yIChpID0gMDsgaSA8IEdFTjlfTE5DRkNNT0NTX1JFR19D T1VOVDsgaSsrKQorCQlHVUNfTU1JT19SRUdfQUREKHJlZ3NldCwgR0VOOV9MTkNGQ01PQ1MoaSks IGZhbHNlKTsKK30KKworc3RhdGljIGludCBndWNfbW1pb19yZWdfc3RhdGVfcXVlcnkoc3RydWN0 IGludGVsX2d1YyAqZ3VjKQogewogCXN0cnVjdCBpbnRlbF9ndCAqZ3QgPSBndWNfdG9fZ3QoZ3Vj KTsKLQlzdHJ1Y3QgZHJtX2k5MTVfcHJpdmF0ZSAqaTkxNSA9IGd0LT5pOTE1OworCXN0cnVjdCBp bnRlbF9lbmdpbmVfY3MgKmVuZ2luZTsKKwllbnVtIGludGVsX2VuZ2luZV9pZCBpZDsKKwlzdHJ1 Y3QgdGVtcF9yZWdzZXQgdGVtcF9zZXQ7CisJdTMyIHRvdGFsOworCisJLyoKKwkgKiBOZWVkIHRv IGFjdHVhbGx5IGJ1aWxkIHRoZSBsaXN0IGluIG9yZGVyIHRvIGZpbHRlciBvdXQKKwkgKiBkdXBs aWNhdGVzIGFuZCBvdGhlciBzdWNoIGRhdGEgZGVwZW5kZW50IGNvbnN0cnVjdGlvbnMuCisJICov CisJdGVtcF9zZXQuc2l6ZSA9IE1BWF9NTUlPX1JFR1M7CisJdGVtcF9zZXQucmVnaXN0ZXJzID0g a21hbGxvY19hcnJheSh0ZW1wX3NldC5zaXplLAorCQkJCQkgIHNpemVvZigqdGVtcF9zZXQucmVn aXN0ZXJzKSwKKwkJCQkJICBHRlBfS0VSTkVMKTsKKwlpZiAoIXRlbXBfc2V0LnJlZ2lzdGVycykK KwkJcmV0dXJuIC1FTk9NRU07CisKKwl0b3RhbCA9IDA7CisJZm9yX2VhY2hfZW5naW5lKGVuZ2lu ZSwgZ3QsIGlkKSB7CisJCWd1Y19tbWlvX3JlZ3NldF9pbml0KCZ0ZW1wX3NldCwgZW5naW5lKTsK KwkJdG90YWwgKz0gdGVtcF9zZXQudXNlZDsKKwl9CisKKwlrZnJlZSh0ZW1wX3NldC5yZWdpc3Rl cnMpOworCisJcmV0dXJuIHRvdGFsICogc2l6ZW9mKHN0cnVjdCBndWNfbW1pb19yZWcpOworfQor CitzdGF0aWMgdm9pZCBndWNfbW1pb19yZWdfc3RhdGVfaW5pdChzdHJ1Y3QgaW50ZWxfZ3VjICpn dWMsCisJCQkJICAgIHN0cnVjdCBfX2d1Y19hZHNfYmxvYiAqYmxvYikKK3sKKwlzdHJ1Y3QgaW50 ZWxfZ3QgKmd0ID0gZ3VjX3RvX2d0KGd1Yyk7CisJc3RydWN0IGludGVsX2VuZ2luZV9jcyAqZW5n aW5lOworCWVudW0gaW50ZWxfZW5naW5lX2lkIGlkOworCXN0cnVjdCB0ZW1wX3JlZ3NldCB0ZW1w X3NldDsKKwlzdHJ1Y3QgZ3VjX21taW9fcmVnX3NldCAqYWRzX3JlZ19zZXQ7CisJdTMyIGFkZHJf Z2d0dCwgb2Zmc2V0OworCXU4IGd1Y19jbGFzczsKKworCW9mZnNldCA9IGd1Y19hZHNfcmVnc2V0 X29mZnNldChndWMpOworCWFkZHJfZ2d0dCA9IGludGVsX2d1Y19nZ3R0X29mZnNldChndWMsIGd1 Yy0+YWRzX3ZtYSkgKyBvZmZzZXQ7CisJdGVtcF9zZXQucmVnaXN0ZXJzID0gKHN0cnVjdCBndWNf bW1pb19yZWcgKikgKCgodTggKikgYmxvYikgKyBvZmZzZXQpOworCXRlbXBfc2V0LnNpemUgPSBn dWMtPmFkc19yZWdzZXRfc2l6ZSAvIHNpemVvZih0ZW1wX3NldC5yZWdpc3RlcnNbMF0pOworCisJ Zm9yX2VhY2hfZW5naW5lKGVuZ2luZSwgZ3QsIGlkKSB7CisJCS8qIENsYXNzIGluZGV4IGlzIGNo ZWNrZWQgaW4gY2xhc3MgY29udmVydGVyICovCisJCUdFTV9CVUdfT04oZW5naW5lLT5pbnN0YW5j ZSA+PSBHVUNfTUFYX0lOU1RBTkNFU19QRVJfQ0xBU1MpOworCisJCWd1Y19jbGFzcyA9IGVuZ2lu ZV9jbGFzc190b19ndWNfY2xhc3MoZW5naW5lLT5jbGFzcyk7CisJCWFkc19yZWdfc2V0ID0gJmJs b2ItPmFkcy5yZWdfc3RhdGVfbGlzdFtndWNfY2xhc3NdW2VuZ2luZS0+aW5zdGFuY2VdOworCisJ CWd1Y19tbWlvX3JlZ3NldF9pbml0KCZ0ZW1wX3NldCwgZW5naW5lKTsKKwkJaWYgKCF0ZW1wX3Nl dC51c2VkKSB7CisJCQlhZHNfcmVnX3NldC0+YWRkcmVzcyA9IDA7CisJCQlhZHNfcmVnX3NldC0+ Y291bnQgPSAwOworCQkJY29udGludWU7CisJCX0KKworCQlhZHNfcmVnX3NldC0+YWRkcmVzcyA9 IGFkZHJfZ2d0dDsKKwkJYWRzX3JlZ19zZXQtPmNvdW50ID0gdGVtcF9zZXQudXNlZDsKKworCQl0 ZW1wX3NldC5zaXplIC09IHRlbXBfc2V0LnVzZWQ7CisJCXRlbXBfc2V0LnJlZ2lzdGVycyArPSB0 ZW1wX3NldC51c2VkOworCQlhZGRyX2dndHQgKz0gdGVtcF9zZXQudXNlZCAqIHNpemVvZihzdHJ1 Y3QgZ3VjX21taW9fcmVnKTsKKwl9CisKKwlHRU1fQlVHX09OKHRlbXBfc2V0LnNpemUpOworfQor CitzdGF0aWMgdm9pZCBmaWxsX2VuZ2luZV9lbmFibGVfbWFza3Moc3RydWN0IGludGVsX2d0ICpn dCwKKwkJCQkgICAgIHN0cnVjdCBndWNfZ3Rfc3lzdGVtX2luZm8gKmluZm8pCit7CisJaW5mby0+ ZW5naW5lX2VuYWJsZWRfbWFza3NbR1VDX1JFTkRFUl9DTEFTU10gPSAxOworCWluZm8tPmVuZ2lu ZV9lbmFibGVkX21hc2tzW0dVQ19CTElUVEVSX0NMQVNTXSA9IDE7CisJaW5mby0+ZW5naW5lX2Vu YWJsZWRfbWFza3NbR1VDX1ZJREVPX0NMQVNTXSA9IFZEQk9YX01BU0soZ3QpOworCWluZm8tPmVu Z2luZV9lbmFibGVkX21hc2tzW0dVQ19WSURFT0VOSEFOQ0VfQ0xBU1NdID0gVkVCT1hfTUFTSyhn dCk7Cit9CisKK3N0YXRpYyBpbnQgZ3VjX3ByZXBfZ29sZGVuX2NvbnRleHQoc3RydWN0IGludGVs X2d1YyAqZ3VjLAorCQkJCSAgIHN0cnVjdCBfX2d1Y19hZHNfYmxvYiAqYmxvYikKK3sKKwlzdHJ1 Y3QgaW50ZWxfZ3QgKmd0ID0gZ3VjX3RvX2d0KGd1Yyk7CisJdTMyIGFkZHJfZ2d0dCwgb2Zmc2V0 OworCXUzMiB0b3RhbF9zaXplID0gMCwgYWxsb2Nfc2l6ZSwgcmVhbF9zaXplOworCXU4IGVuZ2lu ZV9jbGFzcywgZ3VjX2NsYXNzOworCXN0cnVjdCBndWNfZ3Rfc3lzdGVtX2luZm8gKmluZm8sIGxv Y2FsX2luZm87CisKKwkvKgorCSAqIFJlc2VydmUgdGhlIG1lbW9yeSBmb3IgdGhlIGdvbGRlbiBj b250ZXh0cyBhbmQgcG9pbnQgR3VDIGF0IGl0IGJ1dAorCSAqIGxlYXZlIGl0IGVtcHR5IGZvciBu b3cuIFRoZSBjb250ZXh0IGRhdGEgd2lsbCBiZSBmaWxsZWQgaW4gbGF0ZXIKKwkgKiBvbmNlIHRo ZXJlIGlzIHNvbWV0aGluZyBhdmFpbGFibGUgdG8gcHV0IHRoZXJlLgorCSAqCisJICogTm90ZSB0 aGF0IHRoZSBIV1NQIGFuZCByaW5nIGNvbnRleHQgYXJlIG5vdCBpbmNsdWRlZC4KKwkgKgorCSAq IE5vdGUgYWxzbyB0aGF0IHRoZSBzdG9yYWdlIG11c3QgYmUgcGlubmVkIGluIHRoZSBHR1RULCBz byB0aGF0IHRoZQorCSAqIGFkZHJlc3Mgd29uJ3QgY2hhbmdlIGFmdGVyIEd1QyBoYXMgYmVlbiB0 b2xkIHdoZXJlIHRvIGZpbmQgaXQuIFRoZQorCSAqIEd1QyB3aWxsIGFsc28gdmFsaWRhdGUgdGhh dCB0aGUgTFJDIGJhc2UgKyBzaXplIGZhbGwgd2l0aGluIHRoZQorCSAqIGFsbG93ZWQgR0dUVCBy YW5nZS4KKwkgKi8KKwlpZiAoYmxvYikgeworCQlvZmZzZXQgPSBndWNfYWRzX2dvbGRlbl9jdHh0 X29mZnNldChndWMpOworCQlhZGRyX2dndHQgPSBpbnRlbF9ndWNfZ2d0dF9vZmZzZXQoZ3VjLCBn dWMtPmFkc192bWEpICsgb2Zmc2V0OworCQlpbmZvID0gJmJsb2ItPnN5c3RlbV9pbmZvOworCX0g ZWxzZSB7CisJCW1lbXNldCgmbG9jYWxfaW5mbywgMCwgc2l6ZW9mKGxvY2FsX2luZm8pKTsKKwkJ aW5mbyA9ICZsb2NhbF9pbmZvOworCQlmaWxsX2VuZ2luZV9lbmFibGVfbWFza3MoZ3QsIGluZm8p OworCX0KKworCWZvciAoZW5naW5lX2NsYXNzID0gMDsgZW5naW5lX2NsYXNzIDw9IE1BWF9FTkdJ TkVfQ0xBU1M7ICsrZW5naW5lX2NsYXNzKSB7CisJCWlmIChlbmdpbmVfY2xhc3MgPT0gT1RIRVJf Q0xBU1MpCisJCQljb250aW51ZTsKKworCQlndWNfY2xhc3MgPSBlbmdpbmVfY2xhc3NfdG9fZ3Vj X2NsYXNzKGVuZ2luZV9jbGFzcyk7CisKKwkJaWYgKCFpbmZvLT5lbmdpbmVfZW5hYmxlZF9tYXNr c1tndWNfY2xhc3NdKQorCQkJY29udGludWU7CisKKwkJcmVhbF9zaXplID0gaW50ZWxfZW5naW5l X2NvbnRleHRfc2l6ZShndCwgZW5naW5lX2NsYXNzKTsKKwkJYWxsb2Nfc2l6ZSA9IFBBR0VfQUxJ R04ocmVhbF9zaXplKTsKKwkJdG90YWxfc2l6ZSArPSBhbGxvY19zaXplOworCisJCWlmICghYmxv YikKKwkJCWNvbnRpbnVlOworCisJCWJsb2ItPmFkcy5lbmdfc3RhdGVfc2l6ZVtndWNfY2xhc3Nd ID0gcmVhbF9zaXplOworCQlibG9iLT5hZHMuZ29sZGVuX2NvbnRleHRfbHJjYVtndWNfY2xhc3Nd ID0gYWRkcl9nZ3R0OworCQlhZGRyX2dndHQgKz0gYWxsb2Nfc2l6ZTsKKwl9CisKKwlpZiAoIWJs b2IpCisJCXJldHVybiB0b3RhbF9zaXplOworCisJR0VNX0JVR19PTihndWMtPmFkc19nb2xkZW5f Y3R4dF9zaXplICE9IHRvdGFsX3NpemUpOworCXJldHVybiB0b3RhbF9zaXplOworfQorCitzdGF0 aWMgc3RydWN0IGludGVsX2VuZ2luZV9jcyAqZmluZF9lbmdpbmVfc3RhdGUoc3RydWN0IGludGVs X2d0ICpndCwgdTggZW5naW5lX2NsYXNzKQoreworCXN0cnVjdCBpbnRlbF9lbmdpbmVfY3MgKmVu Z2luZTsKKwllbnVtIGludGVsX2VuZ2luZV9pZCBpZDsKKworCWZvcl9lYWNoX2VuZ2luZShlbmdp bmUsIGd0LCBpZCkgeworCQlpZiAoZW5naW5lLT5jbGFzcyAhPSBlbmdpbmVfY2xhc3MpCisJCQlj b250aW51ZTsKKworCQlpZiAoIWVuZ2luZS0+ZGVmYXVsdF9zdGF0ZSkKKwkJCWNvbnRpbnVlOwor CisJCXJldHVybiBlbmdpbmU7CisJfQorCisJcmV0dXJuIE5VTEw7Cit9CisKK3N0YXRpYyB2b2lk IGd1Y19pbml0X2dvbGRlbl9jb250ZXh0KHN0cnVjdCBpbnRlbF9ndWMgKmd1YykKK3sKIAlzdHJ1 Y3QgX19ndWNfYWRzX2Jsb2IgKmJsb2IgPSBndWMtPmFkc19ibG9iOwotCWNvbnN0IHUzMiBza2lw cGVkX3NpemUgPSBMUkNfUFBIV1NQX1NaICogUEFHRV9TSVpFICsgTFJfSFdfQ09OVEVYVF9TSVpF OwotCXUzMiBiYXNlOworCXN0cnVjdCBpbnRlbF9lbmdpbmVfY3MgKmVuZ2luZTsKKwlzdHJ1Y3Qg aW50ZWxfZ3QgKmd0ID0gZ3VjX3RvX2d0KGd1Yyk7CisJdTMyIGFkZHJfZ2d0dCwgb2Zmc2V0Owor CXUzMiB0b3RhbF9zaXplID0gMCwgYWxsb2Nfc2l6ZSwgcmVhbF9zaXplOwogCXU4IGVuZ2luZV9j bGFzcywgZ3VjX2NsYXNzOworCXU4ICpwdHI7CiAKLQkvKiBHdUMgc2NoZWR1bGluZyBwb2xpY2ll cyAqLwotCWd1Y19wb2xpY2llc19pbml0KCZibG9iLT5wb2xpY2llcyk7CisJLyogU2tpcCBleGVj bGlzdCBhbmQgUFBHVFQgcmVnaXN0ZXJzICsgSFdTUCAqLworCWNvbnN0IHUzMiBscl9od19jb250 ZXh0X3NpemUgPSA4MCAqIHNpemVvZih1MzIpOworCWNvbnN0IHUzMiBza2lwX3NpemUgPSBMUkNf UFBIV1NQX1NaICogUEFHRV9TSVpFICsKKwkJbHJfaHdfY29udGV4dF9zaXplOworCisJaWYgKCFp bnRlbF91Y191c2VzX2d1Y19zdWJtaXNzaW9uKCZndC0+dWMpKQorCQlyZXR1cm47CisKKwlHRU1f QlVHX09OKCFibG9iKTsKIAogCS8qCi0JICogR3VDIGV4cGVjdHMgYSBwZXItZW5naW5lLWNsYXNz IGNvbnRleHQgaW1hZ2UgYW5kIHNpemUKLQkgKiAobWludXMgaHdzcCBhbmQgcmluZyBjb250ZXh0 KS4gVGhlIGNvbnRleHQgaW1hZ2Ugd2lsbCBiZQotCSAqIHVzZWQgdG8gcmVpbml0aWFsaXplIGVu Z2luZXMgYWZ0ZXIgYSByZXNldC4gSXQgbXVzdCBleGlzdAotCSAqIGFuZCBiZSBwaW5uZWQgaW4g dGhlIEdHVFQsIHNvIHRoYXQgdGhlIGFkZHJlc3Mgd29uJ3QgY2hhbmdlIGFmdGVyCi0JICogd2Ug aGF2ZSB0b2xkIEd1QyB3aGVyZSB0byBmaW5kIGl0LiBUaGUgY29udGV4dCBzaXplIHdpbGwgYmUg dXNlZAotCSAqIHRvIHZhbGlkYXRlIHRoYXQgdGhlIExSQyBiYXNlICsgc2l6ZSBmYWxsIHdpdGhp biBhbGxvd2VkIEdHVFQuCisJICogR28gYmFjayBhbmQgZmlsbCBpbiB0aGUgZ29sZGVuIGNvbnRl eHQgZGF0YSBub3cgdGhhdCBpdCBpcworCSAqIGF2YWlsYWJsZS4KIAkgKi8KKwlvZmZzZXQgPSBn dWNfYWRzX2dvbGRlbl9jdHh0X29mZnNldChndWMpOworCWFkZHJfZ2d0dCA9IGludGVsX2d1Y19n Z3R0X29mZnNldChndWMsIGd1Yy0+YWRzX3ZtYSkgKyBvZmZzZXQ7CisJcHRyID0gKCh1OCAqKSBi bG9iKSArIG9mZnNldDsKKwogCWZvciAoZW5naW5lX2NsYXNzID0gMDsgZW5naW5lX2NsYXNzIDw9 IE1BWF9FTkdJTkVfQ0xBU1M7ICsrZW5naW5lX2NsYXNzKSB7CiAJCWlmIChlbmdpbmVfY2xhc3Mg PT0gT1RIRVJfQ0xBU1MpCiAJCQljb250aW51ZTsKIAogCQlndWNfY2xhc3MgPSBlbmdpbmVfY2xh c3NfdG9fZ3VjX2NsYXNzKGVuZ2luZV9jbGFzcyk7CiAKLQkJLyoKLQkJICogVE9ETzogU2V0IGNv bnRleHQgcG9pbnRlciB0byBkZWZhdWx0IHN0YXRlIHRvIGFsbG93Ci0JCSAqIEd1QyB0byByZS1p bml0IGd1aWx0eSBjb250ZXh0cyBhZnRlciBpbnRlcm5hbCByZXNldC4KLQkJICovCi0JCWJsb2It PmFkcy5nb2xkZW5fY29udGV4dF9scmNhW2d1Y19jbGFzc10gPSAwOwotCQlibG9iLT5hZHMuZW5n X3N0YXRlX3NpemVbZ3VjX2NsYXNzXSA9Ci0JCQlpbnRlbF9lbmdpbmVfY29udGV4dF9zaXplKGd1 Y190b19ndChndWMpLAotCQkJCQkJICBlbmdpbmVfY2xhc3MpIC0KLQkJCXNraXBwZWRfc2l6ZTsK KwkJaWYgKCFibG9iLT5zeXN0ZW1faW5mby5lbmdpbmVfZW5hYmxlZF9tYXNrc1tndWNfY2xhc3Nd KQorCQkJY29udGludWU7CisKKwkJcmVhbF9zaXplID0gaW50ZWxfZW5naW5lX2NvbnRleHRfc2l6 ZShndCwgZW5naW5lX2NsYXNzKTsKKwkJYWxsb2Nfc2l6ZSA9IFBBR0VfQUxJR04ocmVhbF9zaXpl KTsKKwkJdG90YWxfc2l6ZSArPSBhbGxvY19zaXplOworCisJCWVuZ2luZSA9IGZpbmRfZW5naW5l X3N0YXRlKGd0LCBlbmdpbmVfY2xhc3MpOworCQlpZiAoIWVuZ2luZSkgeworCQkJZHJtX2Vycigm Z3QtPmk5MTUtPmRybSwgIk5vIGVuZ2luZSBzdGF0ZSByZWNvcmRlZCBmb3IgY2xhc3MgJWQhXG4i LCBlbmdpbmVfY2xhc3MpOworCQkJYmxvYi0+YWRzLmVuZ19zdGF0ZV9zaXplW2d1Y19jbGFzc10g PSAwOworCQkJYmxvYi0+YWRzLmdvbGRlbl9jb250ZXh0X2xyY2FbZ3VjX2NsYXNzXSA9IDA7CisJ CQljb250aW51ZTsKKwkJfQorCisJCUdFTV9CVUdfT04oYmxvYi0+YWRzLmVuZ19zdGF0ZV9zaXpl W2d1Y19jbGFzc10gIT0gcmVhbF9zaXplKTsKKwkJR0VNX0JVR19PTihibG9iLT5hZHMuZ29sZGVu X2NvbnRleHRfbHJjYVtndWNfY2xhc3NdICE9IGFkZHJfZ2d0dCk7CisJCWFkZHJfZ2d0dCArPSBh bGxvY19zaXplOworCisJCXNobWVtX3JlYWQoZW5naW5lLT5kZWZhdWx0X3N0YXRlLCBza2lwX3Np emUsIHB0ciArIHNraXBfc2l6ZSwKKwkJCSAgIHJlYWxfc2l6ZSAtIHNraXBfc2l6ZSk7CisJCXB0 ciArPSBhbGxvY19zaXplOwogCX0KIAorCUdFTV9CVUdfT04oZ3VjLT5hZHNfZ29sZGVuX2N0eHRf c2l6ZSAhPSB0b3RhbF9zaXplKTsKK30KKworc3RhdGljIHZvaWQgX19ndWNfYWRzX2luaXQoc3Ry dWN0IGludGVsX2d1YyAqZ3VjKQoreworCXN0cnVjdCBpbnRlbF9ndCAqZ3QgPSBndWNfdG9fZ3Qo Z3VjKTsKKwlzdHJ1Y3QgZHJtX2k5MTVfcHJpdmF0ZSAqaTkxNSA9IGd0LT5pOTE1OworCXN0cnVj dCBfX2d1Y19hZHNfYmxvYiAqYmxvYiA9IGd1Yy0+YWRzX2Jsb2I7CisJdTMyIGJhc2U7CisKKwkv KiBHdUMgc2NoZWR1bGluZyBwb2xpY2llcyAqLworCWd1Y19wb2xpY2llc19pbml0KGd1YywgJmJs b2ItPnBvbGljaWVzKTsKKwogCS8qIFN5c3RlbSBpbmZvICovCi0JYmxvYi0+c3lzdGVtX2luZm8u ZW5naW5lX2VuYWJsZWRfbWFza3NbR1VDX1JFTkRFUl9DTEFTU10gPSAxOwotCWJsb2ItPnN5c3Rl bV9pbmZvLmVuZ2luZV9lbmFibGVkX21hc2tzW0dVQ19CTElUVEVSX0NMQVNTXSA9IDE7Ci0JYmxv Yi0+c3lzdGVtX2luZm8uZW5naW5lX2VuYWJsZWRfbWFza3NbR1VDX1ZJREVPX0NMQVNTXSA9IFZE Qk9YX01BU0soZ3QpOwotCWJsb2ItPnN5c3RlbV9pbmZvLmVuZ2luZV9lbmFibGVkX21hc2tzW0dV Q19WSURFT0VOSEFOQ0VfQ0xBU1NdID0gVkVCT1hfTUFTSyhndCk7CisJZmlsbF9lbmdpbmVfZW5h YmxlX21hc2tzKGd0LCAmYmxvYi0+c3lzdGVtX2luZm8pOwogCiAJYmxvYi0+c3lzdGVtX2luZm8u Z2VuZXJpY19ndF9zeXNpbmZvW0dVQ19HRU5FUklDX0dUX1NZU0lORk9fU0xJQ0VfRU5BQkxFRF0g PQogCQlod2VpZ2h0OChndC0+aW5mby5zc2V1LnNsaWNlX21hc2spOwpAQCAtMTQ1LDYgKzUxMyw5 IEBAIHN0YXRpYyB2b2lkIF9fZ3VjX2Fkc19pbml0KHN0cnVjdCBpbnRlbF9ndWMgKmd1YykKIAkJ CSBHRU4xMl9ET09SQkVMTFNfUEVSX1NRSURJKSArIDE7CiAJfQogCisJLyogR29sZGVuIGNvbnRl eHRzIGZvciByZS1pbml0aWFsaXNpbmcgYWZ0ZXIgYSB3YXRjaGRvZyByZXNldCAqLworCWd1Y19w cmVwX2dvbGRlbl9jb250ZXh0KGd1YywgYmxvYik7CisKIAlndWNfbWFwcGluZ190YWJsZV9pbml0 KGd1Y190b19ndChndWMpLCAmYmxvYi0+c3lzdGVtX2luZm8pOwogCiAJYmFzZSA9IGludGVsX2d1 Y19nZ3R0X29mZnNldChndWMsIGd1Yy0+YWRzX3ZtYSk7CkBAIC0xNTMsNiArNTI0LDkgQEAgc3Rh dGljIHZvaWQgX19ndWNfYWRzX2luaXQoc3RydWN0IGludGVsX2d1YyAqZ3VjKQogCWJsb2ItPmFk cy5zY2hlZHVsZXJfcG9saWNpZXMgPSBiYXNlICsgcHRyX29mZnNldChibG9iLCBwb2xpY2llcyk7 CiAJYmxvYi0+YWRzLmd0X3N5c3RlbV9pbmZvID0gYmFzZSArIHB0cl9vZmZzZXQoYmxvYiwgc3lz dGVtX2luZm8pOwogCisJLyogTU1JTyBzYXZlL3Jlc3RvcmUgbGlzdCAqLworCWd1Y19tbWlvX3Jl Z19zdGF0ZV9pbml0KGd1YywgYmxvYik7CisKIAkvKiBQcml2YXRlIERhdGEgKi8KIAlibG9iLT5h ZHMucHJpdmF0ZV9kYXRhID0gYmFzZSArIGd1Y19hZHNfcHJpdmF0ZV9kYXRhX29mZnNldChndWMp OwogCkBAIC0xNzMsNiArNTQ3LDE5IEBAIGludCBpbnRlbF9ndWNfYWRzX2NyZWF0ZShzdHJ1Y3Qg aW50ZWxfZ3VjICpndWMpCiAKIAlHRU1fQlVHX09OKGd1Yy0+YWRzX3ZtYSk7CiAKKwkvKiBOZWVk IHRvIGNhbGN1bGF0ZSB0aGUgcmVnIHN0YXRlIHNpemUgZHluYW1pY2FsbHk6ICovCisJcmV0ID0g Z3VjX21taW9fcmVnX3N0YXRlX3F1ZXJ5KGd1Yyk7CisJaWYgKHJldCA8IDApCisJCXJldHVybiBy ZXQ7CisJZ3VjLT5hZHNfcmVnc2V0X3NpemUgPSByZXQ7CisKKwkvKiBMaWtld2lzZSB0aGUgZ29s ZGVuIGNvbnRleHRzOiAqLworCXJldCA9IGd1Y19wcmVwX2dvbGRlbl9jb250ZXh0KGd1YywgTlVM TCk7CisJaWYgKHJldCA8IDApCisJCXJldHVybiByZXQ7CisJZ3VjLT5hZHNfZ29sZGVuX2N0eHRf c2l6ZSA9IHJldDsKKworCS8qIE5vdyB0aGUgdG90YWwgc2l6ZSBjYW4gYmUgZGV0ZXJtaW5lZDog Ki8KIAlzaXplID0gZ3VjX2Fkc19ibG9iX3NpemUoZ3VjKTsKIAogCXJldCA9IGludGVsX2d1Y19h bGxvY2F0ZV9hbmRfbWFwX3ZtYShndWMsIHNpemUsICZndWMtPmFkc192bWEsCkBAIC0xODUsNiAr NTcyLDE4IEBAIGludCBpbnRlbF9ndWNfYWRzX2NyZWF0ZShzdHJ1Y3QgaW50ZWxfZ3VjICpndWMp CiAJcmV0dXJuIDA7CiB9CiAKK3ZvaWQgaW50ZWxfZ3VjX2Fkc19pbml0X2xhdGUoc3RydWN0IGlu dGVsX2d1YyAqZ3VjKQoreworCS8qCisJICogVGhlIGdvbGRlbiBjb250ZXh0IHNldHVwIHJlcXVp cmVzIHRoZSBzYXZlZCBlbmdpbmUgc3RhdGUgZnJvbQorCSAqIF9fZW5naW5lc19yZWNvcmRfZGVm YXVsdHMoKS4gSG93ZXZlciwgdGhhdCByZXF1aXJlcyBlbmdpbmVzIHRvIGJlCisJICogb3BlcmF0 aW9uYWwgd2hpY2ggbWVhbnMgdGhlIEFEUyBtdXN0IGFscmVhZHkgaGF2ZSBiZWVuIGNvbmZpZ3Vy ZWQuCisJICogRm9ydHVuYXRlbHksIHRoZSBnb2xkZW4gY29udGV4dCBzdGF0ZSBpcyBub3QgbmVl ZGVkIHVudGlsIGEgaGFuZworCSAqIG9jY3Vycywgc28gaXQgY2FuIGJlIGZpbGxlZCBpbiBkdXJp bmcgdGhpcyBsYXRlIGluaXQgcGhhc2UuCisJICovCisJZ3VjX2luaXRfZ29sZGVuX2NvbnRleHQo Z3VjKTsKK30KKwogdm9pZCBpbnRlbF9ndWNfYWRzX2Rlc3Ryb3koc3RydWN0IGludGVsX2d1YyAq Z3VjKQogewogCWk5MTVfdm1hX3VucGluX2FuZF9yZWxlYXNlKCZndWMtPmFkc192bWEsIEk5MTVf Vk1BX1JFTEVBU0VfTUFQKTsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2d0L3Vj L2ludGVsX2d1Y19hZHMuaCBiL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2d0L3VjL2ludGVsX2d1Y19h ZHMuaAppbmRleCBiMDBkM2FlMTExM2EuLjNkODUwNTFkNTdlNCAxMDA2NDQKLS0tIGEvZHJpdmVy cy9ncHUvZHJtL2k5MTUvZ3QvdWMvaW50ZWxfZ3VjX2Fkcy5oCisrKyBiL2RyaXZlcnMvZ3B1L2Ry bS9pOTE1L2d0L3VjL2ludGVsX2d1Y19hZHMuaApAQCAtNyw5ICs3LDEzIEBACiAjZGVmaW5lIF9J TlRFTF9HVUNfQURTX0hfCiAKIHN0cnVjdCBpbnRlbF9ndWM7CitzdHJ1Y3QgZHJtX3ByaW50ZXI7 CiAKIGludCBpbnRlbF9ndWNfYWRzX2NyZWF0ZShzdHJ1Y3QgaW50ZWxfZ3VjICpndWMpOwogdm9p ZCBpbnRlbF9ndWNfYWRzX2Rlc3Ryb3koc3RydWN0IGludGVsX2d1YyAqZ3VjKTsKK3ZvaWQgaW50 ZWxfZ3VjX2Fkc19pbml0X2xhdGUoc3RydWN0IGludGVsX2d1YyAqZ3VjKTsKIHZvaWQgaW50ZWxf Z3VjX2Fkc19yZXNldChzdHJ1Y3QgaW50ZWxfZ3VjICpndWMpOwordm9pZCBpbnRlbF9ndWNfYWRz X3ByaW50X3BvbGljeV9pbmZvKHN0cnVjdCBpbnRlbF9ndWMgKmd1YywKKwkJCQkgICAgIHN0cnVj dCBkcm1fcHJpbnRlciAqcCk7CiAKICNlbmRpZgpkaWZmIC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJt L2k5MTUvZ3QvdWMvaW50ZWxfZ3VjX2N0LmMgYi9kcml2ZXJzL2dwdS9kcm0vaTkxNS9ndC91Yy9p bnRlbF9ndWNfY3QuYwppbmRleCA4M2VjNjBlYTNmODkuLjkyOTc2ZDIwNTQ3OCAxMDA2NDQKLS0t IGEvZHJpdmVycy9ncHUvZHJtL2k5MTUvZ3QvdWMvaW50ZWxfZ3VjX2N0LmMKKysrIGIvZHJpdmVy cy9ncHUvZHJtL2k5MTUvZ3QvdWMvaW50ZWxfZ3VjX2N0LmMKQEAgLTczLDYgKzczLDcgQEAgc3Rh dGljIGlubGluZSBzdHJ1Y3QgZHJtX2RldmljZSAqY3RfdG9fZHJtKHN0cnVjdCBpbnRlbF9ndWNf Y3QgKmN0KQogI2RlZmluZSBDVEJfREVTQ19TSVpFCQlBTElHTihzaXplb2Yoc3RydWN0IGd1Y19j dF9idWZmZXJfZGVzYyksIFNaXzJLKQogI2RlZmluZSBDVEJfSDJHX0JVRkZFUl9TSVpFCShTWl80 SykKICNkZWZpbmUgQ1RCX0cySF9CVUZGRVJfU0laRQkoNCAqIENUQl9IMkdfQlVGRkVSX1NJWkUp CisjZGVmaW5lIEcySF9ST09NX0JVRkZFUl9TSVpFCShDVEJfRzJIX0JVRkZFUl9TSVpFIC8gNCkK IAogc3RydWN0IGN0X3JlcXVlc3QgewogCXN0cnVjdCBsaXN0X2hlYWQgbGluazsKQEAgLTEwOCw2 ICsxMDksNyBAQCB2b2lkIGludGVsX2d1Y19jdF9pbml0X2Vhcmx5KHN0cnVjdCBpbnRlbF9ndWNf Y3QgKmN0KQogCUlOSVRfTElTVF9IRUFEKCZjdC0+cmVxdWVzdHMuaW5jb21pbmcpOwogCUlOSVRf V09SSygmY3QtPnJlcXVlc3RzLndvcmtlciwgY3RfaW5jb21pbmdfcmVxdWVzdF93b3JrZXJfZnVu Yyk7CiAJdGFza2xldF9zZXR1cCgmY3QtPnJlY2VpdmVfdGFza2xldCwgY3RfcmVjZWl2ZV90YXNr bGV0X2Z1bmMpOworCWluaXRfd2FpdHF1ZXVlX2hlYWQoJmN0LT53cSk7CiB9CiAKIHN0YXRpYyBp bmxpbmUgY29uc3QgY2hhciAqZ3VjX2N0X2J1ZmZlcl90eXBlX3RvX3N0cih1MzIgdHlwZSkKQEAg LTEyOSwyMyArMTMxLDI3IEBAIHN0YXRpYyB2b2lkIGd1Y19jdF9idWZmZXJfZGVzY19pbml0KHN0 cnVjdCBndWNfY3RfYnVmZmVyX2Rlc2MgKmRlc2MpCiAKIHN0YXRpYyB2b2lkIGd1Y19jdF9idWZm ZXJfcmVzZXQoc3RydWN0IGludGVsX2d1Y19jdF9idWZmZXIgKmN0YikKIHsKKwl1MzIgc3BhY2U7 CisKIAljdGItPmJyb2tlbiA9IGZhbHNlOwogCWN0Yi0+dGFpbCA9IDA7CiAJY3RiLT5oZWFkID0g MDsKLQljdGItPnNwYWNlID0gQ0lSQ19TUEFDRShjdGItPnRhaWwsIGN0Yi0+aGVhZCwgY3RiLT5z aXplKTsKKwlzcGFjZSA9IENJUkNfU1BBQ0UoY3RiLT50YWlsLCBjdGItPmhlYWQsIGN0Yi0+c2l6 ZSkgLSBjdGItPnJlc3Zfc3BhY2U7CisJYXRvbWljX3NldCgmY3RiLT5zcGFjZSwgc3BhY2UpOwog CiAJZ3VjX2N0X2J1ZmZlcl9kZXNjX2luaXQoY3RiLT5kZXNjKTsKIH0KIAogc3RhdGljIHZvaWQg Z3VjX2N0X2J1ZmZlcl9pbml0KHN0cnVjdCBpbnRlbF9ndWNfY3RfYnVmZmVyICpjdGIsCiAJCQkg ICAgICAgc3RydWN0IGd1Y19jdF9idWZmZXJfZGVzYyAqZGVzYywKLQkJCSAgICAgICB1MzIgKmNt ZHMsIHUzMiBzaXplX2luX2J5dGVzKQorCQkJICAgICAgIHUzMiAqY21kcywgdTMyIHNpemVfaW5f Ynl0ZXMsIHUzMiByZXN2X3NwYWNlKQogewogCUdFTV9CVUdfT04oc2l6ZV9pbl9ieXRlcyAlIDQp OwogCiAJY3RiLT5kZXNjID0gZGVzYzsKIAljdGItPmNtZHMgPSBjbWRzOwogCWN0Yi0+c2l6ZSA9 IHNpemVfaW5fYnl0ZXMgLyA0OworCWN0Yi0+cmVzdl9zcGFjZSA9IHJlc3Zfc3BhY2UgLyA0Owog CiAJZ3VjX2N0X2J1ZmZlcl9yZXNldChjdGIpOwogfQpAQCAtMjI2LDYgKzIzMiw3IEBAIGludCBp bnRlbF9ndWNfY3RfaW5pdChzdHJ1Y3QgaW50ZWxfZ3VjX2N0ICpjdCkKIAlzdHJ1Y3QgZ3VjX2N0 X2J1ZmZlcl9kZXNjICpkZXNjOwogCXUzMiBibG9iX3NpemU7CiAJdTMyIGNtZHNfc2l6ZTsKKwl1 MzIgcmVzdl9zcGFjZTsKIAl2b2lkICpibG9iOwogCXUzMiAqY21kczsKIAlpbnQgZXJyOwpAQCAt MjUwLDE5ICsyNTcsMjMgQEAgaW50IGludGVsX2d1Y19jdF9pbml0KHN0cnVjdCBpbnRlbF9ndWNf Y3QgKmN0KQogCWRlc2MgPSBibG9iOwogCWNtZHMgPSBibG9iICsgMiAqIENUQl9ERVNDX1NJWkU7 CiAJY21kc19zaXplID0gQ1RCX0gyR19CVUZGRVJfU0laRTsKLQlDVF9ERUJVRyhjdCwgIiVzIGRl c2MgJSN0eCBjbWRzICUjdHggc2l6ZSAldVxuIiwgInNlbmQiLAotCQkgcHRyZGlmZihkZXNjLCBi bG9iKSwgcHRyZGlmZihjbWRzLCBibG9iKSwgY21kc19zaXplKTsKKwlyZXN2X3NwYWNlID0gMDsK KwlDVF9ERUJVRyhjdCwgIiVzIGRlc2MgJSN0eCBjbWRzICUjdHggc2l6ZSAldS8ldVxuIiwgInNl bmQiLAorCQkgcHRyZGlmZihkZXNjLCBibG9iKSwgcHRyZGlmZihjbWRzLCBibG9iKSwgY21kc19z aXplLAorCQkgcmVzdl9zcGFjZSk7CiAKLQlndWNfY3RfYnVmZmVyX2luaXQoJmN0LT5jdGJzLnNl bmQsIGRlc2MsIGNtZHMsIGNtZHNfc2l6ZSk7CisJZ3VjX2N0X2J1ZmZlcl9pbml0KCZjdC0+Y3Ri cy5zZW5kLCBkZXNjLCBjbWRzLCBjbWRzX3NpemUsIHJlc3Zfc3BhY2UpOwogCiAJLyogc3RvcmUg cG9pbnRlcnMgdG8gZGVzYyBhbmQgY21kcyBmb3IgcmVjdiBjdGIgKi8KIAlkZXNjID0gYmxvYiAr IENUQl9ERVNDX1NJWkU7CiAJY21kcyA9IGJsb2IgKyAyICogQ1RCX0RFU0NfU0laRSArIENUQl9I MkdfQlVGRkVSX1NJWkU7CiAJY21kc19zaXplID0gQ1RCX0cySF9CVUZGRVJfU0laRTsKLQlDVF9E RUJVRyhjdCwgIiVzIGRlc2MgJSN0eCBjbWRzICUjdHggc2l6ZSAldVxuIiwgInJlY3YiLAotCQkg cHRyZGlmZihkZXNjLCBibG9iKSwgcHRyZGlmZihjbWRzLCBibG9iKSwgY21kc19zaXplKTsKKwly ZXN2X3NwYWNlID0gRzJIX1JPT01fQlVGRkVSX1NJWkU7CisJQ1RfREVCVUcoY3QsICIlcyBkZXNj ICUjdHggY21kcyAlI3R4IHNpemUgJXUvJXVcbiIsICJyZWN2IiwKKwkJIHB0cmRpZmYoZGVzYywg YmxvYiksIHB0cmRpZmYoY21kcywgYmxvYiksIGNtZHNfc2l6ZSwKKwkJIHJlc3Zfc3BhY2UpOwog Ci0JZ3VjX2N0X2J1ZmZlcl9pbml0KCZjdC0+Y3Ricy5yZWN2LCBkZXNjLCBjbWRzLCBjbWRzX3Np emUpOworCWd1Y19jdF9idWZmZXJfaW5pdCgmY3QtPmN0YnMucmVjdiwgZGVzYywgY21kcywgY21k c19zaXplLCByZXN2X3NwYWNlKTsKIAogCXJldHVybiAwOwogfQpAQCAtNDYxLDggKzQ3Miw4IEBA IHN0YXRpYyBpbnQgY3Rfd3JpdGUoc3RydWN0IGludGVsX2d1Y19jdCAqY3QsCiAKIAkvKiB1cGRh dGUgbG9jYWwgY29waWVzICovCiAJY3RiLT50YWlsID0gdGFpbDsKLQlHRU1fQlVHX09OKGN0Yi0+ c3BhY2UgPCBsZW4gKyBHVUNfQ1RCX0hEUl9MRU4pOwotCWN0Yi0+c3BhY2UgLT0gbGVuICsgR1VD X0NUQl9IRFJfTEVOOworCUdFTV9CVUdfT04oYXRvbWljX3JlYWQoJmN0Yi0+c3BhY2UpIDwgbGVu ICsgR1VDX0NUQl9IRFJfTEVOKTsKKwlhdG9taWNfc3ViKGxlbiArIEdVQ19DVEJfSERSX0xFTiwg JmN0Yi0+c3BhY2UpOwogCiAJLyogbm93IHVwZGF0ZSBkZXNjcmlwdG9yICovCiAJV1JJVEVfT05D RShkZXNjLT50YWlsLCB0YWlsKTsKQEAgLTUzNyw2ICs1NDgsMzIgQEAgc3RhdGljIGlubGluZSBi b29sIGN0X2RlYWRsb2NrZWQoc3RydWN0IGludGVsX2d1Y19jdCAqY3QpCiAJcmV0dXJuIHJldDsK IH0KIAorc3RhdGljIGlubGluZSBib29sIGcyaF9oYXNfcm9vbShzdHJ1Y3QgaW50ZWxfZ3VjX2N0 ICpjdCwgdTMyIGcyaF9sZW5fZHcpCit7CisJc3RydWN0IGludGVsX2d1Y19jdF9idWZmZXIgKmN0 YiA9ICZjdC0+Y3Ricy5yZWN2OworCisJLyoKKwkgKiBXZSBsZWF2ZSBhIGNlcnRhaW4gYW1vdW50 IG9mIHNwYWNlIGluIHRoZSBHMkggQ1RCIGJ1ZmZlciBmb3IKKwkgKiB1bmV4cGVjdGVkIEcySCBD VEJzIChlLmcuIGxvZ2dpbmcsIGVuZ2luZSBoYW5nLCBldGMuLi4pCisJICovCisJcmV0dXJuICFn MmhfbGVuX2R3IHx8IGF0b21pY19yZWFkKCZjdGItPnNwYWNlKSA+PSBnMmhfbGVuX2R3OworfQor CitzdGF0aWMgaW5saW5lIHZvaWQgZzJoX3Jlc2VydmVfc3BhY2Uoc3RydWN0IGludGVsX2d1Y19j dCAqY3QsIHUzMiBnMmhfbGVuX2R3KQoreworCWxvY2tkZXBfYXNzZXJ0X2hlbGQoJmN0LT5jdGJz LnNlbmQubG9jayk7CisKKwlHRU1fQlVHX09OKCFnMmhfaGFzX3Jvb20oY3QsIGcyaF9sZW5fZHcp KTsKKworCWlmIChnMmhfbGVuX2R3KQorCQlhdG9taWNfc3ViKGcyaF9sZW5fZHcsICZjdC0+Y3Ri cy5yZWN2LnNwYWNlKTsKK30KKworc3RhdGljIGlubGluZSB2b2lkIGcyaF9yZWxlYXNlX3NwYWNl KHN0cnVjdCBpbnRlbF9ndWNfY3QgKmN0LCB1MzIgZzJoX2xlbl9kdykKK3sKKwlhdG9taWNfYWRk KGcyaF9sZW5fZHcsICZjdC0+Y3Ricy5yZWN2LnNwYWNlKTsKK30KKwogc3RhdGljIGlubGluZSBi b29sIGgyZ19oYXNfcm9vbShzdHJ1Y3QgaW50ZWxfZ3VjX2N0ICpjdCwgdTMyIGxlbl9kdykKIHsK IAlzdHJ1Y3QgaW50ZWxfZ3VjX2N0X2J1ZmZlciAqY3RiID0gJmN0LT5jdGJzLnNlbmQ7CkBAIC01 NDQsNyArNTgxLDcgQEAgc3RhdGljIGlubGluZSBib29sIGgyZ19oYXNfcm9vbShzdHJ1Y3QgaW50 ZWxfZ3VjX2N0ICpjdCwgdTMyIGxlbl9kdykKIAl1MzIgaGVhZDsKIAl1MzIgc3BhY2U7CiAKLQlp ZiAoY3RiLT5zcGFjZSA+PSBsZW5fZHcpCisJaWYgKGF0b21pY19yZWFkKCZjdGItPnNwYWNlKSA+ PSBsZW5fZHcpCiAJCXJldHVybiB0cnVlOwogCiAJaGVhZCA9IFJFQURfT05DRShkZXNjLT5oZWFk KTsKQEAgLTU1NywxNiArNTk0LDE2IEBAIHN0YXRpYyBpbmxpbmUgYm9vbCBoMmdfaGFzX3Jvb20o c3RydWN0IGludGVsX2d1Y19jdCAqY3QsIHUzMiBsZW5fZHcpCiAJfQogCiAJc3BhY2UgPSBDSVJD X1NQQUNFKGN0Yi0+dGFpbCwgaGVhZCwgY3RiLT5zaXplKTsKLQljdGItPnNwYWNlID0gc3BhY2U7 CisJYXRvbWljX3NldCgmY3RiLT5zcGFjZSwgc3BhY2UpOwogCiAJcmV0dXJuIHNwYWNlID49IGxl bl9kdzsKIH0KIAotc3RhdGljIGludCBoYXNfcm9vbV9uYihzdHJ1Y3QgaW50ZWxfZ3VjX2N0ICpj dCwgdTMyIGxlbl9kdykKK3N0YXRpYyBpbnQgaGFzX3Jvb21fbmIoc3RydWN0IGludGVsX2d1Y19j dCAqY3QsIHUzMiBoMmdfZHcsIHUzMiBnMmhfZHcpCiB7CiAJbG9ja2RlcF9hc3NlcnRfaGVsZCgm Y3QtPmN0YnMuc2VuZC5sb2NrKTsKIAotCWlmICh1bmxpa2VseSghaDJnX2hhc19yb29tKGN0LCBs ZW5fZHcpKSkgeworCWlmICh1bmxpa2VseSghaDJnX2hhc19yb29tKGN0LCBoMmdfZHcpIHx8ICFn MmhfaGFzX3Jvb20oY3QsIGcyaF9kdykpKSB7CiAJCWlmIChjdC0+c3RhbGxfdGltZSA9PSBLVElN RV9NQVgpCiAJCQljdC0+c3RhbGxfdGltZSA9IGt0aW1lX2dldCgpOwogCkBAIC01ODAsNiArNjE3 LDkgQEAgc3RhdGljIGludCBoYXNfcm9vbV9uYihzdHJ1Y3QgaW50ZWxfZ3VjX2N0ICpjdCwgdTMy IGxlbl9kdykKIAlyZXR1cm4gMDsKIH0KIAorI2RlZmluZSBHMkhfTEVOX0RXKGYpIFwKKwlGSUVM RF9HRVQoSU5URUxfR1VDX0NUX1NFTkRfRzJIX0RXX01BU0ssIGYpID8gXAorCUZJRUxEX0dFVChJ TlRFTF9HVUNfQ1RfU0VORF9HMkhfRFdfTUFTSywgZikgKyBHVUNfQ1RCX0hYR19NU0dfTUlOX0xF TiA6IDAKIHN0YXRpYyBpbnQgY3Rfc2VuZF9uYihzdHJ1Y3QgaW50ZWxfZ3VjX2N0ICpjdCwKIAkJ ICAgICAgY29uc3QgdTMyICphY3Rpb24sCiAJCSAgICAgIHUzMiBsZW4sCkBAIC01ODcsMTIgKzYy NywxMyBAQCBzdGF0aWMgaW50IGN0X3NlbmRfbmIoc3RydWN0IGludGVsX2d1Y19jdCAqY3QsCiB7 CiAJc3RydWN0IGludGVsX2d1Y19jdF9idWZmZXIgKmN0YiA9ICZjdC0+Y3Ricy5zZW5kOwogCXVu c2lnbmVkIGxvbmcgc3Bpbl9mbGFnczsKKwl1MzIgZzJoX2xlbl9kdyA9IEcySF9MRU5fRFcoZmxh Z3MpOwogCXUzMiBmZW5jZTsKIAlpbnQgcmV0OwogCiAJc3Bpbl9sb2NrX2lycXNhdmUoJmN0Yi0+ bG9jaywgc3Bpbl9mbGFncyk7CiAKLQlyZXQgPSBoYXNfcm9vbV9uYihjdCwgbGVuICsgR1VDX0NU Ql9IRFJfTEVOKTsKKwlyZXQgPSBoYXNfcm9vbV9uYihjdCwgbGVuICsgR1VDX0NUQl9IRFJfTEVO LCBnMmhfbGVuX2R3KTsKIAlpZiAodW5saWtlbHkocmV0KSkKIAkJZ290byBvdXQ7CiAKQEAgLTYw MSw2ICs2NDIsNyBAQCBzdGF0aWMgaW50IGN0X3NlbmRfbmIoc3RydWN0IGludGVsX2d1Y19jdCAq Y3QsCiAJaWYgKHVubGlrZWx5KHJldCkpCiAJCWdvdG8gb3V0OwogCisJZzJoX3Jlc2VydmVfc3Bh Y2UoY3QsIGcyaF9sZW5fZHcpOwogCWludGVsX2d1Y19ub3RpZnkoY3RfdG9fZ3VjKGN0KSk7CiAK IG91dDoKQEAgLTYzMiwxMSArNjc0LDEzIEBAIHN0YXRpYyBpbnQgY3Rfc2VuZChzdHJ1Y3QgaW50 ZWxfZ3VjX2N0ICpjdCwKIAkvKgogCSAqIFdlIHVzZSBhIGxhenkgc3BpbiB3YWl0IGxvb3AgaGVy ZSBhcyB3ZSBiZWxpZXZlIHRoYXQgaWYgdGhlIENUCiAJICogYnVmZmVycyBhcmUgc2l6ZWQgY29y cmVjdGx5IHRoZSBmbG93IGNvbnRyb2wgY29uZGl0aW9uIHNob3VsZCBiZQotCSAqIHJhcmUuCisJ ICogcmFyZS4gUmVzZXJ2aW5nIHRoZSBtYXhpbXVtIHNpemUgaW4gdGhlIEcySCBjcmVkaXRzIGFz IHdlIGRvbid0IGtub3cKKwkgKiBob3cgYmlnIHRoZSByZXNwb25zZSBpcyBnb2luZyB0byBiZS4K IAkgKi8KIHJldHJ5OgogCXNwaW5fbG9ja19pcnFzYXZlKCZjdGItPmxvY2ssIGZsYWdzKTsKLQlp ZiAodW5saWtlbHkoIWgyZ19oYXNfcm9vbShjdCwgbGVuICsgR1VDX0NUQl9IRFJfTEVOKSkpIHsK KwlpZiAodW5saWtlbHkoIWgyZ19oYXNfcm9vbShjdCwgbGVuICsgR1VDX0NUQl9IRFJfTEVOKSB8 fAorCQkgICAgICFnMmhfaGFzX3Jvb20oY3QsIEdVQ19DVEJfSFhHX01TR19NQVhfTEVOKSkpIHsK IAkJaWYgKGN0LT5zdGFsbF90aW1lID09IEtUSU1FX01BWCkKIAkJCWN0LT5zdGFsbF90aW1lID0g a3RpbWVfZ2V0KCk7CiAJCXNwaW5fdW5sb2NrX2lycXJlc3RvcmUoJmN0Yi0+bG9jaywgZmxhZ3Mp OwpAQCAtNjY0LDYgKzcwOCw3IEBAIHN0YXRpYyBpbnQgY3Rfc2VuZChzdHJ1Y3QgaW50ZWxfZ3Vj X2N0ICpjdCwKIAlzcGluX3VubG9jaygmY3QtPnJlcXVlc3RzLmxvY2spOwogCiAJZXJyID0gY3Rf d3JpdGUoY3QsIGFjdGlvbiwgbGVuLCBmZW5jZSwgMCk7CisJZzJoX3Jlc2VydmVfc3BhY2UoY3Qs IEdVQ19DVEJfSFhHX01TR19NQVhfTEVOKTsKIAogCXNwaW5fdW5sb2NrX2lycXJlc3RvcmUoJmN0 Yi0+bG9jaywgZmxhZ3MpOwogCkBAIC02NzMsNiArNzE4LDcgQEAgc3RhdGljIGludCBjdF9zZW5k KHN0cnVjdCBpbnRlbF9ndWNfY3QgKmN0LAogCWludGVsX2d1Y19ub3RpZnkoY3RfdG9fZ3VjKGN0 KSk7CiAKIAllcnIgPSB3YWl0X2Zvcl9jdF9yZXF1ZXN0X3VwZGF0ZSgmcmVxdWVzdCwgc3RhdHVz KTsKKwlnMmhfcmVsZWFzZV9zcGFjZShjdCwgR1VDX0NUQl9IWEdfTVNHX01BWF9MRU4pOwogCWlm ICh1bmxpa2VseShlcnIpKQogCQlnb3RvIHVubGluazsKIApAQCAtNzExLDcgKzc1NywxMCBAQCBp bnQgaW50ZWxfZ3VjX2N0X3NlbmQoc3RydWN0IGludGVsX2d1Y19jdCAqY3QsIGNvbnN0IHUzMiAq YWN0aW9uLCB1MzIgbGVuLAogCWludCByZXQ7CiAKIAlpZiAodW5saWtlbHkoIWN0LT5lbmFibGVk KSkgewotCQlXQVJOKDEsICJVbmV4cGVjdGVkIHNlbmQ6IGFjdGlvbj0lI3hcbiIsICphY3Rpb24p OworCQlzdHJ1Y3QgaW50ZWxfZ3VjICpndWMgPSBjdF90b19ndWMoY3QpOworCQlzdHJ1Y3QgaW50 ZWxfdWMgKnVjID0gY29udGFpbmVyX29mKGd1Yywgc3RydWN0IGludGVsX3VjLCBndWMpOworCisJ CVdBUk4oIXVjLT5yZXNldF9pbl9wcm9ncmVzcywgIlVuZXhwZWN0ZWQgc2VuZDogYWN0aW9uPSUj eFxuIiwgKmFjdGlvbik7CiAJCXJldHVybiAtRU5PREVWOwogCX0KIApAQCAtOTI4LDYgKzk3Nywx OSBAQCBzdGF0aWMgaW50IGN0X3Byb2Nlc3NfcmVxdWVzdChzdHJ1Y3QgaW50ZWxfZ3VjX2N0ICpj dCwgc3RydWN0IGN0X2luY29taW5nX21zZyAqcgogCWNhc2UgSU5URUxfR1VDX0FDVElPTl9ERUZB VUxUOgogCQlyZXQgPSBpbnRlbF9ndWNfdG9faG9zdF9wcm9jZXNzX3JlY3ZfbXNnKGd1YywgcGF5 bG9hZCwgbGVuKTsKIAkJYnJlYWs7CisJY2FzZSBJTlRFTF9HVUNfQUNUSU9OX0RFUkVHSVNURVJf Q09OVEVYVF9ET05FOgorCQlyZXQgPSBpbnRlbF9ndWNfZGVyZWdpc3Rlcl9kb25lX3Byb2Nlc3Nf bXNnKGd1YywgcGF5bG9hZCwKKwkJCQkJCQkgICAgbGVuKTsKKwkJYnJlYWs7CisJY2FzZSBJTlRF TF9HVUNfQUNUSU9OX1NDSEVEX0NPTlRFWFRfTU9ERV9ET05FOgorCQlyZXQgPSBpbnRlbF9ndWNf c2NoZWRfZG9uZV9wcm9jZXNzX21zZyhndWMsIHBheWxvYWQsIGxlbik7CisJCWJyZWFrOworCWNh c2UgSU5URUxfR1VDX0FDVElPTl9DT05URVhUX1JFU0VUX05PVElGSUNBVElPTjoKKwkJcmV0ID0g aW50ZWxfZ3VjX2NvbnRleHRfcmVzZXRfcHJvY2Vzc19tc2coZ3VjLCBwYXlsb2FkLCBsZW4pOwor CQlicmVhazsKKwljYXNlIElOVEVMX0dVQ19BQ1RJT05fRU5HSU5FX0ZBSUxVUkVfTk9USUZJQ0FU SU9OOgorCQlyZXQgPSBpbnRlbF9ndWNfZW5naW5lX2ZhaWx1cmVfcHJvY2Vzc19tc2coZ3VjLCBw YXlsb2FkLCBsZW4pOworCQlicmVhazsKIAlkZWZhdWx0OgogCQlyZXQgPSAtRU9QTk9UU1VQUDsK IAkJYnJlYWs7CkBAIC05ODUsMTAgKzEwNDcsMjIgQEAgc3RhdGljIHZvaWQgY3RfaW5jb21pbmdf cmVxdWVzdF93b3JrZXJfZnVuYyhzdHJ1Y3Qgd29ya19zdHJ1Y3QgKncpCiBzdGF0aWMgaW50IGN0 X2hhbmRsZV9ldmVudChzdHJ1Y3QgaW50ZWxfZ3VjX2N0ICpjdCwgc3RydWN0IGN0X2luY29taW5n X21zZyAqcmVxdWVzdCkKIHsKIAljb25zdCB1MzIgKmh4ZyA9ICZyZXF1ZXN0LT5tc2dbR1VDX0NU Ql9NU0dfTUlOX0xFTl07CisJdTMyIGFjdGlvbiA9IEZJRUxEX0dFVChHVUNfSFhHX0VWRU5UX01T R18wX0FDVElPTiwgaHhnWzBdKTsKIAl1bnNpZ25lZCBsb25nIGZsYWdzOwogCiAJR0VNX0JVR19P TihGSUVMRF9HRVQoR1VDX0hYR19NU0dfMF9UWVBFLCBoeGdbMF0pICE9IEdVQ19IWEdfVFlQRV9F VkVOVCk7CiAKKwkvKgorCSAqIEFkanVzdGluZyB0aGUgc3BhY2UgbXVzdCBiZSBkb25lIGluIElS USBvciBkZWFkbG9jayBjYW4gb2NjdXIgYXMgdGhlCisJICogQ1RCIHByb2Nlc3NpbmcgaW4gdGhl IGJlbG93IHdvcmtxdWV1ZSBjYW4gc2VuZCBDVEJzIHdoaWNoIGNyZWF0ZXMgYQorCSAqIGNpcmN1 bGFyIGRlcGVuZGVuY3kgaWYgdGhlIHNwYWNlIHdhcyByZXR1cm5lZCB0aGVyZS4KKwkgKi8KKwlz d2l0Y2ggKGFjdGlvbikgeworCWNhc2UgSU5URUxfR1VDX0FDVElPTl9TQ0hFRF9DT05URVhUX01P REVfRE9ORToKKwljYXNlIElOVEVMX0dVQ19BQ1RJT05fREVSRUdJU1RFUl9DT05URVhUX0RPTkU6 CisJCWcyaF9yZWxlYXNlX3NwYWNlKGN0LCByZXF1ZXN0LT5zaXplKTsKKwl9CisKIAlzcGluX2xv Y2tfaXJxc2F2ZSgmY3QtPnJlcXVlc3RzLmxvY2ssIGZsYWdzKTsKIAlsaXN0X2FkZF90YWlsKCZy ZXF1ZXN0LT5saW5rLCAmY3QtPnJlcXVlc3RzLmluY29taW5nKTsKIAlzcGluX3VubG9ja19pcnFy ZXN0b3JlKCZjdC0+cmVxdWVzdHMubG9jaywgZmxhZ3MpOwpAQCAtMTEwNiwzICsxMTgwLDI1IEBA IHZvaWQgaW50ZWxfZ3VjX2N0X2V2ZW50X2hhbmRsZXIoc3RydWN0IGludGVsX2d1Y19jdCAqY3Qp CiAKIAljdF90cnlfcmVjZWl2ZV9tZXNzYWdlKGN0KTsKIH0KKwordm9pZCBpbnRlbF9ndWNfY3Rf cHJpbnRfaW5mbyhzdHJ1Y3QgaW50ZWxfZ3VjX2N0ICpjdCwKKwkJCSAgICAgc3RydWN0IGRybV9w cmludGVyICpwKQoreworCWRybV9wcmludGYocCwgIkNUICVzXG4iLCBlbmFibGVkZGlzYWJsZWQo Y3QtPmVuYWJsZWQpKTsKKworCWlmICghY3QtPmVuYWJsZWQpCisJCXJldHVybjsKKworCWRybV9w cmludGYocCwgIkgyRyBTcGFjZTogJXVcbiIsCisJCSAgIGF0b21pY19yZWFkKCZjdC0+Y3Ricy5z ZW5kLnNwYWNlKSAqIDQpOworCWRybV9wcmludGYocCwgIkhlYWQ6ICV1XG4iLAorCQkgICBjdC0+ Y3Ricy5zZW5kLmRlc2MtPmhlYWQpOworCWRybV9wcmludGYocCwgIlRhaWw6ICV1XG4iLAorCQkg ICBjdC0+Y3Ricy5zZW5kLmRlc2MtPnRhaWwpOworCWRybV9wcmludGYocCwgIkcySCBTcGFjZTog JXVcbiIsCisJCSAgIGF0b21pY19yZWFkKCZjdC0+Y3Ricy5yZWN2LnNwYWNlKSAqIDQpOworCWRy bV9wcmludGYocCwgIkhlYWQ6ICV1XG4iLAorCQkgICBjdC0+Y3Ricy5yZWN2LmRlc2MtPmhlYWQp OworCWRybV9wcmludGYocCwgIlRhaWw6ICV1XG4iLAorCQkgICBjdC0+Y3Ricy5yZWN2LmRlc2Mt PnRhaWwpOworfQpkaWZmIC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJtL2k5MTUvZ3QvdWMvaW50ZWxf Z3VjX2N0LmggYi9kcml2ZXJzL2dwdS9kcm0vaTkxNS9ndC91Yy9pbnRlbF9ndWNfY3QuaAppbmRl eCBlZGQxYmJhMDQ0NWQuLjdiMzQwMjZkMjY0YSAxMDA2NDQKLS0tIGEvZHJpdmVycy9ncHUvZHJt L2k5MTUvZ3QvdWMvaW50ZWxfZ3VjX2N0LmgKKysrIGIvZHJpdmVycy9ncHUvZHJtL2k5MTUvZ3Qv dWMvaW50ZWxfZ3VjX2N0LmgKQEAgLTEwLDExICsxMCwxMyBAQAogI2luY2x1ZGUgPGxpbnV4L3Nw aW5sb2NrLmg+CiAjaW5jbHVkZSA8bGludXgvd29ya3F1ZXVlLmg+CiAjaW5jbHVkZSA8bGludXgv a3RpbWUuaD4KKyNpbmNsdWRlIDxsaW51eC93YWl0Lmg+CiAKICNpbmNsdWRlICJpbnRlbF9ndWNf ZndpZi5oIgogCiBzdHJ1Y3QgaTkxNV92bWE7CiBzdHJ1Y3QgaW50ZWxfZ3VjOworc3RydWN0IGRy bV9wcmludGVyOwogCiAvKioKICAqIERPQzogQ29tbWFuZCBUcmFuc3BvcnQgKENUKS4KQEAgLTMz LDYgKzM1LDcgQEAgc3RydWN0IGludGVsX2d1YzsKICAqIEBkZXNjOiBwb2ludGVyIHRvIHRoZSBi dWZmZXIgZGVzY3JpcHRvcgogICogQGNtZHM6IHBvaW50ZXIgdG8gdGhlIGNvbW1hbmRzIGJ1ZmZl cgogICogQHNpemU6IHNpemUgb2YgdGhlIGNvbW1hbmRzIGJ1ZmZlciBpbiBkd29yZHMKKyAqIEBy ZXN2X3NwYWNlOiByZXNlcnZlZCBzcGFjZSBpbiBidWZmZXIgaW4gZHdvcmRzCiAgKiBAaGVhZDog bG9jYWwgc2hhZG93IGNvcHkgb2YgaGVhZCBpbiBkd29yZHMKICAqIEB0YWlsOiBsb2NhbCBzaGFk b3cgY29weSBvZiB0YWlsIGluIGR3b3JkcwogICogQHNwYWNlOiBsb2NhbCBzaGFkb3cgY29weSBv ZiBzcGFjZSBpbiBkd29yZHMKQEAgLTQzLDkgKzQ2LDEwIEBAIHN0cnVjdCBpbnRlbF9ndWNfY3Rf YnVmZmVyIHsKIAlzdHJ1Y3QgZ3VjX2N0X2J1ZmZlcl9kZXNjICpkZXNjOwogCXUzMiAqY21kczsK IAl1MzIgc2l6ZTsKKwl1MzIgcmVzdl9zcGFjZTsKIAl1MzIgdGFpbDsKIAl1MzIgaGVhZDsKLQl1 MzIgc3BhY2U7CisJYXRvbWljX3Qgc3BhY2U7CiAJYm9vbCBicm9rZW47CiB9OwogCkBAIC02Niw2 ICs3MCw5IEBAIHN0cnVjdCBpbnRlbF9ndWNfY3QgewogCiAJc3RydWN0IHRhc2tsZXRfc3RydWN0 IHJlY2VpdmVfdGFza2xldDsKIAorCS8qKiBAd3E6IHdhaXQgcXVldWUgZm9yIGcyaCBjaGFuZW5s ICovCisJd2FpdF9xdWV1ZV9oZWFkX3Qgd3E7CisKIAlzdHJ1Y3QgewogCQl1MTYgbGFzdF9mZW5j ZTsgLyogbGFzdCBmZW5jZSB1c2VkIHRvIHNlbmQgcmVxdWVzdCAqLwogCkBAIC05Nyw4ICsxMDQs MTUgQEAgc3RhdGljIGlubGluZSBib29sIGludGVsX2d1Y19jdF9lbmFibGVkKHN0cnVjdCBpbnRl bF9ndWNfY3QgKmN0KQogfQogCiAjZGVmaW5lIElOVEVMX0dVQ19DVF9TRU5EX05CCQlCSVQoMzEp CisjZGVmaW5lIElOVEVMX0dVQ19DVF9TRU5EX0cySF9EV19TSElGVAkwCisjZGVmaW5lIElOVEVM X0dVQ19DVF9TRU5EX0cySF9EV19NQVNLCSgweGZmIDw8IElOVEVMX0dVQ19DVF9TRU5EX0cySF9E V19TSElGVCkKKyNkZWZpbmUgTUFLRV9TRU5EX0ZMQUdTKGxlbikgXAorCSh7R0VNX0JVR19PTigh RklFTERfRklUKElOVEVMX0dVQ19DVF9TRU5EX0cySF9EV19NQVNLLCBsZW4pKTsgXAorCShGSUVM RF9QUkVQKElOVEVMX0dVQ19DVF9TRU5EX0cySF9EV19NQVNLLCBsZW4pIHwgSU5URUxfR1VDX0NU X1NFTkRfTkIpO30pCiBpbnQgaW50ZWxfZ3VjX2N0X3NlbmQoc3RydWN0IGludGVsX2d1Y19jdCAq Y3QsIGNvbnN0IHUzMiAqYWN0aW9uLCB1MzIgbGVuLAogCQkgICAgICB1MzIgKnJlc3BvbnNlX2J1 ZiwgdTMyIHJlc3BvbnNlX2J1Zl9zaXplLCB1MzIgZmxhZ3MpOwogdm9pZCBpbnRlbF9ndWNfY3Rf ZXZlbnRfaGFuZGxlcihzdHJ1Y3QgaW50ZWxfZ3VjX2N0ICpjdCk7CiAKK3ZvaWQgaW50ZWxfZ3Vj X2N0X3ByaW50X2luZm8oc3RydWN0IGludGVsX2d1Y19jdCAqY3QsIHN0cnVjdCBkcm1fcHJpbnRl ciAqcCk7CisKICNlbmRpZiAvKiBfSU5URUxfR1VDX0NUX0hfICovCmRpZmYgLS1naXQgYS9kcml2 ZXJzL2dwdS9kcm0vaTkxNS9ndC91Yy9pbnRlbF9ndWNfZGVidWdmcy5jIGIvZHJpdmVycy9ncHUv ZHJtL2k5MTUvZ3QvdWMvaW50ZWxfZ3VjX2RlYnVnZnMuYwppbmRleCBmZTdjYjdiMjlhMWUuLjcy ZGRmZmY0MmY3ZCAxMDA2NDQKLS0tIGEvZHJpdmVycy9ncHUvZHJtL2k5MTUvZ3QvdWMvaW50ZWxf Z3VjX2RlYnVnZnMuYworKysgYi9kcml2ZXJzL2dwdS9kcm0vaTkxNS9ndC91Yy9pbnRlbF9ndWNf ZGVidWdmcy5jCkBAIC05LDYgKzksOSBAQAogI2luY2x1ZGUgImludGVsX2d1Yy5oIgogI2luY2x1 ZGUgImludGVsX2d1Y19kZWJ1Z2ZzLmgiCiAjaW5jbHVkZSAiaW50ZWxfZ3VjX2xvZ19kZWJ1Z2Zz LmgiCisjaW5jbHVkZSAiZ3QvdWMvaW50ZWxfZ3VjX2N0LmgiCisjaW5jbHVkZSAiZ3QvdWMvaW50 ZWxfZ3VjX2Fkcy5oIgorI2luY2x1ZGUgImd0L3VjL2ludGVsX2d1Y19zdWJtaXNzaW9uLmgiCiAK IHN0YXRpYyBpbnQgZ3VjX2luZm9fc2hvdyhzdHJ1Y3Qgc2VxX2ZpbGUgKm0sIHZvaWQgKmRhdGEp CiB7CkBAIC0yMiwxNiArMjUsMzYgQEAgc3RhdGljIGludCBndWNfaW5mb19zaG93KHN0cnVjdCBz ZXFfZmlsZSAqbSwgdm9pZCAqZGF0YSkKIAlkcm1fcHV0cygmcCwgIlxuIik7CiAJaW50ZWxfZ3Vj X2xvZ19pbmZvKCZndWMtPmxvZywgJnApOwogCi0JLyogQWRkIG1vcmUgYXMgcmVxdWlyZWQgLi4u ICovCisJaWYgKCFpbnRlbF9ndWNfc3VibWlzc2lvbl9pc191c2VkKGd1YykpCisJCXJldHVybiAw OworCisJaW50ZWxfZ3VjX2N0X3ByaW50X2luZm8oJmd1Yy0+Y3QsICZwKTsKKwlpbnRlbF9ndWNf c3VibWlzc2lvbl9wcmludF9pbmZvKGd1YywgJnApOworCWludGVsX2d1Y19hZHNfcHJpbnRfcG9s aWN5X2luZm8oZ3VjLCAmcCk7CiAKIAlyZXR1cm4gMDsKIH0KIERFRklORV9HVF9ERUJVR0ZTX0FU VFJJQlVURShndWNfaW5mbyk7CiAKK3N0YXRpYyBpbnQgZ3VjX3JlZ2lzdGVyZWRfY29udGV4dHNf c2hvdyhzdHJ1Y3Qgc2VxX2ZpbGUgKm0sIHZvaWQgKmRhdGEpCit7CisJc3RydWN0IGludGVsX2d1 YyAqZ3VjID0gbS0+cHJpdmF0ZTsKKwlzdHJ1Y3QgZHJtX3ByaW50ZXIgcCA9IGRybV9zZXFfZmls ZV9wcmludGVyKG0pOworCisJaWYgKCFpbnRlbF9ndWNfc3VibWlzc2lvbl9pc191c2VkKGd1Yykp CisJCXJldHVybiAtRU5PREVWOworCisJaW50ZWxfZ3VjX3N1Ym1pc3Npb25fcHJpbnRfY29udGV4 dF9pbmZvKGd1YywgJnApOworCisJcmV0dXJuIDA7Cit9CitERUZJTkVfR1RfREVCVUdGU19BVFRS SUJVVEUoZ3VjX3JlZ2lzdGVyZWRfY29udGV4dHMpOworCiB2b2lkIGludGVsX2d1Y19kZWJ1Z2Zz X3JlZ2lzdGVyKHN0cnVjdCBpbnRlbF9ndWMgKmd1Yywgc3RydWN0IGRlbnRyeSAqcm9vdCkKIHsK IAlzdGF0aWMgY29uc3Qgc3RydWN0IGRlYnVnZnNfZ3RfZmlsZSBmaWxlc1tdID0gewogCQl7ICJn dWNfaW5mbyIsICZndWNfaW5mb19mb3BzLCBOVUxMIH0sCisJCXsgImd1Y19yZWdpc3RlcmVkX2Nv bnRleHRzIiwgJmd1Y19yZWdpc3RlcmVkX2NvbnRleHRzX2ZvcHMsIE5VTEwgfSwKIAl9OwogCiAJ aWYgKCFpbnRlbF9ndWNfaXNfc3VwcG9ydGVkKGd1YykpCmRpZmYgLS1naXQgYS9kcml2ZXJzL2dw dS9kcm0vaTkxNS9ndC91Yy9pbnRlbF9ndWNfZndpZi5oIGIvZHJpdmVycy9ncHUvZHJtL2k5MTUv Z3QvdWMvaW50ZWxfZ3VjX2Z3aWYuaAppbmRleCA2MTdlYzYwMTY0OGQuLjk0YmIxY2E2Zjg4OSAx MDA2NDQKLS0tIGEvZHJpdmVycy9ncHUvZHJtL2k5MTUvZ3QvdWMvaW50ZWxfZ3VjX2Z3aWYuaAor KysgYi9kcml2ZXJzL2dwdS9kcm0vaTkxNS9ndC91Yy9pbnRlbF9ndWNfZndpZi5oCkBAIC0xNywx NCArMTcsMjEgQEAKICNpbmNsdWRlICJhYmkvZ3VjX2NvbW11bmljYXRpb25fY3RiX2FiaS5oIgog I2luY2x1ZGUgImFiaS9ndWNfbWVzc2FnZXNfYWJpLmgiCiAKKy8qIFBheWxvYWQgbGVuZ3RoIG9u bHkgaS5lLiBkb24ndCBpbmNsdWRlIEcySCBoZWFkZXIgbGVuZ3RoICovCisjZGVmaW5lIEcySF9M RU5fRFdfU0NIRURfQ09OVEVYVF9NT0RFX1NFVAkyCisjZGVmaW5lIEcySF9MRU5fRFdfREVSRUdJ U1RFUl9DT05URVhUCQkxCisKKyNkZWZpbmUgR1VDX0NPTlRFWFRfRElTQUJMRQkJMAorI2RlZmlu ZSBHVUNfQ09OVEVYVF9FTkFCTEUJCTEKKwogI2RlZmluZSBHVUNfQ0xJRU5UX1BSSU9SSVRZX0tN RF9ISUdICTAKICNkZWZpbmUgR1VDX0NMSUVOVF9QUklPUklUWV9ISUdICTEKICNkZWZpbmUgR1VD X0NMSUVOVF9QUklPUklUWV9LTURfTk9STUFMCTIKICNkZWZpbmUgR1VDX0NMSUVOVF9QUklPUklU WV9OT1JNQUwJMwogI2RlZmluZSBHVUNfQ0xJRU5UX1BSSU9SSVRZX05VTQkJNAogCi0jZGVmaW5l IEdVQ19NQVhfU1RBR0VfREVTQ1JJUFRPUlMJMTAyNAotI2RlZmluZQlHVUNfSU5WQUxJRF9TVEFH RV9JRAkJR1VDX01BWF9TVEFHRV9ERVNDUklQVE9SUworI2RlZmluZSBHVUNfTUFYX0xSQ19ERVND UklQVE9SUwkJNjU1MzUKKyNkZWZpbmUJR1VDX0lOVkFMSURfTFJDX0lECQlHVUNfTUFYX0xSQ19E RVNDUklQVE9SUwogCiAjZGVmaW5lIEdVQ19SRU5ERVJfRU5HSU5FCQkwCiAjZGVmaW5lIEdVQ19W SURFT19FTkdJTkUJCTEKQEAgLTE3NSw2NiArMTgyLDM5IEBAIHN0cnVjdCBndWNfcHJvY2Vzc19k ZXNjIHsKIAl1MzIgcmVzZXJ2ZWRbMzBdOwogfSBfX3BhY2tlZDsKIAotLyogZW5naW5lIGlkIGFu ZCBjb250ZXh0IGlkIGlzIHBhY2tlZCBpbnRvIGd1Y19leGVjbGlzdF9jb250ZXh0LmNvbnRleHRf aWQqLwotI2RlZmluZSBHVUNfRUxDX0NUWElEX09GRlNFVAkJMAotI2RlZmluZSBHVUNfRUxDX0VO R0lORV9PRkZTRVQJCTI5CisjZGVmaW5lIENPTlRFWFRfUkVHSVNUUkFUSU9OX0ZMQUdfS01ECUJJ VCgwKQogCi0vKiBUaGUgZXhlY2xpc3QgY29udGV4dCBpbmNsdWRpbmcgc29mdHdhcmUgYW5kIEhX IGluZm9ybWF0aW9uICovCi1zdHJ1Y3QgZ3VjX2V4ZWNsaXN0X2NvbnRleHQgewotCXUzMiBjb250 ZXh0X2Rlc2M7Ci0JdTMyIGNvbnRleHRfaWQ7Ci0JdTMyIHJpbmdfc3RhdHVzOwotCXUzMiByaW5n X2xyY2E7Ci0JdTMyIHJpbmdfYmVnaW47Ci0JdTMyIHJpbmdfZW5kOwotCXUzMiByaW5nX25leHRf ZnJlZV9sb2NhdGlvbjsKLQl1MzIgcmluZ19jdXJyZW50X3RhaWxfcG9pbnRlcl92YWx1ZTsKLQl1 OCBlbmdpbmVfc3RhdGVfc3VibWl0X3ZhbHVlOwotCXU4IGVuZ2luZV9zdGF0ZV93YWl0X3ZhbHVl OwotCXUxNiBwYWdlZmF1bHRfY291bnQ7Ci0JdTE2IGVuZ2luZV9zdWJtaXRfcXVldWVfY291bnQ7 Ci19IF9fcGFja2VkOworI2RlZmluZSBDT05URVhUX1BPTElDWV9ERUZBVUxUX0VYRUNVVElPTl9R VUFOVFVNX1VTIDEwMDAwMDAKKyNkZWZpbmUgQ09OVEVYVF9QT0xJQ1lfREVGQVVMVF9QUkVFTVBU SU9OX1RJTUVfVVMgNTAwMDAwCisKKy8qIFByZWVtcHQgdG8gaWRsZSBvbiBxdWFudHVtIGV4cGly eSAqLworI2RlZmluZSBDT05URVhUX1BPTElDWV9GTEFHX1BSRUVNUFRfVE9fSURMRQlCSVQoMCkK IAogLyoKLSAqIFRoaXMgc3RydWN0dXJlIGRlc2NyaWJlcyBhIHN0YWdlIHNldCBhcnJhbmdlZCBm b3IgYSBwYXJ0aWN1bGFyIGNvbW11bmljYXRpb24KLSAqIGJldHdlZW4gdUtlcm5lbCAoR3VDKSBh bmQgRHJpdmVyIChLTUQpLiBUZWNobmljYWxseSwgdGhpcyBpcyBrbm93biBhcyBhCi0gKiAiR3VD IENvbnRleHQgZGVzY3JpcHRvciIgaW4gdGhlIHNwZWNzLCBidXQgd2UgdXNlIHRoZSB0ZXJtICJz dGFnZSBkZXNjcmlwdG9yIgotICogdG8gYXZvaWQgY29uZnVzaW9uIHdpdGggYWxsIHRoZSBvdGhl ciB0aGluZ3MgYWxyZWFkeSBuYW1lZCAiY29udGV4dCIgaW4gdGhlCi0gKiBkcml2ZXIuIEEgc3Rh dGljIHBvb2wgb2YgdGhlc2UgZGVzY3JpcHRvcnMgYXJlIHN0b3JlZCBpbnNpZGUgYSBHRU0gb2Jq ZWN0Ci0gKiAoc3RhZ2VfZGVzY19wb29sKSB3aGljaCBpcyBoZWxkIGZvciB0aGUgZW50aXJlIGxp ZmV0aW1lIG9mIG91ciBpbnRlcmFjdGlvbgotICogd2l0aCB0aGUgR3VDLCBiZWluZyBhbGxvY2F0 ZWQgYmVmb3JlIHRoZSBHdUMgaXMgbG9hZGVkIHdpdGggaXRzIGZpcm13YXJlLgorICogR3VDIENv bnRleHQgcmVnaXN0cmF0aW9uIGRlc2NyaXB0b3IuCisgKiBGSVhNRTogVGhpcyBpcyBvbmx5IHJl cXVpcmVkIHRvIGV4aXN0IGR1cmluZyBjb250ZXh0IHJlZ2lzdHJhdGlvbi4KKyAqIFRoZSBjdXJy ZW50IDE6MSBiZXR3ZWVuIGd1Y19scmNfZGVzYyBhbmQgTFJDcyBmb3IgdGhlIGxpZmV0aW1lIG9m IHRoZSBMUkMKKyAqIGlzIG5vdCByZXF1aXJlZC4KICAqLwotc3RydWN0IGd1Y19zdGFnZV9kZXNj IHsKLQl1MzIgc2NoZWRfY29tbW9uX2FyZWE7Ci0JdTMyIHN0YWdlX2lkOwotCXUzMiBwYXNfaWQ7 Ci0JdTggZW5naW5lc191c2VkOwotCXU2NCBkYl90cmlnZ2VyX2NwdTsKLQl1MzIgZGJfdHJpZ2dl cl91azsKLQl1NjQgZGJfdHJpZ2dlcl9waHk7Ci0JdTE2IGRiX2lkOwotCi0Jc3RydWN0IGd1Y19l eGVjbGlzdF9jb250ZXh0IGxyY1tHVUNfTUFYX0VOR0lORVNfTlVNXTsKLQotCXU4IGF0dHJpYnV0 ZTsKLQorc3RydWN0IGd1Y19scmNfZGVzYyB7CisJdTMyIGh3X2NvbnRleHRfZGVzYzsKKwl1MzIg c2xwbV9wZXJmX21vZGVfaGludDsJLyogU1BMQyB2MSBvbmx5ICovCisJdTMyIHNscG1fZnJlcV9o aW50OworCXUzMiBlbmdpbmVfc3VibWl0X21hc2s7CQkvKiBJbiBsb2dpY2FsIHNwYWNlICovCisJ dTggZW5naW5lX2NsYXNzOworCXU4IHJlc2VydmVkMFszXTsKIAl1MzIgcHJpb3JpdHk7Ci0KLQl1 MzIgd3Ffc2FtcGxlZF90YWlsX29mZnNldDsKLQl1MzIgd3FfdG90YWxfc3VibWl0X2VucXVldWVz OwotCiAJdTMyIHByb2Nlc3NfZGVzYzsKIAl1MzIgd3FfYWRkcjsKIAl1MzIgd3Ffc2l6ZTsKLQot CXUzMiBlbmdpbmVfcHJlc2VuY2U7Ci0KLQl1OCBlbmdpbmVfc3VzcGVuZGVkOwotCi0JdTggcmVz ZXJ2ZWQwWzNdOwotCXU2NCByZXNlcnZlZDFbMV07Ci0KLQl1NjQgZGVzY19wcml2YXRlOworCXUz MiBjb250ZXh0X2ZsYWdzOwkJLyogQ09OVEVYVF9SRUdJU1RSQVRJT05fKiAqLworCS8qIFRpbWUg Zm9yIG9uZSB3b3JrbG9hZCB0byBleGVjdXRlLiAoaW4gbWljcm8gc2Vjb25kcykgKi8KKwl1MzIg ZXhlY3V0aW9uX3F1YW50dW07CisJLyogVGltZSB0byB3YWl0IGZvciBhIHByZWVtcHRpb24gcmVx dWVzdCB0byBjb21wbGV0ZSBiZWZvcmUgaXNzdWluZyBhCisJICogcmVzZXQuIChpbiBtaWNybyBz ZWNvbmRzKS4gKi8KKwl1MzIgcHJlZW1wdGlvbl90aW1lb3V0OworCXUzMiBwb2xpY3lfZmxhZ3M7 CQkvKiBDT05URVhUX1BPTElDWV8qICovCisJdTMyIHJlc2VydmVkMVsxOV07CiB9IF9fcGFja2Vk OwogCiAjZGVmaW5lIEdVQ19QT1dFUl9VTlNQRUNJRklFRAkwCmRpZmYgLS1naXQgYS9kcml2ZXJz L2dwdS9kcm0vaTkxNS9ndC91Yy9pbnRlbF9ndWNfc3VibWlzc2lvbi5jIGIvZHJpdmVycy9ncHUv ZHJtL2k5MTUvZ3QvdWMvaW50ZWxfZ3VjX3N1Ym1pc3Npb24uYwppbmRleCBlOWMyMzdiMTg2OTIu LjI1OWY3OWRmZTdiYiAxMDA2NDQKLS0tIGEvZHJpdmVycy9ncHUvZHJtL2k5MTUvZ3QvdWMvaW50 ZWxfZ3VjX3N1Ym1pc3Npb24uYworKysgYi9kcml2ZXJzL2dwdS9kcm0vaTkxNS9ndC91Yy9pbnRl bF9ndWNfc3VibWlzc2lvbi5jCkBAIC0xMCwxMCArMTAsMTMgQEAKICNpbmNsdWRlICJndC9pbnRl bF9icmVhZGNydW1icy5oIgogI2luY2x1ZGUgImd0L2ludGVsX2NvbnRleHQuaCIKICNpbmNsdWRl ICJndC9pbnRlbF9lbmdpbmVfcG0uaCIKKyNpbmNsdWRlICJndC9pbnRlbF9lbmdpbmVfaGVhcnRi ZWF0LmgiCiAjaW5jbHVkZSAiZ3QvaW50ZWxfZ3QuaCIKICNpbmNsdWRlICJndC9pbnRlbF9ndF9p cnEuaCIKICNpbmNsdWRlICJndC9pbnRlbF9ndF9wbS5oIgorI2luY2x1ZGUgImd0L2ludGVsX2d0 X3JlcXVlc3RzLmgiCiAjaW5jbHVkZSAiZ3QvaW50ZWxfbHJjLmgiCisjaW5jbHVkZSAiZ3QvaW50 ZWxfbHJjX3JlZy5oIgogI2luY2x1ZGUgImd0L2ludGVsX21vY3MuaCIKICNpbmNsdWRlICJndC9p bnRlbF9yaW5nLmgiCiAKQEAgLTU4LDI0NiArNjEsNjk3IEBACiAgKgogICovCiAKKy8qIEd1QyBW aXJ0dWFsIEVuZ2luZSAqLworc3RydWN0IGd1Y192aXJ0dWFsX2VuZ2luZSB7CisJc3RydWN0IGlu dGVsX2VuZ2luZV9jcyBiYXNlOworCXN0cnVjdCBpbnRlbF9jb250ZXh0IGNvbnRleHQ7Cit9Owor CitzdGF0aWMgc3RydWN0IGludGVsX2NvbnRleHQgKgorZ3VjX2NyZWF0ZV92aXJ0dWFsKHN0cnVj dCBpbnRlbF9lbmdpbmVfY3MgKipzaWJsaW5ncywgdW5zaWduZWQgaW50IGNvdW50KTsKKwogI2Rl ZmluZSBHVUNfUkVRVUVTVF9TSVpFIDY0IC8qIGJ5dGVzICovCiAKLXN0YXRpYyBpbmxpbmUgc3Ry dWN0IGk5MTVfcHJpb2xpc3QgKnRvX3ByaW9saXN0KHN0cnVjdCByYl9ub2RlICpyYikKKy8qCisg KiBCZWxvdyBpcyBhIHNldCBvZiBmdW5jdGlvbnMgd2hpY2ggY29udHJvbCB0aGUgR3VDIHNjaGVk dWxpbmcgc3RhdGUgd2hpY2ggZG8KKyAqIG5vdCByZXF1aXJlIGEgbG9jayBhcyBhbGwgc3RhdGUg dHJhbnNpdGlvbnMgYXJlIG11dHVhbGx5IGV4Y2x1c2l2ZS4gaS5lLiBJdAorICogaXMgbm90IHBv c3NpYmxlIGZvciB0aGUgY29udGV4dCBwaW5uaW5nIGNvZGUgYW5kIHN1Ym1pc3Npb24sIGZvciB0 aGUgc2FtZQorICogY29udGV4dCwgdG8gYmUgZXhlY3V0aW5nIHNpbXVsdGFuZW91c2x5LiBXZSBz dGlsbCBuZWVkIGFuIGF0b21pYyBhcyBpdCBpcworICogcG9zc2libGUgZm9yIHNvbWUgb2YgdGhl IGJpdHMgdG8gY2hhbmdpbmcgYXQgdGhlIHNhbWUgdGltZSB0aG91Z2guCisgKi8KKyNkZWZpbmUg U0NIRURfU1RBVEVfTk9fTE9DS19FTkFCTEVECQkJQklUKDApCisjZGVmaW5lIFNDSEVEX1NUQVRF X05PX0xPQ0tfUEVORElOR19FTkFCTEUJCUJJVCgxKQorI2RlZmluZSBTQ0hFRF9TVEFURV9OT19M T0NLX1JFR0lTVEVSRUQJCQlCSVQoMikKKyNkZWZpbmUgU0NIRURfU1RBVEVfTk9fTE9DS19CTE9D S0VEX1NISUZUCQkzCisjZGVmaW5lIFNDSEVEX1NUQVRFX05PX0xPQ0tfQkxPQ0tFRCBcCisJQklU KFNDSEVEX1NUQVRFX05PX0xPQ0tfQkxPQ0tFRF9TSElGVCkKKyNkZWZpbmUgU0NIRURfU1RBVEVf Tk9fTE9DS19CTE9DS0VEX01BU0sgXAorCSgweGZmZmYgPDwgU0NIRURfU1RBVEVfTk9fTE9DS19C TE9DS0VEX1NISUZUKQorc3RhdGljIGlubGluZSBib29sIGNvbnRleHRfZW5hYmxlZChzdHJ1Y3Qg aW50ZWxfY29udGV4dCAqY2UpCiB7Ci0JcmV0dXJuIHJiX2VudHJ5KHJiLCBzdHJ1Y3QgaTkxNV9w cmlvbGlzdCwgbm9kZSk7CisJcmV0dXJuIChhdG9taWNfcmVhZCgmY2UtPmd1Y19zY2hlZF9zdGF0 ZV9ub19sb2NrKSAmCisJCVNDSEVEX1NUQVRFX05PX0xPQ0tfRU5BQkxFRCk7Cit9CisKK3N0YXRp YyBpbmxpbmUgdm9pZCBzZXRfY29udGV4dF9lbmFibGVkKHN0cnVjdCBpbnRlbF9jb250ZXh0ICpj ZSkKK3sKKwlhdG9taWNfb3IoU0NIRURfU1RBVEVfTk9fTE9DS19FTkFCTEVELCAmY2UtPmd1Y19z Y2hlZF9zdGF0ZV9ub19sb2NrKTsKK30KKworc3RhdGljIGlubGluZSB2b2lkIGNscl9jb250ZXh0 X2VuYWJsZWQoc3RydWN0IGludGVsX2NvbnRleHQgKmNlKQoreworCWF0b21pY19hbmQoKHUzMil+ U0NIRURfU1RBVEVfTk9fTE9DS19FTkFCTEVELAorCQkgICAmY2UtPmd1Y19zY2hlZF9zdGF0ZV9u b19sb2NrKTsKK30KKworc3RhdGljIGlubGluZSBib29sIGNvbnRleHRfcGVuZGluZ19lbmFibGUo c3RydWN0IGludGVsX2NvbnRleHQgKmNlKQoreworCXJldHVybiAoYXRvbWljX3JlYWQoJmNlLT5n dWNfc2NoZWRfc3RhdGVfbm9fbG9jaykgJgorCQlTQ0hFRF9TVEFURV9OT19MT0NLX1BFTkRJTkdf RU5BQkxFKTsKIH0KIAotc3RhdGljIHN0cnVjdCBndWNfc3RhZ2VfZGVzYyAqX19nZXRfc3RhZ2Vf ZGVzYyhzdHJ1Y3QgaW50ZWxfZ3VjICpndWMsIHUzMiBpZCkKK3N0YXRpYyBpbmxpbmUgdm9pZCBz ZXRfY29udGV4dF9wZW5kaW5nX2VuYWJsZShzdHJ1Y3QgaW50ZWxfY29udGV4dCAqY2UpCiB7Ci0J c3RydWN0IGd1Y19zdGFnZV9kZXNjICpiYXNlID0gZ3VjLT5zdGFnZV9kZXNjX3Bvb2xfdmFkZHI7 CisJYXRvbWljX29yKFNDSEVEX1NUQVRFX05PX0xPQ0tfUEVORElOR19FTkFCTEUsCisJCSAgJmNl LT5ndWNfc2NoZWRfc3RhdGVfbm9fbG9jayk7Cit9CisKK3N0YXRpYyBpbmxpbmUgdm9pZCBjbHJf Y29udGV4dF9wZW5kaW5nX2VuYWJsZShzdHJ1Y3QgaW50ZWxfY29udGV4dCAqY2UpCit7CisJYXRv bWljX2FuZCgodTMyKX5TQ0hFRF9TVEFURV9OT19MT0NLX1BFTkRJTkdfRU5BQkxFLAorCQkgICAm Y2UtPmd1Y19zY2hlZF9zdGF0ZV9ub19sb2NrKTsKK30KKworc3RhdGljIGlubGluZSB1MzIgY29u dGV4dF9ibG9ja2VkKHN0cnVjdCBpbnRlbF9jb250ZXh0ICpjZSkKK3sKKwlyZXR1cm4gKGF0b21p Y19yZWFkKCZjZS0+Z3VjX3NjaGVkX3N0YXRlX25vX2xvY2spICYKKwkJU0NIRURfU1RBVEVfTk9f TE9DS19CTE9DS0VEX01BU0spID4+CisJCVNDSEVEX1NUQVRFX05PX0xPQ0tfQkxPQ0tFRF9TSElG VDsKK30KKworc3RhdGljIGlubGluZSB2b2lkIGluY3JfY29udGV4dF9ibG9ja2VkKHN0cnVjdCBp bnRlbF9jb250ZXh0ICpjZSkKK3sKKwlsb2NrZGVwX2Fzc2VydF9oZWxkKCZjZS0+ZW5naW5lLT5z Y2hlZF9lbmdpbmUtPmxvY2spOworCWF0b21pY19hZGQoU0NIRURfU1RBVEVfTk9fTE9DS19CTE9D S0VELAorCQkgICAmY2UtPmd1Y19zY2hlZF9zdGF0ZV9ub19sb2NrKTsKK30KIAotCXJldHVybiAm YmFzZVtpZF07CitzdGF0aWMgaW5saW5lIHZvaWQgZGVjcl9jb250ZXh0X2Jsb2NrZWQoc3RydWN0 IGludGVsX2NvbnRleHQgKmNlKQoreworCWxvY2tkZXBfYXNzZXJ0X2hlbGQoJmNlLT5lbmdpbmUt PnNjaGVkX2VuZ2luZS0+bG9jayk7CisJYXRvbWljX3N1YihTQ0hFRF9TVEFURV9OT19MT0NLX0JM T0NLRUQsCisJCSAgICZjZS0+Z3VjX3NjaGVkX3N0YXRlX25vX2xvY2spOwogfQogCi1zdGF0aWMg aW50IGd1Y19zdGFnZV9kZXNjX3Bvb2xfY3JlYXRlKHN0cnVjdCBpbnRlbF9ndWMgKmd1YykKK3N0 YXRpYyBpbmxpbmUgYm9vbCBjb250ZXh0X3JlZ2lzdGVyZWQoc3RydWN0IGludGVsX2NvbnRleHQg KmNlKQogewotCXUzMiBzaXplID0gUEFHRV9BTElHTihzaXplb2Yoc3RydWN0IGd1Y19zdGFnZV9k ZXNjKSAqCi0JCQkgICAgICBHVUNfTUFYX1NUQUdFX0RFU0NSSVBUT1JTKTsKKwlyZXR1cm4gKGF0 b21pY19yZWFkKCZjZS0+Z3VjX3NjaGVkX3N0YXRlX25vX2xvY2spICYKKwkJU0NIRURfU1RBVEVf Tk9fTE9DS19SRUdJU1RFUkVEKTsKK30KIAotCXJldHVybiBpbnRlbF9ndWNfYWxsb2NhdGVfYW5k X21hcF92bWEoZ3VjLCBzaXplLCAmZ3VjLT5zdGFnZV9kZXNjX3Bvb2wsCi0JCQkJCSAgICAgICZn dWMtPnN0YWdlX2Rlc2NfcG9vbF92YWRkcik7CitzdGF0aWMgaW5saW5lIHZvaWQgc2V0X2NvbnRl eHRfcmVnaXN0ZXJlZChzdHJ1Y3QgaW50ZWxfY29udGV4dCAqY2UpCit7CisJYXRvbWljX29yKFND SEVEX1NUQVRFX05PX0xPQ0tfUkVHSVNURVJFRCwKKwkJICAmY2UtPmd1Y19zY2hlZF9zdGF0ZV9u b19sb2NrKTsKIH0KIAotc3RhdGljIHZvaWQgZ3VjX3N0YWdlX2Rlc2NfcG9vbF9kZXN0cm95KHN0 cnVjdCBpbnRlbF9ndWMgKmd1YykKK3N0YXRpYyBpbmxpbmUgdm9pZCBjbHJfY29udGV4dF9yZWdp c3RlcmVkKHN0cnVjdCBpbnRlbF9jb250ZXh0ICpjZSkKIHsKLQlpOTE1X3ZtYV91bnBpbl9hbmRf cmVsZWFzZSgmZ3VjLT5zdGFnZV9kZXNjX3Bvb2wsIEk5MTVfVk1BX1JFTEVBU0VfTUFQKTsKKwlh dG9taWNfYW5kKCh1MzIpflNDSEVEX1NUQVRFX05PX0xPQ0tfUkVHSVNURVJFRCwKKwkJICAgJmNl LT5ndWNfc2NoZWRfc3RhdGVfbm9fbG9jayk7CiB9CiAKIC8qCi0gKiBJbml0aWFsaXNlL2NsZWFy IHRoZSBzdGFnZSBkZXNjcmlwdG9yIHNoYXJlZCB3aXRoIHRoZSBHdUMgZmlybXdhcmUuCi0gKgot ICogVGhpcyBkZXNjcmlwdG9yIHRlbGxzIHRoZSBHdUMgd2hlcmUgKGluIEdHVFQgc3BhY2UpIHRv IGZpbmQgdGhlIGltcG9ydGFudAotICogZGF0YSBzdHJ1Y3R1cmVzIHJlbGF0ZWQgdG8gd29yayBz dWJtaXNzaW9uIChwcm9jZXNzIGRlc2NyaXB0b3IsIHdyaXRlIHF1ZXVlLAotICogZXRjKS4KKyAq IEJlbG93IGlzIGEgc2V0IG9mIGZ1bmN0aW9ucyB3aGljaCBjb250cm9sIHRoZSBHdUMgc2NoZWR1 bGluZyBzdGF0ZSB3aGljaAorICogcmVxdWlyZSBhIGxvY2ssIGFzaWRlIGZyb20gdGhlIHNwZWNp YWwgY2FzZSB3aGVyZSB0aGUgZnVuY3Rpb25zIGFyZSBjYWxsZWQKKyAqIGZyb20gZ3VjX2xyY19k ZXNjX3BpbigpLiBJbiB0aGF0IGNhc2UgaXQgaXNuJ3QgcG9zc2libGUgZm9yIGFueSBvdGhlciBj b2RlCisgKiBwYXRoIHRvIGJlIGV4ZWN1dGluZyBvbiB0aGUgY29udGV4dC4KICAqLwotc3RhdGlj IHZvaWQgZ3VjX3N0YWdlX2Rlc2NfaW5pdChzdHJ1Y3QgaW50ZWxfZ3VjICpndWMpCisjZGVmaW5l IFNDSEVEX1NUQVRFX1dBSVRfRk9SX0RFUkVHSVNURVJfVE9fUkVHSVNURVIJQklUKDApCisjZGVm aW5lIFNDSEVEX1NUQVRFX0RFU1RST1lFRAkJCQlCSVQoMSkKKyNkZWZpbmUgU0NIRURfU1RBVEVf UEVORElOR19ESVNBQkxFCQkJQklUKDIpCisjZGVmaW5lIFNDSEVEX1NUQVRFX0JBTk5FRAkJCQlC SVQoMykKK3N0YXRpYyBpbmxpbmUgdm9pZCBpbml0X3NjaGVkX3N0YXRlKHN0cnVjdCBpbnRlbF9j b250ZXh0ICpjZSkKK3sKKwkvKiBPbmx5IHNob3VsZCBiZSBjYWxsZWQgZnJvbSBndWNfbHJjX2Rl c2NfcGluKCkgKi8KKwlhdG9taWNfc2V0KCZjZS0+Z3VjX3NjaGVkX3N0YXRlX25vX2xvY2ssIDAp OworCWNlLT5ndWNfc3RhdGUuc2NoZWRfc3RhdGUgPSAwOworfQorCitzdGF0aWMgaW5saW5lIGJv b2wKK2NvbnRleHRfd2FpdF9mb3JfZGVyZWdpc3Rlcl90b19yZWdpc3RlcihzdHJ1Y3QgaW50ZWxf Y29udGV4dCAqY2UpCiB7Ci0Jc3RydWN0IGd1Y19zdGFnZV9kZXNjICpkZXNjOworCXJldHVybiBj ZS0+Z3VjX3N0YXRlLnNjaGVkX3N0YXRlICYKKwkJU0NIRURfU1RBVEVfV0FJVF9GT1JfREVSRUdJ U1RFUl9UT19SRUdJU1RFUjsKK30KIAotCS8qIHdlIG9ubHkgdXNlIDEgc3RhZ2UgZGVzYywgc28g aGFyZGNvZGUgaXQgdG8gMCAqLwotCWRlc2MgPSBfX2dldF9zdGFnZV9kZXNjKGd1YywgMCk7Ci0J bWVtc2V0KGRlc2MsIDAsIHNpemVvZigqZGVzYykpOworc3RhdGljIGlubGluZSB2b2lkCitzZXRf Y29udGV4dF93YWl0X2Zvcl9kZXJlZ2lzdGVyX3RvX3JlZ2lzdGVyKHN0cnVjdCBpbnRlbF9jb250 ZXh0ICpjZSkKK3sKKwkvKiBPbmx5IHNob3VsZCBiZSBjYWxsZWQgZnJvbSBndWNfbHJjX2Rlc2Nf cGluKCkgd2l0aG91dCBsb2NrICovCisJY2UtPmd1Y19zdGF0ZS5zY2hlZF9zdGF0ZSB8PQorCQlT Q0hFRF9TVEFURV9XQUlUX0ZPUl9ERVJFR0lTVEVSX1RPX1JFR0lTVEVSOworfQogCi0JZGVzYy0+ YXR0cmlidXRlID0gR1VDX1NUQUdFX0RFU0NfQVRUUl9BQ1RJVkUgfAotCQkJICBHVUNfU1RBR0Vf REVTQ19BVFRSX0tFUk5FTDsKK3N0YXRpYyBpbmxpbmUgdm9pZAorY2xyX2NvbnRleHRfd2FpdF9m b3JfZGVyZWdpc3Rlcl90b19yZWdpc3RlcihzdHJ1Y3QgaW50ZWxfY29udGV4dCAqY2UpCit7CisJ bG9ja2RlcF9hc3NlcnRfaGVsZCgmY2UtPmd1Y19zdGF0ZS5sb2NrKTsKKwljZS0+Z3VjX3N0YXRl LnNjaGVkX3N0YXRlICY9CisJCX5TQ0hFRF9TVEFURV9XQUlUX0ZPUl9ERVJFR0lTVEVSX1RPX1JF R0lTVEVSOworfQogCi0JZGVzYy0+c3RhZ2VfaWQgPSAwOwotCWRlc2MtPnByaW9yaXR5ID0gR1VD X0NMSUVOVF9QUklPUklUWV9LTURfTk9STUFMOworc3RhdGljIGlubGluZSBib29sCitjb250ZXh0 X2Rlc3Ryb3llZChzdHJ1Y3QgaW50ZWxfY29udGV4dCAqY2UpCit7CisJcmV0dXJuIGNlLT5ndWNf c3RhdGUuc2NoZWRfc3RhdGUgJiBTQ0hFRF9TVEFURV9ERVNUUk9ZRUQ7Cit9CiAKLQlkZXNjLT53 cV9zaXplID0gR1VDX1dRX1NJWkU7CitzdGF0aWMgaW5saW5lIHZvaWQKK3NldF9jb250ZXh0X2Rl c3Ryb3llZChzdHJ1Y3QgaW50ZWxfY29udGV4dCAqY2UpCit7CisJbG9ja2RlcF9hc3NlcnRfaGVs ZCgmY2UtPmd1Y19zdGF0ZS5sb2NrKTsKKwljZS0+Z3VjX3N0YXRlLnNjaGVkX3N0YXRlIHw9IFND SEVEX1NUQVRFX0RFU1RST1lFRDsKIH0KIAotc3RhdGljIHZvaWQgZ3VjX3N0YWdlX2Rlc2NfZmlu aShzdHJ1Y3QgaW50ZWxfZ3VjICpndWMpCitzdGF0aWMgaW5saW5lIGJvb2wgY29udGV4dF9wZW5k aW5nX2Rpc2FibGUoc3RydWN0IGludGVsX2NvbnRleHQgKmNlKQogewotCXN0cnVjdCBndWNfc3Rh Z2VfZGVzYyAqZGVzYzsKKwlyZXR1cm4gY2UtPmd1Y19zdGF0ZS5zY2hlZF9zdGF0ZSAmIFNDSEVE X1NUQVRFX1BFTkRJTkdfRElTQUJMRTsKK30KIAotCWRlc2MgPSBfX2dldF9zdGFnZV9kZXNjKGd1 YywgMCk7Ci0JbWVtc2V0KGRlc2MsIDAsIHNpemVvZigqZGVzYykpOworc3RhdGljIGlubGluZSB2 b2lkIHNldF9jb250ZXh0X3BlbmRpbmdfZGlzYWJsZShzdHJ1Y3QgaW50ZWxfY29udGV4dCAqY2Up Cit7CisJbG9ja2RlcF9hc3NlcnRfaGVsZCgmY2UtPmd1Y19zdGF0ZS5sb2NrKTsKKwljZS0+Z3Vj X3N0YXRlLnNjaGVkX3N0YXRlIHw9IFNDSEVEX1NUQVRFX1BFTkRJTkdfRElTQUJMRTsKIH0KIAot c3RhdGljIHZvaWQgZ3VjX2FkZF9yZXF1ZXN0KHN0cnVjdCBpbnRlbF9ndWMgKmd1Yywgc3RydWN0 IGk5MTVfcmVxdWVzdCAqcnEpCitzdGF0aWMgaW5saW5lIHZvaWQgY2xyX2NvbnRleHRfcGVuZGlu Z19kaXNhYmxlKHN0cnVjdCBpbnRlbF9jb250ZXh0ICpjZSkKIHsKLQkvKiBMZWF2aW5nIHN0dWIg YXMgdGhpcyBmdW5jdGlvbiB3aWxsIGJlIHVzZWQgaW4gZnV0dXJlIHBhdGNoZXMgKi8KKwlsb2Nr ZGVwX2Fzc2VydF9oZWxkKCZjZS0+Z3VjX3N0YXRlLmxvY2spOworCWNlLT5ndWNfc3RhdGUuc2No ZWRfc3RhdGUgJj0gflNDSEVEX1NUQVRFX1BFTkRJTkdfRElTQUJMRTsKIH0KIAotLyoKLSAqIFdo ZW4gd2UncmUgZG9pbmcgc3VibWlzc2lvbnMgdXNpbmcgcmVndWxhciBleGVjbGlzdHMgYmFja2Vu ZCwgd3JpdGluZyB0bwotICogRUxTUCBmcm9tIENQVSBzaWRlIGlzIGVub3VnaCB0byBtYWtlIHN1 cmUgdGhhdCB3cml0ZXMgdG8gcmluZ2J1ZmZlciBwYWdlcwotICogcGlubmVkIGluIG1hcHBhYmxl IGFwZXJ0dXJlIHBvcnRpb24gb2YgR0dUVCBhcmUgdmlzaWJsZSB0byBjb21tYW5kIHN0cmVhbWVy LgotICogV3JpdGVzIGRvbmUgYnkgR3VDIG9uIG91ciBiZWhhbGYgYXJlIG5vdCBndWFyYW50ZWVp bmcgc3VjaCBvcmRlcmluZywKLSAqIHRoZXJlZm9yZSwgdG8gZW5zdXJlIHRoZSBmbHVzaCwgd2Un cmUgaXNzdWluZyBhIFBPU1RJTkcgUkVBRC4KLSAqLwotc3RhdGljIHZvaWQgZmx1c2hfZ2d0dF93 cml0ZXMoc3RydWN0IGk5MTVfdm1hICp2bWEpCitzdGF0aWMgaW5saW5lIGJvb2wgY29udGV4dF9i YW5uZWQoc3RydWN0IGludGVsX2NvbnRleHQgKmNlKQogewotCWlmIChpOTE1X3ZtYV9pc19tYXBf YW5kX2ZlbmNlYWJsZSh2bWEpKQotCQlpbnRlbF91bmNvcmVfcG9zdGluZ19yZWFkX2Z3KHZtYS0+ dm0tPmd0LT51bmNvcmUsCi0JCQkJCSAgICAgR1VDX1NUQVRVUyk7CisJcmV0dXJuIGNlLT5ndWNf c3RhdGUuc2NoZWRfc3RhdGUgJiBTQ0hFRF9TVEFURV9CQU5ORUQ7CiB9CiAKLXN0YXRpYyB2b2lk IGd1Y19zdWJtaXQoc3RydWN0IGludGVsX2VuZ2luZV9jcyAqZW5naW5lLAotCQkgICAgICAgc3Ry dWN0IGk5MTVfcmVxdWVzdCAqKm91dCwKLQkJICAgICAgIHN0cnVjdCBpOTE1X3JlcXVlc3QgKipl bmQpCitzdGF0aWMgaW5saW5lIHZvaWQgc2V0X2NvbnRleHRfYmFubmVkKHN0cnVjdCBpbnRlbF9j b250ZXh0ICpjZSkKIHsKLQlzdHJ1Y3QgaW50ZWxfZ3VjICpndWMgPSAmZW5naW5lLT5ndC0+dWMu Z3VjOworCWxvY2tkZXBfYXNzZXJ0X2hlbGQoJmNlLT5ndWNfc3RhdGUubG9jayk7CisJY2UtPmd1 Y19zdGF0ZS5zY2hlZF9zdGF0ZSB8PSBTQ0hFRF9TVEFURV9CQU5ORUQ7Cit9CiAKLQlkbyB7Ci0J CXN0cnVjdCBpOTE1X3JlcXVlc3QgKnJxID0gKm91dCsrOworc3RhdGljIGlubGluZSB2b2lkIGNs cl9jb250ZXh0X2Jhbm5lZChzdHJ1Y3QgaW50ZWxfY29udGV4dCAqY2UpCit7CisJbG9ja2RlcF9h c3NlcnRfaGVsZCgmY2UtPmd1Y19zdGF0ZS5sb2NrKTsKKwljZS0+Z3VjX3N0YXRlLnNjaGVkX3N0 YXRlICY9IH5TQ0hFRF9TVEFURV9CQU5ORUQ7Cit9CiAKLQkJZmx1c2hfZ2d0dF93cml0ZXMocnEt PnJpbmctPnZtYSk7Ci0JCWd1Y19hZGRfcmVxdWVzdChndWMsIHJxKTsKLQl9IHdoaWxlIChvdXQg IT0gZW5kKTsKK3N0YXRpYyBpbmxpbmUgYm9vbCBjb250ZXh0X2d1Y19pZF9pbnZhbGlkKHN0cnVj dCBpbnRlbF9jb250ZXh0ICpjZSkKK3sKKwlyZXR1cm4gKGNlLT5ndWNfaWQgPT0gR1VDX0lOVkFM SURfTFJDX0lEKTsKIH0KIAotc3RhdGljIGlubGluZSBpbnQgcnFfcHJpbyhjb25zdCBzdHJ1Y3Qg aTkxNV9yZXF1ZXN0ICpycSkKK3N0YXRpYyBpbmxpbmUgdm9pZCBzZXRfY29udGV4dF9ndWNfaWRf aW52YWxpZChzdHJ1Y3QgaW50ZWxfY29udGV4dCAqY2UpCiB7Ci0JcmV0dXJuIHJxLT5zY2hlZC5h dHRyLnByaW9yaXR5OworCWNlLT5ndWNfaWQgPSBHVUNfSU5WQUxJRF9MUkNfSUQ7Cit9CisKK3N0 YXRpYyBpbmxpbmUgc3RydWN0IGludGVsX2d1YyAqY2VfdG9fZ3VjKHN0cnVjdCBpbnRlbF9jb250 ZXh0ICpjZSkKK3sKKwlyZXR1cm4gJmNlLT5lbmdpbmUtPmd0LT51Yy5ndWM7Cit9CisKK3N0YXRp YyBpbmxpbmUgc3RydWN0IGk5MTVfcHJpb2xpc3QgKnRvX3ByaW9saXN0KHN0cnVjdCByYl9ub2Rl ICpyYikKK3sKKwlyZXR1cm4gcmJfZW50cnkocmIsIHN0cnVjdCBpOTE1X3ByaW9saXN0LCBub2Rl KTsKK30KKworc3RhdGljIHN0cnVjdCBndWNfbHJjX2Rlc2MgKl9fZ2V0X2xyY19kZXNjKHN0cnVj dCBpbnRlbF9ndWMgKmd1YywgdTMyIGluZGV4KQoreworCXN0cnVjdCBndWNfbHJjX2Rlc2MgKmJh c2UgPSBndWMtPmxyY19kZXNjX3Bvb2xfdmFkZHI7CisKKwlHRU1fQlVHX09OKGluZGV4ID49IEdV Q19NQVhfTFJDX0RFU0NSSVBUT1JTKTsKKworCXJldHVybiAmYmFzZVtpbmRleF07Cit9CisKK3N0 YXRpYyBpbmxpbmUgc3RydWN0IGludGVsX2NvbnRleHQgKl9fZ2V0X2NvbnRleHQoc3RydWN0IGlu dGVsX2d1YyAqZ3VjLCB1MzIgaWQpCit7CisJc3RydWN0IGludGVsX2NvbnRleHQgKmNlID0geGFf bG9hZCgmZ3VjLT5jb250ZXh0X2xvb2t1cCwgaWQpOworCisJR0VNX0JVR19PTihpZCA+PSBHVUNf TUFYX0xSQ19ERVNDUklQVE9SUyk7CisKKwlyZXR1cm4gY2U7Cit9CisKK3N0YXRpYyBpbnQgZ3Vj X2xyY19kZXNjX3Bvb2xfY3JlYXRlKHN0cnVjdCBpbnRlbF9ndWMgKmd1YykKK3sKKwl1MzIgc2l6 ZTsKKwlpbnQgcmV0OworCisJc2l6ZSA9IFBBR0VfQUxJR04oc2l6ZW9mKHN0cnVjdCBndWNfbHJj X2Rlc2MpICoKKwkJCSAgR1VDX01BWF9MUkNfREVTQ1JJUFRPUlMpOworCXJldCA9IGludGVsX2d1 Y19hbGxvY2F0ZV9hbmRfbWFwX3ZtYShndWMsIHNpemUsICZndWMtPmxyY19kZXNjX3Bvb2wsCisJ CQkJCSAgICAgKHZvaWQgKiopJmd1Yy0+bHJjX2Rlc2NfcG9vbF92YWRkcik7CisJaWYgKHJldCkK KwkJcmV0dXJuIHJldDsKKworCXJldHVybiAwOwogfQogCi1zdGF0aWMgc3RydWN0IGk5MTVfcmVx dWVzdCAqc2NoZWR1bGVfaW4oc3RydWN0IGk5MTVfcmVxdWVzdCAqcnEsIGludCBpZHgpCitzdGF0 aWMgdm9pZCBndWNfbHJjX2Rlc2NfcG9vbF9kZXN0cm95KHN0cnVjdCBpbnRlbF9ndWMgKmd1YykK IHsKLQl0cmFjZV9pOTE1X3JlcXVlc3RfaW4ocnEsIGlkeCk7CisJZ3VjLT5scmNfZGVzY19wb29s X3ZhZGRyID0gTlVMTDsKKwlpOTE1X3ZtYV91bnBpbl9hbmRfcmVsZWFzZSgmZ3VjLT5scmNfZGVz Y19wb29sLCBJOTE1X1ZNQV9SRUxFQVNFX01BUCk7Cit9CisKK3N0YXRpYyBpbmxpbmUgYm9vbCBn dWNfc3VibWlzc2lvbl9pbml0aWFsaXplZChzdHJ1Y3QgaW50ZWxfZ3VjICpndWMpCit7CisJcmV0 dXJuIGd1Yy0+bHJjX2Rlc2NfcG9vbF92YWRkciAhPSBOVUxMOworfQorCitzdGF0aWMgaW5saW5l IHZvaWQgcmVzZXRfbHJjX2Rlc2Moc3RydWN0IGludGVsX2d1YyAqZ3VjLCB1MzIgaWQpCit7CisJ aWYgKGxpa2VseShndWNfc3VibWlzc2lvbl9pbml0aWFsaXplZChndWMpKSkgeworCQlzdHJ1Y3Qg Z3VjX2xyY19kZXNjICpkZXNjID0gX19nZXRfbHJjX2Rlc2MoZ3VjLCBpZCk7CisJCXVuc2lnbmVk IGxvbmcgZmxhZ3M7CisKKwkJbWVtc2V0KGRlc2MsIDAsIHNpemVvZigqZGVzYykpOworCisJCS8q CisJCSAqIHhhcnJheSBBUEkgZG9lc24ndCBoYXZlIHhhX2VyYXNlX2lycXNhdmUgd3JhcHBlciwg c28gY2FsbGluZworCQkgKiB0aGUgbG93ZXIgbGV2ZWwgZnVuY3Rpb25zIGRpcmVjdGx5LgorCQkg Ki8KKwkJeGFfbG9ja19pcnFzYXZlKCZndWMtPmNvbnRleHRfbG9va3VwLCBmbGFncyk7CisJCV9f eGFfZXJhc2UoJmd1Yy0+Y29udGV4dF9sb29rdXAsIGlkKTsKKwkJeGFfdW5sb2NrX2lycXJlc3Rv cmUoJmd1Yy0+Y29udGV4dF9sb29rdXAsIGZsYWdzKTsKKwl9Cit9CisKK3N0YXRpYyBpbmxpbmUg Ym9vbCBscmNfZGVzY19yZWdpc3RlcmVkKHN0cnVjdCBpbnRlbF9ndWMgKmd1YywgdTMyIGlkKQor eworCXJldHVybiBfX2dldF9jb250ZXh0KGd1YywgaWQpOworfQorCitzdGF0aWMgaW5saW5lIHZv aWQgc2V0X2xyY19kZXNjX3JlZ2lzdGVyZWQoc3RydWN0IGludGVsX2d1YyAqZ3VjLCB1MzIgaWQs CisJCQkJCSAgIHN0cnVjdCBpbnRlbF9jb250ZXh0ICpjZSkKK3sKKwl1bnNpZ25lZCBsb25nIGZs YWdzOwogCiAJLyoKLQkgKiBDdXJyZW50bHkgd2UgYXJlIG5vdCB0cmFja2luZyB0aGUgcnEtPmNv bnRleHQgYmVpbmcgaW5mbGlnaHQKLQkgKiAoY2UtPmluZmxpZ2h0ID0gcnEtPmVuZ2luZSkuIEl0 IGlzIG9ubHkgdXNlZCBieSB0aGUgZXhlY2xpc3RzCi0JICogYmFja2VuZCBhdCB0aGUgbW9tZW50 LCBhIHNpbWlsYXIgY291bnRpbmcgc3RyYXRlZ3kgd291bGQgYmUKLQkgKiByZXF1aXJlZCBpZiB3 ZSBnZW5lcmFsaXNlIHRoZSBpbmZsaWdodCB0cmFja2luZy4KKwkgKiB4YXJyYXkgQVBJIGRvZXNu J3QgaGF2ZSB4YV9zYXZlX2lycXNhdmUgd3JhcHBlciwgc28gY2FsbGluZyB0aGUKKwkgKiBsb3dl ciBsZXZlbCBmdW5jdGlvbnMgZGlyZWN0bHkuCiAJICovCisJeGFfbG9ja19pcnFzYXZlKCZndWMt PmNvbnRleHRfbG9va3VwLCBmbGFncyk7CisJX194YV9zdG9yZSgmZ3VjLT5jb250ZXh0X2xvb2t1 cCwgaWQsIGNlLCBHRlBfQVRPTUlDKTsKKwl4YV91bmxvY2tfaXJxcmVzdG9yZSgmZ3VjLT5jb250 ZXh0X2xvb2t1cCwgZmxhZ3MpOworfQorCitzdGF0aWMgaW50IGd1Y19zdWJtaXNzaW9uX3NlbmRf YnVzeV9sb29wKHN0cnVjdCBpbnRlbF9ndWMqIGd1YywKKwkJCQkJIGNvbnN0IHUzMiAqYWN0aW9u LAorCQkJCQkgdTMyIGxlbiwKKwkJCQkJIHUzMiBnMmhfbGVuX2R3LAorCQkJCQkgYm9vbCBsb29w KQoreworCWludCBlcnI7CisKKwllcnIgPSBpbnRlbF9ndWNfc2VuZF9idXN5X2xvb3AoZ3VjLCBh Y3Rpb24sIGxlbiwgZzJoX2xlbl9kdywgbG9vcCk7CiAKLQlfX2ludGVsX2d0X3BtX2dldChycS0+ ZW5naW5lLT5ndCk7Ci0JcmV0dXJuIGk5MTVfcmVxdWVzdF9nZXQocnEpOworCWlmICghZXJyICYm IGcyaF9sZW5fZHcpCisJCWF0b21pY19pbmMoJmd1Yy0+b3V0c3RhbmRpbmdfc3VibWlzc2lvbl9n MmgpOworCisJcmV0dXJuIGVycjsKIH0KIAotc3RhdGljIHZvaWQgc2NoZWR1bGVfb3V0KHN0cnVj dCBpOTE1X3JlcXVlc3QgKnJxKQoraW50IGludGVsX2d1Y193YWl0X2Zvcl9wZW5kaW5nX21zZyhz dHJ1Y3QgaW50ZWxfZ3VjICpndWMsCisJCQkJICAgYXRvbWljX3QgKndhaXRfdmFyLAorCQkJCSAg IGJvb2wgaW50ZXJydXB0aWJsZSwKKwkJCQkgICBsb25nIHRpbWVvdXQpCiB7Ci0JdHJhY2VfaTkx NV9yZXF1ZXN0X291dChycSk7CisJY29uc3QgaW50IHN0YXRlID0gaW50ZXJydXB0aWJsZSA/CisJ CVRBU0tfSU5URVJSVVBUSUJMRSA6IFRBU0tfVU5JTlRFUlJVUFRJQkxFOworCURFRklORV9XQUlU KHdhaXQpOworCisJbWlnaHRfc2xlZXAoKTsKKwlHRU1fQlVHX09OKHRpbWVvdXQgPCAwKTsKKwor CWlmICghYXRvbWljX3JlYWQod2FpdF92YXIpKQorCQlyZXR1cm4gMDsKKworCWlmICghdGltZW91 dCkKKwkJcmV0dXJuIC1FVElNRTsKKworCWZvciAoOzspIHsKKwkJcHJlcGFyZV90b193YWl0KCZn dWMtPmN0LndxLCAmd2FpdCwgc3RhdGUpOworCisJCWlmICghYXRvbWljX3JlYWQod2FpdF92YXIp KQorCQkJYnJlYWs7CisKKwkJaWYgKHNpZ25hbF9wZW5kaW5nX3N0YXRlKHN0YXRlLCBjdXJyZW50 KSkgeworCQkJdGltZW91dCA9IC1FSU5UUjsKKwkJCWJyZWFrOworCQl9CisKKwkJaWYgKCF0aW1l b3V0KSB7CisJCQl0aW1lb3V0ID0gLUVUSU1FOworCQkJYnJlYWs7CisJCX0KIAotCWludGVsX2d0 X3BtX3B1dF9hc3luYyhycS0+ZW5naW5lLT5ndCk7Ci0JaTkxNV9yZXF1ZXN0X3B1dChycSk7CisJ CXRpbWVvdXQgPSBpb19zY2hlZHVsZV90aW1lb3V0KHRpbWVvdXQpOworCX0KKwlmaW5pc2hfd2Fp dCgmZ3VjLT5jdC53cSwgJndhaXQpOworCisJcmV0dXJuICh0aW1lb3V0IDwgMCkgPyB0aW1lb3V0 IDogMDsKIH0KIAotc3RhdGljIHZvaWQgX19ndWNfZGVxdWV1ZShzdHJ1Y3QgaW50ZWxfZW5naW5l X2NzICplbmdpbmUpCitpbnQgaW50ZWxfZ3VjX3dhaXRfZm9yX2lkbGUoc3RydWN0IGludGVsX2d1 YyAqZ3VjLCBsb25nIHRpbWVvdXQpCiB7Ci0Jc3RydWN0IGludGVsX2VuZ2luZV9leGVjbGlzdHMg KiBjb25zdCBleGVjbGlzdHMgPSAmZW5naW5lLT5leGVjbGlzdHM7Ci0Jc3RydWN0IGk5MTVfc2No ZWRfZW5naW5lICogY29uc3Qgc2NoZWRfZW5naW5lID0gZW5naW5lLT5zY2hlZF9lbmdpbmU7Ci0J c3RydWN0IGk5MTVfcmVxdWVzdCAqKmZpcnN0ID0gZXhlY2xpc3RzLT5pbmZsaWdodDsKLQlzdHJ1 Y3QgaTkxNV9yZXF1ZXN0ICoqIGNvbnN0IGxhc3RfcG9ydCA9IGZpcnN0ICsgZXhlY2xpc3RzLT5w b3J0X21hc2s7Ci0Jc3RydWN0IGk5MTVfcmVxdWVzdCAqbGFzdCA9IGZpcnN0WzBdOwotCXN0cnVj dCBpOTE1X3JlcXVlc3QgKipwb3J0OwotCWJvb2wgc3VibWl0ID0gZmFsc2U7Ci0Jc3RydWN0IHJi X25vZGUgKnJiOworCWlmICghaW50ZWxfdWNfdXNlc19ndWNfc3VibWlzc2lvbigmZ3VjX3RvX2d0 KGd1YyktPnVjKSkKKwkJcmV0dXJuIDA7CiAKLQlsb2NrZGVwX2Fzc2VydF9oZWxkKCZzY2hlZF9l bmdpbmUtPmxvY2spOworCXJldHVybiBpbnRlbF9ndWNfd2FpdF9mb3JfcGVuZGluZ19tc2coZ3Vj LAorCQkJCQkgICAgICAmZ3VjLT5vdXRzdGFuZGluZ19zdWJtaXNzaW9uX2cyaCwKKwkJCQkJICAg ICAgdHJ1ZSwgdGltZW91dCk7Cit9CiAKLQlpZiAobGFzdCkgewotCQlpZiAoKisrZmlyc3QpCi0J CQlyZXR1cm47CitzdGF0aWMgaW50IGd1Y19scmNfZGVzY19waW4oc3RydWN0IGludGVsX2NvbnRl eHQgKmNlLCBib29sIGxvb3ApOwogCi0JCWxhc3QgPSBOVUxMOworc3RhdGljIGludCBndWNfYWRk X3JlcXVlc3Qoc3RydWN0IGludGVsX2d1YyAqZ3VjLCBzdHJ1Y3QgaTkxNV9yZXF1ZXN0ICpycSkK K3sKKwlpbnQgZXJyID0gMDsKKwlzdHJ1Y3QgaW50ZWxfY29udGV4dCAqY2UgPSBycS0+Y29udGV4 dDsKKwl1MzIgYWN0aW9uWzNdOworCWludCBsZW4gPSAwOworCXUzMiBnMmhfbGVuX2R3ID0gMDsK Kwlib29sIGVuYWJsZWQ7CisKKwkvKgorCSAqIENvcm5lciBjYXNlIHdoZXJlIHJlcXVlc3RzIHdl cmUgc2l0dGluZyBpbiB0aGUgcHJpb3JpdHkgbGlzdCBvciBhCisJICogcmVxdWVzdCByZXN1Ym1p dHRlZCBhZnRlciB0aGUgY29udGV4dCB3YXMgYmFubmVkLgorCSAqLworCWlmICh1bmxpa2VseShp bnRlbF9jb250ZXh0X2lzX2Jhbm5lZChjZSkpKSB7CisJCWk5MTVfcmVxdWVzdF9wdXQoaTkxNV9y ZXF1ZXN0X21hcmtfZWlvKHJxKSk7CisJCWludGVsX2VuZ2luZV9zaWduYWxfYnJlYWRjcnVtYnMo Y2UtPmVuZ2luZSk7CisJCWdvdG8gb3V0OwogCX0KIAorCUdFTV9CVUdfT04oIWF0b21pY19yZWFk KCZjZS0+Z3VjX2lkX3JlZikpOworCUdFTV9CVUdfT04oY29udGV4dF9ndWNfaWRfaW52YWxpZChj ZSkpOworCiAJLyoKLQkgKiBXZSB3cml0ZSBkaXJlY3RseSBpbnRvIHRoZSBleGVjbGlzdHMtPmlu ZmxpZ2h0IHF1ZXVlIGFuZCBkb24ndCB1c2UKLQkgKiB0aGUgZXhlY2xpc3RzLT5wZW5kaW5nIHF1 ZXVlLCBhcyB3ZSBkb24ndCBoYXZlIGEgZGlzdGluY3Qgc3dpdGNoCi0JICogZXZlbnQuCisJICog Q29ybmVyIGNhc2Ugd2hlcmUgdGhlIEd1QyBmaXJtd2FyZSB3YXMgYmxvd24gYXdheSBhbmQgcmVs b2FkZWQgd2hpbGUKKwkgKiB0aGlzIGNvbnRleHQgd2FzIHBpbm5lZC4KIAkgKi8KLQlwb3J0ID0g Zmlyc3Q7CisJaWYgKHVubGlrZWx5KCFscmNfZGVzY19yZWdpc3RlcmVkKGd1YywgY2UtPmd1Y19p ZCkpKSB7CisJCWVyciA9IGd1Y19scmNfZGVzY19waW4oY2UsIGZhbHNlKTsKKwkJaWYgKHVubGlr ZWx5KGVycikpCisJCQlnb3RvIG91dDsKKwl9CisKKwlpZiAodW5saWtlbHkoY29udGV4dF9ibG9j a2VkKGNlKSkpCisJCWdvdG8gb3V0OworCisJZW5hYmxlZCA9IGNvbnRleHRfZW5hYmxlZChjZSk7 CisKKwlpZiAoIWVuYWJsZWQpIHsKKwkJYWN0aW9uW2xlbisrXSA9IElOVEVMX0dVQ19BQ1RJT05f U0NIRURfQ09OVEVYVF9NT0RFX1NFVDsKKwkJYWN0aW9uW2xlbisrXSA9IGNlLT5ndWNfaWQ7CisJ CWFjdGlvbltsZW4rK10gPSBHVUNfQ09OVEVYVF9FTkFCTEU7CisJCXNldF9jb250ZXh0X3BlbmRp bmdfZW5hYmxlKGNlKTsKKwkJaW50ZWxfY29udGV4dF9nZXQoY2UpOworCQlnMmhfbGVuX2R3ID0g RzJIX0xFTl9EV19TQ0hFRF9DT05URVhUX01PREVfU0VUOworCX0gZWxzZSB7CisJCWFjdGlvblts ZW4rK10gPSBJTlRFTF9HVUNfQUNUSU9OX1NDSEVEX0NPTlRFWFQ7CisJCWFjdGlvbltsZW4rK10g PSBjZS0+Z3VjX2lkOworCX0KKworCWVyciA9IGludGVsX2d1Y19zZW5kX25iKGd1YywgYWN0aW9u LCBsZW4sIGcyaF9sZW5fZHcpOworCWlmICghZW5hYmxlZCAmJiAhZXJyKSB7CisJCXRyYWNlX2lu dGVsX2NvbnRleHRfc2NoZWRfZW5hYmxlKGNlKTsKKwkJYXRvbWljX2luYygmZ3VjLT5vdXRzdGFu ZGluZ19zdWJtaXNzaW9uX2cyaCk7CisJCXNldF9jb250ZXh0X2VuYWJsZWQoY2UpOworCX0gZWxz ZSBpZiAoIWVuYWJsZWQpIHsKKwkJY2xyX2NvbnRleHRfcGVuZGluZ19lbmFibGUoY2UpOworCQlp bnRlbF9jb250ZXh0X3B1dChjZSk7CisJfQorCWlmIChsaWtlbHkoIWVycikpCisJCXRyYWNlX2k5 MTVfcmVxdWVzdF9ndWNfc3VibWl0KHJxKTsKKworb3V0OgorCXJldHVybiBlcnI7Cit9CisKK3N0 YXRpYyBpbmxpbmUgdm9pZCBndWNfc2V0X2xyY190YWlsKHN0cnVjdCBpOTE1X3JlcXVlc3QgKnJx KQoreworCXJxLT5jb250ZXh0LT5scmNfcmVnX3N0YXRlW0NUWF9SSU5HX1RBSUxdID0KKwkJaW50 ZWxfcmluZ19zZXRfdGFpbChycS0+cmluZywgcnEtPnRhaWwpOworfQorCitzdGF0aWMgaW5saW5l IGludCBycV9wcmlvKGNvbnN0IHN0cnVjdCBpOTE1X3JlcXVlc3QgKnJxKQoreworCXJldHVybiBy cS0+c2NoZWQuYXR0ci5wcmlvcml0eTsKK30KKworc3RhdGljIGludCBndWNfZGVxdWV1ZV9vbmVf Y29udGV4dChzdHJ1Y3QgaW50ZWxfZ3VjICpndWMpCit7CisJc3RydWN0IGk5MTVfc2NoZWRfZW5n aW5lICogY29uc3Qgc2NoZWRfZW5naW5lID0gZ3VjLT5zY2hlZF9lbmdpbmU7CisJc3RydWN0IGk5 MTVfcmVxdWVzdCAqbGFzdCA9IE5VTEw7CisJYm9vbCBzdWJtaXQgPSBmYWxzZTsKKwlzdHJ1Y3Qg cmJfbm9kZSAqcmI7CisJaW50IHJldDsKKworCWxvY2tkZXBfYXNzZXJ0X2hlbGQoJnNjaGVkX2Vu Z2luZS0+bG9jayk7CisKKwlpZiAoZ3VjLT5zdGFsbGVkX3JlcXVlc3QpIHsKKwkJc3VibWl0ID0g dHJ1ZTsKKwkJbGFzdCA9IGd1Yy0+c3RhbGxlZF9yZXF1ZXN0OworCQlnb3RvIHJlc3VibWl0Owor CX0KKwogCXdoaWxlICgocmIgPSByYl9maXJzdF9jYWNoZWQoJnNjaGVkX2VuZ2luZS0+cXVldWUp KSkgewogCQlzdHJ1Y3QgaTkxNV9wcmlvbGlzdCAqcCA9IHRvX3ByaW9saXN0KHJiKTsKIAkJc3Ry dWN0IGk5MTVfcmVxdWVzdCAqcnEsICpybjsKIAogCQlwcmlvbGlzdF9mb3JfZWFjaF9yZXF1ZXN0 X2NvbnN1bWUocnEsIHJuLCBwKSB7Ci0JCQlpZiAobGFzdCAmJiBycS0+Y29udGV4dCAhPSBsYXN0 LT5jb250ZXh0KSB7Ci0JCQkJaWYgKHBvcnQgPT0gbGFzdF9wb3J0KQotCQkJCQlnb3RvIGRvbmU7 Ci0KLQkJCQkqcG9ydCA9IHNjaGVkdWxlX2luKGxhc3QsCi0JCQkJCQkgICAgcG9ydCAtIGV4ZWNs aXN0cy0+aW5mbGlnaHQpOwotCQkJCXBvcnQrKzsKLQkJCX0KKwkJCWlmIChsYXN0ICYmIHJxLT5j b250ZXh0ICE9IGxhc3QtPmNvbnRleHQpCisJCQkJZ290byBkb25lOwogCiAJCQlsaXN0X2RlbF9p bml0KCZycS0+c2NoZWQubGluayk7CisKIAkJCV9faTkxNV9yZXF1ZXN0X3N1Ym1pdChycSk7Ci0J CQlzdWJtaXQgPSB0cnVlOworCisJCQl0cmFjZV9pOTE1X3JlcXVlc3RfaW4ocnEsIDApOwogCQkJ bGFzdCA9IHJxOworCQkJc3VibWl0ID0gdHJ1ZTsKIAkJfQogCiAJCXJiX2VyYXNlX2NhY2hlZCgm cC0+bm9kZSwgJnNjaGVkX2VuZ2luZS0+cXVldWUpOwogCQlpOTE1X3ByaW9saXN0X2ZyZWUocCk7 CiAJfQogZG9uZToKLQlzY2hlZF9lbmdpbmUtPnF1ZXVlX3ByaW9yaXR5X2hpbnQgPQotCQlyYiA/ IHRvX3ByaW9saXN0KHJiKS0+cHJpb3JpdHkgOiBJTlRfTUlOOwogCWlmIChzdWJtaXQpIHsKLQkJ KnBvcnQgPSBzY2hlZHVsZV9pbihsYXN0LCBwb3J0IC0gZXhlY2xpc3RzLT5pbmZsaWdodCk7Ci0J CSorK3BvcnQgPSBOVUxMOwotCQlndWNfc3VibWl0KGVuZ2luZSwgZmlyc3QsIHBvcnQpOworCQln dWNfc2V0X2xyY190YWlsKGxhc3QpOworcmVzdWJtaXQ6CisJCXJldCA9IGd1Y19hZGRfcmVxdWVz dChndWMsIGxhc3QpOworCQlpZiAodW5saWtlbHkocmV0ID09IC1FUElQRSkpCisJCQlnb3RvIGRl YWRsazsKKwkJZWxzZSBpZiAocmV0ID09IC1FQlVTWSkgeworCQkJdGFza2xldF9zY2hlZHVsZSgm c2NoZWRfZW5naW5lLT50YXNrbGV0KTsKKwkJCWd1Yy0+c3RhbGxlZF9yZXF1ZXN0ID0gbGFzdDsK KwkJCXJldHVybiBmYWxzZTsKKwkJfQogCX0KLQlleGVjbGlzdHMtPmFjdGl2ZSA9IGV4ZWNsaXN0 cy0+aW5mbGlnaHQ7CisKKwlndWMtPnN0YWxsZWRfcmVxdWVzdCA9IE5VTEw7CisJcmV0dXJuIHN1 Ym1pdDsKKworZGVhZGxrOgorCXNjaGVkX2VuZ2luZS0+dGFza2xldC5jYWxsYmFjayA9IE5VTEw7 CisJdGFza2xldF9kaXNhYmxlX25vc3luYygmc2NoZWRfZW5naW5lLT50YXNrbGV0KTsKKwlyZXR1 cm4gZmFsc2U7CiB9CiAKIHN0YXRpYyB2b2lkIGd1Y19zdWJtaXNzaW9uX3Rhc2tsZXQoc3RydWN0 IHRhc2tsZXRfc3RydWN0ICp0KQogewogCXN0cnVjdCBpOTE1X3NjaGVkX2VuZ2luZSAqc2NoZWRf ZW5naW5lID0KIAkJZnJvbV90YXNrbGV0KHNjaGVkX2VuZ2luZSwgdCwgdGFza2xldCk7Ci0Jc3Ry dWN0IGludGVsX2VuZ2luZV9jcyAqIGNvbnN0IGVuZ2luZSA9IHNjaGVkX2VuZ2luZS0+cHJpdmF0 ZV9kYXRhOwotCXN0cnVjdCBpbnRlbF9lbmdpbmVfZXhlY2xpc3RzICogY29uc3QgZXhlY2xpc3Rz ID0gJmVuZ2luZS0+ZXhlY2xpc3RzOwotCXN0cnVjdCBpOTE1X3JlcXVlc3QgKipwb3J0LCAqcnE7 CiAJdW5zaWduZWQgbG9uZyBmbGFnczsKKwlib29sIGxvb3A7CisKKwlzcGluX2xvY2tfaXJxc2F2 ZSgmc2NoZWRfZW5naW5lLT5sb2NrLCBmbGFncyk7CiAKLQlzcGluX2xvY2tfaXJxc2F2ZSgmZW5n aW5lLT5zY2hlZF9lbmdpbmUtPmxvY2ssIGZsYWdzKTsKKwlkbyB7CisJCWxvb3AgPSBndWNfZGVx dWV1ZV9vbmVfY29udGV4dChzY2hlZF9lbmdpbmUtPnByaXZhdGVfZGF0YSk7CisJfSB3aGlsZSAo bG9vcCk7CiAKLQlmb3IgKHBvcnQgPSBleGVjbGlzdHMtPmluZmxpZ2h0OyAocnEgPSAqcG9ydCk7 IHBvcnQrKykgewotCQlpZiAoIWk5MTVfcmVxdWVzdF9jb21wbGV0ZWQocnEpKQotCQkJYnJlYWs7 CisJaTkxNV9zY2hlZF9lbmdpbmVfcmVzZXRfb25fZW1wdHkoc2NoZWRfZW5naW5lKTsKIAotCQlz Y2hlZHVsZV9vdXQocnEpOwotCX0KLQlpZiAocG9ydCAhPSBleGVjbGlzdHMtPmluZmxpZ2h0KSB7 Ci0JCWludCBpZHggPSBwb3J0IC0gZXhlY2xpc3RzLT5pbmZsaWdodDsKLQkJaW50IHJlbSA9IEFS UkFZX1NJWkUoZXhlY2xpc3RzLT5pbmZsaWdodCkgLSBpZHg7Ci0JCW1lbW1vdmUoZXhlY2xpc3Rz LT5pbmZsaWdodCwgcG9ydCwgcmVtICogc2l6ZW9mKCpwb3J0KSk7CisJc3Bpbl91bmxvY2tfaXJx cmVzdG9yZSgmc2NoZWRfZW5naW5lLT5sb2NrLCBmbGFncyk7Cit9CisKK3N0YXRpYyB2b2lkIGNz X2lycV9oYW5kbGVyKHN0cnVjdCBpbnRlbF9lbmdpbmVfY3MgKmVuZ2luZSwgdTE2IGlpcikKK3sK KwlpZiAoaWlyICYgR1RfUkVOREVSX1VTRVJfSU5URVJSVVBUKQorCQlpbnRlbF9lbmdpbmVfc2ln bmFsX2JyZWFkY3J1bWJzKGVuZ2luZSk7Cit9CisKK3N0YXRpYyB2b2lkIF9fZ3VjX2NvbnRleHRf ZGVzdHJveShzdHJ1Y3QgaW50ZWxfY29udGV4dCAqY2UpOworc3RhdGljIHZvaWQgcmVsZWFzZV9n dWNfaWQoc3RydWN0IGludGVsX2d1YyAqZ3VjLCBzdHJ1Y3QgaW50ZWxfY29udGV4dCAqY2UpOwor c3RhdGljIHZvaWQgZ3VjX3NpZ25hbF9jb250ZXh0X2ZlbmNlKHN0cnVjdCBpbnRlbF9jb250ZXh0 ICpjZSk7CitzdGF0aWMgdm9pZCBndWNfY2FuY2VsX2NvbnRleHRfcmVxdWVzdHMoc3RydWN0IGlu dGVsX2NvbnRleHQgKmNlKTsKK3N0YXRpYyB2b2lkIGd1Y19ibG9ja2VkX2ZlbmNlX2NvbXBsZXRl KHN0cnVjdCBpbnRlbF9jb250ZXh0ICpjZSk7CisKK3N0YXRpYyB2b2lkIHNjcnViX2d1Y19kZXNj X2Zvcl9vdXRzdGFuZGluZ19nMmgoc3RydWN0IGludGVsX2d1YyAqZ3VjKQoreworCXN0cnVjdCBp bnRlbF9jb250ZXh0ICpjZTsKKwl1bnNpZ25lZCBsb25nIGluZGV4LCBmbGFnczsKKwlib29sIHBl bmRpbmdfZGlzYWJsZSwgcGVuZGluZ19lbmFibGUsIGRlcmVnaXN0ZXIsIGRlc3Ryb3llZCwgYmFu bmVkOworCisJeGFfZm9yX2VhY2goJmd1Yy0+Y29udGV4dF9sb29rdXAsIGluZGV4LCBjZSkgewor CQkvKiBGbHVzaCBjb250ZXh0ICovCisJCXNwaW5fbG9ja19pcnFzYXZlKCZjZS0+Z3VjX3N0YXRl LmxvY2ssIGZsYWdzKTsKKwkJc3Bpbl91bmxvY2tfaXJxcmVzdG9yZSgmY2UtPmd1Y19zdGF0ZS5s b2NrLCBmbGFncyk7CisKKwkJLyoKKwkJICogT25jZSB3ZSBhcmUgYXQgdGhpcyBwb2ludCBzdWJt aXNzaW9uX2Rpc2FibGVkKCkgaXMgZ3VhcmFudGVlZAorCQkgKiB0byB2aXNpYmxlIHRvIGFsbCBj YWxsZXJzIHdobyBzZXQgdGhlIGJlbG93IGZsYWdzIChzZWUgYWJvdmUKKwkJICogZmx1c2ggYW5k IGZsdXNoZXMgaW4gcmVzZXRfcHJlcGFyZSkuIElmIHN1Ym1pc3Npb25fZGlzYWJsZWQoKQorCQkg KiBpcyBzZXQsIHRoZSBjYWxsZXIgc2hvdWxkbid0IHNldCB0aGVzZSBmbGFncy4KKwkJICovCisK KwkJZGVzdHJveWVkID0gY29udGV4dF9kZXN0cm95ZWQoY2UpOworCQlwZW5kaW5nX2VuYWJsZSA9 IGNvbnRleHRfcGVuZGluZ19lbmFibGUoY2UpOworCQlwZW5kaW5nX2Rpc2FibGUgPSBjb250ZXh0 X3BlbmRpbmdfZGlzYWJsZShjZSk7CisJCWRlcmVnaXN0ZXIgPSBjb250ZXh0X3dhaXRfZm9yX2Rl cmVnaXN0ZXJfdG9fcmVnaXN0ZXIoY2UpOworCQliYW5uZWQgPSBjb250ZXh0X2Jhbm5lZChjZSk7 CisJCWluaXRfc2NoZWRfc3RhdGUoY2UpOworCisJCWlmIChwZW5kaW5nX2VuYWJsZSB8fCBkZXN0 cm95ZWQgfHwgZGVyZWdpc3RlcikgeworCQkJYXRvbWljX2RlYygmZ3VjLT5vdXRzdGFuZGluZ19z dWJtaXNzaW9uX2cyaCk7CisJCQlpZiAoZGVyZWdpc3RlcikKKwkJCQlndWNfc2lnbmFsX2NvbnRl eHRfZmVuY2UoY2UpOworCQkJaWYgKGRlc3Ryb3llZCkgeworCQkJCXJlbGVhc2VfZ3VjX2lkKGd1 YywgY2UpOworCQkJCV9fZ3VjX2NvbnRleHRfZGVzdHJveShjZSk7CisJCQl9CisJCQlpZiAocGVu ZGluZ19lbmFibGV8fCBkZXJlZ2lzdGVyKQorCQkJCWludGVsX2NvbnRleHRfcHV0KGNlKTsKKwkJ fQorCisJCS8qIE5vdCBtdXR1YWx5IGV4Y2x1c2l2ZSB3aXRoIGFib3ZlIGlmIHN0YXRlbWVudC4g Ki8KKwkJaWYgKHBlbmRpbmdfZGlzYWJsZSkgeworCQkJZ3VjX3NpZ25hbF9jb250ZXh0X2ZlbmNl KGNlKTsKKwkJCWlmIChiYW5uZWQpIHsKKwkJCQlndWNfY2FuY2VsX2NvbnRleHRfcmVxdWVzdHMo Y2UpOworCQkJCWludGVsX2VuZ2luZV9zaWduYWxfYnJlYWRjcnVtYnMoY2UtPmVuZ2luZSk7CisJ CQl9CisJCQlpbnRlbF9jb250ZXh0X3NjaGVkX2Rpc2FibGVfdW5waW4oY2UpOworCQkJYXRvbWlj X2RlYygmZ3VjLT5vdXRzdGFuZGluZ19zdWJtaXNzaW9uX2cyaCk7CisJCQlzcGluX2xvY2tfaXJx c2F2ZSgmY2UtPmd1Y19zdGF0ZS5sb2NrLCBmbGFncyk7CisJCQlndWNfYmxvY2tlZF9mZW5jZV9j b21wbGV0ZShjZSk7CisJCQlzcGluX3VubG9ja19pcnFyZXN0b3JlKCZjZS0+Z3VjX3N0YXRlLmxv Y2ssIGZsYWdzKTsKKworCQkJaW50ZWxfY29udGV4dF9wdXQoY2UpOworCQl9CiAJfQorfQorCitz dGF0aWMgaW5saW5lIGJvb2wKK3N1Ym1pc3Npb25fZGlzYWJsZWQoc3RydWN0IGludGVsX2d1YyAq Z3VjKQoreworCXN0cnVjdCBpOTE1X3NjaGVkX2VuZ2luZSAqIGNvbnN0IHNjaGVkX2VuZ2luZSA9 IGd1Yy0+c2NoZWRfZW5naW5lOwogCi0JX19ndWNfZGVxdWV1ZShlbmdpbmUpOworCXJldHVybiB1 bmxpa2VseSghc2NoZWRfZW5naW5lIHx8CisJCQkhX190YXNrbGV0X2lzX2VuYWJsZWQoJnNjaGVk X2VuZ2luZS0+dGFza2xldCkpOworfQogCi0JaTkxNV9zY2hlZF9lbmdpbmVfcmVzZXRfb25fZW1w dHkoZW5naW5lLT5zY2hlZF9lbmdpbmUpOworc3RhdGljIHZvaWQgZGlzYWJsZV9zdWJtaXNzaW9u KHN0cnVjdCBpbnRlbF9ndWMgKmd1YykKK3sKKwlzdHJ1Y3QgaTkxNV9zY2hlZF9lbmdpbmUgKiBj b25zdCBzY2hlZF9lbmdpbmUgPSBndWMtPnNjaGVkX2VuZ2luZTsKIAotCXNwaW5fdW5sb2NrX2ly cXJlc3RvcmUoJmVuZ2luZS0+c2NoZWRfZW5naW5lLT5sb2NrLCBmbGFncyk7CisJaWYgKF9fdGFz a2xldF9pc19lbmFibGVkKCZzY2hlZF9lbmdpbmUtPnRhc2tsZXQpKSB7CisJCUdFTV9CVUdfT04o IWd1Yy0+Y3QuZW5hYmxlZCk7CisJCV9fdGFza2xldF9kaXNhYmxlX3N5bmNfb25jZSgmc2NoZWRf ZW5naW5lLT50YXNrbGV0KTsKKwkJc2NoZWRfZW5naW5lLT50YXNrbGV0LmNhbGxiYWNrID0gTlVM TDsKKwl9CiB9CiAKLXN0YXRpYyB2b2lkIGNzX2lycV9oYW5kbGVyKHN0cnVjdCBpbnRlbF9lbmdp bmVfY3MgKmVuZ2luZSwgdTE2IGlpcikKK3N0YXRpYyB2b2lkIGVuYWJsZV9zdWJtaXNzaW9uKHN0 cnVjdCBpbnRlbF9ndWMgKmd1YykKIHsKLQlpZiAoaWlyICYgR1RfUkVOREVSX1VTRVJfSU5URVJS VVBUKSB7Ci0JCWludGVsX2VuZ2luZV9zaWduYWxfYnJlYWRjcnVtYnMoZW5naW5lKTsKLQkJdGFz a2xldF9oaV9zY2hlZHVsZSgmZW5naW5lLT5zY2hlZF9lbmdpbmUtPnRhc2tsZXQpOworCXN0cnVj dCBpOTE1X3NjaGVkX2VuZ2luZSAqIGNvbnN0IHNjaGVkX2VuZ2luZSA9IGd1Yy0+c2NoZWRfZW5n aW5lOworCXVuc2lnbmVkIGxvbmcgZmxhZ3M7CisKKwlzcGluX2xvY2tfaXJxc2F2ZSgmZ3VjLT5z Y2hlZF9lbmdpbmUtPmxvY2ssIGZsYWdzKTsKKwlzY2hlZF9lbmdpbmUtPnRhc2tsZXQuY2FsbGJh Y2sgPSBndWNfc3VibWlzc2lvbl90YXNrbGV0OworCXdtYigpOworCWlmICghX190YXNrbGV0X2lz X2VuYWJsZWQoJnNjaGVkX2VuZ2luZS0+dGFza2xldCkgJiYKKwkgICAgX190YXNrbGV0X2VuYWJs ZSgmc2NoZWRfZW5naW5lLT50YXNrbGV0KSkgeworCQlHRU1fQlVHX09OKCFndWMtPmN0LmVuYWJs ZWQpOworCisJCS8qIEFuZCBraWNrIGluIGNhc2Ugd2UgbWlzc2VkIGEgbmV3IHJlcXVlc3Qgc3Vi bWlzc2lvbi4gKi8KKwkJdGFza2xldF9oaV9zY2hlZHVsZSgmc2NoZWRfZW5naW5lLT50YXNrbGV0 KTsKIAl9CisJc3Bpbl91bmxvY2tfaXJxcmVzdG9yZSgmZ3VjLT5zY2hlZF9lbmdpbmUtPmxvY2ss IGZsYWdzKTsKIH0KIAotc3RhdGljIHZvaWQgZ3VjX3Jlc2V0X3ByZXBhcmUoc3RydWN0IGludGVs X2VuZ2luZV9jcyAqZW5naW5lKQorc3RhdGljIHZvaWQgZ3VjX2ZsdXNoX3N1Ym1pc3Npb25zKHN0 cnVjdCBpbnRlbF9ndWMgKmd1YykKIHsKLQlFTkdJTkVfVFJBQ0UoZW5naW5lLCAiXG4iKTsKKwlz dHJ1Y3QgaTkxNV9zY2hlZF9lbmdpbmUgKiBjb25zdCBzY2hlZF9lbmdpbmUgPSBndWMtPnNjaGVk X2VuZ2luZTsKKwl1bnNpZ25lZCBsb25nIGZsYWdzOworCisJc3Bpbl9sb2NrX2lycXNhdmUoJnNj aGVkX2VuZ2luZS0+bG9jaywgZmxhZ3MpOworCXNwaW5fdW5sb2NrX2lycXJlc3RvcmUoJnNjaGVk X2VuZ2luZS0+bG9jaywgZmxhZ3MpOworfQorCit2b2lkIGludGVsX2d1Y19zdWJtaXNzaW9uX3Jl c2V0X3ByZXBhcmUoc3RydWN0IGludGVsX2d1YyAqZ3VjKQoreworCWludCBpOworCisJaWYgKHVu bGlrZWx5KCFndWNfc3VibWlzc2lvbl9pbml0aWFsaXplZChndWMpKSkKKwkJLyogUmVzZXQgY2Fs bGVkIGR1cmluZyBkcml2ZXIgbG9hZD8gR3VDIG5vdCB5ZXQgaW5pdGlhbGlzZWQhICovCisJCXJl dHVybjsKKworCWludGVsX2d0X3BhcmtfaGVhcnRiZWF0cyhndWNfdG9fZ3QoZ3VjKSk7CisJZGlz YWJsZV9zdWJtaXNzaW9uKGd1Yyk7CisJZ3VjLT5pbnRlcnJ1cHRzLmRpc2FibGUoZ3VjKTsKKwor CS8qIEZsdXNoIElSUSBoYW5kbGVyICovCisJc3Bpbl9sb2NrX2lycSgmZ3VjX3RvX2d0KGd1Yykt PmlycV9sb2NrKTsKKwlzcGluX3VubG9ja19pcnEoJmd1Y190b19ndChndWMpLT5pcnFfbG9jayk7 CisKKwlndWNfZmx1c2hfc3VibWlzc2lvbnMoZ3VjKTsKIAogCS8qCi0JICogUHJldmVudCByZXF1 ZXN0IHN1Ym1pc3Npb24gdG8gdGhlIGhhcmR3YXJlIHVudGlsIHdlIGhhdmUKLQkgKiBjb21wbGV0 ZWQgdGhlIHJlc2V0IGluIGk5MTVfZ2VtX3Jlc2V0X2ZpbmlzaCgpLiBJZiBhIHJlcXVlc3QKLQkg KiBpcyBjb21wbGV0ZWQgYnkgb25lIGVuZ2luZSwgaXQgbWF5IHRoZW4gcXVldWUgYSByZXF1ZXN0 Ci0JICogdG8gYSBzZWNvbmQgdmlhIGl0cyBleGVjbGlzdHMtPnRhc2tsZXQgKmp1c3QqIGFzIHdl IGFyZQotCSAqIGNhbGxpbmcgZW5naW5lLT5pbml0X2h3KCkgYW5kIGFsc28gd3JpdGluZyB0aGUg RUxTUC4KLQkgKiBUdXJuaW5nIG9mZiB0aGUgZXhlY2xpc3RzLT50YXNrbGV0IHVudGlsIHRoZSBy ZXNldCBpcyBvdmVyCi0JICogcHJldmVudHMgdGhlIHJhY2UuCi0JICovCi0JX190YXNrbGV0X2Rp c2FibGVfc3luY19vbmNlKCZlbmdpbmUtPnNjaGVkX2VuZ2luZS0+dGFza2xldCk7CisJICogSGFu ZGxlIGFueSBvdXRzdGFuZGluZyBHMkhzIGJlZm9yZSByZXNldC4gQ2FsbCBJUlEgaGFuZGxlciBk aXJlY3RseQorCSAqIGVhY2ggcGFzcyBhcyBpbnRlcnJ1cHQgaGF2ZSBiZWVuIGRpc2FibGVkLiBX ZSBhbHdheXMgc2NydWIgZm9yCisJICogb3V0c3RhbmRpbmcgRzJIIGFzIGl0IGlzIHBvc3NpYmxl IGZvciBvdXRzdGFuZGluZ19zdWJtaXNzaW9uX2cyaCB0bworCSAqIGJlIGluY3JlbWVudGVkIGFm dGVyIHRoZSBjb250ZXh0IHN0YXRlIHVwZGF0ZS4KKyAJICovCisJZm9yIChpID0gMDsgaSA8IDQg JiYgYXRvbWljX3JlYWQoJmd1Yy0+b3V0c3RhbmRpbmdfc3VibWlzc2lvbl9nMmgpOyArK2kpIHsK KwkJaW50ZWxfZ3VjX3RvX2hvc3RfZXZlbnRfaGFuZGxlcihndWMpOworI2RlZmluZSB3YWl0X2Zv cl9yZXNldChndWMsIHdhaXRfdmFyKSBcCisJCWludGVsX2d1Y193YWl0X2Zvcl9wZW5kaW5nX21z ZyhndWMsIHdhaXRfdmFyLCBmYWxzZSwgKEhaIC8gMjApKQorCQlkbyB7CisJCQl3YWl0X2Zvcl9y ZXNldChndWMsICZndWMtPm91dHN0YW5kaW5nX3N1Ym1pc3Npb25fZzJoKTsKKwkJfSB3aGlsZSAo IWxpc3RfZW1wdHkoJmd1Yy0+Y3QucmVxdWVzdHMuaW5jb21pbmcpKTsKKwl9CisJc2NydWJfZ3Vj X2Rlc2NfZm9yX291dHN0YW5kaW5nX2cyaChndWMpOworfQorCitzdGF0aWMgc3RydWN0IGludGVs X2VuZ2luZV9jcyAqCitndWNfdmlydHVhbF9nZXRfc2libGluZyhzdHJ1Y3QgaW50ZWxfZW5naW5l X2NzICp2ZSwgdW5zaWduZWQgaW50IHNpYmxpbmcpCit7CisJc3RydWN0IGludGVsX2VuZ2luZV9j cyAqZW5naW5lOworCWludGVsX2VuZ2luZV9tYXNrX3QgdG1wLCBtYXNrID0gdmUtPm1hc2s7CisJ dW5zaWduZWQgaW50IG51bV9zaWJsaW5ncyA9IDA7CisKKwlmb3JfZWFjaF9lbmdpbmVfbWFza2Vk KGVuZ2luZSwgdmUtPmd0LCBtYXNrLCB0bXApCisJCWlmIChudW1fc2libGluZ3MrKyA9PSBzaWJs aW5nKQorCQkJcmV0dXJuIGVuZ2luZTsKKworCXJldHVybiBOVUxMOworfQorCitzdGF0aWMgaW5s aW5lIHN0cnVjdCBpbnRlbF9lbmdpbmVfY3MgKgorX19jb250ZXh0X3RvX3BoeXNpY2FsX2VuZ2lu ZShzdHJ1Y3QgaW50ZWxfY29udGV4dCAqY2UpCit7CisJc3RydWN0IGludGVsX2VuZ2luZV9jcyAq ZW5naW5lID0gY2UtPmVuZ2luZTsKKworCWlmIChpbnRlbF9lbmdpbmVfaXNfdmlydHVhbChlbmdp bmUpKQorCQllbmdpbmUgPSBndWNfdmlydHVhbF9nZXRfc2libGluZyhlbmdpbmUsIDApOworCisJ cmV0dXJuIGVuZ2luZTsKIH0KIAotc3RhdGljIHZvaWQgZ3VjX3Jlc2V0X3N0YXRlKHN0cnVjdCBp bnRlbF9jb250ZXh0ICpjZSwKLQkJCSAgICBzdHJ1Y3QgaW50ZWxfZW5naW5lX2NzICplbmdpbmUs Ci0JCQkgICAgdTMyIGhlYWQsCi0JCQkgICAgYm9vbCBzY3J1YikKK3N0YXRpYyB2b2lkIGd1Y19y ZXNldF9zdGF0ZShzdHJ1Y3QgaW50ZWxfY29udGV4dCAqY2UsIHUzMiBoZWFkLCBib29sIHNjcnVi KQogeworCXN0cnVjdCBpbnRlbF9lbmdpbmVfY3MgKmVuZ2luZSA9IF9fY29udGV4dF90b19waHlz aWNhbF9lbmdpbmUoY2UpOworCisJaWYgKGludGVsX2NvbnRleHRfaXNfYmFubmVkKGNlKSkKKwkJ cmV0dXJuOworCiAJR0VNX0JVR19PTighaW50ZWxfY29udGV4dF9pc19waW5uZWQoY2UpKTsKIAog CS8qCkBAIC0zMTUsNjkgKzc2OSwxNTggQEAgc3RhdGljIHZvaWQgZ3VjX3Jlc2V0X3N0YXRlKHN0 cnVjdCBpbnRlbF9jb250ZXh0ICpjZSwKIAlscmNfdXBkYXRlX3JlZ3MoY2UsIGVuZ2luZSwgaGVh ZCk7CiB9CiAKLXN0YXRpYyB2b2lkIGd1Y19yZXNldF9yZXdpbmQoc3RydWN0IGludGVsX2VuZ2lu ZV9jcyAqZW5naW5lLCBib29sIHN0YWxsZWQpCitzdGF0aWMgdm9pZCBndWNfcmVzZXRfbm9wKHN0 cnVjdCBpbnRlbF9lbmdpbmVfY3MgKmVuZ2luZSkKIHsKLQlzdHJ1Y3QgaW50ZWxfZW5naW5lX2V4 ZWNsaXN0cyAqIGNvbnN0IGV4ZWNsaXN0cyA9ICZlbmdpbmUtPmV4ZWNsaXN0czsKLQlzdHJ1Y3Qg aTkxNV9yZXF1ZXN0ICpycTsKLQl1bnNpZ25lZCBsb25nIGZsYWdzOworfQogCi0Jc3Bpbl9sb2Nr X2lycXNhdmUoJmVuZ2luZS0+c2NoZWRfZW5naW5lLT5sb2NrLCBmbGFncyk7CitzdGF0aWMgdm9p ZCBndWNfcmV3aW5kX25vcChzdHJ1Y3QgaW50ZWxfZW5naW5lX2NzICplbmdpbmUsIGJvb2wgc3Rh bGxlZCkKK3sKK30KIAotCS8qIFB1c2ggYmFjayBhbnkgaW5jb21wbGV0ZSByZXF1ZXN0cyBmb3Ig cmVwbGF5IGFmdGVyIHRoZSByZXNldC4gKi8KLQlycSA9IGV4ZWNsaXN0c191bndpbmRfaW5jb21w bGV0ZV9yZXF1ZXN0cyhleGVjbGlzdHMpOwotCWlmICghcnEpCi0JCWdvdG8gb3V0X3VubG9jazsK K3N0YXRpYyB2b2lkCitfX3Vud2luZF9pbmNvbXBsZXRlX3JlcXVlc3RzKHN0cnVjdCBpbnRlbF9j b250ZXh0ICpjZSkKK3sKKwlzdHJ1Y3QgaTkxNV9yZXF1ZXN0ICpycSwgKnJuOworCXN0cnVjdCBs aXN0X2hlYWQgKnBsOworCWludCBwcmlvID0gSTkxNV9QUklPUklUWV9JTlZBTElEOworCXN0cnVj dCBpOTE1X3NjaGVkX2VuZ2luZSAqIGNvbnN0IHNjaGVkX2VuZ2luZSA9CisJCWNlLT5lbmdpbmUt PnNjaGVkX2VuZ2luZTsKKwl1bnNpZ25lZCBsb25nIGZsYWdzOwogCi0JaWYgKCFpOTE1X3JlcXVl c3Rfc3RhcnRlZChycSkpCi0JCXN0YWxsZWQgPSBmYWxzZTsKKwlzcGluX2xvY2tfaXJxc2F2ZSgm c2NoZWRfZW5naW5lLT5sb2NrLCBmbGFncyk7CisJc3Bpbl9sb2NrKCZjZS0+Z3VjX2FjdGl2ZS5s b2NrKTsKKwlsaXN0X2Zvcl9lYWNoX2VudHJ5X3NhZmUocnEsIHJuLAorCQkJCSAmY2UtPmd1Y19h Y3RpdmUucmVxdWVzdHMsCisJCQkJIHNjaGVkLmxpbmspIHsKKwkJaWYgKGk5MTVfcmVxdWVzdF9j b21wbGV0ZWQocnEpKQorCQkJY29udGludWU7CisKKwkJbGlzdF9kZWxfaW5pdCgmcnEtPnNjaGVk LmxpbmspOworCQlzcGluX3VubG9jaygmY2UtPmd1Y19hY3RpdmUubG9jayk7CisKKwkJX19pOTE1 X3JlcXVlc3RfdW5zdWJtaXQocnEpOworCisJCS8qIFB1c2ggdGhlIHJlcXVlc3QgYmFjayBpbnRv IHRoZSBxdWV1ZSBmb3IgbGF0ZXIgcmVzdWJtaXNzaW9uLiAqLworCQlHRU1fQlVHX09OKHJxX3By aW8ocnEpID09IEk5MTVfUFJJT1JJVFlfSU5WQUxJRCk7CisJCWlmIChycV9wcmlvKHJxKSAhPSBw cmlvKSB7CisJCQlwcmlvID0gcnFfcHJpbyhycSk7CisJCQlwbCA9IGk5MTVfc2NoZWRfbG9va3Vw X3ByaW9saXN0KHNjaGVkX2VuZ2luZSwgcHJpbyk7CisJCX0KKwkJR0VNX0JVR19PTihpOTE1X3Nj aGVkX2VuZ2luZV9pc19lbXB0eShzY2hlZF9lbmdpbmUpKTsKIAotCV9faTkxNV9yZXF1ZXN0X3Jl c2V0KHJxLCBzdGFsbGVkKTsKLQlndWNfcmVzZXRfc3RhdGUocnEtPmNvbnRleHQsIGVuZ2luZSwg cnEtPmhlYWQsIHN0YWxsZWQpOworCQlsaXN0X2FkZF90YWlsKCZycS0+c2NoZWQubGluaywgcGwp OworCQlzZXRfYml0KEk5MTVfRkVOQ0VfRkxBR19QUVVFVUUsICZycS0+ZmVuY2UuZmxhZ3MpOwog Ci1vdXRfdW5sb2NrOgotCXNwaW5fdW5sb2NrX2lycXJlc3RvcmUoJmVuZ2luZS0+c2NoZWRfZW5n aW5lLT5sb2NrLCBmbGFncyk7CisJCXNwaW5fbG9jaygmY2UtPmd1Y19hY3RpdmUubG9jayk7CisJ fQorCXNwaW5fdW5sb2NrKCZjZS0+Z3VjX2FjdGl2ZS5sb2NrKTsKKwlzcGluX3VubG9ja19pcnFy ZXN0b3JlKCZzY2hlZF9lbmdpbmUtPmxvY2ssIGZsYWdzKTsKIH0KIAotc3RhdGljIHZvaWQgZ3Vj X3Jlc2V0X2NhbmNlbChzdHJ1Y3QgaW50ZWxfZW5naW5lX2NzICplbmdpbmUpCitzdGF0aWMgdm9p ZCBfX2d1Y19yZXNldF9jb250ZXh0KHN0cnVjdCBpbnRlbF9jb250ZXh0ICpjZSwgYm9vbCBzdGFs bGVkKQogewotCXN0cnVjdCBpOTE1X3NjaGVkX2VuZ2luZSAqIGNvbnN0IHNjaGVkX2VuZ2luZSA9 IGVuZ2luZS0+c2NoZWRfZW5naW5lOwotCXN0cnVjdCBpOTE1X3JlcXVlc3QgKnJxLCAqcm47Ci0J c3RydWN0IHJiX25vZGUgKnJiOwotCXVuc2lnbmVkIGxvbmcgZmxhZ3M7CisJc3RydWN0IGk5MTVf cmVxdWVzdCAqcnE7CisJdTMyIGhlYWQ7CiAKLQlFTkdJTkVfVFJBQ0UoZW5naW5lLCAiXG4iKTsK KwlpbnRlbF9jb250ZXh0X2dldChjZSk7CiAKIAkvKgotCSAqIEJlZm9yZSB3ZSBjYWxsIGVuZ2lu ZS0+Y2FuY2VsX3JlcXVlc3RzKCksIHdlIHNob3VsZCBoYXZlIGV4Y2x1c2l2ZQotCSAqIGFjY2Vz cyB0byB0aGUgc3VibWlzc2lvbiBzdGF0ZS4gVGhpcyBpcyBhcnJhbmdlZCBmb3IgdXMgYnkgdGhl Ci0JICogY2FsbGVyIGRpc2FibGluZyB0aGUgaW50ZXJydXB0IGdlbmVyYXRpb24sIHRoZSB0YXNr bGV0IGFuZCBvdGhlcgotCSAqIHRocmVhZHMgdGhhdCBtYXkgdGhlbiBhY2Nlc3MgdGhlIHNhbWUg c3RhdGUsIGdpdmluZyB1cyBhIGZyZWUgaGFuZAotCSAqIHRvIHJlc2V0IHN0YXRlLiBIb3dldmVy LCB3ZSBzdGlsbCBuZWVkIHRvIGxldCBsb2NrZGVwIGJlIGF3YXJlIHRoYXQKLQkgKiB3ZSBrbm93 IHRoaXMgc3RhdGUgbWF5IGJlIGFjY2Vzc2VkIGluIGhhcmRpcnEgY29udGV4dCwgc28gd2UKLQkg KiBkaXNhYmxlIHRoZSBpcnEgYXJvdW5kIHRoaXMgbWFuaXB1bGF0aW9uIGFuZCB3ZSB3YW50IHRv IGtlZXAKLQkgKiB0aGUgc3BpbmxvY2sgZm9jdXNlZCBvbiBpdHMgZHV0aWVzIGFuZCBub3QgYWNj aWRlbnRhbGx5IGNvbmZsYXRlCi0JICogY292ZXJhZ2UgdG8gdGhlIHN1Ym1pc3Npb24ncyBpcnEg c3RhdGUuIChTaW1pbGFybHksIGFsdGhvdWdoIHdlCi0JICogc2hvdWxkbid0IG5lZWQgdG8gZGlz YWJsZSBpcnEgYXJvdW5kIHRoZSBtYW5pcHVsYXRpb24gb2YgdGhlCi0JICogc3VibWlzc2lvbidz IGlycSBzdGF0ZSwgd2UgYWxzbyB3aXNoIHRvIHJlbWluZCBvdXJzZWx2ZXMgdGhhdAotCSAqIGl0 IGlzIGlycSBzdGF0ZS4pCisJICogR3VDIHdpbGwgaW1wbGljaXRseSBtYXJrIHRoZSBjb250ZXh0 IGFzIG5vbi1zY2hlZHVsYWJsZQorCSAqIHdoZW4gaXQgc2VuZHMgdGhlIHJlc2V0IG5vdGlmaWNh dGlvbi4gTWFrZSBzdXJlIG91ciBzdGF0ZQorCSAqIHJlZmxlY3RzIHRoaXMgY2hhbmdlLiBUaGUg Y29udGV4dCB3aWxsIGJlIG1hcmtlZCBlbmFibGVkCisJICogb24gcmVzdWJtaXNzaW9uLgogCSAq LwotCXNwaW5fbG9ja19pcnFzYXZlKCZzY2hlZF9lbmdpbmUtPmxvY2ssIGZsYWdzKTsKKwljbHJf Y29udGV4dF9lbmFibGVkKGNlKTsKIAotCS8qIE1hcmsgYWxsIGV4ZWN1dGluZyByZXF1ZXN0cyBh cyBza2lwcGVkLiAqLwotCWxpc3RfZm9yX2VhY2hfZW50cnkocnEsICZzY2hlZF9lbmdpbmUtPnJl cXVlc3RzLCBzY2hlZC5saW5rKSB7Ci0JCWk5MTVfcmVxdWVzdF9zZXRfZXJyb3Jfb25jZShycSwg LUVJTyk7Ci0JCWk5MTVfcmVxdWVzdF9tYXJrX2NvbXBsZXRlKHJxKTsKKwlycSA9IGludGVsX2Nv bnRleHRfZmluZF9hY3RpdmVfcmVxdWVzdChjZSk7CisJaWYgKCFycSkgeworCQloZWFkID0gY2Ut PnJpbmctPnRhaWw7CisJCXN0YWxsZWQgPSBmYWxzZTsKKwkJZ290byBvdXRfcmVwbGF5OwogCX0K IAotCS8qIEZsdXNoIHRoZSBxdWV1ZWQgcmVxdWVzdHMgdG8gdGhlIHRpbWVsaW5lIGxpc3QgKGZv ciByZXRpcmluZykuICovCi0Jd2hpbGUgKChyYiA9IHJiX2ZpcnN0X2NhY2hlZCgmc2NoZWRfZW5n aW5lLT5xdWV1ZSkpKSB7Ci0JCXN0cnVjdCBpOTE1X3ByaW9saXN0ICpwID0gdG9fcHJpb2xpc3Qo cmIpOwotCisJaWYgKCFpOTE1X3JlcXVlc3Rfc3RhcnRlZChycSkpCisJCXN0YWxsZWQgPSBmYWxz ZTsKKworCUdFTV9CVUdfT04oaTkxNV9hY3RpdmVfaXNfaWRsZSgmY2UtPmFjdGl2ZSkpOworCWhl YWQgPSBpbnRlbF9yaW5nX3dyYXAoY2UtPnJpbmcsIHJxLT5oZWFkKTsKKwlfX2k5MTVfcmVxdWVz dF9yZXNldChycSwgc3RhbGxlZCk7CisKK291dF9yZXBsYXk6CisJZ3VjX3Jlc2V0X3N0YXRlKGNl LCBoZWFkLCBzdGFsbGVkKTsKKwlfX3Vud2luZF9pbmNvbXBsZXRlX3JlcXVlc3RzKGNlKTsKKwlp bnRlbF9jb250ZXh0X3B1dChjZSk7Cit9CisKK3ZvaWQgaW50ZWxfZ3VjX3N1Ym1pc3Npb25fcmVz ZXQoc3RydWN0IGludGVsX2d1YyAqZ3VjLCBib29sIHN0YWxsZWQpCit7CisJc3RydWN0IGludGVs X2NvbnRleHQgKmNlOworCXVuc2lnbmVkIGxvbmcgaW5kZXg7CisKKwlpZiAodW5saWtlbHkoIWd1 Y19zdWJtaXNzaW9uX2luaXRpYWxpemVkKGd1YykpKQorCQkvKiBSZXNldCBjYWxsZWQgZHVyaW5n IGRyaXZlciBsb2FkPyBHdUMgbm90IHlldCBpbml0aWFsaXNlZCEgKi8KKwkJcmV0dXJuOworCisJ eGFfZm9yX2VhY2goJmd1Yy0+Y29udGV4dF9sb29rdXAsIGluZGV4LCBjZSkKKwkJaWYgKGludGVs X2NvbnRleHRfaXNfcGlubmVkKGNlKSkKKwkJCV9fZ3VjX3Jlc2V0X2NvbnRleHQoY2UsIHN0YWxs ZWQpOworCisJLyogR3VDIGlzIGJsb3duIGF3YXksIGRyb3AgYWxsIHJlZmVyZW5jZXMgdG8gY29u dGV4dHMgKi8KKwl4YV9kZXN0cm95KCZndWMtPmNvbnRleHRfbG9va3VwKTsKK30KKworc3RhdGlj IHZvaWQgZ3VjX2NhbmNlbF9jb250ZXh0X3JlcXVlc3RzKHN0cnVjdCBpbnRlbF9jb250ZXh0ICpj ZSkKK3sKKwlzdHJ1Y3QgaTkxNV9zY2hlZF9lbmdpbmUgKnNjaGVkX2VuZ2luZSA9IGNlX3RvX2d1 YyhjZSktPnNjaGVkX2VuZ2luZTsKKwlzdHJ1Y3QgaTkxNV9yZXF1ZXN0ICpycTsKKwl1bnNpZ25l ZCBsb25nIGZsYWdzOworCisJLyogTWFyayBhbGwgZXhlY3V0aW5nIHJlcXVlc3RzIGFzIHNraXBw ZWQuICovCisJc3Bpbl9sb2NrX2lycXNhdmUoJnNjaGVkX2VuZ2luZS0+bG9jaywgZmxhZ3MpOwor CXNwaW5fbG9jaygmY2UtPmd1Y19hY3RpdmUubG9jayk7CisJbGlzdF9mb3JfZWFjaF9lbnRyeShy cSwgJmNlLT5ndWNfYWN0aXZlLnJlcXVlc3RzLCBzY2hlZC5saW5rKQorCQlpOTE1X3JlcXVlc3Rf cHV0KGk5MTVfcmVxdWVzdF9tYXJrX2VpbyhycSkpOworCXNwaW5fdW5sb2NrKCZjZS0+Z3VjX2Fj dGl2ZS5sb2NrKTsKKwlzcGluX3VubG9ja19pcnFyZXN0b3JlKCZzY2hlZF9lbmdpbmUtPmxvY2ss IGZsYWdzKTsKK30KKworc3RhdGljIHZvaWQKK2d1Y19jYW5jZWxfc2NoZWRfZW5naW5lX3JlcXVl c3RzKHN0cnVjdCBpOTE1X3NjaGVkX2VuZ2luZSAqc2NoZWRfZW5naW5lKQoreworCXN0cnVjdCBp OTE1X3JlcXVlc3QgKnJxLCAqcm47CisJc3RydWN0IHJiX25vZGUgKnJiOworCXVuc2lnbmVkIGxv bmcgZmxhZ3M7CisKKwkvKiBDYW4gYmUgY2FsbGVkIGR1cmluZyBib290IGlmIEd1QyBmYWlscyB0 byBsb2FkICovCisJaWYgKCFzY2hlZF9lbmdpbmUpCisJCXJldHVybjsKKworCS8qCisJICogQmVm b3JlIHdlIGNhbGwgZW5naW5lLT5jYW5jZWxfcmVxdWVzdHMoKSwgd2Ugc2hvdWxkIGhhdmUgZXhj bHVzaXZlCisJICogYWNjZXNzIHRvIHRoZSBzdWJtaXNzaW9uIHN0YXRlLiBUaGlzIGlzIGFycmFu Z2VkIGZvciB1cyBieSB0aGUKKwkgKiBjYWxsZXIgZGlzYWJsaW5nIHRoZSBpbnRlcnJ1cHQgZ2Vu ZXJhdGlvbiwgdGhlIHRhc2tsZXQgYW5kIG90aGVyCisJICogdGhyZWFkcyB0aGF0IG1heSB0aGVu IGFjY2VzcyB0aGUgc2FtZSBzdGF0ZSwgZ2l2aW5nIHVzIGEgZnJlZSBoYW5kCisJICogdG8gcmVz ZXQgc3RhdGUuIEhvd2V2ZXIsIHdlIHN0aWxsIG5lZWQgdG8gbGV0IGxvY2tkZXAgYmUgYXdhcmUg dGhhdAorCSAqIHdlIGtub3cgdGhpcyBzdGF0ZSBtYXkgYmUgYWNjZXNzZWQgaW4gaGFyZGlycSBj b250ZXh0LCBzbyB3ZQorCSAqIGRpc2FibGUgdGhlIGlycSBhcm91bmQgdGhpcyBtYW5pcHVsYXRp b24gYW5kIHdlIHdhbnQgdG8ga2VlcAorCSAqIHRoZSBzcGlubG9jayBmb2N1c2VkIG9uIGl0cyBk dXRpZXMgYW5kIG5vdCBhY2NpZGVudGFsbHkgY29uZmxhdGUKKwkgKiBjb3ZlcmFnZSB0byB0aGUg c3VibWlzc2lvbidzIGlycSBzdGF0ZS4gKFNpbWlsYXJseSwgYWx0aG91Z2ggd2UKKwkgKiBzaG91 bGRuJ3QgbmVlZCB0byBkaXNhYmxlIGlycSBhcm91bmQgdGhlIG1hbmlwdWxhdGlvbiBvZiB0aGUK KwkgKiBzdWJtaXNzaW9uJ3MgaXJxIHN0YXRlLCB3ZSBhbHNvIHdpc2ggdG8gcmVtaW5kIG91cnNl bHZlcyB0aGF0CisJICogaXQgaXMgaXJxIHN0YXRlLikKKwkgKi8KKwlzcGluX2xvY2tfaXJxc2F2 ZSgmc2NoZWRfZW5naW5lLT5sb2NrLCBmbGFncyk7CisKKwkvKiBGbHVzaCB0aGUgcXVldWVkIHJl cXVlc3RzIHRvIHRoZSB0aW1lbGluZSBsaXN0IChmb3IgcmV0aXJpbmcpLiAqLworCXdoaWxlICgo cmIgPSByYl9maXJzdF9jYWNoZWQoJnNjaGVkX2VuZ2luZS0+cXVldWUpKSkgeworCQlzdHJ1Y3Qg aTkxNV9wcmlvbGlzdCAqcCA9IHRvX3ByaW9saXN0KHJiKTsKKwogCQlwcmlvbGlzdF9mb3JfZWFj aF9yZXF1ZXN0X2NvbnN1bWUocnEsIHJuLCBwKSB7CiAJCQlsaXN0X2RlbF9pbml0KCZycS0+c2No ZWQubGluayk7CisKIAkJCV9faTkxNV9yZXF1ZXN0X3N1Ym1pdChycSk7Ci0JCQlkbWFfZmVuY2Vf c2V0X2Vycm9yKCZycS0+ZmVuY2UsIC1FSU8pOwotCQkJaTkxNV9yZXF1ZXN0X21hcmtfY29tcGxl dGUocnEpOworCisJCQlpOTE1X3JlcXVlc3RfcHV0KGk5MTVfcmVxdWVzdF9tYXJrX2VpbyhycSkp OwogCQl9CiAKIAkJcmJfZXJhc2VfY2FjaGVkKCZwLT5ub2RlLCAmc2NoZWRfZW5naW5lLT5xdWV1 ZSk7CkBAIC0zODksMTM3ICs5MzIsMTMxOCBAQCBzdGF0aWMgdm9pZCBndWNfcmVzZXRfY2FuY2Vs KHN0cnVjdCBpbnRlbF9lbmdpbmVfY3MgKmVuZ2luZSkKIAlzY2hlZF9lbmdpbmUtPnF1ZXVlX3By aW9yaXR5X2hpbnQgPSBJTlRfTUlOOwogCXNjaGVkX2VuZ2luZS0+cXVldWUgPSBSQl9ST09UX0NB Q0hFRDsKIAotCXNwaW5fdW5sb2NrX2lycXJlc3RvcmUoJnNjaGVkX2VuZ2luZS0+bG9jaywgZmxh Z3MpOworCXNwaW5fdW5sb2NrX2lycXJlc3RvcmUoJnNjaGVkX2VuZ2luZS0+bG9jaywgZmxhZ3Mp OworfQorCit2b2lkIGludGVsX2d1Y19zdWJtaXNzaW9uX2NhbmNlbF9yZXF1ZXN0cyhzdHJ1Y3Qg aW50ZWxfZ3VjICpndWMpCit7CisJc3RydWN0IGludGVsX2NvbnRleHQgKmNlOworCXVuc2lnbmVk IGxvbmcgaW5kZXg7CisKKwl4YV9mb3JfZWFjaCgmZ3VjLT5jb250ZXh0X2xvb2t1cCwgaW5kZXgs IGNlKQorCQlpZiAoaW50ZWxfY29udGV4dF9pc19waW5uZWQoY2UpKQorCQkJZ3VjX2NhbmNlbF9j b250ZXh0X3JlcXVlc3RzKGNlKTsKKworCWd1Y19jYW5jZWxfc2NoZWRfZW5naW5lX3JlcXVlc3Rz KGd1Yy0+c2NoZWRfZW5naW5lKTsKKworCS8qIEd1QyBpcyBibG93biBhd2F5LCBkcm9wIGFsbCBy ZWZlcmVuY2VzIHRvIGNvbnRleHRzICovCisJeGFfZGVzdHJveSgmZ3VjLT5jb250ZXh0X2xvb2t1 cCk7Cit9CisKK3ZvaWQgaW50ZWxfZ3VjX3N1Ym1pc3Npb25fcmVzZXRfZmluaXNoKHN0cnVjdCBp bnRlbF9ndWMgKmd1YykKK3sKKwkvKiBSZXNldCBjYWxsZWQgZHVyaW5nIGRyaXZlciBsb2FkIG9y IGR1cmluZyB3ZWRnZT8gKi8KKwlpZiAodW5saWtlbHkoIWd1Y19zdWJtaXNzaW9uX2luaXRpYWxp emVkKGd1YykgfHwKKwkJICAgICB0ZXN0X2JpdChJOTE1X1dFREdFRCwgJmd1Y190b19ndChndWMp LT5yZXNldC5mbGFncykpKQorCQlyZXR1cm47CisKKwkvKgorCSAqIFRlY2huaWNhbGx5IHBvc3Np YmxlIGZvciBlaXRoZXIgb2YgdGhlc2UgdmFsdWVzIHRvIGJlIG5vbi16ZXJvIGhlcmUsCisJICog YnV0IHZlcnkgdW5saWtlbHkgKyBoYXJtbGVzcy4gUmVnYXJkbGVzcyBsZXQncyBhZGQgYSB3YXJu IHNvIHdlIGNhbgorCSAqIHNlZSBpbiBDSSBpZiB0aGlzIGhhcHBlbnMgZnJlcXVlbnRseSAvIGEg cHJlY3Vyc29yIHRvIHRha2luZyBkb3duIHRoZQorCSAqIG1hY2hpbmUuCisJICovCisJR0VNX1dB Uk5fT04oYXRvbWljX3JlYWQoJmd1Yy0+b3V0c3RhbmRpbmdfc3VibWlzc2lvbl9nMmgpKTsKKwlh dG9taWNfc2V0KCZndWMtPm91dHN0YW5kaW5nX3N1Ym1pc3Npb25fZzJoLCAwKTsKKworCWludGVs X2d1Y19nbG9iYWxfcG9saWNpZXNfdXBkYXRlKGd1Yyk7CisJZW5hYmxlX3N1Ym1pc3Npb24oZ3Vj KTsKKwlpbnRlbF9ndF91bnBhcmtfaGVhcnRiZWF0cyhndWNfdG9fZ3QoZ3VjKSk7Cit9CisKKy8q CisgKiBTZXQgdXAgdGhlIG1lbW9yeSByZXNvdXJjZXMgdG8gYmUgc2hhcmVkIHdpdGggdGhlIEd1 QyAodmlhIHRoZSBHR1RUKQorICogYXQgZmlybXdhcmUgbG9hZGluZyB0aW1lLgorICovCitpbnQg aW50ZWxfZ3VjX3N1Ym1pc3Npb25faW5pdChzdHJ1Y3QgaW50ZWxfZ3VjICpndWMpCit7CisJaW50 IHJldDsKKworCWlmIChndWMtPmxyY19kZXNjX3Bvb2wpCisJCXJldHVybiAwOworCisJcmV0ID0g Z3VjX2xyY19kZXNjX3Bvb2xfY3JlYXRlKGd1Yyk7CisJaWYgKHJldCkKKwkJcmV0dXJuIHJldDsK KwkvKgorCSAqIEtlZXAgc3RhdGljIGFuYWx5c2VycyBoYXBweSwgbGV0IHRoZW0ga25vdyB0aGF0 IHdlIGFsbG9jYXRlZCB0aGUKKwkgKiB2bWEgYWZ0ZXIgdGVzdGluZyB0aGF0IGl0IGRpZG4ndCBl eGlzdCBlYXJsaWVyLgorCSAqLworCUdFTV9CVUdfT04oIWd1Yy0+bHJjX2Rlc2NfcG9vbCk7CisK Kwl4YV9pbml0X2ZsYWdzKCZndWMtPmNvbnRleHRfbG9va3VwLCBYQV9GTEFHU19MT0NLX0lSUSk7 CisKKwlzcGluX2xvY2tfaW5pdCgmZ3VjLT5jb250ZXh0c19sb2NrKTsKKwlJTklUX0xJU1RfSEVB RCgmZ3VjLT5ndWNfaWRfbGlzdCk7CisJaWRhX2luaXQoJmd1Yy0+Z3VjX2lkcyk7CisKKwlyZXR1 cm4gMDsKK30KKwordm9pZCBpbnRlbF9ndWNfc3VibWlzc2lvbl9maW5pKHN0cnVjdCBpbnRlbF9n dWMgKmd1YykKK3sKKwlpZiAoIWd1Yy0+bHJjX2Rlc2NfcG9vbCkKKwkJcmV0dXJuOworCisJZ3Vj X2xyY19kZXNjX3Bvb2xfZGVzdHJveShndWMpOworCWk5MTVfc2NoZWRfZW5naW5lX3B1dChndWMt PnNjaGVkX2VuZ2luZSk7Cit9CisKK3N0YXRpYyBpbmxpbmUgdm9pZCBxdWV1ZV9yZXF1ZXN0KHN0 cnVjdCBpOTE1X3NjaGVkX2VuZ2luZSAqc2NoZWRfZW5naW5lLAorCQkJCSBzdHJ1Y3QgaTkxNV9y ZXF1ZXN0ICpycSwKKwkJCQkgaW50IHByaW8pCit7CisJR0VNX0JVR19PTighbGlzdF9lbXB0eSgm cnEtPnNjaGVkLmxpbmspKTsKKwlsaXN0X2FkZF90YWlsKCZycS0+c2NoZWQubGluaywKKwkJICAg ICAgaTkxNV9zY2hlZF9sb29rdXBfcHJpb2xpc3Qoc2NoZWRfZW5naW5lLCBwcmlvKSk7CisJc2V0 X2JpdChJOTE1X0ZFTkNFX0ZMQUdfUFFVRVVFLCAmcnEtPmZlbmNlLmZsYWdzKTsKK30KKworc3Rh dGljIGludCBndWNfYnlwYXNzX3Rhc2tsZXRfc3VibWl0KHN0cnVjdCBpbnRlbF9ndWMgKmd1YywK KwkJCQkgICAgIHN0cnVjdCBpOTE1X3JlcXVlc3QgKnJxKQoreworCWludCByZXQ7CisKKwlfX2k5 MTVfcmVxdWVzdF9zdWJtaXQocnEpOworCisJdHJhY2VfaTkxNV9yZXF1ZXN0X2luKHJxLCAwKTsK KworCWd1Y19zZXRfbHJjX3RhaWwocnEpOworCXJldCA9IGd1Y19hZGRfcmVxdWVzdChndWMsIHJx KTsKKwlpZiAocmV0ID09IC1FQlVTWSkKKwkJZ3VjLT5zdGFsbGVkX3JlcXVlc3QgPSBycTsKKwor CWlmICh1bmxpa2VseShyZXQgPT0gLUVQSVBFKSkKKwkJZGlzYWJsZV9zdWJtaXNzaW9uKGd1Yyk7 CisKKwlyZXR1cm4gcmV0OworfQorCitzdGF0aWMgdm9pZCBndWNfc3VibWl0X3JlcXVlc3Qoc3Ry dWN0IGk5MTVfcmVxdWVzdCAqcnEpCit7CisJc3RydWN0IGk5MTVfc2NoZWRfZW5naW5lICpzY2hl ZF9lbmdpbmUgPSBycS0+ZW5naW5lLT5zY2hlZF9lbmdpbmU7CisJc3RydWN0IGludGVsX2d1YyAq Z3VjID0gJnJxLT5lbmdpbmUtPmd0LT51Yy5ndWM7CisJdW5zaWduZWQgbG9uZyBmbGFnczsKKwor CS8qIFdpbGwgYmUgY2FsbGVkIGZyb20gaXJxLWNvbnRleHQgd2hlbiB1c2luZyBmb3JlaWduIGZl bmNlcy4gKi8KKwlzcGluX2xvY2tfaXJxc2F2ZSgmc2NoZWRfZW5naW5lLT5sb2NrLCBmbGFncyk7 CisKKwlpZiAoc3VibWlzc2lvbl9kaXNhYmxlZChndWMpIHx8IGd1Yy0+c3RhbGxlZF9yZXF1ZXN0 IHx8CisJICAgICFpOTE1X3NjaGVkX2VuZ2luZV9pc19lbXB0eShzY2hlZF9lbmdpbmUpKQorCQlx dWV1ZV9yZXF1ZXN0KHNjaGVkX2VuZ2luZSwgcnEsIHJxX3ByaW8ocnEpKTsKKwllbHNlIGlmIChn dWNfYnlwYXNzX3Rhc2tsZXRfc3VibWl0KGd1YywgcnEpID09IC1FQlVTWSkKKwkJdGFza2xldF9o aV9zY2hlZHVsZSgmc2NoZWRfZW5naW5lLT50YXNrbGV0KTsKKworCXNwaW5fdW5sb2NrX2lycXJl c3RvcmUoJnNjaGVkX2VuZ2luZS0+bG9jaywgZmxhZ3MpOworfQorCitzdGF0aWMgaW50IG5ld19n dWNfaWQoc3RydWN0IGludGVsX2d1YyAqZ3VjKQoreworCXJldHVybiBpZGFfc2ltcGxlX2dldCgm Z3VjLT5ndWNfaWRzLCAwLAorCQkJICAgICAgR1VDX01BWF9MUkNfREVTQ1JJUFRPUlMsIEdGUF9L RVJORUwgfAorCQkJICAgICAgX19HRlBfUkVUUllfTUFZRkFJTCB8IF9fR0ZQX05PV0FSTik7Cit9 CisKK3N0YXRpYyB2b2lkIF9fcmVsZWFzZV9ndWNfaWQoc3RydWN0IGludGVsX2d1YyAqZ3VjLCBz dHJ1Y3QgaW50ZWxfY29udGV4dCAqY2UpCit7CisJaWYgKCFjb250ZXh0X2d1Y19pZF9pbnZhbGlk KGNlKSkgeworCQlpZGFfc2ltcGxlX3JlbW92ZSgmZ3VjLT5ndWNfaWRzLCBjZS0+Z3VjX2lkKTsK KwkJcmVzZXRfbHJjX2Rlc2MoZ3VjLCBjZS0+Z3VjX2lkKTsKKwkJc2V0X2NvbnRleHRfZ3VjX2lk X2ludmFsaWQoY2UpOworCX0KKwlpZiAoIWxpc3RfZW1wdHkoJmNlLT5ndWNfaWRfbGluaykpCisJ CWxpc3RfZGVsX2luaXQoJmNlLT5ndWNfaWRfbGluayk7Cit9CisKK3N0YXRpYyB2b2lkIHJlbGVh c2VfZ3VjX2lkKHN0cnVjdCBpbnRlbF9ndWMgKmd1Yywgc3RydWN0IGludGVsX2NvbnRleHQgKmNl KQoreworCXVuc2lnbmVkIGxvbmcgZmxhZ3M7CisKKwlzcGluX2xvY2tfaXJxc2F2ZSgmZ3VjLT5j b250ZXh0c19sb2NrLCBmbGFncyk7CisJX19yZWxlYXNlX2d1Y19pZChndWMsIGNlKTsKKwlzcGlu X3VubG9ja19pcnFyZXN0b3JlKCZndWMtPmNvbnRleHRzX2xvY2ssIGZsYWdzKTsKK30KKworc3Rh dGljIGludCBzdGVhbF9ndWNfaWQoc3RydWN0IGludGVsX2d1YyAqZ3VjKQoreworCXN0cnVjdCBp bnRlbF9jb250ZXh0ICpjZTsKKwlpbnQgZ3VjX2lkOworCisJbG9ja2RlcF9hc3NlcnRfaGVsZCgm Z3VjLT5jb250ZXh0c19sb2NrKTsKKworCWlmICghbGlzdF9lbXB0eSgmZ3VjLT5ndWNfaWRfbGlz dCkpIHsKKwkJY2UgPSBsaXN0X2ZpcnN0X2VudHJ5KCZndWMtPmd1Y19pZF9saXN0LAorCQkJCSAg ICAgIHN0cnVjdCBpbnRlbF9jb250ZXh0LAorCQkJCSAgICAgIGd1Y19pZF9saW5rKTsKKworCQlH RU1fQlVHX09OKGF0b21pY19yZWFkKCZjZS0+Z3VjX2lkX3JlZikpOworCQlHRU1fQlVHX09OKGNv bnRleHRfZ3VjX2lkX2ludmFsaWQoY2UpKTsKKworCQlsaXN0X2RlbF9pbml0KCZjZS0+Z3VjX2lk X2xpbmspOworCQlndWNfaWQgPSBjZS0+Z3VjX2lkOworCQljbHJfY29udGV4dF9yZWdpc3RlcmVk KGNlKTsKKwkJc2V0X2NvbnRleHRfZ3VjX2lkX2ludmFsaWQoY2UpOworCQlyZXR1cm4gZ3VjX2lk OworCX0gZWxzZSB7CisJCXJldHVybiAtRUFHQUlOOworCX0KK30KKworc3RhdGljIGludCBhc3Np Z25fZ3VjX2lkKHN0cnVjdCBpbnRlbF9ndWMgKmd1YywgdTE2ICpvdXQpCit7CisJaW50IHJldDsK KworCWxvY2tkZXBfYXNzZXJ0X2hlbGQoJmd1Yy0+Y29udGV4dHNfbG9jayk7CisKKwlyZXQgPSBu ZXdfZ3VjX2lkKGd1Yyk7CisJaWYgKHVubGlrZWx5KHJldCA8IDApKSB7CisJCXJldCA9IHN0ZWFs X2d1Y19pZChndWMpOworCQlpZiAocmV0IDwgMCkKKwkJCXJldHVybiByZXQ7CisJfQorCisJKm91 dCA9IHJldDsKKwlyZXR1cm4gMDsKK30KKworI2RlZmluZSBQSU5fR1VDX0lEX1RSSUVTCTQKK3N0 YXRpYyBpbnQgcGluX2d1Y19pZChzdHJ1Y3QgaW50ZWxfZ3VjICpndWMsIHN0cnVjdCBpbnRlbF9j b250ZXh0ICpjZSkKK3sKKwlpbnQgcmV0ID0gMDsKKwl1bnNpZ25lZCBsb25nIGZsYWdzLCB0cmll cyA9IFBJTl9HVUNfSURfVFJJRVM7CisKKwlHRU1fQlVHX09OKGF0b21pY19yZWFkKCZjZS0+Z3Vj X2lkX3JlZikpOworCit0cnlfYWdhaW46CisJc3Bpbl9sb2NrX2lycXNhdmUoJmd1Yy0+Y29udGV4 dHNfbG9jaywgZmxhZ3MpOworCisJaWYgKGNvbnRleHRfZ3VjX2lkX2ludmFsaWQoY2UpKSB7CisJ CXJldCA9IGFzc2lnbl9ndWNfaWQoZ3VjLCAmY2UtPmd1Y19pZCk7CisJCWlmIChyZXQpCisJCQln b3RvIG91dF91bmxvY2s7CisJCXJldCA9IDE7CS8qIEluZGlkY2F0ZXMgbmV3bHkgYXNzaWduZWQg Z3VjX2lkICovCisJfQorCWlmICghbGlzdF9lbXB0eSgmY2UtPmd1Y19pZF9saW5rKSkKKwkJbGlz dF9kZWxfaW5pdCgmY2UtPmd1Y19pZF9saW5rKTsKKwlhdG9taWNfaW5jKCZjZS0+Z3VjX2lkX3Jl Zik7CisKK291dF91bmxvY2s6CisJc3Bpbl91bmxvY2tfaXJxcmVzdG9yZSgmZ3VjLT5jb250ZXh0 c19sb2NrLCBmbGFncyk7CisKKwkvKgorCSAqIC1FQUdBSU4gaW5kaWNhdGVzIG5vIGd1Y19pZHMg YXJlIGF2YWlsYWJsZSwgbGV0J3MgcmV0aXJlIGFueQorCSAqIG91dHN0YW5kaW5nIHJlcXVlc3Rz IHRvIHNlZSBpZiB0aGF0IGZyZWVzIHVwIGEgZ3VjX2lkLiBJZiB0aGUgZmlyc3QKKwkgKiByZXRp cmUgZGlkbid0IGhlbHAsIGluc2VydCBhIHNsZWVwIHdpdGggdGhlIHRpbWVzbGljZSBkdXJhdGlv biBiZWZvcmUKKwkgKiBhdHRlbXB0aW5nIHRvIHJldGlyZSBtb3JlIHJlcXVlc3RzLiBEb3VibGUg dGhlIHNsZWVwIHBlcmlvZCBlYWNoCisJICogc3Vic2VxdWVudCBwYXNzIGJlZm9yZSBmaW5hbGx5 IGdpdmluZyB1cC4gVGhlIHNsZWVwIHBlcmlvZCBoYXMgbWF4IG9mCisJICogMTAwbXMgYW5kIG1p bmltdW0gb2YgMW1zLgorCSAqLworCWlmIChyZXQgPT0gLUVBR0FJTiAmJiAtLXRyaWVzKSB7CisJ CWlmIChQSU5fR1VDX0lEX1RSSUVTIC0gdHJpZXMgPiAxKSB7CisJCQl1bnNpZ25lZCBpbnQgdGlt ZXNsaWNlX3NoaWZ0ZWQgPQorCQkJCWNlLT5lbmdpbmUtPnByb3BzLnRpbWVzbGljZV9kdXJhdGlv bl9tcyA8PAorCQkJCShQSU5fR1VDX0lEX1RSSUVTIC0gdHJpZXMgLSAyKTsKKwkJCXVuc2lnbmVk IGludCBtYXggPSBtaW5fdCh1bnNpZ25lZCBpbnQsIDEwMCwKKwkJCQkJCSB0aW1lc2xpY2Vfc2hp ZnRlZCk7CisKKwkJCW1zbGVlcChtYXhfdCh1bnNpZ25lZCBpbnQsIG1heCwgMSkpOworCQl9CisJ CWludGVsX2d0X3JldGlyZV9yZXF1ZXN0cyhndWNfdG9fZ3QoZ3VjKSk7CisJCWdvdG8gdHJ5X2Fn YWluOworCX0KKworCXJldHVybiByZXQ7Cit9CisKK3N0YXRpYyB2b2lkIHVucGluX2d1Y19pZChz dHJ1Y3QgaW50ZWxfZ3VjICpndWMsIHN0cnVjdCBpbnRlbF9jb250ZXh0ICpjZSkKK3sKKwl1bnNp Z25lZCBsb25nIGZsYWdzOworCisJR0VNX0JVR19PTihhdG9taWNfcmVhZCgmY2UtPmd1Y19pZF9y ZWYpIDwgMCk7CisKKwlzcGluX2xvY2tfaXJxc2F2ZSgmZ3VjLT5jb250ZXh0c19sb2NrLCBmbGFn cyk7CisJaWYgKCFjb250ZXh0X2d1Y19pZF9pbnZhbGlkKGNlKSAmJiBsaXN0X2VtcHR5KCZjZS0+ Z3VjX2lkX2xpbmspICYmCisJICAgICFhdG9taWNfcmVhZCgmY2UtPmd1Y19pZF9yZWYpKQorCQls aXN0X2FkZF90YWlsKCZjZS0+Z3VjX2lkX2xpbmssICZndWMtPmd1Y19pZF9saXN0KTsKKwlzcGlu X3VubG9ja19pcnFyZXN0b3JlKCZndWMtPmNvbnRleHRzX2xvY2ssIGZsYWdzKTsKK30KKworc3Rh dGljIGludCBfX2d1Y19hY3Rpb25fcmVnaXN0ZXJfY29udGV4dChzdHJ1Y3QgaW50ZWxfZ3VjICpn dWMsCisJCQkJCSB1MzIgZ3VjX2lkLAorCQkJCQkgdTMyIG9mZnNldCwKKwkJCQkJIGJvb2wgbG9v cCkKK3sKKwl1MzIgYWN0aW9uW10gPSB7CisJCUlOVEVMX0dVQ19BQ1RJT05fUkVHSVNURVJfQ09O VEVYVCwKKwkJZ3VjX2lkLAorCQlvZmZzZXQsCisJfTsKKworCXJldHVybiBndWNfc3VibWlzc2lv bl9zZW5kX2J1c3lfbG9vcChndWMsIGFjdGlvbiwgQVJSQVlfU0laRShhY3Rpb24pLAorCQkJCQkg ICAgIDAsIGxvb3ApOworfQorCitzdGF0aWMgaW50IHJlZ2lzdGVyX2NvbnRleHQoc3RydWN0IGlu dGVsX2NvbnRleHQgKmNlLCBib29sIGxvb3ApCit7CisJc3RydWN0IGludGVsX2d1YyAqZ3VjID0g Y2VfdG9fZ3VjKGNlKTsKKwl1MzIgb2Zmc2V0ID0gaW50ZWxfZ3VjX2dndHRfb2Zmc2V0KGd1Yywg Z3VjLT5scmNfZGVzY19wb29sKSArCisJCWNlLT5ndWNfaWQgKiBzaXplb2Yoc3RydWN0IGd1Y19s cmNfZGVzYyk7CisJaW50IHJldDsKKworCXRyYWNlX2ludGVsX2NvbnRleHRfcmVnaXN0ZXIoY2Up OworCisJcmV0ID0gX19ndWNfYWN0aW9uX3JlZ2lzdGVyX2NvbnRleHQoZ3VjLCBjZS0+Z3VjX2lk LCBvZmZzZXQsIGxvb3ApOworCXNldF9jb250ZXh0X3JlZ2lzdGVyZWQoY2UpOworCXJldHVybiBy ZXQ7Cit9CisKK3N0YXRpYyBpbnQgX19ndWNfYWN0aW9uX2RlcmVnaXN0ZXJfY29udGV4dChzdHJ1 Y3QgaW50ZWxfZ3VjICpndWMsCisJCQkJCSAgIHUzMiBndWNfaWQsCisJCQkJCSAgIGJvb2wgbG9v cCkKK3sKKwl1MzIgYWN0aW9uW10gPSB7CisJCUlOVEVMX0dVQ19BQ1RJT05fREVSRUdJU1RFUl9D T05URVhULAorCQlndWNfaWQsCisJfTsKKworCXJldHVybiBndWNfc3VibWlzc2lvbl9zZW5kX2J1 c3lfbG9vcChndWMsIGFjdGlvbiwgQVJSQVlfU0laRShhY3Rpb24pLAorCQkJCQkgICAgIEcySF9M RU5fRFdfREVSRUdJU1RFUl9DT05URVhULAorCQkJCQkgICAgIGxvb3ApOworfQorCitzdGF0aWMg aW50IGRlcmVnaXN0ZXJfY29udGV4dChzdHJ1Y3QgaW50ZWxfY29udGV4dCAqY2UsIHUzMiBndWNf aWQsIGJvb2wgbG9vcCkKK3sKKwlzdHJ1Y3QgaW50ZWxfZ3VjICpndWMgPSBjZV90b19ndWMoY2Up OworCisJdHJhY2VfaW50ZWxfY29udGV4dF9kZXJlZ2lzdGVyKGNlKTsKKworCXJldHVybiBfX2d1 Y19hY3Rpb25fZGVyZWdpc3Rlcl9jb250ZXh0KGd1YywgZ3VjX2lkLCBsb29wKTsKK30KKworc3Rh dGljIGludGVsX2VuZ2luZV9tYXNrX3QgYWRqdXN0X2VuZ2luZV9tYXNrKHU4IGNsYXNzLCBpbnRl bF9lbmdpbmVfbWFza190IG1hc2spCit7CisJc3dpdGNoIChjbGFzcykgeworCWNhc2UgUkVOREVS X0NMQVNTOgorCQlyZXR1cm4gbWFzayA+PiBSQ1MwOworCWNhc2UgVklERU9fRU5IQU5DRU1FTlRf Q0xBU1M6CisJCXJldHVybiBtYXNrID4+IFZFQ1MwOworCWNhc2UgVklERU9fREVDT0RFX0NMQVNT OgorCQlyZXR1cm4gbWFzayA+PiBWQ1MwOworCWNhc2UgQ09QWV9FTkdJTkVfQ0xBU1M6CisJCXJl dHVybiBtYXNrID4+IEJDUzA7CisJZGVmYXVsdDoKKwkJTUlTU0lOR19DQVNFKGNsYXNzKTsKKwkJ cmV0dXJuIDA7CisJfQorfQorCitzdGF0aWMgdm9pZCBndWNfY29udGV4dF9wb2xpY3lfaW5pdChz dHJ1Y3QgaW50ZWxfZW5naW5lX2NzICplbmdpbmUsCisJCQkJICAgIHN0cnVjdCBndWNfbHJjX2Rl c2MgKmRlc2MpCit7CisJZGVzYy0+cG9saWN5X2ZsYWdzID0gMDsKKworCWlmIChlbmdpbmUtPmZs YWdzICYgSTkxNV9FTkdJTkVfV0FOVF9GT1JDRURfUFJFRU1QVElPTikKKwkJZGVzYy0+cG9saWN5 X2ZsYWdzIHw9IENPTlRFWFRfUE9MSUNZX0ZMQUdfUFJFRU1QVF9UT19JRExFOworCisJLyogTkI6 IEZvciBib3RoIG9mIHRoZXNlLCB6ZXJvIG1lYW5zIGRpc2FibGVkLiAqLworCWRlc2MtPmV4ZWN1 dGlvbl9xdWFudHVtID0gZW5naW5lLT5wcm9wcy50aW1lc2xpY2VfZHVyYXRpb25fbXMgKiAxMDAw OworCWRlc2MtPnByZWVtcHRpb25fdGltZW91dCA9IGVuZ2luZS0+cHJvcHMucHJlZW1wdF90aW1l b3V0X21zICogMTAwMDsKK30KKworc3RhdGljIGlubGluZSB1OCBtYXBfaTkxNV9wcmlvX3RvX2d1 Y19wcmlvKGludCBwcmlvKTsKKworc3RhdGljIGludCBndWNfbHJjX2Rlc2NfcGluKHN0cnVjdCBp bnRlbF9jb250ZXh0ICpjZSwgYm9vbCBsb29wKQoreworCXN0cnVjdCBpbnRlbF9lbmdpbmVfY3Mg KmVuZ2luZSA9IGNlLT5lbmdpbmU7CisJc3RydWN0IGludGVsX3J1bnRpbWVfcG0gKnJ1bnRpbWVf cG0gPSBlbmdpbmUtPnVuY29yZS0+cnBtOworCXN0cnVjdCBpbnRlbF9ndWMgKmd1YyA9ICZlbmdp bmUtPmd0LT51Yy5ndWM7CisJdTMyIGRlc2NfaWR4ID0gY2UtPmd1Y19pZDsKKwlzdHJ1Y3QgZ3Vj X2xyY19kZXNjICpkZXNjOworCWNvbnN0IHN0cnVjdCBpOTE1X2dlbV9jb250ZXh0ICpjdHg7CisJ aW50IHByaW8gPSBJOTE1X0NPTlRFWFRfREVGQVVMVF9QUklPUklUWTsKKwlib29sIGNvbnRleHRf cmVnaXN0ZXJlZDsKKwlpbnRlbF93YWtlcmVmX3Qgd2FrZXJlZjsKKwlpbnQgcmV0ID0gMDsKKwor CUdFTV9CVUdfT04oIWVuZ2luZS0+bWFzayk7CisKKwkvKgorCSAqIEVuc3VyZSBMUkMgKyBDVCB2 bWFzIGFyZSBpcyBzYW1lIHJlZ2lvbiBhcyB3cml0ZSBiYXJyaWVyIGlzIGRvbmUKKwkgKiBiYXNl ZCBvbiBDVCB2bWEgcmVnaW9uLgorCSAqLworCUdFTV9CVUdfT04oaTkxNV9nZW1fb2JqZWN0X2lz X2xtZW0oZ3VjLT5jdC52bWEtPm9iaikgIT0KKwkJICAgaTkxNV9nZW1fb2JqZWN0X2lzX2xtZW0o Y2UtPnJpbmctPnZtYS0+b2JqKSk7CisKKwljb250ZXh0X3JlZ2lzdGVyZWQgPSBscmNfZGVzY19y ZWdpc3RlcmVkKGd1YywgZGVzY19pZHgpOworCisJcmN1X3JlYWRfbG9jaygpOworCWN0eCA9IHJj dV9kZXJlZmVyZW5jZShjZS0+Z2VtX2NvbnRleHQpOworCWlmIChjdHgpCisJCXByaW8gPSBjdHgt PnNjaGVkLnByaW9yaXR5OworCXJjdV9yZWFkX3VubG9jaygpOworCisJcmVzZXRfbHJjX2Rlc2Mo Z3VjLCBkZXNjX2lkeCk7CisJc2V0X2xyY19kZXNjX3JlZ2lzdGVyZWQoZ3VjLCBkZXNjX2lkeCwg Y2UpOworCisJZGVzYyA9IF9fZ2V0X2xyY19kZXNjKGd1YywgZGVzY19pZHgpOworCWRlc2MtPmVu Z2luZV9jbGFzcyA9IGVuZ2luZV9jbGFzc190b19ndWNfY2xhc3MoZW5naW5lLT5jbGFzcyk7CisJ ZGVzYy0+ZW5naW5lX3N1Ym1pdF9tYXNrID0gYWRqdXN0X2VuZ2luZV9tYXNrKGVuZ2luZS0+Y2xh c3MsCisJCQkJCQkgICAgICBlbmdpbmUtPm1hc2spOworCWRlc2MtPmh3X2NvbnRleHRfZGVzYyA9 IGNlLT5scmMubHJjYTsKKwljZS0+Z3VjX3ByaW8gPSBtYXBfaTkxNV9wcmlvX3RvX2d1Y19wcmlv KHByaW8pOworCWRlc2MtPnByaW9yaXR5ID0gY2UtPmd1Y19wcmlvOworCWRlc2MtPmNvbnRleHRf ZmxhZ3MgPSBDT05URVhUX1JFR0lTVFJBVElPTl9GTEFHX0tNRDsKKwlndWNfY29udGV4dF9wb2xp Y3lfaW5pdChlbmdpbmUsIGRlc2MpOworCWluaXRfc2NoZWRfc3RhdGUoY2UpOworCisJLyoKKwkg KiBUaGUgY29udGV4dF9sb29rdXAgeGFycmF5IGlzIHVzZWQgdG8gZGV0ZXJtaW5lIGlmIHRoZSBo YXJkd2FyZQorCSAqIGNvbnRleHQgaXMgY3VycmVudGx5IHJlZ2lzdGVyZWQuIFRoZXJlIGFyZSB0 d28gY2FzZXMgaW4gd2hpY2ggaXQKKwkgKiBjb3VsZCBiZSByZWdpc3RlcmVkIGVpdGhlciB0aGUg Z3VjX2lkIGhhcyBiZWVuIHN0b2xlbiBmcm9tIGZyb20KKwkgKiBhbm90aGVyIGNvbnRleHQgb3Ig dGhlIGxyYyBkZXNjcmlwdG9yIGFkZHJlc3Mgb2YgdGhpcyBjb250ZXh0IGhhcworCSAqIGNoYW5n ZWQuIEluIGVpdGhlciBjYXNlIHRoZSBjb250ZXh0IG5lZWRzIHRvIGJlIGRlcmVnaXN0ZXJlZCB3 aXRoIHRoZQorCSAqIEd1QyBiZWZvcmUgcmVnaXN0ZXJpbmcgdGhpcyBjb250ZXh0LgorCSAqLwor CWlmIChjb250ZXh0X3JlZ2lzdGVyZWQpIHsKKwkJdHJhY2VfaW50ZWxfY29udGV4dF9zdGVhbF9n dWNfaWQoY2UpOworCQlpZiAoIWxvb3ApIHsKKwkJCXNldF9jb250ZXh0X3dhaXRfZm9yX2RlcmVn aXN0ZXJfdG9fcmVnaXN0ZXIoY2UpOworCQkJaW50ZWxfY29udGV4dF9nZXQoY2UpOworCQl9IGVs c2UgeworCQkJYm9vbCBkaXNhYmxlZDsKKwkJCXVuc2lnbmVkIGxvbmcgZmxhZ3M7CisKKwkJCS8q IFNlYWwgcmFjZSB3aXRoIFJlc2V0ICovCisJCQlzcGluX2xvY2tfaXJxc2F2ZSgmY2UtPmd1Y19z dGF0ZS5sb2NrLCBmbGFncyk7CisJCQlkaXNhYmxlZCA9IHN1Ym1pc3Npb25fZGlzYWJsZWQoZ3Vj KTsKKwkJCWlmIChsaWtlbHkoIWRpc2FibGVkKSkgeworCQkJCXNldF9jb250ZXh0X3dhaXRfZm9y X2RlcmVnaXN0ZXJfdG9fcmVnaXN0ZXIoY2UpOworCQkJCWludGVsX2NvbnRleHRfZ2V0KGNlKTsK KwkJCX0KKwkJCXNwaW5fdW5sb2NrX2lycXJlc3RvcmUoJmNlLT5ndWNfc3RhdGUubG9jaywgZmxh Z3MpOworCQkJaWYgKHVubGlrZWx5KGRpc2FibGVkKSkgeworCQkJCXJlc2V0X2xyY19kZXNjKGd1 YywgZGVzY19pZHgpOworCQkJCXJldHVybiAwOwkvKiBXaWxsIGdldCByZWdpc3RlcmVkIGxhdGVy ICovCisJCQl9CisJCX0KKworCQkvKgorCQkgKiBJZiBzdGVhbGluZyB0aGUgZ3VjX2lkLCB0aGlz IGNlIGhhcyB0aGUgc2FtZSBndWNfaWQgYXMgdGhlCisJCSAqIGNvbnRleHQgd2hvc2UgZ3VjX2lk IHdhcyBzdG9sZW4uCisJCSAqLworCQl3aXRoX2ludGVsX3J1bnRpbWVfcG0ocnVudGltZV9wbSwg d2FrZXJlZikKKwkJCXJldCA9IGRlcmVnaXN0ZXJfY29udGV4dChjZSwgY2UtPmd1Y19pZCwgbG9v cCk7CisJCWlmICh1bmxpa2VseShyZXQgPT0gLUVCVVNZKSkgeworCQkJY2xyX2NvbnRleHRfd2Fp dF9mb3JfZGVyZWdpc3Rlcl90b19yZWdpc3RlcihjZSk7CisJCQlpbnRlbF9jb250ZXh0X3B1dChj ZSk7CisJCX0gZWxzZSBpZiAodW5saWtlbHkocmV0ID09IC1FTk9ERVYpKQorCQkJcmV0ID0gMDsJ LyogV2lsbCBnZXQgcmVnaXN0ZXJlZCBsYXRlciAqLworCX0gZWxzZSB7CisJCXdpdGhfaW50ZWxf cnVudGltZV9wbShydW50aW1lX3BtLCB3YWtlcmVmKQorCQkJcmV0ID0gcmVnaXN0ZXJfY29udGV4 dChjZSwgbG9vcCk7CisJCWlmICh1bmxpa2VseShyZXQgPT0gLUVCVVNZKSkKKwkJCXJlc2V0X2xy Y19kZXNjKGd1YywgZGVzY19pZHgpOworCQllbHNlIGlmICh1bmxpa2VseShyZXQgPT0gLUVOT0RF VikpCisJCQlyZXQgPSAwOwkvKiBXaWxsIGdldCByZWdpc3RlcmVkIGxhdGVyICovCisJfQorCisJ cmV0dXJuIHJldDsKK30KKworc3RhdGljIGludCBfX2d1Y19jb250ZXh0X3ByZV9waW4oc3RydWN0 IGludGVsX2NvbnRleHQgKmNlLAorCQkJCSBzdHJ1Y3QgaW50ZWxfZW5naW5lX2NzICplbmdpbmUs CisJCQkJIHN0cnVjdCBpOTE1X2dlbV93d19jdHggKnd3LAorCQkJCSB2b2lkICoqdmFkZHIpCit7 CisJcmV0dXJuIGxyY19wcmVfcGluKGNlLCBlbmdpbmUsIHd3LCB2YWRkcik7Cit9CisKK3N0YXRp YyBpbnQgX19ndWNfY29udGV4dF9waW4oc3RydWN0IGludGVsX2NvbnRleHQgKmNlLAorCQkJICAg ICBzdHJ1Y3QgaW50ZWxfZW5naW5lX2NzICplbmdpbmUsCisJCQkgICAgIHZvaWQgKnZhZGRyKQor eworCWlmIChpOTE1X2dndHRfb2Zmc2V0KGNlLT5zdGF0ZSkgIT0KKwkgICAgKGNlLT5scmMubHJj YSAmIENUWF9HVFRfQUREUkVTU19NQVNLKSkKKwkJc2V0X2JpdChDT05URVhUX0xSQ0FfRElSVFks ICZjZS0+ZmxhZ3MpOworCisJLyoKKwkgKiBHdUMgY29udGV4dCBnZXRzIHBpbm5lZCBpbiBndWNf cmVxdWVzdF9hbGxvYy4gU2VlIHRoYXQgZnVuY3Rpb24gZm9yCisJICogZXhwbGFpbmF0aW9uIG9m IHdoeS4KKwkgKi8KKworCXJldHVybiBscmNfcGluKGNlLCBlbmdpbmUsIHZhZGRyKTsKK30KKwor c3RhdGljIGludCBndWNfY29udGV4dF9wcmVfcGluKHN0cnVjdCBpbnRlbF9jb250ZXh0ICpjZSwK KwkJCSAgICAgICBzdHJ1Y3QgaTkxNV9nZW1fd3dfY3R4ICp3dywKKwkJCSAgICAgICB2b2lkICoq dmFkZHIpCit7CisJcmV0dXJuIF9fZ3VjX2NvbnRleHRfcHJlX3BpbihjZSwgY2UtPmVuZ2luZSwg d3csIHZhZGRyKTsKK30KKworc3RhdGljIGludCBndWNfY29udGV4dF9waW4oc3RydWN0IGludGVs X2NvbnRleHQgKmNlLCB2b2lkICp2YWRkcikKK3sKKwlyZXR1cm4gX19ndWNfY29udGV4dF9waW4o Y2UsIGNlLT5lbmdpbmUsIHZhZGRyKTsKK30KKworc3RhdGljIHZvaWQgZ3VjX2NvbnRleHRfdW5w aW4oc3RydWN0IGludGVsX2NvbnRleHQgKmNlKQoreworCXN0cnVjdCBpbnRlbF9ndWMgKmd1YyA9 IGNlX3RvX2d1YyhjZSk7CisKKwl1bnBpbl9ndWNfaWQoZ3VjLCBjZSk7CisJbHJjX3VucGluKGNl KTsKK30KKworc3RhdGljIHZvaWQgZ3VjX2NvbnRleHRfcG9zdF91bnBpbihzdHJ1Y3QgaW50ZWxf Y29udGV4dCAqY2UpCit7CisJbHJjX3Bvc3RfdW5waW4oY2UpOworfQorCitzdGF0aWMgdm9pZCBf X2d1Y19jb250ZXh0X3NjaGVkX2VuYWJsZShzdHJ1Y3QgaW50ZWxfZ3VjICpndWMsCisJCQkJICAg ICAgIHN0cnVjdCBpbnRlbF9jb250ZXh0ICpjZSkKK3sKKwl1MzIgYWN0aW9uW10gPSB7CisJCUlO VEVMX0dVQ19BQ1RJT05fU0NIRURfQ09OVEVYVF9NT0RFX1NFVCwKKwkJY2UtPmd1Y19pZCwKKwkJ R1VDX0NPTlRFWFRfRU5BQkxFCisJfTsKKworCXRyYWNlX2ludGVsX2NvbnRleHRfc2NoZWRfZW5h YmxlKGNlKTsKKworCWd1Y19zdWJtaXNzaW9uX3NlbmRfYnVzeV9sb29wKGd1YywgYWN0aW9uLCBB UlJBWV9TSVpFKGFjdGlvbiksCisJCQkJICAgICAgRzJIX0xFTl9EV19TQ0hFRF9DT05URVhUX01P REVfU0VULCB0cnVlKTsKK30KKworc3RhdGljIHZvaWQgX19ndWNfY29udGV4dF9zY2hlZF9kaXNh YmxlKHN0cnVjdCBpbnRlbF9ndWMgKmd1YywKKwkJCQkJc3RydWN0IGludGVsX2NvbnRleHQgKmNl LAorCQkJCQl1MTYgZ3VjX2lkKQoreworCXUzMiBhY3Rpb25bXSA9IHsKKwkJSU5URUxfR1VDX0FD VElPTl9TQ0hFRF9DT05URVhUX01PREVfU0VULAorCQlndWNfaWQsCS8qIGNlLT5ndWNfaWQgbm90 IHN0YWJsZSAqLworCQlHVUNfQ09OVEVYVF9ESVNBQkxFCisJfTsKKworCUdFTV9CVUdfT04oZ3Vj X2lkID09IEdVQ19JTlZBTElEX0xSQ19JRCk7CisKKwl0cmFjZV9pbnRlbF9jb250ZXh0X3NjaGVk X2Rpc2FibGUoY2UpOworCisJZ3VjX3N1Ym1pc3Npb25fc2VuZF9idXN5X2xvb3AoZ3VjLCBhY3Rp b24sIEFSUkFZX1NJWkUoYWN0aW9uKSwKKwkJCQkgICAgICBHMkhfTEVOX0RXX1NDSEVEX0NPTlRF WFRfTU9ERV9TRVQsIHRydWUpOworfQorCitzdGF0aWMgdm9pZCBndWNfYmxvY2tlZF9mZW5jZV9j b21wbGV0ZShzdHJ1Y3QgaW50ZWxfY29udGV4dCAqY2UpCit7CisJbG9ja2RlcF9hc3NlcnRfaGVs ZCgmY2UtPmd1Y19zdGF0ZS5sb2NrKTsKKworCWlmICghaTkxNV9zd19mZW5jZV9kb25lKCZjZS0+ Z3VjX2Jsb2NrZWQpKQorCQlpOTE1X3N3X2ZlbmNlX2NvbXBsZXRlKCZjZS0+Z3VjX2Jsb2NrZWQp OworfQorCitzdGF0aWMgdm9pZCBndWNfYmxvY2tlZF9mZW5jZV9yZWluaXQoc3RydWN0IGludGVs X2NvbnRleHQgKmNlKQoreworCWxvY2tkZXBfYXNzZXJ0X2hlbGQoJmNlLT5ndWNfc3RhdGUubG9j ayk7CisJR0VNX0JVR19PTighaTkxNV9zd19mZW5jZV9kb25lKCZjZS0+Z3VjX2Jsb2NrZWQpKTsK KwlpOTE1X3N3X2ZlbmNlX2ZpbmkoJmNlLT5ndWNfYmxvY2tlZCk7CisJaTkxNV9zd19mZW5jZV9y ZWluaXQoJmNlLT5ndWNfYmxvY2tlZCk7CisJaTkxNV9zd19mZW5jZV9hd2FpdCgmY2UtPmd1Y19i bG9ja2VkKTsKKwlpOTE1X3N3X2ZlbmNlX2NvbW1pdCgmY2UtPmd1Y19ibG9ja2VkKTsKK30KKwor c3RhdGljIHUxNiBwcmVwX2NvbnRleHRfcGVuZGluZ19kaXNhYmxlKHN0cnVjdCBpbnRlbF9jb250 ZXh0ICpjZSkKK3sKKwlsb2NrZGVwX2Fzc2VydF9oZWxkKCZjZS0+Z3VjX3N0YXRlLmxvY2spOwor CisJc2V0X2NvbnRleHRfcGVuZGluZ19kaXNhYmxlKGNlKTsKKwljbHJfY29udGV4dF9lbmFibGVk KGNlKTsKKwlndWNfYmxvY2tlZF9mZW5jZV9yZWluaXQoY2UpOworCWludGVsX2NvbnRleHRfZ2V0 KGNlKTsKKworCXJldHVybiBjZS0+Z3VjX2lkOworfQorCitzdGF0aWMgc3RydWN0IGk5MTVfc3df ZmVuY2UgKmd1Y19jb250ZXh0X2Jsb2NrKHN0cnVjdCBpbnRlbF9jb250ZXh0ICpjZSkKK3sKKwlz dHJ1Y3QgaW50ZWxfZ3VjICpndWMgPSBjZV90b19ndWMoY2UpOworCXN0cnVjdCBpOTE1X3NjaGVk X2VuZ2luZSAqc2NoZWRfZW5naW5lID0gY2UtPmVuZ2luZS0+c2NoZWRfZW5naW5lOworCXVuc2ln bmVkIGxvbmcgZmxhZ3M7CisJc3RydWN0IGludGVsX3J1bnRpbWVfcG0gKnJ1bnRpbWVfcG0gPSAm Y2UtPmVuZ2luZS0+Z3QtPmk5MTUtPnJ1bnRpbWVfcG07CisJaW50ZWxfd2FrZXJlZl90IHdha2Vy ZWY7CisJdTE2IGd1Y19pZDsKKwlib29sIGVuYWJsZWQ7CisKKwlzcGluX2xvY2tfaXJxc2F2ZSgm c2NoZWRfZW5naW5lLT5sb2NrLCBmbGFncyk7CisJaW5jcl9jb250ZXh0X2Jsb2NrZWQoY2UpOwor CXNwaW5fdW5sb2NrX2lycXJlc3RvcmUoJnNjaGVkX2VuZ2luZS0+bG9jaywgZmxhZ3MpOworCisJ c3Bpbl9sb2NrX2lycXNhdmUoJmNlLT5ndWNfc3RhdGUubG9jaywgZmxhZ3MpOworCWVuYWJsZWQg PSBjb250ZXh0X2VuYWJsZWQoY2UpOworCWlmICh1bmxpa2VseSghZW5hYmxlZCB8fCBzdWJtaXNz aW9uX2Rpc2FibGVkKGd1YykpKSB7CisJCWlmIChlbmFibGVkKQorCQkJY2xyX2NvbnRleHRfZW5h YmxlZChjZSk7CisJCXNwaW5fdW5sb2NrX2lycXJlc3RvcmUoJmNlLT5ndWNfc3RhdGUubG9jaywg ZmxhZ3MpOworCQlyZXR1cm4gJmNlLT5ndWNfYmxvY2tlZDsKKwl9CisKKwkvKgorCSAqIFdlIGFk ZCArMiBoZXJlIGFzIHRoZSBzY2hlZHVsZSBkaXNhYmxlIGNvbXBsZXRlIENUQiBoYW5kbGVyIGNh bGxzCisJICogaW50ZWxfY29udGV4dF9zY2hlZF9kaXNhYmxlX3VucGluICgtMiB0byBwaW5fY291 bnQpLgorCSAqLworCWF0b21pY19hZGQoMiwgJmNlLT5waW5fY291bnQpOworCisJZ3VjX2lkID0g cHJlcF9jb250ZXh0X3BlbmRpbmdfZGlzYWJsZShjZSk7CisJc3Bpbl91bmxvY2tfaXJxcmVzdG9y ZSgmY2UtPmd1Y19zdGF0ZS5sb2NrLCBmbGFncyk7CisKKwl3aXRoX2ludGVsX3J1bnRpbWVfcG0o cnVudGltZV9wbSwgd2FrZXJlZikKKwkJX19ndWNfY29udGV4dF9zY2hlZF9kaXNhYmxlKGd1Yywg Y2UsIGd1Y19pZCk7CisKKwlyZXR1cm4gJmNlLT5ndWNfYmxvY2tlZDsKK30KKworc3RhdGljIHZv aWQgZ3VjX2NvbnRleHRfdW5ibG9jayhzdHJ1Y3QgaW50ZWxfY29udGV4dCAqY2UpCit7CisJc3Ry dWN0IGludGVsX2d1YyAqZ3VjID0gY2VfdG9fZ3VjKGNlKTsKKwlzdHJ1Y3QgaTkxNV9zY2hlZF9l bmdpbmUgKnNjaGVkX2VuZ2luZSA9IGNlLT5lbmdpbmUtPnNjaGVkX2VuZ2luZTsKKwl1bnNpZ25l ZCBsb25nIGZsYWdzOworCXN0cnVjdCBpbnRlbF9ydW50aW1lX3BtICpydW50aW1lX3BtID0gJmNl LT5lbmdpbmUtPmd0LT5pOTE1LT5ydW50aW1lX3BtOworCWludGVsX3dha2VyZWZfdCB3YWtlcmVm OworCisJR0VNX0JVR19PTihjb250ZXh0X2VuYWJsZWQoY2UpKTsKKworCWlmICh1bmxpa2VseShj b250ZXh0X2Jsb2NrZWQoY2UpID4gMSkpIHsKKwkJc3Bpbl9sb2NrX2lycXNhdmUoJnNjaGVkX2Vu Z2luZS0+bG9jaywgZmxhZ3MpOworCQlpZiAobGlrZWx5KGNvbnRleHRfYmxvY2tlZChjZSkgPiAx KSkKKwkJCWdvdG8gZGVjcmVtZW50OworCQlzcGluX3VubG9ja19pcnFyZXN0b3JlKCZzY2hlZF9l bmdpbmUtPmxvY2ssIGZsYWdzKTsKKwl9CisKKwlzcGluX2xvY2tfaXJxc2F2ZSgmY2UtPmd1Y19z dGF0ZS5sb2NrLCBmbGFncyk7CisJaWYgKHVubGlrZWx5KHN1Ym1pc3Npb25fZGlzYWJsZWQoZ3Vj KSB8fAorCQkgICAgICFpbnRlbF9jb250ZXh0X2lzX3Bpbm5lZChjZSkgfHwKKwkJICAgICBjb250 ZXh0X3BlbmRpbmdfZGlzYWJsZShjZSkgfHwKKwkJICAgICBjb250ZXh0X2Jsb2NrZWQoY2UpID4g MSkpIHsKKwkJc3Bpbl91bmxvY2tfaXJxcmVzdG9yZSgmY2UtPmd1Y19zdGF0ZS5sb2NrLCBmbGFn cyk7CisJCWdvdG8gb3V0OworCX0KKworCXNldF9jb250ZXh0X3BlbmRpbmdfZW5hYmxlKGNlKTsK KwlzZXRfY29udGV4dF9lbmFibGVkKGNlKTsKKwlpbnRlbF9jb250ZXh0X2dldChjZSk7CisJc3Bp bl91bmxvY2tfaXJxcmVzdG9yZSgmY2UtPmd1Y19zdGF0ZS5sb2NrLCBmbGFncyk7CisKKwl3aXRo X2ludGVsX3J1bnRpbWVfcG0ocnVudGltZV9wbSwgd2FrZXJlZikKKwkJX19ndWNfY29udGV4dF9z Y2hlZF9lbmFibGUoZ3VjLCBjZSk7CisKK291dDoKKwlzcGluX2xvY2tfaXJxc2F2ZSgmc2NoZWRf ZW5naW5lLT5sb2NrLCBmbGFncyk7CitkZWNyZW1lbnQ6CisJZGVjcl9jb250ZXh0X2Jsb2NrZWQo Y2UpOworCXNwaW5fdW5sb2NrX2lycXJlc3RvcmUoJnNjaGVkX2VuZ2luZS0+bG9jaywgZmxhZ3Mp OworfQorCitzdGF0aWMgdm9pZCBndWNfY29udGV4dF9jYW5jZWxfcmVxdWVzdChzdHJ1Y3QgaW50 ZWxfY29udGV4dCAqY2UsCisJCQkJICAgICAgIHN0cnVjdCBpOTE1X3JlcXVlc3QgKnJxKQorewor CWlmIChpOTE1X3N3X2ZlbmNlX3NpZ25hbGVkKCZycS0+c3VibWl0KSkgeworCQlzdHJ1Y3QgaTkx NV9zd19mZW5jZSAqZmVuY2UgPSBndWNfY29udGV4dF9ibG9jayhjZSk7CisKKwkJaTkxNV9zd19m ZW5jZV93YWl0KGZlbmNlKTsKKwkJaWYgKCFpOTE1X3JlcXVlc3RfY29tcGxldGVkKHJxKSkgewor CQkJX19pOTE1X3JlcXVlc3Rfc2tpcChycSk7CisJCQlndWNfcmVzZXRfc3RhdGUoY2UsIGludGVs X3Jpbmdfd3JhcChjZS0+cmluZywgcnEtPmhlYWQpLAorCQkJCQl0cnVlKTsKKwkJfQorCQlndWNf Y29udGV4dF91bmJsb2NrKGNlKTsKKwl9Cit9CisKK3N0YXRpYyB2b2lkIF9fZ3VjX2NvbnRleHRf c2V0X3ByZWVtcHRpb25fdGltZW91dChzdHJ1Y3QgaW50ZWxfZ3VjICpndWMsCisJCQkJCQkgdTE2 IGd1Y19pZCwKKwkJCQkJCSB1MzIgcHJlZW1wdGlvbl90aW1lb3V0KQoreworCXUzMiBhY3Rpb24g W10gPSB7CisJCUlOVEVMX0dVQ19BQ1RJT05fU0VUX0NPTlRFWFRfUFJFRU1QVElPTl9USU1FT1VU LAorCQlndWNfaWQsCisJCXByZWVtcHRpb25fdGltZW91dAorCX07CisKKwlpbnRlbF9ndWNfc2Vu ZF9idXN5X2xvb3AoZ3VjLCBhY3Rpb24sIEFSUkFZX1NJWkUoYWN0aW9uKSwgMCwgdHJ1ZSk7Cit9 CisKK3N0YXRpYyB2b2lkIGd1Y19jb250ZXh0X2JhbihzdHJ1Y3QgaW50ZWxfY29udGV4dCAqY2Us IHN0cnVjdCBpOTE1X3JlcXVlc3QgKnJxKQoreworCXN0cnVjdCBpbnRlbF9ndWMgKmd1YyA9IGNl X3RvX2d1YyhjZSk7CisJc3RydWN0IGludGVsX3J1bnRpbWVfcG0gKnJ1bnRpbWVfcG0gPQorCQkm Y2UtPmVuZ2luZS0+Z3QtPmk5MTUtPnJ1bnRpbWVfcG07CisJaW50ZWxfd2FrZXJlZl90IHdha2Vy ZWY7CisJdW5zaWduZWQgbG9uZyBmbGFnczsKKworCWd1Y19mbHVzaF9zdWJtaXNzaW9ucyhndWMp OworCisJc3Bpbl9sb2NrX2lycXNhdmUoJmNlLT5ndWNfc3RhdGUubG9jaywgZmxhZ3MpOworCXNl dF9jb250ZXh0X2Jhbm5lZChjZSk7CisKKwlpZiAoc3VibWlzc2lvbl9kaXNhYmxlZChndWMpIHx8 ICghY29udGV4dF9lbmFibGVkKGNlKSAmJgorCSAgICAhY29udGV4dF9wZW5kaW5nX2Rpc2FibGUo Y2UpKSkgeworCQlzcGluX3VubG9ja19pcnFyZXN0b3JlKCZjZS0+Z3VjX3N0YXRlLmxvY2ssIGZs YWdzKTsKKworCQlndWNfY2FuY2VsX2NvbnRleHRfcmVxdWVzdHMoY2UpOworCQlpbnRlbF9lbmdp bmVfc2lnbmFsX2JyZWFkY3J1bWJzKGNlLT5lbmdpbmUpOworCX0gZWxzZSBpZiAoIWNvbnRleHRf cGVuZGluZ19kaXNhYmxlKGNlKSkgeworCQl1MTYgZ3VjX2lkOworCisJCS8qCisJCSAqIFdlIGFk ZCArMiBoZXJlIGFzIHRoZSBzY2hlZHVsZSBkaXNhYmxlIGNvbXBsZXRlIENUQiBoYW5kbGVyCisJ CSAqIGNhbGxzIGludGVsX2NvbnRleHRfc2NoZWRfZGlzYWJsZV91bnBpbiAoLTIgdG8gcGluX2Nv dW50KS4KKwkJICovCisJCWF0b21pY19hZGQoMiwgJmNlLT5waW5fY291bnQpOworCisJCWd1Y19p ZCA9IHByZXBfY29udGV4dF9wZW5kaW5nX2Rpc2FibGUoY2UpOworCQlzcGluX3VubG9ja19pcnFy ZXN0b3JlKCZjZS0+Z3VjX3N0YXRlLmxvY2ssIGZsYWdzKTsKKworCQkvKgorCQkgKiBJbiBhZGRp dGlvbiB0byBkaXNhYmxpbmcgc2NoZWR1bGluZywgc2V0IHRoZSBwcmVlbXB0aW9uCisJCSAqIHRp bWVvdXQgdG8gdGhlIG1pbmltdW0gdmFsdWUgKDEgdXMpIHNvIHRoZSBiYW5uZWQgY29udGV4dAor CQkgKiBnZXRzIGtpY2tlZCBvZmYgdGhlIEhXIEFTQVAuCisJCSAqLworCQl3aXRoX2ludGVsX3J1 bnRpbWVfcG0ocnVudGltZV9wbSwgd2FrZXJlZikgeworCQkJX19ndWNfY29udGV4dF9zZXRfcHJl ZW1wdGlvbl90aW1lb3V0KGd1YywgZ3VjX2lkLCAxKTsKKwkJCV9fZ3VjX2NvbnRleHRfc2NoZWRf ZGlzYWJsZShndWMsIGNlLCBndWNfaWQpOworCQl9CisJfSBlbHNlIHsKKwkJaWYgKCFjb250ZXh0 X2d1Y19pZF9pbnZhbGlkKGNlKSkKKwkJCXdpdGhfaW50ZWxfcnVudGltZV9wbShydW50aW1lX3Bt LCB3YWtlcmVmKQorCQkJCV9fZ3VjX2NvbnRleHRfc2V0X3ByZWVtcHRpb25fdGltZW91dChndWMs CisJCQkJCQkJCSAgICAgY2UtPmd1Y19pZCwKKwkJCQkJCQkJICAgICAxKTsKKwkJc3Bpbl91bmxv Y2tfaXJxcmVzdG9yZSgmY2UtPmd1Y19zdGF0ZS5sb2NrLCBmbGFncyk7CisJfQorfQorCitzdGF0 aWMgdm9pZCBndWNfY29udGV4dF9zY2hlZF9kaXNhYmxlKHN0cnVjdCBpbnRlbF9jb250ZXh0ICpj ZSkKK3sKKwlzdHJ1Y3QgaW50ZWxfZ3VjICpndWMgPSBjZV90b19ndWMoY2UpOworCXVuc2lnbmVk IGxvbmcgZmxhZ3M7CisJc3RydWN0IGludGVsX3J1bnRpbWVfcG0gKnJ1bnRpbWVfcG0gPSAmY2Ut PmVuZ2luZS0+Z3QtPmk5MTUtPnJ1bnRpbWVfcG07CisJaW50ZWxfd2FrZXJlZl90IHdha2VyZWY7 CisJdTE2IGd1Y19pZDsKKwlib29sIGVuYWJsZWQ7CisKKwlpZiAoc3VibWlzc2lvbl9kaXNhYmxl ZChndWMpIHx8IGNvbnRleHRfZ3VjX2lkX2ludmFsaWQoY2UpIHx8CisJICAgICFscmNfZGVzY19y ZWdpc3RlcmVkKGd1YywgY2UtPmd1Y19pZCkpIHsKKwkJY2xyX2NvbnRleHRfZW5hYmxlZChjZSk7 CisJCWdvdG8gdW5waW47CisJfQorCisJaWYgKCFjb250ZXh0X2VuYWJsZWQoY2UpKQorCQlnb3Rv IHVucGluOworCisJc3Bpbl9sb2NrX2lycXNhdmUoJmNlLT5ndWNfc3RhdGUubG9jaywgZmxhZ3Mp OworCisJLyoKKwkgKiBXZSBoYXZlIHRvIGNoZWNrIGlmIHRoZSBjb250ZXh0IGhhcyBiZWVuIGRp c2FibGVkIGJ5IGFub3RoZXIgdGhyZWFkLgorCSAqIFdlIGFsc28gaGF2ZSB0byBjaGVjayBpZiB0 aGUgY29udGV4dCBoYXMgYmVlbiBwaW5uZWQgYWdhaW4gYXMgYW5vdGhlcgorCSAqIHBpbiBvcGVy YXRpb24gaXMgYWxsb3dlZCB0byBwYXNzIHRoaXMgZnVuY3Rpb24uIENoZWNraW5nIHRoZSBwaW4K KwkgKiBjb3VudCwgd2l0aGluIGNlLT5ndWNfc3RhdGUubG9jaywgc3luY2hyb25pemVzIHRoaXMg ZnVuY3Rpb24gd2l0aAorCSAqIGd1Y19yZXF1ZXN0X2FsbG9jIGVuc3VyaW5nIGEgcmVxdWVzdCBk b2Vzbid0IHNsaXAgdGhyb3VnaCB0aGUKKwkgKiAnY29udGV4dF9wZW5kaW5nX2Rpc2FibGUnIGZl bmNlLiBDaGVja2luZyB3aXRoaW4gdGhlIHNwaW4gbG9jayAoY2FuJ3QKKwkgKiBzbGVlcCkgZW5z dXJlcyBhbm90aGVyIHByb2Nlc3MgZG9lc24ndCBwaW4gdGhpcyBjb250ZXh0IGFuZCBnZW5lcmF0 ZQorCSAqIGEgcmVxdWVzdCBiZWZvcmUgd2Ugc2V0IHRoZSAnY29udGV4dF9wZW5kaW5nX2Rpc2Fi bGUnIGZsYWcgaGVyZS4KKwkgKi8KKwllbmFibGVkID0gY29udGV4dF9lbmFibGVkKGNlKTsKKwlp ZiAodW5saWtlbHkoIWVuYWJsZWQgfHwgc3VibWlzc2lvbl9kaXNhYmxlZChndWMpKSkgeworCQlp ZiAoZW5hYmxlZCkKKwkJCWNscl9jb250ZXh0X2VuYWJsZWQoY2UpOworCQlzcGluX3VubG9ja19p cnFyZXN0b3JlKCZjZS0+Z3VjX3N0YXRlLmxvY2ssIGZsYWdzKTsKKwkJZ290byB1bnBpbjsKKwl9 CisJaWYgKHVubGlrZWx5KGF0b21pY19hZGRfdW5sZXNzKCZjZS0+cGluX2NvdW50LCAtMiwgMikp KSB7CisJCXNwaW5fdW5sb2NrX2lycXJlc3RvcmUoJmNlLT5ndWNfc3RhdGUubG9jaywgZmxhZ3Mp OworCQlyZXR1cm47CisJfQorCWd1Y19pZCA9IHByZXBfY29udGV4dF9wZW5kaW5nX2Rpc2FibGUo Y2UpOworCisJc3Bpbl91bmxvY2tfaXJxcmVzdG9yZSgmY2UtPmd1Y19zdGF0ZS5sb2NrLCBmbGFn cyk7CisKKwl3aXRoX2ludGVsX3J1bnRpbWVfcG0ocnVudGltZV9wbSwgd2FrZXJlZikKKwkJX19n dWNfY29udGV4dF9zY2hlZF9kaXNhYmxlKGd1YywgY2UsIGd1Y19pZCk7CisKKwlyZXR1cm47Cit1 bnBpbjoKKwlpbnRlbF9jb250ZXh0X3NjaGVkX2Rpc2FibGVfdW5waW4oY2UpOworfQorCitzdGF0 aWMgaW5saW5lIHZvaWQgZ3VjX2xyY19kZXNjX3VucGluKHN0cnVjdCBpbnRlbF9jb250ZXh0ICpj ZSkKK3sKKwlzdHJ1Y3QgaW50ZWxfZ3VjICpndWMgPSBjZV90b19ndWMoY2UpOworCisJR0VNX0JV R19PTighbHJjX2Rlc2NfcmVnaXN0ZXJlZChndWMsIGNlLT5ndWNfaWQpKTsKKwlHRU1fQlVHX09O KGNlICE9IF9fZ2V0X2NvbnRleHQoZ3VjLCBjZS0+Z3VjX2lkKSk7CisJR0VNX0JVR19PTihjb250 ZXh0X2VuYWJsZWQoY2UpKTsKKworCWNscl9jb250ZXh0X3JlZ2lzdGVyZWQoY2UpOworCWRlcmVn aXN0ZXJfY29udGV4dChjZSwgY2UtPmd1Y19pZCwgdHJ1ZSk7Cit9CisKK3N0YXRpYyB2b2lkIF9f Z3VjX2NvbnRleHRfZGVzdHJveShzdHJ1Y3QgaW50ZWxfY29udGV4dCAqY2UpCit7CisJR0VNX0JV R19PTihjZS0+Z3VjX3ByaW9fY291bnRbR1VDX0NMSUVOVF9QUklPUklUWV9LTURfSElHSF0gfHwK KwkJICAgY2UtPmd1Y19wcmlvX2NvdW50W0dVQ19DTElFTlRfUFJJT1JJVFlfSElHSF0gfHwKKwkJ ICAgY2UtPmd1Y19wcmlvX2NvdW50W0dVQ19DTElFTlRfUFJJT1JJVFlfS01EX05PUk1BTF0gfHwK KwkJICAgY2UtPmd1Y19wcmlvX2NvdW50W0dVQ19DTElFTlRfUFJJT1JJVFlfTk9STUFMXSk7CisK KwlscmNfZmluaShjZSk7CisJaW50ZWxfY29udGV4dF9maW5pKGNlKTsKKworCWlmIChpbnRlbF9l bmdpbmVfaXNfdmlydHVhbChjZS0+ZW5naW5lKSkgeworCQlzdHJ1Y3QgZ3VjX3ZpcnR1YWxfZW5n aW5lICp2ZSA9CisJCQljb250YWluZXJfb2YoY2UsIHR5cGVvZigqdmUpLCBjb250ZXh0KTsKKwor CQlpZiAodmUtPmJhc2UuYnJlYWRjcnVtYnMpCisJCQlpbnRlbF9icmVhZGNydW1ic19wdXQodmUt PmJhc2UuYnJlYWRjcnVtYnMpOworCisJCWtmcmVlKHZlKTsKKwl9IGVsc2UgeworCQlpbnRlbF9j b250ZXh0X2ZyZWUoY2UpOworCX0KK30KKworc3RhdGljIHZvaWQgZ3VjX2NvbnRleHRfZGVzdHJv eShzdHJ1Y3Qga3JlZiAqa3JlZikKK3sKKwlzdHJ1Y3QgaW50ZWxfY29udGV4dCAqY2UgPSBjb250 YWluZXJfb2Yoa3JlZiwgdHlwZW9mKCpjZSksIHJlZik7CisJc3RydWN0IGludGVsX3J1bnRpbWVf cG0gKnJ1bnRpbWVfcG0gPSBjZS0+ZW5naW5lLT51bmNvcmUtPnJwbTsKKwlzdHJ1Y3QgaW50ZWxf Z3VjICpndWMgPSBjZV90b19ndWMoY2UpOworCWludGVsX3dha2VyZWZfdCB3YWtlcmVmOworCXVu c2lnbmVkIGxvbmcgZmxhZ3M7CisJYm9vbCBkaXNhYmxlZDsKKworCS8qCisJICogSWYgdGhlIGd1 Y19pZCBpcyBpbnZhbGlkIHRoaXMgY29udGV4dCBoYXMgYmVlbiBzdG9sZW4gYW5kIHdlIGNhbiBm cmVlCisJICogaXQgaW1tZWRpYXRlbHkuIEFsc28gY2FuIGJlIGZyZWVkIGltbWVkaWF0ZWx5IGlm IHRoZSBjb250ZXh0IGlzIG5vdAorCSAqIHJlZ2lzdGVyZWQgd2l0aCB0aGUgR3VDIG9yIHRoZSBH dUMgaXMgaW4gdGhlIG1pZGRsZSBvZiBhIHJlc2V0LgorCSAqLworCWlmIChjb250ZXh0X2d1Y19p ZF9pbnZhbGlkKGNlKSkgeworCQlfX2d1Y19jb250ZXh0X2Rlc3Ryb3koY2UpOworCQlyZXR1cm47 CisJfSBlbHNlIGlmIChzdWJtaXNzaW9uX2Rpc2FibGVkKGd1YykgfHwKKwkJICAgIWxyY19kZXNj X3JlZ2lzdGVyZWQoZ3VjLCBjZS0+Z3VjX2lkKSkgeworCQlyZWxlYXNlX2d1Y19pZChndWMsIGNl KTsKKwkJX19ndWNfY29udGV4dF9kZXN0cm95KGNlKTsKKwkJcmV0dXJuOworCX0KKworCS8qCisJ ICogV2UgaGF2ZSB0byBhY3F1aXJlIHRoZSBjb250ZXh0IHNwaW5sb2NrIGFuZCBjaGVjayBndWNf aWQgYWdhaW4sIGlmIGl0CisJICogaXMgdmFsaWQgaXQgaGFzbid0IGJlZW4gc3RvbGVuIGFuZCBu ZWVkcyB0byBiZSBkZXJlZ2lzdGVyZWQuIFdlCisJICogZGVsZXRlIHRoaXMgY29udGV4dCBmcm9t IHRoZSBsaXN0IG9mIHVucGlubmVkIGd1Y19pZHMgYXZhaWxhYmxlIHRvCisJICogc3RlYWwgdG8g c2VhbCBhIHJhY2Ugd2l0aCBndWNfbHJjX2Rlc2NfcGluKCkuIFdoZW4gdGhlIEcySCBDVEIKKwkg KiByZXR1cm5zIGluZGljYXRpbmcgdGhpcyBjb250ZXh0IGhhcyBiZWVuIGRlcmVnaXN0ZXJlZCB0 aGUgZ3VjX2lkIGlzCisJICogcmV0dXJuZWQgdG8gdGhlIHBvb2wgb2YgYXZhaWxhYmxlIGd1Y19p ZHMuCisJICovCisJc3Bpbl9sb2NrX2lycXNhdmUoJmd1Yy0+Y29udGV4dHNfbG9jaywgZmxhZ3Mp OworCWlmIChjb250ZXh0X2d1Y19pZF9pbnZhbGlkKGNlKSkgeworCQlzcGluX3VubG9ja19pcnFy ZXN0b3JlKCZndWMtPmNvbnRleHRzX2xvY2ssIGZsYWdzKTsKKwkJX19ndWNfY29udGV4dF9kZXN0 cm95KGNlKTsKKwkJcmV0dXJuOworCX0KKworCWlmICghbGlzdF9lbXB0eSgmY2UtPmd1Y19pZF9s aW5rKSkKKwkJbGlzdF9kZWxfaW5pdCgmY2UtPmd1Y19pZF9saW5rKTsKKwlzcGluX3VubG9ja19p cnFyZXN0b3JlKCZndWMtPmNvbnRleHRzX2xvY2ssIGZsYWdzKTsKKworCS8qIFNlYWwgcmFjZSB3 aXRoIFJlc2V0ICovCisJc3Bpbl9sb2NrX2lycXNhdmUoJmNlLT5ndWNfc3RhdGUubG9jaywgZmxh Z3MpOworCWRpc2FibGVkID0gc3VibWlzc2lvbl9kaXNhYmxlZChndWMpOworCWlmIChsaWtlbHko IWRpc2FibGVkKSkKKwkJc2V0X2NvbnRleHRfZGVzdHJveWVkKGNlKTsKKwlzcGluX3VubG9ja19p cnFyZXN0b3JlKCZjZS0+Z3VjX3N0YXRlLmxvY2ssIGZsYWdzKTsKKwlpZiAodW5saWtlbHkoZGlz YWJsZWQpKSB7CisJCXJlbGVhc2VfZ3VjX2lkKGd1YywgY2UpOworCQlfX2d1Y19jb250ZXh0X2Rl c3Ryb3koY2UpOworCQlyZXR1cm47CisJfQorCisJLyoKKwkgKiBXZSBkZWZlciBHdUMgY29udGV4 dCBkZXJlZ2lzdHJhdGlvbiB1bnRpbCB0aGUgY29udGV4dCBpcyBkZXN0cm95ZWQKKwkgKiBpbiBv cmRlciB0byBzYXZlIG9uIENUQnMuIFdpdGggdGhpcyBvcHRpbWl6YXRpb24gaWRlYWxseSB3ZSBv bmx5IG5lZWQKKwkgKiAxIENUQiB0byByZWdpc3RlciB0aGUgY29udGV4dCBkdXJpbmcgdGhlIGZp cnN0IHBpbiBhbmQgMSBDVEIgdG8KKwkgKiBkZXJlZ2lzdGVyIHRoZSBjb250ZXh0IHdoZW4gdGhl IGNvbnRleHQgaXMgZGVzdHJveWVkLiBXaXRob3V0IHRoaXMKKwkgKiBvcHRpbWl6YXRpb24sIGEg Q1RCIHdvdWxkIGJlIG5lZWRlZCBldmVyeSBwaW4gJiB1bnBpbi4KKwkgKgorCSAqIFhYWDogTmVl ZCB0byBhY3FpdXJlIHRoZSBydW50aW1lIHdha2VyZWYgYXMgdGhpcyBjYW4gYmUgdHJpZ2dlcmVk CisJICogZnJvbSBjb250ZXh0X2ZyZWVfd29ya2VyIHdoZW4gcnVudGltZSB3YWtlcmVmIGlzIG5v dCBoZWxkLgorCSAqIGd1Y19scmNfZGVzY191bnBpbiByZXF1aXJlcyB0aGUgcnVudGltZSBhcyBh IEd1QyByZWdpc3RlciBpcyB3cml0dGVuCisJICogaW4gSDJHIENUQiB0byBkZXJlZ2lzdGVyIHRo ZSBjb250ZXh0LiBBIGZ1dHVyZSBwYXRjaCBtYXkgZGVmZXIgdGhpcworCSAqIEgyRyBDVEIgaWYg dGhlIHJ1bnRpbWUgd2FrZXJlZiBpcyB6ZXJvLgorCSAqLworCXdpdGhfaW50ZWxfcnVudGltZV9w bShydW50aW1lX3BtLCB3YWtlcmVmKQorCQlndWNfbHJjX2Rlc2NfdW5waW4oY2UpOworfQorCitz dGF0aWMgaW50IGd1Y19jb250ZXh0X2FsbG9jKHN0cnVjdCBpbnRlbF9jb250ZXh0ICpjZSkKK3sK KwlyZXR1cm4gbHJjX2FsbG9jKGNlLCBjZS0+ZW5naW5lKTsKK30KKworc3RhdGljIHZvaWQgZ3Vj X2NvbnRleHRfc2V0X3ByaW8oc3RydWN0IGludGVsX2d1YyAqZ3VjLAorCQkJCSBzdHJ1Y3QgaW50 ZWxfY29udGV4dCAqY2UsCisJCQkJIHU4IHByaW8pCit7CisJdTMyIGFjdGlvbltdID0geworCQlJ TlRFTF9HVUNfQUNUSU9OX1NFVF9DT05URVhUX1BSSU9SSVRZLAorCQljZS0+Z3VjX2lkLAorCQlw cmlvLAorCX07CisKKwlHRU1fQlVHX09OKHByaW8gPCBHVUNfQ0xJRU5UX1BSSU9SSVRZX0tNRF9I SUdIIHx8CisJCSAgIHByaW8gPiBHVUNfQ0xJRU5UX1BSSU9SSVRZX05PUk1BTCk7CisKKwlpZiAo Y2UtPmd1Y19wcmlvID09IHByaW8gfHwgc3VibWlzc2lvbl9kaXNhYmxlZChndWMpIHx8CisJICAg ICFjb250ZXh0X3JlZ2lzdGVyZWQoY2UpKQorCQlyZXR1cm47CisKKwlndWNfc3VibWlzc2lvbl9z ZW5kX2J1c3lfbG9vcChndWMsIGFjdGlvbiwgQVJSQVlfU0laRShhY3Rpb24pLCAwLCB0cnVlKTsK KworCWNlLT5ndWNfcHJpbyA9IHByaW87CisJdHJhY2VfaW50ZWxfY29udGV4dF9zZXRfcHJpbyhj ZSk7Cit9CisKK3N0YXRpYyBpbmxpbmUgdTggbWFwX2k5MTVfcHJpb190b19ndWNfcHJpbyhpbnQg cHJpbykKK3sKKwlpZiAocHJpbyA9PSBJOTE1X1BSSU9SSVRZX05PUk1BTCkKKwkJcmV0dXJuIEdV Q19DTElFTlRfUFJJT1JJVFlfS01EX05PUk1BTDsKKwllbHNlIGlmIChwcmlvIDwgSTkxNV9QUklP UklUWV9OT1JNQUwpCisJCXJldHVybiBHVUNfQ0xJRU5UX1BSSU9SSVRZX05PUk1BTDsKKwllbHNl IGlmIChwcmlvICE9IEk5MTVfUFJJT1JJVFlfQkFSUklFUikKKwkJcmV0dXJuIEdVQ19DTElFTlRf UFJJT1JJVFlfSElHSDsKKwllbHNlCisJCXJldHVybiBHVUNfQ0xJRU5UX1BSSU9SSVRZX0tNRF9I SUdIOworfQorCitzdGF0aWMgaW5saW5lIHZvaWQgYWRkX2NvbnRleHRfaW5mbGlnaHRfcHJpbyhz dHJ1Y3QgaW50ZWxfY29udGV4dCAqY2UsCisJCQkJCSAgICAgdTggZ3VjX3ByaW8pCit7CisJbG9j a2RlcF9hc3NlcnRfaGVsZCgmY2UtPmd1Y19hY3RpdmUubG9jayk7CisJR0VNX0JVR19PTihndWNf cHJpbyA+PSBBUlJBWV9TSVpFKGNlLT5ndWNfcHJpb19jb3VudCkpOworCisJKytjZS0+Z3VjX3By aW9fY291bnRbZ3VjX3ByaW9dOworCisJLyogT3ZlcmZsb3cgcHJvdGVjdGlvbiAqLworCUdFTV9X QVJOX09OKCFjZS0+Z3VjX3ByaW9fY291bnRbZ3VjX3ByaW9dKTsKK30KKworc3RhdGljIGlubGlu ZSB2b2lkIHN1Yl9jb250ZXh0X2luZmxpZ2h0X3ByaW8oc3RydWN0IGludGVsX2NvbnRleHQgKmNl LAorCQkJCQkgICAgIHU4IGd1Y19wcmlvKQoreworCWxvY2tkZXBfYXNzZXJ0X2hlbGQoJmNlLT5n dWNfYWN0aXZlLmxvY2spOworCUdFTV9CVUdfT04oZ3VjX3ByaW8gPj0gQVJSQVlfU0laRShjZS0+ Z3VjX3ByaW9fY291bnQpKTsKKworCS8qIFVuZGVyZmxvdyBwcm90ZWN0aW9uICovCisJR0VNX1dB Uk5fT04oIWNlLT5ndWNfcHJpb19jb3VudFtndWNfcHJpb10pOworCisJLS1jZS0+Z3VjX3ByaW9f Y291bnRbZ3VjX3ByaW9dOworfQorCitzdGF0aWMgaW5saW5lIHZvaWQgdXBkYXRlX2NvbnRleHRf cHJpbyhzdHJ1Y3QgaW50ZWxfY29udGV4dCAqY2UpCit7CisJc3RydWN0IGludGVsX2d1YyAqZ3Vj ID0gJmNlLT5lbmdpbmUtPmd0LT51Yy5ndWM7CisJaW50IGk7CisKKwlsb2NrZGVwX2Fzc2VydF9o ZWxkKCZjZS0+Z3VjX2FjdGl2ZS5sb2NrKTsKKworCWZvciAoaSA9IDA7IGkgPCBBUlJBWV9TSVpF KGNlLT5ndWNfcHJpb19jb3VudCk7ICsraSkgeworCQlpZiAoY2UtPmd1Y19wcmlvX2NvdW50W2ld KSB7CisJCQlndWNfY29udGV4dF9zZXRfcHJpbyhndWMsIGNlLCBpKTsKKwkJCWJyZWFrOworCQl9 CisJfQorfQorCitzdGF0aWMgaW5saW5lIGJvb2wgbmV3X2d1Y19wcmlvX2hpZ2hlcih1OCBvbGRf Z3VjX3ByaW8sIHU4IG5ld19ndWNfcHJpbykKK3sKKwkvKiBMb3dlciB2YWx1ZSBpcyBoaWdoZXIg cHJpb3JpdHkgKi8KKwlyZXR1cm4gbmV3X2d1Y19wcmlvIDwgb2xkX2d1Y19wcmlvOworfQorCitz dGF0aWMgdm9pZCBhZGRfdG9fY29udGV4dChzdHJ1Y3QgaTkxNV9yZXF1ZXN0ICpycSkKK3sKKwlz dHJ1Y3QgaW50ZWxfY29udGV4dCAqY2UgPSBycS0+Y29udGV4dDsKKwl1OCBuZXdfZ3VjX3ByaW8g PSBtYXBfaTkxNV9wcmlvX3RvX2d1Y19wcmlvKHJxX3ByaW8ocnEpKTsKKworCUdFTV9CVUdfT04o cnEtPmd1Y19wcmlvID09IEdVQ19QUklPX0ZJTkkpOworCisJc3Bpbl9sb2NrKCZjZS0+Z3VjX2Fj dGl2ZS5sb2NrKTsKKwlsaXN0X21vdmVfdGFpbCgmcnEtPnNjaGVkLmxpbmssICZjZS0+Z3VjX2Fj dGl2ZS5yZXF1ZXN0cyk7CisKKwlpZiAocnEtPmd1Y19wcmlvID09IEdVQ19QUklPX0lOSVQpIHsK KwkJcnEtPmd1Y19wcmlvID0gbmV3X2d1Y19wcmlvOworCQlhZGRfY29udGV4dF9pbmZsaWdodF9w cmlvKGNlLCBycS0+Z3VjX3ByaW8pOworCX0gZWxzZSBpZiAobmV3X2d1Y19wcmlvX2hpZ2hlcihy cS0+Z3VjX3ByaW8sIG5ld19ndWNfcHJpbykpIHsKKwkJc3ViX2NvbnRleHRfaW5mbGlnaHRfcHJp byhjZSwgcnEtPmd1Y19wcmlvKTsKKwkJcnEtPmd1Y19wcmlvID0gbmV3X2d1Y19wcmlvOworCQlh ZGRfY29udGV4dF9pbmZsaWdodF9wcmlvKGNlLCBycS0+Z3VjX3ByaW8pOworCX0KKwl1cGRhdGVf Y29udGV4dF9wcmlvKGNlKTsKKworCXNwaW5fdW5sb2NrKCZjZS0+Z3VjX2FjdGl2ZS5sb2NrKTsK K30KKworc3RhdGljIHZvaWQgZ3VjX3ByaW9fZmluaShzdHJ1Y3QgaTkxNV9yZXF1ZXN0ICpycSwg c3RydWN0IGludGVsX2NvbnRleHQgKmNlKQoreworCWlmIChycS0+Z3VjX3ByaW8gIT0gR1VDX1BS SU9fSU5JVCAmJgorCSAgICBycS0+Z3VjX3ByaW8gIT0gR1VDX1BSSU9fRklOSSkgeworCQlzdWJf Y29udGV4dF9pbmZsaWdodF9wcmlvKGNlLCBycS0+Z3VjX3ByaW8pOworCQl1cGRhdGVfY29udGV4 dF9wcmlvKGNlKTsKKwl9CisJcnEtPmd1Y19wcmlvID0gR1VDX1BSSU9fRklOSTsKK30KKworc3Rh dGljIHZvaWQgcmVtb3ZlX2Zyb21fY29udGV4dChzdHJ1Y3QgaTkxNV9yZXF1ZXN0ICpycSkKK3sK KwlzdHJ1Y3QgaW50ZWxfY29udGV4dCAqY2UgPSBycS0+Y29udGV4dDsKKworCXNwaW5fbG9ja19p cnEoJmNlLT5ndWNfYWN0aXZlLmxvY2spOworCisJbGlzdF9kZWxfaW5pdCgmcnEtPnNjaGVkLmxp bmspOworCWNsZWFyX2JpdChJOTE1X0ZFTkNFX0ZMQUdfUFFVRVVFLCAmcnEtPmZlbmNlLmZsYWdz KTsKKworCS8qIFByZXZlbnQgZnVydGhlciBfX2F3YWl0X2V4ZWN1dGlvbigpIHJlZ2lzdGVyaW5n IGEgY2IsIHRoZW4gZmx1c2ggKi8KKwlzZXRfYml0KEk5MTVfRkVOQ0VfRkxBR19BQ1RJVkUsICZy cS0+ZmVuY2UuZmxhZ3MpOworCisJZ3VjX3ByaW9fZmluaShycSwgY2UpOworCisJc3Bpbl91bmxv Y2tfaXJxKCZjZS0+Z3VjX2FjdGl2ZS5sb2NrKTsKKworCWF0b21pY19kZWMoJmNlLT5ndWNfaWRf cmVmKTsKKwlpOTE1X3JlcXVlc3Rfbm90aWZ5X2V4ZWN1dGVfY2JfaW1tKHJxKTsKK30KKworc3Rh dGljIGNvbnN0IHN0cnVjdCBpbnRlbF9jb250ZXh0X29wcyBndWNfY29udGV4dF9vcHMgPSB7CisJ LmFsbG9jID0gZ3VjX2NvbnRleHRfYWxsb2MsCisKKwkucHJlX3BpbiA9IGd1Y19jb250ZXh0X3By ZV9waW4sCisJLnBpbiA9IGd1Y19jb250ZXh0X3BpbiwKKwkudW5waW4gPSBndWNfY29udGV4dF91 bnBpbiwKKwkucG9zdF91bnBpbiA9IGd1Y19jb250ZXh0X3Bvc3RfdW5waW4sCisKKwkuYmFuID0g Z3VjX2NvbnRleHRfYmFuLAorCisJLmNhbmNlbF9yZXF1ZXN0ID0gZ3VjX2NvbnRleHRfY2FuY2Vs X3JlcXVlc3QsCisKKwkuZW50ZXIgPSBpbnRlbF9jb250ZXh0X2VudGVyX2VuZ2luZSwKKwkuZXhp dCA9IGludGVsX2NvbnRleHRfZXhpdF9lbmdpbmUsCisKKwkuc2NoZWRfZGlzYWJsZSA9IGd1Y19j b250ZXh0X3NjaGVkX2Rpc2FibGUsCisKKwkucmVzZXQgPSBscmNfcmVzZXQsCisJLmRlc3Ryb3kg PSBndWNfY29udGV4dF9kZXN0cm95LAorCisJLmNyZWF0ZV92aXJ0dWFsID0gZ3VjX2NyZWF0ZV92 aXJ0dWFsLAorfTsKKworc3RhdGljIHZvaWQgX19ndWNfc2lnbmFsX2NvbnRleHRfZmVuY2Uoc3Ry dWN0IGludGVsX2NvbnRleHQgKmNlKQoreworCXN0cnVjdCBpOTE1X3JlcXVlc3QgKnJxOworCisJ bG9ja2RlcF9hc3NlcnRfaGVsZCgmY2UtPmd1Y19zdGF0ZS5sb2NrKTsKKworCWlmICghbGlzdF9l bXB0eSgmY2UtPmd1Y19zdGF0ZS5mZW5jZXMpKQorCQl0cmFjZV9pbnRlbF9jb250ZXh0X2ZlbmNl X3JlbGVhc2UoY2UpOworCisJbGlzdF9mb3JfZWFjaF9lbnRyeShycSwgJmNlLT5ndWNfc3RhdGUu ZmVuY2VzLCBndWNfZmVuY2VfbGluaykKKwkJaTkxNV9zd19mZW5jZV9jb21wbGV0ZSgmcnEtPnN1 Ym1pdCk7CisKKwlJTklUX0xJU1RfSEVBRCgmY2UtPmd1Y19zdGF0ZS5mZW5jZXMpOworfQorCitz dGF0aWMgdm9pZCBndWNfc2lnbmFsX2NvbnRleHRfZmVuY2Uoc3RydWN0IGludGVsX2NvbnRleHQg KmNlKQoreworCXVuc2lnbmVkIGxvbmcgZmxhZ3M7CisKKwlzcGluX2xvY2tfaXJxc2F2ZSgmY2Ut Pmd1Y19zdGF0ZS5sb2NrLCBmbGFncyk7CisJY2xyX2NvbnRleHRfd2FpdF9mb3JfZGVyZWdpc3Rl cl90b19yZWdpc3RlcihjZSk7CisJX19ndWNfc2lnbmFsX2NvbnRleHRfZmVuY2UoY2UpOworCXNw aW5fdW5sb2NrX2lycXJlc3RvcmUoJmNlLT5ndWNfc3RhdGUubG9jaywgZmxhZ3MpOworfQorCitz dGF0aWMgYm9vbCBjb250ZXh0X25lZWRzX3JlZ2lzdGVyKHN0cnVjdCBpbnRlbF9jb250ZXh0ICpj ZSwgYm9vbCBuZXdfZ3VjX2lkKQoreworCXJldHVybiAobmV3X2d1Y19pZCB8fCB0ZXN0X2JpdChD T05URVhUX0xSQ0FfRElSVFksICZjZS0+ZmxhZ3MpIHx8CisJCSFscmNfZGVzY19yZWdpc3RlcmVk KGNlX3RvX2d1YyhjZSksIGNlLT5ndWNfaWQpKSAmJgorCQkhc3VibWlzc2lvbl9kaXNhYmxlZChj ZV90b19ndWMoY2UpKTsKK30KKworc3RhdGljIGludCBndWNfcmVxdWVzdF9hbGxvYyhzdHJ1Y3Qg aTkxNV9yZXF1ZXN0ICpycSkKK3sKKwlzdHJ1Y3QgaW50ZWxfY29udGV4dCAqY2UgPSBycS0+Y29u dGV4dDsKKwlzdHJ1Y3QgaW50ZWxfZ3VjICpndWMgPSBjZV90b19ndWMoY2UpOworCXVuc2lnbmVk IGxvbmcgZmxhZ3M7CisJaW50IHJldDsKKworCUdFTV9CVUdfT04oIWludGVsX2NvbnRleHRfaXNf cGlubmVkKHJxLT5jb250ZXh0KSk7CisKKwkvKgorCSAqIEZsdXNoIGVub3VnaCBzcGFjZSB0byBy ZWR1Y2UgdGhlIGxpa2VsaWhvb2Qgb2Ygd2FpdGluZyBhZnRlcgorCSAqIHdlIHN0YXJ0IGJ1aWxk aW5nIHRoZSByZXF1ZXN0IC0gaW4gd2hpY2ggY2FzZSB3ZSB3aWxsIGp1c3QKKwkgKiBoYXZlIHRv IHJlcGVhdCB3b3JrLgorCSAqLworCXJxLT5yZXNlcnZlZF9zcGFjZSArPSBHVUNfUkVRVUVTVF9T SVpFOworCisJLyoKKwkgKiBOb3RlIHRoYXQgYWZ0ZXIgdGhpcyBwb2ludCwgd2UgaGF2ZSBjb21t aXR0ZWQgdG8gdXNpbmcKKwkgKiB0aGlzIHJlcXVlc3QgYXMgaXQgaXMgYmVpbmcgdXNlZCB0byBi b3RoIHRyYWNrIHRoZQorCSAqIHN0YXRlIG9mIGVuZ2luZSBpbml0aWFsaXNhdGlvbiBhbmQgbGl2 ZW5lc3Mgb2YgdGhlCisJICogZ29sZGVuIHJlbmRlcnN0YXRlIGFib3ZlLiBUaGluayB0d2ljZSBi ZWZvcmUgeW91IHRyeQorCSAqIHRvIGNhbmNlbC91bndpbmQgdGhpcyByZXF1ZXN0IG5vdy4KKwkg Ki8KKworCS8qIFVuY29uZGl0aW9uYWxseSBpbnZhbGlkYXRlIEdQVSBjYWNoZXMgYW5kIFRMQnMu ICovCisJcmV0ID0gcnEtPmVuZ2luZS0+ZW1pdF9mbHVzaChycSwgRU1JVF9JTlZBTElEQVRFKTsK KwlpZiAocmV0KQorCQlyZXR1cm4gcmV0OworCisJcnEtPnJlc2VydmVkX3NwYWNlIC09IEdVQ19S RVFVRVNUX1NJWkU7CisKKwkvKgorCSAqIENhbGwgcGluX2d1Y19pZCBoZXJlIHJhdGhlciB0aGFu IGluIHRoZSBwaW5uaW5nIHN0ZXAgYXMgd2l0aAorCSAqIGRtYV9yZXN2LCBjb250ZXh0cyBjYW4g YmUgcmVwZWF0ZWRseSBwaW5uZWQgLyB1bnBpbm5lZCB0cmFzaGluZyB0aGUKKwkgKiBndWNfaWRz IGFuZCBjcmVhdGluZyBob3JyaWJsZSByYWNlIGNvbmRpdGlvbnMuIFRoaXMgaXMgZXNwZWNpYWxs eSBiYWQKKwkgKiB3aGVuIGd1Y19pZHMgYXJlIGJlaW5nIHN0b2xlbiBkdWUgdG8gb3ZlciBzdWJz Y3JpcHRpb24uIEJ5IHRoZSB0aW1lCisJICogdGhpcyBmdW5jdGlvbiBpcyByZWFjaGVkLCBpdCBp cyBndWFyYW50ZWVkIHRoYXQgdGhlIGd1Y19pZCB3aWxsIGJlCisJICogcGVyc2lzdGVudCB1bnRp bCB0aGUgZ2VuZXJhdGVkIHJlcXVlc3QgaXMgcmV0aXJlZC4gVGh1cywgc2VhbGluZyB0aGVzZQor CSAqIHJhY2UgY29uZGl0aW9ucy4gSXQgaXMgc3RpbGwgc2FmZSB0byBmYWlsIGhlcmUgaWYgZ3Vj X2lkcyBhcmUKKwkgKiBleGhhdXN0ZWQgYW5kIHJldHVybiAtRUFHQUlOIHRvIHRoZSB1c2VyIGlu ZGljYXRpbmcgdGhhdCB0aGV5IGNhbiB0cnkKKwkgKiBhZ2FpbiBpbiB0aGUgZnV0dXJlLgorCSAq CisJICogVGhlcmUgaXMgbm8gbmVlZCBmb3IgYSBsb2NrIGhlcmUgYXMgdGhlIHRpbWVsaW5lIG11 dGV4IGVuc3VyZXMgYXQKKwkgKiBtb3N0IG9uZSBjb250ZXh0IGNhbiBiZSBleGVjdXRpbmcgdGhp cyBjb2RlIHBhdGggYXQgb25jZS4gVGhlCisJICogZ3VjX2lkX3JlZiBpcyBpbmNyZW1lbnRlZCBv bmNlIGZvciBldmVyeSByZXF1ZXN0IGluIGZsaWdodCBhbmQKKwkgKiBkZWNyZW1lbnRlZCBvbiBl YWNoIHJldGlyZS4gV2hlbiBpdCBpcyB6ZXJvLCBhIGxvY2sgYXJvdW5kIHRoZQorCSAqIGluY3Jl bWVudCAoaW4gcGluX2d1Y19pZCkgaXMgbmVlZGVkIHRvIHNlYWwgYSByYWNlIHdpdGggdW5waW5f Z3VjX2lkLgorCSAqLworCWlmIChhdG9taWNfYWRkX3VubGVzcygmY2UtPmd1Y19pZF9yZWYsIDEs IDApKQorCQlnb3RvIG91dDsKKworCXJldCA9IHBpbl9ndWNfaWQoZ3VjLCBjZSk7CS8qIHJldHVy bnMgMSBpZiBuZXcgZ3VjX2lkIGFzc2lnbmVkICovCisJaWYgKHVubGlrZWx5KHJldCA8IDApKQor CQlyZXR1cm4gcmV0OworCWlmIChjb250ZXh0X25lZWRzX3JlZ2lzdGVyKGNlLCAhIXJldCkpIHsK KwkJcmV0ID0gZ3VjX2xyY19kZXNjX3BpbihjZSwgdHJ1ZSk7CisJCWlmICh1bmxpa2VseShyZXQp KSB7CS8qIHVud2luZCAqLworCQkJaWYgKHJldCA9PSAtRVBJUEUpIHsKKwkJCQlkaXNhYmxlX3N1 Ym1pc3Npb24oZ3VjKTsKKwkJCQlnb3RvIG91dDsJLyogR1BVIHdpbGwgYmUgcmVzZXQgKi8KKwkJ CX0KKwkJCWF0b21pY19kZWMoJmNlLT5ndWNfaWRfcmVmKTsKKwkJCXVucGluX2d1Y19pZChndWMs IGNlKTsKKwkJCXJldHVybiByZXQ7CisJCX0KKwl9CisKKwljbGVhcl9iaXQoQ09OVEVYVF9MUkNB X0RJUlRZLCAmY2UtPmZsYWdzKTsKKworb3V0OgorCS8qCisJICogV2UgYmxvY2sgYWxsIHJlcXVl c3RzIG9uIHRoaXMgY29udGV4dCBpZiBhIEcySCBpcyBwZW5kaW5nIGZvciBhCisJICogc2NoZWR1 bGUgZGlzYWJsZSBvciBjb250ZXh0IGRlcmVnaXN0cmF0aW9uIGFzIHRoZSBHdUMgd2lsbCBmYWls IGEKKwkgKiBzY2hlZHVsZSBlbmFibGUgb3IgY29udGV4dCByZWdpc3RyYXRpb24gaWYgZWl0aGVy IEcySCBpcyBwZW5kaW5nCisJICogcmVzcGVjdGZ1bGx5LiBPbmNlIGEgRzJIIHJldHVybnMsIHRo ZSBmZW5jZSBpcyByZWxlYXNlZCB0aGF0IGlzCisJICogYmxvY2tpbmcgdGhlc2UgcmVxdWVzdHMg KHNlZSBndWNfc2lnbmFsX2NvbnRleHRfZmVuY2UpLgorCSAqCisJICogV2UgY2FuIHNhZmVseSBj aGVjayB0aGUgYmVsb3cgZmllbGRzIG91dHNpZGUgb2YgdGhlIGxvY2sgYXMgaXQgaXNuJ3QKKwkg KiBwb3NzaWJsZSBmb3IgdGhlc2UgZmllbGRzIHRvIHRyYW5zaXRpb24gZnJvbSBiZWluZyBjbGVh ciB0byBzZXQgYnV0CisJICogY29udmVyc2UgaXMgcG9zc2libGUsIGhlbmNlIHRoZSBuZWVkIGZv ciB0aGUgY2hlY2sgd2l0aGluIHRoZSBsb2NrLgorCSAqLworCWlmIChsaWtlbHkoIWNvbnRleHRf d2FpdF9mb3JfZGVyZWdpc3Rlcl90b19yZWdpc3RlcihjZSkgJiYKKwkJICAgIWNvbnRleHRfcGVu ZGluZ19kaXNhYmxlKGNlKSkpCisJCXJldHVybiAwOworCisJc3Bpbl9sb2NrX2lycXNhdmUoJmNl LT5ndWNfc3RhdGUubG9jaywgZmxhZ3MpOworCWlmIChjb250ZXh0X3dhaXRfZm9yX2RlcmVnaXN0 ZXJfdG9fcmVnaXN0ZXIoY2UpIHx8CisJICAgIGNvbnRleHRfcGVuZGluZ19kaXNhYmxlKGNlKSkg eworCQlpOTE1X3N3X2ZlbmNlX2F3YWl0KCZycS0+c3VibWl0KTsKKworCQlsaXN0X2FkZF90YWls KCZycS0+Z3VjX2ZlbmNlX2xpbmssICZjZS0+Z3VjX3N0YXRlLmZlbmNlcyk7CisJfQorCXNwaW5f dW5sb2NrX2lycXJlc3RvcmUoJmNlLT5ndWNfc3RhdGUubG9jaywgZmxhZ3MpOworCisJcmV0dXJu IDA7CiB9CiAKLXN0YXRpYyB2b2lkIGd1Y19yZXNldF9maW5pc2goc3RydWN0IGludGVsX2VuZ2lu ZV9jcyAqZW5naW5lKQorc3RhdGljIGludCBndWNfdmlydHVhbF9jb250ZXh0X3ByZV9waW4oc3Ry dWN0IGludGVsX2NvbnRleHQgKmNlLAorCQkJCSAgICAgICBzdHJ1Y3QgaTkxNV9nZW1fd3dfY3R4 ICp3dywKKwkJCQkgICAgICAgdm9pZCAqKnZhZGRyKQogewotCWlmIChfX3Rhc2tsZXRfZW5hYmxl KCZlbmdpbmUtPnNjaGVkX2VuZ2luZS0+dGFza2xldCkpCi0JCS8qIEFuZCBraWNrIGluIGNhc2Ug d2UgbWlzc2VkIGEgbmV3IHJlcXVlc3Qgc3VibWlzc2lvbi4gKi8KLQkJdGFza2xldF9oaV9zY2hl ZHVsZSgmZW5naW5lLT5zY2hlZF9lbmdpbmUtPnRhc2tsZXQpOworCXN0cnVjdCBpbnRlbF9lbmdp bmVfY3MgKmVuZ2luZSA9IGd1Y192aXJ0dWFsX2dldF9zaWJsaW5nKGNlLT5lbmdpbmUsIDApOwog Ci0JRU5HSU5FX1RSQUNFKGVuZ2luZSwgImRlcHRoLT4lZFxuIiwKLQkJICAgICBhdG9taWNfcmVh ZCgmZW5naW5lLT5zY2hlZF9lbmdpbmUtPnRhc2tsZXQuY291bnQpKTsKKwlyZXR1cm4gX19ndWNf Y29udGV4dF9wcmVfcGluKGNlLCBlbmdpbmUsIHd3LCB2YWRkcik7CiB9CiAKLS8qCi0gKiBTZXQg dXAgdGhlIG1lbW9yeSByZXNvdXJjZXMgdG8gYmUgc2hhcmVkIHdpdGggdGhlIEd1QyAodmlhIHRo ZSBHR1RUKQotICogYXQgZmlybXdhcmUgbG9hZGluZyB0aW1lLgotICovCi1pbnQgaW50ZWxfZ3Vj X3N1Ym1pc3Npb25faW5pdChzdHJ1Y3QgaW50ZWxfZ3VjICpndWMpCitzdGF0aWMgaW50IGd1Y192 aXJ0dWFsX2NvbnRleHRfcGluKHN0cnVjdCBpbnRlbF9jb250ZXh0ICpjZSwgdm9pZCAqdmFkZHIp CiB7Ci0JaW50IHJldDsKLQotCWlmIChndWMtPnN0YWdlX2Rlc2NfcG9vbCkKLQkJcmV0dXJuIDA7 Ci0KLQlyZXQgPSBndWNfc3RhZ2VfZGVzY19wb29sX2NyZWF0ZShndWMpOwotCWlmIChyZXQpCi0J CXJldHVybiByZXQ7Ci0JLyoKLQkgKiBLZWVwIHN0YXRpYyBhbmFseXNlcnMgaGFwcHksIGxldCB0 aGVtIGtub3cgdGhhdCB3ZSBhbGxvY2F0ZWQgdGhlCi0JICogdm1hIGFmdGVyIHRlc3RpbmcgdGhh dCBpdCBkaWRuJ3QgZXhpc3QgZWFybGllci4KLQkgKi8KLQlHRU1fQlVHX09OKCFndWMtPnN0YWdl X2Rlc2NfcG9vbCk7CisJc3RydWN0IGludGVsX2VuZ2luZV9jcyAqZW5naW5lID0gZ3VjX3ZpcnR1 YWxfZ2V0X3NpYmxpbmcoY2UtPmVuZ2luZSwgMCk7CiAKLQlyZXR1cm4gMDsKKwlyZXR1cm4gX19n dWNfY29udGV4dF9waW4oY2UsIGVuZ2luZSwgdmFkZHIpOwogfQogCi12b2lkIGludGVsX2d1Y19z dWJtaXNzaW9uX2Zpbmkoc3RydWN0IGludGVsX2d1YyAqZ3VjKQorc3RhdGljIHZvaWQgZ3VjX3Zp cnR1YWxfY29udGV4dF9lbnRlcihzdHJ1Y3QgaW50ZWxfY29udGV4dCAqY2UpCiB7Ci0JaWYgKGd1 Yy0+c3RhZ2VfZGVzY19wb29sKSB7Ci0JCWd1Y19zdGFnZV9kZXNjX3Bvb2xfZGVzdHJveShndWMp OwotCX0KLX0KKwlpbnRlbF9lbmdpbmVfbWFza190IHRtcCwgbWFzayA9IGNlLT5lbmdpbmUtPm1h c2s7CisJc3RydWN0IGludGVsX2VuZ2luZV9jcyAqZW5naW5lOwogCi1zdGF0aWMgaW50IGd1Y19j b250ZXh0X2FsbG9jKHN0cnVjdCBpbnRlbF9jb250ZXh0ICpjZSkKLXsKLQlyZXR1cm4gbHJjX2Fs bG9jKGNlLCBjZS0+ZW5naW5lKTsKKwlmb3JfZWFjaF9lbmdpbmVfbWFza2VkKGVuZ2luZSwgY2Ut PmVuZ2luZS0+Z3QsIG1hc2ssIHRtcCkKKwkJaW50ZWxfZW5naW5lX3BtX2dldChlbmdpbmUpOwor CisJaW50ZWxfdGltZWxpbmVfZW50ZXIoY2UtPnRpbWVsaW5lKTsKIH0KIAotc3RhdGljIGludCBn dWNfY29udGV4dF9wcmVfcGluKHN0cnVjdCBpbnRlbF9jb250ZXh0ICpjZSwKLQkJCSAgICAgICBz dHJ1Y3QgaTkxNV9nZW1fd3dfY3R4ICp3dywKLQkJCSAgICAgICB2b2lkICoqdmFkZHIpCitzdGF0 aWMgdm9pZCBndWNfdmlydHVhbF9jb250ZXh0X2V4aXQoc3RydWN0IGludGVsX2NvbnRleHQgKmNl KQogewotCXJldHVybiBscmNfcHJlX3BpbihjZSwgY2UtPmVuZ2luZSwgd3csIHZhZGRyKTsKKwlp bnRlbF9lbmdpbmVfbWFza190IHRtcCwgbWFzayA9IGNlLT5lbmdpbmUtPm1hc2s7CisJc3RydWN0 IGludGVsX2VuZ2luZV9jcyAqZW5naW5lOworCisJZm9yX2VhY2hfZW5naW5lX21hc2tlZChlbmdp bmUsIGNlLT5lbmdpbmUtPmd0LCBtYXNrLCB0bXApCisJCWludGVsX2VuZ2luZV9wbV9wdXQoZW5n aW5lKTsKKworCWludGVsX3RpbWVsaW5lX2V4aXQoY2UtPnRpbWVsaW5lKTsKIH0KIAotc3RhdGlj IGludCBndWNfY29udGV4dF9waW4oc3RydWN0IGludGVsX2NvbnRleHQgKmNlLCB2b2lkICp2YWRk cikKK3N0YXRpYyBpbnQgZ3VjX3ZpcnR1YWxfY29udGV4dF9hbGxvYyhzdHJ1Y3QgaW50ZWxfY29u dGV4dCAqY2UpCiB7Ci0JcmV0dXJuIGxyY19waW4oY2UsIGNlLT5lbmdpbmUsIHZhZGRyKTsKKwlz dHJ1Y3QgaW50ZWxfZW5naW5lX2NzICplbmdpbmUgPSBndWNfdmlydHVhbF9nZXRfc2libGluZyhj ZS0+ZW5naW5lLCAwKTsKKworCXJldHVybiBscmNfYWxsb2MoY2UsIGVuZ2luZSk7CiB9CiAKLXN0 YXRpYyBjb25zdCBzdHJ1Y3QgaW50ZWxfY29udGV4dF9vcHMgZ3VjX2NvbnRleHRfb3BzID0gewot CS5hbGxvYyA9IGd1Y19jb250ZXh0X2FsbG9jLAorc3RhdGljIGNvbnN0IHN0cnVjdCBpbnRlbF9j b250ZXh0X29wcyB2aXJ0dWFsX2d1Y19jb250ZXh0X29wcyA9IHsKKwkuYWxsb2MgPSBndWNfdmly dHVhbF9jb250ZXh0X2FsbG9jLAogCi0JLnByZV9waW4gPSBndWNfY29udGV4dF9wcmVfcGluLAot CS5waW4gPSBndWNfY29udGV4dF9waW4sCi0JLnVucGluID0gbHJjX3VucGluLAotCS5wb3N0X3Vu cGluID0gbHJjX3Bvc3RfdW5waW4sCisJLnByZV9waW4gPSBndWNfdmlydHVhbF9jb250ZXh0X3By ZV9waW4sCisJLnBpbiA9IGd1Y192aXJ0dWFsX2NvbnRleHRfcGluLAorCS51bnBpbiA9IGd1Y19j b250ZXh0X3VucGluLAorCS5wb3N0X3VucGluID0gZ3VjX2NvbnRleHRfcG9zdF91bnBpbiwKIAot CS5lbnRlciA9IGludGVsX2NvbnRleHRfZW50ZXJfZW5naW5lLAotCS5leGl0ID0gaW50ZWxfY29u dGV4dF9leGl0X2VuZ2luZSwKKwkuYmFuID0gZ3VjX2NvbnRleHRfYmFuLAogCi0JLnJlc2V0ID0g bHJjX3Jlc2V0LAotCS5kZXN0cm95ID0gbHJjX2Rlc3Ryb3ksCi19OworCS5jYW5jZWxfcmVxdWVz dCA9IGd1Y19jb250ZXh0X2NhbmNlbF9yZXF1ZXN0LAogCi1zdGF0aWMgaW50IGd1Y19yZXF1ZXN0 X2FsbG9jKHN0cnVjdCBpOTE1X3JlcXVlc3QgKnJlcXVlc3QpCi17Ci0JaW50IHJldDsKKwkuZW50 ZXIgPSBndWNfdmlydHVhbF9jb250ZXh0X2VudGVyLAorCS5leGl0ID0gZ3VjX3ZpcnR1YWxfY29u dGV4dF9leGl0LAogCi0JR0VNX0JVR19PTighaW50ZWxfY29udGV4dF9pc19waW5uZWQocmVxdWVz dC0+Y29udGV4dCkpOworCS5zY2hlZF9kaXNhYmxlID0gZ3VjX2NvbnRleHRfc2NoZWRfZGlzYWJs ZSwKIAotCS8qCi0JICogRmx1c2ggZW5vdWdoIHNwYWNlIHRvIHJlZHVjZSB0aGUgbGlrZWxpaG9v ZCBvZiB3YWl0aW5nIGFmdGVyCi0JICogd2Ugc3RhcnQgYnVpbGRpbmcgdGhlIHJlcXVlc3QgLSBp biB3aGljaCBjYXNlIHdlIHdpbGwganVzdAotCSAqIGhhdmUgdG8gcmVwZWF0IHdvcmsuCi0JICov Ci0JcmVxdWVzdC0+cmVzZXJ2ZWRfc3BhY2UgKz0gR1VDX1JFUVVFU1RfU0laRTsKKwkuZGVzdHJv eSA9IGd1Y19jb250ZXh0X2Rlc3Ryb3ksCiAKLQkvKgotCSAqIE5vdGUgdGhhdCBhZnRlciB0aGlz IHBvaW50LCB3ZSBoYXZlIGNvbW1pdHRlZCB0byB1c2luZwotCSAqIHRoaXMgcmVxdWVzdCBhcyBp dCBpcyBiZWluZyB1c2VkIHRvIGJvdGggdHJhY2sgdGhlCi0JICogc3RhdGUgb2YgZW5naW5lIGlu aXRpYWxpc2F0aW9uIGFuZCBsaXZlbmVzcyBvZiB0aGUKLQkgKiBnb2xkZW4gcmVuZGVyc3RhdGUg YWJvdmUuIFRoaW5rIHR3aWNlIGJlZm9yZSB5b3UgdHJ5Ci0JICogdG8gY2FuY2VsL3Vud2luZCB0 aGlzIHJlcXVlc3Qgbm93LgotCSAqLworCS5nZXRfc2libGluZyA9IGd1Y192aXJ0dWFsX2dldF9z aWJsaW5nLAorfTsKIAotCS8qIFVuY29uZGl0aW9uYWxseSBpbnZhbGlkYXRlIEdQVSBjYWNoZXMg YW5kIFRMQnMuICovCi0JcmV0ID0gcmVxdWVzdC0+ZW5naW5lLT5lbWl0X2ZsdXNoKHJlcXVlc3Qs IEVNSVRfSU5WQUxJREFURSk7Ci0JaWYgKHJldCkKLQkJcmV0dXJuIHJldDsKK3N0YXRpYyBib29s CitndWNfaXJxX2VuYWJsZV9icmVhZGNydW1icyhzdHJ1Y3QgaW50ZWxfYnJlYWRjcnVtYnMgKmIp Cit7CisJc3RydWN0IGludGVsX2VuZ2luZV9jcyAqc2libGluZzsKKwlpbnRlbF9lbmdpbmVfbWFz a190IHRtcCwgbWFzayA9IGItPmVuZ2luZV9tYXNrOworCWJvb2wgcmVzdWx0ID0gZmFsc2U7CiAK LQlyZXF1ZXN0LT5yZXNlcnZlZF9zcGFjZSAtPSBHVUNfUkVRVUVTVF9TSVpFOwotCXJldHVybiAw OworCWZvcl9lYWNoX2VuZ2luZV9tYXNrZWQoc2libGluZywgYi0+aXJxX2VuZ2luZS0+Z3QsIG1h c2ssIHRtcCkKKwkJcmVzdWx0IHw9IGludGVsX2VuZ2luZV9pcnFfZW5hYmxlKHNpYmxpbmcpOwor CisJcmV0dXJuIHJlc3VsdDsKIH0KIAotc3RhdGljIGlubGluZSB2b2lkIHF1ZXVlX3JlcXVlc3Qo c3RydWN0IGludGVsX2VuZ2luZV9jcyAqZW5naW5lLAotCQkJCSBzdHJ1Y3QgaTkxNV9yZXF1ZXN0 ICpycSwKLQkJCQkgaW50IHByaW8pCitzdGF0aWMgdm9pZAorZ3VjX2lycV9kaXNhYmxlX2JyZWFk Y3J1bWJzKHN0cnVjdCBpbnRlbF9icmVhZGNydW1icyAqYikKIHsKLQlHRU1fQlVHX09OKCFsaXN0 X2VtcHR5KCZycS0+c2NoZWQubGluaykpOwotCWxpc3RfYWRkX3RhaWwoJnJxLT5zY2hlZC5saW5r LAotCQkgICAgICBpOTE1X3NjaGVkX2xvb2t1cF9wcmlvbGlzdChlbmdpbmUtPnNjaGVkX2VuZ2lu ZSwgcHJpbykpOwotCXNldF9iaXQoSTkxNV9GRU5DRV9GTEFHX1BRVUVVRSwgJnJxLT5mZW5jZS5m bGFncyk7CisJc3RydWN0IGludGVsX2VuZ2luZV9jcyAqc2libGluZzsKKwlpbnRlbF9lbmdpbmVf bWFza190IHRtcCwgbWFzayA9IGItPmVuZ2luZV9tYXNrOworCisJZm9yX2VhY2hfZW5naW5lX21h c2tlZChzaWJsaW5nLCBiLT5pcnFfZW5naW5lLT5ndCwgbWFzaywgdG1wKQorCQlpbnRlbF9lbmdp bmVfaXJxX2Rpc2FibGUoc2libGluZyk7CiB9CiAKLXN0YXRpYyB2b2lkIGd1Y19zdWJtaXRfcmVx dWVzdChzdHJ1Y3QgaTkxNV9yZXF1ZXN0ICpycSkKK3N0YXRpYyB2b2lkIGd1Y19pbml0X2JyZWFk Y3J1bWJzKHN0cnVjdCBpbnRlbF9lbmdpbmVfY3MgKmVuZ2luZSkKIHsKLQlzdHJ1Y3QgaW50ZWxf ZW5naW5lX2NzICplbmdpbmUgPSBycS0+ZW5naW5lOwotCXVuc2lnbmVkIGxvbmcgZmxhZ3M7Ci0K LQkvKiBXaWxsIGJlIGNhbGxlZCBmcm9tIGlycS1jb250ZXh0IHdoZW4gdXNpbmcgZm9yZWlnbiBm ZW5jZXMuICovCi0Jc3Bpbl9sb2NrX2lycXNhdmUoJmVuZ2luZS0+c2NoZWRfZW5naW5lLT5sb2Nr LCBmbGFncyk7CisJaW50IGk7CisKKyAgICAgICAvKgorICAgICAgICAqIEluIEd1QyBzdWJtaXNz aW9uIG1vZGUgd2UgZG8gbm90IGtub3cgd2hpY2ggcGh5c2ljYWwgZW5naW5lIGEgcmVxdWVzdAor ICAgICAgICAqIHdpbGwgYmUgc2NoZWR1bGVkIG9uLCB0aGlzIGNyZWF0ZXMgYSBwcm9ibGVtIGJl Y2F1c2UgdGhlIGJyZWFkY3J1bWIKKyAgICAgICAgKiBpbnRlcnJ1cHQgaXMgcGVyIHBoeXNpY2Fs IGVuZ2luZS4gVG8gd29yayBhcm91bmQgdGhpcyB3ZSBhdHRhY2gKKyAgICAgICAgKiByZXF1ZXN0 cyBhbmQgZGlyZWN0IGFsbCBicmVhZGNydW1iIGludGVycnVwdHMgdG8gdGhlIGZpcnN0IGluc3Rh bmNlCisgICAgICAgICogb2YgYW4gZW5naW5lIHBlciBjbGFzcy4gSW4gYWRkaXRpb24gYWxsIGJy ZWFkY3J1bWIgaW50ZXJydXB0cyBhcmUKKwkqIGVuYWJsZWQgLyBkaXNhYmxlZCBhY3Jvc3MgYW4g ZW5naW5lIGNsYXNzIGluIHVuaXNvbi4KKyAgICAgICAgKi8KKwlmb3IgKGkgPSAwOyBpIDwgTUFY X0VOR0lORV9JTlNUQU5DRTsgKytpKSB7CisJCXN0cnVjdCBpbnRlbF9lbmdpbmVfY3MgKnNpYmxp bmcgPQorCQkJZW5naW5lLT5ndC0+ZW5naW5lX2NsYXNzW2VuZ2luZS0+Y2xhc3NdW2ldOworCisJ CWlmIChzaWJsaW5nKSB7CisJCQlpZiAoZW5naW5lLT5icmVhZGNydW1icyAhPSBzaWJsaW5nLT5i cmVhZGNydW1icykgeworCQkJCWludGVsX2JyZWFkY3J1bWJzX3B1dChlbmdpbmUtPmJyZWFkY3J1 bWJzKTsKKwkJCQllbmdpbmUtPmJyZWFkY3J1bWJzID0KKwkJCQkJaW50ZWxfYnJlYWRjcnVtYnNf Z2V0KHNpYmxpbmctPmJyZWFkY3J1bWJzKTsKKwkJCX0KKwkJCWJyZWFrOworCQl9CisJfQogCi0J cXVldWVfcmVxdWVzdChlbmdpbmUsIHJxLCBycV9wcmlvKHJxKSk7CisJaWYgKGVuZ2luZS0+YnJl YWRjcnVtYnMpIHsKKwkJZW5naW5lLT5icmVhZGNydW1icy0+ZW5naW5lX21hc2sgfD0gZW5naW5l LT5tYXNrOworCQllbmdpbmUtPmJyZWFkY3J1bWJzLT5pcnFfZW5hYmxlID0gZ3VjX2lycV9lbmFi bGVfYnJlYWRjcnVtYnM7CisJCWVuZ2luZS0+YnJlYWRjcnVtYnMtPmlycV9kaXNhYmxlID0gZ3Vj X2lycV9kaXNhYmxlX2JyZWFkY3J1bWJzOworCX0KK30KIAotCUdFTV9CVUdfT04oaTkxNV9zY2hl ZF9lbmdpbmVfaXNfZW1wdHkoZW5naW5lLT5zY2hlZF9lbmdpbmUpKTsKLQlHRU1fQlVHX09OKGxp c3RfZW1wdHkoJnJxLT5zY2hlZC5saW5rKSk7CitzdGF0aWMgdm9pZCBndWNfYnVtcF9pbmZsaWdo dF9yZXF1ZXN0X3ByaW8oc3RydWN0IGk5MTVfcmVxdWVzdCAqcnEsCisJCQkJCSAgIGludCBwcmlv KQoreworCXN0cnVjdCBpbnRlbF9jb250ZXh0ICpjZSA9IHJxLT5jb250ZXh0OworCXU4IG5ld19n dWNfcHJpbyA9IG1hcF9pOTE1X3ByaW9fdG9fZ3VjX3ByaW8ocHJpbyk7CisKKwkvKiBTaG9ydCBj aXJjdWl0IGZ1bmN0aW9uICovCisJaWYgKHByaW8gPCBJOTE1X1BSSU9SSVRZX05PUk1BTCB8fAor CSAgICAocnEtPmd1Y19wcmlvID09IEdVQ19QUklPX0ZJTkkpIHx8CisJICAgIChycS0+Z3VjX3By aW8gIT0gR1VDX1BSSU9fSU5JVCAmJgorCSAgICAgIW5ld19ndWNfcHJpb19oaWdoZXIocnEtPmd1 Y19wcmlvLCBuZXdfZ3VjX3ByaW8pKSkKKwkJcmV0dXJuOworCisJc3Bpbl9sb2NrKCZjZS0+Z3Vj X2FjdGl2ZS5sb2NrKTsKKwlpZiAocnEtPmd1Y19wcmlvICE9IEdVQ19QUklPX0ZJTkkpIHsKKwkJ aWYgKHJxLT5ndWNfcHJpbyAhPSBHVUNfUFJJT19JTklUKQorCQkJc3ViX2NvbnRleHRfaW5mbGln aHRfcHJpbyhjZSwgcnEtPmd1Y19wcmlvKTsKKwkJcnEtPmd1Y19wcmlvID0gbmV3X2d1Y19wcmlv OworCQlhZGRfY29udGV4dF9pbmZsaWdodF9wcmlvKGNlLCBycS0+Z3VjX3ByaW8pOworCQl1cGRh dGVfY29udGV4dF9wcmlvKGNlKTsKKwl9CisJc3Bpbl91bmxvY2soJmNlLT5ndWNfYWN0aXZlLmxv Y2spOworfQogCi0JdGFza2xldF9oaV9zY2hlZHVsZSgmZW5naW5lLT5zY2hlZF9lbmdpbmUtPnRh c2tsZXQpOworc3RhdGljIHZvaWQgZ3VjX3JldGlyZV9pbmZsaWdodF9yZXF1ZXN0X3ByaW8oc3Ry dWN0IGk5MTVfcmVxdWVzdCAqcnEpCit7CisJc3RydWN0IGludGVsX2NvbnRleHQgKmNlID0gcnEt PmNvbnRleHQ7CiAKLQlzcGluX3VubG9ja19pcnFyZXN0b3JlKCZlbmdpbmUtPnNjaGVkX2VuZ2lu ZS0+bG9jaywgZmxhZ3MpOworCXNwaW5fbG9jaygmY2UtPmd1Y19hY3RpdmUubG9jayk7CisJZ3Vj X3ByaW9fZmluaShycSwgY2UpOworCXNwaW5fdW5sb2NrKCZjZS0+Z3VjX2FjdGl2ZS5sb2NrKTsK IH0KIAogc3RhdGljIHZvaWQgc2FuaXRpemVfaHdzcChzdHJ1Y3QgaW50ZWxfZW5naW5lX2NzICpl bmdpbmUpCkBAIC01ODgsMjEgKzIzMTIsNjggQEAgc3RhdGljIGludCBndWNfcmVzdW1lKHN0cnVj dCBpbnRlbF9lbmdpbmVfY3MgKmVuZ2luZSkKIAlyZXR1cm4gMDsKIH0KIAorc3RhdGljIGJvb2wg Z3VjX3NjaGVkX2VuZ2luZV9kaXNhYmxlZChzdHJ1Y3QgaTkxNV9zY2hlZF9lbmdpbmUgKnNjaGVk X2VuZ2luZSkKK3sKKwlyZXR1cm4gIXNjaGVkX2VuZ2luZS0+dGFza2xldC5jYWxsYmFjazsKK30K Kwogc3RhdGljIHZvaWQgZ3VjX3NldF9kZWZhdWx0X3N1Ym1pc3Npb24oc3RydWN0IGludGVsX2Vu Z2luZV9jcyAqZW5naW5lKQogewogCWVuZ2luZS0+c3VibWl0X3JlcXVlc3QgPSBndWNfc3VibWl0 X3JlcXVlc3Q7CiB9CiAKK3N0YXRpYyBpbmxpbmUgdm9pZCBndWNfa2VybmVsX2NvbnRleHRfcGlu KHN0cnVjdCBpbnRlbF9ndWMgKmd1YywKKwkJCQkJICBzdHJ1Y3QgaW50ZWxfY29udGV4dCAqY2Up Cit7CisJaWYgKGNvbnRleHRfZ3VjX2lkX2ludmFsaWQoY2UpKQorCQlwaW5fZ3VjX2lkKGd1Yywg Y2UpOworCWd1Y19scmNfZGVzY19waW4oY2UsIHRydWUpOworfQorCitzdGF0aWMgaW5saW5lIHZv aWQgZ3VjX2luaXRfbHJjX21hcHBpbmcoc3RydWN0IGludGVsX2d1YyAqZ3VjKQoreworCXN0cnVj dCBpbnRlbF9ndCAqZ3QgPSBndWNfdG9fZ3QoZ3VjKTsKKwlzdHJ1Y3QgaW50ZWxfZW5naW5lX2Nz ICplbmdpbmU7CisJZW51bSBpbnRlbF9lbmdpbmVfaWQgaWQ7CisKKwkvKiBtYWtlIHN1cmUgYWxs IGRlc2NyaXB0b3JzIGFyZSBjbGVhbi4uLiAqLworCXhhX2Rlc3Ryb3koJmd1Yy0+Y29udGV4dF9s b29rdXApOworCisJLyoKKwkgKiBTb21lIGNvbnRleHRzIG1pZ2h0IGhhdmUgYmVlbiBwaW5uZWQg YmVmb3JlIHdlIGVuYWJsZWQgR3VDCisJICogc3VibWlzc2lvbiwgc28gd2UgbmVlZCB0byBhZGQg dGhlbSB0byB0aGUgR3VDIGJvb2tlZXBpbmcuCisJICogQWxzbywgYWZ0ZXIgYSByZXNldCB0aGUg b2YgR3VDIHdlIHdhbnQgdG8gbWFrZSBzdXJlIHRoYXQgdGhlCisJICogaW5mb3JtYXRpb24gc2hh cmVkIHdpdGggR3VDIGlzIHByb3Blcmx5IHJlc2V0LiBUaGUga2VybmVsIExSQ3MgYXJlCisJICog bm90IGF0dGFjaGVkIHRvIHRoZSBnZW1fY29udGV4dCwgc28gdGhleSBuZWVkIHRvIGJlIGFkZGVk IHNlcGFyYXRlbHkuCisJICoKKwkgKiBOb3RlOiB3ZSBwdXJwb3NlbHkgZG8gbm90IGNoZWNrIHRo ZSByZXR1cm4gb2YgZ3VjX2xyY19kZXNjX3BpbiwKKwkgKiBiZWNhdXNlIHRoYXQgZnVuY3Rpb24g Y2FuIG9ubHkgZmFpbCBpZiBhIHJlc2V0IGlzIGp1c3Qgc3RhcnRpbmcuIFRoaXMKKwkgKiBpcyBh dCB0aGUgZW5kIG9mIHJlc2V0IHNvIHByZXN1bWFibHkgYW5vdGhlciByZXNldCBpc24ndCBoYXBw ZW5pbmcKKwkgKiBhbmQgZXZlbiBpdCBkaWQgdGhpcyBjb2RlIHdvdWxkIGJlIHJ1biBhZ2Fpbi4K KwkgKi8KKworCWZvcl9lYWNoX2VuZ2luZShlbmdpbmUsIGd0LCBpZCkKKwkJaWYgKGVuZ2luZS0+ a2VybmVsX2NvbnRleHQpCisJCQlndWNfa2VybmVsX2NvbnRleHRfcGluKGd1YywgZW5naW5lLT5r ZXJuZWxfY29udGV4dCk7Cit9CisKIHN0YXRpYyB2b2lkIGd1Y19yZWxlYXNlKHN0cnVjdCBpbnRl bF9lbmdpbmVfY3MgKmVuZ2luZSkKIHsKIAllbmdpbmUtPnNhbml0aXplID0gTlVMTDsgLyogbm8g bG9uZ2VyIGluIGNvbnRyb2wsIG5vdGhpbmcgdG8gc2FuaXRpemUgKi8KIAotCXRhc2tsZXRfa2ls bCgmZW5naW5lLT5zY2hlZF9lbmdpbmUtPnRhc2tsZXQpOwotCiAJaW50ZWxfZW5naW5lX2NsZWFu dXBfY29tbW9uKGVuZ2luZSk7CiAJbHJjX2Zpbmlfd2FfY3R4KGVuZ2luZSk7CiB9CiAKK3N0YXRp YyB2b2lkIHZpcnR1YWxfZ3VjX2J1bXBfc2VyaWFsKHN0cnVjdCBpbnRlbF9lbmdpbmVfY3MgKmVu Z2luZSkKK3sKKwlzdHJ1Y3QgaW50ZWxfZW5naW5lX2NzICplOworCWludGVsX2VuZ2luZV9tYXNr X3QgdG1wLCBtYXNrID0gZW5naW5lLT5tYXNrOworCisJZm9yX2VhY2hfZW5naW5lX21hc2tlZChl LCBlbmdpbmUtPmd0LCBtYXNrLCB0bXApCisJCWUtPnNlcmlhbCsrOworfQorCiBzdGF0aWMgdm9p ZCBndWNfZGVmYXVsdF92ZnVuY3Moc3RydWN0IGludGVsX2VuZ2luZV9jcyAqZW5naW5lKQogewog CS8qIERlZmF1bHQgdmZ1bmNzIHdoaWNoIGNhbiBiZSBvdmVycmlkZGVuIGJ5IGVhY2ggZW5naW5l LiAqLwpAQCAtNjExLDEzICsyMzgyLDE1IEBAIHN0YXRpYyB2b2lkIGd1Y19kZWZhdWx0X3ZmdW5j cyhzdHJ1Y3QgaW50ZWxfZW5naW5lX2NzICplbmdpbmUpCiAKIAllbmdpbmUtPmNvcHMgPSAmZ3Vj X2NvbnRleHRfb3BzOwogCWVuZ2luZS0+cmVxdWVzdF9hbGxvYyA9IGd1Y19yZXF1ZXN0X2FsbG9j OworCWVuZ2luZS0+YWRkX2FjdGl2ZV9yZXF1ZXN0ID0gYWRkX3RvX2NvbnRleHQ7CisJZW5naW5l LT5yZW1vdmVfYWN0aXZlX3JlcXVlc3QgPSByZW1vdmVfZnJvbV9jb250ZXh0OwogCiAJZW5naW5l LT5zY2hlZF9lbmdpbmUtPnNjaGVkdWxlID0gaTkxNV9zY2hlZHVsZTsKIAotCWVuZ2luZS0+cmVz ZXQucHJlcGFyZSA9IGd1Y19yZXNldF9wcmVwYXJlOwotCWVuZ2luZS0+cmVzZXQucmV3aW5kID0g Z3VjX3Jlc2V0X3Jld2luZDsKLQllbmdpbmUtPnJlc2V0LmNhbmNlbCA9IGd1Y19yZXNldF9jYW5j ZWw7Ci0JZW5naW5lLT5yZXNldC5maW5pc2ggPSBndWNfcmVzZXRfZmluaXNoOworCWVuZ2luZS0+ cmVzZXQucHJlcGFyZSA9IGd1Y19yZXNldF9ub3A7CisJZW5naW5lLT5yZXNldC5yZXdpbmQgPSBn dWNfcmV3aW5kX25vcDsKKwllbmdpbmUtPnJlc2V0LmNhbmNlbCA9IGd1Y19yZXNldF9ub3A7CisJ ZW5naW5lLT5yZXNldC5maW5pc2ggPSBndWNfcmVzZXRfbm9wOwogCiAJZW5naW5lLT5lbWl0X2Zs dXNoID0gZ2VuOF9lbWl0X2ZsdXNoX3hjczsKIAllbmdpbmUtPmVtaXRfaW5pdF9icmVhZGNydW1i ID0gZ2VuOF9lbWl0X2luaXRfYnJlYWRjcnVtYjsKQEAgLTYyOSwxMyArMjQwMiwxMyBAQCBzdGF0 aWMgdm9pZCBndWNfZGVmYXVsdF92ZnVuY3Moc3RydWN0IGludGVsX2VuZ2luZV9jcyAqZW5naW5l KQogCWVuZ2luZS0+c2V0X2RlZmF1bHRfc3VibWlzc2lvbiA9IGd1Y19zZXRfZGVmYXVsdF9zdWJt aXNzaW9uOwogCiAJZW5naW5lLT5mbGFncyB8PSBJOTE1X0VOR0lORV9IQVNfUFJFRU1QVElPTjsK KwllbmdpbmUtPmZsYWdzIHw9IEk5MTVfRU5HSU5FX0hBU19USU1FU0xJQ0VTOwogCiAJLyoKIAkg KiBUT0RPOiBHdUMgc3VwcG9ydHMgdGltZXNsaWNpbmcgYW5kIHNlbWFwaG9yZXMgYXMgd2VsbCwg YnV0IHRoZXkncmUKIAkgKiBoYW5kbGVkIGJ5IHRoZSBmaXJtd2FyZSBzbyBzb21lIG1pbm9yIHR3 ZWFrcyBhcmUgcmVxdWlyZWQgYmVmb3JlCiAJICogZW5hYmxpbmcuCiAJICoKLQkgKiBlbmdpbmUt PmZsYWdzIHw9IEk5MTVfRU5HSU5FX0hBU19USU1FU0xJQ0VTOwogCSAqIGVuZ2luZS0+ZmxhZ3Mg fD0gSTkxNV9FTkdJTkVfSEFTX1NFTUFQSE9SRVM7CiAJICovCiAKQEAgLTY2Niw5ICsyNDM5LDIx IEBAIHN0YXRpYyBpbmxpbmUgdm9pZCBndWNfZGVmYXVsdF9pcnFzKHN0cnVjdCBpbnRlbF9lbmdp bmVfY3MgKmVuZ2luZSkKIAlpbnRlbF9lbmdpbmVfc2V0X2lycV9oYW5kbGVyKGVuZ2luZSwgY3Nf aXJxX2hhbmRsZXIpOwogfQogCitzdGF0aWMgdm9pZCBndWNfc2NoZWRfZW5naW5lX2Rlc3Ryb3ko c3RydWN0IGtyZWYgKmtyZWYpCit7CisJc3RydWN0IGk5MTVfc2NoZWRfZW5naW5lICpzY2hlZF9l bmdpbmUgPQorCQljb250YWluZXJfb2Yoa3JlZiwgdHlwZW9mKCpzY2hlZF9lbmdpbmUpLCByZWYp OworCXN0cnVjdCBpbnRlbF9ndWMgKmd1YyA9IHNjaGVkX2VuZ2luZS0+cHJpdmF0ZV9kYXRhOwor CisJZ3VjLT5zY2hlZF9lbmdpbmUgPSBOVUxMOworCXRhc2tsZXRfa2lsbCgmc2NoZWRfZW5naW5l LT50YXNrbGV0KTsgLyogZmx1c2ggdGhlIGNhbGxiYWNrICovCisJa2ZyZWUoc2NoZWRfZW5naW5l KTsKK30KKwogaW50IGludGVsX2d1Y19zdWJtaXNzaW9uX3NldHVwKHN0cnVjdCBpbnRlbF9lbmdp bmVfY3MgKmVuZ2luZSkKIHsKIAlzdHJ1Y3QgZHJtX2k5MTVfcHJpdmF0ZSAqaTkxNSA9IGVuZ2lu ZS0+aTkxNTsKKwlzdHJ1Y3QgaW50ZWxfZ3VjICpndWMgPSAmZW5naW5lLT5ndC0+dWMuZ3VjOwog CiAJLyoKIAkgKiBUaGUgc2V0dXAgcmVsaWVzIG9uIHNldmVyYWwgYXNzdW1wdGlvbnMgKGUuZy4g aXJxcyBhbHdheXMgZW5hYmxlZCkKQEAgLTY3NiwxMCArMjQ2MSwyOCBAQCBpbnQgaW50ZWxfZ3Vj X3N1Ym1pc3Npb25fc2V0dXAoc3RydWN0IGludGVsX2VuZ2luZV9jcyAqZW5naW5lKQogCSAqLwog CUdFTV9CVUdfT04oR1JBUEhJQ1NfVkVSKGk5MTUpIDwgMTEpOwogCi0JdGFza2xldF9zZXR1cCgm ZW5naW5lLT5zY2hlZF9lbmdpbmUtPnRhc2tsZXQsIGd1Y19zdWJtaXNzaW9uX3Rhc2tsZXQpOwor CWlmICghZ3VjLT5zY2hlZF9lbmdpbmUpIHsKKwkJZ3VjLT5zY2hlZF9lbmdpbmUgPSBpOTE1X3Nj aGVkX2VuZ2luZV9jcmVhdGUoRU5HSU5FX1ZJUlRVQUwpOworCQlpZiAoIWd1Yy0+c2NoZWRfZW5n aW5lKQorCQkJcmV0dXJuIC1FTk9NRU07CisKKwkJZ3VjLT5zY2hlZF9lbmdpbmUtPnNjaGVkdWxl ID0gaTkxNV9zY2hlZHVsZTsKKwkJZ3VjLT5zY2hlZF9lbmdpbmUtPmRpc2FibGVkID0gZ3VjX3Nj aGVkX2VuZ2luZV9kaXNhYmxlZDsKKwkJZ3VjLT5zY2hlZF9lbmdpbmUtPnByaXZhdGVfZGF0YSA9 IGd1YzsKKwkJZ3VjLT5zY2hlZF9lbmdpbmUtPmRlc3Ryb3kgPSBndWNfc2NoZWRfZW5naW5lX2Rl c3Ryb3k7CisJCWd1Yy0+c2NoZWRfZW5naW5lLT5idW1wX2luZmxpZ2h0X3JlcXVlc3RfcHJpbyA9 CisJCQlndWNfYnVtcF9pbmZsaWdodF9yZXF1ZXN0X3ByaW87CisJCWd1Yy0+c2NoZWRfZW5naW5l LT5yZXRpcmVfaW5mbGlnaHRfcmVxdWVzdF9wcmlvID0KKwkJCWd1Y19yZXRpcmVfaW5mbGlnaHRf cmVxdWVzdF9wcmlvOworCQl0YXNrbGV0X3NldHVwKCZndWMtPnNjaGVkX2VuZ2luZS0+dGFza2xl dCwKKwkJCSAgICAgIGd1Y19zdWJtaXNzaW9uX3Rhc2tsZXQpOworCX0KKwlpOTE1X3NjaGVkX2Vu Z2luZV9wdXQoZW5naW5lLT5zY2hlZF9lbmdpbmUpOworCWVuZ2luZS0+c2NoZWRfZW5naW5lID0g aTkxNV9zY2hlZF9lbmdpbmVfZ2V0KGd1Yy0+c2NoZWRfZW5naW5lKTsKIAogCWd1Y19kZWZhdWx0 X3ZmdW5jcyhlbmdpbmUpOwogCWd1Y19kZWZhdWx0X2lycXMoZW5naW5lKTsKKwlndWNfaW5pdF9i cmVhZGNydW1icyhlbmdpbmUpOwogCiAJaWYgKGVuZ2luZS0+Y2xhc3MgPT0gUkVOREVSX0NMQVNT KQogCQlyY3Nfc3VibWlzc2lvbl9vdmVycmlkZShlbmdpbmUpOwpAQCAtNjk1LDcgKzI0OTgsNyBA QCBpbnQgaW50ZWxfZ3VjX3N1Ym1pc3Npb25fc2V0dXAoc3RydWN0IGludGVsX2VuZ2luZV9jcyAq ZW5naW5lKQogCiB2b2lkIGludGVsX2d1Y19zdWJtaXNzaW9uX2VuYWJsZShzdHJ1Y3QgaW50ZWxf Z3VjICpndWMpCiB7Ci0JZ3VjX3N0YWdlX2Rlc2NfaW5pdChndWMpOworCWd1Y19pbml0X2xyY19t YXBwaW5nKGd1Yyk7CiB9CiAKIHZvaWQgaW50ZWxfZ3VjX3N1Ym1pc3Npb25fZGlzYWJsZShzdHJ1 Y3QgaW50ZWxfZ3VjICpndWMpCkBAIC03MDUsOCArMjUwOCwxMyBAQCB2b2lkIGludGVsX2d1Y19z dWJtaXNzaW9uX2Rpc2FibGUoc3RydWN0IGludGVsX2d1YyAqZ3VjKQogCUdFTV9CVUdfT04oZ3Qt PmF3YWtlKTsgLyogR1Qgc2hvdWxkIGJlIHBhcmtlZCBmaXJzdCAqLwogCiAJLyogTm90ZTogQnkg dGhlIHRpbWUgd2UncmUgaGVyZSwgR3VDIG1heSBoYXZlIGFscmVhZHkgYmVlbiByZXNldCAqLwor fQogCi0JZ3VjX3N0YWdlX2Rlc2NfZmluaShndWMpOworc3RhdGljIGJvb2wgX19ndWNfc3VibWlz c2lvbl9zdXBwb3J0ZWQoc3RydWN0IGludGVsX2d1YyAqZ3VjKQoreworCS8qIEd1QyBzdWJtaXNz aW9uIGlzIHVuYXZhaWxhYmxlIGZvciBwcmUtR2VuMTEgKi8KKwlyZXR1cm4gaW50ZWxfZ3VjX2lz X3N1cHBvcnRlZChndWMpICYmCisJICAgICAgIEdSQVBISUNTX1ZFUihndWNfdG9fZ3QoZ3VjKS0+ aTkxNSkgPj0gMTE7CiB9CiAKIHN0YXRpYyBib29sIF9fZ3VjX3N1Ym1pc3Npb25fc2VsZWN0ZWQo c3RydWN0IGludGVsX2d1YyAqZ3VjKQpAQCAtNzIxLDUgKzI1MjksNDgzIEBAIHN0YXRpYyBib29s IF9fZ3VjX3N1Ym1pc3Npb25fc2VsZWN0ZWQoc3RydWN0IGludGVsX2d1YyAqZ3VjKQogCiB2b2lk IGludGVsX2d1Y19zdWJtaXNzaW9uX2luaXRfZWFybHkoc3RydWN0IGludGVsX2d1YyAqZ3VjKQog eworCWd1Yy0+c3VibWlzc2lvbl9zdXBwb3J0ZWQgPSBfX2d1Y19zdWJtaXNzaW9uX3N1cHBvcnRl ZChndWMpOwogCWd1Yy0+c3VibWlzc2lvbl9zZWxlY3RlZCA9IF9fZ3VjX3N1Ym1pc3Npb25fc2Vs ZWN0ZWQoZ3VjKTsKIH0KKworc3RhdGljIGlubGluZSBzdHJ1Y3QgaW50ZWxfY29udGV4dCAqCitn MmhfY29udGV4dF9sb29rdXAoc3RydWN0IGludGVsX2d1YyAqZ3VjLCB1MzIgZGVzY19pZHgpCit7 CisJc3RydWN0IGludGVsX2NvbnRleHQgKmNlOworCisJaWYgKHVubGlrZWx5KGRlc2NfaWR4ID49 IEdVQ19NQVhfTFJDX0RFU0NSSVBUT1JTKSkgeworCQlkcm1fZXJyKCZndWNfdG9fZ3QoZ3VjKS0+ aTkxNS0+ZHJtLAorCQkJIkludmFsaWQgZGVzY19pZHggJXUiLCBkZXNjX2lkeCk7CisJCXJldHVy biBOVUxMOworCX0KKworCWNlID0gX19nZXRfY29udGV4dChndWMsIGRlc2NfaWR4KTsKKwlpZiAo dW5saWtlbHkoIWNlKSkgeworCQlkcm1fZXJyKCZndWNfdG9fZ3QoZ3VjKS0+aTkxNS0+ZHJtLAor CQkJIkNvbnRleHQgaXMgTlVMTCwgZGVzY19pZHggJXUiLCBkZXNjX2lkeCk7CisJCXJldHVybiBO VUxMOworCX0KKworCXJldHVybiBjZTsKK30KKworc3RhdGljIHZvaWQgZGVjcl9vdXRzdGFuZGlu Z19zdWJtaXNzaW9uX2cyaChzdHJ1Y3QgaW50ZWxfZ3VjICpndWMpCit7CisJaWYgKGF0b21pY19k ZWNfYW5kX3Rlc3QoJmd1Yy0+b3V0c3RhbmRpbmdfc3VibWlzc2lvbl9nMmgpKQorCQl3YWtlX3Vw X2FsbCgmZ3VjLT5jdC53cSk7Cit9CisKK2ludCBpbnRlbF9ndWNfZGVyZWdpc3Rlcl9kb25lX3By b2Nlc3NfbXNnKHN0cnVjdCBpbnRlbF9ndWMgKmd1YywKKwkJCQkJICBjb25zdCB1MzIgKm1zZywK KwkJCQkJICB1MzIgbGVuKQoreworCXN0cnVjdCBpbnRlbF9jb250ZXh0ICpjZTsKKwl1MzIgZGVz Y19pZHggPSBtc2dbMF07CisKKwlpZiAodW5saWtlbHkobGVuIDwgMSkpIHsKKwkJZHJtX2Vycigm Z3VjX3RvX2d0KGd1YyktPmk5MTUtPmRybSwgIkludmFsaWQgbGVuZ3RoICV1IiwgbGVuKTsKKwkJ cmV0dXJuIC1FUFJPVE87CisJfQorCisJY2UgPSBnMmhfY29udGV4dF9sb29rdXAoZ3VjLCBkZXNj X2lkeCk7CisJaWYgKHVubGlrZWx5KCFjZSkpCisJCXJldHVybiAtRVBST1RPOworCisJdHJhY2Vf aW50ZWxfY29udGV4dF9kZXJlZ2lzdGVyX2RvbmUoY2UpOworCisJaWYgKGNvbnRleHRfd2FpdF9m b3JfZGVyZWdpc3Rlcl90b19yZWdpc3RlcihjZSkpIHsKKwkJc3RydWN0IGludGVsX3J1bnRpbWVf cG0gKnJ1bnRpbWVfcG0gPQorCQkJJmNlLT5lbmdpbmUtPmd0LT5pOTE1LT5ydW50aW1lX3BtOwor CQlpbnRlbF93YWtlcmVmX3Qgd2FrZXJlZjsKKworCQkvKgorCQkgKiBQcmV2aW91cyBvd25lciBv ZiB0aGlzIGd1Y19pZCBoYXMgYmVlbiBkZXJlZ2lzdGVyZWQsIG5vdyBzYWZlCisJCSAqIHJlZ2lz dGVyIHRoaXMgY29udGV4dC4KKwkJICovCisJCXdpdGhfaW50ZWxfcnVudGltZV9wbShydW50aW1l X3BtLCB3YWtlcmVmKQorCQkJcmVnaXN0ZXJfY29udGV4dChjZSwgdHJ1ZSk7CisJCWd1Y19zaWdu YWxfY29udGV4dF9mZW5jZShjZSk7CisJCWludGVsX2NvbnRleHRfcHV0KGNlKTsKKwl9IGVsc2Ug aWYgKGNvbnRleHRfZGVzdHJveWVkKGNlKSkgeworCQkvKiBDb250ZXh0IGhhcyBiZWVuIGRlc3Ry b3llZCAqLworCQlyZWxlYXNlX2d1Y19pZChndWMsIGNlKTsKKwkJX19ndWNfY29udGV4dF9kZXN0 cm95KGNlKTsKKwl9CisKKwlkZWNyX291dHN0YW5kaW5nX3N1Ym1pc3Npb25fZzJoKGd1Yyk7CisK KwlyZXR1cm4gMDsKK30KKworaW50IGludGVsX2d1Y19zY2hlZF9kb25lX3Byb2Nlc3NfbXNnKHN0 cnVjdCBpbnRlbF9ndWMgKmd1YywKKwkJCQkgICAgIGNvbnN0IHUzMiAqbXNnLAorCQkJCSAgICAg dTMyIGxlbikKK3sKKwlzdHJ1Y3QgaW50ZWxfY29udGV4dCAqY2U7CisJdW5zaWduZWQgbG9uZyBm bGFnczsKKwl1MzIgZGVzY19pZHggPSBtc2dbMF07CisKKwlpZiAodW5saWtlbHkobGVuIDwgMikp IHsKKwkJZHJtX2VycigmZ3VjX3RvX2d0KGd1YyktPmk5MTUtPmRybSwgIkludmFsaWQgbGVuZ3Ro ICV1IiwgbGVuKTsKKwkJcmV0dXJuIC1FUFJPVE87CisJfQorCisJY2UgPSBnMmhfY29udGV4dF9s b29rdXAoZ3VjLCBkZXNjX2lkeCk7CisJaWYgKHVubGlrZWx5KCFjZSkpCisJCXJldHVybiAtRVBS T1RPOworCisJaWYgKHVubGlrZWx5KGNvbnRleHRfZGVzdHJveWVkKGNlKSB8fAorCQkgICAgICgh Y29udGV4dF9wZW5kaW5nX2VuYWJsZShjZSkgJiYKKwkJICAgICAhY29udGV4dF9wZW5kaW5nX2Rp c2FibGUoY2UpKSkpIHsKKwkJZHJtX2VycigmZ3VjX3RvX2d0KGd1YyktPmk5MTUtPmRybSwKKwkJ CSJCYWQgY29udGV4dCBzY2hlZF9zdGF0ZSAweCV4LCAweCV4LCBkZXNjX2lkeCAldSIsCisJCQlh dG9taWNfcmVhZCgmY2UtPmd1Y19zY2hlZF9zdGF0ZV9ub19sb2NrKSwKKwkJCWNlLT5ndWNfc3Rh dGUuc2NoZWRfc3RhdGUsIGRlc2NfaWR4KTsKKwkJcmV0dXJuIC1FUFJPVE87CisJfQorCisJdHJh Y2VfaW50ZWxfY29udGV4dF9zY2hlZF9kb25lKGNlKTsKKworCWlmIChjb250ZXh0X3BlbmRpbmdf ZW5hYmxlKGNlKSkgeworCQljbHJfY29udGV4dF9wZW5kaW5nX2VuYWJsZShjZSk7CisJfSBlbHNl IGlmIChjb250ZXh0X3BlbmRpbmdfZGlzYWJsZShjZSkpIHsKKwkJYm9vbCBiYW5uZWQ7CisKKwkJ LyoKKwkJICogVW5waW4gbXVzdCBiZSBkb25lIGJlZm9yZSBfX2d1Y19zaWduYWxfY29udGV4dF9m ZW5jZSwKKwkJICogb3RoZXJ3aXNlIGEgcmFjZSBleGlzdHMgYmV0d2VlbiB0aGUgcmVxdWVzdHMg Z2V0dGluZworCQkgKiBzdWJtaXR0ZWQgKyByZXRpcmVkIGJlZm9yZSB0aGlzIHVucGluIGNvbXBs ZXRlcyByZXN1bHRpbmcgaW4KKwkJICogdGhlIHBpbl9jb3VudCBnb2luZyB0byB6ZXJvIGFuZCB0 aGUgY29udGV4dCBzdGlsbCBiZWluZworCQkgKiBlbmFibGVkLgorCQkgKi8KKwkJaW50ZWxfY29u dGV4dF9zY2hlZF9kaXNhYmxlX3VucGluKGNlKTsKKworCQlzcGluX2xvY2tfaXJxc2F2ZSgmY2Ut Pmd1Y19zdGF0ZS5sb2NrLCBmbGFncyk7CisJCWJhbm5lZCA9IGNvbnRleHRfYmFubmVkKGNlKTsK KwkJY2xyX2NvbnRleHRfYmFubmVkKGNlKTsKKwkJY2xyX2NvbnRleHRfcGVuZGluZ19kaXNhYmxl KGNlKTsKKwkJX19ndWNfc2lnbmFsX2NvbnRleHRfZmVuY2UoY2UpOworCQlndWNfYmxvY2tlZF9m ZW5jZV9jb21wbGV0ZShjZSk7CisJCXNwaW5fdW5sb2NrX2lycXJlc3RvcmUoJmNlLT5ndWNfc3Rh dGUubG9jaywgZmxhZ3MpOworCisJCWlmIChiYW5uZWQpIHsKKwkJCWd1Y19jYW5jZWxfY29udGV4 dF9yZXF1ZXN0cyhjZSk7CisJCQlpbnRlbF9lbmdpbmVfc2lnbmFsX2JyZWFkY3J1bWJzKGNlLT5l bmdpbmUpOworCQl9CisJfQorCisJZGVjcl9vdXRzdGFuZGluZ19zdWJtaXNzaW9uX2cyaChndWMp OworCWludGVsX2NvbnRleHRfcHV0KGNlKTsKKworCXJldHVybiAwOworfQorCitzdGF0aWMgdm9p ZCBjYXB0dXJlX2Vycm9yX3N0YXRlKHN0cnVjdCBpbnRlbF9ndWMgKmd1YywKKwkJCQlzdHJ1Y3Qg aW50ZWxfY29udGV4dCAqY2UpCit7CisJc3RydWN0IGludGVsX2d0ICpndCA9IGd1Y190b19ndChn dWMpOworCXN0cnVjdCBkcm1faTkxNV9wcml2YXRlICppOTE1ID0gZ3QtPmk5MTU7CisJc3RydWN0 IGludGVsX2VuZ2luZV9jcyAqZW5naW5lID0gX19jb250ZXh0X3RvX3BoeXNpY2FsX2VuZ2luZShj ZSk7CisJaW50ZWxfd2FrZXJlZl90IHdha2VyZWY7CisKKwlpbnRlbF9lbmdpbmVfc2V0X2h1bmdf Y29udGV4dChlbmdpbmUsIGNlKTsKKwl3aXRoX2ludGVsX3J1bnRpbWVfcG0oJmk5MTUtPnJ1bnRp bWVfcG0sIHdha2VyZWYpCisJCWk5MTVfY2FwdHVyZV9lcnJvcl9zdGF0ZShndCwgZW5naW5lLT5t YXNrKTsKKwlhdG9taWNfaW5jKCZpOTE1LT5ncHVfZXJyb3IucmVzZXRfZW5naW5lX2NvdW50W2Vu Z2luZS0+dWFiaV9jbGFzc10pOworfQorCitzdGF0aWMgdm9pZCBndWNfY29udGV4dF9yZXBsYXko c3RydWN0IGludGVsX2NvbnRleHQgKmNlKQoreworCXN0cnVjdCBpOTE1X3NjaGVkX2VuZ2luZSAq c2NoZWRfZW5naW5lID0gY2UtPmVuZ2luZS0+c2NoZWRfZW5naW5lOworCisJX19ndWNfcmVzZXRf Y29udGV4dChjZSwgdHJ1ZSk7CisJdGFza2xldF9oaV9zY2hlZHVsZSgmc2NoZWRfZW5naW5lLT50 YXNrbGV0KTsKK30KKworc3RhdGljIHZvaWQgZ3VjX2hhbmRsZV9jb250ZXh0X3Jlc2V0KHN0cnVj dCBpbnRlbF9ndWMgKmd1YywKKwkJCQkgICAgIHN0cnVjdCBpbnRlbF9jb250ZXh0ICpjZSkKK3sK Kwl0cmFjZV9pbnRlbF9jb250ZXh0X3Jlc2V0KGNlKTsKKworCWlmIChsaWtlbHkoIWludGVsX2Nv bnRleHRfaXNfYmFubmVkKGNlKSkpIHsKKwkJY2FwdHVyZV9lcnJvcl9zdGF0ZShndWMsIGNlKTsK KwkJZ3VjX2NvbnRleHRfcmVwbGF5KGNlKTsKKwl9Cit9CisKK2ludCBpbnRlbF9ndWNfY29udGV4 dF9yZXNldF9wcm9jZXNzX21zZyhzdHJ1Y3QgaW50ZWxfZ3VjICpndWMsCisJCQkJCWNvbnN0IHUz MiAqbXNnLCB1MzIgbGVuKQoreworCXN0cnVjdCBpbnRlbF9jb250ZXh0ICpjZTsKKwlpbnQgZGVz Y19pZHg7CisKKwlpZiAodW5saWtlbHkobGVuICE9IDEpKSB7CisJCWRybV9lcnIoJmd1Y190b19n dChndWMpLT5pOTE1LT5kcm0sICJJbnZhbGlkIGxlbmd0aCAldSIsIGxlbik7CisJCXJldHVybiAt RVBST1RPOworCX0KKworCWRlc2NfaWR4ID0gbXNnWzBdOworCWNlID0gZzJoX2NvbnRleHRfbG9v a3VwKGd1YywgZGVzY19pZHgpOworCWlmICh1bmxpa2VseSghY2UpKQorCQlyZXR1cm4gLUVQUk9U TzsKKworCWd1Y19oYW5kbGVfY29udGV4dF9yZXNldChndWMsIGNlKTsKKworCXJldHVybiAwOwor fQorCitzdGF0aWMgc3RydWN0IGludGVsX2VuZ2luZV9jcyAqCitndWNfbG9va3VwX2VuZ2luZShz dHJ1Y3QgaW50ZWxfZ3VjICpndWMsIHU4IGd1Y19jbGFzcywgdTggaW5zdGFuY2UpCit7CisJc3Ry dWN0IGludGVsX2d0ICpndCA9IGd1Y190b19ndChndWMpOworCXU4IGVuZ2luZV9jbGFzcyA9IGd1 Y19jbGFzc190b19lbmdpbmVfY2xhc3MoZ3VjX2NsYXNzKTsKKworCS8qIENsYXNzIGluZGV4IGlz IGNoZWNrZWQgaW4gY2xhc3MgY29udmVydGVyICovCisJR0VNX0JVR19PTihpbnN0YW5jZSA+IE1B WF9FTkdJTkVfSU5TVEFOQ0UpOworCisJcmV0dXJuIGd0LT5lbmdpbmVfY2xhc3NbZW5naW5lX2Ns YXNzXVtpbnN0YW5jZV07Cit9CisKK2ludCBpbnRlbF9ndWNfZW5naW5lX2ZhaWx1cmVfcHJvY2Vz c19tc2coc3RydWN0IGludGVsX2d1YyAqZ3VjLAorCQkJCQkgY29uc3QgdTMyICptc2csIHUzMiBs ZW4pCit7CisJc3RydWN0IGludGVsX2VuZ2luZV9jcyAqZW5naW5lOworCXU4IGd1Y19jbGFzcywg aW5zdGFuY2U7CisJdTMyIHJlYXNvbjsKKworCWlmICh1bmxpa2VseShsZW4gIT0gMykpIHsKKwkJ ZHJtX2VycigmZ3VjX3RvX2d0KGd1YyktPmk5MTUtPmRybSwgIkludmFsaWQgbGVuZ3RoICV1Iiwg bGVuKTsKKwkJcmV0dXJuIC1FUFJPVE87CisJfQorCisJZ3VjX2NsYXNzID0gbXNnWzBdOworCWlu c3RhbmNlID0gbXNnWzFdOworCXJlYXNvbiA9IG1zZ1syXTsKKworCWVuZ2luZSA9IGd1Y19sb29r dXBfZW5naW5lKGd1YywgZ3VjX2NsYXNzLCBpbnN0YW5jZSk7CisJaWYgKHVubGlrZWx5KCFlbmdp bmUpKSB7CisJCWRybV9lcnIoJmd1Y190b19ndChndWMpLT5pOTE1LT5kcm0sCisJCQkiSW52YWxp ZCBlbmdpbmUgJWQ6JWQiLCBndWNfY2xhc3MsIGluc3RhbmNlKTsKKwkJcmV0dXJuIC1FUFJPVE87 CisJfQorCisJaW50ZWxfZ3RfaGFuZGxlX2Vycm9yKGd1Y190b19ndChndWMpLCBlbmdpbmUtPm1h c2ssCisJCQkgICAgICBJOTE1X0VSUk9SX0NBUFRVUkUsCisJCQkgICAgICAiR3VDIGZhaWxlZCB0 byByZXNldCAlcyAocmVhc29uPTB4JTA4eClcbiIsCisJCQkgICAgICBlbmdpbmUtPm5hbWUsIHJl YXNvbik7CisKKwlyZXR1cm4gMDsKK30KKwordm9pZCBpbnRlbF9ndWNfZmluZF9odW5nX2NvbnRl eHQoc3RydWN0IGludGVsX2VuZ2luZV9jcyAqZW5naW5lKQoreworCXN0cnVjdCBpbnRlbF9ndWMg Kmd1YyA9ICZlbmdpbmUtPmd0LT51Yy5ndWM7CisJc3RydWN0IGludGVsX2NvbnRleHQgKmNlOwor CXN0cnVjdCBpOTE1X3JlcXVlc3QgKnJxOworCXVuc2lnbmVkIGxvbmcgaW5kZXg7CisKKwkvKiBS ZXNldCBjYWxsZWQgZHVyaW5nIGRyaXZlciBsb2FkPyBHdUMgbm90IHlldCBpbml0aWFsaXNlZCEg Ki8KKwlpZiAodW5saWtlbHkoIWd1Y19zdWJtaXNzaW9uX2luaXRpYWxpemVkKGd1YykpKQorCQly ZXR1cm47CisKKwl4YV9mb3JfZWFjaCgmZ3VjLT5jb250ZXh0X2xvb2t1cCwgaW5kZXgsIGNlKSB7 CisJCWlmICghaW50ZWxfY29udGV4dF9pc19waW5uZWQoY2UpKQorCQkJY29udGludWU7CisKKwkJ aWYgKGludGVsX2VuZ2luZV9pc192aXJ0dWFsKGNlLT5lbmdpbmUpKSB7CisJCQlpZiAoIShjZS0+ ZW5naW5lLT5tYXNrICYgZW5naW5lLT5tYXNrKSkKKwkJCQljb250aW51ZTsKKwkJfSBlbHNlIHsK KwkJCWlmIChjZS0+ZW5naW5lICE9IGVuZ2luZSkKKwkJCQljb250aW51ZTsKKwkJfQorCisJCWxp c3RfZm9yX2VhY2hfZW50cnkocnEsICZjZS0+Z3VjX2FjdGl2ZS5yZXF1ZXN0cywgc2NoZWQubGlu aykgeworCQkJaWYgKGk5MTVfdGVzdF9yZXF1ZXN0X3N0YXRlKHJxKSAhPSBJOTE1X1JFUVVFU1Rf QUNUSVZFKQorCQkJCWNvbnRpbnVlOworCisJCQlpbnRlbF9lbmdpbmVfc2V0X2h1bmdfY29udGV4 dChlbmdpbmUsIGNlKTsKKworCQkJLyogQ2FuIG9ubHkgY29wZSB3aXRoIG9uZSBoYW5nIGF0IGEg dGltZS4uLiAqLworCQkJcmV0dXJuOworCQl9CisJfQorfQorCit2b2lkIGludGVsX2d1Y19kdW1w X2FjdGl2ZV9yZXF1ZXN0cyhzdHJ1Y3QgaW50ZWxfZW5naW5lX2NzICplbmdpbmUsCisJCQkJICAg IHN0cnVjdCBpOTE1X3JlcXVlc3QgKmh1bmdfcnEsCisJCQkJICAgIHN0cnVjdCBkcm1fcHJpbnRl ciAqbSkKK3sKKwlzdHJ1Y3QgaW50ZWxfZ3VjICpndWMgPSAmZW5naW5lLT5ndC0+dWMuZ3VjOwor CXN0cnVjdCBpbnRlbF9jb250ZXh0ICpjZTsKKwl1bnNpZ25lZCBsb25nIGluZGV4OworCXVuc2ln bmVkIGxvbmcgZmxhZ3M7CisKKwkvKiBSZXNldCBjYWxsZWQgZHVyaW5nIGRyaXZlciBsb2FkPyBH dUMgbm90IHlldCBpbml0aWFsaXNlZCEgKi8KKwlpZiAodW5saWtlbHkoIWd1Y19zdWJtaXNzaW9u X2luaXRpYWxpemVkKGd1YykpKQorCQlyZXR1cm47CisKKwl4YV9mb3JfZWFjaCgmZ3VjLT5jb250 ZXh0X2xvb2t1cCwgaW5kZXgsIGNlKSB7CisJCWlmICghaW50ZWxfY29udGV4dF9pc19waW5uZWQo Y2UpKQorCQkJY29udGludWU7CisKKwkJaWYgKGludGVsX2VuZ2luZV9pc192aXJ0dWFsKGNlLT5l bmdpbmUpKSB7CisJCQlpZiAoIShjZS0+ZW5naW5lLT5tYXNrICYgZW5naW5lLT5tYXNrKSkKKwkJ CQljb250aW51ZTsKKwkJfSBlbHNlIHsKKwkJCWlmIChjZS0+ZW5naW5lICE9IGVuZ2luZSkKKwkJ CQljb250aW51ZTsKKwkJfQorCisJCXNwaW5fbG9ja19pcnFzYXZlKCZjZS0+Z3VjX2FjdGl2ZS5s b2NrLCBmbGFncyk7CisJCWludGVsX2VuZ2luZV9kdW1wX2FjdGl2ZV9yZXF1ZXN0cygmY2UtPmd1 Y19hY3RpdmUucmVxdWVzdHMsCisJCQkJCQkgIGh1bmdfcnEsIG0pOworCQlzcGluX3VubG9ja19p cnFyZXN0b3JlKCZjZS0+Z3VjX2FjdGl2ZS5sb2NrLCBmbGFncyk7CisJfQorfQorCit2b2lkIGlu dGVsX2d1Y19zdWJtaXNzaW9uX3ByaW50X2luZm8oc3RydWN0IGludGVsX2d1YyAqZ3VjLAorCQkJ CSAgICAgc3RydWN0IGRybV9wcmludGVyICpwKQoreworCXN0cnVjdCBpOTE1X3NjaGVkX2VuZ2lu ZSAqc2NoZWRfZW5naW5lID0gZ3VjLT5zY2hlZF9lbmdpbmU7CisJc3RydWN0IHJiX25vZGUgKnJi OworCXVuc2lnbmVkIGxvbmcgZmxhZ3M7CisKKwlpZiAoIXNjaGVkX2VuZ2luZSkKKwkJcmV0dXJu OworCisJZHJtX3ByaW50ZihwLCAiR3VDIE51bWJlciBPdXRzdGFuZGluZyBTdWJtaXNzaW9uIEcy SDogJXVcbiIsCisJCSAgIGF0b21pY19yZWFkKCZndWMtPm91dHN0YW5kaW5nX3N1Ym1pc3Npb25f ZzJoKSk7CisJZHJtX3ByaW50ZihwLCAiR3VDIHRhc2tsZXQgY291bnQ6ICV1XG5cbiIsCisJCSAg IGF0b21pY19yZWFkKCZzY2hlZF9lbmdpbmUtPnRhc2tsZXQuY291bnQpKTsKKworCXNwaW5fbG9j a19pcnFzYXZlKCZzY2hlZF9lbmdpbmUtPmxvY2ssIGZsYWdzKTsKKwlkcm1fcHJpbnRmKHAsICJS ZXF1ZXN0cyBpbiBHdUMgc3VibWl0IHRhc2tsZXQ6XG4iKTsKKwlmb3IgKHJiID0gcmJfZmlyc3Rf Y2FjaGVkKCZzY2hlZF9lbmdpbmUtPnF1ZXVlKTsgcmI7IHJiID0gcmJfbmV4dChyYikpIHsKKwkJ c3RydWN0IGk5MTVfcHJpb2xpc3QgKnBsID0gdG9fcHJpb2xpc3QocmIpOworCQlzdHJ1Y3QgaTkx NV9yZXF1ZXN0ICpycTsKKworCQlwcmlvbGlzdF9mb3JfZWFjaF9yZXF1ZXN0KHJxLCBwbCkKKwkJ CWRybV9wcmludGYocCwgImd1Y19pZD0ldSwgc2Vxbm89JWxsdVxuIiwKKwkJCQkgICBycS0+Y29u dGV4dC0+Z3VjX2lkLAorCQkJCSAgIHJxLT5mZW5jZS5zZXFubyk7CisJfQorCXNwaW5fdW5sb2Nr X2lycXJlc3RvcmUoJnNjaGVkX2VuZ2luZS0+bG9jaywgZmxhZ3MpOworCWRybV9wcmludGYocCwg IlxuIik7Cit9CisKK3N0YXRpYyBpbmxpbmUgdm9pZCBndWNfbG9nX2NvbnRleHRfcHJpb3JpdHko c3RydWN0IGRybV9wcmludGVyICpwLAorCQkJCQkgICAgc3RydWN0IGludGVsX2NvbnRleHQgKmNl KQoreworCWludCBpOworCisJZHJtX3ByaW50ZihwLCAiXHRcdFByaW9yaXR5OiAlZFxuIiwKKwkJ ICAgY2UtPmd1Y19wcmlvKTsKKwlkcm1fcHJpbnRmKHAsICJcdFx0TnVtYmVyIFJlcXVlc3RzIChs b3dlciBpbmRleCA9PSBoaWdoZXIgcHJpb3JpdHkpXG4iKTsKKwlmb3IgKGkgPSBHVUNfQ0xJRU5U X1BSSU9SSVRZX0tNRF9ISUdIOworCSAgICAgaSA8IEdVQ19DTElFTlRfUFJJT1JJVFlfTlVNOyAr K2kpIHsKKwkJZHJtX3ByaW50ZihwLCAiXHRcdE51bWJlciByZXF1ZXN0cyBpbiBwcmlvcml0eSBi YW5kWyVkXTogJWRcbiIsCisJCQkgICBpLCBjZS0+Z3VjX3ByaW9fY291bnRbaV0pOworCX0KKwlk cm1fcHJpbnRmKHAsICJcbiIpOworfQorCit2b2lkIGludGVsX2d1Y19zdWJtaXNzaW9uX3ByaW50 X2NvbnRleHRfaW5mbyhzdHJ1Y3QgaW50ZWxfZ3VjICpndWMsCisJCQkJCSAgICAgc3RydWN0IGRy bV9wcmludGVyICpwKQoreworCXN0cnVjdCBpbnRlbF9jb250ZXh0ICpjZTsKKwl1bnNpZ25lZCBs b25nIGluZGV4OworCisJeGFfZm9yX2VhY2goJmd1Yy0+Y29udGV4dF9sb29rdXAsIGluZGV4LCBj ZSkgeworCQlkcm1fcHJpbnRmKHAsICJHdUMgbHJjIGRlc2NyaXB0b3IgJXU6XG4iLCBjZS0+Z3Vj X2lkKTsKKwkJZHJtX3ByaW50ZihwLCAiXHRIVyBDb250ZXh0IERlc2M6IDB4JTA4eFxuIiwgY2Ut PmxyYy5scmNhKTsKKwkJZHJtX3ByaW50ZihwLCAiXHRcdExSQyBIZWFkOiBJbnRlcm5hbCAldSwg TWVtb3J5ICV1XG4iLAorCQkJICAgY2UtPnJpbmctPmhlYWQsCisJCQkgICBjZS0+bHJjX3JlZ19z dGF0ZVtDVFhfUklOR19IRUFEXSk7CisJCWRybV9wcmludGYocCwgIlx0XHRMUkMgVGFpbDogSW50 ZXJuYWwgJXUsIE1lbW9yeSAldVxuIiwKKwkJCSAgIGNlLT5yaW5nLT50YWlsLAorCQkJICAgY2Ut PmxyY19yZWdfc3RhdGVbQ1RYX1JJTkdfVEFJTF0pOworCQlkcm1fcHJpbnRmKHAsICJcdFx0Q29u dGV4dCBQaW4gQ291bnQ6ICV1XG4iLAorCQkJICAgYXRvbWljX3JlYWQoJmNlLT5waW5fY291bnQp KTsKKwkJZHJtX3ByaW50ZihwLCAiXHRcdEd1QyBJRCBSZWYgQ291bnQ6ICV1XG4iLAorCQkJICAg YXRvbWljX3JlYWQoJmNlLT5ndWNfaWRfcmVmKSk7CisJCWRybV9wcmludGYocCwgIlx0XHRTY2hl ZHVsZSBTdGF0ZTogMHgleCwgMHgleFxuXG4iLAorCQkJICAgY2UtPmd1Y19zdGF0ZS5zY2hlZF9z dGF0ZSwKKwkJCSAgIGF0b21pY19yZWFkKCZjZS0+Z3VjX3NjaGVkX3N0YXRlX25vX2xvY2spKTsK KworCQlndWNfbG9nX2NvbnRleHRfcHJpb3JpdHkocCwgY2UpOworCX0KK30KKworc3RhdGljIHN0 cnVjdCBpbnRlbF9jb250ZXh0ICoKK2d1Y19jcmVhdGVfdmlydHVhbChzdHJ1Y3QgaW50ZWxfZW5n aW5lX2NzICoqc2libGluZ3MsIHVuc2lnbmVkIGludCBjb3VudCkKK3sKKwlzdHJ1Y3QgZ3VjX3Zp cnR1YWxfZW5naW5lICp2ZTsKKwlzdHJ1Y3QgaW50ZWxfZ3VjICpndWM7CisJdW5zaWduZWQgaW50 IG47CisJaW50IGVycjsKKworCXZlID0ga3phbGxvYyhzaXplb2YoKnZlKSwgR0ZQX0tFUk5FTCk7 CisJaWYgKCF2ZSkKKwkJcmV0dXJuIEVSUl9QVFIoLUVOT01FTSk7CisKKwlndWMgPSAmc2libGlu Z3NbMF0tPmd0LT51Yy5ndWM7CisKKwl2ZS0+YmFzZS5pOTE1ID0gc2libGluZ3NbMF0tPmk5MTU7 CisJdmUtPmJhc2UuZ3QgPSBzaWJsaW5nc1swXS0+Z3Q7CisJdmUtPmJhc2UudW5jb3JlID0gc2li bGluZ3NbMF0tPnVuY29yZTsKKwl2ZS0+YmFzZS5pZCA9IC0xOworCisJdmUtPmJhc2UudWFiaV9j bGFzcyA9IEk5MTVfRU5HSU5FX0NMQVNTX0lOVkFMSUQ7CisJdmUtPmJhc2UuaW5zdGFuY2UgPSBJ OTE1X0VOR0lORV9DTEFTU19JTlZBTElEX1ZJUlRVQUw7CisJdmUtPmJhc2UudWFiaV9pbnN0YW5j ZSA9IEk5MTVfRU5HSU5FX0NMQVNTX0lOVkFMSURfVklSVFVBTDsKKwl2ZS0+YmFzZS5zYXR1cmF0 ZWQgPSBBTExfRU5HSU5FUzsKKworCXNucHJpbnRmKHZlLT5iYXNlLm5hbWUsIHNpemVvZih2ZS0+ YmFzZS5uYW1lKSwgInZpcnR1YWwiKTsKKworCXZlLT5iYXNlLnNjaGVkX2VuZ2luZSA9IGk5MTVf c2NoZWRfZW5naW5lX2dldChndWMtPnNjaGVkX2VuZ2luZSk7CisKKwl2ZS0+YmFzZS5jb3BzID0g JnZpcnR1YWxfZ3VjX2NvbnRleHRfb3BzOworCXZlLT5iYXNlLnJlcXVlc3RfYWxsb2MgPSBndWNf cmVxdWVzdF9hbGxvYzsKKwl2ZS0+YmFzZS5idW1wX3NlcmlhbCA9IHZpcnR1YWxfZ3VjX2J1bXBf c2VyaWFsOworCisJdmUtPmJhc2Uuc3VibWl0X3JlcXVlc3QgPSBndWNfc3VibWl0X3JlcXVlc3Q7 CisKKwl2ZS0+YmFzZS5mbGFncyA9IEk5MTVfRU5HSU5FX0lTX1ZJUlRVQUw7CisKKwlpbnRlbF9j b250ZXh0X2luaXQoJnZlLT5jb250ZXh0LCAmdmUtPmJhc2UpOworCisJZm9yIChuID0gMDsgbiA8 IGNvdW50OyBuKyspIHsKKwkJc3RydWN0IGludGVsX2VuZ2luZV9jcyAqc2libGluZyA9IHNpYmxp bmdzW25dOworCisJCUdFTV9CVUdfT04oIWlzX3Bvd2VyX29mXzIoc2libGluZy0+bWFzaykpOwor CQlpZiAoc2libGluZy0+bWFzayAmIHZlLT5iYXNlLm1hc2spIHsKKwkJCURSTV9ERUJVRygiZHVw bGljYXRlICVzIGVudHJ5IGluIGxvYWQgYmFsYW5jZXJcbiIsCisJCQkJICBzaWJsaW5nLT5uYW1l KTsKKwkJCWVyciA9IC1FSU5WQUw7CisJCQlnb3RvIGVycl9wdXQ7CisJCX0KKworCQl2ZS0+YmFz ZS5tYXNrIHw9IHNpYmxpbmctPm1hc2s7CisKKwkJaWYgKG4gIT0gMCAmJiB2ZS0+YmFzZS5jbGFz cyAhPSBzaWJsaW5nLT5jbGFzcykgeworCQkJRFJNX0RFQlVHKCJpbnZhbGlkIG1peGluZyBvZiBl bmdpbmUgY2xhc3MsIHNpYmxpbmcgJWQsIGFscmVhZHkgJWRcbiIsCisJCQkJICBzaWJsaW5nLT5j bGFzcywgdmUtPmJhc2UuY2xhc3MpOworCQkJZXJyID0gLUVJTlZBTDsKKwkJCWdvdG8gZXJyX3B1 dDsKKwkJfSBlbHNlIGlmIChuID09IDApIHsKKwkJCXZlLT5iYXNlLmNsYXNzID0gc2libGluZy0+ Y2xhc3M7CisJCQl2ZS0+YmFzZS51YWJpX2NsYXNzID0gc2libGluZy0+dWFiaV9jbGFzczsKKwkJ CXNucHJpbnRmKHZlLT5iYXNlLm5hbWUsIHNpemVvZih2ZS0+YmFzZS5uYW1lKSwKKwkJCQkgInYl ZHglZCIsIHZlLT5iYXNlLmNsYXNzLCBjb3VudCk7CisJCQl2ZS0+YmFzZS5jb250ZXh0X3NpemUg PSBzaWJsaW5nLT5jb250ZXh0X3NpemU7CisKKwkJCXZlLT5iYXNlLmFkZF9hY3RpdmVfcmVxdWVz dCA9CisJCQkJc2libGluZy0+YWRkX2FjdGl2ZV9yZXF1ZXN0OworCQkJdmUtPmJhc2UucmVtb3Zl X2FjdGl2ZV9yZXF1ZXN0ID0KKwkJCQlzaWJsaW5nLT5yZW1vdmVfYWN0aXZlX3JlcXVlc3Q7CisJ CQl2ZS0+YmFzZS5lbWl0X2JiX3N0YXJ0ID0gc2libGluZy0+ZW1pdF9iYl9zdGFydDsKKwkJCXZl LT5iYXNlLmVtaXRfZmx1c2ggPSBzaWJsaW5nLT5lbWl0X2ZsdXNoOworCQkJdmUtPmJhc2UuZW1p dF9pbml0X2JyZWFkY3J1bWIgPQorCQkJCXNpYmxpbmctPmVtaXRfaW5pdF9icmVhZGNydW1iOwor CQkJdmUtPmJhc2UuZW1pdF9maW5pX2JyZWFkY3J1bWIgPQorCQkJCXNpYmxpbmctPmVtaXRfZmlu aV9icmVhZGNydW1iOworCQkJdmUtPmJhc2UuZW1pdF9maW5pX2JyZWFkY3J1bWJfZHcgPQorCQkJ CXNpYmxpbmctPmVtaXRfZmluaV9icmVhZGNydW1iX2R3OworCQkJdmUtPmJhc2UuYnJlYWRjcnVt YnMgPQorCQkJCWludGVsX2JyZWFkY3J1bWJzX2dldChzaWJsaW5nLT5icmVhZGNydW1icyk7CisK KwkJCXZlLT5iYXNlLmZsYWdzIHw9IHNpYmxpbmctPmZsYWdzOworCisJCQl2ZS0+YmFzZS5wcm9w cy50aW1lc2xpY2VfZHVyYXRpb25fbXMgPQorCQkJCXNpYmxpbmctPnByb3BzLnRpbWVzbGljZV9k dXJhdGlvbl9tczsKKwkJCXZlLT5iYXNlLnByb3BzLnByZWVtcHRfdGltZW91dF9tcyA9CisJCQkJ c2libGluZy0+cHJvcHMucHJlZW1wdF90aW1lb3V0X21zOworCQl9CisJfQorCisJcmV0dXJuICZ2 ZS0+Y29udGV4dDsKKworZXJyX3B1dDoKKwlpbnRlbF9jb250ZXh0X3B1dCgmdmUtPmNvbnRleHQp OworCXJldHVybiBFUlJfUFRSKGVycik7Cit9CisKKworCitib29sIGludGVsX2d1Y192aXJ0dWFs X2VuZ2luZV9oYXNfaGVhcnRiZWF0KGNvbnN0IHN0cnVjdCBpbnRlbF9lbmdpbmVfY3MgKnZlKQor eworCXN0cnVjdCBpbnRlbF9lbmdpbmVfY3MgKmVuZ2luZTsKKwlpbnRlbF9lbmdpbmVfbWFza190 IHRtcCwgbWFzayA9IHZlLT5tYXNrOworCisJZm9yX2VhY2hfZW5naW5lX21hc2tlZChlbmdpbmUs IHZlLT5ndCwgbWFzaywgdG1wKQorCQlpZiAoUkVBRF9PTkNFKGVuZ2luZS0+cHJvcHMuaGVhcnRi ZWF0X2ludGVydmFsX21zKSkKKwkJCXJldHVybiB0cnVlOworCisJcmV0dXJuIGZhbHNlOworfQpk aWZmIC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJtL2k5MTUvZ3QvdWMvaW50ZWxfZ3VjX3N1Ym1pc3Np b24uaCBiL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2d0L3VjL2ludGVsX2d1Y19zdWJtaXNzaW9uLmgK aW5kZXggM2Y3MDA1MDE4OTM5Li5jN2VmNDRmYTBjMzYgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvZ3B1 L2RybS9pOTE1L2d0L3VjL2ludGVsX2d1Y19zdWJtaXNzaW9uLmgKKysrIGIvZHJpdmVycy9ncHUv ZHJtL2k5MTUvZ3QvdWMvaW50ZWxfZ3VjX3N1Ym1pc3Npb24uaApAQCAtMTAsNiArMTAsNyBAQAog CiAjaW5jbHVkZSAiaW50ZWxfZ3VjLmgiCiAKK3N0cnVjdCBkcm1fcHJpbnRlcjsKIHN0cnVjdCBp bnRlbF9lbmdpbmVfY3M7CiAKIHZvaWQgaW50ZWxfZ3VjX3N1Ym1pc3Npb25faW5pdF9lYXJseShz dHJ1Y3QgaW50ZWxfZ3VjICpndWMpOwpAQCAtMjAsMTEgKzIxLDI0IEBAIHZvaWQgaW50ZWxfZ3Vj X3N1Ym1pc3Npb25fZmluaShzdHJ1Y3QgaW50ZWxfZ3VjICpndWMpOwogaW50IGludGVsX2d1Y19w cmVlbXB0X3dvcmtfY3JlYXRlKHN0cnVjdCBpbnRlbF9ndWMgKmd1Yyk7CiB2b2lkIGludGVsX2d1 Y19wcmVlbXB0X3dvcmtfZGVzdHJveShzdHJ1Y3QgaW50ZWxfZ3VjICpndWMpOwogaW50IGludGVs X2d1Y19zdWJtaXNzaW9uX3NldHVwKHN0cnVjdCBpbnRlbF9lbmdpbmVfY3MgKmVuZ2luZSk7Cit2 b2lkIGludGVsX2d1Y19zdWJtaXNzaW9uX3ByaW50X2luZm8oc3RydWN0IGludGVsX2d1YyAqZ3Vj LAorCQkJCSAgICAgc3RydWN0IGRybV9wcmludGVyICpwKTsKK3ZvaWQgaW50ZWxfZ3VjX3N1Ym1p c3Npb25fcHJpbnRfY29udGV4dF9pbmZvKHN0cnVjdCBpbnRlbF9ndWMgKmd1YywKKwkJCQkJICAg ICBzdHJ1Y3QgZHJtX3ByaW50ZXIgKnApOwordm9pZCBpbnRlbF9ndWNfZHVtcF9hY3RpdmVfcmVx dWVzdHMoc3RydWN0IGludGVsX2VuZ2luZV9jcyAqZW5naW5lLAorCQkJCSAgICBzdHJ1Y3QgaTkx NV9yZXF1ZXN0ICpodW5nX3JxLAorCQkJCSAgICBzdHJ1Y3QgZHJtX3ByaW50ZXIgKm0pOworCiti b29sIGludGVsX2d1Y192aXJ0dWFsX2VuZ2luZV9oYXNfaGVhcnRiZWF0KGNvbnN0IHN0cnVjdCBp bnRlbF9lbmdpbmVfY3MgKnZlKTsKKworaW50IGludGVsX2d1Y193YWl0X2Zvcl9wZW5kaW5nX21z ZyhzdHJ1Y3QgaW50ZWxfZ3VjICpndWMsCisJCQkJICAgYXRvbWljX3QgKndhaXRfdmFyLAorCQkJ CSAgIGJvb2wgaW50ZXJydXB0aWJsZSwKKwkJCQkgICBsb25nIHRpbWVvdXQpOwogCiBzdGF0aWMg aW5saW5lIGJvb2wgaW50ZWxfZ3VjX3N1Ym1pc3Npb25faXNfc3VwcG9ydGVkKHN0cnVjdCBpbnRl bF9ndWMgKmd1YykKIHsKLQkvKiBYWFg6IEd1QyBzdWJtaXNzaW9uIGlzIHVuYXZhaWxhYmxlIGZv ciBub3cgKi8KLQlyZXR1cm4gZmFsc2U7CisJcmV0dXJuIGd1Yy0+c3VibWlzc2lvbl9zdXBwb3J0 ZWQ7CiB9CiAKIHN0YXRpYyBpbmxpbmUgYm9vbCBpbnRlbF9ndWNfc3VibWlzc2lvbl9pc193YW50 ZWQoc3RydWN0IGludGVsX2d1YyAqZ3VjKQpkaWZmIC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJtL2k5 MTUvZ3QvdWMvaW50ZWxfdWMuYyBiL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2d0L3VjL2ludGVsX3Vj LmMKaW5kZXggNmQ4YjkyMzMyMTRlLi5kYTU3ZDE4ZDlmNmIgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMv Z3B1L2RybS9pOTE1L2d0L3VjL2ludGVsX3VjLmMKKysrIGIvZHJpdmVycy9ncHUvZHJtL2k5MTUv Z3QvdWMvaW50ZWxfdWMuYwpAQCAtMzQsOCArMzQsMTQgQEAgc3RhdGljIHZvaWQgdWNfZXhwYW5k X2RlZmF1bHRfb3B0aW9ucyhzdHJ1Y3QgaW50ZWxfdWMgKnVjKQogCQlyZXR1cm47CiAJfQogCi0J LyogRGVmYXVsdDogZW5hYmxlIEh1QyBhdXRoZW50aWNhdGlvbiBvbmx5ICovCi0JaTkxNS0+cGFy YW1zLmVuYWJsZV9ndWMgPSBFTkFCTEVfR1VDX0xPQURfSFVDOworCS8qIEludGVybWVkaWF0ZSBw bGF0Zm9ybXMgYXJlIEh1QyBhdXRoZW50aWNhdGlvbiBvbmx5ICovCisJaWYgKElTX0RHMShpOTE1 KSB8fCBJU19BTERFUkxBS0VfUyhpOTE1KSkgeworCQlpOTE1LT5wYXJhbXMuZW5hYmxlX2d1YyA9 IEVOQUJMRV9HVUNfTE9BRF9IVUM7CisJCXJldHVybjsKKwl9CisKKwkvKiBEZWZhdWx0OiBlbmFi bGUgSHVDIGF1dGhlbnRpY2F0aW9uIGFuZCBHdUMgc3VibWlzc2lvbiAqLworCWk5MTUtPnBhcmFt cy5lbmFibGVfZ3VjID0gRU5BQkxFX0dVQ19MT0FEX0hVQyB8IEVOQUJMRV9HVUNfU1VCTUlTU0lP TjsKIH0KIAogLyogUmVzZXQgR3VDIHByb3ZpZGluZyB1cyB3aXRoIGZyZXNoIHN0YXRlIGZvciBi b3RoIEd1QyBhbmQgSHVDLgpAQCAtMTIwLDYgKzEyNiwxMSBAQCB2b2lkIGludGVsX3VjX2luaXRf ZWFybHkoc3RydWN0IGludGVsX3VjICp1YykKIAkJdWMtPm9wcyA9ICZ1Y19vcHNfb2ZmOwogfQog Cit2b2lkIGludGVsX3VjX2luaXRfbGF0ZShzdHJ1Y3QgaW50ZWxfdWMgKnVjKQoreworCWludGVs X2d1Y19pbml0X2xhdGUoJnVjLT5ndWMpOworfQorCiB2b2lkIGludGVsX3VjX2RyaXZlcl9sYXRl X3JlbGVhc2Uoc3RydWN0IGludGVsX3VjICp1YykKIHsKIH0KQEAgLTIwNywyMSArMjE4LDYgQEAg c3RhdGljIHZvaWQgZ3VjX2hhbmRsZV9tbWlvX21zZyhzdHJ1Y3QgaW50ZWxfZ3VjICpndWMpCiAJ c3Bpbl91bmxvY2tfaXJxKCZndWMtPmlycV9sb2NrKTsKIH0KIAotc3RhdGljIHZvaWQgZ3VjX3Jl c2V0X2ludGVycnVwdHMoc3RydWN0IGludGVsX2d1YyAqZ3VjKQotewotCWd1Yy0+aW50ZXJydXB0 cy5yZXNldChndWMpOwotfQotCi1zdGF0aWMgdm9pZCBndWNfZW5hYmxlX2ludGVycnVwdHMoc3Ry dWN0IGludGVsX2d1YyAqZ3VjKQotewotCWd1Yy0+aW50ZXJydXB0cy5lbmFibGUoZ3VjKTsKLX0K LQotc3RhdGljIHZvaWQgZ3VjX2Rpc2FibGVfaW50ZXJydXB0cyhzdHJ1Y3QgaW50ZWxfZ3VjICpn dWMpCi17Ci0JZ3VjLT5pbnRlcnJ1cHRzLmRpc2FibGUoZ3VjKTsKLX0KLQogc3RhdGljIGludCBn dWNfZW5hYmxlX2NvbW11bmljYXRpb24oc3RydWN0IGludGVsX2d1YyAqZ3VjKQogewogCXN0cnVj dCBpbnRlbF9ndCAqZ3QgPSBndWNfdG9fZ3QoZ3VjKTsKQEAgLTI0Miw3ICsyMzgsNyBAQCBzdGF0 aWMgaW50IGd1Y19lbmFibGVfY29tbXVuaWNhdGlvbihzdHJ1Y3QgaW50ZWxfZ3VjICpndWMpCiAJ Z3VjX2dldF9tbWlvX21zZyhndWMpOwogCWd1Y19oYW5kbGVfbW1pb19tc2coZ3VjKTsKIAotCWd1 Y19lbmFibGVfaW50ZXJydXB0cyhndWMpOworCWludGVsX2d1Y19lbmFibGVfaW50ZXJydXB0cyhn dWMpOwogCiAJLyogY2hlY2sgZm9yIENUIG1lc3NhZ2VzIHJlY2VpdmVkIGJlZm9yZSB3ZSBlbmFi bGVkIGludGVycnVwdHMgKi8KIAlzcGluX2xvY2tfaXJxKCZndC0+aXJxX2xvY2spOwpAQCAtMjY1 LDcgKzI2MSw3IEBAIHN0YXRpYyB2b2lkIGd1Y19kaXNhYmxlX2NvbW11bmljYXRpb24oc3RydWN0 IGludGVsX2d1YyAqZ3VjKQogCSAqLwogCWd1Y19jbGVhcl9tbWlvX21zZyhndWMpOwogCi0JZ3Vj X2Rpc2FibGVfaW50ZXJydXB0cyhndWMpOworCWludGVsX2d1Y19kaXNhYmxlX2ludGVycnVwdHMo Z3VjKTsKIAogCWludGVsX2d1Y19jdF9kaXNhYmxlKCZndWMtPmN0KTsKIApAQCAtMzIzLDkgKzMx OSw2IEBAIHN0YXRpYyBpbnQgX191Y19pbml0KHN0cnVjdCBpbnRlbF91YyAqdWMpCiAJaWYgKGk5 MTVfaW5qZWN0X3Byb2JlX2ZhaWx1cmUodWNfdG9fZ3QodWMpLT5pOTE1KSkKIAkJcmV0dXJuIC1F Tk9NRU07CiAKLQkvKiBYWFg6IEd1QyBzdWJtaXNzaW9uIGlzIHVuYXZhaWxhYmxlIGZvciBub3cg Ki8KLQlHRU1fQlVHX09OKGludGVsX3VjX3VzZXNfZ3VjX3N1Ym1pc3Npb24odWMpKTsKLQogCXJl dCA9IGludGVsX2d1Y19pbml0KGd1Yyk7CiAJaWYgKHJldCkKIAkJcmV0dXJuIHJldDsKQEAgLTQ2 Myw3ICs0NTYsNyBAQCBzdGF0aWMgaW50IF9fdWNfaW5pdF9odyhzdHJ1Y3QgaW50ZWxfdWMgKnVj KQogCWlmIChyZXQpCiAJCWdvdG8gZXJyX291dDsKIAotCWd1Y19yZXNldF9pbnRlcnJ1cHRzKGd1 Yyk7CisJaW50ZWxfZ3VjX3Jlc2V0X2ludGVycnVwdHMoZ3VjKTsKIAogCS8qIFdhRW5hYmxldUtl cm5lbEhlYWRlclZhbGlkRml4OnNrbCAqLwogCS8qIFdhRW5hYmxlR3VDQm9vdEhhc2hDaGVja05v dFNldDpza2wsYnh0LGtibCAqLwpAQCAtNTY1LDIzICs1NTgsNjcgQEAgdm9pZCBpbnRlbF91Y19y ZXNldF9wcmVwYXJlKHN0cnVjdCBpbnRlbF91YyAqdWMpCiB7CiAJc3RydWN0IGludGVsX2d1YyAq Z3VjID0gJnVjLT5ndWM7CiAKLQlpZiAoIWludGVsX2d1Y19pc19yZWFkeShndWMpKQorCXVjLT5y ZXNldF9pbl9wcm9ncmVzcyA9IHRydWU7CisKKwkvKiBOb3RoaW5nIHRvIGRvIGlmIEd1QyBpc24n dCBzdXBwb3J0ZWQgKi8KKwlpZiAoIWludGVsX3VjX3N1cHBvcnRzX2d1Yyh1YykpCiAJCXJldHVy bjsKIAorCS8qIEZpcm13YXJlIGV4cGVjdGVkIHRvIGJlIHJ1bm5pbmcgd2hlbiB0aGlzIGZ1bmN0 aW9uIGlzIGNhbGxlZCAqLworCWlmICghaW50ZWxfZ3VjX2lzX3JlYWR5KGd1YykpCisJCWdvdG8g c2FuaXRpemU7CisKKwlpZiAoaW50ZWxfdWNfdXNlc19ndWNfc3VibWlzc2lvbih1YykpCisJCWlu dGVsX2d1Y19zdWJtaXNzaW9uX3Jlc2V0X3ByZXBhcmUoZ3VjKTsKKworc2FuaXRpemU6CiAJX191 Y19zYW5pdGl6ZSh1Yyk7CiB9CiAKK3ZvaWQgaW50ZWxfdWNfcmVzZXQoc3RydWN0IGludGVsX3Vj ICp1YywgYm9vbCBzdGFsbGVkKQoreworCXN0cnVjdCBpbnRlbF9ndWMgKmd1YyA9ICZ1Yy0+Z3Vj OworCisJLyogRmlybXdhcmUgY2FuIG5vdCBiZSBydW5uaW5nIHdoZW4gdGhpcyBmdW5jdGlvbiBp cyBjYWxsZWQgICovCisJaWYgKGludGVsX3VjX3VzZXNfZ3VjX3N1Ym1pc3Npb24odWMpKQorCQlp bnRlbF9ndWNfc3VibWlzc2lvbl9yZXNldChndWMsIHN0YWxsZWQpOworfQorCit2b2lkIGludGVs X3VjX3Jlc2V0X2ZpbmlzaChzdHJ1Y3QgaW50ZWxfdWMgKnVjKQoreworCXN0cnVjdCBpbnRlbF9n dWMgKmd1YyA9ICZ1Yy0+Z3VjOworCisJdWMtPnJlc2V0X2luX3Byb2dyZXNzID0gZmFsc2U7CisK KwkvKiBGaXJtd2FyZSBleHBlY3RlZCB0byBiZSBydW5uaW5nIHdoZW4gdGhpcyBmdW5jdGlvbiBp cyBjYWxsZWQgKi8KKwlpZiAoaW50ZWxfZ3VjX2lzX2Z3X3J1bm5pbmcoZ3VjKSAmJiBpbnRlbF91 Y191c2VzX2d1Y19zdWJtaXNzaW9uKHVjKSkKKwkJaW50ZWxfZ3VjX3N1Ym1pc3Npb25fcmVzZXRf ZmluaXNoKGd1Yyk7Cit9CisKK3ZvaWQgaW50ZWxfdWNfY2FuY2VsX3JlcXVlc3RzKHN0cnVjdCBp bnRlbF91YyAqdWMpCit7CisJc3RydWN0IGludGVsX2d1YyAqZ3VjID0gJnVjLT5ndWM7CisKKwkv KiBGaXJtd2FyZSBjYW4gbm90IGJlIHJ1bm5pbmcgd2hlbiB0aGlzIGZ1bmN0aW9uIGlzIGNhbGxl ZCAgKi8KKwlpZiAoaW50ZWxfdWNfdXNlc19ndWNfc3VibWlzc2lvbih1YykpCisJCWludGVsX2d1 Y19zdWJtaXNzaW9uX2NhbmNlbF9yZXF1ZXN0cyhndWMpOworfQorCiB2b2lkIGludGVsX3VjX3J1 bnRpbWVfc3VzcGVuZChzdHJ1Y3QgaW50ZWxfdWMgKnVjKQogewogCXN0cnVjdCBpbnRlbF9ndWMg Kmd1YyA9ICZ1Yy0+Z3VjOwotCWludCBlcnI7CiAKIAlpZiAoIWludGVsX2d1Y19pc19yZWFkeShn dWMpKQogCQlyZXR1cm47CiAKLQllcnIgPSBpbnRlbF9ndWNfc3VzcGVuZChndWMpOwotCWlmIChl cnIpCi0JCURSTV9ERUJVR19EUklWRVIoIkZhaWxlZCB0byBzdXNwZW5kIEd1QywgZXJyPSVkIiwg ZXJyKTsKKwkvKgorCSAqIFdhaXQgZm9yIGFueSBvdXRzdGFuZGluZyBDVEIgYmVmb3JlIHRlYXJp bmcgZG93biBjb21tdW5pY2F0aW9uIC93IHRoZQorCSAqIEd1Qy4KKwkgKi8KKyNkZWZpbmUgT1VU U1RBTkRJTkdfQ1RCX1RJTUVPVVRfUEVSSU9ECShIWiAvIDUpCisJaW50ZWxfZ3VjX3dhaXRfZm9y X3BlbmRpbmdfbXNnKGd1YywgJmd1Yy0+b3V0c3RhbmRpbmdfc3VibWlzc2lvbl9nMmgsCisJCQkJ ICAgICAgIGZhbHNlLCBPVVRTVEFORElOR19DVEJfVElNRU9VVF9QRVJJT0QpOworCUdFTV9XQVJO X09OKGF0b21pY19yZWFkKCZndWMtPm91dHN0YW5kaW5nX3N1Ym1pc3Npb25fZzJoKSk7CiAKIAln dWNfZGlzYWJsZV9jb21tdW5pY2F0aW9uKGd1Yyk7CiB9CkBAIC01OTAsMTIgKzYyNywxNiBAQCB2 b2lkIGludGVsX3VjX3N1c3BlbmQoc3RydWN0IGludGVsX3VjICp1YykKIHsKIAlzdHJ1Y3QgaW50 ZWxfZ3VjICpndWMgPSAmdWMtPmd1YzsKIAlpbnRlbF93YWtlcmVmX3Qgd2FrZXJlZjsKKwlpbnQg ZXJyOwogCiAJaWYgKCFpbnRlbF9ndWNfaXNfcmVhZHkoZ3VjKSkKIAkJcmV0dXJuOwogCi0Jd2l0 aF9pbnRlbF9ydW50aW1lX3BtKHVjX3RvX2d0KHVjKS0+dW5jb3JlLT5ycG0sIHdha2VyZWYpCi0J CWludGVsX3VjX3J1bnRpbWVfc3VzcGVuZCh1Yyk7CisJd2l0aF9pbnRlbF9ydW50aW1lX3BtKCZ1 Y190b19ndCh1YyktPmk5MTUtPnJ1bnRpbWVfcG0sIHdha2VyZWYpIHsKKwkJZXJyID0gaW50ZWxf Z3VjX3N1c3BlbmQoZ3VjKTsKKwkJaWYgKGVycikKKwkJCURSTV9ERUJVR19EUklWRVIoIkZhaWxl ZCB0byBzdXNwZW5kIEd1QywgZXJyPSVkIiwgZXJyKTsKKwl9CiB9CiAKIHN0YXRpYyBpbnQgX191 Y19yZXN1bWUoc3RydWN0IGludGVsX3VjICp1YywgYm9vbCBlbmFibGVfY29tbXVuaWNhdGlvbikK ZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2d0L3VjL2ludGVsX3VjLmggYi9kcml2 ZXJzL2dwdS9kcm0vaTkxNS9ndC91Yy9pbnRlbF91Yy5oCmluZGV4IDljOTU0YzU4OWVkZi4uZTJk YTJiNmU3NmUxIDEwMDY0NAotLS0gYS9kcml2ZXJzL2dwdS9kcm0vaTkxNS9ndC91Yy9pbnRlbF91 Yy5oCisrKyBiL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2d0L3VjL2ludGVsX3VjLmgKQEAgLTMwLDEz ICszMCwxOSBAQCBzdHJ1Y3QgaW50ZWxfdWMgewogCiAJLyogU25hcHNob3Qgb2YgR3VDIGxvZyBm cm9tIGxhc3QgZmFpbGVkIGxvYWQgKi8KIAlzdHJ1Y3QgZHJtX2k5MTVfZ2VtX29iamVjdCAqbG9h ZF9lcnJfbG9nOworCisJYm9vbCByZXNldF9pbl9wcm9ncmVzczsKIH07CiAKIHZvaWQgaW50ZWxf dWNfaW5pdF9lYXJseShzdHJ1Y3QgaW50ZWxfdWMgKnVjKTsKK3ZvaWQgaW50ZWxfdWNfaW5pdF9s YXRlKHN0cnVjdCBpbnRlbF91YyAqdWMpOwogdm9pZCBpbnRlbF91Y19kcml2ZXJfbGF0ZV9yZWxl YXNlKHN0cnVjdCBpbnRlbF91YyAqdWMpOwogdm9pZCBpbnRlbF91Y19kcml2ZXJfcmVtb3ZlKHN0 cnVjdCBpbnRlbF91YyAqdWMpOwogdm9pZCBpbnRlbF91Y19pbml0X21taW8oc3RydWN0IGludGVs X3VjICp1Yyk7CiB2b2lkIGludGVsX3VjX3Jlc2V0X3ByZXBhcmUoc3RydWN0IGludGVsX3VjICp1 Yyk7Cit2b2lkIGludGVsX3VjX3Jlc2V0KHN0cnVjdCBpbnRlbF91YyAqdWMsIGJvb2wgc3RhbGxl ZCk7Cit2b2lkIGludGVsX3VjX3Jlc2V0X2ZpbmlzaChzdHJ1Y3QgaW50ZWxfdWMgKnVjKTsKK3Zv aWQgaW50ZWxfdWNfY2FuY2VsX3JlcXVlc3RzKHN0cnVjdCBpbnRlbF91YyAqdWMpOwogdm9pZCBp bnRlbF91Y19zdXNwZW5kKHN0cnVjdCBpbnRlbF91YyAqdWMpOwogdm9pZCBpbnRlbF91Y19ydW50 aW1lX3N1c3BlbmQoc3RydWN0IGludGVsX3VjICp1Yyk7CiBpbnQgaW50ZWxfdWNfcmVzdW1lKHN0 cnVjdCBpbnRlbF91YyAqdWMpOwpAQCAtODEsNiArODcsMTEgQEAgdWNfc3RhdGVfY2hlY2tlcnMo Z3VjLCBndWNfc3VibWlzc2lvbik7CiAjdW5kZWYgdWNfc3RhdGVfY2hlY2tlcnMKICN1bmRlZiBf X3VjX3N0YXRlX2NoZWNrZXIKIAorc3RhdGljIGlubGluZSBpbnQgaW50ZWxfdWNfd2FpdF9mb3Jf aWRsZShzdHJ1Y3QgaW50ZWxfdWMgKnVjLCBsb25nIHRpbWVvdXQpCit7CisJcmV0dXJuIGludGVs X2d1Y193YWl0X2Zvcl9pZGxlKCZ1Yy0+Z3VjLCB0aW1lb3V0KTsKK30KKwogI2RlZmluZSBpbnRl bF91Y19vcHNfZnVuY3Rpb24oX05BTUUsIF9PUFMsIF9UWVBFLCBfUkVUKSBcCiBzdGF0aWMgaW5s aW5lIF9UWVBFIGludGVsX3VjXyMjX05BTUUoc3RydWN0IGludGVsX3VjICp1YykgXAogeyBcCmRp ZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9kcm0vaTkxNS9pOTE1X2RlYnVnZnNfcGFyYW1zLmMgYi9k cml2ZXJzL2dwdS9kcm0vaTkxNS9pOTE1X2RlYnVnZnNfcGFyYW1zLmMKaW5kZXggNGUyYjA3NzY5 MmNiLi44ZWNkOGI0MmYwNDggMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2k5MTVf ZGVidWdmc19wYXJhbXMuYworKysgYi9kcml2ZXJzL2dwdS9kcm0vaTkxNS9pOTE1X2RlYnVnZnNf cGFyYW1zLmMKQEAgLTYsOSArNiwyMCBAQAogI2luY2x1ZGUgPGxpbnV4L2tlcm5lbC5oPgogCiAj aW5jbHVkZSAiaTkxNV9kZWJ1Z2ZzX3BhcmFtcy5oIgorI2luY2x1ZGUgImd0L2ludGVsX2d0Lmgi CisjaW5jbHVkZSAiZ3QvdWMvaW50ZWxfZ3VjLmgiCiAjaW5jbHVkZSAiaTkxNV9kcnYuaCIKICNp bmNsdWRlICJpOTE1X3BhcmFtcy5oIgogCisjZGVmaW5lIE1BVENIX0RFQlVHRlNfTk9ERV9OQU1F KF9maWxlLCBfbmFtZSkJKHN0cmNtcCgoX2ZpbGUpLT5mX3BhdGguZGVudHJ5LT5kX25hbWUubmFt ZSwgKF9uYW1lKSkgPT0gMCkKKworI2RlZmluZSBHRVRfSTkxNShpOTE1LCBuYW1lLCBwdHIpCVwK KwlkbyB7CVwKKwkJc3RydWN0IGk5MTVfcGFyYW1zICpwYXJhbXM7CVwKKwkJcGFyYW1zID0gY29u dGFpbmVyX29mKCgodm9pZCAqKSAocHRyKSksIHR5cGVvZigqcGFyYW1zKSwgbmFtZSk7CVwKKwkJ KGk5MTUpID0gY29udGFpbmVyX29mKHBhcmFtcywgdHlwZW9mKCooaTkxNSkpLCBwYXJhbXMpOwlc CisJfSB3aGlsZSgwKQorCiAvKiBpbnQgcGFyYW0gKi8KIHN0YXRpYyBpbnQgaTkxNV9wYXJhbV9p bnRfc2hvdyhzdHJ1Y3Qgc2VxX2ZpbGUgKm0sIHZvaWQgKmRhdGEpCiB7CkBAIC0yNCw2ICszNSwx NiBAQCBzdGF0aWMgaW50IGk5MTVfcGFyYW1faW50X29wZW4oc3RydWN0IGlub2RlICppbm9kZSwg c3RydWN0IGZpbGUgKmZpbGUpCiAJcmV0dXJuIHNpbmdsZV9vcGVuKGZpbGUsIGk5MTVfcGFyYW1f aW50X3Nob3csIGlub2RlLT5pX3ByaXZhdGUpOwogfQogCitzdGF0aWMgaW50IG5vdGlmeV9ndWMo c3RydWN0IGRybV9pOTE1X3ByaXZhdGUgKmk5MTUpCit7CisJaW50IHJldCA9IDA7CisKKwlpZiAo aW50ZWxfdWNfdXNlc19ndWNfc3VibWlzc2lvbigmaTkxNS0+Z3QudWMpKQorCQlyZXQgPSBpbnRl bF9ndWNfZ2xvYmFsX3BvbGljaWVzX3VwZGF0ZSgmaTkxNS0+Z3QudWMuZ3VjKTsKKworCXJldHVy biByZXQ7Cit9CisKIHN0YXRpYyBzc2l6ZV90IGk5MTVfcGFyYW1faW50X3dyaXRlKHN0cnVjdCBm aWxlICpmaWxlLAogCQkJCSAgICBjb25zdCBjaGFyIF9fdXNlciAqdWJ1Ziwgc2l6ZV90IGxlbiwK IAkJCQkgICAgbG9mZl90ICpvZmZwKQpAQCAtODEsOCArMTAyLDEwIEBAIHN0YXRpYyBzc2l6ZV90 IGk5MTVfcGFyYW1fdWludF93cml0ZShzdHJ1Y3QgZmlsZSAqZmlsZSwKIAkJCQkgICAgIGNvbnN0 IGNoYXIgX191c2VyICp1YnVmLCBzaXplX3QgbGVuLAogCQkJCSAgICAgbG9mZl90ICpvZmZwKQog eworCXN0cnVjdCBkcm1faTkxNV9wcml2YXRlICppOTE1OwogCXN0cnVjdCBzZXFfZmlsZSAqbSA9 IGZpbGUtPnByaXZhdGVfZGF0YTsKIAl1bnNpZ25lZCBpbnQgKnZhbHVlID0gbS0+cHJpdmF0ZTsK Kwl1bnNpZ25lZCBpbnQgb2xkID0gKnZhbHVlOwogCWludCByZXQ7CiAKIAlyZXQgPSBrc3RydG91 aW50X2Zyb21fdXNlcih1YnVmLCBsZW4sIDAsIHZhbHVlKTsKQEAgLTk1LDYgKzExOCwxNCBAQCBz dGF0aWMgc3NpemVfdCBpOTE1X3BhcmFtX3VpbnRfd3JpdGUoc3RydWN0IGZpbGUgKmZpbGUsCiAJ CQkqdmFsdWUgPSBiOwogCX0KIAorCWlmICghcmV0ICYmIE1BVENIX0RFQlVHRlNfTk9ERV9OQU1F KGZpbGUsICJyZXNldCIpKSB7CisJCUdFVF9JOTE1KGk5MTUsIHJlc2V0LCB2YWx1ZSk7CisKKwkJ cmV0ID0gbm90aWZ5X2d1YyhpOTE1KTsKKwkJaWYgKHJldCkKKwkJCSp2YWx1ZSA9IG9sZDsKKwl9 CisKIAlyZXR1cm4gcmV0ID86IGxlbjsKIH0KIApkaWZmIC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJt L2k5MTUvaTkxNV9nZW1fZXZpY3QuYyBiL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2k5MTVfZ2VtX2V2 aWN0LmMKaW5kZXggNGQyZDU5YTk5NDJiLi4yYjczZGRiMTFjNjYgMTAwNjQ0Ci0tLSBhL2RyaXZl cnMvZ3B1L2RybS9pOTE1L2k5MTVfZ2VtX2V2aWN0LmMKKysrIGIvZHJpdmVycy9ncHUvZHJtL2k5 MTUvaTkxNV9nZW1fZXZpY3QuYwpAQCAtMjcsNiArMjcsNyBAQAogICovCiAKICNpbmNsdWRlICJn ZW0vaTkxNV9nZW1fY29udGV4dC5oIgorI2luY2x1ZGUgImd0L2ludGVsX2d0LmgiCiAjaW5jbHVk ZSAiZ3QvaW50ZWxfZ3RfcmVxdWVzdHMuaCIKIAogI2luY2x1ZGUgImk5MTVfZHJ2LmgiCmRpZmYg LS1naXQgYS9kcml2ZXJzL2dwdS9kcm0vaTkxNS9pOTE1X2dwdV9lcnJvci5jIGIvZHJpdmVycy9n cHUvZHJtL2k5MTUvaTkxNV9ncHVfZXJyb3IuYwppbmRleCBhMmM1OGI1NGE1OTIuLjBmMDhiY2Zi ZTk2NCAxMDA2NDQKLS0tIGEvZHJpdmVycy9ncHUvZHJtL2k5MTUvaTkxNV9ncHVfZXJyb3IuYwor KysgYi9kcml2ZXJzL2dwdS9kcm0vaTkxNS9pOTE1X2dwdV9lcnJvci5jCkBAIC0xNDI5LDIwICsx NDI5LDM3IEBAIGNhcHR1cmVfZW5naW5lKHN0cnVjdCBpbnRlbF9lbmdpbmVfY3MgKmVuZ2luZSwK IHsKIAlzdHJ1Y3QgaW50ZWxfZW5naW5lX2NhcHR1cmVfdm1hICpjYXB0dXJlID0gTlVMTDsKIAlz dHJ1Y3QgaW50ZWxfZW5naW5lX2NvcmVkdW1wICplZTsKLQlzdHJ1Y3QgaTkxNV9yZXF1ZXN0ICpy cTsKKwlzdHJ1Y3QgaW50ZWxfY29udGV4dCAqY2U7CisJc3RydWN0IGk5MTVfcmVxdWVzdCAqcnEg PSBOVUxMOwogCXVuc2lnbmVkIGxvbmcgZmxhZ3M7CiAKIAllZSA9IGludGVsX2VuZ2luZV9jb3Jl ZHVtcF9hbGxvYyhlbmdpbmUsIEdGUF9LRVJORUwpOwogCWlmICghZWUpCiAJCXJldHVybiBOVUxM OwogCi0Jc3Bpbl9sb2NrX2lycXNhdmUoJmVuZ2luZS0+c2NoZWRfZW5naW5lLT5sb2NrLCBmbGFn cyk7Ci0JcnEgPSBpbnRlbF9lbmdpbmVfZmluZF9hY3RpdmVfcmVxdWVzdChlbmdpbmUpOworCWNl ID0gaW50ZWxfZW5naW5lX2dldF9odW5nX2NvbnRleHQoZW5naW5lKTsKKwlpZiAoY2UpIHsKKwkJ aW50ZWxfZW5naW5lX2NsZWFyX2h1bmdfY29udGV4dChlbmdpbmUpOworCQlycSA9IGludGVsX2Nv bnRleHRfZmluZF9hY3RpdmVfcmVxdWVzdChjZSk7CisJCWlmICghcnEgfHwgIWk5MTVfcmVxdWVz dF9zdGFydGVkKHJxKSkKKwkJCWdvdG8gbm9fcmVxdWVzdF9jYXB0dXJlOworCX0gZWxzZSB7CisJ CS8qCisJCSAqIEdldHRpbmcgaGVyZSB3aXRoIEd1QyBlbmFibGVkIG1lYW5zIGl0IGlzIGEgZm9y Y2VkIGVycm9yIGNhcHR1cmUKKwkJICogd2l0aCBubyBhY3R1YWwgaGFuZy4gU28sIG5vIG5lZWQg dG8gYXR0ZW1wdCB0aGUgZXhlY2xpc3Qgc2VhcmNoLgorCQkgKi8KKwkJaWYgKCFpbnRlbF91Y191 c2VzX2d1Y19zdWJtaXNzaW9uKCZlbmdpbmUtPmd0LT51YykpIHsKKwkJCXNwaW5fbG9ja19pcnFz YXZlKCZlbmdpbmUtPnNjaGVkX2VuZ2luZS0+bG9jaywgZmxhZ3MpOworCQkJcnEgPSBpbnRlbF9l bmdpbmVfZXhlY2xpc3RfZmluZF9odW5nX3JlcXVlc3QoZW5naW5lKTsKKwkJCXNwaW5fdW5sb2Nr X2lycXJlc3RvcmUoJmVuZ2luZS0+c2NoZWRfZW5naW5lLT5sb2NrLAorCQkJCQkgICAgICAgZmxh Z3MpOworCQl9CisJfQogCWlmIChycSkKIAkJY2FwdHVyZSA9IGludGVsX2VuZ2luZV9jb3JlZHVt cF9hZGRfcmVxdWVzdChlZSwgcnEsCiAJCQkJCQkJICAgIEFUT01JQ19NQVlGQUlMKTsKLQlzcGlu X3VubG9ja19pcnFyZXN0b3JlKCZlbmdpbmUtPnNjaGVkX2VuZ2luZS0+bG9jaywgZmxhZ3MpOwog CWlmICghY2FwdHVyZSkgeworbm9fcmVxdWVzdF9jYXB0dXJlOgogCQlrZnJlZShlZSk7CiAJCXJl dHVybiBOVUxMOwogCX0KZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2k5MTVfcmVn LmggYi9kcml2ZXJzL2dwdS9kcm0vaTkxNS9pOTE1X3JlZy5oCmluZGV4IDk0M2ZlNDg1YzY2Mi4u MzU4NGU0ZDAzZGMzIDEwMDY0NAotLS0gYS9kcml2ZXJzL2dwdS9kcm0vaTkxNS9pOTE1X3JlZy5o CisrKyBiL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2k5MTVfcmVnLmgKQEAgLTQxNDIsNiArNDE0Miw3 IEBAIGVudW0gewogCUZBVUxUX0FORF9DT05USU5VRSAvKiBVbnN1cHBvcnRlZCAqLwogfTsKIAor I2RlZmluZSBDVFhfR1RUX0FERFJFU1NfTUFTSyBHRU5NQVNLKDMxLCAxMikKICNkZWZpbmUgR0VO OF9DVFhfVkFMSUQgKDEgPDwgMCkKICNkZWZpbmUgR0VOOF9DVFhfRk9SQ0VfUERfUkVTVE9SRSAo MSA8PCAxKQogI2RlZmluZSBHRU44X0NUWF9GT1JDRV9SRVNUT1JFICgxIDw8IDIpCkBAIC0xMjMw OCw2ICsxMjMwOSw3IEBAIGVudW0gc2tsX3Bvd2VyX2dhdGUgewogCiAvKiBNT0NTIChNZW1vcnkg T2JqZWN0IENvbnRyb2wgU3RhdGUpIHJlZ2lzdGVycyAqLwogI2RlZmluZSBHRU45X0xOQ0ZDTU9D UyhpKQlfTU1JTygweGIwMjAgKyAoaSkgKiA0KQkvKiBMMyBDYWNoZSBDb250cm9sICovCisjZGVm aW5lIEdFTjlfTE5DRkNNT0NTX1JFR19DT1VOVAkzMgogCiAjZGVmaW5lIF9fR0VOOV9SQ1MwX01P Q1MwCTB4YzgwMAogI2RlZmluZSBHRU45X0dGWF9NT0NTKGkpCV9NTUlPKF9fR0VOOV9SQ1MwX01P Q1MwICsgKGkpICogNCkKZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2k5MTVfcmVx dWVzdC5jIGIvZHJpdmVycy9ncHUvZHJtL2k5MTUvaTkxNV9yZXF1ZXN0LmMKaW5kZXggMDllYmVh OWEwMDkwLi4zMjljNjE1OTVmMDIgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2k5 MTVfcmVxdWVzdC5jCisrKyBiL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2k5MTVfcmVxdWVzdC5jCkBA IC0xMTQsNiArMTE0LDkgQEAgc3RhdGljIHZvaWQgaTkxNV9mZW5jZV9yZWxlYXNlKHN0cnVjdCBk bWFfZmVuY2UgKmZlbmNlKQogewogCXN0cnVjdCBpOTE1X3JlcXVlc3QgKnJxID0gdG9fcmVxdWVz dChmZW5jZSk7CiAKKwlHRU1fQlVHX09OKHJxLT5ndWNfcHJpbyAhPSBHVUNfUFJJT19JTklUICYm CisJCSAgIHJxLT5ndWNfcHJpbyAhPSBHVUNfUFJJT19GSU5JKTsKKwogCS8qCiAJICogVGhlIHJl cXVlc3QgaXMgcHV0IG9udG8gYSBSQ1UgZnJlZWxpc3QgKGkuZS4gdGhlIGFkZHJlc3MKIAkgKiBp cyBpbW1lZGlhdGVseSByZXVzZWQpLCBtYXJrIHRoZSBmZW5jZXMgYXMgYmVpbmcgZnJlZWQgbm93 LgpAQCAtMTI1LDM5ICsxMjgsMTcgQEAgc3RhdGljIHZvaWQgaTkxNV9mZW5jZV9yZWxlYXNlKHN0 cnVjdCBkbWFfZmVuY2UgKmZlbmNlKQogCWk5MTVfc3dfZmVuY2VfZmluaSgmcnEtPnNlbWFwaG9y ZSk7CiAKIAkvKgotCSAqIEtlZXAgb25lIHJlcXVlc3Qgb24gZWFjaCBlbmdpbmUgZm9yIHJlc2Vy dmVkIHVzZSB1bmRlciBtZW1wcmVzc3VyZQotCSAqCi0JICogV2UgZG8gbm90IGhvbGQgYSByZWZl cmVuY2UgdG8gdGhlIGVuZ2luZSBoZXJlIGFuZCBzbyBoYXZlIHRvIGJlCi0JICogdmVyeSBjYXJl ZnVsIGluIHdoYXQgcnEtPmVuZ2luZSB3ZSBwb2tlLiBUaGUgdmlydHVhbCBlbmdpbmUgaXMKLQkg KiByZWZlcmVuY2VkIHZpYSB0aGUgcnEtPmNvbnRleHQgYW5kIHdlIHJlbGVhc2VkIHRoYXQgcmVm IGR1cmluZwotCSAqIGk5MTVfcmVxdWVzdF9yZXRpcmUoKSwgZXJnbyB3ZSBtdXN0IG5vdCBkZXJl ZmVyZW5jZSBhIHZpcnR1YWwKLQkgKiBlbmdpbmUgaGVyZS4gTm90IHRoYXQgd2Ugd291bGQgd2Fu dCB0bywgYXMgdGhlIG9ubHkgY29uc3VtZXIgb2YKLQkgKiB0aGUgcmVzZXJ2ZWQgZW5naW5lLT5y ZXF1ZXN0X3Bvb2wgaXMgdGhlIHBvd2VyIG1hbmFnZW1lbnQgcGFya2luZywKLQkgKiB3aGljaCBt dXN0LW5vdC1mYWlsLCBhbmQgdGhhdCBpcyBvbmx5IHJ1biBvbiB0aGUgcGh5c2ljYWwgZW5naW5l cy4KLQkgKgotCSAqIFNpbmNlIHRoZSByZXF1ZXN0IG11c3QgaGF2ZSBiZWVuIGV4ZWN1dGVkIHRv IGJlIGhhdmUgY29tcGxldGVkLAotCSAqIHdlIGtub3cgdGhhdCBpdCB3aWxsIGhhdmUgYmVlbiBw cm9jZXNzZWQgYnkgdGhlIEhXIGFuZCB3aWxsCi0JICogbm90IGJlIHVuc3VibWl0dGVkIGFnYWlu LCBzbyBycS0+ZW5naW5lIGFuZCBycS0+ZXhlY3V0aW9uX21hc2sKLQkgKiBhdCB0aGlzIHBvaW50 IGlzIHN0YWJsZS4gcnEtPmV4ZWN1dGlvbl9tYXNrIHdpbGwgYmUgYSBzaW5nbGUKLQkgKiBiaXQg aWYgdGhlIGxhc3QgYW5kIF9vbmx5XyBlbmdpbmUgaXQgY291bGQgZXhlY3V0aW9uIG9uIHdhcyBh Ci0JICogcGh5c2ljYWwgZW5naW5lLCBpZiBpdCdzIG11bHRpcGxlIGJpdHMgdGhlbiBpdCBzdGFy dGVkIG9uIGFuZAotCSAqIGNvdWxkIHN0aWxsIGJlIG9uIGEgdmlydHVhbCBlbmdpbmUuIFRodXMg aWYgdGhlIG1hc2sgaXMgbm90IGEKLQkgKiBwb3dlci1vZi10d28gd2UgYXNzdW1lIHRoYXQgcnEt PmVuZ2luZSBtYXkgc3RpbGwgYmUgYSB2aXJ0dWFsCi0JICogZW5naW5lIGFuZCBzbyBhIGRhbmds aW5nIGludmFsaWQgcG9pbnRlciB0aGF0IHdlIGNhbm5vdCBkZXJlZmVyZW5jZQotCSAqCi0JICog Rm9yIGV4YW1wbGUsIGNvbnNpZGVyIHRoZSBmbG93IG9mIGEgYm9uZGVkIHJlcXVlc3QgdGhyb3Vn aCBhIHZpcnR1YWwKLQkgKiBlbmdpbmUuIFRoZSByZXF1ZXN0IGlzIGNyZWF0ZWQgd2l0aCBhIHdp ZGUgZW5naW5lIG1hc2sgKGFsbCBlbmdpbmVzCi0JICogdGhhdCB3ZSBtaWdodCBleGVjdXRlIG9u KS4gT24gcHJvY2Vzc2luZyB0aGUgYm9uZCwgdGhlIHJlcXVlc3QgbWFzawotCSAqIGlzIHJlZHVj ZWQgdG8gb25lIG9yIG1vcmUgZW5naW5lcy4gSWYgdGhlIHJlcXVlc3QgaXMgc3Vic2VxdWVudGx5 Ci0JICogYm91bmQgdG8gYSBzaW5nbGUgZW5naW5lLCBpdCB3aWxsIHRoZW4gYmUgY29uc3RyYWlu ZWQgdG8gb25seQotCSAqIGV4ZWN1dGUgb24gdGhhdCBlbmdpbmUgYW5kIG5ldmVyIHJldHVybmVk IHRvIHRoZSB2aXJ0dWFsIGVuZ2luZQotCSAqIGFmdGVyIHRpbWVzbGljaW5nIGF3YXksIHNlZSBf X3Vud2luZF9pbmNvbXBsZXRlX3JlcXVlc3RzKCkuIFRodXMgd2UKLQkgKiBrbm93IHRoYXQgaWYg dGhlIHJxLT5leGVjdXRpb25fbWFzayBpcyBhIHNpbmdsZSBiaXQsIHJxLT5lbmdpbmUKLQkgKiBj YW4gYmUgYSBwaHlzaWNhbCBlbmdpbmUgd2l0aCB0aGUgZXhhY3QgY29ycmVzcG9uZGluZyBtYXNr LgorCSAqIEtlZXAgb25lIHJlcXVlc3Qgb24gZWFjaCBlbmdpbmUgZm9yIHJlc2VydmVkIHVzZSB1 bmRlciBtZW1wcmVzc3VyZSwKKwkgKiBkbyBub3QgdXNlIHdpdGggdmlydHVhbCBlbmdpbmVzIGFz IHRoaXMgcmVhbGx5IGlzIG9ubHkgbmVlZGVkIGZvcgorCSAqIGtlcm5lbCBjb250ZXh0cy4KIAkg Ki8KLQlpZiAoaXNfcG93ZXJfb2ZfMihycS0+ZXhlY3V0aW9uX21hc2spICYmCi0JICAgICFjbXB4 Y2hnKCZycS0+ZW5naW5lLT5yZXF1ZXN0X3Bvb2wsIE5VTEwsIHJxKSkKKwlpZiAoIWludGVsX2Vu Z2luZV9pc192aXJ0dWFsKHJxLT5lbmdpbmUpICYmCisJICAgICFjbXB4Y2hnKCZycS0+ZW5naW5l LT5yZXF1ZXN0X3Bvb2wsIE5VTEwsIHJxKSkgeworCQlpbnRlbF9jb250ZXh0X3B1dChycS0+Y29u dGV4dCk7CiAJCXJldHVybjsKKwl9CisKKwlpbnRlbF9jb250ZXh0X3B1dChycS0+Y29udGV4dCk7 CiAKIAlrbWVtX2NhY2hlX2ZyZWUoZ2xvYmFsLnNsYWJfcmVxdWVzdHMsIHJxKTsKIH0KQEAgLTIw NCw3ICsxODUsNyBAQCBzdGF0aWMgYm9vbCBpcnFfd29ya19pbW0oc3RydWN0IGlycV93b3JrICp3 cmspCiAJcmV0dXJuIGZhbHNlOwogfQogCi1zdGF0aWMgdm9pZCBfX25vdGlmeV9leGVjdXRlX2Ni X2ltbShzdHJ1Y3QgaTkxNV9yZXF1ZXN0ICpycSkKK3ZvaWQgaTkxNV9yZXF1ZXN0X25vdGlmeV9l eGVjdXRlX2NiX2ltbShzdHJ1Y3QgaTkxNV9yZXF1ZXN0ICpycSkKIHsKIAlfX25vdGlmeV9leGVj dXRlX2NiKHJxLCBpcnFfd29ya19pbW0pOwogfQpAQCAtMjc4LDM3ICsyNTksNiBAQCBpOTE1X3Jl cXVlc3RfYWN0aXZlX2VuZ2luZShzdHJ1Y3QgaTkxNV9yZXF1ZXN0ICpycSwKIAlyZXR1cm4gcmV0 OwogfQogCi0KLXN0YXRpYyB2b2lkIHJlbW92ZV9mcm9tX2VuZ2luZShzdHJ1Y3QgaTkxNV9yZXF1 ZXN0ICpycSkKLXsKLQlzdHJ1Y3QgaW50ZWxfZW5naW5lX2NzICplbmdpbmUsICpsb2NrZWQ7Ci0K LQkvKgotCSAqIFZpcnR1YWwgZW5naW5lcyBjb21wbGljYXRlIGFjcXVpcmluZyB0aGUgZW5naW5l IHRpbWVsaW5lIGxvY2ssCi0JICogYXMgdGhlaXIgcnEtPmVuZ2luZSBwb2ludGVyIGlzIG5vdCBz dGFibGUgdW50aWwgdW5kZXIgdGhhdAotCSAqIGVuZ2luZSBsb2NrLiBUaGUgc2ltcGxlIHBsb3kg d2UgdXNlIGlzIHRvIHRha2UgdGhlIGxvY2sgdGhlbgotCSAqIGNoZWNrIHRoYXQgdGhlIHJxIHN0 aWxsIGJlbG9uZ3MgdG8gdGhlIG5ld2x5IGxvY2tlZCBlbmdpbmUuCi0JICovCi0JbG9ja2VkID0g UkVBRF9PTkNFKHJxLT5lbmdpbmUpOwotCXNwaW5fbG9ja19pcnEoJmxvY2tlZC0+c2NoZWRfZW5n aW5lLT5sb2NrKTsKLQl3aGlsZSAodW5saWtlbHkobG9ja2VkICE9IChlbmdpbmUgPSBSRUFEX09O Q0UocnEtPmVuZ2luZSkpKSkgewotCQlzcGluX3VubG9jaygmbG9ja2VkLT5zY2hlZF9lbmdpbmUt PmxvY2spOwotCQlzcGluX2xvY2soJmVuZ2luZS0+c2NoZWRfZW5naW5lLT5sb2NrKTsKLQkJbG9j a2VkID0gZW5naW5lOwotCX0KLQlsaXN0X2RlbF9pbml0KCZycS0+c2NoZWQubGluayk7Ci0KLQlj bGVhcl9iaXQoSTkxNV9GRU5DRV9GTEFHX1BRVUVVRSwgJnJxLT5mZW5jZS5mbGFncyk7Ci0JY2xl YXJfYml0KEk5MTVfRkVOQ0VfRkxBR19IT0xELCAmcnEtPmZlbmNlLmZsYWdzKTsKLQotCS8qIFBy ZXZlbnQgZnVydGhlciBfX2F3YWl0X2V4ZWN1dGlvbigpIHJlZ2lzdGVyaW5nIGEgY2IsIHRoZW4g Zmx1c2ggKi8KLQlzZXRfYml0KEk5MTVfRkVOQ0VfRkxBR19BQ1RJVkUsICZycS0+ZmVuY2UuZmxh Z3MpOwotCi0Jc3Bpbl91bmxvY2tfaXJxKCZsb2NrZWQtPnNjaGVkX2VuZ2luZS0+bG9jayk7Ci0K LQlfX25vdGlmeV9leGVjdXRlX2NiX2ltbShycSk7Ci19Ci0KIHN0YXRpYyB2b2lkIF9fcnFfaW5p dF93YXRjaGRvZyhzdHJ1Y3QgaTkxNV9yZXF1ZXN0ICpycSkKIHsKIAlycS0+d2F0Y2hkb2cudGlt ZXIuZnVuY3Rpb24gPSBOVUxMOwpAQCAtNDA1LDggKzM1NSw3IEBAIGJvb2wgaTkxNV9yZXF1ZXN0 X3JldGlyZShzdHJ1Y3QgaTkxNV9yZXF1ZXN0ICpycSkKIAkgKiBhZnRlciByZW1vdmluZyB0aGUg YnJlYWRjcnVtYiBhbmQgc2lnbmFsaW5nIGl0LCBzbyB0aGF0IHdlIGRvIG5vdAogCSAqIGluYWR2 ZXJ0ZW50bHkgYXR0YWNoIHRoZSBicmVhZGNydW1iIHRvIGEgY29tcGxldGVkIHJlcXVlc3QuCiAJ ICovCi0JaWYgKCFsaXN0X2VtcHR5KCZycS0+c2NoZWQubGluaykpCi0JCXJlbW92ZV9mcm9tX2Vu Z2luZShycSk7CisJcnEtPmVuZ2luZS0+cmVtb3ZlX2FjdGl2ZV9yZXF1ZXN0KHJxKTsKIAlHRU1f QlVHX09OKCFsbGlzdF9lbXB0eSgmcnEtPmV4ZWN1dGVfY2IpKTsKIAogCV9fbGlzdF9kZWxfZW50 cnkoJnJxLT5saW5rKTsgLyogcG9pc29uIG5laXRoZXIgcHJldi9uZXh0IChSQ1Ugd2Fsa3MpICov CkBAIC00MzEsNiArMzgwLDcgQEAgdm9pZCBpOTE1X3JlcXVlc3RfcmV0aXJlX3VwdG8oc3RydWN0 IGk5MTVfcmVxdWVzdCAqcnEpCiAKIAlkbyB7CiAJCXRtcCA9IGxpc3RfZmlyc3RfZW50cnkoJnRs LT5yZXF1ZXN0cywgdHlwZW9mKCp0bXApLCBsaW5rKTsKKwkJR0VNX0JVR19PTighaTkxNV9yZXF1 ZXN0X2NvbXBsZXRlZCh0bXApKTsKIAl9IHdoaWxlIChpOTE1X3JlcXVlc3RfcmV0aXJlKHRtcCkg JiYgdG1wICE9IHJxKTsKIH0KIApAQCAtNTM2LDcgKzQ4Niw3IEBAIF9fYXdhaXRfZXhlY3V0aW9u KHN0cnVjdCBpOTE1X3JlcXVlc3QgKnJxLAogCWlmIChsbGlzdF9hZGQoJmNiLT53b3JrLm5vZGUu bGxpc3QsICZzaWduYWwtPmV4ZWN1dGVfY2IpKSB7CiAJCWlmIChpOTE1X3JlcXVlc3RfaXNfYWN0 aXZlKHNpZ25hbCkgfHwKIAkJICAgIF9fcmVxdWVzdF9pbl9mbGlnaHQoc2lnbmFsKSkKLQkJCV9f bm90aWZ5X2V4ZWN1dGVfY2JfaW1tKHNpZ25hbCk7CisJCQlpOTE1X3JlcXVlc3Rfbm90aWZ5X2V4 ZWN1dGVfY2JfaW1tKHNpZ25hbCk7CiAJfQogCiAJcmV0dXJuIDA7CkBAIC02NjcsMTEgKzYxNywx NSBAQCBib29sIF9faTkxNV9yZXF1ZXN0X3N1Ym1pdChzdHJ1Y3QgaTkxNV9yZXF1ZXN0ICpyZXF1 ZXN0KQogCQkJCSAgICAgcmVxdWVzdC0+cmluZy0+dmFkZHIgKyByZXF1ZXN0LT5wb3N0Zml4KTsK IAogCXRyYWNlX2k5MTVfcmVxdWVzdF9leGVjdXRlKHJlcXVlc3QpOwotCWVuZ2luZS0+c2VyaWFs Kys7CisJaWYgKGVuZ2luZS0+YnVtcF9zZXJpYWwpCisJCWVuZ2luZS0+YnVtcF9zZXJpYWwoZW5n aW5lKTsKKwllbHNlCisJCWVuZ2luZS0+c2VyaWFsKys7CisKIAlyZXN1bHQgPSB0cnVlOwogCiAJ R0VNX0JVR19PTih0ZXN0X2JpdChJOTE1X0ZFTkNFX0ZMQUdfQUNUSVZFLCAmcmVxdWVzdC0+ZmVu Y2UuZmxhZ3MpKTsKLQlsaXN0X21vdmVfdGFpbCgmcmVxdWVzdC0+c2NoZWQubGluaywgJmVuZ2lu ZS0+c2NoZWRfZW5naW5lLT5yZXF1ZXN0cyk7CisJZW5naW5lLT5hZGRfYWN0aXZlX3JlcXVlc3Qo cmVxdWVzdCk7CiBhY3RpdmU6CiAJY2xlYXJfYml0KEk5MTVfRkVOQ0VfRkxBR19QUVVFVUUsICZy ZXF1ZXN0LT5mZW5jZS5mbGFncyk7CiAJc2V0X2JpdChJOTE1X0ZFTkNFX0ZMQUdfQUNUSVZFLCAm cmVxdWVzdC0+ZmVuY2UuZmxhZ3MpOwpAQCAtNzU5LDE4ICs3MTMsNiBAQCB2b2lkIGk5MTVfcmVx dWVzdF91bnN1Ym1pdChzdHJ1Y3QgaTkxNV9yZXF1ZXN0ICpyZXF1ZXN0KQogCXNwaW5fdW5sb2Nr X2lycXJlc3RvcmUoJmVuZ2luZS0+c2NoZWRfZW5naW5lLT5sb2NrLCBmbGFncyk7CiB9CiAKLXN0 YXRpYyB2b2lkIF9fY2FuY2VsX3JlcXVlc3Qoc3RydWN0IGk5MTVfcmVxdWVzdCAqcnEpCi17Ci0J c3RydWN0IGludGVsX2VuZ2luZV9jcyAqZW5naW5lID0gTlVMTDsKLQotCWk5MTVfcmVxdWVzdF9h Y3RpdmVfZW5naW5lKHJxLCAmZW5naW5lKTsKLQotCWlmIChlbmdpbmUgJiYgaW50ZWxfZW5naW5l X3B1bHNlKGVuZ2luZSkpCi0JCWludGVsX2d0X2hhbmRsZV9lcnJvcihlbmdpbmUtPmd0LCBlbmdp bmUtPm1hc2ssIDAsCi0JCQkJICAgICAgInJlcXVlc3QgY2FuY2VsbGF0aW9uIGJ5ICVzIiwKLQkJ CQkgICAgICBjdXJyZW50LT5jb21tKTsKLX0KLQogdm9pZCBpOTE1X3JlcXVlc3RfY2FuY2VsKHN0 cnVjdCBpOTE1X3JlcXVlc3QgKnJxLCBpbnQgZXJyb3IpCiB7CiAJaWYgKCFpOTE1X3JlcXVlc3Rf c2V0X2Vycm9yX29uY2UocnEsIGVycm9yKSkKQEAgLTc3OCw3ICs3MjAsNyBAQCB2b2lkIGk5MTVf cmVxdWVzdF9jYW5jZWwoc3RydWN0IGk5MTVfcmVxdWVzdCAqcnEsIGludCBlcnJvcikKIAogCXNl dF9iaXQoSTkxNV9GRU5DRV9GTEFHX1NFTlRJTkVMLCAmcnEtPmZlbmNlLmZsYWdzKTsKIAotCV9f Y2FuY2VsX3JlcXVlc3QocnEpOworCWludGVsX2NvbnRleHRfY2FuY2VsX3JlcXVlc3QocnEtPmNv bnRleHQsIHJxKTsKIH0KIAogc3RhdGljIGludCBfX2k5MTVfc3dfZmVuY2VfY2FsbApAQCAtOTUw LDcgKzg5MiwxOSBAQCBfX2k5MTVfcmVxdWVzdF9jcmVhdGUoc3RydWN0IGludGVsX2NvbnRleHQg KmNlLCBnZnBfdCBnZnApCiAJCX0KIAl9CiAKLQlycS0+Y29udGV4dCA9IGNlOworCS8qCisJICog SG9sZCBhIHJlZmVyZW5jZSB0byB0aGUgaW50ZWxfY29udGV4dCBvdmVyIGxpZmUgb2YgYW4gaTkx NV9yZXF1ZXN0LgorCSAqIFdpdGhvdXQgdGhpcyBhbiBpOTE1X3JlcXVlc3QgY2FuIGV4aXN0IGFm dGVyIHRoZSBjb250ZXh0IGhhcyBiZWVuCisJICogZGVzdHJveWVkIChlLmcuIHJlcXVlc3QgcmV0 aXJlZCwgY29udGV4dCBjbG9zZWQsIGJ1dCB1c2VyIHNwYWNlIGhvbGRzCisJICogYSByZWZlcmVu Y2UgdG8gdGhlIHJlcXVlc3QgZnJvbSBhbiBvdXQgZmVuY2UpLiBJbiB0aGUgY2FzZSBvZiBHdUMK KwkgKiBzdWJtaXNzaW9uICsgdmlydHVhbCBlbmdpbmUsIHRoZSBlbmdpbmUgdGhhdCB0aGUgcmVx dWVzdCByZWZlcmVuY2VzCisJICogaXMgYWxzbyBkZXN0cm95ZWQgd2hpY2ggY2FuIHRyaWdnZXIg YmFkIHBvaW50ZXIgZHJlZiBpbiBmZW5jZSBvcHMKKwkgKiAoZS5nLiBpOTE1X2ZlbmNlX2dldF9k cml2ZXJfbmFtZSkuIFdlIGNvdWxkIGxpa2VseSBjaGFuZ2UgdGhlc2UKKwkgKiBmdW5jdGlvbnMg dG8gYXZvaWQgdG91Y2hpbmcgdGhlIGVuZ2luZSBidXQgbGV0J3MganVzdCBiZSBzYWZlIGFuZAor CSAqIGhvbGQgdGhlIGludGVsX2NvbnRleHQgcmVmZXJlbmNlLiBJbiBleGVjbGlzdCBtb2RlIHRo ZSByZXF1ZXN0IGFsd2F5cworCSAqIGV2ZW50dWFsbHkgcG9pbnRzIHRvIGEgcGh5c2ljYWwgZW5n aW5lIHNvIHRoaXMgaXNuJ3QgYW4gaXNzdWUuCisJICovCisJcnEtPmNvbnRleHQgPSBpbnRlbF9j b250ZXh0X2dldChjZSk7CiAJcnEtPmVuZ2luZSA9IGNlLT5lbmdpbmU7CiAJcnEtPnJpbmcgPSBj ZS0+cmluZzsKIAlycS0+ZXhlY3V0aW9uX21hc2sgPSBjZS0+ZW5naW5lLT5tYXNrOwpAQCAtOTcz LDYgKzkyNyw4IEBAIF9faTkxNV9yZXF1ZXN0X2NyZWF0ZShzdHJ1Y3QgaW50ZWxfY29udGV4dCAq Y2UsIGdmcF90IGdmcCkKIAogCXJxLT5yY3VzdGF0ZSA9IGdldF9zdGF0ZV9zeW5jaHJvbml6ZV9y Y3UoKTsgLyogYWN0cyBhcyBzbXBfbWIoKSAqLwogCisJcnEtPmd1Y19wcmlvID0gR1VDX1BSSU9f SU5JVDsKKwogCS8qIFdlIGJ1bXAgdGhlIHJlZiBmb3IgdGhlIGZlbmNlIGNoYWluICovCiAJaTkx NV9zd19mZW5jZV9yZWluaXQoJmk5MTVfcmVxdWVzdF9nZXQocnEpLT5zdWJtaXQpOwogCWk5MTVf c3dfZmVuY2VfcmVpbml0KCZpOTE1X3JlcXVlc3RfZ2V0KHJxKS0+c2VtYXBob3JlKTsKQEAgLTEw MjcsNiArOTgzLDcgQEAgX19pOTE1X3JlcXVlc3RfY3JlYXRlKHN0cnVjdCBpbnRlbF9jb250ZXh0 ICpjZSwgZ2ZwX3QgZ2ZwKQogCUdFTV9CVUdfT04oIWxpc3RfZW1wdHkoJnJxLT5zY2hlZC53YWl0 ZXJzX2xpc3QpKTsKIAogZXJyX2ZyZWU6CisJaW50ZWxfY29udGV4dF9wdXQoY2UpOwogCWttZW1f Y2FjaGVfZnJlZShnbG9iYWwuc2xhYl9yZXF1ZXN0cywgcnEpOwogZXJyX3VucmVzZXJ2ZToKIAlp bnRlbF9jb250ZXh0X3VucGluKGNlKTsKQEAgLTEzNzksNiArMTMzNiw5IEBAIGk5MTVfcmVxdWVz dF9hd2FpdF9leHRlcm5hbChzdHJ1Y3QgaTkxNV9yZXF1ZXN0ICpycSwgc3RydWN0IGRtYV9mZW5j ZSAqZmVuY2UpCiAJcmV0dXJuIGVycjsKIH0KIAorc3RhdGljIGludAoraTkxNV9yZXF1ZXN0X2F3 YWl0X3JlcXVlc3Qoc3RydWN0IGk5MTVfcmVxdWVzdCAqdG8sIHN0cnVjdCBpOTE1X3JlcXVlc3Qg KmZyb20pOworCiBpbnQKIGk5MTVfcmVxdWVzdF9hd2FpdF9leGVjdXRpb24oc3RydWN0IGk5MTVf cmVxdWVzdCAqcnEsCiAJCQkgICAgIHN0cnVjdCBkbWFfZmVuY2UgKmZlbmNlKQpAQCAtMTQ2Miw3 ICsxNDIyLDggQEAgaTkxNV9yZXF1ZXN0X2F3YWl0X3JlcXVlc3Qoc3RydWN0IGk5MTVfcmVxdWVz dCAqdG8sIHN0cnVjdCBpOTE1X3JlcXVlc3QgKmZyb20pCiAJCQlyZXR1cm4gcmV0OwogCX0KIAot CWlmIChpc19wb3dlcl9vZl8yKHRvLT5leGVjdXRpb25fbWFzayB8IFJFQURfT05DRShmcm9tLT5l eGVjdXRpb25fbWFzaykpKQorCWlmICghaW50ZWxfZW5naW5lX3VzZXNfZ3VjKHRvLT5lbmdpbmUp ICYmCisJICAgIGlzX3Bvd2VyX29mXzIodG8tPmV4ZWN1dGlvbl9tYXNrIHwgUkVBRF9PTkNFKGZy b20tPmV4ZWN1dGlvbl9tYXNrKSkpCiAJCXJldCA9IGF3YWl0X3JlcXVlc3Rfc3VibWl0KHRvLCBm cm9tKTsKIAllbHNlCiAJCXJldCA9IGVtaXRfc2VtYXBob3JlX3dhaXQodG8sIGZyb20sIEk5MTVf RkVOQ0VfR0ZQKTsKQEAgLTE2MjEsNiArMTU4Miw4IEBAIF9faTkxNV9yZXF1ZXN0X2FkZF90b190 aW1lbGluZShzdHJ1Y3QgaTkxNV9yZXF1ZXN0ICpycSkKIAlwcmV2ID0gdG9fcmVxdWVzdChfX2k5 MTVfYWN0aXZlX2ZlbmNlX3NldCgmdGltZWxpbmUtPmxhc3RfcmVxdWVzdCwKIAkJCQkJCSAgJnJx LT5mZW5jZSkpOwogCWlmIChwcmV2ICYmICFfX2k5MTVfcmVxdWVzdF9pc19jb21wbGV0ZShwcmV2 KSkgeworCQlib29sIHVzZXNfZ3VjID0gaW50ZWxfZW5naW5lX3VzZXNfZ3VjKHJxLT5lbmdpbmUp OworCiAJCS8qCiAJCSAqIFRoZSByZXF1ZXN0cyBhcmUgc3VwcG9zZWQgdG8gYmUga2VwdCBpbiBv cmRlci4gSG93ZXZlciwKIAkJICogd2UgbmVlZCB0byBiZSB3YXJ5IGluIGNhc2UgdGhlIHRpbWVs aW5lLT5sYXN0X3JlcXVlc3QKQEAgLTE2MzEsNyArMTU5NCw4IEBAIF9faTkxNV9yZXF1ZXN0X2Fk ZF90b190aW1lbGluZShzdHJ1Y3QgaTkxNV9yZXF1ZXN0ICpycSkKIAkJCSAgIGk5MTVfc2Vxbm9f cGFzc2VkKHByZXYtPmZlbmNlLnNlcW5vLAogCQkJCQkgICAgIHJxLT5mZW5jZS5zZXFubykpOwog Ci0JCWlmIChpc19wb3dlcl9vZl8yKFJFQURfT05DRShwcmV2LT5lbmdpbmUpLT5tYXNrIHwgcnEt PmVuZ2luZS0+bWFzaykpCisJCWlmICgoIXVzZXNfZ3VjICYmIGlzX3Bvd2VyX29mXzIoUkVBRF9P TkNFKHByZXYtPmVuZ2luZSktPm1hc2sgfCBycS0+ZW5naW5lLT5tYXNrKSkgfHwKKwkJICAgICh1 c2VzX2d1YyAmJiBwcmV2LT5jb250ZXh0ID09IHJxLT5jb250ZXh0KSkKIAkJCWk5MTVfc3dfZmVu Y2VfYXdhaXRfc3dfZmVuY2UoJnJxLT5zdWJtaXQsCiAJCQkJCQkgICAgICZwcmV2LT5zdWJtaXQs CiAJCQkJCQkgICAgICZycS0+c3VibWl0cSk7CkBAIC0yMDcyLDYgKzIwMzYsNDcgQEAgdm9pZCBp OTE1X3JlcXVlc3Rfc2hvdyhzdHJ1Y3QgZHJtX3ByaW50ZXIgKm0sCiAJCSAgIG5hbWUpOwogfQog CitzdGF0aWMgYm9vbCBlbmdpbmVfbWF0Y2hfcmluZyhzdHJ1Y3QgaW50ZWxfZW5naW5lX2NzICpl bmdpbmUsIHN0cnVjdCBpOTE1X3JlcXVlc3QgKnJxKQoreworCXUzMiByaW5nID0gRU5HSU5FX1JF QUQoZW5naW5lLCBSSU5HX1NUQVJUKTsKKworCXJldHVybiByaW5nID09IGk5MTVfZ2d0dF9vZmZz ZXQocnEtPnJpbmctPnZtYSk7Cit9CisKK3N0YXRpYyBib29sIG1hdGNoX3Jpbmcoc3RydWN0IGk5 MTVfcmVxdWVzdCAqcnEpCit7CisJc3RydWN0IGludGVsX2VuZ2luZV9jcyAqZW5naW5lOworCWJv b2wgZm91bmQ7CisJaW50IGk7CisKKwlpZiAoIWludGVsX2VuZ2luZV9pc192aXJ0dWFsKHJxLT5l bmdpbmUpKQorCQlyZXR1cm4gZW5naW5lX21hdGNoX3JpbmcocnEtPmVuZ2luZSwgcnEpOworCisJ Zm91bmQgPSBmYWxzZTsKKwlpID0gMDsKKwl3aGlsZSAoKGVuZ2luZSA9IGludGVsX2VuZ2luZV9n ZXRfc2libGluZyhycS0+ZW5naW5lLCBpKyspKSkgeworCQlmb3VuZCA9IGVuZ2luZV9tYXRjaF9y aW5nKGVuZ2luZSwgcnEpOworCQlpZiAoZm91bmQpCisJCQlicmVhazsKKwl9CisKKwlyZXR1cm4g Zm91bmQ7Cit9CisKK2VudW0gaTkxNV9yZXF1ZXN0X3N0YXRlIGk5MTVfdGVzdF9yZXF1ZXN0X3N0 YXRlKHN0cnVjdCBpOTE1X3JlcXVlc3QgKnJxKQoreworCWlmIChpOTE1X3JlcXVlc3RfY29tcGxl dGVkKHJxKSkKKwkJcmV0dXJuIEk5MTVfUkVRVUVTVF9DT01QTEVURTsKKworCWlmICghaTkxNV9y ZXF1ZXN0X3N0YXJ0ZWQocnEpKQorCQlyZXR1cm4gSTkxNV9SRVFVRVNUX1BFTkRJTkc7CisKKwlp ZiAobWF0Y2hfcmluZyhycSkpCisJCXJldHVybiBJOTE1X1JFUVVFU1RfQUNUSVZFOworCisJcmV0 dXJuIEk5MTVfUkVRVUVTVF9RVUVVRUQ7Cit9CisKICNpZiBJU19FTkFCTEVEKENPTkZJR19EUk1f STkxNV9TRUxGVEVTVCkKICNpbmNsdWRlICJzZWxmdGVzdHMvbW9ja19yZXF1ZXN0LmMiCiAjaW5j bHVkZSAic2VsZnRlc3RzL2k5MTVfcmVxdWVzdC5jIgpkaWZmIC0tZ2l0IGEvZHJpdmVycy9ncHUv ZHJtL2k5MTUvaTkxNV9yZXF1ZXN0LmggYi9kcml2ZXJzL2dwdS9kcm0vaTkxNS9pOTE1X3JlcXVl c3QuaAppbmRleCA1ZGViNjVlYzVmYTUuLmYwNDYzZDE5YzcxMiAxMDA2NDQKLS0tIGEvZHJpdmVy cy9ncHUvZHJtL2k5MTUvaTkxNV9yZXF1ZXN0LmgKKysrIGIvZHJpdmVycy9ncHUvZHJtL2k5MTUv aTkxNV9yZXF1ZXN0LmgKQEAgLTI4NSw2ICsyODUsMjIgQEAgc3RydWN0IGk5MTVfcmVxdWVzdCB7 CiAJCXN0cnVjdCBocnRpbWVyIHRpbWVyOwogCX0gd2F0Y2hkb2c7CiAKKwkvKgorCSAqIFJlcXVl c3RzIG1heSBuZWVkIHRvIGJlIHN0YWxsZWQgd2hlbiB1c2luZyBHdUMgc3VibWlzc2lvbiB3YWl0 aW5nIGZvcgorCSAqIGNlcnRhaW4gR3VDIG9wZXJhdGlvbnMgdG8gY29tcGxldGUuIElmIHRoYXQg aXMgdGhlIGNhc2UsIHN0YWxsZWQKKwkgKiByZXF1ZXN0cyBhcmUgYWRkZWQgdG8gYSBwZXIgY29u dGV4dCBsaXN0IG9mIHN0YWxsZWQgcmVxdWVzdHMuIFRoZQorCSAqIGJlbG93IGxpc3RfaGVhZCBp cyB0aGUgbGluayBpbiB0aGF0IGxpc3QuCisJICovCisJc3RydWN0IGxpc3RfaGVhZCBndWNfZmVu Y2VfbGluazsKKworCS8qKgorCSAqIFByaW9yaXR5IGxldmVsIHdoaWxlIHRoZSByZXF1ZXN0IGlz IGluZmxpZ2h0LiBEaWZmZXJzIHNsaWdodGx5IHRoYW4KKwkgKiBpOTE1IHNjaGVkdWxlciBwcmlv cml0eS4KKwkgKi8KKyNkZWZpbmUJR1VDX1BSSU9fSU5JVAkweGZmCisjZGVmaW5lCUdVQ19QUklP X0ZJTkkJMHhmZQorCXU4IGd1Y19wcmlvOworCiAJSTkxNV9TRUxGVEVTVF9ERUNMQVJFKHN0cnVj dCB7CiAJCXN0cnVjdCBsaXN0X2hlYWQgbGluazsKIAkJdW5zaWduZWQgbG9uZyBkZWxheTsKQEAg LTYzOSw0ICs2NTUsMTcgQEAgYm9vbAogaTkxNV9yZXF1ZXN0X2FjdGl2ZV9lbmdpbmUoc3RydWN0 IGk5MTVfcmVxdWVzdCAqcnEsCiAJCQkgICBzdHJ1Y3QgaW50ZWxfZW5naW5lX2NzICoqYWN0aXZl KTsKIAordm9pZCBpOTE1X3JlcXVlc3Rfbm90aWZ5X2V4ZWN1dGVfY2JfaW1tKHN0cnVjdCBpOTE1 X3JlcXVlc3QgKnJxKTsKKworZW51bSBpOTE1X3JlcXVlc3Rfc3RhdGUKK3sKKwlJOTE1X1JFUVVF U1RfVU5LTk9XTiA9IDAsCisJSTkxNV9SRVFVRVNUX0NPTVBMRVRFLAorCUk5MTVfUkVRVUVTVF9Q RU5ESU5HLAorCUk5MTVfUkVRVUVTVF9RVUVVRUQsCisJSTkxNV9SRVFVRVNUX0FDVElWRSwKK307 CisKK2VudW0gaTkxNV9yZXF1ZXN0X3N0YXRlIGk5MTVfdGVzdF9yZXF1ZXN0X3N0YXRlKHN0cnVj dCBpOTE1X3JlcXVlc3QgKnJxKTsKKwogI2VuZGlmIC8qIEk5MTVfUkVRVUVTVF9IICovCmRpZmYg LS1naXQgYS9kcml2ZXJzL2dwdS9kcm0vaTkxNS9pOTE1X3NjaGVkdWxlci5jIGIvZHJpdmVycy9n cHUvZHJtL2k5MTUvaTkxNV9zY2hlZHVsZXIuYwppbmRleCAzYTU4YTkxMzAzMDkuLjNmY2NhZTM2 NzJjMSAxMDA2NDQKLS0tIGEvZHJpdmVycy9ncHUvZHJtL2k5MTUvaTkxNV9zY2hlZHVsZXIuYwor KysgYi9kcml2ZXJzL2dwdS9kcm0vaTkxNS9pOTE1X3NjaGVkdWxlci5jCkBAIC0yNDEsNiArMjQx LDkgQEAgc3RhdGljIHZvaWQgX19pOTE1X3NjaGVkdWxlKHN0cnVjdCBpOTE1X3NjaGVkX25vZGUg Km5vZGUsCiAJLyogRmlmbyBhbmQgZGVwdGgtZmlyc3QgcmVwbGFjZW1lbnQgZW5zdXJlIG91ciBk ZXBzIGV4ZWN1dGUgYmVmb3JlIHVzICovCiAJc2NoZWRfZW5naW5lID0gbG9ja19zY2hlZF9lbmdp bmUobm9kZSwgc2NoZWRfZW5naW5lLCAmY2FjaGUpOwogCWxpc3RfZm9yX2VhY2hfZW50cnlfc2Fm ZV9yZXZlcnNlKGRlcCwgcCwgJmRmcywgZGZzX2xpbmspIHsKKwkJc3RydWN0IGk5MTVfcmVxdWVz dCAqZnJvbSA9IGNvbnRhaW5lcl9vZihkZXAtPnNpZ25hbGVyLAorCQkJCQkJCSBzdHJ1Y3QgaTkx NV9yZXF1ZXN0LAorCQkJCQkJCSBzY2hlZCk7CiAJCUlOSVRfTElTVF9IRUFEKCZkZXAtPmRmc19s aW5rKTsKIAogCQlub2RlID0gZGVwLT5zaWduYWxlcjsKQEAgLTI1NCw2ICsyNTcsMTAgQEAgc3Rh dGljIHZvaWQgX19pOTE1X3NjaGVkdWxlKHN0cnVjdCBpOTE1X3NjaGVkX25vZGUgKm5vZGUsCiAJ CUdFTV9CVUdfT04obm9kZV90b19yZXF1ZXN0KG5vZGUpLT5lbmdpbmUtPnNjaGVkX2VuZ2luZSAh PQogCQkJICAgc2NoZWRfZW5naW5lKTsKIAorCQkvKiBNdXN0IGJlIGNhbGxlZCBiZWZvcmUgY2hh bmdpbmcgdGhlIG5vZGVzIHByaW9yaXR5ICovCisJCWlmIChzY2hlZF9lbmdpbmUtPmJ1bXBfaW5m bGlnaHRfcmVxdWVzdF9wcmlvKQorCQkJc2NoZWRfZW5naW5lLT5idW1wX2luZmxpZ2h0X3JlcXVl c3RfcHJpbyhmcm9tLCBwcmlvKTsKKwogCQlXUklURV9PTkNFKG5vZGUtPmF0dHIucHJpb3JpdHks IHByaW8pOwogCiAJCS8qCkBAIC00MzEsNyArNDM4LDcgQEAgdm9pZCBpOTE1X3JlcXVlc3Rfc2hv d193aXRoX3NjaGVkdWxlKHN0cnVjdCBkcm1fcHJpbnRlciAqbSwKIAlyY3VfcmVhZF91bmxvY2so KTsKIH0KIAotdm9pZCBpOTE1X3NjaGVkX2VuZ2luZV9mcmVlKHN0cnVjdCBrcmVmICprcmVmKQor c3RhdGljIHZvaWQgZGVmYXVsdF9kZXN0cm95KHN0cnVjdCBrcmVmICprcmVmKQogewogCXN0cnVj dCBpOTE1X3NjaGVkX2VuZ2luZSAqc2NoZWRfZW5naW5lID0KIAkJY29udGFpbmVyX29mKGtyZWYs IHR5cGVvZigqc2NoZWRfZW5naW5lKSwgcmVmKTsKQEAgLTQ0MCw2ICs0NDcsMTEgQEAgdm9pZCBp OTE1X3NjaGVkX2VuZ2luZV9mcmVlKHN0cnVjdCBrcmVmICprcmVmKQogCWtmcmVlKHNjaGVkX2Vu Z2luZSk7CiB9CiAKK3N0YXRpYyBib29sIGRlZmF1bHRfZGlzYWJsZWQoc3RydWN0IGk5MTVfc2No ZWRfZW5naW5lICpzY2hlZF9lbmdpbmUpCit7CisJcmV0dXJuIGZhbHNlOworfQorCiBzdHJ1Y3Qg aTkxNV9zY2hlZF9lbmdpbmUgKgogaTkxNV9zY2hlZF9lbmdpbmVfY3JlYXRlKHVuc2lnbmVkIGlu dCBzdWJjbGFzcykKIHsKQEAgLTQ1Myw2ICs0NjUsOCBAQCBpOTE1X3NjaGVkX2VuZ2luZV9jcmVh dGUodW5zaWduZWQgaW50IHN1YmNsYXNzKQogCiAJc2NoZWRfZW5naW5lLT5xdWV1ZSA9IFJCX1JP T1RfQ0FDSEVEOwogCXNjaGVkX2VuZ2luZS0+cXVldWVfcHJpb3JpdHlfaGludCA9IElOVF9NSU47 CisJc2NoZWRfZW5naW5lLT5kZXN0cm95ID0gZGVmYXVsdF9kZXN0cm95OworCXNjaGVkX2VuZ2lu ZS0+ZGlzYWJsZWQgPSBkZWZhdWx0X2Rpc2FibGVkOwogCiAJSU5JVF9MSVNUX0hFQUQoJnNjaGVk X2VuZ2luZS0+cmVxdWVzdHMpOwogCUlOSVRfTElTVF9IRUFEKCZzY2hlZF9lbmdpbmUtPmhvbGQp OwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJtL2k5MTUvaTkxNV9zY2hlZHVsZXIuaCBiL2Ry aXZlcnMvZ3B1L2RybS9pOTE1L2k5MTVfc2NoZWR1bGVyLmgKaW5kZXggNjUwYWI4ZTBkYjlmLi5m NGQ5ODExYWRlNWIgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2k5MTVfc2NoZWR1 bGVyLmgKKysrIGIvZHJpdmVycy9ncHUvZHJtL2k5MTUvaTkxNV9zY2hlZHVsZXIuaApAQCAtNTEs OCArNTEsNiBAQCBzdGF0aWMgaW5saW5lIHZvaWQgaTkxNV9wcmlvbGlzdF9mcmVlKHN0cnVjdCBp OTE1X3ByaW9saXN0ICpwKQogc3RydWN0IGk5MTVfc2NoZWRfZW5naW5lICoKIGk5MTVfc2NoZWRf ZW5naW5lX2NyZWF0ZSh1bnNpZ25lZCBpbnQgc3ViY2xhc3MpOwogCi12b2lkIGk5MTVfc2NoZWRf ZW5naW5lX2ZyZWUoc3RydWN0IGtyZWYgKmtyZWYpOwotCiBzdGF0aWMgaW5saW5lIHN0cnVjdCBp OTE1X3NjaGVkX2VuZ2luZSAqCiBpOTE1X3NjaGVkX2VuZ2luZV9nZXQoc3RydWN0IGk5MTVfc2No ZWRfZW5naW5lICpzY2hlZF9lbmdpbmUpCiB7CkBAIC02Myw3ICs2MSw3IEBAIGk5MTVfc2NoZWRf ZW5naW5lX2dldChzdHJ1Y3QgaTkxNV9zY2hlZF9lbmdpbmUgKnNjaGVkX2VuZ2luZSkKIHN0YXRp YyBpbmxpbmUgdm9pZAogaTkxNV9zY2hlZF9lbmdpbmVfcHV0KHN0cnVjdCBpOTE1X3NjaGVkX2Vu Z2luZSAqc2NoZWRfZW5naW5lKQogewotCWtyZWZfcHV0KCZzY2hlZF9lbmdpbmUtPnJlZiwgaTkx NV9zY2hlZF9lbmdpbmVfZnJlZSk7CisJa3JlZl9wdXQoJnNjaGVkX2VuZ2luZS0+cmVmLCBzY2hl ZF9lbmdpbmUtPmRlc3Ryb3kpOwogfQogCiBzdGF0aWMgaW5saW5lIGJvb2wKQEAgLTk4LDQgKzk2 LDEwIEBAIHZvaWQgaTkxNV9yZXF1ZXN0X3Nob3dfd2l0aF9zY2hlZHVsZShzdHJ1Y3QgZHJtX3By aW50ZXIgKm0sCiAJCQkJICAgICBjb25zdCBjaGFyICpwcmVmaXgsCiAJCQkJICAgICBpbnQgaW5k ZW50KTsKIAorc3RhdGljIGlubGluZSBib29sCitpOTE1X3NjaGVkX2VuZ2luZV9kaXNhYmxlZChz dHJ1Y3QgaTkxNV9zY2hlZF9lbmdpbmUgKnNjaGVkX2VuZ2luZSkKK3sKKwlyZXR1cm4gc2NoZWRf ZW5naW5lLT5kaXNhYmxlZChzY2hlZF9lbmdpbmUpOworfQorCiAjZW5kaWYgLyogX0k5MTVfU0NI RURVTEVSX0hfICovCmRpZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9kcm0vaTkxNS9pOTE1X3NjaGVk dWxlcl90eXBlcy5oIGIvZHJpdmVycy9ncHUvZHJtL2k5MTUvaTkxNV9zY2hlZHVsZXJfdHlwZXMu aAppbmRleCA1OTM1YzMxNTJiZGMuLmIwYTFiNThjNzg5MyAxMDA2NDQKLS0tIGEvZHJpdmVycy9n cHUvZHJtL2k5MTUvaTkxNV9zY2hlZHVsZXJfdHlwZXMuaAorKysgYi9kcml2ZXJzL2dwdS9kcm0v aTkxNS9pOTE1X3NjaGVkdWxlcl90eXBlcy5oCkBAIC0xNjMsMTIgKzE2MywzNCBAQCBzdHJ1Y3Qg aTkxNV9zY2hlZF9lbmdpbmUgewogCSAqLwogCXZvaWQgKnByaXZhdGVfZGF0YTsKIAorCS8qKgor CSAqIEBkZXN0cm95OiBkZXN0cm95IHNjaGVkdWxlIGVuZ2luZSAvIGNsZWFudXAgaW4gYmFja2Vu ZAorCSAqLworCXZvaWQJKCpkZXN0cm95KShzdHJ1Y3Qga3JlZiAqa3JlZik7CisKKwkvKioKKwkg KiBAZGlzYWJsZWQ6IGNoZWNrIGlmIGJhY2tlbmQgaGFzIGRpc2FibGVkIHN1Ym1pc3Npb24KKwkg Ki8KKwlib29sCSgqZGlzYWJsZWQpKHN0cnVjdCBpOTE1X3NjaGVkX2VuZ2luZSAqc2NoZWRfZW5n aW5lKTsKKwogCS8qKgogCSAqIEBraWNrX2JhY2tlbmQ6IGtpY2sgYmFja2VuZCBhZnRlciBhIHJl cXVlc3QncyBwcmlvcml0eSBoYXMgY2hhbmdlZAogCSAqLwogCXZvaWQJKCpraWNrX2JhY2tlbmQp KGNvbnN0IHN0cnVjdCBpOTE1X3JlcXVlc3QgKnJxLAogCQkJCWludCBwcmlvKTsKIAorCS8qKgor CSAqIEBidW1wX2luZmxpZ2h0X3JlcXVlc3RfcHJpbzogdXBkYXRlIHByaW9yaXR5IG9mIGFuIGlu ZmxpZ2h0IHJlcXVlc3QKKwkgKi8KKwl2b2lkCSgqYnVtcF9pbmZsaWdodF9yZXF1ZXN0X3ByaW8p KHN0cnVjdCBpOTE1X3JlcXVlc3QgKnJxLAorCQkJCQkgICAgICBpbnQgcHJpbyk7CisKKwkvKioK KwkgKiBAcmV0aXJlX2luZmxpZ2h0X3JlcXVlc3RfcHJpbzogaW5kaWNhdGUgcmVxdWVzdCBpcyBy ZXRpcmVkIHRvCisJICogcHJpb3JpdHkgdHJhY2tpbmcKKwkgKi8KKwl2b2lkCSgqcmV0aXJlX2lu ZmxpZ2h0X3JlcXVlc3RfcHJpbykoc3RydWN0IGk5MTVfcmVxdWVzdCAqcnEpOworCiAJLyoqCiAJ ICogQHNjaGVkdWxlOiBhZGp1c3QgcHJpb3JpdHkgb2YgcmVxdWVzdAogCSAqCmRpZmYgLS1naXQg YS9kcml2ZXJzL2dwdS9kcm0vaTkxNS9pOTE1X3RyYWNlLmggYi9kcml2ZXJzL2dwdS9kcm0vaTkx NS9pOTE1X3RyYWNlLmgKaW5kZXggNjc3OGFkMmExNGE0Li5mYjM3NmU4MDQxYWUgMTAwNjQ0Ci0t LSBhL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2k5MTVfdHJhY2UuaAorKysgYi9kcml2ZXJzL2dwdS9k cm0vaTkxNS9pOTE1X3RyYWNlLmgKQEAgLTc5NCwzMCArNzk0LDQwIEBAIERFQ0xBUkVfRVZFTlRf Q0xBU1MoaTkxNV9yZXF1ZXN0LAogCSAgICBUUF9TVFJVQ1RfX2VudHJ5KAogCQkJICAgICBfX2Zp ZWxkKHUzMiwgZGV2KQogCQkJICAgICBfX2ZpZWxkKHU2NCwgY3R4KQorCQkJICAgICBfX2ZpZWxk KHUzMiwgZ3VjX2lkKQogCQkJICAgICBfX2ZpZWxkKHUxNiwgY2xhc3MpCiAJCQkgICAgIF9fZmll bGQodTE2LCBpbnN0YW5jZSkKIAkJCSAgICAgX19maWVsZCh1MzIsIHNlcW5vKQorCQkJICAgICBf X2ZpZWxkKHUzMiwgdGFpbCkKIAkJCSAgICAgKSwKIAogCSAgICBUUF9mYXN0X2Fzc2lnbigKIAkJ CSAgIF9fZW50cnktPmRldiA9IHJxLT5lbmdpbmUtPmk5MTUtPmRybS5wcmltYXJ5LT5pbmRleDsK IAkJCSAgIF9fZW50cnktPmNsYXNzID0gcnEtPmVuZ2luZS0+dWFiaV9jbGFzczsKIAkJCSAgIF9f ZW50cnktPmluc3RhbmNlID0gcnEtPmVuZ2luZS0+dWFiaV9pbnN0YW5jZTsKKwkJCSAgIF9fZW50 cnktPmd1Y19pZCA9IHJxLT5jb250ZXh0LT5ndWNfaWQ7CiAJCQkgICBfX2VudHJ5LT5jdHggPSBy cS0+ZmVuY2UuY29udGV4dDsKIAkJCSAgIF9fZW50cnktPnNlcW5vID0gcnEtPmZlbmNlLnNlcW5v OworCQkJICAgX19lbnRyeS0+dGFpbCA9IHJxLT50YWlsOwogCQkJICAgKSwKIAotCSAgICBUUF9w cmludGsoImRldj0ldSwgZW5naW5lPSV1OiV1LCBjdHg9JWxsdSwgc2Vxbm89JXUiLAorCSAgICBU UF9wcmludGsoImRldj0ldSwgZW5naW5lPSV1OiV1LCBndWNfaWQ9JXUsIGN0eD0lbGx1LCBzZXFu bz0ldSwgdGFpbD0ldSIsCiAJCSAgICAgIF9fZW50cnktPmRldiwgX19lbnRyeS0+Y2xhc3MsIF9f ZW50cnktPmluc3RhbmNlLAotCQkgICAgICBfX2VudHJ5LT5jdHgsIF9fZW50cnktPnNlcW5vKQor CQkgICAgICBfX2VudHJ5LT5ndWNfaWQsIF9fZW50cnktPmN0eCwgX19lbnRyeS0+c2Vxbm8sCisJ CSAgICAgIF9fZW50cnktPnRhaWwpCiApOwogCiBERUZJTkVfRVZFTlQoaTkxNV9yZXF1ZXN0LCBp OTE1X3JlcXVlc3RfYWRkLAotCSAgICBUUF9QUk9UTyhzdHJ1Y3QgaTkxNV9yZXF1ZXN0ICpycSks Ci0JICAgIFRQX0FSR1MocnEpCisJICAgICBUUF9QUk9UTyhzdHJ1Y3QgaTkxNV9yZXF1ZXN0ICpy cSksCisJICAgICBUUF9BUkdTKHJxKQogKTsKIAogI2lmIGRlZmluZWQoQ09ORklHX0RSTV9JOTE1 X0xPV19MRVZFTF9UUkFDRVBPSU5UUykKK0RFRklORV9FVkVOVChpOTE1X3JlcXVlc3QsIGk5MTVf cmVxdWVzdF9ndWNfc3VibWl0LAorCSAgICAgVFBfUFJPVE8oc3RydWN0IGk5MTVfcmVxdWVzdCAq cnEpLAorCSAgICAgVFBfQVJHUyhycSkKKyk7CisKIERFRklORV9FVkVOVChpOTE1X3JlcXVlc3Qs IGk5MTVfcmVxdWVzdF9zdWJtaXQsCiAJICAgICBUUF9QUk9UTyhzdHJ1Y3QgaTkxNV9yZXF1ZXN0 ICpycSksCiAJICAgICBUUF9BUkdTKHJxKQpAQCAtODg1LDggKzg5NSwxMTQgQEAgVFJBQ0VfRVZF TlQoaTkxNV9yZXF1ZXN0X291dCwKIAkJCSAgICAgIF9fZW50cnktPmN0eCwgX19lbnRyeS0+c2Vx bm8sIF9fZW50cnktPmNvbXBsZXRlZCkKICk7CiAKK0RFQ0xBUkVfRVZFTlRfQ0xBU1MoaW50ZWxf Y29udGV4dCwKKwkgICAgVFBfUFJPVE8oc3RydWN0IGludGVsX2NvbnRleHQgKmNlKSwKKwkgICAg VFBfQVJHUyhjZSksCisKKwkgICAgVFBfU1RSVUNUX19lbnRyeSgKKwkJCSAgICAgX19maWVsZCh1 MzIsIGd1Y19pZCkKKwkJCSAgICAgX19maWVsZChpbnQsIHBpbl9jb3VudCkKKwkJCSAgICAgX19m aWVsZCh1MzIsIHNjaGVkX3N0YXRlKQorCQkJICAgICBfX2ZpZWxkKHUzMiwgZ3VjX3NjaGVkX3N0 YXRlX25vX2xvY2spCisJCQkgICAgIF9fZmllbGQodTgsIGd1Y19wcmlvKQorCQkJICAgICApLAor CisJICAgIFRQX2Zhc3RfYXNzaWduKAorCQkJICAgX19lbnRyeS0+Z3VjX2lkID0gY2UtPmd1Y19p ZDsKKwkJCSAgIF9fZW50cnktPnBpbl9jb3VudCA9IGF0b21pY19yZWFkKCZjZS0+cGluX2NvdW50 KTsKKwkJCSAgIF9fZW50cnktPnNjaGVkX3N0YXRlID0gY2UtPmd1Y19zdGF0ZS5zY2hlZF9zdGF0 ZTsKKwkJCSAgIF9fZW50cnktPmd1Y19zY2hlZF9zdGF0ZV9ub19sb2NrID0KKwkJCSAgIGF0b21p Y19yZWFkKCZjZS0+Z3VjX3NjaGVkX3N0YXRlX25vX2xvY2spOworCQkJICAgX19lbnRyeS0+Z3Vj X3ByaW8gPSBjZS0+Z3VjX3ByaW87CisJCQkgICApLAorCisJICAgIFRQX3ByaW50aygiZ3VjX2lk PSVkLCBwaW5fY291bnQ9JWQgc2NoZWRfc3RhdGU9MHgleCwweCV4LCBndWNfcHJpbz0ldSIsCisJ CSAgICAgIF9fZW50cnktPmd1Y19pZCwgX19lbnRyeS0+cGluX2NvdW50LCBfX2VudHJ5LT5zY2hl ZF9zdGF0ZSwKKwkJICAgICAgX19lbnRyeS0+Z3VjX3NjaGVkX3N0YXRlX25vX2xvY2ssIF9fZW50 cnktPmd1Y19wcmlvKQorKTsKKworREVGSU5FX0VWRU5UKGludGVsX2NvbnRleHQsIGludGVsX2Nv bnRleHRfc2V0X3ByaW8sCisJICAgICBUUF9QUk9UTyhzdHJ1Y3QgaW50ZWxfY29udGV4dCAqY2Up LAorCSAgICAgVFBfQVJHUyhjZSkKKyk7CisKK0RFRklORV9FVkVOVChpbnRlbF9jb250ZXh0LCBp bnRlbF9jb250ZXh0X3Jlc2V0LAorCSAgICAgVFBfUFJPVE8oc3RydWN0IGludGVsX2NvbnRleHQg KmNlKSwKKwkgICAgIFRQX0FSR1MoY2UpCispOworCitERUZJTkVfRVZFTlQoaW50ZWxfY29udGV4 dCwgaW50ZWxfY29udGV4dF9iYW4sCisJICAgICBUUF9QUk9UTyhzdHJ1Y3QgaW50ZWxfY29udGV4 dCAqY2UpLAorCSAgICAgVFBfQVJHUyhjZSkKKyk7CisKK0RFRklORV9FVkVOVChpbnRlbF9jb250 ZXh0LCBpbnRlbF9jb250ZXh0X3JlZ2lzdGVyLAorCSAgICAgVFBfUFJPVE8oc3RydWN0IGludGVs X2NvbnRleHQgKmNlKSwKKwkgICAgIFRQX0FSR1MoY2UpCispOworCitERUZJTkVfRVZFTlQoaW50 ZWxfY29udGV4dCwgaW50ZWxfY29udGV4dF9kZXJlZ2lzdGVyLAorCSAgICAgVFBfUFJPVE8oc3Ry dWN0IGludGVsX2NvbnRleHQgKmNlKSwKKwkgICAgIFRQX0FSR1MoY2UpCispOworCitERUZJTkVf RVZFTlQoaW50ZWxfY29udGV4dCwgaW50ZWxfY29udGV4dF9kZXJlZ2lzdGVyX2RvbmUsCisJICAg ICBUUF9QUk9UTyhzdHJ1Y3QgaW50ZWxfY29udGV4dCAqY2UpLAorCSAgICAgVFBfQVJHUyhjZSkK Kyk7CisKK0RFRklORV9FVkVOVChpbnRlbF9jb250ZXh0LCBpbnRlbF9jb250ZXh0X3NjaGVkX2Vu YWJsZSwKKwkgICAgIFRQX1BST1RPKHN0cnVjdCBpbnRlbF9jb250ZXh0ICpjZSksCisJICAgICBU UF9BUkdTKGNlKQorKTsKKworREVGSU5FX0VWRU5UKGludGVsX2NvbnRleHQsIGludGVsX2NvbnRl eHRfc2NoZWRfZGlzYWJsZSwKKwkgICAgIFRQX1BST1RPKHN0cnVjdCBpbnRlbF9jb250ZXh0ICpj ZSksCisJICAgICBUUF9BUkdTKGNlKQorKTsKKworREVGSU5FX0VWRU5UKGludGVsX2NvbnRleHQs IGludGVsX2NvbnRleHRfc2NoZWRfZG9uZSwKKwkgICAgIFRQX1BST1RPKHN0cnVjdCBpbnRlbF9j b250ZXh0ICpjZSksCisJICAgICBUUF9BUkdTKGNlKQorKTsKKworREVGSU5FX0VWRU5UKGludGVs X2NvbnRleHQsIGludGVsX2NvbnRleHRfY3JlYXRlLAorCSAgICAgVFBfUFJPVE8oc3RydWN0IGlu dGVsX2NvbnRleHQgKmNlKSwKKwkgICAgIFRQX0FSR1MoY2UpCispOworCitERUZJTkVfRVZFTlQo aW50ZWxfY29udGV4dCwgaW50ZWxfY29udGV4dF9mZW5jZV9yZWxlYXNlLAorCSAgICAgVFBfUFJP VE8oc3RydWN0IGludGVsX2NvbnRleHQgKmNlKSwKKwkgICAgIFRQX0FSR1MoY2UpCispOworCitE RUZJTkVfRVZFTlQoaW50ZWxfY29udGV4dCwgaW50ZWxfY29udGV4dF9mcmVlLAorCSAgICAgVFBf UFJPVE8oc3RydWN0IGludGVsX2NvbnRleHQgKmNlKSwKKwkgICAgIFRQX0FSR1MoY2UpCispOwor CitERUZJTkVfRVZFTlQoaW50ZWxfY29udGV4dCwgaW50ZWxfY29udGV4dF9zdGVhbF9ndWNfaWQs CisJICAgICBUUF9QUk9UTyhzdHJ1Y3QgaW50ZWxfY29udGV4dCAqY2UpLAorCSAgICAgVFBfQVJH UyhjZSkKKyk7CisKK0RFRklORV9FVkVOVChpbnRlbF9jb250ZXh0LCBpbnRlbF9jb250ZXh0X2Rv X3BpbiwKKwkgICAgIFRQX1BST1RPKHN0cnVjdCBpbnRlbF9jb250ZXh0ICpjZSksCisJICAgICBU UF9BUkdTKGNlKQorKTsKKworREVGSU5FX0VWRU5UKGludGVsX2NvbnRleHQsIGludGVsX2NvbnRl eHRfZG9fdW5waW4sCisJICAgICBUUF9QUk9UTyhzdHJ1Y3QgaW50ZWxfY29udGV4dCAqY2UpLAor CSAgICAgVFBfQVJHUyhjZSkKKyk7CisKICNlbHNlCiAjaWYgIWRlZmluZWQoVFJBQ0VfSEVBREVS X01VTFRJX1JFQUQpCitzdGF0aWMgaW5saW5lIHZvaWQKK3RyYWNlX2k5MTVfcmVxdWVzdF9ndWNf c3VibWl0KHN0cnVjdCBpOTE1X3JlcXVlc3QgKnJxKQoreworfQorCiBzdGF0aWMgaW5saW5lIHZv aWQKIHRyYWNlX2k5MTVfcmVxdWVzdF9zdWJtaXQoc3RydWN0IGk5MTVfcmVxdWVzdCAqcnEpCiB7 CkBAIC05MDYsNiArMTAyMiw4MSBAQCBzdGF0aWMgaW5saW5lIHZvaWQKIHRyYWNlX2k5MTVfcmVx dWVzdF9vdXQoc3RydWN0IGk5MTVfcmVxdWVzdCAqcnEpCiB7CiB9CisKK3N0YXRpYyBpbmxpbmUg dm9pZAordHJhY2VfaW50ZWxfY29udGV4dF9zZXRfcHJpbyhzdHJ1Y3QgaW50ZWxfY29udGV4dCAq Y2UpCit7Cit9CisKK3N0YXRpYyBpbmxpbmUgdm9pZAordHJhY2VfaW50ZWxfY29udGV4dF9yZXNl dChzdHJ1Y3QgaW50ZWxfY29udGV4dCAqY2UpCit7Cit9CisKK3N0YXRpYyBpbmxpbmUgdm9pZAor dHJhY2VfaW50ZWxfY29udGV4dF9iYW4oc3RydWN0IGludGVsX2NvbnRleHQgKmNlKQoreworfQor CitzdGF0aWMgaW5saW5lIHZvaWQKK3RyYWNlX2ludGVsX2NvbnRleHRfcmVnaXN0ZXIoc3RydWN0 IGludGVsX2NvbnRleHQgKmNlKQoreworfQorCitzdGF0aWMgaW5saW5lIHZvaWQKK3RyYWNlX2lu dGVsX2NvbnRleHRfZGVyZWdpc3RlcihzdHJ1Y3QgaW50ZWxfY29udGV4dCAqY2UpCit7Cit9CisK K3N0YXRpYyBpbmxpbmUgdm9pZAordHJhY2VfaW50ZWxfY29udGV4dF9kZXJlZ2lzdGVyX2RvbmUo c3RydWN0IGludGVsX2NvbnRleHQgKmNlKQoreworfQorCitzdGF0aWMgaW5saW5lIHZvaWQKK3Ry YWNlX2ludGVsX2NvbnRleHRfc2NoZWRfZW5hYmxlKHN0cnVjdCBpbnRlbF9jb250ZXh0ICpjZSkK K3sKK30KKworc3RhdGljIGlubGluZSB2b2lkCit0cmFjZV9pbnRlbF9jb250ZXh0X3NjaGVkX2Rp c2FibGUoc3RydWN0IGludGVsX2NvbnRleHQgKmNlKQoreworfQorCitzdGF0aWMgaW5saW5lIHZv aWQKK3RyYWNlX2ludGVsX2NvbnRleHRfc2NoZWRfZG9uZShzdHJ1Y3QgaW50ZWxfY29udGV4dCAq Y2UpCit7Cit9CisKK3N0YXRpYyBpbmxpbmUgdm9pZAordHJhY2VfaW50ZWxfY29udGV4dF9jcmVh dGUoc3RydWN0IGludGVsX2NvbnRleHQgKmNlKQoreworfQorCitzdGF0aWMgaW5saW5lIHZvaWQK K3RyYWNlX2ludGVsX2NvbnRleHRfZmVuY2VfcmVsZWFzZShzdHJ1Y3QgaW50ZWxfY29udGV4dCAq Y2UpCit7Cit9CisKK3N0YXRpYyBpbmxpbmUgdm9pZAordHJhY2VfaW50ZWxfY29udGV4dF9mcmVl KHN0cnVjdCBpbnRlbF9jb250ZXh0ICpjZSkKK3sKK30KKworc3RhdGljIGlubGluZSB2b2lkCit0 cmFjZV9pbnRlbF9jb250ZXh0X3N0ZWFsX2d1Y19pZChzdHJ1Y3QgaW50ZWxfY29udGV4dCAqY2Up Cit7Cit9CisKK3N0YXRpYyBpbmxpbmUgdm9pZAordHJhY2VfaW50ZWxfY29udGV4dF9kb19waW4o c3RydWN0IGludGVsX2NvbnRleHQgKmNlKQoreworfQorCitzdGF0aWMgaW5saW5lIHZvaWQKK3Ry YWNlX2ludGVsX2NvbnRleHRfZG9fdW5waW4oc3RydWN0IGludGVsX2NvbnRleHQgKmNlKQorewor fQogI2VuZGlmCiAjZW5kaWYKIApkaWZmIC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJtL2k5MTUvc2Vs ZnRlc3RzL2k5MTVfcmVxdWVzdC5jIGIvZHJpdmVycy9ncHUvZHJtL2k5MTUvc2VsZnRlc3RzL2k5 MTVfcmVxdWVzdC5jCmluZGV4IGJkNWM5NmE3N2JhMy4uZDY3NzEwZDEwNjE1IDEwMDY0NAotLS0g YS9kcml2ZXJzL2dwdS9kcm0vaTkxNS9zZWxmdGVzdHMvaTkxNV9yZXF1ZXN0LmMKKysrIGIvZHJp dmVycy9ncHUvZHJtL2k5MTUvc2VsZnRlc3RzL2k5MTVfcmVxdWVzdC5jCkBAIC0xMzEzLDcgKzEz MTMsNyBAQCBzdGF0aWMgaW50IF9fbGl2ZV9wYXJhbGxlbF9lbmdpbmUxKHZvaWQgKmFyZykKIAkJ aTkxNV9yZXF1ZXN0X2FkZChycSk7CiAKIAkJZXJyID0gMDsKLQkJaWYgKGk5MTVfcmVxdWVzdF93 YWl0KHJxLCAwLCBIWiAvIDUpIDwgMCkKKwkJaWYgKGk5MTVfcmVxdWVzdF93YWl0KHJxLCAwLCBI WikgPCAwKQogCQkJZXJyID0gLUVUSU1FOwogCQlpOTE1X3JlcXVlc3RfcHV0KHJxKTsKIAkJaWYg KGVycikKQEAgLTE0MTksNyArMTQxOSw3IEBAIHN0YXRpYyBpbnQgX19saXZlX3BhcmFsbGVsX3Nw aW4odm9pZCAqYXJnKQogCX0KIAlpZ3Rfc3Bpbm5lcl9lbmQoJnNwaW4pOwogCi0JaWYgKGVyciA9 PSAwICYmIGk5MTVfcmVxdWVzdF93YWl0KHJxLCAwLCBIWiAvIDUpIDwgMCkKKwlpZiAoZXJyID09 IDAgJiYgaTkxNV9yZXF1ZXN0X3dhaXQocnEsIDAsIEhaKSA8IDApCiAJCWVyciA9IC1FSU87CiAJ aTkxNV9yZXF1ZXN0X3B1dChycSk7CiAKZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2RybS9pOTE1 L3NlbGZ0ZXN0cy9pZ3RfZmx1c2hfdGVzdC5jIGIvZHJpdmVycy9ncHUvZHJtL2k5MTUvc2VsZnRl c3RzL2lndF9mbHVzaF90ZXN0LmMKaW5kZXggN2IwOTM5ZTNmMDA3Li5hNmM3MWZjYTYxYWEgMTAw NjQ0Ci0tLSBhL2RyaXZlcnMvZ3B1L2RybS9pOTE1L3NlbGZ0ZXN0cy9pZ3RfZmx1c2hfdGVzdC5j CisrKyBiL2RyaXZlcnMvZ3B1L2RybS9pOTE1L3NlbGZ0ZXN0cy9pZ3RfZmx1c2hfdGVzdC5jCkBA IC0xOSw3ICsxOSw3IEBAIGludCBpZ3RfZmx1c2hfdGVzdChzdHJ1Y3QgZHJtX2k5MTVfcHJpdmF0 ZSAqaTkxNSkKIAogCWNvbmRfcmVzY2hlZCgpOwogCi0JaWYgKGludGVsX2d0X3dhaXRfZm9yX2lk bGUoZ3QsIEhaIC8gNSkgPT0gLUVUSU1FKSB7CisJaWYgKGludGVsX2d0X3dhaXRfZm9yX2lkbGUo Z3QsIEhaKSA9PSAtRVRJTUUpIHsKIAkJcHJfZXJyKCIlcFMgdGltZWQgb3V0LCBjYW5jZWxsaW5n IGFsbCBmdXJ0aGVyIHRlc3RpbmcuXG4iLAogCQkgICAgICAgX19idWlsdGluX3JldHVybl9hZGRy ZXNzKDApKTsKIApkaWZmIC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJtL2k5MTUvc2VsZnRlc3RzL2ln dF9saXZlX3Rlc3QuYyBiL2RyaXZlcnMvZ3B1L2RybS9pOTE1L3NlbGZ0ZXN0cy9pZ3RfbGl2ZV90 ZXN0LmMKaW5kZXggYzEzMDAxMGE3MDMzLi4xYzcyMTU0MmUyNzcgMTAwNjQ0Ci0tLSBhL2RyaXZl cnMvZ3B1L2RybS9pOTE1L3NlbGZ0ZXN0cy9pZ3RfbGl2ZV90ZXN0LmMKKysrIGIvZHJpdmVycy9n cHUvZHJtL2k5MTUvc2VsZnRlc3RzL2lndF9saXZlX3Rlc3QuYwpAQCAtNSw3ICs1LDcgQEAKICAq LwogCiAjaW5jbHVkZSAiaTkxNV9kcnYuaCIKLSNpbmNsdWRlICJndC9pbnRlbF9ndF9yZXF1ZXN0 cy5oIgorI2luY2x1ZGUgImd0L2ludGVsX2d0LmgiCiAKICNpbmNsdWRlICIuLi9pOTE1X3NlbGZ0 ZXN0LmgiCiAjaW5jbHVkZSAiaWd0X2ZsdXNoX3Rlc3QuaCIKZGlmZiAtLWdpdCBhL2RyaXZlcnMv Z3B1L2RybS9pOTE1L3NlbGZ0ZXN0cy9pbnRlbF9zY2hlZHVsZXJfaGVscGVycy5jIGIvZHJpdmVy cy9ncHUvZHJtL2k5MTUvc2VsZnRlc3RzL2ludGVsX3NjaGVkdWxlcl9oZWxwZXJzLmMKbmV3IGZp bGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwLi5lYmQ2ZDY5YjMzMTUKLS0tIC9kZXYv bnVsbAorKysgYi9kcml2ZXJzL2dwdS9kcm0vaTkxNS9zZWxmdGVzdHMvaW50ZWxfc2NoZWR1bGVy X2hlbHBlcnMuYwpAQCAtMCwwICsxLDg5IEBACisvKgorICogU1BEWC1MaWNlbnNlLUlkZW50aWZp ZXI6IE1JVAorICoKKyAqIENvcHlyaWdodCDCqSAyMDE4IEludGVsIENvcnBvcmF0aW9uCisgKi8K KworLy8jaW5jbHVkZSAiZ3QvaW50ZWxfZW5naW5lX3VzZXIuaCIKKyNpbmNsdWRlICJndC9pbnRl bF9ndC5oIgorI2luY2x1ZGUgImk5MTVfZHJ2LmgiCisjaW5jbHVkZSAiaTkxNV9zZWxmdGVzdC5o IgorCisjaW5jbHVkZSAic2VsZnRlc3RzL2ludGVsX3NjaGVkdWxlcl9oZWxwZXJzLmgiCisKKyNk ZWZpbmUgUkVEVUNFRF9USU1FU0xJQ0UJNQorI2RlZmluZSBSRURVQ0VEX1BSRUVNUFQJCTEwCisj ZGVmaW5lIFdBSVRfRk9SX1JFU0VUX1RJTUUJMTAwMDAKKworaW50IGludGVsX3NlbGZ0ZXN0X21v ZGlmeV9wb2xpY3koc3RydWN0IGludGVsX2VuZ2luZV9jcyAqZW5naW5lLAorCQkJCSBzdHJ1Y3Qg aW50ZWxfc2VsZnRlc3Rfc2F2ZWRfcG9saWN5ICpzYXZlZCwKKwkJCQkgdTMyIG1vZGlmeV90eXBl KQorCit7CisJaW50IGVycjsKKworCXNhdmVkLT5yZXNldCA9IGVuZ2luZS0+aTkxNS0+cGFyYW1z LnJlc2V0OworCXNhdmVkLT5mbGFncyA9IGVuZ2luZS0+ZmxhZ3M7CisJc2F2ZWQtPnRpbWVzbGlj ZSA9IGVuZ2luZS0+cHJvcHMudGltZXNsaWNlX2R1cmF0aW9uX21zOworCXNhdmVkLT5wcmVlbXB0 X3RpbWVvdXQgPSBlbmdpbmUtPnByb3BzLnByZWVtcHRfdGltZW91dF9tczsKKworCXN3aXRjaCAo bW9kaWZ5X3R5cGUpIHsKKwljYXNlIFNFTEZURVNUX1NDSEVEVUxFUl9NT0RJRllfRkFTVF9SRVNF VDoKKwkJLyoKKwkJICogRW5hYmxlIGZvcmNlIHByZS1lbXB0aW9uIG9uIHRpbWUgc2xpY2UgZXhw aXJhdGlvbgorCQkgKiB0b2dldGhlciB3aXRoIGVuZ2luZSByZXNldCBvbiBwcmUtZW1wdGlvbiB0 aW1lb3V0LgorCQkgKiBUaGlzIGlzIHJlcXVpcmVkIHRvIG1ha2UgdGhlIEd1QyBub3RpY2UgYW5k IHJlc2V0CisJCSAqIHRoZSBzaW5nbGUgaGFuZ2luZyBjb250ZXh0LgorCQkgKiBBbHNvLCByZWR1 Y2UgdGhlIHByZWVtcHRpb24gdGltZW91dCB0byBzb21ldGhpbmcKKwkJICogc21hbGwgdG8gc3Bl ZWQgdGhlIHRlc3QgdXAuCisJCSAqLworCQllbmdpbmUtPmk5MTUtPnBhcmFtcy5yZXNldCA9IDI7 CisJCWVuZ2luZS0+ZmxhZ3MgfD0gSTkxNV9FTkdJTkVfV0FOVF9GT1JDRURfUFJFRU1QVElPTjsK KwkJZW5naW5lLT5wcm9wcy50aW1lc2xpY2VfZHVyYXRpb25fbXMgPSBSRURVQ0VEX1RJTUVTTElD RTsKKwkJZW5naW5lLT5wcm9wcy5wcmVlbXB0X3RpbWVvdXRfbXMgPSBSRURVQ0VEX1BSRUVNUFQ7 CisJCWJyZWFrOworCisJY2FzZSBTRUxGVEVTVF9TQ0hFRFVMRVJfTU9ESUZZX05PX0hBTkdDSEVD SzoKKwkJZW5naW5lLT5wcm9wcy5wcmVlbXB0X3RpbWVvdXRfbXMgPSAwOworCQlicmVhazsKKwor CWRlZmF1bHQ6CisJCXByX2VycigiSW52YWxpZCBzY2hlZHVsZXIgcG9saWN5IG1vZGlmaWNhdGlv biB0eXBlOiAlZCFcbiIsIG1vZGlmeV90eXBlKTsKKwkJcmV0dXJuIC1FSU5WQUw7CisJfQorCisJ aWYgKCFpbnRlbF9lbmdpbmVfdXNlc19ndWMoZW5naW5lKSkKKwkJcmV0dXJuIDA7CisKKwllcnIg PSBpbnRlbF9ndWNfZ2xvYmFsX3BvbGljaWVzX3VwZGF0ZSgmZW5naW5lLT5ndC0+dWMuZ3VjKTsK KwlpZiAoZXJyKQorCQlpbnRlbF9zZWxmdGVzdF9yZXN0b3JlX3BvbGljeShlbmdpbmUsIHNhdmVk KTsKKworCXJldHVybiBlcnI7Cit9CisKK2ludCBpbnRlbF9zZWxmdGVzdF9yZXN0b3JlX3BvbGlj eShzdHJ1Y3QgaW50ZWxfZW5naW5lX2NzICplbmdpbmUsCisJCQkJICBzdHJ1Y3QgaW50ZWxfc2Vs ZnRlc3Rfc2F2ZWRfcG9saWN5ICpzYXZlZCkKK3sKKwkvKiBSZXN0b3JlIHRoZSBvcmlnaW5hbCBw b2xpY2llcyAqLworCWVuZ2luZS0+aTkxNS0+cGFyYW1zLnJlc2V0ID0gc2F2ZWQtPnJlc2V0Owor CWVuZ2luZS0+ZmxhZ3MgPSBzYXZlZC0+ZmxhZ3M7CisJZW5naW5lLT5wcm9wcy50aW1lc2xpY2Vf ZHVyYXRpb25fbXMgPSBzYXZlZC0+dGltZXNsaWNlOworCWVuZ2luZS0+cHJvcHMucHJlZW1wdF90 aW1lb3V0X21zID0gc2F2ZWQtPnByZWVtcHRfdGltZW91dDsKKworCWlmICghaW50ZWxfZW5naW5l X3VzZXNfZ3VjKGVuZ2luZSkpCisJCXJldHVybiAwOworCisJcmV0dXJuIGludGVsX2d1Y19nbG9i YWxfcG9saWNpZXNfdXBkYXRlKCZlbmdpbmUtPmd0LT51Yy5ndWMpOworfQorCitpbnQgaW50ZWxf c2VsZnRlc3Rfd2FpdF9mb3JfcnEoc3RydWN0IGk5MTVfcmVxdWVzdCAqcnEpCit7CisJbG9uZyBy ZXQ7CisKKwlyZXQgPSBpOTE1X3JlcXVlc3Rfd2FpdChycSwgMCwgV0FJVF9GT1JfUkVTRVRfVElN RSk7CisJaWYgKHJldCA8IDApCisJCXJldHVybiByZXQ7CisKKwlyZXR1cm4gMDsKK30KZGlmZiAt LWdpdCBhL2RyaXZlcnMvZ3B1L2RybS9pOTE1L3NlbGZ0ZXN0cy9pbnRlbF9zY2hlZHVsZXJfaGVs cGVycy5oIGIvZHJpdmVycy9ncHUvZHJtL2k5MTUvc2VsZnRlc3RzL2ludGVsX3NjaGVkdWxlcl9o ZWxwZXJzLmgKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwLi4wNTBiYzVh OGJhOGIKLS0tIC9kZXYvbnVsbAorKysgYi9kcml2ZXJzL2dwdS9kcm0vaTkxNS9zZWxmdGVzdHMv aW50ZWxfc2NoZWR1bGVyX2hlbHBlcnMuaApAQCAtMCwwICsxLDM1IEBACisvKiBTUERYLUxpY2Vu c2UtSWRlbnRpZmllcjogTUlUICovCisvKgorICogQ29weXJpZ2h0IMKpIDIwMTQtMjAxOSBJbnRl bCBDb3Jwb3JhdGlvbgorICovCisKKyNpZm5kZWYgX0lOVEVMX1NFTEZURVNUX1NDSEVEVUxFUl9I RUxQRVJTX0hfCisjZGVmaW5lIF9JTlRFTF9TRUxGVEVTVF9TQ0hFRFVMRVJfSEVMUEVSU19IXwor CisjaW5jbHVkZSA8bGludXgvdHlwZXMuaD4KKworc3RydWN0IGk5MTVfcmVxdWVzdDsKK3N0cnVj dCBpbnRlbF9lbmdpbmVfY3M7CisKK3N0cnVjdCBpbnRlbF9zZWxmdGVzdF9zYXZlZF9wb2xpY3kK K3sKKwl1MzIgZmxhZ3M7CisJdTMyIHJlc2V0OworCXU2NCB0aW1lc2xpY2U7CisJdTY0IHByZWVt cHRfdGltZW91dDsKK307CisKK2VudW0gc2VsZnRlc3Rfc2NoZWR1bGVyX21vZGlmeQoreworCVNF TEZURVNUX1NDSEVEVUxFUl9NT0RJRllfTk9fSEFOR0NIRUNLID0gMCwKKwlTRUxGVEVTVF9TQ0hF RFVMRVJfTU9ESUZZX0ZBU1RfUkVTRVQsCit9OworCitpbnQgaW50ZWxfc2VsZnRlc3RfbW9kaWZ5 X3BvbGljeShzdHJ1Y3QgaW50ZWxfZW5naW5lX2NzICplbmdpbmUsCisJCQkJIHN0cnVjdCBpbnRl bF9zZWxmdGVzdF9zYXZlZF9wb2xpY3kgKnNhdmVkLAorCQkJCSBlbnVtIHNlbGZ0ZXN0X3NjaGVk dWxlcl9tb2RpZnkgbW9kaWZ5X3R5cGUpOworaW50IGludGVsX3NlbGZ0ZXN0X3Jlc3RvcmVfcG9s aWN5KHN0cnVjdCBpbnRlbF9lbmdpbmVfY3MgKmVuZ2luZSwKKwkJCQkgIHN0cnVjdCBpbnRlbF9z ZWxmdGVzdF9zYXZlZF9wb2xpY3kgKnNhdmVkKTsKK2ludCBpbnRlbF9zZWxmdGVzdF93YWl0X2Zv cl9ycSggc3RydWN0IGk5MTVfcmVxdWVzdCAqcnEpOworCisjZW5kaWYKZGlmZiAtLWdpdCBhL2Ry aXZlcnMvZ3B1L2RybS9pOTE1L3NlbGZ0ZXN0cy9tb2NrX2dlbV9kZXZpY2UuYyBiL2RyaXZlcnMv Z3B1L2RybS9pOTE1L3NlbGZ0ZXN0cy9tb2NrX2dlbV9kZXZpY2UuYwppbmRleCBkMTg5YzRiZDRi ZWYuLjRmODE4MDE0Njg4OCAxMDA2NDQKLS0tIGEvZHJpdmVycy9ncHUvZHJtL2k5MTUvc2VsZnRl c3RzL21vY2tfZ2VtX2RldmljZS5jCisrKyBiL2RyaXZlcnMvZ3B1L2RybS9pOTE1L3NlbGZ0ZXN0 cy9tb2NrX2dlbV9kZXZpY2UuYwpAQCAtNTIsNyArNTIsOCBAQCB2b2lkIG1vY2tfZGV2aWNlX2Zs dXNoKHN0cnVjdCBkcm1faTkxNV9wcml2YXRlICppOTE1KQogCWRvIHsKIAkJZm9yX2VhY2hfZW5n aW5lKGVuZ2luZSwgZ3QsIGlkKQogCQkJbW9ja19lbmdpbmVfZmx1c2goZW5naW5lKTsKLQl9IHdo aWxlIChpbnRlbF9ndF9yZXRpcmVfcmVxdWVzdHNfdGltZW91dChndCwgTUFYX1NDSEVEVUxFX1RJ TUVPVVQpKTsKKwl9IHdoaWxlIChpbnRlbF9ndF9yZXRpcmVfcmVxdWVzdHNfdGltZW91dChndCwg TUFYX1NDSEVEVUxFX1RJTUVPVVQsCisJCQkJCQkgIE5VTEwpKTsKIH0KIAogc3RhdGljIHZvaWQg bW9ja19kZXZpY2VfcmVsZWFzZShzdHJ1Y3QgZHJtX2RldmljZSAqZGV2KQpkaWZmIC0tZ2l0IGEv aW5jbHVkZS91YXBpL2RybS9pOTE1X2RybS5oIGIvaW5jbHVkZS91YXBpL2RybS9pOTE1X2RybS5o CmluZGV4IGUyMGVlZWNhN2ExYy4uNDQ5MTlkMDg0OGEwIDEwMDY0NAotLS0gYS9pbmNsdWRlL3Vh cGkvZHJtL2k5MTVfZHJtLmgKKysrIGIvaW5jbHVkZS91YXBpL2RybS9pOTE1X2RybS5oCkBAIC01 NzIsNiArNTcyLDE1IEBAIHR5cGVkZWYgc3RydWN0IGRybV9pOTE1X2lycV93YWl0IHsKICNkZWZp bmUgICBJOTE1X1NDSEVEVUxFUl9DQVBfUFJFRU1QVElPTgkoMXVsIDw8IDIpCiAjZGVmaW5lICAg STkxNV9TQ0hFRFVMRVJfQ0FQX1NFTUFQSE9SRVMJKDF1bCA8PCAzKQogI2RlZmluZSAgIEk5MTVf U0NIRURVTEVSX0NBUF9FTkdJTkVfQlVTWV9TVEFUUwkoMXVsIDw8IDQpCisvKgorICogSW5kaWNh dGVzIHRoZSAyayB1c2VyIHByaW9yaXR5IGxldmVscyBhcmUgc3RhdGljYWxseSBtYXBwZWQgaW50 byAzIGJ1Y2tldHMgYXMKKyAqIGZvbGxvd3M6CisgKgorICogLTFrIHRvIC0xCUxvdyBwcmlvcml0 eQorICogMAkJTm9ybWFsIHByaW9yaXR5CisgKiAxIHRvIDFrCUhpZ2hlc3QgcHJpb3JpdHkKKyAq LworI2RlZmluZSAgIEk5MTVfU0NIRURVTEVSX0NBUF9TVEFUSUNfUFJJT1JJVFlfTUFQCSgxdWwg PDwgNSkKIAogI2RlZmluZSBJOTE1X1BBUkFNX0hVQ19TVEFUVVMJCSA0MgogCi0tIAoyLjI4LjAK Cl9fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fCkludGVsLWdm eCBtYWlsaW5nIGxpc3QKSW50ZWwtZ2Z4QGxpc3RzLmZyZWVkZXNrdG9wLm9yZwpodHRwczovL2xp c3RzLmZyZWVkZXNrdG9wLm9yZy9tYWlsbWFuL2xpc3RpbmZvL2ludGVsLWdmeAo= 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=-16.8 required=3.0 tests=BAYES_00, HEADER_FROM_DIFFERENT_DOMAINS,INCLUDES_CR_TRAILER,INCLUDES_PATCH, MAILING_LIST_MULTI,SPF_HELO_NONE,SPF_PASS,USER_AGENT_GIT 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 C5C88C07E9B for ; Wed, 21 Jul 2021 07:28:07 +0000 (UTC) Received: from gabe.freedesktop.org (gabe.freedesktop.org [131.252.210.177]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by mail.kernel.org (Postfix) with ESMTPS id 9064E610D2 for ; Wed, 21 Jul 2021 07:28:07 +0000 (UTC) DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org 9064E610D2 Authentication-Results: mail.kernel.org; dmarc=fail (p=none dis=none) header.from=intel.com Authentication-Results: mail.kernel.org; spf=none smtp.mailfrom=dri-devel-bounces@lists.freedesktop.org Received: from gabe.freedesktop.org (localhost [127.0.0.1]) by gabe.freedesktop.org (Postfix) with ESMTP id 9C0386E848; Wed, 21 Jul 2021 07:28:04 +0000 (UTC) Received: from mga04.intel.com (mga04.intel.com [192.55.52.120]) by gabe.freedesktop.org (Postfix) with ESMTPS id 5C049899FF; Tue, 20 Jul 2021 20:40:16 +0000 (UTC) X-IronPort-AV: E=McAfee;i="6200,9189,10051"; a="209421874" X-IronPort-AV: E=Sophos;i="5.84,256,1620716400"; d="scan'208";a="209421874" Received: from orsmga006.jf.intel.com ([10.7.209.51]) by fmsmga104.fm.intel.com with ESMTP/TLS/ECDHE-RSA-AES256-GCM-SHA384; 20 Jul 2021 13:40:15 -0700 X-IronPort-AV: E=Sophos;i="5.84,256,1620716400"; d="scan'208";a="414906054" Received: from dhiatt-server.jf.intel.com ([10.54.81.3]) by orsmga006-auth.jf.intel.com with ESMTP/TLS/ECDHE-RSA-AES256-GCM-SHA384; 20 Jul 2021 13:40:14 -0700 From: Matthew Brost To: , Subject: [RFC PATCH 01/42] drm/i915/guc: GuC submission squashed into single patch Date: Tue, 20 Jul 2021 13:57:21 -0700 Message-Id: <20210720205802.39610-2-matthew.brost@intel.com> X-Mailer: git-send-email 2.28.0 In-Reply-To: <20210720205802.39610-1-matthew.brost@intel.com> References: <20210720205802.39610-1-matthew.brost@intel.com> MIME-Version: 1.0 Content-Type: text/plain; charset=utf-8 Content-Transfer-Encoding: 8bit X-Mailman-Approved-At: Wed, 21 Jul 2021 07:27:54 +0000 X-BeenThere: dri-devel@lists.freedesktop.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: Direct Rendering Infrastructure - Development List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: dri-devel-bounces@lists.freedesktop.org Sender: "dri-devel" https://patchwork.freedesktop.org/series/91840/ Signed-off-by: Matthew Brost --- drivers/gpu/drm/i915/Makefile | 1 + drivers/gpu/drm/i915/gem/i915_gem_context.c | 21 +- drivers/gpu/drm/i915/gem/i915_gem_mman.c | 3 +- drivers/gpu/drm/i915/gt/gen8_engine_cs.c | 6 +- drivers/gpu/drm/i915/gt/intel_breadcrumbs.c | 44 +- drivers/gpu/drm/i915/gt/intel_breadcrumbs.h | 16 +- .../gpu/drm/i915/gt/intel_breadcrumbs_types.h | 7 + drivers/gpu/drm/i915/gt/intel_context.c | 50 +- drivers/gpu/drm/i915/gt/intel_context.h | 50 +- drivers/gpu/drm/i915/gt/intel_context_types.h | 63 +- drivers/gpu/drm/i915/gt/intel_engine.h | 57 +- drivers/gpu/drm/i915/gt/intel_engine_cs.c | 182 +- .../gpu/drm/i915/gt/intel_engine_heartbeat.c | 71 +- .../gpu/drm/i915/gt/intel_engine_heartbeat.h | 4 + drivers/gpu/drm/i915/gt/intel_engine_types.h | 13 +- drivers/gpu/drm/i915/gt/intel_engine_user.c | 4 + .../drm/i915/gt/intel_execlists_submission.c | 89 +- .../drm/i915/gt/intel_execlists_submission.h | 4 - drivers/gpu/drm/i915/gt/intel_gt.c | 21 + drivers/gpu/drm/i915/gt/intel_gt.h | 2 + drivers/gpu/drm/i915/gt/intel_gt_pm.c | 6 +- drivers/gpu/drm/i915/gt/intel_gt_requests.c | 21 +- drivers/gpu/drm/i915/gt/intel_gt_requests.h | 9 +- drivers/gpu/drm/i915/gt/intel_lrc_reg.h | 1 - drivers/gpu/drm/i915/gt/intel_reset.c | 50 +- .../gpu/drm/i915/gt/intel_ring_submission.c | 42 + drivers/gpu/drm/i915/gt/intel_rps.c | 4 + drivers/gpu/drm/i915/gt/intel_workarounds.c | 46 +- .../gpu/drm/i915/gt/intel_workarounds_types.h | 1 + drivers/gpu/drm/i915/gt/mock_engine.c | 34 +- drivers/gpu/drm/i915/gt/selftest_context.c | 10 + .../drm/i915/gt/selftest_engine_heartbeat.c | 22 + .../drm/i915/gt/selftest_engine_heartbeat.h | 2 + drivers/gpu/drm/i915/gt/selftest_execlists.c | 12 +- drivers/gpu/drm/i915/gt/selftest_hangcheck.c | 314 +- drivers/gpu/drm/i915/gt/selftest_mocs.c | 50 +- .../gpu/drm/i915/gt/selftest_workarounds.c | 132 +- .../gpu/drm/i915/gt/uc/abi/guc_actions_abi.h | 15 + drivers/gpu/drm/i915/gt/uc/intel_guc.c | 82 +- drivers/gpu/drm/i915/gt/uc/intel_guc.h | 101 +- drivers/gpu/drm/i915/gt/uc/intel_guc_ads.c | 463 ++- drivers/gpu/drm/i915/gt/uc/intel_guc_ads.h | 4 + drivers/gpu/drm/i915/gt/uc/intel_guc_ct.c | 132 +- drivers/gpu/drm/i915/gt/uc/intel_guc_ct.h | 16 +- .../gpu/drm/i915/gt/uc/intel_guc_debugfs.c | 25 +- drivers/gpu/drm/i915/gt/uc/intel_guc_fwif.h | 88 +- .../gpu/drm/i915/gt/uc/intel_guc_submission.c | 2848 +++++++++++++++-- .../gpu/drm/i915/gt/uc/intel_guc_submission.h | 18 +- drivers/gpu/drm/i915/gt/uc/intel_uc.c | 101 +- drivers/gpu/drm/i915/gt/uc/intel_uc.h | 11 + drivers/gpu/drm/i915/i915_debugfs_params.c | 31 + drivers/gpu/drm/i915/i915_gem_evict.c | 1 + drivers/gpu/drm/i915/i915_gpu_error.c | 25 +- drivers/gpu/drm/i915/i915_reg.h | 2 + drivers/gpu/drm/i915/i915_request.c | 173 +- drivers/gpu/drm/i915/i915_request.h | 29 + drivers/gpu/drm/i915/i915_scheduler.c | 16 +- drivers/gpu/drm/i915/i915_scheduler.h | 10 +- drivers/gpu/drm/i915/i915_scheduler_types.h | 22 + drivers/gpu/drm/i915/i915_trace.h | 199 +- drivers/gpu/drm/i915/selftests/i915_request.c | 4 +- .../gpu/drm/i915/selftests/igt_flush_test.c | 2 +- .../gpu/drm/i915/selftests/igt_live_test.c | 2 +- .../i915/selftests/intel_scheduler_helpers.c | 89 + .../i915/selftests/intel_scheduler_helpers.h | 35 + .../gpu/drm/i915/selftests/mock_gem_device.c | 3 +- include/uapi/drm/i915_drm.h | 9 + 67 files changed, 5122 insertions(+), 898 deletions(-) create mode 100644 drivers/gpu/drm/i915/selftests/intel_scheduler_helpers.c create mode 100644 drivers/gpu/drm/i915/selftests/intel_scheduler_helpers.h diff --git a/drivers/gpu/drm/i915/Makefile b/drivers/gpu/drm/i915/Makefile index 10b3bb6207ba..ab7679957623 100644 --- a/drivers/gpu/drm/i915/Makefile +++ b/drivers/gpu/drm/i915/Makefile @@ -280,6 +280,7 @@ i915-$(CONFIG_DRM_I915_CAPTURE_ERROR) += i915_gpu_error.o i915-$(CONFIG_DRM_I915_SELFTEST) += \ gem/selftests/i915_gem_client_blt.o \ gem/selftests/igt_gem_utils.o \ + selftests/intel_scheduler_helpers.o \ selftests/i915_random.o \ selftests/i915_selftest.o \ selftests/igt_atomic.o \ diff --git a/drivers/gpu/drm/i915/gem/i915_gem_context.c b/drivers/gpu/drm/i915/gem/i915_gem_context.c index 7d6f52d8a801..d87a4c6da5bc 100644 --- a/drivers/gpu/drm/i915/gem/i915_gem_context.c +++ b/drivers/gpu/drm/i915/gem/i915_gem_context.c @@ -74,7 +74,6 @@ #include "gt/intel_context_param.h" #include "gt/intel_engine_heartbeat.h" #include "gt/intel_engine_user.h" -#include "gt/intel_execlists_submission.h" /* virtual_engine */ #include "gt/intel_gpu_commands.h" #include "gt/intel_ring.h" @@ -363,9 +362,6 @@ set_proto_ctx_engines_balance(struct i915_user_extension __user *base, if (!HAS_EXECLISTS(i915)) return -ENODEV; - if (intel_uc_uses_guc_submission(&i915->gt.uc)) - return -ENODEV; /* not implement yet */ - if (get_user(idx, &ext->engine_index)) return -EFAULT; @@ -495,6 +491,11 @@ set_proto_ctx_engines_bond(struct i915_user_extension __user *base, void *data) return -EINVAL; } + if (intel_engine_uses_guc(master)) { + DRM_DEBUG("bonding extension not supported with GuC submission"); + return -ENODEV; + } + if (get_user(num_bonds, &ext->num_bonds)) return -EFAULT; @@ -799,7 +800,8 @@ static int intel_context_set_gem(struct intel_context *ce, } if (ctx->sched.priority >= I915_PRIORITY_NORMAL && - intel_engine_has_timeslices(ce->engine)) + intel_engine_has_timeslices(ce->engine) && + intel_engine_has_semaphores(ce->engine)) __set_bit(CONTEXT_USE_SEMAPHORES, &ce->flags); if (IS_ACTIVE(CONFIG_DRM_I915_REQUEST_TIMEOUT) && @@ -949,8 +951,8 @@ static struct i915_gem_engines *user_engines(struct i915_gem_context *ctx, break; case I915_GEM_ENGINE_TYPE_BALANCED: - ce = intel_execlists_create_virtual(pe[n].siblings, - pe[n].num_siblings); + ce = intel_engine_create_virtual(pe[n].siblings, + pe[n].num_siblings); break; case I915_GEM_ENGINE_TYPE_INVALID: @@ -1082,7 +1084,7 @@ static void kill_engines(struct i915_gem_engines *engines, bool ban) for_each_gem_engine(ce, engines, it) { struct intel_engine_cs *engine; - if (ban && intel_context_set_banned(ce)) + if (ban && intel_context_ban(ce, NULL)) continue; /* @@ -1778,7 +1780,8 @@ static void __apply_priority(struct intel_context *ce, void *arg) if (!intel_engine_has_timeslices(ce->engine)) return; - if (ctx->sched.priority >= I915_PRIORITY_NORMAL) + if (ctx->sched.priority >= I915_PRIORITY_NORMAL && + intel_engine_has_semaphores(ce->engine)) intel_context_set_use_semaphores(ce); else intel_context_clear_use_semaphores(ce); diff --git a/drivers/gpu/drm/i915/gem/i915_gem_mman.c b/drivers/gpu/drm/i915/gem/i915_gem_mman.c index a90f796e85c0..6fffd4d377c2 100644 --- a/drivers/gpu/drm/i915/gem/i915_gem_mman.c +++ b/drivers/gpu/drm/i915/gem/i915_gem_mman.c @@ -645,7 +645,8 @@ mmap_offset_attach(struct drm_i915_gem_object *obj, goto insert; /* Attempt to reap some mmap space from dead objects */ - err = intel_gt_retire_requests_timeout(&i915->gt, MAX_SCHEDULE_TIMEOUT); + err = intel_gt_retire_requests_timeout(&i915->gt, MAX_SCHEDULE_TIMEOUT, + NULL); if (err) goto err; diff --git a/drivers/gpu/drm/i915/gt/gen8_engine_cs.c b/drivers/gpu/drm/i915/gt/gen8_engine_cs.c index 87b06572fd2e..f7aae502ec3d 100644 --- a/drivers/gpu/drm/i915/gt/gen8_engine_cs.c +++ b/drivers/gpu/drm/i915/gt/gen8_engine_cs.c @@ -506,7 +506,8 @@ gen8_emit_fini_breadcrumb_tail(struct i915_request *rq, u32 *cs) *cs++ = MI_USER_INTERRUPT; *cs++ = MI_ARB_ON_OFF | MI_ARB_ENABLE; - if (intel_engine_has_semaphores(rq->engine)) + if (intel_engine_has_semaphores(rq->engine) && + !intel_uc_uses_guc_submission(&rq->engine->gt->uc)) cs = emit_preempt_busywait(rq, cs); rq->tail = intel_ring_offset(rq, cs); @@ -598,7 +599,8 @@ gen12_emit_fini_breadcrumb_tail(struct i915_request *rq, u32 *cs) *cs++ = MI_USER_INTERRUPT; *cs++ = MI_ARB_ON_OFF | MI_ARB_ENABLE; - if (intel_engine_has_semaphores(rq->engine)) + if (intel_engine_has_semaphores(rq->engine) && + !intel_uc_uses_guc_submission(&rq->engine->gt->uc)) cs = gen12_emit_preempt_busywait(rq, cs); rq->tail = intel_ring_offset(rq, cs); diff --git a/drivers/gpu/drm/i915/gt/intel_breadcrumbs.c b/drivers/gpu/drm/i915/gt/intel_breadcrumbs.c index 38cc42783dfb..209cf265bf74 100644 --- a/drivers/gpu/drm/i915/gt/intel_breadcrumbs.c +++ b/drivers/gpu/drm/i915/gt/intel_breadcrumbs.c @@ -15,28 +15,14 @@ #include "intel_gt_pm.h" #include "intel_gt_requests.h" -static bool irq_enable(struct intel_engine_cs *engine) +static bool irq_enable(struct intel_breadcrumbs *b) { - if (!engine->irq_enable) - return false; - - /* Caller disables interrupts */ - spin_lock(&engine->gt->irq_lock); - engine->irq_enable(engine); - spin_unlock(&engine->gt->irq_lock); - - return true; + return intel_engine_irq_enable(b->irq_engine); } -static void irq_disable(struct intel_engine_cs *engine) +static void irq_disable(struct intel_breadcrumbs *b) { - if (!engine->irq_disable) - return; - - /* Caller disables interrupts */ - spin_lock(&engine->gt->irq_lock); - engine->irq_disable(engine); - spin_unlock(&engine->gt->irq_lock); + intel_engine_irq_disable(b->irq_engine); } static void __intel_breadcrumbs_arm_irq(struct intel_breadcrumbs *b) @@ -57,7 +43,7 @@ static void __intel_breadcrumbs_arm_irq(struct intel_breadcrumbs *b) WRITE_ONCE(b->irq_armed, true); /* Requests may have completed before we could enable the interrupt. */ - if (!b->irq_enabled++ && irq_enable(b->irq_engine)) + if (!b->irq_enabled++ && b->irq_enable(b)) irq_work_queue(&b->irq_work); } @@ -76,7 +62,7 @@ static void __intel_breadcrumbs_disarm_irq(struct intel_breadcrumbs *b) { GEM_BUG_ON(!b->irq_enabled); if (!--b->irq_enabled) - irq_disable(b->irq_engine); + b->irq_disable(b); WRITE_ONCE(b->irq_armed, false); intel_gt_pm_put_async(b->irq_engine->gt); @@ -259,6 +245,9 @@ static void signal_irq_work(struct irq_work *work) llist_entry(signal, typeof(*rq), signal_node); struct list_head cb_list; + if (rq->engine->sched_engine->retire_inflight_request_prio) + rq->engine->sched_engine->retire_inflight_request_prio(rq); + spin_lock(&rq->lock); list_replace(&rq->fence.cb_list, &cb_list); __dma_fence_signal__timestamp(&rq->fence, timestamp); @@ -281,7 +270,7 @@ intel_breadcrumbs_create(struct intel_engine_cs *irq_engine) if (!b) return NULL; - b->irq_engine = irq_engine; + kref_init(&b->ref); spin_lock_init(&b->signalers_lock); INIT_LIST_HEAD(&b->signalers); @@ -290,6 +279,10 @@ intel_breadcrumbs_create(struct intel_engine_cs *irq_engine) spin_lock_init(&b->irq_lock); init_irq_work(&b->irq_work, signal_irq_work); + b->irq_engine = irq_engine; + b->irq_enable = irq_enable; + b->irq_disable = irq_disable; + return b; } @@ -303,9 +296,9 @@ void intel_breadcrumbs_reset(struct intel_breadcrumbs *b) spin_lock_irqsave(&b->irq_lock, flags); if (b->irq_enabled) - irq_enable(b->irq_engine); + b->irq_enable(b); else - irq_disable(b->irq_engine); + b->irq_disable(b); spin_unlock_irqrestore(&b->irq_lock, flags); } @@ -325,11 +318,14 @@ void __intel_breadcrumbs_park(struct intel_breadcrumbs *b) } } -void intel_breadcrumbs_free(struct intel_breadcrumbs *b) +void intel_breadcrumbs_free(struct kref *kref) { + struct intel_breadcrumbs *b = container_of(kref, typeof(*b), ref); + irq_work_sync(&b->irq_work); GEM_BUG_ON(!list_empty(&b->signalers)); GEM_BUG_ON(b->irq_armed); + kfree(b); } diff --git a/drivers/gpu/drm/i915/gt/intel_breadcrumbs.h b/drivers/gpu/drm/i915/gt/intel_breadcrumbs.h index 3ce5ce270b04..be0d4f379a85 100644 --- a/drivers/gpu/drm/i915/gt/intel_breadcrumbs.h +++ b/drivers/gpu/drm/i915/gt/intel_breadcrumbs.h @@ -9,7 +9,7 @@ #include #include -#include "intel_engine_types.h" +#include "intel_breadcrumbs_types.h" struct drm_printer; struct i915_request; @@ -17,7 +17,7 @@ struct intel_breadcrumbs; struct intel_breadcrumbs * intel_breadcrumbs_create(struct intel_engine_cs *irq_engine); -void intel_breadcrumbs_free(struct intel_breadcrumbs *b); +void intel_breadcrumbs_free(struct kref *kref); void intel_breadcrumbs_reset(struct intel_breadcrumbs *b); void __intel_breadcrumbs_park(struct intel_breadcrumbs *b); @@ -48,4 +48,16 @@ void i915_request_cancel_breadcrumb(struct i915_request *request); void intel_context_remove_breadcrumbs(struct intel_context *ce, struct intel_breadcrumbs *b); +static inline struct intel_breadcrumbs * +intel_breadcrumbs_get(struct intel_breadcrumbs *b) +{ + kref_get(&b->ref); + return b; +} + +static inline void intel_breadcrumbs_put(struct intel_breadcrumbs *b) +{ + kref_put(&b->ref, intel_breadcrumbs_free); +} + #endif /* __INTEL_BREADCRUMBS__ */ diff --git a/drivers/gpu/drm/i915/gt/intel_breadcrumbs_types.h b/drivers/gpu/drm/i915/gt/intel_breadcrumbs_types.h index 3a084ce8ff5e..72dfd3748c4c 100644 --- a/drivers/gpu/drm/i915/gt/intel_breadcrumbs_types.h +++ b/drivers/gpu/drm/i915/gt/intel_breadcrumbs_types.h @@ -7,10 +7,13 @@ #define __INTEL_BREADCRUMBS_TYPES__ #include +#include #include #include #include +#include "intel_engine_types.h" + /* * Rather than have every client wait upon all user interrupts, * with the herd waking after every interrupt and each doing the @@ -29,6 +32,7 @@ * the overhead of waking that client is much preferred. */ struct intel_breadcrumbs { + struct kref ref; atomic_t active; spinlock_t signalers_lock; /* protects the list of signalers */ @@ -42,7 +46,10 @@ struct intel_breadcrumbs { bool irq_armed; /* Not all breadcrumbs are attached to physical HW */ + intel_engine_mask_t engine_mask; struct intel_engine_cs *irq_engine; + bool (*irq_enable)(struct intel_breadcrumbs *b); + void (*irq_disable)(struct intel_breadcrumbs *b); }; #endif /* __INTEL_BREADCRUMBS_TYPES__ */ diff --git a/drivers/gpu/drm/i915/gt/intel_context.c b/drivers/gpu/drm/i915/gt/intel_context.c index bd63813c8a80..b1e3d00fb1f2 100644 --- a/drivers/gpu/drm/i915/gt/intel_context.c +++ b/drivers/gpu/drm/i915/gt/intel_context.c @@ -8,6 +8,7 @@ #include "i915_drv.h" #include "i915_globals.h" +#include "i915_trace.h" #include "intel_context.h" #include "intel_engine.h" @@ -28,6 +29,7 @@ static void rcu_context_free(struct rcu_head *rcu) { struct intel_context *ce = container_of(rcu, typeof(*ce), rcu); + trace_intel_context_free(ce); kmem_cache_free(global.slab_ce, ce); } @@ -46,6 +48,7 @@ intel_context_create(struct intel_engine_cs *engine) return ERR_PTR(-ENOMEM); intel_context_init(ce, engine); + trace_intel_context_create(ce); return ce; } @@ -80,7 +83,7 @@ static int intel_context_active_acquire(struct intel_context *ce) __i915_active_acquire(&ce->active); - if (intel_context_is_barrier(ce)) + if (intel_context_is_barrier(ce) || intel_engine_uses_guc(ce->engine)) return 0; /* Preallocate tracking nodes */ @@ -268,6 +271,8 @@ int __intel_context_do_pin_ww(struct intel_context *ce, GEM_BUG_ON(!intel_context_is_pinned(ce)); /* no overflow! */ + trace_intel_context_do_pin(ce); + err_unlock: mutex_unlock(&ce->pin_mutex); err_post_unpin: @@ -306,9 +311,9 @@ int __intel_context_do_pin(struct intel_context *ce) return err; } -void intel_context_unpin(struct intel_context *ce) +void __intel_context_do_unpin(struct intel_context *ce, int sub) { - if (!atomic_dec_and_test(&ce->pin_count)) + if (!atomic_sub_and_test(sub, &ce->pin_count)) return; CE_TRACE(ce, "unpin\n"); @@ -323,6 +328,7 @@ void intel_context_unpin(struct intel_context *ce) */ intel_context_get(ce); intel_context_active_release(ce); + trace_intel_context_do_unpin(ce); intel_context_put(ce); } @@ -360,6 +366,12 @@ static int __intel_context_active(struct i915_active *active) return 0; } +static int sw_fence_dummy_notify(struct i915_sw_fence *sf, + enum i915_sw_fence_notify state) +{ + return NOTIFY_DONE; +} + void intel_context_init(struct intel_context *ce, struct intel_engine_cs *engine) { @@ -384,6 +396,18 @@ intel_context_init(struct intel_context *ce, struct intel_engine_cs *engine) mutex_init(&ce->pin_mutex); + spin_lock_init(&ce->guc_state.lock); + INIT_LIST_HEAD(&ce->guc_state.fences); + + spin_lock_init(&ce->guc_active.lock); + INIT_LIST_HEAD(&ce->guc_active.requests); + + ce->guc_id = GUC_INVALID_LRC_ID; + INIT_LIST_HEAD(&ce->guc_id_link); + + i915_sw_fence_init(&ce->guc_blocked, sw_fence_dummy_notify); + i915_sw_fence_commit(&ce->guc_blocked); + i915_active_init(&ce->active, __intel_context_active, __intel_context_retire, 0); } @@ -500,6 +524,26 @@ struct i915_request *intel_context_create_request(struct intel_context *ce) return rq; } +struct i915_request *intel_context_find_active_request(struct intel_context *ce) +{ + struct i915_request *rq, *active = NULL; + unsigned long flags; + + GEM_BUG_ON(!intel_engine_uses_guc(ce->engine)); + + spin_lock_irqsave(&ce->guc_active.lock, flags); + list_for_each_entry_reverse(rq, &ce->guc_active.requests, + sched.link) { + if (i915_request_completed(rq)) + break; + + active = rq; + } + spin_unlock_irqrestore(&ce->guc_active.lock, flags); + + return active; +} + #if IS_ENABLED(CONFIG_DRM_I915_SELFTEST) #include "selftest_context.c" #endif diff --git a/drivers/gpu/drm/i915/gt/intel_context.h b/drivers/gpu/drm/i915/gt/intel_context.h index b10cbe8fee99..876bdb08303c 100644 --- a/drivers/gpu/drm/i915/gt/intel_context.h +++ b/drivers/gpu/drm/i915/gt/intel_context.h @@ -16,6 +16,7 @@ #include "intel_engine_types.h" #include "intel_ring_types.h" #include "intel_timeline_types.h" +#include "i915_trace.h" #define CE_TRACE(ce, fmt, ...) do { \ const struct intel_context *ce__ = (ce); \ @@ -69,6 +70,13 @@ intel_context_is_pinned(struct intel_context *ce) return atomic_read(&ce->pin_count); } +static inline void intel_context_cancel_request(struct intel_context *ce, + struct i915_request *rq) +{ + GEM_BUG_ON(!ce->ops->cancel_request); + return ce->ops->cancel_request(ce, rq); +} + /** * intel_context_unlock_pinned - Releases the earlier locking of 'pinned' status * @ce - the context @@ -113,7 +121,32 @@ static inline void __intel_context_pin(struct intel_context *ce) atomic_inc(&ce->pin_count); } -void intel_context_unpin(struct intel_context *ce); +void __intel_context_do_unpin(struct intel_context *ce, int sub); + +static inline void intel_context_sched_disable_unpin(struct intel_context *ce) +{ + __intel_context_do_unpin(ce, 2); +} + +static inline void intel_context_unpin(struct intel_context *ce) +{ + if (!ce->ops->sched_disable) { + __intel_context_do_unpin(ce, 1); + } else { + /* + * Move ownership of this pin to the scheduling disable which is + * an async operation. When that operation completes the above + * intel_context_sched_disable_unpin is called potentially + * unpinning the context. + */ + while (!atomic_add_unless(&ce->pin_count, -1, 1)) { + if (atomic_cmpxchg(&ce->pin_count, 1, 2) == 1) { + ce->ops->sched_disable(ce); + break; + } + } + } +} void intel_context_enter_engine(struct intel_context *ce); void intel_context_exit_engine(struct intel_context *ce); @@ -175,6 +208,9 @@ int intel_context_prepare_remote_request(struct intel_context *ce, struct i915_request *intel_context_create_request(struct intel_context *ce); +struct i915_request * +intel_context_find_active_request(struct intel_context *ce); + static inline bool intel_context_is_barrier(const struct intel_context *ce) { return test_bit(CONTEXT_BARRIER_BIT, &ce->flags); @@ -215,6 +251,18 @@ static inline bool intel_context_set_banned(struct intel_context *ce) return test_and_set_bit(CONTEXT_BANNED, &ce->flags); } +static inline bool intel_context_ban(struct intel_context *ce, + struct i915_request *rq) +{ + bool ret = intel_context_set_banned(ce); + + trace_intel_context_ban(ce); + if (ce->ops->ban) + ce->ops->ban(ce, rq); + + return ret; +} + static inline bool intel_context_force_single_submission(const struct intel_context *ce) { diff --git a/drivers/gpu/drm/i915/gt/intel_context_types.h b/drivers/gpu/drm/i915/gt/intel_context_types.h index 90026c177105..fe555551c2d2 100644 --- a/drivers/gpu/drm/i915/gt/intel_context_types.h +++ b/drivers/gpu/drm/i915/gt/intel_context_types.h @@ -13,12 +13,14 @@ #include #include "i915_active_types.h" +#include "i915_sw_fence.h" #include "i915_utils.h" #include "intel_engine_types.h" #include "intel_sseu.h" -#define CONTEXT_REDZONE POISON_INUSE +#include "uc/intel_guc_fwif.h" +#define CONTEXT_REDZONE POISON_INUSE DECLARE_EWMA(runtime, 3, 8); struct i915_gem_context; @@ -35,16 +37,29 @@ struct intel_context_ops { int (*alloc)(struct intel_context *ce); + void (*ban)(struct intel_context *ce, struct i915_request *rq); + int (*pre_pin)(struct intel_context *ce, struct i915_gem_ww_ctx *ww, void **vaddr); int (*pin)(struct intel_context *ce, void *vaddr); void (*unpin)(struct intel_context *ce); void (*post_unpin)(struct intel_context *ce); + void (*cancel_request)(struct intel_context *ce, + struct i915_request *rq); + void (*enter)(struct intel_context *ce); void (*exit)(struct intel_context *ce); + void (*sched_disable)(struct intel_context *ce); + void (*reset)(struct intel_context *ce); void (*destroy)(struct kref *kref); + + /* virtual engine/context interface */ + struct intel_context *(*create_virtual)(struct intel_engine_cs **engine, + unsigned int count); + struct intel_engine_cs *(*get_sibling)(struct intel_engine_cs *engine, + unsigned int sibling); }; struct intel_context { @@ -96,6 +111,7 @@ struct intel_context { #define CONTEXT_BANNED 6 #define CONTEXT_FORCE_SINGLE_SUBMISSION 7 #define CONTEXT_NOPREEMPT 8 +#define CONTEXT_LRCA_DIRTY 9 struct { u64 timeout_us; @@ -137,6 +153,51 @@ struct intel_context { struct intel_sseu sseu; u8 wa_bb_page; /* if set, page num reserved for context workarounds */ + + struct { + /** lock: protects everything in guc_state */ + spinlock_t lock; + /** + * sched_state: scheduling state of this context using GuC + * submission + */ + u8 sched_state; + /* + * fences: maintains of list of requests that have a submit + * fence related to GuC submission + */ + struct list_head fences; + } guc_state; + + struct { + /** lock: protects everything in guc_active */ + spinlock_t lock; + /** requests: active requests on this context */ + struct list_head requests; + } guc_active; + + /* GuC scheduling state flags that do not require a lock. */ + atomic_t guc_sched_state_no_lock; + + /* GuC LRC descriptor ID */ + u16 guc_id; + + /* GuC LRC descriptor reference count */ + atomic_t guc_id_ref; + + /* + * GuC ID link - in list when unpinned but guc_id still valid in GuC + */ + struct list_head guc_id_link; + + /* GuC context blocked fence */ + struct i915_sw_fence guc_blocked; + + /* + * GuC priority management + */ + u8 guc_prio; + u32 guc_prio_count[GUC_CLIENT_PRIORITY_NUM]; }; #endif /* __INTEL_CONTEXT_TYPES__ */ diff --git a/drivers/gpu/drm/i915/gt/intel_engine.h b/drivers/gpu/drm/i915/gt/intel_engine.h index f911c1224ab2..04ce7a3e1d82 100644 --- a/drivers/gpu/drm/i915/gt/intel_engine.h +++ b/drivers/gpu/drm/i915/gt/intel_engine.h @@ -212,6 +212,9 @@ void intel_engine_get_instdone(const struct intel_engine_cs *engine, void intel_engine_init_execlists(struct intel_engine_cs *engine); +bool intel_engine_irq_enable(struct intel_engine_cs *engine); +void intel_engine_irq_disable(struct intel_engine_cs *engine); + static inline void __intel_engine_reset(struct intel_engine_cs *engine, bool stalled) { @@ -237,12 +240,15 @@ __printf(3, 4) void intel_engine_dump(struct intel_engine_cs *engine, struct drm_printer *m, const char *header, ...); +void intel_engine_dump_active_requests(struct list_head *requests, + struct i915_request *hung_rq, + struct drm_printer *m); ktime_t intel_engine_get_busy_time(struct intel_engine_cs *engine, ktime_t *now); struct i915_request * -intel_engine_find_active_request(struct intel_engine_cs *engine); +intel_engine_execlist_find_hung_request(struct intel_engine_cs *engine); u32 intel_engine_context_size(struct intel_gt *gt, u8 class); struct intel_context * @@ -273,13 +279,60 @@ intel_engine_has_preempt_reset(const struct intel_engine_cs *engine) return intel_engine_has_preemption(engine); } +struct intel_context * +intel_engine_create_virtual(struct intel_engine_cs **siblings, + unsigned int count); + +static inline bool +intel_virtual_engine_has_heartbeat(const struct intel_engine_cs *engine) +{ + /* + * For non-GuC submission we expect the back-end to look at the + * heartbeat status of the actual physical engine that the work + * has been (or is being) scheduled on, so we should only reach + * here with GuC submission enabled. + */ + GEM_BUG_ON(!intel_engine_uses_guc(engine)); + + return intel_guc_virtual_engine_has_heartbeat(engine); +} + static inline bool intel_engine_has_heartbeat(const struct intel_engine_cs *engine) { if (!IS_ACTIVE(CONFIG_DRM_I915_HEARTBEAT_INTERVAL)) return false; - return READ_ONCE(engine->props.heartbeat_interval_ms); + if (intel_engine_is_virtual(engine)) + return intel_virtual_engine_has_heartbeat(engine); + else + return READ_ONCE(engine->props.heartbeat_interval_ms); +} + +static inline struct intel_engine_cs * +intel_engine_get_sibling(struct intel_engine_cs *engine, unsigned int sibling) +{ + GEM_BUG_ON(!intel_engine_is_virtual(engine)); + return engine->cops->get_sibling(engine, sibling); +} + +static inline void +intel_engine_set_hung_context(struct intel_engine_cs *engine, + struct intel_context *ce) +{ + engine->hung_ce = ce; +} + +static inline void +intel_engine_clear_hung_context(struct intel_engine_cs *engine) +{ + intel_engine_set_hung_context(engine, NULL); +} + +static inline struct intel_context * +intel_engine_get_hung_context(struct intel_engine_cs *engine) +{ + return engine->hung_ce; } #endif /* _INTEL_RINGBUFFER_H_ */ diff --git a/drivers/gpu/drm/i915/gt/intel_engine_cs.c b/drivers/gpu/drm/i915/gt/intel_engine_cs.c index d561573ed98c..51a0d860d551 100644 --- a/drivers/gpu/drm/i915/gt/intel_engine_cs.c +++ b/drivers/gpu/drm/i915/gt/intel_engine_cs.c @@ -739,7 +739,7 @@ static int engine_setup_common(struct intel_engine_cs *engine) err_cmd_parser: i915_sched_engine_put(engine->sched_engine); err_sched_engine: - intel_breadcrumbs_free(engine->breadcrumbs); + intel_breadcrumbs_put(engine->breadcrumbs); err_status: cleanup_status_page(engine); return err; @@ -948,7 +948,7 @@ void intel_engine_cleanup_common(struct intel_engine_cs *engine) GEM_BUG_ON(!list_empty(&engine->sched_engine->requests)); i915_sched_engine_put(engine->sched_engine); - intel_breadcrumbs_free(engine->breadcrumbs); + intel_breadcrumbs_put(engine->breadcrumbs); intel_engine_fini_retire(engine); intel_engine_cleanup_cmd_parser(engine); @@ -1265,6 +1265,30 @@ bool intel_engines_are_idle(struct intel_gt *gt) return true; } +bool intel_engine_irq_enable(struct intel_engine_cs *engine) +{ + if (!engine->irq_enable) + return false; + + /* Caller disables interrupts */ + spin_lock(&engine->gt->irq_lock); + engine->irq_enable(engine); + spin_unlock(&engine->gt->irq_lock); + + return true; +} + +void intel_engine_irq_disable(struct intel_engine_cs *engine) +{ + if (!engine->irq_disable) + return; + + /* Caller disables interrupts */ + spin_lock(&engine->gt->irq_lock); + engine->irq_disable(engine); + spin_unlock(&engine->gt->irq_lock); +} + void intel_engines_reset_default_submission(struct intel_gt *gt) { struct intel_engine_cs *engine; @@ -1601,6 +1625,97 @@ static void print_properties(struct intel_engine_cs *engine, read_ul(&engine->defaults, p->offset)); } +static void engine_dump_request(struct i915_request *rq, struct drm_printer *m, const char *msg) +{ + struct intel_timeline *tl = get_timeline(rq); + + i915_request_show(m, rq, msg, 0); + + drm_printf(m, "\t\tring->start: 0x%08x\n", + i915_ggtt_offset(rq->ring->vma)); + drm_printf(m, "\t\tring->head: 0x%08x\n", + rq->ring->head); + drm_printf(m, "\t\tring->tail: 0x%08x\n", + rq->ring->tail); + drm_printf(m, "\t\tring->emit: 0x%08x\n", + rq->ring->emit); + drm_printf(m, "\t\tring->space: 0x%08x\n", + rq->ring->space); + + if (tl) { + drm_printf(m, "\t\tring->hwsp: 0x%08x\n", + tl->hwsp_offset); + intel_timeline_put(tl); + } + + print_request_ring(m, rq); + + if (rq->context->lrc_reg_state) { + drm_printf(m, "Logical Ring Context:\n"); + hexdump(m, rq->context->lrc_reg_state, PAGE_SIZE); + } +} + +void intel_engine_dump_active_requests(struct list_head *requests, + struct i915_request *hung_rq, + struct drm_printer *m) +{ + struct i915_request *rq; + const char *msg; + enum i915_request_state state; + + list_for_each_entry(rq, requests, sched.link) { + if (rq == hung_rq) + continue; + + state = i915_test_request_state(rq); + if (state < I915_REQUEST_QUEUED) + continue; + + if (state == I915_REQUEST_ACTIVE) + msg = "\t\tactive on engine"; + else + msg = "\t\tactive in queue"; + + engine_dump_request(rq, m, msg); + } +} + +static void engine_dump_active_requests(struct intel_engine_cs *engine, struct drm_printer *m) +{ + struct i915_request *hung_rq = NULL; + struct intel_context *ce; + bool guc; + + /* + * No need for an engine->irq_seqno_barrier() before the seqno reads. + * The GPU is still running so requests are still executing and any + * hardware reads will be out of date by the time they are reported. + * But the intention here is just to report an instantaneous snapshot + * so that's fine. + */ + lockdep_assert_held(&engine->sched_engine->lock); + + drm_printf(m, "\tRequests:\n"); + + guc = intel_uc_uses_guc_submission(&engine->gt->uc); + if (guc) { + ce = intel_engine_get_hung_context(engine); + if (ce) + hung_rq = intel_context_find_active_request(ce); + } else + hung_rq = intel_engine_execlist_find_hung_request(engine); + + if (hung_rq) + engine_dump_request(hung_rq, m, "\t\thung"); + + if (guc) + intel_guc_dump_active_requests(engine, hung_rq, m); + else + intel_engine_dump_active_requests(&engine->sched_engine->requests, + hung_rq, m); +} + void intel_engine_dump(struct intel_engine_cs *engine, struct drm_printer *m, const char *header, ...) @@ -1645,39 +1760,9 @@ void intel_engine_dump(struct intel_engine_cs *engine, i915_reset_count(error)); print_properties(engine, m); - drm_printf(m, "\tRequests:\n"); - spin_lock_irqsave(&engine->sched_engine->lock, flags); - rq = intel_engine_find_active_request(engine); - if (rq) { - struct intel_timeline *tl = get_timeline(rq); + engine_dump_active_requests(engine, m); - i915_request_show(m, rq, "\t\tactive ", 0); - - drm_printf(m, "\t\tring->start: 0x%08x\n", - i915_ggtt_offset(rq->ring->vma)); - drm_printf(m, "\t\tring->head: 0x%08x\n", - rq->ring->head); - drm_printf(m, "\t\tring->tail: 0x%08x\n", - rq->ring->tail); - drm_printf(m, "\t\tring->emit: 0x%08x\n", - rq->ring->emit); - drm_printf(m, "\t\tring->space: 0x%08x\n", - rq->ring->space); - - if (tl) { - drm_printf(m, "\t\tring->hwsp: 0x%08x\n", - tl->hwsp_offset); - intel_timeline_put(tl); - } - - print_request_ring(m, rq); - - if (rq->context->lrc_reg_state) { - drm_printf(m, "Logical Ring Context:\n"); - hexdump(m, rq->context->lrc_reg_state, PAGE_SIZE); - } - } drm_printf(m, "\tOn hold?: %lu\n", list_count(&engine->sched_engine->hold)); spin_unlock_irqrestore(&engine->sched_engine->lock, flags); @@ -1737,18 +1822,32 @@ ktime_t intel_engine_get_busy_time(struct intel_engine_cs *engine, ktime_t *now) return total; } -static bool match_ring(struct i915_request *rq) +struct intel_context * +intel_engine_create_virtual(struct intel_engine_cs **siblings, + unsigned int count) { - u32 ring = ENGINE_READ(rq->engine, RING_START); + if (count == 0) + return ERR_PTR(-EINVAL); + + if (count == 1) + return intel_context_create(siblings[0]); - return ring == i915_ggtt_offset(rq->ring->vma); + GEM_BUG_ON(!siblings[0]->cops->create_virtual); + return siblings[0]->cops->create_virtual(siblings, count); } struct i915_request * -intel_engine_find_active_request(struct intel_engine_cs *engine) +intel_engine_execlist_find_hung_request(struct intel_engine_cs *engine) { struct i915_request *request, *active = NULL; + /* + * This search does not work in GuC submission mode. However, the GuC + * will report the hanging context directly to the driver itself. So + * the driver should never get here when in GuC mode. + */ + GEM_BUG_ON(intel_uc_uses_guc_submission(&engine->gt->uc)); + /* * We are called by the error capture, reset and to dump engine * state at random points in time. In particular, note that neither is @@ -1780,14 +1879,7 @@ intel_engine_find_active_request(struct intel_engine_cs *engine) list_for_each_entry(request, &engine->sched_engine->requests, sched.link) { - if (__i915_request_is_complete(request)) - continue; - - if (!__i915_request_has_started(request)) - continue; - - /* More than one preemptible request may match! */ - if (!match_ring(request)) + if (i915_test_request_state(request) != I915_REQUEST_ACTIVE) continue; active = request; diff --git a/drivers/gpu/drm/i915/gt/intel_engine_heartbeat.c b/drivers/gpu/drm/i915/gt/intel_engine_heartbeat.c index b6a305e6a974..f0768824de6f 100644 --- a/drivers/gpu/drm/i915/gt/intel_engine_heartbeat.c +++ b/drivers/gpu/drm/i915/gt/intel_engine_heartbeat.c @@ -70,12 +70,38 @@ static void show_heartbeat(const struct i915_request *rq, { struct drm_printer p = drm_debug_printer("heartbeat"); - intel_engine_dump(engine, &p, - "%s heartbeat {seqno:%llx:%lld, prio:%d} not ticking\n", - engine->name, - rq->fence.context, - rq->fence.seqno, - rq->sched.attr.priority); + if (!rq) { + intel_engine_dump(engine, &p, + "%s heartbeat not ticking\n", + engine->name); + } else { + intel_engine_dump(engine, &p, + "%s heartbeat {seqno:%llx:%lld, prio:%d} not ticking\n", + engine->name, + rq->fence.context, + rq->fence.seqno, + rq->sched.attr.priority); + } +} + +static void +reset_engine(struct intel_engine_cs *engine, struct i915_request *rq) +{ + if (IS_ENABLED(CONFIG_DRM_I915_DEBUG_GEM)) + show_heartbeat(rq, engine); + + if (intel_engine_uses_guc(engine)) + /* + * GuC itself is toast or GuC's hang detection + * is disabled. Either way, need to find the + * hang culprit manually. + */ + intel_guc_find_hung_context(engine); + + intel_gt_handle_error(engine->gt, engine->mask, + I915_ERROR_CAPTURE, + "stopped heartbeat on %s", + engine->name); } static void heartbeat(struct work_struct *wrk) @@ -102,6 +128,11 @@ static void heartbeat(struct work_struct *wrk) if (intel_gt_is_wedged(engine->gt)) goto out; + if (i915_sched_engine_disabled(engine->sched_engine)) { + reset_engine(engine, engine->heartbeat.systole); + goto out; + } + if (engine->heartbeat.systole) { long delay = READ_ONCE(engine->props.heartbeat_interval_ms); @@ -139,13 +170,7 @@ static void heartbeat(struct work_struct *wrk) engine->sched_engine->schedule(rq, &attr); local_bh_enable(); } else { - if (IS_ENABLED(CONFIG_DRM_I915_DEBUG_GEM)) - show_heartbeat(rq, engine); - - intel_gt_handle_error(engine->gt, engine->mask, - I915_ERROR_CAPTURE, - "stopped heartbeat on %s", - engine->name); + reset_engine(engine, rq); } rq->emitted_jiffies = jiffies; @@ -194,6 +219,26 @@ void intel_engine_park_heartbeat(struct intel_engine_cs *engine) i915_request_put(fetch_and_zero(&engine->heartbeat.systole)); } +void intel_gt_unpark_heartbeats(struct intel_gt *gt) +{ + struct intel_engine_cs *engine; + enum intel_engine_id id; + + for_each_engine(engine, gt, id) + if (intel_engine_pm_is_awake(engine)) + intel_engine_unpark_heartbeat(engine); + +} + +void intel_gt_park_heartbeats(struct intel_gt *gt) +{ + struct intel_engine_cs *engine; + enum intel_engine_id id; + + for_each_engine(engine, gt, id) + intel_engine_park_heartbeat(engine); +} + void intel_engine_init_heartbeat(struct intel_engine_cs *engine) { INIT_DELAYED_WORK(&engine->heartbeat.work, heartbeat); diff --git a/drivers/gpu/drm/i915/gt/intel_engine_heartbeat.h b/drivers/gpu/drm/i915/gt/intel_engine_heartbeat.h index a488ea3e84a3..5da6d809a87a 100644 --- a/drivers/gpu/drm/i915/gt/intel_engine_heartbeat.h +++ b/drivers/gpu/drm/i915/gt/intel_engine_heartbeat.h @@ -7,6 +7,7 @@ #define INTEL_ENGINE_HEARTBEAT_H struct intel_engine_cs; +struct intel_gt; void intel_engine_init_heartbeat(struct intel_engine_cs *engine); @@ -16,6 +17,9 @@ int intel_engine_set_heartbeat(struct intel_engine_cs *engine, void intel_engine_park_heartbeat(struct intel_engine_cs *engine); void intel_engine_unpark_heartbeat(struct intel_engine_cs *engine); +void intel_gt_park_heartbeats(struct intel_gt *gt); +void intel_gt_unpark_heartbeats(struct intel_gt *gt); + int intel_engine_pulse(struct intel_engine_cs *engine); int intel_engine_flush_barriers(struct intel_engine_cs *engine); diff --git a/drivers/gpu/drm/i915/gt/intel_engine_types.h b/drivers/gpu/drm/i915/gt/intel_engine_types.h index 1cb9c3b70b29..eec57e57403f 100644 --- a/drivers/gpu/drm/i915/gt/intel_engine_types.h +++ b/drivers/gpu/drm/i915/gt/intel_engine_types.h @@ -21,7 +21,6 @@ #include "i915_pmu.h" #include "i915_priolist_types.h" #include "i915_selftest.h" -#include "intel_breadcrumbs_types.h" #include "intel_sseu.h" #include "intel_timeline_types.h" #include "intel_uncore.h" @@ -63,6 +62,7 @@ struct i915_sched_engine; struct intel_gt; struct intel_ring; struct intel_uncore; +struct intel_breadcrumbs; typedef u8 intel_engine_mask_t; #define ALL_ENGINES ((intel_engine_mask_t)~0ul) @@ -304,6 +304,8 @@ struct intel_engine_cs { /* keep a request in reserve for a [pm] barrier under oom */ struct i915_request *request_pool; + struct intel_context *hung_ce; + struct llist_head barrier_tasks; struct intel_context *kernel_context; /* pinned */ @@ -388,6 +390,8 @@ struct intel_engine_cs { void (*park)(struct intel_engine_cs *engine); void (*unpark)(struct intel_engine_cs *engine); + void (*bump_serial)(struct intel_engine_cs *engine); + void (*set_default_submission)(struct intel_engine_cs *engine); const struct intel_context_ops *cops; @@ -418,6 +422,12 @@ struct intel_engine_cs { void (*release)(struct intel_engine_cs *engine); + /* + * Add / remove request from engine active tracking + */ + void (*add_active_request)(struct i915_request *rq); + void (*remove_active_request)(struct i915_request *rq); + struct intel_engine_execlists execlists; /* @@ -439,6 +449,7 @@ struct intel_engine_cs { #define I915_ENGINE_IS_VIRTUAL BIT(5) #define I915_ENGINE_HAS_RELATIVE_MMIO BIT(6) #define I915_ENGINE_REQUIRES_CMD_PARSER BIT(7) +#define I915_ENGINE_WANT_FORCED_PREEMPTION BIT(8) unsigned int flags; /* diff --git a/drivers/gpu/drm/i915/gt/intel_engine_user.c b/drivers/gpu/drm/i915/gt/intel_engine_user.c index 84142127ebd8..8f8bea08e734 100644 --- a/drivers/gpu/drm/i915/gt/intel_engine_user.c +++ b/drivers/gpu/drm/i915/gt/intel_engine_user.c @@ -11,6 +11,7 @@ #include "intel_engine.h" #include "intel_engine_user.h" #include "intel_gt.h" +#include "uc/intel_guc_submission.h" struct intel_engine_cs * intel_engine_lookup_user(struct drm_i915_private *i915, u8 class, u8 instance) @@ -115,6 +116,9 @@ static void set_scheduler_caps(struct drm_i915_private *i915) disabled |= (I915_SCHEDULER_CAP_ENABLED | I915_SCHEDULER_CAP_PRIORITY); + if (intel_uc_uses_guc_submission(&i915->gt.uc)) + enabled |= I915_SCHEDULER_CAP_STATIC_PRIORITY_MAP; + for (i = 0; i < ARRAY_SIZE(map); i++) { if (engine->flags & BIT(map[i].engine)) enabled |= BIT(map[i].sched); diff --git a/drivers/gpu/drm/i915/gt/intel_execlists_submission.c b/drivers/gpu/drm/i915/gt/intel_execlists_submission.c index 56e25090da67..2aa5cc100956 100644 --- a/drivers/gpu/drm/i915/gt/intel_execlists_submission.c +++ b/drivers/gpu/drm/i915/gt/intel_execlists_submission.c @@ -114,6 +114,7 @@ #include "gen8_engine_cs.h" #include "intel_breadcrumbs.h" #include "intel_context.h" +#include "intel_engine_heartbeat.h" #include "intel_engine_pm.h" #include "intel_engine_stats.h" #include "intel_execlists_submission.h" @@ -193,6 +194,9 @@ static struct virtual_engine *to_virtual_engine(struct intel_engine_cs *engine) return container_of(engine, struct virtual_engine, base); } +static struct intel_context * +execlists_create_virtual(struct intel_engine_cs **siblings, unsigned int count); + static struct i915_request * __active_request(const struct intel_timeline * const tl, struct i915_request *rq, @@ -2533,11 +2537,26 @@ static int execlists_context_alloc(struct intel_context *ce) return lrc_alloc(ce, ce->engine); } +static void execlists_context_cancel_request(struct intel_context *ce, + struct i915_request *rq) +{ + struct intel_engine_cs *engine = NULL; + + i915_request_active_engine(rq, &engine); + + if (engine && intel_engine_pulse(engine)) + intel_gt_handle_error(engine->gt, engine->mask, 0, + "request cancellation by %s", + current->comm); +} + static const struct intel_context_ops execlists_context_ops = { .flags = COPS_HAS_INFLIGHT, .alloc = execlists_context_alloc, + .cancel_request = execlists_context_cancel_request, + .pre_pin = execlists_context_pre_pin, .pin = execlists_context_pin, .unpin = lrc_unpin, @@ -2548,6 +2567,8 @@ static const struct intel_context_ops execlists_context_ops = { .reset = lrc_reset, .destroy = lrc_destroy, + + .create_virtual = execlists_create_virtual, }; static int emit_pdps(struct i915_request *rq) @@ -3101,6 +3122,42 @@ static void execlists_park(struct intel_engine_cs *engine) cancel_timer(&engine->execlists.preempt); } +static void add_to_engine(struct i915_request *rq) +{ + lockdep_assert_held(&rq->engine->sched_engine->lock); + list_move_tail(&rq->sched.link, &rq->engine->sched_engine->requests); +} + +static void remove_from_engine(struct i915_request *rq) +{ + struct intel_engine_cs *engine, *locked; + + /* + * Virtual engines complicate acquiring the engine timeline lock, + * as their rq->engine pointer is not stable until under that + * engine lock. The simple ploy we use is to take the lock then + * check that the rq still belongs to the newly locked engine. + */ + locked = READ_ONCE(rq->engine); + spin_lock_irq(&locked->sched_engine->lock); + while (unlikely(locked != (engine = READ_ONCE(rq->engine)))) { + spin_unlock(&locked->sched_engine->lock); + spin_lock(&engine->sched_engine->lock); + locked = engine; + } + list_del_init(&rq->sched.link); + + clear_bit(I915_FENCE_FLAG_PQUEUE, &rq->fence.flags); + clear_bit(I915_FENCE_FLAG_HOLD, &rq->fence.flags); + + /* Prevent further __await_execution() registering a cb, then flush */ + set_bit(I915_FENCE_FLAG_ACTIVE, &rq->fence.flags); + + spin_unlock_irq(&locked->sched_engine->lock); + + i915_request_notify_execute_cb_imm(rq); +} + static bool can_preempt(struct intel_engine_cs *engine) { if (GRAPHICS_VER(engine->i915) > 8) @@ -3195,6 +3252,8 @@ logical_ring_default_vfuncs(struct intel_engine_cs *engine) engine->cops = &execlists_context_ops; engine->request_alloc = execlists_request_alloc; + engine->add_active_request = add_to_engine; + engine->remove_active_request = remove_from_engine; engine->reset.prepare = execlists_reset_prepare; engine->reset.rewind = execlists_reset_rewind; @@ -3396,7 +3455,7 @@ static void rcu_virtual_context_destroy(struct work_struct *wrk) intel_context_fini(&ve->context); if (ve->base.breadcrumbs) - intel_breadcrumbs_free(ve->base.breadcrumbs); + intel_breadcrumbs_put(ve->base.breadcrumbs); if (ve->base.sched_engine) i915_sched_engine_put(ve->base.sched_engine); intel_engine_free_request_pool(&ve->base); @@ -3493,11 +3552,24 @@ static void virtual_context_exit(struct intel_context *ce) intel_engine_pm_put(ve->siblings[n]); } +static struct intel_engine_cs * +virtual_get_sibling(struct intel_engine_cs *engine, unsigned int sibling) +{ + struct virtual_engine *ve = to_virtual_engine(engine); + + if (sibling >= ve->num_siblings) + return NULL; + + return ve->siblings[sibling]; +} + static const struct intel_context_ops virtual_context_ops = { .flags = COPS_HAS_INFLIGHT, .alloc = virtual_context_alloc, + .cancel_request = execlists_context_cancel_request, + .pre_pin = virtual_context_pre_pin, .pin = virtual_context_pin, .unpin = lrc_unpin, @@ -3507,6 +3579,8 @@ static const struct intel_context_ops virtual_context_ops = { .exit = virtual_context_exit, .destroy = virtual_context_destroy, + + .get_sibling = virtual_get_sibling, }; static intel_engine_mask_t virtual_submission_mask(struct virtual_engine *ve) @@ -3655,20 +3729,13 @@ static void virtual_submit_request(struct i915_request *rq) spin_unlock_irqrestore(&ve->base.sched_engine->lock, flags); } -struct intel_context * -intel_execlists_create_virtual(struct intel_engine_cs **siblings, - unsigned int count) +static struct intel_context * +execlists_create_virtual(struct intel_engine_cs **siblings, unsigned int count) { struct virtual_engine *ve; unsigned int n; int err; - if (count == 0) - return ERR_PTR(-EINVAL); - - if (count == 1) - return intel_context_create(siblings[0]); - ve = kzalloc(struct_size(ve, siblings, count), GFP_KERNEL); if (!ve) return ERR_PTR(-ENOMEM); @@ -3780,6 +3847,8 @@ intel_execlists_create_virtual(struct intel_engine_cs **siblings, "v%dx%d", ve->base.class, count); ve->base.context_size = sibling->context_size; + ve->base.add_active_request = sibling->add_active_request; + ve->base.remove_active_request = sibling->remove_active_request; ve->base.emit_bb_start = sibling->emit_bb_start; ve->base.emit_flush = sibling->emit_flush; ve->base.emit_init_breadcrumb = sibling->emit_init_breadcrumb; diff --git a/drivers/gpu/drm/i915/gt/intel_execlists_submission.h b/drivers/gpu/drm/i915/gt/intel_execlists_submission.h index ad4f3e1a0fde..a1aa92c983a5 100644 --- a/drivers/gpu/drm/i915/gt/intel_execlists_submission.h +++ b/drivers/gpu/drm/i915/gt/intel_execlists_submission.h @@ -32,10 +32,6 @@ void intel_execlists_show_requests(struct intel_engine_cs *engine, int indent), unsigned int max); -struct intel_context * -intel_execlists_create_virtual(struct intel_engine_cs **siblings, - unsigned int count); - bool intel_engine_in_execlists_submission_mode(const struct intel_engine_cs *engine); diff --git a/drivers/gpu/drm/i915/gt/intel_gt.c b/drivers/gpu/drm/i915/gt/intel_gt.c index e714e21c0a4d..ceeb517ba259 100644 --- a/drivers/gpu/drm/i915/gt/intel_gt.c +++ b/drivers/gpu/drm/i915/gt/intel_gt.c @@ -585,6 +585,25 @@ static void __intel_gt_disable(struct intel_gt *gt) GEM_BUG_ON(intel_gt_pm_is_awake(gt)); } +int intel_gt_wait_for_idle(struct intel_gt *gt, long timeout) +{ + long remaining_timeout; + + /* If the device is asleep, we have no requests outstanding */ + if (!intel_gt_pm_is_awake(gt)) + return 0; + + while ((timeout = intel_gt_retire_requests_timeout(gt, timeout, + &remaining_timeout)) > 0) { + cond_resched(); + if (signal_pending(current)) + return -EINTR; + } + + return timeout ? timeout : intel_uc_wait_for_idle(>->uc, + remaining_timeout); +} + int intel_gt_init(struct intel_gt *gt) { int err; @@ -635,6 +654,8 @@ int intel_gt_init(struct intel_gt *gt) if (err) goto err_gt; + intel_uc_init_late(>->uc); + err = i915_inject_probe_error(gt->i915, -EIO); if (err) goto err_gt; diff --git a/drivers/gpu/drm/i915/gt/intel_gt.h b/drivers/gpu/drm/i915/gt/intel_gt.h index e7aabe0cc5bf..74e771871a9b 100644 --- a/drivers/gpu/drm/i915/gt/intel_gt.h +++ b/drivers/gpu/drm/i915/gt/intel_gt.h @@ -48,6 +48,8 @@ void intel_gt_driver_release(struct intel_gt *gt); void intel_gt_driver_late_release(struct intel_gt *gt); +int intel_gt_wait_for_idle(struct intel_gt *gt, long timeout); + void intel_gt_check_and_clear_faults(struct intel_gt *gt); void intel_gt_clear_error_registers(struct intel_gt *gt, intel_engine_mask_t engine_mask); diff --git a/drivers/gpu/drm/i915/gt/intel_gt_pm.c b/drivers/gpu/drm/i915/gt/intel_gt_pm.c index aef3084e8b16..463a6ae605a0 100644 --- a/drivers/gpu/drm/i915/gt/intel_gt_pm.c +++ b/drivers/gpu/drm/i915/gt/intel_gt_pm.c @@ -174,8 +174,6 @@ static void gt_sanitize(struct intel_gt *gt, bool force) if (intel_gt_is_wedged(gt)) intel_gt_unset_wedged(gt); - intel_uc_sanitize(>->uc); - for_each_engine(engine, gt, id) if (engine->reset.prepare) engine->reset.prepare(engine); @@ -191,6 +189,8 @@ static void gt_sanitize(struct intel_gt *gt, bool force) __intel_engine_reset(engine, false); } + intel_uc_reset(>->uc, false); + for_each_engine(engine, gt, id) if (engine->reset.finish) engine->reset.finish(engine); @@ -243,6 +243,8 @@ int intel_gt_resume(struct intel_gt *gt) goto err_wedged; } + intel_uc_reset_finish(>->uc); + intel_rps_enable(>->rps); intel_llc_enable(>->llc); diff --git a/drivers/gpu/drm/i915/gt/intel_gt_requests.c b/drivers/gpu/drm/i915/gt/intel_gt_requests.c index 647eca9d867a..edb881d75630 100644 --- a/drivers/gpu/drm/i915/gt/intel_gt_requests.c +++ b/drivers/gpu/drm/i915/gt/intel_gt_requests.c @@ -130,7 +130,8 @@ void intel_engine_fini_retire(struct intel_engine_cs *engine) GEM_BUG_ON(engine->retire); } -long intel_gt_retire_requests_timeout(struct intel_gt *gt, long timeout) +long intel_gt_retire_requests_timeout(struct intel_gt *gt, long timeout, + long *remaining_timeout) { struct intel_gt_timelines *timelines = >->timelines; struct intel_timeline *tl, *tn; @@ -195,22 +196,10 @@ out_active: spin_lock(&timelines->lock); if (flush_submission(gt, timeout)) /* Wait, there's more! */ active_count++; - return active_count ? timeout : 0; -} - -int intel_gt_wait_for_idle(struct intel_gt *gt, long timeout) -{ - /* If the device is asleep, we have no requests outstanding */ - if (!intel_gt_pm_is_awake(gt)) - return 0; - - while ((timeout = intel_gt_retire_requests_timeout(gt, timeout)) > 0) { - cond_resched(); - if (signal_pending(current)) - return -EINTR; - } + if (remaining_timeout) + *remaining_timeout = timeout; - return timeout; + return active_count ? timeout : 0; } static void retire_work_handler(struct work_struct *work) diff --git a/drivers/gpu/drm/i915/gt/intel_gt_requests.h b/drivers/gpu/drm/i915/gt/intel_gt_requests.h index fcc30a6e4fe9..51dbe0e3294e 100644 --- a/drivers/gpu/drm/i915/gt/intel_gt_requests.h +++ b/drivers/gpu/drm/i915/gt/intel_gt_requests.h @@ -6,14 +6,17 @@ #ifndef INTEL_GT_REQUESTS_H #define INTEL_GT_REQUESTS_H +#include + struct intel_engine_cs; struct intel_gt; struct intel_timeline; -long intel_gt_retire_requests_timeout(struct intel_gt *gt, long timeout); +long intel_gt_retire_requests_timeout(struct intel_gt *gt, long timeout, + long *remaining_timeout); static inline void intel_gt_retire_requests(struct intel_gt *gt) { - intel_gt_retire_requests_timeout(gt, 0); + intel_gt_retire_requests_timeout(gt, 0, NULL); } void intel_engine_init_retire(struct intel_engine_cs *engine); @@ -21,8 +24,6 @@ void intel_engine_add_retire(struct intel_engine_cs *engine, struct intel_timeline *tl); void intel_engine_fini_retire(struct intel_engine_cs *engine); -int intel_gt_wait_for_idle(struct intel_gt *gt, long timeout); - void intel_gt_init_requests(struct intel_gt *gt); void intel_gt_park_requests(struct intel_gt *gt); void intel_gt_unpark_requests(struct intel_gt *gt); diff --git a/drivers/gpu/drm/i915/gt/intel_lrc_reg.h b/drivers/gpu/drm/i915/gt/intel_lrc_reg.h index 41e5350a7a05..49d4857ad9b7 100644 --- a/drivers/gpu/drm/i915/gt/intel_lrc_reg.h +++ b/drivers/gpu/drm/i915/gt/intel_lrc_reg.h @@ -87,7 +87,6 @@ #define GEN11_CSB_WRITE_PTR_MASK (GEN11_CSB_PTR_MASK << 0) #define MAX_CONTEXT_HW_ID (1 << 21) /* exclusive */ -#define MAX_GUC_CONTEXT_HW_ID (1 << 20) /* exclusive */ #define GEN11_MAX_CONTEXT_HW_ID (1 << 11) /* exclusive */ /* in Gen12 ID 0x7FF is reserved to indicate idle */ #define GEN12_MAX_CONTEXT_HW_ID (GEN11_MAX_CONTEXT_HW_ID - 1) diff --git a/drivers/gpu/drm/i915/gt/intel_reset.c b/drivers/gpu/drm/i915/gt/intel_reset.c index 72251638d4ea..3ed694cab5af 100644 --- a/drivers/gpu/drm/i915/gt/intel_reset.c +++ b/drivers/gpu/drm/i915/gt/intel_reset.c @@ -22,7 +22,6 @@ #include "intel_reset.h" #include "uc/intel_guc.h" -#include "uc/intel_guc_submission.h" #define RESET_MAX_RETRIES 3 @@ -39,21 +38,6 @@ static void rmw_clear_fw(struct intel_uncore *uncore, i915_reg_t reg, u32 clr) intel_uncore_rmw_fw(uncore, reg, clr, 0); } -static void skip_context(struct i915_request *rq) -{ - struct intel_context *hung_ctx = rq->context; - - list_for_each_entry_from_rcu(rq, &hung_ctx->timeline->requests, link) { - if (!i915_request_is_active(rq)) - return; - - if (rq->context == hung_ctx) { - i915_request_set_error_once(rq, -EIO); - __i915_request_skip(rq); - } - } -} - static void client_mark_guilty(struct i915_gem_context *ctx, bool banned) { struct drm_i915_file_private *file_priv = ctx->file_priv; @@ -88,10 +72,8 @@ static bool mark_guilty(struct i915_request *rq) bool banned; int i; - if (intel_context_is_closed(rq->context)) { - intel_context_set_banned(rq->context); + if (intel_context_is_closed(rq->context)) return true; - } rcu_read_lock(); ctx = rcu_dereference(rq->context->gem_context); @@ -123,11 +105,9 @@ static bool mark_guilty(struct i915_request *rq) banned = !i915_gem_context_is_recoverable(ctx); if (time_before(jiffies, prev_hang + CONTEXT_FAST_HANG_JIFFIES)) banned = true; - if (banned) { + if (banned) drm_dbg(&ctx->i915->drm, "context %s: guilty %d, banned\n", ctx->name, atomic_read(&ctx->guilty_count)); - intel_context_set_banned(rq->context); - } client_mark_guilty(ctx, banned); @@ -149,6 +129,8 @@ static void mark_innocent(struct i915_request *rq) void __i915_request_reset(struct i915_request *rq, bool guilty) { + bool banned = false; + RQ_TRACE(rq, "guilty? %s\n", yesno(guilty)); GEM_BUG_ON(__i915_request_is_complete(rq)); @@ -156,13 +138,15 @@ void __i915_request_reset(struct i915_request *rq, bool guilty) if (guilty) { i915_request_set_error_once(rq, -EIO); __i915_request_skip(rq); - if (mark_guilty(rq)) - skip_context(rq); + banned = mark_guilty(rq); } else { i915_request_set_error_once(rq, -EAGAIN); mark_innocent(rq); } rcu_read_unlock(); + + if (banned) + intel_context_ban(rq->context, rq); } static bool i915_in_reset(struct pci_dev *pdev) @@ -826,6 +810,8 @@ static int gt_reset(struct intel_gt *gt, intel_engine_mask_t stalled_mask) __intel_engine_reset(engine, stalled_mask & engine->mask); local_bh_enable(); + intel_uc_reset(>->uc, true); + intel_ggtt_restore_fences(gt->ggtt); return err; @@ -850,6 +836,8 @@ static void reset_finish(struct intel_gt *gt, intel_engine_mask_t awake) if (awake & engine->mask) intel_engine_pm_put(engine); } + + intel_uc_reset_finish(>->uc); } static void nop_submit_request(struct i915_request *request) @@ -903,6 +891,7 @@ static void __intel_gt_set_wedged(struct intel_gt *gt) for_each_engine(engine, gt, id) if (engine->reset.cancel) engine->reset.cancel(engine); + intel_uc_cancel_requests(>->uc); local_bh_enable(); reset_finish(gt, awake); @@ -1191,6 +1180,9 @@ int __intel_engine_reset_bh(struct intel_engine_cs *engine, const char *msg) ENGINE_TRACE(engine, "flags=%lx\n", gt->reset.flags); GEM_BUG_ON(!test_bit(I915_RESET_ENGINE + engine->id, >->reset.flags)); + if (intel_engine_uses_guc(engine)) + return -ENODEV; + if (!intel_engine_pm_get_if_awake(engine)) return 0; @@ -1201,13 +1193,10 @@ int __intel_engine_reset_bh(struct intel_engine_cs *engine, const char *msg) "Resetting %s for %s\n", engine->name, msg); atomic_inc(&engine->i915->gpu_error.reset_engine_count[engine->uabi_class]); - if (intel_engine_uses_guc(engine)) - ret = intel_guc_reset_engine(&engine->gt->uc.guc, engine); - else - ret = intel_gt_reset_engine(engine); + ret = intel_gt_reset_engine(engine); if (ret) { /* If we fail here, we expect to fallback to a global reset */ - ENGINE_TRACE(engine, "Failed to reset, err: %d\n", ret); + ENGINE_TRACE(engine, "Failed to reset %s, err: %d\n", engine->name, ret); goto out; } @@ -1341,7 +1330,8 @@ void intel_gt_handle_error(struct intel_gt *gt, * Try engine reset when available. We fall back to full reset if * single reset fails. */ - if (intel_has_reset_engine(gt) && !intel_gt_is_wedged(gt)) { + if (!intel_uc_uses_guc_submission(>->uc) && + intel_has_reset_engine(gt) && !intel_gt_is_wedged(gt)) { local_bh_disable(); for_each_engine_masked(engine, gt, engine_mask, tmp) { BUILD_BUG_ON(I915_RESET_MODESET >= I915_RESET_ENGINE); diff --git a/drivers/gpu/drm/i915/gt/intel_ring_submission.c b/drivers/gpu/drm/i915/gt/intel_ring_submission.c index 5c4d204d07cc..05bb9f449df1 100644 --- a/drivers/gpu/drm/i915/gt/intel_ring_submission.c +++ b/drivers/gpu/drm/i915/gt/intel_ring_submission.c @@ -586,9 +586,29 @@ static void ring_context_reset(struct intel_context *ce) clear_bit(CONTEXT_VALID_BIT, &ce->flags); } +static void ring_context_ban(struct intel_context *ce, + struct i915_request *rq) +{ + struct intel_engine_cs *engine; + + if (!rq || !i915_request_is_active(rq)) + return; + + engine = rq->engine; + lockdep_assert_held(&engine->sched_engine->lock); + list_for_each_entry_continue(rq, &engine->sched_engine->requests, + sched.link) + if (rq->context == ce) { + i915_request_set_error_once(rq, -EIO); + __i915_request_skip(rq); + } +} + static const struct intel_context_ops ring_context_ops = { .alloc = ring_context_alloc, + .ban = ring_context_ban, + .pre_pin = ring_context_pre_pin, .pin = ring_context_pin, .unpin = ring_context_unpin, @@ -1047,6 +1067,25 @@ static void setup_irq(struct intel_engine_cs *engine) } } +static void add_to_engine(struct i915_request *rq) +{ + lockdep_assert_held(&rq->engine->sched_engine->lock); + list_move_tail(&rq->sched.link, &rq->engine->sched_engine->requests); +} + +static void remove_from_engine(struct i915_request *rq) +{ + spin_lock_irq(&rq->engine->sched_engine->lock); + list_del_init(&rq->sched.link); + + /* Prevent further __await_execution() registering a cb, then flush */ + set_bit(I915_FENCE_FLAG_ACTIVE, &rq->fence.flags); + + spin_unlock_irq(&rq->engine->sched_engine->lock); + + i915_request_notify_execute_cb_imm(rq); +} + static void setup_common(struct intel_engine_cs *engine) { struct drm_i915_private *i915 = engine->i915; @@ -1064,6 +1103,9 @@ static void setup_common(struct intel_engine_cs *engine) engine->reset.cancel = reset_cancel; engine->reset.finish = reset_finish; + engine->add_active_request = add_to_engine; + engine->remove_active_request = remove_from_engine; + engine->cops = &ring_context_ops; engine->request_alloc = ring_request_alloc; diff --git a/drivers/gpu/drm/i915/gt/intel_rps.c b/drivers/gpu/drm/i915/gt/intel_rps.c index 06e9a8ed4e03..0c8e7f2b06f0 100644 --- a/drivers/gpu/drm/i915/gt/intel_rps.c +++ b/drivers/gpu/drm/i915/gt/intel_rps.c @@ -1877,6 +1877,10 @@ void intel_rps_init(struct intel_rps *rps) if (GRAPHICS_VER(i915) >= 8 && GRAPHICS_VER(i915) < 11) rps->pm_intrmsk_mbz |= GEN8_PMINTR_DISABLE_REDIRECT_TO_GUC; + + /* GuC needs ARAT expired interrupt unmasked */ + if (intel_uc_uses_guc_submission(&rps_to_gt(rps)->uc)) + rps->pm_intrmsk_mbz |= ARAT_EXPIRED_INTRMSK; } void intel_rps_sanitize(struct intel_rps *rps) diff --git a/drivers/gpu/drm/i915/gt/intel_workarounds.c b/drivers/gpu/drm/i915/gt/intel_workarounds.c index 7731db33c46a..2fd32dc0b521 100644 --- a/drivers/gpu/drm/i915/gt/intel_workarounds.c +++ b/drivers/gpu/drm/i915/gt/intel_workarounds.c @@ -150,13 +150,14 @@ static void _wa_add(struct i915_wa_list *wal, const struct i915_wa *wa) } static void wa_add(struct i915_wa_list *wal, i915_reg_t reg, - u32 clear, u32 set, u32 read_mask) + u32 clear, u32 set, u32 read_mask, bool masked_reg) { struct i915_wa wa = { .reg = reg, .clr = clear, .set = set, .read = read_mask, + .masked_reg = masked_reg, }; _wa_add(wal, &wa); @@ -165,7 +166,7 @@ static void wa_add(struct i915_wa_list *wal, i915_reg_t reg, static void wa_write_clr_set(struct i915_wa_list *wal, i915_reg_t reg, u32 clear, u32 set) { - wa_add(wal, reg, clear, set, clear); + wa_add(wal, reg, clear, set, clear, false); } static void @@ -200,20 +201,20 @@ wa_write_clr(struct i915_wa_list *wal, i915_reg_t reg, u32 clr) static void wa_masked_en(struct i915_wa_list *wal, i915_reg_t reg, u32 val) { - wa_add(wal, reg, 0, _MASKED_BIT_ENABLE(val), val); + wa_add(wal, reg, 0, _MASKED_BIT_ENABLE(val), val, true); } static void wa_masked_dis(struct i915_wa_list *wal, i915_reg_t reg, u32 val) { - wa_add(wal, reg, 0, _MASKED_BIT_DISABLE(val), val); + wa_add(wal, reg, 0, _MASKED_BIT_DISABLE(val), val, true); } static void wa_masked_field_set(struct i915_wa_list *wal, i915_reg_t reg, u32 mask, u32 val) { - wa_add(wal, reg, 0, _MASKED_FIELD(mask, val), mask); + wa_add(wal, reg, 0, _MASKED_FIELD(mask, val), mask, true); } static void gen6_ctx_workarounds_init(struct intel_engine_cs *engine, @@ -533,10 +534,10 @@ static void icl_ctx_workarounds_init(struct intel_engine_cs *engine, wa_masked_en(wal, ICL_HDC_MODE, HDC_FORCE_NON_COHERENT); /* WaEnableFloatBlendOptimization:icl */ - wa_write_clr_set(wal, - GEN10_CACHE_MODE_SS, - 0, /* write-only, so skip validation */ - _MASKED_BIT_ENABLE(FLOAT_BLEND_OPTIMIZATION_ENABLE)); + wa_add(wal, GEN10_CACHE_MODE_SS, 0, + _MASKED_BIT_ENABLE(FLOAT_BLEND_OPTIMIZATION_ENABLE), + 0 /* write-only, so skip validation */, + true); /* WaDisableGPGPUMidThreadPreemption:icl */ wa_masked_field_set(wal, GEN8_CS_CHICKEN1, @@ -581,7 +582,7 @@ static void gen12_ctx_gt_tuning_init(struct intel_engine_cs *engine, FF_MODE2, FF_MODE2_TDS_TIMER_MASK, FF_MODE2_TDS_TIMER_128, - 0); + 0, false); } static void gen12_ctx_workarounds_init(struct intel_engine_cs *engine, @@ -619,7 +620,7 @@ static void gen12_ctx_workarounds_init(struct intel_engine_cs *engine, FF_MODE2, FF_MODE2_GS_TIMER_MASK, FF_MODE2_GS_TIMER_224, - 0); + 0, false); /* * Wa_14012131227:dg1 @@ -795,7 +796,7 @@ hsw_gt_workarounds_init(struct drm_i915_private *i915, struct i915_wa_list *wal) wa_add(wal, HSW_ROW_CHICKEN3, 0, _MASKED_BIT_ENABLE(HSW_ROW_CHICKEN3_L3_GLOBAL_ATOMICS_DISABLE), - 0 /* XXX does this reg exist? */); + 0 /* XXX does this reg exist? */, true); /* WaVSRefCountFullforceMissDisable:hsw */ wa_write_clr(wal, GEN7_FF_THREAD_MODE, GEN7_FF_VS_REF_CNT_FFME); @@ -1843,10 +1844,10 @@ rcs_engine_wa_init(struct intel_engine_cs *engine, struct i915_wa_list *wal) * disable bit, which we don't touch here, but it's good * to keep in mind (see 3DSTATE_PS and 3DSTATE_WM). */ - wa_add(wal, GEN7_GT_MODE, 0, - _MASKED_FIELD(GEN6_WIZ_HASHING_MASK, - GEN6_WIZ_HASHING_16x4), - GEN6_WIZ_HASHING_16x4); + wa_masked_field_set(wal, + GEN7_GT_MODE, + GEN6_WIZ_HASHING_MASK, + GEN6_WIZ_HASHING_16x4); } if (IS_GRAPHICS_VER(i915, 6, 7)) @@ -1896,10 +1897,10 @@ rcs_engine_wa_init(struct intel_engine_cs *engine, struct i915_wa_list *wal) * disable bit, which we don't touch here, but it's good * to keep in mind (see 3DSTATE_PS and 3DSTATE_WM). */ - wa_add(wal, - GEN6_GT_MODE, 0, - _MASKED_FIELD(GEN6_WIZ_HASHING_MASK, GEN6_WIZ_HASHING_16x4), - GEN6_WIZ_HASHING_16x4); + wa_masked_field_set(wal, + GEN6_GT_MODE, + GEN6_WIZ_HASHING_MASK, + GEN6_WIZ_HASHING_16x4); /* WaDisable_RenderCache_OperationalFlush:snb */ wa_masked_dis(wal, CACHE_MODE_0, RC_OP_FLUSH_ENABLE); @@ -1920,7 +1921,7 @@ rcs_engine_wa_init(struct intel_engine_cs *engine, struct i915_wa_list *wal) wa_add(wal, MI_MODE, 0, _MASKED_BIT_ENABLE(VS_TIMER_DISPATCH), /* XXX bit doesn't stick on Broadwater */ - IS_I965G(i915) ? 0 : VS_TIMER_DISPATCH); + IS_I965G(i915) ? 0 : VS_TIMER_DISPATCH, true); if (GRAPHICS_VER(i915) == 4) /* @@ -1935,7 +1936,8 @@ rcs_engine_wa_init(struct intel_engine_cs *engine, struct i915_wa_list *wal) */ wa_add(wal, ECOSKPD, 0, _MASKED_BIT_ENABLE(ECO_CONSTANT_BUFFER_SR_DISABLE), - 0 /* XXX bit doesn't stick on Broadwater */); + 0 /* XXX bit doesn't stick on Broadwater */, + true); } static void diff --git a/drivers/gpu/drm/i915/gt/intel_workarounds_types.h b/drivers/gpu/drm/i915/gt/intel_workarounds_types.h index c214111ea367..1e873681795d 100644 --- a/drivers/gpu/drm/i915/gt/intel_workarounds_types.h +++ b/drivers/gpu/drm/i915/gt/intel_workarounds_types.h @@ -15,6 +15,7 @@ struct i915_wa { u32 clr; u32 set; u32 read; + bool masked_reg; }; struct i915_wa_list { diff --git a/drivers/gpu/drm/i915/gt/mock_engine.c b/drivers/gpu/drm/i915/gt/mock_engine.c index 68970398e4ef..2c1af030310c 100644 --- a/drivers/gpu/drm/i915/gt/mock_engine.c +++ b/drivers/gpu/drm/i915/gt/mock_engine.c @@ -235,6 +235,34 @@ static void mock_submit_request(struct i915_request *request) spin_unlock_irqrestore(&engine->hw_lock, flags); } +static void mock_add_to_engine(struct i915_request *rq) +{ + lockdep_assert_held(&rq->engine->sched_engine->lock); + list_move_tail(&rq->sched.link, &rq->engine->sched_engine->requests); +} + +static void mock_remove_from_engine(struct i915_request *rq) +{ + struct intel_engine_cs *engine, *locked; + + /* + * Virtual engines complicate acquiring the engine timeline lock, + * as their rq->engine pointer is not stable until under that + * engine lock. The simple ploy we use is to take the lock then + * check that the rq still belongs to the newly locked engine. + */ + + locked = READ_ONCE(rq->engine); + spin_lock_irq(&locked->sched_engine->lock); + while (unlikely(locked != (engine = READ_ONCE(rq->engine)))) { + spin_unlock(&locked->sched_engine->lock); + spin_lock(&engine->sched_engine->lock); + locked = engine; + } + list_del_init(&rq->sched.link); + spin_unlock_irq(&locked->sched_engine->lock); +} + static void mock_reset_prepare(struct intel_engine_cs *engine) { } @@ -284,7 +312,7 @@ static void mock_engine_release(struct intel_engine_cs *engine) GEM_BUG_ON(timer_pending(&mock->hw_delay)); i915_sched_engine_put(engine->sched_engine); - intel_breadcrumbs_free(engine->breadcrumbs); + intel_breadcrumbs_put(engine->breadcrumbs); intel_context_unpin(engine->kernel_context); intel_context_put(engine->kernel_context); @@ -321,6 +349,8 @@ struct intel_engine_cs *mock_engine(struct drm_i915_private *i915, engine->base.emit_flush = mock_emit_flush; engine->base.emit_fini_breadcrumb = mock_emit_breadcrumb; engine->base.submit_request = mock_submit_request; + engine->base.add_active_request = mock_add_to_engine; + engine->base.remove_active_request = mock_remove_from_engine; engine->base.reset.prepare = mock_reset_prepare; engine->base.reset.rewind = mock_reset_rewind; @@ -370,7 +400,7 @@ int mock_engine_init(struct intel_engine_cs *engine) return 0; err_breadcrumbs: - intel_breadcrumbs_free(engine->breadcrumbs); + intel_breadcrumbs_put(engine->breadcrumbs); err_schedule: i915_sched_engine_put(engine->sched_engine); return -ENOMEM; diff --git a/drivers/gpu/drm/i915/gt/selftest_context.c b/drivers/gpu/drm/i915/gt/selftest_context.c index 26685b927169..fa7b99a671dd 100644 --- a/drivers/gpu/drm/i915/gt/selftest_context.c +++ b/drivers/gpu/drm/i915/gt/selftest_context.c @@ -209,7 +209,13 @@ static int __live_active_context(struct intel_engine_cs *engine) * This test makes sure that the context is kept alive until a * subsequent idle-barrier (emitted when the engine wakeref hits 0 * with no more outstanding requests). + * + * In GuC submission mode we don't use idle barriers and we instead + * get a message from the GuC to signal that it is safe to unpin the + * context from memory. */ + if (intel_engine_uses_guc(engine)) + return 0; if (intel_engine_pm_is_awake(engine)) { pr_err("%s is awake before starting %s!\n", @@ -357,7 +363,11 @@ static int __live_remote_context(struct intel_engine_cs *engine) * on the context image remotely (intel_context_prepare_remote_request), * which inserts foreign fences into intel_context.active, does not * clobber the idle-barrier. + * + * In GuC submission mode we don't use idle barriers. */ + if (intel_engine_uses_guc(engine)) + return 0; if (intel_engine_pm_is_awake(engine)) { pr_err("%s is awake before starting %s!\n", diff --git a/drivers/gpu/drm/i915/gt/selftest_engine_heartbeat.c b/drivers/gpu/drm/i915/gt/selftest_engine_heartbeat.c index 4896e4ccad50..317eebf086c3 100644 --- a/drivers/gpu/drm/i915/gt/selftest_engine_heartbeat.c +++ b/drivers/gpu/drm/i915/gt/selftest_engine_heartbeat.c @@ -405,3 +405,25 @@ void st_engine_heartbeat_enable(struct intel_engine_cs *engine) engine->props.heartbeat_interval_ms = engine->defaults.heartbeat_interval_ms; } + +void st_engine_heartbeat_disable_no_pm(struct intel_engine_cs *engine) +{ + engine->props.heartbeat_interval_ms = 0; + + /* + * Park the heartbeat but without holding the PM lock as that + * makes the engines appear not-idle. Note that if/when unpark + * is called due to the PM lock being acquired later the + * heartbeat still won't be enabled because of the above = 0. + */ + if (intel_engine_pm_get_if_awake(engine)) { + intel_engine_park_heartbeat(engine); + intel_engine_pm_put(engine); + } +} + +void st_engine_heartbeat_enable_no_pm(struct intel_engine_cs *engine) +{ + engine->props.heartbeat_interval_ms = + engine->defaults.heartbeat_interval_ms; +} diff --git a/drivers/gpu/drm/i915/gt/selftest_engine_heartbeat.h b/drivers/gpu/drm/i915/gt/selftest_engine_heartbeat.h index cd27113d5400..81da2cd8e406 100644 --- a/drivers/gpu/drm/i915/gt/selftest_engine_heartbeat.h +++ b/drivers/gpu/drm/i915/gt/selftest_engine_heartbeat.h @@ -9,6 +9,8 @@ struct intel_engine_cs; void st_engine_heartbeat_disable(struct intel_engine_cs *engine); +void st_engine_heartbeat_disable_no_pm(struct intel_engine_cs *engine); void st_engine_heartbeat_enable(struct intel_engine_cs *engine); +void st_engine_heartbeat_enable_no_pm(struct intel_engine_cs *engine); #endif /* SELFTEST_ENGINE_HEARTBEAT_H */ diff --git a/drivers/gpu/drm/i915/gt/selftest_execlists.c b/drivers/gpu/drm/i915/gt/selftest_execlists.c index 73ddc6e14730..59cf8afc6d6f 100644 --- a/drivers/gpu/drm/i915/gt/selftest_execlists.c +++ b/drivers/gpu/drm/i915/gt/selftest_execlists.c @@ -3727,7 +3727,7 @@ static int nop_virtual_engine(struct intel_gt *gt, GEM_BUG_ON(!nctx || nctx > ARRAY_SIZE(ve)); for (n = 0; n < nctx; n++) { - ve[n] = intel_execlists_create_virtual(siblings, nsibling); + ve[n] = intel_engine_create_virtual(siblings, nsibling); if (IS_ERR(ve[n])) { err = PTR_ERR(ve[n]); nctx = n; @@ -3923,7 +3923,7 @@ static int mask_virtual_engine(struct intel_gt *gt, * restrict it to our desired engine within the virtual engine. */ - ve = intel_execlists_create_virtual(siblings, nsibling); + ve = intel_engine_create_virtual(siblings, nsibling); if (IS_ERR(ve)) { err = PTR_ERR(ve); goto out_close; @@ -4054,7 +4054,7 @@ static int slicein_virtual_engine(struct intel_gt *gt, i915_request_add(rq); } - ce = intel_execlists_create_virtual(siblings, nsibling); + ce = intel_engine_create_virtual(siblings, nsibling); if (IS_ERR(ce)) { err = PTR_ERR(ce); goto out; @@ -4106,7 +4106,7 @@ static int sliceout_virtual_engine(struct intel_gt *gt, /* XXX We do not handle oversubscription and fairness with normal rq */ for (n = 0; n < nsibling; n++) { - ce = intel_execlists_create_virtual(siblings, nsibling); + ce = intel_engine_create_virtual(siblings, nsibling); if (IS_ERR(ce)) { err = PTR_ERR(ce); goto out; @@ -4208,7 +4208,7 @@ static int preserved_virtual_engine(struct intel_gt *gt, if (err) goto out_scratch; - ve = intel_execlists_create_virtual(siblings, nsibling); + ve = intel_engine_create_virtual(siblings, nsibling); if (IS_ERR(ve)) { err = PTR_ERR(ve); goto out_scratch; @@ -4348,7 +4348,7 @@ static int reset_virtual_engine(struct intel_gt *gt, if (igt_spinner_init(&spin, gt)) return -ENOMEM; - ve = intel_execlists_create_virtual(siblings, nsibling); + ve = intel_engine_create_virtual(siblings, nsibling); if (IS_ERR(ve)) { err = PTR_ERR(ve); goto out_spin; diff --git a/drivers/gpu/drm/i915/gt/selftest_hangcheck.c b/drivers/gpu/drm/i915/gt/selftest_hangcheck.c index 7aea10aa1fb4..a93a9b0d258e 100644 --- a/drivers/gpu/drm/i915/gt/selftest_hangcheck.c +++ b/drivers/gpu/drm/i915/gt/selftest_hangcheck.c @@ -17,6 +17,8 @@ #include "selftests/igt_flush_test.h" #include "selftests/igt_reset.h" #include "selftests/igt_atomic.h" +#include "selftests/igt_spinner.h" +#include "selftests/intel_scheduler_helpers.h" #include "selftests/mock_drm.h" @@ -378,6 +380,7 @@ static int igt_reset_nop(void *arg) ce = intel_context_create(engine); if (IS_ERR(ce)) { err = PTR_ERR(ce); + pr_err("[%s] Create context failed: %d!\n", engine->name, err); break; } @@ -387,6 +390,7 @@ static int igt_reset_nop(void *arg) rq = intel_context_create_request(ce); if (IS_ERR(rq)) { err = PTR_ERR(rq); + pr_err("[%s] Create request failed: %d!\n", engine->name, err); break; } @@ -401,24 +405,31 @@ static int igt_reset_nop(void *arg) igt_global_reset_unlock(gt); if (intel_gt_is_wedged(gt)) { + pr_err("[%s] GT is wedged!\n", engine->name); err = -EIO; break; } if (i915_reset_count(global) != reset_count + ++count) { - pr_err("Full GPU reset not recorded!\n"); + pr_err("[%s] Reset not recorded: %d vs %d + %d!\n", + engine->name, i915_reset_count(global), reset_count, count); err = -EINVAL; break; } err = igt_flush_test(gt->i915); - if (err) + if (err) { + pr_err("[%s] Flush failed: %d!\n", engine->name, err); break; + } } while (time_before(jiffies, end_time)); pr_info("%s: %d resets\n", __func__, count); - if (igt_flush_test(gt->i915)) + if (igt_flush_test(gt->i915)) { + pr_err("Post flush failed: %d!\n", err); err = -EIO; + } + return err; } @@ -440,9 +451,19 @@ static int igt_reset_nop_engine(void *arg) IGT_TIMEOUT(end_time); int err; + if (intel_engine_uses_guc(engine)) { + /* Engine level resets are triggered by GuC when a hang + * is detected. They can't be triggered by the KMD any + * more. Thus a nop batch cannot be used as a reset test + */ + continue; + } + ce = intel_context_create(engine); - if (IS_ERR(ce)) + if (IS_ERR(ce)) { + pr_err("[%s] Create context failed: %d!\n", engine->name, err); return PTR_ERR(ce); + } reset_count = i915_reset_count(global); reset_engine_count = i915_reset_engine_count(global, engine); @@ -549,9 +570,15 @@ static int igt_reset_fail_engine(void *arg) IGT_TIMEOUT(end_time); int err; + /* Can't manually break the reset if i915 doesn't perform it */ + if (intel_engine_uses_guc(engine)) + continue; + ce = intel_context_create(engine); - if (IS_ERR(ce)) + if (IS_ERR(ce)) { + pr_err("[%s] Create context failed: %d!\n", engine->name, err); return PTR_ERR(ce); + } st_engine_heartbeat_disable(engine); set_bit(I915_RESET_ENGINE + id, >->reset.flags); @@ -686,8 +713,12 @@ static int __igt_reset_engine(struct intel_gt *gt, bool active) for_each_engine(engine, gt, id) { unsigned int reset_count, reset_engine_count; unsigned long count; + bool using_guc = intel_engine_uses_guc(engine); IGT_TIMEOUT(end_time); + if (using_guc && !active) + continue; + if (active && !intel_engine_can_store_dword(engine)) continue; @@ -705,13 +736,23 @@ static int __igt_reset_engine(struct intel_gt *gt, bool active) set_bit(I915_RESET_ENGINE + id, >->reset.flags); count = 0; do { - if (active) { - struct i915_request *rq; + struct i915_request *rq = NULL; + struct intel_selftest_saved_policy saved; + int err2; + + err = intel_selftest_modify_policy(engine, &saved, + SELFTEST_SCHEDULER_MODIFY_FAST_RESET); + if (err) { + pr_err("[%s] Modify policy failed: %d!\n", engine->name, err); + break; + } + if (active) { rq = hang_create_request(&h, engine); if (IS_ERR(rq)) { err = PTR_ERR(rq); - break; + pr_err("[%s] Create hang request failed: %d!\n", engine->name, err); + goto restore; } i915_request_get(rq); @@ -727,34 +768,58 @@ static int __igt_reset_engine(struct intel_gt *gt, bool active) i915_request_put(rq); err = -EIO; - break; + goto restore; } + } - i915_request_put(rq); + if (!using_guc) { + err = intel_engine_reset(engine, NULL); + if (err) { + pr_err("intel_engine_reset(%s) failed, err:%d\n", + engine->name, err); + goto skip; + } } - err = intel_engine_reset(engine, NULL); - if (err) { - pr_err("intel_engine_reset(%s) failed, err:%d\n", - engine->name, err); - break; + if (rq) { + /* Ensure the reset happens and kills the engine */ + err = intel_selftest_wait_for_rq(rq); + if (err) + pr_err("[%s] Wait for request %lld:%lld [0x%04X] failed: %d!\n", + engine->name, rq->fence.context, rq->fence.seqno, rq->context->guc_id, err); } +skip: + if (rq) + i915_request_put(rq); + if (i915_reset_count(global) != reset_count) { pr_err("Full GPU reset recorded! (engine reset expected)\n"); err = -EINVAL; - break; + goto restore; } - if (i915_reset_engine_count(global, engine) != - ++reset_engine_count) { - pr_err("%s engine reset not recorded!\n", - engine->name); - err = -EINVAL; - break; + /* GuC based resets are not logged per engine */ + if (!using_guc) { + if (i915_reset_engine_count(global, engine) != + ++reset_engine_count) { + pr_err("%s engine reset not recorded!\n", + engine->name); + err = -EINVAL; + goto restore; + } } count++; + +restore: + err2 = intel_selftest_restore_policy(engine, &saved); + if (err2) + pr_err("[%s] Restore policy failed: %d!\n", engine->name, err); + if (err == 0) + err = err2; + if (err) + break; } while (time_before(jiffies, end_time)); clear_bit(I915_RESET_ENGINE + id, >->reset.flags); st_engine_heartbeat_enable(engine); @@ -765,12 +830,16 @@ static int __igt_reset_engine(struct intel_gt *gt, bool active) break; err = igt_flush_test(gt->i915); - if (err) + if (err) { + pr_err("[%s] Flush failed: %d!\n", engine->name, err); break; + } } - if (intel_gt_is_wedged(gt)) + if (intel_gt_is_wedged(gt)) { + pr_err("GT is wedged!\n"); err = -EIO; + } if (active) hang_fini(&h); @@ -807,7 +876,7 @@ static int active_request_put(struct i915_request *rq) if (!rq) return 0; - if (i915_request_wait(rq, 0, 5 * HZ) < 0) { + if (i915_request_wait(rq, 0, 10 * HZ) < 0) { GEM_TRACE("%s timed out waiting for completion of fence %llx:%lld\n", rq->engine->name, rq->fence.context, @@ -837,6 +906,7 @@ static int active_engine(void *data) ce[count] = intel_context_create(engine); if (IS_ERR(ce[count])) { err = PTR_ERR(ce[count]); + pr_err("[%s] Create context #%ld failed: %d!\n", engine->name, count, err); while (--count) intel_context_put(ce[count]); return err; @@ -852,6 +922,7 @@ static int active_engine(void *data) new = intel_context_create_request(ce[idx]); if (IS_ERR(new)) { err = PTR_ERR(new); + pr_err("[%s] Create request #%d failed: %d!\n", engine->name, idx, err); break; } @@ -867,8 +938,10 @@ static int active_engine(void *data) } err = active_request_put(old); - if (err) + if (err) { + pr_err("[%s] Request put failed: %d!\n", engine->name, err); break; + } cond_resched(); } @@ -876,6 +949,9 @@ static int active_engine(void *data) for (count = 0; count < ARRAY_SIZE(rq); count++) { int err__ = active_request_put(rq[count]); + if (err) + pr_err("[%s] Request put #%ld failed: %d!\n", engine->name, count, err); + /* Keep the first error */ if (!err) err = err__; @@ -916,10 +992,13 @@ static int __igt_reset_engines(struct intel_gt *gt, struct active_engine threads[I915_NUM_ENGINES] = {}; unsigned long device = i915_reset_count(global); unsigned long count = 0, reported; + bool using_guc = intel_engine_uses_guc(engine); IGT_TIMEOUT(end_time); - if (flags & TEST_ACTIVE && - !intel_engine_can_store_dword(engine)) + if (flags & TEST_ACTIVE) { + if (!intel_engine_can_store_dword(engine)) + continue; + } else if (using_guc) continue; if (!wait_for_idle(engine)) { @@ -949,6 +1028,7 @@ static int __igt_reset_engines(struct intel_gt *gt, "igt/%s", other->name); if (IS_ERR(tsk)) { err = PTR_ERR(tsk); + pr_err("[%s] Thread spawn failed: %d!\n", engine->name, err); goto unwind; } @@ -958,16 +1038,26 @@ static int __igt_reset_engines(struct intel_gt *gt, yield(); /* start all threads before we begin */ - st_engine_heartbeat_disable(engine); + st_engine_heartbeat_disable_no_pm(engine); set_bit(I915_RESET_ENGINE + id, >->reset.flags); do { struct i915_request *rq = NULL; + struct intel_selftest_saved_policy saved; + int err2; + + err = intel_selftest_modify_policy(engine, &saved, + SELFTEST_SCHEDULER_MODIFY_FAST_RESET); + if (err) { + pr_err("[%s] Modify policy failed: %d!\n", engine->name, err); + break; + } if (flags & TEST_ACTIVE) { rq = hang_create_request(&h, engine); if (IS_ERR(rq)) { err = PTR_ERR(rq); - break; + pr_err("[%s] Create hang request failed: %d!\n", engine->name, err); + goto restore; } i915_request_get(rq); @@ -983,15 +1073,27 @@ static int __igt_reset_engines(struct intel_gt *gt, i915_request_put(rq); err = -EIO; - break; + goto restore; } + } else { + intel_engine_pm_get(engine); } - err = intel_engine_reset(engine, NULL); - if (err) { - pr_err("i915_reset_engine(%s:%s): failed, err=%d\n", - engine->name, test_name, err); - break; + if (!using_guc) { + err = intel_engine_reset(engine, NULL); + if (err) { + pr_err("i915_reset_engine(%s:%s): failed, err=%d\n", + engine->name, test_name, err); + goto restore; + } + } + + if (rq) { + /* Ensure the reset happens and kills the engine */ + err = intel_selftest_wait_for_rq(rq); + if (err) + pr_err("[%s] Wait for request %lld:%lld [0x%04X] failed: %d!\n", + engine->name, rq->fence.context, rq->fence.seqno, rq->context->guc_id, err); } count++; @@ -999,16 +1101,16 @@ static int __igt_reset_engines(struct intel_gt *gt, if (rq) { if (rq->fence.error != -EIO) { pr_err("i915_reset_engine(%s:%s):" - " failed to reset request %llx:%lld\n", + " failed to reset request %lld:%lld [0x%04X]\n", engine->name, test_name, rq->fence.context, - rq->fence.seqno); + rq->fence.seqno, rq->context->guc_id); i915_request_put(rq); GEM_TRACE_DUMP(); intel_gt_set_wedged(gt); err = -EIO; - break; + goto restore; } if (i915_request_wait(rq, 0, HZ / 5) < 0) { @@ -1027,12 +1129,15 @@ static int __igt_reset_engines(struct intel_gt *gt, GEM_TRACE_DUMP(); intel_gt_set_wedged(gt); err = -EIO; - break; + goto restore; } i915_request_put(rq); } + if (!(flags & TEST_ACTIVE)) + intel_engine_pm_put(engine); + if (!(flags & TEST_SELF) && !wait_for_idle(engine)) { struct drm_printer p = drm_info_printer(gt->i915->drm.dev); @@ -1044,22 +1149,34 @@ static int __igt_reset_engines(struct intel_gt *gt, "%s\n", engine->name); err = -EIO; - break; + goto restore; } + +restore: + err2 = intel_selftest_restore_policy(engine, &saved); + if (err2) + pr_err("[%s] Restore policy failed: %d!\n", engine->name, err2); + if (err == 0) + err = err2; + if (err) + break; } while (time_before(jiffies, end_time)); clear_bit(I915_RESET_ENGINE + id, >->reset.flags); - st_engine_heartbeat_enable(engine); + st_engine_heartbeat_enable_no_pm(engine); pr_info("i915_reset_engine(%s:%s): %lu resets\n", engine->name, test_name, count); - reported = i915_reset_engine_count(global, engine); - reported -= threads[engine->id].resets; - if (reported != count) { - pr_err("i915_reset_engine(%s:%s): reset %lu times, but reported %lu\n", - engine->name, test_name, count, reported); - if (!err) - err = -EINVAL; + /* GuC based resets are not logged per engine */ + if (!using_guc) { + reported = i915_reset_engine_count(global, engine); + reported -= threads[engine->id].resets; + if (reported != count) { + pr_err("i915_reset_engine(%s:%s): reset %lu times, but reported %lu\n", + engine->name, test_name, count, reported); + if (!err) + err = -EINVAL; + } } unwind: @@ -1078,15 +1195,18 @@ static int __igt_reset_engines(struct intel_gt *gt, } put_task_struct(threads[tmp].task); - if (other->uabi_class != engine->uabi_class && - threads[tmp].resets != - i915_reset_engine_count(global, other)) { - pr_err("Innocent engine %s was reset (count=%ld)\n", - other->name, - i915_reset_engine_count(global, other) - - threads[tmp].resets); - if (!err) - err = -EINVAL; + /* GuC based resets are not logged per engine */ + if (!using_guc) { + if (other->uabi_class != engine->uabi_class && + threads[tmp].resets != + i915_reset_engine_count(global, other)) { + pr_err("Innocent engine %s was reset (count=%ld)\n", + other->name, + i915_reset_engine_count(global, other) - + threads[tmp].resets); + if (!err) + err = -EINVAL; + } } } @@ -1101,8 +1221,10 @@ static int __igt_reset_engines(struct intel_gt *gt, break; err = igt_flush_test(gt->i915); - if (err) + if (err) { + pr_err("[%s] Flush failed: %d!\n", engine->name, err); break; + } } if (intel_gt_is_wedged(gt)) @@ -1180,12 +1302,15 @@ static int igt_reset_wait(void *arg) igt_global_reset_lock(gt); err = hang_init(&h, gt); - if (err) + if (err) { + pr_err("[%s] Hang init failed: %d!\n", engine->name, err); goto unlock; + } rq = hang_create_request(&h, engine); if (IS_ERR(rq)) { err = PTR_ERR(rq); + pr_err("[%s] Create hang request failed: %d!\n", engine->name, err); goto fini; } @@ -1310,12 +1435,15 @@ static int __igt_reset_evict_vma(struct intel_gt *gt, /* Check that we can recover an unbind stuck on a hanging request */ err = hang_init(&h, gt); - if (err) + if (err) { + pr_err("[%s] Hang init failed: %d!\n", engine->name, err); return err; + } obj = i915_gem_object_create_internal(gt->i915, SZ_1M); if (IS_ERR(obj)) { err = PTR_ERR(obj); + pr_err("[%s] Create object failed: %d!\n", engine->name, err); goto fini; } @@ -1330,12 +1458,14 @@ static int __igt_reset_evict_vma(struct intel_gt *gt, arg.vma = i915_vma_instance(obj, vm, NULL); if (IS_ERR(arg.vma)) { err = PTR_ERR(arg.vma); + pr_err("[%s] VMA instance failed: %d!\n", engine->name, err); goto out_obj; } rq = hang_create_request(&h, engine); if (IS_ERR(rq)) { err = PTR_ERR(rq); + pr_err("[%s] Create hang request failed: %d!\n", engine->name, err); goto out_obj; } @@ -1347,6 +1477,7 @@ static int __igt_reset_evict_vma(struct intel_gt *gt, err = i915_vma_pin(arg.vma, 0, 0, pin_flags); if (err) { i915_request_add(rq); + pr_err("[%s] VMA pin failed: %d!\n", engine->name, err); goto out_obj; } @@ -1363,8 +1494,14 @@ static int __igt_reset_evict_vma(struct intel_gt *gt, i915_vma_lock(arg.vma); err = i915_request_await_object(rq, arg.vma->obj, flags & EXEC_OBJECT_WRITE); - if (err == 0) + if (err == 0) { err = i915_vma_move_to_active(arg.vma, rq, flags); + if (err) + pr_err("[%s] Move to active failed: %d!\n", engine->name, err); + } else { + pr_err("[%s] Request await failed: %d!\n", engine->name, err); + } + i915_vma_unlock(arg.vma); if (flags & EXEC_OBJECT_NEEDS_FENCE) @@ -1392,6 +1529,7 @@ static int __igt_reset_evict_vma(struct intel_gt *gt, tsk = kthread_run(fn, &arg, "igt/evict_vma"); if (IS_ERR(tsk)) { err = PTR_ERR(tsk); + pr_err("[%s] Thread spawn failed: %d!\n", engine->name, err); tsk = NULL; goto out_reset; } @@ -1508,17 +1646,29 @@ static int igt_reset_queue(void *arg) goto unlock; for_each_engine(engine, gt, id) { + struct intel_selftest_saved_policy saved; struct i915_request *prev; IGT_TIMEOUT(end_time); unsigned int count; + bool using_guc = intel_engine_uses_guc(engine); if (!intel_engine_can_store_dword(engine)) continue; + if (using_guc) { + err = intel_selftest_modify_policy(engine, &saved, + SELFTEST_SCHEDULER_MODIFY_NO_HANGCHECK); + if (err) { + pr_err("[%s] Modify policy failed: %d!\n", engine->name, err); + goto fini; + } + } + prev = hang_create_request(&h, engine); if (IS_ERR(prev)) { err = PTR_ERR(prev); - goto fini; + pr_err("[%s] Create 'prev' hang request failed: %d!\n", engine->name, err); + goto restore; } i915_request_get(prev); @@ -1532,7 +1682,8 @@ static int igt_reset_queue(void *arg) rq = hang_create_request(&h, engine); if (IS_ERR(rq)) { err = PTR_ERR(rq); - goto fini; + pr_err("[%s] Create hang request failed: %d!\n", engine->name, err); + goto restore; } i915_request_get(rq); @@ -1557,7 +1708,7 @@ static int igt_reset_queue(void *arg) GEM_TRACE_DUMP(); intel_gt_set_wedged(gt); - goto fini; + goto restore; } if (!wait_until_running(&h, prev)) { @@ -1575,7 +1726,7 @@ static int igt_reset_queue(void *arg) intel_gt_set_wedged(gt); err = -EIO; - goto fini; + goto restore; } reset_count = fake_hangcheck(gt, BIT(id)); @@ -1586,7 +1737,7 @@ static int igt_reset_queue(void *arg) i915_request_put(rq); i915_request_put(prev); err = -EINVAL; - goto fini; + goto restore; } if (rq->fence.error) { @@ -1595,7 +1746,7 @@ static int igt_reset_queue(void *arg) i915_request_put(rq); i915_request_put(prev); err = -EINVAL; - goto fini; + goto restore; } if (i915_reset_count(global) == reset_count) { @@ -1603,7 +1754,7 @@ static int igt_reset_queue(void *arg) i915_request_put(rq); i915_request_put(prev); err = -EINVAL; - goto fini; + goto restore; } i915_request_put(prev); @@ -1618,9 +1769,22 @@ static int igt_reset_queue(void *arg) i915_request_put(prev); - err = igt_flush_test(gt->i915); +restore: + if (using_guc) { + int err2 = intel_selftest_restore_policy(engine, &saved); + if (err2) + pr_err("%s:%d> [%s] Restore policy failed: %d!\n", __func__, __LINE__, engine->name, err2); + if (err == 0) + err = err2; + } if (err) + goto fini; + + err = igt_flush_test(gt->i915); + if (err) { + pr_err("[%s] Flush failed: %d!\n", engine->name, err); break; + } } fini: @@ -1653,12 +1817,15 @@ static int igt_handle_error(void *arg) return 0; err = hang_init(&h, gt); - if (err) + if (err) { + pr_err("[%s] Hang init failed: %d!\n", engine->name, err); return err; + } rq = hang_create_request(&h, engine); if (IS_ERR(rq)) { err = PTR_ERR(rq); + pr_err("[%s] Create hang request failed: %d!\n", engine->name, err); goto err_fini; } @@ -1743,12 +1910,15 @@ static int igt_atomic_reset_engine(struct intel_engine_cs *engine, return err; err = hang_init(&h, engine->gt); - if (err) + if (err) { + pr_err("[%s] Hang init failed: %d!\n", engine->name, err); return err; + } rq = hang_create_request(&h, engine); if (IS_ERR(rq)) { err = PTR_ERR(rq); + pr_err("[%s] Create hang request failed: %d!\n", engine->name, err); goto out; } diff --git a/drivers/gpu/drm/i915/gt/selftest_mocs.c b/drivers/gpu/drm/i915/gt/selftest_mocs.c index 8763bbeca0f7..13d25bf2a94a 100644 --- a/drivers/gpu/drm/i915/gt/selftest_mocs.c +++ b/drivers/gpu/drm/i915/gt/selftest_mocs.c @@ -10,6 +10,7 @@ #include "gem/selftests/mock_context.h" #include "selftests/igt_reset.h" #include "selftests/igt_spinner.h" +#include "selftests/intel_scheduler_helpers.h" struct live_mocs { struct drm_i915_mocs_table table; @@ -318,7 +319,8 @@ static int live_mocs_clean(void *arg) } static int active_engine_reset(struct intel_context *ce, - const char *reason) + const char *reason, + bool using_guc) { struct igt_spinner spin; struct i915_request *rq; @@ -335,9 +337,13 @@ static int active_engine_reset(struct intel_context *ce, } err = request_add_spin(rq, &spin); - if (err == 0) + if (err == 0 && !using_guc) err = intel_engine_reset(ce->engine, reason); + /* Ensure the reset happens and kills the engine */ + if (err == 0) + err = intel_selftest_wait_for_rq(rq); + igt_spinner_end(&spin); igt_spinner_fini(&spin); @@ -345,21 +351,23 @@ static int active_engine_reset(struct intel_context *ce, } static int __live_mocs_reset(struct live_mocs *mocs, - struct intel_context *ce) + struct intel_context *ce, bool using_guc) { struct intel_gt *gt = ce->engine->gt; int err; if (intel_has_reset_engine(gt)) { - err = intel_engine_reset(ce->engine, "mocs"); - if (err) - return err; - - err = check_mocs_engine(mocs, ce); - if (err) - return err; + if (!using_guc) { + err = intel_engine_reset(ce->engine, "mocs"); + if (err) + return err; + + err = check_mocs_engine(mocs, ce); + if (err) + return err; + } - err = active_engine_reset(ce, "mocs"); + err = active_engine_reset(ce, "mocs", using_guc); if (err) return err; @@ -395,19 +403,33 @@ static int live_mocs_reset(void *arg) igt_global_reset_lock(gt); for_each_engine(engine, gt, id) { + bool using_guc = intel_engine_uses_guc(engine); + struct intel_selftest_saved_policy saved; struct intel_context *ce; + int err2; + + err = intel_selftest_modify_policy(engine, &saved, + SELFTEST_SCHEDULER_MODIFY_FAST_RESET); + if (err) + break; ce = mocs_context_create(engine); if (IS_ERR(ce)) { err = PTR_ERR(ce); - break; + goto restore; } intel_engine_pm_get(engine); - err = __live_mocs_reset(&mocs, ce); - intel_engine_pm_put(engine); + err = __live_mocs_reset(&mocs, ce, using_guc); + + intel_engine_pm_put(engine); intel_context_put(ce); + +restore: + err2 = intel_selftest_restore_policy(engine, &saved); + if (err == 0) + err = err2; if (err) break; } diff --git a/drivers/gpu/drm/i915/gt/selftest_workarounds.c b/drivers/gpu/drm/i915/gt/selftest_workarounds.c index 7ebc4edb8ecf..d820f0b41634 100644 --- a/drivers/gpu/drm/i915/gt/selftest_workarounds.c +++ b/drivers/gpu/drm/i915/gt/selftest_workarounds.c @@ -12,6 +12,7 @@ #include "selftests/igt_flush_test.h" #include "selftests/igt_reset.h" #include "selftests/igt_spinner.h" +#include "selftests/intel_scheduler_helpers.h" #include "selftests/mock_drm.h" #include "gem/selftests/igt_gem_utils.h" @@ -261,28 +262,34 @@ static int do_engine_reset(struct intel_engine_cs *engine) return intel_engine_reset(engine, "live_workarounds"); } +static int do_guc_reset(struct intel_engine_cs *engine) +{ + /* Currently a no-op as the reset is handled by GuC */ + return 0; +} + static int switch_to_scratch_context(struct intel_engine_cs *engine, - struct igt_spinner *spin) + struct igt_spinner *spin, + struct i915_request **rq) { struct intel_context *ce; - struct i915_request *rq; int err = 0; ce = intel_context_create(engine); if (IS_ERR(ce)) return PTR_ERR(ce); - rq = igt_spinner_create_request(spin, ce, MI_NOOP); + *rq = igt_spinner_create_request(spin, ce, MI_NOOP); intel_context_put(ce); - if (IS_ERR(rq)) { + if (IS_ERR(*rq)) { spin = NULL; - err = PTR_ERR(rq); + err = PTR_ERR(*rq); goto err; } - err = request_add_spin(rq, spin); + err = request_add_spin(*rq, spin); err: if (err && spin) igt_spinner_end(spin); @@ -296,6 +303,7 @@ static int check_whitelist_across_reset(struct intel_engine_cs *engine, { struct intel_context *ce, *tmp; struct igt_spinner spin; + struct i915_request *rq; intel_wakeref_t wakeref; int err; @@ -316,13 +324,24 @@ static int check_whitelist_across_reset(struct intel_engine_cs *engine, goto out_spin; } - err = switch_to_scratch_context(engine, &spin); + err = switch_to_scratch_context(engine, &spin, &rq); if (err) goto out_spin; + /* Ensure the spinner hasn't aborted */ + if (i915_request_completed(rq)) { + pr_err("%s spinner failed to start\n", name); + err = -ETIMEDOUT; + goto out_spin; + } + with_intel_runtime_pm(engine->uncore->rpm, wakeref) err = reset(engine); + /* Ensure the reset happens and kills the engine */ + if (err == 0) + err = intel_selftest_wait_for_rq(rq); + igt_spinner_end(&spin); if (err) { @@ -787,9 +806,27 @@ static int live_reset_whitelist(void *arg) continue; if (intel_has_reset_engine(gt)) { - err = check_whitelist_across_reset(engine, - do_engine_reset, - "engine"); + if (intel_engine_uses_guc(engine)) { + struct intel_selftest_saved_policy saved; + int err2; + + err = intel_selftest_modify_policy(engine, &saved, + SELFTEST_SCHEDULER_MODIFY_FAST_RESET); + if(err) + goto out; + + err = check_whitelist_across_reset(engine, + do_guc_reset, + "guc"); + + err2 = intel_selftest_restore_policy(engine, &saved); + if (err == 0) + err = err2; + } else + err = check_whitelist_across_reset(engine, + do_engine_reset, + "engine"); + if (err) goto out; } @@ -1226,31 +1263,42 @@ live_engine_reset_workarounds(void *arg) reference_lists_init(gt, &lists); for_each_engine(engine, gt, id) { + struct intel_selftest_saved_policy saved; + bool using_guc = intel_engine_uses_guc(engine); bool ok; + int ret2; pr_info("Verifying after %s reset...\n", engine->name); + ret = intel_selftest_modify_policy(engine, &saved, + SELFTEST_SCHEDULER_MODIFY_FAST_RESET); + if (ret) + break; + + ce = intel_context_create(engine); if (IS_ERR(ce)) { ret = PTR_ERR(ce); - break; + goto restore; } - ok = verify_wa_lists(gt, &lists, "before reset"); - if (!ok) { - ret = -ESRCH; - goto err; - } + if (!using_guc) { + ok = verify_wa_lists(gt, &lists, "before reset"); + if (!ok) { + ret = -ESRCH; + goto err; + } - ret = intel_engine_reset(engine, "live_workarounds:idle"); - if (ret) { - pr_err("%s: Reset failed while idle\n", engine->name); - goto err; - } + ret = intel_engine_reset(engine, "live_workarounds:idle"); + if (ret) { + pr_err("%s: Reset failed while idle\n", engine->name); + goto err; + } - ok = verify_wa_lists(gt, &lists, "after idle reset"); - if (!ok) { - ret = -ESRCH; - goto err; + ok = verify_wa_lists(gt, &lists, "after idle reset"); + if (!ok) { + ret = -ESRCH; + goto err; + } } ret = igt_spinner_init(&spin, engine->gt); @@ -1271,25 +1319,41 @@ live_engine_reset_workarounds(void *arg) goto err; } - ret = intel_engine_reset(engine, "live_workarounds:active"); - if (ret) { - pr_err("%s: Reset failed on an active spinner\n", - engine->name); - igt_spinner_fini(&spin); - goto err; + /* Ensure the spinner hasn't aborted */ + if (i915_request_completed(rq)) { + ret = -ETIMEDOUT; + goto skip; + } + + if (!using_guc) { + ret = intel_engine_reset(engine, "live_workarounds:active"); + if (ret) { + pr_err("%s: Reset failed on an active spinner\n", + engine->name); + igt_spinner_fini(&spin); + goto err; + } } + /* Ensure the reset happens and kills the engine */ + if (ret == 0) + ret = intel_selftest_wait_for_rq(rq); + +skip: igt_spinner_end(&spin); igt_spinner_fini(&spin); ok = verify_wa_lists(gt, &lists, "after busy reset"); - if (!ok) { + if (!ok) ret = -ESRCH; - goto err; - } err: intel_context_put(ce); + +restore: + ret2 = intel_selftest_restore_policy(engine, &saved); + if (ret == 0) + ret = ret2; if (ret) break; } diff --git a/drivers/gpu/drm/i915/gt/uc/abi/guc_actions_abi.h b/drivers/gpu/drm/i915/gt/uc/abi/guc_actions_abi.h index 2d6198e63ebe..596cf4b818e5 100644 --- a/drivers/gpu/drm/i915/gt/uc/abi/guc_actions_abi.h +++ b/drivers/gpu/drm/i915/gt/uc/abi/guc_actions_abi.h @@ -124,10 +124,25 @@ enum intel_guc_action { INTEL_GUC_ACTION_FORCE_LOG_BUFFER_FLUSH = 0x302, INTEL_GUC_ACTION_ENTER_S_STATE = 0x501, INTEL_GUC_ACTION_EXIT_S_STATE = 0x502, + INTEL_GUC_ACTION_GLOBAL_SCHED_POLICY_CHANGE = 0x506, + INTEL_GUC_ACTION_SCHED_CONTEXT = 0x1000, + INTEL_GUC_ACTION_SCHED_CONTEXT_MODE_SET = 0x1001, + INTEL_GUC_ACTION_SCHED_CONTEXT_MODE_DONE = 0x1002, + INTEL_GUC_ACTION_SCHED_ENGINE_MODE_SET = 0x1003, + INTEL_GUC_ACTION_SCHED_ENGINE_MODE_DONE = 0x1004, + INTEL_GUC_ACTION_SET_CONTEXT_PRIORITY = 0x1005, + INTEL_GUC_ACTION_SET_CONTEXT_EXECUTION_QUANTUM = 0x1006, + INTEL_GUC_ACTION_SET_CONTEXT_PREEMPTION_TIMEOUT = 0x1007, + INTEL_GUC_ACTION_CONTEXT_RESET_NOTIFICATION = 0x1008, + INTEL_GUC_ACTION_ENGINE_FAILURE_NOTIFICATION = 0x1009, INTEL_GUC_ACTION_SLPC_REQUEST = 0x3003, INTEL_GUC_ACTION_AUTHENTICATE_HUC = 0x4000, + INTEL_GUC_ACTION_REGISTER_CONTEXT = 0x4502, + INTEL_GUC_ACTION_DEREGISTER_CONTEXT = 0x4503, INTEL_GUC_ACTION_REGISTER_COMMAND_TRANSPORT_BUFFER = 0x4505, INTEL_GUC_ACTION_DEREGISTER_COMMAND_TRANSPORT_BUFFER = 0x4506, + INTEL_GUC_ACTION_DEREGISTER_CONTEXT_DONE = 0x4600, + INTEL_GUC_ACTION_RESET_CLIENT = 0x5B01, INTEL_GUC_ACTION_LIMIT }; diff --git a/drivers/gpu/drm/i915/gt/uc/intel_guc.c b/drivers/gpu/drm/i915/gt/uc/intel_guc.c index 6661dcb02239..979128e28372 100644 --- a/drivers/gpu/drm/i915/gt/uc/intel_guc.c +++ b/drivers/gpu/drm/i915/gt/uc/intel_guc.c @@ -180,6 +180,11 @@ void intel_guc_init_early(struct intel_guc *guc) } } +void intel_guc_init_late(struct intel_guc *guc) +{ + intel_guc_ads_init_late(guc); +} + static u32 guc_ctl_debug_flags(struct intel_guc *guc) { u32 level = intel_guc_log_get_level(&guc->log); @@ -524,65 +529,35 @@ int intel_guc_auth_huc(struct intel_guc *guc, u32 rsa_offset) */ int intel_guc_suspend(struct intel_guc *guc) { - struct intel_uncore *uncore = guc_to_gt(guc)->uncore; int ret; - u32 status; u32 action[] = { - INTEL_GUC_ACTION_ENTER_S_STATE, - GUC_POWER_D1, /* any value greater than GUC_POWER_D0 */ + INTEL_GUC_ACTION_RESET_CLIENT, }; - /* - * If GuC communication is enabled but submission is not supported, - * we do not need to suspend the GuC. - */ - if (!intel_guc_submission_is_used(guc) || !intel_guc_is_ready(guc)) + if (!intel_guc_is_ready(guc)) return 0; - /* - * The ENTER_S_STATE action queues the save/restore operation in GuC FW - * and then returns, so waiting on the H2G is not enough to guarantee - * GuC is done. When all the processing is done, GuC writes - * INTEL_GUC_SLEEP_STATE_SUCCESS to scratch register 14, so we can poll - * on that. Note that GuC does not ensure that the value in the register - * is different from INTEL_GUC_SLEEP_STATE_SUCCESS while the action is - * in progress so we need to take care of that ourselves as well. - */ - - intel_uncore_write(uncore, SOFT_SCRATCH(14), - INTEL_GUC_SLEEP_STATE_INVALID_MASK); - - ret = intel_guc_send(guc, action, ARRAY_SIZE(action)); - if (ret) - return ret; - - ret = __intel_wait_for_register(uncore, SOFT_SCRATCH(14), - INTEL_GUC_SLEEP_STATE_INVALID_MASK, - 0, 0, 10, &status); - if (ret) - return ret; - - if (status != INTEL_GUC_SLEEP_STATE_SUCCESS) { - DRM_ERROR("GuC failed to change sleep state. " - "action=0x%x, err=%u\n", - action[0], status); - return -EIO; + if (intel_guc_submission_is_used(guc)) { + /* + * This H2G MMIO command tears down the GuC in two steps. First it will + * generate a G2H CTB for every active context indicating a reset. In + * practice the i915 shouldn't ever get a G2H as suspend should only be + * called when the GPU is idle. Next, it tears down the CTBs and this + * H2G MMIO command completes. + * + * Don't abort on a failure code from the GuC. Keep going and do the + * clean up in santize() and re-initialisation on resume and hopefully + * the error here won't be problematic. + */ + ret = intel_guc_send_mmio(guc, action, ARRAY_SIZE(action), NULL, 0); + if (ret) + DRM_ERROR("GuC suspend: RESET_CLIENT action failed with error %d!\n", ret); } - return 0; -} + /* Signal that the GuC isn't running. */ + intel_guc_sanitize(guc); -/** - * intel_guc_reset_engine() - ask GuC to reset an engine - * @guc: intel_guc structure - * @engine: engine to be reset - */ -int intel_guc_reset_engine(struct intel_guc *guc, - struct intel_engine_cs *engine) -{ - /* XXX: to be implemented with submission interface rework */ - - return -ENODEV; + return 0; } /** @@ -591,7 +566,12 @@ int intel_guc_reset_engine(struct intel_guc *guc, */ int intel_guc_resume(struct intel_guc *guc) { - /* XXX: to be implemented with submission interface rework */ + /* + * NB: This function can still be called even if GuC submission is + * disabled, e.g. if GuC is enabled for HuC authentication only. Thus, + * if any code is later added here, it must be support doing nothing + * if submission is disabled (as per intel_guc_suspend). + */ return 0; } diff --git a/drivers/gpu/drm/i915/gt/uc/intel_guc.h b/drivers/gpu/drm/i915/gt/uc/intel_guc.h index 72e4653222e2..5d94cf482516 100644 --- a/drivers/gpu/drm/i915/gt/uc/intel_guc.h +++ b/drivers/gpu/drm/i915/gt/uc/intel_guc.h @@ -6,6 +6,9 @@ #ifndef _INTEL_GUC_H_ #define _INTEL_GUC_H_ +#include +#include + #include "intel_uncore.h" #include "intel_guc_fw.h" #include "intel_guc_fwif.h" @@ -28,23 +31,43 @@ struct intel_guc { struct intel_guc_log log; struct intel_guc_ct ct; + /* Global engine used to submit requests to GuC */ + struct i915_sched_engine *sched_engine; + struct i915_request *stalled_request; + /* intel_guc_recv interrupt related state */ spinlock_t irq_lock; unsigned int msg_enabled_mask; + atomic_t outstanding_submission_g2h; + struct { void (*reset)(struct intel_guc *guc); void (*enable)(struct intel_guc *guc); void (*disable)(struct intel_guc *guc); } interrupts; + /* + * contexts_lock protects the pool of free guc ids and a linked list of + * guc ids available to be stolen + */ + spinlock_t contexts_lock; + struct ida guc_ids; + struct list_head guc_id_list; + + bool submission_supported; bool submission_selected; struct i915_vma *ads_vma; struct __guc_ads_blob *ads_blob; + u32 ads_regset_size; + u32 ads_golden_ctxt_size; + + struct i915_vma *lrc_desc_pool; + void *lrc_desc_pool_vaddr; - struct i915_vma *stage_desc_pool; - void *stage_desc_pool_vaddr; + /* guc_id to intel_context lookup */ + struct xarray context_lookup; /* Control params for fw initialization */ u32 params[GUC_CTL_MAX_DWORDS]; @@ -78,10 +101,11 @@ inline int intel_guc_send(struct intel_guc *guc, const u32 *action, u32 len) } static -inline int intel_guc_send_nb(struct intel_guc *guc, const u32 *action, u32 len) +inline int intel_guc_send_nb(struct intel_guc *guc, const u32 *action, u32 len, + u32 g2h_len_dw) { return intel_guc_ct_send(&guc->ct, action, len, NULL, 0, - INTEL_GUC_CT_SEND_NB); + MAKE_SEND_FLAGS(g2h_len_dw)); } static inline int @@ -92,6 +116,35 @@ intel_guc_send_and_receive(struct intel_guc *guc, const u32 *action, u32 len, response_buf, response_buf_size, 0); } +static inline int intel_guc_send_busy_loop(struct intel_guc* guc, + const u32 *action, + u32 len, + u32 g2h_len_dw, + bool loop) +{ + int err; + unsigned int sleep_period_ms = 1; + bool not_atomic = !in_atomic() && !irqs_disabled(); + + /* No sleeping with spin locks, just busy loop */ + might_sleep_if(loop && not_atomic); + +retry: + err = intel_guc_send_nb(guc, action, len, g2h_len_dw); + if (unlikely(err == -EBUSY && loop)) { + if (likely(not_atomic)) { + if (msleep_interruptible(sleep_period_ms)) + return -EINTR; + sleep_period_ms = sleep_period_ms << 1; + } else { + cpu_relax(); + } + goto retry; + } + + return err; +} + static inline void intel_guc_to_host_event_handler(struct intel_guc *guc) { intel_guc_ct_event_handler(&guc->ct); @@ -125,6 +178,7 @@ static inline u32 intel_guc_ggtt_offset(struct intel_guc *guc, } void intel_guc_init_early(struct intel_guc *guc); +void intel_guc_init_late(struct intel_guc *guc); void intel_guc_init_send_regs(struct intel_guc *guc); void intel_guc_write_params(struct intel_guc *guc); int intel_guc_init(struct intel_guc *guc); @@ -167,9 +221,25 @@ static inline bool intel_guc_is_ready(struct intel_guc *guc) return intel_guc_is_fw_running(guc) && intel_guc_ct_enabled(&guc->ct); } +static inline void intel_guc_reset_interrupts(struct intel_guc *guc) +{ + guc->interrupts.reset(guc); +} + +static inline void intel_guc_enable_interrupts(struct intel_guc *guc) +{ + guc->interrupts.enable(guc); +} + +static inline void intel_guc_disable_interrupts(struct intel_guc *guc) +{ + guc->interrupts.disable(guc); +} + static inline int intel_guc_sanitize(struct intel_guc *guc) { intel_uc_fw_sanitize(&guc->fw); + intel_guc_disable_interrupts(guc); intel_guc_ct_sanitize(&guc->ct); guc->mmio_msg = 0; @@ -190,8 +260,27 @@ static inline void intel_guc_disable_msg(struct intel_guc *guc, u32 mask) spin_unlock_irq(&guc->irq_lock); } -int intel_guc_reset_engine(struct intel_guc *guc, - struct intel_engine_cs *engine); +int intel_guc_wait_for_idle(struct intel_guc *guc, long timeout); + +int intel_guc_deregister_done_process_msg(struct intel_guc *guc, + const u32 *msg, u32 len); +int intel_guc_sched_done_process_msg(struct intel_guc *guc, + const u32 *msg, u32 len); +int intel_guc_context_reset_process_msg(struct intel_guc *guc, + const u32 *msg, u32 len); +int intel_guc_engine_failure_process_msg(struct intel_guc *guc, + const u32 *msg, u32 len); + +void intel_guc_find_hung_context(struct intel_engine_cs *engine); + +int intel_guc_global_policies_update(struct intel_guc *guc); + +void intel_guc_context_ban(struct intel_context *ce, struct i915_request *rq); + +void intel_guc_submission_reset_prepare(struct intel_guc *guc); +void intel_guc_submission_reset(struct intel_guc *guc, bool stalled); +void intel_guc_submission_reset_finish(struct intel_guc *guc); +void intel_guc_submission_cancel_requests(struct intel_guc *guc); void intel_guc_load_status(struct intel_guc *guc, struct drm_printer *p); diff --git a/drivers/gpu/drm/i915/gt/uc/intel_guc_ads.c b/drivers/gpu/drm/i915/gt/uc/intel_guc_ads.c index b82145652d57..c56302dedb32 100644 --- a/drivers/gpu/drm/i915/gt/uc/intel_guc_ads.c +++ b/drivers/gpu/drm/i915/gt/uc/intel_guc_ads.c @@ -3,8 +3,11 @@ * Copyright © 2014-2019 Intel Corporation */ +#include + #include "gt/intel_gt.h" #include "gt/intel_lrc.h" +#include "gt/shmem_utils.h" #include "intel_guc_ads.h" #include "intel_guc_fwif.h" #include "intel_uc.h" @@ -23,6 +26,15 @@ * | guc_policies | * +---------------------------------------+ * | guc_gt_system_info | + * +---------------------------------------+ <== static + * | guc_mmio_reg[countA] (engine 0.0) | + * | guc_mmio_reg[countB] (engine 0.1) | + * | guc_mmio_reg[countC] (engine 1.0) | + * | ... | + * +---------------------------------------+ <== dynamic + * | padding | + * +---------------------------------------+ <== 4K aligned + * | golden contexts | * +---------------------------------------+ * | padding | * +---------------------------------------+ <== 4K aligned @@ -35,16 +47,49 @@ struct __guc_ads_blob { struct guc_ads ads; struct guc_policies policies; struct guc_gt_system_info system_info; + /* From here on, location is dynamic! Refer to above diagram. */ + struct guc_mmio_reg regset[0]; } __packed; +static u32 guc_ads_regset_size(struct intel_guc *guc) +{ + GEM_BUG_ON(!guc->ads_regset_size); + return guc->ads_regset_size; +} + +static u32 guc_ads_golden_ctxt_size(struct intel_guc *guc) +{ + return PAGE_ALIGN(guc->ads_golden_ctxt_size); +} + static u32 guc_ads_private_data_size(struct intel_guc *guc) { return PAGE_ALIGN(guc->fw.private_data_size); } +static u32 guc_ads_regset_offset(struct intel_guc *guc) +{ + return offsetof(struct __guc_ads_blob, regset); +} + +static u32 guc_ads_golden_ctxt_offset(struct intel_guc *guc) +{ + u32 offset; + + offset = guc_ads_regset_offset(guc) + + guc_ads_regset_size(guc); + + return PAGE_ALIGN(offset); +} + static u32 guc_ads_private_data_offset(struct intel_guc *guc) { - return PAGE_ALIGN(sizeof(struct __guc_ads_blob)); + u32 offset; + + offset = guc_ads_golden_ctxt_offset(guc) + + guc_ads_golden_ctxt_size(guc); + + return PAGE_ALIGN(offset); } static u32 guc_ads_blob_size(struct intel_guc *guc) @@ -53,15 +98,68 @@ static u32 guc_ads_blob_size(struct intel_guc *guc) guc_ads_private_data_size(guc); } -static void guc_policies_init(struct guc_policies *policies) +static void guc_policies_init(struct intel_guc *guc, struct guc_policies *policies) { + struct intel_gt *gt = guc_to_gt(guc); + struct drm_i915_private *i915 = gt->i915; + policies->dpc_promote_time = GLOBAL_POLICY_DEFAULT_DPC_PROMOTE_TIME_US; policies->max_num_work_items = GLOBAL_POLICY_MAX_NUM_WI; - /* Disable automatic resets as not yet supported. */ - policies->global_flags = GLOBAL_POLICY_DISABLE_ENGINE_RESET; + + policies->global_flags = 0; + if (i915->params.reset < 2) + policies->global_flags |= GLOBAL_POLICY_DISABLE_ENGINE_RESET; + policies->is_valid = 1; } +void intel_guc_ads_print_policy_info(struct intel_guc *guc, + struct drm_printer *dp) +{ + struct __guc_ads_blob *blob = guc->ads_blob; + + if (unlikely(!blob)) + return; + + drm_printf(dp, "Global scheduling policies:\n"); + drm_printf(dp, " DPC promote time = %u\n", blob->policies.dpc_promote_time); + drm_printf(dp, " Max num work items = %u\n", blob->policies.max_num_work_items); + drm_printf(dp, " Flags = %u\n", blob->policies.global_flags); +} + +static int guc_action_policies_update(struct intel_guc *guc, u32 policy_offset) +{ + u32 action[] = { + INTEL_GUC_ACTION_GLOBAL_SCHED_POLICY_CHANGE, + policy_offset + }; + + return intel_guc_send_busy_loop(guc, action, ARRAY_SIZE(action), 0, true); +} + +int intel_guc_global_policies_update(struct intel_guc *guc) +{ + struct __guc_ads_blob *blob = guc->ads_blob; + struct intel_gt *gt = guc_to_gt(guc); + intel_wakeref_t wakeref; + int ret; + + if (!blob) + return -ENOTSUPP; + + GEM_BUG_ON(!blob->ads.scheduler_policies); + + guc_policies_init(guc, &blob->policies); + + if (!intel_guc_is_ready(guc)) + return 0; + + with_intel_runtime_pm(>->i915->runtime_pm, wakeref) + ret = guc_action_policies_update(guc, blob->ads.scheduler_policies); + + return ret; +} + static void guc_mapping_table_init(struct intel_gt *gt, struct guc_gt_system_info *system_info) { @@ -84,53 +182,323 @@ static void guc_mapping_table_init(struct intel_gt *gt, } /* - * The first 80 dwords of the register state context, containing the - * execlists and ppgtt registers. + * The save/restore register list must be pre-calculated to a temporary + * buffer of driver defined size before it can be generated in place + * inside the ADS. */ -#define LR_HW_CONTEXT_SIZE (80 * sizeof(u32)) +#define MAX_MMIO_REGS 128 /* Arbitrary size, increase as needed */ +struct temp_regset { + struct guc_mmio_reg *registers; + u32 used; + u32 size; +}; -static void __guc_ads_init(struct intel_guc *guc) +static int guc_mmio_reg_cmp(const void *a, const void *b) +{ + const struct guc_mmio_reg *ra = a; + const struct guc_mmio_reg *rb = b; + + return (int)ra->offset - (int)rb->offset; +} + +static void guc_mmio_reg_add(struct temp_regset *regset, + u32 offset, u32 flags) +{ + u32 count = regset->used; + struct guc_mmio_reg reg = { + .offset = offset, + .flags = flags, + }; + struct guc_mmio_reg *slot; + + GEM_BUG_ON(count >= regset->size); + + /* + * The mmio list is built using separate lists within the driver. + * It's possible that at some point we may attempt to add the same + * register more than once. Do not consider this an error; silently + * move on if the register is already in the list. + */ + if (bsearch(®, regset->registers, count, + sizeof(reg), guc_mmio_reg_cmp)) + return; + + slot = ®set->registers[count]; + regset->used++; + *slot = reg; + + while (slot-- > regset->registers) { + GEM_BUG_ON(slot[0].offset == slot[1].offset); + if (slot[1].offset > slot[0].offset) + break; + + swap(slot[1], slot[0]); + } +} + +#define GUC_MMIO_REG_ADD(regset, reg, masked) \ + guc_mmio_reg_add(regset, \ + i915_mmio_reg_offset((reg)), \ + (masked) ? GUC_REGSET_MASKED : 0) + +static void guc_mmio_regset_init(struct temp_regset *regset, + struct intel_engine_cs *engine) +{ + const u32 base = engine->mmio_base; + struct i915_wa_list *wal = &engine->wa_list; + struct i915_wa *wa; + unsigned int i; + + regset->used = 0; + + GUC_MMIO_REG_ADD(regset, RING_MODE_GEN7(base), true); + GUC_MMIO_REG_ADD(regset, RING_HWS_PGA(base), false); + GUC_MMIO_REG_ADD(regset, RING_IMR(base), false); + + for (i = 0, wa = wal->list; i < wal->count; i++, wa++) + GUC_MMIO_REG_ADD(regset, wa->reg, wa->masked_reg); + + /* Be extra paranoid and include all whitelist registers. */ + for (i = 0; i < RING_MAX_NONPRIV_SLOTS; i++) + GUC_MMIO_REG_ADD(regset, + RING_FORCE_TO_NONPRIV(base, i), + false); + + /* add in local MOCS registers */ + for (i = 0; i < GEN9_LNCFCMOCS_REG_COUNT; i++) + GUC_MMIO_REG_ADD(regset, GEN9_LNCFCMOCS(i), false); +} + +static int guc_mmio_reg_state_query(struct intel_guc *guc) { struct intel_gt *gt = guc_to_gt(guc); - struct drm_i915_private *i915 = gt->i915; + struct intel_engine_cs *engine; + enum intel_engine_id id; + struct temp_regset temp_set; + u32 total; + + /* + * Need to actually build the list in order to filter out + * duplicates and other such data dependent constructions. + */ + temp_set.size = MAX_MMIO_REGS; + temp_set.registers = kmalloc_array(temp_set.size, + sizeof(*temp_set.registers), + GFP_KERNEL); + if (!temp_set.registers) + return -ENOMEM; + + total = 0; + for_each_engine(engine, gt, id) { + guc_mmio_regset_init(&temp_set, engine); + total += temp_set.used; + } + + kfree(temp_set.registers); + + return total * sizeof(struct guc_mmio_reg); +} + +static void guc_mmio_reg_state_init(struct intel_guc *guc, + struct __guc_ads_blob *blob) +{ + struct intel_gt *gt = guc_to_gt(guc); + struct intel_engine_cs *engine; + enum intel_engine_id id; + struct temp_regset temp_set; + struct guc_mmio_reg_set *ads_reg_set; + u32 addr_ggtt, offset; + u8 guc_class; + + offset = guc_ads_regset_offset(guc); + addr_ggtt = intel_guc_ggtt_offset(guc, guc->ads_vma) + offset; + temp_set.registers = (struct guc_mmio_reg *) (((u8 *) blob) + offset); + temp_set.size = guc->ads_regset_size / sizeof(temp_set.registers[0]); + + for_each_engine(engine, gt, id) { + /* Class index is checked in class converter */ + GEM_BUG_ON(engine->instance >= GUC_MAX_INSTANCES_PER_CLASS); + + guc_class = engine_class_to_guc_class(engine->class); + ads_reg_set = &blob->ads.reg_state_list[guc_class][engine->instance]; + + guc_mmio_regset_init(&temp_set, engine); + if (!temp_set.used) { + ads_reg_set->address = 0; + ads_reg_set->count = 0; + continue; + } + + ads_reg_set->address = addr_ggtt; + ads_reg_set->count = temp_set.used; + + temp_set.size -= temp_set.used; + temp_set.registers += temp_set.used; + addr_ggtt += temp_set.used * sizeof(struct guc_mmio_reg); + } + + GEM_BUG_ON(temp_set.size); +} + +static void fill_engine_enable_masks(struct intel_gt *gt, + struct guc_gt_system_info *info) +{ + info->engine_enabled_masks[GUC_RENDER_CLASS] = 1; + info->engine_enabled_masks[GUC_BLITTER_CLASS] = 1; + info->engine_enabled_masks[GUC_VIDEO_CLASS] = VDBOX_MASK(gt); + info->engine_enabled_masks[GUC_VIDEOENHANCE_CLASS] = VEBOX_MASK(gt); +} + +static int guc_prep_golden_context(struct intel_guc *guc, + struct __guc_ads_blob *blob) +{ + struct intel_gt *gt = guc_to_gt(guc); + u32 addr_ggtt, offset; + u32 total_size = 0, alloc_size, real_size; + u8 engine_class, guc_class; + struct guc_gt_system_info *info, local_info; + + /* + * Reserve the memory for the golden contexts and point GuC at it but + * leave it empty for now. The context data will be filled in later + * once there is something available to put there. + * + * Note that the HWSP and ring context are not included. + * + * Note also that the storage must be pinned in the GGTT, so that the + * address won't change after GuC has been told where to find it. The + * GuC will also validate that the LRC base + size fall within the + * allowed GGTT range. + */ + if (blob) { + offset = guc_ads_golden_ctxt_offset(guc); + addr_ggtt = intel_guc_ggtt_offset(guc, guc->ads_vma) + offset; + info = &blob->system_info; + } else { + memset(&local_info, 0, sizeof(local_info)); + info = &local_info; + fill_engine_enable_masks(gt, info); + } + + for (engine_class = 0; engine_class <= MAX_ENGINE_CLASS; ++engine_class) { + if (engine_class == OTHER_CLASS) + continue; + + guc_class = engine_class_to_guc_class(engine_class); + + if (!info->engine_enabled_masks[guc_class]) + continue; + + real_size = intel_engine_context_size(gt, engine_class); + alloc_size = PAGE_ALIGN(real_size); + total_size += alloc_size; + + if (!blob) + continue; + + blob->ads.eng_state_size[guc_class] = real_size; + blob->ads.golden_context_lrca[guc_class] = addr_ggtt; + addr_ggtt += alloc_size; + } + + if (!blob) + return total_size; + + GEM_BUG_ON(guc->ads_golden_ctxt_size != total_size); + return total_size; +} + +static struct intel_engine_cs *find_engine_state(struct intel_gt *gt, u8 engine_class) +{ + struct intel_engine_cs *engine; + enum intel_engine_id id; + + for_each_engine(engine, gt, id) { + if (engine->class != engine_class) + continue; + + if (!engine->default_state) + continue; + + return engine; + } + + return NULL; +} + +static void guc_init_golden_context(struct intel_guc *guc) +{ struct __guc_ads_blob *blob = guc->ads_blob; - const u32 skipped_size = LRC_PPHWSP_SZ * PAGE_SIZE + LR_HW_CONTEXT_SIZE; - u32 base; + struct intel_engine_cs *engine; + struct intel_gt *gt = guc_to_gt(guc); + u32 addr_ggtt, offset; + u32 total_size = 0, alloc_size, real_size; u8 engine_class, guc_class; + u8 *ptr; - /* GuC scheduling policies */ - guc_policies_init(&blob->policies); + /* Skip execlist and PPGTT registers + HWSP */ + const u32 lr_hw_context_size = 80 * sizeof(u32); + const u32 skip_size = LRC_PPHWSP_SZ * PAGE_SIZE + + lr_hw_context_size; + + if (!intel_uc_uses_guc_submission(>->uc)) + return; + + GEM_BUG_ON(!blob); /* - * GuC expects a per-engine-class context image and size - * (minus hwsp and ring context). The context image will be - * used to reinitialize engines after a reset. It must exist - * and be pinned in the GGTT, so that the address won't change after - * we have told GuC where to find it. The context size will be used - * to validate that the LRC base + size fall within allowed GGTT. + * Go back and fill in the golden context data now that it is + * available. */ + offset = guc_ads_golden_ctxt_offset(guc); + addr_ggtt = intel_guc_ggtt_offset(guc, guc->ads_vma) + offset; + ptr = ((u8 *) blob) + offset; + for (engine_class = 0; engine_class <= MAX_ENGINE_CLASS; ++engine_class) { if (engine_class == OTHER_CLASS) continue; guc_class = engine_class_to_guc_class(engine_class); - /* - * TODO: Set context pointer to default state to allow - * GuC to re-init guilty contexts after internal reset. - */ - blob->ads.golden_context_lrca[guc_class] = 0; - blob->ads.eng_state_size[guc_class] = - intel_engine_context_size(guc_to_gt(guc), - engine_class) - - skipped_size; + if (!blob->system_info.engine_enabled_masks[guc_class]) + continue; + + real_size = intel_engine_context_size(gt, engine_class); + alloc_size = PAGE_ALIGN(real_size); + total_size += alloc_size; + + engine = find_engine_state(gt, engine_class); + if (!engine) { + drm_err(>->i915->drm, "No engine state recorded for class %d!\n", engine_class); + blob->ads.eng_state_size[guc_class] = 0; + blob->ads.golden_context_lrca[guc_class] = 0; + continue; + } + + GEM_BUG_ON(blob->ads.eng_state_size[guc_class] != real_size); + GEM_BUG_ON(blob->ads.golden_context_lrca[guc_class] != addr_ggtt); + addr_ggtt += alloc_size; + + shmem_read(engine->default_state, skip_size, ptr + skip_size, + real_size - skip_size); + ptr += alloc_size; } + GEM_BUG_ON(guc->ads_golden_ctxt_size != total_size); +} + +static void __guc_ads_init(struct intel_guc *guc) +{ + struct intel_gt *gt = guc_to_gt(guc); + struct drm_i915_private *i915 = gt->i915; + struct __guc_ads_blob *blob = guc->ads_blob; + u32 base; + + /* GuC scheduling policies */ + guc_policies_init(guc, &blob->policies); + /* System info */ - blob->system_info.engine_enabled_masks[GUC_RENDER_CLASS] = 1; - blob->system_info.engine_enabled_masks[GUC_BLITTER_CLASS] = 1; - blob->system_info.engine_enabled_masks[GUC_VIDEO_CLASS] = VDBOX_MASK(gt); - blob->system_info.engine_enabled_masks[GUC_VIDEOENHANCE_CLASS] = VEBOX_MASK(gt); + fill_engine_enable_masks(gt, &blob->system_info); blob->system_info.generic_gt_sysinfo[GUC_GENERIC_GT_SYSINFO_SLICE_ENABLED] = hweight8(gt->info.sseu.slice_mask); @@ -145,6 +513,9 @@ static void __guc_ads_init(struct intel_guc *guc) GEN12_DOORBELLS_PER_SQIDI) + 1; } + /* Golden contexts for re-initialising after a watchdog reset */ + guc_prep_golden_context(guc, blob); + guc_mapping_table_init(guc_to_gt(guc), &blob->system_info); base = intel_guc_ggtt_offset(guc, guc->ads_vma); @@ -153,6 +524,9 @@ static void __guc_ads_init(struct intel_guc *guc) blob->ads.scheduler_policies = base + ptr_offset(blob, policies); blob->ads.gt_system_info = base + ptr_offset(blob, system_info); + /* MMIO save/restore list */ + guc_mmio_reg_state_init(guc, blob); + /* Private Data */ blob->ads.private_data = base + guc_ads_private_data_offset(guc); @@ -173,6 +547,19 @@ int intel_guc_ads_create(struct intel_guc *guc) GEM_BUG_ON(guc->ads_vma); + /* Need to calculate the reg state size dynamically: */ + ret = guc_mmio_reg_state_query(guc); + if (ret < 0) + return ret; + guc->ads_regset_size = ret; + + /* Likewise the golden contexts: */ + ret = guc_prep_golden_context(guc, NULL); + if (ret < 0) + return ret; + guc->ads_golden_ctxt_size = ret; + + /* Now the total size can be determined: */ size = guc_ads_blob_size(guc); ret = intel_guc_allocate_and_map_vma(guc, size, &guc->ads_vma, @@ -185,6 +572,18 @@ int intel_guc_ads_create(struct intel_guc *guc) return 0; } +void intel_guc_ads_init_late(struct intel_guc *guc) +{ + /* + * The golden context setup requires the saved engine state from + * __engines_record_defaults(). However, that requires engines to be + * operational which means the ADS must already have been configured. + * Fortunately, the golden context state is not needed until a hang + * occurs, so it can be filled in during this late init phase. + */ + guc_init_golden_context(guc); +} + void intel_guc_ads_destroy(struct intel_guc *guc) { i915_vma_unpin_and_release(&guc->ads_vma, I915_VMA_RELEASE_MAP); diff --git a/drivers/gpu/drm/i915/gt/uc/intel_guc_ads.h b/drivers/gpu/drm/i915/gt/uc/intel_guc_ads.h index b00d3ae1113a..3d85051d57e4 100644 --- a/drivers/gpu/drm/i915/gt/uc/intel_guc_ads.h +++ b/drivers/gpu/drm/i915/gt/uc/intel_guc_ads.h @@ -7,9 +7,13 @@ #define _INTEL_GUC_ADS_H_ struct intel_guc; +struct drm_printer; int intel_guc_ads_create(struct intel_guc *guc); void intel_guc_ads_destroy(struct intel_guc *guc); +void intel_guc_ads_init_late(struct intel_guc *guc); void intel_guc_ads_reset(struct intel_guc *guc); +void intel_guc_ads_print_policy_info(struct intel_guc *guc, + struct drm_printer *p); #endif diff --git a/drivers/gpu/drm/i915/gt/uc/intel_guc_ct.c b/drivers/gpu/drm/i915/gt/uc/intel_guc_ct.c index 83ec60ea3f89..92976d205478 100644 --- a/drivers/gpu/drm/i915/gt/uc/intel_guc_ct.c +++ b/drivers/gpu/drm/i915/gt/uc/intel_guc_ct.c @@ -73,6 +73,7 @@ static inline struct drm_device *ct_to_drm(struct intel_guc_ct *ct) #define CTB_DESC_SIZE ALIGN(sizeof(struct guc_ct_buffer_desc), SZ_2K) #define CTB_H2G_BUFFER_SIZE (SZ_4K) #define CTB_G2H_BUFFER_SIZE (4 * CTB_H2G_BUFFER_SIZE) +#define G2H_ROOM_BUFFER_SIZE (CTB_G2H_BUFFER_SIZE / 4) struct ct_request { struct list_head link; @@ -108,6 +109,7 @@ void intel_guc_ct_init_early(struct intel_guc_ct *ct) INIT_LIST_HEAD(&ct->requests.incoming); INIT_WORK(&ct->requests.worker, ct_incoming_request_worker_func); tasklet_setup(&ct->receive_tasklet, ct_receive_tasklet_func); + init_waitqueue_head(&ct->wq); } static inline const char *guc_ct_buffer_type_to_str(u32 type) @@ -129,23 +131,27 @@ static void guc_ct_buffer_desc_init(struct guc_ct_buffer_desc *desc) static void guc_ct_buffer_reset(struct intel_guc_ct_buffer *ctb) { + u32 space; + ctb->broken = false; ctb->tail = 0; ctb->head = 0; - ctb->space = CIRC_SPACE(ctb->tail, ctb->head, ctb->size); + space = CIRC_SPACE(ctb->tail, ctb->head, ctb->size) - ctb->resv_space; + atomic_set(&ctb->space, space); guc_ct_buffer_desc_init(ctb->desc); } static void guc_ct_buffer_init(struct intel_guc_ct_buffer *ctb, struct guc_ct_buffer_desc *desc, - u32 *cmds, u32 size_in_bytes) + u32 *cmds, u32 size_in_bytes, u32 resv_space) { GEM_BUG_ON(size_in_bytes % 4); ctb->desc = desc; ctb->cmds = cmds; ctb->size = size_in_bytes / 4; + ctb->resv_space = resv_space / 4; guc_ct_buffer_reset(ctb); } @@ -226,6 +232,7 @@ int intel_guc_ct_init(struct intel_guc_ct *ct) struct guc_ct_buffer_desc *desc; u32 blob_size; u32 cmds_size; + u32 resv_space; void *blob; u32 *cmds; int err; @@ -250,19 +257,23 @@ int intel_guc_ct_init(struct intel_guc_ct *ct) desc = blob; cmds = blob + 2 * CTB_DESC_SIZE; cmds_size = CTB_H2G_BUFFER_SIZE; - CT_DEBUG(ct, "%s desc %#tx cmds %#tx size %u\n", "send", - ptrdiff(desc, blob), ptrdiff(cmds, blob), cmds_size); + resv_space = 0; + CT_DEBUG(ct, "%s desc %#tx cmds %#tx size %u/%u\n", "send", + ptrdiff(desc, blob), ptrdiff(cmds, blob), cmds_size, + resv_space); - guc_ct_buffer_init(&ct->ctbs.send, desc, cmds, cmds_size); + guc_ct_buffer_init(&ct->ctbs.send, desc, cmds, cmds_size, resv_space); /* store pointers to desc and cmds for recv ctb */ desc = blob + CTB_DESC_SIZE; cmds = blob + 2 * CTB_DESC_SIZE + CTB_H2G_BUFFER_SIZE; cmds_size = CTB_G2H_BUFFER_SIZE; - CT_DEBUG(ct, "%s desc %#tx cmds %#tx size %u\n", "recv", - ptrdiff(desc, blob), ptrdiff(cmds, blob), cmds_size); + resv_space = G2H_ROOM_BUFFER_SIZE; + CT_DEBUG(ct, "%s desc %#tx cmds %#tx size %u/%u\n", "recv", + ptrdiff(desc, blob), ptrdiff(cmds, blob), cmds_size, + resv_space); - guc_ct_buffer_init(&ct->ctbs.recv, desc, cmds, cmds_size); + guc_ct_buffer_init(&ct->ctbs.recv, desc, cmds, cmds_size, resv_space); return 0; } @@ -461,8 +472,8 @@ static int ct_write(struct intel_guc_ct *ct, /* update local copies */ ctb->tail = tail; - GEM_BUG_ON(ctb->space < len + GUC_CTB_HDR_LEN); - ctb->space -= len + GUC_CTB_HDR_LEN; + GEM_BUG_ON(atomic_read(&ctb->space) < len + GUC_CTB_HDR_LEN); + atomic_sub(len + GUC_CTB_HDR_LEN, &ctb->space); /* now update descriptor */ WRITE_ONCE(desc->tail, tail); @@ -537,6 +548,32 @@ static inline bool ct_deadlocked(struct intel_guc_ct *ct) return ret; } +static inline bool g2h_has_room(struct intel_guc_ct *ct, u32 g2h_len_dw) +{ + struct intel_guc_ct_buffer *ctb = &ct->ctbs.recv; + + /* + * We leave a certain amount of space in the G2H CTB buffer for + * unexpected G2H CTBs (e.g. logging, engine hang, etc...) + */ + return !g2h_len_dw || atomic_read(&ctb->space) >= g2h_len_dw; +} + +static inline void g2h_reserve_space(struct intel_guc_ct *ct, u32 g2h_len_dw) +{ + lockdep_assert_held(&ct->ctbs.send.lock); + + GEM_BUG_ON(!g2h_has_room(ct, g2h_len_dw)); + + if (g2h_len_dw) + atomic_sub(g2h_len_dw, &ct->ctbs.recv.space); +} + +static inline void g2h_release_space(struct intel_guc_ct *ct, u32 g2h_len_dw) +{ + atomic_add(g2h_len_dw, &ct->ctbs.recv.space); +} + static inline bool h2g_has_room(struct intel_guc_ct *ct, u32 len_dw) { struct intel_guc_ct_buffer *ctb = &ct->ctbs.send; @@ -544,7 +581,7 @@ static inline bool h2g_has_room(struct intel_guc_ct *ct, u32 len_dw) u32 head; u32 space; - if (ctb->space >= len_dw) + if (atomic_read(&ctb->space) >= len_dw) return true; head = READ_ONCE(desc->head); @@ -557,16 +594,16 @@ static inline bool h2g_has_room(struct intel_guc_ct *ct, u32 len_dw) } space = CIRC_SPACE(ctb->tail, head, ctb->size); - ctb->space = space; + atomic_set(&ctb->space, space); return space >= len_dw; } -static int has_room_nb(struct intel_guc_ct *ct, u32 len_dw) +static int has_room_nb(struct intel_guc_ct *ct, u32 h2g_dw, u32 g2h_dw) { lockdep_assert_held(&ct->ctbs.send.lock); - if (unlikely(!h2g_has_room(ct, len_dw))) { + if (unlikely(!h2g_has_room(ct, h2g_dw) || !g2h_has_room(ct, g2h_dw))) { if (ct->stall_time == KTIME_MAX) ct->stall_time = ktime_get(); @@ -580,6 +617,9 @@ static int has_room_nb(struct intel_guc_ct *ct, u32 len_dw) return 0; } +#define G2H_LEN_DW(f) \ + FIELD_GET(INTEL_GUC_CT_SEND_G2H_DW_MASK, f) ? \ + FIELD_GET(INTEL_GUC_CT_SEND_G2H_DW_MASK, f) + GUC_CTB_HXG_MSG_MIN_LEN : 0 static int ct_send_nb(struct intel_guc_ct *ct, const u32 *action, u32 len, @@ -587,12 +627,13 @@ static int ct_send_nb(struct intel_guc_ct *ct, { struct intel_guc_ct_buffer *ctb = &ct->ctbs.send; unsigned long spin_flags; + u32 g2h_len_dw = G2H_LEN_DW(flags); u32 fence; int ret; spin_lock_irqsave(&ctb->lock, spin_flags); - ret = has_room_nb(ct, len + GUC_CTB_HDR_LEN); + ret = has_room_nb(ct, len + GUC_CTB_HDR_LEN, g2h_len_dw); if (unlikely(ret)) goto out; @@ -601,6 +642,7 @@ static int ct_send_nb(struct intel_guc_ct *ct, if (unlikely(ret)) goto out; + g2h_reserve_space(ct, g2h_len_dw); intel_guc_notify(ct_to_guc(ct)); out: @@ -632,11 +674,13 @@ static int ct_send(struct intel_guc_ct *ct, /* * We use a lazy spin wait loop here as we believe that if the CT * buffers are sized correctly the flow control condition should be - * rare. + * rare. Reserving the maximum size in the G2H credits as we don't know + * how big the response is going to be. */ retry: spin_lock_irqsave(&ctb->lock, flags); - if (unlikely(!h2g_has_room(ct, len + GUC_CTB_HDR_LEN))) { + if (unlikely(!h2g_has_room(ct, len + GUC_CTB_HDR_LEN) || + !g2h_has_room(ct, GUC_CTB_HXG_MSG_MAX_LEN))) { if (ct->stall_time == KTIME_MAX) ct->stall_time = ktime_get(); spin_unlock_irqrestore(&ctb->lock, flags); @@ -664,6 +708,7 @@ static int ct_send(struct intel_guc_ct *ct, spin_unlock(&ct->requests.lock); err = ct_write(ct, action, len, fence, 0); + g2h_reserve_space(ct, GUC_CTB_HXG_MSG_MAX_LEN); spin_unlock_irqrestore(&ctb->lock, flags); @@ -673,6 +718,7 @@ static int ct_send(struct intel_guc_ct *ct, intel_guc_notify(ct_to_guc(ct)); err = wait_for_ct_request_update(&request, status); + g2h_release_space(ct, GUC_CTB_HXG_MSG_MAX_LEN); if (unlikely(err)) goto unlink; @@ -711,7 +757,10 @@ int intel_guc_ct_send(struct intel_guc_ct *ct, const u32 *action, u32 len, int ret; if (unlikely(!ct->enabled)) { - WARN(1, "Unexpected send: action=%#x\n", *action); + struct intel_guc *guc = ct_to_guc(ct); + struct intel_uc *uc = container_of(guc, struct intel_uc, guc); + + WARN(!uc->reset_in_progress, "Unexpected send: action=%#x\n", *action); return -ENODEV; } @@ -928,6 +977,19 @@ static int ct_process_request(struct intel_guc_ct *ct, struct ct_incoming_msg *r case INTEL_GUC_ACTION_DEFAULT: ret = intel_guc_to_host_process_recv_msg(guc, payload, len); break; + case INTEL_GUC_ACTION_DEREGISTER_CONTEXT_DONE: + ret = intel_guc_deregister_done_process_msg(guc, payload, + len); + break; + case INTEL_GUC_ACTION_SCHED_CONTEXT_MODE_DONE: + ret = intel_guc_sched_done_process_msg(guc, payload, len); + break; + case INTEL_GUC_ACTION_CONTEXT_RESET_NOTIFICATION: + ret = intel_guc_context_reset_process_msg(guc, payload, len); + break; + case INTEL_GUC_ACTION_ENGINE_FAILURE_NOTIFICATION: + ret = intel_guc_engine_failure_process_msg(guc, payload, len); + break; default: ret = -EOPNOTSUPP; break; @@ -985,10 +1047,22 @@ static void ct_incoming_request_worker_func(struct work_struct *w) static int ct_handle_event(struct intel_guc_ct *ct, struct ct_incoming_msg *request) { const u32 *hxg = &request->msg[GUC_CTB_MSG_MIN_LEN]; + u32 action = FIELD_GET(GUC_HXG_EVENT_MSG_0_ACTION, hxg[0]); unsigned long flags; GEM_BUG_ON(FIELD_GET(GUC_HXG_MSG_0_TYPE, hxg[0]) != GUC_HXG_TYPE_EVENT); + /* + * Adjusting the space must be done in IRQ or deadlock can occur as the + * CTB processing in the below workqueue can send CTBs which creates a + * circular dependency if the space was returned there. + */ + switch (action) { + case INTEL_GUC_ACTION_SCHED_CONTEXT_MODE_DONE: + case INTEL_GUC_ACTION_DEREGISTER_CONTEXT_DONE: + g2h_release_space(ct, request->size); + } + spin_lock_irqsave(&ct->requests.lock, flags); list_add_tail(&request->link, &ct->requests.incoming); spin_unlock_irqrestore(&ct->requests.lock, flags); @@ -1106,3 +1180,25 @@ void intel_guc_ct_event_handler(struct intel_guc_ct *ct) ct_try_receive_message(ct); } + +void intel_guc_ct_print_info(struct intel_guc_ct *ct, + struct drm_printer *p) +{ + drm_printf(p, "CT %s\n", enableddisabled(ct->enabled)); + + if (!ct->enabled) + return; + + drm_printf(p, "H2G Space: %u\n", + atomic_read(&ct->ctbs.send.space) * 4); + drm_printf(p, "Head: %u\n", + ct->ctbs.send.desc->head); + drm_printf(p, "Tail: %u\n", + ct->ctbs.send.desc->tail); + drm_printf(p, "G2H Space: %u\n", + atomic_read(&ct->ctbs.recv.space) * 4); + drm_printf(p, "Head: %u\n", + ct->ctbs.recv.desc->head); + drm_printf(p, "Tail: %u\n", + ct->ctbs.recv.desc->tail); +} diff --git a/drivers/gpu/drm/i915/gt/uc/intel_guc_ct.h b/drivers/gpu/drm/i915/gt/uc/intel_guc_ct.h index edd1bba0445d..7b34026d264a 100644 --- a/drivers/gpu/drm/i915/gt/uc/intel_guc_ct.h +++ b/drivers/gpu/drm/i915/gt/uc/intel_guc_ct.h @@ -10,11 +10,13 @@ #include #include #include +#include #include "intel_guc_fwif.h" struct i915_vma; struct intel_guc; +struct drm_printer; /** * DOC: Command Transport (CT). @@ -33,6 +35,7 @@ struct intel_guc; * @desc: pointer to the buffer descriptor * @cmds: pointer to the commands buffer * @size: size of the commands buffer in dwords + * @resv_space: reserved space in buffer in dwords * @head: local shadow copy of head in dwords * @tail: local shadow copy of tail in dwords * @space: local shadow copy of space in dwords @@ -43,9 +46,10 @@ struct intel_guc_ct_buffer { struct guc_ct_buffer_desc *desc; u32 *cmds; u32 size; + u32 resv_space; u32 tail; u32 head; - u32 space; + atomic_t space; bool broken; }; @@ -66,6 +70,9 @@ struct intel_guc_ct { struct tasklet_struct receive_tasklet; + /** @wq: wait queue for g2h chanenl */ + wait_queue_head_t wq; + struct { u16 last_fence; /* last fence used to send request */ @@ -97,8 +104,15 @@ static inline bool intel_guc_ct_enabled(struct intel_guc_ct *ct) } #define INTEL_GUC_CT_SEND_NB BIT(31) +#define INTEL_GUC_CT_SEND_G2H_DW_SHIFT 0 +#define INTEL_GUC_CT_SEND_G2H_DW_MASK (0xff << INTEL_GUC_CT_SEND_G2H_DW_SHIFT) +#define MAKE_SEND_FLAGS(len) \ + ({GEM_BUG_ON(!FIELD_FIT(INTEL_GUC_CT_SEND_G2H_DW_MASK, len)); \ + (FIELD_PREP(INTEL_GUC_CT_SEND_G2H_DW_MASK, len) | INTEL_GUC_CT_SEND_NB);}) int intel_guc_ct_send(struct intel_guc_ct *ct, const u32 *action, u32 len, u32 *response_buf, u32 response_buf_size, u32 flags); void intel_guc_ct_event_handler(struct intel_guc_ct *ct); +void intel_guc_ct_print_info(struct intel_guc_ct *ct, struct drm_printer *p); + #endif /* _INTEL_GUC_CT_H_ */ diff --git a/drivers/gpu/drm/i915/gt/uc/intel_guc_debugfs.c b/drivers/gpu/drm/i915/gt/uc/intel_guc_debugfs.c index fe7cb7b29a1e..72ddfff42f7d 100644 --- a/drivers/gpu/drm/i915/gt/uc/intel_guc_debugfs.c +++ b/drivers/gpu/drm/i915/gt/uc/intel_guc_debugfs.c @@ -9,6 +9,9 @@ #include "intel_guc.h" #include "intel_guc_debugfs.h" #include "intel_guc_log_debugfs.h" +#include "gt/uc/intel_guc_ct.h" +#include "gt/uc/intel_guc_ads.h" +#include "gt/uc/intel_guc_submission.h" static int guc_info_show(struct seq_file *m, void *data) { @@ -22,16 +25,36 @@ static int guc_info_show(struct seq_file *m, void *data) drm_puts(&p, "\n"); intel_guc_log_info(&guc->log, &p); - /* Add more as required ... */ + if (!intel_guc_submission_is_used(guc)) + return 0; + + intel_guc_ct_print_info(&guc->ct, &p); + intel_guc_submission_print_info(guc, &p); + intel_guc_ads_print_policy_info(guc, &p); return 0; } DEFINE_GT_DEBUGFS_ATTRIBUTE(guc_info); +static int guc_registered_contexts_show(struct seq_file *m, void *data) +{ + struct intel_guc *guc = m->private; + struct drm_printer p = drm_seq_file_printer(m); + + if (!intel_guc_submission_is_used(guc)) + return -ENODEV; + + intel_guc_submission_print_context_info(guc, &p); + + return 0; +} +DEFINE_GT_DEBUGFS_ATTRIBUTE(guc_registered_contexts); + void intel_guc_debugfs_register(struct intel_guc *guc, struct dentry *root) { static const struct debugfs_gt_file files[] = { { "guc_info", &guc_info_fops, NULL }, + { "guc_registered_contexts", &guc_registered_contexts_fops, NULL }, }; if (!intel_guc_is_supported(guc)) diff --git a/drivers/gpu/drm/i915/gt/uc/intel_guc_fwif.h b/drivers/gpu/drm/i915/gt/uc/intel_guc_fwif.h index 617ec601648d..94bb1ca6f889 100644 --- a/drivers/gpu/drm/i915/gt/uc/intel_guc_fwif.h +++ b/drivers/gpu/drm/i915/gt/uc/intel_guc_fwif.h @@ -17,14 +17,21 @@ #include "abi/guc_communication_ctb_abi.h" #include "abi/guc_messages_abi.h" +/* Payload length only i.e. don't include G2H header length */ +#define G2H_LEN_DW_SCHED_CONTEXT_MODE_SET 2 +#define G2H_LEN_DW_DEREGISTER_CONTEXT 1 + +#define GUC_CONTEXT_DISABLE 0 +#define GUC_CONTEXT_ENABLE 1 + #define GUC_CLIENT_PRIORITY_KMD_HIGH 0 #define GUC_CLIENT_PRIORITY_HIGH 1 #define GUC_CLIENT_PRIORITY_KMD_NORMAL 2 #define GUC_CLIENT_PRIORITY_NORMAL 3 #define GUC_CLIENT_PRIORITY_NUM 4 -#define GUC_MAX_STAGE_DESCRIPTORS 1024 -#define GUC_INVALID_STAGE_ID GUC_MAX_STAGE_DESCRIPTORS +#define GUC_MAX_LRC_DESCRIPTORS 65535 +#define GUC_INVALID_LRC_ID GUC_MAX_LRC_DESCRIPTORS #define GUC_RENDER_ENGINE 0 #define GUC_VIDEO_ENGINE 1 @@ -175,66 +182,39 @@ struct guc_process_desc { u32 reserved[30]; } __packed; -/* engine id and context id is packed into guc_execlist_context.context_id*/ -#define GUC_ELC_CTXID_OFFSET 0 -#define GUC_ELC_ENGINE_OFFSET 29 +#define CONTEXT_REGISTRATION_FLAG_KMD BIT(0) -/* The execlist context including software and HW information */ -struct guc_execlist_context { - u32 context_desc; - u32 context_id; - u32 ring_status; - u32 ring_lrca; - u32 ring_begin; - u32 ring_end; - u32 ring_next_free_location; - u32 ring_current_tail_pointer_value; - u8 engine_state_submit_value; - u8 engine_state_wait_value; - u16 pagefault_count; - u16 engine_submit_queue_count; -} __packed; +#define CONTEXT_POLICY_DEFAULT_EXECUTION_QUANTUM_US 1000000 +#define CONTEXT_POLICY_DEFAULT_PREEMPTION_TIME_US 500000 + +/* Preempt to idle on quantum expiry */ +#define CONTEXT_POLICY_FLAG_PREEMPT_TO_IDLE BIT(0) /* - * This structure describes a stage set arranged for a particular communication - * between uKernel (GuC) and Driver (KMD). Technically, this is known as a - * "GuC Context descriptor" in the specs, but we use the term "stage descriptor" - * to avoid confusion with all the other things already named "context" in the - * driver. A static pool of these descriptors are stored inside a GEM object - * (stage_desc_pool) which is held for the entire lifetime of our interaction - * with the GuC, being allocated before the GuC is loaded with its firmware. + * GuC Context registration descriptor. + * FIXME: This is only required to exist during context registration. + * The current 1:1 between guc_lrc_desc and LRCs for the lifetime of the LRC + * is not required. */ -struct guc_stage_desc { - u32 sched_common_area; - u32 stage_id; - u32 pas_id; - u8 engines_used; - u64 db_trigger_cpu; - u32 db_trigger_uk; - u64 db_trigger_phy; - u16 db_id; - - struct guc_execlist_context lrc[GUC_MAX_ENGINES_NUM]; - - u8 attribute; - +struct guc_lrc_desc { + u32 hw_context_desc; + u32 slpm_perf_mode_hint; /* SPLC v1 only */ + u32 slpm_freq_hint; + u32 engine_submit_mask; /* In logical space */ + u8 engine_class; + u8 reserved0[3]; u32 priority; - - u32 wq_sampled_tail_offset; - u32 wq_total_submit_enqueues; - u32 process_desc; u32 wq_addr; u32 wq_size; - - u32 engine_presence; - - u8 engine_suspended; - - u8 reserved0[3]; - u64 reserved1[1]; - - u64 desc_private; + u32 context_flags; /* CONTEXT_REGISTRATION_* */ + /* Time for one workload to execute. (in micro seconds) */ + u32 execution_quantum; + /* Time to wait for a preemption request to complete before issuing a + * reset. (in micro seconds). */ + u32 preemption_timeout; + u32 policy_flags; /* CONTEXT_POLICY_* */ + u32 reserved1[19]; } __packed; #define GUC_POWER_UNSPECIFIED 0 diff --git a/drivers/gpu/drm/i915/gt/uc/intel_guc_submission.c b/drivers/gpu/drm/i915/gt/uc/intel_guc_submission.c index e9c237b18692..259f79dfe7bb 100644 --- a/drivers/gpu/drm/i915/gt/uc/intel_guc_submission.c +++ b/drivers/gpu/drm/i915/gt/uc/intel_guc_submission.c @@ -10,10 +10,13 @@ #include "gt/intel_breadcrumbs.h" #include "gt/intel_context.h" #include "gt/intel_engine_pm.h" +#include "gt/intel_engine_heartbeat.h" #include "gt/intel_gt.h" #include "gt/intel_gt_irq.h" #include "gt/intel_gt_pm.h" +#include "gt/intel_gt_requests.h" #include "gt/intel_lrc.h" +#include "gt/intel_lrc_reg.h" #include "gt/intel_mocs.h" #include "gt/intel_ring.h" @@ -58,246 +61,697 @@ * */ +/* GuC Virtual Engine */ +struct guc_virtual_engine { + struct intel_engine_cs base; + struct intel_context context; +}; + +static struct intel_context * +guc_create_virtual(struct intel_engine_cs **siblings, unsigned int count); + #define GUC_REQUEST_SIZE 64 /* bytes */ -static inline struct i915_priolist *to_priolist(struct rb_node *rb) +/* + * Below is a set of functions which control the GuC scheduling state which do + * not require a lock as all state transitions are mutually exclusive. i.e. It + * is not possible for the context pinning code and submission, for the same + * context, to be executing simultaneously. We still need an atomic as it is + * possible for some of the bits to changing at the same time though. + */ +#define SCHED_STATE_NO_LOCK_ENABLED BIT(0) +#define SCHED_STATE_NO_LOCK_PENDING_ENABLE BIT(1) +#define SCHED_STATE_NO_LOCK_REGISTERED BIT(2) +#define SCHED_STATE_NO_LOCK_BLOCKED_SHIFT 3 +#define SCHED_STATE_NO_LOCK_BLOCKED \ + BIT(SCHED_STATE_NO_LOCK_BLOCKED_SHIFT) +#define SCHED_STATE_NO_LOCK_BLOCKED_MASK \ + (0xffff << SCHED_STATE_NO_LOCK_BLOCKED_SHIFT) +static inline bool context_enabled(struct intel_context *ce) { - return rb_entry(rb, struct i915_priolist, node); + return (atomic_read(&ce->guc_sched_state_no_lock) & + SCHED_STATE_NO_LOCK_ENABLED); +} + +static inline void set_context_enabled(struct intel_context *ce) +{ + atomic_or(SCHED_STATE_NO_LOCK_ENABLED, &ce->guc_sched_state_no_lock); +} + +static inline void clr_context_enabled(struct intel_context *ce) +{ + atomic_and((u32)~SCHED_STATE_NO_LOCK_ENABLED, + &ce->guc_sched_state_no_lock); +} + +static inline bool context_pending_enable(struct intel_context *ce) +{ + return (atomic_read(&ce->guc_sched_state_no_lock) & + SCHED_STATE_NO_LOCK_PENDING_ENABLE); } -static struct guc_stage_desc *__get_stage_desc(struct intel_guc *guc, u32 id) +static inline void set_context_pending_enable(struct intel_context *ce) { - struct guc_stage_desc *base = guc->stage_desc_pool_vaddr; + atomic_or(SCHED_STATE_NO_LOCK_PENDING_ENABLE, + &ce->guc_sched_state_no_lock); +} + +static inline void clr_context_pending_enable(struct intel_context *ce) +{ + atomic_and((u32)~SCHED_STATE_NO_LOCK_PENDING_ENABLE, + &ce->guc_sched_state_no_lock); +} + +static inline u32 context_blocked(struct intel_context *ce) +{ + return (atomic_read(&ce->guc_sched_state_no_lock) & + SCHED_STATE_NO_LOCK_BLOCKED_MASK) >> + SCHED_STATE_NO_LOCK_BLOCKED_SHIFT; +} + +static inline void incr_context_blocked(struct intel_context *ce) +{ + lockdep_assert_held(&ce->engine->sched_engine->lock); + atomic_add(SCHED_STATE_NO_LOCK_BLOCKED, + &ce->guc_sched_state_no_lock); +} - return &base[id]; +static inline void decr_context_blocked(struct intel_context *ce) +{ + lockdep_assert_held(&ce->engine->sched_engine->lock); + atomic_sub(SCHED_STATE_NO_LOCK_BLOCKED, + &ce->guc_sched_state_no_lock); } -static int guc_stage_desc_pool_create(struct intel_guc *guc) +static inline bool context_registered(struct intel_context *ce) { - u32 size = PAGE_ALIGN(sizeof(struct guc_stage_desc) * - GUC_MAX_STAGE_DESCRIPTORS); + return (atomic_read(&ce->guc_sched_state_no_lock) & + SCHED_STATE_NO_LOCK_REGISTERED); +} - return intel_guc_allocate_and_map_vma(guc, size, &guc->stage_desc_pool, - &guc->stage_desc_pool_vaddr); +static inline void set_context_registered(struct intel_context *ce) +{ + atomic_or(SCHED_STATE_NO_LOCK_REGISTERED, + &ce->guc_sched_state_no_lock); } -static void guc_stage_desc_pool_destroy(struct intel_guc *guc) +static inline void clr_context_registered(struct intel_context *ce) { - i915_vma_unpin_and_release(&guc->stage_desc_pool, I915_VMA_RELEASE_MAP); + atomic_and((u32)~SCHED_STATE_NO_LOCK_REGISTERED, + &ce->guc_sched_state_no_lock); } /* - * Initialise/clear the stage descriptor shared with the GuC firmware. - * - * This descriptor tells the GuC where (in GGTT space) to find the important - * data structures related to work submission (process descriptor, write queue, - * etc). + * Below is a set of functions which control the GuC scheduling state which + * require a lock, aside from the special case where the functions are called + * from guc_lrc_desc_pin(). In that case it isn't possible for any other code + * path to be executing on the context. */ -static void guc_stage_desc_init(struct intel_guc *guc) +#define SCHED_STATE_WAIT_FOR_DEREGISTER_TO_REGISTER BIT(0) +#define SCHED_STATE_DESTROYED BIT(1) +#define SCHED_STATE_PENDING_DISABLE BIT(2) +#define SCHED_STATE_BANNED BIT(3) +static inline void init_sched_state(struct intel_context *ce) +{ + /* Only should be called from guc_lrc_desc_pin() */ + atomic_set(&ce->guc_sched_state_no_lock, 0); + ce->guc_state.sched_state = 0; +} + +static inline bool +context_wait_for_deregister_to_register(struct intel_context *ce) { - struct guc_stage_desc *desc; + return ce->guc_state.sched_state & + SCHED_STATE_WAIT_FOR_DEREGISTER_TO_REGISTER; +} - /* we only use 1 stage desc, so hardcode it to 0 */ - desc = __get_stage_desc(guc, 0); - memset(desc, 0, sizeof(*desc)); +static inline void +set_context_wait_for_deregister_to_register(struct intel_context *ce) +{ + /* Only should be called from guc_lrc_desc_pin() without lock */ + ce->guc_state.sched_state |= + SCHED_STATE_WAIT_FOR_DEREGISTER_TO_REGISTER; +} - desc->attribute = GUC_STAGE_DESC_ATTR_ACTIVE | - GUC_STAGE_DESC_ATTR_KERNEL; +static inline void +clr_context_wait_for_deregister_to_register(struct intel_context *ce) +{ + lockdep_assert_held(&ce->guc_state.lock); + ce->guc_state.sched_state &= + ~SCHED_STATE_WAIT_FOR_DEREGISTER_TO_REGISTER; +} - desc->stage_id = 0; - desc->priority = GUC_CLIENT_PRIORITY_KMD_NORMAL; +static inline bool +context_destroyed(struct intel_context *ce) +{ + return ce->guc_state.sched_state & SCHED_STATE_DESTROYED; +} - desc->wq_size = GUC_WQ_SIZE; +static inline void +set_context_destroyed(struct intel_context *ce) +{ + lockdep_assert_held(&ce->guc_state.lock); + ce->guc_state.sched_state |= SCHED_STATE_DESTROYED; } -static void guc_stage_desc_fini(struct intel_guc *guc) +static inline bool context_pending_disable(struct intel_context *ce) { - struct guc_stage_desc *desc; + return ce->guc_state.sched_state & SCHED_STATE_PENDING_DISABLE; +} - desc = __get_stage_desc(guc, 0); - memset(desc, 0, sizeof(*desc)); +static inline void set_context_pending_disable(struct intel_context *ce) +{ + lockdep_assert_held(&ce->guc_state.lock); + ce->guc_state.sched_state |= SCHED_STATE_PENDING_DISABLE; } -static void guc_add_request(struct intel_guc *guc, struct i915_request *rq) +static inline void clr_context_pending_disable(struct intel_context *ce) { - /* Leaving stub as this function will be used in future patches */ + lockdep_assert_held(&ce->guc_state.lock); + ce->guc_state.sched_state &= ~SCHED_STATE_PENDING_DISABLE; } -/* - * When we're doing submissions using regular execlists backend, writing to - * ELSP from CPU side is enough to make sure that writes to ringbuffer pages - * pinned in mappable aperture portion of GGTT are visible to command streamer. - * Writes done by GuC on our behalf are not guaranteeing such ordering, - * therefore, to ensure the flush, we're issuing a POSTING READ. - */ -static void flush_ggtt_writes(struct i915_vma *vma) +static inline bool context_banned(struct intel_context *ce) { - if (i915_vma_is_map_and_fenceable(vma)) - intel_uncore_posting_read_fw(vma->vm->gt->uncore, - GUC_STATUS); + return ce->guc_state.sched_state & SCHED_STATE_BANNED; } -static void guc_submit(struct intel_engine_cs *engine, - struct i915_request **out, - struct i915_request **end) +static inline void set_context_banned(struct intel_context *ce) { - struct intel_guc *guc = &engine->gt->uc.guc; + lockdep_assert_held(&ce->guc_state.lock); + ce->guc_state.sched_state |= SCHED_STATE_BANNED; +} - do { - struct i915_request *rq = *out++; +static inline void clr_context_banned(struct intel_context *ce) +{ + lockdep_assert_held(&ce->guc_state.lock); + ce->guc_state.sched_state &= ~SCHED_STATE_BANNED; +} - flush_ggtt_writes(rq->ring->vma); - guc_add_request(guc, rq); - } while (out != end); +static inline bool context_guc_id_invalid(struct intel_context *ce) +{ + return (ce->guc_id == GUC_INVALID_LRC_ID); } -static inline int rq_prio(const struct i915_request *rq) +static inline void set_context_guc_id_invalid(struct intel_context *ce) { - return rq->sched.attr.priority; + ce->guc_id = GUC_INVALID_LRC_ID; +} + +static inline struct intel_guc *ce_to_guc(struct intel_context *ce) +{ + return &ce->engine->gt->uc.guc; +} + +static inline struct i915_priolist *to_priolist(struct rb_node *rb) +{ + return rb_entry(rb, struct i915_priolist, node); +} + +static struct guc_lrc_desc *__get_lrc_desc(struct intel_guc *guc, u32 index) +{ + struct guc_lrc_desc *base = guc->lrc_desc_pool_vaddr; + + GEM_BUG_ON(index >= GUC_MAX_LRC_DESCRIPTORS); + + return &base[index]; +} + +static inline struct intel_context *__get_context(struct intel_guc *guc, u32 id) +{ + struct intel_context *ce = xa_load(&guc->context_lookup, id); + + GEM_BUG_ON(id >= GUC_MAX_LRC_DESCRIPTORS); + + return ce; +} + +static int guc_lrc_desc_pool_create(struct intel_guc *guc) +{ + u32 size; + int ret; + + size = PAGE_ALIGN(sizeof(struct guc_lrc_desc) * + GUC_MAX_LRC_DESCRIPTORS); + ret = intel_guc_allocate_and_map_vma(guc, size, &guc->lrc_desc_pool, + (void **)&guc->lrc_desc_pool_vaddr); + if (ret) + return ret; + + return 0; } -static struct i915_request *schedule_in(struct i915_request *rq, int idx) +static void guc_lrc_desc_pool_destroy(struct intel_guc *guc) { - trace_i915_request_in(rq, idx); + guc->lrc_desc_pool_vaddr = NULL; + i915_vma_unpin_and_release(&guc->lrc_desc_pool, I915_VMA_RELEASE_MAP); +} + +static inline bool guc_submission_initialized(struct intel_guc *guc) +{ + return guc->lrc_desc_pool_vaddr != NULL; +} + +static inline void reset_lrc_desc(struct intel_guc *guc, u32 id) +{ + if (likely(guc_submission_initialized(guc))) { + struct guc_lrc_desc *desc = __get_lrc_desc(guc, id); + unsigned long flags; + + memset(desc, 0, sizeof(*desc)); + + /* + * xarray API doesn't have xa_erase_irqsave wrapper, so calling + * the lower level functions directly. + */ + xa_lock_irqsave(&guc->context_lookup, flags); + __xa_erase(&guc->context_lookup, id); + xa_unlock_irqrestore(&guc->context_lookup, flags); + } +} + +static inline bool lrc_desc_registered(struct intel_guc *guc, u32 id) +{ + return __get_context(guc, id); +} + +static inline void set_lrc_desc_registered(struct intel_guc *guc, u32 id, + struct intel_context *ce) +{ + unsigned long flags; /* - * Currently we are not tracking the rq->context being inflight - * (ce->inflight = rq->engine). It is only used by the execlists - * backend at the moment, a similar counting strategy would be - * required if we generalise the inflight tracking. + * xarray API doesn't have xa_save_irqsave wrapper, so calling the + * lower level functions directly. */ + xa_lock_irqsave(&guc->context_lookup, flags); + __xa_store(&guc->context_lookup, id, ce, GFP_ATOMIC); + xa_unlock_irqrestore(&guc->context_lookup, flags); +} + +static int guc_submission_send_busy_loop(struct intel_guc* guc, + const u32 *action, + u32 len, + u32 g2h_len_dw, + bool loop) +{ + int err; + + err = intel_guc_send_busy_loop(guc, action, len, g2h_len_dw, loop); - __intel_gt_pm_get(rq->engine->gt); - return i915_request_get(rq); + if (!err && g2h_len_dw) + atomic_inc(&guc->outstanding_submission_g2h); + + return err; } -static void schedule_out(struct i915_request *rq) +int intel_guc_wait_for_pending_msg(struct intel_guc *guc, + atomic_t *wait_var, + bool interruptible, + long timeout) { - trace_i915_request_out(rq); + const int state = interruptible ? + TASK_INTERRUPTIBLE : TASK_UNINTERRUPTIBLE; + DEFINE_WAIT(wait); + + might_sleep(); + GEM_BUG_ON(timeout < 0); + + if (!atomic_read(wait_var)) + return 0; + + if (!timeout) + return -ETIME; + + for (;;) { + prepare_to_wait(&guc->ct.wq, &wait, state); + + if (!atomic_read(wait_var)) + break; + + if (signal_pending_state(state, current)) { + timeout = -EINTR; + break; + } + + if (!timeout) { + timeout = -ETIME; + break; + } - intel_gt_pm_put_async(rq->engine->gt); - i915_request_put(rq); + timeout = io_schedule_timeout(timeout); + } + finish_wait(&guc->ct.wq, &wait); + + return (timeout < 0) ? timeout : 0; } -static void __guc_dequeue(struct intel_engine_cs *engine) +int intel_guc_wait_for_idle(struct intel_guc *guc, long timeout) { - struct intel_engine_execlists * const execlists = &engine->execlists; - struct i915_sched_engine * const sched_engine = engine->sched_engine; - struct i915_request **first = execlists->inflight; - struct i915_request ** const last_port = first + execlists->port_mask; - struct i915_request *last = first[0]; - struct i915_request **port; - bool submit = false; - struct rb_node *rb; + if (!intel_uc_uses_guc_submission(&guc_to_gt(guc)->uc)) + return 0; - lockdep_assert_held(&sched_engine->lock); + return intel_guc_wait_for_pending_msg(guc, + &guc->outstanding_submission_g2h, + true, timeout); +} - if (last) { - if (*++first) - return; +static int guc_lrc_desc_pin(struct intel_context *ce, bool loop); - last = NULL; +static int guc_add_request(struct intel_guc *guc, struct i915_request *rq) +{ + int err = 0; + struct intel_context *ce = rq->context; + u32 action[3]; + int len = 0; + u32 g2h_len_dw = 0; + bool enabled; + + /* + * Corner case where requests were sitting in the priority list or a + * request resubmitted after the context was banned. + */ + if (unlikely(intel_context_is_banned(ce))) { + i915_request_put(i915_request_mark_eio(rq)); + intel_engine_signal_breadcrumbs(ce->engine); + goto out; } + GEM_BUG_ON(!atomic_read(&ce->guc_id_ref)); + GEM_BUG_ON(context_guc_id_invalid(ce)); + /* - * We write directly into the execlists->inflight queue and don't use - * the execlists->pending queue, as we don't have a distinct switch - * event. + * Corner case where the GuC firmware was blown away and reloaded while + * this context was pinned. */ - port = first; + if (unlikely(!lrc_desc_registered(guc, ce->guc_id))) { + err = guc_lrc_desc_pin(ce, false); + if (unlikely(err)) + goto out; + } + + if (unlikely(context_blocked(ce))) + goto out; + + enabled = context_enabled(ce); + + if (!enabled) { + action[len++] = INTEL_GUC_ACTION_SCHED_CONTEXT_MODE_SET; + action[len++] = ce->guc_id; + action[len++] = GUC_CONTEXT_ENABLE; + set_context_pending_enable(ce); + intel_context_get(ce); + g2h_len_dw = G2H_LEN_DW_SCHED_CONTEXT_MODE_SET; + } else { + action[len++] = INTEL_GUC_ACTION_SCHED_CONTEXT; + action[len++] = ce->guc_id; + } + + err = intel_guc_send_nb(guc, action, len, g2h_len_dw); + if (!enabled && !err) { + trace_intel_context_sched_enable(ce); + atomic_inc(&guc->outstanding_submission_g2h); + set_context_enabled(ce); + } else if (!enabled) { + clr_context_pending_enable(ce); + intel_context_put(ce); + } + if (likely(!err)) + trace_i915_request_guc_submit(rq); + +out: + return err; +} + +static inline void guc_set_lrc_tail(struct i915_request *rq) +{ + rq->context->lrc_reg_state[CTX_RING_TAIL] = + intel_ring_set_tail(rq->ring, rq->tail); +} + +static inline int rq_prio(const struct i915_request *rq) +{ + return rq->sched.attr.priority; +} + +static int guc_dequeue_one_context(struct intel_guc *guc) +{ + struct i915_sched_engine * const sched_engine = guc->sched_engine; + struct i915_request *last = NULL; + bool submit = false; + struct rb_node *rb; + int ret; + + lockdep_assert_held(&sched_engine->lock); + + if (guc->stalled_request) { + submit = true; + last = guc->stalled_request; + goto resubmit; + } + while ((rb = rb_first_cached(&sched_engine->queue))) { struct i915_priolist *p = to_priolist(rb); struct i915_request *rq, *rn; priolist_for_each_request_consume(rq, rn, p) { - if (last && rq->context != last->context) { - if (port == last_port) - goto done; - - *port = schedule_in(last, - port - execlists->inflight); - port++; - } + if (last && rq->context != last->context) + goto done; list_del_init(&rq->sched.link); + __i915_request_submit(rq); - submit = true; + + trace_i915_request_in(rq, 0); last = rq; + submit = true; } rb_erase_cached(&p->node, &sched_engine->queue); i915_priolist_free(p); } done: - sched_engine->queue_priority_hint = - rb ? to_priolist(rb)->priority : INT_MIN; if (submit) { - *port = schedule_in(last, port - execlists->inflight); - *++port = NULL; - guc_submit(engine, first, port); + guc_set_lrc_tail(last); +resubmit: + ret = guc_add_request(guc, last); + if (unlikely(ret == -EPIPE)) + goto deadlk; + else if (ret == -EBUSY) { + tasklet_schedule(&sched_engine->tasklet); + guc->stalled_request = last; + return false; + } } - execlists->active = execlists->inflight; + + guc->stalled_request = NULL; + return submit; + +deadlk: + sched_engine->tasklet.callback = NULL; + tasklet_disable_nosync(&sched_engine->tasklet); + return false; } static void guc_submission_tasklet(struct tasklet_struct *t) { struct i915_sched_engine *sched_engine = from_tasklet(sched_engine, t, tasklet); - struct intel_engine_cs * const engine = sched_engine->private_data; - struct intel_engine_execlists * const execlists = &engine->execlists; - struct i915_request **port, *rq; unsigned long flags; + bool loop; + + spin_lock_irqsave(&sched_engine->lock, flags); - spin_lock_irqsave(&engine->sched_engine->lock, flags); + do { + loop = guc_dequeue_one_context(sched_engine->private_data); + } while (loop); - for (port = execlists->inflight; (rq = *port); port++) { - if (!i915_request_completed(rq)) - break; + i915_sched_engine_reset_on_empty(sched_engine); - schedule_out(rq); - } - if (port != execlists->inflight) { - int idx = port - execlists->inflight; - int rem = ARRAY_SIZE(execlists->inflight) - idx; - memmove(execlists->inflight, port, rem * sizeof(*port)); + spin_unlock_irqrestore(&sched_engine->lock, flags); +} + +static void cs_irq_handler(struct intel_engine_cs *engine, u16 iir) +{ + if (iir & GT_RENDER_USER_INTERRUPT) + intel_engine_signal_breadcrumbs(engine); +} + +static void __guc_context_destroy(struct intel_context *ce); +static void release_guc_id(struct intel_guc *guc, struct intel_context *ce); +static void guc_signal_context_fence(struct intel_context *ce); +static void guc_cancel_context_requests(struct intel_context *ce); +static void guc_blocked_fence_complete(struct intel_context *ce); + +static void scrub_guc_desc_for_outstanding_g2h(struct intel_guc *guc) +{ + struct intel_context *ce; + unsigned long index, flags; + bool pending_disable, pending_enable, deregister, destroyed, banned; + + xa_for_each(&guc->context_lookup, index, ce) { + /* Flush context */ + spin_lock_irqsave(&ce->guc_state.lock, flags); + spin_unlock_irqrestore(&ce->guc_state.lock, flags); + + /* + * Once we are at this point submission_disabled() is guaranteed + * to visible to all callers who set the below flags (see above + * flush and flushes in reset_prepare). If submission_disabled() + * is set, the caller shouldn't set these flags. + */ + + destroyed = context_destroyed(ce); + pending_enable = context_pending_enable(ce); + pending_disable = context_pending_disable(ce); + deregister = context_wait_for_deregister_to_register(ce); + banned = context_banned(ce); + init_sched_state(ce); + + if (pending_enable || destroyed || deregister) { + atomic_dec(&guc->outstanding_submission_g2h); + if (deregister) + guc_signal_context_fence(ce); + if (destroyed) { + release_guc_id(guc, ce); + __guc_context_destroy(ce); + } + if (pending_enable|| deregister) + intel_context_put(ce); + } + + /* Not mutualy exclusive with above if statement. */ + if (pending_disable) { + guc_signal_context_fence(ce); + if (banned) { + guc_cancel_context_requests(ce); + intel_engine_signal_breadcrumbs(ce->engine); + } + intel_context_sched_disable_unpin(ce); + atomic_dec(&guc->outstanding_submission_g2h); + spin_lock_irqsave(&ce->guc_state.lock, flags); + guc_blocked_fence_complete(ce); + spin_unlock_irqrestore(&ce->guc_state.lock, flags); + + intel_context_put(ce); + } } +} + +static inline bool +submission_disabled(struct intel_guc *guc) +{ + struct i915_sched_engine * const sched_engine = guc->sched_engine; - __guc_dequeue(engine); + return unlikely(!sched_engine || + !__tasklet_is_enabled(&sched_engine->tasklet)); +} - i915_sched_engine_reset_on_empty(engine->sched_engine); +static void disable_submission(struct intel_guc *guc) +{ + struct i915_sched_engine * const sched_engine = guc->sched_engine; - spin_unlock_irqrestore(&engine->sched_engine->lock, flags); + if (__tasklet_is_enabled(&sched_engine->tasklet)) { + GEM_BUG_ON(!guc->ct.enabled); + __tasklet_disable_sync_once(&sched_engine->tasklet); + sched_engine->tasklet.callback = NULL; + } } -static void cs_irq_handler(struct intel_engine_cs *engine, u16 iir) +static void enable_submission(struct intel_guc *guc) { - if (iir & GT_RENDER_USER_INTERRUPT) { - intel_engine_signal_breadcrumbs(engine); - tasklet_hi_schedule(&engine->sched_engine->tasklet); + struct i915_sched_engine * const sched_engine = guc->sched_engine; + unsigned long flags; + + spin_lock_irqsave(&guc->sched_engine->lock, flags); + sched_engine->tasklet.callback = guc_submission_tasklet; + wmb(); + if (!__tasklet_is_enabled(&sched_engine->tasklet) && + __tasklet_enable(&sched_engine->tasklet)) { + GEM_BUG_ON(!guc->ct.enabled); + + /* And kick in case we missed a new request submission. */ + tasklet_hi_schedule(&sched_engine->tasklet); } + spin_unlock_irqrestore(&guc->sched_engine->lock, flags); } -static void guc_reset_prepare(struct intel_engine_cs *engine) +static void guc_flush_submissions(struct intel_guc *guc) { - ENGINE_TRACE(engine, "\n"); + struct i915_sched_engine * const sched_engine = guc->sched_engine; + unsigned long flags; + + spin_lock_irqsave(&sched_engine->lock, flags); + spin_unlock_irqrestore(&sched_engine->lock, flags); +} + +void intel_guc_submission_reset_prepare(struct intel_guc *guc) +{ + int i; + + if (unlikely(!guc_submission_initialized(guc))) + /* Reset called during driver load? GuC not yet initialised! */ + return; + + intel_gt_park_heartbeats(guc_to_gt(guc)); + disable_submission(guc); + guc->interrupts.disable(guc); + + /* Flush IRQ handler */ + spin_lock_irq(&guc_to_gt(guc)->irq_lock); + spin_unlock_irq(&guc_to_gt(guc)->irq_lock); + + guc_flush_submissions(guc); /* - * Prevent request submission to the hardware until we have - * completed the reset in i915_gem_reset_finish(). If a request - * is completed by one engine, it may then queue a request - * to a second via its execlists->tasklet *just* as we are - * calling engine->init_hw() and also writing the ELSP. - * Turning off the execlists->tasklet until the reset is over - * prevents the race. - */ - __tasklet_disable_sync_once(&engine->sched_engine->tasklet); + * Handle any outstanding G2Hs before reset. Call IRQ handler directly + * each pass as interrupt have been disabled. We always scrub for + * outstanding G2H as it is possible for outstanding_submission_g2h to + * be incremented after the context state update. + */ + for (i = 0; i < 4 && atomic_read(&guc->outstanding_submission_g2h); ++i) { + intel_guc_to_host_event_handler(guc); +#define wait_for_reset(guc, wait_var) \ + intel_guc_wait_for_pending_msg(guc, wait_var, false, (HZ / 20)) + do { + wait_for_reset(guc, &guc->outstanding_submission_g2h); + } while (!list_empty(&guc->ct.requests.incoming)); + } + scrub_guc_desc_for_outstanding_g2h(guc); +} + +static struct intel_engine_cs * +guc_virtual_get_sibling(struct intel_engine_cs *ve, unsigned int sibling) +{ + struct intel_engine_cs *engine; + intel_engine_mask_t tmp, mask = ve->mask; + unsigned int num_siblings = 0; + + for_each_engine_masked(engine, ve->gt, mask, tmp) + if (num_siblings++ == sibling) + return engine; + + return NULL; +} + +static inline struct intel_engine_cs * +__context_to_physical_engine(struct intel_context *ce) +{ + struct intel_engine_cs *engine = ce->engine; + + if (intel_engine_is_virtual(engine)) + engine = guc_virtual_get_sibling(engine, 0); + + return engine; } -static void guc_reset_state(struct intel_context *ce, - struct intel_engine_cs *engine, - u32 head, - bool scrub) +static void guc_reset_state(struct intel_context *ce, u32 head, bool scrub) { + struct intel_engine_cs *engine = __context_to_physical_engine(ce); + + if (intel_context_is_banned(ce)) + return; + GEM_BUG_ON(!intel_context_is_pinned(ce)); /* @@ -315,69 +769,158 @@ static void guc_reset_state(struct intel_context *ce, lrc_update_regs(ce, engine, head); } -static void guc_reset_rewind(struct intel_engine_cs *engine, bool stalled) +static void guc_reset_nop(struct intel_engine_cs *engine) { - struct intel_engine_execlists * const execlists = &engine->execlists; - struct i915_request *rq; - unsigned long flags; +} - spin_lock_irqsave(&engine->sched_engine->lock, flags); +static void guc_rewind_nop(struct intel_engine_cs *engine, bool stalled) +{ +} - /* Push back any incomplete requests for replay after the reset. */ - rq = execlists_unwind_incomplete_requests(execlists); - if (!rq) - goto out_unlock; +static void +__unwind_incomplete_requests(struct intel_context *ce) +{ + struct i915_request *rq, *rn; + struct list_head *pl; + int prio = I915_PRIORITY_INVALID; + struct i915_sched_engine * const sched_engine = + ce->engine->sched_engine; + unsigned long flags; - if (!i915_request_started(rq)) - stalled = false; + spin_lock_irqsave(&sched_engine->lock, flags); + spin_lock(&ce->guc_active.lock); + list_for_each_entry_safe(rq, rn, + &ce->guc_active.requests, + sched.link) { + if (i915_request_completed(rq)) + continue; + + list_del_init(&rq->sched.link); + spin_unlock(&ce->guc_active.lock); + + __i915_request_unsubmit(rq); + + /* Push the request back into the queue for later resubmission. */ + GEM_BUG_ON(rq_prio(rq) == I915_PRIORITY_INVALID); + if (rq_prio(rq) != prio) { + prio = rq_prio(rq); + pl = i915_sched_lookup_priolist(sched_engine, prio); + } + GEM_BUG_ON(i915_sched_engine_is_empty(sched_engine)); - __i915_request_reset(rq, stalled); - guc_reset_state(rq->context, engine, rq->head, stalled); + list_add_tail(&rq->sched.link, pl); + set_bit(I915_FENCE_FLAG_PQUEUE, &rq->fence.flags); -out_unlock: - spin_unlock_irqrestore(&engine->sched_engine->lock, flags); + spin_lock(&ce->guc_active.lock); + } + spin_unlock(&ce->guc_active.lock); + spin_unlock_irqrestore(&sched_engine->lock, flags); } -static void guc_reset_cancel(struct intel_engine_cs *engine) +static void __guc_reset_context(struct intel_context *ce, bool stalled) { - struct i915_sched_engine * const sched_engine = engine->sched_engine; - struct i915_request *rq, *rn; - struct rb_node *rb; - unsigned long flags; + struct i915_request *rq; + u32 head; - ENGINE_TRACE(engine, "\n"); + intel_context_get(ce); /* - * Before we call engine->cancel_requests(), we should have exclusive - * access to the submission state. This is arranged for us by the - * caller disabling the interrupt generation, the tasklet and other - * threads that may then access the same state, giving us a free hand - * to reset state. However, we still need to let lockdep be aware that - * we know this state may be accessed in hardirq context, so we - * disable the irq around this manipulation and we want to keep - * the spinlock focused on its duties and not accidentally conflate - * coverage to the submission's irq state. (Similarly, although we - * shouldn't need to disable irq around the manipulation of the - * submission's irq state, we also wish to remind ourselves that - * it is irq state.) + * GuC will implicitly mark the context as non-schedulable + * when it sends the reset notification. Make sure our state + * reflects this change. The context will be marked enabled + * on resubmission. */ - spin_lock_irqsave(&sched_engine->lock, flags); + clr_context_enabled(ce); - /* Mark all executing requests as skipped. */ - list_for_each_entry(rq, &sched_engine->requests, sched.link) { - i915_request_set_error_once(rq, -EIO); - i915_request_mark_complete(rq); + rq = intel_context_find_active_request(ce); + if (!rq) { + head = ce->ring->tail; + stalled = false; + goto out_replay; } - /* Flush the queued requests to the timeline list (for retiring). */ - while ((rb = rb_first_cached(&sched_engine->queue))) { - struct i915_priolist *p = to_priolist(rb); - + if (!i915_request_started(rq)) + stalled = false; + + GEM_BUG_ON(i915_active_is_idle(&ce->active)); + head = intel_ring_wrap(ce->ring, rq->head); + __i915_request_reset(rq, stalled); + +out_replay: + guc_reset_state(ce, head, stalled); + __unwind_incomplete_requests(ce); + intel_context_put(ce); +} + +void intel_guc_submission_reset(struct intel_guc *guc, bool stalled) +{ + struct intel_context *ce; + unsigned long index; + + if (unlikely(!guc_submission_initialized(guc))) + /* Reset called during driver load? GuC not yet initialised! */ + return; + + xa_for_each(&guc->context_lookup, index, ce) + if (intel_context_is_pinned(ce)) + __guc_reset_context(ce, stalled); + + /* GuC is blown away, drop all references to contexts */ + xa_destroy(&guc->context_lookup); +} + +static void guc_cancel_context_requests(struct intel_context *ce) +{ + struct i915_sched_engine *sched_engine = ce_to_guc(ce)->sched_engine; + struct i915_request *rq; + unsigned long flags; + + /* Mark all executing requests as skipped. */ + spin_lock_irqsave(&sched_engine->lock, flags); + spin_lock(&ce->guc_active.lock); + list_for_each_entry(rq, &ce->guc_active.requests, sched.link) + i915_request_put(i915_request_mark_eio(rq)); + spin_unlock(&ce->guc_active.lock); + spin_unlock_irqrestore(&sched_engine->lock, flags); +} + +static void +guc_cancel_sched_engine_requests(struct i915_sched_engine *sched_engine) +{ + struct i915_request *rq, *rn; + struct rb_node *rb; + unsigned long flags; + + /* Can be called during boot if GuC fails to load */ + if (!sched_engine) + return; + + /* + * Before we call engine->cancel_requests(), we should have exclusive + * access to the submission state. This is arranged for us by the + * caller disabling the interrupt generation, the tasklet and other + * threads that may then access the same state, giving us a free hand + * to reset state. However, we still need to let lockdep be aware that + * we know this state may be accessed in hardirq context, so we + * disable the irq around this manipulation and we want to keep + * the spinlock focused on its duties and not accidentally conflate + * coverage to the submission's irq state. (Similarly, although we + * shouldn't need to disable irq around the manipulation of the + * submission's irq state, we also wish to remind ourselves that + * it is irq state.) + */ + spin_lock_irqsave(&sched_engine->lock, flags); + + /* Flush the queued requests to the timeline list (for retiring). */ + while ((rb = rb_first_cached(&sched_engine->queue))) { + struct i915_priolist *p = to_priolist(rb); + priolist_for_each_request_consume(rq, rn, p) { list_del_init(&rq->sched.link); + __i915_request_submit(rq); - dma_fence_set_error(&rq->fence, -EIO); - i915_request_mark_complete(rq); + + i915_request_put(i915_request_mark_eio(rq)); } rb_erase_cached(&p->node, &sched_engine->queue); @@ -389,137 +932,1318 @@ static void guc_reset_cancel(struct intel_engine_cs *engine) sched_engine->queue_priority_hint = INT_MIN; sched_engine->queue = RB_ROOT_CACHED; - spin_unlock_irqrestore(&sched_engine->lock, flags); + spin_unlock_irqrestore(&sched_engine->lock, flags); +} + +void intel_guc_submission_cancel_requests(struct intel_guc *guc) +{ + struct intel_context *ce; + unsigned long index; + + xa_for_each(&guc->context_lookup, index, ce) + if (intel_context_is_pinned(ce)) + guc_cancel_context_requests(ce); + + guc_cancel_sched_engine_requests(guc->sched_engine); + + /* GuC is blown away, drop all references to contexts */ + xa_destroy(&guc->context_lookup); +} + +void intel_guc_submission_reset_finish(struct intel_guc *guc) +{ + /* Reset called during driver load or during wedge? */ + if (unlikely(!guc_submission_initialized(guc) || + test_bit(I915_WEDGED, &guc_to_gt(guc)->reset.flags))) + return; + + /* + * Technically possible for either of these values to be non-zero here, + * but very unlikely + harmless. Regardless let's add a warn so we can + * see in CI if this happens frequently / a precursor to taking down the + * machine. + */ + GEM_WARN_ON(atomic_read(&guc->outstanding_submission_g2h)); + atomic_set(&guc->outstanding_submission_g2h, 0); + + intel_guc_global_policies_update(guc); + enable_submission(guc); + intel_gt_unpark_heartbeats(guc_to_gt(guc)); +} + +/* + * Set up the memory resources to be shared with the GuC (via the GGTT) + * at firmware loading time. + */ +int intel_guc_submission_init(struct intel_guc *guc) +{ + int ret; + + if (guc->lrc_desc_pool) + return 0; + + ret = guc_lrc_desc_pool_create(guc); + if (ret) + return ret; + /* + * Keep static analysers happy, let them know that we allocated the + * vma after testing that it didn't exist earlier. + */ + GEM_BUG_ON(!guc->lrc_desc_pool); + + xa_init_flags(&guc->context_lookup, XA_FLAGS_LOCK_IRQ); + + spin_lock_init(&guc->contexts_lock); + INIT_LIST_HEAD(&guc->guc_id_list); + ida_init(&guc->guc_ids); + + return 0; +} + +void intel_guc_submission_fini(struct intel_guc *guc) +{ + if (!guc->lrc_desc_pool) + return; + + guc_lrc_desc_pool_destroy(guc); + i915_sched_engine_put(guc->sched_engine); +} + +static inline void queue_request(struct i915_sched_engine *sched_engine, + struct i915_request *rq, + int prio) +{ + GEM_BUG_ON(!list_empty(&rq->sched.link)); + list_add_tail(&rq->sched.link, + i915_sched_lookup_priolist(sched_engine, prio)); + set_bit(I915_FENCE_FLAG_PQUEUE, &rq->fence.flags); +} + +static int guc_bypass_tasklet_submit(struct intel_guc *guc, + struct i915_request *rq) +{ + int ret; + + __i915_request_submit(rq); + + trace_i915_request_in(rq, 0); + + guc_set_lrc_tail(rq); + ret = guc_add_request(guc, rq); + if (ret == -EBUSY) + guc->stalled_request = rq; + + if (unlikely(ret == -EPIPE)) + disable_submission(guc); + + return ret; +} + +static void guc_submit_request(struct i915_request *rq) +{ + struct i915_sched_engine *sched_engine = rq->engine->sched_engine; + struct intel_guc *guc = &rq->engine->gt->uc.guc; + unsigned long flags; + + /* Will be called from irq-context when using foreign fences. */ + spin_lock_irqsave(&sched_engine->lock, flags); + + if (submission_disabled(guc) || guc->stalled_request || + !i915_sched_engine_is_empty(sched_engine)) + queue_request(sched_engine, rq, rq_prio(rq)); + else if (guc_bypass_tasklet_submit(guc, rq) == -EBUSY) + tasklet_hi_schedule(&sched_engine->tasklet); + + spin_unlock_irqrestore(&sched_engine->lock, flags); +} + +static int new_guc_id(struct intel_guc *guc) +{ + return ida_simple_get(&guc->guc_ids, 0, + GUC_MAX_LRC_DESCRIPTORS, GFP_KERNEL | + __GFP_RETRY_MAYFAIL | __GFP_NOWARN); +} + +static void __release_guc_id(struct intel_guc *guc, struct intel_context *ce) +{ + if (!context_guc_id_invalid(ce)) { + ida_simple_remove(&guc->guc_ids, ce->guc_id); + reset_lrc_desc(guc, ce->guc_id); + set_context_guc_id_invalid(ce); + } + if (!list_empty(&ce->guc_id_link)) + list_del_init(&ce->guc_id_link); +} + +static void release_guc_id(struct intel_guc *guc, struct intel_context *ce) +{ + unsigned long flags; + + spin_lock_irqsave(&guc->contexts_lock, flags); + __release_guc_id(guc, ce); + spin_unlock_irqrestore(&guc->contexts_lock, flags); +} + +static int steal_guc_id(struct intel_guc *guc) +{ + struct intel_context *ce; + int guc_id; + + lockdep_assert_held(&guc->contexts_lock); + + if (!list_empty(&guc->guc_id_list)) { + ce = list_first_entry(&guc->guc_id_list, + struct intel_context, + guc_id_link); + + GEM_BUG_ON(atomic_read(&ce->guc_id_ref)); + GEM_BUG_ON(context_guc_id_invalid(ce)); + + list_del_init(&ce->guc_id_link); + guc_id = ce->guc_id; + clr_context_registered(ce); + set_context_guc_id_invalid(ce); + return guc_id; + } else { + return -EAGAIN; + } +} + +static int assign_guc_id(struct intel_guc *guc, u16 *out) +{ + int ret; + + lockdep_assert_held(&guc->contexts_lock); + + ret = new_guc_id(guc); + if (unlikely(ret < 0)) { + ret = steal_guc_id(guc); + if (ret < 0) + return ret; + } + + *out = ret; + return 0; +} + +#define PIN_GUC_ID_TRIES 4 +static int pin_guc_id(struct intel_guc *guc, struct intel_context *ce) +{ + int ret = 0; + unsigned long flags, tries = PIN_GUC_ID_TRIES; + + GEM_BUG_ON(atomic_read(&ce->guc_id_ref)); + +try_again: + spin_lock_irqsave(&guc->contexts_lock, flags); + + if (context_guc_id_invalid(ce)) { + ret = assign_guc_id(guc, &ce->guc_id); + if (ret) + goto out_unlock; + ret = 1; /* Indidcates newly assigned guc_id */ + } + if (!list_empty(&ce->guc_id_link)) + list_del_init(&ce->guc_id_link); + atomic_inc(&ce->guc_id_ref); + +out_unlock: + spin_unlock_irqrestore(&guc->contexts_lock, flags); + + /* + * -EAGAIN indicates no guc_ids are available, let's retire any + * outstanding requests to see if that frees up a guc_id. If the first + * retire didn't help, insert a sleep with the timeslice duration before + * attempting to retire more requests. Double the sleep period each + * subsequent pass before finally giving up. The sleep period has max of + * 100ms and minimum of 1ms. + */ + if (ret == -EAGAIN && --tries) { + if (PIN_GUC_ID_TRIES - tries > 1) { + unsigned int timeslice_shifted = + ce->engine->props.timeslice_duration_ms << + (PIN_GUC_ID_TRIES - tries - 2); + unsigned int max = min_t(unsigned int, 100, + timeslice_shifted); + + msleep(max_t(unsigned int, max, 1)); + } + intel_gt_retire_requests(guc_to_gt(guc)); + goto try_again; + } + + return ret; +} + +static void unpin_guc_id(struct intel_guc *guc, struct intel_context *ce) +{ + unsigned long flags; + + GEM_BUG_ON(atomic_read(&ce->guc_id_ref) < 0); + + spin_lock_irqsave(&guc->contexts_lock, flags); + if (!context_guc_id_invalid(ce) && list_empty(&ce->guc_id_link) && + !atomic_read(&ce->guc_id_ref)) + list_add_tail(&ce->guc_id_link, &guc->guc_id_list); + spin_unlock_irqrestore(&guc->contexts_lock, flags); +} + +static int __guc_action_register_context(struct intel_guc *guc, + u32 guc_id, + u32 offset, + bool loop) +{ + u32 action[] = { + INTEL_GUC_ACTION_REGISTER_CONTEXT, + guc_id, + offset, + }; + + return guc_submission_send_busy_loop(guc, action, ARRAY_SIZE(action), + 0, loop); +} + +static int register_context(struct intel_context *ce, bool loop) +{ + struct intel_guc *guc = ce_to_guc(ce); + u32 offset = intel_guc_ggtt_offset(guc, guc->lrc_desc_pool) + + ce->guc_id * sizeof(struct guc_lrc_desc); + int ret; + + trace_intel_context_register(ce); + + ret = __guc_action_register_context(guc, ce->guc_id, offset, loop); + set_context_registered(ce); + return ret; +} + +static int __guc_action_deregister_context(struct intel_guc *guc, + u32 guc_id, + bool loop) +{ + u32 action[] = { + INTEL_GUC_ACTION_DEREGISTER_CONTEXT, + guc_id, + }; + + return guc_submission_send_busy_loop(guc, action, ARRAY_SIZE(action), + G2H_LEN_DW_DEREGISTER_CONTEXT, + loop); +} + +static int deregister_context(struct intel_context *ce, u32 guc_id, bool loop) +{ + struct intel_guc *guc = ce_to_guc(ce); + + trace_intel_context_deregister(ce); + + return __guc_action_deregister_context(guc, guc_id, loop); +} + +static intel_engine_mask_t adjust_engine_mask(u8 class, intel_engine_mask_t mask) +{ + switch (class) { + case RENDER_CLASS: + return mask >> RCS0; + case VIDEO_ENHANCEMENT_CLASS: + return mask >> VECS0; + case VIDEO_DECODE_CLASS: + return mask >> VCS0; + case COPY_ENGINE_CLASS: + return mask >> BCS0; + default: + MISSING_CASE(class); + return 0; + } +} + +static void guc_context_policy_init(struct intel_engine_cs *engine, + struct guc_lrc_desc *desc) +{ + desc->policy_flags = 0; + + if (engine->flags & I915_ENGINE_WANT_FORCED_PREEMPTION) + desc->policy_flags |= CONTEXT_POLICY_FLAG_PREEMPT_TO_IDLE; + + /* NB: For both of these, zero means disabled. */ + desc->execution_quantum = engine->props.timeslice_duration_ms * 1000; + desc->preemption_timeout = engine->props.preempt_timeout_ms * 1000; +} + +static inline u8 map_i915_prio_to_guc_prio(int prio); + +static int guc_lrc_desc_pin(struct intel_context *ce, bool loop) +{ + struct intel_engine_cs *engine = ce->engine; + struct intel_runtime_pm *runtime_pm = engine->uncore->rpm; + struct intel_guc *guc = &engine->gt->uc.guc; + u32 desc_idx = ce->guc_id; + struct guc_lrc_desc *desc; + const struct i915_gem_context *ctx; + int prio = I915_CONTEXT_DEFAULT_PRIORITY; + bool context_registered; + intel_wakeref_t wakeref; + int ret = 0; + + GEM_BUG_ON(!engine->mask); + + /* + * Ensure LRC + CT vmas are is same region as write barrier is done + * based on CT vma region. + */ + GEM_BUG_ON(i915_gem_object_is_lmem(guc->ct.vma->obj) != + i915_gem_object_is_lmem(ce->ring->vma->obj)); + + context_registered = lrc_desc_registered(guc, desc_idx); + + rcu_read_lock(); + ctx = rcu_dereference(ce->gem_context); + if (ctx) + prio = ctx->sched.priority; + rcu_read_unlock(); + + reset_lrc_desc(guc, desc_idx); + set_lrc_desc_registered(guc, desc_idx, ce); + + desc = __get_lrc_desc(guc, desc_idx); + desc->engine_class = engine_class_to_guc_class(engine->class); + desc->engine_submit_mask = adjust_engine_mask(engine->class, + engine->mask); + desc->hw_context_desc = ce->lrc.lrca; + ce->guc_prio = map_i915_prio_to_guc_prio(prio); + desc->priority = ce->guc_prio; + desc->context_flags = CONTEXT_REGISTRATION_FLAG_KMD; + guc_context_policy_init(engine, desc); + init_sched_state(ce); + + /* + * The context_lookup xarray is used to determine if the hardware + * context is currently registered. There are two cases in which it + * could be registered either the guc_id has been stolen from from + * another context or the lrc descriptor address of this context has + * changed. In either case the context needs to be deregistered with the + * GuC before registering this context. + */ + if (context_registered) { + trace_intel_context_steal_guc_id(ce); + if (!loop) { + set_context_wait_for_deregister_to_register(ce); + intel_context_get(ce); + } else { + bool disabled; + unsigned long flags; + + /* Seal race with Reset */ + spin_lock_irqsave(&ce->guc_state.lock, flags); + disabled = submission_disabled(guc); + if (likely(!disabled)) { + set_context_wait_for_deregister_to_register(ce); + intel_context_get(ce); + } + spin_unlock_irqrestore(&ce->guc_state.lock, flags); + if (unlikely(disabled)) { + reset_lrc_desc(guc, desc_idx); + return 0; /* Will get registered later */ + } + } + + /* + * If stealing the guc_id, this ce has the same guc_id as the + * context whose guc_id was stolen. + */ + with_intel_runtime_pm(runtime_pm, wakeref) + ret = deregister_context(ce, ce->guc_id, loop); + if (unlikely(ret == -EBUSY)) { + clr_context_wait_for_deregister_to_register(ce); + intel_context_put(ce); + } else if (unlikely(ret == -ENODEV)) + ret = 0; /* Will get registered later */ + } else { + with_intel_runtime_pm(runtime_pm, wakeref) + ret = register_context(ce, loop); + if (unlikely(ret == -EBUSY)) + reset_lrc_desc(guc, desc_idx); + else if (unlikely(ret == -ENODEV)) + ret = 0; /* Will get registered later */ + } + + return ret; +} + +static int __guc_context_pre_pin(struct intel_context *ce, + struct intel_engine_cs *engine, + struct i915_gem_ww_ctx *ww, + void **vaddr) +{ + return lrc_pre_pin(ce, engine, ww, vaddr); +} + +static int __guc_context_pin(struct intel_context *ce, + struct intel_engine_cs *engine, + void *vaddr) +{ + if (i915_ggtt_offset(ce->state) != + (ce->lrc.lrca & CTX_GTT_ADDRESS_MASK)) + set_bit(CONTEXT_LRCA_DIRTY, &ce->flags); + + /* + * GuC context gets pinned in guc_request_alloc. See that function for + * explaination of why. + */ + + return lrc_pin(ce, engine, vaddr); +} + +static int guc_context_pre_pin(struct intel_context *ce, + struct i915_gem_ww_ctx *ww, + void **vaddr) +{ + return __guc_context_pre_pin(ce, ce->engine, ww, vaddr); +} + +static int guc_context_pin(struct intel_context *ce, void *vaddr) +{ + return __guc_context_pin(ce, ce->engine, vaddr); +} + +static void guc_context_unpin(struct intel_context *ce) +{ + struct intel_guc *guc = ce_to_guc(ce); + + unpin_guc_id(guc, ce); + lrc_unpin(ce); +} + +static void guc_context_post_unpin(struct intel_context *ce) +{ + lrc_post_unpin(ce); +} + +static void __guc_context_sched_enable(struct intel_guc *guc, + struct intel_context *ce) +{ + u32 action[] = { + INTEL_GUC_ACTION_SCHED_CONTEXT_MODE_SET, + ce->guc_id, + GUC_CONTEXT_ENABLE + }; + + trace_intel_context_sched_enable(ce); + + guc_submission_send_busy_loop(guc, action, ARRAY_SIZE(action), + G2H_LEN_DW_SCHED_CONTEXT_MODE_SET, true); +} + +static void __guc_context_sched_disable(struct intel_guc *guc, + struct intel_context *ce, + u16 guc_id) +{ + u32 action[] = { + INTEL_GUC_ACTION_SCHED_CONTEXT_MODE_SET, + guc_id, /* ce->guc_id not stable */ + GUC_CONTEXT_DISABLE + }; + + GEM_BUG_ON(guc_id == GUC_INVALID_LRC_ID); + + trace_intel_context_sched_disable(ce); + + guc_submission_send_busy_loop(guc, action, ARRAY_SIZE(action), + G2H_LEN_DW_SCHED_CONTEXT_MODE_SET, true); +} + +static void guc_blocked_fence_complete(struct intel_context *ce) +{ + lockdep_assert_held(&ce->guc_state.lock); + + if (!i915_sw_fence_done(&ce->guc_blocked)) + i915_sw_fence_complete(&ce->guc_blocked); +} + +static void guc_blocked_fence_reinit(struct intel_context *ce) +{ + lockdep_assert_held(&ce->guc_state.lock); + GEM_BUG_ON(!i915_sw_fence_done(&ce->guc_blocked)); + i915_sw_fence_fini(&ce->guc_blocked); + i915_sw_fence_reinit(&ce->guc_blocked); + i915_sw_fence_await(&ce->guc_blocked); + i915_sw_fence_commit(&ce->guc_blocked); +} + +static u16 prep_context_pending_disable(struct intel_context *ce) +{ + lockdep_assert_held(&ce->guc_state.lock); + + set_context_pending_disable(ce); + clr_context_enabled(ce); + guc_blocked_fence_reinit(ce); + intel_context_get(ce); + + return ce->guc_id; +} + +static struct i915_sw_fence *guc_context_block(struct intel_context *ce) +{ + struct intel_guc *guc = ce_to_guc(ce); + struct i915_sched_engine *sched_engine = ce->engine->sched_engine; + unsigned long flags; + struct intel_runtime_pm *runtime_pm = &ce->engine->gt->i915->runtime_pm; + intel_wakeref_t wakeref; + u16 guc_id; + bool enabled; + + spin_lock_irqsave(&sched_engine->lock, flags); + incr_context_blocked(ce); + spin_unlock_irqrestore(&sched_engine->lock, flags); + + spin_lock_irqsave(&ce->guc_state.lock, flags); + enabled = context_enabled(ce); + if (unlikely(!enabled || submission_disabled(guc))) { + if (enabled) + clr_context_enabled(ce); + spin_unlock_irqrestore(&ce->guc_state.lock, flags); + return &ce->guc_blocked; + } + + /* + * We add +2 here as the schedule disable complete CTB handler calls + * intel_context_sched_disable_unpin (-2 to pin_count). + */ + atomic_add(2, &ce->pin_count); + + guc_id = prep_context_pending_disable(ce); + spin_unlock_irqrestore(&ce->guc_state.lock, flags); + + with_intel_runtime_pm(runtime_pm, wakeref) + __guc_context_sched_disable(guc, ce, guc_id); + + return &ce->guc_blocked; +} + +static void guc_context_unblock(struct intel_context *ce) +{ + struct intel_guc *guc = ce_to_guc(ce); + struct i915_sched_engine *sched_engine = ce->engine->sched_engine; + unsigned long flags; + struct intel_runtime_pm *runtime_pm = &ce->engine->gt->i915->runtime_pm; + intel_wakeref_t wakeref; + + GEM_BUG_ON(context_enabled(ce)); + + if (unlikely(context_blocked(ce) > 1)) { + spin_lock_irqsave(&sched_engine->lock, flags); + if (likely(context_blocked(ce) > 1)) + goto decrement; + spin_unlock_irqrestore(&sched_engine->lock, flags); + } + + spin_lock_irqsave(&ce->guc_state.lock, flags); + if (unlikely(submission_disabled(guc) || + !intel_context_is_pinned(ce) || + context_pending_disable(ce) || + context_blocked(ce) > 1)) { + spin_unlock_irqrestore(&ce->guc_state.lock, flags); + goto out; + } + + set_context_pending_enable(ce); + set_context_enabled(ce); + intel_context_get(ce); + spin_unlock_irqrestore(&ce->guc_state.lock, flags); + + with_intel_runtime_pm(runtime_pm, wakeref) + __guc_context_sched_enable(guc, ce); + +out: + spin_lock_irqsave(&sched_engine->lock, flags); +decrement: + decr_context_blocked(ce); + spin_unlock_irqrestore(&sched_engine->lock, flags); +} + +static void guc_context_cancel_request(struct intel_context *ce, + struct i915_request *rq) +{ + if (i915_sw_fence_signaled(&rq->submit)) { + struct i915_sw_fence *fence = guc_context_block(ce); + + i915_sw_fence_wait(fence); + if (!i915_request_completed(rq)) { + __i915_request_skip(rq); + guc_reset_state(ce, intel_ring_wrap(ce->ring, rq->head), + true); + } + guc_context_unblock(ce); + } +} + +static void __guc_context_set_preemption_timeout(struct intel_guc *guc, + u16 guc_id, + u32 preemption_timeout) +{ + u32 action [] = { + INTEL_GUC_ACTION_SET_CONTEXT_PREEMPTION_TIMEOUT, + guc_id, + preemption_timeout + }; + + intel_guc_send_busy_loop(guc, action, ARRAY_SIZE(action), 0, true); +} + +static void guc_context_ban(struct intel_context *ce, struct i915_request *rq) +{ + struct intel_guc *guc = ce_to_guc(ce); + struct intel_runtime_pm *runtime_pm = + &ce->engine->gt->i915->runtime_pm; + intel_wakeref_t wakeref; + unsigned long flags; + + guc_flush_submissions(guc); + + spin_lock_irqsave(&ce->guc_state.lock, flags); + set_context_banned(ce); + + if (submission_disabled(guc) || (!context_enabled(ce) && + !context_pending_disable(ce))) { + spin_unlock_irqrestore(&ce->guc_state.lock, flags); + + guc_cancel_context_requests(ce); + intel_engine_signal_breadcrumbs(ce->engine); + } else if (!context_pending_disable(ce)) { + u16 guc_id; + + /* + * We add +2 here as the schedule disable complete CTB handler + * calls intel_context_sched_disable_unpin (-2 to pin_count). + */ + atomic_add(2, &ce->pin_count); + + guc_id = prep_context_pending_disable(ce); + spin_unlock_irqrestore(&ce->guc_state.lock, flags); + + /* + * In addition to disabling scheduling, set the preemption + * timeout to the minimum value (1 us) so the banned context + * gets kicked off the HW ASAP. + */ + with_intel_runtime_pm(runtime_pm, wakeref) { + __guc_context_set_preemption_timeout(guc, guc_id, 1); + __guc_context_sched_disable(guc, ce, guc_id); + } + } else { + if (!context_guc_id_invalid(ce)) + with_intel_runtime_pm(runtime_pm, wakeref) + __guc_context_set_preemption_timeout(guc, + ce->guc_id, + 1); + spin_unlock_irqrestore(&ce->guc_state.lock, flags); + } +} + +static void guc_context_sched_disable(struct intel_context *ce) +{ + struct intel_guc *guc = ce_to_guc(ce); + unsigned long flags; + struct intel_runtime_pm *runtime_pm = &ce->engine->gt->i915->runtime_pm; + intel_wakeref_t wakeref; + u16 guc_id; + bool enabled; + + if (submission_disabled(guc) || context_guc_id_invalid(ce) || + !lrc_desc_registered(guc, ce->guc_id)) { + clr_context_enabled(ce); + goto unpin; + } + + if (!context_enabled(ce)) + goto unpin; + + spin_lock_irqsave(&ce->guc_state.lock, flags); + + /* + * We have to check if the context has been disabled by another thread. + * We also have to check if the context has been pinned again as another + * pin operation is allowed to pass this function. Checking the pin + * count, within ce->guc_state.lock, synchronizes this function with + * guc_request_alloc ensuring a request doesn't slip through the + * 'context_pending_disable' fence. Checking within the spin lock (can't + * sleep) ensures another process doesn't pin this context and generate + * a request before we set the 'context_pending_disable' flag here. + */ + enabled = context_enabled(ce); + if (unlikely(!enabled || submission_disabled(guc))) { + if (enabled) + clr_context_enabled(ce); + spin_unlock_irqrestore(&ce->guc_state.lock, flags); + goto unpin; + } + if (unlikely(atomic_add_unless(&ce->pin_count, -2, 2))) { + spin_unlock_irqrestore(&ce->guc_state.lock, flags); + return; + } + guc_id = prep_context_pending_disable(ce); + + spin_unlock_irqrestore(&ce->guc_state.lock, flags); + + with_intel_runtime_pm(runtime_pm, wakeref) + __guc_context_sched_disable(guc, ce, guc_id); + + return; +unpin: + intel_context_sched_disable_unpin(ce); +} + +static inline void guc_lrc_desc_unpin(struct intel_context *ce) +{ + struct intel_guc *guc = ce_to_guc(ce); + + GEM_BUG_ON(!lrc_desc_registered(guc, ce->guc_id)); + GEM_BUG_ON(ce != __get_context(guc, ce->guc_id)); + GEM_BUG_ON(context_enabled(ce)); + + clr_context_registered(ce); + deregister_context(ce, ce->guc_id, true); +} + +static void __guc_context_destroy(struct intel_context *ce) +{ + GEM_BUG_ON(ce->guc_prio_count[GUC_CLIENT_PRIORITY_KMD_HIGH] || + ce->guc_prio_count[GUC_CLIENT_PRIORITY_HIGH] || + ce->guc_prio_count[GUC_CLIENT_PRIORITY_KMD_NORMAL] || + ce->guc_prio_count[GUC_CLIENT_PRIORITY_NORMAL]); + + lrc_fini(ce); + intel_context_fini(ce); + + if (intel_engine_is_virtual(ce->engine)) { + struct guc_virtual_engine *ve = + container_of(ce, typeof(*ve), context); + + if (ve->base.breadcrumbs) + intel_breadcrumbs_put(ve->base.breadcrumbs); + + kfree(ve); + } else { + intel_context_free(ce); + } +} + +static void guc_context_destroy(struct kref *kref) +{ + struct intel_context *ce = container_of(kref, typeof(*ce), ref); + struct intel_runtime_pm *runtime_pm = ce->engine->uncore->rpm; + struct intel_guc *guc = ce_to_guc(ce); + intel_wakeref_t wakeref; + unsigned long flags; + bool disabled; + + /* + * If the guc_id is invalid this context has been stolen and we can free + * it immediately. Also can be freed immediately if the context is not + * registered with the GuC or the GuC is in the middle of a reset. + */ + if (context_guc_id_invalid(ce)) { + __guc_context_destroy(ce); + return; + } else if (submission_disabled(guc) || + !lrc_desc_registered(guc, ce->guc_id)) { + release_guc_id(guc, ce); + __guc_context_destroy(ce); + return; + } + + /* + * We have to acquire the context spinlock and check guc_id again, if it + * is valid it hasn't been stolen and needs to be deregistered. We + * delete this context from the list of unpinned guc_ids available to + * steal to seal a race with guc_lrc_desc_pin(). When the G2H CTB + * returns indicating this context has been deregistered the guc_id is + * returned to the pool of available guc_ids. + */ + spin_lock_irqsave(&guc->contexts_lock, flags); + if (context_guc_id_invalid(ce)) { + spin_unlock_irqrestore(&guc->contexts_lock, flags); + __guc_context_destroy(ce); + return; + } + + if (!list_empty(&ce->guc_id_link)) + list_del_init(&ce->guc_id_link); + spin_unlock_irqrestore(&guc->contexts_lock, flags); + + /* Seal race with Reset */ + spin_lock_irqsave(&ce->guc_state.lock, flags); + disabled = submission_disabled(guc); + if (likely(!disabled)) + set_context_destroyed(ce); + spin_unlock_irqrestore(&ce->guc_state.lock, flags); + if (unlikely(disabled)) { + release_guc_id(guc, ce); + __guc_context_destroy(ce); + return; + } + + /* + * We defer GuC context deregistration until the context is destroyed + * in order to save on CTBs. With this optimization ideally we only need + * 1 CTB to register the context during the first pin and 1 CTB to + * deregister the context when the context is destroyed. Without this + * optimization, a CTB would be needed every pin & unpin. + * + * XXX: Need to acqiure the runtime wakeref as this can be triggered + * from context_free_worker when runtime wakeref is not held. + * guc_lrc_desc_unpin requires the runtime as a GuC register is written + * in H2G CTB to deregister the context. A future patch may defer this + * H2G CTB if the runtime wakeref is zero. + */ + with_intel_runtime_pm(runtime_pm, wakeref) + guc_lrc_desc_unpin(ce); +} + +static int guc_context_alloc(struct intel_context *ce) +{ + return lrc_alloc(ce, ce->engine); +} + +static void guc_context_set_prio(struct intel_guc *guc, + struct intel_context *ce, + u8 prio) +{ + u32 action[] = { + INTEL_GUC_ACTION_SET_CONTEXT_PRIORITY, + ce->guc_id, + prio, + }; + + GEM_BUG_ON(prio < GUC_CLIENT_PRIORITY_KMD_HIGH || + prio > GUC_CLIENT_PRIORITY_NORMAL); + + if (ce->guc_prio == prio || submission_disabled(guc) || + !context_registered(ce)) + return; + + guc_submission_send_busy_loop(guc, action, ARRAY_SIZE(action), 0, true); + + ce->guc_prio = prio; + trace_intel_context_set_prio(ce); +} + +static inline u8 map_i915_prio_to_guc_prio(int prio) +{ + if (prio == I915_PRIORITY_NORMAL) + return GUC_CLIENT_PRIORITY_KMD_NORMAL; + else if (prio < I915_PRIORITY_NORMAL) + return GUC_CLIENT_PRIORITY_NORMAL; + else if (prio != I915_PRIORITY_BARRIER) + return GUC_CLIENT_PRIORITY_HIGH; + else + return GUC_CLIENT_PRIORITY_KMD_HIGH; +} + +static inline void add_context_inflight_prio(struct intel_context *ce, + u8 guc_prio) +{ + lockdep_assert_held(&ce->guc_active.lock); + GEM_BUG_ON(guc_prio >= ARRAY_SIZE(ce->guc_prio_count)); + + ++ce->guc_prio_count[guc_prio]; + + /* Overflow protection */ + GEM_WARN_ON(!ce->guc_prio_count[guc_prio]); +} + +static inline void sub_context_inflight_prio(struct intel_context *ce, + u8 guc_prio) +{ + lockdep_assert_held(&ce->guc_active.lock); + GEM_BUG_ON(guc_prio >= ARRAY_SIZE(ce->guc_prio_count)); + + /* Underflow protection */ + GEM_WARN_ON(!ce->guc_prio_count[guc_prio]); + + --ce->guc_prio_count[guc_prio]; +} + +static inline void update_context_prio(struct intel_context *ce) +{ + struct intel_guc *guc = &ce->engine->gt->uc.guc; + int i; + + lockdep_assert_held(&ce->guc_active.lock); + + for (i = 0; i < ARRAY_SIZE(ce->guc_prio_count); ++i) { + if (ce->guc_prio_count[i]) { + guc_context_set_prio(guc, ce, i); + break; + } + } +} + +static inline bool new_guc_prio_higher(u8 old_guc_prio, u8 new_guc_prio) +{ + /* Lower value is higher priority */ + return new_guc_prio < old_guc_prio; +} + +static void add_to_context(struct i915_request *rq) +{ + struct intel_context *ce = rq->context; + u8 new_guc_prio = map_i915_prio_to_guc_prio(rq_prio(rq)); + + GEM_BUG_ON(rq->guc_prio == GUC_PRIO_FINI); + + spin_lock(&ce->guc_active.lock); + list_move_tail(&rq->sched.link, &ce->guc_active.requests); + + if (rq->guc_prio == GUC_PRIO_INIT) { + rq->guc_prio = new_guc_prio; + add_context_inflight_prio(ce, rq->guc_prio); + } else if (new_guc_prio_higher(rq->guc_prio, new_guc_prio)) { + sub_context_inflight_prio(ce, rq->guc_prio); + rq->guc_prio = new_guc_prio; + add_context_inflight_prio(ce, rq->guc_prio); + } + update_context_prio(ce); + + spin_unlock(&ce->guc_active.lock); +} + +static void guc_prio_fini(struct i915_request *rq, struct intel_context *ce) +{ + if (rq->guc_prio != GUC_PRIO_INIT && + rq->guc_prio != GUC_PRIO_FINI) { + sub_context_inflight_prio(ce, rq->guc_prio); + update_context_prio(ce); + } + rq->guc_prio = GUC_PRIO_FINI; +} + +static void remove_from_context(struct i915_request *rq) +{ + struct intel_context *ce = rq->context; + + spin_lock_irq(&ce->guc_active.lock); + + list_del_init(&rq->sched.link); + clear_bit(I915_FENCE_FLAG_PQUEUE, &rq->fence.flags); + + /* Prevent further __await_execution() registering a cb, then flush */ + set_bit(I915_FENCE_FLAG_ACTIVE, &rq->fence.flags); + + guc_prio_fini(rq, ce); + + spin_unlock_irq(&ce->guc_active.lock); + + atomic_dec(&ce->guc_id_ref); + i915_request_notify_execute_cb_imm(rq); +} + +static const struct intel_context_ops guc_context_ops = { + .alloc = guc_context_alloc, + + .pre_pin = guc_context_pre_pin, + .pin = guc_context_pin, + .unpin = guc_context_unpin, + .post_unpin = guc_context_post_unpin, + + .ban = guc_context_ban, + + .cancel_request = guc_context_cancel_request, + + .enter = intel_context_enter_engine, + .exit = intel_context_exit_engine, + + .sched_disable = guc_context_sched_disable, + + .reset = lrc_reset, + .destroy = guc_context_destroy, + + .create_virtual = guc_create_virtual, +}; + +static void __guc_signal_context_fence(struct intel_context *ce) +{ + struct i915_request *rq; + + lockdep_assert_held(&ce->guc_state.lock); + + if (!list_empty(&ce->guc_state.fences)) + trace_intel_context_fence_release(ce); + + list_for_each_entry(rq, &ce->guc_state.fences, guc_fence_link) + i915_sw_fence_complete(&rq->submit); + + INIT_LIST_HEAD(&ce->guc_state.fences); +} + +static void guc_signal_context_fence(struct intel_context *ce) +{ + unsigned long flags; + + spin_lock_irqsave(&ce->guc_state.lock, flags); + clr_context_wait_for_deregister_to_register(ce); + __guc_signal_context_fence(ce); + spin_unlock_irqrestore(&ce->guc_state.lock, flags); +} + +static bool context_needs_register(struct intel_context *ce, bool new_guc_id) +{ + return (new_guc_id || test_bit(CONTEXT_LRCA_DIRTY, &ce->flags) || + !lrc_desc_registered(ce_to_guc(ce), ce->guc_id)) && + !submission_disabled(ce_to_guc(ce)); +} + +static int guc_request_alloc(struct i915_request *rq) +{ + struct intel_context *ce = rq->context; + struct intel_guc *guc = ce_to_guc(ce); + unsigned long flags; + int ret; + + GEM_BUG_ON(!intel_context_is_pinned(rq->context)); + + /* + * Flush enough space to reduce the likelihood of waiting after + * we start building the request - in which case we will just + * have to repeat work. + */ + rq->reserved_space += GUC_REQUEST_SIZE; + + /* + * Note that after this point, we have committed to using + * this request as it is being used to both track the + * state of engine initialisation and liveness of the + * golden renderstate above. Think twice before you try + * to cancel/unwind this request now. + */ + + /* Unconditionally invalidate GPU caches and TLBs. */ + ret = rq->engine->emit_flush(rq, EMIT_INVALIDATE); + if (ret) + return ret; + + rq->reserved_space -= GUC_REQUEST_SIZE; + + /* + * Call pin_guc_id here rather than in the pinning step as with + * dma_resv, contexts can be repeatedly pinned / unpinned trashing the + * guc_ids and creating horrible race conditions. This is especially bad + * when guc_ids are being stolen due to over subscription. By the time + * this function is reached, it is guaranteed that the guc_id will be + * persistent until the generated request is retired. Thus, sealing these + * race conditions. It is still safe to fail here if guc_ids are + * exhausted and return -EAGAIN to the user indicating that they can try + * again in the future. + * + * There is no need for a lock here as the timeline mutex ensures at + * most one context can be executing this code path at once. The + * guc_id_ref is incremented once for every request in flight and + * decremented on each retire. When it is zero, a lock around the + * increment (in pin_guc_id) is needed to seal a race with unpin_guc_id. + */ + if (atomic_add_unless(&ce->guc_id_ref, 1, 0)) + goto out; + + ret = pin_guc_id(guc, ce); /* returns 1 if new guc_id assigned */ + if (unlikely(ret < 0)) + return ret; + if (context_needs_register(ce, !!ret)) { + ret = guc_lrc_desc_pin(ce, true); + if (unlikely(ret)) { /* unwind */ + if (ret == -EPIPE) { + disable_submission(guc); + goto out; /* GPU will be reset */ + } + atomic_dec(&ce->guc_id_ref); + unpin_guc_id(guc, ce); + return ret; + } + } + + clear_bit(CONTEXT_LRCA_DIRTY, &ce->flags); + +out: + /* + * We block all requests on this context if a G2H is pending for a + * schedule disable or context deregistration as the GuC will fail a + * schedule enable or context registration if either G2H is pending + * respectfully. Once a G2H returns, the fence is released that is + * blocking these requests (see guc_signal_context_fence). + * + * We can safely check the below fields outside of the lock as it isn't + * possible for these fields to transition from being clear to set but + * converse is possible, hence the need for the check within the lock. + */ + if (likely(!context_wait_for_deregister_to_register(ce) && + !context_pending_disable(ce))) + return 0; + + spin_lock_irqsave(&ce->guc_state.lock, flags); + if (context_wait_for_deregister_to_register(ce) || + context_pending_disable(ce)) { + i915_sw_fence_await(&rq->submit); + + list_add_tail(&rq->guc_fence_link, &ce->guc_state.fences); + } + spin_unlock_irqrestore(&ce->guc_state.lock, flags); + + return 0; } -static void guc_reset_finish(struct intel_engine_cs *engine) +static int guc_virtual_context_pre_pin(struct intel_context *ce, + struct i915_gem_ww_ctx *ww, + void **vaddr) { - if (__tasklet_enable(&engine->sched_engine->tasklet)) - /* And kick in case we missed a new request submission. */ - tasklet_hi_schedule(&engine->sched_engine->tasklet); + struct intel_engine_cs *engine = guc_virtual_get_sibling(ce->engine, 0); - ENGINE_TRACE(engine, "depth->%d\n", - atomic_read(&engine->sched_engine->tasklet.count)); + return __guc_context_pre_pin(ce, engine, ww, vaddr); } -/* - * Set up the memory resources to be shared with the GuC (via the GGTT) - * at firmware loading time. - */ -int intel_guc_submission_init(struct intel_guc *guc) +static int guc_virtual_context_pin(struct intel_context *ce, void *vaddr) { - int ret; - - if (guc->stage_desc_pool) - return 0; - - ret = guc_stage_desc_pool_create(guc); - if (ret) - return ret; - /* - * Keep static analysers happy, let them know that we allocated the - * vma after testing that it didn't exist earlier. - */ - GEM_BUG_ON(!guc->stage_desc_pool); + struct intel_engine_cs *engine = guc_virtual_get_sibling(ce->engine, 0); - return 0; + return __guc_context_pin(ce, engine, vaddr); } -void intel_guc_submission_fini(struct intel_guc *guc) +static void guc_virtual_context_enter(struct intel_context *ce) { - if (guc->stage_desc_pool) { - guc_stage_desc_pool_destroy(guc); - } -} + intel_engine_mask_t tmp, mask = ce->engine->mask; + struct intel_engine_cs *engine; -static int guc_context_alloc(struct intel_context *ce) -{ - return lrc_alloc(ce, ce->engine); + for_each_engine_masked(engine, ce->engine->gt, mask, tmp) + intel_engine_pm_get(engine); + + intel_timeline_enter(ce->timeline); } -static int guc_context_pre_pin(struct intel_context *ce, - struct i915_gem_ww_ctx *ww, - void **vaddr) +static void guc_virtual_context_exit(struct intel_context *ce) { - return lrc_pre_pin(ce, ce->engine, ww, vaddr); + intel_engine_mask_t tmp, mask = ce->engine->mask; + struct intel_engine_cs *engine; + + for_each_engine_masked(engine, ce->engine->gt, mask, tmp) + intel_engine_pm_put(engine); + + intel_timeline_exit(ce->timeline); } -static int guc_context_pin(struct intel_context *ce, void *vaddr) +static int guc_virtual_context_alloc(struct intel_context *ce) { - return lrc_pin(ce, ce->engine, vaddr); + struct intel_engine_cs *engine = guc_virtual_get_sibling(ce->engine, 0); + + return lrc_alloc(ce, engine); } -static const struct intel_context_ops guc_context_ops = { - .alloc = guc_context_alloc, +static const struct intel_context_ops virtual_guc_context_ops = { + .alloc = guc_virtual_context_alloc, - .pre_pin = guc_context_pre_pin, - .pin = guc_context_pin, - .unpin = lrc_unpin, - .post_unpin = lrc_post_unpin, + .pre_pin = guc_virtual_context_pre_pin, + .pin = guc_virtual_context_pin, + .unpin = guc_context_unpin, + .post_unpin = guc_context_post_unpin, - .enter = intel_context_enter_engine, - .exit = intel_context_exit_engine, + .ban = guc_context_ban, - .reset = lrc_reset, - .destroy = lrc_destroy, -}; + .cancel_request = guc_context_cancel_request, -static int guc_request_alloc(struct i915_request *request) -{ - int ret; + .enter = guc_virtual_context_enter, + .exit = guc_virtual_context_exit, - GEM_BUG_ON(!intel_context_is_pinned(request->context)); + .sched_disable = guc_context_sched_disable, - /* - * Flush enough space to reduce the likelihood of waiting after - * we start building the request - in which case we will just - * have to repeat work. - */ - request->reserved_space += GUC_REQUEST_SIZE; + .destroy = guc_context_destroy, - /* - * Note that after this point, we have committed to using - * this request as it is being used to both track the - * state of engine initialisation and liveness of the - * golden renderstate above. Think twice before you try - * to cancel/unwind this request now. - */ + .get_sibling = guc_virtual_get_sibling, +}; - /* Unconditionally invalidate GPU caches and TLBs. */ - ret = request->engine->emit_flush(request, EMIT_INVALIDATE); - if (ret) - return ret; +static bool +guc_irq_enable_breadcrumbs(struct intel_breadcrumbs *b) +{ + struct intel_engine_cs *sibling; + intel_engine_mask_t tmp, mask = b->engine_mask; + bool result = false; - request->reserved_space -= GUC_REQUEST_SIZE; - return 0; + for_each_engine_masked(sibling, b->irq_engine->gt, mask, tmp) + result |= intel_engine_irq_enable(sibling); + + return result; } -static inline void queue_request(struct intel_engine_cs *engine, - struct i915_request *rq, - int prio) +static void +guc_irq_disable_breadcrumbs(struct intel_breadcrumbs *b) { - GEM_BUG_ON(!list_empty(&rq->sched.link)); - list_add_tail(&rq->sched.link, - i915_sched_lookup_priolist(engine->sched_engine, prio)); - set_bit(I915_FENCE_FLAG_PQUEUE, &rq->fence.flags); + struct intel_engine_cs *sibling; + intel_engine_mask_t tmp, mask = b->engine_mask; + + for_each_engine_masked(sibling, b->irq_engine->gt, mask, tmp) + intel_engine_irq_disable(sibling); } -static void guc_submit_request(struct i915_request *rq) +static void guc_init_breadcrumbs(struct intel_engine_cs *engine) { - struct intel_engine_cs *engine = rq->engine; - unsigned long flags; - - /* Will be called from irq-context when using foreign fences. */ - spin_lock_irqsave(&engine->sched_engine->lock, flags); + int i; + + /* + * In GuC submission mode we do not know which physical engine a request + * will be scheduled on, this creates a problem because the breadcrumb + * interrupt is per physical engine. To work around this we attach + * requests and direct all breadcrumb interrupts to the first instance + * of an engine per class. In addition all breadcrumb interrupts are + * enabled / disabled across an engine class in unison. + */ + for (i = 0; i < MAX_ENGINE_INSTANCE; ++i) { + struct intel_engine_cs *sibling = + engine->gt->engine_class[engine->class][i]; + + if (sibling) { + if (engine->breadcrumbs != sibling->breadcrumbs) { + intel_breadcrumbs_put(engine->breadcrumbs); + engine->breadcrumbs = + intel_breadcrumbs_get(sibling->breadcrumbs); + } + break; + } + } - queue_request(engine, rq, rq_prio(rq)); + if (engine->breadcrumbs) { + engine->breadcrumbs->engine_mask |= engine->mask; + engine->breadcrumbs->irq_enable = guc_irq_enable_breadcrumbs; + engine->breadcrumbs->irq_disable = guc_irq_disable_breadcrumbs; + } +} - GEM_BUG_ON(i915_sched_engine_is_empty(engine->sched_engine)); - GEM_BUG_ON(list_empty(&rq->sched.link)); +static void guc_bump_inflight_request_prio(struct i915_request *rq, + int prio) +{ + struct intel_context *ce = rq->context; + u8 new_guc_prio = map_i915_prio_to_guc_prio(prio); + + /* Short circuit function */ + if (prio < I915_PRIORITY_NORMAL || + (rq->guc_prio == GUC_PRIO_FINI) || + (rq->guc_prio != GUC_PRIO_INIT && + !new_guc_prio_higher(rq->guc_prio, new_guc_prio))) + return; + + spin_lock(&ce->guc_active.lock); + if (rq->guc_prio != GUC_PRIO_FINI) { + if (rq->guc_prio != GUC_PRIO_INIT) + sub_context_inflight_prio(ce, rq->guc_prio); + rq->guc_prio = new_guc_prio; + add_context_inflight_prio(ce, rq->guc_prio); + update_context_prio(ce); + } + spin_unlock(&ce->guc_active.lock); +} - tasklet_hi_schedule(&engine->sched_engine->tasklet); +static void guc_retire_inflight_request_prio(struct i915_request *rq) +{ + struct intel_context *ce = rq->context; - spin_unlock_irqrestore(&engine->sched_engine->lock, flags); + spin_lock(&ce->guc_active.lock); + guc_prio_fini(rq, ce); + spin_unlock(&ce->guc_active.lock); } static void sanitize_hwsp(struct intel_engine_cs *engine) @@ -588,21 +2312,68 @@ static int guc_resume(struct intel_engine_cs *engine) return 0; } +static bool guc_sched_engine_disabled(struct i915_sched_engine *sched_engine) +{ + return !sched_engine->tasklet.callback; +} + static void guc_set_default_submission(struct intel_engine_cs *engine) { engine->submit_request = guc_submit_request; } +static inline void guc_kernel_context_pin(struct intel_guc *guc, + struct intel_context *ce) +{ + if (context_guc_id_invalid(ce)) + pin_guc_id(guc, ce); + guc_lrc_desc_pin(ce, true); +} + +static inline void guc_init_lrc_mapping(struct intel_guc *guc) +{ + struct intel_gt *gt = guc_to_gt(guc); + struct intel_engine_cs *engine; + enum intel_engine_id id; + + /* make sure all descriptors are clean... */ + xa_destroy(&guc->context_lookup); + + /* + * Some contexts might have been pinned before we enabled GuC + * submission, so we need to add them to the GuC bookeeping. + * Also, after a reset the of GuC we want to make sure that the + * information shared with GuC is properly reset. The kernel LRCs are + * not attached to the gem_context, so they need to be added separately. + * + * Note: we purposely do not check the return of guc_lrc_desc_pin, + * because that function can only fail if a reset is just starting. This + * is at the end of reset so presumably another reset isn't happening + * and even it did this code would be run again. + */ + + for_each_engine(engine, gt, id) + if (engine->kernel_context) + guc_kernel_context_pin(guc, engine->kernel_context); +} + static void guc_release(struct intel_engine_cs *engine) { engine->sanitize = NULL; /* no longer in control, nothing to sanitize */ - tasklet_kill(&engine->sched_engine->tasklet); - intel_engine_cleanup_common(engine); lrc_fini_wa_ctx(engine); } +static void virtual_guc_bump_serial(struct intel_engine_cs *engine) +{ + struct intel_engine_cs *e; + intel_engine_mask_t tmp, mask = engine->mask; + + for_each_engine_masked(e, engine->gt, mask, tmp) + e->serial++; +} + static void guc_default_vfuncs(struct intel_engine_cs *engine) { /* Default vfuncs which can be overridden by each engine. */ @@ -611,13 +2382,15 @@ static void guc_default_vfuncs(struct intel_engine_cs *engine) engine->cops = &guc_context_ops; engine->request_alloc = guc_request_alloc; + engine->add_active_request = add_to_context; + engine->remove_active_request = remove_from_context; engine->sched_engine->schedule = i915_schedule; - engine->reset.prepare = guc_reset_prepare; - engine->reset.rewind = guc_reset_rewind; - engine->reset.cancel = guc_reset_cancel; - engine->reset.finish = guc_reset_finish; + engine->reset.prepare = guc_reset_nop; + engine->reset.rewind = guc_rewind_nop; + engine->reset.cancel = guc_reset_nop; + engine->reset.finish = guc_reset_nop; engine->emit_flush = gen8_emit_flush_xcs; engine->emit_init_breadcrumb = gen8_emit_init_breadcrumb; @@ -629,13 +2402,13 @@ static void guc_default_vfuncs(struct intel_engine_cs *engine) engine->set_default_submission = guc_set_default_submission; engine->flags |= I915_ENGINE_HAS_PREEMPTION; + engine->flags |= I915_ENGINE_HAS_TIMESLICES; /* * TODO: GuC supports timeslicing and semaphores as well, but they're * handled by the firmware so some minor tweaks are required before * enabling. * - * engine->flags |= I915_ENGINE_HAS_TIMESLICES; * engine->flags |= I915_ENGINE_HAS_SEMAPHORES; */ @@ -666,9 +2439,21 @@ static inline void guc_default_irqs(struct intel_engine_cs *engine) intel_engine_set_irq_handler(engine, cs_irq_handler); } +static void guc_sched_engine_destroy(struct kref *kref) +{ + struct i915_sched_engine *sched_engine = + container_of(kref, typeof(*sched_engine), ref); + struct intel_guc *guc = sched_engine->private_data; + + guc->sched_engine = NULL; + tasklet_kill(&sched_engine->tasklet); /* flush the callback */ + kfree(sched_engine); +} + int intel_guc_submission_setup(struct intel_engine_cs *engine) { struct drm_i915_private *i915 = engine->i915; + struct intel_guc *guc = &engine->gt->uc.guc; /* * The setup relies on several assumptions (e.g. irqs always enabled) @@ -676,10 +2461,28 @@ int intel_guc_submission_setup(struct intel_engine_cs *engine) */ GEM_BUG_ON(GRAPHICS_VER(i915) < 11); - tasklet_setup(&engine->sched_engine->tasklet, guc_submission_tasklet); + if (!guc->sched_engine) { + guc->sched_engine = i915_sched_engine_create(ENGINE_VIRTUAL); + if (!guc->sched_engine) + return -ENOMEM; + + guc->sched_engine->schedule = i915_schedule; + guc->sched_engine->disabled = guc_sched_engine_disabled; + guc->sched_engine->private_data = guc; + guc->sched_engine->destroy = guc_sched_engine_destroy; + guc->sched_engine->bump_inflight_request_prio = + guc_bump_inflight_request_prio; + guc->sched_engine->retire_inflight_request_prio = + guc_retire_inflight_request_prio; + tasklet_setup(&guc->sched_engine->tasklet, + guc_submission_tasklet); + } + i915_sched_engine_put(engine->sched_engine); + engine->sched_engine = i915_sched_engine_get(guc->sched_engine); guc_default_vfuncs(engine); guc_default_irqs(engine); + guc_init_breadcrumbs(engine); if (engine->class == RENDER_CLASS) rcs_submission_override(engine); @@ -695,7 +2498,7 @@ int intel_guc_submission_setup(struct intel_engine_cs *engine) void intel_guc_submission_enable(struct intel_guc *guc) { - guc_stage_desc_init(guc); + guc_init_lrc_mapping(guc); } void intel_guc_submission_disable(struct intel_guc *guc) @@ -705,8 +2508,13 @@ void intel_guc_submission_disable(struct intel_guc *guc) GEM_BUG_ON(gt->awake); /* GT should be parked first */ /* Note: By the time we're here, GuC may have already been reset */ +} - guc_stage_desc_fini(guc); +static bool __guc_submission_supported(struct intel_guc *guc) +{ + /* GuC submission is unavailable for pre-Gen11 */ + return intel_guc_is_supported(guc) && + GRAPHICS_VER(guc_to_gt(guc)->i915) >= 11; } static bool __guc_submission_selected(struct intel_guc *guc) @@ -721,5 +2529,483 @@ static bool __guc_submission_selected(struct intel_guc *guc) void intel_guc_submission_init_early(struct intel_guc *guc) { + guc->submission_supported = __guc_submission_supported(guc); guc->submission_selected = __guc_submission_selected(guc); } + +static inline struct intel_context * +g2h_context_lookup(struct intel_guc *guc, u32 desc_idx) +{ + struct intel_context *ce; + + if (unlikely(desc_idx >= GUC_MAX_LRC_DESCRIPTORS)) { + drm_err(&guc_to_gt(guc)->i915->drm, + "Invalid desc_idx %u", desc_idx); + return NULL; + } + + ce = __get_context(guc, desc_idx); + if (unlikely(!ce)) { + drm_err(&guc_to_gt(guc)->i915->drm, + "Context is NULL, desc_idx %u", desc_idx); + return NULL; + } + + return ce; +} + +static void decr_outstanding_submission_g2h(struct intel_guc *guc) +{ + if (atomic_dec_and_test(&guc->outstanding_submission_g2h)) + wake_up_all(&guc->ct.wq); +} + +int intel_guc_deregister_done_process_msg(struct intel_guc *guc, + const u32 *msg, + u32 len) +{ + struct intel_context *ce; + u32 desc_idx = msg[0]; + + if (unlikely(len < 1)) { + drm_err(&guc_to_gt(guc)->i915->drm, "Invalid length %u", len); + return -EPROTO; + } + + ce = g2h_context_lookup(guc, desc_idx); + if (unlikely(!ce)) + return -EPROTO; + + trace_intel_context_deregister_done(ce); + + if (context_wait_for_deregister_to_register(ce)) { + struct intel_runtime_pm *runtime_pm = + &ce->engine->gt->i915->runtime_pm; + intel_wakeref_t wakeref; + + /* + * Previous owner of this guc_id has been deregistered, now safe + * register this context. + */ + with_intel_runtime_pm(runtime_pm, wakeref) + register_context(ce, true); + guc_signal_context_fence(ce); + intel_context_put(ce); + } else if (context_destroyed(ce)) { + /* Context has been destroyed */ + release_guc_id(guc, ce); + __guc_context_destroy(ce); + } + + decr_outstanding_submission_g2h(guc); + + return 0; +} + +int intel_guc_sched_done_process_msg(struct intel_guc *guc, + const u32 *msg, + u32 len) +{ + struct intel_context *ce; + unsigned long flags; + u32 desc_idx = msg[0]; + + if (unlikely(len < 2)) { + drm_err(&guc_to_gt(guc)->i915->drm, "Invalid length %u", len); + return -EPROTO; + } + + ce = g2h_context_lookup(guc, desc_idx); + if (unlikely(!ce)) + return -EPROTO; + + if (unlikely(context_destroyed(ce) || + (!context_pending_enable(ce) && + !context_pending_disable(ce)))) { + drm_err(&guc_to_gt(guc)->i915->drm, + "Bad context sched_state 0x%x, 0x%x, desc_idx %u", + atomic_read(&ce->guc_sched_state_no_lock), + ce->guc_state.sched_state, desc_idx); + return -EPROTO; + } + + trace_intel_context_sched_done(ce); + + if (context_pending_enable(ce)) { + clr_context_pending_enable(ce); + } else if (context_pending_disable(ce)) { + bool banned; + + /* + * Unpin must be done before __guc_signal_context_fence, + * otherwise a race exists between the requests getting + * submitted + retired before this unpin completes resulting in + * the pin_count going to zero and the context still being + * enabled. + */ + intel_context_sched_disable_unpin(ce); + + spin_lock_irqsave(&ce->guc_state.lock, flags); + banned = context_banned(ce); + clr_context_banned(ce); + clr_context_pending_disable(ce); + __guc_signal_context_fence(ce); + guc_blocked_fence_complete(ce); + spin_unlock_irqrestore(&ce->guc_state.lock, flags); + + if (banned) { + guc_cancel_context_requests(ce); + intel_engine_signal_breadcrumbs(ce->engine); + } + } + + decr_outstanding_submission_g2h(guc); + intel_context_put(ce); + + return 0; +} + +static void capture_error_state(struct intel_guc *guc, + struct intel_context *ce) +{ + struct intel_gt *gt = guc_to_gt(guc); + struct drm_i915_private *i915 = gt->i915; + struct intel_engine_cs *engine = __context_to_physical_engine(ce); + intel_wakeref_t wakeref; + + intel_engine_set_hung_context(engine, ce); + with_intel_runtime_pm(&i915->runtime_pm, wakeref) + i915_capture_error_state(gt, engine->mask); + atomic_inc(&i915->gpu_error.reset_engine_count[engine->uabi_class]); +} + +static void guc_context_replay(struct intel_context *ce) +{ + struct i915_sched_engine *sched_engine = ce->engine->sched_engine; + + __guc_reset_context(ce, true); + tasklet_hi_schedule(&sched_engine->tasklet); +} + +static void guc_handle_context_reset(struct intel_guc *guc, + struct intel_context *ce) +{ + trace_intel_context_reset(ce); + + if (likely(!intel_context_is_banned(ce))) { + capture_error_state(guc, ce); + guc_context_replay(ce); + } +} + +int intel_guc_context_reset_process_msg(struct intel_guc *guc, + const u32 *msg, u32 len) +{ + struct intel_context *ce; + int desc_idx; + + if (unlikely(len != 1)) { + drm_err(&guc_to_gt(guc)->i915->drm, "Invalid length %u", len); + return -EPROTO; + } + + desc_idx = msg[0]; + ce = g2h_context_lookup(guc, desc_idx); + if (unlikely(!ce)) + return -EPROTO; + + guc_handle_context_reset(guc, ce); + + return 0; +} + +static struct intel_engine_cs * +guc_lookup_engine(struct intel_guc *guc, u8 guc_class, u8 instance) +{ + struct intel_gt *gt = guc_to_gt(guc); + u8 engine_class = guc_class_to_engine_class(guc_class); + + /* Class index is checked in class converter */ + GEM_BUG_ON(instance > MAX_ENGINE_INSTANCE); + + return gt->engine_class[engine_class][instance]; +} + +int intel_guc_engine_failure_process_msg(struct intel_guc *guc, + const u32 *msg, u32 len) +{ + struct intel_engine_cs *engine; + u8 guc_class, instance; + u32 reason; + + if (unlikely(len != 3)) { + drm_err(&guc_to_gt(guc)->i915->drm, "Invalid length %u", len); + return -EPROTO; + } + + guc_class = msg[0]; + instance = msg[1]; + reason = msg[2]; + + engine = guc_lookup_engine(guc, guc_class, instance); + if (unlikely(!engine)) { + drm_err(&guc_to_gt(guc)->i915->drm, + "Invalid engine %d:%d", guc_class, instance); + return -EPROTO; + } + + intel_gt_handle_error(guc_to_gt(guc), engine->mask, + I915_ERROR_CAPTURE, + "GuC failed to reset %s (reason=0x%08x)\n", + engine->name, reason); + + return 0; +} + +void intel_guc_find_hung_context(struct intel_engine_cs *engine) +{ + struct intel_guc *guc = &engine->gt->uc.guc; + struct intel_context *ce; + struct i915_request *rq; + unsigned long index; + + /* Reset called during driver load? GuC not yet initialised! */ + if (unlikely(!guc_submission_initialized(guc))) + return; + + xa_for_each(&guc->context_lookup, index, ce) { + if (!intel_context_is_pinned(ce)) + continue; + + if (intel_engine_is_virtual(ce->engine)) { + if (!(ce->engine->mask & engine->mask)) + continue; + } else { + if (ce->engine != engine) + continue; + } + + list_for_each_entry(rq, &ce->guc_active.requests, sched.link) { + if (i915_test_request_state(rq) != I915_REQUEST_ACTIVE) + continue; + + intel_engine_set_hung_context(engine, ce); + + /* Can only cope with one hang at a time... */ + return; + } + } +} + +void intel_guc_dump_active_requests(struct intel_engine_cs *engine, + struct i915_request *hung_rq, + struct drm_printer *m) +{ + struct intel_guc *guc = &engine->gt->uc.guc; + struct intel_context *ce; + unsigned long index; + unsigned long flags; + + /* Reset called during driver load? GuC not yet initialised! */ + if (unlikely(!guc_submission_initialized(guc))) + return; + + xa_for_each(&guc->context_lookup, index, ce) { + if (!intel_context_is_pinned(ce)) + continue; + + if (intel_engine_is_virtual(ce->engine)) { + if (!(ce->engine->mask & engine->mask)) + continue; + } else { + if (ce->engine != engine) + continue; + } + + spin_lock_irqsave(&ce->guc_active.lock, flags); + intel_engine_dump_active_requests(&ce->guc_active.requests, + hung_rq, m); + spin_unlock_irqrestore(&ce->guc_active.lock, flags); + } +} + +void intel_guc_submission_print_info(struct intel_guc *guc, + struct drm_printer *p) +{ + struct i915_sched_engine *sched_engine = guc->sched_engine; + struct rb_node *rb; + unsigned long flags; + + if (!sched_engine) + return; + + drm_printf(p, "GuC Number Outstanding Submission G2H: %u\n", + atomic_read(&guc->outstanding_submission_g2h)); + drm_printf(p, "GuC tasklet count: %u\n\n", + atomic_read(&sched_engine->tasklet.count)); + + spin_lock_irqsave(&sched_engine->lock, flags); + drm_printf(p, "Requests in GuC submit tasklet:\n"); + for (rb = rb_first_cached(&sched_engine->queue); rb; rb = rb_next(rb)) { + struct i915_priolist *pl = to_priolist(rb); + struct i915_request *rq; + + priolist_for_each_request(rq, pl) + drm_printf(p, "guc_id=%u, seqno=%llu\n", + rq->context->guc_id, + rq->fence.seqno); + } + spin_unlock_irqrestore(&sched_engine->lock, flags); + drm_printf(p, "\n"); +} + +static inline void guc_log_context_priority(struct drm_printer *p, + struct intel_context *ce) +{ + int i; + + drm_printf(p, "\t\tPriority: %d\n", + ce->guc_prio); + drm_printf(p, "\t\tNumber Requests (lower index == higher priority)\n"); + for (i = GUC_CLIENT_PRIORITY_KMD_HIGH; + i < GUC_CLIENT_PRIORITY_NUM; ++i) { + drm_printf(p, "\t\tNumber requests in priority band[%d]: %d\n", + i, ce->guc_prio_count[i]); + } + drm_printf(p, "\n"); +} + +void intel_guc_submission_print_context_info(struct intel_guc *guc, + struct drm_printer *p) +{ + struct intel_context *ce; + unsigned long index; + + xa_for_each(&guc->context_lookup, index, ce) { + drm_printf(p, "GuC lrc descriptor %u:\n", ce->guc_id); + drm_printf(p, "\tHW Context Desc: 0x%08x\n", ce->lrc.lrca); + drm_printf(p, "\t\tLRC Head: Internal %u, Memory %u\n", + ce->ring->head, + ce->lrc_reg_state[CTX_RING_HEAD]); + drm_printf(p, "\t\tLRC Tail: Internal %u, Memory %u\n", + ce->ring->tail, + ce->lrc_reg_state[CTX_RING_TAIL]); + drm_printf(p, "\t\tContext Pin Count: %u\n", + atomic_read(&ce->pin_count)); + drm_printf(p, "\t\tGuC ID Ref Count: %u\n", + atomic_read(&ce->guc_id_ref)); + drm_printf(p, "\t\tSchedule State: 0x%x, 0x%x\n\n", + ce->guc_state.sched_state, + atomic_read(&ce->guc_sched_state_no_lock)); + + guc_log_context_priority(p, ce); + } +} + +static struct intel_context * +guc_create_virtual(struct intel_engine_cs **siblings, unsigned int count) +{ + struct guc_virtual_engine *ve; + struct intel_guc *guc; + unsigned int n; + int err; + + ve = kzalloc(sizeof(*ve), GFP_KERNEL); + if (!ve) + return ERR_PTR(-ENOMEM); + + guc = &siblings[0]->gt->uc.guc; + + ve->base.i915 = siblings[0]->i915; + ve->base.gt = siblings[0]->gt; + ve->base.uncore = siblings[0]->uncore; + ve->base.id = -1; + + ve->base.uabi_class = I915_ENGINE_CLASS_INVALID; + ve->base.instance = I915_ENGINE_CLASS_INVALID_VIRTUAL; + ve->base.uabi_instance = I915_ENGINE_CLASS_INVALID_VIRTUAL; + ve->base.saturated = ALL_ENGINES; + + snprintf(ve->base.name, sizeof(ve->base.name), "virtual"); + + ve->base.sched_engine = i915_sched_engine_get(guc->sched_engine); + + ve->base.cops = &virtual_guc_context_ops; + ve->base.request_alloc = guc_request_alloc; + ve->base.bump_serial = virtual_guc_bump_serial; + + ve->base.submit_request = guc_submit_request; + + ve->base.flags = I915_ENGINE_IS_VIRTUAL; + + intel_context_init(&ve->context, &ve->base); + + for (n = 0; n < count; n++) { + struct intel_engine_cs *sibling = siblings[n]; + + GEM_BUG_ON(!is_power_of_2(sibling->mask)); + if (sibling->mask & ve->base.mask) { + DRM_DEBUG("duplicate %s entry in load balancer\n", + sibling->name); + err = -EINVAL; + goto err_put; + } + + ve->base.mask |= sibling->mask; + + if (n != 0 && ve->base.class != sibling->class) { + DRM_DEBUG("invalid mixing of engine class, sibling %d, already %d\n", + sibling->class, ve->base.class); + err = -EINVAL; + goto err_put; + } else if (n == 0) { + ve->base.class = sibling->class; + ve->base.uabi_class = sibling->uabi_class; + snprintf(ve->base.name, sizeof(ve->base.name), + "v%dx%d", ve->base.class, count); + ve->base.context_size = sibling->context_size; + + ve->base.add_active_request = + sibling->add_active_request; + ve->base.remove_active_request = + sibling->remove_active_request; + ve->base.emit_bb_start = sibling->emit_bb_start; + ve->base.emit_flush = sibling->emit_flush; + ve->base.emit_init_breadcrumb = + sibling->emit_init_breadcrumb; + ve->base.emit_fini_breadcrumb = + sibling->emit_fini_breadcrumb; + ve->base.emit_fini_breadcrumb_dw = + sibling->emit_fini_breadcrumb_dw; + ve->base.breadcrumbs = + intel_breadcrumbs_get(sibling->breadcrumbs); + + ve->base.flags |= sibling->flags; + + ve->base.props.timeslice_duration_ms = + sibling->props.timeslice_duration_ms; + ve->base.props.preempt_timeout_ms = + sibling->props.preempt_timeout_ms; + } + } + + return &ve->context; + +err_put: + intel_context_put(&ve->context); + return ERR_PTR(err); +} + + + +bool intel_guc_virtual_engine_has_heartbeat(const struct intel_engine_cs *ve) +{ + struct intel_engine_cs *engine; + intel_engine_mask_t tmp, mask = ve->mask; + + for_each_engine_masked(engine, ve->gt, mask, tmp) + if (READ_ONCE(engine->props.heartbeat_interval_ms)) + return true; + + return false; +} diff --git a/drivers/gpu/drm/i915/gt/uc/intel_guc_submission.h b/drivers/gpu/drm/i915/gt/uc/intel_guc_submission.h index 3f7005018939..c7ef44fa0c36 100644 --- a/drivers/gpu/drm/i915/gt/uc/intel_guc_submission.h +++ b/drivers/gpu/drm/i915/gt/uc/intel_guc_submission.h @@ -10,6 +10,7 @@ #include "intel_guc.h" +struct drm_printer; struct intel_engine_cs; void intel_guc_submission_init_early(struct intel_guc *guc); @@ -20,11 +21,24 @@ void intel_guc_submission_fini(struct intel_guc *guc); int intel_guc_preempt_work_create(struct intel_guc *guc); void intel_guc_preempt_work_destroy(struct intel_guc *guc); int intel_guc_submission_setup(struct intel_engine_cs *engine); +void intel_guc_submission_print_info(struct intel_guc *guc, + struct drm_printer *p); +void intel_guc_submission_print_context_info(struct intel_guc *guc, + struct drm_printer *p); +void intel_guc_dump_active_requests(struct intel_engine_cs *engine, + struct i915_request *hung_rq, + struct drm_printer *m); + +bool intel_guc_virtual_engine_has_heartbeat(const struct intel_engine_cs *ve); + +int intel_guc_wait_for_pending_msg(struct intel_guc *guc, + atomic_t *wait_var, + bool interruptible, + long timeout); static inline bool intel_guc_submission_is_supported(struct intel_guc *guc) { - /* XXX: GuC submission is unavailable for now */ - return false; + return guc->submission_supported; } static inline bool intel_guc_submission_is_wanted(struct intel_guc *guc) diff --git a/drivers/gpu/drm/i915/gt/uc/intel_uc.c b/drivers/gpu/drm/i915/gt/uc/intel_uc.c index 6d8b9233214e..da57d18d9f6b 100644 --- a/drivers/gpu/drm/i915/gt/uc/intel_uc.c +++ b/drivers/gpu/drm/i915/gt/uc/intel_uc.c @@ -34,8 +34,14 @@ static void uc_expand_default_options(struct intel_uc *uc) return; } - /* Default: enable HuC authentication only */ - i915->params.enable_guc = ENABLE_GUC_LOAD_HUC; + /* Intermediate platforms are HuC authentication only */ + if (IS_DG1(i915) || IS_ALDERLAKE_S(i915)) { + i915->params.enable_guc = ENABLE_GUC_LOAD_HUC; + return; + } + + /* Default: enable HuC authentication and GuC submission */ + i915->params.enable_guc = ENABLE_GUC_LOAD_HUC | ENABLE_GUC_SUBMISSION; } /* Reset GuC providing us with fresh state for both GuC and HuC. @@ -120,6 +126,11 @@ void intel_uc_init_early(struct intel_uc *uc) uc->ops = &uc_ops_off; } +void intel_uc_init_late(struct intel_uc *uc) +{ + intel_guc_init_late(&uc->guc); +} + void intel_uc_driver_late_release(struct intel_uc *uc) { } @@ -207,21 +218,6 @@ static void guc_handle_mmio_msg(struct intel_guc *guc) spin_unlock_irq(&guc->irq_lock); } -static void guc_reset_interrupts(struct intel_guc *guc) -{ - guc->interrupts.reset(guc); -} - -static void guc_enable_interrupts(struct intel_guc *guc) -{ - guc->interrupts.enable(guc); -} - -static void guc_disable_interrupts(struct intel_guc *guc) -{ - guc->interrupts.disable(guc); -} - static int guc_enable_communication(struct intel_guc *guc) { struct intel_gt *gt = guc_to_gt(guc); @@ -242,7 +238,7 @@ static int guc_enable_communication(struct intel_guc *guc) guc_get_mmio_msg(guc); guc_handle_mmio_msg(guc); - guc_enable_interrupts(guc); + intel_guc_enable_interrupts(guc); /* check for CT messages received before we enabled interrupts */ spin_lock_irq(>->irq_lock); @@ -265,7 +261,7 @@ static void guc_disable_communication(struct intel_guc *guc) */ guc_clear_mmio_msg(guc); - guc_disable_interrupts(guc); + intel_guc_disable_interrupts(guc); intel_guc_ct_disable(&guc->ct); @@ -323,9 +319,6 @@ static int __uc_init(struct intel_uc *uc) if (i915_inject_probe_failure(uc_to_gt(uc)->i915)) return -ENOMEM; - /* XXX: GuC submission is unavailable for now */ - GEM_BUG_ON(intel_uc_uses_guc_submission(uc)); - ret = intel_guc_init(guc); if (ret) return ret; @@ -463,7 +456,7 @@ static int __uc_init_hw(struct intel_uc *uc) if (ret) goto err_out; - guc_reset_interrupts(guc); + intel_guc_reset_interrupts(guc); /* WaEnableuKernelHeaderValidFix:skl */ /* WaEnableGuCBootHashCheckNotSet:skl,bxt,kbl */ @@ -565,23 +558,67 @@ void intel_uc_reset_prepare(struct intel_uc *uc) { struct intel_guc *guc = &uc->guc; - if (!intel_guc_is_ready(guc)) + uc->reset_in_progress = true; + + /* Nothing to do if GuC isn't supported */ + if (!intel_uc_supports_guc(uc)) return; + /* Firmware expected to be running when this function is called */ + if (!intel_guc_is_ready(guc)) + goto sanitize; + + if (intel_uc_uses_guc_submission(uc)) + intel_guc_submission_reset_prepare(guc); + +sanitize: __uc_sanitize(uc); } +void intel_uc_reset(struct intel_uc *uc, bool stalled) +{ + struct intel_guc *guc = &uc->guc; + + /* Firmware can not be running when this function is called */ + if (intel_uc_uses_guc_submission(uc)) + intel_guc_submission_reset(guc, stalled); +} + +void intel_uc_reset_finish(struct intel_uc *uc) +{ + struct intel_guc *guc = &uc->guc; + + uc->reset_in_progress = false; + + /* Firmware expected to be running when this function is called */ + if (intel_guc_is_fw_running(guc) && intel_uc_uses_guc_submission(uc)) + intel_guc_submission_reset_finish(guc); +} + +void intel_uc_cancel_requests(struct intel_uc *uc) +{ + struct intel_guc *guc = &uc->guc; + + /* Firmware can not be running when this function is called */ + if (intel_uc_uses_guc_submission(uc)) + intel_guc_submission_cancel_requests(guc); +} + void intel_uc_runtime_suspend(struct intel_uc *uc) { struct intel_guc *guc = &uc->guc; - int err; if (!intel_guc_is_ready(guc)) return; - err = intel_guc_suspend(guc); - if (err) - DRM_DEBUG_DRIVER("Failed to suspend GuC, err=%d", err); + /* + * Wait for any outstanding CTB before tearing down communication /w the + * GuC. + */ +#define OUTSTANDING_CTB_TIMEOUT_PERIOD (HZ / 5) + intel_guc_wait_for_pending_msg(guc, &guc->outstanding_submission_g2h, + false, OUTSTANDING_CTB_TIMEOUT_PERIOD); + GEM_WARN_ON(atomic_read(&guc->outstanding_submission_g2h)); guc_disable_communication(guc); } @@ -590,12 +627,16 @@ void intel_uc_suspend(struct intel_uc *uc) { struct intel_guc *guc = &uc->guc; intel_wakeref_t wakeref; + int err; if (!intel_guc_is_ready(guc)) return; - with_intel_runtime_pm(uc_to_gt(uc)->uncore->rpm, wakeref) - intel_uc_runtime_suspend(uc); + with_intel_runtime_pm(&uc_to_gt(uc)->i915->runtime_pm, wakeref) { + err = intel_guc_suspend(guc); + if (err) + DRM_DEBUG_DRIVER("Failed to suspend GuC, err=%d", err); + } } static int __uc_resume(struct intel_uc *uc, bool enable_communication) diff --git a/drivers/gpu/drm/i915/gt/uc/intel_uc.h b/drivers/gpu/drm/i915/gt/uc/intel_uc.h index 9c954c589edf..e2da2b6e76e1 100644 --- a/drivers/gpu/drm/i915/gt/uc/intel_uc.h +++ b/drivers/gpu/drm/i915/gt/uc/intel_uc.h @@ -30,13 +30,19 @@ struct intel_uc { /* Snapshot of GuC log from last failed load */ struct drm_i915_gem_object *load_err_log; + + bool reset_in_progress; }; void intel_uc_init_early(struct intel_uc *uc); +void intel_uc_init_late(struct intel_uc *uc); void intel_uc_driver_late_release(struct intel_uc *uc); void intel_uc_driver_remove(struct intel_uc *uc); void intel_uc_init_mmio(struct intel_uc *uc); void intel_uc_reset_prepare(struct intel_uc *uc); +void intel_uc_reset(struct intel_uc *uc, bool stalled); +void intel_uc_reset_finish(struct intel_uc *uc); +void intel_uc_cancel_requests(struct intel_uc *uc); void intel_uc_suspend(struct intel_uc *uc); void intel_uc_runtime_suspend(struct intel_uc *uc); int intel_uc_resume(struct intel_uc *uc); @@ -81,6 +87,11 @@ uc_state_checkers(guc, guc_submission); #undef uc_state_checkers #undef __uc_state_checker +static inline int intel_uc_wait_for_idle(struct intel_uc *uc, long timeout) +{ + return intel_guc_wait_for_idle(&uc->guc, timeout); +} + #define intel_uc_ops_function(_NAME, _OPS, _TYPE, _RET) \ static inline _TYPE intel_uc_##_NAME(struct intel_uc *uc) \ { \ diff --git a/drivers/gpu/drm/i915/i915_debugfs_params.c b/drivers/gpu/drm/i915/i915_debugfs_params.c index 4e2b077692cb..8ecd8b42f048 100644 --- a/drivers/gpu/drm/i915/i915_debugfs_params.c +++ b/drivers/gpu/drm/i915/i915_debugfs_params.c @@ -6,9 +6,20 @@ #include #include "i915_debugfs_params.h" +#include "gt/intel_gt.h" +#include "gt/uc/intel_guc.h" #include "i915_drv.h" #include "i915_params.h" +#define MATCH_DEBUGFS_NODE_NAME(_file, _name) (strcmp((_file)->f_path.dentry->d_name.name, (_name)) == 0) + +#define GET_I915(i915, name, ptr) \ + do { \ + struct i915_params *params; \ + params = container_of(((void *) (ptr)), typeof(*params), name); \ + (i915) = container_of(params, typeof(*(i915)), params); \ + } while(0) + /* int param */ static int i915_param_int_show(struct seq_file *m, void *data) { @@ -24,6 +35,16 @@ static int i915_param_int_open(struct inode *inode, struct file *file) return single_open(file, i915_param_int_show, inode->i_private); } +static int notify_guc(struct drm_i915_private *i915) +{ + int ret = 0; + + if (intel_uc_uses_guc_submission(&i915->gt.uc)) + ret = intel_guc_global_policies_update(&i915->gt.uc.guc); + + return ret; +} + static ssize_t i915_param_int_write(struct file *file, const char __user *ubuf, size_t len, loff_t *offp) @@ -81,8 +102,10 @@ static ssize_t i915_param_uint_write(struct file *file, const char __user *ubuf, size_t len, loff_t *offp) { + struct drm_i915_private *i915; struct seq_file *m = file->private_data; unsigned int *value = m->private; + unsigned int old = *value; int ret; ret = kstrtouint_from_user(ubuf, len, 0, value); @@ -95,6 +118,14 @@ static ssize_t i915_param_uint_write(struct file *file, *value = b; } + if (!ret && MATCH_DEBUGFS_NODE_NAME(file, "reset")) { + GET_I915(i915, reset, value); + + ret = notify_guc(i915); + if (ret) + *value = old; + } + return ret ?: len; } diff --git a/drivers/gpu/drm/i915/i915_gem_evict.c b/drivers/gpu/drm/i915/i915_gem_evict.c index 4d2d59a9942b..2b73ddb11c66 100644 --- a/drivers/gpu/drm/i915/i915_gem_evict.c +++ b/drivers/gpu/drm/i915/i915_gem_evict.c @@ -27,6 +27,7 @@ */ #include "gem/i915_gem_context.h" +#include "gt/intel_gt.h" #include "gt/intel_gt_requests.h" #include "i915_drv.h" diff --git a/drivers/gpu/drm/i915/i915_gpu_error.c b/drivers/gpu/drm/i915/i915_gpu_error.c index a2c58b54a592..0f08bcfbe964 100644 --- a/drivers/gpu/drm/i915/i915_gpu_error.c +++ b/drivers/gpu/drm/i915/i915_gpu_error.c @@ -1429,20 +1429,37 @@ capture_engine(struct intel_engine_cs *engine, { struct intel_engine_capture_vma *capture = NULL; struct intel_engine_coredump *ee; - struct i915_request *rq; + struct intel_context *ce; + struct i915_request *rq = NULL; unsigned long flags; ee = intel_engine_coredump_alloc(engine, GFP_KERNEL); if (!ee) return NULL; - spin_lock_irqsave(&engine->sched_engine->lock, flags); - rq = intel_engine_find_active_request(engine); + ce = intel_engine_get_hung_context(engine); + if (ce) { + intel_engine_clear_hung_context(engine); + rq = intel_context_find_active_request(ce); + if (!rq || !i915_request_started(rq)) + goto no_request_capture; + } else { + /* + * Getting here with GuC enabled means it is a forced error capture + * with no actual hang. So, no need to attempt the execlist search. + */ + if (!intel_uc_uses_guc_submission(&engine->gt->uc)) { + spin_lock_irqsave(&engine->sched_engine->lock, flags); + rq = intel_engine_execlist_find_hung_request(engine); + spin_unlock_irqrestore(&engine->sched_engine->lock, + flags); + } + } if (rq) capture = intel_engine_coredump_add_request(ee, rq, ATOMIC_MAYFAIL); - spin_unlock_irqrestore(&engine->sched_engine->lock, flags); if (!capture) { +no_request_capture: kfree(ee); return NULL; } diff --git a/drivers/gpu/drm/i915/i915_reg.h b/drivers/gpu/drm/i915/i915_reg.h index 943fe485c662..3584e4d03dc3 100644 --- a/drivers/gpu/drm/i915/i915_reg.h +++ b/drivers/gpu/drm/i915/i915_reg.h @@ -4142,6 +4142,7 @@ enum { FAULT_AND_CONTINUE /* Unsupported */ }; +#define CTX_GTT_ADDRESS_MASK GENMASK(31, 12) #define GEN8_CTX_VALID (1 << 0) #define GEN8_CTX_FORCE_PD_RESTORE (1 << 1) #define GEN8_CTX_FORCE_RESTORE (1 << 2) @@ -12308,6 +12309,7 @@ enum skl_power_gate { /* MOCS (Memory Object Control State) registers */ #define GEN9_LNCFCMOCS(i) _MMIO(0xb020 + (i) * 4) /* L3 Cache Control */ +#define GEN9_LNCFCMOCS_REG_COUNT 32 #define __GEN9_RCS0_MOCS0 0xc800 #define GEN9_GFX_MOCS(i) _MMIO(__GEN9_RCS0_MOCS0 + (i) * 4) diff --git a/drivers/gpu/drm/i915/i915_request.c b/drivers/gpu/drm/i915/i915_request.c index 09ebea9a0090..329c61595f02 100644 --- a/drivers/gpu/drm/i915/i915_request.c +++ b/drivers/gpu/drm/i915/i915_request.c @@ -114,6 +114,9 @@ static void i915_fence_release(struct dma_fence *fence) { struct i915_request *rq = to_request(fence); + GEM_BUG_ON(rq->guc_prio != GUC_PRIO_INIT && + rq->guc_prio != GUC_PRIO_FINI); + /* * The request is put onto a RCU freelist (i.e. the address * is immediately reused), mark the fences as being freed now. @@ -125,39 +128,17 @@ static void i915_fence_release(struct dma_fence *fence) i915_sw_fence_fini(&rq->semaphore); /* - * Keep one request on each engine for reserved use under mempressure - * - * We do not hold a reference to the engine here and so have to be - * very careful in what rq->engine we poke. The virtual engine is - * referenced via the rq->context and we released that ref during - * i915_request_retire(), ergo we must not dereference a virtual - * engine here. Not that we would want to, as the only consumer of - * the reserved engine->request_pool is the power management parking, - * which must-not-fail, and that is only run on the physical engines. - * - * Since the request must have been executed to be have completed, - * we know that it will have been processed by the HW and will - * not be unsubmitted again, so rq->engine and rq->execution_mask - * at this point is stable. rq->execution_mask will be a single - * bit if the last and _only_ engine it could execution on was a - * physical engine, if it's multiple bits then it started on and - * could still be on a virtual engine. Thus if the mask is not a - * power-of-two we assume that rq->engine may still be a virtual - * engine and so a dangling invalid pointer that we cannot dereference - * - * For example, consider the flow of a bonded request through a virtual - * engine. The request is created with a wide engine mask (all engines - * that we might execute on). On processing the bond, the request mask - * is reduced to one or more engines. If the request is subsequently - * bound to a single engine, it will then be constrained to only - * execute on that engine and never returned to the virtual engine - * after timeslicing away, see __unwind_incomplete_requests(). Thus we - * know that if the rq->execution_mask is a single bit, rq->engine - * can be a physical engine with the exact corresponding mask. + * Keep one request on each engine for reserved use under mempressure, + * do not use with virtual engines as this really is only needed for + * kernel contexts. */ - if (is_power_of_2(rq->execution_mask) && - !cmpxchg(&rq->engine->request_pool, NULL, rq)) + if (!intel_engine_is_virtual(rq->engine) && + !cmpxchg(&rq->engine->request_pool, NULL, rq)) { + intel_context_put(rq->context); return; + } + + intel_context_put(rq->context); kmem_cache_free(global.slab_requests, rq); } @@ -204,7 +185,7 @@ static bool irq_work_imm(struct irq_work *wrk) return false; } -static void __notify_execute_cb_imm(struct i915_request *rq) +void i915_request_notify_execute_cb_imm(struct i915_request *rq) { __notify_execute_cb(rq, irq_work_imm); } @@ -278,37 +259,6 @@ i915_request_active_engine(struct i915_request *rq, return ret; } - -static void remove_from_engine(struct i915_request *rq) -{ - struct intel_engine_cs *engine, *locked; - - /* - * Virtual engines complicate acquiring the engine timeline lock, - * as their rq->engine pointer is not stable until under that - * engine lock. The simple ploy we use is to take the lock then - * check that the rq still belongs to the newly locked engine. - */ - locked = READ_ONCE(rq->engine); - spin_lock_irq(&locked->sched_engine->lock); - while (unlikely(locked != (engine = READ_ONCE(rq->engine)))) { - spin_unlock(&locked->sched_engine->lock); - spin_lock(&engine->sched_engine->lock); - locked = engine; - } - list_del_init(&rq->sched.link); - - clear_bit(I915_FENCE_FLAG_PQUEUE, &rq->fence.flags); - clear_bit(I915_FENCE_FLAG_HOLD, &rq->fence.flags); - - /* Prevent further __await_execution() registering a cb, then flush */ - set_bit(I915_FENCE_FLAG_ACTIVE, &rq->fence.flags); - - spin_unlock_irq(&locked->sched_engine->lock); - - __notify_execute_cb_imm(rq); -} - static void __rq_init_watchdog(struct i915_request *rq) { rq->watchdog.timer.function = NULL; @@ -405,8 +355,7 @@ bool i915_request_retire(struct i915_request *rq) * after removing the breadcrumb and signaling it, so that we do not * inadvertently attach the breadcrumb to a completed request. */ - if (!list_empty(&rq->sched.link)) - remove_from_engine(rq); + rq->engine->remove_active_request(rq); GEM_BUG_ON(!llist_empty(&rq->execute_cb)); __list_del_entry(&rq->link); /* poison neither prev/next (RCU walks) */ @@ -431,6 +380,7 @@ void i915_request_retire_upto(struct i915_request *rq) do { tmp = list_first_entry(&tl->requests, typeof(*tmp), link); + GEM_BUG_ON(!i915_request_completed(tmp)); } while (i915_request_retire(tmp) && tmp != rq); } @@ -536,7 +486,7 @@ __await_execution(struct i915_request *rq, if (llist_add(&cb->work.node.llist, &signal->execute_cb)) { if (i915_request_is_active(signal) || __request_in_flight(signal)) - __notify_execute_cb_imm(signal); + i915_request_notify_execute_cb_imm(signal); } return 0; @@ -667,11 +617,15 @@ bool __i915_request_submit(struct i915_request *request) request->ring->vaddr + request->postfix); trace_i915_request_execute(request); - engine->serial++; + if (engine->bump_serial) + engine->bump_serial(engine); + else + engine->serial++; + result = true; GEM_BUG_ON(test_bit(I915_FENCE_FLAG_ACTIVE, &request->fence.flags)); - list_move_tail(&request->sched.link, &engine->sched_engine->requests); + engine->add_active_request(request); active: clear_bit(I915_FENCE_FLAG_PQUEUE, &request->fence.flags); set_bit(I915_FENCE_FLAG_ACTIVE, &request->fence.flags); @@ -759,18 +713,6 @@ void i915_request_unsubmit(struct i915_request *request) spin_unlock_irqrestore(&engine->sched_engine->lock, flags); } -static void __cancel_request(struct i915_request *rq) -{ - struct intel_engine_cs *engine = NULL; - - i915_request_active_engine(rq, &engine); - - if (engine && intel_engine_pulse(engine)) - intel_gt_handle_error(engine->gt, engine->mask, 0, - "request cancellation by %s", - current->comm); -} - void i915_request_cancel(struct i915_request *rq, int error) { if (!i915_request_set_error_once(rq, error)) @@ -778,7 +720,7 @@ void i915_request_cancel(struct i915_request *rq, int error) set_bit(I915_FENCE_FLAG_SENTINEL, &rq->fence.flags); - __cancel_request(rq); + intel_context_cancel_request(rq->context, rq); } static int __i915_sw_fence_call @@ -950,7 +892,19 @@ __i915_request_create(struct intel_context *ce, gfp_t gfp) } } - rq->context = ce; + /* + * Hold a reference to the intel_context over life of an i915_request. + * Without this an i915_request can exist after the context has been + * destroyed (e.g. request retired, context closed, but user space holds + * a reference to the request from an out fence). In the case of GuC + * submission + virtual engine, the engine that the request references + * is also destroyed which can trigger bad pointer dref in fence ops + * (e.g. i915_fence_get_driver_name). We could likely change these + * functions to avoid touching the engine but let's just be safe and + * hold the intel_context reference. In execlist mode the request always + * eventually points to a physical engine so this isn't an issue. + */ + rq->context = intel_context_get(ce); rq->engine = ce->engine; rq->ring = ce->ring; rq->execution_mask = ce->engine->mask; @@ -973,6 +927,8 @@ __i915_request_create(struct intel_context *ce, gfp_t gfp) rq->rcustate = get_state_synchronize_rcu(); /* acts as smp_mb() */ + rq->guc_prio = GUC_PRIO_INIT; + /* We bump the ref for the fence chain */ i915_sw_fence_reinit(&i915_request_get(rq)->submit); i915_sw_fence_reinit(&i915_request_get(rq)->semaphore); @@ -1027,6 +983,7 @@ __i915_request_create(struct intel_context *ce, gfp_t gfp) GEM_BUG_ON(!list_empty(&rq->sched.waiters_list)); err_free: + intel_context_put(ce); kmem_cache_free(global.slab_requests, rq); err_unreserve: intel_context_unpin(ce); @@ -1379,6 +1336,9 @@ i915_request_await_external(struct i915_request *rq, struct dma_fence *fence) return err; } +static int +i915_request_await_request(struct i915_request *to, struct i915_request *from); + int i915_request_await_execution(struct i915_request *rq, struct dma_fence *fence) @@ -1462,7 +1422,8 @@ i915_request_await_request(struct i915_request *to, struct i915_request *from) return ret; } - if (is_power_of_2(to->execution_mask | READ_ONCE(from->execution_mask))) + if (!intel_engine_uses_guc(to->engine) && + is_power_of_2(to->execution_mask | READ_ONCE(from->execution_mask))) ret = await_request_submit(to, from); else ret = emit_semaphore_wait(to, from, I915_FENCE_GFP); @@ -1621,6 +1582,8 @@ __i915_request_add_to_timeline(struct i915_request *rq) prev = to_request(__i915_active_fence_set(&timeline->last_request, &rq->fence)); if (prev && !__i915_request_is_complete(prev)) { + bool uses_guc = intel_engine_uses_guc(rq->engine); + /* * The requests are supposed to be kept in order. However, * we need to be wary in case the timeline->last_request @@ -1631,7 +1594,8 @@ __i915_request_add_to_timeline(struct i915_request *rq) i915_seqno_passed(prev->fence.seqno, rq->fence.seqno)); - if (is_power_of_2(READ_ONCE(prev->engine)->mask | rq->engine->mask)) + if ((!uses_guc && is_power_of_2(READ_ONCE(prev->engine)->mask | rq->engine->mask)) || + (uses_guc && prev->context == rq->context)) i915_sw_fence_await_sw_fence(&rq->submit, &prev->submit, &rq->submitq); @@ -2072,6 +2036,47 @@ void i915_request_show(struct drm_printer *m, name); } +static bool engine_match_ring(struct intel_engine_cs *engine, struct i915_request *rq) +{ + u32 ring = ENGINE_READ(engine, RING_START); + + return ring == i915_ggtt_offset(rq->ring->vma); +} + +static bool match_ring(struct i915_request *rq) +{ + struct intel_engine_cs *engine; + bool found; + int i; + + if (!intel_engine_is_virtual(rq->engine)) + return engine_match_ring(rq->engine, rq); + + found = false; + i = 0; + while ((engine = intel_engine_get_sibling(rq->engine, i++))) { + found = engine_match_ring(engine, rq); + if (found) + break; + } + + return found; +} + +enum i915_request_state i915_test_request_state(struct i915_request *rq) +{ + if (i915_request_completed(rq)) + return I915_REQUEST_COMPLETE; + + if (!i915_request_started(rq)) + return I915_REQUEST_PENDING; + + if (match_ring(rq)) + return I915_REQUEST_ACTIVE; + + return I915_REQUEST_QUEUED; +} + #if IS_ENABLED(CONFIG_DRM_I915_SELFTEST) #include "selftests/mock_request.c" #include "selftests/i915_request.c" diff --git a/drivers/gpu/drm/i915/i915_request.h b/drivers/gpu/drm/i915/i915_request.h index 5deb65ec5fa5..f0463d19c712 100644 --- a/drivers/gpu/drm/i915/i915_request.h +++ b/drivers/gpu/drm/i915/i915_request.h @@ -285,6 +285,22 @@ struct i915_request { struct hrtimer timer; } watchdog; + /* + * Requests may need to be stalled when using GuC submission waiting for + * certain GuC operations to complete. If that is the case, stalled + * requests are added to a per context list of stalled requests. The + * below list_head is the link in that list. + */ + struct list_head guc_fence_link; + + /** + * Priority level while the request is inflight. Differs slightly than + * i915 scheduler priority. + */ +#define GUC_PRIO_INIT 0xff +#define GUC_PRIO_FINI 0xfe + u8 guc_prio; + I915_SELFTEST_DECLARE(struct { struct list_head link; unsigned long delay; @@ -639,4 +655,17 @@ bool i915_request_active_engine(struct i915_request *rq, struct intel_engine_cs **active); +void i915_request_notify_execute_cb_imm(struct i915_request *rq); + +enum i915_request_state +{ + I915_REQUEST_UNKNOWN = 0, + I915_REQUEST_COMPLETE, + I915_REQUEST_PENDING, + I915_REQUEST_QUEUED, + I915_REQUEST_ACTIVE, +}; + +enum i915_request_state i915_test_request_state(struct i915_request *rq); + #endif /* I915_REQUEST_H */ diff --git a/drivers/gpu/drm/i915/i915_scheduler.c b/drivers/gpu/drm/i915/i915_scheduler.c index 3a58a9130309..3fccae3672c1 100644 --- a/drivers/gpu/drm/i915/i915_scheduler.c +++ b/drivers/gpu/drm/i915/i915_scheduler.c @@ -241,6 +241,9 @@ static void __i915_schedule(struct i915_sched_node *node, /* Fifo and depth-first replacement ensure our deps execute before us */ sched_engine = lock_sched_engine(node, sched_engine, &cache); list_for_each_entry_safe_reverse(dep, p, &dfs, dfs_link) { + struct i915_request *from = container_of(dep->signaler, + struct i915_request, + sched); INIT_LIST_HEAD(&dep->dfs_link); node = dep->signaler; @@ -254,6 +257,10 @@ static void __i915_schedule(struct i915_sched_node *node, GEM_BUG_ON(node_to_request(node)->engine->sched_engine != sched_engine); + /* Must be called before changing the nodes priority */ + if (sched_engine->bump_inflight_request_prio) + sched_engine->bump_inflight_request_prio(from, prio); + WRITE_ONCE(node->attr.priority, prio); /* @@ -431,7 +438,7 @@ void i915_request_show_with_schedule(struct drm_printer *m, rcu_read_unlock(); } -void i915_sched_engine_free(struct kref *kref) +static void default_destroy(struct kref *kref) { struct i915_sched_engine *sched_engine = container_of(kref, typeof(*sched_engine), ref); @@ -440,6 +447,11 @@ void i915_sched_engine_free(struct kref *kref) kfree(sched_engine); } +static bool default_disabled(struct i915_sched_engine *sched_engine) +{ + return false; +} + struct i915_sched_engine * i915_sched_engine_create(unsigned int subclass) { @@ -453,6 +465,8 @@ i915_sched_engine_create(unsigned int subclass) sched_engine->queue = RB_ROOT_CACHED; sched_engine->queue_priority_hint = INT_MIN; + sched_engine->destroy = default_destroy; + sched_engine->disabled = default_disabled; INIT_LIST_HEAD(&sched_engine->requests); INIT_LIST_HEAD(&sched_engine->hold); diff --git a/drivers/gpu/drm/i915/i915_scheduler.h b/drivers/gpu/drm/i915/i915_scheduler.h index 650ab8e0db9f..f4d9811ade5b 100644 --- a/drivers/gpu/drm/i915/i915_scheduler.h +++ b/drivers/gpu/drm/i915/i915_scheduler.h @@ -51,8 +51,6 @@ static inline void i915_priolist_free(struct i915_priolist *p) struct i915_sched_engine * i915_sched_engine_create(unsigned int subclass); -void i915_sched_engine_free(struct kref *kref); - static inline struct i915_sched_engine * i915_sched_engine_get(struct i915_sched_engine *sched_engine) { @@ -63,7 +61,7 @@ i915_sched_engine_get(struct i915_sched_engine *sched_engine) static inline void i915_sched_engine_put(struct i915_sched_engine *sched_engine) { - kref_put(&sched_engine->ref, i915_sched_engine_free); + kref_put(&sched_engine->ref, sched_engine->destroy); } static inline bool @@ -98,4 +96,10 @@ void i915_request_show_with_schedule(struct drm_printer *m, const char *prefix, int indent); +static inline bool +i915_sched_engine_disabled(struct i915_sched_engine *sched_engine) +{ + return sched_engine->disabled(sched_engine); +} + #endif /* _I915_SCHEDULER_H_ */ diff --git a/drivers/gpu/drm/i915/i915_scheduler_types.h b/drivers/gpu/drm/i915/i915_scheduler_types.h index 5935c3152bdc..b0a1b58c7893 100644 --- a/drivers/gpu/drm/i915/i915_scheduler_types.h +++ b/drivers/gpu/drm/i915/i915_scheduler_types.h @@ -163,12 +163,34 @@ struct i915_sched_engine { */ void *private_data; + /** + * @destroy: destroy schedule engine / cleanup in backend + */ + void (*destroy)(struct kref *kref); + + /** + * @disabled: check if backend has disabled submission + */ + bool (*disabled)(struct i915_sched_engine *sched_engine); + /** * @kick_backend: kick backend after a request's priority has changed */ void (*kick_backend)(const struct i915_request *rq, int prio); + /** + * @bump_inflight_request_prio: update priority of an inflight request + */ + void (*bump_inflight_request_prio)(struct i915_request *rq, + int prio); + + /** + * @retire_inflight_request_prio: indicate request is retired to + * priority tracking + */ + void (*retire_inflight_request_prio)(struct i915_request *rq); + /** * @schedule: adjust priority of request * diff --git a/drivers/gpu/drm/i915/i915_trace.h b/drivers/gpu/drm/i915/i915_trace.h index 6778ad2a14a4..fb376e8041ae 100644 --- a/drivers/gpu/drm/i915/i915_trace.h +++ b/drivers/gpu/drm/i915/i915_trace.h @@ -794,30 +794,40 @@ DECLARE_EVENT_CLASS(i915_request, TP_STRUCT__entry( __field(u32, dev) __field(u64, ctx) + __field(u32, guc_id) __field(u16, class) __field(u16, instance) __field(u32, seqno) + __field(u32, tail) ), TP_fast_assign( __entry->dev = rq->engine->i915->drm.primary->index; __entry->class = rq->engine->uabi_class; __entry->instance = rq->engine->uabi_instance; + __entry->guc_id = rq->context->guc_id; __entry->ctx = rq->fence.context; __entry->seqno = rq->fence.seqno; + __entry->tail = rq->tail; ), - TP_printk("dev=%u, engine=%u:%u, ctx=%llu, seqno=%u", + TP_printk("dev=%u, engine=%u:%u, guc_id=%u, ctx=%llu, seqno=%u, tail=%u", __entry->dev, __entry->class, __entry->instance, - __entry->ctx, __entry->seqno) + __entry->guc_id, __entry->ctx, __entry->seqno, + __entry->tail) ); DEFINE_EVENT(i915_request, i915_request_add, - TP_PROTO(struct i915_request *rq), - TP_ARGS(rq) + TP_PROTO(struct i915_request *rq), + TP_ARGS(rq) ); #if defined(CONFIG_DRM_I915_LOW_LEVEL_TRACEPOINTS) +DEFINE_EVENT(i915_request, i915_request_guc_submit, + TP_PROTO(struct i915_request *rq), + TP_ARGS(rq) +); + DEFINE_EVENT(i915_request, i915_request_submit, TP_PROTO(struct i915_request *rq), TP_ARGS(rq) @@ -885,8 +895,114 @@ TRACE_EVENT(i915_request_out, __entry->ctx, __entry->seqno, __entry->completed) ); +DECLARE_EVENT_CLASS(intel_context, + TP_PROTO(struct intel_context *ce), + TP_ARGS(ce), + + TP_STRUCT__entry( + __field(u32, guc_id) + __field(int, pin_count) + __field(u32, sched_state) + __field(u32, guc_sched_state_no_lock) + __field(u8, guc_prio) + ), + + TP_fast_assign( + __entry->guc_id = ce->guc_id; + __entry->pin_count = atomic_read(&ce->pin_count); + __entry->sched_state = ce->guc_state.sched_state; + __entry->guc_sched_state_no_lock = + atomic_read(&ce->guc_sched_state_no_lock); + __entry->guc_prio = ce->guc_prio; + ), + + TP_printk("guc_id=%d, pin_count=%d sched_state=0x%x,0x%x, guc_prio=%u", + __entry->guc_id, __entry->pin_count, __entry->sched_state, + __entry->guc_sched_state_no_lock, __entry->guc_prio) +); + +DEFINE_EVENT(intel_context, intel_context_set_prio, + TP_PROTO(struct intel_context *ce), + TP_ARGS(ce) +); + +DEFINE_EVENT(intel_context, intel_context_reset, + TP_PROTO(struct intel_context *ce), + TP_ARGS(ce) +); + +DEFINE_EVENT(intel_context, intel_context_ban, + TP_PROTO(struct intel_context *ce), + TP_ARGS(ce) +); + +DEFINE_EVENT(intel_context, intel_context_register, + TP_PROTO(struct intel_context *ce), + TP_ARGS(ce) +); + +DEFINE_EVENT(intel_context, intel_context_deregister, + TP_PROTO(struct intel_context *ce), + TP_ARGS(ce) +); + +DEFINE_EVENT(intel_context, intel_context_deregister_done, + TP_PROTO(struct intel_context *ce), + TP_ARGS(ce) +); + +DEFINE_EVENT(intel_context, intel_context_sched_enable, + TP_PROTO(struct intel_context *ce), + TP_ARGS(ce) +); + +DEFINE_EVENT(intel_context, intel_context_sched_disable, + TP_PROTO(struct intel_context *ce), + TP_ARGS(ce) +); + +DEFINE_EVENT(intel_context, intel_context_sched_done, + TP_PROTO(struct intel_context *ce), + TP_ARGS(ce) +); + +DEFINE_EVENT(intel_context, intel_context_create, + TP_PROTO(struct intel_context *ce), + TP_ARGS(ce) +); + +DEFINE_EVENT(intel_context, intel_context_fence_release, + TP_PROTO(struct intel_context *ce), + TP_ARGS(ce) +); + +DEFINE_EVENT(intel_context, intel_context_free, + TP_PROTO(struct intel_context *ce), + TP_ARGS(ce) +); + +DEFINE_EVENT(intel_context, intel_context_steal_guc_id, + TP_PROTO(struct intel_context *ce), + TP_ARGS(ce) +); + +DEFINE_EVENT(intel_context, intel_context_do_pin, + TP_PROTO(struct intel_context *ce), + TP_ARGS(ce) +); + +DEFINE_EVENT(intel_context, intel_context_do_unpin, + TP_PROTO(struct intel_context *ce), + TP_ARGS(ce) +); + #else #if !defined(TRACE_HEADER_MULTI_READ) +static inline void +trace_i915_request_guc_submit(struct i915_request *rq) +{ +} + static inline void trace_i915_request_submit(struct i915_request *rq) { @@ -906,6 +1022,81 @@ static inline void trace_i915_request_out(struct i915_request *rq) { } + +static inline void +trace_intel_context_set_prio(struct intel_context *ce) +{ +} + +static inline void +trace_intel_context_reset(struct intel_context *ce) +{ +} + +static inline void +trace_intel_context_ban(struct intel_context *ce) +{ +} + +static inline void +trace_intel_context_register(struct intel_context *ce) +{ +} + +static inline void +trace_intel_context_deregister(struct intel_context *ce) +{ +} + +static inline void +trace_intel_context_deregister_done(struct intel_context *ce) +{ +} + +static inline void +trace_intel_context_sched_enable(struct intel_context *ce) +{ +} + +static inline void +trace_intel_context_sched_disable(struct intel_context *ce) +{ +} + +static inline void +trace_intel_context_sched_done(struct intel_context *ce) +{ +} + +static inline void +trace_intel_context_create(struct intel_context *ce) +{ +} + +static inline void +trace_intel_context_fence_release(struct intel_context *ce) +{ +} + +static inline void +trace_intel_context_free(struct intel_context *ce) +{ +} + +static inline void +trace_intel_context_steal_guc_id(struct intel_context *ce) +{ +} + +static inline void +trace_intel_context_do_pin(struct intel_context *ce) +{ +} + +static inline void +trace_intel_context_do_unpin(struct intel_context *ce) +{ +} #endif #endif diff --git a/drivers/gpu/drm/i915/selftests/i915_request.c b/drivers/gpu/drm/i915/selftests/i915_request.c index bd5c96a77ba3..d67710d10615 100644 --- a/drivers/gpu/drm/i915/selftests/i915_request.c +++ b/drivers/gpu/drm/i915/selftests/i915_request.c @@ -1313,7 +1313,7 @@ static int __live_parallel_engine1(void *arg) i915_request_add(rq); err = 0; - if (i915_request_wait(rq, 0, HZ / 5) < 0) + if (i915_request_wait(rq, 0, HZ) < 0) err = -ETIME; i915_request_put(rq); if (err) @@ -1419,7 +1419,7 @@ static int __live_parallel_spin(void *arg) } igt_spinner_end(&spin); - if (err == 0 && i915_request_wait(rq, 0, HZ / 5) < 0) + if (err == 0 && i915_request_wait(rq, 0, HZ) < 0) err = -EIO; i915_request_put(rq); diff --git a/drivers/gpu/drm/i915/selftests/igt_flush_test.c b/drivers/gpu/drm/i915/selftests/igt_flush_test.c index 7b0939e3f007..a6c71fca61aa 100644 --- a/drivers/gpu/drm/i915/selftests/igt_flush_test.c +++ b/drivers/gpu/drm/i915/selftests/igt_flush_test.c @@ -19,7 +19,7 @@ int igt_flush_test(struct drm_i915_private *i915) cond_resched(); - if (intel_gt_wait_for_idle(gt, HZ / 5) == -ETIME) { + if (intel_gt_wait_for_idle(gt, HZ) == -ETIME) { pr_err("%pS timed out, cancelling all further testing.\n", __builtin_return_address(0)); diff --git a/drivers/gpu/drm/i915/selftests/igt_live_test.c b/drivers/gpu/drm/i915/selftests/igt_live_test.c index c130010a7033..1c721542e277 100644 --- a/drivers/gpu/drm/i915/selftests/igt_live_test.c +++ b/drivers/gpu/drm/i915/selftests/igt_live_test.c @@ -5,7 +5,7 @@ */ #include "i915_drv.h" -#include "gt/intel_gt_requests.h" +#include "gt/intel_gt.h" #include "../i915_selftest.h" #include "igt_flush_test.h" diff --git a/drivers/gpu/drm/i915/selftests/intel_scheduler_helpers.c b/drivers/gpu/drm/i915/selftests/intel_scheduler_helpers.c new file mode 100644 index 000000000000..ebd6d69b3315 --- /dev/null +++ b/drivers/gpu/drm/i915/selftests/intel_scheduler_helpers.c @@ -0,0 +1,89 @@ +/* + * SPDX-License-Identifier: MIT + * + * Copyright © 2018 Intel Corporation + */ + +//#include "gt/intel_engine_user.h" +#include "gt/intel_gt.h" +#include "i915_drv.h" +#include "i915_selftest.h" + +#include "selftests/intel_scheduler_helpers.h" + +#define REDUCED_TIMESLICE 5 +#define REDUCED_PREEMPT 10 +#define WAIT_FOR_RESET_TIME 10000 + +int intel_selftest_modify_policy(struct intel_engine_cs *engine, + struct intel_selftest_saved_policy *saved, + u32 modify_type) + +{ + int err; + + saved->reset = engine->i915->params.reset; + saved->flags = engine->flags; + saved->timeslice = engine->props.timeslice_duration_ms; + saved->preempt_timeout = engine->props.preempt_timeout_ms; + + switch (modify_type) { + case SELFTEST_SCHEDULER_MODIFY_FAST_RESET: + /* + * Enable force pre-emption on time slice expiration + * together with engine reset on pre-emption timeout. + * This is required to make the GuC notice and reset + * the single hanging context. + * Also, reduce the preemption timeout to something + * small to speed the test up. + */ + engine->i915->params.reset = 2; + engine->flags |= I915_ENGINE_WANT_FORCED_PREEMPTION; + engine->props.timeslice_duration_ms = REDUCED_TIMESLICE; + engine->props.preempt_timeout_ms = REDUCED_PREEMPT; + break; + + case SELFTEST_SCHEDULER_MODIFY_NO_HANGCHECK: + engine->props.preempt_timeout_ms = 0; + break; + + default: + pr_err("Invalid scheduler policy modification type: %d!\n", modify_type); + return -EINVAL; + } + + if (!intel_engine_uses_guc(engine)) + return 0; + + err = intel_guc_global_policies_update(&engine->gt->uc.guc); + if (err) + intel_selftest_restore_policy(engine, saved); + + return err; +} + +int intel_selftest_restore_policy(struct intel_engine_cs *engine, + struct intel_selftest_saved_policy *saved) +{ + /* Restore the original policies */ + engine->i915->params.reset = saved->reset; + engine->flags = saved->flags; + engine->props.timeslice_duration_ms = saved->timeslice; + engine->props.preempt_timeout_ms = saved->preempt_timeout; + + if (!intel_engine_uses_guc(engine)) + return 0; + + return intel_guc_global_policies_update(&engine->gt->uc.guc); +} + +int intel_selftest_wait_for_rq(struct i915_request *rq) +{ + long ret; + + ret = i915_request_wait(rq, 0, WAIT_FOR_RESET_TIME); + if (ret < 0) + return ret; + + return 0; +} diff --git a/drivers/gpu/drm/i915/selftests/intel_scheduler_helpers.h b/drivers/gpu/drm/i915/selftests/intel_scheduler_helpers.h new file mode 100644 index 000000000000..050bc5a8ba8b --- /dev/null +++ b/drivers/gpu/drm/i915/selftests/intel_scheduler_helpers.h @@ -0,0 +1,35 @@ +/* SPDX-License-Identifier: MIT */ +/* + * Copyright © 2014-2019 Intel Corporation + */ + +#ifndef _INTEL_SELFTEST_SCHEDULER_HELPERS_H_ +#define _INTEL_SELFTEST_SCHEDULER_HELPERS_H_ + +#include + +struct i915_request; +struct intel_engine_cs; + +struct intel_selftest_saved_policy +{ + u32 flags; + u32 reset; + u64 timeslice; + u64 preempt_timeout; +}; + +enum selftest_scheduler_modify +{ + SELFTEST_SCHEDULER_MODIFY_NO_HANGCHECK = 0, + SELFTEST_SCHEDULER_MODIFY_FAST_RESET, +}; + +int intel_selftest_modify_policy(struct intel_engine_cs *engine, + struct intel_selftest_saved_policy *saved, + enum selftest_scheduler_modify modify_type); +int intel_selftest_restore_policy(struct intel_engine_cs *engine, + struct intel_selftest_saved_policy *saved); +int intel_selftest_wait_for_rq( struct i915_request *rq); + +#endif diff --git a/drivers/gpu/drm/i915/selftests/mock_gem_device.c b/drivers/gpu/drm/i915/selftests/mock_gem_device.c index d189c4bd4bef..4f8180146888 100644 --- a/drivers/gpu/drm/i915/selftests/mock_gem_device.c +++ b/drivers/gpu/drm/i915/selftests/mock_gem_device.c @@ -52,7 +52,8 @@ void mock_device_flush(struct drm_i915_private *i915) do { for_each_engine(engine, gt, id) mock_engine_flush(engine); - } while (intel_gt_retire_requests_timeout(gt, MAX_SCHEDULE_TIMEOUT)); + } while (intel_gt_retire_requests_timeout(gt, MAX_SCHEDULE_TIMEOUT, + NULL)); } static void mock_device_release(struct drm_device *dev) diff --git a/include/uapi/drm/i915_drm.h b/include/uapi/drm/i915_drm.h index e20eeeca7a1c..44919d0848a0 100644 --- a/include/uapi/drm/i915_drm.h +++ b/include/uapi/drm/i915_drm.h @@ -572,6 +572,15 @@ typedef struct drm_i915_irq_wait { #define I915_SCHEDULER_CAP_PREEMPTION (1ul << 2) #define I915_SCHEDULER_CAP_SEMAPHORES (1ul << 3) #define I915_SCHEDULER_CAP_ENGINE_BUSY_STATS (1ul << 4) +/* + * Indicates the 2k user priority levels are statically mapped into 3 buckets as + * follows: + * + * -1k to -1 Low priority + * 0 Normal priority + * 1 to 1k Highest priority + */ +#define I915_SCHEDULER_CAP_STATIC_PRIORITY_MAP (1ul << 5) #define I915_PARAM_HUC_STATUS 42 -- 2.28.0