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 94B94C636CE for ; Tue, 20 Jul 2021 20:40:53 +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 50AC460FEA for ; Tue, 20 Jul 2021 20:40:53 +0000 (UTC) DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org 50AC460FEA 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 5BB1B6E52A; Tue, 20 Jul 2021 20:40:25 +0000 (UTC) Received: from mga05.intel.com (mga05.intel.com [192.55.52.43]) by gabe.freedesktop.org (Postfix) with ESMTPS id F05FF6E4F1; Tue, 20 Jul 2021 20:40:16 +0000 (UTC) X-IronPort-AV: E=McAfee;i="6200,9189,10051"; a="296885365" X-IronPort-AV: E=Sophos;i="5.84,256,1620716400"; d="scan'208";a="296885365" Received: from orsmga006.jf.intel.com ([10.7.209.51]) by fmsmga105.fm.intel.com with ESMTP/TLS/ECDHE-RSA-AES256-GCM-SHA384; 20 Jul 2021 13:40:16 -0700 X-IronPort-AV: E=Sophos;i="5.84,256,1620716400"; d="scan'208";a="414906061" 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:15 -0700 From: Matthew Brost To: , Date: Tue, 20 Jul 2021 13:57:26 -0700 Message-Id: <20210720205802.39610-7-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 06/42] drm/i915/guc: Introduce guc_submit_engine object 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" TW92ZSBmaWVsZHMgcmVsYXRlZCB0byBjb250cm9sbGluZyB0aGUgR3VDIHN1Ym1pc3Npb24gc3Rh dGUgbWFjaGluZSB0byBhCnVuaXF1ZSBvYmplY3QgKGd1Y19zdWJtaXRfZW5naW5lKSByYXRoZXIg dGhhbiB0aGUgZ2xvYmFsIEd1QyBzdGF0ZQooaW50ZWxfZ3VjKS4gVGhpcyBlbmNhcHN1bGF0aW9u IGFsbG93cyBtdWx0aXBsZSBpbnN0YW5jZXMgb2Ygc3VibWlzc2lvbgpvYmplY3RzIHRvIG9wZXJh dGUgaW4gcGFyYWxsZWwgYW5kIGEgc2luZ2xlIGluc3RhbmNlIGNhbiBibG9jayBpZiBuZWVkZWQK d2hpbGUgYW5vdGhlciBjYW4gbWFrZSBmb3J3YXJkIHByb2dyZXNzLiBUaGlzIGlzIGFuYWxvZ291 cyB0byBob3cgdGhlCmV4ZWNsaXN0IG1vZGUgd29ya3MgYXNzaWduaW5nIGEgc2NoZWR1bGUgb2Jq ZWN0IHBlciBwaHlzaWNhbCBlbmdpbmUgYnV0CnJhdGhlciBpbiBHdUMgbW9kZSB3ZSBhc3NpZ24g YSBzY2hlZHVsZSBvYmplY3QgYmFzZWQgb24gdGhlIGJsb2NraW5nCmRlcGVuZGVuY2llcy4KClRo ZSBndWNfc3VibWl0X2VuZ2luZSBvYmplY3QgYWxzbyBlbmNhcHN1bGF0ZXMgdGhlIGk5MTVfc2No ZWRfZW5naW5lCm9iamVjdCBhcyB3ZWxsLgoKTG90cyBvZiBmaW5kLXJlcGxhY2UuCgpDdXJyZW50 bHkgb25seSAxIGd1Y19zdWJtaXRfZW5naW5lIGluc3RhbnRpYXRlZCwgZnV0dXJlIHBhdGNoZXMg d2lsbAppbnN0YW50aWF0ZSBtb3JlLgoKU2lnbmVkLW9mZi1ieTogTWF0dGhldyBCcm9zdCA8bWF0 dGhldy5icm9zdEBpbnRlbC5jb20+CkNjOiBKb2huIEhhcnJpc29uIDxKb2huLkMuSGFycmlzb25A SW50ZWwuY29tPgotLS0KIGRyaXZlcnMvZ3B1L2RybS9pOTE1L2d0L3VjL2ludGVsX2d1Yy5oICAg ICAgICB8ICAzMyArLQogLi4uL2dwdS9kcm0vaTkxNS9ndC91Yy9pbnRlbF9ndWNfc3VibWlzc2lv bi5jIHwgNTU1ICsrKysrKysrKysrLS0tLS0tLQogLi4uL2k5MTUvZ3QvdWMvaW50ZWxfZ3VjX3N1 Ym1pc3Npb25fdHlwZXMuaCAgIHwgIDUyICsrCiBkcml2ZXJzL2dwdS9kcm0vaTkxNS9pOTE1X3Nj aGVkdWxlci5jICAgICAgICAgfCAgMjIgKy0KIGRyaXZlcnMvZ3B1L2RybS9pOTE1L2k5MTVfc2No ZWR1bGVyLmggICAgICAgICB8ICAgMyArCiA1IGZpbGVzIGNoYW5nZWQsIDQwOSBpbnNlcnRpb25z KCspLCAyNTYgZGVsZXRpb25zKC0pCiBjcmVhdGUgbW9kZSAxMDA2NDQgZHJpdmVycy9ncHUvZHJt L2k5MTUvZ3QvdWMvaW50ZWxfZ3VjX3N1Ym1pc3Npb25fdHlwZXMuaAoKZGlmZiAtLWdpdCBhL2Ry aXZlcnMvZ3B1L2RybS9pOTE1L2d0L3VjL2ludGVsX2d1Yy5oIGIvZHJpdmVycy9ncHUvZHJtL2k5 MTUvZ3QvdWMvaW50ZWxfZ3VjLmgKaW5kZXggNzQ0ODFjN2NmMzQ5Li5lMjc4YWQzNzY5ODYgMTAw NjQ0Ci0tLSBhL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2d0L3VjL2ludGVsX2d1Yy5oCisrKyBiL2Ry aXZlcnMvZ3B1L2RybS9pOTE1L2d0L3VjL2ludGVsX2d1Yy5oCkBAIC0yMSw2ICsyMSwxMSBAQAog CiBzdHJ1Y3QgX19ndWNfYWRzX2Jsb2I7CiAKK2VudW0geworCUdVQ19TVUJNSVRfRU5HSU5FX1NJ TkdMRV9MUkMsCisJR1VDX1NVQk1JVF9FTkdJTkVfTUFYCit9OworCiAvKgogICogVG9wIGxldmVs IHN0cnVjdHVyZSBvZiBHdUMuIEl0IGhhbmRsZXMgZmlybXdhcmUgbG9hZGluZyBhbmQgbWFuYWdl cyBjbGllbnQKICAqIHBvb2wuIGludGVsX2d1YyBvd25zIGEgaW50ZWxfZ3VjX2NsaWVudCB0byBy ZXBsYWNlIHRoZSBsZWdhY3kgRXhlY0xpc3QKQEAgLTMxLDMxICszNiw2IEBAIHN0cnVjdCBpbnRl bF9ndWMgewogCXN0cnVjdCBpbnRlbF9ndWNfbG9nIGxvZzsKIAlzdHJ1Y3QgaW50ZWxfZ3VjX2N0 IGN0OwogCi0JLyogR2xvYmFsIGVuZ2luZSB1c2VkIHRvIHN1Ym1pdCByZXF1ZXN0cyB0byBHdUMg Ki8KLQlzdHJ1Y3QgaTkxNV9zY2hlZF9lbmdpbmUgKnNjaGVkX2VuZ2luZTsKLQotCS8qIEdsb2Jh bCBzdGF0ZSByZWxhdGVkIHRvIHN1Ym1pc3Npb24gdGFza2xldCAqLwotCXN0cnVjdCBpOTE1X3Jl cXVlc3QgKnN0YWxsZWRfcnE7Ci0Jc3RydWN0IGludGVsX2NvbnRleHQgKnN0YWxsZWRfY29udGV4 dDsKLQlzdHJ1Y3Qgd29ya19zdHJ1Y3QgcmV0aXJlX3dvcmtlcjsKLQl1bnNpZ25lZCBsb25nIGZs YWdzOwotCWludCB0b3RhbF9udW1fcnFfd2l0aF9ub19ndWNfaWQ7Ci0KLQkvKgotCSAqIFN1Ym1p c3NvbiBzdGFsbCByZWFzb24uIFNlZSBpbnRlbF9ndWNfc3VibWlzc2lvbi5jIGZvciBkZXRhaWxl ZAotCSAqIGRlc2NyaXB0aW9uLgotCSAqLwotCWVudW0gewotCQlTVEFMTF9OT05FLAotCQlTVEFM TF9HVUNfSURfV09SS1FVRVVFLAotCQlTVEFMTF9HVUNfSURfVEFTS0xFVCwKLQkJU1RBTExfU0NI RURfRElTQUJMRSwKLQkJU1RBTExfUkVHSVNURVJfQ09OVEVYVCwKLQkJU1RBTExfREVSRUdJU1RF Ul9DT05URVhULAotCQlTVEFMTF9NT1ZFX0xSQ19UQUlMLAotCQlTVEFMTF9BRERfUkVRVUVTVCwK LQl9IHN1Ym1pc3Npb25fc3RhbGxfcmVhc29uOwotCiAJLyogaW50ZWxfZ3VjX3JlY3YgaW50ZXJy dXB0IHJlbGF0ZWQgc3RhdGUgKi8KIAlzcGlubG9ja190IGlycV9sb2NrOwogCXVuc2lnbmVkIGlu dCBtc2dfZW5hYmxlZF9tYXNrOwpAQCAtNjgsNiArNDgsOCBAQCBzdHJ1Y3QgaW50ZWxfZ3VjIHsK IAkJdm9pZCAoKmRpc2FibGUpKHN0cnVjdCBpbnRlbF9ndWMgKmd1Yyk7CiAJfSBpbnRlcnJ1cHRz OwogCisJc3RydWN0IGd1Y19zdWJtaXRfZW5naW5lICpnc2VbR1VDX1NVQk1JVF9FTkdJTkVfTUFY XTsKKwogCS8qCiAJICogY29udGV4dHNfbG9jayBwcm90ZWN0cyB0aGUgcG9vbCBvZiBmcmVlIGd1 YyBpZHMgYW5kIGEgbGlua2VkIGxpc3Qgb2YKIAkgKiBndWMgaWRzIGF2YWlsYWJsZSB0byBiZSBz dG9sZW4KQEAgLTc2LDcgKzU4LDYgQEAgc3RydWN0IGludGVsX2d1YyB7CiAJc3RydWN0IGlkYSBn dWNfaWRzOwogCXUzMiBudW1fZ3VjX2lkczsKIAl1MzIgbWF4X2d1Y19pZHM7Ci0JYXRvbWljX3Qg bnVtX2d1Y19pZHNfbm90X3JlYWR5OwogCXN0cnVjdCBsaXN0X2hlYWQgZ3VjX2lkX2xpc3Rfbm9f cmVmOwogCXN0cnVjdCBsaXN0X2hlYWQgZ3VjX2lkX2xpc3RfdW5waW5uZWQ7CiAKZGlmZiAtLWdp dCBhL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2d0L3VjL2ludGVsX2d1Y19zdWJtaXNzaW9uLmMgYi9k cml2ZXJzL2dwdS9kcm0vaTkxNS9ndC91Yy9pbnRlbF9ndWNfc3VibWlzc2lvbi5jCmluZGV4IDZi MWU1NTNhMGU5OS4uZmNlNWMxZDhjZmRhIDEwMDY0NAotLS0gYS9kcml2ZXJzL2dwdS9kcm0vaTkx NS9ndC91Yy9pbnRlbF9ndWNfc3VibWlzc2lvbi5jCisrKyBiL2RyaXZlcnMvZ3B1L2RybS9pOTE1 L2d0L3VjL2ludGVsX2d1Y19zdWJtaXNzaW9uLmMKQEAgLTIxLDYgKzIxLDcgQEAKICNpbmNsdWRl ICJndC9pbnRlbF9yaW5nLmgiCiAKICNpbmNsdWRlICJpbnRlbF9ndWNfc3VibWlzc2lvbi5oIgor I2luY2x1ZGUgImludGVsX2d1Y19zdWJtaXNzaW9uX3R5cGVzLmgiCiAKICNpbmNsdWRlICJpOTE1 X2Rydi5oIgogI2luY2x1ZGUgImk5MTVfdHJhY2UuaCIKQEAgLTU3LDcgKzU4LDcgQEAKICAqIFdR X1RZUEVfSU5PUkRFUiBpcyBuZWVkZWQgdG8gc3VwcG9ydCBsZWdhY3kgc3VibWlzc2lvbiB2aWEg R3VDLCB3aGljaAogICogcmVwcmVzZW50cyBpbi1vcmRlciBxdWV1ZS4gVGhlIGtlcm5lbCBkcml2 ZXIgcGFja3MgcmluZyB0YWlsIHBvaW50ZXIgYW5kIGFuCiAgKiBFTFNQIGNvbnRleHQgZGVzY3Jp cHRvciBkd29yZCBpbnRvIFdvcmsgSXRlbS4KLSAqIFNlZSBndWNfYWRkX3JlcXVlc3QoKQorICog U2VlIGdzZV9hZGRfcmVxdWVzdCgpCiAgKgogICogR3VDIGZsb3cgY29udHJvbCBzdGF0ZSBtYWNo aW5lOgogICogVGhlIHRhc2tsZXQsIHdvcmtxdWV1ZSAocmV0aXJlX3dvcmtlciksIGFuZCB0aGUg RzJIIGhhbmRsZXJzIHRvZ2V0aGVyIG1vcmUgb3IKQEAgLTgwLDU3ICs4MSw1NyBAQAogICoJCQkJ Y29udGV4dCkKICAqLwogCi0vKiBHdUMgVmlydHVhbCBFbmdpbmUgKi8KLXN0cnVjdCBndWNfdmly dHVhbF9lbmdpbmUgewotCXN0cnVjdCBpbnRlbF9lbmdpbmVfY3MgYmFzZTsKLQlzdHJ1Y3QgaW50 ZWxfY29udGV4dCBjb250ZXh0OwotfTsKLQogc3RhdGljIHN0cnVjdCBpbnRlbF9jb250ZXh0ICoK IGd1Y19jcmVhdGVfdmlydHVhbChzdHJ1Y3QgaW50ZWxfZW5naW5lX2NzICoqc2libGluZ3MsIHVu c2lnbmVkIGludCBjb3VudCk7CiAKICNkZWZpbmUgR1VDX1JFUVVFU1RfU0laRSA2NCAvKiBieXRl cyAqLwogCitzdGF0aWMgaW5saW5lIHN0cnVjdCBndWNfc3VibWl0X2VuZ2luZSAqY2VfdG9fZ3Nl KHN0cnVjdCBpbnRlbF9jb250ZXh0ICpjZSkKK3sKKwlyZXR1cm4gY29udGFpbmVyX29mKGNlLT5l bmdpbmUtPnNjaGVkX2VuZ2luZSwgc3RydWN0IGd1Y19zdWJtaXRfZW5naW5lLAorCQkJICAgIHNj aGVkX2VuZ2luZSk7Cit9CisKIC8qCiAgKiBHbG9iYWwgR3VDIGZsYWdzIGhlbHBlciBmdW5jdGlv bnMKICAqLwogZW51bSB7Ci0JR1VDX1NUQVRFX1RBU0tMRVRfQkxPQ0tFRCwKLQlHVUNfU1RBVEVf R1VDX0lEU19FWEhBVVNURUQsCisJR1NFX1NUQVRFX1RBU0tMRVRfQkxPQ0tFRCwKKwlHU0VfU1RB VEVfR1VDX0lEU19FWEhBVVNURUQsCiB9OwogCi1zdGF0aWMgYm9vbCB0YXNrbGV0X2Jsb2NrZWQo c3RydWN0IGludGVsX2d1YyAqZ3VjKQorc3RhdGljIGJvb2wgdGFza2xldF9ibG9ja2VkKHN0cnVj dCBndWNfc3VibWl0X2VuZ2luZSAqZ3NlKQogewotCXJldHVybiB0ZXN0X2JpdChHVUNfU1RBVEVf VEFTS0xFVF9CTE9DS0VELCAmZ3VjLT5mbGFncyk7CisJcmV0dXJuIHRlc3RfYml0KEdTRV9TVEFU RV9UQVNLTEVUX0JMT0NLRUQsICZnc2UtPmZsYWdzKTsKIH0KIAotc3RhdGljIHZvaWQgc2V0X3Rh c2tsZXRfYmxvY2tlZChzdHJ1Y3QgaW50ZWxfZ3VjICpndWMpCitzdGF0aWMgdm9pZCBzZXRfdGFz a2xldF9ibG9ja2VkKHN0cnVjdCBndWNfc3VibWl0X2VuZ2luZSAqZ3NlKQogewotCWxvY2tkZXBf YXNzZXJ0X2hlbGQoJmd1Yy0+c2NoZWRfZW5naW5lLT5sb2NrKTsKLQlzZXRfYml0KEdVQ19TVEFU RV9UQVNLTEVUX0JMT0NLRUQsICZndWMtPmZsYWdzKTsKKwlsb2NrZGVwX2Fzc2VydF9oZWxkKCZn c2UtPnNjaGVkX2VuZ2luZS5sb2NrKTsKKwlzZXRfYml0KEdTRV9TVEFURV9UQVNLTEVUX0JMT0NL RUQsICZnc2UtPmZsYWdzKTsKIH0KIAotc3RhdGljIHZvaWQgX19jbHJfdGFza2xldF9ibG9ja2Vk KHN0cnVjdCBpbnRlbF9ndWMgKmd1YykKK3N0YXRpYyB2b2lkIF9fY2xyX3Rhc2tsZXRfYmxvY2tl ZChzdHJ1Y3QgZ3VjX3N1Ym1pdF9lbmdpbmUgKmdzZSkKIHsKLQlsb2NrZGVwX2Fzc2VydF9oZWxk KCZndWMtPnNjaGVkX2VuZ2luZS0+bG9jayk7Ci0JY2xlYXJfYml0KEdVQ19TVEFURV9UQVNLTEVU X0JMT0NLRUQsICZndWMtPmZsYWdzKTsKKwlsb2NrZGVwX2Fzc2VydF9oZWxkKCZnc2UtPnNjaGVk X2VuZ2luZS5sb2NrKTsKKwljbGVhcl9iaXQoR1NFX1NUQVRFX1RBU0tMRVRfQkxPQ0tFRCwgJmdz ZS0+ZmxhZ3MpOwogfQogCi1zdGF0aWMgdm9pZCBjbHJfdGFza2xldF9ibG9ja2VkKHN0cnVjdCBp bnRlbF9ndWMgKmd1YykKK3N0YXRpYyB2b2lkIGNscl90YXNrbGV0X2Jsb2NrZWQoc3RydWN0IGd1 Y19zdWJtaXRfZW5naW5lICpnc2UpCiB7CiAJdW5zaWduZWQgbG9uZyBmbGFnczsKIAotCXNwaW5f bG9ja19pcnFzYXZlKCZndWMtPnNjaGVkX2VuZ2luZS0+bG9jaywgZmxhZ3MpOwotCV9fY2xyX3Rh c2tsZXRfYmxvY2tlZChndWMpOwotCXNwaW5fdW5sb2NrX2lycXJlc3RvcmUoJmd1Yy0+c2NoZWRf ZW5naW5lLT5sb2NrLCBmbGFncyk7CisJc3Bpbl9sb2NrX2lycXNhdmUoJmdzZS0+c2NoZWRfZW5n aW5lLmxvY2ssIGZsYWdzKTsKKwlfX2Nscl90YXNrbGV0X2Jsb2NrZWQoZ3NlKTsKKwlzcGluX3Vu bG9ja19pcnFyZXN0b3JlKCZnc2UtPnNjaGVkX2VuZ2luZS5sb2NrLCBmbGFncyk7CiB9CiAKLXN0 YXRpYyBib29sIGd1Y19pZHNfZXhoYXVzdGVkKHN0cnVjdCBpbnRlbF9ndWMgKmd1YykKK3N0YXRp YyBib29sIGd1Y19pZHNfZXhoYXVzdGVkKHN0cnVjdCBndWNfc3VibWl0X2VuZ2luZSAqZ3NlKQog ewotCXJldHVybiB0ZXN0X2JpdChHVUNfU1RBVEVfR1VDX0lEU19FWEhBVVNURUQsICZndWMtPmZs YWdzKTsKKwlyZXR1cm4gdGVzdF9iaXQoR1NFX1NUQVRFX0dVQ19JRFNfRVhIQVVTVEVELCAmZ3Nl LT5mbGFncyk7CiB9CiAKLXN0YXRpYyBib29sIHRlc3RfYW5kX3VwZGF0ZV9ndWNfaWRzX2V4aGF1 c3RlZChzdHJ1Y3QgaW50ZWxfZ3VjICpndWMpCitzdGF0aWMgYm9vbCB0ZXN0X2FuZF91cGRhdGVf Z3VjX2lkc19leGhhdXN0ZWQoc3RydWN0IGd1Y19zdWJtaXRfZW5naW5lICpnc2UpCiB7CiAJdW5z aWduZWQgbG9uZyBmbGFnczsKIAlib29sIHJldCA9IGZhbHNlOwpAQCAtMTM5LDMzICsxNDAsMzMg QEAgc3RhdGljIGJvb2wgdGVzdF9hbmRfdXBkYXRlX2d1Y19pZHNfZXhoYXVzdGVkKHN0cnVjdCBp bnRlbF9ndWMgKmd1YykKIAkgKiBTdHJpY3Qgb3JkZXJpbmcgb24gY2hlY2tpbmcgaWYgZ3VjX2lk cyBhcmUgZXhoYXVzdGVkIGlzbid0IHJlcXVpcmVkLAogCSAqIHNvIGxldCdzIGF2b2lkIGdyYWJi aW5nIHRoZSBzdWJtaXNzaW9uIGxvY2sgaWYgcG9zc2libGUuCiAJICovCi0JaWYgKGd1Y19pZHNf ZXhoYXVzdGVkKGd1YykpIHsKLQkJc3Bpbl9sb2NrX2lycXNhdmUoJmd1Yy0+c2NoZWRfZW5naW5l LT5sb2NrLCBmbGFncyk7Ci0JCXJldCA9IGd1Y19pZHNfZXhoYXVzdGVkKGd1Yyk7CisJaWYgKGd1 Y19pZHNfZXhoYXVzdGVkKGdzZSkpIHsKKwkJc3Bpbl9sb2NrX2lycXNhdmUoJmdzZS0+c2NoZWRf ZW5naW5lLmxvY2ssIGZsYWdzKTsKKwkJcmV0ID0gZ3VjX2lkc19leGhhdXN0ZWQoZ3NlKTsKIAkJ aWYgKHJldCkKLQkJCSsrZ3VjLT50b3RhbF9udW1fcnFfd2l0aF9ub19ndWNfaWQ7Ci0JCXNwaW5f dW5sb2NrX2lycXJlc3RvcmUoJmd1Yy0+c2NoZWRfZW5naW5lLT5sb2NrLCBmbGFncyk7CisJCQkr K2dzZS0+dG90YWxfbnVtX3JxX3dpdGhfbm9fZ3VjX2lkOworCQlzcGluX3VubG9ja19pcnFyZXN0 b3JlKCZnc2UtPnNjaGVkX2VuZ2luZS5sb2NrLCBmbGFncyk7CiAJfQogCiAJcmV0dXJuIHJldDsK IH0KIAotc3RhdGljIHZvaWQgc2V0X2FuZF91cGRhdGVfZ3VjX2lkc19leGhhdXN0ZWQoc3RydWN0 IGludGVsX2d1YyAqZ3VjKQorc3RhdGljIHZvaWQgc2V0X2FuZF91cGRhdGVfZ3VjX2lkc19leGhh dXN0ZWQoc3RydWN0IGd1Y19zdWJtaXRfZW5naW5lICpnc2UpCiB7CiAJdW5zaWduZWQgbG9uZyBm bGFnczsKIAotCXNwaW5fbG9ja19pcnFzYXZlKCZndWMtPnNjaGVkX2VuZ2luZS0+bG9jaywgZmxh Z3MpOwotCSsrZ3VjLT50b3RhbF9udW1fcnFfd2l0aF9ub19ndWNfaWQ7Ci0Jc2V0X2JpdChHVUNf U1RBVEVfR1VDX0lEU19FWEhBVVNURUQsICZndWMtPmZsYWdzKTsKLQlzcGluX3VubG9ja19pcnFy ZXN0b3JlKCZndWMtPnNjaGVkX2VuZ2luZS0+bG9jaywgZmxhZ3MpOworCXNwaW5fbG9ja19pcnFz YXZlKCZnc2UtPnNjaGVkX2VuZ2luZS5sb2NrLCBmbGFncyk7CisJKytnc2UtPnRvdGFsX251bV9y cV93aXRoX25vX2d1Y19pZDsKKwlzZXRfYml0KEdTRV9TVEFURV9HVUNfSURTX0VYSEFVU1RFRCwg JmdzZS0+ZmxhZ3MpOworCXNwaW5fdW5sb2NrX2lycXJlc3RvcmUoJmdzZS0+c2NoZWRfZW5naW5l LmxvY2ssIGZsYWdzKTsKIH0KIAotc3RhdGljIHZvaWQgY2xyX2d1Y19pZHNfZXhoYXVzdGVkKHN0 cnVjdCBpbnRlbF9ndWMgKmd1YykKK3N0YXRpYyB2b2lkIGNscl9ndWNfaWRzX2V4aGF1c3RlZChz dHJ1Y3QgZ3VjX3N1Ym1pdF9lbmdpbmUgKmdzZSkKIHsKLQlsb2NrZGVwX2Fzc2VydF9oZWxkKCZn dWMtPnNjaGVkX2VuZ2luZS0+bG9jayk7Ci0JR0VNX0JVR19PTihndWMtPnRvdGFsX251bV9ycV93 aXRoX25vX2d1Y19pZCk7CisJbG9ja2RlcF9hc3NlcnRfaGVsZCgmZ3NlLT5zY2hlZF9lbmdpbmUu bG9jayk7CisJR0VNX0JVR19PTihnc2UtPnRvdGFsX251bV9ycV93aXRoX25vX2d1Y19pZCk7CiAK LQljbGVhcl9iaXQoR1VDX1NUQVRFX0dVQ19JRFNfRVhIQVVTVEVELCAmZ3VjLT5mbGFncyk7CisJ Y2xlYXJfYml0KEdTRV9TVEFURV9HVUNfSURTX0VYSEFVU1RFRCwgJmdzZS0+ZmxhZ3MpOwogfQog CiAvKgpAQCAtNDE2LDYgKzQxNywyMCBAQCBzdGF0aWMgaW5saW5lIHN0cnVjdCBpbnRlbF9ndWMg KmNlX3RvX2d1YyhzdHJ1Y3QgaW50ZWxfY29udGV4dCAqY2UpCiAJcmV0dXJuICZjZS0+ZW5naW5l LT5ndC0+dWMuZ3VjOwogfQogCitzdGF0aWMgaW5saW5lIHN0cnVjdCBpOTE1X3NjaGVkX2VuZ2lu ZSAqCitjZV90b19zY2hlZF9lbmdpbmUoc3RydWN0IGludGVsX2NvbnRleHQgKmNlKQoreworCXJl dHVybiBjZS0+ZW5naW5lLT5zY2hlZF9lbmdpbmU7Cit9CisKK3N0YXRpYyBpbmxpbmUgc3RydWN0 IGk5MTVfc2NoZWRfZW5naW5lICoKK2d1Y190b19zY2hlZF9lbmdpbmUoc3RydWN0IGludGVsX2d1 YyAqZ3VjLCBpbnQgaW5kZXgpCit7CisJR0VNX0JVR19PTihpbmRleCA8IDAgfHwgaW5kZXggPj0g R1VDX1NVQk1JVF9FTkdJTkVfTUFYKTsKKworCXJldHVybiAmZ3VjLT5nc2VbaW5kZXhdLT5zY2hl ZF9lbmdpbmU7Cit9CisKIHN0YXRpYyBpbmxpbmUgc3RydWN0IGk5MTVfcHJpb2xpc3QgKnRvX3By aW9saXN0KHN0cnVjdCByYl9ub2RlICpyYikKIHsKIAlyZXR1cm4gcmJfZW50cnkocmIsIHN0cnVj dCBpOTE1X3ByaW9saXN0LCBub2RlKTsKQEAgLTYzNywxOSArNjUyLDIwIEBAIHN0YXRpYyBpbnQg X19ndWNfYWRkX3JlcXVlc3Qoc3RydWN0IGludGVsX2d1YyAqZ3VjLCBzdHJ1Y3QgaTkxNV9yZXF1 ZXN0ICpycSkKIAlyZXR1cm4gZXJyOwogfQogCi1zdGF0aWMgaW50IGd1Y19hZGRfcmVxdWVzdChz dHJ1Y3QgaW50ZWxfZ3VjICpndWMsIHN0cnVjdCBpOTE1X3JlcXVlc3QgKnJxKQorc3RhdGljIGlu dCBnc2VfYWRkX3JlcXVlc3Qoc3RydWN0IGd1Y19zdWJtaXRfZW5naW5lICpnc2UsCisJCQkgICBz dHJ1Y3QgaTkxNV9yZXF1ZXN0ICpycSkKIHsKIAlpbnQgcmV0OwogCi0JbG9ja2RlcF9hc3NlcnRf aGVsZCgmZ3VjLT5zY2hlZF9lbmdpbmUtPmxvY2spOworCWxvY2tkZXBfYXNzZXJ0X2hlbGQoJmdz ZS0+c2NoZWRfZW5naW5lLmxvY2spOwogCi0JcmV0ID0gX19ndWNfYWRkX3JlcXVlc3QoZ3VjLCBy cSk7CisJcmV0ID0gX19ndWNfYWRkX3JlcXVlc3QoZ3NlLT5zY2hlZF9lbmdpbmUucHJpdmF0ZV9k YXRhLCBycSk7CiAJaWYgKHJldCA9PSAtRUJVU1kpIHsKLQkJZ3VjLT5zdGFsbGVkX3JxID0gcnE7 Ci0JCWd1Yy0+c3VibWlzc2lvbl9zdGFsbF9yZWFzb24gPSBTVEFMTF9BRERfUkVRVUVTVDsKKwkJ Z3NlLT5zdGFsbGVkX3JxID0gcnE7CisJCWdzZS0+c3VibWlzc2lvbl9zdGFsbF9yZWFzb24gPSBT VEFMTF9BRERfUkVRVUVTVDsKIAl9IGVsc2UgewotCQlndWMtPnN0YWxsZWRfcnEgPSBOVUxMOwot CQlndWMtPnN1Ym1pc3Npb25fc3RhbGxfcmVhc29uID0gU1RBTExfTk9ORTsKKwkJZ3NlLT5zdGFs bGVkX3JxID0gTlVMTDsKKwkJZ3NlLT5zdWJtaXNzaW9uX3N0YWxsX3JlYXNvbiA9IFNUQUxMX05P TkU7CiAJfQogCiAJcmV0dXJuIHJldDsKQEAgLTY1NywxNCArNjczLDE1IEBAIHN0YXRpYyBpbnQg Z3VjX2FkZF9yZXF1ZXN0KHN0cnVjdCBpbnRlbF9ndWMgKmd1Yywgc3RydWN0IGk5MTVfcmVxdWVz dCAqcnEpCiAKIHN0YXRpYyBpbnQgZ3VjX2xyY19kZXNjX3BpbihzdHJ1Y3QgaW50ZWxfY29udGV4 dCAqY2UsIGJvb2wgbG9vcCk7CiAKLXN0YXRpYyBpbnQgdGFza2xldF9yZWdpc3Rlcl9jb250ZXh0 KHN0cnVjdCBpbnRlbF9ndWMgKmd1YywKK3N0YXRpYyBpbnQgdGFza2xldF9yZWdpc3Rlcl9jb250 ZXh0KHN0cnVjdCBndWNfc3VibWl0X2VuZ2luZSAqZ3NlLAogCQkJCSAgICBzdHJ1Y3QgaTkxNV9y ZXF1ZXN0ICpycSkKIHsKIAlzdHJ1Y3QgaW50ZWxfY29udGV4dCAqY2UgPSBycS0+Y29udGV4dDsK KwlzdHJ1Y3QgaW50ZWxfZ3VjICpndWMgPSBnc2UtPnNjaGVkX2VuZ2luZS5wcml2YXRlX2RhdGE7 CiAJaW50IHJldCA9IDA7CiAKIAkvKiBDaGVjayBzdGF0ZSAqLwotCWxvY2tkZXBfYXNzZXJ0X2hl bGQoJmd1Yy0+c2NoZWRfZW5naW5lLT5sb2NrKTsKKwlsb2NrZGVwX2Fzc2VydF9oZWxkKCZnc2Ut PnNjaGVkX2VuZ2luZS5sb2NrKTsKIAlHRU1fQlVHX09OKGNlLT5ndWNfbnVtX3JxX3N1Ym1pdF9u b19pZCk7CiAJR0VNX0JVR19PTihyZXF1ZXN0X2hhc19ub19ndWNfaWQocnEpKTsKIAlHRU1fQlVH X09OKGNvbnRleHRfZ3VjX2lkX2ludmFsaWQoY2UpKTsKQEAgLTY4NywxMSArNzA0LDExIEBAIHN0 YXRpYyBpbnQgdGFza2xldF9yZWdpc3Rlcl9jb250ZXh0KHN0cnVjdCBpbnRlbF9ndWMgKmd1YywK IAkJCWNscl9jb250ZXh0X25lZWRzX3JlZ2lzdGVyKGNlKTsKIAogCQlpZiAodW5saWtlbHkocmV0 ID09IC1FQlVTWSkpIHsKLQkJCWd1Yy0+c3RhbGxlZF9ycSA9IHJxOwotCQkJZ3VjLT5zdWJtaXNz aW9uX3N0YWxsX3JlYXNvbiA9IFNUQUxMX1JFR0lTVEVSX0NPTlRFWFQ7CisJCQlnc2UtPnN0YWxs ZWRfcnEgPSBycTsKKwkJCWdzZS0+c3VibWlzc2lvbl9zdGFsbF9yZWFzb24gPSBTVEFMTF9SRUdJ U1RFUl9DT05URVhUOwogCQl9IGVsc2UgaWYgKHVubGlrZWx5KHJldCA9PSAtRUlOUFJPR1JFU1Mp KSB7Ci0JCQlndWMtPnN0YWxsZWRfcnEgPSBycTsKLQkJCWd1Yy0+c3VibWlzc2lvbl9zdGFsbF9y ZWFzb24gPSBTVEFMTF9ERVJFR0lTVEVSX0NPTlRFWFQ7CisJCQlnc2UtPnN0YWxsZWRfcnEgPSBy cTsKKwkJCWdzZS0+c3VibWlzc2lvbl9zdGFsbF9yZWFzb24gPSBTVEFMTF9ERVJFR0lTVEVSX0NP TlRFWFQ7CiAJCX0KIAl9CiAKQEAgLTcxMCwyOCArNzI3LDI5IEBAIHN0YXRpYyBpbmxpbmUgaW50 IHJxX3ByaW8oY29uc3Qgc3RydWN0IGk5MTVfcmVxdWVzdCAqcnEpCiAJcmV0dXJuIHJxLT5zY2hl ZC5hdHRyLnByaW9yaXR5OwogfQogCi1zdGF0aWMgdm9pZCBraWNrX3JldGlyZV93cShzdHJ1Y3Qg aW50ZWxfZ3VjICpndWMpCitzdGF0aWMgdm9pZCBraWNrX3JldGlyZV93cShzdHJ1Y3QgZ3VjX3N1 Ym1pdF9lbmdpbmUgKmdzZSkKIHsKLQlxdWV1ZV93b3JrKHN5c3RlbV91bmJvdW5kX3dxLCAmZ3Vj LT5yZXRpcmVfd29ya2VyKTsKKwlxdWV1ZV93b3JrKHN5c3RlbV91bmJvdW5kX3dxLCAmZ3NlLT5y ZXRpcmVfd29ya2VyKTsKIH0KIAotc3RhdGljIGludCB0YXNrbGV0X3Bpbl9ndWNfaWQoc3RydWN0 IGludGVsX2d1YyAqZ3VjLCBzdHJ1Y3QgaTkxNV9yZXF1ZXN0ICpycSk7CitzdGF0aWMgaW50IHRh c2tsZXRfcGluX2d1Y19pZChzdHJ1Y3QgZ3VjX3N1Ym1pdF9lbmdpbmUgKmdzZSwKKwkJCSAgICAg IHN0cnVjdCBpOTE1X3JlcXVlc3QgKnJxKTsKIAotc3RhdGljIGludCBndWNfZGVxdWV1ZV9vbmVf Y29udGV4dChzdHJ1Y3QgaW50ZWxfZ3VjICpndWMpCitzdGF0aWMgaW50IGdzZV9kZXF1ZXVlX29u ZV9jb250ZXh0KHN0cnVjdCBndWNfc3VibWl0X2VuZ2luZSAqZ3NlKQogewotCXN0cnVjdCBpOTE1 X3NjaGVkX2VuZ2luZSAqIGNvbnN0IHNjaGVkX2VuZ2luZSA9IGd1Yy0+c2NoZWRfZW5naW5lOwot CXN0cnVjdCBpOTE1X3JlcXVlc3QgKmxhc3QgPSBndWMtPnN0YWxsZWRfcnE7CisJc3RydWN0IGk5 MTVfc2NoZWRfZW5naW5lICogY29uc3Qgc2NoZWRfZW5naW5lID0gJmdzZS0+c2NoZWRfZW5naW5l OworCXN0cnVjdCBpOTE1X3JlcXVlc3QgKmxhc3QgPSBnc2UtPnN0YWxsZWRfcnE7CiAJYm9vbCBz dWJtaXQgPSAhIWxhc3Q7CiAJc3RydWN0IHJiX25vZGUgKnJiOwogCWludCByZXQ7CiAKIAlsb2Nr ZGVwX2Fzc2VydF9oZWxkKCZzY2hlZF9lbmdpbmUtPmxvY2spOwotCUdFTV9CVUdfT04oZ3VjLT5z dGFsbGVkX2NvbnRleHQpOwotCUdFTV9CVUdfT04oIXN1Ym1pdCAmJiBndWMtPnN1Ym1pc3Npb25f c3RhbGxfcmVhc29uKTsKKwlHRU1fQlVHX09OKGdzZS0+c3RhbGxlZF9jb250ZXh0KTsKKwlHRU1f QlVHX09OKCFzdWJtaXQgJiYgZ3NlLT5zdWJtaXNzaW9uX3N0YWxsX3JlYXNvbik7CiAKIAlpZiAo c3VibWl0KSB7CiAJCS8qIEZsb3cgY29udHJvbCBjb25kaXRpb25zICovCi0JCXN3aXRjaCAoZ3Vj LT5zdWJtaXNzaW9uX3N0YWxsX3JlYXNvbikgeworCQlzd2l0Y2ggKGdzZS0+c3VibWlzc2lvbl9z dGFsbF9yZWFzb24pIHsKIAkJY2FzZSBTVEFMTF9HVUNfSURfVEFTS0xFVDoKIAkJCWdvdG8gZG9u ZTsKIAkJY2FzZSBTVEFMTF9SRUdJU1RFUl9DT05URVhUOgpAQCAtNzQ0LDggKzc2Miw4IEBAIHN0 YXRpYyBpbnQgZ3VjX2RlcXVldWVfb25lX2NvbnRleHQoc3RydWN0IGludGVsX2d1YyAqZ3VjKQog CQkJR0VNX0JVR19PTigiSW52YWxpZCBzdGFsbCBzdGF0ZSIpOwogCQl9CiAJfSBlbHNlIHsKLQkJ R0VNX0JVR19PTighZ3VjLT50b3RhbF9udW1fcnFfd2l0aF9ub19ndWNfaWQgJiYKLQkJCSAgIGd1 Y19pZHNfZXhoYXVzdGVkKGd1YykpOworCQlHRU1fQlVHX09OKCFnc2UtPnRvdGFsX251bV9ycV93 aXRoX25vX2d1Y19pZCAmJgorCQkJICAgZ3VjX2lkc19leGhhdXN0ZWQoZ3NlKSk7CiAKIAkJd2hp bGUgKChyYiA9IHJiX2ZpcnN0X2NhY2hlZCgmc2NoZWRfZW5naW5lLT5xdWV1ZSkpKSB7CiAJCQlz dHJ1Y3QgaTkxNV9wcmlvbGlzdCAqcCA9IHRvX3ByaW9saXN0KHJiKTsKQEAgLTc3NCwxMyArNzky LDEzIEBAIHN0YXRpYyBpbnQgZ3VjX2RlcXVldWVfb25lX2NvbnRleHQoc3RydWN0IGludGVsX2d1 YyAqZ3VjKQogCQlzdHJ1Y3QgaW50ZWxfY29udGV4dCAqY2UgPSBsYXN0LT5jb250ZXh0OwogCiAJ CWlmIChjZS0+Z3VjX251bV9ycV9zdWJtaXRfbm9faWQpIHsKLQkJCXJldCA9IHRhc2tsZXRfcGlu X2d1Y19pZChndWMsIGxhc3QpOworCQkJcmV0ID0gdGFza2xldF9waW5fZ3VjX2lkKGdzZSwgbGFz dCk7CiAJCQlpZiAocmV0KQogCQkJCWdvdG8gYmxrX3Rhc2tsZXRfa2ljazsKIAkJfQogCiByZWdp c3Rlcl9jb250ZXh0OgotCQlyZXQgPSB0YXNrbGV0X3JlZ2lzdGVyX2NvbnRleHQoZ3VjLCBsYXN0 KTsKKwkJcmV0ID0gdGFza2xldF9yZWdpc3Rlcl9jb250ZXh0KGdzZSwgbGFzdCk7CiAJCWlmICh1 bmxpa2VseShyZXQgPT0gLUVJTlBST0dSRVNTKSkKIAkJCWdvdG8gYmxrX3Rhc2tsZXQ7CiAJCWVs c2UgaWYgKHVubGlrZWx5KHJldCA9PSAtRVBJUEUpKQpAQCAtNzk2LDcgKzgxNCw3IEBAIHN0YXRp YyBpbnQgZ3VjX2RlcXVldWVfb25lX2NvbnRleHQoc3RydWN0IGludGVsX2d1YyAqZ3VjKQogCQln dWNfc2V0X2xyY190YWlsKGxhc3QpOwogCiBhZGRfcmVxdWVzdDoKLQkJcmV0ID0gZ3VjX2FkZF9y ZXF1ZXN0KGd1YywgbGFzdCk7CisJCXJldCA9IGdzZV9hZGRfcmVxdWVzdChnc2UsIGxhc3QpOwog CQlpZiAodW5saWtlbHkocmV0ID09IC1FUElQRSkpCiAJCQlnb3RvIGRlYWRsazsKIAkJZWxzZSBp ZiAocmV0ID09IC1FQlVTWSkKQEAgLTgxMSw4ICs4MjksOCBAQCBzdGF0aWMgaW50IGd1Y19kZXF1 ZXVlX29uZV9jb250ZXh0KHN0cnVjdCBpbnRlbF9ndWMgKmd1YykKIAkgKiBObyByZXF1ZXN0cyB3 aXRob3V0IGEgZ3VjX2lkLCBlbmFibGUgZ3VjX2lkIGFsbG9jYXRpb24gYXQgcmVxdWVzdAogCSAq IGNyZWF0aW9uIHRpbWUgKGd1Y19yZXF1ZXN0X2FsbG9jKS4KIAkgKi8KLQlpZiAoIWd1Yy0+dG90 YWxfbnVtX3JxX3dpdGhfbm9fZ3VjX2lkKQotCQljbHJfZ3VjX2lkc19leGhhdXN0ZWQoZ3VjKTsK KwlpZiAoIWdzZS0+dG90YWxfbnVtX3JxX3dpdGhfbm9fZ3VjX2lkKQorCQljbHJfZ3VjX2lkc19l eGhhdXN0ZWQoZ3NlKTsKIAogCXJldHVybiBzdWJtaXQ7CiAKQEAgLTgyNiwyNSArODQ0LDI2IEBA IHN0YXRpYyBpbnQgZ3VjX2RlcXVldWVfb25lX2NvbnRleHQoc3RydWN0IGludGVsX2d1YyAqZ3Vj KQogCXJldHVybiBmYWxzZTsKIAogYmxrX3Rhc2tsZXRfa2ljazoKLQlraWNrX3JldGlyZV93cShn dWMpOworCWtpY2tfcmV0aXJlX3dxKGdzZSk7CiBibGtfdGFza2xldDoKLQlzZXRfdGFza2xldF9i bG9ja2VkKGd1Yyk7CisJc2V0X3Rhc2tsZXRfYmxvY2tlZChnc2UpOwogCXJldHVybiBmYWxzZTsK IH0KIAotc3RhdGljIHZvaWQgZ3VjX3N1Ym1pc3Npb25fdGFza2xldChzdHJ1Y3QgdGFza2xldF9z dHJ1Y3QgKnQpCitzdGF0aWMgdm9pZCBnc2Vfc3VibWlzc2lvbl90YXNrbGV0KHN0cnVjdCB0YXNr bGV0X3N0cnVjdCAqdCkKIHsKIAlzdHJ1Y3QgaTkxNV9zY2hlZF9lbmdpbmUgKnNjaGVkX2VuZ2lu ZSA9CiAJCWZyb21fdGFza2xldChzY2hlZF9lbmdpbmUsIHQsIHRhc2tsZXQpOwotCXN0cnVjdCBp bnRlbF9ndWMgKmd1YyA9IHNjaGVkX2VuZ2luZS0+cHJpdmF0ZV9kYXRhOworCXN0cnVjdCBndWNf c3VibWl0X2VuZ2luZSAqZ3NlID0KKwkJY29udGFpbmVyX29mKHNjaGVkX2VuZ2luZSwgdHlwZW9m KCpnc2UpLCBzY2hlZF9lbmdpbmUpOwogCXVuc2lnbmVkIGxvbmcgZmxhZ3M7CiAJYm9vbCBsb29w OwogCiAJc3Bpbl9sb2NrX2lycXNhdmUoJnNjaGVkX2VuZ2luZS0+bG9jaywgZmxhZ3MpOwogCi0J aWYgKGxpa2VseSghdGFza2xldF9ibG9ja2VkKGd1YykpKQorCWlmIChsaWtlbHkoIXRhc2tsZXRf YmxvY2tlZChnc2UpKSkKIAkJZG8gewotCQkJbG9vcCA9IGd1Y19kZXF1ZXVlX29uZV9jb250ZXh0 KGd1Yyk7CisJCQlsb29wID0gZ3NlX2RlcXVldWVfb25lX2NvbnRleHQoZ3NlKTsKIAkJfSB3aGls ZSAobG9vcCk7CiAKIAlpOTE1X3NjaGVkX2VuZ2luZV9yZXNldF9vbl9lbXB0eShzY2hlZF9lbmdp bmUpOwpAQCAtOTE5LDY5ICs5MzgsOTkgQEAgc3RhdGljIHZvaWQgc2NydWJfZ3VjX2Rlc2NfZm9y X291dHN0YW5kaW5nX2cyaChzdHJ1Y3QgaW50ZWxfZ3VjICpndWMpCiAJfQogfQogCi1zdGF0aWMg aW5saW5lIGJvb2wKLXN1Ym1pc3Npb25fZGlzYWJsZWQoc3RydWN0IGludGVsX2d1YyAqZ3VjKQor c3RhdGljIGJvb2wgc3VibWlzc2lvbl9kaXNhYmxlZChzdHJ1Y3QgaW50ZWxfZ3VjICpndWMpCiB7 Ci0Jc3RydWN0IGk5MTVfc2NoZWRfZW5naW5lICogY29uc3Qgc2NoZWRfZW5naW5lID0gZ3VjLT5z Y2hlZF9lbmdpbmU7CisJaW50IGk7CisKKwlmb3IgKGkgPSAwOyBpIDwgR1VDX1NVQk1JVF9FTkdJ TkVfTUFYOyArK2kpIHsKKwkJc3RydWN0IGk5MTVfc2NoZWRfZW5naW5lICpzY2hlZF9lbmdpbmU7 CisKKwkJaWYgKHVubGlrZWx5KCFndWMtPmdzZVtpXSkpCisJCQlyZXR1cm4gdHJ1ZTsKKworCQlz Y2hlZF9lbmdpbmUgPSBndWNfdG9fc2NoZWRfZW5naW5lKGd1YywgaSk7CisKKwkJaWYgKHVubGlr ZWx5KCFfX3Rhc2tsZXRfaXNfZW5hYmxlZCgmc2NoZWRfZW5naW5lLT50YXNrbGV0KSkpCisJCQly ZXR1cm4gdHJ1ZTsKKwl9CiAKLQlyZXR1cm4gdW5saWtlbHkoIXNjaGVkX2VuZ2luZSB8fAotCQkJ IV9fdGFza2xldF9pc19lbmFibGVkKCZzY2hlZF9lbmdpbmUtPnRhc2tsZXQpKTsKKwlyZXR1cm4g ZmFsc2U7CiB9CiAKLXN0YXRpYyB2b2lkIGtpY2tfdGFza2xldChzdHJ1Y3QgaW50ZWxfZ3VjICpn dWMpCitzdGF0aWMgdm9pZCBraWNrX3Rhc2tsZXQoc3RydWN0IGd1Y19zdWJtaXRfZW5naW5lICpn c2UpCiB7Ci0Jc3RydWN0IGk5MTVfc2NoZWRfZW5naW5lICogY29uc3Qgc2NoZWRfZW5naW5lID0g Z3VjLT5zY2hlZF9lbmdpbmU7CisJc3RydWN0IGk5MTVfc2NoZWRfZW5naW5lICpzY2hlZF9lbmdp bmUgPSAmZ3NlLT5zY2hlZF9lbmdpbmU7CiAKLQlpZiAobGlrZWx5KCF0YXNrbGV0X2Jsb2NrZWQo Z3VjKSkpCisJaWYgKGxpa2VseSghdGFza2xldF9ibG9ja2VkKGdzZSkpKQogCQl0YXNrbGV0X2hp X3NjaGVkdWxlKCZzY2hlZF9lbmdpbmUtPnRhc2tsZXQpOwogfQogCiBzdGF0aWMgdm9pZCBkaXNh YmxlX3N1Ym1pc3Npb24oc3RydWN0IGludGVsX2d1YyAqZ3VjKQogewotCXN0cnVjdCBpOTE1X3Nj aGVkX2VuZ2luZSAqIGNvbnN0IHNjaGVkX2VuZ2luZSA9IGd1Yy0+c2NoZWRfZW5naW5lOworCWlu dCBpOworCisJZm9yIChpID0gMDsgaSA8IEdVQ19TVUJNSVRfRU5HSU5FX01BWDsgKytpKSB7CisJ CXN0cnVjdCBpOTE1X3NjaGVkX2VuZ2luZSAqc2NoZWRfZW5naW5lID0KKwkJCWd1Y190b19zY2hl ZF9lbmdpbmUoZ3VjLCBpKTsKIAotCWlmIChfX3Rhc2tsZXRfaXNfZW5hYmxlZCgmc2NoZWRfZW5n aW5lLT50YXNrbGV0KSkgewotCQlHRU1fQlVHX09OKCFndWMtPmN0LmVuYWJsZWQpOwotCQlfX3Rh c2tsZXRfZGlzYWJsZV9zeW5jX29uY2UoJnNjaGVkX2VuZ2luZS0+dGFza2xldCk7Ci0JCXNjaGVk X2VuZ2luZS0+dGFza2xldC5jYWxsYmFjayA9IE5VTEw7CisJCWlmIChfX3Rhc2tsZXRfaXNfZW5h YmxlZCgmc2NoZWRfZW5naW5lLT50YXNrbGV0KSkgeworCQkJR0VNX0JVR19PTighZ3VjLT5jdC5l bmFibGVkKTsKKwkJCV9fdGFza2xldF9kaXNhYmxlX3N5bmNfb25jZSgmc2NoZWRfZW5naW5lLT50 YXNrbGV0KTsKKwkJCXNjaGVkX2VuZ2luZS0+dGFza2xldC5jYWxsYmFjayA9IE5VTEw7CisJCX0K IAl9CiB9CiAKIHN0YXRpYyB2b2lkIGVuYWJsZV9zdWJtaXNzaW9uKHN0cnVjdCBpbnRlbF9ndWMg Kmd1YykKIHsKLQlzdHJ1Y3QgaTkxNV9zY2hlZF9lbmdpbmUgKiBjb25zdCBzY2hlZF9lbmdpbmUg PSBndWMtPnNjaGVkX2VuZ2luZTsKIAl1bnNpZ25lZCBsb25nIGZsYWdzOworCWludCBpOwogCi0J c3Bpbl9sb2NrX2lycXNhdmUoJmd1Yy0+c2NoZWRfZW5naW5lLT5sb2NrLCBmbGFncyk7Ci0Jc2No ZWRfZW5naW5lLT50YXNrbGV0LmNhbGxiYWNrID0gZ3VjX3N1Ym1pc3Npb25fdGFza2xldDsKLQl3 bWIoKTsKLQlpZiAoIV9fdGFza2xldF9pc19lbmFibGVkKCZzY2hlZF9lbmdpbmUtPnRhc2tsZXQp ICYmCi0JICAgIF9fdGFza2xldF9lbmFibGUoJnNjaGVkX2VuZ2luZS0+dGFza2xldCkpIHsKLQkJ R0VNX0JVR19PTighZ3VjLT5jdC5lbmFibGVkKTsKLQotCQkvKiBSZXNldCB0YXNrbGV0IHN0YXRl ICovCi0JCWd1Yy0+c3RhbGxlZF9ycSA9IE5VTEw7Ci0JCWlmIChndWMtPnN0YWxsZWRfY29udGV4 dCkKLQkJCWludGVsX2NvbnRleHRfcHV0KGd1Yy0+c3RhbGxlZF9jb250ZXh0KTsKLQkJZ3VjLT5z dGFsbGVkX2NvbnRleHQgPSBOVUxMOwotCQlndWMtPnN1Ym1pc3Npb25fc3RhbGxfcmVhc29uID0g U1RBTExfTk9ORTsKLQkJZ3VjLT5mbGFncyA9IDA7CisJZm9yIChpID0gMDsgaSA8IEdVQ19TVUJN SVRfRU5HSU5FX01BWDsgKytpKSB7CisJCXN0cnVjdCBpOTE1X3NjaGVkX2VuZ2luZSAqc2NoZWRf ZW5naW5lID0KKwkJCWd1Y190b19zY2hlZF9lbmdpbmUoZ3VjLCBpKTsKKwkJc3RydWN0IGd1Y19z dWJtaXRfZW5naW5lICpnc2UgPSBndWMtPmdzZVtpXTsKIAotCQkvKiBBbmQga2ljayBpbiBjYXNl IHdlIG1pc3NlZCBhIG5ldyByZXF1ZXN0IHN1Ym1pc3Npb24uICovCi0JCWtpY2tfdGFza2xldChn dWMpOworCQlzcGluX2xvY2tfaXJxc2F2ZSgmc2NoZWRfZW5naW5lLT5sb2NrLCBmbGFncyk7CisJ CXNjaGVkX2VuZ2luZS0+dGFza2xldC5jYWxsYmFjayA9IGdzZV9zdWJtaXNzaW9uX3Rhc2tsZXQ7 CisJCXdtYigpOworCQlpZiAoIV9fdGFza2xldF9pc19lbmFibGVkKCZzY2hlZF9lbmdpbmUtPnRh c2tsZXQpICYmCisJCSAgICBfX3Rhc2tsZXRfZW5hYmxlKCZzY2hlZF9lbmdpbmUtPnRhc2tsZXQp KSB7CisJCQlHRU1fQlVHX09OKCFndWMtPmN0LmVuYWJsZWQpOworCisJCQkvKiBSZXNldCBHdUMg c3VibWl0IGVuZ2luZSBzdGF0ZSAqLworCQkJZ3NlLT5zdGFsbGVkX3JxID0gTlVMTDsKKwkJCWlm IChnc2UtPnN0YWxsZWRfY29udGV4dCkKKwkJCQlpbnRlbF9jb250ZXh0X3B1dChnc2UtPnN0YWxs ZWRfY29udGV4dCk7CisJCQlnc2UtPnN0YWxsZWRfY29udGV4dCA9IE5VTEw7CisJCQlnc2UtPnN1 Ym1pc3Npb25fc3RhbGxfcmVhc29uID0gU1RBTExfTk9ORTsKKwkJCWdzZS0+ZmxhZ3MgPSAwOwor CisJCQkvKiBBbmQga2ljayBpbiBjYXNlIHdlIG1pc3NlZCBhIG5ldyByZXF1ZXN0IHN1Ym1pc3Np b24uICovCisJCQlraWNrX3Rhc2tsZXQoZ3NlKTsKKwkJfQorCQlzcGluX3VubG9ja19pcnFyZXN0 b3JlKCZzY2hlZF9lbmdpbmUtPmxvY2ssIGZsYWdzKTsKIAl9Ci0Jc3Bpbl91bmxvY2tfaXJxcmVz dG9yZSgmZ3VjLT5zY2hlZF9lbmdpbmUtPmxvY2ssIGZsYWdzKTsKIH0KIAotc3RhdGljIHZvaWQg Z3VjX2ZsdXNoX3N1Ym1pc3Npb25zKHN0cnVjdCBpbnRlbF9ndWMgKmd1YykKK3N0YXRpYyB2b2lk IGdzZV9mbHVzaF9zdWJtaXNzaW9ucyhzdHJ1Y3QgZ3VjX3N1Ym1pdF9lbmdpbmUgKmdzZSkKIHsK LQlzdHJ1Y3QgaTkxNV9zY2hlZF9lbmdpbmUgKiBjb25zdCBzY2hlZF9lbmdpbmUgPSBndWMtPnNj aGVkX2VuZ2luZTsKKwlzdHJ1Y3QgaTkxNV9zY2hlZF9lbmdpbmUgKiBjb25zdCBzY2hlZF9lbmdp bmUgPSAmZ3NlLT5zY2hlZF9lbmdpbmU7CiAJdW5zaWduZWQgbG9uZyBmbGFnczsKIAogCXNwaW5f bG9ja19pcnFzYXZlKCZzY2hlZF9lbmdpbmUtPmxvY2ssIGZsYWdzKTsKIAlzcGluX3VubG9ja19p cnFyZXN0b3JlKCZzY2hlZF9lbmdpbmUtPmxvY2ssIGZsYWdzKTsKIH0KIAorc3RhdGljIHZvaWQg Z3VjX2ZsdXNoX3N1Ym1pc3Npb25zKHN0cnVjdCBpbnRlbF9ndWMgKmd1YykKK3sKKwlpbnQgaTsK KworCWZvciAoaSA9IDA7IGkgPCBHVUNfU1VCTUlUX0VOR0lORV9NQVg7ICsraSkKKwkJaWYgKGxp a2VseShndWMtPmdzZVtpXSkpCisJCQlnc2VfZmx1c2hfc3VibWlzc2lvbnMoZ3VjLT5nc2VbaV0p OworfQorCiB2b2lkIGludGVsX2d1Y19zdWJtaXNzaW9uX3Jlc2V0X3ByZXBhcmUoc3RydWN0IGlu dGVsX2d1YyAqZ3VjKQogewogCWludCBpOwpAQCAtMTE2MywxMyArMTIxMiwxMiBAQCB2b2lkIGlu dGVsX2d1Y19zdWJtaXNzaW9uX3Jlc2V0KHN0cnVjdCBpbnRlbF9ndWMgKmd1YywgYm9vbCBzdGFs bGVkKQogCQlpZiAoaW50ZWxfY29udGV4dF9pc19waW5uZWQoY2UpKQogCQkJX19ndWNfcmVzZXRf Y29udGV4dChjZSwgc3RhbGxlZCk7CiAKLQkvKiBHdUMgaXMgYmxvd24gYXdheSwgZHJvcCBhbGwg cmVmZXJlbmNlcyB0byBjb250ZXh0cyAqLwogCXhhX2Rlc3Ryb3koJmd1Yy0+Y29udGV4dF9sb29r dXApOwogfQogCiBzdGF0aWMgdm9pZCBndWNfY2FuY2VsX2NvbnRleHRfcmVxdWVzdHMoc3RydWN0 IGludGVsX2NvbnRleHQgKmNlKQogewotCXN0cnVjdCBpOTE1X3NjaGVkX2VuZ2luZSAqc2NoZWRf ZW5naW5lID0gY2VfdG9fZ3VjKGNlKS0+c2NoZWRfZW5naW5lOworCXN0cnVjdCBpOTE1X3NjaGVk X2VuZ2luZSAqc2NoZWRfZW5naW5lID0gY2VfdG9fc2NoZWRfZW5naW5lKGNlKTsKIAlzdHJ1Y3Qg aTkxNV9yZXF1ZXN0ICpycTsKIAl1bnNpZ25lZCBsb25nIGZsYWdzOwogCkBAIC0xMTg0LDggKzEy MzIsOSBAQCBzdGF0aWMgdm9pZCBndWNfY2FuY2VsX2NvbnRleHRfcmVxdWVzdHMoc3RydWN0IGlu dGVsX2NvbnRleHQgKmNlKQogfQogCiBzdGF0aWMgdm9pZAotZ3VjX2NhbmNlbF9zY2hlZF9lbmdp bmVfcmVxdWVzdHMoc3RydWN0IGk5MTVfc2NoZWRfZW5naW5lICpzY2hlZF9lbmdpbmUpCitnc2Vf Y2FuY2VsX3JlcXVlc3RzKHN0cnVjdCBndWNfc3VibWl0X2VuZ2luZSAqZ3NlKQogeworCXN0cnVj dCBpOTE1X3NjaGVkX2VuZ2luZSAqc2NoZWRfZW5naW5lID0gJmdzZS0+c2NoZWRfZW5naW5lOwog CXN0cnVjdCBpOTE1X3JlcXVlc3QgKnJxLCAqcm47CiAJc3RydWN0IHJiX25vZGUgKnJiOwogCXVu c2lnbmVkIGxvbmcgZmxhZ3M7CkBAIC0xMjQyLDEyICsxMjkxLDE0IEBAIHZvaWQgaW50ZWxfZ3Vj X3N1Ym1pc3Npb25fY2FuY2VsX3JlcXVlc3RzKHN0cnVjdCBpbnRlbF9ndWMgKmd1YykKIHsKIAlz dHJ1Y3QgaW50ZWxfY29udGV4dCAqY2U7CiAJdW5zaWduZWQgbG9uZyBpbmRleDsKKwlpbnQgaTsK IAogCXhhX2Zvcl9lYWNoKCZndWMtPmNvbnRleHRfbG9va3VwLCBpbmRleCwgY2UpCiAJCWlmIChp bnRlbF9jb250ZXh0X2lzX3Bpbm5lZChjZSkpCiAJCQlndWNfY2FuY2VsX2NvbnRleHRfcmVxdWVz dHMoY2UpOwogCi0JZ3VjX2NhbmNlbF9zY2hlZF9lbmdpbmVfcmVxdWVzdHMoZ3VjLT5zY2hlZF9l bmdpbmUpOworCWZvciAoaSA9IDA7IGkgPCBHVUNfU1VCTUlUX0VOR0lORV9NQVg7ICsraSkKKwkJ Z3NlX2NhbmNlbF9yZXF1ZXN0cyhndWMtPmdzZVtpXSk7CiAKIAkvKiBHdUMgaXMgYmxvd24gYXdh eSwgZHJvcCBhbGwgcmVmZXJlbmNlcyB0byBjb250ZXh0cyAqLwogCXhhX2Rlc3Ryb3koJmd1Yy0+ Y29udGV4dF9sb29rdXApOwpAQCAtMTI3NCwxMyArMTMyNSwxMyBAQCB2b2lkIGludGVsX2d1Y19z dWJtaXNzaW9uX3Jlc2V0X2ZpbmlzaChzdHJ1Y3QgaW50ZWxfZ3VjICpndWMpCiAJaW50ZWxfZ3Rf dW5wYXJrX2hlYXJ0YmVhdHMoZ3VjX3RvX2d0KGd1YykpOwogfQogCi1zdGF0aWMgdm9pZCByZXRp cmVfd29ya2VyX3NjaGVkX2Rpc2FibGUoc3RydWN0IGludGVsX2d1YyAqZ3VjLAorc3RhdGljIHZv aWQgcmV0aXJlX3dvcmtlcl9zY2hlZF9kaXNhYmxlKHN0cnVjdCBndWNfc3VibWl0X2VuZ2luZSAq Z3NlLAogCQkJCQlzdHJ1Y3QgaW50ZWxfY29udGV4dCAqY2UpOwogCiBzdGF0aWMgdm9pZCByZXRp cmVfd29ya2VyX2Z1bmMoc3RydWN0IHdvcmtfc3RydWN0ICp3KQogewotCXN0cnVjdCBpbnRlbF9n dWMgKmd1YyA9Ci0JCWNvbnRhaW5lcl9vZih3LCBzdHJ1Y3QgaW50ZWxfZ3VjLCByZXRpcmVfd29y a2VyKTsKKwlzdHJ1Y3QgZ3VjX3N1Ym1pdF9lbmdpbmUgKmdzZSA9CisJCWNvbnRhaW5lcl9vZih3 LCBzdHJ1Y3QgZ3VjX3N1Ym1pdF9lbmdpbmUsIHJldGlyZV93b3JrZXIpOwogCiAJLyoKIAkgKiBJ dCBpcyBwb3NzaWJsZSB0aGF0IGFub3RoZXIgdGhyZWFkIGlzc3VlcyB0aGUgc2NoZWR1bGUgZGlz YWJsZSArIHRoYXQKQEAgLTEyODgsMTcgKzEzMzksMTcgQEAgc3RhdGljIHZvaWQgcmV0aXJlX3dv cmtlcl9mdW5jKHN0cnVjdCB3b3JrX3N0cnVjdCAqdykKIAkgKiB3aGVyZSBub3RoaW5nIG5lZWRz IHRvIGJlIGRvbmUgaGVyZS4gTGV0J3MgYmUgcGFyYW5vaWQgYW5kIGtpY2sgdGhlCiAJICogdGFz a2xldCBpbiB0aGF0IGNhc2UuCiAJICovCi0JaWYgKGd1Yy0+c3VibWlzc2lvbl9zdGFsbF9yZWFz b24gIT0gU1RBTExfU0NIRURfRElTQUJMRSAmJgotCSAgICBndWMtPnN1Ym1pc3Npb25fc3RhbGxf cmVhc29uICE9IFNUQUxMX0dVQ19JRF9XT1JLUVVFVUUpIHsKLQkJa2lja190YXNrbGV0KGd1Yyk7 CisJaWYgKGdzZS0+c3VibWlzc2lvbl9zdGFsbF9yZWFzb24gIT0gU1RBTExfU0NIRURfRElTQUJM RSAmJgorCSAgICBnc2UtPnN1Ym1pc3Npb25fc3RhbGxfcmVhc29uICE9IFNUQUxMX0dVQ19JRF9X T1JLUVVFVUUpIHsKKwkJa2lja190YXNrbGV0KGdzZSk7CiAJCXJldHVybjsKIAl9CiAKLQlpZiAo Z3VjLT5zdWJtaXNzaW9uX3N0YWxsX3JlYXNvbiA9PSBTVEFMTF9TQ0hFRF9ESVNBQkxFKSB7Ci0J CUdFTV9CVUdfT04oIWd1Yy0+c3RhbGxlZF9jb250ZXh0KTsKLQkJR0VNX0JVR19PTihjb250ZXh0 X2d1Y19pZF9pbnZhbGlkKGd1Yy0+c3RhbGxlZF9jb250ZXh0KSk7CisJaWYgKGdzZS0+c3VibWlz c2lvbl9zdGFsbF9yZWFzb24gPT0gU1RBTExfU0NIRURfRElTQUJMRSkgeworCQlHRU1fQlVHX09O KCFnc2UtPnN0YWxsZWRfY29udGV4dCk7CisJCUdFTV9CVUdfT04oY29udGV4dF9ndWNfaWRfaW52 YWxpZChnc2UtPnN0YWxsZWRfY29udGV4dCkpOwogCi0JCXJldGlyZV93b3JrZXJfc2NoZWRfZGlz YWJsZShndWMsIGd1Yy0+c3RhbGxlZF9jb250ZXh0KTsKKwkJcmV0aXJlX3dvcmtlcl9zY2hlZF9k aXNhYmxlKGdzZSwgZ3NlLT5zdGFsbGVkX2NvbnRleHQpOwogCX0KIAogCS8qCkBAIC0xMzA2LDE2 ICsxMzU3LDE2IEBAIHN0YXRpYyB2b2lkIHJldGlyZV93b3JrZXJfZnVuYyhzdHJ1Y3Qgd29ya19z dHJ1Y3QgKncpCiAJICogYWxiZWl0IGFmdGVyIHBvc3NpYmx5IGlzc3VpbmcgYSBzY2hlZHVsZSBk aXNhYmxlIGFzIHRoYXQgaXMgYXN5bmMKIAkgKiBvcGVyYXRpb24uCiAJICovCi0JaW50ZWxfZ3Rf cmV0aXJlX3JlcXVlc3RzKGd1Y190b19ndChndWMpKTsKKwlpbnRlbF9ndF9yZXRpcmVfcmVxdWVz dHMoZ3VjX3RvX2d0KGdzZS0+c2NoZWRfZW5naW5lLnByaXZhdGVfZGF0YSkpOwogCi0JaWYgKGd1 Yy0+c3VibWlzc2lvbl9zdGFsbF9yZWFzb24gPT0gU1RBTExfR1VDX0lEX1dPUktRVUVVRSkgewot CQlHRU1fQlVHX09OKGd1Yy0+c3RhbGxlZF9jb250ZXh0KTsKKwlpZiAoZ3NlLT5zdWJtaXNzaW9u X3N0YWxsX3JlYXNvbiA9PSBTVEFMTF9HVUNfSURfV09SS1FVRVVFKSB7CisJCUdFTV9CVUdfT04o Z3NlLT5zdGFsbGVkX2NvbnRleHQpOwogCiAJCS8qIEhvcGVmdWxseSBndWNfaWRzIGFyZSBub3cg YXZhaWxhYmxlLCBraWNrIHRhc2tsZXQgKi8KLQkJZ3VjLT5zdWJtaXNzaW9uX3N0YWxsX3JlYXNv biA9IFNUQUxMX0dVQ19JRF9UQVNLTEVUOwotCQljbHJfdGFza2xldF9ibG9ja2VkKGd1Yyk7CisJ CWdzZS0+c3VibWlzc2lvbl9zdGFsbF9yZWFzb24gPSBTVEFMTF9HVUNfSURfVEFTS0xFVDsKKwkJ Y2xyX3Rhc2tsZXRfYmxvY2tlZChnc2UpOwogCi0JCWtpY2tfdGFza2xldChndWMpOworCQlraWNr X3Rhc2tsZXQoZ3NlKTsKIAl9CiB9CiAKQEAgLTEzNDYsMTggKzEzOTcsMjQgQEAgaW50IGludGVs X2d1Y19zdWJtaXNzaW9uX2luaXQoc3RydWN0IGludGVsX2d1YyAqZ3VjKQogCUlOSVRfTElTVF9I RUFEKCZndWMtPmd1Y19pZF9saXN0X3VucGlubmVkKTsKIAlpZGFfaW5pdCgmZ3VjLT5ndWNfaWRz KTsKIAotCUlOSVRfV09SSygmZ3VjLT5yZXRpcmVfd29ya2VyLCByZXRpcmVfd29ya2VyX2Z1bmMp OwotCiAJcmV0dXJuIDA7CiB9CiAKIHZvaWQgaW50ZWxfZ3VjX3N1Ym1pc3Npb25fZmluaShzdHJ1 Y3QgaW50ZWxfZ3VjICpndWMpCiB7CisJaW50IGk7CisKIAlpZiAoIWd1Yy0+bHJjX2Rlc2NfcG9v bCkKIAkJcmV0dXJuOwogCiAJZ3VjX2xyY19kZXNjX3Bvb2xfZGVzdHJveShndWMpOwotCWk5MTVf c2NoZWRfZW5naW5lX3B1dChndWMtPnNjaGVkX2VuZ2luZSk7CisKKwlmb3IgKGkgPSAwOyBpIDwg R1VDX1NVQk1JVF9FTkdJTkVfTUFYOyArK2kpIHsKKwkJc3RydWN0IGk5MTVfc2NoZWRfZW5naW5l ICpzY2hlZF9lbmdpbmUgPQorCQkJZ3VjX3RvX3NjaGVkX2VuZ2luZShndWMsIGkpOworCisJCWk5 MTVfc2NoZWRfZW5naW5lX3B1dChzY2hlZF9lbmdpbmUpOworCX0KIH0KIAogc3RhdGljIGlubGlu ZSB2b2lkIHF1ZXVlX3JlcXVlc3Qoc3RydWN0IGk5MTVfc2NoZWRfZW5naW5lICpzY2hlZF9lbmdp bmUsCkBAIC0xMzcyLDIyICsxNDI5LDIzIEBAIHN0YXRpYyBpbmxpbmUgdm9pZCBxdWV1ZV9yZXF1 ZXN0KHN0cnVjdCBpOTE1X3NjaGVkX2VuZ2luZSAqc2NoZWRfZW5naW5lLAogCXNldF9iaXQoSTkx NV9GRU5DRV9GTEFHX1BRVUVVRSwgJnJxLT5mZW5jZS5mbGFncyk7CiAKIAlpZiAoZW1wdHkpCi0J CWtpY2tfdGFza2xldCgmcnEtPmVuZ2luZS0+Z3QtPnVjLmd1Yyk7CisJCWtpY2tfdGFza2xldChj ZV90b19nc2UocnEtPmNvbnRleHQpKTsKIH0KIAogLyogTWFjcm8gdG8gdHdlYWsgaGV1cmlzdGlj LCB1c2luZyBhIHNpbXBsZSBvdmVyIDUwJSBub3QgcmVhZHkgZm9yIG5vdyAqLwogI2RlZmluZSBU T09fTUFOWV9HVUNfSURTX05PVF9SRUFEWShhdmFpbCwgY29uc3VtZWQpIFwKIAkoY29uc3VtZWQg PiBhdmFpbCAvIDIpCi1zdGF0aWMgYm9vbCB0b29fbWFueV9ndWNfaWRzX25vdF9yZWFkeShzdHJ1 Y3QgaW50ZWxfZ3VjICpndWMsCitzdGF0aWMgYm9vbCB0b29fbWFueV9ndWNfaWRzX25vdF9yZWFk eShzdHJ1Y3QgZ3VjX3N1Ym1pdF9lbmdpbmUgKmdzZSwKIAkJCQkgICAgICAgc3RydWN0IGludGVs X2NvbnRleHQgKmNlKQogewogCXUzMiBhdmFpbGFibGVfZ3VjX2lkcywgZ3VjX2lkc19jb25zdW1l ZDsKKwlzdHJ1Y3QgaW50ZWxfZ3VjICpndWMgPSBnc2UtPnNjaGVkX2VuZ2luZS5wcml2YXRlX2Rh dGE7CiAKIAlhdmFpbGFibGVfZ3VjX2lkcyA9IGd1Yy0+bnVtX2d1Y19pZHM7Ci0JZ3VjX2lkc19j b25zdW1lZCA9IGF0b21pY19yZWFkKCZndWMtPm51bV9ndWNfaWRzX25vdF9yZWFkeSk7CisJZ3Vj X2lkc19jb25zdW1lZCA9IGF0b21pY19yZWFkKCZnc2UtPm51bV9ndWNfaWRzX25vdF9yZWFkeSk7 CiAKIAlpZiAoVE9PX01BTllfR1VDX0lEU19OT1RfUkVBRFkoYXZhaWxhYmxlX2d1Y19pZHMsIGd1 Y19pZHNfY29uc3VtZWQpKSB7Ci0JCXNldF9hbmRfdXBkYXRlX2d1Y19pZHNfZXhoYXVzdGVkKGd1 Yyk7CisJCXNldF9hbmRfdXBkYXRlX2d1Y19pZHNfZXhoYXVzdGVkKGdzZSk7CiAJCXJldHVybiB0 cnVlOwogCX0KIApAQCAtMTM5NiwzNCArMTQ1NCwzNiBAQCBzdGF0aWMgYm9vbCB0b29fbWFueV9n dWNfaWRzX25vdF9yZWFkeShzdHJ1Y3QgaW50ZWxfZ3VjICpndWMsCiAKIHN0YXRpYyB2b2lkIGlu Y3JfbnVtX3JxX25vdF9yZWFkeShzdHJ1Y3QgaW50ZWxfY29udGV4dCAqY2UpCiB7Ci0Jc3RydWN0 IGludGVsX2d1YyAqZ3VjID0gY2VfdG9fZ3VjKGNlKTsKKwlzdHJ1Y3QgZ3VjX3N1Ym1pdF9lbmdp bmUgKmdzZSA9IGNlX3RvX2dzZShjZSk7CiAKIAlpZiAoIWF0b21pY19mZXRjaF9hZGQoMSwgJmNl LT5ndWNfbnVtX3JxX25vdF9yZWFkeSkpCi0JCWF0b21pY19pbmMoJmd1Yy0+bnVtX2d1Y19pZHNf bm90X3JlYWR5KTsKKwkJYXRvbWljX2luYygmZ3NlLT5udW1fZ3VjX2lkc19ub3RfcmVhZHkpOwog fQogCiB2b2lkIGludGVsX2d1Y19kZWNyX251bV9ycV9ub3RfcmVhZHkoc3RydWN0IGludGVsX2Nv bnRleHQgKmNlKQogewotCXN0cnVjdCBpbnRlbF9ndWMgKmd1YyA9IGNlX3RvX2d1YyhjZSk7CisJ c3RydWN0IGd1Y19zdWJtaXRfZW5naW5lICpnc2UgPSBjZV90b19nc2UoY2UpOwogCi0JaWYgKGF0 b21pY19mZXRjaF9hZGQoLTEsICZjZS0+Z3VjX251bV9ycV9ub3RfcmVhZHkpID09IDEpCi0JCWF0 b21pY19kZWMoJmd1Yy0+bnVtX2d1Y19pZHNfbm90X3JlYWR5KTsKKwlpZiAoYXRvbWljX2ZldGNo X2FkZCgtMSwgJmNlLT5ndWNfbnVtX3JxX25vdF9yZWFkeSkgPT0gMSkgeworCQlHRU1fQlVHX09O KCFhdG9taWNfcmVhZCgmZ3NlLT5udW1fZ3VjX2lkc19ub3RfcmVhZHkpKTsKKwkJYXRvbWljX2Rl YygmZ3NlLT5udW1fZ3VjX2lkc19ub3RfcmVhZHkpOworCX0KIH0KIAotc3RhdGljIGJvb2wgbmVl ZF90YXNrbGV0KHN0cnVjdCBpbnRlbF9ndWMgKmd1Yywgc3RydWN0IGludGVsX2NvbnRleHQgKmNl KQorc3RhdGljIGJvb2wgbmVlZF90YXNrbGV0KHN0cnVjdCBndWNfc3VibWl0X2VuZ2luZSAqZ3Nl LCBzdHJ1Y3QgaW50ZWxfY29udGV4dCAqY2UpCiB7Ci0Jc3RydWN0IGk5MTVfc2NoZWRfZW5naW5l ICogY29uc3Qgc2NoZWRfZW5naW5lID0KLQkJY2UtPmVuZ2luZS0+c2NoZWRfZW5naW5lOworCXN0 cnVjdCBpOTE1X3NjaGVkX2VuZ2luZSAqIGNvbnN0IHNjaGVkX2VuZ2luZSA9ICZnc2UtPnNjaGVk X2VuZ2luZTsKKwlzdHJ1Y3QgaW50ZWxfZ3VjICpndWMgPSBnc2UtPnNjaGVkX2VuZ2luZS5wcml2 YXRlX2RhdGE7CiAKIAlsb2NrZGVwX2Fzc2VydF9oZWxkKCZzY2hlZF9lbmdpbmUtPmxvY2spOwog Ci0JcmV0dXJuIGd1Y19pZHNfZXhoYXVzdGVkKGd1YykgfHwgc3VibWlzc2lvbl9kaXNhYmxlZChn dWMpIHx8Ci0JCWd1Yy0+c3RhbGxlZF9ycSB8fCBndWMtPnN0YWxsZWRfY29udGV4dCB8fAorCXJl dHVybiBndWNfaWRzX2V4aGF1c3RlZChnc2UpIHx8IHN1Ym1pc3Npb25fZGlzYWJsZWQoZ3VjKSB8 fAorCQlnc2UtPnN0YWxsZWRfcnEgfHwgZ3NlLT5zdGFsbGVkX2NvbnRleHQgfHwKIAkJIWxyY19k ZXNjX3JlZ2lzdGVyZWQoZ3VjLCBjZS0+Z3VjX2lkKSB8fAogCQkhaTkxNV9zY2hlZF9lbmdpbmVf aXNfZW1wdHkoc2NoZWRfZW5naW5lKTsKIH0KIAotc3RhdGljIGludCBndWNfYnlwYXNzX3Rhc2ts ZXRfc3VibWl0KHN0cnVjdCBpbnRlbF9ndWMgKmd1YywKK3N0YXRpYyBpbnQgZ3NlX2J5cGFzc190 YXNrbGV0X3N1Ym1pdChzdHJ1Y3QgZ3VjX3N1Ym1pdF9lbmdpbmUgKmdzZSwKIAkJCQkgICAgIHN0 cnVjdCBpOTE1X3JlcXVlc3QgKnJxKQogewogCWludCByZXQ7CkBAIC0xNDMzLDI3ICsxNDkzLDI3 IEBAIHN0YXRpYyBpbnQgZ3VjX2J5cGFzc190YXNrbGV0X3N1Ym1pdChzdHJ1Y3QgaW50ZWxfZ3Vj ICpndWMsCiAJdHJhY2VfaTkxNV9yZXF1ZXN0X2luKHJxLCAwKTsKIAogCWd1Y19zZXRfbHJjX3Rh aWwocnEpOwotCXJldCA9IGd1Y19hZGRfcmVxdWVzdChndWMsIHJxKTsKKwlyZXQgPSBnc2VfYWRk X3JlcXVlc3QoZ3NlLCBycSk7CiAKIAlpZiAodW5saWtlbHkocmV0ID09IC1FUElQRSkpCi0JCWRp c2FibGVfc3VibWlzc2lvbihndWMpOworCQlkaXNhYmxlX3N1Ym1pc3Npb24oZ3NlLT5zY2hlZF9l bmdpbmUucHJpdmF0ZV9kYXRhKTsKIAogCXJldHVybiByZXQ7CiB9CiAKIHN0YXRpYyB2b2lkIGd1 Y19zdWJtaXRfcmVxdWVzdChzdHJ1Y3QgaTkxNV9yZXF1ZXN0ICpycSkKIHsKLQlzdHJ1Y3QgaTkx NV9zY2hlZF9lbmdpbmUgKnNjaGVkX2VuZ2luZSA9IHJxLT5lbmdpbmUtPnNjaGVkX2VuZ2luZTsK LQlzdHJ1Y3QgaW50ZWxfZ3VjICpndWMgPSAmcnEtPmVuZ2luZS0+Z3QtPnVjLmd1YzsKKwlzdHJ1 Y3QgZ3VjX3N1Ym1pdF9lbmdpbmUgKmdzZSA9IGNlX3RvX2dzZShycS0+Y29udGV4dCk7CisJc3Ry dWN0IGk5MTVfc2NoZWRfZW5naW5lICpzY2hlZF9lbmdpbmUgPSAmZ3NlLT5zY2hlZF9lbmdpbmU7 CiAJdW5zaWduZWQgbG9uZyBmbGFnczsKIAogCS8qIFdpbGwgYmUgY2FsbGVkIGZyb20gaXJxLWNv bnRleHQgd2hlbiB1c2luZyBmb3JlaWduIGZlbmNlcy4gKi8KIAlzcGluX2xvY2tfaXJxc2F2ZSgm c2NoZWRfZW5naW5lLT5sb2NrLCBmbGFncyk7CiAKLQlpZiAobmVlZF90YXNrbGV0KGd1YywgcnEt PmNvbnRleHQpKQorCWlmIChuZWVkX3Rhc2tsZXQoZ3NlLCBycS0+Y29udGV4dCkpCiAJCXF1ZXVl X3JlcXVlc3Qoc2NoZWRfZW5naW5lLCBycSwgcnFfcHJpbyhycSkpOwotCWVsc2UgaWYgKGd1Y19i eXBhc3NfdGFza2xldF9zdWJtaXQoZ3VjLCBycSkgPT0gLUVCVVNZKQotCQlraWNrX3Rhc2tsZXQo Z3VjKTsKKwllbHNlIGlmIChnc2VfYnlwYXNzX3Rhc2tsZXRfc3VibWl0KGdzZSwgcnEpID09IC1F QlVTWSkKKwkJa2lja190YXNrbGV0KGdzZSk7CiAKIAlzcGluX3VubG9ja19pcnFyZXN0b3JlKCZz Y2hlZF9lbmdpbmUtPmxvY2ssIGZsYWdzKTsKIApAQCAtMTUzMiw4ICsxNTkyLDkgQEAgc3RhdGlj IGludCBzdGVhbF9ndWNfaWQoc3RydWN0IGludGVsX2d1YyAqZ3VjLCBib29sIHVucGlubmVkKQog CQkgKiBjb250ZXh0LgogCQkgKi8KIAkJaWYgKCF1bnBpbm5lZCkgewotCQkJR0VNX0JVR19PTihn dWMtPnN0YWxsZWRfY29udGV4dCk7Ci0JCQlndWMtPnN0YWxsZWRfY29udGV4dCA9IGludGVsX2Nv bnRleHRfZ2V0KGNlKTsKKwkJCUdFTV9CVUdfT04oY2VfdG9fZ3NlKGNlKS0+c3RhbGxlZF9jb250 ZXh0KTsKKworCQkJY2VfdG9fZ3NlKGNlKS0+c3RhbGxlZF9jb250ZXh0ID0gaW50ZWxfY29udGV4 dF9nZXQoY2UpOwogCQkJc2V0X2NvbnRleHRfZ3VjX2lkX3N0b2xlbihjZSk7CiAJCX0gZWxzZSB7 CiAJCQlzZXRfY29udGV4dF9ndWNfaWRfaW52YWxpZChjZSk7CkBAIC0xNTk1LDcgKzE2NTYsNyBA QCBzdGF0aWMgaW50IHBpbl9ndWNfaWQoc3RydWN0IGludGVsX2d1YyAqZ3VjLCBzdHJ1Y3QgaW50 ZWxfY29udGV4dCAqY2UsCiB0cnlfYWdhaW46CiAJc3Bpbl9sb2NrX2lycXNhdmUoJmd1Yy0+Y29u dGV4dHNfbG9jaywgZmxhZ3MpOwogCi0JaWYgKCF0YXNrbGV0ICYmIGd1Y19pZHNfZXhoYXVzdGVk KGd1YykpIHsKKwlpZiAoIXRhc2tsZXQgJiYgZ3VjX2lkc19leGhhdXN0ZWQoY2VfdG9fZ3NlKGNl KSkpIHsKIAkJcmV0ID0gLUVBR0FJTjsKIAkJZ290byBvdXRfdW5sb2NrOwogCX0KQEAgLTIwODQs NyArMjE0NSw3IEBAIHN0YXRpYyB2b2lkIGd1Y19jb250ZXh0X2JhbihzdHJ1Y3QgaW50ZWxfY29u dGV4dCAqY2UsIHN0cnVjdCBpOTE1X3JlcXVlc3QgKnJxKQogCWludGVsX3dha2VyZWZfdCB3YWtl cmVmOwogCXVuc2lnbmVkIGxvbmcgZmxhZ3M7CiAKLQlndWNfZmx1c2hfc3VibWlzc2lvbnMoZ3Vj KTsKKwlnc2VfZmx1c2hfc3VibWlzc2lvbnMoY2VfdG9fZ3NlKGNlKSk7CiAKIAlzcGluX2xvY2tf aXJxc2F2ZSgmY2UtPmd1Y19zdGF0ZS5sb2NrLCBmbGFncyk7CiAJc2V0X2NvbnRleHRfYmFubmVk KGNlKTsKQEAgLTIxNzIsNyArMjIzMyw3IEBAIHN0YXRpYyB2b2lkIGd1Y19jb250ZXh0X3NjaGVk X2Rpc2FibGUoc3RydWN0IGludGVsX2NvbnRleHQgKmNlKQogCXNwaW5fdW5sb2NrX2lycXJlc3Rv cmUoJmNlLT5ndWNfc3RhdGUubG9jaywgZmxhZ3MpOwogCiAJd2l0aF9pbnRlbF9ydW50aW1lX3Bt KHJ1bnRpbWVfcG0sIHdha2VyZWYpCi0JCV9fZ3VjX2NvbnRleHRfc2NoZWRfZGlzYWJsZShndWMs IGNlLCBndWNfaWQpOworCQlfX2d1Y19jb250ZXh0X3NjaGVkX2Rpc2FibGUoY2VfdG9fZ3VjKGNl KSwgY2UsIGd1Y19pZCk7CiAKIAlyZXR1cm47CiB1bnBpbjoKQEAgLTI0MjgsNyArMjQ4OSw3IEBA IHN0YXRpYyB2b2lkIHJlbW92ZV9mcm9tX2NvbnRleHQoc3RydWN0IGk5MTVfcmVxdWVzdCAqcnEp CiAJaWYgKGxpa2VseSghcmVxdWVzdF9oYXNfbm9fZ3VjX2lkKHJxKSkpCiAJCWF0b21pY19kZWMo JmNlLT5ndWNfaWRfcmVmKTsKIAllbHNlCi0JCS0tY2VfdG9fZ3VjKHJxLT5jb250ZXh0KS0+dG90 YWxfbnVtX3JxX3dpdGhfbm9fZ3VjX2lkOworCQktLWNlX3RvX2dzZShycS0+Y29udGV4dCktPnRv dGFsX251bV9ycV93aXRoX25vX2d1Y19pZDsKIAl1bnBpbl9ndWNfaWQoY2VfdG9fZ3VjKGNlKSwg Y2UsIGZhbHNlKTsKIAogCWk5MTVfcmVxdWVzdF9ub3RpZnlfZXhlY3V0ZV9jYl9pbW0ocnEpOwpA QCAtMjQ4OSwxMyArMjU1MCwxNCBAQCBzdGF0aWMgdm9pZCBpbnZhbGlkYXRlX2d1Y19pZF9zY2hl ZF9kaXNhYmxlKHN0cnVjdCBpbnRlbF9jb250ZXh0ICpjZSkKIAljbHJfY29udGV4dF9ndWNfaWRf c3RvbGVuKGNlKTsKIH0KIAotc3RhdGljIHZvaWQgcmV0aXJlX3dvcmtlcl9zY2hlZF9kaXNhYmxl KHN0cnVjdCBpbnRlbF9ndWMgKmd1YywKK3N0YXRpYyB2b2lkIHJldGlyZV93b3JrZXJfc2NoZWRf ZGlzYWJsZShzdHJ1Y3QgZ3VjX3N1Ym1pdF9lbmdpbmUgKmdzZSwKIAkJCQkJc3RydWN0IGludGVs X2NvbnRleHQgKmNlKQogeworCXN0cnVjdCBpbnRlbF9ndWMgKmd1YyA9IGdzZS0+c2NoZWRfZW5n aW5lLnByaXZhdGVfZGF0YTsKIAl1bnNpZ25lZCBsb25nIGZsYWdzOwogCWJvb2wgZGlzYWJsZWQ7 CiAKLQlndWMtPnN0YWxsZWRfY29udGV4dCA9IE5VTEw7CisJZ3NlLT5zdGFsbGVkX2NvbnRleHQg PSBOVUxMOwogCXNwaW5fbG9ja19pcnFzYXZlKCZjZS0+Z3VjX3N0YXRlLmxvY2ssIGZsYWdzKTsK IAlkaXNhYmxlZCA9IHN1Ym1pc3Npb25fZGlzYWJsZWQoZ3VjKTsKIAlpZiAoIWRpc2FibGVkICYm ICFjb250ZXh0X3BlbmRpbmdfZGlzYWJsZShjZSkgJiYgY29udGV4dF9lbmFibGVkKGNlKSkgewpA QCAtMjU0MSwxMCArMjYwMywxMCBAQCBzdGF0aWMgdm9pZCByZXRpcmVfd29ya2VyX3NjaGVkX2Rp c2FibGUoc3RydWN0IGludGVsX2d1YyAqZ3VjLAogCiAJCWludmFsaWRhdGVfZ3VjX2lkX3NjaGVk X2Rpc2FibGUoY2UpOwogCi0JCWd1Yy0+c3VibWlzc2lvbl9zdGFsbF9yZWFzb24gPSBTVEFMTF9S RUdJU1RFUl9DT05URVhUOwotCQljbHJfdGFza2xldF9ibG9ja2VkKGd1Yyk7CisJCWdzZS0+c3Vi bWlzc2lvbl9zdGFsbF9yZWFzb24gPSBTVEFMTF9SRUdJU1RFUl9DT05URVhUOworCQljbHJfdGFz a2xldF9ibG9ja2VkKGdzZSk7CiAKLQkJa2lja190YXNrbGV0KGNlX3RvX2d1YyhjZSkpOworCQlr aWNrX3Rhc2tsZXQoZ3NlKTsKIAl9CiAKIAlpbnRlbF9jb250ZXh0X3B1dChjZSk7CkBAIC0yNTU3 LDI1ICsyNjE5LDI2IEBAIHN0YXRpYyBib29sIGNvbnRleHRfbmVlZHNfbHJjX2Rlc2NfcGluKHN0 cnVjdCBpbnRlbF9jb250ZXh0ICpjZSwgYm9vbCBuZXdfZ3VjX2lkCiAJCSFzdWJtaXNzaW9uX2Rp c2FibGVkKGNlX3RvX2d1YyhjZSkpOwogfQogCi1zdGF0aWMgaW50IHRhc2tsZXRfcGluX2d1Y19p ZChzdHJ1Y3QgaW50ZWxfZ3VjICpndWMsIHN0cnVjdCBpOTE1X3JlcXVlc3QgKnJxKQorc3RhdGlj IGludCB0YXNrbGV0X3Bpbl9ndWNfaWQoc3RydWN0IGd1Y19zdWJtaXRfZW5naW5lICpnc2UsCisJ CQkgICAgICBzdHJ1Y3QgaTkxNV9yZXF1ZXN0ICpycSkKIHsKIAlzdHJ1Y3QgaW50ZWxfY29udGV4 dCAqY2UgPSBycS0+Y29udGV4dDsKIAlpbnQgcmV0ID0gMDsKIAotCWxvY2tkZXBfYXNzZXJ0X2hl bGQoJmd1Yy0+c2NoZWRfZW5naW5lLT5sb2NrKTsKKwlsb2NrZGVwX2Fzc2VydF9oZWxkKCZnc2Ut PnNjaGVkX2VuZ2luZS5sb2NrKTsKIAlHRU1fQlVHX09OKCFjZS0+Z3VjX251bV9ycV9zdWJtaXRf bm9faWQpOwogCiAJaWYgKGF0b21pY19hZGRfdW5sZXNzKCZjZS0+Z3VjX2lkX3JlZiwgY2UtPmd1 Y19udW1fcnFfc3VibWl0X25vX2lkLCAwKSkKIAkJZ290byBvdXQ7CiAKLQlyZXQgPSBwaW5fZ3Vj X2lkKGd1YywgY2UsIHRydWUpOworCXJldCA9IHBpbl9ndWNfaWQoZ3NlLT5zY2hlZF9lbmdpbmUu cHJpdmF0ZV9kYXRhLCBjZSwgdHJ1ZSk7CiAJaWYgKHVubGlrZWx5KHJldCA8IDApKSB7CiAJCS8q CiAJCSAqIE5vIGd1Y19pZHMgYXZhaWxhYmxlLCBkaXNhYmxlIHRoZSB0YXNrbGV0IGFuZCBraWNr IHRoZSByZXRpcmUKIAkJICogd29ya3F1ZXVlIGhvcGVmdWxseSBmcmVlaW5nIHVwIHNvbWUgZ3Vj X2lkcy4KIAkJICovCi0JCWd1Yy0+c3RhbGxlZF9ycSA9IHJxOwotCQlndWMtPnN1Ym1pc3Npb25f c3RhbGxfcmVhc29uID0gU1RBTExfR1VDX0lEX1dPUktRVUVVRTsKKwkJZ3NlLT5zdGFsbGVkX3Jx ID0gcnE7CisJCWdzZS0+c3VibWlzc2lvbl9zdGFsbF9yZWFzb24gPSBTVEFMTF9HVUNfSURfV09S S1FVRVVFOwogCQlyZXR1cm4gcmV0OwogCX0KIApAQCAtMjU4NywxNCArMjY1MCwxNCBAQCBzdGF0 aWMgaW50IHRhc2tsZXRfcGluX2d1Y19pZChzdHJ1Y3QgaW50ZWxfZ3VjICpndWMsIHN0cnVjdCBp OTE1X3JlcXVlc3QgKnJxKQogCQlzZXRfY29udGV4dF9uZWVkc19yZWdpc3RlcihjZSk7CiAKIAlp ZiAocmV0ID09IE5FV19HVUNfSURfRU5BQkxFRCkgewotCQlndWMtPnN0YWxsZWRfcnEgPSBycTsK LQkJZ3VjLT5zdWJtaXNzaW9uX3N0YWxsX3JlYXNvbiA9IFNUQUxMX1NDSEVEX0RJU0FCTEU7CisJ CWdzZS0+c3RhbGxlZF9ycSA9IHJxOworCQlnc2UtPnN1Ym1pc3Npb25fc3RhbGxfcmVhc29uID0g U1RBTExfU0NIRURfRElTQUJMRTsKIAl9CiAKIAljbGVhcl9iaXQoQ09OVEVYVF9MUkNBX0RJUlRZ LCAmY2UtPmZsYWdzKTsKIG91dDoKLQlndWMtPnRvdGFsX251bV9ycV93aXRoX25vX2d1Y19pZCAt PSBjZS0+Z3VjX251bV9ycV9zdWJtaXRfbm9faWQ7Ci0JR0VNX0JVR19PTihndWMtPnRvdGFsX251 bV9ycV93aXRoX25vX2d1Y19pZCA8IDApOworCWdzZS0+dG90YWxfbnVtX3JxX3dpdGhfbm9fZ3Vj X2lkIC09IGNlLT5ndWNfbnVtX3JxX3N1Ym1pdF9ub19pZDsKKwlHRU1fQlVHX09OKGdzZS0+dG90 YWxfbnVtX3JxX3dpdGhfbm9fZ3VjX2lkIDwgMCk7CiAKIAlsaXN0X2Zvcl9lYWNoX2VudHJ5X3Jl dmVyc2UocnEsICZjZS0+Z3VjX2FjdGl2ZS5yZXF1ZXN0cywgc2NoZWQubGluaykKIAkJaWYgKHJl cXVlc3RfaGFzX25vX2d1Y19pZChycSkpIHsKQEAgLTI2MTIsNyArMjY3NSw3IEBAIHN0YXRpYyBp bnQgdGFza2xldF9waW5fZ3VjX2lkKHN0cnVjdCBpbnRlbF9ndWMgKmd1Yywgc3RydWN0IGk5MTVf cmVxdWVzdCAqcnEpCiAJICogZnJvbSBhIGNvbnRleHQgdGhhdCBoYXMgc2NoZWR1bGluZyBlbmFi bGVkLiBXZSBoYXZlIHRvIGRpc2FibGUKIAkgKiBzY2hlZHVsaW5nIGJlZm9yZSBkZXJlZ2lzdGVy aW5nIHRoZSBjb250ZXh0IGFuZCBpdCBpc24ndCBzYWZlIHRvIGRvCiAJICogaW4gdGhlIHRhc2ts ZXQgYmVjYXVzZSBvZiBsb2NrIGludmVyc2lvbiAoY2UtPmd1Y19zdGF0ZS5sb2NrIG11c3QgYmUK LQkgKiBhY3F1aXJlZCBiZWZvcmUgZ3VjLT5zY2hlZF9lbmdpbmUtPmxvY2spLiBUbyB3b3JrIGFy b3VuZCB0aGlzCisJICogYWNxdWlyZWQgYmVmb3JlIGdzZS0+c2NoZWRfZW5naW5lLmxvY2spLiBU byB3b3JrIGFyb3VuZCB0aGlzCiAJICogd2UgZG8gdGhlIHNjaGVkdWxlIGRpc2FibGUgaW4gcmV0 aXJlIHdvcmtxdWV1ZSBhbmQgYmxvY2sgdGhlIHRhc2tsZXQKIAkgKiB1bnRpbCB0aGUgc2NoZWR1 bGUgZG9uZSBHMkggcmV0dXJucy4gUmV0dXJuaW5nIG5vbi16ZXJvIGhlcmUga2lja3MKIAkgKiB0 aGUgd29ya3F1ZXVlLgpAQCAtMjYyNCw2ICsyNjg3LDcgQEAgc3RhdGljIGludCBndWNfcmVxdWVz dF9hbGxvYyhzdHJ1Y3QgaTkxNV9yZXF1ZXN0ICpycSkKIHsKIAlzdHJ1Y3QgaW50ZWxfY29udGV4 dCAqY2UgPSBycS0+Y29udGV4dDsKIAlzdHJ1Y3QgaW50ZWxfZ3VjICpndWMgPSBjZV90b19ndWMo Y2UpOworCXN0cnVjdCBndWNfc3VibWl0X2VuZ2luZSAqZ3NlID0gY2VfdG9fZ3NlKGNlKTsKIAl1 bnNpZ25lZCBsb25nIGZsYWdzOwogCWludCByZXQ7CiAKQEAgLTI2MzUsOCArMjY5OSw4IEBAIHN0 YXRpYyBpbnQgZ3VjX3JlcXVlc3RfYWxsb2Moc3RydWN0IGk5MTVfcmVxdWVzdCAqcnEpCiAJICog cmVhZHkgdG8gc3VibWl0KS4gRG9uJ3QgYWxsb2NhdGUgb25lIGhlcmUsIGRlZmVyIHRvIHN1Ym1p c3Npb24gaW4gdGhlCiAJICogdGFza2xldC4KIAkgKi8KLQlpZiAodGVzdF9hbmRfdXBkYXRlX2d1 Y19pZHNfZXhoYXVzdGVkKGd1YykgfHwKLQkgICAgdG9vX21hbnlfZ3VjX2lkc19ub3RfcmVhZHko Z3VjLCBjZSkpIHsKKwlpZiAodGVzdF9hbmRfdXBkYXRlX2d1Y19pZHNfZXhoYXVzdGVkKGdzZSkg fHwKKwkgICAgdG9vX21hbnlfZ3VjX2lkc19ub3RfcmVhZHkoZ3NlLCBjZSkpIHsKIAkJc2V0X2Jp dChJOTE1X0ZFTkNFX0ZMQUdfR1VDX0lEX05PVF9QSU5ORUQsICZycS0+ZmVuY2UuZmxhZ3MpOwog CQlnb3RvIG91dDsKIAl9CkBAIC0yNjkxLDcgKzI3NTUsNyBAQCBzdGF0aWMgaW50IGd1Y19yZXF1 ZXN0X2FsbG9jKHN0cnVjdCBpOTE1X3JlcXVlc3QgKnJxKQogCQkgKiBzdWJtaXNzaW9ucyB3ZSBy ZXR1cm4gdG8gYWxsb2NhdGluZyBndWNfaWRzIGluIHRoaXMgZnVuY3Rpb24uCiAJCSAqLwogCQlz ZXRfYml0KEk5MTVfRkVOQ0VfRkxBR19HVUNfSURfTk9UX1BJTk5FRCwgJnJxLT5mZW5jZS5mbGFn cyk7Ci0JCXNldF9hbmRfdXBkYXRlX2d1Y19pZHNfZXhoYXVzdGVkKGd1Yyk7CisJCXNldF9hbmRf dXBkYXRlX2d1Y19pZHNfZXhoYXVzdGVkKGdzZSk7CiAJCWluY3JfbnVtX3JxX25vdF9yZWFkeShj ZSk7CiAKIAkJcmV0dXJuIDA7CkBAIC0zMDk5LDE3ICszMTYzLDQxIEBAIHN0YXRpYyB2b2lkIGd1 Y19zY2hlZF9lbmdpbmVfZGVzdHJveShzdHJ1Y3Qga3JlZiAqa3JlZikKIHsKIAlzdHJ1Y3QgaTkx NV9zY2hlZF9lbmdpbmUgKnNjaGVkX2VuZ2luZSA9CiAJCWNvbnRhaW5lcl9vZihrcmVmLCB0eXBl b2YoKnNjaGVkX2VuZ2luZSksIHJlZik7Ci0Jc3RydWN0IGludGVsX2d1YyAqZ3VjID0gc2NoZWRf ZW5naW5lLT5wcml2YXRlX2RhdGE7CisJc3RydWN0IGd1Y19zdWJtaXRfZW5naW5lICpnc2UgPQor CQljb250YWluZXJfb2Yoc2NoZWRfZW5naW5lLCB0eXBlb2YoKmdzZSksIHNjaGVkX2VuZ2luZSk7 CisJc3RydWN0IGludGVsX2d1YyAqZ3VjID0gZ3NlLT5zY2hlZF9lbmdpbmUucHJpdmF0ZV9kYXRh OwogCi0JZ3VjLT5zY2hlZF9lbmdpbmUgPSBOVUxMOworCWd1Yy0+Z3NlW2dzZS0+aWRdID0gTlVM TDsKIAl0YXNrbGV0X2tpbGwoJnNjaGVkX2VuZ2luZS0+dGFza2xldCk7IC8qIGZsdXNoIHRoZSBj YWxsYmFjayAqLwotCWtmcmVlKHNjaGVkX2VuZ2luZSk7CisJa2ZyZWUoZ3NlKTsKK30KKworc3Rh dGljIHZvaWQgZ3VjX3N1Ym1pdF9lbmdpbmVfaW5pdChzdHJ1Y3QgaW50ZWxfZ3VjICpndWMsCisJ CQkJICAgc3RydWN0IGd1Y19zdWJtaXRfZW5naW5lICpnc2UsCisJCQkJICAgaW50IGlkKQorewor CXN0cnVjdCBpOTE1X3NjaGVkX2VuZ2luZSAqc2NoZWRfZW5naW5lID0gJmdzZS0+c2NoZWRfZW5n aW5lOworCisJaTkxNV9zY2hlZF9lbmdpbmVfaW5pdChzY2hlZF9lbmdpbmUsIEVOR0lORV9WSVJU VUFMKTsKKwlJTklUX1dPUksoJmdzZS0+cmV0aXJlX3dvcmtlciwgcmV0aXJlX3dvcmtlcl9mdW5j KTsKKwl0YXNrbGV0X3NldHVwKCZzY2hlZF9lbmdpbmUtPnRhc2tsZXQsIGdzZV9zdWJtaXNzaW9u X3Rhc2tsZXQpOworCXNjaGVkX2VuZ2luZS0+c2NoZWR1bGUgPSBpOTE1X3NjaGVkdWxlOworCXNj aGVkX2VuZ2luZS0+ZGlzYWJsZWQgPSBndWNfc2NoZWRfZW5naW5lX2Rpc2FibGVkOworCXNjaGVk X2VuZ2luZS0+ZGVzdHJveSA9IGd1Y19zY2hlZF9lbmdpbmVfZGVzdHJveTsKKwlzY2hlZF9lbmdp bmUtPmJ1bXBfaW5mbGlnaHRfcmVxdWVzdF9wcmlvID0KKwkJZ3VjX2J1bXBfaW5mbGlnaHRfcmVx dWVzdF9wcmlvOworCXNjaGVkX2VuZ2luZS0+cmV0aXJlX2luZmxpZ2h0X3JlcXVlc3RfcHJpbyA9 CisJCWd1Y19yZXRpcmVfaW5mbGlnaHRfcmVxdWVzdF9wcmlvOworCXNjaGVkX2VuZ2luZS0+cHJp dmF0ZV9kYXRhID0gZ3VjOworCWdzZS0+aWQgPSBpZDsKIH0KIAogaW50IGludGVsX2d1Y19zdWJt aXNzaW9uX3NldHVwKHN0cnVjdCBpbnRlbF9lbmdpbmVfY3MgKmVuZ2luZSkKIHsKIAlzdHJ1Y3Qg ZHJtX2k5MTVfcHJpdmF0ZSAqaTkxNSA9IGVuZ2luZS0+aTkxNTsKIAlzdHJ1Y3QgaW50ZWxfZ3Vj ICpndWMgPSAmZW5naW5lLT5ndC0+dWMuZ3VjOworCXN0cnVjdCBpOTE1X3NjaGVkX2VuZ2luZSAq c2NoZWRfZW5naW5lOworCWludCByZXQsIGk7CiAKIAkvKgogCSAqIFRoZSBzZXR1cCByZWxpZXMg b24gc2V2ZXJhbCBhc3N1bXB0aW9ucyAoZS5nLiBpcnFzIGFsd2F5cyBlbmFibGVkKQpAQCAtMzEx NywyNCArMzIwNSwyMCBAQCBpbnQgaW50ZWxfZ3VjX3N1Ym1pc3Npb25fc2V0dXAoc3RydWN0IGlu dGVsX2VuZ2luZV9jcyAqZW5naW5lKQogCSAqLwogCUdFTV9CVUdfT04oR1JBUEhJQ1NfVkVSKGk5 MTUpIDwgMTEpOwogCi0JaWYgKCFndWMtPnNjaGVkX2VuZ2luZSkgewotCQlndWMtPnNjaGVkX2Vu Z2luZSA9IGk5MTVfc2NoZWRfZW5naW5lX2NyZWF0ZShFTkdJTkVfVklSVFVBTCk7Ci0JCWlmICgh Z3VjLT5zY2hlZF9lbmdpbmUpCi0JCQlyZXR1cm4gLUVOT01FTTsKLQotCQlndWMtPnNjaGVkX2Vu Z2luZS0+c2NoZWR1bGUgPSBpOTE1X3NjaGVkdWxlOwotCQlndWMtPnNjaGVkX2VuZ2luZS0+ZGlz YWJsZWQgPSBndWNfc2NoZWRfZW5naW5lX2Rpc2FibGVkOwotCQlndWMtPnNjaGVkX2VuZ2luZS0+ cHJpdmF0ZV9kYXRhID0gZ3VjOwotCQlndWMtPnNjaGVkX2VuZ2luZS0+ZGVzdHJveSA9IGd1Y19z Y2hlZF9lbmdpbmVfZGVzdHJveTsKLQkJZ3VjLT5zY2hlZF9lbmdpbmUtPmJ1bXBfaW5mbGlnaHRf cmVxdWVzdF9wcmlvID0KLQkJCWd1Y19idW1wX2luZmxpZ2h0X3JlcXVlc3RfcHJpbzsKLQkJZ3Vj LT5zY2hlZF9lbmdpbmUtPnJldGlyZV9pbmZsaWdodF9yZXF1ZXN0X3ByaW8gPQotCQkJZ3VjX3Jl dGlyZV9pbmZsaWdodF9yZXF1ZXN0X3ByaW87Ci0JCXRhc2tsZXRfc2V0dXAoJmd1Yy0+c2NoZWRf ZW5naW5lLT50YXNrbGV0LAotCQkJICAgICAgZ3VjX3N1Ym1pc3Npb25fdGFza2xldCk7CisJaWYg KCFndWMtPmdzZVswXSkgeworCQlmb3IgKGkgPSAwOyBpIDwgR1VDX1NVQk1JVF9FTkdJTkVfTUFY OyArK2kpIHsKKwkJCWd1Yy0+Z3NlW2ldID0ga3phbGxvYyhzaXplb2YoKmd1Yy0+Z3NlW2ldKSwg R0ZQX0tFUk5FTCk7CisJCQlpZiAoIWd1Yy0+Z3NlW2ldKSB7CisJCQkJcmV0ID0gLUVOT01FTTsK KwkJCQlnb3RvIHB1dF9zY2hlZF9lbmdpbmU7CisJCQl9CisJCQlndWNfc3VibWl0X2VuZ2luZV9p bml0KGd1YywgZ3VjLT5nc2VbaV0sIGkpOworCQl9CiAJfQorCisJc2NoZWRfZW5naW5lID0gZ3Vj X3RvX3NjaGVkX2VuZ2luZShndWMsIEdVQ19TVUJNSVRfRU5HSU5FX1NJTkdMRV9MUkMpOwogCWk5 MTVfc2NoZWRfZW5naW5lX3B1dChlbmdpbmUtPnNjaGVkX2VuZ2luZSk7Ci0JZW5naW5lLT5zY2hl ZF9lbmdpbmUgPSBpOTE1X3NjaGVkX2VuZ2luZV9nZXQoZ3VjLT5zY2hlZF9lbmdpbmUpOworCWVu Z2luZS0+c2NoZWRfZW5naW5lID0gaTkxNV9zY2hlZF9lbmdpbmVfZ2V0KHNjaGVkX2VuZ2luZSk7 CiAKIAlndWNfZGVmYXVsdF92ZnVuY3MoZW5naW5lKTsKIAlndWNfZGVmYXVsdF9pcnFzKGVuZ2lu ZSk7CkBAIC0zMTUwLDYgKzMyMzQsMTYgQEAgaW50IGludGVsX2d1Y19zdWJtaXNzaW9uX3NldHVw KHN0cnVjdCBpbnRlbF9lbmdpbmVfY3MgKmVuZ2luZSkKIAllbmdpbmUtPnJlbGVhc2UgPSBndWNf cmVsZWFzZTsKIAogCXJldHVybiAwOworCitwdXRfc2NoZWRfZW5naW5lOgorCWZvciAoaSA9IDA7 IGkgPCBHVUNfU1VCTUlUX0VOR0lORV9NQVg7ICsraSkgeworCQlzdHJ1Y3QgaTkxNV9zY2hlZF9l bmdpbmUgKnNjaGVkX2VuZ2luZSA9CisJCQlndWNfdG9fc2NoZWRfZW5naW5lKGd1YywgaSk7CisK KwkJaWYgKHNjaGVkX2VuZ2luZSkKKwkJCWk5MTVfc2NoZWRfZW5naW5lX3B1dChzY2hlZF9lbmdp bmUpOworCX0KKwlyZXR1cm4gcmV0OwogfQogCiB2b2lkIGludGVsX2d1Y19zdWJtaXNzaW9uX2Vu YWJsZShzdHJ1Y3QgaW50ZWxfZ3VjICpndWMpCkBAIC0zMjQ5LDE0ICszMzQzLDE2IEBAIGludCBp bnRlbF9ndWNfZGVyZWdpc3Rlcl9kb25lX3Byb2Nlc3NfbXNnKHN0cnVjdCBpbnRlbF9ndWMgKmd1 YywKIAkJCXJlZ2lzdGVyX2NvbnRleHQoY2UsIHRydWUpOwogCQlndWNfc2lnbmFsX2NvbnRleHRf ZmVuY2UoY2UpOwogCQlpZiAoY29udGV4dF9ibG9ja190YXNrbGV0KGNlKSkgewotCQkJR0VNX0JV R19PTihndWMtPnN1Ym1pc3Npb25fc3RhbGxfcmVhc29uICE9CisJCQlzdHJ1Y3QgZ3VjX3N1Ym1p dF9lbmdpbmUgKmdzZSA9IGNlX3RvX2dzZShjZSk7CisKKwkJCUdFTV9CVUdfT04oZ3NlLT5zdWJt aXNzaW9uX3N0YWxsX3JlYXNvbiAhPQogCQkJCSAgIFNUQUxMX0RFUkVHSVNURVJfQ09OVEVYVCk7 CiAKIAkJCWNscl9jb250ZXh0X2Jsb2NrX3Rhc2tsZXQoY2UpOwotCQkJZ3VjLT5zdWJtaXNzaW9u X3N0YWxsX3JlYXNvbiA9IFNUQUxMX01PVkVfTFJDX1RBSUw7Ci0JCQljbHJfdGFza2xldF9ibG9j a2VkKGd1Yyk7CisJCQlnc2UtPnN1Ym1pc3Npb25fc3RhbGxfcmVhc29uID0gU1RBTExfTU9WRV9M UkNfVEFJTDsKKwkJCWNscl90YXNrbGV0X2Jsb2NrZWQoZ3NlKTsKIAotCQkJa2lja190YXNrbGV0 KGNlX3RvX2d1YyhjZSkpOworCQkJa2lja190YXNrbGV0KGdzZSk7CiAJCX0KIAkJaW50ZWxfY29u dGV4dF9wdXQoY2UpOwogCX0gZWxzZSBpZiAoY29udGV4dF9kZXN0cm95ZWQoY2UpKSB7CkBAIC0z MzIyLDExICszNDE4LDEzIEBAIGludCBpbnRlbF9ndWNfc2NoZWRfZG9uZV9wcm9jZXNzX21zZyhz dHJ1Y3QgaW50ZWxfZ3VjICpndWMsCiAJCXNwaW5fdW5sb2NrX2lycXJlc3RvcmUoJmNlLT5ndWNf c3RhdGUubG9jaywgZmxhZ3MpOwogCiAJCWlmIChjb250ZXh0X2Jsb2NrX3Rhc2tsZXQoY2UpKSB7 CisJCQlzdHJ1Y3QgZ3VjX3N1Ym1pdF9lbmdpbmUgKmdzZSA9IGNlX3RvX2dzZShjZSk7CisKIAkJ CWNscl9jb250ZXh0X2Jsb2NrX3Rhc2tsZXQoY2UpOwotCQkJZ3VjLT5zdWJtaXNzaW9uX3N0YWxs X3JlYXNvbiA9IFNUQUxMX1JFR0lTVEVSX0NPTlRFWFQ7Ci0JCQljbHJfdGFza2xldF9ibG9ja2Vk KGd1Yyk7CisJCQlnc2UtPnN1Ym1pc3Npb25fc3RhbGxfcmVhc29uID0gU1RBTExfUkVHSVNURVJf Q09OVEVYVDsKKwkJCWNscl90YXNrbGV0X2Jsb2NrZWQoZ3NlKTsKIAotCQkJa2lja190YXNrbGV0 KGNlX3RvX2d1YyhjZSkpOworCQkJa2lja190YXNrbGV0KGdzZSk7CiAJCX0KIAogCQlpZiAoYmFu bmVkKSB7CkBAIC0zMzU4LDcgKzM0NTYsNyBAQCBzdGF0aWMgdm9pZCBjYXB0dXJlX2Vycm9yX3N0 YXRlKHN0cnVjdCBpbnRlbF9ndWMgKmd1YywKIHN0YXRpYyB2b2lkIGd1Y19jb250ZXh0X3JlcGxh eShzdHJ1Y3QgaW50ZWxfY29udGV4dCAqY2UpCiB7CiAJX19ndWNfcmVzZXRfY29udGV4dChjZSwg dHJ1ZSk7Ci0Ja2lja190YXNrbGV0KGNlX3RvX2d1YyhjZSkpOworCWtpY2tfdGFza2xldChjZV90 b19nc2UoY2UpKTsKIH0KIAogc3RhdGljIHZvaWQgZ3VjX2hhbmRsZV9jb250ZXh0X3Jlc2V0KHN0 cnVjdCBpbnRlbF9ndWMgKmd1YywKQEAgLTM1MDMsMzUgKzM2MDEsMzIgQEAgdm9pZCBpbnRlbF9n dWNfZHVtcF9hY3RpdmVfcmVxdWVzdHMoc3RydWN0IGludGVsX2VuZ2luZV9jcyAqZW5naW5lLAog CX0KIH0KIAotdm9pZCBpbnRlbF9ndWNfc3VibWlzc2lvbl9wcmludF9pbmZvKHN0cnVjdCBpbnRl bF9ndWMgKmd1YywKLQkJCQkgICAgIHN0cnVjdCBkcm1fcHJpbnRlciAqcCkKK3N0YXRpYyB2b2lk IGdzZV9sb2dfc3VibWlzc2lvbl9pbmZvKHN0cnVjdCBndWNfc3VibWl0X2VuZ2luZSAqZ3NlLAor CQkJCSAgICBzdHJ1Y3QgZHJtX3ByaW50ZXIgKnAsIGludCBpZCkKIHsKLQlzdHJ1Y3QgaTkxNV9z Y2hlZF9lbmdpbmUgKnNjaGVkX2VuZ2luZSA9IGd1Yy0+c2NoZWRfZW5naW5lOworCXN0cnVjdCBp OTE1X3NjaGVkX2VuZ2luZSAqc2NoZWRfZW5naW5lID0gJmdzZS0+c2NoZWRfZW5naW5lOwogCXN0 cnVjdCByYl9ub2RlICpyYjsKIAl1bnNpZ25lZCBsb25nIGZsYWdzOwogCiAJaWYgKCFzY2hlZF9l bmdpbmUpCiAJCXJldHVybjsKIAotCWRybV9wcmludGYocCwgIkd1QyBOdW1iZXIgT3V0c3RhbmRp bmcgU3VibWlzc2lvbiBHMkg6ICV1XG4iLAotCQkgICBhdG9taWNfcmVhZCgmZ3VjLT5vdXRzdGFu ZGluZ19zdWJtaXNzaW9uX2cyaCkpOwotCWRybV9wcmludGYocCwgIkd1QyBOdW1iZXIgR3VDIElE czogJXVcbiIsIGd1Yy0+bnVtX2d1Y19pZHMpOwotCWRybV9wcmludGYocCwgIkd1QyBNYXggR3VD IElEczogJXVcbiIsIGd1Yy0+bWF4X2d1Y19pZHMpOwotCWRybV9wcmludGYocCwgIkd1QyB0YXNr bGV0IGNvdW50OiAldVxuIiwKKwlkcm1fcHJpbnRmKHAsICJHU0VbJWRdIHRhc2tsZXQgY291bnQ6 ICV1XG4iLCBpZCwKIAkJICAgYXRvbWljX3JlYWQoJnNjaGVkX2VuZ2luZS0+dGFza2xldC5jb3Vu dCkpOwotCWRybV9wcmludGYocCwgIkd1QyBzdWJtaXQgZmxhZ3M6IDB4JTA0bHhcbiIsIGd1Yy0+ ZmxhZ3MpOwotCWRybV9wcmludGYocCwgIkd1QyB0b3RhbCBudW1iZXIgcmVxdWVzdCB3aXRob3V0 IGd1Y19pZDogJWRcbiIsCi0JCSAgIGd1Yy0+dG90YWxfbnVtX3JxX3dpdGhfbm9fZ3VjX2lkKTsK LQlkcm1fcHJpbnRmKHAsICJHdUMgTnVtYmVyIEd1QyBJRHMgbm90IHJlYWR5OiAlZFxuIiwKLQkJ ICAgYXRvbWljX3JlYWQoJmd1Yy0+bnVtX2d1Y19pZHNfbm90X3JlYWR5KSk7Ci0JZHJtX3ByaW50 ZihwLCAiR3VDIHN0YWxsIHJlYXNvbjogJWRcbiIsIGd1Yy0+c3VibWlzc2lvbl9zdGFsbF9yZWFz b24pOwotCWRybV9wcmludGYocCwgIkd1QyBzdGFsbGVkIHJlcXVlc3Q6ICVzXG4iLAotCQkgICB5 ZXNubyhndWMtPnN0YWxsZWRfcnEpKTsKLQlkcm1fcHJpbnRmKHAsICJHdUMgc3RhbGxlZCBjb250 ZXh0OiAlc1xuXG4iLAotCQkgICB5ZXNubyhndWMtPnN0YWxsZWRfY29udGV4dCkpOworCWRybV9w cmludGYocCwgIkdTRVslZF0gc3VibWl0IGZsYWdzOiAweCUwNGx4XG4iLCBpZCwgZ3NlLT5mbGFn cyk7CisJZHJtX3ByaW50ZihwLCAiR1NFWyVkXSB0b3RhbCBudW1iZXIgcmVxdWVzdCB3aXRob3V0 IGd1Y19pZDogJWRcbiIsCisJCSAgIGlkLCBnc2UtPnRvdGFsX251bV9ycV93aXRoX25vX2d1Y19p ZCk7CisJZHJtX3ByaW50ZihwLCAiR1NFWyVkXSBOdW1iZXIgR3VDIElEcyBub3QgcmVhZHk6ICVk XG4iLAorCQkgICBpZCwgYXRvbWljX3JlYWQoJmdzZS0+bnVtX2d1Y19pZHNfbm90X3JlYWR5KSk7 CisJZHJtX3ByaW50ZihwLCAiR1NFWyVkXSBzdGFsbCByZWFzb246ICVkXG4iLAorCQkgICBpZCwg Z3NlLT5zdWJtaXNzaW9uX3N0YWxsX3JlYXNvbik7CisJZHJtX3ByaW50ZihwLCAiR1NFWyVkXSBz dGFsbGVkIHJlcXVlc3Q6ICVzXG4iLAorCQkgICBpZCwgeWVzbm8oZ3NlLT5zdGFsbGVkX3JxKSk7 CisJZHJtX3ByaW50ZihwLCAiR1NFWyVkXSBzdGFsbGVkIGNvbnRleHQ6ICVzXG5cbiIsCisJCSAg IGlkLCB5ZXNubyhnc2UtPnN0YWxsZWRfY29udGV4dCkpOwogCiAJc3Bpbl9sb2NrX2lycXNhdmUo JnNjaGVkX2VuZ2luZS0+bG9jaywgZmxhZ3MpOwotCWRybV9wcmludGYocCwgIlJlcXVlc3RzIGlu IEd1QyBzdWJtaXQgdGFza2xldDpcbiIpOworCWRybV9wcmludGYocCwgIlJlcXVlc3RzIGluIEdT RVslZF0gc3VibWl0IHRhc2tsZXQ6XG4iLCBpZCk7CiAJZm9yIChyYiA9IHJiX2ZpcnN0X2NhY2hl ZCgmc2NoZWRfZW5naW5lLT5xdWV1ZSk7IHJiOyByYiA9IHJiX25leHQocmIpKSB7CiAJCXN0cnVj dCBpOTE1X3ByaW9saXN0ICpwbCA9IHRvX3ByaW9saXN0KHJiKTsKIAkJc3RydWN0IGk5MTVfcmVx dWVzdCAqcnE7CkBAIC0zNTYxLDYgKzM2NTYsMjAgQEAgc3RhdGljIGlubGluZSB2b2lkIGd1Y19s b2dfY29udGV4dF9wcmlvcml0eShzdHJ1Y3QgZHJtX3ByaW50ZXIgKnAsCiAJZHJtX3ByaW50Zihw LCAiXG4iKTsKIH0KIAordm9pZCBpbnRlbF9ndWNfc3VibWlzc2lvbl9wcmludF9pbmZvKHN0cnVj dCBpbnRlbF9ndWMgKmd1YywKKwkJCQkgICAgIHN0cnVjdCBkcm1fcHJpbnRlciAqcCkKK3sKKwlp bnQgaTsKKworCWRybV9wcmludGYocCwgIkd1QyBOdW1iZXIgT3V0c3RhbmRpbmcgU3VibWlzc2lv biBHMkg6ICV1XG4iLAorCQkgICBhdG9taWNfcmVhZCgmZ3VjLT5vdXRzdGFuZGluZ19zdWJtaXNz aW9uX2cyaCkpOworCWRybV9wcmludGYocCwgIkd1QyBOdW1iZXIgR3VDIElEczogJWRcbiIsIGd1 Yy0+bnVtX2d1Y19pZHMpOworCWRybV9wcmludGYocCwgIkd1QyBNYXggTnVtYmVyIEd1QyBJRHM6 ICVkXG5cbiIsIGd1Yy0+bWF4X2d1Y19pZHMpOworCisJZm9yIChpID0gMDsgaSA8IEdVQ19TVUJN SVRfRU5HSU5FX01BWDsgKytpKQorCQlnc2VfbG9nX3N1Ym1pc3Npb25faW5mbyhndWMtPmdzZVtp XSwgcCwgaSk7Cit9CisKIHZvaWQgaW50ZWxfZ3VjX3N1Ym1pc3Npb25fcHJpbnRfY29udGV4dF9p bmZvKHN0cnVjdCBpbnRlbF9ndWMgKmd1YywKIAkJCQkJICAgICBzdHJ1Y3QgZHJtX3ByaW50ZXIg KnApCiB7CkBAIC0zNTk0LDYgKzM3MDMsNyBAQCBndWNfY3JlYXRlX3ZpcnR1YWwoc3RydWN0IGlu dGVsX2VuZ2luZV9jcyAqKnNpYmxpbmdzLCB1bnNpZ25lZCBpbnQgY291bnQpCiB7CiAJc3RydWN0 IGd1Y192aXJ0dWFsX2VuZ2luZSAqdmU7CiAJc3RydWN0IGludGVsX2d1YyAqZ3VjOworCXN0cnVj dCBpOTE1X3NjaGVkX2VuZ2luZSAqc2NoZWRfZW5naW5lOwogCXVuc2lnbmVkIGludCBuOwogCWlu dCBlcnI7CiAKQEAgLTM2MDIsNiArMzcxMiw3IEBAIGd1Y19jcmVhdGVfdmlydHVhbChzdHJ1Y3Qg aW50ZWxfZW5naW5lX2NzICoqc2libGluZ3MsIHVuc2lnbmVkIGludCBjb3VudCkKIAkJcmV0dXJu IEVSUl9QVFIoLUVOT01FTSk7CiAKIAlndWMgPSAmc2libGluZ3NbMF0tPmd0LT51Yy5ndWM7CisJ c2NoZWRfZW5naW5lID0gZ3VjX3RvX3NjaGVkX2VuZ2luZShndWMsIEdVQ19TVUJNSVRfRU5HSU5F X1NJTkdMRV9MUkMpOwogCiAJdmUtPmJhc2UuaTkxNSA9IHNpYmxpbmdzWzBdLT5pOTE1OwogCXZl LT5iYXNlLmd0ID0gc2libGluZ3NbMF0tPmd0OwpAQCAtMzYxNSw3ICszNzI2LDcgQEAgZ3VjX2Ny ZWF0ZV92aXJ0dWFsKHN0cnVjdCBpbnRlbF9lbmdpbmVfY3MgKipzaWJsaW5ncywgdW5zaWduZWQg aW50IGNvdW50KQogCiAJc25wcmludGYodmUtPmJhc2UubmFtZSwgc2l6ZW9mKHZlLT5iYXNlLm5h bWUpLCAidmlydHVhbCIpOwogCi0JdmUtPmJhc2Uuc2NoZWRfZW5naW5lID0gaTkxNV9zY2hlZF9l bmdpbmVfZ2V0KGd1Yy0+c2NoZWRfZW5naW5lKTsKKwl2ZS0+YmFzZS5zY2hlZF9lbmdpbmUgPSBp OTE1X3NjaGVkX2VuZ2luZV9nZXQoc2NoZWRfZW5naW5lKTsKIAogCXZlLT5iYXNlLmNvcHMgPSAm dmlydHVhbF9ndWNfY29udGV4dF9vcHM7CiAJdmUtPmJhc2UucmVxdWVzdF9hbGxvYyA9IGd1Y19y ZXF1ZXN0X2FsbG9jOwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJtL2k5MTUvZ3QvdWMvaW50 ZWxfZ3VjX3N1Ym1pc3Npb25fdHlwZXMuaCBiL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2d0L3VjL2lu dGVsX2d1Y19zdWJtaXNzaW9uX3R5cGVzLmgKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAw MDAwMDAwMDAwLi4wYzIyNGFiMThjMDIKLS0tIC9kZXYvbnVsbAorKysgYi9kcml2ZXJzL2dwdS9k cm0vaTkxNS9ndC91Yy9pbnRlbF9ndWNfc3VibWlzc2lvbl90eXBlcy5oCkBAIC0wLDAgKzEsNTIg QEAKKy8qIFNQRFgtTGljZW5zZS1JZGVudGlmaWVyOiBNSVQgKi8KKy8qCisgKiBDb3B5cmlnaHQg wqkgMjAxNC0yMDE5IEludGVsIENvcnBvcmF0aW9uCisgKi8KKworI2lmbmRlZiBfSU5URUxfR1VD X1NVQk1JU1NJT05fVFlQRVNfSF8KKyNkZWZpbmUgX0lOVEVMX0dVQ19TVUJNSVNTSU9OX1RZUEVT X0hfCisKKyNpbmNsdWRlICJndC9pbnRlbF9lbmdpbmVfdHlwZXMuaCIKKyNpbmNsdWRlICJndC9p bnRlbF9jb250ZXh0X3R5cGVzLmgiCisjaW5jbHVkZSAiaTkxNV9zY2hlZHVsZXJfdHlwZXMuaCIK Kworc3RydWN0IGludGVsX2d1YzsKK3N0cnVjdCBpOTE1X3JlcXVlc3Q7CisKKy8qIEd1QyBWaXJ0 dWFsIEVuZ2luZSAqLworc3RydWN0IGd1Y192aXJ0dWFsX2VuZ2luZSB7CisJc3RydWN0IGludGVs X2VuZ2luZV9jcyBiYXNlOworCXN0cnVjdCBpbnRlbF9jb250ZXh0IGNvbnRleHQ7Cit9OworCisv KgorICogT2JqZWN0IHdoaWNoIGVuY2Fwc3VsYXRlcyB0aGUgZ2xvYmFsbHkgb3BlcmF0ZWQgb24g aTkxNV9zY2hlZF9lbmdpbmUgKworICogdGhlIEd1QyBzdWJtaXNzaW9uIHN0YXRlIG1hY2hpbmUg ZGVzY3JpYmVkIGluIGludGVsX2d1Y19zdWJtaXNzaW9uLmMuCisgKi8KK3N0cnVjdCBndWNfc3Vi bWl0X2VuZ2luZSB7CisJc3RydWN0IGk5MTVfc2NoZWRfZW5naW5lIHNjaGVkX2VuZ2luZTsKKwlz dHJ1Y3Qgd29ya19zdHJ1Y3QgcmV0aXJlX3dvcmtlcjsKKwlzdHJ1Y3QgaTkxNV9yZXF1ZXN0ICpz dGFsbGVkX3JxOworCXN0cnVjdCBpbnRlbF9jb250ZXh0ICpzdGFsbGVkX2NvbnRleHQ7CisJdW5z aWduZWQgbG9uZyBmbGFnczsKKwlpbnQgdG90YWxfbnVtX3JxX3dpdGhfbm9fZ3VjX2lkOworCWF0 b21pY190IG51bV9ndWNfaWRzX25vdF9yZWFkeTsKKwlpbnQgaWQ7CisKKwkvKgorCSAqIFN1Ym1p c3NvbiBzdGFsbCByZWFzb24uIFNlZSBpbnRlbF9ndWNfc3VibWlzc2lvbi5jIGZvciBkZXRhaWxl ZAorCSAqIGRlc2NyaXB0aW9uLgorCSAqLworCWVudW0geworCQlTVEFMTF9OT05FLAorCQlTVEFM TF9HVUNfSURfV09SS1FVRVVFLAorCQlTVEFMTF9HVUNfSURfVEFTS0xFVCwKKwkJU1RBTExfU0NI RURfRElTQUJMRSwKKwkJU1RBTExfUkVHSVNURVJfQ09OVEVYVCwKKwkJU1RBTExfREVSRUdJU1RF Ul9DT05URVhULAorCQlTVEFMTF9NT1ZFX0xSQ19UQUlMLAorCQlTVEFMTF9BRERfUkVRVUVTVCwK Kwl9IHN1Ym1pc3Npb25fc3RhbGxfcmVhc29uOworfTsKKworI2VuZGlmCmRpZmYgLS1naXQgYS9k cml2ZXJzL2dwdS9kcm0vaTkxNS9pOTE1X3NjaGVkdWxlci5jIGIvZHJpdmVycy9ncHUvZHJtL2k5 MTUvaTkxNV9zY2hlZHVsZXIuYwppbmRleCAzZmNjYWUzNjcyYzEuLmI5NTMwNTg0ZmMxZSAxMDA2 NDQKLS0tIGEvZHJpdmVycy9ncHUvZHJtL2k5MTUvaTkxNV9zY2hlZHVsZXIuYworKysgYi9kcml2 ZXJzL2dwdS9kcm0vaTkxNS9pOTE1X3NjaGVkdWxlci5jCkBAIC00NTIsMTUgKzQ1Miw5IEBAIHN0 YXRpYyBib29sIGRlZmF1bHRfZGlzYWJsZWQoc3RydWN0IGk5MTVfc2NoZWRfZW5naW5lICpzY2hl ZF9lbmdpbmUpCiAJcmV0dXJuIGZhbHNlOwogfQogCi1zdHJ1Y3QgaTkxNV9zY2hlZF9lbmdpbmUg KgotaTkxNV9zY2hlZF9lbmdpbmVfY3JlYXRlKHVuc2lnbmVkIGludCBzdWJjbGFzcykKK3ZvaWQg aTkxNV9zY2hlZF9lbmdpbmVfaW5pdChzdHJ1Y3QgaTkxNV9zY2hlZF9lbmdpbmUgKnNjaGVkX2Vu Z2luZSwKKwkJCSAgICB1bnNpZ25lZCBpbnQgc3ViY2xhc3MpCiB7Ci0Jc3RydWN0IGk5MTVfc2No ZWRfZW5naW5lICpzY2hlZF9lbmdpbmU7Ci0KLQlzY2hlZF9lbmdpbmUgPSBremFsbG9jKHNpemVv Zigqc2NoZWRfZW5naW5lKSwgR0ZQX0tFUk5FTCk7Ci0JaWYgKCFzY2hlZF9lbmdpbmUpCi0JCXJl dHVybiBOVUxMOwotCiAJa3JlZl9pbml0KCZzY2hlZF9lbmdpbmUtPnJlZik7CiAKIAlzY2hlZF9l bmdpbmUtPnF1ZXVlID0gUkJfUk9PVF9DQUNIRUQ7CkBAIC00ODUsNiArNDc5LDE4IEBAIGk5MTVf c2NoZWRfZW5naW5lX2NyZWF0ZSh1bnNpZ25lZCBpbnQgc3ViY2xhc3MpCiAJbG9ja19tYXBfcmVs ZWFzZSgmc2NoZWRfZW5naW5lLT5sb2NrLmRlcF9tYXApOwogCWxvY2FsX2lycV9lbmFibGUoKTsK ICNlbmRpZgorfQorCitzdHJ1Y3QgaTkxNV9zY2hlZF9lbmdpbmUgKgoraTkxNV9zY2hlZF9lbmdp bmVfY3JlYXRlKHVuc2lnbmVkIGludCBzdWJjbGFzcykKK3sKKwlzdHJ1Y3QgaTkxNV9zY2hlZF9l bmdpbmUgKnNjaGVkX2VuZ2luZTsKKworCXNjaGVkX2VuZ2luZSA9IGt6YWxsb2Moc2l6ZW9mKCpz Y2hlZF9lbmdpbmUpLCBHRlBfS0VSTkVMKTsKKwlpZiAoIXNjaGVkX2VuZ2luZSkKKwkJcmV0dXJu IE5VTEw7CisKKwlpOTE1X3NjaGVkX2VuZ2luZV9pbml0KHNjaGVkX2VuZ2luZSwgc3ViY2xhc3Mp OwogCiAJcmV0dXJuIHNjaGVkX2VuZ2luZTsKIH0KZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2Ry bS9pOTE1L2k5MTVfc2NoZWR1bGVyLmggYi9kcml2ZXJzL2dwdS9kcm0vaTkxNS9pOTE1X3NjaGVk dWxlci5oCmluZGV4IGY0ZDk4MTFhZGU1Yi4uYzdjMDkzYmMyOTcyIDEwMDY0NAotLS0gYS9kcml2 ZXJzL2dwdS9kcm0vaTkxNS9pOTE1X3NjaGVkdWxlci5oCisrKyBiL2RyaXZlcnMvZ3B1L2RybS9p OTE1L2k5MTVfc2NoZWR1bGVyLmgKQEAgLTQ4LDYgKzQ4LDkgQEAgc3RhdGljIGlubGluZSB2b2lk IGk5MTVfcHJpb2xpc3RfZnJlZShzdHJ1Y3QgaTkxNV9wcmlvbGlzdCAqcCkKIAkJX19pOTE1X3By aW9saXN0X2ZyZWUocCk7CiB9CiAKK3ZvaWQgaTkxNV9zY2hlZF9lbmdpbmVfaW5pdChzdHJ1Y3Qg aTkxNV9zY2hlZF9lbmdpbmUgKnNjaGVkX2VuZ2luZSwKKwkJCSAgICB1bnNpZ25lZCBpbnQgc3Vi Y2xhc3MpOworCiBzdHJ1Y3QgaTkxNV9zY2hlZF9lbmdpbmUgKgogaTkxNV9zY2hlZF9lbmdpbmVf Y3JlYXRlKHVuc2lnbmVkIGludCBzdWJjbGFzcyk7CiAKLS0gCjIuMjguMAoKX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX18KSW50ZWwtZ2Z4IG1haWxpbmcgbGlz dApJbnRlbC1nZnhAbGlzdHMuZnJlZWRlc2t0b3Aub3JnCmh0dHBzOi8vbGlzdHMuZnJlZWRlc2t0 b3Aub3JnL21haWxtYW4vbGlzdGluZm8vaW50ZWwtZ2Z4Cg== 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 ED871C07E9B for ; Tue, 20 Jul 2021 20:40:40 +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 C195D60FF3 for ; Tue, 20 Jul 2021 20:40:40 +0000 (UTC) DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org C195D60FF3 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 523AF6E54C; Tue, 20 Jul 2021 20:40:22 +0000 (UTC) Received: from mga05.intel.com (mga05.intel.com [192.55.52.43]) by gabe.freedesktop.org (Postfix) with ESMTPS id F05FF6E4F1; Tue, 20 Jul 2021 20:40:16 +0000 (UTC) X-IronPort-AV: E=McAfee;i="6200,9189,10051"; a="296885365" X-IronPort-AV: E=Sophos;i="5.84,256,1620716400"; d="scan'208";a="296885365" Received: from orsmga006.jf.intel.com ([10.7.209.51]) by fmsmga105.fm.intel.com with ESMTP/TLS/ECDHE-RSA-AES256-GCM-SHA384; 20 Jul 2021 13:40:16 -0700 X-IronPort-AV: E=Sophos;i="5.84,256,1620716400"; d="scan'208";a="414906061" 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:15 -0700 From: Matthew Brost To: , Subject: [RFC PATCH 06/42] drm/i915/guc: Introduce guc_submit_engine object Date: Tue, 20 Jul 2021 13:57:26 -0700 Message-Id: <20210720205802.39610-7-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-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" Move fields related to controlling the GuC submission state machine to a unique object (guc_submit_engine) rather than the global GuC state (intel_guc). This encapsulation allows multiple instances of submission objects to operate in parallel and a single instance can block if needed while another can make forward progress. This is analogous to how the execlist mode works assigning a schedule object per physical engine but rather in GuC mode we assign a schedule object based on the blocking dependencies. The guc_submit_engine object also encapsulates the i915_sched_engine object as well. Lots of find-replace. Currently only 1 guc_submit_engine instantiated, future patches will instantiate more. Signed-off-by: Matthew Brost Cc: John Harrison --- drivers/gpu/drm/i915/gt/uc/intel_guc.h | 33 +- .../gpu/drm/i915/gt/uc/intel_guc_submission.c | 555 +++++++++++------- .../i915/gt/uc/intel_guc_submission_types.h | 52 ++ drivers/gpu/drm/i915/i915_scheduler.c | 22 +- drivers/gpu/drm/i915/i915_scheduler.h | 3 + 5 files changed, 409 insertions(+), 256 deletions(-) create mode 100644 drivers/gpu/drm/i915/gt/uc/intel_guc_submission_types.h diff --git a/drivers/gpu/drm/i915/gt/uc/intel_guc.h b/drivers/gpu/drm/i915/gt/uc/intel_guc.h index 74481c7cf349..e278ad376986 100644 --- a/drivers/gpu/drm/i915/gt/uc/intel_guc.h +++ b/drivers/gpu/drm/i915/gt/uc/intel_guc.h @@ -21,6 +21,11 @@ struct __guc_ads_blob; +enum { + GUC_SUBMIT_ENGINE_SINGLE_LRC, + GUC_SUBMIT_ENGINE_MAX +}; + /* * Top level structure of GuC. It handles firmware loading and manages client * pool. intel_guc owns a intel_guc_client to replace the legacy ExecList @@ -31,31 +36,6 @@ 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; - - /* Global state related to submission tasklet */ - struct i915_request *stalled_rq; - struct intel_context *stalled_context; - struct work_struct retire_worker; - unsigned long flags; - int total_num_rq_with_no_guc_id; - - /* - * Submisson stall reason. See intel_guc_submission.c for detailed - * description. - */ - enum { - STALL_NONE, - STALL_GUC_ID_WORKQUEUE, - STALL_GUC_ID_TASKLET, - STALL_SCHED_DISABLE, - STALL_REGISTER_CONTEXT, - STALL_DEREGISTER_CONTEXT, - STALL_MOVE_LRC_TAIL, - STALL_ADD_REQUEST, - } submission_stall_reason; - /* intel_guc_recv interrupt related state */ spinlock_t irq_lock; unsigned int msg_enabled_mask; @@ -68,6 +48,8 @@ struct intel_guc { void (*disable)(struct intel_guc *guc); } interrupts; + struct guc_submit_engine *gse[GUC_SUBMIT_ENGINE_MAX]; + /* * contexts_lock protects the pool of free guc ids and a linked list of * guc ids available to be stolen @@ -76,7 +58,6 @@ struct intel_guc { struct ida guc_ids; u32 num_guc_ids; u32 max_guc_ids; - atomic_t num_guc_ids_not_ready; struct list_head guc_id_list_no_ref; struct list_head guc_id_list_unpinned; 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 6b1e553a0e99..fce5c1d8cfda 100644 --- a/drivers/gpu/drm/i915/gt/uc/intel_guc_submission.c +++ b/drivers/gpu/drm/i915/gt/uc/intel_guc_submission.c @@ -21,6 +21,7 @@ #include "gt/intel_ring.h" #include "intel_guc_submission.h" +#include "intel_guc_submission_types.h" #include "i915_drv.h" #include "i915_trace.h" @@ -57,7 +58,7 @@ * WQ_TYPE_INORDER is needed to support legacy submission via GuC, which * represents in-order queue. The kernel driver packs ring tail pointer and an * ELSP context descriptor dword into Work Item. - * See guc_add_request() + * See gse_add_request() * * GuC flow control state machine: * The tasklet, workqueue (retire_worker), and the G2H handlers together more or @@ -80,57 +81,57 @@ * context) */ -/* 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 guc_submit_engine *ce_to_gse(struct intel_context *ce) +{ + return container_of(ce->engine->sched_engine, struct guc_submit_engine, + sched_engine); +} + /* * Global GuC flags helper functions */ enum { - GUC_STATE_TASKLET_BLOCKED, - GUC_STATE_GUC_IDS_EXHAUSTED, + GSE_STATE_TASKLET_BLOCKED, + GSE_STATE_GUC_IDS_EXHAUSTED, }; -static bool tasklet_blocked(struct intel_guc *guc) +static bool tasklet_blocked(struct guc_submit_engine *gse) { - return test_bit(GUC_STATE_TASKLET_BLOCKED, &guc->flags); + return test_bit(GSE_STATE_TASKLET_BLOCKED, &gse->flags); } -static void set_tasklet_blocked(struct intel_guc *guc) +static void set_tasklet_blocked(struct guc_submit_engine *gse) { - lockdep_assert_held(&guc->sched_engine->lock); - set_bit(GUC_STATE_TASKLET_BLOCKED, &guc->flags); + lockdep_assert_held(&gse->sched_engine.lock); + set_bit(GSE_STATE_TASKLET_BLOCKED, &gse->flags); } -static void __clr_tasklet_blocked(struct intel_guc *guc) +static void __clr_tasklet_blocked(struct guc_submit_engine *gse) { - lockdep_assert_held(&guc->sched_engine->lock); - clear_bit(GUC_STATE_TASKLET_BLOCKED, &guc->flags); + lockdep_assert_held(&gse->sched_engine.lock); + clear_bit(GSE_STATE_TASKLET_BLOCKED, &gse->flags); } -static void clr_tasklet_blocked(struct intel_guc *guc) +static void clr_tasklet_blocked(struct guc_submit_engine *gse) { unsigned long flags; - spin_lock_irqsave(&guc->sched_engine->lock, flags); - __clr_tasklet_blocked(guc); - spin_unlock_irqrestore(&guc->sched_engine->lock, flags); + spin_lock_irqsave(&gse->sched_engine.lock, flags); + __clr_tasklet_blocked(gse); + spin_unlock_irqrestore(&gse->sched_engine.lock, flags); } -static bool guc_ids_exhausted(struct intel_guc *guc) +static bool guc_ids_exhausted(struct guc_submit_engine *gse) { - return test_bit(GUC_STATE_GUC_IDS_EXHAUSTED, &guc->flags); + return test_bit(GSE_STATE_GUC_IDS_EXHAUSTED, &gse->flags); } -static bool test_and_update_guc_ids_exhausted(struct intel_guc *guc) +static bool test_and_update_guc_ids_exhausted(struct guc_submit_engine *gse) { unsigned long flags; bool ret = false; @@ -139,33 +140,33 @@ static bool test_and_update_guc_ids_exhausted(struct intel_guc *guc) * Strict ordering on checking if guc_ids are exhausted isn't required, * so let's avoid grabbing the submission lock if possible. */ - if (guc_ids_exhausted(guc)) { - spin_lock_irqsave(&guc->sched_engine->lock, flags); - ret = guc_ids_exhausted(guc); + if (guc_ids_exhausted(gse)) { + spin_lock_irqsave(&gse->sched_engine.lock, flags); + ret = guc_ids_exhausted(gse); if (ret) - ++guc->total_num_rq_with_no_guc_id; - spin_unlock_irqrestore(&guc->sched_engine->lock, flags); + ++gse->total_num_rq_with_no_guc_id; + spin_unlock_irqrestore(&gse->sched_engine.lock, flags); } return ret; } -static void set_and_update_guc_ids_exhausted(struct intel_guc *guc) +static void set_and_update_guc_ids_exhausted(struct guc_submit_engine *gse) { unsigned long flags; - spin_lock_irqsave(&guc->sched_engine->lock, flags); - ++guc->total_num_rq_with_no_guc_id; - set_bit(GUC_STATE_GUC_IDS_EXHAUSTED, &guc->flags); - spin_unlock_irqrestore(&guc->sched_engine->lock, flags); + spin_lock_irqsave(&gse->sched_engine.lock, flags); + ++gse->total_num_rq_with_no_guc_id; + set_bit(GSE_STATE_GUC_IDS_EXHAUSTED, &gse->flags); + spin_unlock_irqrestore(&gse->sched_engine.lock, flags); } -static void clr_guc_ids_exhausted(struct intel_guc *guc) +static void clr_guc_ids_exhausted(struct guc_submit_engine *gse) { - lockdep_assert_held(&guc->sched_engine->lock); - GEM_BUG_ON(guc->total_num_rq_with_no_guc_id); + lockdep_assert_held(&gse->sched_engine.lock); + GEM_BUG_ON(gse->total_num_rq_with_no_guc_id); - clear_bit(GUC_STATE_GUC_IDS_EXHAUSTED, &guc->flags); + clear_bit(GSE_STATE_GUC_IDS_EXHAUSTED, &gse->flags); } /* @@ -416,6 +417,20 @@ static inline struct intel_guc *ce_to_guc(struct intel_context *ce) return &ce->engine->gt->uc.guc; } +static inline struct i915_sched_engine * +ce_to_sched_engine(struct intel_context *ce) +{ + return ce->engine->sched_engine; +} + +static inline struct i915_sched_engine * +guc_to_sched_engine(struct intel_guc *guc, int index) +{ + GEM_BUG_ON(index < 0 || index >= GUC_SUBMIT_ENGINE_MAX); + + return &guc->gse[index]->sched_engine; +} + static inline struct i915_priolist *to_priolist(struct rb_node *rb) { return rb_entry(rb, struct i915_priolist, node); @@ -637,19 +652,20 @@ static int __guc_add_request(struct intel_guc *guc, struct i915_request *rq) return err; } -static int guc_add_request(struct intel_guc *guc, struct i915_request *rq) +static int gse_add_request(struct guc_submit_engine *gse, + struct i915_request *rq) { int ret; - lockdep_assert_held(&guc->sched_engine->lock); + lockdep_assert_held(&gse->sched_engine.lock); - ret = __guc_add_request(guc, rq); + ret = __guc_add_request(gse->sched_engine.private_data, rq); if (ret == -EBUSY) { - guc->stalled_rq = rq; - guc->submission_stall_reason = STALL_ADD_REQUEST; + gse->stalled_rq = rq; + gse->submission_stall_reason = STALL_ADD_REQUEST; } else { - guc->stalled_rq = NULL; - guc->submission_stall_reason = STALL_NONE; + gse->stalled_rq = NULL; + gse->submission_stall_reason = STALL_NONE; } return ret; @@ -657,14 +673,15 @@ static int guc_add_request(struct intel_guc *guc, struct i915_request *rq) static int guc_lrc_desc_pin(struct intel_context *ce, bool loop); -static int tasklet_register_context(struct intel_guc *guc, +static int tasklet_register_context(struct guc_submit_engine *gse, struct i915_request *rq) { struct intel_context *ce = rq->context; + struct intel_guc *guc = gse->sched_engine.private_data; int ret = 0; /* Check state */ - lockdep_assert_held(&guc->sched_engine->lock); + lockdep_assert_held(&gse->sched_engine.lock); GEM_BUG_ON(ce->guc_num_rq_submit_no_id); GEM_BUG_ON(request_has_no_guc_id(rq)); GEM_BUG_ON(context_guc_id_invalid(ce)); @@ -687,11 +704,11 @@ static int tasklet_register_context(struct intel_guc *guc, clr_context_needs_register(ce); if (unlikely(ret == -EBUSY)) { - guc->stalled_rq = rq; - guc->submission_stall_reason = STALL_REGISTER_CONTEXT; + gse->stalled_rq = rq; + gse->submission_stall_reason = STALL_REGISTER_CONTEXT; } else if (unlikely(ret == -EINPROGRESS)) { - guc->stalled_rq = rq; - guc->submission_stall_reason = STALL_DEREGISTER_CONTEXT; + gse->stalled_rq = rq; + gse->submission_stall_reason = STALL_DEREGISTER_CONTEXT; } } @@ -710,28 +727,29 @@ static inline int rq_prio(const struct i915_request *rq) return rq->sched.attr.priority; } -static void kick_retire_wq(struct intel_guc *guc) +static void kick_retire_wq(struct guc_submit_engine *gse) { - queue_work(system_unbound_wq, &guc->retire_worker); + queue_work(system_unbound_wq, &gse->retire_worker); } -static int tasklet_pin_guc_id(struct intel_guc *guc, struct i915_request *rq); +static int tasklet_pin_guc_id(struct guc_submit_engine *gse, + struct i915_request *rq); -static int guc_dequeue_one_context(struct intel_guc *guc) +static int gse_dequeue_one_context(struct guc_submit_engine *gse) { - struct i915_sched_engine * const sched_engine = guc->sched_engine; - struct i915_request *last = guc->stalled_rq; + struct i915_sched_engine * const sched_engine = &gse->sched_engine; + struct i915_request *last = gse->stalled_rq; bool submit = !!last; struct rb_node *rb; int ret; lockdep_assert_held(&sched_engine->lock); - GEM_BUG_ON(guc->stalled_context); - GEM_BUG_ON(!submit && guc->submission_stall_reason); + GEM_BUG_ON(gse->stalled_context); + GEM_BUG_ON(!submit && gse->submission_stall_reason); if (submit) { /* Flow control conditions */ - switch (guc->submission_stall_reason) { + switch (gse->submission_stall_reason) { case STALL_GUC_ID_TASKLET: goto done; case STALL_REGISTER_CONTEXT: @@ -744,8 +762,8 @@ static int guc_dequeue_one_context(struct intel_guc *guc) GEM_BUG_ON("Invalid stall state"); } } else { - GEM_BUG_ON(!guc->total_num_rq_with_no_guc_id && - guc_ids_exhausted(guc)); + GEM_BUG_ON(!gse->total_num_rq_with_no_guc_id && + guc_ids_exhausted(gse)); while ((rb = rb_first_cached(&sched_engine->queue))) { struct i915_priolist *p = to_priolist(rb); @@ -774,13 +792,13 @@ static int guc_dequeue_one_context(struct intel_guc *guc) struct intel_context *ce = last->context; if (ce->guc_num_rq_submit_no_id) { - ret = tasklet_pin_guc_id(guc, last); + ret = tasklet_pin_guc_id(gse, last); if (ret) goto blk_tasklet_kick; } register_context: - ret = tasklet_register_context(guc, last); + ret = tasklet_register_context(gse, last); if (unlikely(ret == -EINPROGRESS)) goto blk_tasklet; else if (unlikely(ret == -EPIPE)) @@ -796,7 +814,7 @@ static int guc_dequeue_one_context(struct intel_guc *guc) guc_set_lrc_tail(last); add_request: - ret = guc_add_request(guc, last); + ret = gse_add_request(gse, last); if (unlikely(ret == -EPIPE)) goto deadlk; else if (ret == -EBUSY) @@ -811,8 +829,8 @@ static int guc_dequeue_one_context(struct intel_guc *guc) * No requests without a guc_id, enable guc_id allocation at request * creation time (guc_request_alloc). */ - if (!guc->total_num_rq_with_no_guc_id) - clr_guc_ids_exhausted(guc); + if (!gse->total_num_rq_with_no_guc_id) + clr_guc_ids_exhausted(gse); return submit; @@ -826,25 +844,26 @@ static int guc_dequeue_one_context(struct intel_guc *guc) return false; blk_tasklet_kick: - kick_retire_wq(guc); + kick_retire_wq(gse); blk_tasklet: - set_tasklet_blocked(guc); + set_tasklet_blocked(gse); return false; } -static void guc_submission_tasklet(struct tasklet_struct *t) +static void gse_submission_tasklet(struct tasklet_struct *t) { struct i915_sched_engine *sched_engine = from_tasklet(sched_engine, t, tasklet); - struct intel_guc *guc = sched_engine->private_data; + struct guc_submit_engine *gse = + container_of(sched_engine, typeof(*gse), sched_engine); unsigned long flags; bool loop; spin_lock_irqsave(&sched_engine->lock, flags); - if (likely(!tasklet_blocked(guc))) + if (likely(!tasklet_blocked(gse))) do { - loop = guc_dequeue_one_context(guc); + loop = gse_dequeue_one_context(gse); } while (loop); i915_sched_engine_reset_on_empty(sched_engine); @@ -919,69 +938,99 @@ static void scrub_guc_desc_for_outstanding_g2h(struct intel_guc *guc) } } -static inline bool -submission_disabled(struct intel_guc *guc) +static bool submission_disabled(struct intel_guc *guc) { - struct i915_sched_engine * const sched_engine = guc->sched_engine; + int i; + + for (i = 0; i < GUC_SUBMIT_ENGINE_MAX; ++i) { + struct i915_sched_engine *sched_engine; + + if (unlikely(!guc->gse[i])) + return true; + + sched_engine = guc_to_sched_engine(guc, i); + + if (unlikely(!__tasklet_is_enabled(&sched_engine->tasklet))) + return true; + } - return unlikely(!sched_engine || - !__tasklet_is_enabled(&sched_engine->tasklet)); + return false; } -static void kick_tasklet(struct intel_guc *guc) +static void kick_tasklet(struct guc_submit_engine *gse) { - struct i915_sched_engine * const sched_engine = guc->sched_engine; + struct i915_sched_engine *sched_engine = &gse->sched_engine; - if (likely(!tasklet_blocked(guc))) + if (likely(!tasklet_blocked(gse))) tasklet_hi_schedule(&sched_engine->tasklet); } static void disable_submission(struct intel_guc *guc) { - struct i915_sched_engine * const sched_engine = guc->sched_engine; + int i; + + for (i = 0; i < GUC_SUBMIT_ENGINE_MAX; ++i) { + struct i915_sched_engine *sched_engine = + guc_to_sched_engine(guc, i); - 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; + 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 enable_submission(struct intel_guc *guc) { - struct i915_sched_engine * const sched_engine = guc->sched_engine; unsigned long flags; + int i; - 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); - - /* Reset tasklet state */ - guc->stalled_rq = NULL; - if (guc->stalled_context) - intel_context_put(guc->stalled_context); - guc->stalled_context = NULL; - guc->submission_stall_reason = STALL_NONE; - guc->flags = 0; + for (i = 0; i < GUC_SUBMIT_ENGINE_MAX; ++i) { + struct i915_sched_engine *sched_engine = + guc_to_sched_engine(guc, i); + struct guc_submit_engine *gse = guc->gse[i]; - /* And kick in case we missed a new request submission. */ - kick_tasklet(guc); + spin_lock_irqsave(&sched_engine->lock, flags); + sched_engine->tasklet.callback = gse_submission_tasklet; + wmb(); + if (!__tasklet_is_enabled(&sched_engine->tasklet) && + __tasklet_enable(&sched_engine->tasklet)) { + GEM_BUG_ON(!guc->ct.enabled); + + /* Reset GuC submit engine state */ + gse->stalled_rq = NULL; + if (gse->stalled_context) + intel_context_put(gse->stalled_context); + gse->stalled_context = NULL; + gse->submission_stall_reason = STALL_NONE; + gse->flags = 0; + + /* And kick in case we missed a new request submission. */ + kick_tasklet(gse); + } + spin_unlock_irqrestore(&sched_engine->lock, flags); } - spin_unlock_irqrestore(&guc->sched_engine->lock, flags); } -static void guc_flush_submissions(struct intel_guc *guc) +static void gse_flush_submissions(struct guc_submit_engine *gse) { - struct i915_sched_engine * const sched_engine = guc->sched_engine; + struct i915_sched_engine * const sched_engine = &gse->sched_engine; unsigned long flags; spin_lock_irqsave(&sched_engine->lock, flags); spin_unlock_irqrestore(&sched_engine->lock, flags); } +static void guc_flush_submissions(struct intel_guc *guc) +{ + int i; + + for (i = 0; i < GUC_SUBMIT_ENGINE_MAX; ++i) + if (likely(guc->gse[i])) + gse_flush_submissions(guc->gse[i]); +} + void intel_guc_submission_reset_prepare(struct intel_guc *guc) { int i; @@ -1163,13 +1212,12 @@ void intel_guc_submission_reset(struct intel_guc *guc, bool stalled) 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_sched_engine *sched_engine = ce_to_sched_engine(ce); struct i915_request *rq; unsigned long flags; @@ -1184,8 +1232,9 @@ static void guc_cancel_context_requests(struct intel_context *ce) } static void -guc_cancel_sched_engine_requests(struct i915_sched_engine *sched_engine) +gse_cancel_requests(struct guc_submit_engine *gse) { + struct i915_sched_engine *sched_engine = &gse->sched_engine; struct i915_request *rq, *rn; struct rb_node *rb; unsigned long flags; @@ -1242,12 +1291,14 @@ void intel_guc_submission_cancel_requests(struct intel_guc *guc) { struct intel_context *ce; unsigned long index; + int i; 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); + for (i = 0; i < GUC_SUBMIT_ENGINE_MAX; ++i) + gse_cancel_requests(guc->gse[i]); /* GuC is blown away, drop all references to contexts */ xa_destroy(&guc->context_lookup); @@ -1274,13 +1325,13 @@ void intel_guc_submission_reset_finish(struct intel_guc *guc) intel_gt_unpark_heartbeats(guc_to_gt(guc)); } -static void retire_worker_sched_disable(struct intel_guc *guc, +static void retire_worker_sched_disable(struct guc_submit_engine *gse, struct intel_context *ce); static void retire_worker_func(struct work_struct *w) { - struct intel_guc *guc = - container_of(w, struct intel_guc, retire_worker); + struct guc_submit_engine *gse = + container_of(w, struct guc_submit_engine, retire_worker); /* * It is possible that another thread issues the schedule disable + that @@ -1288,17 +1339,17 @@ static void retire_worker_func(struct work_struct *w) * where nothing needs to be done here. Let's be paranoid and kick the * tasklet in that case. */ - if (guc->submission_stall_reason != STALL_SCHED_DISABLE && - guc->submission_stall_reason != STALL_GUC_ID_WORKQUEUE) { - kick_tasklet(guc); + if (gse->submission_stall_reason != STALL_SCHED_DISABLE && + gse->submission_stall_reason != STALL_GUC_ID_WORKQUEUE) { + kick_tasklet(gse); return; } - if (guc->submission_stall_reason == STALL_SCHED_DISABLE) { - GEM_BUG_ON(!guc->stalled_context); - GEM_BUG_ON(context_guc_id_invalid(guc->stalled_context)); + if (gse->submission_stall_reason == STALL_SCHED_DISABLE) { + GEM_BUG_ON(!gse->stalled_context); + GEM_BUG_ON(context_guc_id_invalid(gse->stalled_context)); - retire_worker_sched_disable(guc, guc->stalled_context); + retire_worker_sched_disable(gse, gse->stalled_context); } /* @@ -1306,16 +1357,16 @@ static void retire_worker_func(struct work_struct *w) * albeit after possibly issuing a schedule disable as that is async * operation. */ - intel_gt_retire_requests(guc_to_gt(guc)); + intel_gt_retire_requests(guc_to_gt(gse->sched_engine.private_data)); - if (guc->submission_stall_reason == STALL_GUC_ID_WORKQUEUE) { - GEM_BUG_ON(guc->stalled_context); + if (gse->submission_stall_reason == STALL_GUC_ID_WORKQUEUE) { + GEM_BUG_ON(gse->stalled_context); /* Hopefully guc_ids are now available, kick tasklet */ - guc->submission_stall_reason = STALL_GUC_ID_TASKLET; - clr_tasklet_blocked(guc); + gse->submission_stall_reason = STALL_GUC_ID_TASKLET; + clr_tasklet_blocked(gse); - kick_tasklet(guc); + kick_tasklet(gse); } } @@ -1346,18 +1397,24 @@ int intel_guc_submission_init(struct intel_guc *guc) INIT_LIST_HEAD(&guc->guc_id_list_unpinned); ida_init(&guc->guc_ids); - INIT_WORK(&guc->retire_worker, retire_worker_func); - return 0; } void intel_guc_submission_fini(struct intel_guc *guc) { + int i; + if (!guc->lrc_desc_pool) return; guc_lrc_desc_pool_destroy(guc); - i915_sched_engine_put(guc->sched_engine); + + for (i = 0; i < GUC_SUBMIT_ENGINE_MAX; ++i) { + struct i915_sched_engine *sched_engine = + guc_to_sched_engine(guc, i); + + i915_sched_engine_put(sched_engine); + } } static inline void queue_request(struct i915_sched_engine *sched_engine, @@ -1372,22 +1429,23 @@ static inline void queue_request(struct i915_sched_engine *sched_engine, set_bit(I915_FENCE_FLAG_PQUEUE, &rq->fence.flags); if (empty) - kick_tasklet(&rq->engine->gt->uc.guc); + kick_tasklet(ce_to_gse(rq->context)); } /* Macro to tweak heuristic, using a simple over 50% not ready for now */ #define TOO_MANY_GUC_IDS_NOT_READY(avail, consumed) \ (consumed > avail / 2) -static bool too_many_guc_ids_not_ready(struct intel_guc *guc, +static bool too_many_guc_ids_not_ready(struct guc_submit_engine *gse, struct intel_context *ce) { u32 available_guc_ids, guc_ids_consumed; + struct intel_guc *guc = gse->sched_engine.private_data; available_guc_ids = guc->num_guc_ids; - guc_ids_consumed = atomic_read(&guc->num_guc_ids_not_ready); + guc_ids_consumed = atomic_read(&gse->num_guc_ids_not_ready); if (TOO_MANY_GUC_IDS_NOT_READY(available_guc_ids, guc_ids_consumed)) { - set_and_update_guc_ids_exhausted(guc); + set_and_update_guc_ids_exhausted(gse); return true; } @@ -1396,34 +1454,36 @@ static bool too_many_guc_ids_not_ready(struct intel_guc *guc, static void incr_num_rq_not_ready(struct intel_context *ce) { - struct intel_guc *guc = ce_to_guc(ce); + struct guc_submit_engine *gse = ce_to_gse(ce); if (!atomic_fetch_add(1, &ce->guc_num_rq_not_ready)) - atomic_inc(&guc->num_guc_ids_not_ready); + atomic_inc(&gse->num_guc_ids_not_ready); } void intel_guc_decr_num_rq_not_ready(struct intel_context *ce) { - struct intel_guc *guc = ce_to_guc(ce); + struct guc_submit_engine *gse = ce_to_gse(ce); - if (atomic_fetch_add(-1, &ce->guc_num_rq_not_ready) == 1) - atomic_dec(&guc->num_guc_ids_not_ready); + if (atomic_fetch_add(-1, &ce->guc_num_rq_not_ready) == 1) { + GEM_BUG_ON(!atomic_read(&gse->num_guc_ids_not_ready)); + atomic_dec(&gse->num_guc_ids_not_ready); + } } -static bool need_tasklet(struct intel_guc *guc, struct intel_context *ce) +static bool need_tasklet(struct guc_submit_engine *gse, struct intel_context *ce) { - struct i915_sched_engine * const sched_engine = - ce->engine->sched_engine; + struct i915_sched_engine * const sched_engine = &gse->sched_engine; + struct intel_guc *guc = gse->sched_engine.private_data; lockdep_assert_held(&sched_engine->lock); - return guc_ids_exhausted(guc) || submission_disabled(guc) || - guc->stalled_rq || guc->stalled_context || + return guc_ids_exhausted(gse) || submission_disabled(guc) || + gse->stalled_rq || gse->stalled_context || !lrc_desc_registered(guc, ce->guc_id) || !i915_sched_engine_is_empty(sched_engine); } -static int guc_bypass_tasklet_submit(struct intel_guc *guc, +static int gse_bypass_tasklet_submit(struct guc_submit_engine *gse, struct i915_request *rq) { int ret; @@ -1433,27 +1493,27 @@ static int guc_bypass_tasklet_submit(struct intel_guc *guc, trace_i915_request_in(rq, 0); guc_set_lrc_tail(rq); - ret = guc_add_request(guc, rq); + ret = gse_add_request(gse, rq); if (unlikely(ret == -EPIPE)) - disable_submission(guc); + disable_submission(gse->sched_engine.private_data); 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; + struct guc_submit_engine *gse = ce_to_gse(rq->context); + struct i915_sched_engine *sched_engine = &gse->sched_engine; unsigned long flags; /* Will be called from irq-context when using foreign fences. */ spin_lock_irqsave(&sched_engine->lock, flags); - if (need_tasklet(guc, rq->context)) + if (need_tasklet(gse, rq->context)) queue_request(sched_engine, rq, rq_prio(rq)); - else if (guc_bypass_tasklet_submit(guc, rq) == -EBUSY) - kick_tasklet(guc); + else if (gse_bypass_tasklet_submit(gse, rq) == -EBUSY) + kick_tasklet(gse); spin_unlock_irqrestore(&sched_engine->lock, flags); @@ -1532,8 +1592,9 @@ static int steal_guc_id(struct intel_guc *guc, bool unpinned) * context. */ if (!unpinned) { - GEM_BUG_ON(guc->stalled_context); - guc->stalled_context = intel_context_get(ce); + GEM_BUG_ON(ce_to_gse(ce)->stalled_context); + + ce_to_gse(ce)->stalled_context = intel_context_get(ce); set_context_guc_id_stolen(ce); } else { set_context_guc_id_invalid(ce); @@ -1595,7 +1656,7 @@ static int pin_guc_id(struct intel_guc *guc, struct intel_context *ce, try_again: spin_lock_irqsave(&guc->contexts_lock, flags); - if (!tasklet && guc_ids_exhausted(guc)) { + if (!tasklet && guc_ids_exhausted(ce_to_gse(ce))) { ret = -EAGAIN; goto out_unlock; } @@ -2084,7 +2145,7 @@ static void guc_context_ban(struct intel_context *ce, struct i915_request *rq) intel_wakeref_t wakeref; unsigned long flags; - guc_flush_submissions(guc); + gse_flush_submissions(ce_to_gse(ce)); spin_lock_irqsave(&ce->guc_state.lock, flags); set_context_banned(ce); @@ -2172,7 +2233,7 @@ static void guc_context_sched_disable(struct intel_context *ce) spin_unlock_irqrestore(&ce->guc_state.lock, flags); with_intel_runtime_pm(runtime_pm, wakeref) - __guc_context_sched_disable(guc, ce, guc_id); + __guc_context_sched_disable(ce_to_guc(ce), ce, guc_id); return; unpin: @@ -2428,7 +2489,7 @@ static void remove_from_context(struct i915_request *rq) if (likely(!request_has_no_guc_id(rq))) atomic_dec(&ce->guc_id_ref); else - --ce_to_guc(rq->context)->total_num_rq_with_no_guc_id; + --ce_to_gse(rq->context)->total_num_rq_with_no_guc_id; unpin_guc_id(ce_to_guc(ce), ce, false); i915_request_notify_execute_cb_imm(rq); @@ -2489,13 +2550,14 @@ static void invalidate_guc_id_sched_disable(struct intel_context *ce) clr_context_guc_id_stolen(ce); } -static void retire_worker_sched_disable(struct intel_guc *guc, +static void retire_worker_sched_disable(struct guc_submit_engine *gse, struct intel_context *ce) { + struct intel_guc *guc = gse->sched_engine.private_data; unsigned long flags; bool disabled; - guc->stalled_context = NULL; + gse->stalled_context = NULL; spin_lock_irqsave(&ce->guc_state.lock, flags); disabled = submission_disabled(guc); if (!disabled && !context_pending_disable(ce) && context_enabled(ce)) { @@ -2541,10 +2603,10 @@ static void retire_worker_sched_disable(struct intel_guc *guc, invalidate_guc_id_sched_disable(ce); - guc->submission_stall_reason = STALL_REGISTER_CONTEXT; - clr_tasklet_blocked(guc); + gse->submission_stall_reason = STALL_REGISTER_CONTEXT; + clr_tasklet_blocked(gse); - kick_tasklet(ce_to_guc(ce)); + kick_tasklet(gse); } intel_context_put(ce); @@ -2557,25 +2619,26 @@ static bool context_needs_lrc_desc_pin(struct intel_context *ce, bool new_guc_id !submission_disabled(ce_to_guc(ce)); } -static int tasklet_pin_guc_id(struct intel_guc *guc, struct i915_request *rq) +static int tasklet_pin_guc_id(struct guc_submit_engine *gse, + struct i915_request *rq) { struct intel_context *ce = rq->context; int ret = 0; - lockdep_assert_held(&guc->sched_engine->lock); + lockdep_assert_held(&gse->sched_engine.lock); GEM_BUG_ON(!ce->guc_num_rq_submit_no_id); if (atomic_add_unless(&ce->guc_id_ref, ce->guc_num_rq_submit_no_id, 0)) goto out; - ret = pin_guc_id(guc, ce, true); + ret = pin_guc_id(gse->sched_engine.private_data, ce, true); if (unlikely(ret < 0)) { /* * No guc_ids available, disable the tasklet and kick the retire * workqueue hopefully freeing up some guc_ids. */ - guc->stalled_rq = rq; - guc->submission_stall_reason = STALL_GUC_ID_WORKQUEUE; + gse->stalled_rq = rq; + gse->submission_stall_reason = STALL_GUC_ID_WORKQUEUE; return ret; } @@ -2587,14 +2650,14 @@ static int tasklet_pin_guc_id(struct intel_guc *guc, struct i915_request *rq) set_context_needs_register(ce); if (ret == NEW_GUC_ID_ENABLED) { - guc->stalled_rq = rq; - guc->submission_stall_reason = STALL_SCHED_DISABLE; + gse->stalled_rq = rq; + gse->submission_stall_reason = STALL_SCHED_DISABLE; } clear_bit(CONTEXT_LRCA_DIRTY, &ce->flags); out: - guc->total_num_rq_with_no_guc_id -= ce->guc_num_rq_submit_no_id; - GEM_BUG_ON(guc->total_num_rq_with_no_guc_id < 0); + gse->total_num_rq_with_no_guc_id -= ce->guc_num_rq_submit_no_id; + GEM_BUG_ON(gse->total_num_rq_with_no_guc_id < 0); list_for_each_entry_reverse(rq, &ce->guc_active.requests, sched.link) if (request_has_no_guc_id(rq)) { @@ -2612,7 +2675,7 @@ static int tasklet_pin_guc_id(struct intel_guc *guc, struct i915_request *rq) * from a context that has scheduling enabled. We have to disable * scheduling before deregistering the context and it isn't safe to do * in the tasklet because of lock inversion (ce->guc_state.lock must be - * acquired before guc->sched_engine->lock). To work around this + * acquired before gse->sched_engine.lock). To work around this * we do the schedule disable in retire workqueue and block the tasklet * until the schedule done G2H returns. Returning non-zero here kicks * the workqueue. @@ -2624,6 +2687,7 @@ static int guc_request_alloc(struct i915_request *rq) { struct intel_context *ce = rq->context; struct intel_guc *guc = ce_to_guc(ce); + struct guc_submit_engine *gse = ce_to_gse(ce); unsigned long flags; int ret; @@ -2635,8 +2699,8 @@ static int guc_request_alloc(struct i915_request *rq) * ready to submit). Don't allocate one here, defer to submission in the * tasklet. */ - if (test_and_update_guc_ids_exhausted(guc) || - too_many_guc_ids_not_ready(guc, ce)) { + if (test_and_update_guc_ids_exhausted(gse) || + too_many_guc_ids_not_ready(gse, ce)) { set_bit(I915_FENCE_FLAG_GUC_ID_NOT_PINNED, &rq->fence.flags); goto out; } @@ -2691,7 +2755,7 @@ static int guc_request_alloc(struct i915_request *rq) * submissions we return to allocating guc_ids in this function. */ set_bit(I915_FENCE_FLAG_GUC_ID_NOT_PINNED, &rq->fence.flags); - set_and_update_guc_ids_exhausted(guc); + set_and_update_guc_ids_exhausted(gse); incr_num_rq_not_ready(ce); return 0; @@ -3099,17 +3163,41 @@ 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; + struct guc_submit_engine *gse = + container_of(sched_engine, typeof(*gse), sched_engine); + struct intel_guc *guc = gse->sched_engine.private_data; - guc->sched_engine = NULL; + guc->gse[gse->id] = NULL; tasklet_kill(&sched_engine->tasklet); /* flush the callback */ - kfree(sched_engine); + kfree(gse); +} + +static void guc_submit_engine_init(struct intel_guc *guc, + struct guc_submit_engine *gse, + int id) +{ + struct i915_sched_engine *sched_engine = &gse->sched_engine; + + i915_sched_engine_init(sched_engine, ENGINE_VIRTUAL); + INIT_WORK(&gse->retire_worker, retire_worker_func); + tasklet_setup(&sched_engine->tasklet, gse_submission_tasklet); + sched_engine->schedule = i915_schedule; + sched_engine->disabled = guc_sched_engine_disabled; + sched_engine->destroy = guc_sched_engine_destroy; + sched_engine->bump_inflight_request_prio = + guc_bump_inflight_request_prio; + sched_engine->retire_inflight_request_prio = + guc_retire_inflight_request_prio; + sched_engine->private_data = guc; + gse->id = id; } 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; + struct i915_sched_engine *sched_engine; + int ret, i; /* * The setup relies on several assumptions (e.g. irqs always enabled) @@ -3117,24 +3205,20 @@ int intel_guc_submission_setup(struct intel_engine_cs *engine) */ GEM_BUG_ON(GRAPHICS_VER(i915) < 11); - 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); + if (!guc->gse[0]) { + for (i = 0; i < GUC_SUBMIT_ENGINE_MAX; ++i) { + guc->gse[i] = kzalloc(sizeof(*guc->gse[i]), GFP_KERNEL); + if (!guc->gse[i]) { + ret = -ENOMEM; + goto put_sched_engine; + } + guc_submit_engine_init(guc, guc->gse[i], i); + } } + + sched_engine = guc_to_sched_engine(guc, GUC_SUBMIT_ENGINE_SINGLE_LRC); i915_sched_engine_put(engine->sched_engine); - engine->sched_engine = i915_sched_engine_get(guc->sched_engine); + engine->sched_engine = i915_sched_engine_get(sched_engine); guc_default_vfuncs(engine); guc_default_irqs(engine); @@ -3150,6 +3234,16 @@ int intel_guc_submission_setup(struct intel_engine_cs *engine) engine->release = guc_release; return 0; + +put_sched_engine: + for (i = 0; i < GUC_SUBMIT_ENGINE_MAX; ++i) { + struct i915_sched_engine *sched_engine = + guc_to_sched_engine(guc, i); + + if (sched_engine) + i915_sched_engine_put(sched_engine); + } + return ret; } void intel_guc_submission_enable(struct intel_guc *guc) @@ -3249,14 +3343,16 @@ int intel_guc_deregister_done_process_msg(struct intel_guc *guc, register_context(ce, true); guc_signal_context_fence(ce); if (context_block_tasklet(ce)) { - GEM_BUG_ON(guc->submission_stall_reason != + struct guc_submit_engine *gse = ce_to_gse(ce); + + GEM_BUG_ON(gse->submission_stall_reason != STALL_DEREGISTER_CONTEXT); clr_context_block_tasklet(ce); - guc->submission_stall_reason = STALL_MOVE_LRC_TAIL; - clr_tasklet_blocked(guc); + gse->submission_stall_reason = STALL_MOVE_LRC_TAIL; + clr_tasklet_blocked(gse); - kick_tasklet(ce_to_guc(ce)); + kick_tasklet(gse); } intel_context_put(ce); } else if (context_destroyed(ce)) { @@ -3322,11 +3418,13 @@ int intel_guc_sched_done_process_msg(struct intel_guc *guc, spin_unlock_irqrestore(&ce->guc_state.lock, flags); if (context_block_tasklet(ce)) { + struct guc_submit_engine *gse = ce_to_gse(ce); + clr_context_block_tasklet(ce); - guc->submission_stall_reason = STALL_REGISTER_CONTEXT; - clr_tasklet_blocked(guc); + gse->submission_stall_reason = STALL_REGISTER_CONTEXT; + clr_tasklet_blocked(gse); - kick_tasklet(ce_to_guc(ce)); + kick_tasklet(gse); } if (banned) { @@ -3358,7 +3456,7 @@ static void capture_error_state(struct intel_guc *guc, static void guc_context_replay(struct intel_context *ce) { __guc_reset_context(ce, true); - kick_tasklet(ce_to_guc(ce)); + kick_tasklet(ce_to_gse(ce)); } static void guc_handle_context_reset(struct intel_guc *guc, @@ -3503,35 +3601,32 @@ void intel_guc_dump_active_requests(struct intel_engine_cs *engine, } } -void intel_guc_submission_print_info(struct intel_guc *guc, - struct drm_printer *p) +static void gse_log_submission_info(struct guc_submit_engine *gse, + struct drm_printer *p, int id) { - struct i915_sched_engine *sched_engine = guc->sched_engine; + struct i915_sched_engine *sched_engine = &gse->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 Number GuC IDs: %u\n", guc->num_guc_ids); - drm_printf(p, "GuC Max GuC IDs: %u\n", guc->max_guc_ids); - drm_printf(p, "GuC tasklet count: %u\n", + drm_printf(p, "GSE[%d] tasklet count: %u\n", id, atomic_read(&sched_engine->tasklet.count)); - drm_printf(p, "GuC submit flags: 0x%04lx\n", guc->flags); - drm_printf(p, "GuC total number request without guc_id: %d\n", - guc->total_num_rq_with_no_guc_id); - drm_printf(p, "GuC Number GuC IDs not ready: %d\n", - atomic_read(&guc->num_guc_ids_not_ready)); - drm_printf(p, "GuC stall reason: %d\n", guc->submission_stall_reason); - drm_printf(p, "GuC stalled request: %s\n", - yesno(guc->stalled_rq)); - drm_printf(p, "GuC stalled context: %s\n\n", - yesno(guc->stalled_context)); + drm_printf(p, "GSE[%d] submit flags: 0x%04lx\n", id, gse->flags); + drm_printf(p, "GSE[%d] total number request without guc_id: %d\n", + id, gse->total_num_rq_with_no_guc_id); + drm_printf(p, "GSE[%d] Number GuC IDs not ready: %d\n", + id, atomic_read(&gse->num_guc_ids_not_ready)); + drm_printf(p, "GSE[%d] stall reason: %d\n", + id, gse->submission_stall_reason); + drm_printf(p, "GSE[%d] stalled request: %s\n", + id, yesno(gse->stalled_rq)); + drm_printf(p, "GSE[%d] stalled context: %s\n\n", + id, yesno(gse->stalled_context)); spin_lock_irqsave(&sched_engine->lock, flags); - drm_printf(p, "Requests in GuC submit tasklet:\n"); + drm_printf(p, "Requests in GSE[%d] submit tasklet:\n", id); for (rb = rb_first_cached(&sched_engine->queue); rb; rb = rb_next(rb)) { struct i915_priolist *pl = to_priolist(rb); struct i915_request *rq; @@ -3561,6 +3656,20 @@ static inline void guc_log_context_priority(struct drm_printer *p, drm_printf(p, "\n"); } +void intel_guc_submission_print_info(struct intel_guc *guc, + struct drm_printer *p) +{ + int i; + + drm_printf(p, "GuC Number Outstanding Submission G2H: %u\n", + atomic_read(&guc->outstanding_submission_g2h)); + drm_printf(p, "GuC Number GuC IDs: %d\n", guc->num_guc_ids); + drm_printf(p, "GuC Max Number GuC IDs: %d\n\n", guc->max_guc_ids); + + for (i = 0; i < GUC_SUBMIT_ENGINE_MAX; ++i) + gse_log_submission_info(guc->gse[i], p, i); +} + void intel_guc_submission_print_context_info(struct intel_guc *guc, struct drm_printer *p) { @@ -3594,6 +3703,7 @@ guc_create_virtual(struct intel_engine_cs **siblings, unsigned int count) { struct guc_virtual_engine *ve; struct intel_guc *guc; + struct i915_sched_engine *sched_engine; unsigned int n; int err; @@ -3602,6 +3712,7 @@ guc_create_virtual(struct intel_engine_cs **siblings, unsigned int count) return ERR_PTR(-ENOMEM); guc = &siblings[0]->gt->uc.guc; + sched_engine = guc_to_sched_engine(guc, GUC_SUBMIT_ENGINE_SINGLE_LRC); ve->base.i915 = siblings[0]->i915; ve->base.gt = siblings[0]->gt; @@ -3615,7 +3726,7 @@ guc_create_virtual(struct intel_engine_cs **siblings, unsigned int count) snprintf(ve->base.name, sizeof(ve->base.name), "virtual"); - ve->base.sched_engine = i915_sched_engine_get(guc->sched_engine); + ve->base.sched_engine = i915_sched_engine_get(sched_engine); ve->base.cops = &virtual_guc_context_ops; ve->base.request_alloc = guc_request_alloc; diff --git a/drivers/gpu/drm/i915/gt/uc/intel_guc_submission_types.h b/drivers/gpu/drm/i915/gt/uc/intel_guc_submission_types.h new file mode 100644 index 000000000000..0c224ab18c02 --- /dev/null +++ b/drivers/gpu/drm/i915/gt/uc/intel_guc_submission_types.h @@ -0,0 +1,52 @@ +/* SPDX-License-Identifier: MIT */ +/* + * Copyright © 2014-2019 Intel Corporation + */ + +#ifndef _INTEL_GUC_SUBMISSION_TYPES_H_ +#define _INTEL_GUC_SUBMISSION_TYPES_H_ + +#include "gt/intel_engine_types.h" +#include "gt/intel_context_types.h" +#include "i915_scheduler_types.h" + +struct intel_guc; +struct i915_request; + +/* GuC Virtual Engine */ +struct guc_virtual_engine { + struct intel_engine_cs base; + struct intel_context context; +}; + +/* + * Object which encapsulates the globally operated on i915_sched_engine + + * the GuC submission state machine described in intel_guc_submission.c. + */ +struct guc_submit_engine { + struct i915_sched_engine sched_engine; + struct work_struct retire_worker; + struct i915_request *stalled_rq; + struct intel_context *stalled_context; + unsigned long flags; + int total_num_rq_with_no_guc_id; + atomic_t num_guc_ids_not_ready; + int id; + + /* + * Submisson stall reason. See intel_guc_submission.c for detailed + * description. + */ + enum { + STALL_NONE, + STALL_GUC_ID_WORKQUEUE, + STALL_GUC_ID_TASKLET, + STALL_SCHED_DISABLE, + STALL_REGISTER_CONTEXT, + STALL_DEREGISTER_CONTEXT, + STALL_MOVE_LRC_TAIL, + STALL_ADD_REQUEST, + } submission_stall_reason; +}; + +#endif diff --git a/drivers/gpu/drm/i915/i915_scheduler.c b/drivers/gpu/drm/i915/i915_scheduler.c index 3fccae3672c1..b9530584fc1e 100644 --- a/drivers/gpu/drm/i915/i915_scheduler.c +++ b/drivers/gpu/drm/i915/i915_scheduler.c @@ -452,15 +452,9 @@ static bool default_disabled(struct i915_sched_engine *sched_engine) return false; } -struct i915_sched_engine * -i915_sched_engine_create(unsigned int subclass) +void i915_sched_engine_init(struct i915_sched_engine *sched_engine, + unsigned int subclass) { - struct i915_sched_engine *sched_engine; - - sched_engine = kzalloc(sizeof(*sched_engine), GFP_KERNEL); - if (!sched_engine) - return NULL; - kref_init(&sched_engine->ref); sched_engine->queue = RB_ROOT_CACHED; @@ -485,6 +479,18 @@ i915_sched_engine_create(unsigned int subclass) lock_map_release(&sched_engine->lock.dep_map); local_irq_enable(); #endif +} + +struct i915_sched_engine * +i915_sched_engine_create(unsigned int subclass) +{ + struct i915_sched_engine *sched_engine; + + sched_engine = kzalloc(sizeof(*sched_engine), GFP_KERNEL); + if (!sched_engine) + return NULL; + + i915_sched_engine_init(sched_engine, subclass); return sched_engine; } diff --git a/drivers/gpu/drm/i915/i915_scheduler.h b/drivers/gpu/drm/i915/i915_scheduler.h index f4d9811ade5b..c7c093bc2972 100644 --- a/drivers/gpu/drm/i915/i915_scheduler.h +++ b/drivers/gpu/drm/i915/i915_scheduler.h @@ -48,6 +48,9 @@ static inline void i915_priolist_free(struct i915_priolist *p) __i915_priolist_free(p); } +void i915_sched_engine_init(struct i915_sched_engine *sched_engine, + unsigned int subclass); + struct i915_sched_engine * i915_sched_engine_create(unsigned int subclass); -- 2.28.0