From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org X-Spam-Level: X-Spam-Status: No, score=-16.8 required=3.0 tests=BAYES_00, HEADER_FROM_DIFFERENT_DOMAINS,INCLUDES_CR_TRAILER,INCLUDES_PATCH, MAILING_LIST_MULTI,SPF_HELO_NONE,SPF_PASS,URIBL_BLOCKED,USER_AGENT_GIT autolearn=ham autolearn_force=no version=3.4.0 Received: from mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id 8282AC47094 for ; Thu, 10 Jun 2021 07:02:27 +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 1C5FC613DF for ; Thu, 10 Jun 2021 07:02:27 +0000 (UTC) DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org 1C5FC613DF 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 518E76E5A2; Thu, 10 Jun 2021 07:02:26 +0000 (UTC) Received: from mga02.intel.com (mga02.intel.com [134.134.136.20]) by gabe.freedesktop.org (Postfix) with ESMTPS id 5B6546E5A2; Thu, 10 Jun 2021 07:02:25 +0000 (UTC) IronPort-SDR: mFqU36SbJcLTwzcez7MNrrOD1DN3dPyRz2MEFJYai0t4/c/W2Wa3xPNUPiKE+VBIGsIUOUtBSz eKqwyj+lkLIQ== X-IronPort-AV: E=McAfee;i="6200,9189,10010"; a="192351619" X-IronPort-AV: E=Sophos;i="5.83,262,1616482800"; d="scan'208";a="192351619" Received: from orsmga001.jf.intel.com ([10.7.209.18]) by orsmga101.jf.intel.com with ESMTP/TLS/ECDHE-RSA-AES256-GCM-SHA384; 10 Jun 2021 00:02:21 -0700 IronPort-SDR: d7eBZpwVQmIS05o1voCF1Q8QC1OZc3MKJJMjrcDWibHF1g1GQRr5DhNqcH2ACrhQm+3WFXfFiq lH4uuWDEpxDw== X-IronPort-AV: E=Sophos;i="5.83,262,1616482800"; d="scan'208";a="482717909" Received: from smirnov2-mobl.ccr.corp.intel.com (HELO thellst-mobl1.intel.com) ([10.249.254.160]) by orsmga001-auth.jf.intel.com with ESMTP/TLS/ECDHE-RSA-AES256-GCM-SHA384; 10 Jun 2021 00:02:19 -0700 From: =?UTF-8?q?Thomas=20Hellstr=C3=B6m?= To: intel-gfx@lists.freedesktop.org, dri-devel@lists.freedesktop.org Date: Thu, 10 Jun 2021 09:01:49 +0200 Message-Id: <20210610070152.572423-2-thomas.hellstrom@linux.intel.com> X-Mailer: git-send-email 2.31.1 In-Reply-To: <20210610070152.572423-1-thomas.hellstrom@linux.intel.com> References: <20210610070152.572423-1-thomas.hellstrom@linux.intel.com> MIME-Version: 1.0 Subject: [Intel-gfx] [PATCH v11 1/4] 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 bCBvdXQgdGhlIHR0bSBkcml2ZXIgZnJvbSB0aGUgYmFja2VuZC4KdjY6Ci0gUmVtb3ZlIHRoZSB0 dG0gZGV2aWNlIHZlcmlmeV9hY2Nlc3MgYXNzaWdubWVudC4gVGhlIG1lbWJlciBpcyBnb25lCiAg dXBzdHJlYW0uCi0tLQogZHJpdmVycy9ncHUvZHJtL2k5MTUvTWFrZWZpbGUgICAgICAgICAgICAg ICAgIHwgICAxICsKIGRyaXZlcnMvZ3B1L2RybS9pOTE1L2dlbS9pOTE1X2dlbV9jcmVhdGUuYyAg ICB8ICAgOSArLQogZHJpdmVycy9ncHUvZHJtL2k5MTUvZ2VtL2k5MTVfZ2VtX2xtZW0uYyAgICAg IHwgIDg0IC0tLQogZHJpdmVycy9ncHUvZHJtL2k5MTUvZ2VtL2k5MTVfZ2VtX2xtZW0uaCAgICAg IHwgICA1IC0KIGRyaXZlcnMvZ3B1L2RybS9pOTE1L2dlbS9pOTE1X2dlbV9vYmplY3QuYyAgICB8 IDEyNSArKy0tCiBkcml2ZXJzL2dwdS9kcm0vaTkxNS9nZW0vaTkxNV9nZW1fb2JqZWN0LmggICAg fCAgIDkgKwogLi4uL2dwdS9kcm0vaTkxNS9nZW0vaTkxNV9nZW1fb2JqZWN0X3R5cGVzLmggIHwg IDI3ICstCiBkcml2ZXJzL2dwdS9kcm0vaTkxNS9nZW0vaTkxNV9nZW1fcmVnaW9uLmMgICAgfCAg IDYgKy0KIGRyaXZlcnMvZ3B1L2RybS9pOTE1L2dlbS9pOTE1X2dlbV90dG0uYyAgICAgICB8IDU0 MCArKysrKysrKysrKysrKysrKysKIGRyaXZlcnMvZ3B1L2RybS9pOTE1L2dlbS9pOTE1X2dlbV90 dG0uaCAgICAgICB8ICA0OCArKwogZHJpdmVycy9ncHUvZHJtL2k5MTUvZ3QvaW50ZWxfcmVnaW9u X2xtZW0uYyAgIHwgICAzICstCiBkcml2ZXJzL2dwdS9kcm0vaTkxNS9pOTE1X2dlbS5jICAgICAg ICAgICAgICAgfCAgIDUgKy0KIGRyaXZlcnMvZ3B1L2RybS9pOTE1L2ludGVsX21lbW9yeV9yZWdp b24uYyAgICB8ICAgMSAtCiBkcml2ZXJzL2dwdS9kcm0vaTkxNS9pbnRlbF9tZW1vcnlfcmVnaW9u LmggICAgfCAgIDEgLQogZHJpdmVycy9ncHUvZHJtL2k5MTUvaW50ZWxfcmVnaW9uX3R0bS5jICAg ICAgIHwgICA4ICstCiBkcml2ZXJzL2dwdS9kcm0vaTkxNS9pbnRlbF9yZWdpb25fdHRtLmggICAg ICAgfCAgMTEgKy0KIDE2IGZpbGVzIGNoYW5nZWQsIDczMCBpbnNlcnRpb25zKCspLCAxNTMgZGVs ZXRpb25zKC0pCiBjcmVhdGUgbW9kZSAxMDA2NDQgZHJpdmVycy9ncHUvZHJtL2k5MTUvZ2VtL2k5 MTVfZ2VtX3R0bS5jCiBjcmVhdGUgbW9kZSAxMDA2NDQgZHJpdmVycy9ncHUvZHJtL2k5MTUvZ2Vt L2k5MTVfZ2VtX3R0bS5oCgpkaWZmIC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJtL2k5MTUvTWFrZWZp bGUgYi9kcml2ZXJzL2dwdS9kcm0vaTkxNS9NYWtlZmlsZQppbmRleCA0ZjIyY2FjMWM0OWIuLmY1 N2RmYzc0ZDZjZSAxMDA2NDQKLS0tIGEvZHJpdmVycy9ncHUvZHJtL2k5MTUvTWFrZWZpbGUKKysr IGIvZHJpdmVycy9ncHUvZHJtL2k5MTUvTWFrZWZpbGUKQEAgLTE1NSw2ICsxNTUsNyBAQCBnZW0t eSArPSBcCiAJZ2VtL2k5MTVfZ2VtX3N0b2xlbi5vIFwKIAlnZW0vaTkxNV9nZW1fdGhyb3R0bGUu byBcCiAJZ2VtL2k5MTVfZ2VtX3RpbGluZy5vIFwKKwlnZW0vaTkxNV9nZW1fdHRtLm8gXAogCWdl bS9pOTE1X2dlbV91c2VycHRyLm8gXAogCWdlbS9pOTE1X2dlbV93YWl0Lm8gXAogCWdlbS9pOTE1 X2dlbWZzLm8KZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2dlbS9pOTE1X2dlbV9j cmVhdGUuYyBiL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2dlbS9pOTE1X2dlbV9jcmVhdGUuYwppbmRl eCA1NDhkZGYzOWQ4NTMuLjkzYmY2M2JiYWZmMSAxMDA2NDQKLS0tIGEvZHJpdmVycy9ncHUvZHJt L2k5MTUvZ2VtL2k5MTVfZ2VtX2NyZWF0ZS5jCisrKyBiL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2dl bS9pOTE1X2dlbV9jcmVhdGUuYwpAQCAtODUsMTMgKzg1LDEwIEBAIGk5MTVfZ2VtX3NldHVwKHN0 cnVjdCBkcm1faTkxNV9nZW1fb2JqZWN0ICpvYmosIHU2NCBzaXplKQogCQlyZXR1cm4gLUUyQklH OwogCiAJLyoKLQkgKiBGb3Igbm93IHJlc29ydCB0byBDUFUgYmFzZWQgY2xlYXJpbmcgZm9yIGRl dmljZSBsb2NhbC1tZW1vcnksIGluIHRoZQotCSAqIG5lYXIgZnV0dXJlIHRoaXMgd2lsbCB1c2Ug dGhlIGJsaXR0ZXIgZW5naW5lIGZvciBhY2NlbGVyYXRlZCwgR1BVCi0JICogYmFzZWQgY2xlYXJp bmcuCisJICogSTkxNV9CT19BTExPQ19VU0VSIHdpbGwgbWFrZSBzdXJlIHRoZSBvYmplY3QgaXMg Y2xlYXJlZCBiZWZvcmUKKwkgKiBhbnkgdXNlciBhY2Nlc3MuCiAJICovCi0JZmxhZ3MgPSAwOwot CWlmIChtci0+dHlwZSA9PSBJTlRFTF9NRU1PUllfTE9DQUwpCi0JCWZsYWdzID0gSTkxNV9CT19B TExPQ19DUFVfQ0xFQVI7CisJZmxhZ3MgPSBJOTE1X0JPX0FMTE9DX1VTRVI7CiAKIAlyZXQgPSBt ci0+b3BzLT5pbml0X29iamVjdChtciwgb2JqLCBzaXplLCBmbGFncyk7CiAJaWYgKHJldCkKZGlm ZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2dlbS9pOTE1X2dlbV9sbWVtLmMgYi9kcml2 ZXJzL2dwdS9kcm0vaTkxNS9nZW0vaTkxNV9nZW1fbG1lbS5jCmluZGV4IDNiNGFhMjhhMDc2ZC4u MmI4Y2QxNWRlMWQ5IDEwMDY0NAotLS0gYS9kcml2ZXJzL2dwdS9kcm0vaTkxNS9nZW0vaTkxNV9n ZW1fbG1lbS5jCisrKyBiL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2dlbS9pOTE1X2dlbV9sbWVtLmMK QEAgLTQsNzQgKzQsMTAgQEAKICAqLwogCiAjaW5jbHVkZSAiaW50ZWxfbWVtb3J5X3JlZ2lvbi5o IgotI2luY2x1ZGUgImludGVsX3JlZ2lvbl90dG0uaCIKICNpbmNsdWRlICJnZW0vaTkxNV9nZW1f cmVnaW9uLmgiCiAjaW5jbHVkZSAiZ2VtL2k5MTVfZ2VtX2xtZW0uaCIKICNpbmNsdWRlICJpOTE1 X2Rydi5oIgogCi1zdGF0aWMgdm9pZCBsbWVtX3B1dF9wYWdlcyhzdHJ1Y3QgZHJtX2k5MTVfZ2Vt X29iamVjdCAqb2JqLAotCQkJICAgc3RydWN0IHNnX3RhYmxlICpwYWdlcykKLXsKLQlpbnRlbF9y ZWdpb25fdHRtX25vZGVfZnJlZShvYmotPm1tLnJlZ2lvbiwgb2JqLT5tbS5zdF9tbV9ub2RlKTsK LQlvYmotPm1tLmRpcnR5ID0gZmFsc2U7Ci0Jc2dfZnJlZV90YWJsZShwYWdlcyk7Ci0Ja2ZyZWUo cGFnZXMpOwotfQotCi1zdGF0aWMgaW50IGxtZW1fZ2V0X3BhZ2VzKHN0cnVjdCBkcm1faTkxNV9n ZW1fb2JqZWN0ICpvYmopCi17Ci0JdW5zaWduZWQgaW50IGZsYWdzOwotCXN0cnVjdCBzZ190YWJs ZSAqcGFnZXM7Ci0KLQlmbGFncyA9IEk5MTVfQUxMT0NfTUlOX1BBR0VfU0laRTsKLQlpZiAob2Jq LT5mbGFncyAmIEk5MTVfQk9fQUxMT0NfQ09OVElHVU9VUykKLQkJZmxhZ3MgfD0gSTkxNV9BTExP Q19DT05USUdVT1VTOwotCi0Jb2JqLT5tbS5zdF9tbV9ub2RlID0gaW50ZWxfcmVnaW9uX3R0bV9u b2RlX2FsbG9jKG9iai0+bW0ucmVnaW9uLAotCQkJCQkJCSBvYmotPmJhc2Uuc2l6ZSwKLQkJCQkJ CQkgZmxhZ3MpOwotCWlmIChJU19FUlIob2JqLT5tbS5zdF9tbV9ub2RlKSkKLQkJcmV0dXJuIFBU Ul9FUlIob2JqLT5tbS5zdF9tbV9ub2RlKTsKLQotCS8qIFJhbmdlIG1hbmFnZXIgaXMgYWx3YXlz IGNvbnRpZ291cyAqLwotCWlmIChvYmotPm1tLnJlZ2lvbi0+aXNfcmFuZ2VfbWFuYWdlcikKLQkJ b2JqLT5mbGFncyB8PSBJOTE1X0JPX0FMTE9DX0NPTlRJR1VPVVM7Ci0JcGFnZXMgPSBpbnRlbF9y ZWdpb25fdHRtX25vZGVfdG9fc3Qob2JqLT5tbS5yZWdpb24sIG9iai0+bW0uc3RfbW1fbm9kZSk7 Ci0JaWYgKElTX0VSUihwYWdlcykpIHsKLQkJaW50ZWxfcmVnaW9uX3R0bV9ub2RlX2ZyZWUob2Jq LT5tbS5yZWdpb24sIG9iai0+bW0uc3RfbW1fbm9kZSk7Ci0JCXJldHVybiBQVFJfRVJSKHBhZ2Vz KTsKLQl9Ci0KLQlfX2k5MTVfZ2VtX29iamVjdF9zZXRfcGFnZXMob2JqLCBwYWdlcywgaTkxNV9z Z19kbWFfc2l6ZXMocGFnZXMtPnNnbCkpOwotCi0JaWYgKG9iai0+ZmxhZ3MgJiBJOTE1X0JPX0FM TE9DX0NQVV9DTEVBUikgewotCQl2b2lkIF9faW9tZW0gKnZhZGRyID0KLQkJCWk5MTVfZ2VtX29i amVjdF9sbWVtX2lvX21hcChvYmosIDAsIG9iai0+YmFzZS5zaXplKTsKLQotCQlpZiAoIXZhZGRy KSB7Ci0JCQlzdHJ1Y3Qgc2dfdGFibGUgKnBhZ2VzID0KLQkJCQlfX2k5MTVfZ2VtX29iamVjdF91 bnNldF9wYWdlcyhvYmopOwotCi0JCQlpZiAoIUlTX0VSUl9PUl9OVUxMKHBhZ2VzKSkKLQkJCQls bWVtX3B1dF9wYWdlcyhvYmosIHBhZ2VzKTsKLQkJfQotCi0JCW1lbXNldF9pbyh2YWRkciwgMCwg b2JqLT5iYXNlLnNpemUpOwotCQlpb19tYXBwaW5nX3VubWFwKHZhZGRyKTsKLQl9Ci0KLQlyZXR1 cm4gMDsKLX0KLQotY29uc3Qgc3RydWN0IGRybV9pOTE1X2dlbV9vYmplY3Rfb3BzIGk5MTVfZ2Vt X2xtZW1fb2JqX29wcyA9IHsKLQkubmFtZSA9ICJpOTE1X2dlbV9vYmplY3RfbG1lbSIsCi0JLmZs YWdzID0gSTkxNV9HRU1fT0JKRUNUX0hBU19JT01FTSwKLQotCS5nZXRfcGFnZXMgPSBsbWVtX2dl dF9wYWdlcywKLQkucHV0X3BhZ2VzID0gbG1lbV9wdXRfcGFnZXMsCi0JLnJlbGVhc2UgPSBpOTE1 X2dlbV9vYmplY3RfcmVsZWFzZV9tZW1vcnlfcmVnaW9uLAotfTsKLQogdm9pZCBfX2lvbWVtICoK IGk5MTVfZ2VtX29iamVjdF9sbWVtX2lvX21hcChzdHJ1Y3QgZHJtX2k5MTVfZ2VtX29iamVjdCAq b2JqLAogCQkJICAgIHVuc2lnbmVkIGxvbmcgbiwKQEAgLTEwMywyMyArMzksMyBAQCBpOTE1X2dl bV9vYmplY3RfY3JlYXRlX2xtZW0oc3RydWN0IGRybV9pOTE1X3ByaXZhdGUgKmk5MTUsCiAJcmV0 dXJuIGk5MTVfZ2VtX29iamVjdF9jcmVhdGVfcmVnaW9uKGk5MTUtPm1tLnJlZ2lvbnNbSU5URUxf UkVHSU9OX0xNRU1dLAogCQkJCQkgICAgIHNpemUsIGZsYWdzKTsKIH0KLQotaW50IF9faTkxNV9n ZW1fbG1lbV9vYmplY3RfaW5pdChzdHJ1Y3QgaW50ZWxfbWVtb3J5X3JlZ2lvbiAqbWVtLAotCQkJ CXN0cnVjdCBkcm1faTkxNV9nZW1fb2JqZWN0ICpvYmosCi0JCQkJcmVzb3VyY2Vfc2l6ZV90IHNp emUsCi0JCQkJdW5zaWduZWQgaW50IGZsYWdzKQotewotCXN0YXRpYyBzdHJ1Y3QgbG9ja19jbGFz c19rZXkgbG9ja19jbGFzczsKLQlzdHJ1Y3QgZHJtX2k5MTVfcHJpdmF0ZSAqaTkxNSA9IG1lbS0+ aTkxNTsKLQotCWRybV9nZW1fcHJpdmF0ZV9vYmplY3RfaW5pdCgmaTkxNS0+ZHJtLCAmb2JqLT5i YXNlLCBzaXplKTsKLQlpOTE1X2dlbV9vYmplY3RfaW5pdChvYmosICZpOTE1X2dlbV9sbWVtX29i al9vcHMsICZsb2NrX2NsYXNzLCBmbGFncyk7Ci0KLQlvYmotPnJlYWRfZG9tYWlucyA9IEk5MTVf R0VNX0RPTUFJTl9XQyB8IEk5MTVfR0VNX0RPTUFJTl9HVFQ7Ci0KLQlpOTE1X2dlbV9vYmplY3Rf c2V0X2NhY2hlX2NvaGVyZW5jeShvYmosIEk5MTVfQ0FDSEVfTk9ORSk7Ci0KLQlpOTE1X2dlbV9v YmplY3RfaW5pdF9tZW1vcnlfcmVnaW9uKG9iaiwgbWVtKTsKLQotCXJldHVybiAwOwotfQpkaWZm IC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJtL2k5MTUvZ2VtL2k5MTVfZ2VtX2xtZW0uaCBiL2RyaXZl cnMvZ3B1L2RybS9pOTE1L2dlbS9pOTE1X2dlbV9sbWVtLmgKaW5kZXggZmFjNmJjNWE1ZWJiLi5l YTc2ZmQxMWNjYjAgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2dlbS9pOTE1X2dl bV9sbWVtLmgKKysrIGIvZHJpdmVycy9ncHUvZHJtL2k5MTUvZ2VtL2k5MTVfZ2VtX2xtZW0uaApA QCAtMjYsOSArMjYsNCBAQCBpOTE1X2dlbV9vYmplY3RfY3JlYXRlX2xtZW0oc3RydWN0IGRybV9p OTE1X3ByaXZhdGUgKmk5MTUsCiAJCQkgICAgcmVzb3VyY2Vfc2l6ZV90IHNpemUsCiAJCQkgICAg dW5zaWduZWQgaW50IGZsYWdzKTsKIAotaW50IF9faTkxNV9nZW1fbG1lbV9vYmplY3RfaW5pdChz dHJ1Y3QgaW50ZWxfbWVtb3J5X3JlZ2lvbiAqbWVtLAotCQkJCXN0cnVjdCBkcm1faTkxNV9nZW1f b2JqZWN0ICpvYmosCi0JCQkJcmVzb3VyY2Vfc2l6ZV90IHNpemUsCi0JCQkJdW5zaWduZWQgaW50 IGZsYWdzKTsKLQogI2VuZGlmIC8qICFfX0k5MTVfR0VNX0xNRU1fSCAqLwpkaWZmIC0tZ2l0IGEv ZHJpdmVycy9ncHUvZHJtL2k5MTUvZ2VtL2k5MTVfZ2VtX29iamVjdC5jIGIvZHJpdmVycy9ncHUv ZHJtL2k5MTUvZ2VtL2k5MTVfZ2VtX29iamVjdC5jCmluZGV4IDU3MDZkNDcxNjkyZC4uMTZlYWM1 ZWE5MjM4IDEwMDY0NAotLS0gYS9kcml2ZXJzL2dwdS9kcm0vaTkxNS9nZW0vaTkxNV9nZW1fb2Jq ZWN0LmMKKysrIGIvZHJpdmVycy9ncHUvZHJtL2k5MTUvZ2VtL2k5MTVfZ2VtX29iamVjdC5jCkBA IC0xNzIsNyArMTcyLDcgQEAgc3RhdGljIHZvaWQgaTkxNV9nZW1fY2xvc2Vfb2JqZWN0KHN0cnVj dCBkcm1fZ2VtX29iamVjdCAqZ2VtLCBzdHJ1Y3QgZHJtX2ZpbGUgKmYKIAl9CiB9CiAKLXN0YXRp YyB2b2lkIF9faTkxNV9nZW1fZnJlZV9vYmplY3RfcmN1KHN0cnVjdCByY3VfaGVhZCAqaGVhZCkK K3ZvaWQgX19pOTE1X2dlbV9mcmVlX29iamVjdF9yY3Uoc3RydWN0IHJjdV9oZWFkICpoZWFkKQog ewogCXN0cnVjdCBkcm1faTkxNV9nZW1fb2JqZWN0ICpvYmogPQogCQljb250YWluZXJfb2YoaGVh ZCwgdHlwZW9mKCpvYmopLCByY3UpOwpAQCAtMjA4LDU5ICsyMDgsNjkgQEAgc3RhdGljIHZvaWQg X19pOTE1X2dlbV9vYmplY3RfZnJlZV9tbWFwcyhzdHJ1Y3QgZHJtX2k5MTVfZ2VtX29iamVjdCAq b2JqKQogCX0KIH0KIAotc3RhdGljIHZvaWQgX19pOTE1X2dlbV9mcmVlX29iamVjdHMoc3RydWN0 IGRybV9pOTE1X3ByaXZhdGUgKmk5MTUsCi0JCQkJICAgIHN0cnVjdCBsbGlzdF9ub2RlICpmcmVl ZCkKK3ZvaWQgX19pOTE1X2dlbV9mcmVlX29iamVjdChzdHJ1Y3QgZHJtX2k5MTVfZ2VtX29iamVj dCAqb2JqKQogewotCXN0cnVjdCBkcm1faTkxNV9nZW1fb2JqZWN0ICpvYmosICpvbjsKKwl0cmFj ZV9pOTE1X2dlbV9vYmplY3RfZGVzdHJveShvYmopOwogCi0JbGxpc3RfZm9yX2VhY2hfZW50cnlf c2FmZShvYmosIG9uLCBmcmVlZCwgZnJlZWQpIHsKLQkJdHJhY2VfaTkxNV9nZW1fb2JqZWN0X2Rl c3Ryb3kob2JqKTsKKwlpZiAoIWxpc3RfZW1wdHkoJm9iai0+dm1hLmxpc3QpKSB7CisJCXN0cnVj dCBpOTE1X3ZtYSAqdm1hOworCisJCS8qCisJCSAqIE5vdGUgdGhhdCB0aGUgdm1hIGtlZXBzIGFu IG9iamVjdCByZWZlcmVuY2Ugd2hpbGUKKwkJICogaXQgaXMgYWN0aXZlLCBzbyBpdCAqc2hvdWxk KiBub3Qgc2xlZXAgd2hpbGUgd2UKKwkJICogZGVzdHJveSBpdC4gT3VyIGRlYnVnIGNvZGUgZXJy cyBpbnNpdHMgaXQgKm1pZ2h0Ki4KKwkJICogRm9yIHRoZSBtb21lbnQsIHBsYXkgYWxvbmcuCisJ CSAqLworCQlzcGluX2xvY2soJm9iai0+dm1hLmxvY2spOworCQl3aGlsZSAoKHZtYSA9IGxpc3Rf Zmlyc3RfZW50cnlfb3JfbnVsbCgmb2JqLT52bWEubGlzdCwKKwkJCQkJCSAgICAgICBzdHJ1Y3Qg aTkxNV92bWEsCisJCQkJCQkgICAgICAgb2JqX2xpbmspKSkgeworCQkJR0VNX0JVR19PTih2bWEt Pm9iaiAhPSBvYmopOworCQkJc3Bpbl91bmxvY2soJm9iai0+dm1hLmxvY2spOwogCi0JCWlmICgh bGlzdF9lbXB0eSgmb2JqLT52bWEubGlzdCkpIHsKLQkJCXN0cnVjdCBpOTE1X3ZtYSAqdm1hOwor CQkJX19pOTE1X3ZtYV9wdXQodm1hKTsKIAotCQkJLyoKLQkJCSAqIE5vdGUgdGhhdCB0aGUgdm1h IGtlZXBzIGFuIG9iamVjdCByZWZlcmVuY2Ugd2hpbGUKLQkJCSAqIGl0IGlzIGFjdGl2ZSwgc28g aXQgKnNob3VsZCogbm90IHNsZWVwIHdoaWxlIHdlCi0JCQkgKiBkZXN0cm95IGl0LiBPdXIgZGVi dWcgY29kZSBlcnJzIGluc2l0cyBpdCAqbWlnaHQqLgotCQkJICogRm9yIHRoZSBtb21lbnQsIHBs YXkgYWxvbmcuCi0JCQkgKi8KIAkJCXNwaW5fbG9jaygmb2JqLT52bWEubG9jayk7Ci0JCQl3aGls ZSAoKHZtYSA9IGxpc3RfZmlyc3RfZW50cnlfb3JfbnVsbCgmb2JqLT52bWEubGlzdCwKLQkJCQkJ CQkgICAgICAgc3RydWN0IGk5MTVfdm1hLAotCQkJCQkJCSAgICAgICBvYmpfbGluaykpKSB7Ci0J CQkJR0VNX0JVR19PTih2bWEtPm9iaiAhPSBvYmopOwotCQkJCXNwaW5fdW5sb2NrKCZvYmotPnZt YS5sb2NrKTsKKwkJfQorCQlzcGluX3VubG9jaygmb2JqLT52bWEubG9jayk7CisJfQogCi0JCQkJ X19pOTE1X3ZtYV9wdXQodm1hKTsKKwlfX2k5MTVfZ2VtX29iamVjdF9mcmVlX21tYXBzKG9iaik7 CiAKLQkJCQlzcGluX2xvY2soJm9iai0+dm1hLmxvY2spOwotCQkJfQotCQkJc3Bpbl91bmxvY2so Jm9iai0+dm1hLmxvY2spOwotCQl9CisJR0VNX0JVR19PTighbGlzdF9lbXB0eSgmb2JqLT5sdXRf bGlzdCkpOwogCi0JCV9faTkxNV9nZW1fb2JqZWN0X2ZyZWVfbW1hcHMob2JqKTsKKwlhdG9taWNf c2V0KCZvYmotPm1tLnBhZ2VzX3Bpbl9jb3VudCwgMCk7CisJX19pOTE1X2dlbV9vYmplY3RfcHV0 X3BhZ2VzKG9iaik7CisJR0VNX0JVR19PTihpOTE1X2dlbV9vYmplY3RfaGFzX3BhZ2VzKG9iaikp OworCWJpdG1hcF9mcmVlKG9iai0+Yml0XzE3KTsKIAotCQlHRU1fQlVHX09OKCFsaXN0X2VtcHR5 KCZvYmotPmx1dF9saXN0KSk7CisJaWYgKG9iai0+YmFzZS5pbXBvcnRfYXR0YWNoKQorCQlkcm1f cHJpbWVfZ2VtX2Rlc3Ryb3koJm9iai0+YmFzZSwgTlVMTCk7CiAKLQkJYXRvbWljX3NldCgmb2Jq LT5tbS5wYWdlc19waW5fY291bnQsIDApOwotCQlfX2k5MTVfZ2VtX29iamVjdF9wdXRfcGFnZXMo b2JqKTsKLQkJR0VNX0JVR19PTihpOTE1X2dlbV9vYmplY3RfaGFzX3BhZ2VzKG9iaikpOwotCQli aXRtYXBfZnJlZShvYmotPmJpdF8xNyk7CisJZHJtX2dlbV9mcmVlX21tYXBfb2Zmc2V0KCZvYmot PmJhc2UpOwogCi0JCWlmIChvYmotPmJhc2UuaW1wb3J0X2F0dGFjaCkKLQkJCWRybV9wcmltZV9n ZW1fZGVzdHJveSgmb2JqLT5iYXNlLCBOVUxMKTsKKwlpZiAob2JqLT5vcHMtPnJlbGVhc2UpCisJ CW9iai0+b3BzLT5yZWxlYXNlKG9iaik7CiAKLQkJZHJtX2dlbV9mcmVlX21tYXBfb2Zmc2V0KCZv YmotPmJhc2UpOworCWlmIChvYmotPm1tLm5fcGxhY2VtZW50cyA+IDEpCisJCWtmcmVlKG9iai0+ bW0ucGxhY2VtZW50cyk7CiAKLQkJaWYgKG9iai0+b3BzLT5yZWxlYXNlKQotCQkJb2JqLT5vcHMt PnJlbGVhc2Uob2JqKTsKKwlpZiAob2JqLT5zaGFyZXNfcmVzdl9mcm9tKQorCQlpOTE1X3ZtX3Jl c3ZfcHV0KG9iai0+c2hhcmVzX3Jlc3ZfZnJvbSk7Cit9CiAKLQkJaWYgKG9iai0+bW0ubl9wbGFj ZW1lbnRzID4gMSkKLQkJCWtmcmVlKG9iai0+bW0ucGxhY2VtZW50cyk7CitzdGF0aWMgdm9pZCBf X2k5MTVfZ2VtX2ZyZWVfb2JqZWN0cyhzdHJ1Y3QgZHJtX2k5MTVfcHJpdmF0ZSAqaTkxNSwKKwkJ CQkgICAgc3RydWN0IGxsaXN0X25vZGUgKmZyZWVkKQoreworCXN0cnVjdCBkcm1faTkxNV9nZW1f b2JqZWN0ICpvYmosICpvbjsKIAotCQlpZiAob2JqLT5zaGFyZXNfcmVzdl9mcm9tKQotCQkJaTkx NV92bV9yZXN2X3B1dChvYmotPnNoYXJlc19yZXN2X2Zyb20pOworCWxsaXN0X2Zvcl9lYWNoX2Vu dHJ5X3NhZmUob2JqLCBvbiwgZnJlZWQsIGZyZWVkKSB7CisJCW1pZ2h0X3NsZWVwKCk7CisJCWlm IChvYmotPm9wcy0+ZGVsYXllZF9mcmVlKSB7CisJCQlvYmotPm9wcy0+ZGVsYXllZF9mcmVlKG9i aik7CisJCQljb250aW51ZTsKKwkJfQorCQlfX2k5MTVfZ2VtX2ZyZWVfb2JqZWN0KG9iaik7CiAK IAkJLyogQnV0IGtlZXAgdGhlIHBvaW50ZXIgYWxpdmUgZm9yIFJDVS1wcm90ZWN0ZWQgbG9va3Vw cyAqLwogCQljYWxsX3JjdSgmb2JqLT5yY3UsIF9faTkxNV9nZW1fZnJlZV9vYmplY3RfcmN1KTsK QEAgLTMxOCw2ICszMjgsNyBAQCBzdGF0aWMgdm9pZCBpOTE1X2dlbV9mcmVlX29iamVjdChzdHJ1 Y3QgZHJtX2dlbV9vYmplY3QgKmdlbV9vYmopCiAJICogd29ya2VyIGFuZCBwZXJmb3JtaW5nIGZy ZWVzIGRpcmVjdGx5IGZyb20gc3Vic2VxdWVudCBhbGxvY2F0aW9ucyBmb3IKIAkgKiBjcnVkZSBi dXQgZWZmZWN0aXZlIG1lbW9yeSB0aHJvdHRsaW5nLgogCSAqLworCiAJaWYgKGxsaXN0X2FkZCgm b2JqLT5mcmVlZCwgJmk5MTUtPm1tLmZyZWVfbGlzdCkpCiAJCXF1ZXVlX3dvcmsoaTkxNS0+d3Es ICZpOTE1LT5tbS5mcmVlX3dvcmspOwogfQpAQCAtNDEwLDYgKzQyMSw0MiBAQCBpbnQgaTkxNV9n ZW1fb2JqZWN0X3JlYWRfZnJvbV9wYWdlKHN0cnVjdCBkcm1faTkxNV9nZW1fb2JqZWN0ICpvYmos IHU2NCBvZmZzZXQsCiAJcmV0dXJuIDA7CiB9CiAKKy8qKgorICogaTkxNV9nZW1fb2JqZWN0X2V2 aWN0YWJsZSAtIFdoZXRoZXIgb2JqZWN0IGlzIGxpa2VseSBldmljdGFibGUgYWZ0ZXIgdW5iaW5k LgorICogQG9iajogVGhlIG9iamVjdCB0byBjaGVjaworICoKKyAqIFRoaXMgZnVuY3Rpb24gY2hl Y2tzIHdoZXRoZXIgdGhlIG9iamVjdCBpcyBsaWtlbHkgdW52aWN0YWJsZSBhZnRlciB1bmJpbmQu CisgKiBJZiB0aGUgb2JqZWN0IGlzIG5vdCBsb2NrZWQgd2hlbiBjaGVja2luZywgdGhlIHJlc3Vs dCBpcyBvbmx5IGFkdmlzb3J5LgorICogSWYgdGhlIG9iamVjdCBpcyBsb2NrZWQgd2hlbiBjaGVj a2luZywgYW5kIHRoZSBmdW5jdGlvbiByZXR1cm5zIHRydWUsCisgKiB0aGVuIGFuIGV2aWN0aW9u IHNob3VsZCBpbmRlZWQgYmUgcG9zc2libGUuIEJ1dCBzaW5jZSB1bmxvY2tlZCB2bWEKKyAqIHVu cGlubmluZyBhbmQgdW5iaW5kaW5nIGlzIGN1cnJlbnRseSBwb3NzaWJsZSwgdGhlIG9iamVjdCBj YW4gYWN0dWFsbHkKKyAqIGJlY29tZSBldmljdGFibGUgZXZlbiBpZiB0aGlzIGZ1bmN0aW9uIHJl dHVybnMgZmFsc2UuCisgKgorICogUmV0dXJuOiB0cnVlIGlmIHRoZSBvYmplY3QgbWF5IGJlIGV2 aWN0YWJsZS4gRmFsc2Ugb3RoZXJ3aXNlLgorICovCitib29sIGk5MTVfZ2VtX29iamVjdF9ldmlj dGFibGUoc3RydWN0IGRybV9pOTE1X2dlbV9vYmplY3QgKm9iaikKK3sKKwlzdHJ1Y3QgaTkxNV92 bWEgKnZtYTsKKwlpbnQgcGluX2NvdW50ID0gYXRvbWljX3JlYWQoJm9iai0+bW0ucGFnZXNfcGlu X2NvdW50KTsKKworCWlmICghcGluX2NvdW50KQorCQlyZXR1cm4gdHJ1ZTsKKworCXNwaW5fbG9j aygmb2JqLT52bWEubG9jayk7CisJbGlzdF9mb3JfZWFjaF9lbnRyeSh2bWEsICZvYmotPnZtYS5s aXN0LCBvYmpfbGluaykgeworCQlpZiAoaTkxNV92bWFfaXNfcGlubmVkKHZtYSkpIHsKKwkJCXNw aW5fdW5sb2NrKCZvYmotPnZtYS5sb2NrKTsKKwkJCXJldHVybiBmYWxzZTsKKwkJfQorCQlpZiAo YXRvbWljX3JlYWQoJnZtYS0+cGFnZXNfY291bnQpKQorCQkJcGluX2NvdW50LS07CisJfQorCXNw aW5fdW5sb2NrKCZvYmotPnZtYS5sb2NrKTsKKwlHRU1fV0FSTl9PTihwaW5fY291bnQgPCAwKTsK KworCXJldHVybiBwaW5fY291bnQgPT0gMDsKK30KKwogdm9pZCBpOTE1X2dlbV9pbml0X19vYmpl Y3RzKHN0cnVjdCBkcm1faTkxNV9wcml2YXRlICppOTE1KQogewogCUlOSVRfV09SSygmaTkxNS0+ bW0uZnJlZV93b3JrLCBfX2k5MTVfZ2VtX2ZyZWVfd29yayk7CmRpZmYgLS1naXQgYS9kcml2ZXJz L2dwdS9kcm0vaTkxNS9nZW0vaTkxNV9nZW1fb2JqZWN0LmggYi9kcml2ZXJzL2dwdS9kcm0vaTkx NS9nZW0vaTkxNV9nZW1fb2JqZWN0LmgKaW5kZXggN2MwZWI0MjVjYjNiLi41YWUzMmVhOTllZTUg MTAwNjQ0Ci0tLSBhL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2dlbS9pOTE1X2dlbV9vYmplY3QuaAor KysgYi9kcml2ZXJzL2dwdS9kcm0vaTkxNS9nZW0vaTkxNV9nZW1fb2JqZWN0LmgKQEAgLTIwMCw2 ICsyMDAsOSBAQCBzdGF0aWMgaW5saW5lIGJvb2wgaTkxNV9nZW1fb2JqZWN0X3RyeWxvY2soc3Ry dWN0IGRybV9pOTE1X2dlbV9vYmplY3QgKm9iaikKIAogc3RhdGljIGlubGluZSB2b2lkIGk5MTVf Z2VtX29iamVjdF91bmxvY2soc3RydWN0IGRybV9pOTE1X2dlbV9vYmplY3QgKm9iaikKIHsKKwlp ZiAob2JqLT5vcHMtPmFkanVzdF9scnUpCisJCW9iai0+b3BzLT5hZGp1c3RfbHJ1KG9iaik7CisK IAlkbWFfcmVzdl91bmxvY2sob2JqLT5iYXNlLnJlc3YpOwogfQogCkBAIC01ODcsNiArNTkwLDEy IEBAIGludCBpOTE1X2dlbV9vYmplY3RfcmVhZF9mcm9tX3BhZ2Uoc3RydWN0IGRybV9pOTE1X2dl bV9vYmplY3QgKm9iaiwgdTY0IG9mZnNldCwKIAogYm9vbCBpOTE1X2dlbV9vYmplY3RfaXNfc2ht ZW0oY29uc3Qgc3RydWN0IGRybV9pOTE1X2dlbV9vYmplY3QgKm9iaik7CiAKK3ZvaWQgX19pOTE1 X2dlbV9mcmVlX29iamVjdF9yY3Uoc3RydWN0IHJjdV9oZWFkICpoZWFkKTsKKwordm9pZCBfX2k5 MTVfZ2VtX2ZyZWVfb2JqZWN0KHN0cnVjdCBkcm1faTkxNV9nZW1fb2JqZWN0ICpvYmopOworCiti b29sIGk5MTVfZ2VtX29iamVjdF9ldmljdGFibGUoc3RydWN0IGRybV9pOTE1X2dlbV9vYmplY3Qg Km9iaik7CisKICNpZmRlZiBDT05GSUdfTU1VX05PVElGSUVSCiBzdGF0aWMgaW5saW5lIGJvb2wK IGk5MTVfZ2VtX29iamVjdF9pc191c2VycHRyKHN0cnVjdCBkcm1faTkxNV9nZW1fb2JqZWN0ICpv YmopCmRpZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9kcm0vaTkxNS9nZW0vaTkxNV9nZW1fb2JqZWN0 X3R5cGVzLmggYi9kcml2ZXJzL2dwdS9kcm0vaTkxNS9nZW0vaTkxNV9nZW1fb2JqZWN0X3R5cGVz LmgKaW5kZXggZDA0N2VhMTI2MDI5Li42ODMxMzQ3NGU2YTYgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMv Z3B1L2RybS9pOTE1L2dlbS9pOTE1X2dlbV9vYmplY3RfdHlwZXMuaAorKysgYi9kcml2ZXJzL2dw dS9kcm0vaTkxNS9nZW0vaTkxNV9nZW1fb2JqZWN0X3R5cGVzLmgKQEAgLTYzLDYgKzYzLDIwIEBA IHN0cnVjdCBkcm1faTkxNV9nZW1fb2JqZWN0X29wcyB7CiAJCSAgICAgIGNvbnN0IHN0cnVjdCBk cm1faTkxNV9nZW1fcHdyaXRlICphcmcpOwogCiAJaW50ICgqZG1hYnVmX2V4cG9ydCkoc3RydWN0 IGRybV9pOTE1X2dlbV9vYmplY3QgKm9iaik7CisKKwkvKioKKwkgKiBhZGp1c3RfbHJ1IC0gbm90 aWZ5IHRoYXQgdGhlIG1hZHZpc2UgdmFsdWUgd2FzIHVwZGF0ZWQKKwkgKiBAb2JqOiBUaGUgZ2Vt IG9iamVjdAorCSAqCisJICogVGhlIG1hZHZpc2UgdmFsdWUgbWF5IGhhdmUgYmVlbiB1cGRhdGVk LCBvciBvYmplY3Qgd2FzIHJlY2VudGx5CisJICogcmVmZXJlbmNlZCBzbyBhY3QgYWNjb3JkaW5n bHkgKFBlcmhhcHMgY2hhbmdpbmcgYW4gTFJVIGxpc3QgZXRjKS4KKwkgKi8KKwl2b2lkICgqYWRq dXN0X2xydSkoc3RydWN0IGRybV9pOTE1X2dlbV9vYmplY3QgKm9iaik7CisKKwkvKioKKwkgKiBk ZWxheWVkX2ZyZWUgLSBPdmVycmlkZSB0aGUgZGVmYXVsdCBkZWxheWVkIGZyZWUgaW1wbGVtZW50 YXRpb24KKwkgKi8KKwl2b2lkICgqZGVsYXllZF9mcmVlKShzdHJ1Y3QgZHJtX2k5MTVfZ2VtX29i amVjdCAqb2JqKTsKIAl2b2lkICgqcmVsZWFzZSkoc3RydWN0IGRybV9pOTE1X2dlbV9vYmplY3Qg Km9iaik7CiAKIAljb25zdCBjaGFyICpuYW1lOyAvKiBmcmllbmRseSBuYW1lIGZvciBkZWJ1Zywg ZS5nLiBsb2NrZGVwIGNsYXNzZXMgKi8KQEAgLTE4NywxMiArMjAxLDE0IEBAIHN0cnVjdCBkcm1f aTkxNV9nZW1fb2JqZWN0IHsKICNkZWZpbmUgSTkxNV9CT19BTExPQ19WT0xBVElMRSAgIEJJVCgx KQogI2RlZmluZSBJOTE1X0JPX0FMTE9DX1NUUlVDVF9QQUdFIEJJVCgyKQogI2RlZmluZSBJOTE1 X0JPX0FMTE9DX0NQVV9DTEVBUiAgQklUKDMpCisjZGVmaW5lIEk5MTVfQk9fQUxMT0NfVVNFUiAg ICAgICBCSVQoNCkKICNkZWZpbmUgSTkxNV9CT19BTExPQ19GTEFHUyAoSTkxNV9CT19BTExPQ19D T05USUdVT1VTIHwgXAogCQkJICAgICBJOTE1X0JPX0FMTE9DX1ZPTEFUSUxFIHwgXAogCQkJICAg ICBJOTE1X0JPX0FMTE9DX1NUUlVDVF9QQUdFIHwgXAotCQkJICAgICBJOTE1X0JPX0FMTE9DX0NQ VV9DTEVBUikKLSNkZWZpbmUgSTkxNV9CT19SRUFET05MWSAgICAgICAgIEJJVCg0KQotI2RlZmlu ZSBJOTE1X1RJTElOR19RVUlSS19CSVQgICAgNSAvKiB1bmtub3duIHN3aXp6bGluZzsgZG8gbm90 IHJlbGVhc2UhICovCisJCQkgICAgIEk5MTVfQk9fQUxMT0NfQ1BVX0NMRUFSIHwgXAorCQkJICAg ICBJOTE1X0JPX0FMTE9DX1VTRVIpCisjZGVmaW5lIEk5MTVfQk9fUkVBRE9OTFkgICAgICAgICBC SVQoNSkKKyNkZWZpbmUgSTkxNV9USUxJTkdfUVVJUktfQklUICAgIDYgLyogdW5rbm93biBzd2l6 emxpbmc7IGRvIG5vdCByZWxlYXNlISAqLwogCiAJLyoKIAkgKiBJcyB0aGUgb2JqZWN0IHRvIGJl IG1hcHBlZCBhcyByZWFkLW9ubHkgdG8gdGhlIEdQVQpAQCAtMzEwLDYgKzMyNiwxMSBAQCBzdHJ1 Y3QgZHJtX2k5MTVfZ2VtX29iamVjdCB7CiAJCWJvb2wgZGlydHk6MTsKIAl9IG1tOwogCisJc3Ry dWN0IHsKKwkJc3RydWN0IHNnX3RhYmxlICpjYWNoZWRfaW9fc3Q7CisJCWJvb2wgY3JlYXRlZDox OworCX0gdHRtOworCiAJLyoqIFJlY29yZCBvZiBhZGRyZXNzIGJpdCAxNyBvZiBlYWNoIHBhZ2Ug YXQgbGFzdCB1bmJpbmQuICovCiAJdW5zaWduZWQgbG9uZyAqYml0XzE3OwogCmRpZmYgLS1naXQg YS9kcml2ZXJzL2dwdS9kcm0vaTkxNS9nZW0vaTkxNV9nZW1fcmVnaW9uLmMgYi9kcml2ZXJzL2dw dS9kcm0vaTkxNS9nZW0vaTkxNV9nZW1fcmVnaW9uLmMKaW5kZXggZjI1ZTY2NDZjNWI3Li5kMWYx ODQwNTQwZGQgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2dlbS9pOTE1X2dlbV9y ZWdpb24uYworKysgYi9kcml2ZXJzL2dwdS9kcm0vaTkxNS9nZW0vaTkxNV9nZW1fcmVnaW9uLmMK QEAgLTE4LDExICsxOCw3IEBAIHZvaWQgaTkxNV9nZW1fb2JqZWN0X2luaXRfbWVtb3J5X3JlZ2lv bihzdHJ1Y3QgZHJtX2k5MTVfZ2VtX29iamVjdCAqb2JqLAogCiAJbXV0ZXhfbG9jaygmbWVtLT5v YmplY3RzLmxvY2spOwogCi0JaWYgKG9iai0+ZmxhZ3MgJiBJOTE1X0JPX0FMTE9DX1ZPTEFUSUxF KQotCQlsaXN0X2FkZCgmb2JqLT5tbS5yZWdpb25fbGluaywgJm1lbS0+b2JqZWN0cy5wdXJnZWFi bGUpOwotCWVsc2UKLQkJbGlzdF9hZGQoJm9iai0+bW0ucmVnaW9uX2xpbmssICZtZW0tPm9iamVj dHMubGlzdCk7Ci0KKwlsaXN0X2FkZCgmb2JqLT5tbS5yZWdpb25fbGluaywgJm1lbS0+b2JqZWN0 cy5saXN0KTsKIAltdXRleF91bmxvY2soJm1lbS0+b2JqZWN0cy5sb2NrKTsKIH0KIApkaWZmIC0t Z2l0IGEvZHJpdmVycy9ncHUvZHJtL2k5MTUvZ2VtL2k5MTVfZ2VtX3R0bS5jIGIvZHJpdmVycy9n cHUvZHJtL2k5MTUvZ2VtL2k5MTVfZ2VtX3R0bS5jCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4 IDAwMDAwMDAwMDAwMC4uMjY5NWI4YzM3ZTEzCi0tLSAvZGV2L251bGwKKysrIGIvZHJpdmVycy9n cHUvZHJtL2k5MTUvZ2VtL2k5MTVfZ2VtX3R0bS5jCkBAIC0wLDAgKzEsNTQwIEBACisvLyBTUERY LUxpY2Vuc2UtSWRlbnRpZmllcjogTUlUCisvKgorICogQ29weXJpZ2h0IMKpIDIwMjEgSW50ZWwg Q29ycG9yYXRpb24KKyAqLworCisjaW5jbHVkZSA8ZHJtL3R0bS90dG1fYm9fZHJpdmVyLmg+Cisj aW5jbHVkZSA8ZHJtL3R0bS90dG1fcGxhY2VtZW50Lmg+CisKKyNpbmNsdWRlICJpOTE1X2Rydi5o IgorI2luY2x1ZGUgImludGVsX21lbW9yeV9yZWdpb24uaCIKKyNpbmNsdWRlICJpbnRlbF9yZWdp b25fdHRtLmgiCisKKyNpbmNsdWRlICJnZW0vaTkxNV9nZW1fb2JqZWN0LmgiCisjaW5jbHVkZSAi Z2VtL2k5MTVfZ2VtX3JlZ2lvbi5oIgorI2luY2x1ZGUgImdlbS9pOTE1X2dlbV90dG0uaCIKKwor I2RlZmluZSBJOTE1X1BMX0xNRU0wIFRUTV9QTF9QUklWCisjZGVmaW5lIEk5MTVfUExfU1lTVEVN IFRUTV9QTF9TWVNURU0KKyNkZWZpbmUgSTkxNV9QTF9TVE9MRU4gVFRNX1BMX1ZSQU0KKyNkZWZp bmUgSTkxNV9QTF9HR1RUIFRUTV9QTF9UVAorCisjZGVmaW5lIEk5MTVfVFRNX1BSSU9fUFVSR0Ug ICAgIDAKKyNkZWZpbmUgSTkxNV9UVE1fUFJJT19OT19QQUdFUyAgMQorI2RlZmluZSBJOTE1X1RU TV9QUklPX0hBU19QQUdFUyAyCisKKy8qKgorICogc3RydWN0IGk5MTVfdHRtX3R0IC0gVFRNIHBh Z2UgdmVjdG9yIHdpdGggYWRkaXRpb25hbCBwcml2YXRlIGluZm9ybWF0aW9uCisgKiBAdHRtOiBU aGUgYmFzZSBUVE0gcGFnZSB2ZWN0b3IuCisgKiBAZGV2OiBUaGUgc3RydWN0IGRldmljZSB1c2Vk IGZvciBkbWEgbWFwcGluZyBhbmQgdW5tYXBwaW5nLgorICogQGNhY2hlZF9zdDogVGhlIGNhY2hl ZCBzY2F0dGVyLWdhdGhlciB0YWJsZS4KKyAqCisgKiBOb3RlIHRoYXQgRE1BIG1heSBiZSBnb2lu ZyBvbiByaWdodCB1cCB0byB0aGUgcG9pbnQgd2hlcmUgdGhlIHBhZ2UtCisgKiB2ZWN0b3IgaXMg dW5wb3B1bGF0ZWQgaW4gZGVsYXllZCBkZXN0cm95LiBIZW5jZSBrZWVwIHRoZQorICogc2NhdHRl ci1nYXRoZXIgdGFibGUgbWFwcGVkIGFuZCBjYWNoZWQgdXAgdG8gdGhhdCBwb2ludC4gVGhpcyBp cworICogZGlmZmVyZW50IGZyb20gdGhlIGNhY2hlZCBnZW0gb2JqZWN0IGlvIHNjYXR0ZXItZ2F0 aGVyIHRhYmxlIHdoaWNoCisgKiBkb2Vzbid0IGhhdmUgYW4gYXNzb2NpYXRlZCBkbWEgbWFwcGlu Zy4KKyAqLworc3RydWN0IGk5MTVfdHRtX3R0IHsKKwlzdHJ1Y3QgdHRtX3R0IHR0bTsKKwlzdHJ1 Y3QgZGV2aWNlICpkZXY7CisJc3RydWN0IHNnX3RhYmxlICpjYWNoZWRfc3Q7Cit9OworCitzdGF0 aWMgY29uc3Qgc3RydWN0IHR0bV9wbGFjZSBsbWVtMF9zeXNfcGxhY2VtZW50X2ZsYWdzW10gPSB7 CisJeworCQkuZnBmbiA9IDAsCisJCS5scGZuID0gMCwKKwkJLm1lbV90eXBlID0gSTkxNV9QTF9M TUVNMCwKKwkJLmZsYWdzID0gMCwKKwl9LCB7CisJCS5mcGZuID0gMCwKKwkJLmxwZm4gPSAwLAor CQkubWVtX3R5cGUgPSBJOTE1X1BMX1NZU1RFTSwKKwkJLmZsYWdzID0gMCwKKwl9Cit9OworCitz dGF0aWMgc3RydWN0IHR0bV9wbGFjZW1lbnQgaTkxNV9sbWVtMF9wbGFjZW1lbnQgPSB7CisJLm51 bV9wbGFjZW1lbnQgPSAxLAorCS5wbGFjZW1lbnQgPSAmbG1lbTBfc3lzX3BsYWNlbWVudF9mbGFn c1swXSwKKwkubnVtX2J1c3lfcGxhY2VtZW50ID0gMSwKKwkuYnVzeV9wbGFjZW1lbnQgPSAmbG1l bTBfc3lzX3BsYWNlbWVudF9mbGFnc1swXSwKK307CisKK3N0YXRpYyBzdHJ1Y3QgdHRtX3BsYWNl bWVudCBpOTE1X3N5c19wbGFjZW1lbnQgPSB7CisJLm51bV9wbGFjZW1lbnQgPSAxLAorCS5wbGFj ZW1lbnQgPSAmbG1lbTBfc3lzX3BsYWNlbWVudF9mbGFnc1sxXSwKKwkubnVtX2J1c3lfcGxhY2Vt ZW50ID0gMSwKKwkuYnVzeV9wbGFjZW1lbnQgPSAmbG1lbTBfc3lzX3BsYWNlbWVudF9mbGFnc1sx XSwKK307CisKK3N0YXRpYyB2b2lkIGk5MTVfdHRtX2FkanVzdF9scnUoc3RydWN0IGRybV9pOTE1 X2dlbV9vYmplY3QgKm9iaik7CisKK3N0YXRpYyBzdHJ1Y3QgdHRtX3R0ICppOTE1X3R0bV90dF9j cmVhdGUoc3RydWN0IHR0bV9idWZmZXJfb2JqZWN0ICpibywKKwkJCQkJIHVpbnQzMl90IHBhZ2Vf ZmxhZ3MpCit7CisJc3RydWN0IHR0bV9yZXNvdXJjZV9tYW5hZ2VyICptYW4gPQorCQl0dG1fbWFu YWdlcl90eXBlKGJvLT5iZGV2LCBiby0+cmVzb3VyY2UtPm1lbV90eXBlKTsKKwlzdHJ1Y3QgZHJt X2k5MTVfZ2VtX29iamVjdCAqb2JqID0gaTkxNV90dG1fdG9fZ2VtKGJvKTsKKwlzdHJ1Y3QgaTkx NV90dG1fdHQgKmk5MTVfdHQ7CisJaW50IHJldDsKKworCWk5MTVfdHQgPSBremFsbG9jKHNpemVv ZigqaTkxNV90dCksIEdGUF9LRVJORUwpOworCWlmICghaTkxNV90dCkKKwkJcmV0dXJuIE5VTEw7 CisKKwlpZiAob2JqLT5mbGFncyAmIEk5MTVfQk9fQUxMT0NfQ1BVX0NMRUFSICYmCisJICAgIG1h bi0+dXNlX3R0KQorCQlwYWdlX2ZsYWdzIHw9IFRUTV9QQUdFX0ZMQUdfWkVST19BTExPQzsKKwor CXJldCA9IHR0bV90dF9pbml0KCZpOTE1X3R0LT50dG0sIGJvLCBwYWdlX2ZsYWdzLCB0dG1fd3Jp dGVfY29tYmluZWQpOworCWlmIChyZXQpIHsKKwkJa2ZyZWUoaTkxNV90dCk7CisJCXJldHVybiBO VUxMOworCX0KKworCWk5MTVfdHQtPmRldiA9IG9iai0+YmFzZS5kZXYtPmRldjsKKworCXJldHVy biAmaTkxNV90dC0+dHRtOworfQorCitzdGF0aWMgdm9pZCBpOTE1X3R0bV90dF91bnBvcHVsYXRl KHN0cnVjdCB0dG1fZGV2aWNlICpiZGV2LCBzdHJ1Y3QgdHRtX3R0ICp0dG0pCit7CisJc3RydWN0 IGk5MTVfdHRtX3R0ICppOTE1X3R0ID0gY29udGFpbmVyX29mKHR0bSwgdHlwZW9mKCppOTE1X3R0 KSwgdHRtKTsKKworCWlmIChpOTE1X3R0LT5jYWNoZWRfc3QpIHsKKwkJZG1hX3VubWFwX3NndGFi bGUoaTkxNV90dC0+ZGV2LCBpOTE1X3R0LT5jYWNoZWRfc3QsCisJCQkJICBETUFfQklESVJFQ1RJ T05BTCwgMCk7CisJCXNnX2ZyZWVfdGFibGUoaTkxNV90dC0+Y2FjaGVkX3N0KTsKKwkJa2ZyZWUo aTkxNV90dC0+Y2FjaGVkX3N0KTsKKwkJaTkxNV90dC0+Y2FjaGVkX3N0ID0gTlVMTDsKKwl9CisJ dHRtX3Bvb2xfZnJlZSgmYmRldi0+cG9vbCwgdHRtKTsKK30KKworc3RhdGljIHZvaWQgaTkxNV90 dG1fdHRfZGVzdHJveShzdHJ1Y3QgdHRtX2RldmljZSAqYmRldiwgc3RydWN0IHR0bV90dCAqdHRt KQoreworCXN0cnVjdCBpOTE1X3R0bV90dCAqaTkxNV90dCA9IGNvbnRhaW5lcl9vZih0dG0sIHR5 cGVvZigqaTkxNV90dCksIHR0bSk7CisKKwl0dG1fdHRfZGVzdHJveV9jb21tb24oYmRldiwgdHRt KTsKKwlrZnJlZShpOTE1X3R0KTsKK30KKworc3RhdGljIGJvb2wgaTkxNV90dG1fZXZpY3Rpb25f dmFsdWFibGUoc3RydWN0IHR0bV9idWZmZXJfb2JqZWN0ICpibywKKwkJCQkgICAgICAgY29uc3Qg c3RydWN0IHR0bV9wbGFjZSAqcGxhY2UpCit7CisJc3RydWN0IGRybV9pOTE1X2dlbV9vYmplY3Qg Km9iaiA9IGk5MTVfdHRtX3RvX2dlbShibyk7CisKKwkvKiBXaWxsIGRvIGZvciBub3cuIE91ciBw aW5uZWQgb2JqZWN0cyBhcmUgc3RpbGwgb24gVFRNJ3MgTFJVIGxpc3RzICovCisJaWYgKCFpOTE1 X2dlbV9vYmplY3RfZXZpY3RhYmxlKG9iaikpCisJCXJldHVybiBmYWxzZTsKKworCS8qIFRoaXMg aXNuJ3QgdmFsaWQgd2l0aCBhIGJ1ZGR5IGFsbG9jYXRvciAqLworCXJldHVybiB0dG1fYm9fZXZp Y3Rpb25fdmFsdWFibGUoYm8sIHBsYWNlKTsKK30KKworc3RhdGljIHZvaWQgaTkxNV90dG1fZXZp Y3RfZmxhZ3Moc3RydWN0IHR0bV9idWZmZXJfb2JqZWN0ICpibywKKwkJCQkgc3RydWN0IHR0bV9w bGFjZW1lbnQgKnBsYWNlbWVudCkKK3sKKwkqcGxhY2VtZW50ID0gaTkxNV9zeXNfcGxhY2VtZW50 OworfQorCitzdGF0aWMgaW50IGk5MTVfdHRtX21vdmVfbm90aWZ5KHN0cnVjdCB0dG1fYnVmZmVy X29iamVjdCAqYm8pCit7CisJc3RydWN0IGRybV9pOTE1X2dlbV9vYmplY3QgKm9iaiA9IGk5MTVf dHRtX3RvX2dlbShibyk7CisJaW50IHJldDsKKworCXJldCA9IGk5MTVfZ2VtX29iamVjdF91bmJp bmQob2JqLCBJOTE1X0dFTV9PQkpFQ1RfVU5CSU5EX0FDVElWRSk7CisJaWYgKHJldCkKKwkJcmV0 dXJuIHJldDsKKworCXJldCA9IF9faTkxNV9nZW1fb2JqZWN0X3B1dF9wYWdlcyhvYmopOworCWlm IChyZXQpCisJCXJldHVybiByZXQ7CisKKwlyZXR1cm4gMDsKK30KKworc3RhdGljIHZvaWQgaTkx NV90dG1fZnJlZV9jYWNoZWRfaW9fc3Qoc3RydWN0IGRybV9pOTE1X2dlbV9vYmplY3QgKm9iaikK K3sKKwlpZiAob2JqLT50dG0uY2FjaGVkX2lvX3N0KSB7CisJCXNnX2ZyZWVfdGFibGUob2JqLT50 dG0uY2FjaGVkX2lvX3N0KTsKKwkJa2ZyZWUob2JqLT50dG0uY2FjaGVkX2lvX3N0KTsKKwkJb2Jq LT50dG0uY2FjaGVkX2lvX3N0ID0gTlVMTDsKKwl9Cit9CisKK3N0YXRpYyB2b2lkIGk5MTVfdHRt X3B1cmdlKHN0cnVjdCBkcm1faTkxNV9nZW1fb2JqZWN0ICpvYmopCit7CisJc3RydWN0IHR0bV9i dWZmZXJfb2JqZWN0ICpibyA9IGk5MTVfZ2VtX3RvX3R0bShvYmopOworCXN0cnVjdCB0dG1fb3Bl cmF0aW9uX2N0eCBjdHggPSB7CisJCS5pbnRlcnJ1cHRpYmxlID0gdHJ1ZSwKKwkJLm5vX3dhaXRf Z3B1ID0gZmFsc2UsCisJfTsKKwlzdHJ1Y3QgdHRtX3BsYWNlbWVudCBwbGFjZSA9IHt9OworCWlu dCByZXQ7CisKKwlpZiAob2JqLT5tbS5tYWR2ID09IF9fSTkxNV9NQURWX1BVUkdFRCkKKwkJcmV0 dXJuOworCisJLyogVFRNJ3MgcHVyZ2UgaW50ZXJmYWNlLiBOb3RlIHRoYXQgd2UgbWlnaHQgYmUg cmVlbnRlcmluZy4gKi8KKwlyZXQgPSB0dG1fYm9fdmFsaWRhdGUoYm8sICZwbGFjZSwgJmN0eCk7 CisKKwlpZiAoIXJldCkgeworCQlpOTE1X3R0bV9mcmVlX2NhY2hlZF9pb19zdChvYmopOworCQlv YmotPm1tLm1hZHYgPSBfX0k5MTVfTUFEVl9QVVJHRUQ7CisJfQorfQorCitzdGF0aWMgdm9pZCBp OTE1X3R0bV9zd2FwX25vdGlmeShzdHJ1Y3QgdHRtX2J1ZmZlcl9vYmplY3QgKmJvKQoreworCXN0 cnVjdCBkcm1faTkxNV9nZW1fb2JqZWN0ICpvYmogPSBpOTE1X3R0bV90b19nZW0oYm8pOworCWlu dCByZXQgPSBpOTE1X3R0bV9tb3ZlX25vdGlmeShibyk7CisKKwlHRU1fV0FSTl9PTihyZXQpOwor CUdFTV9XQVJOX09OKG9iai0+dHRtLmNhY2hlZF9pb19zdCk7CisJaWYgKCFyZXQgJiYgb2JqLT5t bS5tYWR2ICE9IEk5MTVfTUFEVl9XSUxMTkVFRCkKKwkJaTkxNV90dG1fcHVyZ2Uob2JqKTsKK30K Kworc3RhdGljIHZvaWQgaTkxNV90dG1fZGVsZXRlX21lbV9ub3RpZnkoc3RydWN0IHR0bV9idWZm ZXJfb2JqZWN0ICpibykKK3sKKwlzdHJ1Y3QgZHJtX2k5MTVfZ2VtX29iamVjdCAqb2JqID0gaTkx NV90dG1fdG9fZ2VtKGJvKTsKKworCWlmIChsaWtlbHkob2JqKSkgeworCQkvKiBUaGlzIHJlbGVh c2VzIGFsbCBnZW0gb2JqZWN0IGJpbmRpbmdzIHRvIHRoZSBiYWNrZW5kLiAqLworCQlfX2k5MTVf Z2VtX2ZyZWVfb2JqZWN0KG9iaik7CisJfQorfQorCitzdGF0aWMgc3RydWN0IGludGVsX21lbW9y eV9yZWdpb24gKgoraTkxNV90dG1fcmVnaW9uKHN0cnVjdCB0dG1fZGV2aWNlICpiZGV2LCBpbnQg dHRtX21lbV90eXBlKQoreworCXN0cnVjdCBkcm1faTkxNV9wcml2YXRlICppOTE1ID0gY29udGFp bmVyX29mKGJkZXYsIHR5cGVvZigqaTkxNSksIGJkZXYpOworCisJLyogVGhlcmUncyBzb21lIHJv b20gZm9yIG9wdGltaXphdGlvbiBoZXJlLi4uICovCisJR0VNX0JVR19PTih0dG1fbWVtX3R5cGUg IT0gSTkxNV9QTF9TWVNURU0gJiYKKwkJICAgdHRtX21lbV90eXBlIDwgSTkxNV9QTF9MTUVNMCk7 CisJaWYgKHR0bV9tZW1fdHlwZSA9PSBJOTE1X1BMX1NZU1RFTSkKKwkJcmV0dXJuIGludGVsX21l bW9yeV9yZWdpb25fbG9va3VwKGk5MTUsIElOVEVMX01FTU9SWV9TWVNURU0sCisJCQkJCQkgIDAp OworCisJcmV0dXJuIGludGVsX21lbW9yeV9yZWdpb25fbG9va3VwKGk5MTUsIElOVEVMX01FTU9S WV9MT0NBTCwKKwkJCQkJICB0dG1fbWVtX3R5cGUgLSBJOTE1X1BMX0xNRU0wKTsKK30KKworc3Rh dGljIHN0cnVjdCBzZ190YWJsZSAqaTkxNV90dG1fdHRfZ2V0X3N0KHN0cnVjdCB0dG1fdHQgKnR0 bSkKK3sKKwlzdHJ1Y3QgaTkxNV90dG1fdHQgKmk5MTVfdHQgPSBjb250YWluZXJfb2YodHRtLCB0 eXBlb2YoKmk5MTVfdHQpLCB0dG0pOworCXN0cnVjdCBzY2F0dGVybGlzdCAqc2c7CisJc3RydWN0 IHNnX3RhYmxlICpzdDsKKwlpbnQgcmV0OworCisJaWYgKGk5MTVfdHQtPmNhY2hlZF9zdCkKKwkJ cmV0dXJuIGk5MTVfdHQtPmNhY2hlZF9zdDsKKworCXN0ID0ga3phbGxvYyhzaXplb2YoKnN0KSwg R0ZQX0tFUk5FTCk7CisJaWYgKCFzdCkKKwkJcmV0dXJuIEVSUl9QVFIoLUVOT01FTSk7CisKKwlz ZyA9IF9fc2dfYWxsb2NfdGFibGVfZnJvbV9wYWdlcworCQkoc3QsIHR0bS0+cGFnZXMsIHR0bS0+ bnVtX3BhZ2VzLCAwLAorCQkgKHVuc2lnbmVkIGxvbmcpdHRtLT5udW1fcGFnZXMgPDwgUEFHRV9T SElGVCwKKwkJIGk5MTVfc2dfc2VnbWVudF9zaXplKCksIE5VTEwsIDAsIEdGUF9LRVJORUwpOwor CWlmIChJU19FUlIoc2cpKSB7CisJCWtmcmVlKHN0KTsKKwkJcmV0dXJuIEVSUl9DQVNUKHNnKTsK Kwl9CisKKwlyZXQgPSBkbWFfbWFwX3NndGFibGUoaTkxNV90dC0+ZGV2LCBzdCwgRE1BX0JJRElS RUNUSU9OQUwsIDApOworCWlmIChyZXQpIHsKKwkJc2dfZnJlZV90YWJsZShzdCk7CisJCWtmcmVl KHN0KTsKKwkJcmV0dXJuIEVSUl9QVFIocmV0KTsKKwl9CisKKwlpOTE1X3R0LT5jYWNoZWRfc3Qg PSBzdDsKKwlyZXR1cm4gc3Q7Cit9CisKK3N0YXRpYyBzdHJ1Y3Qgc2dfdGFibGUgKgoraTkxNV90 dG1fcmVzb3VyY2VfZ2V0X3N0KHN0cnVjdCBkcm1faTkxNV9nZW1fb2JqZWN0ICpvYmosCisJCQkg c3RydWN0IHR0bV9yZXNvdXJjZSAqcmVzKQoreworCXN0cnVjdCB0dG1fYnVmZmVyX29iamVjdCAq Ym8gPSBpOTE1X2dlbV90b190dG0ob2JqKTsKKwlzdHJ1Y3QgdHRtX3Jlc291cmNlX21hbmFnZXIg Km1hbiA9CisJCXR0bV9tYW5hZ2VyX3R5cGUoYm8tPmJkZXYsIHJlcy0+bWVtX3R5cGUpOworCisJ aWYgKG1hbi0+dXNlX3R0KQorCQlyZXR1cm4gaTkxNV90dG1fdHRfZ2V0X3N0KGJvLT50dG0pOwor CisJcmV0dXJuIGludGVsX3JlZ2lvbl90dG1fbm9kZV90b19zdChvYmotPm1tLnJlZ2lvbiwgcmVz KTsKK30KKworc3RhdGljIGludCBpOTE1X3R0bV9tb3ZlKHN0cnVjdCB0dG1fYnVmZmVyX29iamVj dCAqYm8sIGJvb2wgZXZpY3QsCisJCQkgc3RydWN0IHR0bV9vcGVyYXRpb25fY3R4ICpjdHgsCisJ CQkgc3RydWN0IHR0bV9yZXNvdXJjZSAqZHN0X21lbSwKKwkJCSBzdHJ1Y3QgdHRtX3BsYWNlICpo b3ApCit7CisJc3RydWN0IGRybV9pOTE1X2dlbV9vYmplY3QgKm9iaiA9IGk5MTVfdHRtX3RvX2dl bShibyk7CisJc3RydWN0IHR0bV9yZXNvdXJjZV9tYW5hZ2VyICpkc3RfbWFuID0KKwkJdHRtX21h bmFnZXJfdHlwZShiby0+YmRldiwgZHN0X21lbS0+bWVtX3R5cGUpOworCXN0cnVjdCB0dG1fcmVz b3VyY2VfbWFuYWdlciAqc3JjX21hbiA9CisJCXR0bV9tYW5hZ2VyX3R5cGUoYm8tPmJkZXYsIGJv LT5yZXNvdXJjZS0+bWVtX3R5cGUpOworCXN0cnVjdCBpbnRlbF9tZW1vcnlfcmVnaW9uICpkc3Rf cmVnLCAqc3JjX3JlZzsKKwl1bmlvbiB7CisJCXN0cnVjdCB0dG1fa21hcF9pdGVyX3R0IHR0Owor CQlzdHJ1Y3QgdHRtX2ttYXBfaXRlcl9pb21hcCBpbzsKKwl9IF9kc3RfaXRlciwgX3NyY19pdGVy OworCXN0cnVjdCB0dG1fa21hcF9pdGVyICpkc3RfaXRlciwgKnNyY19pdGVyOworCXN0cnVjdCBz Z190YWJsZSAqZHN0X3N0OworCWludCByZXQ7CisKKwlkc3RfcmVnID0gaTkxNV90dG1fcmVnaW9u KGJvLT5iZGV2LCBkc3RfbWVtLT5tZW1fdHlwZSk7CisJc3JjX3JlZyA9IGk5MTVfdHRtX3JlZ2lv bihiby0+YmRldiwgYm8tPnJlc291cmNlLT5tZW1fdHlwZSk7CisJR0VNX0JVR19PTighZHN0X3Jl ZyB8fCAhc3JjX3JlZyk7CisKKwkvKiBTeW5jIGZvciBub3cuIFdlIGNvdWxkIGRvIHRoZSBhY3R1 YWwgY29weSBhc3luYy4gKi8KKwlyZXQgPSB0dG1fYm9fd2FpdF9jdHgoYm8sIGN0eCk7CisJaWYg KHJldCkKKwkJcmV0dXJuIHJldDsKKworCXJldCA9IGk5MTVfdHRtX21vdmVfbm90aWZ5KGJvKTsK KwlpZiAocmV0KQorCQlyZXR1cm4gcmV0OworCisJaWYgKG9iai0+bW0ubWFkdiAhPSBJOTE1X01B RFZfV0lMTE5FRUQpIHsKKwkJaTkxNV90dG1fcHVyZ2Uob2JqKTsKKwkJdHRtX3Jlc291cmNlX2Zy ZWUoYm8sICZkc3RfbWVtKTsKKwkJcmV0dXJuIDA7CisJfQorCisJLyogUG9wdWxhdGUgdHRtIHdp dGggcGFnZXMgaWYgbmVlZGVkLiBUeXBpY2FsbHkgc3lzdGVtIG1lbW9yeS4gKi8KKwlpZiAoYm8t PnR0bSAmJiAoZHN0X21hbi0+dXNlX3R0IHx8CisJCQkoYm8tPnR0bS0+cGFnZV9mbGFncyAmIFRU TV9QQUdFX0ZMQUdfU1dBUFBFRCkpKSB7CisJCXJldCA9IHR0bV90dF9wb3B1bGF0ZShiby0+YmRl diwgYm8tPnR0bSwgY3R4KTsKKwkJaWYgKHJldCkKKwkJCXJldHVybiByZXQ7CisJfQorCisJZHN0 X3N0ID0gaTkxNV90dG1fcmVzb3VyY2VfZ2V0X3N0KG9iaiwgZHN0X21lbSk7CisJaWYgKElTX0VS Uihkc3Rfc3QpKQorCQlyZXR1cm4gUFRSX0VSUihkc3Rfc3QpOworCisJLyogSWYgd2Ugc3RhcnQg bWFwcGluZyBHR1RULCB3ZSBjYW4gbm8gbG9uZ2VyIHVzZSBtYW46OnVzZV90dCBoZXJlLiAqLwor CWRzdF9pdGVyID0gZHN0X21hbi0+dXNlX3R0ID8KKwkJdHRtX2ttYXBfaXRlcl90dF9pbml0KCZf ZHN0X2l0ZXIudHQsIGJvLT50dG0pIDoKKwkJdHRtX2ttYXBfaXRlcl9pb21hcF9pbml0KCZfZHN0 X2l0ZXIuaW8sICZkc3RfcmVnLT5pb21hcCwKKwkJCQkJIGRzdF9zdCwgZHN0X3JlZy0+cmVnaW9u LnN0YXJ0KTsKKworCXNyY19pdGVyID0gc3JjX21hbi0+dXNlX3R0ID8KKwkJdHRtX2ttYXBfaXRl cl90dF9pbml0KCZfc3JjX2l0ZXIudHQsIGJvLT50dG0pIDoKKwkJdHRtX2ttYXBfaXRlcl9pb21h cF9pbml0KCZfc3JjX2l0ZXIuaW8sICZzcmNfcmVnLT5pb21hcCwKKwkJCQkJIG9iai0+dHRtLmNh Y2hlZF9pb19zdCwKKwkJCQkJIHNyY19yZWctPnJlZ2lvbi5zdGFydCk7CisKKwl0dG1fbW92ZV9t ZW1jcHkoYm8sIGRzdF9tZW0tPm51bV9wYWdlcywgZHN0X2l0ZXIsIHNyY19pdGVyKTsKKwl0dG1f Ym9fbW92ZV9zeW5jX2NsZWFudXAoYm8sIGRzdF9tZW0pOworCWk5MTVfdHRtX2ZyZWVfY2FjaGVk X2lvX3N0KG9iaik7CisKKwlpZiAoIWRzdF9tYW4tPnVzZV90dCkKKwkJb2JqLT50dG0uY2FjaGVk X2lvX3N0ID0gZHN0X3N0OworCisJcmV0dXJuIDA7Cit9CisKK3N0YXRpYyBzdHJ1Y3QgdHRtX2Rl dmljZV9mdW5jcyBpOTE1X3R0bV9ib19kcml2ZXIgPSB7CisJLnR0bV90dF9jcmVhdGUgPSBpOTE1 X3R0bV90dF9jcmVhdGUsCisJLnR0bV90dF91bnBvcHVsYXRlID0gaTkxNV90dG1fdHRfdW5wb3B1 bGF0ZSwKKwkudHRtX3R0X2Rlc3Ryb3kgPSBpOTE1X3R0bV90dF9kZXN0cm95LAorCS5ldmljdGlv bl92YWx1YWJsZSA9IGk5MTVfdHRtX2V2aWN0aW9uX3ZhbHVhYmxlLAorCS5ldmljdF9mbGFncyA9 IGk5MTVfdHRtX2V2aWN0X2ZsYWdzLAorCS5tb3ZlID0gaTkxNV90dG1fbW92ZSwKKwkuc3dhcF9u b3RpZnkgPSBpOTE1X3R0bV9zd2FwX25vdGlmeSwKKwkuZGVsZXRlX21lbV9ub3RpZnkgPSBpOTE1 X3R0bV9kZWxldGVfbWVtX25vdGlmeSwKK307CisKKy8qKgorICogaTkxNV90dG1fZHJpdmVyIC0g UmV0dXJuIGEgcG9pbnRlciB0byB0aGUgVFRNIGRldmljZSBmdW5jcworICoKKyAqIFJldHVybjog UG9pbnRlciB0byBzdGF0aWNhbGx5IGFsbG9jYXRlZCBUVE0gZGV2aWNlIGZ1bmNzLgorICovCitz dHJ1Y3QgdHRtX2RldmljZV9mdW5jcyAqaTkxNV90dG1fZHJpdmVyKHZvaWQpCit7CisJcmV0dXJu ICZpOTE1X3R0bV9ib19kcml2ZXI7Cit9CisKK3N0YXRpYyBpbnQgaTkxNV90dG1fZ2V0X3BhZ2Vz KHN0cnVjdCBkcm1faTkxNV9nZW1fb2JqZWN0ICpvYmopCit7CisJc3RydWN0IHR0bV9idWZmZXJf b2JqZWN0ICpibyA9IGk5MTVfZ2VtX3RvX3R0bShvYmopOworCXN0cnVjdCB0dG1fb3BlcmF0aW9u X2N0eCBjdHggPSB7CisJCS5pbnRlcnJ1cHRpYmxlID0gdHJ1ZSwKKwkJLm5vX3dhaXRfZ3B1ID0g ZmFsc2UsCisJfTsKKwlzdHJ1Y3Qgc2dfdGFibGUgKnN0OworCWludCByZXQ7CisKKwkvKiBNb3Zl IHRvIHRoZSByZXF1ZXN0ZWQgcGxhY2VtZW50LiAqLworCXJldCA9IHR0bV9ib192YWxpZGF0ZShi bywgJmk5MTVfbG1lbTBfcGxhY2VtZW50LCAmY3R4KTsKKwlpZiAocmV0KQorCQlyZXR1cm4gcmV0 ID09IC1FTk9TUEMgPyAtRU5YSU8gOiByZXQ7CisKKwkvKiBPYmplY3QgZWl0aGVyIGhhcyBhIHBh Z2UgdmVjdG9yIG9yIGlzIGFuIGlvbWVtIG9iamVjdCAqLworCXN0ID0gYm8tPnR0bSA/IGk5MTVf dHRtX3R0X2dldF9zdChiby0+dHRtKSA6IG9iai0+dHRtLmNhY2hlZF9pb19zdDsKKwlpZiAoSVNf RVJSKHN0KSkKKwkJcmV0dXJuIFBUUl9FUlIoc3QpOworCisJX19pOTE1X2dlbV9vYmplY3Rfc2V0 X3BhZ2VzKG9iaiwgc3QsIGk5MTVfc2dfZG1hX3NpemVzKHN0LT5zZ2wpKTsKKworCWk5MTVfdHRt X2FkanVzdF9scnUob2JqKTsKKworCXJldHVybiByZXQ7Cit9CisKK3N0YXRpYyB2b2lkIGk5MTVf dHRtX3B1dF9wYWdlcyhzdHJ1Y3QgZHJtX2k5MTVfZ2VtX29iamVjdCAqb2JqLAorCQkJICAgICAg IHN0cnVjdCBzZ190YWJsZSAqc3QpCit7CisJLyoKKwkgKiBXZSdyZSBjdXJyZW50bHkgbm90IGNh bGxlZCBmcm9tIGEgc2hyaW5rZXIsIHNvIHB1dF9wYWdlcygpCisJICogdHlwaWNhbGx5IG1lYW5z IHRoZSBvYmplY3QgaXMgYWJvdXQgdG8gZGVzdHJveWVkLCBvciBjYWxsZWQKKwkgKiBmcm9tIG1v dmVfbm90aWZ5KCkuIFNvIGp1c3QgYXZvaWQgZG9pbmcgbXVjaCBmb3Igbm93LgorCSAqIElmIHRo ZSBvYmplY3QgaXMgbm90IGRlc3Ryb3llZCBuZXh0LCBUaGUgVFRNIGV2aWN0aW9uIGxvZ2ljCisJ ICogYW5kIHNocmlua2VycyB3aWxsIG1vdmUgaXQgb3V0IGlmIG5lZWRlZC4KKwkgKi8KKworCWk5 MTVfdHRtX2FkanVzdF9scnUob2JqKTsKK30KKworc3RhdGljIHZvaWQgaTkxNV90dG1fYWRqdXN0 X2xydShzdHJ1Y3QgZHJtX2k5MTVfZ2VtX29iamVjdCAqb2JqKQoreworCXN0cnVjdCB0dG1fYnVm ZmVyX29iamVjdCAqYm8gPSBpOTE1X2dlbV90b190dG0ob2JqKTsKKworCS8qCisJICogRG9uJ3Qg bWFuaXB1bGF0ZSB0aGUgVFRNIExSVXMgd2hpbGUgaW4gVFRNIGJvIGRlc3RydWN0aW9uLgorCSAq IFdlJ3JlIGNhbGxlZCB0aHJvdWdoIGk5MTVfdHRtX2RlbGV0ZV9tZW1fbm90aWZ5KCkuCisJICov CisJaWYgKCFrcmVmX3JlYWQoJmJvLT5rcmVmKSkKKwkJcmV0dXJuOworCisJLyoKKwkgKiBQdXQg b24gdGhlIGNvcnJlY3QgTFJVIGxpc3QgZGVwZW5kaW5nIG9uIHRoZSBNQURWIHN0YXR1cworCSAq LworCXNwaW5fbG9jaygmYm8tPmJkZXYtPmxydV9sb2NrKTsKKwlpZiAob2JqLT5tbS5tYWR2ICE9 IEk5MTVfTUFEVl9XSUxMTkVFRCkgeworCQliby0+cHJpb3JpdHkgPSBJOTE1X1RUTV9QUklPX1BV UkdFOworCX0gZWxzZSBpZiAoIWk5MTVfZ2VtX29iamVjdF9oYXNfcGFnZXMob2JqKSkgeworCQlp ZiAoYm8tPnByaW9yaXR5IDwgSTkxNV9UVE1fUFJJT19IQVNfUEFHRVMpCisJCQliby0+cHJpb3Jp dHkgPSBJOTE1X1RUTV9QUklPX0hBU19QQUdFUzsKKwl9IGVsc2UgeworCQlpZiAoYm8tPnByaW9y aXR5ID4gSTkxNV9UVE1fUFJJT19OT19QQUdFUykKKwkJCWJvLT5wcmlvcml0eSA9IEk5MTVfVFRN X1BSSU9fTk9fUEFHRVM7CisJfQorCisJdHRtX2JvX21vdmVfdG9fbHJ1X3RhaWwoYm8sIGJvLT5y ZXNvdXJjZSwgTlVMTCk7CisJc3Bpbl91bmxvY2soJmJvLT5iZGV2LT5scnVfbG9jayk7Cit9CisK Ky8qCisgKiBUVE0tYmFja2VkIGdlbSBvYmplY3QgZGVzdHJ1Y3Rpb24gcmVxdWlyZXMgc29tZSBj bGFyaWZpY2F0aW9uLgorICogQmFzaWNhbGx5IHdlIGhhdmUgdHdvIHBvc3NpYmlsaXRpZXMgaGVy ZS4gV2UgY2FuIGVpdGhlciByZWx5IG9uIHRoZQorICogaTkxNSBkZWxheWVkIGRlc3RydWN0aW9u IGFuZCBwdXQgdGhlIFRUTSBvYmplY3Qgd2hlbiB0aGUgb2JqZWN0CisgKiBpcyBpZGxlLiBUaGlz IHdvdWxkIGJlIGRldGVjdGVkIGJ5IFRUTSB3aGljaCB3b3VsZCBieXBhc3MgdGhlCisgKiBUVE0g ZGVsYXllZCBkZXN0cm95IGhhbmRsaW5nLiBUaGUgb3RoZXIgYXBwcm9hY2ggaXMgdG8gcHV0IHRo ZSBUVE0KKyAqIG9iamVjdCBlYXJseSBhbmQgcmVseSBvbiB0aGUgVFRNIGRlc3Ryb3llZCBoYW5k bGluZywgYW5kIHRoZW4gZnJlZQorICogdGhlIGxlZnRvdmVyIHBhcnRzIG9mIHRoZSBHRU0gb2Jq ZWN0IG9uY2UgVFRNJ3MgZGVzdHJveWVkIGxpc3QgaGFuZGxpbmcgaXMKKyAqIGNvbXBsZXRlLiBG b3Igbm93LCB3ZSByZWx5IG9uIHRoZSBsYXR0ZXIgZm9yIHR3byByZWFzb25zOgorICogYSkgVFRN IGNhbiBldmljdCBhbiBvYmplY3QgZXZlbiB3aGVuIGl0J3Mgb24gdGhlIGRlbGF5ZWQgZGVzdHJv eSBsaXN0LAorICogd2hpY2ggaW4gdGhlb3J5IGFsbG93cyBmb3IgY29tcGxldGUgZXZpY3Rpb24u CisgKiBiKSBUaGVyZSBpcyB3b3JrIGdvaW5nIG9uIGluIFRUTSB0byBhbGxvdyBmcmVlaW5nIGFu IG9iamVjdCBldmVuIHdoZW4KKyAqIGl0J3Mgbm90IGlkbGUsIGFuZCB1c2luZyB0aGUgVFRNIGRl c3Ryb3llZCBsaXN0IGhhbmRsaW5nIGNvdWxkIGhlbHAgdXMKKyAqIGJlbmVmaXQgZnJvbSB0aGF0 LgorICovCitzdGF0aWMgdm9pZCBpOTE1X3R0bV9kZWxheWVkX2ZyZWUoc3RydWN0IGRybV9pOTE1 X2dlbV9vYmplY3QgKm9iaikKK3sKKwlpZiAob2JqLT50dG0uY3JlYXRlZCkgeworCQl0dG1fYm9f cHV0KGk5MTVfZ2VtX3RvX3R0bShvYmopKTsKKwl9IGVsc2UgeworCQlfX2k5MTVfZ2VtX2ZyZWVf b2JqZWN0KG9iaik7CisJCWNhbGxfcmN1KCZvYmotPnJjdSwgX19pOTE1X2dlbV9mcmVlX29iamVj dF9yY3UpOworCX0KK30KKworc3RhdGljIGNvbnN0IHN0cnVjdCBkcm1faTkxNV9nZW1fb2JqZWN0 X29wcyBpOTE1X2dlbV90dG1fb2JqX29wcyA9IHsKKwkubmFtZSA9ICJpOTE1X2dlbV9vYmplY3Rf dHRtIiwKKwkuZmxhZ3MgPSBJOTE1X0dFTV9PQkpFQ1RfSEFTX0lPTUVNLAorCisJLmdldF9wYWdl cyA9IGk5MTVfdHRtX2dldF9wYWdlcywKKwkucHV0X3BhZ2VzID0gaTkxNV90dG1fcHV0X3BhZ2Vz LAorCS50cnVuY2F0ZSA9IGk5MTVfdHRtX3B1cmdlLAorCS5hZGp1c3RfbHJ1ID0gaTkxNV90dG1f YWRqdXN0X2xydSwKKwkuZGVsYXllZF9mcmVlID0gaTkxNV90dG1fZGVsYXllZF9mcmVlLAorfTsK Kwordm9pZCBpOTE1X3R0bV9ib19kZXN0cm95KHN0cnVjdCB0dG1fYnVmZmVyX29iamVjdCAqYm8p Cit7CisJc3RydWN0IGRybV9pOTE1X2dlbV9vYmplY3QgKm9iaiA9IGk5MTVfdHRtX3RvX2dlbShi byk7CisKKwlpOTE1X2dlbV9vYmplY3RfcmVsZWFzZV9tZW1vcnlfcmVnaW9uKG9iaik7CisJaWYg KG9iai0+dHRtLmNyZWF0ZWQpCisJCWNhbGxfcmN1KCZvYmotPnJjdSwgX19pOTE1X2dlbV9mcmVl X29iamVjdF9yY3UpOworfQorCisvKioKKyAqIF9faTkxNV9nZW1fdHRtX29iamVjdF9pbml0IC0g SW5pdGlhbGl6ZSBhIHR0bS1iYWNrZWQgaTkxNSBnZW0gb2JqZWN0CisgKiBAbWVtOiBUaGUgaW5p dGlhbCBtZW1vcnkgcmVnaW9uIGZvciB0aGUgb2JqZWN0LgorICogQG9iajogVGhlIGdlbSBvYmpl Y3QuCisgKiBAc2l6ZTogT2JqZWN0IHNpemUgaW4gYnl0ZXMuCisgKiBAZmxhZ3M6IGdlbSBvYmpl Y3QgZmxhZ3MuCisgKgorICogUmV0dXJuOiAwIG9uIHN1Y2Nlc3MsIG5lZ2F0aXZlIGVycm9yIGNv ZGUgb24gZmFpbHVyZS4KKyAqLworaW50IF9faTkxNV9nZW1fdHRtX29iamVjdF9pbml0KHN0cnVj dCBpbnRlbF9tZW1vcnlfcmVnaW9uICptZW0sCisJCQkgICAgICAgc3RydWN0IGRybV9pOTE1X2dl bV9vYmplY3QgKm9iaiwKKwkJCSAgICAgICByZXNvdXJjZV9zaXplX3Qgc2l6ZSwKKwkJCSAgICAg ICB1bnNpZ25lZCBpbnQgZmxhZ3MpCit7CisJc3RhdGljIHN0cnVjdCBsb2NrX2NsYXNzX2tleSBs b2NrX2NsYXNzOworCXN0cnVjdCBkcm1faTkxNV9wcml2YXRlICppOTE1ID0gbWVtLT5pOTE1Owor CWVudW0gdHRtX2JvX3R5cGUgYm9fdHlwZTsKKwlzaXplX3QgYWxpZ25tZW50ID0gMDsKKwlpbnQg cmV0OworCisJLyogQWRqdXN0IGFsaWdubWVudCB0byBHUFUtIGFuZCBDUFUgaHVnZSBwYWdlIHNp emVzLiAqLworCisJaWYgKG1lbS0+aXNfcmFuZ2VfbWFuYWdlcikgeworCQlpZiAoc2l6ZSA+PSBT Wl8xRykKKwkJCWFsaWdubWVudCA9IFNaXzFHID4+IFBBR0VfU0hJRlQ7CisJCWVsc2UgaWYgKHNp emUgPj0gU1pfMk0pCisJCQlhbGlnbm1lbnQgPSBTWl8yTSA+PiBQQUdFX1NISUZUOworCQllbHNl IGlmIChzaXplID49IFNaXzY0SykKKwkJCWFsaWdubWVudCA9IFNaXzY0SyA+PiBQQUdFX1NISUZU OworCX0KKworCWRybV9nZW1fcHJpdmF0ZV9vYmplY3RfaW5pdCgmaTkxNS0+ZHJtLCAmb2JqLT5i YXNlLCBzaXplKTsKKwlpOTE1X2dlbV9vYmplY3RfaW5pdChvYmosICZpOTE1X2dlbV90dG1fb2Jq X29wcywgJmxvY2tfY2xhc3MsIGZsYWdzKTsKKwlpOTE1X2dlbV9vYmplY3RfaW5pdF9tZW1vcnlf cmVnaW9uKG9iaiwgbWVtKTsKKwlpOTE1X2dlbV9vYmplY3RfbWFrZV91bnNocmlua2FibGUob2Jq KTsKKwlvYmotPnJlYWRfZG9tYWlucyA9IEk5MTVfR0VNX0RPTUFJTl9XQyB8IEk5MTVfR0VNX0RP TUFJTl9HVFQ7CisJaTkxNV9nZW1fb2JqZWN0X3NldF9jYWNoZV9jb2hlcmVuY3kob2JqLCBJOTE1 X0NBQ0hFX05PTkUpOworCisJYm9fdHlwZSA9IChvYmotPmZsYWdzICYgSTkxNV9CT19BTExPQ19V U0VSKSA/IHR0bV9ib190eXBlX2RldmljZSA6CisJCXR0bV9ib190eXBlX2tlcm5lbDsKKworCS8q CisJICogSWYgdGhpcyBmdW5jdGlvbiBmYWlscywgaXQgd2lsbCBjYWxsIHRoZSBkZXN0cnVjdG9y LCBidXQKKwkgKiBvdXIgY2FsbGVyIHN0aWxsIG93bnMgdGhlIG9iamVjdC4gU28gbm8gZnJlZWlu ZyBpbiB0aGUKKwkgKiBkZXN0cnVjdG9yIHVudGlsIG9iai0+dHRtLmNyZWF0ZWQgaXMgdHJ1ZS4K KwkgKiBTaW1pbGFybHksIGluIGRlbGF5ZWRfZGVzdHJveSwgd2UgY2FuJ3QgY2FsbCB0dG1fYm9f cHV0KCkKKwkgKiB1bnRpbCBzdWNjZXNzZnVsIGluaXRpYWxpemF0aW9uLgorCSAqLworCXJldCA9 IHR0bV9ib19pbml0KCZpOTE1LT5iZGV2LCBpOTE1X2dlbV90b190dG0ob2JqKSwgc2l6ZSwKKwkJ CSAgYm9fdHlwZSwgJmk5MTVfc3lzX3BsYWNlbWVudCwgYWxpZ25tZW50LAorCQkJICB0cnVlLCBO VUxMLCBOVUxMLCBpOTE1X3R0bV9ib19kZXN0cm95KTsKKworCWlmICghcmV0KQorCQlvYmotPnR0 bS5jcmVhdGVkID0gdHJ1ZTsKKworCS8qIGk5MTUgd2FudHMgLUVOWElPIHdoZW4gb3V0IG9mIG1l bW9yeSByZWdpb24gc3BhY2UuICovCisJcmV0dXJuIChyZXQgPT0gLUVOT1NQQykgPyAtRU5YSU8g OiByZXQ7Cit9CmRpZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9kcm0vaTkxNS9nZW0vaTkxNV9nZW1f dHRtLmggYi9kcml2ZXJzL2dwdS9kcm0vaTkxNS9nZW0vaTkxNV9nZW1fdHRtLmgKbmV3IGZpbGUg bW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwLi5iOGQzZGNiYjUwZGYKLS0tIC9kZXYvbnVs bAorKysgYi9kcml2ZXJzL2dwdS9kcm0vaTkxNS9nZW0vaTkxNV9nZW1fdHRtLmgKQEAgLTAsMCAr MSw0OCBAQAorLyogU1BEWC1MaWNlbnNlLUlkZW50aWZpZXI6IE1JVCAqLworLyoKKyAqIENvcHly aWdodCDCqSAyMDIxIEludGVsIENvcnBvcmF0aW9uCisgKi8KKyNpZm5kZWYgX0k5MTVfR0VNX1RU TV9IXworI2RlZmluZSBfSTkxNV9HRU1fVFRNX0hfCisKKyNpbmNsdWRlICJnZW0vaTkxNV9nZW1f b2JqZWN0X3R5cGVzLmgiCisKKy8qKgorICogaTkxNV9nZW1fdG9fdHRtIC0gQ29udmVydCBhIHN0 cnVjdCBkcm1faTkxNV9nZW1fb2JqZWN0IHRvIGEKKyAqIHN0cnVjdCB0dG1fYnVmZmVyX29iamVj dC4KKyAqIEBvYmo6IFBvaW50ZXIgdG8gdGhlIGdlbSBvYmplY3QuCisgKgorICogUmV0dXJuOiBQ b2ludGVyIHRvIHRoZSBlbWJlZGRlZCBzdHJ1Y3QgdHRtX2J1ZmZlcl9vYmplY3QuCisgKi8KK3N0 YXRpYyBpbmxpbmUgc3RydWN0IHR0bV9idWZmZXJfb2JqZWN0ICoKK2k5MTVfZ2VtX3RvX3R0bShz dHJ1Y3QgZHJtX2k5MTVfZ2VtX29iamVjdCAqb2JqKQoreworCXJldHVybiAmb2JqLT5fX2RvX25v dF9hY2Nlc3M7Cit9CisKKy8qCisgKiBpOTE1IHR0bSBnZW0gb2JqZWN0IGRlc3RydWN0b3IuIElu dGVybmFsIHVzZSBvbmx5LgorICovCit2b2lkIGk5MTVfdHRtX2JvX2Rlc3Ryb3koc3RydWN0IHR0 bV9idWZmZXJfb2JqZWN0ICpibyk7CisKKy8qKgorICogaTkxNV90dG1fdG9fZ2VtIC0gQ29udmVy dCBhIHN0cnVjdCB0dG1fYnVmZmVyX29iamVjdCB0byBhbiBlbWJlZGRpbmcKKyAqIHN0cnVjdCBk cm1faTkxNV9nZW1fb2JqZWN0LgorICoKKyAqIFJldHVybjogUG9pbnRlciB0byB0aGUgZW1iZWRk aW5nIHN0cnVjdCB0dG1fYnVmZmVyX29iamVjdCwgb3IgTlVMTAorICogaWYgdGhlIG9iamVjdCB3 YXMgbm90IGFuIGk5MTUgdHRtIG9iamVjdC4KKyAqLworc3RhdGljIGlubGluZSBzdHJ1Y3QgZHJt X2k5MTVfZ2VtX29iamVjdCAqCitpOTE1X3R0bV90b19nZW0oc3RydWN0IHR0bV9idWZmZXJfb2Jq ZWN0ICpibykKK3sKKwlpZiAoR0VNX1dBUk5fT04oYm8tPmRlc3Ryb3kgIT0gaTkxNV90dG1fYm9f ZGVzdHJveSkpCisJCXJldHVybiBOVUxMOworCisJcmV0dXJuIGNvbnRhaW5lcl9vZihibywgc3Ry dWN0IGRybV9pOTE1X2dlbV9vYmplY3QsIF9fZG9fbm90X2FjY2Vzcyk7Cit9CisKK2ludCBfX2k5 MTVfZ2VtX3R0bV9vYmplY3RfaW5pdChzdHJ1Y3QgaW50ZWxfbWVtb3J5X3JlZ2lvbiAqbWVtLAor CQkJICAgICAgIHN0cnVjdCBkcm1faTkxNV9nZW1fb2JqZWN0ICpvYmosCisJCQkgICAgICAgcmVz b3VyY2Vfc2l6ZV90IHNpemUsCisJCQkgICAgICAgdW5zaWduZWQgaW50IGZsYWdzKTsKKyNlbmRp ZgpkaWZmIC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJtL2k5MTUvZ3QvaW50ZWxfcmVnaW9uX2xtZW0u YyBiL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2d0L2ludGVsX3JlZ2lvbl9sbWVtLmMKaW5kZXggZjcz NjZiMDU0ZjhlLi40YWUxZjcxN2E5NGMgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvZ3B1L2RybS9pOTE1 L2d0L2ludGVsX3JlZ2lvbl9sbWVtLmMKKysrIGIvZHJpdmVycy9ncHUvZHJtL2k5MTUvZ3QvaW50 ZWxfcmVnaW9uX2xtZW0uYwpAQCAtOSw2ICs5LDcgQEAKICNpbmNsdWRlICJpbnRlbF9yZWdpb25f dHRtLmgiCiAjaW5jbHVkZSAiZ2VtL2k5MTVfZ2VtX2xtZW0uaCIKICNpbmNsdWRlICJnZW0vaTkx NV9nZW1fcmVnaW9uLmgiCisjaW5jbHVkZSAiZ2VtL2k5MTVfZ2VtX3R0bS5oIgogI2luY2x1ZGUg ImludGVsX3JlZ2lvbl9sbWVtLmgiCiAKIHN0YXRpYyBpbnQgaW5pdF9mYWtlX2xtZW1fYmFyKHN0 cnVjdCBpbnRlbF9tZW1vcnlfcmVnaW9uICptZW0pCkBAIC0xMDcsNyArMTA4LDcgQEAgcmVnaW9u X2xtZW1faW5pdChzdHJ1Y3QgaW50ZWxfbWVtb3J5X3JlZ2lvbiAqbWVtKQogc3RhdGljIGNvbnN0 IHN0cnVjdCBpbnRlbF9tZW1vcnlfcmVnaW9uX29wcyBpbnRlbF9yZWdpb25fbG1lbV9vcHMgPSB7 CiAJLmluaXQgPSByZWdpb25fbG1lbV9pbml0LAogCS5yZWxlYXNlID0gcmVnaW9uX2xtZW1fcmVs ZWFzZSwKLQkuaW5pdF9vYmplY3QgPSBfX2k5MTVfZ2VtX2xtZW1fb2JqZWN0X2luaXQsCisJLmlu aXRfb2JqZWN0ID0gX19pOTE1X2dlbV90dG1fb2JqZWN0X2luaXQsCiB9OwogCiBzdHJ1Y3QgaW50 ZWxfbWVtb3J5X3JlZ2lvbiAqCmRpZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9kcm0vaTkxNS9pOTE1 X2dlbS5jIGIvZHJpdmVycy9ncHUvZHJtL2k5MTUvaTkxNV9nZW0uYwppbmRleCA1ODkzODhkZWM0 OGEuLjZhMGEzZjBlMzZlMSAxMDA2NDQKLS0tIGEvZHJpdmVycy9ncHUvZHJtL2k5MTUvaTkxNV9n ZW0uYworKysgYi9kcml2ZXJzL2dwdS9kcm0vaTkxNS9pOTE1X2dlbS5jCkBAIC0xMDA1LDggKzEw MDUsMTEgQEAgaTkxNV9nZW1fbWFkdmlzZV9pb2N0bChzdHJ1Y3QgZHJtX2RldmljZSAqZGV2LCB2 b2lkICpkYXRhLAogCQl9CiAJfQogCi0JaWYgKG9iai0+bW0ubWFkdiAhPSBfX0k5MTVfTUFEVl9Q VVJHRUQpCisJaWYgKG9iai0+bW0ubWFkdiAhPSBfX0k5MTVfTUFEVl9QVVJHRUQpIHsKIAkJb2Jq LT5tbS5tYWR2ID0gYXJncy0+bWFkdjsKKwkJaWYgKG9iai0+b3BzLT5hZGp1c3RfbHJ1KQorCQkJ b2JqLT5vcHMtPmFkanVzdF9scnUob2JqKTsKKwl9CiAKIAlpZiAoaTkxNV9nZW1fb2JqZWN0X2hh c19wYWdlcyhvYmopKSB7CiAJCXVuc2lnbmVkIGxvbmcgZmxhZ3M7CmRpZmYgLS1naXQgYS9kcml2 ZXJzL2dwdS9kcm0vaTkxNS9pbnRlbF9tZW1vcnlfcmVnaW9uLmMgYi9kcml2ZXJzL2dwdS9kcm0v aTkxNS9pbnRlbF9tZW1vcnlfcmVnaW9uLmMKaW5kZXggZTYwMjRlYjdjY2E0Li4xMmZiNTQyM2Zk NWUgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2ludGVsX21lbW9yeV9yZWdpb24u YworKysgYi9kcml2ZXJzL2dwdS9kcm0vaTkxNS9pbnRlbF9tZW1vcnlfcmVnaW9uLmMKQEAgLTE0 OSw3ICsxNDksNiBAQCBpbnRlbF9tZW1vcnlfcmVnaW9uX2NyZWF0ZShzdHJ1Y3QgZHJtX2k5MTVf cHJpdmF0ZSAqaTkxNSwKIAogCW11dGV4X2luaXQoJm1lbS0+b2JqZWN0cy5sb2NrKTsKIAlJTklU X0xJU1RfSEVBRCgmbWVtLT5vYmplY3RzLmxpc3QpOwotCUlOSVRfTElTVF9IRUFEKCZtZW0tPm9i amVjdHMucHVyZ2VhYmxlKTsKIAlJTklUX0xJU1RfSEVBRCgmbWVtLT5yZXNlcnZlZCk7CiAKIAlt dXRleF9pbml0KCZtZW0tPm1tX2xvY2spOwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJtL2k5 MTUvaW50ZWxfbWVtb3J5X3JlZ2lvbi5oIGIvZHJpdmVycy9ncHUvZHJtL2k5MTUvaW50ZWxfbWVt b3J5X3JlZ2lvbi5oCmluZGV4IDFmN2RhYzYzYWJiNy4uYzdlNjM1ZDYyZTFhIDEwMDY0NAotLS0g YS9kcml2ZXJzL2dwdS9kcm0vaTkxNS9pbnRlbF9tZW1vcnlfcmVnaW9uLmgKKysrIGIvZHJpdmVy cy9ncHUvZHJtL2k5MTUvaW50ZWxfbWVtb3J5X3JlZ2lvbi5oCkBAIC0xMDEsNyArMTAxLDYgQEAg c3RydWN0IGludGVsX21lbW9yeV9yZWdpb24gewogCXN0cnVjdCB7CiAJCXN0cnVjdCBtdXRleCBs b2NrOyAvKiBQcm90ZWN0cyBhY2Nlc3MgdG8gb2JqZWN0cyAqLwogCQlzdHJ1Y3QgbGlzdF9oZWFk IGxpc3Q7Ci0JCXN0cnVjdCBsaXN0X2hlYWQgcHVyZ2VhYmxlOwogCX0gb2JqZWN0czsKIAogCXNp emVfdCBjaHVua19zaXplOwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJtL2k5MTUvaW50ZWxf cmVnaW9uX3R0bS5jIGIvZHJpdmVycy9ncHUvZHJtL2k5MTUvaW50ZWxfcmVnaW9uX3R0bS5jCmlu ZGV4IDgyYTY3MjdlZGU0Ni4uMjdmZTA2NjhkMDk0IDEwMDY0NAotLS0gYS9kcml2ZXJzL2dwdS9k cm0vaTkxNS9pbnRlbF9yZWdpb25fdHRtLmMKKysrIGIvZHJpdmVycy9ncHUvZHJtL2k5MTUvaW50 ZWxfcmVnaW9uX3R0bS5jCkBAIC0xMSw2ICsxMSw3IEBACiAKICNpbmNsdWRlICJpbnRlbF9yZWdp b25fdHRtLmgiCiAKKyNpbmNsdWRlICJnZW0vaTkxNV9nZW1fdHRtLmgiIC8qIEZvciB0aGUgZnVu Y3Mvb3BzIGV4cG9ydCBvbmx5ICovCiAvKioKICAqIERPQzogVFRNIHN1cHBvcnQgc3RydWN0dXJl CiAgKgpAQCAtMjAsOSArMjEsNiBAQAogICogaTkxNSBHRU0gcmVnaW9ucyB0byBUVE0gbWVtb3J5 IHR5cGVzIGFuZCByZXNvdXJjZSBtYW5hZ2Vycy4KICAqLwogCi0vKiBBIFplcm8taW5pdGlhbGl6 ZWQgZHJpdmVyIGZvciBub3cuIFdlIGRvbid0IGhhdmUgYSBUVE0gYmFja2VuZCB5ZXQuICovCi1z dGF0aWMgc3RydWN0IHR0bV9kZXZpY2VfZnVuY3MgaTkxNV90dG1fYm9fZHJpdmVyOwotCiAvKioK ICAqIGludGVsX3JlZ2lvbl90dG1fZGV2aWNlX2luaXQgLSBJbml0aWFsaXplIGEgVFRNIGRldmlj ZQogICogQGRldl9wcml2OiBQb2ludGVyIHRvIGFuIGk5MTUgZGV2aWNlIHByaXZhdGUgc3RydWN0 dXJlLgpAQCAtMzMsNyArMzEsNyBAQCBpbnQgaW50ZWxfcmVnaW9uX3R0bV9kZXZpY2VfaW5pdChz dHJ1Y3QgZHJtX2k5MTVfcHJpdmF0ZSAqZGV2X3ByaXYpCiB7CiAJc3RydWN0IGRybV9kZXZpY2Ug KmRybSA9ICZkZXZfcHJpdi0+ZHJtOwogCi0JcmV0dXJuIHR0bV9kZXZpY2VfaW5pdCgmZGV2X3By aXYtPmJkZXYsICZpOTE1X3R0bV9ib19kcml2ZXIsCisJcmV0dXJuIHR0bV9kZXZpY2VfaW5pdCgm ZGV2X3ByaXYtPmJkZXYsIGk5MTVfdHRtX2RyaXZlcigpLAogCQkJICAgICAgIGRybS0+ZGV2LCBk cm0tPmFub25faW5vZGUtPmlfbWFwcGluZywKIAkJCSAgICAgICBkcm0tPnZtYV9vZmZzZXRfbWFu YWdlciwgZmFsc2UsIGZhbHNlKTsKIH0KQEAgLTE3Nyw2ICsxNzUsNyBAQCBzdHJ1Y3Qgc2dfdGFi bGUgKmludGVsX3JlZ2lvbl90dG1fbm9kZV90b19zdChzdHJ1Y3QgaW50ZWxfbWVtb3J5X3JlZ2lv biAqbWVtLAogCQkJCSAgICBtZW0tPnJlZ2lvbi5zdGFydCk7CiB9CiAKKyNpZmRlZiBDT05GSUdf RFJNX0k5MTVfU0VMRlRFU1QKIC8qKgogICogaW50ZWxfcmVnaW9uX3R0bV9ub2RlX2FsbG9jIC0g QWxsb2NhdGUgbWVtb3J5IHJlc291cmNlcyBmcm9tIGEgcmVnaW9uCiAgKiBAbWVtOiBUaGUgbWVt b3J5IHJlZ2lvbiwKQEAgLTIyNCwzICsyMjMsNCBAQCBpbnRlbF9yZWdpb25fdHRtX25vZGVfYWxs b2Moc3RydWN0IGludGVsX21lbW9yeV9yZWdpb24gKm1lbSwKIAkJcmV0ID0gLUVOWElPOwogCXJl dHVybiByZXQgPyBFUlJfUFRSKHJldCkgOiByZXM7CiB9CisjZW5kaWYKZGlmZiAtLWdpdCBhL2Ry aXZlcnMvZ3B1L2RybS9pOTE1L2ludGVsX3JlZ2lvbl90dG0uaCBiL2RyaXZlcnMvZ3B1L2RybS9p OTE1L2ludGVsX3JlZ2lvbl90dG0uaAppbmRleCAxMWIwNTc0YWI3OTEuLmU4Y2Y4MzBmZGE2ZiAx MDA2NDQKLS0tIGEvZHJpdmVycy9ncHUvZHJtL2k5MTUvaW50ZWxfcmVnaW9uX3R0bS5oCisrKyBi L2RyaXZlcnMvZ3B1L2RybS9pOTE1L2ludGVsX3JlZ2lvbl90dG0uaApAQCAtMTIsNiArMTIsNyBA QAogc3RydWN0IGRybV9pOTE1X3ByaXZhdGU7CiBzdHJ1Y3QgaW50ZWxfbWVtb3J5X3JlZ2lvbjsK IHN0cnVjdCB0dG1fcmVzb3VyY2U7CitzdHJ1Y3QgdHRtX2RldmljZV9mdW5jczsKIAogaW50IGlu dGVsX3JlZ2lvbl90dG1fZGV2aWNlX2luaXQoc3RydWN0IGRybV9pOTE1X3ByaXZhdGUgKmRldl9w cml2KTsKIApAQCAtMjQsMTEgKzI1LDE1IEBAIHZvaWQgaW50ZWxfcmVnaW9uX3R0bV9maW5pKHN0 cnVjdCBpbnRlbF9tZW1vcnlfcmVnaW9uICptZW0pOwogc3RydWN0IHNnX3RhYmxlICppbnRlbF9y ZWdpb25fdHRtX25vZGVfdG9fc3Qoc3RydWN0IGludGVsX21lbW9yeV9yZWdpb24gKm1lbSwKIAkJ CQkJICAgICBzdHJ1Y3QgdHRtX3Jlc291cmNlICpyZXMpOwogCit2b2lkIGludGVsX3JlZ2lvbl90 dG1fbm9kZV9mcmVlKHN0cnVjdCBpbnRlbF9tZW1vcnlfcmVnaW9uICptZW0sCisJCQkJc3RydWN0 IHR0bV9yZXNvdXJjZSAqbm9kZSk7CisKK3N0cnVjdCB0dG1fZGV2aWNlX2Z1bmNzICppOTE1X3R0 bV9kcml2ZXIodm9pZCk7CisKKyNpZmRlZiBDT05GSUdfRFJNX0k5MTVfU0VMRlRFU1QKIHN0cnVj dCB0dG1fcmVzb3VyY2UgKgogaW50ZWxfcmVnaW9uX3R0bV9ub2RlX2FsbG9jKHN0cnVjdCBpbnRl bF9tZW1vcnlfcmVnaW9uICptZW0sCiAJCQkgICAgcmVzb3VyY2Vfc2l6ZV90IHNpemUsCiAJCQkg ICAgdW5zaWduZWQgaW50IGZsYWdzKTsKLQotdm9pZCBpbnRlbF9yZWdpb25fdHRtX25vZGVfZnJl ZShzdHJ1Y3QgaW50ZWxfbWVtb3J5X3JlZ2lvbiAqbWVtLAotCQkJCXN0cnVjdCB0dG1fcmVzb3Vy Y2UgKm5vZGUpOworI2VuZGlmCiAjZW5kaWYgLyogX0lOVEVMX1JFR0lPTl9UVE1fSF8gKi8KLS0g CjIuMzEuMQoKX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX18K SW50ZWwtZ2Z4IG1haWxpbmcgbGlzdApJbnRlbC1nZnhAbGlzdHMuZnJlZWRlc2t0b3Aub3JnCmh0 dHBzOi8vbGlzdHMuZnJlZWRlc2t0b3Aub3JnL21haWxtYW4vbGlzdGluZm8vaW50ZWwtZ2Z4Cg== From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org X-Spam-Level: X-Spam-Status: No, score=-16.8 required=3.0 tests=BAYES_00, HEADER_FROM_DIFFERENT_DOMAINS,INCLUDES_CR_TRAILER,INCLUDES_PATCH, MAILING_LIST_MULTI,SPF_HELO_NONE,SPF_PASS,URIBL_BLOCKED,USER_AGENT_GIT autolearn=ham autolearn_force=no version=3.4.0 Received: from mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id AEAD2C48BD1 for ; Thu, 10 Jun 2021 07:02:37 +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 7E06E61374 for ; Thu, 10 Jun 2021 07:02:37 +0000 (UTC) DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org 7E06E61374 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 B3CFA6E858; Thu, 10 Jun 2021 07:02:26 +0000 (UTC) Received: from mga02.intel.com (mga02.intel.com [134.134.136.20]) by gabe.freedesktop.org (Postfix) with ESMTPS id 5B6546E5A2; Thu, 10 Jun 2021 07:02:25 +0000 (UTC) IronPort-SDR: mFqU36SbJcLTwzcez7MNrrOD1DN3dPyRz2MEFJYai0t4/c/W2Wa3xPNUPiKE+VBIGsIUOUtBSz eKqwyj+lkLIQ== X-IronPort-AV: E=McAfee;i="6200,9189,10010"; a="192351619" X-IronPort-AV: E=Sophos;i="5.83,262,1616482800"; d="scan'208";a="192351619" Received: from orsmga001.jf.intel.com ([10.7.209.18]) by orsmga101.jf.intel.com with ESMTP/TLS/ECDHE-RSA-AES256-GCM-SHA384; 10 Jun 2021 00:02:21 -0700 IronPort-SDR: d7eBZpwVQmIS05o1voCF1Q8QC1OZc3MKJJMjrcDWibHF1g1GQRr5DhNqcH2ACrhQm+3WFXfFiq lH4uuWDEpxDw== X-IronPort-AV: E=Sophos;i="5.83,262,1616482800"; d="scan'208";a="482717909" Received: from smirnov2-mobl.ccr.corp.intel.com (HELO thellst-mobl1.intel.com) ([10.249.254.160]) by orsmga001-auth.jf.intel.com with ESMTP/TLS/ECDHE-RSA-AES256-GCM-SHA384; 10 Jun 2021 00:02:19 -0700 From: =?UTF-8?q?Thomas=20Hellstr=C3=B6m?= To: intel-gfx@lists.freedesktop.org, dri-devel@lists.freedesktop.org Subject: [PATCH v11 1/4] drm/i915/ttm: Introduce a TTM i915 gem object backend Date: Thu, 10 Jun 2021 09:01:49 +0200 Message-Id: <20210610070152.572423-2-thomas.hellstrom@linux.intel.com> X-Mailer: git-send-email 2.31.1 In-Reply-To: <20210610070152.572423-1-thomas.hellstrom@linux.intel.com> References: <20210610070152.572423-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. v6: - Remove the ttm device verify_access assignment. The member is gone upstream. --- 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 | 540 ++++++++++++++++++ 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, 730 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 4f22cac1c49b..f57dfc74d6ce 100644 --- a/drivers/gpu/drm/i915/Makefile +++ b/drivers/gpu/drm/i915/Makefile @@ -155,6 +155,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 5706d471692d..16eac5ea9238 100644 --- a/drivers/gpu/drm/i915/gem/i915_gem_object.c +++ b/drivers/gpu/drm/i915/gem/i915_gem_object.c @@ -172,7 +172,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); @@ -208,59 +208,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); @@ -318,6 +328,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); } @@ -410,6 +421,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 7c0eb425cb3b..5ae32ea99ee5 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..2695b8c37e13 --- /dev/null +++ b/drivers/gpu/drm/i915/gem/i915_gem_ttm.c @@ -0,0 +1,540 @@ +// 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->resource->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); +} + +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->resource->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->resource->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, + .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->resource, 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 589388dec48a..6a0a3f0e36e1 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 e6024eb7cca4..12fb5423fd5e 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 1f7dac63abb7..c7e635d62e1a 100644 --- a/drivers/gpu/drm/i915/intel_memory_region.h +++ b/drivers/gpu/drm/i915/intel_memory_region.h @@ -101,7 +101,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 82a6727ede46..27fe0668d094 100644 --- a/drivers/gpu/drm/i915/intel_region_ttm.c +++ b/drivers/gpu/drm/i915/intel_region_ttm.c @@ -11,6 +11,7 @@ #include "intel_region_ttm.h" +#include "gem/i915_gem_ttm.h" /* For the funcs/ops export only */ /** * DOC: TTM support structure * @@ -20,9 +21,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. @@ -33,7 +31,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); } @@ -177,6 +175,7 @@ struct sg_table *intel_region_ttm_node_to_st(struct intel_memory_region *mem, mem->region.start); } +#ifdef CONFIG_DRM_I915_SELFTEST /** * intel_region_ttm_node_alloc - Allocate memory resources from a region * @mem: The memory region, @@ -224,3 +223,4 @@ intel_region_ttm_node_alloc(struct intel_memory_region *mem, ret = -ENXIO; return ret ? ERR_PTR(ret) : res; } +#endif diff --git a/drivers/gpu/drm/i915/intel_region_ttm.h b/drivers/gpu/drm/i915/intel_region_ttm.h index 11b0574ab791..e8cf830fda6f 100644 --- a/drivers/gpu/drm/i915/intel_region_ttm.h +++ b/drivers/gpu/drm/i915/intel_region_ttm.h @@ -12,6 +12,7 @@ struct drm_i915_private; struct intel_memory_region; struct ttm_resource; +struct ttm_device_funcs; int intel_region_ttm_device_init(struct drm_i915_private *dev_priv); @@ -24,11 +25,15 @@ void intel_region_ttm_fini(struct intel_memory_region *mem); struct sg_table *intel_region_ttm_node_to_st(struct intel_memory_region *mem, struct ttm_resource *res); +void intel_region_ttm_node_free(struct intel_memory_region *mem, + struct ttm_resource *node); + +struct ttm_device_funcs *i915_ttm_driver(void); + +#ifdef CONFIG_DRM_I915_SELFTEST struct ttm_resource * 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, - struct ttm_resource *node); +#endif #endif /* _INTEL_REGION_TTM_H_ */ -- 2.31.1