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.1 required=3.0 tests=DKIMWL_WL_HIGH,DKIM_SIGNED, DKIM_VALID,DKIM_VALID_AU,INCLUDES_PATCH,MAILING_LIST_MULTI,SIGNED_OFF_BY, 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 A580DC10F11 for ; Mon, 22 Apr 2019 13:35:31 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [209.132.180.67]) by mail.kernel.org (Postfix) with ESMTP id 353802064A for ; Mon, 22 Apr 2019 13:35:31 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=default; t=1555940131; bh=hXrbXusdB3+E1408F1vj5bcD6qHTlUBZRNYOxqP3DFE=; h=From:To:Cc:Subject:Date:In-Reply-To:References:List-ID:From; b=jq0aHzfuVqRFf6/E9acY/9s/xO4PkiOYpjxgZliLH5EM7+2CjNnuBV4c09QrOS/i5 DZM7dhyX3kM6U96tVw58cvwmgykgsnn2xMGT6Y/KnXhJOVvorFTojbdGaBBaeworRi PU9MEQwugGfPE57CTIuxB3iVCHu2N8QqJfiXvgJs= Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1728197AbfDVNfa (ORCPT ); Mon, 22 Apr 2019 09:35:30 -0400 Received: from bombadil.infradead.org ([198.137.202.133]:37020 "EHLO bombadil.infradead.org" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1727443AbfDVN2Q (ORCPT ); Mon, 22 Apr 2019 09:28:16 -0400 DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; d=infradead.org; s=bombadil.20170209; h=Sender:Content-Transfer-Encoding: MIME-Version:References:In-Reply-To:Message-Id:Date:Subject:Cc:To:From: Reply-To:Content-Type:Content-ID:Content-Description:Resent-Date:Resent-From: Resent-Sender:Resent-To:Resent-Cc:Resent-Message-ID:List-Id:List-Help: List-Unsubscribe:List-Subscribe:List-Post:List-Owner:List-Archive; bh=bhe8Pj7ubQvqmWNY04q8XaXTOLznyaqwKQzRGPIgP1s=; b=IRgHkW94qd/NFbW1hgskTw9p9c BTKLt6bb9zTtsTsS4pbPTxGQU2nXzSEeG1LXKWClEv9Tt2kUyX3FhocE51GBOuUPGj+JtgV3X6zCy MYNkL1g/wB7ovIsCqA4m/c+ZOrWurClYcijHQsFHRM1QV8Qr+335UyA2yBL1ooSf+5GwTf+jz1+9l KYHd35AY4zvXF8BfCbdwC6BkDB4wTGXtUMB0UGio5yxgTK5RLHPRsi6Vql+TbKeZaNOjhQcBlfGEZ wsK3FZ8wfKgINTiNW5R0SstppKkE09Tp54xICdRl2ZDUmTBQu4bIU4uMmzcq1f5WTfh6ZayIDBlQB mG0Jj9Cw==; Received: from 179.176.125.229.dynamic.adsl.gvt.net.br ([179.176.125.229] helo=bombadil.infradead.org) by bombadil.infradead.org with esmtpsa (Exim 4.90_1 #2 (Red Hat Linux)) id 1hIYzV-0005Ho-70; Mon, 22 Apr 2019 13:28:15 +0000 Received: from mchehab by bombadil.infradead.org with local (Exim 4.92) (envelope-from ) id 1hIYzS-0005l7-SX; Mon, 22 Apr 2019 10:28:10 -0300 From: Mauro Carvalho Chehab To: Linux Doc Mailing List Cc: Mauro Carvalho Chehab , Mauro Carvalho Chehab , linux-kernel@vger.kernel.org, Jonathan Corbet , Peter Zijlstra , Ingo Molnar , Will Deacon , Federico Vaga , Maarten Lankhorst , Maxime Ripard , Sean Paul , David Airlie , Daniel Vetter , dri-devel@lists.freedesktop.org Subject: [PATCH v2 21/79] docs: locking: convert docs to ReST and rename to *.rst Date: Mon, 22 Apr 2019 10:27:10 -0300 Message-Id: X-Mailer: git-send-email 2.20.1 In-Reply-To: References: MIME-Version: 1.0 Content-Transfer-Encoding: 8bit Sender: linux-kernel-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org Convert the locking documents to ReST and add them to the kernel development book where it belongs. Most of the stuff here is just to make Sphinx to properly parse the text file, as they're already in good shape, not requiring massive changes in order to be parsed. The conversion is actually: - add blank lines and identation in order to identify paragraphs; - fix tables markups; - add some lists markups; - mark literal blocks; - adjust title markups. At its new index.rst, let's add a :orphan: while this is not linked to the main index.rst file, in order to avoid build warnings. Signed-off-by: Mauro Carvalho Chehab --- Documentation/kernel-hacking/locking.rst | 2 +- Documentation/locking/index.rst | 24 +++ ...{lockdep-design.txt => lockdep-design.rst} | 41 ++-- Documentation/locking/lockstat.rst | 204 ++++++++++++++++++ Documentation/locking/lockstat.txt | 183 ---------------- .../{locktorture.txt => locktorture.rst} | 105 +++++---- .../{mutex-design.txt => mutex-design.rst} | 26 ++- ...t-mutex-design.txt => rt-mutex-design.rst} | 139 ++++++------ .../locking/{rt-mutex.txt => rt-mutex.rst} | 30 +-- .../locking/{spinlocks.txt => spinlocks.rst} | 32 ++- ...w-mutex-design.txt => ww-mutex-design.rst} | 82 +++---- Documentation/pi-futex.txt | 2 +- .../it_IT/kernel-hacking/locking.rst | 2 +- drivers/gpu/drm/drm_modeset_lock.c | 2 +- include/linux/lockdep.h | 2 +- include/linux/mutex.h | 2 +- include/linux/rwsem.h | 2 +- kernel/locking/mutex.c | 2 +- kernel/locking/rtmutex.c | 2 +- lib/Kconfig.debug | 4 +- 20 files changed, 506 insertions(+), 382 deletions(-) create mode 100644 Documentation/locking/index.rst rename Documentation/locking/{lockdep-design.txt => lockdep-design.rst} (93%) create mode 100644 Documentation/locking/lockstat.rst delete mode 100644 Documentation/locking/lockstat.txt rename Documentation/locking/{locktorture.txt => locktorture.rst} (57%) rename Documentation/locking/{mutex-design.txt => mutex-design.rst} (94%) rename Documentation/locking/{rt-mutex-design.txt => rt-mutex-design.rst} (91%) rename Documentation/locking/{rt-mutex.txt => rt-mutex.rst} (71%) rename Documentation/locking/{spinlocks.txt => spinlocks.rst} (89%) rename Documentation/locking/{ww-mutex-design.txt => ww-mutex-design.rst} (93%) diff --git a/Documentation/kernel-hacking/locking.rst b/Documentation/kernel-hacking/locking.rst index 519673df0e82..71a843464ec2 100644 --- a/Documentation/kernel-hacking/locking.rst +++ b/Documentation/kernel-hacking/locking.rst @@ -1364,7 +1364,7 @@ Futex API reference Further reading =============== -- ``Documentation/locking/spinlocks.txt``: Linus Torvalds' spinlocking +- ``Documentation/locking/spinlocks.rst``: Linus Torvalds' spinlocking tutorial in the kernel sources. - Unix Systems for Modern Architectures: Symmetric Multiprocessing and diff --git a/Documentation/locking/index.rst b/Documentation/locking/index.rst new file mode 100644 index 000000000000..ef5da7fe9aac --- /dev/null +++ b/Documentation/locking/index.rst @@ -0,0 +1,24 @@ +:orphan: + +======= +locking +======= + +.. toctree:: + :maxdepth: 1 + + lockdep-design + lockstat + locktorture + mutex-design + rt-mutex-design + rt-mutex + spinlocks + ww-mutex-design + +.. only:: subproject and html + + Indices + ======= + + * :ref:`genindex` diff --git a/Documentation/locking/lockdep-design.txt b/Documentation/locking/lockdep-design.rst similarity index 93% rename from Documentation/locking/lockdep-design.txt rename to Documentation/locking/lockdep-design.rst index 39fae143c9cb..49707a5029c5 100644 --- a/Documentation/locking/lockdep-design.txt +++ b/Documentation/locking/lockdep-design.rst @@ -2,6 +2,7 @@ Runtime locking correctness validator ===================================== started by Ingo Molnar + additions by Arjan van de Ven Lock-class @@ -42,7 +43,7 @@ Where STATE can be either one of (kernel/locking/lockdep_states.h) - 'ever used' [ == !unused ] When locking rules are violated, these state bits are presented in the -locking error messages, inside curlies. A contrived example: +locking error messages, inside curlies. A contrived example:: modprobe/2287 is trying to acquire lock: (&sio_locks[i].lock){-.-.}, at: [] mutex_lock+0x21/0x24 @@ -54,10 +55,12 @@ locking error messages, inside curlies. A contrived example: The bit position indicates STATE, STATE-read, for each of the states listed above, and the character displayed in each indicates: + === =================================================== '.' acquired while irqs disabled and not in irq context '-' acquired in irq context '+' acquired with irqs enabled '?' acquired in irq context with irqs enabled. + === =================================================== Unused mutexes cannot be part of the cause of an error. @@ -67,7 +70,7 @@ Single-lock state rules: A softirq-unsafe lock-class is automatically hardirq-unsafe as well. The following states are exclusive, and only one of them is allowed to be -set for any lock-class: +set for any lock-class:: and and @@ -81,7 +84,7 @@ Multi-lock dependency rules: The same lock-class must not be acquired twice, because this could lead to lock recursion deadlocks. -Furthermore, two locks may not be taken in different order: +Furthermore, two locks may not be taken in different order:: -> -> @@ -92,7 +95,7 @@ other locking sequence between the acquire-lock operations, the validator will still track all dependencies between locks.) Furthermore, the following usage based lock dependencies are not allowed -between any two lock-classes: +between any two lock-classes:: -> -> @@ -148,16 +151,16 @@ the ordering is not static. In order to teach the validator about this correct usage model, new versions of the various locking primitives were added that allow you to specify a "nesting level". An example call, for the block device mutex, -looks like this: +looks like this:: -enum bdev_bd_mutex_lock_class -{ + enum bdev_bd_mutex_lock_class + { BD_MUTEX_NORMAL, BD_MUTEX_WHOLE, BD_MUTEX_PARTITION -}; + }; - mutex_lock_nested(&bdev->bd_contains->bd_mutex, BD_MUTEX_PARTITION); +mutex_lock_nested(&bdev->bd_contains->bd_mutex, BD_MUTEX_PARTITION); In this case the locking is done on a bdev object that is known to be a partition. @@ -178,7 +181,7 @@ must be held: lockdep_assert_held*(&lock) and lockdep_*pin_lock(&lock). As the name suggests, lockdep_assert_held* family of macros assert that a particular lock is held at a certain time (and generate a WARN() otherwise). This annotation is largely used all over the kernel, e.g. kernel/sched/ -core.c +core.c:: void update_rq_clock(struct rq *rq) { @@ -197,7 +200,7 @@ out to be especially helpful to debug code with callbacks, where an upper layer assumes a lock remains taken, but a lower layer thinks it can maybe drop and reacquire the lock ("unwittingly" introducing races). lockdep_pin_lock() returns a 'struct pin_cookie' that is then used by lockdep_unpin_lock() to check -that nobody tampered with the lock, e.g. kernel/sched/sched.h +that nobody tampered with the lock, e.g. kernel/sched/sched.h:: static inline void rq_pin_lock(struct rq *rq, struct rq_flags *rf) { @@ -224,7 +227,7 @@ correctness) in the sense that for every simple, standalone single-task locking sequence that occurred at least once during the lifetime of the kernel, the validator proves it with a 100% certainty that no combination and timing of these locking sequences can cause any class of -lock related deadlock. [*] +lock related deadlock. [1]_ I.e. complex multi-CPU and multi-task locking scenarios do not have to occur in practice to prove a deadlock: only the simple 'component' @@ -243,7 +246,9 @@ possible combination of locking interaction between CPUs, combined with every possible hardirq and softirq nesting scenario (which is impossible to do in practice). -[*] assuming that the validator itself is 100% correct, and no other +.. [1] + + assuming that the validator itself is 100% correct, and no other part of the system corrupts the state of the validator in any way. We also assume that all NMI/SMM paths [which could interrupt even hardirq-disabled codepaths] are correct and do not interfere @@ -254,7 +259,7 @@ to do in practice). Performance: ------------ -The above rules require _massive_ amounts of runtime checking. If we did +The above rules require **massive** amounts of runtime checking. If we did that for every lock taken and for every irqs-enable event, it would render the system practically unusably slow. The complexity of checking is O(N^2), so even with just a few hundred lock-classes we'd have to do @@ -313,17 +318,17 @@ be harder to do than to say. Of course, if you do run out of lock classes, the next thing to do is to find the offending lock classes. First, the following command gives -you the number of lock classes currently in use along with the maximum: +you the number of lock classes currently in use along with the maximum:: grep "lock-classes" /proc/lockdep_stats -This command produces the following output on a modest system: +This command produces the following output on a modest system:: - lock-classes: 748 [max: 8191] + lock-classes: 748 [max: 8191] If the number allocated (748 above) increases continually over time, then there is likely a leak. The following command can be used to -identify the leaking lock classes: +identify the leaking lock classes:: grep "BD" /proc/lockdep diff --git a/Documentation/locking/lockstat.rst b/Documentation/locking/lockstat.rst new file mode 100644 index 000000000000..536eab8dbd99 --- /dev/null +++ b/Documentation/locking/lockstat.rst @@ -0,0 +1,204 @@ +=============== +Lock Statistics +=============== + +What +==== + +As the name suggests, it provides statistics on locks. + + +Why +=== + +Because things like lock contention can severely impact performance. + +How +=== + +Lockdep already has hooks in the lock functions and maps lock instances to +lock classes. We build on that (see Documentation/locking/lockdep-design.rst). +The graph below shows the relation between the lock functions and the various +hooks therein:: + + __acquire + | + lock _____ + | \ + | __contended + | | + | + | _______/ + |/ + | + __acquired + | + . + + . + | + __release + | + unlock + + lock, unlock - the regular lock functions + __* - the hooks + <> - states + +With these hooks we provide the following statistics: + + con-bounces + - number of lock contention that involved x-cpu data + contentions + - number of lock acquisitions that had to wait + wait time + min + - shortest (non-0) time we ever had to wait for a lock + max + - longest time we ever had to wait for a lock + total + - total time we spend waiting on this lock + avg + - average time spent waiting on this lock + acq-bounces + - number of lock acquisitions that involved x-cpu data + acquisitions + - number of times we took the lock + hold time + min + - shortest (non-0) time we ever held the lock + max + - longest time we ever held the lock + total + - total time this lock was held + avg + - average time this lock was held + +These numbers are gathered per lock class, per read/write state (when +applicable). + +It also tracks 4 contention points per class. A contention point is a call site +that had to wait on lock acquisition. + +Configuration +------------- + +Lock statistics are enabled via CONFIG_LOCK_STAT. + +Usage +----- + +Enable collection of statistics:: + + # echo 1 >/proc/sys/kernel/lock_stat + +Disable collection of statistics:: + + # echo 0 >/proc/sys/kernel/lock_stat + +Look at the current lock statistics:: + + ( line numbers not part of actual output, done for clarity in the explanation + below ) + + # less /proc/lock_stat + + 01 lock_stat version 0.4 + 02----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- + 03 class name con-bounces contentions waittime-min waittime-max waittime-total waittime-avg acq-bounces acquisitions holdtime-min holdtime-max holdtime-total holdtime-avg + 04----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- + 05 + 06 &mm->mmap_sem-W: 46 84 0.26 939.10 16371.53 194.90 47291 2922365 0.16 2220301.69 17464026916.32 5975.99 + 07 &mm->mmap_sem-R: 37 100 1.31 299502.61 325629.52 3256.30 212344 34316685 0.10 7744.91 95016910.20 2.77 + 08 --------------- + 09 &mm->mmap_sem 1 [] khugepaged_scan_mm_slot+0x57/0x280 + 10 &mm->mmap_sem 96 [] __do_page_fault+0x1d4/0x510 + 11 &mm->mmap_sem 34 [] vm_mmap_pgoff+0x87/0xd0 + 12 &mm->mmap_sem 17 [] vm_munmap+0x41/0x80 + 13 --------------- + 14 &mm->mmap_sem 1 [] dup_mmap+0x2a/0x3f0 + 15 &mm->mmap_sem 60 [] SyS_mprotect+0xe9/0x250 + 16 &mm->mmap_sem 41 [] __do_page_fault+0x1d4/0x510 + 17 &mm->mmap_sem 68 [] vm_mmap_pgoff+0x87/0xd0 + 18 + 19............................................................................................................................................................................................................................. + 20 + 21 unix_table_lock: 110 112 0.21 49.24 163.91 1.46 21094 66312 0.12 624.42 31589.81 0.48 + 22 --------------- + 23 unix_table_lock 45 [] unix_create1+0x16e/0x1b0 + 24 unix_table_lock 47 [] unix_release_sock+0x31/0x250 + 25 unix_table_lock 15 [] unix_find_other+0x117/0x230 + 26 unix_table_lock 5 [] unix_autobind+0x11f/0x1b0 + 27 --------------- + 28 unix_table_lock 39 [] unix_release_sock+0x31/0x250 + 29 unix_table_lock 49 [] unix_create1+0x16e/0x1b0 + 30 unix_table_lock 20 [] unix_find_other+0x117/0x230 + 31 unix_table_lock 4 [] unix_autobind+0x11f/0x1b0 + + +This excerpt shows the first two lock class statistics. Line 01 shows the +output version - each time the format changes this will be updated. Line 02-04 +show the header with column descriptions. Lines 05-18 and 20-31 show the actual +statistics. These statistics come in two parts; the actual stats separated by a +short separator (line 08, 13) from the contention points. + +Lines 09-12 show the first 4 recorded contention points (the code +which tries to get the lock) and lines 14-17 show the first 4 recorded +contended points (the lock holder). It is possible that the max +con-bounces point is missing in the statistics. + +The first lock (05-18) is a read/write lock, and shows two lines above the +short separator. The contention points don't match the column descriptors, +they have two: contentions and [] symbol. The second set of contention +points are the points we're contending with. + +The integer part of the time values is in us. + +Dealing with nested locks, subclasses may appear:: + + 32........................................................................................................................................................................................................................... + 33 + 34 &rq->lock: 13128 13128 0.43 190.53 103881.26 7.91 97454 3453404 0.00 401.11 13224683.11 3.82 + 35 --------- + 36 &rq->lock 645 [] task_rq_lock+0x43/0x75 + 37 &rq->lock 297 [] try_to_wake_up+0x127/0x25a + 38 &rq->lock 360 [] select_task_rq_fair+0x1f0/0x74a + 39 &rq->lock 428 [] scheduler_tick+0x46/0x1fb + 40 --------- + 41 &rq->lock 77 [] task_rq_lock+0x43/0x75 + 42 &rq->lock 174 [] try_to_wake_up+0x127/0x25a + 43 &rq->lock 4715 [] double_rq_lock+0x42/0x54 + 44 &rq->lock 893 [] schedule+0x157/0x7b8 + 45 + 46........................................................................................................................................................................................................................... + 47 + 48 &rq->lock/1: 1526 11488 0.33 388.73 136294.31 11.86 21461 38404 0.00 37.93 109388.53 2.84 + 49 ----------- + 50 &rq->lock/1 11526 [] double_rq_lock+0x4f/0x54 + 51 ----------- + 52 &rq->lock/1 5645 [] double_rq_lock+0x42/0x54 + 53 &rq->lock/1 1224 [] schedule+0x157/0x7b8 + 54 &rq->lock/1 4336 [] double_rq_lock+0x4f/0x54 + 55 &rq->lock/1 181 [] try_to_wake_up+0x127/0x25a + +Line 48 shows statistics for the second subclass (/1) of &rq->lock class +(subclass starts from 0), since in this case, as line 50 suggests, +double_rq_lock actually acquires a nested lock of two spinlocks. + +View the top contending locks:: + + # grep : /proc/lock_stat | head + clockevents_lock: 2926159 2947636 0.15 46882.81 1784540466.34 605.41 3381345 3879161 0.00 2260.97 53178395.68 13.71 + tick_broadcast_lock: 346460 346717 0.18 2257.43 39364622.71 113.54 3642919 4242696 0.00 2263.79 49173646.60 11.59 + &mapping->i_mmap_mutex: 203896 203899 3.36 645530.05 31767507988.39 155800.21 3361776 8893984 0.17 2254.15 14110121.02 1.59 + &rq->lock: 135014 136909 0.18 606.09 842160.68 6.15 1540728 10436146 0.00 728.72 17606683.41 1.69 + &(&zone->lru_lock)->rlock: 93000 94934 0.16 59.18 188253.78 1.98 1199912 3809894 0.15 391.40 3559518.81 0.93 + tasklist_lock-W: 40667 41130 0.23 1189.42 428980.51 10.43 270278 510106 0.16 653.51 3939674.91 7.72 + tasklist_lock-R: 21298 21305 0.20 1310.05 215511.12 10.12 186204 241258 0.14 1162.33 1179779.23 4.89 + rcu_node_1: 47656 49022 0.16 635.41 193616.41 3.95 844888 1865423 0.00 764.26 1656226.96 0.89 + &(&dentry->d_lockref.lock)->rlock: 39791 40179 0.15 1302.08 88851.96 2.21 2790851 12527025 0.10 1910.75 3379714.27 0.27 + rcu_node_0: 29203 30064 0.16 786.55 1555573.00 51.74 88963 244254 0.00 398.87 428872.51 1.76 + +Clear the statistics:: + + # echo 0 > /proc/lock_stat diff --git a/Documentation/locking/lockstat.txt b/Documentation/locking/lockstat.txt deleted file mode 100644 index fdbeb0c45ef3..000000000000 --- a/Documentation/locking/lockstat.txt +++ /dev/null @@ -1,183 +0,0 @@ - -LOCK STATISTICS - -- WHAT - -As the name suggests, it provides statistics on locks. - -- WHY - -Because things like lock contention can severely impact performance. - -- HOW - -Lockdep already has hooks in the lock functions and maps lock instances to -lock classes. We build on that (see Documentation/locking/lockdep-design.txt). -The graph below shows the relation between the lock functions and the various -hooks therein. - - __acquire - | - lock _____ - | \ - | __contended - | | - | - | _______/ - |/ - | - __acquired - | - . - - . - | - __release - | - unlock - -lock, unlock - the regular lock functions -__* - the hooks -<> - states - -With these hooks we provide the following statistics: - - con-bounces - number of lock contention that involved x-cpu data - contentions - number of lock acquisitions that had to wait - wait time min - shortest (non-0) time we ever had to wait for a lock - max - longest time we ever had to wait for a lock - total - total time we spend waiting on this lock - avg - average time spent waiting on this lock - acq-bounces - number of lock acquisitions that involved x-cpu data - acquisitions - number of times we took the lock - hold time min - shortest (non-0) time we ever held the lock - max - longest time we ever held the lock - total - total time this lock was held - avg - average time this lock was held - -These numbers are gathered per lock class, per read/write state (when -applicable). - -It also tracks 4 contention points per class. A contention point is a call site -that had to wait on lock acquisition. - - - CONFIGURATION - -Lock statistics are enabled via CONFIG_LOCK_STAT. - - - USAGE - -Enable collection of statistics: - -# echo 1 >/proc/sys/kernel/lock_stat - -Disable collection of statistics: - -# echo 0 >/proc/sys/kernel/lock_stat - -Look at the current lock statistics: - -( line numbers not part of actual output, done for clarity in the explanation - below ) - -# less /proc/lock_stat - -01 lock_stat version 0.4 -02----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- -03 class name con-bounces contentions waittime-min waittime-max waittime-total waittime-avg acq-bounces acquisitions holdtime-min holdtime-max holdtime-total holdtime-avg -04----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- -05 -06 &mm->mmap_sem-W: 46 84 0.26 939.10 16371.53 194.90 47291 2922365 0.16 2220301.69 17464026916.32 5975.99 -07 &mm->mmap_sem-R: 37 100 1.31 299502.61 325629.52 3256.30 212344 34316685 0.10 7744.91 95016910.20 2.77 -08 --------------- -09 &mm->mmap_sem 1 [] khugepaged_scan_mm_slot+0x57/0x280 -10 &mm->mmap_sem 96 [] __do_page_fault+0x1d4/0x510 -11 &mm->mmap_sem 34 [] vm_mmap_pgoff+0x87/0xd0 -12 &mm->mmap_sem 17 [] vm_munmap+0x41/0x80 -13 --------------- -14 &mm->mmap_sem 1 [] dup_mmap+0x2a/0x3f0 -15 &mm->mmap_sem 60 [] SyS_mprotect+0xe9/0x250 -16 &mm->mmap_sem 41 [] __do_page_fault+0x1d4/0x510 -17 &mm->mmap_sem 68 [] vm_mmap_pgoff+0x87/0xd0 -18 -19............................................................................................................................................................................................................................. -20 -21 unix_table_lock: 110 112 0.21 49.24 163.91 1.46 21094 66312 0.12 624.42 31589.81 0.48 -22 --------------- -23 unix_table_lock 45 [] unix_create1+0x16e/0x1b0 -24 unix_table_lock 47 [] unix_release_sock+0x31/0x250 -25 unix_table_lock 15 [] unix_find_other+0x117/0x230 -26 unix_table_lock 5 [] unix_autobind+0x11f/0x1b0 -27 --------------- -28 unix_table_lock 39 [] unix_release_sock+0x31/0x250 -29 unix_table_lock 49 [] unix_create1+0x16e/0x1b0 -30 unix_table_lock 20 [] unix_find_other+0x117/0x230 -31 unix_table_lock 4 [] unix_autobind+0x11f/0x1b0 - - -This excerpt shows the first two lock class statistics. Line 01 shows the -output version - each time the format changes this will be updated. Line 02-04 -show the header with column descriptions. Lines 05-18 and 20-31 show the actual -statistics. These statistics come in two parts; the actual stats separated by a -short separator (line 08, 13) from the contention points. - -Lines 09-12 show the first 4 recorded contention points (the code -which tries to get the lock) and lines 14-17 show the first 4 recorded -contended points (the lock holder). It is possible that the max -con-bounces point is missing in the statistics. - -The first lock (05-18) is a read/write lock, and shows two lines above the -short separator. The contention points don't match the column descriptors, -they have two: contentions and [] symbol. The second set of contention -points are the points we're contending with. - -The integer part of the time values is in us. - -Dealing with nested locks, subclasses may appear: - -32........................................................................................................................................................................................................................... -33 -34 &rq->lock: 13128 13128 0.43 190.53 103881.26 7.91 97454 3453404 0.00 401.11 13224683.11 3.82 -35 --------- -36 &rq->lock 645 [] task_rq_lock+0x43/0x75 -37 &rq->lock 297 [] try_to_wake_up+0x127/0x25a -38 &rq->lock 360 [] select_task_rq_fair+0x1f0/0x74a -39 &rq->lock 428 [] scheduler_tick+0x46/0x1fb -40 --------- -41 &rq->lock 77 [] task_rq_lock+0x43/0x75 -42 &rq->lock 174 [] try_to_wake_up+0x127/0x25a -43 &rq->lock 4715 [] double_rq_lock+0x42/0x54 -44 &rq->lock 893 [] schedule+0x157/0x7b8 -45 -46........................................................................................................................................................................................................................... -47 -48 &rq->lock/1: 1526 11488 0.33 388.73 136294.31 11.86 21461 38404 0.00 37.93 109388.53 2.84 -49 ----------- -50 &rq->lock/1 11526 [] double_rq_lock+0x4f/0x54 -51 ----------- -52 &rq->lock/1 5645 [] double_rq_lock+0x42/0x54 -53 &rq->lock/1 1224 [] schedule+0x157/0x7b8 -54 &rq->lock/1 4336 [] double_rq_lock+0x4f/0x54 -55 &rq->lock/1 181 [] try_to_wake_up+0x127/0x25a - -Line 48 shows statistics for the second subclass (/1) of &rq->lock class -(subclass starts from 0), since in this case, as line 50 suggests, -double_rq_lock actually acquires a nested lock of two spinlocks. - -View the top contending locks: - -# grep : /proc/lock_stat | head - clockevents_lock: 2926159 2947636 0.15 46882.81 1784540466.34 605.41 3381345 3879161 0.00 2260.97 53178395.68 13.71 - tick_broadcast_lock: 346460 346717 0.18 2257.43 39364622.71 113.54 3642919 4242696 0.00 2263.79 49173646.60 11.59 - &mapping->i_mmap_mutex: 203896 203899 3.36 645530.05 31767507988.39 155800.21 3361776 8893984 0.17 2254.15 14110121.02 1.59 - &rq->lock: 135014 136909 0.18 606.09 842160.68 6.15 1540728 10436146 0.00 728.72 17606683.41 1.69 - &(&zone->lru_lock)->rlock: 93000 94934 0.16 59.18 188253.78 1.98 1199912 3809894 0.15 391.40 3559518.81 0.93 - tasklist_lock-W: 40667 41130 0.23 1189.42 428980.51 10.43 270278 510106 0.16 653.51 3939674.91 7.72 - tasklist_lock-R: 21298 21305 0.20 1310.05 215511.12 10.12 186204 241258 0.14 1162.33 1179779.23 4.89 - rcu_node_1: 47656 49022 0.16 635.41 193616.41 3.95 844888 1865423 0.00 764.26 1656226.96 0.89 - &(&dentry->d_lockref.lock)->rlock: 39791 40179 0.15 1302.08 88851.96 2.21 2790851 12527025 0.10 1910.75 3379714.27 0.27 - rcu_node_0: 29203 30064 0.16 786.55 1555573.00 51.74 88963 244254 0.00 398.87 428872.51 1.76 - -Clear the statistics: - -# echo 0 > /proc/lock_stat diff --git a/Documentation/locking/locktorture.txt b/Documentation/locking/locktorture.rst similarity index 57% rename from Documentation/locking/locktorture.txt rename to Documentation/locking/locktorture.rst index 6a8df4cd19bf..e79eeeca3ac6 100644 --- a/Documentation/locking/locktorture.txt +++ b/Documentation/locking/locktorture.rst @@ -1,6 +1,9 @@ +================================== Kernel Lock Torture Test Operation +================================== CONFIG_LOCK_TORTURE_TEST +======================== The CONFIG LOCK_TORTURE_TEST config option provides a kernel module that runs torture tests on core kernel locking primitives. The kernel @@ -18,61 +21,77 @@ can be simulated by either enlarging this critical region hold time and/or creating more kthreads. -MODULE PARAMETERS +Module Parameters +================= This module has the following parameters: - ** Locktorture-specific ** +Locktorture-specific +-------------------- -nwriters_stress Number of kernel threads that will stress exclusive lock +nwriters_stress + Number of kernel threads that will stress exclusive lock ownership (writers). The default value is twice the number of online CPUs. -nreaders_stress Number of kernel threads that will stress shared lock +nreaders_stress + Number of kernel threads that will stress shared lock ownership (readers). The default is the same amount of writer locks. If the user did not specify nwriters_stress, then both readers and writers be the amount of online CPUs. -torture_type Type of lock to torture. By default, only spinlocks will +torture_type + Type of lock to torture. By default, only spinlocks will be tortured. This module can torture the following locks, with string values as follows: - o "lock_busted": Simulates a buggy lock implementation. + - "lock_busted": + Simulates a buggy lock implementation. - o "spin_lock": spin_lock() and spin_unlock() pairs. + - "spin_lock": + spin_lock() and spin_unlock() pairs. - o "spin_lock_irq": spin_lock_irq() and spin_unlock_irq() - pairs. + - "spin_lock_irq": + spin_lock_irq() and spin_unlock_irq() pairs. - o "rw_lock": read/write lock() and unlock() rwlock pairs. + - "rw_lock": + read/write lock() and unlock() rwlock pairs. - o "rw_lock_irq": read/write lock_irq() and unlock_irq() - rwlock pairs. + - "rw_lock_irq": + read/write lock_irq() and unlock_irq() + rwlock pairs. - o "mutex_lock": mutex_lock() and mutex_unlock() pairs. + - "mutex_lock": + mutex_lock() and mutex_unlock() pairs. - o "rtmutex_lock": rtmutex_lock() and rtmutex_unlock() - pairs. Kernel must have CONFIG_RT_MUTEX=y. + - "rtmutex_lock": + rtmutex_lock() and rtmutex_unlock() pairs. + Kernel must have CONFIG_RT_MUTEX=y. - o "rwsem_lock": read/write down() and up() semaphore pairs. + - "rwsem_lock": + read/write down() and up() semaphore pairs. - ** Torture-framework (RCU + locking) ** +Torture-framework (RCU + locking) +--------------------------------- -shutdown_secs The number of seconds to run the test before terminating +shutdown_secs + The number of seconds to run the test before terminating the test and powering off the system. The default is zero, which disables test termination and system shutdown. This capability is useful for automated testing. -onoff_interval The number of seconds between each attempt to execute a +onoff_interval + The number of seconds between each attempt to execute a randomly selected CPU-hotplug operation. Defaults to zero, which disables CPU hotplugging. In CONFIG_HOTPLUG_CPU=n kernels, locktorture will silently refuse to do any CPU-hotplug operations regardless of what value is specified for onoff_interval. -onoff_holdoff The number of seconds to wait until starting CPU-hotplug +onoff_holdoff + The number of seconds to wait until starting CPU-hotplug operations. This would normally only be used when locktorture was built into the kernel and started automatically at boot time, in which case it is useful @@ -80,53 +99,59 @@ onoff_holdoff The number of seconds to wait until starting CPU-hotplug coming and going. This parameter is only useful if CONFIG_HOTPLUG_CPU is enabled. -stat_interval Number of seconds between statistics-related printk()s. +stat_interval + Number of seconds between statistics-related printk()s. By default, locktorture will report stats every 60 seconds. Setting the interval to zero causes the statistics to be printed -only- when the module is unloaded, and this is the default. -stutter The length of time to run the test before pausing for this +stutter + The length of time to run the test before pausing for this same period of time. Defaults to "stutter=5", so as to run and pause for (roughly) five-second intervals. Specifying "stutter=0" causes the test to run continuously without pausing, which is the old default behavior. -shuffle_interval The number of seconds to keep the test threads affinitied +shuffle_interval + The number of seconds to keep the test threads affinitied to a particular subset of the CPUs, defaults to 3 seconds. Used in conjunction with test_no_idle_hz. -verbose Enable verbose debugging printing, via printk(). Enabled +verbose + Enable verbose debugging printing, via printk(). Enabled by default. This extra information is mostly related to high-level errors and reports from the main 'torture' framework. -STATISTICS +Statistics +========== -Statistics are printed in the following format: +Statistics are printed in the following format:: -spin_lock-torture: Writes: Total: 93746064 Max/Min: 0/0 Fail: 0 - (A) (B) (C) (D) (E) + spin_lock-torture: Writes: Total: 93746064 Max/Min: 0/0 Fail: 0 + (A) (B) (C) (D) (E) -(A): Lock type that is being tortured -- torture_type parameter. + (A): Lock type that is being tortured -- torture_type parameter. -(B): Number of writer lock acquisitions. If dealing with a read/write primitive - a second "Reads" statistics line is printed. + (B): Number of writer lock acquisitions. If dealing with a read/write + primitive a second "Reads" statistics line is printed. -(C): Number of times the lock was acquired. + (C): Number of times the lock was acquired. -(D): Min and max number of times threads failed to acquire the lock. + (D): Min and max number of times threads failed to acquire the lock. -(E): true/false values if there were errors acquiring the lock. This should - -only- be positive if there is a bug in the locking primitive's - implementation. Otherwise a lock should never fail (i.e., spin_lock()). - Of course, the same applies for (C), above. A dummy example of this is - the "lock_busted" type. + (E): true/false values if there were errors acquiring the lock. This should + -only- be positive if there is a bug in the locking primitive's + implementation. Otherwise a lock should never fail (i.e., spin_lock()). + Of course, the same applies for (C), above. A dummy example of this is + the "lock_busted" type. -USAGE +Usage +===== -The following script may be used to torture locks: +The following script may be used to torture locks:: #!/bin/sh diff --git a/Documentation/locking/mutex-design.txt b/Documentation/locking/mutex-design.rst similarity index 94% rename from Documentation/locking/mutex-design.txt rename to Documentation/locking/mutex-design.rst index 818aca19612f..4d8236b81fa5 100644 --- a/Documentation/locking/mutex-design.txt +++ b/Documentation/locking/mutex-design.rst @@ -1,6 +1,9 @@ +======================= Generic Mutex Subsystem +======================= started by Ingo Molnar + updated by Davidlohr Bueso What are mutexes? @@ -23,7 +26,7 @@ Implementation Mutexes are represented by 'struct mutex', defined in include/linux/mutex.h and implemented in kernel/locking/mutex.c. These locks use an atomic variable (->owner) to keep track of the lock state during its lifetime. Field owner -actually contains 'struct task_struct *' to the current lock owner and it is +actually contains `struct task_struct *` to the current lock owner and it is therefore NULL if not currently owned. Since task_struct pointers are aligned at at least L1_CACHE_BYTES, low bits (3) are used to store extra state (e.g., if waiter list is non-empty). In its most basic form it also includes a @@ -101,29 +104,36 @@ features that make lock debugging easier and faster: Interfaces ---------- -Statically define the mutex: +Statically define the mutex:: + DEFINE_MUTEX(name); -Dynamically initialize the mutex: +Dynamically initialize the mutex:: + mutex_init(mutex); -Acquire the mutex, uninterruptible: +Acquire the mutex, uninterruptible:: + void mutex_lock(struct mutex *lock); void mutex_lock_nested(struct mutex *lock, unsigned int subclass); int mutex_trylock(struct mutex *lock); -Acquire the mutex, interruptible: +Acquire the mutex, interruptible:: + int mutex_lock_interruptible_nested(struct mutex *lock, unsigned int subclass); int mutex_lock_interruptible(struct mutex *lock); -Acquire the mutex, interruptible, if dec to 0: +Acquire the mutex, interruptible, if dec to 0:: + int atomic_dec_and_mutex_lock(atomic_t *cnt, struct mutex *lock); -Unlock the mutex: +Unlock the mutex:: + void mutex_unlock(struct mutex *lock); -Test if the mutex is taken: +Test if the mutex is taken:: + int mutex_is_locked(struct mutex *lock); Disadvantages diff --git a/Documentation/locking/rt-mutex-design.txt b/Documentation/locking/rt-mutex-design.rst similarity index 91% rename from Documentation/locking/rt-mutex-design.txt rename to Documentation/locking/rt-mutex-design.rst index 3d7b865539cc..59c2a64efb21 100644 --- a/Documentation/locking/rt-mutex-design.txt +++ b/Documentation/locking/rt-mutex-design.rst @@ -1,14 +1,15 @@ -# -# Copyright (c) 2006 Steven Rostedt -# Licensed under the GNU Free Documentation License, Version 1.2 -# - +============================== RT-mutex implementation design ------------------------------- +============================== + +Copyright (c) 2006 Steven Rostedt + +Licensed under the GNU Free Documentation License, Version 1.2 + This document tries to describe the design of the rtmutex.c implementation. It doesn't describe the reasons why rtmutex.c exists. For that please see -Documentation/locking/rt-mutex.txt. Although this document does explain problems +Documentation/locking/rt-mutex.rst. Although this document does explain problems that happen without this code, but that is in the concept to understand what the code actually is doing. @@ -41,17 +42,17 @@ to release the lock, because for all we know, B is a CPU hog and will never give C a chance to release the lock. This is called unbounded priority inversion. -Here's a little ASCII art to show the problem. +Here's a little ASCII art to show the problem:: - grab lock L1 (owned by C) - | -A ---+ - C preempted by B - | -C +----+ + grab lock L1 (owned by C) + | + A ---+ + C preempted by B + | + C +----+ -B +--------> - B now keeps A from running. + B +--------> + B now keeps A from running. Priority Inheritance (PI) @@ -75,24 +76,29 @@ Terminology Here I explain some terminology that is used in this document to help describe the design that is used to implement PI. -PI chain - The PI chain is an ordered series of locks and processes that cause +PI chain + - The PI chain is an ordered series of locks and processes that cause processes to inherit priorities from a previous process that is blocked on one of its locks. This is described in more detail later in this document. -mutex - In this document, to differentiate from locks that implement +mutex + - In this document, to differentiate from locks that implement PI and spin locks that are used in the PI code, from now on the PI locks will be called a mutex. -lock - In this document from now on, I will use the term lock when +lock + - In this document from now on, I will use the term lock when referring to spin locks that are used to protect parts of the PI algorithm. These locks disable preemption for UP (when CONFIG_PREEMPT is enabled) and on SMP prevents multiple CPUs from entering critical sections simultaneously. -spin lock - Same as lock above. +spin lock + - Same as lock above. -waiter - A waiter is a struct that is stored on the stack of a blocked +waiter + - A waiter is a struct that is stored on the stack of a blocked process. Since the scope of the waiter is within the code for a process being blocked on the mutex, it is fine to allocate the waiter on the process's stack (local variable). This @@ -104,14 +110,18 @@ waiter - A waiter is a struct that is stored on the stack of a blocked waiter is sometimes used in reference to the task that is waiting on a mutex. This is the same as waiter->task. -waiters - A list of processes that are blocked on a mutex. +waiters + - A list of processes that are blocked on a mutex. -top waiter - The highest priority process waiting on a specific mutex. +top waiter + - The highest priority process waiting on a specific mutex. -top pi waiter - The highest priority process waiting on one of the mutexes +top pi waiter + - The highest priority process waiting on one of the mutexes that a specific process owns. -Note: task and process are used interchangeably in this document, mostly to +Note: + task and process are used interchangeably in this document, mostly to differentiate between two processes that are being described together. @@ -123,7 +133,7 @@ inheritance to take place. Multiple chains may converge, but a chain would never diverge, since a process can't be blocked on more than one mutex at a time. -Example: +Example:: Process: A, B, C, D, E Mutexes: L1, L2, L3, L4 @@ -137,21 +147,21 @@ Example: D owns L4 E blocked on L4 -The chain would be: +The chain would be:: E->L4->D->L3->C->L2->B->L1->A To show where two chains merge, we could add another process F and another mutex L5 where B owns L5 and F is blocked on mutex L5. -The chain for F would be: +The chain for F would be:: F->L5->B->L1->A Since a process may own more than one mutex, but never be blocked on more than one, the chains merge. -Here we show both chains: +Here we show both chains:: E->L4->D->L3->C->L2-+ | @@ -165,12 +175,12 @@ than the processes to the left or below in the chain. Also since a mutex may have more than one process blocked on it, we can have multiple chains merge at mutexes. If we add another process G that is -blocked on mutex L2: +blocked on mutex L2:: G->L2->B->L1->A And once again, to show how this can grow I will show the merging chains -again. +again:: E->L4->D->L3->C-+ +->L2-+ @@ -184,7 +194,7 @@ the chain (A and B in this example), must have their priorities increased to that of G. Mutex Waiters Tree ------------------ +------------------ Every mutex keeps track of all the waiters that are blocked on itself. The mutex has a rbtree to store these waiters by priority. This tree is protected @@ -219,19 +229,19 @@ defined. But is very complex to figure it out, since it depends on all the nesting of mutexes. Let's look at the example where we have 3 mutexes, L1, L2, and L3, and four separate functions func1, func2, func3 and func4. The following shows a locking order of L1->L2->L3, but may not actually -be directly nested that way. +be directly nested that way:: -void func1(void) -{ + void func1(void) + { mutex_lock(L1); /* do anything */ mutex_unlock(L1); -} + } -void func2(void) -{ + void func2(void) + { mutex_lock(L1); mutex_lock(L2); @@ -239,10 +249,10 @@ void func2(void) mutex_unlock(L2); mutex_unlock(L1); -} + } -void func3(void) -{ + void func3(void) + { mutex_lock(L2); mutex_lock(L3); @@ -250,30 +260,30 @@ void func3(void) mutex_unlock(L3); mutex_unlock(L2); -} + } -void func4(void) -{ + void func4(void) + { mutex_lock(L3); /* do something again */ mutex_unlock(L3); -} + } Now we add 4 processes that run each of these functions separately. Processes A, B, C, and D which run functions func1, func2, func3 and func4 respectively, and such that D runs first and A last. With D being preempted -in func4 in the "do something again" area, we have a locking that follows: +in func4 in the "do something again" area, we have a locking that follows:: -D owns L3 - C blocked on L3 - C owns L2 - B blocked on L2 - B owns L1 - A blocked on L1 + D owns L3 + C blocked on L3 + C owns L2 + B blocked on L2 + B owns L1 + A blocked on L1 -And thus we have the chain A->L1->B->L2->C->L3->D. + And thus we have the chain A->L1->B->L2->C->L3->D. This gives us a PI depth of 4 (four processes), but looking at any of the functions individually, it seems as though they only have at most a locking @@ -298,7 +308,7 @@ not true, the rtmutex.c code will be broken!), this allows for the least significant bit to be used as a flag. Bit 0 is used as the "Has Waiters" flag. It's set whenever there are waiters on a mutex. -See Documentation/locking/rt-mutex.txt for further details. +See Documentation/locking/rt-mutex.rst for further details. cmpxchg Tricks -------------- @@ -307,17 +317,17 @@ Some architectures implement an atomic cmpxchg (Compare and Exchange). This is used (when applicable) to keep the fast path of grabbing and releasing mutexes short. -cmpxchg is basically the following function performed atomically: +cmpxchg is basically the following function performed atomically:: -unsigned long _cmpxchg(unsigned long *A, unsigned long *B, unsigned long *C) -{ + unsigned long _cmpxchg(unsigned long *A, unsigned long *B, unsigned long *C) + { unsigned long T = *A; if (*A == *B) { *A = *C; } return T; -} -#define cmpxchg(a,b,c) _cmpxchg(&a,&b,&c) + } + #define cmpxchg(a,b,c) _cmpxchg(&a,&b,&c) This is really nice to have, since it allows you to only update a variable if the variable is what you expect it to be. You know if it succeeded if @@ -352,9 +362,10 @@ Then rt_mutex_setprio is called to adjust the priority of the task to the new priority. Note that rt_mutex_setprio is defined in kernel/sched/core.c to implement the actual change in priority. -(Note: For the "prio" field in task_struct, the lower the number, the +Note: + For the "prio" field in task_struct, the lower the number, the higher the priority. A "prio" of 5 is of higher priority than a - "prio" of 10.) + "prio" of 10. It is interesting to note that rt_mutex_adjust_prio can either increase or decrease the priority of the task. In the case that a higher priority @@ -439,6 +450,7 @@ wait_lock, which this code currently holds. So setting the "Has Waiters" flag forces the current owner to synchronize with this code. The lock is taken if the following are true: + 1) The lock has no owner 2) The current task is the highest priority against all other waiters of the lock @@ -546,10 +558,13 @@ Credits ------- Author: Steven Rostedt + Updated: Alex Shi - 7/6/2017 -Original Reviewers: Ingo Molnar, Thomas Gleixner, Thomas Duetsch, and +Original Reviewers: + Ingo Molnar, Thomas Gleixner, Thomas Duetsch, and Randy Dunlap + Update (7/6/2017) Reviewers: Steven Rostedt and Sebastian Siewior Updates diff --git a/Documentation/locking/rt-mutex.txt b/Documentation/locking/rt-mutex.rst similarity index 71% rename from Documentation/locking/rt-mutex.txt rename to Documentation/locking/rt-mutex.rst index 35793e003041..c365dc302081 100644 --- a/Documentation/locking/rt-mutex.txt +++ b/Documentation/locking/rt-mutex.rst @@ -1,5 +1,6 @@ +================================== RT-mutex subsystem with PI support ----------------------------------- +================================== RT-mutexes with priority inheritance are used to support PI-futexes, which enable pthread_mutex_t priority inheritance attributes @@ -46,27 +47,30 @@ The state of the rt-mutex is tracked via the owner field of the rt-mutex structure: lock->owner holds the task_struct pointer of the owner. Bit 0 is used to -keep track of the "lock has waiters" state. +keep track of the "lock has waiters" state: - owner bit0 + ============ ======= ================================================ + owner bit0 Notes + ============ ======= ================================================ NULL 0 lock is free (fast acquire possible) NULL 1 lock is free and has waiters and the top waiter - is going to take the lock* + is going to take the lock [1]_ taskpointer 0 lock is held (fast release possible) - taskpointer 1 lock is held and has waiters** + taskpointer 1 lock is held and has waiters [2]_ + ============ ======= ================================================ The fast atomic compare exchange based acquire and release is only possible when bit 0 of lock->owner is 0. -(*) It also can be a transitional state when grabbing the lock -with ->wait_lock is held. To prevent any fast path cmpxchg to the lock, -we need to set the bit0 before looking at the lock, and the owner may be -NULL in this small time, hence this can be a transitional state. +.. [1] It also can be a transitional state when grabbing the lock + with ->wait_lock is held. To prevent any fast path cmpxchg to the lock, + we need to set the bit0 before looking at the lock, and the owner may + be NULL in this small time, hence this can be a transitional state. -(**) There is a small time when bit 0 is set but there are no -waiters. This can happen when grabbing the lock in the slow path. -To prevent a cmpxchg of the owner releasing the lock, we need to -set this bit before looking at the lock. +.. [2] There is a small time when bit 0 is set but there are no + waiters. This can happen when grabbing the lock in the slow path. + To prevent a cmpxchg of the owner releasing the lock, we need to + set this bit before looking at the lock. BTW, there is still technically a "Pending Owner", it's just not called that anymore. The pending owner happens to be the top_waiter of a lock diff --git a/Documentation/locking/spinlocks.txt b/Documentation/locking/spinlocks.rst similarity index 89% rename from Documentation/locking/spinlocks.txt rename to Documentation/locking/spinlocks.rst index ff35e40bdf5b..098107fb7d86 100644 --- a/Documentation/locking/spinlocks.txt +++ b/Documentation/locking/spinlocks.rst @@ -1,8 +1,13 @@ +=============== +Locking lessons +=============== + Lesson 1: Spin locks +==================== -The most basic primitive for locking is spinlock. +The most basic primitive for locking is spinlock:: -static DEFINE_SPINLOCK(xxx_lock); + static DEFINE_SPINLOCK(xxx_lock); unsigned long flags; @@ -19,23 +24,25 @@ worry about UP vs SMP issues: the spinlocks work correctly under both. NOTE! Implications of spin_locks for memory are further described in: Documentation/memory-barriers.txt + (5) LOCK operations. + (6) UNLOCK operations. The above is usually pretty simple (you usually need and want only one spinlock for most things - using more than one spinlock can make things a lot more complex and even slower and is usually worth it only for -sequences that you _know_ need to be split up: avoid it at all cost if you +sequences that you **know** need to be split up: avoid it at all cost if you aren't sure). This is really the only really hard part about spinlocks: once you start using spinlocks they tend to expand to areas you might not have noticed before, because you have to make sure the spinlocks correctly protect the -shared data structures _everywhere_ they are used. The spinlocks are most +shared data structures **everywhere** they are used. The spinlocks are most easily added to places that are completely independent of other code (for example, internal driver data structures that nobody else ever touches). - NOTE! The spin-lock is safe only when you _also_ use the lock itself + NOTE! The spin-lock is safe only when you **also** use the lock itself to do locking across CPU's, which implies that EVERYTHING that touches a shared variable has to agree about the spinlock they want to use. @@ -43,6 +50,7 @@ example, internal driver data structures that nobody else ever touches). ---- Lesson 2: reader-writer spinlocks. +================================== If your data accesses have a very natural pattern where you usually tend to mostly read from the shared variables, the reader-writer locks @@ -54,7 +62,7 @@ to change the variables it has to get an exclusive write lock. simple spinlocks. Unless the reader critical section is long, you are better off just using spinlocks. -The routines look the same as above: +The routines look the same as above:: rwlock_t xxx_lock = __RW_LOCK_UNLOCKED(xxx_lock); @@ -71,7 +79,7 @@ The routines look the same as above: The above kind of lock may be useful for complex data structures like linked lists, especially searching for entries without changing the list itself. The read lock allows many concurrent readers. Anything that -_changes_ the list will have to get the write lock. +**changes** the list will have to get the write lock. NOTE! RCU is better for list traversal, but requires careful attention to design detail (see Documentation/RCU/listRCU.txt). @@ -87,10 +95,11 @@ to get the write-lock at the very beginning. ---- Lesson 3: spinlocks revisited. +============================== The single spin-lock primitives above are by no means the only ones. They are the most safe ones, and the ones that work under all circumstances, -but partly _because_ they are safe they are also fairly slow. They are slower +but partly **because** they are safe they are also fairly slow. They are slower than they'd need to be, because they do have to disable interrupts (which is just a single instruction on a x86, but it's an expensive one - and on other architectures it can be worse). @@ -98,7 +107,7 @@ and on other architectures it can be worse). If you have a case where you have to protect a data structure across several CPU's and you want to use spinlocks you can potentially use cheaper versions of the spinlocks. IFF you know that the spinlocks are -never used in interrupt handlers, you can use the non-irq versions: +never used in interrupt handlers, you can use the non-irq versions:: spin_lock(&lock); ... @@ -110,7 +119,7 @@ This is useful if you know that the data in question is only ever manipulated from a "process context", ie no interrupts involved. The reasons you mustn't use these versions if you have interrupts that -play with the spinlock is that you can get deadlocks: +play with the spinlock is that you can get deadlocks:: spin_lock(&lock); ... @@ -147,9 +156,10 @@ indeed), while write-locks need to protect themselves against interrupts. ---- Reference information: +====================== For dynamic initialization, use spin_lock_init() or rwlock_init() as -appropriate: +appropriate:: spinlock_t xxx_lock; rwlock_t xxx_rw_lock; diff --git a/Documentation/locking/ww-mutex-design.txt b/Documentation/locking/ww-mutex-design.rst similarity index 93% rename from Documentation/locking/ww-mutex-design.txt rename to Documentation/locking/ww-mutex-design.rst index f0ed7c30e695..1846c199da23 100644 --- a/Documentation/locking/ww-mutex-design.txt +++ b/Documentation/locking/ww-mutex-design.rst @@ -1,3 +1,4 @@ +====================================== Wound/Wait Deadlock-Proof Mutex Design ====================================== @@ -85,6 +86,7 @@ Furthermore there are three different class of w/w lock acquire functions: no deadlock potential and hence the ww_mutex_lock call will block and not prematurely return -EDEADLK. The advantage of the _slow functions is in interface safety: + - ww_mutex_lock has a __must_check int return type, whereas ww_mutex_lock_slow has a void return type. Note that since ww mutex code needs loops/retries anyway the __must_check doesn't result in spurious warnings, even though the @@ -115,36 +117,36 @@ expect the number of simultaneous competing transactions to be typically small, and you want to reduce the number of rollbacks. Three different ways to acquire locks within the same w/w class. Common -definitions for methods #1 and #2: +definitions for methods #1 and #2:: -static DEFINE_WW_CLASS(ww_class); + static DEFINE_WW_CLASS(ww_class); -struct obj { + struct obj { struct ww_mutex lock; /* obj data */ -}; + }; -struct obj_entry { + struct obj_entry { struct list_head head; struct obj *obj; -}; + }; Method 1, using a list in execbuf->buffers that's not allowed to be reordered. This is useful if a list of required objects is already tracked somewhere. Furthermore the lock helper can use propagate the -EALREADY return code back to the caller as a signal that an object is twice on the list. This is useful if the list is constructed from userspace input and the ABI requires userspace to -not have duplicate entries (e.g. for a gpu commandbuffer submission ioctl). +not have duplicate entries (e.g. for a gpu commandbuffer submission ioctl):: -int lock_objs(struct list_head *list, struct ww_acquire_ctx *ctx) -{ + int lock_objs(struct list_head *list, struct ww_acquire_ctx *ctx) + { struct obj *res_obj = NULL; struct obj_entry *contended_entry = NULL; struct obj_entry *entry; ww_acquire_init(ctx, &ww_class); -retry: + retry: list_for_each_entry (entry, list, head) { if (entry->obj == res_obj) { res_obj = NULL; @@ -160,7 +162,7 @@ retry: ww_acquire_done(ctx); return 0; -err: + err: list_for_each_entry_continue_reverse (entry, list, head) ww_mutex_unlock(&entry->obj->lock); @@ -176,14 +178,14 @@ err: ww_acquire_fini(ctx); return ret; -} + } Method 2, using a list in execbuf->buffers that can be reordered. Same semantics of duplicate entry detection using -EALREADY as method 1 above. But the -list-reordering allows for a bit more idiomatic code. +list-reordering allows for a bit more idiomatic code:: -int lock_objs(struct list_head *list, struct ww_acquire_ctx *ctx) -{ + int lock_objs(struct list_head *list, struct ww_acquire_ctx *ctx) + { struct obj_entry *entry, *entry2; ww_acquire_init(ctx, &ww_class); @@ -216,24 +218,25 @@ int lock_objs(struct list_head *list, struct ww_acquire_ctx *ctx) ww_acquire_done(ctx); return 0; -} + } -Unlocking works the same way for both methods #1 and #2: +Unlocking works the same way for both methods #1 and #2:: -void unlock_objs(struct list_head *list, struct ww_acquire_ctx *ctx) -{ + void unlock_objs(struct list_head *list, struct ww_acquire_ctx *ctx) + { struct obj_entry *entry; list_for_each_entry (entry, list, head) ww_mutex_unlock(&entry->obj->lock); ww_acquire_fini(ctx); -} + } Method 3 is useful if the list of objects is constructed ad-hoc and not upfront, e.g. when adjusting edges in a graph where each node has its own ww_mutex lock, and edges can only be changed when holding the locks of all involved nodes. w/w mutexes are a natural fit for such a case for two reasons: + - They can handle lock-acquisition in any order which allows us to start walking a graph from a starting point and then iteratively discovering new edges and locking down the nodes those edges connect to. @@ -243,6 +246,7 @@ mutexes are a natural fit for such a case for two reasons: as a starting point). Note that this approach differs in two important ways from the above methods: + - Since the list of objects is dynamically constructed (and might very well be different when retrying due to hitting the -EDEADLK die condition) there's no need to keep any object on a persistent list when it's not locked. We can @@ -260,17 +264,17 @@ any interface misuse for these cases. Also, method 3 can't fail the lock acquisition step since it doesn't return -EALREADY. Of course this would be different when using the _interruptible -variants, but that's outside of the scope of these examples here. +variants, but that's outside of the scope of these examples here:: -struct obj { + struct obj { struct ww_mutex ww_mutex; struct list_head locked_list; -}; + }; -static DEFINE_WW_CLASS(ww_class); + static DEFINE_WW_CLASS(ww_class); -void __unlock_objs(struct list_head *list) -{ + void __unlock_objs(struct list_head *list) + { struct obj *entry, *temp; list_for_each_entry_safe (entry, temp, list, locked_list) { @@ -279,15 +283,15 @@ void __unlock_objs(struct list_head *list) list_del(&entry->locked_list); ww_mutex_unlock(entry->ww_mutex) } -} + } -void lock_objs(struct list_head *list, struct ww_acquire_ctx *ctx) -{ + void lock_objs(struct list_head *list, struct ww_acquire_ctx *ctx) + { struct obj *obj; ww_acquire_init(ctx, &ww_class); -retry: + retry: /* re-init loop start state */ loop { /* magic code which walks over a graph and decides which objects @@ -312,13 +316,13 @@ retry: ww_acquire_done(ctx); return 0; -} + } -void unlock_objs(struct list_head *list, struct ww_acquire_ctx *ctx) -{ + void unlock_objs(struct list_head *list, struct ww_acquire_ctx *ctx) + { __unlock_objs(list); ww_acquire_fini(ctx); -} + } Method 4: Only lock one single objects. In that case deadlock detection and prevention is obviously overkill, since with grabbing just one lock you can't @@ -329,11 +333,14 @@ Implementation Details ---------------------- Design: +^^^^^^^ + ww_mutex currently encapsulates a struct mutex, this means no extra overhead for normal mutex locks, which are far more common. As such there is only a small increase in code size if wait/wound mutexes are not used. We maintain the following invariants for the wait list: + (1) Waiters with an acquire context are sorted by stamp order; waiters without an acquire context are interspersed in FIFO order. (2) For Wait-Die, among waiters with contexts, only the first one can have @@ -355,6 +362,8 @@ Design: therefore be directed towards the uncontended cases. Lockdep: +^^^^^^^^ + Special care has been taken to warn for as many cases of api abuse as possible. Some common api abuses will be caught with CONFIG_DEBUG_MUTEXES, but CONFIG_PROVE_LOCKING is recommended. @@ -379,5 +388,6 @@ Lockdep: having called ww_acquire_fini on the first. - 'normal' deadlocks that can occur. -FIXME: Update this section once we have the TASK_DEADLOCK task state flag magic -implemented. +FIXME: + Update this section once we have the TASK_DEADLOCK task state flag magic + implemented. diff --git a/Documentation/pi-futex.txt b/Documentation/pi-futex.txt index b154f6c0c36e..c33ba2befbf8 100644 --- a/Documentation/pi-futex.txt +++ b/Documentation/pi-futex.txt @@ -119,4 +119,4 @@ properties of futexes, and all four combinations are possible: futex, robust-futex, PI-futex, robust+PI-futex. More details about priority inheritance can be found in -Documentation/locking/rt-mutex.txt. +Documentation/locking/rt-mutex.rst. diff --git a/Documentation/translations/it_IT/kernel-hacking/locking.rst b/Documentation/translations/it_IT/kernel-hacking/locking.rst index 0ef31666663b..75d9b86fcc50 100644 --- a/Documentation/translations/it_IT/kernel-hacking/locking.rst +++ b/Documentation/translations/it_IT/kernel-hacking/locking.rst @@ -1404,7 +1404,7 @@ Riferimento per l'API dei Futex Approfondimenti =============== -- ``Documentation/locking/spinlocks.txt``: la guida di Linus Torvalds agli +- ``Documentation/locking/spinlocks.rst``: la guida di Linus Torvalds agli spinlock del kernel. - Unix Systems for Modern Architectures: Symmetric Multiprocessing and diff --git a/drivers/gpu/drm/drm_modeset_lock.c b/drivers/gpu/drm/drm_modeset_lock.c index 81dd11901ffd..cb5671d32ada 100644 --- a/drivers/gpu/drm/drm_modeset_lock.c +++ b/drivers/gpu/drm/drm_modeset_lock.c @@ -36,7 +36,7 @@ * of extra utility/tracking out of our acquire-ctx. This is provided * by &struct drm_modeset_lock and &struct drm_modeset_acquire_ctx. * - * For basic principles of &ww_mutex, see: Documentation/locking/ww-mutex-design.txt + * For basic principles of &ww_mutex, see: Documentation/locking/ww-mutex-design.rst * * The basic usage pattern is to:: * diff --git a/include/linux/lockdep.h b/include/linux/lockdep.h index 79c3873d58ac..4c6296aaeefb 100644 --- a/include/linux/lockdep.h +++ b/include/linux/lockdep.h @@ -5,7 +5,7 @@ * Copyright (C) 2006,2007 Red Hat, Inc., Ingo Molnar * Copyright (C) 2007 Red Hat, Inc., Peter Zijlstra * - * see Documentation/locking/lockdep-design.txt for more details. + * see Documentation/locking/lockdep-design.rst for more details. */ #ifndef __LINUX_LOCKDEP_H #define __LINUX_LOCKDEP_H diff --git a/include/linux/mutex.h b/include/linux/mutex.h index 3093dd162424..dcd03fee6e01 100644 --- a/include/linux/mutex.h +++ b/include/linux/mutex.h @@ -151,7 +151,7 @@ static inline bool mutex_is_locked(struct mutex *lock) /* * See kernel/locking/mutex.c for detailed documentation of these APIs. - * Also see Documentation/locking/mutex-design.txt. + * Also see Documentation/locking/mutex-design.rst. */ #ifdef CONFIG_DEBUG_LOCK_ALLOC extern void mutex_lock_nested(struct mutex *lock, unsigned int subclass); diff --git a/include/linux/rwsem.h b/include/linux/rwsem.h index 2ea18a3def04..61a084ae17ac 100644 --- a/include/linux/rwsem.h +++ b/include/linux/rwsem.h @@ -158,7 +158,7 @@ extern void downgrade_write(struct rw_semaphore *sem); * static then another method for expressing nested locking is * the explicit definition of lock class keys and the use of * lockdep_set_class() at lock initialization time. - * See Documentation/locking/lockdep-design.txt for more details.) + * See Documentation/locking/lockdep-design.rst for more details.) */ extern void down_read_nested(struct rw_semaphore *sem, int subclass); extern void down_write_nested(struct rw_semaphore *sem, int subclass); diff --git a/kernel/locking/mutex.c b/kernel/locking/mutex.c index db578783dd36..5ec20b3cdbe5 100644 --- a/kernel/locking/mutex.c +++ b/kernel/locking/mutex.c @@ -15,7 +15,7 @@ * by Steven Rostedt, based on work by Gregory Haskins, Peter Morreale * and Sven Dietrich. * - * Also see Documentation/locking/mutex-design.txt. + * Also see Documentation/locking/mutex-design.rst. */ #include #include diff --git a/kernel/locking/rtmutex.c b/kernel/locking/rtmutex.c index 978d63a8261c..8630bb99eec7 100644 --- a/kernel/locking/rtmutex.c +++ b/kernel/locking/rtmutex.c @@ -8,7 +8,7 @@ * Copyright (C) 2005 Kihon Technologies Inc., Steven Rostedt * Copyright (C) 2006 Esben Nielsen * - * See Documentation/locking/rt-mutex-design.txt for details. + * See Documentation/locking/rt-mutex-design.rst for details. */ #include #include diff --git a/lib/Kconfig.debug b/lib/Kconfig.debug index 1b0129196e70..aa05f47f5762 100644 --- a/lib/Kconfig.debug +++ b/lib/Kconfig.debug @@ -1112,7 +1112,7 @@ config PROVE_LOCKING the proof of observed correctness is also maintained for an arbitrary combination of these separate locking variants. - For more details, see Documentation/locking/lockdep-design.txt. + For more details, see Documentation/locking/lockdep-design.rst. config LOCK_STAT bool "Lock usage statistics" @@ -1126,7 +1126,7 @@ config LOCK_STAT help This feature enables tracking lock contention points - For more details, see Documentation/locking/lockstat.txt + For more details, see Documentation/locking/lockstat.rst This also enables lock events required by "perf lock", subcommand of perf. -- 2.20.1 From mboxrd@z Thu Jan 1 00:00:00 1970 From: Mauro Carvalho Chehab Subject: [PATCH v2 21/79] docs: locking: convert docs to ReST and rename to *.rst Date: Mon, 22 Apr 2019 10:27:10 -0300 Message-ID: References: Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Return-path: Received: from bombadil.infradead.org (bombadil.infradead.org [IPv6:2607:7c80:54:e::133]) by gabe.freedesktop.org (Postfix) with ESMTPS id 183BD891AD for ; Mon, 22 Apr 2019 13:28:26 +0000 (UTC) In-Reply-To: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: dri-devel-bounces@lists.freedesktop.org Sender: "dri-devel" To: Linux Doc Mailing List Cc: Jonathan Corbet , Peter Zijlstra , David Airlie , Will Deacon , linux-kernel@vger.kernel.org, dri-devel@lists.freedesktop.org, Mauro Carvalho Chehab , Maxime Ripard , Ingo Molnar , Federico Vaga , Mauro Carvalho Chehab , Sean Paul List-Id: dri-devel@lists.freedesktop.org Q29udmVydCB0aGUgbG9ja2luZyBkb2N1bWVudHMgdG8gUmVTVCBhbmQgYWRkIHRoZW0gdG8gdGhl Cmtlcm5lbCBkZXZlbG9wbWVudCBib29rIHdoZXJlIGl0IGJlbG9uZ3MuCgpNb3N0IG9mIHRoZSBz dHVmZiBoZXJlIGlzIGp1c3QgdG8gbWFrZSBTcGhpbnggdG8gcHJvcGVybHkKcGFyc2UgdGhlIHRl eHQgZmlsZSwgYXMgdGhleSdyZSBhbHJlYWR5IGluIGdvb2Qgc2hhcGUsCm5vdCByZXF1aXJpbmcg bWFzc2l2ZSBjaGFuZ2VzIGluIG9yZGVyIHRvIGJlIHBhcnNlZC4KClRoZSBjb252ZXJzaW9uIGlz IGFjdHVhbGx5OgogIC0gYWRkIGJsYW5rIGxpbmVzIGFuZCBpZGVudGF0aW9uIGluIG9yZGVyIHRv IGlkZW50aWZ5IHBhcmFncmFwaHM7CiAgLSBmaXggdGFibGVzIG1hcmt1cHM7CiAgLSBhZGQgc29t ZSBsaXN0cyBtYXJrdXBzOwogIC0gbWFyayBsaXRlcmFsIGJsb2NrczsKICAtIGFkanVzdCB0aXRs ZSBtYXJrdXBzLgoKQXQgaXRzIG5ldyBpbmRleC5yc3QsIGxldCdzIGFkZCBhIDpvcnBoYW46IHdo aWxlIHRoaXMgaXMgbm90IGxpbmtlZCB0bwp0aGUgbWFpbiBpbmRleC5yc3QgZmlsZSwgaW4gb3Jk ZXIgdG8gYXZvaWQgYnVpbGQgd2FybmluZ3MuCgpTaWduZWQtb2ZmLWJ5OiBNYXVybyBDYXJ2YWxo byBDaGVoYWIgPG1jaGVoYWIrc2Ftc3VuZ0BrZXJuZWwub3JnPgotLS0KIERvY3VtZW50YXRpb24v a2VybmVsLWhhY2tpbmcvbG9ja2luZy5yc3QgICAgICB8ICAgMiArLQogRG9jdW1lbnRhdGlvbi9s b2NraW5nL2luZGV4LnJzdCAgICAgICAgICAgICAgIHwgIDI0ICsrKwogLi4ue2xvY2tkZXAtZGVz aWduLnR4dCA9PiBsb2NrZGVwLWRlc2lnbi5yc3R9IHwgIDQxICsrLS0KIERvY3VtZW50YXRpb24v bG9ja2luZy9sb2Nrc3RhdC5yc3QgICAgICAgICAgICB8IDIwNCArKysrKysrKysrKysrKysrKysK IERvY3VtZW50YXRpb24vbG9ja2luZy9sb2Nrc3RhdC50eHQgICAgICAgICAgICB8IDE4MyAtLS0t LS0tLS0tLS0tLS0tCiAuLi4ve2xvY2t0b3J0dXJlLnR4dCA9PiBsb2NrdG9ydHVyZS5yc3R9ICAg ICAgfCAxMDUgKysrKystLS0tCiAuLi4ve211dGV4LWRlc2lnbi50eHQgPT4gbXV0ZXgtZGVzaWdu LnJzdH0gICAgfCAgMjYgKystCiAuLi50LW11dGV4LWRlc2lnbi50eHQgPT4gcnQtbXV0ZXgtZGVz aWduLnJzdH0gfCAxMzkgKysrKysrLS0tLS0tCiAuLi4vbG9ja2luZy97cnQtbXV0ZXgudHh0ID0+ IHJ0LW11dGV4LnJzdH0gICAgfCAgMzAgKy0tCiAuLi4vbG9ja2luZy97c3BpbmxvY2tzLnR4dCA9 PiBzcGlubG9ja3MucnN0fSAgfCAgMzIgKystCiAuLi53LW11dGV4LWRlc2lnbi50eHQgPT4gd3ct bXV0ZXgtZGVzaWduLnJzdH0gfCAgODIgKysrLS0tLQogRG9jdW1lbnRhdGlvbi9waS1mdXRleC50 eHQgICAgICAgICAgICAgICAgICAgIHwgICAyICstCiAuLi4vaXRfSVQva2VybmVsLWhhY2tpbmcv bG9ja2luZy5yc3QgICAgICAgICAgfCAgIDIgKy0KIGRyaXZlcnMvZ3B1L2RybS9kcm1fbW9kZXNl dF9sb2NrLmMgICAgICAgICAgICB8ICAgMiArLQogaW5jbHVkZS9saW51eC9sb2NrZGVwLmggICAg ICAgICAgICAgICAgICAgICAgIHwgICAyICstCiBpbmNsdWRlL2xpbnV4L211dGV4LmggICAgICAg ICAgICAgICAgICAgICAgICAgfCAgIDIgKy0KIGluY2x1ZGUvbGludXgvcndzZW0uaCAgICAgICAg ICAgICAgICAgICAgICAgICB8ICAgMiArLQoga2VybmVsL2xvY2tpbmcvbXV0ZXguYyAgICAgICAg ICAgICAgICAgICAgICAgIHwgICAyICstCiBrZXJuZWwvbG9ja2luZy9ydG11dGV4LmMgICAgICAg ICAgICAgICAgICAgICAgfCAgIDIgKy0KIGxpYi9LY29uZmlnLmRlYnVnICAgICAgICAgICAgICAg ICAgICAgICAgICAgICB8ICAgNCArLQogMjAgZmlsZXMgY2hhbmdlZCwgNTA2IGluc2VydGlvbnMo KyksIDM4MiBkZWxldGlvbnMoLSkKIGNyZWF0ZSBtb2RlIDEwMDY0NCBEb2N1bWVudGF0aW9uL2xv Y2tpbmcvaW5kZXgucnN0CiByZW5hbWUgRG9jdW1lbnRhdGlvbi9sb2NraW5nL3tsb2NrZGVwLWRl c2lnbi50eHQgPT4gbG9ja2RlcC1kZXNpZ24ucnN0fSAoOTMlKQogY3JlYXRlIG1vZGUgMTAwNjQ0 IERvY3VtZW50YXRpb24vbG9ja2luZy9sb2Nrc3RhdC5yc3QKIGRlbGV0ZSBtb2RlIDEwMDY0NCBE b2N1bWVudGF0aW9uL2xvY2tpbmcvbG9ja3N0YXQudHh0CiByZW5hbWUgRG9jdW1lbnRhdGlvbi9s b2NraW5nL3tsb2NrdG9ydHVyZS50eHQgPT4gbG9ja3RvcnR1cmUucnN0fSAoNTclKQogcmVuYW1l IERvY3VtZW50YXRpb24vbG9ja2luZy97bXV0ZXgtZGVzaWduLnR4dCA9PiBtdXRleC1kZXNpZ24u cnN0fSAoOTQlKQogcmVuYW1lIERvY3VtZW50YXRpb24vbG9ja2luZy97cnQtbXV0ZXgtZGVzaWdu LnR4dCA9PiBydC1tdXRleC1kZXNpZ24ucnN0fSAoOTElKQogcmVuYW1lIERvY3VtZW50YXRpb24v bG9ja2luZy97cnQtbXV0ZXgudHh0ID0+IHJ0LW11dGV4LnJzdH0gKDcxJSkKIHJlbmFtZSBEb2N1 bWVudGF0aW9uL2xvY2tpbmcve3NwaW5sb2Nrcy50eHQgPT4gc3BpbmxvY2tzLnJzdH0gKDg5JSkK IHJlbmFtZSBEb2N1bWVudGF0aW9uL2xvY2tpbmcve3d3LW11dGV4LWRlc2lnbi50eHQgPT4gd3ct bXV0ZXgtZGVzaWduLnJzdH0gKDkzJSkKCmRpZmYgLS1naXQgYS9Eb2N1bWVudGF0aW9uL2tlcm5l bC1oYWNraW5nL2xvY2tpbmcucnN0IGIvRG9jdW1lbnRhdGlvbi9rZXJuZWwtaGFja2luZy9sb2Nr aW5nLnJzdAppbmRleCA1MTk2NzNkZjBlODIuLjcxYTg0MzQ2NGVjMiAxMDA2NDQKLS0tIGEvRG9j dW1lbnRhdGlvbi9rZXJuZWwtaGFja2luZy9sb2NraW5nLnJzdAorKysgYi9Eb2N1bWVudGF0aW9u L2tlcm5lbC1oYWNraW5nL2xvY2tpbmcucnN0CkBAIC0xMzY0LDcgKzEzNjQsNyBAQCBGdXRleCBB UEkgcmVmZXJlbmNlCiBGdXJ0aGVyIHJlYWRpbmcKID09PT09PT09PT09PT09PQogCi0tICBgYERv Y3VtZW50YXRpb24vbG9ja2luZy9zcGlubG9ja3MudHh0YGA6IExpbnVzIFRvcnZhbGRzJyBzcGlu bG9ja2luZworLSAgYGBEb2N1bWVudGF0aW9uL2xvY2tpbmcvc3BpbmxvY2tzLnJzdGBgOiBMaW51 cyBUb3J2YWxkcycgc3BpbmxvY2tpbmcKICAgIHR1dG9yaWFsIGluIHRoZSBrZXJuZWwgc291cmNl cy4KIAogLSAgVW5peCBTeXN0ZW1zIGZvciBNb2Rlcm4gQXJjaGl0ZWN0dXJlczogU3ltbWV0cmlj IE11bHRpcHJvY2Vzc2luZyBhbmQKZGlmZiAtLWdpdCBhL0RvY3VtZW50YXRpb24vbG9ja2luZy9p bmRleC5yc3QgYi9Eb2N1bWVudGF0aW9uL2xvY2tpbmcvaW5kZXgucnN0Cm5ldyBmaWxlIG1vZGUg MTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwMC4uZWY1ZGE3ZmU5YWFjCi0tLSAvZGV2L251bGwKKysr IGIvRG9jdW1lbnRhdGlvbi9sb2NraW5nL2luZGV4LnJzdApAQCAtMCwwICsxLDI0IEBACis6b3Jw aGFuOgorCis9PT09PT09Citsb2NraW5nCis9PT09PT09CisKKy4uIHRvY3RyZWU6OgorICAgIDpt YXhkZXB0aDogMQorCisgICAgbG9ja2RlcC1kZXNpZ24KKyAgICBsb2Nrc3RhdAorICAgIGxvY2t0 b3J0dXJlCisgICAgbXV0ZXgtZGVzaWduCisgICAgcnQtbXV0ZXgtZGVzaWduCisgICAgcnQtbXV0 ZXgKKyAgICBzcGlubG9ja3MKKyAgICB3dy1tdXRleC1kZXNpZ24KKworLi4gb25seTo6ICBzdWJw cm9qZWN0IGFuZCBodG1sCisKKyAgIEluZGljZXMKKyAgID09PT09PT0KKworICAgKiA6cmVmOmBn ZW5pbmRleGAKZGlmZiAtLWdpdCBhL0RvY3VtZW50YXRpb24vbG9ja2luZy9sb2NrZGVwLWRlc2ln bi50eHQgYi9Eb2N1bWVudGF0aW9uL2xvY2tpbmcvbG9ja2RlcC1kZXNpZ24ucnN0CnNpbWlsYXJp dHkgaW5kZXggOTMlCnJlbmFtZSBmcm9tIERvY3VtZW50YXRpb24vbG9ja2luZy9sb2NrZGVwLWRl c2lnbi50eHQKcmVuYW1lIHRvIERvY3VtZW50YXRpb24vbG9ja2luZy9sb2NrZGVwLWRlc2lnbi5y c3QKaW5kZXggMzlmYWUxNDNjOWNiLi40OTcwN2E1MDI5YzUgMTAwNjQ0Ci0tLSBhL0RvY3VtZW50 YXRpb24vbG9ja2luZy9sb2NrZGVwLWRlc2lnbi50eHQKKysrIGIvRG9jdW1lbnRhdGlvbi9sb2Nr aW5nL2xvY2tkZXAtZGVzaWduLnJzdApAQCAtMiw2ICsyLDcgQEAgUnVudGltZSBsb2NraW5nIGNv cnJlY3RuZXNzIHZhbGlkYXRvcgogPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PQogCiBzdGFydGVkIGJ5IEluZ28gTW9sbmFyIDxtaW5nb0ByZWRoYXQuY29tPgorCiBhZGRpdGlv bnMgYnkgQXJqYW4gdmFuIGRlIFZlbiA8YXJqYW5AbGludXguaW50ZWwuY29tPgogCiBMb2NrLWNs YXNzCkBAIC00Miw3ICs0Myw3IEBAIFdoZXJlIFNUQVRFIGNhbiBiZSBlaXRoZXIgb25lIG9mIChr ZXJuZWwvbG9ja2luZy9sb2NrZGVwX3N0YXRlcy5oKQogLSAnZXZlciB1c2VkJyAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgIFsgPT0gIXVudXNlZCAgICAgICAgXQogCiBXaGVu IGxvY2tpbmcgcnVsZXMgYXJlIHZpb2xhdGVkLCB0aGVzZSBzdGF0ZSBiaXRzIGFyZSBwcmVzZW50 ZWQgaW4gdGhlCi1sb2NraW5nIGVycm9yIG1lc3NhZ2VzLCBpbnNpZGUgY3VybGllcy4gQSBjb250 cml2ZWQgZXhhbXBsZToKK2xvY2tpbmcgZXJyb3IgbWVzc2FnZXMsIGluc2lkZSBjdXJsaWVzLiBB IGNvbnRyaXZlZCBleGFtcGxlOjoKIAogICAgbW9kcHJvYmUvMjI4NyBpcyB0cnlpbmcgdG8gYWNx dWlyZSBsb2NrOgogICAgICgmc2lvX2xvY2tzW2ldLmxvY2spey0uLS59LCBhdDogWzxjMDI4Njdm ZD5dIG11dGV4X2xvY2srMHgyMS8weDI0CkBAIC01NCwxMCArNTUsMTIgQEAgbG9ja2luZyBlcnJv ciBtZXNzYWdlcywgaW5zaWRlIGN1cmxpZXMuIEEgY29udHJpdmVkIGV4YW1wbGU6CiBUaGUgYml0 IHBvc2l0aW9uIGluZGljYXRlcyBTVEFURSwgU1RBVEUtcmVhZCwgZm9yIGVhY2ggb2YgdGhlIHN0 YXRlcyBsaXN0ZWQKIGFib3ZlLCBhbmQgdGhlIGNoYXJhY3RlciBkaXNwbGF5ZWQgaW4gZWFjaCBp bmRpY2F0ZXM6CiAKKyAgID09PSAgPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09CiAgICAnLicgIGFjcXVpcmVkIHdoaWxlIGlycXMgZGlzYWJsZWQgYW5k IG5vdCBpbiBpcnEgY29udGV4dAogICAgJy0nICBhY3F1aXJlZCBpbiBpcnEgY29udGV4dAogICAg JysnICBhY3F1aXJlZCB3aXRoIGlycXMgZW5hYmxlZAogICAgJz8nICBhY3F1aXJlZCBpbiBpcnEg Y29udGV4dCB3aXRoIGlycXMgZW5hYmxlZC4KKyAgID09PSAgPT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09CiAKIFVudXNlZCBtdXRleGVzIGNhbm5vdCBi ZSBwYXJ0IG9mIHRoZSBjYXVzZSBvZiBhbiBlcnJvci4KIApAQCAtNjcsNyArNzAsNyBAQCBTaW5n bGUtbG9jayBzdGF0ZSBydWxlczoKIAogQSBzb2Z0aXJxLXVuc2FmZSBsb2NrLWNsYXNzIGlzIGF1 dG9tYXRpY2FsbHkgaGFyZGlycS11bnNhZmUgYXMgd2VsbC4gVGhlCiBmb2xsb3dpbmcgc3RhdGVz IGFyZSBleGNsdXNpdmUsIGFuZCBvbmx5IG9uZSBvZiB0aGVtIGlzIGFsbG93ZWQgdG8gYmUKLXNl dCBmb3IgYW55IGxvY2stY2xhc3M6CitzZXQgZm9yIGFueSBsb2NrLWNsYXNzOjoKIAogIDxoYXJk aXJxLXNhZmU+IGFuZCA8aGFyZGlycS11bnNhZmU+CiAgPHNvZnRpcnEtc2FmZT4gYW5kIDxzb2Z0 aXJxLXVuc2FmZT4KQEAgLTgxLDcgKzg0LDcgQEAgTXVsdGktbG9jayBkZXBlbmRlbmN5IHJ1bGVz OgogVGhlIHNhbWUgbG9jay1jbGFzcyBtdXN0IG5vdCBiZSBhY3F1aXJlZCB0d2ljZSwgYmVjYXVz ZSB0aGlzIGNvdWxkIGxlYWQKIHRvIGxvY2sgcmVjdXJzaW9uIGRlYWRsb2Nrcy4KIAotRnVydGhl cm1vcmUsIHR3byBsb2NrcyBtYXkgbm90IGJlIHRha2VuIGluIGRpZmZlcmVudCBvcmRlcjoKK0Z1 cnRoZXJtb3JlLCB0d28gbG9ja3MgbWF5IG5vdCBiZSB0YWtlbiBpbiBkaWZmZXJlbnQgb3JkZXI6 OgogCiAgPEwxPiAtPiA8TDI+CiAgPEwyPiAtPiA8TDE+CkBAIC05Miw3ICs5NSw3IEBAIG90aGVy IGxvY2tpbmcgc2VxdWVuY2UgYmV0d2VlbiB0aGUgYWNxdWlyZS1sb2NrIG9wZXJhdGlvbnMsIHRo ZQogdmFsaWRhdG9yIHdpbGwgc3RpbGwgdHJhY2sgYWxsIGRlcGVuZGVuY2llcyBiZXR3ZWVuIGxv Y2tzLikKIAogRnVydGhlcm1vcmUsIHRoZSBmb2xsb3dpbmcgdXNhZ2UgYmFzZWQgbG9jayBkZXBl bmRlbmNpZXMgYXJlIG5vdCBhbGxvd2VkCi1iZXR3ZWVuIGFueSB0d28gbG9jay1jbGFzc2VzOgor YmV0d2VlbiBhbnkgdHdvIGxvY2stY2xhc3Nlczo6CiAKICAgIDxoYXJkaXJxLXNhZmU+ICAgLT4g IDxoYXJkaXJxLXVuc2FmZT4KICAgIDxzb2Z0aXJxLXNhZmU+ICAgLT4gIDxzb2Z0aXJxLXVuc2Fm ZT4KQEAgLTE0OCwxNiArMTUxLDE2IEBAIHRoZSBvcmRlcmluZyBpcyBub3Qgc3RhdGljLgogSW4g b3JkZXIgdG8gdGVhY2ggdGhlIHZhbGlkYXRvciBhYm91dCB0aGlzIGNvcnJlY3QgdXNhZ2UgbW9k ZWwsIG5ldwogdmVyc2lvbnMgb2YgdGhlIHZhcmlvdXMgbG9ja2luZyBwcmltaXRpdmVzIHdlcmUg YWRkZWQgdGhhdCBhbGxvdyB5b3UgdG8KIHNwZWNpZnkgYSAibmVzdGluZyBsZXZlbCIuIEFuIGV4 YW1wbGUgY2FsbCwgZm9yIHRoZSBibG9jayBkZXZpY2UgbXV0ZXgsCi1sb29rcyBsaWtlIHRoaXM6 Citsb29rcyBsaWtlIHRoaXM6OgogCi1lbnVtIGJkZXZfYmRfbXV0ZXhfbG9ja19jbGFzcwotewor ICBlbnVtIGJkZXZfYmRfbXV0ZXhfbG9ja19jbGFzcworICB7CiAgICAgICAgQkRfTVVURVhfTk9S TUFMLAogICAgICAgIEJEX01VVEVYX1dIT0xFLAogICAgICAgIEJEX01VVEVYX1BBUlRJVElPTgot fTsKKyAgfTsKIAotIG11dGV4X2xvY2tfbmVzdGVkKCZiZGV2LT5iZF9jb250YWlucy0+YmRfbXV0 ZXgsIEJEX01VVEVYX1BBUlRJVElPTik7CittdXRleF9sb2NrX25lc3RlZCgmYmRldi0+YmRfY29u dGFpbnMtPmJkX211dGV4LCBCRF9NVVRFWF9QQVJUSVRJT04pOwogCiBJbiB0aGlzIGNhc2UgdGhl IGxvY2tpbmcgaXMgZG9uZSBvbiBhIGJkZXYgb2JqZWN0IHRoYXQgaXMga25vd24gdG8gYmUgYQog cGFydGl0aW9uLgpAQCAtMTc4LDcgKzE4MSw3IEBAIG11c3QgYmUgaGVsZDogbG9ja2RlcF9hc3Nl cnRfaGVsZCooJmxvY2spIGFuZCBsb2NrZGVwXypwaW5fbG9jaygmbG9jaykuCiBBcyB0aGUgbmFt ZSBzdWdnZXN0cywgbG9ja2RlcF9hc3NlcnRfaGVsZCogZmFtaWx5IG9mIG1hY3JvcyBhc3NlcnQg dGhhdCBhCiBwYXJ0aWN1bGFyIGxvY2sgaXMgaGVsZCBhdCBhIGNlcnRhaW4gdGltZSAoYW5kIGdl bmVyYXRlIGEgV0FSTigpIG90aGVyd2lzZSkuCiBUaGlzIGFubm90YXRpb24gaXMgbGFyZ2VseSB1 c2VkIGFsbCBvdmVyIHRoZSBrZXJuZWwsIGUuZy4ga2VybmVsL3NjaGVkLwotY29yZS5jCitjb3Jl LmM6OgogCiAgIHZvaWQgdXBkYXRlX3JxX2Nsb2NrKHN0cnVjdCBycSAqcnEpCiAgIHsKQEAgLTE5 Nyw3ICsyMDAsNyBAQCBvdXQgdG8gYmUgZXNwZWNpYWxseSBoZWxwZnVsIHRvIGRlYnVnIGNvZGUg d2l0aCBjYWxsYmFja3MsIHdoZXJlIGFuIHVwcGVyCiBsYXllciBhc3N1bWVzIGEgbG9jayByZW1h aW5zIHRha2VuLCBidXQgYSBsb3dlciBsYXllciB0aGlua3MgaXQgY2FuIG1heWJlIGRyb3AKIGFu ZCByZWFjcXVpcmUgdGhlIGxvY2sgKCJ1bndpdHRpbmdseSIgaW50cm9kdWNpbmcgcmFjZXMpLiBs b2NrZGVwX3Bpbl9sb2NrKCkKIHJldHVybnMgYSAnc3RydWN0IHBpbl9jb29raWUnIHRoYXQgaXMg dGhlbiB1c2VkIGJ5IGxvY2tkZXBfdW5waW5fbG9jaygpIHRvIGNoZWNrCi10aGF0IG5vYm9keSB0 YW1wZXJlZCB3aXRoIHRoZSBsb2NrLCBlLmcuIGtlcm5lbC9zY2hlZC9zY2hlZC5oCit0aGF0IG5v Ym9keSB0YW1wZXJlZCB3aXRoIHRoZSBsb2NrLCBlLmcuIGtlcm5lbC9zY2hlZC9zY2hlZC5oOjoK IAogICBzdGF0aWMgaW5saW5lIHZvaWQgcnFfcGluX2xvY2soc3RydWN0IHJxICpycSwgc3RydWN0 IHJxX2ZsYWdzICpyZikKICAgewpAQCAtMjI0LDcgKzIyNyw3IEBAIGNvcnJlY3RuZXNzKSBpbiB0 aGUgc2Vuc2UgdGhhdCBmb3IgZXZlcnkgc2ltcGxlLCBzdGFuZGFsb25lIHNpbmdsZS10YXNrCiBs b2NraW5nIHNlcXVlbmNlIHRoYXQgb2NjdXJyZWQgYXQgbGVhc3Qgb25jZSBkdXJpbmcgdGhlIGxp ZmV0aW1lIG9mIHRoZQoga2VybmVsLCB0aGUgdmFsaWRhdG9yIHByb3ZlcyBpdCB3aXRoIGEgMTAw JSBjZXJ0YWludHkgdGhhdCBubwogY29tYmluYXRpb24gYW5kIHRpbWluZyBvZiB0aGVzZSBsb2Nr aW5nIHNlcXVlbmNlcyBjYW4gY2F1c2UgYW55IGNsYXNzIG9mCi1sb2NrIHJlbGF0ZWQgZGVhZGxv Y2suIFsqXQorbG9jayByZWxhdGVkIGRlYWRsb2NrLiBbMV1fCiAKIEkuZS4gY29tcGxleCBtdWx0 aS1DUFUgYW5kIG11bHRpLXRhc2sgbG9ja2luZyBzY2VuYXJpb3MgZG8gbm90IGhhdmUgdG8KIG9j Y3VyIGluIHByYWN0aWNlIHRvIHByb3ZlIGEgZGVhZGxvY2s6IG9ubHkgdGhlIHNpbXBsZSAnY29t cG9uZW50JwpAQCAtMjQzLDcgKzI0Niw5IEBAIHBvc3NpYmxlIGNvbWJpbmF0aW9uIG9mIGxvY2tp bmcgaW50ZXJhY3Rpb24gYmV0d2VlbiBDUFVzLCBjb21iaW5lZCB3aXRoCiBldmVyeSBwb3NzaWJs ZSBoYXJkaXJxIGFuZCBzb2Z0aXJxIG5lc3Rpbmcgc2NlbmFyaW8gKHdoaWNoIGlzIGltcG9zc2li bGUKIHRvIGRvIGluIHByYWN0aWNlKS4KIAotWypdIGFzc3VtaW5nIHRoYXQgdGhlIHZhbGlkYXRv ciBpdHNlbGYgaXMgMTAwJSBjb3JyZWN0LCBhbmQgbm8gb3RoZXIKKy4uIFsxXQorCisgICAgYXNz dW1pbmcgdGhhdCB0aGUgdmFsaWRhdG9yIGl0c2VsZiBpcyAxMDAlIGNvcnJlY3QsIGFuZCBubyBv dGhlcgogICAgIHBhcnQgb2YgdGhlIHN5c3RlbSBjb3JydXB0cyB0aGUgc3RhdGUgb2YgdGhlIHZh bGlkYXRvciBpbiBhbnkgd2F5LgogICAgIFdlIGFsc28gYXNzdW1lIHRoYXQgYWxsIE5NSS9TTU0g cGF0aHMgW3doaWNoIGNvdWxkIGludGVycnVwdAogICAgIGV2ZW4gaGFyZGlycS1kaXNhYmxlZCBj b2RlcGF0aHNdIGFyZSBjb3JyZWN0IGFuZCBkbyBub3QgaW50ZXJmZXJlCkBAIC0yNTQsNyArMjU5 LDcgQEAgdG8gZG8gaW4gcHJhY3RpY2UpLgogUGVyZm9ybWFuY2U6CiAtLS0tLS0tLS0tLS0KIAot VGhlIGFib3ZlIHJ1bGVzIHJlcXVpcmUgX21hc3NpdmVfIGFtb3VudHMgb2YgcnVudGltZSBjaGVj a2luZy4gSWYgd2UgZGlkCitUaGUgYWJvdmUgcnVsZXMgcmVxdWlyZSAqKm1hc3NpdmUqKiBhbW91 bnRzIG9mIHJ1bnRpbWUgY2hlY2tpbmcuIElmIHdlIGRpZAogdGhhdCBmb3IgZXZlcnkgbG9jayB0 YWtlbiBhbmQgZm9yIGV2ZXJ5IGlycXMtZW5hYmxlIGV2ZW50LCBpdCB3b3VsZAogcmVuZGVyIHRo ZSBzeXN0ZW0gcHJhY3RpY2FsbHkgdW51c2FibHkgc2xvdy4gVGhlIGNvbXBsZXhpdHkgb2YgY2hl Y2tpbmcKIGlzIE8oTl4yKSwgc28gZXZlbiB3aXRoIGp1c3QgYSBmZXcgaHVuZHJlZCBsb2NrLWNs YXNzZXMgd2UnZCBoYXZlIHRvIGRvCkBAIC0zMTMsMTcgKzMxOCwxNyBAQCBiZSBoYXJkZXIgdG8g ZG8gdGhhbiB0byBzYXkuCiAKIE9mIGNvdXJzZSwgaWYgeW91IGRvIHJ1biBvdXQgb2YgbG9jayBj bGFzc2VzLCB0aGUgbmV4dCB0aGluZyB0byBkbyBpcwogdG8gZmluZCB0aGUgb2ZmZW5kaW5nIGxv Y2sgY2xhc3Nlcy4gIEZpcnN0LCB0aGUgZm9sbG93aW5nIGNvbW1hbmQgZ2l2ZXMKLXlvdSB0aGUg bnVtYmVyIG9mIGxvY2sgY2xhc3NlcyBjdXJyZW50bHkgaW4gdXNlIGFsb25nIHdpdGggdGhlIG1h eGltdW06Cit5b3UgdGhlIG51bWJlciBvZiBsb2NrIGNsYXNzZXMgY3VycmVudGx5IGluIHVzZSBh bG9uZyB3aXRoIHRoZSBtYXhpbXVtOjoKIAogCWdyZXAgImxvY2stY2xhc3NlcyIgL3Byb2MvbG9j a2RlcF9zdGF0cwogCi1UaGlzIGNvbW1hbmQgcHJvZHVjZXMgdGhlIGZvbGxvd2luZyBvdXRwdXQg b24gYSBtb2Rlc3Qgc3lzdGVtOgorVGhpcyBjb21tYW5kIHByb2R1Y2VzIHRoZSBmb2xsb3dpbmcg b3V0cHV0IG9uIGEgbW9kZXN0IHN5c3RlbTo6CiAKLQkgbG9jay1jbGFzc2VzOiAgICAgICAgICAg ICAgICAgICAgICAgICAgNzQ4IFttYXg6IDgxOTFdCisJbG9jay1jbGFzc2VzOiAgICAgICAgICAg ICAgICAgICAgICAgICAgNzQ4IFttYXg6IDgxOTFdCiAKIElmIHRoZSBudW1iZXIgYWxsb2NhdGVk ICg3NDggYWJvdmUpIGluY3JlYXNlcyBjb250aW51YWxseSBvdmVyIHRpbWUsCiB0aGVuIHRoZXJl IGlzIGxpa2VseSBhIGxlYWsuICBUaGUgZm9sbG93aW5nIGNvbW1hbmQgY2FuIGJlIHVzZWQgdG8K LWlkZW50aWZ5IHRoZSBsZWFraW5nIGxvY2sgY2xhc3NlczoKK2lkZW50aWZ5IHRoZSBsZWFraW5n IGxvY2sgY2xhc3Nlczo6CiAKIAlncmVwICJCRCIgL3Byb2MvbG9ja2RlcAogCmRpZmYgLS1naXQg YS9Eb2N1bWVudGF0aW9uL2xvY2tpbmcvbG9ja3N0YXQucnN0IGIvRG9jdW1lbnRhdGlvbi9sb2Nr aW5nL2xvY2tzdGF0LnJzdApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAwMDAu LjUzNmVhYjhkYmQ5OQotLS0gL2Rldi9udWxsCisrKyBiL0RvY3VtZW50YXRpb24vbG9ja2luZy9s b2Nrc3RhdC5yc3QKQEAgLTAsMCArMSwyMDQgQEAKKz09PT09PT09PT09PT09PQorTG9jayBTdGF0 aXN0aWNzCis9PT09PT09PT09PT09PT0KKworV2hhdAorPT09PQorCitBcyB0aGUgbmFtZSBzdWdn ZXN0cywgaXQgcHJvdmlkZXMgc3RhdGlzdGljcyBvbiBsb2Nrcy4KKworCitXaHkKKz09PQorCitC ZWNhdXNlIHRoaW5ncyBsaWtlIGxvY2sgY29udGVudGlvbiBjYW4gc2V2ZXJlbHkgaW1wYWN0IHBl cmZvcm1hbmNlLgorCitIb3cKKz09PQorCitMb2NrZGVwIGFscmVhZHkgaGFzIGhvb2tzIGluIHRo ZSBsb2NrIGZ1bmN0aW9ucyBhbmQgbWFwcyBsb2NrIGluc3RhbmNlcyB0bworbG9jayBjbGFzc2Vz LiBXZSBidWlsZCBvbiB0aGF0IChzZWUgRG9jdW1lbnRhdGlvbi9sb2NraW5nL2xvY2tkZXAtZGVz aWduLnJzdCkuCitUaGUgZ3JhcGggYmVsb3cgc2hvd3MgdGhlIHJlbGF0aW9uIGJldHdlZW4gdGhl IGxvY2sgZnVuY3Rpb25zIGFuZCB0aGUgdmFyaW91cworaG9va3MgdGhlcmVpbjo6CisKKyAgICAg ICAgX19hY3F1aXJlCisgICAgICAgICAgICB8CisgICAgICAgICAgIGxvY2sgX19fX18KKyAgICAg ICAgICAgIHwgICAgICAgIFwKKyAgICAgICAgICAgIHwgICAgX19jb250ZW5kZWQKKyAgICAgICAg ICAgIHwgICAgICAgICB8CisgICAgICAgICAgICB8ICAgICAgIDx3YWl0PgorICAgICAgICAgICAg fCBfX19fX19fLworICAgICAgICAgICAgfC8KKyAgICAgICAgICAgIHwKKyAgICAgICBfX2FjcXVp cmVkCisgICAgICAgICAgICB8CisgICAgICAgICAgICAuCisgICAgICAgICAgPGhvbGQ+CisgICAg ICAgICAgICAuCisgICAgICAgICAgICB8CisgICAgICAgX19yZWxlYXNlCisgICAgICAgICAgICB8 CisgICAgICAgICB1bmxvY2sKKworICBsb2NrLCB1bmxvY2sJLSB0aGUgcmVndWxhciBsb2NrIGZ1 bmN0aW9ucworICBfXyoJCS0gdGhlIGhvb2tzCisgIDw+IAkJLSBzdGF0ZXMKKworV2l0aCB0aGVz ZSBob29rcyB3ZSBwcm92aWRlIHRoZSBmb2xsb3dpbmcgc3RhdGlzdGljczoKKworIGNvbi1ib3Vu Y2VzCisJLSBudW1iZXIgb2YgbG9jayBjb250ZW50aW9uIHRoYXQgaW52b2x2ZWQgeC1jcHUgZGF0 YQorIGNvbnRlbnRpb25zCisJLSBudW1iZXIgb2YgbG9jayBhY3F1aXNpdGlvbnMgdGhhdCBoYWQg dG8gd2FpdAorIHdhaXQgdGltZQorICAgICBtaW4KKwktIHNob3J0ZXN0IChub24tMCkgdGltZSB3 ZSBldmVyIGhhZCB0byB3YWl0IGZvciBhIGxvY2sKKyAgICAgbWF4CisJLSBsb25nZXN0IHRpbWUg d2UgZXZlciBoYWQgdG8gd2FpdCBmb3IgYSBsb2NrCisgICAgIHRvdGFsCisJLSB0b3RhbCB0aW1l IHdlIHNwZW5kIHdhaXRpbmcgb24gdGhpcyBsb2NrCisgICAgIGF2ZworCS0gYXZlcmFnZSB0aW1l IHNwZW50IHdhaXRpbmcgb24gdGhpcyBsb2NrCisgYWNxLWJvdW5jZXMKKwktIG51bWJlciBvZiBs b2NrIGFjcXVpc2l0aW9ucyB0aGF0IGludm9sdmVkIHgtY3B1IGRhdGEKKyBhY3F1aXNpdGlvbnMK KwktIG51bWJlciBvZiB0aW1lcyB3ZSB0b29rIHRoZSBsb2NrCisgaG9sZCB0aW1lCisgICAgIG1p bgorCS0gc2hvcnRlc3QgKG5vbi0wKSB0aW1lIHdlIGV2ZXIgaGVsZCB0aGUgbG9jaworICAgICBt YXgKKwktIGxvbmdlc3QgdGltZSB3ZSBldmVyIGhlbGQgdGhlIGxvY2sKKyAgICAgdG90YWwKKwkt IHRvdGFsIHRpbWUgdGhpcyBsb2NrIHdhcyBoZWxkCisgICAgIGF2ZworCS0gYXZlcmFnZSB0aW1l IHRoaXMgbG9jayB3YXMgaGVsZAorCitUaGVzZSBudW1iZXJzIGFyZSBnYXRoZXJlZCBwZXIgbG9j ayBjbGFzcywgcGVyIHJlYWQvd3JpdGUgc3RhdGUgKHdoZW4KK2FwcGxpY2FibGUpLgorCitJdCBh bHNvIHRyYWNrcyA0IGNvbnRlbnRpb24gcG9pbnRzIHBlciBjbGFzcy4gQSBjb250ZW50aW9uIHBv aW50IGlzIGEgY2FsbCBzaXRlCit0aGF0IGhhZCB0byB3YWl0IG9uIGxvY2sgYWNxdWlzaXRpb24u CisKK0NvbmZpZ3VyYXRpb24KKy0tLS0tLS0tLS0tLS0KKworTG9jayBzdGF0aXN0aWNzIGFyZSBl bmFibGVkIHZpYSBDT05GSUdfTE9DS19TVEFULgorCitVc2FnZQorLS0tLS0KKworRW5hYmxlIGNv bGxlY3Rpb24gb2Ygc3RhdGlzdGljczo6CisKKwkjIGVjaG8gMSA+L3Byb2Mvc3lzL2tlcm5lbC9s b2NrX3N0YXQKKworRGlzYWJsZSBjb2xsZWN0aW9uIG9mIHN0YXRpc3RpY3M6OgorCisJIyBlY2hv IDAgPi9wcm9jL3N5cy9rZXJuZWwvbG9ja19zdGF0CisKK0xvb2sgYXQgdGhlIGN1cnJlbnQgbG9j ayBzdGF0aXN0aWNzOjoKKworICAoIGxpbmUgbnVtYmVycyBub3QgcGFydCBvZiBhY3R1YWwgb3V0 cHV0LCBkb25lIGZvciBjbGFyaXR5IGluIHRoZSBleHBsYW5hdGlvbgorICAgIGJlbG93ICkKKwor ICAjIGxlc3MgL3Byb2MvbG9ja19zdGF0CisKKyAgMDEgbG9ja19zdGF0IHZlcnNpb24gMC40Cisg IDAyLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0KKyAg MDMgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBjbGFzcyBuYW1lICAgIGNvbi1ib3VuY2Vz ICAgIGNvbnRlbnRpb25zICAgd2FpdHRpbWUtbWluICAgd2FpdHRpbWUtbWF4IHdhaXR0aW1lLXRv dGFsICAgd2FpdHRpbWUtYXZnICAgIGFjcS1ib3VuY2VzICAgYWNxdWlzaXRpb25zICAgaG9sZHRp bWUtbWluICAgaG9sZHRpbWUtbWF4IGhvbGR0aW1lLXRvdGFsICAgaG9sZHRpbWUtYXZnCisgIDA0 LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0KKyAgMDUK KyAgMDYgICAgICAgICAgICAgICAgICAgICAgICAgJm1tLT5tbWFwX3NlbS1XOiAgICAgICAgICAg IDQ2ICAgICAgICAgICAgIDg0ICAgICAgICAgICAwLjI2ICAgICAgICAgOTM5LjEwICAgICAgIDE2 MzcxLjUzICAgICAgICAgMTk0LjkwICAgICAgICAgIDQ3MjkxICAgICAgICAyOTIyMzY1ICAgICAg ICAgICAwLjE2ICAgICAyMjIwMzAxLjY5IDE3NDY0MDI2OTE2LjMyICAgICAgICA1OTc1Ljk5Cisg IDA3ICAgICAgICAgICAgICAgICAgICAgICAgICZtbS0+bW1hcF9zZW0tUjogICAgICAgICAgICAz NyAgICAgICAgICAgIDEwMCAgICAgICAgICAgMS4zMSAgICAgIDI5OTUwMi42MSAgICAgIDMyNTYy OS41MiAgICAgICAgMzI1Ni4zMCAgICAgICAgIDIxMjM0NCAgICAgICAzNDMxNjY4NSAgICAgICAg ICAgMC4xMCAgICAgICAgNzc0NC45MSAgICA5NTAxNjkxMC4yMCAgICAgICAgICAgMi43NworICAw OCAgICAgICAgICAgICAgICAgICAgICAgICAtLS0tLS0tLS0tLS0tLS0KKyAgMDkgICAgICAgICAg ICAgICAgICAgICAgICAgICAmbW0tPm1tYXBfc2VtICAgICAgICAgICAgICAxICAgICAgICAgIFs8 ZmZmZmZmZmY4MTE1MDJhNz5dIGtodWdlcGFnZWRfc2Nhbl9tbV9zbG90KzB4NTcvMHgyODAKKyAg MTAgICAgICAgICAgICAgICAgICAgICAgICAgICAmbW0tPm1tYXBfc2VtICAgICAgICAgICAgIDk2 ICAgICAgICAgIFs8ZmZmZmZmZmY4MTUzNTFjND5dIF9fZG9fcGFnZV9mYXVsdCsweDFkNC8weDUx MAorICAxMSAgICAgICAgICAgICAgICAgICAgICAgICAgICZtbS0+bW1hcF9zZW0gICAgICAgICAg ICAgMzQgICAgICAgICAgWzxmZmZmZmZmZjgxMTEzZDc3Pl0gdm1fbW1hcF9wZ29mZisweDg3LzB4 ZDAKKyAgMTIgICAgICAgICAgICAgICAgICAgICAgICAgICAmbW0tPm1tYXBfc2VtICAgICAgICAg ICAgIDE3ICAgICAgICAgIFs8ZmZmZmZmZmY4MTEyN2U3MT5dIHZtX211bm1hcCsweDQxLzB4ODAK KyAgMTMgICAgICAgICAgICAgICAgICAgICAgICAgLS0tLS0tLS0tLS0tLS0tCisgIDE0ICAgICAg ICAgICAgICAgICAgICAgICAgICAgJm1tLT5tbWFwX3NlbSAgICAgICAgICAgICAgMSAgICAgICAg ICBbPGZmZmZmZmZmODEwNDZmZGE+XSBkdXBfbW1hcCsweDJhLzB4M2YwCisgIDE1ICAgICAgICAg ICAgICAgICAgICAgICAgICAgJm1tLT5tbWFwX3NlbSAgICAgICAgICAgICA2MCAgICAgICAgICBb PGZmZmZmZmZmODExMjllMjk+XSBTeVNfbXByb3RlY3QrMHhlOS8weDI1MAorICAxNiAgICAgICAg ICAgICAgICAgICAgICAgICAgICZtbS0+bW1hcF9zZW0gICAgICAgICAgICAgNDEgICAgICAgICAg WzxmZmZmZmZmZjgxNTM1MWM0Pl0gX19kb19wYWdlX2ZhdWx0KzB4MWQ0LzB4NTEwCisgIDE3ICAg ICAgICAgICAgICAgICAgICAgICAgICAgJm1tLT5tbWFwX3NlbSAgICAgICAgICAgICA2OCAgICAg ICAgICBbPGZmZmZmZmZmODExMTNkNzc+XSB2bV9tbWFwX3Bnb2ZmKzB4ODcvMHhkMAorICAxOAor ICAxOS4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4u Li4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4u Li4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4u Li4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uCisg IDIwCisgIDIxICAgICAgICAgICAgICAgICAgICAgICAgIHVuaXhfdGFibGVfbG9jazogICAgICAg ICAgIDExMCAgICAgICAgICAgIDExMiAgICAgICAgICAgMC4yMSAgICAgICAgICA0OS4yNCAgICAg ICAgIDE2My45MSAgICAgICAgICAgMS40NiAgICAgICAgICAyMTA5NCAgICAgICAgICA2NjMxMiAg ICAgICAgICAgMC4xMiAgICAgICAgIDYyNC40MiAgICAgICAzMTU4OS44MSAgICAgICAgICAgMC40 OAorICAyMiAgICAgICAgICAgICAgICAgICAgICAgICAtLS0tLS0tLS0tLS0tLS0KKyAgMjMgICAg ICAgICAgICAgICAgICAgICAgICAgdW5peF90YWJsZV9sb2NrICAgICAgICAgICAgIDQ1ICAgICAg ICAgIFs8ZmZmZmZmZmY4MTUwYWQ4ZT5dIHVuaXhfY3JlYXRlMSsweDE2ZS8weDFiMAorICAyNCAg ICAgICAgICAgICAgICAgICAgICAgICB1bml4X3RhYmxlX2xvY2sgICAgICAgICAgICAgNDcgICAg ICAgICAgWzxmZmZmZmZmZjgxNTBiMTExPl0gdW5peF9yZWxlYXNlX3NvY2srMHgzMS8weDI1MAor ICAyNSAgICAgICAgICAgICAgICAgICAgICAgICB1bml4X3RhYmxlX2xvY2sgICAgICAgICAgICAg MTUgICAgICAgICAgWzxmZmZmZmZmZjgxNTBjYTM3Pl0gdW5peF9maW5kX290aGVyKzB4MTE3LzB4 MjMwCisgIDI2ICAgICAgICAgICAgICAgICAgICAgICAgIHVuaXhfdGFibGVfbG9jayAgICAgICAg ICAgICAgNSAgICAgICAgICBbPGZmZmZmZmZmODE1MGEwOWY+XSB1bml4X2F1dG9iaW5kKzB4MTFm LzB4MWIwCisgIDI3ICAgICAgICAgICAgICAgICAgICAgICAgIC0tLS0tLS0tLS0tLS0tLQorICAy OCAgICAgICAgICAgICAgICAgICAgICAgICB1bml4X3RhYmxlX2xvY2sgICAgICAgICAgICAgMzkg ICAgICAgICAgWzxmZmZmZmZmZjgxNTBiMTExPl0gdW5peF9yZWxlYXNlX3NvY2srMHgzMS8weDI1 MAorICAyOSAgICAgICAgICAgICAgICAgICAgICAgICB1bml4X3RhYmxlX2xvY2sgICAgICAgICAg ICAgNDkgICAgICAgICAgWzxmZmZmZmZmZjgxNTBhZDhlPl0gdW5peF9jcmVhdGUxKzB4MTZlLzB4 MWIwCisgIDMwICAgICAgICAgICAgICAgICAgICAgICAgIHVuaXhfdGFibGVfbG9jayAgICAgICAg ICAgICAyMCAgICAgICAgICBbPGZmZmZmZmZmODE1MGNhMzc+XSB1bml4X2ZpbmRfb3RoZXIrMHgx MTcvMHgyMzAKKyAgMzEgICAgICAgICAgICAgICAgICAgICAgICAgdW5peF90YWJsZV9sb2NrICAg ICAgICAgICAgICA0ICAgICAgICAgIFs8ZmZmZmZmZmY4MTUwYTA5Zj5dIHVuaXhfYXV0b2JpbmQr MHgxMWYvMHgxYjAKKworCitUaGlzIGV4Y2VycHQgc2hvd3MgdGhlIGZpcnN0IHR3byBsb2NrIGNs YXNzIHN0YXRpc3RpY3MuIExpbmUgMDEgc2hvd3MgdGhlCitvdXRwdXQgdmVyc2lvbiAtIGVhY2gg dGltZSB0aGUgZm9ybWF0IGNoYW5nZXMgdGhpcyB3aWxsIGJlIHVwZGF0ZWQuIExpbmUgMDItMDQK K3Nob3cgdGhlIGhlYWRlciB3aXRoIGNvbHVtbiBkZXNjcmlwdGlvbnMuIExpbmVzIDA1LTE4IGFu ZCAyMC0zMSBzaG93IHRoZSBhY3R1YWwKK3N0YXRpc3RpY3MuIFRoZXNlIHN0YXRpc3RpY3MgY29t ZSBpbiB0d28gcGFydHM7IHRoZSBhY3R1YWwgc3RhdHMgc2VwYXJhdGVkIGJ5IGEKK3Nob3J0IHNl cGFyYXRvciAobGluZSAwOCwgMTMpIGZyb20gdGhlIGNvbnRlbnRpb24gcG9pbnRzLgorCitMaW5l cyAwOS0xMiBzaG93IHRoZSBmaXJzdCA0IHJlY29yZGVkIGNvbnRlbnRpb24gcG9pbnRzICh0aGUg Y29kZQord2hpY2ggdHJpZXMgdG8gZ2V0IHRoZSBsb2NrKSBhbmQgbGluZXMgMTQtMTcgc2hvdyB0 aGUgZmlyc3QgNCByZWNvcmRlZAorY29udGVuZGVkIHBvaW50cyAodGhlIGxvY2sgaG9sZGVyKS4g SXQgaXMgcG9zc2libGUgdGhhdCB0aGUgbWF4Citjb24tYm91bmNlcyBwb2ludCBpcyBtaXNzaW5n IGluIHRoZSBzdGF0aXN0aWNzLgorCitUaGUgZmlyc3QgbG9jayAoMDUtMTgpIGlzIGEgcmVhZC93 cml0ZSBsb2NrLCBhbmQgc2hvd3MgdHdvIGxpbmVzIGFib3ZlIHRoZQorc2hvcnQgc2VwYXJhdG9y LiBUaGUgY29udGVudGlvbiBwb2ludHMgZG9uJ3QgbWF0Y2ggdGhlIGNvbHVtbiBkZXNjcmlwdG9y cywKK3RoZXkgaGF2ZSB0d286IGNvbnRlbnRpb25zIGFuZCBbPElQPl0gc3ltYm9sLiBUaGUgc2Vj b25kIHNldCBvZiBjb250ZW50aW9uCitwb2ludHMgYXJlIHRoZSBwb2ludHMgd2UncmUgY29udGVu ZGluZyB3aXRoLgorCitUaGUgaW50ZWdlciBwYXJ0IG9mIHRoZSB0aW1lIHZhbHVlcyBpcyBpbiB1 cy4KKworRGVhbGluZyB3aXRoIG5lc3RlZCBsb2Nrcywgc3ViY2xhc3NlcyBtYXkgYXBwZWFyOjoK KworICAzMi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4u Li4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4u Li4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4u Li4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLgor ICAzMworICAzNCAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAmcnEtPmxvY2s6ICAgICAg IDEzMTI4ICAgICAgICAgIDEzMTI4ICAgICAgICAgICAwLjQzICAgICAgICAgMTkwLjUzICAgICAg MTAzODgxLjI2ICAgICAgICAgICA3LjkxICAgICAgICAgIDk3NDU0ICAgICAgICAzNDUzNDA0ICAg ICAgICAgICAwLjAwICAgICAgICAgNDAxLjExICAgIDEzMjI0NjgzLjExICAgICAgICAgICAzLjgy CisgIDM1ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIC0tLS0tLS0tLQorICAzNiAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAmcnEtPmxvY2sgICAgICAgICAgNjQ1ICAgICAgICAg IFs8ZmZmZmZmZmY4MTAzYmZjND5dIHRhc2tfcnFfbG9jaysweDQzLzB4NzUKKyAgMzcgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgJnJxLT5sb2NrICAgICAgICAgIDI5NyAgICAgICAgICBb PGZmZmZmZmZmODEwNGJhNjU+XSB0cnlfdG9fd2FrZV91cCsweDEyNy8weDI1YQorICAzOCAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAmcnEtPmxvY2sgICAgICAgICAgMzYwICAgICAgICAg IFs8ZmZmZmZmZmY4MTAzYzRjNT5dIHNlbGVjdF90YXNrX3JxX2ZhaXIrMHgxZjAvMHg3NGEKKyAg MzkgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgJnJxLT5sb2NrICAgICAgICAgIDQyOCAg ICAgICAgICBbPGZmZmZmZmZmODEwNDVmOTg+XSBzY2hlZHVsZXJfdGljaysweDQ2LzB4MWZiCisg IDQwICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIC0tLS0tLS0tLQorICA0MSAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAmcnEtPmxvY2sgICAgICAgICAgIDc3ICAgICAgICAgIFs8 ZmZmZmZmZmY4MTAzYmZjND5dIHRhc2tfcnFfbG9jaysweDQzLzB4NzUKKyAgNDIgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgJnJxLT5sb2NrICAgICAgICAgIDE3NCAgICAgICAgICBbPGZm ZmZmZmZmODEwNGJhNjU+XSB0cnlfdG9fd2FrZV91cCsweDEyNy8weDI1YQorICA0MyAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAmcnEtPmxvY2sgICAgICAgICA0NzE1ICAgICAgICAgIFs8 ZmZmZmZmZmY4MTAzZWQ0Yj5dIGRvdWJsZV9ycV9sb2NrKzB4NDIvMHg1NAorICA0NCAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAmcnEtPmxvY2sgICAgICAgICAgODkzICAgICAgICAgIFs8 ZmZmZmZmZmY4MTM0MDUyND5dIHNjaGVkdWxlKzB4MTU3LzB4N2I4CisgIDQ1CisgIDQ2Li4uLi4u Li4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4u Li4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4u Li4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4u Li4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uCisgIDQ3CisgIDQ4ICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAmcnEtPmxvY2svMTogICAgICAgIDE1MjYgICAgICAg ICAgMTE0ODggICAgICAgICAgIDAuMzMgICAgICAgICAzODguNzMgICAgICAxMzYyOTQuMzEgICAg ICAgICAgMTEuODYgICAgICAgICAgMjE0NjEgICAgICAgICAgMzg0MDQgICAgICAgICAgIDAuMDAg ICAgICAgICAgMzcuOTMgICAgICAxMDkzODguNTMgICAgICAgICAgIDIuODQKKyAgNDkgICAgICAg ICAgICAgICAgICAgICAgICAgICAgIC0tLS0tLS0tLS0tCisgIDUwICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAmcnEtPmxvY2svMSAgICAgICAgMTE1MjYgICAgICAgICAgWzxmZmZmZmZmZjgx MDNlZDU4Pl0gZG91YmxlX3JxX2xvY2srMHg0Zi8weDU0CisgIDUxICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAtLS0tLS0tLS0tLQorICA1MiAgICAgICAgICAgICAgICAgICAgICAgICAgICAg JnJxLT5sb2NrLzEgICAgICAgICA1NjQ1ICAgICAgICAgIFs8ZmZmZmZmZmY4MTAzZWQ0Yj5dIGRv dWJsZV9ycV9sb2NrKzB4NDIvMHg1NAorICA1MyAgICAgICAgICAgICAgICAgICAgICAgICAgICAg JnJxLT5sb2NrLzEgICAgICAgICAxMjI0ICAgICAgICAgIFs8ZmZmZmZmZmY4MTM0MDUyND5dIHNj aGVkdWxlKzB4MTU3LzB4N2I4CisgIDU0ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAmcnEt PmxvY2svMSAgICAgICAgIDQzMzYgICAgICAgICAgWzxmZmZmZmZmZjgxMDNlZDU4Pl0gZG91Ymxl X3JxX2xvY2srMHg0Zi8weDU0CisgIDU1ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAmcnEt PmxvY2svMSAgICAgICAgICAxODEgICAgICAgICAgWzxmZmZmZmZmZjgxMDRiYTY1Pl0gdHJ5X3Rv X3dha2VfdXArMHgxMjcvMHgyNWEKKworTGluZSA0OCBzaG93cyBzdGF0aXN0aWNzIGZvciB0aGUg c2Vjb25kIHN1YmNsYXNzICgvMSkgb2YgJnJxLT5sb2NrIGNsYXNzCisoc3ViY2xhc3Mgc3RhcnRz IGZyb20gMCksIHNpbmNlIGluIHRoaXMgY2FzZSwgYXMgbGluZSA1MCBzdWdnZXN0cywKK2RvdWJs ZV9ycV9sb2NrIGFjdHVhbGx5IGFjcXVpcmVzIGEgbmVzdGVkIGxvY2sgb2YgdHdvIHNwaW5sb2Nr cy4KKworVmlldyB0aGUgdG9wIGNvbnRlbmRpbmcgbG9ja3M6OgorCisgICMgZ3JlcCA6IC9wcm9j L2xvY2tfc3RhdCB8IGhlYWQKKwkJCWNsb2NrZXZlbnRzX2xvY2s6ICAgICAgIDI5MjYxNTkgICAg ICAgIDI5NDc2MzYgICAgICAgICAgIDAuMTUgICAgICAgNDY4ODIuODEgIDE3ODQ1NDA0NjYuMzQg ICAgICAgICA2MDUuNDEgICAgICAgIDMzODEzNDUgICAgICAgIDM4NzkxNjEgICAgICAgICAgIDAu MDAgICAgICAgIDIyNjAuOTcgICAgNTMxNzgzOTUuNjggICAgICAgICAgMTMuNzEKKwkJICAgICB0 aWNrX2Jyb2FkY2FzdF9sb2NrOiAgICAgICAgMzQ2NDYwICAgICAgICAgMzQ2NzE3ICAgICAgICAg ICAwLjE4ICAgICAgICAyMjU3LjQzICAgIDM5MzY0NjIyLjcxICAgICAgICAgMTEzLjU0ICAgICAg ICAzNjQyOTE5ICAgICAgICA0MjQyNjk2ICAgICAgICAgICAwLjAwICAgICAgICAyMjYzLjc5ICAg IDQ5MTczNjQ2LjYwICAgICAgICAgIDExLjU5CisJCSAgJm1hcHBpbmctPmlfbW1hcF9tdXRleDog ICAgICAgIDIwMzg5NiAgICAgICAgIDIwMzg5OSAgICAgICAgICAgMy4zNiAgICAgIDY0NTUzMC4w NSAzMTc2NzUwNzk4OC4zOSAgICAgIDE1NTgwMC4yMSAgICAgICAgMzM2MTc3NiAgICAgICAgODg5 Mzk4NCAgICAgICAgICAgMC4xNyAgICAgICAgMjI1NC4xNSAgICAxNDExMDEyMS4wMiAgICAgICAg ICAgMS41OQorCQkJICAgICAgICZycS0+bG9jazogICAgICAgIDEzNTAxNCAgICAgICAgIDEzNjkw OSAgICAgICAgICAgMC4xOCAgICAgICAgIDYwNi4wOSAgICAgIDg0MjE2MC42OCAgICAgICAgICAg Ni4xNSAgICAgICAgMTU0MDcyOCAgICAgICAxMDQzNjE0NiAgICAgICAgICAgMC4wMCAgICAgICAg IDcyOC43MiAgICAxNzYwNjY4My40MSAgICAgICAgICAgMS42OQorCSAgICAgICAmKCZ6b25lLT5s cnVfbG9jayktPnJsb2NrOiAgICAgICAgIDkzMDAwICAgICAgICAgIDk0OTM0ICAgICAgICAgICAw LjE2ICAgICAgICAgIDU5LjE4ICAgICAgMTg4MjUzLjc4ICAgICAgICAgICAxLjk4ICAgICAgICAx MTk5OTEyICAgICAgICAzODA5ODk0ICAgICAgICAgICAwLjE1ICAgICAgICAgMzkxLjQwICAgICAz NTU5NTE4LjgxICAgICAgICAgICAwLjkzCisJCQkgdGFza2xpc3RfbG9jay1XOiAgICAgICAgIDQw NjY3ICAgICAgICAgIDQxMTMwICAgICAgICAgICAwLjIzICAgICAgICAxMTg5LjQyICAgICAgNDI4 OTgwLjUxICAgICAgICAgIDEwLjQzICAgICAgICAgMjcwMjc4ICAgICAgICAgNTEwMTA2ICAgICAg ICAgICAwLjE2ICAgICAgICAgNjUzLjUxICAgICAzOTM5Njc0LjkxICAgICAgICAgICA3LjcyCisJ CQkgdGFza2xpc3RfbG9jay1SOiAgICAgICAgIDIxMjk4ICAgICAgICAgIDIxMzA1ICAgICAgICAg ICAwLjIwICAgICAgICAxMzEwLjA1ICAgICAgMjE1NTExLjEyICAgICAgICAgIDEwLjEyICAgICAg ICAgMTg2MjA0ICAgICAgICAgMjQxMjU4ICAgICAgICAgICAwLjE0ICAgICAgICAxMTYyLjMzICAg ICAxMTc5Nzc5LjIzICAgICAgICAgICA0Ljg5CisJCQkgICAgICByY3Vfbm9kZV8xOiAgICAgICAg IDQ3NjU2ICAgICAgICAgIDQ5MDIyICAgICAgICAgICAwLjE2ICAgICAgICAgNjM1LjQxICAgICAg MTkzNjE2LjQxICAgICAgICAgICAzLjk1ICAgICAgICAgODQ0ODg4ICAgICAgICAxODY1NDIzICAg ICAgICAgICAwLjAwICAgICAgICAgNzY0LjI2ICAgICAxNjU2MjI2Ljk2ICAgICAgICAgICAwLjg5 CisgICAgICAgJigmZGVudHJ5LT5kX2xvY2tyZWYubG9jayktPnJsb2NrOiAgICAgICAgIDM5Nzkx ICAgICAgICAgIDQwMTc5ICAgICAgICAgICAwLjE1ICAgICAgICAxMzAyLjA4ICAgICAgIDg4ODUx Ljk2ICAgICAgICAgICAyLjIxICAgICAgICAyNzkwODUxICAgICAgIDEyNTI3MDI1ICAgICAgICAg ICAwLjEwICAgICAgICAxOTEwLjc1ICAgICAzMzc5NzE0LjI3ICAgICAgICAgICAwLjI3CisJCQkg ICAgICByY3Vfbm9kZV8wOiAgICAgICAgIDI5MjAzICAgICAgICAgIDMwMDY0ICAgICAgICAgICAw LjE2ICAgICAgICAgNzg2LjU1ICAgICAxNTU1NTczLjAwICAgICAgICAgIDUxLjc0ICAgICAgICAg IDg4OTYzICAgICAgICAgMjQ0MjU0ICAgICAgICAgICAwLjAwICAgICAgICAgMzk4Ljg3ICAgICAg NDI4ODcyLjUxICAgICAgICAgICAxLjc2CisKK0NsZWFyIHRoZSBzdGF0aXN0aWNzOjoKKworICAj IGVjaG8gMCA+IC9wcm9jL2xvY2tfc3RhdApkaWZmIC0tZ2l0IGEvRG9jdW1lbnRhdGlvbi9sb2Nr aW5nL2xvY2tzdGF0LnR4dCBiL0RvY3VtZW50YXRpb24vbG9ja2luZy9sb2Nrc3RhdC50eHQKZGVs ZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IGZkYmViMGM0NWVmMy4uMDAwMDAwMDAwMDAwCi0t LSBhL0RvY3VtZW50YXRpb24vbG9ja2luZy9sb2Nrc3RhdC50eHQKKysrIC9kZXYvbnVsbApAQCAt MSwxODMgKzAsMCBAQAotCi1MT0NLIFNUQVRJU1RJQ1MKLQotLSBXSEFUCi0KLUFzIHRoZSBuYW1l IHN1Z2dlc3RzLCBpdCBwcm92aWRlcyBzdGF0aXN0aWNzIG9uIGxvY2tzLgotCi0tIFdIWQotCi1C ZWNhdXNlIHRoaW5ncyBsaWtlIGxvY2sgY29udGVudGlvbiBjYW4gc2V2ZXJlbHkgaW1wYWN0IHBl cmZvcm1hbmNlLgotCi0tIEhPVwotCi1Mb2NrZGVwIGFscmVhZHkgaGFzIGhvb2tzIGluIHRoZSBs b2NrIGZ1bmN0aW9ucyBhbmQgbWFwcyBsb2NrIGluc3RhbmNlcyB0bwotbG9jayBjbGFzc2VzLiBX ZSBidWlsZCBvbiB0aGF0IChzZWUgRG9jdW1lbnRhdGlvbi9sb2NraW5nL2xvY2tkZXAtZGVzaWdu LnR4dCkuCi1UaGUgZ3JhcGggYmVsb3cgc2hvd3MgdGhlIHJlbGF0aW9uIGJldHdlZW4gdGhlIGxv Y2sgZnVuY3Rpb25zIGFuZCB0aGUgdmFyaW91cwotaG9va3MgdGhlcmVpbi4KLQotICAgICAgICBf X2FjcXVpcmUKLSAgICAgICAgICAgIHwKLSAgICAgICAgICAgbG9jayBfX19fXwotICAgICAgICAg ICAgfCAgICAgICAgXAotICAgICAgICAgICAgfCAgICBfX2NvbnRlbmRlZAotICAgICAgICAgICAg fCAgICAgICAgIHwKLSAgICAgICAgICAgIHwgICAgICAgPHdhaXQ+Ci0gICAgICAgICAgICB8IF9f X19fX18vCi0gICAgICAgICAgICB8LwotICAgICAgICAgICAgfAotICAgICAgIF9fYWNxdWlyZWQK LSAgICAgICAgICAgIHwKLSAgICAgICAgICAgIC4KLSAgICAgICAgICA8aG9sZD4KLSAgICAgICAg ICAgIC4KLSAgICAgICAgICAgIHwKLSAgICAgICBfX3JlbGVhc2UKLSAgICAgICAgICAgIHwKLSAg ICAgICAgIHVubG9jawotCi1sb2NrLCB1bmxvY2sJLSB0aGUgcmVndWxhciBsb2NrIGZ1bmN0aW9u cwotX18qCQktIHRoZSBob29rcwotPD4gCQktIHN0YXRlcwotCi1XaXRoIHRoZXNlIGhvb2tzIHdl IHByb3ZpZGUgdGhlIGZvbGxvd2luZyBzdGF0aXN0aWNzOgotCi0gY29uLWJvdW5jZXMgICAgICAg LSBudW1iZXIgb2YgbG9jayBjb250ZW50aW9uIHRoYXQgaW52b2x2ZWQgeC1jcHUgZGF0YQotIGNv bnRlbnRpb25zICAgICAgIC0gbnVtYmVyIG9mIGxvY2sgYWNxdWlzaXRpb25zIHRoYXQgaGFkIHRv IHdhaXQKLSB3YWl0IHRpbWUgbWluICAgICAtIHNob3J0ZXN0IChub24tMCkgdGltZSB3ZSBldmVy IGhhZCB0byB3YWl0IGZvciBhIGxvY2sKLSAgICAgICAgICAgbWF4ICAgICAtIGxvbmdlc3QgdGlt ZSB3ZSBldmVyIGhhZCB0byB3YWl0IGZvciBhIGxvY2sKLQkgICB0b3RhbCAgIC0gdG90YWwgdGlt ZSB3ZSBzcGVuZCB3YWl0aW5nIG9uIHRoaXMgbG9jawotCSAgIGF2ZyAgICAgLSBhdmVyYWdlIHRp bWUgc3BlbnQgd2FpdGluZyBvbiB0aGlzIGxvY2sKLSBhY3EtYm91bmNlcyAgICAgICAtIG51bWJl ciBvZiBsb2NrIGFjcXVpc2l0aW9ucyB0aGF0IGludm9sdmVkIHgtY3B1IGRhdGEKLSBhY3F1aXNp dGlvbnMgICAgICAtIG51bWJlciBvZiB0aW1lcyB3ZSB0b29rIHRoZSBsb2NrCi0gaG9sZCB0aW1l IG1pbiAgICAgLSBzaG9ydGVzdCAobm9uLTApIHRpbWUgd2UgZXZlciBoZWxkIHRoZSBsb2NrCi0J ICAgbWF4ICAgICAtIGxvbmdlc3QgdGltZSB3ZSBldmVyIGhlbGQgdGhlIGxvY2sKLQkgICB0b3Rh bCAgIC0gdG90YWwgdGltZSB0aGlzIGxvY2sgd2FzIGhlbGQKLQkgICBhdmcgICAgIC0gYXZlcmFn ZSB0aW1lIHRoaXMgbG9jayB3YXMgaGVsZAotCi1UaGVzZSBudW1iZXJzIGFyZSBnYXRoZXJlZCBw ZXIgbG9jayBjbGFzcywgcGVyIHJlYWQvd3JpdGUgc3RhdGUgKHdoZW4KLWFwcGxpY2FibGUpLgot Ci1JdCBhbHNvIHRyYWNrcyA0IGNvbnRlbnRpb24gcG9pbnRzIHBlciBjbGFzcy4gQSBjb250ZW50 aW9uIHBvaW50IGlzIGEgY2FsbCBzaXRlCi10aGF0IGhhZCB0byB3YWl0IG9uIGxvY2sgYWNxdWlz aXRpb24uCi0KLSAtIENPTkZJR1VSQVRJT04KLQotTG9jayBzdGF0aXN0aWNzIGFyZSBlbmFibGVk IHZpYSBDT05GSUdfTE9DS19TVEFULgotCi0gLSBVU0FHRQotCi1FbmFibGUgY29sbGVjdGlvbiBv ZiBzdGF0aXN0aWNzOgotCi0jIGVjaG8gMSA+L3Byb2Mvc3lzL2tlcm5lbC9sb2NrX3N0YXQKLQot RGlzYWJsZSBjb2xsZWN0aW9uIG9mIHN0YXRpc3RpY3M6Ci0KLSMgZWNobyAwID4vcHJvYy9zeXMv a2VybmVsL2xvY2tfc3RhdAotCi1Mb29rIGF0IHRoZSBjdXJyZW50IGxvY2sgc3RhdGlzdGljczoK LQotKCBsaW5lIG51bWJlcnMgbm90IHBhcnQgb2YgYWN0dWFsIG91dHB1dCwgZG9uZSBmb3IgY2xh cml0eSBpbiB0aGUgZXhwbGFuYXRpb24KLSAgYmVsb3cgKQotCi0jIGxlc3MgL3Byb2MvbG9ja19z dGF0Ci0KLTAxIGxvY2tfc3RhdCB2ZXJzaW9uIDAuNAotMDItLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLQotMDMgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICBjbGFzcyBuYW1lICAgIGNvbi1ib3VuY2VzICAgIGNvbnRlbnRpb25zICAgd2FpdHRpbWUt bWluICAgd2FpdHRpbWUtbWF4IHdhaXR0aW1lLXRvdGFsICAgd2FpdHRpbWUtYXZnICAgIGFjcS1i b3VuY2VzICAgYWNxdWlzaXRpb25zICAgaG9sZHRpbWUtbWluICAgaG9sZHRpbWUtbWF4IGhvbGR0 aW1lLXRvdGFsICAgaG9sZHRpbWUtYXZnCi0wNC0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tCi0wNQotMDYgICAgICAgICAgICAgICAgICAgICAgICAgJm1t LT5tbWFwX3NlbS1XOiAgICAgICAgICAgIDQ2ICAgICAgICAgICAgIDg0ICAgICAgICAgICAwLjI2 ICAgICAgICAgOTM5LjEwICAgICAgIDE2MzcxLjUzICAgICAgICAgMTk0LjkwICAgICAgICAgIDQ3 MjkxICAgICAgICAyOTIyMzY1ICAgICAgICAgICAwLjE2ICAgICAyMjIwMzAxLjY5IDE3NDY0MDI2 OTE2LjMyICAgICAgICA1OTc1Ljk5Ci0wNyAgICAgICAgICAgICAgICAgICAgICAgICAmbW0tPm1t YXBfc2VtLVI6ICAgICAgICAgICAgMzcgICAgICAgICAgICAxMDAgICAgICAgICAgIDEuMzEgICAg ICAyOTk1MDIuNjEgICAgICAzMjU2MjkuNTIgICAgICAgIDMyNTYuMzAgICAgICAgICAyMTIzNDQg ICAgICAgMzQzMTY2ODUgICAgICAgICAgIDAuMTAgICAgICAgIDc3NDQuOTEgICAgOTUwMTY5MTAu MjAgICAgICAgICAgIDIuNzcKLTA4ICAgICAgICAgICAgICAgICAgICAgICAgIC0tLS0tLS0tLS0t LS0tLQotMDkgICAgICAgICAgICAgICAgICAgICAgICAgICAmbW0tPm1tYXBfc2VtICAgICAgICAg ICAgICAxICAgICAgICAgIFs8ZmZmZmZmZmY4MTE1MDJhNz5dIGtodWdlcGFnZWRfc2Nhbl9tbV9z bG90KzB4NTcvMHgyODAKLTEwICAgICAgICAgICAgICAgICAgICAgICAgICAgJm1tLT5tbWFwX3Nl bSAgICAgICAgICAgICA5NiAgICAgICAgICBbPGZmZmZmZmZmODE1MzUxYzQ+XSBfX2RvX3BhZ2Vf ZmF1bHQrMHgxZDQvMHg1MTAKLTExICAgICAgICAgICAgICAgICAgICAgICAgICAgJm1tLT5tbWFw X3NlbSAgICAgICAgICAgICAzNCAgICAgICAgICBbPGZmZmZmZmZmODExMTNkNzc+XSB2bV9tbWFw X3Bnb2ZmKzB4ODcvMHhkMAotMTIgICAgICAgICAgICAgICAgICAgICAgICAgICAmbW0tPm1tYXBf c2VtICAgICAgICAgICAgIDE3ICAgICAgICAgIFs8ZmZmZmZmZmY4MTEyN2U3MT5dIHZtX211bm1h cCsweDQxLzB4ODAKLTEzICAgICAgICAgICAgICAgICAgICAgICAgIC0tLS0tLS0tLS0tLS0tLQot MTQgICAgICAgICAgICAgICAgICAgICAgICAgICAmbW0tPm1tYXBfc2VtICAgICAgICAgICAgICAx ICAgICAgICAgIFs8ZmZmZmZmZmY4MTA0NmZkYT5dIGR1cF9tbWFwKzB4MmEvMHgzZjAKLTE1ICAg ICAgICAgICAgICAgICAgICAgICAgICAgJm1tLT5tbWFwX3NlbSAgICAgICAgICAgICA2MCAgICAg ICAgICBbPGZmZmZmZmZmODExMjllMjk+XSBTeVNfbXByb3RlY3QrMHhlOS8weDI1MAotMTYgICAg ICAgICAgICAgICAgICAgICAgICAgICAmbW0tPm1tYXBfc2VtICAgICAgICAgICAgIDQxICAgICAg ICAgIFs8ZmZmZmZmZmY4MTUzNTFjND5dIF9fZG9fcGFnZV9mYXVsdCsweDFkNC8weDUxMAotMTcg ICAgICAgICAgICAgICAgICAgICAgICAgICAmbW0tPm1tYXBfc2VtICAgICAgICAgICAgIDY4ICAg ICAgICAgIFs8ZmZmZmZmZmY4MTExM2Q3Nz5dIHZtX21tYXBfcGdvZmYrMHg4Ny8weGQwCi0xOAot MTkuLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4u Li4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4u Li4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4u Li4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLgotMjAK LTIxICAgICAgICAgICAgICAgICAgICAgICAgIHVuaXhfdGFibGVfbG9jazogICAgICAgICAgIDEx MCAgICAgICAgICAgIDExMiAgICAgICAgICAgMC4yMSAgICAgICAgICA0OS4yNCAgICAgICAgIDE2 My45MSAgICAgICAgICAgMS40NiAgICAgICAgICAyMTA5NCAgICAgICAgICA2NjMxMiAgICAgICAg ICAgMC4xMiAgICAgICAgIDYyNC40MiAgICAgICAzMTU4OS44MSAgICAgICAgICAgMC40OAotMjIg ICAgICAgICAgICAgICAgICAgICAgICAgLS0tLS0tLS0tLS0tLS0tCi0yMyAgICAgICAgICAgICAg ICAgICAgICAgICB1bml4X3RhYmxlX2xvY2sgICAgICAgICAgICAgNDUgICAgICAgICAgWzxmZmZm ZmZmZjgxNTBhZDhlPl0gdW5peF9jcmVhdGUxKzB4MTZlLzB4MWIwCi0yNCAgICAgICAgICAgICAg ICAgICAgICAgICB1bml4X3RhYmxlX2xvY2sgICAgICAgICAgICAgNDcgICAgICAgICAgWzxmZmZm ZmZmZjgxNTBiMTExPl0gdW5peF9yZWxlYXNlX3NvY2srMHgzMS8weDI1MAotMjUgICAgICAgICAg ICAgICAgICAgICAgICAgdW5peF90YWJsZV9sb2NrICAgICAgICAgICAgIDE1ICAgICAgICAgIFs8 ZmZmZmZmZmY4MTUwY2EzNz5dIHVuaXhfZmluZF9vdGhlcisweDExNy8weDIzMAotMjYgICAgICAg ICAgICAgICAgICAgICAgICAgdW5peF90YWJsZV9sb2NrICAgICAgICAgICAgICA1ICAgICAgICAg IFs8ZmZmZmZmZmY4MTUwYTA5Zj5dIHVuaXhfYXV0b2JpbmQrMHgxMWYvMHgxYjAKLTI3ICAgICAg ICAgICAgICAgICAgICAgICAgIC0tLS0tLS0tLS0tLS0tLQotMjggICAgICAgICAgICAgICAgICAg ICAgICAgdW5peF90YWJsZV9sb2NrICAgICAgICAgICAgIDM5ICAgICAgICAgIFs8ZmZmZmZmZmY4 MTUwYjExMT5dIHVuaXhfcmVsZWFzZV9zb2NrKzB4MzEvMHgyNTAKLTI5ICAgICAgICAgICAgICAg ICAgICAgICAgIHVuaXhfdGFibGVfbG9jayAgICAgICAgICAgICA0OSAgICAgICAgICBbPGZmZmZm ZmZmODE1MGFkOGU+XSB1bml4X2NyZWF0ZTErMHgxNmUvMHgxYjAKLTMwICAgICAgICAgICAgICAg ICAgICAgICAgIHVuaXhfdGFibGVfbG9jayAgICAgICAgICAgICAyMCAgICAgICAgICBbPGZmZmZm ZmZmODE1MGNhMzc+XSB1bml4X2ZpbmRfb3RoZXIrMHgxMTcvMHgyMzAKLTMxICAgICAgICAgICAg ICAgICAgICAgICAgIHVuaXhfdGFibGVfbG9jayAgICAgICAgICAgICAgNCAgICAgICAgICBbPGZm ZmZmZmZmODE1MGEwOWY+XSB1bml4X2F1dG9iaW5kKzB4MTFmLzB4MWIwCi0KLQotVGhpcyBleGNl cnB0IHNob3dzIHRoZSBmaXJzdCB0d28gbG9jayBjbGFzcyBzdGF0aXN0aWNzLiBMaW5lIDAxIHNo b3dzIHRoZQotb3V0cHV0IHZlcnNpb24gLSBlYWNoIHRpbWUgdGhlIGZvcm1hdCBjaGFuZ2VzIHRo aXMgd2lsbCBiZSB1cGRhdGVkLiBMaW5lIDAyLTA0Ci1zaG93IHRoZSBoZWFkZXIgd2l0aCBjb2x1 bW4gZGVzY3JpcHRpb25zLiBMaW5lcyAwNS0xOCBhbmQgMjAtMzEgc2hvdyB0aGUgYWN0dWFsCi1z dGF0aXN0aWNzLiBUaGVzZSBzdGF0aXN0aWNzIGNvbWUgaW4gdHdvIHBhcnRzOyB0aGUgYWN0dWFs IHN0YXRzIHNlcGFyYXRlZCBieSBhCi1zaG9ydCBzZXBhcmF0b3IgKGxpbmUgMDgsIDEzKSBmcm9t IHRoZSBjb250ZW50aW9uIHBvaW50cy4KLQotTGluZXMgMDktMTIgc2hvdyB0aGUgZmlyc3QgNCBy ZWNvcmRlZCBjb250ZW50aW9uIHBvaW50cyAodGhlIGNvZGUKLXdoaWNoIHRyaWVzIHRvIGdldCB0 aGUgbG9jaykgYW5kIGxpbmVzIDE0LTE3IHNob3cgdGhlIGZpcnN0IDQgcmVjb3JkZWQKLWNvbnRl bmRlZCBwb2ludHMgKHRoZSBsb2NrIGhvbGRlcikuIEl0IGlzIHBvc3NpYmxlIHRoYXQgdGhlIG1h eAotY29uLWJvdW5jZXMgcG9pbnQgaXMgbWlzc2luZyBpbiB0aGUgc3RhdGlzdGljcy4KLQotVGhl IGZpcnN0IGxvY2sgKDA1LTE4KSBpcyBhIHJlYWQvd3JpdGUgbG9jaywgYW5kIHNob3dzIHR3byBs aW5lcyBhYm92ZSB0aGUKLXNob3J0IHNlcGFyYXRvci4gVGhlIGNvbnRlbnRpb24gcG9pbnRzIGRv bid0IG1hdGNoIHRoZSBjb2x1bW4gZGVzY3JpcHRvcnMsCi10aGV5IGhhdmUgdHdvOiBjb250ZW50 aW9ucyBhbmQgWzxJUD5dIHN5bWJvbC4gVGhlIHNlY29uZCBzZXQgb2YgY29udGVudGlvbgotcG9p bnRzIGFyZSB0aGUgcG9pbnRzIHdlJ3JlIGNvbnRlbmRpbmcgd2l0aC4KLQotVGhlIGludGVnZXIg cGFydCBvZiB0aGUgdGltZSB2YWx1ZXMgaXMgaW4gdXMuCi0KLURlYWxpbmcgd2l0aCBuZXN0ZWQg bG9ja3MsIHN1YmNsYXNzZXMgbWF5IGFwcGVhcjoKLQotMzIuLi4uLi4uLi4uLi4uLi4uLi4uLi4u Li4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4u Li4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4u Li4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4u Li4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4KLTMzCi0zNCAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAmcnEtPmxvY2s6ICAgICAgIDEzMTI4ICAgICAgICAgIDEzMTI4ICAgICAgICAgICAw LjQzICAgICAgICAgMTkwLjUzICAgICAgMTAzODgxLjI2ICAgICAgICAgICA3LjkxICAgICAgICAg IDk3NDU0ICAgICAgICAzNDUzNDA0ICAgICAgICAgICAwLjAwICAgICAgICAgNDAxLjExICAgIDEz MjI0NjgzLjExICAgICAgICAgICAzLjgyCi0zNSAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAtLS0tLS0tLS0KLTM2ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICZycS0+bG9jayAg ICAgICAgICA2NDUgICAgICAgICAgWzxmZmZmZmZmZjgxMDNiZmM0Pl0gdGFza19ycV9sb2NrKzB4 NDMvMHg3NQotMzcgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgJnJxLT5sb2NrICAgICAg ICAgIDI5NyAgICAgICAgICBbPGZmZmZmZmZmODEwNGJhNjU+XSB0cnlfdG9fd2FrZV91cCsweDEy Ny8weDI1YQotMzggICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgJnJxLT5sb2NrICAgICAg ICAgIDM2MCAgICAgICAgICBbPGZmZmZmZmZmODEwM2M0YzU+XSBzZWxlY3RfdGFza19ycV9mYWly KzB4MWYwLzB4NzRhCi0zOSAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAmcnEtPmxvY2sg ICAgICAgICAgNDI4ICAgICAgICAgIFs8ZmZmZmZmZmY4MTA0NWY5OD5dIHNjaGVkdWxlcl90aWNr KzB4NDYvMHgxZmIKLTQwICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIC0tLS0tLS0tLQot NDEgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgJnJxLT5sb2NrICAgICAgICAgICA3NyAg ICAgICAgICBbPGZmZmZmZmZmODEwM2JmYzQ+XSB0YXNrX3JxX2xvY2srMHg0My8weDc1Ci00MiAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAmcnEtPmxvY2sgICAgICAgICAgMTc0ICAgICAg ICAgIFs8ZmZmZmZmZmY4MTA0YmE2NT5dIHRyeV90b193YWtlX3VwKzB4MTI3LzB4MjVhCi00MyAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAmcnEtPmxvY2sgICAgICAgICA0NzE1ICAgICAg ICAgIFs8ZmZmZmZmZmY4MTAzZWQ0Yj5dIGRvdWJsZV9ycV9sb2NrKzB4NDIvMHg1NAotNDQgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgJnJxLT5sb2NrICAgICAgICAgIDg5MyAgICAgICAg ICBbPGZmZmZmZmZmODEzNDA1MjQ+XSBzY2hlZHVsZSsweDE1Ny8weDdiOAotNDUKLTQ2Li4uLi4u Li4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4u Li4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4u Li4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4u Li4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uCi00NwotNDggICAgICAg ICAgICAgICAgICAgICAgICAgICAgICZycS0+bG9jay8xOiAgICAgICAgMTUyNiAgICAgICAgICAx MTQ4OCAgICAgICAgICAgMC4zMyAgICAgICAgIDM4OC43MyAgICAgIDEzNjI5NC4zMSAgICAgICAg ICAxMS44NiAgICAgICAgICAyMTQ2MSAgICAgICAgICAzODQwNCAgICAgICAgICAgMC4wMCAgICAg ICAgICAzNy45MyAgICAgIDEwOTM4OC41MyAgICAgICAgICAgMi44NAotNDkgICAgICAgICAgICAg ICAgICAgICAgICAgICAgIC0tLS0tLS0tLS0tCi01MCAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgJnJxLT5sb2NrLzEgICAgICAgIDExNTI2ICAgICAgICAgIFs8ZmZmZmZmZmY4MTAzZWQ1OD5d IGRvdWJsZV9ycV9sb2NrKzB4NGYvMHg1NAotNTEgICAgICAgICAgICAgICAgICAgICAgICAgICAg IC0tLS0tLS0tLS0tCi01MiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgJnJxLT5sb2NrLzEg ICAgICAgICA1NjQ1ICAgICAgICAgIFs8ZmZmZmZmZmY4MTAzZWQ0Yj5dIGRvdWJsZV9ycV9sb2Nr KzB4NDIvMHg1NAotNTMgICAgICAgICAgICAgICAgICAgICAgICAgICAgICZycS0+bG9jay8xICAg ICAgICAgMTIyNCAgICAgICAgICBbPGZmZmZmZmZmODEzNDA1MjQ+XSBzY2hlZHVsZSsweDE1Ny8w eDdiOAotNTQgICAgICAgICAgICAgICAgICAgICAgICAgICAgICZycS0+bG9jay8xICAgICAgICAg NDMzNiAgICAgICAgICBbPGZmZmZmZmZmODEwM2VkNTg+XSBkb3VibGVfcnFfbG9jaysweDRmLzB4 NTQKLTU1ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAmcnEtPmxvY2svMSAgICAgICAgICAx ODEgICAgICAgICAgWzxmZmZmZmZmZjgxMDRiYTY1Pl0gdHJ5X3RvX3dha2VfdXArMHgxMjcvMHgy NWEKLQotTGluZSA0OCBzaG93cyBzdGF0aXN0aWNzIGZvciB0aGUgc2Vjb25kIHN1YmNsYXNzICgv MSkgb2YgJnJxLT5sb2NrIGNsYXNzCi0oc3ViY2xhc3Mgc3RhcnRzIGZyb20gMCksIHNpbmNlIGlu IHRoaXMgY2FzZSwgYXMgbGluZSA1MCBzdWdnZXN0cywKLWRvdWJsZV9ycV9sb2NrIGFjdHVhbGx5 IGFjcXVpcmVzIGEgbmVzdGVkIGxvY2sgb2YgdHdvIHNwaW5sb2Nrcy4KLQotVmlldyB0aGUgdG9w IGNvbnRlbmRpbmcgbG9ja3M6Ci0KLSMgZ3JlcCA6IC9wcm9jL2xvY2tfc3RhdCB8IGhlYWQKLQkJ CWNsb2NrZXZlbnRzX2xvY2s6ICAgICAgIDI5MjYxNTkgICAgICAgIDI5NDc2MzYgICAgICAgICAg IDAuMTUgICAgICAgNDY4ODIuODEgIDE3ODQ1NDA0NjYuMzQgICAgICAgICA2MDUuNDEgICAgICAg IDMzODEzNDUgICAgICAgIDM4NzkxNjEgICAgICAgICAgIDAuMDAgICAgICAgIDIyNjAuOTcgICAg NTMxNzgzOTUuNjggICAgICAgICAgMTMuNzEKLQkJICAgICB0aWNrX2Jyb2FkY2FzdF9sb2NrOiAg ICAgICAgMzQ2NDYwICAgICAgICAgMzQ2NzE3ICAgICAgICAgICAwLjE4ICAgICAgICAyMjU3LjQz ICAgIDM5MzY0NjIyLjcxICAgICAgICAgMTEzLjU0ICAgICAgICAzNjQyOTE5ICAgICAgICA0MjQy Njk2ICAgICAgICAgICAwLjAwICAgICAgICAyMjYzLjc5ICAgIDQ5MTczNjQ2LjYwICAgICAgICAg IDExLjU5Ci0JCSAgJm1hcHBpbmctPmlfbW1hcF9tdXRleDogICAgICAgIDIwMzg5NiAgICAgICAg IDIwMzg5OSAgICAgICAgICAgMy4zNiAgICAgIDY0NTUzMC4wNSAzMTc2NzUwNzk4OC4zOSAgICAg IDE1NTgwMC4yMSAgICAgICAgMzM2MTc3NiAgICAgICAgODg5Mzk4NCAgICAgICAgICAgMC4xNyAg ICAgICAgMjI1NC4xNSAgICAxNDExMDEyMS4wMiAgICAgICAgICAgMS41OQotCQkJICAgICAgICZy cS0+bG9jazogICAgICAgIDEzNTAxNCAgICAgICAgIDEzNjkwOSAgICAgICAgICAgMC4xOCAgICAg ICAgIDYwNi4wOSAgICAgIDg0MjE2MC42OCAgICAgICAgICAgNi4xNSAgICAgICAgMTU0MDcyOCAg ICAgICAxMDQzNjE0NiAgICAgICAgICAgMC4wMCAgICAgICAgIDcyOC43MiAgICAxNzYwNjY4My40 MSAgICAgICAgICAgMS42OQotCSAgICAgICAmKCZ6b25lLT5scnVfbG9jayktPnJsb2NrOiAgICAg ICAgIDkzMDAwICAgICAgICAgIDk0OTM0ICAgICAgICAgICAwLjE2ICAgICAgICAgIDU5LjE4ICAg ICAgMTg4MjUzLjc4ICAgICAgICAgICAxLjk4ICAgICAgICAxMTk5OTEyICAgICAgICAzODA5ODk0 ICAgICAgICAgICAwLjE1ICAgICAgICAgMzkxLjQwICAgICAzNTU5NTE4LjgxICAgICAgICAgICAw LjkzCi0JCQkgdGFza2xpc3RfbG9jay1XOiAgICAgICAgIDQwNjY3ICAgICAgICAgIDQxMTMwICAg ICAgICAgICAwLjIzICAgICAgICAxMTg5LjQyICAgICAgNDI4OTgwLjUxICAgICAgICAgIDEwLjQz ICAgICAgICAgMjcwMjc4ICAgICAgICAgNTEwMTA2ICAgICAgICAgICAwLjE2ICAgICAgICAgNjUz LjUxICAgICAzOTM5Njc0LjkxICAgICAgICAgICA3LjcyCi0JCQkgdGFza2xpc3RfbG9jay1SOiAg ICAgICAgIDIxMjk4ICAgICAgICAgIDIxMzA1ICAgICAgICAgICAwLjIwICAgICAgICAxMzEwLjA1 ICAgICAgMjE1NTExLjEyICAgICAgICAgIDEwLjEyICAgICAgICAgMTg2MjA0ICAgICAgICAgMjQx MjU4ICAgICAgICAgICAwLjE0ICAgICAgICAxMTYyLjMzICAgICAxMTc5Nzc5LjIzICAgICAgICAg ICA0Ljg5Ci0JCQkgICAgICByY3Vfbm9kZV8xOiAgICAgICAgIDQ3NjU2ICAgICAgICAgIDQ5MDIy ICAgICAgICAgICAwLjE2ICAgICAgICAgNjM1LjQxICAgICAgMTkzNjE2LjQxICAgICAgICAgICAz Ljk1ICAgICAgICAgODQ0ODg4ICAgICAgICAxODY1NDIzICAgICAgICAgICAwLjAwICAgICAgICAg NzY0LjI2ICAgICAxNjU2MjI2Ljk2ICAgICAgICAgICAwLjg5Ci0gICAgICAgJigmZGVudHJ5LT5k X2xvY2tyZWYubG9jayktPnJsb2NrOiAgICAgICAgIDM5NzkxICAgICAgICAgIDQwMTc5ICAgICAg ICAgICAwLjE1ICAgICAgICAxMzAyLjA4ICAgICAgIDg4ODUxLjk2ICAgICAgICAgICAyLjIxICAg ICAgICAyNzkwODUxICAgICAgIDEyNTI3MDI1ICAgICAgICAgICAwLjEwICAgICAgICAxOTEwLjc1 ICAgICAzMzc5NzE0LjI3ICAgICAgICAgICAwLjI3Ci0JCQkgICAgICByY3Vfbm9kZV8wOiAgICAg ICAgIDI5MjAzICAgICAgICAgIDMwMDY0ICAgICAgICAgICAwLjE2ICAgICAgICAgNzg2LjU1ICAg ICAxNTU1NTczLjAwICAgICAgICAgIDUxLjc0ICAgICAgICAgIDg4OTYzICAgICAgICAgMjQ0MjU0 ICAgICAgICAgICAwLjAwICAgICAgICAgMzk4Ljg3ICAgICAgNDI4ODcyLjUxICAgICAgICAgICAx Ljc2Ci0KLUNsZWFyIHRoZSBzdGF0aXN0aWNzOgotCi0jIGVjaG8gMCA+IC9wcm9jL2xvY2tfc3Rh dApkaWZmIC0tZ2l0IGEvRG9jdW1lbnRhdGlvbi9sb2NraW5nL2xvY2t0b3J0dXJlLnR4dCBiL0Rv Y3VtZW50YXRpb24vbG9ja2luZy9sb2NrdG9ydHVyZS5yc3QKc2ltaWxhcml0eSBpbmRleCA1NyUK cmVuYW1lIGZyb20gRG9jdW1lbnRhdGlvbi9sb2NraW5nL2xvY2t0b3J0dXJlLnR4dApyZW5hbWUg dG8gRG9jdW1lbnRhdGlvbi9sb2NraW5nL2xvY2t0b3J0dXJlLnJzdAppbmRleCA2YThkZjRjZDE5 YmYuLmU3OWVlZWNhM2FjNiAxMDA2NDQKLS0tIGEvRG9jdW1lbnRhdGlvbi9sb2NraW5nL2xvY2t0 b3J0dXJlLnR4dAorKysgYi9Eb2N1bWVudGF0aW9uL2xvY2tpbmcvbG9ja3RvcnR1cmUucnN0CkBA IC0xLDYgKzEsOSBAQAorPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQogS2VybmVs IExvY2sgVG9ydHVyZSBUZXN0IE9wZXJhdGlvbgorPT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PQogCiBDT05GSUdfTE9DS19UT1JUVVJFX1RFU1QKKz09PT09PT09PT09PT09PT09PT09 PT09PQogCiBUaGUgQ09ORklHIExPQ0tfVE9SVFVSRV9URVNUIGNvbmZpZyBvcHRpb24gcHJvdmlk ZXMgYSBrZXJuZWwgbW9kdWxlCiB0aGF0IHJ1bnMgdG9ydHVyZSB0ZXN0cyBvbiBjb3JlIGtlcm5l bCBsb2NraW5nIHByaW1pdGl2ZXMuIFRoZSBrZXJuZWwKQEAgLTE4LDYxICsyMSw3NyBAQCBjYW4g YmUgc2ltdWxhdGVkIGJ5IGVpdGhlciBlbmxhcmdpbmcgdGhpcyBjcml0aWNhbCByZWdpb24gaG9s ZCB0aW1lIGFuZC9vcgogY3JlYXRpbmcgbW9yZSBrdGhyZWFkcy4KIAogCi1NT0RVTEUgUEFSQU1F VEVSUworTW9kdWxlIFBhcmFtZXRlcnMKKz09PT09PT09PT09PT09PT09CiAKIFRoaXMgbW9kdWxl IGhhcyB0aGUgZm9sbG93aW5nIHBhcmFtZXRlcnM6CiAKIAotCSAgICAqKiBMb2NrdG9ydHVyZS1z cGVjaWZpYyAqKgorTG9ja3RvcnR1cmUtc3BlY2lmaWMKKy0tLS0tLS0tLS0tLS0tLS0tLS0tCiAK LW53cml0ZXJzX3N0cmVzcyAgIE51bWJlciBvZiBrZXJuZWwgdGhyZWFkcyB0aGF0IHdpbGwgc3Ry ZXNzIGV4Y2x1c2l2ZSBsb2NrCitud3JpdGVyc19zdHJlc3MKKwkJICBOdW1iZXIgb2Yga2VybmVs IHRocmVhZHMgdGhhdCB3aWxsIHN0cmVzcyBleGNsdXNpdmUgbG9jawogCQkgIG93bmVyc2hpcCAo d3JpdGVycykuIFRoZSBkZWZhdWx0IHZhbHVlIGlzIHR3aWNlIHRoZSBudW1iZXIKIAkJICBvZiBv bmxpbmUgQ1BVcy4KIAotbnJlYWRlcnNfc3RyZXNzICAgTnVtYmVyIG9mIGtlcm5lbCB0aHJlYWRz IHRoYXQgd2lsbCBzdHJlc3Mgc2hhcmVkIGxvY2sKK25yZWFkZXJzX3N0cmVzcworCQkgIE51bWJl ciBvZiBrZXJuZWwgdGhyZWFkcyB0aGF0IHdpbGwgc3RyZXNzIHNoYXJlZCBsb2NrCiAJCSAgb3du ZXJzaGlwIChyZWFkZXJzKS4gVGhlIGRlZmF1bHQgaXMgdGhlIHNhbWUgYW1vdW50IG9mIHdyaXRl cgogCQkgIGxvY2tzLiBJZiB0aGUgdXNlciBkaWQgbm90IHNwZWNpZnkgbndyaXRlcnNfc3RyZXNz LCB0aGVuCiAJCSAgYm90aCByZWFkZXJzIGFuZCB3cml0ZXJzIGJlIHRoZSBhbW91bnQgb2Ygb25s aW5lIENQVXMuCiAKLXRvcnR1cmVfdHlwZQkgIFR5cGUgb2YgbG9jayB0byB0b3J0dXJlLiBCeSBk ZWZhdWx0LCBvbmx5IHNwaW5sb2NrcyB3aWxsCit0b3J0dXJlX3R5cGUKKwkJICBUeXBlIG9mIGxv Y2sgdG8gdG9ydHVyZS4gQnkgZGVmYXVsdCwgb25seSBzcGlubG9ja3Mgd2lsbAogCQkgIGJlIHRv cnR1cmVkLiBUaGlzIG1vZHVsZSBjYW4gdG9ydHVyZSB0aGUgZm9sbG93aW5nIGxvY2tzLAogCQkg IHdpdGggc3RyaW5nIHZhbHVlcyBhcyBmb2xsb3dzOgogCi0JCSAgICAgbyAibG9ja19idXN0ZWQi OiBTaW11bGF0ZXMgYSBidWdneSBsb2NrIGltcGxlbWVudGF0aW9uLgorCQkgICAgIC0gImxvY2tf YnVzdGVkIjoKKwkJCQlTaW11bGF0ZXMgYSBidWdneSBsb2NrIGltcGxlbWVudGF0aW9uLgogCi0J CSAgICAgbyAic3Bpbl9sb2NrIjogc3Bpbl9sb2NrKCkgYW5kIHNwaW5fdW5sb2NrKCkgcGFpcnMu CisJCSAgICAgLSAic3Bpbl9sb2NrIjoKKwkJCQlzcGluX2xvY2soKSBhbmQgc3Bpbl91bmxvY2so KSBwYWlycy4KIAotCQkgICAgIG8gInNwaW5fbG9ja19pcnEiOiBzcGluX2xvY2tfaXJxKCkgYW5k IHNwaW5fdW5sb2NrX2lycSgpCi0JCQkJCXBhaXJzLgorCQkgICAgIC0gInNwaW5fbG9ja19pcnEi OgorCQkJCXNwaW5fbG9ja19pcnEoKSBhbmQgc3Bpbl91bmxvY2tfaXJxKCkgcGFpcnMuCiAKLQkJ ICAgICBvICJyd19sb2NrIjogcmVhZC93cml0ZSBsb2NrKCkgYW5kIHVubG9jaygpIHJ3bG9jayBw YWlycy4KKwkJICAgICAtICJyd19sb2NrIjoKKwkJCQlyZWFkL3dyaXRlIGxvY2soKSBhbmQgdW5s b2NrKCkgcndsb2NrIHBhaXJzLgogCi0JCSAgICAgbyAicndfbG9ja19pcnEiOiByZWFkL3dyaXRl IGxvY2tfaXJxKCkgYW5kIHVubG9ja19pcnEoKQotCQkJCSAgICAgIHJ3bG9jayBwYWlycy4KKwkJ ICAgICAtICJyd19sb2NrX2lycSI6CisJCQkJcmVhZC93cml0ZSBsb2NrX2lycSgpIGFuZCB1bmxv Y2tfaXJxKCkKKwkJCQlyd2xvY2sgcGFpcnMuCiAKLQkJICAgICBvICJtdXRleF9sb2NrIjogbXV0 ZXhfbG9jaygpIGFuZCBtdXRleF91bmxvY2soKSBwYWlycy4KKwkJICAgICAtICJtdXRleF9sb2Nr IjoKKwkJCQltdXRleF9sb2NrKCkgYW5kIG11dGV4X3VubG9jaygpIHBhaXJzLgogCi0JCSAgICAg byAicnRtdXRleF9sb2NrIjogcnRtdXRleF9sb2NrKCkgYW5kIHJ0bXV0ZXhfdW5sb2NrKCkKLQkJ CQkgICAgICAgcGFpcnMuIEtlcm5lbCBtdXN0IGhhdmUgQ09ORklHX1JUX01VVEVYPXkuCisJCSAg ICAgLSAicnRtdXRleF9sb2NrIjoKKwkJCQlydG11dGV4X2xvY2soKSBhbmQgcnRtdXRleF91bmxv Y2soKSBwYWlycy4KKwkJCQlLZXJuZWwgbXVzdCBoYXZlIENPTkZJR19SVF9NVVRFWD15LgogCi0J CSAgICAgbyAicndzZW1fbG9jayI6IHJlYWQvd3JpdGUgZG93bigpIGFuZCB1cCgpIHNlbWFwaG9y ZSBwYWlycy4KKwkJICAgICAtICJyd3NlbV9sb2NrIjoKKwkJCQlyZWFkL3dyaXRlIGRvd24oKSBh bmQgdXAoKSBzZW1hcGhvcmUgcGFpcnMuCiAKIAotCSAgICAqKiBUb3J0dXJlLWZyYW1ld29yayAo UkNVICsgbG9ja2luZykgKioKK1RvcnR1cmUtZnJhbWV3b3JrIChSQ1UgKyBsb2NraW5nKQorLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tCiAKLXNodXRkb3duX3NlY3MJICBUaGUgbnVt YmVyIG9mIHNlY29uZHMgdG8gcnVuIHRoZSB0ZXN0IGJlZm9yZSB0ZXJtaW5hdGluZworc2h1dGRv d25fc2VjcworCQkgIFRoZSBudW1iZXIgb2Ygc2Vjb25kcyB0byBydW4gdGhlIHRlc3QgYmVmb3Jl IHRlcm1pbmF0aW5nCiAJCSAgdGhlIHRlc3QgYW5kIHBvd2VyaW5nIG9mZiB0aGUgc3lzdGVtLiAg VGhlIGRlZmF1bHQgaXMKIAkJICB6ZXJvLCB3aGljaCBkaXNhYmxlcyB0ZXN0IHRlcm1pbmF0aW9u IGFuZCBzeXN0ZW0gc2h1dGRvd24uCiAJCSAgVGhpcyBjYXBhYmlsaXR5IGlzIHVzZWZ1bCBmb3Ig YXV0b21hdGVkIHRlc3RpbmcuCiAKLW9ub2ZmX2ludGVydmFsCSAgVGhlIG51bWJlciBvZiBzZWNv bmRzIGJldHdlZW4gZWFjaCBhdHRlbXB0IHRvIGV4ZWN1dGUgYQorb25vZmZfaW50ZXJ2YWwKKwkJ ICBUaGUgbnVtYmVyIG9mIHNlY29uZHMgYmV0d2VlbiBlYWNoIGF0dGVtcHQgdG8gZXhlY3V0ZSBh CiAJCSAgcmFuZG9tbHkgc2VsZWN0ZWQgQ1BVLWhvdHBsdWcgb3BlcmF0aW9uLiAgRGVmYXVsdHMK IAkJICB0byB6ZXJvLCB3aGljaCBkaXNhYmxlcyBDUFUgaG90cGx1Z2dpbmcuICBJbgogCQkgIENP TkZJR19IT1RQTFVHX0NQVT1uIGtlcm5lbHMsIGxvY2t0b3J0dXJlIHdpbGwgc2lsZW50bHkKIAkJ ICByZWZ1c2UgdG8gZG8gYW55IENQVS1ob3RwbHVnIG9wZXJhdGlvbnMgcmVnYXJkbGVzcyBvZgog CQkgIHdoYXQgdmFsdWUgaXMgc3BlY2lmaWVkIGZvciBvbm9mZl9pbnRlcnZhbC4KIAotb25vZmZf aG9sZG9mZgkgIFRoZSBudW1iZXIgb2Ygc2Vjb25kcyB0byB3YWl0IHVudGlsIHN0YXJ0aW5nIENQ VS1ob3RwbHVnCitvbm9mZl9ob2xkb2ZmCisJCSAgVGhlIG51bWJlciBvZiBzZWNvbmRzIHRvIHdh aXQgdW50aWwgc3RhcnRpbmcgQ1BVLWhvdHBsdWcKIAkJICBvcGVyYXRpb25zLiAgVGhpcyB3b3Vs ZCBub3JtYWxseSBvbmx5IGJlIHVzZWQgd2hlbgogCQkgIGxvY2t0b3J0dXJlIHdhcyBidWlsdCBp bnRvIHRoZSBrZXJuZWwgYW5kIHN0YXJ0ZWQKIAkJICBhdXRvbWF0aWNhbGx5IGF0IGJvb3QgdGlt ZSwgaW4gd2hpY2ggY2FzZSBpdCBpcyB1c2VmdWwKQEAgLTgwLDUzICs5OSw1OSBAQCBvbm9mZl9o b2xkb2ZmCSAgVGhlIG51bWJlciBvZiBzZWNvbmRzIHRvIHdhaXQgdW50aWwgc3RhcnRpbmcgQ1BV LWhvdHBsdWcKIAkJICBjb21pbmcgYW5kIGdvaW5nLiBUaGlzIHBhcmFtZXRlciBpcyBvbmx5IHVz ZWZ1bCBpZgogCQkgIENPTkZJR19IT1RQTFVHX0NQVSBpcyBlbmFibGVkLgogCi1zdGF0X2ludGVy dmFsCSAgTnVtYmVyIG9mIHNlY29uZHMgYmV0d2VlbiBzdGF0aXN0aWNzLXJlbGF0ZWQgcHJpbnRr KClzLgorc3RhdF9pbnRlcnZhbAorCQkgIE51bWJlciBvZiBzZWNvbmRzIGJldHdlZW4gc3RhdGlz dGljcy1yZWxhdGVkIHByaW50aygpcy4KIAkJICBCeSBkZWZhdWx0LCBsb2NrdG9ydHVyZSB3aWxs IHJlcG9ydCBzdGF0cyBldmVyeSA2MCBzZWNvbmRzLgogCQkgIFNldHRpbmcgdGhlIGludGVydmFs IHRvIHplcm8gY2F1c2VzIHRoZSBzdGF0aXN0aWNzIHRvCiAJCSAgYmUgcHJpbnRlZCAtb25seS0g d2hlbiB0aGUgbW9kdWxlIGlzIHVubG9hZGVkLCBhbmQgdGhpcwogCQkgIGlzIHRoZSBkZWZhdWx0 LgogCi1zdHV0dGVyCQkgIFRoZSBsZW5ndGggb2YgdGltZSB0byBydW4gdGhlIHRlc3QgYmVmb3Jl IHBhdXNpbmcgZm9yIHRoaXMKK3N0dXR0ZXIKKwkJICBUaGUgbGVuZ3RoIG9mIHRpbWUgdG8gcnVu IHRoZSB0ZXN0IGJlZm9yZSBwYXVzaW5nIGZvciB0aGlzCiAJCSAgc2FtZSBwZXJpb2Qgb2YgdGlt ZS4gIERlZmF1bHRzIHRvICJzdHV0dGVyPTUiLCBzbyBhcwogCQkgIHRvIHJ1biBhbmQgcGF1c2Ug Zm9yIChyb3VnaGx5KSBmaXZlLXNlY29uZCBpbnRlcnZhbHMuCiAJCSAgU3BlY2lmeWluZyAic3R1 dHRlcj0wIiBjYXVzZXMgdGhlIHRlc3QgdG8gcnVuIGNvbnRpbnVvdXNseQogCQkgIHdpdGhvdXQg cGF1c2luZywgd2hpY2ggaXMgdGhlIG9sZCBkZWZhdWx0IGJlaGF2aW9yLgogCi1zaHVmZmxlX2lu dGVydmFsICBUaGUgbnVtYmVyIG9mIHNlY29uZHMgdG8ga2VlcCB0aGUgdGVzdCB0aHJlYWRzIGFm ZmluaXRpZWQKK3NodWZmbGVfaW50ZXJ2YWwKKwkJICBUaGUgbnVtYmVyIG9mIHNlY29uZHMgdG8g a2VlcCB0aGUgdGVzdCB0aHJlYWRzIGFmZmluaXRpZWQKIAkJICB0byBhIHBhcnRpY3VsYXIgc3Vi c2V0IG9mIHRoZSBDUFVzLCBkZWZhdWx0cyB0byAzIHNlY29uZHMuCiAJCSAgVXNlZCBpbiBjb25q dW5jdGlvbiB3aXRoIHRlc3Rfbm9faWRsZV9oei4KIAotdmVyYm9zZQkJICBFbmFibGUgdmVyYm9z ZSBkZWJ1Z2dpbmcgcHJpbnRpbmcsIHZpYSBwcmludGsoKS4gRW5hYmxlZAordmVyYm9zZQorCQkg IEVuYWJsZSB2ZXJib3NlIGRlYnVnZ2luZyBwcmludGluZywgdmlhIHByaW50aygpLiBFbmFibGVk CiAJCSAgYnkgZGVmYXVsdC4gVGhpcyBleHRyYSBpbmZvcm1hdGlvbiBpcyBtb3N0bHkgcmVsYXRl ZCB0bwogCQkgIGhpZ2gtbGV2ZWwgZXJyb3JzIGFuZCByZXBvcnRzIGZyb20gdGhlIG1haW4gJ3Rv cnR1cmUnCiAJCSAgZnJhbWV3b3JrLgogCiAKLVNUQVRJU1RJQ1MKK1N0YXRpc3RpY3MKKz09PT09 PT09PT0KIAotU3RhdGlzdGljcyBhcmUgcHJpbnRlZCBpbiB0aGUgZm9sbG93aW5nIGZvcm1hdDoK K1N0YXRpc3RpY3MgYXJlIHByaW50ZWQgaW4gdGhlIGZvbGxvd2luZyBmb3JtYXQ6OgogCi1zcGlu X2xvY2stdG9ydHVyZTogV3JpdGVzOiAgVG90YWw6IDkzNzQ2MDY0ICBNYXgvTWluOiAwLzAgICBG YWlsOiAwCi0gICAoQSkJCSAgICAoQikJCSAgIChDKQkJICAoRCkJICAgICAgIChFKQorICBzcGlu X2xvY2stdG9ydHVyZTogV3JpdGVzOiAgVG90YWw6IDkzNzQ2MDY0ICBNYXgvTWluOiAwLzAgICBG YWlsOiAwCisgICAgIChBKQkJICAgIChCKQkJICAgKEMpCQkgIChEKQkgICAgICAgKEUpCiAKLShB KTogTG9jayB0eXBlIHRoYXQgaXMgYmVpbmcgdG9ydHVyZWQgLS0gdG9ydHVyZV90eXBlIHBhcmFt ZXRlci4KKyAgKEEpOiBMb2NrIHR5cGUgdGhhdCBpcyBiZWluZyB0b3J0dXJlZCAtLSB0b3J0dXJl X3R5cGUgcGFyYW1ldGVyLgogCi0oQik6IE51bWJlciBvZiB3cml0ZXIgbG9jayBhY3F1aXNpdGlv bnMuIElmIGRlYWxpbmcgd2l0aCBhIHJlYWQvd3JpdGUgcHJpbWl0aXZlCi0gICAgIGEgc2Vjb25k ICJSZWFkcyIgc3RhdGlzdGljcyBsaW5lIGlzIHByaW50ZWQuCisgIChCKTogTnVtYmVyIG9mIHdy aXRlciBsb2NrIGFjcXVpc2l0aW9ucy4gSWYgZGVhbGluZyB3aXRoIGEgcmVhZC93cml0ZQorICAg ICAgIHByaW1pdGl2ZSBhIHNlY29uZCAiUmVhZHMiIHN0YXRpc3RpY3MgbGluZSBpcyBwcmludGVk LgogCi0oQyk6IE51bWJlciBvZiB0aW1lcyB0aGUgbG9jayB3YXMgYWNxdWlyZWQuCisgIChDKTog TnVtYmVyIG9mIHRpbWVzIHRoZSBsb2NrIHdhcyBhY3F1aXJlZC4KIAotKEQpOiBNaW4gYW5kIG1h eCBudW1iZXIgb2YgdGltZXMgdGhyZWFkcyBmYWlsZWQgdG8gYWNxdWlyZSB0aGUgbG9jay4KKyAg KEQpOiBNaW4gYW5kIG1heCBudW1iZXIgb2YgdGltZXMgdGhyZWFkcyBmYWlsZWQgdG8gYWNxdWly ZSB0aGUgbG9jay4KIAotKEUpOiB0cnVlL2ZhbHNlIHZhbHVlcyBpZiB0aGVyZSB3ZXJlIGVycm9y cyBhY3F1aXJpbmcgdGhlIGxvY2suIFRoaXMgc2hvdWxkCi0gICAgIC1vbmx5LSBiZSBwb3NpdGl2 ZSBpZiB0aGVyZSBpcyBhIGJ1ZyBpbiB0aGUgbG9ja2luZyBwcmltaXRpdmUncwotICAgICBpbXBs ZW1lbnRhdGlvbi4gT3RoZXJ3aXNlIGEgbG9jayBzaG91bGQgbmV2ZXIgZmFpbCAoaS5lLiwgc3Bp bl9sb2NrKCkpLgotICAgICBPZiBjb3Vyc2UsIHRoZSBzYW1lIGFwcGxpZXMgZm9yIChDKSwgYWJv dmUuIEEgZHVtbXkgZXhhbXBsZSBvZiB0aGlzIGlzCi0gICAgIHRoZSAibG9ja19idXN0ZWQiIHR5 cGUuCisgIChFKTogdHJ1ZS9mYWxzZSB2YWx1ZXMgaWYgdGhlcmUgd2VyZSBlcnJvcnMgYWNxdWly aW5nIHRoZSBsb2NrLiBUaGlzIHNob3VsZAorICAgICAgIC1vbmx5LSBiZSBwb3NpdGl2ZSBpZiB0 aGVyZSBpcyBhIGJ1ZyBpbiB0aGUgbG9ja2luZyBwcmltaXRpdmUncworICAgICAgIGltcGxlbWVu dGF0aW9uLiBPdGhlcndpc2UgYSBsb2NrIHNob3VsZCBuZXZlciBmYWlsIChpLmUuLCBzcGluX2xv Y2soKSkuCisgICAgICAgT2YgY291cnNlLCB0aGUgc2FtZSBhcHBsaWVzIGZvciAoQyksIGFib3Zl LiBBIGR1bW15IGV4YW1wbGUgb2YgdGhpcyBpcworICAgICAgIHRoZSAibG9ja19idXN0ZWQiIHR5 cGUuCiAKLVVTQUdFCitVc2FnZQorPT09PT0KIAotVGhlIGZvbGxvd2luZyBzY3JpcHQgbWF5IGJl IHVzZWQgdG8gdG9ydHVyZSBsb2NrczoKK1RoZSBmb2xsb3dpbmcgc2NyaXB0IG1heSBiZSB1c2Vk IHRvIHRvcnR1cmUgbG9ja3M6OgogCiAJIyEvYmluL3NoCiAKZGlmZiAtLWdpdCBhL0RvY3VtZW50 YXRpb24vbG9ja2luZy9tdXRleC1kZXNpZ24udHh0IGIvRG9jdW1lbnRhdGlvbi9sb2NraW5nL211 dGV4LWRlc2lnbi5yc3QKc2ltaWxhcml0eSBpbmRleCA5NCUKcmVuYW1lIGZyb20gRG9jdW1lbnRh dGlvbi9sb2NraW5nL211dGV4LWRlc2lnbi50eHQKcmVuYW1lIHRvIERvY3VtZW50YXRpb24vbG9j a2luZy9tdXRleC1kZXNpZ24ucnN0CmluZGV4IDgxOGFjYTE5NjEyZi4uNGQ4MjM2YjgxZmE1IDEw MDY0NAotLS0gYS9Eb2N1bWVudGF0aW9uL2xvY2tpbmcvbXV0ZXgtZGVzaWduLnR4dAorKysgYi9E b2N1bWVudGF0aW9uL2xvY2tpbmcvbXV0ZXgtZGVzaWduLnJzdApAQCAtMSw2ICsxLDkgQEAKKz09 PT09PT09PT09PT09PT09PT09PT09CiBHZW5lcmljIE11dGV4IFN1YnN5c3RlbQorPT09PT09PT09 PT09PT09PT09PT09PT0KIAogc3RhcnRlZCBieSBJbmdvIE1vbG5hciA8bWluZ29AcmVkaGF0LmNv bT4KKwogdXBkYXRlZCBieSBEYXZpZGxvaHIgQnVlc28gPGRhdmlkbG9ockBocC5jb20+CiAKIFdo YXQgYXJlIG11dGV4ZXM/CkBAIC0yMyw3ICsyNiw3IEBAIEltcGxlbWVudGF0aW9uCiBNdXRleGVz IGFyZSByZXByZXNlbnRlZCBieSAnc3RydWN0IG11dGV4JywgZGVmaW5lZCBpbiBpbmNsdWRlL2xp bnV4L211dGV4LmgKIGFuZCBpbXBsZW1lbnRlZCBpbiBrZXJuZWwvbG9ja2luZy9tdXRleC5jLiBU aGVzZSBsb2NrcyB1c2UgYW4gYXRvbWljIHZhcmlhYmxlCiAoLT5vd25lcikgdG8ga2VlcCB0cmFj ayBvZiB0aGUgbG9jayBzdGF0ZSBkdXJpbmcgaXRzIGxpZmV0aW1lLiAgRmllbGQgb3duZXIKLWFj dHVhbGx5IGNvbnRhaW5zICdzdHJ1Y3QgdGFza19zdHJ1Y3QgKicgdG8gdGhlIGN1cnJlbnQgbG9j ayBvd25lciBhbmQgaXQgaXMKK2FjdHVhbGx5IGNvbnRhaW5zIGBzdHJ1Y3QgdGFza19zdHJ1Y3Qg KmAgdG8gdGhlIGN1cnJlbnQgbG9jayBvd25lciBhbmQgaXQgaXMKIHRoZXJlZm9yZSBOVUxMIGlm IG5vdCBjdXJyZW50bHkgb3duZWQuIFNpbmNlIHRhc2tfc3RydWN0IHBvaW50ZXJzIGFyZSBhbGln bmVkCiBhdCBhdCBsZWFzdCBMMV9DQUNIRV9CWVRFUywgbG93IGJpdHMgKDMpIGFyZSB1c2VkIHRv IHN0b3JlIGV4dHJhIHN0YXRlIChlLmcuLAogaWYgd2FpdGVyIGxpc3QgaXMgbm9uLWVtcHR5KS4g IEluIGl0cyBtb3N0IGJhc2ljIGZvcm0gaXQgYWxzbyBpbmNsdWRlcyBhCkBAIC0xMDEsMjkgKzEw NCwzNiBAQCBmZWF0dXJlcyB0aGF0IG1ha2UgbG9jayBkZWJ1Z2dpbmcgZWFzaWVyIGFuZCBmYXN0 ZXI6CiAKIEludGVyZmFjZXMKIC0tLS0tLS0tLS0KLVN0YXRpY2FsbHkgZGVmaW5lIHRoZSBtdXRl eDoKK1N0YXRpY2FsbHkgZGVmaW5lIHRoZSBtdXRleDo6CisKICAgIERFRklORV9NVVRFWChuYW1l KTsKIAotRHluYW1pY2FsbHkgaW5pdGlhbGl6ZSB0aGUgbXV0ZXg6CitEeW5hbWljYWxseSBpbml0 aWFsaXplIHRoZSBtdXRleDo6CisKICAgIG11dGV4X2luaXQobXV0ZXgpOwogCi1BY3F1aXJlIHRo ZSBtdXRleCwgdW5pbnRlcnJ1cHRpYmxlOgorQWNxdWlyZSB0aGUgbXV0ZXgsIHVuaW50ZXJydXB0 aWJsZTo6CisKICAgIHZvaWQgbXV0ZXhfbG9jayhzdHJ1Y3QgbXV0ZXggKmxvY2spOwogICAgdm9p ZCBtdXRleF9sb2NrX25lc3RlZChzdHJ1Y3QgbXV0ZXggKmxvY2ssIHVuc2lnbmVkIGludCBzdWJj bGFzcyk7CiAgICBpbnQgIG11dGV4X3RyeWxvY2soc3RydWN0IG11dGV4ICpsb2NrKTsKIAotQWNx dWlyZSB0aGUgbXV0ZXgsIGludGVycnVwdGlibGU6CitBY3F1aXJlIHRoZSBtdXRleCwgaW50ZXJy dXB0aWJsZTo6CisKICAgIGludCBtdXRleF9sb2NrX2ludGVycnVwdGlibGVfbmVzdGVkKHN0cnVj dCBtdXRleCAqbG9jaywKIAkJCQkgICAgICAgdW5zaWduZWQgaW50IHN1YmNsYXNzKTsKICAgIGlu dCBtdXRleF9sb2NrX2ludGVycnVwdGlibGUoc3RydWN0IG11dGV4ICpsb2NrKTsKIAotQWNxdWly ZSB0aGUgbXV0ZXgsIGludGVycnVwdGlibGUsIGlmIGRlYyB0byAwOgorQWNxdWlyZSB0aGUgbXV0 ZXgsIGludGVycnVwdGlibGUsIGlmIGRlYyB0byAwOjoKKwogICAgaW50IGF0b21pY19kZWNfYW5k X211dGV4X2xvY2soYXRvbWljX3QgKmNudCwgc3RydWN0IG11dGV4ICpsb2NrKTsKIAotVW5sb2Nr IHRoZSBtdXRleDoKK1VubG9jayB0aGUgbXV0ZXg6OgorCiAgICB2b2lkIG11dGV4X3VubG9jayhz dHJ1Y3QgbXV0ZXggKmxvY2spOwogCi1UZXN0IGlmIHRoZSBtdXRleCBpcyB0YWtlbjoKK1Rlc3Qg aWYgdGhlIG11dGV4IGlzIHRha2VuOjoKKwogICAgaW50IG11dGV4X2lzX2xvY2tlZChzdHJ1Y3Qg bXV0ZXggKmxvY2spOwogCiBEaXNhZHZhbnRhZ2VzCmRpZmYgLS1naXQgYS9Eb2N1bWVudGF0aW9u L2xvY2tpbmcvcnQtbXV0ZXgtZGVzaWduLnR4dCBiL0RvY3VtZW50YXRpb24vbG9ja2luZy9ydC1t dXRleC1kZXNpZ24ucnN0CnNpbWlsYXJpdHkgaW5kZXggOTElCnJlbmFtZSBmcm9tIERvY3VtZW50 YXRpb24vbG9ja2luZy9ydC1tdXRleC1kZXNpZ24udHh0CnJlbmFtZSB0byBEb2N1bWVudGF0aW9u L2xvY2tpbmcvcnQtbXV0ZXgtZGVzaWduLnJzdAppbmRleCAzZDdiODY1NTM5Y2MuLjU5YzJhNjRl ZmIyMSAxMDA2NDQKLS0tIGEvRG9jdW1lbnRhdGlvbi9sb2NraW5nL3J0LW11dGV4LWRlc2lnbi50 eHQKKysrIGIvRG9jdW1lbnRhdGlvbi9sb2NraW5nL3J0LW11dGV4LWRlc2lnbi5yc3QKQEAgLTEs MTQgKzEsMTUgQEAKLSMKLSMgQ29weXJpZ2h0IChjKSAyMDA2IFN0ZXZlbiBSb3N0ZWR0Ci0jIExp Y2Vuc2VkIHVuZGVyIHRoZSBHTlUgRnJlZSBEb2N1bWVudGF0aW9uIExpY2Vuc2UsIFZlcnNpb24g MS4yCi0jCi0KKz09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQogUlQtbXV0ZXggaW1wbGVt ZW50YXRpb24gZGVzaWduCi0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0KKz09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PQorCitDb3B5cmlnaHQgKGMpIDIwMDYgU3RldmVuIFJvc3Rl ZHQKKworTGljZW5zZWQgdW5kZXIgdGhlIEdOVSBGcmVlIERvY3VtZW50YXRpb24gTGljZW5zZSwg VmVyc2lvbiAxLjIKKwogCiBUaGlzIGRvY3VtZW50IHRyaWVzIHRvIGRlc2NyaWJlIHRoZSBkZXNp Z24gb2YgdGhlIHJ0bXV0ZXguYyBpbXBsZW1lbnRhdGlvbi4KIEl0IGRvZXNuJ3QgZGVzY3JpYmUg dGhlIHJlYXNvbnMgd2h5IHJ0bXV0ZXguYyBleGlzdHMuIEZvciB0aGF0IHBsZWFzZSBzZWUKLURv Y3VtZW50YXRpb24vbG9ja2luZy9ydC1tdXRleC50eHQuICBBbHRob3VnaCB0aGlzIGRvY3VtZW50 IGRvZXMgZXhwbGFpbiBwcm9ibGVtcworRG9jdW1lbnRhdGlvbi9sb2NraW5nL3J0LW11dGV4LnJz dC4gIEFsdGhvdWdoIHRoaXMgZG9jdW1lbnQgZG9lcyBleHBsYWluIHByb2JsZW1zCiB0aGF0IGhh cHBlbiB3aXRob3V0IHRoaXMgY29kZSwgYnV0IHRoYXQgaXMgaW4gdGhlIGNvbmNlcHQgdG8gdW5k ZXJzdGFuZAogd2hhdCB0aGUgY29kZSBhY3R1YWxseSBpcyBkb2luZy4KIApAQCAtNDEsMTcgKzQy LDE3IEBAIHRvIHJlbGVhc2UgdGhlIGxvY2ssIGJlY2F1c2UgZm9yIGFsbCB3ZSBrbm93LCBCIGlz IGEgQ1BVIGhvZyBhbmQgd2lsbAogbmV2ZXIgZ2l2ZSBDIGEgY2hhbmNlIHRvIHJlbGVhc2UgdGhl IGxvY2suICBUaGlzIGlzIGNhbGxlZCB1bmJvdW5kZWQgcHJpb3JpdHkKIGludmVyc2lvbi4KIAot SGVyZSdzIGEgbGl0dGxlIEFTQ0lJIGFydCB0byBzaG93IHRoZSBwcm9ibGVtLgorSGVyZSdzIGEg bGl0dGxlIEFTQ0lJIGFydCB0byBzaG93IHRoZSBwcm9ibGVtOjoKIAotICAgZ3JhYiBsb2NrIEwx IChvd25lZCBieSBDKQotICAgICB8Ci1BIC0tLSsKLSAgICAgICAgQyBwcmVlbXB0ZWQgYnkgQgot ICAgICAgICAgIHwKLUMgICAgKy0tLS0rCisgICAgIGdyYWIgbG9jayBMMSAob3duZWQgYnkgQykK KyAgICAgICB8CisgIEEgLS0tKworICAgICAgICAgIEMgcHJlZW1wdGVkIGJ5IEIKKyAgICAgICAg ICAgIHwKKyAgQyAgICArLS0tLSsKIAotQiAgICAgICAgICstLS0tLS0tLT4KLSAgICAgICAgICAg ICAgICBCIG5vdyBrZWVwcyBBIGZyb20gcnVubmluZy4KKyAgQiAgICAgICAgICstLS0tLS0tLT4K KyAgICAgICAgICAgICAgICAgIEIgbm93IGtlZXBzIEEgZnJvbSBydW5uaW5nLgogCiAKIFByaW9y aXR5IEluaGVyaXRhbmNlIChQSSkKQEAgLTc1LDI0ICs3NiwyOSBAQCBUZXJtaW5vbG9neQogSGVy ZSBJIGV4cGxhaW4gc29tZSB0ZXJtaW5vbG9neSB0aGF0IGlzIHVzZWQgaW4gdGhpcyBkb2N1bWVu dCB0byBoZWxwIGRlc2NyaWJlCiB0aGUgZGVzaWduIHRoYXQgaXMgdXNlZCB0byBpbXBsZW1lbnQg UEkuCiAKLVBJIGNoYWluIC0gVGhlIFBJIGNoYWluIGlzIGFuIG9yZGVyZWQgc2VyaWVzIG9mIGxv Y2tzIGFuZCBwcm9jZXNzZXMgdGhhdCBjYXVzZQorUEkgY2hhaW4KKyAgICAgICAgIC0gVGhlIFBJ IGNoYWluIGlzIGFuIG9yZGVyZWQgc2VyaWVzIG9mIGxvY2tzIGFuZCBwcm9jZXNzZXMgdGhhdCBj YXVzZQogICAgICAgICAgICBwcm9jZXNzZXMgdG8gaW5oZXJpdCBwcmlvcml0aWVzIGZyb20gYSBw cmV2aW91cyBwcm9jZXNzIHRoYXQgaXMKICAgICAgICAgICAgYmxvY2tlZCBvbiBvbmUgb2YgaXRz IGxvY2tzLiAgVGhpcyBpcyBkZXNjcmliZWQgaW4gbW9yZSBkZXRhaWwKICAgICAgICAgICAgbGF0 ZXIgaW4gdGhpcyBkb2N1bWVudC4KIAotbXV0ZXggICAgLSBJbiB0aGlzIGRvY3VtZW50LCB0byBk aWZmZXJlbnRpYXRlIGZyb20gbG9ja3MgdGhhdCBpbXBsZW1lbnQKK211dGV4CisgICAgICAgICAt IEluIHRoaXMgZG9jdW1lbnQsIHRvIGRpZmZlcmVudGlhdGUgZnJvbSBsb2NrcyB0aGF0IGltcGxl bWVudAogICAgICAgICAgICBQSSBhbmQgc3BpbiBsb2NrcyB0aGF0IGFyZSB1c2VkIGluIHRoZSBQ SSBjb2RlLCBmcm9tIG5vdyBvbgogICAgICAgICAgICB0aGUgUEkgbG9ja3Mgd2lsbCBiZSBjYWxs ZWQgYSBtdXRleC4KIAotbG9jayAgICAgLSBJbiB0aGlzIGRvY3VtZW50IGZyb20gbm93IG9uLCBJ IHdpbGwgdXNlIHRoZSB0ZXJtIGxvY2sgd2hlbgorbG9jaworICAgICAgICAgLSBJbiB0aGlzIGRv Y3VtZW50IGZyb20gbm93IG9uLCBJIHdpbGwgdXNlIHRoZSB0ZXJtIGxvY2sgd2hlbgogICAgICAg ICAgICByZWZlcnJpbmcgdG8gc3BpbiBsb2NrcyB0aGF0IGFyZSB1c2VkIHRvIHByb3RlY3QgcGFy dHMgb2YgdGhlIFBJCiAgICAgICAgICAgIGFsZ29yaXRobS4gIFRoZXNlIGxvY2tzIGRpc2FibGUg cHJlZW1wdGlvbiBmb3IgVVAgKHdoZW4KICAgICAgICAgICAgQ09ORklHX1BSRUVNUFQgaXMgZW5h YmxlZCkgYW5kIG9uIFNNUCBwcmV2ZW50cyBtdWx0aXBsZSBDUFVzIGZyb20KICAgICAgICAgICAg ZW50ZXJpbmcgY3JpdGljYWwgc2VjdGlvbnMgc2ltdWx0YW5lb3VzbHkuCiAKLXNwaW4gbG9jayAt IFNhbWUgYXMgbG9jayBhYm92ZS4KK3NwaW4gbG9jaworICAgICAgICAgLSBTYW1lIGFzIGxvY2sg YWJvdmUuCiAKLXdhaXRlciAgIC0gQSB3YWl0ZXIgaXMgYSBzdHJ1Y3QgdGhhdCBpcyBzdG9yZWQg b24gdGhlIHN0YWNrIG9mIGEgYmxvY2tlZAord2FpdGVyCisgICAgICAgICAtIEEgd2FpdGVyIGlz IGEgc3RydWN0IHRoYXQgaXMgc3RvcmVkIG9uIHRoZSBzdGFjayBvZiBhIGJsb2NrZWQKICAgICAg ICAgICAgcHJvY2Vzcy4gIFNpbmNlIHRoZSBzY29wZSBvZiB0aGUgd2FpdGVyIGlzIHdpdGhpbiB0 aGUgY29kZSBmb3IKICAgICAgICAgICAgYSBwcm9jZXNzIGJlaW5nIGJsb2NrZWQgb24gdGhlIG11 dGV4LCBpdCBpcyBmaW5lIHRvIGFsbG9jYXRlCiAgICAgICAgICAgIHRoZSB3YWl0ZXIgb24gdGhl IHByb2Nlc3MncyBzdGFjayAobG9jYWwgdmFyaWFibGUpLiAgVGhpcwpAQCAtMTA0LDE0ICsxMTAs MTggQEAgd2FpdGVyICAgLSBBIHdhaXRlciBpcyBhIHN0cnVjdCB0aGF0IGlzIHN0b3JlZCBvbiB0 aGUgc3RhY2sgb2YgYSBibG9ja2VkCiAgICAgICAgICAgIHdhaXRlciBpcyBzb21ldGltZXMgdXNl ZCBpbiByZWZlcmVuY2UgdG8gdGhlIHRhc2sgdGhhdCBpcyB3YWl0aW5nCiAgICAgICAgICAgIG9u IGEgbXV0ZXguIFRoaXMgaXMgdGhlIHNhbWUgYXMgd2FpdGVyLT50YXNrLgogCi13YWl0ZXJzICAt IEEgbGlzdCBvZiBwcm9jZXNzZXMgdGhhdCBhcmUgYmxvY2tlZCBvbiBhIG11dGV4Lgord2FpdGVy cworICAgICAgICAgLSBBIGxpc3Qgb2YgcHJvY2Vzc2VzIHRoYXQgYXJlIGJsb2NrZWQgb24gYSBt dXRleC4KIAotdG9wIHdhaXRlciAtIFRoZSBoaWdoZXN0IHByaW9yaXR5IHByb2Nlc3Mgd2FpdGlu ZyBvbiBhIHNwZWNpZmljIG11dGV4LgordG9wIHdhaXRlcgorICAgICAgICAgLSBUaGUgaGlnaGVz dCBwcmlvcml0eSBwcm9jZXNzIHdhaXRpbmcgb24gYSBzcGVjaWZpYyBtdXRleC4KIAotdG9wIHBp IHdhaXRlciAtIFRoZSBoaWdoZXN0IHByaW9yaXR5IHByb2Nlc3Mgd2FpdGluZyBvbiBvbmUgb2Yg dGhlIG11dGV4ZXMKK3RvcCBwaSB3YWl0ZXIKKyAgICAgICAgICAgICAgLSBUaGUgaGlnaGVzdCBw cmlvcml0eSBwcm9jZXNzIHdhaXRpbmcgb24gb25lIG9mIHRoZSBtdXRleGVzCiAgICAgICAgICAg ICAgICAgdGhhdCBhIHNwZWNpZmljIHByb2Nlc3Mgb3ducy4KIAotTm90ZTogIHRhc2sgYW5kIHBy b2Nlc3MgYXJlIHVzZWQgaW50ZXJjaGFuZ2VhYmx5IGluIHRoaXMgZG9jdW1lbnQsIG1vc3RseSB0 bworTm90ZToKKyAgICAgICB0YXNrIGFuZCBwcm9jZXNzIGFyZSB1c2VkIGludGVyY2hhbmdlYWJs eSBpbiB0aGlzIGRvY3VtZW50LCBtb3N0bHkgdG8KICAgICAgICBkaWZmZXJlbnRpYXRlIGJldHdl ZW4gdHdvIHByb2Nlc3NlcyB0aGF0IGFyZSBiZWluZyBkZXNjcmliZWQgdG9nZXRoZXIuCiAKIApA QCAtMTIzLDcgKzEzMyw3IEBAIGluaGVyaXRhbmNlIHRvIHRha2UgcGxhY2UuICBNdWx0aXBsZSBj aGFpbnMgbWF5IGNvbnZlcmdlLCBidXQgYSBjaGFpbgogd291bGQgbmV2ZXIgZGl2ZXJnZSwgc2lu Y2UgYSBwcm9jZXNzIGNhbid0IGJlIGJsb2NrZWQgb24gbW9yZSB0aGFuIG9uZQogbXV0ZXggYXQg YSB0aW1lLgogCi1FeGFtcGxlOgorRXhhbXBsZTo6CiAKICAgIFByb2Nlc3M6ICBBLCBCLCBDLCBE LCBFCiAgICBNdXRleGVzOiAgTDEsIEwyLCBMMywgTDQKQEAgLTEzNywyMSArMTQ3LDIxIEBAIEV4 YW1wbGU6CiAgICAgICAgICAgICAgICAgICAgICAgICAgRCBvd25zIEw0CiAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgIEUgYmxvY2tlZCBvbiBMNAogCi1UaGUgY2hhaW4gd291bGQgYmU6 CitUaGUgY2hhaW4gd291bGQgYmU6OgogCiAgICBFLT5MNC0+RC0+TDMtPkMtPkwyLT5CLT5MMS0+ QQogCiBUbyBzaG93IHdoZXJlIHR3byBjaGFpbnMgbWVyZ2UsIHdlIGNvdWxkIGFkZCBhbm90aGVy IHByb2Nlc3MgRiBhbmQKIGFub3RoZXIgbXV0ZXggTDUgd2hlcmUgQiBvd25zIEw1IGFuZCBGIGlz IGJsb2NrZWQgb24gbXV0ZXggTDUuCiAKLVRoZSBjaGFpbiBmb3IgRiB3b3VsZCBiZToKK1RoZSBj aGFpbiBmb3IgRiB3b3VsZCBiZTo6CiAKICAgIEYtPkw1LT5CLT5MMS0+QQogCiBTaW5jZSBhIHBy b2Nlc3MgbWF5IG93biBtb3JlIHRoYW4gb25lIG11dGV4LCBidXQgbmV2ZXIgYmUgYmxvY2tlZCBv biBtb3JlIHRoYW4KIG9uZSwgdGhlIGNoYWlucyBtZXJnZS4KIAotSGVyZSB3ZSBzaG93IGJvdGgg Y2hhaW5zOgorSGVyZSB3ZSBzaG93IGJvdGggY2hhaW5zOjoKIAogICAgRS0+TDQtPkQtPkwzLT5D LT5MMi0rCiAgICAgICAgICAgICAgICAgICAgICAgIHwKQEAgLTE2NSwxMiArMTc1LDEyIEBAIHRo YW4gdGhlIHByb2Nlc3NlcyB0byB0aGUgbGVmdCBvciBiZWxvdyBpbiB0aGUgY2hhaW4uCiAKIEFs c28gc2luY2UgYSBtdXRleCBtYXkgaGF2ZSBtb3JlIHRoYW4gb25lIHByb2Nlc3MgYmxvY2tlZCBv biBpdCwgd2UgY2FuCiBoYXZlIG11bHRpcGxlIGNoYWlucyBtZXJnZSBhdCBtdXRleGVzLiAgSWYg d2UgYWRkIGFub3RoZXIgcHJvY2VzcyBHIHRoYXQgaXMKLWJsb2NrZWQgb24gbXV0ZXggTDI6Citi bG9ja2VkIG9uIG11dGV4IEwyOjoKIAogICBHLT5MMi0+Qi0+TDEtPkEKIAogQW5kIG9uY2UgYWdh aW4sIHRvIHNob3cgaG93IHRoaXMgY2FuIGdyb3cgSSB3aWxsIHNob3cgdGhlIG1lcmdpbmcgY2hh aW5zCi1hZ2Fpbi4KK2FnYWluOjoKIAogICAgRS0+TDQtPkQtPkwzLT5DLSsKICAgICAgICAgICAg ICAgICAgICArLT5MMi0rCkBAIC0xODQsNyArMTk0LDcgQEAgdGhlIGNoYWluIChBIGFuZCBCIGlu IHRoaXMgZXhhbXBsZSksIG11c3QgaGF2ZSB0aGVpciBwcmlvcml0aWVzIGluY3JlYXNlZAogdG8g dGhhdCBvZiBHLgogCiBNdXRleCBXYWl0ZXJzIFRyZWUKLS0tLS0tLS0tLS0tLS0tLS0tCistLS0t LS0tLS0tLS0tLS0tLS0KIAogRXZlcnkgbXV0ZXgga2VlcHMgdHJhY2sgb2YgYWxsIHRoZSB3YWl0 ZXJzIHRoYXQgYXJlIGJsb2NrZWQgb24gaXRzZWxmLiBUaGUKIG11dGV4IGhhcyBhIHJidHJlZSB0 byBzdG9yZSB0aGVzZSB3YWl0ZXJzIGJ5IHByaW9yaXR5LiAgVGhpcyB0cmVlIGlzIHByb3RlY3Rl ZApAQCAtMjE5LDE5ICsyMjksMTkgQEAgZGVmaW5lZC4gIEJ1dCBpcyB2ZXJ5IGNvbXBsZXggdG8g ZmlndXJlIGl0IG91dCwgc2luY2UgaXQgZGVwZW5kcyBvbiBhbGwKIHRoZSBuZXN0aW5nIG9mIG11 dGV4ZXMuICBMZXQncyBsb29rIGF0IHRoZSBleGFtcGxlIHdoZXJlIHdlIGhhdmUgMyBtdXRleGVz LAogTDEsIEwyLCBhbmQgTDMsIGFuZCBmb3VyIHNlcGFyYXRlIGZ1bmN0aW9ucyBmdW5jMSwgZnVu YzIsIGZ1bmMzIGFuZCBmdW5jNC4KIFRoZSBmb2xsb3dpbmcgc2hvd3MgYSBsb2NraW5nIG9yZGVy IG9mIEwxLT5MMi0+TDMsIGJ1dCBtYXkgbm90IGFjdHVhbGx5Ci1iZSBkaXJlY3RseSBuZXN0ZWQg dGhhdCB3YXkuCitiZSBkaXJlY3RseSBuZXN0ZWQgdGhhdCB3YXk6OgogCi12b2lkIGZ1bmMxKHZv aWQpCi17CisgIHZvaWQgZnVuYzEodm9pZCkKKyAgewogCW11dGV4X2xvY2soTDEpOwogCiAJLyog ZG8gYW55dGhpbmcgKi8KIAogCW11dGV4X3VubG9jayhMMSk7Ci19CisgIH0KIAotdm9pZCBmdW5j Mih2b2lkKQoteworICB2b2lkIGZ1bmMyKHZvaWQpCisgIHsKIAltdXRleF9sb2NrKEwxKTsKIAlt dXRleF9sb2NrKEwyKTsKIApAQCAtMjM5LDEwICsyNDksMTAgQEAgdm9pZCBmdW5jMih2b2lkKQog CiAJbXV0ZXhfdW5sb2NrKEwyKTsKIAltdXRleF91bmxvY2soTDEpOwotfQorICB9CiAKLXZvaWQg ZnVuYzModm9pZCkKLXsKKyAgdm9pZCBmdW5jMyh2b2lkKQorICB7CiAJbXV0ZXhfbG9jayhMMik7 CiAJbXV0ZXhfbG9jayhMMyk7CiAKQEAgLTI1MCwzMCArMjYwLDMwIEBAIHZvaWQgZnVuYzModm9p ZCkKIAogCW11dGV4X3VubG9jayhMMyk7CiAJbXV0ZXhfdW5sb2NrKEwyKTsKLX0KKyAgfQogCi12 b2lkIGZ1bmM0KHZvaWQpCi17CisgIHZvaWQgZnVuYzQodm9pZCkKKyAgewogCW11dGV4X2xvY2so TDMpOwogCiAJLyogZG8gc29tZXRoaW5nIGFnYWluICovCiAKIAltdXRleF91bmxvY2soTDMpOwot fQorICB9CiAKIE5vdyB3ZSBhZGQgNCBwcm9jZXNzZXMgdGhhdCBydW4gZWFjaCBvZiB0aGVzZSBm dW5jdGlvbnMgc2VwYXJhdGVseS4KIFByb2Nlc3NlcyBBLCBCLCBDLCBhbmQgRCB3aGljaCBydW4g ZnVuY3Rpb25zIGZ1bmMxLCBmdW5jMiwgZnVuYzMgYW5kIGZ1bmM0CiByZXNwZWN0aXZlbHksIGFu ZCBzdWNoIHRoYXQgRCBydW5zIGZpcnN0IGFuZCBBIGxhc3QuICBXaXRoIEQgYmVpbmcgcHJlZW1w dGVkCi1pbiBmdW5jNCBpbiB0aGUgImRvIHNvbWV0aGluZyBhZ2FpbiIgYXJlYSwgd2UgaGF2ZSBh IGxvY2tpbmcgdGhhdCBmb2xsb3dzOgoraW4gZnVuYzQgaW4gdGhlICJkbyBzb21ldGhpbmcgYWdh aW4iIGFyZWEsIHdlIGhhdmUgYSBsb2NraW5nIHRoYXQgZm9sbG93czo6CiAKLUQgb3ducyBMMwot ICAgICAgIEMgYmxvY2tlZCBvbiBMMwotICAgICAgIEMgb3ducyBMMgotICAgICAgICAgICAgICBC IGJsb2NrZWQgb24gTDIKLSAgICAgICAgICAgICAgQiBvd25zIEwxCi0gICAgICAgICAgICAgICAg ICAgICBBIGJsb2NrZWQgb24gTDEKKyAgRCBvd25zIEwzCisgICAgICAgICBDIGJsb2NrZWQgb24g TDMKKyAgICAgICAgIEMgb3ducyBMMgorICAgICAgICAgICAgICAgIEIgYmxvY2tlZCBvbiBMMgor ICAgICAgICAgICAgICAgIEIgb3ducyBMMQorICAgICAgICAgICAgICAgICAgICAgICBBIGJsb2Nr ZWQgb24gTDEKIAotQW5kIHRodXMgd2UgaGF2ZSB0aGUgY2hhaW4gQS0+TDEtPkItPkwyLT5DLT5M My0+RC4KKyAgQW5kIHRodXMgd2UgaGF2ZSB0aGUgY2hhaW4gQS0+TDEtPkItPkwyLT5DLT5MMy0+ RC4KIAogVGhpcyBnaXZlcyB1cyBhIFBJIGRlcHRoIG9mIDQgKGZvdXIgcHJvY2Vzc2VzKSwgYnV0 IGxvb2tpbmcgYXQgYW55IG9mIHRoZQogZnVuY3Rpb25zIGluZGl2aWR1YWxseSwgaXQgc2VlbXMg YXMgdGhvdWdoIHRoZXkgb25seSBoYXZlIGF0IG1vc3QgYSBsb2NraW5nCkBAIC0yOTgsNyArMzA4 LDcgQEAgbm90IHRydWUsIHRoZSBydG11dGV4LmMgY29kZSB3aWxsIGJlIGJyb2tlbiEpLCB0aGlz IGFsbG93cyBmb3IgdGhlIGxlYXN0CiBzaWduaWZpY2FudCBiaXQgdG8gYmUgdXNlZCBhcyBhIGZs YWcuICBCaXQgMCBpcyB1c2VkIGFzIHRoZSAiSGFzIFdhaXRlcnMiCiBmbGFnLiBJdCdzIHNldCB3 aGVuZXZlciB0aGVyZSBhcmUgd2FpdGVycyBvbiBhIG11dGV4LgogCi1TZWUgRG9jdW1lbnRhdGlv bi9sb2NraW5nL3J0LW11dGV4LnR4dCBmb3IgZnVydGhlciBkZXRhaWxzLgorU2VlIERvY3VtZW50 YXRpb24vbG9ja2luZy9ydC1tdXRleC5yc3QgZm9yIGZ1cnRoZXIgZGV0YWlscy4KIAogY21weGNo ZyBUcmlja3MKIC0tLS0tLS0tLS0tLS0tCkBAIC0zMDcsMTcgKzMxNywxNyBAQCBTb21lIGFyY2hp dGVjdHVyZXMgaW1wbGVtZW50IGFuIGF0b21pYyBjbXB4Y2hnIChDb21wYXJlIGFuZCBFeGNoYW5n ZSkuICBUaGlzCiBpcyB1c2VkICh3aGVuIGFwcGxpY2FibGUpIHRvIGtlZXAgdGhlIGZhc3QgcGF0 aCBvZiBncmFiYmluZyBhbmQgcmVsZWFzaW5nCiBtdXRleGVzIHNob3J0LgogCi1jbXB4Y2hnIGlz IGJhc2ljYWxseSB0aGUgZm9sbG93aW5nIGZ1bmN0aW9uIHBlcmZvcm1lZCBhdG9taWNhbGx5Ogor Y21weGNoZyBpcyBiYXNpY2FsbHkgdGhlIGZvbGxvd2luZyBmdW5jdGlvbiBwZXJmb3JtZWQgYXRv bWljYWxseTo6CiAKLXVuc2lnbmVkIGxvbmcgX2NtcHhjaGcodW5zaWduZWQgbG9uZyAqQSwgdW5z aWduZWQgbG9uZyAqQiwgdW5zaWduZWQgbG9uZyAqQykKLXsKKyAgdW5zaWduZWQgbG9uZyBfY21w eGNoZyh1bnNpZ25lZCBsb25nICpBLCB1bnNpZ25lZCBsb25nICpCLCB1bnNpZ25lZCBsb25nICpD KQorICB7CiAJdW5zaWduZWQgbG9uZyBUID0gKkE7CiAJaWYgKCpBID09ICpCKSB7CiAJCSpBID0g KkM7CiAJfQogCXJldHVybiBUOwotfQotI2RlZmluZSBjbXB4Y2hnKGEsYixjKSBfY21weGNoZygm YSwmYiwmYykKKyAgfQorICAjZGVmaW5lIGNtcHhjaGcoYSxiLGMpIF9jbXB4Y2hnKCZhLCZiLCZj KQogCiBUaGlzIGlzIHJlYWxseSBuaWNlIHRvIGhhdmUsIHNpbmNlIGl0IGFsbG93cyB5b3UgdG8g b25seSB1cGRhdGUgYSB2YXJpYWJsZQogaWYgdGhlIHZhcmlhYmxlIGlzIHdoYXQgeW91IGV4cGVj dCBpdCB0byBiZS4gIFlvdSBrbm93IGlmIGl0IHN1Y2NlZWRlZCBpZgpAQCAtMzUyLDkgKzM2Miwx MCBAQCBUaGVuIHJ0X211dGV4X3NldHByaW8gaXMgY2FsbGVkIHRvIGFkanVzdCB0aGUgcHJpb3Jp dHkgb2YgdGhlIHRhc2sgdG8gdGhlCiBuZXcgcHJpb3JpdHkuIE5vdGUgdGhhdCBydF9tdXRleF9z ZXRwcmlvIGlzIGRlZmluZWQgaW4ga2VybmVsL3NjaGVkL2NvcmUuYwogdG8gaW1wbGVtZW50IHRo ZSBhY3R1YWwgY2hhbmdlIGluIHByaW9yaXR5LgogCi0oTm90ZTogIEZvciB0aGUgInByaW8iIGZp ZWxkIGluIHRhc2tfc3RydWN0LCB0aGUgbG93ZXIgdGhlIG51bWJlciwgdGhlCitOb3RlOgorCUZv ciB0aGUgInByaW8iIGZpZWxkIGluIHRhc2tfc3RydWN0LCB0aGUgbG93ZXIgdGhlIG51bWJlciwg dGhlCiAJaGlnaGVyIHRoZSBwcmlvcml0eS4gQSAicHJpbyIgb2YgNSBpcyBvZiBoaWdoZXIgcHJp b3JpdHkgdGhhbiBhCi0JInByaW8iIG9mIDEwLikKKwkicHJpbyIgb2YgMTAuCiAKIEl0IGlzIGlu dGVyZXN0aW5nIHRvIG5vdGUgdGhhdCBydF9tdXRleF9hZGp1c3RfcHJpbyBjYW4gZWl0aGVyIGlu Y3JlYXNlCiBvciBkZWNyZWFzZSB0aGUgcHJpb3JpdHkgb2YgdGhlIHRhc2suICBJbiB0aGUgY2Fz ZSB0aGF0IGEgaGlnaGVyIHByaW9yaXR5CkBAIC00MzksNiArNDUwLDcgQEAgd2FpdF9sb2NrLCB3 aGljaCB0aGlzIGNvZGUgY3VycmVudGx5IGhvbGRzLiBTbyBzZXR0aW5nIHRoZSAiSGFzIFdhaXRl cnMiIGZsYWcKIGZvcmNlcyB0aGUgY3VycmVudCBvd25lciB0byBzeW5jaHJvbml6ZSB3aXRoIHRo aXMgY29kZS4KIAogVGhlIGxvY2sgaXMgdGFrZW4gaWYgdGhlIGZvbGxvd2luZyBhcmUgdHJ1ZToK KwogICAgMSkgVGhlIGxvY2sgaGFzIG5vIG93bmVyCiAgICAyKSBUaGUgY3VycmVudCB0YXNrIGlz IHRoZSBoaWdoZXN0IHByaW9yaXR5IGFnYWluc3QgYWxsIG90aGVyCiAgICAgICB3YWl0ZXJzIG9m IHRoZSBsb2NrCkBAIC01NDYsMTAgKzU1OCwxMyBAQCBDcmVkaXRzCiAtLS0tLS0tCiAKIEF1dGhv cjogIFN0ZXZlbiBSb3N0ZWR0IDxyb3N0ZWR0QGdvb2RtaXMub3JnPgorCiBVcGRhdGVkOiBBbGV4 IFNoaSA8YWxleC5zaGlAbGluYXJvLm9yZz4JLSA3LzYvMjAxNwogCi1PcmlnaW5hbCBSZXZpZXdl cnM6ICBJbmdvIE1vbG5hciwgVGhvbWFzIEdsZWl4bmVyLCBUaG9tYXMgRHVldHNjaCwgYW5kCitP cmlnaW5hbCBSZXZpZXdlcnM6CisJCSAgICAgSW5nbyBNb2xuYXIsIFRob21hcyBHbGVpeG5lciwg VGhvbWFzIER1ZXRzY2gsIGFuZAogCQkgICAgIFJhbmR5IER1bmxhcAorCiBVcGRhdGUgKDcvNi8y MDE3KSBSZXZpZXdlcnM6IFN0ZXZlbiBSb3N0ZWR0IGFuZCBTZWJhc3RpYW4gU2lld2lvcgogCiBV cGRhdGVzCmRpZmYgLS1naXQgYS9Eb2N1bWVudGF0aW9uL2xvY2tpbmcvcnQtbXV0ZXgudHh0IGIv RG9jdW1lbnRhdGlvbi9sb2NraW5nL3J0LW11dGV4LnJzdApzaW1pbGFyaXR5IGluZGV4IDcxJQpy ZW5hbWUgZnJvbSBEb2N1bWVudGF0aW9uL2xvY2tpbmcvcnQtbXV0ZXgudHh0CnJlbmFtZSB0byBE b2N1bWVudGF0aW9uL2xvY2tpbmcvcnQtbXV0ZXgucnN0CmluZGV4IDM1NzkzZTAwMzA0MS4uYzM2 NWRjMzAyMDgxIDEwMDY0NAotLS0gYS9Eb2N1bWVudGF0aW9uL2xvY2tpbmcvcnQtbXV0ZXgudHh0 CisrKyBiL0RvY3VtZW50YXRpb24vbG9ja2luZy9ydC1tdXRleC5yc3QKQEAgLTEsNSArMSw2IEBA Cis9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09CiBSVC1tdXRleCBzdWJzeXN0ZW0g d2l0aCBQSSBzdXBwb3J0Ci0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tCis9PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09CiAKIFJULW11dGV4ZXMgd2l0aCBwcmlvcml0 eSBpbmhlcml0YW5jZSBhcmUgdXNlZCB0byBzdXBwb3J0IFBJLWZ1dGV4ZXMsCiB3aGljaCBlbmFi bGUgcHRocmVhZF9tdXRleF90IHByaW9yaXR5IGluaGVyaXRhbmNlIGF0dHJpYnV0ZXMKQEAgLTQ2 LDI3ICs0NywzMCBAQCBUaGUgc3RhdGUgb2YgdGhlIHJ0LW11dGV4IGlzIHRyYWNrZWQgdmlhIHRo ZSBvd25lciBmaWVsZCBvZiB0aGUgcnQtbXV0ZXgKIHN0cnVjdHVyZToKIAogbG9jay0+b3duZXIg aG9sZHMgdGhlIHRhc2tfc3RydWN0IHBvaW50ZXIgb2YgdGhlIG93bmVyLiBCaXQgMCBpcyB1c2Vk IHRvCi1rZWVwIHRyYWNrIG9mIHRoZSAibG9jayBoYXMgd2FpdGVycyIgc3RhdGUuCitrZWVwIHRy YWNrIG9mIHRoZSAibG9jayBoYXMgd2FpdGVycyIgc3RhdGU6CiAKLSBvd25lciAgICAgICAgYml0 MAorID09PT09PT09PT09PSA9PT09PT09ID09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PQorIG93bmVyICAgICAgICBiaXQwICAgIE5vdGVzCisgPT09PT09PT09 PT09ID09PT09PT0gPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09CiAgTlVMTCAgICAgICAgIDAgICAgICAgbG9jayBpcyBmcmVlIChmYXN0IGFjcXVpcmUgcG9z c2libGUpCiAgTlVMTCAgICAgICAgIDEgICAgICAgbG9jayBpcyBmcmVlIGFuZCBoYXMgd2FpdGVy cyBhbmQgdGhlIHRvcCB3YWl0ZXIKLQkJCWlzIGdvaW5nIHRvIHRha2UgdGhlIGxvY2sqCisJCSAg ICAgIGlzIGdvaW5nIHRvIHRha2UgdGhlIGxvY2sgWzFdXwogIHRhc2twb2ludGVyICAwICAgICAg IGxvY2sgaXMgaGVsZCAoZmFzdCByZWxlYXNlIHBvc3NpYmxlKQotIHRhc2twb2ludGVyICAxICAg ICAgIGxvY2sgaXMgaGVsZCBhbmQgaGFzIHdhaXRlcnMqKgorIHRhc2twb2ludGVyICAxICAgICAg IGxvY2sgaXMgaGVsZCBhbmQgaGFzIHdhaXRlcnMgWzJdXworID09PT09PT09PT09PSA9PT09PT09 ID09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQogCiBUaGUg ZmFzdCBhdG9taWMgY29tcGFyZSBleGNoYW5nZSBiYXNlZCBhY3F1aXJlIGFuZCByZWxlYXNlIGlz IG9ubHkKIHBvc3NpYmxlIHdoZW4gYml0IDAgb2YgbG9jay0+b3duZXIgaXMgMC4KIAotKCopIEl0 IGFsc28gY2FuIGJlIGEgdHJhbnNpdGlvbmFsIHN0YXRlIHdoZW4gZ3JhYmJpbmcgdGhlIGxvY2sK LXdpdGggLT53YWl0X2xvY2sgaXMgaGVsZC4gVG8gcHJldmVudCBhbnkgZmFzdCBwYXRoIGNtcHhj aGcgdG8gdGhlIGxvY2ssCi13ZSBuZWVkIHRvIHNldCB0aGUgYml0MCBiZWZvcmUgbG9va2luZyBh dCB0aGUgbG9jaywgYW5kIHRoZSBvd25lciBtYXkgYmUKLU5VTEwgaW4gdGhpcyBzbWFsbCB0aW1l LCBoZW5jZSB0aGlzIGNhbiBiZSBhIHRyYW5zaXRpb25hbCBzdGF0ZS4KKy4uIFsxXSBJdCBhbHNv IGNhbiBiZSBhIHRyYW5zaXRpb25hbCBzdGF0ZSB3aGVuIGdyYWJiaW5nIHRoZSBsb2NrCisgICAg ICAgd2l0aCAtPndhaXRfbG9jayBpcyBoZWxkLiBUbyBwcmV2ZW50IGFueSBmYXN0IHBhdGggY21w eGNoZyB0byB0aGUgbG9jaywKKyAgICAgICB3ZSBuZWVkIHRvIHNldCB0aGUgYml0MCBiZWZvcmUg bG9va2luZyBhdCB0aGUgbG9jaywgYW5kIHRoZSBvd25lciBtYXkKKyAgICAgICBiZSBOVUxMIGlu IHRoaXMgc21hbGwgdGltZSwgaGVuY2UgdGhpcyBjYW4gYmUgYSB0cmFuc2l0aW9uYWwgc3RhdGUu CiAKLSgqKikgVGhlcmUgaXMgYSBzbWFsbCB0aW1lIHdoZW4gYml0IDAgaXMgc2V0IGJ1dCB0aGVy ZSBhcmUgbm8KLXdhaXRlcnMuIFRoaXMgY2FuIGhhcHBlbiB3aGVuIGdyYWJiaW5nIHRoZSBsb2Nr IGluIHRoZSBzbG93IHBhdGguCi1UbyBwcmV2ZW50IGEgY21weGNoZyBvZiB0aGUgb3duZXIgcmVs ZWFzaW5nIHRoZSBsb2NrLCB3ZSBuZWVkIHRvCi1zZXQgdGhpcyBiaXQgYmVmb3JlIGxvb2tpbmcg YXQgdGhlIGxvY2suCisuLiBbMl0gVGhlcmUgaXMgYSBzbWFsbCB0aW1lIHdoZW4gYml0IDAgaXMg c2V0IGJ1dCB0aGVyZSBhcmUgbm8KKyAgICAgICB3YWl0ZXJzLiBUaGlzIGNhbiBoYXBwZW4gd2hl biBncmFiYmluZyB0aGUgbG9jayBpbiB0aGUgc2xvdyBwYXRoLgorICAgICAgIFRvIHByZXZlbnQg YSBjbXB4Y2hnIG9mIHRoZSBvd25lciByZWxlYXNpbmcgdGhlIGxvY2ssIHdlIG5lZWQgdG8KKyAg ICAgICBzZXQgdGhpcyBiaXQgYmVmb3JlIGxvb2tpbmcgYXQgdGhlIGxvY2suCiAKIEJUVywgdGhl cmUgaXMgc3RpbGwgdGVjaG5pY2FsbHkgYSAiUGVuZGluZyBPd25lciIsIGl0J3MganVzdCBub3Qg Y2FsbGVkCiB0aGF0IGFueW1vcmUuIFRoZSBwZW5kaW5nIG93bmVyIGhhcHBlbnMgdG8gYmUgdGhl IHRvcF93YWl0ZXIgb2YgYSBsb2NrCmRpZmYgLS1naXQgYS9Eb2N1bWVudGF0aW9uL2xvY2tpbmcv c3BpbmxvY2tzLnR4dCBiL0RvY3VtZW50YXRpb24vbG9ja2luZy9zcGlubG9ja3MucnN0CnNpbWls YXJpdHkgaW5kZXggODklCnJlbmFtZSBmcm9tIERvY3VtZW50YXRpb24vbG9ja2luZy9zcGlubG9j a3MudHh0CnJlbmFtZSB0byBEb2N1bWVudGF0aW9uL2xvY2tpbmcvc3BpbmxvY2tzLnJzdAppbmRl eCBmZjM1ZTQwYmRmNWIuLjA5ODEwN2ZiN2Q4NiAxMDA2NDQKLS0tIGEvRG9jdW1lbnRhdGlvbi9s b2NraW5nL3NwaW5sb2Nrcy50eHQKKysrIGIvRG9jdW1lbnRhdGlvbi9sb2NraW5nL3NwaW5sb2Nr cy5yc3QKQEAgLTEsOCArMSwxMyBAQAorPT09PT09PT09PT09PT09CitMb2NraW5nIGxlc3NvbnMK Kz09PT09PT09PT09PT09PQorCiBMZXNzb24gMTogU3BpbiBsb2NrcworPT09PT09PT09PT09PT09 PT09PT0KIAotVGhlIG1vc3QgYmFzaWMgcHJpbWl0aXZlIGZvciBsb2NraW5nIGlzIHNwaW5sb2Nr LgorVGhlIG1vc3QgYmFzaWMgcHJpbWl0aXZlIGZvciBsb2NraW5nIGlzIHNwaW5sb2NrOjoKIAot c3RhdGljIERFRklORV9TUElOTE9DSyh4eHhfbG9jayk7CisgIHN0YXRpYyBERUZJTkVfU1BJTkxP Q0soeHh4X2xvY2spOwogCiAJdW5zaWduZWQgbG9uZyBmbGFnczsKIApAQCAtMTksMjMgKzI0LDI1 IEBAIHdvcnJ5IGFib3V0IFVQIHZzIFNNUCBpc3N1ZXM6IHRoZSBzcGlubG9ja3Mgd29yayBjb3Jy ZWN0bHkgdW5kZXIgYm90aC4KICAgIE5PVEUhIEltcGxpY2F0aW9ucyBvZiBzcGluX2xvY2tzIGZv ciBtZW1vcnkgYXJlIGZ1cnRoZXIgZGVzY3JpYmVkIGluOgogCiAgICAgIERvY3VtZW50YXRpb24v bWVtb3J5LWJhcnJpZXJzLnR4dAorCiAgICAgICAgKDUpIExPQ0sgb3BlcmF0aW9ucy4KKwogICAg ICAgICg2KSBVTkxPQ0sgb3BlcmF0aW9ucy4KIAogVGhlIGFib3ZlIGlzIHVzdWFsbHkgcHJldHR5 IHNpbXBsZSAoeW91IHVzdWFsbHkgbmVlZCBhbmQgd2FudCBvbmx5IG9uZQogc3BpbmxvY2sgZm9y IG1vc3QgdGhpbmdzIC0gdXNpbmcgbW9yZSB0aGFuIG9uZSBzcGlubG9jayBjYW4gbWFrZSB0aGlu Z3MgYQogbG90IG1vcmUgY29tcGxleCBhbmQgZXZlbiBzbG93ZXIgYW5kIGlzIHVzdWFsbHkgd29y dGggaXQgb25seSBmb3IKLXNlcXVlbmNlcyB0aGF0IHlvdSBfa25vd18gbmVlZCB0byBiZSBzcGxp dCB1cDogYXZvaWQgaXQgYXQgYWxsIGNvc3QgaWYgeW91CitzZXF1ZW5jZXMgdGhhdCB5b3UgKipr bm93KiogbmVlZCB0byBiZSBzcGxpdCB1cDogYXZvaWQgaXQgYXQgYWxsIGNvc3QgaWYgeW91CiBh cmVuJ3Qgc3VyZSkuCiAKIFRoaXMgaXMgcmVhbGx5IHRoZSBvbmx5IHJlYWxseSBoYXJkIHBhcnQg YWJvdXQgc3BpbmxvY2tzOiBvbmNlIHlvdSBzdGFydAogdXNpbmcgc3BpbmxvY2tzIHRoZXkgdGVu ZCB0byBleHBhbmQgdG8gYXJlYXMgeW91IG1pZ2h0IG5vdCBoYXZlIG5vdGljZWQKIGJlZm9yZSwg YmVjYXVzZSB5b3UgaGF2ZSB0byBtYWtlIHN1cmUgdGhlIHNwaW5sb2NrcyBjb3JyZWN0bHkgcHJv dGVjdCB0aGUKLXNoYXJlZCBkYXRhIHN0cnVjdHVyZXMgX2V2ZXJ5d2hlcmVfIHRoZXkgYXJlIHVz ZWQuIFRoZSBzcGlubG9ja3MgYXJlIG1vc3QKK3NoYXJlZCBkYXRhIHN0cnVjdHVyZXMgKipldmVy eXdoZXJlKiogdGhleSBhcmUgdXNlZC4gVGhlIHNwaW5sb2NrcyBhcmUgbW9zdAogZWFzaWx5IGFk ZGVkIHRvIHBsYWNlcyB0aGF0IGFyZSBjb21wbGV0ZWx5IGluZGVwZW5kZW50IG9mIG90aGVyIGNv ZGUgKGZvcgogZXhhbXBsZSwgaW50ZXJuYWwgZHJpdmVyIGRhdGEgc3RydWN0dXJlcyB0aGF0IG5v Ym9keSBlbHNlIGV2ZXIgdG91Y2hlcykuCiAKLSAgIE5PVEUhIFRoZSBzcGluLWxvY2sgaXMgc2Fm ZSBvbmx5IHdoZW4geW91IF9hbHNvXyB1c2UgdGhlIGxvY2sgaXRzZWxmCisgICBOT1RFISBUaGUg c3Bpbi1sb2NrIGlzIHNhZmUgb25seSB3aGVuIHlvdSAqKmFsc28qKiB1c2UgdGhlIGxvY2sgaXRz ZWxmCiAgICB0byBkbyBsb2NraW5nIGFjcm9zcyBDUFUncywgd2hpY2ggaW1wbGllcyB0aGF0IEVW RVJZVEhJTkcgdGhhdAogICAgdG91Y2hlcyBhIHNoYXJlZCB2YXJpYWJsZSBoYXMgdG8gYWdyZWUg YWJvdXQgdGhlIHNwaW5sb2NrIHRoZXkgd2FudAogICAgdG8gdXNlLgpAQCAtNDMsNiArNTAsNyBA QCBleGFtcGxlLCBpbnRlcm5hbCBkcml2ZXIgZGF0YSBzdHJ1Y3R1cmVzIHRoYXQgbm9ib2R5IGVs c2UgZXZlciB0b3VjaGVzKS4KIC0tLS0KIAogTGVzc29uIDI6IHJlYWRlci13cml0ZXIgc3Bpbmxv Y2tzLgorPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQogCiBJZiB5b3VyIGRhdGEg YWNjZXNzZXMgaGF2ZSBhIHZlcnkgbmF0dXJhbCBwYXR0ZXJuIHdoZXJlIHlvdSB1c3VhbGx5IHRl bmQKIHRvIG1vc3RseSByZWFkIGZyb20gdGhlIHNoYXJlZCB2YXJpYWJsZXMsIHRoZSByZWFkZXIt d3JpdGVyIGxvY2tzCkBAIC01NCw3ICs2Miw3IEBAIHRvIGNoYW5nZSB0aGUgdmFyaWFibGVzIGl0 IGhhcyB0byBnZXQgYW4gZXhjbHVzaXZlIHdyaXRlIGxvY2suCiAgICBzaW1wbGUgc3BpbmxvY2tz LiAgVW5sZXNzIHRoZSByZWFkZXIgY3JpdGljYWwgc2VjdGlvbiBpcyBsb25nLCB5b3UKICAgIGFy ZSBiZXR0ZXIgb2ZmIGp1c3QgdXNpbmcgc3BpbmxvY2tzLgogCi1UaGUgcm91dGluZXMgbG9vayB0 aGUgc2FtZSBhcyBhYm92ZToKK1RoZSByb3V0aW5lcyBsb29rIHRoZSBzYW1lIGFzIGFib3ZlOjoK IAogICAgcndsb2NrX3QgeHh4X2xvY2sgPSBfX1JXX0xPQ0tfVU5MT0NLRUQoeHh4X2xvY2spOwog CkBAIC03MSw3ICs3OSw3IEBAIFRoZSByb3V0aW5lcyBsb29rIHRoZSBzYW1lIGFzIGFib3ZlOgog VGhlIGFib3ZlIGtpbmQgb2YgbG9jayBtYXkgYmUgdXNlZnVsIGZvciBjb21wbGV4IGRhdGEgc3Ry dWN0dXJlcyBsaWtlCiBsaW5rZWQgbGlzdHMsIGVzcGVjaWFsbHkgc2VhcmNoaW5nIGZvciBlbnRy aWVzIHdpdGhvdXQgY2hhbmdpbmcgdGhlIGxpc3QKIGl0c2VsZi4gIFRoZSByZWFkIGxvY2sgYWxs b3dzIG1hbnkgY29uY3VycmVudCByZWFkZXJzLiAgQW55dGhpbmcgdGhhdAotX2NoYW5nZXNfIHRo ZSBsaXN0IHdpbGwgaGF2ZSB0byBnZXQgdGhlIHdyaXRlIGxvY2suCisqKmNoYW5nZXMqKiB0aGUg bGlzdCB3aWxsIGhhdmUgdG8gZ2V0IHRoZSB3cml0ZSBsb2NrLgogCiAgICBOT1RFISBSQ1UgaXMg YmV0dGVyIGZvciBsaXN0IHRyYXZlcnNhbCwgYnV0IHJlcXVpcmVzIGNhcmVmdWwKICAgIGF0dGVu dGlvbiB0byBkZXNpZ24gZGV0YWlsIChzZWUgRG9jdW1lbnRhdGlvbi9SQ1UvbGlzdFJDVS50eHQp LgpAQCAtODcsMTAgKzk1LDExIEBAIHRvIGdldCB0aGUgd3JpdGUtbG9jayBhdCB0aGUgdmVyeSBi ZWdpbm5pbmcuCiAtLS0tCiAKIExlc3NvbiAzOiBzcGlubG9ja3MgcmV2aXNpdGVkLgorPT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09CiAKIFRoZSBzaW5nbGUgc3Bpbi1sb2NrIHByaW1pdGl2 ZXMgYWJvdmUgYXJlIGJ5IG5vIG1lYW5zIHRoZSBvbmx5IG9uZXMuIFRoZXkKIGFyZSB0aGUgbW9z dCBzYWZlIG9uZXMsIGFuZCB0aGUgb25lcyB0aGF0IHdvcmsgdW5kZXIgYWxsIGNpcmN1bXN0YW5j ZXMsCi1idXQgcGFydGx5IF9iZWNhdXNlXyB0aGV5IGFyZSBzYWZlIHRoZXkgYXJlIGFsc28gZmFp cmx5IHNsb3cuIFRoZXkgYXJlIHNsb3dlcgorYnV0IHBhcnRseSAqKmJlY2F1c2UqKiB0aGV5IGFy ZSBzYWZlIHRoZXkgYXJlIGFsc28gZmFpcmx5IHNsb3cuIFRoZXkgYXJlIHNsb3dlcgogdGhhbiB0 aGV5J2QgbmVlZCB0byBiZSwgYmVjYXVzZSB0aGV5IGRvIGhhdmUgdG8gZGlzYWJsZSBpbnRlcnJ1 cHRzCiAod2hpY2ggaXMganVzdCBhIHNpbmdsZSBpbnN0cnVjdGlvbiBvbiBhIHg4NiwgYnV0IGl0 J3MgYW4gZXhwZW5zaXZlIG9uZSAtCiBhbmQgb24gb3RoZXIgYXJjaGl0ZWN0dXJlcyBpdCBjYW4g YmUgd29yc2UpLgpAQCAtOTgsNyArMTA3LDcgQEAgYW5kIG9uIG90aGVyIGFyY2hpdGVjdHVyZXMg aXQgY2FuIGJlIHdvcnNlKS4KIElmIHlvdSBoYXZlIGEgY2FzZSB3aGVyZSB5b3UgaGF2ZSB0byBw cm90ZWN0IGEgZGF0YSBzdHJ1Y3R1cmUgYWNyb3NzCiBzZXZlcmFsIENQVSdzIGFuZCB5b3Ugd2Fu dCB0byB1c2Ugc3BpbmxvY2tzIHlvdSBjYW4gcG90ZW50aWFsbHkgdXNlCiBjaGVhcGVyIHZlcnNp b25zIG9mIHRoZSBzcGlubG9ja3MuIElGRiB5b3Uga25vdyB0aGF0IHRoZSBzcGlubG9ja3MgYXJl Ci1uZXZlciB1c2VkIGluIGludGVycnVwdCBoYW5kbGVycywgeW91IGNhbiB1c2UgdGhlIG5vbi1p cnEgdmVyc2lvbnM6CituZXZlciB1c2VkIGluIGludGVycnVwdCBoYW5kbGVycywgeW91IGNhbiB1 c2UgdGhlIG5vbi1pcnEgdmVyc2lvbnM6OgogCiAJc3Bpbl9sb2NrKCZsb2NrKTsKIAkuLi4KQEAg LTExMCw3ICsxMTksNyBAQCBUaGlzIGlzIHVzZWZ1bCBpZiB5b3Uga25vdyB0aGF0IHRoZSBkYXRh IGluIHF1ZXN0aW9uIGlzIG9ubHkgZXZlcgogbWFuaXB1bGF0ZWQgZnJvbSBhICJwcm9jZXNzIGNv bnRleHQiLCBpZSBubyBpbnRlcnJ1cHRzIGludm9sdmVkLgogCiBUaGUgcmVhc29ucyB5b3UgbXVz dG4ndCB1c2UgdGhlc2UgdmVyc2lvbnMgaWYgeW91IGhhdmUgaW50ZXJydXB0cyB0aGF0Ci1wbGF5 IHdpdGggdGhlIHNwaW5sb2NrIGlzIHRoYXQgeW91IGNhbiBnZXQgZGVhZGxvY2tzOgorcGxheSB3 aXRoIHRoZSBzcGlubG9jayBpcyB0aGF0IHlvdSBjYW4gZ2V0IGRlYWRsb2Nrczo6CiAKIAlzcGlu X2xvY2soJmxvY2spOwogCS4uLgpAQCAtMTQ3LDkgKzE1NiwxMCBAQCBpbmRlZWQpLCB3aGlsZSB3 cml0ZS1sb2NrcyBuZWVkIHRvIHByb3RlY3QgdGhlbXNlbHZlcyBhZ2FpbnN0IGludGVycnVwdHMu CiAtLS0tCiAKIFJlZmVyZW5jZSBpbmZvcm1hdGlvbjoKKz09PT09PT09PT09PT09PT09PT09PT0K IAogRm9yIGR5bmFtaWMgaW5pdGlhbGl6YXRpb24sIHVzZSBzcGluX2xvY2tfaW5pdCgpIG9yIHJ3 bG9ja19pbml0KCkgYXMKLWFwcHJvcHJpYXRlOgorYXBwcm9wcmlhdGU6OgogCiAgICBzcGlubG9j a190IHh4eF9sb2NrOwogICAgcndsb2NrX3QgeHh4X3J3X2xvY2s7CmRpZmYgLS1naXQgYS9Eb2N1 bWVudGF0aW9uL2xvY2tpbmcvd3ctbXV0ZXgtZGVzaWduLnR4dCBiL0RvY3VtZW50YXRpb24vbG9j a2luZy93dy1tdXRleC1kZXNpZ24ucnN0CnNpbWlsYXJpdHkgaW5kZXggOTMlCnJlbmFtZSBmcm9t IERvY3VtZW50YXRpb24vbG9ja2luZy93dy1tdXRleC1kZXNpZ24udHh0CnJlbmFtZSB0byBEb2N1 bWVudGF0aW9uL2xvY2tpbmcvd3ctbXV0ZXgtZGVzaWduLnJzdAppbmRleCBmMGVkN2MzMGU2OTUu LjE4NDZjMTk5ZGEyMyAxMDA2NDQKLS0tIGEvRG9jdW1lbnRhdGlvbi9sb2NraW5nL3d3LW11dGV4 LWRlc2lnbi50eHQKKysrIGIvRG9jdW1lbnRhdGlvbi9sb2NraW5nL3d3LW11dGV4LWRlc2lnbi5y c3QKQEAgLTEsMyArMSw0IEBACis9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PQogV291bmQvV2FpdCBEZWFkbG9jay1Qcm9vZiBNdXRleCBEZXNpZ24KID09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09CiAKQEAgLTg1LDYgKzg2LDcgQEAgRnVydGhlcm1vcmUg dGhlcmUgYXJlIHRocmVlIGRpZmZlcmVudCBjbGFzcyBvZiB3L3cgbG9jayBhY3F1aXJlIGZ1bmN0 aW9uczoKICAgbm8gZGVhZGxvY2sgcG90ZW50aWFsIGFuZCBoZW5jZSB0aGUgd3dfbXV0ZXhfbG9j ayBjYWxsIHdpbGwgYmxvY2sgYW5kIG5vdAogICBwcmVtYXR1cmVseSByZXR1cm4gLUVERUFETEsu IFRoZSBhZHZhbnRhZ2Ugb2YgdGhlIF9zbG93IGZ1bmN0aW9ucyBpcyBpbgogICBpbnRlcmZhY2Ug c2FmZXR5OgorCiAgIC0gd3dfbXV0ZXhfbG9jayBoYXMgYSBfX211c3RfY2hlY2sgaW50IHJldHVy biB0eXBlLCB3aGVyZWFzIHd3X211dGV4X2xvY2tfc2xvdwogICAgIGhhcyBhIHZvaWQgcmV0dXJu IHR5cGUuIE5vdGUgdGhhdCBzaW5jZSB3dyBtdXRleCBjb2RlIG5lZWRzIGxvb3BzL3JldHJpZXMK ICAgICBhbnl3YXkgdGhlIF9fbXVzdF9jaGVjayBkb2Vzbid0IHJlc3VsdCBpbiBzcHVyaW91cyB3 YXJuaW5ncywgZXZlbiB0aG91Z2ggdGhlCkBAIC0xMTUsMzYgKzExNywzNiBAQCBleHBlY3QgdGhl IG51bWJlciBvZiBzaW11bHRhbmVvdXMgY29tcGV0aW5nIHRyYW5zYWN0aW9ucyB0byBiZSB0eXBp Y2FsbHkgc21hbGwsCiBhbmQgeW91IHdhbnQgdG8gcmVkdWNlIHRoZSBudW1iZXIgb2Ygcm9sbGJh Y2tzLgogCiBUaHJlZSBkaWZmZXJlbnQgd2F5cyB0byBhY3F1aXJlIGxvY2tzIHdpdGhpbiB0aGUg c2FtZSB3L3cgY2xhc3MuIENvbW1vbgotZGVmaW5pdGlvbnMgZm9yIG1ldGhvZHMgIzEgYW5kICMy OgorZGVmaW5pdGlvbnMgZm9yIG1ldGhvZHMgIzEgYW5kICMyOjoKIAotc3RhdGljIERFRklORV9X V19DTEFTUyh3d19jbGFzcyk7CisgIHN0YXRpYyBERUZJTkVfV1dfQ0xBU1Mod3dfY2xhc3MpOwog Ci1zdHJ1Y3Qgb2JqIHsKKyAgc3RydWN0IG9iaiB7CiAJc3RydWN0IHd3X211dGV4IGxvY2s7CiAJ Lyogb2JqIGRhdGEgKi8KLX07CisgIH07CiAKLXN0cnVjdCBvYmpfZW50cnkgeworICBzdHJ1Y3Qg b2JqX2VudHJ5IHsKIAlzdHJ1Y3QgbGlzdF9oZWFkIGhlYWQ7CiAJc3RydWN0IG9iaiAqb2JqOwot fTsKKyAgfTsKIAogTWV0aG9kIDEsIHVzaW5nIGEgbGlzdCBpbiBleGVjYnVmLT5idWZmZXJzIHRo YXQncyBub3QgYWxsb3dlZCB0byBiZSByZW9yZGVyZWQuCiBUaGlzIGlzIHVzZWZ1bCBpZiBhIGxp c3Qgb2YgcmVxdWlyZWQgb2JqZWN0cyBpcyBhbHJlYWR5IHRyYWNrZWQgc29tZXdoZXJlLgogRnVy dGhlcm1vcmUgdGhlIGxvY2sgaGVscGVyIGNhbiB1c2UgcHJvcGFnYXRlIHRoZSAtRUFMUkVBRFkg cmV0dXJuIGNvZGUgYmFjayB0bwogdGhlIGNhbGxlciBhcyBhIHNpZ25hbCB0aGF0IGFuIG9iamVj dCBpcyB0d2ljZSBvbiB0aGUgbGlzdC4gVGhpcyBpcyB1c2VmdWwgaWYKIHRoZSBsaXN0IGlzIGNv bnN0cnVjdGVkIGZyb20gdXNlcnNwYWNlIGlucHV0IGFuZCB0aGUgQUJJIHJlcXVpcmVzIHVzZXJz cGFjZSB0bwotbm90IGhhdmUgZHVwbGljYXRlIGVudHJpZXMgKGUuZy4gZm9yIGEgZ3B1IGNvbW1h bmRidWZmZXIgc3VibWlzc2lvbiBpb2N0bCkuCitub3QgaGF2ZSBkdXBsaWNhdGUgZW50cmllcyAo ZS5nLiBmb3IgYSBncHUgY29tbWFuZGJ1ZmZlciBzdWJtaXNzaW9uIGlvY3RsKTo6CiAKLWludCBs b2NrX29ianMoc3RydWN0IGxpc3RfaGVhZCAqbGlzdCwgc3RydWN0IHd3X2FjcXVpcmVfY3R4ICpj dHgpCi17CisgIGludCBsb2NrX29ianMoc3RydWN0IGxpc3RfaGVhZCAqbGlzdCwgc3RydWN0IHd3 X2FjcXVpcmVfY3R4ICpjdHgpCisgIHsKIAlzdHJ1Y3Qgb2JqICpyZXNfb2JqID0gTlVMTDsKIAlz dHJ1Y3Qgb2JqX2VudHJ5ICpjb250ZW5kZWRfZW50cnkgPSBOVUxMOwogCXN0cnVjdCBvYmpfZW50 cnkgKmVudHJ5OwogCiAJd3dfYWNxdWlyZV9pbml0KGN0eCwgJnd3X2NsYXNzKTsKIAotcmV0cnk6 CisgIHJldHJ5OgogCWxpc3RfZm9yX2VhY2hfZW50cnkgKGVudHJ5LCBsaXN0LCBoZWFkKSB7CiAJ CWlmIChlbnRyeS0+b2JqID09IHJlc19vYmopIHsKIAkJCXJlc19vYmogPSBOVUxMOwpAQCAtMTYw LDcgKzE2Miw3IEBAIHJldHJ5OgogCXd3X2FjcXVpcmVfZG9uZShjdHgpOwogCXJldHVybiAwOwog Ci1lcnI6CisgIGVycjoKIAlsaXN0X2Zvcl9lYWNoX2VudHJ5X2NvbnRpbnVlX3JldmVyc2UgKGVu dHJ5LCBsaXN0LCBoZWFkKQogCQl3d19tdXRleF91bmxvY2soJmVudHJ5LT5vYmotPmxvY2spOwog CkBAIC0xNzYsMTQgKzE3OCwxNCBAQCBlcnI6CiAJd3dfYWNxdWlyZV9maW5pKGN0eCk7CiAKIAly ZXR1cm4gcmV0OwotfQorICB9CiAKIE1ldGhvZCAyLCB1c2luZyBhIGxpc3QgaW4gZXhlY2J1Zi0+ YnVmZmVycyB0aGF0IGNhbiBiZSByZW9yZGVyZWQuIFNhbWUgc2VtYW50aWNzCiBvZiBkdXBsaWNh dGUgZW50cnkgZGV0ZWN0aW9uIHVzaW5nIC1FQUxSRUFEWSBhcyBtZXRob2QgMSBhYm92ZS4gQnV0 IHRoZQotbGlzdC1yZW9yZGVyaW5nIGFsbG93cyBmb3IgYSBiaXQgbW9yZSBpZGlvbWF0aWMgY29k ZS4KK2xpc3QtcmVvcmRlcmluZyBhbGxvd3MgZm9yIGEgYml0IG1vcmUgaWRpb21hdGljIGNvZGU6 OgogCi1pbnQgbG9ja19vYmpzKHN0cnVjdCBsaXN0X2hlYWQgKmxpc3QsIHN0cnVjdCB3d19hY3F1 aXJlX2N0eCAqY3R4KQoteworICBpbnQgbG9ja19vYmpzKHN0cnVjdCBsaXN0X2hlYWQgKmxpc3Qs IHN0cnVjdCB3d19hY3F1aXJlX2N0eCAqY3R4KQorICB7CiAJc3RydWN0IG9ial9lbnRyeSAqZW50 cnksICplbnRyeTI7CiAKIAl3d19hY3F1aXJlX2luaXQoY3R4LCAmd3dfY2xhc3MpOwpAQCAtMjE2 LDI0ICsyMTgsMjUgQEAgaW50IGxvY2tfb2JqcyhzdHJ1Y3QgbGlzdF9oZWFkICpsaXN0LCBzdHJ1 Y3Qgd3dfYWNxdWlyZV9jdHggKmN0eCkKIAogCXd3X2FjcXVpcmVfZG9uZShjdHgpOwogCXJldHVy biAwOwotfQorICB9CiAKLVVubG9ja2luZyB3b3JrcyB0aGUgc2FtZSB3YXkgZm9yIGJvdGggbWV0 aG9kcyAjMSBhbmQgIzI6CitVbmxvY2tpbmcgd29ya3MgdGhlIHNhbWUgd2F5IGZvciBib3RoIG1l dGhvZHMgIzEgYW5kICMyOjoKIAotdm9pZCB1bmxvY2tfb2JqcyhzdHJ1Y3QgbGlzdF9oZWFkICps aXN0LCBzdHJ1Y3Qgd3dfYWNxdWlyZV9jdHggKmN0eCkKLXsKKyAgdm9pZCB1bmxvY2tfb2Jqcyhz dHJ1Y3QgbGlzdF9oZWFkICpsaXN0LCBzdHJ1Y3Qgd3dfYWNxdWlyZV9jdHggKmN0eCkKKyAgewog CXN0cnVjdCBvYmpfZW50cnkgKmVudHJ5OwogCiAJbGlzdF9mb3JfZWFjaF9lbnRyeSAoZW50cnks IGxpc3QsIGhlYWQpCiAJCXd3X211dGV4X3VubG9jaygmZW50cnktPm9iai0+bG9jayk7CiAKIAl3 d19hY3F1aXJlX2ZpbmkoY3R4KTsKLX0KKyAgfQogCiBNZXRob2QgMyBpcyB1c2VmdWwgaWYgdGhl IGxpc3Qgb2Ygb2JqZWN0cyBpcyBjb25zdHJ1Y3RlZCBhZC1ob2MgYW5kIG5vdCB1cGZyb250LAog ZS5nLiB3aGVuIGFkanVzdGluZyBlZGdlcyBpbiBhIGdyYXBoIHdoZXJlIGVhY2ggbm9kZSBoYXMg aXRzIG93biB3d19tdXRleCBsb2NrLAogYW5kIGVkZ2VzIGNhbiBvbmx5IGJlIGNoYW5nZWQgd2hl biBob2xkaW5nIHRoZSBsb2NrcyBvZiBhbGwgaW52b2x2ZWQgbm9kZXMuIHcvdwogbXV0ZXhlcyBh cmUgYSBuYXR1cmFsIGZpdCBmb3Igc3VjaCBhIGNhc2UgZm9yIHR3byByZWFzb25zOgorCiAtIFRo ZXkgY2FuIGhhbmRsZSBsb2NrLWFjcXVpc2l0aW9uIGluIGFueSBvcmRlciB3aGljaCBhbGxvd3Mg dXMgdG8gc3RhcnQgd2Fsa2luZwogICBhIGdyYXBoIGZyb20gYSBzdGFydGluZyBwb2ludCBhbmQg dGhlbiBpdGVyYXRpdmVseSBkaXNjb3ZlcmluZyBuZXcgZWRnZXMgYW5kCiAgIGxvY2tpbmcgZG93 biB0aGUgbm9kZXMgdGhvc2UgZWRnZXMgY29ubmVjdCB0by4KQEAgLTI0Myw2ICsyNDYsNyBAQCBt dXRleGVzIGFyZSBhIG5hdHVyYWwgZml0IGZvciBzdWNoIGEgY2FzZSBmb3IgdHdvIHJlYXNvbnM6 CiAgIGFzIGEgc3RhcnRpbmcgcG9pbnQpLgogCiBOb3RlIHRoYXQgdGhpcyBhcHByb2FjaCBkaWZm ZXJzIGluIHR3byBpbXBvcnRhbnQgd2F5cyBmcm9tIHRoZSBhYm92ZSBtZXRob2RzOgorCiAtIFNp bmNlIHRoZSBsaXN0IG9mIG9iamVjdHMgaXMgZHluYW1pY2FsbHkgY29uc3RydWN0ZWQgKGFuZCBt aWdodCB2ZXJ5IHdlbGwgYmUKICAgZGlmZmVyZW50IHdoZW4gcmV0cnlpbmcgZHVlIHRvIGhpdHRp bmcgdGhlIC1FREVBRExLIGRpZSBjb25kaXRpb24pIHRoZXJlJ3MKICAgbm8gbmVlZCB0byBrZWVw IGFueSBvYmplY3Qgb24gYSBwZXJzaXN0ZW50IGxpc3Qgd2hlbiBpdCdzIG5vdCBsb2NrZWQuIFdl IGNhbgpAQCAtMjYwLDE3ICsyNjQsMTcgQEAgYW55IGludGVyZmFjZSBtaXN1c2UgZm9yIHRoZXNl IGNhc2VzLgogCiBBbHNvLCBtZXRob2QgMyBjYW4ndCBmYWlsIHRoZSBsb2NrIGFjcXVpc2l0aW9u IHN0ZXAgc2luY2UgaXQgZG9lc24ndCByZXR1cm4KIC1FQUxSRUFEWS4gT2YgY291cnNlIHRoaXMg d291bGQgYmUgZGlmZmVyZW50IHdoZW4gdXNpbmcgdGhlIF9pbnRlcnJ1cHRpYmxlCi12YXJpYW50 cywgYnV0IHRoYXQncyBvdXRzaWRlIG9mIHRoZSBzY29wZSBvZiB0aGVzZSBleGFtcGxlcyBoZXJl LgordmFyaWFudHMsIGJ1dCB0aGF0J3Mgb3V0c2lkZSBvZiB0aGUgc2NvcGUgb2YgdGhlc2UgZXhh bXBsZXMgaGVyZTo6CiAKLXN0cnVjdCBvYmogeworICBzdHJ1Y3Qgb2JqIHsKIAlzdHJ1Y3Qgd3df bXV0ZXggd3dfbXV0ZXg7CiAJc3RydWN0IGxpc3RfaGVhZCBsb2NrZWRfbGlzdDsKLX07CisgIH07 CiAKLXN0YXRpYyBERUZJTkVfV1dfQ0xBU1Mod3dfY2xhc3MpOworICBzdGF0aWMgREVGSU5FX1dX X0NMQVNTKHd3X2NsYXNzKTsKIAotdm9pZCBfX3VubG9ja19vYmpzKHN0cnVjdCBsaXN0X2hlYWQg Kmxpc3QpCi17CisgIHZvaWQgX191bmxvY2tfb2JqcyhzdHJ1Y3QgbGlzdF9oZWFkICpsaXN0KQor ICB7CiAJc3RydWN0IG9iaiAqZW50cnksICp0ZW1wOwogCiAJbGlzdF9mb3JfZWFjaF9lbnRyeV9z YWZlIChlbnRyeSwgdGVtcCwgbGlzdCwgbG9ja2VkX2xpc3QpIHsKQEAgLTI3OSwxNSArMjgzLDE1 IEBAIHZvaWQgX191bmxvY2tfb2JqcyhzdHJ1Y3QgbGlzdF9oZWFkICpsaXN0KQogCQlsaXN0X2Rl bCgmZW50cnktPmxvY2tlZF9saXN0KTsKIAkJd3dfbXV0ZXhfdW5sb2NrKGVudHJ5LT53d19tdXRl eCkKIAl9Ci19CisgIH0KIAotdm9pZCBsb2NrX29ianMoc3RydWN0IGxpc3RfaGVhZCAqbGlzdCwg c3RydWN0IHd3X2FjcXVpcmVfY3R4ICpjdHgpCi17CisgIHZvaWQgbG9ja19vYmpzKHN0cnVjdCBs aXN0X2hlYWQgKmxpc3QsIHN0cnVjdCB3d19hY3F1aXJlX2N0eCAqY3R4KQorICB7CiAJc3RydWN0 IG9iaiAqb2JqOwogCiAJd3dfYWNxdWlyZV9pbml0KGN0eCwgJnd3X2NsYXNzKTsKIAotcmV0cnk6 CisgIHJldHJ5OgogCS8qIHJlLWluaXQgbG9vcCBzdGFydCBzdGF0ZSAqLwogCWxvb3AgewogCQkv KiBtYWdpYyBjb2RlIHdoaWNoIHdhbGtzIG92ZXIgYSBncmFwaCBhbmQgZGVjaWRlcyB3aGljaCBv YmplY3RzCkBAIC0zMTIsMTMgKzMxNiwxMyBAQCByZXRyeToKIAogCXd3X2FjcXVpcmVfZG9uZShj dHgpOwogCXJldHVybiAwOwotfQorICB9CiAKLXZvaWQgdW5sb2NrX29ianMoc3RydWN0IGxpc3Rf aGVhZCAqbGlzdCwgc3RydWN0IHd3X2FjcXVpcmVfY3R4ICpjdHgpCi17CisgIHZvaWQgdW5sb2Nr X29ianMoc3RydWN0IGxpc3RfaGVhZCAqbGlzdCwgc3RydWN0IHd3X2FjcXVpcmVfY3R4ICpjdHgp CisgIHsKIAlfX3VubG9ja19vYmpzKGxpc3QpOwogCXd3X2FjcXVpcmVfZmluaShjdHgpOwotfQor ICB9CiAKIE1ldGhvZCA0OiBPbmx5IGxvY2sgb25lIHNpbmdsZSBvYmplY3RzLiBJbiB0aGF0IGNh c2UgZGVhZGxvY2sgZGV0ZWN0aW9uIGFuZAogcHJldmVudGlvbiBpcyBvYnZpb3VzbHkgb3Zlcmtp bGwsIHNpbmNlIHdpdGggZ3JhYmJpbmcganVzdCBvbmUgbG9jayB5b3UgY2FuJ3QKQEAgLTMyOSwx MSArMzMzLDE0IEBAIEltcGxlbWVudGF0aW9uIERldGFpbHMKIC0tLS0tLS0tLS0tLS0tLS0tLS0t LS0KIAogRGVzaWduOgorXl5eXl5eXgorCiAgIHd3X211dGV4IGN1cnJlbnRseSBlbmNhcHN1bGF0 ZXMgYSBzdHJ1Y3QgbXV0ZXgsIHRoaXMgbWVhbnMgbm8gZXh0cmEgb3ZlcmhlYWQgZm9yCiAgIG5v cm1hbCBtdXRleCBsb2Nrcywgd2hpY2ggYXJlIGZhciBtb3JlIGNvbW1vbi4gQXMgc3VjaCB0aGVy ZSBpcyBvbmx5IGEgc21hbGwKICAgaW5jcmVhc2UgaW4gY29kZSBzaXplIGlmIHdhaXQvd291bmQg bXV0ZXhlcyBhcmUgbm90IHVzZWQuCiAKICAgV2UgbWFpbnRhaW4gdGhlIGZvbGxvd2luZyBpbnZh cmlhbnRzIGZvciB0aGUgd2FpdCBsaXN0OgorCiAgICgxKSBXYWl0ZXJzIHdpdGggYW4gYWNxdWly ZSBjb250ZXh0IGFyZSBzb3J0ZWQgYnkgc3RhbXAgb3JkZXI7IHdhaXRlcnMKICAgICAgIHdpdGhv dXQgYW4gYWNxdWlyZSBjb250ZXh0IGFyZSBpbnRlcnNwZXJzZWQgaW4gRklGTyBvcmRlci4KICAg KDIpIEZvciBXYWl0LURpZSwgYW1vbmcgd2FpdGVycyB3aXRoIGNvbnRleHRzLCBvbmx5IHRoZSBm aXJzdCBvbmUgY2FuIGhhdmUKQEAgLTM1NSw2ICszNjIsOCBAQCBEZXNpZ246CiAgIHRoZXJlZm9y ZSBiZSBkaXJlY3RlZCB0b3dhcmRzIHRoZSB1bmNvbnRlbmRlZCBjYXNlcy4KIAogTG9ja2RlcDoK K15eXl5eXl5eCisKICAgU3BlY2lhbCBjYXJlIGhhcyBiZWVuIHRha2VuIHRvIHdhcm4gZm9yIGFz IG1hbnkgY2FzZXMgb2YgYXBpIGFidXNlCiAgIGFzIHBvc3NpYmxlLiBTb21lIGNvbW1vbiBhcGkg YWJ1c2VzIHdpbGwgYmUgY2F1Z2h0IHdpdGgKICAgQ09ORklHX0RFQlVHX01VVEVYRVMsIGJ1dCBD T05GSUdfUFJPVkVfTE9DS0lORyBpcyByZWNvbW1lbmRlZC4KQEAgLTM3OSw1ICszODgsNiBAQCBM b2NrZGVwOgogICAgICBoYXZpbmcgY2FsbGVkIHd3X2FjcXVpcmVfZmluaSBvbiB0aGUgZmlyc3Qu CiAgICAtICdub3JtYWwnIGRlYWRsb2NrcyB0aGF0IGNhbiBvY2N1ci4KIAotRklYTUU6IFVwZGF0 ZSB0aGlzIHNlY3Rpb24gb25jZSB3ZSBoYXZlIHRoZSBUQVNLX0RFQURMT0NLIHRhc2sgc3RhdGUg ZmxhZyBtYWdpYwotaW1wbGVtZW50ZWQuCitGSVhNRToKKyAgVXBkYXRlIHRoaXMgc2VjdGlvbiBv bmNlIHdlIGhhdmUgdGhlIFRBU0tfREVBRExPQ0sgdGFzayBzdGF0ZSBmbGFnIG1hZ2ljCisgIGlt cGxlbWVudGVkLgpkaWZmIC0tZ2l0IGEvRG9jdW1lbnRhdGlvbi9waS1mdXRleC50eHQgYi9Eb2N1 bWVudGF0aW9uL3BpLWZ1dGV4LnR4dAppbmRleCBiMTU0ZjZjMGMzNmUuLmMzM2JhMmJlZmJmOCAx MDA2NDQKLS0tIGEvRG9jdW1lbnRhdGlvbi9waS1mdXRleC50eHQKKysrIGIvRG9jdW1lbnRhdGlv bi9waS1mdXRleC50eHQKQEAgLTExOSw0ICsxMTksNCBAQCBwcm9wZXJ0aWVzIG9mIGZ1dGV4ZXMs IGFuZCBhbGwgZm91ciBjb21iaW5hdGlvbnMgYXJlIHBvc3NpYmxlOiBmdXRleCwKIHJvYnVzdC1m dXRleCwgUEktZnV0ZXgsIHJvYnVzdCtQSS1mdXRleC4KIAogTW9yZSBkZXRhaWxzIGFib3V0IHBy aW9yaXR5IGluaGVyaXRhbmNlIGNhbiBiZSBmb3VuZCBpbgotRG9jdW1lbnRhdGlvbi9sb2NraW5n L3J0LW11dGV4LnR4dC4KK0RvY3VtZW50YXRpb24vbG9ja2luZy9ydC1tdXRleC5yc3QuCmRpZmYg LS1naXQgYS9Eb2N1bWVudGF0aW9uL3RyYW5zbGF0aW9ucy9pdF9JVC9rZXJuZWwtaGFja2luZy9s b2NraW5nLnJzdCBiL0RvY3VtZW50YXRpb24vdHJhbnNsYXRpb25zL2l0X0lUL2tlcm5lbC1oYWNr aW5nL2xvY2tpbmcucnN0CmluZGV4IDBlZjMxNjY2NjYzYi4uNzVkOWI4NmZjYzUwIDEwMDY0NAot LS0gYS9Eb2N1bWVudGF0aW9uL3RyYW5zbGF0aW9ucy9pdF9JVC9rZXJuZWwtaGFja2luZy9sb2Nr aW5nLnJzdAorKysgYi9Eb2N1bWVudGF0aW9uL3RyYW5zbGF0aW9ucy9pdF9JVC9rZXJuZWwtaGFj a2luZy9sb2NraW5nLnJzdApAQCAtMTQwNCw3ICsxNDA0LDcgQEAgUmlmZXJpbWVudG8gcGVyIGwn QVBJIGRlaSBGdXRleAogQXBwcm9mb25kaW1lbnRpCiA9PT09PT09PT09PT09PT0KIAotLSAgYGBE b2N1bWVudGF0aW9uL2xvY2tpbmcvc3BpbmxvY2tzLnR4dGBgOiBsYSBndWlkYSBkaSBMaW51cyBU b3J2YWxkcyBhZ2xpCistICBgYERvY3VtZW50YXRpb24vbG9ja2luZy9zcGlubG9ja3MucnN0YGA6 IGxhIGd1aWRhIGRpIExpbnVzIFRvcnZhbGRzIGFnbGkKICAgIHNwaW5sb2NrIGRlbCBrZXJuZWwu CiAKIC0gIFVuaXggU3lzdGVtcyBmb3IgTW9kZXJuIEFyY2hpdGVjdHVyZXM6IFN5bW1ldHJpYyBN dWx0aXByb2Nlc3NpbmcgYW5kCmRpZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9kcm0vZHJtX21vZGVz ZXRfbG9jay5jIGIvZHJpdmVycy9ncHUvZHJtL2RybV9tb2Rlc2V0X2xvY2suYwppbmRleCA4MWRk MTE5MDFmZmQuLmNiNTY3MWQzMmFkYSAxMDA2NDQKLS0tIGEvZHJpdmVycy9ncHUvZHJtL2RybV9t b2Rlc2V0X2xvY2suYworKysgYi9kcml2ZXJzL2dwdS9kcm0vZHJtX21vZGVzZXRfbG9jay5jCkBA IC0zNiw3ICszNiw3IEBACiAgKiBvZiBleHRyYSB1dGlsaXR5L3RyYWNraW5nIG91dCBvZiBvdXIg YWNxdWlyZS1jdHguICBUaGlzIGlzIHByb3ZpZGVkCiAgKiBieSAmc3RydWN0IGRybV9tb2Rlc2V0 X2xvY2sgYW5kICZzdHJ1Y3QgZHJtX21vZGVzZXRfYWNxdWlyZV9jdHguCiAgKgotICogRm9yIGJh c2ljIHByaW5jaXBsZXMgb2YgJnd3X211dGV4LCBzZWU6IERvY3VtZW50YXRpb24vbG9ja2luZy93 dy1tdXRleC1kZXNpZ24udHh0CisgKiBGb3IgYmFzaWMgcHJpbmNpcGxlcyBvZiAmd3dfbXV0ZXgs IHNlZTogRG9jdW1lbnRhdGlvbi9sb2NraW5nL3d3LW11dGV4LWRlc2lnbi5yc3QKICAqCiAgKiBU aGUgYmFzaWMgdXNhZ2UgcGF0dGVybiBpcyB0bzo6CiAgKgpkaWZmIC0tZ2l0IGEvaW5jbHVkZS9s aW51eC9sb2NrZGVwLmggYi9pbmNsdWRlL2xpbnV4L2xvY2tkZXAuaAppbmRleCA3OWMzODczZDU4 YWMuLjRjNjI5NmFhZWVmYiAxMDA2NDQKLS0tIGEvaW5jbHVkZS9saW51eC9sb2NrZGVwLmgKKysr IGIvaW5jbHVkZS9saW51eC9sb2NrZGVwLmgKQEAgLTUsNyArNSw3IEBACiAgKiAgQ29weXJpZ2h0 IChDKSAyMDA2LDIwMDcgUmVkIEhhdCwgSW5jLiwgSW5nbyBNb2xuYXIgPG1pbmdvQHJlZGhhdC5j b20+CiAgKiAgQ29weXJpZ2h0IChDKSAyMDA3IFJlZCBIYXQsIEluYy4sIFBldGVyIFppamxzdHJh CiAgKgotICogc2VlIERvY3VtZW50YXRpb24vbG9ja2luZy9sb2NrZGVwLWRlc2lnbi50eHQgZm9y IG1vcmUgZGV0YWlscy4KKyAqIHNlZSBEb2N1bWVudGF0aW9uL2xvY2tpbmcvbG9ja2RlcC1kZXNp Z24ucnN0IGZvciBtb3JlIGRldGFpbHMuCiAgKi8KICNpZm5kZWYgX19MSU5VWF9MT0NLREVQX0gK ICNkZWZpbmUgX19MSU5VWF9MT0NLREVQX0gKZGlmZiAtLWdpdCBhL2luY2x1ZGUvbGludXgvbXV0 ZXguaCBiL2luY2x1ZGUvbGludXgvbXV0ZXguaAppbmRleCAzMDkzZGQxNjI0MjQuLmRjZDAzZmVl NmUwMSAxMDA2NDQKLS0tIGEvaW5jbHVkZS9saW51eC9tdXRleC5oCisrKyBiL2luY2x1ZGUvbGlu dXgvbXV0ZXguaApAQCAtMTUxLDcgKzE1MSw3IEBAIHN0YXRpYyBpbmxpbmUgYm9vbCBtdXRleF9p c19sb2NrZWQoc3RydWN0IG11dGV4ICpsb2NrKQogCiAvKgogICogU2VlIGtlcm5lbC9sb2NraW5n L211dGV4LmMgZm9yIGRldGFpbGVkIGRvY3VtZW50YXRpb24gb2YgdGhlc2UgQVBJcy4KLSAqIEFs c28gc2VlIERvY3VtZW50YXRpb24vbG9ja2luZy9tdXRleC1kZXNpZ24udHh0LgorICogQWxzbyBz ZWUgRG9jdW1lbnRhdGlvbi9sb2NraW5nL211dGV4LWRlc2lnbi5yc3QuCiAgKi8KICNpZmRlZiBD T05GSUdfREVCVUdfTE9DS19BTExPQwogZXh0ZXJuIHZvaWQgbXV0ZXhfbG9ja19uZXN0ZWQoc3Ry dWN0IG11dGV4ICpsb2NrLCB1bnNpZ25lZCBpbnQgc3ViY2xhc3MpOwpkaWZmIC0tZ2l0IGEvaW5j bHVkZS9saW51eC9yd3NlbS5oIGIvaW5jbHVkZS9saW51eC9yd3NlbS5oCmluZGV4IDJlYTE4YTNk ZWYwNC4uNjFhMDg0YWUxN2FjIDEwMDY0NAotLS0gYS9pbmNsdWRlL2xpbnV4L3J3c2VtLmgKKysr IGIvaW5jbHVkZS9saW51eC9yd3NlbS5oCkBAIC0xNTgsNyArMTU4LDcgQEAgZXh0ZXJuIHZvaWQg ZG93bmdyYWRlX3dyaXRlKHN0cnVjdCByd19zZW1hcGhvcmUgKnNlbSk7CiAgKiBzdGF0aWMgdGhl biBhbm90aGVyIG1ldGhvZCBmb3IgZXhwcmVzc2luZyBuZXN0ZWQgbG9ja2luZyBpcwogICogdGhl IGV4cGxpY2l0IGRlZmluaXRpb24gb2YgbG9jayBjbGFzcyBrZXlzIGFuZCB0aGUgdXNlIG9mCiAg KiBsb2NrZGVwX3NldF9jbGFzcygpIGF0IGxvY2sgaW5pdGlhbGl6YXRpb24gdGltZS4KLSAqIFNl ZSBEb2N1bWVudGF0aW9uL2xvY2tpbmcvbG9ja2RlcC1kZXNpZ24udHh0IGZvciBtb3JlIGRldGFp bHMuKQorICogU2VlIERvY3VtZW50YXRpb24vbG9ja2luZy9sb2NrZGVwLWRlc2lnbi5yc3QgZm9y IG1vcmUgZGV0YWlscy4pCiAgKi8KIGV4dGVybiB2b2lkIGRvd25fcmVhZF9uZXN0ZWQoc3RydWN0 IHJ3X3NlbWFwaG9yZSAqc2VtLCBpbnQgc3ViY2xhc3MpOwogZXh0ZXJuIHZvaWQgZG93bl93cml0 ZV9uZXN0ZWQoc3RydWN0IHJ3X3NlbWFwaG9yZSAqc2VtLCBpbnQgc3ViY2xhc3MpOwpkaWZmIC0t Z2l0IGEva2VybmVsL2xvY2tpbmcvbXV0ZXguYyBiL2tlcm5lbC9sb2NraW5nL211dGV4LmMKaW5k ZXggZGI1Nzg3ODNkZDM2Li41ZWMyMGIzY2RiZTUgMTAwNjQ0Ci0tLSBhL2tlcm5lbC9sb2NraW5n L211dGV4LmMKKysrIGIva2VybmVsL2xvY2tpbmcvbXV0ZXguYwpAQCAtMTUsNyArMTUsNyBAQAog ICogICAgYnkgU3RldmVuIFJvc3RlZHQsIGJhc2VkIG9uIHdvcmsgYnkgR3JlZ29yeSBIYXNraW5z LCBQZXRlciBNb3JyZWFsZQogICogICAgYW5kIFN2ZW4gRGlldHJpY2guCiAgKgotICogQWxzbyBz ZWUgRG9jdW1lbnRhdGlvbi9sb2NraW5nL211dGV4LWRlc2lnbi50eHQuCisgKiBBbHNvIHNlZSBE b2N1bWVudGF0aW9uL2xvY2tpbmcvbXV0ZXgtZGVzaWduLnJzdC4KICAqLwogI2luY2x1ZGUgPGxp bnV4L211dGV4Lmg+CiAjaW5jbHVkZSA8bGludXgvd3dfbXV0ZXguaD4KZGlmZiAtLWdpdCBhL2tl cm5lbC9sb2NraW5nL3J0bXV0ZXguYyBiL2tlcm5lbC9sb2NraW5nL3J0bXV0ZXguYwppbmRleCA5 NzhkNjNhODI2MWMuLjg2MzBiYjk5ZWVjNyAxMDA2NDQKLS0tIGEva2VybmVsL2xvY2tpbmcvcnRt dXRleC5jCisrKyBiL2tlcm5lbC9sb2NraW5nL3J0bXV0ZXguYwpAQCAtOCw3ICs4LDcgQEAKICAq ICBDb3B5cmlnaHQgKEMpIDIwMDUgS2lob24gVGVjaG5vbG9naWVzIEluYy4sIFN0ZXZlbiBSb3N0 ZWR0CiAgKiAgQ29weXJpZ2h0IChDKSAyMDA2IEVzYmVuIE5pZWxzZW4KICAqCi0gKiAgU2VlIERv Y3VtZW50YXRpb24vbG9ja2luZy9ydC1tdXRleC1kZXNpZ24udHh0IGZvciBkZXRhaWxzLgorICog IFNlZSBEb2N1bWVudGF0aW9uL2xvY2tpbmcvcnQtbXV0ZXgtZGVzaWduLnJzdCBmb3IgZGV0YWls cy4KICAqLwogI2luY2x1ZGUgPGxpbnV4L3NwaW5sb2NrLmg+CiAjaW5jbHVkZSA8bGludXgvZXhw b3J0Lmg+CmRpZmYgLS1naXQgYS9saWIvS2NvbmZpZy5kZWJ1ZyBiL2xpYi9LY29uZmlnLmRlYnVn CmluZGV4IDFiMDEyOTE5NmU3MC4uYWEwNWY0N2Y1NzYyIDEwMDY0NAotLS0gYS9saWIvS2NvbmZp Zy5kZWJ1ZworKysgYi9saWIvS2NvbmZpZy5kZWJ1ZwpAQCAtMTExMiw3ICsxMTEyLDcgQEAgY29u ZmlnIFBST1ZFX0xPQ0tJTkcKIAkgdGhlIHByb29mIG9mIG9ic2VydmVkIGNvcnJlY3RuZXNzIGlz IGFsc28gbWFpbnRhaW5lZCBmb3IgYW4KIAkgYXJiaXRyYXJ5IGNvbWJpbmF0aW9uIG9mIHRoZXNl IHNlcGFyYXRlIGxvY2tpbmcgdmFyaWFudHMuCiAKLQkgRm9yIG1vcmUgZGV0YWlscywgc2VlIERv Y3VtZW50YXRpb24vbG9ja2luZy9sb2NrZGVwLWRlc2lnbi50eHQuCisJIEZvciBtb3JlIGRldGFp bHMsIHNlZSBEb2N1bWVudGF0aW9uL2xvY2tpbmcvbG9ja2RlcC1kZXNpZ24ucnN0LgogCiBjb25m aWcgTE9DS19TVEFUCiAJYm9vbCAiTG9jayB1c2FnZSBzdGF0aXN0aWNzIgpAQCAtMTEyNiw3ICsx MTI2LDcgQEAgY29uZmlnIExPQ0tfU1RBVAogCWhlbHAKIAkgVGhpcyBmZWF0dXJlIGVuYWJsZXMg dHJhY2tpbmcgbG9jayBjb250ZW50aW9uIHBvaW50cwogCi0JIEZvciBtb3JlIGRldGFpbHMsIHNl ZSBEb2N1bWVudGF0aW9uL2xvY2tpbmcvbG9ja3N0YXQudHh0CisJIEZvciBtb3JlIGRldGFpbHMs IHNlZSBEb2N1bWVudGF0aW9uL2xvY2tpbmcvbG9ja3N0YXQucnN0CiAKIAkgVGhpcyBhbHNvIGVu YWJsZXMgbG9jayBldmVudHMgcmVxdWlyZWQgYnkgInBlcmYgbG9jayIsCiAJIHN1YmNvbW1hbmQg b2YgcGVyZi4KLS0gCjIuMjAuMQoKX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fX18KZHJpLWRldmVsIG1haWxpbmcgbGlzdApkcmktZGV2ZWxAbGlzdHMuZnJlZWRl c2t0b3Aub3JnCmh0dHBzOi8vbGlzdHMuZnJlZWRlc2t0b3Aub3JnL21haWxtYW4vbGlzdGluZm8v ZHJpLWRldmVs