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.8 required=3.0 tests=DKIM_SIGNED,DKIM_VALID, DKIM_VALID_AU,HEADER_FROM_DIFFERENT_DOMAINS,INCLUDES_PATCH,MAILING_LIST_MULTI, SIGNED_OFF_BY,SPF_HELO_NONE,SPF_PASS,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 A87E8C433E3 for ; Tue, 7 Jul 2020 20:12:46 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by mail.kernel.org (Postfix) with ESMTP id 80D65206BE for ; Tue, 7 Jul 2020 20:12:46 +0000 (UTC) Authentication-Results: mail.kernel.org; dkim=pass (1024-bit key) header.d=ffwll.ch header.i=@ffwll.ch header.b="fmFnnt+e" Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1728326AbgGGUMp (ORCPT ); Tue, 7 Jul 2020 16:12:45 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:49488 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1728231AbgGGUMp (ORCPT ); Tue, 7 Jul 2020 16:12:45 -0400 Received: from mail-wr1-x444.google.com (mail-wr1-x444.google.com [IPv6:2a00:1450:4864:20::444]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id DFE40C08C5DC for ; Tue, 7 Jul 2020 13:12:43 -0700 (PDT) Received: by mail-wr1-x444.google.com with SMTP id f2so18609157wrp.7 for ; Tue, 07 Jul 2020 13:12:43 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=ffwll.ch; s=google; h=from:to:cc:subject:date:message-id:in-reply-to:references :mime-version:content-transfer-encoding; bh=+zqqvyi3z5A21ql34E5+vQaCHF2rAOOJAQR+upY9QO0=; b=fmFnnt+ehdq4yzSf5JNaqXX4yhCqAqD0kK0/qt4eB91lTy43C9BV8NE2+7bCE2dMEV j/iYq+xbAyWSUJE96U9SszSPGm8fuSDz412xfxFWlqIfJCVtYRTbtJZuwBEimFPr2Jzq SZeC88b3d2af3OnObiDD64/C7gkdSt0cAFrRU= X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references:mime-version:content-transfer-encoding; bh=+zqqvyi3z5A21ql34E5+vQaCHF2rAOOJAQR+upY9QO0=; b=nyRHhpGLLB62t0RfV//WUSyQck9t3DWK7LypyMFXIbBnmRXPnsMKH1exCUuRJMTELI Jxv7mrXQnGcEDdVn/jVSSrPVSEDsZofIv0qhGGUELY91se/Q7ondpol56Jq/1WYVB7Ep PkIdq6vQRBmpaHHHypizAoQhwSzyqzemOr6H0Ky/TWRoIckAU0kggGLqBjlqduNA5wcN zY9pyNuO9YgkTN71glmrho1mpcWthCTCyYErZ05LByIu+m0qOuKIWl9c8u1AH+YlQZcu xjTfzM8bjezWuSb5PON1n/Fgcd7jEf2uWZnR6KpI/JsExUUI53FKyLaN+BLEs1uAXFOD VGKQ== X-Gm-Message-State: AOAM530p87nk3uNvegi+zh/H0z/RH1T8vIH16oBu2TlyEhZS/UiTPau3 7BrN3AKurl0BUzauCy022syq/A== X-Google-Smtp-Source: ABdhPJzrfZJXwmqAifF26fj/gQn6kFUlKzxT6On6Iaf8irG4na4G4iK3mAJTIWo1H7s/v1Eotv4TeA== X-Received: by 2002:adf:cf0c:: with SMTP id o12mr54938782wrj.265.1594152762369; Tue, 07 Jul 2020 13:12:42 -0700 (PDT) Received: from phenom.ffwll.local ([2a02:168:57f4:0:efd0:b9e5:5ae6:c2fa]) by smtp.gmail.com with ESMTPSA id q7sm2515262wra.56.2020.07.07.13.12.40 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Tue, 07 Jul 2020 13:12:41 -0700 (PDT) From: Daniel Vetter To: DRI Development Cc: Intel Graphics Development , linux-rdma@vger.kernel.org, Daniel Vetter , Felix Kuehling , =?UTF-8?q?Thomas=20Hellstr=C3=B6m?= , Maarten Lankhorst , Mika Kuoppala , linux-media@vger.kernel.org, linaro-mm-sig@lists.linaro.org, amd-gfx@lists.freedesktop.org, Chris Wilson , =?UTF-8?q?Christian=20K=C3=B6nig?= , Daniel Vetter Subject: [PATCH 01/25] dma-fence: basic lockdep annotations Date: Tue, 7 Jul 2020 22:12:05 +0200 Message-Id: <20200707201229.472834-2-daniel.vetter@ffwll.ch> X-Mailer: git-send-email 2.27.0 In-Reply-To: <20200707201229.472834-1-daniel.vetter@ffwll.ch> References: <20200707201229.472834-1-daniel.vetter@ffwll.ch> MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Sender: linux-rdma-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: linux-rdma@vger.kernel.org Design is similar to the lockdep annotations for workers, but with some twists: - We use a read-lock for the execution/worker/completion side, so that this explicit annotation can be more liberally sprinkled around. With read locks lockdep isn't going to complain if the read-side isn't nested the same way under all circumstances, so ABBA deadlocks are ok. Which they are, since this is an annotation only. - We're using non-recursive lockdep read lock mode, since in recursive read lock mode lockdep does not catch read side hazards. And we _very_ much want read side hazards to be caught. For full details of this limitation see commit e91498589746065e3ae95d9a00b068e525eec34f Author: Peter Zijlstra Date: Wed Aug 23 13:13:11 2017 +0200 locking/lockdep/selftests: Add mixed read-write ABBA tests - To allow nesting of the read-side explicit annotations we explicitly keep track of the nesting. lock_is_held() allows us to do that. - The wait-side annotation is a write lock, and entirely done within dma_fence_wait() for everyone by default. - To be able to freely annotate helper functions I want to make it ok to call dma_fence_begin/end_signalling from soft/hardirq context. First attempt was using the hardirq locking context for the write side in lockdep, but this forces all normal spinlocks nested within dma_fence_begin/end_signalling to be spinlocks. That bollocks. The approach now is to simple check in_atomic(), and for these cases entirely rely on the might_sleep() check in dma_fence_wait(). That will catch any wrong nesting against spinlocks from soft/hardirq contexts. The idea here is that every code path that's critical for eventually signalling a dma_fence should be annotated with dma_fence_begin/end_signalling. The annotation ideally starts right after a dma_fence is published (added to a dma_resv, exposed as a sync_file fd, attached to a drm_syncobj fd, or anything else that makes the dma_fence visible to other kernel threads), up to and including the dma_fence_wait(). Examples are irq handlers, the scheduler rt threads, the tail of execbuf (after the corresponding fences are visible), any workers that end up signalling dma_fences and really anything else. Not annotated should be code paths that only complete fences opportunistically as the gpu progresses, like e.g. shrinker/eviction code. The main class of deadlocks this is supposed to catch are: Thread A: mutex_lock(A); mutex_unlock(A); dma_fence_signal(); Thread B: mutex_lock(A); dma_fence_wait(); mutex_unlock(A); Thread B is blocked on A signalling the fence, but A never gets around to that because it cannot acquire the lock A. Note that dma_fence_wait() is allowed to be nested within dma_fence_begin/end_signalling sections. To allow this to happen the read lock needs to be upgraded to a write lock, which means that any other lock is acquired between the dma_fence_begin_signalling() call and the call to dma_fence_wait(), and still held, this will result in an immediate lockdep complaint. The only other option would be to not annotate such calls, defeating the point. Therefore these annotations cannot be sprinkled over the code entirely mindless to avoid false positives. Originally I hope that the cross-release lockdep extensions would alleviate the need for explicit annotations: https://lwn.net/Articles/709849/ But there's a few reasons why that's not an option: - It's not happening in upstream, since it got reverted due to too many false positives: commit e966eaeeb623f09975ef362c2866fae6f86844f9 Author: Ingo Molnar Date: Tue Dec 12 12:31:16 2017 +0100 locking/lockdep: Remove the cross-release locking checks This code (CONFIG_LOCKDEP_CROSSRELEASE=y and CONFIG_LOCKDEP_COMPLETIONS=y), while it found a number of old bugs initially, was also causing too many false positives that caused people to disable lockdep - which is arguably a worse overall outcome. - cross-release uses the complete() call to annotate the end of critical sections, for dma_fence that would be dma_fence_signal(). But we do not want all dma_fence_signal() calls to be treated as critical, since many are opportunistic cleanup of gpu requests. If these get stuck there's still the main completion interrupt and workers who can unblock everyone. Automatically annotating all dma_fence_signal() calls would hence cause false positives. - cross-release had some educated guesses for when a critical section starts, like fresh syscall or fresh work callback. This would again cause false positives without explicit annotations, since for dma_fence the critical sections only starts when we publish a fence. - Furthermore there can be cases where a thread never does a dma_fence_signal, but is still critical for reaching completion of fences. One example would be a scheduler kthread which picks up jobs and pushes them into hardware, where the interrupt handler or another completion thread calls dma_fence_signal(). But if the scheduler thread hangs, then all the fences hang, hence we need to manually annotate it. cross-release aimed to solve this by chaining cross-release dependencies, but the dependency from scheduler thread to the completion interrupt handler goes through hw where cross-release code can't observe it. In short, without manual annotations and careful review of the start and end of critical sections, cross-relese dependency tracking doesn't work. We need explicit annotations. v2: handle soft/hardirq ctx better against write side and dont forget EXPORT_SYMBOL, drivers can't use this otherwise. v3: Kerneldoc. v4: Some spelling fixes from Mika v5: Amend commit message to explain in detail why cross-release isn't the solution. v6: Pull out misplaced .rst hunk. Cc: Felix Kuehling Reviewed-by: Thomas Hellström Reviewed-by: Maarten Lankhorst Cc: Mika Kuoppala Cc: Thomas Hellstrom Cc: linux-media@vger.kernel.org Cc: linaro-mm-sig@lists.linaro.org Cc: linux-rdma@vger.kernel.org Cc: amd-gfx@lists.freedesktop.org Cc: intel-gfx@lists.freedesktop.org Cc: Chris Wilson Cc: Maarten Lankhorst Cc: Christian König Signed-off-by: Daniel Vetter --- Documentation/driver-api/dma-buf.rst | 6 + drivers/dma-buf/dma-fence.c | 161 +++++++++++++++++++++++++++ include/linux/dma-fence.h | 12 ++ 3 files changed, 179 insertions(+) diff --git a/Documentation/driver-api/dma-buf.rst b/Documentation/driver-api/dma-buf.rst index 7fb7b661febd..05d856131140 100644 --- a/Documentation/driver-api/dma-buf.rst +++ b/Documentation/driver-api/dma-buf.rst @@ -133,6 +133,12 @@ DMA Fences .. kernel-doc:: drivers/dma-buf/dma-fence.c :doc: DMA fences overview +DMA Fence Signalling Annotations +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + +.. kernel-doc:: drivers/dma-buf/dma-fence.c + :doc: fence signalling annotation + DMA Fences Functions Reference ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ diff --git a/drivers/dma-buf/dma-fence.c b/drivers/dma-buf/dma-fence.c index 656e9ac2d028..0005bc002529 100644 --- a/drivers/dma-buf/dma-fence.c +++ b/drivers/dma-buf/dma-fence.c @@ -110,6 +110,160 @@ u64 dma_fence_context_alloc(unsigned num) } EXPORT_SYMBOL(dma_fence_context_alloc); +/** + * DOC: fence signalling annotation + * + * Proving correctness of all the kernel code around &dma_fence through code + * review and testing is tricky for a few reasons: + * + * * It is a cross-driver contract, and therefore all drivers must follow the + * same rules for lock nesting order, calling contexts for various functions + * and anything else significant for in-kernel interfaces. But it is also + * impossible to test all drivers in a single machine, hence brute-force N vs. + * N testing of all combinations is impossible. Even just limiting to the + * possible combinations is infeasible. + * + * * There is an enormous amount of driver code involved. For render drivers + * there's the tail of command submission, after fences are published, + * scheduler code, interrupt and workers to process job completion, + * and timeout, gpu reset and gpu hang recovery code. Plus for integration + * with core mm with have &mmu_notifier, respectively &mmu_interval_notifier, + * and &shrinker. For modesetting drivers there's the commit tail functions + * between when fences for an atomic modeset are published, and when the + * corresponding vblank completes, including any interrupt processing and + * related workers. Auditing all that code, across all drivers, is not + * feasible. + * + * * Due to how many other subsystems are involved and the locking hierarchies + * this pulls in there is extremely thin wiggle-room for driver-specific + * differences. &dma_fence interacts with almost all of the core memory + * handling through page fault handlers via &dma_resv, dma_resv_lock() and + * dma_resv_unlock(). On the other side it also interacts through all + * allocation sites through &mmu_notifier and &shrinker. + * + * Furthermore lockdep does not handle cross-release dependencies, which means + * any deadlocks between dma_fence_wait() and dma_fence_signal() can't be caught + * at runtime with some quick testing. The simplest example is one thread + * waiting on a &dma_fence while holding a lock:: + * + * lock(A); + * dma_fence_wait(B); + * unlock(A); + * + * while the other thread is stuck trying to acquire the same lock, which + * prevents it from signalling the fence the previous thread is stuck waiting + * on:: + * + * lock(A); + * unlock(A); + * dma_fence_signal(B); + * + * By manually annotating all code relevant to signalling a &dma_fence we can + * teach lockdep about these dependencies, which also helps with the validation + * headache since now lockdep can check all the rules for us:: + * + * cookie = dma_fence_begin_signalling(); + * lock(A); + * unlock(A); + * dma_fence_signal(B); + * dma_fence_end_signalling(cookie); + * + * For using dma_fence_begin_signalling() and dma_fence_end_signalling() to + * annotate critical sections the following rules need to be observed: + * + * * All code necessary to complete a &dma_fence must be annotated, from the + * point where a fence is accessible to other threads, to the point where + * dma_fence_signal() is called. Un-annotated code can contain deadlock issues, + * and due to the very strict rules and many corner cases it is infeasible to + * catch these just with review or normal stress testing. + * + * * &struct dma_resv deserves a special note, since the readers are only + * protected by rcu. This means the signalling critical section starts as soon + * as the new fences are installed, even before dma_resv_unlock() is called. + * + * * The only exception are fast paths and opportunistic signalling code, which + * calls dma_fence_signal() purely as an optimization, but is not required to + * guarantee completion of a &dma_fence. The usual example is a wait IOCTL + * which calls dma_fence_signal(), while the mandatory completion path goes + * through a hardware interrupt and possible job completion worker. + * + * * To aid composability of code, the annotations can be freely nested, as long + * as the overall locking hierarchy is consistent. The annotations also work + * both in interrupt and process context. Due to implementation details this + * requires that callers pass an opaque cookie from + * dma_fence_begin_signalling() to dma_fence_end_signalling(). + * + * * Validation against the cross driver contract is implemented by priming + * lockdep with the relevant hierarchy at boot-up. This means even just + * testing with a single device is enough to validate a driver, at least as + * far as deadlocks with dma_fence_wait() against dma_fence_signal() are + * concerned. + */ +#ifdef CONFIG_LOCKDEP +struct lockdep_map dma_fence_lockdep_map = { + .name = "dma_fence_map" +}; + +/** + * dma_fence_begin_signalling - begin a critical DMA fence signalling section + * + * Drivers should use this to annotate the beginning of any code section + * required to eventually complete &dma_fence by calling dma_fence_signal(). + * + * The end of these critical sections are annotated with + * dma_fence_end_signalling(). + * + * Returns: + * + * Opaque cookie needed by the implementation, which needs to be passed to + * dma_fence_end_signalling(). + */ +bool dma_fence_begin_signalling(void) +{ + /* explicitly nesting ... */ + if (lock_is_held_type(&dma_fence_lockdep_map, 1)) + return true; + + /* rely on might_sleep check for soft/hardirq locks */ + if (in_atomic()) + return true; + + /* ... and non-recursive readlock */ + lock_acquire(&dma_fence_lockdep_map, 0, 0, 1, 1, NULL, _RET_IP_); + + return false; +} +EXPORT_SYMBOL(dma_fence_begin_signalling); + +/** + * dma_fence_end_signalling - end a critical DMA fence signalling section + * + * Closes a critical section annotation opened by dma_fence_begin_signalling(). + */ +void dma_fence_end_signalling(bool cookie) +{ + if (cookie) + return; + + lock_release(&dma_fence_lockdep_map, _RET_IP_); +} +EXPORT_SYMBOL(dma_fence_end_signalling); + +void __dma_fence_might_wait(void) +{ + bool tmp; + + tmp = lock_is_held_type(&dma_fence_lockdep_map, 1); + if (tmp) + lock_release(&dma_fence_lockdep_map, _THIS_IP_); + lock_map_acquire(&dma_fence_lockdep_map); + lock_map_release(&dma_fence_lockdep_map); + if (tmp) + lock_acquire(&dma_fence_lockdep_map, 0, 0, 1, 1, NULL, _THIS_IP_); +} +#endif + + /** * dma_fence_signal_locked - signal completion of a fence * @fence: the fence to signal @@ -170,14 +324,19 @@ int dma_fence_signal(struct dma_fence *fence) { unsigned long flags; int ret; + bool tmp; if (!fence) return -EINVAL; + tmp = dma_fence_begin_signalling(); + spin_lock_irqsave(fence->lock, flags); ret = dma_fence_signal_locked(fence); spin_unlock_irqrestore(fence->lock, flags); + dma_fence_end_signalling(tmp); + return ret; } EXPORT_SYMBOL(dma_fence_signal); @@ -210,6 +369,8 @@ dma_fence_wait_timeout(struct dma_fence *fence, bool intr, signed long timeout) might_sleep(); + __dma_fence_might_wait(); + trace_dma_fence_wait_start(fence); if (fence->ops->wait) ret = fence->ops->wait(fence, intr, timeout); diff --git a/include/linux/dma-fence.h b/include/linux/dma-fence.h index 3347c54f3a87..3f288f7db2ef 100644 --- a/include/linux/dma-fence.h +++ b/include/linux/dma-fence.h @@ -357,6 +357,18 @@ dma_fence_get_rcu_safe(struct dma_fence __rcu **fencep) } while (1); } +#ifdef CONFIG_LOCKDEP +bool dma_fence_begin_signalling(void); +void dma_fence_end_signalling(bool cookie); +#else +static inline bool dma_fence_begin_signalling(void) +{ + return true; +} +static inline void dma_fence_end_signalling(bool cookie) {} +static inline void __dma_fence_might_wait(void) {} +#endif + int dma_fence_signal(struct dma_fence *fence); int dma_fence_signal_locked(struct dma_fence *fence); signed long dma_fence_default_wait(struct dma_fence *fence, -- 2.27.0 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_INVALID,DKIM_SIGNED, HEADER_FROM_DIFFERENT_DOMAINS,INCLUDES_PATCH,MAILING_LIST_MULTI,SIGNED_OFF_BY, SPF_HELO_NONE,SPF_PASS,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 8B88DC433E0 for ; Tue, 7 Jul 2020 20:12:50 +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 641DD206BE for ; Tue, 7 Jul 2020 20:12:50 +0000 (UTC) Authentication-Results: mail.kernel.org; dkim=fail reason="signature verification failed" (1024-bit key) header.d=ffwll.ch header.i=@ffwll.ch header.b="fmFnnt+e" DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org 641DD206BE Authentication-Results: mail.kernel.org; dmarc=none (p=none dis=none) header.from=ffwll.ch 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 940786E3B5; Tue, 7 Jul 2020 20:12:45 +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 4489F6E233 for ; Tue, 7 Jul 2020 20:12:44 +0000 (UTC) Received: by mail-wr1-x441.google.com with SMTP id j4so44180589wrp.10 for ; Tue, 07 Jul 2020 13:12:44 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=ffwll.ch; s=google; h=from:to:cc:subject:date:message-id:in-reply-to:references :mime-version:content-transfer-encoding; bh=+zqqvyi3z5A21ql34E5+vQaCHF2rAOOJAQR+upY9QO0=; b=fmFnnt+ehdq4yzSf5JNaqXX4yhCqAqD0kK0/qt4eB91lTy43C9BV8NE2+7bCE2dMEV j/iYq+xbAyWSUJE96U9SszSPGm8fuSDz412xfxFWlqIfJCVtYRTbtJZuwBEimFPr2Jzq SZeC88b3d2af3OnObiDD64/C7gkdSt0cAFrRU= X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references:mime-version:content-transfer-encoding; bh=+zqqvyi3z5A21ql34E5+vQaCHF2rAOOJAQR+upY9QO0=; b=off8ceNI6V1+ZWwDElmc/Fxrgczr2Z7yD78xq+ZCwLdWY/q56q+CcT3E6DvyObvDWm EEoAjJvNuYbOHum8zL5enqhedniEY+UwWvVY99Iytt68MkHp55ugfYRfhMmSa/UMqQue 90t81HrVGUkVcXhC3o3EBsluIstP4s+qPRDuNLymI2fbwz/wlw/i/7LBOdueltcLo+DL NEWmVj1Wjxk/QXRBfB7t8Vahks9Zkzp8d3XuiIQyFM3ojhqbQZsFKMRS7Yl85XUThSRo xxgFmhsvrNR59UxcSbh1iwfS6n6eQZ12i086SlAPo1YLU4PNPfnq4NoeUChgmst5q+53 Fa7A== X-Gm-Message-State: AOAM532GA0Yq8WZEgg1pPoOeSJo/WWnfj6nV27aazPjCDhBQKfOtG3e9 USLdzRCOd9kyXy/ozUEMdhZEfcjL1W0= X-Google-Smtp-Source: ABdhPJzrfZJXwmqAifF26fj/gQn6kFUlKzxT6On6Iaf8irG4na4G4iK3mAJTIWo1H7s/v1Eotv4TeA== X-Received: by 2002:adf:cf0c:: with SMTP id o12mr54938782wrj.265.1594152762369; Tue, 07 Jul 2020 13:12:42 -0700 (PDT) Received: from phenom.ffwll.local ([2a02:168:57f4:0:efd0:b9e5:5ae6:c2fa]) by smtp.gmail.com with ESMTPSA id q7sm2515262wra.56.2020.07.07.13.12.40 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Tue, 07 Jul 2020 13:12:41 -0700 (PDT) From: Daniel Vetter To: DRI Development Subject: [PATCH 01/25] dma-fence: basic lockdep annotations Date: Tue, 7 Jul 2020 22:12:05 +0200 Message-Id: <20200707201229.472834-2-daniel.vetter@ffwll.ch> X-Mailer: git-send-email 2.27.0 In-Reply-To: <20200707201229.472834-1-daniel.vetter@ffwll.ch> References: <20200707201229.472834-1-daniel.vetter@ffwll.ch> 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: , Cc: =?UTF-8?q?Christian=20K=C3=B6nig?= , linux-rdma@vger.kernel.org, Daniel Vetter , Intel Graphics Development , amd-gfx@lists.freedesktop.org, Chris Wilson , linaro-mm-sig@lists.linaro.org, =?UTF-8?q?Thomas=20Hellstr=C3=B6m?= , Daniel Vetter , linux-media@vger.kernel.org, Felix Kuehling , Mika Kuoppala Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Errors-To: dri-devel-bounces@lists.freedesktop.org Sender: "dri-devel" RGVzaWduIGlzIHNpbWlsYXIgdG8gdGhlIGxvY2tkZXAgYW5ub3RhdGlvbnMgZm9yIHdvcmtlcnMs IGJ1dCB3aXRoCnNvbWUgdHdpc3RzOgoKLSBXZSB1c2UgYSByZWFkLWxvY2sgZm9yIHRoZSBleGVj dXRpb24vd29ya2VyL2NvbXBsZXRpb24gc2lkZSwgc28gdGhhdAogIHRoaXMgZXhwbGljaXQgYW5u b3RhdGlvbiBjYW4gYmUgbW9yZSBsaWJlcmFsbHkgc3ByaW5rbGVkIGFyb3VuZC4KICBXaXRoIHJl YWQgbG9ja3MgbG9ja2RlcCBpc24ndCBnb2luZyB0byBjb21wbGFpbiBpZiB0aGUgcmVhZC1zaWRl CiAgaXNuJ3QgbmVzdGVkIHRoZSBzYW1lIHdheSB1bmRlciBhbGwgY2lyY3Vtc3RhbmNlcywgc28g QUJCQSBkZWFkbG9ja3MKICBhcmUgb2suIFdoaWNoIHRoZXkgYXJlLCBzaW5jZSB0aGlzIGlzIGFu IGFubm90YXRpb24gb25seS4KCi0gV2UncmUgdXNpbmcgbm9uLXJlY3Vyc2l2ZSBsb2NrZGVwIHJl YWQgbG9jayBtb2RlLCBzaW5jZSBpbiByZWN1cnNpdmUKICByZWFkIGxvY2sgbW9kZSBsb2NrZGVw IGRvZXMgbm90IGNhdGNoIHJlYWQgc2lkZSBoYXphcmRzLiBBbmQgd2UKICBfdmVyeV8gbXVjaCB3 YW50IHJlYWQgc2lkZSBoYXphcmRzIHRvIGJlIGNhdWdodC4gRm9yIGZ1bGwgZGV0YWlscyBvZgog IHRoaXMgbGltaXRhdGlvbiBzZWUKCiAgY29tbWl0IGU5MTQ5ODU4OTc0NjA2NWUzYWU5NWQ5YTAw YjA2OGU1MjVlZWMzNGYKICBBdXRob3I6IFBldGVyIFppamxzdHJhIDxwZXRlcnpAaW5mcmFkZWFk Lm9yZz4KICBEYXRlOiAgIFdlZCBBdWcgMjMgMTM6MTM6MTEgMjAxNyArMDIwMAoKICAgICAgbG9j a2luZy9sb2NrZGVwL3NlbGZ0ZXN0czogQWRkIG1peGVkIHJlYWQtd3JpdGUgQUJCQSB0ZXN0cwoK LSBUbyBhbGxvdyBuZXN0aW5nIG9mIHRoZSByZWFkLXNpZGUgZXhwbGljaXQgYW5ub3RhdGlvbnMg d2UgZXhwbGljaXRseQogIGtlZXAgdHJhY2sgb2YgdGhlIG5lc3RpbmcuIGxvY2tfaXNfaGVsZCgp IGFsbG93cyB1cyB0byBkbyB0aGF0LgoKLSBUaGUgd2FpdC1zaWRlIGFubm90YXRpb24gaXMgYSB3 cml0ZSBsb2NrLCBhbmQgZW50aXJlbHkgZG9uZSB3aXRoaW4KICBkbWFfZmVuY2Vfd2FpdCgpIGZv ciBldmVyeW9uZSBieSBkZWZhdWx0LgoKLSBUbyBiZSBhYmxlIHRvIGZyZWVseSBhbm5vdGF0ZSBo ZWxwZXIgZnVuY3Rpb25zIEkgd2FudCB0byBtYWtlIGl0IG9rCiAgdG8gY2FsbCBkbWFfZmVuY2Vf YmVnaW4vZW5kX3NpZ25hbGxpbmcgZnJvbSBzb2Z0L2hhcmRpcnEgY29udGV4dC4KICBGaXJzdCBh dHRlbXB0IHdhcyB1c2luZyB0aGUgaGFyZGlycSBsb2NraW5nIGNvbnRleHQgZm9yIHRoZSB3cml0 ZQogIHNpZGUgaW4gbG9ja2RlcCwgYnV0IHRoaXMgZm9yY2VzIGFsbCBub3JtYWwgc3BpbmxvY2tz IG5lc3RlZCB3aXRoaW4KICBkbWFfZmVuY2VfYmVnaW4vZW5kX3NpZ25hbGxpbmcgdG8gYmUgc3Bp bmxvY2tzLiBUaGF0IGJvbGxvY2tzLgoKICBUaGUgYXBwcm9hY2ggbm93IGlzIHRvIHNpbXBsZSBj aGVjayBpbl9hdG9taWMoKSwgYW5kIGZvciB0aGVzZSBjYXNlcwogIGVudGlyZWx5IHJlbHkgb24g dGhlIG1pZ2h0X3NsZWVwKCkgY2hlY2sgaW4gZG1hX2ZlbmNlX3dhaXQoKS4gVGhhdAogIHdpbGwg Y2F0Y2ggYW55IHdyb25nIG5lc3RpbmcgYWdhaW5zdCBzcGlubG9ja3MgZnJvbSBzb2Z0L2hhcmRp cnEKICBjb250ZXh0cy4KClRoZSBpZGVhIGhlcmUgaXMgdGhhdCBldmVyeSBjb2RlIHBhdGggdGhh dCdzIGNyaXRpY2FsIGZvciBldmVudHVhbGx5CnNpZ25hbGxpbmcgYSBkbWFfZmVuY2Ugc2hvdWxk IGJlIGFubm90YXRlZCB3aXRoCmRtYV9mZW5jZV9iZWdpbi9lbmRfc2lnbmFsbGluZy4gVGhlIGFu bm90YXRpb24gaWRlYWxseSBzdGFydHMgcmlnaHQKYWZ0ZXIgYSBkbWFfZmVuY2UgaXMgcHVibGlz aGVkIChhZGRlZCB0byBhIGRtYV9yZXN2LCBleHBvc2VkIGFzIGEKc3luY19maWxlIGZkLCBhdHRh Y2hlZCB0byBhIGRybV9zeW5jb2JqIGZkLCBvciBhbnl0aGluZyBlbHNlIHRoYXQKbWFrZXMgdGhl IGRtYV9mZW5jZSB2aXNpYmxlIHRvIG90aGVyIGtlcm5lbCB0aHJlYWRzKSwgdXAgdG8gYW5kCmlu Y2x1ZGluZyB0aGUgZG1hX2ZlbmNlX3dhaXQoKS4gRXhhbXBsZXMgYXJlIGlycSBoYW5kbGVycywg dGhlCnNjaGVkdWxlciBydCB0aHJlYWRzLCB0aGUgdGFpbCBvZiBleGVjYnVmIChhZnRlciB0aGUg Y29ycmVzcG9uZGluZwpmZW5jZXMgYXJlIHZpc2libGUpLCBhbnkgd29ya2VycyB0aGF0IGVuZCB1 cCBzaWduYWxsaW5nIGRtYV9mZW5jZXMgYW5kCnJlYWxseSBhbnl0aGluZyBlbHNlLiBOb3QgYW5u b3RhdGVkIHNob3VsZCBiZSBjb2RlIHBhdGhzIHRoYXQgb25seQpjb21wbGV0ZSBmZW5jZXMgb3Bw b3J0dW5pc3RpY2FsbHkgYXMgdGhlIGdwdSBwcm9ncmVzc2VzLCBsaWtlIGUuZy4Kc2hyaW5rZXIv ZXZpY3Rpb24gY29kZS4KClRoZSBtYWluIGNsYXNzIG9mIGRlYWRsb2NrcyB0aGlzIGlzIHN1cHBv c2VkIHRvIGNhdGNoIGFyZToKClRocmVhZCBBOgoKCW11dGV4X2xvY2soQSk7CgltdXRleF91bmxv Y2soQSk7CgoJZG1hX2ZlbmNlX3NpZ25hbCgpOwoKVGhyZWFkIEI6CgoJbXV0ZXhfbG9jayhBKTsK CWRtYV9mZW5jZV93YWl0KCk7CgltdXRleF91bmxvY2soQSk7CgpUaHJlYWQgQiBpcyBibG9ja2Vk IG9uIEEgc2lnbmFsbGluZyB0aGUgZmVuY2UsIGJ1dCBBIG5ldmVyIGdldHMgYXJvdW5kCnRvIHRo YXQgYmVjYXVzZSBpdCBjYW5ub3QgYWNxdWlyZSB0aGUgbG9jayBBLgoKTm90ZSB0aGF0IGRtYV9m ZW5jZV93YWl0KCkgaXMgYWxsb3dlZCB0byBiZSBuZXN0ZWQgd2l0aGluCmRtYV9mZW5jZV9iZWdp bi9lbmRfc2lnbmFsbGluZyBzZWN0aW9ucy4gVG8gYWxsb3cgdGhpcyB0byBoYXBwZW4gdGhlCnJl YWQgbG9jayBuZWVkcyB0byBiZSB1cGdyYWRlZCB0byBhIHdyaXRlIGxvY2ssIHdoaWNoIG1lYW5z IHRoYXQgYW55Cm90aGVyIGxvY2sgaXMgYWNxdWlyZWQgYmV0d2VlbiB0aGUgZG1hX2ZlbmNlX2Jl Z2luX3NpZ25hbGxpbmcoKSBjYWxsIGFuZAp0aGUgY2FsbCB0byBkbWFfZmVuY2Vfd2FpdCgpLCBh bmQgc3RpbGwgaGVsZCwgdGhpcyB3aWxsIHJlc3VsdCBpbiBhbgppbW1lZGlhdGUgbG9ja2RlcCBj b21wbGFpbnQuIFRoZSBvbmx5IG90aGVyIG9wdGlvbiB3b3VsZCBiZSB0byBub3QKYW5ub3RhdGUg c3VjaCBjYWxscywgZGVmZWF0aW5nIHRoZSBwb2ludC4gVGhlcmVmb3JlIHRoZXNlIGFubm90YXRp b25zCmNhbm5vdCBiZSBzcHJpbmtsZWQgb3ZlciB0aGUgY29kZSBlbnRpcmVseSBtaW5kbGVzcyB0 byBhdm9pZCBmYWxzZQpwb3NpdGl2ZXMuCgpPcmlnaW5hbGx5IEkgaG9wZSB0aGF0IHRoZSBjcm9z cy1yZWxlYXNlIGxvY2tkZXAgZXh0ZW5zaW9ucyB3b3VsZAphbGxldmlhdGUgdGhlIG5lZWQgZm9y IGV4cGxpY2l0IGFubm90YXRpb25zOgoKaHR0cHM6Ly9sd24ubmV0L0FydGljbGVzLzcwOTg0OS8K CkJ1dCB0aGVyZSdzIGEgZmV3IHJlYXNvbnMgd2h5IHRoYXQncyBub3QgYW4gb3B0aW9uOgoKLSBJ dCdzIG5vdCBoYXBwZW5pbmcgaW4gdXBzdHJlYW0sIHNpbmNlIGl0IGdvdCByZXZlcnRlZCBkdWUg dG8gdG9vCiAgbWFueSBmYWxzZSBwb3NpdGl2ZXM6CgoJY29tbWl0IGU5NjZlYWVlYjYyM2YwOTk3 NWVmMzYyYzI4NjZmYWU2Zjg2ODQ0ZjkKCUF1dGhvcjogSW5nbyBNb2xuYXIgPG1pbmdvQGtlcm5l bC5vcmc+CglEYXRlOiAgIFR1ZSBEZWMgMTIgMTI6MzE6MTYgMjAxNyArMDEwMAoKCSAgICBsb2Nr aW5nL2xvY2tkZXA6IFJlbW92ZSB0aGUgY3Jvc3MtcmVsZWFzZSBsb2NraW5nIGNoZWNrcwoKCSAg ICBUaGlzIGNvZGUgKENPTkZJR19MT0NLREVQX0NST1NTUkVMRUFTRT15IGFuZCBDT05GSUdfTE9D S0RFUF9DT01QTEVUSU9OUz15KSwKCSAgICB3aGlsZSBpdCBmb3VuZCBhIG51bWJlciBvZiBvbGQg YnVncyBpbml0aWFsbHksIHdhcyBhbHNvIGNhdXNpbmcgdG9vIG1hbnkKCSAgICBmYWxzZSBwb3Np dGl2ZXMgdGhhdCBjYXVzZWQgcGVvcGxlIHRvIGRpc2FibGUgbG9ja2RlcCAtIHdoaWNoIGlzIGFy Z3VhYmx5CgkgICAgYSB3b3JzZSBvdmVyYWxsIG91dGNvbWUuCgotIGNyb3NzLXJlbGVhc2UgdXNl cyB0aGUgY29tcGxldGUoKSBjYWxsIHRvIGFubm90YXRlIHRoZSBlbmQgb2YKICBjcml0aWNhbCBz ZWN0aW9ucywgZm9yIGRtYV9mZW5jZSB0aGF0IHdvdWxkIGJlIGRtYV9mZW5jZV9zaWduYWwoKS4K ICBCdXQgd2UgZG8gbm90IHdhbnQgYWxsIGRtYV9mZW5jZV9zaWduYWwoKSBjYWxscyB0byBiZSB0 cmVhdGVkIGFzCiAgY3JpdGljYWwsIHNpbmNlIG1hbnkgYXJlIG9wcG9ydHVuaXN0aWMgY2xlYW51 cCBvZiBncHUgcmVxdWVzdHMuIElmCiAgdGhlc2UgZ2V0IHN0dWNrIHRoZXJlJ3Mgc3RpbGwgdGhl IG1haW4gY29tcGxldGlvbiBpbnRlcnJ1cHQgYW5kCiAgd29ya2VycyB3aG8gY2FuIHVuYmxvY2sg ZXZlcnlvbmUuIEF1dG9tYXRpY2FsbHkgYW5ub3RhdGluZyBhbGwKICBkbWFfZmVuY2Vfc2lnbmFs KCkgY2FsbHMgd291bGQgaGVuY2UgY2F1c2UgZmFsc2UgcG9zaXRpdmVzLgoKLSBjcm9zcy1yZWxl YXNlIGhhZCBzb21lIGVkdWNhdGVkIGd1ZXNzZXMgZm9yIHdoZW4gYSBjcml0aWNhbCBzZWN0aW9u CiAgc3RhcnRzLCBsaWtlIGZyZXNoIHN5c2NhbGwgb3IgZnJlc2ggd29yayBjYWxsYmFjay4gVGhp cyB3b3VsZCBhZ2FpbgogIGNhdXNlIGZhbHNlIHBvc2l0aXZlcyB3aXRob3V0IGV4cGxpY2l0IGFu bm90YXRpb25zLCBzaW5jZSBmb3IKICBkbWFfZmVuY2UgdGhlIGNyaXRpY2FsIHNlY3Rpb25zIG9u bHkgc3RhcnRzIHdoZW4gd2UgcHVibGlzaCBhIGZlbmNlLgoKLSBGdXJ0aGVybW9yZSB0aGVyZSBj YW4gYmUgY2FzZXMgd2hlcmUgYSB0aHJlYWQgbmV2ZXIgZG9lcyBhCiAgZG1hX2ZlbmNlX3NpZ25h bCwgYnV0IGlzIHN0aWxsIGNyaXRpY2FsIGZvciByZWFjaGluZyBjb21wbGV0aW9uIG9mCiAgZmVu Y2VzLiBPbmUgZXhhbXBsZSB3b3VsZCBiZSBhIHNjaGVkdWxlciBrdGhyZWFkIHdoaWNoIHBpY2tz IHVwIGpvYnMKICBhbmQgcHVzaGVzIHRoZW0gaW50byBoYXJkd2FyZSwgd2hlcmUgdGhlIGludGVy cnVwdCBoYW5kbGVyIG9yCiAgYW5vdGhlciBjb21wbGV0aW9uIHRocmVhZCBjYWxscyBkbWFfZmVu Y2Vfc2lnbmFsKCkuIEJ1dCBpZiB0aGUKICBzY2hlZHVsZXIgdGhyZWFkIGhhbmdzLCB0aGVuIGFs bCB0aGUgZmVuY2VzIGhhbmcsIGhlbmNlIHdlIG5lZWQgdG8KICBtYW51YWxseSBhbm5vdGF0ZSBp dC4gY3Jvc3MtcmVsZWFzZSBhaW1lZCB0byBzb2x2ZSB0aGlzIGJ5IGNoYWluaW5nCiAgY3Jvc3Mt cmVsZWFzZSBkZXBlbmRlbmNpZXMsIGJ1dCB0aGUgZGVwZW5kZW5jeSBmcm9tIHNjaGVkdWxlciB0 aHJlYWQKICB0byB0aGUgY29tcGxldGlvbiBpbnRlcnJ1cHQgaGFuZGxlciBnb2VzIHRocm91Z2gg aHcgd2hlcmUKICBjcm9zcy1yZWxlYXNlIGNvZGUgY2FuJ3Qgb2JzZXJ2ZSBpdC4KCkluIHNob3J0 LCB3aXRob3V0IG1hbnVhbCBhbm5vdGF0aW9ucyBhbmQgY2FyZWZ1bCByZXZpZXcgb2YgdGhlIHN0 YXJ0CmFuZCBlbmQgb2YgY3JpdGljYWwgc2VjdGlvbnMsIGNyb3NzLXJlbGVzZSBkZXBlbmRlbmN5 IHRyYWNraW5nIGRvZXNuJ3QKd29yay4gV2UgbmVlZCBleHBsaWNpdCBhbm5vdGF0aW9ucy4KCnYy OiBoYW5kbGUgc29mdC9oYXJkaXJxIGN0eCBiZXR0ZXIgYWdhaW5zdCB3cml0ZSBzaWRlIGFuZCBk b250IGZvcmdldApFWFBPUlRfU1lNQk9MLCBkcml2ZXJzIGNhbid0IHVzZSB0aGlzIG90aGVyd2lz ZS4KCnYzOiBLZXJuZWxkb2MuCgp2NDogU29tZSBzcGVsbGluZyBmaXhlcyBmcm9tIE1pa2EKCnY1 OiBBbWVuZCBjb21taXQgbWVzc2FnZSB0byBleHBsYWluIGluIGRldGFpbCB3aHkgY3Jvc3MtcmVs ZWFzZSBpc24ndAp0aGUgc29sdXRpb24uCgp2NjogUHVsbCBvdXQgbWlzcGxhY2VkIC5yc3QgaHVu ay4KCkNjOiBGZWxpeCBLdWVobGluZyA8RmVsaXguS3VlaGxpbmdAYW1kLmNvbT4KUmV2aWV3ZWQt Ynk6IFRob21hcyBIZWxsc3Ryw7ZtIDx0aG9tYXMuaGVsbHN0cm9tQGludGVsLmNvbT4KUmV2aWV3 ZWQtYnk6IE1hYXJ0ZW4gTGFua2hvcnN0IDxtYWFydGVuLmxhbmtob3JzdEBsaW51eC5pbnRlbC5j b20+CkNjOiBNaWthIEt1b3BwYWxhIDxtaWthLmt1b3BwYWxhQGludGVsLmNvbT4KQ2M6IFRob21h cyBIZWxsc3Ryb20gPHRob21hcy5oZWxsc3Ryb21AaW50ZWwuY29tPgpDYzogbGludXgtbWVkaWFA dmdlci5rZXJuZWwub3JnCkNjOiBsaW5hcm8tbW0tc2lnQGxpc3RzLmxpbmFyby5vcmcKQ2M6IGxp bnV4LXJkbWFAdmdlci5rZXJuZWwub3JnCkNjOiBhbWQtZ2Z4QGxpc3RzLmZyZWVkZXNrdG9wLm9y ZwpDYzogaW50ZWwtZ2Z4QGxpc3RzLmZyZWVkZXNrdG9wLm9yZwpDYzogQ2hyaXMgV2lsc29uIDxj aHJpc0BjaHJpcy13aWxzb24uY28udWs+CkNjOiBNYWFydGVuIExhbmtob3JzdCA8bWFhcnRlbi5s YW5raG9yc3RAbGludXguaW50ZWwuY29tPgpDYzogQ2hyaXN0aWFuIEvDtm5pZyA8Y2hyaXN0aWFu LmtvZW5pZ0BhbWQuY29tPgpTaWduZWQtb2ZmLWJ5OiBEYW5pZWwgVmV0dGVyIDxkYW5pZWwudmV0 dGVyQGludGVsLmNvbT4KLS0tCiBEb2N1bWVudGF0aW9uL2RyaXZlci1hcGkvZG1hLWJ1Zi5yc3Qg fCAgIDYgKwogZHJpdmVycy9kbWEtYnVmL2RtYS1mZW5jZS5jICAgICAgICAgIHwgMTYxICsrKysr KysrKysrKysrKysrKysrKysrKysrKwogaW5jbHVkZS9saW51eC9kbWEtZmVuY2UuaCAgICAgICAg ICAgIHwgIDEyICsrCiAzIGZpbGVzIGNoYW5nZWQsIDE3OSBpbnNlcnRpb25zKCspCgpkaWZmIC0t Z2l0IGEvRG9jdW1lbnRhdGlvbi9kcml2ZXItYXBpL2RtYS1idWYucnN0IGIvRG9jdW1lbnRhdGlv bi9kcml2ZXItYXBpL2RtYS1idWYucnN0CmluZGV4IDdmYjdiNjYxZmViZC4uMDVkODU2MTMxMTQw IDEwMDY0NAotLS0gYS9Eb2N1bWVudGF0aW9uL2RyaXZlci1hcGkvZG1hLWJ1Zi5yc3QKKysrIGIv RG9jdW1lbnRhdGlvbi9kcml2ZXItYXBpL2RtYS1idWYucnN0CkBAIC0xMzMsNiArMTMzLDEyIEBA IERNQSBGZW5jZXMKIC4uIGtlcm5lbC1kb2M6OiBkcml2ZXJzL2RtYS1idWYvZG1hLWZlbmNlLmMK ICAgIDpkb2M6IERNQSBmZW5jZXMgb3ZlcnZpZXcKIAorRE1BIEZlbmNlIFNpZ25hbGxpbmcgQW5u b3RhdGlvbnMKK35+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+CisKKy4uIGtlcm5lbC1k b2M6OiBkcml2ZXJzL2RtYS1idWYvZG1hLWZlbmNlLmMKKyAgIDpkb2M6IGZlbmNlIHNpZ25hbGxp bmcgYW5ub3RhdGlvbgorCiBETUEgRmVuY2VzIEZ1bmN0aW9ucyBSZWZlcmVuY2UKIH5+fn5+fn5+ fn5+fn5+fn5+fn5+fn5+fn5+fn5+fgogCmRpZmYgLS1naXQgYS9kcml2ZXJzL2RtYS1idWYvZG1h LWZlbmNlLmMgYi9kcml2ZXJzL2RtYS1idWYvZG1hLWZlbmNlLmMKaW5kZXggNjU2ZTlhYzJkMDI4 Li4wMDA1YmMwMDI1MjkgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvZG1hLWJ1Zi9kbWEtZmVuY2UuYwor KysgYi9kcml2ZXJzL2RtYS1idWYvZG1hLWZlbmNlLmMKQEAgLTExMCw2ICsxMTAsMTYwIEBAIHU2 NCBkbWFfZmVuY2VfY29udGV4dF9hbGxvYyh1bnNpZ25lZCBudW0pCiB9CiBFWFBPUlRfU1lNQk9M KGRtYV9mZW5jZV9jb250ZXh0X2FsbG9jKTsKIAorLyoqCisgKiBET0M6IGZlbmNlIHNpZ25hbGxp bmcgYW5ub3RhdGlvbgorICoKKyAqIFByb3ZpbmcgY29ycmVjdG5lc3Mgb2YgYWxsIHRoZSBrZXJu ZWwgY29kZSBhcm91bmQgJmRtYV9mZW5jZSB0aHJvdWdoIGNvZGUKKyAqIHJldmlldyBhbmQgdGVz dGluZyBpcyB0cmlja3kgZm9yIGEgZmV3IHJlYXNvbnM6CisgKgorICogKiBJdCBpcyBhIGNyb3Nz LWRyaXZlciBjb250cmFjdCwgYW5kIHRoZXJlZm9yZSBhbGwgZHJpdmVycyBtdXN0IGZvbGxvdyB0 aGUKKyAqICAgc2FtZSBydWxlcyBmb3IgbG9jayBuZXN0aW5nIG9yZGVyLCBjYWxsaW5nIGNvbnRl eHRzIGZvciB2YXJpb3VzIGZ1bmN0aW9ucworICogICBhbmQgYW55dGhpbmcgZWxzZSBzaWduaWZp Y2FudCBmb3IgaW4ta2VybmVsIGludGVyZmFjZXMuIEJ1dCBpdCBpcyBhbHNvCisgKiAgIGltcG9z c2libGUgdG8gdGVzdCBhbGwgZHJpdmVycyBpbiBhIHNpbmdsZSBtYWNoaW5lLCBoZW5jZSBicnV0 ZS1mb3JjZSBOIHZzLgorICogICBOIHRlc3Rpbmcgb2YgYWxsIGNvbWJpbmF0aW9ucyBpcyBpbXBv c3NpYmxlLiBFdmVuIGp1c3QgbGltaXRpbmcgdG8gdGhlCisgKiAgIHBvc3NpYmxlIGNvbWJpbmF0 aW9ucyBpcyBpbmZlYXNpYmxlLgorICoKKyAqICogVGhlcmUgaXMgYW4gZW5vcm1vdXMgYW1vdW50 IG9mIGRyaXZlciBjb2RlIGludm9sdmVkLiBGb3IgcmVuZGVyIGRyaXZlcnMKKyAqICAgdGhlcmUn cyB0aGUgdGFpbCBvZiBjb21tYW5kIHN1Ym1pc3Npb24sIGFmdGVyIGZlbmNlcyBhcmUgcHVibGlz aGVkLAorICogICBzY2hlZHVsZXIgY29kZSwgaW50ZXJydXB0IGFuZCB3b3JrZXJzIHRvIHByb2Nl c3Mgam9iIGNvbXBsZXRpb24sCisgKiAgIGFuZCB0aW1lb3V0LCBncHUgcmVzZXQgYW5kIGdwdSBo YW5nIHJlY292ZXJ5IGNvZGUuIFBsdXMgZm9yIGludGVncmF0aW9uCisgKiAgIHdpdGggY29yZSBt bSB3aXRoIGhhdmUgJm1tdV9ub3RpZmllciwgcmVzcGVjdGl2ZWx5ICZtbXVfaW50ZXJ2YWxfbm90 aWZpZXIsCisgKiAgIGFuZCAmc2hyaW5rZXIuIEZvciBtb2Rlc2V0dGluZyBkcml2ZXJzIHRoZXJl J3MgdGhlIGNvbW1pdCB0YWlsIGZ1bmN0aW9ucworICogICBiZXR3ZWVuIHdoZW4gZmVuY2VzIGZv ciBhbiBhdG9taWMgbW9kZXNldCBhcmUgcHVibGlzaGVkLCBhbmQgd2hlbiB0aGUKKyAqICAgY29y cmVzcG9uZGluZyB2YmxhbmsgY29tcGxldGVzLCBpbmNsdWRpbmcgYW55IGludGVycnVwdCBwcm9j ZXNzaW5nIGFuZAorICogICByZWxhdGVkIHdvcmtlcnMuIEF1ZGl0aW5nIGFsbCB0aGF0IGNvZGUs IGFjcm9zcyBhbGwgZHJpdmVycywgaXMgbm90CisgKiAgIGZlYXNpYmxlLgorICoKKyAqICogRHVl IHRvIGhvdyBtYW55IG90aGVyIHN1YnN5c3RlbXMgYXJlIGludm9sdmVkIGFuZCB0aGUgbG9ja2lu ZyBoaWVyYXJjaGllcworICogICB0aGlzIHB1bGxzIGluIHRoZXJlIGlzIGV4dHJlbWVseSB0aGlu IHdpZ2dsZS1yb29tIGZvciBkcml2ZXItc3BlY2lmaWMKKyAqICAgZGlmZmVyZW5jZXMuICZkbWFf ZmVuY2UgaW50ZXJhY3RzIHdpdGggYWxtb3N0IGFsbCBvZiB0aGUgY29yZSBtZW1vcnkKKyAqICAg aGFuZGxpbmcgdGhyb3VnaCBwYWdlIGZhdWx0IGhhbmRsZXJzIHZpYSAmZG1hX3Jlc3YsIGRtYV9y ZXN2X2xvY2soKSBhbmQKKyAqICAgZG1hX3Jlc3ZfdW5sb2NrKCkuIE9uIHRoZSBvdGhlciBzaWRl IGl0IGFsc28gaW50ZXJhY3RzIHRocm91Z2ggYWxsCisgKiAgIGFsbG9jYXRpb24gc2l0ZXMgdGhy b3VnaCAmbW11X25vdGlmaWVyIGFuZCAmc2hyaW5rZXIuCisgKgorICogRnVydGhlcm1vcmUgbG9j a2RlcCBkb2VzIG5vdCBoYW5kbGUgY3Jvc3MtcmVsZWFzZSBkZXBlbmRlbmNpZXMsIHdoaWNoIG1l YW5zCisgKiBhbnkgZGVhZGxvY2tzIGJldHdlZW4gZG1hX2ZlbmNlX3dhaXQoKSBhbmQgZG1hX2Zl bmNlX3NpZ25hbCgpIGNhbid0IGJlIGNhdWdodAorICogYXQgcnVudGltZSB3aXRoIHNvbWUgcXVp Y2sgdGVzdGluZy4gVGhlIHNpbXBsZXN0IGV4YW1wbGUgaXMgb25lIHRocmVhZAorICogd2FpdGlu ZyBvbiBhICZkbWFfZmVuY2Ugd2hpbGUgaG9sZGluZyBhIGxvY2s6OgorICoKKyAqICAgICBsb2Nr KEEpOworICogICAgIGRtYV9mZW5jZV93YWl0KEIpOworICogICAgIHVubG9jayhBKTsKKyAqCisg KiB3aGlsZSB0aGUgb3RoZXIgdGhyZWFkIGlzIHN0dWNrIHRyeWluZyB0byBhY3F1aXJlIHRoZSBz YW1lIGxvY2ssIHdoaWNoCisgKiBwcmV2ZW50cyBpdCBmcm9tIHNpZ25hbGxpbmcgdGhlIGZlbmNl IHRoZSBwcmV2aW91cyB0aHJlYWQgaXMgc3R1Y2sgd2FpdGluZworICogb246OgorICoKKyAqICAg ICBsb2NrKEEpOworICogICAgIHVubG9jayhBKTsKKyAqICAgICBkbWFfZmVuY2Vfc2lnbmFsKEIp OworICoKKyAqIEJ5IG1hbnVhbGx5IGFubm90YXRpbmcgYWxsIGNvZGUgcmVsZXZhbnQgdG8gc2ln bmFsbGluZyBhICZkbWFfZmVuY2Ugd2UgY2FuCisgKiB0ZWFjaCBsb2NrZGVwIGFib3V0IHRoZXNl IGRlcGVuZGVuY2llcywgd2hpY2ggYWxzbyBoZWxwcyB3aXRoIHRoZSB2YWxpZGF0aW9uCisgKiBo ZWFkYWNoZSBzaW5jZSBub3cgbG9ja2RlcCBjYW4gY2hlY2sgYWxsIHRoZSBydWxlcyBmb3IgdXM6 OgorICoKKyAqICAgIGNvb2tpZSA9IGRtYV9mZW5jZV9iZWdpbl9zaWduYWxsaW5nKCk7CisgKiAg ICBsb2NrKEEpOworICogICAgdW5sb2NrKEEpOworICogICAgZG1hX2ZlbmNlX3NpZ25hbChCKTsK KyAqICAgIGRtYV9mZW5jZV9lbmRfc2lnbmFsbGluZyhjb29raWUpOworICoKKyAqIEZvciB1c2lu ZyBkbWFfZmVuY2VfYmVnaW5fc2lnbmFsbGluZygpIGFuZCBkbWFfZmVuY2VfZW5kX3NpZ25hbGxp bmcoKSB0bworICogYW5ub3RhdGUgY3JpdGljYWwgc2VjdGlvbnMgdGhlIGZvbGxvd2luZyBydWxl cyBuZWVkIHRvIGJlIG9ic2VydmVkOgorICoKKyAqICogQWxsIGNvZGUgbmVjZXNzYXJ5IHRvIGNv bXBsZXRlIGEgJmRtYV9mZW5jZSBtdXN0IGJlIGFubm90YXRlZCwgZnJvbSB0aGUKKyAqICAgcG9p bnQgd2hlcmUgYSBmZW5jZSBpcyBhY2Nlc3NpYmxlIHRvIG90aGVyIHRocmVhZHMsIHRvIHRoZSBw b2ludCB3aGVyZQorICogICBkbWFfZmVuY2Vfc2lnbmFsKCkgaXMgY2FsbGVkLiBVbi1hbm5vdGF0 ZWQgY29kZSBjYW4gY29udGFpbiBkZWFkbG9jayBpc3N1ZXMsCisgKiAgIGFuZCBkdWUgdG8gdGhl IHZlcnkgc3RyaWN0IHJ1bGVzIGFuZCBtYW55IGNvcm5lciBjYXNlcyBpdCBpcyBpbmZlYXNpYmxl IHRvCisgKiAgIGNhdGNoIHRoZXNlIGp1c3Qgd2l0aCByZXZpZXcgb3Igbm9ybWFsIHN0cmVzcyB0 ZXN0aW5nLgorICoKKyAqICogJnN0cnVjdCBkbWFfcmVzdiBkZXNlcnZlcyBhIHNwZWNpYWwgbm90 ZSwgc2luY2UgdGhlIHJlYWRlcnMgYXJlIG9ubHkKKyAqICAgcHJvdGVjdGVkIGJ5IHJjdS4gVGhp cyBtZWFucyB0aGUgc2lnbmFsbGluZyBjcml0aWNhbCBzZWN0aW9uIHN0YXJ0cyBhcyBzb29uCisg KiAgIGFzIHRoZSBuZXcgZmVuY2VzIGFyZSBpbnN0YWxsZWQsIGV2ZW4gYmVmb3JlIGRtYV9yZXN2 X3VubG9jaygpIGlzIGNhbGxlZC4KKyAqCisgKiAqIFRoZSBvbmx5IGV4Y2VwdGlvbiBhcmUgZmFz dCBwYXRocyBhbmQgb3Bwb3J0dW5pc3RpYyBzaWduYWxsaW5nIGNvZGUsIHdoaWNoCisgKiAgIGNh bGxzIGRtYV9mZW5jZV9zaWduYWwoKSBwdXJlbHkgYXMgYW4gb3B0aW1pemF0aW9uLCBidXQgaXMg bm90IHJlcXVpcmVkIHRvCisgKiAgIGd1YXJhbnRlZSBjb21wbGV0aW9uIG9mIGEgJmRtYV9mZW5j ZS4gVGhlIHVzdWFsIGV4YW1wbGUgaXMgYSB3YWl0IElPQ1RMCisgKiAgIHdoaWNoIGNhbGxzIGRt YV9mZW5jZV9zaWduYWwoKSwgd2hpbGUgdGhlIG1hbmRhdG9yeSBjb21wbGV0aW9uIHBhdGggZ29l cworICogICB0aHJvdWdoIGEgaGFyZHdhcmUgaW50ZXJydXB0IGFuZCBwb3NzaWJsZSBqb2IgY29t cGxldGlvbiB3b3JrZXIuCisgKgorICogKiBUbyBhaWQgY29tcG9zYWJpbGl0eSBvZiBjb2RlLCB0 aGUgYW5ub3RhdGlvbnMgY2FuIGJlIGZyZWVseSBuZXN0ZWQsIGFzIGxvbmcKKyAqICAgYXMgdGhl IG92ZXJhbGwgbG9ja2luZyBoaWVyYXJjaHkgaXMgY29uc2lzdGVudC4gVGhlIGFubm90YXRpb25z IGFsc28gd29yaworICogICBib3RoIGluIGludGVycnVwdCBhbmQgcHJvY2VzcyBjb250ZXh0LiBE dWUgdG8gaW1wbGVtZW50YXRpb24gZGV0YWlscyB0aGlzCisgKiAgIHJlcXVpcmVzIHRoYXQgY2Fs bGVycyBwYXNzIGFuIG9wYXF1ZSBjb29raWUgZnJvbQorICogICBkbWFfZmVuY2VfYmVnaW5fc2ln bmFsbGluZygpIHRvIGRtYV9mZW5jZV9lbmRfc2lnbmFsbGluZygpLgorICoKKyAqICogVmFsaWRh dGlvbiBhZ2FpbnN0IHRoZSBjcm9zcyBkcml2ZXIgY29udHJhY3QgaXMgaW1wbGVtZW50ZWQgYnkg cHJpbWluZworICogICBsb2NrZGVwIHdpdGggdGhlIHJlbGV2YW50IGhpZXJhcmNoeSBhdCBib290 LXVwLiBUaGlzIG1lYW5zIGV2ZW4ganVzdAorICogICB0ZXN0aW5nIHdpdGggYSBzaW5nbGUgZGV2 aWNlIGlzIGVub3VnaCB0byB2YWxpZGF0ZSBhIGRyaXZlciwgYXQgbGVhc3QgYXMKKyAqICAgZmFy IGFzIGRlYWRsb2NrcyB3aXRoIGRtYV9mZW5jZV93YWl0KCkgYWdhaW5zdCBkbWFfZmVuY2Vfc2ln bmFsKCkgYXJlCisgKiAgIGNvbmNlcm5lZC4KKyAqLworI2lmZGVmIENPTkZJR19MT0NLREVQCitz dHJ1Y3QgbG9ja2RlcF9tYXAJZG1hX2ZlbmNlX2xvY2tkZXBfbWFwID0geworCS5uYW1lID0gImRt YV9mZW5jZV9tYXAiCit9OworCisvKioKKyAqIGRtYV9mZW5jZV9iZWdpbl9zaWduYWxsaW5nIC0g YmVnaW4gYSBjcml0aWNhbCBETUEgZmVuY2Ugc2lnbmFsbGluZyBzZWN0aW9uCisgKgorICogRHJp dmVycyBzaG91bGQgdXNlIHRoaXMgdG8gYW5ub3RhdGUgdGhlIGJlZ2lubmluZyBvZiBhbnkgY29k ZSBzZWN0aW9uCisgKiByZXF1aXJlZCB0byBldmVudHVhbGx5IGNvbXBsZXRlICZkbWFfZmVuY2Ug YnkgY2FsbGluZyBkbWFfZmVuY2Vfc2lnbmFsKCkuCisgKgorICogVGhlIGVuZCBvZiB0aGVzZSBj cml0aWNhbCBzZWN0aW9ucyBhcmUgYW5ub3RhdGVkIHdpdGgKKyAqIGRtYV9mZW5jZV9lbmRfc2ln bmFsbGluZygpLgorICoKKyAqIFJldHVybnM6CisgKgorICogT3BhcXVlIGNvb2tpZSBuZWVkZWQg YnkgdGhlIGltcGxlbWVudGF0aW9uLCB3aGljaCBuZWVkcyB0byBiZSBwYXNzZWQgdG8KKyAqIGRt YV9mZW5jZV9lbmRfc2lnbmFsbGluZygpLgorICovCitib29sIGRtYV9mZW5jZV9iZWdpbl9zaWdu YWxsaW5nKHZvaWQpCit7CisJLyogZXhwbGljaXRseSBuZXN0aW5nIC4uLiAqLworCWlmIChsb2Nr X2lzX2hlbGRfdHlwZSgmZG1hX2ZlbmNlX2xvY2tkZXBfbWFwLCAxKSkKKwkJcmV0dXJuIHRydWU7 CisKKwkvKiByZWx5IG9uIG1pZ2h0X3NsZWVwIGNoZWNrIGZvciBzb2Z0L2hhcmRpcnEgbG9ja3Mg Ki8KKwlpZiAoaW5fYXRvbWljKCkpCisJCXJldHVybiB0cnVlOworCisJLyogLi4uIGFuZCBub24t cmVjdXJzaXZlIHJlYWRsb2NrICovCisJbG9ja19hY3F1aXJlKCZkbWFfZmVuY2VfbG9ja2RlcF9t YXAsIDAsIDAsIDEsIDEsIE5VTEwsIF9SRVRfSVBfKTsKKworCXJldHVybiBmYWxzZTsKK30KK0VY UE9SVF9TWU1CT0woZG1hX2ZlbmNlX2JlZ2luX3NpZ25hbGxpbmcpOworCisvKioKKyAqIGRtYV9m ZW5jZV9lbmRfc2lnbmFsbGluZyAtIGVuZCBhIGNyaXRpY2FsIERNQSBmZW5jZSBzaWduYWxsaW5n IHNlY3Rpb24KKyAqCisgKiBDbG9zZXMgYSBjcml0aWNhbCBzZWN0aW9uIGFubm90YXRpb24gb3Bl bmVkIGJ5IGRtYV9mZW5jZV9iZWdpbl9zaWduYWxsaW5nKCkuCisgKi8KK3ZvaWQgZG1hX2ZlbmNl X2VuZF9zaWduYWxsaW5nKGJvb2wgY29va2llKQoreworCWlmIChjb29raWUpCisJCXJldHVybjsK KworCWxvY2tfcmVsZWFzZSgmZG1hX2ZlbmNlX2xvY2tkZXBfbWFwLCBfUkVUX0lQXyk7Cit9CitF WFBPUlRfU1lNQk9MKGRtYV9mZW5jZV9lbmRfc2lnbmFsbGluZyk7CisKK3ZvaWQgX19kbWFfZmVu Y2VfbWlnaHRfd2FpdCh2b2lkKQoreworCWJvb2wgdG1wOworCisJdG1wID0gbG9ja19pc19oZWxk X3R5cGUoJmRtYV9mZW5jZV9sb2NrZGVwX21hcCwgMSk7CisJaWYgKHRtcCkKKwkJbG9ja19yZWxl YXNlKCZkbWFfZmVuY2VfbG9ja2RlcF9tYXAsIF9USElTX0lQXyk7CisJbG9ja19tYXBfYWNxdWly ZSgmZG1hX2ZlbmNlX2xvY2tkZXBfbWFwKTsKKwlsb2NrX21hcF9yZWxlYXNlKCZkbWFfZmVuY2Vf bG9ja2RlcF9tYXApOworCWlmICh0bXApCisJCWxvY2tfYWNxdWlyZSgmZG1hX2ZlbmNlX2xvY2tk ZXBfbWFwLCAwLCAwLCAxLCAxLCBOVUxMLCBfVEhJU19JUF8pOworfQorI2VuZGlmCisKKwogLyoq CiAgKiBkbWFfZmVuY2Vfc2lnbmFsX2xvY2tlZCAtIHNpZ25hbCBjb21wbGV0aW9uIG9mIGEgZmVu Y2UKICAqIEBmZW5jZTogdGhlIGZlbmNlIHRvIHNpZ25hbApAQCAtMTcwLDE0ICszMjQsMTkgQEAg aW50IGRtYV9mZW5jZV9zaWduYWwoc3RydWN0IGRtYV9mZW5jZSAqZmVuY2UpCiB7CiAJdW5zaWdu ZWQgbG9uZyBmbGFnczsKIAlpbnQgcmV0OworCWJvb2wgdG1wOwogCiAJaWYgKCFmZW5jZSkKIAkJ cmV0dXJuIC1FSU5WQUw7CiAKKwl0bXAgPSBkbWFfZmVuY2VfYmVnaW5fc2lnbmFsbGluZygpOwor CiAJc3Bpbl9sb2NrX2lycXNhdmUoZmVuY2UtPmxvY2ssIGZsYWdzKTsKIAlyZXQgPSBkbWFfZmVu Y2Vfc2lnbmFsX2xvY2tlZChmZW5jZSk7CiAJc3Bpbl91bmxvY2tfaXJxcmVzdG9yZShmZW5jZS0+ bG9jaywgZmxhZ3MpOwogCisJZG1hX2ZlbmNlX2VuZF9zaWduYWxsaW5nKHRtcCk7CisKIAlyZXR1 cm4gcmV0OwogfQogRVhQT1JUX1NZTUJPTChkbWFfZmVuY2Vfc2lnbmFsKTsKQEAgLTIxMCw2ICsz NjksOCBAQCBkbWFfZmVuY2Vfd2FpdF90aW1lb3V0KHN0cnVjdCBkbWFfZmVuY2UgKmZlbmNlLCBi b29sIGludHIsIHNpZ25lZCBsb25nIHRpbWVvdXQpCiAKIAltaWdodF9zbGVlcCgpOwogCisJX19k bWFfZmVuY2VfbWlnaHRfd2FpdCgpOworCiAJdHJhY2VfZG1hX2ZlbmNlX3dhaXRfc3RhcnQoZmVu Y2UpOwogCWlmIChmZW5jZS0+b3BzLT53YWl0KQogCQlyZXQgPSBmZW5jZS0+b3BzLT53YWl0KGZl bmNlLCBpbnRyLCB0aW1lb3V0KTsKZGlmZiAtLWdpdCBhL2luY2x1ZGUvbGludXgvZG1hLWZlbmNl LmggYi9pbmNsdWRlL2xpbnV4L2RtYS1mZW5jZS5oCmluZGV4IDMzNDdjNTRmM2E4Ny4uM2YyODhm N2RiMmVmIDEwMDY0NAotLS0gYS9pbmNsdWRlL2xpbnV4L2RtYS1mZW5jZS5oCisrKyBiL2luY2x1 ZGUvbGludXgvZG1hLWZlbmNlLmgKQEAgLTM1Nyw2ICszNTcsMTggQEAgZG1hX2ZlbmNlX2dldF9y Y3Vfc2FmZShzdHJ1Y3QgZG1hX2ZlbmNlIF9fcmN1ICoqZmVuY2VwKQogCX0gd2hpbGUgKDEpOwog fQogCisjaWZkZWYgQ09ORklHX0xPQ0tERVAKK2Jvb2wgZG1hX2ZlbmNlX2JlZ2luX3NpZ25hbGxp bmcodm9pZCk7Cit2b2lkIGRtYV9mZW5jZV9lbmRfc2lnbmFsbGluZyhib29sIGNvb2tpZSk7Cisj ZWxzZQorc3RhdGljIGlubGluZSBib29sIGRtYV9mZW5jZV9iZWdpbl9zaWduYWxsaW5nKHZvaWQp Cit7CisJcmV0dXJuIHRydWU7Cit9CitzdGF0aWMgaW5saW5lIHZvaWQgZG1hX2ZlbmNlX2VuZF9z aWduYWxsaW5nKGJvb2wgY29va2llKSB7fQorc3RhdGljIGlubGluZSB2b2lkIF9fZG1hX2ZlbmNl X21pZ2h0X3dhaXQodm9pZCkge30KKyNlbmRpZgorCiBpbnQgZG1hX2ZlbmNlX3NpZ25hbChzdHJ1 Y3QgZG1hX2ZlbmNlICpmZW5jZSk7CiBpbnQgZG1hX2ZlbmNlX3NpZ25hbF9sb2NrZWQoc3RydWN0 IGRtYV9mZW5jZSAqZmVuY2UpOwogc2lnbmVkIGxvbmcgZG1hX2ZlbmNlX2RlZmF1bHRfd2FpdChz dHJ1Y3QgZG1hX2ZlbmNlICpmZW5jZSwKLS0gCjIuMjcuMAoKX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fX18KZHJpLWRldmVsIG1haWxpbmcgbGlzdApkcmktZGV2 ZWxAbGlzdHMuZnJlZWRlc2t0b3Aub3JnCmh0dHBzOi8vbGlzdHMuZnJlZWRlc2t0b3Aub3JnL21h aWxtYW4vbGlzdGluZm8vZHJpLWRldmVsCg== 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_INVALID,DKIM_SIGNED, HEADER_FROM_DIFFERENT_DOMAINS,INCLUDES_PATCH,MAILING_LIST_MULTI,SIGNED_OFF_BY, SPF_HELO_NONE,SPF_PASS,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 2A963C433E6 for ; Tue, 7 Jul 2020 20:12:49 +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 01CD7206BE for ; Tue, 7 Jul 2020 20:12:48 +0000 (UTC) Authentication-Results: mail.kernel.org; dkim=fail reason="signature verification failed" (1024-bit key) header.d=ffwll.ch header.i=@ffwll.ch header.b="fmFnnt+e" DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org 01CD7206BE Authentication-Results: mail.kernel.org; dmarc=none (p=none dis=none) header.from=ffwll.ch 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 324E56E239; Tue, 7 Jul 2020 20:12:45 +0000 (UTC) Received: from mail-wr1-x443.google.com (mail-wr1-x443.google.com [IPv6:2a00:1450:4864:20::443]) by gabe.freedesktop.org (Postfix) with ESMTPS id DBC406E239 for ; Tue, 7 Jul 2020 20:12:43 +0000 (UTC) Received: by mail-wr1-x443.google.com with SMTP id f7so43578095wrw.1 for ; Tue, 07 Jul 2020 13:12:43 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=ffwll.ch; s=google; h=from:to:cc:subject:date:message-id:in-reply-to:references :mime-version:content-transfer-encoding; bh=+zqqvyi3z5A21ql34E5+vQaCHF2rAOOJAQR+upY9QO0=; b=fmFnnt+ehdq4yzSf5JNaqXX4yhCqAqD0kK0/qt4eB91lTy43C9BV8NE2+7bCE2dMEV j/iYq+xbAyWSUJE96U9SszSPGm8fuSDz412xfxFWlqIfJCVtYRTbtJZuwBEimFPr2Jzq SZeC88b3d2af3OnObiDD64/C7gkdSt0cAFrRU= X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references:mime-version:content-transfer-encoding; bh=+zqqvyi3z5A21ql34E5+vQaCHF2rAOOJAQR+upY9QO0=; b=Ekg8rhuYayeO8vyFGDHHZ4l97dQu+j+q87JBkEo/tNCqtnKvzxaTlEIfaBgGS3GtYG /l2YNIOtpq+m/q3GnLWvy/ZcvWFV8UYGQvQDcHPSdYUSJKhF6CTTQy0jEs9l19jlWexI N9F5rtXvWc0KEU7R+yzYKV6cbYw5o8cSSxuoBwsdw0/yMvgD9LffKGyuZJItTz3g7CSR zkto+dxa4Iw/EwuVQAbJUbB70q8BNEkbPnuZxT+nBF5e2xAaAgiP5rJ0a/eclZNDbpLU Znyh/UpBjQkiznoj8lPRBOKizOLerHtON+K3BCxPkgm5IAWxPj7TvbFlkKo/ppZJIaNv wQaA== X-Gm-Message-State: AOAM530n58wVp8bdH+U+eE1eSg5QKVCkwKpZAd7PuLoPmlVr9G3nGSjL s6JM9uRRr3T6iuQ8RmfwrFdTrg== X-Google-Smtp-Source: ABdhPJzrfZJXwmqAifF26fj/gQn6kFUlKzxT6On6Iaf8irG4na4G4iK3mAJTIWo1H7s/v1Eotv4TeA== X-Received: by 2002:adf:cf0c:: with SMTP id o12mr54938782wrj.265.1594152762369; Tue, 07 Jul 2020 13:12:42 -0700 (PDT) Received: from phenom.ffwll.local ([2a02:168:57f4:0:efd0:b9e5:5ae6:c2fa]) by smtp.gmail.com with ESMTPSA id q7sm2515262wra.56.2020.07.07.13.12.40 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Tue, 07 Jul 2020 13:12:41 -0700 (PDT) From: Daniel Vetter To: DRI Development Date: Tue, 7 Jul 2020 22:12:05 +0200 Message-Id: <20200707201229.472834-2-daniel.vetter@ffwll.ch> X-Mailer: git-send-email 2.27.0 In-Reply-To: <20200707201229.472834-1-daniel.vetter@ffwll.ch> References: <20200707201229.472834-1-daniel.vetter@ffwll.ch> MIME-Version: 1.0 Subject: [Intel-gfx] [PATCH 01/25] dma-fence: basic lockdep annotations X-BeenThere: intel-gfx@lists.freedesktop.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: Intel graphics driver community testing & development List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Cc: =?UTF-8?q?Christian=20K=C3=B6nig?= , linux-rdma@vger.kernel.org, Daniel Vetter , Intel Graphics Development , amd-gfx@lists.freedesktop.org, Chris Wilson , linaro-mm-sig@lists.linaro.org, =?UTF-8?q?Thomas=20Hellstr=C3=B6m?= , Daniel Vetter , linux-media@vger.kernel.org, Felix Kuehling , Mika Kuoppala Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Errors-To: intel-gfx-bounces@lists.freedesktop.org Sender: "Intel-gfx" RGVzaWduIGlzIHNpbWlsYXIgdG8gdGhlIGxvY2tkZXAgYW5ub3RhdGlvbnMgZm9yIHdvcmtlcnMs IGJ1dCB3aXRoCnNvbWUgdHdpc3RzOgoKLSBXZSB1c2UgYSByZWFkLWxvY2sgZm9yIHRoZSBleGVj dXRpb24vd29ya2VyL2NvbXBsZXRpb24gc2lkZSwgc28gdGhhdAogIHRoaXMgZXhwbGljaXQgYW5u b3RhdGlvbiBjYW4gYmUgbW9yZSBsaWJlcmFsbHkgc3ByaW5rbGVkIGFyb3VuZC4KICBXaXRoIHJl YWQgbG9ja3MgbG9ja2RlcCBpc24ndCBnb2luZyB0byBjb21wbGFpbiBpZiB0aGUgcmVhZC1zaWRl CiAgaXNuJ3QgbmVzdGVkIHRoZSBzYW1lIHdheSB1bmRlciBhbGwgY2lyY3Vtc3RhbmNlcywgc28g QUJCQSBkZWFkbG9ja3MKICBhcmUgb2suIFdoaWNoIHRoZXkgYXJlLCBzaW5jZSB0aGlzIGlzIGFu IGFubm90YXRpb24gb25seS4KCi0gV2UncmUgdXNpbmcgbm9uLXJlY3Vyc2l2ZSBsb2NrZGVwIHJl YWQgbG9jayBtb2RlLCBzaW5jZSBpbiByZWN1cnNpdmUKICByZWFkIGxvY2sgbW9kZSBsb2NrZGVw IGRvZXMgbm90IGNhdGNoIHJlYWQgc2lkZSBoYXphcmRzLiBBbmQgd2UKICBfdmVyeV8gbXVjaCB3 YW50IHJlYWQgc2lkZSBoYXphcmRzIHRvIGJlIGNhdWdodC4gRm9yIGZ1bGwgZGV0YWlscyBvZgog IHRoaXMgbGltaXRhdGlvbiBzZWUKCiAgY29tbWl0IGU5MTQ5ODU4OTc0NjA2NWUzYWU5NWQ5YTAw YjA2OGU1MjVlZWMzNGYKICBBdXRob3I6IFBldGVyIFppamxzdHJhIDxwZXRlcnpAaW5mcmFkZWFk Lm9yZz4KICBEYXRlOiAgIFdlZCBBdWcgMjMgMTM6MTM6MTEgMjAxNyArMDIwMAoKICAgICAgbG9j a2luZy9sb2NrZGVwL3NlbGZ0ZXN0czogQWRkIG1peGVkIHJlYWQtd3JpdGUgQUJCQSB0ZXN0cwoK LSBUbyBhbGxvdyBuZXN0aW5nIG9mIHRoZSByZWFkLXNpZGUgZXhwbGljaXQgYW5ub3RhdGlvbnMg d2UgZXhwbGljaXRseQogIGtlZXAgdHJhY2sgb2YgdGhlIG5lc3RpbmcuIGxvY2tfaXNfaGVsZCgp IGFsbG93cyB1cyB0byBkbyB0aGF0LgoKLSBUaGUgd2FpdC1zaWRlIGFubm90YXRpb24gaXMgYSB3 cml0ZSBsb2NrLCBhbmQgZW50aXJlbHkgZG9uZSB3aXRoaW4KICBkbWFfZmVuY2Vfd2FpdCgpIGZv ciBldmVyeW9uZSBieSBkZWZhdWx0LgoKLSBUbyBiZSBhYmxlIHRvIGZyZWVseSBhbm5vdGF0ZSBo ZWxwZXIgZnVuY3Rpb25zIEkgd2FudCB0byBtYWtlIGl0IG9rCiAgdG8gY2FsbCBkbWFfZmVuY2Vf YmVnaW4vZW5kX3NpZ25hbGxpbmcgZnJvbSBzb2Z0L2hhcmRpcnEgY29udGV4dC4KICBGaXJzdCBh dHRlbXB0IHdhcyB1c2luZyB0aGUgaGFyZGlycSBsb2NraW5nIGNvbnRleHQgZm9yIHRoZSB3cml0 ZQogIHNpZGUgaW4gbG9ja2RlcCwgYnV0IHRoaXMgZm9yY2VzIGFsbCBub3JtYWwgc3BpbmxvY2tz IG5lc3RlZCB3aXRoaW4KICBkbWFfZmVuY2VfYmVnaW4vZW5kX3NpZ25hbGxpbmcgdG8gYmUgc3Bp bmxvY2tzLiBUaGF0IGJvbGxvY2tzLgoKICBUaGUgYXBwcm9hY2ggbm93IGlzIHRvIHNpbXBsZSBj aGVjayBpbl9hdG9taWMoKSwgYW5kIGZvciB0aGVzZSBjYXNlcwogIGVudGlyZWx5IHJlbHkgb24g dGhlIG1pZ2h0X3NsZWVwKCkgY2hlY2sgaW4gZG1hX2ZlbmNlX3dhaXQoKS4gVGhhdAogIHdpbGwg Y2F0Y2ggYW55IHdyb25nIG5lc3RpbmcgYWdhaW5zdCBzcGlubG9ja3MgZnJvbSBzb2Z0L2hhcmRp cnEKICBjb250ZXh0cy4KClRoZSBpZGVhIGhlcmUgaXMgdGhhdCBldmVyeSBjb2RlIHBhdGggdGhh dCdzIGNyaXRpY2FsIGZvciBldmVudHVhbGx5CnNpZ25hbGxpbmcgYSBkbWFfZmVuY2Ugc2hvdWxk IGJlIGFubm90YXRlZCB3aXRoCmRtYV9mZW5jZV9iZWdpbi9lbmRfc2lnbmFsbGluZy4gVGhlIGFu bm90YXRpb24gaWRlYWxseSBzdGFydHMgcmlnaHQKYWZ0ZXIgYSBkbWFfZmVuY2UgaXMgcHVibGlz aGVkIChhZGRlZCB0byBhIGRtYV9yZXN2LCBleHBvc2VkIGFzIGEKc3luY19maWxlIGZkLCBhdHRh Y2hlZCB0byBhIGRybV9zeW5jb2JqIGZkLCBvciBhbnl0aGluZyBlbHNlIHRoYXQKbWFrZXMgdGhl IGRtYV9mZW5jZSB2aXNpYmxlIHRvIG90aGVyIGtlcm5lbCB0aHJlYWRzKSwgdXAgdG8gYW5kCmlu Y2x1ZGluZyB0aGUgZG1hX2ZlbmNlX3dhaXQoKS4gRXhhbXBsZXMgYXJlIGlycSBoYW5kbGVycywg dGhlCnNjaGVkdWxlciBydCB0aHJlYWRzLCB0aGUgdGFpbCBvZiBleGVjYnVmIChhZnRlciB0aGUg Y29ycmVzcG9uZGluZwpmZW5jZXMgYXJlIHZpc2libGUpLCBhbnkgd29ya2VycyB0aGF0IGVuZCB1 cCBzaWduYWxsaW5nIGRtYV9mZW5jZXMgYW5kCnJlYWxseSBhbnl0aGluZyBlbHNlLiBOb3QgYW5u b3RhdGVkIHNob3VsZCBiZSBjb2RlIHBhdGhzIHRoYXQgb25seQpjb21wbGV0ZSBmZW5jZXMgb3Bw b3J0dW5pc3RpY2FsbHkgYXMgdGhlIGdwdSBwcm9ncmVzc2VzLCBsaWtlIGUuZy4Kc2hyaW5rZXIv ZXZpY3Rpb24gY29kZS4KClRoZSBtYWluIGNsYXNzIG9mIGRlYWRsb2NrcyB0aGlzIGlzIHN1cHBv c2VkIHRvIGNhdGNoIGFyZToKClRocmVhZCBBOgoKCW11dGV4X2xvY2soQSk7CgltdXRleF91bmxv Y2soQSk7CgoJZG1hX2ZlbmNlX3NpZ25hbCgpOwoKVGhyZWFkIEI6CgoJbXV0ZXhfbG9jayhBKTsK CWRtYV9mZW5jZV93YWl0KCk7CgltdXRleF91bmxvY2soQSk7CgpUaHJlYWQgQiBpcyBibG9ja2Vk IG9uIEEgc2lnbmFsbGluZyB0aGUgZmVuY2UsIGJ1dCBBIG5ldmVyIGdldHMgYXJvdW5kCnRvIHRo YXQgYmVjYXVzZSBpdCBjYW5ub3QgYWNxdWlyZSB0aGUgbG9jayBBLgoKTm90ZSB0aGF0IGRtYV9m ZW5jZV93YWl0KCkgaXMgYWxsb3dlZCB0byBiZSBuZXN0ZWQgd2l0aGluCmRtYV9mZW5jZV9iZWdp bi9lbmRfc2lnbmFsbGluZyBzZWN0aW9ucy4gVG8gYWxsb3cgdGhpcyB0byBoYXBwZW4gdGhlCnJl YWQgbG9jayBuZWVkcyB0byBiZSB1cGdyYWRlZCB0byBhIHdyaXRlIGxvY2ssIHdoaWNoIG1lYW5z IHRoYXQgYW55Cm90aGVyIGxvY2sgaXMgYWNxdWlyZWQgYmV0d2VlbiB0aGUgZG1hX2ZlbmNlX2Jl Z2luX3NpZ25hbGxpbmcoKSBjYWxsIGFuZAp0aGUgY2FsbCB0byBkbWFfZmVuY2Vfd2FpdCgpLCBh bmQgc3RpbGwgaGVsZCwgdGhpcyB3aWxsIHJlc3VsdCBpbiBhbgppbW1lZGlhdGUgbG9ja2RlcCBj b21wbGFpbnQuIFRoZSBvbmx5IG90aGVyIG9wdGlvbiB3b3VsZCBiZSB0byBub3QKYW5ub3RhdGUg c3VjaCBjYWxscywgZGVmZWF0aW5nIHRoZSBwb2ludC4gVGhlcmVmb3JlIHRoZXNlIGFubm90YXRp b25zCmNhbm5vdCBiZSBzcHJpbmtsZWQgb3ZlciB0aGUgY29kZSBlbnRpcmVseSBtaW5kbGVzcyB0 byBhdm9pZCBmYWxzZQpwb3NpdGl2ZXMuCgpPcmlnaW5hbGx5IEkgaG9wZSB0aGF0IHRoZSBjcm9z cy1yZWxlYXNlIGxvY2tkZXAgZXh0ZW5zaW9ucyB3b3VsZAphbGxldmlhdGUgdGhlIG5lZWQgZm9y IGV4cGxpY2l0IGFubm90YXRpb25zOgoKaHR0cHM6Ly9sd24ubmV0L0FydGljbGVzLzcwOTg0OS8K CkJ1dCB0aGVyZSdzIGEgZmV3IHJlYXNvbnMgd2h5IHRoYXQncyBub3QgYW4gb3B0aW9uOgoKLSBJ dCdzIG5vdCBoYXBwZW5pbmcgaW4gdXBzdHJlYW0sIHNpbmNlIGl0IGdvdCByZXZlcnRlZCBkdWUg dG8gdG9vCiAgbWFueSBmYWxzZSBwb3NpdGl2ZXM6CgoJY29tbWl0IGU5NjZlYWVlYjYyM2YwOTk3 NWVmMzYyYzI4NjZmYWU2Zjg2ODQ0ZjkKCUF1dGhvcjogSW5nbyBNb2xuYXIgPG1pbmdvQGtlcm5l bC5vcmc+CglEYXRlOiAgIFR1ZSBEZWMgMTIgMTI6MzE6MTYgMjAxNyArMDEwMAoKCSAgICBsb2Nr aW5nL2xvY2tkZXA6IFJlbW92ZSB0aGUgY3Jvc3MtcmVsZWFzZSBsb2NraW5nIGNoZWNrcwoKCSAg ICBUaGlzIGNvZGUgKENPTkZJR19MT0NLREVQX0NST1NTUkVMRUFTRT15IGFuZCBDT05GSUdfTE9D S0RFUF9DT01QTEVUSU9OUz15KSwKCSAgICB3aGlsZSBpdCBmb3VuZCBhIG51bWJlciBvZiBvbGQg YnVncyBpbml0aWFsbHksIHdhcyBhbHNvIGNhdXNpbmcgdG9vIG1hbnkKCSAgICBmYWxzZSBwb3Np dGl2ZXMgdGhhdCBjYXVzZWQgcGVvcGxlIHRvIGRpc2FibGUgbG9ja2RlcCAtIHdoaWNoIGlzIGFy Z3VhYmx5CgkgICAgYSB3b3JzZSBvdmVyYWxsIG91dGNvbWUuCgotIGNyb3NzLXJlbGVhc2UgdXNl cyB0aGUgY29tcGxldGUoKSBjYWxsIHRvIGFubm90YXRlIHRoZSBlbmQgb2YKICBjcml0aWNhbCBz ZWN0aW9ucywgZm9yIGRtYV9mZW5jZSB0aGF0IHdvdWxkIGJlIGRtYV9mZW5jZV9zaWduYWwoKS4K ICBCdXQgd2UgZG8gbm90IHdhbnQgYWxsIGRtYV9mZW5jZV9zaWduYWwoKSBjYWxscyB0byBiZSB0 cmVhdGVkIGFzCiAgY3JpdGljYWwsIHNpbmNlIG1hbnkgYXJlIG9wcG9ydHVuaXN0aWMgY2xlYW51 cCBvZiBncHUgcmVxdWVzdHMuIElmCiAgdGhlc2UgZ2V0IHN0dWNrIHRoZXJlJ3Mgc3RpbGwgdGhl IG1haW4gY29tcGxldGlvbiBpbnRlcnJ1cHQgYW5kCiAgd29ya2VycyB3aG8gY2FuIHVuYmxvY2sg ZXZlcnlvbmUuIEF1dG9tYXRpY2FsbHkgYW5ub3RhdGluZyBhbGwKICBkbWFfZmVuY2Vfc2lnbmFs KCkgY2FsbHMgd291bGQgaGVuY2UgY2F1c2UgZmFsc2UgcG9zaXRpdmVzLgoKLSBjcm9zcy1yZWxl YXNlIGhhZCBzb21lIGVkdWNhdGVkIGd1ZXNzZXMgZm9yIHdoZW4gYSBjcml0aWNhbCBzZWN0aW9u CiAgc3RhcnRzLCBsaWtlIGZyZXNoIHN5c2NhbGwgb3IgZnJlc2ggd29yayBjYWxsYmFjay4gVGhp cyB3b3VsZCBhZ2FpbgogIGNhdXNlIGZhbHNlIHBvc2l0aXZlcyB3aXRob3V0IGV4cGxpY2l0IGFu bm90YXRpb25zLCBzaW5jZSBmb3IKICBkbWFfZmVuY2UgdGhlIGNyaXRpY2FsIHNlY3Rpb25zIG9u bHkgc3RhcnRzIHdoZW4gd2UgcHVibGlzaCBhIGZlbmNlLgoKLSBGdXJ0aGVybW9yZSB0aGVyZSBj YW4gYmUgY2FzZXMgd2hlcmUgYSB0aHJlYWQgbmV2ZXIgZG9lcyBhCiAgZG1hX2ZlbmNlX3NpZ25h bCwgYnV0IGlzIHN0aWxsIGNyaXRpY2FsIGZvciByZWFjaGluZyBjb21wbGV0aW9uIG9mCiAgZmVu Y2VzLiBPbmUgZXhhbXBsZSB3b3VsZCBiZSBhIHNjaGVkdWxlciBrdGhyZWFkIHdoaWNoIHBpY2tz IHVwIGpvYnMKICBhbmQgcHVzaGVzIHRoZW0gaW50byBoYXJkd2FyZSwgd2hlcmUgdGhlIGludGVy cnVwdCBoYW5kbGVyIG9yCiAgYW5vdGhlciBjb21wbGV0aW9uIHRocmVhZCBjYWxscyBkbWFfZmVu Y2Vfc2lnbmFsKCkuIEJ1dCBpZiB0aGUKICBzY2hlZHVsZXIgdGhyZWFkIGhhbmdzLCB0aGVuIGFs bCB0aGUgZmVuY2VzIGhhbmcsIGhlbmNlIHdlIG5lZWQgdG8KICBtYW51YWxseSBhbm5vdGF0ZSBp dC4gY3Jvc3MtcmVsZWFzZSBhaW1lZCB0byBzb2x2ZSB0aGlzIGJ5IGNoYWluaW5nCiAgY3Jvc3Mt cmVsZWFzZSBkZXBlbmRlbmNpZXMsIGJ1dCB0aGUgZGVwZW5kZW5jeSBmcm9tIHNjaGVkdWxlciB0 aHJlYWQKICB0byB0aGUgY29tcGxldGlvbiBpbnRlcnJ1cHQgaGFuZGxlciBnb2VzIHRocm91Z2gg aHcgd2hlcmUKICBjcm9zcy1yZWxlYXNlIGNvZGUgY2FuJ3Qgb2JzZXJ2ZSBpdC4KCkluIHNob3J0 LCB3aXRob3V0IG1hbnVhbCBhbm5vdGF0aW9ucyBhbmQgY2FyZWZ1bCByZXZpZXcgb2YgdGhlIHN0 YXJ0CmFuZCBlbmQgb2YgY3JpdGljYWwgc2VjdGlvbnMsIGNyb3NzLXJlbGVzZSBkZXBlbmRlbmN5 IHRyYWNraW5nIGRvZXNuJ3QKd29yay4gV2UgbmVlZCBleHBsaWNpdCBhbm5vdGF0aW9ucy4KCnYy OiBoYW5kbGUgc29mdC9oYXJkaXJxIGN0eCBiZXR0ZXIgYWdhaW5zdCB3cml0ZSBzaWRlIGFuZCBk b250IGZvcmdldApFWFBPUlRfU1lNQk9MLCBkcml2ZXJzIGNhbid0IHVzZSB0aGlzIG90aGVyd2lz ZS4KCnYzOiBLZXJuZWxkb2MuCgp2NDogU29tZSBzcGVsbGluZyBmaXhlcyBmcm9tIE1pa2EKCnY1 OiBBbWVuZCBjb21taXQgbWVzc2FnZSB0byBleHBsYWluIGluIGRldGFpbCB3aHkgY3Jvc3MtcmVs ZWFzZSBpc24ndAp0aGUgc29sdXRpb24uCgp2NjogUHVsbCBvdXQgbWlzcGxhY2VkIC5yc3QgaHVu ay4KCkNjOiBGZWxpeCBLdWVobGluZyA8RmVsaXguS3VlaGxpbmdAYW1kLmNvbT4KUmV2aWV3ZWQt Ynk6IFRob21hcyBIZWxsc3Ryw7ZtIDx0aG9tYXMuaGVsbHN0cm9tQGludGVsLmNvbT4KUmV2aWV3 ZWQtYnk6IE1hYXJ0ZW4gTGFua2hvcnN0IDxtYWFydGVuLmxhbmtob3JzdEBsaW51eC5pbnRlbC5j b20+CkNjOiBNaWthIEt1b3BwYWxhIDxtaWthLmt1b3BwYWxhQGludGVsLmNvbT4KQ2M6IFRob21h cyBIZWxsc3Ryb20gPHRob21hcy5oZWxsc3Ryb21AaW50ZWwuY29tPgpDYzogbGludXgtbWVkaWFA dmdlci5rZXJuZWwub3JnCkNjOiBsaW5hcm8tbW0tc2lnQGxpc3RzLmxpbmFyby5vcmcKQ2M6IGxp bnV4LXJkbWFAdmdlci5rZXJuZWwub3JnCkNjOiBhbWQtZ2Z4QGxpc3RzLmZyZWVkZXNrdG9wLm9y ZwpDYzogaW50ZWwtZ2Z4QGxpc3RzLmZyZWVkZXNrdG9wLm9yZwpDYzogQ2hyaXMgV2lsc29uIDxj aHJpc0BjaHJpcy13aWxzb24uY28udWs+CkNjOiBNYWFydGVuIExhbmtob3JzdCA8bWFhcnRlbi5s YW5raG9yc3RAbGludXguaW50ZWwuY29tPgpDYzogQ2hyaXN0aWFuIEvDtm5pZyA8Y2hyaXN0aWFu LmtvZW5pZ0BhbWQuY29tPgpTaWduZWQtb2ZmLWJ5OiBEYW5pZWwgVmV0dGVyIDxkYW5pZWwudmV0 dGVyQGludGVsLmNvbT4KLS0tCiBEb2N1bWVudGF0aW9uL2RyaXZlci1hcGkvZG1hLWJ1Zi5yc3Qg fCAgIDYgKwogZHJpdmVycy9kbWEtYnVmL2RtYS1mZW5jZS5jICAgICAgICAgIHwgMTYxICsrKysr KysrKysrKysrKysrKysrKysrKysrKwogaW5jbHVkZS9saW51eC9kbWEtZmVuY2UuaCAgICAgICAg ICAgIHwgIDEyICsrCiAzIGZpbGVzIGNoYW5nZWQsIDE3OSBpbnNlcnRpb25zKCspCgpkaWZmIC0t Z2l0IGEvRG9jdW1lbnRhdGlvbi9kcml2ZXItYXBpL2RtYS1idWYucnN0IGIvRG9jdW1lbnRhdGlv bi9kcml2ZXItYXBpL2RtYS1idWYucnN0CmluZGV4IDdmYjdiNjYxZmViZC4uMDVkODU2MTMxMTQw IDEwMDY0NAotLS0gYS9Eb2N1bWVudGF0aW9uL2RyaXZlci1hcGkvZG1hLWJ1Zi5yc3QKKysrIGIv RG9jdW1lbnRhdGlvbi9kcml2ZXItYXBpL2RtYS1idWYucnN0CkBAIC0xMzMsNiArMTMzLDEyIEBA IERNQSBGZW5jZXMKIC4uIGtlcm5lbC1kb2M6OiBkcml2ZXJzL2RtYS1idWYvZG1hLWZlbmNlLmMK ICAgIDpkb2M6IERNQSBmZW5jZXMgb3ZlcnZpZXcKIAorRE1BIEZlbmNlIFNpZ25hbGxpbmcgQW5u b3RhdGlvbnMKK35+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+CisKKy4uIGtlcm5lbC1k b2M6OiBkcml2ZXJzL2RtYS1idWYvZG1hLWZlbmNlLmMKKyAgIDpkb2M6IGZlbmNlIHNpZ25hbGxp bmcgYW5ub3RhdGlvbgorCiBETUEgRmVuY2VzIEZ1bmN0aW9ucyBSZWZlcmVuY2UKIH5+fn5+fn5+ fn5+fn5+fn5+fn5+fn5+fn5+fn5+fgogCmRpZmYgLS1naXQgYS9kcml2ZXJzL2RtYS1idWYvZG1h LWZlbmNlLmMgYi9kcml2ZXJzL2RtYS1idWYvZG1hLWZlbmNlLmMKaW5kZXggNjU2ZTlhYzJkMDI4 Li4wMDA1YmMwMDI1MjkgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvZG1hLWJ1Zi9kbWEtZmVuY2UuYwor KysgYi9kcml2ZXJzL2RtYS1idWYvZG1hLWZlbmNlLmMKQEAgLTExMCw2ICsxMTAsMTYwIEBAIHU2 NCBkbWFfZmVuY2VfY29udGV4dF9hbGxvYyh1bnNpZ25lZCBudW0pCiB9CiBFWFBPUlRfU1lNQk9M KGRtYV9mZW5jZV9jb250ZXh0X2FsbG9jKTsKIAorLyoqCisgKiBET0M6IGZlbmNlIHNpZ25hbGxp bmcgYW5ub3RhdGlvbgorICoKKyAqIFByb3ZpbmcgY29ycmVjdG5lc3Mgb2YgYWxsIHRoZSBrZXJu ZWwgY29kZSBhcm91bmQgJmRtYV9mZW5jZSB0aHJvdWdoIGNvZGUKKyAqIHJldmlldyBhbmQgdGVz dGluZyBpcyB0cmlja3kgZm9yIGEgZmV3IHJlYXNvbnM6CisgKgorICogKiBJdCBpcyBhIGNyb3Nz LWRyaXZlciBjb250cmFjdCwgYW5kIHRoZXJlZm9yZSBhbGwgZHJpdmVycyBtdXN0IGZvbGxvdyB0 aGUKKyAqICAgc2FtZSBydWxlcyBmb3IgbG9jayBuZXN0aW5nIG9yZGVyLCBjYWxsaW5nIGNvbnRl eHRzIGZvciB2YXJpb3VzIGZ1bmN0aW9ucworICogICBhbmQgYW55dGhpbmcgZWxzZSBzaWduaWZp Y2FudCBmb3IgaW4ta2VybmVsIGludGVyZmFjZXMuIEJ1dCBpdCBpcyBhbHNvCisgKiAgIGltcG9z c2libGUgdG8gdGVzdCBhbGwgZHJpdmVycyBpbiBhIHNpbmdsZSBtYWNoaW5lLCBoZW5jZSBicnV0 ZS1mb3JjZSBOIHZzLgorICogICBOIHRlc3Rpbmcgb2YgYWxsIGNvbWJpbmF0aW9ucyBpcyBpbXBv c3NpYmxlLiBFdmVuIGp1c3QgbGltaXRpbmcgdG8gdGhlCisgKiAgIHBvc3NpYmxlIGNvbWJpbmF0 aW9ucyBpcyBpbmZlYXNpYmxlLgorICoKKyAqICogVGhlcmUgaXMgYW4gZW5vcm1vdXMgYW1vdW50 IG9mIGRyaXZlciBjb2RlIGludm9sdmVkLiBGb3IgcmVuZGVyIGRyaXZlcnMKKyAqICAgdGhlcmUn cyB0aGUgdGFpbCBvZiBjb21tYW5kIHN1Ym1pc3Npb24sIGFmdGVyIGZlbmNlcyBhcmUgcHVibGlz aGVkLAorICogICBzY2hlZHVsZXIgY29kZSwgaW50ZXJydXB0IGFuZCB3b3JrZXJzIHRvIHByb2Nl c3Mgam9iIGNvbXBsZXRpb24sCisgKiAgIGFuZCB0aW1lb3V0LCBncHUgcmVzZXQgYW5kIGdwdSBo YW5nIHJlY292ZXJ5IGNvZGUuIFBsdXMgZm9yIGludGVncmF0aW9uCisgKiAgIHdpdGggY29yZSBt bSB3aXRoIGhhdmUgJm1tdV9ub3RpZmllciwgcmVzcGVjdGl2ZWx5ICZtbXVfaW50ZXJ2YWxfbm90 aWZpZXIsCisgKiAgIGFuZCAmc2hyaW5rZXIuIEZvciBtb2Rlc2V0dGluZyBkcml2ZXJzIHRoZXJl J3MgdGhlIGNvbW1pdCB0YWlsIGZ1bmN0aW9ucworICogICBiZXR3ZWVuIHdoZW4gZmVuY2VzIGZv ciBhbiBhdG9taWMgbW9kZXNldCBhcmUgcHVibGlzaGVkLCBhbmQgd2hlbiB0aGUKKyAqICAgY29y cmVzcG9uZGluZyB2YmxhbmsgY29tcGxldGVzLCBpbmNsdWRpbmcgYW55IGludGVycnVwdCBwcm9j ZXNzaW5nIGFuZAorICogICByZWxhdGVkIHdvcmtlcnMuIEF1ZGl0aW5nIGFsbCB0aGF0IGNvZGUs IGFjcm9zcyBhbGwgZHJpdmVycywgaXMgbm90CisgKiAgIGZlYXNpYmxlLgorICoKKyAqICogRHVl IHRvIGhvdyBtYW55IG90aGVyIHN1YnN5c3RlbXMgYXJlIGludm9sdmVkIGFuZCB0aGUgbG9ja2lu ZyBoaWVyYXJjaGllcworICogICB0aGlzIHB1bGxzIGluIHRoZXJlIGlzIGV4dHJlbWVseSB0aGlu IHdpZ2dsZS1yb29tIGZvciBkcml2ZXItc3BlY2lmaWMKKyAqICAgZGlmZmVyZW5jZXMuICZkbWFf ZmVuY2UgaW50ZXJhY3RzIHdpdGggYWxtb3N0IGFsbCBvZiB0aGUgY29yZSBtZW1vcnkKKyAqICAg aGFuZGxpbmcgdGhyb3VnaCBwYWdlIGZhdWx0IGhhbmRsZXJzIHZpYSAmZG1hX3Jlc3YsIGRtYV9y ZXN2X2xvY2soKSBhbmQKKyAqICAgZG1hX3Jlc3ZfdW5sb2NrKCkuIE9uIHRoZSBvdGhlciBzaWRl IGl0IGFsc28gaW50ZXJhY3RzIHRocm91Z2ggYWxsCisgKiAgIGFsbG9jYXRpb24gc2l0ZXMgdGhy b3VnaCAmbW11X25vdGlmaWVyIGFuZCAmc2hyaW5rZXIuCisgKgorICogRnVydGhlcm1vcmUgbG9j a2RlcCBkb2VzIG5vdCBoYW5kbGUgY3Jvc3MtcmVsZWFzZSBkZXBlbmRlbmNpZXMsIHdoaWNoIG1l YW5zCisgKiBhbnkgZGVhZGxvY2tzIGJldHdlZW4gZG1hX2ZlbmNlX3dhaXQoKSBhbmQgZG1hX2Zl bmNlX3NpZ25hbCgpIGNhbid0IGJlIGNhdWdodAorICogYXQgcnVudGltZSB3aXRoIHNvbWUgcXVp Y2sgdGVzdGluZy4gVGhlIHNpbXBsZXN0IGV4YW1wbGUgaXMgb25lIHRocmVhZAorICogd2FpdGlu ZyBvbiBhICZkbWFfZmVuY2Ugd2hpbGUgaG9sZGluZyBhIGxvY2s6OgorICoKKyAqICAgICBsb2Nr KEEpOworICogICAgIGRtYV9mZW5jZV93YWl0KEIpOworICogICAgIHVubG9jayhBKTsKKyAqCisg KiB3aGlsZSB0aGUgb3RoZXIgdGhyZWFkIGlzIHN0dWNrIHRyeWluZyB0byBhY3F1aXJlIHRoZSBz YW1lIGxvY2ssIHdoaWNoCisgKiBwcmV2ZW50cyBpdCBmcm9tIHNpZ25hbGxpbmcgdGhlIGZlbmNl IHRoZSBwcmV2aW91cyB0aHJlYWQgaXMgc3R1Y2sgd2FpdGluZworICogb246OgorICoKKyAqICAg ICBsb2NrKEEpOworICogICAgIHVubG9jayhBKTsKKyAqICAgICBkbWFfZmVuY2Vfc2lnbmFsKEIp OworICoKKyAqIEJ5IG1hbnVhbGx5IGFubm90YXRpbmcgYWxsIGNvZGUgcmVsZXZhbnQgdG8gc2ln bmFsbGluZyBhICZkbWFfZmVuY2Ugd2UgY2FuCisgKiB0ZWFjaCBsb2NrZGVwIGFib3V0IHRoZXNl IGRlcGVuZGVuY2llcywgd2hpY2ggYWxzbyBoZWxwcyB3aXRoIHRoZSB2YWxpZGF0aW9uCisgKiBo ZWFkYWNoZSBzaW5jZSBub3cgbG9ja2RlcCBjYW4gY2hlY2sgYWxsIHRoZSBydWxlcyBmb3IgdXM6 OgorICoKKyAqICAgIGNvb2tpZSA9IGRtYV9mZW5jZV9iZWdpbl9zaWduYWxsaW5nKCk7CisgKiAg ICBsb2NrKEEpOworICogICAgdW5sb2NrKEEpOworICogICAgZG1hX2ZlbmNlX3NpZ25hbChCKTsK KyAqICAgIGRtYV9mZW5jZV9lbmRfc2lnbmFsbGluZyhjb29raWUpOworICoKKyAqIEZvciB1c2lu ZyBkbWFfZmVuY2VfYmVnaW5fc2lnbmFsbGluZygpIGFuZCBkbWFfZmVuY2VfZW5kX3NpZ25hbGxp bmcoKSB0bworICogYW5ub3RhdGUgY3JpdGljYWwgc2VjdGlvbnMgdGhlIGZvbGxvd2luZyBydWxl cyBuZWVkIHRvIGJlIG9ic2VydmVkOgorICoKKyAqICogQWxsIGNvZGUgbmVjZXNzYXJ5IHRvIGNv bXBsZXRlIGEgJmRtYV9mZW5jZSBtdXN0IGJlIGFubm90YXRlZCwgZnJvbSB0aGUKKyAqICAgcG9p bnQgd2hlcmUgYSBmZW5jZSBpcyBhY2Nlc3NpYmxlIHRvIG90aGVyIHRocmVhZHMsIHRvIHRoZSBw b2ludCB3aGVyZQorICogICBkbWFfZmVuY2Vfc2lnbmFsKCkgaXMgY2FsbGVkLiBVbi1hbm5vdGF0 ZWQgY29kZSBjYW4gY29udGFpbiBkZWFkbG9jayBpc3N1ZXMsCisgKiAgIGFuZCBkdWUgdG8gdGhl IHZlcnkgc3RyaWN0IHJ1bGVzIGFuZCBtYW55IGNvcm5lciBjYXNlcyBpdCBpcyBpbmZlYXNpYmxl IHRvCisgKiAgIGNhdGNoIHRoZXNlIGp1c3Qgd2l0aCByZXZpZXcgb3Igbm9ybWFsIHN0cmVzcyB0 ZXN0aW5nLgorICoKKyAqICogJnN0cnVjdCBkbWFfcmVzdiBkZXNlcnZlcyBhIHNwZWNpYWwgbm90 ZSwgc2luY2UgdGhlIHJlYWRlcnMgYXJlIG9ubHkKKyAqICAgcHJvdGVjdGVkIGJ5IHJjdS4gVGhp cyBtZWFucyB0aGUgc2lnbmFsbGluZyBjcml0aWNhbCBzZWN0aW9uIHN0YXJ0cyBhcyBzb29uCisg KiAgIGFzIHRoZSBuZXcgZmVuY2VzIGFyZSBpbnN0YWxsZWQsIGV2ZW4gYmVmb3JlIGRtYV9yZXN2 X3VubG9jaygpIGlzIGNhbGxlZC4KKyAqCisgKiAqIFRoZSBvbmx5IGV4Y2VwdGlvbiBhcmUgZmFz dCBwYXRocyBhbmQgb3Bwb3J0dW5pc3RpYyBzaWduYWxsaW5nIGNvZGUsIHdoaWNoCisgKiAgIGNh bGxzIGRtYV9mZW5jZV9zaWduYWwoKSBwdXJlbHkgYXMgYW4gb3B0aW1pemF0aW9uLCBidXQgaXMg bm90IHJlcXVpcmVkIHRvCisgKiAgIGd1YXJhbnRlZSBjb21wbGV0aW9uIG9mIGEgJmRtYV9mZW5j ZS4gVGhlIHVzdWFsIGV4YW1wbGUgaXMgYSB3YWl0IElPQ1RMCisgKiAgIHdoaWNoIGNhbGxzIGRt YV9mZW5jZV9zaWduYWwoKSwgd2hpbGUgdGhlIG1hbmRhdG9yeSBjb21wbGV0aW9uIHBhdGggZ29l cworICogICB0aHJvdWdoIGEgaGFyZHdhcmUgaW50ZXJydXB0IGFuZCBwb3NzaWJsZSBqb2IgY29t cGxldGlvbiB3b3JrZXIuCisgKgorICogKiBUbyBhaWQgY29tcG9zYWJpbGl0eSBvZiBjb2RlLCB0 aGUgYW5ub3RhdGlvbnMgY2FuIGJlIGZyZWVseSBuZXN0ZWQsIGFzIGxvbmcKKyAqICAgYXMgdGhl IG92ZXJhbGwgbG9ja2luZyBoaWVyYXJjaHkgaXMgY29uc2lzdGVudC4gVGhlIGFubm90YXRpb25z IGFsc28gd29yaworICogICBib3RoIGluIGludGVycnVwdCBhbmQgcHJvY2VzcyBjb250ZXh0LiBE dWUgdG8gaW1wbGVtZW50YXRpb24gZGV0YWlscyB0aGlzCisgKiAgIHJlcXVpcmVzIHRoYXQgY2Fs bGVycyBwYXNzIGFuIG9wYXF1ZSBjb29raWUgZnJvbQorICogICBkbWFfZmVuY2VfYmVnaW5fc2ln bmFsbGluZygpIHRvIGRtYV9mZW5jZV9lbmRfc2lnbmFsbGluZygpLgorICoKKyAqICogVmFsaWRh dGlvbiBhZ2FpbnN0IHRoZSBjcm9zcyBkcml2ZXIgY29udHJhY3QgaXMgaW1wbGVtZW50ZWQgYnkg cHJpbWluZworICogICBsb2NrZGVwIHdpdGggdGhlIHJlbGV2YW50IGhpZXJhcmNoeSBhdCBib290 LXVwLiBUaGlzIG1lYW5zIGV2ZW4ganVzdAorICogICB0ZXN0aW5nIHdpdGggYSBzaW5nbGUgZGV2 aWNlIGlzIGVub3VnaCB0byB2YWxpZGF0ZSBhIGRyaXZlciwgYXQgbGVhc3QgYXMKKyAqICAgZmFy IGFzIGRlYWRsb2NrcyB3aXRoIGRtYV9mZW5jZV93YWl0KCkgYWdhaW5zdCBkbWFfZmVuY2Vfc2ln bmFsKCkgYXJlCisgKiAgIGNvbmNlcm5lZC4KKyAqLworI2lmZGVmIENPTkZJR19MT0NLREVQCitz dHJ1Y3QgbG9ja2RlcF9tYXAJZG1hX2ZlbmNlX2xvY2tkZXBfbWFwID0geworCS5uYW1lID0gImRt YV9mZW5jZV9tYXAiCit9OworCisvKioKKyAqIGRtYV9mZW5jZV9iZWdpbl9zaWduYWxsaW5nIC0g YmVnaW4gYSBjcml0aWNhbCBETUEgZmVuY2Ugc2lnbmFsbGluZyBzZWN0aW9uCisgKgorICogRHJp dmVycyBzaG91bGQgdXNlIHRoaXMgdG8gYW5ub3RhdGUgdGhlIGJlZ2lubmluZyBvZiBhbnkgY29k ZSBzZWN0aW9uCisgKiByZXF1aXJlZCB0byBldmVudHVhbGx5IGNvbXBsZXRlICZkbWFfZmVuY2Ug YnkgY2FsbGluZyBkbWFfZmVuY2Vfc2lnbmFsKCkuCisgKgorICogVGhlIGVuZCBvZiB0aGVzZSBj cml0aWNhbCBzZWN0aW9ucyBhcmUgYW5ub3RhdGVkIHdpdGgKKyAqIGRtYV9mZW5jZV9lbmRfc2ln bmFsbGluZygpLgorICoKKyAqIFJldHVybnM6CisgKgorICogT3BhcXVlIGNvb2tpZSBuZWVkZWQg YnkgdGhlIGltcGxlbWVudGF0aW9uLCB3aGljaCBuZWVkcyB0byBiZSBwYXNzZWQgdG8KKyAqIGRt YV9mZW5jZV9lbmRfc2lnbmFsbGluZygpLgorICovCitib29sIGRtYV9mZW5jZV9iZWdpbl9zaWdu YWxsaW5nKHZvaWQpCit7CisJLyogZXhwbGljaXRseSBuZXN0aW5nIC4uLiAqLworCWlmIChsb2Nr X2lzX2hlbGRfdHlwZSgmZG1hX2ZlbmNlX2xvY2tkZXBfbWFwLCAxKSkKKwkJcmV0dXJuIHRydWU7 CisKKwkvKiByZWx5IG9uIG1pZ2h0X3NsZWVwIGNoZWNrIGZvciBzb2Z0L2hhcmRpcnEgbG9ja3Mg Ki8KKwlpZiAoaW5fYXRvbWljKCkpCisJCXJldHVybiB0cnVlOworCisJLyogLi4uIGFuZCBub24t cmVjdXJzaXZlIHJlYWRsb2NrICovCisJbG9ja19hY3F1aXJlKCZkbWFfZmVuY2VfbG9ja2RlcF9t YXAsIDAsIDAsIDEsIDEsIE5VTEwsIF9SRVRfSVBfKTsKKworCXJldHVybiBmYWxzZTsKK30KK0VY UE9SVF9TWU1CT0woZG1hX2ZlbmNlX2JlZ2luX3NpZ25hbGxpbmcpOworCisvKioKKyAqIGRtYV9m ZW5jZV9lbmRfc2lnbmFsbGluZyAtIGVuZCBhIGNyaXRpY2FsIERNQSBmZW5jZSBzaWduYWxsaW5n IHNlY3Rpb24KKyAqCisgKiBDbG9zZXMgYSBjcml0aWNhbCBzZWN0aW9uIGFubm90YXRpb24gb3Bl bmVkIGJ5IGRtYV9mZW5jZV9iZWdpbl9zaWduYWxsaW5nKCkuCisgKi8KK3ZvaWQgZG1hX2ZlbmNl X2VuZF9zaWduYWxsaW5nKGJvb2wgY29va2llKQoreworCWlmIChjb29raWUpCisJCXJldHVybjsK KworCWxvY2tfcmVsZWFzZSgmZG1hX2ZlbmNlX2xvY2tkZXBfbWFwLCBfUkVUX0lQXyk7Cit9CitF WFBPUlRfU1lNQk9MKGRtYV9mZW5jZV9lbmRfc2lnbmFsbGluZyk7CisKK3ZvaWQgX19kbWFfZmVu Y2VfbWlnaHRfd2FpdCh2b2lkKQoreworCWJvb2wgdG1wOworCisJdG1wID0gbG9ja19pc19oZWxk X3R5cGUoJmRtYV9mZW5jZV9sb2NrZGVwX21hcCwgMSk7CisJaWYgKHRtcCkKKwkJbG9ja19yZWxl YXNlKCZkbWFfZmVuY2VfbG9ja2RlcF9tYXAsIF9USElTX0lQXyk7CisJbG9ja19tYXBfYWNxdWly ZSgmZG1hX2ZlbmNlX2xvY2tkZXBfbWFwKTsKKwlsb2NrX21hcF9yZWxlYXNlKCZkbWFfZmVuY2Vf bG9ja2RlcF9tYXApOworCWlmICh0bXApCisJCWxvY2tfYWNxdWlyZSgmZG1hX2ZlbmNlX2xvY2tk ZXBfbWFwLCAwLCAwLCAxLCAxLCBOVUxMLCBfVEhJU19JUF8pOworfQorI2VuZGlmCisKKwogLyoq CiAgKiBkbWFfZmVuY2Vfc2lnbmFsX2xvY2tlZCAtIHNpZ25hbCBjb21wbGV0aW9uIG9mIGEgZmVu Y2UKICAqIEBmZW5jZTogdGhlIGZlbmNlIHRvIHNpZ25hbApAQCAtMTcwLDE0ICszMjQsMTkgQEAg aW50IGRtYV9mZW5jZV9zaWduYWwoc3RydWN0IGRtYV9mZW5jZSAqZmVuY2UpCiB7CiAJdW5zaWdu ZWQgbG9uZyBmbGFnczsKIAlpbnQgcmV0OworCWJvb2wgdG1wOwogCiAJaWYgKCFmZW5jZSkKIAkJ cmV0dXJuIC1FSU5WQUw7CiAKKwl0bXAgPSBkbWFfZmVuY2VfYmVnaW5fc2lnbmFsbGluZygpOwor CiAJc3Bpbl9sb2NrX2lycXNhdmUoZmVuY2UtPmxvY2ssIGZsYWdzKTsKIAlyZXQgPSBkbWFfZmVu Y2Vfc2lnbmFsX2xvY2tlZChmZW5jZSk7CiAJc3Bpbl91bmxvY2tfaXJxcmVzdG9yZShmZW5jZS0+ bG9jaywgZmxhZ3MpOwogCisJZG1hX2ZlbmNlX2VuZF9zaWduYWxsaW5nKHRtcCk7CisKIAlyZXR1 cm4gcmV0OwogfQogRVhQT1JUX1NZTUJPTChkbWFfZmVuY2Vfc2lnbmFsKTsKQEAgLTIxMCw2ICsz NjksOCBAQCBkbWFfZmVuY2Vfd2FpdF90aW1lb3V0KHN0cnVjdCBkbWFfZmVuY2UgKmZlbmNlLCBi b29sIGludHIsIHNpZ25lZCBsb25nIHRpbWVvdXQpCiAKIAltaWdodF9zbGVlcCgpOwogCisJX19k bWFfZmVuY2VfbWlnaHRfd2FpdCgpOworCiAJdHJhY2VfZG1hX2ZlbmNlX3dhaXRfc3RhcnQoZmVu Y2UpOwogCWlmIChmZW5jZS0+b3BzLT53YWl0KQogCQlyZXQgPSBmZW5jZS0+b3BzLT53YWl0KGZl bmNlLCBpbnRyLCB0aW1lb3V0KTsKZGlmZiAtLWdpdCBhL2luY2x1ZGUvbGludXgvZG1hLWZlbmNl LmggYi9pbmNsdWRlL2xpbnV4L2RtYS1mZW5jZS5oCmluZGV4IDMzNDdjNTRmM2E4Ny4uM2YyODhm N2RiMmVmIDEwMDY0NAotLS0gYS9pbmNsdWRlL2xpbnV4L2RtYS1mZW5jZS5oCisrKyBiL2luY2x1 ZGUvbGludXgvZG1hLWZlbmNlLmgKQEAgLTM1Nyw2ICszNTcsMTggQEAgZG1hX2ZlbmNlX2dldF9y Y3Vfc2FmZShzdHJ1Y3QgZG1hX2ZlbmNlIF9fcmN1ICoqZmVuY2VwKQogCX0gd2hpbGUgKDEpOwog fQogCisjaWZkZWYgQ09ORklHX0xPQ0tERVAKK2Jvb2wgZG1hX2ZlbmNlX2JlZ2luX3NpZ25hbGxp bmcodm9pZCk7Cit2b2lkIGRtYV9mZW5jZV9lbmRfc2lnbmFsbGluZyhib29sIGNvb2tpZSk7Cisj ZWxzZQorc3RhdGljIGlubGluZSBib29sIGRtYV9mZW5jZV9iZWdpbl9zaWduYWxsaW5nKHZvaWQp Cit7CisJcmV0dXJuIHRydWU7Cit9CitzdGF0aWMgaW5saW5lIHZvaWQgZG1hX2ZlbmNlX2VuZF9z aWduYWxsaW5nKGJvb2wgY29va2llKSB7fQorc3RhdGljIGlubGluZSB2b2lkIF9fZG1hX2ZlbmNl X21pZ2h0X3dhaXQodm9pZCkge30KKyNlbmRpZgorCiBpbnQgZG1hX2ZlbmNlX3NpZ25hbChzdHJ1 Y3QgZG1hX2ZlbmNlICpmZW5jZSk7CiBpbnQgZG1hX2ZlbmNlX3NpZ25hbF9sb2NrZWQoc3RydWN0 IGRtYV9mZW5jZSAqZmVuY2UpOwogc2lnbmVkIGxvbmcgZG1hX2ZlbmNlX2RlZmF1bHRfd2FpdChz dHJ1Y3QgZG1hX2ZlbmNlICpmZW5jZSwKLS0gCjIuMjcuMAoKX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fX18KSW50ZWwtZ2Z4IG1haWxpbmcgbGlzdApJbnRlbC1n ZnhAbGlzdHMuZnJlZWRlc2t0b3Aub3JnCmh0dHBzOi8vbGlzdHMuZnJlZWRlc2t0b3Aub3JnL21h aWxtYW4vbGlzdGluZm8vaW50ZWwtZ2Z4Cg== 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_INVALID,DKIM_SIGNED, HEADER_FROM_DIFFERENT_DOMAINS,INCLUDES_PATCH,MAILING_LIST_MULTI,SIGNED_OFF_BY, SPF_HELO_NONE,SPF_PASS,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 115EBC433E7 for ; Tue, 7 Jul 2020 20:12:48 +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 DC0FD206BE for ; Tue, 7 Jul 2020 20:12:47 +0000 (UTC) Authentication-Results: mail.kernel.org; dkim=fail reason="signature verification failed" (1024-bit key) header.d=ffwll.ch header.i=@ffwll.ch header.b="fmFnnt+e" DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org DC0FD206BE Authentication-Results: mail.kernel.org; dmarc=none (p=none dis=none) header.from=ffwll.ch Authentication-Results: mail.kernel.org; spf=none smtp.mailfrom=amd-gfx-bounces@lists.freedesktop.org Received: from gabe.freedesktop.org (localhost [127.0.0.1]) by gabe.freedesktop.org (Postfix) with ESMTP id 2E8E66E233; Tue, 7 Jul 2020 20:12:45 +0000 (UTC) Received: from mail-wr1-x442.google.com (mail-wr1-x442.google.com [IPv6:2a00:1450:4864:20::442]) by gabe.freedesktop.org (Postfix) with ESMTPS id D98196E233 for ; Tue, 7 Jul 2020 20:12:43 +0000 (UTC) Received: by mail-wr1-x442.google.com with SMTP id z15so35313272wrl.8 for ; Tue, 07 Jul 2020 13:12:43 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=ffwll.ch; s=google; h=from:to:cc:subject:date:message-id:in-reply-to:references :mime-version:content-transfer-encoding; bh=+zqqvyi3z5A21ql34E5+vQaCHF2rAOOJAQR+upY9QO0=; b=fmFnnt+ehdq4yzSf5JNaqXX4yhCqAqD0kK0/qt4eB91lTy43C9BV8NE2+7bCE2dMEV j/iYq+xbAyWSUJE96U9SszSPGm8fuSDz412xfxFWlqIfJCVtYRTbtJZuwBEimFPr2Jzq SZeC88b3d2af3OnObiDD64/C7gkdSt0cAFrRU= X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references:mime-version:content-transfer-encoding; bh=+zqqvyi3z5A21ql34E5+vQaCHF2rAOOJAQR+upY9QO0=; b=fRM2z0FeS+rviNOYsquIirNWq6yqV8P7gER8qKoUu6tkQUhBfXT1PbEl1glzdh2n6i SFXUTjO1FZKqvMJTOOR0B83+8XSkyTjZXUlDmvm2XLIPLkQh3gu4Zu5NY2P5AS3EW1W2 MeTlsKUvuKLqCNBahLgMr8lVakv62uO+SrG5g/GK7le3UGiQFAAWfLBXYiRUz0uzfWLb 2VDAHz/WgNNmDH1twO8F8fUXYLpPgzvpaFGg7RCdo0LDOJUQO1vilnJ+h6VGpOmHFD8e yuplDs/K6y5HR0MM9sO2J6iDrh88xDn6ncIC8FwSVMsoLEVVDsZezjlGiYEzhziE+SSp QR8Q== X-Gm-Message-State: AOAM533cOouK8cfPxopCG1idf5HzvrfUvqfy30OnaQyL/RzpDnHWuanM 4F9tby4YVhjyOjBT3l2w9EltSMj8748= X-Google-Smtp-Source: ABdhPJzrfZJXwmqAifF26fj/gQn6kFUlKzxT6On6Iaf8irG4na4G4iK3mAJTIWo1H7s/v1Eotv4TeA== X-Received: by 2002:adf:cf0c:: with SMTP id o12mr54938782wrj.265.1594152762369; Tue, 07 Jul 2020 13:12:42 -0700 (PDT) Received: from phenom.ffwll.local ([2a02:168:57f4:0:efd0:b9e5:5ae6:c2fa]) by smtp.gmail.com with ESMTPSA id q7sm2515262wra.56.2020.07.07.13.12.40 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Tue, 07 Jul 2020 13:12:41 -0700 (PDT) From: Daniel Vetter To: DRI Development Subject: [PATCH 01/25] dma-fence: basic lockdep annotations Date: Tue, 7 Jul 2020 22:12:05 +0200 Message-Id: <20200707201229.472834-2-daniel.vetter@ffwll.ch> X-Mailer: git-send-email 2.27.0 In-Reply-To: <20200707201229.472834-1-daniel.vetter@ffwll.ch> References: <20200707201229.472834-1-daniel.vetter@ffwll.ch> MIME-Version: 1.0 X-BeenThere: amd-gfx@lists.freedesktop.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: Discussion list for AMD gfx List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Cc: =?UTF-8?q?Christian=20K=C3=B6nig?= , linux-rdma@vger.kernel.org, Daniel Vetter , Intel Graphics Development , Maarten Lankhorst , amd-gfx@lists.freedesktop.org, Chris Wilson , linaro-mm-sig@lists.linaro.org, =?UTF-8?q?Thomas=20Hellstr=C3=B6m?= , Daniel Vetter , linux-media@vger.kernel.org, Felix Kuehling , Mika Kuoppala Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Errors-To: amd-gfx-bounces@lists.freedesktop.org Sender: "amd-gfx" RGVzaWduIGlzIHNpbWlsYXIgdG8gdGhlIGxvY2tkZXAgYW5ub3RhdGlvbnMgZm9yIHdvcmtlcnMs IGJ1dCB3aXRoCnNvbWUgdHdpc3RzOgoKLSBXZSB1c2UgYSByZWFkLWxvY2sgZm9yIHRoZSBleGVj dXRpb24vd29ya2VyL2NvbXBsZXRpb24gc2lkZSwgc28gdGhhdAogIHRoaXMgZXhwbGljaXQgYW5u b3RhdGlvbiBjYW4gYmUgbW9yZSBsaWJlcmFsbHkgc3ByaW5rbGVkIGFyb3VuZC4KICBXaXRoIHJl YWQgbG9ja3MgbG9ja2RlcCBpc24ndCBnb2luZyB0byBjb21wbGFpbiBpZiB0aGUgcmVhZC1zaWRl CiAgaXNuJ3QgbmVzdGVkIHRoZSBzYW1lIHdheSB1bmRlciBhbGwgY2lyY3Vtc3RhbmNlcywgc28g QUJCQSBkZWFkbG9ja3MKICBhcmUgb2suIFdoaWNoIHRoZXkgYXJlLCBzaW5jZSB0aGlzIGlzIGFu IGFubm90YXRpb24gb25seS4KCi0gV2UncmUgdXNpbmcgbm9uLXJlY3Vyc2l2ZSBsb2NrZGVwIHJl YWQgbG9jayBtb2RlLCBzaW5jZSBpbiByZWN1cnNpdmUKICByZWFkIGxvY2sgbW9kZSBsb2NrZGVw IGRvZXMgbm90IGNhdGNoIHJlYWQgc2lkZSBoYXphcmRzLiBBbmQgd2UKICBfdmVyeV8gbXVjaCB3 YW50IHJlYWQgc2lkZSBoYXphcmRzIHRvIGJlIGNhdWdodC4gRm9yIGZ1bGwgZGV0YWlscyBvZgog IHRoaXMgbGltaXRhdGlvbiBzZWUKCiAgY29tbWl0IGU5MTQ5ODU4OTc0NjA2NWUzYWU5NWQ5YTAw YjA2OGU1MjVlZWMzNGYKICBBdXRob3I6IFBldGVyIFppamxzdHJhIDxwZXRlcnpAaW5mcmFkZWFk Lm9yZz4KICBEYXRlOiAgIFdlZCBBdWcgMjMgMTM6MTM6MTEgMjAxNyArMDIwMAoKICAgICAgbG9j a2luZy9sb2NrZGVwL3NlbGZ0ZXN0czogQWRkIG1peGVkIHJlYWQtd3JpdGUgQUJCQSB0ZXN0cwoK LSBUbyBhbGxvdyBuZXN0aW5nIG9mIHRoZSByZWFkLXNpZGUgZXhwbGljaXQgYW5ub3RhdGlvbnMg d2UgZXhwbGljaXRseQogIGtlZXAgdHJhY2sgb2YgdGhlIG5lc3RpbmcuIGxvY2tfaXNfaGVsZCgp IGFsbG93cyB1cyB0byBkbyB0aGF0LgoKLSBUaGUgd2FpdC1zaWRlIGFubm90YXRpb24gaXMgYSB3 cml0ZSBsb2NrLCBhbmQgZW50aXJlbHkgZG9uZSB3aXRoaW4KICBkbWFfZmVuY2Vfd2FpdCgpIGZv ciBldmVyeW9uZSBieSBkZWZhdWx0LgoKLSBUbyBiZSBhYmxlIHRvIGZyZWVseSBhbm5vdGF0ZSBo ZWxwZXIgZnVuY3Rpb25zIEkgd2FudCB0byBtYWtlIGl0IG9rCiAgdG8gY2FsbCBkbWFfZmVuY2Vf YmVnaW4vZW5kX3NpZ25hbGxpbmcgZnJvbSBzb2Z0L2hhcmRpcnEgY29udGV4dC4KICBGaXJzdCBh dHRlbXB0IHdhcyB1c2luZyB0aGUgaGFyZGlycSBsb2NraW5nIGNvbnRleHQgZm9yIHRoZSB3cml0 ZQogIHNpZGUgaW4gbG9ja2RlcCwgYnV0IHRoaXMgZm9yY2VzIGFsbCBub3JtYWwgc3BpbmxvY2tz IG5lc3RlZCB3aXRoaW4KICBkbWFfZmVuY2VfYmVnaW4vZW5kX3NpZ25hbGxpbmcgdG8gYmUgc3Bp bmxvY2tzLiBUaGF0IGJvbGxvY2tzLgoKICBUaGUgYXBwcm9hY2ggbm93IGlzIHRvIHNpbXBsZSBj aGVjayBpbl9hdG9taWMoKSwgYW5kIGZvciB0aGVzZSBjYXNlcwogIGVudGlyZWx5IHJlbHkgb24g dGhlIG1pZ2h0X3NsZWVwKCkgY2hlY2sgaW4gZG1hX2ZlbmNlX3dhaXQoKS4gVGhhdAogIHdpbGwg Y2F0Y2ggYW55IHdyb25nIG5lc3RpbmcgYWdhaW5zdCBzcGlubG9ja3MgZnJvbSBzb2Z0L2hhcmRp cnEKICBjb250ZXh0cy4KClRoZSBpZGVhIGhlcmUgaXMgdGhhdCBldmVyeSBjb2RlIHBhdGggdGhh dCdzIGNyaXRpY2FsIGZvciBldmVudHVhbGx5CnNpZ25hbGxpbmcgYSBkbWFfZmVuY2Ugc2hvdWxk IGJlIGFubm90YXRlZCB3aXRoCmRtYV9mZW5jZV9iZWdpbi9lbmRfc2lnbmFsbGluZy4gVGhlIGFu bm90YXRpb24gaWRlYWxseSBzdGFydHMgcmlnaHQKYWZ0ZXIgYSBkbWFfZmVuY2UgaXMgcHVibGlz aGVkIChhZGRlZCB0byBhIGRtYV9yZXN2LCBleHBvc2VkIGFzIGEKc3luY19maWxlIGZkLCBhdHRh Y2hlZCB0byBhIGRybV9zeW5jb2JqIGZkLCBvciBhbnl0aGluZyBlbHNlIHRoYXQKbWFrZXMgdGhl IGRtYV9mZW5jZSB2aXNpYmxlIHRvIG90aGVyIGtlcm5lbCB0aHJlYWRzKSwgdXAgdG8gYW5kCmlu Y2x1ZGluZyB0aGUgZG1hX2ZlbmNlX3dhaXQoKS4gRXhhbXBsZXMgYXJlIGlycSBoYW5kbGVycywg dGhlCnNjaGVkdWxlciBydCB0aHJlYWRzLCB0aGUgdGFpbCBvZiBleGVjYnVmIChhZnRlciB0aGUg Y29ycmVzcG9uZGluZwpmZW5jZXMgYXJlIHZpc2libGUpLCBhbnkgd29ya2VycyB0aGF0IGVuZCB1 cCBzaWduYWxsaW5nIGRtYV9mZW5jZXMgYW5kCnJlYWxseSBhbnl0aGluZyBlbHNlLiBOb3QgYW5u b3RhdGVkIHNob3VsZCBiZSBjb2RlIHBhdGhzIHRoYXQgb25seQpjb21wbGV0ZSBmZW5jZXMgb3Bw b3J0dW5pc3RpY2FsbHkgYXMgdGhlIGdwdSBwcm9ncmVzc2VzLCBsaWtlIGUuZy4Kc2hyaW5rZXIv ZXZpY3Rpb24gY29kZS4KClRoZSBtYWluIGNsYXNzIG9mIGRlYWRsb2NrcyB0aGlzIGlzIHN1cHBv c2VkIHRvIGNhdGNoIGFyZToKClRocmVhZCBBOgoKCW11dGV4X2xvY2soQSk7CgltdXRleF91bmxv Y2soQSk7CgoJZG1hX2ZlbmNlX3NpZ25hbCgpOwoKVGhyZWFkIEI6CgoJbXV0ZXhfbG9jayhBKTsK CWRtYV9mZW5jZV93YWl0KCk7CgltdXRleF91bmxvY2soQSk7CgpUaHJlYWQgQiBpcyBibG9ja2Vk IG9uIEEgc2lnbmFsbGluZyB0aGUgZmVuY2UsIGJ1dCBBIG5ldmVyIGdldHMgYXJvdW5kCnRvIHRo YXQgYmVjYXVzZSBpdCBjYW5ub3QgYWNxdWlyZSB0aGUgbG9jayBBLgoKTm90ZSB0aGF0IGRtYV9m ZW5jZV93YWl0KCkgaXMgYWxsb3dlZCB0byBiZSBuZXN0ZWQgd2l0aGluCmRtYV9mZW5jZV9iZWdp bi9lbmRfc2lnbmFsbGluZyBzZWN0aW9ucy4gVG8gYWxsb3cgdGhpcyB0byBoYXBwZW4gdGhlCnJl YWQgbG9jayBuZWVkcyB0byBiZSB1cGdyYWRlZCB0byBhIHdyaXRlIGxvY2ssIHdoaWNoIG1lYW5z IHRoYXQgYW55Cm90aGVyIGxvY2sgaXMgYWNxdWlyZWQgYmV0d2VlbiB0aGUgZG1hX2ZlbmNlX2Jl Z2luX3NpZ25hbGxpbmcoKSBjYWxsIGFuZAp0aGUgY2FsbCB0byBkbWFfZmVuY2Vfd2FpdCgpLCBh bmQgc3RpbGwgaGVsZCwgdGhpcyB3aWxsIHJlc3VsdCBpbiBhbgppbW1lZGlhdGUgbG9ja2RlcCBj b21wbGFpbnQuIFRoZSBvbmx5IG90aGVyIG9wdGlvbiB3b3VsZCBiZSB0byBub3QKYW5ub3RhdGUg c3VjaCBjYWxscywgZGVmZWF0aW5nIHRoZSBwb2ludC4gVGhlcmVmb3JlIHRoZXNlIGFubm90YXRp b25zCmNhbm5vdCBiZSBzcHJpbmtsZWQgb3ZlciB0aGUgY29kZSBlbnRpcmVseSBtaW5kbGVzcyB0 byBhdm9pZCBmYWxzZQpwb3NpdGl2ZXMuCgpPcmlnaW5hbGx5IEkgaG9wZSB0aGF0IHRoZSBjcm9z cy1yZWxlYXNlIGxvY2tkZXAgZXh0ZW5zaW9ucyB3b3VsZAphbGxldmlhdGUgdGhlIG5lZWQgZm9y IGV4cGxpY2l0IGFubm90YXRpb25zOgoKaHR0cHM6Ly9sd24ubmV0L0FydGljbGVzLzcwOTg0OS8K CkJ1dCB0aGVyZSdzIGEgZmV3IHJlYXNvbnMgd2h5IHRoYXQncyBub3QgYW4gb3B0aW9uOgoKLSBJ dCdzIG5vdCBoYXBwZW5pbmcgaW4gdXBzdHJlYW0sIHNpbmNlIGl0IGdvdCByZXZlcnRlZCBkdWUg dG8gdG9vCiAgbWFueSBmYWxzZSBwb3NpdGl2ZXM6CgoJY29tbWl0IGU5NjZlYWVlYjYyM2YwOTk3 NWVmMzYyYzI4NjZmYWU2Zjg2ODQ0ZjkKCUF1dGhvcjogSW5nbyBNb2xuYXIgPG1pbmdvQGtlcm5l bC5vcmc+CglEYXRlOiAgIFR1ZSBEZWMgMTIgMTI6MzE6MTYgMjAxNyArMDEwMAoKCSAgICBsb2Nr aW5nL2xvY2tkZXA6IFJlbW92ZSB0aGUgY3Jvc3MtcmVsZWFzZSBsb2NraW5nIGNoZWNrcwoKCSAg ICBUaGlzIGNvZGUgKENPTkZJR19MT0NLREVQX0NST1NTUkVMRUFTRT15IGFuZCBDT05GSUdfTE9D S0RFUF9DT01QTEVUSU9OUz15KSwKCSAgICB3aGlsZSBpdCBmb3VuZCBhIG51bWJlciBvZiBvbGQg YnVncyBpbml0aWFsbHksIHdhcyBhbHNvIGNhdXNpbmcgdG9vIG1hbnkKCSAgICBmYWxzZSBwb3Np dGl2ZXMgdGhhdCBjYXVzZWQgcGVvcGxlIHRvIGRpc2FibGUgbG9ja2RlcCAtIHdoaWNoIGlzIGFy Z3VhYmx5CgkgICAgYSB3b3JzZSBvdmVyYWxsIG91dGNvbWUuCgotIGNyb3NzLXJlbGVhc2UgdXNl cyB0aGUgY29tcGxldGUoKSBjYWxsIHRvIGFubm90YXRlIHRoZSBlbmQgb2YKICBjcml0aWNhbCBz ZWN0aW9ucywgZm9yIGRtYV9mZW5jZSB0aGF0IHdvdWxkIGJlIGRtYV9mZW5jZV9zaWduYWwoKS4K ICBCdXQgd2UgZG8gbm90IHdhbnQgYWxsIGRtYV9mZW5jZV9zaWduYWwoKSBjYWxscyB0byBiZSB0 cmVhdGVkIGFzCiAgY3JpdGljYWwsIHNpbmNlIG1hbnkgYXJlIG9wcG9ydHVuaXN0aWMgY2xlYW51 cCBvZiBncHUgcmVxdWVzdHMuIElmCiAgdGhlc2UgZ2V0IHN0dWNrIHRoZXJlJ3Mgc3RpbGwgdGhl IG1haW4gY29tcGxldGlvbiBpbnRlcnJ1cHQgYW5kCiAgd29ya2VycyB3aG8gY2FuIHVuYmxvY2sg ZXZlcnlvbmUuIEF1dG9tYXRpY2FsbHkgYW5ub3RhdGluZyBhbGwKICBkbWFfZmVuY2Vfc2lnbmFs KCkgY2FsbHMgd291bGQgaGVuY2UgY2F1c2UgZmFsc2UgcG9zaXRpdmVzLgoKLSBjcm9zcy1yZWxl YXNlIGhhZCBzb21lIGVkdWNhdGVkIGd1ZXNzZXMgZm9yIHdoZW4gYSBjcml0aWNhbCBzZWN0aW9u CiAgc3RhcnRzLCBsaWtlIGZyZXNoIHN5c2NhbGwgb3IgZnJlc2ggd29yayBjYWxsYmFjay4gVGhp cyB3b3VsZCBhZ2FpbgogIGNhdXNlIGZhbHNlIHBvc2l0aXZlcyB3aXRob3V0IGV4cGxpY2l0IGFu bm90YXRpb25zLCBzaW5jZSBmb3IKICBkbWFfZmVuY2UgdGhlIGNyaXRpY2FsIHNlY3Rpb25zIG9u bHkgc3RhcnRzIHdoZW4gd2UgcHVibGlzaCBhIGZlbmNlLgoKLSBGdXJ0aGVybW9yZSB0aGVyZSBj YW4gYmUgY2FzZXMgd2hlcmUgYSB0aHJlYWQgbmV2ZXIgZG9lcyBhCiAgZG1hX2ZlbmNlX3NpZ25h bCwgYnV0IGlzIHN0aWxsIGNyaXRpY2FsIGZvciByZWFjaGluZyBjb21wbGV0aW9uIG9mCiAgZmVu Y2VzLiBPbmUgZXhhbXBsZSB3b3VsZCBiZSBhIHNjaGVkdWxlciBrdGhyZWFkIHdoaWNoIHBpY2tz IHVwIGpvYnMKICBhbmQgcHVzaGVzIHRoZW0gaW50byBoYXJkd2FyZSwgd2hlcmUgdGhlIGludGVy cnVwdCBoYW5kbGVyIG9yCiAgYW5vdGhlciBjb21wbGV0aW9uIHRocmVhZCBjYWxscyBkbWFfZmVu Y2Vfc2lnbmFsKCkuIEJ1dCBpZiB0aGUKICBzY2hlZHVsZXIgdGhyZWFkIGhhbmdzLCB0aGVuIGFs bCB0aGUgZmVuY2VzIGhhbmcsIGhlbmNlIHdlIG5lZWQgdG8KICBtYW51YWxseSBhbm5vdGF0ZSBp dC4gY3Jvc3MtcmVsZWFzZSBhaW1lZCB0byBzb2x2ZSB0aGlzIGJ5IGNoYWluaW5nCiAgY3Jvc3Mt cmVsZWFzZSBkZXBlbmRlbmNpZXMsIGJ1dCB0aGUgZGVwZW5kZW5jeSBmcm9tIHNjaGVkdWxlciB0 aHJlYWQKICB0byB0aGUgY29tcGxldGlvbiBpbnRlcnJ1cHQgaGFuZGxlciBnb2VzIHRocm91Z2gg aHcgd2hlcmUKICBjcm9zcy1yZWxlYXNlIGNvZGUgY2FuJ3Qgb2JzZXJ2ZSBpdC4KCkluIHNob3J0 LCB3aXRob3V0IG1hbnVhbCBhbm5vdGF0aW9ucyBhbmQgY2FyZWZ1bCByZXZpZXcgb2YgdGhlIHN0 YXJ0CmFuZCBlbmQgb2YgY3JpdGljYWwgc2VjdGlvbnMsIGNyb3NzLXJlbGVzZSBkZXBlbmRlbmN5 IHRyYWNraW5nIGRvZXNuJ3QKd29yay4gV2UgbmVlZCBleHBsaWNpdCBhbm5vdGF0aW9ucy4KCnYy OiBoYW5kbGUgc29mdC9oYXJkaXJxIGN0eCBiZXR0ZXIgYWdhaW5zdCB3cml0ZSBzaWRlIGFuZCBk b250IGZvcmdldApFWFBPUlRfU1lNQk9MLCBkcml2ZXJzIGNhbid0IHVzZSB0aGlzIG90aGVyd2lz ZS4KCnYzOiBLZXJuZWxkb2MuCgp2NDogU29tZSBzcGVsbGluZyBmaXhlcyBmcm9tIE1pa2EKCnY1 OiBBbWVuZCBjb21taXQgbWVzc2FnZSB0byBleHBsYWluIGluIGRldGFpbCB3aHkgY3Jvc3MtcmVs ZWFzZSBpc24ndAp0aGUgc29sdXRpb24uCgp2NjogUHVsbCBvdXQgbWlzcGxhY2VkIC5yc3QgaHVu ay4KCkNjOiBGZWxpeCBLdWVobGluZyA8RmVsaXguS3VlaGxpbmdAYW1kLmNvbT4KUmV2aWV3ZWQt Ynk6IFRob21hcyBIZWxsc3Ryw7ZtIDx0aG9tYXMuaGVsbHN0cm9tQGludGVsLmNvbT4KUmV2aWV3 ZWQtYnk6IE1hYXJ0ZW4gTGFua2hvcnN0IDxtYWFydGVuLmxhbmtob3JzdEBsaW51eC5pbnRlbC5j b20+CkNjOiBNaWthIEt1b3BwYWxhIDxtaWthLmt1b3BwYWxhQGludGVsLmNvbT4KQ2M6IFRob21h cyBIZWxsc3Ryb20gPHRob21hcy5oZWxsc3Ryb21AaW50ZWwuY29tPgpDYzogbGludXgtbWVkaWFA dmdlci5rZXJuZWwub3JnCkNjOiBsaW5hcm8tbW0tc2lnQGxpc3RzLmxpbmFyby5vcmcKQ2M6IGxp bnV4LXJkbWFAdmdlci5rZXJuZWwub3JnCkNjOiBhbWQtZ2Z4QGxpc3RzLmZyZWVkZXNrdG9wLm9y ZwpDYzogaW50ZWwtZ2Z4QGxpc3RzLmZyZWVkZXNrdG9wLm9yZwpDYzogQ2hyaXMgV2lsc29uIDxj aHJpc0BjaHJpcy13aWxzb24uY28udWs+CkNjOiBNYWFydGVuIExhbmtob3JzdCA8bWFhcnRlbi5s YW5raG9yc3RAbGludXguaW50ZWwuY29tPgpDYzogQ2hyaXN0aWFuIEvDtm5pZyA8Y2hyaXN0aWFu LmtvZW5pZ0BhbWQuY29tPgpTaWduZWQtb2ZmLWJ5OiBEYW5pZWwgVmV0dGVyIDxkYW5pZWwudmV0 dGVyQGludGVsLmNvbT4KLS0tCiBEb2N1bWVudGF0aW9uL2RyaXZlci1hcGkvZG1hLWJ1Zi5yc3Qg fCAgIDYgKwogZHJpdmVycy9kbWEtYnVmL2RtYS1mZW5jZS5jICAgICAgICAgIHwgMTYxICsrKysr KysrKysrKysrKysrKysrKysrKysrKwogaW5jbHVkZS9saW51eC9kbWEtZmVuY2UuaCAgICAgICAg ICAgIHwgIDEyICsrCiAzIGZpbGVzIGNoYW5nZWQsIDE3OSBpbnNlcnRpb25zKCspCgpkaWZmIC0t Z2l0IGEvRG9jdW1lbnRhdGlvbi9kcml2ZXItYXBpL2RtYS1idWYucnN0IGIvRG9jdW1lbnRhdGlv bi9kcml2ZXItYXBpL2RtYS1idWYucnN0CmluZGV4IDdmYjdiNjYxZmViZC4uMDVkODU2MTMxMTQw IDEwMDY0NAotLS0gYS9Eb2N1bWVudGF0aW9uL2RyaXZlci1hcGkvZG1hLWJ1Zi5yc3QKKysrIGIv RG9jdW1lbnRhdGlvbi9kcml2ZXItYXBpL2RtYS1idWYucnN0CkBAIC0xMzMsNiArMTMzLDEyIEBA IERNQSBGZW5jZXMKIC4uIGtlcm5lbC1kb2M6OiBkcml2ZXJzL2RtYS1idWYvZG1hLWZlbmNlLmMK ICAgIDpkb2M6IERNQSBmZW5jZXMgb3ZlcnZpZXcKIAorRE1BIEZlbmNlIFNpZ25hbGxpbmcgQW5u b3RhdGlvbnMKK35+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+CisKKy4uIGtlcm5lbC1k b2M6OiBkcml2ZXJzL2RtYS1idWYvZG1hLWZlbmNlLmMKKyAgIDpkb2M6IGZlbmNlIHNpZ25hbGxp bmcgYW5ub3RhdGlvbgorCiBETUEgRmVuY2VzIEZ1bmN0aW9ucyBSZWZlcmVuY2UKIH5+fn5+fn5+ fn5+fn5+fn5+fn5+fn5+fn5+fn5+fgogCmRpZmYgLS1naXQgYS9kcml2ZXJzL2RtYS1idWYvZG1h LWZlbmNlLmMgYi9kcml2ZXJzL2RtYS1idWYvZG1hLWZlbmNlLmMKaW5kZXggNjU2ZTlhYzJkMDI4 Li4wMDA1YmMwMDI1MjkgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvZG1hLWJ1Zi9kbWEtZmVuY2UuYwor KysgYi9kcml2ZXJzL2RtYS1idWYvZG1hLWZlbmNlLmMKQEAgLTExMCw2ICsxMTAsMTYwIEBAIHU2 NCBkbWFfZmVuY2VfY29udGV4dF9hbGxvYyh1bnNpZ25lZCBudW0pCiB9CiBFWFBPUlRfU1lNQk9M KGRtYV9mZW5jZV9jb250ZXh0X2FsbG9jKTsKIAorLyoqCisgKiBET0M6IGZlbmNlIHNpZ25hbGxp bmcgYW5ub3RhdGlvbgorICoKKyAqIFByb3ZpbmcgY29ycmVjdG5lc3Mgb2YgYWxsIHRoZSBrZXJu ZWwgY29kZSBhcm91bmQgJmRtYV9mZW5jZSB0aHJvdWdoIGNvZGUKKyAqIHJldmlldyBhbmQgdGVz dGluZyBpcyB0cmlja3kgZm9yIGEgZmV3IHJlYXNvbnM6CisgKgorICogKiBJdCBpcyBhIGNyb3Nz LWRyaXZlciBjb250cmFjdCwgYW5kIHRoZXJlZm9yZSBhbGwgZHJpdmVycyBtdXN0IGZvbGxvdyB0 aGUKKyAqICAgc2FtZSBydWxlcyBmb3IgbG9jayBuZXN0aW5nIG9yZGVyLCBjYWxsaW5nIGNvbnRl eHRzIGZvciB2YXJpb3VzIGZ1bmN0aW9ucworICogICBhbmQgYW55dGhpbmcgZWxzZSBzaWduaWZp Y2FudCBmb3IgaW4ta2VybmVsIGludGVyZmFjZXMuIEJ1dCBpdCBpcyBhbHNvCisgKiAgIGltcG9z c2libGUgdG8gdGVzdCBhbGwgZHJpdmVycyBpbiBhIHNpbmdsZSBtYWNoaW5lLCBoZW5jZSBicnV0 ZS1mb3JjZSBOIHZzLgorICogICBOIHRlc3Rpbmcgb2YgYWxsIGNvbWJpbmF0aW9ucyBpcyBpbXBv c3NpYmxlLiBFdmVuIGp1c3QgbGltaXRpbmcgdG8gdGhlCisgKiAgIHBvc3NpYmxlIGNvbWJpbmF0 aW9ucyBpcyBpbmZlYXNpYmxlLgorICoKKyAqICogVGhlcmUgaXMgYW4gZW5vcm1vdXMgYW1vdW50 IG9mIGRyaXZlciBjb2RlIGludm9sdmVkLiBGb3IgcmVuZGVyIGRyaXZlcnMKKyAqICAgdGhlcmUn cyB0aGUgdGFpbCBvZiBjb21tYW5kIHN1Ym1pc3Npb24sIGFmdGVyIGZlbmNlcyBhcmUgcHVibGlz aGVkLAorICogICBzY2hlZHVsZXIgY29kZSwgaW50ZXJydXB0IGFuZCB3b3JrZXJzIHRvIHByb2Nl c3Mgam9iIGNvbXBsZXRpb24sCisgKiAgIGFuZCB0aW1lb3V0LCBncHUgcmVzZXQgYW5kIGdwdSBo YW5nIHJlY292ZXJ5IGNvZGUuIFBsdXMgZm9yIGludGVncmF0aW9uCisgKiAgIHdpdGggY29yZSBt bSB3aXRoIGhhdmUgJm1tdV9ub3RpZmllciwgcmVzcGVjdGl2ZWx5ICZtbXVfaW50ZXJ2YWxfbm90 aWZpZXIsCisgKiAgIGFuZCAmc2hyaW5rZXIuIEZvciBtb2Rlc2V0dGluZyBkcml2ZXJzIHRoZXJl J3MgdGhlIGNvbW1pdCB0YWlsIGZ1bmN0aW9ucworICogICBiZXR3ZWVuIHdoZW4gZmVuY2VzIGZv ciBhbiBhdG9taWMgbW9kZXNldCBhcmUgcHVibGlzaGVkLCBhbmQgd2hlbiB0aGUKKyAqICAgY29y cmVzcG9uZGluZyB2YmxhbmsgY29tcGxldGVzLCBpbmNsdWRpbmcgYW55IGludGVycnVwdCBwcm9j ZXNzaW5nIGFuZAorICogICByZWxhdGVkIHdvcmtlcnMuIEF1ZGl0aW5nIGFsbCB0aGF0IGNvZGUs IGFjcm9zcyBhbGwgZHJpdmVycywgaXMgbm90CisgKiAgIGZlYXNpYmxlLgorICoKKyAqICogRHVl IHRvIGhvdyBtYW55IG90aGVyIHN1YnN5c3RlbXMgYXJlIGludm9sdmVkIGFuZCB0aGUgbG9ja2lu ZyBoaWVyYXJjaGllcworICogICB0aGlzIHB1bGxzIGluIHRoZXJlIGlzIGV4dHJlbWVseSB0aGlu IHdpZ2dsZS1yb29tIGZvciBkcml2ZXItc3BlY2lmaWMKKyAqICAgZGlmZmVyZW5jZXMuICZkbWFf ZmVuY2UgaW50ZXJhY3RzIHdpdGggYWxtb3N0IGFsbCBvZiB0aGUgY29yZSBtZW1vcnkKKyAqICAg aGFuZGxpbmcgdGhyb3VnaCBwYWdlIGZhdWx0IGhhbmRsZXJzIHZpYSAmZG1hX3Jlc3YsIGRtYV9y ZXN2X2xvY2soKSBhbmQKKyAqICAgZG1hX3Jlc3ZfdW5sb2NrKCkuIE9uIHRoZSBvdGhlciBzaWRl IGl0IGFsc28gaW50ZXJhY3RzIHRocm91Z2ggYWxsCisgKiAgIGFsbG9jYXRpb24gc2l0ZXMgdGhy b3VnaCAmbW11X25vdGlmaWVyIGFuZCAmc2hyaW5rZXIuCisgKgorICogRnVydGhlcm1vcmUgbG9j a2RlcCBkb2VzIG5vdCBoYW5kbGUgY3Jvc3MtcmVsZWFzZSBkZXBlbmRlbmNpZXMsIHdoaWNoIG1l YW5zCisgKiBhbnkgZGVhZGxvY2tzIGJldHdlZW4gZG1hX2ZlbmNlX3dhaXQoKSBhbmQgZG1hX2Zl bmNlX3NpZ25hbCgpIGNhbid0IGJlIGNhdWdodAorICogYXQgcnVudGltZSB3aXRoIHNvbWUgcXVp Y2sgdGVzdGluZy4gVGhlIHNpbXBsZXN0IGV4YW1wbGUgaXMgb25lIHRocmVhZAorICogd2FpdGlu ZyBvbiBhICZkbWFfZmVuY2Ugd2hpbGUgaG9sZGluZyBhIGxvY2s6OgorICoKKyAqICAgICBsb2Nr KEEpOworICogICAgIGRtYV9mZW5jZV93YWl0KEIpOworICogICAgIHVubG9jayhBKTsKKyAqCisg KiB3aGlsZSB0aGUgb3RoZXIgdGhyZWFkIGlzIHN0dWNrIHRyeWluZyB0byBhY3F1aXJlIHRoZSBz YW1lIGxvY2ssIHdoaWNoCisgKiBwcmV2ZW50cyBpdCBmcm9tIHNpZ25hbGxpbmcgdGhlIGZlbmNl IHRoZSBwcmV2aW91cyB0aHJlYWQgaXMgc3R1Y2sgd2FpdGluZworICogb246OgorICoKKyAqICAg ICBsb2NrKEEpOworICogICAgIHVubG9jayhBKTsKKyAqICAgICBkbWFfZmVuY2Vfc2lnbmFsKEIp OworICoKKyAqIEJ5IG1hbnVhbGx5IGFubm90YXRpbmcgYWxsIGNvZGUgcmVsZXZhbnQgdG8gc2ln bmFsbGluZyBhICZkbWFfZmVuY2Ugd2UgY2FuCisgKiB0ZWFjaCBsb2NrZGVwIGFib3V0IHRoZXNl IGRlcGVuZGVuY2llcywgd2hpY2ggYWxzbyBoZWxwcyB3aXRoIHRoZSB2YWxpZGF0aW9uCisgKiBo ZWFkYWNoZSBzaW5jZSBub3cgbG9ja2RlcCBjYW4gY2hlY2sgYWxsIHRoZSBydWxlcyBmb3IgdXM6 OgorICoKKyAqICAgIGNvb2tpZSA9IGRtYV9mZW5jZV9iZWdpbl9zaWduYWxsaW5nKCk7CisgKiAg ICBsb2NrKEEpOworICogICAgdW5sb2NrKEEpOworICogICAgZG1hX2ZlbmNlX3NpZ25hbChCKTsK KyAqICAgIGRtYV9mZW5jZV9lbmRfc2lnbmFsbGluZyhjb29raWUpOworICoKKyAqIEZvciB1c2lu ZyBkbWFfZmVuY2VfYmVnaW5fc2lnbmFsbGluZygpIGFuZCBkbWFfZmVuY2VfZW5kX3NpZ25hbGxp bmcoKSB0bworICogYW5ub3RhdGUgY3JpdGljYWwgc2VjdGlvbnMgdGhlIGZvbGxvd2luZyBydWxl cyBuZWVkIHRvIGJlIG9ic2VydmVkOgorICoKKyAqICogQWxsIGNvZGUgbmVjZXNzYXJ5IHRvIGNv bXBsZXRlIGEgJmRtYV9mZW5jZSBtdXN0IGJlIGFubm90YXRlZCwgZnJvbSB0aGUKKyAqICAgcG9p bnQgd2hlcmUgYSBmZW5jZSBpcyBhY2Nlc3NpYmxlIHRvIG90aGVyIHRocmVhZHMsIHRvIHRoZSBw b2ludCB3aGVyZQorICogICBkbWFfZmVuY2Vfc2lnbmFsKCkgaXMgY2FsbGVkLiBVbi1hbm5vdGF0 ZWQgY29kZSBjYW4gY29udGFpbiBkZWFkbG9jayBpc3N1ZXMsCisgKiAgIGFuZCBkdWUgdG8gdGhl IHZlcnkgc3RyaWN0IHJ1bGVzIGFuZCBtYW55IGNvcm5lciBjYXNlcyBpdCBpcyBpbmZlYXNpYmxl IHRvCisgKiAgIGNhdGNoIHRoZXNlIGp1c3Qgd2l0aCByZXZpZXcgb3Igbm9ybWFsIHN0cmVzcyB0 ZXN0aW5nLgorICoKKyAqICogJnN0cnVjdCBkbWFfcmVzdiBkZXNlcnZlcyBhIHNwZWNpYWwgbm90 ZSwgc2luY2UgdGhlIHJlYWRlcnMgYXJlIG9ubHkKKyAqICAgcHJvdGVjdGVkIGJ5IHJjdS4gVGhp cyBtZWFucyB0aGUgc2lnbmFsbGluZyBjcml0aWNhbCBzZWN0aW9uIHN0YXJ0cyBhcyBzb29uCisg KiAgIGFzIHRoZSBuZXcgZmVuY2VzIGFyZSBpbnN0YWxsZWQsIGV2ZW4gYmVmb3JlIGRtYV9yZXN2 X3VubG9jaygpIGlzIGNhbGxlZC4KKyAqCisgKiAqIFRoZSBvbmx5IGV4Y2VwdGlvbiBhcmUgZmFz dCBwYXRocyBhbmQgb3Bwb3J0dW5pc3RpYyBzaWduYWxsaW5nIGNvZGUsIHdoaWNoCisgKiAgIGNh bGxzIGRtYV9mZW5jZV9zaWduYWwoKSBwdXJlbHkgYXMgYW4gb3B0aW1pemF0aW9uLCBidXQgaXMg bm90IHJlcXVpcmVkIHRvCisgKiAgIGd1YXJhbnRlZSBjb21wbGV0aW9uIG9mIGEgJmRtYV9mZW5j ZS4gVGhlIHVzdWFsIGV4YW1wbGUgaXMgYSB3YWl0IElPQ1RMCisgKiAgIHdoaWNoIGNhbGxzIGRt YV9mZW5jZV9zaWduYWwoKSwgd2hpbGUgdGhlIG1hbmRhdG9yeSBjb21wbGV0aW9uIHBhdGggZ29l cworICogICB0aHJvdWdoIGEgaGFyZHdhcmUgaW50ZXJydXB0IGFuZCBwb3NzaWJsZSBqb2IgY29t cGxldGlvbiB3b3JrZXIuCisgKgorICogKiBUbyBhaWQgY29tcG9zYWJpbGl0eSBvZiBjb2RlLCB0 aGUgYW5ub3RhdGlvbnMgY2FuIGJlIGZyZWVseSBuZXN0ZWQsIGFzIGxvbmcKKyAqICAgYXMgdGhl IG92ZXJhbGwgbG9ja2luZyBoaWVyYXJjaHkgaXMgY29uc2lzdGVudC4gVGhlIGFubm90YXRpb25z IGFsc28gd29yaworICogICBib3RoIGluIGludGVycnVwdCBhbmQgcHJvY2VzcyBjb250ZXh0LiBE dWUgdG8gaW1wbGVtZW50YXRpb24gZGV0YWlscyB0aGlzCisgKiAgIHJlcXVpcmVzIHRoYXQgY2Fs bGVycyBwYXNzIGFuIG9wYXF1ZSBjb29raWUgZnJvbQorICogICBkbWFfZmVuY2VfYmVnaW5fc2ln bmFsbGluZygpIHRvIGRtYV9mZW5jZV9lbmRfc2lnbmFsbGluZygpLgorICoKKyAqICogVmFsaWRh dGlvbiBhZ2FpbnN0IHRoZSBjcm9zcyBkcml2ZXIgY29udHJhY3QgaXMgaW1wbGVtZW50ZWQgYnkg cHJpbWluZworICogICBsb2NrZGVwIHdpdGggdGhlIHJlbGV2YW50IGhpZXJhcmNoeSBhdCBib290 LXVwLiBUaGlzIG1lYW5zIGV2ZW4ganVzdAorICogICB0ZXN0aW5nIHdpdGggYSBzaW5nbGUgZGV2 aWNlIGlzIGVub3VnaCB0byB2YWxpZGF0ZSBhIGRyaXZlciwgYXQgbGVhc3QgYXMKKyAqICAgZmFy IGFzIGRlYWRsb2NrcyB3aXRoIGRtYV9mZW5jZV93YWl0KCkgYWdhaW5zdCBkbWFfZmVuY2Vfc2ln bmFsKCkgYXJlCisgKiAgIGNvbmNlcm5lZC4KKyAqLworI2lmZGVmIENPTkZJR19MT0NLREVQCitz dHJ1Y3QgbG9ja2RlcF9tYXAJZG1hX2ZlbmNlX2xvY2tkZXBfbWFwID0geworCS5uYW1lID0gImRt YV9mZW5jZV9tYXAiCit9OworCisvKioKKyAqIGRtYV9mZW5jZV9iZWdpbl9zaWduYWxsaW5nIC0g YmVnaW4gYSBjcml0aWNhbCBETUEgZmVuY2Ugc2lnbmFsbGluZyBzZWN0aW9uCisgKgorICogRHJp dmVycyBzaG91bGQgdXNlIHRoaXMgdG8gYW5ub3RhdGUgdGhlIGJlZ2lubmluZyBvZiBhbnkgY29k ZSBzZWN0aW9uCisgKiByZXF1aXJlZCB0byBldmVudHVhbGx5IGNvbXBsZXRlICZkbWFfZmVuY2Ug YnkgY2FsbGluZyBkbWFfZmVuY2Vfc2lnbmFsKCkuCisgKgorICogVGhlIGVuZCBvZiB0aGVzZSBj cml0aWNhbCBzZWN0aW9ucyBhcmUgYW5ub3RhdGVkIHdpdGgKKyAqIGRtYV9mZW5jZV9lbmRfc2ln bmFsbGluZygpLgorICoKKyAqIFJldHVybnM6CisgKgorICogT3BhcXVlIGNvb2tpZSBuZWVkZWQg YnkgdGhlIGltcGxlbWVudGF0aW9uLCB3aGljaCBuZWVkcyB0byBiZSBwYXNzZWQgdG8KKyAqIGRt YV9mZW5jZV9lbmRfc2lnbmFsbGluZygpLgorICovCitib29sIGRtYV9mZW5jZV9iZWdpbl9zaWdu YWxsaW5nKHZvaWQpCit7CisJLyogZXhwbGljaXRseSBuZXN0aW5nIC4uLiAqLworCWlmIChsb2Nr X2lzX2hlbGRfdHlwZSgmZG1hX2ZlbmNlX2xvY2tkZXBfbWFwLCAxKSkKKwkJcmV0dXJuIHRydWU7 CisKKwkvKiByZWx5IG9uIG1pZ2h0X3NsZWVwIGNoZWNrIGZvciBzb2Z0L2hhcmRpcnEgbG9ja3Mg Ki8KKwlpZiAoaW5fYXRvbWljKCkpCisJCXJldHVybiB0cnVlOworCisJLyogLi4uIGFuZCBub24t cmVjdXJzaXZlIHJlYWRsb2NrICovCisJbG9ja19hY3F1aXJlKCZkbWFfZmVuY2VfbG9ja2RlcF9t YXAsIDAsIDAsIDEsIDEsIE5VTEwsIF9SRVRfSVBfKTsKKworCXJldHVybiBmYWxzZTsKK30KK0VY UE9SVF9TWU1CT0woZG1hX2ZlbmNlX2JlZ2luX3NpZ25hbGxpbmcpOworCisvKioKKyAqIGRtYV9m ZW5jZV9lbmRfc2lnbmFsbGluZyAtIGVuZCBhIGNyaXRpY2FsIERNQSBmZW5jZSBzaWduYWxsaW5n IHNlY3Rpb24KKyAqCisgKiBDbG9zZXMgYSBjcml0aWNhbCBzZWN0aW9uIGFubm90YXRpb24gb3Bl bmVkIGJ5IGRtYV9mZW5jZV9iZWdpbl9zaWduYWxsaW5nKCkuCisgKi8KK3ZvaWQgZG1hX2ZlbmNl X2VuZF9zaWduYWxsaW5nKGJvb2wgY29va2llKQoreworCWlmIChjb29raWUpCisJCXJldHVybjsK KworCWxvY2tfcmVsZWFzZSgmZG1hX2ZlbmNlX2xvY2tkZXBfbWFwLCBfUkVUX0lQXyk7Cit9CitF WFBPUlRfU1lNQk9MKGRtYV9mZW5jZV9lbmRfc2lnbmFsbGluZyk7CisKK3ZvaWQgX19kbWFfZmVu Y2VfbWlnaHRfd2FpdCh2b2lkKQoreworCWJvb2wgdG1wOworCisJdG1wID0gbG9ja19pc19oZWxk X3R5cGUoJmRtYV9mZW5jZV9sb2NrZGVwX21hcCwgMSk7CisJaWYgKHRtcCkKKwkJbG9ja19yZWxl YXNlKCZkbWFfZmVuY2VfbG9ja2RlcF9tYXAsIF9USElTX0lQXyk7CisJbG9ja19tYXBfYWNxdWly ZSgmZG1hX2ZlbmNlX2xvY2tkZXBfbWFwKTsKKwlsb2NrX21hcF9yZWxlYXNlKCZkbWFfZmVuY2Vf bG9ja2RlcF9tYXApOworCWlmICh0bXApCisJCWxvY2tfYWNxdWlyZSgmZG1hX2ZlbmNlX2xvY2tk ZXBfbWFwLCAwLCAwLCAxLCAxLCBOVUxMLCBfVEhJU19JUF8pOworfQorI2VuZGlmCisKKwogLyoq CiAgKiBkbWFfZmVuY2Vfc2lnbmFsX2xvY2tlZCAtIHNpZ25hbCBjb21wbGV0aW9uIG9mIGEgZmVu Y2UKICAqIEBmZW5jZTogdGhlIGZlbmNlIHRvIHNpZ25hbApAQCAtMTcwLDE0ICszMjQsMTkgQEAg aW50IGRtYV9mZW5jZV9zaWduYWwoc3RydWN0IGRtYV9mZW5jZSAqZmVuY2UpCiB7CiAJdW5zaWdu ZWQgbG9uZyBmbGFnczsKIAlpbnQgcmV0OworCWJvb2wgdG1wOwogCiAJaWYgKCFmZW5jZSkKIAkJ cmV0dXJuIC1FSU5WQUw7CiAKKwl0bXAgPSBkbWFfZmVuY2VfYmVnaW5fc2lnbmFsbGluZygpOwor CiAJc3Bpbl9sb2NrX2lycXNhdmUoZmVuY2UtPmxvY2ssIGZsYWdzKTsKIAlyZXQgPSBkbWFfZmVu Y2Vfc2lnbmFsX2xvY2tlZChmZW5jZSk7CiAJc3Bpbl91bmxvY2tfaXJxcmVzdG9yZShmZW5jZS0+ bG9jaywgZmxhZ3MpOwogCisJZG1hX2ZlbmNlX2VuZF9zaWduYWxsaW5nKHRtcCk7CisKIAlyZXR1 cm4gcmV0OwogfQogRVhQT1JUX1NZTUJPTChkbWFfZmVuY2Vfc2lnbmFsKTsKQEAgLTIxMCw2ICsz NjksOCBAQCBkbWFfZmVuY2Vfd2FpdF90aW1lb3V0KHN0cnVjdCBkbWFfZmVuY2UgKmZlbmNlLCBi b29sIGludHIsIHNpZ25lZCBsb25nIHRpbWVvdXQpCiAKIAltaWdodF9zbGVlcCgpOwogCisJX19k bWFfZmVuY2VfbWlnaHRfd2FpdCgpOworCiAJdHJhY2VfZG1hX2ZlbmNlX3dhaXRfc3RhcnQoZmVu Y2UpOwogCWlmIChmZW5jZS0+b3BzLT53YWl0KQogCQlyZXQgPSBmZW5jZS0+b3BzLT53YWl0KGZl bmNlLCBpbnRyLCB0aW1lb3V0KTsKZGlmZiAtLWdpdCBhL2luY2x1ZGUvbGludXgvZG1hLWZlbmNl LmggYi9pbmNsdWRlL2xpbnV4L2RtYS1mZW5jZS5oCmluZGV4IDMzNDdjNTRmM2E4Ny4uM2YyODhm N2RiMmVmIDEwMDY0NAotLS0gYS9pbmNsdWRlL2xpbnV4L2RtYS1mZW5jZS5oCisrKyBiL2luY2x1 ZGUvbGludXgvZG1hLWZlbmNlLmgKQEAgLTM1Nyw2ICszNTcsMTggQEAgZG1hX2ZlbmNlX2dldF9y Y3Vfc2FmZShzdHJ1Y3QgZG1hX2ZlbmNlIF9fcmN1ICoqZmVuY2VwKQogCX0gd2hpbGUgKDEpOwog fQogCisjaWZkZWYgQ09ORklHX0xPQ0tERVAKK2Jvb2wgZG1hX2ZlbmNlX2JlZ2luX3NpZ25hbGxp bmcodm9pZCk7Cit2b2lkIGRtYV9mZW5jZV9lbmRfc2lnbmFsbGluZyhib29sIGNvb2tpZSk7Cisj ZWxzZQorc3RhdGljIGlubGluZSBib29sIGRtYV9mZW5jZV9iZWdpbl9zaWduYWxsaW5nKHZvaWQp Cit7CisJcmV0dXJuIHRydWU7Cit9CitzdGF0aWMgaW5saW5lIHZvaWQgZG1hX2ZlbmNlX2VuZF9z aWduYWxsaW5nKGJvb2wgY29va2llKSB7fQorc3RhdGljIGlubGluZSB2b2lkIF9fZG1hX2ZlbmNl X21pZ2h0X3dhaXQodm9pZCkge30KKyNlbmRpZgorCiBpbnQgZG1hX2ZlbmNlX3NpZ25hbChzdHJ1 Y3QgZG1hX2ZlbmNlICpmZW5jZSk7CiBpbnQgZG1hX2ZlbmNlX3NpZ25hbF9sb2NrZWQoc3RydWN0 IGRtYV9mZW5jZSAqZmVuY2UpOwogc2lnbmVkIGxvbmcgZG1hX2ZlbmNlX2RlZmF1bHRfd2FpdChz dHJ1Y3QgZG1hX2ZlbmNlICpmZW5jZSwKLS0gCjIuMjcuMAoKX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fX18KYW1kLWdmeCBtYWlsaW5nIGxpc3QKYW1kLWdmeEBs aXN0cy5mcmVlZGVza3RvcC5vcmcKaHR0cHM6Ly9saXN0cy5mcmVlZGVza3RvcC5vcmcvbWFpbG1h bi9saXN0aW5mby9hbWQtZ2Z4Cg==