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 22692C48BE6 for ; Mon, 14 Jun 2021 17:43:41 +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 E3EBB61378 for ; Mon, 14 Jun 2021 17:43:40 +0000 (UTC) DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org E3EBB61378 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 168296E0DF; Mon, 14 Jun 2021 17:43:28 +0000 (UTC) Received: from mga04.intel.com (mga04.intel.com [192.55.52.120]) by gabe.freedesktop.org (Postfix) with ESMTPS id 3DAFB6E0D5; Mon, 14 Jun 2021 17:43:27 +0000 (UTC) IronPort-SDR: EqW/R+bQYLudUfhAAVnwL8yy+tVH3sCQV8qf+1ZAoUR6/ex5Hp/uCFmbvSQQP8xnLDndnAES8j iTLYLATwhcBw== X-IronPort-AV: E=McAfee;i="6200,9189,10015"; a="204020419" X-IronPort-AV: E=Sophos;i="5.83,273,1616482800"; d="scan'208";a="204020419" Received: from fmsmga008.fm.intel.com ([10.253.24.58]) by fmsmga104.fm.intel.com with ESMTP/TLS/ECDHE-RSA-AES256-GCM-SHA384; 14 Jun 2021 10:43:25 -0700 IronPort-SDR: vMbnwN9aFVSU7SmEBjN6lz+JzMZTiooqgWAhGvQCyCAs+2622+2WiGmhyRNCBUEe/F2exQtxaY 4WbrV32Z5p/w== X-IronPort-AV: E=Sophos;i="5.83,273,1616482800"; d="scan'208";a="451666859" Received: from fnygreen-mobl1.ger.corp.intel.com (HELO thellst-mobl1.intel.com) ([10.249.254.50]) by fmsmga008-auth.fm.intel.com with ESMTP/TLS/ECDHE-RSA-AES256-GCM-SHA384; 14 Jun 2021 10:43:04 -0700 From: =?UTF-8?q?Thomas=20Hellstr=C3=B6m?= To: intel-gfx@lists.freedesktop.org, dri-devel@lists.freedesktop.org Date: Mon, 14 Jun 2021 19:42:44 +0200 Message-Id: <20210614174246.403854-3-thomas.hellstrom@linux.intel.com> X-Mailer: git-send-email 2.31.1 In-Reply-To: <20210614174246.403854-1-thomas.hellstrom@linux.intel.com> References: <20210614174246.403854-1-thomas.hellstrom@linux.intel.com> MIME-Version: 1.0 Subject: [Intel-gfx] [PATCH v5 2/4] drm/i915/ttm: Adjust gem flags and caching settings after a move X-BeenThere: intel-gfx@lists.freedesktop.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: Intel graphics driver community testing & development List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Cc: =?UTF-8?q?Thomas=20Hellstr=C3=B6m?= , matthew.auld@intel.com Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Errors-To: intel-gfx-bounces@lists.freedesktop.org Sender: "Intel-gfx" QWZ0ZXIgYSBUVE0gbW92ZSBvciBvYmplY3QgaW5pdCB3ZSBuZWVkIHRvIHVwZGF0ZSB0aGUgaTkx NSBnZW0gZmxhZ3MgYW5kCmNhY2hpbmcgc2V0dGluZ3MgdG8gcmVmbGVjdCB0aGUgbmV3IHBsYWNl bWVudC4gQ3VycmVudGx5IGNhY2hpbmcgc2V0dGluZ3MKYXJlIG5vdCBjaGFuZ2VkIGR1cmluZyB0 aGUgbGlmZXRpbWUgb2YgYW4gb2JqZWN0LCBhbHRob3VnaCB0aGF0IG1pZ2h0CmNoYW5nZSBtb3Zp bmcgZm9yd2FyZCBpZiB3ZSBydW4gaW50byBwZXJmb3JtYW5jZSBpc3N1ZXMgb3IgaXNzdWVzIHdp dGgKV0Mgc3lzdGVtIHBhZ2UgYWxsb2NhdGlvbnMuCkFsc28gaW50cm9kdWNlIGdwdV9iaW5kc19p b21lbSgpIGFuZCBjcHVfbWFwc19pb21lbSgpIHRvIGNsZWFuIHVwIHRoZQp2YXJpb3VzIHdheXMg d2UgcHJldmlvdXNseSB1c2VkIHRvIGRldGVjdCB0aGlzLgpGaW5hbGx5LCBpbml0aWFsaXplIHRo ZSBUVE0gb2JqZWN0IHJlc2VydmVkIHRvIGJlIGFibGUgdG8gdXBkYXRlCmZsYWdzIGFuZCBjYWNo aW5nIGJlZm9yZSBhbnlvbmUgZWxzZSBnZXRzIGhvbGQgb2YgdGhlIG9iamVjdC4KClNpZ25lZC1v ZmYtYnk6IFRob21hcyBIZWxsc3Ryw7ZtIDx0aG9tYXMuaGVsbHN0cm9tQGxpbnV4LmludGVsLmNv bT4KUmV2aWV3ZWQtYnk6IE1hdHRoZXcgQXVsZCA8bWF0dGhldy5hdWxkQGludGVsLmNvbT4KLS0t CnYyOgotIFN0eWxlIGZpeGVzIChSZXBvcnRlZCBieSBNYXR0aGV3IEF1bGQpCnYzOgotIE1vcmUg c3R5bGUgZml4ZXMuIENsYXJpZnkgd2h5IHdlJ3JlIHVwZGF0aW5nIGNhY2hpbmcgc2V0dGluZ3Mg YWZ0ZXIgbW92ZS4KICAoU3VnZ2VzdGVkIGJ5IE1hdHRoZXcgQXVsZCkKdjU6Ci0gRml4IGNvbmZ1 c2lvbiBhcm91bmQgc2hyaW5rYWJsZSBUVE0gb2JqZWN0IGluIHRoZSBjb3JyZWN0IHBhdGNoLgog IChTdWdnZXN0ZWQgYnkgTWF0dGhldyBBdWxkKQotLS0KIGRyaXZlcnMvZ3B1L2RybS9pOTE1L2dl bS9pOTE1X2dlbV90dG0uYyB8IDExMCArKysrKysrKysrKysrKysrKysrLS0tLS0KIDEgZmlsZSBj aGFuZ2VkLCA4OCBpbnNlcnRpb25zKCspLCAyMiBkZWxldGlvbnMoLSkKCmRpZmYgLS1naXQgYS9k cml2ZXJzL2dwdS9kcm0vaTkxNS9nZW0vaTkxNV9nZW1fdHRtLmMgYi9kcml2ZXJzL2dwdS9kcm0v aTkxNS9nZW0vaTkxNV9nZW1fdHRtLmMKaW5kZXggMzNhYjQ3ZjFlMDViLi4zNzdiYzNhYWY0NTYg MTAwNjQ0Ci0tLSBhL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2dlbS9pOTE1X2dlbV90dG0uYworKysg Yi9kcml2ZXJzL2dwdS9kcm0vaTkxNS9nZW0vaTkxNV9nZW1fdHRtLmMKQEAgLTcwLDYgKzcwLDE3 IEBAIHN0YXRpYyBzdHJ1Y3QgdHRtX3BsYWNlbWVudCBpOTE1X3N5c19wbGFjZW1lbnQgPSB7CiAJ LmJ1c3lfcGxhY2VtZW50ID0gJmxtZW0wX3N5c19wbGFjZW1lbnRfZmxhZ3NbMV0sCiB9OwogCitz dGF0aWMgYm9vbCBncHVfYmluZHNfaW9tZW0oc3RydWN0IHR0bV9yZXNvdXJjZSAqbWVtKQorewor CXJldHVybiBtZW0tPm1lbV90eXBlICE9IFRUTV9QTF9TWVNURU07Cit9CisKK3N0YXRpYyBib29s IGNwdV9tYXBzX2lvbWVtKHN0cnVjdCB0dG1fcmVzb3VyY2UgKm1lbSkKK3sKKwkvKiBPbmNlIC8g aWYgd2Ugc3VwcG9ydCBHR1RULCB0aGlzIGlzIGFsc28gZmFsc2UgZm9yIGNhY2hlZCB0dG1fdHRz ICovCisJcmV0dXJuIG1lbS0+bWVtX3R5cGUgIT0gVFRNX1BMX1NZU1RFTTsKK30KKwogc3RhdGlj IHZvaWQgaTkxNV90dG1fYWRqdXN0X2xydShzdHJ1Y3QgZHJtX2k5MTVfZ2VtX29iamVjdCAqb2Jq KTsKIAogc3RhdGljIHN0cnVjdCB0dG1fdHQgKmk5MTVfdHRtX3R0X2NyZWF0ZShzdHJ1Y3QgdHRt X2J1ZmZlcl9vYmplY3QgKmJvLApAQCAtMTc1LDYgKzE4Niw0MCBAQCBzdGF0aWMgdm9pZCBpOTE1 X3R0bV9mcmVlX2NhY2hlZF9pb19zdChzdHJ1Y3QgZHJtX2k5MTVfZ2VtX29iamVjdCAqb2JqKQog CW9iai0+dHRtLmNhY2hlZF9pb19zdCA9IE5VTEw7CiB9CiAKK3N0YXRpYyB2b2lkCitpOTE1X3R0 bV9hZGp1c3RfZG9tYWluc19hZnRlcl9jcHVfbW92ZShzdHJ1Y3QgZHJtX2k5MTVfZ2VtX29iamVj dCAqb2JqKQoreworCXN0cnVjdCB0dG1fYnVmZmVyX29iamVjdCAqYm8gPSBpOTE1X2dlbV90b190 dG0ob2JqKTsKKworCWlmIChjcHVfbWFwc19pb21lbShiby0+cmVzb3VyY2UpIHx8IGJvLT50dG0t PmNhY2hpbmcgIT0gdHRtX2NhY2hlZCkgeworCQlvYmotPndyaXRlX2RvbWFpbiA9IEk5MTVfR0VN X0RPTUFJTl9XQzsKKwkJb2JqLT5yZWFkX2RvbWFpbnMgPSBJOTE1X0dFTV9ET01BSU5fV0M7CisJ fSBlbHNlIHsKKwkJb2JqLT53cml0ZV9kb21haW4gPSBJOTE1X0dFTV9ET01BSU5fQ1BVOworCQlv YmotPnJlYWRfZG9tYWlucyA9IEk5MTVfR0VNX0RPTUFJTl9DUFU7CisJfQorfQorCitzdGF0aWMg dm9pZCBpOTE1X3R0bV9hZGp1c3RfZ2VtX2FmdGVyX21vdmUoc3RydWN0IGRybV9pOTE1X2dlbV9v YmplY3QgKm9iaikKK3sKKwlzdHJ1Y3QgZHJtX2k5MTVfcHJpdmF0ZSAqaTkxNSA9IHRvX2k5MTUo b2JqLT5iYXNlLmRldik7CisJc3RydWN0IHR0bV9idWZmZXJfb2JqZWN0ICpibyA9IGk5MTVfZ2Vt X3RvX3R0bShvYmopOworCXVuc2lnbmVkIGludCBjYWNoZV9sZXZlbDsKKworCW9iai0+bWVtX2Zs YWdzICY9IH4oSTkxNV9CT19GTEFHX1NUUlVDVF9QQUdFIHwgSTkxNV9CT19GTEFHX0lPTUVNKTsK KworCW9iai0+bWVtX2ZsYWdzIHw9IGNwdV9tYXBzX2lvbWVtKGJvLT5yZXNvdXJjZSkgPyBJOTE1 X0JPX0ZMQUdfSU9NRU0gOgorCQlJOTE1X0JPX0ZMQUdfU1RSVUNUX1BBR0U7CisKKwlpZiAoKEhB U19MTEMoaTkxNSkgfHwgSEFTX1NOT09QKGk5MTUpKSAmJiAhZ3B1X2JpbmRzX2lvbWVtKGJvLT5y ZXNvdXJjZSkgJiYKKwkgICAgYm8tPnR0bS0+Y2FjaGluZyA9PSB0dG1fY2FjaGVkKQorCQljYWNo ZV9sZXZlbCA9IEk5MTVfQ0FDSEVfTExDOworCWVsc2UKKwkJY2FjaGVfbGV2ZWwgPSBJOTE1X0NB Q0hFX05PTkU7CisKKwlpOTE1X2dlbV9vYmplY3Rfc2V0X2NhY2hlX2NvaGVyZW5jeShvYmosIGNh Y2hlX2xldmVsKTsKK30KKwogc3RhdGljIHZvaWQgaTkxNV90dG1fcHVyZ2Uoc3RydWN0IGRybV9p OTE1X2dlbV9vYmplY3QgKm9iaikKIHsKIAlzdHJ1Y3QgdHRtX2J1ZmZlcl9vYmplY3QgKmJvID0g aTkxNV9nZW1fdG9fdHRtKG9iaik7CkBAIC0xOTAsOCArMjM1LDEwIEBAIHN0YXRpYyB2b2lkIGk5 MTVfdHRtX3B1cmdlKHN0cnVjdCBkcm1faTkxNV9nZW1fb2JqZWN0ICpvYmopCiAKIAkvKiBUVE0n cyBwdXJnZSBpbnRlcmZhY2UuIE5vdGUgdGhhdCB3ZSBtaWdodCBiZSByZWVudGVyaW5nLiAqLwog CXJldCA9IHR0bV9ib192YWxpZGF0ZShibywgJnBsYWNlLCAmY3R4KTsKLQogCWlmICghcmV0KSB7 CisJCW9iai0+d3JpdGVfZG9tYWluID0gMDsKKwkJb2JqLT5yZWFkX2RvbWFpbnMgPSAwOworCQlp OTE1X3R0bV9hZGp1c3RfZ2VtX2FmdGVyX21vdmUob2JqKTsKIAkJaTkxNV90dG1fZnJlZV9jYWNo ZWRfaW9fc3Qob2JqKTsKIAkJb2JqLT5tbS5tYWR2ID0gX19JOTE1X01BRFZfUFVSR0VEOwogCX0K QEAgLTI3MywxMiArMzIwLDE1IEBAIGk5MTVfdHRtX3Jlc291cmNlX2dldF9zdChzdHJ1Y3QgZHJt X2k5MTVfZ2VtX29iamVjdCAqb2JqLAogCQkJIHN0cnVjdCB0dG1fcmVzb3VyY2UgKnJlcykKIHsK IAlzdHJ1Y3QgdHRtX2J1ZmZlcl9vYmplY3QgKmJvID0gaTkxNV9nZW1fdG9fdHRtKG9iaik7Ci0J c3RydWN0IHR0bV9yZXNvdXJjZV9tYW5hZ2VyICptYW4gPQotCQl0dG1fbWFuYWdlcl90eXBlKGJv LT5iZGV2LCByZXMtPm1lbV90eXBlKTsKIAotCWlmIChtYW4tPnVzZV90dCkKKwlpZiAoIWdwdV9i aW5kc19pb21lbShyZXMpKQogCQlyZXR1cm4gaTkxNV90dG1fdHRfZ2V0X3N0KGJvLT50dG0pOwog CisJLyoKKwkgKiBJZiBDUFUgbWFwcGluZyBkaWZmZXJzLCB3ZSBuZWVkIHRvIGFkZCB0aGUgdHRt X3R0IHBhZ2VzIHRvCisJICogdGhlIHJlc3VsdGluZyBzdC4gTWlnaHQgbWFrZSBzZW5zZSBmb3Ig R0dUVC4KKwkgKi8KKwlHRU1fV0FSTl9PTighY3B1X21hcHNfaW9tZW0ocmVzKSk7CiAJcmV0dXJu IGludGVsX3JlZ2lvbl90dG1fbm9kZV90b19zdChvYmotPm1tLnJlZ2lvbiwgcmVzKTsKIH0KIApA QCAtMjkwLDggKzM0MCw2IEBAIHN0YXRpYyBpbnQgaTkxNV90dG1fbW92ZShzdHJ1Y3QgdHRtX2J1 ZmZlcl9vYmplY3QgKmJvLCBib29sIGV2aWN0LAogCXN0cnVjdCBkcm1faTkxNV9nZW1fb2JqZWN0 ICpvYmogPSBpOTE1X3R0bV90b19nZW0oYm8pOwogCXN0cnVjdCB0dG1fcmVzb3VyY2VfbWFuYWdl ciAqZHN0X21hbiA9CiAJCXR0bV9tYW5hZ2VyX3R5cGUoYm8tPmJkZXYsIGRzdF9tZW0tPm1lbV90 eXBlKTsKLQlzdHJ1Y3QgdHRtX3Jlc291cmNlX21hbmFnZXIgKnNyY19tYW4gPQotCQl0dG1fbWFu YWdlcl90eXBlKGJvLT5iZGV2LCBiby0+cmVzb3VyY2UtPm1lbV90eXBlKTsKIAlzdHJ1Y3QgaW50 ZWxfbWVtb3J5X3JlZ2lvbiAqZHN0X3JlZywgKnNyY19yZWc7CiAJdW5pb24gewogCQlzdHJ1Y3Qg dHRtX2ttYXBfaXRlcl90dCB0dDsKQEAgLTMzMiwzNCArMzgwLDM2IEBAIHN0YXRpYyBpbnQgaTkx NV90dG1fbW92ZShzdHJ1Y3QgdHRtX2J1ZmZlcl9vYmplY3QgKmJvLCBib29sIGV2aWN0LAogCWlm IChJU19FUlIoZHN0X3N0KSkKIAkJcmV0dXJuIFBUUl9FUlIoZHN0X3N0KTsKIAotCS8qIElmIHdl IHN0YXJ0IG1hcHBpbmcgR0dUVCwgd2UgY2FuIG5vIGxvbmdlciB1c2UgbWFuOjp1c2VfdHQgaGVy ZS4gKi8KLQlkc3RfaXRlciA9IGRzdF9tYW4tPnVzZV90dCA/CisJZHN0X2l0ZXIgPSAhY3B1X21h cHNfaW9tZW0oZHN0X21lbSkgPwogCQl0dG1fa21hcF9pdGVyX3R0X2luaXQoJl9kc3RfaXRlci50 dCwgYm8tPnR0bSkgOgogCQl0dG1fa21hcF9pdGVyX2lvbWFwX2luaXQoJl9kc3RfaXRlci5pbywg JmRzdF9yZWctPmlvbWFwLAogCQkJCQkgZHN0X3N0LCBkc3RfcmVnLT5yZWdpb24uc3RhcnQpOwog Ci0Jc3JjX2l0ZXIgPSBzcmNfbWFuLT51c2VfdHQgPworCXNyY19pdGVyID0gIWNwdV9tYXBzX2lv bWVtKGJvLT5yZXNvdXJjZSkgPwogCQl0dG1fa21hcF9pdGVyX3R0X2luaXQoJl9zcmNfaXRlci50 dCwgYm8tPnR0bSkgOgogCQl0dG1fa21hcF9pdGVyX2lvbWFwX2luaXQoJl9zcmNfaXRlci5pbywg JnNyY19yZWctPmlvbWFwLAogCQkJCQkgb2JqLT50dG0uY2FjaGVkX2lvX3N0LAogCQkJCQkgc3Jj X3JlZy0+cmVnaW9uLnN0YXJ0KTsKIAogCXR0bV9tb3ZlX21lbWNweShibywgZHN0X21lbS0+bnVt X3BhZ2VzLCBkc3RfaXRlciwgc3JjX2l0ZXIpOworCS8qIEJlbG93IGRzdF9tZW0gYmVjb21lcyBi by0+cmVzb3VyY2UuICovCiAJdHRtX2JvX21vdmVfc3luY19jbGVhbnVwKGJvLCBkc3RfbWVtKTsK KwlpOTE1X3R0bV9hZGp1c3RfZG9tYWluc19hZnRlcl9jcHVfbW92ZShvYmopOwogCWk5MTVfdHRt X2ZyZWVfY2FjaGVkX2lvX3N0KG9iaik7CiAKLQlpZiAoIWRzdF9tYW4tPnVzZV90dCkgeworCWlm IChncHVfYmluZHNfaW9tZW0oZHN0X21lbSkgfHwgY3B1X21hcHNfaW9tZW0oZHN0X21lbSkpIHsK IAkJb2JqLT50dG0uY2FjaGVkX2lvX3N0ID0gZHN0X3N0OwogCQlvYmotPnR0bS5nZXRfaW9fcGFn ZS5zZ19wb3MgPSBkc3Rfc3QtPnNnbDsKIAkJb2JqLT50dG0uZ2V0X2lvX3BhZ2Uuc2dfaWR4ID0g MDsKIAl9CiAKKwlpOTE1X3R0bV9hZGp1c3RfZ2VtX2FmdGVyX21vdmUob2JqKTsKIAlyZXR1cm4g MDsKIH0KIAogc3RhdGljIGludCBpOTE1X3R0bV9pb19tZW1fcmVzZXJ2ZShzdHJ1Y3QgdHRtX2Rl dmljZSAqYmRldiwgc3RydWN0IHR0bV9yZXNvdXJjZSAqbWVtKQogewotCWlmIChtZW0tPm1lbV90 eXBlIDwgSTkxNV9QTF9MTUVNMCkKKwlpZiAoIWNwdV9tYXBzX2lvbWVtKG1lbSkpCiAJCXJldHVy biAwOwogCiAJbWVtLT5idXMuY2FjaGluZyA9IHR0bV93cml0ZV9jb21iaW5lZDsKQEAgLTQyMSw2 ICs0NzEsMTYgQEAgc3RhdGljIGludCBpOTE1X3R0bV9nZXRfcGFnZXMoc3RydWN0IGRybV9pOTE1 X2dlbV9vYmplY3QgKm9iaikKIAlpZiAocmV0KQogCQlyZXR1cm4gcmV0ID09IC1FTk9TUEMgPyAt RU5YSU8gOiByZXQ7CiAKKwlpOTE1X3R0bV9hZGp1c3RfbHJ1KG9iaik7CisJaWYgKGJvLT50dG0g JiYgIXR0bV90dF9pc19wb3B1bGF0ZWQoYm8tPnR0bSkpIHsKKwkJcmV0ID0gdHRtX3R0X3BvcHVs YXRlKGJvLT5iZGV2LCBiby0+dHRtLCAmY3R4KTsKKwkJaWYgKHJldCkKKwkJCXJldHVybiByZXQ7 CisKKwkJaTkxNV90dG1fYWRqdXN0X2RvbWFpbnNfYWZ0ZXJfY3B1X21vdmUob2JqKTsKKwkJaTkx NV90dG1fYWRqdXN0X2dlbV9hZnRlcl9tb3ZlKG9iaik7CisJfQorCiAJLyogT2JqZWN0IGVpdGhl ciBoYXMgYSBwYWdlIHZlY3RvciBvciBpcyBhbiBpb21lbSBvYmplY3QgKi8KIAlzdCA9IGJvLT50 dG0gPyBpOTE1X3R0bV90dF9nZXRfc3QoYm8tPnR0bSkgOiBvYmotPnR0bS5jYWNoZWRfaW9fc3Q7 CiAJaWYgKElTX0VSUihzdCkpCkBAIC00MjgsOCArNDg4LDYgQEAgc3RhdGljIGludCBpOTE1X3R0 bV9nZXRfcGFnZXMoc3RydWN0IGRybV9pOTE1X2dlbV9vYmplY3QgKm9iaikKIAogCV9faTkxNV9n ZW1fb2JqZWN0X3NldF9wYWdlcyhvYmosIHN0LCBpOTE1X3NnX2RtYV9zaXplcyhzdC0+c2dsKSk7 CiAKLQlpOTE1X3R0bV9hZGp1c3RfbHJ1KG9iaik7Ci0KIAlyZXR1cm4gcmV0OwogfQogCkBAIC01 OTksNiArNjU3LDEwIEBAIGludCBfX2k5MTVfZ2VtX3R0bV9vYmplY3RfaW5pdChzdHJ1Y3QgaW50 ZWxfbWVtb3J5X3JlZ2lvbiAqbWVtLAogewogCXN0YXRpYyBzdHJ1Y3QgbG9ja19jbGFzc19rZXkg bG9ja19jbGFzczsKIAlzdHJ1Y3QgZHJtX2k5MTVfcHJpdmF0ZSAqaTkxNSA9IG1lbS0+aTkxNTsK KwlzdHJ1Y3QgdHRtX29wZXJhdGlvbl9jdHggY3R4ID0geworCQkuaW50ZXJydXB0aWJsZSA9IHRy dWUsCisJCS5ub193YWl0X2dwdSA9IGZhbHNlLAorCX07CiAJZW51bSB0dG1fYm9fdHlwZSBib190 eXBlOwogCXNpemVfdCBhbGlnbm1lbnQgPSAwOwogCWludCByZXQ7CkBAIC02MTgsMTUgKzY4MCwx NCBAQCBpbnQgX19pOTE1X2dlbV90dG1fb2JqZWN0X2luaXQoc3RydWN0IGludGVsX21lbW9yeV9y ZWdpb24gKm1lbSwKIAlpOTE1X2dlbV9vYmplY3RfaW5pdChvYmosICZpOTE1X2dlbV90dG1fb2Jq X29wcywgJmxvY2tfY2xhc3MsIGZsYWdzKTsKIAlpOTE1X2dlbV9vYmplY3RfaW5pdF9tZW1vcnlf cmVnaW9uKG9iaiwgbWVtKTsKIAlpOTE1X2dlbV9vYmplY3RfbWFrZV91bnNocmlua2FibGUob2Jq KTsKLQlvYmotPnJlYWRfZG9tYWlucyA9IEk5MTVfR0VNX0RPTUFJTl9XQyB8IEk5MTVfR0VNX0RP TUFJTl9HVFQ7Ci0Jb2JqLT5tZW1fZmxhZ3MgfD0gSTkxNV9CT19GTEFHX0lPTUVNOwotCWk5MTVf Z2VtX29iamVjdF9zZXRfY2FjaGVfY29oZXJlbmN5KG9iaiwgSTkxNV9DQUNIRV9OT05FKTsKIAlJ TklUX1JBRElYX1RSRUUoJm9iai0+dHRtLmdldF9pb19wYWdlLnJhZGl4LCBHRlBfS0VSTkVMIHwg X19HRlBfTk9XQVJOKTsKIAltdXRleF9pbml0KCZvYmotPnR0bS5nZXRfaW9fcGFnZS5sb2NrKTsK IAogCWJvX3R5cGUgPSAob2JqLT5mbGFncyAmIEk5MTVfQk9fQUxMT0NfVVNFUikgPyB0dG1fYm9f dHlwZV9kZXZpY2UgOgogCQl0dG1fYm9fdHlwZV9rZXJuZWw7CiAKKwlvYmotPmJhc2Uudm1hX25v ZGUuZHJpdmVyX3ByaXZhdGUgPSBpOTE1X2dlbV90b190dG0ob2JqKTsKKwogCS8qCiAJICogSWYg dGhpcyBmdW5jdGlvbiBmYWlscywgaXQgd2lsbCBjYWxsIHRoZSBkZXN0cnVjdG9yLCBidXQKIAkg KiBvdXIgY2FsbGVyIHN0aWxsIG93bnMgdGhlIG9iamVjdC4gU28gbm8gZnJlZWluZyBpbiB0aGUK QEAgLTYzNCwxNCArNjk1LDE5IEBAIGludCBfX2k5MTVfZ2VtX3R0bV9vYmplY3RfaW5pdChzdHJ1 Y3QgaW50ZWxfbWVtb3J5X3JlZ2lvbiAqbWVtLAogCSAqIFNpbWlsYXJseSwgaW4gZGVsYXllZF9k ZXN0cm95LCB3ZSBjYW4ndCBjYWxsIHR0bV9ib19wdXQoKQogCSAqIHVudGlsIHN1Y2Nlc3NmdWwg aW5pdGlhbGl6YXRpb24uCiAJICovCi0Jb2JqLT5iYXNlLnZtYV9ub2RlLmRyaXZlcl9wcml2YXRl ID0gaTkxNV9nZW1fdG9fdHRtKG9iaik7Ci0JcmV0ID0gdHRtX2JvX2luaXQoJmk5MTUtPmJkZXYs IGk5MTVfZ2VtX3RvX3R0bShvYmopLCBzaXplLAotCQkJICBib190eXBlLCAmaTkxNV9zeXNfcGxh Y2VtZW50LCBhbGlnbm1lbnQsCi0JCQkgIHRydWUsIE5VTEwsIE5VTEwsIGk5MTVfdHRtX2JvX2Rl c3Ryb3kpOworCXJldCA9IHR0bV9ib19pbml0X3Jlc2VydmVkKCZpOTE1LT5iZGV2LCBpOTE1X2dl bV90b190dG0ob2JqKSwgc2l6ZSwKKwkJCQkgICBib190eXBlLCAmaTkxNV9zeXNfcGxhY2VtZW50 LCBhbGlnbm1lbnQsCisJCQkJICAgJmN0eCwgTlVMTCwgTlVMTCwgaTkxNV90dG1fYm9fZGVzdHJv eSk7CisKKwlpZiAocmV0KQorCQlnb3RvIG91dDsKIAotCWlmICghcmV0KQotCQlvYmotPnR0bS5j cmVhdGVkID0gdHJ1ZTsKKwlvYmotPnR0bS5jcmVhdGVkID0gdHJ1ZTsKKwlpOTE1X3R0bV9hZGp1 c3RfZG9tYWluc19hZnRlcl9jcHVfbW92ZShvYmopOworCWk5MTVfdHRtX2FkanVzdF9nZW1fYWZ0 ZXJfbW92ZShvYmopOworCWk5MTVfZ2VtX29iamVjdF91bmxvY2sob2JqKTsKIAorb3V0OgogCS8q IGk5MTUgd2FudHMgLUVOWElPIHdoZW4gb3V0IG9mIG1lbW9yeSByZWdpb24gc3BhY2UuICovCiAJ cmV0dXJuIChyZXQgPT0gLUVOT1NQQykgPyAtRU5YSU8gOiByZXQ7CiB9Ci0tIAoyLjMxLjEKCl9f X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fCkludGVsLWdmeCBt YWlsaW5nIGxpc3QKSW50ZWwtZ2Z4QGxpc3RzLmZyZWVkZXNrdG9wLm9yZwpodHRwczovL2xpc3Rz LmZyZWVkZXNrdG9wLm9yZy9tYWlsbWFuL2xpc3RpbmZvL2ludGVsLWdmeAo= 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 BD58FC48BE8 for ; Mon, 14 Jun 2021 17:43:41 +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 9069E61350 for ; Mon, 14 Jun 2021 17:43:41 +0000 (UTC) DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org 9069E61350 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 A639689F19; Mon, 14 Jun 2021 17:43:31 +0000 (UTC) Received: from mga04.intel.com (mga04.intel.com [192.55.52.120]) by gabe.freedesktop.org (Postfix) with ESMTPS id 3DAFB6E0D5; Mon, 14 Jun 2021 17:43:27 +0000 (UTC) IronPort-SDR: EqW/R+bQYLudUfhAAVnwL8yy+tVH3sCQV8qf+1ZAoUR6/ex5Hp/uCFmbvSQQP8xnLDndnAES8j iTLYLATwhcBw== X-IronPort-AV: E=McAfee;i="6200,9189,10015"; a="204020419" X-IronPort-AV: E=Sophos;i="5.83,273,1616482800"; d="scan'208";a="204020419" Received: from fmsmga008.fm.intel.com ([10.253.24.58]) by fmsmga104.fm.intel.com with ESMTP/TLS/ECDHE-RSA-AES256-GCM-SHA384; 14 Jun 2021 10:43:25 -0700 IronPort-SDR: vMbnwN9aFVSU7SmEBjN6lz+JzMZTiooqgWAhGvQCyCAs+2622+2WiGmhyRNCBUEe/F2exQtxaY 4WbrV32Z5p/w== X-IronPort-AV: E=Sophos;i="5.83,273,1616482800"; d="scan'208";a="451666859" Received: from fnygreen-mobl1.ger.corp.intel.com (HELO thellst-mobl1.intel.com) ([10.249.254.50]) by fmsmga008-auth.fm.intel.com with ESMTP/TLS/ECDHE-RSA-AES256-GCM-SHA384; 14 Jun 2021 10:43:04 -0700 From: =?UTF-8?q?Thomas=20Hellstr=C3=B6m?= To: intel-gfx@lists.freedesktop.org, dri-devel@lists.freedesktop.org Subject: [PATCH v5 2/4] drm/i915/ttm: Adjust gem flags and caching settings after a move Date: Mon, 14 Jun 2021 19:42:44 +0200 Message-Id: <20210614174246.403854-3-thomas.hellstrom@linux.intel.com> X-Mailer: git-send-email 2.31.1 In-Reply-To: <20210614174246.403854-1-thomas.hellstrom@linux.intel.com> References: <20210614174246.403854-1-thomas.hellstrom@linux.intel.com> MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit X-BeenThere: dri-devel@lists.freedesktop.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: Direct Rendering Infrastructure - Development List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Cc: =?UTF-8?q?Thomas=20Hellstr=C3=B6m?= , matthew.auld@intel.com Errors-To: dri-devel-bounces@lists.freedesktop.org Sender: "dri-devel" After a TTM move or object init we need to update the i915 gem flags and caching settings to reflect the new placement. Currently caching settings are not changed during the lifetime of an object, although that might change moving forward if we run into performance issues or issues with WC system page allocations. Also introduce gpu_binds_iomem() and cpu_maps_iomem() to clean up the various ways we previously used to detect this. Finally, initialize the TTM object reserved to be able to update flags and caching before anyone else gets hold of the object. Signed-off-by: Thomas Hellström Reviewed-by: Matthew Auld --- v2: - Style fixes (Reported by Matthew Auld) v3: - More style fixes. Clarify why we're updating caching settings after move. (Suggested by Matthew Auld) v5: - Fix confusion around shrinkable TTM object in the correct patch. (Suggested by Matthew Auld) --- drivers/gpu/drm/i915/gem/i915_gem_ttm.c | 110 +++++++++++++++++++----- 1 file changed, 88 insertions(+), 22 deletions(-) diff --git a/drivers/gpu/drm/i915/gem/i915_gem_ttm.c b/drivers/gpu/drm/i915/gem/i915_gem_ttm.c index 33ab47f1e05b..377bc3aaf456 100644 --- a/drivers/gpu/drm/i915/gem/i915_gem_ttm.c +++ b/drivers/gpu/drm/i915/gem/i915_gem_ttm.c @@ -70,6 +70,17 @@ static struct ttm_placement i915_sys_placement = { .busy_placement = &lmem0_sys_placement_flags[1], }; +static bool gpu_binds_iomem(struct ttm_resource *mem) +{ + return mem->mem_type != TTM_PL_SYSTEM; +} + +static bool cpu_maps_iomem(struct ttm_resource *mem) +{ + /* Once / if we support GGTT, this is also false for cached ttm_tts */ + return mem->mem_type != TTM_PL_SYSTEM; +} + static void i915_ttm_adjust_lru(struct drm_i915_gem_object *obj); static struct ttm_tt *i915_ttm_tt_create(struct ttm_buffer_object *bo, @@ -175,6 +186,40 @@ static void i915_ttm_free_cached_io_st(struct drm_i915_gem_object *obj) obj->ttm.cached_io_st = NULL; } +static void +i915_ttm_adjust_domains_after_cpu_move(struct drm_i915_gem_object *obj) +{ + struct ttm_buffer_object *bo = i915_gem_to_ttm(obj); + + if (cpu_maps_iomem(bo->resource) || bo->ttm->caching != ttm_cached) { + obj->write_domain = I915_GEM_DOMAIN_WC; + obj->read_domains = I915_GEM_DOMAIN_WC; + } else { + obj->write_domain = I915_GEM_DOMAIN_CPU; + obj->read_domains = I915_GEM_DOMAIN_CPU; + } +} + +static void i915_ttm_adjust_gem_after_move(struct drm_i915_gem_object *obj) +{ + struct drm_i915_private *i915 = to_i915(obj->base.dev); + struct ttm_buffer_object *bo = i915_gem_to_ttm(obj); + unsigned int cache_level; + + obj->mem_flags &= ~(I915_BO_FLAG_STRUCT_PAGE | I915_BO_FLAG_IOMEM); + + obj->mem_flags |= cpu_maps_iomem(bo->resource) ? I915_BO_FLAG_IOMEM : + I915_BO_FLAG_STRUCT_PAGE; + + if ((HAS_LLC(i915) || HAS_SNOOP(i915)) && !gpu_binds_iomem(bo->resource) && + bo->ttm->caching == ttm_cached) + cache_level = I915_CACHE_LLC; + else + cache_level = I915_CACHE_NONE; + + i915_gem_object_set_cache_coherency(obj, cache_level); +} + static void i915_ttm_purge(struct drm_i915_gem_object *obj) { struct ttm_buffer_object *bo = i915_gem_to_ttm(obj); @@ -190,8 +235,10 @@ static void i915_ttm_purge(struct drm_i915_gem_object *obj) /* TTM's purge interface. Note that we might be reentering. */ ret = ttm_bo_validate(bo, &place, &ctx); - if (!ret) { + obj->write_domain = 0; + obj->read_domains = 0; + i915_ttm_adjust_gem_after_move(obj); i915_ttm_free_cached_io_st(obj); obj->mm.madv = __I915_MADV_PURGED; } @@ -273,12 +320,15 @@ i915_ttm_resource_get_st(struct drm_i915_gem_object *obj, struct ttm_resource *res) { struct ttm_buffer_object *bo = i915_gem_to_ttm(obj); - struct ttm_resource_manager *man = - ttm_manager_type(bo->bdev, res->mem_type); - if (man->use_tt) + if (!gpu_binds_iomem(res)) return i915_ttm_tt_get_st(bo->ttm); + /* + * If CPU mapping differs, we need to add the ttm_tt pages to + * the resulting st. Might make sense for GGTT. + */ + GEM_WARN_ON(!cpu_maps_iomem(res)); return intel_region_ttm_node_to_st(obj->mm.region, res); } @@ -290,8 +340,6 @@ static int i915_ttm_move(struct ttm_buffer_object *bo, bool evict, struct drm_i915_gem_object *obj = i915_ttm_to_gem(bo); struct ttm_resource_manager *dst_man = ttm_manager_type(bo->bdev, dst_mem->mem_type); - struct ttm_resource_manager *src_man = - ttm_manager_type(bo->bdev, bo->resource->mem_type); struct intel_memory_region *dst_reg, *src_reg; union { struct ttm_kmap_iter_tt tt; @@ -332,34 +380,36 @@ static int i915_ttm_move(struct ttm_buffer_object *bo, bool evict, if (IS_ERR(dst_st)) return PTR_ERR(dst_st); - /* If we start mapping GGTT, we can no longer use man::use_tt here. */ - dst_iter = dst_man->use_tt ? + dst_iter = !cpu_maps_iomem(dst_mem) ? ttm_kmap_iter_tt_init(&_dst_iter.tt, bo->ttm) : ttm_kmap_iter_iomap_init(&_dst_iter.io, &dst_reg->iomap, dst_st, dst_reg->region.start); - src_iter = src_man->use_tt ? + src_iter = !cpu_maps_iomem(bo->resource) ? ttm_kmap_iter_tt_init(&_src_iter.tt, bo->ttm) : ttm_kmap_iter_iomap_init(&_src_iter.io, &src_reg->iomap, obj->ttm.cached_io_st, src_reg->region.start); ttm_move_memcpy(bo, dst_mem->num_pages, dst_iter, src_iter); + /* Below dst_mem becomes bo->resource. */ ttm_bo_move_sync_cleanup(bo, dst_mem); + i915_ttm_adjust_domains_after_cpu_move(obj); i915_ttm_free_cached_io_st(obj); - if (!dst_man->use_tt) { + if (gpu_binds_iomem(dst_mem) || cpu_maps_iomem(dst_mem)) { obj->ttm.cached_io_st = dst_st; obj->ttm.get_io_page.sg_pos = dst_st->sgl; obj->ttm.get_io_page.sg_idx = 0; } + i915_ttm_adjust_gem_after_move(obj); return 0; } static int i915_ttm_io_mem_reserve(struct ttm_device *bdev, struct ttm_resource *mem) { - if (mem->mem_type < I915_PL_LMEM0) + if (!cpu_maps_iomem(mem)) return 0; mem->bus.caching = ttm_write_combined; @@ -421,6 +471,16 @@ static int i915_ttm_get_pages(struct drm_i915_gem_object *obj) if (ret) return ret == -ENOSPC ? -ENXIO : ret; + i915_ttm_adjust_lru(obj); + if (bo->ttm && !ttm_tt_is_populated(bo->ttm)) { + ret = ttm_tt_populate(bo->bdev, bo->ttm, &ctx); + if (ret) + return ret; + + i915_ttm_adjust_domains_after_cpu_move(obj); + i915_ttm_adjust_gem_after_move(obj); + } + /* Object either has a page vector or is an iomem object */ st = bo->ttm ? i915_ttm_tt_get_st(bo->ttm) : obj->ttm.cached_io_st; if (IS_ERR(st)) @@ -428,8 +488,6 @@ static int i915_ttm_get_pages(struct drm_i915_gem_object *obj) __i915_gem_object_set_pages(obj, st, i915_sg_dma_sizes(st->sgl)); - i915_ttm_adjust_lru(obj); - return ret; } @@ -599,6 +657,10 @@ 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; + struct ttm_operation_ctx ctx = { + .interruptible = true, + .no_wait_gpu = false, + }; enum ttm_bo_type bo_type; size_t alignment = 0; int ret; @@ -618,15 +680,14 @@ int __i915_gem_ttm_object_init(struct intel_memory_region *mem, i915_gem_object_init(obj, &i915_gem_ttm_obj_ops, &lock_class, flags); i915_gem_object_init_memory_region(obj, mem); i915_gem_object_make_unshrinkable(obj); - obj->read_domains = I915_GEM_DOMAIN_WC | I915_GEM_DOMAIN_GTT; - obj->mem_flags |= I915_BO_FLAG_IOMEM; - i915_gem_object_set_cache_coherency(obj, I915_CACHE_NONE); INIT_RADIX_TREE(&obj->ttm.get_io_page.radix, GFP_KERNEL | __GFP_NOWARN); mutex_init(&obj->ttm.get_io_page.lock); bo_type = (obj->flags & I915_BO_ALLOC_USER) ? ttm_bo_type_device : ttm_bo_type_kernel; + obj->base.vma_node.driver_private = i915_gem_to_ttm(obj); + /* * If this function fails, it will call the destructor, but * our caller still owns the object. So no freeing in the @@ -634,14 +695,19 @@ int __i915_gem_ttm_object_init(struct intel_memory_region *mem, * Similarly, in delayed_destroy, we can't call ttm_bo_put() * until successful initialization. */ - 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, - true, NULL, NULL, i915_ttm_bo_destroy); + ret = ttm_bo_init_reserved(&i915->bdev, i915_gem_to_ttm(obj), size, + bo_type, &i915_sys_placement, alignment, + &ctx, NULL, NULL, i915_ttm_bo_destroy); + + if (ret) + goto out; - if (!ret) - obj->ttm.created = true; + obj->ttm.created = true; + i915_ttm_adjust_domains_after_cpu_move(obj); + i915_ttm_adjust_gem_after_move(obj); + i915_gem_object_unlock(obj); +out: /* i915 wants -ENXIO when out of memory region space. */ return (ret == -ENOSPC) ? -ENXIO : ret; } -- 2.31.1