From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from mail-pg0-f72.google.com (mail-pg0-f72.google.com [74.125.83.72]) by kanga.kvack.org (Postfix) with ESMTP id CE35C6B0069 for ; Fri, 22 Sep 2017 13:33:17 -0400 (EDT) Received: by mail-pg0-f72.google.com with SMTP id 188so3326713pgb.3 for ; Fri, 22 Sep 2017 10:33:17 -0700 (PDT) Received: from mga09.intel.com (mga09.intel.com. [134.134.136.24]) by mx.google.com with ESMTPS id 76si170090pfm.211.2017.09.22.10.33.15 for (version=TLS1_2 cipher=ECDHE-RSA-AES128-GCM-SHA256 bits=128/128); Fri, 22 Sep 2017 10:33:15 -0700 (PDT) From: Matthew Auld Subject: [PATCH 02/21] drm/i915: introduce simple gemfs Date: Fri, 22 Sep 2017 18:32:33 +0100 Message-Id: <20170922173252.10137-3-matthew.auld@intel.com> In-Reply-To: <20170922173252.10137-1-matthew.auld@intel.com> References: <20170922173252.10137-1-matthew.auld@intel.com> MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Sender: owner-linux-mm@kvack.org List-ID: To: intel-gfx@lists.freedesktop.org Cc: Joonas Lahtinen , Chris Wilson , Dave Hansen , "Kirill A . Shutemov" , Hugh Dickins , linux-mm@kvack.org Not a fully blown gemfs, just our very own tmpfs kernel mount. Doing so moves us away from the shmemfs shm_mnt, and gives us the much needed flexibility to do things like set our own mount options, namely huge= which should allow us to enable the use of transparent-huge-pages for our shmem backed objects. v2: various improvements suggested by Joonas v3: move gemfs instance to i915.mm and simplify now that we have file_setup_with_mnt v4: fallback to tmpfs shm_mnt upon failure to setup gemfs Signed-off-by: Matthew Auld Cc: Joonas Lahtinen Cc: Chris Wilson Cc: Dave Hansen Cc: Kirill A. Shutemov Cc: Hugh Dickins Cc: linux-mm@kvack.org --- drivers/gpu/drm/i915/Makefile | 1 + drivers/gpu/drm/i915/i915_drv.h | 5 +++ drivers/gpu/drm/i915/i915_gem.c | 30 +++++++++++++- drivers/gpu/drm/i915/i915_gemfs.c | 52 ++++++++++++++++++++++++ drivers/gpu/drm/i915/i915_gemfs.h | 34 ++++++++++++++++ drivers/gpu/drm/i915/selftests/mock_gem_device.c | 4 ++ 6 files changed, 125 insertions(+), 1 deletion(-) create mode 100644 drivers/gpu/drm/i915/i915_gemfs.c create mode 100644 drivers/gpu/drm/i915/i915_gemfs.h diff --git a/drivers/gpu/drm/i915/Makefile b/drivers/gpu/drm/i915/Makefile index 5182e3d5557d..980c41568f46 100644 --- a/drivers/gpu/drm/i915/Makefile +++ b/drivers/gpu/drm/i915/Makefile @@ -47,6 +47,7 @@ i915-y += i915_cmd_parser.o \ i915_gem_tiling.o \ i915_gem_timeline.o \ i915_gem_userptr.o \ + i915_gemfs.o \ i915_trace_points.o \ i915_vma.o \ intel_breadcrumbs.o \ diff --git a/drivers/gpu/drm/i915/i915_drv.h b/drivers/gpu/drm/i915/i915_drv.h index f5d0e816008d..b59714f0c1bf 100644 --- a/drivers/gpu/drm/i915/i915_drv.h +++ b/drivers/gpu/drm/i915/i915_drv.h @@ -1500,6 +1500,11 @@ struct i915_gem_mm { /** Usable portion of the GTT for GEM */ dma_addr_t stolen_base; /* limited to low memory (32-bit) */ + /** + * tmpfs instance used for shmem backed objects + */ + struct vfsmount *gemfs; + /** PPGTT used for aliasing the PPGTT with the GTT */ struct i915_hw_ppgtt *aliasing_ppgtt; diff --git a/drivers/gpu/drm/i915/i915_gem.c b/drivers/gpu/drm/i915/i915_gem.c index 2a650f92aa74..e5718ac9166d 100644 --- a/drivers/gpu/drm/i915/i915_gem.c +++ b/drivers/gpu/drm/i915/i915_gem.c @@ -35,6 +35,7 @@ #include "intel_drv.h" #include "intel_frontbuffer.h" #include "intel_mocs.h" +#include "i915_gemfs.h" #include #include #include @@ -4251,6 +4252,29 @@ static const struct drm_i915_gem_object_ops i915_gem_object_ops = { .pwrite = i915_gem_object_pwrite_gtt, }; +static int i915_gem_object_create_shmem(struct drm_device *dev, + struct drm_gem_object *obj, + size_t size) +{ + struct drm_i915_private *i915 = to_i915(dev); + struct file *filp; + + drm_gem_private_object_init(dev, obj, size); + + if (i915->mm.gemfs) + filp = shmem_file_setup_with_mnt(i915->mm.gemfs, "i915", size, + VM_NORESERVE); + else + filp = shmem_file_setup("i915", size, VM_NORESERVE); + + if (IS_ERR(filp)) + return PTR_ERR(filp); + + obj->filp = filp; + + return 0; +} + struct drm_i915_gem_object * i915_gem_object_create(struct drm_i915_private *dev_priv, u64 size) { @@ -4275,7 +4299,7 @@ i915_gem_object_create(struct drm_i915_private *dev_priv, u64 size) if (obj == NULL) return ERR_PTR(-ENOMEM); - ret = drm_gem_object_init(&dev_priv->drm, &obj->base, size); + ret = i915_gem_object_create_shmem(&dev_priv->drm, &obj->base, size); if (ret) goto fail; @@ -4914,6 +4938,8 @@ i915_gem_load_init(struct drm_i915_private *dev_priv) spin_lock_init(&dev_priv->fb_tracking.lock); + WARN_ON(i915_gemfs_init(dev_priv)); + return 0; err_priorities: @@ -4952,6 +4978,8 @@ void i915_gem_load_cleanup(struct drm_i915_private *dev_priv) /* And ensure that our DESTROY_BY_RCU slabs are truly destroyed */ rcu_barrier(); + + i915_gemfs_fini(dev_priv); } int i915_gem_freeze(struct drm_i915_private *dev_priv) diff --git a/drivers/gpu/drm/i915/i915_gemfs.c b/drivers/gpu/drm/i915/i915_gemfs.c new file mode 100644 index 000000000000..168d0bd98f60 --- /dev/null +++ b/drivers/gpu/drm/i915/i915_gemfs.c @@ -0,0 +1,52 @@ +/* + * Copyright A(C) 2017 Intel Corporation + * + * Permission is hereby granted, free of charge, to any person obtaining a + * copy of this software and associated documentation files (the "Software"), + * to deal in the Software without restriction, including without limitation + * the rights to use, copy, modify, merge, publish, distribute, sublicense, + * and/or sell copies of the Software, and to permit persons to whom the + * Software is furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice (including the next + * paragraph) shall be included in all copies or substantial portions of the + * Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL + * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING + * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS + * IN THE SOFTWARE. + * + */ + +#include +#include + +#include "i915_drv.h" +#include "i915_gemfs.h" + +int i915_gemfs_init(struct drm_i915_private *i915) +{ + struct file_system_type *type; + struct vfsmount *gemfs; + + type = get_fs_type("tmpfs"); + if (!type) + return -ENODEV; + + gemfs = kern_mount(type); + if (IS_ERR(gemfs)) + return PTR_ERR(gemfs); + + i915->mm.gemfs = gemfs; + + return 0; +} + +void i915_gemfs_fini(struct drm_i915_private *i915) +{ + kern_unmount(i915->mm.gemfs); +} diff --git a/drivers/gpu/drm/i915/i915_gemfs.h b/drivers/gpu/drm/i915/i915_gemfs.h new file mode 100644 index 000000000000..cca8bdc5b93e --- /dev/null +++ b/drivers/gpu/drm/i915/i915_gemfs.h @@ -0,0 +1,34 @@ +/* + * Copyright A(C) 2017 Intel Corporation + * + * Permission is hereby granted, free of charge, to any person obtaining a + * copy of this software and associated documentation files (the "Software"), + * to deal in the Software without restriction, including without limitation + * the rights to use, copy, modify, merge, publish, distribute, sublicense, + * and/or sell copies of the Software, and to permit persons to whom the + * Software is furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice (including the next + * paragraph) shall be included in all copies or substantial portions of the + * Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL + * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING + * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS + * IN THE SOFTWARE. + * + */ + +#ifndef __I915_GEMFS_H__ +#define __I915_GEMFS_H__ + +struct drm_i915_private; + +int i915_gemfs_init(struct drm_i915_private *i915); + +void i915_gemfs_fini(struct drm_i915_private *i915); + +#endif diff --git a/drivers/gpu/drm/i915/selftests/mock_gem_device.c b/drivers/gpu/drm/i915/selftests/mock_gem_device.c index 2388424a14da..ed3407b078e7 100644 --- a/drivers/gpu/drm/i915/selftests/mock_gem_device.c +++ b/drivers/gpu/drm/i915/selftests/mock_gem_device.c @@ -83,6 +83,8 @@ static void mock_device_release(struct drm_device *dev) kmem_cache_destroy(i915->vmas); kmem_cache_destroy(i915->objects); + i915_gemfs_fini(i915); + drm_dev_fini(&i915->drm); put_device(&i915->drm.pdev->dev); } @@ -239,6 +241,8 @@ struct drm_i915_private *mock_gem_device(void) if (!i915->kernel_context) goto err_engine; + WARN_ON(i915_gemfs_init(i915)); + return i915; err_engine: -- 2.13.5 -- To unsubscribe, send a message with 'unsubscribe linux-mm' in the body to majordomo@kvack.org. For more info on Linux MM, see: http://www.linux-mm.org/ . Don't email: email@kvack.org From mboxrd@z Thu Jan 1 00:00:00 1970 From: Matthew Auld Subject: [PATCH 02/21] drm/i915: introduce simple gemfs Date: Fri, 22 Sep 2017 18:32:33 +0100 Message-ID: <20170922173252.10137-3-matthew.auld@intel.com> References: <20170922173252.10137-1-matthew.auld@intel.com> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Return-path: Received: from mga09.intel.com (mga09.intel.com [134.134.136.24]) by gabe.freedesktop.org (Postfix) with ESMTPS id C2D376E036 for ; Fri, 22 Sep 2017 17:33:15 +0000 (UTC) In-Reply-To: <20170922173252.10137-1-matthew.auld@intel.com> List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: intel-gfx-bounces@lists.freedesktop.org Sender: "Intel-gfx" To: intel-gfx@lists.freedesktop.org Cc: Dave Hansen , Hugh Dickins , linux-mm@kvack.org, "Kirill A . Shutemov" List-Id: intel-gfx@lists.freedesktop.org Tm90IGEgZnVsbHkgYmxvd24gZ2VtZnMsIGp1c3Qgb3VyIHZlcnkgb3duIHRtcGZzIGtlcm5lbCBt b3VudC4gRG9pbmcgc28KbW92ZXMgdXMgYXdheSBmcm9tIHRoZSBzaG1lbWZzIHNobV9tbnQsIGFu ZCBnaXZlcyB1cyB0aGUgbXVjaCBuZWVkZWQKZmxleGliaWxpdHkgdG8gZG8gdGhpbmdzIGxpa2Ug c2V0IG91ciBvd24gbW91bnQgb3B0aW9ucywgbmFtZWx5IGh1Z2U9CndoaWNoIHNob3VsZCBhbGxv dyB1cyB0byBlbmFibGUgdGhlIHVzZSBvZiB0cmFuc3BhcmVudC1odWdlLXBhZ2VzIGZvcgpvdXIg c2htZW0gYmFja2VkIG9iamVjdHMuCgp2MjogdmFyaW91cyBpbXByb3ZlbWVudHMgc3VnZ2VzdGVk IGJ5IEpvb25hcwoKdjM6IG1vdmUgZ2VtZnMgaW5zdGFuY2UgdG8gaTkxNS5tbSBhbmQgc2ltcGxp Znkgbm93IHRoYXQgd2UgaGF2ZQpmaWxlX3NldHVwX3dpdGhfbW50Cgp2NDogZmFsbGJhY2sgdG8g dG1wZnMgc2htX21udCB1cG9uIGZhaWx1cmUgdG8gc2V0dXAgZ2VtZnMKClNpZ25lZC1vZmYtYnk6 IE1hdHRoZXcgQXVsZCA8bWF0dGhldy5hdWxkQGludGVsLmNvbT4KQ2M6IEpvb25hcyBMYWh0aW5l biA8am9vbmFzLmxhaHRpbmVuQGxpbnV4LmludGVsLmNvbT4KQ2M6IENocmlzIFdpbHNvbiA8Y2hy aXNAY2hyaXMtd2lsc29uLmNvLnVrPgpDYzogRGF2ZSBIYW5zZW4gPGRhdmUuaGFuc2VuQGludGVs LmNvbT4KQ2M6IEtpcmlsbCBBLiBTaHV0ZW1vdiA8a2lyaWxsQHNodXRlbW92Lm5hbWU+CkNjOiBI dWdoIERpY2tpbnMgPGh1Z2hkQGdvb2dsZS5jb20+CkNjOiBsaW51eC1tbUBrdmFjay5vcmcKLS0t CiBkcml2ZXJzL2dwdS9kcm0vaTkxNS9NYWtlZmlsZSAgICAgICAgICAgICAgICAgICAgfCAgMSAr CiBkcml2ZXJzL2dwdS9kcm0vaTkxNS9pOTE1X2Rydi5oICAgICAgICAgICAgICAgICAgfCAgNSAr KysKIGRyaXZlcnMvZ3B1L2RybS9pOTE1L2k5MTVfZ2VtLmMgICAgICAgICAgICAgICAgICB8IDMw ICsrKysrKysrKysrKystCiBkcml2ZXJzL2dwdS9kcm0vaTkxNS9pOTE1X2dlbWZzLmMgICAgICAg ICAgICAgICAgfCA1MiArKysrKysrKysrKysrKysrKysrKysrKysKIGRyaXZlcnMvZ3B1L2RybS9p OTE1L2k5MTVfZ2VtZnMuaCAgICAgICAgICAgICAgICB8IDM0ICsrKysrKysrKysrKysrKysKIGRy aXZlcnMvZ3B1L2RybS9pOTE1L3NlbGZ0ZXN0cy9tb2NrX2dlbV9kZXZpY2UuYyB8ICA0ICsrCiA2 IGZpbGVzIGNoYW5nZWQsIDEyNSBpbnNlcnRpb25zKCspLCAxIGRlbGV0aW9uKC0pCiBjcmVhdGUg bW9kZSAxMDA2NDQgZHJpdmVycy9ncHUvZHJtL2k5MTUvaTkxNV9nZW1mcy5jCiBjcmVhdGUgbW9k ZSAxMDA2NDQgZHJpdmVycy9ncHUvZHJtL2k5MTUvaTkxNV9nZW1mcy5oCgpkaWZmIC0tZ2l0IGEv ZHJpdmVycy9ncHUvZHJtL2k5MTUvTWFrZWZpbGUgYi9kcml2ZXJzL2dwdS9kcm0vaTkxNS9NYWtl ZmlsZQppbmRleCA1MTgyZTNkNTU1N2QuLjk4MGM0MTU2OGY0NiAxMDA2NDQKLS0tIGEvZHJpdmVy cy9ncHUvZHJtL2k5MTUvTWFrZWZpbGUKKysrIGIvZHJpdmVycy9ncHUvZHJtL2k5MTUvTWFrZWZp bGUKQEAgLTQ3LDYgKzQ3LDcgQEAgaTkxNS15ICs9IGk5MTVfY21kX3BhcnNlci5vIFwKIAkgIGk5 MTVfZ2VtX3RpbGluZy5vIFwKIAkgIGk5MTVfZ2VtX3RpbWVsaW5lLm8gXAogCSAgaTkxNV9nZW1f dXNlcnB0ci5vIFwKKwkgIGk5MTVfZ2VtZnMubyBcCiAJICBpOTE1X3RyYWNlX3BvaW50cy5vIFwK IAkgIGk5MTVfdm1hLm8gXAogCSAgaW50ZWxfYnJlYWRjcnVtYnMubyBcCmRpZmYgLS1naXQgYS9k cml2ZXJzL2dwdS9kcm0vaTkxNS9pOTE1X2Rydi5oIGIvZHJpdmVycy9ncHUvZHJtL2k5MTUvaTkx NV9kcnYuaAppbmRleCBmNWQwZTgxNjAwOGQuLmI1OTcxNGYwYzFiZiAxMDA2NDQKLS0tIGEvZHJp dmVycy9ncHUvZHJtL2k5MTUvaTkxNV9kcnYuaAorKysgYi9kcml2ZXJzL2dwdS9kcm0vaTkxNS9p OTE1X2Rydi5oCkBAIC0xNTAwLDYgKzE1MDAsMTEgQEAgc3RydWN0IGk5MTVfZ2VtX21tIHsKIAkv KiogVXNhYmxlIHBvcnRpb24gb2YgdGhlIEdUVCBmb3IgR0VNICovCiAJZG1hX2FkZHJfdCBzdG9s ZW5fYmFzZTsgLyogbGltaXRlZCB0byBsb3cgbWVtb3J5ICgzMi1iaXQpICovCiAKKwkvKioKKwkg KiB0bXBmcyBpbnN0YW5jZSB1c2VkIGZvciBzaG1lbSBiYWNrZWQgb2JqZWN0cworCSAqLworCXN0 cnVjdCB2ZnNtb3VudCAqZ2VtZnM7CisKIAkvKiogUFBHVFQgdXNlZCBmb3IgYWxpYXNpbmcgdGhl IFBQR1RUIHdpdGggdGhlIEdUVCAqLwogCXN0cnVjdCBpOTE1X2h3X3BwZ3R0ICphbGlhc2luZ19w cGd0dDsKIApkaWZmIC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJtL2k5MTUvaTkxNV9nZW0uYyBiL2Ry aXZlcnMvZ3B1L2RybS9pOTE1L2k5MTVfZ2VtLmMKaW5kZXggMmE2NTBmOTJhYTc0Li5lNTcxOGFj OTE2NmQgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2k5MTVfZ2VtLmMKKysrIGIv ZHJpdmVycy9ncHUvZHJtL2k5MTUvaTkxNV9nZW0uYwpAQCAtMzUsNiArMzUsNyBAQAogI2luY2x1 ZGUgImludGVsX2Rydi5oIgogI2luY2x1ZGUgImludGVsX2Zyb250YnVmZmVyLmgiCiAjaW5jbHVk ZSAiaW50ZWxfbW9jcy5oIgorI2luY2x1ZGUgImk5MTVfZ2VtZnMuaCIKICNpbmNsdWRlIDxsaW51 eC9kbWEtZmVuY2UtYXJyYXkuaD4KICNpbmNsdWRlIDxsaW51eC9rdGhyZWFkLmg+CiAjaW5jbHVk ZSA8bGludXgvcmVzZXJ2YXRpb24uaD4KQEAgLTQyNTEsNiArNDI1MiwyOSBAQCBzdGF0aWMgY29u c3Qgc3RydWN0IGRybV9pOTE1X2dlbV9vYmplY3Rfb3BzIGk5MTVfZ2VtX29iamVjdF9vcHMgPSB7 CiAJLnB3cml0ZSA9IGk5MTVfZ2VtX29iamVjdF9wd3JpdGVfZ3R0LAogfTsKIAorc3RhdGljIGlu dCBpOTE1X2dlbV9vYmplY3RfY3JlYXRlX3NobWVtKHN0cnVjdCBkcm1fZGV2aWNlICpkZXYsCisJ CQkJCXN0cnVjdCBkcm1fZ2VtX29iamVjdCAqb2JqLAorCQkJCQlzaXplX3Qgc2l6ZSkKK3sKKwlz dHJ1Y3QgZHJtX2k5MTVfcHJpdmF0ZSAqaTkxNSA9IHRvX2k5MTUoZGV2KTsKKwlzdHJ1Y3QgZmls ZSAqZmlscDsKKworCWRybV9nZW1fcHJpdmF0ZV9vYmplY3RfaW5pdChkZXYsIG9iaiwgc2l6ZSk7 CisKKwlpZiAoaTkxNS0+bW0uZ2VtZnMpCisJCWZpbHAgPSBzaG1lbV9maWxlX3NldHVwX3dpdGhf bW50KGk5MTUtPm1tLmdlbWZzLCAiaTkxNSIsIHNpemUsCisJCQkJCQkgVk1fTk9SRVNFUlZFKTsK KwllbHNlCisJCWZpbHAgPSBzaG1lbV9maWxlX3NldHVwKCJpOTE1Iiwgc2l6ZSwgVk1fTk9SRVNF UlZFKTsKKworCWlmIChJU19FUlIoZmlscCkpCisJCXJldHVybiBQVFJfRVJSKGZpbHApOworCisJ b2JqLT5maWxwID0gZmlscDsKKworCXJldHVybiAwOworfQorCiBzdHJ1Y3QgZHJtX2k5MTVfZ2Vt X29iamVjdCAqCiBpOTE1X2dlbV9vYmplY3RfY3JlYXRlKHN0cnVjdCBkcm1faTkxNV9wcml2YXRl ICpkZXZfcHJpdiwgdTY0IHNpemUpCiB7CkBAIC00Mjc1LDcgKzQyOTksNyBAQCBpOTE1X2dlbV9v YmplY3RfY3JlYXRlKHN0cnVjdCBkcm1faTkxNV9wcml2YXRlICpkZXZfcHJpdiwgdTY0IHNpemUp CiAJaWYgKG9iaiA9PSBOVUxMKQogCQlyZXR1cm4gRVJSX1BUUigtRU5PTUVNKTsKIAotCXJldCA9 IGRybV9nZW1fb2JqZWN0X2luaXQoJmRldl9wcml2LT5kcm0sICZvYmotPmJhc2UsIHNpemUpOwor CXJldCA9IGk5MTVfZ2VtX29iamVjdF9jcmVhdGVfc2htZW0oJmRldl9wcml2LT5kcm0sICZvYmot PmJhc2UsIHNpemUpOwogCWlmIChyZXQpCiAJCWdvdG8gZmFpbDsKIApAQCAtNDkxNCw2ICs0OTM4 LDggQEAgaTkxNV9nZW1fbG9hZF9pbml0KHN0cnVjdCBkcm1faTkxNV9wcml2YXRlICpkZXZfcHJp dikKIAogCXNwaW5fbG9ja19pbml0KCZkZXZfcHJpdi0+ZmJfdHJhY2tpbmcubG9jayk7CiAKKwlX QVJOX09OKGk5MTVfZ2VtZnNfaW5pdChkZXZfcHJpdikpOworCiAJcmV0dXJuIDA7CiAKIGVycl9w cmlvcml0aWVzOgpAQCAtNDk1Miw2ICs0OTc4LDggQEAgdm9pZCBpOTE1X2dlbV9sb2FkX2NsZWFu dXAoc3RydWN0IGRybV9pOTE1X3ByaXZhdGUgKmRldl9wcml2KQogCiAJLyogQW5kIGVuc3VyZSB0 aGF0IG91ciBERVNUUk9ZX0JZX1JDVSBzbGFicyBhcmUgdHJ1bHkgZGVzdHJveWVkICovCiAJcmN1 X2JhcnJpZXIoKTsKKworCWk5MTVfZ2VtZnNfZmluaShkZXZfcHJpdik7CiB9CiAKIGludCBpOTE1 X2dlbV9mcmVlemUoc3RydWN0IGRybV9pOTE1X3ByaXZhdGUgKmRldl9wcml2KQpkaWZmIC0tZ2l0 IGEvZHJpdmVycy9ncHUvZHJtL2k5MTUvaTkxNV9nZW1mcy5jIGIvZHJpdmVycy9ncHUvZHJtL2k5 MTUvaTkxNV9nZW1mcy5jCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwMC4u MTY4ZDBiZDk4ZjYwCi0tLSAvZGV2L251bGwKKysrIGIvZHJpdmVycy9ncHUvZHJtL2k5MTUvaTkx NV9nZW1mcy5jCkBAIC0wLDAgKzEsNTIgQEAKKy8qCisgKiBDb3B5cmlnaHQgwqkgMjAxNyBJbnRl bCBDb3Jwb3JhdGlvbgorICoKKyAqIFBlcm1pc3Npb24gaXMgaGVyZWJ5IGdyYW50ZWQsIGZyZWUg b2YgY2hhcmdlLCB0byBhbnkgcGVyc29uIG9idGFpbmluZyBhCisgKiBjb3B5IG9mIHRoaXMgc29m dHdhcmUgYW5kIGFzc29jaWF0ZWQgZG9jdW1lbnRhdGlvbiBmaWxlcyAodGhlICJTb2Z0d2FyZSIp LAorICogdG8gZGVhbCBpbiB0aGUgU29mdHdhcmUgd2l0aG91dCByZXN0cmljdGlvbiwgaW5jbHVk aW5nIHdpdGhvdXQgbGltaXRhdGlvbgorICogdGhlIHJpZ2h0cyB0byB1c2UsIGNvcHksIG1vZGlm eSwgbWVyZ2UsIHB1Ymxpc2gsIGRpc3RyaWJ1dGUsIHN1YmxpY2Vuc2UsCisgKiBhbmQvb3Igc2Vs bCBjb3BpZXMgb2YgdGhlIFNvZnR3YXJlLCBhbmQgdG8gcGVybWl0IHBlcnNvbnMgdG8gd2hvbSB0 aGUKKyAqIFNvZnR3YXJlIGlzIGZ1cm5pc2hlZCB0byBkbyBzbywgc3ViamVjdCB0byB0aGUgZm9s bG93aW5nIGNvbmRpdGlvbnM6CisgKgorICogVGhlIGFib3ZlIGNvcHlyaWdodCBub3RpY2UgYW5k IHRoaXMgcGVybWlzc2lvbiBub3RpY2UgKGluY2x1ZGluZyB0aGUgbmV4dAorICogcGFyYWdyYXBo KSBzaGFsbCBiZSBpbmNsdWRlZCBpbiBhbGwgY29waWVzIG9yIHN1YnN0YW50aWFsIHBvcnRpb25z IG9mIHRoZQorICogU29mdHdhcmUuCisgKgorICogVEhFIFNPRlRXQVJFIElTIFBST1ZJREVEICJB UyBJUyIsIFdJVEhPVVQgV0FSUkFOVFkgT0YgQU5ZIEtJTkQsIEVYUFJFU1MgT1IKKyAqIElNUExJ RUQsIElOQ0xVRElORyBCVVQgTk9UIExJTUlURUQgVE8gVEhFIFdBUlJBTlRJRVMgT0YgTUVSQ0hB TlRBQklMSVRZLAorICogRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UgQU5EIE5PTklO RlJJTkdFTUVOVC4gIElOIE5PIEVWRU5UIFNIQUxMCisgKiBUSEUgQVVUSE9SUyBPUiBDT1BZUklH SFQgSE9MREVSUyBCRSBMSUFCTEUgRk9SIEFOWSBDTEFJTSwgREFNQUdFUyBPUiBPVEhFUgorICog TElBQklMSVRZLCBXSEVUSEVSIElOIEFOIEFDVElPTiBPRiBDT05UUkFDVCwgVE9SVCBPUiBPVEhF UldJU0UsIEFSSVNJTkcKKyAqIEZST00sIE9VVCBPRiBPUiBJTiBDT05ORUNUSU9OIFdJVEggVEhF IFNPRlRXQVJFIE9SIFRIRSBVU0UgT1IgT1RIRVIgREVBTElOR1MKKyAqIElOIFRIRSBTT0ZUV0FS RS4KKyAqCisgKi8KKworI2luY2x1ZGUgPGxpbnV4L2ZzLmg+CisjaW5jbHVkZSA8bGludXgvbW91 bnQuaD4KKworI2luY2x1ZGUgImk5MTVfZHJ2LmgiCisjaW5jbHVkZSAiaTkxNV9nZW1mcy5oIgor CitpbnQgaTkxNV9nZW1mc19pbml0KHN0cnVjdCBkcm1faTkxNV9wcml2YXRlICppOTE1KQorewor CXN0cnVjdCBmaWxlX3N5c3RlbV90eXBlICp0eXBlOworCXN0cnVjdCB2ZnNtb3VudCAqZ2VtZnM7 CisKKwl0eXBlID0gZ2V0X2ZzX3R5cGUoInRtcGZzIik7CisJaWYgKCF0eXBlKQorCQlyZXR1cm4g LUVOT0RFVjsKKworCWdlbWZzID0ga2Vybl9tb3VudCh0eXBlKTsKKwlpZiAoSVNfRVJSKGdlbWZz KSkKKwkJcmV0dXJuIFBUUl9FUlIoZ2VtZnMpOworCisJaTkxNS0+bW0uZ2VtZnMgPSBnZW1mczsK KworCXJldHVybiAwOworfQorCit2b2lkIGk5MTVfZ2VtZnNfZmluaShzdHJ1Y3QgZHJtX2k5MTVf cHJpdmF0ZSAqaTkxNSkKK3sKKwlrZXJuX3VubW91bnQoaTkxNS0+bW0uZ2VtZnMpOworfQpkaWZm IC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJtL2k5MTUvaTkxNV9nZW1mcy5oIGIvZHJpdmVycy9ncHUv ZHJtL2k5MTUvaTkxNV9nZW1mcy5oCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAw MDAwMC4uY2NhOGJkYzViOTNlCi0tLSAvZGV2L251bGwKKysrIGIvZHJpdmVycy9ncHUvZHJtL2k5 MTUvaTkxNV9nZW1mcy5oCkBAIC0wLDAgKzEsMzQgQEAKKy8qCisgKiBDb3B5cmlnaHQgwqkgMjAx NyBJbnRlbCBDb3Jwb3JhdGlvbgorICoKKyAqIFBlcm1pc3Npb24gaXMgaGVyZWJ5IGdyYW50ZWQs IGZyZWUgb2YgY2hhcmdlLCB0byBhbnkgcGVyc29uIG9idGFpbmluZyBhCisgKiBjb3B5IG9mIHRo aXMgc29mdHdhcmUgYW5kIGFzc29jaWF0ZWQgZG9jdW1lbnRhdGlvbiBmaWxlcyAodGhlICJTb2Z0 d2FyZSIpLAorICogdG8gZGVhbCBpbiB0aGUgU29mdHdhcmUgd2l0aG91dCByZXN0cmljdGlvbiwg aW5jbHVkaW5nIHdpdGhvdXQgbGltaXRhdGlvbgorICogdGhlIHJpZ2h0cyB0byB1c2UsIGNvcHks IG1vZGlmeSwgbWVyZ2UsIHB1Ymxpc2gsIGRpc3RyaWJ1dGUsIHN1YmxpY2Vuc2UsCisgKiBhbmQv b3Igc2VsbCBjb3BpZXMgb2YgdGhlIFNvZnR3YXJlLCBhbmQgdG8gcGVybWl0IHBlcnNvbnMgdG8g d2hvbSB0aGUKKyAqIFNvZnR3YXJlIGlzIGZ1cm5pc2hlZCB0byBkbyBzbywgc3ViamVjdCB0byB0 aGUgZm9sbG93aW5nIGNvbmRpdGlvbnM6CisgKgorICogVGhlIGFib3ZlIGNvcHlyaWdodCBub3Rp Y2UgYW5kIHRoaXMgcGVybWlzc2lvbiBub3RpY2UgKGluY2x1ZGluZyB0aGUgbmV4dAorICogcGFy YWdyYXBoKSBzaGFsbCBiZSBpbmNsdWRlZCBpbiBhbGwgY29waWVzIG9yIHN1YnN0YW50aWFsIHBv cnRpb25zIG9mIHRoZQorICogU29mdHdhcmUuCisgKgorICogVEhFIFNPRlRXQVJFIElTIFBST1ZJ REVEICJBUyBJUyIsIFdJVEhPVVQgV0FSUkFOVFkgT0YgQU5ZIEtJTkQsIEVYUFJFU1MgT1IKKyAq IElNUExJRUQsIElOQ0xVRElORyBCVVQgTk9UIExJTUlURUQgVE8gVEhFIFdBUlJBTlRJRVMgT0Yg TUVSQ0hBTlRBQklMSVRZLAorICogRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UgQU5E IE5PTklORlJJTkdFTUVOVC4gIElOIE5PIEVWRU5UIFNIQUxMCisgKiBUSEUgQVVUSE9SUyBPUiBD T1BZUklHSFQgSE9MREVSUyBCRSBMSUFCTEUgRk9SIEFOWSBDTEFJTSwgREFNQUdFUyBPUiBPVEhF UgorICogTElBQklMSVRZLCBXSEVUSEVSIElOIEFOIEFDVElPTiBPRiBDT05UUkFDVCwgVE9SVCBP UiBPVEhFUldJU0UsIEFSSVNJTkcKKyAqIEZST00sIE9VVCBPRiBPUiBJTiBDT05ORUNUSU9OIFdJ VEggVEhFIFNPRlRXQVJFIE9SIFRIRSBVU0UgT1IgT1RIRVIgREVBTElOR1MKKyAqIElOIFRIRSBT T0ZUV0FSRS4KKyAqCisgKi8KKworI2lmbmRlZiBfX0k5MTVfR0VNRlNfSF9fCisjZGVmaW5lIF9f STkxNV9HRU1GU19IX18KKworc3RydWN0IGRybV9pOTE1X3ByaXZhdGU7CisKK2ludCBpOTE1X2dl bWZzX2luaXQoc3RydWN0IGRybV9pOTE1X3ByaXZhdGUgKmk5MTUpOworCit2b2lkIGk5MTVfZ2Vt ZnNfZmluaShzdHJ1Y3QgZHJtX2k5MTVfcHJpdmF0ZSAqaTkxNSk7CisKKyNlbmRpZgpkaWZmIC0t Z2l0IGEvZHJpdmVycy9ncHUvZHJtL2k5MTUvc2VsZnRlc3RzL21vY2tfZ2VtX2RldmljZS5jIGIv ZHJpdmVycy9ncHUvZHJtL2k5MTUvc2VsZnRlc3RzL21vY2tfZ2VtX2RldmljZS5jCmluZGV4IDIz ODg0MjRhMTRkYS4uZWQzNDA3YjA3OGU3IDEwMDY0NAotLS0gYS9kcml2ZXJzL2dwdS9kcm0vaTkx NS9zZWxmdGVzdHMvbW9ja19nZW1fZGV2aWNlLmMKKysrIGIvZHJpdmVycy9ncHUvZHJtL2k5MTUv c2VsZnRlc3RzL21vY2tfZ2VtX2RldmljZS5jCkBAIC04Myw2ICs4Myw4IEBAIHN0YXRpYyB2b2lk IG1vY2tfZGV2aWNlX3JlbGVhc2Uoc3RydWN0IGRybV9kZXZpY2UgKmRldikKIAlrbWVtX2NhY2hl X2Rlc3Ryb3koaTkxNS0+dm1hcyk7CiAJa21lbV9jYWNoZV9kZXN0cm95KGk5MTUtPm9iamVjdHMp OwogCisJaTkxNV9nZW1mc19maW5pKGk5MTUpOworCiAJZHJtX2Rldl9maW5pKCZpOTE1LT5kcm0p OwogCXB1dF9kZXZpY2UoJmk5MTUtPmRybS5wZGV2LT5kZXYpOwogfQpAQCAtMjM5LDYgKzI0MSw4 IEBAIHN0cnVjdCBkcm1faTkxNV9wcml2YXRlICptb2NrX2dlbV9kZXZpY2Uodm9pZCkKIAlpZiAo IWk5MTUtPmtlcm5lbF9jb250ZXh0KQogCQlnb3RvIGVycl9lbmdpbmU7CiAKKwlXQVJOX09OKGk5 MTVfZ2VtZnNfaW5pdChpOTE1KSk7CisKIAlyZXR1cm4gaTkxNTsKIAogZXJyX2VuZ2luZToKLS0g CjIuMTMuNQoKX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX18K SW50ZWwtZ2Z4IG1haWxpbmcgbGlzdApJbnRlbC1nZnhAbGlzdHMuZnJlZWRlc2t0b3Aub3JnCmh0 dHBzOi8vbGlzdHMuZnJlZWRlc2t0b3Aub3JnL21haWxtYW4vbGlzdGluZm8vaW50ZWwtZ2Z4Cg==