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 6C7A4C49EA5 for ; Mon, 14 Jun 2021 16:27:04 +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 3EB6260234 for ; Mon, 14 Jun 2021 16:27:04 +0000 (UTC) DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org 3EB6260234 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 D184989F06; Mon, 14 Jun 2021 16:26:53 +0000 (UTC) Received: from mga07.intel.com (mga07.intel.com [134.134.136.100]) by gabe.freedesktop.org (Postfix) with ESMTPS id 0458B89F06; Mon, 14 Jun 2021 16:26:50 +0000 (UTC) IronPort-SDR: 55b/4waIvnXP/m0PhHYmC0Cad6I4knJXTqn7s2xTcG3Hm5OclMQk8VvyMJbB/GbGVfqxn2C2LK TS2V4K6RPjzg== X-IronPort-AV: E=McAfee;i="6200,9189,10015"; a="269689042" X-IronPort-AV: E=Sophos;i="5.83,273,1616482800"; d="scan'208";a="269689042" Received: from orsmga008.jf.intel.com ([10.7.209.65]) by orsmga105.jf.intel.com with ESMTP/TLS/ECDHE-RSA-AES256-GCM-SHA384; 14 Jun 2021 09:26:45 -0700 IronPort-SDR: aXnF4RR0ztoOdpZLMGcmfCDoMA3DSP7WWtFqTvY373kfWlw3U13Gdx7lWqKnmwPDtrkN9E+Pnb 9mx/OS/iKpdA== X-IronPort-AV: E=Sophos;i="5.83,273,1616482800"; d="scan'208";a="449946744" Received: from fnygreen-mobl1.ger.corp.intel.com (HELO thellst-mobl1.intel.com) ([10.249.254.50]) by orsmga008-auth.jf.intel.com with ESMTP/TLS/ECDHE-RSA-AES256-GCM-SHA384; 14 Jun 2021 09:26:44 -0700 From: =?UTF-8?q?Thomas=20Hellstr=C3=B6m?= To: intel-gfx@lists.freedesktop.org, dri-devel@lists.freedesktop.org Date: Mon, 14 Jun 2021 18:26:12 +0200 Message-Id: <20210614162612.294869-13-thomas.hellstrom@linux.intel.com> X-Mailer: git-send-email 2.31.1 In-Reply-To: <20210614162612.294869-1-thomas.hellstrom@linux.intel.com> References: <20210614162612.294869-1-thomas.hellstrom@linux.intel.com> MIME-Version: 1.0 Subject: [Intel-gfx] [PATCH v3 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 PgotLS0KIGRyaXZlcnMvZ3B1L2RybS9pOTE1L01ha2VmaWxlICAgICAgICAgICAgICAgICB8ICAg MSAtCiAuLi4vZ3B1L2RybS9pOTE1L2dlbS9pOTE1X2dlbV9vYmplY3RfYmx0LmMgICAgfCA0NjEg LS0tLS0tLS0tLS0tLS0KIC4uLi9ncHUvZHJtL2k5MTUvZ2VtL2k5MTVfZ2VtX29iamVjdF9ibHQu aCAgICB8ICAzOSAtLQogLi4uL2k5MTUvZ2VtL3NlbGZ0ZXN0cy9pOTE1X2dlbV9vYmplY3RfYmx0 LmMgIHwgNTk3IC0tLS0tLS0tLS0tLS0tLS0tLQogLi4uL2RybS9pOTE1L3NlbGZ0ZXN0cy9pOTE1 X2xpdmVfc2VsZnRlc3RzLmggIHwgICAxIC0KIC4uLi9kcm0vaTkxNS9zZWxmdGVzdHMvaTkxNV9w ZXJmX3NlbGZ0ZXN0cy5oICB8ICAgMSAtCiAuLi4vZHJtL2k5MTUvc2VsZnRlc3RzL2ludGVsX21l bW9yeV9yZWdpb24uYyAgfCAgMjEgKy0KIDcgZmlsZXMgY2hhbmdlZCwgMTQgaW5zZXJ0aW9ucygr KSwgMTEwNyBkZWxldGlvbnMoLSkKIGRlbGV0ZSBtb2RlIDEwMDY0NCBkcml2ZXJzL2dwdS9kcm0v aTkxNS9nZW0vaTkxNV9nZW1fb2JqZWN0X2JsdC5jCiBkZWxldGUgbW9kZSAxMDA2NDQgZHJpdmVy cy9ncHUvZHJtL2k5MTUvZ2VtL2k5MTVfZ2VtX29iamVjdF9ibHQuaAogZGVsZXRlIG1vZGUgMTAw NjQ0IGRyaXZlcnMvZ3B1L2RybS9pOTE1L2dlbS9zZWxmdGVzdHMvaTkxNV9nZW1fb2JqZWN0X2Js dC5jCgpkaWZmIC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJtL2k5MTUvTWFrZWZpbGUgYi9kcml2ZXJz L2dwdS9kcm0vaTkxNS9NYWtlZmlsZQppbmRleCBjYTA3NDc0ZWMyZGYuLjEzMDg1YWM3OGM2MyAx MDA2NDQKLS0tIGEvZHJpdmVycy9ncHUvZHJtL2k5MTUvTWFrZWZpbGUKKysrIGIvZHJpdmVycy9n cHUvZHJtL2k5MTUvTWFrZWZpbGUKQEAgLTE0Myw3ICsxNDMsNiBAQCBnZW0teSArPSBcCiAJZ2Vt L2k5MTVfZ2VtX2V4ZWNidWZmZXIubyBcCiAJZ2VtL2k5MTVfZ2VtX2ludGVybmFsLm8gXAogCWdl bS9pOTE1X2dlbV9vYmplY3QubyBcCi0JZ2VtL2k5MTVfZ2VtX29iamVjdF9ibHQubyBcCiAJZ2Vt L2k5MTVfZ2VtX2xtZW0ubyBcCiAJZ2VtL2k5MTVfZ2VtX21tYW4ubyBcCiAJZ2VtL2k5MTVfZ2Vt X3BhZ2VzLm8gXApkaWZmIC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJtL2k5MTUvZ2VtL2k5MTVfZ2Vt X29iamVjdF9ibHQuYyBiL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2dlbS9pOTE1X2dlbV9vYmplY3Rf Ymx0LmMKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDNlMjhjNjhmZGEzZS4uMDAwMDAw MDAwMDAwCi0tLSBhL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2dlbS9pOTE1X2dlbV9vYmplY3RfYmx0 LmMKKysrIC9kZXYvbnVsbApAQCAtMSw0NjEgKzAsMCBAQAotLy8gU1BEWC1MaWNlbnNlLUlkZW50 aWZpZXI6IE1JVAotLyoKLSAqIENvcHlyaWdodCDCqSAyMDE5IEludGVsIENvcnBvcmF0aW9uCi0g Ki8KLQotI2luY2x1ZGUgImk5MTVfZHJ2LmgiCi0jaW5jbHVkZSAiZ3QvaW50ZWxfY29udGV4dC5o IgotI2luY2x1ZGUgImd0L2ludGVsX2VuZ2luZV9wbS5oIgotI2luY2x1ZGUgImd0L2ludGVsX2dw dV9jb21tYW5kcy5oIgotI2luY2x1ZGUgImd0L2ludGVsX2d0LmgiCi0jaW5jbHVkZSAiZ3QvaW50 ZWxfZ3RfYnVmZmVyX3Bvb2wuaCIKLSNpbmNsdWRlICJndC9pbnRlbF9yaW5nLmgiCi0jaW5jbHVk ZSAiaTkxNV9nZW1fY2xmbHVzaC5oIgotI2luY2x1ZGUgImk5MTVfZ2VtX29iamVjdF9ibHQuaCIK LQotc3RydWN0IGk5MTVfdm1hICppbnRlbF9lbWl0X3ZtYV9maWxsX2JsdChzdHJ1Y3QgaW50ZWxf Y29udGV4dCAqY2UsCi0JCQkJCSBzdHJ1Y3QgaTkxNV92bWEgKnZtYSwKLQkJCQkJIHN0cnVjdCBp OTE1X2dlbV93d19jdHggKnd3LAotCQkJCQkgdTMyIHZhbHVlKQotewotCXN0cnVjdCBkcm1faTkx NV9wcml2YXRlICppOTE1ID0gY2UtPnZtLT5pOTE1OwotCWNvbnN0IHUzMiBibG9ja19zaXplID0g U1pfOE07IC8qIH4xbXMgYXQgOEdpQi9zIHByZWVtcHRpb24gZGVsYXkgKi8KLQlzdHJ1Y3QgaW50 ZWxfZ3RfYnVmZmVyX3Bvb2xfbm9kZSAqcG9vbDsKLQlzdHJ1Y3QgaTkxNV92bWEgKmJhdGNoOwot CXU2NCBvZmZzZXQ7Ci0JdTY0IGNvdW50OwotCXU2NCByZW07Ci0JdTMyIHNpemU7Ci0JdTMyICpj bWQ7Ci0JaW50IGVycjsKLQotCUdFTV9CVUdfT04oaW50ZWxfZW5naW5lX2lzX3ZpcnR1YWwoY2Ut PmVuZ2luZSkpOwotCWludGVsX2VuZ2luZV9wbV9nZXQoY2UtPmVuZ2luZSk7Ci0KLQljb3VudCA9 IGRpdl91NjQocm91bmRfdXAodm1hLT5zaXplLCBibG9ja19zaXplKSwgYmxvY2tfc2l6ZSk7Ci0J c2l6ZSA9ICgxICsgOCAqIGNvdW50KSAqIHNpemVvZih1MzIpOwotCXNpemUgPSByb3VuZF91cChz aXplLCBQQUdFX1NJWkUpOwotCXBvb2wgPSBpbnRlbF9ndF9nZXRfYnVmZmVyX3Bvb2woY2UtPmVu Z2luZS0+Z3QsIHNpemUsIEk5MTVfTUFQX1dDKTsKLQlpZiAoSVNfRVJSKHBvb2wpKSB7Ci0JCWVy ciA9IFBUUl9FUlIocG9vbCk7Ci0JCWdvdG8gb3V0X3BtOwotCX0KLQotCWVyciA9IGk5MTVfZ2Vt X29iamVjdF9sb2NrKHBvb2wtPm9iaiwgd3cpOwotCWlmIChlcnIpCi0JCWdvdG8gb3V0X3B1dDsK LQotCWJhdGNoID0gaTkxNV92bWFfaW5zdGFuY2UocG9vbC0+b2JqLCBjZS0+dm0sIE5VTEwpOwot CWlmIChJU19FUlIoYmF0Y2gpKSB7Ci0JCWVyciA9IFBUUl9FUlIoYmF0Y2gpOwotCQlnb3RvIG91 dF9wdXQ7Ci0JfQotCi0JZXJyID0gaTkxNV92bWFfcGluX3d3KGJhdGNoLCB3dywgMCwgMCwgUElO X1VTRVIpOwotCWlmICh1bmxpa2VseShlcnIpKQotCQlnb3RvIG91dF9wdXQ7Ci0KLQkvKiB3ZSBw aW5uZWQgdGhlIHBvb2wsIG1hcmsgaXQgYXMgc3VjaCAqLwotCWludGVsX2d0X2J1ZmZlcl9wb29s X21hcmtfdXNlZChwb29sKTsKLQotCWNtZCA9IGk5MTVfZ2VtX29iamVjdF9waW5fbWFwKHBvb2wt Pm9iaiwgcG9vbC0+dHlwZSk7Ci0JaWYgKElTX0VSUihjbWQpKSB7Ci0JCWVyciA9IFBUUl9FUlIo Y21kKTsKLQkJZ290byBvdXRfdW5waW47Ci0JfQotCi0JcmVtID0gdm1hLT5zaXplOwotCW9mZnNl dCA9IHZtYS0+bm9kZS5zdGFydDsKLQotCWRvIHsKLQkJdTMyIHNpemUgPSBtaW5fdCh1NjQsIHJl bSwgYmxvY2tfc2l6ZSk7Ci0KLQkJR0VNX0JVR19PTihzaXplID4+IFBBR0VfU0hJRlQgPiBTMTZf TUFYKTsKLQotCQlpZiAoR1JBUEhJQ1NfVkVSKGk5MTUpID49IDgpIHsKLQkJCSpjbWQrKyA9IFhZ X0NPTE9SX0JMVF9DTUQgfCBCTFRfV1JJVEVfUkdCQSB8ICg3IC0gMik7Ci0JCQkqY21kKysgPSBC TFRfREVQVEhfMzIgfCBCTFRfUk9QX0NPTE9SX0NPUFkgfCBQQUdFX1NJWkU7Ci0JCQkqY21kKysg PSAwOwotCQkJKmNtZCsrID0gc2l6ZSA+PiBQQUdFX1NISUZUIDw8IDE2IHwgUEFHRV9TSVpFIC8g NDsKLQkJCSpjbWQrKyA9IGxvd2VyXzMyX2JpdHMob2Zmc2V0KTsKLQkJCSpjbWQrKyA9IHVwcGVy XzMyX2JpdHMob2Zmc2V0KTsKLQkJCSpjbWQrKyA9IHZhbHVlOwotCQl9IGVsc2UgewotCQkJKmNt ZCsrID0gWFlfQ09MT1JfQkxUX0NNRCB8IEJMVF9XUklURV9SR0JBIHwgKDYgLSAyKTsKLQkJCSpj bWQrKyA9IEJMVF9ERVBUSF8zMiB8IEJMVF9ST1BfQ09MT1JfQ09QWSB8IFBBR0VfU0laRTsKLQkJ CSpjbWQrKyA9IDA7Ci0JCQkqY21kKysgPSBzaXplID4+IFBBR0VfU0hJRlQgPDwgMTYgfCBQQUdF X1NJWkUgLyA0OwotCQkJKmNtZCsrID0gb2Zmc2V0OwotCQkJKmNtZCsrID0gdmFsdWU7Ci0JCX0K LQotCQkvKiBBbGxvdyBvdXJzZWx2ZXMgdG8gYmUgcHJlZW1wdGVkIGluIGJldHdlZW4gYmxvY2tz LiAqLwotCQkqY21kKysgPSBNSV9BUkJfQ0hFQ0s7Ci0KLQkJb2Zmc2V0ICs9IHNpemU7Ci0JCXJl bSAtPSBzaXplOwotCX0gd2hpbGUgKHJlbSk7Ci0KLQkqY21kID0gTUlfQkFUQ0hfQlVGRkVSX0VO RDsKLQotCWk5MTVfZ2VtX29iamVjdF9mbHVzaF9tYXAocG9vbC0+b2JqKTsKLQlpOTE1X2dlbV9v YmplY3RfdW5waW5fbWFwKHBvb2wtPm9iaik7Ci0KLQlpbnRlbF9ndF9jaGlwc2V0X2ZsdXNoKGNl LT52bS0+Z3QpOwotCi0JYmF0Y2gtPnByaXZhdGUgPSBwb29sOwotCXJldHVybiBiYXRjaDsKLQot b3V0X3VucGluOgotCWk5MTVfdm1hX3VucGluKGJhdGNoKTsKLW91dF9wdXQ6Ci0JaW50ZWxfZ3Rf YnVmZmVyX3Bvb2xfcHV0KHBvb2wpOwotb3V0X3BtOgotCWludGVsX2VuZ2luZV9wbV9wdXQoY2Ut PmVuZ2luZSk7Ci0JcmV0dXJuIEVSUl9QVFIoZXJyKTsKLX0KLQotaW50IGludGVsX2VtaXRfdm1h X21hcmtfYWN0aXZlKHN0cnVjdCBpOTE1X3ZtYSAqdm1hLCBzdHJ1Y3QgaTkxNV9yZXF1ZXN0ICpy cSkKLXsKLQlpbnQgZXJyOwotCi0JZXJyID0gaTkxNV9yZXF1ZXN0X2F3YWl0X29iamVjdChycSwg dm1hLT5vYmosIGZhbHNlKTsKLQlpZiAoZXJyID09IDApCi0JCWVyciA9IGk5MTVfdm1hX21vdmVf dG9fYWN0aXZlKHZtYSwgcnEsIDApOwotCWlmICh1bmxpa2VseShlcnIpKQotCQlyZXR1cm4gZXJy OwotCi0JcmV0dXJuIGludGVsX2d0X2J1ZmZlcl9wb29sX21hcmtfYWN0aXZlKHZtYS0+cHJpdmF0 ZSwgcnEpOwotfQotCi12b2lkIGludGVsX2VtaXRfdm1hX3JlbGVhc2Uoc3RydWN0IGludGVsX2Nv bnRleHQgKmNlLCBzdHJ1Y3QgaTkxNV92bWEgKnZtYSkKLXsKLQlpOTE1X3ZtYV91bnBpbih2bWEp OwotCWludGVsX2d0X2J1ZmZlcl9wb29sX3B1dCh2bWEtPnByaXZhdGUpOwotCWludGVsX2VuZ2lu ZV9wbV9wdXQoY2UtPmVuZ2luZSk7Ci19Ci0KLXN0YXRpYyBpbnQKLW1vdmVfb2JqX3RvX2dwdShz dHJ1Y3QgZHJtX2k5MTVfZ2VtX29iamVjdCAqb2JqLAotCQlzdHJ1Y3QgaTkxNV9yZXF1ZXN0ICpy cSwKLQkJYm9vbCB3cml0ZSkKLXsKLQlpZiAob2JqLT5jYWNoZV9kaXJ0eSAmIH5vYmotPmNhY2hl X2NvaGVyZW50KQotCQlpOTE1X2dlbV9jbGZsdXNoX29iamVjdChvYmosIDApOwotCi0JcmV0dXJu IGk5MTVfcmVxdWVzdF9hd2FpdF9vYmplY3QocnEsIG9iaiwgd3JpdGUpOwotfQotCi1pbnQgaTkx NV9nZW1fb2JqZWN0X2ZpbGxfYmx0KHN0cnVjdCBkcm1faTkxNV9nZW1fb2JqZWN0ICpvYmosCi0J CQkgICAgIHN0cnVjdCBpbnRlbF9jb250ZXh0ICpjZSwKLQkJCSAgICAgdTMyIHZhbHVlKQotewot CXN0cnVjdCBpOTE1X2dlbV93d19jdHggd3c7Ci0Jc3RydWN0IGk5MTVfcmVxdWVzdCAqcnE7Ci0J c3RydWN0IGk5MTVfdm1hICpiYXRjaDsKLQlzdHJ1Y3QgaTkxNV92bWEgKnZtYTsKLQlpbnQgZXJy OwotCi0Jdm1hID0gaTkxNV92bWFfaW5zdGFuY2Uob2JqLCBjZS0+dm0sIE5VTEwpOwotCWlmIChJ U19FUlIodm1hKSkKLQkJcmV0dXJuIFBUUl9FUlIodm1hKTsKLQotCWk5MTVfZ2VtX3d3X2N0eF9p bml0KCZ3dywgdHJ1ZSk7Ci0JaW50ZWxfZW5naW5lX3BtX2dldChjZS0+ZW5naW5lKTsKLXJldHJ5 OgotCWVyciA9IGk5MTVfZ2VtX29iamVjdF9sb2NrKG9iaiwgJnd3KTsKLQlpZiAoZXJyKQotCQln b3RvIG91dDsKLQotCWVyciA9IGludGVsX2NvbnRleHRfcGluX3d3KGNlLCAmd3cpOwotCWlmIChl cnIpCi0JCWdvdG8gb3V0OwotCi0JZXJyID0gaTkxNV92bWFfcGluX3d3KHZtYSwgJnd3LCAwLCAw LCBQSU5fVVNFUik7Ci0JaWYgKGVycikKLQkJZ290byBvdXRfY3R4OwotCi0JYmF0Y2ggPSBpbnRl bF9lbWl0X3ZtYV9maWxsX2JsdChjZSwgdm1hLCAmd3csIHZhbHVlKTsKLQlpZiAoSVNfRVJSKGJh dGNoKSkgewotCQllcnIgPSBQVFJfRVJSKGJhdGNoKTsKLQkJZ290byBvdXRfdm1hOwotCX0KLQot CXJxID0gaTkxNV9yZXF1ZXN0X2NyZWF0ZShjZSk7Ci0JaWYgKElTX0VSUihycSkpIHsKLQkJZXJy ID0gUFRSX0VSUihycSk7Ci0JCWdvdG8gb3V0X2JhdGNoOwotCX0KLQotCWVyciA9IGludGVsX2Vt aXRfdm1hX21hcmtfYWN0aXZlKGJhdGNoLCBycSk7Ci0JaWYgKHVubGlrZWx5KGVycikpCi0JCWdv dG8gb3V0X3JlcXVlc3Q7Ci0KLQllcnIgPSBtb3ZlX29ial90b19ncHUodm1hLT5vYmosIHJxLCB0 cnVlKTsKLQlpZiAoZXJyID09IDApCi0JCWVyciA9IGk5MTVfdm1hX21vdmVfdG9fYWN0aXZlKHZt YSwgcnEsIEVYRUNfT0JKRUNUX1dSSVRFKTsKLQlpZiAodW5saWtlbHkoZXJyKSkKLQkJZ290byBv dXRfcmVxdWVzdDsKLQotCWlmIChjZS0+ZW5naW5lLT5lbWl0X2luaXRfYnJlYWRjcnVtYikKLQkJ ZXJyID0gY2UtPmVuZ2luZS0+ZW1pdF9pbml0X2JyZWFkY3J1bWIocnEpOwotCi0JaWYgKGxpa2Vs eSghZXJyKSkKLQkJZXJyID0gY2UtPmVuZ2luZS0+ZW1pdF9iYl9zdGFydChycSwKLQkJCQkJCWJh dGNoLT5ub2RlLnN0YXJ0LAotCQkJCQkJYmF0Y2gtPm5vZGUuc2l6ZSwKLQkJCQkJCTApOwotb3V0 X3JlcXVlc3Q6Ci0JaWYgKHVubGlrZWx5KGVycikpCi0JCWk5MTVfcmVxdWVzdF9zZXRfZXJyb3Jf b25jZShycSwgZXJyKTsKLQotCWk5MTVfcmVxdWVzdF9hZGQocnEpOwotb3V0X2JhdGNoOgotCWlu dGVsX2VtaXRfdm1hX3JlbGVhc2UoY2UsIGJhdGNoKTsKLW91dF92bWE6Ci0JaTkxNV92bWFfdW5w aW4odm1hKTsKLW91dF9jdHg6Ci0JaW50ZWxfY29udGV4dF91bnBpbihjZSk7Ci1vdXQ6Ci0JaWYg KGVyciA9PSAtRURFQURMSykgewotCQllcnIgPSBpOTE1X2dlbV93d19jdHhfYmFja29mZigmd3cp OwotCQlpZiAoIWVycikKLQkJCWdvdG8gcmV0cnk7Ci0JfQotCWk5MTVfZ2VtX3d3X2N0eF9maW5p KCZ3dyk7Ci0JaW50ZWxfZW5naW5lX3BtX3B1dChjZS0+ZW5naW5lKTsKLQlyZXR1cm4gZXJyOwot fQotCi0vKiBXYV8xMjA5NjQ0NjExOmljbCxlaGwgKi8KLXN0YXRpYyBib29sIHdhXzEyMDk2NDQ2 MTFfYXBwbGllcyhzdHJ1Y3QgZHJtX2k5MTVfcHJpdmF0ZSAqaTkxNSwgdTMyIHNpemUpCi17Ci0J dTMyIGhlaWdodCA9IHNpemUgPj4gUEFHRV9TSElGVDsKLQotCWlmIChHUkFQSElDU19WRVIoaTkx NSkgIT0gMTEpCi0JCXJldHVybiBmYWxzZTsKLQotCXJldHVybiBoZWlnaHQgJSA0ID09IDMgJiYg aGVpZ2h0IDw9IDg7Ci19Ci0KLXN0cnVjdCBpOTE1X3ZtYSAqaW50ZWxfZW1pdF92bWFfY29weV9i bHQoc3RydWN0IGludGVsX2NvbnRleHQgKmNlLAotCQkJCQkgc3RydWN0IGk5MTVfZ2VtX3d3X2N0 eCAqd3csCi0JCQkJCSBzdHJ1Y3QgaTkxNV92bWEgKnNyYywKLQkJCQkJIHN0cnVjdCBpOTE1X3Zt YSAqZHN0KQotewotCXN0cnVjdCBkcm1faTkxNV9wcml2YXRlICppOTE1ID0gY2UtPnZtLT5pOTE1 OwotCWNvbnN0IHUzMiBibG9ja19zaXplID0gU1pfOE07IC8qIH4xbXMgYXQgOEdpQi9zIHByZWVt cHRpb24gZGVsYXkgKi8KLQlzdHJ1Y3QgaW50ZWxfZ3RfYnVmZmVyX3Bvb2xfbm9kZSAqcG9vbDsK LQlzdHJ1Y3QgaTkxNV92bWEgKmJhdGNoOwotCXU2NCBzcmNfb2Zmc2V0LCBkc3Rfb2Zmc2V0Owot CXU2NCBjb3VudCwgcmVtOwotCXUzMiBzaXplLCAqY21kOwotCWludCBlcnI7Ci0KLQlHRU1fQlVH X09OKHNyYy0+c2l6ZSAhPSBkc3QtPnNpemUpOwotCi0JR0VNX0JVR19PTihpbnRlbF9lbmdpbmVf aXNfdmlydHVhbChjZS0+ZW5naW5lKSk7Ci0JaW50ZWxfZW5naW5lX3BtX2dldChjZS0+ZW5naW5l KTsKLQotCWNvdW50ID0gZGl2X3U2NChyb3VuZF91cChkc3QtPnNpemUsIGJsb2NrX3NpemUpLCBi bG9ja19zaXplKTsKLQlzaXplID0gKDEgKyAxMSAqIGNvdW50KSAqIHNpemVvZih1MzIpOwotCXNp emUgPSByb3VuZF91cChzaXplLCBQQUdFX1NJWkUpOwotCXBvb2wgPSBpbnRlbF9ndF9nZXRfYnVm ZmVyX3Bvb2woY2UtPmVuZ2luZS0+Z3QsIHNpemUsIEk5MTVfTUFQX1dDKTsKLQlpZiAoSVNfRVJS KHBvb2wpKSB7Ci0JCWVyciA9IFBUUl9FUlIocG9vbCk7Ci0JCWdvdG8gb3V0X3BtOwotCX0KLQot CWVyciA9IGk5MTVfZ2VtX29iamVjdF9sb2NrKHBvb2wtPm9iaiwgd3cpOwotCWlmIChlcnIpCi0J CWdvdG8gb3V0X3B1dDsKLQotCWJhdGNoID0gaTkxNV92bWFfaW5zdGFuY2UocG9vbC0+b2JqLCBj ZS0+dm0sIE5VTEwpOwotCWlmIChJU19FUlIoYmF0Y2gpKSB7Ci0JCWVyciA9IFBUUl9FUlIoYmF0 Y2gpOwotCQlnb3RvIG91dF9wdXQ7Ci0JfQotCi0JZXJyID0gaTkxNV92bWFfcGluX3d3KGJhdGNo LCB3dywgMCwgMCwgUElOX1VTRVIpOwotCWlmICh1bmxpa2VseShlcnIpKQotCQlnb3RvIG91dF9w dXQ7Ci0KLQkvKiB3ZSBwaW5uZWQgdGhlIHBvb2wsIG1hcmsgaXQgYXMgc3VjaCAqLwotCWludGVs X2d0X2J1ZmZlcl9wb29sX21hcmtfdXNlZChwb29sKTsKLQotCWNtZCA9IGk5MTVfZ2VtX29iamVj dF9waW5fbWFwKHBvb2wtPm9iaiwgcG9vbC0+dHlwZSk7Ci0JaWYgKElTX0VSUihjbWQpKSB7Ci0J CWVyciA9IFBUUl9FUlIoY21kKTsKLQkJZ290byBvdXRfdW5waW47Ci0JfQotCi0JcmVtID0gc3Jj LT5zaXplOwotCXNyY19vZmZzZXQgPSBzcmMtPm5vZGUuc3RhcnQ7Ci0JZHN0X29mZnNldCA9IGRz dC0+bm9kZS5zdGFydDsKLQotCWRvIHsKLQkJc2l6ZSA9IG1pbl90KHU2NCwgcmVtLCBibG9ja19z aXplKTsKLQkJR0VNX0JVR19PTihzaXplID4+IFBBR0VfU0hJRlQgPiBTMTZfTUFYKTsKLQotCQlp ZiAoR1JBUEhJQ1NfVkVSKGk5MTUpID49IDkgJiYKLQkJICAgICF3YV8xMjA5NjQ0NjExX2FwcGxp ZXMoaTkxNSwgc2l6ZSkpIHsKLQkJCSpjbWQrKyA9IEdFTjlfWFlfRkFTVF9DT1BZX0JMVF9DTUQg fCAoMTAgLSAyKTsKLQkJCSpjbWQrKyA9IEJMVF9ERVBUSF8zMiB8IFBBR0VfU0laRTsKLQkJCSpj bWQrKyA9IDA7Ci0JCQkqY21kKysgPSBzaXplID4+IFBBR0VfU0hJRlQgPDwgMTYgfCBQQUdFX1NJ WkUgLyA0OwotCQkJKmNtZCsrID0gbG93ZXJfMzJfYml0cyhkc3Rfb2Zmc2V0KTsKLQkJCSpjbWQr KyA9IHVwcGVyXzMyX2JpdHMoZHN0X29mZnNldCk7Ci0JCQkqY21kKysgPSAwOwotCQkJKmNtZCsr ID0gUEFHRV9TSVpFOwotCQkJKmNtZCsrID0gbG93ZXJfMzJfYml0cyhzcmNfb2Zmc2V0KTsKLQkJ CSpjbWQrKyA9IHVwcGVyXzMyX2JpdHMoc3JjX29mZnNldCk7Ci0JCX0gZWxzZSBpZiAoR1JBUEhJ Q1NfVkVSKGk5MTUpID49IDgpIHsKLQkJCSpjbWQrKyA9IFhZX1NSQ19DT1BZX0JMVF9DTUQgfCBC TFRfV1JJVEVfUkdCQSB8ICgxMCAtIDIpOwotCQkJKmNtZCsrID0gQkxUX0RFUFRIXzMyIHwgQkxU X1JPUF9TUkNfQ09QWSB8IFBBR0VfU0laRTsKLQkJCSpjbWQrKyA9IDA7Ci0JCQkqY21kKysgPSBz aXplID4+IFBBR0VfU0hJRlQgPDwgMTYgfCBQQUdFX1NJWkUgLyA0OwotCQkJKmNtZCsrID0gbG93 ZXJfMzJfYml0cyhkc3Rfb2Zmc2V0KTsKLQkJCSpjbWQrKyA9IHVwcGVyXzMyX2JpdHMoZHN0X29m ZnNldCk7Ci0JCQkqY21kKysgPSAwOwotCQkJKmNtZCsrID0gUEFHRV9TSVpFOwotCQkJKmNtZCsr ID0gbG93ZXJfMzJfYml0cyhzcmNfb2Zmc2V0KTsKLQkJCSpjbWQrKyA9IHVwcGVyXzMyX2JpdHMo c3JjX29mZnNldCk7Ci0JCX0gZWxzZSB7Ci0JCQkqY21kKysgPSBTUkNfQ09QWV9CTFRfQ01EIHwg QkxUX1dSSVRFX1JHQkEgfCAoNiAtIDIpOwotCQkJKmNtZCsrID0gQkxUX0RFUFRIXzMyIHwgQkxU X1JPUF9TUkNfQ09QWSB8IFBBR0VfU0laRTsKLQkJCSpjbWQrKyA9IHNpemUgPj4gUEFHRV9TSElG VCA8PCAxNiB8IFBBR0VfU0laRTsKLQkJCSpjbWQrKyA9IGRzdF9vZmZzZXQ7Ci0JCQkqY21kKysg PSBQQUdFX1NJWkU7Ci0JCQkqY21kKysgPSBzcmNfb2Zmc2V0OwotCQl9Ci0KLQkJLyogQWxsb3cg b3Vyc2VsdmVzIHRvIGJlIHByZWVtcHRlZCBpbiBiZXR3ZWVuIGJsb2Nrcy4gKi8KLQkJKmNtZCsr ID0gTUlfQVJCX0NIRUNLOwotCi0JCXNyY19vZmZzZXQgKz0gc2l6ZTsKLQkJZHN0X29mZnNldCAr PSBzaXplOwotCQlyZW0gLT0gc2l6ZTsKLQl9IHdoaWxlIChyZW0pOwotCi0JKmNtZCA9IE1JX0JB VENIX0JVRkZFUl9FTkQ7Ci0KLQlpOTE1X2dlbV9vYmplY3RfZmx1c2hfbWFwKHBvb2wtPm9iaik7 Ci0JaTkxNV9nZW1fb2JqZWN0X3VucGluX21hcChwb29sLT5vYmopOwotCi0JaW50ZWxfZ3RfY2hp cHNldF9mbHVzaChjZS0+dm0tPmd0KTsKLQliYXRjaC0+cHJpdmF0ZSA9IHBvb2w7Ci0JcmV0dXJu IGJhdGNoOwotCi1vdXRfdW5waW46Ci0JaTkxNV92bWFfdW5waW4oYmF0Y2gpOwotb3V0X3B1dDoK LQlpbnRlbF9ndF9idWZmZXJfcG9vbF9wdXQocG9vbCk7Ci1vdXRfcG06Ci0JaW50ZWxfZW5naW5l X3BtX3B1dChjZS0+ZW5naW5lKTsKLQlyZXR1cm4gRVJSX1BUUihlcnIpOwotfQotCi1pbnQgaTkx NV9nZW1fb2JqZWN0X2NvcHlfYmx0KHN0cnVjdCBkcm1faTkxNV9nZW1fb2JqZWN0ICpzcmMsCi0J CQkgICAgIHN0cnVjdCBkcm1faTkxNV9nZW1fb2JqZWN0ICpkc3QsCi0JCQkgICAgIHN0cnVjdCBp bnRlbF9jb250ZXh0ICpjZSkKLXsKLQlzdHJ1Y3QgaTkxNV9hZGRyZXNzX3NwYWNlICp2bSA9IGNl LT52bTsKLQlzdHJ1Y3QgaTkxNV92bWEgKnZtYVsyXSwgKmJhdGNoOwotCXN0cnVjdCBpOTE1X2dl bV93d19jdHggd3c7Ci0Jc3RydWN0IGk5MTVfcmVxdWVzdCAqcnE7Ci0JaW50IGVyciwgaTsKLQot CXZtYVswXSA9IGk5MTVfdm1hX2luc3RhbmNlKHNyYywgdm0sIE5VTEwpOwotCWlmIChJU19FUlIo dm1hWzBdKSkKLQkJcmV0dXJuIFBUUl9FUlIodm1hWzBdKTsKLQotCXZtYVsxXSA9IGk5MTVfdm1h X2luc3RhbmNlKGRzdCwgdm0sIE5VTEwpOwotCWlmIChJU19FUlIodm1hWzFdKSkKLQkJcmV0dXJu IFBUUl9FUlIodm1hWzFdKTsKLQotCWk5MTVfZ2VtX3d3X2N0eF9pbml0KCZ3dywgdHJ1ZSk7Ci0J aW50ZWxfZW5naW5lX3BtX2dldChjZS0+ZW5naW5lKTsKLXJldHJ5OgotCWVyciA9IGk5MTVfZ2Vt X29iamVjdF9sb2NrKHNyYywgJnd3KTsKLQlpZiAoIWVycikKLQkJZXJyID0gaTkxNV9nZW1fb2Jq ZWN0X2xvY2soZHN0LCAmd3cpOwotCWlmICghZXJyKQotCQllcnIgPSBpbnRlbF9jb250ZXh0X3Bp bl93dyhjZSwgJnd3KTsKLQlpZiAoZXJyKQotCQlnb3RvIG91dDsKLQotCWVyciA9IGk5MTVfdm1h X3Bpbl93dyh2bWFbMF0sICZ3dywgMCwgMCwgUElOX1VTRVIpOwotCWlmIChlcnIpCi0JCWdvdG8g b3V0X2N0eDsKLQotCWVyciA9IGk5MTVfdm1hX3Bpbl93dyh2bWFbMV0sICZ3dywgMCwgMCwgUElO X1VTRVIpOwotCWlmICh1bmxpa2VseShlcnIpKQotCQlnb3RvIG91dF91bnBpbl9zcmM7Ci0KLQli YXRjaCA9IGludGVsX2VtaXRfdm1hX2NvcHlfYmx0KGNlLCAmd3csIHZtYVswXSwgdm1hWzFdKTsK LQlpZiAoSVNfRVJSKGJhdGNoKSkgewotCQllcnIgPSBQVFJfRVJSKGJhdGNoKTsKLQkJZ290byBv dXRfdW5waW5fZHN0OwotCX0KLQotCXJxID0gaTkxNV9yZXF1ZXN0X2NyZWF0ZShjZSk7Ci0JaWYg KElTX0VSUihycSkpIHsKLQkJZXJyID0gUFRSX0VSUihycSk7Ci0JCWdvdG8gb3V0X2JhdGNoOwot CX0KLQotCWVyciA9IGludGVsX2VtaXRfdm1hX21hcmtfYWN0aXZlKGJhdGNoLCBycSk7Ci0JaWYg KHVubGlrZWx5KGVycikpCi0JCWdvdG8gb3V0X3JlcXVlc3Q7Ci0KLQlmb3IgKGkgPSAwOyBpIDwg QVJSQVlfU0laRSh2bWEpOyBpKyspIHsKLQkJZXJyID0gbW92ZV9vYmpfdG9fZ3B1KHZtYVtpXS0+ b2JqLCBycSwgaSk7Ci0JCWlmICh1bmxpa2VseShlcnIpKQotCQkJZ290byBvdXRfcmVxdWVzdDsK LQl9Ci0KLQlmb3IgKGkgPSAwOyBpIDwgQVJSQVlfU0laRSh2bWEpOyBpKyspIHsKLQkJdW5zaWdu ZWQgaW50IGZsYWdzID0gaSA/IEVYRUNfT0JKRUNUX1dSSVRFIDogMDsKLQotCQllcnIgPSBpOTE1 X3ZtYV9tb3ZlX3RvX2FjdGl2ZSh2bWFbaV0sIHJxLCBmbGFncyk7Ci0JCWlmICh1bmxpa2VseShl cnIpKQotCQkJZ290byBvdXRfcmVxdWVzdDsKLQl9Ci0KLQlpZiAocnEtPmVuZ2luZS0+ZW1pdF9p bml0X2JyZWFkY3J1bWIpIHsKLQkJZXJyID0gcnEtPmVuZ2luZS0+ZW1pdF9pbml0X2JyZWFkY3J1 bWIocnEpOwotCQlpZiAodW5saWtlbHkoZXJyKSkKLQkJCWdvdG8gb3V0X3JlcXVlc3Q7Ci0JfQot Ci0JZXJyID0gcnEtPmVuZ2luZS0+ZW1pdF9iYl9zdGFydChycSwKLQkJCQkJYmF0Y2gtPm5vZGUu c3RhcnQsIGJhdGNoLT5ub2RlLnNpemUsCi0JCQkJCTApOwotCi1vdXRfcmVxdWVzdDoKLQlpZiAo dW5saWtlbHkoZXJyKSkKLQkJaTkxNV9yZXF1ZXN0X3NldF9lcnJvcl9vbmNlKHJxLCBlcnIpOwot Ci0JaTkxNV9yZXF1ZXN0X2FkZChycSk7Ci1vdXRfYmF0Y2g6Ci0JaW50ZWxfZW1pdF92bWFfcmVs ZWFzZShjZSwgYmF0Y2gpOwotb3V0X3VucGluX2RzdDoKLQlpOTE1X3ZtYV91bnBpbih2bWFbMV0p Owotb3V0X3VucGluX3NyYzoKLQlpOTE1X3ZtYV91bnBpbih2bWFbMF0pOwotb3V0X2N0eDoKLQlp bnRlbF9jb250ZXh0X3VucGluKGNlKTsKLW91dDoKLQlpZiAoZXJyID09IC1FREVBRExLKSB7Ci0J CWVyciA9IGk5MTVfZ2VtX3d3X2N0eF9iYWNrb2ZmKCZ3dyk7Ci0JCWlmICghZXJyKQotCQkJZ290 byByZXRyeTsKLQl9Ci0JaTkxNV9nZW1fd3dfY3R4X2ZpbmkoJnd3KTsKLQlpbnRlbF9lbmdpbmVf cG1fcHV0KGNlLT5lbmdpbmUpOwotCXJldHVybiBlcnI7Ci19Ci0KLSNpZiBJU19FTkFCTEVEKENP TkZJR19EUk1fSTkxNV9TRUxGVEVTVCkKLSNpbmNsdWRlICJzZWxmdGVzdHMvaTkxNV9nZW1fb2Jq ZWN0X2JsdC5jIgotI2VuZGlmCmRpZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9kcm0vaTkxNS9nZW0v aTkxNV9nZW1fb2JqZWN0X2JsdC5oIGIvZHJpdmVycy9ncHUvZHJtL2k5MTUvZ2VtL2k5MTVfZ2Vt X29iamVjdF9ibHQuaApkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMjQwOWZkY2NjZjBl Li4wMDAwMDAwMDAwMDAKLS0tIGEvZHJpdmVycy9ncHUvZHJtL2k5MTUvZ2VtL2k5MTVfZ2VtX29i amVjdF9ibHQuaAorKysgL2Rldi9udWxsCkBAIC0xLDM5ICswLDAgQEAKLS8qIFNQRFgtTGljZW5z ZS1JZGVudGlmaWVyOiBNSVQgKi8KLS8qCi0gKiBDb3B5cmlnaHQgwqkgMjAxOSBJbnRlbCBDb3Jw b3JhdGlvbgotICovCi0KLSNpZm5kZWYgX19JOTE1X0dFTV9PQkpFQ1RfQkxUX0hfXwotI2RlZmlu ZSBfX0k5MTVfR0VNX09CSkVDVF9CTFRfSF9fCi0KLSNpbmNsdWRlIDxsaW51eC90eXBlcy5oPgot Ci0jaW5jbHVkZSAiZ3QvaW50ZWxfY29udGV4dC5oIgotI2luY2x1ZGUgImd0L2ludGVsX2VuZ2lu ZV9wbS5oIgotI2luY2x1ZGUgImk5MTVfdm1hLmgiCi0KLXN0cnVjdCBkcm1faTkxNV9nZW1fb2Jq ZWN0Owotc3RydWN0IGk5MTVfZ2VtX3d3X2N0eDsKLQotc3RydWN0IGk5MTVfdm1hICppbnRlbF9l bWl0X3ZtYV9maWxsX2JsdChzdHJ1Y3QgaW50ZWxfY29udGV4dCAqY2UsCi0JCQkJCSBzdHJ1Y3Qg aTkxNV92bWEgKnZtYSwKLQkJCQkJIHN0cnVjdCBpOTE1X2dlbV93d19jdHggKnd3LAotCQkJCQkg dTMyIHZhbHVlKTsKLQotc3RydWN0IGk5MTVfdm1hICppbnRlbF9lbWl0X3ZtYV9jb3B5X2JsdChz dHJ1Y3QgaW50ZWxfY29udGV4dCAqY2UsCi0JCQkJCSBzdHJ1Y3QgaTkxNV9nZW1fd3dfY3R4ICp3 dywKLQkJCQkJIHN0cnVjdCBpOTE1X3ZtYSAqc3JjLAotCQkJCQkgc3RydWN0IGk5MTVfdm1hICpk c3QpOwotCi1pbnQgaW50ZWxfZW1pdF92bWFfbWFya19hY3RpdmUoc3RydWN0IGk5MTVfdm1hICp2 bWEsIHN0cnVjdCBpOTE1X3JlcXVlc3QgKnJxKTsKLXZvaWQgaW50ZWxfZW1pdF92bWFfcmVsZWFz ZShzdHJ1Y3QgaW50ZWxfY29udGV4dCAqY2UsIHN0cnVjdCBpOTE1X3ZtYSAqdm1hKTsKLQotaW50 IGk5MTVfZ2VtX29iamVjdF9maWxsX2JsdChzdHJ1Y3QgZHJtX2k5MTVfZ2VtX29iamVjdCAqb2Jq LAotCQkJICAgICBzdHJ1Y3QgaW50ZWxfY29udGV4dCAqY2UsCi0JCQkgICAgIHUzMiB2YWx1ZSk7 Ci0KLWludCBpOTE1X2dlbV9vYmplY3RfY29weV9ibHQoc3RydWN0IGRybV9pOTE1X2dlbV9vYmpl Y3QgKnNyYywKLQkJCSAgICAgc3RydWN0IGRybV9pOTE1X2dlbV9vYmplY3QgKmRzdCwKLQkJCSAg ICAgc3RydWN0IGludGVsX2NvbnRleHQgKmNlKTsKLQotI2VuZGlmCmRpZmYgLS1naXQgYS9kcml2 ZXJzL2dwdS9kcm0vaTkxNS9nZW0vc2VsZnRlc3RzL2k5MTVfZ2VtX29iamVjdF9ibHQuYyBiL2Ry aXZlcnMvZ3B1L2RybS9pOTE1L2dlbS9zZWxmdGVzdHMvaTkxNV9nZW1fb2JqZWN0X2JsdC5jCmRl bGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCA4YzMzNWQxYTg0MDYuLjAwMDAwMDAwMDAwMAot LS0gYS9kcml2ZXJzL2dwdS9kcm0vaTkxNS9nZW0vc2VsZnRlc3RzL2k5MTVfZ2VtX29iamVjdF9i bHQuYworKysgL2Rldi9udWxsCkBAIC0xLDU5NyArMCwwIEBACi0vLyBTUERYLUxpY2Vuc2UtSWRl bnRpZmllcjogTUlUCi0vKgotICogQ29weXJpZ2h0IMKpIDIwMTkgSW50ZWwgQ29ycG9yYXRpb24K LSAqLwotCi0jaW5jbHVkZSA8bGludXgvc29ydC5oPgotCi0jaW5jbHVkZSAiZ3QvaW50ZWxfZ3Qu aCIKLSNpbmNsdWRlICJndC9pbnRlbF9lbmdpbmVfdXNlci5oIgotCi0jaW5jbHVkZSAiaTkxNV9z ZWxmdGVzdC5oIgotCi0jaW5jbHVkZSAiZ2VtL2k5MTVfZ2VtX2NvbnRleHQuaCIKLSNpbmNsdWRl ICJzZWxmdGVzdHMvaWd0X2ZsdXNoX3Rlc3QuaCIKLSNpbmNsdWRlICJzZWxmdGVzdHMvaTkxNV9y YW5kb20uaCIKLSNpbmNsdWRlICJzZWxmdGVzdHMvbW9ja19kcm0uaCIKLSNpbmNsdWRlICJodWdl X2dlbV9vYmplY3QuaCIKLSNpbmNsdWRlICJtb2NrX2NvbnRleHQuaCIKLQotc3RhdGljIGludCB3 cmFwX2t0aW1lX2NvbXBhcmUoY29uc3Qgdm9pZCAqQSwgY29uc3Qgdm9pZCAqQikKLXsKLQljb25z dCBrdGltZV90ICphID0gQSwgKmIgPSBCOwotCi0JcmV0dXJuIGt0aW1lX2NvbXBhcmUoKmEsICpi KTsKLX0KLQotc3RhdGljIGludCBfX3BlcmZfZmlsbF9ibHQoc3RydWN0IGRybV9pOTE1X2dlbV9v YmplY3QgKm9iaikKLXsKLQlzdHJ1Y3QgZHJtX2k5MTVfcHJpdmF0ZSAqaTkxNSA9IHRvX2k5MTUo b2JqLT5iYXNlLmRldik7Ci0JaW50IGluc3QgPSAwOwotCi0JZG8gewotCQlzdHJ1Y3QgaW50ZWxf ZW5naW5lX2NzICplbmdpbmU7Ci0JCWt0aW1lX3QgdFs1XTsKLQkJaW50IHBhc3M7Ci0JCWludCBl cnI7Ci0KLQkJZW5naW5lID0gaW50ZWxfZW5naW5lX2xvb2t1cF91c2VyKGk5MTUsCi0JCQkJCQkg IEk5MTVfRU5HSU5FX0NMQVNTX0NPUFksCi0JCQkJCQkgIGluc3QrKyk7Ci0JCWlmICghZW5naW5l KQotCQkJcmV0dXJuIDA7Ci0KLQkJaW50ZWxfZW5naW5lX3BtX2dldChlbmdpbmUpOwotCQlmb3Ig KHBhc3MgPSAwOyBwYXNzIDwgQVJSQVlfU0laRSh0KTsgcGFzcysrKSB7Ci0JCQlzdHJ1Y3QgaW50 ZWxfY29udGV4dCAqY2UgPSBlbmdpbmUtPmtlcm5lbF9jb250ZXh0OwotCQkJa3RpbWVfdCB0MCwg dDE7Ci0KLQkJCXQwID0ga3RpbWVfZ2V0KCk7Ci0KLQkJCWVyciA9IGk5MTVfZ2VtX29iamVjdF9m aWxsX2JsdChvYmosIGNlLCAwKTsKLQkJCWlmIChlcnIpCi0JCQkJYnJlYWs7Ci0KLQkJCWVyciA9 IGk5MTVfZ2VtX29iamVjdF93YWl0KG9iaiwKLQkJCQkJCSAgIEk5MTVfV0FJVF9BTEwsCi0JCQkJ CQkgICBNQVhfU0NIRURVTEVfVElNRU9VVCk7Ci0JCQlpZiAoZXJyKQotCQkJCWJyZWFrOwotCi0J CQl0MSA9IGt0aW1lX2dldCgpOwotCQkJdFtwYXNzXSA9IGt0aW1lX3N1Yih0MSwgdDApOwotCQl9 Ci0JCWludGVsX2VuZ2luZV9wbV9wdXQoZW5naW5lKTsKLQkJaWYgKGVycikKLQkJCXJldHVybiBl cnI7Ci0KLQkJc29ydCh0LCBBUlJBWV9TSVpFKHQpLCBzaXplb2YoKnQpLCB3cmFwX2t0aW1lX2Nv bXBhcmUsIE5VTEwpOwotCQlwcl9pbmZvKCIlczogYmx0ICV6ZCBLaUIgZmlsbDogJWxsZCBNaUIv c1xuIiwKLQkJCWVuZ2luZS0+bmFtZSwKLQkJCW9iai0+YmFzZS5zaXplID4+IDEwLAotCQkJZGl2 NjRfdTY0KG11bF91MzJfdTMyKDQgKiBvYmotPmJhc2Uuc2l6ZSwKLQkJCQkJICAgICAgMTAwMCAq IDEwMDAgKiAxMDAwKSwKLQkJCQkgIHRbMV0gKyAyICogdFsyXSArIHRbM10pID4+IDIwKTsKLQl9 IHdoaWxlICgxKTsKLX0KLQotc3RhdGljIGludCBwZXJmX2ZpbGxfYmx0KHZvaWQgKmFyZykKLXsK LQlzdHJ1Y3QgZHJtX2k5MTVfcHJpdmF0ZSAqaTkxNSA9IGFyZzsKLQlzdGF0aWMgY29uc3QgdW5z aWduZWQgbG9uZyBzaXplc1tdID0gewotCQlTWl80SywKLQkJU1pfNjRLLAotCQlTWl8yTSwKLQkJ U1pfNjRNCi0JfTsKLQlpbnQgaTsKLQotCWZvciAoaSA9IDA7IGkgPCBBUlJBWV9TSVpFKHNpemVz KTsgaSsrKSB7Ci0JCXN0cnVjdCBkcm1faTkxNV9nZW1fb2JqZWN0ICpvYmo7Ci0JCWludCBlcnI7 Ci0KLQkJb2JqID0gaTkxNV9nZW1fb2JqZWN0X2NyZWF0ZV9pbnRlcm5hbChpOTE1LCBzaXplc1tp XSk7Ci0JCWlmIChJU19FUlIob2JqKSkKLQkJCXJldHVybiBQVFJfRVJSKG9iaik7Ci0KLQkJZXJy ID0gX19wZXJmX2ZpbGxfYmx0KG9iaik7Ci0JCWk5MTVfZ2VtX29iamVjdF9wdXQob2JqKTsKLQkJ aWYgKGVycikKLQkJCXJldHVybiBlcnI7Ci0JfQotCi0JcmV0dXJuIDA7Ci19Ci0KLXN0YXRpYyBp bnQgX19wZXJmX2NvcHlfYmx0KHN0cnVjdCBkcm1faTkxNV9nZW1fb2JqZWN0ICpzcmMsCi0JCQkg ICBzdHJ1Y3QgZHJtX2k5MTVfZ2VtX29iamVjdCAqZHN0KQotewotCXN0cnVjdCBkcm1faTkxNV9w cml2YXRlICppOTE1ID0gdG9faTkxNShzcmMtPmJhc2UuZGV2KTsKLQlpbnQgaW5zdCA9IDA7Ci0K LQlkbyB7Ci0JCXN0cnVjdCBpbnRlbF9lbmdpbmVfY3MgKmVuZ2luZTsKLQkJa3RpbWVfdCB0WzVd OwotCQlpbnQgcGFzczsKLQkJaW50IGVyciA9IDA7Ci0KLQkJZW5naW5lID0gaW50ZWxfZW5naW5l X2xvb2t1cF91c2VyKGk5MTUsCi0JCQkJCQkgIEk5MTVfRU5HSU5FX0NMQVNTX0NPUFksCi0JCQkJ CQkgIGluc3QrKyk7Ci0JCWlmICghZW5naW5lKQotCQkJcmV0dXJuIDA7Ci0KLQkJaW50ZWxfZW5n aW5lX3BtX2dldChlbmdpbmUpOwotCQlmb3IgKHBhc3MgPSAwOyBwYXNzIDwgQVJSQVlfU0laRSh0 KTsgcGFzcysrKSB7Ci0JCQlzdHJ1Y3QgaW50ZWxfY29udGV4dCAqY2UgPSBlbmdpbmUtPmtlcm5l bF9jb250ZXh0OwotCQkJa3RpbWVfdCB0MCwgdDE7Ci0KLQkJCXQwID0ga3RpbWVfZ2V0KCk7Ci0K LQkJCWVyciA9IGk5MTVfZ2VtX29iamVjdF9jb3B5X2JsdChzcmMsIGRzdCwgY2UpOwotCQkJaWYg KGVycikKLQkJCQlicmVhazsKLQotCQkJZXJyID0gaTkxNV9nZW1fb2JqZWN0X3dhaXQoZHN0LAot CQkJCQkJICAgSTkxNV9XQUlUX0FMTCwKLQkJCQkJCSAgIE1BWF9TQ0hFRFVMRV9USU1FT1VUKTsK LQkJCWlmIChlcnIpCi0JCQkJYnJlYWs7Ci0KLQkJCXQxID0ga3RpbWVfZ2V0KCk7Ci0JCQl0W3Bh c3NdID0ga3RpbWVfc3ViKHQxLCB0MCk7Ci0JCX0KLQkJaW50ZWxfZW5naW5lX3BtX3B1dChlbmdp bmUpOwotCQlpZiAoZXJyKQotCQkJcmV0dXJuIGVycjsKLQotCQlzb3J0KHQsIEFSUkFZX1NJWkUo dCksIHNpemVvZigqdCksIHdyYXBfa3RpbWVfY29tcGFyZSwgTlVMTCk7Ci0JCXByX2luZm8oIiVz OiBibHQgJXpkIEtpQiBjb3B5OiAlbGxkIE1pQi9zXG4iLAotCQkJZW5naW5lLT5uYW1lLAotCQkJ c3JjLT5iYXNlLnNpemUgPj4gMTAsCi0JCQlkaXY2NF91NjQobXVsX3UzMl91MzIoNCAqIHNyYy0+ YmFzZS5zaXplLAotCQkJCQkgICAgICAxMDAwICogMTAwMCAqIDEwMDApLAotCQkJCSAgdFsxXSAr IDIgKiB0WzJdICsgdFszXSkgPj4gMjApOwotCX0gd2hpbGUgKDEpOwotfQotCi1zdGF0aWMgaW50 IHBlcmZfY29weV9ibHQodm9pZCAqYXJnKQotewotCXN0cnVjdCBkcm1faTkxNV9wcml2YXRlICpp OTE1ID0gYXJnOwotCXN0YXRpYyBjb25zdCB1bnNpZ25lZCBsb25nIHNpemVzW10gPSB7Ci0JCVNa XzRLLAotCQlTWl82NEssCi0JCVNaXzJNLAotCQlTWl82NE0KLQl9OwotCWludCBpOwotCi0JZm9y IChpID0gMDsgaSA8IEFSUkFZX1NJWkUoc2l6ZXMpOyBpKyspIHsKLQkJc3RydWN0IGRybV9pOTE1 X2dlbV9vYmplY3QgKnNyYywgKmRzdDsKLQkJaW50IGVycjsKLQotCQlzcmMgPSBpOTE1X2dlbV9v YmplY3RfY3JlYXRlX2ludGVybmFsKGk5MTUsIHNpemVzW2ldKTsKLQkJaWYgKElTX0VSUihzcmMp KQotCQkJcmV0dXJuIFBUUl9FUlIoc3JjKTsKLQotCQlkc3QgPSBpOTE1X2dlbV9vYmplY3RfY3Jl YXRlX2ludGVybmFsKGk5MTUsIHNpemVzW2ldKTsKLQkJaWYgKElTX0VSUihkc3QpKSB7Ci0JCQll cnIgPSBQVFJfRVJSKGRzdCk7Ci0JCQlnb3RvIGVycl9zcmM7Ci0JCX0KLQotCQllcnIgPSBfX3Bl cmZfY29weV9ibHQoc3JjLCBkc3QpOwotCi0JCWk5MTVfZ2VtX29iamVjdF9wdXQoZHN0KTsKLWVy cl9zcmM6Ci0JCWk5MTVfZ2VtX29iamVjdF9wdXQoc3JjKTsKLQkJaWYgKGVycikKLQkJCXJldHVy biBlcnI7Ci0JfQotCi0JcmV0dXJuIDA7Ci19Ci0KLXN0cnVjdCBpZ3RfdGhyZWFkX2FyZyB7Ci0J c3RydWN0IGludGVsX2VuZ2luZV9jcyAqZW5naW5lOwotCXN0cnVjdCBpOTE1X2dlbV9jb250ZXh0 ICpjdHg7Ci0Jc3RydWN0IGZpbGUgKmZpbGU7Ci0Jc3RydWN0IHJuZF9zdGF0ZSBwcm5nOwotCXVu c2lnbmVkIGludCBuX2NwdXM7Ci19OwotCi1zdGF0aWMgaW50IGlndF9maWxsX2JsdF90aHJlYWQo dm9pZCAqYXJnKQotewotCXN0cnVjdCBpZ3RfdGhyZWFkX2FyZyAqdGhyZWFkID0gYXJnOwotCXN0 cnVjdCBpbnRlbF9lbmdpbmVfY3MgKmVuZ2luZSA9IHRocmVhZC0+ZW5naW5lOwotCXN0cnVjdCBy bmRfc3RhdGUgKnBybmcgPSAmdGhyZWFkLT5wcm5nOwotCXN0cnVjdCBkcm1faTkxNV9nZW1fb2Jq ZWN0ICpvYmo7Ci0Jc3RydWN0IGk5MTVfZ2VtX2NvbnRleHQgKmN0eDsKLQlzdHJ1Y3QgaW50ZWxf Y29udGV4dCAqY2U7Ci0JdW5zaWduZWQgaW50IHByaW87Ci0JSUdUX1RJTUVPVVQoZW5kKTsKLQl1 NjQgdG90YWwsIG1heDsKLQlpbnQgZXJyOwotCi0JY3R4ID0gdGhyZWFkLT5jdHg7Ci0JaWYgKCFj dHgpIHsKLQkJY3R4ID0gbGl2ZV9jb250ZXh0X2Zvcl9lbmdpbmUoZW5naW5lLCB0aHJlYWQtPmZp bGUpOwotCQlpZiAoSVNfRVJSKGN0eCkpCi0JCQlyZXR1cm4gUFRSX0VSUihjdHgpOwotCi0JCXBy aW8gPSBpOTE1X3ByYW5kb21fdTMyX21heF9zdGF0ZShJOTE1X1BSSU9SSVRZX01BWCwgcHJuZyk7 Ci0JCWN0eC0+c2NoZWQucHJpb3JpdHkgPSBwcmlvOwotCX0KLQotCWNlID0gaTkxNV9nZW1fY29u dGV4dF9nZXRfZW5naW5lKGN0eCwgMCk7Ci0JR0VNX0JVR19PTihJU19FUlIoY2UpKTsKLQotCS8q Ci0JICogSWYgd2UgaGF2ZSBhIHRpbnkgc2hhcmVkIGFkZHJlc3Mgc3BhY2UsIGxpa2UgZm9yIHRo ZSBHR1RUCi0JICogdGhlbiB3ZSBjYW4ndCBiZSB0b28gZ3JlZWR5LgotCSAqLwotCW1heCA9IGNl LT52bS0+dG90YWw7Ci0JaWYgKGk5MTVfaXNfZ2d0dChjZS0+dm0pIHx8IHRocmVhZC0+Y3R4KQot CQltYXggPSBkaXZfdTY0KG1heCwgdGhyZWFkLT5uX2NwdXMpOwotCW1heCA+Pj0gNDsKLQotCXRv dGFsID0gUEFHRV9TSVpFOwotCWRvIHsKLQkJLyogQWltIHRvIGtlZXAgdGhlIHJ1bnRpbWUgdW5k ZXIgcmVhc29uYWJsZSBib3VuZHMhICovCi0JCWNvbnN0IHUzMiBtYXhfcGh5c19zaXplID0gU1pf NjRLOwotCQl1MzIgdmFsID0gcHJhbmRvbV91MzJfc3RhdGUocHJuZyk7Ci0JCXUzMiBwaHlzX3N6 OwotCQl1MzIgc3o7Ci0JCXUzMiAqdmFkZHI7Ci0JCXUzMiBpOwotCi0JCXRvdGFsID0gbWluKHRv dGFsLCBtYXgpOwotCQlzeiA9IGk5MTVfcHJhbmRvbV91MzJfbWF4X3N0YXRlKHRvdGFsLCBwcm5n KSArIDE7Ci0JCXBoeXNfc3ogPSBzeiAlIG1heF9waHlzX3NpemUgKyAxOwotCi0JCXN6ID0gcm91 bmRfdXAoc3osIFBBR0VfU0laRSk7Ci0JCXBoeXNfc3ogPSByb3VuZF91cChwaHlzX3N6LCBQQUdF X1NJWkUpOwotCQlwaHlzX3N6ID0gbWluKHBoeXNfc3osIHN6KTsKLQotCQlwcl9kZWJ1ZygiJXMg d2l0aCBwaHlzX3N6PSAleCwgc3o9JXgsIHZhbD0leFxuIiwgX19mdW5jX18sCi0JCQkgcGh5c19z eiwgc3osIHZhbCk7Ci0KLQkJb2JqID0gaHVnZV9nZW1fb2JqZWN0KGVuZ2luZS0+aTkxNSwgcGh5 c19zeiwgc3opOwotCQlpZiAoSVNfRVJSKG9iaikpIHsKLQkJCWVyciA9IFBUUl9FUlIob2JqKTsK LQkJCWdvdG8gZXJyX2ZsdXNoOwotCQl9Ci0KLQkJdmFkZHIgPSBpOTE1X2dlbV9vYmplY3RfcGlu X21hcF91bmxvY2tlZChvYmosIEk5MTVfTUFQX1dCKTsKLQkJaWYgKElTX0VSUih2YWRkcikpIHsK LQkJCWVyciA9IFBUUl9FUlIodmFkZHIpOwotCQkJZ290byBlcnJfcHV0OwotCQl9Ci0KLQkJLyoK LQkJICogTWFrZSBzdXJlIHRoZSBwb3RlbnRpYWxseSBhc3luYyBjbGZsdXNoIGRvZXMgaXRzIGpv YiwgaWYKLQkJICogcmVxdWlyZWQuCi0JCSAqLwotCQltZW1zZXQzMih2YWRkciwgdmFsIF4gMHhk ZWFkYmVhZiwKLQkJCSBodWdlX2dlbV9vYmplY3RfcGh5c19zaXplKG9iaikgLyBzaXplb2YodTMy KSk7Ci0KLQkJaWYgKCEob2JqLT5jYWNoZV9jb2hlcmVudCAmIEk5MTVfQk9fQ0FDSEVfQ09IRVJF TlRfRk9SX1dSSVRFKSkKLQkJCW9iai0+Y2FjaGVfZGlydHkgPSB0cnVlOwotCi0JCWVyciA9IGk5 MTVfZ2VtX29iamVjdF9maWxsX2JsdChvYmosIGNlLCB2YWwpOwotCQlpZiAoZXJyKQotCQkJZ290 byBlcnJfdW5waW47Ci0KLQkJZXJyID0gaTkxNV9nZW1fb2JqZWN0X3dhaXQob2JqLCAwLCBNQVhf U0NIRURVTEVfVElNRU9VVCk7Ci0JCWlmIChlcnIpCi0JCQlnb3RvIGVycl91bnBpbjsKLQotCQlm b3IgKGkgPSAwOyBpIDwgaHVnZV9nZW1fb2JqZWN0X3BoeXNfc2l6ZShvYmopIC8gc2l6ZW9mKHUz Mik7IGkgKz0gMTcpIHsKLQkJCWlmICghKG9iai0+Y2FjaGVfY29oZXJlbnQgJiBJOTE1X0JPX0NB Q0hFX0NPSEVSRU5UX0ZPUl9SRUFEKSkKLQkJCQlkcm1fY2xmbHVzaF92aXJ0X3JhbmdlKCZ2YWRk cltpXSwgc2l6ZW9mKHZhZGRyW2ldKSk7Ci0KLQkJCWlmICh2YWRkcltpXSAhPSB2YWwpIHsKLQkJ CQlwcl9lcnIoInZhZGRyWyV1XT0leCwgZXhwZWN0ZWQ9JXhcbiIsIGksCi0JCQkJICAgICAgIHZh ZGRyW2ldLCB2YWwpOwotCQkJCWVyciA9IC1FSU5WQUw7Ci0JCQkJZ290byBlcnJfdW5waW47Ci0J CQl9Ci0JCX0KLQotCQlpOTE1X2dlbV9vYmplY3RfdW5waW5fbWFwKG9iaik7Ci0JCWk5MTVfZ2Vt X29iamVjdF9wdXQob2JqKTsKLQotCQl0b3RhbCA8PD0gMTsKLQl9IHdoaWxlICghdGltZV9hZnRl cihqaWZmaWVzLCBlbmQpKTsKLQotCWdvdG8gZXJyX2ZsdXNoOwotCi1lcnJfdW5waW46Ci0JaTkx NV9nZW1fb2JqZWN0X3VucGluX21hcChvYmopOwotZXJyX3B1dDoKLQlpOTE1X2dlbV9vYmplY3Rf cHV0KG9iaik7Ci1lcnJfZmx1c2g6Ci0JaWYgKGVyciA9PSAtRU5PTUVNKQotCQllcnIgPSAwOwot Ci0JaW50ZWxfY29udGV4dF9wdXQoY2UpOwotCXJldHVybiBlcnI7Ci19Ci0KLXN0YXRpYyBpbnQg aWd0X2NvcHlfYmx0X3RocmVhZCh2b2lkICphcmcpCi17Ci0Jc3RydWN0IGlndF90aHJlYWRfYXJn ICp0aHJlYWQgPSBhcmc7Ci0Jc3RydWN0IGludGVsX2VuZ2luZV9jcyAqZW5naW5lID0gdGhyZWFk LT5lbmdpbmU7Ci0Jc3RydWN0IHJuZF9zdGF0ZSAqcHJuZyA9ICZ0aHJlYWQtPnBybmc7Ci0Jc3Ry dWN0IGRybV9pOTE1X2dlbV9vYmplY3QgKnNyYywgKmRzdDsKLQlzdHJ1Y3QgaTkxNV9nZW1fY29u dGV4dCAqY3R4OwotCXN0cnVjdCBpbnRlbF9jb250ZXh0ICpjZTsKLQl1bnNpZ25lZCBpbnQgcHJp bzsKLQlJR1RfVElNRU9VVChlbmQpOwotCXU2NCB0b3RhbCwgbWF4OwotCWludCBlcnI7Ci0KLQlj dHggPSB0aHJlYWQtPmN0eDsKLQlpZiAoIWN0eCkgewotCQljdHggPSBsaXZlX2NvbnRleHRfZm9y X2VuZ2luZShlbmdpbmUsIHRocmVhZC0+ZmlsZSk7Ci0JCWlmIChJU19FUlIoY3R4KSkKLQkJCXJl dHVybiBQVFJfRVJSKGN0eCk7Ci0KLQkJcHJpbyA9IGk5MTVfcHJhbmRvbV91MzJfbWF4X3N0YXRl KEk5MTVfUFJJT1JJVFlfTUFYLCBwcm5nKTsKLQkJY3R4LT5zY2hlZC5wcmlvcml0eSA9IHByaW87 Ci0JfQotCi0JY2UgPSBpOTE1X2dlbV9jb250ZXh0X2dldF9lbmdpbmUoY3R4LCAwKTsKLQlHRU1f QlVHX09OKElTX0VSUihjZSkpOwotCi0JLyoKLQkgKiBJZiB3ZSBoYXZlIGEgdGlueSBzaGFyZWQg YWRkcmVzcyBzcGFjZSwgbGlrZSBmb3IgdGhlIEdHVFQKLQkgKiB0aGVuIHdlIGNhbid0IGJlIHRv byBncmVlZHkuCi0JICovCi0JbWF4ID0gY2UtPnZtLT50b3RhbDsKLQlpZiAoaTkxNV9pc19nZ3R0 KGNlLT52bSkgfHwgdGhyZWFkLT5jdHgpCi0JCW1heCA9IGRpdl91NjQobWF4LCB0aHJlYWQtPm5f Y3B1cyk7Ci0JbWF4ID4+PSA0OwotCi0JdG90YWwgPSBQQUdFX1NJWkU7Ci0JZG8gewotCQkvKiBB aW0gdG8ga2VlcCB0aGUgcnVudGltZSB1bmRlciByZWFzb25hYmxlIGJvdW5kcyEgKi8KLQkJY29u c3QgdTMyIG1heF9waHlzX3NpemUgPSBTWl82NEs7Ci0JCXUzMiB2YWwgPSBwcmFuZG9tX3UzMl9z dGF0ZShwcm5nKTsKLQkJdTMyIHBoeXNfc3o7Ci0JCXUzMiBzejsKLQkJdTMyICp2YWRkcjsKLQkJ dTMyIGk7Ci0KLQkJdG90YWwgPSBtaW4odG90YWwsIG1heCk7Ci0JCXN6ID0gaTkxNV9wcmFuZG9t X3UzMl9tYXhfc3RhdGUodG90YWwsIHBybmcpICsgMTsKLQkJcGh5c19zeiA9IHN6ICUgbWF4X3Bo eXNfc2l6ZSArIDE7Ci0KLQkJc3ogPSByb3VuZF91cChzeiwgUEFHRV9TSVpFKTsKLQkJcGh5c19z eiA9IHJvdW5kX3VwKHBoeXNfc3osIFBBR0VfU0laRSk7Ci0JCXBoeXNfc3ogPSBtaW4ocGh5c19z eiwgc3opOwotCi0JCXByX2RlYnVnKCIlcyB3aXRoIHBoeXNfc3o9ICV4LCBzej0leCwgdmFsPSV4 XG4iLCBfX2Z1bmNfXywKLQkJCSBwaHlzX3N6LCBzeiwgdmFsKTsKLQotCQlzcmMgPSBodWdlX2dl bV9vYmplY3QoZW5naW5lLT5pOTE1LCBwaHlzX3N6LCBzeik7Ci0JCWlmIChJU19FUlIoc3JjKSkg ewotCQkJZXJyID0gUFRSX0VSUihzcmMpOwotCQkJZ290byBlcnJfZmx1c2g7Ci0JCX0KLQotCQl2 YWRkciA9IGk5MTVfZ2VtX29iamVjdF9waW5fbWFwX3VubG9ja2VkKHNyYywgSTkxNV9NQVBfV0Ip OwotCQlpZiAoSVNfRVJSKHZhZGRyKSkgewotCQkJZXJyID0gUFRSX0VSUih2YWRkcik7Ci0JCQln b3RvIGVycl9wdXRfc3JjOwotCQl9Ci0KLQkJbWVtc2V0MzIodmFkZHIsIHZhbCwKLQkJCSBodWdl X2dlbV9vYmplY3RfcGh5c19zaXplKHNyYykgLyBzaXplb2YodTMyKSk7Ci0KLQkJaTkxNV9nZW1f b2JqZWN0X3VucGluX21hcChzcmMpOwotCi0JCWlmICghKHNyYy0+Y2FjaGVfY29oZXJlbnQgJiBJ OTE1X0JPX0NBQ0hFX0NPSEVSRU5UX0ZPUl9SRUFEKSkKLQkJCXNyYy0+Y2FjaGVfZGlydHkgPSB0 cnVlOwotCi0JCWRzdCA9IGh1Z2VfZ2VtX29iamVjdChlbmdpbmUtPmk5MTUsIHBoeXNfc3osIHN6 KTsKLQkJaWYgKElTX0VSUihkc3QpKSB7Ci0JCQllcnIgPSBQVFJfRVJSKGRzdCk7Ci0JCQlnb3Rv IGVycl9wdXRfc3JjOwotCQl9Ci0KLQkJdmFkZHIgPSBpOTE1X2dlbV9vYmplY3RfcGluX21hcF91 bmxvY2tlZChkc3QsIEk5MTVfTUFQX1dCKTsKLQkJaWYgKElTX0VSUih2YWRkcikpIHsKLQkJCWVy ciA9IFBUUl9FUlIodmFkZHIpOwotCQkJZ290byBlcnJfcHV0X2RzdDsKLQkJfQotCi0JCW1lbXNl dDMyKHZhZGRyLCB2YWwgXiAweGRlYWRiZWFmLAotCQkJIGh1Z2VfZ2VtX29iamVjdF9waHlzX3Np emUoZHN0KSAvIHNpemVvZih1MzIpKTsKLQotCQlpZiAoIShkc3QtPmNhY2hlX2NvaGVyZW50ICYg STkxNV9CT19DQUNIRV9DT0hFUkVOVF9GT1JfV1JJVEUpKQotCQkJZHN0LT5jYWNoZV9kaXJ0eSA9 IHRydWU7Ci0KLQkJZXJyID0gaTkxNV9nZW1fb2JqZWN0X2NvcHlfYmx0KHNyYywgZHN0LCBjZSk7 Ci0JCWlmIChlcnIpCi0JCQlnb3RvIGVycl91bnBpbjsKLQotCQllcnIgPSBpOTE1X2dlbV9vYmpl Y3Rfd2FpdChkc3QsIDAsIE1BWF9TQ0hFRFVMRV9USU1FT1VUKTsKLQkJaWYgKGVycikKLQkJCWdv dG8gZXJyX3VucGluOwotCi0JCWZvciAoaSA9IDA7IGkgPCBodWdlX2dlbV9vYmplY3RfcGh5c19z aXplKGRzdCkgLyBzaXplb2YodTMyKTsgaSArPSAxNykgewotCQkJaWYgKCEoZHN0LT5jYWNoZV9j b2hlcmVudCAmIEk5MTVfQk9fQ0FDSEVfQ09IRVJFTlRfRk9SX1JFQUQpKQotCQkJCWRybV9jbGZs dXNoX3ZpcnRfcmFuZ2UoJnZhZGRyW2ldLCBzaXplb2YodmFkZHJbaV0pKTsKLQotCQkJaWYgKHZh ZGRyW2ldICE9IHZhbCkgewotCQkJCXByX2VycigidmFkZHJbJXVdPSV4LCBleHBlY3RlZD0leFxu IiwgaSwKLQkJCQkgICAgICAgdmFkZHJbaV0sIHZhbCk7Ci0JCQkJZXJyID0gLUVJTlZBTDsKLQkJ CQlnb3RvIGVycl91bnBpbjsKLQkJCX0KLQkJfQotCi0JCWk5MTVfZ2VtX29iamVjdF91bnBpbl9t YXAoZHN0KTsKLQotCQlpOTE1X2dlbV9vYmplY3RfcHV0KHNyYyk7Ci0JCWk5MTVfZ2VtX29iamVj dF9wdXQoZHN0KTsKLQotCQl0b3RhbCA8PD0gMTsKLQl9IHdoaWxlICghdGltZV9hZnRlcihqaWZm aWVzLCBlbmQpKTsKLQotCWdvdG8gZXJyX2ZsdXNoOwotCi1lcnJfdW5waW46Ci0JaTkxNV9nZW1f b2JqZWN0X3VucGluX21hcChkc3QpOwotZXJyX3B1dF9kc3Q6Ci0JaTkxNV9nZW1fb2JqZWN0X3B1 dChkc3QpOwotZXJyX3B1dF9zcmM6Ci0JaTkxNV9nZW1fb2JqZWN0X3B1dChzcmMpOwotZXJyX2Zs dXNoOgotCWlmIChlcnIgPT0gLUVOT01FTSkKLQkJZXJyID0gMDsKLQotCWludGVsX2NvbnRleHRf cHV0KGNlKTsKLQlyZXR1cm4gZXJyOwotfQotCi1zdGF0aWMgaW50IGlndF90aHJlYWRlZF9ibHQo c3RydWN0IGludGVsX2VuZ2luZV9jcyAqZW5naW5lLAotCQkJICAgIGludCAoKmJsdF9mbikodm9p ZCAqYXJnKSwKLQkJCSAgICB1bnNpZ25lZCBpbnQgZmxhZ3MpCi0jZGVmaW5lIFNJTkdMRV9DVFgg QklUKDApCi17Ci0Jc3RydWN0IGlndF90aHJlYWRfYXJnICp0aHJlYWQ7Ci0Jc3RydWN0IHRhc2tf c3RydWN0ICoqdHNrOwotCXVuc2lnbmVkIGludCBuX2NwdXMsIGk7Ci0JSTkxNV9STkRfU1RBVEUo cHJuZyk7Ci0JaW50IGVyciA9IDA7Ci0KLQluX2NwdXMgPSBudW1fb25saW5lX2NwdXMoKSArIDE7 Ci0KLQl0c2sgPSBrY2FsbG9jKG5fY3B1cywgc2l6ZW9mKHN0cnVjdCB0YXNrX3N0cnVjdCAqKSwg R0ZQX0tFUk5FTCk7Ci0JaWYgKCF0c2spCi0JCXJldHVybiAwOwotCi0JdGhyZWFkID0ga2NhbGxv YyhuX2NwdXMsIHNpemVvZihzdHJ1Y3QgaWd0X3RocmVhZF9hcmcpLCBHRlBfS0VSTkVMKTsKLQlp ZiAoIXRocmVhZCkKLQkJZ290byBvdXRfdHNrOwotCi0JdGhyZWFkWzBdLmZpbGUgPSBtb2NrX2Zp bGUoZW5naW5lLT5pOTE1KTsKLQlpZiAoSVNfRVJSKHRocmVhZFswXS5maWxlKSkgewotCQllcnIg PSBQVFJfRVJSKHRocmVhZFswXS5maWxlKTsKLQkJZ290byBvdXRfdGhyZWFkOwotCX0KLQotCWlm IChmbGFncyAmIFNJTkdMRV9DVFgpIHsKLQkJdGhyZWFkWzBdLmN0eCA9IGxpdmVfY29udGV4dF9m b3JfZW5naW5lKGVuZ2luZSwgdGhyZWFkWzBdLmZpbGUpOwotCQlpZiAoSVNfRVJSKHRocmVhZFsw XS5jdHgpKSB7Ci0JCQllcnIgPSBQVFJfRVJSKHRocmVhZFswXS5jdHgpOwotCQkJZ290byBvdXRf ZmlsZTsKLQkJfQotCX0KLQotCWZvciAoaSA9IDA7IGkgPCBuX2NwdXM7ICsraSkgewotCQl0aHJl YWRbaV0uZW5naW5lID0gZW5naW5lOwotCQl0aHJlYWRbaV0uZmlsZSA9IHRocmVhZFswXS5maWxl OwotCQl0aHJlYWRbaV0uY3R4ID0gdGhyZWFkWzBdLmN0eDsKLQkJdGhyZWFkW2ldLm5fY3B1cyA9 IG5fY3B1czsKLQkJdGhyZWFkW2ldLnBybmcgPQotCQkJSTkxNV9STkRfU1RBVEVfSU5JVElBTEla RVIocHJhbmRvbV91MzJfc3RhdGUoJnBybmcpKTsKLQotCQl0c2tbaV0gPSBrdGhyZWFkX3J1bihi bHRfZm4sICZ0aHJlYWRbaV0sICJpZ3QvYmx0LSVkIiwgaSk7Ci0JCWlmIChJU19FUlIodHNrW2ld KSkgewotCQkJZXJyID0gUFRSX0VSUih0c2tbaV0pOwotCQkJYnJlYWs7Ci0JCX0KLQotCQlnZXRf dGFza19zdHJ1Y3QodHNrW2ldKTsKLQl9Ci0KLQl5aWVsZCgpOyAvKiBzdGFydCBhbGwgdGhyZWFk cyBiZWZvcmUgd2Uga3RocmVhZF9zdG9wKCkgKi8KLQotCWZvciAoaSA9IDA7IGkgPCBuX2NwdXM7 ICsraSkgewotCQlpbnQgc3RhdHVzOwotCi0JCWlmIChJU19FUlJfT1JfTlVMTCh0c2tbaV0pKQot CQkJY29udGludWU7Ci0KLQkJc3RhdHVzID0ga3RocmVhZF9zdG9wKHRza1tpXSk7Ci0JCWlmIChz dGF0dXMgJiYgIWVycikKLQkJCWVyciA9IHN0YXR1czsKLQotCQlwdXRfdGFza19zdHJ1Y3QodHNr W2ldKTsKLQl9Ci0KLW91dF9maWxlOgotCWZwdXQodGhyZWFkWzBdLmZpbGUpOwotb3V0X3RocmVh ZDoKLQlrZnJlZSh0aHJlYWQpOwotb3V0X3RzazoKLQlrZnJlZSh0c2spOwotCXJldHVybiBlcnI7 Ci19Ci0KLXN0YXRpYyBpbnQgdGVzdF9jb3B5X2VuZ2luZXMoc3RydWN0IGRybV9pOTE1X3ByaXZh dGUgKmk5MTUsCi0JCQkgICAgIGludCAoKmZuKSh2b2lkICphcmcpLAotCQkJICAgICB1bnNpZ25l ZCBpbnQgZmxhZ3MpCi17Ci0Jc3RydWN0IGludGVsX2VuZ2luZV9jcyAqZW5naW5lOwotCWludCBy ZXQ7Ci0KLQlmb3JfZWFjaF91YWJpX2NsYXNzX2VuZ2luZShlbmdpbmUsIEk5MTVfRU5HSU5FX0NM QVNTX0NPUFksIGk5MTUpIHsKLQkJcmV0ID0gaWd0X3RocmVhZGVkX2JsdChlbmdpbmUsIGZuLCBm bGFncyk7Ci0JCWlmIChyZXQpCi0JCQlyZXR1cm4gcmV0OwotCX0KLQotCXJldHVybiAwOwotfQot Ci1zdGF0aWMgaW50IGlndF9maWxsX2JsdCh2b2lkICphcmcpCi17Ci0JcmV0dXJuIHRlc3RfY29w eV9lbmdpbmVzKGFyZywgaWd0X2ZpbGxfYmx0X3RocmVhZCwgMCk7Ci19Ci0KLXN0YXRpYyBpbnQg aWd0X2ZpbGxfYmx0X2N0eDAodm9pZCAqYXJnKQotewotCXJldHVybiB0ZXN0X2NvcHlfZW5naW5l cyhhcmcsIGlndF9maWxsX2JsdF90aHJlYWQsIFNJTkdMRV9DVFgpOwotfQotCi1zdGF0aWMgaW50 IGlndF9jb3B5X2JsdCh2b2lkICphcmcpCi17Ci0JcmV0dXJuIHRlc3RfY29weV9lbmdpbmVzKGFy ZywgaWd0X2NvcHlfYmx0X3RocmVhZCwgMCk7Ci19Ci0KLXN0YXRpYyBpbnQgaWd0X2NvcHlfYmx0 X2N0eDAodm9pZCAqYXJnKQotewotCXJldHVybiB0ZXN0X2NvcHlfZW5naW5lcyhhcmcsIGlndF9j b3B5X2JsdF90aHJlYWQsIFNJTkdMRV9DVFgpOwotfQotCi1pbnQgaTkxNV9nZW1fb2JqZWN0X2Js dF9saXZlX3NlbGZ0ZXN0cyhzdHJ1Y3QgZHJtX2k5MTVfcHJpdmF0ZSAqaTkxNSkKLXsKLQlzdGF0 aWMgY29uc3Qgc3RydWN0IGk5MTVfc3VidGVzdCB0ZXN0c1tdID0gewotCQlTVUJURVNUKGlndF9m aWxsX2JsdCksCi0JCVNVQlRFU1QoaWd0X2ZpbGxfYmx0X2N0eDApLAotCQlTVUJURVNUKGlndF9j b3B5X2JsdCksCi0JCVNVQlRFU1QoaWd0X2NvcHlfYmx0X2N0eDApLAotCX07Ci0KLQlpZiAoaW50 ZWxfZ3RfaXNfd2VkZ2VkKCZpOTE1LT5ndCkpCi0JCXJldHVybiAwOwotCi0JcmV0dXJuIGk5MTVf bGl2ZV9zdWJ0ZXN0cyh0ZXN0cywgaTkxNSk7Ci19Ci0KLWludCBpOTE1X2dlbV9vYmplY3RfYmx0 X3BlcmZfc2VsZnRlc3RzKHN0cnVjdCBkcm1faTkxNV9wcml2YXRlICppOTE1KQotewotCXN0YXRp YyBjb25zdCBzdHJ1Y3QgaTkxNV9zdWJ0ZXN0IHRlc3RzW10gPSB7Ci0JCVNVQlRFU1QocGVyZl9m aWxsX2JsdCksCi0JCVNVQlRFU1QocGVyZl9jb3B5X2JsdCksCi0JfTsKLQotCWlmIChpbnRlbF9n dF9pc193ZWRnZWQoJmk5MTUtPmd0KSkKLQkJcmV0dXJuIDA7Ci0KLQlyZXR1cm4gaTkxNV9saXZl X3N1YnRlc3RzKHRlc3RzLCBpOTE1KTsKLX0KZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2RybS9p OTE1L3NlbGZ0ZXN0cy9pOTE1X2xpdmVfc2VsZnRlc3RzLmggYi9kcml2ZXJzL2dwdS9kcm0vaTkx NS9zZWxmdGVzdHMvaTkxNV9saXZlX3NlbGZ0ZXN0cy5oCmluZGV4IDZmNTg5M2VjZDU0OS4uMWFl M2Y4MDM5ZDY4IDEwMDY0NAotLS0gYS9kcml2ZXJzL2dwdS9kcm0vaTkxNS9zZWxmdGVzdHMvaTkx NV9saXZlX3NlbGZ0ZXN0cy5oCisrKyBiL2RyaXZlcnMvZ3B1L2RybS9pOTE1L3NlbGZ0ZXN0cy9p OTE1X2xpdmVfc2VsZnRlc3RzLmgKQEAgLTM5LDcgKzM5LDYgQEAgc2VsZnRlc3QoZXZpY3QsIGk5 MTVfZ2VtX2V2aWN0X2xpdmVfc2VsZnRlc3RzKQogc2VsZnRlc3QoaHVnZXBhZ2VzLCBpOTE1X2dl bV9odWdlX3BhZ2VfbGl2ZV9zZWxmdGVzdHMpCiBzZWxmdGVzdChnZW1fY29udGV4dHMsIGk5MTVf Z2VtX2NvbnRleHRfbGl2ZV9zZWxmdGVzdHMpCiBzZWxmdGVzdChnZW1fZXhlY2J1ZiwgaTkxNV9n ZW1fZXhlY2J1ZmZlcl9saXZlX3NlbGZ0ZXN0cykKLXNlbGZ0ZXN0KGJsdCwgaTkxNV9nZW1fb2Jq ZWN0X2JsdF9saXZlX3NlbGZ0ZXN0cykKIHNlbGZ0ZXN0KHJlc2V0LCBpbnRlbF9yZXNldF9saXZl X3NlbGZ0ZXN0cykKIHNlbGZ0ZXN0KG1lbW9yeV9yZWdpb24sIGludGVsX21lbW9yeV9yZWdpb25f bGl2ZV9zZWxmdGVzdHMpCiBzZWxmdGVzdChoYW5nY2hlY2ssIGludGVsX2hhbmdjaGVja19saXZl X3NlbGZ0ZXN0cykKZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2RybS9pOTE1L3NlbGZ0ZXN0cy9p OTE1X3BlcmZfc2VsZnRlc3RzLmggYi9kcml2ZXJzL2dwdS9kcm0vaTkxNS9zZWxmdGVzdHMvaTkx NV9wZXJmX3NlbGZ0ZXN0cy5oCmluZGV4IDUwNzdkYzNjM2I4Yy4uMDU4NDUwZDM1MWY3IDEwMDY0 NAotLS0gYS9kcml2ZXJzL2dwdS9kcm0vaTkxNS9zZWxmdGVzdHMvaTkxNV9wZXJmX3NlbGZ0ZXN0 cy5oCisrKyBiL2RyaXZlcnMvZ3B1L2RybS9pOTE1L3NlbGZ0ZXN0cy9pOTE1X3BlcmZfc2VsZnRl c3RzLmgKQEAgLTE4LDUgKzE4LDQgQEAKIHNlbGZ0ZXN0KGVuZ2luZV9jcywgaW50ZWxfZW5naW5l X2NzX3BlcmZfc2VsZnRlc3RzKQogc2VsZnRlc3QocmVxdWVzdCwgaTkxNV9yZXF1ZXN0X3BlcmZf c2VsZnRlc3RzKQogc2VsZnRlc3QobWlncmF0ZSwgaW50ZWxfbWlncmF0ZV9wZXJmX3NlbGZ0ZXN0 cykKLXNlbGZ0ZXN0KGJsdCwgaTkxNV9nZW1fb2JqZWN0X2JsdF9wZXJmX3NlbGZ0ZXN0cykKIHNl bGZ0ZXN0KHJlZ2lvbiwgaW50ZWxfbWVtb3J5X3JlZ2lvbl9wZXJmX3NlbGZ0ZXN0cykKZGlmZiAt LWdpdCBhL2RyaXZlcnMvZ3B1L2RybS9pOTE1L3NlbGZ0ZXN0cy9pbnRlbF9tZW1vcnlfcmVnaW9u LmMgYi9kcml2ZXJzL2dwdS9kcm0vaTkxNS9zZWxmdGVzdHMvaW50ZWxfbWVtb3J5X3JlZ2lvbi5j CmluZGV4IGM4NWQ1MTZiODVjZC4uMmUxOGYzYTNkNTM4IDEwMDY0NAotLS0gYS9kcml2ZXJzL2dw dS9kcm0vaTkxNS9zZWxmdGVzdHMvaW50ZWxfbWVtb3J5X3JlZ2lvbi5jCisrKyBiL2RyaXZlcnMv Z3B1L2RybS9pOTE1L3NlbGZ0ZXN0cy9pbnRlbF9tZW1vcnlfcmVnaW9uLmMKQEAgLTE1LDExICsx NSwxMiBAQAogI2luY2x1ZGUgImdlbS9pOTE1X2dlbV9jb250ZXh0LmgiCiAjaW5jbHVkZSAiZ2Vt L2k5MTVfZ2VtX2xtZW0uaCIKICNpbmNsdWRlICJnZW0vaTkxNV9nZW1fcmVnaW9uLmgiCi0jaW5j bHVkZSAiZ2VtL2k5MTVfZ2VtX29iamVjdF9ibHQuaCIKICNpbmNsdWRlICJnZW0vc2VsZnRlc3Rz L2lndF9nZW1fdXRpbHMuaCIKICNpbmNsdWRlICJnZW0vc2VsZnRlc3RzL21vY2tfY29udGV4dC5o IgorI2luY2x1ZGUgImd0L2ludGVsX2VuZ2luZV9wbS5oIgogI2luY2x1ZGUgImd0L2ludGVsX2Vu Z2luZV91c2VyLmgiCiAjaW5jbHVkZSAiZ3QvaW50ZWxfZ3QuaCIKKyNpbmNsdWRlICJndC9pbnRl bF9taWdyYXRlLmgiCiAjaW5jbHVkZSAiaTkxNV9tZW1jcHkuaCIKICNpbmNsdWRlICJzZWxmdGVz dHMvaWd0X2ZsdXNoX3Rlc3QuaCIKICNpbmNsdWRlICJzZWxmdGVzdHMvaTkxNV9yYW5kb20uaCIK QEAgLTc0MSw2ICs3NDIsNyBAQCBzdGF0aWMgaW50IGlndF9sbWVtX3dyaXRlX2NwdSh2b2lkICph cmcpCiAJCVBBR0VfU0laRSAtIDY0LAogCX07CiAJc3RydWN0IGludGVsX2VuZ2luZV9jcyAqZW5n aW5lOworCXN0cnVjdCBpOTE1X3JlcXVlc3QgKnJxOwogCXUzMiAqdmFkZHI7CiAJdTMyIHN6Owog CXUzMiBpOwpAQCAtNzY3LDE1ICs3NjksMjAgQEAgc3RhdGljIGludCBpZ3RfbG1lbV93cml0ZV9j cHUodm9pZCAqYXJnKQogCQlnb3RvIG91dF9wdXQ7CiAJfQogCisJaTkxNV9nZW1fb2JqZWN0X2xv Y2sob2JqLCBOVUxMKTsKIAkvKiBQdXQgdGhlIHBhZ2VzIGludG8gYSBrbm93biBzdGF0ZSAtLSBm cm9tIHRoZSBncHUgZm9yIGFkZGVkIGZ1biAqLwogCWludGVsX2VuZ2luZV9wbV9nZXQoZW5naW5l KTsKLQllcnIgPSBpOTE1X2dlbV9vYmplY3RfZmlsbF9ibHQob2JqLCBlbmdpbmUtPmtlcm5lbF9j b250ZXh0LCAweGRlYWRiZWFmKTsKLQlpbnRlbF9lbmdpbmVfcG1fcHV0KGVuZ2luZSk7Ci0JaWYg KGVycikKLQkJZ290byBvdXRfdW5waW47CisJZXJyID0gaW50ZWxfY29udGV4dF9taWdyYXRlX2Ns ZWFyKGVuZ2luZS0+Z3QtPm1pZ3JhdGUuY29udGV4dCwgTlVMTCwKKwkJCQkJICBvYmotPm1tLnBh Z2VzLT5zZ2wsIEk5MTVfQ0FDSEVfTk9ORSwKKwkJCQkJICB0cnVlLCAweGRlYWRiZWFmLCAmcnEp OworCWlmIChycSkgeworCQlkbWFfcmVzdl9hZGRfZXhjbF9mZW5jZShvYmotPmJhc2UucmVzdiwg JnJxLT5mZW5jZSk7CisJCWk5MTVfcmVxdWVzdF9wdXQocnEpOworCX0KIAotCWk5MTVfZ2VtX29i amVjdF9sb2NrKG9iaiwgTlVMTCk7Ci0JZXJyID0gaTkxNV9nZW1fb2JqZWN0X3NldF90b193Y19k b21haW4ob2JqLCB0cnVlKTsKKwlpbnRlbF9lbmdpbmVfcG1fcHV0KGVuZ2luZSk7CisJaWYgKCFl cnIpCisJCWVyciA9IGk5MTVfZ2VtX29iamVjdF9zZXRfdG9fd2NfZG9tYWluKG9iaiwgdHJ1ZSk7 CiAJaTkxNV9nZW1fb2JqZWN0X3VubG9jayhvYmopOwogCWlmIChlcnIpCiAJCWdvdG8gb3V0X3Vu cGluOwotLSAKMi4zMS4xCgpfX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fXwpJbnRlbC1nZnggbWFpbGluZyBsaXN0CkludGVsLWdmeEBsaXN0cy5mcmVlZGVza3Rv cC5vcmcKaHR0cHM6Ly9saXN0cy5mcmVlZGVza3RvcC5vcmcvbWFpbG1hbi9saXN0aW5mby9pbnRl bC1nZngK 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 D944EC2B9F4 for ; Mon, 14 Jun 2021 16:27:07 +0000 (UTC) Received: from gabe.freedesktop.org (gabe.freedesktop.org [131.252.210.177]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by mail.kernel.org (Postfix) with ESMTPS id AB12360234 for ; Mon, 14 Jun 2021 16:27:07 +0000 (UTC) DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org AB12360234 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 A1FD589F33; Mon, 14 Jun 2021 16:26:58 +0000 (UTC) Received: from mga07.intel.com (mga07.intel.com [134.134.136.100]) by gabe.freedesktop.org (Postfix) with ESMTPS id 0458B89F06; Mon, 14 Jun 2021 16:26:50 +0000 (UTC) IronPort-SDR: 55b/4waIvnXP/m0PhHYmC0Cad6I4knJXTqn7s2xTcG3Hm5OclMQk8VvyMJbB/GbGVfqxn2C2LK TS2V4K6RPjzg== X-IronPort-AV: E=McAfee;i="6200,9189,10015"; a="269689042" X-IronPort-AV: E=Sophos;i="5.83,273,1616482800"; d="scan'208";a="269689042" Received: from orsmga008.jf.intel.com ([10.7.209.65]) by orsmga105.jf.intel.com with ESMTP/TLS/ECDHE-RSA-AES256-GCM-SHA384; 14 Jun 2021 09:26:45 -0700 IronPort-SDR: aXnF4RR0ztoOdpZLMGcmfCDoMA3DSP7WWtFqTvY373kfWlw3U13Gdx7lWqKnmwPDtrkN9E+Pnb 9mx/OS/iKpdA== X-IronPort-AV: E=Sophos;i="5.83,273,1616482800"; d="scan'208";a="449946744" Received: from fnygreen-mobl1.ger.corp.intel.com (HELO thellst-mobl1.intel.com) ([10.249.254.50]) by orsmga008-auth.jf.intel.com with ESMTP/TLS/ECDHE-RSA-AES256-GCM-SHA384; 14 Jun 2021 09:26:44 -0700 From: =?UTF-8?q?Thomas=20Hellstr=C3=B6m?= To: intel-gfx@lists.freedesktop.org, dri-devel@lists.freedesktop.org Subject: [PATCH v3 12/12] drm/i915/gem: Zap the i915_gem_object_blt code Date: Mon, 14 Jun 2021 18:26:12 +0200 Message-Id: <20210614162612.294869-13-thomas.hellstrom@linux.intel.com> X-Mailer: git-send-email 2.31.1 In-Reply-To: <20210614162612.294869-1-thomas.hellstrom@linux.intel.com> References: <20210614162612.294869-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 --- 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 ca07474ec2df..13085ac78c63 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 6f5893ecd549..1ae3f8039d68 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(reset, intel_reset_live_selftests) selftest(memory_region, intel_memory_region_live_selftests) selftest(hangcheck, intel_hangcheck_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 c85d516b85cd..2e18f3a3d538 100644 --- a/drivers/gpu/drm/i915/selftests/intel_memory_region.c +++ b/drivers/gpu/drm/i915/selftests/intel_memory_region.c @@ -15,11 +15,12 @@ #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 "gt/intel_migrate.h" #include "i915_memcpy.h" #include "selftests/igt_flush_test.h" #include "selftests/i915_random.h" @@ -741,6 +742,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; @@ -767,15 +769,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