From mboxrd@z Thu Jan 1 00:00:00 1970 From: Russell King - ARM Linux admin Subject: Re: [PATCH] dma-buf: add struct dma_buf_attach_info v2 Date: Tue, 30 Apr 2019 18:31:27 +0100 Message-ID: <20190430173127.k5ivpaz6ktbfecgo@shell.armlinux.org.uk> References: <20190430111002.106168-1-christian.koenig@amd.com> Mime-Version: 1.0 Content-Type: text/plain; charset=iso-8859-1 Content-Transfer-Encoding: 8bit Return-path: Content-Disposition: inline In-Reply-To: <20190430111002.106168-1-christian.koenig@amd.com> Sender: linux-kernel-owner@vger.kernel.org To: Christian =?iso-8859-1?Q?K=F6nig?= Cc: xen-devel@lists.xenproject.org, devel@driverdev.osuosl.org, linux-tegra@vger.kernel.org, intel-gfx@lists.freedesktop.org, linux-kernel@vger.kernel.org, dri-devel@lists.freedesktop.org, linux-media@vger.kernel.org, sstabellini@kernel.org, jgross@suse.com, boris.ostrovsky@oracle.com, digetx@gmail.com, gregkh@linuxfoundation.org, arnd@arndb.de, mchehab@kernel.org, kyungmin.park@samsung.com, m.szyprowski@samsung.com, pawel@osciak.com, jonathanh@nvidia.com, thierry.reding@gmail.com, tomi.valkeinen@ti.com, rodrigo.vivi@intel.com, joonas.lahtinen@linux.intel.com, jani.nikula@linux.intel.com, sean@poorly.run, maxime.ripard@bootlin.com, maarten.lankhorst@linux.intel.com, sumit.semwal@linaro.org List-Id: linux-tegra@vger.kernel.org On Tue, Apr 30, 2019 at 01:10:02PM +0200, Christian König wrote: > Add a structure for the parameters of dma_buf_attach, this makes it much easier > to add new parameters later on. I don't understand this reasoning. What are the "new parameters" that are being proposed, and why do we need to put them into memory to pass them across this interface? If the intention is to make it easier to change the interface, passing parameters in this manner mean that it's easy for the interface to change and drivers not to notice the changes, since the compiler will not warn (unless some member of the structure that the driver is using gets removed, in which case it will error.) Additions to the structure will go unnoticed by drivers - what if the caller is expecting some different kind of behaviour, and the driver ignores that new addition? This doesn't seem to me like a good idea. > > v2: rebase cleanup and fix all new implementations as well > > Signed-off-by: Christian König > --- > drivers/dma-buf/dma-buf.c | 13 +++++++------ > drivers/gpu/drm/armada/armada_gem.c | 6 +++++- > drivers/gpu/drm/drm_prime.c | 6 +++++- > drivers/gpu/drm/i915/i915_gem_dmabuf.c | 6 +++++- > drivers/gpu/drm/omapdrm/omap_gem_dmabuf.c | 6 +++++- > drivers/gpu/drm/tegra/gem.c | 6 +++++- > drivers/gpu/drm/udl/udl_dmabuf.c | 6 +++++- > .../common/videobuf2/videobuf2-dma-contig.c | 6 +++++- > .../media/common/videobuf2/videobuf2-dma-sg.c | 6 +++++- > drivers/misc/fastrpc.c | 6 +++++- > drivers/staging/media/tegra-vde/tegra-vde.c | 6 +++++- > drivers/xen/gntdev-dmabuf.c | 4 ++++ > include/linux/dma-buf.h | 17 +++++++++++++++-- > 13 files changed, 76 insertions(+), 18 deletions(-) > > diff --git a/drivers/dma-buf/dma-buf.c b/drivers/dma-buf/dma-buf.c > index 3ae6c0c2cc02..e295e76a8c57 100644 > --- a/drivers/dma-buf/dma-buf.c > +++ b/drivers/dma-buf/dma-buf.c > @@ -535,8 +535,9 @@ EXPORT_SYMBOL_GPL(dma_buf_put); > /** > * dma_buf_attach - Add the device to dma_buf's attachments list; optionally, > * 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. > + * @info: [in] holds all the attach related information provided > + * by the importer. see &struct dma_buf_attach_info > + * for further details. > * > * Returns struct dma_buf_attachment pointer for this attachment. Attachments > * must be cleaned up by calling dma_buf_detach(). > @@ -550,20 +551,20 @@ EXPORT_SYMBOL_GPL(dma_buf_put); > * accessible to @dev, and cannot be moved to a more suitable place. This is > * indicated with the error code -EBUSY. > */ > -struct dma_buf_attachment *dma_buf_attach(struct dma_buf *dmabuf, > - struct device *dev) > +struct dma_buf_attachment *dma_buf_attach(const struct dma_buf_attach_info *info) > { > + struct dma_buf *dmabuf = info->dmabuf; > struct dma_buf_attachment *attach; > int ret; > > - if (WARN_ON(!dmabuf || !dev)) > + if (WARN_ON(!dmabuf || !info->dev)) > return ERR_PTR(-EINVAL); > > attach = kzalloc(sizeof(*attach), GFP_KERNEL); > if (!attach) > return ERR_PTR(-ENOMEM); > > - attach->dev = dev; > + attach->dev = info->dev; > attach->dmabuf = dmabuf; > > mutex_lock(&dmabuf->lock); > diff --git a/drivers/gpu/drm/armada/armada_gem.c b/drivers/gpu/drm/armada/armada_gem.c > index 642d0e70d0f8..19c47821032f 100644 > --- a/drivers/gpu/drm/armada/armada_gem.c > +++ b/drivers/gpu/drm/armada/armada_gem.c > @@ -501,6 +501,10 @@ armada_gem_prime_export(struct drm_device *dev, struct drm_gem_object *obj, > struct drm_gem_object * > armada_gem_prime_import(struct drm_device *dev, struct dma_buf *buf) > { > + struct dma_buf_attach_info attach_info = { > + .dev = dev->dev, > + .dmabuf = buf > + }; > struct dma_buf_attachment *attach; > struct armada_gem_object *dobj; > > @@ -516,7 +520,7 @@ armada_gem_prime_import(struct drm_device *dev, struct dma_buf *buf) > } > } > > - attach = dma_buf_attach(buf, dev->dev); > + attach = dma_buf_attach(&attach_info); > if (IS_ERR(attach)) > return ERR_CAST(attach); > > diff --git a/drivers/gpu/drm/drm_prime.c b/drivers/gpu/drm/drm_prime.c > index dc079efb3b0f..1dd70fc095ee 100644 > --- a/drivers/gpu/drm/drm_prime.c > +++ b/drivers/gpu/drm/drm_prime.c > @@ -710,6 +710,10 @@ struct drm_gem_object *drm_gem_prime_import_dev(struct drm_device *dev, > struct dma_buf *dma_buf, > struct device *attach_dev) > { > + struct dma_buf_attach_info attach_info = { > + .dev = attach_dev, > + .dmabuf = dma_buf > + }; > struct dma_buf_attachment *attach; > struct sg_table *sgt; > struct drm_gem_object *obj; > @@ -730,7 +734,7 @@ struct drm_gem_object *drm_gem_prime_import_dev(struct drm_device *dev, > if (!dev->driver->gem_prime_import_sg_table) > return ERR_PTR(-EINVAL); > > - attach = dma_buf_attach(dma_buf, attach_dev); > + attach = dma_buf_attach(&attach_info); > if (IS_ERR(attach)) > return ERR_CAST(attach); > > diff --git a/drivers/gpu/drm/i915/i915_gem_dmabuf.c b/drivers/gpu/drm/i915/i915_gem_dmabuf.c > index 5a101a9462d8..978054157c64 100644 > --- a/drivers/gpu/drm/i915/i915_gem_dmabuf.c > +++ b/drivers/gpu/drm/i915/i915_gem_dmabuf.c > @@ -277,6 +277,10 @@ static const struct drm_i915_gem_object_ops i915_gem_object_dmabuf_ops = { > struct drm_gem_object *i915_gem_prime_import(struct drm_device *dev, > struct dma_buf *dma_buf) > { > + struct dma_buf_attach_info attach_info = { > + .dev = dev->dev, > + .dmabuf = dma_buf > + }; > struct dma_buf_attachment *attach; > struct drm_i915_gem_object *obj; > int ret; > @@ -295,7 +299,7 @@ struct drm_gem_object *i915_gem_prime_import(struct drm_device *dev, > } > > /* need to attach */ > - attach = dma_buf_attach(dma_buf, dev->dev); > + attach = dma_buf_attach(&attach_info); > if (IS_ERR(attach)) > return ERR_CAST(attach); > > diff --git a/drivers/gpu/drm/omapdrm/omap_gem_dmabuf.c b/drivers/gpu/drm/omapdrm/omap_gem_dmabuf.c > index 0f8b597ccd10..38d06574b251 100644 > --- a/drivers/gpu/drm/omapdrm/omap_gem_dmabuf.c > +++ b/drivers/gpu/drm/omapdrm/omap_gem_dmabuf.c > @@ -156,6 +156,10 @@ struct dma_buf *omap_gem_prime_export(struct drm_device *dev, > struct drm_gem_object *omap_gem_prime_import(struct drm_device *dev, > struct dma_buf *dma_buf) > { > + struct dma_buf_attach_info attach_info = { > + .dev = dev->dev, > + .dmabuf = dma_buf > + }; > struct dma_buf_attachment *attach; > struct drm_gem_object *obj; > struct sg_table *sgt; > @@ -173,7 +177,7 @@ struct drm_gem_object *omap_gem_prime_import(struct drm_device *dev, > } > } > > - attach = dma_buf_attach(dma_buf, dev->dev); > + attach = dma_buf_attach(&attach_info); > if (IS_ERR(attach)) > return ERR_CAST(attach); > > diff --git a/drivers/gpu/drm/tegra/gem.c b/drivers/gpu/drm/tegra/gem.c > index 4f80100ff5f3..8e6b6c879add 100644 > --- a/drivers/gpu/drm/tegra/gem.c > +++ b/drivers/gpu/drm/tegra/gem.c > @@ -332,6 +332,10 @@ struct tegra_bo *tegra_bo_create_with_handle(struct drm_file *file, > static struct tegra_bo *tegra_bo_import(struct drm_device *drm, > struct dma_buf *buf) > { > + struct dma_buf_attach_info attach_info = { > + .dev = drm->dev, > + .dmabuf = buf > + }; > struct tegra_drm *tegra = drm->dev_private; > struct dma_buf_attachment *attach; > struct tegra_bo *bo; > @@ -341,7 +345,7 @@ static struct tegra_bo *tegra_bo_import(struct drm_device *drm, > if (IS_ERR(bo)) > return bo; > > - attach = dma_buf_attach(buf, drm->dev); > + attach = dma_buf_attach(&attach_info); > if (IS_ERR(attach)) { > err = PTR_ERR(attach); > goto free; > diff --git a/drivers/gpu/drm/udl/udl_dmabuf.c b/drivers/gpu/drm/udl/udl_dmabuf.c > index 556f62662aa9..86b928f9742f 100644 > --- a/drivers/gpu/drm/udl/udl_dmabuf.c > +++ b/drivers/gpu/drm/udl/udl_dmabuf.c > @@ -226,6 +226,10 @@ static int udl_prime_create(struct drm_device *dev, > struct drm_gem_object *udl_gem_prime_import(struct drm_device *dev, > struct dma_buf *dma_buf) > { > + struct dma_buf_attach_info attach_info = { > + .dev = dev->dev, > + .dmabuf = dma_buf > + }; > struct dma_buf_attachment *attach; > struct sg_table *sg; > struct udl_gem_object *uobj; > @@ -233,7 +237,7 @@ struct drm_gem_object *udl_gem_prime_import(struct drm_device *dev, > > /* need to attach */ > get_device(dev->dev); > - attach = dma_buf_attach(dma_buf, dev->dev); > + attach = dma_buf_attach(&attach_info); > if (IS_ERR(attach)) { > put_device(dev->dev); > return ERR_CAST(attach); > diff --git a/drivers/media/common/videobuf2/videobuf2-dma-contig.c b/drivers/media/common/videobuf2/videobuf2-dma-contig.c > index 82389aead6ed..b2d844d45ea6 100644 > --- a/drivers/media/common/videobuf2/videobuf2-dma-contig.c > +++ b/drivers/media/common/videobuf2/videobuf2-dma-contig.c > @@ -653,6 +653,10 @@ static void vb2_dc_detach_dmabuf(void *mem_priv) > static void *vb2_dc_attach_dmabuf(struct device *dev, struct dma_buf *dbuf, > unsigned long size, enum dma_data_direction dma_dir) > { > + struct dma_buf_attach_info attach_info = { > + .dev = dev, > + .dmabuf = dbuf > + }; > struct vb2_dc_buf *buf; > struct dma_buf_attachment *dba; > > @@ -668,7 +672,7 @@ static void *vb2_dc_attach_dmabuf(struct device *dev, struct dma_buf *dbuf, > > buf->dev = dev; > /* create attachment for the dmabuf with the user device */ > - dba = dma_buf_attach(dbuf, buf->dev); > + dba = dma_buf_attach(&attach_info); > if (IS_ERR(dba)) { > pr_err("failed to attach dmabuf\n"); > kfree(buf); > diff --git a/drivers/media/common/videobuf2/videobuf2-dma-sg.c b/drivers/media/common/videobuf2/videobuf2-dma-sg.c > index 270c3162fdcb..ddd5f36a8ec7 100644 > --- a/drivers/media/common/videobuf2/videobuf2-dma-sg.c > +++ b/drivers/media/common/videobuf2/videobuf2-dma-sg.c > @@ -608,6 +608,10 @@ static void vb2_dma_sg_detach_dmabuf(void *mem_priv) > static void *vb2_dma_sg_attach_dmabuf(struct device *dev, struct dma_buf *dbuf, > unsigned long size, enum dma_data_direction dma_dir) > { > + struct dma_buf_attach_info attach_info = { > + .dev = dev, > + .dmabuf = dbuf > + }; > struct vb2_dma_sg_buf *buf; > struct dma_buf_attachment *dba; > > @@ -623,7 +627,7 @@ static void *vb2_dma_sg_attach_dmabuf(struct device *dev, struct dma_buf *dbuf, > > buf->dev = dev; > /* create attachment for the dmabuf with the user device */ > - dba = dma_buf_attach(dbuf, buf->dev); > + dba = dma_buf_attach(&attach_info); > if (IS_ERR(dba)) { > pr_err("failed to attach dmabuf\n"); > kfree(buf); > diff --git a/drivers/misc/fastrpc.c b/drivers/misc/fastrpc.c > index 39f832d27288..93d0aac05715 100644 > --- a/drivers/misc/fastrpc.c > +++ b/drivers/misc/fastrpc.c > @@ -482,6 +482,7 @@ static int fastrpc_map_create(struct fastrpc_user *fl, int fd, > u64 len, struct fastrpc_map **ppmap) > { > struct fastrpc_session_ctx *sess = fl->sctx; > + struct dma_buf_attach_info attach_info; > struct fastrpc_map *map = NULL; > int err = 0; > > @@ -501,7 +502,10 @@ static int fastrpc_map_create(struct fastrpc_user *fl, int fd, > goto get_err; > } > > - map->attach = dma_buf_attach(map->buf, sess->dev); > + memset(&attach_info, 0, sizeof(attach_info)); > + attach_info.dev = sess->dev; > + attach_info.dmabuf = map->buf; > + map->attach = dma_buf_attach(&attach_info); > if (IS_ERR(map->attach)) { > dev_err(sess->dev, "Failed to attach dmabuf\n"); > err = PTR_ERR(map->attach); > diff --git a/drivers/staging/media/tegra-vde/tegra-vde.c b/drivers/staging/media/tegra-vde/tegra-vde.c > index aa6c6bba961e..5a10c1facc27 100644 > --- a/drivers/staging/media/tegra-vde/tegra-vde.c > +++ b/drivers/staging/media/tegra-vde/tegra-vde.c > @@ -568,6 +568,10 @@ static int tegra_vde_attach_dmabuf(struct device *dev, > size_t *size, > enum dma_data_direction dma_dir) > { > + struct dma_buf_attach_info attach_info = { > + .dev = dev, > + .dmabuf = dmabuf > + }; > struct dma_buf_attachment *attachment; > struct dma_buf *dmabuf; > struct sg_table *sgt; > @@ -591,7 +595,7 @@ static int tegra_vde_attach_dmabuf(struct device *dev, > return -EINVAL; > } > > - attachment = dma_buf_attach(dmabuf, dev); > + attachment = dma_buf_attach(&attach_info); > if (IS_ERR(attachment)) { > dev_err(dev, "Failed to attach dmabuf\n"); > err = PTR_ERR(attachment); > diff --git a/drivers/xen/gntdev-dmabuf.c b/drivers/xen/gntdev-dmabuf.c > index 2c4f324f8626..cacca830b482 100644 > --- a/drivers/xen/gntdev-dmabuf.c > +++ b/drivers/xen/gntdev-dmabuf.c > @@ -608,6 +608,7 @@ dmabuf_imp_to_refs(struct gntdev_dmabuf_priv *priv, struct device *dev, > int fd, int count, int domid) > { > struct gntdev_dmabuf *gntdev_dmabuf, *ret; > + struct dma_buf_attach_info attach_info; > struct dma_buf *dma_buf; > struct dma_buf_attachment *attach; > struct sg_table *sgt; > @@ -627,6 +628,9 @@ dmabuf_imp_to_refs(struct gntdev_dmabuf_priv *priv, struct device *dev, > gntdev_dmabuf->priv = priv; > gntdev_dmabuf->fd = fd; > > + memset(&attach_info, 0, sizeof(attach_info)); > + attach_info.dev = dev; > + attach_info.dmabuf = dma_buf; > attach = dma_buf_attach(dma_buf, dev); > if (IS_ERR(attach)) { > ret = ERR_CAST(attach); > diff --git a/include/linux/dma-buf.h b/include/linux/dma-buf.h > index a0bd071466fc..b5b0f5e3f186 100644 > --- a/include/linux/dma-buf.h > +++ b/include/linux/dma-buf.h > @@ -375,6 +375,19 @@ struct dma_buf_export_info { > struct dma_buf_export_info name = { .exp_name = KBUILD_MODNAME, \ > .owner = THIS_MODULE } > > +/** > + * struct dma_buf_attach_info - holds information needed to attach to a dma_buf > + * @dmabuf: the exported dma_buf > + * @dev: the device which wants to import the attachment > + * > + * This structure holds the information required to attach to a buffer. Used > + * with dma_buf_attach() only. > + */ > +struct dma_buf_attach_info { > + struct dma_buf *dmabuf; > + struct device *dev; > +}; > + > /** > * get_dma_buf - convenience wrapper for get_file. > * @dmabuf: [in] pointer to dma_buf > @@ -389,8 +402,8 @@ static inline void get_dma_buf(struct dma_buf *dmabuf) > get_file(dmabuf->file); > } > > -struct dma_buf_attachment *dma_buf_attach(struct dma_buf *dmabuf, > - struct device *dev); > +struct dma_buf_attachment * > +dma_buf_attach(const struct dma_buf_attach_info *info); > void dma_buf_detach(struct dma_buf *dmabuf, > struct dma_buf_attachment *dmabuf_attach); > > -- > 2.17.1 > > -- RMK's Patch system: https://www.armlinux.org.uk/developer/patches/ FTTC broadband for 0.8mile line in suburbia: sync at 12.1Mbps down 622kbps up According to speedtest.net: 11.9Mbps down 500kbps up 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=-8.8 required=3.0 tests=DKIM_INVALID,DKIM_SIGNED, HEADER_FROM_DIFFERENT_DOMAINS,INCLUDES_PATCH,MAILING_LIST_MULTI,SIGNED_OFF_BY, SPF_HELO_NONE,SPF_PASS,URIBL_BLOCKED,USER_AGENT_NEOMUTT 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 BBB8EC43219 for ; Tue, 30 Apr 2019 17:32:27 +0000 (UTC) Received: from lists.xenproject.org (lists.xenproject.org [192.237.175.120]) (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 7CFFC21670 for ; Tue, 30 Apr 2019 17:32:27 +0000 (UTC) Authentication-Results: mail.kernel.org; dkim=fail reason="signature verification failed" (2048-bit key) header.d=armlinux.org.uk header.i=@armlinux.org.uk header.b="bEGACmCO" DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org 7CFFC21670 Authentication-Results: mail.kernel.org; dmarc=fail (p=none dis=none) header.from=armlinux.org.uk Authentication-Results: mail.kernel.org; spf=none smtp.mailfrom=xen-devel-bounces@lists.xenproject.org Received: from localhost ([127.0.0.1] helo=lists.xenproject.org) by lists.xenproject.org with esmtp (Exim 4.89) (envelope-from ) id 1hLWbg-0007UG-G9; Tue, 30 Apr 2019 17:31:52 +0000 Received: from us1-rack-dfw2.inumbo.com ([104.130.134.6]) by lists.xenproject.org with esmtp (Exim 4.89) (envelope-from ) id 1hLWbe-0007UB-Fp for xen-devel@lists.xenproject.org; Tue, 30 Apr 2019 17:31:50 +0000 X-Inumbo-ID: d38a46f6-6b6d-11e9-843c-bc764e045a96 Received: from pandora.armlinux.org.uk (unknown [2001:4d48:ad52:3201:214:fdff:fe10:1be6]) by us1-rack-dfw2.inumbo.com (Halon) with ESMTPS id d38a46f6-6b6d-11e9-843c-bc764e045a96; Tue, 30 Apr 2019 17:31:46 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; d=armlinux.org.uk; s=pandora-2019; h=Sender:In-Reply-To: Content-Transfer-Encoding:Content-Type:MIME-Version:References:Message-ID: Subject:Cc:To:From:Date:Reply-To:Content-ID:Content-Description:Resent-Date: Resent-From:Resent-Sender:Resent-To:Resent-Cc:Resent-Message-ID:List-Id: List-Help:List-Unsubscribe:List-Subscribe:List-Post:List-Owner:List-Archive; bh=X8xU0U6D5kWrphY4pyIW4cT6Pwpmzj8wWI41U0UNHdw=; b=bEGACmCOKe4fNpajmptVRvBbA fz+Abk23XlztD6TL3PZ6Zg/c75wZ3U2MquU1xv8GXapxKn7nVNJVFxRx8CB5T/ZDC0CnsnRbq+wWH POzZF7dj+fVMGUT8hgE8piwTl1K30iUmGwPl+5wtPxS8QDjJbAYfXH4shvuQ/DwUipi0iT4W7j25C 42DgJIE2JEjVh7u0GtLEVX5nYKbSP4HRpZtKr1AgdplZ/xe6+C5H3T5xDsunAbQTrzJfZ0Mip8lz/ jnE9LSsIljM/IdbvlHwDnpYSheAuGqT3dvOHka3e0aqnXszWCkBz2zMjnGplqE8j8tzavfGKXmvXm K9RrlxbKA==; Received: from shell.armlinux.org.uk ([2001:4d48:ad52:3201:5054:ff:fe00:4ec]:55642) by pandora.armlinux.org.uk with esmtpsa (TLSv1.2:ECDHE-RSA-AES256-GCM-SHA384:256) (Exim 4.90_1) (envelope-from ) id 1hLWbV-0007Nk-ST; Tue, 30 Apr 2019 18:31:42 +0100 Received: from linux by shell.armlinux.org.uk with local (Exim 4.89) (envelope-from ) id 1hLWbH-0004AW-Ic; Tue, 30 Apr 2019 18:31:27 +0100 Date: Tue, 30 Apr 2019 18:31:27 +0100 From: Russell King - ARM Linux admin To: Christian =?iso-8859-1?Q?K=F6nig?= Message-ID: <20190430173127.k5ivpaz6ktbfecgo@shell.armlinux.org.uk> References: <20190430111002.106168-1-christian.koenig@amd.com> MIME-Version: 1.0 Content-Disposition: inline In-Reply-To: <20190430111002.106168-1-christian.koenig@amd.com> User-Agent: NeoMutt/20170113 (1.7.2) Subject: Re: [Xen-devel] [PATCH] dma-buf: add struct dma_buf_attach_info v2 X-BeenThere: xen-devel@lists.xenproject.org X-Mailman-Version: 2.1.23 Precedence: list List-Id: Xen developer discussion List-Unsubscribe: , List-Post: List-Help: List-Subscribe: , Cc: maxime.ripard@bootlin.com, joonas.lahtinen@linux.intel.com, dri-devel@lists.freedesktop.org, thierry.reding@gmail.com, digetx@gmail.com, sumit.semwal@linaro.org, m.szyprowski@samsung.com, devel@driverdev.osuosl.org, sstabellini@kernel.org, arnd@arndb.de, jonathanh@nvidia.com, tomi.valkeinen@ti.com, xen-devel@lists.xenproject.org, linux-media@vger.kernel.org, pawel@osciak.com, intel-gfx@lists.freedesktop.org, maarten.lankhorst@linux.intel.com, jani.nikula@linux.intel.com, rodrigo.vivi@intel.com, linux-tegra@vger.kernel.org, boris.ostrovsky@oracle.com, mchehab@kernel.org, sean@poorly.run, jgross@suse.com, gregkh@linuxfoundation.org, linux-kernel@vger.kernel.org, kyungmin.park@samsung.com Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Errors-To: xen-devel-bounces@lists.xenproject.org Sender: "Xen-devel" T24gVHVlLCBBcHIgMzAsIDIwMTkgYXQgMDE6MTA6MDJQTSArMDIwMCwgQ2hyaXN0aWFuIEvDtm5p ZyB3cm90ZToKPiBBZGQgYSBzdHJ1Y3R1cmUgZm9yIHRoZSBwYXJhbWV0ZXJzIG9mIGRtYV9idWZf YXR0YWNoLCB0aGlzIG1ha2VzIGl0IG11Y2ggZWFzaWVyCj4gdG8gYWRkIG5ldyBwYXJhbWV0ZXJz IGxhdGVyIG9uLgoKSSBkb24ndCB1bmRlcnN0YW5kIHRoaXMgcmVhc29uaW5nLiAgV2hhdCBhcmUg dGhlICJuZXcgcGFyYW1ldGVycyIgdGhhdAphcmUgYmVpbmcgcHJvcG9zZWQsIGFuZCB3aHkgZG8g d2UgbmVlZCB0byBwdXQgdGhlbSBpbnRvIG1lbW9yeSB0byBwYXNzCnRoZW0gYWNyb3NzIHRoaXMg aW50ZXJmYWNlPwoKSWYgdGhlIGludGVudGlvbiBpcyB0byBtYWtlIGl0IGVhc2llciB0byBjaGFu Z2UgdGhlIGludGVyZmFjZSwgcGFzc2luZwpwYXJhbWV0ZXJzIGluIHRoaXMgbWFubmVyIG1lYW4g dGhhdCBpdCdzIGVhc3kgZm9yIHRoZSBpbnRlcmZhY2UgdG8KY2hhbmdlIGFuZCBkcml2ZXJzIG5v dCB0byBub3RpY2UgdGhlIGNoYW5nZXMsIHNpbmNlIHRoZSBjb21waWxlciB3aWxsCm5vdCB3YXJu ICh1bmxlc3Mgc29tZSBtZW1iZXIgb2YgdGhlIHN0cnVjdHVyZSB0aGF0IHRoZSBkcml2ZXIgaXMg dXNpbmcKZ2V0cyByZW1vdmVkLCBpbiB3aGljaCBjYXNlIGl0IHdpbGwgZXJyb3IuKQoKQWRkaXRp b25zIHRvIHRoZSBzdHJ1Y3R1cmUgd2lsbCBnbyB1bm5vdGljZWQgYnkgZHJpdmVycyAtIHdoYXQg aWYgdGhlCmNhbGxlciBpcyBleHBlY3Rpbmcgc29tZSBkaWZmZXJlbnQga2luZCBvZiBiZWhhdmlv dXIsIGFuZCB0aGUgZHJpdmVyCmlnbm9yZXMgdGhhdCBuZXcgYWRkaXRpb24/CgpUaGlzIGRvZXNu J3Qgc2VlbSB0byBtZSBsaWtlIGEgZ29vZCBpZGVhLgoKPiAKPiB2MjogcmViYXNlIGNsZWFudXAg YW5kIGZpeCBhbGwgbmV3IGltcGxlbWVudGF0aW9ucyBhcyB3ZWxsCj4gCj4gU2lnbmVkLW9mZi1i eTogQ2hyaXN0aWFuIEvDtm5pZyA8Y2hyaXN0aWFuLmtvZW5pZ0BhbWQuY29tPgo+IC0tLQo+ICBk cml2ZXJzL2RtYS1idWYvZG1hLWJ1Zi5jICAgICAgICAgICAgICAgICAgICAgICB8IDEzICsrKysr KystLS0tLS0KPiAgZHJpdmVycy9ncHUvZHJtL2FybWFkYS9hcm1hZGFfZ2VtLmMgICAgICAgICAg ICAgfCAgNiArKysrKy0KPiAgZHJpdmVycy9ncHUvZHJtL2RybV9wcmltZS5jICAgICAgICAgICAg ICAgICAgICAgfCAgNiArKysrKy0KPiAgZHJpdmVycy9ncHUvZHJtL2k5MTUvaTkxNV9nZW1fZG1h YnVmLmMgICAgICAgICAgfCAgNiArKysrKy0KPiAgZHJpdmVycy9ncHUvZHJtL29tYXBkcm0vb21h cF9nZW1fZG1hYnVmLmMgICAgICAgfCAgNiArKysrKy0KPiAgZHJpdmVycy9ncHUvZHJtL3RlZ3Jh L2dlbS5jICAgICAgICAgICAgICAgICAgICAgfCAgNiArKysrKy0KPiAgZHJpdmVycy9ncHUvZHJt L3VkbC91ZGxfZG1hYnVmLmMgICAgICAgICAgICAgICAgfCAgNiArKysrKy0KPiAgLi4uL2NvbW1v bi92aWRlb2J1ZjIvdmlkZW9idWYyLWRtYS1jb250aWcuYyAgICAgfCAgNiArKysrKy0KPiAgLi4u L21lZGlhL2NvbW1vbi92aWRlb2J1ZjIvdmlkZW9idWYyLWRtYS1zZy5jICAgfCAgNiArKysrKy0K PiAgZHJpdmVycy9taXNjL2Zhc3RycGMuYyAgICAgICAgICAgICAgICAgICAgICAgICAgfCAgNiAr KysrKy0KPiAgZHJpdmVycy9zdGFnaW5nL21lZGlhL3RlZ3JhLXZkZS90ZWdyYS12ZGUuYyAgICAg fCAgNiArKysrKy0KPiAgZHJpdmVycy94ZW4vZ250ZGV2LWRtYWJ1Zi5jICAgICAgICAgICAgICAg ICAgICAgfCAgNCArKysrCj4gIGluY2x1ZGUvbGludXgvZG1hLWJ1Zi5oICAgICAgICAgICAgICAg ICAgICAgICAgIHwgMTcgKysrKysrKysrKysrKysrLS0KPiAgMTMgZmlsZXMgY2hhbmdlZCwgNzYg aW5zZXJ0aW9ucygrKSwgMTggZGVsZXRpb25zKC0pCj4gCj4gZGlmZiAtLWdpdCBhL2RyaXZlcnMv ZG1hLWJ1Zi9kbWEtYnVmLmMgYi9kcml2ZXJzL2RtYS1idWYvZG1hLWJ1Zi5jCj4gaW5kZXggM2Fl NmMwYzJjYzAyLi5lMjk1ZTc2YThjNTcgMTAwNjQ0Cj4gLS0tIGEvZHJpdmVycy9kbWEtYnVmL2Rt YS1idWYuYwo+ICsrKyBiL2RyaXZlcnMvZG1hLWJ1Zi9kbWEtYnVmLmMKPiBAQCAtNTM1LDggKzUz NSw5IEBAIEVYUE9SVF9TWU1CT0xfR1BMKGRtYV9idWZfcHV0KTsKPiAgLyoqCj4gICAqIGRtYV9i dWZfYXR0YWNoIC0gQWRkIHRoZSBkZXZpY2UgdG8gZG1hX2J1ZidzIGF0dGFjaG1lbnRzIGxpc3Q7 IG9wdGlvbmFsbHksCj4gICAqIGNhbGxzIGF0dGFjaCgpIG9mIGRtYV9idWZfb3BzIHRvIGFsbG93 IGRldmljZS1zcGVjaWZpYyBhdHRhY2ggZnVuY3Rpb25hbGl0eQo+IC0gKiBAZG1hYnVmOglbaW5d CWJ1ZmZlciB0byBhdHRhY2ggZGV2aWNlIHRvLgo+IC0gKiBAZGV2OglbaW5dCWRldmljZSB0byBi ZSBhdHRhY2hlZC4KPiArICogQGluZm86CVtpbl0JaG9sZHMgYWxsIHRoZSBhdHRhY2ggcmVsYXRl ZCBpbmZvcm1hdGlvbiBwcm92aWRlZAo+ICsgKgkJCWJ5IHRoZSBpbXBvcnRlci4gc2VlICZzdHJ1 Y3QgZG1hX2J1Zl9hdHRhY2hfaW5mbwo+ICsgKgkJCWZvciBmdXJ0aGVyIGRldGFpbHMuCj4gICAq Cj4gICAqIFJldHVybnMgc3RydWN0IGRtYV9idWZfYXR0YWNobWVudCBwb2ludGVyIGZvciB0aGlz IGF0dGFjaG1lbnQuIEF0dGFjaG1lbnRzCj4gICAqIG11c3QgYmUgY2xlYW5lZCB1cCBieSBjYWxs aW5nIGRtYV9idWZfZGV0YWNoKCkuCj4gQEAgLTU1MCwyMCArNTUxLDIwIEBAIEVYUE9SVF9TWU1C T0xfR1BMKGRtYV9idWZfcHV0KTsKPiAgICogYWNjZXNzaWJsZSB0byBAZGV2LCBhbmQgY2Fubm90 IGJlIG1vdmVkIHRvIGEgbW9yZSBzdWl0YWJsZSBwbGFjZS4gVGhpcyBpcwo+ICAgKiBpbmRpY2F0 ZWQgd2l0aCB0aGUgZXJyb3IgY29kZSAtRUJVU1kuCj4gICAqLwo+IC1zdHJ1Y3QgZG1hX2J1Zl9h dHRhY2htZW50ICpkbWFfYnVmX2F0dGFjaChzdHJ1Y3QgZG1hX2J1ZiAqZG1hYnVmLAo+IC0JCQkJ CSAgc3RydWN0IGRldmljZSAqZGV2KQo+ICtzdHJ1Y3QgZG1hX2J1Zl9hdHRhY2htZW50ICpkbWFf YnVmX2F0dGFjaChjb25zdCBzdHJ1Y3QgZG1hX2J1Zl9hdHRhY2hfaW5mbyAqaW5mbykKPiAgewo+ ICsJc3RydWN0IGRtYV9idWYgKmRtYWJ1ZiA9IGluZm8tPmRtYWJ1ZjsKPiAgCXN0cnVjdCBkbWFf YnVmX2F0dGFjaG1lbnQgKmF0dGFjaDsKPiAgCWludCByZXQ7Cj4gIAo+IC0JaWYgKFdBUk5fT04o IWRtYWJ1ZiB8fCAhZGV2KSkKPiArCWlmIChXQVJOX09OKCFkbWFidWYgfHwgIWluZm8tPmRldikp Cj4gIAkJcmV0dXJuIEVSUl9QVFIoLUVJTlZBTCk7Cj4gIAo+ICAJYXR0YWNoID0ga3phbGxvYyhz aXplb2YoKmF0dGFjaCksIEdGUF9LRVJORUwpOwo+ICAJaWYgKCFhdHRhY2gpCj4gIAkJcmV0dXJu IEVSUl9QVFIoLUVOT01FTSk7Cj4gIAo+IC0JYXR0YWNoLT5kZXYgPSBkZXY7Cj4gKwlhdHRhY2gt PmRldiA9IGluZm8tPmRldjsKPiAgCWF0dGFjaC0+ZG1hYnVmID0gZG1hYnVmOwo+ICAKPiAgCW11 dGV4X2xvY2soJmRtYWJ1Zi0+bG9jayk7Cj4gZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2RybS9h cm1hZGEvYXJtYWRhX2dlbS5jIGIvZHJpdmVycy9ncHUvZHJtL2FybWFkYS9hcm1hZGFfZ2VtLmMK PiBpbmRleCA2NDJkMGU3MGQwZjguLjE5YzQ3ODIxMDMyZiAxMDA2NDQKPiAtLS0gYS9kcml2ZXJz L2dwdS9kcm0vYXJtYWRhL2FybWFkYV9nZW0uYwo+ICsrKyBiL2RyaXZlcnMvZ3B1L2RybS9hcm1h ZGEvYXJtYWRhX2dlbS5jCj4gQEAgLTUwMSw2ICs1MDEsMTAgQEAgYXJtYWRhX2dlbV9wcmltZV9l eHBvcnQoc3RydWN0IGRybV9kZXZpY2UgKmRldiwgc3RydWN0IGRybV9nZW1fb2JqZWN0ICpvYmos Cj4gIHN0cnVjdCBkcm1fZ2VtX29iamVjdCAqCj4gIGFybWFkYV9nZW1fcHJpbWVfaW1wb3J0KHN0 cnVjdCBkcm1fZGV2aWNlICpkZXYsIHN0cnVjdCBkbWFfYnVmICpidWYpCj4gIHsKPiArCXN0cnVj dCBkbWFfYnVmX2F0dGFjaF9pbmZvIGF0dGFjaF9pbmZvID0gewo+ICsJCS5kZXYgPSBkZXYtPmRl diwKPiArCQkuZG1hYnVmID0gYnVmCj4gKwl9Owo+ICAJc3RydWN0IGRtYV9idWZfYXR0YWNobWVu dCAqYXR0YWNoOwo+ICAJc3RydWN0IGFybWFkYV9nZW1fb2JqZWN0ICpkb2JqOwo+ICAKPiBAQCAt NTE2LDcgKzUyMCw3IEBAIGFybWFkYV9nZW1fcHJpbWVfaW1wb3J0KHN0cnVjdCBkcm1fZGV2aWNl ICpkZXYsIHN0cnVjdCBkbWFfYnVmICpidWYpCj4gIAkJfQo+ICAJfQo+ICAKPiAtCWF0dGFjaCA9 IGRtYV9idWZfYXR0YWNoKGJ1ZiwgZGV2LT5kZXYpOwo+ICsJYXR0YWNoID0gZG1hX2J1Zl9hdHRh Y2goJmF0dGFjaF9pbmZvKTsKPiAgCWlmIChJU19FUlIoYXR0YWNoKSkKPiAgCQlyZXR1cm4gRVJS X0NBU1QoYXR0YWNoKTsKPiAgCj4gZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2RybS9kcm1fcHJp bWUuYyBiL2RyaXZlcnMvZ3B1L2RybS9kcm1fcHJpbWUuYwo+IGluZGV4IGRjMDc5ZWZiM2IwZi4u MWRkNzBmYzA5NWVlIDEwMDY0NAo+IC0tLSBhL2RyaXZlcnMvZ3B1L2RybS9kcm1fcHJpbWUuYwo+ ICsrKyBiL2RyaXZlcnMvZ3B1L2RybS9kcm1fcHJpbWUuYwo+IEBAIC03MTAsNiArNzEwLDEwIEBA IHN0cnVjdCBkcm1fZ2VtX29iamVjdCAqZHJtX2dlbV9wcmltZV9pbXBvcnRfZGV2KHN0cnVjdCBk cm1fZGV2aWNlICpkZXYsCj4gIAkJCQkJICAgIHN0cnVjdCBkbWFfYnVmICpkbWFfYnVmLAo+ICAJ CQkJCSAgICBzdHJ1Y3QgZGV2aWNlICphdHRhY2hfZGV2KQo+ICB7Cj4gKwlzdHJ1Y3QgZG1hX2J1 Zl9hdHRhY2hfaW5mbyBhdHRhY2hfaW5mbyA9IHsKPiArCQkuZGV2ID0gYXR0YWNoX2RldiwKPiAr CQkuZG1hYnVmID0gZG1hX2J1Zgo+ICsJfTsKPiAgCXN0cnVjdCBkbWFfYnVmX2F0dGFjaG1lbnQg KmF0dGFjaDsKPiAgCXN0cnVjdCBzZ190YWJsZSAqc2d0Owo+ICAJc3RydWN0IGRybV9nZW1fb2Jq ZWN0ICpvYmo7Cj4gQEAgLTczMCw3ICs3MzQsNyBAQCBzdHJ1Y3QgZHJtX2dlbV9vYmplY3QgKmRy bV9nZW1fcHJpbWVfaW1wb3J0X2RldihzdHJ1Y3QgZHJtX2RldmljZSAqZGV2LAo+ICAJaWYgKCFk ZXYtPmRyaXZlci0+Z2VtX3ByaW1lX2ltcG9ydF9zZ190YWJsZSkKPiAgCQlyZXR1cm4gRVJSX1BU UigtRUlOVkFMKTsKPiAgCj4gLQlhdHRhY2ggPSBkbWFfYnVmX2F0dGFjaChkbWFfYnVmLCBhdHRh Y2hfZGV2KTsKPiArCWF0dGFjaCA9IGRtYV9idWZfYXR0YWNoKCZhdHRhY2hfaW5mbyk7Cj4gIAlp ZiAoSVNfRVJSKGF0dGFjaCkpCj4gIAkJcmV0dXJuIEVSUl9DQVNUKGF0dGFjaCk7Cj4gIAo+IGRp ZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9kcm0vaTkxNS9pOTE1X2dlbV9kbWFidWYuYyBiL2RyaXZl cnMvZ3B1L2RybS9pOTE1L2k5MTVfZ2VtX2RtYWJ1Zi5jCj4gaW5kZXggNWExMDFhOTQ2MmQ4Li45 NzgwNTQxNTdjNjQgMTAwNjQ0Cj4gLS0tIGEvZHJpdmVycy9ncHUvZHJtL2k5MTUvaTkxNV9nZW1f ZG1hYnVmLmMKPiArKysgYi9kcml2ZXJzL2dwdS9kcm0vaTkxNS9pOTE1X2dlbV9kbWFidWYuYwo+ IEBAIC0yNzcsNiArMjc3LDEwIEBAIHN0YXRpYyBjb25zdCBzdHJ1Y3QgZHJtX2k5MTVfZ2VtX29i amVjdF9vcHMgaTkxNV9nZW1fb2JqZWN0X2RtYWJ1Zl9vcHMgPSB7Cj4gIHN0cnVjdCBkcm1fZ2Vt X29iamVjdCAqaTkxNV9nZW1fcHJpbWVfaW1wb3J0KHN0cnVjdCBkcm1fZGV2aWNlICpkZXYsCj4g IAkJCQkJICAgICBzdHJ1Y3QgZG1hX2J1ZiAqZG1hX2J1ZikKPiAgewo+ICsJc3RydWN0IGRtYV9i dWZfYXR0YWNoX2luZm8gYXR0YWNoX2luZm8gPSB7Cj4gKwkJLmRldiA9IGRldi0+ZGV2LAo+ICsJ CS5kbWFidWYgPSBkbWFfYnVmCj4gKwl9Owo+ICAJc3RydWN0IGRtYV9idWZfYXR0YWNobWVudCAq YXR0YWNoOwo+ICAJc3RydWN0IGRybV9pOTE1X2dlbV9vYmplY3QgKm9iajsKPiAgCWludCByZXQ7 Cj4gQEAgLTI5NSw3ICsyOTksNyBAQCBzdHJ1Y3QgZHJtX2dlbV9vYmplY3QgKmk5MTVfZ2VtX3By aW1lX2ltcG9ydChzdHJ1Y3QgZHJtX2RldmljZSAqZGV2LAo+ICAJfQo+ICAKPiAgCS8qIG5lZWQg dG8gYXR0YWNoICovCj4gLQlhdHRhY2ggPSBkbWFfYnVmX2F0dGFjaChkbWFfYnVmLCBkZXYtPmRl dik7Cj4gKwlhdHRhY2ggPSBkbWFfYnVmX2F0dGFjaCgmYXR0YWNoX2luZm8pOwo+ICAJaWYgKElT X0VSUihhdHRhY2gpKQo+ICAJCXJldHVybiBFUlJfQ0FTVChhdHRhY2gpOwo+ICAKPiBkaWZmIC0t Z2l0IGEvZHJpdmVycy9ncHUvZHJtL29tYXBkcm0vb21hcF9nZW1fZG1hYnVmLmMgYi9kcml2ZXJz L2dwdS9kcm0vb21hcGRybS9vbWFwX2dlbV9kbWFidWYuYwo+IGluZGV4IDBmOGI1OTdjY2QxMC4u MzhkMDY1NzRiMjUxIDEwMDY0NAo+IC0tLSBhL2RyaXZlcnMvZ3B1L2RybS9vbWFwZHJtL29tYXBf Z2VtX2RtYWJ1Zi5jCj4gKysrIGIvZHJpdmVycy9ncHUvZHJtL29tYXBkcm0vb21hcF9nZW1fZG1h YnVmLmMKPiBAQCAtMTU2LDYgKzE1NiwxMCBAQCBzdHJ1Y3QgZG1hX2J1ZiAqb21hcF9nZW1fcHJp bWVfZXhwb3J0KHN0cnVjdCBkcm1fZGV2aWNlICpkZXYsCj4gIHN0cnVjdCBkcm1fZ2VtX29iamVj dCAqb21hcF9nZW1fcHJpbWVfaW1wb3J0KHN0cnVjdCBkcm1fZGV2aWNlICpkZXYsCj4gIAkJCQkJ ICAgICBzdHJ1Y3QgZG1hX2J1ZiAqZG1hX2J1ZikKPiAgewo+ICsJc3RydWN0IGRtYV9idWZfYXR0 YWNoX2luZm8gYXR0YWNoX2luZm8gPSB7Cj4gKwkJLmRldiA9IGRldi0+ZGV2LAo+ICsJCS5kbWFi dWYgPSBkbWFfYnVmCj4gKwl9Owo+ICAJc3RydWN0IGRtYV9idWZfYXR0YWNobWVudCAqYXR0YWNo Owo+ICAJc3RydWN0IGRybV9nZW1fb2JqZWN0ICpvYmo7Cj4gIAlzdHJ1Y3Qgc2dfdGFibGUgKnNn dDsKPiBAQCAtMTczLDcgKzE3Nyw3IEBAIHN0cnVjdCBkcm1fZ2VtX29iamVjdCAqb21hcF9nZW1f cHJpbWVfaW1wb3J0KHN0cnVjdCBkcm1fZGV2aWNlICpkZXYsCj4gIAkJfQo+ICAJfQo+ICAKPiAt CWF0dGFjaCA9IGRtYV9idWZfYXR0YWNoKGRtYV9idWYsIGRldi0+ZGV2KTsKPiArCWF0dGFjaCA9 IGRtYV9idWZfYXR0YWNoKCZhdHRhY2hfaW5mbyk7Cj4gIAlpZiAoSVNfRVJSKGF0dGFjaCkpCj4g IAkJcmV0dXJuIEVSUl9DQVNUKGF0dGFjaCk7Cj4gIAo+IGRpZmYgLS1naXQgYS9kcml2ZXJzL2dw dS9kcm0vdGVncmEvZ2VtLmMgYi9kcml2ZXJzL2dwdS9kcm0vdGVncmEvZ2VtLmMKPiBpbmRleCA0 ZjgwMTAwZmY1ZjMuLjhlNmI2Yzg3OWFkZCAxMDA2NDQKPiAtLS0gYS9kcml2ZXJzL2dwdS9kcm0v dGVncmEvZ2VtLmMKPiArKysgYi9kcml2ZXJzL2dwdS9kcm0vdGVncmEvZ2VtLmMKPiBAQCAtMzMy LDYgKzMzMiwxMCBAQCBzdHJ1Y3QgdGVncmFfYm8gKnRlZ3JhX2JvX2NyZWF0ZV93aXRoX2hhbmRs ZShzdHJ1Y3QgZHJtX2ZpbGUgKmZpbGUsCj4gIHN0YXRpYyBzdHJ1Y3QgdGVncmFfYm8gKnRlZ3Jh X2JvX2ltcG9ydChzdHJ1Y3QgZHJtX2RldmljZSAqZHJtLAo+ICAJCQkJCXN0cnVjdCBkbWFfYnVm ICpidWYpCj4gIHsKPiArCXN0cnVjdCBkbWFfYnVmX2F0dGFjaF9pbmZvIGF0dGFjaF9pbmZvID0g ewo+ICsJCS5kZXYgPSBkcm0tPmRldiwKPiArCQkuZG1hYnVmID0gYnVmCj4gKwl9Owo+ICAJc3Ry dWN0IHRlZ3JhX2RybSAqdGVncmEgPSBkcm0tPmRldl9wcml2YXRlOwo+ICAJc3RydWN0IGRtYV9i dWZfYXR0YWNobWVudCAqYXR0YWNoOwo+ICAJc3RydWN0IHRlZ3JhX2JvICpibzsKPiBAQCAtMzQx LDcgKzM0NSw3IEBAIHN0YXRpYyBzdHJ1Y3QgdGVncmFfYm8gKnRlZ3JhX2JvX2ltcG9ydChzdHJ1 Y3QgZHJtX2RldmljZSAqZHJtLAo+ICAJaWYgKElTX0VSUihibykpCj4gIAkJcmV0dXJuIGJvOwo+ ICAKPiAtCWF0dGFjaCA9IGRtYV9idWZfYXR0YWNoKGJ1ZiwgZHJtLT5kZXYpOwo+ICsJYXR0YWNo ID0gZG1hX2J1Zl9hdHRhY2goJmF0dGFjaF9pbmZvKTsKPiAgCWlmIChJU19FUlIoYXR0YWNoKSkg ewo+ICAJCWVyciA9IFBUUl9FUlIoYXR0YWNoKTsKPiAgCQlnb3RvIGZyZWU7Cj4gZGlmZiAtLWdp dCBhL2RyaXZlcnMvZ3B1L2RybS91ZGwvdWRsX2RtYWJ1Zi5jIGIvZHJpdmVycy9ncHUvZHJtL3Vk bC91ZGxfZG1hYnVmLmMKPiBpbmRleCA1NTZmNjI2NjJhYTkuLjg2YjkyOGY5NzQyZiAxMDA2NDQK PiAtLS0gYS9kcml2ZXJzL2dwdS9kcm0vdWRsL3VkbF9kbWFidWYuYwo+ICsrKyBiL2RyaXZlcnMv Z3B1L2RybS91ZGwvdWRsX2RtYWJ1Zi5jCj4gQEAgLTIyNiw2ICsyMjYsMTAgQEAgc3RhdGljIGlu dCB1ZGxfcHJpbWVfY3JlYXRlKHN0cnVjdCBkcm1fZGV2aWNlICpkZXYsCj4gIHN0cnVjdCBkcm1f Z2VtX29iamVjdCAqdWRsX2dlbV9wcmltZV9pbXBvcnQoc3RydWN0IGRybV9kZXZpY2UgKmRldiwK PiAgCQkJCXN0cnVjdCBkbWFfYnVmICpkbWFfYnVmKQo+ICB7Cj4gKwlzdHJ1Y3QgZG1hX2J1Zl9h dHRhY2hfaW5mbyBhdHRhY2hfaW5mbyA9IHsKPiArCQkuZGV2ID0gZGV2LT5kZXYsCj4gKwkJLmRt YWJ1ZiA9IGRtYV9idWYKPiArCX07Cj4gIAlzdHJ1Y3QgZG1hX2J1Zl9hdHRhY2htZW50ICphdHRh Y2g7Cj4gIAlzdHJ1Y3Qgc2dfdGFibGUgKnNnOwo+ICAJc3RydWN0IHVkbF9nZW1fb2JqZWN0ICp1 b2JqOwo+IEBAIC0yMzMsNyArMjM3LDcgQEAgc3RydWN0IGRybV9nZW1fb2JqZWN0ICp1ZGxfZ2Vt X3ByaW1lX2ltcG9ydChzdHJ1Y3QgZHJtX2RldmljZSAqZGV2LAo+ICAKPiAgCS8qIG5lZWQgdG8g YXR0YWNoICovCj4gIAlnZXRfZGV2aWNlKGRldi0+ZGV2KTsKPiAtCWF0dGFjaCA9IGRtYV9idWZf YXR0YWNoKGRtYV9idWYsIGRldi0+ZGV2KTsKPiArCWF0dGFjaCA9IGRtYV9idWZfYXR0YWNoKCZh dHRhY2hfaW5mbyk7Cj4gIAlpZiAoSVNfRVJSKGF0dGFjaCkpIHsKPiAgCQlwdXRfZGV2aWNlKGRl di0+ZGV2KTsKPiAgCQlyZXR1cm4gRVJSX0NBU1QoYXR0YWNoKTsKPiBkaWZmIC0tZ2l0IGEvZHJp dmVycy9tZWRpYS9jb21tb24vdmlkZW9idWYyL3ZpZGVvYnVmMi1kbWEtY29udGlnLmMgYi9kcml2 ZXJzL21lZGlhL2NvbW1vbi92aWRlb2J1ZjIvdmlkZW9idWYyLWRtYS1jb250aWcuYwo+IGluZGV4 IDgyMzg5YWVhZDZlZC4uYjJkODQ0ZDQ1ZWE2IDEwMDY0NAo+IC0tLSBhL2RyaXZlcnMvbWVkaWEv Y29tbW9uL3ZpZGVvYnVmMi92aWRlb2J1ZjItZG1hLWNvbnRpZy5jCj4gKysrIGIvZHJpdmVycy9t ZWRpYS9jb21tb24vdmlkZW9idWYyL3ZpZGVvYnVmMi1kbWEtY29udGlnLmMKPiBAQCAtNjUzLDYg KzY1MywxMCBAQCBzdGF0aWMgdm9pZCB2YjJfZGNfZGV0YWNoX2RtYWJ1Zih2b2lkICptZW1fcHJp dikKPiAgc3RhdGljIHZvaWQgKnZiMl9kY19hdHRhY2hfZG1hYnVmKHN0cnVjdCBkZXZpY2UgKmRl diwgc3RydWN0IGRtYV9idWYgKmRidWYsCj4gIAl1bnNpZ25lZCBsb25nIHNpemUsIGVudW0gZG1h X2RhdGFfZGlyZWN0aW9uIGRtYV9kaXIpCj4gIHsKPiArCXN0cnVjdCBkbWFfYnVmX2F0dGFjaF9p bmZvIGF0dGFjaF9pbmZvID0gewo+ICsJCS5kZXYgPSBkZXYsCj4gKwkJLmRtYWJ1ZiA9IGRidWYK PiArCX07Cj4gIAlzdHJ1Y3QgdmIyX2RjX2J1ZiAqYnVmOwo+ICAJc3RydWN0IGRtYV9idWZfYXR0 YWNobWVudCAqZGJhOwo+ICAKPiBAQCAtNjY4LDcgKzY3Miw3IEBAIHN0YXRpYyB2b2lkICp2YjJf ZGNfYXR0YWNoX2RtYWJ1ZihzdHJ1Y3QgZGV2aWNlICpkZXYsIHN0cnVjdCBkbWFfYnVmICpkYnVm LAo+ICAKPiAgCWJ1Zi0+ZGV2ID0gZGV2Owo+ICAJLyogY3JlYXRlIGF0dGFjaG1lbnQgZm9yIHRo ZSBkbWFidWYgd2l0aCB0aGUgdXNlciBkZXZpY2UgKi8KPiAtCWRiYSA9IGRtYV9idWZfYXR0YWNo KGRidWYsIGJ1Zi0+ZGV2KTsKPiArCWRiYSA9IGRtYV9idWZfYXR0YWNoKCZhdHRhY2hfaW5mbyk7 Cj4gIAlpZiAoSVNfRVJSKGRiYSkpIHsKPiAgCQlwcl9lcnIoImZhaWxlZCB0byBhdHRhY2ggZG1h YnVmXG4iKTsKPiAgCQlrZnJlZShidWYpOwo+IGRpZmYgLS1naXQgYS9kcml2ZXJzL21lZGlhL2Nv bW1vbi92aWRlb2J1ZjIvdmlkZW9idWYyLWRtYS1zZy5jIGIvZHJpdmVycy9tZWRpYS9jb21tb24v dmlkZW9idWYyL3ZpZGVvYnVmMi1kbWEtc2cuYwo+IGluZGV4IDI3MGMzMTYyZmRjYi4uZGRkNWYz NmE4ZWM3IDEwMDY0NAo+IC0tLSBhL2RyaXZlcnMvbWVkaWEvY29tbW9uL3ZpZGVvYnVmMi92aWRl b2J1ZjItZG1hLXNnLmMKPiArKysgYi9kcml2ZXJzL21lZGlhL2NvbW1vbi92aWRlb2J1ZjIvdmlk ZW9idWYyLWRtYS1zZy5jCj4gQEAgLTYwOCw2ICs2MDgsMTAgQEAgc3RhdGljIHZvaWQgdmIyX2Rt YV9zZ19kZXRhY2hfZG1hYnVmKHZvaWQgKm1lbV9wcml2KQo+ICBzdGF0aWMgdm9pZCAqdmIyX2Rt YV9zZ19hdHRhY2hfZG1hYnVmKHN0cnVjdCBkZXZpY2UgKmRldiwgc3RydWN0IGRtYV9idWYgKmRi dWYsCj4gIAl1bnNpZ25lZCBsb25nIHNpemUsIGVudW0gZG1hX2RhdGFfZGlyZWN0aW9uIGRtYV9k aXIpCj4gIHsKPiArCXN0cnVjdCBkbWFfYnVmX2F0dGFjaF9pbmZvIGF0dGFjaF9pbmZvID0gewo+ ICsJCS5kZXYgPSBkZXYsCj4gKwkJLmRtYWJ1ZiA9IGRidWYKPiArCX07Cj4gIAlzdHJ1Y3QgdmIy X2RtYV9zZ19idWYgKmJ1ZjsKPiAgCXN0cnVjdCBkbWFfYnVmX2F0dGFjaG1lbnQgKmRiYTsKPiAg Cj4gQEAgLTYyMyw3ICs2MjcsNyBAQCBzdGF0aWMgdm9pZCAqdmIyX2RtYV9zZ19hdHRhY2hfZG1h YnVmKHN0cnVjdCBkZXZpY2UgKmRldiwgc3RydWN0IGRtYV9idWYgKmRidWYsCj4gIAo+ICAJYnVm LT5kZXYgPSBkZXY7Cj4gIAkvKiBjcmVhdGUgYXR0YWNobWVudCBmb3IgdGhlIGRtYWJ1ZiB3aXRo IHRoZSB1c2VyIGRldmljZSAqLwo+IC0JZGJhID0gZG1hX2J1Zl9hdHRhY2goZGJ1ZiwgYnVmLT5k ZXYpOwo+ICsJZGJhID0gZG1hX2J1Zl9hdHRhY2goJmF0dGFjaF9pbmZvKTsKPiAgCWlmIChJU19F UlIoZGJhKSkgewo+ICAJCXByX2VycigiZmFpbGVkIHRvIGF0dGFjaCBkbWFidWZcbiIpOwo+ICAJ CWtmcmVlKGJ1Zik7Cj4gZGlmZiAtLWdpdCBhL2RyaXZlcnMvbWlzYy9mYXN0cnBjLmMgYi9kcml2 ZXJzL21pc2MvZmFzdHJwYy5jCj4gaW5kZXggMzlmODMyZDI3Mjg4Li45M2QwYWFjMDU3MTUgMTAw NjQ0Cj4gLS0tIGEvZHJpdmVycy9taXNjL2Zhc3RycGMuYwo+ICsrKyBiL2RyaXZlcnMvbWlzYy9m YXN0cnBjLmMKPiBAQCAtNDgyLDYgKzQ4Miw3IEBAIHN0YXRpYyBpbnQgZmFzdHJwY19tYXBfY3Jl YXRlKHN0cnVjdCBmYXN0cnBjX3VzZXIgKmZsLCBpbnQgZmQsCj4gIAkJCSAgICAgIHU2NCBsZW4s IHN0cnVjdCBmYXN0cnBjX21hcCAqKnBwbWFwKQo+ICB7Cj4gIAlzdHJ1Y3QgZmFzdHJwY19zZXNz aW9uX2N0eCAqc2VzcyA9IGZsLT5zY3R4Owo+ICsJc3RydWN0IGRtYV9idWZfYXR0YWNoX2luZm8g YXR0YWNoX2luZm87Cj4gIAlzdHJ1Y3QgZmFzdHJwY19tYXAgKm1hcCA9IE5VTEw7Cj4gIAlpbnQg ZXJyID0gMDsKPiAgCj4gQEAgLTUwMSw3ICs1MDIsMTAgQEAgc3RhdGljIGludCBmYXN0cnBjX21h cF9jcmVhdGUoc3RydWN0IGZhc3RycGNfdXNlciAqZmwsIGludCBmZCwKPiAgCQlnb3RvIGdldF9l cnI7Cj4gIAl9Cj4gIAo+IC0JbWFwLT5hdHRhY2ggPSBkbWFfYnVmX2F0dGFjaChtYXAtPmJ1Ziwg c2Vzcy0+ZGV2KTsKPiArCW1lbXNldCgmYXR0YWNoX2luZm8sIDAsIHNpemVvZihhdHRhY2hfaW5m bykpOwo+ICsJYXR0YWNoX2luZm8uZGV2ID0gc2Vzcy0+ZGV2Owo+ICsJYXR0YWNoX2luZm8uZG1h YnVmID0gbWFwLT5idWY7Cj4gKwltYXAtPmF0dGFjaCA9IGRtYV9idWZfYXR0YWNoKCZhdHRhY2hf aW5mbyk7Cj4gIAlpZiAoSVNfRVJSKG1hcC0+YXR0YWNoKSkgewo+ICAJCWRldl9lcnIoc2Vzcy0+ ZGV2LCAiRmFpbGVkIHRvIGF0dGFjaCBkbWFidWZcbiIpOwo+ICAJCWVyciA9IFBUUl9FUlIobWFw LT5hdHRhY2gpOwo+IGRpZmYgLS1naXQgYS9kcml2ZXJzL3N0YWdpbmcvbWVkaWEvdGVncmEtdmRl L3RlZ3JhLXZkZS5jIGIvZHJpdmVycy9zdGFnaW5nL21lZGlhL3RlZ3JhLXZkZS90ZWdyYS12ZGUu Ywo+IGluZGV4IGFhNmM2YmJhOTYxZS4uNWExMGMxZmFjYzI3IDEwMDY0NAo+IC0tLSBhL2RyaXZl cnMvc3RhZ2luZy9tZWRpYS90ZWdyYS12ZGUvdGVncmEtdmRlLmMKPiArKysgYi9kcml2ZXJzL3N0 YWdpbmcvbWVkaWEvdGVncmEtdmRlL3RlZ3JhLXZkZS5jCj4gQEAgLTU2OCw2ICs1NjgsMTAgQEAg c3RhdGljIGludCB0ZWdyYV92ZGVfYXR0YWNoX2RtYWJ1ZihzdHJ1Y3QgZGV2aWNlICpkZXYsCj4g IAkJCQkgICBzaXplX3QgKnNpemUsCj4gIAkJCQkgICBlbnVtIGRtYV9kYXRhX2RpcmVjdGlvbiBk bWFfZGlyKQo+ICB7Cj4gKwlzdHJ1Y3QgZG1hX2J1Zl9hdHRhY2hfaW5mbyBhdHRhY2hfaW5mbyA9 IHsKPiArCQkuZGV2ID0gZGV2LAo+ICsJCS5kbWFidWYgPSBkbWFidWYKPiArCX07Cj4gIAlzdHJ1 Y3QgZG1hX2J1Zl9hdHRhY2htZW50ICphdHRhY2htZW50Owo+ICAJc3RydWN0IGRtYV9idWYgKmRt YWJ1ZjsKPiAgCXN0cnVjdCBzZ190YWJsZSAqc2d0Owo+IEBAIC01OTEsNyArNTk1LDcgQEAgc3Rh dGljIGludCB0ZWdyYV92ZGVfYXR0YWNoX2RtYWJ1ZihzdHJ1Y3QgZGV2aWNlICpkZXYsCj4gIAkJ cmV0dXJuIC1FSU5WQUw7Cj4gIAl9Cj4gIAo+IC0JYXR0YWNobWVudCA9IGRtYV9idWZfYXR0YWNo KGRtYWJ1ZiwgZGV2KTsKPiArCWF0dGFjaG1lbnQgPSBkbWFfYnVmX2F0dGFjaCgmYXR0YWNoX2lu Zm8pOwo+ICAJaWYgKElTX0VSUihhdHRhY2htZW50KSkgewo+ICAJCWRldl9lcnIoZGV2LCAiRmFp bGVkIHRvIGF0dGFjaCBkbWFidWZcbiIpOwo+ICAJCWVyciA9IFBUUl9FUlIoYXR0YWNobWVudCk7 Cj4gZGlmZiAtLWdpdCBhL2RyaXZlcnMveGVuL2dudGRldi1kbWFidWYuYyBiL2RyaXZlcnMveGVu L2dudGRldi1kbWFidWYuYwo+IGluZGV4IDJjNGYzMjRmODYyNi4uY2FjY2E4MzBiNDgyIDEwMDY0 NAo+IC0tLSBhL2RyaXZlcnMveGVuL2dudGRldi1kbWFidWYuYwo+ICsrKyBiL2RyaXZlcnMveGVu L2dudGRldi1kbWFidWYuYwo+IEBAIC02MDgsNiArNjA4LDcgQEAgZG1hYnVmX2ltcF90b19yZWZz KHN0cnVjdCBnbnRkZXZfZG1hYnVmX3ByaXYgKnByaXYsIHN0cnVjdCBkZXZpY2UgKmRldiwKPiAg CQkgICBpbnQgZmQsIGludCBjb3VudCwgaW50IGRvbWlkKQo+ICB7Cj4gIAlzdHJ1Y3QgZ250ZGV2 X2RtYWJ1ZiAqZ250ZGV2X2RtYWJ1ZiwgKnJldDsKPiArCXN0cnVjdCBkbWFfYnVmX2F0dGFjaF9p bmZvIGF0dGFjaF9pbmZvOwo+ICAJc3RydWN0IGRtYV9idWYgKmRtYV9idWY7Cj4gIAlzdHJ1Y3Qg ZG1hX2J1Zl9hdHRhY2htZW50ICphdHRhY2g7Cj4gIAlzdHJ1Y3Qgc2dfdGFibGUgKnNndDsKPiBA QCAtNjI3LDYgKzYyOCw5IEBAIGRtYWJ1Zl9pbXBfdG9fcmVmcyhzdHJ1Y3QgZ250ZGV2X2RtYWJ1 Zl9wcml2ICpwcml2LCBzdHJ1Y3QgZGV2aWNlICpkZXYsCj4gIAlnbnRkZXZfZG1hYnVmLT5wcml2 ID0gcHJpdjsKPiAgCWdudGRldl9kbWFidWYtPmZkID0gZmQ7Cj4gIAo+ICsJbWVtc2V0KCZhdHRh Y2hfaW5mbywgMCwgc2l6ZW9mKGF0dGFjaF9pbmZvKSk7Cj4gKwlhdHRhY2hfaW5mby5kZXYgPSBk ZXY7Cj4gKwlhdHRhY2hfaW5mby5kbWFidWYgPSBkbWFfYnVmOwo+ICAJYXR0YWNoID0gZG1hX2J1 Zl9hdHRhY2goZG1hX2J1ZiwgZGV2KTsKPiAgCWlmIChJU19FUlIoYXR0YWNoKSkgewo+ICAJCXJl dCA9IEVSUl9DQVNUKGF0dGFjaCk7Cj4gZGlmZiAtLWdpdCBhL2luY2x1ZGUvbGludXgvZG1hLWJ1 Zi5oIGIvaW5jbHVkZS9saW51eC9kbWEtYnVmLmgKPiBpbmRleCBhMGJkMDcxNDY2ZmMuLmI1YjBm NWUzZjE4NiAxMDA2NDQKPiAtLS0gYS9pbmNsdWRlL2xpbnV4L2RtYS1idWYuaAo+ICsrKyBiL2lu Y2x1ZGUvbGludXgvZG1hLWJ1Zi5oCj4gQEAgLTM3NSw2ICszNzUsMTkgQEAgc3RydWN0IGRtYV9i dWZfZXhwb3J0X2luZm8gewo+ICAJc3RydWN0IGRtYV9idWZfZXhwb3J0X2luZm8gbmFtZSA9IHsg LmV4cF9uYW1lID0gS0JVSUxEX01PRE5BTUUsIFwKPiAgCQkJCQkgLm93bmVyID0gVEhJU19NT0RV TEUgfQo+ICAKPiArLyoqCj4gKyAqIHN0cnVjdCBkbWFfYnVmX2F0dGFjaF9pbmZvIC0gaG9sZHMg aW5mb3JtYXRpb24gbmVlZGVkIHRvIGF0dGFjaCB0byBhIGRtYV9idWYKPiArICogQGRtYWJ1ZjoJ dGhlIGV4cG9ydGVkIGRtYV9idWYKPiArICogQGRldjoJdGhlIGRldmljZSB3aGljaCB3YW50cyB0 byBpbXBvcnQgdGhlIGF0dGFjaG1lbnQKPiArICoKPiArICogVGhpcyBzdHJ1Y3R1cmUgaG9sZHMg dGhlIGluZm9ybWF0aW9uIHJlcXVpcmVkIHRvIGF0dGFjaCB0byBhIGJ1ZmZlci4gVXNlZAo+ICsg KiB3aXRoIGRtYV9idWZfYXR0YWNoKCkgb25seS4KPiArICovCj4gK3N0cnVjdCBkbWFfYnVmX2F0 dGFjaF9pbmZvIHsKPiArCXN0cnVjdCBkbWFfYnVmICpkbWFidWY7Cj4gKwlzdHJ1Y3QgZGV2aWNl ICpkZXY7Cj4gK307Cj4gKwo+ICAvKioKPiAgICogZ2V0X2RtYV9idWYgLSBjb252ZW5pZW5jZSB3 cmFwcGVyIGZvciBnZXRfZmlsZS4KPiAgICogQGRtYWJ1ZjoJW2luXQlwb2ludGVyIHRvIGRtYV9i dWYKPiBAQCAtMzg5LDggKzQwMiw4IEBAIHN0YXRpYyBpbmxpbmUgdm9pZCBnZXRfZG1hX2J1Zihz dHJ1Y3QgZG1hX2J1ZiAqZG1hYnVmKQo+ICAJZ2V0X2ZpbGUoZG1hYnVmLT5maWxlKTsKPiAgfQo+ ICAKPiAtc3RydWN0IGRtYV9idWZfYXR0YWNobWVudCAqZG1hX2J1Zl9hdHRhY2goc3RydWN0IGRt YV9idWYgKmRtYWJ1ZiwKPiAtCQkJCQkJCXN0cnVjdCBkZXZpY2UgKmRldik7Cj4gK3N0cnVjdCBk bWFfYnVmX2F0dGFjaG1lbnQgKgo+ICtkbWFfYnVmX2F0dGFjaChjb25zdCBzdHJ1Y3QgZG1hX2J1 Zl9hdHRhY2hfaW5mbyAqaW5mbyk7Cj4gIHZvaWQgZG1hX2J1Zl9kZXRhY2goc3RydWN0IGRtYV9i dWYgKmRtYWJ1ZiwKPiAgCQkJCXN0cnVjdCBkbWFfYnVmX2F0dGFjaG1lbnQgKmRtYWJ1Zl9hdHRh Y2gpOwo+ICAKPiAtLSAKPiAyLjE3LjEKPiAKPiAKCi0tIApSTUsncyBQYXRjaCBzeXN0ZW06IGh0 dHBzOi8vd3d3LmFybWxpbnV4Lm9yZy51ay9kZXZlbG9wZXIvcGF0Y2hlcy8KRlRUQyBicm9hZGJh bmQgZm9yIDAuOG1pbGUgbGluZSBpbiBzdWJ1cmJpYTogc3luYyBhdCAxMi4xTWJwcyBkb3duIDYy MmticHMgdXAKQWNjb3JkaW5nIHRvIHNwZWVkdGVzdC5uZXQ6IDExLjlNYnBzIGRvd24gNTAwa2Jw cyB1cAoKX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX18KWGVu LWRldmVsIG1haWxpbmcgbGlzdApYZW4tZGV2ZWxAbGlzdHMueGVucHJvamVjdC5vcmcKaHR0cHM6 Ly9saXN0cy54ZW5wcm9qZWN0Lm9yZy9tYWlsbWFuL2xpc3RpbmZvL3hlbi1kZXZlbA==