From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org X-Spam-Level: X-Spam-Status: No, score=-16.8 required=3.0 tests=BAYES_00, HEADER_FROM_DIFFERENT_DOMAINS,INCLUDES_CR_TRAILER,INCLUDES_PATCH, MAILING_LIST_MULTI,SPF_HELO_NONE,SPF_PASS,USER_AGENT_GIT autolearn=ham autolearn_force=no version=3.4.0 Received: from mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id 8D662C49361 for ; Thu, 17 Jun 2021 06:31:20 +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 5EA29613ED for ; Thu, 17 Jun 2021 06:31:20 +0000 (UTC) DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org 5EA29613ED Authentication-Results: mail.kernel.org; dmarc=fail (p=none dis=none) header.from=linux.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 076EC6E88D; Thu, 17 Jun 2021 06:31:15 +0000 (UTC) Received: from mga11.intel.com (mga11.intel.com [192.55.52.93]) by gabe.freedesktop.org (Postfix) with ESMTPS id 45A546E887; Thu, 17 Jun 2021 06:30:56 +0000 (UTC) IronPort-SDR: jB20jkkAUT1eHB/BfGmfCCvGEfwcNO2RK4qBkIIfZfjdoTjfgQFczLWh72ElfY7P+DSWrCMZHO GvNuIFky6p2w== X-IronPort-AV: E=McAfee;i="6200,9189,10017"; a="203287865" X-IronPort-AV: E=Sophos;i="5.83,278,1616482800"; d="scan'208";a="203287865" Received: from orsmga004.jf.intel.com ([10.7.209.38]) by fmsmga102.fm.intel.com with ESMTP/TLS/ECDHE-RSA-AES256-GCM-SHA384; 16 Jun 2021 23:30:55 -0700 IronPort-SDR: /KrcR/QFH3cGPXi8e3QBHrHvtTlZIwcHoylCmPGFo79gurOU6t+Eb6cj9r2v7tF5L67IEcLhst U4foInYfvqnQ== X-IronPort-AV: E=Sophos;i="5.83,278,1616482800"; d="scan'208";a="554302764" Received: from vanderss-mobl.ger.corp.intel.com (HELO thellst-mobl1.intel.com) ([10.249.254.193]) by orsmga004-auth.jf.intel.com with ESMTP/TLS/ECDHE-RSA-AES256-GCM-SHA384; 16 Jun 2021 23:30:54 -0700 From: =?UTF-8?q?Thomas=20Hellstr=C3=B6m?= To: intel-gfx@lists.freedesktop.org, dri-devel@lists.freedesktop.org Date: Thu, 17 Jun 2021 08:30:18 +0200 Message-Id: <20210617063018.92802-13-thomas.hellstrom@linux.intel.com> X-Mailer: git-send-email 2.31.1 In-Reply-To: <20210617063018.92802-1-thomas.hellstrom@linux.intel.com> References: <20210617063018.92802-1-thomas.hellstrom@linux.intel.com> MIME-Version: 1.0 Subject: [Intel-gfx] [PATCH v5 12/12] drm/i915/gem: Zap the i915_gem_object_blt code 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: , Cc: =?UTF-8?q?Thomas=20Hellstr=C3=B6m?= , matthew.auld@intel.com Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Errors-To: intel-gfx-bounces@lists.freedesktop.org Sender: "Intel-gfx" SXQncyB1bnVzZWQgd2l0aCB0aGUgZXhjZXB0aW9uIG9mIHNlbGZ0ZXN0LiBSZXBsYWNlIGEgY2Fs bCBpbiB0aGUKbWVtb3J5X3JlZ2lvbiBsaXZlIHNlbGZ0ZXN0IHdpdGggYSBjYWxsIGludG8gYSBj b3JyZXNwb25kaW5nCmZ1bmN0aW9uIGluIHRoZSBuZXcgbWlncmF0ZSBjb2RlLgoKU2lnbmVkLW9m Zi1ieTogVGhvbWFzIEhlbGxzdHLDtm0gPHRob21hcy5oZWxsc3Ryb21AbGludXguaW50ZWwuY29t PgpSZXZpZXdlZC1ieTogTWF0dGhldyBBdWxkIDxtYXR0aGV3LmF1bGRAaW50ZWwuY29tPgotLS0K IGRyaXZlcnMvZ3B1L2RybS9pOTE1L01ha2VmaWxlICAgICAgICAgICAgICAgICB8ICAgMSAtCiAu Li4vZ3B1L2RybS9pOTE1L2dlbS9pOTE1X2dlbV9vYmplY3RfYmx0LmMgICAgfCA0NjEgLS0tLS0t LS0tLS0tLS0KIC4uLi9ncHUvZHJtL2k5MTUvZ2VtL2k5MTVfZ2VtX29iamVjdF9ibHQuaCAgICB8 ICAzOSAtLQogLi4uL2k5MTUvZ2VtL3NlbGZ0ZXN0cy9pOTE1X2dlbV9vYmplY3RfYmx0LmMgIHwg NTk3IC0tLS0tLS0tLS0tLS0tLS0tLQogLi4uL2RybS9pOTE1L3NlbGZ0ZXN0cy9pOTE1X2xpdmVf c2VsZnRlc3RzLmggIHwgICAxIC0KIC4uLi9kcm0vaTkxNS9zZWxmdGVzdHMvaTkxNV9wZXJmX3Nl bGZ0ZXN0cy5oICB8ICAgMSAtCiAuLi4vZHJtL2k5MTUvc2VsZnRlc3RzL2ludGVsX21lbW9yeV9y ZWdpb24uYyAgfCAgMjEgKy0KIDcgZmlsZXMgY2hhbmdlZCwgMTQgaW5zZXJ0aW9ucygrKSwgMTEw NyBkZWxldGlvbnMoLSkKIGRlbGV0ZSBtb2RlIDEwMDY0NCBkcml2ZXJzL2dwdS9kcm0vaTkxNS9n ZW0vaTkxNV9nZW1fb2JqZWN0X2JsdC5jCiBkZWxldGUgbW9kZSAxMDA2NDQgZHJpdmVycy9ncHUv ZHJtL2k5MTUvZ2VtL2k5MTVfZ2VtX29iamVjdF9ibHQuaAogZGVsZXRlIG1vZGUgMTAwNjQ0IGRy aXZlcnMvZ3B1L2RybS9pOTE1L2dlbS9zZWxmdGVzdHMvaTkxNV9nZW1fb2JqZWN0X2JsdC5jCgpk aWZmIC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJtL2k5MTUvTWFrZWZpbGUgYi9kcml2ZXJzL2dwdS9k cm0vaTkxNS9NYWtlZmlsZQppbmRleCBmZmExNDA4NDQzMmMuLjAxZjI4YWQ1ZWE1NyAxMDA2NDQK LS0tIGEvZHJpdmVycy9ncHUvZHJtL2k5MTUvTWFrZWZpbGUKKysrIGIvZHJpdmVycy9ncHUvZHJt L2k5MTUvTWFrZWZpbGUKQEAgLTE0Myw3ICsxNDMsNiBAQCBnZW0teSArPSBcCiAJZ2VtL2k5MTVf Z2VtX2V4ZWNidWZmZXIubyBcCiAJZ2VtL2k5MTVfZ2VtX2ludGVybmFsLm8gXAogCWdlbS9pOTE1 X2dlbV9vYmplY3QubyBcCi0JZ2VtL2k5MTVfZ2VtX29iamVjdF9ibHQubyBcCiAJZ2VtL2k5MTVf Z2VtX2xtZW0ubyBcCiAJZ2VtL2k5MTVfZ2VtX21tYW4ubyBcCiAJZ2VtL2k5MTVfZ2VtX3BhZ2Vz Lm8gXApkaWZmIC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJtL2k5MTUvZ2VtL2k5MTVfZ2VtX29iamVj dF9ibHQuYyBiL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2dlbS9pOTE1X2dlbV9vYmplY3RfYmx0LmMK ZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDNlMjhjNjhmZGEzZS4uMDAwMDAwMDAwMDAw Ci0tLSBhL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2dlbS9pOTE1X2dlbV9vYmplY3RfYmx0LmMKKysr IC9kZXYvbnVsbApAQCAtMSw0NjEgKzAsMCBAQAotLy8gU1BEWC1MaWNlbnNlLUlkZW50aWZpZXI6 IE1JVAotLyoKLSAqIENvcHlyaWdodCDCqSAyMDE5IEludGVsIENvcnBvcmF0aW9uCi0gKi8KLQot I2luY2x1ZGUgImk5MTVfZHJ2LmgiCi0jaW5jbHVkZSAiZ3QvaW50ZWxfY29udGV4dC5oIgotI2lu Y2x1ZGUgImd0L2ludGVsX2VuZ2luZV9wbS5oIgotI2luY2x1ZGUgImd0L2ludGVsX2dwdV9jb21t YW5kcy5oIgotI2luY2x1ZGUgImd0L2ludGVsX2d0LmgiCi0jaW5jbHVkZSAiZ3QvaW50ZWxfZ3Rf YnVmZmVyX3Bvb2wuaCIKLSNpbmNsdWRlICJndC9pbnRlbF9yaW5nLmgiCi0jaW5jbHVkZSAiaTkx NV9nZW1fY2xmbHVzaC5oIgotI2luY2x1ZGUgImk5MTVfZ2VtX29iamVjdF9ibHQuaCIKLQotc3Ry dWN0IGk5MTVfdm1hICppbnRlbF9lbWl0X3ZtYV9maWxsX2JsdChzdHJ1Y3QgaW50ZWxfY29udGV4 dCAqY2UsCi0JCQkJCSBzdHJ1Y3QgaTkxNV92bWEgKnZtYSwKLQkJCQkJIHN0cnVjdCBpOTE1X2dl bV93d19jdHggKnd3LAotCQkJCQkgdTMyIHZhbHVlKQotewotCXN0cnVjdCBkcm1faTkxNV9wcml2 YXRlICppOTE1ID0gY2UtPnZtLT5pOTE1OwotCWNvbnN0IHUzMiBibG9ja19zaXplID0gU1pfOE07 IC8qIH4xbXMgYXQgOEdpQi9zIHByZWVtcHRpb24gZGVsYXkgKi8KLQlzdHJ1Y3QgaW50ZWxfZ3Rf YnVmZmVyX3Bvb2xfbm9kZSAqcG9vbDsKLQlzdHJ1Y3QgaTkxNV92bWEgKmJhdGNoOwotCXU2NCBv ZmZzZXQ7Ci0JdTY0IGNvdW50OwotCXU2NCByZW07Ci0JdTMyIHNpemU7Ci0JdTMyICpjbWQ7Ci0J aW50IGVycjsKLQotCUdFTV9CVUdfT04oaW50ZWxfZW5naW5lX2lzX3ZpcnR1YWwoY2UtPmVuZ2lu ZSkpOwotCWludGVsX2VuZ2luZV9wbV9nZXQoY2UtPmVuZ2luZSk7Ci0KLQljb3VudCA9IGRpdl91 NjQocm91bmRfdXAodm1hLT5zaXplLCBibG9ja19zaXplKSwgYmxvY2tfc2l6ZSk7Ci0Jc2l6ZSA9 ICgxICsgOCAqIGNvdW50KSAqIHNpemVvZih1MzIpOwotCXNpemUgPSByb3VuZF91cChzaXplLCBQ QUdFX1NJWkUpOwotCXBvb2wgPSBpbnRlbF9ndF9nZXRfYnVmZmVyX3Bvb2woY2UtPmVuZ2luZS0+ Z3QsIHNpemUsIEk5MTVfTUFQX1dDKTsKLQlpZiAoSVNfRVJSKHBvb2wpKSB7Ci0JCWVyciA9IFBU Ul9FUlIocG9vbCk7Ci0JCWdvdG8gb3V0X3BtOwotCX0KLQotCWVyciA9IGk5MTVfZ2VtX29iamVj dF9sb2NrKHBvb2wtPm9iaiwgd3cpOwotCWlmIChlcnIpCi0JCWdvdG8gb3V0X3B1dDsKLQotCWJh dGNoID0gaTkxNV92bWFfaW5zdGFuY2UocG9vbC0+b2JqLCBjZS0+dm0sIE5VTEwpOwotCWlmIChJ U19FUlIoYmF0Y2gpKSB7Ci0JCWVyciA9IFBUUl9FUlIoYmF0Y2gpOwotCQlnb3RvIG91dF9wdXQ7 Ci0JfQotCi0JZXJyID0gaTkxNV92bWFfcGluX3d3KGJhdGNoLCB3dywgMCwgMCwgUElOX1VTRVIp OwotCWlmICh1bmxpa2VseShlcnIpKQotCQlnb3RvIG91dF9wdXQ7Ci0KLQkvKiB3ZSBwaW5uZWQg dGhlIHBvb2wsIG1hcmsgaXQgYXMgc3VjaCAqLwotCWludGVsX2d0X2J1ZmZlcl9wb29sX21hcmtf dXNlZChwb29sKTsKLQotCWNtZCA9IGk5MTVfZ2VtX29iamVjdF9waW5fbWFwKHBvb2wtPm9iaiwg cG9vbC0+dHlwZSk7Ci0JaWYgKElTX0VSUihjbWQpKSB7Ci0JCWVyciA9IFBUUl9FUlIoY21kKTsK LQkJZ290byBvdXRfdW5waW47Ci0JfQotCi0JcmVtID0gdm1hLT5zaXplOwotCW9mZnNldCA9IHZt YS0+bm9kZS5zdGFydDsKLQotCWRvIHsKLQkJdTMyIHNpemUgPSBtaW5fdCh1NjQsIHJlbSwgYmxv Y2tfc2l6ZSk7Ci0KLQkJR0VNX0JVR19PTihzaXplID4+IFBBR0VfU0hJRlQgPiBTMTZfTUFYKTsK LQotCQlpZiAoR1JBUEhJQ1NfVkVSKGk5MTUpID49IDgpIHsKLQkJCSpjbWQrKyA9IFhZX0NPTE9S X0JMVF9DTUQgfCBCTFRfV1JJVEVfUkdCQSB8ICg3IC0gMik7Ci0JCQkqY21kKysgPSBCTFRfREVQ VEhfMzIgfCBCTFRfUk9QX0NPTE9SX0NPUFkgfCBQQUdFX1NJWkU7Ci0JCQkqY21kKysgPSAwOwot CQkJKmNtZCsrID0gc2l6ZSA+PiBQQUdFX1NISUZUIDw8IDE2IHwgUEFHRV9TSVpFIC8gNDsKLQkJ CSpjbWQrKyA9IGxvd2VyXzMyX2JpdHMob2Zmc2V0KTsKLQkJCSpjbWQrKyA9IHVwcGVyXzMyX2Jp dHMob2Zmc2V0KTsKLQkJCSpjbWQrKyA9IHZhbHVlOwotCQl9IGVsc2UgewotCQkJKmNtZCsrID0g WFlfQ09MT1JfQkxUX0NNRCB8IEJMVF9XUklURV9SR0JBIHwgKDYgLSAyKTsKLQkJCSpjbWQrKyA9 IEJMVF9ERVBUSF8zMiB8IEJMVF9ST1BfQ09MT1JfQ09QWSB8IFBBR0VfU0laRTsKLQkJCSpjbWQr KyA9IDA7Ci0JCQkqY21kKysgPSBzaXplID4+IFBBR0VfU0hJRlQgPDwgMTYgfCBQQUdFX1NJWkUg LyA0OwotCQkJKmNtZCsrID0gb2Zmc2V0OwotCQkJKmNtZCsrID0gdmFsdWU7Ci0JCX0KLQotCQkv KiBBbGxvdyBvdXJzZWx2ZXMgdG8gYmUgcHJlZW1wdGVkIGluIGJldHdlZW4gYmxvY2tzLiAqLwot CQkqY21kKysgPSBNSV9BUkJfQ0hFQ0s7Ci0KLQkJb2Zmc2V0ICs9IHNpemU7Ci0JCXJlbSAtPSBz aXplOwotCX0gd2hpbGUgKHJlbSk7Ci0KLQkqY21kID0gTUlfQkFUQ0hfQlVGRkVSX0VORDsKLQot CWk5MTVfZ2VtX29iamVjdF9mbHVzaF9tYXAocG9vbC0+b2JqKTsKLQlpOTE1X2dlbV9vYmplY3Rf dW5waW5fbWFwKHBvb2wtPm9iaik7Ci0KLQlpbnRlbF9ndF9jaGlwc2V0X2ZsdXNoKGNlLT52bS0+ Z3QpOwotCi0JYmF0Y2gtPnByaXZhdGUgPSBwb29sOwotCXJldHVybiBiYXRjaDsKLQotb3V0X3Vu cGluOgotCWk5MTVfdm1hX3VucGluKGJhdGNoKTsKLW91dF9wdXQ6Ci0JaW50ZWxfZ3RfYnVmZmVy X3Bvb2xfcHV0KHBvb2wpOwotb3V0X3BtOgotCWludGVsX2VuZ2luZV9wbV9wdXQoY2UtPmVuZ2lu ZSk7Ci0JcmV0dXJuIEVSUl9QVFIoZXJyKTsKLX0KLQotaW50IGludGVsX2VtaXRfdm1hX21hcmtf YWN0aXZlKHN0cnVjdCBpOTE1X3ZtYSAqdm1hLCBzdHJ1Y3QgaTkxNV9yZXF1ZXN0ICpycSkKLXsK LQlpbnQgZXJyOwotCi0JZXJyID0gaTkxNV9yZXF1ZXN0X2F3YWl0X29iamVjdChycSwgdm1hLT5v YmosIGZhbHNlKTsKLQlpZiAoZXJyID09IDApCi0JCWVyciA9IGk5MTVfdm1hX21vdmVfdG9fYWN0 aXZlKHZtYSwgcnEsIDApOwotCWlmICh1bmxpa2VseShlcnIpKQotCQlyZXR1cm4gZXJyOwotCi0J cmV0dXJuIGludGVsX2d0X2J1ZmZlcl9wb29sX21hcmtfYWN0aXZlKHZtYS0+cHJpdmF0ZSwgcnEp OwotfQotCi12b2lkIGludGVsX2VtaXRfdm1hX3JlbGVhc2Uoc3RydWN0IGludGVsX2NvbnRleHQg KmNlLCBzdHJ1Y3QgaTkxNV92bWEgKnZtYSkKLXsKLQlpOTE1X3ZtYV91bnBpbih2bWEpOwotCWlu dGVsX2d0X2J1ZmZlcl9wb29sX3B1dCh2bWEtPnByaXZhdGUpOwotCWludGVsX2VuZ2luZV9wbV9w dXQoY2UtPmVuZ2luZSk7Ci19Ci0KLXN0YXRpYyBpbnQKLW1vdmVfb2JqX3RvX2dwdShzdHJ1Y3Qg ZHJtX2k5MTVfZ2VtX29iamVjdCAqb2JqLAotCQlzdHJ1Y3QgaTkxNV9yZXF1ZXN0ICpycSwKLQkJ Ym9vbCB3cml0ZSkKLXsKLQlpZiAob2JqLT5jYWNoZV9kaXJ0eSAmIH5vYmotPmNhY2hlX2NvaGVy ZW50KQotCQlpOTE1X2dlbV9jbGZsdXNoX29iamVjdChvYmosIDApOwotCi0JcmV0dXJuIGk5MTVf cmVxdWVzdF9hd2FpdF9vYmplY3QocnEsIG9iaiwgd3JpdGUpOwotfQotCi1pbnQgaTkxNV9nZW1f b2JqZWN0X2ZpbGxfYmx0KHN0cnVjdCBkcm1faTkxNV9nZW1fb2JqZWN0ICpvYmosCi0JCQkgICAg IHN0cnVjdCBpbnRlbF9jb250ZXh0ICpjZSwKLQkJCSAgICAgdTMyIHZhbHVlKQotewotCXN0cnVj dCBpOTE1X2dlbV93d19jdHggd3c7Ci0Jc3RydWN0IGk5MTVfcmVxdWVzdCAqcnE7Ci0Jc3RydWN0 IGk5MTVfdm1hICpiYXRjaDsKLQlzdHJ1Y3QgaTkxNV92bWEgKnZtYTsKLQlpbnQgZXJyOwotCi0J dm1hID0gaTkxNV92bWFfaW5zdGFuY2Uob2JqLCBjZS0+dm0sIE5VTEwpOwotCWlmIChJU19FUlIo dm1hKSkKLQkJcmV0dXJuIFBUUl9FUlIodm1hKTsKLQotCWk5MTVfZ2VtX3d3X2N0eF9pbml0KCZ3 dywgdHJ1ZSk7Ci0JaW50ZWxfZW5naW5lX3BtX2dldChjZS0+ZW5naW5lKTsKLXJldHJ5OgotCWVy ciA9IGk5MTVfZ2VtX29iamVjdF9sb2NrKG9iaiwgJnd3KTsKLQlpZiAoZXJyKQotCQlnb3RvIG91 dDsKLQotCWVyciA9IGludGVsX2NvbnRleHRfcGluX3d3KGNlLCAmd3cpOwotCWlmIChlcnIpCi0J CWdvdG8gb3V0OwotCi0JZXJyID0gaTkxNV92bWFfcGluX3d3KHZtYSwgJnd3LCAwLCAwLCBQSU5f VVNFUik7Ci0JaWYgKGVycikKLQkJZ290byBvdXRfY3R4OwotCi0JYmF0Y2ggPSBpbnRlbF9lbWl0 X3ZtYV9maWxsX2JsdChjZSwgdm1hLCAmd3csIHZhbHVlKTsKLQlpZiAoSVNfRVJSKGJhdGNoKSkg ewotCQllcnIgPSBQVFJfRVJSKGJhdGNoKTsKLQkJZ290byBvdXRfdm1hOwotCX0KLQotCXJxID0g aTkxNV9yZXF1ZXN0X2NyZWF0ZShjZSk7Ci0JaWYgKElTX0VSUihycSkpIHsKLQkJZXJyID0gUFRS X0VSUihycSk7Ci0JCWdvdG8gb3V0X2JhdGNoOwotCX0KLQotCWVyciA9IGludGVsX2VtaXRfdm1h X21hcmtfYWN0aXZlKGJhdGNoLCBycSk7Ci0JaWYgKHVubGlrZWx5KGVycikpCi0JCWdvdG8gb3V0 X3JlcXVlc3Q7Ci0KLQllcnIgPSBtb3ZlX29ial90b19ncHUodm1hLT5vYmosIHJxLCB0cnVlKTsK LQlpZiAoZXJyID09IDApCi0JCWVyciA9IGk5MTVfdm1hX21vdmVfdG9fYWN0aXZlKHZtYSwgcnEs IEVYRUNfT0JKRUNUX1dSSVRFKTsKLQlpZiAodW5saWtlbHkoZXJyKSkKLQkJZ290byBvdXRfcmVx dWVzdDsKLQotCWlmIChjZS0+ZW5naW5lLT5lbWl0X2luaXRfYnJlYWRjcnVtYikKLQkJZXJyID0g Y2UtPmVuZ2luZS0+ZW1pdF9pbml0X2JyZWFkY3J1bWIocnEpOwotCi0JaWYgKGxpa2VseSghZXJy KSkKLQkJZXJyID0gY2UtPmVuZ2luZS0+ZW1pdF9iYl9zdGFydChycSwKLQkJCQkJCWJhdGNoLT5u b2RlLnN0YXJ0LAotCQkJCQkJYmF0Y2gtPm5vZGUuc2l6ZSwKLQkJCQkJCTApOwotb3V0X3JlcXVl c3Q6Ci0JaWYgKHVubGlrZWx5KGVycikpCi0JCWk5MTVfcmVxdWVzdF9zZXRfZXJyb3Jfb25jZShy cSwgZXJyKTsKLQotCWk5MTVfcmVxdWVzdF9hZGQocnEpOwotb3V0X2JhdGNoOgotCWludGVsX2Vt aXRfdm1hX3JlbGVhc2UoY2UsIGJhdGNoKTsKLW91dF92bWE6Ci0JaTkxNV92bWFfdW5waW4odm1h KTsKLW91dF9jdHg6Ci0JaW50ZWxfY29udGV4dF91bnBpbihjZSk7Ci1vdXQ6Ci0JaWYgKGVyciA9 PSAtRURFQURMSykgewotCQllcnIgPSBpOTE1X2dlbV93d19jdHhfYmFja29mZigmd3cpOwotCQlp ZiAoIWVycikKLQkJCWdvdG8gcmV0cnk7Ci0JfQotCWk5MTVfZ2VtX3d3X2N0eF9maW5pKCZ3dyk7 Ci0JaW50ZWxfZW5naW5lX3BtX3B1dChjZS0+ZW5naW5lKTsKLQlyZXR1cm4gZXJyOwotfQotCi0v KiBXYV8xMjA5NjQ0NjExOmljbCxlaGwgKi8KLXN0YXRpYyBib29sIHdhXzEyMDk2NDQ2MTFfYXBw bGllcyhzdHJ1Y3QgZHJtX2k5MTVfcHJpdmF0ZSAqaTkxNSwgdTMyIHNpemUpCi17Ci0JdTMyIGhl aWdodCA9IHNpemUgPj4gUEFHRV9TSElGVDsKLQotCWlmIChHUkFQSElDU19WRVIoaTkxNSkgIT0g MTEpCi0JCXJldHVybiBmYWxzZTsKLQotCXJldHVybiBoZWlnaHQgJSA0ID09IDMgJiYgaGVpZ2h0 IDw9IDg7Ci19Ci0KLXN0cnVjdCBpOTE1X3ZtYSAqaW50ZWxfZW1pdF92bWFfY29weV9ibHQoc3Ry dWN0IGludGVsX2NvbnRleHQgKmNlLAotCQkJCQkgc3RydWN0IGk5MTVfZ2VtX3d3X2N0eCAqd3cs Ci0JCQkJCSBzdHJ1Y3QgaTkxNV92bWEgKnNyYywKLQkJCQkJIHN0cnVjdCBpOTE1X3ZtYSAqZHN0 KQotewotCXN0cnVjdCBkcm1faTkxNV9wcml2YXRlICppOTE1ID0gY2UtPnZtLT5pOTE1OwotCWNv bnN0IHUzMiBibG9ja19zaXplID0gU1pfOE07IC8qIH4xbXMgYXQgOEdpQi9zIHByZWVtcHRpb24g ZGVsYXkgKi8KLQlzdHJ1Y3QgaW50ZWxfZ3RfYnVmZmVyX3Bvb2xfbm9kZSAqcG9vbDsKLQlzdHJ1 Y3QgaTkxNV92bWEgKmJhdGNoOwotCXU2NCBzcmNfb2Zmc2V0LCBkc3Rfb2Zmc2V0OwotCXU2NCBj b3VudCwgcmVtOwotCXUzMiBzaXplLCAqY21kOwotCWludCBlcnI7Ci0KLQlHRU1fQlVHX09OKHNy Yy0+c2l6ZSAhPSBkc3QtPnNpemUpOwotCi0JR0VNX0JVR19PTihpbnRlbF9lbmdpbmVfaXNfdmly dHVhbChjZS0+ZW5naW5lKSk7Ci0JaW50ZWxfZW5naW5lX3BtX2dldChjZS0+ZW5naW5lKTsKLQot CWNvdW50ID0gZGl2X3U2NChyb3VuZF91cChkc3QtPnNpemUsIGJsb2NrX3NpemUpLCBibG9ja19z aXplKTsKLQlzaXplID0gKDEgKyAxMSAqIGNvdW50KSAqIHNpemVvZih1MzIpOwotCXNpemUgPSBy b3VuZF91cChzaXplLCBQQUdFX1NJWkUpOwotCXBvb2wgPSBpbnRlbF9ndF9nZXRfYnVmZmVyX3Bv b2woY2UtPmVuZ2luZS0+Z3QsIHNpemUsIEk5MTVfTUFQX1dDKTsKLQlpZiAoSVNfRVJSKHBvb2wp KSB7Ci0JCWVyciA9IFBUUl9FUlIocG9vbCk7Ci0JCWdvdG8gb3V0X3BtOwotCX0KLQotCWVyciA9 IGk5MTVfZ2VtX29iamVjdF9sb2NrKHBvb2wtPm9iaiwgd3cpOwotCWlmIChlcnIpCi0JCWdvdG8g b3V0X3B1dDsKLQotCWJhdGNoID0gaTkxNV92bWFfaW5zdGFuY2UocG9vbC0+b2JqLCBjZS0+dm0s IE5VTEwpOwotCWlmIChJU19FUlIoYmF0Y2gpKSB7Ci0JCWVyciA9IFBUUl9FUlIoYmF0Y2gpOwot CQlnb3RvIG91dF9wdXQ7Ci0JfQotCi0JZXJyID0gaTkxNV92bWFfcGluX3d3KGJhdGNoLCB3dywg MCwgMCwgUElOX1VTRVIpOwotCWlmICh1bmxpa2VseShlcnIpKQotCQlnb3RvIG91dF9wdXQ7Ci0K LQkvKiB3ZSBwaW5uZWQgdGhlIHBvb2wsIG1hcmsgaXQgYXMgc3VjaCAqLwotCWludGVsX2d0X2J1 ZmZlcl9wb29sX21hcmtfdXNlZChwb29sKTsKLQotCWNtZCA9IGk5MTVfZ2VtX29iamVjdF9waW5f bWFwKHBvb2wtPm9iaiwgcG9vbC0+dHlwZSk7Ci0JaWYgKElTX0VSUihjbWQpKSB7Ci0JCWVyciA9 IFBUUl9FUlIoY21kKTsKLQkJZ290byBvdXRfdW5waW47Ci0JfQotCi0JcmVtID0gc3JjLT5zaXpl OwotCXNyY19vZmZzZXQgPSBzcmMtPm5vZGUuc3RhcnQ7Ci0JZHN0X29mZnNldCA9IGRzdC0+bm9k ZS5zdGFydDsKLQotCWRvIHsKLQkJc2l6ZSA9IG1pbl90KHU2NCwgcmVtLCBibG9ja19zaXplKTsK LQkJR0VNX0JVR19PTihzaXplID4+IFBBR0VfU0hJRlQgPiBTMTZfTUFYKTsKLQotCQlpZiAoR1JB UEhJQ1NfVkVSKGk5MTUpID49IDkgJiYKLQkJICAgICF3YV8xMjA5NjQ0NjExX2FwcGxpZXMoaTkx NSwgc2l6ZSkpIHsKLQkJCSpjbWQrKyA9IEdFTjlfWFlfRkFTVF9DT1BZX0JMVF9DTUQgfCAoMTAg LSAyKTsKLQkJCSpjbWQrKyA9IEJMVF9ERVBUSF8zMiB8IFBBR0VfU0laRTsKLQkJCSpjbWQrKyA9 IDA7Ci0JCQkqY21kKysgPSBzaXplID4+IFBBR0VfU0hJRlQgPDwgMTYgfCBQQUdFX1NJWkUgLyA0 OwotCQkJKmNtZCsrID0gbG93ZXJfMzJfYml0cyhkc3Rfb2Zmc2V0KTsKLQkJCSpjbWQrKyA9IHVw cGVyXzMyX2JpdHMoZHN0X29mZnNldCk7Ci0JCQkqY21kKysgPSAwOwotCQkJKmNtZCsrID0gUEFH RV9TSVpFOwotCQkJKmNtZCsrID0gbG93ZXJfMzJfYml0cyhzcmNfb2Zmc2V0KTsKLQkJCSpjbWQr KyA9IHVwcGVyXzMyX2JpdHMoc3JjX29mZnNldCk7Ci0JCX0gZWxzZSBpZiAoR1JBUEhJQ1NfVkVS KGk5MTUpID49IDgpIHsKLQkJCSpjbWQrKyA9IFhZX1NSQ19DT1BZX0JMVF9DTUQgfCBCTFRfV1JJ VEVfUkdCQSB8ICgxMCAtIDIpOwotCQkJKmNtZCsrID0gQkxUX0RFUFRIXzMyIHwgQkxUX1JPUF9T UkNfQ09QWSB8IFBBR0VfU0laRTsKLQkJCSpjbWQrKyA9IDA7Ci0JCQkqY21kKysgPSBzaXplID4+ IFBBR0VfU0hJRlQgPDwgMTYgfCBQQUdFX1NJWkUgLyA0OwotCQkJKmNtZCsrID0gbG93ZXJfMzJf Yml0cyhkc3Rfb2Zmc2V0KTsKLQkJCSpjbWQrKyA9IHVwcGVyXzMyX2JpdHMoZHN0X29mZnNldCk7 Ci0JCQkqY21kKysgPSAwOwotCQkJKmNtZCsrID0gUEFHRV9TSVpFOwotCQkJKmNtZCsrID0gbG93 ZXJfMzJfYml0cyhzcmNfb2Zmc2V0KTsKLQkJCSpjbWQrKyA9IHVwcGVyXzMyX2JpdHMoc3JjX29m ZnNldCk7Ci0JCX0gZWxzZSB7Ci0JCQkqY21kKysgPSBTUkNfQ09QWV9CTFRfQ01EIHwgQkxUX1dS SVRFX1JHQkEgfCAoNiAtIDIpOwotCQkJKmNtZCsrID0gQkxUX0RFUFRIXzMyIHwgQkxUX1JPUF9T UkNfQ09QWSB8IFBBR0VfU0laRTsKLQkJCSpjbWQrKyA9IHNpemUgPj4gUEFHRV9TSElGVCA8PCAx NiB8IFBBR0VfU0laRTsKLQkJCSpjbWQrKyA9IGRzdF9vZmZzZXQ7Ci0JCQkqY21kKysgPSBQQUdF X1NJWkU7Ci0JCQkqY21kKysgPSBzcmNfb2Zmc2V0OwotCQl9Ci0KLQkJLyogQWxsb3cgb3Vyc2Vs dmVzIHRvIGJlIHByZWVtcHRlZCBpbiBiZXR3ZWVuIGJsb2Nrcy4gKi8KLQkJKmNtZCsrID0gTUlf QVJCX0NIRUNLOwotCi0JCXNyY19vZmZzZXQgKz0gc2l6ZTsKLQkJZHN0X29mZnNldCArPSBzaXpl OwotCQlyZW0gLT0gc2l6ZTsKLQl9IHdoaWxlIChyZW0pOwotCi0JKmNtZCA9IE1JX0JBVENIX0JV RkZFUl9FTkQ7Ci0KLQlpOTE1X2dlbV9vYmplY3RfZmx1c2hfbWFwKHBvb2wtPm9iaik7Ci0JaTkx NV9nZW1fb2JqZWN0X3VucGluX21hcChwb29sLT5vYmopOwotCi0JaW50ZWxfZ3RfY2hpcHNldF9m bHVzaChjZS0+dm0tPmd0KTsKLQliYXRjaC0+cHJpdmF0ZSA9IHBvb2w7Ci0JcmV0dXJuIGJhdGNo OwotCi1vdXRfdW5waW46Ci0JaTkxNV92bWFfdW5waW4oYmF0Y2gpOwotb3V0X3B1dDoKLQlpbnRl bF9ndF9idWZmZXJfcG9vbF9wdXQocG9vbCk7Ci1vdXRfcG06Ci0JaW50ZWxfZW5naW5lX3BtX3B1 dChjZS0+ZW5naW5lKTsKLQlyZXR1cm4gRVJSX1BUUihlcnIpOwotfQotCi1pbnQgaTkxNV9nZW1f b2JqZWN0X2NvcHlfYmx0KHN0cnVjdCBkcm1faTkxNV9nZW1fb2JqZWN0ICpzcmMsCi0JCQkgICAg IHN0cnVjdCBkcm1faTkxNV9nZW1fb2JqZWN0ICpkc3QsCi0JCQkgICAgIHN0cnVjdCBpbnRlbF9j b250ZXh0ICpjZSkKLXsKLQlzdHJ1Y3QgaTkxNV9hZGRyZXNzX3NwYWNlICp2bSA9IGNlLT52bTsK LQlzdHJ1Y3QgaTkxNV92bWEgKnZtYVsyXSwgKmJhdGNoOwotCXN0cnVjdCBpOTE1X2dlbV93d19j dHggd3c7Ci0Jc3RydWN0IGk5MTVfcmVxdWVzdCAqcnE7Ci0JaW50IGVyciwgaTsKLQotCXZtYVsw XSA9IGk5MTVfdm1hX2luc3RhbmNlKHNyYywgdm0sIE5VTEwpOwotCWlmIChJU19FUlIodm1hWzBd KSkKLQkJcmV0dXJuIFBUUl9FUlIodm1hWzBdKTsKLQotCXZtYVsxXSA9IGk5MTVfdm1hX2luc3Rh bmNlKGRzdCwgdm0sIE5VTEwpOwotCWlmIChJU19FUlIodm1hWzFdKSkKLQkJcmV0dXJuIFBUUl9F UlIodm1hWzFdKTsKLQotCWk5MTVfZ2VtX3d3X2N0eF9pbml0KCZ3dywgdHJ1ZSk7Ci0JaW50ZWxf ZW5naW5lX3BtX2dldChjZS0+ZW5naW5lKTsKLXJldHJ5OgotCWVyciA9IGk5MTVfZ2VtX29iamVj dF9sb2NrKHNyYywgJnd3KTsKLQlpZiAoIWVycikKLQkJZXJyID0gaTkxNV9nZW1fb2JqZWN0X2xv Y2soZHN0LCAmd3cpOwotCWlmICghZXJyKQotCQllcnIgPSBpbnRlbF9jb250ZXh0X3Bpbl93dyhj ZSwgJnd3KTsKLQlpZiAoZXJyKQotCQlnb3RvIG91dDsKLQotCWVyciA9IGk5MTVfdm1hX3Bpbl93 dyh2bWFbMF0sICZ3dywgMCwgMCwgUElOX1VTRVIpOwotCWlmIChlcnIpCi0JCWdvdG8gb3V0X2N0 eDsKLQotCWVyciA9IGk5MTVfdm1hX3Bpbl93dyh2bWFbMV0sICZ3dywgMCwgMCwgUElOX1VTRVIp OwotCWlmICh1bmxpa2VseShlcnIpKQotCQlnb3RvIG91dF91bnBpbl9zcmM7Ci0KLQliYXRjaCA9 IGludGVsX2VtaXRfdm1hX2NvcHlfYmx0KGNlLCAmd3csIHZtYVswXSwgdm1hWzFdKTsKLQlpZiAo SVNfRVJSKGJhdGNoKSkgewotCQllcnIgPSBQVFJfRVJSKGJhdGNoKTsKLQkJZ290byBvdXRfdW5w aW5fZHN0OwotCX0KLQotCXJxID0gaTkxNV9yZXF1ZXN0X2NyZWF0ZShjZSk7Ci0JaWYgKElTX0VS UihycSkpIHsKLQkJZXJyID0gUFRSX0VSUihycSk7Ci0JCWdvdG8gb3V0X2JhdGNoOwotCX0KLQot CWVyciA9IGludGVsX2VtaXRfdm1hX21hcmtfYWN0aXZlKGJhdGNoLCBycSk7Ci0JaWYgKHVubGlr ZWx5KGVycikpCi0JCWdvdG8gb3V0X3JlcXVlc3Q7Ci0KLQlmb3IgKGkgPSAwOyBpIDwgQVJSQVlf U0laRSh2bWEpOyBpKyspIHsKLQkJZXJyID0gbW92ZV9vYmpfdG9fZ3B1KHZtYVtpXS0+b2JqLCBy cSwgaSk7Ci0JCWlmICh1bmxpa2VseShlcnIpKQotCQkJZ290byBvdXRfcmVxdWVzdDsKLQl9Ci0K LQlmb3IgKGkgPSAwOyBpIDwgQVJSQVlfU0laRSh2bWEpOyBpKyspIHsKLQkJdW5zaWduZWQgaW50 IGZsYWdzID0gaSA/IEVYRUNfT0JKRUNUX1dSSVRFIDogMDsKLQotCQllcnIgPSBpOTE1X3ZtYV9t b3ZlX3RvX2FjdGl2ZSh2bWFbaV0sIHJxLCBmbGFncyk7Ci0JCWlmICh1bmxpa2VseShlcnIpKQot CQkJZ290byBvdXRfcmVxdWVzdDsKLQl9Ci0KLQlpZiAocnEtPmVuZ2luZS0+ZW1pdF9pbml0X2Jy ZWFkY3J1bWIpIHsKLQkJZXJyID0gcnEtPmVuZ2luZS0+ZW1pdF9pbml0X2JyZWFkY3J1bWIocnEp OwotCQlpZiAodW5saWtlbHkoZXJyKSkKLQkJCWdvdG8gb3V0X3JlcXVlc3Q7Ci0JfQotCi0JZXJy ID0gcnEtPmVuZ2luZS0+ZW1pdF9iYl9zdGFydChycSwKLQkJCQkJYmF0Y2gtPm5vZGUuc3RhcnQs IGJhdGNoLT5ub2RlLnNpemUsCi0JCQkJCTApOwotCi1vdXRfcmVxdWVzdDoKLQlpZiAodW5saWtl bHkoZXJyKSkKLQkJaTkxNV9yZXF1ZXN0X3NldF9lcnJvcl9vbmNlKHJxLCBlcnIpOwotCi0JaTkx NV9yZXF1ZXN0X2FkZChycSk7Ci1vdXRfYmF0Y2g6Ci0JaW50ZWxfZW1pdF92bWFfcmVsZWFzZShj ZSwgYmF0Y2gpOwotb3V0X3VucGluX2RzdDoKLQlpOTE1X3ZtYV91bnBpbih2bWFbMV0pOwotb3V0 X3VucGluX3NyYzoKLQlpOTE1X3ZtYV91bnBpbih2bWFbMF0pOwotb3V0X2N0eDoKLQlpbnRlbF9j b250ZXh0X3VucGluKGNlKTsKLW91dDoKLQlpZiAoZXJyID09IC1FREVBRExLKSB7Ci0JCWVyciA9 IGk5MTVfZ2VtX3d3X2N0eF9iYWNrb2ZmKCZ3dyk7Ci0JCWlmICghZXJyKQotCQkJZ290byByZXRy eTsKLQl9Ci0JaTkxNV9nZW1fd3dfY3R4X2ZpbmkoJnd3KTsKLQlpbnRlbF9lbmdpbmVfcG1fcHV0 KGNlLT5lbmdpbmUpOwotCXJldHVybiBlcnI7Ci19Ci0KLSNpZiBJU19FTkFCTEVEKENPTkZJR19E Uk1fSTkxNV9TRUxGVEVTVCkKLSNpbmNsdWRlICJzZWxmdGVzdHMvaTkxNV9nZW1fb2JqZWN0X2Js dC5jIgotI2VuZGlmCmRpZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9kcm0vaTkxNS9nZW0vaTkxNV9n ZW1fb2JqZWN0X2JsdC5oIGIvZHJpdmVycy9ncHUvZHJtL2k5MTUvZ2VtL2k5MTVfZ2VtX29iamVj dF9ibHQuaApkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMjQwOWZkY2NjZjBlLi4wMDAw MDAwMDAwMDAKLS0tIGEvZHJpdmVycy9ncHUvZHJtL2k5MTUvZ2VtL2k5MTVfZ2VtX29iamVjdF9i bHQuaAorKysgL2Rldi9udWxsCkBAIC0xLDM5ICswLDAgQEAKLS8qIFNQRFgtTGljZW5zZS1JZGVu dGlmaWVyOiBNSVQgKi8KLS8qCi0gKiBDb3B5cmlnaHQgwqkgMjAxOSBJbnRlbCBDb3Jwb3JhdGlv bgotICovCi0KLSNpZm5kZWYgX19JOTE1X0dFTV9PQkpFQ1RfQkxUX0hfXwotI2RlZmluZSBfX0k5 MTVfR0VNX09CSkVDVF9CTFRfSF9fCi0KLSNpbmNsdWRlIDxsaW51eC90eXBlcy5oPgotCi0jaW5j bHVkZSAiZ3QvaW50ZWxfY29udGV4dC5oIgotI2luY2x1ZGUgImd0L2ludGVsX2VuZ2luZV9wbS5o IgotI2luY2x1ZGUgImk5MTVfdm1hLmgiCi0KLXN0cnVjdCBkcm1faTkxNV9nZW1fb2JqZWN0Owot c3RydWN0IGk5MTVfZ2VtX3d3X2N0eDsKLQotc3RydWN0IGk5MTVfdm1hICppbnRlbF9lbWl0X3Zt YV9maWxsX2JsdChzdHJ1Y3QgaW50ZWxfY29udGV4dCAqY2UsCi0JCQkJCSBzdHJ1Y3QgaTkxNV92 bWEgKnZtYSwKLQkJCQkJIHN0cnVjdCBpOTE1X2dlbV93d19jdHggKnd3LAotCQkJCQkgdTMyIHZh bHVlKTsKLQotc3RydWN0IGk5MTVfdm1hICppbnRlbF9lbWl0X3ZtYV9jb3B5X2JsdChzdHJ1Y3Qg aW50ZWxfY29udGV4dCAqY2UsCi0JCQkJCSBzdHJ1Y3QgaTkxNV9nZW1fd3dfY3R4ICp3dywKLQkJ CQkJIHN0cnVjdCBpOTE1X3ZtYSAqc3JjLAotCQkJCQkgc3RydWN0IGk5MTVfdm1hICpkc3QpOwot Ci1pbnQgaW50ZWxfZW1pdF92bWFfbWFya19hY3RpdmUoc3RydWN0IGk5MTVfdm1hICp2bWEsIHN0 cnVjdCBpOTE1X3JlcXVlc3QgKnJxKTsKLXZvaWQgaW50ZWxfZW1pdF92bWFfcmVsZWFzZShzdHJ1 Y3QgaW50ZWxfY29udGV4dCAqY2UsIHN0cnVjdCBpOTE1X3ZtYSAqdm1hKTsKLQotaW50IGk5MTVf Z2VtX29iamVjdF9maWxsX2JsdChzdHJ1Y3QgZHJtX2k5MTVfZ2VtX29iamVjdCAqb2JqLAotCQkJ ICAgICBzdHJ1Y3QgaW50ZWxfY29udGV4dCAqY2UsCi0JCQkgICAgIHUzMiB2YWx1ZSk7Ci0KLWlu dCBpOTE1X2dlbV9vYmplY3RfY29weV9ibHQoc3RydWN0IGRybV9pOTE1X2dlbV9vYmplY3QgKnNy YywKLQkJCSAgICAgc3RydWN0IGRybV9pOTE1X2dlbV9vYmplY3QgKmRzdCwKLQkJCSAgICAgc3Ry dWN0IGludGVsX2NvbnRleHQgKmNlKTsKLQotI2VuZGlmCmRpZmYgLS1naXQgYS9kcml2ZXJzL2dw dS9kcm0vaTkxNS9nZW0vc2VsZnRlc3RzL2k5MTVfZ2VtX29iamVjdF9ibHQuYyBiL2RyaXZlcnMv Z3B1L2RybS9pOTE1L2dlbS9zZWxmdGVzdHMvaTkxNV9nZW1fb2JqZWN0X2JsdC5jCmRlbGV0ZWQg ZmlsZSBtb2RlIDEwMDY0NAppbmRleCA4YzMzNWQxYTg0MDYuLjAwMDAwMDAwMDAwMAotLS0gYS9k cml2ZXJzL2dwdS9kcm0vaTkxNS9nZW0vc2VsZnRlc3RzL2k5MTVfZ2VtX29iamVjdF9ibHQuYwor KysgL2Rldi9udWxsCkBAIC0xLDU5NyArMCwwIEBACi0vLyBTUERYLUxpY2Vuc2UtSWRlbnRpZmll cjogTUlUCi0vKgotICogQ29weXJpZ2h0IMKpIDIwMTkgSW50ZWwgQ29ycG9yYXRpb24KLSAqLwot Ci0jaW5jbHVkZSA8bGludXgvc29ydC5oPgotCi0jaW5jbHVkZSAiZ3QvaW50ZWxfZ3QuaCIKLSNp bmNsdWRlICJndC9pbnRlbF9lbmdpbmVfdXNlci5oIgotCi0jaW5jbHVkZSAiaTkxNV9zZWxmdGVz dC5oIgotCi0jaW5jbHVkZSAiZ2VtL2k5MTVfZ2VtX2NvbnRleHQuaCIKLSNpbmNsdWRlICJzZWxm dGVzdHMvaWd0X2ZsdXNoX3Rlc3QuaCIKLSNpbmNsdWRlICJzZWxmdGVzdHMvaTkxNV9yYW5kb20u aCIKLSNpbmNsdWRlICJzZWxmdGVzdHMvbW9ja19kcm0uaCIKLSNpbmNsdWRlICJodWdlX2dlbV9v YmplY3QuaCIKLSNpbmNsdWRlICJtb2NrX2NvbnRleHQuaCIKLQotc3RhdGljIGludCB3cmFwX2t0 aW1lX2NvbXBhcmUoY29uc3Qgdm9pZCAqQSwgY29uc3Qgdm9pZCAqQikKLXsKLQljb25zdCBrdGlt ZV90ICphID0gQSwgKmIgPSBCOwotCi0JcmV0dXJuIGt0aW1lX2NvbXBhcmUoKmEsICpiKTsKLX0K LQotc3RhdGljIGludCBfX3BlcmZfZmlsbF9ibHQoc3RydWN0IGRybV9pOTE1X2dlbV9vYmplY3Qg Km9iaikKLXsKLQlzdHJ1Y3QgZHJtX2k5MTVfcHJpdmF0ZSAqaTkxNSA9IHRvX2k5MTUob2JqLT5i YXNlLmRldik7Ci0JaW50IGluc3QgPSAwOwotCi0JZG8gewotCQlzdHJ1Y3QgaW50ZWxfZW5naW5l X2NzICplbmdpbmU7Ci0JCWt0aW1lX3QgdFs1XTsKLQkJaW50IHBhc3M7Ci0JCWludCBlcnI7Ci0K LQkJZW5naW5lID0gaW50ZWxfZW5naW5lX2xvb2t1cF91c2VyKGk5MTUsCi0JCQkJCQkgIEk5MTVf RU5HSU5FX0NMQVNTX0NPUFksCi0JCQkJCQkgIGluc3QrKyk7Ci0JCWlmICghZW5naW5lKQotCQkJ cmV0dXJuIDA7Ci0KLQkJaW50ZWxfZW5naW5lX3BtX2dldChlbmdpbmUpOwotCQlmb3IgKHBhc3Mg PSAwOyBwYXNzIDwgQVJSQVlfU0laRSh0KTsgcGFzcysrKSB7Ci0JCQlzdHJ1Y3QgaW50ZWxfY29u dGV4dCAqY2UgPSBlbmdpbmUtPmtlcm5lbF9jb250ZXh0OwotCQkJa3RpbWVfdCB0MCwgdDE7Ci0K LQkJCXQwID0ga3RpbWVfZ2V0KCk7Ci0KLQkJCWVyciA9IGk5MTVfZ2VtX29iamVjdF9maWxsX2Js dChvYmosIGNlLCAwKTsKLQkJCWlmIChlcnIpCi0JCQkJYnJlYWs7Ci0KLQkJCWVyciA9IGk5MTVf Z2VtX29iamVjdF93YWl0KG9iaiwKLQkJCQkJCSAgIEk5MTVfV0FJVF9BTEwsCi0JCQkJCQkgICBN QVhfU0NIRURVTEVfVElNRU9VVCk7Ci0JCQlpZiAoZXJyKQotCQkJCWJyZWFrOwotCi0JCQl0MSA9 IGt0aW1lX2dldCgpOwotCQkJdFtwYXNzXSA9IGt0aW1lX3N1Yih0MSwgdDApOwotCQl9Ci0JCWlu dGVsX2VuZ2luZV9wbV9wdXQoZW5naW5lKTsKLQkJaWYgKGVycikKLQkJCXJldHVybiBlcnI7Ci0K LQkJc29ydCh0LCBBUlJBWV9TSVpFKHQpLCBzaXplb2YoKnQpLCB3cmFwX2t0aW1lX2NvbXBhcmUs IE5VTEwpOwotCQlwcl9pbmZvKCIlczogYmx0ICV6ZCBLaUIgZmlsbDogJWxsZCBNaUIvc1xuIiwK LQkJCWVuZ2luZS0+bmFtZSwKLQkJCW9iai0+YmFzZS5zaXplID4+IDEwLAotCQkJZGl2NjRfdTY0 KG11bF91MzJfdTMyKDQgKiBvYmotPmJhc2Uuc2l6ZSwKLQkJCQkJICAgICAgMTAwMCAqIDEwMDAg KiAxMDAwKSwKLQkJCQkgIHRbMV0gKyAyICogdFsyXSArIHRbM10pID4+IDIwKTsKLQl9IHdoaWxl ICgxKTsKLX0KLQotc3RhdGljIGludCBwZXJmX2ZpbGxfYmx0KHZvaWQgKmFyZykKLXsKLQlzdHJ1 Y3QgZHJtX2k5MTVfcHJpdmF0ZSAqaTkxNSA9IGFyZzsKLQlzdGF0aWMgY29uc3QgdW5zaWduZWQg bG9uZyBzaXplc1tdID0gewotCQlTWl80SywKLQkJU1pfNjRLLAotCQlTWl8yTSwKLQkJU1pfNjRN Ci0JfTsKLQlpbnQgaTsKLQotCWZvciAoaSA9IDA7IGkgPCBBUlJBWV9TSVpFKHNpemVzKTsgaSsr KSB7Ci0JCXN0cnVjdCBkcm1faTkxNV9nZW1fb2JqZWN0ICpvYmo7Ci0JCWludCBlcnI7Ci0KLQkJ b2JqID0gaTkxNV9nZW1fb2JqZWN0X2NyZWF0ZV9pbnRlcm5hbChpOTE1LCBzaXplc1tpXSk7Ci0J CWlmIChJU19FUlIob2JqKSkKLQkJCXJldHVybiBQVFJfRVJSKG9iaik7Ci0KLQkJZXJyID0gX19w ZXJmX2ZpbGxfYmx0KG9iaik7Ci0JCWk5MTVfZ2VtX29iamVjdF9wdXQob2JqKTsKLQkJaWYgKGVy cikKLQkJCXJldHVybiBlcnI7Ci0JfQotCi0JcmV0dXJuIDA7Ci19Ci0KLXN0YXRpYyBpbnQgX19w ZXJmX2NvcHlfYmx0KHN0cnVjdCBkcm1faTkxNV9nZW1fb2JqZWN0ICpzcmMsCi0JCQkgICBzdHJ1 Y3QgZHJtX2k5MTVfZ2VtX29iamVjdCAqZHN0KQotewotCXN0cnVjdCBkcm1faTkxNV9wcml2YXRl ICppOTE1ID0gdG9faTkxNShzcmMtPmJhc2UuZGV2KTsKLQlpbnQgaW5zdCA9IDA7Ci0KLQlkbyB7 Ci0JCXN0cnVjdCBpbnRlbF9lbmdpbmVfY3MgKmVuZ2luZTsKLQkJa3RpbWVfdCB0WzVdOwotCQlp bnQgcGFzczsKLQkJaW50IGVyciA9IDA7Ci0KLQkJZW5naW5lID0gaW50ZWxfZW5naW5lX2xvb2t1 cF91c2VyKGk5MTUsCi0JCQkJCQkgIEk5MTVfRU5HSU5FX0NMQVNTX0NPUFksCi0JCQkJCQkgIGlu c3QrKyk7Ci0JCWlmICghZW5naW5lKQotCQkJcmV0dXJuIDA7Ci0KLQkJaW50ZWxfZW5naW5lX3Bt X2dldChlbmdpbmUpOwotCQlmb3IgKHBhc3MgPSAwOyBwYXNzIDwgQVJSQVlfU0laRSh0KTsgcGFz cysrKSB7Ci0JCQlzdHJ1Y3QgaW50ZWxfY29udGV4dCAqY2UgPSBlbmdpbmUtPmtlcm5lbF9jb250 ZXh0OwotCQkJa3RpbWVfdCB0MCwgdDE7Ci0KLQkJCXQwID0ga3RpbWVfZ2V0KCk7Ci0KLQkJCWVy ciA9IGk5MTVfZ2VtX29iamVjdF9jb3B5X2JsdChzcmMsIGRzdCwgY2UpOwotCQkJaWYgKGVycikK LQkJCQlicmVhazsKLQotCQkJZXJyID0gaTkxNV9nZW1fb2JqZWN0X3dhaXQoZHN0LAotCQkJCQkJ ICAgSTkxNV9XQUlUX0FMTCwKLQkJCQkJCSAgIE1BWF9TQ0hFRFVMRV9USU1FT1VUKTsKLQkJCWlm IChlcnIpCi0JCQkJYnJlYWs7Ci0KLQkJCXQxID0ga3RpbWVfZ2V0KCk7Ci0JCQl0W3Bhc3NdID0g a3RpbWVfc3ViKHQxLCB0MCk7Ci0JCX0KLQkJaW50ZWxfZW5naW5lX3BtX3B1dChlbmdpbmUpOwot CQlpZiAoZXJyKQotCQkJcmV0dXJuIGVycjsKLQotCQlzb3J0KHQsIEFSUkFZX1NJWkUodCksIHNp emVvZigqdCksIHdyYXBfa3RpbWVfY29tcGFyZSwgTlVMTCk7Ci0JCXByX2luZm8oIiVzOiBibHQg JXpkIEtpQiBjb3B5OiAlbGxkIE1pQi9zXG4iLAotCQkJZW5naW5lLT5uYW1lLAotCQkJc3JjLT5i YXNlLnNpemUgPj4gMTAsCi0JCQlkaXY2NF91NjQobXVsX3UzMl91MzIoNCAqIHNyYy0+YmFzZS5z aXplLAotCQkJCQkgICAgICAxMDAwICogMTAwMCAqIDEwMDApLAotCQkJCSAgdFsxXSArIDIgKiB0 WzJdICsgdFszXSkgPj4gMjApOwotCX0gd2hpbGUgKDEpOwotfQotCi1zdGF0aWMgaW50IHBlcmZf Y29weV9ibHQodm9pZCAqYXJnKQotewotCXN0cnVjdCBkcm1faTkxNV9wcml2YXRlICppOTE1ID0g YXJnOwotCXN0YXRpYyBjb25zdCB1bnNpZ25lZCBsb25nIHNpemVzW10gPSB7Ci0JCVNaXzRLLAot CQlTWl82NEssCi0JCVNaXzJNLAotCQlTWl82NE0KLQl9OwotCWludCBpOwotCi0JZm9yIChpID0g MDsgaSA8IEFSUkFZX1NJWkUoc2l6ZXMpOyBpKyspIHsKLQkJc3RydWN0IGRybV9pOTE1X2dlbV9v YmplY3QgKnNyYywgKmRzdDsKLQkJaW50IGVycjsKLQotCQlzcmMgPSBpOTE1X2dlbV9vYmplY3Rf Y3JlYXRlX2ludGVybmFsKGk5MTUsIHNpemVzW2ldKTsKLQkJaWYgKElTX0VSUihzcmMpKQotCQkJ cmV0dXJuIFBUUl9FUlIoc3JjKTsKLQotCQlkc3QgPSBpOTE1X2dlbV9vYmplY3RfY3JlYXRlX2lu dGVybmFsKGk5MTUsIHNpemVzW2ldKTsKLQkJaWYgKElTX0VSUihkc3QpKSB7Ci0JCQllcnIgPSBQ VFJfRVJSKGRzdCk7Ci0JCQlnb3RvIGVycl9zcmM7Ci0JCX0KLQotCQllcnIgPSBfX3BlcmZfY29w eV9ibHQoc3JjLCBkc3QpOwotCi0JCWk5MTVfZ2VtX29iamVjdF9wdXQoZHN0KTsKLWVycl9zcmM6 Ci0JCWk5MTVfZ2VtX29iamVjdF9wdXQoc3JjKTsKLQkJaWYgKGVycikKLQkJCXJldHVybiBlcnI7 Ci0JfQotCi0JcmV0dXJuIDA7Ci19Ci0KLXN0cnVjdCBpZ3RfdGhyZWFkX2FyZyB7Ci0Jc3RydWN0 IGludGVsX2VuZ2luZV9jcyAqZW5naW5lOwotCXN0cnVjdCBpOTE1X2dlbV9jb250ZXh0ICpjdHg7 Ci0Jc3RydWN0IGZpbGUgKmZpbGU7Ci0Jc3RydWN0IHJuZF9zdGF0ZSBwcm5nOwotCXVuc2lnbmVk IGludCBuX2NwdXM7Ci19OwotCi1zdGF0aWMgaW50IGlndF9maWxsX2JsdF90aHJlYWQodm9pZCAq YXJnKQotewotCXN0cnVjdCBpZ3RfdGhyZWFkX2FyZyAqdGhyZWFkID0gYXJnOwotCXN0cnVjdCBp bnRlbF9lbmdpbmVfY3MgKmVuZ2luZSA9IHRocmVhZC0+ZW5naW5lOwotCXN0cnVjdCBybmRfc3Rh dGUgKnBybmcgPSAmdGhyZWFkLT5wcm5nOwotCXN0cnVjdCBkcm1faTkxNV9nZW1fb2JqZWN0ICpv Ymo7Ci0Jc3RydWN0IGk5MTVfZ2VtX2NvbnRleHQgKmN0eDsKLQlzdHJ1Y3QgaW50ZWxfY29udGV4 dCAqY2U7Ci0JdW5zaWduZWQgaW50IHByaW87Ci0JSUdUX1RJTUVPVVQoZW5kKTsKLQl1NjQgdG90 YWwsIG1heDsKLQlpbnQgZXJyOwotCi0JY3R4ID0gdGhyZWFkLT5jdHg7Ci0JaWYgKCFjdHgpIHsK LQkJY3R4ID0gbGl2ZV9jb250ZXh0X2Zvcl9lbmdpbmUoZW5naW5lLCB0aHJlYWQtPmZpbGUpOwot CQlpZiAoSVNfRVJSKGN0eCkpCi0JCQlyZXR1cm4gUFRSX0VSUihjdHgpOwotCi0JCXByaW8gPSBp OTE1X3ByYW5kb21fdTMyX21heF9zdGF0ZShJOTE1X1BSSU9SSVRZX01BWCwgcHJuZyk7Ci0JCWN0 eC0+c2NoZWQucHJpb3JpdHkgPSBwcmlvOwotCX0KLQotCWNlID0gaTkxNV9nZW1fY29udGV4dF9n ZXRfZW5naW5lKGN0eCwgMCk7Ci0JR0VNX0JVR19PTihJU19FUlIoY2UpKTsKLQotCS8qCi0JICog SWYgd2UgaGF2ZSBhIHRpbnkgc2hhcmVkIGFkZHJlc3Mgc3BhY2UsIGxpa2UgZm9yIHRoZSBHR1RU Ci0JICogdGhlbiB3ZSBjYW4ndCBiZSB0b28gZ3JlZWR5LgotCSAqLwotCW1heCA9IGNlLT52bS0+ dG90YWw7Ci0JaWYgKGk5MTVfaXNfZ2d0dChjZS0+dm0pIHx8IHRocmVhZC0+Y3R4KQotCQltYXgg PSBkaXZfdTY0KG1heCwgdGhyZWFkLT5uX2NwdXMpOwotCW1heCA+Pj0gNDsKLQotCXRvdGFsID0g UEFHRV9TSVpFOwotCWRvIHsKLQkJLyogQWltIHRvIGtlZXAgdGhlIHJ1bnRpbWUgdW5kZXIgcmVh c29uYWJsZSBib3VuZHMhICovCi0JCWNvbnN0IHUzMiBtYXhfcGh5c19zaXplID0gU1pfNjRLOwot CQl1MzIgdmFsID0gcHJhbmRvbV91MzJfc3RhdGUocHJuZyk7Ci0JCXUzMiBwaHlzX3N6OwotCQl1 MzIgc3o7Ci0JCXUzMiAqdmFkZHI7Ci0JCXUzMiBpOwotCi0JCXRvdGFsID0gbWluKHRvdGFsLCBt YXgpOwotCQlzeiA9IGk5MTVfcHJhbmRvbV91MzJfbWF4X3N0YXRlKHRvdGFsLCBwcm5nKSArIDE7 Ci0JCXBoeXNfc3ogPSBzeiAlIG1heF9waHlzX3NpemUgKyAxOwotCi0JCXN6ID0gcm91bmRfdXAo c3osIFBBR0VfU0laRSk7Ci0JCXBoeXNfc3ogPSByb3VuZF91cChwaHlzX3N6LCBQQUdFX1NJWkUp OwotCQlwaHlzX3N6ID0gbWluKHBoeXNfc3osIHN6KTsKLQotCQlwcl9kZWJ1ZygiJXMgd2l0aCBw aHlzX3N6PSAleCwgc3o9JXgsIHZhbD0leFxuIiwgX19mdW5jX18sCi0JCQkgcGh5c19zeiwgc3os IHZhbCk7Ci0KLQkJb2JqID0gaHVnZV9nZW1fb2JqZWN0KGVuZ2luZS0+aTkxNSwgcGh5c19zeiwg c3opOwotCQlpZiAoSVNfRVJSKG9iaikpIHsKLQkJCWVyciA9IFBUUl9FUlIob2JqKTsKLQkJCWdv dG8gZXJyX2ZsdXNoOwotCQl9Ci0KLQkJdmFkZHIgPSBpOTE1X2dlbV9vYmplY3RfcGluX21hcF91 bmxvY2tlZChvYmosIEk5MTVfTUFQX1dCKTsKLQkJaWYgKElTX0VSUih2YWRkcikpIHsKLQkJCWVy ciA9IFBUUl9FUlIodmFkZHIpOwotCQkJZ290byBlcnJfcHV0OwotCQl9Ci0KLQkJLyoKLQkJICog TWFrZSBzdXJlIHRoZSBwb3RlbnRpYWxseSBhc3luYyBjbGZsdXNoIGRvZXMgaXRzIGpvYiwgaWYK LQkJICogcmVxdWlyZWQuCi0JCSAqLwotCQltZW1zZXQzMih2YWRkciwgdmFsIF4gMHhkZWFkYmVh ZiwKLQkJCSBodWdlX2dlbV9vYmplY3RfcGh5c19zaXplKG9iaikgLyBzaXplb2YodTMyKSk7Ci0K LQkJaWYgKCEob2JqLT5jYWNoZV9jb2hlcmVudCAmIEk5MTVfQk9fQ0FDSEVfQ09IRVJFTlRfRk9S X1dSSVRFKSkKLQkJCW9iai0+Y2FjaGVfZGlydHkgPSB0cnVlOwotCi0JCWVyciA9IGk5MTVfZ2Vt X29iamVjdF9maWxsX2JsdChvYmosIGNlLCB2YWwpOwotCQlpZiAoZXJyKQotCQkJZ290byBlcnJf dW5waW47Ci0KLQkJZXJyID0gaTkxNV9nZW1fb2JqZWN0X3dhaXQob2JqLCAwLCBNQVhfU0NIRURV TEVfVElNRU9VVCk7Ci0JCWlmIChlcnIpCi0JCQlnb3RvIGVycl91bnBpbjsKLQotCQlmb3IgKGkg PSAwOyBpIDwgaHVnZV9nZW1fb2JqZWN0X3BoeXNfc2l6ZShvYmopIC8gc2l6ZW9mKHUzMik7IGkg Kz0gMTcpIHsKLQkJCWlmICghKG9iai0+Y2FjaGVfY29oZXJlbnQgJiBJOTE1X0JPX0NBQ0hFX0NP SEVSRU5UX0ZPUl9SRUFEKSkKLQkJCQlkcm1fY2xmbHVzaF92aXJ0X3JhbmdlKCZ2YWRkcltpXSwg c2l6ZW9mKHZhZGRyW2ldKSk7Ci0KLQkJCWlmICh2YWRkcltpXSAhPSB2YWwpIHsKLQkJCQlwcl9l cnIoInZhZGRyWyV1XT0leCwgZXhwZWN0ZWQ9JXhcbiIsIGksCi0JCQkJICAgICAgIHZhZGRyW2ld LCB2YWwpOwotCQkJCWVyciA9IC1FSU5WQUw7Ci0JCQkJZ290byBlcnJfdW5waW47Ci0JCQl9Ci0J CX0KLQotCQlpOTE1X2dlbV9vYmplY3RfdW5waW5fbWFwKG9iaik7Ci0JCWk5MTVfZ2VtX29iamVj dF9wdXQob2JqKTsKLQotCQl0b3RhbCA8PD0gMTsKLQl9IHdoaWxlICghdGltZV9hZnRlcihqaWZm aWVzLCBlbmQpKTsKLQotCWdvdG8gZXJyX2ZsdXNoOwotCi1lcnJfdW5waW46Ci0JaTkxNV9nZW1f b2JqZWN0X3VucGluX21hcChvYmopOwotZXJyX3B1dDoKLQlpOTE1X2dlbV9vYmplY3RfcHV0KG9i aik7Ci1lcnJfZmx1c2g6Ci0JaWYgKGVyciA9PSAtRU5PTUVNKQotCQllcnIgPSAwOwotCi0JaW50 ZWxfY29udGV4dF9wdXQoY2UpOwotCXJldHVybiBlcnI7Ci19Ci0KLXN0YXRpYyBpbnQgaWd0X2Nv cHlfYmx0X3RocmVhZCh2b2lkICphcmcpCi17Ci0Jc3RydWN0IGlndF90aHJlYWRfYXJnICp0aHJl YWQgPSBhcmc7Ci0Jc3RydWN0IGludGVsX2VuZ2luZV9jcyAqZW5naW5lID0gdGhyZWFkLT5lbmdp bmU7Ci0Jc3RydWN0IHJuZF9zdGF0ZSAqcHJuZyA9ICZ0aHJlYWQtPnBybmc7Ci0Jc3RydWN0IGRy bV9pOTE1X2dlbV9vYmplY3QgKnNyYywgKmRzdDsKLQlzdHJ1Y3QgaTkxNV9nZW1fY29udGV4dCAq Y3R4OwotCXN0cnVjdCBpbnRlbF9jb250ZXh0ICpjZTsKLQl1bnNpZ25lZCBpbnQgcHJpbzsKLQlJ R1RfVElNRU9VVChlbmQpOwotCXU2NCB0b3RhbCwgbWF4OwotCWludCBlcnI7Ci0KLQljdHggPSB0 aHJlYWQtPmN0eDsKLQlpZiAoIWN0eCkgewotCQljdHggPSBsaXZlX2NvbnRleHRfZm9yX2VuZ2lu ZShlbmdpbmUsIHRocmVhZC0+ZmlsZSk7Ci0JCWlmIChJU19FUlIoY3R4KSkKLQkJCXJldHVybiBQ VFJfRVJSKGN0eCk7Ci0KLQkJcHJpbyA9IGk5MTVfcHJhbmRvbV91MzJfbWF4X3N0YXRlKEk5MTVf UFJJT1JJVFlfTUFYLCBwcm5nKTsKLQkJY3R4LT5zY2hlZC5wcmlvcml0eSA9IHByaW87Ci0JfQot Ci0JY2UgPSBpOTE1X2dlbV9jb250ZXh0X2dldF9lbmdpbmUoY3R4LCAwKTsKLQlHRU1fQlVHX09O KElTX0VSUihjZSkpOwotCi0JLyoKLQkgKiBJZiB3ZSBoYXZlIGEgdGlueSBzaGFyZWQgYWRkcmVz cyBzcGFjZSwgbGlrZSBmb3IgdGhlIEdHVFQKLQkgKiB0aGVuIHdlIGNhbid0IGJlIHRvbyBncmVl ZHkuCi0JICovCi0JbWF4ID0gY2UtPnZtLT50b3RhbDsKLQlpZiAoaTkxNV9pc19nZ3R0KGNlLT52 bSkgfHwgdGhyZWFkLT5jdHgpCi0JCW1heCA9IGRpdl91NjQobWF4LCB0aHJlYWQtPm5fY3B1cyk7 Ci0JbWF4ID4+PSA0OwotCi0JdG90YWwgPSBQQUdFX1NJWkU7Ci0JZG8gewotCQkvKiBBaW0gdG8g a2VlcCB0aGUgcnVudGltZSB1bmRlciByZWFzb25hYmxlIGJvdW5kcyEgKi8KLQkJY29uc3QgdTMy IG1heF9waHlzX3NpemUgPSBTWl82NEs7Ci0JCXUzMiB2YWwgPSBwcmFuZG9tX3UzMl9zdGF0ZShw cm5nKTsKLQkJdTMyIHBoeXNfc3o7Ci0JCXUzMiBzejsKLQkJdTMyICp2YWRkcjsKLQkJdTMyIGk7 Ci0KLQkJdG90YWwgPSBtaW4odG90YWwsIG1heCk7Ci0JCXN6ID0gaTkxNV9wcmFuZG9tX3UzMl9t YXhfc3RhdGUodG90YWwsIHBybmcpICsgMTsKLQkJcGh5c19zeiA9IHN6ICUgbWF4X3BoeXNfc2l6 ZSArIDE7Ci0KLQkJc3ogPSByb3VuZF91cChzeiwgUEFHRV9TSVpFKTsKLQkJcGh5c19zeiA9IHJv dW5kX3VwKHBoeXNfc3osIFBBR0VfU0laRSk7Ci0JCXBoeXNfc3ogPSBtaW4ocGh5c19zeiwgc3op OwotCi0JCXByX2RlYnVnKCIlcyB3aXRoIHBoeXNfc3o9ICV4LCBzej0leCwgdmFsPSV4XG4iLCBf X2Z1bmNfXywKLQkJCSBwaHlzX3N6LCBzeiwgdmFsKTsKLQotCQlzcmMgPSBodWdlX2dlbV9vYmpl Y3QoZW5naW5lLT5pOTE1LCBwaHlzX3N6LCBzeik7Ci0JCWlmIChJU19FUlIoc3JjKSkgewotCQkJ ZXJyID0gUFRSX0VSUihzcmMpOwotCQkJZ290byBlcnJfZmx1c2g7Ci0JCX0KLQotCQl2YWRkciA9 IGk5MTVfZ2VtX29iamVjdF9waW5fbWFwX3VubG9ja2VkKHNyYywgSTkxNV9NQVBfV0IpOwotCQlp ZiAoSVNfRVJSKHZhZGRyKSkgewotCQkJZXJyID0gUFRSX0VSUih2YWRkcik7Ci0JCQlnb3RvIGVy cl9wdXRfc3JjOwotCQl9Ci0KLQkJbWVtc2V0MzIodmFkZHIsIHZhbCwKLQkJCSBodWdlX2dlbV9v YmplY3RfcGh5c19zaXplKHNyYykgLyBzaXplb2YodTMyKSk7Ci0KLQkJaTkxNV9nZW1fb2JqZWN0 X3VucGluX21hcChzcmMpOwotCi0JCWlmICghKHNyYy0+Y2FjaGVfY29oZXJlbnQgJiBJOTE1X0JP X0NBQ0hFX0NPSEVSRU5UX0ZPUl9SRUFEKSkKLQkJCXNyYy0+Y2FjaGVfZGlydHkgPSB0cnVlOwot Ci0JCWRzdCA9IGh1Z2VfZ2VtX29iamVjdChlbmdpbmUtPmk5MTUsIHBoeXNfc3osIHN6KTsKLQkJ aWYgKElTX0VSUihkc3QpKSB7Ci0JCQllcnIgPSBQVFJfRVJSKGRzdCk7Ci0JCQlnb3RvIGVycl9w dXRfc3JjOwotCQl9Ci0KLQkJdmFkZHIgPSBpOTE1X2dlbV9vYmplY3RfcGluX21hcF91bmxvY2tl ZChkc3QsIEk5MTVfTUFQX1dCKTsKLQkJaWYgKElTX0VSUih2YWRkcikpIHsKLQkJCWVyciA9IFBU Ul9FUlIodmFkZHIpOwotCQkJZ290byBlcnJfcHV0X2RzdDsKLQkJfQotCi0JCW1lbXNldDMyKHZh ZGRyLCB2YWwgXiAweGRlYWRiZWFmLAotCQkJIGh1Z2VfZ2VtX29iamVjdF9waHlzX3NpemUoZHN0 KSAvIHNpemVvZih1MzIpKTsKLQotCQlpZiAoIShkc3QtPmNhY2hlX2NvaGVyZW50ICYgSTkxNV9C T19DQUNIRV9DT0hFUkVOVF9GT1JfV1JJVEUpKQotCQkJZHN0LT5jYWNoZV9kaXJ0eSA9IHRydWU7 Ci0KLQkJZXJyID0gaTkxNV9nZW1fb2JqZWN0X2NvcHlfYmx0KHNyYywgZHN0LCBjZSk7Ci0JCWlm IChlcnIpCi0JCQlnb3RvIGVycl91bnBpbjsKLQotCQllcnIgPSBpOTE1X2dlbV9vYmplY3Rfd2Fp dChkc3QsIDAsIE1BWF9TQ0hFRFVMRV9USU1FT1VUKTsKLQkJaWYgKGVycikKLQkJCWdvdG8gZXJy X3VucGluOwotCi0JCWZvciAoaSA9IDA7IGkgPCBodWdlX2dlbV9vYmplY3RfcGh5c19zaXplKGRz dCkgLyBzaXplb2YodTMyKTsgaSArPSAxNykgewotCQkJaWYgKCEoZHN0LT5jYWNoZV9jb2hlcmVu dCAmIEk5MTVfQk9fQ0FDSEVfQ09IRVJFTlRfRk9SX1JFQUQpKQotCQkJCWRybV9jbGZsdXNoX3Zp cnRfcmFuZ2UoJnZhZGRyW2ldLCBzaXplb2YodmFkZHJbaV0pKTsKLQotCQkJaWYgKHZhZGRyW2ld ICE9IHZhbCkgewotCQkJCXByX2VycigidmFkZHJbJXVdPSV4LCBleHBlY3RlZD0leFxuIiwgaSwK LQkJCQkgICAgICAgdmFkZHJbaV0sIHZhbCk7Ci0JCQkJZXJyID0gLUVJTlZBTDsKLQkJCQlnb3Rv IGVycl91bnBpbjsKLQkJCX0KLQkJfQotCi0JCWk5MTVfZ2VtX29iamVjdF91bnBpbl9tYXAoZHN0 KTsKLQotCQlpOTE1X2dlbV9vYmplY3RfcHV0KHNyYyk7Ci0JCWk5MTVfZ2VtX29iamVjdF9wdXQo ZHN0KTsKLQotCQl0b3RhbCA8PD0gMTsKLQl9IHdoaWxlICghdGltZV9hZnRlcihqaWZmaWVzLCBl bmQpKTsKLQotCWdvdG8gZXJyX2ZsdXNoOwotCi1lcnJfdW5waW46Ci0JaTkxNV9nZW1fb2JqZWN0 X3VucGluX21hcChkc3QpOwotZXJyX3B1dF9kc3Q6Ci0JaTkxNV9nZW1fb2JqZWN0X3B1dChkc3Qp OwotZXJyX3B1dF9zcmM6Ci0JaTkxNV9nZW1fb2JqZWN0X3B1dChzcmMpOwotZXJyX2ZsdXNoOgot CWlmIChlcnIgPT0gLUVOT01FTSkKLQkJZXJyID0gMDsKLQotCWludGVsX2NvbnRleHRfcHV0KGNl KTsKLQlyZXR1cm4gZXJyOwotfQotCi1zdGF0aWMgaW50IGlndF90aHJlYWRlZF9ibHQoc3RydWN0 IGludGVsX2VuZ2luZV9jcyAqZW5naW5lLAotCQkJICAgIGludCAoKmJsdF9mbikodm9pZCAqYXJn KSwKLQkJCSAgICB1bnNpZ25lZCBpbnQgZmxhZ3MpCi0jZGVmaW5lIFNJTkdMRV9DVFggQklUKDAp Ci17Ci0Jc3RydWN0IGlndF90aHJlYWRfYXJnICp0aHJlYWQ7Ci0Jc3RydWN0IHRhc2tfc3RydWN0 ICoqdHNrOwotCXVuc2lnbmVkIGludCBuX2NwdXMsIGk7Ci0JSTkxNV9STkRfU1RBVEUocHJuZyk7 Ci0JaW50IGVyciA9IDA7Ci0KLQluX2NwdXMgPSBudW1fb25saW5lX2NwdXMoKSArIDE7Ci0KLQl0 c2sgPSBrY2FsbG9jKG5fY3B1cywgc2l6ZW9mKHN0cnVjdCB0YXNrX3N0cnVjdCAqKSwgR0ZQX0tF Uk5FTCk7Ci0JaWYgKCF0c2spCi0JCXJldHVybiAwOwotCi0JdGhyZWFkID0ga2NhbGxvYyhuX2Nw dXMsIHNpemVvZihzdHJ1Y3QgaWd0X3RocmVhZF9hcmcpLCBHRlBfS0VSTkVMKTsKLQlpZiAoIXRo cmVhZCkKLQkJZ290byBvdXRfdHNrOwotCi0JdGhyZWFkWzBdLmZpbGUgPSBtb2NrX2ZpbGUoZW5n aW5lLT5pOTE1KTsKLQlpZiAoSVNfRVJSKHRocmVhZFswXS5maWxlKSkgewotCQllcnIgPSBQVFJf RVJSKHRocmVhZFswXS5maWxlKTsKLQkJZ290byBvdXRfdGhyZWFkOwotCX0KLQotCWlmIChmbGFn cyAmIFNJTkdMRV9DVFgpIHsKLQkJdGhyZWFkWzBdLmN0eCA9IGxpdmVfY29udGV4dF9mb3JfZW5n aW5lKGVuZ2luZSwgdGhyZWFkWzBdLmZpbGUpOwotCQlpZiAoSVNfRVJSKHRocmVhZFswXS5jdHgp KSB7Ci0JCQllcnIgPSBQVFJfRVJSKHRocmVhZFswXS5jdHgpOwotCQkJZ290byBvdXRfZmlsZTsK LQkJfQotCX0KLQotCWZvciAoaSA9IDA7IGkgPCBuX2NwdXM7ICsraSkgewotCQl0aHJlYWRbaV0u ZW5naW5lID0gZW5naW5lOwotCQl0aHJlYWRbaV0uZmlsZSA9IHRocmVhZFswXS5maWxlOwotCQl0 aHJlYWRbaV0uY3R4ID0gdGhyZWFkWzBdLmN0eDsKLQkJdGhyZWFkW2ldLm5fY3B1cyA9IG5fY3B1 czsKLQkJdGhyZWFkW2ldLnBybmcgPQotCQkJSTkxNV9STkRfU1RBVEVfSU5JVElBTElaRVIocHJh bmRvbV91MzJfc3RhdGUoJnBybmcpKTsKLQotCQl0c2tbaV0gPSBrdGhyZWFkX3J1bihibHRfZm4s ICZ0aHJlYWRbaV0sICJpZ3QvYmx0LSVkIiwgaSk7Ci0JCWlmIChJU19FUlIodHNrW2ldKSkgewot CQkJZXJyID0gUFRSX0VSUih0c2tbaV0pOwotCQkJYnJlYWs7Ci0JCX0KLQotCQlnZXRfdGFza19z dHJ1Y3QodHNrW2ldKTsKLQl9Ci0KLQl5aWVsZCgpOyAvKiBzdGFydCBhbGwgdGhyZWFkcyBiZWZv cmUgd2Uga3RocmVhZF9zdG9wKCkgKi8KLQotCWZvciAoaSA9IDA7IGkgPCBuX2NwdXM7ICsraSkg ewotCQlpbnQgc3RhdHVzOwotCi0JCWlmIChJU19FUlJfT1JfTlVMTCh0c2tbaV0pKQotCQkJY29u dGludWU7Ci0KLQkJc3RhdHVzID0ga3RocmVhZF9zdG9wKHRza1tpXSk7Ci0JCWlmIChzdGF0dXMg JiYgIWVycikKLQkJCWVyciA9IHN0YXR1czsKLQotCQlwdXRfdGFza19zdHJ1Y3QodHNrW2ldKTsK LQl9Ci0KLW91dF9maWxlOgotCWZwdXQodGhyZWFkWzBdLmZpbGUpOwotb3V0X3RocmVhZDoKLQlr ZnJlZSh0aHJlYWQpOwotb3V0X3RzazoKLQlrZnJlZSh0c2spOwotCXJldHVybiBlcnI7Ci19Ci0K LXN0YXRpYyBpbnQgdGVzdF9jb3B5X2VuZ2luZXMoc3RydWN0IGRybV9pOTE1X3ByaXZhdGUgKmk5 MTUsCi0JCQkgICAgIGludCAoKmZuKSh2b2lkICphcmcpLAotCQkJICAgICB1bnNpZ25lZCBpbnQg ZmxhZ3MpCi17Ci0Jc3RydWN0IGludGVsX2VuZ2luZV9jcyAqZW5naW5lOwotCWludCByZXQ7Ci0K LQlmb3JfZWFjaF91YWJpX2NsYXNzX2VuZ2luZShlbmdpbmUsIEk5MTVfRU5HSU5FX0NMQVNTX0NP UFksIGk5MTUpIHsKLQkJcmV0ID0gaWd0X3RocmVhZGVkX2JsdChlbmdpbmUsIGZuLCBmbGFncyk7 Ci0JCWlmIChyZXQpCi0JCQlyZXR1cm4gcmV0OwotCX0KLQotCXJldHVybiAwOwotfQotCi1zdGF0 aWMgaW50IGlndF9maWxsX2JsdCh2b2lkICphcmcpCi17Ci0JcmV0dXJuIHRlc3RfY29weV9lbmdp bmVzKGFyZywgaWd0X2ZpbGxfYmx0X3RocmVhZCwgMCk7Ci19Ci0KLXN0YXRpYyBpbnQgaWd0X2Zp bGxfYmx0X2N0eDAodm9pZCAqYXJnKQotewotCXJldHVybiB0ZXN0X2NvcHlfZW5naW5lcyhhcmcs IGlndF9maWxsX2JsdF90aHJlYWQsIFNJTkdMRV9DVFgpOwotfQotCi1zdGF0aWMgaW50IGlndF9j b3B5X2JsdCh2b2lkICphcmcpCi17Ci0JcmV0dXJuIHRlc3RfY29weV9lbmdpbmVzKGFyZywgaWd0 X2NvcHlfYmx0X3RocmVhZCwgMCk7Ci19Ci0KLXN0YXRpYyBpbnQgaWd0X2NvcHlfYmx0X2N0eDAo dm9pZCAqYXJnKQotewotCXJldHVybiB0ZXN0X2NvcHlfZW5naW5lcyhhcmcsIGlndF9jb3B5X2Js dF90aHJlYWQsIFNJTkdMRV9DVFgpOwotfQotCi1pbnQgaTkxNV9nZW1fb2JqZWN0X2JsdF9saXZl X3NlbGZ0ZXN0cyhzdHJ1Y3QgZHJtX2k5MTVfcHJpdmF0ZSAqaTkxNSkKLXsKLQlzdGF0aWMgY29u c3Qgc3RydWN0IGk5MTVfc3VidGVzdCB0ZXN0c1tdID0gewotCQlTVUJURVNUKGlndF9maWxsX2Js dCksCi0JCVNVQlRFU1QoaWd0X2ZpbGxfYmx0X2N0eDApLAotCQlTVUJURVNUKGlndF9jb3B5X2Js dCksCi0JCVNVQlRFU1QoaWd0X2NvcHlfYmx0X2N0eDApLAotCX07Ci0KLQlpZiAoaW50ZWxfZ3Rf aXNfd2VkZ2VkKCZpOTE1LT5ndCkpCi0JCXJldHVybiAwOwotCi0JcmV0dXJuIGk5MTVfbGl2ZV9z dWJ0ZXN0cyh0ZXN0cywgaTkxNSk7Ci19Ci0KLWludCBpOTE1X2dlbV9vYmplY3RfYmx0X3BlcmZf c2VsZnRlc3RzKHN0cnVjdCBkcm1faTkxNV9wcml2YXRlICppOTE1KQotewotCXN0YXRpYyBjb25z dCBzdHJ1Y3QgaTkxNV9zdWJ0ZXN0IHRlc3RzW10gPSB7Ci0JCVNVQlRFU1QocGVyZl9maWxsX2Js dCksCi0JCVNVQlRFU1QocGVyZl9jb3B5X2JsdCksCi0JfTsKLQotCWlmIChpbnRlbF9ndF9pc193 ZWRnZWQoJmk5MTUtPmd0KSkKLQkJcmV0dXJuIDA7Ci0KLQlyZXR1cm4gaTkxNV9saXZlX3N1YnRl c3RzKHRlc3RzLCBpOTE1KTsKLX0KZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2RybS9pOTE1L3Nl bGZ0ZXN0cy9pOTE1X2xpdmVfc2VsZnRlc3RzLmggYi9kcml2ZXJzL2dwdS9kcm0vaTkxNS9zZWxm dGVzdHMvaTkxNV9saXZlX3NlbGZ0ZXN0cy5oCmluZGV4IGJlNWUwMTkxZWFlYS4uYTY4MTk3Y2Yx MDQ0IDEwMDY0NAotLS0gYS9kcml2ZXJzL2dwdS9kcm0vaTkxNS9zZWxmdGVzdHMvaTkxNV9saXZl X3NlbGZ0ZXN0cy5oCisrKyBiL2RyaXZlcnMvZ3B1L2RybS9pOTE1L3NlbGZ0ZXN0cy9pOTE1X2xp dmVfc2VsZnRlc3RzLmgKQEAgLTM5LDcgKzM5LDYgQEAgc2VsZnRlc3QoZXZpY3QsIGk5MTVfZ2Vt X2V2aWN0X2xpdmVfc2VsZnRlc3RzKQogc2VsZnRlc3QoaHVnZXBhZ2VzLCBpOTE1X2dlbV9odWdl X3BhZ2VfbGl2ZV9zZWxmdGVzdHMpCiBzZWxmdGVzdChnZW1fY29udGV4dHMsIGk5MTVfZ2VtX2Nv bnRleHRfbGl2ZV9zZWxmdGVzdHMpCiBzZWxmdGVzdChnZW1fZXhlY2J1ZiwgaTkxNV9nZW1fZXhl Y2J1ZmZlcl9saXZlX3NlbGZ0ZXN0cykKLXNlbGZ0ZXN0KGJsdCwgaTkxNV9nZW1fb2JqZWN0X2Js dF9saXZlX3NlbGZ0ZXN0cykKIHNlbGZ0ZXN0KGNsaWVudCwgaTkxNV9nZW1fY2xpZW50X2JsdF9s aXZlX3NlbGZ0ZXN0cykKIHNlbGZ0ZXN0KHJlc2V0LCBpbnRlbF9yZXNldF9saXZlX3NlbGZ0ZXN0 cykKIHNlbGZ0ZXN0KG1lbW9yeV9yZWdpb24sIGludGVsX21lbW9yeV9yZWdpb25fbGl2ZV9zZWxm dGVzdHMpCmRpZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9kcm0vaTkxNS9zZWxmdGVzdHMvaTkxNV9w ZXJmX3NlbGZ0ZXN0cy5oIGIvZHJpdmVycy9ncHUvZHJtL2k5MTUvc2VsZnRlc3RzL2k5MTVfcGVy Zl9zZWxmdGVzdHMuaAppbmRleCA1MDc3ZGMzYzNiOGMuLjA1ODQ1MGQzNTFmNyAxMDA2NDQKLS0t IGEvZHJpdmVycy9ncHUvZHJtL2k5MTUvc2VsZnRlc3RzL2k5MTVfcGVyZl9zZWxmdGVzdHMuaAor KysgYi9kcml2ZXJzL2dwdS9kcm0vaTkxNS9zZWxmdGVzdHMvaTkxNV9wZXJmX3NlbGZ0ZXN0cy5o CkBAIC0xOCw1ICsxOCw0IEBACiBzZWxmdGVzdChlbmdpbmVfY3MsIGludGVsX2VuZ2luZV9jc19w ZXJmX3NlbGZ0ZXN0cykKIHNlbGZ0ZXN0KHJlcXVlc3QsIGk5MTVfcmVxdWVzdF9wZXJmX3NlbGZ0 ZXN0cykKIHNlbGZ0ZXN0KG1pZ3JhdGUsIGludGVsX21pZ3JhdGVfcGVyZl9zZWxmdGVzdHMpCi1z ZWxmdGVzdChibHQsIGk5MTVfZ2VtX29iamVjdF9ibHRfcGVyZl9zZWxmdGVzdHMpCiBzZWxmdGVz dChyZWdpb24sIGludGVsX21lbW9yeV9yZWdpb25fcGVyZl9zZWxmdGVzdHMpCmRpZmYgLS1naXQg YS9kcml2ZXJzL2dwdS9kcm0vaTkxNS9zZWxmdGVzdHMvaW50ZWxfbWVtb3J5X3JlZ2lvbi5jIGIv ZHJpdmVycy9ncHUvZHJtL2k5MTUvc2VsZnRlc3RzL2ludGVsX21lbW9yeV9yZWdpb24uYwppbmRl eCAxMThhNjZjMjk2OTUuLmVjYzNiOWU2YzIyYiAxMDA2NDQKLS0tIGEvZHJpdmVycy9ncHUvZHJt L2k5MTUvc2VsZnRlc3RzL2ludGVsX21lbW9yeV9yZWdpb24uYworKysgYi9kcml2ZXJzL2dwdS9k cm0vaTkxNS9zZWxmdGVzdHMvaW50ZWxfbWVtb3J5X3JlZ2lvbi5jCkBAIC0xNSwxMiArMTUsMTMg QEAKICNpbmNsdWRlICJnZW0vaTkxNV9nZW1fY29udGV4dC5oIgogI2luY2x1ZGUgImdlbS9pOTE1 X2dlbV9sbWVtLmgiCiAjaW5jbHVkZSAiZ2VtL2k5MTVfZ2VtX3JlZ2lvbi5oIgotI2luY2x1ZGUg ImdlbS9pOTE1X2dlbV9vYmplY3RfYmx0LmgiCiAjaW5jbHVkZSAiZ2VtL3NlbGZ0ZXN0cy9pZ3Rf Z2VtX3V0aWxzLmgiCiAjaW5jbHVkZSAiZ2VtL3NlbGZ0ZXN0cy9tb2NrX2NvbnRleHQuaCIKKyNp bmNsdWRlICJndC9pbnRlbF9lbmdpbmVfcG0uaCIKICNpbmNsdWRlICJndC9pbnRlbF9lbmdpbmVf dXNlci5oIgogI2luY2x1ZGUgImd0L2ludGVsX2d0LmgiCiAjaW5jbHVkZSAiaTkxNV9idWRkeS5o IgorI2luY2x1ZGUgImd0L2ludGVsX21pZ3JhdGUuaCIKICNpbmNsdWRlICJpOTE1X21lbWNweS5o IgogI2luY2x1ZGUgImk5MTVfdHRtX2J1ZGR5X21hbmFnZXIuaCIKICNpbmNsdWRlICJzZWxmdGVz dHMvaWd0X2ZsdXNoX3Rlc3QuaCIKQEAgLTgwOCw2ICs4MDksNyBAQCBzdGF0aWMgaW50IGlndF9s bWVtX3dyaXRlX2NwdSh2b2lkICphcmcpCiAJCVBBR0VfU0laRSAtIDY0LAogCX07CiAJc3RydWN0 IGludGVsX2VuZ2luZV9jcyAqZW5naW5lOworCXN0cnVjdCBpOTE1X3JlcXVlc3QgKnJxOwogCXUz MiAqdmFkZHI7CiAJdTMyIHN6OwogCXUzMiBpOwpAQCAtODM0LDE1ICs4MzYsMjAgQEAgc3RhdGlj IGludCBpZ3RfbG1lbV93cml0ZV9jcHUodm9pZCAqYXJnKQogCQlnb3RvIG91dF9wdXQ7CiAJfQog CisJaTkxNV9nZW1fb2JqZWN0X2xvY2sob2JqLCBOVUxMKTsKIAkvKiBQdXQgdGhlIHBhZ2VzIGlu dG8gYSBrbm93biBzdGF0ZSAtLSBmcm9tIHRoZSBncHUgZm9yIGFkZGVkIGZ1biAqLwogCWludGVs X2VuZ2luZV9wbV9nZXQoZW5naW5lKTsKLQllcnIgPSBpOTE1X2dlbV9vYmplY3RfZmlsbF9ibHQo b2JqLCBlbmdpbmUtPmtlcm5lbF9jb250ZXh0LCAweGRlYWRiZWFmKTsKLQlpbnRlbF9lbmdpbmVf cG1fcHV0KGVuZ2luZSk7Ci0JaWYgKGVycikKLQkJZ290byBvdXRfdW5waW47CisJZXJyID0gaW50 ZWxfY29udGV4dF9taWdyYXRlX2NsZWFyKGVuZ2luZS0+Z3QtPm1pZ3JhdGUuY29udGV4dCwgTlVM TCwKKwkJCQkJICBvYmotPm1tLnBhZ2VzLT5zZ2wsIEk5MTVfQ0FDSEVfTk9ORSwKKwkJCQkJICB0 cnVlLCAweGRlYWRiZWFmLCAmcnEpOworCWlmIChycSkgeworCQlkbWFfcmVzdl9hZGRfZXhjbF9m ZW5jZShvYmotPmJhc2UucmVzdiwgJnJxLT5mZW5jZSk7CisJCWk5MTVfcmVxdWVzdF9wdXQocnEp OworCX0KIAotCWk5MTVfZ2VtX29iamVjdF9sb2NrKG9iaiwgTlVMTCk7Ci0JZXJyID0gaTkxNV9n ZW1fb2JqZWN0X3NldF90b193Y19kb21haW4ob2JqLCB0cnVlKTsKKwlpbnRlbF9lbmdpbmVfcG1f cHV0KGVuZ2luZSk7CisJaWYgKCFlcnIpCisJCWVyciA9IGk5MTVfZ2VtX29iamVjdF9zZXRfdG9f d2NfZG9tYWluKG9iaiwgdHJ1ZSk7CiAJaTkxNV9nZW1fb2JqZWN0X3VubG9jayhvYmopOwogCWlm IChlcnIpCiAJCWdvdG8gb3V0X3VucGluOwotLSAKMi4zMS4xCgpfX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fXwpJbnRlbC1nZnggbWFpbGluZyBsaXN0CkludGVs LWdmeEBsaXN0cy5mcmVlZGVza3RvcC5vcmcKaHR0cHM6Ly9saXN0cy5mcmVlZGVza3RvcC5vcmcv bWFpbG1hbi9saXN0aW5mby9pbnRlbC1nZngK From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org X-Spam-Level: X-Spam-Status: No, score=-16.8 required=3.0 tests=BAYES_00, HEADER_FROM_DIFFERENT_DOMAINS,INCLUDES_CR_TRAILER,INCLUDES_PATCH, MAILING_LIST_MULTI,SPF_HELO_NONE,SPF_PASS,USER_AGENT_GIT autolearn=ham autolearn_force=no version=3.4.0 Received: from mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id 3291CC49361 for ; Thu, 17 Jun 2021 06:31:13 +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 037B2613E7 for ; Thu, 17 Jun 2021 06:31:13 +0000 (UTC) DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org 037B2613E7 Authentication-Results: mail.kernel.org; dmarc=fail (p=none dis=none) header.from=linux.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 6D1FD6E88A; Thu, 17 Jun 2021 06:31:04 +0000 (UTC) Received: from mga11.intel.com (mga11.intel.com [192.55.52.93]) by gabe.freedesktop.org (Postfix) with ESMTPS id 45A546E887; Thu, 17 Jun 2021 06:30:56 +0000 (UTC) IronPort-SDR: jB20jkkAUT1eHB/BfGmfCCvGEfwcNO2RK4qBkIIfZfjdoTjfgQFczLWh72ElfY7P+DSWrCMZHO GvNuIFky6p2w== X-IronPort-AV: E=McAfee;i="6200,9189,10017"; a="203287865" X-IronPort-AV: E=Sophos;i="5.83,278,1616482800"; d="scan'208";a="203287865" Received: from orsmga004.jf.intel.com ([10.7.209.38]) by fmsmga102.fm.intel.com with ESMTP/TLS/ECDHE-RSA-AES256-GCM-SHA384; 16 Jun 2021 23:30:55 -0700 IronPort-SDR: /KrcR/QFH3cGPXi8e3QBHrHvtTlZIwcHoylCmPGFo79gurOU6t+Eb6cj9r2v7tF5L67IEcLhst U4foInYfvqnQ== X-IronPort-AV: E=Sophos;i="5.83,278,1616482800"; d="scan'208";a="554302764" Received: from vanderss-mobl.ger.corp.intel.com (HELO thellst-mobl1.intel.com) ([10.249.254.193]) by orsmga004-auth.jf.intel.com with ESMTP/TLS/ECDHE-RSA-AES256-GCM-SHA384; 16 Jun 2021 23:30:54 -0700 From: =?UTF-8?q?Thomas=20Hellstr=C3=B6m?= To: intel-gfx@lists.freedesktop.org, dri-devel@lists.freedesktop.org Subject: [PATCH v5 12/12] drm/i915/gem: Zap the i915_gem_object_blt code Date: Thu, 17 Jun 2021 08:30:18 +0200 Message-Id: <20210617063018.92802-13-thomas.hellstrom@linux.intel.com> X-Mailer: git-send-email 2.31.1 In-Reply-To: <20210617063018.92802-1-thomas.hellstrom@linux.intel.com> References: <20210617063018.92802-1-thomas.hellstrom@linux.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: , Cc: =?UTF-8?q?Thomas=20Hellstr=C3=B6m?= , matthew.auld@intel.com Errors-To: dri-devel-bounces@lists.freedesktop.org Sender: "dri-devel" It's unused with the exception of selftest. Replace a call in the memory_region live selftest with a call into a corresponding function in the new migrate code. Signed-off-by: Thomas Hellström Reviewed-by: Matthew Auld --- drivers/gpu/drm/i915/Makefile | 1 - .../gpu/drm/i915/gem/i915_gem_object_blt.c | 461 -------------- .../gpu/drm/i915/gem/i915_gem_object_blt.h | 39 -- .../i915/gem/selftests/i915_gem_object_blt.c | 597 ------------------ .../drm/i915/selftests/i915_live_selftests.h | 1 - .../drm/i915/selftests/i915_perf_selftests.h | 1 - .../drm/i915/selftests/intel_memory_region.c | 21 +- 7 files changed, 14 insertions(+), 1107 deletions(-) delete mode 100644 drivers/gpu/drm/i915/gem/i915_gem_object_blt.c delete mode 100644 drivers/gpu/drm/i915/gem/i915_gem_object_blt.h delete mode 100644 drivers/gpu/drm/i915/gem/selftests/i915_gem_object_blt.c diff --git a/drivers/gpu/drm/i915/Makefile b/drivers/gpu/drm/i915/Makefile index ffa14084432c..01f28ad5ea57 100644 --- a/drivers/gpu/drm/i915/Makefile +++ b/drivers/gpu/drm/i915/Makefile @@ -143,7 +143,6 @@ gem-y += \ gem/i915_gem_execbuffer.o \ gem/i915_gem_internal.o \ gem/i915_gem_object.o \ - gem/i915_gem_object_blt.o \ gem/i915_gem_lmem.o \ gem/i915_gem_mman.o \ gem/i915_gem_pages.o \ diff --git a/drivers/gpu/drm/i915/gem/i915_gem_object_blt.c b/drivers/gpu/drm/i915/gem/i915_gem_object_blt.c deleted file mode 100644 index 3e28c68fda3e..000000000000 --- a/drivers/gpu/drm/i915/gem/i915_gem_object_blt.c +++ /dev/null @@ -1,461 +0,0 @@ -// SPDX-License-Identifier: MIT -/* - * Copyright © 2019 Intel Corporation - */ - -#include "i915_drv.h" -#include "gt/intel_context.h" -#include "gt/intel_engine_pm.h" -#include "gt/intel_gpu_commands.h" -#include "gt/intel_gt.h" -#include "gt/intel_gt_buffer_pool.h" -#include "gt/intel_ring.h" -#include "i915_gem_clflush.h" -#include "i915_gem_object_blt.h" - -struct i915_vma *intel_emit_vma_fill_blt(struct intel_context *ce, - struct i915_vma *vma, - struct i915_gem_ww_ctx *ww, - u32 value) -{ - struct drm_i915_private *i915 = ce->vm->i915; - const u32 block_size = SZ_8M; /* ~1ms at 8GiB/s preemption delay */ - struct intel_gt_buffer_pool_node *pool; - struct i915_vma *batch; - u64 offset; - u64 count; - u64 rem; - u32 size; - u32 *cmd; - int err; - - GEM_BUG_ON(intel_engine_is_virtual(ce->engine)); - intel_engine_pm_get(ce->engine); - - count = div_u64(round_up(vma->size, block_size), block_size); - size = (1 + 8 * count) * sizeof(u32); - size = round_up(size, PAGE_SIZE); - pool = intel_gt_get_buffer_pool(ce->engine->gt, size, I915_MAP_WC); - if (IS_ERR(pool)) { - err = PTR_ERR(pool); - goto out_pm; - } - - err = i915_gem_object_lock(pool->obj, ww); - if (err) - goto out_put; - - batch = i915_vma_instance(pool->obj, ce->vm, NULL); - if (IS_ERR(batch)) { - err = PTR_ERR(batch); - goto out_put; - } - - err = i915_vma_pin_ww(batch, ww, 0, 0, PIN_USER); - if (unlikely(err)) - goto out_put; - - /* we pinned the pool, mark it as such */ - intel_gt_buffer_pool_mark_used(pool); - - cmd = i915_gem_object_pin_map(pool->obj, pool->type); - if (IS_ERR(cmd)) { - err = PTR_ERR(cmd); - goto out_unpin; - } - - rem = vma->size; - offset = vma->node.start; - - do { - u32 size = min_t(u64, rem, block_size); - - GEM_BUG_ON(size >> PAGE_SHIFT > S16_MAX); - - if (GRAPHICS_VER(i915) >= 8) { - *cmd++ = XY_COLOR_BLT_CMD | BLT_WRITE_RGBA | (7 - 2); - *cmd++ = BLT_DEPTH_32 | BLT_ROP_COLOR_COPY | PAGE_SIZE; - *cmd++ = 0; - *cmd++ = size >> PAGE_SHIFT << 16 | PAGE_SIZE / 4; - *cmd++ = lower_32_bits(offset); - *cmd++ = upper_32_bits(offset); - *cmd++ = value; - } else { - *cmd++ = XY_COLOR_BLT_CMD | BLT_WRITE_RGBA | (6 - 2); - *cmd++ = BLT_DEPTH_32 | BLT_ROP_COLOR_COPY | PAGE_SIZE; - *cmd++ = 0; - *cmd++ = size >> PAGE_SHIFT << 16 | PAGE_SIZE / 4; - *cmd++ = offset; - *cmd++ = value; - } - - /* Allow ourselves to be preempted in between blocks. */ - *cmd++ = MI_ARB_CHECK; - - offset += size; - rem -= size; - } while (rem); - - *cmd = MI_BATCH_BUFFER_END; - - i915_gem_object_flush_map(pool->obj); - i915_gem_object_unpin_map(pool->obj); - - intel_gt_chipset_flush(ce->vm->gt); - - batch->private = pool; - return batch; - -out_unpin: - i915_vma_unpin(batch); -out_put: - intel_gt_buffer_pool_put(pool); -out_pm: - intel_engine_pm_put(ce->engine); - return ERR_PTR(err); -} - -int intel_emit_vma_mark_active(struct i915_vma *vma, struct i915_request *rq) -{ - int err; - - err = i915_request_await_object(rq, vma->obj, false); - if (err == 0) - err = i915_vma_move_to_active(vma, rq, 0); - if (unlikely(err)) - return err; - - return intel_gt_buffer_pool_mark_active(vma->private, rq); -} - -void intel_emit_vma_release(struct intel_context *ce, struct i915_vma *vma) -{ - i915_vma_unpin(vma); - intel_gt_buffer_pool_put(vma->private); - intel_engine_pm_put(ce->engine); -} - -static int -move_obj_to_gpu(struct drm_i915_gem_object *obj, - struct i915_request *rq, - bool write) -{ - if (obj->cache_dirty & ~obj->cache_coherent) - i915_gem_clflush_object(obj, 0); - - return i915_request_await_object(rq, obj, write); -} - -int i915_gem_object_fill_blt(struct drm_i915_gem_object *obj, - struct intel_context *ce, - u32 value) -{ - struct i915_gem_ww_ctx ww; - struct i915_request *rq; - struct i915_vma *batch; - struct i915_vma *vma; - int err; - - vma = i915_vma_instance(obj, ce->vm, NULL); - if (IS_ERR(vma)) - return PTR_ERR(vma); - - i915_gem_ww_ctx_init(&ww, true); - intel_engine_pm_get(ce->engine); -retry: - err = i915_gem_object_lock(obj, &ww); - if (err) - goto out; - - err = intel_context_pin_ww(ce, &ww); - if (err) - goto out; - - err = i915_vma_pin_ww(vma, &ww, 0, 0, PIN_USER); - if (err) - goto out_ctx; - - batch = intel_emit_vma_fill_blt(ce, vma, &ww, value); - if (IS_ERR(batch)) { - err = PTR_ERR(batch); - goto out_vma; - } - - rq = i915_request_create(ce); - if (IS_ERR(rq)) { - err = PTR_ERR(rq); - goto out_batch; - } - - err = intel_emit_vma_mark_active(batch, rq); - if (unlikely(err)) - goto out_request; - - err = move_obj_to_gpu(vma->obj, rq, true); - if (err == 0) - err = i915_vma_move_to_active(vma, rq, EXEC_OBJECT_WRITE); - if (unlikely(err)) - goto out_request; - - if (ce->engine->emit_init_breadcrumb) - err = ce->engine->emit_init_breadcrumb(rq); - - if (likely(!err)) - err = ce->engine->emit_bb_start(rq, - batch->node.start, - batch->node.size, - 0); -out_request: - if (unlikely(err)) - i915_request_set_error_once(rq, err); - - i915_request_add(rq); -out_batch: - intel_emit_vma_release(ce, batch); -out_vma: - i915_vma_unpin(vma); -out_ctx: - intel_context_unpin(ce); -out: - if (err == -EDEADLK) { - err = i915_gem_ww_ctx_backoff(&ww); - if (!err) - goto retry; - } - i915_gem_ww_ctx_fini(&ww); - intel_engine_pm_put(ce->engine); - return err; -} - -/* Wa_1209644611:icl,ehl */ -static bool wa_1209644611_applies(struct drm_i915_private *i915, u32 size) -{ - u32 height = size >> PAGE_SHIFT; - - if (GRAPHICS_VER(i915) != 11) - return false; - - return height % 4 == 3 && height <= 8; -} - -struct i915_vma *intel_emit_vma_copy_blt(struct intel_context *ce, - struct i915_gem_ww_ctx *ww, - struct i915_vma *src, - struct i915_vma *dst) -{ - struct drm_i915_private *i915 = ce->vm->i915; - const u32 block_size = SZ_8M; /* ~1ms at 8GiB/s preemption delay */ - struct intel_gt_buffer_pool_node *pool; - struct i915_vma *batch; - u64 src_offset, dst_offset; - u64 count, rem; - u32 size, *cmd; - int err; - - GEM_BUG_ON(src->size != dst->size); - - GEM_BUG_ON(intel_engine_is_virtual(ce->engine)); - intel_engine_pm_get(ce->engine); - - count = div_u64(round_up(dst->size, block_size), block_size); - size = (1 + 11 * count) * sizeof(u32); - size = round_up(size, PAGE_SIZE); - pool = intel_gt_get_buffer_pool(ce->engine->gt, size, I915_MAP_WC); - if (IS_ERR(pool)) { - err = PTR_ERR(pool); - goto out_pm; - } - - err = i915_gem_object_lock(pool->obj, ww); - if (err) - goto out_put; - - batch = i915_vma_instance(pool->obj, ce->vm, NULL); - if (IS_ERR(batch)) { - err = PTR_ERR(batch); - goto out_put; - } - - err = i915_vma_pin_ww(batch, ww, 0, 0, PIN_USER); - if (unlikely(err)) - goto out_put; - - /* we pinned the pool, mark it as such */ - intel_gt_buffer_pool_mark_used(pool); - - cmd = i915_gem_object_pin_map(pool->obj, pool->type); - if (IS_ERR(cmd)) { - err = PTR_ERR(cmd); - goto out_unpin; - } - - rem = src->size; - src_offset = src->node.start; - dst_offset = dst->node.start; - - do { - size = min_t(u64, rem, block_size); - GEM_BUG_ON(size >> PAGE_SHIFT > S16_MAX); - - if (GRAPHICS_VER(i915) >= 9 && - !wa_1209644611_applies(i915, size)) { - *cmd++ = GEN9_XY_FAST_COPY_BLT_CMD | (10 - 2); - *cmd++ = BLT_DEPTH_32 | PAGE_SIZE; - *cmd++ = 0; - *cmd++ = size >> PAGE_SHIFT << 16 | PAGE_SIZE / 4; - *cmd++ = lower_32_bits(dst_offset); - *cmd++ = upper_32_bits(dst_offset); - *cmd++ = 0; - *cmd++ = PAGE_SIZE; - *cmd++ = lower_32_bits(src_offset); - *cmd++ = upper_32_bits(src_offset); - } else if (GRAPHICS_VER(i915) >= 8) { - *cmd++ = XY_SRC_COPY_BLT_CMD | BLT_WRITE_RGBA | (10 - 2); - *cmd++ = BLT_DEPTH_32 | BLT_ROP_SRC_COPY | PAGE_SIZE; - *cmd++ = 0; - *cmd++ = size >> PAGE_SHIFT << 16 | PAGE_SIZE / 4; - *cmd++ = lower_32_bits(dst_offset); - *cmd++ = upper_32_bits(dst_offset); - *cmd++ = 0; - *cmd++ = PAGE_SIZE; - *cmd++ = lower_32_bits(src_offset); - *cmd++ = upper_32_bits(src_offset); - } else { - *cmd++ = SRC_COPY_BLT_CMD | BLT_WRITE_RGBA | (6 - 2); - *cmd++ = BLT_DEPTH_32 | BLT_ROP_SRC_COPY | PAGE_SIZE; - *cmd++ = size >> PAGE_SHIFT << 16 | PAGE_SIZE; - *cmd++ = dst_offset; - *cmd++ = PAGE_SIZE; - *cmd++ = src_offset; - } - - /* Allow ourselves to be preempted in between blocks. */ - *cmd++ = MI_ARB_CHECK; - - src_offset += size; - dst_offset += size; - rem -= size; - } while (rem); - - *cmd = MI_BATCH_BUFFER_END; - - i915_gem_object_flush_map(pool->obj); - i915_gem_object_unpin_map(pool->obj); - - intel_gt_chipset_flush(ce->vm->gt); - batch->private = pool; - return batch; - -out_unpin: - i915_vma_unpin(batch); -out_put: - intel_gt_buffer_pool_put(pool); -out_pm: - intel_engine_pm_put(ce->engine); - return ERR_PTR(err); -} - -int i915_gem_object_copy_blt(struct drm_i915_gem_object *src, - struct drm_i915_gem_object *dst, - struct intel_context *ce) -{ - struct i915_address_space *vm = ce->vm; - struct i915_vma *vma[2], *batch; - struct i915_gem_ww_ctx ww; - struct i915_request *rq; - int err, i; - - vma[0] = i915_vma_instance(src, vm, NULL); - if (IS_ERR(vma[0])) - return PTR_ERR(vma[0]); - - vma[1] = i915_vma_instance(dst, vm, NULL); - if (IS_ERR(vma[1])) - return PTR_ERR(vma[1]); - - i915_gem_ww_ctx_init(&ww, true); - intel_engine_pm_get(ce->engine); -retry: - err = i915_gem_object_lock(src, &ww); - if (!err) - err = i915_gem_object_lock(dst, &ww); - if (!err) - err = intel_context_pin_ww(ce, &ww); - if (err) - goto out; - - err = i915_vma_pin_ww(vma[0], &ww, 0, 0, PIN_USER); - if (err) - goto out_ctx; - - err = i915_vma_pin_ww(vma[1], &ww, 0, 0, PIN_USER); - if (unlikely(err)) - goto out_unpin_src; - - batch = intel_emit_vma_copy_blt(ce, &ww, vma[0], vma[1]); - if (IS_ERR(batch)) { - err = PTR_ERR(batch); - goto out_unpin_dst; - } - - rq = i915_request_create(ce); - if (IS_ERR(rq)) { - err = PTR_ERR(rq); - goto out_batch; - } - - err = intel_emit_vma_mark_active(batch, rq); - if (unlikely(err)) - goto out_request; - - for (i = 0; i < ARRAY_SIZE(vma); i++) { - err = move_obj_to_gpu(vma[i]->obj, rq, i); - if (unlikely(err)) - goto out_request; - } - - for (i = 0; i < ARRAY_SIZE(vma); i++) { - unsigned int flags = i ? EXEC_OBJECT_WRITE : 0; - - err = i915_vma_move_to_active(vma[i], rq, flags); - if (unlikely(err)) - goto out_request; - } - - if (rq->engine->emit_init_breadcrumb) { - err = rq->engine->emit_init_breadcrumb(rq); - if (unlikely(err)) - goto out_request; - } - - err = rq->engine->emit_bb_start(rq, - batch->node.start, batch->node.size, - 0); - -out_request: - if (unlikely(err)) - i915_request_set_error_once(rq, err); - - i915_request_add(rq); -out_batch: - intel_emit_vma_release(ce, batch); -out_unpin_dst: - i915_vma_unpin(vma[1]); -out_unpin_src: - i915_vma_unpin(vma[0]); -out_ctx: - intel_context_unpin(ce); -out: - if (err == -EDEADLK) { - err = i915_gem_ww_ctx_backoff(&ww); - if (!err) - goto retry; - } - i915_gem_ww_ctx_fini(&ww); - intel_engine_pm_put(ce->engine); - return err; -} - -#if IS_ENABLED(CONFIG_DRM_I915_SELFTEST) -#include "selftests/i915_gem_object_blt.c" -#endif diff --git a/drivers/gpu/drm/i915/gem/i915_gem_object_blt.h b/drivers/gpu/drm/i915/gem/i915_gem_object_blt.h deleted file mode 100644 index 2409fdcccf0e..000000000000 --- a/drivers/gpu/drm/i915/gem/i915_gem_object_blt.h +++ /dev/null @@ -1,39 +0,0 @@ -/* SPDX-License-Identifier: MIT */ -/* - * Copyright © 2019 Intel Corporation - */ - -#ifndef __I915_GEM_OBJECT_BLT_H__ -#define __I915_GEM_OBJECT_BLT_H__ - -#include - -#include "gt/intel_context.h" -#include "gt/intel_engine_pm.h" -#include "i915_vma.h" - -struct drm_i915_gem_object; -struct i915_gem_ww_ctx; - -struct i915_vma *intel_emit_vma_fill_blt(struct intel_context *ce, - struct i915_vma *vma, - struct i915_gem_ww_ctx *ww, - u32 value); - -struct i915_vma *intel_emit_vma_copy_blt(struct intel_context *ce, - struct i915_gem_ww_ctx *ww, - struct i915_vma *src, - struct i915_vma *dst); - -int intel_emit_vma_mark_active(struct i915_vma *vma, struct i915_request *rq); -void intel_emit_vma_release(struct intel_context *ce, struct i915_vma *vma); - -int i915_gem_object_fill_blt(struct drm_i915_gem_object *obj, - struct intel_context *ce, - u32 value); - -int i915_gem_object_copy_blt(struct drm_i915_gem_object *src, - struct drm_i915_gem_object *dst, - struct intel_context *ce); - -#endif diff --git a/drivers/gpu/drm/i915/gem/selftests/i915_gem_object_blt.c b/drivers/gpu/drm/i915/gem/selftests/i915_gem_object_blt.c deleted file mode 100644 index 8c335d1a8406..000000000000 --- a/drivers/gpu/drm/i915/gem/selftests/i915_gem_object_blt.c +++ /dev/null @@ -1,597 +0,0 @@ -// SPDX-License-Identifier: MIT -/* - * Copyright © 2019 Intel Corporation - */ - -#include - -#include "gt/intel_gt.h" -#include "gt/intel_engine_user.h" - -#include "i915_selftest.h" - -#include "gem/i915_gem_context.h" -#include "selftests/igt_flush_test.h" -#include "selftests/i915_random.h" -#include "selftests/mock_drm.h" -#include "huge_gem_object.h" -#include "mock_context.h" - -static int wrap_ktime_compare(const void *A, const void *B) -{ - const ktime_t *a = A, *b = B; - - return ktime_compare(*a, *b); -} - -static int __perf_fill_blt(struct drm_i915_gem_object *obj) -{ - struct drm_i915_private *i915 = to_i915(obj->base.dev); - int inst = 0; - - do { - struct intel_engine_cs *engine; - ktime_t t[5]; - int pass; - int err; - - engine = intel_engine_lookup_user(i915, - I915_ENGINE_CLASS_COPY, - inst++); - if (!engine) - return 0; - - intel_engine_pm_get(engine); - for (pass = 0; pass < ARRAY_SIZE(t); pass++) { - struct intel_context *ce = engine->kernel_context; - ktime_t t0, t1; - - t0 = ktime_get(); - - err = i915_gem_object_fill_blt(obj, ce, 0); - if (err) - break; - - err = i915_gem_object_wait(obj, - I915_WAIT_ALL, - MAX_SCHEDULE_TIMEOUT); - if (err) - break; - - t1 = ktime_get(); - t[pass] = ktime_sub(t1, t0); - } - intel_engine_pm_put(engine); - if (err) - return err; - - sort(t, ARRAY_SIZE(t), sizeof(*t), wrap_ktime_compare, NULL); - pr_info("%s: blt %zd KiB fill: %lld MiB/s\n", - engine->name, - obj->base.size >> 10, - div64_u64(mul_u32_u32(4 * obj->base.size, - 1000 * 1000 * 1000), - t[1] + 2 * t[2] + t[3]) >> 20); - } while (1); -} - -static int perf_fill_blt(void *arg) -{ - struct drm_i915_private *i915 = arg; - static const unsigned long sizes[] = { - SZ_4K, - SZ_64K, - SZ_2M, - SZ_64M - }; - int i; - - for (i = 0; i < ARRAY_SIZE(sizes); i++) { - struct drm_i915_gem_object *obj; - int err; - - obj = i915_gem_object_create_internal(i915, sizes[i]); - if (IS_ERR(obj)) - return PTR_ERR(obj); - - err = __perf_fill_blt(obj); - i915_gem_object_put(obj); - if (err) - return err; - } - - return 0; -} - -static int __perf_copy_blt(struct drm_i915_gem_object *src, - struct drm_i915_gem_object *dst) -{ - struct drm_i915_private *i915 = to_i915(src->base.dev); - int inst = 0; - - do { - struct intel_engine_cs *engine; - ktime_t t[5]; - int pass; - int err = 0; - - engine = intel_engine_lookup_user(i915, - I915_ENGINE_CLASS_COPY, - inst++); - if (!engine) - return 0; - - intel_engine_pm_get(engine); - for (pass = 0; pass < ARRAY_SIZE(t); pass++) { - struct intel_context *ce = engine->kernel_context; - ktime_t t0, t1; - - t0 = ktime_get(); - - err = i915_gem_object_copy_blt(src, dst, ce); - if (err) - break; - - err = i915_gem_object_wait(dst, - I915_WAIT_ALL, - MAX_SCHEDULE_TIMEOUT); - if (err) - break; - - t1 = ktime_get(); - t[pass] = ktime_sub(t1, t0); - } - intel_engine_pm_put(engine); - if (err) - return err; - - sort(t, ARRAY_SIZE(t), sizeof(*t), wrap_ktime_compare, NULL); - pr_info("%s: blt %zd KiB copy: %lld MiB/s\n", - engine->name, - src->base.size >> 10, - div64_u64(mul_u32_u32(4 * src->base.size, - 1000 * 1000 * 1000), - t[1] + 2 * t[2] + t[3]) >> 20); - } while (1); -} - -static int perf_copy_blt(void *arg) -{ - struct drm_i915_private *i915 = arg; - static const unsigned long sizes[] = { - SZ_4K, - SZ_64K, - SZ_2M, - SZ_64M - }; - int i; - - for (i = 0; i < ARRAY_SIZE(sizes); i++) { - struct drm_i915_gem_object *src, *dst; - int err; - - src = i915_gem_object_create_internal(i915, sizes[i]); - if (IS_ERR(src)) - return PTR_ERR(src); - - dst = i915_gem_object_create_internal(i915, sizes[i]); - if (IS_ERR(dst)) { - err = PTR_ERR(dst); - goto err_src; - } - - err = __perf_copy_blt(src, dst); - - i915_gem_object_put(dst); -err_src: - i915_gem_object_put(src); - if (err) - return err; - } - - return 0; -} - -struct igt_thread_arg { - struct intel_engine_cs *engine; - struct i915_gem_context *ctx; - struct file *file; - struct rnd_state prng; - unsigned int n_cpus; -}; - -static int igt_fill_blt_thread(void *arg) -{ - struct igt_thread_arg *thread = arg; - struct intel_engine_cs *engine = thread->engine; - struct rnd_state *prng = &thread->prng; - struct drm_i915_gem_object *obj; - struct i915_gem_context *ctx; - struct intel_context *ce; - unsigned int prio; - IGT_TIMEOUT(end); - u64 total, max; - int err; - - ctx = thread->ctx; - if (!ctx) { - ctx = live_context_for_engine(engine, thread->file); - if (IS_ERR(ctx)) - return PTR_ERR(ctx); - - prio = i915_prandom_u32_max_state(I915_PRIORITY_MAX, prng); - ctx->sched.priority = prio; - } - - ce = i915_gem_context_get_engine(ctx, 0); - GEM_BUG_ON(IS_ERR(ce)); - - /* - * If we have a tiny shared address space, like for the GGTT - * then we can't be too greedy. - */ - max = ce->vm->total; - if (i915_is_ggtt(ce->vm) || thread->ctx) - max = div_u64(max, thread->n_cpus); - max >>= 4; - - total = PAGE_SIZE; - do { - /* Aim to keep the runtime under reasonable bounds! */ - const u32 max_phys_size = SZ_64K; - u32 val = prandom_u32_state(prng); - u32 phys_sz; - u32 sz; - u32 *vaddr; - u32 i; - - total = min(total, max); - sz = i915_prandom_u32_max_state(total, prng) + 1; - phys_sz = sz % max_phys_size + 1; - - sz = round_up(sz, PAGE_SIZE); - phys_sz = round_up(phys_sz, PAGE_SIZE); - phys_sz = min(phys_sz, sz); - - pr_debug("%s with phys_sz= %x, sz=%x, val=%x\n", __func__, - phys_sz, sz, val); - - obj = huge_gem_object(engine->i915, phys_sz, sz); - if (IS_ERR(obj)) { - err = PTR_ERR(obj); - goto err_flush; - } - - vaddr = i915_gem_object_pin_map_unlocked(obj, I915_MAP_WB); - if (IS_ERR(vaddr)) { - err = PTR_ERR(vaddr); - goto err_put; - } - - /* - * Make sure the potentially async clflush does its job, if - * required. - */ - memset32(vaddr, val ^ 0xdeadbeaf, - huge_gem_object_phys_size(obj) / sizeof(u32)); - - if (!(obj->cache_coherent & I915_BO_CACHE_COHERENT_FOR_WRITE)) - obj->cache_dirty = true; - - err = i915_gem_object_fill_blt(obj, ce, val); - if (err) - goto err_unpin; - - err = i915_gem_object_wait(obj, 0, MAX_SCHEDULE_TIMEOUT); - if (err) - goto err_unpin; - - for (i = 0; i < huge_gem_object_phys_size(obj) / sizeof(u32); i += 17) { - if (!(obj->cache_coherent & I915_BO_CACHE_COHERENT_FOR_READ)) - drm_clflush_virt_range(&vaddr[i], sizeof(vaddr[i])); - - if (vaddr[i] != val) { - pr_err("vaddr[%u]=%x, expected=%x\n", i, - vaddr[i], val); - err = -EINVAL; - goto err_unpin; - } - } - - i915_gem_object_unpin_map(obj); - i915_gem_object_put(obj); - - total <<= 1; - } while (!time_after(jiffies, end)); - - goto err_flush; - -err_unpin: - i915_gem_object_unpin_map(obj); -err_put: - i915_gem_object_put(obj); -err_flush: - if (err == -ENOMEM) - err = 0; - - intel_context_put(ce); - return err; -} - -static int igt_copy_blt_thread(void *arg) -{ - struct igt_thread_arg *thread = arg; - struct intel_engine_cs *engine = thread->engine; - struct rnd_state *prng = &thread->prng; - struct drm_i915_gem_object *src, *dst; - struct i915_gem_context *ctx; - struct intel_context *ce; - unsigned int prio; - IGT_TIMEOUT(end); - u64 total, max; - int err; - - ctx = thread->ctx; - if (!ctx) { - ctx = live_context_for_engine(engine, thread->file); - if (IS_ERR(ctx)) - return PTR_ERR(ctx); - - prio = i915_prandom_u32_max_state(I915_PRIORITY_MAX, prng); - ctx->sched.priority = prio; - } - - ce = i915_gem_context_get_engine(ctx, 0); - GEM_BUG_ON(IS_ERR(ce)); - - /* - * If we have a tiny shared address space, like for the GGTT - * then we can't be too greedy. - */ - max = ce->vm->total; - if (i915_is_ggtt(ce->vm) || thread->ctx) - max = div_u64(max, thread->n_cpus); - max >>= 4; - - total = PAGE_SIZE; - do { - /* Aim to keep the runtime under reasonable bounds! */ - const u32 max_phys_size = SZ_64K; - u32 val = prandom_u32_state(prng); - u32 phys_sz; - u32 sz; - u32 *vaddr; - u32 i; - - total = min(total, max); - sz = i915_prandom_u32_max_state(total, prng) + 1; - phys_sz = sz % max_phys_size + 1; - - sz = round_up(sz, PAGE_SIZE); - phys_sz = round_up(phys_sz, PAGE_SIZE); - phys_sz = min(phys_sz, sz); - - pr_debug("%s with phys_sz= %x, sz=%x, val=%x\n", __func__, - phys_sz, sz, val); - - src = huge_gem_object(engine->i915, phys_sz, sz); - if (IS_ERR(src)) { - err = PTR_ERR(src); - goto err_flush; - } - - vaddr = i915_gem_object_pin_map_unlocked(src, I915_MAP_WB); - if (IS_ERR(vaddr)) { - err = PTR_ERR(vaddr); - goto err_put_src; - } - - memset32(vaddr, val, - huge_gem_object_phys_size(src) / sizeof(u32)); - - i915_gem_object_unpin_map(src); - - if (!(src->cache_coherent & I915_BO_CACHE_COHERENT_FOR_READ)) - src->cache_dirty = true; - - dst = huge_gem_object(engine->i915, phys_sz, sz); - if (IS_ERR(dst)) { - err = PTR_ERR(dst); - goto err_put_src; - } - - vaddr = i915_gem_object_pin_map_unlocked(dst, I915_MAP_WB); - if (IS_ERR(vaddr)) { - err = PTR_ERR(vaddr); - goto err_put_dst; - } - - memset32(vaddr, val ^ 0xdeadbeaf, - huge_gem_object_phys_size(dst) / sizeof(u32)); - - if (!(dst->cache_coherent & I915_BO_CACHE_COHERENT_FOR_WRITE)) - dst->cache_dirty = true; - - err = i915_gem_object_copy_blt(src, dst, ce); - if (err) - goto err_unpin; - - err = i915_gem_object_wait(dst, 0, MAX_SCHEDULE_TIMEOUT); - if (err) - goto err_unpin; - - for (i = 0; i < huge_gem_object_phys_size(dst) / sizeof(u32); i += 17) { - if (!(dst->cache_coherent & I915_BO_CACHE_COHERENT_FOR_READ)) - drm_clflush_virt_range(&vaddr[i], sizeof(vaddr[i])); - - if (vaddr[i] != val) { - pr_err("vaddr[%u]=%x, expected=%x\n", i, - vaddr[i], val); - err = -EINVAL; - goto err_unpin; - } - } - - i915_gem_object_unpin_map(dst); - - i915_gem_object_put(src); - i915_gem_object_put(dst); - - total <<= 1; - } while (!time_after(jiffies, end)); - - goto err_flush; - -err_unpin: - i915_gem_object_unpin_map(dst); -err_put_dst: - i915_gem_object_put(dst); -err_put_src: - i915_gem_object_put(src); -err_flush: - if (err == -ENOMEM) - err = 0; - - intel_context_put(ce); - return err; -} - -static int igt_threaded_blt(struct intel_engine_cs *engine, - int (*blt_fn)(void *arg), - unsigned int flags) -#define SINGLE_CTX BIT(0) -{ - struct igt_thread_arg *thread; - struct task_struct **tsk; - unsigned int n_cpus, i; - I915_RND_STATE(prng); - int err = 0; - - n_cpus = num_online_cpus() + 1; - - tsk = kcalloc(n_cpus, sizeof(struct task_struct *), GFP_KERNEL); - if (!tsk) - return 0; - - thread = kcalloc(n_cpus, sizeof(struct igt_thread_arg), GFP_KERNEL); - if (!thread) - goto out_tsk; - - thread[0].file = mock_file(engine->i915); - if (IS_ERR(thread[0].file)) { - err = PTR_ERR(thread[0].file); - goto out_thread; - } - - if (flags & SINGLE_CTX) { - thread[0].ctx = live_context_for_engine(engine, thread[0].file); - if (IS_ERR(thread[0].ctx)) { - err = PTR_ERR(thread[0].ctx); - goto out_file; - } - } - - for (i = 0; i < n_cpus; ++i) { - thread[i].engine = engine; - thread[i].file = thread[0].file; - thread[i].ctx = thread[0].ctx; - thread[i].n_cpus = n_cpus; - thread[i].prng = - I915_RND_STATE_INITIALIZER(prandom_u32_state(&prng)); - - tsk[i] = kthread_run(blt_fn, &thread[i], "igt/blt-%d", i); - if (IS_ERR(tsk[i])) { - err = PTR_ERR(tsk[i]); - break; - } - - get_task_struct(tsk[i]); - } - - yield(); /* start all threads before we kthread_stop() */ - - for (i = 0; i < n_cpus; ++i) { - int status; - - if (IS_ERR_OR_NULL(tsk[i])) - continue; - - status = kthread_stop(tsk[i]); - if (status && !err) - err = status; - - put_task_struct(tsk[i]); - } - -out_file: - fput(thread[0].file); -out_thread: - kfree(thread); -out_tsk: - kfree(tsk); - return err; -} - -static int test_copy_engines(struct drm_i915_private *i915, - int (*fn)(void *arg), - unsigned int flags) -{ - struct intel_engine_cs *engine; - int ret; - - for_each_uabi_class_engine(engine, I915_ENGINE_CLASS_COPY, i915) { - ret = igt_threaded_blt(engine, fn, flags); - if (ret) - return ret; - } - - return 0; -} - -static int igt_fill_blt(void *arg) -{ - return test_copy_engines(arg, igt_fill_blt_thread, 0); -} - -static int igt_fill_blt_ctx0(void *arg) -{ - return test_copy_engines(arg, igt_fill_blt_thread, SINGLE_CTX); -} - -static int igt_copy_blt(void *arg) -{ - return test_copy_engines(arg, igt_copy_blt_thread, 0); -} - -static int igt_copy_blt_ctx0(void *arg) -{ - return test_copy_engines(arg, igt_copy_blt_thread, SINGLE_CTX); -} - -int i915_gem_object_blt_live_selftests(struct drm_i915_private *i915) -{ - static const struct i915_subtest tests[] = { - SUBTEST(igt_fill_blt), - SUBTEST(igt_fill_blt_ctx0), - SUBTEST(igt_copy_blt), - SUBTEST(igt_copy_blt_ctx0), - }; - - if (intel_gt_is_wedged(&i915->gt)) - return 0; - - return i915_live_subtests(tests, i915); -} - -int i915_gem_object_blt_perf_selftests(struct drm_i915_private *i915) -{ - static const struct i915_subtest tests[] = { - SUBTEST(perf_fill_blt), - SUBTEST(perf_copy_blt), - }; - - if (intel_gt_is_wedged(&i915->gt)) - return 0; - - return i915_live_subtests(tests, i915); -} diff --git a/drivers/gpu/drm/i915/selftests/i915_live_selftests.h b/drivers/gpu/drm/i915/selftests/i915_live_selftests.h index be5e0191eaea..a68197cf1044 100644 --- a/drivers/gpu/drm/i915/selftests/i915_live_selftests.h +++ b/drivers/gpu/drm/i915/selftests/i915_live_selftests.h @@ -39,7 +39,6 @@ selftest(evict, i915_gem_evict_live_selftests) selftest(hugepages, i915_gem_huge_page_live_selftests) selftest(gem_contexts, i915_gem_context_live_selftests) selftest(gem_execbuf, i915_gem_execbuffer_live_selftests) -selftest(blt, i915_gem_object_blt_live_selftests) selftest(client, i915_gem_client_blt_live_selftests) selftest(reset, intel_reset_live_selftests) selftest(memory_region, intel_memory_region_live_selftests) diff --git a/drivers/gpu/drm/i915/selftests/i915_perf_selftests.h b/drivers/gpu/drm/i915/selftests/i915_perf_selftests.h index 5077dc3c3b8c..058450d351f7 100644 --- a/drivers/gpu/drm/i915/selftests/i915_perf_selftests.h +++ b/drivers/gpu/drm/i915/selftests/i915_perf_selftests.h @@ -18,5 +18,4 @@ selftest(engine_cs, intel_engine_cs_perf_selftests) selftest(request, i915_request_perf_selftests) selftest(migrate, intel_migrate_perf_selftests) -selftest(blt, i915_gem_object_blt_perf_selftests) selftest(region, intel_memory_region_perf_selftests) diff --git a/drivers/gpu/drm/i915/selftests/intel_memory_region.c b/drivers/gpu/drm/i915/selftests/intel_memory_region.c index 118a66c29695..ecc3b9e6c22b 100644 --- a/drivers/gpu/drm/i915/selftests/intel_memory_region.c +++ b/drivers/gpu/drm/i915/selftests/intel_memory_region.c @@ -15,12 +15,13 @@ #include "gem/i915_gem_context.h" #include "gem/i915_gem_lmem.h" #include "gem/i915_gem_region.h" -#include "gem/i915_gem_object_blt.h" #include "gem/selftests/igt_gem_utils.h" #include "gem/selftests/mock_context.h" +#include "gt/intel_engine_pm.h" #include "gt/intel_engine_user.h" #include "gt/intel_gt.h" #include "i915_buddy.h" +#include "gt/intel_migrate.h" #include "i915_memcpy.h" #include "i915_ttm_buddy_manager.h" #include "selftests/igt_flush_test.h" @@ -808,6 +809,7 @@ static int igt_lmem_write_cpu(void *arg) PAGE_SIZE - 64, }; struct intel_engine_cs *engine; + struct i915_request *rq; u32 *vaddr; u32 sz; u32 i; @@ -834,15 +836,20 @@ static int igt_lmem_write_cpu(void *arg) goto out_put; } + i915_gem_object_lock(obj, NULL); /* Put the pages into a known state -- from the gpu for added fun */ intel_engine_pm_get(engine); - err = i915_gem_object_fill_blt(obj, engine->kernel_context, 0xdeadbeaf); - intel_engine_pm_put(engine); - if (err) - goto out_unpin; + err = intel_context_migrate_clear(engine->gt->migrate.context, NULL, + obj->mm.pages->sgl, I915_CACHE_NONE, + true, 0xdeadbeaf, &rq); + if (rq) { + dma_resv_add_excl_fence(obj->base.resv, &rq->fence); + i915_request_put(rq); + } - i915_gem_object_lock(obj, NULL); - err = i915_gem_object_set_to_wc_domain(obj, true); + intel_engine_pm_put(engine); + if (!err) + err = i915_gem_object_set_to_wc_domain(obj, true); i915_gem_object_unlock(obj); if (err) goto out_unpin; -- 2.31.1