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 95740C2B9F7 for ; Wed, 26 May 2021 11:33:53 +0000 (UTC) Received: from gabe.freedesktop.org (gabe.freedesktop.org [131.252.210.177]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by mail.kernel.org (Postfix) with ESMTPS id 56A666113D for ; Wed, 26 May 2021 11:33:53 +0000 (UTC) DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org 56A666113D 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 297356ECBA; Wed, 26 May 2021 11:33:46 +0000 (UTC) Received: from mga01.intel.com (mga01.intel.com [192.55.52.88]) by gabe.freedesktop.org (Postfix) with ESMTPS id 641996ECA3; Wed, 26 May 2021 11:33:36 +0000 (UTC) IronPort-SDR: t9TpRePFafBAu8/K7odSxvm7+rBls/WvrhOMD5SyLBD7fTo2/bpOg8P/3mRoALvksRjGL/P+dR Pg8e2ZJJ4NMg== X-IronPort-AV: E=McAfee;i="6200,9189,9995"; a="223627313" X-IronPort-AV: E=Sophos;i="5.82,331,1613462400"; d="scan'208";a="223627313" Received: from fmsmga005.fm.intel.com ([10.253.24.32]) by fmsmga101.fm.intel.com with ESMTP/TLS/ECDHE-RSA-AES256-GCM-SHA384; 26 May 2021 04:33:36 -0700 IronPort-SDR: 9qn2zF99Bzjm00SUQ/Q+udev0aM2gF/VWXz7ARVFwFXrwYlLJv7DqavTJHmxSeM9GgdyRIehQy CZ1hx/w6VPOg== X-IronPort-AV: E=Sophos;i="5.82,331,1613462400"; d="scan'208";a="633457959" Received: from pegilssx-mobl.ger.corp.intel.com (HELO thellst-mobl1.intel.com) ([10.249.254.205]) by fmsmga005-auth.fm.intel.com with ESMTP/TLS/ECDHE-RSA-AES256-GCM-SHA384; 26 May 2021 04:33:34 -0700 From: =?UTF-8?q?Thomas=20Hellstr=C3=B6m?= To: intel-gfx@lists.freedesktop.org, dri-devel@lists.freedesktop.org Date: Wed, 26 May 2021 13:32:55 +0200 Message-Id: <20210526113259.1661914-12-thomas.hellstrom@linux.intel.com> X-Mailer: git-send-email 2.31.1 In-Reply-To: <20210526113259.1661914-1-thomas.hellstrom@linux.intel.com> References: <20210526113259.1661914-1-thomas.hellstrom@linux.intel.com> MIME-Version: 1.0 Subject: [Intel-gfx] [PATCH v4 11/15] drm/i915/ttm: Introduce a TTM i915 gem object backend 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 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Errors-To: intel-gfx-bounces@lists.freedesktop.org Sender: "Intel-gfx" TW9zdCBsb2dpY2FsIHBsYWNlIHRvIGludHJvZHVjZSBUVE0gYnVmZmVyIG9iamVjdHMgaXMgYXMg YW4gaTkxNQpnZW0gb2JqZWN0IGJhY2tlbmQuIFdlIG5lZWQgdG8gYWRkIHNvbWUgb3BzIHRvIGFj Y291bnQgZm9yIGFkZGVkCmZ1bmN0aW9uYWxpdHkgbGlrZSBkZWxheWVkIGRlbGV0ZSBhbmQgTFJV IGxpc3QgbWFuaXB1bGF0aW9uLgoKSW5pdGlhbGx5IHdlIHN1cHBvcnQgb25seSBMTUVNIGFuZCBT WVNURU0gbWVtb3J5LCBidXQgU1lTVEVNCih3aGljaCBpbiB0aGlzIGNhc2UgbWVhbnMgZXZpY3Rl ZCBMTUVNIG9iamVjdHMpIGlzIG5vdAp2aXNpYmxlIHRvIGk5MTUgR0VNIHlldC4gVGhlIHBsYW4g aXMgdG8gbW92ZSB0aGUgaTkxNSBnZW0gc3lzdGVtIHJlZ2lvbgpvdmVyIHRvIHRoZSBUVE0gc3lz dGVtIG1lbW9yeSB0eXBlIGluIHVwY29taW5nIHBhdGNoZXMuCgpXZSBzZXQgdXAgR1BVIGJpbmRp bmdzIGRpcmVjdGx5IGJvdGggZnJvbSBMTUVNIGFuZCBmcm9tIHRoZSBzeXN0ZW0gcmVnaW9uLAph cyB0aGVyZSBpcyBubyBuZWVkIHRvIHVzZSB0aGUgbGVnYWN5IFRUTV9UVCBtZW1vcnkgdHlwZS4g V2UgcmVzZXJ2ZQp0aGF0IGZvciBmdXR1cmUgcG9ydGluZyBvZiBHR1RUIGJpbmRpbmdzIHRvIFRU TS4KClJlbW92ZSB0aGUgb2xkIGxtZW0gYmFja2VuZC4KClNpZ25lZC1vZmYtYnk6IFRob21hcyBI ZWxsc3Ryw7ZtIDx0aG9tYXMuaGVsbHN0cm9tQGxpbnV4LmludGVsLmNvbT4KUmV2aWV3ZWQtYnk6 IE1hdHRoZXcgQXVsZCA8bWF0dGhldy5hdWxkQGludGVsLmNvbT4KLS0tCnYyOgotIEJyZWFrIG91 dCBuZWVkZWQgVFRNIGZ1bmN0aW9uYWxpdHkgdG8gYSBzZXBhcmF0ZSBwYXRjaCAoUmVwb3J0ZWQg YnkKQ2hyaXN0aWFuIEvDtm5pZykuCi0gRml4IGFuIHVuaGFuZGxlZCBlcnJvciAoUmVwb3J0ZWQg YnkgTWF0dGhldyBBdWxkIGFuZCBNYWFydGVuIExhbmtob3JzdCkKLSBSZW1vdmUgYSBzdHJheSBs ZWZ0b3ZlciBzZ190YWJsZSBhbGxvY2F0aW9uIChSZXBvcnRlZCBieSBNYXR0aGV3IEF1bGQpCi0g VXNlIHR0bV90dF91bnBvcHVsYXRlKCkgcmF0aGVyIHRoYW4gdHRtX3R0X2Rlc3Ryb3koKSBpbiB0 aGUgcHVyZ2UgcGF0aAogIGFzIHNvbWUgVFRNIGZ1bmN0aW9uYWxpdHkgcmVsaWVzIG9uIGhhdmlu ZyBhIHR0bV90dCBwcmVzZW50IGZvciAhaXNfaW9tZW0uCnYzOgotIFVzZSB0dG1fYm9fdHlwZV9k ZXZpY2UgZm9yIHVzZXJzcGFjZSB2aXNpYmxlIG9iamVjdHMgc28gdGhhdCBUVE0gY2FuCiAgYWxs b2NhdGUgYW4gYWRkcmVzcyBzcGFjZSBvZmZzZXQgZm9yIG1tYXAnaW5nLgotIEZpeCB1cCB0aGUg ZGVzdHJ1Y3Rpb24gcGF0aCAoUmVwb3J0ZWQgYnkgTWF0dGhldyBBdWxkKQotIFVzZSB0dG1fYm9f dmFsaWRhdGUoKSBmb3IgcHVyZ2luZyAoUmVwb3J0ZWQgYnkgQ2hyaXN0aWFuIEvDtm5pZykKLSBD cmVhdGUgdHRtX3R0cyB3cml0ZS1jb21iaW5lZCBhcyB0aGV5IGFyZSBjdXJyZW50bHkgZm9yIGV2 aWN0aW9uIG9ubHkgYW5kCiAgd2Ugd2FudCB0byBtYWludGFpbiBjb25zaXN0ZW50IHdyaXRlLWNv bWJpbmVkIGNhY2hpbmcgZm9yIGJvcyB0aGF0IGFyZQogIG5vdCBpbiBzeXN0ZW0gb25seS4gKFN1 Z2dlc3RlZCBieSBEYW5pZWwgVmV0dGVyKQotIE1ha2Ugc3RydWN0IHR0bV9wbGFjZW1lbnRzIHN0 YXRpYy4KLSBBZGQgdGhlIHR0bSBkZXZpY2UgZnVuY3Mvb3BzIHRvIGk5MTVfZ2VtX3R0bS5oIGZv ciB0aGUgcmVnaW9uIGNvZGUuCi0gUmVuYW1lIG5ldy0+ZHN0IGFuZCBvbGQtPnNyYy4gQ2hlY2sg Zm9yIHN3YXBpbiBpbiB0aGUgbW92ZSBjYWxsYmFjay4KdjQ6Ci0gQWRhcHQgdG8gc21hbGwgaW50 ZXJmYWNlIGNoYW5nZSBpbiB0dG1fbW92ZV9tZW1jcHkuCi0gVXNlIGEgZnVuY3Rpb24gdG8gcHVs bCBvdXQgdGhlIHR0bSBkcml2ZXIgZnJvbSB0aGUgYmFja2VuZC4KLS0tCiBkcml2ZXJzL2dwdS9k cm0vaTkxNS9NYWtlZmlsZSAgICAgICAgICAgICAgICAgfCAgIDEgKwogZHJpdmVycy9ncHUvZHJt L2k5MTUvZ2VtL2k5MTVfZ2VtX2NyZWF0ZS5jICAgIHwgICA5ICstCiBkcml2ZXJzL2dwdS9kcm0v aTkxNS9nZW0vaTkxNV9nZW1fbG1lbS5jICAgICAgfCAgODQgLS0tCiBkcml2ZXJzL2dwdS9kcm0v aTkxNS9nZW0vaTkxNV9nZW1fbG1lbS5oICAgICAgfCAgIDUgLQogZHJpdmVycy9ncHUvZHJtL2k5 MTUvZ2VtL2k5MTVfZ2VtX29iamVjdC5jICAgIHwgMTI1ICsrLS0KIGRyaXZlcnMvZ3B1L2RybS9p OTE1L2dlbS9pOTE1X2dlbV9vYmplY3QuaCAgICB8ICAgOSArCiAuLi4vZ3B1L2RybS9pOTE1L2dl bS9pOTE1X2dlbV9vYmplY3RfdHlwZXMuaCAgfCAgMjcgKy0KIGRyaXZlcnMvZ3B1L2RybS9pOTE1 L2dlbS9pOTE1X2dlbV9yZWdpb24uYyAgICB8ICAgNiArLQogZHJpdmVycy9ncHUvZHJtL2k5MTUv Z2VtL2k5MTVfZ2VtX3R0bS5jICAgICAgIHwgNTQxICsrKysrKysrKysrKysrKysrKwogZHJpdmVy cy9ncHUvZHJtL2k5MTUvZ2VtL2k5MTVfZ2VtX3R0bS5oICAgICAgIHwgIDQ4ICsrCiBkcml2ZXJz L2dwdS9kcm0vaTkxNS9ndC9pbnRlbF9yZWdpb25fbG1lbS5jICAgfCAgIDMgKy0KIGRyaXZlcnMv Z3B1L2RybS9pOTE1L2k5MTVfZ2VtLmMgICAgICAgICAgICAgICB8ICAgNSArLQogZHJpdmVycy9n cHUvZHJtL2k5MTUvaW50ZWxfbWVtb3J5X3JlZ2lvbi5jICAgIHwgICAxIC0KIGRyaXZlcnMvZ3B1 L2RybS9pOTE1L2ludGVsX21lbW9yeV9yZWdpb24uaCAgICB8ICAgMSAtCiBkcml2ZXJzL2dwdS9k cm0vaTkxNS9pbnRlbF9yZWdpb25fdHRtLmMgICAgICAgfCAgIDggKy0KIGRyaXZlcnMvZ3B1L2Ry bS9pOTE1L2ludGVsX3JlZ2lvbl90dG0uaCAgICAgICB8ICAxMSArLQogMTYgZmlsZXMgY2hhbmdl ZCwgNzMxIGluc2VydGlvbnMoKyksIDE1MyBkZWxldGlvbnMoLSkKIGNyZWF0ZSBtb2RlIDEwMDY0 NCBkcml2ZXJzL2dwdS9kcm0vaTkxNS9nZW0vaTkxNV9nZW1fdHRtLmMKIGNyZWF0ZSBtb2RlIDEw MDY0NCBkcml2ZXJzL2dwdS9kcm0vaTkxNS9nZW0vaTkxNV9nZW1fdHRtLmgKCmRpZmYgLS1naXQg YS9kcml2ZXJzL2dwdS9kcm0vaTkxNS9NYWtlZmlsZSBiL2RyaXZlcnMvZ3B1L2RybS9pOTE1L01h a2VmaWxlCmluZGV4IGViYzE5YmQ1ZmZmNC4uOWY5Y2Q1YzA4NWMzIDEwMDY0NAotLS0gYS9kcml2 ZXJzL2dwdS9kcm0vaTkxNS9NYWtlZmlsZQorKysgYi9kcml2ZXJzL2dwdS9kcm0vaTkxNS9NYWtl ZmlsZQpAQCAtMTU0LDYgKzE1NCw3IEBAIGdlbS15ICs9IFwKIAlnZW0vaTkxNV9nZW1fc3RvbGVu Lm8gXAogCWdlbS9pOTE1X2dlbV90aHJvdHRsZS5vIFwKIAlnZW0vaTkxNV9nZW1fdGlsaW5nLm8g XAorCWdlbS9pOTE1X2dlbV90dG0ubyBcCiAJZ2VtL2k5MTVfZ2VtX3VzZXJwdHIubyBcCiAJZ2Vt L2k5MTVfZ2VtX3dhaXQubyBcCiAJZ2VtL2k5MTVfZ2VtZnMubwpkaWZmIC0tZ2l0IGEvZHJpdmVy cy9ncHUvZHJtL2k5MTUvZ2VtL2k5MTVfZ2VtX2NyZWF0ZS5jIGIvZHJpdmVycy9ncHUvZHJtL2k5 MTUvZ2VtL2k5MTVfZ2VtX2NyZWF0ZS5jCmluZGV4IDU0OGRkZjM5ZDg1My4uOTNiZjYzYmJhZmYx IDEwMDY0NAotLS0gYS9kcml2ZXJzL2dwdS9kcm0vaTkxNS9nZW0vaTkxNV9nZW1fY3JlYXRlLmMK KysrIGIvZHJpdmVycy9ncHUvZHJtL2k5MTUvZ2VtL2k5MTVfZ2VtX2NyZWF0ZS5jCkBAIC04NSwx MyArODUsMTAgQEAgaTkxNV9nZW1fc2V0dXAoc3RydWN0IGRybV9pOTE1X2dlbV9vYmplY3QgKm9i aiwgdTY0IHNpemUpCiAJCXJldHVybiAtRTJCSUc7CiAKIAkvKgotCSAqIEZvciBub3cgcmVzb3J0 IHRvIENQVSBiYXNlZCBjbGVhcmluZyBmb3IgZGV2aWNlIGxvY2FsLW1lbW9yeSwgaW4gdGhlCi0J ICogbmVhciBmdXR1cmUgdGhpcyB3aWxsIHVzZSB0aGUgYmxpdHRlciBlbmdpbmUgZm9yIGFjY2Vs ZXJhdGVkLCBHUFUKLQkgKiBiYXNlZCBjbGVhcmluZy4KKwkgKiBJOTE1X0JPX0FMTE9DX1VTRVIg d2lsbCBtYWtlIHN1cmUgdGhlIG9iamVjdCBpcyBjbGVhcmVkIGJlZm9yZQorCSAqIGFueSB1c2Vy IGFjY2Vzcy4KIAkgKi8KLQlmbGFncyA9IDA7Ci0JaWYgKG1yLT50eXBlID09IElOVEVMX01FTU9S WV9MT0NBTCkKLQkJZmxhZ3MgPSBJOTE1X0JPX0FMTE9DX0NQVV9DTEVBUjsKKwlmbGFncyA9IEk5 MTVfQk9fQUxMT0NfVVNFUjsKIAogCXJldCA9IG1yLT5vcHMtPmluaXRfb2JqZWN0KG1yLCBvYmos IHNpemUsIGZsYWdzKTsKIAlpZiAocmV0KQpkaWZmIC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJtL2k5 MTUvZ2VtL2k5MTVfZ2VtX2xtZW0uYyBiL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2dlbS9pOTE1X2dl bV9sbWVtLmMKaW5kZXggM2I0YWEyOGEwNzZkLi4yYjhjZDE1ZGUxZDkgMTAwNjQ0Ci0tLSBhL2Ry aXZlcnMvZ3B1L2RybS9pOTE1L2dlbS9pOTE1X2dlbV9sbWVtLmMKKysrIGIvZHJpdmVycy9ncHUv ZHJtL2k5MTUvZ2VtL2k5MTVfZ2VtX2xtZW0uYwpAQCAtNCw3NCArNCwxMCBAQAogICovCiAKICNp bmNsdWRlICJpbnRlbF9tZW1vcnlfcmVnaW9uLmgiCi0jaW5jbHVkZSAiaW50ZWxfcmVnaW9uX3R0 bS5oIgogI2luY2x1ZGUgImdlbS9pOTE1X2dlbV9yZWdpb24uaCIKICNpbmNsdWRlICJnZW0vaTkx NV9nZW1fbG1lbS5oIgogI2luY2x1ZGUgImk5MTVfZHJ2LmgiCiAKLXN0YXRpYyB2b2lkIGxtZW1f cHV0X3BhZ2VzKHN0cnVjdCBkcm1faTkxNV9nZW1fb2JqZWN0ICpvYmosCi0JCQkgICBzdHJ1Y3Qg c2dfdGFibGUgKnBhZ2VzKQotewotCWludGVsX3JlZ2lvbl90dG1fbm9kZV9mcmVlKG9iai0+bW0u cmVnaW9uLCBvYmotPm1tLnN0X21tX25vZGUpOwotCW9iai0+bW0uZGlydHkgPSBmYWxzZTsKLQlz Z19mcmVlX3RhYmxlKHBhZ2VzKTsKLQlrZnJlZShwYWdlcyk7Ci19Ci0KLXN0YXRpYyBpbnQgbG1l bV9nZXRfcGFnZXMoc3RydWN0IGRybV9pOTE1X2dlbV9vYmplY3QgKm9iaikKLXsKLQl1bnNpZ25l ZCBpbnQgZmxhZ3M7Ci0Jc3RydWN0IHNnX3RhYmxlICpwYWdlczsKLQotCWZsYWdzID0gSTkxNV9B TExPQ19NSU5fUEFHRV9TSVpFOwotCWlmIChvYmotPmZsYWdzICYgSTkxNV9CT19BTExPQ19DT05U SUdVT1VTKQotCQlmbGFncyB8PSBJOTE1X0FMTE9DX0NPTlRJR1VPVVM7Ci0KLQlvYmotPm1tLnN0 X21tX25vZGUgPSBpbnRlbF9yZWdpb25fdHRtX25vZGVfYWxsb2Mob2JqLT5tbS5yZWdpb24sCi0J CQkJCQkJIG9iai0+YmFzZS5zaXplLAotCQkJCQkJCSBmbGFncyk7Ci0JaWYgKElTX0VSUihvYmot Pm1tLnN0X21tX25vZGUpKQotCQlyZXR1cm4gUFRSX0VSUihvYmotPm1tLnN0X21tX25vZGUpOwot Ci0JLyogUmFuZ2UgbWFuYWdlciBpcyBhbHdheXMgY29udGlnb3VzICovCi0JaWYgKG9iai0+bW0u cmVnaW9uLT5pc19yYW5nZV9tYW5hZ2VyKQotCQlvYmotPmZsYWdzIHw9IEk5MTVfQk9fQUxMT0Nf Q09OVElHVU9VUzsKLQlwYWdlcyA9IGludGVsX3JlZ2lvbl90dG1fbm9kZV90b19zdChvYmotPm1t LnJlZ2lvbiwgb2JqLT5tbS5zdF9tbV9ub2RlKTsKLQlpZiAoSVNfRVJSKHBhZ2VzKSkgewotCQlp bnRlbF9yZWdpb25fdHRtX25vZGVfZnJlZShvYmotPm1tLnJlZ2lvbiwgb2JqLT5tbS5zdF9tbV9u b2RlKTsKLQkJcmV0dXJuIFBUUl9FUlIocGFnZXMpOwotCX0KLQotCV9faTkxNV9nZW1fb2JqZWN0 X3NldF9wYWdlcyhvYmosIHBhZ2VzLCBpOTE1X3NnX2RtYV9zaXplcyhwYWdlcy0+c2dsKSk7Ci0K LQlpZiAob2JqLT5mbGFncyAmIEk5MTVfQk9fQUxMT0NfQ1BVX0NMRUFSKSB7Ci0JCXZvaWQgX19p b21lbSAqdmFkZHIgPQotCQkJaTkxNV9nZW1fb2JqZWN0X2xtZW1faW9fbWFwKG9iaiwgMCwgb2Jq LT5iYXNlLnNpemUpOwotCi0JCWlmICghdmFkZHIpIHsKLQkJCXN0cnVjdCBzZ190YWJsZSAqcGFn ZXMgPQotCQkJCV9faTkxNV9nZW1fb2JqZWN0X3Vuc2V0X3BhZ2VzKG9iaik7Ci0KLQkJCWlmICgh SVNfRVJSX09SX05VTEwocGFnZXMpKQotCQkJCWxtZW1fcHV0X3BhZ2VzKG9iaiwgcGFnZXMpOwot CQl9Ci0KLQkJbWVtc2V0X2lvKHZhZGRyLCAwLCBvYmotPmJhc2Uuc2l6ZSk7Ci0JCWlvX21hcHBp bmdfdW5tYXAodmFkZHIpOwotCX0KLQotCXJldHVybiAwOwotfQotCi1jb25zdCBzdHJ1Y3QgZHJt X2k5MTVfZ2VtX29iamVjdF9vcHMgaTkxNV9nZW1fbG1lbV9vYmpfb3BzID0gewotCS5uYW1lID0g Imk5MTVfZ2VtX29iamVjdF9sbWVtIiwKLQkuZmxhZ3MgPSBJOTE1X0dFTV9PQkpFQ1RfSEFTX0lP TUVNLAotCi0JLmdldF9wYWdlcyA9IGxtZW1fZ2V0X3BhZ2VzLAotCS5wdXRfcGFnZXMgPSBsbWVt X3B1dF9wYWdlcywKLQkucmVsZWFzZSA9IGk5MTVfZ2VtX29iamVjdF9yZWxlYXNlX21lbW9yeV9y ZWdpb24sCi19OwotCiB2b2lkIF9faW9tZW0gKgogaTkxNV9nZW1fb2JqZWN0X2xtZW1faW9fbWFw KHN0cnVjdCBkcm1faTkxNV9nZW1fb2JqZWN0ICpvYmosCiAJCQkgICAgdW5zaWduZWQgbG9uZyBu LApAQCAtMTAzLDIzICszOSwzIEBAIGk5MTVfZ2VtX29iamVjdF9jcmVhdGVfbG1lbShzdHJ1Y3Qg ZHJtX2k5MTVfcHJpdmF0ZSAqaTkxNSwKIAlyZXR1cm4gaTkxNV9nZW1fb2JqZWN0X2NyZWF0ZV9y ZWdpb24oaTkxNS0+bW0ucmVnaW9uc1tJTlRFTF9SRUdJT05fTE1FTV0sCiAJCQkJCSAgICAgc2l6 ZSwgZmxhZ3MpOwogfQotCi1pbnQgX19pOTE1X2dlbV9sbWVtX29iamVjdF9pbml0KHN0cnVjdCBp bnRlbF9tZW1vcnlfcmVnaW9uICptZW0sCi0JCQkJc3RydWN0IGRybV9pOTE1X2dlbV9vYmplY3Qg Km9iaiwKLQkJCQlyZXNvdXJjZV9zaXplX3Qgc2l6ZSwKLQkJCQl1bnNpZ25lZCBpbnQgZmxhZ3Mp Ci17Ci0Jc3RhdGljIHN0cnVjdCBsb2NrX2NsYXNzX2tleSBsb2NrX2NsYXNzOwotCXN0cnVjdCBk cm1faTkxNV9wcml2YXRlICppOTE1ID0gbWVtLT5pOTE1OwotCi0JZHJtX2dlbV9wcml2YXRlX29i amVjdF9pbml0KCZpOTE1LT5kcm0sICZvYmotPmJhc2UsIHNpemUpOwotCWk5MTVfZ2VtX29iamVj dF9pbml0KG9iaiwgJmk5MTVfZ2VtX2xtZW1fb2JqX29wcywgJmxvY2tfY2xhc3MsIGZsYWdzKTsK LQotCW9iai0+cmVhZF9kb21haW5zID0gSTkxNV9HRU1fRE9NQUlOX1dDIHwgSTkxNV9HRU1fRE9N QUlOX0dUVDsKLQotCWk5MTVfZ2VtX29iamVjdF9zZXRfY2FjaGVfY29oZXJlbmN5KG9iaiwgSTkx NV9DQUNIRV9OT05FKTsKLQotCWk5MTVfZ2VtX29iamVjdF9pbml0X21lbW9yeV9yZWdpb24ob2Jq LCBtZW0pOwotCi0JcmV0dXJuIDA7Ci19CmRpZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9kcm0vaTkx NS9nZW0vaTkxNV9nZW1fbG1lbS5oIGIvZHJpdmVycy9ncHUvZHJtL2k5MTUvZ2VtL2k5MTVfZ2Vt X2xtZW0uaAppbmRleCBmYWM2YmM1YTVlYmIuLmVhNzZmZDExY2NiMCAxMDA2NDQKLS0tIGEvZHJp dmVycy9ncHUvZHJtL2k5MTUvZ2VtL2k5MTVfZ2VtX2xtZW0uaAorKysgYi9kcml2ZXJzL2dwdS9k cm0vaTkxNS9nZW0vaTkxNV9nZW1fbG1lbS5oCkBAIC0yNiw5ICsyNiw0IEBAIGk5MTVfZ2VtX29i amVjdF9jcmVhdGVfbG1lbShzdHJ1Y3QgZHJtX2k5MTVfcHJpdmF0ZSAqaTkxNSwKIAkJCSAgICBy ZXNvdXJjZV9zaXplX3Qgc2l6ZSwKIAkJCSAgICB1bnNpZ25lZCBpbnQgZmxhZ3MpOwogCi1pbnQg X19pOTE1X2dlbV9sbWVtX29iamVjdF9pbml0KHN0cnVjdCBpbnRlbF9tZW1vcnlfcmVnaW9uICpt ZW0sCi0JCQkJc3RydWN0IGRybV9pOTE1X2dlbV9vYmplY3QgKm9iaiwKLQkJCQlyZXNvdXJjZV9z aXplX3Qgc2l6ZSwKLQkJCQl1bnNpZ25lZCBpbnQgZmxhZ3MpOwotCiAjZW5kaWYgLyogIV9fSTkx NV9HRU1fTE1FTV9IICovCmRpZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9kcm0vaTkxNS9nZW0vaTkx NV9nZW1fb2JqZWN0LmMgYi9kcml2ZXJzL2dwdS9kcm0vaTkxNS9nZW0vaTkxNV9nZW1fb2JqZWN0 LmMKaW5kZXggZTkyNDdhZmIwMzIwLi5kZjJiNGU2YjliY2MgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMv Z3B1L2RybS9pOTE1L2dlbS9pOTE1X2dlbV9vYmplY3QuYworKysgYi9kcml2ZXJzL2dwdS9kcm0v aTkxNS9nZW0vaTkxNV9nZW1fb2JqZWN0LmMKQEAgLTE3Myw3ICsxNzMsNyBAQCBzdGF0aWMgdm9p ZCBpOTE1X2dlbV9jbG9zZV9vYmplY3Qoc3RydWN0IGRybV9nZW1fb2JqZWN0ICpnZW0sIHN0cnVj dCBkcm1fZmlsZSAqZgogCX0KIH0KIAotc3RhdGljIHZvaWQgX19pOTE1X2dlbV9mcmVlX29iamVj dF9yY3Uoc3RydWN0IHJjdV9oZWFkICpoZWFkKQordm9pZCBfX2k5MTVfZ2VtX2ZyZWVfb2JqZWN0 X3JjdShzdHJ1Y3QgcmN1X2hlYWQgKmhlYWQpCiB7CiAJc3RydWN0IGRybV9pOTE1X2dlbV9vYmpl Y3QgKm9iaiA9CiAJCWNvbnRhaW5lcl9vZihoZWFkLCB0eXBlb2YoKm9iaiksIHJjdSk7CkBAIC0y MDksNTkgKzIwOSw2OSBAQCBzdGF0aWMgdm9pZCBfX2k5MTVfZ2VtX29iamVjdF9mcmVlX21tYXBz KHN0cnVjdCBkcm1faTkxNV9nZW1fb2JqZWN0ICpvYmopCiAJfQogfQogCi1zdGF0aWMgdm9pZCBf X2k5MTVfZ2VtX2ZyZWVfb2JqZWN0cyhzdHJ1Y3QgZHJtX2k5MTVfcHJpdmF0ZSAqaTkxNSwKLQkJ CQkgICAgc3RydWN0IGxsaXN0X25vZGUgKmZyZWVkKQordm9pZCBfX2k5MTVfZ2VtX2ZyZWVfb2Jq ZWN0KHN0cnVjdCBkcm1faTkxNV9nZW1fb2JqZWN0ICpvYmopCiB7Ci0Jc3RydWN0IGRybV9pOTE1 X2dlbV9vYmplY3QgKm9iaiwgKm9uOworCXRyYWNlX2k5MTVfZ2VtX29iamVjdF9kZXN0cm95KG9i aik7CiAKLQlsbGlzdF9mb3JfZWFjaF9lbnRyeV9zYWZlKG9iaiwgb24sIGZyZWVkLCBmcmVlZCkg ewotCQl0cmFjZV9pOTE1X2dlbV9vYmplY3RfZGVzdHJveShvYmopOworCWlmICghbGlzdF9lbXB0 eSgmb2JqLT52bWEubGlzdCkpIHsKKwkJc3RydWN0IGk5MTVfdm1hICp2bWE7CisKKwkJLyoKKwkJ ICogTm90ZSB0aGF0IHRoZSB2bWEga2VlcHMgYW4gb2JqZWN0IHJlZmVyZW5jZSB3aGlsZQorCQkg KiBpdCBpcyBhY3RpdmUsIHNvIGl0ICpzaG91bGQqIG5vdCBzbGVlcCB3aGlsZSB3ZQorCQkgKiBk ZXN0cm95IGl0LiBPdXIgZGVidWcgY29kZSBlcnJzIGluc2l0cyBpdCAqbWlnaHQqLgorCQkgKiBG b3IgdGhlIG1vbWVudCwgcGxheSBhbG9uZy4KKwkJICovCisJCXNwaW5fbG9jaygmb2JqLT52bWEu bG9jayk7CisJCXdoaWxlICgodm1hID0gbGlzdF9maXJzdF9lbnRyeV9vcl9udWxsKCZvYmotPnZt YS5saXN0LAorCQkJCQkJICAgICAgIHN0cnVjdCBpOTE1X3ZtYSwKKwkJCQkJCSAgICAgICBvYmpf bGluaykpKSB7CisJCQlHRU1fQlVHX09OKHZtYS0+b2JqICE9IG9iaik7CisJCQlzcGluX3VubG9j aygmb2JqLT52bWEubG9jayk7CiAKLQkJaWYgKCFsaXN0X2VtcHR5KCZvYmotPnZtYS5saXN0KSkg ewotCQkJc3RydWN0IGk5MTVfdm1hICp2bWE7CisJCQlfX2k5MTVfdm1hX3B1dCh2bWEpOwogCi0J CQkvKgotCQkJICogTm90ZSB0aGF0IHRoZSB2bWEga2VlcHMgYW4gb2JqZWN0IHJlZmVyZW5jZSB3 aGlsZQotCQkJICogaXQgaXMgYWN0aXZlLCBzbyBpdCAqc2hvdWxkKiBub3Qgc2xlZXAgd2hpbGUg d2UKLQkJCSAqIGRlc3Ryb3kgaXQuIE91ciBkZWJ1ZyBjb2RlIGVycnMgaW5zaXRzIGl0ICptaWdo dCouCi0JCQkgKiBGb3IgdGhlIG1vbWVudCwgcGxheSBhbG9uZy4KLQkJCSAqLwogCQkJc3Bpbl9s b2NrKCZvYmotPnZtYS5sb2NrKTsKLQkJCXdoaWxlICgodm1hID0gbGlzdF9maXJzdF9lbnRyeV9v cl9udWxsKCZvYmotPnZtYS5saXN0LAotCQkJCQkJCSAgICAgICBzdHJ1Y3QgaTkxNV92bWEsCi0J CQkJCQkJICAgICAgIG9ial9saW5rKSkpIHsKLQkJCQlHRU1fQlVHX09OKHZtYS0+b2JqICE9IG9i aik7Ci0JCQkJc3Bpbl91bmxvY2soJm9iai0+dm1hLmxvY2spOworCQl9CisJCXNwaW5fdW5sb2Nr KCZvYmotPnZtYS5sb2NrKTsKKwl9CiAKLQkJCQlfX2k5MTVfdm1hX3B1dCh2bWEpOworCV9faTkx NV9nZW1fb2JqZWN0X2ZyZWVfbW1hcHMob2JqKTsKIAotCQkJCXNwaW5fbG9jaygmb2JqLT52bWEu bG9jayk7Ci0JCQl9Ci0JCQlzcGluX3VubG9jaygmb2JqLT52bWEubG9jayk7Ci0JCX0KKwlHRU1f QlVHX09OKCFsaXN0X2VtcHR5KCZvYmotPmx1dF9saXN0KSk7CiAKLQkJX19pOTE1X2dlbV9vYmpl Y3RfZnJlZV9tbWFwcyhvYmopOworCWF0b21pY19zZXQoJm9iai0+bW0ucGFnZXNfcGluX2NvdW50 LCAwKTsKKwlfX2k5MTVfZ2VtX29iamVjdF9wdXRfcGFnZXMob2JqKTsKKwlHRU1fQlVHX09OKGk5 MTVfZ2VtX29iamVjdF9oYXNfcGFnZXMob2JqKSk7CisJYml0bWFwX2ZyZWUob2JqLT5iaXRfMTcp OwogCi0JCUdFTV9CVUdfT04oIWxpc3RfZW1wdHkoJm9iai0+bHV0X2xpc3QpKTsKKwlpZiAob2Jq LT5iYXNlLmltcG9ydF9hdHRhY2gpCisJCWRybV9wcmltZV9nZW1fZGVzdHJveSgmb2JqLT5iYXNl LCBOVUxMKTsKIAotCQlhdG9taWNfc2V0KCZvYmotPm1tLnBhZ2VzX3Bpbl9jb3VudCwgMCk7Ci0J CV9faTkxNV9nZW1fb2JqZWN0X3B1dF9wYWdlcyhvYmopOwotCQlHRU1fQlVHX09OKGk5MTVfZ2Vt X29iamVjdF9oYXNfcGFnZXMob2JqKSk7Ci0JCWJpdG1hcF9mcmVlKG9iai0+Yml0XzE3KTsKKwlk cm1fZ2VtX2ZyZWVfbW1hcF9vZmZzZXQoJm9iai0+YmFzZSk7CiAKLQkJaWYgKG9iai0+YmFzZS5p bXBvcnRfYXR0YWNoKQotCQkJZHJtX3ByaW1lX2dlbV9kZXN0cm95KCZvYmotPmJhc2UsIE5VTEwp OworCWlmIChvYmotPm9wcy0+cmVsZWFzZSkKKwkJb2JqLT5vcHMtPnJlbGVhc2Uob2JqKTsKIAot CQlkcm1fZ2VtX2ZyZWVfbW1hcF9vZmZzZXQoJm9iai0+YmFzZSk7CisJaWYgKG9iai0+bW0ubl9w bGFjZW1lbnRzID4gMSkKKwkJa2ZyZWUob2JqLT5tbS5wbGFjZW1lbnRzKTsKIAotCQlpZiAob2Jq LT5vcHMtPnJlbGVhc2UpCi0JCQlvYmotPm9wcy0+cmVsZWFzZShvYmopOworCWlmIChvYmotPnNo YXJlc19yZXN2X2Zyb20pCisJCWk5MTVfdm1fcmVzdl9wdXQob2JqLT5zaGFyZXNfcmVzdl9mcm9t KTsKK30KIAotCQlpZiAob2JqLT5tbS5uX3BsYWNlbWVudHMgPiAxKQotCQkJa2ZyZWUob2JqLT5t bS5wbGFjZW1lbnRzKTsKK3N0YXRpYyB2b2lkIF9faTkxNV9nZW1fZnJlZV9vYmplY3RzKHN0cnVj dCBkcm1faTkxNV9wcml2YXRlICppOTE1LAorCQkJCSAgICBzdHJ1Y3QgbGxpc3Rfbm9kZSAqZnJl ZWQpCit7CisJc3RydWN0IGRybV9pOTE1X2dlbV9vYmplY3QgKm9iaiwgKm9uOwogCi0JCWlmIChv YmotPnNoYXJlc19yZXN2X2Zyb20pCi0JCQlpOTE1X3ZtX3Jlc3ZfcHV0KG9iai0+c2hhcmVzX3Jl c3ZfZnJvbSk7CisJbGxpc3RfZm9yX2VhY2hfZW50cnlfc2FmZShvYmosIG9uLCBmcmVlZCwgZnJl ZWQpIHsKKwkJbWlnaHRfc2xlZXAoKTsKKwkJaWYgKG9iai0+b3BzLT5kZWxheWVkX2ZyZWUpIHsK KwkJCW9iai0+b3BzLT5kZWxheWVkX2ZyZWUob2JqKTsKKwkJCWNvbnRpbnVlOworCQl9CisJCV9f aTkxNV9nZW1fZnJlZV9vYmplY3Qob2JqKTsKIAogCQkvKiBCdXQga2VlcCB0aGUgcG9pbnRlciBh bGl2ZSBmb3IgUkNVLXByb3RlY3RlZCBsb29rdXBzICovCiAJCWNhbGxfcmN1KCZvYmotPnJjdSwg X19pOTE1X2dlbV9mcmVlX29iamVjdF9yY3UpOwpAQCAtMzE5LDYgKzMyOSw3IEBAIHN0YXRpYyB2 b2lkIGk5MTVfZ2VtX2ZyZWVfb2JqZWN0KHN0cnVjdCBkcm1fZ2VtX29iamVjdCAqZ2VtX29iaikK IAkgKiB3b3JrZXIgYW5kIHBlcmZvcm1pbmcgZnJlZXMgZGlyZWN0bHkgZnJvbSBzdWJzZXF1ZW50 IGFsbG9jYXRpb25zIGZvcgogCSAqIGNydWRlIGJ1dCBlZmZlY3RpdmUgbWVtb3J5IHRocm90dGxp bmcuCiAJICovCisKIAlpZiAobGxpc3RfYWRkKCZvYmotPmZyZWVkLCAmaTkxNS0+bW0uZnJlZV9s aXN0KSkKIAkJcXVldWVfd29yayhpOTE1LT53cSwgJmk5MTUtPm1tLmZyZWVfd29yayk7CiB9CkBA IC00MTEsNiArNDIyLDQyIEBAIGludCBpOTE1X2dlbV9vYmplY3RfcmVhZF9mcm9tX3BhZ2Uoc3Ry dWN0IGRybV9pOTE1X2dlbV9vYmplY3QgKm9iaiwgdTY0IG9mZnNldCwKIAlyZXR1cm4gMDsKIH0K IAorLyoqCisgKiBpOTE1X2dlbV9vYmplY3RfZXZpY3RhYmxlIC0gV2hldGhlciBvYmplY3QgaXMg bGlrZWx5IGV2aWN0YWJsZSBhZnRlciB1bmJpbmQuCisgKiBAb2JqOiBUaGUgb2JqZWN0IHRvIGNo ZWNrCisgKgorICogVGhpcyBmdW5jdGlvbiBjaGVja3Mgd2hldGhlciB0aGUgb2JqZWN0IGlzIGxp a2VseSB1bnZpY3RhYmxlIGFmdGVyIHVuYmluZC4KKyAqIElmIHRoZSBvYmplY3QgaXMgbm90IGxv Y2tlZCB3aGVuIGNoZWNraW5nLCB0aGUgcmVzdWx0IGlzIG9ubHkgYWR2aXNvcnkuCisgKiBJZiB0 aGUgb2JqZWN0IGlzIGxvY2tlZCB3aGVuIGNoZWNraW5nLCBhbmQgdGhlIGZ1bmN0aW9uIHJldHVy bnMgdHJ1ZSwKKyAqIHRoZW4gYW4gZXZpY3Rpb24gc2hvdWxkIGluZGVlZCBiZSBwb3NzaWJsZS4g QnV0IHNpbmNlIHVubG9ja2VkIHZtYQorICogdW5waW5uaW5nIGFuZCB1bmJpbmRpbmcgaXMgY3Vy cmVudGx5IHBvc3NpYmxlLCB0aGUgb2JqZWN0IGNhbiBhY3R1YWxseQorICogYmVjb21lIGV2aWN0 YWJsZSBldmVuIGlmIHRoaXMgZnVuY3Rpb24gcmV0dXJucyBmYWxzZS4KKyAqCisgKiBSZXR1cm46 IHRydWUgaWYgdGhlIG9iamVjdCBtYXkgYmUgZXZpY3RhYmxlLiBGYWxzZSBvdGhlcndpc2UuCisg Ki8KK2Jvb2wgaTkxNV9nZW1fb2JqZWN0X2V2aWN0YWJsZShzdHJ1Y3QgZHJtX2k5MTVfZ2VtX29i amVjdCAqb2JqKQoreworCXN0cnVjdCBpOTE1X3ZtYSAqdm1hOworCWludCBwaW5fY291bnQgPSBh dG9taWNfcmVhZCgmb2JqLT5tbS5wYWdlc19waW5fY291bnQpOworCisJaWYgKCFwaW5fY291bnQp CisJCXJldHVybiB0cnVlOworCisJc3Bpbl9sb2NrKCZvYmotPnZtYS5sb2NrKTsKKwlsaXN0X2Zv cl9lYWNoX2VudHJ5KHZtYSwgJm9iai0+dm1hLmxpc3QsIG9ial9saW5rKSB7CisJCWlmIChpOTE1 X3ZtYV9pc19waW5uZWQodm1hKSkgeworCQkJc3Bpbl91bmxvY2soJm9iai0+dm1hLmxvY2spOwor CQkJcmV0dXJuIGZhbHNlOworCQl9CisJCWlmIChhdG9taWNfcmVhZCgmdm1hLT5wYWdlc19jb3Vu dCkpCisJCQlwaW5fY291bnQtLTsKKwl9CisJc3Bpbl91bmxvY2soJm9iai0+dm1hLmxvY2spOwor CUdFTV9XQVJOX09OKHBpbl9jb3VudCA8IDApOworCisJcmV0dXJuIHBpbl9jb3VudCA9PSAwOwor fQorCiB2b2lkIGk5MTVfZ2VtX2luaXRfX29iamVjdHMoc3RydWN0IGRybV9pOTE1X3ByaXZhdGUg Kmk5MTUpCiB7CiAJSU5JVF9XT1JLKCZpOTE1LT5tbS5mcmVlX3dvcmssIF9faTkxNV9nZW1fZnJl ZV93b3JrKTsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2dlbS9pOTE1X2dlbV9v YmplY3QuaCBiL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2dlbS9pOTE1X2dlbV9vYmplY3QuaAppbmRl eCAyZWJkNzk1MzdhZWEuLmFlNTkzMGUzMDdkNSAxMDA2NDQKLS0tIGEvZHJpdmVycy9ncHUvZHJt L2k5MTUvZ2VtL2k5MTVfZ2VtX29iamVjdC5oCisrKyBiL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2dl bS9pOTE1X2dlbV9vYmplY3QuaApAQCAtMjAwLDYgKzIwMCw5IEBAIHN0YXRpYyBpbmxpbmUgYm9v bCBpOTE1X2dlbV9vYmplY3RfdHJ5bG9jayhzdHJ1Y3QgZHJtX2k5MTVfZ2VtX29iamVjdCAqb2Jq KQogCiBzdGF0aWMgaW5saW5lIHZvaWQgaTkxNV9nZW1fb2JqZWN0X3VubG9jayhzdHJ1Y3QgZHJt X2k5MTVfZ2VtX29iamVjdCAqb2JqKQogeworCWlmIChvYmotPm9wcy0+YWRqdXN0X2xydSkKKwkJ b2JqLT5vcHMtPmFkanVzdF9scnUob2JqKTsKKwogCWRtYV9yZXN2X3VubG9jayhvYmotPmJhc2Uu cmVzdik7CiB9CiAKQEAgLTU4Nyw2ICs1OTAsMTIgQEAgaW50IGk5MTVfZ2VtX29iamVjdF9yZWFk X2Zyb21fcGFnZShzdHJ1Y3QgZHJtX2k5MTVfZ2VtX29iamVjdCAqb2JqLCB1NjQgb2Zmc2V0LAog CiBib29sIGk5MTVfZ2VtX29iamVjdF9pc19zaG1lbShjb25zdCBzdHJ1Y3QgZHJtX2k5MTVfZ2Vt X29iamVjdCAqb2JqKTsKIAordm9pZCBfX2k5MTVfZ2VtX2ZyZWVfb2JqZWN0X3JjdShzdHJ1Y3Qg cmN1X2hlYWQgKmhlYWQpOworCit2b2lkIF9faTkxNV9nZW1fZnJlZV9vYmplY3Qoc3RydWN0IGRy bV9pOTE1X2dlbV9vYmplY3QgKm9iaik7CisKK2Jvb2wgaTkxNV9nZW1fb2JqZWN0X2V2aWN0YWJs ZShzdHJ1Y3QgZHJtX2k5MTVfZ2VtX29iamVjdCAqb2JqKTsKKwogI2lmZGVmIENPTkZJR19NTVVf Tk9USUZJRVIKIHN0YXRpYyBpbmxpbmUgYm9vbAogaTkxNV9nZW1fb2JqZWN0X2lzX3VzZXJwdHIo c3RydWN0IGRybV9pOTE1X2dlbV9vYmplY3QgKm9iaikKZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1 L2RybS9pOTE1L2dlbS9pOTE1X2dlbV9vYmplY3RfdHlwZXMuaCBiL2RyaXZlcnMvZ3B1L2RybS9p OTE1L2dlbS9pOTE1X2dlbV9vYmplY3RfdHlwZXMuaAppbmRleCBkMDQ3ZWExMjYwMjkuLjY4MzEz NDc0ZTZhNiAxMDA2NDQKLS0tIGEvZHJpdmVycy9ncHUvZHJtL2k5MTUvZ2VtL2k5MTVfZ2VtX29i amVjdF90eXBlcy5oCisrKyBiL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2dlbS9pOTE1X2dlbV9vYmpl Y3RfdHlwZXMuaApAQCAtNjMsNiArNjMsMjAgQEAgc3RydWN0IGRybV9pOTE1X2dlbV9vYmplY3Rf b3BzIHsKIAkJICAgICAgY29uc3Qgc3RydWN0IGRybV9pOTE1X2dlbV9wd3JpdGUgKmFyZyk7CiAK IAlpbnQgKCpkbWFidWZfZXhwb3J0KShzdHJ1Y3QgZHJtX2k5MTVfZ2VtX29iamVjdCAqb2JqKTsK KworCS8qKgorCSAqIGFkanVzdF9scnUgLSBub3RpZnkgdGhhdCB0aGUgbWFkdmlzZSB2YWx1ZSB3 YXMgdXBkYXRlZAorCSAqIEBvYmo6IFRoZSBnZW0gb2JqZWN0CisJICoKKwkgKiBUaGUgbWFkdmlz ZSB2YWx1ZSBtYXkgaGF2ZSBiZWVuIHVwZGF0ZWQsIG9yIG9iamVjdCB3YXMgcmVjZW50bHkKKwkg KiByZWZlcmVuY2VkIHNvIGFjdCBhY2NvcmRpbmdseSAoUGVyaGFwcyBjaGFuZ2luZyBhbiBMUlUg bGlzdCBldGMpLgorCSAqLworCXZvaWQgKCphZGp1c3RfbHJ1KShzdHJ1Y3QgZHJtX2k5MTVfZ2Vt X29iamVjdCAqb2JqKTsKKworCS8qKgorCSAqIGRlbGF5ZWRfZnJlZSAtIE92ZXJyaWRlIHRoZSBk ZWZhdWx0IGRlbGF5ZWQgZnJlZSBpbXBsZW1lbnRhdGlvbgorCSAqLworCXZvaWQgKCpkZWxheWVk X2ZyZWUpKHN0cnVjdCBkcm1faTkxNV9nZW1fb2JqZWN0ICpvYmopOwogCXZvaWQgKCpyZWxlYXNl KShzdHJ1Y3QgZHJtX2k5MTVfZ2VtX29iamVjdCAqb2JqKTsKIAogCWNvbnN0IGNoYXIgKm5hbWU7 IC8qIGZyaWVuZGx5IG5hbWUgZm9yIGRlYnVnLCBlLmcuIGxvY2tkZXAgY2xhc3NlcyAqLwpAQCAt MTg3LDEyICsyMDEsMTQgQEAgc3RydWN0IGRybV9pOTE1X2dlbV9vYmplY3QgewogI2RlZmluZSBJ OTE1X0JPX0FMTE9DX1ZPTEFUSUxFICAgQklUKDEpCiAjZGVmaW5lIEk5MTVfQk9fQUxMT0NfU1RS VUNUX1BBR0UgQklUKDIpCiAjZGVmaW5lIEk5MTVfQk9fQUxMT0NfQ1BVX0NMRUFSICBCSVQoMykK KyNkZWZpbmUgSTkxNV9CT19BTExPQ19VU0VSICAgICAgIEJJVCg0KQogI2RlZmluZSBJOTE1X0JP X0FMTE9DX0ZMQUdTIChJOTE1X0JPX0FMTE9DX0NPTlRJR1VPVVMgfCBcCiAJCQkgICAgIEk5MTVf Qk9fQUxMT0NfVk9MQVRJTEUgfCBcCiAJCQkgICAgIEk5MTVfQk9fQUxMT0NfU1RSVUNUX1BBR0Ug fCBcCi0JCQkgICAgIEk5MTVfQk9fQUxMT0NfQ1BVX0NMRUFSKQotI2RlZmluZSBJOTE1X0JPX1JF QURPTkxZICAgICAgICAgQklUKDQpCi0jZGVmaW5lIEk5MTVfVElMSU5HX1FVSVJLX0JJVCAgICA1 IC8qIHVua25vd24gc3dpenpsaW5nOyBkbyBub3QgcmVsZWFzZSEgKi8KKwkJCSAgICAgSTkxNV9C T19BTExPQ19DUFVfQ0xFQVIgfCBcCisJCQkgICAgIEk5MTVfQk9fQUxMT0NfVVNFUikKKyNkZWZp bmUgSTkxNV9CT19SRUFET05MWSAgICAgICAgIEJJVCg1KQorI2RlZmluZSBJOTE1X1RJTElOR19R VUlSS19CSVQgICAgNiAvKiB1bmtub3duIHN3aXp6bGluZzsgZG8gbm90IHJlbGVhc2UhICovCiAK IAkvKgogCSAqIElzIHRoZSBvYmplY3QgdG8gYmUgbWFwcGVkIGFzIHJlYWQtb25seSB0byB0aGUg R1BVCkBAIC0zMTAsNiArMzI2LDExIEBAIHN0cnVjdCBkcm1faTkxNV9nZW1fb2JqZWN0IHsKIAkJ Ym9vbCBkaXJ0eToxOwogCX0gbW07CiAKKwlzdHJ1Y3QgeworCQlzdHJ1Y3Qgc2dfdGFibGUgKmNh Y2hlZF9pb19zdDsKKwkJYm9vbCBjcmVhdGVkOjE7CisJfSB0dG07CisKIAkvKiogUmVjb3JkIG9m IGFkZHJlc3MgYml0IDE3IG9mIGVhY2ggcGFnZSBhdCBsYXN0IHVuYmluZC4gKi8KIAl1bnNpZ25l ZCBsb25nICpiaXRfMTc7CiAKZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2dlbS9p OTE1X2dlbV9yZWdpb24uYyBiL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2dlbS9pOTE1X2dlbV9yZWdp b24uYwppbmRleCBmMjVlNjY0NmM1YjcuLmQxZjE4NDA1NDBkZCAxMDA2NDQKLS0tIGEvZHJpdmVy cy9ncHUvZHJtL2k5MTUvZ2VtL2k5MTVfZ2VtX3JlZ2lvbi5jCisrKyBiL2RyaXZlcnMvZ3B1L2Ry bS9pOTE1L2dlbS9pOTE1X2dlbV9yZWdpb24uYwpAQCAtMTgsMTEgKzE4LDcgQEAgdm9pZCBpOTE1 X2dlbV9vYmplY3RfaW5pdF9tZW1vcnlfcmVnaW9uKHN0cnVjdCBkcm1faTkxNV9nZW1fb2JqZWN0 ICpvYmosCiAKIAltdXRleF9sb2NrKCZtZW0tPm9iamVjdHMubG9jayk7CiAKLQlpZiAob2JqLT5m bGFncyAmIEk5MTVfQk9fQUxMT0NfVk9MQVRJTEUpCi0JCWxpc3RfYWRkKCZvYmotPm1tLnJlZ2lv bl9saW5rLCAmbWVtLT5vYmplY3RzLnB1cmdlYWJsZSk7Ci0JZWxzZQotCQlsaXN0X2FkZCgmb2Jq LT5tbS5yZWdpb25fbGluaywgJm1lbS0+b2JqZWN0cy5saXN0KTsKLQorCWxpc3RfYWRkKCZvYmot Pm1tLnJlZ2lvbl9saW5rLCAmbWVtLT5vYmplY3RzLmxpc3QpOwogCW11dGV4X3VubG9jaygmbWVt LT5vYmplY3RzLmxvY2spOwogfQogCmRpZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9kcm0vaTkxNS9n ZW0vaTkxNV9nZW1fdHRtLmMgYi9kcml2ZXJzL2dwdS9kcm0vaTkxNS9nZW0vaTkxNV9nZW1fdHRt LmMKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwLi4xNzU5ODkzMGE5OWUK LS0tIC9kZXYvbnVsbAorKysgYi9kcml2ZXJzL2dwdS9kcm0vaTkxNS9nZW0vaTkxNV9nZW1fdHRt LmMKQEAgLTAsMCArMSw1NDEgQEAKKy8vIFNQRFgtTGljZW5zZS1JZGVudGlmaWVyOiBNSVQKKy8q CisgKiBDb3B5cmlnaHQgwqkgMjAyMSBJbnRlbCBDb3Jwb3JhdGlvbgorICovCisKKyNpbmNsdWRl IDxkcm0vdHRtL3R0bV9ib19kcml2ZXIuaD4KKyNpbmNsdWRlIDxkcm0vdHRtL3R0bV9wbGFjZW1l bnQuaD4KKworI2luY2x1ZGUgImk5MTVfZHJ2LmgiCisjaW5jbHVkZSAiaW50ZWxfbWVtb3J5X3Jl Z2lvbi5oIgorI2luY2x1ZGUgImludGVsX3JlZ2lvbl90dG0uaCIKKworI2luY2x1ZGUgImdlbS9p OTE1X2dlbV9vYmplY3QuaCIKKyNpbmNsdWRlICJnZW0vaTkxNV9nZW1fcmVnaW9uLmgiCisjaW5j bHVkZSAiZ2VtL2k5MTVfZ2VtX3R0bS5oIgorCisjZGVmaW5lIEk5MTVfUExfTE1FTTAgVFRNX1BM X1BSSVYKKyNkZWZpbmUgSTkxNV9QTF9TWVNURU0gVFRNX1BMX1NZU1RFTQorI2RlZmluZSBJOTE1 X1BMX1NUT0xFTiBUVE1fUExfVlJBTQorI2RlZmluZSBJOTE1X1BMX0dHVFQgVFRNX1BMX1RUCisK KyNkZWZpbmUgSTkxNV9UVE1fUFJJT19QVVJHRSAgICAgMAorI2RlZmluZSBJOTE1X1RUTV9QUklP X05PX1BBR0VTICAxCisjZGVmaW5lIEk5MTVfVFRNX1BSSU9fSEFTX1BBR0VTIDIKKworLyoqCisg KiBzdHJ1Y3QgaTkxNV90dG1fdHQgLSBUVE0gcGFnZSB2ZWN0b3Igd2l0aCBhZGRpdGlvbmFsIHBy aXZhdGUgaW5mb3JtYXRpb24KKyAqIEB0dG06IFRoZSBiYXNlIFRUTSBwYWdlIHZlY3Rvci4KKyAq IEBkZXY6IFRoZSBzdHJ1Y3QgZGV2aWNlIHVzZWQgZm9yIGRtYSBtYXBwaW5nIGFuZCB1bm1hcHBp bmcuCisgKiBAY2FjaGVkX3N0OiBUaGUgY2FjaGVkIHNjYXR0ZXItZ2F0aGVyIHRhYmxlLgorICoK KyAqIE5vdGUgdGhhdCBETUEgbWF5IGJlIGdvaW5nIG9uIHJpZ2h0IHVwIHRvIHRoZSBwb2ludCB3 aGVyZSB0aGUgcGFnZS0KKyAqIHZlY3RvciBpcyB1bnBvcHVsYXRlZCBpbiBkZWxheWVkIGRlc3Ry b3kuIEhlbmNlIGtlZXAgdGhlCisgKiBzY2F0dGVyLWdhdGhlciB0YWJsZSBtYXBwZWQgYW5kIGNh Y2hlZCB1cCB0byB0aGF0IHBvaW50LiBUaGlzIGlzCisgKiBkaWZmZXJlbnQgZnJvbSB0aGUgY2Fj aGVkIGdlbSBvYmplY3QgaW8gc2NhdHRlci1nYXRoZXIgdGFibGUgd2hpY2gKKyAqIGRvZXNuJ3Qg aGF2ZSBhbiBhc3NvY2lhdGVkIGRtYSBtYXBwaW5nLgorICovCitzdHJ1Y3QgaTkxNV90dG1fdHQg eworCXN0cnVjdCB0dG1fdHQgdHRtOworCXN0cnVjdCBkZXZpY2UgKmRldjsKKwlzdHJ1Y3Qgc2df dGFibGUgKmNhY2hlZF9zdDsKK307CisKK3N0YXRpYyBjb25zdCBzdHJ1Y3QgdHRtX3BsYWNlIGxt ZW0wX3N5c19wbGFjZW1lbnRfZmxhZ3NbXSA9IHsKKwl7CisJCS5mcGZuID0gMCwKKwkJLmxwZm4g PSAwLAorCQkubWVtX3R5cGUgPSBJOTE1X1BMX0xNRU0wLAorCQkuZmxhZ3MgPSAwLAorCX0sIHsK KwkJLmZwZm4gPSAwLAorCQkubHBmbiA9IDAsCisJCS5tZW1fdHlwZSA9IEk5MTVfUExfU1lTVEVN LAorCQkuZmxhZ3MgPSAwLAorCX0KK307CisKK3N0YXRpYyBzdHJ1Y3QgdHRtX3BsYWNlbWVudCBp OTE1X2xtZW0wX3BsYWNlbWVudCA9IHsKKwkubnVtX3BsYWNlbWVudCA9IDEsCisJLnBsYWNlbWVu dCA9ICZsbWVtMF9zeXNfcGxhY2VtZW50X2ZsYWdzWzBdLAorCS5udW1fYnVzeV9wbGFjZW1lbnQg PSAxLAorCS5idXN5X3BsYWNlbWVudCA9ICZsbWVtMF9zeXNfcGxhY2VtZW50X2ZsYWdzWzBdLAor fTsKKworc3RhdGljIHN0cnVjdCB0dG1fcGxhY2VtZW50IGk5MTVfc3lzX3BsYWNlbWVudCA9IHsK KwkubnVtX3BsYWNlbWVudCA9IDEsCisJLnBsYWNlbWVudCA9ICZsbWVtMF9zeXNfcGxhY2VtZW50 X2ZsYWdzWzFdLAorCS5udW1fYnVzeV9wbGFjZW1lbnQgPSAxLAorCS5idXN5X3BsYWNlbWVudCA9 ICZsbWVtMF9zeXNfcGxhY2VtZW50X2ZsYWdzWzFdLAorfTsKKworc3RhdGljIHZvaWQgaTkxNV90 dG1fYWRqdXN0X2xydShzdHJ1Y3QgZHJtX2k5MTVfZ2VtX29iamVjdCAqb2JqKTsKKworc3RhdGlj IHN0cnVjdCB0dG1fdHQgKmk5MTVfdHRtX3R0X2NyZWF0ZShzdHJ1Y3QgdHRtX2J1ZmZlcl9vYmpl Y3QgKmJvLAorCQkJCQkgdWludDMyX3QgcGFnZV9mbGFncykKK3sKKwlzdHJ1Y3QgdHRtX3Jlc291 cmNlX21hbmFnZXIgKm1hbiA9CisJCXR0bV9tYW5hZ2VyX3R5cGUoYm8tPmJkZXYsIGJvLT5tZW0u bWVtX3R5cGUpOworCXN0cnVjdCBkcm1faTkxNV9nZW1fb2JqZWN0ICpvYmogPSBpOTE1X3R0bV90 b19nZW0oYm8pOworCXN0cnVjdCBpOTE1X3R0bV90dCAqaTkxNV90dDsKKwlpbnQgcmV0OworCisJ aTkxNV90dCA9IGt6YWxsb2Moc2l6ZW9mKCppOTE1X3R0KSwgR0ZQX0tFUk5FTCk7CisJaWYgKCFp OTE1X3R0KQorCQlyZXR1cm4gTlVMTDsKKworCWlmIChvYmotPmZsYWdzICYgSTkxNV9CT19BTExP Q19DUFVfQ0xFQVIgJiYKKwkgICAgbWFuLT51c2VfdHQpCisJCXBhZ2VfZmxhZ3MgfD0gVFRNX1BB R0VfRkxBR19aRVJPX0FMTE9DOworCisJcmV0ID0gdHRtX3R0X2luaXQoJmk5MTVfdHQtPnR0bSwg Ym8sIHBhZ2VfZmxhZ3MsIHR0bV93cml0ZV9jb21iaW5lZCk7CisJaWYgKHJldCkgeworCQlrZnJl ZShpOTE1X3R0KTsKKwkJcmV0dXJuIE5VTEw7CisJfQorCisJaTkxNV90dC0+ZGV2ID0gb2JqLT5i YXNlLmRldi0+ZGV2OworCisJcmV0dXJuICZpOTE1X3R0LT50dG07Cit9CisKK3N0YXRpYyB2b2lk IGk5MTVfdHRtX3R0X3VucG9wdWxhdGUoc3RydWN0IHR0bV9kZXZpY2UgKmJkZXYsIHN0cnVjdCB0 dG1fdHQgKnR0bSkKK3sKKwlzdHJ1Y3QgaTkxNV90dG1fdHQgKmk5MTVfdHQgPSBjb250YWluZXJf b2YodHRtLCB0eXBlb2YoKmk5MTVfdHQpLCB0dG0pOworCisJaWYgKGk5MTVfdHQtPmNhY2hlZF9z dCkgeworCQlkbWFfdW5tYXBfc2d0YWJsZShpOTE1X3R0LT5kZXYsIGk5MTVfdHQtPmNhY2hlZF9z dCwKKwkJCQkgIERNQV9CSURJUkVDVElPTkFMLCAwKTsKKwkJc2dfZnJlZV90YWJsZShpOTE1X3R0 LT5jYWNoZWRfc3QpOworCQlrZnJlZShpOTE1X3R0LT5jYWNoZWRfc3QpOworCQlpOTE1X3R0LT5j YWNoZWRfc3QgPSBOVUxMOworCX0KKwl0dG1fcG9vbF9mcmVlKCZiZGV2LT5wb29sLCB0dG0pOwor fQorCitzdGF0aWMgdm9pZCBpOTE1X3R0bV90dF9kZXN0cm95KHN0cnVjdCB0dG1fZGV2aWNlICpi ZGV2LCBzdHJ1Y3QgdHRtX3R0ICp0dG0pCit7CisJc3RydWN0IGk5MTVfdHRtX3R0ICppOTE1X3R0 ID0gY29udGFpbmVyX29mKHR0bSwgdHlwZW9mKCppOTE1X3R0KSwgdHRtKTsKKworCXR0bV90dF9k ZXN0cm95X2NvbW1vbihiZGV2LCB0dG0pOworCWtmcmVlKGk5MTVfdHQpOworfQorCitzdGF0aWMg Ym9vbCBpOTE1X3R0bV9ldmljdGlvbl92YWx1YWJsZShzdHJ1Y3QgdHRtX2J1ZmZlcl9vYmplY3Qg KmJvLAorCQkJCSAgICAgICBjb25zdCBzdHJ1Y3QgdHRtX3BsYWNlICpwbGFjZSkKK3sKKwlzdHJ1 Y3QgZHJtX2k5MTVfZ2VtX29iamVjdCAqb2JqID0gaTkxNV90dG1fdG9fZ2VtKGJvKTsKKworCS8q IFdpbGwgZG8gZm9yIG5vdy4gT3VyIHBpbm5lZCBvYmplY3RzIGFyZSBzdGlsbCBvbiBUVE0ncyBM UlUgbGlzdHMgKi8KKwlpZiAoIWk5MTVfZ2VtX29iamVjdF9ldmljdGFibGUob2JqKSkKKwkJcmV0 dXJuIGZhbHNlOworCisJLyogVGhpcyBpc24ndCB2YWxpZCB3aXRoIGEgYnVkZHkgYWxsb2NhdG9y ICovCisJcmV0dXJuIHR0bV9ib19ldmljdGlvbl92YWx1YWJsZShibywgcGxhY2UpOworfQorCitz dGF0aWMgdm9pZCBpOTE1X3R0bV9ldmljdF9mbGFncyhzdHJ1Y3QgdHRtX2J1ZmZlcl9vYmplY3Qg KmJvLAorCQkJCSBzdHJ1Y3QgdHRtX3BsYWNlbWVudCAqcGxhY2VtZW50KQoreworCSpwbGFjZW1l bnQgPSBpOTE1X3N5c19wbGFjZW1lbnQ7Cit9CisKK3N0YXRpYyBpbnQgaTkxNV90dG1fbW92ZV9u b3RpZnkoc3RydWN0IHR0bV9idWZmZXJfb2JqZWN0ICpibykKK3sKKwlzdHJ1Y3QgZHJtX2k5MTVf Z2VtX29iamVjdCAqb2JqID0gaTkxNV90dG1fdG9fZ2VtKGJvKTsKKwlpbnQgcmV0OworCisJcmV0 ID0gaTkxNV9nZW1fb2JqZWN0X3VuYmluZChvYmosIEk5MTVfR0VNX09CSkVDVF9VTkJJTkRfQUNU SVZFKTsKKwlpZiAocmV0KQorCQlyZXR1cm4gcmV0OworCisJcmV0ID0gX19pOTE1X2dlbV9vYmpl Y3RfcHV0X3BhZ2VzKG9iaik7CisJaWYgKHJldCkKKwkJcmV0dXJuIHJldDsKKworCXJldHVybiAw OworfQorCitzdGF0aWMgdm9pZCBpOTE1X3R0bV9mcmVlX2NhY2hlZF9pb19zdChzdHJ1Y3QgZHJt X2k5MTVfZ2VtX29iamVjdCAqb2JqKQoreworCWlmIChvYmotPnR0bS5jYWNoZWRfaW9fc3QpIHsK KwkJc2dfZnJlZV90YWJsZShvYmotPnR0bS5jYWNoZWRfaW9fc3QpOworCQlrZnJlZShvYmotPnR0 bS5jYWNoZWRfaW9fc3QpOworCQlvYmotPnR0bS5jYWNoZWRfaW9fc3QgPSBOVUxMOworCX0KK30K Kworc3RhdGljIHZvaWQgaTkxNV90dG1fcHVyZ2Uoc3RydWN0IGRybV9pOTE1X2dlbV9vYmplY3Qg Km9iaikKK3sKKwlzdHJ1Y3QgdHRtX2J1ZmZlcl9vYmplY3QgKmJvID0gaTkxNV9nZW1fdG9fdHRt KG9iaik7CisJc3RydWN0IHR0bV9vcGVyYXRpb25fY3R4IGN0eCA9IHsKKwkJLmludGVycnVwdGli bGUgPSB0cnVlLAorCQkubm9fd2FpdF9ncHUgPSBmYWxzZSwKKwl9OworCXN0cnVjdCB0dG1fcGxh Y2VtZW50IHBsYWNlID0ge307CisJaW50IHJldDsKKworCWlmIChvYmotPm1tLm1hZHYgPT0gX19J OTE1X01BRFZfUFVSR0VEKQorCQlyZXR1cm47CisKKwkvKiBUVE0ncyBwdXJnZSBpbnRlcmZhY2Uu IE5vdGUgdGhhdCB3ZSBtaWdodCBiZSByZWVudGVyaW5nLiAqLworCXJldCA9IHR0bV9ib192YWxp ZGF0ZShibywgJnBsYWNlLCAmY3R4KTsKKworCWlmICghcmV0KSB7CisJCWk5MTVfdHRtX2ZyZWVf Y2FjaGVkX2lvX3N0KG9iaik7CisJCW9iai0+bW0ubWFkdiA9IF9fSTkxNV9NQURWX1BVUkdFRDsK Kwl9Cit9CisKK3N0YXRpYyB2b2lkIGk5MTVfdHRtX3N3YXBfbm90aWZ5KHN0cnVjdCB0dG1fYnVm ZmVyX29iamVjdCAqYm8pCit7CisJc3RydWN0IGRybV9pOTE1X2dlbV9vYmplY3QgKm9iaiA9IGk5 MTVfdHRtX3RvX2dlbShibyk7CisJaW50IHJldCA9IGk5MTVfdHRtX21vdmVfbm90aWZ5KGJvKTsK KworCUdFTV9XQVJOX09OKHJldCk7CisJR0VNX1dBUk5fT04ob2JqLT50dG0uY2FjaGVkX2lvX3N0 KTsKKwlpZiAoIXJldCAmJiBvYmotPm1tLm1hZHYgIT0gSTkxNV9NQURWX1dJTExORUVEKQorCQlp OTE1X3R0bV9wdXJnZShvYmopOworfQorCitzdGF0aWMgdm9pZCBpOTE1X3R0bV9kZWxldGVfbWVt X25vdGlmeShzdHJ1Y3QgdHRtX2J1ZmZlcl9vYmplY3QgKmJvKQoreworCXN0cnVjdCBkcm1faTkx NV9nZW1fb2JqZWN0ICpvYmogPSBpOTE1X3R0bV90b19nZW0oYm8pOworCisJaWYgKGxpa2VseShv YmopKSB7CisJCS8qIFRoaXMgcmVsZWFzZXMgYWxsIGdlbSBvYmplY3QgYmluZGluZ3MgdG8gdGhl IGJhY2tlbmQuICovCisJCV9faTkxNV9nZW1fZnJlZV9vYmplY3Qob2JqKTsKKwl9Cit9CisKK3N0 YXRpYyBzdHJ1Y3QgaW50ZWxfbWVtb3J5X3JlZ2lvbiAqCitpOTE1X3R0bV9yZWdpb24oc3RydWN0 IHR0bV9kZXZpY2UgKmJkZXYsIGludCB0dG1fbWVtX3R5cGUpCit7CisJc3RydWN0IGRybV9pOTE1 X3ByaXZhdGUgKmk5MTUgPSBjb250YWluZXJfb2YoYmRldiwgdHlwZW9mKCppOTE1KSwgYmRldik7 CisKKwkvKiBUaGVyZSdzIHNvbWUgcm9vbSBmb3Igb3B0aW1pemF0aW9uIGhlcmUuLi4gKi8KKwlH RU1fQlVHX09OKHR0bV9tZW1fdHlwZSAhPSBJOTE1X1BMX1NZU1RFTSAmJgorCQkgICB0dG1fbWVt X3R5cGUgPCBJOTE1X1BMX0xNRU0wKTsKKwlpZiAodHRtX21lbV90eXBlID09IEk5MTVfUExfU1lT VEVNKQorCQlyZXR1cm4gaW50ZWxfbWVtb3J5X3JlZ2lvbl9sb29rdXAoaTkxNSwgSU5URUxfTUVN T1JZX1NZU1RFTSwKKwkJCQkJCSAgMCk7CisKKwlyZXR1cm4gaW50ZWxfbWVtb3J5X3JlZ2lvbl9s b29rdXAoaTkxNSwgSU5URUxfTUVNT1JZX0xPQ0FMLAorCQkJCQkgIHR0bV9tZW1fdHlwZSAtIEk5 MTVfUExfTE1FTTApOworfQorCitzdGF0aWMgc3RydWN0IHNnX3RhYmxlICppOTE1X3R0bV90dF9n ZXRfc3Qoc3RydWN0IHR0bV90dCAqdHRtKQoreworCXN0cnVjdCBpOTE1X3R0bV90dCAqaTkxNV90 dCA9IGNvbnRhaW5lcl9vZih0dG0sIHR5cGVvZigqaTkxNV90dCksIHR0bSk7CisJc3RydWN0IHNj YXR0ZXJsaXN0ICpzZzsKKwlzdHJ1Y3Qgc2dfdGFibGUgKnN0OworCWludCByZXQ7CisKKwlpZiAo aTkxNV90dC0+Y2FjaGVkX3N0KQorCQlyZXR1cm4gaTkxNV90dC0+Y2FjaGVkX3N0OworCisJc3Qg PSBremFsbG9jKHNpemVvZigqc3QpLCBHRlBfS0VSTkVMKTsKKwlpZiAoIXN0KQorCQlyZXR1cm4g RVJSX1BUUigtRU5PTUVNKTsKKworCXNnID0gX19zZ19hbGxvY190YWJsZV9mcm9tX3BhZ2VzCisJ CShzdCwgdHRtLT5wYWdlcywgdHRtLT5udW1fcGFnZXMsIDAsCisJCSAodW5zaWduZWQgbG9uZyl0 dG0tPm51bV9wYWdlcyA8PCBQQUdFX1NISUZULAorCQkgaTkxNV9zZ19zZWdtZW50X3NpemUoKSwg TlVMTCwgMCwgR0ZQX0tFUk5FTCk7CisJaWYgKElTX0VSUihzZykpIHsKKwkJa2ZyZWUoc3QpOwor CQlyZXR1cm4gRVJSX0NBU1Qoc2cpOworCX0KKworCXJldCA9IGRtYV9tYXBfc2d0YWJsZShpOTE1 X3R0LT5kZXYsIHN0LCBETUFfQklESVJFQ1RJT05BTCwgMCk7CisJaWYgKHJldCkgeworCQlzZ19m cmVlX3RhYmxlKHN0KTsKKwkJa2ZyZWUoc3QpOworCQlyZXR1cm4gRVJSX1BUUihyZXQpOworCX0K KworCWk5MTVfdHQtPmNhY2hlZF9zdCA9IHN0OworCXJldHVybiBzdDsKK30KKworc3RhdGljIHN0 cnVjdCBzZ190YWJsZSAqCitpOTE1X3R0bV9yZXNvdXJjZV9nZXRfc3Qoc3RydWN0IGRybV9pOTE1 X2dlbV9vYmplY3QgKm9iaiwKKwkJCSBzdHJ1Y3QgdHRtX3Jlc291cmNlICpyZXMpCit7CisJc3Ry dWN0IHR0bV9idWZmZXJfb2JqZWN0ICpibyA9IGk5MTVfZ2VtX3RvX3R0bShvYmopOworCXN0cnVj dCB0dG1fcmVzb3VyY2VfbWFuYWdlciAqbWFuID0KKwkJdHRtX21hbmFnZXJfdHlwZShiby0+YmRl diwgcmVzLT5tZW1fdHlwZSk7CisKKwlpZiAobWFuLT51c2VfdHQpCisJCXJldHVybiBpOTE1X3R0 bV90dF9nZXRfc3QoYm8tPnR0bSk7CisKKwlyZXR1cm4gaW50ZWxfcmVnaW9uX3R0bV9ub2RlX3Rv X3N0KG9iai0+bW0ucmVnaW9uLCByZXMtPm1tX25vZGUpOworfQorCitzdGF0aWMgaW50IGk5MTVf dHRtX21vdmUoc3RydWN0IHR0bV9idWZmZXJfb2JqZWN0ICpibywgYm9vbCBldmljdCwKKwkJCSBz dHJ1Y3QgdHRtX29wZXJhdGlvbl9jdHggKmN0eCwKKwkJCSBzdHJ1Y3QgdHRtX3Jlc291cmNlICpk c3RfbWVtLAorCQkJIHN0cnVjdCB0dG1fcGxhY2UgKmhvcCkKK3sKKwlzdHJ1Y3QgZHJtX2k5MTVf Z2VtX29iamVjdCAqb2JqID0gaTkxNV90dG1fdG9fZ2VtKGJvKTsKKwlzdHJ1Y3QgdHRtX3Jlc291 cmNlX21hbmFnZXIgKmRzdF9tYW4gPQorCQl0dG1fbWFuYWdlcl90eXBlKGJvLT5iZGV2LCBkc3Rf bWVtLT5tZW1fdHlwZSk7CisJc3RydWN0IHR0bV9yZXNvdXJjZV9tYW5hZ2VyICpzcmNfbWFuID0K KwkJdHRtX21hbmFnZXJfdHlwZShiby0+YmRldiwgYm8tPm1lbS5tZW1fdHlwZSk7CisJc3RydWN0 IGludGVsX21lbW9yeV9yZWdpb24gKmRzdF9yZWcsICpzcmNfcmVnOworCXVuaW9uIHsKKwkJc3Ry dWN0IHR0bV9rbWFwX2l0ZXJfdHQgdHQ7CisJCXN0cnVjdCB0dG1fa21hcF9pdGVyX2lvbWFwIGlv OworCX0gX2RzdF9pdGVyLCBfc3JjX2l0ZXI7CisJc3RydWN0IHR0bV9rbWFwX2l0ZXIgKmRzdF9p dGVyLCAqc3JjX2l0ZXI7CisJc3RydWN0IHNnX3RhYmxlICpkc3Rfc3Q7CisJaW50IHJldDsKKwor CWRzdF9yZWcgPSBpOTE1X3R0bV9yZWdpb24oYm8tPmJkZXYsIGRzdF9tZW0tPm1lbV90eXBlKTsK KwlzcmNfcmVnID0gaTkxNV90dG1fcmVnaW9uKGJvLT5iZGV2LCBiby0+bWVtLm1lbV90eXBlKTsK KwlHRU1fQlVHX09OKCFkc3RfcmVnIHx8ICFzcmNfcmVnKTsKKworCS8qIFN5bmMgZm9yIG5vdy4g V2UgY291bGQgZG8gdGhlIGFjdHVhbCBjb3B5IGFzeW5jLiAqLworCXJldCA9IHR0bV9ib193YWl0 X2N0eChibywgY3R4KTsKKwlpZiAocmV0KQorCQlyZXR1cm4gcmV0OworCisJcmV0ID0gaTkxNV90 dG1fbW92ZV9ub3RpZnkoYm8pOworCWlmIChyZXQpCisJCXJldHVybiByZXQ7CisKKwlpZiAob2Jq LT5tbS5tYWR2ICE9IEk5MTVfTUFEVl9XSUxMTkVFRCkgeworCQlpOTE1X3R0bV9wdXJnZShvYmop OworCQl0dG1fcmVzb3VyY2VfZnJlZShibywgZHN0X21lbSk7CisJCXJldHVybiAwOworCX0KKwor CS8qIFBvcHVsYXRlIHR0bSB3aXRoIHBhZ2VzIGlmIG5lZWRlZC4gVHlwaWNhbGx5IHN5c3RlbSBt ZW1vcnkuICovCisJaWYgKGJvLT50dG0gJiYgKGRzdF9tYW4tPnVzZV90dCB8fAorCQkJKGJvLT50 dG0tPnBhZ2VfZmxhZ3MgJiBUVE1fUEFHRV9GTEFHX1NXQVBQRUQpKSkgeworCQlyZXQgPSB0dG1f dHRfcG9wdWxhdGUoYm8tPmJkZXYsIGJvLT50dG0sIGN0eCk7CisJCWlmIChyZXQpCisJCQlyZXR1 cm4gcmV0OworCX0KKworCWRzdF9zdCA9IGk5MTVfdHRtX3Jlc291cmNlX2dldF9zdChvYmosIGRz dF9tZW0pOworCWlmIChJU19FUlIoZHN0X3N0KSkKKwkJcmV0dXJuIFBUUl9FUlIoZHN0X3N0KTsK KworCS8qIElmIHdlIHN0YXJ0IG1hcHBpbmcgR0dUVCwgd2UgY2FuIG5vIGxvbmdlciB1c2UgbWFu Ojp1c2VfdHQgaGVyZS4gKi8KKwlkc3RfaXRlciA9IGRzdF9tYW4tPnVzZV90dCA/CisJCXR0bV9r bWFwX2l0ZXJfdHRfaW5pdCgmX2RzdF9pdGVyLnR0LCBiby0+dHRtKSA6CisJCXR0bV9rbWFwX2l0 ZXJfaW9tYXBfaW5pdCgmX2RzdF9pdGVyLmlvLCAmZHN0X3JlZy0+aW9tYXAsCisJCQkJCSBkc3Rf c3QsIGRzdF9yZWctPnJlZ2lvbi5zdGFydCk7CisKKwlzcmNfaXRlciA9IHNyY19tYW4tPnVzZV90 dCA/CisJCXR0bV9rbWFwX2l0ZXJfdHRfaW5pdCgmX3NyY19pdGVyLnR0LCBiby0+dHRtKSA6CisJ CXR0bV9rbWFwX2l0ZXJfaW9tYXBfaW5pdCgmX3NyY19pdGVyLmlvLCAmc3JjX3JlZy0+aW9tYXAs CisJCQkJCSBvYmotPnR0bS5jYWNoZWRfaW9fc3QsCisJCQkJCSBzcmNfcmVnLT5yZWdpb24uc3Rh cnQpOworCisJdHRtX21vdmVfbWVtY3B5KGJvLCBkc3RfbWVtLT5udW1fcGFnZXMsIGRzdF9pdGVy LCBzcmNfaXRlcik7CisJdHRtX2JvX21vdmVfc3luY19jbGVhbnVwKGJvLCBkc3RfbWVtKTsKKwlp OTE1X3R0bV9mcmVlX2NhY2hlZF9pb19zdChvYmopOworCisJaWYgKCFkc3RfbWFuLT51c2VfdHQp CisJCW9iai0+dHRtLmNhY2hlZF9pb19zdCA9IGRzdF9zdDsKKworCXJldHVybiAwOworfQorCitz dGF0aWMgc3RydWN0IHR0bV9kZXZpY2VfZnVuY3MgaTkxNV90dG1fYm9fZHJpdmVyID0geworCS50 dG1fdHRfY3JlYXRlID0gaTkxNV90dG1fdHRfY3JlYXRlLAorCS50dG1fdHRfdW5wb3B1bGF0ZSA9 IGk5MTVfdHRtX3R0X3VucG9wdWxhdGUsCisJLnR0bV90dF9kZXN0cm95ID0gaTkxNV90dG1fdHRf ZGVzdHJveSwKKwkuZXZpY3Rpb25fdmFsdWFibGUgPSBpOTE1X3R0bV9ldmljdGlvbl92YWx1YWJs ZSwKKwkuZXZpY3RfZmxhZ3MgPSBpOTE1X3R0bV9ldmljdF9mbGFncywKKwkubW92ZSA9IGk5MTVf dHRtX21vdmUsCisJLnZlcmlmeV9hY2Nlc3MgPSBOVUxMLAorCS5zd2FwX25vdGlmeSA9IGk5MTVf dHRtX3N3YXBfbm90aWZ5LAorCS5kZWxldGVfbWVtX25vdGlmeSA9IGk5MTVfdHRtX2RlbGV0ZV9t ZW1fbm90aWZ5LAorfTsKKworLyoqCisgKiBpOTE1X3R0bV9kcml2ZXIgLSBSZXR1cm4gYSBwb2lu dGVyIHRvIHRoZSBUVE0gZGV2aWNlIGZ1bmNzCisgKgorICogUmV0dXJuOiBQb2ludGVyIHRvIHN0 YXRpY2FsbHkgYWxsb2NhdGVkIFRUTSBkZXZpY2UgZnVuY3MuCisgKi8KK3N0cnVjdCB0dG1fZGV2 aWNlX2Z1bmNzICppOTE1X3R0bV9kcml2ZXIodm9pZCkKK3sKKwlyZXR1cm4gJmk5MTVfdHRtX2Jv X2RyaXZlcjsKK30KKworc3RhdGljIGludCBpOTE1X3R0bV9nZXRfcGFnZXMoc3RydWN0IGRybV9p OTE1X2dlbV9vYmplY3QgKm9iaikKK3sKKwlzdHJ1Y3QgdHRtX2J1ZmZlcl9vYmplY3QgKmJvID0g aTkxNV9nZW1fdG9fdHRtKG9iaik7CisJc3RydWN0IHR0bV9vcGVyYXRpb25fY3R4IGN0eCA9IHsK KwkJLmludGVycnVwdGlibGUgPSB0cnVlLAorCQkubm9fd2FpdF9ncHUgPSBmYWxzZSwKKwl9Owor CXN0cnVjdCBzZ190YWJsZSAqc3Q7CisJaW50IHJldDsKKworCS8qIE1vdmUgdG8gdGhlIHJlcXVl c3RlZCBwbGFjZW1lbnQuICovCisJcmV0ID0gdHRtX2JvX3ZhbGlkYXRlKGJvLCAmaTkxNV9sbWVt MF9wbGFjZW1lbnQsICZjdHgpOworCWlmIChyZXQpCisJCXJldHVybiByZXQgPT0gLUVOT1NQQyA/ IC1FTlhJTyA6IHJldDsKKworCS8qIE9iamVjdCBlaXRoZXIgaGFzIGEgcGFnZSB2ZWN0b3Igb3Ig aXMgYW4gaW9tZW0gb2JqZWN0ICovCisJc3QgPSBiby0+dHRtID8gaTkxNV90dG1fdHRfZ2V0X3N0 KGJvLT50dG0pIDogb2JqLT50dG0uY2FjaGVkX2lvX3N0OworCWlmIChJU19FUlIoc3QpKQorCQly ZXR1cm4gUFRSX0VSUihzdCk7CisKKwlfX2k5MTVfZ2VtX29iamVjdF9zZXRfcGFnZXMob2JqLCBz dCwgaTkxNV9zZ19kbWFfc2l6ZXMoc3QtPnNnbCkpOworCisJaTkxNV90dG1fYWRqdXN0X2xydShv YmopOworCisJcmV0dXJuIHJldDsKK30KKworc3RhdGljIHZvaWQgaTkxNV90dG1fcHV0X3BhZ2Vz KHN0cnVjdCBkcm1faTkxNV9nZW1fb2JqZWN0ICpvYmosCisJCQkgICAgICAgc3RydWN0IHNnX3Rh YmxlICpzdCkKK3sKKwkvKgorCSAqIFdlJ3JlIGN1cnJlbnRseSBub3QgY2FsbGVkIGZyb20gYSBz aHJpbmtlciwgc28gcHV0X3BhZ2VzKCkKKwkgKiB0eXBpY2FsbHkgbWVhbnMgdGhlIG9iamVjdCBp cyBhYm91dCB0byBkZXN0cm95ZWQsIG9yIGNhbGxlZAorCSAqIGZyb20gbW92ZV9ub3RpZnkoKS4g U28ganVzdCBhdm9pZCBkb2luZyBtdWNoIGZvciBub3cuCisJICogSWYgdGhlIG9iamVjdCBpcyBu b3QgZGVzdHJveWVkIG5leHQsIFRoZSBUVE0gZXZpY3Rpb24gbG9naWMKKwkgKiBhbmQgc2hyaW5r ZXJzIHdpbGwgbW92ZSBpdCBvdXQgaWYgbmVlZGVkLgorCSAqLworCisJaTkxNV90dG1fYWRqdXN0 X2xydShvYmopOworfQorCitzdGF0aWMgdm9pZCBpOTE1X3R0bV9hZGp1c3RfbHJ1KHN0cnVjdCBk cm1faTkxNV9nZW1fb2JqZWN0ICpvYmopCit7CisJc3RydWN0IHR0bV9idWZmZXJfb2JqZWN0ICpi byA9IGk5MTVfZ2VtX3RvX3R0bShvYmopOworCisJLyoKKwkgKiBEb24ndCBtYW5pcHVsYXRlIHRo ZSBUVE0gTFJVcyB3aGlsZSBpbiBUVE0gYm8gZGVzdHJ1Y3Rpb24uCisJICogV2UncmUgY2FsbGVk IHRocm91Z2ggaTkxNV90dG1fZGVsZXRlX21lbV9ub3RpZnkoKS4KKwkgKi8KKwlpZiAoIWtyZWZf cmVhZCgmYm8tPmtyZWYpKQorCQlyZXR1cm47CisKKwkvKgorCSAqIFB1dCBvbiB0aGUgY29ycmVj dCBMUlUgbGlzdCBkZXBlbmRpbmcgb24gdGhlIE1BRFYgc3RhdHVzCisJICovCisJc3Bpbl9sb2Nr KCZiby0+YmRldi0+bHJ1X2xvY2spOworCWlmIChvYmotPm1tLm1hZHYgIT0gSTkxNV9NQURWX1dJ TExORUVEKSB7CisJCWJvLT5wcmlvcml0eSA9IEk5MTVfVFRNX1BSSU9fUFVSR0U7CisJfSBlbHNl IGlmICghaTkxNV9nZW1fb2JqZWN0X2hhc19wYWdlcyhvYmopKSB7CisJCWlmIChiby0+cHJpb3Jp dHkgPCBJOTE1X1RUTV9QUklPX0hBU19QQUdFUykKKwkJCWJvLT5wcmlvcml0eSA9IEk5MTVfVFRN X1BSSU9fSEFTX1BBR0VTOworCX0gZWxzZSB7CisJCWlmIChiby0+cHJpb3JpdHkgPiBJOTE1X1RU TV9QUklPX05PX1BBR0VTKQorCQkJYm8tPnByaW9yaXR5ID0gSTkxNV9UVE1fUFJJT19OT19QQUdF UzsKKwl9CisKKwl0dG1fYm9fbW92ZV90b19scnVfdGFpbChibywgJmJvLT5tZW0sIE5VTEwpOwor CXNwaW5fdW5sb2NrKCZiby0+YmRldi0+bHJ1X2xvY2spOworfQorCisvKgorICogVFRNLWJhY2tl ZCBnZW0gb2JqZWN0IGRlc3RydWN0aW9uIHJlcXVpcmVzIHNvbWUgY2xhcmlmaWNhdGlvbi4KKyAq IEJhc2ljYWxseSB3ZSBoYXZlIHR3byBwb3NzaWJpbGl0aWVzIGhlcmUuIFdlIGNhbiBlaXRoZXIg cmVseSBvbiB0aGUKKyAqIGk5MTUgZGVsYXllZCBkZXN0cnVjdGlvbiBhbmQgcHV0IHRoZSBUVE0g b2JqZWN0IHdoZW4gdGhlIG9iamVjdAorICogaXMgaWRsZS4gVGhpcyB3b3VsZCBiZSBkZXRlY3Rl ZCBieSBUVE0gd2hpY2ggd291bGQgYnlwYXNzIHRoZQorICogVFRNIGRlbGF5ZWQgZGVzdHJveSBo YW5kbGluZy4gVGhlIG90aGVyIGFwcHJvYWNoIGlzIHRvIHB1dCB0aGUgVFRNCisgKiBvYmplY3Qg ZWFybHkgYW5kIHJlbHkgb24gdGhlIFRUTSBkZXN0cm95ZWQgaGFuZGxpbmcsIGFuZCB0aGVuIGZy ZWUKKyAqIHRoZSBsZWZ0b3ZlciBwYXJ0cyBvZiB0aGUgR0VNIG9iamVjdCBvbmNlIFRUTSdzIGRl c3Ryb3llZCBsaXN0IGhhbmRsaW5nIGlzCisgKiBjb21wbGV0ZS4gRm9yIG5vdywgd2UgcmVseSBv biB0aGUgbGF0dGVyIGZvciB0d28gcmVhc29uczoKKyAqIGEpIFRUTSBjYW4gZXZpY3QgYW4gb2Jq ZWN0IGV2ZW4gd2hlbiBpdCdzIG9uIHRoZSBkZWxheWVkIGRlc3Ryb3kgbGlzdCwKKyAqIHdoaWNo IGluIHRoZW9yeSBhbGxvd3MgZm9yIGNvbXBsZXRlIGV2aWN0aW9uLgorICogYikgVGhlcmUgaXMg d29yayBnb2luZyBvbiBpbiBUVE0gdG8gYWxsb3cgZnJlZWluZyBhbiBvYmplY3QgZXZlbiB3aGVu CisgKiBpdCdzIG5vdCBpZGxlLCBhbmQgdXNpbmcgdGhlIFRUTSBkZXN0cm95ZWQgbGlzdCBoYW5k bGluZyBjb3VsZCBoZWxwIHVzCisgKiBiZW5lZml0IGZyb20gdGhhdC4KKyAqLworc3RhdGljIHZv aWQgaTkxNV90dG1fZGVsYXllZF9mcmVlKHN0cnVjdCBkcm1faTkxNV9nZW1fb2JqZWN0ICpvYmop Cit7CisJaWYgKG9iai0+dHRtLmNyZWF0ZWQpIHsKKwkJdHRtX2JvX3B1dChpOTE1X2dlbV90b190 dG0ob2JqKSk7CisJfSBlbHNlIHsKKwkJX19pOTE1X2dlbV9mcmVlX29iamVjdChvYmopOworCQlj YWxsX3JjdSgmb2JqLT5yY3UsIF9faTkxNV9nZW1fZnJlZV9vYmplY3RfcmN1KTsKKwl9Cit9CisK K3N0YXRpYyBjb25zdCBzdHJ1Y3QgZHJtX2k5MTVfZ2VtX29iamVjdF9vcHMgaTkxNV9nZW1fdHRt X29ial9vcHMgPSB7CisJLm5hbWUgPSAiaTkxNV9nZW1fb2JqZWN0X3R0bSIsCisJLmZsYWdzID0g STkxNV9HRU1fT0JKRUNUX0hBU19JT01FTSwKKworCS5nZXRfcGFnZXMgPSBpOTE1X3R0bV9nZXRf cGFnZXMsCisJLnB1dF9wYWdlcyA9IGk5MTVfdHRtX3B1dF9wYWdlcywKKwkudHJ1bmNhdGUgPSBp OTE1X3R0bV9wdXJnZSwKKwkuYWRqdXN0X2xydSA9IGk5MTVfdHRtX2FkanVzdF9scnUsCisJLmRl bGF5ZWRfZnJlZSA9IGk5MTVfdHRtX2RlbGF5ZWRfZnJlZSwKK307CisKK3ZvaWQgaTkxNV90dG1f Ym9fZGVzdHJveShzdHJ1Y3QgdHRtX2J1ZmZlcl9vYmplY3QgKmJvKQoreworCXN0cnVjdCBkcm1f aTkxNV9nZW1fb2JqZWN0ICpvYmogPSBpOTE1X3R0bV90b19nZW0oYm8pOworCisJaTkxNV9nZW1f b2JqZWN0X3JlbGVhc2VfbWVtb3J5X3JlZ2lvbihvYmopOworCWlmIChvYmotPnR0bS5jcmVhdGVk KQorCQljYWxsX3JjdSgmb2JqLT5yY3UsIF9faTkxNV9nZW1fZnJlZV9vYmplY3RfcmN1KTsKK30K KworLyoqCisgKiBfX2k5MTVfZ2VtX3R0bV9vYmplY3RfaW5pdCAtIEluaXRpYWxpemUgYSB0dG0t YmFja2VkIGk5MTUgZ2VtIG9iamVjdAorICogQG1lbTogVGhlIGluaXRpYWwgbWVtb3J5IHJlZ2lv biBmb3IgdGhlIG9iamVjdC4KKyAqIEBvYmo6IFRoZSBnZW0gb2JqZWN0LgorICogQHNpemU6IE9i amVjdCBzaXplIGluIGJ5dGVzLgorICogQGZsYWdzOiBnZW0gb2JqZWN0IGZsYWdzLgorICoKKyAq IFJldHVybjogMCBvbiBzdWNjZXNzLCBuZWdhdGl2ZSBlcnJvciBjb2RlIG9uIGZhaWx1cmUuCisg Ki8KK2ludCBfX2k5MTVfZ2VtX3R0bV9vYmplY3RfaW5pdChzdHJ1Y3QgaW50ZWxfbWVtb3J5X3Jl Z2lvbiAqbWVtLAorCQkJICAgICAgIHN0cnVjdCBkcm1faTkxNV9nZW1fb2JqZWN0ICpvYmosCisJ CQkgICAgICAgcmVzb3VyY2Vfc2l6ZV90IHNpemUsCisJCQkgICAgICAgdW5zaWduZWQgaW50IGZs YWdzKQoreworCXN0YXRpYyBzdHJ1Y3QgbG9ja19jbGFzc19rZXkgbG9ja19jbGFzczsKKwlzdHJ1 Y3QgZHJtX2k5MTVfcHJpdmF0ZSAqaTkxNSA9IG1lbS0+aTkxNTsKKwllbnVtIHR0bV9ib190eXBl IGJvX3R5cGU7CisJc2l6ZV90IGFsaWdubWVudCA9IDA7CisJaW50IHJldDsKKworCS8qIEFkanVz dCBhbGlnbm1lbnQgdG8gR1BVLSBhbmQgQ1BVIGh1Z2UgcGFnZSBzaXplcy4gKi8KKworCWlmICht ZW0tPmlzX3JhbmdlX21hbmFnZXIpIHsKKwkJaWYgKHNpemUgPj0gU1pfMUcpCisJCQlhbGlnbm1l bnQgPSBTWl8xRyA+PiBQQUdFX1NISUZUOworCQllbHNlIGlmIChzaXplID49IFNaXzJNKQorCQkJ YWxpZ25tZW50ID0gU1pfMk0gPj4gUEFHRV9TSElGVDsKKwkJZWxzZSBpZiAoc2l6ZSA+PSBTWl82 NEspCisJCQlhbGlnbm1lbnQgPSBTWl82NEsgPj4gUEFHRV9TSElGVDsKKwl9CisKKwlkcm1fZ2Vt X3ByaXZhdGVfb2JqZWN0X2luaXQoJmk5MTUtPmRybSwgJm9iai0+YmFzZSwgc2l6ZSk7CisJaTkx NV9nZW1fb2JqZWN0X2luaXQob2JqLCAmaTkxNV9nZW1fdHRtX29ial9vcHMsICZsb2NrX2NsYXNz LCBmbGFncyk7CisJaTkxNV9nZW1fb2JqZWN0X2luaXRfbWVtb3J5X3JlZ2lvbihvYmosIG1lbSk7 CisJaTkxNV9nZW1fb2JqZWN0X21ha2VfdW5zaHJpbmthYmxlKG9iaik7CisJb2JqLT5yZWFkX2Rv bWFpbnMgPSBJOTE1X0dFTV9ET01BSU5fV0MgfCBJOTE1X0dFTV9ET01BSU5fR1RUOworCWk5MTVf Z2VtX29iamVjdF9zZXRfY2FjaGVfY29oZXJlbmN5KG9iaiwgSTkxNV9DQUNIRV9OT05FKTsKKwor CWJvX3R5cGUgPSAob2JqLT5mbGFncyAmIEk5MTVfQk9fQUxMT0NfVVNFUikgPyB0dG1fYm9fdHlw ZV9kZXZpY2UgOgorCQl0dG1fYm9fdHlwZV9rZXJuZWw7CisKKwkvKgorCSAqIElmIHRoaXMgZnVu Y3Rpb24gZmFpbHMsIGl0IHdpbGwgY2FsbCB0aGUgZGVzdHJ1Y3RvciwgYnV0CisJICogb3VyIGNh bGxlciBzdGlsbCBvd25zIHRoZSBvYmplY3QuIFNvIG5vIGZyZWVpbmcgaW4gdGhlCisJICogZGVz dHJ1Y3RvciB1bnRpbCBvYmotPnR0bS5jcmVhdGVkIGlzIHRydWUuCisJICogU2ltaWxhcmx5LCBp biBkZWxheWVkX2Rlc3Ryb3ksIHdlIGNhbid0IGNhbGwgdHRtX2JvX3B1dCgpCisJICogdW50aWwg c3VjY2Vzc2Z1bCBpbml0aWFsaXphdGlvbi4KKwkgKi8KKwlyZXQgPSB0dG1fYm9faW5pdCgmaTkx NS0+YmRldiwgaTkxNV9nZW1fdG9fdHRtKG9iaiksIHNpemUsCisJCQkgIGJvX3R5cGUsICZpOTE1 X3N5c19wbGFjZW1lbnQsIGFsaWdubWVudCwKKwkJCSAgdHJ1ZSwgTlVMTCwgTlVMTCwgaTkxNV90 dG1fYm9fZGVzdHJveSk7CisKKwlpZiAoIXJldCkKKwkJb2JqLT50dG0uY3JlYXRlZCA9IHRydWU7 CisKKwkvKiBpOTE1IHdhbnRzIC1FTlhJTyB3aGVuIG91dCBvZiBtZW1vcnkgcmVnaW9uIHNwYWNl LiAqLworCXJldHVybiAocmV0ID09IC1FTk9TUEMpID8gLUVOWElPIDogcmV0OworfQpkaWZmIC0t Z2l0IGEvZHJpdmVycy9ncHUvZHJtL2k5MTUvZ2VtL2k5MTVfZ2VtX3R0bS5oIGIvZHJpdmVycy9n cHUvZHJtL2k5MTUvZ2VtL2k5MTVfZ2VtX3R0bS5oCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4 IDAwMDAwMDAwMDAwMC4uYjhkM2RjYmI1MGRmCi0tLSAvZGV2L251bGwKKysrIGIvZHJpdmVycy9n cHUvZHJtL2k5MTUvZ2VtL2k5MTVfZ2VtX3R0bS5oCkBAIC0wLDAgKzEsNDggQEAKKy8qIFNQRFgt TGljZW5zZS1JZGVudGlmaWVyOiBNSVQgKi8KKy8qCisgKiBDb3B5cmlnaHQgwqkgMjAyMSBJbnRl bCBDb3Jwb3JhdGlvbgorICovCisjaWZuZGVmIF9JOTE1X0dFTV9UVE1fSF8KKyNkZWZpbmUgX0k5 MTVfR0VNX1RUTV9IXworCisjaW5jbHVkZSAiZ2VtL2k5MTVfZ2VtX29iamVjdF90eXBlcy5oIgor CisvKioKKyAqIGk5MTVfZ2VtX3RvX3R0bSAtIENvbnZlcnQgYSBzdHJ1Y3QgZHJtX2k5MTVfZ2Vt X29iamVjdCB0byBhCisgKiBzdHJ1Y3QgdHRtX2J1ZmZlcl9vYmplY3QuCisgKiBAb2JqOiBQb2lu dGVyIHRvIHRoZSBnZW0gb2JqZWN0LgorICoKKyAqIFJldHVybjogUG9pbnRlciB0byB0aGUgZW1i ZWRkZWQgc3RydWN0IHR0bV9idWZmZXJfb2JqZWN0LgorICovCitzdGF0aWMgaW5saW5lIHN0cnVj dCB0dG1fYnVmZmVyX29iamVjdCAqCitpOTE1X2dlbV90b190dG0oc3RydWN0IGRybV9pOTE1X2dl bV9vYmplY3QgKm9iaikKK3sKKwlyZXR1cm4gJm9iai0+X19kb19ub3RfYWNjZXNzOworfQorCisv KgorICogaTkxNSB0dG0gZ2VtIG9iamVjdCBkZXN0cnVjdG9yLiBJbnRlcm5hbCB1c2Ugb25seS4K KyAqLwordm9pZCBpOTE1X3R0bV9ib19kZXN0cm95KHN0cnVjdCB0dG1fYnVmZmVyX29iamVjdCAq Ym8pOworCisvKioKKyAqIGk5MTVfdHRtX3RvX2dlbSAtIENvbnZlcnQgYSBzdHJ1Y3QgdHRtX2J1 ZmZlcl9vYmplY3QgdG8gYW4gZW1iZWRkaW5nCisgKiBzdHJ1Y3QgZHJtX2k5MTVfZ2VtX29iamVj dC4KKyAqCisgKiBSZXR1cm46IFBvaW50ZXIgdG8gdGhlIGVtYmVkZGluZyBzdHJ1Y3QgdHRtX2J1 ZmZlcl9vYmplY3QsIG9yIE5VTEwKKyAqIGlmIHRoZSBvYmplY3Qgd2FzIG5vdCBhbiBpOTE1IHR0 bSBvYmplY3QuCisgKi8KK3N0YXRpYyBpbmxpbmUgc3RydWN0IGRybV9pOTE1X2dlbV9vYmplY3Qg KgoraTkxNV90dG1fdG9fZ2VtKHN0cnVjdCB0dG1fYnVmZmVyX29iamVjdCAqYm8pCit7CisJaWYg KEdFTV9XQVJOX09OKGJvLT5kZXN0cm95ICE9IGk5MTVfdHRtX2JvX2Rlc3Ryb3kpKQorCQlyZXR1 cm4gTlVMTDsKKworCXJldHVybiBjb250YWluZXJfb2YoYm8sIHN0cnVjdCBkcm1faTkxNV9nZW1f b2JqZWN0LCBfX2RvX25vdF9hY2Nlc3MpOworfQorCitpbnQgX19pOTE1X2dlbV90dG1fb2JqZWN0 X2luaXQoc3RydWN0IGludGVsX21lbW9yeV9yZWdpb24gKm1lbSwKKwkJCSAgICAgICBzdHJ1Y3Qg ZHJtX2k5MTVfZ2VtX29iamVjdCAqb2JqLAorCQkJICAgICAgIHJlc291cmNlX3NpemVfdCBzaXpl LAorCQkJICAgICAgIHVuc2lnbmVkIGludCBmbGFncyk7CisjZW5kaWYKZGlmZiAtLWdpdCBhL2Ry aXZlcnMvZ3B1L2RybS9pOTE1L2d0L2ludGVsX3JlZ2lvbl9sbWVtLmMgYi9kcml2ZXJzL2dwdS9k cm0vaTkxNS9ndC9pbnRlbF9yZWdpb25fbG1lbS5jCmluZGV4IGY3MzY2YjA1NGY4ZS4uNGFlMWY3 MTdhOTRjIDEwMDY0NAotLS0gYS9kcml2ZXJzL2dwdS9kcm0vaTkxNS9ndC9pbnRlbF9yZWdpb25f bG1lbS5jCisrKyBiL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2d0L2ludGVsX3JlZ2lvbl9sbWVtLmMK QEAgLTksNiArOSw3IEBACiAjaW5jbHVkZSAiaW50ZWxfcmVnaW9uX3R0bS5oIgogI2luY2x1ZGUg ImdlbS9pOTE1X2dlbV9sbWVtLmgiCiAjaW5jbHVkZSAiZ2VtL2k5MTVfZ2VtX3JlZ2lvbi5oIgor I2luY2x1ZGUgImdlbS9pOTE1X2dlbV90dG0uaCIKICNpbmNsdWRlICJpbnRlbF9yZWdpb25fbG1l bS5oIgogCiBzdGF0aWMgaW50IGluaXRfZmFrZV9sbWVtX2JhcihzdHJ1Y3QgaW50ZWxfbWVtb3J5 X3JlZ2lvbiAqbWVtKQpAQCAtMTA3LDcgKzEwOCw3IEBAIHJlZ2lvbl9sbWVtX2luaXQoc3RydWN0 IGludGVsX21lbW9yeV9yZWdpb24gKm1lbSkKIHN0YXRpYyBjb25zdCBzdHJ1Y3QgaW50ZWxfbWVt b3J5X3JlZ2lvbl9vcHMgaW50ZWxfcmVnaW9uX2xtZW1fb3BzID0gewogCS5pbml0ID0gcmVnaW9u X2xtZW1faW5pdCwKIAkucmVsZWFzZSA9IHJlZ2lvbl9sbWVtX3JlbGVhc2UsCi0JLmluaXRfb2Jq ZWN0ID0gX19pOTE1X2dlbV9sbWVtX29iamVjdF9pbml0LAorCS5pbml0X29iamVjdCA9IF9faTkx NV9nZW1fdHRtX29iamVjdF9pbml0LAogfTsKIAogc3RydWN0IGludGVsX21lbW9yeV9yZWdpb24g KgpkaWZmIC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJtL2k5MTUvaTkxNV9nZW0uYyBiL2RyaXZlcnMv Z3B1L2RybS9pOTE1L2k5MTVfZ2VtLmMKaW5kZXggMDk5M2Q3MDZmMDY3Li40MGZlOWExNDczMTgg MTAwNjQ0Ci0tLSBhL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2k5MTVfZ2VtLmMKKysrIGIvZHJpdmVy cy9ncHUvZHJtL2k5MTUvaTkxNV9nZW0uYwpAQCAtMTAwNSw4ICsxMDA1LDExIEBAIGk5MTVfZ2Vt X21hZHZpc2VfaW9jdGwoc3RydWN0IGRybV9kZXZpY2UgKmRldiwgdm9pZCAqZGF0YSwKIAkJfQog CX0KIAotCWlmIChvYmotPm1tLm1hZHYgIT0gX19JOTE1X01BRFZfUFVSR0VEKQorCWlmIChvYmot Pm1tLm1hZHYgIT0gX19JOTE1X01BRFZfUFVSR0VEKSB7CiAJCW9iai0+bW0ubWFkdiA9IGFyZ3Mt Pm1hZHY7CisJCWlmIChvYmotPm9wcy0+YWRqdXN0X2xydSkKKwkJCW9iai0+b3BzLT5hZGp1c3Rf bHJ1KG9iaik7CisJfQogCiAJaWYgKGk5MTVfZ2VtX29iamVjdF9oYXNfcGFnZXMob2JqKSkgewog CQl1bnNpZ25lZCBsb25nIGZsYWdzOwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJtL2k5MTUv aW50ZWxfbWVtb3J5X3JlZ2lvbi5jIGIvZHJpdmVycy9ncHUvZHJtL2k5MTUvaW50ZWxfbWVtb3J5 X3JlZ2lvbi5jCmluZGV4IDQwOTJjYzk4NzY3OS4uYmQyN2U4OTdkNGQwIDEwMDY0NAotLS0gYS9k cml2ZXJzL2dwdS9kcm0vaTkxNS9pbnRlbF9tZW1vcnlfcmVnaW9uLmMKKysrIGIvZHJpdmVycy9n cHUvZHJtL2k5MTUvaW50ZWxfbWVtb3J5X3JlZ2lvbi5jCkBAIC0xNDksNyArMTQ5LDYgQEAgaW50 ZWxfbWVtb3J5X3JlZ2lvbl9jcmVhdGUoc3RydWN0IGRybV9pOTE1X3ByaXZhdGUgKmk5MTUsCiAK IAltdXRleF9pbml0KCZtZW0tPm9iamVjdHMubG9jayk7CiAJSU5JVF9MSVNUX0hFQUQoJm1lbS0+ b2JqZWN0cy5saXN0KTsKLQlJTklUX0xJU1RfSEVBRCgmbWVtLT5vYmplY3RzLnB1cmdlYWJsZSk7 CiAJSU5JVF9MSVNUX0hFQUQoJm1lbS0+cmVzZXJ2ZWQpOwogCiAJbXV0ZXhfaW5pdCgmbWVtLT5t bV9sb2NrKTsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2ludGVsX21lbW9yeV9y ZWdpb24uaCBiL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2ludGVsX21lbW9yeV9yZWdpb24uaAppbmRl eCBlNjljZGUxM2RhZjIuLjdiNWZhOTdjMGI1OSAxMDA2NDQKLS0tIGEvZHJpdmVycy9ncHUvZHJt L2k5MTUvaW50ZWxfbWVtb3J5X3JlZ2lvbi5oCisrKyBiL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2lu dGVsX21lbW9yeV9yZWdpb24uaApAQCAtMTAwLDcgKzEwMCw2IEBAIHN0cnVjdCBpbnRlbF9tZW1v cnlfcmVnaW9uIHsKIAlzdHJ1Y3QgewogCQlzdHJ1Y3QgbXV0ZXggbG9jazsgLyogUHJvdGVjdHMg YWNjZXNzIHRvIG9iamVjdHMgKi8KIAkJc3RydWN0IGxpc3RfaGVhZCBsaXN0OwotCQlzdHJ1Y3Qg bGlzdF9oZWFkIHB1cmdlYWJsZTsKIAl9IG9iamVjdHM7CiAKIAlzaXplX3QgY2h1bmtfc2l6ZTsK ZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2ludGVsX3JlZ2lvbl90dG0uYyBiL2Ry aXZlcnMvZ3B1L2RybS9pOTE1L2ludGVsX3JlZ2lvbl90dG0uYwppbmRleCBjOGFjMTE4YzIxZjYu LjBiNDFhMTU0NTU3MCAxMDA2NDQKLS0tIGEvZHJpdmVycy9ncHUvZHJtL2k5MTUvaW50ZWxfcmVn aW9uX3R0bS5jCisrKyBiL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2ludGVsX3JlZ2lvbl90dG0uYwpA QCAtMTAsNiArMTAsNyBAQAogCiAjaW5jbHVkZSAiaW50ZWxfcmVnaW9uX3R0bS5oIgogCisjaW5j bHVkZSAiZ2VtL2k5MTVfZ2VtX3R0bS5oIiAvKiBGb3IgdGhlIGZ1bmNzL29wcyBleHBvcnQgb25s eSAqLwogLyoqCiAgKiBET0M6IFRUTSBzdXBwb3J0IHN0cnVjdHVyZQogICoKQEAgLTE5LDkgKzIw LDYgQEAKICAqIGk5MTUgR0VNIHJlZ2lvbnMgdG8gVFRNIG1lbW9yeSB0eXBlcyBhbmQgcmVzb3Vy Y2UgbWFuYWdlcnMuCiAgKi8KIAotLyogQSBaZXJvLWluaXRpYWxpemVkIGRyaXZlciBmb3Igbm93 LiBXZSBkb24ndCBoYXZlIGEgVFRNIGJhY2tlbmQgeWV0LiAqLwotc3RhdGljIHN0cnVjdCB0dG1f ZGV2aWNlX2Z1bmNzIGk5MTVfdHRtX2JvX2RyaXZlcjsKLQogLyoqCiAgKiBpbnRlbF9yZWdpb25f dHRtX2RldmljZV9pbml0IC0gSW5pdGlhbGl6ZSBhIFRUTSBkZXZpY2UKICAqIEBkZXZfcHJpdjog UG9pbnRlciB0byBhbiBpOTE1IGRldmljZSBwcml2YXRlIHN0cnVjdHVyZS4KQEAgLTMyLDcgKzMw LDcgQEAgaW50IGludGVsX3JlZ2lvbl90dG1fZGV2aWNlX2luaXQoc3RydWN0IGRybV9pOTE1X3By aXZhdGUgKmRldl9wcml2KQogewogCXN0cnVjdCBkcm1fZGV2aWNlICpkcm0gPSAmZGV2X3ByaXYt PmRybTsKIAotCXJldHVybiB0dG1fZGV2aWNlX2luaXQoJmRldl9wcml2LT5iZGV2LCAmaTkxNV90 dG1fYm9fZHJpdmVyLAorCXJldHVybiB0dG1fZGV2aWNlX2luaXQoJmRldl9wcml2LT5iZGV2LCBp OTE1X3R0bV9kcml2ZXIoKSwKIAkJCSAgICAgICBkcm0tPmRldiwgZHJtLT5hbm9uX2lub2RlLT5p X21hcHBpbmcsCiAJCQkgICAgICAgZHJtLT52bWFfb2Zmc2V0X21hbmFnZXIsIGZhbHNlLCBmYWxz ZSk7CiB9CkBAIC0xNzIsNiArMTcwLDcgQEAgc3RydWN0IHNnX3RhYmxlICppbnRlbF9yZWdpb25f dHRtX25vZGVfdG9fc3Qoc3RydWN0IGludGVsX21lbW9yeV9yZWdpb24gKm1lbSwKIAlyZXR1cm4g aTkxNV9zZ19mcm9tX21tX25vZGUobm9kZSwgbWVtLT5yZWdpb24uc3RhcnQpOwogfQogCisjaWZk ZWYgQ09ORklHX0RSTV9JOTE1X1NFTEZURVNUCiAvKioKICAqIGludGVsX3JlZ2lvbl90dG1fbm9k ZV9hbGxvYyAtIEFsbG9jYXRlIG1lbW9yeSByZXNvdXJjZXMgZnJvbSBhIHJlZ2lvbgogICogQG1l bTogVGhlIG1lbW9yeSByZWdpb24sCkBAIC0yMTgsMyArMjE3LDQgQEAgdm9pZCAqaW50ZWxfcmVn aW9uX3R0bV9ub2RlX2FsbG9jKHN0cnVjdCBpbnRlbF9tZW1vcnlfcmVnaW9uICptZW0sCiAJCXJl dCA9IC1FTlhJTzsKIAlyZXR1cm4gcmV0ID8gRVJSX1BUUihyZXQpIDogcmVzLm1tX25vZGU7CiB9 CisjZW5kaWYKZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2ludGVsX3JlZ2lvbl90 dG0uaCBiL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2ludGVsX3JlZ2lvbl90dG0uaAppbmRleCAxYzgy YzZjMzQyOWQuLmVhYTNlY2NmYTI1MiAxMDA2NDQKLS0tIGEvZHJpdmVycy9ncHUvZHJtL2k5MTUv aW50ZWxfcmVnaW9uX3R0bS5oCisrKyBiL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2ludGVsX3JlZ2lv bl90dG0uaApAQCAtMTEsNiArMTEsNyBAQAogCiBzdHJ1Y3QgZHJtX2k5MTVfcHJpdmF0ZTsKIHN0 cnVjdCBpbnRlbF9tZW1vcnlfcmVnaW9uOworc3RydWN0IHR0bV9kZXZpY2VfZnVuY3M7CiAKIGlu dCBpbnRlbF9yZWdpb25fdHRtX2RldmljZV9pbml0KHN0cnVjdCBkcm1faTkxNV9wcml2YXRlICpk ZXZfcHJpdik7CiAKQEAgLTIzLDEwICsyNCwxNCBAQCB2b2lkIGludGVsX3JlZ2lvbl90dG1fZmlu aShzdHJ1Y3QgaW50ZWxfbWVtb3J5X3JlZ2lvbiAqbWVtKTsKIHN0cnVjdCBzZ190YWJsZSAqaW50 ZWxfcmVnaW9uX3R0bV9ub2RlX3RvX3N0KHN0cnVjdCBpbnRlbF9tZW1vcnlfcmVnaW9uICptZW0s CiAJCQkJCSAgICAgdm9pZCAqbm9kZSk7CiAKK3ZvaWQgaW50ZWxfcmVnaW9uX3R0bV9ub2RlX2Zy ZWUoc3RydWN0IGludGVsX21lbW9yeV9yZWdpb24gKm1lbSwKKwkJCQl2b2lkICpub2RlKTsKKwor c3RydWN0IHR0bV9kZXZpY2VfZnVuY3MgKmk5MTVfdHRtX2RyaXZlcih2b2lkKTsKKworI2lmZGVm IENPTkZJR19EUk1fSTkxNV9TRUxGVEVTVAogdm9pZCAqaW50ZWxfcmVnaW9uX3R0bV9ub2RlX2Fs bG9jKHN0cnVjdCBpbnRlbF9tZW1vcnlfcmVnaW9uICptZW0sCiAJCQkJICByZXNvdXJjZV9zaXpl X3Qgc2l6ZSwKIAkJCQkgIHVuc2lnbmVkIGludCBmbGFncyk7Ci0KLXZvaWQgaW50ZWxfcmVnaW9u X3R0bV9ub2RlX2ZyZWUoc3RydWN0IGludGVsX21lbW9yeV9yZWdpb24gKm1lbSwKLQkJCQl2b2lk ICpub2RlKTsKKyNlbmRpZgogI2VuZGlmIC8qIF9JTlRFTF9SRUdJT05fVFRNX0hfICovCi0tIAoy LjMxLjEKCl9fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fCklu dGVsLWdmeCBtYWlsaW5nIGxpc3QKSW50ZWwtZ2Z4QGxpc3RzLmZyZWVkZXNrdG9wLm9yZwpodHRw czovL2xpc3RzLmZyZWVkZXNrdG9wLm9yZy9tYWlsbWFuL2xpc3RpbmZvL2ludGVsLWdmeAo= 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 2F96AC47082 for ; Wed, 26 May 2021 11:33:54 +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 E003A6142D for ; Wed, 26 May 2021 11:33:53 +0000 (UTC) DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org E003A6142D 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 C68526ECB3; Wed, 26 May 2021 11:33:44 +0000 (UTC) Received: from mga01.intel.com (mga01.intel.com [192.55.52.88]) by gabe.freedesktop.org (Postfix) with ESMTPS id 641996ECA3; Wed, 26 May 2021 11:33:36 +0000 (UTC) IronPort-SDR: t9TpRePFafBAu8/K7odSxvm7+rBls/WvrhOMD5SyLBD7fTo2/bpOg8P/3mRoALvksRjGL/P+dR Pg8e2ZJJ4NMg== X-IronPort-AV: E=McAfee;i="6200,9189,9995"; a="223627313" X-IronPort-AV: E=Sophos;i="5.82,331,1613462400"; d="scan'208";a="223627313" Received: from fmsmga005.fm.intel.com ([10.253.24.32]) by fmsmga101.fm.intel.com with ESMTP/TLS/ECDHE-RSA-AES256-GCM-SHA384; 26 May 2021 04:33:36 -0700 IronPort-SDR: 9qn2zF99Bzjm00SUQ/Q+udev0aM2gF/VWXz7ARVFwFXrwYlLJv7DqavTJHmxSeM9GgdyRIehQy CZ1hx/w6VPOg== X-IronPort-AV: E=Sophos;i="5.82,331,1613462400"; d="scan'208";a="633457959" Received: from pegilssx-mobl.ger.corp.intel.com (HELO thellst-mobl1.intel.com) ([10.249.254.205]) by fmsmga005-auth.fm.intel.com with ESMTP/TLS/ECDHE-RSA-AES256-GCM-SHA384; 26 May 2021 04:33:34 -0700 From: =?UTF-8?q?Thomas=20Hellstr=C3=B6m?= To: intel-gfx@lists.freedesktop.org, dri-devel@lists.freedesktop.org Subject: [PATCH v4 11/15] drm/i915/ttm: Introduce a TTM i915 gem object backend Date: Wed, 26 May 2021 13:32:55 +0200 Message-Id: <20210526113259.1661914-12-thomas.hellstrom@linux.intel.com> X-Mailer: git-send-email 2.31.1 In-Reply-To: <20210526113259.1661914-1-thomas.hellstrom@linux.intel.com> References: <20210526113259.1661914-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 Errors-To: dri-devel-bounces@lists.freedesktop.org Sender: "dri-devel" Most logical place to introduce TTM buffer objects is as an i915 gem object backend. We need to add some ops to account for added functionality like delayed delete and LRU list manipulation. Initially we support only LMEM and SYSTEM memory, but SYSTEM (which in this case means evicted LMEM objects) is not visible to i915 GEM yet. The plan is to move the i915 gem system region over to the TTM system memory type in upcoming patches. We set up GPU bindings directly both from LMEM and from the system region, as there is no need to use the legacy TTM_TT memory type. We reserve that for future porting of GGTT bindings to TTM. Remove the old lmem backend. Signed-off-by: Thomas Hellström Reviewed-by: Matthew Auld --- v2: - Break out needed TTM functionality to a separate patch (Reported by Christian König). - Fix an unhandled error (Reported by Matthew Auld and Maarten Lankhorst) - Remove a stray leftover sg_table allocation (Reported by Matthew Auld) - Use ttm_tt_unpopulate() rather than ttm_tt_destroy() in the purge path as some TTM functionality relies on having a ttm_tt present for !is_iomem. v3: - Use ttm_bo_type_device for userspace visible objects so that TTM can allocate an address space offset for mmap'ing. - Fix up the destruction path (Reported by Matthew Auld) - Use ttm_bo_validate() for purging (Reported by Christian König) - Create ttm_tts write-combined as they are currently for eviction only and we want to maintain consistent write-combined caching for bos that are not in system only. (Suggested by Daniel Vetter) - Make struct ttm_placements static. - Add the ttm device funcs/ops to i915_gem_ttm.h for the region code. - Rename new->dst and old->src. Check for swapin in the move callback. v4: - Adapt to small interface change in ttm_move_memcpy. - Use a function to pull out the ttm driver from the backend. --- drivers/gpu/drm/i915/Makefile | 1 + drivers/gpu/drm/i915/gem/i915_gem_create.c | 9 +- drivers/gpu/drm/i915/gem/i915_gem_lmem.c | 84 --- drivers/gpu/drm/i915/gem/i915_gem_lmem.h | 5 - drivers/gpu/drm/i915/gem/i915_gem_object.c | 125 ++-- drivers/gpu/drm/i915/gem/i915_gem_object.h | 9 + .../gpu/drm/i915/gem/i915_gem_object_types.h | 27 +- drivers/gpu/drm/i915/gem/i915_gem_region.c | 6 +- drivers/gpu/drm/i915/gem/i915_gem_ttm.c | 541 ++++++++++++++++++ drivers/gpu/drm/i915/gem/i915_gem_ttm.h | 48 ++ drivers/gpu/drm/i915/gt/intel_region_lmem.c | 3 +- drivers/gpu/drm/i915/i915_gem.c | 5 +- drivers/gpu/drm/i915/intel_memory_region.c | 1 - drivers/gpu/drm/i915/intel_memory_region.h | 1 - drivers/gpu/drm/i915/intel_region_ttm.c | 8 +- drivers/gpu/drm/i915/intel_region_ttm.h | 11 +- 16 files changed, 731 insertions(+), 153 deletions(-) create mode 100644 drivers/gpu/drm/i915/gem/i915_gem_ttm.c create mode 100644 drivers/gpu/drm/i915/gem/i915_gem_ttm.h diff --git a/drivers/gpu/drm/i915/Makefile b/drivers/gpu/drm/i915/Makefile index ebc19bd5fff4..9f9cd5c085c3 100644 --- a/drivers/gpu/drm/i915/Makefile +++ b/drivers/gpu/drm/i915/Makefile @@ -154,6 +154,7 @@ gem-y += \ gem/i915_gem_stolen.o \ gem/i915_gem_throttle.o \ gem/i915_gem_tiling.o \ + gem/i915_gem_ttm.o \ gem/i915_gem_userptr.o \ gem/i915_gem_wait.o \ gem/i915_gemfs.o diff --git a/drivers/gpu/drm/i915/gem/i915_gem_create.c b/drivers/gpu/drm/i915/gem/i915_gem_create.c index 548ddf39d853..93bf63bbaff1 100644 --- a/drivers/gpu/drm/i915/gem/i915_gem_create.c +++ b/drivers/gpu/drm/i915/gem/i915_gem_create.c @@ -85,13 +85,10 @@ i915_gem_setup(struct drm_i915_gem_object *obj, u64 size) return -E2BIG; /* - * For now resort to CPU based clearing for device local-memory, in the - * near future this will use the blitter engine for accelerated, GPU - * based clearing. + * I915_BO_ALLOC_USER will make sure the object is cleared before + * any user access. */ - flags = 0; - if (mr->type == INTEL_MEMORY_LOCAL) - flags = I915_BO_ALLOC_CPU_CLEAR; + flags = I915_BO_ALLOC_USER; ret = mr->ops->init_object(mr, obj, size, flags); if (ret) diff --git a/drivers/gpu/drm/i915/gem/i915_gem_lmem.c b/drivers/gpu/drm/i915/gem/i915_gem_lmem.c index 3b4aa28a076d..2b8cd15de1d9 100644 --- a/drivers/gpu/drm/i915/gem/i915_gem_lmem.c +++ b/drivers/gpu/drm/i915/gem/i915_gem_lmem.c @@ -4,74 +4,10 @@ */ #include "intel_memory_region.h" -#include "intel_region_ttm.h" #include "gem/i915_gem_region.h" #include "gem/i915_gem_lmem.h" #include "i915_drv.h" -static void lmem_put_pages(struct drm_i915_gem_object *obj, - struct sg_table *pages) -{ - intel_region_ttm_node_free(obj->mm.region, obj->mm.st_mm_node); - obj->mm.dirty = false; - sg_free_table(pages); - kfree(pages); -} - -static int lmem_get_pages(struct drm_i915_gem_object *obj) -{ - unsigned int flags; - struct sg_table *pages; - - flags = I915_ALLOC_MIN_PAGE_SIZE; - if (obj->flags & I915_BO_ALLOC_CONTIGUOUS) - flags |= I915_ALLOC_CONTIGUOUS; - - obj->mm.st_mm_node = intel_region_ttm_node_alloc(obj->mm.region, - obj->base.size, - flags); - if (IS_ERR(obj->mm.st_mm_node)) - return PTR_ERR(obj->mm.st_mm_node); - - /* Range manager is always contigous */ - if (obj->mm.region->is_range_manager) - obj->flags |= I915_BO_ALLOC_CONTIGUOUS; - pages = intel_region_ttm_node_to_st(obj->mm.region, obj->mm.st_mm_node); - if (IS_ERR(pages)) { - intel_region_ttm_node_free(obj->mm.region, obj->mm.st_mm_node); - return PTR_ERR(pages); - } - - __i915_gem_object_set_pages(obj, pages, i915_sg_dma_sizes(pages->sgl)); - - if (obj->flags & I915_BO_ALLOC_CPU_CLEAR) { - void __iomem *vaddr = - i915_gem_object_lmem_io_map(obj, 0, obj->base.size); - - if (!vaddr) { - struct sg_table *pages = - __i915_gem_object_unset_pages(obj); - - if (!IS_ERR_OR_NULL(pages)) - lmem_put_pages(obj, pages); - } - - memset_io(vaddr, 0, obj->base.size); - io_mapping_unmap(vaddr); - } - - return 0; -} - -const struct drm_i915_gem_object_ops i915_gem_lmem_obj_ops = { - .name = "i915_gem_object_lmem", - .flags = I915_GEM_OBJECT_HAS_IOMEM, - - .get_pages = lmem_get_pages, - .put_pages = lmem_put_pages, - .release = i915_gem_object_release_memory_region, -}; - void __iomem * i915_gem_object_lmem_io_map(struct drm_i915_gem_object *obj, unsigned long n, @@ -103,23 +39,3 @@ i915_gem_object_create_lmem(struct drm_i915_private *i915, return i915_gem_object_create_region(i915->mm.regions[INTEL_REGION_LMEM], size, flags); } - -int __i915_gem_lmem_object_init(struct intel_memory_region *mem, - struct drm_i915_gem_object *obj, - resource_size_t size, - unsigned int flags) -{ - static struct lock_class_key lock_class; - struct drm_i915_private *i915 = mem->i915; - - drm_gem_private_object_init(&i915->drm, &obj->base, size); - i915_gem_object_init(obj, &i915_gem_lmem_obj_ops, &lock_class, flags); - - obj->read_domains = I915_GEM_DOMAIN_WC | I915_GEM_DOMAIN_GTT; - - i915_gem_object_set_cache_coherency(obj, I915_CACHE_NONE); - - i915_gem_object_init_memory_region(obj, mem); - - return 0; -} diff --git a/drivers/gpu/drm/i915/gem/i915_gem_lmem.h b/drivers/gpu/drm/i915/gem/i915_gem_lmem.h index fac6bc5a5ebb..ea76fd11ccb0 100644 --- a/drivers/gpu/drm/i915/gem/i915_gem_lmem.h +++ b/drivers/gpu/drm/i915/gem/i915_gem_lmem.h @@ -26,9 +26,4 @@ i915_gem_object_create_lmem(struct drm_i915_private *i915, resource_size_t size, unsigned int flags); -int __i915_gem_lmem_object_init(struct intel_memory_region *mem, - struct drm_i915_gem_object *obj, - resource_size_t size, - unsigned int flags); - #endif /* !__I915_GEM_LMEM_H */ diff --git a/drivers/gpu/drm/i915/gem/i915_gem_object.c b/drivers/gpu/drm/i915/gem/i915_gem_object.c index e9247afb0320..df2b4e6b9bcc 100644 --- a/drivers/gpu/drm/i915/gem/i915_gem_object.c +++ b/drivers/gpu/drm/i915/gem/i915_gem_object.c @@ -173,7 +173,7 @@ static void i915_gem_close_object(struct drm_gem_object *gem, struct drm_file *f } } -static void __i915_gem_free_object_rcu(struct rcu_head *head) +void __i915_gem_free_object_rcu(struct rcu_head *head) { struct drm_i915_gem_object *obj = container_of(head, typeof(*obj), rcu); @@ -209,59 +209,69 @@ static void __i915_gem_object_free_mmaps(struct drm_i915_gem_object *obj) } } -static void __i915_gem_free_objects(struct drm_i915_private *i915, - struct llist_node *freed) +void __i915_gem_free_object(struct drm_i915_gem_object *obj) { - struct drm_i915_gem_object *obj, *on; + trace_i915_gem_object_destroy(obj); - llist_for_each_entry_safe(obj, on, freed, freed) { - trace_i915_gem_object_destroy(obj); + if (!list_empty(&obj->vma.list)) { + struct i915_vma *vma; + + /* + * Note that the vma keeps an object reference while + * it is active, so it *should* not sleep while we + * destroy it. Our debug code errs insits it *might*. + * For the moment, play along. + */ + spin_lock(&obj->vma.lock); + while ((vma = list_first_entry_or_null(&obj->vma.list, + struct i915_vma, + obj_link))) { + GEM_BUG_ON(vma->obj != obj); + spin_unlock(&obj->vma.lock); - if (!list_empty(&obj->vma.list)) { - struct i915_vma *vma; + __i915_vma_put(vma); - /* - * Note that the vma keeps an object reference while - * it is active, so it *should* not sleep while we - * destroy it. Our debug code errs insits it *might*. - * For the moment, play along. - */ spin_lock(&obj->vma.lock); - while ((vma = list_first_entry_or_null(&obj->vma.list, - struct i915_vma, - obj_link))) { - GEM_BUG_ON(vma->obj != obj); - spin_unlock(&obj->vma.lock); + } + spin_unlock(&obj->vma.lock); + } - __i915_vma_put(vma); + __i915_gem_object_free_mmaps(obj); - spin_lock(&obj->vma.lock); - } - spin_unlock(&obj->vma.lock); - } + GEM_BUG_ON(!list_empty(&obj->lut_list)); - __i915_gem_object_free_mmaps(obj); + atomic_set(&obj->mm.pages_pin_count, 0); + __i915_gem_object_put_pages(obj); + GEM_BUG_ON(i915_gem_object_has_pages(obj)); + bitmap_free(obj->bit_17); - GEM_BUG_ON(!list_empty(&obj->lut_list)); + if (obj->base.import_attach) + drm_prime_gem_destroy(&obj->base, NULL); - atomic_set(&obj->mm.pages_pin_count, 0); - __i915_gem_object_put_pages(obj); - GEM_BUG_ON(i915_gem_object_has_pages(obj)); - bitmap_free(obj->bit_17); + drm_gem_free_mmap_offset(&obj->base); - if (obj->base.import_attach) - drm_prime_gem_destroy(&obj->base, NULL); + if (obj->ops->release) + obj->ops->release(obj); - drm_gem_free_mmap_offset(&obj->base); + if (obj->mm.n_placements > 1) + kfree(obj->mm.placements); - if (obj->ops->release) - obj->ops->release(obj); + if (obj->shares_resv_from) + i915_vm_resv_put(obj->shares_resv_from); +} - if (obj->mm.n_placements > 1) - kfree(obj->mm.placements); +static void __i915_gem_free_objects(struct drm_i915_private *i915, + struct llist_node *freed) +{ + struct drm_i915_gem_object *obj, *on; - if (obj->shares_resv_from) - i915_vm_resv_put(obj->shares_resv_from); + llist_for_each_entry_safe(obj, on, freed, freed) { + might_sleep(); + if (obj->ops->delayed_free) { + obj->ops->delayed_free(obj); + continue; + } + __i915_gem_free_object(obj); /* But keep the pointer alive for RCU-protected lookups */ call_rcu(&obj->rcu, __i915_gem_free_object_rcu); @@ -319,6 +329,7 @@ static void i915_gem_free_object(struct drm_gem_object *gem_obj) * worker and performing frees directly from subsequent allocations for * crude but effective memory throttling. */ + if (llist_add(&obj->freed, &i915->mm.free_list)) queue_work(i915->wq, &i915->mm.free_work); } @@ -411,6 +422,42 @@ int i915_gem_object_read_from_page(struct drm_i915_gem_object *obj, u64 offset, return 0; } +/** + * i915_gem_object_evictable - Whether object is likely evictable after unbind. + * @obj: The object to check + * + * This function checks whether the object is likely unvictable after unbind. + * If the object is not locked when checking, the result is only advisory. + * If the object is locked when checking, and the function returns true, + * then an eviction should indeed be possible. But since unlocked vma + * unpinning and unbinding is currently possible, the object can actually + * become evictable even if this function returns false. + * + * Return: true if the object may be evictable. False otherwise. + */ +bool i915_gem_object_evictable(struct drm_i915_gem_object *obj) +{ + struct i915_vma *vma; + int pin_count = atomic_read(&obj->mm.pages_pin_count); + + if (!pin_count) + return true; + + spin_lock(&obj->vma.lock); + list_for_each_entry(vma, &obj->vma.list, obj_link) { + if (i915_vma_is_pinned(vma)) { + spin_unlock(&obj->vma.lock); + return false; + } + if (atomic_read(&vma->pages_count)) + pin_count--; + } + spin_unlock(&obj->vma.lock); + GEM_WARN_ON(pin_count < 0); + + return pin_count == 0; +} + void i915_gem_init__objects(struct drm_i915_private *i915) { INIT_WORK(&i915->mm.free_work, __i915_gem_free_work); diff --git a/drivers/gpu/drm/i915/gem/i915_gem_object.h b/drivers/gpu/drm/i915/gem/i915_gem_object.h index 2ebd79537aea..ae5930e307d5 100644 --- a/drivers/gpu/drm/i915/gem/i915_gem_object.h +++ b/drivers/gpu/drm/i915/gem/i915_gem_object.h @@ -200,6 +200,9 @@ static inline bool i915_gem_object_trylock(struct drm_i915_gem_object *obj) static inline void i915_gem_object_unlock(struct drm_i915_gem_object *obj) { + if (obj->ops->adjust_lru) + obj->ops->adjust_lru(obj); + dma_resv_unlock(obj->base.resv); } @@ -587,6 +590,12 @@ int i915_gem_object_read_from_page(struct drm_i915_gem_object *obj, u64 offset, bool i915_gem_object_is_shmem(const struct drm_i915_gem_object *obj); +void __i915_gem_free_object_rcu(struct rcu_head *head); + +void __i915_gem_free_object(struct drm_i915_gem_object *obj); + +bool i915_gem_object_evictable(struct drm_i915_gem_object *obj); + #ifdef CONFIG_MMU_NOTIFIER static inline bool i915_gem_object_is_userptr(struct drm_i915_gem_object *obj) diff --git a/drivers/gpu/drm/i915/gem/i915_gem_object_types.h b/drivers/gpu/drm/i915/gem/i915_gem_object_types.h index d047ea126029..68313474e6a6 100644 --- a/drivers/gpu/drm/i915/gem/i915_gem_object_types.h +++ b/drivers/gpu/drm/i915/gem/i915_gem_object_types.h @@ -63,6 +63,20 @@ struct drm_i915_gem_object_ops { const struct drm_i915_gem_pwrite *arg); int (*dmabuf_export)(struct drm_i915_gem_object *obj); + + /** + * adjust_lru - notify that the madvise value was updated + * @obj: The gem object + * + * The madvise value may have been updated, or object was recently + * referenced so act accordingly (Perhaps changing an LRU list etc). + */ + void (*adjust_lru)(struct drm_i915_gem_object *obj); + + /** + * delayed_free - Override the default delayed free implementation + */ + void (*delayed_free)(struct drm_i915_gem_object *obj); void (*release)(struct drm_i915_gem_object *obj); const char *name; /* friendly name for debug, e.g. lockdep classes */ @@ -187,12 +201,14 @@ struct drm_i915_gem_object { #define I915_BO_ALLOC_VOLATILE BIT(1) #define I915_BO_ALLOC_STRUCT_PAGE BIT(2) #define I915_BO_ALLOC_CPU_CLEAR BIT(3) +#define I915_BO_ALLOC_USER BIT(4) #define I915_BO_ALLOC_FLAGS (I915_BO_ALLOC_CONTIGUOUS | \ I915_BO_ALLOC_VOLATILE | \ I915_BO_ALLOC_STRUCT_PAGE | \ - I915_BO_ALLOC_CPU_CLEAR) -#define I915_BO_READONLY BIT(4) -#define I915_TILING_QUIRK_BIT 5 /* unknown swizzling; do not release! */ + I915_BO_ALLOC_CPU_CLEAR | \ + I915_BO_ALLOC_USER) +#define I915_BO_READONLY BIT(5) +#define I915_TILING_QUIRK_BIT 6 /* unknown swizzling; do not release! */ /* * Is the object to be mapped as read-only to the GPU @@ -310,6 +326,11 @@ struct drm_i915_gem_object { bool dirty:1; } mm; + struct { + struct sg_table *cached_io_st; + bool created:1; + } ttm; + /** Record of address bit 17 of each page at last unbind. */ unsigned long *bit_17; diff --git a/drivers/gpu/drm/i915/gem/i915_gem_region.c b/drivers/gpu/drm/i915/gem/i915_gem_region.c index f25e6646c5b7..d1f1840540dd 100644 --- a/drivers/gpu/drm/i915/gem/i915_gem_region.c +++ b/drivers/gpu/drm/i915/gem/i915_gem_region.c @@ -18,11 +18,7 @@ void i915_gem_object_init_memory_region(struct drm_i915_gem_object *obj, mutex_lock(&mem->objects.lock); - if (obj->flags & I915_BO_ALLOC_VOLATILE) - list_add(&obj->mm.region_link, &mem->objects.purgeable); - else - list_add(&obj->mm.region_link, &mem->objects.list); - + list_add(&obj->mm.region_link, &mem->objects.list); mutex_unlock(&mem->objects.lock); } diff --git a/drivers/gpu/drm/i915/gem/i915_gem_ttm.c b/drivers/gpu/drm/i915/gem/i915_gem_ttm.c new file mode 100644 index 000000000000..17598930a99e --- /dev/null +++ b/drivers/gpu/drm/i915/gem/i915_gem_ttm.c @@ -0,0 +1,541 @@ +// SPDX-License-Identifier: MIT +/* + * Copyright © 2021 Intel Corporation + */ + +#include +#include + +#include "i915_drv.h" +#include "intel_memory_region.h" +#include "intel_region_ttm.h" + +#include "gem/i915_gem_object.h" +#include "gem/i915_gem_region.h" +#include "gem/i915_gem_ttm.h" + +#define I915_PL_LMEM0 TTM_PL_PRIV +#define I915_PL_SYSTEM TTM_PL_SYSTEM +#define I915_PL_STOLEN TTM_PL_VRAM +#define I915_PL_GGTT TTM_PL_TT + +#define I915_TTM_PRIO_PURGE 0 +#define I915_TTM_PRIO_NO_PAGES 1 +#define I915_TTM_PRIO_HAS_PAGES 2 + +/** + * struct i915_ttm_tt - TTM page vector with additional private information + * @ttm: The base TTM page vector. + * @dev: The struct device used for dma mapping and unmapping. + * @cached_st: The cached scatter-gather table. + * + * Note that DMA may be going on right up to the point where the page- + * vector is unpopulated in delayed destroy. Hence keep the + * scatter-gather table mapped and cached up to that point. This is + * different from the cached gem object io scatter-gather table which + * doesn't have an associated dma mapping. + */ +struct i915_ttm_tt { + struct ttm_tt ttm; + struct device *dev; + struct sg_table *cached_st; +}; + +static const struct ttm_place lmem0_sys_placement_flags[] = { + { + .fpfn = 0, + .lpfn = 0, + .mem_type = I915_PL_LMEM0, + .flags = 0, + }, { + .fpfn = 0, + .lpfn = 0, + .mem_type = I915_PL_SYSTEM, + .flags = 0, + } +}; + +static struct ttm_placement i915_lmem0_placement = { + .num_placement = 1, + .placement = &lmem0_sys_placement_flags[0], + .num_busy_placement = 1, + .busy_placement = &lmem0_sys_placement_flags[0], +}; + +static struct ttm_placement i915_sys_placement = { + .num_placement = 1, + .placement = &lmem0_sys_placement_flags[1], + .num_busy_placement = 1, + .busy_placement = &lmem0_sys_placement_flags[1], +}; + +static void i915_ttm_adjust_lru(struct drm_i915_gem_object *obj); + +static struct ttm_tt *i915_ttm_tt_create(struct ttm_buffer_object *bo, + uint32_t page_flags) +{ + struct ttm_resource_manager *man = + ttm_manager_type(bo->bdev, bo->mem.mem_type); + struct drm_i915_gem_object *obj = i915_ttm_to_gem(bo); + struct i915_ttm_tt *i915_tt; + int ret; + + i915_tt = kzalloc(sizeof(*i915_tt), GFP_KERNEL); + if (!i915_tt) + return NULL; + + if (obj->flags & I915_BO_ALLOC_CPU_CLEAR && + man->use_tt) + page_flags |= TTM_PAGE_FLAG_ZERO_ALLOC; + + ret = ttm_tt_init(&i915_tt->ttm, bo, page_flags, ttm_write_combined); + if (ret) { + kfree(i915_tt); + return NULL; + } + + i915_tt->dev = obj->base.dev->dev; + + return &i915_tt->ttm; +} + +static void i915_ttm_tt_unpopulate(struct ttm_device *bdev, struct ttm_tt *ttm) +{ + struct i915_ttm_tt *i915_tt = container_of(ttm, typeof(*i915_tt), ttm); + + if (i915_tt->cached_st) { + dma_unmap_sgtable(i915_tt->dev, i915_tt->cached_st, + DMA_BIDIRECTIONAL, 0); + sg_free_table(i915_tt->cached_st); + kfree(i915_tt->cached_st); + i915_tt->cached_st = NULL; + } + ttm_pool_free(&bdev->pool, ttm); +} + +static void i915_ttm_tt_destroy(struct ttm_device *bdev, struct ttm_tt *ttm) +{ + struct i915_ttm_tt *i915_tt = container_of(ttm, typeof(*i915_tt), ttm); + + ttm_tt_destroy_common(bdev, ttm); + kfree(i915_tt); +} + +static bool i915_ttm_eviction_valuable(struct ttm_buffer_object *bo, + const struct ttm_place *place) +{ + struct drm_i915_gem_object *obj = i915_ttm_to_gem(bo); + + /* Will do for now. Our pinned objects are still on TTM's LRU lists */ + if (!i915_gem_object_evictable(obj)) + return false; + + /* This isn't valid with a buddy allocator */ + return ttm_bo_eviction_valuable(bo, place); +} + +static void i915_ttm_evict_flags(struct ttm_buffer_object *bo, + struct ttm_placement *placement) +{ + *placement = i915_sys_placement; +} + +static int i915_ttm_move_notify(struct ttm_buffer_object *bo) +{ + struct drm_i915_gem_object *obj = i915_ttm_to_gem(bo); + int ret; + + ret = i915_gem_object_unbind(obj, I915_GEM_OBJECT_UNBIND_ACTIVE); + if (ret) + return ret; + + ret = __i915_gem_object_put_pages(obj); + if (ret) + return ret; + + return 0; +} + +static void i915_ttm_free_cached_io_st(struct drm_i915_gem_object *obj) +{ + if (obj->ttm.cached_io_st) { + sg_free_table(obj->ttm.cached_io_st); + kfree(obj->ttm.cached_io_st); + obj->ttm.cached_io_st = NULL; + } +} + +static void i915_ttm_purge(struct drm_i915_gem_object *obj) +{ + struct ttm_buffer_object *bo = i915_gem_to_ttm(obj); + struct ttm_operation_ctx ctx = { + .interruptible = true, + .no_wait_gpu = false, + }; + struct ttm_placement place = {}; + int ret; + + if (obj->mm.madv == __I915_MADV_PURGED) + return; + + /* TTM's purge interface. Note that we might be reentering. */ + ret = ttm_bo_validate(bo, &place, &ctx); + + if (!ret) { + i915_ttm_free_cached_io_st(obj); + obj->mm.madv = __I915_MADV_PURGED; + } +} + +static void i915_ttm_swap_notify(struct ttm_buffer_object *bo) +{ + struct drm_i915_gem_object *obj = i915_ttm_to_gem(bo); + int ret = i915_ttm_move_notify(bo); + + GEM_WARN_ON(ret); + GEM_WARN_ON(obj->ttm.cached_io_st); + if (!ret && obj->mm.madv != I915_MADV_WILLNEED) + i915_ttm_purge(obj); +} + +static void i915_ttm_delete_mem_notify(struct ttm_buffer_object *bo) +{ + struct drm_i915_gem_object *obj = i915_ttm_to_gem(bo); + + if (likely(obj)) { + /* This releases all gem object bindings to the backend. */ + __i915_gem_free_object(obj); + } +} + +static struct intel_memory_region * +i915_ttm_region(struct ttm_device *bdev, int ttm_mem_type) +{ + struct drm_i915_private *i915 = container_of(bdev, typeof(*i915), bdev); + + /* There's some room for optimization here... */ + GEM_BUG_ON(ttm_mem_type != I915_PL_SYSTEM && + ttm_mem_type < I915_PL_LMEM0); + if (ttm_mem_type == I915_PL_SYSTEM) + return intel_memory_region_lookup(i915, INTEL_MEMORY_SYSTEM, + 0); + + return intel_memory_region_lookup(i915, INTEL_MEMORY_LOCAL, + ttm_mem_type - I915_PL_LMEM0); +} + +static struct sg_table *i915_ttm_tt_get_st(struct ttm_tt *ttm) +{ + struct i915_ttm_tt *i915_tt = container_of(ttm, typeof(*i915_tt), ttm); + struct scatterlist *sg; + struct sg_table *st; + int ret; + + if (i915_tt->cached_st) + return i915_tt->cached_st; + + st = kzalloc(sizeof(*st), GFP_KERNEL); + if (!st) + return ERR_PTR(-ENOMEM); + + sg = __sg_alloc_table_from_pages + (st, ttm->pages, ttm->num_pages, 0, + (unsigned long)ttm->num_pages << PAGE_SHIFT, + i915_sg_segment_size(), NULL, 0, GFP_KERNEL); + if (IS_ERR(sg)) { + kfree(st); + return ERR_CAST(sg); + } + + ret = dma_map_sgtable(i915_tt->dev, st, DMA_BIDIRECTIONAL, 0); + if (ret) { + sg_free_table(st); + kfree(st); + return ERR_PTR(ret); + } + + i915_tt->cached_st = st; + return st; +} + +static struct sg_table * +i915_ttm_resource_get_st(struct drm_i915_gem_object *obj, + struct ttm_resource *res) +{ + struct ttm_buffer_object *bo = i915_gem_to_ttm(obj); + struct ttm_resource_manager *man = + ttm_manager_type(bo->bdev, res->mem_type); + + if (man->use_tt) + return i915_ttm_tt_get_st(bo->ttm); + + return intel_region_ttm_node_to_st(obj->mm.region, res->mm_node); +} + +static int i915_ttm_move(struct ttm_buffer_object *bo, bool evict, + struct ttm_operation_ctx *ctx, + struct ttm_resource *dst_mem, + struct ttm_place *hop) +{ + struct drm_i915_gem_object *obj = i915_ttm_to_gem(bo); + struct ttm_resource_manager *dst_man = + ttm_manager_type(bo->bdev, dst_mem->mem_type); + struct ttm_resource_manager *src_man = + ttm_manager_type(bo->bdev, bo->mem.mem_type); + struct intel_memory_region *dst_reg, *src_reg; + union { + struct ttm_kmap_iter_tt tt; + struct ttm_kmap_iter_iomap io; + } _dst_iter, _src_iter; + struct ttm_kmap_iter *dst_iter, *src_iter; + struct sg_table *dst_st; + int ret; + + dst_reg = i915_ttm_region(bo->bdev, dst_mem->mem_type); + src_reg = i915_ttm_region(bo->bdev, bo->mem.mem_type); + GEM_BUG_ON(!dst_reg || !src_reg); + + /* Sync for now. We could do the actual copy async. */ + ret = ttm_bo_wait_ctx(bo, ctx); + if (ret) + return ret; + + ret = i915_ttm_move_notify(bo); + if (ret) + return ret; + + if (obj->mm.madv != I915_MADV_WILLNEED) { + i915_ttm_purge(obj); + ttm_resource_free(bo, dst_mem); + return 0; + } + + /* Populate ttm with pages if needed. Typically system memory. */ + if (bo->ttm && (dst_man->use_tt || + (bo->ttm->page_flags & TTM_PAGE_FLAG_SWAPPED))) { + ret = ttm_tt_populate(bo->bdev, bo->ttm, ctx); + if (ret) + return ret; + } + + dst_st = i915_ttm_resource_get_st(obj, dst_mem); + if (IS_ERR(dst_st)) + return PTR_ERR(dst_st); + + /* If we start mapping GGTT, we can no longer use man::use_tt here. */ + dst_iter = dst_man->use_tt ? + ttm_kmap_iter_tt_init(&_dst_iter.tt, bo->ttm) : + ttm_kmap_iter_iomap_init(&_dst_iter.io, &dst_reg->iomap, + dst_st, dst_reg->region.start); + + src_iter = src_man->use_tt ? + ttm_kmap_iter_tt_init(&_src_iter.tt, bo->ttm) : + ttm_kmap_iter_iomap_init(&_src_iter.io, &src_reg->iomap, + obj->ttm.cached_io_st, + src_reg->region.start); + + ttm_move_memcpy(bo, dst_mem->num_pages, dst_iter, src_iter); + ttm_bo_move_sync_cleanup(bo, dst_mem); + i915_ttm_free_cached_io_st(obj); + + if (!dst_man->use_tt) + obj->ttm.cached_io_st = dst_st; + + return 0; +} + +static struct ttm_device_funcs i915_ttm_bo_driver = { + .ttm_tt_create = i915_ttm_tt_create, + .ttm_tt_unpopulate = i915_ttm_tt_unpopulate, + .ttm_tt_destroy = i915_ttm_tt_destroy, + .eviction_valuable = i915_ttm_eviction_valuable, + .evict_flags = i915_ttm_evict_flags, + .move = i915_ttm_move, + .verify_access = NULL, + .swap_notify = i915_ttm_swap_notify, + .delete_mem_notify = i915_ttm_delete_mem_notify, +}; + +/** + * i915_ttm_driver - Return a pointer to the TTM device funcs + * + * Return: Pointer to statically allocated TTM device funcs. + */ +struct ttm_device_funcs *i915_ttm_driver(void) +{ + return &i915_ttm_bo_driver; +} + +static int i915_ttm_get_pages(struct drm_i915_gem_object *obj) +{ + struct ttm_buffer_object *bo = i915_gem_to_ttm(obj); + struct ttm_operation_ctx ctx = { + .interruptible = true, + .no_wait_gpu = false, + }; + struct sg_table *st; + int ret; + + /* Move to the requested placement. */ + ret = ttm_bo_validate(bo, &i915_lmem0_placement, &ctx); + if (ret) + return ret == -ENOSPC ? -ENXIO : ret; + + /* Object either has a page vector or is an iomem object */ + st = bo->ttm ? i915_ttm_tt_get_st(bo->ttm) : obj->ttm.cached_io_st; + if (IS_ERR(st)) + return PTR_ERR(st); + + __i915_gem_object_set_pages(obj, st, i915_sg_dma_sizes(st->sgl)); + + i915_ttm_adjust_lru(obj); + + return ret; +} + +static void i915_ttm_put_pages(struct drm_i915_gem_object *obj, + struct sg_table *st) +{ + /* + * We're currently not called from a shrinker, so put_pages() + * typically means the object is about to destroyed, or called + * from move_notify(). So just avoid doing much for now. + * If the object is not destroyed next, The TTM eviction logic + * and shrinkers will move it out if needed. + */ + + i915_ttm_adjust_lru(obj); +} + +static void i915_ttm_adjust_lru(struct drm_i915_gem_object *obj) +{ + struct ttm_buffer_object *bo = i915_gem_to_ttm(obj); + + /* + * Don't manipulate the TTM LRUs while in TTM bo destruction. + * We're called through i915_ttm_delete_mem_notify(). + */ + if (!kref_read(&bo->kref)) + return; + + /* + * Put on the correct LRU list depending on the MADV status + */ + spin_lock(&bo->bdev->lru_lock); + if (obj->mm.madv != I915_MADV_WILLNEED) { + bo->priority = I915_TTM_PRIO_PURGE; + } else if (!i915_gem_object_has_pages(obj)) { + if (bo->priority < I915_TTM_PRIO_HAS_PAGES) + bo->priority = I915_TTM_PRIO_HAS_PAGES; + } else { + if (bo->priority > I915_TTM_PRIO_NO_PAGES) + bo->priority = I915_TTM_PRIO_NO_PAGES; + } + + ttm_bo_move_to_lru_tail(bo, &bo->mem, NULL); + spin_unlock(&bo->bdev->lru_lock); +} + +/* + * TTM-backed gem object destruction requires some clarification. + * Basically we have two possibilities here. We can either rely on the + * i915 delayed destruction and put the TTM object when the object + * is idle. This would be detected by TTM which would bypass the + * TTM delayed destroy handling. The other approach is to put the TTM + * object early and rely on the TTM destroyed handling, and then free + * the leftover parts of the GEM object once TTM's destroyed list handling is + * complete. For now, we rely on the latter for two reasons: + * a) TTM can evict an object even when it's on the delayed destroy list, + * which in theory allows for complete eviction. + * b) There is work going on in TTM to allow freeing an object even when + * it's not idle, and using the TTM destroyed list handling could help us + * benefit from that. + */ +static void i915_ttm_delayed_free(struct drm_i915_gem_object *obj) +{ + if (obj->ttm.created) { + ttm_bo_put(i915_gem_to_ttm(obj)); + } else { + __i915_gem_free_object(obj); + call_rcu(&obj->rcu, __i915_gem_free_object_rcu); + } +} + +static const struct drm_i915_gem_object_ops i915_gem_ttm_obj_ops = { + .name = "i915_gem_object_ttm", + .flags = I915_GEM_OBJECT_HAS_IOMEM, + + .get_pages = i915_ttm_get_pages, + .put_pages = i915_ttm_put_pages, + .truncate = i915_ttm_purge, + .adjust_lru = i915_ttm_adjust_lru, + .delayed_free = i915_ttm_delayed_free, +}; + +void i915_ttm_bo_destroy(struct ttm_buffer_object *bo) +{ + struct drm_i915_gem_object *obj = i915_ttm_to_gem(bo); + + i915_gem_object_release_memory_region(obj); + if (obj->ttm.created) + call_rcu(&obj->rcu, __i915_gem_free_object_rcu); +} + +/** + * __i915_gem_ttm_object_init - Initialize a ttm-backed i915 gem object + * @mem: The initial memory region for the object. + * @obj: The gem object. + * @size: Object size in bytes. + * @flags: gem object flags. + * + * Return: 0 on success, negative error code on failure. + */ +int __i915_gem_ttm_object_init(struct intel_memory_region *mem, + struct drm_i915_gem_object *obj, + resource_size_t size, + unsigned int flags) +{ + static struct lock_class_key lock_class; + struct drm_i915_private *i915 = mem->i915; + enum ttm_bo_type bo_type; + size_t alignment = 0; + int ret; + + /* Adjust alignment to GPU- and CPU huge page sizes. */ + + if (mem->is_range_manager) { + if (size >= SZ_1G) + alignment = SZ_1G >> PAGE_SHIFT; + else if (size >= SZ_2M) + alignment = SZ_2M >> PAGE_SHIFT; + else if (size >= SZ_64K) + alignment = SZ_64K >> PAGE_SHIFT; + } + + drm_gem_private_object_init(&i915->drm, &obj->base, size); + i915_gem_object_init(obj, &i915_gem_ttm_obj_ops, &lock_class, flags); + i915_gem_object_init_memory_region(obj, mem); + i915_gem_object_make_unshrinkable(obj); + obj->read_domains = I915_GEM_DOMAIN_WC | I915_GEM_DOMAIN_GTT; + i915_gem_object_set_cache_coherency(obj, I915_CACHE_NONE); + + bo_type = (obj->flags & I915_BO_ALLOC_USER) ? ttm_bo_type_device : + ttm_bo_type_kernel; + + /* + * If this function fails, it will call the destructor, but + * our caller still owns the object. So no freeing in the + * destructor until obj->ttm.created is true. + * Similarly, in delayed_destroy, we can't call ttm_bo_put() + * until successful initialization. + */ + ret = ttm_bo_init(&i915->bdev, i915_gem_to_ttm(obj), size, + bo_type, &i915_sys_placement, alignment, + true, NULL, NULL, i915_ttm_bo_destroy); + + if (!ret) + obj->ttm.created = true; + + /* i915 wants -ENXIO when out of memory region space. */ + return (ret == -ENOSPC) ? -ENXIO : ret; +} diff --git a/drivers/gpu/drm/i915/gem/i915_gem_ttm.h b/drivers/gpu/drm/i915/gem/i915_gem_ttm.h new file mode 100644 index 000000000000..b8d3dcbb50df --- /dev/null +++ b/drivers/gpu/drm/i915/gem/i915_gem_ttm.h @@ -0,0 +1,48 @@ +/* SPDX-License-Identifier: MIT */ +/* + * Copyright © 2021 Intel Corporation + */ +#ifndef _I915_GEM_TTM_H_ +#define _I915_GEM_TTM_H_ + +#include "gem/i915_gem_object_types.h" + +/** + * i915_gem_to_ttm - Convert a struct drm_i915_gem_object to a + * struct ttm_buffer_object. + * @obj: Pointer to the gem object. + * + * Return: Pointer to the embedded struct ttm_buffer_object. + */ +static inline struct ttm_buffer_object * +i915_gem_to_ttm(struct drm_i915_gem_object *obj) +{ + return &obj->__do_not_access; +} + +/* + * i915 ttm gem object destructor. Internal use only. + */ +void i915_ttm_bo_destroy(struct ttm_buffer_object *bo); + +/** + * i915_ttm_to_gem - Convert a struct ttm_buffer_object to an embedding + * struct drm_i915_gem_object. + * + * Return: Pointer to the embedding struct ttm_buffer_object, or NULL + * if the object was not an i915 ttm object. + */ +static inline struct drm_i915_gem_object * +i915_ttm_to_gem(struct ttm_buffer_object *bo) +{ + if (GEM_WARN_ON(bo->destroy != i915_ttm_bo_destroy)) + return NULL; + + return container_of(bo, struct drm_i915_gem_object, __do_not_access); +} + +int __i915_gem_ttm_object_init(struct intel_memory_region *mem, + struct drm_i915_gem_object *obj, + resource_size_t size, + unsigned int flags); +#endif diff --git a/drivers/gpu/drm/i915/gt/intel_region_lmem.c b/drivers/gpu/drm/i915/gt/intel_region_lmem.c index f7366b054f8e..4ae1f717a94c 100644 --- a/drivers/gpu/drm/i915/gt/intel_region_lmem.c +++ b/drivers/gpu/drm/i915/gt/intel_region_lmem.c @@ -9,6 +9,7 @@ #include "intel_region_ttm.h" #include "gem/i915_gem_lmem.h" #include "gem/i915_gem_region.h" +#include "gem/i915_gem_ttm.h" #include "intel_region_lmem.h" static int init_fake_lmem_bar(struct intel_memory_region *mem) @@ -107,7 +108,7 @@ region_lmem_init(struct intel_memory_region *mem) static const struct intel_memory_region_ops intel_region_lmem_ops = { .init = region_lmem_init, .release = region_lmem_release, - .init_object = __i915_gem_lmem_object_init, + .init_object = __i915_gem_ttm_object_init, }; struct intel_memory_region * diff --git a/drivers/gpu/drm/i915/i915_gem.c b/drivers/gpu/drm/i915/i915_gem.c index 0993d706f067..40fe9a147318 100644 --- a/drivers/gpu/drm/i915/i915_gem.c +++ b/drivers/gpu/drm/i915/i915_gem.c @@ -1005,8 +1005,11 @@ i915_gem_madvise_ioctl(struct drm_device *dev, void *data, } } - if (obj->mm.madv != __I915_MADV_PURGED) + if (obj->mm.madv != __I915_MADV_PURGED) { obj->mm.madv = args->madv; + if (obj->ops->adjust_lru) + obj->ops->adjust_lru(obj); + } if (i915_gem_object_has_pages(obj)) { unsigned long flags; diff --git a/drivers/gpu/drm/i915/intel_memory_region.c b/drivers/gpu/drm/i915/intel_memory_region.c index 4092cc987679..bd27e897d4d0 100644 --- a/drivers/gpu/drm/i915/intel_memory_region.c +++ b/drivers/gpu/drm/i915/intel_memory_region.c @@ -149,7 +149,6 @@ intel_memory_region_create(struct drm_i915_private *i915, mutex_init(&mem->objects.lock); INIT_LIST_HEAD(&mem->objects.list); - INIT_LIST_HEAD(&mem->objects.purgeable); INIT_LIST_HEAD(&mem->reserved); mutex_init(&mem->mm_lock); diff --git a/drivers/gpu/drm/i915/intel_memory_region.h b/drivers/gpu/drm/i915/intel_memory_region.h index e69cde13daf2..7b5fa97c0b59 100644 --- a/drivers/gpu/drm/i915/intel_memory_region.h +++ b/drivers/gpu/drm/i915/intel_memory_region.h @@ -100,7 +100,6 @@ struct intel_memory_region { struct { struct mutex lock; /* Protects access to objects */ struct list_head list; - struct list_head purgeable; } objects; size_t chunk_size; diff --git a/drivers/gpu/drm/i915/intel_region_ttm.c b/drivers/gpu/drm/i915/intel_region_ttm.c index c8ac118c21f6..0b41a1545570 100644 --- a/drivers/gpu/drm/i915/intel_region_ttm.c +++ b/drivers/gpu/drm/i915/intel_region_ttm.c @@ -10,6 +10,7 @@ #include "intel_region_ttm.h" +#include "gem/i915_gem_ttm.h" /* For the funcs/ops export only */ /** * DOC: TTM support structure * @@ -19,9 +20,6 @@ * i915 GEM regions to TTM memory types and resource managers. */ -/* A Zero-initialized driver for now. We don't have a TTM backend yet. */ -static struct ttm_device_funcs i915_ttm_bo_driver; - /** * intel_region_ttm_device_init - Initialize a TTM device * @dev_priv: Pointer to an i915 device private structure. @@ -32,7 +30,7 @@ int intel_region_ttm_device_init(struct drm_i915_private *dev_priv) { struct drm_device *drm = &dev_priv->drm; - return ttm_device_init(&dev_priv->bdev, &i915_ttm_bo_driver, + return ttm_device_init(&dev_priv->bdev, i915_ttm_driver(), drm->dev, drm->anon_inode->i_mapping, drm->vma_offset_manager, false, false); } @@ -172,6 +170,7 @@ struct sg_table *intel_region_ttm_node_to_st(struct intel_memory_region *mem, return i915_sg_from_mm_node(node, mem->region.start); } +#ifdef CONFIG_DRM_I915_SELFTEST /** * intel_region_ttm_node_alloc - Allocate memory resources from a region * @mem: The memory region, @@ -218,3 +217,4 @@ void *intel_region_ttm_node_alloc(struct intel_memory_region *mem, ret = -ENXIO; return ret ? ERR_PTR(ret) : res.mm_node; } +#endif diff --git a/drivers/gpu/drm/i915/intel_region_ttm.h b/drivers/gpu/drm/i915/intel_region_ttm.h index 1c82c6c3429d..eaa3eccfa252 100644 --- a/drivers/gpu/drm/i915/intel_region_ttm.h +++ b/drivers/gpu/drm/i915/intel_region_ttm.h @@ -11,6 +11,7 @@ struct drm_i915_private; struct intel_memory_region; +struct ttm_device_funcs; int intel_region_ttm_device_init(struct drm_i915_private *dev_priv); @@ -23,10 +24,14 @@ void intel_region_ttm_fini(struct intel_memory_region *mem); struct sg_table *intel_region_ttm_node_to_st(struct intel_memory_region *mem, void *node); +void intel_region_ttm_node_free(struct intel_memory_region *mem, + void *node); + +struct ttm_device_funcs *i915_ttm_driver(void); + +#ifdef CONFIG_DRM_I915_SELFTEST void *intel_region_ttm_node_alloc(struct intel_memory_region *mem, resource_size_t size, unsigned int flags); - -void intel_region_ttm_node_free(struct intel_memory_region *mem, - void *node); +#endif #endif /* _INTEL_REGION_TTM_H_ */ -- 2.31.1