From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org X-Spam-Level: X-Spam-Status: No, score=-16.8 required=3.0 tests=BAYES_00, HEADER_FROM_DIFFERENT_DOMAINS,INCLUDES_CR_TRAILER,INCLUDES_PATCH, MAILING_LIST_MULTI,SPF_HELO_NONE,SPF_PASS,URIBL_BLOCKED,USER_AGENT_GIT autolearn=ham autolearn_force=no version=3.4.0 Received: from mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id 7CCA7C47082 for ; Tue, 8 Jun 2021 08:45:16 +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 49F4B6124B for ; Tue, 8 Jun 2021 08:45:16 +0000 (UTC) DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org 49F4B6124B Authentication-Results: mail.kernel.org; dmarc=fail (p=none dis=none) header.from=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 984FE6EB3C; Tue, 8 Jun 2021 08:45:15 +0000 (UTC) Received: from mga04.intel.com (mga04.intel.com [192.55.52.120]) by gabe.freedesktop.org (Postfix) with ESMTPS id 1E6B96EB3C; Tue, 8 Jun 2021 08:45:14 +0000 (UTC) IronPort-SDR: w/4OHnyu2y0vMkVnO1RDfCkheBMTRbCqeCFQEd+2dctQp8QsD80yqyqAK5E5jjLN9vx+3u6oDu F1lvxdhK84Jg== X-IronPort-AV: E=McAfee;i="6200,9189,10008"; a="202943843" X-IronPort-AV: E=Sophos;i="5.83,257,1616482800"; d="scan'208";a="202943843" Received: from orsmga007.jf.intel.com ([10.7.209.58]) by fmsmga104.fm.intel.com with ESMTP/TLS/ECDHE-RSA-AES256-GCM-SHA384; 08 Jun 2021 01:45:13 -0700 IronPort-SDR: pDefVqBFfu8RQtDeywTZm0PGKY6giZSrsFTMkgmW8R8edzKN988cDt+5OVey6OAacf0sYO9syN 4lEvqxQHYPgQ== X-IronPort-AV: E=Sophos;i="5.83,257,1616482800"; d="scan'208";a="440382092" Received: from mrahim1x-mobl.gar.corp.intel.com (HELO mwauld-desk1.intel.com) ([10.215.170.251]) by orsmga007-auth.jf.intel.com with ESMTP/TLS/ECDHE-RSA-AES256-GCM-SHA384; 08 Jun 2021 01:45:10 -0700 From: Matthew Auld To: intel-gfx@lists.freedesktop.org Date: Tue, 8 Jun 2021 09:44:27 +0100 Message-Id: <20210608084428.142676-6-matthew.auld@intel.com> X-Mailer: git-send-email 2.26.3 In-Reply-To: <20210608084428.142676-1-matthew.auld@intel.com> References: <20210608084428.142676-1-matthew.auld@intel.com> MIME-Version: 1.0 Subject: [Intel-gfx] [PATCH v2 5/6] drm/i915/ttm: switch over to ttm_buddy_man 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?= , dri-devel@lists.freedesktop.org Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Errors-To: intel-gfx-bounces@lists.freedesktop.org Sender: "Intel-gfx" TW92ZSBiYWNrIHRvIHRoZSBidWRkeSBhbGxvY2F0b3IgZm9yIG1hbmFnaW5nIGRldmljZSBsb2Nh bCBtZW1vcnksIGFuZApyZXN0b3JlIHRoZSBsb3N0IG1vY2sgc2VsZnRlc3RzLiBLZWVwIGFyb3Vu ZCB0aGUgcmFuZ2UgbWFuYWdlciByZWxhdGVkCmJpdHMsIHNpbmNlIHdlIGxpa2VseSBuZWVkIHRo aXMgZm9yIG1hbmFnaW5nIHN0b2xlbiBhdCBzb21lIHBvaW50LiBGb3IKc3RvbGVuIHdlIGFsc28g ZG9uJ3QgbmVlZCB0byByZXNlcnZlIGFueXRoaW5nIHNvIG5vIG5lZWQgdG8gc3VwcG9ydCBhCmdl bmVyaWMgcmVzZXJ2ZSBpbnRlcmZhY2UuCgp2MihUaG9tYXMpOgogICAgLSBiby0+cGFnZV9hbGln bm1lbnQgaXMgaW4gcGFnZSB1bml0cywgbm90IGJ5dGVzCgpTaWduZWQtb2ZmLWJ5OiBNYXR0aGV3 IEF1bGQgPG1hdHRoZXcuYXVsZEBpbnRlbC5jb20+CkNjOiBUaG9tYXMgSGVsbHN0csO2bSA8dGhv bWFzLmhlbGxzdHJvbUBsaW51eC5pbnRlbC5jb20+ClJldmlld2VkLWJ5OiBUaG9tYXMgSGVsbHN0 csO2bSA8dGhvbWFzLmhlbGxzdHJvbUBsaW51eC5pbnRlbC5jb20+Ci0tLQogZHJpdmVycy9ncHUv ZHJtL2k5MTUvZ2VtL2k5MTVfZ2VtX3R0bS5jICAgICAgIHwgIDI2ICstLQogZHJpdmVycy9ncHUv ZHJtL2k5MTUvaW50ZWxfbWVtb3J5X3JlZ2lvbi5jICAgIHwgIDU1ICstLS0tLQogZHJpdmVycy9n cHUvZHJtL2k5MTUvaW50ZWxfbWVtb3J5X3JlZ2lvbi5oICAgIHwgIDE3IC0tCiBkcml2ZXJzL2dw dS9kcm0vaTkxNS9pbnRlbF9yZWdpb25fdHRtLmMgICAgICAgfCAxMDAgKysrLS0tLS0tLS0KIC4u Li9kcm0vaTkxNS9zZWxmdGVzdHMvaW50ZWxfbWVtb3J5X3JlZ2lvbi5jICB8IDE3MCArKysrKysr KysrKystLS0tLS0KIGRyaXZlcnMvZ3B1L2RybS9pOTE1L3NlbGZ0ZXN0cy9tb2NrX3JlZ2lvbi5j ICB8ICAxNSArLQogNiBmaWxlcyBjaGFuZ2VkLCAxNjggaW5zZXJ0aW9ucygrKSwgMjE1IGRlbGV0 aW9ucygtKQoKZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2dlbS9pOTE1X2dlbV90 dG0uYyBiL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2dlbS9pOTE1X2dlbV90dG0uYwppbmRleCBjNjEy Mjc1YzM2YzkuLjViZjFkMTk0NWRkNiAxMDA2NDQKLS0tIGEvZHJpdmVycy9ncHUvZHJtL2k5MTUv Z2VtL2k5MTVfZ2VtX3R0bS5jCisrKyBiL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2dlbS9pOTE1X2dl bV90dG0uYwpAQCAtMTgxLDExICsxODEsNyBAQCBzdGF0aWMgYm9vbCBpOTE1X3R0bV9ldmljdGlv bl92YWx1YWJsZShzdHJ1Y3QgdHRtX2J1ZmZlcl9vYmplY3QgKmJvLAogCXN0cnVjdCBkcm1faTkx NV9nZW1fb2JqZWN0ICpvYmogPSBpOTE1X3R0bV90b19nZW0oYm8pOwogCiAJLyogV2lsbCBkbyBm b3Igbm93LiBPdXIgcGlubmVkIG9iamVjdHMgYXJlIHN0aWxsIG9uIFRUTSdzIExSVSBsaXN0cyAq LwotCWlmICghaTkxNV9nZW1fb2JqZWN0X2V2aWN0YWJsZShvYmopKQotCQlyZXR1cm4gZmFsc2U7 Ci0KLQkvKiBUaGlzIGlzbid0IHZhbGlkIHdpdGggYSBidWRkeSBhbGxvY2F0b3IgKi8KLQlyZXR1 cm4gdHRtX2JvX2V2aWN0aW9uX3ZhbHVhYmxlKGJvLCBwbGFjZSk7CisJcmV0dXJuIGk5MTVfZ2Vt X29iamVjdF9ldmljdGFibGUob2JqKTsKIH0KIAogc3RhdGljIHZvaWQgaTkxNV90dG1fZXZpY3Rf ZmxhZ3Moc3RydWN0IHR0bV9idWZmZXJfb2JqZWN0ICpibywKQEAgLTMyOCwxMSArMzI0LDE1IEBA IGk5MTVfdHRtX3Jlc291cmNlX2dldF9zdChzdHJ1Y3QgZHJtX2k5MTVfZ2VtX29iamVjdCAqb2Jq LAogCXN0cnVjdCB0dG1fYnVmZmVyX29iamVjdCAqYm8gPSBpOTE1X2dlbV90b190dG0ob2JqKTsK IAlzdHJ1Y3QgdHRtX3Jlc291cmNlX21hbmFnZXIgKm1hbiA9CiAJCXR0bV9tYW5hZ2VyX3R5cGUo Ym8tPmJkZXYsIHJlcy0+bWVtX3R5cGUpOworCXN0cnVjdCBpbnRlbF9tZW1vcnlfcmVnaW9uICpt ciA9IG9iai0+bW0ucmVnaW9uOwogCiAJaWYgKG1hbi0+dXNlX3R0KQogCQlyZXR1cm4gaTkxNV90 dG1fdHRfZ2V0X3N0KGJvLT50dG0pOwogCi0JcmV0dXJuIGludGVsX3JlZ2lvbl90dG1fbm9kZV90 b19zdChvYmotPm1tLnJlZ2lvbiwgcmVzLT5tbV9ub2RlKTsKKwlpZiAobXItPmlzX3JhbmdlX21h bmFnZXIpCisJCXJldHVybiBpbnRlbF9yZWdpb25fdHRtX25vZGVfdG9fc3QobXIsIHJlcyk7CisJ ZWxzZQorCQlyZXR1cm4gaTkxNV9zZ19mcm9tX2J1ZGR5X3Jlc291cmNlKHJlcywgbXItPnJlZ2lv bi5zdGFydCk7CiB9CiAKIHN0YXRpYyBpbnQgaTkxNV90dG1fbW92ZShzdHJ1Y3QgdHRtX2J1ZmZl cl9vYmplY3QgKmJvLCBib29sIGV2aWN0LApAQCAtNjU3LDIwICs2NTcsOCBAQCBpbnQgX19pOTE1 X2dlbV90dG1fb2JqZWN0X2luaXQoc3RydWN0IGludGVsX21lbW9yeV9yZWdpb24gKm1lbSwKIAlz dGF0aWMgc3RydWN0IGxvY2tfY2xhc3Nfa2V5IGxvY2tfY2xhc3M7CiAJc3RydWN0IGRybV9pOTE1 X3ByaXZhdGUgKmk5MTUgPSBtZW0tPmk5MTU7CiAJZW51bSB0dG1fYm9fdHlwZSBib190eXBlOwot CXNpemVfdCBhbGlnbm1lbnQgPSAwOwogCWludCByZXQ7CiAKLQkvKiBBZGp1c3QgYWxpZ25tZW50 IHRvIEdQVS0gYW5kIENQVSBodWdlIHBhZ2Ugc2l6ZXMuICovCi0KLQlpZiAobWVtLT5pc19yYW5n ZV9tYW5hZ2VyKSB7Ci0JCWlmIChzaXplID49IFNaXzFHKQotCQkJYWxpZ25tZW50ID0gU1pfMUcg Pj4gUEFHRV9TSElGVDsKLQkJZWxzZSBpZiAoc2l6ZSA+PSBTWl8yTSkKLQkJCWFsaWdubWVudCA9 IFNaXzJNID4+IFBBR0VfU0hJRlQ7Ci0JCWVsc2UgaWYgKHNpemUgPj0gU1pfNjRLKQotCQkJYWxp Z25tZW50ID0gU1pfNjRLID4+IFBBR0VfU0hJRlQ7Ci0JfQotCiAJZHJtX2dlbV9wcml2YXRlX29i amVjdF9pbml0KCZpOTE1LT5kcm0sICZvYmotPmJhc2UsIHNpemUpOwogCWk5MTVfZ2VtX29iamVj dF9pbml0KG9iaiwgJmk5MTVfZ2VtX3R0bV9vYmpfb3BzLCAmbG9ja19jbGFzcywgZmxhZ3MpOwog CWk5MTVfZ2VtX29iamVjdF9pbml0X21lbW9yeV9yZWdpb24ob2JqLCBtZW0pOwpAQCAtNjkyLDcg KzY4MCw3IEBAIGludCBfX2k5MTVfZ2VtX3R0bV9vYmplY3RfaW5pdChzdHJ1Y3QgaW50ZWxfbWVt b3J5X3JlZ2lvbiAqbWVtLAogCSAqLwogCW9iai0+YmFzZS52bWFfbm9kZS5kcml2ZXJfcHJpdmF0 ZSA9IGk5MTVfZ2VtX3RvX3R0bShvYmopOwogCXJldCA9IHR0bV9ib19pbml0KCZpOTE1LT5iZGV2 LCBpOTE1X2dlbV90b190dG0ob2JqKSwgc2l6ZSwKLQkJCSAgYm9fdHlwZSwgJmk5MTVfc3lzX3Bs YWNlbWVudCwgYWxpZ25tZW50LAorCQkJICBib190eXBlLCAmaTkxNV9zeXNfcGxhY2VtZW50LCAx LAogCQkJICB0cnVlLCBOVUxMLCBOVUxMLCBpOTE1X3R0bV9ib19kZXN0cm95KTsKIAogCWlmICgh cmV0KQpkaWZmIC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJtL2k5MTUvaW50ZWxfbWVtb3J5X3JlZ2lv bi5jIGIvZHJpdmVycy9ncHUvZHJtL2k5MTUvaW50ZWxfbWVtb3J5X3JlZ2lvbi5jCmluZGV4IDEy ZmI1NDIzZmQ1ZS4uZGY1OWY4ODRkMzdjIDEwMDY0NAotLS0gYS9kcml2ZXJzL2dwdS9kcm0vaTkx NS9pbnRlbF9tZW1vcnlfcmVnaW9uLmMKKysrIGIvZHJpdmVycy9ncHUvZHJtL2k5MTUvaW50ZWxf bWVtb3J5X3JlZ2lvbi5jCkBAIC01LDYgKzUsNyBAQAogCiAjaW5jbHVkZSAiaW50ZWxfbWVtb3J5 X3JlZ2lvbi5oIgogI2luY2x1ZGUgImk5MTVfZHJ2LmgiCisjaW5jbHVkZSAiaTkxNV90dG1fYnVk ZHlfbWFuYWdlci5oIgogCiBzdGF0aWMgY29uc3Qgc3RydWN0IHsKIAl1MTYgY2xhc3M7CkBAIC0y OCwxMSArMjksNiBAQCBzdGF0aWMgY29uc3Qgc3RydWN0IHsKIAl9LAogfTsKIAotc3RydWN0IGlu dGVsX3JlZ2lvbl9yZXNlcnZlIHsKLQlzdHJ1Y3QgbGlzdF9oZWFkIGxpbms7Ci0Jc3RydWN0IHR0 bV9yZXNvdXJjZSAqcmVzOwotfTsKLQogc3RydWN0IGludGVsX21lbW9yeV9yZWdpb24gKgogaW50 ZWxfbWVtb3J5X3JlZ2lvbl9sb29rdXAoc3RydWN0IGRybV9pOTE1X3ByaXZhdGUgKmk5MTUsCiAJ CQkgICB1MTYgY2xhc3MsIHUxNiBpbnN0YW5jZSkKQEAgLTYzLDI3ICs1OSw2IEBAIGludGVsX21l bW9yeV9yZWdpb25fYnlfdHlwZShzdHJ1Y3QgZHJtX2k5MTVfcHJpdmF0ZSAqaTkxNSwKIAlyZXR1 cm4gTlVMTDsKIH0KIAotLyoqCi0gKiBpbnRlbF9tZW1vcnlfcmVnaW9uX3VucmVzZXJ2ZSAtIFVu cmVzZXJ2ZSBhbGwgcHJldmlvdXNseSByZXNlcnZlZAotICogcmFuZ2VzCi0gKiBAbWVtOiBUaGUg cmVnaW9uIGNvbnRhaW5pbmcgdGhlIHJlc2VydmVkIHJhbmdlcy4KLSAqLwotdm9pZCBpbnRlbF9t ZW1vcnlfcmVnaW9uX3VucmVzZXJ2ZShzdHJ1Y3QgaW50ZWxfbWVtb3J5X3JlZ2lvbiAqbWVtKQot ewotCXN0cnVjdCBpbnRlbF9yZWdpb25fcmVzZXJ2ZSAqcmVzZXJ2ZSwgKm5leHQ7Ci0KLQlpZiAo IW1lbS0+cHJpdl9vcHMgfHwgIW1lbS0+cHJpdl9vcHMtPmZyZWUpCi0JCXJldHVybjsKLQotCW11 dGV4X2xvY2soJm1lbS0+bW1fbG9jayk7Ci0JbGlzdF9mb3JfZWFjaF9lbnRyeV9zYWZlKHJlc2Vy dmUsIG5leHQsICZtZW0tPnJlc2VydmVkLCBsaW5rKSB7Ci0JCWxpc3RfZGVsKCZyZXNlcnZlLT5s aW5rKTsKLQkJbWVtLT5wcml2X29wcy0+ZnJlZShtZW0sIHJlc2VydmUtPnJlcyk7Ci0JCWtmcmVl KHJlc2VydmUpOwotCX0KLQltdXRleF91bmxvY2soJm1lbS0+bW1fbG9jayk7Ci19Ci0KIC8qKgog ICogaW50ZWxfbWVtb3J5X3JlZ2lvbl9yZXNlcnZlIC0gUmVzZXJ2ZSBhIG1lbW9yeSByYW5nZQog ICogQG1lbTogVGhlIHJlZ2lvbiBmb3Igd2hpY2ggd2Ugd2FudCB0byByZXNlcnZlIGEgcmFuZ2Uu CkBAIC05NiwyOCArNzEsMTEgQEAgaW50IGludGVsX21lbW9yeV9yZWdpb25fcmVzZXJ2ZShzdHJ1 Y3QgaW50ZWxfbWVtb3J5X3JlZ2lvbiAqbWVtLAogCQkJCXJlc291cmNlX3NpemVfdCBvZmZzZXQs CiAJCQkJcmVzb3VyY2Vfc2l6ZV90IHNpemUpCiB7Ci0JaW50IHJldDsKLQlzdHJ1Y3QgaW50ZWxf cmVnaW9uX3Jlc2VydmUgKnJlc2VydmU7Ci0KLQlpZiAoIW1lbS0+cHJpdl9vcHMgfHwgIW1lbS0+ cHJpdl9vcHMtPnJlc2VydmUpCi0JCXJldHVybiAtRUlOVkFMOwotCi0JcmVzZXJ2ZSA9IGt6YWxs b2Moc2l6ZW9mKCpyZXNlcnZlKSwgR0ZQX0tFUk5FTCk7Ci0JaWYgKCFyZXNlcnZlKQotCQlyZXR1 cm4gLUVOT01FTTsKKwlzdHJ1Y3QgdHRtX3Jlc291cmNlX21hbmFnZXIgKm1hbiA9IG1lbS0+cmVn aW9uX3ByaXZhdGU7CiAKLQlyZXNlcnZlLT5yZXMgPSBtZW0tPnByaXZfb3BzLT5yZXNlcnZlKG1l bSwgb2Zmc2V0LCBzaXplKTsKLQlpZiAoSVNfRVJSKHJlc2VydmUtPnJlcykpIHsKLQkJcmV0ID0g UFRSX0VSUihyZXNlcnZlLT5yZXMpOwotCQlrZnJlZShyZXNlcnZlKTsKLQkJcmV0dXJuIHJldDsK LQl9Ci0KLQltdXRleF9sb2NrKCZtZW0tPm1tX2xvY2spOwotCWxpc3RfYWRkX3RhaWwoJnJlc2Vy dmUtPmxpbmssICZtZW0tPnJlc2VydmVkKTsKLQltdXRleF91bmxvY2soJm1lbS0+bW1fbG9jayk7 CisJR0VNX0JVR19PTihtZW0tPmlzX3JhbmdlX21hbmFnZXIpOwogCi0JcmV0dXJuIDA7CisJcmV0 dXJuIGk5MTVfdHRtX2J1ZGR5X21hbl9yZXNlcnZlKG1hbiwgb2Zmc2V0LCBzaXplKTsKIH0KIAog c3RydWN0IGludGVsX21lbW9yeV9yZWdpb24gKgpAQCAtMTQ5LDkgKzEwNyw2IEBAIGludGVsX21l bW9yeV9yZWdpb25fY3JlYXRlKHN0cnVjdCBkcm1faTkxNV9wcml2YXRlICppOTE1LAogCiAJbXV0 ZXhfaW5pdCgmbWVtLT5vYmplY3RzLmxvY2spOwogCUlOSVRfTElTVF9IRUFEKCZtZW0tPm9iamVj dHMubGlzdCk7Ci0JSU5JVF9MSVNUX0hFQUQoJm1lbS0+cmVzZXJ2ZWQpOwotCi0JbXV0ZXhfaW5p dCgmbWVtLT5tbV9sb2NrKTsKIAogCWlmIChvcHMtPmluaXQpIHsKIAkJZXJyID0gb3BzLT5pbml0 KG1lbSk7CkBAIC0xODIsMTEgKzEzNyw5IEBAIHN0YXRpYyB2b2lkIF9faW50ZWxfbWVtb3J5X3Jl Z2lvbl9kZXN0cm95KHN0cnVjdCBrcmVmICprcmVmKQogCXN0cnVjdCBpbnRlbF9tZW1vcnlfcmVn aW9uICptZW0gPQogCQljb250YWluZXJfb2Yoa3JlZiwgdHlwZW9mKCptZW0pLCBrcmVmKTsKIAot CWludGVsX21lbW9yeV9yZWdpb25fdW5yZXNlcnZlKG1lbSk7CiAJaWYgKG1lbS0+b3BzLT5yZWxl YXNlKQogCQltZW0tPm9wcy0+cmVsZWFzZShtZW0pOwogCi0JbXV0ZXhfZGVzdHJveSgmbWVtLT5t bV9sb2NrKTsKIAltdXRleF9kZXN0cm95KCZtZW0tPm9iamVjdHMubG9jayk7CiAJa2ZyZWUobWVt KTsKIH0KZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2ludGVsX21lbW9yeV9yZWdp b24uaCBiL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2ludGVsX21lbW9yeV9yZWdpb24uaAppbmRleCBj N2U2MzVkNjJlMWEuLmIwNGZiMjI3MjZkOSAxMDA2NDQKLS0tIGEvZHJpdmVycy9ncHUvZHJtL2k5 MTUvaW50ZWxfbWVtb3J5X3JlZ2lvbi5oCisrKyBiL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2ludGVs X21lbW9yeV9yZWdpb24uaApAQCAtNTksMTkgKzU5LDEwIEBAIHN0cnVjdCBpbnRlbF9tZW1vcnlf cmVnaW9uX29wcyB7CiAJCQkgICB1bnNpZ25lZCBpbnQgZmxhZ3MpOwogfTsKIAotc3RydWN0IGlu dGVsX21lbW9yeV9yZWdpb25fcHJpdmF0ZV9vcHMgewotCXN0cnVjdCB0dG1fcmVzb3VyY2UgKigq cmVzZXJ2ZSkoc3RydWN0IGludGVsX21lbW9yeV9yZWdpb24gKm1lbSwKLQkJCQkJcmVzb3VyY2Vf c2l6ZV90IG9mZnNldCwKLQkJCQkJcmVzb3VyY2Vfc2l6ZV90IHNpemUpOwotCXZvaWQgKCpmcmVl KShzdHJ1Y3QgaW50ZWxfbWVtb3J5X3JlZ2lvbiAqbWVtLAotCQkgICAgIHN0cnVjdCB0dG1fcmVz b3VyY2UgKnJlcyk7Ci19OwotCiBzdHJ1Y3QgaW50ZWxfbWVtb3J5X3JlZ2lvbiB7CiAJc3RydWN0 IGRybV9pOTE1X3ByaXZhdGUgKmk5MTU7CiAKIAljb25zdCBzdHJ1Y3QgaW50ZWxfbWVtb3J5X3Jl Z2lvbl9vcHMgKm9wczsKLQljb25zdCBzdHJ1Y3QgaW50ZWxfbWVtb3J5X3JlZ2lvbl9wcml2YXRl X29wcyAqcHJpdl9vcHM7CiAKIAlzdHJ1Y3QgaW9fbWFwcGluZyBpb21hcDsKIAlzdHJ1Y3QgcmVz b3VyY2UgcmVnaW9uOwpAQCAtNzksOCArNzAsNiBAQCBzdHJ1Y3QgaW50ZWxfbWVtb3J5X3JlZ2lv biB7CiAJLyogRm9yIGZha2UgTE1FTSAqLwogCXN0cnVjdCBkcm1fbW1fbm9kZSBmYWtlX21hcHBh YmxlOwogCi0Jc3RydWN0IG11dGV4IG1tX2xvY2s7Ci0KIAlzdHJ1Y3Qga3JlZiBrcmVmOwogCiAJ cmVzb3VyY2Vfc2l6ZV90IGlvX3N0YXJ0OwpAQCAtOTQsOCArODMsNiBAQCBzdHJ1Y3QgaW50ZWxf bWVtb3J5X3JlZ2lvbiB7CiAJY2hhciBuYW1lWzE2XTsKIAlib29sIHByaXZhdGU7IC8qIG5vdCBm b3IgdXNlcnNwYWNlICovCiAKLQlzdHJ1Y3QgbGlzdF9oZWFkIHJlc2VydmVkOwotCiAJZG1hX2Fk ZHJfdCByZW1hcF9hZGRyOwogCiAJc3RydWN0IHsKQEAgLTEwMyw4ICs5MCw2IEBAIHN0cnVjdCBp bnRlbF9tZW1vcnlfcmVnaW9uIHsKIAkJc3RydWN0IGxpc3RfaGVhZCBsaXN0OwogCX0gb2JqZWN0 czsKIAotCXNpemVfdCBjaHVua19zaXplOwotCXVuc2lnbmVkIGludCBtYXhfb3JkZXI7CiAJYm9v bCBpc19yYW5nZV9tYW5hZ2VyOwogCiAJdm9pZCAqcmVnaW9uX3ByaXZhdGU7CkBAIC0xMzgsOCAr MTIzLDYgQEAgX19wcmludGYoMiwgMykgdm9pZAogaW50ZWxfbWVtb3J5X3JlZ2lvbl9zZXRfbmFt ZShzdHJ1Y3QgaW50ZWxfbWVtb3J5X3JlZ2lvbiAqbWVtLAogCQkJICAgICBjb25zdCBjaGFyICpm bXQsIC4uLik7CiAKLXZvaWQgaW50ZWxfbWVtb3J5X3JlZ2lvbl91bnJlc2VydmUoc3RydWN0IGlu dGVsX21lbW9yeV9yZWdpb24gKm1lbSk7Ci0KIGludCBpbnRlbF9tZW1vcnlfcmVnaW9uX3Jlc2Vy dmUoc3RydWN0IGludGVsX21lbW9yeV9yZWdpb24gKm1lbSwKIAkJCQlyZXNvdXJjZV9zaXplX3Qg b2Zmc2V0LAogCQkJCXJlc291cmNlX3NpemVfdCBzaXplKTsKZGlmZiAtLWdpdCBhL2RyaXZlcnMv Z3B1L2RybS9pOTE1L2ludGVsX3JlZ2lvbl90dG0uYyBiL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2lu dGVsX3JlZ2lvbl90dG0uYwppbmRleCA1YTY2NGY2Y2M5M2YuLjIzYTEzMzZkMjMzNSAxMDA2NDQK LS0tIGEvZHJpdmVycy9ncHUvZHJtL2k5MTUvaW50ZWxfcmVnaW9uX3R0bS5jCisrKyBiL2RyaXZl cnMvZ3B1L2RybS9pOTE1L2ludGVsX3JlZ2lvbl90dG0uYwpAQCAtOCw2ICs4LDcgQEAKIAogI2lu Y2x1ZGUgImk5MTVfZHJ2LmgiCiAjaW5jbHVkZSAiaTkxNV9zY2F0dGVybGlzdC5oIgorI2luY2x1 ZGUgImk5MTVfdHRtX2J1ZGR5X21hbmFnZXIuaCIKIAogI2luY2x1ZGUgImludGVsX3JlZ2lvbl90 dG0uaCIKIApAQCAtNjcsNzIgKzY4LDE3IEBAIGludCBpbnRlbF9yZWdpb25fdG9fdHRtX3R5cGUo Y29uc3Qgc3RydWN0IGludGVsX21lbW9yeV9yZWdpb24gKm1lbSkKIAlyZXR1cm4gdHlwZTsKIH0K IAotc3RhdGljIHN0cnVjdCB0dG1fcmVzb3VyY2UgKgotaW50ZWxfcmVnaW9uX3R0bV9ub2RlX3Jl c2VydmUoc3RydWN0IGludGVsX21lbW9yeV9yZWdpb24gKm1lbSwKLQkJCSAgICAgIHJlc291cmNl X3NpemVfdCBvZmZzZXQsCi0JCQkgICAgICByZXNvdXJjZV9zaXplX3Qgc2l6ZSkKLXsKLQlzdHJ1 Y3QgdHRtX3Jlc291cmNlX21hbmFnZXIgKm1hbiA9IG1lbS0+cmVnaW9uX3ByaXZhdGU7Ci0Jc3Ry dWN0IHR0bV9wbGFjZSBwbGFjZSA9IHt9OwotCXN0cnVjdCB0dG1fYnVmZmVyX29iamVjdCBtb2Nr X2JvID0ge307Ci0Jc3RydWN0IHR0bV9yZXNvdXJjZSAqcmVzOwotCWludCByZXQ7Ci0KLQkvKgot CSAqIEhhdmluZyB0byB1c2UgYSBtb2NrX2JvIGlzIHVuZm9ydHVuYXRlIGJ1dCBzdGVtcyBmcm9t IHNvbWUKLQkgKiBkcml2ZXJzIGhhdmluZyBwcml2YXRlIG1hbmFnZXJzIHRoYXQgaW5zaXN0IHRv IGtub3cgd2hhdCB0aGUKLQkgKiBhbGxvY2F0ZSBtZW1vcnkgaXMgaW50ZW5kZWQgZm9yLCB1c2lu ZyBpdCB0byBzZW5kIHByaXZhdGUKLQkgKiBkYXRhIHRvIHRoZSBtYW5hZ2VyLiBBbHNvIHJlY2Vu dGx5IHRoZSBibyBoYXMgYmVlbiB1c2VkIHRvIHNlbmQKLQkgKiBhbGlnbm1lbnQgaW5mbyB0byB0 aGUgbWFuYWdlci4gQXNzdW1lIHRoYXQgYXBhcnQgZnJvbSB0aGUgbGF0dGVyLAotCSAqIG5vbmUg b2YgdGhlIG1hbmFnZXJzIHdlIHVzZSB3aWxsIGV2ZXIgYWNjZXNzIHRoZSBidWZmZXIgb2JqZWN0 Ci0JICogbWVtYmVycywgaG9waW5nIHdlIGNhbiBwYXNzIHRoZSBhbGlnbm1lbnQgaW5mbyBpbiB0 aGUKLQkgKiBzdHJ1Y3QgdHRtX3BsYWNlIGluIHRoZSBmdXR1cmUuCi0JICovCi0KLQlwbGFjZS5m cGZuID0gb2Zmc2V0ID4+IFBBR0VfU0hJRlQ7Ci0JcGxhY2UubHBmbiA9IHBsYWNlLmZwZm4gKyAo c2l6ZSA+PiBQQUdFX1NISUZUKTsKLQltb2NrX2JvLmJhc2Uuc2l6ZSA9IHNpemU7Ci0JcmV0ID0g bWFuLT5mdW5jLT5hbGxvYyhtYW4sICZtb2NrX2JvLCAmcGxhY2UsICZyZXMpOwotCWlmIChyZXQg PT0gLUVOT1NQQykKLQkJcmV0ID0gLUVOWElPOwotCi0JcmV0dXJuIHJldCA/IEVSUl9QVFIocmV0 KSA6IHJlczsKLX0KLQotLyoqCi0gKiBpbnRlbF9yZWdpb25fdHRtX25vZGVfZnJlZSAtIEZyZWUg YSBub2RlIGFsbG9jYXRlZCBmcm9tIGEgcmVzb3VyY2UgbWFuYWdlcgotICogQG1lbTogVGhlIHJl Z2lvbiB0aGUgbm9kZSB3YXMgYWxsb2NhdGVkIGZyb20uCi0gKiBAbm9kZTogVGhlIG9wYXF1ZSBu b2RlIHJlcHJlc2VudGluZyBhbiBhbGxvY2F0aW9uLgotICovCi12b2lkIGludGVsX3JlZ2lvbl90 dG1fbm9kZV9mcmVlKHN0cnVjdCBpbnRlbF9tZW1vcnlfcmVnaW9uICptZW0sCi0JCQkJc3RydWN0 IHR0bV9yZXNvdXJjZSAqcmVzKQotewotCXN0cnVjdCB0dG1fcmVzb3VyY2VfbWFuYWdlciAqbWFu ID0gbWVtLT5yZWdpb25fcHJpdmF0ZTsKLQotCW1hbi0+ZnVuYy0+ZnJlZShtYW4sIHJlcyk7Ci19 Ci0KLXN0YXRpYyBjb25zdCBzdHJ1Y3QgaW50ZWxfbWVtb3J5X3JlZ2lvbl9wcml2YXRlX29wcyBw cml2X29wcyA9IHsKLQkucmVzZXJ2ZSA9IGludGVsX3JlZ2lvbl90dG1fbm9kZV9yZXNlcnZlLAot CS5mcmVlID0gaW50ZWxfcmVnaW9uX3R0bV9ub2RlX2ZyZWUsCi19OwotCiBpbnQgaW50ZWxfcmVn aW9uX3R0bV9pbml0KHN0cnVjdCBpbnRlbF9tZW1vcnlfcmVnaW9uICptZW0pCiB7CiAJc3RydWN0 IHR0bV9kZXZpY2UgKmJkZXYgPSAmbWVtLT5pOTE1LT5iZGV2OwogCWludCBtZW1fdHlwZSA9IGlu dGVsX3JlZ2lvbl90b190dG1fdHlwZShtZW0pOwogCWludCByZXQ7CiAKLQlyZXQgPSB0dG1fcmFu Z2VfbWFuX2luaXQoYmRldiwgbWVtX3R5cGUsIGZhbHNlLAotCQkJCSByZXNvdXJjZV9zaXplKCZt ZW0tPnJlZ2lvbikgPj4gUEFHRV9TSElGVCk7CisJcmV0ID0gaTkxNV90dG1fYnVkZHlfbWFuX2lu aXQoYmRldiwgbWVtX3R5cGUsIGZhbHNlLAorCQkJCSAgICAgIHJlc291cmNlX3NpemUoJm1lbS0+ cmVnaW9uKSwgUEFHRV9TSVpFKTsKIAlpZiAocmV0KQogCQlyZXR1cm4gcmV0OwogCi0JbWVtLT5j aHVua19zaXplID0gUEFHRV9TSVpFOwotCW1lbS0+bWF4X29yZGVyID0KLQkJZ2V0X29yZGVyKHJv dW5kZG93bl9wb3dfb2ZfdHdvKHJlc291cmNlX3NpemUoJm1lbS0+cmVnaW9uKSkpOwotCW1lbS0+ aXNfcmFuZ2VfbWFuYWdlciA9IHRydWU7Ci0JbWVtLT5wcml2X29wcyA9ICZwcml2X29wczsKIAlt ZW0tPnJlZ2lvbl9wcml2YXRlID0gdHRtX21hbmFnZXJfdHlwZShiZGV2LCBtZW1fdHlwZSk7CiAK IAlyZXR1cm4gMDsKQEAgLTE1MCw4ICs5Niw4IEBAIHZvaWQgaW50ZWxfcmVnaW9uX3R0bV9maW5p KHN0cnVjdCBpbnRlbF9tZW1vcnlfcmVnaW9uICptZW0pCiB7CiAJaW50IHJldDsKIAotCXJldCA9 IHR0bV9yYW5nZV9tYW5fZmluaSgmbWVtLT5pOTE1LT5iZGV2LAotCQkJCSBpbnRlbF9yZWdpb25f dG9fdHRtX3R5cGUobWVtKSk7CisJcmV0ID0gaTkxNV90dG1fYnVkZHlfbWFuX2ZpbmkoJm1lbS0+ aTkxNS0+YmRldiwKKwkJCQkgICAgICBpbnRlbF9yZWdpb25fdG9fdHRtX3R5cGUobWVtKSk7CiAJ R0VNX1dBUk5fT04ocmV0KTsKIAltZW0tPnJlZ2lvbl9wcml2YXRlID0gTlVMTDsKIH0KQEAgLTIw NiwyNSArMTUyLDMzIEBAIGludGVsX3JlZ2lvbl90dG1fbm9kZV9hbGxvYyhzdHJ1Y3QgaW50ZWxf bWVtb3J5X3JlZ2lvbiAqbWVtLAogCXN0cnVjdCB0dG1fcmVzb3VyY2UgKnJlczsKIAlpbnQgcmV0 OwogCi0JLyoKLQkgKiBXZSBpZ25vcmUgdGhlIGZsYWdzIGZvciBub3cgc2luY2Ugd2UncmUgdXNp bmcgdGhlIHJhbmdlCi0JICogbWFuYWdlciBhbmQgY29udGlnb3VzIGFuZCBtaW4gcGFnZSBzaXpl IHdvdWxkIGJlIGZ1bGZpbGxlZAotCSAqIGJ5IGRlZmF1bHQgaWYgc2l6ZSBpcyBtaW4gcGFnZSBz aXplIGFsaWduZWQuCi0JICovCiAJbW9ja19iby5iYXNlLnNpemUgPSBzaXplOwotCi0JaWYgKG1l bS0+aXNfcmFuZ2VfbWFuYWdlcikgewotCQlpZiAoc2l6ZSA+PSBTWl8xRykKLQkJCW1vY2tfYm8u cGFnZV9hbGlnbm1lbnQgPSBTWl8xRyA+PiBQQUdFX1NISUZUOwotCQllbHNlIGlmIChzaXplID49 IFNaXzJNKQotCQkJbW9ja19iby5wYWdlX2FsaWdubWVudCA9IFNaXzJNID4+IFBBR0VfU0hJRlQ7 Ci0JCWVsc2UgaWYgKHNpemUgPj0gU1pfNjRLKQotCQkJbW9ja19iby5wYWdlX2FsaWdubWVudCA9 IFNaXzY0SyA+PiBQQUdFX1NISUZUOwotCX0KKwltb2NrX2JvLnBhZ2VfYWxpZ25tZW50ID0gMTsK KwlwbGFjZS5mbGFncyA9IGZsYWdzOwogCiAJcmV0ID0gbWFuLT5mdW5jLT5hbGxvYyhtYW4sICZt b2NrX2JvLCAmcGxhY2UsICZyZXMpOwogCWlmIChyZXQgPT0gLUVOT1NQQykKIAkJcmV0ID0gLUVO WElPOwogCXJldHVybiByZXQgPyBFUlJfUFRSKHJldCkgOiByZXM7CiB9CisKICNlbmRpZgorCisv KioKKyAqIGludGVsX3JlZ2lvbl90dG1faW5pdCAtIEluaXRpYWxpemUgYSBtZW1vcnkgcmVnaW9u IGZvciBUVE0uCisgKiBAbWVtOiBUaGUgcmVnaW9uIHRvIGluaXRpYWxpemUuCisgKgorICogVGhp cyBmdW5jdGlvbiBpbml0aWFsaXplcyBhIHN1aXRhYmxlIFRUTSByZXNvdXJjZSBtYW5hZ2VyIGZv ciB0aGUKKyAqIHJlZ2lvbiwgYW5kIGlmIGl0J3MgYSBMTUVNIHJlZ2lvbiB0eXBlLCBhdHRhY2hl cyBpdCB0byB0aGUgVFRNCisgKiBkZXZpY2UuIE1PQ0sgcmVnaW9ucyBhcmUgTk9UIGF0dGFjaGVk IHRvIHRoZSBUVE0gZGV2aWNlLCBzaW5jZSB3ZSBkb24ndAorICogaGF2ZSBvbmUgZm9yIHRoZSBt b2NrIHNlbGZ0ZXN0cy4KKyAqCisgKiBSZXR1cm46IDAgb24gc3VjY2VzcywgbmVnYXRpdmUgZXJy b3IgY29kZSBvbiBmYWlsdXJlLgorICovCit2b2lkIGludGVsX3JlZ2lvbl90dG1fbm9kZV9mcmVl KHN0cnVjdCBpbnRlbF9tZW1vcnlfcmVnaW9uICptZW0sCisJCQkJc3RydWN0IHR0bV9yZXNvdXJj ZSAqcmVzKQoreworCXN0cnVjdCB0dG1fcmVzb3VyY2VfbWFuYWdlciAqbWFuID0gbWVtLT5yZWdp b25fcHJpdmF0ZTsKKworCW1hbi0+ZnVuYy0+ZnJlZShtYW4sIHJlcyk7Cit9CmRpZmYgLS1naXQg YS9kcml2ZXJzL2dwdS9kcm0vaTkxNS9zZWxmdGVzdHMvaW50ZWxfbWVtb3J5X3JlZ2lvbi5jIGIv ZHJpdmVycy9ncHUvZHJtL2k5MTUvc2VsZnRlc3RzL2ludGVsX21lbW9yeV9yZWdpb24uYwppbmRl eCBjODVkNTE2Yjg1Y2QuLmRjMjNkNjk5ZWNiNSAxMDA2NDQKLS0tIGEvZHJpdmVycy9ncHUvZHJt L2k5MTUvc2VsZnRlc3RzL2ludGVsX21lbW9yeV9yZWdpb24uYworKysgYi9kcml2ZXJzL2dwdS9k cm0vaTkxNS9zZWxmdGVzdHMvaW50ZWxfbWVtb3J5X3JlZ2lvbi5jCkBAIC0yMCw3ICsyMCw5IEBA CiAjaW5jbHVkZSAiZ2VtL3NlbGZ0ZXN0cy9tb2NrX2NvbnRleHQuaCIKICNpbmNsdWRlICJndC9p bnRlbF9lbmdpbmVfdXNlci5oIgogI2luY2x1ZGUgImd0L2ludGVsX2d0LmgiCisjaW5jbHVkZSAi aTkxNV9idWRkeS5oIgogI2luY2x1ZGUgImk5MTVfbWVtY3B5LmgiCisjaW5jbHVkZSAiaTkxNV90 dG1fYnVkZHlfbWFuYWdlci5oIgogI2luY2x1ZGUgInNlbGZ0ZXN0cy9pZ3RfZmx1c2hfdGVzdC5o IgogI2luY2x1ZGUgInNlbGZ0ZXN0cy9pOTE1X3JhbmRvbS5oIgogCkBAIC01NywxMCArNTksOSBA QCBzdGF0aWMgaW50IGlndF9tb2NrX2ZpbGwodm9pZCAqYXJnKQogCUxJU1RfSEVBRChvYmplY3Rz KTsKIAlpbnQgZXJyID0gMDsKIAotCXBhZ2Vfc2l6ZSA9IG1lbS0+Y2h1bmtfc2l6ZTsKKwlwYWdl X3NpemUgPSBQQUdFX1NJWkU7CisJbWF4X3BhZ2VzID0gZGl2NjRfdTY0KHRvdGFsLCBwYWdlX3Np emUpOwogCXJlbSA9IHRvdGFsOwotcmV0cnk6Ci0JbWF4X3BhZ2VzID0gZGl2NjRfdTY0KHJlbSwg cGFnZV9zaXplKTsKIAogCWZvcl9lYWNoX3ByaW1lX251bWJlcl9mcm9tKHBhZ2VfbnVtLCAxLCBt YXhfcGFnZXMpIHsKIAkJcmVzb3VyY2Vfc2l6ZV90IHNpemUgPSBwYWdlX251bSAqIHBhZ2Vfc2l6 ZTsKQEAgLTg2LDExICs4Nyw2IEBAIHN0YXRpYyBpbnQgaWd0X21vY2tfZmlsbCh2b2lkICphcmcp CiAJCWVyciA9IDA7CiAJaWYgKGVyciA9PSAtRU5YSU8pIHsKIAkJaWYgKHBhZ2VfbnVtICogcGFn ZV9zaXplIDw9IHJlbSkgewotCQkJaWYgKG1lbS0+aXNfcmFuZ2VfbWFuYWdlciAmJiBtYXhfcGFn ZXMgPiAxKSB7Ci0JCQkJbWF4X3BhZ2VzID4+PSAxOwotCQkJCWdvdG8gcmV0cnk7Ci0JCQl9Ci0K IAkJCXByX2VycigiJXMgZmFpbGVkLCBzcGFjZSBzdGlsbCBsZWZ0IGluIHJlZ2lvblxuIiwKIAkJ CSAgICAgICBfX2Z1bmNfXyk7CiAJCQllcnIgPSAtRUlOVkFMOwpAQCAtMTU3LDYgKzE1Myw3IEBA IHN0YXRpYyBib29sIGlzX2NvbnRpZ3VvdXMoc3RydWN0IGRybV9pOTE1X2dlbV9vYmplY3QgKm9i aikKIHN0YXRpYyBpbnQgaWd0X21vY2tfcmVzZXJ2ZSh2b2lkICphcmcpCiB7CiAJc3RydWN0IGlu dGVsX21lbW9yeV9yZWdpb24gKm1lbSA9IGFyZzsKKwlzdHJ1Y3QgZHJtX2k5MTVfcHJpdmF0ZSAq aTkxNSA9IG1lbS0+aTkxNTsKIAlyZXNvdXJjZV9zaXplX3QgYXZhaWwgPSByZXNvdXJjZV9zaXpl KCZtZW0tPnJlZ2lvbik7CiAJc3RydWN0IGRybV9pOTE1X2dlbV9vYmplY3QgKm9iajsKIAljb25z dCB1MzIgY2h1bmtfc2l6ZSA9IFNaXzMyTTsKQEAgLTE2NiwxNiArMTYzLDE4IEBAIHN0YXRpYyBp bnQgaWd0X21vY2tfcmVzZXJ2ZSh2b2lkICphcmcpCiAJTElTVF9IRUFEKG9iamVjdHMpOwogCWlu dCBlcnIgPSAwOwogCi0JaWYgKCFsaXN0X2VtcHR5KCZtZW0tPnJlc2VydmVkKSkgewotCQlwcl9l cnIoIiVzIHJlZ2lvbiByZXNlcnZlZCBsaXN0IGlzIG5vdCBlbXB0eVxuIiwgX19mdW5jX18pOwot CQlyZXR1cm4gLUVJTlZBTDsKLQl9Ci0KIAljb3VudCA9IGF2YWlsIC8gY2h1bmtfc2l6ZTsKIAlv cmRlciA9IGk5MTVfcmFuZG9tX29yZGVyKGNvdW50LCAmcHJuZyk7CiAJaWYgKCFvcmRlcikKIAkJ cmV0dXJuIDA7CiAKKwltZW0gPSBtb2NrX3JlZ2lvbl9jcmVhdGUoaTkxNSwgMCwgU1pfMkcsIEk5 MTVfR1RUX1BBR0VfU0laRV80SywgMCk7CisJaWYgKElTX0VSUihtZW0pKSB7CisJCXByX2Vycigi ZmFpbGVkIHRvIGNyZWF0ZSBtZW1vcnkgcmVnaW9uXG4iKTsKKwkJZXJyID0gUFRSX0VSUihtZW0p OworCQlnb3RvIG91dF9jbG9zZTsKKwl9CisKIAkvKiBSZXNlcnZlIGEgYnVuY2ggb2YgcmFuZ2Vz IHdpdGhpbiB0aGUgcmVnaW9uICovCiAJZm9yIChpID0gMDsgaSA8IGNvdW50OyArK2kpIHsKIAkJ dTY0IHN0YXJ0ID0gb3JkZXJbaV0gKiBjaHVua19zaXplOwpAQCAtMjA1LDE4ICsyMDQsMTIgQEAg c3RhdGljIGludCBpZ3RfbW9ja19yZXNlcnZlKHZvaWQgKmFyZykKIAlkbyB7CiAJCXUzMiBzaXpl ID0gaTkxNV9wcmFuZG9tX3UzMl9tYXhfc3RhdGUoY3VyX2F2YWlsLCAmcHJuZyk7CiAKLXJldHJ5 OgogCQlzaXplID0gbWF4X3QodTMyLCByb3VuZF91cChzaXplLCBQQUdFX1NJWkUpLCBQQUdFX1NJ WkUpOwogCQlvYmogPSBpZ3Rfb2JqZWN0X2NyZWF0ZShtZW0sICZvYmplY3RzLCBzaXplLCAwKTsK IAkJaWYgKElTX0VSUihvYmopKSB7Ci0JCQlpZiAoUFRSX0VSUihvYmopID09IC1FTlhJTykgewot CQkJCWlmIChtZW0tPmlzX3JhbmdlX21hbmFnZXIgJiYKLQkJCQkgICAgc2l6ZSA+IG1lbS0+Y2h1 bmtfc2l6ZSkgewotCQkJCQlzaXplID4+PSAxOwotCQkJCQlnb3RvIHJldHJ5OwotCQkJCX0KKwkJ CWlmIChQVFJfRVJSKG9iaikgPT0gLUVOWElPKQogCQkJCWJyZWFrOwotCQkJfQorCiAJCQllcnIg PSBQVFJfRVJSKG9iaik7CiAJCQlnb3RvIG91dF9jbG9zZTsKIAkJfQpAQCAtMjMyLDcgKzIyNSw3 IEBAIHN0YXRpYyBpbnQgaWd0X21vY2tfcmVzZXJ2ZSh2b2lkICphcmcpCiBvdXRfY2xvc2U6CiAJ a2ZyZWUob3JkZXIpOwogCWNsb3NlX29iamVjdHMobWVtLCAmb2JqZWN0cyk7Ci0JaW50ZWxfbWVt b3J5X3JlZ2lvbl91bnJlc2VydmUobWVtKTsKKwlpbnRlbF9tZW1vcnlfcmVnaW9uX3B1dChtZW0p OwogCXJldHVybiBlcnI7CiB9CiAKQEAgLTI1Miw3ICsyNDUsNyBAQCBzdGF0aWMgaW50IGlndF9t b2NrX2NvbnRpZ3VvdXModm9pZCAqYXJnKQogCXRvdGFsID0gcmVzb3VyY2Vfc2l6ZSgmbWVtLT5y ZWdpb24pOwogCiAJLyogTWluIHNpemUgKi8KLQlvYmogPSBpZ3Rfb2JqZWN0X2NyZWF0ZShtZW0s ICZvYmplY3RzLCBtZW0tPmNodW5rX3NpemUsCisJb2JqID0gaWd0X29iamVjdF9jcmVhdGUobWVt LCAmb2JqZWN0cywgUEFHRV9TSVpFLAogCQkJCUk5MTVfQk9fQUxMT0NfQ09OVElHVU9VUyk7CiAJ aWYgKElTX0VSUihvYmopKQogCQlyZXR1cm4gUFRSX0VSUihvYmopOwpAQCAtMzMzLDE3ICszMjYs MTUgQEAgc3RhdGljIGludCBpZ3RfbW9ja19jb250aWd1b3VzKHZvaWQgKmFyZykKIAltaW4gPSB0 YXJnZXQ7CiAJdGFyZ2V0ID0gdG90YWwgPj4gMTsKIAotCWlmICghbWVtLT5pc19yYW5nZV9tYW5h Z2VyKSB7Ci0JCS8qIE1ha2Ugc3VyZSB3ZSBjYW4gc3RpbGwgYWxsb2NhdGUgYWxsIHRoZSBmcmFn bWVudGVkIHNwYWNlICovCi0JCW9iaiA9IGlndF9vYmplY3RfY3JlYXRlKG1lbSwgJm9iamVjdHMs IHRhcmdldCwgMCk7Ci0JCWlmIChJU19FUlIob2JqKSkgewotCQkJZXJyID0gUFRSX0VSUihvYmop OwotCQkJZ290byBlcnJfY2xvc2Vfb2JqZWN0czsKLQkJfQotCi0JCWlndF9vYmplY3RfcmVsZWFz ZShvYmopOworCS8qIE1ha2Ugc3VyZSB3ZSBjYW4gc3RpbGwgYWxsb2NhdGUgYWxsIHRoZSBmcmFn bWVudGVkIHNwYWNlICovCisJb2JqID0gaWd0X29iamVjdF9jcmVhdGUobWVtLCAmb2JqZWN0cywg dGFyZ2V0LCAwKTsKKwlpZiAoSVNfRVJSKG9iaikpIHsKKwkJZXJyID0gUFRSX0VSUihvYmopOwor CQlnb3RvIGVycl9jbG9zZV9vYmplY3RzOwogCX0KIAorCWlndF9vYmplY3RfcmVsZWFzZShvYmop OworCiAJLyoKIAkgKiBFdmVuIHRob3VnaCB3ZSBoYXZlIGVub3VnaCBmcmVlIHNwYWNlLCB3ZSBk b24ndCBoYXZlIGEgYmlnIGVub3VnaAogCSAqIGNvbnRpZ3VvdXMgYmxvY2suIE1ha2Ugc3VyZSB0 aGF0IGhvbGRzIHRydWUuCkBAIC0zNjIsNyArMzUzLDcgQEAgc3RhdGljIGludCBpZ3RfbW9ja19j b250aWd1b3VzKHZvaWQgKmFyZykKIAkJfQogCiAJCXRhcmdldCA+Pj0gMTsKLQl9IHdoaWxlICh0 YXJnZXQgPj0gbWVtLT5jaHVua19zaXplKTsKKwl9IHdoaWxlICh0YXJnZXQgPj0gUEFHRV9TSVpF KTsKIAogZXJyX2Nsb3NlX29iamVjdHM6CiAJbGlzdF9zcGxpY2VfdGFpbCgmaG9sZXMsICZvYmpl Y3RzKTsKQEAgLTM3NCw3ICszNjUsOSBAQCBzdGF0aWMgaW50IGlndF9tb2NrX3NwbGludGVyZWRf cmVnaW9uKHZvaWQgKmFyZykKIHsKIAlzdHJ1Y3QgaW50ZWxfbWVtb3J5X3JlZ2lvbiAqbWVtID0g YXJnOwogCXN0cnVjdCBkcm1faTkxNV9wcml2YXRlICppOTE1ID0gbWVtLT5pOTE1OworCXN0cnVj dCBpOTE1X3R0bV9idWRkeV9yZXNvdXJjZSAqcmVzOwogCXN0cnVjdCBkcm1faTkxNV9nZW1fb2Jq ZWN0ICpvYmo7CisJc3RydWN0IGk5MTVfYnVkZHlfbW0gKm1tOwogCXVuc2lnbmVkIGludCBleHBl Y3RlZF9vcmRlcjsKIAlMSVNUX0hFQUQob2JqZWN0cyk7CiAJdTY0IHNpemU7CkBAIC0zODIsNyAr Mzc1LDcgQEAgc3RhdGljIGludCBpZ3RfbW9ja19zcGxpbnRlcmVkX3JlZ2lvbih2b2lkICphcmcp CiAKIAkvKgogCSAqIFNhbml0eSBjaGVjayB3ZSBjYW4gc3RpbGwgYWxsb2NhdGUgZXZlcnl0aGlu ZyBldmVuIGlmIHRoZQotCSAqIG1heF9vcmRlciAhPSBtbS5zaXplLiBpLmUgb3VyIHN0YXJ0aW5n IGFkZHJlc3Mgc3BhY2Ugc2l6ZSBpcyBub3QgYQorCSAqIG1tLm1heF9vcmRlciAhPSBtbS5zaXpl LiBpLmUgb3VyIHN0YXJ0aW5nIGFkZHJlc3Mgc3BhY2Ugc2l6ZSBpcyBub3QgYQogCSAqIHBvd2Vy LW9mLXR3by4KIAkgKi8KIApAQCAtMzkxLDIwICszODQsMjkgQEAgc3RhdGljIGludCBpZ3RfbW9j a19zcGxpbnRlcmVkX3JlZ2lvbih2b2lkICphcmcpCiAJaWYgKElTX0VSUihtZW0pKQogCQlyZXR1 cm4gUFRSX0VSUihtZW0pOwogCi0JZXhwZWN0ZWRfb3JkZXIgPSBnZXRfb3JkZXIocm91bmRkb3du X3Bvd19vZl90d28oc2l6ZSkpOwotCWlmIChtZW0tPm1heF9vcmRlciAhPSBleHBlY3RlZF9vcmRl cikgewotCQlwcl9lcnIoIiVzIG9yZGVyIG1pc21hdGNoKCV1ICE9ICV1KVxuIiwKLQkJICAgICAg IF9fZnVuY19fLCBtZW0tPm1heF9vcmRlciwgZXhwZWN0ZWRfb3JkZXIpOwotCQllcnIgPSAtRUlO VkFMOwotCQlnb3RvIG91dF9wdXQ7Ci0JfQotCiAJb2JqID0gaWd0X29iamVjdF9jcmVhdGUobWVt LCAmb2JqZWN0cywgc2l6ZSwgMCk7CiAJaWYgKElTX0VSUihvYmopKSB7CiAJCWVyciA9IFBUUl9F UlIob2JqKTsKIAkJZ290byBvdXRfY2xvc2U7CiAJfQogCisJcmVzID0gdG9fdHRtX2J1ZGR5X3Jl c291cmNlKG9iai0+bW0uc3RfbW1fbm9kZSk7CisJbW0gPSByZXMtPm1tOworCWlmIChtbS0+c2l6 ZSAhPSBzaXplKSB7CisJCXByX2VycigiJXMgc2l6ZSBtaXNtYXRjaCglbGx1ICE9ICVsbHUpXG4i LAorCQkgICAgICAgX19mdW5jX18sIG1tLT5zaXplLCBzaXplKTsKKwkJZXJyID0gLUVJTlZBTDsK KwkJZ290byBvdXRfcHV0OworCX0KKworCWV4cGVjdGVkX29yZGVyID0gZ2V0X29yZGVyKHJvdW5k ZG93bl9wb3dfb2ZfdHdvKHNpemUpKTsKKwlpZiAobW0tPm1heF9vcmRlciAhPSBleHBlY3RlZF9v cmRlcikgeworCQlwcl9lcnIoIiVzIG9yZGVyIG1pc21hdGNoKCV1ICE9ICV1KVxuIiwKKwkJICAg ICAgIF9fZnVuY19fLCBtbS0+bWF4X29yZGVyLCBleHBlY3RlZF9vcmRlcik7CisJCWVyciA9IC1F SU5WQUw7CisJCWdvdG8gb3V0X3B1dDsKKwl9CisKIAljbG9zZV9vYmplY3RzKG1lbSwgJm9iamVj dHMpOwogCiAJLyoKQEAgLTQxNSwxNSArNDE3LDEyIEBAIHN0YXRpYyBpbnQgaWd0X21vY2tfc3Bs aW50ZXJlZF9yZWdpb24odm9pZCAqYXJnKQogCSAqIHN1cmUgdGhhdCBkb2VzIGluZGVlZCBob2xk IHRydWUuCiAJICovCiAKLQlpZiAoIW1lbS0+aXNfcmFuZ2VfbWFuYWdlcikgewotCQlvYmogPSBp Z3Rfb2JqZWN0X2NyZWF0ZShtZW0sICZvYmplY3RzLCBzaXplLAotCQkJCQlJOTE1X0JPX0FMTE9D X0NPTlRJR1VPVVMpOwotCQlpZiAoIUlTX0VSUihvYmopKSB7Ci0JCQlwcl9lcnIoIiVzIHRvbyBs YXJnZSBjb250aWd1b3VzIGFsbG9jYXRpb24gd2FzIG5vdCByZWplY3RlZFxuIiwKLQkJCSAgICAg ICBfX2Z1bmNfXyk7Ci0JCQllcnIgPSAtRUlOVkFMOwotCQkJZ290byBvdXRfY2xvc2U7Ci0JCX0K KwlvYmogPSBpZ3Rfb2JqZWN0X2NyZWF0ZShtZW0sICZvYmplY3RzLCBzaXplLCBJOTE1X0JPX0FM TE9DX0NPTlRJR1VPVVMpOworCWlmICghSVNfRVJSKG9iaikpIHsKKwkJcHJfZXJyKCIlcyB0b28g bGFyZ2UgY29udGlndW91cyBhbGxvY2F0aW9uIHdhcyBub3QgcmVqZWN0ZWRcbiIsCisJCSAgICAg ICBfX2Z1bmNfXyk7CisJCWVyciA9IC1FSU5WQUw7CisJCWdvdG8gb3V0X2Nsb3NlOwogCX0KIAog CW9iaiA9IGlndF9vYmplY3RfY3JlYXRlKG1lbSwgJm9iamVjdHMsIHJvdW5kZG93bl9wb3dfb2Zf dHdvKHNpemUpLApAQCAtNDQyLDYgKzQ0MSw3NCBAQCBzdGF0aWMgaW50IGlndF9tb2NrX3NwbGlu dGVyZWRfcmVnaW9uKHZvaWQgKmFyZykKIAlyZXR1cm4gZXJyOwogfQogCisjaWZuZGVmIFNaXzhH CisjZGVmaW5lIFNaXzhHIEJJVF9VTEwoMzMpCisjZW5kaWYKKworc3RhdGljIGludCBpZ3RfbW9j a19tYXhfc2VnbWVudCh2b2lkICphcmcpCit7CisJY29uc3QgdW5zaWduZWQgaW50IG1heF9zZWdt ZW50ID0gaTkxNV9zZ19zZWdtZW50X3NpemUoKTsKKwlzdHJ1Y3QgaW50ZWxfbWVtb3J5X3JlZ2lv biAqbWVtID0gYXJnOworCXN0cnVjdCBkcm1faTkxNV9wcml2YXRlICppOTE1ID0gbWVtLT5pOTE1 OworCXN0cnVjdCBpOTE1X3R0bV9idWRkeV9yZXNvdXJjZSAqcmVzOworCXN0cnVjdCBkcm1faTkx NV9nZW1fb2JqZWN0ICpvYmo7CisJc3RydWN0IGk5MTVfYnVkZHlfYmxvY2sgKmJsb2NrOworCXN0 cnVjdCBpOTE1X2J1ZGR5X21tICptbTsKKwlzdHJ1Y3QgbGlzdF9oZWFkICpibG9ja3M7CisJc3Ry dWN0IHNjYXR0ZXJsaXN0ICpzZzsKKwlMSVNUX0hFQUQob2JqZWN0cyk7CisJdTY0IHNpemU7CisJ aW50IGVyciA9IDA7CisKKwkvKgorCSAqIFdoaWxlIHdlIG1heSBjcmVhdGUgdmVyeSBsYXJnZSBj b250aWd1b3VzIGJsb2Nrcywgd2UgbWF5IG5lZWQKKwkgKiB0byBicmVhayB0aG9zZSBkb3duIGZv ciBjb25zdW1wdGlvbiBlbHNld2hlcmUuIEluIHBhcnRpY3VsYXIsCisJICogZG1hLW1hcHBpbmcg d2l0aCBzY2F0dGVybGlzdCBlbGVtZW50cyBoYXZlIGFuIGltcGxpY2l0IGxpbWl0IG9mCisJICog VUlOVF9NQVggb24gZWFjaCBlbGVtZW50LgorCSAqLworCisJc2l6ZSA9IFNaXzhHOworCW1lbSA9 IG1vY2tfcmVnaW9uX2NyZWF0ZShpOTE1LCAwLCBzaXplLCBQQUdFX1NJWkUsIDApOworCWlmIChJ U19FUlIobWVtKSkKKwkJcmV0dXJuIFBUUl9FUlIobWVtKTsKKworCW9iaiA9IGlndF9vYmplY3Rf Y3JlYXRlKG1lbSwgJm9iamVjdHMsIHNpemUsIDApOworCWlmIChJU19FUlIob2JqKSkgeworCQll cnIgPSBQVFJfRVJSKG9iaik7CisJCWdvdG8gb3V0X3B1dDsKKwl9CisKKwlyZXMgPSB0b190dG1f YnVkZHlfcmVzb3VyY2Uob2JqLT5tbS5zdF9tbV9ub2RlKTsKKwlibG9ja3MgPSAmcmVzLT5ibG9j a3M7CisJbW0gPSByZXMtPm1tOworCXNpemUgPSAwOworCWxpc3RfZm9yX2VhY2hfZW50cnkoYmxv Y2ssIGJsb2NrcywgbGluaykgeworCQlpZiAoaTkxNV9idWRkeV9ibG9ja19zaXplKG1tLCBibG9j aykgPiBzaXplKQorCQkJc2l6ZSA9IGk5MTVfYnVkZHlfYmxvY2tfc2l6ZShtbSwgYmxvY2spOwor CX0KKwlpZiAoc2l6ZSA8IG1heF9zZWdtZW50KSB7CisJCXByX2VycigiJXM6IEZhaWxlZCB0byBj cmVhdGUgYSBodWdlIGNvbnRpZ3VvdXMgYmxvY2sgWz4gJXVdLCBsYXJnZXN0IGJsb2NrICVsbGRc biIsCisJCSAgICAgICBfX2Z1bmNfXywgbWF4X3NlZ21lbnQsIHNpemUpOworCQllcnIgPSAtRUlO VkFMOworCQlnb3RvIG91dF9jbG9zZTsKKwl9CisKKwlmb3IgKHNnID0gb2JqLT5tbS5wYWdlcy0+ c2dsOyBzZzsgc2cgPSBzZ19uZXh0KHNnKSkgeworCQlpZiAoc2ctPmxlbmd0aCA+IG1heF9zZWdt ZW50KSB7CisJCQlwcl9lcnIoIiVzOiBDcmVhdGVkIGFuIG92ZXJzaXplZCBzY2F0dGVybGlzdCBl bnRyeSwgJXUgPiAldVxuIiwKKwkJCSAgICAgICBfX2Z1bmNfXywgc2ctPmxlbmd0aCwgbWF4X3Nl Z21lbnQpOworCQkJZXJyID0gLUVJTlZBTDsKKwkJCWdvdG8gb3V0X2Nsb3NlOworCQl9CisJfQor CitvdXRfY2xvc2U6CisJY2xvc2Vfb2JqZWN0cyhtZW0sICZvYmplY3RzKTsKK291dF9wdXQ6CisJ aW50ZWxfbWVtb3J5X3JlZ2lvbl9wdXQobWVtKTsKKwlyZXR1cm4gZXJyOworfQorCiBzdGF0aWMg aW50IGlndF9ncHVfd3JpdGVfZHcoc3RydWN0IGludGVsX2NvbnRleHQgKmNlLAogCQkJICAgIHN0 cnVjdCBpOTE1X3ZtYSAqdm1hLAogCQkJICAgIHUzMiBkd29yZCwKQEAgLTEwNDYsNiArMTExMyw3 IEBAIGludCBpbnRlbF9tZW1vcnlfcmVnaW9uX21vY2tfc2VsZnRlc3RzKHZvaWQpCiAJCVNVQlRF U1QoaWd0X21vY2tfZmlsbCksCiAJCVNVQlRFU1QoaWd0X21vY2tfY29udGlndW91cyksCiAJCVNV QlRFU1QoaWd0X21vY2tfc3BsaW50ZXJlZF9yZWdpb24pLAorCQlTVUJURVNUKGlndF9tb2NrX21h eF9zZWdtZW50KSwKIAl9OwogCXN0cnVjdCBpbnRlbF9tZW1vcnlfcmVnaW9uICptZW07CiAJc3Ry dWN0IGRybV9pOTE1X3ByaXZhdGUgKmk5MTU7CmRpZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9kcm0v aTkxNS9zZWxmdGVzdHMvbW9ja19yZWdpb24uYyBiL2RyaXZlcnMvZ3B1L2RybS9pOTE1L3NlbGZ0 ZXN0cy9tb2NrX3JlZ2lvbi5jCmluZGV4IGVhZmM1YTA0OTc1Yy4uZDNlNGU2NTczY2I5IDEwMDY0 NAotLS0gYS9kcml2ZXJzL2dwdS9kcm0vaTkxNS9zZWxmdGVzdHMvbW9ja19yZWdpb24uYworKysg Yi9kcml2ZXJzL2dwdS9kcm0vaTkxNS9zZWxmdGVzdHMvbW9ja19yZWdpb24uYwpAQCAtMyw2ICsz LDcgQEAKICAqIENvcHlyaWdodCDCqSAyMDE5LTIwMjEgSW50ZWwgQ29ycG9yYXRpb24KICAqLwog CisjaW5jbHVkZSA8ZHJtL3R0bS90dG1fcGxhY2VtZW50Lmg+CiAjaW5jbHVkZSA8bGludXgvc2Nh dHRlcmxpc3QuaD4KIAogI2luY2x1ZGUgPGRybS90dG0vdHRtX3BsYWNlbWVudC5oPgpAQCAtMjUs MTAgKzI2LDExIEBAIHN0YXRpYyBpbnQgbW9ja19yZWdpb25fZ2V0X3BhZ2VzKHN0cnVjdCBkcm1f aTkxNV9nZW1fb2JqZWN0ICpvYmopCiB7CiAJdW5zaWduZWQgaW50IGZsYWdzOwogCXN0cnVjdCBz Z190YWJsZSAqcGFnZXM7CisJaW50IGVycjsKIAogCWZsYWdzID0gSTkxNV9BTExPQ19NSU5fUEFH RV9TSVpFOwogCWlmIChvYmotPmZsYWdzICYgSTkxNV9CT19BTExPQ19DT05USUdVT1VTKQotCQlm bGFncyB8PSBJOTE1X0FMTE9DX0NPTlRJR1VPVVM7CisJCWZsYWdzIHw9IFRUTV9QTF9GTEFHX0NP TlRJR1VPVVM7CiAKIAlvYmotPm1tLnN0X21tX25vZGUgPSBpbnRlbF9yZWdpb25fdHRtX25vZGVf YWxsb2Mob2JqLT5tbS5yZWdpb24sCiAJCQkJCQkJIG9iai0+YmFzZS5zaXplLApAQCAtMzYsMTUg KzM4LDIwIEBAIHN0YXRpYyBpbnQgbW9ja19yZWdpb25fZ2V0X3BhZ2VzKHN0cnVjdCBkcm1faTkx NV9nZW1fb2JqZWN0ICpvYmopCiAJaWYgKElTX0VSUihvYmotPm1tLnN0X21tX25vZGUpKQogCQly ZXR1cm4gUFRSX0VSUihvYmotPm1tLnN0X21tX25vZGUpOwogCi0JcGFnZXMgPSBpbnRlbF9yZWdp b25fdHRtX25vZGVfdG9fc3Qob2JqLT5tbS5yZWdpb24sIG9iai0+bW0uc3RfbW1fbm9kZSk7CisJ cGFnZXMgPSBpOTE1X3NnX2Zyb21fYnVkZHlfcmVzb3VyY2Uob2JqLT5tbS5zdF9tbV9ub2RlLAor CQkJCQkgICAgb2JqLT5tbS5yZWdpb24tPnJlZ2lvbi5zdGFydCk7CiAJaWYgKElTX0VSUihwYWdl cykpIHsKLQkJaW50ZWxfcmVnaW9uX3R0bV9ub2RlX2ZyZWUob2JqLT5tbS5yZWdpb24sIG9iai0+ bW0uc3RfbW1fbm9kZSk7Ci0JCXJldHVybiBQVFJfRVJSKHBhZ2VzKTsKKwkJZXJyID0gUFRSX0VS UihwYWdlcyk7CisJCWdvdG8gZXJyX2ZyZWVfbW1fbm9kZTsKIAl9CiAKIAlfX2k5MTVfZ2VtX29i amVjdF9zZXRfcGFnZXMob2JqLCBwYWdlcywgaTkxNV9zZ19kbWFfc2l6ZXMocGFnZXMtPnNnbCkp OwogCiAJcmV0dXJuIDA7CisKK2Vycl9mcmVlX21tX25vZGU6CisJaW50ZWxfcmVnaW9uX3R0bV9u b2RlX2ZyZWUob2JqLT5tbS5yZWdpb24sIG9iai0+bW0uc3RfbW1fbm9kZSk7CisJcmV0dXJuIGVy cjsKIH0KIAogc3RhdGljIGNvbnN0IHN0cnVjdCBkcm1faTkxNV9nZW1fb2JqZWN0X29wcyBtb2Nr X3JlZ2lvbl9vYmpfb3BzID0gewotLSAKMi4yNi4zCgpfX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fXwpJbnRlbC1nZnggbWFpbGluZyBsaXN0CkludGVsLWdmeEBs aXN0cy5mcmVlZGVza3RvcC5vcmcKaHR0cHM6Ly9saXN0cy5mcmVlZGVza3RvcC5vcmcvbWFpbG1h bi9saXN0aW5mby9pbnRlbC1nZngK From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org X-Spam-Level: X-Spam-Status: No, score=-16.8 required=3.0 tests=BAYES_00, HEADER_FROM_DIFFERENT_DOMAINS,INCLUDES_CR_TRAILER,INCLUDES_PATCH, MAILING_LIST_MULTI,SPF_HELO_NONE,SPF_PASS,URIBL_BLOCKED,USER_AGENT_GIT autolearn=ham autolearn_force=no version=3.4.0 Received: from mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id E6F6FC4743D for ; Tue, 8 Jun 2021 08:45:16 +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 B31A26124B for ; Tue, 8 Jun 2021 08:45:16 +0000 (UTC) DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org B31A26124B Authentication-Results: mail.kernel.org; dmarc=fail (p=none dis=none) header.from=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 B0C156EB44; Tue, 8 Jun 2021 08:45:15 +0000 (UTC) Received: from mga04.intel.com (mga04.intel.com [192.55.52.120]) by gabe.freedesktop.org (Postfix) with ESMTPS id 1E6B96EB3C; Tue, 8 Jun 2021 08:45:14 +0000 (UTC) IronPort-SDR: w/4OHnyu2y0vMkVnO1RDfCkheBMTRbCqeCFQEd+2dctQp8QsD80yqyqAK5E5jjLN9vx+3u6oDu F1lvxdhK84Jg== X-IronPort-AV: E=McAfee;i="6200,9189,10008"; a="202943843" X-IronPort-AV: E=Sophos;i="5.83,257,1616482800"; d="scan'208";a="202943843" Received: from orsmga007.jf.intel.com ([10.7.209.58]) by fmsmga104.fm.intel.com with ESMTP/TLS/ECDHE-RSA-AES256-GCM-SHA384; 08 Jun 2021 01:45:13 -0700 IronPort-SDR: pDefVqBFfu8RQtDeywTZm0PGKY6giZSrsFTMkgmW8R8edzKN988cDt+5OVey6OAacf0sYO9syN 4lEvqxQHYPgQ== X-IronPort-AV: E=Sophos;i="5.83,257,1616482800"; d="scan'208";a="440382092" Received: from mrahim1x-mobl.gar.corp.intel.com (HELO mwauld-desk1.intel.com) ([10.215.170.251]) by orsmga007-auth.jf.intel.com with ESMTP/TLS/ECDHE-RSA-AES256-GCM-SHA384; 08 Jun 2021 01:45:10 -0700 From: Matthew Auld To: intel-gfx@lists.freedesktop.org Subject: [PATCH v2 5/6] drm/i915/ttm: switch over to ttm_buddy_man Date: Tue, 8 Jun 2021 09:44:27 +0100 Message-Id: <20210608084428.142676-6-matthew.auld@intel.com> X-Mailer: git-send-email 2.26.3 In-Reply-To: <20210608084428.142676-1-matthew.auld@intel.com> References: <20210608084428.142676-1-matthew.auld@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?= , dri-devel@lists.freedesktop.org Errors-To: dri-devel-bounces@lists.freedesktop.org Sender: "dri-devel" Move back to the buddy allocator for managing device local memory, and restore the lost mock selftests. Keep around the range manager related bits, since we likely need this for managing stolen at some point. For stolen we also don't need to reserve anything so no need to support a generic reserve interface. v2(Thomas): - bo->page_alignment is in page units, not bytes Signed-off-by: Matthew Auld Cc: Thomas Hellström Reviewed-by: Thomas Hellström --- drivers/gpu/drm/i915/gem/i915_gem_ttm.c | 26 +-- drivers/gpu/drm/i915/intel_memory_region.c | 55 +----- drivers/gpu/drm/i915/intel_memory_region.h | 17 -- drivers/gpu/drm/i915/intel_region_ttm.c | 100 +++-------- .../drm/i915/selftests/intel_memory_region.c | 170 ++++++++++++------ drivers/gpu/drm/i915/selftests/mock_region.c | 15 +- 6 files changed, 168 insertions(+), 215 deletions(-) diff --git a/drivers/gpu/drm/i915/gem/i915_gem_ttm.c b/drivers/gpu/drm/i915/gem/i915_gem_ttm.c index c612275c36c9..5bf1d1945dd6 100644 --- a/drivers/gpu/drm/i915/gem/i915_gem_ttm.c +++ b/drivers/gpu/drm/i915/gem/i915_gem_ttm.c @@ -181,11 +181,7 @@ static bool i915_ttm_eviction_valuable(struct ttm_buffer_object *bo, struct drm_i915_gem_object *obj = i915_ttm_to_gem(bo); /* Will do for now. Our pinned objects are still on TTM's LRU lists */ - if (!i915_gem_object_evictable(obj)) - return false; - - /* This isn't valid with a buddy allocator */ - return ttm_bo_eviction_valuable(bo, place); + return i915_gem_object_evictable(obj); } static void i915_ttm_evict_flags(struct ttm_buffer_object *bo, @@ -328,11 +324,15 @@ i915_ttm_resource_get_st(struct drm_i915_gem_object *obj, struct ttm_buffer_object *bo = i915_gem_to_ttm(obj); struct ttm_resource_manager *man = ttm_manager_type(bo->bdev, res->mem_type); + struct intel_memory_region *mr = obj->mm.region; if (man->use_tt) return i915_ttm_tt_get_st(bo->ttm); - return intel_region_ttm_node_to_st(obj->mm.region, res->mm_node); + if (mr->is_range_manager) + return intel_region_ttm_node_to_st(mr, res); + else + return i915_sg_from_buddy_resource(res, mr->region.start); } static int i915_ttm_move(struct ttm_buffer_object *bo, bool evict, @@ -657,20 +657,8 @@ int __i915_gem_ttm_object_init(struct intel_memory_region *mem, static struct lock_class_key lock_class; struct drm_i915_private *i915 = mem->i915; enum ttm_bo_type bo_type; - size_t alignment = 0; int ret; - /* Adjust alignment to GPU- and CPU huge page sizes. */ - - if (mem->is_range_manager) { - if (size >= SZ_1G) - alignment = SZ_1G >> PAGE_SHIFT; - else if (size >= SZ_2M) - alignment = SZ_2M >> PAGE_SHIFT; - else if (size >= SZ_64K) - alignment = SZ_64K >> PAGE_SHIFT; - } - drm_gem_private_object_init(&i915->drm, &obj->base, size); i915_gem_object_init(obj, &i915_gem_ttm_obj_ops, &lock_class, flags); i915_gem_object_init_memory_region(obj, mem); @@ -692,7 +680,7 @@ int __i915_gem_ttm_object_init(struct intel_memory_region *mem, */ obj->base.vma_node.driver_private = i915_gem_to_ttm(obj); ret = ttm_bo_init(&i915->bdev, i915_gem_to_ttm(obj), size, - bo_type, &i915_sys_placement, alignment, + bo_type, &i915_sys_placement, 1, true, NULL, NULL, i915_ttm_bo_destroy); if (!ret) diff --git a/drivers/gpu/drm/i915/intel_memory_region.c b/drivers/gpu/drm/i915/intel_memory_region.c index 12fb5423fd5e..df59f884d37c 100644 --- a/drivers/gpu/drm/i915/intel_memory_region.c +++ b/drivers/gpu/drm/i915/intel_memory_region.c @@ -5,6 +5,7 @@ #include "intel_memory_region.h" #include "i915_drv.h" +#include "i915_ttm_buddy_manager.h" static const struct { u16 class; @@ -28,11 +29,6 @@ static const struct { }, }; -struct intel_region_reserve { - struct list_head link; - struct ttm_resource *res; -}; - struct intel_memory_region * intel_memory_region_lookup(struct drm_i915_private *i915, u16 class, u16 instance) @@ -63,27 +59,6 @@ intel_memory_region_by_type(struct drm_i915_private *i915, return NULL; } -/** - * 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 intel_region_reserve *reserve, *next; - - if (!mem->priv_ops || !mem->priv_ops->free) - return; - - mutex_lock(&mem->mm_lock); - list_for_each_entry_safe(reserve, next, &mem->reserved, link) { - list_del(&reserve->link); - mem->priv_ops->free(mem, reserve->res); - kfree(reserve); - } - mutex_unlock(&mem->mm_lock); -} - /** * intel_memory_region_reserve - Reserve a memory range * @mem: The region for which we want to reserve a range. @@ -96,28 +71,11 @@ int intel_memory_region_reserve(struct intel_memory_region *mem, resource_size_t offset, resource_size_t size) { - int ret; - struct intel_region_reserve *reserve; - - if (!mem->priv_ops || !mem->priv_ops->reserve) - return -EINVAL; - - reserve = kzalloc(sizeof(*reserve), GFP_KERNEL); - if (!reserve) - return -ENOMEM; + struct ttm_resource_manager *man = mem->region_private; - reserve->res = mem->priv_ops->reserve(mem, offset, size); - if (IS_ERR(reserve->res)) { - ret = PTR_ERR(reserve->res); - kfree(reserve); - return ret; - } - - mutex_lock(&mem->mm_lock); - list_add_tail(&reserve->link, &mem->reserved); - mutex_unlock(&mem->mm_lock); + GEM_BUG_ON(mem->is_range_manager); - return 0; + return i915_ttm_buddy_man_reserve(man, offset, size); } struct intel_memory_region * @@ -149,9 +107,6 @@ intel_memory_region_create(struct drm_i915_private *i915, mutex_init(&mem->objects.lock); INIT_LIST_HEAD(&mem->objects.list); - INIT_LIST_HEAD(&mem->reserved); - - mutex_init(&mem->mm_lock); if (ops->init) { err = ops->init(mem); @@ -182,11 +137,9 @@ 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); - mutex_destroy(&mem->mm_lock); mutex_destroy(&mem->objects.lock); kfree(mem); } diff --git a/drivers/gpu/drm/i915/intel_memory_region.h b/drivers/gpu/drm/i915/intel_memory_region.h index c7e635d62e1a..b04fb22726d9 100644 --- a/drivers/gpu/drm/i915/intel_memory_region.h +++ b/drivers/gpu/drm/i915/intel_memory_region.h @@ -59,19 +59,10 @@ struct intel_memory_region_ops { unsigned int flags); }; -struct intel_memory_region_private_ops { - struct ttm_resource *(*reserve)(struct intel_memory_region *mem, - resource_size_t offset, - resource_size_t size); - void (*free)(struct intel_memory_region *mem, - struct ttm_resource *res); -}; - 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; @@ -79,8 +70,6 @@ struct intel_memory_region { /* For fake LMEM */ struct drm_mm_node fake_mappable; - struct mutex mm_lock; - struct kref kref; resource_size_t io_start; @@ -94,8 +83,6 @@ struct intel_memory_region { char name[16]; bool private; /* not for userspace */ - struct list_head reserved; - dma_addr_t remap_addr; struct { @@ -103,8 +90,6 @@ struct intel_memory_region { struct list_head list; } objects; - size_t chunk_size; - unsigned int max_order; bool is_range_manager; void *region_private; @@ -138,8 +123,6 @@ __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); diff --git a/drivers/gpu/drm/i915/intel_region_ttm.c b/drivers/gpu/drm/i915/intel_region_ttm.c index 5a664f6cc93f..23a1336d2335 100644 --- a/drivers/gpu/drm/i915/intel_region_ttm.c +++ b/drivers/gpu/drm/i915/intel_region_ttm.c @@ -8,6 +8,7 @@ #include "i915_drv.h" #include "i915_scatterlist.h" +#include "i915_ttm_buddy_manager.h" #include "intel_region_ttm.h" @@ -67,72 +68,17 @@ int intel_region_to_ttm_type(const struct intel_memory_region *mem) return type; } -static struct ttm_resource * -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_buffer_object mock_bo = {}; - struct ttm_resource *res; - 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); - mock_bo.base.size = size; - ret = man->func->alloc(man, &mock_bo, &place, &res); - if (ret == -ENOSPC) - ret = -ENXIO; - - return ret ? ERR_PTR(ret) : res; -} - -/** - * 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, - struct ttm_resource *res) -{ - struct ttm_resource_manager *man = mem->region_private; - - 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, -}; - int intel_region_ttm_init(struct intel_memory_region *mem) { struct ttm_device *bdev = &mem->i915->bdev; int mem_type = intel_region_to_ttm_type(mem); int ret; - ret = ttm_range_man_init(bdev, mem_type, false, - resource_size(&mem->region) >> PAGE_SHIFT); + ret = i915_ttm_buddy_man_init(bdev, mem_type, false, + resource_size(&mem->region), PAGE_SIZE); if (ret) return ret; - 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 = ttm_manager_type(bdev, mem_type); return 0; @@ -150,8 +96,8 @@ void intel_region_ttm_fini(struct intel_memory_region *mem) { int ret; - ret = ttm_range_man_fini(&mem->i915->bdev, - intel_region_to_ttm_type(mem)); + ret = i915_ttm_buddy_man_fini(&mem->i915->bdev, + intel_region_to_ttm_type(mem)); GEM_WARN_ON(ret); mem->region_private = NULL; } @@ -206,25 +152,33 @@ intel_region_ttm_node_alloc(struct intel_memory_region *mem, struct ttm_resource *res; 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. - */ mock_bo.base.size = size; - - 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; - } + mock_bo.page_alignment = 1; + place.flags = flags; ret = man->func->alloc(man, &mock_bo, &place, &res); if (ret == -ENOSPC) ret = -ENXIO; return ret ? ERR_PTR(ret) : res; } + #endif + +/** + * 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. + */ +void intel_region_ttm_node_free(struct intel_memory_region *mem, + struct ttm_resource *res) +{ + struct ttm_resource_manager *man = mem->region_private; + + man->func->free(man, res); +} diff --git a/drivers/gpu/drm/i915/selftests/intel_memory_region.c b/drivers/gpu/drm/i915/selftests/intel_memory_region.c index c85d516b85cd..dc23d699ecb5 100644 --- a/drivers/gpu/drm/i915/selftests/intel_memory_region.c +++ b/drivers/gpu/drm/i915/selftests/intel_memory_region.c @@ -20,7 +20,9 @@ #include "gem/selftests/mock_context.h" #include "gt/intel_engine_user.h" #include "gt/intel_gt.h" +#include "i915_buddy.h" #include "i915_memcpy.h" +#include "i915_ttm_buddy_manager.h" #include "selftests/igt_flush_test.h" #include "selftests/i915_random.h" @@ -57,10 +59,9 @@ static int igt_mock_fill(void *arg) LIST_HEAD(objects); int err = 0; - page_size = mem->chunk_size; + page_size = PAGE_SIZE; + max_pages = div64_u64(total, page_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; @@ -86,11 +87,6 @@ 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; @@ -157,6 +153,7 @@ static bool is_contiguous(struct drm_i915_gem_object *obj) static int igt_mock_reserve(void *arg) { struct intel_memory_region *mem = arg; + struct drm_i915_private *i915 = mem->i915; resource_size_t avail = resource_size(&mem->region); struct drm_i915_gem_object *obj; const u32 chunk_size = SZ_32M; @@ -166,16 +163,18 @@ static int igt_mock_reserve(void *arg) LIST_HEAD(objects); int err = 0; - if (!list_empty(&mem->reserved)) { - pr_err("%s region reserved list is not empty\n", __func__); - return -EINVAL; - } - count = avail / chunk_size; order = i915_random_order(count, &prng); if (!order) return 0; + mem = mock_region_create(i915, 0, SZ_2G, I915_GTT_PAGE_SIZE_4K, 0); + if (IS_ERR(mem)) { + pr_err("failed to create memory region\n"); + err = PTR_ERR(mem); + goto out_close; + } + /* Reserve a bunch of ranges within the region */ for (i = 0; i < count; ++i) { u64 start = order[i] * chunk_size; @@ -205,18 +204,12 @@ 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 (mem->is_range_manager && - size > mem->chunk_size) { - size >>= 1; - goto retry; - } + if (PTR_ERR(obj) == -ENXIO) break; - } + err = PTR_ERR(obj); goto out_close; } @@ -232,7 +225,7 @@ static int igt_mock_reserve(void *arg) out_close: kfree(order); close_objects(mem, &objects); - intel_memory_region_unreserve(mem); + intel_memory_region_put(mem); return err; } @@ -252,7 +245,7 @@ static int igt_mock_contiguous(void *arg) total = resource_size(&mem->region); /* Min size */ - obj = igt_object_create(mem, &objects, mem->chunk_size, + obj = igt_object_create(mem, &objects, PAGE_SIZE, I915_BO_ALLOC_CONTIGUOUS); if (IS_ERR(obj)) return PTR_ERR(obj); @@ -333,17 +326,15 @@ static int igt_mock_contiguous(void *arg) min = target; target = total >> 1; - 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); + /* 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); + /* * Even though we have enough free space, we don't have a big enough * contiguous block. Make sure that holds true. @@ -362,7 +353,7 @@ static int igt_mock_contiguous(void *arg) } target >>= 1; - } while (target >= mem->chunk_size); + } while (target >= PAGE_SIZE); err_close_objects: list_splice_tail(&holes, &objects); @@ -374,7 +365,9 @@ static int igt_mock_splintered_region(void *arg) { struct intel_memory_region *mem = arg; struct drm_i915_private *i915 = mem->i915; + struct i915_ttm_buddy_resource *res; struct drm_i915_gem_object *obj; + struct i915_buddy_mm *mm; unsigned int expected_order; LIST_HEAD(objects); u64 size; @@ -382,7 +375,7 @@ static int igt_mock_splintered_region(void *arg) /* * Sanity check we can still allocate everything even if the - * max_order != mm.size. i.e our starting address space size is not a + * mm.max_order != mm.size. i.e our starting address space size is not a * power-of-two. */ @@ -391,20 +384,29 @@ static int igt_mock_splintered_region(void *arg) if (IS_ERR(mem)) return PTR_ERR(mem); - expected_order = get_order(rounddown_pow_of_two(size)); - if (mem->max_order != expected_order) { - pr_err("%s order mismatch(%u != %u)\n", - __func__, mem->max_order, expected_order); - err = -EINVAL; - goto out_put; - } - obj = igt_object_create(mem, &objects, size, 0); if (IS_ERR(obj)) { err = PTR_ERR(obj); goto out_close; } + res = to_ttm_buddy_resource(obj->mm.st_mm_node); + mm = res->mm; + if (mm->size != size) { + pr_err("%s size mismatch(%llu != %llu)\n", + __func__, mm->size, size); + err = -EINVAL; + goto out_put; + } + + expected_order = get_order(rounddown_pow_of_two(size)); + if (mm->max_order != expected_order) { + pr_err("%s order mismatch(%u != %u)\n", + __func__, mm->max_order, expected_order); + err = -EINVAL; + goto out_put; + } + close_objects(mem, &objects); /* @@ -415,15 +417,12 @@ static int igt_mock_splintered_region(void *arg) * sure that does indeed hold true. */ - 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, 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), @@ -442,6 +441,74 @@ 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 i915_ttm_buddy_resource *res; + struct drm_i915_gem_object *obj; + struct i915_buddy_block *block; + struct i915_buddy_mm *mm; + struct list_head *blocks; + 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; + } + + res = to_ttm_buddy_resource(obj->mm.st_mm_node); + blocks = &res->blocks; + mm = res->mm; + size = 0; + list_for_each_entry(block, blocks, link) { + if (i915_buddy_block_size(mm, block) > size) + size = i915_buddy_block_size(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, @@ -1046,6 +1113,7 @@ 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 eafc5a04975c..d3e4e6573cb9 100644 --- a/drivers/gpu/drm/i915/selftests/mock_region.c +++ b/drivers/gpu/drm/i915/selftests/mock_region.c @@ -3,6 +3,7 @@ * Copyright © 2019-2021 Intel Corporation */ +#include #include #include @@ -25,10 +26,11 @@ static int mock_region_get_pages(struct drm_i915_gem_object *obj) { unsigned int flags; struct sg_table *pages; + int err; flags = I915_ALLOC_MIN_PAGE_SIZE; if (obj->flags & I915_BO_ALLOC_CONTIGUOUS) - flags |= I915_ALLOC_CONTIGUOUS; + flags |= TTM_PL_FLAG_CONTIGUOUS; obj->mm.st_mm_node = intel_region_ttm_node_alloc(obj->mm.region, obj->base.size, @@ -36,15 +38,20 @@ static int mock_region_get_pages(struct drm_i915_gem_object *obj) 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); + pages = i915_sg_from_buddy_resource(obj->mm.st_mm_node, + obj->mm.region->region.start); if (IS_ERR(pages)) { - intel_region_ttm_node_free(obj->mm.region, obj->mm.st_mm_node); - return PTR_ERR(pages); + err = PTR_ERR(pages); + goto err_free_mm_node; } __i915_gem_object_set_pages(obj, pages, i915_sg_dma_sizes(pages->sgl)); return 0; + +err_free_mm_node: + intel_region_ttm_node_free(obj->mm.region, obj->mm.st_mm_node); + return err; } static const struct drm_i915_gem_object_ops mock_region_obj_ops = { -- 2.26.3