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=-13.6 required=3.0 tests=BAYES_00,DKIM_INVALID, DKIM_SIGNED,HEADER_FROM_DIFFERENT_DOMAINS,INCLUDES_CR_TRAILER,INCLUDES_PATCH, MAILING_LIST_MULTI,SPF_HELO_NONE,SPF_PASS 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 E6722C4743C for ; Wed, 23 Jun 2021 09:45:42 +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 2E2B560FD8 for ; Wed, 23 Jun 2021 09:45:42 +0000 (UTC) DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org 2E2B560FD8 Authentication-Results: mail.kernel.org; dmarc=none (p=none dis=none) header.from=basnieuwenhuizen.nl 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 72B166E89F; Wed, 23 Jun 2021 09:45:41 +0000 (UTC) Received: from mail-io1-xd2b.google.com (mail-io1-xd2b.google.com [IPv6:2607:f8b0:4864:20::d2b]) by gabe.freedesktop.org (Postfix) with ESMTPS id 448CF6E896 for ; Wed, 23 Jun 2021 09:45:40 +0000 (UTC) Received: by mail-io1-xd2b.google.com with SMTP id s19so2556756ioc.3 for ; Wed, 23 Jun 2021 02:45:40 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=basnieuwenhuizen.nl; s=google; h=mime-version:references:in-reply-to:from:date:message-id:subject:to :cc:content-transfer-encoding; bh=8gz89K+x320TzMzMlB3+TLV3c93YiJCgn8umvlOMJ7I=; b=UARL5J9lCxepYR+GpbiT8J1lwnotarNRcwqOzmlkdPdATr4Ft7irVcJYUbtEQkx1LO zxsxY6Zm0Z5RD2A17BLP71onkMoKvAoZEjSAtOpjeD75+vttZHD1VJWAnzOHw4T15X0x se2ZaGrozmEjIH++gDlMWdONx/tsFCKOCbcDTAPE8aSaZfPOugpvZLJ+rST5e62BCMif teGq/8tlyxXnvZzR0MqA4Hjw/P7DxnEB4xiJsJp4zLYQuR7GGop1zJMsQN/kgU7lSvWF LJY6PoHplEjH3uVXi5PtNJkjEEUcSs9YK4ycNb1UhR7r30hNPy2AYpWfaIJkaJb1L+6D +/OA== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:mime-version:references:in-reply-to:from:date :message-id:subject:to:cc:content-transfer-encoding; bh=8gz89K+x320TzMzMlB3+TLV3c93YiJCgn8umvlOMJ7I=; b=aC5Z6abKdbQMu94fQJdjjDbAEyzgvD6JE7Fu7L2kvTZrbH3E5heSk0b04FS1m9NfqH 081MuiGtAG82jmvK08CybYHvHAYgXpRWQuAMwhrSoUJQkjUpD2tb+WJfD1PMO3Y+DKcZ 9BjU6TCoa0BTeh7mhTRgKAjSa7pKyx5FpG9VNrUIs9vWHnM4x3x/UCK+3sNCyulZDGvc jzJaAKfZJsu8cxE8LlAjmQc+UPSc6nJKW+2vz+CzeIMsBIoAgL3HtwEesI+gAcTof/Ae GF98UjIiY4c4GyYj5roANFdrbdM7SYLjSJTpLpInBuXZ7kx88yXqZCcHGoAOREg132R9 x4pg== X-Gm-Message-State: AOAM533Mw99PpVpxXdUqdoTSdeYqJs1sJFleLMeCnPgztyvoUmHksWW7 YjYb6rvE5/6xcFWiV848L32ueTBwJTAH+2ITK9lyKQ== X-Google-Smtp-Source: ABdhPJz0Qdv8wrZCQKMjrVivv7XKFWpj7oILU6UBEyVuV5CbKdEvy4Ib4hW+cuG2n1jxs4HjTMU5IoMdoKRWpSJ1e3s= X-Received: by 2002:a02:ca4a:: with SMTP id i10mr8071337jal.141.1624441539001; Wed, 23 Jun 2021 02:45:39 -0700 (PDT) MIME-Version: 1.0 References: <20210622165511.3169559-1-daniel.vetter@ffwll.ch> <20210622165511.3169559-16-daniel.vetter@ffwll.ch> In-Reply-To: <20210622165511.3169559-16-daniel.vetter@ffwll.ch> From: Bas Nieuwenhuizen Date: Wed, 23 Jun 2021 11:45:33 +0200 Message-ID: Subject: Re: [PATCH 15/15] RFC: drm/amdgpu: Implement a proper implicit fencing uapi To: Daniel Vetter Content-Type: text/plain; charset="UTF-8" Content-Transfer-Encoding: quoted-printable X-BeenThere: dri-devel@lists.freedesktop.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: Direct Rendering Infrastructure - Development List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Cc: Rob Clark , Daniel Stone , =?UTF-8?Q?Christian_K=C3=B6nig?= , Intel Graphics Development , Kevin Wang , DRI Development , "moderated list:DMA BUFFER SHARING FRAMEWORK" , Luben Tuikov , "Kristian H . Kristensen" , Chen Li , Daniel Vetter , Alex Deucher , mesa-dev , =?UTF-8?Q?Michel_D=C3=A4nzer?= , Dennis Li , Deepak R Varma Errors-To: dri-devel-bounces@lists.freedesktop.org Sender: "dri-devel" On Tue, Jun 22, 2021 at 6:55 PM Daniel Vetter wrot= e: > > WARNING: Absolutely untested beyond "gcc isn't dying in agony". > > Implicit fencing done properly needs to treat the implicit fencing > slots like a funny kind of IPC mailbox. In other words it needs to be > explicitly. This is the only way it will mesh well with explicit > fencing userspace like vk, and it's also the bare minimum required to > be able to manage anything else that wants to use the same buffer on > multiple engines in parallel, and still be able to share it through > implicit sync. > > amdgpu completely lacks such an uapi. Fix this. > > Luckily the concept of ignoring implicit fences exists already, and > takes care of all the complexities of making sure that non-optional > fences (like bo moves) are not ignored. This support was added in > > commit 177ae09b5d699a5ebd1cafcee78889db968abf54 > Author: Andres Rodriguez > Date: Fri Sep 15 20:44:06 2017 -0400 > > drm/amdgpu: introduce AMDGPU_GEM_CREATE_EXPLICIT_SYNC v2 > > Unfortuantely it's the wrong semantics, because it's a bo flag and > disables implicit sync on an allocated buffer completely. > > We _do_ want implicit sync, but control it explicitly. For this we > need a flag on the drm_file, so that a given userspace (like vulkan) > can manage the implicit sync slots explicitly. The other side of the > pipeline (compositor, other process or just different stage in a media > pipeline in the same process) can then either do the same, or fully > participate in the implicit sync as implemented by the kernel by > default. > > By building on the existing flag for buffers we avoid any issues with > opening up additional security concerns - anything this new flag here > allows is already. > > All drivers which supports this concept of a userspace-specific > opt-out of implicit sync have a flag in their CS ioctl, but in reality > that turned out to be a bit too inflexible. See the discussion below, > let's try to do a bit better for amdgpu. > > This alone only allows us to completely avoid any stalls due to > implicit sync, it does not yet allow us to use implicit sync as a > strange form of IPC for sync_file. > > For that we need two more pieces: > > - a way to get the current implicit sync fences out of a buffer. Could > be done in a driver ioctl, but everyone needs this, and generally a > dma-buf is involved anyway to establish the sharing. So an ioctl on > the dma-buf makes a ton more sense: > > https://lore.kernel.org/dri-devel/20210520190007.534046-4-jason@jlekstr= and.net/ > > Current drivers in upstream solves this by having the opt-out flag > on their CS ioctl. This has the downside that very often the CS > which must actually stall for the implicit fence is run a while > after the implicit fence point was logically sampled per the api > spec (vk passes an explicit syncobj around for that afaiui), and so > results in oversync. Converting the implicit sync fences into a > snap-shot sync_file is actually accurate. > > - Simillar we need to be able to set the exclusive implicit fence. > Current drivers again do this with a CS ioctl flag, with again the > same problems that the time the CS happens additional dependencies > have been added. An explicit ioctl to only insert a sync_file (while > respecting the rules for how exclusive and shared fence slots must > be update in struct dma_resv) is much better. This is proposed here: > > https://lore.kernel.org/dri-devel/20210520190007.534046-5-jason@jlekstr= and.net/ > > These three pieces together allow userspace to fully control implicit > fencing and remove all unecessary stall points due to them. > > Well, as much as the implicit fencing model fundamentally allows: > There is only one set of fences, you can only choose to sync against > only writers (exclusive slot), or everyone. Hence suballocating > multiple buffers or anything else like this is fundamentally not > possible, and can only be fixed by a proper explicit fencing model. > > Aside from that caveat this model gets implicit fencing as closely to > explicit fencing semantics as possible: > > On the actual implementation I opted for a simple setparam ioctl, no > locking (just atomic reads/writes) for simplicity. There is a nice > flag parameter in the VM ioctl which we could use, except: > - it's not checked, so userspace likely passes garbage > - there's already a comment that userspace _does_ pass garbage in the > priority field > So yeah unfortunately this flag parameter for setting vm flags is > useless, and we need to hack up a new one. > > v2: Explain why a new SETPARAM (Jason) > > v3: Bas noticed I forgot to hook up the dependency-side shortcut. We > need both, or this doesn't do much. > > v4: Rebase over the amdgpu patch to always set the implicit sync > fences. So I think there is still a case missing in this implementation. Consider these 3 cases (format: a->b: b waits on a. Yes, I know arrows are hard) explicit->explicit: This doesn't wait now, which is good Implicit->explicit: This doesn't wait now, which is good explicit->implicit : This still waits as the explicit submission still adds shared fences and most things that set an exclusive fence for implicit sync will hence wait on it. This is probably good enough for what radv needs now but also sounds like a risk wrt baking in new uapi behavior that we don't want to be the end result. Within AMDGPU this is probably solvable in two ways: 1) Downgrade AMDGPU_SYNC_NE_OWNER to AMDGPU_SYNC_EXPLICIT for shared fences= . 2) Have an EXPLICIT fence owner that is used for explicit submissions that is ignored by AMDGPU_SYNC_NE_OWNER. But this doesn't solve cross-driver interactions here. > > Cc: mesa-dev@lists.freedesktop.org > Cc: Bas Nieuwenhuizen > Cc: Dave Airlie > Cc: Rob Clark > Cc: Kristian H. Kristensen > Cc: Michel D=C3=A4nzer > Cc: Daniel Stone > Cc: Sumit Semwal > Cc: "Christian K=C3=B6nig" > Cc: Alex Deucher > Cc: Daniel Vetter > Cc: Deepak R Varma > Cc: Chen Li > Cc: Kevin Wang > Cc: Dennis Li > Cc: Luben Tuikov > Cc: linaro-mm-sig@lists.linaro.org > Signed-off-by: Daniel Vetter > --- > drivers/gpu/drm/amd/amdgpu/amdgpu_cs.c | 7 +++++-- > drivers/gpu/drm/amd/amdgpu/amdgpu_drv.c | 21 +++++++++++++++++++++ > drivers/gpu/drm/amd/amdgpu/amdgpu_vm.h | 6 ++++++ > include/uapi/drm/amdgpu_drm.h | 10 ++++++++++ > 4 files changed, 42 insertions(+), 2 deletions(-) > > diff --git a/drivers/gpu/drm/amd/amdgpu/amdgpu_cs.c b/drivers/gpu/drm/amd= /amdgpu/amdgpu_cs.c > index 65df34c17264..c5386d13eb4a 100644 > --- a/drivers/gpu/drm/amd/amdgpu/amdgpu_cs.c > +++ b/drivers/gpu/drm/amd/amdgpu/amdgpu_cs.c > @@ -498,6 +498,7 @@ static int amdgpu_cs_parser_bos(struct amdgpu_cs_pars= er *p, > struct amdgpu_bo *gds; > struct amdgpu_bo *gws; > struct amdgpu_bo *oa; > + bool no_implicit_sync =3D READ_ONCE(fpriv->vm.no_implicit_sync); > int r; > > INIT_LIST_HEAD(&p->validated); > @@ -577,7 +578,8 @@ static int amdgpu_cs_parser_bos(struct amdgpu_cs_pars= er *p, > > e->bo_va =3D amdgpu_vm_bo_find(vm, bo); > > - if (bo->tbo.base.dma_buf && !amdgpu_bo_explicit_sync(bo))= { > + if (bo->tbo.base.dma_buf && > + !(no_implicit_sync || amdgpu_bo_explicit_sync(bo))) { > e->chain =3D dma_fence_chain_alloc(); > if (!e->chain) { > r =3D -ENOMEM; > @@ -649,6 +651,7 @@ static int amdgpu_cs_sync_rings(struct amdgpu_cs_pars= er *p) > { > struct amdgpu_fpriv *fpriv =3D p->filp->driver_priv; > struct amdgpu_bo_list_entry *e; > + bool no_implicit_sync =3D READ_ONCE(fpriv->vm.no_implicit_sync); > int r; > > list_for_each_entry(e, &p->validated, tv.head) { > @@ -656,7 +659,7 @@ static int amdgpu_cs_sync_rings(struct amdgpu_cs_pars= er *p) > struct dma_resv *resv =3D bo->tbo.base.resv; > enum amdgpu_sync_mode sync_mode; > > - sync_mode =3D amdgpu_bo_explicit_sync(bo) ? > + sync_mode =3D no_implicit_sync || amdgpu_bo_explicit_sync= (bo) ? > AMDGPU_SYNC_EXPLICIT : AMDGPU_SYNC_NE_OWNER; > r =3D amdgpu_sync_resv(p->adev, &p->job->sync, resv, sync= _mode, > &fpriv->vm); > diff --git a/drivers/gpu/drm/amd/amdgpu/amdgpu_drv.c b/drivers/gpu/drm/am= d/amdgpu/amdgpu_drv.c > index c080ba15ae77..f982626b5328 100644 > --- a/drivers/gpu/drm/amd/amdgpu/amdgpu_drv.c > +++ b/drivers/gpu/drm/amd/amdgpu/amdgpu_drv.c > @@ -1724,6 +1724,26 @@ int amdgpu_file_to_fpriv(struct file *filp, struct= amdgpu_fpriv **fpriv) > return 0; > } > > +int amdgpu_setparam_ioctl(struct drm_device *dev, void *data, > + struct drm_file *filp) > +{ > + struct drm_amdgpu_setparam *setparam =3D data; > + struct amdgpu_fpriv *fpriv =3D filp->driver_priv; > + > + switch (setparam->param) { > + case AMDGPU_SETPARAM_NO_IMPLICIT_SYNC: > + if (setparam->value) > + WRITE_ONCE(fpriv->vm.no_implicit_sync, true); > + else > + WRITE_ONCE(fpriv->vm.no_implicit_sync, false); > + break; > + default: > + return -EINVAL; > + } > + > + return 0; > +} > + > const struct drm_ioctl_desc amdgpu_ioctls_kms[] =3D { > DRM_IOCTL_DEF_DRV(AMDGPU_GEM_CREATE, amdgpu_gem_create_ioctl, DRM= _AUTH|DRM_RENDER_ALLOW), > DRM_IOCTL_DEF_DRV(AMDGPU_CTX, amdgpu_ctx_ioctl, DRM_AUTH|DRM_REND= ER_ALLOW), > @@ -1742,6 +1762,7 @@ const struct drm_ioctl_desc amdgpu_ioctls_kms[] =3D= { > DRM_IOCTL_DEF_DRV(AMDGPU_GEM_VA, amdgpu_gem_va_ioctl, DRM_AUTH|DR= M_RENDER_ALLOW), > DRM_IOCTL_DEF_DRV(AMDGPU_GEM_OP, amdgpu_gem_op_ioctl, DRM_AUTH|DR= M_RENDER_ALLOW), > DRM_IOCTL_DEF_DRV(AMDGPU_GEM_USERPTR, amdgpu_gem_userptr_ioctl, D= RM_AUTH|DRM_RENDER_ALLOW), > + DRM_IOCTL_DEF_DRV(AMDGPU_SETPARAM, amdgpu_setparam_ioctl, DRM_AUT= H|DRM_RENDER_ALLOW), > }; > > static const struct drm_driver amdgpu_kms_driver =3D { > diff --git a/drivers/gpu/drm/amd/amdgpu/amdgpu_vm.h b/drivers/gpu/drm/amd= /amdgpu/amdgpu_vm.h > index ddb85a85cbba..0e8c440c6303 100644 > --- a/drivers/gpu/drm/amd/amdgpu/amdgpu_vm.h > +++ b/drivers/gpu/drm/amd/amdgpu/amdgpu_vm.h > @@ -321,6 +321,12 @@ struct amdgpu_vm { > bool bulk_moveable; > /* Flag to indicate if VM is used for compute */ > bool is_compute_context; > + /* > + * Flag to indicate whether implicit sync should always be skippe= d on > + * this context. We do not care about races at all, userspace is = allowed > + * to shoot itself with implicit sync to its fullest liking. > + */ > + bool no_implicit_sync; > }; > > struct amdgpu_vm_manager { > diff --git a/include/uapi/drm/amdgpu_drm.h b/include/uapi/drm/amdgpu_drm.= h > index 0cbd1540aeac..9eae245c14d6 100644 > --- a/include/uapi/drm/amdgpu_drm.h > +++ b/include/uapi/drm/amdgpu_drm.h > @@ -54,6 +54,7 @@ extern "C" { > #define DRM_AMDGPU_VM 0x13 > #define DRM_AMDGPU_FENCE_TO_HANDLE 0x14 > #define DRM_AMDGPU_SCHED 0x15 > +#define DRM_AMDGPU_SETPARAM 0x16 > > #define DRM_IOCTL_AMDGPU_GEM_CREATE DRM_IOWR(DRM_COMMAND_BASE + DRM_A= MDGPU_GEM_CREATE, union drm_amdgpu_gem_create) > #define DRM_IOCTL_AMDGPU_GEM_MMAP DRM_IOWR(DRM_COMMAND_BASE + DRM_A= MDGPU_GEM_MMAP, union drm_amdgpu_gem_mmap) > @@ -71,6 +72,7 @@ extern "C" { > #define DRM_IOCTL_AMDGPU_VM DRM_IOWR(DRM_COMMAND_BASE + DRM_A= MDGPU_VM, union drm_amdgpu_vm) > #define DRM_IOCTL_AMDGPU_FENCE_TO_HANDLE DRM_IOWR(DRM_COMMAND_BASE + DRM= _AMDGPU_FENCE_TO_HANDLE, union drm_amdgpu_fence_to_handle) > #define DRM_IOCTL_AMDGPU_SCHED DRM_IOW(DRM_COMMAND_BASE + DRM_AM= DGPU_SCHED, union drm_amdgpu_sched) > +#define DRM_IOCTL_AMDGPU_SETPARAM DRM_IOW(DRM_COMMAND_BASE + DRM_AM= DGPU_SETPARAM, struct drm_amdgpu_setparam) > > /** > * DOC: memory domains > @@ -306,6 +308,14 @@ union drm_amdgpu_sched { > struct drm_amdgpu_sched_in in; > }; > > +#define AMDGPU_SETPARAM_NO_IMPLICIT_SYNC 1 > + > +struct drm_amdgpu_setparam { > + /* AMDGPU_SETPARAM_* */ > + __u32 param; > + __u32 value; > +}; > + > /* > * This is not a reliable API and you should expect it to fail for any > * number of reasons and have fallback path that do not use userptr to > -- > 2.32.0.rc2 > 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=-13.6 required=3.0 tests=BAYES_00,DKIM_INVALID, DKIM_SIGNED,HEADER_FROM_DIFFERENT_DOMAINS,INCLUDES_CR_TRAILER,INCLUDES_PATCH, MAILING_LIST_MULTI,SPF_HELO_NONE,SPF_PASS 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 ECFA8C48BE5 for ; Wed, 23 Jun 2021 09:45:45 +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 7F5C860725 for ; Wed, 23 Jun 2021 09:45:45 +0000 (UTC) DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org 7F5C860725 Authentication-Results: mail.kernel.org; dmarc=none (p=none dis=none) header.from=basnieuwenhuizen.nl 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 70C116E89D; Wed, 23 Jun 2021 09:45:41 +0000 (UTC) Received: from mail-io1-xd33.google.com (mail-io1-xd33.google.com [IPv6:2607:f8b0:4864:20::d33]) by gabe.freedesktop.org (Postfix) with ESMTPS id 4531B6E897 for ; Wed, 23 Jun 2021 09:45:40 +0000 (UTC) Received: by mail-io1-xd33.google.com with SMTP id v3so2525237ioq.9 for ; Wed, 23 Jun 2021 02:45:40 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=basnieuwenhuizen.nl; s=google; h=mime-version:references:in-reply-to:from:date:message-id:subject:to :cc:content-transfer-encoding; bh=8gz89K+x320TzMzMlB3+TLV3c93YiJCgn8umvlOMJ7I=; b=UARL5J9lCxepYR+GpbiT8J1lwnotarNRcwqOzmlkdPdATr4Ft7irVcJYUbtEQkx1LO zxsxY6Zm0Z5RD2A17BLP71onkMoKvAoZEjSAtOpjeD75+vttZHD1VJWAnzOHw4T15X0x se2ZaGrozmEjIH++gDlMWdONx/tsFCKOCbcDTAPE8aSaZfPOugpvZLJ+rST5e62BCMif teGq/8tlyxXnvZzR0MqA4Hjw/P7DxnEB4xiJsJp4zLYQuR7GGop1zJMsQN/kgU7lSvWF LJY6PoHplEjH3uVXi5PtNJkjEEUcSs9YK4ycNb1UhR7r30hNPy2AYpWfaIJkaJb1L+6D +/OA== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:mime-version:references:in-reply-to:from:date :message-id:subject:to:cc:content-transfer-encoding; bh=8gz89K+x320TzMzMlB3+TLV3c93YiJCgn8umvlOMJ7I=; b=Y3LDAFGdPCw5jq9serOkQfLxaaJSZXmpFIfQ+WcIjFRSn+XMg/Tf+hrH+mHjmYJxeG JzBMz815U7OTxAbmmnmfKjon/7G3ouzCGMA6CHROEkXBhNQoSx6bbNkn/rwH1iwJCOE9 zX/8PC1q6U+p4OhiC8db7TBw4q35yPYc6u3gNuK4fptmyjRvd9Y7iS465k+TOU0RhXYE kWPZDYX1r/APSCyFJOjYDR+T8W0R+cM+b4Xt2vefzWeNDEzWKdARSMKXq4WdwewJMXl9 MG2JWa7bF3AmhxEVTlQoHk7A5MS+RZOEm04wGPDUVYShZepVfgNMAp9SvdbkLbiI9bQK 2Anw== X-Gm-Message-State: AOAM531lccr5BN/u2hHxE6/VUPrFL2vQtfIOKKMWCw7in6YveXbQmD5c mFPCqcETiFF9OtX3kUPTPubEO4S/zZ0CqZpJ8HZgNQ== X-Google-Smtp-Source: ABdhPJz0Qdv8wrZCQKMjrVivv7XKFWpj7oILU6UBEyVuV5CbKdEvy4Ib4hW+cuG2n1jxs4HjTMU5IoMdoKRWpSJ1e3s= X-Received: by 2002:a02:ca4a:: with SMTP id i10mr8071337jal.141.1624441539001; Wed, 23 Jun 2021 02:45:39 -0700 (PDT) MIME-Version: 1.0 References: <20210622165511.3169559-1-daniel.vetter@ffwll.ch> <20210622165511.3169559-16-daniel.vetter@ffwll.ch> In-Reply-To: <20210622165511.3169559-16-daniel.vetter@ffwll.ch> From: Bas Nieuwenhuizen Date: Wed, 23 Jun 2021 11:45:33 +0200 Message-ID: To: Daniel Vetter Subject: Re: [Intel-gfx] [PATCH 15/15] RFC: drm/amdgpu: Implement a proper implicit fencing uapi X-BeenThere: intel-gfx@lists.freedesktop.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: Intel graphics driver community testing & development List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Cc: Rob Clark , Daniel Stone , =?UTF-8?Q?Christian_K=C3=B6nig?= , Intel Graphics Development , Kevin Wang , DRI Development , Sumit Semwal , "moderated list:DMA BUFFER SHARING FRAMEWORK" , Luben Tuikov , "Kristian H . Kristensen" , Chen Li , Daniel Vetter , Alex Deucher , mesa-dev , Dave Airlie , =?UTF-8?Q?Michel_D=C3=A4nzer?= , Dennis Li , Deepak R Varma Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Errors-To: intel-gfx-bounces@lists.freedesktop.org Sender: "Intel-gfx" T24gVHVlLCBKdW4gMjIsIDIwMjEgYXQgNjo1NSBQTSBEYW5pZWwgVmV0dGVyIDxkYW5pZWwudmV0 dGVyQGZmd2xsLmNoPiB3cm90ZToKPgo+IFdBUk5JTkc6IEFic29sdXRlbHkgdW50ZXN0ZWQgYmV5 b25kICJnY2MgaXNuJ3QgZHlpbmcgaW4gYWdvbnkiLgo+Cj4gSW1wbGljaXQgZmVuY2luZyBkb25l IHByb3Blcmx5IG5lZWRzIHRvIHRyZWF0IHRoZSBpbXBsaWNpdCBmZW5jaW5nCj4gc2xvdHMgbGlr ZSBhIGZ1bm55IGtpbmQgb2YgSVBDIG1haWxib3guIEluIG90aGVyIHdvcmRzIGl0IG5lZWRzIHRv IGJlCj4gZXhwbGljaXRseS4gVGhpcyBpcyB0aGUgb25seSB3YXkgaXQgd2lsbCBtZXNoIHdlbGwg d2l0aCBleHBsaWNpdAo+IGZlbmNpbmcgdXNlcnNwYWNlIGxpa2UgdmssIGFuZCBpdCdzIGFsc28g dGhlIGJhcmUgbWluaW11bSByZXF1aXJlZCB0bwo+IGJlIGFibGUgdG8gbWFuYWdlIGFueXRoaW5n IGVsc2UgdGhhdCB3YW50cyB0byB1c2UgdGhlIHNhbWUgYnVmZmVyIG9uCj4gbXVsdGlwbGUgZW5n aW5lcyBpbiBwYXJhbGxlbCwgYW5kIHN0aWxsIGJlIGFibGUgdG8gc2hhcmUgaXQgdGhyb3VnaAo+ IGltcGxpY2l0IHN5bmMuCj4KPiBhbWRncHUgY29tcGxldGVseSBsYWNrcyBzdWNoIGFuIHVhcGku IEZpeCB0aGlzLgo+Cj4gTHVja2lseSB0aGUgY29uY2VwdCBvZiBpZ25vcmluZyBpbXBsaWNpdCBm ZW5jZXMgZXhpc3RzIGFscmVhZHksIGFuZAo+IHRha2VzIGNhcmUgb2YgYWxsIHRoZSBjb21wbGV4 aXRpZXMgb2YgbWFraW5nIHN1cmUgdGhhdCBub24tb3B0aW9uYWwKPiBmZW5jZXMgKGxpa2UgYm8g bW92ZXMpIGFyZSBub3QgaWdub3JlZC4gVGhpcyBzdXBwb3J0IHdhcyBhZGRlZCBpbgo+Cj4gY29t bWl0IDE3N2FlMDliNWQ2OTlhNWViZDFjYWZjZWU3ODg4OWRiOTY4YWJmNTQKPiBBdXRob3I6IEFu ZHJlcyBSb2RyaWd1ZXogPGFuZHJlc3g3QGdtYWlsLmNvbT4KPiBEYXRlOiAgIEZyaSBTZXAgMTUg MjA6NDQ6MDYgMjAxNyAtMDQwMAo+Cj4gICAgIGRybS9hbWRncHU6IGludHJvZHVjZSBBTURHUFVf R0VNX0NSRUFURV9FWFBMSUNJVF9TWU5DIHYyCj4KPiBVbmZvcnR1YW50ZWx5IGl0J3MgdGhlIHdy b25nIHNlbWFudGljcywgYmVjYXVzZSBpdCdzIGEgYm8gZmxhZyBhbmQKPiBkaXNhYmxlcyBpbXBs aWNpdCBzeW5jIG9uIGFuIGFsbG9jYXRlZCBidWZmZXIgY29tcGxldGVseS4KPgo+IFdlIF9kb18g d2FudCBpbXBsaWNpdCBzeW5jLCBidXQgY29udHJvbCBpdCBleHBsaWNpdGx5LiBGb3IgdGhpcyB3 ZQo+IG5lZWQgYSBmbGFnIG9uIHRoZSBkcm1fZmlsZSwgc28gdGhhdCBhIGdpdmVuIHVzZXJzcGFj ZSAobGlrZSB2dWxrYW4pCj4gY2FuIG1hbmFnZSB0aGUgaW1wbGljaXQgc3luYyBzbG90cyBleHBs aWNpdGx5LiBUaGUgb3RoZXIgc2lkZSBvZiB0aGUKPiBwaXBlbGluZSAoY29tcG9zaXRvciwgb3Ro ZXIgcHJvY2VzcyBvciBqdXN0IGRpZmZlcmVudCBzdGFnZSBpbiBhIG1lZGlhCj4gcGlwZWxpbmUg aW4gdGhlIHNhbWUgcHJvY2VzcykgY2FuIHRoZW4gZWl0aGVyIGRvIHRoZSBzYW1lLCBvciBmdWxs eQo+IHBhcnRpY2lwYXRlIGluIHRoZSBpbXBsaWNpdCBzeW5jIGFzIGltcGxlbWVudGVkIGJ5IHRo ZSBrZXJuZWwgYnkKPiBkZWZhdWx0Lgo+Cj4gQnkgYnVpbGRpbmcgb24gdGhlIGV4aXN0aW5nIGZs YWcgZm9yIGJ1ZmZlcnMgd2UgYXZvaWQgYW55IGlzc3VlcyB3aXRoCj4gb3BlbmluZyB1cCBhZGRp dGlvbmFsIHNlY3VyaXR5IGNvbmNlcm5zIC0gYW55dGhpbmcgdGhpcyBuZXcgZmxhZyBoZXJlCj4g YWxsb3dzIGlzIGFscmVhZHkuCj4KPiBBbGwgZHJpdmVycyB3aGljaCBzdXBwb3J0cyB0aGlzIGNv bmNlcHQgb2YgYSB1c2Vyc3BhY2Utc3BlY2lmaWMKPiBvcHQtb3V0IG9mIGltcGxpY2l0IHN5bmMg aGF2ZSBhIGZsYWcgaW4gdGhlaXIgQ1MgaW9jdGwsIGJ1dCBpbiByZWFsaXR5Cj4gdGhhdCB0dXJu ZWQgb3V0IHRvIGJlIGEgYml0IHRvbyBpbmZsZXhpYmxlLiBTZWUgdGhlIGRpc2N1c3Npb24gYmVs b3csCj4gbGV0J3MgdHJ5IHRvIGRvIGEgYml0IGJldHRlciBmb3IgYW1kZ3B1Lgo+Cj4gVGhpcyBh bG9uZSBvbmx5IGFsbG93cyB1cyB0byBjb21wbGV0ZWx5IGF2b2lkIGFueSBzdGFsbHMgZHVlIHRv Cj4gaW1wbGljaXQgc3luYywgaXQgZG9lcyBub3QgeWV0IGFsbG93IHVzIHRvIHVzZSBpbXBsaWNp dCBzeW5jIGFzIGEKPiBzdHJhbmdlIGZvcm0gb2YgSVBDIGZvciBzeW5jX2ZpbGUuCj4KPiBGb3Ig dGhhdCB3ZSBuZWVkIHR3byBtb3JlIHBpZWNlczoKPgo+IC0gYSB3YXkgdG8gZ2V0IHRoZSBjdXJy ZW50IGltcGxpY2l0IHN5bmMgZmVuY2VzIG91dCBvZiBhIGJ1ZmZlci4gQ291bGQKPiAgIGJlIGRv bmUgaW4gYSBkcml2ZXIgaW9jdGwsIGJ1dCBldmVyeW9uZSBuZWVkcyB0aGlzLCBhbmQgZ2VuZXJh bGx5IGEKPiAgIGRtYS1idWYgaXMgaW52b2x2ZWQgYW55d2F5IHRvIGVzdGFibGlzaCB0aGUgc2hh cmluZy4gU28gYW4gaW9jdGwgb24KPiAgIHRoZSBkbWEtYnVmIG1ha2VzIGEgdG9uIG1vcmUgc2Vu c2U6Cj4KPiAgIGh0dHBzOi8vbG9yZS5rZXJuZWwub3JnL2RyaS1kZXZlbC8yMDIxMDUyMDE5MDAw Ny41MzQwNDYtNC1qYXNvbkBqbGVrc3RyYW5kLm5ldC8KPgo+ICAgQ3VycmVudCBkcml2ZXJzIGlu IHVwc3RyZWFtIHNvbHZlcyB0aGlzIGJ5IGhhdmluZyB0aGUgb3B0LW91dCBmbGFnCj4gICBvbiB0 aGVpciBDUyBpb2N0bC4gVGhpcyBoYXMgdGhlIGRvd25zaWRlIHRoYXQgdmVyeSBvZnRlbiB0aGUg Q1MKPiAgIHdoaWNoIG11c3QgYWN0dWFsbHkgc3RhbGwgZm9yIHRoZSBpbXBsaWNpdCBmZW5jZSBp cyBydW4gYSB3aGlsZQo+ICAgYWZ0ZXIgdGhlIGltcGxpY2l0IGZlbmNlIHBvaW50IHdhcyBsb2dp Y2FsbHkgc2FtcGxlZCBwZXIgdGhlIGFwaQo+ICAgc3BlYyAodmsgcGFzc2VzIGFuIGV4cGxpY2l0 IHN5bmNvYmogYXJvdW5kIGZvciB0aGF0IGFmYWl1aSksIGFuZCBzbwo+ICAgcmVzdWx0cyBpbiBv dmVyc3luYy4gQ29udmVydGluZyB0aGUgaW1wbGljaXQgc3luYyBmZW5jZXMgaW50byBhCj4gICBz bmFwLXNob3Qgc3luY19maWxlIGlzIGFjdHVhbGx5IGFjY3VyYXRlLgo+Cj4gLSBTaW1pbGxhciB3 ZSBuZWVkIHRvIGJlIGFibGUgdG8gc2V0IHRoZSBleGNsdXNpdmUgaW1wbGljaXQgZmVuY2UuCj4g ICBDdXJyZW50IGRyaXZlcnMgYWdhaW4gZG8gdGhpcyB3aXRoIGEgQ1MgaW9jdGwgZmxhZywgd2l0 aCBhZ2FpbiB0aGUKPiAgIHNhbWUgcHJvYmxlbXMgdGhhdCB0aGUgdGltZSB0aGUgQ1MgaGFwcGVu cyBhZGRpdGlvbmFsIGRlcGVuZGVuY2llcwo+ICAgaGF2ZSBiZWVuIGFkZGVkLiBBbiBleHBsaWNp dCBpb2N0bCB0byBvbmx5IGluc2VydCBhIHN5bmNfZmlsZSAod2hpbGUKPiAgIHJlc3BlY3Rpbmcg dGhlIHJ1bGVzIGZvciBob3cgZXhjbHVzaXZlIGFuZCBzaGFyZWQgZmVuY2Ugc2xvdHMgbXVzdAo+ ICAgYmUgdXBkYXRlIGluIHN0cnVjdCBkbWFfcmVzdikgaXMgbXVjaCBiZXR0ZXIuIFRoaXMgaXMg cHJvcG9zZWQgaGVyZToKPgo+ICAgaHR0cHM6Ly9sb3JlLmtlcm5lbC5vcmcvZHJpLWRldmVsLzIw MjEwNTIwMTkwMDA3LjUzNDA0Ni01LWphc29uQGpsZWtzdHJhbmQubmV0Lwo+Cj4gVGhlc2UgdGhy ZWUgcGllY2VzIHRvZ2V0aGVyIGFsbG93IHVzZXJzcGFjZSB0byBmdWxseSBjb250cm9sIGltcGxp Y2l0Cj4gZmVuY2luZyBhbmQgcmVtb3ZlIGFsbCB1bmVjZXNzYXJ5IHN0YWxsIHBvaW50cyBkdWUg dG8gdGhlbS4KPgo+IFdlbGwsIGFzIG11Y2ggYXMgdGhlIGltcGxpY2l0IGZlbmNpbmcgbW9kZWwg ZnVuZGFtZW50YWxseSBhbGxvd3M6Cj4gVGhlcmUgaXMgb25seSBvbmUgc2V0IG9mIGZlbmNlcywg eW91IGNhbiBvbmx5IGNob29zZSB0byBzeW5jIGFnYWluc3QKPiBvbmx5IHdyaXRlcnMgKGV4Y2x1 c2l2ZSBzbG90KSwgb3IgZXZlcnlvbmUuIEhlbmNlIHN1YmFsbG9jYXRpbmcKPiBtdWx0aXBsZSBi dWZmZXJzIG9yIGFueXRoaW5nIGVsc2UgbGlrZSB0aGlzIGlzIGZ1bmRhbWVudGFsbHkgbm90Cj4g cG9zc2libGUsIGFuZCBjYW4gb25seSBiZSBmaXhlZCBieSBhIHByb3BlciBleHBsaWNpdCBmZW5j aW5nIG1vZGVsLgo+Cj4gQXNpZGUgZnJvbSB0aGF0IGNhdmVhdCB0aGlzIG1vZGVsIGdldHMgaW1w bGljaXQgZmVuY2luZyBhcyBjbG9zZWx5IHRvCj4gZXhwbGljaXQgZmVuY2luZyBzZW1hbnRpY3Mg YXMgcG9zc2libGU6Cj4KPiBPbiB0aGUgYWN0dWFsIGltcGxlbWVudGF0aW9uIEkgb3B0ZWQgZm9y IGEgc2ltcGxlIHNldHBhcmFtIGlvY3RsLCBubwo+IGxvY2tpbmcgKGp1c3QgYXRvbWljIHJlYWRz L3dyaXRlcykgZm9yIHNpbXBsaWNpdHkuIFRoZXJlIGlzIGEgbmljZQo+IGZsYWcgcGFyYW1ldGVy IGluIHRoZSBWTSBpb2N0bCB3aGljaCB3ZSBjb3VsZCB1c2UsIGV4Y2VwdDoKPiAtIGl0J3Mgbm90 IGNoZWNrZWQsIHNvIHVzZXJzcGFjZSBsaWtlbHkgcGFzc2VzIGdhcmJhZ2UKPiAtIHRoZXJlJ3Mg YWxyZWFkeSBhIGNvbW1lbnQgdGhhdCB1c2Vyc3BhY2UgX2RvZXNfIHBhc3MgZ2FyYmFnZSBpbiB0 aGUKPiAgIHByaW9yaXR5IGZpZWxkCj4gU28geWVhaCB1bmZvcnR1bmF0ZWx5IHRoaXMgZmxhZyBw YXJhbWV0ZXIgZm9yIHNldHRpbmcgdm0gZmxhZ3MgaXMKPiB1c2VsZXNzLCBhbmQgd2UgbmVlZCB0 byBoYWNrIHVwIGEgbmV3IG9uZS4KPgo+IHYyOiBFeHBsYWluIHdoeSBhIG5ldyBTRVRQQVJBTSAo SmFzb24pCj4KPiB2MzogQmFzIG5vdGljZWQgSSBmb3Jnb3QgdG8gaG9vayB1cCB0aGUgZGVwZW5k ZW5jeS1zaWRlIHNob3J0Y3V0LiBXZQo+IG5lZWQgYm90aCwgb3IgdGhpcyBkb2Vzbid0IGRvIG11 Y2guCj4KPiB2NDogUmViYXNlIG92ZXIgdGhlIGFtZGdwdSBwYXRjaCB0byBhbHdheXMgc2V0IHRo ZSBpbXBsaWNpdCBzeW5jCj4gZmVuY2VzLgoKU28gSSB0aGluayB0aGVyZSBpcyBzdGlsbCBhIGNh c2UgbWlzc2luZyBpbiB0aGlzIGltcGxlbWVudGF0aW9uLgpDb25zaWRlciB0aGVzZSAzIGNhc2Vz CgooZm9ybWF0OiBhLT5iOiBiIHdhaXRzIG9uIGEuIFllcywgSSBrbm93IGFycm93cyBhcmUgaGFy ZCkKCmV4cGxpY2l0LT5leHBsaWNpdDogVGhpcyBkb2Vzbid0IHdhaXQgbm93LCB3aGljaCBpcyBn b29kCkltcGxpY2l0LT5leHBsaWNpdDogVGhpcyBkb2Vzbid0IHdhaXQgbm93LCB3aGljaCBpcyBn b29kCmV4cGxpY2l0LT5pbXBsaWNpdCA6IFRoaXMgc3RpbGwgd2FpdHMgYXMgdGhlIGV4cGxpY2l0 IHN1Ym1pc3Npb24gc3RpbGwKYWRkcyBzaGFyZWQgZmVuY2VzIGFuZCBtb3N0IHRoaW5ncyB0aGF0 IHNldCBhbiBleGNsdXNpdmUgZmVuY2UgZm9yCmltcGxpY2l0IHN5bmMgd2lsbCBoZW5jZSB3YWl0 IG9uIGl0LgoKVGhpcyBpcyBwcm9iYWJseSBnb29kIGVub3VnaCBmb3Igd2hhdCByYWR2IG5lZWRz IG5vdyBidXQgYWxzbyBzb3VuZHMKbGlrZSBhIHJpc2sgd3J0IGJha2luZyBpbiBuZXcgdWFwaSBi ZWhhdmlvciB0aGF0IHdlIGRvbid0IHdhbnQgdG8gYmUKdGhlIGVuZCByZXN1bHQuCgpXaXRoaW4g QU1ER1BVIHRoaXMgaXMgcHJvYmFibHkgc29sdmFibGUgaW4gdHdvIHdheXM6CgoxKSBEb3duZ3Jh ZGUgQU1ER1BVX1NZTkNfTkVfT1dORVIgdG8gQU1ER1BVX1NZTkNfRVhQTElDSVQgZm9yIHNoYXJl ZCBmZW5jZXMuCjIpIEhhdmUgYW4gRVhQTElDSVQgZmVuY2Ugb3duZXIgdGhhdCBpcyB1c2VkIGZv ciBleHBsaWNpdCBzdWJtaXNzaW9ucwp0aGF0IGlzIGlnbm9yZWQgYnkgQU1ER1BVX1NZTkNfTkVf T1dORVIuCgpCdXQgdGhpcyBkb2Vzbid0IHNvbHZlIGNyb3NzLWRyaXZlciBpbnRlcmFjdGlvbnMg aGVyZS4KCj4KPiBDYzogbWVzYS1kZXZAbGlzdHMuZnJlZWRlc2t0b3Aub3JnCj4gQ2M6IEJhcyBO aWV1d2VuaHVpemVuIDxiYXNAYmFzbmlldXdlbmh1aXplbi5ubD4KPiBDYzogRGF2ZSBBaXJsaWUg PGFpcmxpZWRAZ21haWwuY29tPgo+IENjOiBSb2IgQ2xhcmsgPHJvYmRjbGFya0BjaHJvbWl1bS5v cmc+Cj4gQ2M6IEtyaXN0aWFuIEguIEtyaXN0ZW5zZW4gPGhvZWdzYmVyZ0Bnb29nbGUuY29tPgo+ IENjOiBNaWNoZWwgRMOkbnplciA8bWljaGVsQGRhZW56ZXIubmV0Pgo+IENjOiBEYW5pZWwgU3Rv bmUgPGRhbmllbHNAY29sbGFib3JhLmNvbT4KPiBDYzogU3VtaXQgU2Vtd2FsIDxzdW1pdC5zZW13 YWxAbGluYXJvLm9yZz4KPiBDYzogIkNocmlzdGlhbiBLw7ZuaWciIDxjaHJpc3RpYW4ua29lbmln QGFtZC5jb20+Cj4gQ2M6IEFsZXggRGV1Y2hlciA8YWxleGFuZGVyLmRldWNoZXJAYW1kLmNvbT4K PiBDYzogRGFuaWVsIFZldHRlciA8ZGFuaWVsLnZldHRlckBmZndsbC5jaD4KPiBDYzogRGVlcGFr IFIgVmFybWEgPG1oMTJneDI4MjVAZ21haWwuY29tPgo+IENjOiBDaGVuIExpIDxjaGVubGlAdW5p b250ZWNoLmNvbT4KPiBDYzogS2V2aW4gV2FuZyA8a2V2aW4xLndhbmdAYW1kLmNvbT4KPiBDYzog RGVubmlzIExpIDxEZW5uaXMuTGlAYW1kLmNvbT4KPiBDYzogTHViZW4gVHVpa292IDxsdWJlbi50 dWlrb3ZAYW1kLmNvbT4KPiBDYzogbGluYXJvLW1tLXNpZ0BsaXN0cy5saW5hcm8ub3JnCj4gU2ln bmVkLW9mZi1ieTogRGFuaWVsIFZldHRlciA8ZGFuaWVsLnZldHRlckBpbnRlbC5jb20+Cj4gLS0t Cj4gIGRyaXZlcnMvZ3B1L2RybS9hbWQvYW1kZ3B1L2FtZGdwdV9jcy5jICB8ICA3ICsrKysrLS0K PiAgZHJpdmVycy9ncHUvZHJtL2FtZC9hbWRncHUvYW1kZ3B1X2Rydi5jIHwgMjEgKysrKysrKysr KysrKysrKysrKysrCj4gIGRyaXZlcnMvZ3B1L2RybS9hbWQvYW1kZ3B1L2FtZGdwdV92bS5oICB8 ICA2ICsrKysrKwo+ICBpbmNsdWRlL3VhcGkvZHJtL2FtZGdwdV9kcm0uaCAgICAgICAgICAgfCAx MCArKysrKysrKysrCj4gIDQgZmlsZXMgY2hhbmdlZCwgNDIgaW5zZXJ0aW9ucygrKSwgMiBkZWxl dGlvbnMoLSkKPgo+IGRpZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9kcm0vYW1kL2FtZGdwdS9hbWRn cHVfY3MuYyBiL2RyaXZlcnMvZ3B1L2RybS9hbWQvYW1kZ3B1L2FtZGdwdV9jcy5jCj4gaW5kZXgg NjVkZjM0YzE3MjY0Li5jNTM4NmQxM2ViNGEgMTAwNjQ0Cj4gLS0tIGEvZHJpdmVycy9ncHUvZHJt L2FtZC9hbWRncHUvYW1kZ3B1X2NzLmMKPiArKysgYi9kcml2ZXJzL2dwdS9kcm0vYW1kL2FtZGdw dS9hbWRncHVfY3MuYwo+IEBAIC00OTgsNiArNDk4LDcgQEAgc3RhdGljIGludCBhbWRncHVfY3Nf cGFyc2VyX2JvcyhzdHJ1Y3QgYW1kZ3B1X2NzX3BhcnNlciAqcCwKPiAgICAgICAgIHN0cnVjdCBh bWRncHVfYm8gKmdkczsKPiAgICAgICAgIHN0cnVjdCBhbWRncHVfYm8gKmd3czsKPiAgICAgICAg IHN0cnVjdCBhbWRncHVfYm8gKm9hOwo+ICsgICAgICAgYm9vbCBub19pbXBsaWNpdF9zeW5jID0g UkVBRF9PTkNFKGZwcml2LT52bS5ub19pbXBsaWNpdF9zeW5jKTsKPiAgICAgICAgIGludCByOwo+ Cj4gICAgICAgICBJTklUX0xJU1RfSEVBRCgmcC0+dmFsaWRhdGVkKTsKPiBAQCAtNTc3LDcgKzU3 OCw4IEBAIHN0YXRpYyBpbnQgYW1kZ3B1X2NzX3BhcnNlcl9ib3Moc3RydWN0IGFtZGdwdV9jc19w YXJzZXIgKnAsCj4KPiAgICAgICAgICAgICAgICAgZS0+Ym9fdmEgPSBhbWRncHVfdm1fYm9fZmlu ZCh2bSwgYm8pOwo+Cj4gLSAgICAgICAgICAgICAgIGlmIChiby0+dGJvLmJhc2UuZG1hX2J1ZiAm JiAhYW1kZ3B1X2JvX2V4cGxpY2l0X3N5bmMoYm8pKSB7Cj4gKyAgICAgICAgICAgICAgIGlmIChi by0+dGJvLmJhc2UuZG1hX2J1ZiAmJgo+ICsgICAgICAgICAgICAgICAgICAgIShub19pbXBsaWNp dF9zeW5jIHx8IGFtZGdwdV9ib19leHBsaWNpdF9zeW5jKGJvKSkpIHsKPiAgICAgICAgICAgICAg ICAgICAgICAgICBlLT5jaGFpbiA9IGRtYV9mZW5jZV9jaGFpbl9hbGxvYygpOwo+ICAgICAgICAg ICAgICAgICAgICAgICAgIGlmICghZS0+Y2hhaW4pIHsKPiAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgIHIgPSAtRU5PTUVNOwo+IEBAIC02NDksNiArNjUxLDcgQEAgc3RhdGljIGludCBh bWRncHVfY3Nfc3luY19yaW5ncyhzdHJ1Y3QgYW1kZ3B1X2NzX3BhcnNlciAqcCkKPiAgewo+ICAg ICAgICAgc3RydWN0IGFtZGdwdV9mcHJpdiAqZnByaXYgPSBwLT5maWxwLT5kcml2ZXJfcHJpdjsK PiAgICAgICAgIHN0cnVjdCBhbWRncHVfYm9fbGlzdF9lbnRyeSAqZTsKPiArICAgICAgIGJvb2wg bm9faW1wbGljaXRfc3luYyA9IFJFQURfT05DRShmcHJpdi0+dm0ubm9faW1wbGljaXRfc3luYyk7 Cj4gICAgICAgICBpbnQgcjsKPgo+ICAgICAgICAgbGlzdF9mb3JfZWFjaF9lbnRyeShlLCAmcC0+ dmFsaWRhdGVkLCB0di5oZWFkKSB7Cj4gQEAgLTY1Niw3ICs2NTksNyBAQCBzdGF0aWMgaW50IGFt ZGdwdV9jc19zeW5jX3JpbmdzKHN0cnVjdCBhbWRncHVfY3NfcGFyc2VyICpwKQo+ICAgICAgICAg ICAgICAgICBzdHJ1Y3QgZG1hX3Jlc3YgKnJlc3YgPSBiby0+dGJvLmJhc2UucmVzdjsKPiAgICAg ICAgICAgICAgICAgZW51bSBhbWRncHVfc3luY19tb2RlIHN5bmNfbW9kZTsKPgo+IC0gICAgICAg ICAgICAgICBzeW5jX21vZGUgPSBhbWRncHVfYm9fZXhwbGljaXRfc3luYyhibykgPwo+ICsgICAg ICAgICAgICAgICBzeW5jX21vZGUgPSBub19pbXBsaWNpdF9zeW5jIHx8IGFtZGdwdV9ib19leHBs aWNpdF9zeW5jKGJvKSA/Cj4gICAgICAgICAgICAgICAgICAgICAgICAgQU1ER1BVX1NZTkNfRVhQ TElDSVQgOiBBTURHUFVfU1lOQ19ORV9PV05FUjsKPiAgICAgICAgICAgICAgICAgciA9IGFtZGdw dV9zeW5jX3Jlc3YocC0+YWRldiwgJnAtPmpvYi0+c3luYywgcmVzdiwgc3luY19tb2RlLAo+ICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAmZnByaXYtPnZtKTsKPiBkaWZmIC0t Z2l0IGEvZHJpdmVycy9ncHUvZHJtL2FtZC9hbWRncHUvYW1kZ3B1X2Rydi5jIGIvZHJpdmVycy9n cHUvZHJtL2FtZC9hbWRncHUvYW1kZ3B1X2Rydi5jCj4gaW5kZXggYzA4MGJhMTVhZTc3Li5mOTgy NjI2YjUzMjggMTAwNjQ0Cj4gLS0tIGEvZHJpdmVycy9ncHUvZHJtL2FtZC9hbWRncHUvYW1kZ3B1 X2Rydi5jCj4gKysrIGIvZHJpdmVycy9ncHUvZHJtL2FtZC9hbWRncHUvYW1kZ3B1X2Rydi5jCj4g QEAgLTE3MjQsNiArMTcyNCwyNiBAQCBpbnQgYW1kZ3B1X2ZpbGVfdG9fZnByaXYoc3RydWN0IGZp bGUgKmZpbHAsIHN0cnVjdCBhbWRncHVfZnByaXYgKipmcHJpdikKPiAgICAgICAgIHJldHVybiAw Owo+ICB9Cj4KPiAraW50IGFtZGdwdV9zZXRwYXJhbV9pb2N0bChzdHJ1Y3QgZHJtX2RldmljZSAq ZGV2LCB2b2lkICpkYXRhLAo+ICsgICAgICAgICAgICAgICAgICAgICAgICAgc3RydWN0IGRybV9m aWxlICpmaWxwKQo+ICt7Cj4gKyAgICAgICBzdHJ1Y3QgZHJtX2FtZGdwdV9zZXRwYXJhbSAqc2V0 cGFyYW0gPSBkYXRhOwo+ICsgICAgICAgc3RydWN0IGFtZGdwdV9mcHJpdiAqZnByaXYgPSBmaWxw LT5kcml2ZXJfcHJpdjsKPiArCj4gKyAgICAgICBzd2l0Y2ggKHNldHBhcmFtLT5wYXJhbSkgewo+ ICsgICAgICAgY2FzZSBBTURHUFVfU0VUUEFSQU1fTk9fSU1QTElDSVRfU1lOQzoKPiArICAgICAg ICAgICAgICAgaWYgKHNldHBhcmFtLT52YWx1ZSkKPiArICAgICAgICAgICAgICAgICAgICAgICBX UklURV9PTkNFKGZwcml2LT52bS5ub19pbXBsaWNpdF9zeW5jLCB0cnVlKTsKPiArICAgICAgICAg ICAgICAgZWxzZQo+ICsgICAgICAgICAgICAgICAgICAgICAgIFdSSVRFX09OQ0UoZnByaXYtPnZt Lm5vX2ltcGxpY2l0X3N5bmMsIGZhbHNlKTsKPiArICAgICAgICAgICAgICAgYnJlYWs7Cj4gKyAg ICAgICBkZWZhdWx0Ogo+ICsgICAgICAgICAgICAgICByZXR1cm4gLUVJTlZBTDsKPiArICAgICAg IH0KPiArCj4gKyAgICAgICByZXR1cm4gMDsKPiArfQo+ICsKPiAgY29uc3Qgc3RydWN0IGRybV9p b2N0bF9kZXNjIGFtZGdwdV9pb2N0bHNfa21zW10gPSB7Cj4gICAgICAgICBEUk1fSU9DVExfREVG X0RSVihBTURHUFVfR0VNX0NSRUFURSwgYW1kZ3B1X2dlbV9jcmVhdGVfaW9jdGwsIERSTV9BVVRI fERSTV9SRU5ERVJfQUxMT1cpLAo+ICAgICAgICAgRFJNX0lPQ1RMX0RFRl9EUlYoQU1ER1BVX0NU WCwgYW1kZ3B1X2N0eF9pb2N0bCwgRFJNX0FVVEh8RFJNX1JFTkRFUl9BTExPVyksCj4gQEAgLTE3 NDIsNiArMTc2Miw3IEBAIGNvbnN0IHN0cnVjdCBkcm1faW9jdGxfZGVzYyBhbWRncHVfaW9jdGxz X2ttc1tdID0gewo+ICAgICAgICAgRFJNX0lPQ1RMX0RFRl9EUlYoQU1ER1BVX0dFTV9WQSwgYW1k Z3B1X2dlbV92YV9pb2N0bCwgRFJNX0FVVEh8RFJNX1JFTkRFUl9BTExPVyksCj4gICAgICAgICBE Uk1fSU9DVExfREVGX0RSVihBTURHUFVfR0VNX09QLCBhbWRncHVfZ2VtX29wX2lvY3RsLCBEUk1f QVVUSHxEUk1fUkVOREVSX0FMTE9XKSwKPiAgICAgICAgIERSTV9JT0NUTF9ERUZfRFJWKEFNREdQ VV9HRU1fVVNFUlBUUiwgYW1kZ3B1X2dlbV91c2VycHRyX2lvY3RsLCBEUk1fQVVUSHxEUk1fUkVO REVSX0FMTE9XKSwKPiArICAgICAgIERSTV9JT0NUTF9ERUZfRFJWKEFNREdQVV9TRVRQQVJBTSwg YW1kZ3B1X3NldHBhcmFtX2lvY3RsLCBEUk1fQVVUSHxEUk1fUkVOREVSX0FMTE9XKSwKPiAgfTsK Pgo+ICBzdGF0aWMgY29uc3Qgc3RydWN0IGRybV9kcml2ZXIgYW1kZ3B1X2ttc19kcml2ZXIgPSB7 Cj4gZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2RybS9hbWQvYW1kZ3B1L2FtZGdwdV92bS5oIGIv ZHJpdmVycy9ncHUvZHJtL2FtZC9hbWRncHUvYW1kZ3B1X3ZtLmgKPiBpbmRleCBkZGI4NWE4NWNi YmEuLjBlOGM0NDBjNjMwMyAxMDA2NDQKPiAtLS0gYS9kcml2ZXJzL2dwdS9kcm0vYW1kL2FtZGdw dS9hbWRncHVfdm0uaAo+ICsrKyBiL2RyaXZlcnMvZ3B1L2RybS9hbWQvYW1kZ3B1L2FtZGdwdV92 bS5oCj4gQEAgLTMyMSw2ICszMjEsMTIgQEAgc3RydWN0IGFtZGdwdV92bSB7Cj4gICAgICAgICBi b29sICAgICAgICAgICAgICAgICAgICBidWxrX21vdmVhYmxlOwo+ICAgICAgICAgLyogRmxhZyB0 byBpbmRpY2F0ZSBpZiBWTSBpcyB1c2VkIGZvciBjb21wdXRlICovCj4gICAgICAgICBib29sICAg ICAgICAgICAgICAgICAgICBpc19jb21wdXRlX2NvbnRleHQ7Cj4gKyAgICAgICAvKgo+ICsgICAg ICAgICogRmxhZyB0byBpbmRpY2F0ZSB3aGV0aGVyIGltcGxpY2l0IHN5bmMgc2hvdWxkIGFsd2F5 cyBiZSBza2lwcGVkIG9uCj4gKyAgICAgICAgKiB0aGlzIGNvbnRleHQuIFdlIGRvIG5vdCBjYXJl IGFib3V0IHJhY2VzIGF0IGFsbCwgdXNlcnNwYWNlIGlzIGFsbG93ZWQKPiArICAgICAgICAqIHRv IHNob290IGl0c2VsZiB3aXRoIGltcGxpY2l0IHN5bmMgdG8gaXRzIGZ1bGxlc3QgbGlraW5nLgo+ ICsgICAgICAgICovCj4gKyAgICAgICBib29sIG5vX2ltcGxpY2l0X3N5bmM7Cj4gIH07Cj4KPiAg c3RydWN0IGFtZGdwdV92bV9tYW5hZ2VyIHsKPiBkaWZmIC0tZ2l0IGEvaW5jbHVkZS91YXBpL2Ry bS9hbWRncHVfZHJtLmggYi9pbmNsdWRlL3VhcGkvZHJtL2FtZGdwdV9kcm0uaAo+IGluZGV4IDBj YmQxNTQwYWVhYy4uOWVhZTI0NWMxNGQ2IDEwMDY0NAo+IC0tLSBhL2luY2x1ZGUvdWFwaS9kcm0v YW1kZ3B1X2RybS5oCj4gKysrIGIvaW5jbHVkZS91YXBpL2RybS9hbWRncHVfZHJtLmgKPiBAQCAt NTQsNiArNTQsNyBAQCBleHRlcm4gIkMiIHsKPiAgI2RlZmluZSBEUk1fQU1ER1BVX1ZNICAgICAg ICAgICAgICAgICAgMHgxMwo+ICAjZGVmaW5lIERSTV9BTURHUFVfRkVOQ0VfVE9fSEFORExFICAg ICAweDE0Cj4gICNkZWZpbmUgRFJNX0FNREdQVV9TQ0hFRCAgICAgICAgICAgICAgIDB4MTUKPiAr I2RlZmluZSBEUk1fQU1ER1BVX1NFVFBBUkFNICAgICAgICAgICAgMHgxNgo+Cj4gICNkZWZpbmUg RFJNX0lPQ1RMX0FNREdQVV9HRU1fQ1JFQVRFICAgIERSTV9JT1dSKERSTV9DT01NQU5EX0JBU0Ug KyBEUk1fQU1ER1BVX0dFTV9DUkVBVEUsIHVuaW9uIGRybV9hbWRncHVfZ2VtX2NyZWF0ZSkKPiAg I2RlZmluZSBEUk1fSU9DVExfQU1ER1BVX0dFTV9NTUFQICAgICAgRFJNX0lPV1IoRFJNX0NPTU1B TkRfQkFTRSArIERSTV9BTURHUFVfR0VNX01NQVAsIHVuaW9uIGRybV9hbWRncHVfZ2VtX21tYXAp Cj4gQEAgLTcxLDYgKzcyLDcgQEAgZXh0ZXJuICJDIiB7Cj4gICNkZWZpbmUgRFJNX0lPQ1RMX0FN REdQVV9WTSAgICAgICAgICAgIERSTV9JT1dSKERSTV9DT01NQU5EX0JBU0UgKyBEUk1fQU1ER1BV X1ZNLCB1bmlvbiBkcm1fYW1kZ3B1X3ZtKQo+ICAjZGVmaW5lIERSTV9JT0NUTF9BTURHUFVfRkVO Q0VfVE9fSEFORExFIERSTV9JT1dSKERSTV9DT01NQU5EX0JBU0UgKyBEUk1fQU1ER1BVX0ZFTkNF X1RPX0hBTkRMRSwgdW5pb24gZHJtX2FtZGdwdV9mZW5jZV90b19oYW5kbGUpCj4gICNkZWZpbmUg RFJNX0lPQ1RMX0FNREdQVV9TQ0hFRCAgICAgICAgIERSTV9JT1coRFJNX0NPTU1BTkRfQkFTRSAr IERSTV9BTURHUFVfU0NIRUQsIHVuaW9uIGRybV9hbWRncHVfc2NoZWQpCj4gKyNkZWZpbmUgRFJN X0lPQ1RMX0FNREdQVV9TRVRQQVJBTSAgICAgIERSTV9JT1coRFJNX0NPTU1BTkRfQkFTRSArIERS TV9BTURHUFVfU0VUUEFSQU0sIHN0cnVjdCBkcm1fYW1kZ3B1X3NldHBhcmFtKQo+Cj4gIC8qKgo+ ICAgKiBET0M6IG1lbW9yeSBkb21haW5zCj4gQEAgLTMwNiw2ICszMDgsMTQgQEAgdW5pb24gZHJt X2FtZGdwdV9zY2hlZCB7Cj4gICAgICAgICBzdHJ1Y3QgZHJtX2FtZGdwdV9zY2hlZF9pbiBpbjsK PiAgfTsKPgo+ICsjZGVmaW5lIEFNREdQVV9TRVRQQVJBTV9OT19JTVBMSUNJVF9TWU5DICAgICAg IDEKPiArCj4gK3N0cnVjdCBkcm1fYW1kZ3B1X3NldHBhcmFtIHsKPiArICAgICAgIC8qIEFNREdQ VV9TRVRQQVJBTV8qICovCj4gKyAgICAgICBfX3UzMiAgIHBhcmFtOwo+ICsgICAgICAgX191MzIg ICB2YWx1ZTsKPiArfTsKPiArCj4gIC8qCj4gICAqIFRoaXMgaXMgbm90IGEgcmVsaWFibGUgQVBJ IGFuZCB5b3Ugc2hvdWxkIGV4cGVjdCBpdCB0byBmYWlsIGZvciBhbnkKPiAgICogbnVtYmVyIG9m IHJlYXNvbnMgYW5kIGhhdmUgZmFsbGJhY2sgcGF0aCB0aGF0IGRvIG5vdCB1c2UgdXNlcnB0ciB0 bwo+IC0tCj4gMi4zMi4wLnJjMgo+Cl9fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fCkludGVsLWdmeCBtYWlsaW5nIGxpc3QKSW50ZWwtZ2Z4QGxpc3RzLmZyZWVk ZXNrdG9wLm9yZwpodHRwczovL2xpc3RzLmZyZWVkZXNrdG9wLm9yZy9tYWlsbWFuL2xpc3RpbmZv L2ludGVsLWdmeAo=