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=-9.6 required=3.0 tests=DKIM_SIGNED,DKIM_VALID, DKIM_VALID_AU,FREEMAIL_FORGED_FROMDOMAIN,FREEMAIL_FROM, HEADER_FROM_DIFFERENT_DOMAINS,INCLUDES_PATCH,MAILING_LIST_MULTI,SIGNED_OFF_BY, 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 75DD7C34047 for ; Wed, 19 Feb 2020 12:59:17 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [209.132.180.67]) by mail.kernel.org (Postfix) with ESMTP id 3C8362465D for ; Wed, 19 Feb 2020 12:59:17 +0000 (UTC) Authentication-Results: mail.kernel.org; dkim=pass (2048-bit key) header.d=gmail.com header.i=@gmail.com header.b="mYEJ1VRX" Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1727525AbgBSM7Q (ORCPT ); Wed, 19 Feb 2020 07:59:16 -0500 Received: from mail-wr1-f66.google.com ([209.85.221.66]:40433 "EHLO mail-wr1-f66.google.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1726786AbgBSM7Q (ORCPT ); Wed, 19 Feb 2020 07:59:16 -0500 Received: by mail-wr1-f66.google.com with SMTP id t3so405459wru.7 for ; Wed, 19 Feb 2020 04:59:12 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20161025; h=from:to:subject:date:message-id:mime-version :content-transfer-encoding; bh=eHSR65M1UxYKDgV0h05dvsavOHLsx/vkHuLWvTFUtV4=; b=mYEJ1VRXAH8td5GxLROlP5SO69QoYmRgF5bxx98EQIu/+xfEXnWmzB3LmnnMKDptoZ 1fnX/a/DPoFUDbXbHBoXAZ5OJUfnVb/jlTP+sbceimY6n81RX7BbP23zzb1I92x5siS7 Y/ah83uE5QkjaiERG6bXMUXNh6MSiYdPBOygXUukP0HC8AiFMpgE56qnLVe1AaYL5IKm kBrHiKUJ7riVp9+u/XtFAK+uHogOK68tJhUSVBykmhllILbfPvDNs/ByAK722mJx4Cog NxNfGTLQjctLpShhpyhlJUjHPiIIREHuBtusvHNFPZRUeuusV7Imn0FheO909FmrPSZ6 NxVA== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:from:to:subject:date:message-id:mime-version :content-transfer-encoding; bh=eHSR65M1UxYKDgV0h05dvsavOHLsx/vkHuLWvTFUtV4=; b=GdWbZgdS5TwXrpCVkqV7tPRKd56vxhb5SnXJsDqPZD0PhHWNQQLWs+Lmx4noVbBkKT 2FK7JozD7UIHnHO0LW2zU7/g+aBamJlDD/mYRXHXsZi1HGcrJO9At6CTS26HV7wrLp2I YsFif6xmx8c/u+fOxyL1caZsZlc/HEZKO2dzGzJcoY/zNVs35a7b2cAC+EG7DYslW8cR FbIOMbp+QoU4VKrO2Ren6hTpt53QnLBsED5Ny+U9RSqpXCFQcUr33RzMvItg8AGydHZB IIHQOtBvPJH8lX6xbdDN4PW3HBqZVHTvzpcjXRWBYkfK/wCsYlBd2dEw/ga04QzQl9N7 wvaw== X-Gm-Message-State: APjAAAUeE5fHYIpOeDG7zjDpr2wo7iEj3Wfq4mJrcg9Q+A9PfDd58LcI gCLb/fb9dRqt6KvWCLyUE/A= X-Google-Smtp-Source: APXvYqyegaZn838rtrQaoHTKprz6TGiIxIUg3oHkVuR8qdGXKH3wgiQyGji93MmJ80dj/IV8Vnr4Hw== X-Received: by 2002:a5d:4d4a:: with SMTP id a10mr37753965wru.220.1582117151751; Wed, 19 Feb 2020 04:59:11 -0800 (PST) Received: from abel.fritz.box ([2a02:908:1252:fb60:90ea:9d7:18a3:895e]) by smtp.gmail.com with ESMTPSA id h2sm3079024wrt.45.2020.02.19.04.59.10 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Wed, 19 Feb 2020 04:59:11 -0800 (PST) From: "=?UTF-8?q?Christian=20K=C3=B6nig?=" X-Google-Original-From: =?UTF-8?q?Christian=20K=C3=B6nig?= To: dri-devel@lists.freedesktop.org, linaro-mm-sig@lists.linaro.org, linux-media@vger.kernel.org, intel-gfx@lists.freedesktop.org, daniel@ffwll.ch Subject: [PATCH 1/7] dma-buf: add dynamic DMA-buf handling v15 Date: Wed, 19 Feb 2020 13:59:04 +0100 Message-Id: <20200219125910.89147-1-christian.koenig@amd.com> X-Mailer: git-send-email 2.17.1 MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Sender: linux-media-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: linux-media@vger.kernel.org On the exporter side we add optional explicit pinning callbacks. Which are called when the importer doesn't implement dynamic handling, move notification or need the DMA-buf locked in place for its use case. On the importer side we add an optional move_notify callback. This callback is used by the exporter to inform the importers that their mappings should be destroyed as soon as possible. This allows the exporter to provide the mappings without the need to pin the backing store. v2: don't try to invalidate mappings when the callback is NULL, lock the reservation obj while using the attachments, add helper to set the callback v3: move flag for invalidation support into the DMA-buf, use new attach_info structure to set the callback v4: use importer_priv field instead of mangling exporter priv. v5: drop invalidation_supported flag v6: squash together with pin/unpin changes v7: pin/unpin takes an attachment now v8: nuke dma_buf_attachment_(map|unmap)_locked, everything is now handled backward compatible v9: always cache when export/importer don't agree on dynamic handling v10: minimal style cleanup v11: drop automatically re-entry avoidance v12: rename callback to move_notify v13: add might_lock in appropriate places v14: rebase on separated locking change v15: add EXPERIMENTAL flag, some more code comments Signed-off-by: Christian König --- drivers/dma-buf/Kconfig | 10 ++ drivers/dma-buf/dma-buf.c | 110 ++++++++++++++++++-- drivers/gpu/drm/amd/amdgpu/amdgpu_dma_buf.c | 6 +- include/linux/dma-buf.h | 82 +++++++++++++-- 4 files changed, 188 insertions(+), 20 deletions(-) diff --git a/drivers/dma-buf/Kconfig b/drivers/dma-buf/Kconfig index e7d820ce0724..ef73b678419c 100644 --- a/drivers/dma-buf/Kconfig +++ b/drivers/dma-buf/Kconfig @@ -39,6 +39,16 @@ config UDMABUF A driver to let userspace turn memfd regions into dma-bufs. Qemu can use this to create host dmabufs for guest framebuffers. +config DMABUF_MOVE_NOTIFY + bool "Move notify between drivers (EXPERIMENTAL)" + default n + help + Don''t pin buffers if the dynamic DMA-buf interface is available on both the + exporter as well as the importer. This fixes a security problem where + userspace is able to pin unrestricted amounts of memory through DMA-buf. + But marked experimental because we don''t jet have a consistent execution + context and memory management between drivers. + config DMABUF_SELFTESTS tristate "Selftests for the dma-buf interfaces" default n diff --git a/drivers/dma-buf/dma-buf.c b/drivers/dma-buf/dma-buf.c index d4097856c86b..5f10d1929476 100644 --- a/drivers/dma-buf/dma-buf.c +++ b/drivers/dma-buf/dma-buf.c @@ -527,6 +527,10 @@ struct dma_buf *dma_buf_export(const struct dma_buf_export_info *exp_info) exp_info->ops->dynamic_mapping)) return ERR_PTR(-EINVAL); + if (WARN_ON(!exp_info->ops->dynamic_mapping && + (exp_info->ops->pin || exp_info->ops->unpin))) + return ERR_PTR(-EINVAL); + if (!try_module_get(exp_info->owner)) return ERR_PTR(-ENOENT); @@ -651,7 +655,8 @@ EXPORT_SYMBOL_GPL(dma_buf_put); * calls attach() of dma_buf_ops to allow device-specific attach functionality * @dmabuf: [in] buffer to attach device to. * @dev: [in] device to be attached. - * @dynamic_mapping: [in] calling convention for map/unmap + * @importer_ops [in] importer operations for the attachment + * @importer_priv [in] importer private pointer for the attachment * * Returns struct dma_buf_attachment pointer for this attachment. Attachments * must be cleaned up by calling dma_buf_detach(). @@ -667,11 +672,13 @@ EXPORT_SYMBOL_GPL(dma_buf_put); */ struct dma_buf_attachment * dma_buf_dynamic_attach(struct dma_buf *dmabuf, struct device *dev, - bool dynamic_mapping) + const struct dma_buf_attach_ops *importer_ops, + void *importer_priv) { struct dma_buf_attachment *attach; int ret; + /* TODO: make move_notify mandatory if importer_ops are provided. */ if (WARN_ON(!dmabuf || !dev)) return ERR_PTR(-EINVAL); @@ -681,7 +688,8 @@ dma_buf_dynamic_attach(struct dma_buf *dmabuf, struct device *dev, attach->dev = dev; attach->dmabuf = dmabuf; - attach->dynamic_mapping = dynamic_mapping; + attach->importer_ops = importer_ops; + attach->importer_priv = importer_priv; if (dmabuf->ops->attach) { ret = dmabuf->ops->attach(dmabuf, attach); @@ -700,15 +708,19 @@ dma_buf_dynamic_attach(struct dma_buf *dmabuf, struct device *dev, dma_buf_is_dynamic(dmabuf)) { struct sg_table *sgt; - if (dma_buf_is_dynamic(attach->dmabuf)) + if (dma_buf_is_dynamic(attach->dmabuf)) { dma_resv_lock(attach->dmabuf->resv, NULL); + ret = dma_buf_pin(attach); + if (ret) + goto err_unlock; + } sgt = dmabuf->ops->map_dma_buf(attach, DMA_BIDIRECTIONAL); if (!sgt) sgt = ERR_PTR(-ENOMEM); if (IS_ERR(sgt)) { ret = PTR_ERR(sgt); - goto err_unlock; + goto err_unpin; } if (dma_buf_is_dynamic(attach->dmabuf)) dma_resv_unlock(attach->dmabuf->resv); @@ -722,6 +734,10 @@ dma_buf_dynamic_attach(struct dma_buf *dmabuf, struct device *dev, kfree(attach); return ERR_PTR(ret); +err_unpin: + if (dma_buf_is_dynamic(attach->dmabuf)) + dma_buf_unpin(attach); + err_unlock: if (dma_buf_is_dynamic(attach->dmabuf)) dma_resv_unlock(attach->dmabuf->resv); @@ -742,7 +758,7 @@ EXPORT_SYMBOL_GPL(dma_buf_dynamic_attach); struct dma_buf_attachment *dma_buf_attach(struct dma_buf *dmabuf, struct device *dev) { - return dma_buf_dynamic_attach(dmabuf, dev, false); + return dma_buf_dynamic_attach(dmabuf, dev, NULL, NULL); } EXPORT_SYMBOL_GPL(dma_buf_attach); @@ -765,8 +781,10 @@ void dma_buf_detach(struct dma_buf *dmabuf, struct dma_buf_attachment *attach) dmabuf->ops->unmap_dma_buf(attach, attach->sgt, attach->dir); - if (dma_buf_is_dynamic(attach->dmabuf)) + if (dma_buf_is_dynamic(attach->dmabuf)) { + dma_buf_unpin(attach); dma_resv_unlock(attach->dmabuf->resv); + } } dma_resv_lock(dmabuf->resv, NULL); @@ -779,6 +797,44 @@ void dma_buf_detach(struct dma_buf *dmabuf, struct dma_buf_attachment *attach) } EXPORT_SYMBOL_GPL(dma_buf_detach); +/** + * dma_buf_pin - Lock down the DMA-buf + * + * @attach: [in] attachment which should be pinned + * + * Returns: + * 0 on success, negative error code on failure. + */ +int dma_buf_pin(struct dma_buf_attachment *attach) +{ + struct dma_buf *dmabuf = attach->dmabuf; + int ret = 0; + + dma_resv_assert_held(dmabuf->resv); + + if (dmabuf->ops->pin) + ret = dmabuf->ops->pin(attach); + + return ret; +} +EXPORT_SYMBOL_GPL(dma_buf_pin); + +/** + * dma_buf_unpin - Remove lock from DMA-buf + * + * @attach: [in] attachment which should be unpinned + */ +void dma_buf_unpin(struct dma_buf_attachment *attach) +{ + struct dma_buf *dmabuf = attach->dmabuf; + + dma_resv_assert_held(dmabuf->resv); + + if (dmabuf->ops->unpin) + dmabuf->ops->unpin(attach); +} +EXPORT_SYMBOL_GPL(dma_buf_unpin); + /** * dma_buf_map_attachment - Returns the scatterlist table of the attachment; * mapped into _device_ address space. Is a wrapper for map_dma_buf() of the @@ -798,6 +854,7 @@ struct sg_table *dma_buf_map_attachment(struct dma_buf_attachment *attach, enum dma_data_direction direction) { struct sg_table *sg_table; + int r; might_sleep(); @@ -819,13 +876,25 @@ struct sg_table *dma_buf_map_attachment(struct dma_buf_attachment *attach, return attach->sgt; } - if (dma_buf_is_dynamic(attach->dmabuf)) + if (dma_buf_is_dynamic(attach->dmabuf)) { dma_resv_assert_held(attach->dmabuf->resv); + if (!attach->importer_ops->move_notify || + !IS_ENABLED(CONFIG_DMABUF_MOVE_NOTIFY)) { + r = dma_buf_pin(attach); + if (r) + return ERR_PTR(r); + } + } sg_table = attach->dmabuf->ops->map_dma_buf(attach, direction); if (!sg_table) sg_table = ERR_PTR(-ENOMEM); + if (IS_ERR(sg_table) && dma_buf_is_dynamic(attach->dmabuf) && + (!attach->importer_ops->move_notify || + !IS_ENABLED(CONFIG_DMABUF_MOVE_NOTIFY))) + dma_buf_unpin(attach); + if (!IS_ERR(sg_table) && attach->dmabuf->ops->cache_sgt_mapping) { attach->sgt = sg_table; attach->dir = direction; @@ -864,9 +933,34 @@ void dma_buf_unmap_attachment(struct dma_buf_attachment *attach, dma_resv_assert_held(attach->dmabuf->resv); attach->dmabuf->ops->unmap_dma_buf(attach, sg_table, direction); + + if (dma_buf_is_dynamic(attach->dmabuf) && + (!attach->importer_ops->move_notify || + !IS_ENABLED(CONFIG_DMABUF_MOVE_NOTIFY))) + dma_buf_unpin(attach); } EXPORT_SYMBOL_GPL(dma_buf_unmap_attachment); +/** + * dma_buf_move_notify - notify attachments that DMA-buf is moving + * + * @dmabuf: [in] buffer which is moving + * + * Informs all attachmenst that they need to destroy and recreated all their + * mappings. + */ +void dma_buf_move_notify(struct dma_buf *dmabuf) +{ + struct dma_buf_attachment *attach; + + dma_resv_assert_held(dmabuf->resv); + + list_for_each_entry(attach, &dmabuf->attachments, node) + if (attach->importer_ops && attach->importer_ops->move_notify) + attach->importer_ops->move_notify(attach); +} +EXPORT_SYMBOL_GPL(dma_buf_move_notify); + /** * DOC: cpu access * diff --git a/drivers/gpu/drm/amd/amdgpu/amdgpu_dma_buf.c b/drivers/gpu/drm/amd/amdgpu/amdgpu_dma_buf.c index a59cd47aa6c1..7cafc65fd76a 100644 --- a/drivers/gpu/drm/amd/amdgpu/amdgpu_dma_buf.c +++ b/drivers/gpu/drm/amd/amdgpu/amdgpu_dma_buf.c @@ -412,6 +412,9 @@ amdgpu_dma_buf_create_obj(struct drm_device *dev, struct dma_buf *dma_buf) return ERR_PTR(ret); } +static const struct dma_buf_attach_ops amdgpu_dma_buf_attach_ops = { +}; + /** * amdgpu_gem_prime_import - &drm_driver.gem_prime_import implementation * @dev: DRM device @@ -444,7 +447,8 @@ struct drm_gem_object *amdgpu_gem_prime_import(struct drm_device *dev, if (IS_ERR(obj)) return obj; - attach = dma_buf_dynamic_attach(dma_buf, dev->dev, true); + attach = dma_buf_dynamic_attach(dma_buf, dev->dev, + &amdgpu_dma_buf_attach_ops, NULL); if (IS_ERR(attach)) { drm_gem_object_put(obj); return ERR_CAST(attach); diff --git a/include/linux/dma-buf.h b/include/linux/dma-buf.h index abf5459a5b9d..b38cea240b67 100644 --- a/include/linux/dma-buf.h +++ b/include/linux/dma-buf.h @@ -93,14 +93,41 @@ struct dma_buf_ops { */ void (*detach)(struct dma_buf *, struct dma_buf_attachment *); + /** + * @pin: + * + * This is called by dma_buf_pin and lets the exporter know that the + * DMA-buf can't be moved any more. + * + * This is called with the dmabuf->resv object locked. + * + * This callback is optional and should only be used in limited use + * cases like scanout and not for temporary pin operations. + * + * Returns: + * + * 0 on success, negative error code on failure. + */ + int (*pin)(struct dma_buf_attachment *attach); + + /** + * @unpin: + * + * This is called by dma_buf_unpin and lets the exporter know that the + * DMA-buf can be moved again. + * + * This is called with the dmabuf->resv object locked. + * + * This callback is optional. + */ + void (*unpin)(struct dma_buf_attachment *attach); + /** * @map_dma_buf: * * This is called by dma_buf_map_attachment() and is used to map a * shared &dma_buf into device address space, and it is mandatory. It - * can only be called if @attach has been called successfully. This - * essentially pins the DMA buffer into place, and it cannot be moved - * any more + * can only be called if @attach has been called successfully. * * This call may sleep, e.g. when the backing storage first needs to be * allocated, or moved to a location suitable for all currently attached @@ -141,9 +168,8 @@ struct dma_buf_ops { * * This is called by dma_buf_unmap_attachment() and should unmap and * release the &sg_table allocated in @map_dma_buf, and it is mandatory. - * It should also unpin the backing storage if this is the last mapping - * of the DMA buffer, it the exporter supports backing storage - * migration. + * For static dma_buf handling this might also unpins the backing + * storage if this is the last mapping of the DMA buffer. */ void (*unmap_dma_buf)(struct dma_buf_attachment *, struct sg_table *, @@ -311,6 +337,34 @@ struct dma_buf { } cb_excl, cb_shared; }; +/** + * struct dma_buf_attach_ops - importer operations for an attachment + * @move_notify: [optional] notification that the DMA-buf is moving + * + * Attachment operations implemented by the importer. + */ +struct dma_buf_attach_ops { + /** + * @move_notify + * + * If this callback is provided the framework can avoid pinning the + * backing store while mappings exists. + * + * This callback is called with the lock of the reservation object + * associated with the dma_buf held and the mapping function must be + * called with this lock held as well. This makes sure that no mapping + * is created concurrently with an ongoing move operation. + * + * Mappings stay valid and are not directly affected by this callback. + * But the DMA-buf can now be in a different physical location, so all + * mappings should be destroyed and re-created as soon as possible. + * + * New mappings can be created after this callback returns, and will + * point to the new location of the DMA-buf. + */ + void (*move_notify)(struct dma_buf_attachment *attach); +}; + /** * struct dma_buf_attachment - holds device-buffer attachment data * @dmabuf: buffer for this attachment. @@ -319,8 +373,9 @@ struct dma_buf { * @sgt: cached mapping. * @dir: direction of cached mapping. * @priv: exporter specific attachment data. - * @dynamic_mapping: true if dma_buf_map/unmap_attachment() is called with the - * dma_resv lock held. + * @importer_ops: importer operations for this attachment, if provided + * dma_buf_map/unmap_attachment() must be called with the dma_resv lock held. + * @importer_priv: importer specific attachment data. * * This structure holds the attachment information between the dma_buf buffer * and its user device(s). The list contains one attachment struct per device @@ -337,7 +392,8 @@ struct dma_buf_attachment { struct list_head node; struct sg_table *sgt; enum dma_data_direction dir; - bool dynamic_mapping; + const struct dma_buf_attach_ops *importer_ops; + void *importer_priv; void *priv; }; @@ -399,6 +455,7 @@ static inline void get_dma_buf(struct dma_buf *dmabuf) */ static inline bool dma_buf_is_dynamic(struct dma_buf *dmabuf) { + /* TODO: switch to using pin/unpin functions as indicator. */ return dmabuf->ops->dynamic_mapping; } @@ -413,16 +470,19 @@ static inline bool dma_buf_is_dynamic(struct dma_buf *dmabuf) static inline bool dma_buf_attachment_is_dynamic(struct dma_buf_attachment *attach) { - return attach->dynamic_mapping; + return !!attach->importer_ops; } struct dma_buf_attachment *dma_buf_attach(struct dma_buf *dmabuf, struct device *dev); struct dma_buf_attachment * dma_buf_dynamic_attach(struct dma_buf *dmabuf, struct device *dev, - bool dynamic_mapping); + const struct dma_buf_attach_ops *importer_ops, + void *importer_priv); void dma_buf_detach(struct dma_buf *dmabuf, struct dma_buf_attachment *attach); +int dma_buf_pin(struct dma_buf_attachment *attach); +void dma_buf_unpin(struct dma_buf_attachment *attach); struct dma_buf *dma_buf_export(const struct dma_buf_export_info *exp_info); -- 2.17.1 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=-9.3 required=3.0 tests=DKIM_ADSP_CUSTOM_MED, DKIM_INVALID,DKIM_SIGNED,FREEMAIL_FORGED_FROMDOMAIN,FREEMAIL_FROM, HEADER_FROM_DIFFERENT_DOMAINS,INCLUDES_PATCH,MAILING_LIST_MULTI,SIGNED_OFF_BY, 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 1B0A4C3404D for ; Wed, 19 Feb 2020 12:59: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 E42F920801 for ; Wed, 19 Feb 2020 12:59:15 +0000 (UTC) Authentication-Results: mail.kernel.org; dkim=fail reason="signature verification failed" (2048-bit key) header.d=gmail.com header.i=@gmail.com header.b="mYEJ1VRX" DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org E42F920801 Authentication-Results: mail.kernel.org; dmarc=fail (p=none dis=none) header.from=gmail.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 29CC96EBC9; Wed, 19 Feb 2020 12:59:15 +0000 (UTC) Received: from mail-wr1-x441.google.com (mail-wr1-x441.google.com [IPv6:2a00:1450:4864:20::441]) by gabe.freedesktop.org (Postfix) with ESMTPS id CD8416E5B2; Wed, 19 Feb 2020 12:59:13 +0000 (UTC) Received: by mail-wr1-x441.google.com with SMTP id w12so447927wrt.2; Wed, 19 Feb 2020 04:59:13 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20161025; h=from:to:subject:date:message-id:mime-version :content-transfer-encoding; bh=eHSR65M1UxYKDgV0h05dvsavOHLsx/vkHuLWvTFUtV4=; b=mYEJ1VRXAH8td5GxLROlP5SO69QoYmRgF5bxx98EQIu/+xfEXnWmzB3LmnnMKDptoZ 1fnX/a/DPoFUDbXbHBoXAZ5OJUfnVb/jlTP+sbceimY6n81RX7BbP23zzb1I92x5siS7 Y/ah83uE5QkjaiERG6bXMUXNh6MSiYdPBOygXUukP0HC8AiFMpgE56qnLVe1AaYL5IKm kBrHiKUJ7riVp9+u/XtFAK+uHogOK68tJhUSVBykmhllILbfPvDNs/ByAK722mJx4Cog NxNfGTLQjctLpShhpyhlJUjHPiIIREHuBtusvHNFPZRUeuusV7Imn0FheO909FmrPSZ6 NxVA== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:from:to:subject:date:message-id:mime-version :content-transfer-encoding; bh=eHSR65M1UxYKDgV0h05dvsavOHLsx/vkHuLWvTFUtV4=; b=IAMNdlH9T45DIUwCpNUY9l1nMSO8MHVR+35Qyv5Yq8H1boNNZq//E5wIu/NhQ2r+zQ MbS15XmbsOr2X0LIUUi+M9BcUtYnrn4QZDKvq7b56GpPTEntt4o918fFq6s23QvzQQn8 umB/Erl9yc8yEc6FLv6BCpFdSTc2y4ryO3anc4923AGiRhH6kGBg2S8UDaI2Xon89PaV 2UMPncqsYVw4b+MvYlDAwjASCNWX/Bkh0h1Vy4KuicaHuXMnyTn3c5zxWIFwHyM0LVpH hav0KFuHAx6SJvv8gYP0IQRaMKEZqqqaTWBmOr1Vh3NzkyexxMwjwf8Xs+9ZsjsMId4o t8OA== X-Gm-Message-State: APjAAAUmx0kIvJDQX9CMbaIwhlBuXkB+FOGayXpEXUwrSuTXmpY/oMv5 r/lhghTlgN79qvTICtifZCR7j8zJ X-Google-Smtp-Source: APXvYqyegaZn838rtrQaoHTKprz6TGiIxIUg3oHkVuR8qdGXKH3wgiQyGji93MmJ80dj/IV8Vnr4Hw== X-Received: by 2002:a5d:4d4a:: with SMTP id a10mr37753965wru.220.1582117151751; Wed, 19 Feb 2020 04:59:11 -0800 (PST) Received: from abel.fritz.box ([2a02:908:1252:fb60:90ea:9d7:18a3:895e]) by smtp.gmail.com with ESMTPSA id h2sm3079024wrt.45.2020.02.19.04.59.10 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Wed, 19 Feb 2020 04:59:11 -0800 (PST) From: "=?UTF-8?q?Christian=20K=C3=B6nig?=" X-Google-Original-From: =?UTF-8?q?Christian=20K=C3=B6nig?= To: dri-devel@lists.freedesktop.org, linaro-mm-sig@lists.linaro.org, linux-media@vger.kernel.org, intel-gfx@lists.freedesktop.org, daniel@ffwll.ch Subject: [PATCH 1/7] dma-buf: add dynamic DMA-buf handling v15 Date: Wed, 19 Feb 2020 13:59:04 +0100 Message-Id: <20200219125910.89147-1-christian.koenig@amd.com> X-Mailer: git-send-email 2.17.1 MIME-Version: 1.0 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: , Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Errors-To: dri-devel-bounces@lists.freedesktop.org Sender: "dri-devel" T24gdGhlIGV4cG9ydGVyIHNpZGUgd2UgYWRkIG9wdGlvbmFsIGV4cGxpY2l0IHBpbm5pbmcgY2Fs bGJhY2tzLiBXaGljaCBhcmUKY2FsbGVkIHdoZW4gdGhlIGltcG9ydGVyIGRvZXNuJ3QgaW1wbGVt ZW50IGR5bmFtaWMgaGFuZGxpbmcsIG1vdmUgbm90aWZpY2F0aW9uCm9yIG5lZWQgdGhlIERNQS1i dWYgbG9ja2VkIGluIHBsYWNlIGZvciBpdHMgdXNlIGNhc2UuCgpPbiB0aGUgaW1wb3J0ZXIgc2lk ZSB3ZSBhZGQgYW4gb3B0aW9uYWwgbW92ZV9ub3RpZnkgY2FsbGJhY2suIFRoaXMgY2FsbGJhY2sg aXMKdXNlZCBieSB0aGUgZXhwb3J0ZXIgdG8gaW5mb3JtIHRoZSBpbXBvcnRlcnMgdGhhdCB0aGVp ciBtYXBwaW5ncyBzaG91bGQgYmUKZGVzdHJveWVkIGFzIHNvb24gYXMgcG9zc2libGUuCgpUaGlz IGFsbG93cyB0aGUgZXhwb3J0ZXIgdG8gcHJvdmlkZSB0aGUgbWFwcGluZ3Mgd2l0aG91dCB0aGUg bmVlZCB0byBwaW4KdGhlIGJhY2tpbmcgc3RvcmUuCgp2MjogZG9uJ3QgdHJ5IHRvIGludmFsaWRh dGUgbWFwcGluZ3Mgd2hlbiB0aGUgY2FsbGJhY2sgaXMgTlVMTCwKICAgIGxvY2sgdGhlIHJlc2Vy dmF0aW9uIG9iaiB3aGlsZSB1c2luZyB0aGUgYXR0YWNobWVudHMsCiAgICBhZGQgaGVscGVyIHRv IHNldCB0aGUgY2FsbGJhY2sKdjM6IG1vdmUgZmxhZyBmb3IgaW52YWxpZGF0aW9uIHN1cHBvcnQg aW50byB0aGUgRE1BLWJ1ZiwKICAgIHVzZSBuZXcgYXR0YWNoX2luZm8gc3RydWN0dXJlIHRvIHNl dCB0aGUgY2FsbGJhY2sKdjQ6IHVzZSBpbXBvcnRlcl9wcml2IGZpZWxkIGluc3RlYWQgb2YgbWFu Z2xpbmcgZXhwb3J0ZXIgcHJpdi4KdjU6IGRyb3AgaW52YWxpZGF0aW9uX3N1cHBvcnRlZCBmbGFn CnY2OiBzcXVhc2ggdG9nZXRoZXIgd2l0aCBwaW4vdW5waW4gY2hhbmdlcwp2NzogcGluL3VucGlu IHRha2VzIGFuIGF0dGFjaG1lbnQgbm93CnY4OiBudWtlIGRtYV9idWZfYXR0YWNobWVudF8obWFw fHVubWFwKV9sb2NrZWQsCiAgICBldmVyeXRoaW5nIGlzIG5vdyBoYW5kbGVkIGJhY2t3YXJkIGNv bXBhdGlibGUKdjk6IGFsd2F5cyBjYWNoZSB3aGVuIGV4cG9ydC9pbXBvcnRlciBkb24ndCBhZ3Jl ZSBvbiBkeW5hbWljIGhhbmRsaW5nCnYxMDogbWluaW1hbCBzdHlsZSBjbGVhbnVwCnYxMTogZHJv cCBhdXRvbWF0aWNhbGx5IHJlLWVudHJ5IGF2b2lkYW5jZQp2MTI6IHJlbmFtZSBjYWxsYmFjayB0 byBtb3ZlX25vdGlmeQp2MTM6IGFkZCBtaWdodF9sb2NrIGluIGFwcHJvcHJpYXRlIHBsYWNlcwp2 MTQ6IHJlYmFzZSBvbiBzZXBhcmF0ZWQgbG9ja2luZyBjaGFuZ2UKdjE1OiBhZGQgRVhQRVJJTUVO VEFMIGZsYWcsIHNvbWUgbW9yZSBjb2RlIGNvbW1lbnRzCgpTaWduZWQtb2ZmLWJ5OiBDaHJpc3Rp YW4gS8O2bmlnIDxjaHJpc3RpYW4ua29lbmlnQGFtZC5jb20+Ci0tLQogZHJpdmVycy9kbWEtYnVm L0tjb25maWcgICAgICAgICAgICAgICAgICAgICB8ICAxMCArKwogZHJpdmVycy9kbWEtYnVmL2Rt YS1idWYuYyAgICAgICAgICAgICAgICAgICB8IDExMCArKysrKysrKysrKysrKysrKystLQogZHJp dmVycy9ncHUvZHJtL2FtZC9hbWRncHUvYW1kZ3B1X2RtYV9idWYuYyB8ICAgNiArLQogaW5jbHVk ZS9saW51eC9kbWEtYnVmLmggICAgICAgICAgICAgICAgICAgICB8ICA4MiArKysrKysrKysrKysr LS0KIDQgZmlsZXMgY2hhbmdlZCwgMTg4IGluc2VydGlvbnMoKyksIDIwIGRlbGV0aW9ucygtKQoK ZGlmZiAtLWdpdCBhL2RyaXZlcnMvZG1hLWJ1Zi9LY29uZmlnIGIvZHJpdmVycy9kbWEtYnVmL0tj b25maWcKaW5kZXggZTdkODIwY2UwNzI0Li5lZjczYjY3ODQxOWMgMTAwNjQ0Ci0tLSBhL2RyaXZl cnMvZG1hLWJ1Zi9LY29uZmlnCisrKyBiL2RyaXZlcnMvZG1hLWJ1Zi9LY29uZmlnCkBAIC0zOSw2 ICszOSwxNiBAQCBjb25maWcgVURNQUJVRgogCSAgQSBkcml2ZXIgdG8gbGV0IHVzZXJzcGFjZSB0 dXJuIG1lbWZkIHJlZ2lvbnMgaW50byBkbWEtYnVmcy4KIAkgIFFlbXUgY2FuIHVzZSB0aGlzIHRv IGNyZWF0ZSBob3N0IGRtYWJ1ZnMgZm9yIGd1ZXN0IGZyYW1lYnVmZmVycy4KIAorY29uZmlnIERN QUJVRl9NT1ZFX05PVElGWQorCWJvb2wgIk1vdmUgbm90aWZ5IGJldHdlZW4gZHJpdmVycyAoRVhQ RVJJTUVOVEFMKSIKKwlkZWZhdWx0IG4KKwloZWxwCisJICBEb24nJ3QgcGluIGJ1ZmZlcnMgaWYg dGhlIGR5bmFtaWMgRE1BLWJ1ZiBpbnRlcmZhY2UgaXMgYXZhaWxhYmxlIG9uIGJvdGggdGhlCisJ ICBleHBvcnRlciBhcyB3ZWxsIGFzIHRoZSBpbXBvcnRlci4gVGhpcyBmaXhlcyBhIHNlY3VyaXR5 IHByb2JsZW0gd2hlcmUKKwkgIHVzZXJzcGFjZSBpcyBhYmxlIHRvIHBpbiB1bnJlc3RyaWN0ZWQg YW1vdW50cyBvZiBtZW1vcnkgdGhyb3VnaCBETUEtYnVmLgorCSAgQnV0IG1hcmtlZCBleHBlcmlt ZW50YWwgYmVjYXVzZSB3ZSBkb24nJ3QgamV0IGhhdmUgYSBjb25zaXN0ZW50IGV4ZWN1dGlvbgor CSAgY29udGV4dCBhbmQgbWVtb3J5IG1hbmFnZW1lbnQgYmV0d2VlbiBkcml2ZXJzLgorCiBjb25m aWcgRE1BQlVGX1NFTEZURVNUUwogCXRyaXN0YXRlICJTZWxmdGVzdHMgZm9yIHRoZSBkbWEtYnVm IGludGVyZmFjZXMiCiAJZGVmYXVsdCBuCmRpZmYgLS1naXQgYS9kcml2ZXJzL2RtYS1idWYvZG1h LWJ1Zi5jIGIvZHJpdmVycy9kbWEtYnVmL2RtYS1idWYuYwppbmRleCBkNDA5Nzg1NmM4NmIuLjVm MTBkMTkyOTQ3NiAxMDA2NDQKLS0tIGEvZHJpdmVycy9kbWEtYnVmL2RtYS1idWYuYworKysgYi9k cml2ZXJzL2RtYS1idWYvZG1hLWJ1Zi5jCkBAIC01MjcsNiArNTI3LDEwIEBAIHN0cnVjdCBkbWFf YnVmICpkbWFfYnVmX2V4cG9ydChjb25zdCBzdHJ1Y3QgZG1hX2J1Zl9leHBvcnRfaW5mbyAqZXhw X2luZm8pCiAJCSAgICBleHBfaW5mby0+b3BzLT5keW5hbWljX21hcHBpbmcpKQogCQlyZXR1cm4g RVJSX1BUUigtRUlOVkFMKTsKIAorCWlmIChXQVJOX09OKCFleHBfaW5mby0+b3BzLT5keW5hbWlj X21hcHBpbmcgJiYKKwkJICAgIChleHBfaW5mby0+b3BzLT5waW4gfHwgZXhwX2luZm8tPm9wcy0+ dW5waW4pKSkKKwkJcmV0dXJuIEVSUl9QVFIoLUVJTlZBTCk7CisKIAlpZiAoIXRyeV9tb2R1bGVf Z2V0KGV4cF9pbmZvLT5vd25lcikpCiAJCXJldHVybiBFUlJfUFRSKC1FTk9FTlQpOwogCkBAIC02 NTEsNyArNjU1LDggQEAgRVhQT1JUX1NZTUJPTF9HUEwoZG1hX2J1Zl9wdXQpOwogICogY2FsbHMg YXR0YWNoKCkgb2YgZG1hX2J1Zl9vcHMgdG8gYWxsb3cgZGV2aWNlLXNwZWNpZmljIGF0dGFjaCBm dW5jdGlvbmFsaXR5CiAgKiBAZG1hYnVmOgkJW2luXQlidWZmZXIgdG8gYXR0YWNoIGRldmljZSB0 by4KICAqIEBkZXY6CQlbaW5dCWRldmljZSB0byBiZSBhdHRhY2hlZC4KLSAqIEBkeW5hbWljX21h cHBpbmc6CVtpbl0JY2FsbGluZyBjb252ZW50aW9uIGZvciBtYXAvdW5tYXAKKyAqIEBpbXBvcnRl cl9vcHMJW2luXQlpbXBvcnRlciBvcGVyYXRpb25zIGZvciB0aGUgYXR0YWNobWVudAorICogQGlt cG9ydGVyX3ByaXYJW2luXQlpbXBvcnRlciBwcml2YXRlIHBvaW50ZXIgZm9yIHRoZSBhdHRhY2ht ZW50CiAgKgogICogUmV0dXJucyBzdHJ1Y3QgZG1hX2J1Zl9hdHRhY2htZW50IHBvaW50ZXIgZm9y IHRoaXMgYXR0YWNobWVudC4gQXR0YWNobWVudHMKICAqIG11c3QgYmUgY2xlYW5lZCB1cCBieSBj YWxsaW5nIGRtYV9idWZfZGV0YWNoKCkuCkBAIC02NjcsMTEgKzY3MiwxMyBAQCBFWFBPUlRfU1lN Qk9MX0dQTChkbWFfYnVmX3B1dCk7CiAgKi8KIHN0cnVjdCBkbWFfYnVmX2F0dGFjaG1lbnQgKgog ZG1hX2J1Zl9keW5hbWljX2F0dGFjaChzdHJ1Y3QgZG1hX2J1ZiAqZG1hYnVmLCBzdHJ1Y3QgZGV2 aWNlICpkZXYsCi0JCSAgICAgICBib29sIGR5bmFtaWNfbWFwcGluZykKKwkJICAgICAgIGNvbnN0 IHN0cnVjdCBkbWFfYnVmX2F0dGFjaF9vcHMgKmltcG9ydGVyX29wcywKKwkJICAgICAgIHZvaWQg KmltcG9ydGVyX3ByaXYpCiB7CiAJc3RydWN0IGRtYV9idWZfYXR0YWNobWVudCAqYXR0YWNoOwog CWludCByZXQ7CiAKKwkvKiBUT0RPOiBtYWtlIG1vdmVfbm90aWZ5IG1hbmRhdG9yeSBpZiBpbXBv cnRlcl9vcHMgYXJlIHByb3ZpZGVkLiAqLwogCWlmIChXQVJOX09OKCFkbWFidWYgfHwgIWRldikp CiAJCXJldHVybiBFUlJfUFRSKC1FSU5WQUwpOwogCkBAIC02ODEsNyArNjg4LDggQEAgZG1hX2J1 Zl9keW5hbWljX2F0dGFjaChzdHJ1Y3QgZG1hX2J1ZiAqZG1hYnVmLCBzdHJ1Y3QgZGV2aWNlICpk ZXYsCiAKIAlhdHRhY2gtPmRldiA9IGRldjsKIAlhdHRhY2gtPmRtYWJ1ZiA9IGRtYWJ1ZjsKLQlh dHRhY2gtPmR5bmFtaWNfbWFwcGluZyA9IGR5bmFtaWNfbWFwcGluZzsKKwlhdHRhY2gtPmltcG9y dGVyX29wcyA9IGltcG9ydGVyX29wczsKKwlhdHRhY2gtPmltcG9ydGVyX3ByaXYgPSBpbXBvcnRl cl9wcml2OwogCiAJaWYgKGRtYWJ1Zi0+b3BzLT5hdHRhY2gpIHsKIAkJcmV0ID0gZG1hYnVmLT5v cHMtPmF0dGFjaChkbWFidWYsIGF0dGFjaCk7CkBAIC03MDAsMTUgKzcwOCwxOSBAQCBkbWFfYnVm X2R5bmFtaWNfYXR0YWNoKHN0cnVjdCBkbWFfYnVmICpkbWFidWYsIHN0cnVjdCBkZXZpY2UgKmRl diwKIAkgICAgZG1hX2J1Zl9pc19keW5hbWljKGRtYWJ1ZikpIHsKIAkJc3RydWN0IHNnX3RhYmxl ICpzZ3Q7CiAKLQkJaWYgKGRtYV9idWZfaXNfZHluYW1pYyhhdHRhY2gtPmRtYWJ1ZikpCisJCWlm IChkbWFfYnVmX2lzX2R5bmFtaWMoYXR0YWNoLT5kbWFidWYpKSB7CiAJCQlkbWFfcmVzdl9sb2Nr KGF0dGFjaC0+ZG1hYnVmLT5yZXN2LCBOVUxMKTsKKwkJCXJldCA9IGRtYV9idWZfcGluKGF0dGFj aCk7CisJCQlpZiAocmV0KQorCQkJCWdvdG8gZXJyX3VubG9jazsKKwkJfQogCiAJCXNndCA9IGRt YWJ1Zi0+b3BzLT5tYXBfZG1hX2J1ZihhdHRhY2gsIERNQV9CSURJUkVDVElPTkFMKTsKIAkJaWYg KCFzZ3QpCiAJCQlzZ3QgPSBFUlJfUFRSKC1FTk9NRU0pOwogCQlpZiAoSVNfRVJSKHNndCkpIHsK IAkJCXJldCA9IFBUUl9FUlIoc2d0KTsKLQkJCWdvdG8gZXJyX3VubG9jazsKKwkJCWdvdG8gZXJy X3VucGluOwogCQl9CiAJCWlmIChkbWFfYnVmX2lzX2R5bmFtaWMoYXR0YWNoLT5kbWFidWYpKQog CQkJZG1hX3Jlc3ZfdW5sb2NrKGF0dGFjaC0+ZG1hYnVmLT5yZXN2KTsKQEAgLTcyMiw2ICs3MzQs MTAgQEAgZG1hX2J1Zl9keW5hbWljX2F0dGFjaChzdHJ1Y3QgZG1hX2J1ZiAqZG1hYnVmLCBzdHJ1 Y3QgZGV2aWNlICpkZXYsCiAJa2ZyZWUoYXR0YWNoKTsKIAlyZXR1cm4gRVJSX1BUUihyZXQpOwog CitlcnJfdW5waW46CisJaWYgKGRtYV9idWZfaXNfZHluYW1pYyhhdHRhY2gtPmRtYWJ1ZikpCisJ CWRtYV9idWZfdW5waW4oYXR0YWNoKTsKKwogZXJyX3VubG9jazoKIAlpZiAoZG1hX2J1Zl9pc19k eW5hbWljKGF0dGFjaC0+ZG1hYnVmKSkKIAkJZG1hX3Jlc3ZfdW5sb2NrKGF0dGFjaC0+ZG1hYnVm LT5yZXN2KTsKQEAgLTc0Miw3ICs3NTgsNyBAQCBFWFBPUlRfU1lNQk9MX0dQTChkbWFfYnVmX2R5 bmFtaWNfYXR0YWNoKTsKIHN0cnVjdCBkbWFfYnVmX2F0dGFjaG1lbnQgKmRtYV9idWZfYXR0YWNo KHN0cnVjdCBkbWFfYnVmICpkbWFidWYsCiAJCQkJCSAgc3RydWN0IGRldmljZSAqZGV2KQogewot CXJldHVybiBkbWFfYnVmX2R5bmFtaWNfYXR0YWNoKGRtYWJ1ZiwgZGV2LCBmYWxzZSk7CisJcmV0 dXJuIGRtYV9idWZfZHluYW1pY19hdHRhY2goZG1hYnVmLCBkZXYsIE5VTEwsIE5VTEwpOwogfQog RVhQT1JUX1NZTUJPTF9HUEwoZG1hX2J1Zl9hdHRhY2gpOwogCkBAIC03NjUsOCArNzgxLDEwIEBA IHZvaWQgZG1hX2J1Zl9kZXRhY2goc3RydWN0IGRtYV9idWYgKmRtYWJ1Ziwgc3RydWN0IGRtYV9i dWZfYXR0YWNobWVudCAqYXR0YWNoKQogCiAJCWRtYWJ1Zi0+b3BzLT51bm1hcF9kbWFfYnVmKGF0 dGFjaCwgYXR0YWNoLT5zZ3QsIGF0dGFjaC0+ZGlyKTsKIAotCQlpZiAoZG1hX2J1Zl9pc19keW5h bWljKGF0dGFjaC0+ZG1hYnVmKSkKKwkJaWYgKGRtYV9idWZfaXNfZHluYW1pYyhhdHRhY2gtPmRt YWJ1ZikpIHsKKwkJCWRtYV9idWZfdW5waW4oYXR0YWNoKTsKIAkJCWRtYV9yZXN2X3VubG9jayhh dHRhY2gtPmRtYWJ1Zi0+cmVzdik7CisJCX0KIAl9CiAKIAlkbWFfcmVzdl9sb2NrKGRtYWJ1Zi0+ cmVzdiwgTlVMTCk7CkBAIC03NzksNiArNzk3LDQ0IEBAIHZvaWQgZG1hX2J1Zl9kZXRhY2goc3Ry dWN0IGRtYV9idWYgKmRtYWJ1Ziwgc3RydWN0IGRtYV9idWZfYXR0YWNobWVudCAqYXR0YWNoKQog fQogRVhQT1JUX1NZTUJPTF9HUEwoZG1hX2J1Zl9kZXRhY2gpOwogCisvKioKKyAqIGRtYV9idWZf cGluIC0gTG9jayBkb3duIHRoZSBETUEtYnVmCisgKgorICogQGF0dGFjaDoJW2luXQlhdHRhY2ht ZW50IHdoaWNoIHNob3VsZCBiZSBwaW5uZWQKKyAqCisgKiBSZXR1cm5zOgorICogMCBvbiBzdWNj ZXNzLCBuZWdhdGl2ZSBlcnJvciBjb2RlIG9uIGZhaWx1cmUuCisgKi8KK2ludCBkbWFfYnVmX3Bp bihzdHJ1Y3QgZG1hX2J1Zl9hdHRhY2htZW50ICphdHRhY2gpCit7CisJc3RydWN0IGRtYV9idWYg KmRtYWJ1ZiA9IGF0dGFjaC0+ZG1hYnVmOworCWludCByZXQgPSAwOworCisJZG1hX3Jlc3ZfYXNz ZXJ0X2hlbGQoZG1hYnVmLT5yZXN2KTsKKworCWlmIChkbWFidWYtPm9wcy0+cGluKQorCQlyZXQg PSBkbWFidWYtPm9wcy0+cGluKGF0dGFjaCk7CisKKwlyZXR1cm4gcmV0OworfQorRVhQT1JUX1NZ TUJPTF9HUEwoZG1hX2J1Zl9waW4pOworCisvKioKKyAqIGRtYV9idWZfdW5waW4gLSBSZW1vdmUg bG9jayBmcm9tIERNQS1idWYKKyAqCisgKiBAYXR0YWNoOglbaW5dCWF0dGFjaG1lbnQgd2hpY2gg c2hvdWxkIGJlIHVucGlubmVkCisgKi8KK3ZvaWQgZG1hX2J1Zl91bnBpbihzdHJ1Y3QgZG1hX2J1 Zl9hdHRhY2htZW50ICphdHRhY2gpCit7CisJc3RydWN0IGRtYV9idWYgKmRtYWJ1ZiA9IGF0dGFj aC0+ZG1hYnVmOworCisJZG1hX3Jlc3ZfYXNzZXJ0X2hlbGQoZG1hYnVmLT5yZXN2KTsKKworCWlm IChkbWFidWYtPm9wcy0+dW5waW4pCisJCWRtYWJ1Zi0+b3BzLT51bnBpbihhdHRhY2gpOworfQor RVhQT1JUX1NZTUJPTF9HUEwoZG1hX2J1Zl91bnBpbik7CisKIC8qKgogICogZG1hX2J1Zl9tYXBf YXR0YWNobWVudCAtIFJldHVybnMgdGhlIHNjYXR0ZXJsaXN0IHRhYmxlIG9mIHRoZSBhdHRhY2ht ZW50OwogICogbWFwcGVkIGludG8gX2RldmljZV8gYWRkcmVzcyBzcGFjZS4gSXMgYSB3cmFwcGVy IGZvciBtYXBfZG1hX2J1ZigpIG9mIHRoZQpAQCAtNzk4LDYgKzg1NCw3IEBAIHN0cnVjdCBzZ190 YWJsZSAqZG1hX2J1Zl9tYXBfYXR0YWNobWVudChzdHJ1Y3QgZG1hX2J1Zl9hdHRhY2htZW50ICph dHRhY2gsCiAJCQkJCWVudW0gZG1hX2RhdGFfZGlyZWN0aW9uIGRpcmVjdGlvbikKIHsKIAlzdHJ1 Y3Qgc2dfdGFibGUgKnNnX3RhYmxlOworCWludCByOwogCiAJbWlnaHRfc2xlZXAoKTsKIApAQCAt ODE5LDEzICs4NzYsMjUgQEAgc3RydWN0IHNnX3RhYmxlICpkbWFfYnVmX21hcF9hdHRhY2htZW50 KHN0cnVjdCBkbWFfYnVmX2F0dGFjaG1lbnQgKmF0dGFjaCwKIAkJcmV0dXJuIGF0dGFjaC0+c2d0 OwogCX0KIAotCWlmIChkbWFfYnVmX2lzX2R5bmFtaWMoYXR0YWNoLT5kbWFidWYpKQorCWlmIChk bWFfYnVmX2lzX2R5bmFtaWMoYXR0YWNoLT5kbWFidWYpKSB7CiAJCWRtYV9yZXN2X2Fzc2VydF9o ZWxkKGF0dGFjaC0+ZG1hYnVmLT5yZXN2KTsKKwkJaWYgKCFhdHRhY2gtPmltcG9ydGVyX29wcy0+ bW92ZV9ub3RpZnkgfHwKKwkJICAgICFJU19FTkFCTEVEKENPTkZJR19ETUFCVUZfTU9WRV9OT1RJ RlkpKSB7CisJCQlyID0gZG1hX2J1Zl9waW4oYXR0YWNoKTsKKwkJCWlmIChyKQorCQkJCXJldHVy biBFUlJfUFRSKHIpOworCQl9CisJfQogCiAJc2dfdGFibGUgPSBhdHRhY2gtPmRtYWJ1Zi0+b3Bz LT5tYXBfZG1hX2J1ZihhdHRhY2gsIGRpcmVjdGlvbik7CiAJaWYgKCFzZ190YWJsZSkKIAkJc2df dGFibGUgPSBFUlJfUFRSKC1FTk9NRU0pOwogCisJaWYgKElTX0VSUihzZ190YWJsZSkgJiYgZG1h X2J1Zl9pc19keW5hbWljKGF0dGFjaC0+ZG1hYnVmKSAmJgorCSAgICAoIWF0dGFjaC0+aW1wb3J0 ZXJfb3BzLT5tb3ZlX25vdGlmeSB8fAorCSAgICAgIUlTX0VOQUJMRUQoQ09ORklHX0RNQUJVRl9N T1ZFX05PVElGWSkpKQorCQlkbWFfYnVmX3VucGluKGF0dGFjaCk7CisKIAlpZiAoIUlTX0VSUihz Z190YWJsZSkgJiYgYXR0YWNoLT5kbWFidWYtPm9wcy0+Y2FjaGVfc2d0X21hcHBpbmcpIHsKIAkJ YXR0YWNoLT5zZ3QgPSBzZ190YWJsZTsKIAkJYXR0YWNoLT5kaXIgPSBkaXJlY3Rpb247CkBAIC04 NjQsOSArOTMzLDM0IEBAIHZvaWQgZG1hX2J1Zl91bm1hcF9hdHRhY2htZW50KHN0cnVjdCBkbWFf YnVmX2F0dGFjaG1lbnQgKmF0dGFjaCwKIAkJZG1hX3Jlc3ZfYXNzZXJ0X2hlbGQoYXR0YWNoLT5k bWFidWYtPnJlc3YpOwogCiAJYXR0YWNoLT5kbWFidWYtPm9wcy0+dW5tYXBfZG1hX2J1ZihhdHRh Y2gsIHNnX3RhYmxlLCBkaXJlY3Rpb24pOworCisJaWYgKGRtYV9idWZfaXNfZHluYW1pYyhhdHRh Y2gtPmRtYWJ1ZikgJiYKKwkgICAgKCFhdHRhY2gtPmltcG9ydGVyX29wcy0+bW92ZV9ub3RpZnkg fHwKKwkgICAgICFJU19FTkFCTEVEKENPTkZJR19ETUFCVUZfTU9WRV9OT1RJRlkpKSkKKwkJZG1h X2J1Zl91bnBpbihhdHRhY2gpOwogfQogRVhQT1JUX1NZTUJPTF9HUEwoZG1hX2J1Zl91bm1hcF9h dHRhY2htZW50KTsKIAorLyoqCisgKiBkbWFfYnVmX21vdmVfbm90aWZ5IC0gbm90aWZ5IGF0dGFj aG1lbnRzIHRoYXQgRE1BLWJ1ZiBpcyBtb3ZpbmcKKyAqCisgKiBAZG1hYnVmOglbaW5dCWJ1ZmZl ciB3aGljaCBpcyBtb3ZpbmcKKyAqCisgKiBJbmZvcm1zIGFsbCBhdHRhY2htZW5zdCB0aGF0IHRo ZXkgbmVlZCB0byBkZXN0cm95IGFuZCByZWNyZWF0ZWQgYWxsIHRoZWlyCisgKiBtYXBwaW5ncy4K KyAqLwordm9pZCBkbWFfYnVmX21vdmVfbm90aWZ5KHN0cnVjdCBkbWFfYnVmICpkbWFidWYpCit7 CisJc3RydWN0IGRtYV9idWZfYXR0YWNobWVudCAqYXR0YWNoOworCisJZG1hX3Jlc3ZfYXNzZXJ0 X2hlbGQoZG1hYnVmLT5yZXN2KTsKKworCWxpc3RfZm9yX2VhY2hfZW50cnkoYXR0YWNoLCAmZG1h YnVmLT5hdHRhY2htZW50cywgbm9kZSkKKwkJaWYgKGF0dGFjaC0+aW1wb3J0ZXJfb3BzICYmIGF0 dGFjaC0+aW1wb3J0ZXJfb3BzLT5tb3ZlX25vdGlmeSkKKwkJCWF0dGFjaC0+aW1wb3J0ZXJfb3Bz LT5tb3ZlX25vdGlmeShhdHRhY2gpOworfQorRVhQT1JUX1NZTUJPTF9HUEwoZG1hX2J1Zl9tb3Zl X25vdGlmeSk7CisKIC8qKgogICogRE9DOiBjcHUgYWNjZXNzCiAgKgpkaWZmIC0tZ2l0IGEvZHJp dmVycy9ncHUvZHJtL2FtZC9hbWRncHUvYW1kZ3B1X2RtYV9idWYuYyBiL2RyaXZlcnMvZ3B1L2Ry bS9hbWQvYW1kZ3B1L2FtZGdwdV9kbWFfYnVmLmMKaW5kZXggYTU5Y2Q0N2FhNmMxLi43Y2FmYzY1 ZmQ3NmEgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvZ3B1L2RybS9hbWQvYW1kZ3B1L2FtZGdwdV9kbWFf YnVmLmMKKysrIGIvZHJpdmVycy9ncHUvZHJtL2FtZC9hbWRncHUvYW1kZ3B1X2RtYV9idWYuYwpA QCAtNDEyLDYgKzQxMiw5IEBAIGFtZGdwdV9kbWFfYnVmX2NyZWF0ZV9vYmooc3RydWN0IGRybV9k ZXZpY2UgKmRldiwgc3RydWN0IGRtYV9idWYgKmRtYV9idWYpCiAJcmV0dXJuIEVSUl9QVFIocmV0 KTsKIH0KIAorc3RhdGljIGNvbnN0IHN0cnVjdCBkbWFfYnVmX2F0dGFjaF9vcHMgYW1kZ3B1X2Rt YV9idWZfYXR0YWNoX29wcyA9IHsKK307CisKIC8qKgogICogYW1kZ3B1X2dlbV9wcmltZV9pbXBv cnQgLSAmZHJtX2RyaXZlci5nZW1fcHJpbWVfaW1wb3J0IGltcGxlbWVudGF0aW9uCiAgKiBAZGV2 OiBEUk0gZGV2aWNlCkBAIC00NDQsNyArNDQ3LDggQEAgc3RydWN0IGRybV9nZW1fb2JqZWN0ICph bWRncHVfZ2VtX3ByaW1lX2ltcG9ydChzdHJ1Y3QgZHJtX2RldmljZSAqZGV2LAogCWlmIChJU19F UlIob2JqKSkKIAkJcmV0dXJuIG9iajsKIAotCWF0dGFjaCA9IGRtYV9idWZfZHluYW1pY19hdHRh Y2goZG1hX2J1ZiwgZGV2LT5kZXYsIHRydWUpOworCWF0dGFjaCA9IGRtYV9idWZfZHluYW1pY19h dHRhY2goZG1hX2J1ZiwgZGV2LT5kZXYsCisJCQkJCSZhbWRncHVfZG1hX2J1Zl9hdHRhY2hfb3Bz LCBOVUxMKTsKIAlpZiAoSVNfRVJSKGF0dGFjaCkpIHsKIAkJZHJtX2dlbV9vYmplY3RfcHV0KG9i aik7CiAJCXJldHVybiBFUlJfQ0FTVChhdHRhY2gpOwpkaWZmIC0tZ2l0IGEvaW5jbHVkZS9saW51 eC9kbWEtYnVmLmggYi9pbmNsdWRlL2xpbnV4L2RtYS1idWYuaAppbmRleCBhYmY1NDU5YTViOWQu LmIzOGNlYTI0MGI2NyAxMDA2NDQKLS0tIGEvaW5jbHVkZS9saW51eC9kbWEtYnVmLmgKKysrIGIv aW5jbHVkZS9saW51eC9kbWEtYnVmLmgKQEAgLTkzLDE0ICs5Myw0MSBAQCBzdHJ1Y3QgZG1hX2J1 Zl9vcHMgewogCSAqLwogCXZvaWQgKCpkZXRhY2gpKHN0cnVjdCBkbWFfYnVmICosIHN0cnVjdCBk bWFfYnVmX2F0dGFjaG1lbnQgKik7CiAKKwkvKioKKwkgKiBAcGluOgorCSAqCisJICogVGhpcyBp cyBjYWxsZWQgYnkgZG1hX2J1Zl9waW4gYW5kIGxldHMgdGhlIGV4cG9ydGVyIGtub3cgdGhhdCB0 aGUKKwkgKiBETUEtYnVmIGNhbid0IGJlIG1vdmVkIGFueSBtb3JlLgorCSAqCisJICogVGhpcyBp cyBjYWxsZWQgd2l0aCB0aGUgZG1hYnVmLT5yZXN2IG9iamVjdCBsb2NrZWQuCisJICoKKwkgKiBU aGlzIGNhbGxiYWNrIGlzIG9wdGlvbmFsIGFuZCBzaG91bGQgb25seSBiZSB1c2VkIGluIGxpbWl0 ZWQgdXNlCisJICogY2FzZXMgbGlrZSBzY2Fub3V0IGFuZCBub3QgZm9yIHRlbXBvcmFyeSBwaW4g b3BlcmF0aW9ucy4KKwkgKgorCSAqIFJldHVybnM6CisJICoKKwkgKiAwIG9uIHN1Y2Nlc3MsIG5l Z2F0aXZlIGVycm9yIGNvZGUgb24gZmFpbHVyZS4KKwkgKi8KKwlpbnQgKCpwaW4pKHN0cnVjdCBk bWFfYnVmX2F0dGFjaG1lbnQgKmF0dGFjaCk7CisKKwkvKioKKwkgKiBAdW5waW46CisJICoKKwkg KiBUaGlzIGlzIGNhbGxlZCBieSBkbWFfYnVmX3VucGluIGFuZCBsZXRzIHRoZSBleHBvcnRlciBr bm93IHRoYXQgdGhlCisJICogRE1BLWJ1ZiBjYW4gYmUgbW92ZWQgYWdhaW4uCisJICoKKwkgKiBU aGlzIGlzIGNhbGxlZCB3aXRoIHRoZSBkbWFidWYtPnJlc3Ygb2JqZWN0IGxvY2tlZC4KKwkgKgor CSAqIFRoaXMgY2FsbGJhY2sgaXMgb3B0aW9uYWwuCisJICovCisJdm9pZCAoKnVucGluKShzdHJ1 Y3QgZG1hX2J1Zl9hdHRhY2htZW50ICphdHRhY2gpOworCiAJLyoqCiAJICogQG1hcF9kbWFfYnVm OgogCSAqCiAJICogVGhpcyBpcyBjYWxsZWQgYnkgZG1hX2J1Zl9tYXBfYXR0YWNobWVudCgpIGFu ZCBpcyB1c2VkIHRvIG1hcCBhCiAJICogc2hhcmVkICZkbWFfYnVmIGludG8gZGV2aWNlIGFkZHJl c3Mgc3BhY2UsIGFuZCBpdCBpcyBtYW5kYXRvcnkuIEl0Ci0JICogY2FuIG9ubHkgYmUgY2FsbGVk IGlmIEBhdHRhY2ggaGFzIGJlZW4gY2FsbGVkIHN1Y2Nlc3NmdWxseS4gVGhpcwotCSAqIGVzc2Vu dGlhbGx5IHBpbnMgdGhlIERNQSBidWZmZXIgaW50byBwbGFjZSwgYW5kIGl0IGNhbm5vdCBiZSBt b3ZlZAotCSAqIGFueSBtb3JlCisJICogY2FuIG9ubHkgYmUgY2FsbGVkIGlmIEBhdHRhY2ggaGFz IGJlZW4gY2FsbGVkIHN1Y2Nlc3NmdWxseS4KIAkgKgogCSAqIFRoaXMgY2FsbCBtYXkgc2xlZXAs IGUuZy4gd2hlbiB0aGUgYmFja2luZyBzdG9yYWdlIGZpcnN0IG5lZWRzIHRvIGJlCiAJICogYWxs b2NhdGVkLCBvciBtb3ZlZCB0byBhIGxvY2F0aW9uIHN1aXRhYmxlIGZvciBhbGwgY3VycmVudGx5 IGF0dGFjaGVkCkBAIC0xNDEsOSArMTY4LDggQEAgc3RydWN0IGRtYV9idWZfb3BzIHsKIAkgKgog CSAqIFRoaXMgaXMgY2FsbGVkIGJ5IGRtYV9idWZfdW5tYXBfYXR0YWNobWVudCgpIGFuZCBzaG91 bGQgdW5tYXAgYW5kCiAJICogcmVsZWFzZSB0aGUgJnNnX3RhYmxlIGFsbG9jYXRlZCBpbiBAbWFw X2RtYV9idWYsIGFuZCBpdCBpcyBtYW5kYXRvcnkuCi0JICogSXQgc2hvdWxkIGFsc28gdW5waW4g dGhlIGJhY2tpbmcgc3RvcmFnZSBpZiB0aGlzIGlzIHRoZSBsYXN0IG1hcHBpbmcKLQkgKiBvZiB0 aGUgRE1BIGJ1ZmZlciwgaXQgdGhlIGV4cG9ydGVyIHN1cHBvcnRzIGJhY2tpbmcgc3RvcmFnZQot CSAqIG1pZ3JhdGlvbi4KKwkgKiBGb3Igc3RhdGljIGRtYV9idWYgaGFuZGxpbmcgdGhpcyBtaWdo dCBhbHNvIHVucGlucyB0aGUgYmFja2luZworCSAqIHN0b3JhZ2UgaWYgdGhpcyBpcyB0aGUgbGFz dCBtYXBwaW5nIG9mIHRoZSBETUEgYnVmZmVyLgogCSAqLwogCXZvaWQgKCp1bm1hcF9kbWFfYnVm KShzdHJ1Y3QgZG1hX2J1Zl9hdHRhY2htZW50ICosCiAJCQkgICAgICBzdHJ1Y3Qgc2dfdGFibGUg KiwKQEAgLTMxMSw2ICszMzcsMzQgQEAgc3RydWN0IGRtYV9idWYgewogCX0gY2JfZXhjbCwgY2Jf c2hhcmVkOwogfTsKIAorLyoqCisgKiBzdHJ1Y3QgZG1hX2J1Zl9hdHRhY2hfb3BzIC0gaW1wb3J0 ZXIgb3BlcmF0aW9ucyBmb3IgYW4gYXR0YWNobWVudAorICogQG1vdmVfbm90aWZ5OiBbb3B0aW9u YWxdIG5vdGlmaWNhdGlvbiB0aGF0IHRoZSBETUEtYnVmIGlzIG1vdmluZworICoKKyAqIEF0dGFj aG1lbnQgb3BlcmF0aW9ucyBpbXBsZW1lbnRlZCBieSB0aGUgaW1wb3J0ZXIuCisgKi8KK3N0cnVj dCBkbWFfYnVmX2F0dGFjaF9vcHMgeworCS8qKgorCSAqIEBtb3ZlX25vdGlmeQorCSAqCisJICog SWYgdGhpcyBjYWxsYmFjayBpcyBwcm92aWRlZCB0aGUgZnJhbWV3b3JrIGNhbiBhdm9pZCBwaW5u aW5nIHRoZQorCSAqIGJhY2tpbmcgc3RvcmUgd2hpbGUgbWFwcGluZ3MgZXhpc3RzLgorCSAqCisJ ICogVGhpcyBjYWxsYmFjayBpcyBjYWxsZWQgd2l0aCB0aGUgbG9jayBvZiB0aGUgcmVzZXJ2YXRp b24gb2JqZWN0CisJICogYXNzb2NpYXRlZCB3aXRoIHRoZSBkbWFfYnVmIGhlbGQgYW5kIHRoZSBt YXBwaW5nIGZ1bmN0aW9uIG11c3QgYmUKKwkgKiBjYWxsZWQgd2l0aCB0aGlzIGxvY2sgaGVsZCBh cyB3ZWxsLiBUaGlzIG1ha2VzIHN1cmUgdGhhdCBubyBtYXBwaW5nCisJICogaXMgY3JlYXRlZCBj b25jdXJyZW50bHkgd2l0aCBhbiBvbmdvaW5nIG1vdmUgb3BlcmF0aW9uLgorCSAqCisJICogTWFw cGluZ3Mgc3RheSB2YWxpZCBhbmQgYXJlIG5vdCBkaXJlY3RseSBhZmZlY3RlZCBieSB0aGlzIGNh bGxiYWNrLgorCSAqIEJ1dCB0aGUgRE1BLWJ1ZiBjYW4gbm93IGJlIGluIGEgZGlmZmVyZW50IHBo eXNpY2FsIGxvY2F0aW9uLCBzbyBhbGwKKwkgKiBtYXBwaW5ncyBzaG91bGQgYmUgZGVzdHJveWVk IGFuZCByZS1jcmVhdGVkIGFzIHNvb24gYXMgcG9zc2libGUuCisJICoKKwkgKiBOZXcgbWFwcGlu Z3MgY2FuIGJlIGNyZWF0ZWQgYWZ0ZXIgdGhpcyBjYWxsYmFjayByZXR1cm5zLCBhbmQgd2lsbAor CSAqIHBvaW50IHRvIHRoZSBuZXcgbG9jYXRpb24gb2YgdGhlIERNQS1idWYuCisJICovCisJdm9p ZCAoKm1vdmVfbm90aWZ5KShzdHJ1Y3QgZG1hX2J1Zl9hdHRhY2htZW50ICphdHRhY2gpOworfTsK KwogLyoqCiAgKiBzdHJ1Y3QgZG1hX2J1Zl9hdHRhY2htZW50IC0gaG9sZHMgZGV2aWNlLWJ1ZmZl ciBhdHRhY2htZW50IGRhdGEKICAqIEBkbWFidWY6IGJ1ZmZlciBmb3IgdGhpcyBhdHRhY2htZW50 LgpAQCAtMzE5LDggKzM3Myw5IEBAIHN0cnVjdCBkbWFfYnVmIHsKICAqIEBzZ3Q6IGNhY2hlZCBt YXBwaW5nLgogICogQGRpcjogZGlyZWN0aW9uIG9mIGNhY2hlZCBtYXBwaW5nLgogICogQHByaXY6 IGV4cG9ydGVyIHNwZWNpZmljIGF0dGFjaG1lbnQgZGF0YS4KLSAqIEBkeW5hbWljX21hcHBpbmc6 IHRydWUgaWYgZG1hX2J1Zl9tYXAvdW5tYXBfYXR0YWNobWVudCgpIGlzIGNhbGxlZCB3aXRoIHRo ZQotICogZG1hX3Jlc3YgbG9jayBoZWxkLgorICogQGltcG9ydGVyX29wczogaW1wb3J0ZXIgb3Bl cmF0aW9ucyBmb3IgdGhpcyBhdHRhY2htZW50LCBpZiBwcm92aWRlZAorICogZG1hX2J1Zl9tYXAv dW5tYXBfYXR0YWNobWVudCgpIG11c3QgYmUgY2FsbGVkIHdpdGggdGhlIGRtYV9yZXN2IGxvY2sg aGVsZC4KKyAqIEBpbXBvcnRlcl9wcml2OiBpbXBvcnRlciBzcGVjaWZpYyBhdHRhY2htZW50IGRh dGEuCiAgKgogICogVGhpcyBzdHJ1Y3R1cmUgaG9sZHMgdGhlIGF0dGFjaG1lbnQgaW5mb3JtYXRp b24gYmV0d2VlbiB0aGUgZG1hX2J1ZiBidWZmZXIKICAqIGFuZCBpdHMgdXNlciBkZXZpY2Uocyku IFRoZSBsaXN0IGNvbnRhaW5zIG9uZSBhdHRhY2htZW50IHN0cnVjdCBwZXIgZGV2aWNlCkBAIC0z MzcsNyArMzkyLDggQEAgc3RydWN0IGRtYV9idWZfYXR0YWNobWVudCB7CiAJc3RydWN0IGxpc3Rf aGVhZCBub2RlOwogCXN0cnVjdCBzZ190YWJsZSAqc2d0OwogCWVudW0gZG1hX2RhdGFfZGlyZWN0 aW9uIGRpcjsKLQlib29sIGR5bmFtaWNfbWFwcGluZzsKKwljb25zdCBzdHJ1Y3QgZG1hX2J1Zl9h dHRhY2hfb3BzICppbXBvcnRlcl9vcHM7CisJdm9pZCAqaW1wb3J0ZXJfcHJpdjsKIAl2b2lkICpw cml2OwogfTsKIApAQCAtMzk5LDYgKzQ1NSw3IEBAIHN0YXRpYyBpbmxpbmUgdm9pZCBnZXRfZG1h X2J1ZihzdHJ1Y3QgZG1hX2J1ZiAqZG1hYnVmKQogICovCiBzdGF0aWMgaW5saW5lIGJvb2wgZG1h X2J1Zl9pc19keW5hbWljKHN0cnVjdCBkbWFfYnVmICpkbWFidWYpCiB7CisJLyogVE9ETzogc3dp dGNoIHRvIHVzaW5nIHBpbi91bnBpbiBmdW5jdGlvbnMgYXMgaW5kaWNhdG9yLiAqLwogCXJldHVy biBkbWFidWYtPm9wcy0+ZHluYW1pY19tYXBwaW5nOwogfQogCkBAIC00MTMsMTYgKzQ3MCwxOSBA QCBzdGF0aWMgaW5saW5lIGJvb2wgZG1hX2J1Zl9pc19keW5hbWljKHN0cnVjdCBkbWFfYnVmICpk bWFidWYpCiBzdGF0aWMgaW5saW5lIGJvb2wKIGRtYV9idWZfYXR0YWNobWVudF9pc19keW5hbWlj KHN0cnVjdCBkbWFfYnVmX2F0dGFjaG1lbnQgKmF0dGFjaCkKIHsKLQlyZXR1cm4gYXR0YWNoLT5k eW5hbWljX21hcHBpbmc7CisJcmV0dXJuICEhYXR0YWNoLT5pbXBvcnRlcl9vcHM7CiB9CiAKIHN0 cnVjdCBkbWFfYnVmX2F0dGFjaG1lbnQgKmRtYV9idWZfYXR0YWNoKHN0cnVjdCBkbWFfYnVmICpk bWFidWYsCiAJCQkJCSAgc3RydWN0IGRldmljZSAqZGV2KTsKIHN0cnVjdCBkbWFfYnVmX2F0dGFj aG1lbnQgKgogZG1hX2J1Zl9keW5hbWljX2F0dGFjaChzdHJ1Y3QgZG1hX2J1ZiAqZG1hYnVmLCBz dHJ1Y3QgZGV2aWNlICpkZXYsCi0JCSAgICAgICBib29sIGR5bmFtaWNfbWFwcGluZyk7CisJCSAg ICAgICBjb25zdCBzdHJ1Y3QgZG1hX2J1Zl9hdHRhY2hfb3BzICppbXBvcnRlcl9vcHMsCisJCSAg ICAgICB2b2lkICppbXBvcnRlcl9wcml2KTsKIHZvaWQgZG1hX2J1Zl9kZXRhY2goc3RydWN0IGRt YV9idWYgKmRtYWJ1ZiwKIAkJICAgIHN0cnVjdCBkbWFfYnVmX2F0dGFjaG1lbnQgKmF0dGFjaCk7 CitpbnQgZG1hX2J1Zl9waW4oc3RydWN0IGRtYV9idWZfYXR0YWNobWVudCAqYXR0YWNoKTsKK3Zv aWQgZG1hX2J1Zl91bnBpbihzdHJ1Y3QgZG1hX2J1Zl9hdHRhY2htZW50ICphdHRhY2gpOwogCiBz dHJ1Y3QgZG1hX2J1ZiAqZG1hX2J1Zl9leHBvcnQoY29uc3Qgc3RydWN0IGRtYV9idWZfZXhwb3J0 X2luZm8gKmV4cF9pbmZvKTsKIAotLSAKMi4xNy4xCgpfX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fXwpkcmktZGV2ZWwgbWFpbGluZyBsaXN0CmRyaS1kZXZlbEBs aXN0cy5mcmVlZGVza3RvcC5vcmcKaHR0cHM6Ly9saXN0cy5mcmVlZGVza3RvcC5vcmcvbWFpbG1h bi9saXN0aW5mby9kcmktZGV2ZWwK 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=-9.3 required=3.0 tests=DKIM_ADSP_CUSTOM_MED, DKIM_INVALID,DKIM_SIGNED,FREEMAIL_FORGED_FROMDOMAIN,FREEMAIL_FROM, HEADER_FROM_DIFFERENT_DOMAINS,INCLUDES_PATCH,MAILING_LIST_MULTI,SIGNED_OFF_BY, SPF_HELO_NONE,SPF_PASS,URIBL_BLOCKED,USER_AGENT_GIT autolearn=unavailable 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 556EEC3405E for ; Wed, 19 Feb 2020 16:56:11 +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 2BF0F2464E for ; Wed, 19 Feb 2020 16:56:11 +0000 (UTC) Authentication-Results: mail.kernel.org; dkim=fail reason="signature verification failed" (2048-bit key) header.d=gmail.com header.i=@gmail.com header.b="mYEJ1VRX" DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org 2BF0F2464E Authentication-Results: mail.kernel.org; dmarc=fail (p=none dis=none) header.from=gmail.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 8FE126E822; Wed, 19 Feb 2020 16:56:10 +0000 (UTC) Received: from mail-wr1-x441.google.com (mail-wr1-x441.google.com [IPv6:2a00:1450:4864:20::441]) by gabe.freedesktop.org (Postfix) with ESMTPS id CD8416E5B2; Wed, 19 Feb 2020 12:59:13 +0000 (UTC) Received: by mail-wr1-x441.google.com with SMTP id w12so447927wrt.2; Wed, 19 Feb 2020 04:59:13 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20161025; h=from:to:subject:date:message-id:mime-version :content-transfer-encoding; bh=eHSR65M1UxYKDgV0h05dvsavOHLsx/vkHuLWvTFUtV4=; b=mYEJ1VRXAH8td5GxLROlP5SO69QoYmRgF5bxx98EQIu/+xfEXnWmzB3LmnnMKDptoZ 1fnX/a/DPoFUDbXbHBoXAZ5OJUfnVb/jlTP+sbceimY6n81RX7BbP23zzb1I92x5siS7 Y/ah83uE5QkjaiERG6bXMUXNh6MSiYdPBOygXUukP0HC8AiFMpgE56qnLVe1AaYL5IKm kBrHiKUJ7riVp9+u/XtFAK+uHogOK68tJhUSVBykmhllILbfPvDNs/ByAK722mJx4Cog NxNfGTLQjctLpShhpyhlJUjHPiIIREHuBtusvHNFPZRUeuusV7Imn0FheO909FmrPSZ6 NxVA== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:from:to:subject:date:message-id:mime-version :content-transfer-encoding; bh=eHSR65M1UxYKDgV0h05dvsavOHLsx/vkHuLWvTFUtV4=; b=IAMNdlH9T45DIUwCpNUY9l1nMSO8MHVR+35Qyv5Yq8H1boNNZq//E5wIu/NhQ2r+zQ MbS15XmbsOr2X0LIUUi+M9BcUtYnrn4QZDKvq7b56GpPTEntt4o918fFq6s23QvzQQn8 umB/Erl9yc8yEc6FLv6BCpFdSTc2y4ryO3anc4923AGiRhH6kGBg2S8UDaI2Xon89PaV 2UMPncqsYVw4b+MvYlDAwjASCNWX/Bkh0h1Vy4KuicaHuXMnyTn3c5zxWIFwHyM0LVpH hav0KFuHAx6SJvv8gYP0IQRaMKEZqqqaTWBmOr1Vh3NzkyexxMwjwf8Xs+9ZsjsMId4o t8OA== X-Gm-Message-State: APjAAAUmx0kIvJDQX9CMbaIwhlBuXkB+FOGayXpEXUwrSuTXmpY/oMv5 r/lhghTlgN79qvTICtifZCR7j8zJ X-Google-Smtp-Source: APXvYqyegaZn838rtrQaoHTKprz6TGiIxIUg3oHkVuR8qdGXKH3wgiQyGji93MmJ80dj/IV8Vnr4Hw== X-Received: by 2002:a5d:4d4a:: with SMTP id a10mr37753965wru.220.1582117151751; Wed, 19 Feb 2020 04:59:11 -0800 (PST) Received: from abel.fritz.box ([2a02:908:1252:fb60:90ea:9d7:18a3:895e]) by smtp.gmail.com with ESMTPSA id h2sm3079024wrt.45.2020.02.19.04.59.10 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Wed, 19 Feb 2020 04:59:11 -0800 (PST) From: "=?UTF-8?q?Christian=20K=C3=B6nig?=" X-Google-Original-From: =?UTF-8?q?Christian=20K=C3=B6nig?= To: dri-devel@lists.freedesktop.org, linaro-mm-sig@lists.linaro.org, linux-media@vger.kernel.org, intel-gfx@lists.freedesktop.org, daniel@ffwll.ch Date: Wed, 19 Feb 2020 13:59:04 +0100 Message-Id: <20200219125910.89147-1-christian.koenig@amd.com> X-Mailer: git-send-email 2.17.1 MIME-Version: 1.0 X-Mailman-Approved-At: Wed, 19 Feb 2020 16:56:01 +0000 Subject: [Intel-gfx] [PATCH 1/7] dma-buf: add dynamic DMA-buf handling v15 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: , Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Errors-To: intel-gfx-bounces@lists.freedesktop.org Sender: "Intel-gfx" T24gdGhlIGV4cG9ydGVyIHNpZGUgd2UgYWRkIG9wdGlvbmFsIGV4cGxpY2l0IHBpbm5pbmcgY2Fs bGJhY2tzLiBXaGljaCBhcmUKY2FsbGVkIHdoZW4gdGhlIGltcG9ydGVyIGRvZXNuJ3QgaW1wbGVt ZW50IGR5bmFtaWMgaGFuZGxpbmcsIG1vdmUgbm90aWZpY2F0aW9uCm9yIG5lZWQgdGhlIERNQS1i dWYgbG9ja2VkIGluIHBsYWNlIGZvciBpdHMgdXNlIGNhc2UuCgpPbiB0aGUgaW1wb3J0ZXIgc2lk ZSB3ZSBhZGQgYW4gb3B0aW9uYWwgbW92ZV9ub3RpZnkgY2FsbGJhY2suIFRoaXMgY2FsbGJhY2sg aXMKdXNlZCBieSB0aGUgZXhwb3J0ZXIgdG8gaW5mb3JtIHRoZSBpbXBvcnRlcnMgdGhhdCB0aGVp ciBtYXBwaW5ncyBzaG91bGQgYmUKZGVzdHJveWVkIGFzIHNvb24gYXMgcG9zc2libGUuCgpUaGlz IGFsbG93cyB0aGUgZXhwb3J0ZXIgdG8gcHJvdmlkZSB0aGUgbWFwcGluZ3Mgd2l0aG91dCB0aGUg bmVlZCB0byBwaW4KdGhlIGJhY2tpbmcgc3RvcmUuCgp2MjogZG9uJ3QgdHJ5IHRvIGludmFsaWRh dGUgbWFwcGluZ3Mgd2hlbiB0aGUgY2FsbGJhY2sgaXMgTlVMTCwKICAgIGxvY2sgdGhlIHJlc2Vy dmF0aW9uIG9iaiB3aGlsZSB1c2luZyB0aGUgYXR0YWNobWVudHMsCiAgICBhZGQgaGVscGVyIHRv IHNldCB0aGUgY2FsbGJhY2sKdjM6IG1vdmUgZmxhZyBmb3IgaW52YWxpZGF0aW9uIHN1cHBvcnQg aW50byB0aGUgRE1BLWJ1ZiwKICAgIHVzZSBuZXcgYXR0YWNoX2luZm8gc3RydWN0dXJlIHRvIHNl dCB0aGUgY2FsbGJhY2sKdjQ6IHVzZSBpbXBvcnRlcl9wcml2IGZpZWxkIGluc3RlYWQgb2YgbWFu Z2xpbmcgZXhwb3J0ZXIgcHJpdi4KdjU6IGRyb3AgaW52YWxpZGF0aW9uX3N1cHBvcnRlZCBmbGFn CnY2OiBzcXVhc2ggdG9nZXRoZXIgd2l0aCBwaW4vdW5waW4gY2hhbmdlcwp2NzogcGluL3VucGlu IHRha2VzIGFuIGF0dGFjaG1lbnQgbm93CnY4OiBudWtlIGRtYV9idWZfYXR0YWNobWVudF8obWFw fHVubWFwKV9sb2NrZWQsCiAgICBldmVyeXRoaW5nIGlzIG5vdyBoYW5kbGVkIGJhY2t3YXJkIGNv bXBhdGlibGUKdjk6IGFsd2F5cyBjYWNoZSB3aGVuIGV4cG9ydC9pbXBvcnRlciBkb24ndCBhZ3Jl ZSBvbiBkeW5hbWljIGhhbmRsaW5nCnYxMDogbWluaW1hbCBzdHlsZSBjbGVhbnVwCnYxMTogZHJv cCBhdXRvbWF0aWNhbGx5IHJlLWVudHJ5IGF2b2lkYW5jZQp2MTI6IHJlbmFtZSBjYWxsYmFjayB0 byBtb3ZlX25vdGlmeQp2MTM6IGFkZCBtaWdodF9sb2NrIGluIGFwcHJvcHJpYXRlIHBsYWNlcwp2 MTQ6IHJlYmFzZSBvbiBzZXBhcmF0ZWQgbG9ja2luZyBjaGFuZ2UKdjE1OiBhZGQgRVhQRVJJTUVO VEFMIGZsYWcsIHNvbWUgbW9yZSBjb2RlIGNvbW1lbnRzCgpTaWduZWQtb2ZmLWJ5OiBDaHJpc3Rp YW4gS8O2bmlnIDxjaHJpc3RpYW4ua29lbmlnQGFtZC5jb20+Ci0tLQogZHJpdmVycy9kbWEtYnVm L0tjb25maWcgICAgICAgICAgICAgICAgICAgICB8ICAxMCArKwogZHJpdmVycy9kbWEtYnVmL2Rt YS1idWYuYyAgICAgICAgICAgICAgICAgICB8IDExMCArKysrKysrKysrKysrKysrKystLQogZHJp dmVycy9ncHUvZHJtL2FtZC9hbWRncHUvYW1kZ3B1X2RtYV9idWYuYyB8ICAgNiArLQogaW5jbHVk ZS9saW51eC9kbWEtYnVmLmggICAgICAgICAgICAgICAgICAgICB8ICA4MiArKysrKysrKysrKysr LS0KIDQgZmlsZXMgY2hhbmdlZCwgMTg4IGluc2VydGlvbnMoKyksIDIwIGRlbGV0aW9ucygtKQoK ZGlmZiAtLWdpdCBhL2RyaXZlcnMvZG1hLWJ1Zi9LY29uZmlnIGIvZHJpdmVycy9kbWEtYnVmL0tj b25maWcKaW5kZXggZTdkODIwY2UwNzI0Li5lZjczYjY3ODQxOWMgMTAwNjQ0Ci0tLSBhL2RyaXZl cnMvZG1hLWJ1Zi9LY29uZmlnCisrKyBiL2RyaXZlcnMvZG1hLWJ1Zi9LY29uZmlnCkBAIC0zOSw2 ICszOSwxNiBAQCBjb25maWcgVURNQUJVRgogCSAgQSBkcml2ZXIgdG8gbGV0IHVzZXJzcGFjZSB0 dXJuIG1lbWZkIHJlZ2lvbnMgaW50byBkbWEtYnVmcy4KIAkgIFFlbXUgY2FuIHVzZSB0aGlzIHRv IGNyZWF0ZSBob3N0IGRtYWJ1ZnMgZm9yIGd1ZXN0IGZyYW1lYnVmZmVycy4KIAorY29uZmlnIERN QUJVRl9NT1ZFX05PVElGWQorCWJvb2wgIk1vdmUgbm90aWZ5IGJldHdlZW4gZHJpdmVycyAoRVhQ RVJJTUVOVEFMKSIKKwlkZWZhdWx0IG4KKwloZWxwCisJICBEb24nJ3QgcGluIGJ1ZmZlcnMgaWYg dGhlIGR5bmFtaWMgRE1BLWJ1ZiBpbnRlcmZhY2UgaXMgYXZhaWxhYmxlIG9uIGJvdGggdGhlCisJ ICBleHBvcnRlciBhcyB3ZWxsIGFzIHRoZSBpbXBvcnRlci4gVGhpcyBmaXhlcyBhIHNlY3VyaXR5 IHByb2JsZW0gd2hlcmUKKwkgIHVzZXJzcGFjZSBpcyBhYmxlIHRvIHBpbiB1bnJlc3RyaWN0ZWQg YW1vdW50cyBvZiBtZW1vcnkgdGhyb3VnaCBETUEtYnVmLgorCSAgQnV0IG1hcmtlZCBleHBlcmlt ZW50YWwgYmVjYXVzZSB3ZSBkb24nJ3QgamV0IGhhdmUgYSBjb25zaXN0ZW50IGV4ZWN1dGlvbgor CSAgY29udGV4dCBhbmQgbWVtb3J5IG1hbmFnZW1lbnQgYmV0d2VlbiBkcml2ZXJzLgorCiBjb25m aWcgRE1BQlVGX1NFTEZURVNUUwogCXRyaXN0YXRlICJTZWxmdGVzdHMgZm9yIHRoZSBkbWEtYnVm IGludGVyZmFjZXMiCiAJZGVmYXVsdCBuCmRpZmYgLS1naXQgYS9kcml2ZXJzL2RtYS1idWYvZG1h LWJ1Zi5jIGIvZHJpdmVycy9kbWEtYnVmL2RtYS1idWYuYwppbmRleCBkNDA5Nzg1NmM4NmIuLjVm MTBkMTkyOTQ3NiAxMDA2NDQKLS0tIGEvZHJpdmVycy9kbWEtYnVmL2RtYS1idWYuYworKysgYi9k cml2ZXJzL2RtYS1idWYvZG1hLWJ1Zi5jCkBAIC01MjcsNiArNTI3LDEwIEBAIHN0cnVjdCBkbWFf YnVmICpkbWFfYnVmX2V4cG9ydChjb25zdCBzdHJ1Y3QgZG1hX2J1Zl9leHBvcnRfaW5mbyAqZXhw X2luZm8pCiAJCSAgICBleHBfaW5mby0+b3BzLT5keW5hbWljX21hcHBpbmcpKQogCQlyZXR1cm4g RVJSX1BUUigtRUlOVkFMKTsKIAorCWlmIChXQVJOX09OKCFleHBfaW5mby0+b3BzLT5keW5hbWlj X21hcHBpbmcgJiYKKwkJICAgIChleHBfaW5mby0+b3BzLT5waW4gfHwgZXhwX2luZm8tPm9wcy0+ dW5waW4pKSkKKwkJcmV0dXJuIEVSUl9QVFIoLUVJTlZBTCk7CisKIAlpZiAoIXRyeV9tb2R1bGVf Z2V0KGV4cF9pbmZvLT5vd25lcikpCiAJCXJldHVybiBFUlJfUFRSKC1FTk9FTlQpOwogCkBAIC02 NTEsNyArNjU1LDggQEAgRVhQT1JUX1NZTUJPTF9HUEwoZG1hX2J1Zl9wdXQpOwogICogY2FsbHMg YXR0YWNoKCkgb2YgZG1hX2J1Zl9vcHMgdG8gYWxsb3cgZGV2aWNlLXNwZWNpZmljIGF0dGFjaCBm dW5jdGlvbmFsaXR5CiAgKiBAZG1hYnVmOgkJW2luXQlidWZmZXIgdG8gYXR0YWNoIGRldmljZSB0 by4KICAqIEBkZXY6CQlbaW5dCWRldmljZSB0byBiZSBhdHRhY2hlZC4KLSAqIEBkeW5hbWljX21h cHBpbmc6CVtpbl0JY2FsbGluZyBjb252ZW50aW9uIGZvciBtYXAvdW5tYXAKKyAqIEBpbXBvcnRl cl9vcHMJW2luXQlpbXBvcnRlciBvcGVyYXRpb25zIGZvciB0aGUgYXR0YWNobWVudAorICogQGlt cG9ydGVyX3ByaXYJW2luXQlpbXBvcnRlciBwcml2YXRlIHBvaW50ZXIgZm9yIHRoZSBhdHRhY2ht ZW50CiAgKgogICogUmV0dXJucyBzdHJ1Y3QgZG1hX2J1Zl9hdHRhY2htZW50IHBvaW50ZXIgZm9y IHRoaXMgYXR0YWNobWVudC4gQXR0YWNobWVudHMKICAqIG11c3QgYmUgY2xlYW5lZCB1cCBieSBj YWxsaW5nIGRtYV9idWZfZGV0YWNoKCkuCkBAIC02NjcsMTEgKzY3MiwxMyBAQCBFWFBPUlRfU1lN Qk9MX0dQTChkbWFfYnVmX3B1dCk7CiAgKi8KIHN0cnVjdCBkbWFfYnVmX2F0dGFjaG1lbnQgKgog ZG1hX2J1Zl9keW5hbWljX2F0dGFjaChzdHJ1Y3QgZG1hX2J1ZiAqZG1hYnVmLCBzdHJ1Y3QgZGV2 aWNlICpkZXYsCi0JCSAgICAgICBib29sIGR5bmFtaWNfbWFwcGluZykKKwkJICAgICAgIGNvbnN0 IHN0cnVjdCBkbWFfYnVmX2F0dGFjaF9vcHMgKmltcG9ydGVyX29wcywKKwkJICAgICAgIHZvaWQg KmltcG9ydGVyX3ByaXYpCiB7CiAJc3RydWN0IGRtYV9idWZfYXR0YWNobWVudCAqYXR0YWNoOwog CWludCByZXQ7CiAKKwkvKiBUT0RPOiBtYWtlIG1vdmVfbm90aWZ5IG1hbmRhdG9yeSBpZiBpbXBv cnRlcl9vcHMgYXJlIHByb3ZpZGVkLiAqLwogCWlmIChXQVJOX09OKCFkbWFidWYgfHwgIWRldikp CiAJCXJldHVybiBFUlJfUFRSKC1FSU5WQUwpOwogCkBAIC02ODEsNyArNjg4LDggQEAgZG1hX2J1 Zl9keW5hbWljX2F0dGFjaChzdHJ1Y3QgZG1hX2J1ZiAqZG1hYnVmLCBzdHJ1Y3QgZGV2aWNlICpk ZXYsCiAKIAlhdHRhY2gtPmRldiA9IGRldjsKIAlhdHRhY2gtPmRtYWJ1ZiA9IGRtYWJ1ZjsKLQlh dHRhY2gtPmR5bmFtaWNfbWFwcGluZyA9IGR5bmFtaWNfbWFwcGluZzsKKwlhdHRhY2gtPmltcG9y dGVyX29wcyA9IGltcG9ydGVyX29wczsKKwlhdHRhY2gtPmltcG9ydGVyX3ByaXYgPSBpbXBvcnRl cl9wcml2OwogCiAJaWYgKGRtYWJ1Zi0+b3BzLT5hdHRhY2gpIHsKIAkJcmV0ID0gZG1hYnVmLT5v cHMtPmF0dGFjaChkbWFidWYsIGF0dGFjaCk7CkBAIC03MDAsMTUgKzcwOCwxOSBAQCBkbWFfYnVm X2R5bmFtaWNfYXR0YWNoKHN0cnVjdCBkbWFfYnVmICpkbWFidWYsIHN0cnVjdCBkZXZpY2UgKmRl diwKIAkgICAgZG1hX2J1Zl9pc19keW5hbWljKGRtYWJ1ZikpIHsKIAkJc3RydWN0IHNnX3RhYmxl ICpzZ3Q7CiAKLQkJaWYgKGRtYV9idWZfaXNfZHluYW1pYyhhdHRhY2gtPmRtYWJ1ZikpCisJCWlm IChkbWFfYnVmX2lzX2R5bmFtaWMoYXR0YWNoLT5kbWFidWYpKSB7CiAJCQlkbWFfcmVzdl9sb2Nr KGF0dGFjaC0+ZG1hYnVmLT5yZXN2LCBOVUxMKTsKKwkJCXJldCA9IGRtYV9idWZfcGluKGF0dGFj aCk7CisJCQlpZiAocmV0KQorCQkJCWdvdG8gZXJyX3VubG9jazsKKwkJfQogCiAJCXNndCA9IGRt YWJ1Zi0+b3BzLT5tYXBfZG1hX2J1ZihhdHRhY2gsIERNQV9CSURJUkVDVElPTkFMKTsKIAkJaWYg KCFzZ3QpCiAJCQlzZ3QgPSBFUlJfUFRSKC1FTk9NRU0pOwogCQlpZiAoSVNfRVJSKHNndCkpIHsK IAkJCXJldCA9IFBUUl9FUlIoc2d0KTsKLQkJCWdvdG8gZXJyX3VubG9jazsKKwkJCWdvdG8gZXJy X3VucGluOwogCQl9CiAJCWlmIChkbWFfYnVmX2lzX2R5bmFtaWMoYXR0YWNoLT5kbWFidWYpKQog CQkJZG1hX3Jlc3ZfdW5sb2NrKGF0dGFjaC0+ZG1hYnVmLT5yZXN2KTsKQEAgLTcyMiw2ICs3MzQs MTAgQEAgZG1hX2J1Zl9keW5hbWljX2F0dGFjaChzdHJ1Y3QgZG1hX2J1ZiAqZG1hYnVmLCBzdHJ1 Y3QgZGV2aWNlICpkZXYsCiAJa2ZyZWUoYXR0YWNoKTsKIAlyZXR1cm4gRVJSX1BUUihyZXQpOwog CitlcnJfdW5waW46CisJaWYgKGRtYV9idWZfaXNfZHluYW1pYyhhdHRhY2gtPmRtYWJ1ZikpCisJ CWRtYV9idWZfdW5waW4oYXR0YWNoKTsKKwogZXJyX3VubG9jazoKIAlpZiAoZG1hX2J1Zl9pc19k eW5hbWljKGF0dGFjaC0+ZG1hYnVmKSkKIAkJZG1hX3Jlc3ZfdW5sb2NrKGF0dGFjaC0+ZG1hYnVm LT5yZXN2KTsKQEAgLTc0Miw3ICs3NTgsNyBAQCBFWFBPUlRfU1lNQk9MX0dQTChkbWFfYnVmX2R5 bmFtaWNfYXR0YWNoKTsKIHN0cnVjdCBkbWFfYnVmX2F0dGFjaG1lbnQgKmRtYV9idWZfYXR0YWNo KHN0cnVjdCBkbWFfYnVmICpkbWFidWYsCiAJCQkJCSAgc3RydWN0IGRldmljZSAqZGV2KQogewot CXJldHVybiBkbWFfYnVmX2R5bmFtaWNfYXR0YWNoKGRtYWJ1ZiwgZGV2LCBmYWxzZSk7CisJcmV0 dXJuIGRtYV9idWZfZHluYW1pY19hdHRhY2goZG1hYnVmLCBkZXYsIE5VTEwsIE5VTEwpOwogfQog RVhQT1JUX1NZTUJPTF9HUEwoZG1hX2J1Zl9hdHRhY2gpOwogCkBAIC03NjUsOCArNzgxLDEwIEBA IHZvaWQgZG1hX2J1Zl9kZXRhY2goc3RydWN0IGRtYV9idWYgKmRtYWJ1Ziwgc3RydWN0IGRtYV9i dWZfYXR0YWNobWVudCAqYXR0YWNoKQogCiAJCWRtYWJ1Zi0+b3BzLT51bm1hcF9kbWFfYnVmKGF0 dGFjaCwgYXR0YWNoLT5zZ3QsIGF0dGFjaC0+ZGlyKTsKIAotCQlpZiAoZG1hX2J1Zl9pc19keW5h bWljKGF0dGFjaC0+ZG1hYnVmKSkKKwkJaWYgKGRtYV9idWZfaXNfZHluYW1pYyhhdHRhY2gtPmRt YWJ1ZikpIHsKKwkJCWRtYV9idWZfdW5waW4oYXR0YWNoKTsKIAkJCWRtYV9yZXN2X3VubG9jayhh dHRhY2gtPmRtYWJ1Zi0+cmVzdik7CisJCX0KIAl9CiAKIAlkbWFfcmVzdl9sb2NrKGRtYWJ1Zi0+ cmVzdiwgTlVMTCk7CkBAIC03NzksNiArNzk3LDQ0IEBAIHZvaWQgZG1hX2J1Zl9kZXRhY2goc3Ry dWN0IGRtYV9idWYgKmRtYWJ1Ziwgc3RydWN0IGRtYV9idWZfYXR0YWNobWVudCAqYXR0YWNoKQog fQogRVhQT1JUX1NZTUJPTF9HUEwoZG1hX2J1Zl9kZXRhY2gpOwogCisvKioKKyAqIGRtYV9idWZf cGluIC0gTG9jayBkb3duIHRoZSBETUEtYnVmCisgKgorICogQGF0dGFjaDoJW2luXQlhdHRhY2ht ZW50IHdoaWNoIHNob3VsZCBiZSBwaW5uZWQKKyAqCisgKiBSZXR1cm5zOgorICogMCBvbiBzdWNj ZXNzLCBuZWdhdGl2ZSBlcnJvciBjb2RlIG9uIGZhaWx1cmUuCisgKi8KK2ludCBkbWFfYnVmX3Bp bihzdHJ1Y3QgZG1hX2J1Zl9hdHRhY2htZW50ICphdHRhY2gpCit7CisJc3RydWN0IGRtYV9idWYg KmRtYWJ1ZiA9IGF0dGFjaC0+ZG1hYnVmOworCWludCByZXQgPSAwOworCisJZG1hX3Jlc3ZfYXNz ZXJ0X2hlbGQoZG1hYnVmLT5yZXN2KTsKKworCWlmIChkbWFidWYtPm9wcy0+cGluKQorCQlyZXQg PSBkbWFidWYtPm9wcy0+cGluKGF0dGFjaCk7CisKKwlyZXR1cm4gcmV0OworfQorRVhQT1JUX1NZ TUJPTF9HUEwoZG1hX2J1Zl9waW4pOworCisvKioKKyAqIGRtYV9idWZfdW5waW4gLSBSZW1vdmUg bG9jayBmcm9tIERNQS1idWYKKyAqCisgKiBAYXR0YWNoOglbaW5dCWF0dGFjaG1lbnQgd2hpY2gg c2hvdWxkIGJlIHVucGlubmVkCisgKi8KK3ZvaWQgZG1hX2J1Zl91bnBpbihzdHJ1Y3QgZG1hX2J1 Zl9hdHRhY2htZW50ICphdHRhY2gpCit7CisJc3RydWN0IGRtYV9idWYgKmRtYWJ1ZiA9IGF0dGFj aC0+ZG1hYnVmOworCisJZG1hX3Jlc3ZfYXNzZXJ0X2hlbGQoZG1hYnVmLT5yZXN2KTsKKworCWlm IChkbWFidWYtPm9wcy0+dW5waW4pCisJCWRtYWJ1Zi0+b3BzLT51bnBpbihhdHRhY2gpOworfQor RVhQT1JUX1NZTUJPTF9HUEwoZG1hX2J1Zl91bnBpbik7CisKIC8qKgogICogZG1hX2J1Zl9tYXBf YXR0YWNobWVudCAtIFJldHVybnMgdGhlIHNjYXR0ZXJsaXN0IHRhYmxlIG9mIHRoZSBhdHRhY2ht ZW50OwogICogbWFwcGVkIGludG8gX2RldmljZV8gYWRkcmVzcyBzcGFjZS4gSXMgYSB3cmFwcGVy IGZvciBtYXBfZG1hX2J1ZigpIG9mIHRoZQpAQCAtNzk4LDYgKzg1NCw3IEBAIHN0cnVjdCBzZ190 YWJsZSAqZG1hX2J1Zl9tYXBfYXR0YWNobWVudChzdHJ1Y3QgZG1hX2J1Zl9hdHRhY2htZW50ICph dHRhY2gsCiAJCQkJCWVudW0gZG1hX2RhdGFfZGlyZWN0aW9uIGRpcmVjdGlvbikKIHsKIAlzdHJ1 Y3Qgc2dfdGFibGUgKnNnX3RhYmxlOworCWludCByOwogCiAJbWlnaHRfc2xlZXAoKTsKIApAQCAt ODE5LDEzICs4NzYsMjUgQEAgc3RydWN0IHNnX3RhYmxlICpkbWFfYnVmX21hcF9hdHRhY2htZW50 KHN0cnVjdCBkbWFfYnVmX2F0dGFjaG1lbnQgKmF0dGFjaCwKIAkJcmV0dXJuIGF0dGFjaC0+c2d0 OwogCX0KIAotCWlmIChkbWFfYnVmX2lzX2R5bmFtaWMoYXR0YWNoLT5kbWFidWYpKQorCWlmIChk bWFfYnVmX2lzX2R5bmFtaWMoYXR0YWNoLT5kbWFidWYpKSB7CiAJCWRtYV9yZXN2X2Fzc2VydF9o ZWxkKGF0dGFjaC0+ZG1hYnVmLT5yZXN2KTsKKwkJaWYgKCFhdHRhY2gtPmltcG9ydGVyX29wcy0+ bW92ZV9ub3RpZnkgfHwKKwkJICAgICFJU19FTkFCTEVEKENPTkZJR19ETUFCVUZfTU9WRV9OT1RJ RlkpKSB7CisJCQlyID0gZG1hX2J1Zl9waW4oYXR0YWNoKTsKKwkJCWlmIChyKQorCQkJCXJldHVy biBFUlJfUFRSKHIpOworCQl9CisJfQogCiAJc2dfdGFibGUgPSBhdHRhY2gtPmRtYWJ1Zi0+b3Bz LT5tYXBfZG1hX2J1ZihhdHRhY2gsIGRpcmVjdGlvbik7CiAJaWYgKCFzZ190YWJsZSkKIAkJc2df dGFibGUgPSBFUlJfUFRSKC1FTk9NRU0pOwogCisJaWYgKElTX0VSUihzZ190YWJsZSkgJiYgZG1h X2J1Zl9pc19keW5hbWljKGF0dGFjaC0+ZG1hYnVmKSAmJgorCSAgICAoIWF0dGFjaC0+aW1wb3J0 ZXJfb3BzLT5tb3ZlX25vdGlmeSB8fAorCSAgICAgIUlTX0VOQUJMRUQoQ09ORklHX0RNQUJVRl9N T1ZFX05PVElGWSkpKQorCQlkbWFfYnVmX3VucGluKGF0dGFjaCk7CisKIAlpZiAoIUlTX0VSUihz Z190YWJsZSkgJiYgYXR0YWNoLT5kbWFidWYtPm9wcy0+Y2FjaGVfc2d0X21hcHBpbmcpIHsKIAkJ YXR0YWNoLT5zZ3QgPSBzZ190YWJsZTsKIAkJYXR0YWNoLT5kaXIgPSBkaXJlY3Rpb247CkBAIC04 NjQsOSArOTMzLDM0IEBAIHZvaWQgZG1hX2J1Zl91bm1hcF9hdHRhY2htZW50KHN0cnVjdCBkbWFf YnVmX2F0dGFjaG1lbnQgKmF0dGFjaCwKIAkJZG1hX3Jlc3ZfYXNzZXJ0X2hlbGQoYXR0YWNoLT5k bWFidWYtPnJlc3YpOwogCiAJYXR0YWNoLT5kbWFidWYtPm9wcy0+dW5tYXBfZG1hX2J1ZihhdHRh Y2gsIHNnX3RhYmxlLCBkaXJlY3Rpb24pOworCisJaWYgKGRtYV9idWZfaXNfZHluYW1pYyhhdHRh Y2gtPmRtYWJ1ZikgJiYKKwkgICAgKCFhdHRhY2gtPmltcG9ydGVyX29wcy0+bW92ZV9ub3RpZnkg fHwKKwkgICAgICFJU19FTkFCTEVEKENPTkZJR19ETUFCVUZfTU9WRV9OT1RJRlkpKSkKKwkJZG1h X2J1Zl91bnBpbihhdHRhY2gpOwogfQogRVhQT1JUX1NZTUJPTF9HUEwoZG1hX2J1Zl91bm1hcF9h dHRhY2htZW50KTsKIAorLyoqCisgKiBkbWFfYnVmX21vdmVfbm90aWZ5IC0gbm90aWZ5IGF0dGFj aG1lbnRzIHRoYXQgRE1BLWJ1ZiBpcyBtb3ZpbmcKKyAqCisgKiBAZG1hYnVmOglbaW5dCWJ1ZmZl ciB3aGljaCBpcyBtb3ZpbmcKKyAqCisgKiBJbmZvcm1zIGFsbCBhdHRhY2htZW5zdCB0aGF0IHRo ZXkgbmVlZCB0byBkZXN0cm95IGFuZCByZWNyZWF0ZWQgYWxsIHRoZWlyCisgKiBtYXBwaW5ncy4K KyAqLwordm9pZCBkbWFfYnVmX21vdmVfbm90aWZ5KHN0cnVjdCBkbWFfYnVmICpkbWFidWYpCit7 CisJc3RydWN0IGRtYV9idWZfYXR0YWNobWVudCAqYXR0YWNoOworCisJZG1hX3Jlc3ZfYXNzZXJ0 X2hlbGQoZG1hYnVmLT5yZXN2KTsKKworCWxpc3RfZm9yX2VhY2hfZW50cnkoYXR0YWNoLCAmZG1h YnVmLT5hdHRhY2htZW50cywgbm9kZSkKKwkJaWYgKGF0dGFjaC0+aW1wb3J0ZXJfb3BzICYmIGF0 dGFjaC0+aW1wb3J0ZXJfb3BzLT5tb3ZlX25vdGlmeSkKKwkJCWF0dGFjaC0+aW1wb3J0ZXJfb3Bz LT5tb3ZlX25vdGlmeShhdHRhY2gpOworfQorRVhQT1JUX1NZTUJPTF9HUEwoZG1hX2J1Zl9tb3Zl X25vdGlmeSk7CisKIC8qKgogICogRE9DOiBjcHUgYWNjZXNzCiAgKgpkaWZmIC0tZ2l0IGEvZHJp dmVycy9ncHUvZHJtL2FtZC9hbWRncHUvYW1kZ3B1X2RtYV9idWYuYyBiL2RyaXZlcnMvZ3B1L2Ry bS9hbWQvYW1kZ3B1L2FtZGdwdV9kbWFfYnVmLmMKaW5kZXggYTU5Y2Q0N2FhNmMxLi43Y2FmYzY1 ZmQ3NmEgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvZ3B1L2RybS9hbWQvYW1kZ3B1L2FtZGdwdV9kbWFf YnVmLmMKKysrIGIvZHJpdmVycy9ncHUvZHJtL2FtZC9hbWRncHUvYW1kZ3B1X2RtYV9idWYuYwpA QCAtNDEyLDYgKzQxMiw5IEBAIGFtZGdwdV9kbWFfYnVmX2NyZWF0ZV9vYmooc3RydWN0IGRybV9k ZXZpY2UgKmRldiwgc3RydWN0IGRtYV9idWYgKmRtYV9idWYpCiAJcmV0dXJuIEVSUl9QVFIocmV0 KTsKIH0KIAorc3RhdGljIGNvbnN0IHN0cnVjdCBkbWFfYnVmX2F0dGFjaF9vcHMgYW1kZ3B1X2Rt YV9idWZfYXR0YWNoX29wcyA9IHsKK307CisKIC8qKgogICogYW1kZ3B1X2dlbV9wcmltZV9pbXBv cnQgLSAmZHJtX2RyaXZlci5nZW1fcHJpbWVfaW1wb3J0IGltcGxlbWVudGF0aW9uCiAgKiBAZGV2 OiBEUk0gZGV2aWNlCkBAIC00NDQsNyArNDQ3LDggQEAgc3RydWN0IGRybV9nZW1fb2JqZWN0ICph bWRncHVfZ2VtX3ByaW1lX2ltcG9ydChzdHJ1Y3QgZHJtX2RldmljZSAqZGV2LAogCWlmIChJU19F UlIob2JqKSkKIAkJcmV0dXJuIG9iajsKIAotCWF0dGFjaCA9IGRtYV9idWZfZHluYW1pY19hdHRh Y2goZG1hX2J1ZiwgZGV2LT5kZXYsIHRydWUpOworCWF0dGFjaCA9IGRtYV9idWZfZHluYW1pY19h dHRhY2goZG1hX2J1ZiwgZGV2LT5kZXYsCisJCQkJCSZhbWRncHVfZG1hX2J1Zl9hdHRhY2hfb3Bz LCBOVUxMKTsKIAlpZiAoSVNfRVJSKGF0dGFjaCkpIHsKIAkJZHJtX2dlbV9vYmplY3RfcHV0KG9i aik7CiAJCXJldHVybiBFUlJfQ0FTVChhdHRhY2gpOwpkaWZmIC0tZ2l0IGEvaW5jbHVkZS9saW51 eC9kbWEtYnVmLmggYi9pbmNsdWRlL2xpbnV4L2RtYS1idWYuaAppbmRleCBhYmY1NDU5YTViOWQu LmIzOGNlYTI0MGI2NyAxMDA2NDQKLS0tIGEvaW5jbHVkZS9saW51eC9kbWEtYnVmLmgKKysrIGIv aW5jbHVkZS9saW51eC9kbWEtYnVmLmgKQEAgLTkzLDE0ICs5Myw0MSBAQCBzdHJ1Y3QgZG1hX2J1 Zl9vcHMgewogCSAqLwogCXZvaWQgKCpkZXRhY2gpKHN0cnVjdCBkbWFfYnVmICosIHN0cnVjdCBk bWFfYnVmX2F0dGFjaG1lbnQgKik7CiAKKwkvKioKKwkgKiBAcGluOgorCSAqCisJICogVGhpcyBp cyBjYWxsZWQgYnkgZG1hX2J1Zl9waW4gYW5kIGxldHMgdGhlIGV4cG9ydGVyIGtub3cgdGhhdCB0 aGUKKwkgKiBETUEtYnVmIGNhbid0IGJlIG1vdmVkIGFueSBtb3JlLgorCSAqCisJICogVGhpcyBp cyBjYWxsZWQgd2l0aCB0aGUgZG1hYnVmLT5yZXN2IG9iamVjdCBsb2NrZWQuCisJICoKKwkgKiBU aGlzIGNhbGxiYWNrIGlzIG9wdGlvbmFsIGFuZCBzaG91bGQgb25seSBiZSB1c2VkIGluIGxpbWl0 ZWQgdXNlCisJICogY2FzZXMgbGlrZSBzY2Fub3V0IGFuZCBub3QgZm9yIHRlbXBvcmFyeSBwaW4g b3BlcmF0aW9ucy4KKwkgKgorCSAqIFJldHVybnM6CisJICoKKwkgKiAwIG9uIHN1Y2Nlc3MsIG5l Z2F0aXZlIGVycm9yIGNvZGUgb24gZmFpbHVyZS4KKwkgKi8KKwlpbnQgKCpwaW4pKHN0cnVjdCBk bWFfYnVmX2F0dGFjaG1lbnQgKmF0dGFjaCk7CisKKwkvKioKKwkgKiBAdW5waW46CisJICoKKwkg KiBUaGlzIGlzIGNhbGxlZCBieSBkbWFfYnVmX3VucGluIGFuZCBsZXRzIHRoZSBleHBvcnRlciBr bm93IHRoYXQgdGhlCisJICogRE1BLWJ1ZiBjYW4gYmUgbW92ZWQgYWdhaW4uCisJICoKKwkgKiBU aGlzIGlzIGNhbGxlZCB3aXRoIHRoZSBkbWFidWYtPnJlc3Ygb2JqZWN0IGxvY2tlZC4KKwkgKgor CSAqIFRoaXMgY2FsbGJhY2sgaXMgb3B0aW9uYWwuCisJICovCisJdm9pZCAoKnVucGluKShzdHJ1 Y3QgZG1hX2J1Zl9hdHRhY2htZW50ICphdHRhY2gpOworCiAJLyoqCiAJICogQG1hcF9kbWFfYnVm OgogCSAqCiAJICogVGhpcyBpcyBjYWxsZWQgYnkgZG1hX2J1Zl9tYXBfYXR0YWNobWVudCgpIGFu ZCBpcyB1c2VkIHRvIG1hcCBhCiAJICogc2hhcmVkICZkbWFfYnVmIGludG8gZGV2aWNlIGFkZHJl c3Mgc3BhY2UsIGFuZCBpdCBpcyBtYW5kYXRvcnkuIEl0Ci0JICogY2FuIG9ubHkgYmUgY2FsbGVk IGlmIEBhdHRhY2ggaGFzIGJlZW4gY2FsbGVkIHN1Y2Nlc3NmdWxseS4gVGhpcwotCSAqIGVzc2Vu dGlhbGx5IHBpbnMgdGhlIERNQSBidWZmZXIgaW50byBwbGFjZSwgYW5kIGl0IGNhbm5vdCBiZSBt b3ZlZAotCSAqIGFueSBtb3JlCisJICogY2FuIG9ubHkgYmUgY2FsbGVkIGlmIEBhdHRhY2ggaGFz IGJlZW4gY2FsbGVkIHN1Y2Nlc3NmdWxseS4KIAkgKgogCSAqIFRoaXMgY2FsbCBtYXkgc2xlZXAs IGUuZy4gd2hlbiB0aGUgYmFja2luZyBzdG9yYWdlIGZpcnN0IG5lZWRzIHRvIGJlCiAJICogYWxs b2NhdGVkLCBvciBtb3ZlZCB0byBhIGxvY2F0aW9uIHN1aXRhYmxlIGZvciBhbGwgY3VycmVudGx5 IGF0dGFjaGVkCkBAIC0xNDEsOSArMTY4LDggQEAgc3RydWN0IGRtYV9idWZfb3BzIHsKIAkgKgog CSAqIFRoaXMgaXMgY2FsbGVkIGJ5IGRtYV9idWZfdW5tYXBfYXR0YWNobWVudCgpIGFuZCBzaG91 bGQgdW5tYXAgYW5kCiAJICogcmVsZWFzZSB0aGUgJnNnX3RhYmxlIGFsbG9jYXRlZCBpbiBAbWFw X2RtYV9idWYsIGFuZCBpdCBpcyBtYW5kYXRvcnkuCi0JICogSXQgc2hvdWxkIGFsc28gdW5waW4g dGhlIGJhY2tpbmcgc3RvcmFnZSBpZiB0aGlzIGlzIHRoZSBsYXN0IG1hcHBpbmcKLQkgKiBvZiB0 aGUgRE1BIGJ1ZmZlciwgaXQgdGhlIGV4cG9ydGVyIHN1cHBvcnRzIGJhY2tpbmcgc3RvcmFnZQot CSAqIG1pZ3JhdGlvbi4KKwkgKiBGb3Igc3RhdGljIGRtYV9idWYgaGFuZGxpbmcgdGhpcyBtaWdo dCBhbHNvIHVucGlucyB0aGUgYmFja2luZworCSAqIHN0b3JhZ2UgaWYgdGhpcyBpcyB0aGUgbGFz dCBtYXBwaW5nIG9mIHRoZSBETUEgYnVmZmVyLgogCSAqLwogCXZvaWQgKCp1bm1hcF9kbWFfYnVm KShzdHJ1Y3QgZG1hX2J1Zl9hdHRhY2htZW50ICosCiAJCQkgICAgICBzdHJ1Y3Qgc2dfdGFibGUg KiwKQEAgLTMxMSw2ICszMzcsMzQgQEAgc3RydWN0IGRtYV9idWYgewogCX0gY2JfZXhjbCwgY2Jf c2hhcmVkOwogfTsKIAorLyoqCisgKiBzdHJ1Y3QgZG1hX2J1Zl9hdHRhY2hfb3BzIC0gaW1wb3J0 ZXIgb3BlcmF0aW9ucyBmb3IgYW4gYXR0YWNobWVudAorICogQG1vdmVfbm90aWZ5OiBbb3B0aW9u YWxdIG5vdGlmaWNhdGlvbiB0aGF0IHRoZSBETUEtYnVmIGlzIG1vdmluZworICoKKyAqIEF0dGFj aG1lbnQgb3BlcmF0aW9ucyBpbXBsZW1lbnRlZCBieSB0aGUgaW1wb3J0ZXIuCisgKi8KK3N0cnVj dCBkbWFfYnVmX2F0dGFjaF9vcHMgeworCS8qKgorCSAqIEBtb3ZlX25vdGlmeQorCSAqCisJICog SWYgdGhpcyBjYWxsYmFjayBpcyBwcm92aWRlZCB0aGUgZnJhbWV3b3JrIGNhbiBhdm9pZCBwaW5u aW5nIHRoZQorCSAqIGJhY2tpbmcgc3RvcmUgd2hpbGUgbWFwcGluZ3MgZXhpc3RzLgorCSAqCisJ ICogVGhpcyBjYWxsYmFjayBpcyBjYWxsZWQgd2l0aCB0aGUgbG9jayBvZiB0aGUgcmVzZXJ2YXRp b24gb2JqZWN0CisJICogYXNzb2NpYXRlZCB3aXRoIHRoZSBkbWFfYnVmIGhlbGQgYW5kIHRoZSBt YXBwaW5nIGZ1bmN0aW9uIG11c3QgYmUKKwkgKiBjYWxsZWQgd2l0aCB0aGlzIGxvY2sgaGVsZCBh cyB3ZWxsLiBUaGlzIG1ha2VzIHN1cmUgdGhhdCBubyBtYXBwaW5nCisJICogaXMgY3JlYXRlZCBj b25jdXJyZW50bHkgd2l0aCBhbiBvbmdvaW5nIG1vdmUgb3BlcmF0aW9uLgorCSAqCisJICogTWFw cGluZ3Mgc3RheSB2YWxpZCBhbmQgYXJlIG5vdCBkaXJlY3RseSBhZmZlY3RlZCBieSB0aGlzIGNh bGxiYWNrLgorCSAqIEJ1dCB0aGUgRE1BLWJ1ZiBjYW4gbm93IGJlIGluIGEgZGlmZmVyZW50IHBo eXNpY2FsIGxvY2F0aW9uLCBzbyBhbGwKKwkgKiBtYXBwaW5ncyBzaG91bGQgYmUgZGVzdHJveWVk IGFuZCByZS1jcmVhdGVkIGFzIHNvb24gYXMgcG9zc2libGUuCisJICoKKwkgKiBOZXcgbWFwcGlu Z3MgY2FuIGJlIGNyZWF0ZWQgYWZ0ZXIgdGhpcyBjYWxsYmFjayByZXR1cm5zLCBhbmQgd2lsbAor CSAqIHBvaW50IHRvIHRoZSBuZXcgbG9jYXRpb24gb2YgdGhlIERNQS1idWYuCisJICovCisJdm9p ZCAoKm1vdmVfbm90aWZ5KShzdHJ1Y3QgZG1hX2J1Zl9hdHRhY2htZW50ICphdHRhY2gpOworfTsK KwogLyoqCiAgKiBzdHJ1Y3QgZG1hX2J1Zl9hdHRhY2htZW50IC0gaG9sZHMgZGV2aWNlLWJ1ZmZl ciBhdHRhY2htZW50IGRhdGEKICAqIEBkbWFidWY6IGJ1ZmZlciBmb3IgdGhpcyBhdHRhY2htZW50 LgpAQCAtMzE5LDggKzM3Myw5IEBAIHN0cnVjdCBkbWFfYnVmIHsKICAqIEBzZ3Q6IGNhY2hlZCBt YXBwaW5nLgogICogQGRpcjogZGlyZWN0aW9uIG9mIGNhY2hlZCBtYXBwaW5nLgogICogQHByaXY6 IGV4cG9ydGVyIHNwZWNpZmljIGF0dGFjaG1lbnQgZGF0YS4KLSAqIEBkeW5hbWljX21hcHBpbmc6 IHRydWUgaWYgZG1hX2J1Zl9tYXAvdW5tYXBfYXR0YWNobWVudCgpIGlzIGNhbGxlZCB3aXRoIHRo ZQotICogZG1hX3Jlc3YgbG9jayBoZWxkLgorICogQGltcG9ydGVyX29wczogaW1wb3J0ZXIgb3Bl cmF0aW9ucyBmb3IgdGhpcyBhdHRhY2htZW50LCBpZiBwcm92aWRlZAorICogZG1hX2J1Zl9tYXAv dW5tYXBfYXR0YWNobWVudCgpIG11c3QgYmUgY2FsbGVkIHdpdGggdGhlIGRtYV9yZXN2IGxvY2sg aGVsZC4KKyAqIEBpbXBvcnRlcl9wcml2OiBpbXBvcnRlciBzcGVjaWZpYyBhdHRhY2htZW50IGRh dGEuCiAgKgogICogVGhpcyBzdHJ1Y3R1cmUgaG9sZHMgdGhlIGF0dGFjaG1lbnQgaW5mb3JtYXRp b24gYmV0d2VlbiB0aGUgZG1hX2J1ZiBidWZmZXIKICAqIGFuZCBpdHMgdXNlciBkZXZpY2Uocyku IFRoZSBsaXN0IGNvbnRhaW5zIG9uZSBhdHRhY2htZW50IHN0cnVjdCBwZXIgZGV2aWNlCkBAIC0z MzcsNyArMzkyLDggQEAgc3RydWN0IGRtYV9idWZfYXR0YWNobWVudCB7CiAJc3RydWN0IGxpc3Rf aGVhZCBub2RlOwogCXN0cnVjdCBzZ190YWJsZSAqc2d0OwogCWVudW0gZG1hX2RhdGFfZGlyZWN0 aW9uIGRpcjsKLQlib29sIGR5bmFtaWNfbWFwcGluZzsKKwljb25zdCBzdHJ1Y3QgZG1hX2J1Zl9h dHRhY2hfb3BzICppbXBvcnRlcl9vcHM7CisJdm9pZCAqaW1wb3J0ZXJfcHJpdjsKIAl2b2lkICpw cml2OwogfTsKIApAQCAtMzk5LDYgKzQ1NSw3IEBAIHN0YXRpYyBpbmxpbmUgdm9pZCBnZXRfZG1h X2J1ZihzdHJ1Y3QgZG1hX2J1ZiAqZG1hYnVmKQogICovCiBzdGF0aWMgaW5saW5lIGJvb2wgZG1h X2J1Zl9pc19keW5hbWljKHN0cnVjdCBkbWFfYnVmICpkbWFidWYpCiB7CisJLyogVE9ETzogc3dp dGNoIHRvIHVzaW5nIHBpbi91bnBpbiBmdW5jdGlvbnMgYXMgaW5kaWNhdG9yLiAqLwogCXJldHVy biBkbWFidWYtPm9wcy0+ZHluYW1pY19tYXBwaW5nOwogfQogCkBAIC00MTMsMTYgKzQ3MCwxOSBA QCBzdGF0aWMgaW5saW5lIGJvb2wgZG1hX2J1Zl9pc19keW5hbWljKHN0cnVjdCBkbWFfYnVmICpk bWFidWYpCiBzdGF0aWMgaW5saW5lIGJvb2wKIGRtYV9idWZfYXR0YWNobWVudF9pc19keW5hbWlj KHN0cnVjdCBkbWFfYnVmX2F0dGFjaG1lbnQgKmF0dGFjaCkKIHsKLQlyZXR1cm4gYXR0YWNoLT5k eW5hbWljX21hcHBpbmc7CisJcmV0dXJuICEhYXR0YWNoLT5pbXBvcnRlcl9vcHM7CiB9CiAKIHN0 cnVjdCBkbWFfYnVmX2F0dGFjaG1lbnQgKmRtYV9idWZfYXR0YWNoKHN0cnVjdCBkbWFfYnVmICpk bWFidWYsCiAJCQkJCSAgc3RydWN0IGRldmljZSAqZGV2KTsKIHN0cnVjdCBkbWFfYnVmX2F0dGFj aG1lbnQgKgogZG1hX2J1Zl9keW5hbWljX2F0dGFjaChzdHJ1Y3QgZG1hX2J1ZiAqZG1hYnVmLCBz dHJ1Y3QgZGV2aWNlICpkZXYsCi0JCSAgICAgICBib29sIGR5bmFtaWNfbWFwcGluZyk7CisJCSAg ICAgICBjb25zdCBzdHJ1Y3QgZG1hX2J1Zl9hdHRhY2hfb3BzICppbXBvcnRlcl9vcHMsCisJCSAg ICAgICB2b2lkICppbXBvcnRlcl9wcml2KTsKIHZvaWQgZG1hX2J1Zl9kZXRhY2goc3RydWN0IGRt YV9idWYgKmRtYWJ1ZiwKIAkJICAgIHN0cnVjdCBkbWFfYnVmX2F0dGFjaG1lbnQgKmF0dGFjaCk7 CitpbnQgZG1hX2J1Zl9waW4oc3RydWN0IGRtYV9idWZfYXR0YWNobWVudCAqYXR0YWNoKTsKK3Zv aWQgZG1hX2J1Zl91bnBpbihzdHJ1Y3QgZG1hX2J1Zl9hdHRhY2htZW50ICphdHRhY2gpOwogCiBz dHJ1Y3QgZG1hX2J1ZiAqZG1hX2J1Zl9leHBvcnQoY29uc3Qgc3RydWN0IGRtYV9idWZfZXhwb3J0 X2luZm8gKmV4cF9pbmZvKTsKIAotLSAKMi4xNy4xCgpfX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fXwpJbnRlbC1nZnggbWFpbGluZyBsaXN0CkludGVsLWdmeEBs aXN0cy5mcmVlZGVza3RvcC5vcmcKaHR0cHM6Ly9saXN0cy5mcmVlZGVza3RvcC5vcmcvbWFpbG1h bi9saXN0aW5mby9pbnRlbC1nZngK