From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org X-Spam-Level: X-Spam-Status: No, score=-16.8 required=3.0 tests=BAYES_00, HEADER_FROM_DIFFERENT_DOMAINS,INCLUDES_CR_TRAILER,INCLUDES_PATCH, MAILING_LIST_MULTI,SPF_HELO_NONE,SPF_PASS,USER_AGENT_GIT autolearn=ham autolearn_force=no version=3.4.0 Received: from mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id 170BFC433ED for ; Tue, 18 May 2021 08:27:49 +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 D90C1610A1 for ; Tue, 18 May 2021 08:27:48 +0000 (UTC) DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org D90C1610A1 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 0930C6E874; Tue, 18 May 2021 08:27:42 +0000 (UTC) Received: from mga17.intel.com (mga17.intel.com [192.55.52.151]) by gabe.freedesktop.org (Postfix) with ESMTPS id 8457B6E860; Tue, 18 May 2021 08:27:39 +0000 (UTC) IronPort-SDR: Hh3v3iPG36tYB7pd1fC/zjKmzafsw/1M0rqgRByl/jnFJRS+o5yqiOsI0FgZqQcLAa9nj1f9gD 7FWd/dSTis1g== X-IronPort-AV: E=McAfee;i="6200,9189,9987"; a="180937170" X-IronPort-AV: E=Sophos;i="5.82,309,1613462400"; d="scan'208";a="180937170" Received: from orsmga005.jf.intel.com ([10.7.209.41]) by fmsmga107.fm.intel.com with ESMTP/TLS/ECDHE-RSA-AES256-GCM-SHA384; 18 May 2021 01:27:37 -0700 IronPort-SDR: P0/7LBMGe6uiTxlH2oaq5oqv7j3oyavaj6/i1T4MIP7e+M3bYmpJVMQItikhIY1QOHXj102yM1 8SuBzif6PnTQ== X-IronPort-AV: E=Sophos;i="5.82,309,1613462400"; d="scan'208";a="611892316" Received: from cmutgix-mobl.gar.corp.intel.com (HELO thellst-mobl1.intel.com) ([10.249.254.195]) by orsmga005-auth.jf.intel.com with ESMTP/TLS/ECDHE-RSA-AES256-GCM-SHA384; 18 May 2021 01:27:31 -0700 From: =?UTF-8?q?Thomas=20Hellstr=C3=B6m?= To: intel-gfx@lists.freedesktop.org, dri-devel@lists.freedesktop.org Date: Tue, 18 May 2021 10:26:51 +0200 Message-Id: <20210518082701.997251-6-thomas.hellstrom@linux.intel.com> X-Mailer: git-send-email 2.31.1 In-Reply-To: <20210518082701.997251-1-thomas.hellstrom@linux.intel.com> References: <20210518082701.997251-1-thomas.hellstrom@linux.intel.com> MIME-Version: 1.0 Subject: [Intel-gfx] [PATCH v2 05/15] drm/i915/ttm Initialize the ttm device and memory managers 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?= Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Errors-To: intel-gfx-bounces@lists.freedesktop.org Sender: "Intel-gfx" VGVtcG9yYXJpbHkgcmVtb3ZlIHRoZSBidWRkeSBhbGxvY2F0b3IgYW5kIHJlbGF0ZWQgc2VsZnRl c3RzCmFuZCBob29rIHVwIHRoZSBUVE0gcmFuZ2UgbWFuYWdlciBmb3IgaTkxNSByZWdpb25zLgoK QWxzbyBtb2RpZnkgdGhlIG1vY2sgcmVnaW9uIHNlbGZ0ZXN0cyBzb21ld2hhdCB0byBhY2NvdW50 IGZvciBhCmZyYWdtZW50aW5nIG1hbmFnZXIuCgpTaWduZWQtb2ZmLWJ5OiBUaG9tYXMgSGVsbHN0 csO2bSA8dGhvbWFzLmhlbGxzdHJvbUBsaW51eC5pbnRlbC5jb20+Ci0tLQp2MjoKLSBGaXggYW4g ZXJyb3IgdW53aW5kIGluIGxtZW1fZ2V0X3BhZ2VzKCkgKFJlcG9ydGVkIGJ5IE1hdHRoZXcgQXVs ZCkKLSBCcmVhayBvdXQgYW5kIG1vZGlmeSB1c2FnZSBvZiBpOTE1X3NnX2RtYV9zaXplcygpIChS ZXBvcnRlZCBieSBNYXR0ZXcgQXVsZCkKLSBCcmVhayBvdXQgVFRNIGNoYW5nZXMgdG8gYSBzZXBh cmF0ZSBwYXRjaCAoUmVwb3J0ZWQgYnkgQ2hyaXN0aWFuIEvDtm5pZykKLS0tCiBkcml2ZXJzL2dw dS9kcm0vaTkxNS9LY29uZmlnICAgICAgICAgICAgICAgICAgfCAgIDEgKwogZHJpdmVycy9ncHUv ZHJtL2k5MTUvTWFrZWZpbGUgICAgICAgICAgICAgICAgIHwgICAyICstCiBkcml2ZXJzL2dwdS9k cm0vaTkxNS9nZW0vaTkxNV9nZW1fbG1lbS5jICAgICAgfCAgNTkgKy0KIC4uLi9ncHUvZHJtL2k5 MTUvZ2VtL2k5MTVfZ2VtX29iamVjdF90eXBlcy5oICB8ICAgNiArLQogZHJpdmVycy9ncHUvZHJt L2k5MTUvZ2VtL2k5MTVfZ2VtX3BhZ2VzLmMgICAgIHwgICAzICstCiBkcml2ZXJzL2dwdS9kcm0v aTkxNS9nZW0vaTkxNV9nZW1fcmVnaW9uLmMgICAgfCAxMjAgLS0tCiBkcml2ZXJzL2dwdS9kcm0v aTkxNS9nZW0vaTkxNV9nZW1fcmVnaW9uLmggICAgfCAgIDQgLQogZHJpdmVycy9ncHUvZHJtL2k5 MTUvZ2VtL2k5MTVfZ2VtX3NobWVtLmMgICAgIHwgICA0ICstCiBkcml2ZXJzL2dwdS9kcm0vaTkx NS9nZW0vaTkxNV9nZW1fc3RvbGVuLmMgICAgfCAgMTAgKy0KIGRyaXZlcnMvZ3B1L2RybS9pOTE1 L2dlbS9pOTE1X2dlbV9zdG9sZW4uaCAgICB8ICAgOSArLQogZHJpdmVycy9ncHUvZHJtL2k5MTUv Z3QvaW50ZWxfZ3QuYyAgICAgICAgICAgIHwgICAyIC0KIGRyaXZlcnMvZ3B1L2RybS9pOTE1L2d0 L2ludGVsX3JlZ2lvbl9sbWVtLmMgICB8ICAyNyArLQogZHJpdmVycy9ncHUvZHJtL2k5MTUvaTkx NV9idWRkeS5jICAgICAgICAgICAgIHwgNDM1IC0tLS0tLS0tLS0KIGRyaXZlcnMvZ3B1L2RybS9p OTE1L2k5MTVfYnVkZHkuaCAgICAgICAgICAgICB8IDEzMSAtLS0KIGRyaXZlcnMvZ3B1L2RybS9p OTE1L2k5MTVfZHJ2LmMgICAgICAgICAgICAgICB8ICAgOCArCiBkcml2ZXJzL2dwdS9kcm0vaTkx NS9pOTE1X2Rydi5oICAgICAgICAgICAgICAgfCAgIDcgKy0KIGRyaXZlcnMvZ3B1L2RybS9pOTE1 L2k5MTVfZ2VtLmMgICAgICAgICAgICAgICB8ICAgMSArCiBkcml2ZXJzL2dwdS9kcm0vaTkxNS9p OTE1X2dsb2JhbHMuYyAgICAgICAgICAgfCAgIDEgLQogZHJpdmVycy9ncHUvZHJtL2k5MTUvaTkx NV9nbG9iYWxzLmggICAgICAgICAgIHwgICAxIC0KIGRyaXZlcnMvZ3B1L2RybS9pOTE1L2k5MTVf c2NhdHRlcmxpc3QuYyAgICAgICB8ICA3MCArKwogZHJpdmVycy9ncHUvZHJtL2k5MTUvaTkxNV9z Y2F0dGVybGlzdC5oICAgICAgIHwgICA0ICsKIGRyaXZlcnMvZ3B1L2RybS9pOTE1L2ludGVsX21l bW9yeV9yZWdpb24uYyAgICB8IDE4MCArKy0tCiBkcml2ZXJzL2dwdS9kcm0vaTkxNS9pbnRlbF9t ZW1vcnlfcmVnaW9uLmggICAgfCAgNDQgKy0KIGRyaXZlcnMvZ3B1L2RybS9pOTE1L2ludGVsX3Jl Z2lvbl90dG0uYyAgICAgICB8IDI0NSArKysrKysKIGRyaXZlcnMvZ3B1L2RybS9pOTE1L2ludGVs X3JlZ2lvbl90dG0uaCAgICAgICB8ICAyOSArCiBkcml2ZXJzL2dwdS9kcm0vaTkxNS9zZWxmdGVz dHMvaTkxNV9idWRkeS5jICAgfCA3ODkgLS0tLS0tLS0tLS0tLS0tLS0tCiAuLi4vZHJtL2k5MTUv c2VsZnRlc3RzL2k5MTVfbW9ja19zZWxmdGVzdHMuaCAgfCAgIDEgLQogLi4uL2RybS9pOTE1L3Nl bGZ0ZXN0cy9pbnRlbF9tZW1vcnlfcmVnaW9uLmMgIHwgMTMzICstLQogZHJpdmVycy9ncHUvZHJt L2k5MTUvc2VsZnRlc3RzL21vY2tfcmVnaW9uLmMgIHwgIDUwICstCiAyOSBmaWxlcyBjaGFuZ2Vk LCA2MjIgaW5zZXJ0aW9ucygrKSwgMTc1NCBkZWxldGlvbnMoLSkKIGRlbGV0ZSBtb2RlIDEwMDY0 NCBkcml2ZXJzL2dwdS9kcm0vaTkxNS9pOTE1X2J1ZGR5LmMKIGRlbGV0ZSBtb2RlIDEwMDY0NCBk cml2ZXJzL2dwdS9kcm0vaTkxNS9pOTE1X2J1ZGR5LmgKIGNyZWF0ZSBtb2RlIDEwMDY0NCBkcml2 ZXJzL2dwdS9kcm0vaTkxNS9pbnRlbF9yZWdpb25fdHRtLmMKIGNyZWF0ZSBtb2RlIDEwMDY0NCBk cml2ZXJzL2dwdS9kcm0vaTkxNS9pbnRlbF9yZWdpb25fdHRtLmgKIGRlbGV0ZSBtb2RlIDEwMDY0 NCBkcml2ZXJzL2dwdS9kcm0vaTkxNS9zZWxmdGVzdHMvaTkxNV9idWRkeS5jCgpkaWZmIC0tZ2l0 IGEvZHJpdmVycy9ncHUvZHJtL2k5MTUvS2NvbmZpZyBiL2RyaXZlcnMvZ3B1L2RybS9pOTE1L0tj b25maWcKaW5kZXggMWUxY2IyNDVmY2E3Li5iNjNkMzc0ZGZmMjMgMTAwNjQ0Ci0tLSBhL2RyaXZl cnMvZ3B1L2RybS9pOTE1L0tjb25maWcKKysrIGIvZHJpdmVycy9ncHUvZHJtL2k5MTUvS2NvbmZp ZwpAQCAtMjYsNiArMjYsNyBAQCBjb25maWcgRFJNX0k5MTUKIAlzZWxlY3QgU05EX0hEQV9JOTE1 IGlmIFNORF9IREFfQ09SRQogCXNlbGVjdCBDRUNfQ09SRSBpZiBDRUNfTk9USUZJRVIKIAlzZWxl Y3QgVk1BUF9QRk4KKwlzZWxlY3QgRFJNX1RUTQogCWhlbHAKIAkgIENob29zZSB0aGlzIG9wdGlv biBpZiB5b3UgaGF2ZSBhIHN5c3RlbSB0aGF0IGhhcyAiSW50ZWwgR3JhcGhpY3MKIAkgIE1lZGlh IEFjY2VsZXJhdG9yIiBvciAiSEQgR3JhcGhpY3MiIGludGVncmF0ZWQgZ3JhcGhpY3MsCmRpZmYg LS1naXQgYS9kcml2ZXJzL2dwdS9kcm0vaTkxNS9NYWtlZmlsZSBiL2RyaXZlcnMvZ3B1L2RybS9p OTE1L01ha2VmaWxlCmluZGV4IGQwZDkzNmQ5MTM3Yi4uY2I4ODIzNTcwOTk2IDEwMDY0NAotLS0g YS9kcml2ZXJzL2dwdS9kcm0vaTkxNS9NYWtlZmlsZQorKysgYi9kcml2ZXJzL2dwdS9kcm0vaTkx NS9NYWtlZmlsZQpAQCAtNTAsNiArNTAsNyBAQCBpOTE1LXkgKz0gaTkxNV9kcnYubyBcCiAJICBp bnRlbF9tZW1vcnlfcmVnaW9uLm8gXAogCSAgaW50ZWxfcGNoLm8gXAogCSAgaW50ZWxfcG0ubyBc CisJICBpbnRlbF9yZWdpb25fdHRtLm8gXAogCSAgaW50ZWxfcnVudGltZV9wbS5vIFwKIAkgIGlu dGVsX3NpZGViYW5kLm8gXAogCSAgaW50ZWxfc3RlcC5vIFwKQEAgLTE2MCw3ICsxNjEsNiBAQCBn ZW0teSArPSBcCiBpOTE1LXkgKz0gXAogCSAgJChnZW0teSkgXAogCSAgaTkxNV9hY3RpdmUubyBc Ci0JICBpOTE1X2J1ZGR5Lm8gXAogCSAgaTkxNV9jbWRfcGFyc2VyLm8gXAogCSAgaTkxNV9nZW1f ZXZpY3QubyBcCiAJICBpOTE1X2dlbV9ndHQubyBcCmRpZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9k cm0vaTkxNS9nZW0vaTkxNV9nZW1fbG1lbS5jIGIvZHJpdmVycy9ncHUvZHJtL2k5MTUvZ2VtL2k5 MTVfZ2VtX2xtZW0uYwppbmRleCBmNDRiZGQwOGY3Y2IuLjNiNGFhMjhhMDc2ZCAxMDA2NDQKLS0t IGEvZHJpdmVycy9ncHUvZHJtL2k5MTUvZ2VtL2k5MTVfZ2VtX2xtZW0uYworKysgYi9kcml2ZXJz L2dwdS9kcm0vaTkxNS9nZW0vaTkxNV9nZW1fbG1lbS5jCkBAIC00LDE2ICs0LDcxIEBACiAgKi8K IAogI2luY2x1ZGUgImludGVsX21lbW9yeV9yZWdpb24uaCIKKyNpbmNsdWRlICJpbnRlbF9yZWdp b25fdHRtLmgiCiAjaW5jbHVkZSAiZ2VtL2k5MTVfZ2VtX3JlZ2lvbi5oIgogI2luY2x1ZGUgImdl bS9pOTE1X2dlbV9sbWVtLmgiCiAjaW5jbHVkZSAiaTkxNV9kcnYuaCIKIAorc3RhdGljIHZvaWQg bG1lbV9wdXRfcGFnZXMoc3RydWN0IGRybV9pOTE1X2dlbV9vYmplY3QgKm9iaiwKKwkJCSAgIHN0 cnVjdCBzZ190YWJsZSAqcGFnZXMpCit7CisJaW50ZWxfcmVnaW9uX3R0bV9ub2RlX2ZyZWUob2Jq LT5tbS5yZWdpb24sIG9iai0+bW0uc3RfbW1fbm9kZSk7CisJb2JqLT5tbS5kaXJ0eSA9IGZhbHNl OworCXNnX2ZyZWVfdGFibGUocGFnZXMpOworCWtmcmVlKHBhZ2VzKTsKK30KKworc3RhdGljIGlu dCBsbWVtX2dldF9wYWdlcyhzdHJ1Y3QgZHJtX2k5MTVfZ2VtX29iamVjdCAqb2JqKQoreworCXVu c2lnbmVkIGludCBmbGFnczsKKwlzdHJ1Y3Qgc2dfdGFibGUgKnBhZ2VzOworCisJZmxhZ3MgPSBJ OTE1X0FMTE9DX01JTl9QQUdFX1NJWkU7CisJaWYgKG9iai0+ZmxhZ3MgJiBJOTE1X0JPX0FMTE9D X0NPTlRJR1VPVVMpCisJCWZsYWdzIHw9IEk5MTVfQUxMT0NfQ09OVElHVU9VUzsKKworCW9iai0+ bW0uc3RfbW1fbm9kZSA9IGludGVsX3JlZ2lvbl90dG1fbm9kZV9hbGxvYyhvYmotPm1tLnJlZ2lv biwKKwkJCQkJCQkgb2JqLT5iYXNlLnNpemUsCisJCQkJCQkJIGZsYWdzKTsKKwlpZiAoSVNfRVJS KG9iai0+bW0uc3RfbW1fbm9kZSkpCisJCXJldHVybiBQVFJfRVJSKG9iai0+bW0uc3RfbW1fbm9k ZSk7CisKKwkvKiBSYW5nZSBtYW5hZ2VyIGlzIGFsd2F5cyBjb250aWdvdXMgKi8KKwlpZiAob2Jq LT5tbS5yZWdpb24tPmlzX3JhbmdlX21hbmFnZXIpCisJCW9iai0+ZmxhZ3MgfD0gSTkxNV9CT19B TExPQ19DT05USUdVT1VTOworCXBhZ2VzID0gaW50ZWxfcmVnaW9uX3R0bV9ub2RlX3RvX3N0KG9i ai0+bW0ucmVnaW9uLCBvYmotPm1tLnN0X21tX25vZGUpOworCWlmIChJU19FUlIocGFnZXMpKSB7 CisJCWludGVsX3JlZ2lvbl90dG1fbm9kZV9mcmVlKG9iai0+bW0ucmVnaW9uLCBvYmotPm1tLnN0 X21tX25vZGUpOworCQlyZXR1cm4gUFRSX0VSUihwYWdlcyk7CisJfQorCisJX19pOTE1X2dlbV9v YmplY3Rfc2V0X3BhZ2VzKG9iaiwgcGFnZXMsIGk5MTVfc2dfZG1hX3NpemVzKHBhZ2VzLT5zZ2wp KTsKKworCWlmIChvYmotPmZsYWdzICYgSTkxNV9CT19BTExPQ19DUFVfQ0xFQVIpIHsKKwkJdm9p ZCBfX2lvbWVtICp2YWRkciA9CisJCQlpOTE1X2dlbV9vYmplY3RfbG1lbV9pb19tYXAob2JqLCAw LCBvYmotPmJhc2Uuc2l6ZSk7CisKKwkJaWYgKCF2YWRkcikgeworCQkJc3RydWN0IHNnX3RhYmxl ICpwYWdlcyA9CisJCQkJX19pOTE1X2dlbV9vYmplY3RfdW5zZXRfcGFnZXMob2JqKTsKKworCQkJ aWYgKCFJU19FUlJfT1JfTlVMTChwYWdlcykpCisJCQkJbG1lbV9wdXRfcGFnZXMob2JqLCBwYWdl cyk7CisJCX0KKworCQltZW1zZXRfaW8odmFkZHIsIDAsIG9iai0+YmFzZS5zaXplKTsKKwkJaW9f bWFwcGluZ191bm1hcCh2YWRkcik7CisJfQorCisJcmV0dXJuIDA7Cit9CisKIGNvbnN0IHN0cnVj dCBkcm1faTkxNV9nZW1fb2JqZWN0X29wcyBpOTE1X2dlbV9sbWVtX29ial9vcHMgPSB7CiAJLm5h bWUgPSAiaTkxNV9nZW1fb2JqZWN0X2xtZW0iLAogCS5mbGFncyA9IEk5MTVfR0VNX09CSkVDVF9I QVNfSU9NRU0sCiAKLQkuZ2V0X3BhZ2VzID0gaTkxNV9nZW1fb2JqZWN0X2dldF9wYWdlc19idWRk eSwKLQkucHV0X3BhZ2VzID0gaTkxNV9nZW1fb2JqZWN0X3B1dF9wYWdlc19idWRkeSwKKwkuZ2V0 X3BhZ2VzID0gbG1lbV9nZXRfcGFnZXMsCisJLnB1dF9wYWdlcyA9IGxtZW1fcHV0X3BhZ2VzLAog CS5yZWxlYXNlID0gaTkxNV9nZW1fb2JqZWN0X3JlbGVhc2VfbWVtb3J5X3JlZ2lvbiwKIH07CiAK ZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2dlbS9pOTE1X2dlbV9vYmplY3RfdHlw ZXMuaCBiL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2dlbS9pOTE1X2dlbV9vYmplY3RfdHlwZXMuaApp bmRleCA0NTAzNDBhNzMxODYuLmRiZDdmZmZlOTU2ZSAxMDA2NDQKLS0tIGEvZHJpdmVycy9ncHUv ZHJtL2k5MTUvZ2VtL2k5MTVfZ2VtX29iamVjdF90eXBlcy5oCisrKyBiL2RyaXZlcnMvZ3B1L2Ry bS9pOTE1L2dlbS9pOTE1X2dlbV9vYmplY3RfdHlwZXMuaApAQCAtMjMyLDEwICsyMzIsMTIgQEAg c3RydWN0IGRybV9pOTE1X2dlbV9vYmplY3QgewogCQkgKiBNZW1vcnkgcmVnaW9uIGZvciB0aGlz IG9iamVjdC4KIAkJICovCiAJCXN0cnVjdCBpbnRlbF9tZW1vcnlfcmVnaW9uICpyZWdpb247CisK IAkJLyoqCi0JCSAqIExpc3Qgb2YgbWVtb3J5IHJlZ2lvbiBibG9ja3MgYWxsb2NhdGVkIGZvciB0 aGlzIG9iamVjdC4KKwkJICogTWVtb3J5IG1hbmFnZXIgbm9kZSBhbGxvY2F0ZWQgZm9yIHRoaXMg b2JqZWN0LgogCQkgKi8KLQkJc3RydWN0IGxpc3RfaGVhZCBibG9ja3M7CisJCXZvaWQgKnN0X21t X25vZGU7CisKIAkJLyoqCiAJCSAqIEVsZW1lbnQgd2l0aGluIG1lbW9yeV9yZWdpb24tPm9iamVj dHMgb3IgcmVnaW9uLT5wdXJnZWFibGUKIAkJICogaWYgdGhlIG9iamVjdCBpcyBtYXJrZWQgYXMg RE9OVE5FRUQuIEFjY2VzcyBpcyBwcm90ZWN0ZWQgYnkKZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1 L2RybS9pOTE1L2dlbS9pOTE1X2dlbV9wYWdlcy5jIGIvZHJpdmVycy9ncHUvZHJtL2k5MTUvZ2Vt L2k5MTVfZ2VtX3BhZ2VzLmMKaW5kZXggYWVkOGEzN2NjZGM5Li42MmVlMjE4NWE0MWIgMTAwNjQ0 Ci0tLSBhL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2dlbS9pOTE1X2dlbV9wYWdlcy5jCisrKyBiL2Ry aXZlcnMvZ3B1L2RybS9pOTE1L2dlbS9pOTE1X2dlbV9wYWdlcy5jCkBAIC00NzMsNyArNDczLDgg QEAgX19pOTE1X2dlbV9vYmplY3RfZ2V0X3NnKHN0cnVjdCBkcm1faTkxNV9nZW1fb2JqZWN0ICpv YmosCiAKIAltaWdodF9zbGVlcCgpOwogCUdFTV9CVUdfT04obiA+PSBvYmotPmJhc2Uuc2l6ZSA+ PiBQQUdFX1NISUZUKTsKLQlHRU1fQlVHX09OKCFpOTE1X2dlbV9vYmplY3RfaGFzX3Bpbm5lZF9w YWdlcyhvYmopKTsKKwlpZiAoIWk5MTVfZ2VtX29iamVjdF9oYXNfcGlubmVkX3BhZ2VzKG9iaikp CisJCWFzc2VydF9vYmplY3RfaGVsZChvYmopOwogCiAJLyogQXMgd2UgaXRlcmF0ZSBmb3J3YXJk IHRocm91Z2ggdGhlIHNnLCB3ZSByZWNvcmQgZWFjaCBlbnRyeSBpbiBhCiAJICogcmFkaXh0cmVl IGZvciBxdWljayByZXBlYXRlZCAoYmFja3dhcmRzKSBsb29rdXBzLiBJZiB3ZSBoYXZlIHNlZW4K ZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2dlbS9pOTE1X2dlbV9yZWdpb24uYyBi L2RyaXZlcnMvZ3B1L2RybS9pOTE1L2dlbS9pOTE1X2dlbV9yZWdpb24uYwppbmRleCBjZThmY2Zj NTQwNzkuLmYyNWU2NjQ2YzViNyAxMDA2NDQKLS0tIGEvZHJpdmVycy9ncHUvZHJtL2k5MTUvZ2Vt L2k5MTVfZ2VtX3JlZ2lvbi5jCisrKyBiL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2dlbS9pOTE1X2dl bV9yZWdpb24uYwpAQCAtOCwxMjkgKzgsOSBAQAogI2luY2x1ZGUgImk5MTVfZHJ2LmgiCiAjaW5j bHVkZSAiaTkxNV90cmFjZS5oIgogCi12b2lkCi1pOTE1X2dlbV9vYmplY3RfcHV0X3BhZ2VzX2J1 ZGR5KHN0cnVjdCBkcm1faTkxNV9nZW1fb2JqZWN0ICpvYmosCi0JCQkJc3RydWN0IHNnX3RhYmxl ICpwYWdlcykKLXsKLQlfX2ludGVsX21lbW9yeV9yZWdpb25fcHV0X3BhZ2VzX2J1ZGR5KG9iai0+ bW0ucmVnaW9uLCAmb2JqLT5tbS5ibG9ja3MpOwotCi0Jb2JqLT5tbS5kaXJ0eSA9IGZhbHNlOwot CXNnX2ZyZWVfdGFibGUocGFnZXMpOwotCWtmcmVlKHBhZ2VzKTsKLX0KLQotaW50Ci1pOTE1X2dl bV9vYmplY3RfZ2V0X3BhZ2VzX2J1ZGR5KHN0cnVjdCBkcm1faTkxNV9nZW1fb2JqZWN0ICpvYmop Ci17Ci0JY29uc3QgdTY0IG1heF9zZWdtZW50ID0gaTkxNV9zZ19zZWdtZW50X3NpemUoKTsKLQlz dHJ1Y3QgaW50ZWxfbWVtb3J5X3JlZ2lvbiAqbWVtID0gb2JqLT5tbS5yZWdpb247Ci0Jc3RydWN0 IGxpc3RfaGVhZCAqYmxvY2tzID0gJm9iai0+bW0uYmxvY2tzOwotCXJlc291cmNlX3NpemVfdCBz aXplID0gb2JqLT5iYXNlLnNpemU7Ci0JcmVzb3VyY2Vfc2l6ZV90IHByZXZfZW5kOwotCXN0cnVj dCBpOTE1X2J1ZGR5X2Jsb2NrICpibG9jazsKLQl1bnNpZ25lZCBpbnQgZmxhZ3M7Ci0Jc3RydWN0 IHNnX3RhYmxlICpzdDsKLQlzdHJ1Y3Qgc2NhdHRlcmxpc3QgKnNnOwotCXVuc2lnbmVkIGludCBz Z19wYWdlX3NpemVzOwotCWludCByZXQ7Ci0KLQlzdCA9IGttYWxsb2Moc2l6ZW9mKCpzdCksIEdG UF9LRVJORUwpOwotCWlmICghc3QpCi0JCXJldHVybiAtRU5PTUVNOwotCi0JaWYgKHNnX2FsbG9j X3RhYmxlKHN0LCBzaXplID4+IFBBR0VfU0hJRlQsIEdGUF9LRVJORUwpKSB7Ci0JCWtmcmVlKHN0 KTsKLQkJcmV0dXJuIC1FTk9NRU07Ci0JfQotCi0JZmxhZ3MgPSBJOTE1X0FMTE9DX01JTl9QQUdF X1NJWkU7Ci0JaWYgKG9iai0+ZmxhZ3MgJiBJOTE1X0JPX0FMTE9DX0NPTlRJR1VPVVMpCi0JCWZs YWdzIHw9IEk5MTVfQUxMT0NfQ09OVElHVU9VUzsKLQotCXJldCA9IF9faW50ZWxfbWVtb3J5X3Jl Z2lvbl9nZXRfcGFnZXNfYnVkZHkobWVtLCBzaXplLCBmbGFncywgYmxvY2tzKTsKLQlpZiAocmV0 KQotCQlnb3RvIGVycl9mcmVlX3NnOwotCi0JR0VNX0JVR19PTihsaXN0X2VtcHR5KGJsb2Nrcykp OwotCi0Jc2cgPSBzdC0+c2dsOwotCXN0LT5uZW50cyA9IDA7Ci0Jc2dfcGFnZV9zaXplcyA9IDA7 Ci0JcHJldl9lbmQgPSAocmVzb3VyY2Vfc2l6ZV90KS0xOwotCi0JbGlzdF9mb3JfZWFjaF9lbnRy eShibG9jaywgYmxvY2tzLCBsaW5rKSB7Ci0JCXU2NCBibG9ja19zaXplLCBvZmZzZXQ7Ci0KLQkJ YmxvY2tfc2l6ZSA9IG1pbl90KHU2NCwgc2l6ZSwKLQkJCQkgICBpOTE1X2J1ZGR5X2Jsb2NrX3Np emUoJm1lbS0+bW0sIGJsb2NrKSk7Ci0JCW9mZnNldCA9IGk5MTVfYnVkZHlfYmxvY2tfb2Zmc2V0 KGJsb2NrKTsKLQotCQl3aGlsZSAoYmxvY2tfc2l6ZSkgewotCQkJdTY0IGxlbjsKLQotCQkJaWYg KG9mZnNldCAhPSBwcmV2X2VuZCB8fCBzZy0+bGVuZ3RoID49IG1heF9zZWdtZW50KSB7Ci0JCQkJ aWYgKHN0LT5uZW50cykgewotCQkJCQlzZ19wYWdlX3NpemVzIHw9IHNnLT5sZW5ndGg7Ci0JCQkJ CXNnID0gX19zZ19uZXh0KHNnKTsKLQkJCQl9Ci0KLQkJCQlzZ19kbWFfYWRkcmVzcyhzZykgPSBt ZW0tPnJlZ2lvbi5zdGFydCArIG9mZnNldDsKLQkJCQlzZ19kbWFfbGVuKHNnKSA9IDA7Ci0JCQkJ c2ctPmxlbmd0aCA9IDA7Ci0JCQkJc3QtPm5lbnRzKys7Ci0JCQl9Ci0KLQkJCWxlbiA9IG1pbihi bG9ja19zaXplLCBtYXhfc2VnbWVudCAtIHNnLT5sZW5ndGgpOwotCQkJc2ctPmxlbmd0aCArPSBs ZW47Ci0JCQlzZ19kbWFfbGVuKHNnKSArPSBsZW47Ci0KLQkJCW9mZnNldCArPSBsZW47Ci0JCQli bG9ja19zaXplIC09IGxlbjsKLQotCQkJcHJldl9lbmQgPSBvZmZzZXQ7Ci0JCX0KLQl9Ci0KLQlz Z19wYWdlX3NpemVzIHw9IHNnLT5sZW5ndGg7Ci0Jc2dfbWFya19lbmQoc2cpOwotCWk5MTVfc2df dHJpbShzdCk7Ci0KLQkvKiBJbnRlbmRlZCBmb3Iga2VybmVsIGludGVybmFsIHVzZSBvbmx5ICov Ci0JaWYgKG9iai0+ZmxhZ3MgJiBJOTE1X0JPX0FMTE9DX0NQVV9DTEVBUikgewotCQlzdHJ1Y3Qg c2NhdHRlcmxpc3QgKnNnOwotCQl1bnNpZ25lZCBsb25nIGk7Ci0KLQkJZm9yX2VhY2hfc2coc3Qt PnNnbCwgc2csIHN0LT5uZW50cywgaSkgewotCQkJdW5zaWduZWQgaW50IGxlbmd0aDsKLQkJCXZv aWQgX19pb21lbSAqdmFkZHI7Ci0JCQlkbWFfYWRkcl90IGRhZGRyOwotCi0JCQlkYWRkciA9IHNn X2RtYV9hZGRyZXNzKHNnKTsKLQkJCWRhZGRyIC09IG1lbS0+cmVnaW9uLnN0YXJ0OwotCQkJbGVu Z3RoID0gc2dfZG1hX2xlbihzZyk7Ci0KLQkJCXZhZGRyID0gaW9fbWFwcGluZ19tYXBfd2MoJm1l bS0+aW9tYXAsIGRhZGRyLCBsZW5ndGgpOwotCQkJbWVtc2V0NjQoKHZvaWQgX19mb3JjZSAqKXZh ZGRyLCAwLCBsZW5ndGggLyBzaXplb2YodTY0KSk7Ci0JCQlpb19tYXBwaW5nX3VubWFwKHZhZGRy KTsKLQkJfQotCi0JCXdtYigpOwotCX0KLQotCV9faTkxNV9nZW1fb2JqZWN0X3NldF9wYWdlcyhv YmosIHN0LCBzZ19wYWdlX3NpemVzKTsKLQotCXJldHVybiAwOwotCi1lcnJfZnJlZV9zZzoKLQlz Z19mcmVlX3RhYmxlKHN0KTsKLQlrZnJlZShzdCk7Ci0JcmV0dXJuIHJldDsKLX0KLQogdm9pZCBp OTE1X2dlbV9vYmplY3RfaW5pdF9tZW1vcnlfcmVnaW9uKHN0cnVjdCBkcm1faTkxNV9nZW1fb2Jq ZWN0ICpvYmosCiAJCQkJCXN0cnVjdCBpbnRlbF9tZW1vcnlfcmVnaW9uICptZW0pCiB7Ci0JSU5J VF9MSVNUX0hFQUQoJm9iai0+bW0uYmxvY2tzKTsKIAlvYmotPm1tLnJlZ2lvbiA9IGludGVsX21l bW9yeV9yZWdpb25fZ2V0KG1lbSk7CiAKIAlpZiAob2JqLT5iYXNlLnNpemUgPD0gbWVtLT5taW5f cGFnZV9zaXplKQpkaWZmIC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJtL2k5MTUvZ2VtL2k5MTVfZ2Vt X3JlZ2lvbi5oIGIvZHJpdmVycy9ncHUvZHJtL2k5MTUvZ2VtL2k5MTVfZ2VtX3JlZ2lvbi5oCmlu ZGV4IGViZGRjODZkNzhmNy4uODRmY2IzMjk3NDAwIDEwMDY0NAotLS0gYS9kcml2ZXJzL2dwdS9k cm0vaTkxNS9nZW0vaTkxNV9nZW1fcmVnaW9uLmgKKysrIGIvZHJpdmVycy9ncHUvZHJtL2k5MTUv Z2VtL2k5MTVfZ2VtX3JlZ2lvbi5oCkBAIC0xMiwxMCArMTIsNiBAQCBzdHJ1Y3QgaW50ZWxfbWVt b3J5X3JlZ2lvbjsKIHN0cnVjdCBkcm1faTkxNV9nZW1fb2JqZWN0Owogc3RydWN0IHNnX3RhYmxl OwogCi1pbnQgaTkxNV9nZW1fb2JqZWN0X2dldF9wYWdlc19idWRkeShzdHJ1Y3QgZHJtX2k5MTVf Z2VtX29iamVjdCAqb2JqKTsKLXZvaWQgaTkxNV9nZW1fb2JqZWN0X3B1dF9wYWdlc19idWRkeShz dHJ1Y3QgZHJtX2k5MTVfZ2VtX29iamVjdCAqb2JqLAotCQkJCSAgICAgc3RydWN0IHNnX3RhYmxl ICpwYWdlcyk7Ci0KIHZvaWQgaTkxNV9nZW1fb2JqZWN0X2luaXRfbWVtb3J5X3JlZ2lvbihzdHJ1 Y3QgZHJtX2k5MTVfZ2VtX29iamVjdCAqb2JqLAogCQkJCQlzdHJ1Y3QgaW50ZWxfbWVtb3J5X3Jl Z2lvbiAqbWVtKTsKIHZvaWQgaTkxNV9nZW1fb2JqZWN0X3JlbGVhc2VfbWVtb3J5X3JlZ2lvbihz dHJ1Y3QgZHJtX2k5MTVfZ2VtX29iamVjdCAqb2JqKTsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1 L2RybS9pOTE1L2dlbS9pOTE1X2dlbV9zaG1lbS5jIGIvZHJpdmVycy9ncHUvZHJtL2k5MTUvZ2Vt L2k5MTVfZ2VtX3NobWVtLmMKaW5kZXggYTliZmE2NmM4ZGExLi41ZDE2YzQ0NjJmZGEgMTAwNjQ0 Ci0tLSBhL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2dlbS9pOTE1X2dlbV9zaG1lbS5jCisrKyBiL2Ry aXZlcnMvZ3B1L2RybS9pOTE1L2dlbS9pOTE1X2dlbV9zaG1lbS5jCkBAIC02MjgsMTEgKzYyOCwx MyBAQCBzdGF0aWMgY29uc3Qgc3RydWN0IGludGVsX21lbW9yeV9yZWdpb25fb3BzIHNobWVtX3Jl Z2lvbl9vcHMgPSB7CiAJLmluaXRfb2JqZWN0ID0gc2htZW1fb2JqZWN0X2luaXQsCiB9OwogCi1z dHJ1Y3QgaW50ZWxfbWVtb3J5X3JlZ2lvbiAqaTkxNV9nZW1fc2htZW1fc2V0dXAoc3RydWN0IGRy bV9pOTE1X3ByaXZhdGUgKmk5MTUpCitzdHJ1Y3QgaW50ZWxfbWVtb3J5X3JlZ2lvbiAqaTkxNV9n ZW1fc2htZW1fc2V0dXAoc3RydWN0IGRybV9pOTE1X3ByaXZhdGUgKmk5MTUsCisJCQkJCQkgdTE2 IHR5cGUsIHUxNiBpbnN0YW5jZSkKIHsKIAlyZXR1cm4gaW50ZWxfbWVtb3J5X3JlZ2lvbl9jcmVh dGUoaTkxNSwgMCwKIAkJCQkJICB0b3RhbHJhbV9wYWdlcygpIDw8IFBBR0VfU0hJRlQsCiAJCQkJ CSAgUEFHRV9TSVpFLCAwLAorCQkJCQkgIHR5cGUsIGluc3RhbmNlLAogCQkJCQkgICZzaG1lbV9y ZWdpb25fb3BzKTsKIH0KIApkaWZmIC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJtL2k5MTUvZ2VtL2k5 MTVfZ2VtX3N0b2xlbi5jIGIvZHJpdmVycy9ncHUvZHJtL2k5MTUvZ2VtL2k5MTVfZ2VtX3N0b2xl bi5jCmluZGV4IDI5M2Y2NDBmYWEwYS4uYzQyYWJlZTIwNmRhIDEwMDY0NAotLS0gYS9kcml2ZXJz L2dwdS9kcm0vaTkxNS9nZW0vaTkxNV9nZW1fc3RvbGVuLmMKKysrIGIvZHJpdmVycy9ncHUvZHJt L2k5MTUvZ2VtL2k5MTVfZ2VtX3N0b2xlbi5jCkBAIC03NzAsNyArNzcwLDggQEAgc3RhdGljIGNv bnN0IHN0cnVjdCBpbnRlbF9tZW1vcnlfcmVnaW9uX29wcyBpOTE1X3JlZ2lvbl9zdG9sZW5fbG1l bV9vcHMgPSB7CiB9OwogCiBzdHJ1Y3QgaW50ZWxfbWVtb3J5X3JlZ2lvbiAqCi1pOTE1X2dlbV9z dG9sZW5fbG1lbV9zZXR1cChzdHJ1Y3QgZHJtX2k5MTVfcHJpdmF0ZSAqaTkxNSkKK2k5MTVfZ2Vt X3N0b2xlbl9sbWVtX3NldHVwKHN0cnVjdCBkcm1faTkxNV9wcml2YXRlICppOTE1LCB1MTYgdHlw ZSwKKwkJCSAgIHUxNiBpbnN0YW5jZSkKIHsKIAlzdHJ1Y3QgaW50ZWxfdW5jb3JlICp1bmNvcmUg PSAmaTkxNS0+dW5jb3JlOwogCXN0cnVjdCBwY2lfZGV2ICpwZGV2ID0gdG9fcGNpX2RldihpOTE1 LT5kcm0uZGV2KTsKQEAgLTc4OCw2ICs3ODksNyBAQCBpOTE1X2dlbV9zdG9sZW5fbG1lbV9zZXR1 cChzdHJ1Y3QgZHJtX2k5MTVfcHJpdmF0ZSAqaTkxNSkKIAogCW1lbSA9IGludGVsX21lbW9yeV9y ZWdpb25fY3JlYXRlKGk5MTUsIGxtZW1fYmFzZSwgbG1lbV9zaXplLAogCQkJCQkgSTkxNV9HVFRf UEFHRV9TSVpFXzRLLCBpb19zdGFydCwKKwkJCQkJIHR5cGUsIGluc3RhbmNlLAogCQkJCQkgJmk5 MTVfcmVnaW9uX3N0b2xlbl9sbWVtX29wcyk7CiAJaWYgKElTX0VSUihtZW0pKQogCQlyZXR1cm4g bWVtOwpAQCAtODA5LDE0ICs4MTEsMTUgQEAgaTkxNV9nZW1fc3RvbGVuX2xtZW1fc2V0dXAoc3Ry dWN0IGRybV9pOTE1X3ByaXZhdGUgKmk5MTUpCiB9CiAKIHN0cnVjdCBpbnRlbF9tZW1vcnlfcmVn aW9uKgotaTkxNV9nZW1fc3RvbGVuX3NtZW1fc2V0dXAoc3RydWN0IGRybV9pOTE1X3ByaXZhdGUg Kmk5MTUpCitpOTE1X2dlbV9zdG9sZW5fc21lbV9zZXR1cChzdHJ1Y3QgZHJtX2k5MTVfcHJpdmF0 ZSAqaTkxNSwgdTE2IHR5cGUsCisJCQkgICB1MTYgaW5zdGFuY2UpCiB7CiAJc3RydWN0IGludGVs X21lbW9yeV9yZWdpb24gKm1lbTsKIAogCW1lbSA9IGludGVsX21lbW9yeV9yZWdpb25fY3JlYXRl KGk5MTUsCiAJCQkJCSBpbnRlbF9ncmFwaGljc19zdG9sZW5fcmVzLnN0YXJ0LAogCQkJCQkgcmVz b3VyY2Vfc2l6ZSgmaW50ZWxfZ3JhcGhpY3Nfc3RvbGVuX3JlcyksCi0JCQkJCSBQQUdFX1NJWkUs IDAsCisJCQkJCSBQQUdFX1NJWkUsIDAsIHR5cGUsIGluc3RhbmNlLAogCQkJCQkgJmk5MTVfcmVn aW9uX3N0b2xlbl9zbWVtX29wcyk7CiAJaWYgKElTX0VSUihtZW0pKQogCQlyZXR1cm4gbWVtOwpA QCAtODI0LDcgKzgyNyw2IEBAIGk5MTVfZ2VtX3N0b2xlbl9zbWVtX3NldHVwKHN0cnVjdCBkcm1f aTkxNV9wcml2YXRlICppOTE1KQogCWludGVsX21lbW9yeV9yZWdpb25fc2V0X25hbWUobWVtLCAi c3RvbGVuLXN5c3RlbSIpOwogCiAJbWVtLT5wcml2YXRlID0gdHJ1ZTsKLQogCXJldHVybiBtZW07 CiB9CiAKZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2dlbS9pOTE1X2dlbV9zdG9s ZW4uaCBiL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2dlbS9pOTE1X2dlbV9zdG9sZW4uaAppbmRleCAy YmVjNmMzNjdiOWMuLmNjZGY3YmVmYzU3MSAxMDA2NDQKLS0tIGEvZHJpdmVycy9ncHUvZHJtL2k5 MTUvZ2VtL2k5MTVfZ2VtX3N0b2xlbi5oCisrKyBiL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2dlbS9p OTE1X2dlbV9zdG9sZW4uaApAQCAtMjEsOCArMjEsMTMgQEAgaW50IGk5MTVfZ2VtX3N0b2xlbl9p bnNlcnRfbm9kZV9pbl9yYW5nZShzdHJ1Y3QgZHJtX2k5MTVfcHJpdmF0ZSAqZGV2X3ByaXYsCiAJ CQkJCSB1NjQgZW5kKTsKIHZvaWQgaTkxNV9nZW1fc3RvbGVuX3JlbW92ZV9ub2RlKHN0cnVjdCBk cm1faTkxNV9wcml2YXRlICpkZXZfcHJpdiwKIAkJCQkgc3RydWN0IGRybV9tbV9ub2RlICpub2Rl KTsKLXN0cnVjdCBpbnRlbF9tZW1vcnlfcmVnaW9uICppOTE1X2dlbV9zdG9sZW5fc21lbV9zZXR1 cChzdHJ1Y3QgZHJtX2k5MTVfcHJpdmF0ZSAqaTkxNSk7Ci1zdHJ1Y3QgaW50ZWxfbWVtb3J5X3Jl Z2lvbiAqaTkxNV9nZW1fc3RvbGVuX2xtZW1fc2V0dXAoc3RydWN0IGRybV9pOTE1X3ByaXZhdGUg Kmk5MTUpOworc3RydWN0IGludGVsX21lbW9yeV9yZWdpb24gKgoraTkxNV9nZW1fc3RvbGVuX3Nt ZW1fc2V0dXAoc3RydWN0IGRybV9pOTE1X3ByaXZhdGUgKmk5MTUsIHUxNiB0eXBlLAorCQkJICAg dTE2IGluc3RhbmNlKTsKK3N0cnVjdCBpbnRlbF9tZW1vcnlfcmVnaW9uICoKK2k5MTVfZ2VtX3N0 b2xlbl9sbWVtX3NldHVwKHN0cnVjdCBkcm1faTkxNV9wcml2YXRlICppOTE1LCB1MTYgdHlwZSwK KwkJCSAgIHUxNiBpbnN0YW5jZSk7CisKIHN0cnVjdCBkcm1faTkxNV9nZW1fb2JqZWN0ICoKIGk5 MTVfZ2VtX29iamVjdF9jcmVhdGVfc3RvbGVuKHN0cnVjdCBkcm1faTkxNV9wcml2YXRlICpkZXZf cHJpdiwKIAkJCSAgICAgIHJlc291cmNlX3NpemVfdCBzaXplKTsKZGlmZiAtLWdpdCBhL2RyaXZl cnMvZ3B1L2RybS9pOTE1L2d0L2ludGVsX2d0LmMgYi9kcml2ZXJzL2dwdS9kcm0vaTkxNS9ndC9p bnRlbF9ndC5jCmluZGV4IDhkNzdkY2JhZDA1OS4uM2Y4OGVjZGVlMDMxIDEwMDY0NAotLS0gYS9k cml2ZXJzL2dwdS9kcm0vaTkxNS9ndC9pbnRlbF9ndC5jCisrKyBiL2RyaXZlcnMvZ3B1L2RybS9p OTE1L2d0L2ludGVsX2d0LmMKQEAgLTY4LDggKzY4LDYgQEAgaW50IGludGVsX2d0X3Byb2JlX2xt ZW0oc3RydWN0IGludGVsX2d0ICpndCkKIAlpZCA9IElOVEVMX1JFR0lPTl9MTUVNOwogCiAJbWVt LT5pZCA9IGlkOwotCW1lbS0+dHlwZSA9IElOVEVMX01FTU9SWV9MT0NBTDsKLQltZW0tPmluc3Rh bmNlID0gMDsKIAogCWludGVsX21lbW9yeV9yZWdpb25fc2V0X25hbWUobWVtLCAibG9jYWwldSIs IG1lbS0+aW5zdGFuY2UpOwogCmRpZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9kcm0vaTkxNS9ndC9p bnRlbF9yZWdpb25fbG1lbS5jIGIvZHJpdmVycy9ncHUvZHJtL2k5MTUvZ3QvaW50ZWxfcmVnaW9u X2xtZW0uYwppbmRleCA3M2ZjZWIwYzI1ZmMuLmY3MzY2YjA1NGY4ZSAxMDA2NDQKLS0tIGEvZHJp dmVycy9ncHUvZHJtL2k5MTUvZ3QvaW50ZWxfcmVnaW9uX2xtZW0uYworKysgYi9kcml2ZXJzL2dw dS9kcm0vaTkxNS9ndC9pbnRlbF9yZWdpb25fbG1lbS5jCkBAIC01LDYgKzUsOCBAQAogCiAjaW5j bHVkZSAiaTkxNV9kcnYuaCIKICNpbmNsdWRlICJpbnRlbF9tZW1vcnlfcmVnaW9uLmgiCisjaW5j bHVkZSAiaW50ZWxfcmVnaW9uX2xtZW0uaCIKKyNpbmNsdWRlICJpbnRlbF9yZWdpb25fdHRtLmgi CiAjaW5jbHVkZSAiZ2VtL2k5MTVfZ2VtX2xtZW0uaCIKICNpbmNsdWRlICJnZW0vaTkxNV9nZW1f cmVnaW9uLmgiCiAjaW5jbHVkZSAiaW50ZWxfcmVnaW9uX2xtZW0uaCIKQEAgLTY2LDkgKzY4LDkg QEAgc3RhdGljIHZvaWQgcmVsZWFzZV9mYWtlX2xtZW1fYmFyKHN0cnVjdCBpbnRlbF9tZW1vcnlf cmVnaW9uICptZW0pCiBzdGF0aWMgdm9pZAogcmVnaW9uX2xtZW1fcmVsZWFzZShzdHJ1Y3QgaW50 ZWxfbWVtb3J5X3JlZ2lvbiAqbWVtKQogewotCXJlbGVhc2VfZmFrZV9sbWVtX2JhcihtZW0pOwor CWludGVsX3JlZ2lvbl90dG1fZmluaShtZW0pOwogCWlvX21hcHBpbmdfZmluaSgmbWVtLT5pb21h cCk7Ci0JaW50ZWxfbWVtb3J5X3JlZ2lvbl9yZWxlYXNlX2J1ZGR5KG1lbSk7CisJcmVsZWFzZV9m YWtlX2xtZW1fYmFyKG1lbSk7CiB9CiAKIHN0YXRpYyBpbnQKQEAgLTgzLDEyICs4NSwyMSBAQCBy ZWdpb25fbG1lbV9pbml0KHN0cnVjdCBpbnRlbF9tZW1vcnlfcmVnaW9uICptZW0pCiAKIAlpZiAo IWlvX21hcHBpbmdfaW5pdF93YygmbWVtLT5pb21hcCwKIAkJCQltZW0tPmlvX3N0YXJ0LAotCQkJ CXJlc291cmNlX3NpemUoJm1lbS0+cmVnaW9uKSkpCi0JCXJldHVybiAtRUlPOworCQkJCXJlc291 cmNlX3NpemUoJm1lbS0+cmVnaW9uKSkpIHsKKwkJcmV0ID0gLUVJTzsKKwkJZ290byBvdXRfbm9f aW87CisJfQogCi0JcmV0ID0gaW50ZWxfbWVtb3J5X3JlZ2lvbl9pbml0X2J1ZGR5KG1lbSk7CisJ cmV0ID0gaW50ZWxfcmVnaW9uX3R0bV9pbml0KG1lbSk7CiAJaWYgKHJldCkKLQkJaW9fbWFwcGlu Z19maW5pKCZtZW0tPmlvbWFwKTsKKwkJZ290byBvdXRfbm9fYnVkZHk7CisKKwlyZXR1cm4gMDsK Kworb3V0X25vX2J1ZGR5OgorCWlvX21hcHBpbmdfZmluaSgmbWVtLT5pb21hcCk7CitvdXRfbm9f aW86CisJcmVsZWFzZV9mYWtlX2xtZW1fYmFyKG1lbSk7CiAKIAlyZXR1cm4gcmV0OwogfQpAQCAt MTI3LDYgKzEzOCw4IEBAIGludGVsX2d0X3NldHVwX2Zha2VfbG1lbShzdHJ1Y3QgaW50ZWxfZ3Qg Kmd0KQogCQkJCQkgbWFwcGFibGVfZW5kLAogCQkJCQkgUEFHRV9TSVpFLAogCQkJCQkgaW9fc3Rh cnQsCisJCQkJCSBJTlRFTF9NRU1PUllfTE9DQUwsCisJCQkJCSAwLAogCQkJCQkgJmludGVsX3Jl Z2lvbl9sbWVtX29wcyk7CiAJaWYgKCFJU19FUlIobWVtKSkgewogCQlkcm1faW5mbygmaTkxNS0+ ZHJtLCAiSW50ZWwgZ3JhcGhpY3MgZmFrZSBMTUVNOiAlcFJcbiIsCkBAIC0xOTgsNiArMjExLDgg QEAgc3RhdGljIHN0cnVjdCBpbnRlbF9tZW1vcnlfcmVnaW9uICpzZXR1cF9sbWVtKHN0cnVjdCBp bnRlbF9ndCAqZ3QpCiAJCQkJCSBsbWVtX3NpemUsCiAJCQkJCSBJOTE1X0dUVF9QQUdFX1NJWkVf NEssCiAJCQkJCSBpb19zdGFydCwKKwkJCQkJIElOVEVMX01FTU9SWV9MT0NBTCwKKwkJCQkJIDAs CiAJCQkJCSAmaW50ZWxfcmVnaW9uX2xtZW1fb3BzKTsKIAlpZiAoSVNfRVJSKG1lbSkpCiAJCXJl dHVybiBtZW07CmRpZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9kcm0vaTkxNS9pOTE1X2J1ZGR5LmMg Yi9kcml2ZXJzL2dwdS9kcm0vaTkxNS9pOTE1X2J1ZGR5LmMKZGVsZXRlZCBmaWxlIG1vZGUgMTAw NjQ0CmluZGV4IDNhMmY2ZWVjYjJmYy4uMDAwMDAwMDAwMDAwCi0tLSBhL2RyaXZlcnMvZ3B1L2Ry bS9pOTE1L2k5MTVfYnVkZHkuYworKysgL2Rldi9udWxsCkBAIC0xLDQzNSArMCwwIEBACi0vLyBT UERYLUxpY2Vuc2UtSWRlbnRpZmllcjogTUlUCi0vKgotICogQ29weXJpZ2h0IMKpIDIwMTkgSW50 ZWwgQ29ycG9yYXRpb24KLSAqLwotCi0jaW5jbHVkZSA8bGludXgva21lbWxlYWsuaD4KLSNpbmNs dWRlIDxsaW51eC9zbGFiLmg+Ci0KLSNpbmNsdWRlICJpOTE1X2J1ZGR5LmgiCi0KLSNpbmNsdWRl ICJpOTE1X2dlbS5oIgotI2luY2x1ZGUgImk5MTVfZ2xvYmFscy5oIgotI2luY2x1ZGUgImk5MTVf dXRpbHMuaCIKLQotc3RhdGljIHN0cnVjdCBpOTE1X2dsb2JhbF9ibG9jayB7Ci0Jc3RydWN0IGk5 MTVfZ2xvYmFsIGJhc2U7Ci0Jc3RydWN0IGttZW1fY2FjaGUgKnNsYWJfYmxvY2tzOwotfSBnbG9i YWw7Ci0KLXN0YXRpYyB2b2lkIGk5MTVfZ2xvYmFsX2J1ZGR5X3Nocmluayh2b2lkKQotewotCWtt ZW1fY2FjaGVfc2hyaW5rKGdsb2JhbC5zbGFiX2Jsb2Nrcyk7Ci19Ci0KLXN0YXRpYyB2b2lkIGk5 MTVfZ2xvYmFsX2J1ZGR5X2V4aXQodm9pZCkKLXsKLQlrbWVtX2NhY2hlX2Rlc3Ryb3koZ2xvYmFs LnNsYWJfYmxvY2tzKTsKLX0KLQotc3RhdGljIHN0cnVjdCBpOTE1X2dsb2JhbF9ibG9jayBnbG9i YWwgPSB7IHsKLQkuc2hyaW5rID0gaTkxNV9nbG9iYWxfYnVkZHlfc2hyaW5rLAotCS5leGl0ID0g aTkxNV9nbG9iYWxfYnVkZHlfZXhpdCwKLX0gfTsKLQotaW50IF9faW5pdCBpOTE1X2dsb2JhbF9i dWRkeV9pbml0KHZvaWQpCi17Ci0JZ2xvYmFsLnNsYWJfYmxvY2tzID0gS01FTV9DQUNIRShpOTE1 X2J1ZGR5X2Jsb2NrLCBTTEFCX0hXQ0FDSEVfQUxJR04pOwotCWlmICghZ2xvYmFsLnNsYWJfYmxv Y2tzKQotCQlyZXR1cm4gLUVOT01FTTsKLQotCWk5MTVfZ2xvYmFsX3JlZ2lzdGVyKCZnbG9iYWwu YmFzZSk7Ci0JcmV0dXJuIDA7Ci19Ci0KLXN0YXRpYyBzdHJ1Y3QgaTkxNV9idWRkeV9ibG9jayAq aTkxNV9ibG9ja19hbGxvYyhzdHJ1Y3QgaTkxNV9idWRkeV9ibG9jayAqcGFyZW50LAotCQkJCQkJ IHVuc2lnbmVkIGludCBvcmRlciwKLQkJCQkJCSB1NjQgb2Zmc2V0KQotewotCXN0cnVjdCBpOTE1 X2J1ZGR5X2Jsb2NrICpibG9jazsKLQotCUdFTV9CVUdfT04ob3JkZXIgPiBJOTE1X0JVRERZX01B WF9PUkRFUik7Ci0KLQlibG9jayA9IGttZW1fY2FjaGVfemFsbG9jKGdsb2JhbC5zbGFiX2Jsb2Nr cywgR0ZQX0tFUk5FTCk7Ci0JaWYgKCFibG9jaykKLQkJcmV0dXJuIE5VTEw7Ci0KLQlibG9jay0+ aGVhZGVyID0gb2Zmc2V0OwotCWJsb2NrLT5oZWFkZXIgfD0gb3JkZXI7Ci0JYmxvY2stPnBhcmVu dCA9IHBhcmVudDsKLQotCUdFTV9CVUdfT04oYmxvY2stPmhlYWRlciAmIEk5MTVfQlVERFlfSEVB REVSX1VOVVNFRCk7Ci0JcmV0dXJuIGJsb2NrOwotfQotCi1zdGF0aWMgdm9pZCBpOTE1X2Jsb2Nr X2ZyZWUoc3RydWN0IGk5MTVfYnVkZHlfYmxvY2sgKmJsb2NrKQotewotCWttZW1fY2FjaGVfZnJl ZShnbG9iYWwuc2xhYl9ibG9ja3MsIGJsb2NrKTsKLX0KLQotc3RhdGljIHZvaWQgbWFya19hbGxv Y2F0ZWQoc3RydWN0IGk5MTVfYnVkZHlfYmxvY2sgKmJsb2NrKQotewotCWJsb2NrLT5oZWFkZXIg Jj0gfkk5MTVfQlVERFlfSEVBREVSX1NUQVRFOwotCWJsb2NrLT5oZWFkZXIgfD0gSTkxNV9CVURE WV9BTExPQ0FURUQ7Ci0KLQlsaXN0X2RlbCgmYmxvY2stPmxpbmspOwotfQotCi1zdGF0aWMgdm9p ZCBtYXJrX2ZyZWUoc3RydWN0IGk5MTVfYnVkZHlfbW0gKm1tLAotCQkgICAgICBzdHJ1Y3QgaTkx NV9idWRkeV9ibG9jayAqYmxvY2spCi17Ci0JYmxvY2stPmhlYWRlciAmPSB+STkxNV9CVUREWV9I RUFERVJfU1RBVEU7Ci0JYmxvY2stPmhlYWRlciB8PSBJOTE1X0JVRERZX0ZSRUU7Ci0KLQlsaXN0 X2FkZCgmYmxvY2stPmxpbmssCi0JCSAmbW0tPmZyZWVfbGlzdFtpOTE1X2J1ZGR5X2Jsb2NrX29y ZGVyKGJsb2NrKV0pOwotfQotCi1zdGF0aWMgdm9pZCBtYXJrX3NwbGl0KHN0cnVjdCBpOTE1X2J1 ZGR5X2Jsb2NrICpibG9jaykKLXsKLQlibG9jay0+aGVhZGVyICY9IH5JOTE1X0JVRERZX0hFQURF Ul9TVEFURTsKLQlibG9jay0+aGVhZGVyIHw9IEk5MTVfQlVERFlfU1BMSVQ7Ci0KLQlsaXN0X2Rl bCgmYmxvY2stPmxpbmspOwotfQotCi1pbnQgaTkxNV9idWRkeV9pbml0KHN0cnVjdCBpOTE1X2J1 ZGR5X21tICptbSwgdTY0IHNpemUsIHU2NCBjaHVua19zaXplKQotewotCXVuc2lnbmVkIGludCBp OwotCXU2NCBvZmZzZXQ7Ci0KLQlpZiAoc2l6ZSA8IGNodW5rX3NpemUpCi0JCXJldHVybiAtRUlO VkFMOwotCi0JaWYgKGNodW5rX3NpemUgPCBQQUdFX1NJWkUpCi0JCXJldHVybiAtRUlOVkFMOwot Ci0JaWYgKCFpc19wb3dlcl9vZl8yKGNodW5rX3NpemUpKQotCQlyZXR1cm4gLUVJTlZBTDsKLQot CXNpemUgPSByb3VuZF9kb3duKHNpemUsIGNodW5rX3NpemUpOwotCi0JbW0tPnNpemUgPSBzaXpl OwotCW1tLT5jaHVua19zaXplID0gY2h1bmtfc2l6ZTsKLQltbS0+bWF4X29yZGVyID0gaWxvZzIo c2l6ZSkgLSBpbG9nMihjaHVua19zaXplKTsKLQotCUdFTV9CVUdfT04obW0tPm1heF9vcmRlciA+ IEk5MTVfQlVERFlfTUFYX09SREVSKTsKLQotCW1tLT5mcmVlX2xpc3QgPSBrbWFsbG9jX2FycmF5 KG1tLT5tYXhfb3JkZXIgKyAxLAotCQkJCSAgICAgIHNpemVvZihzdHJ1Y3QgbGlzdF9oZWFkKSwK LQkJCQkgICAgICBHRlBfS0VSTkVMKTsKLQlpZiAoIW1tLT5mcmVlX2xpc3QpCi0JCXJldHVybiAt RU5PTUVNOwotCi0JZm9yIChpID0gMDsgaSA8PSBtbS0+bWF4X29yZGVyOyArK2kpCi0JCUlOSVRf TElTVF9IRUFEKCZtbS0+ZnJlZV9saXN0W2ldKTsKLQotCW1tLT5uX3Jvb3RzID0gaHdlaWdodDY0 KHNpemUpOwotCi0JbW0tPnJvb3RzID0ga21hbGxvY19hcnJheShtbS0+bl9yb290cywKLQkJCQkg IHNpemVvZihzdHJ1Y3QgaTkxNV9idWRkeV9ibG9jayAqKSwKLQkJCQkgIEdGUF9LRVJORUwpOwot CWlmICghbW0tPnJvb3RzKQotCQlnb3RvIG91dF9mcmVlX2xpc3Q7Ci0KLQlvZmZzZXQgPSAwOwot CWkgPSAwOwotCi0JLyoKLQkgKiBTcGxpdCBpbnRvIHBvd2VyLW9mLXR3byBibG9ja3MsIGluIGNh c2Ugd2UgYXJlIGdpdmVuIGEgc2l6ZSB0aGF0IGlzCi0JICogbm90IGl0c2VsZiBhIHBvd2VyLW9m LXR3by4KLQkgKi8KLQlkbyB7Ci0JCXN0cnVjdCBpOTE1X2J1ZGR5X2Jsb2NrICpyb290OwotCQl1 bnNpZ25lZCBpbnQgb3JkZXI7Ci0JCXU2NCByb290X3NpemU7Ci0KLQkJcm9vdF9zaXplID0gcm91 bmRkb3duX3Bvd19vZl90d28oc2l6ZSk7Ci0JCW9yZGVyID0gaWxvZzIocm9vdF9zaXplKSAtIGls b2cyKGNodW5rX3NpemUpOwotCi0JCXJvb3QgPSBpOTE1X2Jsb2NrX2FsbG9jKE5VTEwsIG9yZGVy LCBvZmZzZXQpOwotCQlpZiAoIXJvb3QpCi0JCQlnb3RvIG91dF9mcmVlX3Jvb3RzOwotCi0JCW1h cmtfZnJlZShtbSwgcm9vdCk7Ci0KLQkJR0VNX0JVR19PTihpID4gbW0tPm1heF9vcmRlcik7Ci0J CUdFTV9CVUdfT04oaTkxNV9idWRkeV9ibG9ja19zaXplKG1tLCByb290KSA8IGNodW5rX3NpemUp OwotCi0JCW1tLT5yb290c1tpXSA9IHJvb3Q7Ci0KLQkJb2Zmc2V0ICs9IHJvb3Rfc2l6ZTsKLQkJ c2l6ZSAtPSByb290X3NpemU7Ci0JCWkrKzsKLQl9IHdoaWxlIChzaXplKTsKLQotCXJldHVybiAw OwotCi1vdXRfZnJlZV9yb290czoKLQl3aGlsZSAoaS0tKQotCQlpOTE1X2Jsb2NrX2ZyZWUobW0t PnJvb3RzW2ldKTsKLQlrZnJlZShtbS0+cm9vdHMpOwotb3V0X2ZyZWVfbGlzdDoKLQlrZnJlZSht bS0+ZnJlZV9saXN0KTsKLQlyZXR1cm4gLUVOT01FTTsKLX0KLQotdm9pZCBpOTE1X2J1ZGR5X2Zp bmkoc3RydWN0IGk5MTVfYnVkZHlfbW0gKm1tKQotewotCWludCBpOwotCi0JZm9yIChpID0gMDsg aSA8IG1tLT5uX3Jvb3RzOyArK2kpIHsKLQkJR0VNX1dBUk5fT04oIWk5MTVfYnVkZHlfYmxvY2tf aXNfZnJlZShtbS0+cm9vdHNbaV0pKTsKLQkJaTkxNV9ibG9ja19mcmVlKG1tLT5yb290c1tpXSk7 Ci0JfQotCi0Ja2ZyZWUobW0tPnJvb3RzKTsKLQlrZnJlZShtbS0+ZnJlZV9saXN0KTsKLX0KLQot c3RhdGljIGludCBzcGxpdF9ibG9jayhzdHJ1Y3QgaTkxNV9idWRkeV9tbSAqbW0sCi0JCSAgICAg ICBzdHJ1Y3QgaTkxNV9idWRkeV9ibG9jayAqYmxvY2spCi17Ci0JdW5zaWduZWQgaW50IGJsb2Nr X29yZGVyID0gaTkxNV9idWRkeV9ibG9ja19vcmRlcihibG9jaykgLSAxOwotCXU2NCBvZmZzZXQg PSBpOTE1X2J1ZGR5X2Jsb2NrX29mZnNldChibG9jayk7Ci0KLQlHRU1fQlVHX09OKCFpOTE1X2J1 ZGR5X2Jsb2NrX2lzX2ZyZWUoYmxvY2spKTsKLQlHRU1fQlVHX09OKCFpOTE1X2J1ZGR5X2Jsb2Nr X29yZGVyKGJsb2NrKSk7Ci0KLQlibG9jay0+bGVmdCA9IGk5MTVfYmxvY2tfYWxsb2MoYmxvY2ss IGJsb2NrX29yZGVyLCBvZmZzZXQpOwotCWlmICghYmxvY2stPmxlZnQpCi0JCXJldHVybiAtRU5P TUVNOwotCi0JYmxvY2stPnJpZ2h0ID0gaTkxNV9ibG9ja19hbGxvYyhibG9jaywgYmxvY2tfb3Jk ZXIsCi0JCQkJCW9mZnNldCArIChtbS0+Y2h1bmtfc2l6ZSA8PCBibG9ja19vcmRlcikpOwotCWlm ICghYmxvY2stPnJpZ2h0KSB7Ci0JCWk5MTVfYmxvY2tfZnJlZShibG9jay0+bGVmdCk7Ci0JCXJl dHVybiAtRU5PTUVNOwotCX0KLQotCW1hcmtfZnJlZShtbSwgYmxvY2stPmxlZnQpOwotCW1hcmtf ZnJlZShtbSwgYmxvY2stPnJpZ2h0KTsKLQotCW1hcmtfc3BsaXQoYmxvY2spOwotCi0JcmV0dXJu IDA7Ci19Ci0KLXN0YXRpYyBzdHJ1Y3QgaTkxNV9idWRkeV9ibG9jayAqCi1nZXRfYnVkZHkoc3Ry dWN0IGk5MTVfYnVkZHlfYmxvY2sgKmJsb2NrKQotewotCXN0cnVjdCBpOTE1X2J1ZGR5X2Jsb2Nr ICpwYXJlbnQ7Ci0KLQlwYXJlbnQgPSBibG9jay0+cGFyZW50OwotCWlmICghcGFyZW50KQotCQly ZXR1cm4gTlVMTDsKLQotCWlmIChwYXJlbnQtPmxlZnQgPT0gYmxvY2spCi0JCXJldHVybiBwYXJl bnQtPnJpZ2h0OwotCi0JcmV0dXJuIHBhcmVudC0+bGVmdDsKLX0KLQotc3RhdGljIHZvaWQgX19p OTE1X2J1ZGR5X2ZyZWUoc3RydWN0IGk5MTVfYnVkZHlfbW0gKm1tLAotCQkJICAgICAgc3RydWN0 IGk5MTVfYnVkZHlfYmxvY2sgKmJsb2NrKQotewotCXN0cnVjdCBpOTE1X2J1ZGR5X2Jsb2NrICpw YXJlbnQ7Ci0KLQl3aGlsZSAoKHBhcmVudCA9IGJsb2NrLT5wYXJlbnQpKSB7Ci0JCXN0cnVjdCBp OTE1X2J1ZGR5X2Jsb2NrICpidWRkeTsKLQotCQlidWRkeSA9IGdldF9idWRkeShibG9jayk7Ci0K LQkJaWYgKCFpOTE1X2J1ZGR5X2Jsb2NrX2lzX2ZyZWUoYnVkZHkpKQotCQkJYnJlYWs7Ci0KLQkJ bGlzdF9kZWwoJmJ1ZGR5LT5saW5rKTsKLQotCQlpOTE1X2Jsb2NrX2ZyZWUoYmxvY2spOwotCQlp OTE1X2Jsb2NrX2ZyZWUoYnVkZHkpOwotCi0JCWJsb2NrID0gcGFyZW50OwotCX0KLQotCW1hcmtf ZnJlZShtbSwgYmxvY2spOwotfQotCi12b2lkIGk5MTVfYnVkZHlfZnJlZShzdHJ1Y3QgaTkxNV9i dWRkeV9tbSAqbW0sCi0JCSAgICAgc3RydWN0IGk5MTVfYnVkZHlfYmxvY2sgKmJsb2NrKQotewot CUdFTV9CVUdfT04oIWk5MTVfYnVkZHlfYmxvY2tfaXNfYWxsb2NhdGVkKGJsb2NrKSk7Ci0JX19p OTE1X2J1ZGR5X2ZyZWUobW0sIGJsb2NrKTsKLX0KLQotdm9pZCBpOTE1X2J1ZGR5X2ZyZWVfbGlz dChzdHJ1Y3QgaTkxNV9idWRkeV9tbSAqbW0sIHN0cnVjdCBsaXN0X2hlYWQgKm9iamVjdHMpCi17 Ci0Jc3RydWN0IGk5MTVfYnVkZHlfYmxvY2sgKmJsb2NrLCAqb247Ci0KLQlsaXN0X2Zvcl9lYWNo X2VudHJ5X3NhZmUoYmxvY2ssIG9uLCBvYmplY3RzLCBsaW5rKSB7Ci0JCWk5MTVfYnVkZHlfZnJl ZShtbSwgYmxvY2spOwotCQljb25kX3Jlc2NoZWQoKTsKLQl9Ci0JSU5JVF9MSVNUX0hFQUQob2Jq ZWN0cyk7Ci19Ci0KLS8qCi0gKiBBbGxvY2F0ZSBwb3dlci1vZi10d28gYmxvY2suIFRoZSBvcmRl ciB2YWx1ZSBoZXJlIHRyYW5zbGF0ZXMgdG86Ci0gKgotICogICAwID0gMl4wICogbW0tPmNodW5r X3NpemUKLSAqICAgMSA9IDJeMSAqIG1tLT5jaHVua19zaXplCi0gKiAgIDIgPSAyXjIgKiBtbS0+ Y2h1bmtfc2l6ZQotICogICAuLi4KLSAqLwotc3RydWN0IGk5MTVfYnVkZHlfYmxvY2sgKgotaTkx NV9idWRkeV9hbGxvYyhzdHJ1Y3QgaTkxNV9idWRkeV9tbSAqbW0sIHVuc2lnbmVkIGludCBvcmRl cikKLXsKLQlzdHJ1Y3QgaTkxNV9idWRkeV9ibG9jayAqYmxvY2sgPSBOVUxMOwotCXVuc2lnbmVk IGludCBpOwotCWludCBlcnI7Ci0KLQlmb3IgKGkgPSBvcmRlcjsgaSA8PSBtbS0+bWF4X29yZGVy OyArK2kpIHsKLQkJYmxvY2sgPSBsaXN0X2ZpcnN0X2VudHJ5X29yX251bGwoJm1tLT5mcmVlX2xp c3RbaV0sCi0JCQkJCQkgc3RydWN0IGk5MTVfYnVkZHlfYmxvY2ssCi0JCQkJCQkgbGluayk7Ci0J CWlmIChibG9jaykKLQkJCWJyZWFrOwotCX0KLQotCWlmICghYmxvY2spCi0JCXJldHVybiBFUlJf UFRSKC1FTk9TUEMpOwotCi0JR0VNX0JVR19PTighaTkxNV9idWRkeV9ibG9ja19pc19mcmVlKGJs b2NrKSk7Ci0KLQl3aGlsZSAoaSAhPSBvcmRlcikgewotCQllcnIgPSBzcGxpdF9ibG9jayhtbSwg YmxvY2spOwotCQlpZiAodW5saWtlbHkoZXJyKSkKLQkJCWdvdG8gb3V0X2ZyZWU7Ci0KLQkJLyog R28gbG93ICovCi0JCWJsb2NrID0gYmxvY2stPmxlZnQ7Ci0JCWktLTsKLQl9Ci0KLQltYXJrX2Fs bG9jYXRlZChibG9jayk7Ci0Ja21lbWxlYWtfdXBkYXRlX3RyYWNlKGJsb2NrKTsKLQlyZXR1cm4g YmxvY2s7Ci0KLW91dF9mcmVlOgotCWlmIChpICE9IG9yZGVyKQotCQlfX2k5MTVfYnVkZHlfZnJl ZShtbSwgYmxvY2spOwotCXJldHVybiBFUlJfUFRSKGVycik7Ci19Ci0KLXN0YXRpYyBpbmxpbmUg Ym9vbCBvdmVybGFwcyh1NjQgczEsIHU2NCBlMSwgdTY0IHMyLCB1NjQgZTIpCi17Ci0JcmV0dXJu IHMxIDw9IGUyICYmIGUxID49IHMyOwotfQotCi1zdGF0aWMgaW5saW5lIGJvb2wgY29udGFpbnMo dTY0IHMxLCB1NjQgZTEsIHU2NCBzMiwgdTY0IGUyKQotewotCXJldHVybiBzMSA8PSBzMiAmJiBl MSA+PSBlMjsKLX0KLQotLyoKLSAqIEFsbG9jYXRlIHJhbmdlLiBOb3RlIHRoYXQgaXQncyBzYWZl IHRvIGNoYWluIHRvZ2V0aGVyIG11bHRpcGxlIGFsbG9jX3JhbmdlcwotICogd2l0aCB0aGUgc2Ft ZSBibG9ja3MgbGlzdC4KLSAqCi0gKiBJbnRlbmRlZCBmb3IgcHJlLWFsbG9jYXRpbmcgcG9ydGlv bnMgb2YgdGhlIGFkZHJlc3Mgc3BhY2UsIGZvciBleGFtcGxlIHRvCi0gKiByZXNlcnZlIGEgYmxv Y2sgZm9yIHRoZSBpbml0aWFsIGZyYW1lYnVmZmVyIG9yIHNpbWlsYXIsIGhlbmNlIHRoZSBleHBl Y3RhdGlvbgotICogaGVyZSBpcyB0aGF0IGk5MTVfYnVkZHlfYWxsb2MoKSBpcyBzdGlsbCB0aGUg bWFpbiB2ZWhpY2xlIGZvcgotICogYWxsb2NhdGlvbnMsIHNvIGlmIHRoYXQncyBub3QgdGhlIGNh c2UgdGhlbiB0aGUgZHJtX21tIHJhbmdlIGFsbG9jYXRvciBpcwotICogcHJvYmFibHkgYSBtdWNo IGJldHRlciBmaXQsIGFuZCBzbyB5b3Ugc2hvdWxkIHByb2JhYmx5IGdvIHVzZSB0aGF0IGluc3Rl YWQuCi0gKi8KLWludCBpOTE1X2J1ZGR5X2FsbG9jX3JhbmdlKHN0cnVjdCBpOTE1X2J1ZGR5X21t ICptbSwKLQkJCSAgIHN0cnVjdCBsaXN0X2hlYWQgKmJsb2NrcywKLQkJCSAgIHU2NCBzdGFydCwg dTY0IHNpemUpCi17Ci0Jc3RydWN0IGk5MTVfYnVkZHlfYmxvY2sgKmJsb2NrOwotCXN0cnVjdCBp OTE1X2J1ZGR5X2Jsb2NrICpidWRkeTsKLQlMSVNUX0hFQUQoYWxsb2NhdGVkKTsKLQlMSVNUX0hF QUQoZGZzKTsKLQl1NjQgZW5kOwotCWludCBlcnI7Ci0JaW50IGk7Ci0KLQlpZiAoc2l6ZSA8IG1t LT5jaHVua19zaXplKQotCQlyZXR1cm4gLUVJTlZBTDsKLQotCWlmICghSVNfQUxJR05FRChzaXpl IHwgc3RhcnQsIG1tLT5jaHVua19zaXplKSkKLQkJcmV0dXJuIC1FSU5WQUw7Ci0KLQlpZiAocmFu Z2Vfb3ZlcmZsb3dzKHN0YXJ0LCBzaXplLCBtbS0+c2l6ZSkpCi0JCXJldHVybiAtRUlOVkFMOwot Ci0JZm9yIChpID0gMDsgaSA8IG1tLT5uX3Jvb3RzOyArK2kpCi0JCWxpc3RfYWRkX3RhaWwoJm1t LT5yb290c1tpXS0+dG1wX2xpbmssICZkZnMpOwotCi0JZW5kID0gc3RhcnQgKyBzaXplIC0gMTsK LQotCWRvIHsKLQkJdTY0IGJsb2NrX3N0YXJ0OwotCQl1NjQgYmxvY2tfZW5kOwotCi0JCWJsb2Nr ID0gbGlzdF9maXJzdF9lbnRyeV9vcl9udWxsKCZkZnMsCi0JCQkJCQkgc3RydWN0IGk5MTVfYnVk ZHlfYmxvY2ssCi0JCQkJCQkgdG1wX2xpbmspOwotCQlpZiAoIWJsb2NrKQotCQkJYnJlYWs7Ci0K LQkJbGlzdF9kZWwoJmJsb2NrLT50bXBfbGluayk7Ci0KLQkJYmxvY2tfc3RhcnQgPSBpOTE1X2J1 ZGR5X2Jsb2NrX29mZnNldChibG9jayk7Ci0JCWJsb2NrX2VuZCA9IGJsb2NrX3N0YXJ0ICsgaTkx NV9idWRkeV9ibG9ja19zaXplKG1tLCBibG9jaykgLSAxOwotCi0JCWlmICghb3ZlcmxhcHMoc3Rh cnQsIGVuZCwgYmxvY2tfc3RhcnQsIGJsb2NrX2VuZCkpCi0JCQljb250aW51ZTsKLQotCQlpZiAo aTkxNV9idWRkeV9ibG9ja19pc19hbGxvY2F0ZWQoYmxvY2spKSB7Ci0JCQllcnIgPSAtRU5PU1BD OwotCQkJZ290byBlcnJfZnJlZTsKLQkJfQotCi0JCWlmIChjb250YWlucyhzdGFydCwgZW5kLCBi bG9ja19zdGFydCwgYmxvY2tfZW5kKSkgewotCQkJaWYgKCFpOTE1X2J1ZGR5X2Jsb2NrX2lzX2Zy ZWUoYmxvY2spKSB7Ci0JCQkJZXJyID0gLUVOT1NQQzsKLQkJCQlnb3RvIGVycl9mcmVlOwotCQkJ fQotCi0JCQltYXJrX2FsbG9jYXRlZChibG9jayk7Ci0JCQlsaXN0X2FkZF90YWlsKCZibG9jay0+ bGluaywgJmFsbG9jYXRlZCk7Ci0JCQljb250aW51ZTsKLQkJfQotCi0JCWlmICghaTkxNV9idWRk eV9ibG9ja19pc19zcGxpdChibG9jaykpIHsKLQkJCWVyciA9IHNwbGl0X2Jsb2NrKG1tLCBibG9j ayk7Ci0JCQlpZiAodW5saWtlbHkoZXJyKSkKLQkJCQlnb3RvIGVycl91bmRvOwotCQl9Ci0KLQkJ bGlzdF9hZGQoJmJsb2NrLT5yaWdodC0+dG1wX2xpbmssICZkZnMpOwotCQlsaXN0X2FkZCgmYmxv Y2stPmxlZnQtPnRtcF9saW5rLCAmZGZzKTsKLQl9IHdoaWxlICgxKTsKLQotCWxpc3Rfc3BsaWNl X3RhaWwoJmFsbG9jYXRlZCwgYmxvY2tzKTsKLQlyZXR1cm4gMDsKLQotZXJyX3VuZG86Ci0JLyoK LQkgKiBXZSByZWFsbHkgZG9uJ3Qgd2FudCB0byBsZWF2ZSBhcm91bmQgYSBidW5jaCBvZiBzcGxp dCBibG9ja3MsIHNpbmNlCi0JICogYmlnZ2VyIGlzIGJldHRlciwgc28gbWFrZSBzdXJlIHdlIG1l cmdlIGV2ZXJ5dGhpbmcgYmFjayBiZWZvcmUgd2UKLQkgKiBmcmVlIHRoZSBhbGxvY2F0ZWQgYmxv Y2tzLgotCSAqLwotCWJ1ZGR5ID0gZ2V0X2J1ZGR5KGJsb2NrKTsKLQlpZiAoYnVkZHkgJiYKLQkg ICAgKGk5MTVfYnVkZHlfYmxvY2tfaXNfZnJlZShibG9jaykgJiYKLQkgICAgIGk5MTVfYnVkZHlf YmxvY2tfaXNfZnJlZShidWRkeSkpKQotCQlfX2k5MTVfYnVkZHlfZnJlZShtbSwgYmxvY2spOwot Ci1lcnJfZnJlZToKLQlpOTE1X2J1ZGR5X2ZyZWVfbGlzdChtbSwgJmFsbG9jYXRlZCk7Ci0JcmV0 dXJuIGVycjsKLX0KLQotI2lmIElTX0VOQUJMRUQoQ09ORklHX0RSTV9JOTE1X1NFTEZURVNUKQot I2luY2x1ZGUgInNlbGZ0ZXN0cy9pOTE1X2J1ZGR5LmMiCi0jZW5kaWYKZGlmZiAtLWdpdCBhL2Ry aXZlcnMvZ3B1L2RybS9pOTE1L2k5MTVfYnVkZHkuaCBiL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2k5 MTVfYnVkZHkuaApkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggOWNlNTIwMGY0MDAxLi4w MDAwMDAwMDAwMDAKLS0tIGEvZHJpdmVycy9ncHUvZHJtL2k5MTUvaTkxNV9idWRkeS5oCisrKyAv ZGV2L251bGwKQEAgLTEsMTMxICswLDAgQEAKLS8qIFNQRFgtTGljZW5zZS1JZGVudGlmaWVyOiBN SVQgKi8KLS8qCi0gKiBDb3B5cmlnaHQgwqkgMjAxOSBJbnRlbCBDb3Jwb3JhdGlvbgotICovCi0K LSNpZm5kZWYgX19JOTE1X0JVRERZX0hfXwotI2RlZmluZSBfX0k5MTVfQlVERFlfSF9fCi0KLSNp bmNsdWRlIDxsaW51eC9iaXRvcHMuaD4KLSNpbmNsdWRlIDxsaW51eC9saXN0Lmg+Ci0KLXN0cnVj dCBpOTE1X2J1ZGR5X2Jsb2NrIHsKLSNkZWZpbmUgSTkxNV9CVUREWV9IRUFERVJfT0ZGU0VUIEdF Tk1BU0tfVUxMKDYzLCAxMikKLSNkZWZpbmUgSTkxNV9CVUREWV9IRUFERVJfU1RBVEUgIEdFTk1B U0tfVUxMKDExLCAxMCkKLSNkZWZpbmUgICBJOTE1X0JVRERZX0FMTE9DQVRFRAkgICAoMSA8PCAx MCkKLSNkZWZpbmUgICBJOTE1X0JVRERZX0ZSRUUJICAgKDIgPDwgMTApCi0jZGVmaW5lICAgSTkx NV9CVUREWV9TUExJVAkgICAoMyA8PCAxMCkKLS8qIEZyZWUgdG8gYmUgdXNlZCwgaWYgbmVlZGVk IGluIHRoZSBmdXR1cmUgKi8KLSNkZWZpbmUgSTkxNV9CVUREWV9IRUFERVJfVU5VU0VEIEdFTk1B U0tfVUxMKDksIDYpCi0jZGVmaW5lIEk5MTVfQlVERFlfSEVBREVSX09SREVSICBHRU5NQVNLX1VM TCg1LCAwKQotCXU2NCBoZWFkZXI7Ci0KLQlzdHJ1Y3QgaTkxNV9idWRkeV9ibG9jayAqbGVmdDsK LQlzdHJ1Y3QgaTkxNV9idWRkeV9ibG9jayAqcmlnaHQ7Ci0Jc3RydWN0IGk5MTVfYnVkZHlfYmxv Y2sgKnBhcmVudDsKLQotCXZvaWQgKnByaXZhdGU7IC8qIG93bmVkIGJ5IGNyZWF0b3IgKi8KLQot CS8qCi0JICogV2hpbGUgdGhlIGJsb2NrIGlzIGFsbG9jYXRlZCBieSB0aGUgdXNlciB0aHJvdWdo IGk5MTVfYnVkZHlfYWxsb2MqLAotCSAqIHRoZSB1c2VyIGhhcyBvd25lcnNoaXAgb2YgdGhlIGxp bmssIGZvciBleGFtcGxlIHRvIG1haW50YWluIHdpdGhpbgotCSAqIGEgbGlzdCwgaWYgc28gZGVz aXJlZC4gQXMgc29vbiBhcyB0aGUgYmxvY2sgaXMgZnJlZWQgd2l0aAotCSAqIGk5MTVfYnVkZHlf ZnJlZSogb3duZXJzaGlwIGlzIGdpdmVuIGJhY2sgdG8gdGhlIG1tLgotCSAqLwotCXN0cnVjdCBs aXN0X2hlYWQgbGluazsKLQlzdHJ1Y3QgbGlzdF9oZWFkIHRtcF9saW5rOwotfTsKLQotLyogT3Jk ZXItemVybyBtdXN0IGJlIGF0IGxlYXN0IFBBR0VfU0laRSAqLwotI2RlZmluZSBJOTE1X0JVRERZ X01BWF9PUkRFUiAoNjMgLSBQQUdFX1NISUZUKQotCi0vKgotICogQmluYXJ5IEJ1ZGR5IFN5c3Rl bS4KLSAqCi0gKiBMb2NraW5nIHNob3VsZCBiZSBoYW5kbGVkIGJ5IHRoZSB1c2VyLCBhIHNpbXBs ZSBtdXRleCBhcm91bmQKLSAqIGk5MTVfYnVkZHlfYWxsb2MqIGFuZCBpOTE1X2J1ZGR5X2ZyZWUq IHNob3VsZCBzdWZmaWNlLgotICovCi1zdHJ1Y3QgaTkxNV9idWRkeV9tbSB7Ci0JLyogTWFpbnRh aW4gYSBmcmVlIGxpc3QgZm9yIGVhY2ggb3JkZXIuICovCi0Jc3RydWN0IGxpc3RfaGVhZCAqZnJl ZV9saXN0OwotCi0JLyoKLQkgKiBNYWludGFpbiBleHBsaWNpdCBiaW5hcnkgdHJlZShzKSB0byB0 cmFjayB0aGUgYWxsb2NhdGlvbiBvZiB0aGUKLQkgKiBhZGRyZXNzIHNwYWNlLiBUaGlzIGdpdmVz IHVzIGEgc2ltcGxlIHdheSBvZiBmaW5kaW5nIGEgYnVkZHkgYmxvY2sKLQkgKiBhbmQgcGVyZm9y bWluZyB0aGUgcG90ZW50aWFsbHkgcmVjdXJzaXZlIG1lcmdlIHN0ZXAgd2hlbiBmcmVlaW5nIGEK LQkgKiBibG9jay4gIE5vZGVzIGFyZSBlaXRoZXIgYWxsb2NhdGVkIG9yIGZyZWUsIGluIHdoaWNo IGNhc2UgdGhleSB3aWxsCi0JICogYWxzbyBleGlzdCBvbiB0aGUgcmVzcGVjdGl2ZSBmcmVlIGxp c3QuCi0JICovCi0Jc3RydWN0IGk5MTVfYnVkZHlfYmxvY2sgKipyb290czsKLQotCS8qCi0JICog QW55dGhpbmcgZnJvbSBoZXJlIGlzIHB1YmxpYywgYW5kIHJlbWFpbnMgc3RhdGljIGZvciB0aGUg bGlmZXRpbWUgb2YKLQkgKiB0aGUgbW0uIEV2ZXJ5dGhpbmcgYWJvdmUgaXMgY29uc2lkZXJlZCBk by1ub3QtdG91Y2guCi0JICovCi0JdW5zaWduZWQgaW50IG5fcm9vdHM7Ci0JdW5zaWduZWQgaW50 IG1heF9vcmRlcjsKLQotCS8qIE11c3QgYmUgYXQgbGVhc3QgUEFHRV9TSVpFICovCi0JdTY0IGNo dW5rX3NpemU7Ci0JdTY0IHNpemU7Ci19OwotCi1zdGF0aWMgaW5saW5lIHU2NAotaTkxNV9idWRk eV9ibG9ja19vZmZzZXQoc3RydWN0IGk5MTVfYnVkZHlfYmxvY2sgKmJsb2NrKQotewotCXJldHVy biBibG9jay0+aGVhZGVyICYgSTkxNV9CVUREWV9IRUFERVJfT0ZGU0VUOwotfQotCi1zdGF0aWMg aW5saW5lIHVuc2lnbmVkIGludAotaTkxNV9idWRkeV9ibG9ja19vcmRlcihzdHJ1Y3QgaTkxNV9i dWRkeV9ibG9jayAqYmxvY2spCi17Ci0JcmV0dXJuIGJsb2NrLT5oZWFkZXIgJiBJOTE1X0JVRERZ X0hFQURFUl9PUkRFUjsKLX0KLQotc3RhdGljIGlubGluZSB1bnNpZ25lZCBpbnQKLWk5MTVfYnVk ZHlfYmxvY2tfc3RhdGUoc3RydWN0IGk5MTVfYnVkZHlfYmxvY2sgKmJsb2NrKQotewotCXJldHVy biBibG9jay0+aGVhZGVyICYgSTkxNV9CVUREWV9IRUFERVJfU1RBVEU7Ci19Ci0KLXN0YXRpYyBp bmxpbmUgYm9vbAotaTkxNV9idWRkeV9ibG9ja19pc19hbGxvY2F0ZWQoc3RydWN0IGk5MTVfYnVk ZHlfYmxvY2sgKmJsb2NrKQotewotCXJldHVybiBpOTE1X2J1ZGR5X2Jsb2NrX3N0YXRlKGJsb2Nr KSA9PSBJOTE1X0JVRERZX0FMTE9DQVRFRDsKLX0KLQotc3RhdGljIGlubGluZSBib29sCi1pOTE1 X2J1ZGR5X2Jsb2NrX2lzX2ZyZWUoc3RydWN0IGk5MTVfYnVkZHlfYmxvY2sgKmJsb2NrKQotewot CXJldHVybiBpOTE1X2J1ZGR5X2Jsb2NrX3N0YXRlKGJsb2NrKSA9PSBJOTE1X0JVRERZX0ZSRUU7 Ci19Ci0KLXN0YXRpYyBpbmxpbmUgYm9vbAotaTkxNV9idWRkeV9ibG9ja19pc19zcGxpdChzdHJ1 Y3QgaTkxNV9idWRkeV9ibG9jayAqYmxvY2spCi17Ci0JcmV0dXJuIGk5MTVfYnVkZHlfYmxvY2tf c3RhdGUoYmxvY2spID09IEk5MTVfQlVERFlfU1BMSVQ7Ci19Ci0KLXN0YXRpYyBpbmxpbmUgdTY0 Ci1pOTE1X2J1ZGR5X2Jsb2NrX3NpemUoc3RydWN0IGk5MTVfYnVkZHlfbW0gKm1tLAotCQkgICAg ICBzdHJ1Y3QgaTkxNV9idWRkeV9ibG9jayAqYmxvY2spCi17Ci0JcmV0dXJuIG1tLT5jaHVua19z aXplIDw8IGk5MTVfYnVkZHlfYmxvY2tfb3JkZXIoYmxvY2spOwotfQotCi1pbnQgaTkxNV9idWRk eV9pbml0KHN0cnVjdCBpOTE1X2J1ZGR5X21tICptbSwgdTY0IHNpemUsIHU2NCBjaHVua19zaXpl KTsKLQotdm9pZCBpOTE1X2J1ZGR5X2Zpbmkoc3RydWN0IGk5MTVfYnVkZHlfbW0gKm1tKTsKLQot c3RydWN0IGk5MTVfYnVkZHlfYmxvY2sgKgotaTkxNV9idWRkeV9hbGxvYyhzdHJ1Y3QgaTkxNV9i dWRkeV9tbSAqbW0sIHVuc2lnbmVkIGludCBvcmRlcik7Ci0KLWludCBpOTE1X2J1ZGR5X2FsbG9j X3JhbmdlKHN0cnVjdCBpOTE1X2J1ZGR5X21tICptbSwKLQkJCSAgIHN0cnVjdCBsaXN0X2hlYWQg KmJsb2NrcywKLQkJCSAgIHU2NCBzdGFydCwgdTY0IHNpemUpOwotCi12b2lkIGk5MTVfYnVkZHlf ZnJlZShzdHJ1Y3QgaTkxNV9idWRkeV9tbSAqbW0sIHN0cnVjdCBpOTE1X2J1ZGR5X2Jsb2NrICpi bG9jayk7Ci0KLXZvaWQgaTkxNV9idWRkeV9mcmVlX2xpc3Qoc3RydWN0IGk5MTVfYnVkZHlfbW0g Km1tLCBzdHJ1Y3QgbGlzdF9oZWFkICpvYmplY3RzKTsKLQotI2VuZGlmCmRpZmYgLS1naXQgYS9k cml2ZXJzL2dwdS9kcm0vaTkxNS9pOTE1X2Rydi5jIGIvZHJpdmVycy9ncHUvZHJtL2k5MTUvaTkx NV9kcnYuYwppbmRleCA5MmJjY2M1NjIzYTguLjEyMmRkMjk3YjZhZiAxMDA2NDQKLS0tIGEvZHJp dmVycy9ncHUvZHJtL2k5MTUvaTkxNV9kcnYuYworKysgYi9kcml2ZXJzL2dwdS9kcm0vaTkxNS9p OTE1X2Rydi5jCkBAIC04NCw2ICs4NCw3IEBACiAjaW5jbHVkZSAiaW50ZWxfZ3Z0LmgiCiAjaW5j bHVkZSAiaW50ZWxfbWVtb3J5X3JlZ2lvbi5oIgogI2luY2x1ZGUgImludGVsX3BtLmgiCisjaW5j bHVkZSAiaW50ZWxfcmVnaW9uX3R0bS5oIgogI2luY2x1ZGUgImludGVsX3NpZGViYW5kLmgiCiAj aW5jbHVkZSAidmx2X3N1c3BlbmQuaCIKIApAQCAtMzM1LDYgKzMzNiwxMCBAQCBzdGF0aWMgaW50 IGk5MTVfZHJpdmVyX2Vhcmx5X3Byb2JlKHN0cnVjdCBkcm1faTkxNV9wcml2YXRlICpkZXZfcHJp dikKIAlpZiAocmV0IDwgMCkKIAkJZ290byBlcnJfd29ya3F1ZXVlczsKIAorCXJldCA9IGludGVs X3JlZ2lvbl90dG1fZGV2aWNlX2luaXQoZGV2X3ByaXYpOworCWlmIChyZXQpCisJCWdvdG8gZXJy X3R0bTsKKwogCWludGVsX3dvcGNtX2luaXRfZWFybHkoJmRldl9wcml2LT53b3BjbSk7CiAKIAlp bnRlbF9ndF9pbml0X2Vhcmx5KCZkZXZfcHJpdi0+Z3QsIGRldl9wcml2KTsKQEAgLTM1OSw2ICsz NjQsOCBAQCBzdGF0aWMgaW50IGk5MTVfZHJpdmVyX2Vhcmx5X3Byb2JlKHN0cnVjdCBkcm1faTkx NV9wcml2YXRlICpkZXZfcHJpdikKIGVycl9nZW06CiAJaTkxNV9nZW1fY2xlYW51cF9lYXJseShk ZXZfcHJpdik7CiAJaW50ZWxfZ3RfZHJpdmVyX2xhdGVfcmVsZWFzZSgmZGV2X3ByaXYtPmd0KTsK KwlpbnRlbF9yZWdpb25fdHRtX2RldmljZV9maW5pKGRldl9wcml2KTsKK2Vycl90dG06CiAJdmx2 X3N1c3BlbmRfY2xlYW51cChkZXZfcHJpdik7CiBlcnJfd29ya3F1ZXVlczoKIAlpOTE1X3dvcmtx dWV1ZXNfY2xlYW51cChkZXZfcHJpdik7CkBAIC0zNzYsNiArMzgzLDcgQEAgc3RhdGljIHZvaWQg aTkxNV9kcml2ZXJfbGF0ZV9yZWxlYXNlKHN0cnVjdCBkcm1faTkxNV9wcml2YXRlICpkZXZfcHJp dikKIAlpbnRlbF9wb3dlcl9kb21haW5zX2NsZWFudXAoZGV2X3ByaXYpOwogCWk5MTVfZ2VtX2Ns ZWFudXBfZWFybHkoZGV2X3ByaXYpOwogCWludGVsX2d0X2RyaXZlcl9sYXRlX3JlbGVhc2UoJmRl dl9wcml2LT5ndCk7CisJaW50ZWxfcmVnaW9uX3R0bV9kZXZpY2VfZmluaShkZXZfcHJpdik7CiAJ dmx2X3N1c3BlbmRfY2xlYW51cChkZXZfcHJpdik7CiAJaTkxNV93b3JrcXVldWVzX2NsZWFudXAo ZGV2X3ByaXYpOwogCmRpZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9kcm0vaTkxNS9pOTE1X2Rydi5o IGIvZHJpdmVycy9ncHUvZHJtL2k5MTUvaTkxNV9kcnYuaAppbmRleCAxMjgxOThlOGI0ZDAuLjEy NzZhMmY2MDc0MCAxMDA2NDQKLS0tIGEvZHJpdmVycy9ncHUvZHJtL2k5MTUvaTkxNV9kcnYuaAor KysgYi9kcml2ZXJzL2dwdS9kcm0vaTkxNS9pOTE1X2Rydi5oCkBAIC02MCw2ICs2MCw3IEBACiAj aW5jbHVkZSA8ZHJtL2RybV9hdG9taWMuaD4KICNpbmNsdWRlIDxkcm0vZHJtX2Nvbm5lY3Rvci5o PgogI2luY2x1ZGUgPGRybS9pOTE1X21laV9oZGNwX2ludGVyZmFjZS5oPgorI2luY2x1ZGUgPGRy bS90dG0vdHRtX2RldmljZS5oPgogCiAjaW5jbHVkZSAiaTkxNV9wYXJhbXMuaCIKICNpbmNsdWRl ICJpOTE1X3JlZy5oIgpAQCAtMTE2Niw2ICsxMTY3LDkgQEAgc3RydWN0IGRybV9pOTE1X3ByaXZh dGUgewogCS8qIE11dGV4IHRvIHByb3RlY3QgdGhlIGFib3ZlIGhkY3AgY29tcG9uZW50IHJlbGF0 ZWQgdmFsdWVzLiAqLwogCXN0cnVjdCBtdXRleCBoZGNwX2NvbXBfbXV0ZXg7CiAKKwkvKiBUaGUg VFRNIGRldmljZSBzdHJ1Y3R1cmUuICovCisJc3RydWN0IHR0bV9kZXZpY2UgYmRldjsKKwogCUk5 MTVfU0VMRlRFU1RfREVDTEFSRShzdHJ1Y3QgaTkxNV9zZWxmdGVzdF9zdGFzaCBzZWxmdGVzdDsp CiAKIAkvKgpAQCAtMTc1MSw3ICsxNzU1LDggQEAgdm9pZCBpOTE1X2dlbV9jbGVhbnVwX3VzZXJw dHIoc3RydWN0IGRybV9pOTE1X3ByaXZhdGUgKmRldl9wcml2KTsKIHZvaWQgaTkxNV9nZW1faW5p dF9lYXJseShzdHJ1Y3QgZHJtX2k5MTVfcHJpdmF0ZSAqZGV2X3ByaXYpOwogdm9pZCBpOTE1X2dl bV9jbGVhbnVwX2Vhcmx5KHN0cnVjdCBkcm1faTkxNV9wcml2YXRlICpkZXZfcHJpdik7CiAKLXN0 cnVjdCBpbnRlbF9tZW1vcnlfcmVnaW9uICppOTE1X2dlbV9zaG1lbV9zZXR1cChzdHJ1Y3QgZHJt X2k5MTVfcHJpdmF0ZSAqaTkxNSk7CitzdHJ1Y3QgaW50ZWxfbWVtb3J5X3JlZ2lvbiAqaTkxNV9n ZW1fc2htZW1fc2V0dXAoc3RydWN0IGRybV9pOTE1X3ByaXZhdGUgKmk5MTUsCisJCQkJCQkgdTE2 IHR5cGUsIHUxNiBpbnN0YW5jZSk7CiAKIHN0YXRpYyBpbmxpbmUgdm9pZCBpOTE1X2dlbV9kcmFp bl9mcmVlZF9vYmplY3RzKHN0cnVjdCBkcm1faTkxNV9wcml2YXRlICppOTE1KQogewpkaWZmIC0t Z2l0IGEvZHJpdmVycy9ncHUvZHJtL2k5MTUvaTkxNV9nZW0uYyBiL2RyaXZlcnMvZ3B1L2RybS9p OTE1L2k5MTVfZ2VtLmMKaW5kZXggZDAwMThjNWY4OGJkLi4xODBmNmU5MTA3ZDQgMTAwNjQ0Ci0t LSBhL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2k5MTVfZ2VtLmMKKysrIGIvZHJpdmVycy9ncHUvZHJt L2k5MTUvaTkxNV9nZW0uYwpAQCAtMTEwOSw2ICsxMTA5LDcgQEAgaW50IGk5MTVfZ2VtX2luaXQo c3RydWN0IGRybV9pOTE1X3ByaXZhdGUgKmRldl9wcml2KQogCX0KIAogCWk5MTVfZ2VtX2RyYWlu X2ZyZWVkX29iamVjdHMoZGV2X3ByaXYpOworCiAJcmV0dXJuIHJldDsKIH0KIApkaWZmIC0tZ2l0 IGEvZHJpdmVycy9ncHUvZHJtL2k5MTUvaTkxNV9nbG9iYWxzLmMgYi9kcml2ZXJzL2dwdS9kcm0v aTkxNS9pOTE1X2dsb2JhbHMuYwppbmRleCAzYWEyMTM2ODQyOTMuLjc3ZjE5MTFjNDYzYiAxMDA2 NDQKLS0tIGEvZHJpdmVycy9ncHUvZHJtL2k5MTUvaTkxNV9nbG9iYWxzLmMKKysrIGIvZHJpdmVy cy9ncHUvZHJtL2k5MTUvaTkxNV9nbG9iYWxzLmMKQEAgLTg3LDcgKzg3LDYgQEAgc3RhdGljIHZv aWQgX19pOTE1X2dsb2JhbHNfY2xlYW51cCh2b2lkKQogCiBzdGF0aWMgX19pbml0Y29uc3QgaW50 ICgqIGNvbnN0IGluaXRmbltdKSh2b2lkKSA9IHsKIAlpOTE1X2dsb2JhbF9hY3RpdmVfaW5pdCwK LQlpOTE1X2dsb2JhbF9idWRkeV9pbml0LAogCWk5MTVfZ2xvYmFsX2NvbnRleHRfaW5pdCwKIAlp OTE1X2dsb2JhbF9nZW1fY29udGV4dF9pbml0LAogCWk5MTVfZ2xvYmFsX29iamVjdHNfaW5pdCwK ZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2k5MTVfZ2xvYmFscy5oIGIvZHJpdmVy cy9ncHUvZHJtL2k5MTUvaTkxNV9nbG9iYWxzLmgKaW5kZXggYjJmNWNkOWI5YjFhLi4yZDE5OWY0 MTFhNGEgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2k5MTVfZ2xvYmFscy5oCisr KyBiL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2k5MTVfZ2xvYmFscy5oCkBAIC0yNyw3ICsyNyw2IEBA IHZvaWQgaTkxNV9nbG9iYWxzX2V4aXQodm9pZCk7CiAKIC8qIGNvbnN0cnVjdG9ycyAqLwogaW50 IGk5MTVfZ2xvYmFsX2FjdGl2ZV9pbml0KHZvaWQpOwotaW50IGk5MTVfZ2xvYmFsX2J1ZGR5X2lu aXQodm9pZCk7CiBpbnQgaTkxNV9nbG9iYWxfY29udGV4dF9pbml0KHZvaWQpOwogaW50IGk5MTVf Z2xvYmFsX2dlbV9jb250ZXh0X2luaXQodm9pZCk7CiBpbnQgaTkxNV9nbG9iYWxfb2JqZWN0c19p bml0KHZvaWQpOwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJtL2k5MTUvaTkxNV9zY2F0dGVy bGlzdC5jIGIvZHJpdmVycy9ncHUvZHJtL2k5MTUvaTkxNV9zY2F0dGVybGlzdC5jCmluZGV4IGNj NmIzODQ2YThjNy4uNjllOWU2YzMxMzVlIDEwMDY0NAotLS0gYS9kcml2ZXJzL2dwdS9kcm0vaTkx NS9pOTE1X3NjYXR0ZXJsaXN0LmMKKysrIGIvZHJpdmVycy9ncHUvZHJtL2k5MTUvaTkxNV9zY2F0 dGVybGlzdC5jCkBAIC02LDYgKzYsMTAgQEAKIAogI2luY2x1ZGUgImk5MTVfc2NhdHRlcmxpc3Qu aCIKIAorI2luY2x1ZGUgPGRybS9kcm1fbW0uaD4KKworI2luY2x1ZGUgPGxpbnV4L3NsYWIuaD4K KwogYm9vbCBpOTE1X3NnX3RyaW0oc3RydWN0IHNnX3RhYmxlICpvcmlnX3N0KQogewogCXN0cnVj dCBzZ190YWJsZSBuZXdfc3Q7CkBAIC0zNCw2ICszOCw3MiBAQCBib29sIGk5MTVfc2dfdHJpbShz dHJ1Y3Qgc2dfdGFibGUgKm9yaWdfc3QpCiAJcmV0dXJuIHRydWU7CiB9CiAKKy8qKgorICogaTkx NV9zZ19mcm9tX21tX25vZGUgLSBDcmVhdGUgYW4gc2dfdGFibGUgZnJvbSBhIHN0cnVjdCBkcm1f bW1fbm9kZQorICogQG5vZGU6IFRoZSBkcm1fbW1fbm9kZS4KKyAqIEByZWdpb25fc3RhcnQ6IEFu IG9mZnNldCB0byBhZGQgdG8gdGhlIGRtYSBhZGRyZXNzZXMgb2YgdGhlIHNnIGxpc3QuCisgKgor ICogQ3JlYXRlIGEgc3RydWN0IHNnX3RhYmxlLCBpbml0aWFsaXppbmcgaXQgZnJvbSBhIHN0cnVj dCBkcm1fbW1fbm9kZSwKKyAqIHRha2luZyBhIG1heGltdW0gc2VnbWVudCBsZW5ndGggaW50byBh Y2NvdW50LCBzcGxpdHRpbmcgaW50byBzZWdtZW50cworICogaWYgbmVjZXNzYXJ5LgorICoKKyAq IFJldHVybjogQSBwb2ludGVyIHRvIGEga21hbGxvY2VkIHN0cnVjdCBzZ190YWJsZSBvbiBzdWNj ZXNzLCBuZWdhdGl2ZQorICogZXJyb3IgY29kZSBjYXN0IHRvIGFuIGVycm9yIHBvaW50ZXIgb24g ZmFpbHVyZS4KKyAqLworc3RydWN0IHNnX3RhYmxlICppOTE1X3NnX2Zyb21fbW1fbm9kZShjb25z dCBzdHJ1Y3QgZHJtX21tX25vZGUgKm5vZGUsCisJCQkJICAgICAgdTY0IHJlZ2lvbl9zdGFydCkK K3sKKwljb25zdCB1NjQgbWF4X3NlZ21lbnQgPSBTWl8xRzsgLyogRG8gd2UgaGF2ZSBhIGxpbWl0 IG9uIHRoaXM/ICovCisJdTY0IHNlZ21lbnRfcGFnZXMgPSBtYXhfc2VnbWVudCA+PiBQQUdFX1NI SUZUOworCXU2NCBibG9ja19zaXplLCBvZmZzZXQsIHByZXZfZW5kOworCXN0cnVjdCBzZ190YWJs ZSAqc3Q7CisJc3RydWN0IHNjYXR0ZXJsaXN0ICpzZzsKKworCXN0ID0ga21hbGxvYyhzaXplb2Yo KnN0KSwgR0ZQX0tFUk5FTCk7CisJaWYgKCFzdCkKKwkJcmV0dXJuIEVSUl9QVFIoLUVOT01FTSk7 CisKKwlpZiAoc2dfYWxsb2NfdGFibGUoc3QsIERJVl9ST1VORF9VUChub2RlLT5zaXplLCBzZWdt ZW50X3BhZ2VzKSwKKwkJCSAgIEdGUF9LRVJORUwpKSB7CisJCWtmcmVlKHN0KTsKKwkJcmV0dXJu IEVSUl9QVFIoLUVOT01FTSk7CisJfQorCisJc2cgPSBzdC0+c2dsOworCXN0LT5uZW50cyA9IDA7 CisJcHJldl9lbmQgPSAocmVzb3VyY2Vfc2l6ZV90KS0xOworCWJsb2NrX3NpemUgPSBub2RlLT5z aXplIDw8IFBBR0VfU0hJRlQ7CisJb2Zmc2V0ID0gbm9kZS0+c3RhcnQgPDwgUEFHRV9TSElGVDsK KworCXdoaWxlIChibG9ja19zaXplKSB7CisJCXU2NCBsZW47CisKKwkJaWYgKG9mZnNldCAhPSBw cmV2X2VuZCB8fCBzZy0+bGVuZ3RoID49IG1heF9zZWdtZW50KSB7CisJCQlpZiAoc3QtPm5lbnRz KQorCQkJCXNnID0gX19zZ19uZXh0KHNnKTsKKworCQkJc2dfZG1hX2FkZHJlc3Moc2cpID0gcmVn aW9uX3N0YXJ0ICsgb2Zmc2V0OworCQkJc2dfZG1hX2xlbihzZykgPSAwOworCQkJc2ctPmxlbmd0 aCA9IDA7CisJCQlzdC0+bmVudHMrKzsKKwkJfQorCisJCWxlbiA9IG1pbihibG9ja19zaXplLCBt YXhfc2VnbWVudCAtIHNnLT5sZW5ndGgpOworCQlzZy0+bGVuZ3RoICs9IGxlbjsKKwkJc2dfZG1h X2xlbihzZykgKz0gbGVuOworCisJCW9mZnNldCArPSBsZW47CisJCWJsb2NrX3NpemUgLT0gbGVu OworCisJCXByZXZfZW5kID0gb2Zmc2V0OworCX0KKworCXNnX21hcmtfZW5kKHNnKTsKKwlpOTE1 X3NnX3RyaW0oc3QpOworCisJcmV0dXJuIHN0OworfQorCiAjaWYgSVNfRU5BQkxFRChDT05GSUdf RFJNX0k5MTVfU0VMRlRFU1QpCiAjaW5jbHVkZSAic2VsZnRlc3RzL3NjYXR0ZXJsaXN0LmMiCiAj ZW5kaWYKZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2k5MTVfc2NhdHRlcmxpc3Qu aCBiL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2k5MTVfc2NhdHRlcmxpc3QuaAppbmRleCBiOTZiYWFk NjZhM2EuLjVhY2NhNDVlYTk4MSAxMDA2NDQKLS0tIGEvZHJpdmVycy9ncHUvZHJtL2k5MTUvaTkx NV9zY2F0dGVybGlzdC5oCisrKyBiL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2k5MTVfc2NhdHRlcmxp c3QuaApAQCAtMTMsNiArMTMsOCBAQAogCiAjaW5jbHVkZSAiaTkxNV9nZW0uaCIKIAorc3RydWN0 IGRybV9tbV9ub2RlOworCiAvKgogICogT3B0aW1pc2VkIFNHTCBpdGVyYXRvciBmb3IgR0VNIG9i amVjdHMKICAqLwpAQCAtMTQxLDQgKzE0Myw2IEBAIHN0YXRpYyBpbmxpbmUgdW5zaWduZWQgaW50 IGk5MTVfc2dfc2VnbWVudF9zaXplKHZvaWQpCiAKIGJvb2wgaTkxNV9zZ190cmltKHN0cnVjdCBz Z190YWJsZSAqb3JpZ19zdCk7CiAKK3N0cnVjdCBzZ190YWJsZSAqaTkxNV9zZ19mcm9tX21tX25v ZGUoY29uc3Qgc3RydWN0IGRybV9tbV9ub2RlICpub2RlLAorCQkJCSAgICAgIHU2NCByZWdpb25f c3RhcnQpOwogI2VuZGlmCmRpZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9kcm0vaTkxNS9pbnRlbF9t ZW1vcnlfcmVnaW9uLmMgYi9kcml2ZXJzL2dwdS9kcm0vaTkxNS9pbnRlbF9tZW1vcnlfcmVnaW9u LmMKaW5kZXggZDk4ZThiODFkMzIyLi40MDkyY2M5ODc2NzkgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMv Z3B1L2RybS9pOTE1L2ludGVsX21lbW9yeV9yZWdpb24uYworKysgYi9kcml2ZXJzL2dwdS9kcm0v aTkxNS9pbnRlbF9tZW1vcnlfcmVnaW9uLmMKQEAgLTI4LDYgKzI4LDExIEBAIHN0YXRpYyBjb25z dCBzdHJ1Y3QgewogCX0sCiB9OwogCitzdHJ1Y3QgaW50ZWxfcmVnaW9uX3Jlc2VydmUgeworCXN0 cnVjdCBsaXN0X2hlYWQgbGluazsKKwl2b2lkICpub2RlOworfTsKKwogc3RydWN0IGludGVsX21l bW9yeV9yZWdpb24gKgogaW50ZWxfbWVtb3J5X3JlZ2lvbl9sb29rdXAoc3RydWN0IGRybV9pOTE1 X3ByaXZhdGUgKmk5MTUsCiAJCQkgICB1MTYgY2xhc3MsIHUxNiBpbnN0YW5jZSkKQEAgLTU4LDE0 NiArNjMsNjEgQEAgaW50ZWxfbWVtb3J5X3JlZ2lvbl9ieV90eXBlKHN0cnVjdCBkcm1faTkxNV9w cml2YXRlICppOTE1LAogCXJldHVybiBOVUxMOwogfQogCi1zdGF0aWMgdTY0Ci1pbnRlbF9tZW1v cnlfcmVnaW9uX2ZyZWVfcGFnZXMoc3RydWN0IGludGVsX21lbW9yeV9yZWdpb24gKm1lbSwKLQkJ CSAgICAgICBzdHJ1Y3QgbGlzdF9oZWFkICpibG9ja3MpCisvKioKKyAqIGludGVsX21lbW9yeV9y ZWdpb25fdW5yZXNlcnZlIC0gVW5yZXNlcnZlIGFsbCBwcmV2aW91c2x5IHJlc2VydmVkCisgKiBy YW5nZXMKKyAqIEBtZW06IFRoZSByZWdpb24gY29udGFpbmluZyB0aGUgcmVzZXJ2ZWQgcmFuZ2Vz LgorICovCit2b2lkIGludGVsX21lbW9yeV9yZWdpb25fdW5yZXNlcnZlKHN0cnVjdCBpbnRlbF9t ZW1vcnlfcmVnaW9uICptZW0pCiB7Ci0Jc3RydWN0IGk5MTVfYnVkZHlfYmxvY2sgKmJsb2NrLCAq b247Ci0JdTY0IHNpemUgPSAwOworCXN0cnVjdCBpbnRlbF9yZWdpb25fcmVzZXJ2ZSAqcmVzZXJ2 ZSwgKm5leHQ7CiAKLQlsaXN0X2Zvcl9lYWNoX2VudHJ5X3NhZmUoYmxvY2ssIG9uLCBibG9ja3Ms IGxpbmspIHsKLQkJc2l6ZSArPSBpOTE1X2J1ZGR5X2Jsb2NrX3NpemUoJm1lbS0+bW0sIGJsb2Nr KTsKLQkJaTkxNV9idWRkeV9mcmVlKCZtZW0tPm1tLCBibG9jayk7Ci0JfQotCUlOSVRfTElTVF9I RUFEKGJsb2Nrcyk7CisJaWYgKCFtZW0tPnByaXZfb3BzIHx8ICFtZW0tPnByaXZfb3BzLT5mcmVl KQorCQlyZXR1cm47CiAKLQlyZXR1cm4gc2l6ZTsKLX0KLQotdm9pZAotX19pbnRlbF9tZW1vcnlf cmVnaW9uX3B1dF9wYWdlc19idWRkeShzdHJ1Y3QgaW50ZWxfbWVtb3J5X3JlZ2lvbiAqbWVtLAot CQkJCSAgICAgIHN0cnVjdCBsaXN0X2hlYWQgKmJsb2NrcykKLXsKIAltdXRleF9sb2NrKCZtZW0t Pm1tX2xvY2spOwotCW1lbS0+YXZhaWwgKz0gaW50ZWxfbWVtb3J5X3JlZ2lvbl9mcmVlX3BhZ2Vz KG1lbSwgYmxvY2tzKTsKLQltdXRleF91bmxvY2soJm1lbS0+bW1fbG9jayk7Ci19Ci0KLXZvaWQK LV9faW50ZWxfbWVtb3J5X3JlZ2lvbl9wdXRfYmxvY2tfYnVkZHkoc3RydWN0IGk5MTVfYnVkZHlf YmxvY2sgKmJsb2NrKQotewotCXN0cnVjdCBsaXN0X2hlYWQgYmxvY2tzOwotCi0JSU5JVF9MSVNU X0hFQUQoJmJsb2Nrcyk7Ci0JbGlzdF9hZGQoJmJsb2NrLT5saW5rLCAmYmxvY2tzKTsKLQlfX2lu dGVsX21lbW9yeV9yZWdpb25fcHV0X3BhZ2VzX2J1ZGR5KGJsb2NrLT5wcml2YXRlLCAmYmxvY2tz KTsKLX0KLQotaW50Ci1fX2ludGVsX21lbW9yeV9yZWdpb25fZ2V0X3BhZ2VzX2J1ZGR5KHN0cnVj dCBpbnRlbF9tZW1vcnlfcmVnaW9uICptZW0sCi0JCQkJICAgICAgcmVzb3VyY2Vfc2l6ZV90IHNp emUsCi0JCQkJICAgICAgdW5zaWduZWQgaW50IGZsYWdzLAotCQkJCSAgICAgIHN0cnVjdCBsaXN0 X2hlYWQgKmJsb2NrcykKLXsKLQl1bnNpZ25lZCBpbnQgbWluX29yZGVyID0gMDsKLQl1bnNpZ25l ZCBsb25nIG5fcGFnZXM7Ci0KLQlHRU1fQlVHX09OKCFJU19BTElHTkVEKHNpemUsIG1lbS0+bW0u Y2h1bmtfc2l6ZSkpOwotCUdFTV9CVUdfT04oIWxpc3RfZW1wdHkoYmxvY2tzKSk7Ci0KLQlpZiAo ZmxhZ3MgJiBJOTE1X0FMTE9DX01JTl9QQUdFX1NJWkUpIHsKLQkJbWluX29yZGVyID0gaWxvZzIo bWVtLT5taW5fcGFnZV9zaXplKSAtCi0JCQkgICAgaWxvZzIobWVtLT5tbS5jaHVua19zaXplKTsK LQl9Ci0KLQlpZiAoZmxhZ3MgJiBJOTE1X0FMTE9DX0NPTlRJR1VPVVMpIHsKLQkJc2l6ZSA9IHJv dW5kdXBfcG93X29mX3R3byhzaXplKTsKLQkJbWluX29yZGVyID0gaWxvZzIoc2l6ZSkgLSBpbG9n MihtZW0tPm1tLmNodW5rX3NpemUpOworCWxpc3RfZm9yX2VhY2hfZW50cnlfc2FmZShyZXNlcnZl LCBuZXh0LCAmbWVtLT5yZXNlcnZlZCwgbGluaykgeworCQlsaXN0X2RlbCgmcmVzZXJ2ZS0+bGlu ayk7CisJCW1lbS0+cHJpdl9vcHMtPmZyZWUobWVtLCByZXNlcnZlLT5ub2RlKTsKKwkJa2ZyZWUo cmVzZXJ2ZSk7CiAJfQotCi0JaWYgKHNpemUgPiBtZW0tPm1tLnNpemUpCi0JCXJldHVybiAtRTJC SUc7Ci0KLQluX3BhZ2VzID0gc2l6ZSA+PiBpbG9nMihtZW0tPm1tLmNodW5rX3NpemUpOwotCi0J bXV0ZXhfbG9jaygmbWVtLT5tbV9sb2NrKTsKLQotCWRvIHsKLQkJc3RydWN0IGk5MTVfYnVkZHlf YmxvY2sgKmJsb2NrOwotCQl1bnNpZ25lZCBpbnQgb3JkZXI7Ci0KLQkJb3JkZXIgPSBmbHMobl9w YWdlcykgLSAxOwotCQlHRU1fQlVHX09OKG9yZGVyID4gbWVtLT5tbS5tYXhfb3JkZXIpOwotCQlH RU1fQlVHX09OKG9yZGVyIDwgbWluX29yZGVyKTsKLQotCQlkbyB7Ci0JCQlibG9jayA9IGk5MTVf YnVkZHlfYWxsb2MoJm1lbS0+bW0sIG9yZGVyKTsKLQkJCWlmICghSVNfRVJSKGJsb2NrKSkKLQkJ CQlicmVhazsKLQotCQkJaWYgKG9yZGVyLS0gPT0gbWluX29yZGVyKQotCQkJCWdvdG8gZXJyX2Zy ZWVfYmxvY2tzOwotCQl9IHdoaWxlICgxKTsKLQotCQluX3BhZ2VzIC09IEJJVChvcmRlcik7Ci0K LQkJYmxvY2stPnByaXZhdGUgPSBtZW07Ci0JCWxpc3RfYWRkX3RhaWwoJmJsb2NrLT5saW5rLCBi bG9ja3MpOwotCi0JCWlmICghbl9wYWdlcykKLQkJCWJyZWFrOwotCX0gd2hpbGUgKDEpOwotCi0J bWVtLT5hdmFpbCAtPSBzaXplOwogCW11dGV4X3VubG9jaygmbWVtLT5tbV9sb2NrKTsKLQlyZXR1 cm4gMDsKLQotZXJyX2ZyZWVfYmxvY2tzOgotCWludGVsX21lbW9yeV9yZWdpb25fZnJlZV9wYWdl cyhtZW0sIGJsb2Nrcyk7Ci0JbXV0ZXhfdW5sb2NrKCZtZW0tPm1tX2xvY2spOwotCXJldHVybiAt RU5YSU87CiB9CiAKLXN0cnVjdCBpOTE1X2J1ZGR5X2Jsb2NrICoKLV9faW50ZWxfbWVtb3J5X3Jl Z2lvbl9nZXRfYmxvY2tfYnVkZHkoc3RydWN0IGludGVsX21lbW9yeV9yZWdpb24gKm1lbSwKLQkJ CQkgICAgICByZXNvdXJjZV9zaXplX3Qgc2l6ZSwKLQkJCQkgICAgICB1bnNpZ25lZCBpbnQgZmxh Z3MpCisvKioKKyAqIGludGVsX21lbW9yeV9yZWdpb25fcmVzZXJ2ZSAtIFJlc2VydmUgYSBtZW1v cnkgcmFuZ2UKKyAqIEBtZW06IFRoZSByZWdpb24gZm9yIHdoaWNoIHdlIHdhbnQgdG8gcmVzZXJ2 ZSBhIHJhbmdlLgorICogQG9mZnNldDogU3RhcnQgb2YgdGhlIHJhbmdlIHRvIHJlc2VydmUuCisg KiBAc2l6ZTogVGhlIHNpemUgb2YgdGhlIHJhbmdlIHRvIHJlc2VydmUuCisgKgorICogUmV0dXJu OiAwIG9uIHN1Y2Nlc3MsIG5lZ2F0aXZlIGVycm9yIGNvZGUgb24gZmFpbHVyZS4KKyAqLworaW50 IGludGVsX21lbW9yeV9yZWdpb25fcmVzZXJ2ZShzdHJ1Y3QgaW50ZWxfbWVtb3J5X3JlZ2lvbiAq bWVtLAorCQkJCXJlc291cmNlX3NpemVfdCBvZmZzZXQsCisJCQkJcmVzb3VyY2Vfc2l6ZV90IHNp emUpCiB7Ci0Jc3RydWN0IGk5MTVfYnVkZHlfYmxvY2sgKmJsb2NrOwotCUxJU1RfSEVBRChibG9j a3MpOwogCWludCByZXQ7CisJc3RydWN0IGludGVsX3JlZ2lvbl9yZXNlcnZlICpyZXNlcnZlOwog Ci0JcmV0ID0gX19pbnRlbF9tZW1vcnlfcmVnaW9uX2dldF9wYWdlc19idWRkeShtZW0sIHNpemUs IGZsYWdzLCAmYmxvY2tzKTsKLQlpZiAocmV0KQotCQlyZXR1cm4gRVJSX1BUUihyZXQpOworCWlm ICghbWVtLT5wcml2X29wcyB8fCAhbWVtLT5wcml2X29wcy0+cmVzZXJ2ZSkKKwkJcmV0dXJuIC1F SU5WQUw7CiAKLQlibG9jayA9IGxpc3RfZmlyc3RfZW50cnkoJmJsb2NrcywgdHlwZW9mKCpibG9j ayksIGxpbmspOwotCWxpc3RfZGVsX2luaXQoJmJsb2NrLT5saW5rKTsKLQlyZXR1cm4gYmxvY2s7 Ci19CisJcmVzZXJ2ZSA9IGt6YWxsb2Moc2l6ZW9mKCpyZXNlcnZlKSwgR0ZQX0tFUk5FTCk7CisJ aWYgKCFyZXNlcnZlKQorCQlyZXR1cm4gLUVOT01FTTsKIAotaW50IGludGVsX21lbW9yeV9yZWdp b25faW5pdF9idWRkeShzdHJ1Y3QgaW50ZWxfbWVtb3J5X3JlZ2lvbiAqbWVtKQotewotCXJldHVy biBpOTE1X2J1ZGR5X2luaXQoJm1lbS0+bW0sIHJlc291cmNlX3NpemUoJm1lbS0+cmVnaW9uKSwK LQkJCSAgICAgICBQQUdFX1NJWkUpOwotfQotCi12b2lkIGludGVsX21lbW9yeV9yZWdpb25fcmVs ZWFzZV9idWRkeShzdHJ1Y3QgaW50ZWxfbWVtb3J5X3JlZ2lvbiAqbWVtKQotewotCWk5MTVfYnVk ZHlfZnJlZV9saXN0KCZtZW0tPm1tLCAmbWVtLT5yZXNlcnZlZCk7Ci0JaTkxNV9idWRkeV9maW5p KCZtZW0tPm1tKTsKLX0KLQotaW50IGludGVsX21lbW9yeV9yZWdpb25fcmVzZXJ2ZShzdHJ1Y3Qg aW50ZWxfbWVtb3J5X3JlZ2lvbiAqbWVtLAotCQkJCXU2NCBvZmZzZXQsIHU2NCBzaXplKQotewot CWludCByZXQ7CisJcmVzZXJ2ZS0+bm9kZSA9IG1lbS0+cHJpdl9vcHMtPnJlc2VydmUobWVtLCBv ZmZzZXQsIHNpemUpOworCWlmIChJU19FUlIocmVzZXJ2ZS0+bm9kZSkpIHsKKwkJcmV0ID0gUFRS X0VSUihyZXNlcnZlLT5ub2RlKTsKKwkJa2ZyZWUocmVzZXJ2ZSk7CisJCXJldHVybiByZXQ7CisJ fQogCiAJbXV0ZXhfbG9jaygmbWVtLT5tbV9sb2NrKTsKLQlyZXQgPSBpOTE1X2J1ZGR5X2FsbG9j X3JhbmdlKCZtZW0tPm1tLCAmbWVtLT5yZXNlcnZlZCwgb2Zmc2V0LCBzaXplKTsKKwlsaXN0X2Fk ZF90YWlsKCZyZXNlcnZlLT5saW5rLCAmbWVtLT5yZXNlcnZlZCk7CiAJbXV0ZXhfdW5sb2NrKCZt ZW0tPm1tX2xvY2spOwogCi0JcmV0dXJuIHJldDsKKwlyZXR1cm4gMDsKIH0KIAogc3RydWN0IGlu dGVsX21lbW9yeV9yZWdpb24gKgpAQCAtMjA2LDYgKzEyNiw4IEBAIGludGVsX21lbW9yeV9yZWdp b25fY3JlYXRlKHN0cnVjdCBkcm1faTkxNV9wcml2YXRlICppOTE1LAogCQkJICAgcmVzb3VyY2Vf c2l6ZV90IHNpemUsCiAJCQkgICByZXNvdXJjZV9zaXplX3QgbWluX3BhZ2Vfc2l6ZSwKIAkJCSAg IHJlc291cmNlX3NpemVfdCBpb19zdGFydCwKKwkJCSAgIHUxNiB0eXBlLAorCQkJICAgdTE2IGlu c3RhbmNlLAogCQkJICAgY29uc3Qgc3RydWN0IGludGVsX21lbW9yeV9yZWdpb25fb3BzICpvcHMp CiB7CiAJc3RydWN0IGludGVsX21lbW9yeV9yZWdpb24gKm1lbTsKQEAgLTIyMiw2ICsxNDQsOCBA QCBpbnRlbF9tZW1vcnlfcmVnaW9uX2NyZWF0ZShzdHJ1Y3QgZHJtX2k5MTVfcHJpdmF0ZSAqaTkx NSwKIAltZW0tPm9wcyA9IG9wczsKIAltZW0tPnRvdGFsID0gc2l6ZTsKIAltZW0tPmF2YWlsID0g bWVtLT50b3RhbDsKKwltZW0tPnR5cGUgPSB0eXBlOworCW1lbS0+aW5zdGFuY2UgPSBpbnN0YW5j ZTsKIAogCW11dGV4X2luaXQoJm1lbS0+b2JqZWN0cy5sb2NrKTsKIAlJTklUX0xJU1RfSEVBRCgm bWVtLT5vYmplY3RzLmxpc3QpOwpAQCAtMjU5LDYgKzE4Myw3IEBAIHN0YXRpYyB2b2lkIF9faW50 ZWxfbWVtb3J5X3JlZ2lvbl9kZXN0cm95KHN0cnVjdCBrcmVmICprcmVmKQogCXN0cnVjdCBpbnRl bF9tZW1vcnlfcmVnaW9uICptZW0gPQogCQljb250YWluZXJfb2Yoa3JlZiwgdHlwZW9mKCptZW0p LCBrcmVmKTsKIAorCWludGVsX21lbW9yeV9yZWdpb25fdW5yZXNlcnZlKG1lbSk7CiAJaWYgKG1l bS0+b3BzLT5yZWxlYXNlKQogCQltZW0tPm9wcy0+cmVsZWFzZShtZW0pOwogCkBAIC0yOTYsMTUg KzIyMSwxNSBAQCBpbnQgaW50ZWxfbWVtb3J5X3JlZ2lvbnNfaHdfcHJvYmUoc3RydWN0IGRybV9p OTE1X3ByaXZhdGUgKmk5MTUpCiAJCWluc3RhbmNlID0gaW50ZWxfcmVnaW9uX21hcFtpXS5pbnN0 YW5jZTsKIAkJc3dpdGNoICh0eXBlKSB7CiAJCWNhc2UgSU5URUxfTUVNT1JZX1NZU1RFTToKLQkJ CW1lbSA9IGk5MTVfZ2VtX3NobWVtX3NldHVwKGk5MTUpOworCQkJbWVtID0gaTkxNV9nZW1fc2ht ZW1fc2V0dXAoaTkxNSwgdHlwZSwgaW5zdGFuY2UpOwogCQkJYnJlYWs7CiAJCWNhc2UgSU5URUxf TUVNT1JZX1NUT0xFTl9MT0NBTDoKLQkJCW1lbSA9IGk5MTVfZ2VtX3N0b2xlbl9sbWVtX3NldHVw KGk5MTUpOworCQkJbWVtID0gaTkxNV9nZW1fc3RvbGVuX2xtZW1fc2V0dXAoaTkxNSwgdHlwZSwg aW5zdGFuY2UpOwogCQkJaWYgKCFJU19FUlIobWVtKSkKIAkJCQlpOTE1LT5tbS5zdG9sZW5fcmVn aW9uID0gbWVtOwogCQkJYnJlYWs7CiAJCWNhc2UgSU5URUxfTUVNT1JZX1NUT0xFTl9TWVNURU06 Ci0JCQltZW0gPSBpOTE1X2dlbV9zdG9sZW5fc21lbV9zZXR1cChpOTE1KTsKKwkJCW1lbSA9IGk5 MTVfZ2VtX3N0b2xlbl9zbWVtX3NldHVwKGk5MTUsIHR5cGUsIGluc3RhbmNlKTsKIAkJCWlmICgh SVNfRVJSKG1lbSkpCiAJCQkJaTkxNS0+bW0uc3RvbGVuX3JlZ2lvbiA9IG1lbTsKIAkJCWJyZWFr OwpAQCAtMzIxLDkgKzI0Niw2IEBAIGludCBpbnRlbF9tZW1vcnlfcmVnaW9uc19od19wcm9iZShz dHJ1Y3QgZHJtX2k5MTVfcHJpdmF0ZSAqaTkxNSkKIAkJfQogCiAJCW1lbS0+aWQgPSBpOwotCQlt ZW0tPnR5cGUgPSB0eXBlOwotCQltZW0tPmluc3RhbmNlID0gaW5zdGFuY2U7Ci0KIAkJaTkxNS0+ bW0ucmVnaW9uc1tpXSA9IG1lbTsKIAl9CiAKZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2RybS9p OTE1L2ludGVsX21lbW9yeV9yZWdpb24uaCBiL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2ludGVsX21l bW9yeV9yZWdpb24uaAppbmRleCBkMjRjZTVhMGIzMGIuLmU2OWNkZTEzZGFmMiAxMDA2NDQKLS0t IGEvZHJpdmVycy9ncHUvZHJtL2k5MTUvaW50ZWxfbWVtb3J5X3JlZ2lvbi5oCisrKyBiL2RyaXZl cnMvZ3B1L2RybS9pOTE1L2ludGVsX21lbW9yeV9yZWdpb24uaApAQCAtMTMsOCArMTMsNiBAQAog I2luY2x1ZGUgPGRybS9kcm1fbW0uaD4KICNpbmNsdWRlIDxkcm0vaTkxNV9kcm0uaD4KIAotI2lu Y2x1ZGUgImk5MTVfYnVkZHkuaCIKLQogc3RydWN0IGRybV9pOTE1X3ByaXZhdGU7CiBzdHJ1Y3Qg ZHJtX2k5MTVfZ2VtX29iamVjdDsKIHN0cnVjdCBpbnRlbF9tZW1vcnlfcmVnaW9uOwpAQCAtMjUs NiArMjMsNyBAQCBlbnVtIGludGVsX21lbW9yeV90eXBlIHsKIAlJTlRFTF9NRU1PUllfTE9DQUwg PSBJOTE1X01FTU9SWV9DTEFTU19ERVZJQ0UsCiAJSU5URUxfTUVNT1JZX1NUT0xFTl9TWVNURU0s CiAJSU5URUxfTUVNT1JZX1NUT0xFTl9MT0NBTCwKKwlJTlRFTF9NRU1PUllfTU9DSywKIH07CiAK IGVudW0gaW50ZWxfcmVnaW9uX2lkIHsKQEAgLTU5LDEwICs1OCwxOSBAQCBzdHJ1Y3QgaW50ZWxf bWVtb3J5X3JlZ2lvbl9vcHMgewogCQkJICAgdW5zaWduZWQgaW50IGZsYWdzKTsKIH07CiAKK3N0 cnVjdCBpbnRlbF9tZW1vcnlfcmVnaW9uX3ByaXZhdGVfb3BzIHsKKwl2b2lkICooKnJlc2VydmUp KHN0cnVjdCBpbnRlbF9tZW1vcnlfcmVnaW9uICptZW0sCisJCQkgcmVzb3VyY2Vfc2l6ZV90IG9m ZnNldCwKKwkJCSByZXNvdXJjZV9zaXplX3Qgc2l6ZSk7CisJdm9pZCAoKmZyZWUpKHN0cnVjdCBp bnRlbF9tZW1vcnlfcmVnaW9uICptZW0sCisJCSAgICAgdm9pZCAqbm9kZSk7Cit9OworCiBzdHJ1 Y3QgaW50ZWxfbWVtb3J5X3JlZ2lvbiB7CiAJc3RydWN0IGRybV9pOTE1X3ByaXZhdGUgKmk5MTU7 CiAKIAljb25zdCBzdHJ1Y3QgaW50ZWxfbWVtb3J5X3JlZ2lvbl9vcHMgKm9wczsKKwljb25zdCBz dHJ1Y3QgaW50ZWxfbWVtb3J5X3JlZ2lvbl9wcml2YXRlX29wcyAqcHJpdl9vcHM7CiAKIAlzdHJ1 Y3QgaW9fbWFwcGluZyBpb21hcDsKIAlzdHJ1Y3QgcmVzb3VyY2UgcmVnaW9uOwpAQCAtNzAsNyAr NzgsNiBAQCBzdHJ1Y3QgaW50ZWxfbWVtb3J5X3JlZ2lvbiB7CiAJLyogRm9yIGZha2UgTE1FTSAq LwogCXN0cnVjdCBkcm1fbW1fbm9kZSBmYWtlX21hcHBhYmxlOwogCi0Jc3RydWN0IGk5MTVfYnVk ZHlfbW0gbW07CiAJc3RydWN0IG11dGV4IG1tX2xvY2s7CiAKIAlzdHJ1Y3Qga3JlZiBrcmVmOwpA QCAtOTUsMzYgKzEwMiwyNiBAQCBzdHJ1Y3QgaW50ZWxfbWVtb3J5X3JlZ2lvbiB7CiAJCXN0cnVj dCBsaXN0X2hlYWQgbGlzdDsKIAkJc3RydWN0IGxpc3RfaGVhZCBwdXJnZWFibGU7CiAJfSBvYmpl Y3RzOworCisJc2l6ZV90IGNodW5rX3NpemU7CisJdW5zaWduZWQgaW50IG1heF9vcmRlcjsKKwli b29sIGlzX3JhbmdlX21hbmFnZXI7CisKKwl2b2lkICpyZWdpb25fcHJpdmF0ZTsKIH07CiAKIHN0 cnVjdCBpbnRlbF9tZW1vcnlfcmVnaW9uICoKIGludGVsX21lbW9yeV9yZWdpb25fbG9va3VwKHN0 cnVjdCBkcm1faTkxNV9wcml2YXRlICppOTE1LAogCQkJICAgdTE2IGNsYXNzLCB1MTYgaW5zdGFu Y2UpOwogCi1pbnQgaW50ZWxfbWVtb3J5X3JlZ2lvbl9pbml0X2J1ZGR5KHN0cnVjdCBpbnRlbF9t ZW1vcnlfcmVnaW9uICptZW0pOwotdm9pZCBpbnRlbF9tZW1vcnlfcmVnaW9uX3JlbGVhc2VfYnVk ZHkoc3RydWN0IGludGVsX21lbW9yeV9yZWdpb24gKm1lbSk7Ci0KLWludCBfX2ludGVsX21lbW9y eV9yZWdpb25fZ2V0X3BhZ2VzX2J1ZGR5KHN0cnVjdCBpbnRlbF9tZW1vcnlfcmVnaW9uICptZW0s Ci0JCQkJCSAgcmVzb3VyY2Vfc2l6ZV90IHNpemUsCi0JCQkJCSAgdW5zaWduZWQgaW50IGZsYWdz LAotCQkJCQkgIHN0cnVjdCBsaXN0X2hlYWQgKmJsb2Nrcyk7Ci1zdHJ1Y3QgaTkxNV9idWRkeV9i bG9jayAqCi1fX2ludGVsX21lbW9yeV9yZWdpb25fZ2V0X2Jsb2NrX2J1ZGR5KHN0cnVjdCBpbnRl bF9tZW1vcnlfcmVnaW9uICptZW0sCi0JCQkJICAgICAgcmVzb3VyY2Vfc2l6ZV90IHNpemUsCi0J CQkJICAgICAgdW5zaWduZWQgaW50IGZsYWdzKTsKLXZvaWQgX19pbnRlbF9tZW1vcnlfcmVnaW9u X3B1dF9wYWdlc19idWRkeShzdHJ1Y3QgaW50ZWxfbWVtb3J5X3JlZ2lvbiAqbWVtLAotCQkJCQkg ICBzdHJ1Y3QgbGlzdF9oZWFkICpibG9ja3MpOwotdm9pZCBfX2ludGVsX21lbW9yeV9yZWdpb25f cHV0X2Jsb2NrX2J1ZGR5KHN0cnVjdCBpOTE1X2J1ZGR5X2Jsb2NrICpibG9jayk7Ci0KLWludCBp bnRlbF9tZW1vcnlfcmVnaW9uX3Jlc2VydmUoc3RydWN0IGludGVsX21lbW9yeV9yZWdpb24gKm1l bSwKLQkJCQl1NjQgb2Zmc2V0LCB1NjQgc2l6ZSk7Ci0KIHN0cnVjdCBpbnRlbF9tZW1vcnlfcmVn aW9uICoKIGludGVsX21lbW9yeV9yZWdpb25fY3JlYXRlKHN0cnVjdCBkcm1faTkxNV9wcml2YXRl ICppOTE1LAogCQkJICAgcmVzb3VyY2Vfc2l6ZV90IHN0YXJ0LAogCQkJICAgcmVzb3VyY2Vfc2l6 ZV90IHNpemUsCiAJCQkgICByZXNvdXJjZV9zaXplX3QgbWluX3BhZ2Vfc2l6ZSwKIAkJCSAgIHJl c291cmNlX3NpemVfdCBpb19zdGFydCwKKwkJCSAgIHUxNiB0eXBlLAorCQkJICAgdTE2IGluc3Rh bmNlLAogCQkJICAgY29uc3Qgc3RydWN0IGludGVsX21lbW9yeV9yZWdpb25fb3BzICpvcHMpOwog CiBzdHJ1Y3QgaW50ZWxfbWVtb3J5X3JlZ2lvbiAqCkBAIC0xNDEsNCArMTM4LDkgQEAgX19wcmlu dGYoMiwgMykgdm9pZAogaW50ZWxfbWVtb3J5X3JlZ2lvbl9zZXRfbmFtZShzdHJ1Y3QgaW50ZWxf bWVtb3J5X3JlZ2lvbiAqbWVtLAogCQkJICAgICBjb25zdCBjaGFyICpmbXQsIC4uLik7CiAKK3Zv aWQgaW50ZWxfbWVtb3J5X3JlZ2lvbl91bnJlc2VydmUoc3RydWN0IGludGVsX21lbW9yeV9yZWdp b24gKm1lbSk7CisKK2ludCBpbnRlbF9tZW1vcnlfcmVnaW9uX3Jlc2VydmUoc3RydWN0IGludGVs X21lbW9yeV9yZWdpb24gKm1lbSwKKwkJCQlyZXNvdXJjZV9zaXplX3Qgb2Zmc2V0LAorCQkJCXJl c291cmNlX3NpemVfdCBzaXplKTsKICNlbmRpZgpkaWZmIC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJt L2k5MTUvaW50ZWxfcmVnaW9uX3R0bS5jIGIvZHJpdmVycy9ncHUvZHJtL2k5MTUvaW50ZWxfcmVn aW9uX3R0bS5jCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwMC4uOWZiNDQ3 ZTE5ZWJkCi0tLSAvZGV2L251bGwKKysrIGIvZHJpdmVycy9ncHUvZHJtL2k5MTUvaW50ZWxfcmVn aW9uX3R0bS5jCkBAIC0wLDAgKzEsMjQ1IEBACisvLyBTUERYLUxpY2Vuc2UtSWRlbnRpZmllcjog TUlUCisvKgorICogQ29weXJpZ2h0IMKpIDIwMjEgSW50ZWwgQ29ycG9yYXRpb24KKyAqLworI2lu Y2x1ZGUgPGRybS90dG0vdHRtX2JvX2RyaXZlci5oPgorI2luY2x1ZGUgPGRybS90dG0vdHRtX2Rl dmljZS5oPgorCisjaW5jbHVkZSAiaTkxNV9kcnYuaCIKKyNpbmNsdWRlICJpOTE1X3NjYXR0ZXJs aXN0LmgiCisKKyNpbmNsdWRlICJpbnRlbF9yZWdpb25fdHRtLmgiCisKKy8qIEEgWmVyby1pbml0 aWFsaXplZCBkcml2ZXIgZm9yIG5vdy4gV2UgZG9uJ3QgaGF2ZSBhIFRUTSBiYWNrZW5kIHlldC4g Ki8KK3N0YXRpYyBzdHJ1Y3QgdHRtX2RldmljZV9mdW5jcyBpOTE1X3R0bV9ib19kcml2ZXI7CisK Ky8qKgorICogRE9DOiBUVE0gc3VwcG9ydCBzdHJ1Y3R1cmUKKyAqCisgKiBUaGUgY29kZSBpbiB0 aGlzIGZpbGUgZGVhbHMgd2l0aCBzZXR0aW5nIHVwIG1lbW9yeSBtYW5hZ2VycyBmb3IgVFRNCisg KiBMTUVNIGFuZCBNT0NLIHJlZ2lvbnMgYW5kIGNvbnZlcnRpbmcgdGhlIG91dHB1dCBmcm9tCisg KiB0aGUgbWFuYWdlcnMgdG8gc3RydWN0IHNnX3RhYmxlLCBCYXNpY2FsbHkgcHJvdmlkaW5nIHRo ZSBtYXBwaW5nIGZyb20KKyAqIGk5MTUgR0VNIHJlZ2lvbnMgdG8gVFRNIG1lbW9yeSB0eXBlcyBh bmQgcmVzb3VyY2UgbWFuYWdlcnMuCisgKi8KKworLyoqCisgKiBpbnRlbF9yZWdpb25fdHRtX2Rl dmljZV9pbml0IC0gSW5pdGlhbGl6ZSBhIFRUTSBkZXZpY2UKKyAqIEBkZXZfcHJpdjogUG9pbnRl ciB0byBhbiBpOTE1IGRldmljZSBwcml2YXRlIHN0cnVjdHVyZS4KKyAqCisgKiBSZXR1cm46IDAg b24gc3VjY2VzcywgbmVnYXRpdmUgZXJyb3IgY29kZSBvbiBmYWlsdXJlLgorICovCitpbnQgaW50 ZWxfcmVnaW9uX3R0bV9kZXZpY2VfaW5pdChzdHJ1Y3QgZHJtX2k5MTVfcHJpdmF0ZSAqZGV2X3By aXYpCit7CisJc3RydWN0IGRybV9kZXZpY2UgKmRybSA9ICZkZXZfcHJpdi0+ZHJtOworCisJcmV0 dXJuIHR0bV9kZXZpY2VfaW5pdCgmZGV2X3ByaXYtPmJkZXYsICZpOTE1X3R0bV9ib19kcml2ZXIs CisJCQkgICAgICAgZHJtLT5kZXYsIGRybS0+YW5vbl9pbm9kZS0+aV9tYXBwaW5nLAorCQkJICAg ICAgIGRybS0+dm1hX29mZnNldF9tYW5hZ2VyLCBmYWxzZSwgZmFsc2UpOworfQorCisvKioKKyAq IGludGVsX3JlZ2lvbl90dG1fZGV2aWNlX2ZpbmkgLSBGaW5hbGl6ZSBhIFRUTSBkZXZpY2UKKyAq IEBkZXZfcHJpdjogUG9pbnRlciB0byBhbiBpOTE1IGRldmljZSBwcml2YXRlIHN0cnVjdHVyZS4K KyAqLwordm9pZCBpbnRlbF9yZWdpb25fdHRtX2RldmljZV9maW5pKHN0cnVjdCBkcm1faTkxNV9w cml2YXRlICpkZXZfcHJpdikKK3sKKwl0dG1fZGV2aWNlX2ZpbmkoJmRldl9wcml2LT5iZGV2KTsK K30KKworLyoKKyAqIE1hcCB0aGUgaTkxNSBtZW1vcnkgcmVnaW9ucyB0byBUVE0gbWVtb3J5IHR5 cGVzLiBXZSB1c2UgdGhlCisgKiBkcml2ZXItcHJpdmF0ZSB0eXBlcyBmb3Igbm93LCByZXNlcnZp bmcgVFRNX1BMX1ZSQU0gZm9yIHN0b2xlbgorICogbWVtb3J5IGFuZCBUVE1fUExfVFQgZm9yIEdH VFQgdXNlIGlmIGRlY2lkZWQgdG8gaW1wbGVtZW50IHRoaXMuCisgKi8KK3N0YXRpYyBpbnQgaW50 ZWxfcmVnaW9uX3RvX3R0bV90eXBlKHN0cnVjdCBpbnRlbF9tZW1vcnlfcmVnaW9uICptZW0pCit7 CisJaW50IHR5cGU7CisKKwlHRU1fQlVHX09OKG1lbS0+dHlwZSAhPSBJTlRFTF9NRU1PUllfTE9D QUwpOworCisJdHlwZSA9IG1lbS0+aW5zdGFuY2UgKyBUVE1fUExfUFJJVjsKKwlHRU1fQlVHX09O KHR5cGUgPj0gVFRNX05VTV9NRU1fVFlQRVMpOworCisJcmV0dXJuIHR5cGU7Cit9CisKK3N0YXRp YyB2b2lkICppbnRlbF9yZWdpb25fdHRtX25vZGVfcmVzZXJ2ZShzdHJ1Y3QgaW50ZWxfbWVtb3J5 X3JlZ2lvbiAqbWVtLAorCQkJCQkgICByZXNvdXJjZV9zaXplX3Qgb2Zmc2V0LAorCQkJCQkgICBy ZXNvdXJjZV9zaXplX3Qgc2l6ZSkKK3sKKwlzdHJ1Y3QgdHRtX3Jlc291cmNlX21hbmFnZXIgKm1h biA9IG1lbS0+cmVnaW9uX3ByaXZhdGU7CisJc3RydWN0IHR0bV9wbGFjZSBwbGFjZSA9IHt9Owor CXN0cnVjdCB0dG1fcmVzb3VyY2UgcmVzID0ge307CisJc3RydWN0IHR0bV9idWZmZXJfb2JqZWN0 IG1vY2tfYm8gPSB7fTsKKwlpbnQgcmV0OworCisJLyoKKwkgKiBIYXZpbmcgdG8gdXNlIGEgbW9j a19ibyBpcyB1bmZvcnR1bmF0ZSBidXQgc3RlbXMgZnJvbSBzb21lCisJICogZHJpdmVycyBoYXZp bmcgcHJpdmF0ZSBtYW5hZ2VycyB0aGF0IGluc2lzdCB0byBrbm93IHdoYXQgdGhlCisJICogYWxs b2NhdGUgbWVtb3J5IGlzIGludGVuZGVkIGZvciwgdXNpbmcgaXQgdG8gc2VuZCBwcml2YXRlCisJ ICogZGF0YSB0byB0aGUgbWFuYWdlci4gQWxzbyByZWNlbnRseSB0aGUgYm8gaGFzIGJlZW4gdXNl ZCB0byBzZW5kCisJICogYWxpZ25tZW50IGluZm8gdG8gdGhlIG1hbmFnZXIuIEFzc3VtZSB0aGF0 IGFwYXJ0IGZyb20gdGhlIGxhdHRlciwKKwkgKiBub25lIG9mIHRoZSBtYW5hZ2VycyB3ZSB1c2Ug d2lsbCBldmVyIGFjY2VzcyB0aGUgYnVmZmVyIG9iamVjdAorCSAqIG1lbWJlcnMsIGhvcGluZyB3 ZSBjYW4gcGFzcyB0aGUgYWxpZ25tZW50IGluZm8gaW4gdGhlCisJICogc3RydWN0IHR0bV9wbGFj ZSBpbiB0aGUgZnV0dXJlLgorCSAqLworCisJcGxhY2UuZnBmbiA9IG9mZnNldCA+PiBQQUdFX1NI SUZUOworCXBsYWNlLmxwZm4gPSBwbGFjZS5mcGZuICsgKHNpemUgPj4gUEFHRV9TSElGVCk7CisJ cmVzLm51bV9wYWdlcyA9IHNpemUgPj4gUEFHRV9TSElGVDsKKwlyZXQgPSBtYW4tPmZ1bmMtPmFs bG9jKG1hbiwgJm1vY2tfYm8sICZwbGFjZSwgJnJlcyk7CisJaWYgKHJldCA9PSAtRU5PU1BDKQor CQlyZXQgPSAtRU5YSU87CisKKwlyZXR1cm4gcmV0ID8gRVJSX1BUUihyZXQpIDogcmVzLm1tX25v ZGU7Cit9CisKKy8qKgorICogaW50ZWxfcmVnaW9uX3R0bV9ub2RlX2ZyZWUgLSBGcmVlIGEgbm9k ZSBhbGxvY2F0ZWQgZnJvbSBhIHJlc291cmNlIG1hbmFnZXIKKyAqIEBtZW06IFRoZSByZWdpb24g dGhlIG5vZGUgd2FzIGFsbG9jYXRlZCBmcm9tLgorICogQG5vZGU6IFRoZSBvcGFxdWUgbm9kZSBy ZXByZXNlbnRpbmcgYW4gYWxsb2NhdGlvbi4KKyAqLwordm9pZCBpbnRlbF9yZWdpb25fdHRtX25v ZGVfZnJlZShzdHJ1Y3QgaW50ZWxfbWVtb3J5X3JlZ2lvbiAqbWVtLAorCQkJCXZvaWQgKm5vZGUp Cit7CisJc3RydWN0IHR0bV9yZXNvdXJjZV9tYW5hZ2VyICptYW4gPSBtZW0tPnJlZ2lvbl9wcml2 YXRlOworCXN0cnVjdCB0dG1fcmVzb3VyY2UgcmVzID0ge307CisKKwlyZXMubW1fbm9kZSA9IG5v ZGU7CisJbWFuLT5mdW5jLT5mcmVlKG1hbiwgJnJlcyk7Cit9CisKK3N0YXRpYyBjb25zdCBzdHJ1 Y3QgaW50ZWxfbWVtb3J5X3JlZ2lvbl9wcml2YXRlX29wcyBwcml2X29wcyA9IHsKKwkucmVzZXJ2 ZSA9IGludGVsX3JlZ2lvbl90dG1fbm9kZV9yZXNlcnZlLAorCS5mcmVlID0gaW50ZWxfcmVnaW9u X3R0bV9ub2RlX2ZyZWUsCit9OworCisvKioKKyAqIGludGVsX3JlZ2lvbl90dG1faW5pdCAtIElu aXRpYWxpemUgYSBtZW1vcnkgcmVnaW9uIGZvciBUVE0uCisgKiBAbWVtOiBUaGUgcmVnaW9uIHRv IGluaXRpYWxpemUuCisgKgorICogVGhpcyBmdW5jdGlvbiBpbml0aWFsaXplcyBhIHN1aXRhYmxl IFRUTSByZXNvdXJjZSBtYW5hZ2VyIGZvciB0aGUKKyAqIHJlZ2lvbiwgYW5kIGlmIGl0J3MgYSBM TUVNIHJlZ2lvbiB0eXBlLCBhdHRhY2hlcyBpdCB0byB0aGUgVFRNCisgKiBkZXZpY2UuIE1PQ0sg cmVnaW9ucyBhcmUgTk9UIGF0dGFjaGVkIHRvIHRoZSBUVE0gZGV2aWNlLCBzaW5jZSB3ZSBkb24n dAorICogaGF2ZSBvbmUgZm9yIHRoZSBtb2NrIHNlbGZ0ZXN0cy4KKyAqCisgKiBSZXR1cm46IDAg b24gc3VjY2VzcywgbmVnYXRpdmUgZXJyb3IgY29kZSBvbiBmYWlsdXJlLgorICovCitpbnQgaW50 ZWxfcmVnaW9uX3R0bV9pbml0KHN0cnVjdCBpbnRlbF9tZW1vcnlfcmVnaW9uICptZW0pCit7CisJ c3RydWN0IHR0bV9yZXNvdXJjZV9tYW5hZ2VyICptYW47CisKKwltYW4gPSB0dG1fcmFuZ2VfbWFu X2luaXRfc3RhbmRhbG9uZShyZXNvdXJjZV9zaXplKCZtZW0tPnJlZ2lvbikgPj4KKwkJCQkJICAg IFBBR0VfU0hJRlQsIGZhbHNlKTsKKwlpZiAoSVNfRVJSKG1hbikpCisJCXJldHVybiBQVFJfRVJS KG1hbik7CisKKwl0dG1fcmVzb3VyY2VfbWFuYWdlcl9zZXRfdXNlZChtYW4sIHRydWUpOworCW1l bS0+Y2h1bmtfc2l6ZSA9IFBBR0VfU0laRTsKKwltZW0tPm1heF9vcmRlciA9CisJCWdldF9vcmRl cihyb3VuZGRvd25fcG93X29mX3R3byhyZXNvdXJjZV9zaXplKCZtZW0tPnJlZ2lvbikpKTsKKwlt ZW0tPmlzX3JhbmdlX21hbmFnZXIgPSB0cnVlOworCW1lbS0+cHJpdl9vcHMgPSAmcHJpdl9vcHM7 CisJbWVtLT5yZWdpb25fcHJpdmF0ZSA9IG1hbjsKKworCS8qCisJICogUmVnaXN0ZXIgb25seSBM T0NBTCBtZW1vcnkgd2l0aCB0aGUgZGV2aWNlIHNvIHRoYXQgd2UgY2FuCisJICogcnVuIHRoZSBt b2NrIHNlbGZ0ZXN0cyB1c2luZyB0aGUgbWFuYWdlci4KKwkgKi8KKwlpZiAobWVtLT50eXBlID09 IElOVEVMX01FTU9SWV9MT0NBTCkgeworCQl0dG1fc2V0X2RyaXZlcl9tYW5hZ2VyKCZtZW0tPmk5 MTUtPmJkZXYsCisJCQkJICAgICAgIGludGVsX3JlZ2lvbl90b190dG1fdHlwZShtZW0pLAorCQkJ CSAgICAgICBtYW4pOworCX0KKworCXJldHVybiAwOworfQorCisvKioKKyAqIGludGVsX3JlZ2lv bl90dG1fZmluaSAtIEZpbmFsaXplIGEgVFRNIHJlZ2lvbi4KKyAqIEBtZW06IFRoZSBtZW1vcnkg cmVnaW9uCisgKgorICogVGhpcyBmdW5jdGlvbnMgdGFrZXMgZG93biB0aGUgVFRNIHJlc291cmNl IG1hbmFnZXIgYXNzb2NpYXRlZCB3aXRoIHRoZQorICogbWVtb3J5IHJlZ2lvbiwgYW5kIGlmIGl0 IHdhcyByZWdpc3RlcmVkIHdpdGggdGhlIFRUTSBkZXZpY2UsCisgKiByZW1vdmVzIHRoYXQgcmVn aXN0cmF0aW9uLgorICovCit2b2lkIGludGVsX3JlZ2lvbl90dG1fZmluaShzdHJ1Y3QgaW50ZWxf bWVtb3J5X3JlZ2lvbiAqbWVtKQoreworCXN0cnVjdCB0dG1fcmVzb3VyY2VfbWFuYWdlciAqbWFu ID0gbWVtLT5yZWdpb25fcHJpdmF0ZTsKKworCWlmIChtZW0tPnR5cGUgPT0gSU5URUxfTUVNT1JZ X0xPQ0FMKSB7CisJCWludCByZXQ7CisKKwkJcmV0ID0gdHRtX3JhbmdlX21hbl9maW5pKCZtZW0t Pmk5MTUtPmJkZXYsCisJCQkJCSBpbnRlbF9yZWdpb25fdG9fdHRtX3R5cGUobWVtKSk7CisJCUdF TV9XQVJOX09OKHJldCk7CisJfSBlbHNlIHsKKwkJdHRtX3Jlc291cmNlX21hbmFnZXJfc2V0X3Vz ZWQobWFuLCBmYWxzZSk7CisJCXR0bV9yYW5nZV9tYW5fZmluaV9zdGFuZGFsb25lKG1hbik7CisJ fQorfQorCisvKioKKyAqIGludGVsX3JlZ2lvbl90dG1fbm9kZV90b19zdCAtIENvbnZlcnQgYW4g b3BhcXVlIFRUTSByZXNvdXJjZSBtYW5hZ2VyIG5vZGUKKyAqIHRvIGFuIHNnX3RhYmxlLgorICog QG1lbTogVGhlIG1lbW9yeSByZWdpb24uCisgKiBAbm9kZTogVGhlIHJlc291cmNlIG1hbmFnZXIg bm9kZSBvYnRhaW5lZCBmcm9tIHRoZSBUVE0gcmVzb3VyY2UgbWFuYWdlci4KKyAqCisgKiBUaGUg Z2VtIGJhY2tlbmRzIHR5cGljYWxseSB1c2Ugc2ctdGFibGVzIGZvciBvcGVyYXRpb25zIG9uIHRo ZSB1bmRlcmx5aW5nCisgKiBpb19tZW1vcnkuIFNvIHByb3ZpZGUgYSB3YXkgZm9yIHRoZSBiYWNr ZW5kcyB0byB0cmFuc2xhdGUgdGhlCisgKiBub2RlcyB0aGV5IGFyZSBoYW5kZWQgZnJvbSBUVE0g dG8gc2ctdGFibGVzLgorICoKKyAqIFJldHVybjogQSBtYWxsb2NlZCBzZ190YWJsZSBvbiBzdWNj ZXNzLCBhbiBlcnJvciBwb2ludGVyIG9uIGZhaWx1cmUuCisgKi8KK3N0cnVjdCBzZ190YWJsZSAq aW50ZWxfcmVnaW9uX3R0bV9ub2RlX3RvX3N0KHN0cnVjdCBpbnRlbF9tZW1vcnlfcmVnaW9uICpt ZW0sCisJCQkJCSAgICAgdm9pZCAqbm9kZSkKK3sKKwlyZXR1cm4gaTkxNV9zZ19mcm9tX21tX25v ZGUobm9kZSwgbWVtLT5yZWdpb24uc3RhcnQpOworfQorCisvKioKKyAqIGludGVsX3JlZ2lvbl90 dG1fbm9kZV9hbGxvYyAtIEFsbG9jYXRlIG1lbW9yeSByZXNvdXJjZXMgZnJvbSBhIHJlZ2lvbgor ICogQG1lbTogVGhlIG1lbW9yeSByZWdpb24sCisgKiBAc2l6ZTogVGhlIHJlcXVlc3RlZCBzaXpl IGluIGJ5dGVzCisgKiBAZmxhZ3M6IEFsbG9jYXRpb24gZmxhZ3MKKyAqCisgKiBUaGlzIGZ1bmN0 aW9uYWxpdHkgaXMgcHJvdmlkZWQgb25seSBmb3IgY2FsbGVycyB0aGF0IG5lZWQgdG8gYWxsb2Nh dGUKKyAqIG1lbW9yeSBmcm9tIHN0YW5kYWxvbmUgVFRNIHJhbmdlIG1hbmFnZXJzLCB3aXRob3V0 IHRoZSBUVE0gZXZpY3Rpb24KKyAqIGZ1bmN0aW9uYWxpdHkuIERvbid0IHVzZSBpZiB5b3UgYXJl IG5vdCBjb21wbGV0ZWx5IHN1cmUgdGhhdCdzIHRoZQorICogY2FzZS4gVGhlIHJldHVybmVkIG9w YXF1ZSBub2RlIGNhbiBiZSBjb252ZXJ0ZWQgdG8gYW4gc2dfdGFibGUgdXNpbmcKKyAqIGludGVs X3JlZ2lvbl90dG1fbm9kZV90b19zdCgpLCBhbmQgY2FuIGJlIGZyZWVkIHVzaW5nCisgKiBpbnRl bF9yZWdpb25fdHRtX25vZGVfZnJlZSgpLgorICoKKyAqIFJldHVybjogQSB2YWxpZCBwb2ludGVy IG9uIHN1Y2Nlc3MsIGFuIGVycm9yIHBvaW50ZXIgb24gZmFpbHVyZS4KKyAqLwordm9pZCAqaW50 ZWxfcmVnaW9uX3R0bV9ub2RlX2FsbG9jKHN0cnVjdCBpbnRlbF9tZW1vcnlfcmVnaW9uICptZW0s CisJCQkJICByZXNvdXJjZV9zaXplX3Qgc2l6ZSwKKwkJCQkgIHVuc2lnbmVkIGludCBmbGFncykK K3sKKwlzdHJ1Y3QgdHRtX3Jlc291cmNlX21hbmFnZXIgKm1hbiA9IG1lbS0+cmVnaW9uX3ByaXZh dGU7CisJc3RydWN0IHR0bV9wbGFjZSBwbGFjZSA9IHt9OworCXN0cnVjdCB0dG1fcmVzb3VyY2Ug cmVzID0ge307CisJc3RydWN0IHR0bV9idWZmZXJfb2JqZWN0IG1vY2tfYm8gPSB7fTsKKwlpbnQg cmV0OworCisJLyoKKwkgKiBXZSBpZ25vcmUgdGhlIGZsYWdzIGZvciBub3cgc2luY2Ugd2UncmUg dXNpbmcgdGhlIHJhbmdlCisJICogbWFuYWdlciBhbmQgY29udGlnb3VzIGFuZCBtaW4gcGFnZSBz aXplIHdvdWxkIGJlIGZ1bGZpbGxlZAorCSAqIGJ5IGRlZmF1bHQgaWYgc2l6ZSBpcyBtaW4gcGFn ZSBzaXplIGFsaWduZWQuCisJICovCisJcmVzLm51bV9wYWdlcyA9IHNpemUgPj4gUEFHRV9TSElG VDsKKworCWlmIChtZW0tPmlzX3JhbmdlX21hbmFnZXIpIHsKKwkJaWYgKHNpemUgPj0gU1pfMUcp CisJCQltb2NrX2JvLnBhZ2VfYWxpZ25tZW50ID0gU1pfMUcgPj4gUEFHRV9TSElGVDsKKwkJZWxz ZSBpZiAoc2l6ZSA+PSBTWl8yTSkKKwkJCW1vY2tfYm8ucGFnZV9hbGlnbm1lbnQgPSBTWl8yTSA+ PiBQQUdFX1NISUZUOworCQllbHNlIGlmIChzaXplID49IFNaXzY0SykKKwkJCW1vY2tfYm8ucGFn ZV9hbGlnbm1lbnQgPSBTWl82NEsgPj4gUEFHRV9TSElGVDsKKwl9CisKKwlyZXQgPSBtYW4tPmZ1 bmMtPmFsbG9jKG1hbiwgJm1vY2tfYm8sICZwbGFjZSwgJnJlcyk7CisJaWYgKHJldCA9PSAtRU5P U1BDKQorCQlyZXQgPSAtRU5YSU87CisJcmV0dXJuIHJldCA/IEVSUl9QVFIocmV0KSA6IHJlcy5t bV9ub2RlOworfQpkaWZmIC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJtL2k5MTUvaW50ZWxfcmVnaW9u X3R0bS5oIGIvZHJpdmVycy9ncHUvZHJtL2k5MTUvaW50ZWxfcmVnaW9uX3R0bS5oCm5ldyBmaWxl IG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwMC4uNDAxMjlmN2UwMzE3Ci0tLSAvZGV2L251 bGwKKysrIGIvZHJpdmVycy9ncHUvZHJtL2k5MTUvaW50ZWxfcmVnaW9uX3R0bS5oCkBAIC0wLDAg KzEsMjkgQEAKKy8qIFNQRFgtTGljZW5zZS1JZGVudGlmaWVyOiBNSVQgKi8KKy8qCisgKiBDb3B5 cmlnaHQgwqkgMjAyMSBJbnRlbCBDb3Jwb3JhdGlvbgorICovCisjaWZuZGVmIF9JTlRFTF9SRUdJ T05fVFRNX0hfCisjZGVmaW5lIF9JTlRFTF9SRUdJT05fVFRNX0hfCisKKyNpbmNsdWRlIDxsaW51 eC90eXBlcy5oPgorCitzdHJ1Y3QgZHJtX2k5MTVfcHJpdmF0ZTsKK3N0cnVjdCBpbnRlbF9tZW1v cnlfcmVnaW9uOworCitpbnQgaW50ZWxfcmVnaW9uX3R0bV9kZXZpY2VfaW5pdChzdHJ1Y3QgZHJt X2k5MTVfcHJpdmF0ZSAqZGV2X3ByaXYpOworCit2b2lkIGludGVsX3JlZ2lvbl90dG1fZGV2aWNl X2Zpbmkoc3RydWN0IGRybV9pOTE1X3ByaXZhdGUgKmRldl9wcml2KTsKKworaW50IGludGVsX3Jl Z2lvbl90dG1faW5pdChzdHJ1Y3QgaW50ZWxfbWVtb3J5X3JlZ2lvbiAqbWVtKTsKKwordm9pZCBp bnRlbF9yZWdpb25fdHRtX2Zpbmkoc3RydWN0IGludGVsX21lbW9yeV9yZWdpb24gKm1lbSk7CisK K3N0cnVjdCBzZ190YWJsZSAqaW50ZWxfcmVnaW9uX3R0bV9ub2RlX3RvX3N0KHN0cnVjdCBpbnRl bF9tZW1vcnlfcmVnaW9uICptZW0sCisJCQkJCSAgICAgdm9pZCAqbm9kZSk7CisKK3ZvaWQgKmlu dGVsX3JlZ2lvbl90dG1fbm9kZV9hbGxvYyhzdHJ1Y3QgaW50ZWxfbWVtb3J5X3JlZ2lvbiAqbWVt LAorCQkJCSAgcmVzb3VyY2Vfc2l6ZV90IHNpemUsCisJCQkJICB1bnNpZ25lZCBpbnQgZmxhZ3Mp Owordm9pZCBpbnRlbF9yZWdpb25fdHRtX25vZGVfZnJlZShzdHJ1Y3QgaW50ZWxfbWVtb3J5X3Jl Z2lvbiAqbWVtLAorCQkJCXZvaWQgKm5vZGUpOworI2VuZGlmIC8qIF9JTlRFTF9SRUdJT05fVFRN X0hfICovCmRpZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9kcm0vaTkxNS9zZWxmdGVzdHMvaTkxNV9i dWRkeS5jIGIvZHJpdmVycy9ncHUvZHJtL2k5MTUvc2VsZnRlc3RzL2k5MTVfYnVkZHkuYwpkZWxl dGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggZjBmNWM0ZGY4ZGJjLi4wMDAwMDAwMDAwMDAKLS0t IGEvZHJpdmVycy9ncHUvZHJtL2k5MTUvc2VsZnRlc3RzL2k5MTVfYnVkZHkuYworKysgL2Rldi9u dWxsCkBAIC0xLDc4OSArMCwwIEBACi0vLyBTUERYLUxpY2Vuc2UtSWRlbnRpZmllcjogTUlUCi0v KgotICogQ29weXJpZ2h0IMKpIDIwMTkgSW50ZWwgQ29ycG9yYXRpb24KLSAqLwotCi0jaW5jbHVk ZSA8bGludXgvcHJpbWVfbnVtYmVycy5oPgotCi0jaW5jbHVkZSAiLi4vaTkxNV9zZWxmdGVzdC5o IgotI2luY2x1ZGUgImk5MTVfcmFuZG9tLmgiCi0KLXN0YXRpYyB2b2lkIF9faWd0X2R1bXBfYmxv Y2soc3RydWN0IGk5MTVfYnVkZHlfbW0gKm1tLAotCQkJICAgICBzdHJ1Y3QgaTkxNV9idWRkeV9i bG9jayAqYmxvY2ssCi0JCQkgICAgIGJvb2wgYnVkZHkpCi17Ci0JcHJfZXJyKCJibG9jayBpbmZv OiBoZWFkZXI9JWxseCwgc3RhdGU9JXUsIG9yZGVyPSVkLCBvZmZzZXQ9JWxseCBzaXplPSVsbHgg cm9vdD0lcyBidWRkeT0lc1xuIiwKLQkgICAgICAgYmxvY2stPmhlYWRlciwKLQkgICAgICAgaTkx NV9idWRkeV9ibG9ja19zdGF0ZShibG9jayksCi0JICAgICAgIGk5MTVfYnVkZHlfYmxvY2tfb3Jk ZXIoYmxvY2spLAotCSAgICAgICBpOTE1X2J1ZGR5X2Jsb2NrX29mZnNldChibG9jayksCi0JICAg ICAgIGk5MTVfYnVkZHlfYmxvY2tfc2l6ZShtbSwgYmxvY2spLAotCSAgICAgICB5ZXNubyghYmxv Y2stPnBhcmVudCksCi0JICAgICAgIHllc25vKGJ1ZGR5KSk7Ci19Ci0KLXN0YXRpYyB2b2lkIGln dF9kdW1wX2Jsb2NrKHN0cnVjdCBpOTE1X2J1ZGR5X21tICptbSwKLQkJCSAgIHN0cnVjdCBpOTE1 X2J1ZGR5X2Jsb2NrICpibG9jaykKLXsKLQlzdHJ1Y3QgaTkxNV9idWRkeV9ibG9jayAqYnVkZHk7 Ci0KLQlfX2lndF9kdW1wX2Jsb2NrKG1tLCBibG9jaywgZmFsc2UpOwotCi0JYnVkZHkgPSBnZXRf YnVkZHkoYmxvY2spOwotCWlmIChidWRkeSkKLQkJX19pZ3RfZHVtcF9ibG9jayhtbSwgYnVkZHks IHRydWUpOwotfQotCi1zdGF0aWMgaW50IGlndF9jaGVja19ibG9jayhzdHJ1Y3QgaTkxNV9idWRk eV9tbSAqbW0sCi0JCQkgICBzdHJ1Y3QgaTkxNV9idWRkeV9ibG9jayAqYmxvY2spCi17Ci0Jc3Ry dWN0IGk5MTVfYnVkZHlfYmxvY2sgKmJ1ZGR5OwotCXVuc2lnbmVkIGludCBibG9ja19zdGF0ZTsK LQl1NjQgYmxvY2tfc2l6ZTsKLQl1NjQgb2Zmc2V0OwotCWludCBlcnIgPSAwOwotCi0JYmxvY2tf c3RhdGUgPSBpOTE1X2J1ZGR5X2Jsb2NrX3N0YXRlKGJsb2NrKTsKLQotCWlmIChibG9ja19zdGF0 ZSAhPSBJOTE1X0JVRERZX0FMTE9DQVRFRCAmJgotCSAgICBibG9ja19zdGF0ZSAhPSBJOTE1X0JV RERZX0ZSRUUgJiYKLQkgICAgYmxvY2tfc3RhdGUgIT0gSTkxNV9CVUREWV9TUExJVCkgewotCQlw cl9lcnIoImJsb2NrIHN0YXRlIG1pc21hdGNoXG4iKTsKLQkJZXJyID0gLUVJTlZBTDsKLQl9Ci0K LQlibG9ja19zaXplID0gaTkxNV9idWRkeV9ibG9ja19zaXplKG1tLCBibG9jayk7Ci0Jb2Zmc2V0 ID0gaTkxNV9idWRkeV9ibG9ja19vZmZzZXQoYmxvY2spOwotCi0JaWYgKGJsb2NrX3NpemUgPCBt bS0+Y2h1bmtfc2l6ZSkgewotCQlwcl9lcnIoImJsb2NrIHNpemUgc21hbGxlciB0aGFuIG1pbiBz aXplXG4iKTsKLQkJZXJyID0gLUVJTlZBTDsKLQl9Ci0KLQlpZiAoIWlzX3Bvd2VyX29mXzIoYmxv Y2tfc2l6ZSkpIHsKLQkJcHJfZXJyKCJibG9jayBzaXplIG5vdCBwb3dlciBvZiB0d29cbiIpOwot CQllcnIgPSAtRUlOVkFMOwotCX0KLQotCWlmICghSVNfQUxJR05FRChibG9ja19zaXplLCBtbS0+ Y2h1bmtfc2l6ZSkpIHsKLQkJcHJfZXJyKCJibG9jayBzaXplIG5vdCBhbGlnbmVkIHRvIG1pbiBz aXplXG4iKTsKLQkJZXJyID0gLUVJTlZBTDsKLQl9Ci0KLQlpZiAoIUlTX0FMSUdORUQob2Zmc2V0 LCBtbS0+Y2h1bmtfc2l6ZSkpIHsKLQkJcHJfZXJyKCJibG9jayBvZmZzZXQgbm90IGFsaWduZWQg dG8gbWluIHNpemVcbiIpOwotCQllcnIgPSAtRUlOVkFMOwotCX0KLQotCWlmICghSVNfQUxJR05F RChvZmZzZXQsIGJsb2NrX3NpemUpKSB7Ci0JCXByX2VycigiYmxvY2sgb2Zmc2V0IG5vdCBhbGln bmVkIHRvIGJsb2NrIHNpemVcbiIpOwotCQllcnIgPSAtRUlOVkFMOwotCX0KLQotCWJ1ZGR5ID0g Z2V0X2J1ZGR5KGJsb2NrKTsKLQotCWlmICghYnVkZHkgJiYgYmxvY2stPnBhcmVudCkgewotCQlw cl9lcnIoImJ1ZGR5IGhhcyBnb25lIGZpc2hpbmdcbiIpOwotCQllcnIgPSAtRUlOVkFMOwotCX0K LQotCWlmIChidWRkeSkgewotCQlpZiAoaTkxNV9idWRkeV9ibG9ja19vZmZzZXQoYnVkZHkpICE9 IChvZmZzZXQgXiBibG9ja19zaXplKSkgewotCQkJcHJfZXJyKCJidWRkeSBoYXMgd3Jvbmcgb2Zm c2V0XG4iKTsKLQkJCWVyciA9IC1FSU5WQUw7Ci0JCX0KLQotCQlpZiAoaTkxNV9idWRkeV9ibG9j a19zaXplKG1tLCBidWRkeSkgIT0gYmxvY2tfc2l6ZSkgewotCQkJcHJfZXJyKCJidWRkeSBzaXpl IG1pc21hdGNoXG4iKTsKLQkJCWVyciA9IC1FSU5WQUw7Ci0JCX0KLQotCQlpZiAoaTkxNV9idWRk eV9ibG9ja19zdGF0ZShidWRkeSkgPT0gYmxvY2tfc3RhdGUgJiYKLQkJICAgIGJsb2NrX3N0YXRl ID09IEk5MTVfQlVERFlfRlJFRSkgewotCQkJcHJfZXJyKCJibG9jayBhbmQgaXRzIGJ1ZGR5IGFy ZSBmcmVlXG4iKTsKLQkJCWVyciA9IC1FSU5WQUw7Ci0JCX0KLQl9Ci0KLQlyZXR1cm4gZXJyOwot fQotCi1zdGF0aWMgaW50IGlndF9jaGVja19ibG9ja3Moc3RydWN0IGk5MTVfYnVkZHlfbW0gKm1t LAotCQkJICAgIHN0cnVjdCBsaXN0X2hlYWQgKmJsb2NrcywKLQkJCSAgICB1NjQgZXhwZWN0ZWRf c2l6ZSwKLQkJCSAgICBib29sIGlzX2NvbnRpZ3VvdXMpCi17Ci0Jc3RydWN0IGk5MTVfYnVkZHlf YmxvY2sgKmJsb2NrOwotCXN0cnVjdCBpOTE1X2J1ZGR5X2Jsb2NrICpwcmV2OwotCXU2NCB0b3Rh bDsKLQlpbnQgZXJyID0gMDsKLQotCWJsb2NrID0gTlVMTDsKLQlwcmV2ID0gTlVMTDsKLQl0b3Rh bCA9IDA7Ci0KLQlsaXN0X2Zvcl9lYWNoX2VudHJ5KGJsb2NrLCBibG9ja3MsIGxpbmspIHsKLQkJ ZXJyID0gaWd0X2NoZWNrX2Jsb2NrKG1tLCBibG9jayk7Ci0KLQkJaWYgKCFpOTE1X2J1ZGR5X2Js b2NrX2lzX2FsbG9jYXRlZChibG9jaykpIHsKLQkJCXByX2VycigiYmxvY2sgbm90IGFsbG9jYXRl ZFxuIiksCi0JCQllcnIgPSAtRUlOVkFMOwotCQl9Ci0KLQkJaWYgKGlzX2NvbnRpZ3VvdXMgJiYg cHJldikgewotCQkJdTY0IHByZXZfYmxvY2tfc2l6ZTsKLQkJCXU2NCBwcmV2X29mZnNldDsKLQkJ CXU2NCBvZmZzZXQ7Ci0KLQkJCXByZXZfb2Zmc2V0ID0gaTkxNV9idWRkeV9ibG9ja19vZmZzZXQo cHJldik7Ci0JCQlwcmV2X2Jsb2NrX3NpemUgPSBpOTE1X2J1ZGR5X2Jsb2NrX3NpemUobW0sIHBy ZXYpOwotCQkJb2Zmc2V0ID0gaTkxNV9idWRkeV9ibG9ja19vZmZzZXQoYmxvY2spOwotCi0JCQlp ZiAob2Zmc2V0ICE9IChwcmV2X29mZnNldCArIHByZXZfYmxvY2tfc2l6ZSkpIHsKLQkJCQlwcl9l cnIoImJsb2NrIG9mZnNldCBtaXNtYXRjaFxuIik7Ci0JCQkJZXJyID0gLUVJTlZBTDsKLQkJCX0K LQkJfQotCi0JCWlmIChlcnIpCi0JCQlicmVhazsKLQotCQl0b3RhbCArPSBpOTE1X2J1ZGR5X2Js b2NrX3NpemUobW0sIGJsb2NrKTsKLQkJcHJldiA9IGJsb2NrOwotCX0KLQotCWlmICghZXJyKSB7 Ci0JCWlmICh0b3RhbCAhPSBleHBlY3RlZF9zaXplKSB7Ci0JCQlwcl9lcnIoInNpemUgbWlzbWF0 Y2gsIGV4cGVjdGVkPSVsbHgsIGZvdW5kPSVsbHhcbiIsCi0JCQkgICAgICAgZXhwZWN0ZWRfc2l6 ZSwgdG90YWwpOwotCQkJZXJyID0gLUVJTlZBTDsKLQkJfQotCQlyZXR1cm4gZXJyOwotCX0KLQot CWlmIChwcmV2KSB7Ci0JCXByX2VycigicHJldiBibG9jaywgZHVtcDpcbiIpOwotCQlpZ3RfZHVt cF9ibG9jayhtbSwgcHJldik7Ci0JfQotCi0JaWYgKGJsb2NrKSB7Ci0JCXByX2VycigiYmFkIGJs b2NrLCBkdW1wOlxuIik7Ci0JCWlndF9kdW1wX2Jsb2NrKG1tLCBibG9jayk7Ci0JfQotCi0JcmV0 dXJuIGVycjsKLX0KLQotc3RhdGljIGludCBpZ3RfY2hlY2tfbW0oc3RydWN0IGk5MTVfYnVkZHlf bW0gKm1tKQotewotCXN0cnVjdCBpOTE1X2J1ZGR5X2Jsb2NrICpyb290OwotCXN0cnVjdCBpOTE1 X2J1ZGR5X2Jsb2NrICpwcmV2OwotCXVuc2lnbmVkIGludCBpOwotCXU2NCB0b3RhbDsKLQlpbnQg ZXJyID0gMDsKLQotCWlmICghbW0tPm5fcm9vdHMpIHsKLQkJcHJfZXJyKCJuX3Jvb3RzIGlzIHpl cm9cbiIpOwotCQlyZXR1cm4gLUVJTlZBTDsKLQl9Ci0KLQlpZiAobW0tPm5fcm9vdHMgIT0gaHdl aWdodDY0KG1tLT5zaXplKSkgewotCQlwcl9lcnIoIm5fcm9vdHMgbWlzbWF0Y2gsIG5fcm9vdHM9 JXUsIGV4cGVjdGVkPSVsdVxuIiwKLQkJICAgICAgIG1tLT5uX3Jvb3RzLCBod2VpZ2h0NjQobW0t PnNpemUpKTsKLQkJcmV0dXJuIC1FSU5WQUw7Ci0JfQotCi0Jcm9vdCA9IE5VTEw7Ci0JcHJldiA9 IE5VTEw7Ci0JdG90YWwgPSAwOwotCi0JZm9yIChpID0gMDsgaSA8IG1tLT5uX3Jvb3RzOyArK2kp IHsKLQkJc3RydWN0IGk5MTVfYnVkZHlfYmxvY2sgKmJsb2NrOwotCQl1bnNpZ25lZCBpbnQgb3Jk ZXI7Ci0KLQkJcm9vdCA9IG1tLT5yb290c1tpXTsKLQkJaWYgKCFyb290KSB7Ci0JCQlwcl9lcnIo InJvb3QoJXUpIGlzIE5VTExcbiIsIGkpOwotCQkJZXJyID0gLUVJTlZBTDsKLQkJCWJyZWFrOwot CQl9Ci0KLQkJZXJyID0gaWd0X2NoZWNrX2Jsb2NrKG1tLCByb290KTsKLQotCQlpZiAoIWk5MTVf YnVkZHlfYmxvY2tfaXNfZnJlZShyb290KSkgewotCQkJcHJfZXJyKCJyb290IG5vdCBmcmVlXG4i KTsKLQkJCWVyciA9IC1FSU5WQUw7Ci0JCX0KLQotCQlvcmRlciA9IGk5MTVfYnVkZHlfYmxvY2tf b3JkZXIocm9vdCk7Ci0KLQkJaWYgKCFpKSB7Ci0JCQlpZiAob3JkZXIgIT0gbW0tPm1heF9vcmRl cikgewotCQkJCXByX2VycigibWF4IG9yZGVyIHJvb3QgbWlzc2luZ1xuIik7Ci0JCQkJZXJyID0g LUVJTlZBTDsKLQkJCX0KLQkJfQotCi0JCWlmIChwcmV2KSB7Ci0JCQl1NjQgcHJldl9ibG9ja19z aXplOwotCQkJdTY0IHByZXZfb2Zmc2V0OwotCQkJdTY0IG9mZnNldDsKLQotCQkJcHJldl9vZmZz ZXQgPSBpOTE1X2J1ZGR5X2Jsb2NrX29mZnNldChwcmV2KTsKLQkJCXByZXZfYmxvY2tfc2l6ZSA9 IGk5MTVfYnVkZHlfYmxvY2tfc2l6ZShtbSwgcHJldik7Ci0JCQlvZmZzZXQgPSBpOTE1X2J1ZGR5 X2Jsb2NrX29mZnNldChyb290KTsKLQotCQkJaWYgKG9mZnNldCAhPSAocHJldl9vZmZzZXQgKyBw cmV2X2Jsb2NrX3NpemUpKSB7Ci0JCQkJcHJfZXJyKCJyb290IG9mZnNldCBtaXNtYXRjaFxuIik7 Ci0JCQkJZXJyID0gLUVJTlZBTDsKLQkJCX0KLQkJfQotCi0JCWJsb2NrID0gbGlzdF9maXJzdF9l bnRyeV9vcl9udWxsKCZtbS0+ZnJlZV9saXN0W29yZGVyXSwKLQkJCQkJCSBzdHJ1Y3QgaTkxNV9i dWRkeV9ibG9jaywKLQkJCQkJCSBsaW5rKTsKLQkJaWYgKGJsb2NrICE9IHJvb3QpIHsKLQkJCXBy X2Vycigicm9vdCBtaXNtYXRjaCBhdCBvcmRlcj0ldVxuIiwgb3JkZXIpOwotCQkJZXJyID0gLUVJ TlZBTDsKLQkJfQotCi0JCWlmIChlcnIpCi0JCQlicmVhazsKLQotCQlwcmV2ID0gcm9vdDsKLQkJ dG90YWwgKz0gaTkxNV9idWRkeV9ibG9ja19zaXplKG1tLCByb290KTsKLQl9Ci0KLQlpZiAoIWVy cikgewotCQlpZiAodG90YWwgIT0gbW0tPnNpemUpIHsKLQkJCXByX2VycigiZXhwZWN0ZWQgbW0g c2l6ZT0lbGx4LCBmb3VuZD0lbGx4XG4iLCBtbS0+c2l6ZSwKLQkJCSAgICAgICB0b3RhbCk7Ci0J CQllcnIgPSAtRUlOVkFMOwotCQl9Ci0JCXJldHVybiBlcnI7Ci0JfQotCi0JaWYgKHByZXYpIHsK LQkJcHJfZXJyKCJwcmV2IHJvb3QoJXUpLCBkdW1wOlxuIiwgaSAtIDEpOwotCQlpZ3RfZHVtcF9i bG9jayhtbSwgcHJldik7Ci0JfQotCi0JaWYgKHJvb3QpIHsKLQkJcHJfZXJyKCJiYWQgcm9vdCgl dSksIGR1bXA6XG4iLCBpKTsKLQkJaWd0X2R1bXBfYmxvY2sobW0sIHJvb3QpOwotCX0KLQotCXJl dHVybiBlcnI7Ci19Ci0KLXN0YXRpYyB2b2lkIGlndF9tbV9jb25maWcodTY0ICpzaXplLCB1NjQg KmNodW5rX3NpemUpCi17Ci0JSTkxNV9STkRfU1RBVEUocHJuZyk7Ci0JdTMyIHMsIG1zOwotCi0J LyogTm90aGluZyBmYW5jeSwganVzdCB0cnkgdG8gZ2V0IGFuIGludGVyZXN0aW5nIGJpdCBwYXR0 ZXJuICovCi0KLQlwcmFuZG9tX3NlZWRfc3RhdGUoJnBybmcsIGk5MTVfc2VsZnRlc3QucmFuZG9t X3NlZWQpOwotCi0JLyogTGV0IHNpemUgYmUgYSByYW5kb20gbnVtYmVyIG9mIHBhZ2VzIHVwIHRv IDggR0IgKDJNIHBhZ2VzKSAqLwotCXMgPSAxICsgaTkxNV9wcmFuZG9tX3UzMl9tYXhfc3RhdGUo KEJJVCgzMyAtIDEyKSkgLSAxLCAmcHJuZyk7Ci0JLyogTGV0IHRoZSBjaHVuayBzaXplIGJlIGEg cmFuZG9tIHBvd2VyIG9mIDIgbGVzcyB0aGFuIHNpemUgKi8KLQltcyA9IEJJVChpOTE1X3ByYW5k b21fdTMyX21heF9zdGF0ZShpbG9nMihzKSwgJnBybmcpKTsKLQkvKiBSb3VuZCBzaXplIGRvd24g dG8gdGhlIGNodW5rIHNpemUgKi8KLQlzICY9IC1tczsKLQotCS8qIENvbnZlcnQgZnJvbSBwYWdl cyB0byBieXRlcyAqLwotCSpjaHVua19zaXplID0gKHU2NCltcyA8PCAxMjsKLQkqc2l6ZSA9ICh1 NjQpcyA8PCAxMjsKLX0KLQotc3RhdGljIGludCBpZ3RfYnVkZHlfYWxsb2Nfc21va2Uodm9pZCAq YXJnKQotewotCXN0cnVjdCBpOTE1X2J1ZGR5X21tIG1tOwotCUlHVF9USU1FT1VUKGVuZF90aW1l KTsKLQlJOTE1X1JORF9TVEFURShwcm5nKTsKLQl1NjQgY2h1bmtfc2l6ZTsKLQl1NjQgbW1fc2l6 ZTsKLQlpbnQgKm9yZGVyOwotCWludCBlcnIsIGk7Ci0KLQlpZ3RfbW1fY29uZmlnKCZtbV9zaXpl LCAmY2h1bmtfc2l6ZSk7Ci0KLQlwcl9pbmZvKCJidWRkeV9pbml0IHdpdGggc2l6ZT0lbGx4LCBj aHVua19zaXplPSVsbHhcbiIsIG1tX3NpemUsIGNodW5rX3NpemUpOwotCi0JZXJyID0gaTkxNV9i dWRkeV9pbml0KCZtbSwgbW1fc2l6ZSwgY2h1bmtfc2l6ZSk7Ci0JaWYgKGVycikgewotCQlwcl9l cnIoImJ1ZGR5X2luaXQgZmFpbGVkKCVkKVxuIiwgZXJyKTsKLQkJcmV0dXJuIGVycjsKLQl9Ci0K LQlvcmRlciA9IGk5MTVfcmFuZG9tX29yZGVyKG1tLm1heF9vcmRlciArIDEsICZwcm5nKTsKLQlp ZiAoIW9yZGVyKQotCQlnb3RvIG91dF9maW5pOwotCi0JZm9yIChpID0gMDsgaSA8PSBtbS5tYXhf b3JkZXI7ICsraSkgewotCQlzdHJ1Y3QgaTkxNV9idWRkeV9ibG9jayAqYmxvY2s7Ci0JCWludCBt YXhfb3JkZXIgPSBvcmRlcltpXTsKLQkJYm9vbCB0aW1lb3V0ID0gZmFsc2U7Ci0JCUxJU1RfSEVB RChibG9ja3MpOwotCQlpbnQgb3JkZXI7Ci0JCXU2NCB0b3RhbDsKLQotCQllcnIgPSBpZ3RfY2hl Y2tfbW0oJm1tKTsKLQkJaWYgKGVycikgewotCQkJcHJfZXJyKCJwcmUtbW0gY2hlY2sgZmFpbGVk LCBhYm9ydFxuIik7Ci0JCQlicmVhazsKLQkJfQotCi0JCXByX2luZm8oImZpbGxpbmcgZnJvbSBt YXhfb3JkZXI9JXVcbiIsIG1heF9vcmRlcik7Ci0KLQkJb3JkZXIgPSBtYXhfb3JkZXI7Ci0JCXRv dGFsID0gMDsKLQotCQlkbyB7Ci1yZXRyeToKLQkJCWJsb2NrID0gaTkxNV9idWRkeV9hbGxvYygm bW0sIG9yZGVyKTsKLQkJCWlmIChJU19FUlIoYmxvY2spKSB7Ci0JCQkJZXJyID0gUFRSX0VSUihi bG9jayk7Ci0JCQkJaWYgKGVyciA9PSAtRU5PTUVNKSB7Ci0JCQkJCXByX2luZm8oImJ1ZGR5X2Fs bG9jIGhpdCAtRU5PTUVNIHdpdGggb3JkZXI9JWRcbiIsCi0JCQkJCQlvcmRlcik7Ci0JCQkJfSBl bHNlIHsKLQkJCQkJaWYgKG9yZGVyLS0pIHsKLQkJCQkJCWVyciA9IDA7Ci0JCQkJCQlnb3RvIHJl dHJ5OwotCQkJCQl9Ci0KLQkJCQkJcHJfZXJyKCJidWRkeV9hbGxvYyB3aXRoIG9yZGVyPSVkIGZh aWxlZCglZClcbiIsCi0JCQkJCSAgICAgICBvcmRlciwgZXJyKTsKLQkJCQl9Ci0KLQkJCQlicmVh azsKLQkJCX0KLQotCQkJbGlzdF9hZGRfdGFpbCgmYmxvY2stPmxpbmssICZibG9ja3MpOwotCi0J CQlpZiAoaTkxNV9idWRkeV9ibG9ja19vcmRlcihibG9jaykgIT0gb3JkZXIpIHsKLQkJCQlwcl9l cnIoImJ1ZGR5X2FsbG9jIG9yZGVyIG1pc21hdGNoXG4iKTsKLQkJCQllcnIgPSAtRUlOVkFMOwot CQkJCWJyZWFrOwotCQkJfQotCi0JCQl0b3RhbCArPSBpOTE1X2J1ZGR5X2Jsb2NrX3NpemUoJm1t LCBibG9jayk7Ci0KLQkJCWlmIChfX2lndF90aW1lb3V0KGVuZF90aW1lLCBOVUxMKSkgewotCQkJ CXRpbWVvdXQgPSB0cnVlOwotCQkJCWJyZWFrOwotCQkJfQotCQl9IHdoaWxlICh0b3RhbCA8IG1t LnNpemUpOwotCi0JCWlmICghZXJyKQotCQkJZXJyID0gaWd0X2NoZWNrX2Jsb2NrcygmbW0sICZi bG9ja3MsIHRvdGFsLCBmYWxzZSk7Ci0KLQkJaTkxNV9idWRkeV9mcmVlX2xpc3QoJm1tLCAmYmxv Y2tzKTsKLQotCQlpZiAoIWVycikgewotCQkJZXJyID0gaWd0X2NoZWNrX21tKCZtbSk7Ci0JCQlp ZiAoZXJyKQotCQkJCXByX2VycigicG9zdC1tbSBjaGVjayBmYWlsZWRcbiIpOwotCQl9Ci0KLQkJ aWYgKGVyciB8fCB0aW1lb3V0KQotCQkJYnJlYWs7Ci0KLQkJY29uZF9yZXNjaGVkKCk7Ci0JfQot Ci0JaWYgKGVyciA9PSAtRU5PTUVNKQotCQllcnIgPSAwOwotCi0Ja2ZyZWUob3JkZXIpOwotb3V0 X2Zpbmk6Ci0JaTkxNV9idWRkeV9maW5pKCZtbSk7Ci0KLQlyZXR1cm4gZXJyOwotfQotCi1zdGF0 aWMgaW50IGlndF9idWRkeV9hbGxvY19wZXNzaW1pc3RpYyh2b2lkICphcmcpCi17Ci0JY29uc3Qg dW5zaWduZWQgaW50IG1heF9vcmRlciA9IDE2OwotCXN0cnVjdCBpOTE1X2J1ZGR5X2Jsb2NrICpi bG9jaywgKmJuOwotCXN0cnVjdCBpOTE1X2J1ZGR5X21tIG1tOwotCXVuc2lnbmVkIGludCBvcmRl cjsKLQlMSVNUX0hFQUQoYmxvY2tzKTsKLQlpbnQgZXJyOwotCi0JLyoKLQkgKiBDcmVhdGUgYSBw b3Qtc2l6ZWQgbW0sIHRoZW4gYWxsb2NhdGUgb25lIG9mIGVhY2ggcG9zc2libGUKLQkgKiBvcmRl ciB3aXRoaW4uIFRoaXMgc2hvdWxkIGxlYXZlIHRoZSBtbSB3aXRoIGV4YWN0bHkgb25lCi0JICog cGFnZSBsZWZ0LgotCSAqLwotCi0JZXJyID0gaTkxNV9idWRkeV9pbml0KCZtbSwgUEFHRV9TSVpF IDw8IG1heF9vcmRlciwgUEFHRV9TSVpFKTsKLQlpZiAoZXJyKSB7Ci0JCXByX2VycigiYnVkZHlf aW5pdCBmYWlsZWQoJWQpXG4iLCBlcnIpOwotCQlyZXR1cm4gZXJyOwotCX0KLQlHRU1fQlVHX09O KG1tLm1heF9vcmRlciAhPSBtYXhfb3JkZXIpOwotCi0JZm9yIChvcmRlciA9IDA7IG9yZGVyIDwg bWF4X29yZGVyOyBvcmRlcisrKSB7Ci0JCWJsb2NrID0gaTkxNV9idWRkeV9hbGxvYygmbW0sIG9y ZGVyKTsKLQkJaWYgKElTX0VSUihibG9jaykpIHsKLQkJCXByX2luZm8oImJ1ZGR5X2FsbG9jIGhp dCAtRU5PTUVNIHdpdGggb3JkZXI9JWRcbiIsCi0JCQkJb3JkZXIpOwotCQkJZXJyID0gUFRSX0VS UihibG9jayk7Ci0JCQlnb3RvIGVycjsKLQkJfQotCi0JCWxpc3RfYWRkX3RhaWwoJmJsb2NrLT5s aW5rLCAmYmxvY2tzKTsKLQl9Ci0KLQkvKiBBbmQgbm93IHRoZSBsYXN0IHJlbWFpbmluZyBibG9j ayBhdmFpbGFibGUgKi8KLQlibG9jayA9IGk5MTVfYnVkZHlfYWxsb2MoJm1tLCAwKTsKLQlpZiAo SVNfRVJSKGJsb2NrKSkgewotCQlwcl9pbmZvKCJidWRkeV9hbGxvYyBoaXQgLUVOT01FTSBvbiBm aW5hbCBhbGxvY1xuIik7Ci0JCWVyciA9IFBUUl9FUlIoYmxvY2spOwotCQlnb3RvIGVycjsKLQl9 Ci0JbGlzdF9hZGRfdGFpbCgmYmxvY2stPmxpbmssICZibG9ja3MpOwotCi0JLyogU2hvdWxkIGJl IGNvbXBsZXRlbHkgZnVsbCEgKi8KLQlmb3IgKG9yZGVyID0gbWF4X29yZGVyOyBvcmRlci0tOyAp IHsKLQkJYmxvY2sgPSBpOTE1X2J1ZGR5X2FsbG9jKCZtbSwgb3JkZXIpOwotCQlpZiAoIUlTX0VS UihibG9jaykpIHsKLQkJCXByX2luZm8oImJ1ZGR5X2FsbG9jIHVuZXhwZWN0ZWRseSBzdWNjZWVk ZWQgYXQgb3JkZXIgJWQsIGl0IHNob3VsZCBiZSBmdWxsISIsCi0JCQkJb3JkZXIpOwotCQkJbGlz dF9hZGRfdGFpbCgmYmxvY2stPmxpbmssICZibG9ja3MpOwotCQkJZXJyID0gLUVJTlZBTDsKLQkJ CWdvdG8gZXJyOwotCQl9Ci0JfQotCi0JYmxvY2sgPSBsaXN0X2xhc3RfZW50cnkoJmJsb2Nrcywg dHlwZW9mKCpibG9jayksIGxpbmspOwotCWxpc3RfZGVsKCZibG9jay0+bGluayk7Ci0JaTkxNV9i dWRkeV9mcmVlKCZtbSwgYmxvY2spOwotCi0JLyogQXMgd2UgZnJlZSBpbiBpbmNyZWFzaW5nIHNp emUsIHdlIG1ha2UgYXZhaWxhYmxlIGxhcmdlciBibG9ja3MgKi8KLQlvcmRlciA9IDE7Ci0JbGlz dF9mb3JfZWFjaF9lbnRyeV9zYWZlKGJsb2NrLCBibiwgJmJsb2NrcywgbGluaykgewotCQlsaXN0 X2RlbCgmYmxvY2stPmxpbmspOwotCQlpOTE1X2J1ZGR5X2ZyZWUoJm1tLCBibG9jayk7Ci0KLQkJ YmxvY2sgPSBpOTE1X2J1ZGR5X2FsbG9jKCZtbSwgb3JkZXIpOwotCQlpZiAoSVNfRVJSKGJsb2Nr KSkgewotCQkJcHJfaW5mbygiYnVkZHlfYWxsb2MgKHJlYWxsb2MpIGhpdCAtRU5PTUVNIHdpdGgg b3JkZXI9JWRcbiIsCi0JCQkJb3JkZXIpOwotCQkJZXJyID0gUFRSX0VSUihibG9jayk7Ci0JCQln b3RvIGVycjsKLQkJfQotCQlpOTE1X2J1ZGR5X2ZyZWUoJm1tLCBibG9jayk7Ci0JCW9yZGVyKys7 Ci0JfQotCi0JLyogVG8gY29uZmlybSwgbm93IHRoZSB3aG9sZSBtbSBzaG91bGQgYmUgYXZhaWxh YmxlICovCi0JYmxvY2sgPSBpOTE1X2J1ZGR5X2FsbG9jKCZtbSwgbWF4X29yZGVyKTsKLQlpZiAo SVNfRVJSKGJsb2NrKSkgewotCQlwcl9pbmZvKCJidWRkeV9hbGxvYyAocmVhbGxvYykgaGl0IC1F Tk9NRU0gd2l0aCBvcmRlcj0lZFxuIiwKLQkJCW1heF9vcmRlcik7Ci0JCWVyciA9IFBUUl9FUlIo YmxvY2spOwotCQlnb3RvIGVycjsKLQl9Ci0JaTkxNV9idWRkeV9mcmVlKCZtbSwgYmxvY2spOwot Ci1lcnI6Ci0JaTkxNV9idWRkeV9mcmVlX2xpc3QoJm1tLCAmYmxvY2tzKTsKLQlpOTE1X2J1ZGR5 X2ZpbmkoJm1tKTsKLQlyZXR1cm4gZXJyOwotfQotCi1zdGF0aWMgaW50IGlndF9idWRkeV9hbGxv Y19vcHRpbWlzdGljKHZvaWQgKmFyZykKLXsKLQljb25zdCBpbnQgbWF4X29yZGVyID0gMTY7Ci0J c3RydWN0IGk5MTVfYnVkZHlfYmxvY2sgKmJsb2NrOwotCXN0cnVjdCBpOTE1X2J1ZGR5X21tIG1t OwotCUxJU1RfSEVBRChibG9ja3MpOwotCWludCBvcmRlcjsKLQlpbnQgZXJyOwotCi0JLyoKLQkg KiBDcmVhdGUgYSBtbSB3aXRoIG9uZSBibG9jayBvZiBlYWNoIG9yZGVyIGF2YWlsYWJsZSwgYW5k Ci0JICogdHJ5IHRvIGFsbG9jYXRlIHRoZW0gYWxsLgotCSAqLwotCi0JZXJyID0gaTkxNV9idWRk eV9pbml0KCZtbSwKLQkJCSAgICAgIFBBR0VfU0laRSAqICgoMSA8PCAobWF4X29yZGVyICsgMSkp IC0gMSksCi0JCQkgICAgICBQQUdFX1NJWkUpOwotCWlmIChlcnIpIHsKLQkJcHJfZXJyKCJidWRk eV9pbml0IGZhaWxlZCglZClcbiIsIGVycik7Ci0JCXJldHVybiBlcnI7Ci0JfQotCUdFTV9CVUdf T04obW0ubWF4X29yZGVyICE9IG1heF9vcmRlcik7Ci0KLQlmb3IgKG9yZGVyID0gMDsgb3JkZXIg PD0gbWF4X29yZGVyOyBvcmRlcisrKSB7Ci0JCWJsb2NrID0gaTkxNV9idWRkeV9hbGxvYygmbW0s IG9yZGVyKTsKLQkJaWYgKElTX0VSUihibG9jaykpIHsKLQkJCXByX2luZm8oImJ1ZGR5X2FsbG9j IGhpdCAtRU5PTUVNIHdpdGggb3JkZXI9JWRcbiIsCi0JCQkJb3JkZXIpOwotCQkJZXJyID0gUFRS X0VSUihibG9jayk7Ci0JCQlnb3RvIGVycjsKLQkJfQotCi0JCWxpc3RfYWRkX3RhaWwoJmJsb2Nr LT5saW5rLCAmYmxvY2tzKTsKLQl9Ci0KLQkvKiBTaG91bGQgYmUgY29tcGxldGVseSBmdWxsISAq LwotCWJsb2NrID0gaTkxNV9idWRkeV9hbGxvYygmbW0sIDApOwotCWlmICghSVNfRVJSKGJsb2Nr KSkgewotCQlwcl9pbmZvKCJidWRkeV9hbGxvYyB1bmV4cGVjdGVkbHkgc3VjY2VlZGVkLCBpdCBz aG91bGQgYmUgZnVsbCEiKTsKLQkJbGlzdF9hZGRfdGFpbCgmYmxvY2stPmxpbmssICZibG9ja3Mp OwotCQllcnIgPSAtRUlOVkFMOwotCQlnb3RvIGVycjsKLQl9Ci0KLWVycjoKLQlpOTE1X2J1ZGR5 X2ZyZWVfbGlzdCgmbW0sICZibG9ja3MpOwotCWk5MTVfYnVkZHlfZmluaSgmbW0pOwotCXJldHVy biBlcnI7Ci19Ci0KLXN0YXRpYyBpbnQgaWd0X2J1ZGR5X2FsbG9jX3BhdGhvbG9naWNhbCh2b2lk ICphcmcpCi17Ci0JY29uc3QgaW50IG1heF9vcmRlciA9IDE2OwotCXN0cnVjdCBpOTE1X2J1ZGR5 X2Jsb2NrICpibG9jazsKLQlzdHJ1Y3QgaTkxNV9idWRkeV9tbSBtbTsKLQlMSVNUX0hFQUQoYmxv Y2tzKTsKLQlMSVNUX0hFQUQoaG9sZXMpOwotCWludCBvcmRlciwgdG9wOwotCWludCBlcnI7Ci0K LQkvKgotCSAqIENyZWF0ZSBhIHBvdC1zaXplZCBtbSwgdGhlbiBhbGxvY2F0ZSBvbmUgb2YgZWFj aCBwb3NzaWJsZQotCSAqIG9yZGVyIHdpdGhpbi4gVGhpcyBzaG91bGQgbGVhdmUgdGhlIG1tIHdp dGggZXhhY3RseSBvbmUKLQkgKiBwYWdlIGxlZnQuIEZyZWUgdGhlIGxhcmdlc3QgYmxvY2ssIHRo ZW4gd2hpdHRsZSBkb3duIGFnYWluLgotCSAqIEV2ZW50dWFsbHkgd2Ugd2lsbCBoYXZlIGEgZnVs bHkgNTAlIGZyYWdtZW50ZWQgbW0uCi0JICovCi0KLQllcnIgPSBpOTE1X2J1ZGR5X2luaXQoJm1t LCBQQUdFX1NJWkUgPDwgbWF4X29yZGVyLCBQQUdFX1NJWkUpOwotCWlmIChlcnIpIHsKLQkJcHJf ZXJyKCJidWRkeV9pbml0IGZhaWxlZCglZClcbiIsIGVycik7Ci0JCXJldHVybiBlcnI7Ci0JfQot CUdFTV9CVUdfT04obW0ubWF4X29yZGVyICE9IG1heF9vcmRlcik7Ci0KLQlmb3IgKHRvcCA9IG1h eF9vcmRlcjsgdG9wOyB0b3AtLSkgewotCQkvKiBNYWtlIHJvb20gYnkgZnJlZWluZyB0aGUgbGFy Z2VzdCBhbGxvY2F0ZWQgYmxvY2sgKi8KLQkJYmxvY2sgPSBsaXN0X2ZpcnN0X2VudHJ5X29yX251 bGwoJmJsb2NrcywgdHlwZW9mKCpibG9jayksIGxpbmspOwotCQlpZiAoYmxvY2spIHsKLQkJCWxp c3RfZGVsKCZibG9jay0+bGluayk7Ci0JCQlpOTE1X2J1ZGR5X2ZyZWUoJm1tLCBibG9jayk7Ci0J CX0KLQotCQlmb3IgKG9yZGVyID0gdG9wOyBvcmRlci0tOyApIHsKLQkJCWJsb2NrID0gaTkxNV9i dWRkeV9hbGxvYygmbW0sIG9yZGVyKTsKLQkJCWlmIChJU19FUlIoYmxvY2spKSB7Ci0JCQkJcHJf aW5mbygiYnVkZHlfYWxsb2MgaGl0IC1FTk9NRU0gd2l0aCBvcmRlcj0lZCwgdG9wPSVkXG4iLAot CQkJCQlvcmRlciwgdG9wKTsKLQkJCQllcnIgPSBQVFJfRVJSKGJsb2NrKTsKLQkJCQlnb3RvIGVy cjsKLQkJCX0KLQkJCWxpc3RfYWRkX3RhaWwoJmJsb2NrLT5saW5rLCAmYmxvY2tzKTsKLQkJfQot Ci0JCS8qIFRoZXJlIHNob3VsZCBiZSBvbmUgZmluYWwgcGFnZSBmb3IgdGhpcyBzdWItYWxsb2Nh dGlvbiAqLwotCQlibG9jayA9IGk5MTVfYnVkZHlfYWxsb2MoJm1tLCAwKTsKLQkJaWYgKElTX0VS UihibG9jaykpIHsKLQkJCXByX2luZm8oImJ1ZGR5X2FsbG9jIGhpdCAtRU5PTUVNIGZvciBob2xl XG4iKTsKLQkJCWVyciA9IFBUUl9FUlIoYmxvY2spOwotCQkJZ290byBlcnI7Ci0JCX0KLQkJbGlz dF9hZGRfdGFpbCgmYmxvY2stPmxpbmssICZob2xlcyk7Ci0KLQkJYmxvY2sgPSBpOTE1X2J1ZGR5 X2FsbG9jKCZtbSwgdG9wKTsKLQkJaWYgKCFJU19FUlIoYmxvY2spKSB7Ci0JCQlwcl9pbmZvKCJi dWRkeV9hbGxvYyB1bmV4cGVjdGVkbHkgc3VjY2VlZGVkIGF0IHRvcC1vcmRlciAlZC8lZCwgaXQg c2hvdWxkIGJlIGZ1bGwhIiwKLQkJCQl0b3AsIG1heF9vcmRlcik7Ci0JCQlsaXN0X2FkZF90YWls KCZibG9jay0+bGluaywgJmJsb2Nrcyk7Ci0JCQllcnIgPSAtRUlOVkFMOwotCQkJZ290byBlcnI7 Ci0JCX0KLQl9Ci0KLQlpOTE1X2J1ZGR5X2ZyZWVfbGlzdCgmbW0sICZob2xlcyk7Ci0KLQkvKiBO b3RoaW5nIGxhcmdlciB0aGFuIGJsb2NrcyBvZiBjaHVua19zaXplIG5vdyBhdmFpbGFibGUgKi8K LQlmb3IgKG9yZGVyID0gMTsgb3JkZXIgPD0gbWF4X29yZGVyOyBvcmRlcisrKSB7Ci0JCWJsb2Nr ID0gaTkxNV9idWRkeV9hbGxvYygmbW0sIG9yZGVyKTsKLQkJaWYgKCFJU19FUlIoYmxvY2spKSB7 Ci0JCQlwcl9pbmZvKCJidWRkeV9hbGxvYyB1bmV4cGVjdGVkbHkgc3VjY2VlZGVkIGF0IG9yZGVy ICVkLCBpdCBzaG91bGQgYmUgZnVsbCEiLAotCQkJCW9yZGVyKTsKLQkJCWxpc3RfYWRkX3RhaWwo JmJsb2NrLT5saW5rLCAmYmxvY2tzKTsKLQkJCWVyciA9IC1FSU5WQUw7Ci0JCQlnb3RvIGVycjsK LQkJfQotCX0KLQotZXJyOgotCWxpc3Rfc3BsaWNlX3RhaWwoJmhvbGVzLCAmYmxvY2tzKTsKLQlp OTE1X2J1ZGR5X2ZyZWVfbGlzdCgmbW0sICZibG9ja3MpOwotCWk5MTVfYnVkZHlfZmluaSgmbW0p OwotCXJldHVybiBlcnI7Ci19Ci0KLXN0YXRpYyBpbnQgaWd0X2J1ZGR5X2FsbG9jX3JhbmdlKHZv aWQgKmFyZykKLXsKLQlzdHJ1Y3QgaTkxNV9idWRkeV9tbSBtbTsKLQl1bnNpZ25lZCBsb25nIHBh Z2VfbnVtOwotCUxJU1RfSEVBRChibG9ja3MpOwotCXU2NCBjaHVua19zaXplOwotCXU2NCBvZmZz ZXQ7Ci0JdTY0IHNpemU7Ci0JdTY0IHJlbTsKLQlpbnQgZXJyOwotCi0JaWd0X21tX2NvbmZpZygm c2l6ZSwgJmNodW5rX3NpemUpOwotCi0JcHJfaW5mbygiYnVkZHlfaW5pdCB3aXRoIHNpemU9JWxs eCwgY2h1bmtfc2l6ZT0lbGx4XG4iLCBzaXplLCBjaHVua19zaXplKTsKLQotCWVyciA9IGk5MTVf YnVkZHlfaW5pdCgmbW0sIHNpemUsIGNodW5rX3NpemUpOwotCWlmIChlcnIpIHsKLQkJcHJfZXJy KCJidWRkeV9pbml0IGZhaWxlZCglZClcbiIsIGVycik7Ci0JCXJldHVybiBlcnI7Ci0JfQotCi0J ZXJyID0gaWd0X2NoZWNrX21tKCZtbSk7Ci0JaWYgKGVycikgewotCQlwcl9lcnIoInByZS1tbSBj aGVjayBmYWlsZWQsIGFib3J0LCBhYm9ydCwgYWJvcnQhXG4iKTsKLQkJZ290byBlcnJfZmluaTsK LQl9Ci0KLQlyZW0gPSBtbS5zaXplOwotCW9mZnNldCA9IDA7Ci0KLQlmb3JfZWFjaF9wcmltZV9u dW1iZXJfZnJvbShwYWdlX251bSwgMSwgVUxPTkdfTUFYIC0gMSkgewotCQlzdHJ1Y3QgaTkxNV9i dWRkeV9ibG9jayAqYmxvY2s7Ci0JCUxJU1RfSEVBRCh0bXApOwotCi0JCXNpemUgPSBtaW4ocGFn ZV9udW0gKiBtbS5jaHVua19zaXplLCByZW0pOwotCi0JCWVyciA9IGk5MTVfYnVkZHlfYWxsb2Nf cmFuZ2UoJm1tLCAmdG1wLCBvZmZzZXQsIHNpemUpOwotCQlpZiAoZXJyKSB7Ci0JCQlpZiAoZXJy ID09IC1FTk9NRU0pIHsKLQkJCQlwcl9pbmZvKCJhbGxvY19yYW5nZSBoaXQgLUVOT01FTSB3aXRo IHNpemU9JWxseFxuIiwKLQkJCQkJc2l6ZSk7Ci0JCQl9IGVsc2UgewotCQkJCXByX2VycigiYWxs b2NfcmFuZ2Ugd2l0aCBvZmZzZXQ9JWxseCwgc2l6ZT0lbGx4IGZhaWxlZCglZClcbiIsCi0JCQkJ ICAgICAgIG9mZnNldCwgc2l6ZSwgZXJyKTsKLQkJCX0KLQotCQkJYnJlYWs7Ci0JCX0KLQotCQli bG9jayA9IGxpc3RfZmlyc3RfZW50cnlfb3JfbnVsbCgmdG1wLAotCQkJCQkJIHN0cnVjdCBpOTE1 X2J1ZGR5X2Jsb2NrLAotCQkJCQkJIGxpbmspOwotCQlpZiAoIWJsb2NrKSB7Ci0JCQlwcl9lcnIo ImFsbG9jX3JhbmdlIGhhcyBubyBibG9ja3NcbiIpOwotCQkJZXJyID0gLUVJTlZBTDsKLQkJCWJy ZWFrOwotCQl9Ci0KLQkJaWYgKGk5MTVfYnVkZHlfYmxvY2tfb2Zmc2V0KGJsb2NrKSAhPSBvZmZz ZXQpIHsKLQkJCXByX2VycigiYWxsb2NfcmFuZ2Ugc3RhcnQgb2Zmc2V0IG1pc21hdGNoLCBmb3Vu ZD0lbGx4LCBleHBlY3RlZD0lbGx4XG4iLAotCQkJICAgICAgIGk5MTVfYnVkZHlfYmxvY2tfb2Zm c2V0KGJsb2NrKSwgb2Zmc2V0KTsKLQkJCWVyciA9IC1FSU5WQUw7Ci0JCX0KLQotCQlpZiAoIWVy cikKLQkJCWVyciA9IGlndF9jaGVja19ibG9ja3MoJm1tLCAmdG1wLCBzaXplLCB0cnVlKTsKLQot CQlsaXN0X3NwbGljZV90YWlsKCZ0bXAsICZibG9ja3MpOwotCi0JCWlmIChlcnIpCi0JCQlicmVh azsKLQotCQlvZmZzZXQgKz0gc2l6ZTsKLQotCQlyZW0gLT0gc2l6ZTsKLQkJaWYgKCFyZW0pCi0J CQlicmVhazsKLQotCQljb25kX3Jlc2NoZWQoKTsKLQl9Ci0KLQlpZiAoZXJyID09IC1FTk9NRU0p Ci0JCWVyciA9IDA7Ci0KLQlpOTE1X2J1ZGR5X2ZyZWVfbGlzdCgmbW0sICZibG9ja3MpOwotCi0J aWYgKCFlcnIpIHsKLQkJZXJyID0gaWd0X2NoZWNrX21tKCZtbSk7Ci0JCWlmIChlcnIpCi0JCQlw cl9lcnIoInBvc3QtbW0gY2hlY2sgZmFpbGVkXG4iKTsKLQl9Ci0KLWVycl9maW5pOgotCWk5MTVf YnVkZHlfZmluaSgmbW0pOwotCi0JcmV0dXJuIGVycjsKLX0KLQotc3RhdGljIGludCBpZ3RfYnVk ZHlfYWxsb2NfbGltaXQodm9pZCAqYXJnKQotewotCXN0cnVjdCBpOTE1X2J1ZGR5X2Jsb2NrICpi bG9jazsKLQlzdHJ1Y3QgaTkxNV9idWRkeV9tbSBtbTsKLQljb25zdCB1NjQgc2l6ZSA9IFU2NF9N QVg7Ci0JaW50IGVycjsKLQotCWVyciA9IGk5MTVfYnVkZHlfaW5pdCgmbW0sIHNpemUsIFBBR0Vf U0laRSk7Ci0JaWYgKGVycikKLQkJcmV0dXJuIGVycjsKLQotCWlmIChtbS5tYXhfb3JkZXIgIT0g STkxNV9CVUREWV9NQVhfT1JERVIpIHsKLQkJcHJfZXJyKCJtbS5tYXhfb3JkZXIoJWQpICE9ICVk XG4iLAotCQkgICAgICAgbW0ubWF4X29yZGVyLCBJOTE1X0JVRERZX01BWF9PUkRFUik7Ci0JCWVy ciA9IC1FSU5WQUw7Ci0JCWdvdG8gb3V0X2Zpbmk7Ci0JfQotCi0JYmxvY2sgPSBpOTE1X2J1ZGR5 X2FsbG9jKCZtbSwgbW0ubWF4X29yZGVyKTsKLQlpZiAoSVNfRVJSKGJsb2NrKSkgewotCQllcnIg PSBQVFJfRVJSKGJsb2NrKTsKLQkJZ290byBvdXRfZmluaTsKLQl9Ci0KLQlpZiAoaTkxNV9idWRk eV9ibG9ja19vcmRlcihibG9jaykgIT0gbW0ubWF4X29yZGVyKSB7Ci0JCXByX2VycigiYmxvY2sg b3JkZXIoJWQpICE9ICVkXG4iLAotCQkgICAgICAgaTkxNV9idWRkeV9ibG9ja19vcmRlcihibG9j ayksIG1tLm1heF9vcmRlcik7Ci0JCWVyciA9IC1FSU5WQUw7Ci0JCWdvdG8gb3V0X2ZyZWU7Ci0J fQotCi0JaWYgKGk5MTVfYnVkZHlfYmxvY2tfc2l6ZSgmbW0sIGJsb2NrKSAhPQotCSAgICBCSVRf VUxMKG1tLm1heF9vcmRlcikgKiBQQUdFX1NJWkUpIHsKLQkJcHJfZXJyKCJibG9jayBzaXplKCVs bHUpICE9ICVsbHVcbiIsCi0JCSAgICAgICBpOTE1X2J1ZGR5X2Jsb2NrX3NpemUoJm1tLCBibG9j ayksCi0JCSAgICAgICBCSVRfVUxMKG1tLm1heF9vcmRlcikgKiBQQUdFX1NJWkUpOwotCQllcnIg PSAtRUlOVkFMOwotCQlnb3RvIG91dF9mcmVlOwotCX0KLQotb3V0X2ZyZWU6Ci0JaTkxNV9idWRk eV9mcmVlKCZtbSwgYmxvY2spOwotb3V0X2Zpbmk6Ci0JaTkxNV9idWRkeV9maW5pKCZtbSk7Ci0J cmV0dXJuIGVycjsKLX0KLQotaW50IGk5MTVfYnVkZHlfbW9ja19zZWxmdGVzdHModm9pZCkKLXsK LQlzdGF0aWMgY29uc3Qgc3RydWN0IGk5MTVfc3VidGVzdCB0ZXN0c1tdID0gewotCQlTVUJURVNU KGlndF9idWRkeV9hbGxvY19wZXNzaW1pc3RpYyksCi0JCVNVQlRFU1QoaWd0X2J1ZGR5X2FsbG9j X29wdGltaXN0aWMpLAotCQlTVUJURVNUKGlndF9idWRkeV9hbGxvY19wYXRob2xvZ2ljYWwpLAot CQlTVUJURVNUKGlndF9idWRkeV9hbGxvY19zbW9rZSksCi0JCVNVQlRFU1QoaWd0X2J1ZGR5X2Fs bG9jX3JhbmdlKSwKLQkJU1VCVEVTVChpZ3RfYnVkZHlfYWxsb2NfbGltaXQpLAotCX07Ci0KLQly ZXR1cm4gaTkxNV9zdWJ0ZXN0cyh0ZXN0cywgTlVMTCk7Ci19CmRpZmYgLS1naXQgYS9kcml2ZXJz L2dwdS9kcm0vaTkxNS9zZWxmdGVzdHMvaTkxNV9tb2NrX3NlbGZ0ZXN0cy5oIGIvZHJpdmVycy9n cHUvZHJtL2k5MTUvc2VsZnRlc3RzL2k5MTVfbW9ja19zZWxmdGVzdHMuaAppbmRleCAzZGIzNGQz ZWVhNTguLjM0ZTVjYWYzODA5MyAxMDA2NDQKLS0tIGEvZHJpdmVycy9ncHUvZHJtL2k5MTUvc2Vs ZnRlc3RzL2k5MTVfbW9ja19zZWxmdGVzdHMuaAorKysgYi9kcml2ZXJzL2dwdS9kcm0vaTkxNS9z ZWxmdGVzdHMvaTkxNV9tb2NrX3NlbGZ0ZXN0cy5oCkBAIC0zMyw1ICszMyw0IEBAIHNlbGZ0ZXN0 KGV2aWN0LCBpOTE1X2dlbV9ldmljdF9tb2NrX3NlbGZ0ZXN0cykKIHNlbGZ0ZXN0KGd0dCwgaTkx NV9nZW1fZ3R0X21vY2tfc2VsZnRlc3RzKQogc2VsZnRlc3QoaHVnZXBhZ2VzLCBpOTE1X2dlbV9o dWdlX3BhZ2VfbW9ja19zZWxmdGVzdHMpCiBzZWxmdGVzdChjb250ZXh0cywgaTkxNV9nZW1fY29u dGV4dF9tb2NrX3NlbGZ0ZXN0cykKLXNlbGZ0ZXN0KGJ1ZGR5LCBpOTE1X2J1ZGR5X21vY2tfc2Vs ZnRlc3RzKQogc2VsZnRlc3QobWVtb3J5X3JlZ2lvbiwgaW50ZWxfbWVtb3J5X3JlZ2lvbl9tb2Nr X3NlbGZ0ZXN0cykKZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2RybS9pOTE1L3NlbGZ0ZXN0cy9p bnRlbF9tZW1vcnlfcmVnaW9uLmMgYi9kcml2ZXJzL2dwdS9kcm0vaTkxNS9zZWxmdGVzdHMvaW50 ZWxfbWVtb3J5X3JlZ2lvbi5jCmluZGV4IGY4NWZkOGNiZmJmNS4uYzg1ZDUxNmI4NWNkIDEwMDY0 NAotLS0gYS9kcml2ZXJzL2dwdS9kcm0vaTkxNS9zZWxmdGVzdHMvaW50ZWxfbWVtb3J5X3JlZ2lv bi5jCisrKyBiL2RyaXZlcnMvZ3B1L2RybS9pOTE1L3NlbGZ0ZXN0cy9pbnRlbF9tZW1vcnlfcmVn aW9uLmMKQEAgLTU3LDkgKzU3LDEwIEBAIHN0YXRpYyBpbnQgaWd0X21vY2tfZmlsbCh2b2lkICph cmcpCiAJTElTVF9IRUFEKG9iamVjdHMpOwogCWludCBlcnIgPSAwOwogCi0JcGFnZV9zaXplID0g bWVtLT5tbS5jaHVua19zaXplOwotCW1heF9wYWdlcyA9IGRpdjY0X3U2NCh0b3RhbCwgcGFnZV9z aXplKTsKKwlwYWdlX3NpemUgPSBtZW0tPmNodW5rX3NpemU7CiAJcmVtID0gdG90YWw7CityZXRy eToKKwltYXhfcGFnZXMgPSBkaXY2NF91NjQocmVtLCBwYWdlX3NpemUpOwogCiAJZm9yX2VhY2hf cHJpbWVfbnVtYmVyX2Zyb20ocGFnZV9udW0sIDEsIG1heF9wYWdlcykgewogCQlyZXNvdXJjZV9z aXplX3Qgc2l6ZSA9IHBhZ2VfbnVtICogcGFnZV9zaXplOwpAQCAtODUsNiArODYsMTEgQEAgc3Rh dGljIGludCBpZ3RfbW9ja19maWxsKHZvaWQgKmFyZykKIAkJZXJyID0gMDsKIAlpZiAoZXJyID09 IC1FTlhJTykgewogCQlpZiAocGFnZV9udW0gKiBwYWdlX3NpemUgPD0gcmVtKSB7CisJCQlpZiAo bWVtLT5pc19yYW5nZV9tYW5hZ2VyICYmIG1heF9wYWdlcyA+IDEpIHsKKwkJCQltYXhfcGFnZXMg Pj49IDE7CisJCQkJZ290byByZXRyeTsKKwkJCX0KKwogCQkJcHJfZXJyKCIlcyBmYWlsZWQsIHNw YWNlIHN0aWxsIGxlZnQgaW4gcmVnaW9uXG4iLAogCQkJICAgICAgIF9fZnVuY19fKTsKIAkJCWVy ciA9IC1FSU5WQUw7CkBAIC0xOTksMTIgKzIwNSwxOCBAQCBzdGF0aWMgaW50IGlndF9tb2NrX3Jl c2VydmUodm9pZCAqYXJnKQogCWRvIHsKIAkJdTMyIHNpemUgPSBpOTE1X3ByYW5kb21fdTMyX21h eF9zdGF0ZShjdXJfYXZhaWwsICZwcm5nKTsKIAorcmV0cnk6CiAJCXNpemUgPSBtYXhfdCh1MzIs IHJvdW5kX3VwKHNpemUsIFBBR0VfU0laRSksIFBBR0VfU0laRSk7CiAJCW9iaiA9IGlndF9vYmpl Y3RfY3JlYXRlKG1lbSwgJm9iamVjdHMsIHNpemUsIDApOwogCQlpZiAoSVNfRVJSKG9iaikpIHsK LQkJCWlmIChQVFJfRVJSKG9iaikgPT0gLUVOWElPKQorCQkJaWYgKFBUUl9FUlIob2JqKSA9PSAt RU5YSU8pIHsKKwkJCQlpZiAobWVtLT5pc19yYW5nZV9tYW5hZ2VyICYmCisJCQkJICAgIHNpemUg PiBtZW0tPmNodW5rX3NpemUpIHsKKwkJCQkJc2l6ZSA+Pj0gMTsKKwkJCQkJZ290byByZXRyeTsK KwkJCQl9CiAJCQkJYnJlYWs7Ci0KKwkJCX0KIAkJCWVyciA9IFBUUl9FUlIob2JqKTsKIAkJCWdv dG8gb3V0X2Nsb3NlOwogCQl9CkBAIC0yMjAsNyArMjMyLDcgQEAgc3RhdGljIGludCBpZ3RfbW9j a19yZXNlcnZlKHZvaWQgKmFyZykKIG91dF9jbG9zZToKIAlrZnJlZShvcmRlcik7CiAJY2xvc2Vf b2JqZWN0cyhtZW0sICZvYmplY3RzKTsKLQlpOTE1X2J1ZGR5X2ZyZWVfbGlzdCgmbWVtLT5tbSwg Jm1lbS0+cmVzZXJ2ZWQpOworCWludGVsX21lbW9yeV9yZWdpb25fdW5yZXNlcnZlKG1lbSk7CiAJ cmV0dXJuIGVycjsKIH0KIApAQCAtMjQwLDcgKzI1Miw3IEBAIHN0YXRpYyBpbnQgaWd0X21vY2tf Y29udGlndW91cyh2b2lkICphcmcpCiAJdG90YWwgPSByZXNvdXJjZV9zaXplKCZtZW0tPnJlZ2lv bik7CiAKIAkvKiBNaW4gc2l6ZSAqLwotCW9iaiA9IGlndF9vYmplY3RfY3JlYXRlKG1lbSwgJm9i amVjdHMsIG1lbS0+bW0uY2h1bmtfc2l6ZSwKKwlvYmogPSBpZ3Rfb2JqZWN0X2NyZWF0ZShtZW0s ICZvYmplY3RzLCBtZW0tPmNodW5rX3NpemUsCiAJCQkJSTkxNV9CT19BTExPQ19DT05USUdVT1VT KTsKIAlpZiAoSVNfRVJSKG9iaikpCiAJCXJldHVybiBQVFJfRVJSKG9iaik7CkBAIC0zMjEsMTQg KzMzMywxNiBAQCBzdGF0aWMgaW50IGlndF9tb2NrX2NvbnRpZ3VvdXModm9pZCAqYXJnKQogCW1p biA9IHRhcmdldDsKIAl0YXJnZXQgPSB0b3RhbCA+PiAxOwogCi0JLyogTWFrZSBzdXJlIHdlIGNh biBzdGlsbCBhbGxvY2F0ZSBhbGwgdGhlIGZyYWdtZW50ZWQgc3BhY2UgKi8KLQlvYmogPSBpZ3Rf b2JqZWN0X2NyZWF0ZShtZW0sICZvYmplY3RzLCB0YXJnZXQsIDApOwotCWlmIChJU19FUlIob2Jq KSkgewotCQllcnIgPSBQVFJfRVJSKG9iaik7Ci0JCWdvdG8gZXJyX2Nsb3NlX29iamVjdHM7Ci0J fQorCWlmICghbWVtLT5pc19yYW5nZV9tYW5hZ2VyKSB7CisJCS8qIE1ha2Ugc3VyZSB3ZSBjYW4g c3RpbGwgYWxsb2NhdGUgYWxsIHRoZSBmcmFnbWVudGVkIHNwYWNlICovCisJCW9iaiA9IGlndF9v YmplY3RfY3JlYXRlKG1lbSwgJm9iamVjdHMsIHRhcmdldCwgMCk7CisJCWlmIChJU19FUlIob2Jq KSkgeworCQkJZXJyID0gUFRSX0VSUihvYmopOworCQkJZ290byBlcnJfY2xvc2Vfb2JqZWN0czsK KwkJfQogCi0JaWd0X29iamVjdF9yZWxlYXNlKG9iaik7CisJCWlndF9vYmplY3RfcmVsZWFzZShv YmopOworCX0KIAogCS8qCiAJICogRXZlbiB0aG91Z2ggd2UgaGF2ZSBlbm91Z2ggZnJlZSBzcGFj ZSwgd2UgZG9uJ3QgaGF2ZSBhIGJpZyBlbm91Z2gKQEAgLTM0OCw3ICszNjIsNyBAQCBzdGF0aWMg aW50IGlndF9tb2NrX2NvbnRpZ3VvdXModm9pZCAqYXJnKQogCQl9CiAKIAkJdGFyZ2V0ID4+PSAx OwotCX0gd2hpbGUgKHRhcmdldCA+PSBtZW0tPm1tLmNodW5rX3NpemUpOworCX0gd2hpbGUgKHRh cmdldCA+PSBtZW0tPmNodW5rX3NpemUpOwogCiBlcnJfY2xvc2Vfb2JqZWN0czoKIAlsaXN0X3Nw bGljZV90YWlsKCZob2xlcywgJm9iamVjdHMpOwpAQCAtMzY4LDcgKzM4Miw3IEBAIHN0YXRpYyBp bnQgaWd0X21vY2tfc3BsaW50ZXJlZF9yZWdpb24odm9pZCAqYXJnKQogCiAJLyoKIAkgKiBTYW5p dHkgY2hlY2sgd2UgY2FuIHN0aWxsIGFsbG9jYXRlIGV2ZXJ5dGhpbmcgZXZlbiBpZiB0aGUKLQkg KiBtbS5tYXhfb3JkZXIgIT0gbW0uc2l6ZS4gaS5lIG91ciBzdGFydGluZyBhZGRyZXNzIHNwYWNl IHNpemUgaXMgbm90IGEKKwkgKiBtYXhfb3JkZXIgIT0gbW0uc2l6ZS4gaS5lIG91ciBzdGFydGlu ZyBhZGRyZXNzIHNwYWNlIHNpemUgaXMgbm90IGEKIAkgKiBwb3dlci1vZi10d28uCiAJICovCiAK QEAgLTM3NywxNyArMzkxLDEwIEBAIHN0YXRpYyBpbnQgaWd0X21vY2tfc3BsaW50ZXJlZF9yZWdp b24odm9pZCAqYXJnKQogCWlmIChJU19FUlIobWVtKSkKIAkJcmV0dXJuIFBUUl9FUlIobWVtKTsK IAotCWlmIChtZW0tPm1tLnNpemUgIT0gc2l6ZSkgewotCQlwcl9lcnIoIiVzIHNpemUgbWlzbWF0 Y2goJWxsdSAhPSAlbGx1KVxuIiwKLQkJICAgICAgIF9fZnVuY19fLCBtZW0tPm1tLnNpemUsIHNp emUpOwotCQllcnIgPSAtRUlOVkFMOwotCQlnb3RvIG91dF9wdXQ7Ci0JfQotCiAJZXhwZWN0ZWRf b3JkZXIgPSBnZXRfb3JkZXIocm91bmRkb3duX3Bvd19vZl90d28oc2l6ZSkpOwotCWlmIChtZW0t Pm1tLm1heF9vcmRlciAhPSBleHBlY3RlZF9vcmRlcikgeworCWlmIChtZW0tPm1heF9vcmRlciAh PSBleHBlY3RlZF9vcmRlcikgewogCQlwcl9lcnIoIiVzIG9yZGVyIG1pc21hdGNoKCV1ICE9ICV1 KVxuIiwKLQkJICAgICAgIF9fZnVuY19fLCBtZW0tPm1tLm1heF9vcmRlciwgZXhwZWN0ZWRfb3Jk ZXIpOworCQkgICAgICAgX19mdW5jX18sIG1lbS0+bWF4X29yZGVyLCBleHBlY3RlZF9vcmRlcik7 CiAJCWVyciA9IC1FSU5WQUw7CiAJCWdvdG8gb3V0X3B1dDsKIAl9CkBAIC00MDgsMTIgKzQxNSwx NSBAQCBzdGF0aWMgaW50IGlndF9tb2NrX3NwbGludGVyZWRfcmVnaW9uKHZvaWQgKmFyZykKIAkg KiBzdXJlIHRoYXQgZG9lcyBpbmRlZWQgaG9sZCB0cnVlLgogCSAqLwogCi0Jb2JqID0gaWd0X29i amVjdF9jcmVhdGUobWVtLCAmb2JqZWN0cywgc2l6ZSwgSTkxNV9CT19BTExPQ19DT05USUdVT1VT KTsKLQlpZiAoIUlTX0VSUihvYmopKSB7Ci0JCXByX2VycigiJXMgdG9vIGxhcmdlIGNvbnRpZ3Vv dXMgYWxsb2NhdGlvbiB3YXMgbm90IHJlamVjdGVkXG4iLAotCQkgICAgICAgX19mdW5jX18pOwot CQllcnIgPSAtRUlOVkFMOwotCQlnb3RvIG91dF9jbG9zZTsKKwlpZiAoIW1lbS0+aXNfcmFuZ2Vf bWFuYWdlcikgeworCQlvYmogPSBpZ3Rfb2JqZWN0X2NyZWF0ZShtZW0sICZvYmplY3RzLCBzaXpl LAorCQkJCQlJOTE1X0JPX0FMTE9DX0NPTlRJR1VPVVMpOworCQlpZiAoIUlTX0VSUihvYmopKSB7 CisJCQlwcl9lcnIoIiVzIHRvbyBsYXJnZSBjb250aWd1b3VzIGFsbG9jYXRpb24gd2FzIG5vdCBy ZWplY3RlZFxuIiwKKwkJCSAgICAgICBfX2Z1bmNfXyk7CisJCQllcnIgPSAtRUlOVkFMOworCQkJ Z290byBvdXRfY2xvc2U7CisJCX0KIAl9CiAKIAlvYmogPSBpZ3Rfb2JqZWN0X2NyZWF0ZShtZW0s ICZvYmplY3RzLCByb3VuZGRvd25fcG93X29mX3R3byhzaXplKSwKQEAgLTQzMiw2OCArNDQyLDYg QEAgc3RhdGljIGludCBpZ3RfbW9ja19zcGxpbnRlcmVkX3JlZ2lvbih2b2lkICphcmcpCiAJcmV0 dXJuIGVycjsKIH0KIAotI2lmbmRlZiBTWl84RwotI2RlZmluZSBTWl84RyBCSVRfVUxMKDMzKQot I2VuZGlmCi0KLXN0YXRpYyBpbnQgaWd0X21vY2tfbWF4X3NlZ21lbnQodm9pZCAqYXJnKQotewot CWNvbnN0IHVuc2lnbmVkIGludCBtYXhfc2VnbWVudCA9IGk5MTVfc2dfc2VnbWVudF9zaXplKCk7 Ci0Jc3RydWN0IGludGVsX21lbW9yeV9yZWdpb24gKm1lbSA9IGFyZzsKLQlzdHJ1Y3QgZHJtX2k5 MTVfcHJpdmF0ZSAqaTkxNSA9IG1lbS0+aTkxNTsKLQlzdHJ1Y3QgZHJtX2k5MTVfZ2VtX29iamVj dCAqb2JqOwotCXN0cnVjdCBpOTE1X2J1ZGR5X2Jsb2NrICpibG9jazsKLQlzdHJ1Y3Qgc2NhdHRl cmxpc3QgKnNnOwotCUxJU1RfSEVBRChvYmplY3RzKTsKLQl1NjQgc2l6ZTsKLQlpbnQgZXJyID0g MDsKLQotCS8qCi0JICogV2hpbGUgd2UgbWF5IGNyZWF0ZSB2ZXJ5IGxhcmdlIGNvbnRpZ3VvdXMg YmxvY2tzLCB3ZSBtYXkgbmVlZAotCSAqIHRvIGJyZWFrIHRob3NlIGRvd24gZm9yIGNvbnN1bXB0 aW9uIGVsc2V3aGVyZS4gSW4gcGFydGljdWxhciwKLQkgKiBkbWEtbWFwcGluZyB3aXRoIHNjYXR0 ZXJsaXN0IGVsZW1lbnRzIGhhdmUgYW4gaW1wbGljaXQgbGltaXQgb2YKLQkgKiBVSU5UX01BWCBv biBlYWNoIGVsZW1lbnQuCi0JICovCi0KLQlzaXplID0gU1pfOEc7Ci0JbWVtID0gbW9ja19yZWdp b25fY3JlYXRlKGk5MTUsIDAsIHNpemUsIFBBR0VfU0laRSwgMCk7Ci0JaWYgKElTX0VSUihtZW0p KQotCQlyZXR1cm4gUFRSX0VSUihtZW0pOwotCi0Jb2JqID0gaWd0X29iamVjdF9jcmVhdGUobWVt LCAmb2JqZWN0cywgc2l6ZSwgMCk7Ci0JaWYgKElTX0VSUihvYmopKSB7Ci0JCWVyciA9IFBUUl9F UlIob2JqKTsKLQkJZ290byBvdXRfcHV0OwotCX0KLQotCXNpemUgPSAwOwotCWxpc3RfZm9yX2Vh Y2hfZW50cnkoYmxvY2ssICZvYmotPm1tLmJsb2NrcywgbGluaykgewotCQlpZiAoaTkxNV9idWRk eV9ibG9ja19zaXplKCZtZW0tPm1tLCBibG9jaykgPiBzaXplKQotCQkJc2l6ZSA9IGk5MTVfYnVk ZHlfYmxvY2tfc2l6ZSgmbWVtLT5tbSwgYmxvY2spOwotCX0KLQlpZiAoc2l6ZSA8IG1heF9zZWdt ZW50KSB7Ci0JCXByX2VycigiJXM6IEZhaWxlZCB0byBjcmVhdGUgYSBodWdlIGNvbnRpZ3VvdXMg YmxvY2sgWz4gJXVdLCBsYXJnZXN0IGJsb2NrICVsbGRcbiIsCi0JCSAgICAgICBfX2Z1bmNfXywg bWF4X3NlZ21lbnQsIHNpemUpOwotCQllcnIgPSAtRUlOVkFMOwotCQlnb3RvIG91dF9jbG9zZTsK LQl9Ci0KLQlmb3IgKHNnID0gb2JqLT5tbS5wYWdlcy0+c2dsOyBzZzsgc2cgPSBzZ19uZXh0KHNn KSkgewotCQlpZiAoc2ctPmxlbmd0aCA+IG1heF9zZWdtZW50KSB7Ci0JCQlwcl9lcnIoIiVzOiBD cmVhdGVkIGFuIG92ZXJzaXplZCBzY2F0dGVybGlzdCBlbnRyeSwgJXUgPiAldVxuIiwKLQkJCSAg ICAgICBfX2Z1bmNfXywgc2ctPmxlbmd0aCwgbWF4X3NlZ21lbnQpOwotCQkJZXJyID0gLUVJTlZB TDsKLQkJCWdvdG8gb3V0X2Nsb3NlOwotCQl9Ci0JfQotCi1vdXRfY2xvc2U6Ci0JY2xvc2Vfb2Jq ZWN0cyhtZW0sICZvYmplY3RzKTsKLW91dF9wdXQ6Ci0JaW50ZWxfbWVtb3J5X3JlZ2lvbl9wdXQo bWVtKTsKLQlyZXR1cm4gZXJyOwotfQotCiBzdGF0aWMgaW50IGlndF9ncHVfd3JpdGVfZHcoc3Ry dWN0IGludGVsX2NvbnRleHQgKmNlLAogCQkJICAgIHN0cnVjdCBpOTE1X3ZtYSAqdm1hLAogCQkJ ICAgIHUzMiBkd29yZCwKQEAgLTEwOTgsNyArMTA0Niw2IEBAIGludCBpbnRlbF9tZW1vcnlfcmVn aW9uX21vY2tfc2VsZnRlc3RzKHZvaWQpCiAJCVNVQlRFU1QoaWd0X21vY2tfZmlsbCksCiAJCVNV QlRFU1QoaWd0X21vY2tfY29udGlndW91cyksCiAJCVNVQlRFU1QoaWd0X21vY2tfc3BsaW50ZXJl ZF9yZWdpb24pLAotCQlTVUJURVNUKGlndF9tb2NrX21heF9zZWdtZW50KSwKIAl9OwogCXN0cnVj dCBpbnRlbF9tZW1vcnlfcmVnaW9uICptZW07CiAJc3RydWN0IGRybV9pOTE1X3ByaXZhdGUgKmk5 MTU7CmRpZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9kcm0vaTkxNS9zZWxmdGVzdHMvbW9ja19yZWdp b24uYyBiL2RyaXZlcnMvZ3B1L2RybS9pOTE1L3NlbGZ0ZXN0cy9tb2NrX3JlZ2lvbi5jCmluZGV4 IDVkMmQwMTBhMWUyMi4uOGEyMTdhNTkyZWM2IDEwMDY0NAotLS0gYS9kcml2ZXJzL2dwdS9kcm0v aTkxNS9zZWxmdGVzdHMvbW9ja19yZWdpb24uYworKysgYi9kcml2ZXJzL2dwdS9kcm0vaTkxNS9z ZWxmdGVzdHMvbW9ja19yZWdpb24uYwpAQCAtMSwxNyArMSw1MiBAQAogLy8gU1BEWC1MaWNlbnNl LUlkZW50aWZpZXI6IE1JVAogLyoKLSAqIENvcHlyaWdodCDCqSAyMDE5IEludGVsIENvcnBvcmF0 aW9uCisgKiBDb3B5cmlnaHQgwqkgMjAxOS0yMDIxIEludGVsIENvcnBvcmF0aW9uCiAgKi8KIAor I2luY2x1ZGUgPGxpbnV4L3NjYXR0ZXJsaXN0Lmg+CisKICNpbmNsdWRlICJnZW0vaTkxNV9nZW1f cmVnaW9uLmgiCiAjaW5jbHVkZSAiaW50ZWxfbWVtb3J5X3JlZ2lvbi5oIgorI2luY2x1ZGUgImlu dGVsX3JlZ2lvbl90dG0uaCIKIAogI2luY2x1ZGUgIm1vY2tfcmVnaW9uLmgiCiAKK3N0YXRpYyB2 b2lkIG1vY2tfcmVnaW9uX3B1dF9wYWdlcyhzdHJ1Y3QgZHJtX2k5MTVfZ2VtX29iamVjdCAqb2Jq LAorCQkJCSAgc3RydWN0IHNnX3RhYmxlICpwYWdlcykKK3sKKwlpbnRlbF9yZWdpb25fdHRtX25v ZGVfZnJlZShvYmotPm1tLnJlZ2lvbiwgb2JqLT5tbS5zdF9tbV9ub2RlKTsKKwlzZ19mcmVlX3Rh YmxlKHBhZ2VzKTsKKwlrZnJlZShwYWdlcyk7Cit9CisKK3N0YXRpYyBpbnQgbW9ja19yZWdpb25f Z2V0X3BhZ2VzKHN0cnVjdCBkcm1faTkxNV9nZW1fb2JqZWN0ICpvYmopCit7CisJdW5zaWduZWQg aW50IGZsYWdzOworCXN0cnVjdCBzZ190YWJsZSAqcGFnZXM7CisKKwlmbGFncyA9IEk5MTVfQUxM T0NfTUlOX1BBR0VfU0laRTsKKwlpZiAob2JqLT5mbGFncyAmIEk5MTVfQk9fQUxMT0NfQ09OVElH VU9VUykKKwkJZmxhZ3MgfD0gSTkxNV9BTExPQ19DT05USUdVT1VTOworCisJb2JqLT5tbS5zdF9t bV9ub2RlID0gaW50ZWxfcmVnaW9uX3R0bV9ub2RlX2FsbG9jKG9iai0+bW0ucmVnaW9uLAorCQkJ CQkJCSBvYmotPmJhc2Uuc2l6ZSwKKwkJCQkJCQkgZmxhZ3MpOworCWlmIChJU19FUlIob2JqLT5t bS5zdF9tbV9ub2RlKSkKKwkJcmV0dXJuIFBUUl9FUlIob2JqLT5tbS5zdF9tbV9ub2RlKTsKKwor CXBhZ2VzID0gaW50ZWxfcmVnaW9uX3R0bV9ub2RlX3RvX3N0KG9iai0+bW0ucmVnaW9uLCBvYmot Pm1tLnN0X21tX25vZGUpOworCWlmIChJU19FUlIocGFnZXMpKQorCQlyZXR1cm4gUFRSX0VSUihw YWdlcyk7CisKKwlfX2k5MTVfZ2VtX29iamVjdF9zZXRfcGFnZXMob2JqLCBwYWdlcywgaTkxNV9z Z19kbWFfc2l6ZXMocGFnZXMtPnNnbCkpOworCisJcmV0dXJuIDA7Cit9CisKIHN0YXRpYyBjb25z dCBzdHJ1Y3QgZHJtX2k5MTVfZ2VtX29iamVjdF9vcHMgbW9ja19yZWdpb25fb2JqX29wcyA9IHsK IAkubmFtZSA9ICJtb2NrLXJlZ2lvbiIsCi0JLmdldF9wYWdlcyA9IGk5MTVfZ2VtX29iamVjdF9n ZXRfcGFnZXNfYnVkZHksCi0JLnB1dF9wYWdlcyA9IGk5MTVfZ2VtX29iamVjdF9wdXRfcGFnZXNf YnVkZHksCisJLmdldF9wYWdlcyA9IG1vY2tfcmVnaW9uX2dldF9wYWdlcywKKwkucHV0X3BhZ2Vz ID0gbW9ja19yZWdpb25fcHV0X3BhZ2VzLAogCS5yZWxlYXNlID0gaTkxNV9nZW1fb2JqZWN0X3Jl bGVhc2VfbWVtb3J5X3JlZ2lvbiwKIH07CiAKQEAgLTIzLDcgKzU4LDcgQEAgc3RhdGljIGludCBt b2NrX29iamVjdF9pbml0KHN0cnVjdCBpbnRlbF9tZW1vcnlfcmVnaW9uICptZW0sCiAJc3RhdGlj IHN0cnVjdCBsb2NrX2NsYXNzX2tleSBsb2NrX2NsYXNzOwogCXN0cnVjdCBkcm1faTkxNV9wcml2 YXRlICppOTE1ID0gbWVtLT5pOTE1OwogCi0JaWYgKHNpemUgPiBtZW0tPm1tLnNpemUpCisJaWYg KHNpemUgPiByZXNvdXJjZV9zaXplKCZtZW0tPnJlZ2lvbikpCiAJCXJldHVybiAtRTJCSUc7CiAK IAlkcm1fZ2VtX3ByaXZhdGVfb2JqZWN0X2luaXQoJmk5MTUtPmRybSwgJm9iai0+YmFzZSwgc2l6 ZSk7CkBAIC0zOSw4ICs3NCw4IEBAIHN0YXRpYyBpbnQgbW9ja19vYmplY3RfaW5pdChzdHJ1Y3Qg aW50ZWxfbWVtb3J5X3JlZ2lvbiAqbWVtLAogfQogCiBzdGF0aWMgY29uc3Qgc3RydWN0IGludGVs X21lbW9yeV9yZWdpb25fb3BzIG1vY2tfcmVnaW9uX29wcyA9IHsKLQkuaW5pdCA9IGludGVsX21l bW9yeV9yZWdpb25faW5pdF9idWRkeSwKLQkucmVsZWFzZSA9IGludGVsX21lbW9yeV9yZWdpb25f cmVsZWFzZV9idWRkeSwKKwkuaW5pdCA9IGludGVsX3JlZ2lvbl90dG1faW5pdCwKKwkucmVsZWFz ZSA9IGludGVsX3JlZ2lvbl90dG1fZmluaSwKIAkuaW5pdF9vYmplY3QgPSBtb2NrX29iamVjdF9p bml0LAogfTsKIApAQCAtNTIsNSArODcsNiBAQCBtb2NrX3JlZ2lvbl9jcmVhdGUoc3RydWN0IGRy bV9pOTE1X3ByaXZhdGUgKmk5MTUsCiAJCSAgIHJlc291cmNlX3NpemVfdCBpb19zdGFydCkKIHsK IAlyZXR1cm4gaW50ZWxfbWVtb3J5X3JlZ2lvbl9jcmVhdGUoaTkxNSwgc3RhcnQsIHNpemUsIG1p bl9wYWdlX3NpemUsCi0JCQkJCSAgaW9fc3RhcnQsICZtb2NrX3JlZ2lvbl9vcHMpOworCQkJCQkg IGlvX3N0YXJ0LCBJTlRFTF9NRU1PUllfTU9DSywgMCwKKwkJCQkJICAmbW9ja19yZWdpb25fb3Bz KTsKIH0KLS0gCjIuMzEuMQoKX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fX18KSW50ZWwtZ2Z4IG1haWxpbmcgbGlzdApJbnRlbC1nZnhAbGlzdHMuZnJlZWRlc2t0 b3Aub3JnCmh0dHBzOi8vbGlzdHMuZnJlZWRlc2t0b3Aub3JnL21haWxtYW4vbGlzdGluZm8vaW50 ZWwtZ2Z4Cg== From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org X-Spam-Level: X-Spam-Status: No, score=-16.8 required=3.0 tests=BAYES_00, HEADER_FROM_DIFFERENT_DOMAINS,INCLUDES_CR_TRAILER,INCLUDES_PATCH, MAILING_LIST_MULTI,SPF_HELO_NONE,SPF_PASS,USER_AGENT_GIT autolearn=ham autolearn_force=no version=3.4.0 Received: from mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id 1BD43C433B4 for ; Tue, 18 May 2021 08:27:50 +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 C47B1610E9 for ; Tue, 18 May 2021 08:27:49 +0000 (UTC) DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org C47B1610E9 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 A866D6EABA; Tue, 18 May 2021 08:27:43 +0000 (UTC) Received: from mga17.intel.com (mga17.intel.com [192.55.52.151]) by gabe.freedesktop.org (Postfix) with ESMTPS id 8457B6E860; Tue, 18 May 2021 08:27:39 +0000 (UTC) IronPort-SDR: Hh3v3iPG36tYB7pd1fC/zjKmzafsw/1M0rqgRByl/jnFJRS+o5yqiOsI0FgZqQcLAa9nj1f9gD 7FWd/dSTis1g== X-IronPort-AV: E=McAfee;i="6200,9189,9987"; a="180937170" X-IronPort-AV: E=Sophos;i="5.82,309,1613462400"; d="scan'208";a="180937170" Received: from orsmga005.jf.intel.com ([10.7.209.41]) by fmsmga107.fm.intel.com with ESMTP/TLS/ECDHE-RSA-AES256-GCM-SHA384; 18 May 2021 01:27:37 -0700 IronPort-SDR: P0/7LBMGe6uiTxlH2oaq5oqv7j3oyavaj6/i1T4MIP7e+M3bYmpJVMQItikhIY1QOHXj102yM1 8SuBzif6PnTQ== X-IronPort-AV: E=Sophos;i="5.82,309,1613462400"; d="scan'208";a="611892316" Received: from cmutgix-mobl.gar.corp.intel.com (HELO thellst-mobl1.intel.com) ([10.249.254.195]) by orsmga005-auth.jf.intel.com with ESMTP/TLS/ECDHE-RSA-AES256-GCM-SHA384; 18 May 2021 01:27:31 -0700 From: =?UTF-8?q?Thomas=20Hellstr=C3=B6m?= To: intel-gfx@lists.freedesktop.org, dri-devel@lists.freedesktop.org Subject: [PATCH v2 05/15] drm/i915/ttm Initialize the ttm device and memory managers Date: Tue, 18 May 2021 10:26:51 +0200 Message-Id: <20210518082701.997251-6-thomas.hellstrom@linux.intel.com> X-Mailer: git-send-email 2.31.1 In-Reply-To: <20210518082701.997251-1-thomas.hellstrom@linux.intel.com> References: <20210518082701.997251-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?= Errors-To: dri-devel-bounces@lists.freedesktop.org Sender: "dri-devel" Temporarily remove the buddy allocator and related selftests and hook up the TTM range manager for i915 regions. Also modify the mock region selftests somewhat to account for a fragmenting manager. Signed-off-by: Thomas Hellström --- v2: - Fix an error unwind in lmem_get_pages() (Reported by Matthew Auld) - Break out and modify usage of i915_sg_dma_sizes() (Reported by Mattew Auld) - Break out TTM changes to a separate patch (Reported by Christian König) --- drivers/gpu/drm/i915/Kconfig | 1 + drivers/gpu/drm/i915/Makefile | 2 +- drivers/gpu/drm/i915/gem/i915_gem_lmem.c | 59 +- .../gpu/drm/i915/gem/i915_gem_object_types.h | 6 +- drivers/gpu/drm/i915/gem/i915_gem_pages.c | 3 +- drivers/gpu/drm/i915/gem/i915_gem_region.c | 120 --- drivers/gpu/drm/i915/gem/i915_gem_region.h | 4 - drivers/gpu/drm/i915/gem/i915_gem_shmem.c | 4 +- drivers/gpu/drm/i915/gem/i915_gem_stolen.c | 10 +- drivers/gpu/drm/i915/gem/i915_gem_stolen.h | 9 +- drivers/gpu/drm/i915/gt/intel_gt.c | 2 - drivers/gpu/drm/i915/gt/intel_region_lmem.c | 27 +- drivers/gpu/drm/i915/i915_buddy.c | 435 ---------- drivers/gpu/drm/i915/i915_buddy.h | 131 --- drivers/gpu/drm/i915/i915_drv.c | 8 + drivers/gpu/drm/i915/i915_drv.h | 7 +- drivers/gpu/drm/i915/i915_gem.c | 1 + drivers/gpu/drm/i915/i915_globals.c | 1 - drivers/gpu/drm/i915/i915_globals.h | 1 - drivers/gpu/drm/i915/i915_scatterlist.c | 70 ++ drivers/gpu/drm/i915/i915_scatterlist.h | 4 + drivers/gpu/drm/i915/intel_memory_region.c | 180 ++-- drivers/gpu/drm/i915/intel_memory_region.h | 44 +- drivers/gpu/drm/i915/intel_region_ttm.c | 245 ++++++ drivers/gpu/drm/i915/intel_region_ttm.h | 29 + drivers/gpu/drm/i915/selftests/i915_buddy.c | 789 ------------------ .../drm/i915/selftests/i915_mock_selftests.h | 1 - .../drm/i915/selftests/intel_memory_region.c | 133 +-- drivers/gpu/drm/i915/selftests/mock_region.c | 50 +- 29 files changed, 622 insertions(+), 1754 deletions(-) delete mode 100644 drivers/gpu/drm/i915/i915_buddy.c delete mode 100644 drivers/gpu/drm/i915/i915_buddy.h create mode 100644 drivers/gpu/drm/i915/intel_region_ttm.c create mode 100644 drivers/gpu/drm/i915/intel_region_ttm.h delete mode 100644 drivers/gpu/drm/i915/selftests/i915_buddy.c diff --git a/drivers/gpu/drm/i915/Kconfig b/drivers/gpu/drm/i915/Kconfig index 1e1cb245fca7..b63d374dff23 100644 --- a/drivers/gpu/drm/i915/Kconfig +++ b/drivers/gpu/drm/i915/Kconfig @@ -26,6 +26,7 @@ config DRM_I915 select SND_HDA_I915 if SND_HDA_CORE select CEC_CORE if CEC_NOTIFIER select VMAP_PFN + select DRM_TTM help Choose this option if you have a system that has "Intel Graphics Media Accelerator" or "HD Graphics" integrated graphics, diff --git a/drivers/gpu/drm/i915/Makefile b/drivers/gpu/drm/i915/Makefile index d0d936d9137b..cb8823570996 100644 --- a/drivers/gpu/drm/i915/Makefile +++ b/drivers/gpu/drm/i915/Makefile @@ -50,6 +50,7 @@ i915-y += i915_drv.o \ intel_memory_region.o \ intel_pch.o \ intel_pm.o \ + intel_region_ttm.o \ intel_runtime_pm.o \ intel_sideband.o \ intel_step.o \ @@ -160,7 +161,6 @@ gem-y += \ i915-y += \ $(gem-y) \ i915_active.o \ - i915_buddy.o \ i915_cmd_parser.o \ i915_gem_evict.o \ i915_gem_gtt.o \ diff --git a/drivers/gpu/drm/i915/gem/i915_gem_lmem.c b/drivers/gpu/drm/i915/gem/i915_gem_lmem.c index f44bdd08f7cb..3b4aa28a076d 100644 --- a/drivers/gpu/drm/i915/gem/i915_gem_lmem.c +++ b/drivers/gpu/drm/i915/gem/i915_gem_lmem.c @@ -4,16 +4,71 @@ */ #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 = i915_gem_object_get_pages_buddy, - .put_pages = i915_gem_object_put_pages_buddy, + .get_pages = lmem_get_pages, + .put_pages = lmem_put_pages, .release = i915_gem_object_release_memory_region, }; 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 450340a73186..dbd7fffe956e 100644 --- a/drivers/gpu/drm/i915/gem/i915_gem_object_types.h +++ b/drivers/gpu/drm/i915/gem/i915_gem_object_types.h @@ -232,10 +232,12 @@ struct drm_i915_gem_object { * Memory region for this object. */ struct intel_memory_region *region; + /** - * List of memory region blocks allocated for this object. + * Memory manager node allocated for this object. */ - struct list_head blocks; + void *st_mm_node; + /** * Element within memory_region->objects or region->purgeable * if the object is marked as DONTNEED. Access is protected by diff --git a/drivers/gpu/drm/i915/gem/i915_gem_pages.c b/drivers/gpu/drm/i915/gem/i915_gem_pages.c index aed8a37ccdc9..62ee2185a41b 100644 --- a/drivers/gpu/drm/i915/gem/i915_gem_pages.c +++ b/drivers/gpu/drm/i915/gem/i915_gem_pages.c @@ -473,7 +473,8 @@ __i915_gem_object_get_sg(struct drm_i915_gem_object *obj, might_sleep(); GEM_BUG_ON(n >= obj->base.size >> PAGE_SHIFT); - GEM_BUG_ON(!i915_gem_object_has_pinned_pages(obj)); + if (!i915_gem_object_has_pinned_pages(obj)) + assert_object_held(obj); /* As we iterate forward through the sg, we record each entry in a * radixtree for quick repeated (backwards) lookups. If we have seen diff --git a/drivers/gpu/drm/i915/gem/i915_gem_region.c b/drivers/gpu/drm/i915/gem/i915_gem_region.c index ce8fcfc54079..f25e6646c5b7 100644 --- a/drivers/gpu/drm/i915/gem/i915_gem_region.c +++ b/drivers/gpu/drm/i915/gem/i915_gem_region.c @@ -8,129 +8,9 @@ #include "i915_drv.h" #include "i915_trace.h" -void -i915_gem_object_put_pages_buddy(struct drm_i915_gem_object *obj, - struct sg_table *pages) -{ - __intel_memory_region_put_pages_buddy(obj->mm.region, &obj->mm.blocks); - - obj->mm.dirty = false; - sg_free_table(pages); - kfree(pages); -} - -int -i915_gem_object_get_pages_buddy(struct drm_i915_gem_object *obj) -{ - const u64 max_segment = i915_sg_segment_size(); - struct intel_memory_region *mem = obj->mm.region; - struct list_head *blocks = &obj->mm.blocks; - resource_size_t size = obj->base.size; - resource_size_t prev_end; - struct i915_buddy_block *block; - unsigned int flags; - struct sg_table *st; - struct scatterlist *sg; - unsigned int sg_page_sizes; - int ret; - - st = kmalloc(sizeof(*st), GFP_KERNEL); - if (!st) - return -ENOMEM; - - if (sg_alloc_table(st, size >> PAGE_SHIFT, GFP_KERNEL)) { - kfree(st); - return -ENOMEM; - } - - flags = I915_ALLOC_MIN_PAGE_SIZE; - if (obj->flags & I915_BO_ALLOC_CONTIGUOUS) - flags |= I915_ALLOC_CONTIGUOUS; - - ret = __intel_memory_region_get_pages_buddy(mem, size, flags, blocks); - if (ret) - goto err_free_sg; - - GEM_BUG_ON(list_empty(blocks)); - - sg = st->sgl; - st->nents = 0; - sg_page_sizes = 0; - prev_end = (resource_size_t)-1; - - list_for_each_entry(block, blocks, link) { - u64 block_size, offset; - - block_size = min_t(u64, size, - i915_buddy_block_size(&mem->mm, block)); - offset = i915_buddy_block_offset(block); - - while (block_size) { - u64 len; - - if (offset != prev_end || sg->length >= max_segment) { - if (st->nents) { - sg_page_sizes |= sg->length; - sg = __sg_next(sg); - } - - sg_dma_address(sg) = mem->region.start + offset; - sg_dma_len(sg) = 0; - sg->length = 0; - st->nents++; - } - - len = min(block_size, max_segment - sg->length); - sg->length += len; - sg_dma_len(sg) += len; - - offset += len; - block_size -= len; - - prev_end = offset; - } - } - - sg_page_sizes |= sg->length; - sg_mark_end(sg); - i915_sg_trim(st); - - /* Intended for kernel internal use only */ - if (obj->flags & I915_BO_ALLOC_CPU_CLEAR) { - struct scatterlist *sg; - unsigned long i; - - for_each_sg(st->sgl, sg, st->nents, i) { - unsigned int length; - void __iomem *vaddr; - dma_addr_t daddr; - - daddr = sg_dma_address(sg); - daddr -= mem->region.start; - length = sg_dma_len(sg); - - vaddr = io_mapping_map_wc(&mem->iomap, daddr, length); - memset64((void __force *)vaddr, 0, length / sizeof(u64)); - io_mapping_unmap(vaddr); - } - - wmb(); - } - - __i915_gem_object_set_pages(obj, st, sg_page_sizes); - - return 0; - -err_free_sg: - sg_free_table(st); - kfree(st); - return ret; -} - void i915_gem_object_init_memory_region(struct drm_i915_gem_object *obj, struct intel_memory_region *mem) { - INIT_LIST_HEAD(&obj->mm.blocks); obj->mm.region = intel_memory_region_get(mem); if (obj->base.size <= mem->min_page_size) diff --git a/drivers/gpu/drm/i915/gem/i915_gem_region.h b/drivers/gpu/drm/i915/gem/i915_gem_region.h index ebddc86d78f7..84fcb3297400 100644 --- a/drivers/gpu/drm/i915/gem/i915_gem_region.h +++ b/drivers/gpu/drm/i915/gem/i915_gem_region.h @@ -12,10 +12,6 @@ struct intel_memory_region; struct drm_i915_gem_object; struct sg_table; -int i915_gem_object_get_pages_buddy(struct drm_i915_gem_object *obj); -void i915_gem_object_put_pages_buddy(struct drm_i915_gem_object *obj, - struct sg_table *pages); - void i915_gem_object_init_memory_region(struct drm_i915_gem_object *obj, struct intel_memory_region *mem); void i915_gem_object_release_memory_region(struct drm_i915_gem_object *obj); diff --git a/drivers/gpu/drm/i915/gem/i915_gem_shmem.c b/drivers/gpu/drm/i915/gem/i915_gem_shmem.c index a9bfa66c8da1..5d16c4462fda 100644 --- a/drivers/gpu/drm/i915/gem/i915_gem_shmem.c +++ b/drivers/gpu/drm/i915/gem/i915_gem_shmem.c @@ -628,11 +628,13 @@ static const struct intel_memory_region_ops shmem_region_ops = { .init_object = shmem_object_init, }; -struct intel_memory_region *i915_gem_shmem_setup(struct drm_i915_private *i915) +struct intel_memory_region *i915_gem_shmem_setup(struct drm_i915_private *i915, + u16 type, u16 instance) { return intel_memory_region_create(i915, 0, totalram_pages() << PAGE_SHIFT, PAGE_SIZE, 0, + type, instance, &shmem_region_ops); } diff --git a/drivers/gpu/drm/i915/gem/i915_gem_stolen.c b/drivers/gpu/drm/i915/gem/i915_gem_stolen.c index 293f640faa0a..c42abee206da 100644 --- a/drivers/gpu/drm/i915/gem/i915_gem_stolen.c +++ b/drivers/gpu/drm/i915/gem/i915_gem_stolen.c @@ -770,7 +770,8 @@ static const struct intel_memory_region_ops i915_region_stolen_lmem_ops = { }; struct intel_memory_region * -i915_gem_stolen_lmem_setup(struct drm_i915_private *i915) +i915_gem_stolen_lmem_setup(struct drm_i915_private *i915, u16 type, + u16 instance) { struct intel_uncore *uncore = &i915->uncore; struct pci_dev *pdev = to_pci_dev(i915->drm.dev); @@ -788,6 +789,7 @@ i915_gem_stolen_lmem_setup(struct drm_i915_private *i915) mem = intel_memory_region_create(i915, lmem_base, lmem_size, I915_GTT_PAGE_SIZE_4K, io_start, + type, instance, &i915_region_stolen_lmem_ops); if (IS_ERR(mem)) return mem; @@ -809,14 +811,15 @@ i915_gem_stolen_lmem_setup(struct drm_i915_private *i915) } struct intel_memory_region* -i915_gem_stolen_smem_setup(struct drm_i915_private *i915) +i915_gem_stolen_smem_setup(struct drm_i915_private *i915, u16 type, + u16 instance) { struct intel_memory_region *mem; mem = intel_memory_region_create(i915, intel_graphics_stolen_res.start, resource_size(&intel_graphics_stolen_res), - PAGE_SIZE, 0, + PAGE_SIZE, 0, type, instance, &i915_region_stolen_smem_ops); if (IS_ERR(mem)) return mem; @@ -824,7 +827,6 @@ i915_gem_stolen_smem_setup(struct drm_i915_private *i915) intel_memory_region_set_name(mem, "stolen-system"); mem->private = true; - return mem; } diff --git a/drivers/gpu/drm/i915/gem/i915_gem_stolen.h b/drivers/gpu/drm/i915/gem/i915_gem_stolen.h index 2bec6c367b9c..ccdf7befc571 100644 --- a/drivers/gpu/drm/i915/gem/i915_gem_stolen.h +++ b/drivers/gpu/drm/i915/gem/i915_gem_stolen.h @@ -21,8 +21,13 @@ int i915_gem_stolen_insert_node_in_range(struct drm_i915_private *dev_priv, u64 end); void i915_gem_stolen_remove_node(struct drm_i915_private *dev_priv, struct drm_mm_node *node); -struct intel_memory_region *i915_gem_stolen_smem_setup(struct drm_i915_private *i915); -struct intel_memory_region *i915_gem_stolen_lmem_setup(struct drm_i915_private *i915); +struct intel_memory_region * +i915_gem_stolen_smem_setup(struct drm_i915_private *i915, u16 type, + u16 instance); +struct intel_memory_region * +i915_gem_stolen_lmem_setup(struct drm_i915_private *i915, u16 type, + u16 instance); + struct drm_i915_gem_object * i915_gem_object_create_stolen(struct drm_i915_private *dev_priv, resource_size_t size); diff --git a/drivers/gpu/drm/i915/gt/intel_gt.c b/drivers/gpu/drm/i915/gt/intel_gt.c index 8d77dcbad059..3f88ecdee031 100644 --- a/drivers/gpu/drm/i915/gt/intel_gt.c +++ b/drivers/gpu/drm/i915/gt/intel_gt.c @@ -68,8 +68,6 @@ int intel_gt_probe_lmem(struct intel_gt *gt) id = INTEL_REGION_LMEM; mem->id = id; - mem->type = INTEL_MEMORY_LOCAL; - mem->instance = 0; intel_memory_region_set_name(mem, "local%u", mem->instance); diff --git a/drivers/gpu/drm/i915/gt/intel_region_lmem.c b/drivers/gpu/drm/i915/gt/intel_region_lmem.c index 73fceb0c25fc..f7366b054f8e 100644 --- a/drivers/gpu/drm/i915/gt/intel_region_lmem.c +++ b/drivers/gpu/drm/i915/gt/intel_region_lmem.c @@ -5,6 +5,8 @@ #include "i915_drv.h" #include "intel_memory_region.h" +#include "intel_region_lmem.h" +#include "intel_region_ttm.h" #include "gem/i915_gem_lmem.h" #include "gem/i915_gem_region.h" #include "intel_region_lmem.h" @@ -66,9 +68,9 @@ static void release_fake_lmem_bar(struct intel_memory_region *mem) static void region_lmem_release(struct intel_memory_region *mem) { - release_fake_lmem_bar(mem); + intel_region_ttm_fini(mem); io_mapping_fini(&mem->iomap); - intel_memory_region_release_buddy(mem); + release_fake_lmem_bar(mem); } static int @@ -83,12 +85,21 @@ region_lmem_init(struct intel_memory_region *mem) if (!io_mapping_init_wc(&mem->iomap, mem->io_start, - resource_size(&mem->region))) - return -EIO; + resource_size(&mem->region))) { + ret = -EIO; + goto out_no_io; + } - ret = intel_memory_region_init_buddy(mem); + ret = intel_region_ttm_init(mem); if (ret) - io_mapping_fini(&mem->iomap); + goto out_no_buddy; + + return 0; + +out_no_buddy: + io_mapping_fini(&mem->iomap); +out_no_io: + release_fake_lmem_bar(mem); return ret; } @@ -127,6 +138,8 @@ intel_gt_setup_fake_lmem(struct intel_gt *gt) mappable_end, PAGE_SIZE, io_start, + INTEL_MEMORY_LOCAL, + 0, &intel_region_lmem_ops); if (!IS_ERR(mem)) { drm_info(&i915->drm, "Intel graphics fake LMEM: %pR\n", @@ -198,6 +211,8 @@ static struct intel_memory_region *setup_lmem(struct intel_gt *gt) lmem_size, I915_GTT_PAGE_SIZE_4K, io_start, + INTEL_MEMORY_LOCAL, + 0, &intel_region_lmem_ops); if (IS_ERR(mem)) return mem; diff --git a/drivers/gpu/drm/i915/i915_buddy.c b/drivers/gpu/drm/i915/i915_buddy.c deleted file mode 100644 index 3a2f6eecb2fc..000000000000 --- a/drivers/gpu/drm/i915/i915_buddy.c +++ /dev/null @@ -1,435 +0,0 @@ -// SPDX-License-Identifier: MIT -/* - * Copyright © 2019 Intel Corporation - */ - -#include -#include - -#include "i915_buddy.h" - -#include "i915_gem.h" -#include "i915_globals.h" -#include "i915_utils.h" - -static struct i915_global_block { - struct i915_global base; - struct kmem_cache *slab_blocks; -} global; - -static void i915_global_buddy_shrink(void) -{ - kmem_cache_shrink(global.slab_blocks); -} - -static void i915_global_buddy_exit(void) -{ - kmem_cache_destroy(global.slab_blocks); -} - -static struct i915_global_block global = { { - .shrink = i915_global_buddy_shrink, - .exit = i915_global_buddy_exit, -} }; - -int __init i915_global_buddy_init(void) -{ - global.slab_blocks = KMEM_CACHE(i915_buddy_block, SLAB_HWCACHE_ALIGN); - if (!global.slab_blocks) - return -ENOMEM; - - i915_global_register(&global.base); - return 0; -} - -static struct i915_buddy_block *i915_block_alloc(struct i915_buddy_block *parent, - unsigned int order, - u64 offset) -{ - struct i915_buddy_block *block; - - GEM_BUG_ON(order > I915_BUDDY_MAX_ORDER); - - block = kmem_cache_zalloc(global.slab_blocks, GFP_KERNEL); - if (!block) - return NULL; - - block->header = offset; - block->header |= order; - block->parent = parent; - - GEM_BUG_ON(block->header & I915_BUDDY_HEADER_UNUSED); - return block; -} - -static void i915_block_free(struct i915_buddy_block *block) -{ - kmem_cache_free(global.slab_blocks, block); -} - -static void mark_allocated(struct i915_buddy_block *block) -{ - block->header &= ~I915_BUDDY_HEADER_STATE; - block->header |= I915_BUDDY_ALLOCATED; - - list_del(&block->link); -} - -static void mark_free(struct i915_buddy_mm *mm, - struct i915_buddy_block *block) -{ - block->header &= ~I915_BUDDY_HEADER_STATE; - block->header |= I915_BUDDY_FREE; - - list_add(&block->link, - &mm->free_list[i915_buddy_block_order(block)]); -} - -static void mark_split(struct i915_buddy_block *block) -{ - block->header &= ~I915_BUDDY_HEADER_STATE; - block->header |= I915_BUDDY_SPLIT; - - list_del(&block->link); -} - -int i915_buddy_init(struct i915_buddy_mm *mm, u64 size, u64 chunk_size) -{ - unsigned int i; - u64 offset; - - if (size < chunk_size) - return -EINVAL; - - if (chunk_size < PAGE_SIZE) - return -EINVAL; - - if (!is_power_of_2(chunk_size)) - return -EINVAL; - - size = round_down(size, chunk_size); - - mm->size = size; - mm->chunk_size = chunk_size; - mm->max_order = ilog2(size) - ilog2(chunk_size); - - GEM_BUG_ON(mm->max_order > I915_BUDDY_MAX_ORDER); - - mm->free_list = kmalloc_array(mm->max_order + 1, - sizeof(struct list_head), - GFP_KERNEL); - if (!mm->free_list) - return -ENOMEM; - - for (i = 0; i <= mm->max_order; ++i) - INIT_LIST_HEAD(&mm->free_list[i]); - - mm->n_roots = hweight64(size); - - mm->roots = kmalloc_array(mm->n_roots, - sizeof(struct i915_buddy_block *), - GFP_KERNEL); - if (!mm->roots) - goto out_free_list; - - offset = 0; - i = 0; - - /* - * Split into power-of-two blocks, in case we are given a size that is - * not itself a power-of-two. - */ - do { - struct i915_buddy_block *root; - unsigned int order; - u64 root_size; - - root_size = rounddown_pow_of_two(size); - order = ilog2(root_size) - ilog2(chunk_size); - - root = i915_block_alloc(NULL, order, offset); - if (!root) - goto out_free_roots; - - mark_free(mm, root); - - GEM_BUG_ON(i > mm->max_order); - GEM_BUG_ON(i915_buddy_block_size(mm, root) < chunk_size); - - mm->roots[i] = root; - - offset += root_size; - size -= root_size; - i++; - } while (size); - - return 0; - -out_free_roots: - while (i--) - i915_block_free(mm->roots[i]); - kfree(mm->roots); -out_free_list: - kfree(mm->free_list); - return -ENOMEM; -} - -void i915_buddy_fini(struct i915_buddy_mm *mm) -{ - int i; - - for (i = 0; i < mm->n_roots; ++i) { - GEM_WARN_ON(!i915_buddy_block_is_free(mm->roots[i])); - i915_block_free(mm->roots[i]); - } - - kfree(mm->roots); - kfree(mm->free_list); -} - -static int split_block(struct i915_buddy_mm *mm, - struct i915_buddy_block *block) -{ - unsigned int block_order = i915_buddy_block_order(block) - 1; - u64 offset = i915_buddy_block_offset(block); - - GEM_BUG_ON(!i915_buddy_block_is_free(block)); - GEM_BUG_ON(!i915_buddy_block_order(block)); - - block->left = i915_block_alloc(block, block_order, offset); - if (!block->left) - return -ENOMEM; - - block->right = i915_block_alloc(block, block_order, - offset + (mm->chunk_size << block_order)); - if (!block->right) { - i915_block_free(block->left); - return -ENOMEM; - } - - mark_free(mm, block->left); - mark_free(mm, block->right); - - mark_split(block); - - return 0; -} - -static struct i915_buddy_block * -get_buddy(struct i915_buddy_block *block) -{ - struct i915_buddy_block *parent; - - parent = block->parent; - if (!parent) - return NULL; - - if (parent->left == block) - return parent->right; - - return parent->left; -} - -static void __i915_buddy_free(struct i915_buddy_mm *mm, - struct i915_buddy_block *block) -{ - struct i915_buddy_block *parent; - - while ((parent = block->parent)) { - struct i915_buddy_block *buddy; - - buddy = get_buddy(block); - - if (!i915_buddy_block_is_free(buddy)) - break; - - list_del(&buddy->link); - - i915_block_free(block); - i915_block_free(buddy); - - block = parent; - } - - mark_free(mm, block); -} - -void i915_buddy_free(struct i915_buddy_mm *mm, - struct i915_buddy_block *block) -{ - GEM_BUG_ON(!i915_buddy_block_is_allocated(block)); - __i915_buddy_free(mm, block); -} - -void i915_buddy_free_list(struct i915_buddy_mm *mm, struct list_head *objects) -{ - struct i915_buddy_block *block, *on; - - list_for_each_entry_safe(block, on, objects, link) { - i915_buddy_free(mm, block); - cond_resched(); - } - INIT_LIST_HEAD(objects); -} - -/* - * Allocate power-of-two block. The order value here translates to: - * - * 0 = 2^0 * mm->chunk_size - * 1 = 2^1 * mm->chunk_size - * 2 = 2^2 * mm->chunk_size - * ... - */ -struct i915_buddy_block * -i915_buddy_alloc(struct i915_buddy_mm *mm, unsigned int order) -{ - struct i915_buddy_block *block = NULL; - unsigned int i; - int err; - - for (i = order; i <= mm->max_order; ++i) { - block = list_first_entry_or_null(&mm->free_list[i], - struct i915_buddy_block, - link); - if (block) - break; - } - - if (!block) - return ERR_PTR(-ENOSPC); - - GEM_BUG_ON(!i915_buddy_block_is_free(block)); - - while (i != order) { - err = split_block(mm, block); - if (unlikely(err)) - goto out_free; - - /* Go low */ - block = block->left; - i--; - } - - mark_allocated(block); - kmemleak_update_trace(block); - return block; - -out_free: - if (i != order) - __i915_buddy_free(mm, block); - return ERR_PTR(err); -} - -static inline bool overlaps(u64 s1, u64 e1, u64 s2, u64 e2) -{ - return s1 <= e2 && e1 >= s2; -} - -static inline bool contains(u64 s1, u64 e1, u64 s2, u64 e2) -{ - return s1 <= s2 && e1 >= e2; -} - -/* - * Allocate range. Note that it's safe to chain together multiple alloc_ranges - * with the same blocks list. - * - * Intended for pre-allocating portions of the address space, for example to - * reserve a block for the initial framebuffer or similar, hence the expectation - * here is that i915_buddy_alloc() is still the main vehicle for - * allocations, so if that's not the case then the drm_mm range allocator is - * probably a much better fit, and so you should probably go use that instead. - */ -int i915_buddy_alloc_range(struct i915_buddy_mm *mm, - struct list_head *blocks, - u64 start, u64 size) -{ - struct i915_buddy_block *block; - struct i915_buddy_block *buddy; - LIST_HEAD(allocated); - LIST_HEAD(dfs); - u64 end; - int err; - int i; - - if (size < mm->chunk_size) - return -EINVAL; - - if (!IS_ALIGNED(size | start, mm->chunk_size)) - return -EINVAL; - - if (range_overflows(start, size, mm->size)) - return -EINVAL; - - for (i = 0; i < mm->n_roots; ++i) - list_add_tail(&mm->roots[i]->tmp_link, &dfs); - - end = start + size - 1; - - do { - u64 block_start; - u64 block_end; - - block = list_first_entry_or_null(&dfs, - struct i915_buddy_block, - tmp_link); - if (!block) - break; - - list_del(&block->tmp_link); - - block_start = i915_buddy_block_offset(block); - block_end = block_start + i915_buddy_block_size(mm, block) - 1; - - if (!overlaps(start, end, block_start, block_end)) - continue; - - if (i915_buddy_block_is_allocated(block)) { - err = -ENOSPC; - goto err_free; - } - - if (contains(start, end, block_start, block_end)) { - if (!i915_buddy_block_is_free(block)) { - err = -ENOSPC; - goto err_free; - } - - mark_allocated(block); - list_add_tail(&block->link, &allocated); - continue; - } - - if (!i915_buddy_block_is_split(block)) { - err = split_block(mm, block); - if (unlikely(err)) - goto err_undo; - } - - list_add(&block->right->tmp_link, &dfs); - list_add(&block->left->tmp_link, &dfs); - } while (1); - - list_splice_tail(&allocated, blocks); - return 0; - -err_undo: - /* - * We really don't want to leave around a bunch of split blocks, since - * bigger is better, so make sure we merge everything back before we - * free the allocated blocks. - */ - buddy = get_buddy(block); - if (buddy && - (i915_buddy_block_is_free(block) && - i915_buddy_block_is_free(buddy))) - __i915_buddy_free(mm, block); - -err_free: - i915_buddy_free_list(mm, &allocated); - return err; -} - -#if IS_ENABLED(CONFIG_DRM_I915_SELFTEST) -#include "selftests/i915_buddy.c" -#endif diff --git a/drivers/gpu/drm/i915/i915_buddy.h b/drivers/gpu/drm/i915/i915_buddy.h deleted file mode 100644 index 9ce5200f4001..000000000000 --- a/drivers/gpu/drm/i915/i915_buddy.h +++ /dev/null @@ -1,131 +0,0 @@ -/* SPDX-License-Identifier: MIT */ -/* - * Copyright © 2019 Intel Corporation - */ - -#ifndef __I915_BUDDY_H__ -#define __I915_BUDDY_H__ - -#include -#include - -struct i915_buddy_block { -#define I915_BUDDY_HEADER_OFFSET GENMASK_ULL(63, 12) -#define I915_BUDDY_HEADER_STATE GENMASK_ULL(11, 10) -#define I915_BUDDY_ALLOCATED (1 << 10) -#define I915_BUDDY_FREE (2 << 10) -#define I915_BUDDY_SPLIT (3 << 10) -/* Free to be used, if needed in the future */ -#define I915_BUDDY_HEADER_UNUSED GENMASK_ULL(9, 6) -#define I915_BUDDY_HEADER_ORDER GENMASK_ULL(5, 0) - u64 header; - - struct i915_buddy_block *left; - struct i915_buddy_block *right; - struct i915_buddy_block *parent; - - void *private; /* owned by creator */ - - /* - * While the block is allocated by the user through i915_buddy_alloc*, - * the user has ownership of the link, for example to maintain within - * a list, if so desired. As soon as the block is freed with - * i915_buddy_free* ownership is given back to the mm. - */ - struct list_head link; - struct list_head tmp_link; -}; - -/* Order-zero must be at least PAGE_SIZE */ -#define I915_BUDDY_MAX_ORDER (63 - PAGE_SHIFT) - -/* - * Binary Buddy System. - * - * Locking should be handled by the user, a simple mutex around - * i915_buddy_alloc* and i915_buddy_free* should suffice. - */ -struct i915_buddy_mm { - /* Maintain a free list for each order. */ - struct list_head *free_list; - - /* - * Maintain explicit binary tree(s) to track the allocation of the - * address space. This gives us a simple way of finding a buddy block - * and performing the potentially recursive merge step when freeing a - * block. Nodes are either allocated or free, in which case they will - * also exist on the respective free list. - */ - struct i915_buddy_block **roots; - - /* - * Anything from here is public, and remains static for the lifetime of - * the mm. Everything above is considered do-not-touch. - */ - unsigned int n_roots; - unsigned int max_order; - - /* Must be at least PAGE_SIZE */ - u64 chunk_size; - u64 size; -}; - -static inline u64 -i915_buddy_block_offset(struct i915_buddy_block *block) -{ - return block->header & I915_BUDDY_HEADER_OFFSET; -} - -static inline unsigned int -i915_buddy_block_order(struct i915_buddy_block *block) -{ - return block->header & I915_BUDDY_HEADER_ORDER; -} - -static inline unsigned int -i915_buddy_block_state(struct i915_buddy_block *block) -{ - return block->header & I915_BUDDY_HEADER_STATE; -} - -static inline bool -i915_buddy_block_is_allocated(struct i915_buddy_block *block) -{ - return i915_buddy_block_state(block) == I915_BUDDY_ALLOCATED; -} - -static inline bool -i915_buddy_block_is_free(struct i915_buddy_block *block) -{ - return i915_buddy_block_state(block) == I915_BUDDY_FREE; -} - -static inline bool -i915_buddy_block_is_split(struct i915_buddy_block *block) -{ - return i915_buddy_block_state(block) == I915_BUDDY_SPLIT; -} - -static inline u64 -i915_buddy_block_size(struct i915_buddy_mm *mm, - struct i915_buddy_block *block) -{ - return mm->chunk_size << i915_buddy_block_order(block); -} - -int i915_buddy_init(struct i915_buddy_mm *mm, u64 size, u64 chunk_size); - -void i915_buddy_fini(struct i915_buddy_mm *mm); - -struct i915_buddy_block * -i915_buddy_alloc(struct i915_buddy_mm *mm, unsigned int order); - -int i915_buddy_alloc_range(struct i915_buddy_mm *mm, - struct list_head *blocks, - u64 start, u64 size); - -void i915_buddy_free(struct i915_buddy_mm *mm, struct i915_buddy_block *block); - -void i915_buddy_free_list(struct i915_buddy_mm *mm, struct list_head *objects); - -#endif diff --git a/drivers/gpu/drm/i915/i915_drv.c b/drivers/gpu/drm/i915/i915_drv.c index 92bccc5623a8..122dd297b6af 100644 --- a/drivers/gpu/drm/i915/i915_drv.c +++ b/drivers/gpu/drm/i915/i915_drv.c @@ -84,6 +84,7 @@ #include "intel_gvt.h" #include "intel_memory_region.h" #include "intel_pm.h" +#include "intel_region_ttm.h" #include "intel_sideband.h" #include "vlv_suspend.h" @@ -335,6 +336,10 @@ static int i915_driver_early_probe(struct drm_i915_private *dev_priv) if (ret < 0) goto err_workqueues; + ret = intel_region_ttm_device_init(dev_priv); + if (ret) + goto err_ttm; + intel_wopcm_init_early(&dev_priv->wopcm); intel_gt_init_early(&dev_priv->gt, dev_priv); @@ -359,6 +364,8 @@ static int i915_driver_early_probe(struct drm_i915_private *dev_priv) err_gem: i915_gem_cleanup_early(dev_priv); intel_gt_driver_late_release(&dev_priv->gt); + intel_region_ttm_device_fini(dev_priv); +err_ttm: vlv_suspend_cleanup(dev_priv); err_workqueues: i915_workqueues_cleanup(dev_priv); @@ -376,6 +383,7 @@ static void i915_driver_late_release(struct drm_i915_private *dev_priv) intel_power_domains_cleanup(dev_priv); i915_gem_cleanup_early(dev_priv); intel_gt_driver_late_release(&dev_priv->gt); + intel_region_ttm_device_fini(dev_priv); vlv_suspend_cleanup(dev_priv); i915_workqueues_cleanup(dev_priv); diff --git a/drivers/gpu/drm/i915/i915_drv.h b/drivers/gpu/drm/i915/i915_drv.h index 128198e8b4d0..1276a2f60740 100644 --- a/drivers/gpu/drm/i915/i915_drv.h +++ b/drivers/gpu/drm/i915/i915_drv.h @@ -60,6 +60,7 @@ #include #include #include +#include #include "i915_params.h" #include "i915_reg.h" @@ -1166,6 +1167,9 @@ struct drm_i915_private { /* Mutex to protect the above hdcp component related values. */ struct mutex hdcp_comp_mutex; + /* The TTM device structure. */ + struct ttm_device bdev; + I915_SELFTEST_DECLARE(struct i915_selftest_stash selftest;) /* @@ -1751,7 +1755,8 @@ void i915_gem_cleanup_userptr(struct drm_i915_private *dev_priv); void i915_gem_init_early(struct drm_i915_private *dev_priv); void i915_gem_cleanup_early(struct drm_i915_private *dev_priv); -struct intel_memory_region *i915_gem_shmem_setup(struct drm_i915_private *i915); +struct intel_memory_region *i915_gem_shmem_setup(struct drm_i915_private *i915, + u16 type, u16 instance); static inline void i915_gem_drain_freed_objects(struct drm_i915_private *i915) { diff --git a/drivers/gpu/drm/i915/i915_gem.c b/drivers/gpu/drm/i915/i915_gem.c index d0018c5f88bd..180f6e9107d4 100644 --- a/drivers/gpu/drm/i915/i915_gem.c +++ b/drivers/gpu/drm/i915/i915_gem.c @@ -1109,6 +1109,7 @@ int i915_gem_init(struct drm_i915_private *dev_priv) } i915_gem_drain_freed_objects(dev_priv); + return ret; } diff --git a/drivers/gpu/drm/i915/i915_globals.c b/drivers/gpu/drm/i915/i915_globals.c index 3aa213684293..77f1911c463b 100644 --- a/drivers/gpu/drm/i915/i915_globals.c +++ b/drivers/gpu/drm/i915/i915_globals.c @@ -87,7 +87,6 @@ static void __i915_globals_cleanup(void) static __initconst int (* const initfn[])(void) = { i915_global_active_init, - i915_global_buddy_init, i915_global_context_init, i915_global_gem_context_init, i915_global_objects_init, diff --git a/drivers/gpu/drm/i915/i915_globals.h b/drivers/gpu/drm/i915/i915_globals.h index b2f5cd9b9b1a..2d199f411a4a 100644 --- a/drivers/gpu/drm/i915/i915_globals.h +++ b/drivers/gpu/drm/i915/i915_globals.h @@ -27,7 +27,6 @@ void i915_globals_exit(void); /* constructors */ int i915_global_active_init(void); -int i915_global_buddy_init(void); int i915_global_context_init(void); int i915_global_gem_context_init(void); int i915_global_objects_init(void); diff --git a/drivers/gpu/drm/i915/i915_scatterlist.c b/drivers/gpu/drm/i915/i915_scatterlist.c index cc6b3846a8c7..69e9e6c3135e 100644 --- a/drivers/gpu/drm/i915/i915_scatterlist.c +++ b/drivers/gpu/drm/i915/i915_scatterlist.c @@ -6,6 +6,10 @@ #include "i915_scatterlist.h" +#include + +#include + bool i915_sg_trim(struct sg_table *orig_st) { struct sg_table new_st; @@ -34,6 +38,72 @@ bool i915_sg_trim(struct sg_table *orig_st) return true; } +/** + * i915_sg_from_mm_node - Create an sg_table from a struct drm_mm_node + * @node: The drm_mm_node. + * @region_start: An offset to add to the dma addresses of the sg list. + * + * Create a struct sg_table, initializing it from a struct drm_mm_node, + * taking a maximum segment length into account, splitting into segments + * if necessary. + * + * Return: A pointer to a kmalloced struct sg_table on success, negative + * error code cast to an error pointer on failure. + */ +struct sg_table *i915_sg_from_mm_node(const struct drm_mm_node *node, + u64 region_start) +{ + const u64 max_segment = SZ_1G; /* Do we have a limit on this? */ + u64 segment_pages = max_segment >> PAGE_SHIFT; + u64 block_size, offset, prev_end; + struct sg_table *st; + struct scatterlist *sg; + + st = kmalloc(sizeof(*st), GFP_KERNEL); + if (!st) + return ERR_PTR(-ENOMEM); + + if (sg_alloc_table(st, DIV_ROUND_UP(node->size, segment_pages), + GFP_KERNEL)) { + kfree(st); + return ERR_PTR(-ENOMEM); + } + + sg = st->sgl; + st->nents = 0; + prev_end = (resource_size_t)-1; + block_size = node->size << PAGE_SHIFT; + offset = node->start << PAGE_SHIFT; + + while (block_size) { + u64 len; + + if (offset != prev_end || sg->length >= max_segment) { + if (st->nents) + sg = __sg_next(sg); + + sg_dma_address(sg) = region_start + offset; + sg_dma_len(sg) = 0; + sg->length = 0; + st->nents++; + } + + len = min(block_size, max_segment - sg->length); + sg->length += len; + sg_dma_len(sg) += len; + + offset += len; + block_size -= len; + + prev_end = offset; + } + + sg_mark_end(sg); + i915_sg_trim(st); + + return st; +} + #if IS_ENABLED(CONFIG_DRM_I915_SELFTEST) #include "selftests/scatterlist.c" #endif diff --git a/drivers/gpu/drm/i915/i915_scatterlist.h b/drivers/gpu/drm/i915/i915_scatterlist.h index b96baad66a3a..5acca45ea981 100644 --- a/drivers/gpu/drm/i915/i915_scatterlist.h +++ b/drivers/gpu/drm/i915/i915_scatterlist.h @@ -13,6 +13,8 @@ #include "i915_gem.h" +struct drm_mm_node; + /* * Optimised SGL iterator for GEM objects */ @@ -141,4 +143,6 @@ static inline unsigned int i915_sg_segment_size(void) bool i915_sg_trim(struct sg_table *orig_st); +struct sg_table *i915_sg_from_mm_node(const struct drm_mm_node *node, + u64 region_start); #endif diff --git a/drivers/gpu/drm/i915/intel_memory_region.c b/drivers/gpu/drm/i915/intel_memory_region.c index d98e8b81d322..4092cc987679 100644 --- a/drivers/gpu/drm/i915/intel_memory_region.c +++ b/drivers/gpu/drm/i915/intel_memory_region.c @@ -28,6 +28,11 @@ static const struct { }, }; +struct intel_region_reserve { + struct list_head link; + void *node; +}; + struct intel_memory_region * intel_memory_region_lookup(struct drm_i915_private *i915, u16 class, u16 instance) @@ -58,146 +63,61 @@ intel_memory_region_by_type(struct drm_i915_private *i915, return NULL; } -static u64 -intel_memory_region_free_pages(struct intel_memory_region *mem, - struct list_head *blocks) +/** + * intel_memory_region_unreserve - Unreserve all previously reserved + * ranges + * @mem: The region containing the reserved ranges. + */ +void intel_memory_region_unreserve(struct intel_memory_region *mem) { - struct i915_buddy_block *block, *on; - u64 size = 0; + struct intel_region_reserve *reserve, *next; - list_for_each_entry_safe(block, on, blocks, link) { - size += i915_buddy_block_size(&mem->mm, block); - i915_buddy_free(&mem->mm, block); - } - INIT_LIST_HEAD(blocks); + if (!mem->priv_ops || !mem->priv_ops->free) + return; - return size; -} - -void -__intel_memory_region_put_pages_buddy(struct intel_memory_region *mem, - struct list_head *blocks) -{ mutex_lock(&mem->mm_lock); - mem->avail += intel_memory_region_free_pages(mem, blocks); - mutex_unlock(&mem->mm_lock); -} - -void -__intel_memory_region_put_block_buddy(struct i915_buddy_block *block) -{ - struct list_head blocks; - - INIT_LIST_HEAD(&blocks); - list_add(&block->link, &blocks); - __intel_memory_region_put_pages_buddy(block->private, &blocks); -} - -int -__intel_memory_region_get_pages_buddy(struct intel_memory_region *mem, - resource_size_t size, - unsigned int flags, - struct list_head *blocks) -{ - unsigned int min_order = 0; - unsigned long n_pages; - - GEM_BUG_ON(!IS_ALIGNED(size, mem->mm.chunk_size)); - GEM_BUG_ON(!list_empty(blocks)); - - if (flags & I915_ALLOC_MIN_PAGE_SIZE) { - min_order = ilog2(mem->min_page_size) - - ilog2(mem->mm.chunk_size); - } - - if (flags & I915_ALLOC_CONTIGUOUS) { - size = roundup_pow_of_two(size); - min_order = ilog2(size) - ilog2(mem->mm.chunk_size); + list_for_each_entry_safe(reserve, next, &mem->reserved, link) { + list_del(&reserve->link); + mem->priv_ops->free(mem, reserve->node); + kfree(reserve); } - - if (size > mem->mm.size) - return -E2BIG; - - n_pages = size >> ilog2(mem->mm.chunk_size); - - mutex_lock(&mem->mm_lock); - - do { - struct i915_buddy_block *block; - unsigned int order; - - order = fls(n_pages) - 1; - GEM_BUG_ON(order > mem->mm.max_order); - GEM_BUG_ON(order < min_order); - - do { - block = i915_buddy_alloc(&mem->mm, order); - if (!IS_ERR(block)) - break; - - if (order-- == min_order) - goto err_free_blocks; - } while (1); - - n_pages -= BIT(order); - - block->private = mem; - list_add_tail(&block->link, blocks); - - if (!n_pages) - break; - } while (1); - - mem->avail -= size; mutex_unlock(&mem->mm_lock); - return 0; - -err_free_blocks: - intel_memory_region_free_pages(mem, blocks); - mutex_unlock(&mem->mm_lock); - return -ENXIO; } -struct i915_buddy_block * -__intel_memory_region_get_block_buddy(struct intel_memory_region *mem, - resource_size_t size, - unsigned int flags) +/** + * intel_memory_region_reserve - Reserve a memory range + * @mem: The region for which we want to reserve a range. + * @offset: Start of the range to reserve. + * @size: The size of the range to reserve. + * + * Return: 0 on success, negative error code on failure. + */ +int intel_memory_region_reserve(struct intel_memory_region *mem, + resource_size_t offset, + resource_size_t size) { - struct i915_buddy_block *block; - LIST_HEAD(blocks); int ret; + struct intel_region_reserve *reserve; - ret = __intel_memory_region_get_pages_buddy(mem, size, flags, &blocks); - if (ret) - return ERR_PTR(ret); + if (!mem->priv_ops || !mem->priv_ops->reserve) + return -EINVAL; - block = list_first_entry(&blocks, typeof(*block), link); - list_del_init(&block->link); - return block; -} + reserve = kzalloc(sizeof(*reserve), GFP_KERNEL); + if (!reserve) + return -ENOMEM; -int intel_memory_region_init_buddy(struct intel_memory_region *mem) -{ - return i915_buddy_init(&mem->mm, resource_size(&mem->region), - PAGE_SIZE); -} - -void intel_memory_region_release_buddy(struct intel_memory_region *mem) -{ - i915_buddy_free_list(&mem->mm, &mem->reserved); - i915_buddy_fini(&mem->mm); -} - -int intel_memory_region_reserve(struct intel_memory_region *mem, - u64 offset, u64 size) -{ - int ret; + reserve->node = mem->priv_ops->reserve(mem, offset, size); + if (IS_ERR(reserve->node)) { + ret = PTR_ERR(reserve->node); + kfree(reserve); + return ret; + } mutex_lock(&mem->mm_lock); - ret = i915_buddy_alloc_range(&mem->mm, &mem->reserved, offset, size); + list_add_tail(&reserve->link, &mem->reserved); mutex_unlock(&mem->mm_lock); - return ret; + return 0; } struct intel_memory_region * @@ -206,6 +126,8 @@ intel_memory_region_create(struct drm_i915_private *i915, resource_size_t size, resource_size_t min_page_size, resource_size_t io_start, + u16 type, + u16 instance, const struct intel_memory_region_ops *ops) { struct intel_memory_region *mem; @@ -222,6 +144,8 @@ intel_memory_region_create(struct drm_i915_private *i915, mem->ops = ops; mem->total = size; mem->avail = mem->total; + mem->type = type; + mem->instance = instance; mutex_init(&mem->objects.lock); INIT_LIST_HEAD(&mem->objects.list); @@ -259,6 +183,7 @@ static void __intel_memory_region_destroy(struct kref *kref) struct intel_memory_region *mem = container_of(kref, typeof(*mem), kref); + intel_memory_region_unreserve(mem); if (mem->ops->release) mem->ops->release(mem); @@ -296,15 +221,15 @@ int intel_memory_regions_hw_probe(struct drm_i915_private *i915) instance = intel_region_map[i].instance; switch (type) { case INTEL_MEMORY_SYSTEM: - mem = i915_gem_shmem_setup(i915); + mem = i915_gem_shmem_setup(i915, type, instance); break; case INTEL_MEMORY_STOLEN_LOCAL: - mem = i915_gem_stolen_lmem_setup(i915); + mem = i915_gem_stolen_lmem_setup(i915, type, instance); if (!IS_ERR(mem)) i915->mm.stolen_region = mem; break; case INTEL_MEMORY_STOLEN_SYSTEM: - mem = i915_gem_stolen_smem_setup(i915); + mem = i915_gem_stolen_smem_setup(i915, type, instance); if (!IS_ERR(mem)) i915->mm.stolen_region = mem; break; @@ -321,9 +246,6 @@ int intel_memory_regions_hw_probe(struct drm_i915_private *i915) } mem->id = i; - mem->type = type; - mem->instance = instance; - i915->mm.regions[i] = mem; } diff --git a/drivers/gpu/drm/i915/intel_memory_region.h b/drivers/gpu/drm/i915/intel_memory_region.h index d24ce5a0b30b..e69cde13daf2 100644 --- a/drivers/gpu/drm/i915/intel_memory_region.h +++ b/drivers/gpu/drm/i915/intel_memory_region.h @@ -13,8 +13,6 @@ #include #include -#include "i915_buddy.h" - struct drm_i915_private; struct drm_i915_gem_object; struct intel_memory_region; @@ -25,6 +23,7 @@ enum intel_memory_type { INTEL_MEMORY_LOCAL = I915_MEMORY_CLASS_DEVICE, INTEL_MEMORY_STOLEN_SYSTEM, INTEL_MEMORY_STOLEN_LOCAL, + INTEL_MEMORY_MOCK, }; enum intel_region_id { @@ -59,10 +58,19 @@ struct intel_memory_region_ops { unsigned int flags); }; +struct intel_memory_region_private_ops { + void *(*reserve)(struct intel_memory_region *mem, + resource_size_t offset, + resource_size_t size); + void (*free)(struct intel_memory_region *mem, + void *node); +}; + struct intel_memory_region { struct drm_i915_private *i915; const struct intel_memory_region_ops *ops; + const struct intel_memory_region_private_ops *priv_ops; struct io_mapping iomap; struct resource region; @@ -70,7 +78,6 @@ struct intel_memory_region { /* For fake LMEM */ struct drm_mm_node fake_mappable; - struct i915_buddy_mm mm; struct mutex mm_lock; struct kref kref; @@ -95,36 +102,26 @@ struct intel_memory_region { struct list_head list; struct list_head purgeable; } objects; + + size_t chunk_size; + unsigned int max_order; + bool is_range_manager; + + void *region_private; }; struct intel_memory_region * intel_memory_region_lookup(struct drm_i915_private *i915, u16 class, u16 instance); -int intel_memory_region_init_buddy(struct intel_memory_region *mem); -void intel_memory_region_release_buddy(struct intel_memory_region *mem); - -int __intel_memory_region_get_pages_buddy(struct intel_memory_region *mem, - resource_size_t size, - unsigned int flags, - struct list_head *blocks); -struct i915_buddy_block * -__intel_memory_region_get_block_buddy(struct intel_memory_region *mem, - resource_size_t size, - unsigned int flags); -void __intel_memory_region_put_pages_buddy(struct intel_memory_region *mem, - struct list_head *blocks); -void __intel_memory_region_put_block_buddy(struct i915_buddy_block *block); - -int intel_memory_region_reserve(struct intel_memory_region *mem, - u64 offset, u64 size); - struct intel_memory_region * intel_memory_region_create(struct drm_i915_private *i915, resource_size_t start, resource_size_t size, resource_size_t min_page_size, resource_size_t io_start, + u16 type, + u16 instance, const struct intel_memory_region_ops *ops); struct intel_memory_region * @@ -141,4 +138,9 @@ __printf(2, 3) void intel_memory_region_set_name(struct intel_memory_region *mem, const char *fmt, ...); +void intel_memory_region_unreserve(struct intel_memory_region *mem); + +int intel_memory_region_reserve(struct intel_memory_region *mem, + resource_size_t offset, + resource_size_t size); #endif diff --git a/drivers/gpu/drm/i915/intel_region_ttm.c b/drivers/gpu/drm/i915/intel_region_ttm.c new file mode 100644 index 000000000000..9fb447e19ebd --- /dev/null +++ b/drivers/gpu/drm/i915/intel_region_ttm.c @@ -0,0 +1,245 @@ +// SPDX-License-Identifier: MIT +/* + * Copyright © 2021 Intel Corporation + */ +#include +#include + +#include "i915_drv.h" +#include "i915_scatterlist.h" + +#include "intel_region_ttm.h" + +/* A Zero-initialized driver for now. We don't have a TTM backend yet. */ +static struct ttm_device_funcs i915_ttm_bo_driver; + +/** + * DOC: TTM support structure + * + * The code in this file deals with setting up memory managers for TTM + * LMEM and MOCK regions and converting the output from + * the managers to struct sg_table, Basically providing the mapping from + * i915 GEM regions to TTM memory types and resource managers. + */ + +/** + * intel_region_ttm_device_init - Initialize a TTM device + * @dev_priv: Pointer to an i915 device private structure. + * + * Return: 0 on success, negative error code on failure. + */ +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, + drm->dev, drm->anon_inode->i_mapping, + drm->vma_offset_manager, false, false); +} + +/** + * intel_region_ttm_device_fini - Finalize a TTM device + * @dev_priv: Pointer to an i915 device private structure. + */ +void intel_region_ttm_device_fini(struct drm_i915_private *dev_priv) +{ + ttm_device_fini(&dev_priv->bdev); +} + +/* + * Map the i915 memory regions to TTM memory types. We use the + * driver-private types for now, reserving TTM_PL_VRAM for stolen + * memory and TTM_PL_TT for GGTT use if decided to implement this. + */ +static int intel_region_to_ttm_type(struct intel_memory_region *mem) +{ + int type; + + GEM_BUG_ON(mem->type != INTEL_MEMORY_LOCAL); + + type = mem->instance + TTM_PL_PRIV; + GEM_BUG_ON(type >= TTM_NUM_MEM_TYPES); + + return type; +} + +static void *intel_region_ttm_node_reserve(struct intel_memory_region *mem, + resource_size_t offset, + resource_size_t size) +{ + struct ttm_resource_manager *man = mem->region_private; + struct ttm_place place = {}; + struct ttm_resource res = {}; + struct ttm_buffer_object mock_bo = {}; + int ret; + + /* + * Having to use a mock_bo is unfortunate but stems from some + * drivers having private managers that insist to know what the + * allocate memory is intended for, using it to send private + * data to the manager. Also recently the bo has been used to send + * alignment info to the manager. Assume that apart from the latter, + * none of the managers we use will ever access the buffer object + * members, hoping we can pass the alignment info in the + * struct ttm_place in the future. + */ + + place.fpfn = offset >> PAGE_SHIFT; + place.lpfn = place.fpfn + (size >> PAGE_SHIFT); + res.num_pages = size >> PAGE_SHIFT; + ret = man->func->alloc(man, &mock_bo, &place, &res); + if (ret == -ENOSPC) + ret = -ENXIO; + + return ret ? ERR_PTR(ret) : res.mm_node; +} + +/** + * intel_region_ttm_node_free - Free a node allocated from a resource manager + * @mem: The region the node was allocated from. + * @node: The opaque node representing an allocation. + */ +void intel_region_ttm_node_free(struct intel_memory_region *mem, + void *node) +{ + struct ttm_resource_manager *man = mem->region_private; + struct ttm_resource res = {}; + + res.mm_node = node; + man->func->free(man, &res); +} + +static const struct intel_memory_region_private_ops priv_ops = { + .reserve = intel_region_ttm_node_reserve, + .free = intel_region_ttm_node_free, +}; + +/** + * intel_region_ttm_init - Initialize a memory region for TTM. + * @mem: The region to initialize. + * + * This function initializes a suitable TTM resource manager for the + * region, and if it's a LMEM region type, attaches it to the TTM + * device. MOCK regions are NOT attached to the TTM device, since we don't + * have one for the mock selftests. + * + * Return: 0 on success, negative error code on failure. + */ +int intel_region_ttm_init(struct intel_memory_region *mem) +{ + struct ttm_resource_manager *man; + + man = ttm_range_man_init_standalone(resource_size(&mem->region) >> + PAGE_SHIFT, false); + if (IS_ERR(man)) + return PTR_ERR(man); + + ttm_resource_manager_set_used(man, true); + mem->chunk_size = PAGE_SIZE; + mem->max_order = + get_order(rounddown_pow_of_two(resource_size(&mem->region))); + mem->is_range_manager = true; + mem->priv_ops = &priv_ops; + mem->region_private = man; + + /* + * Register only LOCAL memory with the device so that we can + * run the mock selftests using the manager. + */ + if (mem->type == INTEL_MEMORY_LOCAL) { + ttm_set_driver_manager(&mem->i915->bdev, + intel_region_to_ttm_type(mem), + man); + } + + return 0; +} + +/** + * intel_region_ttm_fini - Finalize a TTM region. + * @mem: The memory region + * + * This functions takes down the TTM resource manager associated with the + * memory region, and if it was registered with the TTM device, + * removes that registration. + */ +void intel_region_ttm_fini(struct intel_memory_region *mem) +{ + struct ttm_resource_manager *man = mem->region_private; + + if (mem->type == INTEL_MEMORY_LOCAL) { + int ret; + + ret = ttm_range_man_fini(&mem->i915->bdev, + intel_region_to_ttm_type(mem)); + GEM_WARN_ON(ret); + } else { + ttm_resource_manager_set_used(man, false); + ttm_range_man_fini_standalone(man); + } +} + +/** + * intel_region_ttm_node_to_st - Convert an opaque TTM resource manager node + * to an sg_table. + * @mem: The memory region. + * @node: The resource manager node obtained from the TTM resource manager. + * + * The gem backends typically use sg-tables for operations on the underlying + * io_memory. So provide a way for the backends to translate the + * nodes they are handed from TTM to sg-tables. + * + * Return: A malloced sg_table on success, an error pointer on failure. + */ +struct sg_table *intel_region_ttm_node_to_st(struct intel_memory_region *mem, + void *node) +{ + return i915_sg_from_mm_node(node, mem->region.start); +} + +/** + * intel_region_ttm_node_alloc - Allocate memory resources from a region + * @mem: The memory region, + * @size: The requested size in bytes + * @flags: Allocation flags + * + * This functionality is provided only for callers that need to allocate + * memory from standalone TTM range managers, without the TTM eviction + * functionality. Don't use if you are not completely sure that's the + * case. The returned opaque node can be converted to an sg_table using + * intel_region_ttm_node_to_st(), and can be freed using + * intel_region_ttm_node_free(). + * + * Return: A valid pointer on success, an error pointer on failure. + */ +void *intel_region_ttm_node_alloc(struct intel_memory_region *mem, + resource_size_t size, + unsigned int flags) +{ + struct ttm_resource_manager *man = mem->region_private; + struct ttm_place place = {}; + struct ttm_resource res = {}; + struct ttm_buffer_object mock_bo = {}; + int ret; + + /* + * We ignore the flags for now since we're using the range + * manager and contigous and min page size would be fulfilled + * by default if size is min page size aligned. + */ + res.num_pages = size >> PAGE_SHIFT; + + if (mem->is_range_manager) { + if (size >= SZ_1G) + mock_bo.page_alignment = SZ_1G >> PAGE_SHIFT; + else if (size >= SZ_2M) + mock_bo.page_alignment = SZ_2M >> PAGE_SHIFT; + else if (size >= SZ_64K) + mock_bo.page_alignment = SZ_64K >> PAGE_SHIFT; + } + + ret = man->func->alloc(man, &mock_bo, &place, &res); + if (ret == -ENOSPC) + ret = -ENXIO; + return ret ? ERR_PTR(ret) : res.mm_node; +} diff --git a/drivers/gpu/drm/i915/intel_region_ttm.h b/drivers/gpu/drm/i915/intel_region_ttm.h new file mode 100644 index 000000000000..40129f7e0317 --- /dev/null +++ b/drivers/gpu/drm/i915/intel_region_ttm.h @@ -0,0 +1,29 @@ +/* SPDX-License-Identifier: MIT */ +/* + * Copyright © 2021 Intel Corporation + */ +#ifndef _INTEL_REGION_TTM_H_ +#define _INTEL_REGION_TTM_H_ + +#include + +struct drm_i915_private; +struct intel_memory_region; + +int intel_region_ttm_device_init(struct drm_i915_private *dev_priv); + +void intel_region_ttm_device_fini(struct drm_i915_private *dev_priv); + +int intel_region_ttm_init(struct intel_memory_region *mem); + +void intel_region_ttm_fini(struct intel_memory_region *mem); + +struct sg_table *intel_region_ttm_node_to_st(struct intel_memory_region *mem, + void *node); + +void *intel_region_ttm_node_alloc(struct intel_memory_region *mem, + resource_size_t size, + unsigned int flags); +void intel_region_ttm_node_free(struct intel_memory_region *mem, + void *node); +#endif /* _INTEL_REGION_TTM_H_ */ diff --git a/drivers/gpu/drm/i915/selftests/i915_buddy.c b/drivers/gpu/drm/i915/selftests/i915_buddy.c deleted file mode 100644 index f0f5c4df8dbc..000000000000 --- a/drivers/gpu/drm/i915/selftests/i915_buddy.c +++ /dev/null @@ -1,789 +0,0 @@ -// SPDX-License-Identifier: MIT -/* - * Copyright © 2019 Intel Corporation - */ - -#include - -#include "../i915_selftest.h" -#include "i915_random.h" - -static void __igt_dump_block(struct i915_buddy_mm *mm, - struct i915_buddy_block *block, - bool buddy) -{ - pr_err("block info: header=%llx, state=%u, order=%d, offset=%llx size=%llx root=%s buddy=%s\n", - block->header, - i915_buddy_block_state(block), - i915_buddy_block_order(block), - i915_buddy_block_offset(block), - i915_buddy_block_size(mm, block), - yesno(!block->parent), - yesno(buddy)); -} - -static void igt_dump_block(struct i915_buddy_mm *mm, - struct i915_buddy_block *block) -{ - struct i915_buddy_block *buddy; - - __igt_dump_block(mm, block, false); - - buddy = get_buddy(block); - if (buddy) - __igt_dump_block(mm, buddy, true); -} - -static int igt_check_block(struct i915_buddy_mm *mm, - struct i915_buddy_block *block) -{ - struct i915_buddy_block *buddy; - unsigned int block_state; - u64 block_size; - u64 offset; - int err = 0; - - block_state = i915_buddy_block_state(block); - - if (block_state != I915_BUDDY_ALLOCATED && - block_state != I915_BUDDY_FREE && - block_state != I915_BUDDY_SPLIT) { - pr_err("block state mismatch\n"); - err = -EINVAL; - } - - block_size = i915_buddy_block_size(mm, block); - offset = i915_buddy_block_offset(block); - - if (block_size < mm->chunk_size) { - pr_err("block size smaller than min size\n"); - err = -EINVAL; - } - - if (!is_power_of_2(block_size)) { - pr_err("block size not power of two\n"); - err = -EINVAL; - } - - if (!IS_ALIGNED(block_size, mm->chunk_size)) { - pr_err("block size not aligned to min size\n"); - err = -EINVAL; - } - - if (!IS_ALIGNED(offset, mm->chunk_size)) { - pr_err("block offset not aligned to min size\n"); - err = -EINVAL; - } - - if (!IS_ALIGNED(offset, block_size)) { - pr_err("block offset not aligned to block size\n"); - err = -EINVAL; - } - - buddy = get_buddy(block); - - if (!buddy && block->parent) { - pr_err("buddy has gone fishing\n"); - err = -EINVAL; - } - - if (buddy) { - if (i915_buddy_block_offset(buddy) != (offset ^ block_size)) { - pr_err("buddy has wrong offset\n"); - err = -EINVAL; - } - - if (i915_buddy_block_size(mm, buddy) != block_size) { - pr_err("buddy size mismatch\n"); - err = -EINVAL; - } - - if (i915_buddy_block_state(buddy) == block_state && - block_state == I915_BUDDY_FREE) { - pr_err("block and its buddy are free\n"); - err = -EINVAL; - } - } - - return err; -} - -static int igt_check_blocks(struct i915_buddy_mm *mm, - struct list_head *blocks, - u64 expected_size, - bool is_contiguous) -{ - struct i915_buddy_block *block; - struct i915_buddy_block *prev; - u64 total; - int err = 0; - - block = NULL; - prev = NULL; - total = 0; - - list_for_each_entry(block, blocks, link) { - err = igt_check_block(mm, block); - - if (!i915_buddy_block_is_allocated(block)) { - pr_err("block not allocated\n"), - err = -EINVAL; - } - - if (is_contiguous && prev) { - u64 prev_block_size; - u64 prev_offset; - u64 offset; - - prev_offset = i915_buddy_block_offset(prev); - prev_block_size = i915_buddy_block_size(mm, prev); - offset = i915_buddy_block_offset(block); - - if (offset != (prev_offset + prev_block_size)) { - pr_err("block offset mismatch\n"); - err = -EINVAL; - } - } - - if (err) - break; - - total += i915_buddy_block_size(mm, block); - prev = block; - } - - if (!err) { - if (total != expected_size) { - pr_err("size mismatch, expected=%llx, found=%llx\n", - expected_size, total); - err = -EINVAL; - } - return err; - } - - if (prev) { - pr_err("prev block, dump:\n"); - igt_dump_block(mm, prev); - } - - if (block) { - pr_err("bad block, dump:\n"); - igt_dump_block(mm, block); - } - - return err; -} - -static int igt_check_mm(struct i915_buddy_mm *mm) -{ - struct i915_buddy_block *root; - struct i915_buddy_block *prev; - unsigned int i; - u64 total; - int err = 0; - - if (!mm->n_roots) { - pr_err("n_roots is zero\n"); - return -EINVAL; - } - - if (mm->n_roots != hweight64(mm->size)) { - pr_err("n_roots mismatch, n_roots=%u, expected=%lu\n", - mm->n_roots, hweight64(mm->size)); - return -EINVAL; - } - - root = NULL; - prev = NULL; - total = 0; - - for (i = 0; i < mm->n_roots; ++i) { - struct i915_buddy_block *block; - unsigned int order; - - root = mm->roots[i]; - if (!root) { - pr_err("root(%u) is NULL\n", i); - err = -EINVAL; - break; - } - - err = igt_check_block(mm, root); - - if (!i915_buddy_block_is_free(root)) { - pr_err("root not free\n"); - err = -EINVAL; - } - - order = i915_buddy_block_order(root); - - if (!i) { - if (order != mm->max_order) { - pr_err("max order root missing\n"); - err = -EINVAL; - } - } - - if (prev) { - u64 prev_block_size; - u64 prev_offset; - u64 offset; - - prev_offset = i915_buddy_block_offset(prev); - prev_block_size = i915_buddy_block_size(mm, prev); - offset = i915_buddy_block_offset(root); - - if (offset != (prev_offset + prev_block_size)) { - pr_err("root offset mismatch\n"); - err = -EINVAL; - } - } - - block = list_first_entry_or_null(&mm->free_list[order], - struct i915_buddy_block, - link); - if (block != root) { - pr_err("root mismatch at order=%u\n", order); - err = -EINVAL; - } - - if (err) - break; - - prev = root; - total += i915_buddy_block_size(mm, root); - } - - if (!err) { - if (total != mm->size) { - pr_err("expected mm size=%llx, found=%llx\n", mm->size, - total); - err = -EINVAL; - } - return err; - } - - if (prev) { - pr_err("prev root(%u), dump:\n", i - 1); - igt_dump_block(mm, prev); - } - - if (root) { - pr_err("bad root(%u), dump:\n", i); - igt_dump_block(mm, root); - } - - return err; -} - -static void igt_mm_config(u64 *size, u64 *chunk_size) -{ - I915_RND_STATE(prng); - u32 s, ms; - - /* Nothing fancy, just try to get an interesting bit pattern */ - - prandom_seed_state(&prng, i915_selftest.random_seed); - - /* Let size be a random number of pages up to 8 GB (2M pages) */ - s = 1 + i915_prandom_u32_max_state((BIT(33 - 12)) - 1, &prng); - /* Let the chunk size be a random power of 2 less than size */ - ms = BIT(i915_prandom_u32_max_state(ilog2(s), &prng)); - /* Round size down to the chunk size */ - s &= -ms; - - /* Convert from pages to bytes */ - *chunk_size = (u64)ms << 12; - *size = (u64)s << 12; -} - -static int igt_buddy_alloc_smoke(void *arg) -{ - struct i915_buddy_mm mm; - IGT_TIMEOUT(end_time); - I915_RND_STATE(prng); - u64 chunk_size; - u64 mm_size; - int *order; - int err, i; - - igt_mm_config(&mm_size, &chunk_size); - - pr_info("buddy_init with size=%llx, chunk_size=%llx\n", mm_size, chunk_size); - - err = i915_buddy_init(&mm, mm_size, chunk_size); - if (err) { - pr_err("buddy_init failed(%d)\n", err); - return err; - } - - order = i915_random_order(mm.max_order + 1, &prng); - if (!order) - goto out_fini; - - for (i = 0; i <= mm.max_order; ++i) { - struct i915_buddy_block *block; - int max_order = order[i]; - bool timeout = false; - LIST_HEAD(blocks); - int order; - u64 total; - - err = igt_check_mm(&mm); - if (err) { - pr_err("pre-mm check failed, abort\n"); - break; - } - - pr_info("filling from max_order=%u\n", max_order); - - order = max_order; - total = 0; - - do { -retry: - block = i915_buddy_alloc(&mm, order); - if (IS_ERR(block)) { - err = PTR_ERR(block); - if (err == -ENOMEM) { - pr_info("buddy_alloc hit -ENOMEM with order=%d\n", - order); - } else { - if (order--) { - err = 0; - goto retry; - } - - pr_err("buddy_alloc with order=%d failed(%d)\n", - order, err); - } - - break; - } - - list_add_tail(&block->link, &blocks); - - if (i915_buddy_block_order(block) != order) { - pr_err("buddy_alloc order mismatch\n"); - err = -EINVAL; - break; - } - - total += i915_buddy_block_size(&mm, block); - - if (__igt_timeout(end_time, NULL)) { - timeout = true; - break; - } - } while (total < mm.size); - - if (!err) - err = igt_check_blocks(&mm, &blocks, total, false); - - i915_buddy_free_list(&mm, &blocks); - - if (!err) { - err = igt_check_mm(&mm); - if (err) - pr_err("post-mm check failed\n"); - } - - if (err || timeout) - break; - - cond_resched(); - } - - if (err == -ENOMEM) - err = 0; - - kfree(order); -out_fini: - i915_buddy_fini(&mm); - - return err; -} - -static int igt_buddy_alloc_pessimistic(void *arg) -{ - const unsigned int max_order = 16; - struct i915_buddy_block *block, *bn; - struct i915_buddy_mm mm; - unsigned int order; - LIST_HEAD(blocks); - int err; - - /* - * Create a pot-sized mm, then allocate one of each possible - * order within. This should leave the mm with exactly one - * page left. - */ - - err = i915_buddy_init(&mm, PAGE_SIZE << max_order, PAGE_SIZE); - if (err) { - pr_err("buddy_init failed(%d)\n", err); - return err; - } - GEM_BUG_ON(mm.max_order != max_order); - - for (order = 0; order < max_order; order++) { - block = i915_buddy_alloc(&mm, order); - if (IS_ERR(block)) { - pr_info("buddy_alloc hit -ENOMEM with order=%d\n", - order); - err = PTR_ERR(block); - goto err; - } - - list_add_tail(&block->link, &blocks); - } - - /* And now the last remaining block available */ - block = i915_buddy_alloc(&mm, 0); - if (IS_ERR(block)) { - pr_info("buddy_alloc hit -ENOMEM on final alloc\n"); - err = PTR_ERR(block); - goto err; - } - list_add_tail(&block->link, &blocks); - - /* Should be completely full! */ - for (order = max_order; order--; ) { - block = i915_buddy_alloc(&mm, order); - if (!IS_ERR(block)) { - pr_info("buddy_alloc unexpectedly succeeded at order %d, it should be full!", - order); - list_add_tail(&block->link, &blocks); - err = -EINVAL; - goto err; - } - } - - block = list_last_entry(&blocks, typeof(*block), link); - list_del(&block->link); - i915_buddy_free(&mm, block); - - /* As we free in increasing size, we make available larger blocks */ - order = 1; - list_for_each_entry_safe(block, bn, &blocks, link) { - list_del(&block->link); - i915_buddy_free(&mm, block); - - block = i915_buddy_alloc(&mm, order); - if (IS_ERR(block)) { - pr_info("buddy_alloc (realloc) hit -ENOMEM with order=%d\n", - order); - err = PTR_ERR(block); - goto err; - } - i915_buddy_free(&mm, block); - order++; - } - - /* To confirm, now the whole mm should be available */ - block = i915_buddy_alloc(&mm, max_order); - if (IS_ERR(block)) { - pr_info("buddy_alloc (realloc) hit -ENOMEM with order=%d\n", - max_order); - err = PTR_ERR(block); - goto err; - } - i915_buddy_free(&mm, block); - -err: - i915_buddy_free_list(&mm, &blocks); - i915_buddy_fini(&mm); - return err; -} - -static int igt_buddy_alloc_optimistic(void *arg) -{ - const int max_order = 16; - struct i915_buddy_block *block; - struct i915_buddy_mm mm; - LIST_HEAD(blocks); - int order; - int err; - - /* - * Create a mm with one block of each order available, and - * try to allocate them all. - */ - - err = i915_buddy_init(&mm, - PAGE_SIZE * ((1 << (max_order + 1)) - 1), - PAGE_SIZE); - if (err) { - pr_err("buddy_init failed(%d)\n", err); - return err; - } - GEM_BUG_ON(mm.max_order != max_order); - - for (order = 0; order <= max_order; order++) { - block = i915_buddy_alloc(&mm, order); - if (IS_ERR(block)) { - pr_info("buddy_alloc hit -ENOMEM with order=%d\n", - order); - err = PTR_ERR(block); - goto err; - } - - list_add_tail(&block->link, &blocks); - } - - /* Should be completely full! */ - block = i915_buddy_alloc(&mm, 0); - if (!IS_ERR(block)) { - pr_info("buddy_alloc unexpectedly succeeded, it should be full!"); - list_add_tail(&block->link, &blocks); - err = -EINVAL; - goto err; - } - -err: - i915_buddy_free_list(&mm, &blocks); - i915_buddy_fini(&mm); - return err; -} - -static int igt_buddy_alloc_pathological(void *arg) -{ - const int max_order = 16; - struct i915_buddy_block *block; - struct i915_buddy_mm mm; - LIST_HEAD(blocks); - LIST_HEAD(holes); - int order, top; - int err; - - /* - * Create a pot-sized mm, then allocate one of each possible - * order within. This should leave the mm with exactly one - * page left. Free the largest block, then whittle down again. - * Eventually we will have a fully 50% fragmented mm. - */ - - err = i915_buddy_init(&mm, PAGE_SIZE << max_order, PAGE_SIZE); - if (err) { - pr_err("buddy_init failed(%d)\n", err); - return err; - } - GEM_BUG_ON(mm.max_order != max_order); - - for (top = max_order; top; top--) { - /* Make room by freeing the largest allocated block */ - block = list_first_entry_or_null(&blocks, typeof(*block), link); - if (block) { - list_del(&block->link); - i915_buddy_free(&mm, block); - } - - for (order = top; order--; ) { - block = i915_buddy_alloc(&mm, order); - if (IS_ERR(block)) { - pr_info("buddy_alloc hit -ENOMEM with order=%d, top=%d\n", - order, top); - err = PTR_ERR(block); - goto err; - } - list_add_tail(&block->link, &blocks); - } - - /* There should be one final page for this sub-allocation */ - block = i915_buddy_alloc(&mm, 0); - if (IS_ERR(block)) { - pr_info("buddy_alloc hit -ENOMEM for hole\n"); - err = PTR_ERR(block); - goto err; - } - list_add_tail(&block->link, &holes); - - block = i915_buddy_alloc(&mm, top); - if (!IS_ERR(block)) { - pr_info("buddy_alloc unexpectedly succeeded at top-order %d/%d, it should be full!", - top, max_order); - list_add_tail(&block->link, &blocks); - err = -EINVAL; - goto err; - } - } - - i915_buddy_free_list(&mm, &holes); - - /* Nothing larger than blocks of chunk_size now available */ - for (order = 1; order <= max_order; order++) { - block = i915_buddy_alloc(&mm, order); - if (!IS_ERR(block)) { - pr_info("buddy_alloc unexpectedly succeeded at order %d, it should be full!", - order); - list_add_tail(&block->link, &blocks); - err = -EINVAL; - goto err; - } - } - -err: - list_splice_tail(&holes, &blocks); - i915_buddy_free_list(&mm, &blocks); - i915_buddy_fini(&mm); - return err; -} - -static int igt_buddy_alloc_range(void *arg) -{ - struct i915_buddy_mm mm; - unsigned long page_num; - LIST_HEAD(blocks); - u64 chunk_size; - u64 offset; - u64 size; - u64 rem; - int err; - - igt_mm_config(&size, &chunk_size); - - pr_info("buddy_init with size=%llx, chunk_size=%llx\n", size, chunk_size); - - err = i915_buddy_init(&mm, size, chunk_size); - if (err) { - pr_err("buddy_init failed(%d)\n", err); - return err; - } - - err = igt_check_mm(&mm); - if (err) { - pr_err("pre-mm check failed, abort, abort, abort!\n"); - goto err_fini; - } - - rem = mm.size; - offset = 0; - - for_each_prime_number_from(page_num, 1, ULONG_MAX - 1) { - struct i915_buddy_block *block; - LIST_HEAD(tmp); - - size = min(page_num * mm.chunk_size, rem); - - err = i915_buddy_alloc_range(&mm, &tmp, offset, size); - if (err) { - if (err == -ENOMEM) { - pr_info("alloc_range hit -ENOMEM with size=%llx\n", - size); - } else { - pr_err("alloc_range with offset=%llx, size=%llx failed(%d)\n", - offset, size, err); - } - - break; - } - - block = list_first_entry_or_null(&tmp, - struct i915_buddy_block, - link); - if (!block) { - pr_err("alloc_range has no blocks\n"); - err = -EINVAL; - break; - } - - if (i915_buddy_block_offset(block) != offset) { - pr_err("alloc_range start offset mismatch, found=%llx, expected=%llx\n", - i915_buddy_block_offset(block), offset); - err = -EINVAL; - } - - if (!err) - err = igt_check_blocks(&mm, &tmp, size, true); - - list_splice_tail(&tmp, &blocks); - - if (err) - break; - - offset += size; - - rem -= size; - if (!rem) - break; - - cond_resched(); - } - - if (err == -ENOMEM) - err = 0; - - i915_buddy_free_list(&mm, &blocks); - - if (!err) { - err = igt_check_mm(&mm); - if (err) - pr_err("post-mm check failed\n"); - } - -err_fini: - i915_buddy_fini(&mm); - - return err; -} - -static int igt_buddy_alloc_limit(void *arg) -{ - struct i915_buddy_block *block; - struct i915_buddy_mm mm; - const u64 size = U64_MAX; - int err; - - err = i915_buddy_init(&mm, size, PAGE_SIZE); - if (err) - return err; - - if (mm.max_order != I915_BUDDY_MAX_ORDER) { - pr_err("mm.max_order(%d) != %d\n", - mm.max_order, I915_BUDDY_MAX_ORDER); - err = -EINVAL; - goto out_fini; - } - - block = i915_buddy_alloc(&mm, mm.max_order); - if (IS_ERR(block)) { - err = PTR_ERR(block); - goto out_fini; - } - - if (i915_buddy_block_order(block) != mm.max_order) { - pr_err("block order(%d) != %d\n", - i915_buddy_block_order(block), mm.max_order); - err = -EINVAL; - goto out_free; - } - - if (i915_buddy_block_size(&mm, block) != - BIT_ULL(mm.max_order) * PAGE_SIZE) { - pr_err("block size(%llu) != %llu\n", - i915_buddy_block_size(&mm, block), - BIT_ULL(mm.max_order) * PAGE_SIZE); - err = -EINVAL; - goto out_free; - } - -out_free: - i915_buddy_free(&mm, block); -out_fini: - i915_buddy_fini(&mm); - return err; -} - -int i915_buddy_mock_selftests(void) -{ - static const struct i915_subtest tests[] = { - SUBTEST(igt_buddy_alloc_pessimistic), - SUBTEST(igt_buddy_alloc_optimistic), - SUBTEST(igt_buddy_alloc_pathological), - SUBTEST(igt_buddy_alloc_smoke), - SUBTEST(igt_buddy_alloc_range), - SUBTEST(igt_buddy_alloc_limit), - }; - - return i915_subtests(tests, NULL); -} diff --git a/drivers/gpu/drm/i915/selftests/i915_mock_selftests.h b/drivers/gpu/drm/i915/selftests/i915_mock_selftests.h index 3db34d3eea58..34e5caf38093 100644 --- a/drivers/gpu/drm/i915/selftests/i915_mock_selftests.h +++ b/drivers/gpu/drm/i915/selftests/i915_mock_selftests.h @@ -33,5 +33,4 @@ selftest(evict, i915_gem_evict_mock_selftests) selftest(gtt, i915_gem_gtt_mock_selftests) selftest(hugepages, i915_gem_huge_page_mock_selftests) selftest(contexts, i915_gem_context_mock_selftests) -selftest(buddy, i915_buddy_mock_selftests) selftest(memory_region, intel_memory_region_mock_selftests) diff --git a/drivers/gpu/drm/i915/selftests/intel_memory_region.c b/drivers/gpu/drm/i915/selftests/intel_memory_region.c index f85fd8cbfbf5..c85d516b85cd 100644 --- a/drivers/gpu/drm/i915/selftests/intel_memory_region.c +++ b/drivers/gpu/drm/i915/selftests/intel_memory_region.c @@ -57,9 +57,10 @@ static int igt_mock_fill(void *arg) LIST_HEAD(objects); int err = 0; - page_size = mem->mm.chunk_size; - max_pages = div64_u64(total, page_size); + page_size = mem->chunk_size; rem = total; +retry: + max_pages = div64_u64(rem, page_size); for_each_prime_number_from(page_num, 1, max_pages) { resource_size_t size = page_num * page_size; @@ -85,6 +86,11 @@ static int igt_mock_fill(void *arg) err = 0; if (err == -ENXIO) { if (page_num * page_size <= rem) { + if (mem->is_range_manager && max_pages > 1) { + max_pages >>= 1; + goto retry; + } + pr_err("%s failed, space still left in region\n", __func__); err = -EINVAL; @@ -199,12 +205,18 @@ static int igt_mock_reserve(void *arg) do { u32 size = i915_prandom_u32_max_state(cur_avail, &prng); +retry: size = max_t(u32, round_up(size, PAGE_SIZE), PAGE_SIZE); obj = igt_object_create(mem, &objects, size, 0); if (IS_ERR(obj)) { - if (PTR_ERR(obj) == -ENXIO) + if (PTR_ERR(obj) == -ENXIO) { + if (mem->is_range_manager && + size > mem->chunk_size) { + size >>= 1; + goto retry; + } break; - + } err = PTR_ERR(obj); goto out_close; } @@ -220,7 +232,7 @@ static int igt_mock_reserve(void *arg) out_close: kfree(order); close_objects(mem, &objects); - i915_buddy_free_list(&mem->mm, &mem->reserved); + intel_memory_region_unreserve(mem); return err; } @@ -240,7 +252,7 @@ static int igt_mock_contiguous(void *arg) total = resource_size(&mem->region); /* Min size */ - obj = igt_object_create(mem, &objects, mem->mm.chunk_size, + obj = igt_object_create(mem, &objects, mem->chunk_size, I915_BO_ALLOC_CONTIGUOUS); if (IS_ERR(obj)) return PTR_ERR(obj); @@ -321,14 +333,16 @@ static int igt_mock_contiguous(void *arg) min = target; target = total >> 1; - /* Make sure we can still allocate all the fragmented space */ - obj = igt_object_create(mem, &objects, target, 0); - if (IS_ERR(obj)) { - err = PTR_ERR(obj); - goto err_close_objects; - } + if (!mem->is_range_manager) { + /* Make sure we can still allocate all the fragmented space */ + obj = igt_object_create(mem, &objects, target, 0); + if (IS_ERR(obj)) { + err = PTR_ERR(obj); + goto err_close_objects; + } - igt_object_release(obj); + igt_object_release(obj); + } /* * Even though we have enough free space, we don't have a big enough @@ -348,7 +362,7 @@ static int igt_mock_contiguous(void *arg) } target >>= 1; - } while (target >= mem->mm.chunk_size); + } while (target >= mem->chunk_size); err_close_objects: list_splice_tail(&holes, &objects); @@ -368,7 +382,7 @@ static int igt_mock_splintered_region(void *arg) /* * Sanity check we can still allocate everything even if the - * mm.max_order != mm.size. i.e our starting address space size is not a + * max_order != mm.size. i.e our starting address space size is not a * power-of-two. */ @@ -377,17 +391,10 @@ static int igt_mock_splintered_region(void *arg) if (IS_ERR(mem)) return PTR_ERR(mem); - if (mem->mm.size != size) { - pr_err("%s size mismatch(%llu != %llu)\n", - __func__, mem->mm.size, size); - err = -EINVAL; - goto out_put; - } - expected_order = get_order(rounddown_pow_of_two(size)); - if (mem->mm.max_order != expected_order) { + if (mem->max_order != expected_order) { pr_err("%s order mismatch(%u != %u)\n", - __func__, mem->mm.max_order, expected_order); + __func__, mem->max_order, expected_order); err = -EINVAL; goto out_put; } @@ -408,12 +415,15 @@ static int igt_mock_splintered_region(void *arg) * sure that does indeed hold true. */ - obj = igt_object_create(mem, &objects, size, I915_BO_ALLOC_CONTIGUOUS); - if (!IS_ERR(obj)) { - pr_err("%s too large contiguous allocation was not rejected\n", - __func__); - err = -EINVAL; - goto out_close; + if (!mem->is_range_manager) { + obj = igt_object_create(mem, &objects, size, + I915_BO_ALLOC_CONTIGUOUS); + if (!IS_ERR(obj)) { + pr_err("%s too large contiguous allocation was not rejected\n", + __func__); + err = -EINVAL; + goto out_close; + } } obj = igt_object_create(mem, &objects, rounddown_pow_of_two(size), @@ -432,68 +442,6 @@ static int igt_mock_splintered_region(void *arg) return err; } -#ifndef SZ_8G -#define SZ_8G BIT_ULL(33) -#endif - -static int igt_mock_max_segment(void *arg) -{ - const unsigned int max_segment = i915_sg_segment_size(); - struct intel_memory_region *mem = arg; - struct drm_i915_private *i915 = mem->i915; - struct drm_i915_gem_object *obj; - struct i915_buddy_block *block; - struct scatterlist *sg; - LIST_HEAD(objects); - u64 size; - int err = 0; - - /* - * While we may create very large contiguous blocks, we may need - * to break those down for consumption elsewhere. In particular, - * dma-mapping with scatterlist elements have an implicit limit of - * UINT_MAX on each element. - */ - - size = SZ_8G; - mem = mock_region_create(i915, 0, size, PAGE_SIZE, 0); - if (IS_ERR(mem)) - return PTR_ERR(mem); - - obj = igt_object_create(mem, &objects, size, 0); - if (IS_ERR(obj)) { - err = PTR_ERR(obj); - goto out_put; - } - - size = 0; - list_for_each_entry(block, &obj->mm.blocks, link) { - if (i915_buddy_block_size(&mem->mm, block) > size) - size = i915_buddy_block_size(&mem->mm, block); - } - if (size < max_segment) { - pr_err("%s: Failed to create a huge contiguous block [> %u], largest block %lld\n", - __func__, max_segment, size); - err = -EINVAL; - goto out_close; - } - - for (sg = obj->mm.pages->sgl; sg; sg = sg_next(sg)) { - if (sg->length > max_segment) { - pr_err("%s: Created an oversized scatterlist entry, %u > %u\n", - __func__, sg->length, max_segment); - err = -EINVAL; - goto out_close; - } - } - -out_close: - close_objects(mem, &objects); -out_put: - intel_memory_region_put(mem); - return err; -} - static int igt_gpu_write_dw(struct intel_context *ce, struct i915_vma *vma, u32 dword, @@ -1098,7 +1046,6 @@ int intel_memory_region_mock_selftests(void) SUBTEST(igt_mock_fill), SUBTEST(igt_mock_contiguous), SUBTEST(igt_mock_splintered_region), - SUBTEST(igt_mock_max_segment), }; struct intel_memory_region *mem; struct drm_i915_private *i915; diff --git a/drivers/gpu/drm/i915/selftests/mock_region.c b/drivers/gpu/drm/i915/selftests/mock_region.c index 5d2d010a1e22..8a217a592ec6 100644 --- a/drivers/gpu/drm/i915/selftests/mock_region.c +++ b/drivers/gpu/drm/i915/selftests/mock_region.c @@ -1,17 +1,52 @@ // SPDX-License-Identifier: MIT /* - * Copyright © 2019 Intel Corporation + * Copyright © 2019-2021 Intel Corporation */ +#include + #include "gem/i915_gem_region.h" #include "intel_memory_region.h" +#include "intel_region_ttm.h" #include "mock_region.h" +static void mock_region_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); + sg_free_table(pages); + kfree(pages); +} + +static int mock_region_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); + + pages = intel_region_ttm_node_to_st(obj->mm.region, obj->mm.st_mm_node); + if (IS_ERR(pages)) + return PTR_ERR(pages); + + __i915_gem_object_set_pages(obj, pages, i915_sg_dma_sizes(pages->sgl)); + + return 0; +} + static const struct drm_i915_gem_object_ops mock_region_obj_ops = { .name = "mock-region", - .get_pages = i915_gem_object_get_pages_buddy, - .put_pages = i915_gem_object_put_pages_buddy, + .get_pages = mock_region_get_pages, + .put_pages = mock_region_put_pages, .release = i915_gem_object_release_memory_region, }; @@ -23,7 +58,7 @@ static int mock_object_init(struct intel_memory_region *mem, static struct lock_class_key lock_class; struct drm_i915_private *i915 = mem->i915; - if (size > mem->mm.size) + if (size > resource_size(&mem->region)) return -E2BIG; drm_gem_private_object_init(&i915->drm, &obj->base, size); @@ -39,8 +74,8 @@ static int mock_object_init(struct intel_memory_region *mem, } static const struct intel_memory_region_ops mock_region_ops = { - .init = intel_memory_region_init_buddy, - .release = intel_memory_region_release_buddy, + .init = intel_region_ttm_init, + .release = intel_region_ttm_fini, .init_object = mock_object_init, }; @@ -52,5 +87,6 @@ mock_region_create(struct drm_i915_private *i915, resource_size_t io_start) { return intel_memory_region_create(i915, start, size, min_page_size, - io_start, &mock_region_ops); + io_start, INTEL_MEMORY_MOCK, 0, + &mock_region_ops); } -- 2.31.1